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