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