2 * Author Andreas Eversberg (jolly@eversberg.eu)
3 * Based on source code structure by
4 * Karsten Keil (keil@isdn4linux.de)
6 * This file is (c) under GNU PUBLIC LICENSE
7 * For changes and modifications please read
8 * ../../../Documentation/isdn/mISDN.cert
10 * Thanks to Karsten Keil (great drivers)
11 * Cologne Chip (great chips)
14 * Real-time tone generation
16 * Real-time cross-connection and conferrence
17 * Compensate jitter due to system load and hardware fault.
18 * All features are done in kernel space and will be realized
19 * using hardware, if available and supported by chip set.
20 * Blowfish encryption/decryption
25 * The dsp module provides layer 2 for b-channels (64kbit). It provides
26 * transparent audio forwarding with special digital signal processing:
28 * - (1) generation of tones
29 * - (2) detection of dtmf tones
30 * - (3) crossconnecting and conferences (clocking)
31 * - (4) echo generation for delay test
32 * - (5) volume control
33 * - (6) disable receive data
35 * - (8) encryption/decryption
39 * ------upper layer------
43 * +-----+-------------+-----+
50 * |+---------+| +----+----+
53 * || Tones || | DTMF |
56 * |+----+----+| +----+----+
60 * +----+----+ +----+----+
63 * |TX Volume| |RX Volume|
66 * +----+----+ +----+----+
70 * +----+-------------+----+
73 * | Pipeline Processing |
76 * +----+-------------+----+
80 * +----+----+ +----+----+
83 * | Encrypt | | Decrypt |
86 * +----+----+ +----+----+
90 * ------card layer------
93 * Above you can see the logical data flow. If software is used to do the
94 * process, it is actually the real data flow. If hardware is used, data
95 * may not flow, but hardware commands to the card, to provide the data flow
98 * NOTE: The channel must be activated in order to make dsp work, even if
99 * no data flow to the upper layer is intended. Activation can be done
100 * after and before controlling the setting using PH_CONTROL requests.
102 * DTMF: Will be detected by hardware if possible. It is done before CMX
105 * Tones: Will be generated via software if endless looped audio fifos are
106 * not supported by hardware. Tones will override all data from CMX.
107 * It is not required to join a conference to use tones at any time.
109 * CMX: Is transparent when not used. When it is used, it will do
110 * crossconnections and conferences via software if not possible through
111 * hardware. If hardware capability is available, hardware is used.
113 * Echo: Is generated by CMX and is used to check performane of hard and
116 * The CMX has special functions for conferences with one, two and more
117 * members. It will allow different types of data flow. Receive and transmit
118 * data to/form upper layer may be swithed on/off individually without loosing
119 * features of CMX, Tones and DTMF.
121 * Echo Cancellation: Sometimes we like to cancel echo from the interface.
122 * Note that a VoIP call may not have echo caused by the IP phone. The echo
123 * is generated by the telephone line connected to it. Because the delay
124 * is high, it becomes an echo. RESULT: Echo Cachelation is required if
125 * both echo AND delay is applied to an interface.
126 * Remember that software CMX always generates a more or less delay.
128 * If all used features can be realized in hardware, and if transmit and/or
129 * receive data ist disabled, the card may not send/receive any data at all.
130 * Not receiving is usefull if only announcements are played. Not sending is
131 * usefull if an answering machine records audio. Not sending and receiving is
132 * usefull during most states of the call. If supported by hardware, tones
133 * will be played without cpu load. Small PBXs and NT-Mode applications will
134 * not need expensive hardware when processing calls.
139 * When data is received from upper or lower layer (card), the complete dsp
140 * module is locked by a global lock. This lock MUST lock irq, because it
141 * must lock timer events by DSP poll timer.
142 * When data is ready to be transmitted down, the data is queued and sent
143 * outside lock and timer event.
144 * PH_CONTROL must not change any settings, join or split conference members
145 * during process of data.
149 * It works quite the same as transparent, except that HDLC data is forwarded
150 * to all other conference members if no hardware bridging is possible.
151 * Send data will be writte to sendq. Sendq will be sent if confirm is received.
152 * Conference cannot join, if one member is not hdlc.
156 #include <linux/delay.h>
157 #include <linux/mISDNif.h>
158 #include <linux/mISDNdsp.h>
159 #include <linux/module.h>
160 #include <linux/vmalloc.h>
164 static const char *mISDN_dsp_revision
= "2.0";
169 static int dtmfthreshold
= 100;
171 MODULE_AUTHOR("Andreas Eversberg");
172 module_param(debug
, uint
, S_IRUGO
| S_IWUSR
);
173 module_param(options
, uint
, S_IRUGO
| S_IWUSR
);
174 module_param(poll
, uint
, S_IRUGO
| S_IWUSR
);
175 module_param(dtmfthreshold
, uint
, S_IRUGO
| S_IWUSR
);
176 MODULE_LICENSE("GPL");
178 /*int spinnest = 0;*/
180 spinlock_t dsp_lock
; /* global dsp lock */
181 struct list_head dsp_ilist
;
182 struct list_head conf_ilist
;
185 int dsp_poll
, dsp_tics
;
187 /* check if rx may be turned off or must be turned on */
189 dsp_rx_off_member(struct dsp
*dsp
)
191 struct mISDN_ctrl_req cq
;
194 memset(&cq
, 0, sizeof(cq
));
196 if (!dsp
->features_rx_off
)
200 if (!dsp
->rx_disabled
)
203 else if (dsp
->dtmf
.software
)
205 /* echo in software */
206 else if (dsp
->echo
.software
)
208 /* bridge in software */
209 else if (dsp
->conf
&& dsp
->conf
->software
)
211 /* data is not required by user space and not required
212 * for echo dtmf detection, soft-echo, soft-bridging */
214 if (rx_off
== dsp
->rx_is_off
)
218 if (dsp_debug
& DEBUG_DSP_CORE
)
219 printk(KERN_DEBUG
"%s: no peer, no rx_off\n",
223 cq
.op
= MISDN_CTRL_RX_OFF
;
225 if (dsp
->ch
.peer
->ctrl(dsp
->ch
.peer
, CONTROL_CHANNEL
, &cq
)) {
226 printk(KERN_DEBUG
"%s: 2nd CONTROL_CHANNEL failed\n",
230 dsp
->rx_is_off
= rx_off
;
231 if (dsp_debug
& DEBUG_DSP_CORE
)
232 printk(KERN_DEBUG
"%s: %s set rx_off = %d\n",
233 __func__
, dsp
->name
, rx_off
);
236 dsp_rx_off(struct dsp
*dsp
)
238 struct dsp_conf_member
*member
;
240 if (dsp_options
& DSP_OPT_NOHARDWARE
)
245 dsp_rx_off_member(dsp
);
248 /* check all members in conf */
249 list_for_each_entry(member
, &dsp
->conf
->mlist
, list
) {
250 dsp_rx_off_member(member
->dsp
);
254 /* enable "fill empty" feature */
256 dsp_fill_empty(struct dsp
*dsp
)
258 struct mISDN_ctrl_req cq
;
260 memset(&cq
, 0, sizeof(cq
));
263 if (dsp_debug
& DEBUG_DSP_CORE
)
264 printk(KERN_DEBUG
"%s: no peer, no fill_empty\n",
268 cq
.op
= MISDN_CTRL_FILL_EMPTY
;
270 if (dsp
->ch
.peer
->ctrl(dsp
->ch
.peer
, CONTROL_CHANNEL
, &cq
)) {
271 printk(KERN_DEBUG
"%s: CONTROL_CHANNEL failed\n",
275 if (dsp_debug
& DEBUG_DSP_CORE
)
276 printk(KERN_DEBUG
"%s: %s set fill_empty = 1\n",
277 __func__
, dsp
->name
);
281 dsp_control_req(struct dsp
*dsp
, struct mISDNhead
*hh
, struct sk_buff
*skb
)
283 struct sk_buff
*nskb
;
289 if (skb
->len
< sizeof(int))
290 printk(KERN_ERR
"%s: PH_CONTROL message too short\n", __func__
);
291 cont
= *((int *)skb
->data
);
292 len
= skb
->len
- sizeof(int);
293 data
= skb
->data
+ sizeof(int);
296 case DTMF_TONE_START
: /* turn on DTMF */
301 if (dsp_debug
& DEBUG_DSP_CORE
)
302 printk(KERN_DEBUG
"%s: start dtmf\n", __func__
);
303 if (len
== sizeof(int)) {
304 if (dsp_debug
& DEBUG_DSP_CORE
)
305 printk(KERN_NOTICE
"changing DTMF Threshold "
306 "to %d\n", *((int *)data
));
307 dsp
->dtmf
.treshold
= (*(int *)data
) * 10000;
310 dsp_dtmf_goertzel_init(dsp
);
312 /* check dtmf hardware */
313 dsp_dtmf_hardware(dsp
);
316 case DTMF_TONE_STOP
: /* turn off DTMF */
317 if (dsp_debug
& DEBUG_DSP_CORE
)
318 printk(KERN_DEBUG
"%s: stop dtmf\n", __func__
);
319 dsp
->dtmf
.hardware
= 0;
320 dsp
->dtmf
.software
= 0;
322 case DSP_CONF_JOIN
: /* join / update conference */
323 if (len
< sizeof(int)) {
327 if (*((u32
*)data
) == 0)
329 if (dsp_debug
& DEBUG_DSP_CORE
)
330 printk(KERN_DEBUG
"%s: join conference %d\n",
331 __func__
, *((u32
*)data
));
332 ret
= dsp_cmx_conf(dsp
, *((u32
*)data
));
333 /* dsp_cmx_hardware will also be called here */
335 if (dsp_debug
& DEBUG_DSP_CMX
)
338 case DSP_CONF_SPLIT
: /* remove from conference */
340 if (dsp_debug
& DEBUG_DSP_CORE
)
341 printk(KERN_DEBUG
"%s: release conference\n", __func__
);
342 ret
= dsp_cmx_conf(dsp
, 0);
343 /* dsp_cmx_hardware will also be called here */
344 if (dsp_debug
& DEBUG_DSP_CMX
)
348 case DSP_TONE_PATT_ON
: /* play tone */
353 if (len
< sizeof(int)) {
357 if (dsp_debug
& DEBUG_DSP_CORE
)
358 printk(KERN_DEBUG
"%s: turn tone 0x%x on\n",
359 __func__
, *((int *)skb
->data
));
360 ret
= dsp_tone(dsp
, *((int *)data
));
362 dsp_cmx_hardware(dsp
->conf
, dsp
);
368 case DSP_TONE_PATT_OFF
: /* stop tone */
373 if (dsp_debug
& DEBUG_DSP_CORE
)
374 printk(KERN_DEBUG
"%s: turn tone off\n", __func__
);
376 dsp_cmx_hardware(dsp
->conf
, dsp
);
378 /* reset tx buffers (user space data) */
383 case DSP_VOL_CHANGE_TX
: /* change volume */
388 if (len
< sizeof(int)) {
392 dsp
->tx_volume
= *((int *)data
);
393 if (dsp_debug
& DEBUG_DSP_CORE
)
394 printk(KERN_DEBUG
"%s: change tx vol to %d\n",
395 __func__
, dsp
->tx_volume
);
396 dsp_cmx_hardware(dsp
->conf
, dsp
);
397 dsp_dtmf_hardware(dsp
);
400 case DSP_VOL_CHANGE_RX
: /* change volume */
405 if (len
< sizeof(int)) {
409 dsp
->rx_volume
= *((int *)data
);
410 if (dsp_debug
& DEBUG_DSP_CORE
)
411 printk(KERN_DEBUG
"%s: change rx vol to %d\n",
412 __func__
, dsp
->tx_volume
);
413 dsp_cmx_hardware(dsp
->conf
, dsp
);
414 dsp_dtmf_hardware(dsp
);
417 case DSP_ECHO_ON
: /* enable echo */
418 dsp
->echo
.software
= 1; /* soft echo */
419 if (dsp_debug
& DEBUG_DSP_CORE
)
420 printk(KERN_DEBUG
"%s: enable cmx-echo\n", __func__
);
421 dsp_cmx_hardware(dsp
->conf
, dsp
);
423 if (dsp_debug
& DEBUG_DSP_CMX
)
426 case DSP_ECHO_OFF
: /* disable echo */
427 dsp
->echo
.software
= 0;
428 dsp
->echo
.hardware
= 0;
429 if (dsp_debug
& DEBUG_DSP_CORE
)
430 printk(KERN_DEBUG
"%s: disable cmx-echo\n", __func__
);
431 dsp_cmx_hardware(dsp
->conf
, dsp
);
433 if (dsp_debug
& DEBUG_DSP_CMX
)
436 case DSP_RECEIVE_ON
: /* enable receive to user space */
437 if (dsp_debug
& DEBUG_DSP_CORE
)
438 printk(KERN_DEBUG
"%s: enable receive to user "
439 "space\n", __func__
);
440 dsp
->rx_disabled
= 0;
443 case DSP_RECEIVE_OFF
: /* disable receive to user space */
444 if (dsp_debug
& DEBUG_DSP_CORE
)
445 printk(KERN_DEBUG
"%s: disable receive to "
446 "user space\n", __func__
);
447 dsp
->rx_disabled
= 1;
450 case DSP_MIX_ON
: /* enable mixing of tx data */
455 if (dsp_debug
& DEBUG_DSP_CORE
)
456 printk(KERN_DEBUG
"%s: enable mixing of "
457 "tx-data with conf mebers\n", __func__
);
459 dsp_cmx_hardware(dsp
->conf
, dsp
);
461 if (dsp_debug
& DEBUG_DSP_CMX
)
464 case DSP_MIX_OFF
: /* disable mixing of tx data */
469 if (dsp_debug
& DEBUG_DSP_CORE
)
470 printk(KERN_DEBUG
"%s: disable mixing of "
471 "tx-data with conf mebers\n", __func__
);
473 dsp_cmx_hardware(dsp
->conf
, dsp
);
475 if (dsp_debug
& DEBUG_DSP_CMX
)
478 case DSP_TXDATA_ON
: /* enable txdata */
480 if (dsp_debug
& DEBUG_DSP_CORE
)
481 printk(KERN_DEBUG
"%s: enable tx-data\n", __func__
);
482 dsp_cmx_hardware(dsp
->conf
, dsp
);
484 if (dsp_debug
& DEBUG_DSP_CMX
)
487 case DSP_TXDATA_OFF
: /* disable txdata */
489 if (dsp_debug
& DEBUG_DSP_CORE
)
490 printk(KERN_DEBUG
"%s: disable tx-data\n", __func__
);
491 dsp_cmx_hardware(dsp
->conf
, dsp
);
493 if (dsp_debug
& DEBUG_DSP_CMX
)
496 case DSP_DELAY
: /* use delay algorithm instead of dynamic
502 if (len
< sizeof(int)) {
506 dsp
->cmx_delay
= (*((int *)data
)) << 3;
507 /* miliseconds to samples */
508 if (dsp
->cmx_delay
>= (CMX_BUFF_HALF
>>1))
509 /* clip to half of maximum usable buffer
510 (half of half buffer) */
511 dsp
->cmx_delay
= (CMX_BUFF_HALF
>>1) - 1;
512 if (dsp_debug
& DEBUG_DSP_CORE
)
513 printk(KERN_DEBUG
"%s: use delay algorithm to "
514 "compensate jitter (%d samples)\n",
515 __func__
, dsp
->cmx_delay
);
517 case DSP_JITTER
: /* use dynamic jitter algorithm instead of
524 if (dsp_debug
& DEBUG_DSP_CORE
)
525 printk(KERN_DEBUG
"%s: use jitter algorithm to "
526 "compensate jitter\n", __func__
);
528 case DSP_TX_DEJITTER
: /* use dynamic jitter algorithm for tx-buffer */
533 dsp
->tx_dejitter
= 1;
534 if (dsp_debug
& DEBUG_DSP_CORE
)
535 printk(KERN_DEBUG
"%s: use dejitter on TX "
536 "buffer\n", __func__
);
538 case DSP_TX_DEJ_OFF
: /* use tx-buffer without dejittering*/
543 dsp
->tx_dejitter
= 0;
544 if (dsp_debug
& DEBUG_DSP_CORE
)
545 printk(KERN_DEBUG
"%s: use TX buffer without "
546 "dejittering\n", __func__
);
548 case DSP_PIPELINE_CFG
:
553 if (len
> 0 && ((char *)data
)[len
- 1]) {
554 printk(KERN_DEBUG
"%s: pipeline config string "
555 "is not NULL terminated!\n", __func__
);
558 dsp
->pipeline
.inuse
= 1;
559 dsp_cmx_hardware(dsp
->conf
, dsp
);
560 ret
= dsp_pipeline_build(&dsp
->pipeline
,
561 len
> 0 ? data
: NULL
);
562 dsp_cmx_hardware(dsp
->conf
, dsp
);
566 case DSP_BF_ENABLE_KEY
: /* turn blowfish on */
571 if (len
< 4 || len
> 56) {
575 if (dsp_debug
& DEBUG_DSP_CORE
)
576 printk(KERN_DEBUG
"%s: turn blowfish on (key "
577 "not shown)\n", __func__
);
578 ret
= dsp_bf_init(dsp
, (u8
*)data
, len
);
581 cont
= DSP_BF_ACCEPT
;
583 cont
= DSP_BF_REJECT
;
584 /* send indication if it worked to set it */
585 nskb
= _alloc_mISDN_skb(PH_CONTROL_IND
, MISDN_ID_ANY
,
586 sizeof(int), &cont
, GFP_ATOMIC
);
589 if (dsp
->up
->send(dsp
->up
, nskb
))
595 dsp_cmx_hardware(dsp
->conf
, dsp
);
596 dsp_dtmf_hardware(dsp
);
600 case DSP_BF_DISABLE
: /* turn blowfish off */
605 if (dsp_debug
& DEBUG_DSP_CORE
)
606 printk(KERN_DEBUG
"%s: turn blowfish off\n", __func__
);
608 dsp_cmx_hardware(dsp
->conf
, dsp
);
609 dsp_dtmf_hardware(dsp
);
613 if (dsp_debug
& DEBUG_DSP_CORE
)
614 printk(KERN_DEBUG
"%s: ctrl req %x unhandled\n",
622 get_features(struct mISDNchannel
*ch
)
624 struct dsp
*dsp
= container_of(ch
, struct dsp
, ch
);
625 struct mISDN_ctrl_req cq
;
628 if (dsp_debug
& DEBUG_DSP_CORE
)
629 printk(KERN_DEBUG
"%s: no peer, no features\n",
633 memset(&cq
, 0, sizeof(cq
));
634 cq
.op
= MISDN_CTRL_GETOP
;
635 if (ch
->peer
->ctrl(ch
->peer
, CONTROL_CHANNEL
, &cq
) < 0) {
636 printk(KERN_DEBUG
"%s: CONTROL_CHANNEL failed\n",
640 if (cq
.op
& MISDN_CTRL_RX_OFF
)
641 dsp
->features_rx_off
= 1;
642 if (cq
.op
& MISDN_CTRL_FILL_EMPTY
)
643 dsp
->features_fill_empty
= 1;
644 if (dsp_options
& DSP_OPT_NOHARDWARE
)
646 if ((cq
.op
& MISDN_CTRL_HW_FEATURES_OP
)) {
647 cq
.op
= MISDN_CTRL_HW_FEATURES
;
648 *((u_long
*)&cq
.p1
) = (u_long
)&dsp
->features
;
649 if (ch
->peer
->ctrl(ch
->peer
, CONTROL_CHANNEL
, &cq
)) {
650 printk(KERN_DEBUG
"%s: 2nd CONTROL_CHANNEL failed\n",
654 if (dsp_debug
& DEBUG_DSP_CORE
)
655 printk(KERN_DEBUG
"%s: features not supported for %s\n",
656 __func__
, dsp
->name
);
660 dsp_function(struct mISDNchannel
*ch
, struct sk_buff
*skb
)
662 struct dsp
*dsp
= container_of(ch
, struct dsp
, ch
);
663 struct mISDNhead
*hh
;
668 hh
= mISDN_HEAD_P(skb
);
672 dsp
->data_pending
= 0;
673 /* trigger next hdlc frame, if any */
675 spin_lock_irqsave(&dsp_lock
, flags
);
677 schedule_work(&dsp
->workq
);
678 spin_unlock_irqrestore(&dsp_lock
, flags
);
687 if (dsp
->rx_is_off
) {
688 if (dsp_debug
& DEBUG_DSP_CORE
)
689 printk(KERN_DEBUG
"%s: rx-data during rx_off"
691 __func__
, dsp
->name
);
695 spin_lock_irqsave(&dsp_lock
, flags
);
696 dsp_cmx_hdlc(dsp
, skb
);
697 spin_unlock_irqrestore(&dsp_lock
, flags
);
698 if (dsp
->rx_disabled
) {
699 /* if receive is not allowed */
702 hh
->prim
= DL_DATA_IND
;
704 return dsp
->up
->send(dsp
->up
, skb
);
708 spin_lock_irqsave(&dsp_lock
, flags
);
710 /* decrypt if enabled */
712 dsp_bf_decrypt(dsp
, skb
->data
, skb
->len
);
714 if (dsp
->pipeline
.inuse
)
715 dsp_pipeline_process_rx(&dsp
->pipeline
, skb
->data
,
717 /* change volume if requested */
719 dsp_change_volume(skb
, dsp
->rx_volume
);
720 /* check if dtmf soft decoding is turned on */
721 if (dsp
->dtmf
.software
) {
722 digits
= dsp_dtmf_goertzel_decode(dsp
, skb
->data
,
723 skb
->len
, (dsp_options
&DSP_OPT_ULAW
) ? 1 : 0);
725 /* we need to process receive data if software */
726 if (dsp
->conf
&& dsp
->conf
->software
) {
727 /* process data from card at cmx */
728 dsp_cmx_receive(dsp
, skb
);
731 spin_unlock_irqrestore(&dsp_lock
, flags
);
733 /* send dtmf result, if any */
737 struct sk_buff
*nskb
;
738 if (dsp_debug
& DEBUG_DSP_DTMF
)
739 printk(KERN_DEBUG
"%s: digit"
740 "(%c) to layer %s\n",
741 __func__
, *digits
, dsp
->name
);
742 k
= *digits
| DTMF_TONE_VAL
;
743 nskb
= _alloc_mISDN_skb(PH_CONTROL_IND
,
744 MISDN_ID_ANY
, sizeof(int), &k
,
757 if (dsp
->rx_disabled
) {
758 /* if receive is not allowed */
761 hh
->prim
= DL_DATA_IND
;
763 return dsp
->up
->send(dsp
->up
, skb
);
765 case (PH_CONTROL_IND
):
766 if (dsp_debug
& DEBUG_DSP_DTMFCOEFF
)
767 printk(KERN_DEBUG
"%s: PH_CONTROL INDICATION "
768 "received: %x (len %d) %s\n", __func__
,
769 hh
->id
, skb
->len
, dsp
->name
);
771 case (DTMF_HFC_COEF
): /* getting coefficients */
772 if (!dsp
->dtmf
.hardware
) {
773 if (dsp_debug
& DEBUG_DSP_DTMFCOEFF
)
774 printk(KERN_DEBUG
"%s: ignoring DTMF "
775 "coefficients from HFC\n",
779 digits
= dsp_dtmf_goertzel_decode(dsp
, skb
->data
,
783 struct sk_buff
*nskb
;
784 if (dsp_debug
& DEBUG_DSP_DTMF
)
785 printk(KERN_DEBUG
"%s: digit"
786 "(%c) to layer %s\n",
787 __func__
, *digits
, dsp
->name
);
788 k
= *digits
| DTMF_TONE_VAL
;
789 nskb
= _alloc_mISDN_skb(PH_CONTROL_IND
,
790 MISDN_ID_ANY
, sizeof(int), &k
,
803 case (HFC_VOL_CHANGE_TX
): /* change volume */
804 if (skb
->len
!= sizeof(int)) {
808 spin_lock_irqsave(&dsp_lock
, flags
);
809 dsp
->tx_volume
= *((int *)skb
->data
);
810 if (dsp_debug
& DEBUG_DSP_CORE
)
811 printk(KERN_DEBUG
"%s: change tx volume to "
812 "%d\n", __func__
, dsp
->tx_volume
);
813 dsp_cmx_hardware(dsp
->conf
, dsp
);
814 dsp_dtmf_hardware(dsp
);
816 spin_unlock_irqrestore(&dsp_lock
, flags
);
819 if (dsp_debug
& DEBUG_DSP_CORE
)
820 printk(KERN_DEBUG
"%s: ctrl ind %x unhandled "
821 "%s\n", __func__
, hh
->id
, dsp
->name
);
825 case (PH_ACTIVATE_IND
):
826 case (PH_ACTIVATE_CNF
):
827 if (dsp_debug
& DEBUG_DSP_CORE
)
828 printk(KERN_DEBUG
"%s: b_channel is now active %s\n",
829 __func__
, dsp
->name
);
830 /* bchannel now active */
831 spin_lock_irqsave(&dsp_lock
, flags
);
833 dsp
->data_pending
= 0;
835 /* rx_W and rx_R will be adjusted on first frame */
838 memset(dsp
->rx_buff
, 0, sizeof(dsp
->rx_buff
));
839 dsp_cmx_hardware(dsp
->conf
, dsp
);
840 dsp_dtmf_hardware(dsp
);
842 spin_unlock_irqrestore(&dsp_lock
, flags
);
843 if (dsp_debug
& DEBUG_DSP_CORE
)
844 printk(KERN_DEBUG
"%s: done with activation, sending "
845 "confirm to user space. %s\n", __func__
,
847 /* send activation to upper layer */
848 hh
->prim
= DL_ESTABLISH_CNF
;
850 return dsp
->up
->send(dsp
->up
, skb
);
852 case (PH_DEACTIVATE_IND
):
853 case (PH_DEACTIVATE_CNF
):
854 if (dsp_debug
& DEBUG_DSP_CORE
)
855 printk(KERN_DEBUG
"%s: b_channel is now inactive %s\n",
856 __func__
, dsp
->name
);
857 /* bchannel now inactive */
858 spin_lock_irqsave(&dsp_lock
, flags
);
860 dsp
->data_pending
= 0;
861 dsp_cmx_hardware(dsp
->conf
, dsp
);
863 spin_unlock_irqrestore(&dsp_lock
, flags
);
864 hh
->prim
= DL_RELEASE_CNF
;
866 return dsp
->up
->send(dsp
->up
, skb
);
877 if (!dsp
->b_active
) {
881 hh
->prim
= PH_DATA_REQ
;
882 spin_lock_irqsave(&dsp_lock
, flags
);
883 skb_queue_tail(&dsp
->sendq
, skb
);
884 schedule_work(&dsp
->workq
);
885 spin_unlock_irqrestore(&dsp_lock
, flags
);
888 /* send data to tx-buffer (if no tone is played) */
889 if (!dsp
->tone
.tone
) {
890 spin_lock_irqsave(&dsp_lock
, flags
);
891 dsp_cmx_transmit(dsp
, skb
);
892 spin_unlock_irqrestore(&dsp_lock
, flags
);
895 case (PH_CONTROL_REQ
):
896 spin_lock_irqsave(&dsp_lock
, flags
);
897 ret
= dsp_control_req(dsp
, hh
, skb
);
898 spin_unlock_irqrestore(&dsp_lock
, flags
);
900 case (DL_ESTABLISH_REQ
):
901 case (PH_ACTIVATE_REQ
):
902 if (dsp_debug
& DEBUG_DSP_CORE
)
903 printk(KERN_DEBUG
"%s: activating b_channel %s\n",
904 __func__
, dsp
->name
);
905 if (dsp
->dtmf
.hardware
|| dsp
->dtmf
.software
)
906 dsp_dtmf_goertzel_init(dsp
);
908 /* enable fill_empty feature */
909 if (dsp
->features_fill_empty
)
911 /* send ph_activate */
912 hh
->prim
= PH_ACTIVATE_REQ
;
914 return ch
->recv(ch
->peer
, skb
);
916 case (DL_RELEASE_REQ
):
917 case (PH_DEACTIVATE_REQ
):
918 if (dsp_debug
& DEBUG_DSP_CORE
)
919 printk(KERN_DEBUG
"%s: releasing b_channel %s\n",
920 __func__
, dsp
->name
);
921 spin_lock_irqsave(&dsp_lock
, flags
);
923 dsp
->tone
.hardware
= 0;
924 dsp
->tone
.software
= 0;
925 if (timer_pending(&dsp
->tone
.tl
))
926 del_timer(&dsp
->tone
.tl
);
928 dsp_cmx_conf(dsp
, 0); /* dsp_cmx_hardware will also be
930 skb_queue_purge(&dsp
->sendq
);
931 spin_unlock_irqrestore(&dsp_lock
, flags
);
932 hh
->prim
= PH_DEACTIVATE_REQ
;
934 return ch
->recv(ch
->peer
, skb
);
937 if (dsp_debug
& DEBUG_DSP_CORE
)
938 printk(KERN_DEBUG
"%s: msg %x unhandled %s\n",
939 __func__
, hh
->prim
, dsp
->name
);
948 dsp_ctrl(struct mISDNchannel
*ch
, u_int cmd
, void *arg
)
950 struct dsp
*dsp
= container_of(ch
, struct dsp
, ch
);
954 if (debug
& DEBUG_DSP_CTRL
)
955 printk(KERN_DEBUG
"%s:(%x)\n", __func__
, cmd
);
962 dsp
->ch
.peer
->ctrl(dsp
->ch
.peer
, CLOSE_CHANNEL
, NULL
);
964 /* wait until workqueue has finished,
965 * must lock here, or we may hit send-process currently
967 spin_lock_irqsave(&dsp_lock
, flags
);
969 spin_unlock_irqrestore(&dsp_lock
, flags
);
970 /* MUST not be locked, because it waits until queue is done. */
971 cancel_work_sync(&dsp
->workq
);
972 spin_lock_irqsave(&dsp_lock
, flags
);
973 if (timer_pending(&dsp
->tone
.tl
))
974 del_timer(&dsp
->tone
.tl
);
975 skb_queue_purge(&dsp
->sendq
);
976 if (dsp_debug
& DEBUG_DSP_CTRL
)
977 printk(KERN_DEBUG
"%s: releasing member %s\n",
978 __func__
, dsp
->name
);
980 dsp_cmx_conf(dsp
, 0); /* dsp_cmx_hardware will also be called
982 dsp_pipeline_destroy(&dsp
->pipeline
);
984 if (dsp_debug
& DEBUG_DSP_CTRL
)
985 printk(KERN_DEBUG
"%s: remove & destroy object %s\n",
986 __func__
, dsp
->name
);
987 list_del(&dsp
->list
);
988 spin_unlock_irqrestore(&dsp_lock
, flags
);
990 if (dsp_debug
& DEBUG_DSP_CTRL
)
991 printk(KERN_DEBUG
"%s: dsp instance released\n",
994 module_put(THIS_MODULE
);
1001 dsp_send_bh(struct work_struct
*work
)
1003 struct dsp
*dsp
= container_of(work
, struct dsp
, workq
);
1004 struct sk_buff
*skb
;
1005 struct mISDNhead
*hh
;
1007 if (dsp
->hdlc
&& dsp
->data_pending
)
1008 return; /* wait until data has been acknowledged */
1010 /* send queued data */
1011 while ((skb
= skb_dequeue(&dsp
->sendq
))) {
1012 /* in locked date, we must have still data in queue */
1013 if (dsp
->data_pending
) {
1014 if (dsp_debug
& DEBUG_DSP_CORE
)
1015 printk(KERN_DEBUG
"%s: fifo full %s, this is "
1016 "no bug!\n", __func__
, dsp
->name
);
1017 /* flush transparent data, if not acked */
1021 hh
= mISDN_HEAD_P(skb
);
1022 if (hh
->prim
== DL_DATA_REQ
) {
1023 /* send packet up */
1025 if (dsp
->up
->send(dsp
->up
, skb
))
1030 /* send packet down */
1032 dsp
->data_pending
= 1;
1033 if (dsp
->ch
.recv(dsp
->ch
.peer
, skb
)) {
1035 dsp
->data_pending
= 0;
1044 dspcreate(struct channel_req
*crq
)
1049 if (crq
->protocol
!= ISDN_P_B_L2DSP
1050 && crq
->protocol
!= ISDN_P_B_L2DSPHDLC
)
1051 return -EPROTONOSUPPORT
;
1052 ndsp
= vmalloc(sizeof(struct dsp
));
1054 printk(KERN_ERR
"%s: vmalloc struct dsp failed\n", __func__
);
1057 memset(ndsp
, 0, sizeof(struct dsp
));
1058 if (dsp_debug
& DEBUG_DSP_CTRL
)
1059 printk(KERN_DEBUG
"%s: creating new dsp instance\n", __func__
);
1061 /* default enabled */
1062 INIT_WORK(&ndsp
->workq
, (void *)dsp_send_bh
);
1063 skb_queue_head_init(&ndsp
->sendq
);
1064 ndsp
->ch
.send
= dsp_function
;
1065 ndsp
->ch
.ctrl
= dsp_ctrl
;
1067 crq
->ch
= &ndsp
->ch
;
1068 if (crq
->protocol
== ISDN_P_B_L2DSP
) {
1069 crq
->protocol
= ISDN_P_B_RAW
;
1072 crq
->protocol
= ISDN_P_B_HDLC
;
1075 if (!try_module_get(THIS_MODULE
))
1076 printk(KERN_WARNING
"%s:cannot get module\n",
1079 sprintf(ndsp
->name
, "DSP_C%x(0x%p)",
1080 ndsp
->up
->st
->dev
->id
+ 1, ndsp
);
1081 /* set frame size to start */
1082 ndsp
->features
.hfc_id
= -1; /* current PCM id */
1083 ndsp
->features
.pcm_id
= -1; /* current PCM id */
1084 ndsp
->pcm_slot_rx
= -1; /* current CPM slot */
1085 ndsp
->pcm_slot_tx
= -1;
1086 ndsp
->pcm_bank_rx
= -1;
1087 ndsp
->pcm_bank_tx
= -1;
1088 ndsp
->hfc_conf
= -1; /* current conference number */
1089 /* set tone timer */
1090 ndsp
->tone
.tl
.function
= (void *)dsp_tone_timeout
;
1091 ndsp
->tone
.tl
.data
= (long) ndsp
;
1092 init_timer(&ndsp
->tone
.tl
);
1094 if (dtmfthreshold
< 20 || dtmfthreshold
> 500)
1095 dtmfthreshold
= 200;
1096 ndsp
->dtmf
.treshold
= dtmfthreshold
*10000;
1098 /* init pipeline append to list */
1099 spin_lock_irqsave(&dsp_lock
, flags
);
1100 dsp_pipeline_init(&ndsp
->pipeline
);
1101 list_add_tail(&ndsp
->list
, &dsp_ilist
);
1102 spin_unlock_irqrestore(&dsp_lock
, flags
);
1108 static struct Bprotocol DSP
= {
1109 .Bprotocols
= (1 << (ISDN_P_B_L2DSP
& ISDN_P_B_MASK
))
1110 | (1 << (ISDN_P_B_L2DSPHDLC
& ISDN_P_B_MASK
)),
1115 static int dsp_init(void)
1120 printk(KERN_INFO
"DSP modul %s\n", mISDN_dsp_revision
);
1122 dsp_options
= options
;
1125 /* set packet size */
1128 if (dsp_poll
> MAX_POLL
) {
1129 printk(KERN_ERR
"%s: Wrong poll value (%d), use %d "
1130 "maximum.\n", __func__
, poll
, MAX_POLL
);
1135 printk(KERN_ERR
"%s: Wrong poll value (%d), use 8 "
1136 "minimum.\n", __func__
, dsp_poll
);
1140 dsp_tics
= poll
* HZ
/ 8000;
1141 if (dsp_tics
* 8000 != poll
* HZ
) {
1142 printk(KERN_INFO
"mISDN_dsp: Cannot clock every %d "
1143 "samples (0,125 ms). It is not a multiple of "
1144 "%d HZ.\n", poll
, HZ
);
1150 while (poll
<= MAX_POLL
) {
1151 tics
= (poll
* HZ
) / 8000;
1152 if (tics
* 8000 == poll
* HZ
) {
1161 if (dsp_poll
== 0) {
1162 printk(KERN_INFO
"mISDN_dsp: There is no multiple of kernel "
1163 "clock that equals exactly the duration of 8-256 "
1164 "samples. (Choose kernel clock speed like 100, 250, "
1169 printk(KERN_INFO
"mISDN_dsp: DSP clocks every %d samples. This equals "
1170 "%d jiffies.\n", dsp_poll
, dsp_tics
);
1172 spin_lock_init(&dsp_lock
);
1173 INIT_LIST_HEAD(&dsp_ilist
);
1174 INIT_LIST_HEAD(&conf_ilist
);
1176 /* init conversion tables */
1177 dsp_audio_generate_law_tables();
1178 dsp_silence
= (dsp_options
&DSP_OPT_ULAW
) ? 0xff : 0x2a;
1179 dsp_audio_law_to_s32
= (dsp_options
&DSP_OPT_ULAW
) ?
1180 dsp_audio_ulaw_to_s32
: dsp_audio_alaw_to_s32
;
1181 dsp_audio_generate_s2law_table();
1182 dsp_audio_generate_seven();
1183 dsp_audio_generate_mix_table();
1184 if (dsp_options
& DSP_OPT_ULAW
)
1185 dsp_audio_generate_ulaw_samples();
1186 dsp_audio_generate_volume_changes();
1188 err
= dsp_pipeline_module_init();
1190 printk(KERN_ERR
"mISDN_dsp: Can't initialize pipeline, "
1191 "error(%d)\n", err
);
1195 err
= mISDN_register_Bprotocol(&DSP
);
1197 printk(KERN_ERR
"Can't register %s error(%d)\n", DSP
.name
, err
);
1201 /* set sample timer */
1202 dsp_spl_tl
.function
= (void *)dsp_cmx_send
;
1203 dsp_spl_tl
.data
= 0;
1204 init_timer(&dsp_spl_tl
);
1205 dsp_spl_tl
.expires
= jiffies
+ dsp_tics
;
1206 dsp_spl_jiffies
= dsp_spl_tl
.expires
;
1207 add_timer(&dsp_spl_tl
);
1213 static void dsp_cleanup(void)
1215 mISDN_unregister_Bprotocol(&DSP
);
1217 if (timer_pending(&dsp_spl_tl
))
1218 del_timer(&dsp_spl_tl
);
1220 if (!list_empty(&dsp_ilist
)) {
1221 printk(KERN_ERR
"mISDN_dsp: Audio DSP object inst list not "
1224 if (!list_empty(&conf_ilist
)) {
1225 printk(KERN_ERR
"mISDN_dsp: Conference list not empty. Not "
1226 "all memory freed.\n");
1229 dsp_pipeline_module_exit();
1232 module_init(dsp_init
);
1233 module_exit(dsp_cleanup
);