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
155
156#include <linux/delay.h>
157#include <linux/gfp.h>
158#include <linux/mISDNif.h>
159#include <linux/mISDNdsp.h>
160#include <linux/module.h>
161#include <linux/vmalloc.h>
162#include "core.h"
163#include "dsp.h"
164
165static const char *mISDN_dsp_revision = "2.0";
166
167static int debug;
168static int options;
169static int poll;
170static int dtmfthreshold = 100;
171
172MODULE_AUTHOR("Andreas Eversberg");
173module_param(debug, uint, S_IRUGO | S_IWUSR);
174module_param(options, uint, S_IRUGO | S_IWUSR);
175module_param(poll, uint, S_IRUGO | S_IWUSR);
176module_param(dtmfthreshold, uint, S_IRUGO | S_IWUSR);
177MODULE_LICENSE("GPL");
178
179
180
181spinlock_t dsp_lock;
182struct list_head dsp_ilist;
183struct list_head conf_ilist;
184int dsp_debug;
185int dsp_options;
186int dsp_poll, dsp_tics;
187
188
189static void
190dsp_rx_off_member(struct dsp *dsp)
191{
192 struct mISDN_ctrl_req cq;
193 int rx_off = 1;
194
195 memset(&cq, 0, sizeof(cq));
196
197 if (!dsp->features_rx_off)
198 return;
199
200
201 if (!dsp->rx_disabled)
202 rx_off = 0;
203
204 else if (dsp->dtmf.software)
205 rx_off = 0;
206
207 else if (dsp->echo.software)
208 rx_off = 0;
209
210 else if (dsp->conf && dsp->conf->software)
211 rx_off = 0;
212
213
214
215 if (rx_off == dsp->rx_is_off)
216 return;
217
218 if (!dsp->ch.peer) {
219 if (dsp_debug & DEBUG_DSP_CORE)
220 printk(KERN_DEBUG "%s: no peer, no rx_off\n",
221 __func__);
222 return;
223 }
224 cq.op = MISDN_CTRL_RX_OFF;
225 cq.p1 = rx_off;
226 if (dsp->ch.peer->ctrl(dsp->ch.peer, CONTROL_CHANNEL, &cq)) {
227 printk(KERN_DEBUG "%s: 2nd CONTROL_CHANNEL failed\n",
228 __func__);
229 return;
230 }
231 dsp->rx_is_off = rx_off;
232 if (dsp_debug & DEBUG_DSP_CORE)
233 printk(KERN_DEBUG "%s: %s set rx_off = %d\n",
234 __func__, dsp->name, rx_off);
235}
236static void
237dsp_rx_off(struct dsp *dsp)
238{
239 struct dsp_conf_member *member;
240
241 if (dsp_options & DSP_OPT_NOHARDWARE)
242 return;
243
244
245 if (!dsp->conf) {
246 dsp_rx_off_member(dsp);
247 return;
248 }
249
250 list_for_each_entry(member, &dsp->conf->mlist, list) {
251 dsp_rx_off_member(member->dsp);
252 }
253}
254
255
256static void
257dsp_fill_empty(struct dsp *dsp)
258{
259 struct mISDN_ctrl_req cq;
260
261 memset(&cq, 0, sizeof(cq));
262
263 if (!dsp->ch.peer) {
264 if (dsp_debug & DEBUG_DSP_CORE)
265 printk(KERN_DEBUG "%s: no peer, no fill_empty\n",
266 __func__);
267 return;
268 }
269 cq.op = MISDN_CTRL_FILL_EMPTY;
270 cq.p1 = 1;
271 cq.p2 = dsp_silence;
272 if (dsp->ch.peer->ctrl(dsp->ch.peer, CONTROL_CHANNEL, &cq)) {
273 printk(KERN_DEBUG "%s: CONTROL_CHANNEL failed\n",
274 __func__);
275 return;
276 }
277 if (dsp_debug & DEBUG_DSP_CORE)
278 printk(KERN_DEBUG "%s: %s set fill_empty = 1\n",
279 __func__, dsp->name);
280}
281
282static int
283dsp_control_req(struct dsp *dsp, struct mISDNhead *hh, struct sk_buff *skb)
284{
285 struct sk_buff *nskb;
286 int ret = 0;
287 int cont;
288 u8 *data;
289 int len;
290
291 if (skb->len < sizeof(int))
292 printk(KERN_ERR "%s: PH_CONTROL message too short\n", __func__);
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 mebers\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 mebers\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 ndsp->tone.tl.function = (void *)dsp_tone_timeout;
1094 ndsp->tone.tl.data = (long) ndsp;
1095 init_timer(&ndsp->tone.tl);
1096
1097 if (dtmfthreshold < 20 || dtmfthreshold > 500)
1098 dtmfthreshold = 200;
1099 ndsp->dtmf.treshold = dtmfthreshold * 10000;
1100
1101
1102 spin_lock_irqsave(&dsp_lock, flags);
1103 dsp_pipeline_init(&ndsp->pipeline);
1104 list_add_tail(&ndsp->list, &dsp_ilist);
1105 spin_unlock_irqrestore(&dsp_lock, flags);
1106
1107 return 0;
1108}
1109
1110
1111static struct Bprotocol DSP = {
1112 .Bprotocols = (1 << (ISDN_P_B_L2DSP & ISDN_P_B_MASK))
1113 | (1 << (ISDN_P_B_L2DSPHDLC & ISDN_P_B_MASK)),
1114 .name = "dsp",
1115 .create = dspcreate
1116};
1117
1118static int __init dsp_init(void)
1119{
1120 int err;
1121 int tics;
1122
1123 printk(KERN_INFO "DSP module %s\n", mISDN_dsp_revision);
1124
1125 dsp_options = options;
1126 dsp_debug = debug;
1127
1128
1129 dsp_poll = poll;
1130 if (dsp_poll) {
1131 if (dsp_poll > MAX_POLL) {
1132 printk(KERN_ERR "%s: Wrong poll value (%d), use %d "
1133 "maximum.\n", __func__, poll, MAX_POLL);
1134 err = -EINVAL;
1135 return err;
1136 }
1137 if (dsp_poll < 8) {
1138 printk(KERN_ERR "%s: Wrong poll value (%d), use 8 "
1139 "minimum.\n", __func__, dsp_poll);
1140 err = -EINVAL;
1141 return err;
1142 }
1143 dsp_tics = poll * HZ / 8000;
1144 if (dsp_tics * 8000 != poll * HZ) {
1145 printk(KERN_INFO "mISDN_dsp: Cannot clock every %d "
1146 "samples (0,125 ms). It is not a multiple of "
1147 "%d HZ.\n", poll, HZ);
1148 err = -EINVAL;
1149 return err;
1150 }
1151 } else {
1152 poll = 8;
1153 while (poll <= MAX_POLL) {
1154 tics = (poll * HZ) / 8000;
1155 if (tics * 8000 == poll * HZ) {
1156 dsp_tics = tics;
1157 dsp_poll = poll;
1158 if (poll >= 64)
1159 break;
1160 }
1161 poll++;
1162 }
1163 }
1164 if (dsp_poll == 0) {
1165 printk(KERN_INFO "mISDN_dsp: There is no multiple of kernel "
1166 "clock that equals exactly the duration of 8-256 "
1167 "samples. (Choose kernel clock speed like 100, 250, "
1168 "300, 1000)\n");
1169 err = -EINVAL;
1170 return err;
1171 }
1172 printk(KERN_INFO "mISDN_dsp: DSP clocks every %d samples. This equals "
1173 "%d jiffies.\n", dsp_poll, dsp_tics);
1174
1175 spin_lock_init(&dsp_lock);
1176 INIT_LIST_HEAD(&dsp_ilist);
1177 INIT_LIST_HEAD(&conf_ilist);
1178
1179
1180 dsp_audio_generate_law_tables();
1181 dsp_silence = (dsp_options & DSP_OPT_ULAW) ? 0xff : 0x2a;
1182 dsp_audio_law_to_s32 = (dsp_options & DSP_OPT_ULAW) ?
1183 dsp_audio_ulaw_to_s32 : dsp_audio_alaw_to_s32;
1184 dsp_audio_generate_s2law_table();
1185 dsp_audio_generate_seven();
1186 dsp_audio_generate_mix_table();
1187 if (dsp_options & DSP_OPT_ULAW)
1188 dsp_audio_generate_ulaw_samples();
1189 dsp_audio_generate_volume_changes();
1190
1191 err = dsp_pipeline_module_init();
1192 if (err) {
1193 printk(KERN_ERR "mISDN_dsp: Can't initialize pipeline, "
1194 "error(%d)\n", err);
1195 return err;
1196 }
1197
1198 err = mISDN_register_Bprotocol(&DSP);
1199 if (err) {
1200 printk(KERN_ERR "Can't register %s error(%d)\n", DSP.name, err);
1201 return err;
1202 }
1203
1204
1205 dsp_spl_tl.function = (void *)dsp_cmx_send;
1206 dsp_spl_tl.data = 0;
1207 init_timer(&dsp_spl_tl);
1208 dsp_spl_tl.expires = jiffies + dsp_tics;
1209 dsp_spl_jiffies = dsp_spl_tl.expires;
1210 add_timer(&dsp_spl_tl);
1211
1212 return 0;
1213}
1214
1215
1216static void __exit dsp_cleanup(void)
1217{
1218 mISDN_unregister_Bprotocol(&DSP);
1219
1220 del_timer_sync(&dsp_spl_tl);
1221
1222 if (!list_empty(&dsp_ilist)) {
1223 printk(KERN_ERR "mISDN_dsp: Audio DSP object inst list not "
1224 "empty.\n");
1225 }
1226 if (!list_empty(&conf_ilist)) {
1227 printk(KERN_ERR "mISDN_dsp: Conference list not empty. Not "
1228 "all memory freed.\n");
1229 }
1230
1231 dsp_pipeline_module_exit();
1232}
1233
1234module_init(dsp_init);
1235module_exit(dsp_cleanup);
1236
