1/* 2 * Author Andreas Eversberg (jolly@eversberg.eu) 3 * Based on source code structure by 4 * Karsten Keil (keil@isdn4linux.de) 5 * 6 * This file is (c) under GNU PUBLIC LICENSE 7 * For changes and modifications please read 8 * ../../../Documentation/isdn/mISDN.cert 9 * 10 * Thanks to Karsten Keil (great drivers) 11 * Cologne Chip (great chips) 12 * 13 * This module does: 14 * Real-time tone generation 15 * DTMF detection 16 * Real-time cross-connection and conferrence 17 * Compensate jitter due to system load and hardware fault. 18 * All features are done in kernel space and will be realized 19 * using hardware, if available and supported by chip set. 20 * Blowfish encryption/decryption 21 */ 22 23/* STRUCTURE: 24 * 25 * The dsp module provides layer 2 for b-channels (64kbit). It provides 26 * transparent audio forwarding with special digital signal processing: 27 * 28 * - (1) generation of tones 29 * - (2) detection of dtmf tones 30 * - (3) crossconnecting and conferences (clocking) 31 * - (4) echo generation for delay test 32 * - (5) volume control 33 * - (6) disable receive data 34 * - (7) pipeline 35 * - (8) encryption/decryption 36 * 37 * Look: 38 * TX RX 39 * ------upper layer------ 40 * | ^ 41 * | |(6) 42 * v | 43 * +-----+-------------+-----+ 44 * |(3)(4) | 45 * | CMX | 46 * | | 47 * | +-------------+ 48 * | | ^ 49 * | | | 50 * |+---------+| +----+----+ 51 * ||(1) || |(2) | 52 * || || | | 53 * || Tones || | DTMF | 54 * || || | | 55 * || || | | 56 * |+----+----+| +----+----+ 57 * +-----+-----+ ^ 58 * | | 59 * v | 60 * +----+----+ +----+----+ 61 * |(5) | |(5) | 62 * | | | | 63 * |TX Volume| |RX Volume| 64 * | | | | 65 * | | | | 66 * +----+----+ +----+----+ 67 * | ^ 68 * | | 69 * v | 70 * +----+-------------+----+ 71 * |(7) | 72 * | | 73 * | Pipeline Processing | 74 * | | 75 * | | 76 * +----+-------------+----+ 77 * | ^ 78 * | | 79 * v | 80 * +----+----+ +----+----+ 81 * |(8) | |(8) | 82 * | | | | 83 * | Encrypt | | Decrypt | 84 * | | | | 85 * | | | | 86 * +----+----+ +----+----+ 87 * | ^ 88 * | | 89 * v | 90 * ------card layer------ 91 * TX RX 92 * 93 * Above you can see the logical data flow. If software is used to do the 94 * process, it is actually the real data flow. If hardware is used, data 95 * may not flow, but hardware commands to the card, to provide the data flow 96 * as shown. 97 * 98 * NOTE: The channel must be activated in order to make dsp work, even if 99 * no data flow to the upper layer is intended. Activation can be done 100 * after and before controlling the setting using PH_CONTROL requests. 101 * 102 * DTMF: Will be detected by hardware if possible. It is done before CMX 103 * processing. 104 * 105 * Tones: Will be generated via software if endless looped audio fifos are 106 * not supported by hardware. Tones will override all data from CMX. 107 * It is not required to join a conference to use tones at any time. 108 * 109 * CMX: Is transparent when not used. When it is used, it will do 110 * crossconnections and conferences via software if not possible through 111 * hardware. If hardware capability is available, hardware is used. 112 * 113 * Echo: Is generated by CMX and is used to check performance of hard and 114 * software CMX. 115 * 116 * The CMX has special functions for conferences with one, two and more 117 * members. It will allow different types of data flow. Receive and transmit 118 * data to/form upper layer may be swithed on/off individually without losing 119 * features of CMX, Tones and DTMF. 120 * 121 * Echo Cancellation: Sometimes we like to cancel echo from the interface. 122 * Note that a VoIP call may not have echo caused by the IP phone. The echo 123 * is generated by the telephone line connected to it. Because the delay 124 * is high, it becomes an echo. RESULT: Echo Cachelation is required if 125 * both echo AND delay is applied to an interface. 126 * Remember that software CMX always generates a more or less delay. 127 * 128 * If all used features can be realized in hardware, and if transmit and/or 129 * receive data ist disabled, the card may not send/receive any data at all. 130 * Not receiving is useful if only announcements are played. Not sending is 131 * useful if an answering machine records audio. Not sending and receiving is 132 * useful during most states of the call. If supported by hardware, tones 133 * will be played without cpu load. Small PBXs and NT-Mode applications will 134 * not need expensive hardware when processing calls. 135 * 136 * 137 * LOCKING: 138 * 139 * When data is received from upper or lower layer (card), the complete dsp 140 * module is locked by a global lock. This lock MUST lock irq, because it 141 * must lock timer events by DSP poll timer. 142 * When data is ready to be transmitted down, the data is queued and sent 143 * outside lock and timer event. 144 * PH_CONTROL must not change any settings, join or split conference members 145 * during process of data. 146 * 147 * HDLC: 148 * 149 * It works quite the same as transparent, except that HDLC data is forwarded 150 * to all other conference members if no hardware bridging is possible. 151 * Send data will be writte to sendq. Sendq will be sent if confirm is received. 152 * Conference cannot join, if one member is not hdlc. 153 * 154 */ 155 156#include <linux/delay.h> 157#include <linux/gfp.h> 158#include <linux/mISDNif.h> 159#include <linux/mISDNdsp.h> 160#include <linux/module.h> 161#include <linux/vmalloc.h> 162#include "core.h" 163#include "dsp.h" 164 165static const char *mISDN_dsp_revision = "2.0"; 166 167static int debug; 168static int options; 169static int poll; 170static int dtmfthreshold = 100; 171 172MODULE_AUTHOR("Andreas Eversberg"); 173module_param(debug, uint, S_IRUGO | S_IWUSR); 174module_param(options, uint, S_IRUGO | S_IWUSR); 175module_param(poll, uint, S_IRUGO | S_IWUSR); 176module_param(dtmfthreshold, uint, S_IRUGO | S_IWUSR); 177MODULE_LICENSE("GPL"); 178 179/*int spinnest = 0;*/ 180 181spinlock_t dsp_lock; /* global dsp lock */ 182struct list_head dsp_ilist; 183struct list_head conf_ilist; 184int dsp_debug; 185int dsp_options; 186int dsp_poll, dsp_tics; 187 188/* check if rx may be turned off or must be turned on */ 189static void 190dsp_rx_off_member(struct dsp *dsp) 191{ 192 struct mISDN_ctrl_req cq; 193 int rx_off = 1; 194 195 memset(&cq, 0, sizeof(cq)); 196 197 if (!dsp->features_rx_off) 198 return; 199 200 /* not disabled */ 201 if (!dsp->rx_disabled) 202 rx_off = 0; 203 /* software dtmf */ 204 else if (dsp->dtmf.software) 205 rx_off = 0; 206 /* echo in software */ 207 else if (dsp->echo.software) 208 rx_off = 0; 209 /* bridge in software */ 210 else if (dsp->conf && dsp->conf->software) 211 rx_off = 0; 212 /* data is not required by user space and not required 213 * for echo dtmf detection, soft-echo, soft-bridging */ 214 215 if (rx_off == dsp->rx_is_off) 216 return; 217 218 if (!dsp->ch.peer) { 219 if (dsp_debug & DEBUG_DSP_CORE) 220 printk(KERN_DEBUG "%s: no peer, no rx_off\n", 221 __func__); 222 return; 223 } 224 cq.op = MISDN_CTRL_RX_OFF; 225 cq.p1 = rx_off; 226 if (dsp->ch.peer->ctrl(dsp->ch.peer, CONTROL_CHANNEL, &cq)) { 227 printk(KERN_DEBUG "%s: 2nd CONTROL_CHANNEL failed\n", 228 __func__); 229 return; 230 } 231 dsp->rx_is_off = rx_off; 232 if (dsp_debug & DEBUG_DSP_CORE) 233 printk(KERN_DEBUG "%s: %s set rx_off = %d\n", 234 __func__, dsp->name, rx_off); 235} 236static void 237dsp_rx_off(struct dsp *dsp) 238{ 239 struct dsp_conf_member *member; 240 241 if (dsp_options & DSP_OPT_NOHARDWARE) 242 return; 243 244 /* no conf */ 245 if (!dsp->conf) { 246 dsp_rx_off_member(dsp); 247 return; 248 } 249 /* check all members in conf */ 250 list_for_each_entry(member, &dsp->conf->mlist, list) { 251 dsp_rx_off_member(member->dsp); 252 } 253} 254 255/* enable "fill empty" feature */ 256static void 257dsp_fill_empty(struct dsp *dsp) 258{ 259 struct mISDN_ctrl_req cq; 260 261 memset(&cq, 0, sizeof(cq)); 262 263 if (!dsp->ch.peer) { 264 if (dsp_debug & DEBUG_DSP_CORE) 265 printk(KERN_DEBUG "%s: no peer, no fill_empty\n", 266 __func__); 267 return; 268 } 269 cq.op = MISDN_CTRL_FILL_EMPTY; 270 cq.p1 = 1; 271 if (dsp->ch.peer->ctrl(dsp->ch.peer, CONTROL_CHANNEL, &cq)) { 272 printk(KERN_DEBUG "%s: CONTROL_CHANNEL failed\n", 273 __func__); 274 return; 275 } 276 if (dsp_debug & DEBUG_DSP_CORE) 277 printk(KERN_DEBUG "%s: %s set fill_empty = 1\n", 278 __func__, dsp->name); 279} 280 281static int 282dsp_control_req(struct dsp *dsp, struct mISDNhead *hh, struct sk_buff *skb) 283{ 284 struct sk_buff *nskb; 285 int ret = 0; 286 int cont; 287 u8 *data; 288 int len; 289 290 if (skb->len < sizeof(int)) 291 printk(KERN_ERR "%s: PH_CONTROL message too short\n", __func__); 292 cont = *((int *)skb->data); 293 len = skb->len - sizeof(int); 294 data = skb->data + sizeof(int); 295 296 switch (cont) { 297 case DTMF_TONE_START: /* turn on DTMF */ 298 if (dsp->hdlc) { 299 ret = -EINVAL; 300 break; 301 } 302 if (dsp_debug & DEBUG_DSP_CORE) 303 printk(KERN_DEBUG "%s: start dtmf\n", __func__); 304 if (len == sizeof(int)) { 305 if (dsp_debug & DEBUG_DSP_CORE) 306 printk(KERN_NOTICE "changing DTMF Threshold " 307 "to %d\n", *((int *)data)); 308 dsp->dtmf.treshold = (*(int *)data) * 10000; 309 } 310 dsp->dtmf.enable = 1; 311 /* init goertzel */ 312 dsp_dtmf_goertzel_init(dsp); 313 314 /* check dtmf hardware */ 315 dsp_dtmf_hardware(dsp); 316 dsp_rx_off(dsp); 317 break; 318 case DTMF_TONE_STOP: /* turn off DTMF */ 319 if (dsp_debug & DEBUG_DSP_CORE) 320 printk(KERN_DEBUG "%s: stop dtmf\n", __func__); 321 dsp->dtmf.enable = 0; 322 dsp->dtmf.hardware = 0; 323 dsp->dtmf.software = 0; 324 break; 325 case DSP_CONF_JOIN: /* join / update conference */ 326 if (len < sizeof(int)) { 327 ret = -EINVAL; 328 break; 329 } 330 if (*((u32 *)data) == 0) 331 goto conf_split; 332 if (dsp_debug & DEBUG_DSP_CORE) 333 printk(KERN_DEBUG "%s: join conference %d\n", 334 __func__, *((u32 *)data)); 335 ret = dsp_cmx_conf(dsp, *((u32 *)data)); 336 /* dsp_cmx_hardware will also be called here */ 337 dsp_rx_off(dsp); 338 if (dsp_debug & DEBUG_DSP_CMX) 339 dsp_cmx_debug(dsp); 340 break; 341 case DSP_CONF_SPLIT: /* remove from conference */ 342 conf_split: 343 if (dsp_debug & DEBUG_DSP_CORE) 344 printk(KERN_DEBUG "%s: release conference\n", __func__); 345 ret = dsp_cmx_conf(dsp, 0); 346 /* dsp_cmx_hardware will also be called here */ 347 if (dsp_debug & DEBUG_DSP_CMX) 348 dsp_cmx_debug(dsp); 349 dsp_rx_off(dsp); 350 break; 351 case DSP_TONE_PATT_ON: /* play tone */ 352 if (dsp->hdlc) { 353 ret = -EINVAL; 354 break; 355 } 356 if (len < sizeof(int)) { 357 ret = -EINVAL; 358 break; 359 } 360 if (dsp_debug & DEBUG_DSP_CORE) 361 printk(KERN_DEBUG "%s: turn tone 0x%x on\n", 362 __func__, *((int *)skb->data)); 363 ret = dsp_tone(dsp, *((int *)data)); 364 if (!ret) { 365 dsp_cmx_hardware(dsp->conf, dsp); 366 dsp_rx_off(dsp); 367 } 368 if (!dsp->tone.tone) 369 goto tone_off; 370 break; 371 case DSP_TONE_PATT_OFF: /* stop tone */ 372 if (dsp->hdlc) { 373 ret = -EINVAL; 374 break; 375 } 376 if (dsp_debug & DEBUG_DSP_CORE) 377 printk(KERN_DEBUG "%s: turn tone off\n", __func__); 378 dsp_tone(dsp, 0); 379 dsp_cmx_hardware(dsp->conf, dsp); 380 dsp_rx_off(dsp); 381 /* reset tx buffers (user space data) */ 382 tone_off: 383 dsp->rx_W = 0; 384 dsp->rx_R = 0; 385 break; 386 case DSP_VOL_CHANGE_TX: /* change volume */ 387 if (dsp->hdlc) { 388 ret = -EINVAL; 389 break; 390 } 391 if (len < sizeof(int)) { 392 ret = -EINVAL; 393 break; 394 } 395 dsp->tx_volume = *((int *)data); 396 if (dsp_debug & DEBUG_DSP_CORE) 397 printk(KERN_DEBUG "%s: change tx vol to %d\n", 398 __func__, dsp->tx_volume); 399 dsp_cmx_hardware(dsp->conf, dsp); 400 dsp_dtmf_hardware(dsp); 401 dsp_rx_off(dsp); 402 break; 403 case DSP_VOL_CHANGE_RX: /* change volume */ 404 if (dsp->hdlc) { 405 ret = -EINVAL; 406 break; 407 } 408 if (len < sizeof(int)) { 409 ret = -EINVAL; 410 break; 411 } 412 dsp->rx_volume = *((int *)data); 413 if (dsp_debug & DEBUG_DSP_CORE) 414 printk(KERN_DEBUG "%s: change rx vol to %d\n", 415 __func__, dsp->tx_volume); 416 dsp_cmx_hardware(dsp->conf, dsp); 417 dsp_dtmf_hardware(dsp); 418 dsp_rx_off(dsp); 419 break; 420 case DSP_ECHO_ON: /* enable echo */ 421 dsp->echo.software = 1; /* soft echo */ 422 if (dsp_debug & DEBUG_DSP_CORE) 423 printk(KERN_DEBUG "%s: enable cmx-echo\n", __func__); 424 dsp_cmx_hardware(dsp->conf, dsp); 425 dsp_rx_off(dsp); 426 if (dsp_debug & DEBUG_DSP_CMX) 427 dsp_cmx_debug(dsp); 428 break; 429 case DSP_ECHO_OFF: /* disable echo */ 430 dsp->echo.software = 0; 431 dsp->echo.hardware = 0; 432 if (dsp_debug & DEBUG_DSP_CORE) 433 printk(KERN_DEBUG "%s: disable cmx-echo\n", __func__); 434 dsp_cmx_hardware(dsp->conf, dsp); 435 dsp_rx_off(dsp); 436 if (dsp_debug & DEBUG_DSP_CMX) 437 dsp_cmx_debug(dsp); 438 break; 439 case DSP_RECEIVE_ON: /* enable receive to user space */ 440 if (dsp_debug & DEBUG_DSP_CORE) 441 printk(KERN_DEBUG "%s: enable receive to user " 442 "space\n", __func__); 443 dsp->rx_disabled = 0; 444 dsp_rx_off(dsp); 445 break; 446 case DSP_RECEIVE_OFF: /* disable receive to user space */ 447 if (dsp_debug & DEBUG_DSP_CORE) 448 printk(KERN_DEBUG "%s: disable receive to " 449 "user space\n", __func__); 450 dsp->rx_disabled = 1; 451 dsp_rx_off(dsp); 452 break; 453 case DSP_MIX_ON: /* enable mixing of tx data */ 454 if (dsp->hdlc) { 455 ret = -EINVAL; 456 break; 457 } 458 if (dsp_debug & DEBUG_DSP_CORE) 459 printk(KERN_DEBUG "%s: enable mixing of " 460 "tx-data with conf mebers\n", __func__); 461 dsp->tx_mix = 1; 462 dsp_cmx_hardware(dsp->conf, dsp); 463 dsp_rx_off(dsp); 464 if (dsp_debug & DEBUG_DSP_CMX) 465 dsp_cmx_debug(dsp); 466 break; 467 case DSP_MIX_OFF: /* disable mixing of tx data */ 468 if (dsp->hdlc) { 469 ret = -EINVAL; 470 break; 471 } 472 if (dsp_debug & DEBUG_DSP_CORE) 473 printk(KERN_DEBUG "%s: disable mixing of " 474 "tx-data with conf mebers\n", __func__); 475 dsp->tx_mix = 0; 476 dsp_cmx_hardware(dsp->conf, dsp); 477 dsp_rx_off(dsp); 478 if (dsp_debug & DEBUG_DSP_CMX) 479 dsp_cmx_debug(dsp); 480 break; 481 case DSP_TXDATA_ON: /* enable txdata */ 482 dsp->tx_data = 1; 483 if (dsp_debug & DEBUG_DSP_CORE) 484 printk(KERN_DEBUG "%s: enable tx-data\n", __func__); 485 dsp_cmx_hardware(dsp->conf, dsp); 486 dsp_rx_off(dsp); 487 if (dsp_debug & DEBUG_DSP_CMX) 488 dsp_cmx_debug(dsp); 489 break; 490 case DSP_TXDATA_OFF: /* disable txdata */ 491 dsp->tx_data = 0; 492 if (dsp_debug & DEBUG_DSP_CORE) 493 printk(KERN_DEBUG "%s: disable tx-data\n", __func__); 494 dsp_cmx_hardware(dsp->conf, dsp); 495 dsp_rx_off(dsp); 496 if (dsp_debug & DEBUG_DSP_CMX) 497 dsp_cmx_debug(dsp); 498 break; 499 case DSP_DELAY: /* use delay algorithm instead of dynamic 500 jitter algorithm */ 501 if (dsp->hdlc) { 502 ret = -EINVAL; 503 break; 504 } 505 if (len < sizeof(int)) { 506 ret = -EINVAL; 507 break; 508 } 509 dsp->cmx_delay = (*((int *)data)) << 3; 510 /* milliseconds to samples */ 511 if (dsp->cmx_delay >= (CMX_BUFF_HALF >> 1)) 512 /* clip to half of maximum usable buffer 513 (half of half buffer) */ 514 dsp->cmx_delay = (CMX_BUFF_HALF >> 1) - 1; 515 if (dsp_debug & DEBUG_DSP_CORE) 516 printk(KERN_DEBUG "%s: use delay algorithm to " 517 "compensate jitter (%d samples)\n", 518 __func__, dsp->cmx_delay); 519 break; 520 case DSP_JITTER: /* use dynamic jitter algorithm instead of 521 delay algorithm */ 522 if (dsp->hdlc) { 523 ret = -EINVAL; 524 break; 525 } 526 dsp->cmx_delay = 0; 527 if (dsp_debug & DEBUG_DSP_CORE) 528 printk(KERN_DEBUG "%s: use jitter algorithm to " 529 "compensate jitter\n", __func__); 530 break; 531 case DSP_TX_DEJITTER: /* use dynamic jitter algorithm for tx-buffer */ 532 if (dsp->hdlc) { 533 ret = -EINVAL; 534 break; 535 } 536 dsp->tx_dejitter = 1; 537 if (dsp_debug & DEBUG_DSP_CORE) 538 printk(KERN_DEBUG "%s: use dejitter on TX " 539 "buffer\n", __func__); 540 break; 541 case DSP_TX_DEJ_OFF: /* use tx-buffer without dejittering*/ 542 if (dsp->hdlc) { 543 ret = -EINVAL; 544 break; 545 } 546 dsp->tx_dejitter = 0; 547 if (dsp_debug & DEBUG_DSP_CORE) 548 printk(KERN_DEBUG "%s: use TX buffer without " 549 "dejittering\n", __func__); 550 break; 551 case DSP_PIPELINE_CFG: 552 if (dsp->hdlc) { 553 ret = -EINVAL; 554 break; 555 } 556 if (len > 0 && ((char *)data)[len - 1]) { 557 printk(KERN_DEBUG "%s: pipeline config string " 558 "is not NULL terminated!\n", __func__); 559 ret = -EINVAL; 560 } else { 561 dsp->pipeline.inuse = 1; 562 dsp_cmx_hardware(dsp->conf, dsp); 563 ret = dsp_pipeline_build(&dsp->pipeline, 564 len > 0 ? data : NULL); 565 dsp_cmx_hardware(dsp->conf, dsp); 566 dsp_rx_off(dsp); 567 } 568 break; 569 case DSP_BF_ENABLE_KEY: /* turn blowfish on */ 570 if (dsp->hdlc) { 571 ret = -EINVAL; 572 break; 573 } 574 if (len < 4 || len > 56) { 575 ret = -EINVAL; 576 break; 577 } 578 if (dsp_debug & DEBUG_DSP_CORE) 579 printk(KERN_DEBUG "%s: turn blowfish on (key " 580 "not shown)\n", __func__); 581 ret = dsp_bf_init(dsp, (u8 *)data, len); 582 /* set new cont */ 583 if (!ret) 584 cont = DSP_BF_ACCEPT; 585 else 586 cont = DSP_BF_REJECT; 587 /* send indication if it worked to set it */ 588 nskb = _alloc_mISDN_skb(PH_CONTROL_IND, MISDN_ID_ANY, 589 sizeof(int), &cont, GFP_ATOMIC); 590 if (nskb) { 591 if (dsp->up) { 592 if (dsp->up->send(dsp->up, nskb)) 593 dev_kfree_skb(nskb); 594 } else 595 dev_kfree_skb(nskb); 596 } 597 if (!ret) { 598 dsp_cmx_hardware(dsp->conf, dsp); 599 dsp_dtmf_hardware(dsp); 600 dsp_rx_off(dsp); 601 } 602 break; 603 case DSP_BF_DISABLE: /* turn blowfish off */ 604 if (dsp->hdlc) { 605 ret = -EINVAL; 606 break; 607 } 608 if (dsp_debug & DEBUG_DSP_CORE) 609 printk(KERN_DEBUG "%s: turn blowfish off\n", __func__); 610 dsp_bf_cleanup(dsp); 611 dsp_cmx_hardware(dsp->conf, dsp); 612 dsp_dtmf_hardware(dsp); 613 dsp_rx_off(dsp); 614 break; 615 default: 616 if (dsp_debug & DEBUG_DSP_CORE) 617 printk(KERN_DEBUG "%s: ctrl req %x unhandled\n", 618 __func__, cont); 619 ret = -EINVAL; 620 } 621 return ret; 622} 623 624static void 625get_features(struct mISDNchannel *ch) 626{ 627 struct dsp *dsp = container_of(ch, struct dsp, ch); 628 struct mISDN_ctrl_req cq; 629 630 if (!ch->peer) { 631 if (dsp_debug & DEBUG_DSP_CORE) 632 printk(KERN_DEBUG "%s: no peer, no features\n", 633 __func__); 634 return; 635 } 636 memset(&cq, 0, sizeof(cq)); 637 cq.op = MISDN_CTRL_GETOP; 638 if (ch->peer->ctrl(ch->peer, CONTROL_CHANNEL, &cq) < 0) { 639 printk(KERN_DEBUG "%s: CONTROL_CHANNEL failed\n", 640 __func__); 641 return; 642 } 643 if (cq.op & MISDN_CTRL_RX_OFF) 644 dsp->features_rx_off = 1; 645 if (cq.op & MISDN_CTRL_FILL_EMPTY) 646 dsp->features_fill_empty = 1; 647 if (dsp_options & DSP_OPT_NOHARDWARE) 648 return; 649 if ((cq.op & MISDN_CTRL_HW_FEATURES_OP)) { 650 cq.op = MISDN_CTRL_HW_FEATURES; 651 *((u_long *)&cq.p1) = (u_long)&dsp->features; 652 if (ch->peer->ctrl(ch->peer, CONTROL_CHANNEL, &cq)) { 653 printk(KERN_DEBUG "%s: 2nd CONTROL_CHANNEL failed\n", 654 __func__); 655 } 656 } else 657 if (dsp_debug & DEBUG_DSP_CORE) 658 printk(KERN_DEBUG "%s: features not supported for %s\n", 659 __func__, dsp->name); 660} 661 662static int 663dsp_function(struct mISDNchannel *ch, struct sk_buff *skb) 664{ 665 struct dsp *dsp = container_of(ch, struct dsp, ch); 666 struct mISDNhead *hh; 667 int ret = 0; 668 u8 *digits = NULL; 669 u_long flags; 670 671 hh = mISDN_HEAD_P(skb); 672 switch (hh->prim) { 673 /* FROM DOWN */ 674 case (PH_DATA_CNF): 675 dsp->data_pending = 0; 676 /* trigger next hdlc frame, if any */ 677 if (dsp->hdlc) { 678 spin_lock_irqsave(&dsp_lock, flags); 679 if (dsp->b_active) 680 schedule_work(&dsp->workq); 681 spin_unlock_irqrestore(&dsp_lock, flags); 682 } 683 break; 684 case (PH_DATA_IND): 685 case (DL_DATA_IND): 686 if (skb->len < 1) { 687 ret = -EINVAL; 688 break; 689 } 690 if (dsp->rx_is_off) { 691 if (dsp_debug & DEBUG_DSP_CORE) 692 printk(KERN_DEBUG "%s: rx-data during rx_off" 693 " for %s\n", 694 __func__, dsp->name); 695 } 696 if (dsp->hdlc) { 697 /* hdlc */ 698 spin_lock_irqsave(&dsp_lock, flags); 699 dsp_cmx_hdlc(dsp, skb); 700 spin_unlock_irqrestore(&dsp_lock, flags); 701 if (dsp->rx_disabled) { 702 /* if receive is not allowed */ 703 break; 704 } 705 hh->prim = DL_DATA_IND; 706 if (dsp->up) 707 return dsp->up->send(dsp->up, skb); 708 break; 709 } 710 711 spin_lock_irqsave(&dsp_lock, flags); 712 713 /* decrypt if enabled */ 714 if (dsp->bf_enable) 715 dsp_bf_decrypt(dsp, skb->data, skb->len); 716 /* pipeline */ 717 if (dsp->pipeline.inuse) 718 dsp_pipeline_process_rx(&dsp->pipeline, skb->data, 719 skb->len, hh->id); 720 /* change volume if requested */ 721 if (dsp->rx_volume) 722 dsp_change_volume(skb, dsp->rx_volume); 723 /* check if dtmf soft decoding is turned on */ 724 if (dsp->dtmf.software) { 725 digits = dsp_dtmf_goertzel_decode(dsp, skb->data, 726 skb->len, (dsp_options & DSP_OPT_ULAW) ? 1 : 0); 727 } 728 /* we need to process receive data if software */ 729 if (dsp->conf && dsp->conf->software) { 730 /* process data from card at cmx */ 731 dsp_cmx_receive(dsp, skb); 732 } 733 734 spin_unlock_irqrestore(&dsp_lock, flags); 735 736 /* send dtmf result, if any */ 737 if (digits) { 738 while (*digits) { 739 int k; 740 struct sk_buff *nskb; 741 if (dsp_debug & DEBUG_DSP_DTMF) 742 printk(KERN_DEBUG "%s: digit" 743 "(%c) to layer %s\n", 744 __func__, *digits, dsp->name); 745 k = *digits | DTMF_TONE_VAL; 746 nskb = _alloc_mISDN_skb(PH_CONTROL_IND, 747 MISDN_ID_ANY, sizeof(int), &k, 748 GFP_ATOMIC); 749 if (nskb) { 750 if (dsp->up) { 751 if (dsp->up->send( 752 dsp->up, nskb)) 753 dev_kfree_skb(nskb); 754 } else 755 dev_kfree_skb(nskb); 756 } 757 digits++; 758 } 759 } 760 if (dsp->rx_disabled) { 761 /* if receive is not allowed */ 762 break; 763 } 764 hh->prim = DL_DATA_IND; 765 if (dsp->up) 766 return dsp->up->send(dsp->up, skb); 767 break; 768 case (PH_CONTROL_IND): 769 if (dsp_debug & DEBUG_DSP_DTMFCOEFF) 770 printk(KERN_DEBUG "%s: PH_CONTROL INDICATION " 771 "received: %x (len %d) %s\n", __func__, 772 hh->id, skb->len, dsp->name); 773 switch (hh->id) { 774 case (DTMF_HFC_COEF): /* getting coefficients */ 775 if (!dsp->dtmf.hardware) { 776 if (dsp_debug & DEBUG_DSP_DTMFCOEFF) 777 printk(KERN_DEBUG "%s: ignoring DTMF " 778 "coefficients from HFC\n", 779 __func__); 780 break; 781 } 782 digits = dsp_dtmf_goertzel_decode(dsp, skb->data, 783 skb->len, 2); 784 while (*digits) { 785 int k; 786 struct sk_buff *nskb; 787 if (dsp_debug & DEBUG_DSP_DTMF) 788 printk(KERN_DEBUG "%s: digit" 789 "(%c) to layer %s\n", 790 __func__, *digits, dsp->name); 791 k = *digits | DTMF_TONE_VAL; 792 nskb = _alloc_mISDN_skb(PH_CONTROL_IND, 793 MISDN_ID_ANY, sizeof(int), &k, 794 GFP_ATOMIC); 795 if (nskb) { 796 if (dsp->up) { 797 if (dsp->up->send( 798 dsp->up, nskb)) 799 dev_kfree_skb(nskb); 800 } else 801 dev_kfree_skb(nskb); 802 } 803 digits++; 804 } 805 break; 806 case (HFC_VOL_CHANGE_TX): /* change volume */ 807 if (skb->len != sizeof(int)) { 808 ret = -EINVAL; 809 break; 810 } 811 spin_lock_irqsave(&dsp_lock, flags); 812 dsp->tx_volume = *((int *)skb->data); 813 if (dsp_debug & DEBUG_DSP_CORE) 814 printk(KERN_DEBUG "%s: change tx volume to " 815 "%d\n", __func__, dsp->tx_volume); 816 dsp_cmx_hardware(dsp->conf, dsp); 817 dsp_dtmf_hardware(dsp); 818 dsp_rx_off(dsp); 819 spin_unlock_irqrestore(&dsp_lock, flags); 820 break; 821 default: 822 if (dsp_debug & DEBUG_DSP_CORE) 823 printk(KERN_DEBUG "%s: ctrl ind %x unhandled " 824 "%s\n", __func__, hh->id, dsp->name); 825 ret = -EINVAL; 826 } 827 break; 828 case (PH_ACTIVATE_IND): 829 case (PH_ACTIVATE_CNF): 830 if (dsp_debug & DEBUG_DSP_CORE) 831 printk(KERN_DEBUG "%s: b_channel is now active %s\n", 832 __func__, dsp->name); 833 /* bchannel now active */ 834 spin_lock_irqsave(&dsp_lock, flags); 835 dsp->b_active = 1; 836 dsp->data_pending = 0; 837 dsp->rx_init = 1; 838 /* rx_W and rx_R will be adjusted on first frame */ 839 dsp->rx_W = 0; 840 dsp->rx_R = 0; 841 memset(dsp->rx_buff, 0, sizeof(dsp->rx_buff)); 842 dsp_cmx_hardware(dsp->conf, dsp); 843 dsp_dtmf_hardware(dsp); 844 dsp_rx_off(dsp); 845 spin_unlock_irqrestore(&dsp_lock, flags); 846 if (dsp_debug & DEBUG_DSP_CORE) 847 printk(KERN_DEBUG "%s: done with activation, sending " 848 "confirm to user space. %s\n", __func__, 849 dsp->name); 850 /* send activation to upper layer */ 851 hh->prim = DL_ESTABLISH_CNF; 852 if (dsp->up) 853 return dsp->up->send(dsp->up, skb); 854 break; 855 case (PH_DEACTIVATE_IND): 856 case (PH_DEACTIVATE_CNF): 857 if (dsp_debug & DEBUG_DSP_CORE) 858 printk(KERN_DEBUG "%s: b_channel is now inactive %s\n", 859 __func__, dsp->name); 860 /* bchannel now inactive */ 861 spin_lock_irqsave(&dsp_lock, flags); 862 dsp->b_active = 0; 863 dsp->data_pending = 0; 864 dsp_cmx_hardware(dsp->conf, dsp); 865 dsp_rx_off(dsp); 866 spin_unlock_irqrestore(&dsp_lock, flags); 867 hh->prim = DL_RELEASE_CNF; 868 if (dsp->up) 869 return dsp->up->send(dsp->up, skb); 870 break; 871 /* FROM UP */ 872 case (DL_DATA_REQ): 873 case (PH_DATA_REQ): 874 if (skb->len < 1) { 875 ret = -EINVAL; 876 break; 877 } 878 if (dsp->hdlc) { 879 /* hdlc */ 880 if (!dsp->b_active) { 881 ret = -EIO; 882 break; 883 } 884 hh->prim = PH_DATA_REQ; 885 spin_lock_irqsave(&dsp_lock, flags); 886 skb_queue_tail(&dsp->sendq, skb); 887 schedule_work(&dsp->workq); 888 spin_unlock_irqrestore(&dsp_lock, flags); 889 return 0; 890 } 891 /* send data to tx-buffer (if no tone is played) */ 892 if (!dsp->tone.tone) { 893 spin_lock_irqsave(&dsp_lock, flags); 894 dsp_cmx_transmit(dsp, skb); 895 spin_unlock_irqrestore(&dsp_lock, flags); 896 } 897 break; 898 case (PH_CONTROL_REQ): 899 spin_lock_irqsave(&dsp_lock, flags); 900 ret = dsp_control_req(dsp, hh, skb); 901 spin_unlock_irqrestore(&dsp_lock, flags); 902 break; 903 case (DL_ESTABLISH_REQ): 904 case (PH_ACTIVATE_REQ): 905 if (dsp_debug & DEBUG_DSP_CORE) 906 printk(KERN_DEBUG "%s: activating b_channel %s\n", 907 __func__, dsp->name); 908 if (dsp->dtmf.hardware || dsp->dtmf.software) 909 dsp_dtmf_goertzel_init(dsp); 910 get_features(ch); 911 /* enable fill_empty feature */ 912 if (dsp->features_fill_empty) 913 dsp_fill_empty(dsp); 914 /* send ph_activate */ 915 hh->prim = PH_ACTIVATE_REQ; 916 if (ch->peer) 917 return ch->recv(ch->peer, skb); 918 break; 919 case (DL_RELEASE_REQ): 920 case (PH_DEACTIVATE_REQ): 921 if (dsp_debug & DEBUG_DSP_CORE) 922 printk(KERN_DEBUG "%s: releasing b_channel %s\n", 923 __func__, dsp->name); 924 spin_lock_irqsave(&dsp_lock, flags); 925 dsp->tone.tone = 0; 926 dsp->tone.hardware = 0; 927 dsp->tone.software = 0; 928 if (timer_pending(&dsp->tone.tl)) 929 del_timer(&dsp->tone.tl); 930 if (dsp->conf) 931 dsp_cmx_conf(dsp, 0); /* dsp_cmx_hardware will also be 932 called here */ 933 skb_queue_purge(&dsp->sendq); 934 spin_unlock_irqrestore(&dsp_lock, flags); 935 hh->prim = PH_DEACTIVATE_REQ; 936 if (ch->peer) 937 return ch->recv(ch->peer, skb); 938 break; 939 default: 940 if (dsp_debug & DEBUG_DSP_CORE) 941 printk(KERN_DEBUG "%s: msg %x unhandled %s\n", 942 __func__, hh->prim, dsp->name); 943 ret = -EINVAL; 944 } 945 if (!ret) 946 dev_kfree_skb(skb); 947 return ret; 948} 949 950static int 951dsp_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg) 952{ 953 struct dsp *dsp = container_of(ch, struct dsp, ch); 954 u_long flags; 955 int err = 0; 956 957 if (debug & DEBUG_DSP_CTRL) 958 printk(KERN_DEBUG "%s:(%x)\n", __func__, cmd); 959 960 switch (cmd) { 961 case OPEN_CHANNEL: 962 break; 963 case CLOSE_CHANNEL: 964 if (dsp->ch.peer) 965 dsp->ch.peer->ctrl(dsp->ch.peer, CLOSE_CHANNEL, NULL); 966 967 /* wait until workqueue has finished, 968 * must lock here, or we may hit send-process currently 969 * queueing. */ 970 spin_lock_irqsave(&dsp_lock, flags); 971 dsp->b_active = 0; 972 spin_unlock_irqrestore(&dsp_lock, flags); 973 /* MUST not be locked, because it waits until queue is done. */ 974 cancel_work_sync(&dsp->workq); 975 spin_lock_irqsave(&dsp_lock, flags); 976 if (timer_pending(&dsp->tone.tl)) 977 del_timer(&dsp->tone.tl); 978 skb_queue_purge(&dsp->sendq); 979 if (dsp_debug & DEBUG_DSP_CTRL) 980 printk(KERN_DEBUG "%s: releasing member %s\n", 981 __func__, dsp->name); 982 dsp->b_active = 0; 983 dsp_cmx_conf(dsp, 0); /* dsp_cmx_hardware will also be called 984 here */ 985 dsp_pipeline_destroy(&dsp->pipeline); 986 987 if (dsp_debug & DEBUG_DSP_CTRL) 988 printk(KERN_DEBUG "%s: remove & destroy object %s\n", 989 __func__, dsp->name); 990 list_del(&dsp->list); 991 spin_unlock_irqrestore(&dsp_lock, flags); 992 993 if (dsp_debug & DEBUG_DSP_CTRL) 994 printk(KERN_DEBUG "%s: dsp instance released\n", 995 __func__); 996 vfree(dsp); 997 module_put(THIS_MODULE); 998 break; 999 } 1000 return err; 1001} 1002 1003static void 1004dsp_send_bh(struct work_struct *work) 1005{ 1006 struct dsp *dsp = container_of(work, struct dsp, workq); 1007 struct sk_buff *skb; 1008 struct mISDNhead *hh; 1009 1010 if (dsp->hdlc && dsp->data_pending) 1011 return; /* wait until data has been acknowledged */ 1012 1013 /* send queued data */ 1014 while ((skb = skb_dequeue(&dsp->sendq))) { 1015 /* in locked date, we must have still data in queue */ 1016 if (dsp->data_pending) { 1017 if (dsp_debug & DEBUG_DSP_CORE) 1018 printk(KERN_DEBUG "%s: fifo full %s, this is " 1019 "no bug!\n", __func__, dsp->name); 1020 /* flush transparent data, if not acked */ 1021 dev_kfree_skb(skb); 1022 continue; 1023 } 1024 hh = mISDN_HEAD_P(skb); 1025 if (hh->prim == DL_DATA_REQ) { 1026 /* send packet up */ 1027 if (dsp->up) { 1028 if (dsp->up->send(dsp->up, skb)) 1029 dev_kfree_skb(skb); 1030 } else 1031 dev_kfree_skb(skb); 1032 } else { 1033 /* send packet down */ 1034 if (dsp->ch.peer) { 1035 dsp->data_pending = 1; 1036 if (dsp->ch.recv(dsp->ch.peer, skb)) { 1037 dev_kfree_skb(skb); 1038 dsp->data_pending = 0; 1039 } 1040 } else 1041 dev_kfree_skb(skb); 1042 } 1043 } 1044} 1045 1046static int 1047dspcreate(struct channel_req *crq) 1048{ 1049 struct dsp *ndsp; 1050 u_long flags; 1051 1052 if (crq->protocol != ISDN_P_B_L2DSP 1053 && crq->protocol != ISDN_P_B_L2DSPHDLC) 1054 return -EPROTONOSUPPORT; 1055 ndsp = vzalloc(sizeof(struct dsp)); 1056 if (!ndsp) { 1057 printk(KERN_ERR "%s: vmalloc struct dsp failed\n", __func__); 1058 return -ENOMEM; 1059 } 1060 if (dsp_debug & DEBUG_DSP_CTRL) 1061 printk(KERN_DEBUG "%s: creating new dsp instance\n", __func__); 1062 1063 /* default enabled */ 1064 INIT_WORK(&ndsp->workq, (void *)dsp_send_bh); 1065 skb_queue_head_init(&ndsp->sendq); 1066 ndsp->ch.send = dsp_function; 1067 ndsp->ch.ctrl = dsp_ctrl; 1068 ndsp->up = crq->ch; 1069 crq->ch = &ndsp->ch; 1070 if (crq->protocol == ISDN_P_B_L2DSP) { 1071 crq->protocol = ISDN_P_B_RAW; 1072 ndsp->hdlc = 0; 1073 } else { 1074 crq->protocol = ISDN_P_B_HDLC; 1075 ndsp->hdlc = 1; 1076 } 1077 if (!try_module_get(THIS_MODULE)) 1078 printk(KERN_WARNING "%s:cannot get module\n", 1079 __func__); 1080 1081 sprintf(ndsp->name, "DSP_C%x(0x%p)", 1082 ndsp->up->st->dev->id + 1, ndsp); 1083 /* set frame size to start */ 1084 ndsp->features.hfc_id = -1; /* current PCM id */ 1085 ndsp->features.pcm_id = -1; /* current PCM id */ 1086 ndsp->pcm_slot_rx = -1; /* current CPM slot */ 1087 ndsp->pcm_slot_tx = -1; 1088 ndsp->pcm_bank_rx = -1; 1089 ndsp->pcm_bank_tx = -1; 1090 ndsp->hfc_conf = -1; /* current conference number */ 1091 /* set tone timer */ 1092 ndsp->tone.tl.function = (void *)dsp_tone_timeout; 1093 ndsp->tone.tl.data = (long) ndsp; 1094 init_timer(&ndsp->tone.tl); 1095 1096 if (dtmfthreshold < 20 || dtmfthreshold > 500) 1097 dtmfthreshold = 200; 1098 ndsp->dtmf.treshold = dtmfthreshold * 10000; 1099 1100 /* init pipeline append to list */ 1101 spin_lock_irqsave(&dsp_lock, flags); 1102 dsp_pipeline_init(&ndsp->pipeline); 1103 list_add_tail(&ndsp->list, &dsp_ilist); 1104 spin_unlock_irqrestore(&dsp_lock, flags); 1105 1106 return 0; 1107} 1108 1109 1110static struct Bprotocol DSP = { 1111 .Bprotocols = (1 << (ISDN_P_B_L2DSP & ISDN_P_B_MASK)) 1112 | (1 << (ISDN_P_B_L2DSPHDLC & ISDN_P_B_MASK)), 1113 .name = "dsp", 1114 .create = dspcreate 1115}; 1116 1117static int __init dsp_init(void) 1118{ 1119 int err; 1120 int tics; 1121 1122 printk(KERN_INFO "DSP module %s\n", mISDN_dsp_revision); 1123 1124 dsp_options = options; 1125 dsp_debug = debug; 1126 1127 /* set packet size */ 1128 dsp_poll = poll; 1129 if (dsp_poll) { 1130 if (dsp_poll > MAX_POLL) { 1131 printk(KERN_ERR "%s: Wrong poll value (%d), use %d " 1132 "maximum.\n", __func__, poll, MAX_POLL); 1133 err = -EINVAL; 1134 return err; 1135 } 1136 if (dsp_poll < 8) { 1137 printk(KERN_ERR "%s: Wrong poll value (%d), use 8 " 1138 "minimum.\n", __func__, dsp_poll); 1139 err = -EINVAL; 1140 return err; 1141 } 1142 dsp_tics = poll * HZ / 8000; 1143 if (dsp_tics * 8000 != poll * HZ) { 1144 printk(KERN_INFO "mISDN_dsp: Cannot clock every %d " 1145 "samples (0,125 ms). It is not a multiple of " 1146 "%d HZ.\n", poll, HZ); 1147 err = -EINVAL; 1148 return err; 1149 } 1150 } else { 1151 poll = 8; 1152 while (poll <= MAX_POLL) { 1153 tics = (poll * HZ) / 8000; 1154 if (tics * 8000 == poll * HZ) { 1155 dsp_tics = tics; 1156 dsp_poll = poll; 1157 if (poll >= 64) 1158 break; 1159 } 1160 poll++; 1161 } 1162 } 1163 if (dsp_poll == 0) { 1164 printk(KERN_INFO "mISDN_dsp: There is no multiple of kernel " 1165 "clock that equals exactly the duration of 8-256 " 1166 "samples. (Choose kernel clock speed like 100, 250, " 1167 "300, 1000)\n"); 1168 err = -EINVAL; 1169 return err; 1170 } 1171 printk(KERN_INFO "mISDN_dsp: DSP clocks every %d samples. This equals " 1172 "%d jiffies.\n", dsp_poll, dsp_tics); 1173 1174 spin_lock_init(&dsp_lock); 1175 INIT_LIST_HEAD(&dsp_ilist); 1176 INIT_LIST_HEAD(&conf_ilist); 1177 1178 /* init conversion tables */ 1179 dsp_audio_generate_law_tables(); 1180 dsp_silence = (dsp_options & DSP_OPT_ULAW) ? 0xff : 0x2a; 1181 dsp_audio_law_to_s32 = (dsp_options & DSP_OPT_ULAW) ? 1182 dsp_audio_ulaw_to_s32 : dsp_audio_alaw_to_s32; 1183 dsp_audio_generate_s2law_table(); 1184 dsp_audio_generate_seven(); 1185 dsp_audio_generate_mix_table(); 1186 if (dsp_options & DSP_OPT_ULAW) 1187 dsp_audio_generate_ulaw_samples(); 1188 dsp_audio_generate_volume_changes(); 1189 1190 err = dsp_pipeline_module_init(); 1191 if (err) { 1192 printk(KERN_ERR "mISDN_dsp: Can't initialize pipeline, " 1193 "error(%d)\n", err); 1194 return err; 1195 } 1196 1197 err = mISDN_register_Bprotocol(&DSP); 1198 if (err) { 1199 printk(KERN_ERR "Can't register %s error(%d)\n", DSP.name, err); 1200 return err; 1201 } 1202 1203 /* set sample timer */ 1204 dsp_spl_tl.function = (void *)dsp_cmx_send; 1205 dsp_spl_tl.data = 0; 1206 init_timer(&dsp_spl_tl); 1207 dsp_spl_tl.expires = jiffies + dsp_tics; 1208 dsp_spl_jiffies = dsp_spl_tl.expires; 1209 add_timer(&dsp_spl_tl); 1210 1211 return 0; 1212} 1213 1214 1215static void __exit dsp_cleanup(void) 1216{ 1217 mISDN_unregister_Bprotocol(&DSP); 1218 1219 if (timer_pending(&dsp_spl_tl)) 1220 del_timer(&dsp_spl_tl); 1221 1222 if (!list_empty(&dsp_ilist)) { 1223 printk(KERN_ERR "mISDN_dsp: Audio DSP object inst list not " 1224 "empty.\n"); 1225 } 1226 if (!list_empty(&conf_ilist)) { 1227 printk(KERN_ERR "mISDN_dsp: Conference list not empty. Not " 1228 "all memory freed.\n"); 1229 } 1230 1231 dsp_pipeline_module_exit(); 1232} 1233 1234module_init(dsp_init); 1235module_exit(dsp_cleanup); 1236