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