1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154#include <linux/delay.h>
155#include <linux/gfp.h>
156#include <linux/mISDNif.h>
157#include <linux/mISDNdsp.h>
158#include <linux/module.h>
159#include <linux/vmalloc.h>
160#include "core.h"
161#include "dsp.h"
162
163static const char *mISDN_dsp_revision = "2.0";
164
165static int debug;
166static int options;
167static int poll;
168static int dtmfthreshold = 100;
169
170MODULE_AUTHOR("Andreas Eversberg");
171module_param(debug, uint, S_IRUGO | S_IWUSR);
172module_param(options, uint, S_IRUGO | S_IWUSR);
173module_param(poll, uint, S_IRUGO | S_IWUSR);
174module_param(dtmfthreshold, uint, S_IRUGO | S_IWUSR);
175MODULE_LICENSE("GPL");
176
177
178
179spinlock_t dsp_lock;
180struct list_head dsp_ilist;
181struct list_head conf_ilist;
182int dsp_debug;
183int dsp_options;
184int dsp_poll, dsp_tics;
185
186
187static void
188dsp_rx_off_member(struct dsp *dsp)
189{
190 struct mISDN_ctrl_req cq;
191 int rx_off = 1;
192
193 memset(&cq, 0, sizeof(cq));
194
195 if (!dsp->features_rx_off)
196 return;
197
198
199 if (!dsp->rx_disabled)
200 rx_off = 0;
201
202 else if (dsp->dtmf.software)
203 rx_off = 0;
204
205 else if (dsp->echo.software)
206 rx_off = 0;
207
208 else if (dsp->conf && dsp->conf->software)
209 rx_off = 0;
210
211
212
213 if (rx_off == dsp->rx_is_off)
214 return;
215
216 if (!dsp->ch.peer) {
217 if (dsp_debug & DEBUG_DSP_CORE)
218 printk(KERN_DEBUG "%s: no peer, no rx_off\n",
219 __func__);
220 return;
221 }
222 cq.op = MISDN_CTRL_RX_OFF;
223 cq.p1 = rx_off;
224 if (dsp->ch.peer->ctrl(dsp->ch.peer, CONTROL_CHANNEL, &cq)) {
225 printk(KERN_DEBUG "%s: 2nd CONTROL_CHANNEL failed\n",
226 __func__);
227 return;
228 }
229 dsp->rx_is_off = rx_off;
230 if (dsp_debug & DEBUG_DSP_CORE)
231 printk(KERN_DEBUG "%s: %s set rx_off = %d\n",
232 __func__, dsp->name, rx_off);
233}
234static void
235dsp_rx_off(struct dsp *dsp)
236{
237 struct dsp_conf_member *member;
238
239 if (dsp_options & DSP_OPT_NOHARDWARE)
240 return;
241
242
243 if (!dsp->conf) {
244 dsp_rx_off_member(dsp);
245 return;
246 }
247
248 list_for_each_entry(member, &dsp->conf->mlist, list) {
249 dsp_rx_off_member(member->dsp);
250 }
251}
252
253
254static void
255dsp_fill_empty(struct dsp *dsp)
256{
257 struct mISDN_ctrl_req cq;
258
259 memset(&cq, 0, sizeof(cq));
260
261 if (!dsp->ch.peer) {
262 if (dsp_debug & DEBUG_DSP_CORE)
263 printk(KERN_DEBUG "%s: no peer, no fill_empty\n",
264 __func__);
265 return;
266 }
267 cq.op = MISDN_CTRL_FILL_EMPTY;
268 cq.p1 = 1;
269 cq.p2 = dsp_silence;
270 if (dsp->ch.peer->ctrl(dsp->ch.peer, CONTROL_CHANNEL, &cq)) {
271 printk(KERN_DEBUG "%s: CONTROL_CHANNEL failed\n",
272 __func__);
273 return;
274 }
275 if (dsp_debug & DEBUG_DSP_CORE)
276 printk(KERN_DEBUG "%s: %s set fill_empty = 1\n",
277 __func__, dsp->name);
278}
279
280static int
281dsp_control_req(struct dsp *dsp, struct mISDNhead *hh, struct sk_buff *skb)
282{
283 struct sk_buff *nskb;
284 int ret = 0;
285 int cont;
286 u8 *data;
287 int len;
288
289 if (skb->len < sizeof(int)) {
290 printk(KERN_ERR "%s: PH_CONTROL message too short\n", __func__);
291 return -EINVAL;
292 }
293 cont = *((int *)skb->data);
294 len = skb->len - sizeof(int);
295 data = skb->data + sizeof(int);
296
297 switch (cont) {
298 case DTMF_TONE_START:
299 if (dsp->hdlc) {
300 ret = -EINVAL;
301 break;
302 }
303 if (dsp_debug & DEBUG_DSP_CORE)
304 printk(KERN_DEBUG "%s: start dtmf\n", __func__);
305 if (len == sizeof(int)) {
306 if (dsp_debug & DEBUG_DSP_CORE)
307 printk(KERN_NOTICE "changing DTMF Threshold "
308 "to %d\n", *((int *)data));
309 dsp->dtmf.treshold = (*(int *)data) * 10000;
310 }
311 dsp->dtmf.enable = 1;
312
313 dsp_dtmf_goertzel_init(dsp);
314
315
316 dsp_dtmf_hardware(dsp);
317 dsp_rx_off(dsp);
318 break;
319 case DTMF_TONE_STOP:
320 if (dsp_debug & DEBUG_DSP_CORE)
321 printk(KERN_DEBUG "%s: stop dtmf\n", __func__);
322 dsp->dtmf.enable = 0;
323 dsp->dtmf.hardware = 0;
324 dsp->dtmf.software = 0;
325 break;
326 case DSP_CONF_JOIN:
327 if (len < sizeof(int)) {
328 ret = -EINVAL;
329 break;
330 }
331 if (*((u32 *)data) == 0)
332 goto conf_split;
333 if (dsp_debug & DEBUG_DSP_CORE)
334 printk(KERN_DEBUG "%s: join conference %d\n",
335 __func__, *((u32 *)data));
336 ret = dsp_cmx_conf(dsp, *((u32 *)data));
337
338 dsp_rx_off(dsp);
339 if (dsp_debug & DEBUG_DSP_CMX)
340 dsp_cmx_debug(dsp);
341 break;
342 case DSP_CONF_SPLIT:
343 conf_split:
344 if (dsp_debug & DEBUG_DSP_CORE)
345 printk(KERN_DEBUG "%s: release conference\n", __func__);
346 ret = dsp_cmx_conf(dsp, 0);
347
348 if (dsp_debug & DEBUG_DSP_CMX)
349 dsp_cmx_debug(dsp);
350 dsp_rx_off(dsp);
351 break;
352 case DSP_TONE_PATT_ON:
353 if (dsp->hdlc) {
354 ret = -EINVAL;
355 break;
356 }
357 if (len < sizeof(int)) {
358 ret = -EINVAL;
359 break;
360 }
361 if (dsp_debug & DEBUG_DSP_CORE)
362 printk(KERN_DEBUG "%s: turn tone 0x%x on\n",
363 __func__, *((int *)skb->data));
364 ret = dsp_tone(dsp, *((int *)data));
365 if (!ret) {
366 dsp_cmx_hardware(dsp->conf, dsp);
367 dsp_rx_off(dsp);
368 }
369 if (!dsp->tone.tone)
370 goto tone_off;
371 break;
372 case DSP_TONE_PATT_OFF:
373 if (dsp->hdlc) {
374 ret = -EINVAL;
375 break;
376 }
377 if (dsp_debug & DEBUG_DSP_CORE)
378 printk(KERN_DEBUG "%s: turn tone off\n", __func__);
379 dsp_tone(dsp, 0);
380 dsp_cmx_hardware(dsp->conf, dsp);
381 dsp_rx_off(dsp);
382
383 tone_off:
384 dsp->rx_W = 0;
385 dsp->rx_R = 0;
386 break;
387 case DSP_VOL_CHANGE_TX:
388 if (dsp->hdlc) {
389 ret = -EINVAL;
390 break;
391 }
392 if (len < sizeof(int)) {
393 ret = -EINVAL;
394 break;
395 }
396 dsp->tx_volume = *((int *)data);
397 if (dsp_debug & DEBUG_DSP_CORE)
398 printk(KERN_DEBUG "%s: change tx vol to %d\n",
399 __func__, dsp->tx_volume);
400 dsp_cmx_hardware(dsp->conf, dsp);
401 dsp_dtmf_hardware(dsp);
402 dsp_rx_off(dsp);
403 break;
404 case DSP_VOL_CHANGE_RX:
405 if (dsp->hdlc) {
406 ret = -EINVAL;
407 break;
408 }
409 if (len < sizeof(int)) {
410 ret = -EINVAL;
411 break;
412 }
413 dsp->rx_volume = *((int *)data);
414 if (dsp_debug & DEBUG_DSP_CORE)
415 printk(KERN_DEBUG "%s: change rx vol to %d\n",
416 __func__, dsp->tx_volume);
417 dsp_cmx_hardware(dsp->conf, dsp);
418 dsp_dtmf_hardware(dsp);
419 dsp_rx_off(dsp);
420 break;
421 case DSP_ECHO_ON:
422 dsp->echo.software = 1;
423 if (dsp_debug & DEBUG_DSP_CORE)
424 printk(KERN_DEBUG "%s: enable cmx-echo\n", __func__);
425 dsp_cmx_hardware(dsp->conf, dsp);
426 dsp_rx_off(dsp);
427 if (dsp_debug & DEBUG_DSP_CMX)
428 dsp_cmx_debug(dsp);
429 break;
430 case DSP_ECHO_OFF:
431 dsp->echo.software = 0;
432 dsp->echo.hardware = 0;
433 if (dsp_debug & DEBUG_DSP_CORE)
434 printk(KERN_DEBUG "%s: disable cmx-echo\n", __func__);
435 dsp_cmx_hardware(dsp->conf, dsp);
436 dsp_rx_off(dsp);
437 if (dsp_debug & DEBUG_DSP_CMX)
438 dsp_cmx_debug(dsp);
439 break;
440 case DSP_RECEIVE_ON:
441 if (dsp_debug & DEBUG_DSP_CORE)
442 printk(KERN_DEBUG "%s: enable receive to user "
443 "space\n", __func__);
444 dsp->rx_disabled = 0;
445 dsp_rx_off(dsp);
446 break;
447 case DSP_RECEIVE_OFF:
448 if (dsp_debug & DEBUG_DSP_CORE)
449 printk(KERN_DEBUG "%s: disable receive to "
450 "user space\n", __func__);
451 dsp->rx_disabled = 1;
452 dsp_rx_off(dsp);
453 break;
454 case DSP_MIX_ON:
455 if (dsp->hdlc) {
456 ret = -EINVAL;
457 break;
458 }
459 if (dsp_debug & DEBUG_DSP_CORE)
460 printk(KERN_DEBUG "%s: enable mixing of "
461 "tx-data with conf members\n", __func__);
462 dsp->tx_mix = 1;
463 dsp_cmx_hardware(dsp->conf, dsp);
464 dsp_rx_off(dsp);
465 if (dsp_debug & DEBUG_DSP_CMX)
466 dsp_cmx_debug(dsp);
467 break;
468 case DSP_MIX_OFF:
469 if (dsp->hdlc) {
470 ret = -EINVAL;
471 break;
472 }
473 if (dsp_debug & DEBUG_DSP_CORE)
474 printk(KERN_DEBUG "%s: disable mixing of "
475 "tx-data with conf members\n", __func__);
476 dsp->tx_mix = 0;
477 dsp_cmx_hardware(dsp->conf, dsp);
478 dsp_rx_off(dsp);
479 if (dsp_debug & DEBUG_DSP_CMX)
480 dsp_cmx_debug(dsp);
481 break;
482 case DSP_TXDATA_ON:
483 dsp->tx_data = 1;
484 if (dsp_debug & DEBUG_DSP_CORE)
485 printk(KERN_DEBUG "%s: enable tx-data\n", __func__);
486 dsp_cmx_hardware(dsp->conf, dsp);
487 dsp_rx_off(dsp);
488 if (dsp_debug & DEBUG_DSP_CMX)
489 dsp_cmx_debug(dsp);
490 break;
491 case DSP_TXDATA_OFF:
492 dsp->tx_data = 0;
493 if (dsp_debug & DEBUG_DSP_CORE)
494 printk(KERN_DEBUG "%s: disable tx-data\n", __func__);
495 dsp_cmx_hardware(dsp->conf, dsp);
496 dsp_rx_off(dsp);
497 if (dsp_debug & DEBUG_DSP_CMX)
498 dsp_cmx_debug(dsp);
499 break;
500 case DSP_DELAY:
501
502 if (dsp->hdlc) {
503 ret = -EINVAL;
504 break;
505 }
506 if (len < sizeof(int)) {
507 ret = -EINVAL;
508 break;
509 }
510 dsp->cmx_delay = (*((int *)data)) << 3;
511
512 if (dsp->cmx_delay >= (CMX_BUFF_HALF >> 1))
513
514
515 dsp->cmx_delay = (CMX_BUFF_HALF >> 1) - 1;
516 if (dsp_debug & DEBUG_DSP_CORE)
517 printk(KERN_DEBUG "%s: use delay algorithm to "
518 "compensate jitter (%d samples)\n",
519 __func__, dsp->cmx_delay);
520 break;
521 case DSP_JITTER:
522
523 if (dsp->hdlc) {
524 ret = -EINVAL;
525 break;
526 }
527 dsp->cmx_delay = 0;
528 if (dsp_debug & DEBUG_DSP_CORE)
529 printk(KERN_DEBUG "%s: use jitter algorithm to "
530 "compensate jitter\n", __func__);
531 break;
532 case DSP_TX_DEJITTER:
533 if (dsp->hdlc) {
534 ret = -EINVAL;
535 break;
536 }
537 dsp->tx_dejitter = 1;
538 if (dsp_debug & DEBUG_DSP_CORE)
539 printk(KERN_DEBUG "%s: use dejitter on TX "
540 "buffer\n", __func__);
541 break;
542 case DSP_TX_DEJ_OFF:
543 if (dsp->hdlc) {
544 ret = -EINVAL;
545 break;
546 }
547 dsp->tx_dejitter = 0;
548 if (dsp_debug & DEBUG_DSP_CORE)
549 printk(KERN_DEBUG "%s: use TX buffer without "
550 "dejittering\n", __func__);
551 break;
552 case DSP_PIPELINE_CFG:
553 if (dsp->hdlc) {
554 ret = -EINVAL;
555 break;
556 }
557 if (len > 0 && ((char *)data)[len - 1]) {
558 printk(KERN_DEBUG "%s: pipeline config string "
559 "is not NULL terminated!\n", __func__);
560 ret = -EINVAL;
561 } else {
562 dsp->pipeline.inuse = 1;
563 dsp_cmx_hardware(dsp->conf, dsp);
564 ret = dsp_pipeline_build(&dsp->pipeline,
565 len > 0 ? data : NULL);
566 dsp_cmx_hardware(dsp->conf, dsp);
567 dsp_rx_off(dsp);
568 }
569 break;
570 case DSP_BF_ENABLE_KEY:
571 if (dsp->hdlc) {
572 ret = -EINVAL;
573 break;
574 }
575 if (len < 4 || len > 56) {
576 ret = -EINVAL;
577 break;
578 }
579 if (dsp_debug & DEBUG_DSP_CORE)
580 printk(KERN_DEBUG "%s: turn blowfish on (key "
581 "not shown)\n", __func__);
582 ret = dsp_bf_init(dsp, (u8 *)data, len);
583
584 if (!ret)
585 cont = DSP_BF_ACCEPT;
586 else
587 cont = DSP_BF_REJECT;
588
589 nskb = _alloc_mISDN_skb(PH_CONTROL_IND, MISDN_ID_ANY,
590 sizeof(int), &cont, GFP_ATOMIC);
591 if (nskb) {
592 if (dsp->up) {
593 if (dsp->up->send(dsp->up, nskb))
594 dev_kfree_skb(nskb);
595 } else
596 dev_kfree_skb(nskb);
597 }
598 if (!ret) {
599 dsp_cmx_hardware(dsp->conf, dsp);
600 dsp_dtmf_hardware(dsp);
601 dsp_rx_off(dsp);
602 }
603 break;
604 case DSP_BF_DISABLE:
605 if (dsp->hdlc) {
606 ret = -EINVAL;
607 break;
608 }
609 if (dsp_debug & DEBUG_DSP_CORE)
610 printk(KERN_DEBUG "%s: turn blowfish off\n", __func__);
611 dsp_bf_cleanup(dsp);
612 dsp_cmx_hardware(dsp->conf, dsp);
613 dsp_dtmf_hardware(dsp);
614 dsp_rx_off(dsp);
615 break;
616 default:
617 if (dsp_debug & DEBUG_DSP_CORE)
618 printk(KERN_DEBUG "%s: ctrl req %x unhandled\n",
619 __func__, cont);
620 ret = -EINVAL;
621 }
622 return ret;
623}
624
625static void
626get_features(struct mISDNchannel *ch)
627{
628 struct dsp *dsp = container_of(ch, struct dsp, ch);
629 struct mISDN_ctrl_req cq;
630
631 if (!ch->peer) {
632 if (dsp_debug & DEBUG_DSP_CORE)
633 printk(KERN_DEBUG "%s: no peer, no features\n",
634 __func__);
635 return;
636 }
637 memset(&cq, 0, sizeof(cq));
638 cq.op = MISDN_CTRL_GETOP;
639 if (ch->peer->ctrl(ch->peer, CONTROL_CHANNEL, &cq) < 0) {
640 printk(KERN_DEBUG "%s: CONTROL_CHANNEL failed\n",
641 __func__);
642 return;
643 }
644 if (cq.op & MISDN_CTRL_RX_OFF)
645 dsp->features_rx_off = 1;
646 if (cq.op & MISDN_CTRL_FILL_EMPTY)
647 dsp->features_fill_empty = 1;
648 if (dsp_options & DSP_OPT_NOHARDWARE)
649 return;
650 if ((cq.op & MISDN_CTRL_HW_FEATURES_OP)) {
651 cq.op = MISDN_CTRL_HW_FEATURES;
652 *((u_long *)&cq.p1) = (u_long)&dsp->features;
653 if (ch->peer->ctrl(ch->peer, CONTROL_CHANNEL, &cq)) {
654 printk(KERN_DEBUG "%s: 2nd CONTROL_CHANNEL failed\n",
655 __func__);
656 }
657 } else
658 if (dsp_debug & DEBUG_DSP_CORE)
659 printk(KERN_DEBUG "%s: features not supported for %s\n",
660 __func__, dsp->name);
661}
662
663static int
664dsp_function(struct mISDNchannel *ch, struct sk_buff *skb)
665{
666 struct dsp *dsp = container_of(ch, struct dsp, ch);
667 struct mISDNhead *hh;
668 int ret = 0;
669 u8 *digits = NULL;
670 u_long flags;
671
672 hh = mISDN_HEAD_P(skb);
673 switch (hh->prim) {
674
675 case (PH_DATA_CNF):
676 dsp->data_pending = 0;
677
678 if (dsp->hdlc) {
679 spin_lock_irqsave(&dsp_lock, flags);
680 if (dsp->b_active)
681 schedule_work(&dsp->workq);
682 spin_unlock_irqrestore(&dsp_lock, flags);
683 }
684 break;
685 case (PH_DATA_IND):
686 case (DL_DATA_IND):
687 if (skb->len < 1) {
688 ret = -EINVAL;
689 break;
690 }
691 if (dsp->rx_is_off) {
692 if (dsp_debug & DEBUG_DSP_CORE)
693 printk(KERN_DEBUG "%s: rx-data during rx_off"
694 " for %s\n",
695 __func__, dsp->name);
696 }
697 if (dsp->hdlc) {
698
699 spin_lock_irqsave(&dsp_lock, flags);
700 dsp_cmx_hdlc(dsp, skb);
701 spin_unlock_irqrestore(&dsp_lock, flags);
702 if (dsp->rx_disabled) {
703
704 break;
705 }
706 hh->prim = DL_DATA_IND;
707 if (dsp->up)
708 return dsp->up->send(dsp->up, skb);
709 break;
710 }
711
712 spin_lock_irqsave(&dsp_lock, flags);
713
714
715 if (dsp->bf_enable)
716 dsp_bf_decrypt(dsp, skb->data, skb->len);
717
718 if (dsp->pipeline.inuse)
719 dsp_pipeline_process_rx(&dsp->pipeline, skb->data,
720 skb->len, hh->id);
721
722 if (dsp->rx_volume)
723 dsp_change_volume(skb, dsp->rx_volume);
724
725 if (dsp->dtmf.software) {
726 digits = dsp_dtmf_goertzel_decode(dsp, skb->data,
727 skb->len, (dsp_options & DSP_OPT_ULAW) ? 1 : 0);
728 }
729
730 if (dsp->conf && dsp->conf->software) {
731
732 dsp_cmx_receive(dsp, skb);
733 }
734
735 spin_unlock_irqrestore(&dsp_lock, flags);
736
737
738 if (digits) {
739 while (*digits) {
740 int k;
741 struct sk_buff *nskb;
742 if (dsp_debug & DEBUG_DSP_DTMF)
743 printk(KERN_DEBUG "%s: digit"
744 "(%c) to layer %s\n",
745 __func__, *digits, dsp->name);
746 k = *digits | DTMF_TONE_VAL;
747 nskb = _alloc_mISDN_skb(PH_CONTROL_IND,
748 MISDN_ID_ANY, sizeof(int), &k,
749 GFP_ATOMIC);
750 if (nskb) {
751 if (dsp->up) {
752 if (dsp->up->send(
753 dsp->up, nskb))
754 dev_kfree_skb(nskb);
755 } else
756 dev_kfree_skb(nskb);
757 }
758 digits++;
759 }
760 }
761 if (dsp->rx_disabled) {
762
763 break;
764 }
765 hh->prim = DL_DATA_IND;
766 if (dsp->up)
767 return dsp->up->send(dsp->up, skb);
768 break;
769 case (PH_CONTROL_IND):
770 if (dsp_debug & DEBUG_DSP_DTMFCOEFF)
771 printk(KERN_DEBUG "%s: PH_CONTROL INDICATION "
772 "received: %x (len %d) %s\n", __func__,
773 hh->id, skb->len, dsp->name);
774 switch (hh->id) {
775 case (DTMF_HFC_COEF):
776 if (!dsp->dtmf.hardware) {
777 if (dsp_debug & DEBUG_DSP_DTMFCOEFF)
778 printk(KERN_DEBUG "%s: ignoring DTMF "
779 "coefficients from HFC\n",
780 __func__);
781 break;
782 }
783 digits = dsp_dtmf_goertzel_decode(dsp, skb->data,
784 skb->len, 2);
785 while (*digits) {
786 int k;
787 struct sk_buff *nskb;
788 if (dsp_debug & DEBUG_DSP_DTMF)
789 printk(KERN_DEBUG "%s: digit"
790 "(%c) to layer %s\n",
791 __func__, *digits, dsp->name);
792 k = *digits | DTMF_TONE_VAL;
793 nskb = _alloc_mISDN_skb(PH_CONTROL_IND,
794 MISDN_ID_ANY, sizeof(int), &k,
795 GFP_ATOMIC);
796 if (nskb) {
797 if (dsp->up) {
798 if (dsp->up->send(
799 dsp->up, nskb))
800 dev_kfree_skb(nskb);
801 } else
802 dev_kfree_skb(nskb);
803 }
804 digits++;
805 }
806 break;
807 case (HFC_VOL_CHANGE_TX):
808 if (skb->len != sizeof(int)) {
809 ret = -EINVAL;
810 break;
811 }
812 spin_lock_irqsave(&dsp_lock, flags);
813 dsp->tx_volume = *((int *)skb->data);
814 if (dsp_debug & DEBUG_DSP_CORE)
815 printk(KERN_DEBUG "%s: change tx volume to "
816 "%d\n", __func__, dsp->tx_volume);
817 dsp_cmx_hardware(dsp->conf, dsp);
818 dsp_dtmf_hardware(dsp);
819 dsp_rx_off(dsp);
820 spin_unlock_irqrestore(&dsp_lock, flags);
821 break;
822 default:
823 if (dsp_debug & DEBUG_DSP_CORE)
824 printk(KERN_DEBUG "%s: ctrl ind %x unhandled "
825 "%s\n", __func__, hh->id, dsp->name);
826 ret = -EINVAL;
827 }
828 break;
829 case (PH_ACTIVATE_IND):
830 case (PH_ACTIVATE_CNF):
831 if (dsp_debug & DEBUG_DSP_CORE)
832 printk(KERN_DEBUG "%s: b_channel is now active %s\n",
833 __func__, dsp->name);
834
835 spin_lock_irqsave(&dsp_lock, flags);
836 dsp->b_active = 1;
837 dsp->data_pending = 0;
838 dsp->rx_init = 1;
839
840 dsp->rx_W = 0;
841 dsp->rx_R = 0;
842 memset(dsp->rx_buff, 0, sizeof(dsp->rx_buff));
843 dsp_cmx_hardware(dsp->conf, dsp);
844 dsp_dtmf_hardware(dsp);
845 dsp_rx_off(dsp);
846 spin_unlock_irqrestore(&dsp_lock, flags);
847 if (dsp_debug & DEBUG_DSP_CORE)
848 printk(KERN_DEBUG "%s: done with activation, sending "
849 "confirm to user space. %s\n", __func__,
850 dsp->name);
851
852 hh->prim = DL_ESTABLISH_CNF;
853 if (dsp->up)
854 return dsp->up->send(dsp->up, skb);
855 break;
856 case (PH_DEACTIVATE_IND):
857 case (PH_DEACTIVATE_CNF):
858 if (dsp_debug & DEBUG_DSP_CORE)
859 printk(KERN_DEBUG "%s: b_channel is now inactive %s\n",
860 __func__, dsp->name);
861
862 spin_lock_irqsave(&dsp_lock, flags);
863 dsp->b_active = 0;
864 dsp->data_pending = 0;
865 dsp_cmx_hardware(dsp->conf, dsp);
866 dsp_rx_off(dsp);
867 spin_unlock_irqrestore(&dsp_lock, flags);
868 hh->prim = DL_RELEASE_CNF;
869 if (dsp->up)
870 return dsp->up->send(dsp->up, skb);
871 break;
872
873 case (DL_DATA_REQ):
874 case (PH_DATA_REQ):
875 if (skb->len < 1) {
876 ret = -EINVAL;
877 break;
878 }
879 if (dsp->hdlc) {
880
881 if (!dsp->b_active) {
882 ret = -EIO;
883 break;
884 }
885 hh->prim = PH_DATA_REQ;
886 spin_lock_irqsave(&dsp_lock, flags);
887 skb_queue_tail(&dsp->sendq, skb);
888 schedule_work(&dsp->workq);
889 spin_unlock_irqrestore(&dsp_lock, flags);
890 return 0;
891 }
892
893 if (!dsp->tone.tone) {
894 spin_lock_irqsave(&dsp_lock, flags);
895 dsp_cmx_transmit(dsp, skb);
896 spin_unlock_irqrestore(&dsp_lock, flags);
897 }
898 break;
899 case (PH_CONTROL_REQ):
900 spin_lock_irqsave(&dsp_lock, flags);
901 ret = dsp_control_req(dsp, hh, skb);
902 spin_unlock_irqrestore(&dsp_lock, flags);
903 break;
904 case (DL_ESTABLISH_REQ):
905 case (PH_ACTIVATE_REQ):
906 if (dsp_debug & DEBUG_DSP_CORE)
907 printk(KERN_DEBUG "%s: activating b_channel %s\n",
908 __func__, dsp->name);
909 if (dsp->dtmf.hardware || dsp->dtmf.software)
910 dsp_dtmf_goertzel_init(dsp);
911 get_features(ch);
912
913 if (dsp->features_fill_empty)
914 dsp_fill_empty(dsp);
915
916 hh->prim = PH_ACTIVATE_REQ;
917 if (ch->peer)
918 return ch->recv(ch->peer, skb);
919 break;
920 case (DL_RELEASE_REQ):
921 case (PH_DEACTIVATE_REQ):
922 if (dsp_debug & DEBUG_DSP_CORE)
923 printk(KERN_DEBUG "%s: releasing b_channel %s\n",
924 __func__, dsp->name);
925 spin_lock_irqsave(&dsp_lock, flags);
926 dsp->tone.tone = 0;
927 dsp->tone.hardware = 0;
928 dsp->tone.software = 0;
929 if (timer_pending(&dsp->tone.tl))
930 del_timer(&dsp->tone.tl);
931 if (dsp->conf)
932 dsp_cmx_conf(dsp, 0);
933
934 skb_queue_purge(&dsp->sendq);
935 spin_unlock_irqrestore(&dsp_lock, flags);
936 hh->prim = PH_DEACTIVATE_REQ;
937 if (ch->peer)
938 return ch->recv(ch->peer, skb);
939 break;
940 default:
941 if (dsp_debug & DEBUG_DSP_CORE)
942 printk(KERN_DEBUG "%s: msg %x unhandled %s\n",
943 __func__, hh->prim, dsp->name);
944 ret = -EINVAL;
945 }
946 if (!ret)
947 dev_kfree_skb(skb);
948 return ret;
949}
950
951static int
952dsp_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
953{
954 struct dsp *dsp = container_of(ch, struct dsp, ch);
955 u_long flags;
956 int err = 0;
957
958 if (debug & DEBUG_DSP_CTRL)
959 printk(KERN_DEBUG "%s:(%x)\n", __func__, cmd);
960
961 switch (cmd) {
962 case OPEN_CHANNEL:
963 break;
964 case CLOSE_CHANNEL:
965 if (dsp->ch.peer)
966 dsp->ch.peer->ctrl(dsp->ch.peer, CLOSE_CHANNEL, NULL);
967
968
969
970
971 spin_lock_irqsave(&dsp_lock, flags);
972 dsp->b_active = 0;
973 spin_unlock_irqrestore(&dsp_lock, flags);
974
975 cancel_work_sync(&dsp->workq);
976 spin_lock_irqsave(&dsp_lock, flags);
977 if (timer_pending(&dsp->tone.tl))
978 del_timer(&dsp->tone.tl);
979 skb_queue_purge(&dsp->sendq);
980 if (dsp_debug & DEBUG_DSP_CTRL)
981 printk(KERN_DEBUG "%s: releasing member %s\n",
982 __func__, dsp->name);
983 dsp->b_active = 0;
984 dsp_cmx_conf(dsp, 0);
985
986 dsp_pipeline_destroy(&dsp->pipeline);
987
988 if (dsp_debug & DEBUG_DSP_CTRL)
989 printk(KERN_DEBUG "%s: remove & destroy object %s\n",
990 __func__, dsp->name);
991 list_del(&dsp->list);
992 spin_unlock_irqrestore(&dsp_lock, flags);
993
994 if (dsp_debug & DEBUG_DSP_CTRL)
995 printk(KERN_DEBUG "%s: dsp instance released\n",
996 __func__);
997 vfree(dsp);
998 module_put(THIS_MODULE);
999 break;
1000 }
1001 return err;
1002}
1003
1004static void
1005dsp_send_bh(struct work_struct *work)
1006{
1007 struct dsp *dsp = container_of(work, struct dsp, workq);
1008 struct sk_buff *skb;
1009 struct mISDNhead *hh;
1010
1011 if (dsp->hdlc && dsp->data_pending)
1012 return;
1013
1014
1015 while ((skb = skb_dequeue(&dsp->sendq))) {
1016
1017 if (dsp->data_pending) {
1018 if (dsp_debug & DEBUG_DSP_CORE)
1019 printk(KERN_DEBUG "%s: fifo full %s, this is "
1020 "no bug!\n", __func__, dsp->name);
1021
1022 dev_kfree_skb(skb);
1023 continue;
1024 }
1025 hh = mISDN_HEAD_P(skb);
1026 if (hh->prim == DL_DATA_REQ) {
1027
1028 if (dsp->up) {
1029 if (dsp->up->send(dsp->up, skb))
1030 dev_kfree_skb(skb);
1031 } else
1032 dev_kfree_skb(skb);
1033 } else {
1034
1035 if (dsp->ch.peer) {
1036 dsp->data_pending = 1;
1037 if (dsp->ch.recv(dsp->ch.peer, skb)) {
1038 dev_kfree_skb(skb);
1039 dsp->data_pending = 0;
1040 }
1041 } else
1042 dev_kfree_skb(skb);
1043 }
1044 }
1045}
1046
1047static int
1048dspcreate(struct channel_req *crq)
1049{
1050 struct dsp *ndsp;
1051 u_long flags;
1052
1053 if (crq->protocol != ISDN_P_B_L2DSP
1054 && crq->protocol != ISDN_P_B_L2DSPHDLC)
1055 return -EPROTONOSUPPORT;
1056 ndsp = vzalloc(sizeof(struct dsp));
1057 if (!ndsp) {
1058 printk(KERN_ERR "%s: vmalloc struct dsp failed\n", __func__);
1059 return -ENOMEM;
1060 }
1061 if (dsp_debug & DEBUG_DSP_CTRL)
1062 printk(KERN_DEBUG "%s: creating new dsp instance\n", __func__);
1063
1064
1065 INIT_WORK(&ndsp->workq, (void *)dsp_send_bh);
1066 skb_queue_head_init(&ndsp->sendq);
1067 ndsp->ch.send = dsp_function;
1068 ndsp->ch.ctrl = dsp_ctrl;
1069 ndsp->up = crq->ch;
1070 crq->ch = &ndsp->ch;
1071 if (crq->protocol == ISDN_P_B_L2DSP) {
1072 crq->protocol = ISDN_P_B_RAW;
1073 ndsp->hdlc = 0;
1074 } else {
1075 crq->protocol = ISDN_P_B_HDLC;
1076 ndsp->hdlc = 1;
1077 }
1078 if (!try_module_get(THIS_MODULE))
1079 printk(KERN_WARNING "%s:cannot get module\n",
1080 __func__);
1081
1082 sprintf(ndsp->name, "DSP_C%x(0x%p)",
1083 ndsp->up->st->dev->id + 1, ndsp);
1084
1085 ndsp->features.hfc_id = -1;
1086 ndsp->features.pcm_id = -1;
1087 ndsp->pcm_slot_rx = -1;
1088 ndsp->pcm_slot_tx = -1;
1089 ndsp->pcm_bank_rx = -1;
1090 ndsp->pcm_bank_tx = -1;
1091 ndsp->hfc_conf = -1;
1092
1093 timer_setup(&ndsp->tone.tl, dsp_tone_timeout, 0);
1094
1095 if (dtmfthreshold < 20 || dtmfthreshold > 500)
1096 dtmfthreshold = 200;
1097 ndsp->dtmf.treshold = dtmfthreshold * 10000;
1098
1099
1100 spin_lock_irqsave(&dsp_lock, flags);
1101 dsp_pipeline_init(&ndsp->pipeline);
1102 list_add_tail(&ndsp->list, &dsp_ilist);
1103 spin_unlock_irqrestore(&dsp_lock, flags);
1104
1105 return 0;
1106}
1107
1108
1109static struct Bprotocol DSP = {
1110 .Bprotocols = (1 << (ISDN_P_B_L2DSP & ISDN_P_B_MASK))
1111 | (1 << (ISDN_P_B_L2DSPHDLC & ISDN_P_B_MASK)),
1112 .name = "dsp",
1113 .create = dspcreate
1114};
1115
1116static int __init dsp_init(void)
1117{
1118 int err;
1119 int tics;
1120
1121 printk(KERN_INFO "DSP module %s\n", mISDN_dsp_revision);
1122
1123 dsp_options = options;
1124 dsp_debug = debug;
1125
1126
1127 dsp_poll = poll;
1128 if (dsp_poll) {
1129 if (dsp_poll > MAX_POLL) {
1130 printk(KERN_ERR "%s: Wrong poll value (%d), use %d "
1131 "maximum.\n", __func__, poll, MAX_POLL);
1132 err = -EINVAL;
1133 return err;
1134 }
1135 if (dsp_poll < 8) {
1136 printk(KERN_ERR "%s: Wrong poll value (%d), use 8 "
1137 "minimum.\n", __func__, dsp_poll);
1138 err = -EINVAL;
1139 return err;
1140 }
1141 dsp_tics = poll * HZ / 8000;
1142 if (dsp_tics * 8000 != poll * HZ) {
1143 printk(KERN_INFO "mISDN_dsp: Cannot clock every %d "
1144 "samples (0,125 ms). It is not a multiple of "
1145 "%d HZ.\n", poll, HZ);
1146 err = -EINVAL;
1147 return err;
1148 }
1149 } else {
1150 poll = 8;
1151 while (poll <= MAX_POLL) {
1152 tics = (poll * HZ) / 8000;
1153 if (tics * 8000 == poll * HZ) {
1154 dsp_tics = tics;
1155 dsp_poll = poll;
1156 if (poll >= 64)
1157 break;
1158 }
1159 poll++;
1160 }
1161 }
1162 if (dsp_poll == 0) {
1163 printk(KERN_INFO "mISDN_dsp: There is no multiple of kernel "
1164 "clock that equals exactly the duration of 8-256 "
1165 "samples. (Choose kernel clock speed like 100, 250, "
1166 "300, 1000)\n");
1167 err = -EINVAL;
1168 return err;
1169 }
1170 printk(KERN_INFO "mISDN_dsp: DSP clocks every %d samples. This equals "
1171 "%d jiffies.\n", dsp_poll, dsp_tics);
1172
1173 spin_lock_init(&dsp_lock);
1174 INIT_LIST_HEAD(&dsp_ilist);
1175 INIT_LIST_HEAD(&conf_ilist);
1176
1177
1178 dsp_audio_generate_law_tables();
1179 dsp_silence = (dsp_options & DSP_OPT_ULAW) ? 0xff : 0x2a;
1180 dsp_audio_law_to_s32 = (dsp_options & DSP_OPT_ULAW) ?
1181 dsp_audio_ulaw_to_s32 : dsp_audio_alaw_to_s32;
1182 dsp_audio_generate_s2law_table();
1183 dsp_audio_generate_seven();
1184 dsp_audio_generate_mix_table();
1185 if (dsp_options & DSP_OPT_ULAW)
1186 dsp_audio_generate_ulaw_samples();
1187 dsp_audio_generate_volume_changes();
1188
1189 err = dsp_pipeline_module_init();
1190 if (err) {
1191 printk(KERN_ERR "mISDN_dsp: Can't initialize pipeline, "
1192 "error(%d)\n", err);
1193 return err;
1194 }
1195
1196 err = mISDN_register_Bprotocol(&DSP);
1197 if (err) {
1198 printk(KERN_ERR "Can't register %s error(%d)\n", DSP.name, err);
1199 return err;
1200 }
1201
1202
1203 timer_setup(&dsp_spl_tl, (void *)dsp_cmx_send, 0);
1204 dsp_spl_tl.expires = jiffies + dsp_tics;
1205 dsp_spl_jiffies = dsp_spl_tl.expires;
1206 add_timer(&dsp_spl_tl);
1207
1208 return 0;
1209}
1210
1211
1212static void __exit dsp_cleanup(void)
1213{
1214 mISDN_unregister_Bprotocol(&DSP);
1215
1216 del_timer_sync(&dsp_spl_tl);
1217
1218 if (!list_empty(&dsp_ilist)) {
1219 printk(KERN_ERR "mISDN_dsp: Audio DSP object inst list not "
1220 "empty.\n");
1221 }
1222 if (!list_empty(&conf_ilist)) {
1223 printk(KERN_ERR "mISDN_dsp: Conference list not empty. Not "
1224 "all memory freed.\n");
1225 }
1226
1227 dsp_pipeline_module_exit();
1228}
1229
1230module_init(dsp_init);
1231module_exit(dsp_cleanup);
1232
