1 /* 2 * Audio crossconnecting/conferrencing (hardware level). 3 * 4 * Copyright 2002 by Andreas Eversberg (jolly@eversberg.eu) 5 * 6 * This software may be used and distributed according to the terms 7 * of the GNU General Public License, incorporated herein by reference. 8 * 9 */ 10 11 /* 12 * The process of adding and removing parties to/from a conference: 13 * 14 * There is a chain of struct dsp_conf which has one or more members in a chain 15 * of struct dsp_conf_member. 16 * 17 * After a party is added, the conference is checked for hardware capability. 18 * Also if a party is removed, the conference is checked again. 19 * 20 * There are 3 different solutions: -1 = software, 0 = hardware-crossconnect 21 * 1-n = hardware-conference. The n will give the conference number. 22 * 23 * Depending on the change after removal or insertion of a party, hardware 24 * commands are given. 25 * 26 * The current solution is stored within the struct dsp_conf entry. 27 */ 28 29 /* 30 * HOW THE CMX WORKS: 31 * 32 * There are 3 types of interaction: One member is alone, in this case only 33 * data flow from upper to lower layer is done. 34 * Two members will also exchange their data so they are crossconnected. 35 * Three or more members will be added in a conference and will hear each 36 * other but will not receive their own speech (echo) if not enabled. 37 * 38 * Features of CMX are: 39 * - Crossconnecting or even conference, if more than two members are together. 40 * - Force mixing of transmit data with other crossconnect/conference members. 41 * - Echo generation to benchmark the delay of audio processing. 42 * - Use hardware to minimize cpu load, disable FIFO load and minimize delay. 43 * - Dejittering and clock generation. 44 * 45 * There are 2 buffers: 46 * 47 * 48 * RX-Buffer 49 * R W 50 * | | 51 * ----------------+-------------+------------------- 52 * 53 * The rx-buffer is a ring buffer used to store the received data for each 54 * individual member. This is only the case if data needs to be dejittered 55 * or in case of a conference where different clocks require reclocking. 56 * The transmit-clock (R) will read the buffer. 57 * If the clock overruns the write-pointer, we will have a buffer underrun. 58 * If the write pointer always has a certain distance from the transmit- 59 * clock, we will have a delay. The delay will dynamically be increased and 60 * reduced. 61 * 62 * 63 * TX-Buffer 64 * R W 65 * | | 66 * -----------------+--------+----------------------- 67 * 68 * The tx-buffer is a ring buffer to queue the transmit data from user space 69 * until it will be mixed or sent. There are two pointers, R and W. If the write 70 * pointer W would reach or overrun R, the buffer would overrun. In this case 71 * (some) data is dropped so that it will not overrun. 72 * Additionally a dynamic dejittering can be enabled. this allows data from 73 * user space that have jitter and different clock source. 74 * 75 * 76 * Clock: 77 * 78 * A Clock is not required, if the data source has exactly one clock. In this 79 * case the data source is forwarded to the destination. 80 * 81 * A Clock is required, because the data source 82 * - has multiple clocks. 83 * - has no usable clock due to jitter or packet loss (VoIP). 84 * In this case the system's clock is used. The clock resolution depends on 85 * the jiffie resolution. 86 * 87 * If a member joins a conference: 88 * 89 * - If a member joins, its rx_buff is set to silence and change read pointer 90 * to transmit clock. 91 * 92 * The procedure of received data from card is explained in cmx_receive. 93 * The procedure of received data from user space is explained in cmx_transmit. 94 * The procedure of transmit data to card is cmx_send. 95 * 96 * 97 * Interaction with other features: 98 * 99 * DTMF: 100 * DTMF decoding is done before the data is crossconnected. 101 * 102 * Volume change: 103 * Changing rx-volume is done before the data is crossconnected. The tx-volume 104 * must be changed whenever data is transmitted to the card by the cmx. 105 * 106 * Tones: 107 * If a tone is enabled, it will be processed whenever data is transmitted to 108 * the card. It will replace the tx-data from the user space. 109 * If tones are generated by hardware, this conference member is removed for 110 * this time. 111 * 112 * Disable rx-data: 113 * If cmx is realized in hardware, rx data will be disabled if requested by 114 * the upper layer. If dtmf decoding is done by software and enabled, rx data 115 * will not be disabled but blocked to the upper layer. 116 * 117 * HFC conference engine: 118 * If it is possible to realize all features using hardware, hardware will be 119 * used if not forbidden by control command. Disabling rx-data provides 120 * absolutely traffic free audio processing. (except for the quick 1-frame 121 * upload of a tone loop, only once for a new tone) 122 * 123 */ 124 125 /* delay.h is required for hw_lock.h */ 126 127 #include <linux/slab.h> 128 #include <linux/delay.h> 129 #include <linux/mISDNif.h> 130 #include <linux/mISDNdsp.h> 131 #include "core.h" 132 #include "dsp.h" 133 /* 134 * debugging of multi party conference, 135 * by using conference even with two members 136 */ 137 138 /* #define CMX_CONF_DEBUG */ 139 140 /*#define CMX_DEBUG * massive read/write pointer output */ 141 /*#define CMX_DELAY_DEBUG * gives rx-buffer delay overview */ 142 /*#define CMX_TX_DEBUG * massive read/write on tx-buffer with content */ 143 144 static inline int 145 count_list_member(struct list_head *head) 146 { 147 int cnt = 0; 148 struct list_head *m; 149 150 list_for_each(m, head) 151 cnt++; 152 return cnt; 153 } 154 155 /* 156 * debug cmx memory structure 157 */ 158 void 159 dsp_cmx_debug(struct dsp *dsp) 160 { 161 struct dsp_conf *conf; 162 struct dsp_conf_member *member; 163 struct dsp *odsp; 164 165 printk(KERN_DEBUG "-----Current DSP\n"); 166 list_for_each_entry(odsp, &dsp_ilist, list) { 167 printk(KERN_DEBUG "* %s hardecho=%d softecho=%d txmix=%d", 168 odsp->name, odsp->echo.hardware, odsp->echo.software, 169 odsp->tx_mix); 170 if (odsp->conf) 171 printk(" (Conf %d)", odsp->conf->id); 172 if (dsp == odsp) 173 printk(" *this*"); 174 printk("\n"); 175 } 176 printk(KERN_DEBUG "-----Current Conf:\n"); 177 list_for_each_entry(conf, &conf_ilist, list) { 178 printk(KERN_DEBUG "* Conf %d (%p)\n", conf->id, conf); 179 list_for_each_entry(member, &conf->mlist, list) { 180 printk(KERN_DEBUG 181 " - member = %s (slot_tx %d, bank_tx %d, " 182 "slot_rx %d, bank_rx %d hfc_conf %d " 183 "tx_data %d rx_is_off %d)%s\n", 184 member->dsp->name, member->dsp->pcm_slot_tx, 185 member->dsp->pcm_bank_tx, member->dsp->pcm_slot_rx, 186 member->dsp->pcm_bank_rx, member->dsp->hfc_conf, 187 member->dsp->tx_data, member->dsp->rx_is_off, 188 (member->dsp == dsp) ? " *this*" : ""); 189 } 190 } 191 printk(KERN_DEBUG "-----end\n"); 192 } 193 194 /* 195 * search conference 196 */ 197 static struct dsp_conf * 198 dsp_cmx_search_conf(u32 id) 199 { 200 struct dsp_conf *conf; 201 202 if (!id) { 203 printk(KERN_WARNING "%s: conference ID is 0.\n", __func__); 204 return NULL; 205 } 206 207 /* search conference */ 208 list_for_each_entry(conf, &conf_ilist, list) 209 if (conf->id == id) 210 return conf; 211 212 return NULL; 213 } 214 215 216 /* 217 * add member to conference 218 */ 219 static int 220 dsp_cmx_add_conf_member(struct dsp *dsp, struct dsp_conf *conf) 221 { 222 struct dsp_conf_member *member; 223 224 if (!conf || !dsp) { 225 printk(KERN_WARNING "%s: conf or dsp is 0.\n", __func__); 226 return -EINVAL; 227 } 228 if (dsp->member) { 229 printk(KERN_WARNING "%s: dsp is already member in a conf.\n", 230 __func__); 231 return -EINVAL; 232 } 233 234 if (dsp->conf) { 235 printk(KERN_WARNING "%s: dsp is already in a conf.\n", 236 __func__); 237 return -EINVAL; 238 } 239 240 member = kzalloc(sizeof(struct dsp_conf_member), GFP_ATOMIC); 241 if (!member) { 242 printk(KERN_ERR "kzalloc struct dsp_conf_member failed\n"); 243 return -ENOMEM; 244 } 245 member->dsp = dsp; 246 /* clear rx buffer */ 247 memset(dsp->rx_buff, dsp_silence, sizeof(dsp->rx_buff)); 248 dsp->rx_init = 1; /* rx_W and rx_R will be adjusted on first frame */ 249 dsp->rx_W = 0; 250 dsp->rx_R = 0; 251 252 list_add_tail(&member->list, &conf->mlist); 253 254 dsp->conf = conf; 255 dsp->member = member; 256 257 return 0; 258 } 259 260 261 /* 262 * del member from conference 263 */ 264 int 265 dsp_cmx_del_conf_member(struct dsp *dsp) 266 { 267 struct dsp_conf_member *member; 268 269 if (!dsp) { 270 printk(KERN_WARNING "%s: dsp is 0.\n", 271 __func__); 272 return -EINVAL; 273 } 274 275 if (!dsp->conf) { 276 printk(KERN_WARNING "%s: dsp is not in a conf.\n", 277 __func__); 278 return -EINVAL; 279 } 280 281 if (list_empty(&dsp->conf->mlist)) { 282 printk(KERN_WARNING "%s: dsp has linked an empty conf.\n", 283 __func__); 284 return -EINVAL; 285 } 286 287 /* find us in conf */ 288 list_for_each_entry(member, &dsp->conf->mlist, list) { 289 if (member->dsp == dsp) { 290 list_del(&member->list); 291 dsp->conf = NULL; 292 dsp->member = NULL; 293 kfree(member); 294 return 0; 295 } 296 } 297 printk(KERN_WARNING 298 "%s: dsp is not present in its own conf_member list.\n", 299 __func__); 300 301 return -EINVAL; 302 } 303 304 305 /* 306 * new conference 307 */ 308 static struct dsp_conf 309 *dsp_cmx_new_conf(u32 id) 310 { 311 struct dsp_conf *conf; 312 313 if (!id) { 314 printk(KERN_WARNING "%s: id is 0.\n", 315 __func__); 316 return NULL; 317 } 318 319 conf = kzalloc(sizeof(struct dsp_conf), GFP_ATOMIC); 320 if (!conf) { 321 printk(KERN_ERR "kzalloc struct dsp_conf failed\n"); 322 return NULL; 323 } 324 INIT_LIST_HEAD(&conf->mlist); 325 conf->id = id; 326 327 list_add_tail(&conf->list, &conf_ilist); 328 329 return conf; 330 } 331 332 333 /* 334 * del conference 335 */ 336 int 337 dsp_cmx_del_conf(struct dsp_conf *conf) 338 { 339 if (!conf) { 340 printk(KERN_WARNING "%s: conf is null.\n", 341 __func__); 342 return -EINVAL; 343 } 344 345 if (!list_empty(&conf->mlist)) { 346 printk(KERN_WARNING "%s: conf not empty.\n", 347 __func__); 348 return -EINVAL; 349 } 350 list_del(&conf->list); 351 kfree(conf); 352 353 return 0; 354 } 355 356 357 /* 358 * send HW message to hfc card 359 */ 360 static void 361 dsp_cmx_hw_message(struct dsp *dsp, u32 message, u32 param1, u32 param2, 362 u32 param3, u32 param4) 363 { 364 struct mISDN_ctrl_req cq; 365 366 memset(&cq, 0, sizeof(cq)); 367 cq.op = message; 368 cq.p1 = param1 | (param2 << 8); 369 cq.p2 = param3 | (param4 << 8); 370 if (dsp->ch.peer) 371 dsp->ch.peer->ctrl(dsp->ch.peer, CONTROL_CHANNEL, &cq); 372 } 373 374 375 /* 376 * do hardware update and set the software/hardware flag 377 * 378 * either a conference or a dsp instance can be given 379 * if only dsp instance is given, the instance is not associated with a conf 380 * and therefore removed. if a conference is given, the dsp is expected to 381 * be member of that conference. 382 */ 383 void 384 dsp_cmx_hardware(struct dsp_conf *conf, struct dsp *dsp) 385 { 386 struct dsp_conf_member *member, *nextm; 387 struct dsp *finddsp; 388 int memb = 0, i, ii, i1, i2; 389 int freeunits[8]; 390 u_char freeslots[256]; 391 int same_hfc = -1, same_pcm = -1, current_conf = -1, 392 all_conf = 1, tx_data = 0; 393 394 /* dsp gets updated (no conf) */ 395 if (!conf) { 396 if (!dsp) 397 return; 398 if (dsp_debug & DEBUG_DSP_CMX) 399 printk(KERN_DEBUG "%s checking dsp %s\n", 400 __func__, dsp->name); 401 one_member: 402 /* remove HFC conference if enabled */ 403 if (dsp->hfc_conf >= 0) { 404 if (dsp_debug & DEBUG_DSP_CMX) 405 printk(KERN_DEBUG 406 "%s removing %s from HFC conf %d " 407 "because dsp is split\n", __func__, 408 dsp->name, dsp->hfc_conf); 409 dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_CONF_SPLIT, 410 0, 0, 0, 0); 411 dsp->hfc_conf = -1; 412 } 413 /* process hw echo */ 414 if (dsp->features.pcm_banks < 1) 415 return; 416 if (!dsp->echo.software && !dsp->echo.hardware) { 417 /* NO ECHO: remove PCM slot if assigned */ 418 if (dsp->pcm_slot_tx >= 0 || dsp->pcm_slot_rx >= 0) { 419 if (dsp_debug & DEBUG_DSP_CMX) 420 printk(KERN_DEBUG "%s removing %s from" 421 " PCM slot %d (TX) %d (RX) because" 422 " dsp is split (no echo)\n", 423 __func__, dsp->name, 424 dsp->pcm_slot_tx, dsp->pcm_slot_rx); 425 dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_PCM_DISC, 426 0, 0, 0, 0); 427 dsp->pcm_slot_tx = -1; 428 dsp->pcm_bank_tx = -1; 429 dsp->pcm_slot_rx = -1; 430 dsp->pcm_bank_rx = -1; 431 } 432 return; 433 } 434 /* echo is enabled, find out if we use soft or hardware */ 435 dsp->echo.software = dsp->tx_data; 436 dsp->echo.hardware = 0; 437 /* ECHO: already echo */ 438 if (dsp->pcm_slot_tx >= 0 && dsp->pcm_slot_rx < 0 && 439 dsp->pcm_bank_tx == 2 && dsp->pcm_bank_rx == 2) { 440 dsp->echo.hardware = 1; 441 return; 442 } 443 /* ECHO: if slot already assigned */ 444 if (dsp->pcm_slot_tx >= 0) { 445 dsp->pcm_slot_rx = dsp->pcm_slot_tx; 446 dsp->pcm_bank_tx = 2; /* 2 means loop */ 447 dsp->pcm_bank_rx = 2; 448 if (dsp_debug & DEBUG_DSP_CMX) 449 printk(KERN_DEBUG 450 "%s refresh %s for echo using slot %d\n", 451 __func__, dsp->name, 452 dsp->pcm_slot_tx); 453 dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_PCM_CONN, 454 dsp->pcm_slot_tx, 2, dsp->pcm_slot_rx, 2); 455 dsp->echo.hardware = 1; 456 return; 457 } 458 /* ECHO: find slot */ 459 dsp->pcm_slot_tx = -1; 460 dsp->pcm_slot_rx = -1; 461 memset(freeslots, 1, sizeof(freeslots)); 462 list_for_each_entry(finddsp, &dsp_ilist, list) { 463 if (finddsp->features.pcm_id == dsp->features.pcm_id) { 464 if (finddsp->pcm_slot_rx >= 0 && 465 finddsp->pcm_slot_rx < sizeof(freeslots)) 466 freeslots[finddsp->pcm_slot_rx] = 0; 467 if (finddsp->pcm_slot_tx >= 0 && 468 finddsp->pcm_slot_tx < sizeof(freeslots)) 469 freeslots[finddsp->pcm_slot_tx] = 0; 470 } 471 } 472 i = 0; 473 ii = dsp->features.pcm_slots; 474 while (i < ii) { 475 if (freeslots[i]) 476 break; 477 i++; 478 } 479 if (i == ii) { 480 if (dsp_debug & DEBUG_DSP_CMX) 481 printk(KERN_DEBUG 482 "%s no slot available for echo\n", 483 __func__); 484 /* no more slots available */ 485 dsp->echo.software = 1; 486 return; 487 } 488 /* assign free slot */ 489 dsp->pcm_slot_tx = i; 490 dsp->pcm_slot_rx = i; 491 dsp->pcm_bank_tx = 2; /* loop */ 492 dsp->pcm_bank_rx = 2; 493 if (dsp_debug & DEBUG_DSP_CMX) 494 printk(KERN_DEBUG 495 "%s assign echo for %s using slot %d\n", 496 __func__, dsp->name, dsp->pcm_slot_tx); 497 dsp_cmx_hw_message(dsp, MISDN_CTRL_HFC_PCM_CONN, 498 dsp->pcm_slot_tx, 2, dsp->pcm_slot_rx, 2); 499 dsp->echo.hardware = 1; 500 return; 501 } 502 503 /* conf gets updated (all members) */ 504 if (dsp_debug & DEBUG_DSP_CMX) 505 printk(KERN_DEBUG "%s checking conference %d\n", 506 __func__, conf->id); 507 508 if (list_empty(&conf->mlist)) { 509 printk(KERN_ERR "%s: conference without members\n", 510 __func__); 511 return; 512 } 513 member = list_entry(conf->mlist.next, struct dsp_conf_member, list); 514 same_hfc = member->dsp->features.hfc_id; 515 same_pcm = member->dsp->features.pcm_id; 516 /* check all members in our conference */ 517 list_for_each_entry(member, &conf->mlist, list) { 518 /* check if member uses mixing */ 519 if (member->dsp->tx_mix) { 520 if (dsp_debug & DEBUG_DSP_CMX) 521 printk(KERN_DEBUG 522 "%s dsp %s cannot form a conf, because " 523 "tx_mix is turned on\n", __func__, 524 member->dsp->name); 525 conf_software: 526 list_for_each_entry(member, &conf->mlist, list) { 527 dsp = member->dsp; 528 /* remove HFC conference if enabled */ 529 if (dsp->hfc_conf >= 0) { 530 if (dsp_debug & DEBUG_DSP_CMX) 531 printk(KERN_DEBUG 532 "%s removing %s from HFC " 533 "conf %d because not " 534 "possible with hardware\n", 535 __func__, 536 dsp->name, 537 dsp->hfc_conf); 538 dsp_cmx_hw_message(dsp, 539 MISDN_CTRL_HFC_CONF_SPLIT, 540 0, 0, 0, 0); 541 dsp->hfc_conf = -1; 542 } 543 /* remove PCM slot if assigned */ 544 if (dsp->pcm_slot_tx >= 0 || 545 dsp->pcm_slot_rx >= 0) { 546 if (dsp_debug & DEBUG_DSP_CMX) 547 printk(KERN_DEBUG "%s removing " 548 "%s from PCM slot %d (TX)" 549 " slot %d (RX) because not" 550 " possible with hardware\n", 551 __func__, 552 dsp->name, 553 dsp->pcm_slot_tx, 554 dsp->pcm_slot_rx); 555 dsp_cmx_hw_message(dsp, 556 MISDN_CTRL_HFC_PCM_DISC, 557 0, 0, 0, 0); 558 dsp->pcm_slot_tx = -1; 559 dsp->pcm_bank_tx = -1; 560 dsp->pcm_slot_rx = -1; 561 dsp->pcm_bank_rx = -1; 562 } 563 } 564 conf->hardware = 0; 565 conf->software = 1; 566 return; 567 } 568 /* check if member has echo turned on */ 569 if (member->dsp->echo.hardware || member->dsp->echo.software) { 570 if (dsp_debug & DEBUG_DSP_CMX) 571 printk(KERN_DEBUG 572 "%s dsp %s cannot form a conf, because " 573 "echo is turned on\n", __func__, 574 member->dsp->name); 575 goto conf_software; 576 } 577 /* check if member has tx_mix turned on */ 578 if (member->dsp->tx_mix) { 579 if (dsp_debug & DEBUG_DSP_CMX) 580 printk(KERN_DEBUG 581 "%s dsp %s cannot form a conf, because " 582 "tx_mix is turned on\n", 583 __func__, member->dsp->name); 584 goto conf_software; 585 } 586 /* check if member changes volume at an not suppoted level */ 587 if (member->dsp->tx_volume) { 588 if (dsp_debug & DEBUG_DSP_CMX) 589 printk(KERN_DEBUG 590 "%s dsp %s cannot form a conf, because " 591 "tx_volume is changed\n", 592 __func__, member->dsp->name); 593 goto conf_software; 594 } 595 if (member->dsp->rx_volume) { 596 if (dsp_debug & DEBUG_DSP_CMX) 597 printk(KERN_DEBUG 598 "%s dsp %s cannot form a conf, because " 599 "rx_volume is changed\n", 600 __func__, member->dsp->name); 601 goto conf_software; 602 } 603 /* check if tx-data turned on */ 604 if (member->dsp->tx_data) { 605 if (dsp_debug & DEBUG_DSP_CMX) 606 printk(KERN_DEBUG 607 "%s dsp %s tx_data is turned on\n", 608 __func__, member->dsp->name); 609 tx_data = 1; 610 } 611 /* check if pipeline exists */ 612 if (member->dsp->pipeline.inuse) { 613 if (dsp_debug & DEBUG_DSP_CMX) 614 printk(KERN_DEBUG 615 "%s dsp %s cannot form a conf, because " 616 "pipeline exists\n", __func__, 617 member->dsp->name); 618 goto conf_software; 619 } 620 /* check if encryption is enabled */ 621 if (member->dsp->bf_enable) { 622 if (dsp_debug & DEBUG_DSP_CMX) 623 printk(KERN_DEBUG "%s dsp %s cannot form a " 624 "conf, because encryption is enabled\n", 625 __func__, member->dsp->name); 626 goto conf_software; 627 } 628 /* check if member is on a card with PCM support */ 629 if (member->dsp->features.pcm_id < 0) { 630 if (dsp_debug & DEBUG_DSP_CMX) 631 printk(KERN_DEBUG 632 "%s dsp %s cannot form a conf, because " 633 "dsp has no PCM bus\n", 634 __func__, member->dsp->name); 635 goto conf_software; 636 } 637 /* check if relations are on the same PCM bus */ 638 if (member->dsp->features.pcm_id != same_pcm) { 639 if (dsp_debug & DEBUG_DSP_CMX) 640 printk(KERN_DEBUG 641 "%s dsp %s cannot form a conf, because " 642 "dsp is on a different PCM bus than the " 643 "first dsp\n", 644 __func__, member->dsp->name); 645 goto conf_software; 646 } 647 /* determine if members are on the same hfc chip */ 648 if (same_hfc != member->dsp->features.hfc_id) 649 same_hfc = -1; 650 /* if there are members already in a conference */ 651 if (current_conf < 0 && member->dsp->hfc_conf >= 0) 652 current_conf = member->dsp->hfc_conf; 653 /* if any member is not in a conference */ 654 if (member->dsp->hfc_conf < 0) 655 all_conf = 0; 656 657 memb++; 658 } 659 660 /* if no member, this is an error */ 661 if (memb < 1) 662 return; 663 664 /* one member */ 665 if (memb == 1) { 666 if (dsp_debug & DEBUG_DSP_CMX) 667 printk(KERN_DEBUG 668 "%s conf %d cannot form a HW conference, " 669 "because dsp is alone\n", __func__, conf->id); 670 conf->hardware = 0; 671 conf->software = 0; 672 member = list_entry(conf->mlist.next, struct dsp_conf_member, 673 list); 674 dsp = member->dsp; 675 goto one_member; 676 } 677 678 /* 679 * ok, now we are sure that all members are on the same pcm. 680 * now we will see if we have only two members, so we can do 681 * crossconnections, which don't have any limitations. 682 */ 683 684 /* if we have only two members */ 685 if (memb == 2) { 686 member = list_entry(conf->mlist.next, struct dsp_conf_member, 687 list); 688 nextm = list_entry(member->list.next, struct dsp_conf_member, 689 list); 690 /* remove HFC conference if enabled */ 691 if (member->dsp->hfc_conf >= 0) { 692 if (dsp_debug & DEBUG_DSP_CMX) 693 printk(KERN_DEBUG 694 "%s removing %s from HFC conf %d because " 695 "two parties require only a PCM slot\n", 696 __func__, member->dsp->name, 697 member->dsp->hfc_conf); 698 dsp_cmx_hw_message(member->dsp, 699 MISDN_CTRL_HFC_CONF_SPLIT, 0, 0, 0, 0); 700 member->dsp->hfc_conf = -1; 701 } 702 if (nextm->dsp->hfc_conf >= 0) { 703 if (dsp_debug & DEBUG_DSP_CMX) 704 printk(KERN_DEBUG 705 "%s removing %s from HFC conf %d because " 706 "two parties require only a PCM slot\n", 707 __func__, nextm->dsp->name, 708 nextm->dsp->hfc_conf); 709 dsp_cmx_hw_message(nextm->dsp, 710 MISDN_CTRL_HFC_CONF_SPLIT, 0, 0, 0, 0); 711 nextm->dsp->hfc_conf = -1; 712 } 713 /* if members have two banks (and not on the same chip) */ 714 if (member->dsp->features.pcm_banks > 1 && 715 nextm->dsp->features.pcm_banks > 1 && 716 member->dsp->features.hfc_id != 717 nextm->dsp->features.hfc_id) { 718 /* if both members have same slots with crossed banks */ 719 if (member->dsp->pcm_slot_tx >= 0 && 720 member->dsp->pcm_slot_rx >= 0 && 721 nextm->dsp->pcm_slot_tx >= 0 && 722 nextm->dsp->pcm_slot_rx >= 0 && 723 nextm->dsp->pcm_slot_tx == 724 member->dsp->pcm_slot_rx && 725 nextm->dsp->pcm_slot_rx == 726 member->dsp->pcm_slot_tx && 727 nextm->dsp->pcm_slot_tx == 728 member->dsp->pcm_slot_tx && 729 member->dsp->pcm_bank_tx != 730 member->dsp->pcm_bank_rx && 731 nextm->dsp->pcm_bank_tx != 732 nextm->dsp->pcm_bank_rx) { 733 /* all members have same slot */ 734 if (dsp_debug & DEBUG_DSP_CMX) 735 printk(KERN_DEBUG 736 "%s dsp %s & %s stay joined on " 737 "PCM slot %d bank %d (TX) bank %d " 738 "(RX) (on different chips)\n", 739 __func__, 740 member->dsp->name, 741 nextm->dsp->name, 742 member->dsp->pcm_slot_tx, 743 member->dsp->pcm_bank_tx, 744 member->dsp->pcm_bank_rx); 745 conf->hardware = 1; 746 conf->software = tx_data; 747 return; 748 } 749 /* find a new slot */ 750 memset(freeslots, 1, sizeof(freeslots)); 751 list_for_each_entry(dsp, &dsp_ilist, list) { 752 if (dsp != member->dsp && 753 dsp != nextm->dsp && 754 member->dsp->features.pcm_id == 755 dsp->features.pcm_id) { 756 if (dsp->pcm_slot_rx >= 0 && 757 dsp->pcm_slot_rx < 758 sizeof(freeslots)) 759 freeslots[dsp->pcm_slot_rx] = 0; 760 if (dsp->pcm_slot_tx >= 0 && 761 dsp->pcm_slot_tx < 762 sizeof(freeslots)) 763 freeslots[dsp->pcm_slot_tx] = 0; 764 } 765 } 766 i = 0; 767 ii = member->dsp->features.pcm_slots; 768 while (i < ii) { 769 if (freeslots[i]) 770 break; 771 i++; 772 } 773 if (i == ii) { 774 if (dsp_debug & DEBUG_DSP_CMX) 775 printk(KERN_DEBUG 776 "%s no slot available for " 777 "%s & %s\n", __func__, 778 member->dsp->name, 779 nextm->dsp->name); 780 /* no more slots available */ 781 goto conf_software; 782 } 783 /* assign free slot */ 784 member->dsp->pcm_slot_tx = i; 785 member->dsp->pcm_slot_rx = i; 786 nextm->dsp->pcm_slot_tx = i; 787 nextm->dsp->pcm_slot_rx = i; 788 member->dsp->pcm_bank_rx = 0; 789 member->dsp->pcm_bank_tx = 1; 790 nextm->dsp->pcm_bank_rx = 1; 791 nextm->dsp->pcm_bank_tx = 0; 792 if (dsp_debug & DEBUG_DSP_CMX) 793 printk(KERN_DEBUG 794 "%s adding %s & %s to new PCM slot %d " 795 "(TX and RX on different chips) because " 796 "both members have not same slots\n", 797 __func__, 798 member->dsp->name, 799 nextm->dsp->name, 800 member->dsp->pcm_slot_tx); 801 dsp_cmx_hw_message(member->dsp, MISDN_CTRL_HFC_PCM_CONN, 802 member->dsp->pcm_slot_tx, member->dsp->pcm_bank_tx, 803 member->dsp->pcm_slot_rx, member->dsp->pcm_bank_rx); 804 dsp_cmx_hw_message(nextm->dsp, MISDN_CTRL_HFC_PCM_CONN, 805 nextm->dsp->pcm_slot_tx, nextm->dsp->pcm_bank_tx, 806 nextm->dsp->pcm_slot_rx, nextm->dsp->pcm_bank_rx); 807 conf->hardware = 1; 808 conf->software = tx_data; 809 return; 810 /* if members have one bank (or on the same chip) */ 811 } else { 812 /* if both members have different crossed slots */ 813 if (member->dsp->pcm_slot_tx >= 0 && 814 member->dsp->pcm_slot_rx >= 0 && 815 nextm->dsp->pcm_slot_tx >= 0 && 816 nextm->dsp->pcm_slot_rx >= 0 && 817 nextm->dsp->pcm_slot_tx == 818 member->dsp->pcm_slot_rx && 819 nextm->dsp->pcm_slot_rx == 820 member->dsp->pcm_slot_tx && 821 member->dsp->pcm_slot_tx != 822 member->dsp->pcm_slot_rx && 823 member->dsp->pcm_bank_tx == 0 && 824 member->dsp->pcm_bank_rx == 0 && 825 nextm->dsp->pcm_bank_tx == 0 && 826 nextm->dsp->pcm_bank_rx == 0) { 827 /* all members have same slot */ 828 if (dsp_debug & DEBUG_DSP_CMX) 829 printk(KERN_DEBUG 830 "%s dsp %s & %s stay joined on PCM " 831 "slot %d (TX) %d (RX) on same chip " 832 "or one bank PCM)\n", __func__, 833 member->dsp->name, 834 nextm->dsp->name, 835 member->dsp->pcm_slot_tx, 836 member->dsp->pcm_slot_rx); 837 conf->hardware = 1; 838 conf->software = tx_data; 839 return; 840 } 841 /* find two new slot */ 842 memset(freeslots, 1, sizeof(freeslots)); 843 list_for_each_entry(dsp, &dsp_ilist, list) { 844 if (dsp != member->dsp && 845 dsp != nextm->dsp && 846 member->dsp->features.pcm_id == 847 dsp->features.pcm_id) { 848 if (dsp->pcm_slot_rx >= 0 && 849 dsp->pcm_slot_rx < 850 sizeof(freeslots)) 851 freeslots[dsp->pcm_slot_rx] = 0; 852 if (dsp->pcm_slot_tx >= 0 && 853 dsp->pcm_slot_tx < 854 sizeof(freeslots)) 855 freeslots[dsp->pcm_slot_tx] = 0; 856 } 857 } 858 i1 = 0; 859 ii = member->dsp->features.pcm_slots; 860 while (i1 < ii) { 861 if (freeslots[i1]) 862 break; 863 i1++; 864 } 865 if (i1 == ii) { 866 if (dsp_debug & DEBUG_DSP_CMX) 867 printk(KERN_DEBUG 868 "%s no slot available " 869 "for %s & %s\n", __func__, 870 member->dsp->name, 871 nextm->dsp->name); 872 /* no more slots available */ 873 goto conf_software; 874 } 875 i2 = i1 + 1; 876 while (i2 < ii) { 877 if (freeslots[i2]) 878 break; 879 i2++; 880 } 881 if (i2 == ii) { 882 if (dsp_debug & DEBUG_DSP_CMX) 883 printk(KERN_DEBUG 884 "%s no slot available " 885 "for %s & %s\n", 886 __func__, 887 member->dsp->name, 888 nextm->dsp->name); 889 /* no more slots available */ 890 goto conf_software; 891 } 892 /* assign free slots */ 893 member->dsp->pcm_slot_tx = i1; 894 member->dsp->pcm_slot_rx = i2; 895 nextm->dsp->pcm_slot_tx = i2; 896 nextm->dsp->pcm_slot_rx = i1; 897 member->dsp->pcm_bank_rx = 0; 898 member->dsp->pcm_bank_tx = 0; 899 nextm->dsp->pcm_bank_rx = 0; 900 nextm->dsp->pcm_bank_tx = 0; 901 if (dsp_debug & DEBUG_DSP_CMX) 902 printk(KERN_DEBUG 903 "%s adding %s & %s to new PCM slot %d " 904 "(TX) %d (RX) on same chip or one bank " 905 "PCM, because both members have not " 906 "crossed slots\n", __func__, 907 member->dsp->name, 908 nextm->dsp->name, 909 member->dsp->pcm_slot_tx, 910 member->dsp->pcm_slot_rx); 911 dsp_cmx_hw_message(member->dsp, MISDN_CTRL_HFC_PCM_CONN, 912 member->dsp->pcm_slot_tx, member->dsp->pcm_bank_tx, 913 member->dsp->pcm_slot_rx, member->dsp->pcm_bank_rx); 914 dsp_cmx_hw_message(nextm->dsp, MISDN_CTRL_HFC_PCM_CONN, 915 nextm->dsp->pcm_slot_tx, nextm->dsp->pcm_bank_tx, 916 nextm->dsp->pcm_slot_rx, nextm->dsp->pcm_bank_rx); 917 conf->hardware = 1; 918 conf->software = tx_data; 919 return; 920 } 921 } 922 923 /* 924 * if we have more than two, we may check if we have a conference 925 * unit available on the chip. also all members must be on the same 926 */ 927 928 /* if not the same HFC chip */ 929 if (same_hfc < 0) { 930 if (dsp_debug & DEBUG_DSP_CMX) 931 printk(KERN_DEBUG 932 "%s conference %d cannot be formed, because " 933 "members are on different chips or not " 934 "on HFC chip\n", 935 __func__, conf->id); 936 goto conf_software; 937 } 938 939 /* for more than two members.. */ 940 941 /* if all members already have the same conference */ 942 if (all_conf) { 943 conf->hardware = 1; 944 conf->software = tx_data; 945 return; 946 } 947 948 /* 949 * if there is an existing conference, but not all members have joined 950 */ 951 if (current_conf >= 0) { 952 join_members: 953 list_for_each_entry(member, &conf->mlist, list) { 954 /* if no conference engine on our chip, change to 955 * software */ 956 if (!member->dsp->features.hfc_conf) 957 goto conf_software; 958 /* in case of hdlc, change to software */ 959 if (member->dsp->hdlc) 960 goto conf_software; 961 /* join to current conference */ 962 if (member->dsp->hfc_conf == current_conf) 963 continue; 964 /* get a free timeslot first */ 965 memset(freeslots, 1, sizeof(freeslots)); 966 list_for_each_entry(dsp, &dsp_ilist, list) { 967 /* 968 * not checking current member, because 969 * slot will be overwritten. 970 */ 971 if ( 972 dsp != member->dsp && 973 /* dsp must be on the same PCM */ 974 member->dsp->features.pcm_id == 975 dsp->features.pcm_id) { 976 /* dsp must be on a slot */ 977 if (dsp->pcm_slot_tx >= 0 && 978 dsp->pcm_slot_tx < 979 sizeof(freeslots)) 980 freeslots[dsp->pcm_slot_tx] = 0; 981 if (dsp->pcm_slot_rx >= 0 && 982 dsp->pcm_slot_rx < 983 sizeof(freeslots)) 984 freeslots[dsp->pcm_slot_rx] = 0; 985 } 986 } 987 i = 0; 988 ii = member->dsp->features.pcm_slots; 989 while (i < ii) { 990 if (freeslots[i]) 991 break; 992 i++; 993 } 994 if (i == ii) { 995 /* no more slots available */ 996 if (dsp_debug & DEBUG_DSP_CMX) 997 printk(KERN_DEBUG 998 "%s conference %d cannot be formed," 999 " because no slot free\n", 1000 __func__, conf->id); 1001 goto conf_software; 1002 } 1003 if (dsp_debug & DEBUG_DSP_CMX) 1004 printk(KERN_DEBUG 1005 "%s changing dsp %s to HW conference " 1006 "%d slot %d\n", __func__, 1007 member->dsp->name, current_conf, i); 1008 /* assign free slot & set PCM & join conf */ 1009 member->dsp->pcm_slot_tx = i; 1010 member->dsp->pcm_slot_rx = i; 1011 member->dsp->pcm_bank_tx = 2; /* loop */ 1012 member->dsp->pcm_bank_rx = 2; 1013 member->dsp->hfc_conf = current_conf; 1014 dsp_cmx_hw_message(member->dsp, MISDN_CTRL_HFC_PCM_CONN, 1015 i, 2, i, 2); 1016 dsp_cmx_hw_message(member->dsp, 1017 MISDN_CTRL_HFC_CONF_JOIN, current_conf, 0, 0, 0); 1018 } 1019 conf->hardware = 1; 1020 conf->software = tx_data; 1021 return; 1022 } 1023 1024 /* 1025 * no member is in a conference yet, so we find a free one 1026 */ 1027 memset(freeunits, 1, sizeof(freeunits)); 1028 list_for_each_entry(dsp, &dsp_ilist, list) { 1029 /* dsp must be on the same chip */ 1030 if (dsp->features.hfc_id == same_hfc && 1031 /* dsp must have joined a HW conference */ 1032 dsp->hfc_conf >= 0 && 1033 /* slot must be within range */ 1034 dsp->hfc_conf < 8) 1035 freeunits[dsp->hfc_conf] = 0; 1036 } 1037 i = 0; 1038 ii = 8; 1039 while (i < ii) { 1040 if (freeunits[i]) 1041 break; 1042 i++; 1043 } 1044 if (i == ii) { 1045 /* no more conferences available */ 1046 if (dsp_debug & DEBUG_DSP_CMX) 1047 printk(KERN_DEBUG 1048 "%s conference %d cannot be formed, because " 1049 "no conference number free\n", 1050 __func__, conf->id); 1051 goto conf_software; 1052 } 1053 /* join all members */ 1054 current_conf = i; 1055 goto join_members; 1056 } 1057 1058 1059 /* 1060 * conf_id != 0: join or change conference 1061 * conf_id == 0: split from conference if not already 1062 */ 1063 int 1064 dsp_cmx_conf(struct dsp *dsp, u32 conf_id) 1065 { 1066 int err; 1067 struct dsp_conf *conf; 1068 struct dsp_conf_member *member; 1069 1070 /* if conference doesn't change */ 1071 if (dsp->conf_id == conf_id) 1072 return 0; 1073 1074 /* first remove us from current conf */ 1075 if (dsp->conf_id) { 1076 if (dsp_debug & DEBUG_DSP_CMX) 1077 printk(KERN_DEBUG "removing us from conference %d\n", 1078 dsp->conf->id); 1079 /* remove us from conf */ 1080 conf = dsp->conf; 1081 err = dsp_cmx_del_conf_member(dsp); 1082 if (err) 1083 return err; 1084 dsp->conf_id = 0; 1085 1086 /* update hardware */ 1087 dsp_cmx_hardware(NULL, dsp); 1088 1089 /* conf now empty? */ 1090 if (list_empty(&conf->mlist)) { 1091 if (dsp_debug & DEBUG_DSP_CMX) 1092 printk(KERN_DEBUG 1093 "conference is empty, so we remove it.\n"); 1094 err = dsp_cmx_del_conf(conf); 1095 if (err) 1096 return err; 1097 } else { 1098 /* update members left on conf */ 1099 dsp_cmx_hardware(conf, NULL); 1100 } 1101 } 1102 1103 /* if split */ 1104 if (!conf_id) 1105 return 0; 1106 1107 /* now add us to conf */ 1108 if (dsp_debug & DEBUG_DSP_CMX) 1109 printk(KERN_DEBUG "searching conference %d\n", 1110 conf_id); 1111 conf = dsp_cmx_search_conf(conf_id); 1112 if (!conf) { 1113 if (dsp_debug & DEBUG_DSP_CMX) 1114 printk(KERN_DEBUG 1115 "conference doesn't exist yet, creating.\n"); 1116 /* the conference doesn't exist, so we create */ 1117 conf = dsp_cmx_new_conf(conf_id); 1118 if (!conf) 1119 return -EINVAL; 1120 } else if (!list_empty(&conf->mlist)) { 1121 member = list_entry(conf->mlist.next, struct dsp_conf_member, 1122 list); 1123 if (dsp->hdlc && !member->dsp->hdlc) { 1124 if (dsp_debug & DEBUG_DSP_CMX) 1125 printk(KERN_DEBUG 1126 "cannot join transparent conference.\n"); 1127 return -EINVAL; 1128 } 1129 if (!dsp->hdlc && member->dsp->hdlc) { 1130 if (dsp_debug & DEBUG_DSP_CMX) 1131 printk(KERN_DEBUG 1132 "cannot join hdlc conference.\n"); 1133 return -EINVAL; 1134 } 1135 } 1136 /* add conference member */ 1137 err = dsp_cmx_add_conf_member(dsp, conf); 1138 if (err) 1139 return err; 1140 dsp->conf_id = conf_id; 1141 1142 /* if we are alone, we do nothing! */ 1143 if (list_empty(&conf->mlist)) { 1144 if (dsp_debug & DEBUG_DSP_CMX) 1145 printk(KERN_DEBUG 1146 "we are alone in this conference, so exit.\n"); 1147 /* update hardware */ 1148 dsp_cmx_hardware(NULL, dsp); 1149 return 0; 1150 } 1151 1152 /* update members on conf */ 1153 dsp_cmx_hardware(conf, NULL); 1154 1155 return 0; 1156 } 1157 1158 #ifdef CMX_DELAY_DEBUG 1159 int delaycount; 1160 static void 1161 showdelay(struct dsp *dsp, int samples, int delay) 1162 { 1163 char bar[] = "--------------------------------------------------|"; 1164 int sdelay; 1165 1166 delaycount += samples; 1167 if (delaycount < 8000) 1168 return; 1169 delaycount = 0; 1170 1171 sdelay = delay * 50 / (dsp_poll << 2); 1172 1173 printk(KERN_DEBUG "DELAY (%s) %3d >%s\n", dsp->name, delay, 1174 sdelay > 50 ? "..." : bar + 50 - sdelay); 1175 } 1176 #endif 1177 1178 /* 1179 * audio data is received from card 1180 */ 1181 void 1182 dsp_cmx_receive(struct dsp *dsp, struct sk_buff *skb) 1183 { 1184 u8 *d, *p; 1185 int len = skb->len; 1186 struct mISDNhead *hh = mISDN_HEAD_P(skb); 1187 int w, i, ii; 1188 1189 /* check if we have sompen */ 1190 if (len < 1) 1191 return; 1192 1193 /* half of the buffer should be larger than maximum packet size */ 1194 if (len >= CMX_BUFF_HALF) { 1195 printk(KERN_ERR 1196 "%s line %d: packet from card is too large (%d bytes). " 1197 "please make card send smaller packets OR increase " 1198 "CMX_BUFF_SIZE\n", __FILE__, __LINE__, len); 1199 return; 1200 } 1201 1202 /* 1203 * initialize pointers if not already - 1204 * also add delay if requested by PH_SIGNAL 1205 */ 1206 if (dsp->rx_init) { 1207 dsp->rx_init = 0; 1208 if (dsp->features.unordered) { 1209 dsp->rx_R = (hh->id & CMX_BUFF_MASK); 1210 if (dsp->cmx_delay) 1211 dsp->rx_W = (dsp->rx_R + dsp->cmx_delay) 1212 & CMX_BUFF_MASK; 1213 else 1214 dsp->rx_W = (dsp->rx_R + (dsp_poll >> 1)) 1215 & CMX_BUFF_MASK; 1216 } else { 1217 dsp->rx_R = 0; 1218 if (dsp->cmx_delay) 1219 dsp->rx_W = dsp->cmx_delay; 1220 else 1221 dsp->rx_W = dsp_poll >> 1; 1222 } 1223 } 1224 /* if frame contains time code, write directly */ 1225 if (dsp->features.unordered) { 1226 dsp->rx_W = (hh->id & CMX_BUFF_MASK); 1227 /* printk(KERN_DEBUG "%s %08x\n", dsp->name, hh->id); */ 1228 } 1229 /* 1230 * if we underrun (or maybe overrun), 1231 * we set our new read pointer, and write silence to buffer 1232 */ 1233 if (((dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK) >= CMX_BUFF_HALF) { 1234 if (dsp_debug & DEBUG_DSP_CLOCK) 1235 printk(KERN_DEBUG 1236 "cmx_receive(dsp=%lx): UNDERRUN (or overrun the " 1237 "maximum delay), adjusting read pointer! " 1238 "(inst %s)\n", (u_long)dsp, dsp->name); 1239 /* flush rx buffer and set delay to dsp_poll / 2 */ 1240 if (dsp->features.unordered) { 1241 dsp->rx_R = (hh->id & CMX_BUFF_MASK); 1242 if (dsp->cmx_delay) 1243 dsp->rx_W = (dsp->rx_R + dsp->cmx_delay) 1244 & CMX_BUFF_MASK; 1245 else 1246 dsp->rx_W = (dsp->rx_R + (dsp_poll >> 1)) 1247 & CMX_BUFF_MASK; 1248 } else { 1249 dsp->rx_R = 0; 1250 if (dsp->cmx_delay) 1251 dsp->rx_W = dsp->cmx_delay; 1252 else 1253 dsp->rx_W = dsp_poll >> 1; 1254 } 1255 memset(dsp->rx_buff, dsp_silence, sizeof(dsp->rx_buff)); 1256 } 1257 /* if we have reached double delay, jump back to middle */ 1258 if (dsp->cmx_delay) 1259 if (((dsp->rx_W - dsp->rx_R) & CMX_BUFF_MASK) >= 1260 (dsp->cmx_delay << 1)) { 1261 if (dsp_debug & DEBUG_DSP_CLOCK) 1262 printk(KERN_DEBUG 1263 "cmx_receive(dsp=%lx): OVERRUN (because " 1264 "twice the delay is reached), adjusting " 1265 "read pointer! (inst %s)\n", 1266 (u_long)dsp, dsp->name); 1267 /* flush buffer */ 1268 if (dsp->features.unordered) { 1269 dsp->rx_R = (hh->id & CMX_BUFF_MASK); 1270 dsp->rx_W = (dsp->rx_R + dsp->cmx_delay) 1271 & CMX_BUFF_MASK; 1272 } else { 1273 dsp->rx_R = 0; 1274 dsp->rx_W = dsp->cmx_delay; 1275 } 1276 memset(dsp->rx_buff, dsp_silence, sizeof(dsp->rx_buff)); 1277 } 1278 1279 /* show where to write */ 1280 #ifdef CMX_DEBUG 1281 printk(KERN_DEBUG 1282 "cmx_receive(dsp=%lx): rx_R(dsp)=%05x rx_W(dsp)=%05x len=%d %s\n", 1283 (u_long)dsp, dsp->rx_R, dsp->rx_W, len, dsp->name); 1284 #endif 1285 1286 /* write data into rx_buffer */ 1287 p = skb->data; 1288 d = dsp->rx_buff; 1289 w = dsp->rx_W; 1290 i = 0; 1291 ii = len; 1292 while (i < ii) { 1293 d[w++ & CMX_BUFF_MASK] = *p++; 1294 i++; 1295 } 1296 1297 /* increase write-pointer */ 1298 dsp->rx_W = ((dsp->rx_W + len) & CMX_BUFF_MASK); 1299 #ifdef CMX_DELAY_DEBUG 1300 showdelay(dsp, len, (dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK); 1301 #endif 1302 } 1303 1304 1305 /* 1306 * send (mixed) audio data to card and control jitter 1307 */ 1308 static void 1309 dsp_cmx_send_member(struct dsp *dsp, int len, s32 *c, int members) 1310 { 1311 struct dsp_conf *conf = dsp->conf; 1312 struct dsp *member, *other; 1313 register s32 sample; 1314 u8 *d, *p, *q, *o_q; 1315 struct sk_buff *nskb, *txskb; 1316 int r, rr, t, tt, o_r, o_rr; 1317 int preload = 0; 1318 struct mISDNhead *hh, *thh; 1319 int tx_data_only = 0; 1320 1321 /* don't process if: */ 1322 if (!dsp->b_active) { /* if not active */ 1323 dsp->last_tx = 0; 1324 return; 1325 } 1326 if (((dsp->conf && dsp->conf->hardware) || /* hardware conf */ 1327 dsp->echo.hardware) && /* OR hardware echo */ 1328 dsp->tx_R == dsp->tx_W && /* AND no tx-data */ 1329 !(dsp->tone.tone && dsp->tone.software)) { /* AND not soft tones */ 1330 if (!dsp->tx_data) { /* no tx_data for user space required */ 1331 dsp->last_tx = 0; 1332 return; 1333 } 1334 if (dsp->conf && dsp->conf->software && dsp->conf->hardware) 1335 tx_data_only = 1; 1336 if (dsp->echo.software && dsp->echo.hardware) 1337 tx_data_only = 1; 1338 } 1339 1340 #ifdef CMX_DEBUG 1341 printk(KERN_DEBUG 1342 "SEND members=%d dsp=%s, conf=%p, rx_R=%05x rx_W=%05x\n", 1343 members, dsp->name, conf, dsp->rx_R, dsp->rx_W); 1344 #endif 1345 1346 /* preload if we have delay set */ 1347 if (dsp->cmx_delay && !dsp->last_tx) { 1348 preload = len; 1349 if (preload < 128) 1350 preload = 128; 1351 } 1352 1353 /* PREPARE RESULT */ 1354 nskb = mI_alloc_skb(len + preload, GFP_ATOMIC); 1355 if (!nskb) { 1356 printk(KERN_ERR 1357 "FATAL ERROR in mISDN_dsp.o: cannot alloc %d bytes\n", 1358 len + preload); 1359 return; 1360 } 1361 hh = mISDN_HEAD_P(nskb); 1362 hh->prim = PH_DATA_REQ; 1363 hh->id = 0; 1364 dsp->last_tx = 1; 1365 1366 /* set pointers, indexes and stuff */ 1367 member = dsp; 1368 p = dsp->tx_buff; /* transmit data */ 1369 q = dsp->rx_buff; /* received data */ 1370 d = skb_put(nskb, preload + len); /* result */ 1371 t = dsp->tx_R; /* tx-pointers */ 1372 tt = dsp->tx_W; 1373 r = dsp->rx_R; /* rx-pointers */ 1374 rr = (r + len) & CMX_BUFF_MASK; 1375 1376 /* preload with silence, if required */ 1377 if (preload) { 1378 memset(d, dsp_silence, preload); 1379 d += preload; 1380 } 1381 1382 /* PROCESS TONES/TX-DATA ONLY */ 1383 if (dsp->tone.tone && dsp->tone.software) { 1384 /* -> copy tone */ 1385 dsp_tone_copy(dsp, d, len); 1386 dsp->tx_R = 0; /* clear tx buffer */ 1387 dsp->tx_W = 0; 1388 goto send_packet; 1389 } 1390 /* if we have tx-data but do not use mixing */ 1391 if (!dsp->tx_mix && t != tt) { 1392 /* -> send tx-data and continue when not enough */ 1393 #ifdef CMX_TX_DEBUG 1394 sprintf(debugbuf, "TX sending (%04x-%04x)%p: ", t, tt, p); 1395 #endif 1396 while (r != rr && t != tt) { 1397 #ifdef CMX_TX_DEBUG 1398 if (strlen(debugbuf) < 48) 1399 sprintf(debugbuf + strlen(debugbuf), " %02x", 1400 p[t]); 1401 #endif 1402 *d++ = p[t]; /* write tx_buff */ 1403 t = (t + 1) & CMX_BUFF_MASK; 1404 r = (r + 1) & CMX_BUFF_MASK; 1405 } 1406 if (r == rr) { 1407 dsp->tx_R = t; 1408 #ifdef CMX_TX_DEBUG 1409 printk(KERN_DEBUG "%s\n", debugbuf); 1410 #endif 1411 goto send_packet; 1412 } 1413 } 1414 #ifdef CMX_TX_DEBUG 1415 printk(KERN_DEBUG "%s\n", debugbuf); 1416 #endif 1417 1418 /* PROCESS DATA (one member / no conf) */ 1419 if (!conf || members <= 1) { 1420 /* -> if echo is NOT enabled */ 1421 if (!dsp->echo.software) { 1422 /* -> send tx-data if available or use 0-volume */ 1423 while (r != rr && t != tt) { 1424 *d++ = p[t]; /* write tx_buff */ 1425 t = (t + 1) & CMX_BUFF_MASK; 1426 r = (r + 1) & CMX_BUFF_MASK; 1427 } 1428 if (r != rr) { 1429 if (dsp_debug & DEBUG_DSP_CLOCK) 1430 printk(KERN_DEBUG "%s: RX empty\n", 1431 __func__); 1432 memset(d, dsp_silence, (rr - r) & CMX_BUFF_MASK); 1433 } 1434 /* -> if echo is enabled */ 1435 } else { 1436 /* 1437 * -> mix tx-data with echo if available, 1438 * or use echo only 1439 */ 1440 while (r != rr && t != tt) { 1441 *d++ = dsp_audio_mix_law[(p[t] << 8) | q[r]]; 1442 t = (t + 1) & CMX_BUFF_MASK; 1443 r = (r + 1) & CMX_BUFF_MASK; 1444 } 1445 while (r != rr) { 1446 *d++ = q[r]; /* echo */ 1447 r = (r + 1) & CMX_BUFF_MASK; 1448 } 1449 } 1450 dsp->tx_R = t; 1451 goto send_packet; 1452 } 1453 /* PROCESS DATA (two members) */ 1454 #ifdef CMX_CONF_DEBUG 1455 if (0) { 1456 #else 1457 if (members == 2) { 1458 #endif 1459 /* "other" becomes other party */ 1460 other = (list_entry(conf->mlist.next, 1461 struct dsp_conf_member, list))->dsp; 1462 if (other == member) 1463 other = (list_entry(conf->mlist.prev, 1464 struct dsp_conf_member, list))->dsp; 1465 o_q = other->rx_buff; /* received data */ 1466 o_rr = (other->rx_R + len) & CMX_BUFF_MASK; 1467 /* end of rx-pointer */ 1468 o_r = (o_rr - rr + r) & CMX_BUFF_MASK; 1469 /* start rx-pointer at current read position*/ 1470 /* -> if echo is NOT enabled */ 1471 if (!dsp->echo.software) { 1472 /* 1473 * -> copy other member's rx-data, 1474 * if tx-data is available, mix 1475 */ 1476 while (o_r != o_rr && t != tt) { 1477 *d++ = dsp_audio_mix_law[(p[t] << 8) | o_q[o_r]]; 1478 t = (t + 1) & CMX_BUFF_MASK; 1479 o_r = (o_r + 1) & CMX_BUFF_MASK; 1480 } 1481 while (o_r != o_rr) { 1482 *d++ = o_q[o_r]; 1483 o_r = (o_r + 1) & CMX_BUFF_MASK; 1484 } 1485 /* -> if echo is enabled */ 1486 } else { 1487 /* 1488 * -> mix other member's rx-data with echo, 1489 * if tx-data is available, mix 1490 */ 1491 while (r != rr && t != tt) { 1492 sample = dsp_audio_law_to_s32[p[t]] + 1493 dsp_audio_law_to_s32[q[r]] + 1494 dsp_audio_law_to_s32[o_q[o_r]]; 1495 if (sample < -32768) 1496 sample = -32768; 1497 else if (sample > 32767) 1498 sample = 32767; 1499 *d++ = dsp_audio_s16_to_law[sample & 0xffff]; 1500 /* tx-data + rx_data + echo */ 1501 t = (t + 1) & CMX_BUFF_MASK; 1502 r = (r + 1) & CMX_BUFF_MASK; 1503 o_r = (o_r + 1) & CMX_BUFF_MASK; 1504 } 1505 while (r != rr) { 1506 *d++ = dsp_audio_mix_law[(q[r] << 8) | o_q[o_r]]; 1507 r = (r + 1) & CMX_BUFF_MASK; 1508 o_r = (o_r + 1) & CMX_BUFF_MASK; 1509 } 1510 } 1511 dsp->tx_R = t; 1512 goto send_packet; 1513 } 1514 /* PROCESS DATA (three or more members) */ 1515 /* -> if echo is NOT enabled */ 1516 if (!dsp->echo.software) { 1517 /* 1518 * -> subtract rx-data from conf-data, 1519 * if tx-data is available, mix 1520 */ 1521 while (r != rr && t != tt) { 1522 sample = dsp_audio_law_to_s32[p[t]] + *c++ - 1523 dsp_audio_law_to_s32[q[r]]; 1524 if (sample < -32768) 1525 sample = -32768; 1526 else if (sample > 32767) 1527 sample = 32767; 1528 *d++ = dsp_audio_s16_to_law[sample & 0xffff]; 1529 /* conf-rx+tx */ 1530 r = (r + 1) & CMX_BUFF_MASK; 1531 t = (t + 1) & CMX_BUFF_MASK; 1532 } 1533 while (r != rr) { 1534 sample = *c++ - dsp_audio_law_to_s32[q[r]]; 1535 if (sample < -32768) 1536 sample = -32768; 1537 else if (sample > 32767) 1538 sample = 32767; 1539 *d++ = dsp_audio_s16_to_law[sample & 0xffff]; 1540 /* conf-rx */ 1541 r = (r + 1) & CMX_BUFF_MASK; 1542 } 1543 /* -> if echo is enabled */ 1544 } else { 1545 /* 1546 * -> encode conf-data, if tx-data 1547 * is available, mix 1548 */ 1549 while (r != rr && t != tt) { 1550 sample = dsp_audio_law_to_s32[p[t]] + *c++; 1551 if (sample < -32768) 1552 sample = -32768; 1553 else if (sample > 32767) 1554 sample = 32767; 1555 *d++ = dsp_audio_s16_to_law[sample & 0xffff]; 1556 /* conf(echo)+tx */ 1557 t = (t + 1) & CMX_BUFF_MASK; 1558 r = (r + 1) & CMX_BUFF_MASK; 1559 } 1560 while (r != rr) { 1561 sample = *c++; 1562 if (sample < -32768) 1563 sample = -32768; 1564 else if (sample > 32767) 1565 sample = 32767; 1566 *d++ = dsp_audio_s16_to_law[sample & 0xffff]; 1567 /* conf(echo) */ 1568 r = (r + 1) & CMX_BUFF_MASK; 1569 } 1570 } 1571 dsp->tx_R = t; 1572 goto send_packet; 1573 1574 send_packet: 1575 /* 1576 * send tx-data if enabled - don't filter, 1577 * because we want what we send, not what we filtered 1578 */ 1579 if (dsp->tx_data) { 1580 if (tx_data_only) { 1581 hh->prim = DL_DATA_REQ; 1582 hh->id = 0; 1583 /* queue and trigger */ 1584 skb_queue_tail(&dsp->sendq, nskb); 1585 schedule_work(&dsp->workq); 1586 /* exit because only tx_data is used */ 1587 return; 1588 } else { 1589 txskb = mI_alloc_skb(len, GFP_ATOMIC); 1590 if (!txskb) { 1591 printk(KERN_ERR 1592 "FATAL ERROR in mISDN_dsp.o: " 1593 "cannot alloc %d bytes\n", len); 1594 } else { 1595 thh = mISDN_HEAD_P(txskb); 1596 thh->prim = DL_DATA_REQ; 1597 thh->id = 0; 1598 memcpy(skb_put(txskb, len), nskb->data + preload, 1599 len); 1600 /* queue (trigger later) */ 1601 skb_queue_tail(&dsp->sendq, txskb); 1602 } 1603 } 1604 } 1605 1606 /* send data only to card, if we don't just calculated tx_data */ 1607 /* adjust volume */ 1608 if (dsp->tx_volume) 1609 dsp_change_volume(nskb, dsp->tx_volume); 1610 /* pipeline */ 1611 if (dsp->pipeline.inuse) 1612 dsp_pipeline_process_tx(&dsp->pipeline, nskb->data, 1613 nskb->len); 1614 /* crypt */ 1615 if (dsp->bf_enable) 1616 dsp_bf_encrypt(dsp, nskb->data, nskb->len); 1617 /* queue and trigger */ 1618 skb_queue_tail(&dsp->sendq, nskb); 1619 schedule_work(&dsp->workq); 1620 } 1621 1622 static u32 jittercount; /* counter for jitter check */ 1623 struct timer_list dsp_spl_tl; 1624 unsigned long dsp_spl_jiffies; /* calculate the next time to fire */ 1625 static u16 dsp_count; /* last sample count */ 1626 static int dsp_count_valid; /* if we have last sample count */ 1627 1628 void 1629 dsp_cmx_send(void *arg) 1630 { 1631 struct dsp_conf *conf; 1632 struct dsp_conf_member *member; 1633 struct dsp *dsp; 1634 int mustmix, members; 1635 static s32 mixbuffer[MAX_POLL + 100]; 1636 s32 *c; 1637 u8 *p, *q; 1638 int r, rr; 1639 int jittercheck = 0, delay, i; 1640 u_long flags; 1641 u16 length, count; 1642 1643 /* lock */ 1644 spin_lock_irqsave(&dsp_lock, flags); 1645 1646 if (!dsp_count_valid) { 1647 dsp_count = mISDN_clock_get(); 1648 length = dsp_poll; 1649 dsp_count_valid = 1; 1650 } else { 1651 count = mISDN_clock_get(); 1652 length = count - dsp_count; 1653 dsp_count = count; 1654 } 1655 if (length > MAX_POLL + 100) 1656 length = MAX_POLL + 100; 1657 /* printk(KERN_DEBUG "len=%d dsp_count=0x%x\n", length, dsp_count); */ 1658 1659 /* 1660 * check if jitter needs to be checked (this is every second) 1661 */ 1662 jittercount += length; 1663 if (jittercount >= 8000) { 1664 jittercount -= 8000; 1665 jittercheck = 1; 1666 } 1667 1668 /* loop all members that do not require conference mixing */ 1669 list_for_each_entry(dsp, &dsp_ilist, list) { 1670 if (dsp->hdlc) 1671 continue; 1672 conf = dsp->conf; 1673 mustmix = 0; 1674 members = 0; 1675 if (conf) { 1676 members = count_list_member(&conf->mlist); 1677 #ifdef CMX_CONF_DEBUG 1678 if (conf->software && members > 1) 1679 #else 1680 if (conf->software && members > 2) 1681 #endif 1682 mustmix = 1; 1683 } 1684 1685 /* transmission required */ 1686 if (!mustmix) { 1687 dsp_cmx_send_member(dsp, length, mixbuffer, members); 1688 1689 /* 1690 * unused mixbuffer is given to prevent a 1691 * potential null-pointer-bug 1692 */ 1693 } 1694 } 1695 1696 /* loop all members that require conference mixing */ 1697 list_for_each_entry(conf, &conf_ilist, list) { 1698 /* count members and check hardware */ 1699 members = count_list_member(&conf->mlist); 1700 #ifdef CMX_CONF_DEBUG 1701 if (conf->software && members > 1) { 1702 #else 1703 if (conf->software && members > 2) { 1704 #endif 1705 /* check for hdlc conf */ 1706 member = list_entry(conf->mlist.next, 1707 struct dsp_conf_member, list); 1708 if (member->dsp->hdlc) 1709 continue; 1710 /* mix all data */ 1711 memset(mixbuffer, 0, length * sizeof(s32)); 1712 list_for_each_entry(member, &conf->mlist, list) { 1713 dsp = member->dsp; 1714 /* get range of data to mix */ 1715 c = mixbuffer; 1716 q = dsp->rx_buff; 1717 r = dsp->rx_R; 1718 rr = (r + length) & CMX_BUFF_MASK; 1719 /* add member's data */ 1720 while (r != rr) { 1721 *c++ += dsp_audio_law_to_s32[q[r]]; 1722 r = (r + 1) & CMX_BUFF_MASK; 1723 } 1724 } 1725 1726 /* process each member */ 1727 list_for_each_entry(member, &conf->mlist, list) { 1728 /* transmission */ 1729 dsp_cmx_send_member(member->dsp, length, 1730 mixbuffer, members); 1731 } 1732 } 1733 } 1734 1735 /* delete rx-data, increment buffers, change pointers */ 1736 list_for_each_entry(dsp, &dsp_ilist, list) { 1737 if (dsp->hdlc) 1738 continue; 1739 p = dsp->rx_buff; 1740 q = dsp->tx_buff; 1741 r = dsp->rx_R; 1742 /* move receive pointer when receiving */ 1743 if (!dsp->rx_is_off) { 1744 rr = (r + length) & CMX_BUFF_MASK; 1745 /* delete rx-data */ 1746 while (r != rr) { 1747 p[r] = dsp_silence; 1748 r = (r + 1) & CMX_BUFF_MASK; 1749 } 1750 /* increment rx-buffer pointer */ 1751 dsp->rx_R = r; /* write incremented read pointer */ 1752 } 1753 1754 /* check current rx_delay */ 1755 delay = (dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK; 1756 if (delay >= CMX_BUFF_HALF) 1757 delay = 0; /* will be the delay before next write */ 1758 /* check for lower delay */ 1759 if (delay < dsp->rx_delay[0]) 1760 dsp->rx_delay[0] = delay; 1761 /* check current tx_delay */ 1762 delay = (dsp->tx_W-dsp->tx_R) & CMX_BUFF_MASK; 1763 if (delay >= CMX_BUFF_HALF) 1764 delay = 0; /* will be the delay before next write */ 1765 /* check for lower delay */ 1766 if (delay < dsp->tx_delay[0]) 1767 dsp->tx_delay[0] = delay; 1768 if (jittercheck) { 1769 /* find the lowest of all rx_delays */ 1770 delay = dsp->rx_delay[0]; 1771 i = 1; 1772 while (i < MAX_SECONDS_JITTER_CHECK) { 1773 if (delay > dsp->rx_delay[i]) 1774 delay = dsp->rx_delay[i]; 1775 i++; 1776 } 1777 /* 1778 * remove rx_delay only if we have delay AND we 1779 * have not preset cmx_delay AND 1780 * the delay is greater dsp_poll 1781 */ 1782 if (delay > dsp_poll && !dsp->cmx_delay) { 1783 if (dsp_debug & DEBUG_DSP_CLOCK) 1784 printk(KERN_DEBUG 1785 "%s lowest rx_delay of %d bytes for" 1786 " dsp %s are now removed.\n", 1787 __func__, delay, 1788 dsp->name); 1789 r = dsp->rx_R; 1790 rr = (r + delay - (dsp_poll >> 1)) 1791 & CMX_BUFF_MASK; 1792 /* delete rx-data */ 1793 while (r != rr) { 1794 p[r] = dsp_silence; 1795 r = (r + 1) & CMX_BUFF_MASK; 1796 } 1797 /* increment rx-buffer pointer */ 1798 dsp->rx_R = r; 1799 /* write incremented read pointer */ 1800 } 1801 /* find the lowest of all tx_delays */ 1802 delay = dsp->tx_delay[0]; 1803 i = 1; 1804 while (i < MAX_SECONDS_JITTER_CHECK) { 1805 if (delay > dsp->tx_delay[i]) 1806 delay = dsp->tx_delay[i]; 1807 i++; 1808 } 1809 /* 1810 * remove delay only if we have delay AND we 1811 * have enabled tx_dejitter 1812 */ 1813 if (delay > dsp_poll && dsp->tx_dejitter) { 1814 if (dsp_debug & DEBUG_DSP_CLOCK) 1815 printk(KERN_DEBUG 1816 "%s lowest tx_delay of %d bytes for" 1817 " dsp %s are now removed.\n", 1818 __func__, delay, 1819 dsp->name); 1820 r = dsp->tx_R; 1821 rr = (r + delay - (dsp_poll >> 1)) 1822 & CMX_BUFF_MASK; 1823 /* delete tx-data */ 1824 while (r != rr) { 1825 q[r] = dsp_silence; 1826 r = (r + 1) & CMX_BUFF_MASK; 1827 } 1828 /* increment rx-buffer pointer */ 1829 dsp->tx_R = r; 1830 /* write incremented read pointer */ 1831 } 1832 /* scroll up delays */ 1833 i = MAX_SECONDS_JITTER_CHECK - 1; 1834 while (i) { 1835 dsp->rx_delay[i] = dsp->rx_delay[i - 1]; 1836 dsp->tx_delay[i] = dsp->tx_delay[i - 1]; 1837 i--; 1838 } 1839 dsp->tx_delay[0] = CMX_BUFF_HALF; /* (infinite) delay */ 1840 dsp->rx_delay[0] = CMX_BUFF_HALF; /* (infinite) delay */ 1841 } 1842 } 1843 1844 /* if next event would be in the past ... */ 1845 if ((s32)(dsp_spl_jiffies + dsp_tics-jiffies) <= 0) 1846 dsp_spl_jiffies = jiffies + 1; 1847 else 1848 dsp_spl_jiffies += dsp_tics; 1849 1850 dsp_spl_tl.expires = dsp_spl_jiffies; 1851 add_timer(&dsp_spl_tl); 1852 1853 /* unlock */ 1854 spin_unlock_irqrestore(&dsp_lock, flags); 1855 } 1856 1857 /* 1858 * audio data is transmitted from upper layer to the dsp 1859 */ 1860 void 1861 dsp_cmx_transmit(struct dsp *dsp, struct sk_buff *skb) 1862 { 1863 u_int w, ww; 1864 u8 *d, *p; 1865 int space; /* todo: , l = skb->len; */ 1866 #ifdef CMX_TX_DEBUG 1867 char debugbuf[256] = ""; 1868 #endif 1869 1870 /* check if there is enough space, and then copy */ 1871 w = dsp->tx_W; 1872 ww = dsp->tx_R; 1873 p = dsp->tx_buff; 1874 d = skb->data; 1875 space = (ww - w - 1) & CMX_BUFF_MASK; 1876 /* write-pointer should not overrun nor reach read pointer */ 1877 if (space < skb->len) { 1878 /* write to the space we have left */ 1879 ww = (ww - 1) & CMX_BUFF_MASK; /* end one byte prior tx_R */ 1880 if (dsp_debug & DEBUG_DSP_CLOCK) 1881 printk(KERN_DEBUG "%s: TX overflow space=%d skb->len=" 1882 "%d, w=0x%04x, ww=0x%04x\n", __func__, space, 1883 skb->len, w, ww); 1884 } else 1885 /* write until all byte are copied */ 1886 ww = (w + skb->len) & CMX_BUFF_MASK; 1887 dsp->tx_W = ww; 1888 1889 /* show current buffer */ 1890 #ifdef CMX_DEBUG 1891 printk(KERN_DEBUG 1892 "cmx_transmit(dsp=%lx) %d bytes to 0x%x-0x%x. %s\n", 1893 (u_long)dsp, (ww - w) & CMX_BUFF_MASK, w, ww, dsp->name); 1894 #endif 1895 1896 /* copy transmit data to tx-buffer */ 1897 #ifdef CMX_TX_DEBUG 1898 sprintf(debugbuf, "TX getting (%04x-%04x)%p: ", w, ww, p); 1899 #endif 1900 while (w != ww) { 1901 #ifdef CMX_TX_DEBUG 1902 if (strlen(debugbuf) < 48) 1903 sprintf(debugbuf + strlen(debugbuf), " %02x", *d); 1904 #endif 1905 p[w] = *d++; 1906 w = (w + 1) & CMX_BUFF_MASK; 1907 } 1908 #ifdef CMX_TX_DEBUG 1909 printk(KERN_DEBUG "%s\n", debugbuf); 1910 #endif 1911 1912 } 1913 1914 /* 1915 * hdlc data is received from card and sent to all members. 1916 */ 1917 void 1918 dsp_cmx_hdlc(struct dsp *dsp, struct sk_buff *skb) 1919 { 1920 struct sk_buff *nskb = NULL; 1921 struct dsp_conf_member *member; 1922 struct mISDNhead *hh; 1923 1924 /* not if not active */ 1925 if (!dsp->b_active) 1926 return; 1927 1928 /* check if we have sompen */ 1929 if (skb->len < 1) 1930 return; 1931 1932 /* no conf */ 1933 if (!dsp->conf) { 1934 /* in case of software echo */ 1935 if (dsp->echo.software) { 1936 nskb = skb_clone(skb, GFP_ATOMIC); 1937 if (nskb) { 1938 hh = mISDN_HEAD_P(nskb); 1939 hh->prim = PH_DATA_REQ; 1940 hh->id = 0; 1941 skb_queue_tail(&dsp->sendq, nskb); 1942 schedule_work(&dsp->workq); 1943 } 1944 } 1945 return; 1946 } 1947 /* in case of hardware conference */ 1948 if (dsp->conf->hardware) 1949 return; 1950 list_for_each_entry(member, &dsp->conf->mlist, list) { 1951 if (dsp->echo.software || member->dsp != dsp) { 1952 nskb = skb_clone(skb, GFP_ATOMIC); 1953 if (nskb) { 1954 hh = mISDN_HEAD_P(nskb); 1955 hh->prim = PH_DATA_REQ; 1956 hh->id = 0; 1957 skb_queue_tail(&member->dsp->sendq, nskb); 1958 schedule_work(&member->dsp->workq); 1959 } 1960 } 1961 } 1962 } 1963