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