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