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