aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--drivers/isdn/hardware/mISDN/Kconfig7
-rw-r--r--drivers/isdn/hardware/mISDN/Makefile1
-rw-r--r--drivers/isdn/hardware/mISDN/hfc_multi.h10
-rw-r--r--drivers/isdn/hardware/mISDN/hfc_pci.h2
-rw-r--r--drivers/isdn/hardware/mISDN/hfcmulti.c206
-rw-r--r--drivers/isdn/hardware/mISDN/hfcpci.c239
-rw-r--r--drivers/isdn/hardware/mISDN/hfcsusb.c2196
-rw-r--r--drivers/isdn/hardware/mISDN/hfcsusb.h418
-rw-r--r--drivers/isdn/mISDN/Makefile2
-rw-r--r--drivers/isdn/mISDN/clock.c216
-rw-r--r--drivers/isdn/mISDN/core.c280
-rw-r--r--drivers/isdn/mISDN/core.h2
-rw-r--r--drivers/isdn/mISDN/dsp.h2
-rw-r--r--drivers/isdn/mISDN/dsp_cmx.c146
-rw-r--r--drivers/isdn/mISDN/dsp_core.c55
-rw-r--r--drivers/isdn/mISDN/dsp_pipeline.c34
-rw-r--r--drivers/isdn/mISDN/hwchannel.c42
-rw-r--r--drivers/isdn/mISDN/l1oip_core.c25
-rw-r--r--drivers/isdn/mISDN/layer1.c2
-rw-r--r--drivers/isdn/mISDN/socket.c41
-rw-r--r--drivers/isdn/mISDN/stack.c66
-rw-r--r--drivers/isdn/mISDN/tei.c6
-rw-r--r--include/linux/mISDNhw.h26
-rw-r--r--include/linux/mISDNif.h89
24 files changed, 3734 insertions, 379 deletions
diff --git a/drivers/isdn/hardware/mISDN/Kconfig b/drivers/isdn/hardware/mISDN/Kconfig
index 14793480c453..fd112ae252cf 100644
--- a/drivers/isdn/hardware/mISDN/Kconfig
+++ b/drivers/isdn/hardware/mISDN/Kconfig
@@ -23,3 +23,10 @@ config MISDN_HFCMULTI
23 * HFC-8S (8 S/T interfaces on one chip) 23 * HFC-8S (8 S/T interfaces on one chip)
24 * HFC-E1 (E1 interface for 2Mbit ISDN) 24 * HFC-E1 (E1 interface for 2Mbit ISDN)
25 25
26config MISDN_HFCUSB
27 tristate "Support for HFC-S USB based TAs"
28 depends on USB
29 help
30 Enable support for USB ISDN TAs with Cologne Chip AG's
31 HFC-S USB ISDN Controller
32
diff --git a/drivers/isdn/hardware/mISDN/Makefile b/drivers/isdn/hardware/mISDN/Makefile
index 1e7ca5332ad7..b0403526bbba 100644
--- a/drivers/isdn/hardware/mISDN/Makefile
+++ b/drivers/isdn/hardware/mISDN/Makefile
@@ -5,3 +5,4 @@
5 5
6obj-$(CONFIG_MISDN_HFCPCI) += hfcpci.o 6obj-$(CONFIG_MISDN_HFCPCI) += hfcpci.o
7obj-$(CONFIG_MISDN_HFCMULTI) += hfcmulti.o 7obj-$(CONFIG_MISDN_HFCMULTI) += hfcmulti.o
8obj-$(CONFIG_MISDN_HFCUSB) += hfcsusb.o
diff --git a/drivers/isdn/hardware/mISDN/hfc_multi.h b/drivers/isdn/hardware/mISDN/hfc_multi.h
index 7bbf7300593d..663b77f578be 100644
--- a/drivers/isdn/hardware/mISDN/hfc_multi.h
+++ b/drivers/isdn/hardware/mISDN/hfc_multi.h
@@ -2,10 +2,6 @@
2 * see notice in hfc_multi.c 2 * see notice in hfc_multi.c
3 */ 3 */
4 4
5extern void ztdummy_extern_interrupt(void);
6extern void ztdummy_register_interrupt(void);
7extern int ztdummy_unregister_interrupt(void);
8
9#define DEBUG_HFCMULTI_FIFO 0x00010000 5#define DEBUG_HFCMULTI_FIFO 0x00010000
10#define DEBUG_HFCMULTI_CRC 0x00020000 6#define DEBUG_HFCMULTI_CRC 0x00020000
11#define DEBUG_HFCMULTI_INIT 0x00040000 7#define DEBUG_HFCMULTI_INIT 0x00040000
@@ -13,6 +9,7 @@ extern int ztdummy_unregister_interrupt(void);
13#define DEBUG_HFCMULTI_MODE 0x00100000 9#define DEBUG_HFCMULTI_MODE 0x00100000
14#define DEBUG_HFCMULTI_MSG 0x00200000 10#define DEBUG_HFCMULTI_MSG 0x00200000
15#define DEBUG_HFCMULTI_STATE 0x00400000 11#define DEBUG_HFCMULTI_STATE 0x00400000
12#define DEBUG_HFCMULTI_FILL 0x00800000
16#define DEBUG_HFCMULTI_SYNC 0x01000000 13#define DEBUG_HFCMULTI_SYNC 0x01000000
17#define DEBUG_HFCMULTI_DTMF 0x02000000 14#define DEBUG_HFCMULTI_DTMF 0x02000000
18#define DEBUG_HFCMULTI_LOCK 0x80000000 15#define DEBUG_HFCMULTI_LOCK 0x80000000
@@ -170,6 +167,8 @@ struct hfc_multi {
170 167
171 u_long chip; /* chip configuration */ 168 u_long chip; /* chip configuration */
172 int masterclk; /* port that provides master clock -1=off */ 169 int masterclk; /* port that provides master clock -1=off */
170 unsigned char silence;/* silence byte */
171 unsigned char silence_data[128];/* silence block */
173 int dtmf; /* flag that dtmf is currently in process */ 172 int dtmf; /* flag that dtmf is currently in process */
174 int Flen; /* F-buffer size */ 173 int Flen; /* F-buffer size */
175 int Zlen; /* Z-buffer size (must be int for calculation)*/ 174 int Zlen; /* Z-buffer size (must be int for calculation)*/
@@ -198,6 +197,9 @@ struct hfc_multi {
198 197
199 spinlock_t lock; /* the lock */ 198 spinlock_t lock; /* the lock */
200 199
200 struct mISDNclock *iclock; /* isdn clock support */
201 int iclock_on;
202
201 /* 203 /*
202 * the channel index is counted from 0, regardless where the channel 204 * the channel index is counted from 0, regardless where the channel
203 * is located on the hfc-channel. 205 * is located on the hfc-channel.
diff --git a/drivers/isdn/hardware/mISDN/hfc_pci.h b/drivers/isdn/hardware/mISDN/hfc_pci.h
index 5783d22a18fe..3132ddc99fcd 100644
--- a/drivers/isdn/hardware/mISDN/hfc_pci.h
+++ b/drivers/isdn/hardware/mISDN/hfc_pci.h
@@ -26,7 +26,7 @@
26 * change mask and threshold simultaneously 26 * change mask and threshold simultaneously
27 */ 27 */
28#define HFCPCI_BTRANS_THRESHOLD 128 28#define HFCPCI_BTRANS_THRESHOLD 128
29#define HFCPCI_BTRANS_MAX 256 29#define HFCPCI_FILLEMPTY 64
30#define HFCPCI_BTRANS_THRESMASK 0x00 30#define HFCPCI_BTRANS_THRESMASK 0x00
31 31
32/* defines for PCI config */ 32/* defines for PCI config */
diff --git a/drivers/isdn/hardware/mISDN/hfcmulti.c b/drivers/isdn/hardware/mISDN/hfcmulti.c
index c63e2f49da8a..97f4708b3879 100644
--- a/drivers/isdn/hardware/mISDN/hfcmulti.c
+++ b/drivers/isdn/hardware/mISDN/hfcmulti.c
@@ -133,6 +133,12 @@
133 * Give the value of the clock control register (A_ST_CLK_DLY) 133 * Give the value of the clock control register (A_ST_CLK_DLY)
134 * of the S/T interfaces in TE mode. 134 * of the S/T interfaces in TE mode.
135 * This register is needed for the TBR3 certification, so don't change it. 135 * This register is needed for the TBR3 certification, so don't change it.
136 *
137 * clock:
138 * NOTE: only one clock value must be given once
139 * Selects interface with clock source for mISDN and applications.
140 * Set to card number starting with 1. Set to -1 to disable.
141 * By default, the first card is used as clock source.
136 */ 142 */
137 143
138/* 144/*
@@ -140,7 +146,7 @@
140 * #define HFC_REGISTER_DEBUG 146 * #define HFC_REGISTER_DEBUG
141 */ 147 */
142 148
143static const char *hfcmulti_revision = "2.02"; 149#define HFC_MULTI_VERSION "2.03"
144 150
145#include <linux/module.h> 151#include <linux/module.h>
146#include <linux/pci.h> 152#include <linux/pci.h>
@@ -165,10 +171,6 @@ static LIST_HEAD(HFClist);
165static spinlock_t HFClock; /* global hfc list lock */ 171static spinlock_t HFClock; /* global hfc list lock */
166 172
167static void ph_state_change(struct dchannel *); 173static void ph_state_change(struct dchannel *);
168static void (*hfc_interrupt)(void);
169static void (*register_interrupt)(void);
170static int (*unregister_interrupt)(void);
171static int interrupt_registered;
172 174
173static struct hfc_multi *syncmaster; 175static struct hfc_multi *syncmaster;
174static int plxsd_master; /* if we have a master card (yet) */ 176static int plxsd_master; /* if we have a master card (yet) */
@@ -184,7 +186,6 @@ static int nt_t1_count[] = { 3840, 1920, 960, 480, 240, 120, 60, 30 };
184#define CLKDEL_TE 0x0f /* CLKDEL in TE mode */ 186#define CLKDEL_TE 0x0f /* CLKDEL in TE mode */
185#define CLKDEL_NT 0x6c /* CLKDEL in NT mode 187#define CLKDEL_NT 0x6c /* CLKDEL in NT mode
186 (0x60 MUST be included!) */ 188 (0x60 MUST be included!) */
187static u_char silence = 0xff; /* silence by LAW */
188 189
189#define DIP_4S 0x1 /* DIP Switches for Beronet 1S/2S/4S cards */ 190#define DIP_4S 0x1 /* DIP Switches for Beronet 1S/2S/4S cards */
190#define DIP_8S 0x2 /* DIP Switches for Beronet 8S+ cards */ 191#define DIP_8S 0x2 /* DIP Switches for Beronet 8S+ cards */
@@ -195,12 +196,13 @@ static u_char silence = 0xff; /* silence by LAW */
195 */ 196 */
196 197
197static uint type[MAX_CARDS]; 198static uint type[MAX_CARDS];
198static uint pcm[MAX_CARDS]; 199static int pcm[MAX_CARDS];
199static uint dslot[MAX_CARDS]; 200static int dslot[MAX_CARDS];
200static uint iomode[MAX_CARDS]; 201static uint iomode[MAX_CARDS];
201static uint port[MAX_PORTS]; 202static uint port[MAX_PORTS];
202static uint debug; 203static uint debug;
203static uint poll; 204static uint poll;
205static int clock;
204static uint timer; 206static uint timer;
205static uint clockdelay_te = CLKDEL_TE; 207static uint clockdelay_te = CLKDEL_TE;
206static uint clockdelay_nt = CLKDEL_NT; 208static uint clockdelay_nt = CLKDEL_NT;
@@ -209,14 +211,16 @@ static int HFC_cnt, Port_cnt, PCM_cnt = 99;
209 211
210MODULE_AUTHOR("Andreas Eversberg"); 212MODULE_AUTHOR("Andreas Eversberg");
211MODULE_LICENSE("GPL"); 213MODULE_LICENSE("GPL");
214MODULE_VERSION(HFC_MULTI_VERSION);
212module_param(debug, uint, S_IRUGO | S_IWUSR); 215module_param(debug, uint, S_IRUGO | S_IWUSR);
213module_param(poll, uint, S_IRUGO | S_IWUSR); 216module_param(poll, uint, S_IRUGO | S_IWUSR);
217module_param(clock, int, S_IRUGO | S_IWUSR);
214module_param(timer, uint, S_IRUGO | S_IWUSR); 218module_param(timer, uint, S_IRUGO | S_IWUSR);
215module_param(clockdelay_te, uint, S_IRUGO | S_IWUSR); 219module_param(clockdelay_te, uint, S_IRUGO | S_IWUSR);
216module_param(clockdelay_nt, uint, S_IRUGO | S_IWUSR); 220module_param(clockdelay_nt, uint, S_IRUGO | S_IWUSR);
217module_param_array(type, uint, NULL, S_IRUGO | S_IWUSR); 221module_param_array(type, uint, NULL, S_IRUGO | S_IWUSR);
218module_param_array(pcm, uint, NULL, S_IRUGO | S_IWUSR); 222module_param_array(pcm, int, NULL, S_IRUGO | S_IWUSR);
219module_param_array(dslot, uint, NULL, S_IRUGO | S_IWUSR); 223module_param_array(dslot, int, NULL, S_IRUGO | S_IWUSR);
220module_param_array(iomode, uint, NULL, S_IRUGO | S_IWUSR); 224module_param_array(iomode, uint, NULL, S_IRUGO | S_IWUSR);
221module_param_array(port, uint, NULL, S_IRUGO | S_IWUSR); 225module_param_array(port, uint, NULL, S_IRUGO | S_IWUSR);
222 226
@@ -1419,19 +1423,6 @@ controller_fail:
1419 HFC_outb(hc, R_TI_WD, poll_timer); 1423 HFC_outb(hc, R_TI_WD, poll_timer);
1420 hc->hw.r_irqmsk_misc |= V_TI_IRQMSK; 1424 hc->hw.r_irqmsk_misc |= V_TI_IRQMSK;
1421 1425
1422 /*
1423 * set up 125us interrupt, only if function pointer is available
1424 * and module parameter timer is set
1425 */
1426 if (timer && hfc_interrupt && register_interrupt) {
1427 /* only one chip should use this interrupt */
1428 timer = 0;
1429 interrupt_registered = 1;
1430 hc->hw.r_irqmsk_misc |= V_PROC_IRQMSK;
1431 /* deactivate other interrupts in ztdummy */
1432 register_interrupt();
1433 }
1434
1435 /* set E1 state machine IRQ */ 1426 /* set E1 state machine IRQ */
1436 if (hc->type == 1) 1427 if (hc->type == 1)
1437 hc->hw.r_irqmsk_misc |= V_STA_IRQMSK; 1428 hc->hw.r_irqmsk_misc |= V_STA_IRQMSK;
@@ -1991,6 +1982,17 @@ next_frame:
1991 return; /* no data */ 1982 return; /* no data */
1992 } 1983 }
1993 1984
1985 /* "fill fifo if empty" feature */
1986 if (bch && test_bit(FLG_FILLEMPTY, &bch->Flags)
1987 && !test_bit(FLG_HDLC, &bch->Flags) && z2 == z1) {
1988 if (debug & DEBUG_HFCMULTI_FILL)
1989 printk(KERN_DEBUG "%s: buffer empty, so we have "
1990 "underrun\n", __func__);
1991 /* fill buffer, to prevent future underrun */
1992 hc->write_fifo(hc, hc->silence_data, poll >> 1);
1993 Zspace -= (poll >> 1);
1994 }
1995
1994 /* if audio data and connected slot */ 1996 /* if audio data and connected slot */
1995 if (bch && (!test_bit(FLG_HDLC, &bch->Flags)) && (!*txpending) 1997 if (bch && (!test_bit(FLG_HDLC, &bch->Flags)) && (!*txpending)
1996 && slot_tx >= 0) { 1998 && slot_tx >= 0) {
@@ -2027,7 +2029,6 @@ next_frame:
2027 __func__, hc->id + 1, ch, Zspace, z1, z2, ii-i, len-i, 2029 __func__, hc->id + 1, ch, Zspace, z1, z2, ii-i, len-i,
2028 temp ? "HDLC":"TRANS"); 2030 temp ? "HDLC":"TRANS");
2029 2031
2030
2031 /* Have to prep the audio data */ 2032 /* Have to prep the audio data */
2032 hc->write_fifo(hc, d, ii - i); 2033 hc->write_fifo(hc, d, ii - i);
2033 *idxp = ii; 2034 *idxp = ii;
@@ -2066,7 +2067,7 @@ next_frame:
2066 * no more data at all. this prevents sending an undefined value. 2067 * no more data at all. this prevents sending an undefined value.
2067 */ 2068 */
2068 if (bch && test_bit(FLG_TRANSPARENT, &bch->Flags)) 2069 if (bch && test_bit(FLG_TRANSPARENT, &bch->Flags))
2069 HFC_outb_nodebug(hc, A_FIFO_DATA0_NOINC, silence); 2070 HFC_outb_nodebug(hc, A_FIFO_DATA0_NOINC, hc->silence);
2070} 2071}
2071 2072
2072 2073
@@ -2583,7 +2584,6 @@ hfcmulti_interrupt(int intno, void *dev_id)
2583 static int iq1 = 0, iq2 = 0, iq3 = 0, iq4 = 0, 2584 static int iq1 = 0, iq2 = 0, iq3 = 0, iq4 = 0,
2584 iq5 = 0, iq6 = 0, iqcnt = 0; 2585 iq5 = 0, iq6 = 0, iqcnt = 0;
2585#endif 2586#endif
2586 static int count;
2587 struct hfc_multi *hc = dev_id; 2587 struct hfc_multi *hc = dev_id;
2588 struct dchannel *dch; 2588 struct dchannel *dch;
2589 u_char r_irq_statech, status, r_irq_misc, r_irq_oview; 2589 u_char r_irq_statech, status, r_irq_misc, r_irq_oview;
@@ -2637,6 +2637,7 @@ hfcmulti_interrupt(int intno, void *dev_id)
2637 iqcnt = 0; 2637 iqcnt = 0;
2638 } 2638 }
2639#endif 2639#endif
2640
2640 if (!r_irq_statech && 2641 if (!r_irq_statech &&
2641 !(status & (V_DTMF_STA | V_LOST_STA | V_EXT_IRQSTA | 2642 !(status & (V_DTMF_STA | V_LOST_STA | V_EXT_IRQSTA |
2642 V_MISC_IRQSTA | V_FR_IRQSTA))) { 2643 V_MISC_IRQSTA | V_FR_IRQSTA))) {
@@ -2657,6 +2658,7 @@ hfcmulti_interrupt(int intno, void *dev_id)
2657 if (status & V_MISC_IRQSTA) { 2658 if (status & V_MISC_IRQSTA) {
2658 /* misc IRQ */ 2659 /* misc IRQ */
2659 r_irq_misc = HFC_inb_nodebug(hc, R_IRQ_MISC); 2660 r_irq_misc = HFC_inb_nodebug(hc, R_IRQ_MISC);
2661 r_irq_misc &= hc->hw.r_irqmsk_misc; /* ignore disabled irqs */
2660 if (r_irq_misc & V_STA_IRQ) { 2662 if (r_irq_misc & V_STA_IRQ) {
2661 if (hc->type == 1) { 2663 if (hc->type == 1) {
2662 /* state machine */ 2664 /* state machine */
@@ -2691,23 +2693,20 @@ hfcmulti_interrupt(int intno, void *dev_id)
2691 plxsd_checksync(hc, 0); 2693 plxsd_checksync(hc, 0);
2692 } 2694 }
2693 } 2695 }
2694 if (r_irq_misc & V_TI_IRQ) 2696 if (r_irq_misc & V_TI_IRQ) {
2697 if (hc->iclock_on)
2698 mISDN_clock_update(hc->iclock, poll, NULL);
2695 handle_timer_irq(hc); 2699 handle_timer_irq(hc);
2700 }
2696 2701
2697 if (r_irq_misc & V_DTMF_IRQ) { 2702 if (r_irq_misc & V_DTMF_IRQ) {
2698 /* -> DTMF IRQ */
2699 hfcmulti_dtmf(hc); 2703 hfcmulti_dtmf(hc);
2700 } 2704 }
2701 /* TODO: REPLACE !!!! 125 us Interrupts are not acceptable */
2702 if (r_irq_misc & V_IRQ_PROC) { 2705 if (r_irq_misc & V_IRQ_PROC) {
2703 /* IRQ every 125us */ 2706 static int irq_proc_cnt;
2704 count++; 2707 if (!irq_proc_cnt++)
2705 /* generate 1kHz signal */ 2708 printk(KERN_WARNING "%s: got V_IRQ_PROC -"
2706 if (count == 8) { 2709 " this should not happen\n", __func__);
2707 if (hfc_interrupt)
2708 hfc_interrupt();
2709 count = 0;
2710 }
2711 } 2710 }
2712 2711
2713 } 2712 }
@@ -2954,7 +2953,7 @@ mode_hfcmulti(struct hfc_multi *hc, int ch, int protocol, int slot_tx,
2954 HFC_outb(hc, R_INC_RES_FIFO, V_RES_F); 2953 HFC_outb(hc, R_INC_RES_FIFO, V_RES_F);
2955 HFC_wait(hc); 2954 HFC_wait(hc);
2956 /* tx silence */ 2955 /* tx silence */
2957 HFC_outb_nodebug(hc, A_FIFO_DATA0_NOINC, silence); 2956 HFC_outb_nodebug(hc, A_FIFO_DATA0_NOINC, hc->silence);
2958 HFC_outb(hc, R_SLOT, (((ch / 4) * 8) + 2957 HFC_outb(hc, R_SLOT, (((ch / 4) * 8) +
2959 ((ch % 4) * 4)) << 1); 2958 ((ch % 4) * 4)) << 1);
2960 HFC_outb(hc, A_SL_CFG, 0x80 | 0x20 | (ch << 1)); 2959 HFC_outb(hc, A_SL_CFG, 0x80 | 0x20 | (ch << 1));
@@ -2969,7 +2968,7 @@ mode_hfcmulti(struct hfc_multi *hc, int ch, int protocol, int slot_tx,
2969 HFC_outb(hc, R_INC_RES_FIFO, V_RES_F); 2968 HFC_outb(hc, R_INC_RES_FIFO, V_RES_F);
2970 HFC_wait(hc); 2969 HFC_wait(hc);
2971 /* tx silence */ 2970 /* tx silence */
2972 HFC_outb_nodebug(hc, A_FIFO_DATA0_NOINC, silence); 2971 HFC_outb_nodebug(hc, A_FIFO_DATA0_NOINC, hc->silence);
2973 /* enable RX fifo */ 2972 /* enable RX fifo */
2974 HFC_outb(hc, R_FIFO, (ch<<1)|1); 2973 HFC_outb(hc, R_FIFO, (ch<<1)|1);
2975 HFC_wait(hc); 2974 HFC_wait(hc);
@@ -3461,7 +3460,7 @@ channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
3461 switch (cq->op) { 3460 switch (cq->op) {
3462 case MISDN_CTRL_GETOP: 3461 case MISDN_CTRL_GETOP:
3463 cq->op = MISDN_CTRL_HFC_OP | MISDN_CTRL_HW_FEATURES_OP 3462 cq->op = MISDN_CTRL_HFC_OP | MISDN_CTRL_HW_FEATURES_OP
3464 | MISDN_CTRL_RX_OFF; 3463 | MISDN_CTRL_RX_OFF | MISDN_CTRL_FILL_EMPTY;
3465 break; 3464 break;
3466 case MISDN_CTRL_RX_OFF: /* turn off / on rx stream */ 3465 case MISDN_CTRL_RX_OFF: /* turn off / on rx stream */
3467 hc->chan[bch->slot].rx_off = !!cq->p1; 3466 hc->chan[bch->slot].rx_off = !!cq->p1;
@@ -3476,6 +3475,12 @@ channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
3476 printk(KERN_DEBUG "%s: RX_OFF request (nr=%d off=%d)\n", 3475 printk(KERN_DEBUG "%s: RX_OFF request (nr=%d off=%d)\n",
3477 __func__, bch->nr, hc->chan[bch->slot].rx_off); 3476 __func__, bch->nr, hc->chan[bch->slot].rx_off);
3478 break; 3477 break;
3478 case MISDN_CTRL_FILL_EMPTY: /* fill fifo, if empty */
3479 test_and_set_bit(FLG_FILLEMPTY, &bch->Flags);
3480 if (debug & DEBUG_HFCMULTI_MSG)
3481 printk(KERN_DEBUG "%s: FILL_EMPTY request (nr=%d "
3482 "off=%d)\n", __func__, bch->nr, !!cq->p1);
3483 break;
3479 case MISDN_CTRL_HW_FEATURES: /* fill features structure */ 3484 case MISDN_CTRL_HW_FEATURES: /* fill features structure */
3480 if (debug & DEBUG_HFCMULTI_MSG) 3485 if (debug & DEBUG_HFCMULTI_MSG)
3481 printk(KERN_DEBUG "%s: HW_FEATURE request\n", 3486 printk(KERN_DEBUG "%s: HW_FEATURE request\n",
@@ -3992,6 +3997,7 @@ open_bchannel(struct hfc_multi *hc, struct dchannel *dch,
3992 } 3997 }
3993 if (test_and_set_bit(FLG_OPEN, &bch->Flags)) 3998 if (test_and_set_bit(FLG_OPEN, &bch->Flags))
3994 return -EBUSY; /* b-channel can be only open once */ 3999 return -EBUSY; /* b-channel can be only open once */
4000 test_and_clear_bit(FLG_FILLEMPTY, &bch->Flags);
3995 bch->ch.protocol = rq->protocol; 4001 bch->ch.protocol = rq->protocol;
3996 hc->chan[ch].rx_off = 0; 4002 hc->chan[ch].rx_off = 0;
3997 rq->ch = &bch->ch; 4003 rq->ch = &bch->ch;
@@ -4081,6 +4087,15 @@ hfcm_dctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
4081 return err; 4087 return err;
4082} 4088}
4083 4089
4090static int
4091clockctl(void *priv, int enable)
4092{
4093 struct hfc_multi *hc = priv;
4094
4095 hc->iclock_on = enable;
4096 return 0;
4097}
4098
4084/* 4099/*
4085 * initialize the card 4100 * initialize the card
4086 */ 4101 */
@@ -4495,10 +4510,14 @@ release_card(struct hfc_multi *hc)
4495 printk(KERN_WARNING "%s: release card (%d) entered\n", 4510 printk(KERN_WARNING "%s: release card (%d) entered\n",
4496 __func__, hc->id); 4511 __func__, hc->id);
4497 4512
4513 /* unregister clock source */
4514 if (hc->iclock)
4515 mISDN_unregister_clock(hc->iclock);
4516
4517 /* disable irq */
4498 spin_lock_irqsave(&hc->lock, flags); 4518 spin_lock_irqsave(&hc->lock, flags);
4499 disable_hwirq(hc); 4519 disable_hwirq(hc);
4500 spin_unlock_irqrestore(&hc->lock, flags); 4520 spin_unlock_irqrestore(&hc->lock, flags);
4501
4502 udelay(1000); 4521 udelay(1000);
4503 4522
4504 /* dimm leds */ 4523 /* dimm leds */
@@ -4699,7 +4718,7 @@ init_e1_port(struct hfc_multi *hc, struct hm_map *m)
4699 } else 4718 } else
4700 hc->chan[hc->dslot].jitter = 2; /* default */ 4719 hc->chan[hc->dslot].jitter = 2; /* default */
4701 snprintf(name, MISDN_MAX_IDLEN - 1, "hfc-e1.%d", HFC_cnt + 1); 4720 snprintf(name, MISDN_MAX_IDLEN - 1, "hfc-e1.%d", HFC_cnt + 1);
4702 ret = mISDN_register_device(&dch->dev, name); 4721 ret = mISDN_register_device(&dch->dev, &hc->pci_dev->dev, name);
4703 if (ret) 4722 if (ret)
4704 goto free_chan; 4723 goto free_chan;
4705 hc->created[0] = 1; 4724 hc->created[0] = 1;
@@ -4807,9 +4826,9 @@ init_multi_port(struct hfc_multi *hc, int pt)
4807 test_and_set_bit(HFC_CFG_DIS_ECHANNEL, 4826 test_and_set_bit(HFC_CFG_DIS_ECHANNEL,
4808 &hc->chan[i + 2].cfg); 4827 &hc->chan[i + 2].cfg);
4809 } 4828 }
4810 snprintf(name, MISDN_MAX_IDLEN - 1, "hfc-%ds.%d/%d", 4829 snprintf(name, MISDN_MAX_IDLEN - 1, "hfc-%ds.%d-%d",
4811 hc->type, HFC_cnt + 1, pt + 1); 4830 hc->type, HFC_cnt + 1, pt + 1);
4812 ret = mISDN_register_device(&dch->dev, name); 4831 ret = mISDN_register_device(&dch->dev, &hc->pci_dev->dev, name);
4813 if (ret) 4832 if (ret)
4814 goto free_chan; 4833 goto free_chan;
4815 hc->created[pt] = 1; 4834 hc->created[pt] = 1;
@@ -4828,6 +4847,7 @@ hfcmulti_init(struct pci_dev *pdev, const struct pci_device_id *ent)
4828 struct hfc_multi *hc; 4847 struct hfc_multi *hc;
4829 u_long flags; 4848 u_long flags;
4830 u_char dips = 0, pmj = 0; /* dip settings, port mode Jumpers */ 4849 u_char dips = 0, pmj = 0; /* dip settings, port mode Jumpers */
4850 int i;
4831 4851
4832 if (HFC_cnt >= MAX_CARDS) { 4852 if (HFC_cnt >= MAX_CARDS) {
4833 printk(KERN_ERR "too many cards (max=%d).\n", 4853 printk(KERN_ERR "too many cards (max=%d).\n",
@@ -4861,11 +4881,11 @@ hfcmulti_init(struct pci_dev *pdev, const struct pci_device_id *ent)
4861 hc->id = HFC_cnt; 4881 hc->id = HFC_cnt;
4862 hc->pcm = pcm[HFC_cnt]; 4882 hc->pcm = pcm[HFC_cnt];
4863 hc->io_mode = iomode[HFC_cnt]; 4883 hc->io_mode = iomode[HFC_cnt];
4864 if (dslot[HFC_cnt] < 0) { 4884 if (dslot[HFC_cnt] < 0 && hc->type == 1) {
4865 hc->dslot = 0; 4885 hc->dslot = 0;
4866 printk(KERN_INFO "HFC-E1 card has disabled D-channel, but " 4886 printk(KERN_INFO "HFC-E1 card has disabled D-channel, but "
4867 "31 B-channels\n"); 4887 "31 B-channels\n");
4868 } if (dslot[HFC_cnt] > 0 && dslot[HFC_cnt] < 32) { 4888 } if (dslot[HFC_cnt] > 0 && dslot[HFC_cnt] < 32 && hc->type == 1) {
4869 hc->dslot = dslot[HFC_cnt]; 4889 hc->dslot = dslot[HFC_cnt];
4870 printk(KERN_INFO "HFC-E1 card has alternating D-channel on " 4890 printk(KERN_INFO "HFC-E1 card has alternating D-channel on "
4871 "time slot %d\n", dslot[HFC_cnt]); 4891 "time slot %d\n", dslot[HFC_cnt]);
@@ -4876,9 +4896,17 @@ hfcmulti_init(struct pci_dev *pdev, const struct pci_device_id *ent)
4876 hc->masterclk = -1; 4896 hc->masterclk = -1;
4877 if (type[HFC_cnt] & 0x100) { 4897 if (type[HFC_cnt] & 0x100) {
4878 test_and_set_bit(HFC_CHIP_ULAW, &hc->chip); 4898 test_and_set_bit(HFC_CHIP_ULAW, &hc->chip);
4879 silence = 0xff; /* ulaw silence */ 4899 hc->silence = 0xff; /* ulaw silence */
4880 } else 4900 } else
4881 silence = 0x2a; /* alaw silence */ 4901 hc->silence = 0x2a; /* alaw silence */
4902 if ((poll >> 1) > sizeof(hc->silence_data)) {
4903 printk(KERN_ERR "HFCMULTI error: silence_data too small, "
4904 "please fix\n");
4905 return -EINVAL;
4906 }
4907 for (i = 0; i < (poll >> 1); i++)
4908 hc->silence_data[i] = hc->silence;
4909
4882 if (!(type[HFC_cnt] & 0x200)) 4910 if (!(type[HFC_cnt] & 0x200))
4883 test_and_set_bit(HFC_CHIP_DTMF, &hc->chip); 4911 test_and_set_bit(HFC_CHIP_DTMF, &hc->chip);
4884 4912
@@ -4945,9 +4973,7 @@ hfcmulti_init(struct pci_dev *pdev, const struct pci_device_id *ent)
4945 switch (m->dip_type) { 4973 switch (m->dip_type) {
4946 case DIP_4S: 4974 case DIP_4S:
4947 /* 4975 /*
4948 * get DIP Setting for beroNet 1S/2S/4S cards 4976 * Get DIP setting for beroNet 1S/2S/4S cards
4949 * check if Port Jumper config matches
4950 * module param 'protocol'
4951 * DIP Setting: (collect GPIO 13/14/15 (R_GPIO_IN1) + 4977 * DIP Setting: (collect GPIO 13/14/15 (R_GPIO_IN1) +
4952 * GPI 19/23 (R_GPI_IN2)) 4978 * GPI 19/23 (R_GPI_IN2))
4953 */ 4979 */
@@ -4966,9 +4992,8 @@ hfcmulti_init(struct pci_dev *pdev, const struct pci_device_id *ent)
4966 break; 4992 break;
4967 case DIP_8S: 4993 case DIP_8S:
4968 /* 4994 /*
4969 * get DIP Setting for beroNet 8S0+ cards 4995 * Get DIP Setting for beroNet 8S0+ cards
4970 * 4996 * Enable PCI auxbridge function
4971 * enable PCI auxbridge function
4972 */ 4997 */
4973 HFC_outb(hc, R_BRG_PCM_CFG, 1 | V_PCM_CLK); 4998 HFC_outb(hc, R_BRG_PCM_CFG, 1 | V_PCM_CLK);
4974 /* prepare access to auxport */ 4999 /* prepare access to auxport */
@@ -5003,6 +5028,10 @@ hfcmulti_init(struct pci_dev *pdev, const struct pci_device_id *ent)
5003 list_add_tail(&hc->list, &HFClist); 5028 list_add_tail(&hc->list, &HFClist);
5004 spin_unlock_irqrestore(&HFClock, flags); 5029 spin_unlock_irqrestore(&HFClock, flags);
5005 5030
5031 /* use as clock source */
5032 if (clock == HFC_cnt + 1)
5033 hc->iclock = mISDN_register_clock("HFCMulti", 0, clockctl, hc);
5034
5006 /* initialize hardware */ 5035 /* initialize hardware */
5007 ret_err = init_card(hc); 5036 ret_err = init_card(hc);
5008 if (ret_err) { 5037 if (ret_err) {
@@ -5137,8 +5166,7 @@ static struct pci_device_id hfmultipci_ids[] __devinitdata = {
5137 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD, 5166 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD,
5138 PCI_DEVICE_ID_CCD_HFC8S, 0, 0, H(14)}, /* old Eval */ 5167 PCI_DEVICE_ID_CCD_HFC8S, 0, 0, H(14)}, /* old Eval */
5139 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD, 5168 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD,
5140 PCI_SUBDEVICE_ID_CCD_IOB8STR, 0, 0, H(15)}, 5169 PCI_SUBDEVICE_ID_CCD_IOB8STR, 0, 0, H(15)}, /* IOB8ST Recording */
5141 /* IOB8ST Recording */
5142 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD, 5170 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD,
5143 PCI_SUBDEVICE_ID_CCD_IOB8ST, 0, 0, H(16)}, /* IOB8ST */ 5171 PCI_SUBDEVICE_ID_CCD_IOB8ST, 0, 0, H(16)}, /* IOB8ST */
5144 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD, 5172 { PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_HFC8S, PCI_VENDOR_ID_CCD,
@@ -5188,18 +5216,16 @@ hfcmulti_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
5188 struct hm_map *m = (struct hm_map *)ent->driver_data; 5216 struct hm_map *m = (struct hm_map *)ent->driver_data;
5189 int ret; 5217 int ret;
5190 5218
5191 if (m == NULL) { 5219 if (m == NULL && ent->vendor == PCI_VENDOR_ID_CCD && (
5192 if (ent->vendor == PCI_VENDOR_ID_CCD) 5220 ent->device == PCI_DEVICE_ID_CCD_HFC4S ||
5193 if (ent->device == PCI_DEVICE_ID_CCD_HFC4S || 5221 ent->device == PCI_DEVICE_ID_CCD_HFC8S ||
5194 ent->device == PCI_DEVICE_ID_CCD_HFC8S || 5222 ent->device == PCI_DEVICE_ID_CCD_HFCE1)) {
5195 ent->device == PCI_DEVICE_ID_CCD_HFCE1) 5223 printk(KERN_ERR
5196 printk(KERN_ERR 5224 "Unknown HFC multiport controller (vendor:%x device:%x "
5197 "unknown HFC multiport controller " 5225 "subvendor:%x subdevice:%x)\n", ent->vendor, ent->device,
5198 "(vendor:%x device:%x subvendor:%x " 5226 ent->subvendor, ent->subdevice);
5199 "subdevice:%x) Please contact the " 5227 printk(KERN_ERR
5200 "driver maintainer for support.\n", 5228 "Please contact the driver maintainer for support.\n");
5201 ent->vendor, ent->device,
5202 ent->subvendor, ent->subdevice);
5203 return -ENODEV; 5229 return -ENODEV;
5204 } 5230 }
5205 ret = hfcmulti_init(pdev, ent); 5231 ret = hfcmulti_init(pdev, ent);
@@ -5222,22 +5248,9 @@ HFCmulti_cleanup(void)
5222{ 5248{
5223 struct hfc_multi *card, *next; 5249 struct hfc_multi *card, *next;
5224 5250
5225 /* unload interrupt function symbol */ 5251 /* get rid of all devices of this driver */
5226 if (hfc_interrupt)
5227 symbol_put(ztdummy_extern_interrupt);
5228 if (register_interrupt)
5229 symbol_put(ztdummy_register_interrupt);
5230 if (unregister_interrupt) {
5231 if (interrupt_registered) {
5232 interrupt_registered = 0;
5233 unregister_interrupt();
5234 }
5235 symbol_put(ztdummy_unregister_interrupt);
5236 }
5237
5238 list_for_each_entry_safe(card, next, &HFClist, list) 5252 list_for_each_entry_safe(card, next, &HFClist, list)
5239 release_card(card); 5253 release_card(card);
5240 /* get rid of all devices of this driver */
5241 pci_unregister_driver(&hfcmultipci_driver); 5254 pci_unregister_driver(&hfcmultipci_driver);
5242} 5255}
5243 5256
@@ -5246,8 +5259,10 @@ HFCmulti_init(void)
5246{ 5259{
5247 int err; 5260 int err;
5248 5261
5262 printk(KERN_INFO "mISDN: HFC-multi driver %s\n", HFC_MULTI_VERSION);
5263
5249#ifdef IRQ_DEBUG 5264#ifdef IRQ_DEBUG
5250 printk(KERN_ERR "%s: IRQ_DEBUG IS ENABLED!\n", __func__); 5265 printk(KERN_DEBUG "%s: IRQ_DEBUG IS ENABLED!\n", __func__);
5251#endif 5266#endif
5252 5267
5253 spin_lock_init(&HFClock); 5268 spin_lock_init(&HFClock);
@@ -5256,22 +5271,11 @@ HFCmulti_init(void)
5256 if (debug & DEBUG_HFCMULTI_INIT) 5271 if (debug & DEBUG_HFCMULTI_INIT)
5257 printk(KERN_DEBUG "%s: init entered\n", __func__); 5272 printk(KERN_DEBUG "%s: init entered\n", __func__);
5258 5273
5259 hfc_interrupt = symbol_get(ztdummy_extern_interrupt);
5260 register_interrupt = symbol_get(ztdummy_register_interrupt);
5261 unregister_interrupt = symbol_get(ztdummy_unregister_interrupt);
5262 printk(KERN_INFO "mISDN: HFC-multi driver %s\n",
5263 hfcmulti_revision);
5264
5265 switch (poll) { 5274 switch (poll) {
5266 case 0: 5275 case 0:
5267 poll_timer = 6; 5276 poll_timer = 6;
5268 poll = 128; 5277 poll = 128;
5269 break; 5278 break;
5270 /*
5271 * wenn dieses break nochmal verschwindet,
5272 * gibt es heisse ohren :-)
5273 * "without the break you will get hot ears ???"
5274 */
5275 case 8: 5279 case 8:
5276 poll_timer = 2; 5280 poll_timer = 2;
5277 break; 5281 break;
@@ -5298,20 +5302,12 @@ HFCmulti_init(void)
5298 5302
5299 } 5303 }
5300 5304
5305 if (!clock)
5306 clock = 1;
5307
5301 err = pci_register_driver(&hfcmultipci_driver); 5308 err = pci_register_driver(&hfcmultipci_driver);
5302 if (err < 0) { 5309 if (err < 0) {
5303 printk(KERN_ERR "error registering pci driver: %x\n", err); 5310 printk(KERN_ERR "error registering pci driver: %x\n", err);
5304 if (hfc_interrupt)
5305 symbol_put(ztdummy_extern_interrupt);
5306 if (register_interrupt)
5307 symbol_put(ztdummy_register_interrupt);
5308 if (unregister_interrupt) {
5309 if (interrupt_registered) {
5310 interrupt_registered = 0;
5311 unregister_interrupt();
5312 }
5313 symbol_put(ztdummy_unregister_interrupt);
5314 }
5315 return err; 5311 return err;
5316 } 5312 }
5317 return 0; 5313 return 0;
diff --git a/drivers/isdn/hardware/mISDN/hfcpci.c b/drivers/isdn/hardware/mISDN/hfcpci.c
index cd8302af40eb..917bf41a293b 100644
--- a/drivers/isdn/hardware/mISDN/hfcpci.c
+++ b/drivers/isdn/hardware/mISDN/hfcpci.c
@@ -23,6 +23,25 @@
23 * along with this program; if not, write to the Free Software 23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 * 25 *
26 * Module options:
27 *
28 * debug:
29 * NOTE: only one poll value must be given for all cards
30 * See hfc_pci.h for debug flags.
31 *
32 * poll:
33 * NOTE: only one poll value must be given for all cards
34 * Give the number of samples for each fifo process.
35 * By default 128 is used. Decrease to reduce delay, increase to
36 * reduce cpu load. If unsure, don't mess with it!
37 * A value of 128 will use controller's interrupt. Other values will
38 * use kernel timer, because the controller will not allow lower values
39 * than 128.
40 * Also note that the value depends on the kernel timer frequency.
41 * If kernel uses a frequency of 1000 Hz, steps of 8 samples are possible.
42 * If the kernel uses 100 Hz, steps of 80 samples are possible.
43 * If the kernel uses 300 Hz, steps of about 26 samples are possible.
44 *
26 */ 45 */
27 46
28#include <linux/module.h> 47#include <linux/module.h>
@@ -34,16 +53,16 @@
34 53
35static const char *hfcpci_revision = "2.0"; 54static const char *hfcpci_revision = "2.0";
36 55
37#define MAX_CARDS 8
38static int HFC_cnt; 56static int HFC_cnt;
39static uint debug; 57static uint debug;
58static uint poll, tics;
59struct timer_list hfc_tl;
60u32 hfc_jiffies;
40 61
41MODULE_AUTHOR("Karsten Keil"); 62MODULE_AUTHOR("Karsten Keil");
42MODULE_LICENSE("GPL"); 63MODULE_LICENSE("GPL");
43module_param(debug, uint, 0); 64module_param(debug, uint, 0);
44 65module_param(poll, uint, S_IRUGO | S_IWUSR);
45static LIST_HEAD(HFClist);
46static DEFINE_RWLOCK(HFClock);
47 66
48enum { 67enum {
49 HFC_CCD_2BD0, 68 HFC_CCD_2BD0,
@@ -114,7 +133,6 @@ struct hfcPCI_hw {
114 133
115 134
116struct hfc_pci { 135struct hfc_pci {
117 struct list_head list;
118 u_char subtype; 136 u_char subtype;
119 u_char chanlimit; 137 u_char chanlimit;
120 u_char initdone; 138 u_char initdone;
@@ -520,9 +538,9 @@ receive_dmsg(struct hfc_pci *hc)
520} 538}
521 539
522/* 540/*
523 * check for transparent receive data and read max one threshold size if avail 541 * check for transparent receive data and read max one 'poll' size if avail
524 */ 542 */
525static int 543static void
526hfcpci_empty_fifo_trans(struct bchannel *bch, struct bzfifo *bz, u_char *bdata) 544hfcpci_empty_fifo_trans(struct bchannel *bch, struct bzfifo *bz, u_char *bdata)
527{ 545{
528 __le16 *z1r, *z2r; 546 __le16 *z1r, *z2r;
@@ -534,17 +552,19 @@ hfcpci_empty_fifo_trans(struct bchannel *bch, struct bzfifo *bz, u_char *bdata)
534 552
535 fcnt = le16_to_cpu(*z1r) - le16_to_cpu(*z2r); 553 fcnt = le16_to_cpu(*z1r) - le16_to_cpu(*z2r);
536 if (!fcnt) 554 if (!fcnt)
537 return 0; /* no data avail */ 555 return; /* no data avail */
538 556
539 if (fcnt <= 0) 557 if (fcnt <= 0)
540 fcnt += B_FIFO_SIZE; /* bytes actually buffered */ 558 fcnt += B_FIFO_SIZE; /* bytes actually buffered */
541 if (fcnt > HFCPCI_BTRANS_THRESHOLD)
542 fcnt = HFCPCI_BTRANS_THRESHOLD; /* limit size */
543
544 new_z2 = le16_to_cpu(*z2r) + fcnt; /* new position in fifo */ 559 new_z2 = le16_to_cpu(*z2r) + fcnt; /* new position in fifo */
545 if (new_z2 >= (B_FIFO_SIZE + B_SUB_VAL)) 560 if (new_z2 >= (B_FIFO_SIZE + B_SUB_VAL))
546 new_z2 -= B_FIFO_SIZE; /* buffer wrap */ 561 new_z2 -= B_FIFO_SIZE; /* buffer wrap */
547 562
563 if (fcnt > MAX_DATA_SIZE) { /* flush, if oversized */
564 *z2r = cpu_to_le16(new_z2); /* new position */
565 return;
566 }
567
548 bch->rx_skb = mI_alloc_skb(fcnt, GFP_ATOMIC); 568 bch->rx_skb = mI_alloc_skb(fcnt, GFP_ATOMIC);
549 if (bch->rx_skb) { 569 if (bch->rx_skb) {
550 ptr = skb_put(bch->rx_skb, fcnt); 570 ptr = skb_put(bch->rx_skb, fcnt);
@@ -569,7 +589,6 @@ hfcpci_empty_fifo_trans(struct bchannel *bch, struct bzfifo *bz, u_char *bdata)
569 printk(KERN_WARNING "HFCPCI: receive out of memory\n"); 589 printk(KERN_WARNING "HFCPCI: receive out of memory\n");
570 590
571 *z2r = cpu_to_le16(new_z2); /* new position */ 591 *z2r = cpu_to_le16(new_z2); /* new position */
572 return 1;
573} 592}
574 593
575/* 594/*
@@ -580,12 +599,11 @@ main_rec_hfcpci(struct bchannel *bch)
580{ 599{
581 struct hfc_pci *hc = bch->hw; 600 struct hfc_pci *hc = bch->hw;
582 int rcnt, real_fifo; 601 int rcnt, real_fifo;
583 int receive, count = 5; 602 int receive = 0, count = 5;
584 struct bzfifo *bz; 603 struct bzfifo *bz;
585 u_char *bdata; 604 u_char *bdata;
586 struct zt *zp; 605 struct zt *zp;
587 606
588
589 if ((bch->nr & 2) && (!hc->hw.bswapped)) { 607 if ((bch->nr & 2) && (!hc->hw.bswapped)) {
590 bz = &((union fifo_area *)(hc->hw.fifos))->b_chans.rxbz_b2; 608 bz = &((union fifo_area *)(hc->hw.fifos))->b_chans.rxbz_b2;
591 bdata = ((union fifo_area *)(hc->hw.fifos))->b_chans.rxdat_b2; 609 bdata = ((union fifo_area *)(hc->hw.fifos))->b_chans.rxdat_b2;
@@ -625,9 +643,10 @@ Begin:
625 receive = 1; 643 receive = 1;
626 else 644 else
627 receive = 0; 645 receive = 0;
628 } else if (test_bit(FLG_TRANSPARENT, &bch->Flags)) 646 } else if (test_bit(FLG_TRANSPARENT, &bch->Flags)) {
629 receive = hfcpci_empty_fifo_trans(bch, bz, bdata); 647 hfcpci_empty_fifo_trans(bch, bz, bdata);
630 else 648 return;
649 } else
631 receive = 0; 650 receive = 0;
632 if (count && receive) 651 if (count && receive)
633 goto Begin; 652 goto Begin;
@@ -751,11 +770,41 @@ hfcpci_fill_fifo(struct bchannel *bch)
751 /* fcnt contains available bytes in fifo */ 770 /* fcnt contains available bytes in fifo */
752 fcnt = B_FIFO_SIZE - fcnt; 771 fcnt = B_FIFO_SIZE - fcnt;
753 /* remaining bytes to send (bytes in fifo) */ 772 /* remaining bytes to send (bytes in fifo) */
773
774 /* "fill fifo if empty" feature */
775 if (test_bit(FLG_FILLEMPTY, &bch->Flags) && !fcnt) {
776 /* printk(KERN_DEBUG "%s: buffer empty, so we have "
777 "underrun\n", __func__); */
778 /* fill buffer, to prevent future underrun */
779 count = HFCPCI_FILLEMPTY;
780 new_z1 = le16_to_cpu(*z1t) + count;
781 /* new buffer Position */
782 if (new_z1 >= (B_FIFO_SIZE + B_SUB_VAL))
783 new_z1 -= B_FIFO_SIZE; /* buffer wrap */
784 dst = bdata + (le16_to_cpu(*z1t) - B_SUB_VAL);
785 maxlen = (B_FIFO_SIZE + B_SUB_VAL) - le16_to_cpu(*z1t);
786 /* end of fifo */
787 if (bch->debug & DEBUG_HW_BFIFO)
788 printk(KERN_DEBUG "hfcpci_FFt fillempty "
789 "fcnt(%d) maxl(%d) nz1(%x) dst(%p)\n",
790 fcnt, maxlen, new_z1, dst);
791 fcnt += count;
792 if (maxlen > count)
793 maxlen = count; /* limit size */
794 memset(dst, 0x2a, maxlen); /* first copy */
795 count -= maxlen; /* remaining bytes */
796 if (count) {
797 dst = bdata; /* start of buffer */
798 memset(dst, 0x2a, count);
799 }
800 *z1t = cpu_to_le16(new_z1); /* now send data */
801 }
802
754next_t_frame: 803next_t_frame:
755 count = bch->tx_skb->len - bch->tx_idx; 804 count = bch->tx_skb->len - bch->tx_idx;
756 /* maximum fill shall be HFCPCI_BTRANS_MAX */ 805 /* maximum fill shall be poll*2 */
757 if (count > HFCPCI_BTRANS_MAX - fcnt) 806 if (count > (poll << 1) - fcnt)
758 count = HFCPCI_BTRANS_MAX - fcnt; 807 count = (poll << 1) - fcnt;
759 if (count <= 0) 808 if (count <= 0)
760 return; 809 return;
761 /* data is suitable for fifo */ 810 /* data is suitable for fifo */
@@ -1135,37 +1184,37 @@ hfcpci_int(int intno, void *dev_id)
1135 val &= ~0x80; 1184 val &= ~0x80;
1136 Write_hfc(hc, HFCPCI_CTMT, hc->hw.ctmt | HFCPCI_CLTIMER); 1185 Write_hfc(hc, HFCPCI_CTMT, hc->hw.ctmt | HFCPCI_CLTIMER);
1137 } 1186 }
1138 if (val & 0x08) { 1187 if (val & 0x08) { /* B1 rx */
1139 bch = Sel_BCS(hc, hc->hw.bswapped ? 2 : 1); 1188 bch = Sel_BCS(hc, hc->hw.bswapped ? 2 : 1);
1140 if (bch) 1189 if (bch)
1141 main_rec_hfcpci(bch); 1190 main_rec_hfcpci(bch);
1142 else if (hc->dch.debug) 1191 else if (hc->dch.debug)
1143 printk(KERN_DEBUG "hfcpci spurious 0x08 IRQ\n"); 1192 printk(KERN_DEBUG "hfcpci spurious 0x08 IRQ\n");
1144 } 1193 }
1145 if (val & 0x10) { 1194 if (val & 0x10) { /* B2 rx */
1146 bch = Sel_BCS(hc, 2); 1195 bch = Sel_BCS(hc, 2);
1147 if (bch) 1196 if (bch)
1148 main_rec_hfcpci(bch); 1197 main_rec_hfcpci(bch);
1149 else if (hc->dch.debug) 1198 else if (hc->dch.debug)
1150 printk(KERN_DEBUG "hfcpci spurious 0x10 IRQ\n"); 1199 printk(KERN_DEBUG "hfcpci spurious 0x10 IRQ\n");
1151 } 1200 }
1152 if (val & 0x01) { 1201 if (val & 0x01) { /* B1 tx */
1153 bch = Sel_BCS(hc, hc->hw.bswapped ? 2 : 1); 1202 bch = Sel_BCS(hc, hc->hw.bswapped ? 2 : 1);
1154 if (bch) 1203 if (bch)
1155 tx_birq(bch); 1204 tx_birq(bch);
1156 else if (hc->dch.debug) 1205 else if (hc->dch.debug)
1157 printk(KERN_DEBUG "hfcpci spurious 0x01 IRQ\n"); 1206 printk(KERN_DEBUG "hfcpci spurious 0x01 IRQ\n");
1158 } 1207 }
1159 if (val & 0x02) { 1208 if (val & 0x02) { /* B2 tx */
1160 bch = Sel_BCS(hc, 2); 1209 bch = Sel_BCS(hc, 2);
1161 if (bch) 1210 if (bch)
1162 tx_birq(bch); 1211 tx_birq(bch);
1163 else if (hc->dch.debug) 1212 else if (hc->dch.debug)
1164 printk(KERN_DEBUG "hfcpci spurious 0x02 IRQ\n"); 1213 printk(KERN_DEBUG "hfcpci spurious 0x02 IRQ\n");
1165 } 1214 }
1166 if (val & 0x20) 1215 if (val & 0x20) /* D rx */
1167 receive_dmsg(hc); 1216 receive_dmsg(hc);
1168 if (val & 0x04) { /* dframe transmitted */ 1217 if (val & 0x04) { /* D tx */
1169 if (test_and_clear_bit(FLG_BUSY_TIMER, &hc->dch.Flags)) 1218 if (test_and_clear_bit(FLG_BUSY_TIMER, &hc->dch.Flags))
1170 del_timer(&hc->dch.timer); 1219 del_timer(&hc->dch.timer);
1171 tx_dirq(&hc->dch); 1220 tx_dirq(&hc->dch);
@@ -1283,14 +1332,16 @@ mode_hfcpci(struct bchannel *bch, int bc, int protocol)
1283 } 1332 }
1284 if (fifo2 & 2) { 1333 if (fifo2 & 2) {
1285 hc->hw.fifo_en |= HFCPCI_FIFOEN_B2; 1334 hc->hw.fifo_en |= HFCPCI_FIFOEN_B2;
1286 hc->hw.int_m1 |= (HFCPCI_INTS_B2TRANS + 1335 if (!tics)
1287 HFCPCI_INTS_B2REC); 1336 hc->hw.int_m1 |= (HFCPCI_INTS_B2TRANS +
1337 HFCPCI_INTS_B2REC);
1288 hc->hw.ctmt |= 2; 1338 hc->hw.ctmt |= 2;
1289 hc->hw.conn &= ~0x18; 1339 hc->hw.conn &= ~0x18;
1290 } else { 1340 } else {
1291 hc->hw.fifo_en |= HFCPCI_FIFOEN_B1; 1341 hc->hw.fifo_en |= HFCPCI_FIFOEN_B1;
1292 hc->hw.int_m1 |= (HFCPCI_INTS_B1TRANS + 1342 if (!tics)
1293 HFCPCI_INTS_B1REC); 1343 hc->hw.int_m1 |= (HFCPCI_INTS_B1TRANS +
1344 HFCPCI_INTS_B1REC);
1294 hc->hw.ctmt |= 1; 1345 hc->hw.ctmt |= 1;
1295 hc->hw.conn &= ~0x03; 1346 hc->hw.conn &= ~0x03;
1296 } 1347 }
@@ -1398,7 +1449,8 @@ set_hfcpci_rxtest(struct bchannel *bch, int protocol, int chan)
1398 if (chan & 2) { 1449 if (chan & 2) {
1399 hc->hw.sctrl_r |= SCTRL_B2_ENA; 1450 hc->hw.sctrl_r |= SCTRL_B2_ENA;
1400 hc->hw.fifo_en |= HFCPCI_FIFOEN_B2RX; 1451 hc->hw.fifo_en |= HFCPCI_FIFOEN_B2RX;
1401 hc->hw.int_m1 |= HFCPCI_INTS_B2REC; 1452 if (!tics)
1453 hc->hw.int_m1 |= HFCPCI_INTS_B2REC;
1402 hc->hw.ctmt |= 2; 1454 hc->hw.ctmt |= 2;
1403 hc->hw.conn &= ~0x18; 1455 hc->hw.conn &= ~0x18;
1404#ifdef REVERSE_BITORDER 1456#ifdef REVERSE_BITORDER
@@ -1407,7 +1459,8 @@ set_hfcpci_rxtest(struct bchannel *bch, int protocol, int chan)
1407 } else { 1459 } else {
1408 hc->hw.sctrl_r |= SCTRL_B1_ENA; 1460 hc->hw.sctrl_r |= SCTRL_B1_ENA;
1409 hc->hw.fifo_en |= HFCPCI_FIFOEN_B1RX; 1461 hc->hw.fifo_en |= HFCPCI_FIFOEN_B1RX;
1410 hc->hw.int_m1 |= HFCPCI_INTS_B1REC; 1462 if (!tics)
1463 hc->hw.int_m1 |= HFCPCI_INTS_B1REC;
1411 hc->hw.ctmt |= 1; 1464 hc->hw.ctmt |= 1;
1412 hc->hw.conn &= ~0x03; 1465 hc->hw.conn &= ~0x03;
1413#ifdef REVERSE_BITORDER 1466#ifdef REVERSE_BITORDER
@@ -1481,11 +1534,17 @@ deactivate_bchannel(struct bchannel *bch)
1481static int 1534static int
1482channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq) 1535channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
1483{ 1536{
1484 int ret = 0; 1537 int ret = 0;
1485 1538
1486 switch (cq->op) { 1539 switch (cq->op) {
1487 case MISDN_CTRL_GETOP: 1540 case MISDN_CTRL_GETOP:
1488 cq->op = 0; 1541 cq->op = MISDN_CTRL_FILL_EMPTY;
1542 break;
1543 case MISDN_CTRL_FILL_EMPTY: /* fill fifo, if empty */
1544 test_and_set_bit(FLG_FILLEMPTY, &bch->Flags);
1545 if (debug & DEBUG_HW_OPEN)
1546 printk(KERN_DEBUG "%s: FILL_EMPTY request (nr=%d "
1547 "off=%d)\n", __func__, bch->nr, !!cq->p1);
1489 break; 1548 break;
1490 default: 1549 default:
1491 printk(KERN_WARNING "%s: unknown Op %x\n", __func__, cq->op); 1550 printk(KERN_WARNING "%s: unknown Op %x\n", __func__, cq->op);
@@ -1859,6 +1918,10 @@ open_dchannel(struct hfc_pci *hc, struct mISDNchannel *ch,
1859 hc->dch.dev.id, __builtin_return_address(0)); 1918 hc->dch.dev.id, __builtin_return_address(0));
1860 if (rq->protocol == ISDN_P_NONE) 1919 if (rq->protocol == ISDN_P_NONE)
1861 return -EINVAL; 1920 return -EINVAL;
1921 if (rq->adr.channel == 1) {
1922 /* TODO: E-Channel */
1923 return -EINVAL;
1924 }
1862 if (!hc->initdone) { 1925 if (!hc->initdone) {
1863 if (rq->protocol == ISDN_P_TE_S0) { 1926 if (rq->protocol == ISDN_P_TE_S0) {
1864 err = create_l1(&hc->dch, hfc_l1callback); 1927 err = create_l1(&hc->dch, hfc_l1callback);
@@ -1874,6 +1937,11 @@ open_dchannel(struct hfc_pci *hc, struct mISDNchannel *ch,
1874 if (rq->protocol != ch->protocol) { 1937 if (rq->protocol != ch->protocol) {
1875 if (hc->hw.protocol == ISDN_P_TE_S0) 1938 if (hc->hw.protocol == ISDN_P_TE_S0)
1876 l1_event(hc->dch.l1, CLOSE_CHANNEL); 1939 l1_event(hc->dch.l1, CLOSE_CHANNEL);
1940 if (rq->protocol == ISDN_P_TE_S0) {
1941 err = create_l1(&hc->dch, hfc_l1callback);
1942 if (err)
1943 return err;
1944 }
1877 hc->hw.protocol = rq->protocol; 1945 hc->hw.protocol = rq->protocol;
1878 ch->protocol = rq->protocol; 1946 ch->protocol = rq->protocol;
1879 hfcpci_setmode(hc); 1947 hfcpci_setmode(hc);
@@ -1903,6 +1971,7 @@ open_bchannel(struct hfc_pci *hc, struct channel_req *rq)
1903 bch = &hc->bch[rq->adr.channel - 1]; 1971 bch = &hc->bch[rq->adr.channel - 1];
1904 if (test_and_set_bit(FLG_OPEN, &bch->Flags)) 1972 if (test_and_set_bit(FLG_OPEN, &bch->Flags))
1905 return -EBUSY; /* b-channel can be only open once */ 1973 return -EBUSY; /* b-channel can be only open once */
1974 test_and_clear_bit(FLG_FILLEMPTY, &bch->Flags);
1906 bch->ch.protocol = rq->protocol; 1975 bch->ch.protocol = rq->protocol;
1907 rq->ch = &bch->ch; /* TODO: E-channel */ 1976 rq->ch = &bch->ch; /* TODO: E-channel */
1908 if (!try_module_get(THIS_MODULE)) 1977 if (!try_module_get(THIS_MODULE))
@@ -1928,7 +1997,8 @@ hfc_dctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1928 switch (cmd) { 1997 switch (cmd) {
1929 case OPEN_CHANNEL: 1998 case OPEN_CHANNEL:
1930 rq = arg; 1999 rq = arg;
1931 if (rq->adr.channel == 0) 2000 if ((rq->protocol == ISDN_P_TE_S0) ||
2001 (rq->protocol == ISDN_P_NT_S0))
1932 err = open_dchannel(hc, ch, rq); 2002 err = open_dchannel(hc, ch, rq);
1933 else 2003 else
1934 err = open_bchannel(hc, rq); 2004 err = open_bchannel(hc, rq);
@@ -2027,7 +2097,6 @@ release_card(struct hfc_pci *hc) {
2027 mISDN_freebchannel(&hc->bch[1]); 2097 mISDN_freebchannel(&hc->bch[1]);
2028 mISDN_freebchannel(&hc->bch[0]); 2098 mISDN_freebchannel(&hc->bch[0]);
2029 mISDN_freedchannel(&hc->dch); 2099 mISDN_freedchannel(&hc->dch);
2030 list_del(&hc->list);
2031 pci_set_drvdata(hc->pdev, NULL); 2100 pci_set_drvdata(hc->pdev, NULL);
2032 kfree(hc); 2101 kfree(hc);
2033} 2102}
@@ -2037,12 +2106,8 @@ setup_card(struct hfc_pci *card)
2037{ 2106{
2038 int err = -EINVAL; 2107 int err = -EINVAL;
2039 u_int i; 2108 u_int i;
2040 u_long flags;
2041 char name[MISDN_MAX_IDLEN]; 2109 char name[MISDN_MAX_IDLEN];
2042 2110
2043 if (HFC_cnt >= MAX_CARDS)
2044 return -EINVAL; /* maybe better value */
2045
2046 card->dch.debug = debug; 2111 card->dch.debug = debug;
2047 spin_lock_init(&card->lock); 2112 spin_lock_init(&card->lock);
2048 mISDN_initdchannel(&card->dch, MAX_DFRAME_LEN_L1, ph_state); 2113 mISDN_initdchannel(&card->dch, MAX_DFRAME_LEN_L1, ph_state);
@@ -2068,13 +2133,10 @@ setup_card(struct hfc_pci *card)
2068 if (err) 2133 if (err)
2069 goto error; 2134 goto error;
2070 snprintf(name, MISDN_MAX_IDLEN - 1, "hfc-pci.%d", HFC_cnt + 1); 2135 snprintf(name, MISDN_MAX_IDLEN - 1, "hfc-pci.%d", HFC_cnt + 1);
2071 err = mISDN_register_device(&card->dch.dev, name); 2136 err = mISDN_register_device(&card->dch.dev, &card->pdev->dev, name);
2072 if (err) 2137 if (err)
2073 goto error; 2138 goto error;
2074 HFC_cnt++; 2139 HFC_cnt++;
2075 write_lock_irqsave(&HFClock, flags);
2076 list_add_tail(&card->list, &HFClist);
2077 write_unlock_irqrestore(&HFClock, flags);
2078 printk(KERN_INFO "HFC %d cards installed\n", HFC_cnt); 2140 printk(KERN_INFO "HFC %d cards installed\n", HFC_cnt);
2079 return 0; 2141 return 0;
2080error: 2142error:
@@ -2210,15 +2272,12 @@ static void __devexit
2210hfc_remove_pci(struct pci_dev *pdev) 2272hfc_remove_pci(struct pci_dev *pdev)
2211{ 2273{
2212 struct hfc_pci *card = pci_get_drvdata(pdev); 2274 struct hfc_pci *card = pci_get_drvdata(pdev);
2213 u_long flags;
2214 2275
2215 if (card) { 2276 if (card)
2216 write_lock_irqsave(&HFClock, flags);
2217 release_card(card); 2277 release_card(card);
2218 write_unlock_irqrestore(&HFClock, flags); 2278 else
2219 } else
2220 if (debug) 2279 if (debug)
2221 printk(KERN_WARNING "%s: drvdata allready removed\n", 2280 printk(KERN_WARNING "%s: drvdata already removed\n",
2222 __func__); 2281 __func__);
2223} 2282}
2224 2283
@@ -2230,25 +2289,97 @@ static struct pci_driver hfc_driver = {
2230 .id_table = hfc_ids, 2289 .id_table = hfc_ids,
2231}; 2290};
2232 2291
2292static int
2293_hfcpci_softirq(struct device *dev, void *arg)
2294{
2295 struct hfc_pci *hc = dev_get_drvdata(dev);
2296 struct bchannel *bch;
2297 if (hc == NULL)
2298 return 0;
2299
2300 if (hc->hw.int_m2 & HFCPCI_IRQ_ENABLE) {
2301 spin_lock(&hc->lock);
2302 bch = Sel_BCS(hc, hc->hw.bswapped ? 2 : 1);
2303 if (bch && bch->state == ISDN_P_B_RAW) { /* B1 rx&tx */
2304 main_rec_hfcpci(bch);
2305 tx_birq(bch);
2306 }
2307 bch = Sel_BCS(hc, hc->hw.bswapped ? 1 : 2);
2308 if (bch && bch->state == ISDN_P_B_RAW) { /* B2 rx&tx */
2309 main_rec_hfcpci(bch);
2310 tx_birq(bch);
2311 }
2312 spin_unlock(&hc->lock);
2313 }
2314 return 0;
2315}
2316
2317static void
2318hfcpci_softirq(void *arg)
2319{
2320 (void) driver_for_each_device(&hfc_driver.driver, NULL, arg,
2321 _hfcpci_softirq);
2322
2323 /* if next event would be in the past ... */
2324 if ((s32)(hfc_jiffies + tics - jiffies) <= 0)
2325 hfc_jiffies = jiffies + 1;
2326 else
2327 hfc_jiffies += tics;
2328 hfc_tl.expires = hfc_jiffies;
2329 add_timer(&hfc_tl);
2330}
2331
2233static int __init 2332static int __init
2234HFC_init(void) 2333HFC_init(void)
2235{ 2334{
2236 int err; 2335 int err;
2237 2336
2337 if (!poll)
2338 poll = HFCPCI_BTRANS_THRESHOLD;
2339
2340 if (poll != HFCPCI_BTRANS_THRESHOLD) {
2341 tics = (poll * HZ) / 8000;
2342 if (tics < 1)
2343 tics = 1;
2344 poll = (tics * 8000) / HZ;
2345 if (poll > 256 || poll < 8) {
2346 printk(KERN_ERR "%s: Wrong poll value %d not in range "
2347 "of 8..256.\n", __func__, poll);
2348 err = -EINVAL;
2349 return err;
2350 }
2351 }
2352 if (poll != HFCPCI_BTRANS_THRESHOLD) {
2353 printk(KERN_INFO "%s: Using alternative poll value of %d\n",
2354 __func__, poll);
2355 hfc_tl.function = (void *)hfcpci_softirq;
2356 hfc_tl.data = 0;
2357 init_timer(&hfc_tl);
2358 hfc_tl.expires = jiffies + tics;
2359 hfc_jiffies = hfc_tl.expires;
2360 add_timer(&hfc_tl);
2361 } else
2362 tics = 0; /* indicate the use of controller's timer */
2363
2238 err = pci_register_driver(&hfc_driver); 2364 err = pci_register_driver(&hfc_driver);
2365 if (err) {
2366 if (timer_pending(&hfc_tl))
2367 del_timer(&hfc_tl);
2368 }
2369
2239 return err; 2370 return err;
2240} 2371}
2241 2372
2242static void __exit 2373static void __exit
2243HFC_cleanup(void) 2374HFC_cleanup(void)
2244{ 2375{
2245 struct hfc_pci *card, *next; 2376 if (timer_pending(&hfc_tl))
2377 del_timer(&hfc_tl);
2246 2378
2247 list_for_each_entry_safe(card, next, &HFClist, list) {
2248 release_card(card);
2249 }
2250 pci_unregister_driver(&hfc_driver); 2379 pci_unregister_driver(&hfc_driver);
2251} 2380}
2252 2381
2253module_init(HFC_init); 2382module_init(HFC_init);
2254module_exit(HFC_cleanup); 2383module_exit(HFC_cleanup);
2384
2385MODULE_DEVICE_TABLE(pci, hfc_ids);
diff --git a/drivers/isdn/hardware/mISDN/hfcsusb.c b/drivers/isdn/hardware/mISDN/hfcsusb.c
new file mode 100644
index 000000000000..ba6925fbf38a
--- /dev/null
+++ b/drivers/isdn/hardware/mISDN/hfcsusb.c
@@ -0,0 +1,2196 @@
1/* hfcsusb.c
2 * mISDN driver for Colognechip HFC-S USB chip
3 *
4 * Copyright 2001 by Peter Sprenger (sprenger@moving-bytes.de)
5 * Copyright 2008 by Martin Bachem (info@bachem-it.com)
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 *
21 *
22 * module params
23 * debug=<n>, default=0, with n=0xHHHHGGGG
24 * H - l1 driver flags described in hfcsusb.h
25 * G - common mISDN debug flags described at mISDNhw.h
26 *
27 * poll=<n>, default 128
28 * n : burst size of PH_DATA_IND at transparent rx data
29 *
30 */
31
32#include <linux/module.h>
33#include <linux/delay.h>
34#include <linux/usb.h>
35#include <linux/mISDNhw.h>
36#include "hfcsusb.h"
37
38const char *hfcsusb_rev = "Revision: 0.3.3 (socket), 2008-11-05";
39
40static unsigned int debug;
41static int poll = DEFAULT_TRANSP_BURST_SZ;
42
43static LIST_HEAD(HFClist);
44static DEFINE_RWLOCK(HFClock);
45
46
47MODULE_AUTHOR("Martin Bachem");
48MODULE_LICENSE("GPL");
49module_param(debug, uint, S_IRUGO | S_IWUSR);
50module_param(poll, int, 0);
51
52static int hfcsusb_cnt;
53
54/* some function prototypes */
55static void hfcsusb_ph_command(struct hfcsusb *hw, u_char command);
56static void release_hw(struct hfcsusb *hw);
57static void reset_hfcsusb(struct hfcsusb *hw);
58static void setPortMode(struct hfcsusb *hw);
59static void hfcsusb_start_endpoint(struct hfcsusb *hw, int channel);
60static void hfcsusb_stop_endpoint(struct hfcsusb *hw, int channel);
61static int hfcsusb_setup_bch(struct bchannel *bch, int protocol);
62static void deactivate_bchannel(struct bchannel *bch);
63static void hfcsusb_ph_info(struct hfcsusb *hw);
64
65/* start next background transfer for control channel */
66static void
67ctrl_start_transfer(struct hfcsusb *hw)
68{
69 if (debug & DBG_HFC_CALL_TRACE)
70 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
71
72 if (hw->ctrl_cnt) {
73 hw->ctrl_urb->pipe = hw->ctrl_out_pipe;
74 hw->ctrl_urb->setup_packet = (u_char *)&hw->ctrl_write;
75 hw->ctrl_urb->transfer_buffer = NULL;
76 hw->ctrl_urb->transfer_buffer_length = 0;
77 hw->ctrl_write.wIndex =
78 cpu_to_le16(hw->ctrl_buff[hw->ctrl_out_idx].hfcs_reg);
79 hw->ctrl_write.wValue =
80 cpu_to_le16(hw->ctrl_buff[hw->ctrl_out_idx].reg_val);
81
82 usb_submit_urb(hw->ctrl_urb, GFP_ATOMIC);
83 }
84}
85
86/*
87 * queue a control transfer request to write HFC-S USB
88 * chip register using CTRL resuest queue
89 */
90static int write_reg(struct hfcsusb *hw, __u8 reg, __u8 val)
91{
92 struct ctrl_buf *buf;
93
94 if (debug & DBG_HFC_CALL_TRACE)
95 printk(KERN_DEBUG "%s: %s reg(0x%02x) val(0x%02x)\n",
96 hw->name, __func__, reg, val);
97
98 spin_lock(&hw->ctrl_lock);
99 if (hw->ctrl_cnt >= HFC_CTRL_BUFSIZE)
100 return 1;
101 buf = &hw->ctrl_buff[hw->ctrl_in_idx];
102 buf->hfcs_reg = reg;
103 buf->reg_val = val;
104 if (++hw->ctrl_in_idx >= HFC_CTRL_BUFSIZE)
105 hw->ctrl_in_idx = 0;
106 if (++hw->ctrl_cnt == 1)
107 ctrl_start_transfer(hw);
108 spin_unlock(&hw->ctrl_lock);
109
110 return 0;
111}
112
113/* control completion routine handling background control cmds */
114static void
115ctrl_complete(struct urb *urb)
116{
117 struct hfcsusb *hw = (struct hfcsusb *) urb->context;
118 struct ctrl_buf *buf;
119
120 if (debug & DBG_HFC_CALL_TRACE)
121 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
122
123 urb->dev = hw->dev;
124 if (hw->ctrl_cnt) {
125 buf = &hw->ctrl_buff[hw->ctrl_out_idx];
126 hw->ctrl_cnt--; /* decrement actual count */
127 if (++hw->ctrl_out_idx >= HFC_CTRL_BUFSIZE)
128 hw->ctrl_out_idx = 0; /* pointer wrap */
129
130 ctrl_start_transfer(hw); /* start next transfer */
131 }
132}
133
134/* handle LED bits */
135static void
136set_led_bit(struct hfcsusb *hw, signed short led_bits, int set_on)
137{
138 if (set_on) {
139 if (led_bits < 0)
140 hw->led_state &= ~abs(led_bits);
141 else
142 hw->led_state |= led_bits;
143 } else {
144 if (led_bits < 0)
145 hw->led_state |= abs(led_bits);
146 else
147 hw->led_state &= ~led_bits;
148 }
149}
150
151/* handle LED requests */
152static void
153handle_led(struct hfcsusb *hw, int event)
154{
155 struct hfcsusb_vdata *driver_info = (struct hfcsusb_vdata *)
156 hfcsusb_idtab[hw->vend_idx].driver_info;
157 __u8 tmpled;
158
159 if (driver_info->led_scheme == LED_OFF)
160 return;
161 tmpled = hw->led_state;
162
163 switch (event) {
164 case LED_POWER_ON:
165 set_led_bit(hw, driver_info->led_bits[0], 1);
166 set_led_bit(hw, driver_info->led_bits[1], 0);
167 set_led_bit(hw, driver_info->led_bits[2], 0);
168 set_led_bit(hw, driver_info->led_bits[3], 0);
169 break;
170 case LED_POWER_OFF:
171 set_led_bit(hw, driver_info->led_bits[0], 0);
172 set_led_bit(hw, driver_info->led_bits[1], 0);
173 set_led_bit(hw, driver_info->led_bits[2], 0);
174 set_led_bit(hw, driver_info->led_bits[3], 0);
175 break;
176 case LED_S0_ON:
177 set_led_bit(hw, driver_info->led_bits[1], 1);
178 break;
179 case LED_S0_OFF:
180 set_led_bit(hw, driver_info->led_bits[1], 0);
181 break;
182 case LED_B1_ON:
183 set_led_bit(hw, driver_info->led_bits[2], 1);
184 break;
185 case LED_B1_OFF:
186 set_led_bit(hw, driver_info->led_bits[2], 0);
187 break;
188 case LED_B2_ON:
189 set_led_bit(hw, driver_info->led_bits[3], 1);
190 break;
191 case LED_B2_OFF:
192 set_led_bit(hw, driver_info->led_bits[3], 0);
193 break;
194 }
195
196 if (hw->led_state != tmpled) {
197 if (debug & DBG_HFC_CALL_TRACE)
198 printk(KERN_DEBUG "%s: %s reg(0x%02x) val(x%02x)\n",
199 hw->name, __func__,
200 HFCUSB_P_DATA, hw->led_state);
201
202 write_reg(hw, HFCUSB_P_DATA, hw->led_state);
203 }
204}
205
206/*
207 * Layer2 -> Layer 1 Bchannel data
208 */
209static int
210hfcusb_l2l1B(struct mISDNchannel *ch, struct sk_buff *skb)
211{
212 struct bchannel *bch = container_of(ch, struct bchannel, ch);
213 struct hfcsusb *hw = bch->hw;
214 int ret = -EINVAL;
215 struct mISDNhead *hh = mISDN_HEAD_P(skb);
216 u_long flags;
217
218 if (debug & DBG_HFC_CALL_TRACE)
219 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
220
221 switch (hh->prim) {
222 case PH_DATA_REQ:
223 spin_lock_irqsave(&hw->lock, flags);
224 ret = bchannel_senddata(bch, skb);
225 spin_unlock_irqrestore(&hw->lock, flags);
226 if (debug & DBG_HFC_CALL_TRACE)
227 printk(KERN_DEBUG "%s: %s PH_DATA_REQ ret(%i)\n",
228 hw->name, __func__, ret);
229 if (ret > 0) {
230 /*
231 * other l1 drivers don't send early confirms on
232 * transp data, but hfcsusb does because tx_next
233 * skb is needed in tx_iso_complete()
234 */
235 queue_ch_frame(ch, PH_DATA_CNF, hh->id, NULL);
236 ret = 0;
237 }
238 return ret;
239 case PH_ACTIVATE_REQ:
240 if (!test_and_set_bit(FLG_ACTIVE, &bch->Flags)) {
241 hfcsusb_start_endpoint(hw, bch->nr);
242 ret = hfcsusb_setup_bch(bch, ch->protocol);
243 } else
244 ret = 0;
245 if (!ret)
246 _queue_data(ch, PH_ACTIVATE_IND, MISDN_ID_ANY,
247 0, NULL, GFP_KERNEL);
248 break;
249 case PH_DEACTIVATE_REQ:
250 deactivate_bchannel(bch);
251 _queue_data(ch, PH_DEACTIVATE_IND, MISDN_ID_ANY,
252 0, NULL, GFP_KERNEL);
253 ret = 0;
254 break;
255 }
256 if (!ret)
257 dev_kfree_skb(skb);
258 return ret;
259}
260
261/*
262 * send full D/B channel status information
263 * as MPH_INFORMATION_IND
264 */
265static void
266hfcsusb_ph_info(struct hfcsusb *hw)
267{
268 struct ph_info *phi;
269 struct dchannel *dch = &hw->dch;
270 int i;
271
272 phi = kzalloc(sizeof(struct ph_info) +
273 dch->dev.nrbchan * sizeof(struct ph_info_ch), GFP_ATOMIC);
274 phi->dch.ch.protocol = hw->protocol;
275 phi->dch.ch.Flags = dch->Flags;
276 phi->dch.state = dch->state;
277 phi->dch.num_bch = dch->dev.nrbchan;
278 for (i = 0; i < dch->dev.nrbchan; i++) {
279 phi->bch[i].protocol = hw->bch[i].ch.protocol;
280 phi->bch[i].Flags = hw->bch[i].Flags;
281 }
282 _queue_data(&dch->dev.D, MPH_INFORMATION_IND, MISDN_ID_ANY,
283 sizeof(struct ph_info_dch) + dch->dev.nrbchan *
284 sizeof(struct ph_info_ch), phi, GFP_ATOMIC);
285}
286
287/*
288 * Layer2 -> Layer 1 Dchannel data
289 */
290static int
291hfcusb_l2l1D(struct mISDNchannel *ch, struct sk_buff *skb)
292{
293 struct mISDNdevice *dev = container_of(ch, struct mISDNdevice, D);
294 struct dchannel *dch = container_of(dev, struct dchannel, dev);
295 struct mISDNhead *hh = mISDN_HEAD_P(skb);
296 struct hfcsusb *hw = dch->hw;
297 int ret = -EINVAL;
298 u_long flags;
299
300 switch (hh->prim) {
301 case PH_DATA_REQ:
302 if (debug & DBG_HFC_CALL_TRACE)
303 printk(KERN_DEBUG "%s: %s: PH_DATA_REQ\n",
304 hw->name, __func__);
305
306 spin_lock_irqsave(&hw->lock, flags);
307 ret = dchannel_senddata(dch, skb);
308 spin_unlock_irqrestore(&hw->lock, flags);
309 if (ret > 0) {
310 ret = 0;
311 queue_ch_frame(ch, PH_DATA_CNF, hh->id, NULL);
312 }
313 break;
314
315 case PH_ACTIVATE_REQ:
316 if (debug & DBG_HFC_CALL_TRACE)
317 printk(KERN_DEBUG "%s: %s: PH_ACTIVATE_REQ %s\n",
318 hw->name, __func__,
319 (hw->protocol == ISDN_P_NT_S0) ? "NT" : "TE");
320
321 if (hw->protocol == ISDN_P_NT_S0) {
322 ret = 0;
323 if (test_bit(FLG_ACTIVE, &dch->Flags)) {
324 _queue_data(&dch->dev.D,
325 PH_ACTIVATE_IND, MISDN_ID_ANY, 0,
326 NULL, GFP_ATOMIC);
327 } else {
328 hfcsusb_ph_command(hw,
329 HFC_L1_ACTIVATE_NT);
330 test_and_set_bit(FLG_L2_ACTIVATED,
331 &dch->Flags);
332 }
333 } else {
334 hfcsusb_ph_command(hw, HFC_L1_ACTIVATE_TE);
335 ret = l1_event(dch->l1, hh->prim);
336 }
337 break;
338
339 case PH_DEACTIVATE_REQ:
340 if (debug & DBG_HFC_CALL_TRACE)
341 printk(KERN_DEBUG "%s: %s: PH_DEACTIVATE_REQ\n",
342 hw->name, __func__);
343 test_and_clear_bit(FLG_L2_ACTIVATED, &dch->Flags);
344
345 if (hw->protocol == ISDN_P_NT_S0) {
346 hfcsusb_ph_command(hw, HFC_L1_DEACTIVATE_NT);
347 spin_lock_irqsave(&hw->lock, flags);
348 skb_queue_purge(&dch->squeue);
349 if (dch->tx_skb) {
350 dev_kfree_skb(dch->tx_skb);
351 dch->tx_skb = NULL;
352 }
353 dch->tx_idx = 0;
354 if (dch->rx_skb) {
355 dev_kfree_skb(dch->rx_skb);
356 dch->rx_skb = NULL;
357 }
358 test_and_clear_bit(FLG_TX_BUSY, &dch->Flags);
359 spin_unlock_irqrestore(&hw->lock, flags);
360#ifdef FIXME
361 if (test_and_clear_bit(FLG_L1_BUSY, &dch->Flags))
362 dchannel_sched_event(&hc->dch, D_CLEARBUSY);
363#endif
364 ret = 0;
365 } else
366 ret = l1_event(dch->l1, hh->prim);
367 break;
368 case MPH_INFORMATION_REQ:
369 hfcsusb_ph_info(hw);
370 ret = 0;
371 break;
372 }
373
374 return ret;
375}
376
377/*
378 * Layer 1 callback function
379 */
380static int
381hfc_l1callback(struct dchannel *dch, u_int cmd)
382{
383 struct hfcsusb *hw = dch->hw;
384
385 if (debug & DBG_HFC_CALL_TRACE)
386 printk(KERN_DEBUG "%s: %s cmd 0x%x\n",
387 hw->name, __func__, cmd);
388
389 switch (cmd) {
390 case INFO3_P8:
391 case INFO3_P10:
392 case HW_RESET_REQ:
393 case HW_POWERUP_REQ:
394 break;
395
396 case HW_DEACT_REQ:
397 skb_queue_purge(&dch->squeue);
398 if (dch->tx_skb) {
399 dev_kfree_skb(dch->tx_skb);
400 dch->tx_skb = NULL;
401 }
402 dch->tx_idx = 0;
403 if (dch->rx_skb) {
404 dev_kfree_skb(dch->rx_skb);
405 dch->rx_skb = NULL;
406 }
407 test_and_clear_bit(FLG_TX_BUSY, &dch->Flags);
408 break;
409 case PH_ACTIVATE_IND:
410 test_and_set_bit(FLG_ACTIVE, &dch->Flags);
411 _queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL,
412 GFP_ATOMIC);
413 break;
414 case PH_DEACTIVATE_IND:
415 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
416 _queue_data(&dch->dev.D, cmd, MISDN_ID_ANY, 0, NULL,
417 GFP_ATOMIC);
418 break;
419 default:
420 if (dch->debug & DEBUG_HW)
421 printk(KERN_DEBUG "%s: %s: unknown cmd %x\n",
422 hw->name, __func__, cmd);
423 return -1;
424 }
425 hfcsusb_ph_info(hw);
426 return 0;
427}
428
429static int
430open_dchannel(struct hfcsusb *hw, struct mISDNchannel *ch,
431 struct channel_req *rq)
432{
433 int err = 0;
434
435 if (debug & DEBUG_HW_OPEN)
436 printk(KERN_DEBUG "%s: %s: dev(%d) open addr(%i) from %p\n",
437 hw->name, __func__, hw->dch.dev.id, rq->adr.channel,
438 __builtin_return_address(0));
439 if (rq->protocol == ISDN_P_NONE)
440 return -EINVAL;
441
442 test_and_clear_bit(FLG_ACTIVE, &hw->dch.Flags);
443 test_and_clear_bit(FLG_ACTIVE, &hw->ech.Flags);
444 hfcsusb_start_endpoint(hw, HFC_CHAN_D);
445
446 /* E-Channel logging */
447 if (rq->adr.channel == 1) {
448 if (hw->fifos[HFCUSB_PCM_RX].pipe) {
449 hfcsusb_start_endpoint(hw, HFC_CHAN_E);
450 set_bit(FLG_ACTIVE, &hw->ech.Flags);
451 _queue_data(&hw->ech.dev.D, PH_ACTIVATE_IND,
452 MISDN_ID_ANY, 0, NULL, GFP_ATOMIC);
453 } else
454 return -EINVAL;
455 }
456
457 if (!hw->initdone) {
458 hw->protocol = rq->protocol;
459 if (rq->protocol == ISDN_P_TE_S0) {
460 err = create_l1(&hw->dch, hfc_l1callback);
461 if (err)
462 return err;
463 }
464 setPortMode(hw);
465 ch->protocol = rq->protocol;
466 hw->initdone = 1;
467 } else {
468 if (rq->protocol != ch->protocol)
469 return -EPROTONOSUPPORT;
470 }
471
472 if (((ch->protocol == ISDN_P_NT_S0) && (hw->dch.state == 3)) ||
473 ((ch->protocol == ISDN_P_TE_S0) && (hw->dch.state == 7)))
474 _queue_data(ch, PH_ACTIVATE_IND, MISDN_ID_ANY,
475 0, NULL, GFP_KERNEL);
476 rq->ch = ch;
477 if (!try_module_get(THIS_MODULE))
478 printk(KERN_WARNING "%s: %s: cannot get module\n",
479 hw->name, __func__);
480 return 0;
481}
482
483static int
484open_bchannel(struct hfcsusb *hw, struct channel_req *rq)
485{
486 struct bchannel *bch;
487
488 if (rq->adr.channel > 2)
489 return -EINVAL;
490 if (rq->protocol == ISDN_P_NONE)
491 return -EINVAL;
492
493 if (debug & DBG_HFC_CALL_TRACE)
494 printk(KERN_DEBUG "%s: %s B%i\n",
495 hw->name, __func__, rq->adr.channel);
496
497 bch = &hw->bch[rq->adr.channel - 1];
498 if (test_and_set_bit(FLG_OPEN, &bch->Flags))
499 return -EBUSY; /* b-channel can be only open once */
500 test_and_clear_bit(FLG_FILLEMPTY, &bch->Flags);
501 bch->ch.protocol = rq->protocol;
502 rq->ch = &bch->ch;
503
504 /* start USB endpoint for bchannel */
505 if (rq->adr.channel == 1)
506 hfcsusb_start_endpoint(hw, HFC_CHAN_B1);
507 else
508 hfcsusb_start_endpoint(hw, HFC_CHAN_B2);
509
510 if (!try_module_get(THIS_MODULE))
511 printk(KERN_WARNING "%s: %s:cannot get module\n",
512 hw->name, __func__);
513 return 0;
514}
515
516static int
517channel_ctrl(struct hfcsusb *hw, struct mISDN_ctrl_req *cq)
518{
519 int ret = 0;
520
521 if (debug & DBG_HFC_CALL_TRACE)
522 printk(KERN_DEBUG "%s: %s op(0x%x) channel(0x%x)\n",
523 hw->name, __func__, (cq->op), (cq->channel));
524
525 switch (cq->op) {
526 case MISDN_CTRL_GETOP:
527 cq->op = MISDN_CTRL_LOOP | MISDN_CTRL_CONNECT |
528 MISDN_CTRL_DISCONNECT;
529 break;
530 default:
531 printk(KERN_WARNING "%s: %s: unknown Op %x\n",
532 hw->name, __func__, cq->op);
533 ret = -EINVAL;
534 break;
535 }
536 return ret;
537}
538
539/*
540 * device control function
541 */
542static int
543hfc_dctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
544{
545 struct mISDNdevice *dev = container_of(ch, struct mISDNdevice, D);
546 struct dchannel *dch = container_of(dev, struct dchannel, dev);
547 struct hfcsusb *hw = dch->hw;
548 struct channel_req *rq;
549 int err = 0;
550
551 if (dch->debug & DEBUG_HW)
552 printk(KERN_DEBUG "%s: %s: cmd:%x %p\n",
553 hw->name, __func__, cmd, arg);
554 switch (cmd) {
555 case OPEN_CHANNEL:
556 rq = arg;
557 if ((rq->protocol == ISDN_P_TE_S0) ||
558 (rq->protocol == ISDN_P_NT_S0))
559 err = open_dchannel(hw, ch, rq);
560 else
561 err = open_bchannel(hw, rq);
562 if (!err)
563 hw->open++;
564 break;
565 case CLOSE_CHANNEL:
566 hw->open--;
567 if (debug & DEBUG_HW_OPEN)
568 printk(KERN_DEBUG
569 "%s: %s: dev(%d) close from %p (open %d)\n",
570 hw->name, __func__, hw->dch.dev.id,
571 __builtin_return_address(0), hw->open);
572 if (!hw->open) {
573 hfcsusb_stop_endpoint(hw, HFC_CHAN_D);
574 if (hw->fifos[HFCUSB_PCM_RX].pipe)
575 hfcsusb_stop_endpoint(hw, HFC_CHAN_E);
576 handle_led(hw, LED_POWER_ON);
577 }
578 module_put(THIS_MODULE);
579 break;
580 case CONTROL_CHANNEL:
581 err = channel_ctrl(hw, arg);
582 break;
583 default:
584 if (dch->debug & DEBUG_HW)
585 printk(KERN_DEBUG "%s: %s: unknown command %x\n",
586 hw->name, __func__, cmd);
587 return -EINVAL;
588 }
589 return err;
590}
591
592/*
593 * S0 TE state change event handler
594 */
595static void
596ph_state_te(struct dchannel *dch)
597{
598 struct hfcsusb *hw = dch->hw;
599
600 if (debug & DEBUG_HW) {
601 if (dch->state <= HFC_MAX_TE_LAYER1_STATE)
602 printk(KERN_DEBUG "%s: %s: %s\n", hw->name, __func__,
603 HFC_TE_LAYER1_STATES[dch->state]);
604 else
605 printk(KERN_DEBUG "%s: %s: TE F%d\n",
606 hw->name, __func__, dch->state);
607 }
608
609 switch (dch->state) {
610 case 0:
611 l1_event(dch->l1, HW_RESET_IND);
612 break;
613 case 3:
614 l1_event(dch->l1, HW_DEACT_IND);
615 break;
616 case 5:
617 case 8:
618 l1_event(dch->l1, ANYSIGNAL);
619 break;
620 case 6:
621 l1_event(dch->l1, INFO2);
622 break;
623 case 7:
624 l1_event(dch->l1, INFO4_P8);
625 break;
626 }
627 if (dch->state == 7)
628 handle_led(hw, LED_S0_ON);
629 else
630 handle_led(hw, LED_S0_OFF);
631}
632
633/*
634 * S0 NT state change event handler
635 */
636static void
637ph_state_nt(struct dchannel *dch)
638{
639 struct hfcsusb *hw = dch->hw;
640
641 if (debug & DEBUG_HW) {
642 if (dch->state <= HFC_MAX_NT_LAYER1_STATE)
643 printk(KERN_DEBUG "%s: %s: %s\n",
644 hw->name, __func__,
645 HFC_NT_LAYER1_STATES[dch->state]);
646
647 else
648 printk(KERN_INFO DRIVER_NAME "%s: %s: NT G%d\n",
649 hw->name, __func__, dch->state);
650 }
651
652 switch (dch->state) {
653 case (1):
654 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
655 test_and_clear_bit(FLG_L2_ACTIVATED, &dch->Flags);
656 hw->nt_timer = 0;
657 hw->timers &= ~NT_ACTIVATION_TIMER;
658 handle_led(hw, LED_S0_OFF);
659 break;
660
661 case (2):
662 if (hw->nt_timer < 0) {
663 hw->nt_timer = 0;
664 hw->timers &= ~NT_ACTIVATION_TIMER;
665 hfcsusb_ph_command(dch->hw, HFC_L1_DEACTIVATE_NT);
666 } else {
667 hw->timers |= NT_ACTIVATION_TIMER;
668 hw->nt_timer = NT_T1_COUNT;
669 /* allow G2 -> G3 transition */
670 write_reg(hw, HFCUSB_STATES, 2 | HFCUSB_NT_G2_G3);
671 }
672 break;
673 case (3):
674 hw->nt_timer = 0;
675 hw->timers &= ~NT_ACTIVATION_TIMER;
676 test_and_set_bit(FLG_ACTIVE, &dch->Flags);
677 _queue_data(&dch->dev.D, PH_ACTIVATE_IND,
678 MISDN_ID_ANY, 0, NULL, GFP_ATOMIC);
679 handle_led(hw, LED_S0_ON);
680 break;
681 case (4):
682 hw->nt_timer = 0;
683 hw->timers &= ~NT_ACTIVATION_TIMER;
684 break;
685 default:
686 break;
687 }
688 hfcsusb_ph_info(hw);
689}
690
691static void
692ph_state(struct dchannel *dch)
693{
694 struct hfcsusb *hw = dch->hw;
695
696 if (hw->protocol == ISDN_P_NT_S0)
697 ph_state_nt(dch);
698 else if (hw->protocol == ISDN_P_TE_S0)
699 ph_state_te(dch);
700}
701
702/*
703 * disable/enable BChannel for desired protocoll
704 */
705static int
706hfcsusb_setup_bch(struct bchannel *bch, int protocol)
707{
708 struct hfcsusb *hw = bch->hw;
709 __u8 conhdlc, sctrl, sctrl_r;
710
711 if (debug & DEBUG_HW)
712 printk(KERN_DEBUG "%s: %s: protocol %x-->%x B%d\n",
713 hw->name, __func__, bch->state, protocol,
714 bch->nr);
715
716 /* setup val for CON_HDLC */
717 conhdlc = 0;
718 if (protocol > ISDN_P_NONE)
719 conhdlc = 8; /* enable FIFO */
720
721 switch (protocol) {
722 case (-1): /* used for init */
723 bch->state = -1;
724 /* fall trough */
725 case (ISDN_P_NONE):
726 if (bch->state == ISDN_P_NONE)
727 return 0; /* already in idle state */
728 bch->state = ISDN_P_NONE;
729 clear_bit(FLG_HDLC, &bch->Flags);
730 clear_bit(FLG_TRANSPARENT, &bch->Flags);
731 break;
732 case (ISDN_P_B_RAW):
733 conhdlc |= 2;
734 bch->state = protocol;
735 set_bit(FLG_TRANSPARENT, &bch->Flags);
736 break;
737 case (ISDN_P_B_HDLC):
738 bch->state = protocol;
739 set_bit(FLG_HDLC, &bch->Flags);
740 break;
741 default:
742 if (debug & DEBUG_HW)
743 printk(KERN_DEBUG "%s: %s: prot not known %x\n",
744 hw->name, __func__, protocol);
745 return -ENOPROTOOPT;
746 }
747
748 if (protocol >= ISDN_P_NONE) {
749 write_reg(hw, HFCUSB_FIFO, (bch->nr == 1) ? 0 : 2);
750 write_reg(hw, HFCUSB_CON_HDLC, conhdlc);
751 write_reg(hw, HFCUSB_INC_RES_F, 2);
752 write_reg(hw, HFCUSB_FIFO, (bch->nr == 1) ? 1 : 3);
753 write_reg(hw, HFCUSB_CON_HDLC, conhdlc);
754 write_reg(hw, HFCUSB_INC_RES_F, 2);
755
756 sctrl = 0x40 + ((hw->protocol == ISDN_P_TE_S0) ? 0x00 : 0x04);
757 sctrl_r = 0x0;
758 if (test_bit(FLG_ACTIVE, &hw->bch[0].Flags)) {
759 sctrl |= 1;
760 sctrl_r |= 1;
761 }
762 if (test_bit(FLG_ACTIVE, &hw->bch[1].Flags)) {
763 sctrl |= 2;
764 sctrl_r |= 2;
765 }
766 write_reg(hw, HFCUSB_SCTRL, sctrl);
767 write_reg(hw, HFCUSB_SCTRL_R, sctrl_r);
768
769 if (protocol > ISDN_P_NONE)
770 handle_led(hw, (bch->nr == 1) ? LED_B1_ON : LED_B2_ON);
771 else
772 handle_led(hw, (bch->nr == 1) ? LED_B1_OFF :
773 LED_B2_OFF);
774 }
775 hfcsusb_ph_info(hw);
776 return 0;
777}
778
779static void
780hfcsusb_ph_command(struct hfcsusb *hw, u_char command)
781{
782 if (debug & DEBUG_HW)
783 printk(KERN_DEBUG "%s: %s: %x\n",
784 hw->name, __func__, command);
785
786 switch (command) {
787 case HFC_L1_ACTIVATE_TE:
788 /* force sending sending INFO1 */
789 write_reg(hw, HFCUSB_STATES, 0x14);
790 /* start l1 activation */
791 write_reg(hw, HFCUSB_STATES, 0x04);
792 break;
793
794 case HFC_L1_FORCE_DEACTIVATE_TE:
795 write_reg(hw, HFCUSB_STATES, 0x10);
796 write_reg(hw, HFCUSB_STATES, 0x03);
797 break;
798
799 case HFC_L1_ACTIVATE_NT:
800 if (hw->dch.state == 3)
801 _queue_data(&hw->dch.dev.D, PH_ACTIVATE_IND,
802 MISDN_ID_ANY, 0, NULL, GFP_ATOMIC);
803 else
804 write_reg(hw, HFCUSB_STATES, HFCUSB_ACTIVATE |
805 HFCUSB_DO_ACTION | HFCUSB_NT_G2_G3);
806 break;
807
808 case HFC_L1_DEACTIVATE_NT:
809 write_reg(hw, HFCUSB_STATES,
810 HFCUSB_DO_ACTION);
811 break;
812 }
813}
814
815/*
816 * Layer 1 B-channel hardware access
817 */
818static int
819channel_bctrl(struct bchannel *bch, struct mISDN_ctrl_req *cq)
820{
821 int ret = 0;
822
823 switch (cq->op) {
824 case MISDN_CTRL_GETOP:
825 cq->op = MISDN_CTRL_FILL_EMPTY;
826 break;
827 case MISDN_CTRL_FILL_EMPTY: /* fill fifo, if empty */
828 test_and_set_bit(FLG_FILLEMPTY, &bch->Flags);
829 if (debug & DEBUG_HW_OPEN)
830 printk(KERN_DEBUG "%s: FILL_EMPTY request (nr=%d "
831 "off=%d)\n", __func__, bch->nr, !!cq->p1);
832 break;
833 default:
834 printk(KERN_WARNING "%s: unknown Op %x\n", __func__, cq->op);
835 ret = -EINVAL;
836 break;
837 }
838 return ret;
839}
840
841/* collect data from incoming interrupt or isochron USB data */
842static void
843hfcsusb_rx_frame(struct usb_fifo *fifo, __u8 *data, unsigned int len,
844 int finish)
845{
846 struct hfcsusb *hw = fifo->hw;
847 struct sk_buff *rx_skb = NULL;
848 int maxlen = 0;
849 int fifon = fifo->fifonum;
850 int i;
851 int hdlc = 0;
852
853 if (debug & DBG_HFC_CALL_TRACE)
854 printk(KERN_DEBUG "%s: %s: fifo(%i) len(%i) "
855 "dch(%p) bch(%p) ech(%p)\n",
856 hw->name, __func__, fifon, len,
857 fifo->dch, fifo->bch, fifo->ech);
858
859 if (!len)
860 return;
861
862 if ((!!fifo->dch + !!fifo->bch + !!fifo->ech) != 1) {
863 printk(KERN_DEBUG "%s: %s: undefined channel\n",
864 hw->name, __func__);
865 return;
866 }
867
868 spin_lock(&hw->lock);
869 if (fifo->dch) {
870 rx_skb = fifo->dch->rx_skb;
871 maxlen = fifo->dch->maxlen;
872 hdlc = 1;
873 }
874 if (fifo->bch) {
875 rx_skb = fifo->bch->rx_skb;
876 maxlen = fifo->bch->maxlen;
877 hdlc = test_bit(FLG_HDLC, &fifo->bch->Flags);
878 }
879 if (fifo->ech) {
880 rx_skb = fifo->ech->rx_skb;
881 maxlen = fifo->ech->maxlen;
882 hdlc = 1;
883 }
884
885 if (!rx_skb) {
886 rx_skb = mI_alloc_skb(maxlen, GFP_ATOMIC);
887 if (rx_skb) {
888 if (fifo->dch)
889 fifo->dch->rx_skb = rx_skb;
890 if (fifo->bch)
891 fifo->bch->rx_skb = rx_skb;
892 if (fifo->ech)
893 fifo->ech->rx_skb = rx_skb;
894 skb_trim(rx_skb, 0);
895 } else {
896 printk(KERN_DEBUG "%s: %s: No mem for rx_skb\n",
897 hw->name, __func__);
898 spin_unlock(&hw->lock);
899 return;
900 }
901 }
902
903 if (fifo->dch || fifo->ech) {
904 /* D/E-Channel SKB range check */
905 if ((rx_skb->len + len) >= MAX_DFRAME_LEN_L1) {
906 printk(KERN_DEBUG "%s: %s: sbk mem exceeded "
907 "for fifo(%d) HFCUSB_D_RX\n",
908 hw->name, __func__, fifon);
909 skb_trim(rx_skb, 0);
910 spin_unlock(&hw->lock);
911 return;
912 }
913 } else if (fifo->bch) {
914 /* B-Channel SKB range check */
915 if ((rx_skb->len + len) >= (MAX_BCH_SIZE + 3)) {
916 printk(KERN_DEBUG "%s: %s: sbk mem exceeded "
917 "for fifo(%d) HFCUSB_B_RX\n",
918 hw->name, __func__, fifon);
919 skb_trim(rx_skb, 0);
920 spin_unlock(&hw->lock);
921 return;
922 }
923 }
924
925 memcpy(skb_put(rx_skb, len), data, len);
926
927 if (hdlc) {
928 /* we have a complete hdlc packet */
929 if (finish) {
930 if ((rx_skb->len > 3) &&
931 (!(rx_skb->data[rx_skb->len - 1]))) {
932 if (debug & DBG_HFC_FIFO_VERBOSE) {
933 printk(KERN_DEBUG "%s: %s: fifon(%i)"
934 " new RX len(%i): ",
935 hw->name, __func__, fifon,
936 rx_skb->len);
937 i = 0;
938 while (i < rx_skb->len)
939 printk("%02x ",
940 rx_skb->data[i++]);
941 printk("\n");
942 }
943
944 /* remove CRC & status */
945 skb_trim(rx_skb, rx_skb->len - 3);
946
947 if (fifo->dch)
948 recv_Dchannel(fifo->dch);
949 if (fifo->bch)
950 recv_Bchannel(fifo->bch);
951 if (fifo->ech)
952 recv_Echannel(fifo->ech,
953 &hw->dch);
954 } else {
955 if (debug & DBG_HFC_FIFO_VERBOSE) {
956 printk(KERN_DEBUG
957 "%s: CRC or minlen ERROR fifon(%i) "
958 "RX len(%i): ",
959 hw->name, fifon, rx_skb->len);
960 i = 0;
961 while (i < rx_skb->len)
962 printk("%02x ",
963 rx_skb->data[i++]);
964 printk("\n");
965 }
966 skb_trim(rx_skb, 0);
967 }
968 }
969 } else {
970 /* deliver transparent data to layer2 */
971 if (rx_skb->len >= poll)
972 recv_Bchannel(fifo->bch);
973 }
974 spin_unlock(&hw->lock);
975}
976
977void
978fill_isoc_urb(struct urb *urb, struct usb_device *dev, unsigned int pipe,
979 void *buf, int num_packets, int packet_size, int interval,
980 usb_complete_t complete, void *context)
981{
982 int k;
983
984 usb_fill_bulk_urb(urb, dev, pipe, buf, packet_size * num_packets,
985 complete, context);
986
987 urb->number_of_packets = num_packets;
988 urb->transfer_flags = URB_ISO_ASAP;
989 urb->actual_length = 0;
990 urb->interval = interval;
991
992 for (k = 0; k < num_packets; k++) {
993 urb->iso_frame_desc[k].offset = packet_size * k;
994 urb->iso_frame_desc[k].length = packet_size;
995 urb->iso_frame_desc[k].actual_length = 0;
996 }
997}
998
999/* receive completion routine for all ISO tx fifos */
1000static void
1001rx_iso_complete(struct urb *urb)
1002{
1003 struct iso_urb *context_iso_urb = (struct iso_urb *) urb->context;
1004 struct usb_fifo *fifo = context_iso_urb->owner_fifo;
1005 struct hfcsusb *hw = fifo->hw;
1006 int k, len, errcode, offset, num_isoc_packets, fifon, maxlen,
1007 status, iso_status, i;
1008 __u8 *buf;
1009 static __u8 eof[8];
1010 __u8 s0_state;
1011
1012 fifon = fifo->fifonum;
1013 status = urb->status;
1014
1015 spin_lock(&hw->lock);
1016 if (fifo->stop_gracefull) {
1017 fifo->stop_gracefull = 0;
1018 fifo->active = 0;
1019 spin_unlock(&hw->lock);
1020 return;
1021 }
1022 spin_unlock(&hw->lock);
1023
1024 /*
1025 * ISO transfer only partially completed,
1026 * look at individual frame status for details
1027 */
1028 if (status == -EXDEV) {
1029 if (debug & DEBUG_HW)
1030 printk(KERN_DEBUG "%s: %s: with -EXDEV "
1031 "urb->status %d, fifonum %d\n",
1032 hw->name, __func__, status, fifon);
1033
1034 /* clear status, so go on with ISO transfers */
1035 status = 0;
1036 }
1037
1038 s0_state = 0;
1039 if (fifo->active && !status) {
1040 num_isoc_packets = iso_packets[fifon];
1041 maxlen = fifo->usb_packet_maxlen;
1042
1043 for (k = 0; k < num_isoc_packets; ++k) {
1044 len = urb->iso_frame_desc[k].actual_length;
1045 offset = urb->iso_frame_desc[k].offset;
1046 buf = context_iso_urb->buffer + offset;
1047 iso_status = urb->iso_frame_desc[k].status;
1048
1049 if (iso_status && (debug & DBG_HFC_FIFO_VERBOSE)) {
1050 printk(KERN_DEBUG "%s: %s: "
1051 "ISO packet %i, status: %i\n",
1052 hw->name, __func__, k, iso_status);
1053 }
1054
1055 /* USB data log for every D ISO in */
1056 if ((fifon == HFCUSB_D_RX) &&
1057 (debug & DBG_HFC_USB_VERBOSE)) {
1058 printk(KERN_DEBUG
1059 "%s: %s: %d (%d/%d) len(%d) ",
1060 hw->name, __func__, urb->start_frame,
1061 k, num_isoc_packets-1,
1062 len);
1063 for (i = 0; i < len; i++)
1064 printk("%x ", buf[i]);
1065 printk("\n");
1066 }
1067
1068 if (!iso_status) {
1069 if (fifo->last_urblen != maxlen) {
1070 /*
1071 * save fifo fill-level threshold bits
1072 * to use them later in TX ISO URB
1073 * completions
1074 */
1075 hw->threshold_mask = buf[1];
1076
1077 if (fifon == HFCUSB_D_RX)
1078 s0_state = (buf[0] >> 4);
1079
1080 eof[fifon] = buf[0] & 1;
1081 if (len > 2)
1082 hfcsusb_rx_frame(fifo, buf + 2,
1083 len - 2, (len < maxlen)
1084 ? eof[fifon] : 0);
1085 } else
1086 hfcsusb_rx_frame(fifo, buf, len,
1087 (len < maxlen) ?
1088 eof[fifon] : 0);
1089 fifo->last_urblen = len;
1090 }
1091 }
1092
1093 /* signal S0 layer1 state change */
1094 if ((s0_state) && (hw->initdone) &&
1095 (s0_state != hw->dch.state)) {
1096 hw->dch.state = s0_state;
1097 schedule_event(&hw->dch, FLG_PHCHANGE);
1098 }
1099
1100 fill_isoc_urb(urb, fifo->hw->dev, fifo->pipe,
1101 context_iso_urb->buffer, num_isoc_packets,
1102 fifo->usb_packet_maxlen, fifo->intervall,
1103 (usb_complete_t)rx_iso_complete, urb->context);
1104 errcode = usb_submit_urb(urb, GFP_ATOMIC);
1105 if (errcode < 0) {
1106 if (debug & DEBUG_HW)
1107 printk(KERN_DEBUG "%s: %s: error submitting "
1108 "ISO URB: %d\n",
1109 hw->name, __func__, errcode);
1110 }
1111 } else {
1112 if (status && (debug & DBG_HFC_URB_INFO))
1113 printk(KERN_DEBUG "%s: %s: rx_iso_complete : "
1114 "urb->status %d, fifonum %d\n",
1115 hw->name, __func__, status, fifon);
1116 }
1117}
1118
1119/* receive completion routine for all interrupt rx fifos */
1120static void
1121rx_int_complete(struct urb *urb)
1122{
1123 int len, status, i;
1124 __u8 *buf, maxlen, fifon;
1125 struct usb_fifo *fifo = (struct usb_fifo *) urb->context;
1126 struct hfcsusb *hw = fifo->hw;
1127 static __u8 eof[8];
1128
1129 spin_lock(&hw->lock);
1130 if (fifo->stop_gracefull) {
1131 fifo->stop_gracefull = 0;
1132 fifo->active = 0;
1133 spin_unlock(&hw->lock);
1134 return;
1135 }
1136 spin_unlock(&hw->lock);
1137
1138 fifon = fifo->fifonum;
1139 if ((!fifo->active) || (urb->status)) {
1140 if (debug & DBG_HFC_URB_ERROR)
1141 printk(KERN_DEBUG
1142 "%s: %s: RX-Fifo %i is going down (%i)\n",
1143 hw->name, __func__, fifon, urb->status);
1144
1145 fifo->urb->interval = 0; /* cancel automatic rescheduling */
1146 return;
1147 }
1148 len = urb->actual_length;
1149 buf = fifo->buffer;
1150 maxlen = fifo->usb_packet_maxlen;
1151
1152 /* USB data log for every D INT in */
1153 if ((fifon == HFCUSB_D_RX) && (debug & DBG_HFC_USB_VERBOSE)) {
1154 printk(KERN_DEBUG "%s: %s: D RX INT len(%d) ",
1155 hw->name, __func__, len);
1156 for (i = 0; i < len; i++)
1157 printk("%02x ", buf[i]);
1158 printk("\n");
1159 }
1160
1161 if (fifo->last_urblen != fifo->usb_packet_maxlen) {
1162 /* the threshold mask is in the 2nd status byte */
1163 hw->threshold_mask = buf[1];
1164
1165 /* signal S0 layer1 state change */
1166 if (hw->initdone && ((buf[0] >> 4) != hw->dch.state)) {
1167 hw->dch.state = (buf[0] >> 4);
1168 schedule_event(&hw->dch, FLG_PHCHANGE);
1169 }
1170
1171 eof[fifon] = buf[0] & 1;
1172 /* if we have more than the 2 status bytes -> collect data */
1173 if (len > 2)
1174 hfcsusb_rx_frame(fifo, buf + 2,
1175 urb->actual_length - 2,
1176 (len < maxlen) ? eof[fifon] : 0);
1177 } else {
1178 hfcsusb_rx_frame(fifo, buf, urb->actual_length,
1179 (len < maxlen) ? eof[fifon] : 0);
1180 }
1181 fifo->last_urblen = urb->actual_length;
1182
1183 status = usb_submit_urb(urb, GFP_ATOMIC);
1184 if (status) {
1185 if (debug & DEBUG_HW)
1186 printk(KERN_DEBUG "%s: %s: error resubmitting USB\n",
1187 hw->name, __func__);
1188 }
1189}
1190
1191/* transmit completion routine for all ISO tx fifos */
1192static void
1193tx_iso_complete(struct urb *urb)
1194{
1195 struct iso_urb *context_iso_urb = (struct iso_urb *) urb->context;
1196 struct usb_fifo *fifo = context_iso_urb->owner_fifo;
1197 struct hfcsusb *hw = fifo->hw;
1198 struct sk_buff *tx_skb;
1199 int k, tx_offset, num_isoc_packets, sink, remain, current_len,
1200 errcode, hdlc, i;
1201 int *tx_idx;
1202 int frame_complete, fifon, status;
1203 __u8 threshbit;
1204
1205 spin_lock(&hw->lock);
1206 if (fifo->stop_gracefull) {
1207 fifo->stop_gracefull = 0;
1208 fifo->active = 0;
1209 spin_unlock(&hw->lock);
1210 return;
1211 }
1212
1213 if (fifo->dch) {
1214 tx_skb = fifo->dch->tx_skb;
1215 tx_idx = &fifo->dch->tx_idx;
1216 hdlc = 1;
1217 } else if (fifo->bch) {
1218 tx_skb = fifo->bch->tx_skb;
1219 tx_idx = &fifo->bch->tx_idx;
1220 hdlc = test_bit(FLG_HDLC, &fifo->bch->Flags);
1221 } else {
1222 printk(KERN_DEBUG "%s: %s: neither BCH nor DCH\n",
1223 hw->name, __func__);
1224 spin_unlock(&hw->lock);
1225 return;
1226 }
1227
1228 fifon = fifo->fifonum;
1229 status = urb->status;
1230
1231 tx_offset = 0;
1232
1233 /*
1234 * ISO transfer only partially completed,
1235 * look at individual frame status for details
1236 */
1237 if (status == -EXDEV) {
1238 if (debug & DBG_HFC_URB_ERROR)
1239 printk(KERN_DEBUG "%s: %s: "
1240 "-EXDEV (%i) fifon (%d)\n",
1241 hw->name, __func__, status, fifon);
1242
1243 /* clear status, so go on with ISO transfers */
1244 status = 0;
1245 }
1246
1247 if (fifo->active && !status) {
1248 /* is FifoFull-threshold set for our channel? */
1249 threshbit = (hw->threshold_mask & (1 << fifon));
1250 num_isoc_packets = iso_packets[fifon];
1251
1252 /* predict dataflow to avoid fifo overflow */
1253 if (fifon >= HFCUSB_D_TX)
1254 sink = (threshbit) ? SINK_DMIN : SINK_DMAX;
1255 else
1256 sink = (threshbit) ? SINK_MIN : SINK_MAX;
1257 fill_isoc_urb(urb, fifo->hw->dev, fifo->pipe,
1258 context_iso_urb->buffer, num_isoc_packets,
1259 fifo->usb_packet_maxlen, fifo->intervall,
1260 (usb_complete_t)tx_iso_complete, urb->context);
1261 memset(context_iso_urb->buffer, 0,
1262 sizeof(context_iso_urb->buffer));
1263 frame_complete = 0;
1264
1265 for (k = 0; k < num_isoc_packets; ++k) {
1266 /* analyze tx success of previous ISO packets */
1267 if (debug & DBG_HFC_URB_ERROR) {
1268 errcode = urb->iso_frame_desc[k].status;
1269 if (errcode) {
1270 printk(KERN_DEBUG "%s: %s: "
1271 "ISO packet %i, status: %i\n",
1272 hw->name, __func__, k, errcode);
1273 }
1274 }
1275
1276 /* Generate next ISO Packets */
1277 if (tx_skb)
1278 remain = tx_skb->len - *tx_idx;
1279 else
1280 remain = 0;
1281
1282 if (remain > 0) {
1283 fifo->bit_line -= sink;
1284 current_len = (0 - fifo->bit_line) / 8;
1285 if (current_len > 14)
1286 current_len = 14;
1287 if (current_len < 0)
1288 current_len = 0;
1289 if (remain < current_len)
1290 current_len = remain;
1291
1292 /* how much bit do we put on the line? */
1293 fifo->bit_line += current_len * 8;
1294
1295 context_iso_urb->buffer[tx_offset] = 0;
1296 if (current_len == remain) {
1297 if (hdlc) {
1298 /* signal frame completion */
1299 context_iso_urb->
1300 buffer[tx_offset] = 1;
1301 /* add 2 byte flags and 16bit
1302 * CRC at end of ISDN frame */
1303 fifo->bit_line += 32;
1304 }
1305 frame_complete = 1;
1306 }
1307
1308 /* copy tx data to iso-urb buffer */
1309 memcpy(context_iso_urb->buffer + tx_offset + 1,
1310 (tx_skb->data + *tx_idx), current_len);
1311 *tx_idx += current_len;
1312
1313 urb->iso_frame_desc[k].offset = tx_offset;
1314 urb->iso_frame_desc[k].length = current_len + 1;
1315
1316 /* USB data log for every D ISO out */
1317 if ((fifon == HFCUSB_D_RX) &&
1318 (debug & DBG_HFC_USB_VERBOSE)) {
1319 printk(KERN_DEBUG
1320 "%s: %s (%d/%d) offs(%d) len(%d) ",
1321 hw->name, __func__,
1322 k, num_isoc_packets-1,
1323 urb->iso_frame_desc[k].offset,
1324 urb->iso_frame_desc[k].length);
1325
1326 for (i = urb->iso_frame_desc[k].offset;
1327 i < (urb->iso_frame_desc[k].offset
1328 + urb->iso_frame_desc[k].length);
1329 i++)
1330 printk("%x ",
1331 context_iso_urb->buffer[i]);
1332
1333 printk(" skb->len(%i) tx-idx(%d)\n",
1334 tx_skb->len, *tx_idx);
1335 }
1336
1337 tx_offset += (current_len + 1);
1338 } else {
1339 urb->iso_frame_desc[k].offset = tx_offset++;
1340 urb->iso_frame_desc[k].length = 1;
1341 /* we lower data margin every msec */
1342 fifo->bit_line -= sink;
1343 if (fifo->bit_line < BITLINE_INF)
1344 fifo->bit_line = BITLINE_INF;
1345 }
1346
1347 if (frame_complete) {
1348 frame_complete = 0;
1349
1350 if (debug & DBG_HFC_FIFO_VERBOSE) {
1351 printk(KERN_DEBUG "%s: %s: "
1352 "fifon(%i) new TX len(%i): ",
1353 hw->name, __func__,
1354 fifon, tx_skb->len);
1355 i = 0;
1356 while (i < tx_skb->len)
1357 printk("%02x ",
1358 tx_skb->data[i++]);
1359 printk("\n");
1360 }
1361
1362 dev_kfree_skb(tx_skb);
1363 tx_skb = NULL;
1364 if (fifo->dch && get_next_dframe(fifo->dch))
1365 tx_skb = fifo->dch->tx_skb;
1366 else if (fifo->bch &&
1367 get_next_bframe(fifo->bch)) {
1368 if (test_bit(FLG_TRANSPARENT,
1369 &fifo->bch->Flags))
1370 confirm_Bsend(fifo->bch);
1371 tx_skb = fifo->bch->tx_skb;
1372 }
1373 }
1374 }
1375 errcode = usb_submit_urb(urb, GFP_ATOMIC);
1376 if (errcode < 0) {
1377 if (debug & DEBUG_HW)
1378 printk(KERN_DEBUG
1379 "%s: %s: error submitting ISO URB: %d \n",
1380 hw->name, __func__, errcode);
1381 }
1382
1383 /*
1384 * abuse DChannel tx iso completion to trigger NT mode state
1385 * changes tx_iso_complete is assumed to be called every
1386 * fifo->intervall (ms)
1387 */
1388 if ((fifon == HFCUSB_D_TX) && (hw->protocol == ISDN_P_NT_S0)
1389 && (hw->timers & NT_ACTIVATION_TIMER)) {
1390 if ((--hw->nt_timer) < 0)
1391 schedule_event(&hw->dch, FLG_PHCHANGE);
1392 }
1393
1394 } else {
1395 if (status && (debug & DBG_HFC_URB_ERROR))
1396 printk(KERN_DEBUG "%s: %s: urb->status %s (%i)"
1397 "fifonum=%d\n",
1398 hw->name, __func__,
1399 symbolic(urb_errlist, status), status, fifon);
1400 }
1401 spin_unlock(&hw->lock);
1402}
1403
1404/*
1405 * allocs urbs and start isoc transfer with two pending urbs to avoid
1406 * gaps in the transfer chain
1407 */
1408static int
1409start_isoc_chain(struct usb_fifo *fifo, int num_packets_per_urb,
1410 usb_complete_t complete, int packet_size)
1411{
1412 struct hfcsusb *hw = fifo->hw;
1413 int i, k, errcode;
1414
1415 if (debug)
1416 printk(KERN_DEBUG "%s: %s: fifo %i\n",
1417 hw->name, __func__, fifo->fifonum);
1418
1419 /* allocate Memory for Iso out Urbs */
1420 for (i = 0; i < 2; i++) {
1421 if (!(fifo->iso[i].urb)) {
1422 fifo->iso[i].urb =
1423 usb_alloc_urb(num_packets_per_urb, GFP_KERNEL);
1424 if (!(fifo->iso[i].urb)) {
1425 printk(KERN_DEBUG
1426 "%s: %s: alloc urb for fifo %i failed",
1427 hw->name, __func__, fifo->fifonum);
1428 }
1429 fifo->iso[i].owner_fifo = (struct usb_fifo *) fifo;
1430 fifo->iso[i].indx = i;
1431
1432 /* Init the first iso */
1433 if (ISO_BUFFER_SIZE >=
1434 (fifo->usb_packet_maxlen *
1435 num_packets_per_urb)) {
1436 fill_isoc_urb(fifo->iso[i].urb,
1437 fifo->hw->dev, fifo->pipe,
1438 fifo->iso[i].buffer,
1439 num_packets_per_urb,
1440 fifo->usb_packet_maxlen,
1441 fifo->intervall, complete,
1442 &fifo->iso[i]);
1443 memset(fifo->iso[i].buffer, 0,
1444 sizeof(fifo->iso[i].buffer));
1445
1446 for (k = 0; k < num_packets_per_urb; k++) {
1447 fifo->iso[i].urb->
1448 iso_frame_desc[k].offset =
1449 k * packet_size;
1450 fifo->iso[i].urb->
1451 iso_frame_desc[k].length =
1452 packet_size;
1453 }
1454 } else {
1455 printk(KERN_DEBUG
1456 "%s: %s: ISO Buffer size to small!\n",
1457 hw->name, __func__);
1458 }
1459 }
1460 fifo->bit_line = BITLINE_INF;
1461
1462 errcode = usb_submit_urb(fifo->iso[i].urb, GFP_KERNEL);
1463 fifo->active = (errcode >= 0) ? 1 : 0;
1464 fifo->stop_gracefull = 0;
1465 if (errcode < 0) {
1466 printk(KERN_DEBUG "%s: %s: %s URB nr:%d\n",
1467 hw->name, __func__,
1468 symbolic(urb_errlist, errcode), i);
1469 }
1470 }
1471 return fifo->active;
1472}
1473
1474static void
1475stop_iso_gracefull(struct usb_fifo *fifo)
1476{
1477 struct hfcsusb *hw = fifo->hw;
1478 int i, timeout;
1479 u_long flags;
1480
1481 for (i = 0; i < 2; i++) {
1482 spin_lock_irqsave(&hw->lock, flags);
1483 if (debug)
1484 printk(KERN_DEBUG "%s: %s for fifo %i.%i\n",
1485 hw->name, __func__, fifo->fifonum, i);
1486 fifo->stop_gracefull = 1;
1487 spin_unlock_irqrestore(&hw->lock, flags);
1488 }
1489
1490 for (i = 0; i < 2; i++) {
1491 timeout = 3;
1492 while (fifo->stop_gracefull && timeout--)
1493 schedule_timeout_interruptible((HZ/1000)*16);
1494 if (debug && fifo->stop_gracefull)
1495 printk(KERN_DEBUG "%s: ERROR %s for fifo %i.%i\n",
1496 hw->name, __func__, fifo->fifonum, i);
1497 }
1498}
1499
1500static void
1501stop_int_gracefull(struct usb_fifo *fifo)
1502{
1503 struct hfcsusb *hw = fifo->hw;
1504 int timeout;
1505 u_long flags;
1506
1507 spin_lock_irqsave(&hw->lock, flags);
1508 if (debug)
1509 printk(KERN_DEBUG "%s: %s for fifo %i\n",
1510 hw->name, __func__, fifo->fifonum);
1511 fifo->stop_gracefull = 1;
1512 spin_unlock_irqrestore(&hw->lock, flags);
1513
1514 timeout = 3;
1515 while (fifo->stop_gracefull && timeout--)
1516 schedule_timeout_interruptible((HZ/1000)*3);
1517 if (debug && fifo->stop_gracefull)
1518 printk(KERN_DEBUG "%s: ERROR %s for fifo %i\n",
1519 hw->name, __func__, fifo->fifonum);
1520}
1521
1522/* start the interrupt transfer for the given fifo */
1523static void
1524start_int_fifo(struct usb_fifo *fifo)
1525{
1526 struct hfcsusb *hw = fifo->hw;
1527 int errcode;
1528
1529 if (debug)
1530 printk(KERN_DEBUG "%s: %s: INT IN fifo:%d\n",
1531 hw->name, __func__, fifo->fifonum);
1532
1533 if (!fifo->urb) {
1534 fifo->urb = usb_alloc_urb(0, GFP_KERNEL);
1535 if (!fifo->urb)
1536 return;
1537 }
1538 usb_fill_int_urb(fifo->urb, fifo->hw->dev, fifo->pipe,
1539 fifo->buffer, fifo->usb_packet_maxlen,
1540 (usb_complete_t)rx_int_complete, fifo, fifo->intervall);
1541 fifo->active = 1;
1542 fifo->stop_gracefull = 0;
1543 errcode = usb_submit_urb(fifo->urb, GFP_KERNEL);
1544 if (errcode) {
1545 printk(KERN_DEBUG "%s: %s: submit URB: status:%i\n",
1546 hw->name, __func__, errcode);
1547 fifo->active = 0;
1548 }
1549}
1550
1551static void
1552setPortMode(struct hfcsusb *hw)
1553{
1554 if (debug & DEBUG_HW)
1555 printk(KERN_DEBUG "%s: %s %s\n", hw->name, __func__,
1556 (hw->protocol == ISDN_P_TE_S0) ? "TE" : "NT");
1557
1558 if (hw->protocol == ISDN_P_TE_S0) {
1559 write_reg(hw, HFCUSB_SCTRL, 0x40);
1560 write_reg(hw, HFCUSB_SCTRL_E, 0x00);
1561 write_reg(hw, HFCUSB_CLKDEL, CLKDEL_TE);
1562 write_reg(hw, HFCUSB_STATES, 3 | 0x10);
1563 write_reg(hw, HFCUSB_STATES, 3);
1564 } else {
1565 write_reg(hw, HFCUSB_SCTRL, 0x44);
1566 write_reg(hw, HFCUSB_SCTRL_E, 0x09);
1567 write_reg(hw, HFCUSB_CLKDEL, CLKDEL_NT);
1568 write_reg(hw, HFCUSB_STATES, 1 | 0x10);
1569 write_reg(hw, HFCUSB_STATES, 1);
1570 }
1571}
1572
1573static void
1574reset_hfcsusb(struct hfcsusb *hw)
1575{
1576 struct usb_fifo *fifo;
1577 int i;
1578
1579 if (debug & DEBUG_HW)
1580 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
1581
1582 /* do Chip reset */
1583 write_reg(hw, HFCUSB_CIRM, 8);
1584
1585 /* aux = output, reset off */
1586 write_reg(hw, HFCUSB_CIRM, 0x10);
1587
1588 /* set USB_SIZE to match the wMaxPacketSize for INT or BULK transfers */
1589 write_reg(hw, HFCUSB_USB_SIZE, (hw->packet_size / 8) |
1590 ((hw->packet_size / 8) << 4));
1591
1592 /* set USB_SIZE_I to match the the wMaxPacketSize for ISO transfers */
1593 write_reg(hw, HFCUSB_USB_SIZE_I, hw->iso_packet_size);
1594
1595 /* enable PCM/GCI master mode */
1596 write_reg(hw, HFCUSB_MST_MODE1, 0); /* set default values */
1597 write_reg(hw, HFCUSB_MST_MODE0, 1); /* enable master mode */
1598
1599 /* init the fifos */
1600 write_reg(hw, HFCUSB_F_THRES,
1601 (HFCUSB_TX_THRESHOLD / 8) | ((HFCUSB_RX_THRESHOLD / 8) << 4));
1602
1603 fifo = hw->fifos;
1604 for (i = 0; i < HFCUSB_NUM_FIFOS; i++) {
1605 write_reg(hw, HFCUSB_FIFO, i); /* select the desired fifo */
1606 fifo[i].max_size =
1607 (i <= HFCUSB_B2_RX) ? MAX_BCH_SIZE : MAX_DFRAME_LEN;
1608 fifo[i].last_urblen = 0;
1609
1610 /* set 2 bit for D- & E-channel */
1611 write_reg(hw, HFCUSB_HDLC_PAR, ((i <= HFCUSB_B2_RX) ? 0 : 2));
1612
1613 /* enable all fifos */
1614 if (i == HFCUSB_D_TX)
1615 write_reg(hw, HFCUSB_CON_HDLC,
1616 (hw->protocol == ISDN_P_NT_S0) ? 0x08 : 0x09);
1617 else
1618 write_reg(hw, HFCUSB_CON_HDLC, 0x08);
1619 write_reg(hw, HFCUSB_INC_RES_F, 2); /* reset the fifo */
1620 }
1621
1622 write_reg(hw, HFCUSB_SCTRL_R, 0); /* disable both B receivers */
1623 handle_led(hw, LED_POWER_ON);
1624}
1625
1626/* start USB data pipes dependand on device's endpoint configuration */
1627static void
1628hfcsusb_start_endpoint(struct hfcsusb *hw, int channel)
1629{
1630 /* quick check if endpoint already running */
1631 if ((channel == HFC_CHAN_D) && (hw->fifos[HFCUSB_D_RX].active))
1632 return;
1633 if ((channel == HFC_CHAN_B1) && (hw->fifos[HFCUSB_B1_RX].active))
1634 return;
1635 if ((channel == HFC_CHAN_B2) && (hw->fifos[HFCUSB_B2_RX].active))
1636 return;
1637 if ((channel == HFC_CHAN_E) && (hw->fifos[HFCUSB_PCM_RX].active))
1638 return;
1639
1640 /* start rx endpoints using USB INT IN method */
1641 if (hw->cfg_used == CNF_3INT3ISO || hw->cfg_used == CNF_4INT3ISO)
1642 start_int_fifo(hw->fifos + channel*2 + 1);
1643
1644 /* start rx endpoints using USB ISO IN method */
1645 if (hw->cfg_used == CNF_3ISO3ISO || hw->cfg_used == CNF_4ISO3ISO) {
1646 switch (channel) {
1647 case HFC_CHAN_D:
1648 start_isoc_chain(hw->fifos + HFCUSB_D_RX,
1649 ISOC_PACKETS_D,
1650 (usb_complete_t)rx_iso_complete,
1651 16);
1652 break;
1653 case HFC_CHAN_E:
1654 start_isoc_chain(hw->fifos + HFCUSB_PCM_RX,
1655 ISOC_PACKETS_D,
1656 (usb_complete_t)rx_iso_complete,
1657 16);
1658 break;
1659 case HFC_CHAN_B1:
1660 start_isoc_chain(hw->fifos + HFCUSB_B1_RX,
1661 ISOC_PACKETS_B,
1662 (usb_complete_t)rx_iso_complete,
1663 16);
1664 break;
1665 case HFC_CHAN_B2:
1666 start_isoc_chain(hw->fifos + HFCUSB_B2_RX,
1667 ISOC_PACKETS_B,
1668 (usb_complete_t)rx_iso_complete,
1669 16);
1670 break;
1671 }
1672 }
1673
1674 /* start tx endpoints using USB ISO OUT method */
1675 switch (channel) {
1676 case HFC_CHAN_D:
1677 start_isoc_chain(hw->fifos + HFCUSB_D_TX,
1678 ISOC_PACKETS_B,
1679 (usb_complete_t)tx_iso_complete, 1);
1680 break;
1681 case HFC_CHAN_B1:
1682 start_isoc_chain(hw->fifos + HFCUSB_B1_TX,
1683 ISOC_PACKETS_D,
1684 (usb_complete_t)tx_iso_complete, 1);
1685 break;
1686 case HFC_CHAN_B2:
1687 start_isoc_chain(hw->fifos + HFCUSB_B2_TX,
1688 ISOC_PACKETS_B,
1689 (usb_complete_t)tx_iso_complete, 1);
1690 break;
1691 }
1692}
1693
1694/* stop USB data pipes dependand on device's endpoint configuration */
1695static void
1696hfcsusb_stop_endpoint(struct hfcsusb *hw, int channel)
1697{
1698 /* quick check if endpoint currently running */
1699 if ((channel == HFC_CHAN_D) && (!hw->fifos[HFCUSB_D_RX].active))
1700 return;
1701 if ((channel == HFC_CHAN_B1) && (!hw->fifos[HFCUSB_B1_RX].active))
1702 return;
1703 if ((channel == HFC_CHAN_B2) && (!hw->fifos[HFCUSB_B2_RX].active))
1704 return;
1705 if ((channel == HFC_CHAN_E) && (!hw->fifos[HFCUSB_PCM_RX].active))
1706 return;
1707
1708 /* rx endpoints using USB INT IN method */
1709 if (hw->cfg_used == CNF_3INT3ISO || hw->cfg_used == CNF_4INT3ISO)
1710 stop_int_gracefull(hw->fifos + channel*2 + 1);
1711
1712 /* rx endpoints using USB ISO IN method */
1713 if (hw->cfg_used == CNF_3ISO3ISO || hw->cfg_used == CNF_4ISO3ISO)
1714 stop_iso_gracefull(hw->fifos + channel*2 + 1);
1715
1716 /* tx endpoints using USB ISO OUT method */
1717 if (channel != HFC_CHAN_E)
1718 stop_iso_gracefull(hw->fifos + channel*2);
1719}
1720
1721
1722/* Hardware Initialization */
1723int
1724setup_hfcsusb(struct hfcsusb *hw)
1725{
1726 int err;
1727 u_char b;
1728
1729 if (debug & DBG_HFC_CALL_TRACE)
1730 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
1731
1732 /* check the chip id */
1733 if (read_reg_atomic(hw, HFCUSB_CHIP_ID, &b) != 1) {
1734 printk(KERN_DEBUG "%s: %s: cannot read chip id\n",
1735 hw->name, __func__);
1736 return 1;
1737 }
1738 if (b != HFCUSB_CHIPID) {
1739 printk(KERN_DEBUG "%s: %s: Invalid chip id 0x%02x\n",
1740 hw->name, __func__, b);
1741 return 1;
1742 }
1743
1744 /* first set the needed config, interface and alternate */
1745 err = usb_set_interface(hw->dev, hw->if_used, hw->alt_used);
1746
1747 hw->led_state = 0;
1748
1749 /* init the background machinery for control requests */
1750 hw->ctrl_read.bRequestType = 0xc0;
1751 hw->ctrl_read.bRequest = 1;
1752 hw->ctrl_read.wLength = cpu_to_le16(1);
1753 hw->ctrl_write.bRequestType = 0x40;
1754 hw->ctrl_write.bRequest = 0;
1755 hw->ctrl_write.wLength = 0;
1756 usb_fill_control_urb(hw->ctrl_urb, hw->dev, hw->ctrl_out_pipe,
1757 (u_char *)&hw->ctrl_write, NULL, 0,
1758 (usb_complete_t)ctrl_complete, hw);
1759
1760 reset_hfcsusb(hw);
1761 return 0;
1762}
1763
1764static void
1765release_hw(struct hfcsusb *hw)
1766{
1767 if (debug & DBG_HFC_CALL_TRACE)
1768 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
1769
1770 /*
1771 * stop all endpoints gracefully
1772 * TODO: mISDN_core should generate CLOSE_CHANNEL
1773 * signals after calling mISDN_unregister_device()
1774 */
1775 hfcsusb_stop_endpoint(hw, HFC_CHAN_D);
1776 hfcsusb_stop_endpoint(hw, HFC_CHAN_B1);
1777 hfcsusb_stop_endpoint(hw, HFC_CHAN_B2);
1778 if (hw->fifos[HFCUSB_PCM_RX].pipe)
1779 hfcsusb_stop_endpoint(hw, HFC_CHAN_E);
1780 if (hw->protocol == ISDN_P_TE_S0)
1781 l1_event(hw->dch.l1, CLOSE_CHANNEL);
1782
1783 mISDN_unregister_device(&hw->dch.dev);
1784 mISDN_freebchannel(&hw->bch[1]);
1785 mISDN_freebchannel(&hw->bch[0]);
1786 mISDN_freedchannel(&hw->dch);
1787
1788 if (hw->ctrl_urb) {
1789 usb_kill_urb(hw->ctrl_urb);
1790 usb_free_urb(hw->ctrl_urb);
1791 hw->ctrl_urb = NULL;
1792 }
1793
1794 if (hw->intf)
1795 usb_set_intfdata(hw->intf, NULL);
1796 list_del(&hw->list);
1797 kfree(hw);
1798 hw = NULL;
1799}
1800
1801static void
1802deactivate_bchannel(struct bchannel *bch)
1803{
1804 struct hfcsusb *hw = bch->hw;
1805 u_long flags;
1806
1807 if (bch->debug & DEBUG_HW)
1808 printk(KERN_DEBUG "%s: %s: bch->nr(%i)\n",
1809 hw->name, __func__, bch->nr);
1810
1811 spin_lock_irqsave(&hw->lock, flags);
1812 if (test_and_clear_bit(FLG_TX_NEXT, &bch->Flags)) {
1813 dev_kfree_skb(bch->next_skb);
1814 bch->next_skb = NULL;
1815 }
1816 if (bch->tx_skb) {
1817 dev_kfree_skb(bch->tx_skb);
1818 bch->tx_skb = NULL;
1819 }
1820 bch->tx_idx = 0;
1821 if (bch->rx_skb) {
1822 dev_kfree_skb(bch->rx_skb);
1823 bch->rx_skb = NULL;
1824 }
1825 clear_bit(FLG_ACTIVE, &bch->Flags);
1826 clear_bit(FLG_TX_BUSY, &bch->Flags);
1827 spin_unlock_irqrestore(&hw->lock, flags);
1828 hfcsusb_setup_bch(bch, ISDN_P_NONE);
1829 hfcsusb_stop_endpoint(hw, bch->nr);
1830}
1831
1832/*
1833 * Layer 1 B-channel hardware access
1834 */
1835static int
1836hfc_bctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1837{
1838 struct bchannel *bch = container_of(ch, struct bchannel, ch);
1839 int ret = -EINVAL;
1840
1841 if (bch->debug & DEBUG_HW)
1842 printk(KERN_DEBUG "%s: cmd:%x %p\n", __func__, cmd, arg);
1843
1844 switch (cmd) {
1845 case HW_TESTRX_RAW:
1846 case HW_TESTRX_HDLC:
1847 case HW_TESTRX_OFF:
1848 ret = -EINVAL;
1849 break;
1850
1851 case CLOSE_CHANNEL:
1852 test_and_clear_bit(FLG_OPEN, &bch->Flags);
1853 if (test_bit(FLG_ACTIVE, &bch->Flags))
1854 deactivate_bchannel(bch);
1855 ch->protocol = ISDN_P_NONE;
1856 ch->peer = NULL;
1857 module_put(THIS_MODULE);
1858 ret = 0;
1859 break;
1860 case CONTROL_CHANNEL:
1861 ret = channel_bctrl(bch, arg);
1862 break;
1863 default:
1864 printk(KERN_WARNING "%s: unknown prim(%x)\n",
1865 __func__, cmd);
1866 }
1867 return ret;
1868}
1869
1870static int
1871setup_instance(struct hfcsusb *hw, struct device *parent)
1872{
1873 u_long flags;
1874 int err, i;
1875
1876 if (debug & DBG_HFC_CALL_TRACE)
1877 printk(KERN_DEBUG "%s: %s\n", hw->name, __func__);
1878
1879 spin_lock_init(&hw->ctrl_lock);
1880 spin_lock_init(&hw->lock);
1881
1882 mISDN_initdchannel(&hw->dch, MAX_DFRAME_LEN_L1, ph_state);
1883 hw->dch.debug = debug & 0xFFFF;
1884 hw->dch.hw = hw;
1885 hw->dch.dev.Dprotocols = (1 << ISDN_P_TE_S0) | (1 << ISDN_P_NT_S0);
1886 hw->dch.dev.D.send = hfcusb_l2l1D;
1887 hw->dch.dev.D.ctrl = hfc_dctrl;
1888
1889 /* enable E-Channel logging */
1890 if (hw->fifos[HFCUSB_PCM_RX].pipe)
1891 mISDN_initdchannel(&hw->ech, MAX_DFRAME_LEN_L1, NULL);
1892
1893 hw->dch.dev.Bprotocols = (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)) |
1894 (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK));
1895 hw->dch.dev.nrbchan = 2;
1896 for (i = 0; i < 2; i++) {
1897 hw->bch[i].nr = i + 1;
1898 set_channelmap(i + 1, hw->dch.dev.channelmap);
1899 hw->bch[i].debug = debug;
1900 mISDN_initbchannel(&hw->bch[i], MAX_DATA_MEM);
1901 hw->bch[i].hw = hw;
1902 hw->bch[i].ch.send = hfcusb_l2l1B;
1903 hw->bch[i].ch.ctrl = hfc_bctrl;
1904 hw->bch[i].ch.nr = i + 1;
1905 list_add(&hw->bch[i].ch.list, &hw->dch.dev.bchannels);
1906 }
1907
1908 hw->fifos[HFCUSB_B1_TX].bch = &hw->bch[0];
1909 hw->fifos[HFCUSB_B1_RX].bch = &hw->bch[0];
1910 hw->fifos[HFCUSB_B2_TX].bch = &hw->bch[1];
1911 hw->fifos[HFCUSB_B2_RX].bch = &hw->bch[1];
1912 hw->fifos[HFCUSB_D_TX].dch = &hw->dch;
1913 hw->fifos[HFCUSB_D_RX].dch = &hw->dch;
1914 hw->fifos[HFCUSB_PCM_RX].ech = &hw->ech;
1915 hw->fifos[HFCUSB_PCM_TX].ech = &hw->ech;
1916
1917 err = setup_hfcsusb(hw);
1918 if (err)
1919 goto out;
1920
1921 snprintf(hw->name, MISDN_MAX_IDLEN - 1, "%s.%d", DRIVER_NAME,
1922 hfcsusb_cnt + 1);
1923 printk(KERN_INFO "%s: registered as '%s'\n",
1924 DRIVER_NAME, hw->name);
1925
1926 err = mISDN_register_device(&hw->dch.dev, parent, hw->name);
1927 if (err)
1928 goto out;
1929
1930 hfcsusb_cnt++;
1931 write_lock_irqsave(&HFClock, flags);
1932 list_add_tail(&hw->list, &HFClist);
1933 write_unlock_irqrestore(&HFClock, flags);
1934 return 0;
1935
1936out:
1937 mISDN_freebchannel(&hw->bch[1]);
1938 mISDN_freebchannel(&hw->bch[0]);
1939 mISDN_freedchannel(&hw->dch);
1940 kfree(hw);
1941 return err;
1942}
1943
1944static int
1945hfcsusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
1946{
1947 struct hfcsusb *hw;
1948 struct usb_device *dev = interface_to_usbdev(intf);
1949 struct usb_host_interface *iface = intf->cur_altsetting;
1950 struct usb_host_interface *iface_used = NULL;
1951 struct usb_host_endpoint *ep;
1952 struct hfcsusb_vdata *driver_info;
1953 int ifnum = iface->desc.bInterfaceNumber, i, idx, alt_idx,
1954 probe_alt_setting, vend_idx, cfg_used, *vcf, attr, cfg_found,
1955 ep_addr, cmptbl[16], small_match, iso_packet_size, packet_size,
1956 alt_used = 0;
1957
1958 vend_idx = 0xffff;
1959 for (i = 0; hfcsusb_idtab[i].idVendor; i++) {
1960 if ((le16_to_cpu(dev->descriptor.idVendor)
1961 == hfcsusb_idtab[i].idVendor) &&
1962 (le16_to_cpu(dev->descriptor.idProduct)
1963 == hfcsusb_idtab[i].idProduct)) {
1964 vend_idx = i;
1965 continue;
1966 }
1967 }
1968
1969 printk(KERN_DEBUG
1970 "%s: interface(%d) actalt(%d) minor(%d) vend_idx(%d)\n",
1971 __func__, ifnum, iface->desc.bAlternateSetting,
1972 intf->minor, vend_idx);
1973
1974 if (vend_idx == 0xffff) {
1975 printk(KERN_WARNING
1976 "%s: no valid vendor found in USB descriptor\n",
1977 __func__);
1978 return -EIO;
1979 }
1980 /* if vendor and product ID is OK, start probing alternate settings */
1981 alt_idx = 0;
1982 small_match = -1;
1983
1984 /* default settings */
1985 iso_packet_size = 16;
1986 packet_size = 64;
1987
1988 while (alt_idx < intf->num_altsetting) {
1989 iface = intf->altsetting + alt_idx;
1990 probe_alt_setting = iface->desc.bAlternateSetting;
1991 cfg_used = 0;
1992
1993 while (validconf[cfg_used][0]) {
1994 cfg_found = 1;
1995 vcf = validconf[cfg_used];
1996 ep = iface->endpoint;
1997 memcpy(cmptbl, vcf, 16 * sizeof(int));
1998
1999 /* check for all endpoints in this alternate setting */
2000 for (i = 0; i < iface->desc.bNumEndpoints; i++) {
2001 ep_addr = ep->desc.bEndpointAddress;
2002
2003 /* get endpoint base */
2004 idx = ((ep_addr & 0x7f) - 1) * 2;
2005 if (ep_addr & 0x80)
2006 idx++;
2007 attr = ep->desc.bmAttributes;
2008
2009 if (cmptbl[idx] != EP_NOP) {
2010 if (cmptbl[idx] == EP_NUL)
2011 cfg_found = 0;
2012 if (attr == USB_ENDPOINT_XFER_INT
2013 && cmptbl[idx] == EP_INT)
2014 cmptbl[idx] = EP_NUL;
2015 if (attr == USB_ENDPOINT_XFER_BULK
2016 && cmptbl[idx] == EP_BLK)
2017 cmptbl[idx] = EP_NUL;
2018 if (attr == USB_ENDPOINT_XFER_ISOC
2019 && cmptbl[idx] == EP_ISO)
2020 cmptbl[idx] = EP_NUL;
2021
2022 if (attr == USB_ENDPOINT_XFER_INT &&
2023 ep->desc.bInterval < vcf[17]) {
2024 cfg_found = 0;
2025 }
2026 }
2027 ep++;
2028 }
2029
2030 for (i = 0; i < 16; i++)
2031 if (cmptbl[i] != EP_NOP && cmptbl[i] != EP_NUL)
2032 cfg_found = 0;
2033
2034 if (cfg_found) {
2035 if (small_match < cfg_used) {
2036 small_match = cfg_used;
2037 alt_used = probe_alt_setting;
2038 iface_used = iface;
2039 }
2040 }
2041 cfg_used++;
2042 }
2043 alt_idx++;
2044 } /* (alt_idx < intf->num_altsetting) */
2045
2046 /* not found a valid USB Ta Endpoint config */
2047 if (small_match == -1)
2048 return -EIO;
2049
2050 iface = iface_used;
2051 hw = kzalloc(sizeof(struct hfcsusb), GFP_KERNEL);
2052 if (!hw)
2053 return -ENOMEM; /* got no mem */
2054 snprintf(hw->name, MISDN_MAX_IDLEN - 1, "%s", DRIVER_NAME);
2055
2056 ep = iface->endpoint;
2057 vcf = validconf[small_match];
2058
2059 for (i = 0; i < iface->desc.bNumEndpoints; i++) {
2060 struct usb_fifo *f;
2061
2062 ep_addr = ep->desc.bEndpointAddress;
2063 /* get endpoint base */
2064 idx = ((ep_addr & 0x7f) - 1) * 2;
2065 if (ep_addr & 0x80)
2066 idx++;
2067 f = &hw->fifos[idx & 7];
2068
2069 /* init Endpoints */
2070 if (vcf[idx] == EP_NOP || vcf[idx] == EP_NUL) {
2071 ep++;
2072 continue;
2073 }
2074 switch (ep->desc.bmAttributes) {
2075 case USB_ENDPOINT_XFER_INT:
2076 f->pipe = usb_rcvintpipe(dev,
2077 ep->desc.bEndpointAddress);
2078 f->usb_transfer_mode = USB_INT;
2079 packet_size = le16_to_cpu(ep->desc.wMaxPacketSize);
2080 break;
2081 case USB_ENDPOINT_XFER_BULK:
2082 if (ep_addr & 0x80)
2083 f->pipe = usb_rcvbulkpipe(dev,
2084 ep->desc.bEndpointAddress);
2085 else
2086 f->pipe = usb_sndbulkpipe(dev,
2087 ep->desc.bEndpointAddress);
2088 f->usb_transfer_mode = USB_BULK;
2089 packet_size = le16_to_cpu(ep->desc.wMaxPacketSize);
2090 break;
2091 case USB_ENDPOINT_XFER_ISOC:
2092 if (ep_addr & 0x80)
2093 f->pipe = usb_rcvisocpipe(dev,
2094 ep->desc.bEndpointAddress);
2095 else
2096 f->pipe = usb_sndisocpipe(dev,
2097 ep->desc.bEndpointAddress);
2098 f->usb_transfer_mode = USB_ISOC;
2099 iso_packet_size = le16_to_cpu(ep->desc.wMaxPacketSize);
2100 break;
2101 default:
2102 f->pipe = 0;
2103 }
2104
2105 if (f->pipe) {
2106 f->fifonum = idx & 7;
2107 f->hw = hw;
2108 f->usb_packet_maxlen =
2109 le16_to_cpu(ep->desc.wMaxPacketSize);
2110 f->intervall = ep->desc.bInterval;
2111 }
2112 ep++;
2113 }
2114 hw->dev = dev; /* save device */
2115 hw->if_used = ifnum; /* save used interface */
2116 hw->alt_used = alt_used; /* and alternate config */
2117 hw->ctrl_paksize = dev->descriptor.bMaxPacketSize0; /* control size */
2118 hw->cfg_used = vcf[16]; /* store used config */
2119 hw->vend_idx = vend_idx; /* store found vendor */
2120 hw->packet_size = packet_size;
2121 hw->iso_packet_size = iso_packet_size;
2122
2123 /* create the control pipes needed for register access */
2124 hw->ctrl_in_pipe = usb_rcvctrlpipe(hw->dev, 0);
2125 hw->ctrl_out_pipe = usb_sndctrlpipe(hw->dev, 0);
2126 hw->ctrl_urb = usb_alloc_urb(0, GFP_KERNEL);
2127
2128 driver_info =
2129 (struct hfcsusb_vdata *)hfcsusb_idtab[vend_idx].driver_info;
2130 printk(KERN_DEBUG "%s: %s: detected \"%s\" (%s, if=%d alt=%d)\n",
2131 hw->name, __func__, driver_info->vend_name,
2132 conf_str[small_match], ifnum, alt_used);
2133
2134 if (setup_instance(hw, dev->dev.parent))
2135 return -EIO;
2136
2137 hw->intf = intf;
2138 usb_set_intfdata(hw->intf, hw);
2139 return 0;
2140}
2141
2142/* function called when an active device is removed */
2143static void
2144hfcsusb_disconnect(struct usb_interface *intf)
2145{
2146 struct hfcsusb *hw = usb_get_intfdata(intf);
2147 struct hfcsusb *next;
2148 int cnt = 0;
2149
2150 printk(KERN_INFO "%s: device disconnected\n", hw->name);
2151
2152 handle_led(hw, LED_POWER_OFF);
2153 release_hw(hw);
2154
2155 list_for_each_entry_safe(hw, next, &HFClist, list)
2156 cnt++;
2157 if (!cnt)
2158 hfcsusb_cnt = 0;
2159
2160 usb_set_intfdata(intf, NULL);
2161}
2162
2163static struct usb_driver hfcsusb_drv = {
2164 .name = DRIVER_NAME,
2165 .id_table = hfcsusb_idtab,
2166 .probe = hfcsusb_probe,
2167 .disconnect = hfcsusb_disconnect,
2168};
2169
2170static int __init
2171hfcsusb_init(void)
2172{
2173 printk(KERN_INFO DRIVER_NAME " driver Rev. %s debug(0x%x) poll(%i)\n",
2174 hfcsusb_rev, debug, poll);
2175
2176 if (usb_register(&hfcsusb_drv)) {
2177 printk(KERN_INFO DRIVER_NAME
2178 ": Unable to register hfcsusb module at usb stack\n");
2179 return -ENODEV;
2180 }
2181
2182 return 0;
2183}
2184
2185static void __exit
2186hfcsusb_cleanup(void)
2187{
2188 if (debug & DBG_HFC_CALL_TRACE)
2189 printk(KERN_INFO DRIVER_NAME ": %s\n", __func__);
2190
2191 /* unregister Hardware */
2192 usb_deregister(&hfcsusb_drv); /* release our driver */
2193}
2194
2195module_init(hfcsusb_init);
2196module_exit(hfcsusb_cleanup);
diff --git a/drivers/isdn/hardware/mISDN/hfcsusb.h b/drivers/isdn/hardware/mISDN/hfcsusb.h
new file mode 100644
index 000000000000..098486b8e8d2
--- /dev/null
+++ b/drivers/isdn/hardware/mISDN/hfcsusb.h
@@ -0,0 +1,418 @@
1/*
2 * hfcsusb.h, HFC-S USB mISDN driver
3 */
4
5#ifndef __HFCSUSB_H__
6#define __HFCSUSB_H__
7
8
9#define DRIVER_NAME "HFC-S_USB"
10
11#define DBG_HFC_CALL_TRACE 0x00010000
12#define DBG_HFC_FIFO_VERBOSE 0x00020000
13#define DBG_HFC_USB_VERBOSE 0x00100000
14#define DBG_HFC_URB_INFO 0x00200000
15#define DBG_HFC_URB_ERROR 0x00400000
16
17#define DEFAULT_TRANSP_BURST_SZ 128
18
19#define HFC_CTRL_TIMEOUT 20 /* 5ms timeout writing/reading regs */
20#define CLKDEL_TE 0x0f /* CLKDEL in TE mode */
21#define CLKDEL_NT 0x6c /* CLKDEL in NT mode */
22
23/* hfcsusb Layer1 commands */
24#define HFC_L1_ACTIVATE_TE 1
25#define HFC_L1_ACTIVATE_NT 2
26#define HFC_L1_DEACTIVATE_NT 3
27#define HFC_L1_FORCE_DEACTIVATE_TE 4
28
29/* cmd FLAGS in HFCUSB_STATES register */
30#define HFCUSB_LOAD_STATE 0x10
31#define HFCUSB_ACTIVATE 0x20
32#define HFCUSB_DO_ACTION 0x40
33#define HFCUSB_NT_G2_G3 0x80
34
35/* timers */
36#define NT_ACTIVATION_TIMER 0x01 /* enables NT mode activation Timer */
37#define NT_T1_COUNT 10
38
39#define MAX_BCH_SIZE 2048 /* allowed B-channel packet size */
40
41#define HFCUSB_RX_THRESHOLD 64 /* threshold for fifo report bit rx */
42#define HFCUSB_TX_THRESHOLD 96 /* threshold for fifo report bit tx */
43
44#define HFCUSB_CHIP_ID 0x16 /* Chip ID register index */
45#define HFCUSB_CIRM 0x00 /* cirm register index */
46#define HFCUSB_USB_SIZE 0x07 /* int length register */
47#define HFCUSB_USB_SIZE_I 0x06 /* iso length register */
48#define HFCUSB_F_CROSS 0x0b /* bit order register */
49#define HFCUSB_CLKDEL 0x37 /* bit delay register */
50#define HFCUSB_CON_HDLC 0xfa /* channel connect register */
51#define HFCUSB_HDLC_PAR 0xfb
52#define HFCUSB_SCTRL 0x31 /* S-bus control register (tx) */
53#define HFCUSB_SCTRL_E 0x32 /* same for E and special funcs */
54#define HFCUSB_SCTRL_R 0x33 /* S-bus control register (rx) */
55#define HFCUSB_F_THRES 0x0c /* threshold register */
56#define HFCUSB_FIFO 0x0f /* fifo select register */
57#define HFCUSB_F_USAGE 0x1a /* fifo usage register */
58#define HFCUSB_MST_MODE0 0x14
59#define HFCUSB_MST_MODE1 0x15
60#define HFCUSB_P_DATA 0x1f
61#define HFCUSB_INC_RES_F 0x0e
62#define HFCUSB_B1_SSL 0x20
63#define HFCUSB_B2_SSL 0x21
64#define HFCUSB_B1_RSL 0x24
65#define HFCUSB_B2_RSL 0x25
66#define HFCUSB_STATES 0x30
67
68
69#define HFCUSB_CHIPID 0x40 /* ID value of HFC-S USB */
70
71/* fifo registers */
72#define HFCUSB_NUM_FIFOS 8 /* maximum number of fifos */
73#define HFCUSB_B1_TX 0 /* index for B1 transmit bulk/int */
74#define HFCUSB_B1_RX 1 /* index for B1 receive bulk/int */
75#define HFCUSB_B2_TX 2
76#define HFCUSB_B2_RX 3
77#define HFCUSB_D_TX 4
78#define HFCUSB_D_RX 5
79#define HFCUSB_PCM_TX 6
80#define HFCUSB_PCM_RX 7
81
82
83#define USB_INT 0
84#define USB_BULK 1
85#define USB_ISOC 2
86
87#define ISOC_PACKETS_D 8
88#define ISOC_PACKETS_B 8
89#define ISO_BUFFER_SIZE 128
90
91/* defines how much ISO packets are handled in one URB */
92static int iso_packets[8] =
93 { ISOC_PACKETS_B, ISOC_PACKETS_B, ISOC_PACKETS_B, ISOC_PACKETS_B,
94 ISOC_PACKETS_D, ISOC_PACKETS_D, ISOC_PACKETS_D, ISOC_PACKETS_D
95};
96
97
98/* Fifo flow Control for TX ISO */
99#define SINK_MAX 68
100#define SINK_MIN 48
101#define SINK_DMIN 12
102#define SINK_DMAX 18
103#define BITLINE_INF (-96*8)
104
105/* HFC-S USB register access by Control-URSs */
106#define write_reg_atomic(a, b, c) \
107 usb_control_msg((a)->dev, (a)->ctrl_out_pipe, 0, 0x40, (c), (b), \
108 0, 0, HFC_CTRL_TIMEOUT)
109#define read_reg_atomic(a, b, c) \
110 usb_control_msg((a)->dev, (a)->ctrl_in_pipe, 1, 0xC0, 0, (b), (c), \
111 1, HFC_CTRL_TIMEOUT)
112#define HFC_CTRL_BUFSIZE 64
113
114struct ctrl_buf {
115 __u8 hfcs_reg; /* register number */
116 __u8 reg_val; /* value to be written (or read) */
117};
118
119/*
120 * URB error codes
121 * Used to represent a list of values and their respective symbolic names
122 */
123struct hfcusb_symbolic_list {
124 const int num;
125 const char *name;
126};
127
128static struct hfcusb_symbolic_list urb_errlist[] = {
129 {-ENOMEM, "No memory for allocation of internal structures"},
130 {-ENOSPC, "The host controller's bandwidth is already consumed"},
131 {-ENOENT, "URB was canceled by unlink_urb"},
132 {-EXDEV, "ISO transfer only partially completed"},
133 {-EAGAIN, "Too match scheduled for the future"},
134 {-ENXIO, "URB already queued"},
135 {-EFBIG, "Too much ISO frames requested"},
136 {-ENOSR, "Buffer error (overrun)"},
137 {-EPIPE, "Specified endpoint is stalled (device not responding)"},
138 {-EOVERFLOW, "Babble (bad cable?)"},
139 {-EPROTO, "Bit-stuff error (bad cable?)"},
140 {-EILSEQ, "CRC/Timeout"},
141 {-ETIMEDOUT, "NAK (device does not respond)"},
142 {-ESHUTDOWN, "Device unplugged"},
143 {-1, NULL}
144};
145
146static inline const char *
147symbolic(struct hfcusb_symbolic_list list[], const int num)
148{
149 int i;
150 for (i = 0; list[i].name != NULL; i++)
151 if (list[i].num == num)
152 return list[i].name;
153 return "<unkown USB Error>";
154}
155
156/* USB descriptor need to contain one of the following EndPoint combination: */
157#define CNF_4INT3ISO 1 /* 4 INT IN, 3 ISO OUT */
158#define CNF_3INT3ISO 2 /* 3 INT IN, 3 ISO OUT */
159#define CNF_4ISO3ISO 3 /* 4 ISO IN, 3 ISO OUT */
160#define CNF_3ISO3ISO 4 /* 3 ISO IN, 3 ISO OUT */
161
162#define EP_NUL 1 /* Endpoint at this position not allowed */
163#define EP_NOP 2 /* all type of endpoints allowed at this position */
164#define EP_ISO 3 /* Isochron endpoint mandatory at this position */
165#define EP_BLK 4 /* Bulk endpoint mandatory at this position */
166#define EP_INT 5 /* Interrupt endpoint mandatory at this position */
167
168#define HFC_CHAN_B1 0
169#define HFC_CHAN_B2 1
170#define HFC_CHAN_D 2
171#define HFC_CHAN_E 3
172
173
174/*
175 * List of all supported enpoints configiration sets, used to find the
176 * best matching endpoint configuration within a devices' USB descriptor.
177 * We need at least 3 RX endpoints, and 3 TX endpoints, either
178 * INT-in and ISO-out, or ISO-in and ISO-out)
179 * with 4 RX endpoints even E-Channel logging is possible
180 */
181static int
182validconf[][19] = {
183 /* INT in, ISO out config */
184 {EP_NUL, EP_INT, EP_NUL, EP_INT, EP_NUL, EP_INT, EP_NOP, EP_INT,
185 EP_ISO, EP_NUL, EP_ISO, EP_NUL, EP_ISO, EP_NUL, EP_NUL, EP_NUL,
186 CNF_4INT3ISO, 2, 1},
187 {EP_NUL, EP_INT, EP_NUL, EP_INT, EP_NUL, EP_INT, EP_NUL, EP_NUL,
188 EP_ISO, EP_NUL, EP_ISO, EP_NUL, EP_ISO, EP_NUL, EP_NUL, EP_NUL,
189 CNF_3INT3ISO, 2, 0},
190 /* ISO in, ISO out config */
191 {EP_NOP, EP_NOP, EP_NOP, EP_NOP, EP_NOP, EP_NOP, EP_NOP, EP_NOP,
192 EP_ISO, EP_ISO, EP_ISO, EP_ISO, EP_ISO, EP_ISO, EP_NOP, EP_ISO,
193 CNF_4ISO3ISO, 2, 1},
194 {EP_NUL, EP_NUL, EP_NUL, EP_NUL, EP_NUL, EP_NUL, EP_NUL, EP_NUL,
195 EP_ISO, EP_ISO, EP_ISO, EP_ISO, EP_ISO, EP_ISO, EP_NUL, EP_NUL,
196 CNF_3ISO3ISO, 2, 0},
197 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} /* EOL element */
198};
199
200/* string description of chosen config */
201char *conf_str[] = {
202 "4 Interrupt IN + 3 Isochron OUT",
203 "3 Interrupt IN + 3 Isochron OUT",
204 "4 Isochron IN + 3 Isochron OUT",
205 "3 Isochron IN + 3 Isochron OUT"
206};
207
208
209#define LED_OFF 0 /* no LED support */
210#define LED_SCHEME1 1 /* LED standard scheme */
211#define LED_SCHEME2 2 /* not used yet... */
212
213#define LED_POWER_ON 1
214#define LED_POWER_OFF 2
215#define LED_S0_ON 3
216#define LED_S0_OFF 4
217#define LED_B1_ON 5
218#define LED_B1_OFF 6
219#define LED_B1_DATA 7
220#define LED_B2_ON 8
221#define LED_B2_OFF 9
222#define LED_B2_DATA 10
223
224#define LED_NORMAL 0 /* LEDs are normal */
225#define LED_INVERTED 1 /* LEDs are inverted */
226
227/* time in ms to perform a Flashing LED when B-Channel has traffic */
228#define LED_TIME 250
229
230
231
232struct hfcsusb;
233struct usb_fifo;
234
235/* structure defining input+output fifos (interrupt/bulk mode) */
236struct iso_urb {
237 struct urb *urb;
238 __u8 buffer[ISO_BUFFER_SIZE]; /* buffer rx/tx USB URB data */
239 struct usb_fifo *owner_fifo; /* pointer to owner fifo */
240 __u8 indx; /* Fifos's ISO double buffer 0 or 1 ? */
241#ifdef ISO_FRAME_START_DEBUG
242 int start_frames[ISO_FRAME_START_RING_COUNT];
243 __u8 iso_frm_strt_pos; /* index in start_frame[] */
244#endif
245};
246
247struct usb_fifo {
248 int fifonum; /* fifo index attached to this structure */
249 int active; /* fifo is currently active */
250 struct hfcsusb *hw; /* pointer to main structure */
251 int pipe; /* address of endpoint */
252 __u8 usb_packet_maxlen; /* maximum length for usb transfer */
253 unsigned int max_size; /* maximum size of receive/send packet */
254 __u8 intervall; /* interrupt interval */
255 struct urb *urb; /* transfer structure for usb routines */
256 __u8 buffer[128]; /* buffer USB INT OUT URB data */
257 int bit_line; /* how much bits are in the fifo? */
258
259 __u8 usb_transfer_mode; /* switched between ISO and INT */
260 struct iso_urb iso[2]; /* two urbs to have one always
261 one pending */
262
263 struct dchannel *dch; /* link to hfcsusb_t->dch */
264 struct bchannel *bch; /* link to hfcsusb_t->bch */
265 struct dchannel *ech; /* link to hfcsusb_t->ech, TODO: E-CHANNEL */
266 int last_urblen; /* remember length of last packet */
267 __u8 stop_gracefull; /* stops URB retransmission */
268};
269
270struct hfcsusb {
271 struct list_head list;
272 struct dchannel dch;
273 struct bchannel bch[2];
274 struct dchannel ech; /* TODO : wait for struct echannel ;) */
275
276 struct usb_device *dev; /* our device */
277 struct usb_interface *intf; /* used interface */
278 int if_used; /* used interface number */
279 int alt_used; /* used alternate config */
280 int cfg_used; /* configuration index used */
281 int vend_idx; /* index in hfcsusb_idtab */
282 int packet_size;
283 int iso_packet_size;
284 struct usb_fifo fifos[HFCUSB_NUM_FIFOS];
285
286 /* control pipe background handling */
287 struct ctrl_buf ctrl_buff[HFC_CTRL_BUFSIZE];
288 int ctrl_in_idx, ctrl_out_idx, ctrl_cnt;
289 struct urb *ctrl_urb;
290 struct usb_ctrlrequest ctrl_write;
291 struct usb_ctrlrequest ctrl_read;
292 int ctrl_paksize;
293 int ctrl_in_pipe, ctrl_out_pipe;
294 spinlock_t ctrl_lock; /* lock for ctrl */
295 spinlock_t lock;
296
297 __u8 threshold_mask;
298 __u8 led_state;
299
300 __u8 protocol;
301 int nt_timer;
302 int open;
303 __u8 timers;
304 __u8 initdone;
305 char name[MISDN_MAX_IDLEN];
306};
307
308/* private vendor specific data */
309struct hfcsusb_vdata {
310 __u8 led_scheme; /* led display scheme */
311 signed short led_bits[8]; /* array of 8 possible LED bitmask */
312 char *vend_name; /* device name */
313};
314
315
316#define HFC_MAX_TE_LAYER1_STATE 8
317#define HFC_MAX_NT_LAYER1_STATE 4
318
319const char *HFC_TE_LAYER1_STATES[HFC_MAX_TE_LAYER1_STATE + 1] = {
320 "TE F0 - Reset",
321 "TE F1 - Reset",
322 "TE F2 - Sensing",
323 "TE F3 - Deactivated",
324 "TE F4 - Awaiting signal",
325 "TE F5 - Identifying input",
326 "TE F6 - Synchronized",
327 "TE F7 - Activated",
328 "TE F8 - Lost framing",
329};
330
331const char *HFC_NT_LAYER1_STATES[HFC_MAX_NT_LAYER1_STATE + 1] = {
332 "NT G0 - Reset",
333 "NT G1 - Deactive",
334 "NT G2 - Pending activation",
335 "NT G3 - Active",
336 "NT G4 - Pending deactivation",
337};
338
339/* supported devices */
340static struct usb_device_id hfcsusb_idtab[] = {
341 {
342 USB_DEVICE(0x0959, 0x2bd0),
343 .driver_info = (unsigned long) &((struct hfcsusb_vdata)
344 {LED_OFF, {4, 0, 2, 1},
345 "ISDN USB TA (Cologne Chip HFC-S USB based)"}),
346 },
347 {
348 USB_DEVICE(0x0675, 0x1688),
349 .driver_info = (unsigned long) &((struct hfcsusb_vdata)
350 {LED_SCHEME1, {1, 2, 0, 0},
351 "DrayTek miniVigor 128 USB ISDN TA"}),
352 },
353 {
354 USB_DEVICE(0x07b0, 0x0007),
355 .driver_info = (unsigned long) &((struct hfcsusb_vdata)
356 {LED_SCHEME1, {0x80, -64, -32, -16},
357 "Billion tiny USB ISDN TA 128"}),
358 },
359 {
360 USB_DEVICE(0x0742, 0x2008),
361 .driver_info = (unsigned long) &((struct hfcsusb_vdata)
362 {LED_SCHEME1, {4, 0, 2, 1},
363 "Stollmann USB TA"}),
364 },
365 {
366 USB_DEVICE(0x0742, 0x2009),
367 .driver_info = (unsigned long) &((struct hfcsusb_vdata)
368 {LED_SCHEME1, {4, 0, 2, 1},
369 "Aceex USB ISDN TA"}),
370 },
371 {
372 USB_DEVICE(0x0742, 0x200A),
373 .driver_info = (unsigned long) &((struct hfcsusb_vdata)
374 {LED_SCHEME1, {4, 0, 2, 1},
375 "OEM USB ISDN TA"}),
376 },
377 {
378 USB_DEVICE(0x08e3, 0x0301),
379 .driver_info = (unsigned long) &((struct hfcsusb_vdata)
380 {LED_SCHEME1, {2, 0, 1, 4},
381 "Olitec USB RNIS"}),
382 },
383 {
384 USB_DEVICE(0x07fa, 0x0846),
385 .driver_info = (unsigned long) &((struct hfcsusb_vdata)
386 {LED_SCHEME1, {0x80, -64, -32, -16},
387 "Bewan Modem RNIS USB"}),
388 },
389 {
390 USB_DEVICE(0x07fa, 0x0847),
391 .driver_info = (unsigned long) &((struct hfcsusb_vdata)
392 {LED_SCHEME1, {0x80, -64, -32, -16},
393 "Djinn Numeris USB"}),
394 },
395 {
396 USB_DEVICE(0x07b0, 0x0006),
397 .driver_info = (unsigned long) &((struct hfcsusb_vdata)
398 {LED_SCHEME1, {0x80, -64, -32, -16},
399 "Twister ISDN TA"}),
400 },
401 {
402 USB_DEVICE(0x071d, 0x1005),
403 .driver_info = (unsigned long) &((struct hfcsusb_vdata)
404 {LED_SCHEME1, {0x02, 0, 0x01, 0x04},
405 "Eicon DIVA USB 4.0"}),
406 },
407 {
408 USB_DEVICE(0x0586, 0x0102),
409 .driver_info = (unsigned long) &((struct hfcsusb_vdata)
410 {LED_SCHEME1, {0x88, -64, -32, -16},
411 "ZyXEL OMNI.NET USB II"}),
412 },
413 { }
414};
415
416MODULE_DEVICE_TABLE(usb, hfcsusb_idtab);
417
418#endif /* __HFCSUSB_H__ */
diff --git a/drivers/isdn/mISDN/Makefile b/drivers/isdn/mISDN/Makefile
index 1cb5e633cf75..0a6bd2a9e730 100644
--- a/drivers/isdn/mISDN/Makefile
+++ b/drivers/isdn/mISDN/Makefile
@@ -8,6 +8,6 @@ obj-$(CONFIG_MISDN_L1OIP) += l1oip.o
8 8
9# multi objects 9# multi objects
10 10
11mISDN_core-objs := core.o fsm.o socket.o hwchannel.o stack.o layer1.o layer2.o tei.o timerdev.o 11mISDN_core-objs := core.o fsm.o socket.o clock.o hwchannel.o stack.o layer1.o layer2.o tei.o timerdev.o
12mISDN_dsp-objs := dsp_core.o dsp_cmx.o dsp_tones.o dsp_dtmf.o dsp_audio.o dsp_blowfish.o dsp_pipeline.o dsp_hwec.o 12mISDN_dsp-objs := dsp_core.o dsp_cmx.o dsp_tones.o dsp_dtmf.o dsp_audio.o dsp_blowfish.o dsp_pipeline.o dsp_hwec.o
13l1oip-objs := l1oip_core.o l1oip_codec.o 13l1oip-objs := l1oip_core.o l1oip_codec.o
diff --git a/drivers/isdn/mISDN/clock.c b/drivers/isdn/mISDN/clock.c
new file mode 100644
index 000000000000..44d9c3d5d33d
--- /dev/null
+++ b/drivers/isdn/mISDN/clock.c
@@ -0,0 +1,216 @@
1/*
2 * Copyright 2008 by Andreas Eversberg <andreas@eversberg.eu>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * Quick API description:
14 *
15 * A clock source registers using mISDN_register_clock:
16 * name = text string to name clock source
17 * priority = value to priorize clock sources (0 = default)
18 * ctl = callback function to enable/disable clock source
19 * priv = private pointer of clock source
20 * return = pointer to clock source structure;
21 *
22 * Note: Callback 'ctl' can be called before mISDN_register_clock returns!
23 * Also it can be called during mISDN_unregister_clock.
24 *
25 * A clock source calls mISDN_clock_update with given samples elapsed, if
26 * enabled. If function call is delayed, tv must be set with the timestamp
27 * of the actual event.
28 *
29 * A clock source unregisters using mISDN_unregister_clock.
30 *
31 * To get current clock, call mISDN_clock_get. The signed short value
32 * counts the number of samples since. Time since last clock event is added.
33 *
34 */
35
36#include <linux/types.h>
37#include <linux/stddef.h>
38#include <linux/spinlock.h>
39#include <linux/mISDNif.h>
40#include "core.h"
41
42static u_int *debug;
43static LIST_HEAD(iclock_list);
44DEFINE_RWLOCK(iclock_lock);
45u16 iclock_count; /* counter of last clock */
46struct timeval iclock_tv; /* time stamp of last clock */
47int iclock_tv_valid; /* already received one timestamp */
48struct mISDNclock *iclock_current;
49
50void
51mISDN_init_clock(u_int *dp)
52{
53 debug = dp;
54 do_gettimeofday(&iclock_tv);
55}
56
57static void
58select_iclock(void)
59{
60 struct mISDNclock *iclock, *bestclock = NULL, *lastclock = NULL;
61 int pri = -128;
62
63 list_for_each_entry(iclock, &iclock_list, list) {
64 if (iclock->pri > pri) {
65 pri = iclock->pri;
66 bestclock = iclock;
67 }
68 if (iclock_current == iclock)
69 lastclock = iclock;
70 }
71 if (lastclock && bestclock != lastclock) {
72 /* last used clock source still exists but changes, disable */
73 if (*debug & DEBUG_CLOCK)
74 printk(KERN_DEBUG "Old clock source '%s' disable.\n",
75 lastclock->name);
76 lastclock->ctl(lastclock->priv, 0);
77 }
78 if (bestclock && bestclock != iclock_current) {
79 /* new clock source selected, enable */
80 if (*debug & DEBUG_CLOCK)
81 printk(KERN_DEBUG "New clock source '%s' enable.\n",
82 bestclock->name);
83 bestclock->ctl(bestclock->priv, 1);
84 }
85 if (bestclock != iclock_current) {
86 /* no clock received yet */
87 iclock_tv_valid = 0;
88 }
89 iclock_current = bestclock;
90}
91
92struct mISDNclock
93*mISDN_register_clock(char *name, int pri, clockctl_func_t *ctl, void *priv)
94{
95 u_long flags;
96 struct mISDNclock *iclock;
97
98 if (*debug & (DEBUG_CORE | DEBUG_CLOCK))
99 printk(KERN_DEBUG "%s: %s %d\n", __func__, name, pri);
100 iclock = kzalloc(sizeof(struct mISDNclock), GFP_ATOMIC);
101 if (!iclock) {
102 printk(KERN_ERR "%s: No memory for clock entry.\n", __func__);
103 return NULL;
104 }
105 strncpy(iclock->name, name, sizeof(iclock->name)-1);
106 iclock->pri = pri;
107 iclock->priv = priv;
108 iclock->ctl = ctl;
109 write_lock_irqsave(&iclock_lock, flags);
110 list_add_tail(&iclock->list, &iclock_list);
111 select_iclock();
112 write_unlock_irqrestore(&iclock_lock, flags);
113 return iclock;
114}
115EXPORT_SYMBOL(mISDN_register_clock);
116
117void
118mISDN_unregister_clock(struct mISDNclock *iclock)
119{
120 u_long flags;
121
122 if (*debug & (DEBUG_CORE | DEBUG_CLOCK))
123 printk(KERN_DEBUG "%s: %s %d\n", __func__, iclock->name,
124 iclock->pri);
125 write_lock_irqsave(&iclock_lock, flags);
126 if (iclock_current == iclock) {
127 if (*debug & DEBUG_CLOCK)
128 printk(KERN_DEBUG
129 "Current clock source '%s' unregisters.\n",
130 iclock->name);
131 iclock->ctl(iclock->priv, 0);
132 }
133 list_del(&iclock->list);
134 select_iclock();
135 write_unlock_irqrestore(&iclock_lock, flags);
136}
137EXPORT_SYMBOL(mISDN_unregister_clock);
138
139void
140mISDN_clock_update(struct mISDNclock *iclock, int samples, struct timeval *tv)
141{
142 u_long flags;
143 struct timeval tv_now;
144 time_t elapsed_sec;
145 int elapsed_8000th;
146
147 write_lock_irqsave(&iclock_lock, flags);
148 if (iclock_current != iclock) {
149 printk(KERN_ERR "%s: '%s' sends us clock updates, but we do "
150 "listen to '%s'. This is a bug!\n", __func__,
151 iclock->name,
152 iclock_current ? iclock_current->name : "nothing");
153 iclock->ctl(iclock->priv, 0);
154 write_unlock_irqrestore(&iclock_lock, flags);
155 return;
156 }
157 if (iclock_tv_valid) {
158 /* increment sample counter by given samples */
159 iclock_count += samples;
160 if (tv) { /* tv must be set, if function call is delayed */
161 iclock_tv.tv_sec = tv->tv_sec;
162 iclock_tv.tv_usec = tv->tv_usec;
163 } else
164 do_gettimeofday(&iclock_tv);
165 } else {
166 /* calc elapsed time by system clock */
167 if (tv) { /* tv must be set, if function call is delayed */
168 tv_now.tv_sec = tv->tv_sec;
169 tv_now.tv_usec = tv->tv_usec;
170 } else
171 do_gettimeofday(&tv_now);
172 elapsed_sec = tv_now.tv_sec - iclock_tv.tv_sec;
173 elapsed_8000th = (tv_now.tv_usec / 125)
174 - (iclock_tv.tv_usec / 125);
175 if (elapsed_8000th < 0) {
176 elapsed_sec -= 1;
177 elapsed_8000th += 8000;
178 }
179 /* add elapsed time to counter and set new timestamp */
180 iclock_count += elapsed_sec * 8000 + elapsed_8000th;
181 iclock_tv.tv_sec = tv_now.tv_sec;
182 iclock_tv.tv_usec = tv_now.tv_usec;
183 iclock_tv_valid = 1;
184 if (*debug & DEBUG_CLOCK)
185 printk("Received first clock from source '%s'.\n",
186 iclock_current ? iclock_current->name : "nothing");
187 }
188 write_unlock_irqrestore(&iclock_lock, flags);
189}
190EXPORT_SYMBOL(mISDN_clock_update);
191
192unsigned short
193mISDN_clock_get(void)
194{
195 u_long flags;
196 struct timeval tv_now;
197 time_t elapsed_sec;
198 int elapsed_8000th;
199 u16 count;
200
201 read_lock_irqsave(&iclock_lock, flags);
202 /* calc elapsed time by system clock */
203 do_gettimeofday(&tv_now);
204 elapsed_sec = tv_now.tv_sec - iclock_tv.tv_sec;
205 elapsed_8000th = (tv_now.tv_usec / 125) - (iclock_tv.tv_usec / 125);
206 if (elapsed_8000th < 0) {
207 elapsed_sec -= 1;
208 elapsed_8000th += 8000;
209 }
210 /* add elapsed time to counter */
211 count = iclock_count + elapsed_sec * 8000 + elapsed_8000th;
212 read_unlock_irqrestore(&iclock_lock, flags);
213 return count;
214}
215EXPORT_SYMBOL(mISDN_clock_get);
216
diff --git a/drivers/isdn/mISDN/core.c b/drivers/isdn/mISDN/core.c
index 751665c448d0..9426c9827e47 100644
--- a/drivers/isdn/mISDN/core.c
+++ b/drivers/isdn/mISDN/core.c
@@ -25,39 +25,183 @@ MODULE_AUTHOR("Karsten Keil");
25MODULE_LICENSE("GPL"); 25MODULE_LICENSE("GPL");
26module_param(debug, uint, S_IRUGO | S_IWUSR); 26module_param(debug, uint, S_IRUGO | S_IWUSR);
27 27
28static LIST_HEAD(devices);
29static DEFINE_RWLOCK(device_lock);
30static u64 device_ids; 28static u64 device_ids;
31#define MAX_DEVICE_ID 63 29#define MAX_DEVICE_ID 63
32 30
33static LIST_HEAD(Bprotocols); 31static LIST_HEAD(Bprotocols);
34static DEFINE_RWLOCK(bp_lock); 32static DEFINE_RWLOCK(bp_lock);
35 33
34static void mISDN_dev_release(struct device *dev)
35{
36 /* nothing to do: the device is part of its parent's data structure */
37}
38
39static ssize_t _show_id(struct device *dev,
40 struct device_attribute *attr, char *buf)
41{
42 struct mISDNdevice *mdev = dev_to_mISDN(dev);
43
44 if (!mdev)
45 return -ENODEV;
46 return sprintf(buf, "%d\n", mdev->id);
47}
48
49static ssize_t _show_nrbchan(struct device *dev,
50 struct device_attribute *attr, char *buf)
51{
52 struct mISDNdevice *mdev = dev_to_mISDN(dev);
53
54 if (!mdev)
55 return -ENODEV;
56 return sprintf(buf, "%d\n", mdev->nrbchan);
57}
58
59static ssize_t _show_d_protocols(struct device *dev,
60 struct device_attribute *attr, char *buf)
61{
62 struct mISDNdevice *mdev = dev_to_mISDN(dev);
63
64 if (!mdev)
65 return -ENODEV;
66 return sprintf(buf, "%d\n", mdev->Dprotocols);
67}
68
69static ssize_t _show_b_protocols(struct device *dev,
70 struct device_attribute *attr, char *buf)
71{
72 struct mISDNdevice *mdev = dev_to_mISDN(dev);
73
74 if (!mdev)
75 return -ENODEV;
76 return sprintf(buf, "%d\n", mdev->Bprotocols | get_all_Bprotocols());
77}
78
79static ssize_t _show_protocol(struct device *dev,
80 struct device_attribute *attr, char *buf)
81{
82 struct mISDNdevice *mdev = dev_to_mISDN(dev);
83
84 if (!mdev)
85 return -ENODEV;
86 return sprintf(buf, "%d\n", mdev->D.protocol);
87}
88
89static ssize_t _show_name(struct device *dev,
90 struct device_attribute *attr, char *buf)
91{
92 strcpy(buf, dev_name(dev));
93 return strlen(buf);
94}
95
96#if 0 /* hangs */
97static ssize_t _set_name(struct device *dev, struct device_attribute *attr,
98 const char *buf, size_t count)
99{
100 int err = 0;
101 char *out = kmalloc(count + 1, GFP_KERNEL);
102
103 if (!out)
104 return -ENOMEM;
105
106 memcpy(out, buf, count);
107 if (count && out[count - 1] == '\n')
108 out[--count] = 0;
109 if (count)
110 err = device_rename(dev, out);
111 kfree(out);
112
113 return (err < 0) ? err : count;
114}
115#endif
116
117static ssize_t _show_channelmap(struct device *dev,
118 struct device_attribute *attr, char *buf)
119{
120 struct mISDNdevice *mdev = dev_to_mISDN(dev);
121 char *bp = buf;
122 int i;
123
124 for (i = 0; i <= mdev->nrbchan; i++)
125 *bp++ = test_channelmap(i, mdev->channelmap) ? '1' : '0';
126
127 return bp - buf;
128}
129
130static struct device_attribute mISDN_dev_attrs[] = {
131 __ATTR(id, S_IRUGO, _show_id, NULL),
132 __ATTR(d_protocols, S_IRUGO, _show_d_protocols, NULL),
133 __ATTR(b_protocols, S_IRUGO, _show_b_protocols, NULL),
134 __ATTR(protocol, S_IRUGO, _show_protocol, NULL),
135 __ATTR(channelmap, S_IRUGO, _show_channelmap, NULL),
136 __ATTR(nrbchan, S_IRUGO, _show_nrbchan, NULL),
137 __ATTR(name, S_IRUGO, _show_name, NULL),
138/* __ATTR(name, S_IRUGO|S_IWUSR, _show_name, _set_name), */
139 {}
140};
141
142#ifdef CONFIG_HOTPLUG
143static int mISDN_uevent(struct device *dev, struct kobj_uevent_env *env)
144{
145 struct mISDNdevice *mdev = dev_to_mISDN(dev);
146
147 if (!mdev)
148 return 0;
149
150 if (add_uevent_var(env, "nchans=%d", mdev->nrbchan))
151 return -ENOMEM;
152
153 return 0;
154}
155#endif
156
157static void mISDN_class_release(struct class *cls)
158{
159 /* do nothing, it's static */
160}
161
162static struct class mISDN_class = {
163 .name = "mISDN",
164 .owner = THIS_MODULE,
165#ifdef CONFIG_HOTPLUG
166 .dev_uevent = mISDN_uevent,
167#endif
168 .dev_attrs = mISDN_dev_attrs,
169 .dev_release = mISDN_dev_release,
170 .class_release = mISDN_class_release,
171};
172
173static int
174_get_mdevice(struct device *dev, void *id)
175{
176 struct mISDNdevice *mdev = dev_to_mISDN(dev);
177
178 if (!mdev)
179 return 0;
180 if (mdev->id != *(u_int *)id)
181 return 0;
182 return 1;
183}
184
36struct mISDNdevice 185struct mISDNdevice
37*get_mdevice(u_int id) 186*get_mdevice(u_int id)
38{ 187{
39 struct mISDNdevice *dev; 188 return dev_to_mISDN(class_find_device(&mISDN_class, NULL, &id,
189 _get_mdevice));
190}
40 191
41 read_lock(&device_lock); 192static int
42 list_for_each_entry(dev, &devices, D.list) 193_get_mdevice_count(struct device *dev, void *cnt)
43 if (dev->id == id) { 194{
44 read_unlock(&device_lock); 195 *(int *)cnt += 1;
45 return dev; 196 return 0;
46 }
47 read_unlock(&device_lock);
48 return NULL;
49} 197}
50 198
51int 199int
52get_mdevice_count(void) 200get_mdevice_count(void)
53{ 201{
54 struct mISDNdevice *dev; 202 int cnt = 0;
55 int cnt = 0;
56 203
57 read_lock(&device_lock); 204 class_for_each_device(&mISDN_class, NULL, &cnt, _get_mdevice_count);
58 list_for_each_entry(dev, &devices, D.list)
59 cnt++;
60 read_unlock(&device_lock);
61 return cnt; 205 return cnt;
62} 206}
63 207
@@ -68,48 +212,66 @@ get_free_devid(void)
68 212
69 for (i = 0; i <= MAX_DEVICE_ID; i++) 213 for (i = 0; i <= MAX_DEVICE_ID; i++)
70 if (!test_and_set_bit(i, (u_long *)&device_ids)) 214 if (!test_and_set_bit(i, (u_long *)&device_ids))
71 return i; 215 break;
72 return -1; 216 if (i > MAX_DEVICE_ID)
217 return -1;
218 return i;
73} 219}
74 220
75int 221int
76mISDN_register_device(struct mISDNdevice *dev, char *name) 222mISDN_register_device(struct mISDNdevice *dev,
223 struct device *parent, char *name)
77{ 224{
78 u_long flags;
79 int err; 225 int err;
80 226
81 dev->id = get_free_devid(); 227 dev->id = get_free_devid();
228 err = -EBUSY;
82 if (dev->id < 0) 229 if (dev->id < 0)
83 return -EBUSY; 230 goto error1;
231
232 device_initialize(&dev->dev);
84 if (name && name[0]) 233 if (name && name[0])
85 strcpy(dev->name, name); 234 dev_set_name(&dev->dev, "%s", name);
86 else 235 else
87 sprintf(dev->name, "mISDN%d", dev->id); 236 dev_set_name(&dev->dev, "mISDN%d", dev->id);
88 if (debug & DEBUG_CORE) 237 if (debug & DEBUG_CORE)
89 printk(KERN_DEBUG "mISDN_register %s %d\n", 238 printk(KERN_DEBUG "mISDN_register %s %d\n",
90 dev->name, dev->id); 239 dev_name(&dev->dev), dev->id);
91 err = create_stack(dev); 240 err = create_stack(dev);
92 if (err) 241 if (err)
93 return err; 242 goto error1;
94 write_lock_irqsave(&device_lock, flags); 243
95 list_add_tail(&dev->D.list, &devices); 244 dev->dev.class = &mISDN_class;
96 write_unlock_irqrestore(&device_lock, flags); 245 dev->dev.platform_data = dev;
246 dev->dev.parent = parent;
247 dev_set_drvdata(&dev->dev, dev);
248
249 err = device_add(&dev->dev);
250 if (err)
251 goto error3;
97 return 0; 252 return 0;
253
254error3:
255 delete_stack(dev);
256 return err;
257error1:
258 return err;
259
98} 260}
99EXPORT_SYMBOL(mISDN_register_device); 261EXPORT_SYMBOL(mISDN_register_device);
100 262
101void 263void
102mISDN_unregister_device(struct mISDNdevice *dev) { 264mISDN_unregister_device(struct mISDNdevice *dev) {
103 u_long flags;
104
105 if (debug & DEBUG_CORE) 265 if (debug & DEBUG_CORE)
106 printk(KERN_DEBUG "mISDN_unregister %s %d\n", 266 printk(KERN_DEBUG "mISDN_unregister %s %d\n",
107 dev->name, dev->id); 267 dev_name(&dev->dev), dev->id);
108 write_lock_irqsave(&device_lock, flags); 268 /* sysfs_remove_link(&dev->dev.kobj, "device"); */
109 list_del(&dev->D.list); 269 device_del(&dev->dev);
110 write_unlock_irqrestore(&device_lock, flags); 270 dev_set_drvdata(&dev->dev, NULL);
271
111 test_and_clear_bit(dev->id, (u_long *)&device_ids); 272 test_and_clear_bit(dev->id, (u_long *)&device_ids);
112 delete_stack(dev); 273 delete_stack(dev);
274 put_device(&dev->dev);
113} 275}
114EXPORT_SYMBOL(mISDN_unregister_device); 276EXPORT_SYMBOL(mISDN_unregister_device);
115 277
@@ -199,43 +361,45 @@ mISDNInit(void)
199 361
200 printk(KERN_INFO "Modular ISDN core version %d.%d.%d\n", 362 printk(KERN_INFO "Modular ISDN core version %d.%d.%d\n",
201 MISDN_MAJOR_VERSION, MISDN_MINOR_VERSION, MISDN_RELEASE); 363 MISDN_MAJOR_VERSION, MISDN_MINOR_VERSION, MISDN_RELEASE);
364 mISDN_init_clock(&debug);
202 mISDN_initstack(&debug); 365 mISDN_initstack(&debug);
366 err = class_register(&mISDN_class);
367 if (err)
368 goto error1;
203 err = mISDN_inittimer(&debug); 369 err = mISDN_inittimer(&debug);
204 if (err) 370 if (err)
205 goto error; 371 goto error2;
206 err = l1_init(&debug); 372 err = l1_init(&debug);
207 if (err) { 373 if (err)
208 mISDN_timer_cleanup(); 374 goto error3;
209 goto error;
210 }
211 err = Isdnl2_Init(&debug); 375 err = Isdnl2_Init(&debug);
212 if (err) { 376 if (err)
213 mISDN_timer_cleanup(); 377 goto error4;
214 l1_cleanup();
215 goto error;
216 }
217 err = misdn_sock_init(&debug); 378 err = misdn_sock_init(&debug);
218 if (err) { 379 if (err)
219 mISDN_timer_cleanup(); 380 goto error5;
220 l1_cleanup(); 381 return 0;
221 Isdnl2_cleanup(); 382
222 } 383error5:
223error: 384 Isdnl2_cleanup();
385error4:
386 l1_cleanup();
387error3:
388 mISDN_timer_cleanup();
389error2:
390 class_unregister(&mISDN_class);
391error1:
224 return err; 392 return err;
225} 393}
226 394
227static void mISDN_cleanup(void) 395static void mISDN_cleanup(void)
228{ 396{
229 misdn_sock_cleanup(); 397 misdn_sock_cleanup();
230 mISDN_timer_cleanup();
231 l1_cleanup();
232 Isdnl2_cleanup(); 398 Isdnl2_cleanup();
399 l1_cleanup();
400 mISDN_timer_cleanup();
401 class_unregister(&mISDN_class);
233 402
234 if (!list_empty(&devices))
235 printk(KERN_ERR "%s devices still registered\n", __func__);
236
237 if (!list_empty(&Bprotocols))
238 printk(KERN_ERR "%s Bprotocols still registered\n", __func__);
239 printk(KERN_DEBUG "mISDNcore unloaded\n"); 403 printk(KERN_DEBUG "mISDNcore unloaded\n");
240} 404}
241 405
diff --git a/drivers/isdn/mISDN/core.h b/drivers/isdn/mISDN/core.h
index 7da7233b4c1a..7ac2f81a812b 100644
--- a/drivers/isdn/mISDN/core.h
+++ b/drivers/isdn/mISDN/core.h
@@ -74,4 +74,6 @@ extern void l1_cleanup(void);
74extern int Isdnl2_Init(u_int *); 74extern int Isdnl2_Init(u_int *);
75extern void Isdnl2_cleanup(void); 75extern void Isdnl2_cleanup(void);
76 76
77extern void mISDN_init_clock(u_int *);
78
77#endif 79#endif
diff --git a/drivers/isdn/mISDN/dsp.h b/drivers/isdn/mISDN/dsp.h
index 6c3fed6b8d4f..98a33c58f091 100644
--- a/drivers/isdn/mISDN/dsp.h
+++ b/drivers/isdn/mISDN/dsp.h
@@ -15,6 +15,7 @@
15#define DEBUG_DSP_TONE 0x0020 15#define DEBUG_DSP_TONE 0x0020
16#define DEBUG_DSP_BLOWFISH 0x0040 16#define DEBUG_DSP_BLOWFISH 0x0040
17#define DEBUG_DSP_DELAY 0x0100 17#define DEBUG_DSP_DELAY 0x0100
18#define DEBUG_DSP_CLOCK 0x0200
18#define DEBUG_DSP_DTMFCOEFF 0x8000 /* heavy output */ 19#define DEBUG_DSP_DTMFCOEFF 0x8000 /* heavy output */
19 20
20/* options may be: 21/* options may be:
@@ -198,6 +199,7 @@ struct dsp {
198 /* hardware stuff */ 199 /* hardware stuff */
199 struct dsp_features features; 200 struct dsp_features features;
200 int features_rx_off; /* set if rx_off is featured */ 201 int features_rx_off; /* set if rx_off is featured */
202 int features_fill_empty; /* set if fill_empty is featured */
201 int pcm_slot_rx; /* current PCM slot (or -1) */ 203 int pcm_slot_rx; /* current PCM slot (or -1) */
202 int pcm_bank_rx; 204 int pcm_bank_rx;
203 int pcm_slot_tx; 205 int pcm_slot_tx;
diff --git a/drivers/isdn/mISDN/dsp_cmx.c b/drivers/isdn/mISDN/dsp_cmx.c
index c884511e2d49..0ac67bff303a 100644
--- a/drivers/isdn/mISDN/dsp_cmx.c
+++ b/drivers/isdn/mISDN/dsp_cmx.c
@@ -137,6 +137,7 @@
137/* #define CMX_CONF_DEBUG */ 137/* #define CMX_CONF_DEBUG */
138 138
139/*#define CMX_DEBUG * massive read/write pointer output */ 139/*#define CMX_DEBUG * massive read/write pointer output */
140/*#define CMX_DELAY_DEBUG * gives rx-buffer delay overview */
140/*#define CMX_TX_DEBUG * massive read/write on tx-buffer with content */ 141/*#define CMX_TX_DEBUG * massive read/write on tx-buffer with content */
141 142
142static inline int 143static inline int
@@ -744,11 +745,11 @@ conf_software:
744 if (dsp->pcm_slot_rx >= 0 && 745 if (dsp->pcm_slot_rx >= 0 &&
745 dsp->pcm_slot_rx < 746 dsp->pcm_slot_rx <
746 sizeof(freeslots)) 747 sizeof(freeslots))
747 freeslots[dsp->pcm_slot_tx] = 0; 748 freeslots[dsp->pcm_slot_rx] = 0;
748 if (dsp->pcm_slot_tx >= 0 && 749 if (dsp->pcm_slot_tx >= 0 &&
749 dsp->pcm_slot_tx < 750 dsp->pcm_slot_tx <
750 sizeof(freeslots)) 751 sizeof(freeslots))
751 freeslots[dsp->pcm_slot_rx] = 0; 752 freeslots[dsp->pcm_slot_tx] = 0;
752 } 753 }
753 } 754 }
754 i = 0; 755 i = 0;
@@ -836,11 +837,11 @@ conf_software:
836 if (dsp->pcm_slot_rx >= 0 && 837 if (dsp->pcm_slot_rx >= 0 &&
837 dsp->pcm_slot_rx < 838 dsp->pcm_slot_rx <
838 sizeof(freeslots)) 839 sizeof(freeslots))
839 freeslots[dsp->pcm_slot_tx] = 0; 840 freeslots[dsp->pcm_slot_rx] = 0;
840 if (dsp->pcm_slot_tx >= 0 && 841 if (dsp->pcm_slot_tx >= 0 &&
841 dsp->pcm_slot_tx < 842 dsp->pcm_slot_tx <
842 sizeof(freeslots)) 843 sizeof(freeslots))
843 freeslots[dsp->pcm_slot_rx] = 0; 844 freeslots[dsp->pcm_slot_tx] = 0;
844 } 845 }
845 } 846 }
846 i1 = 0; 847 i1 = 0;
@@ -926,10 +927,6 @@ conf_software:
926 927
927 /* for more than two members.. */ 928 /* for more than two members.. */
928 929
929 /* in case of hdlc, we change to software */
930 if (dsp->hdlc)
931 goto conf_software;
932
933 /* if all members already have the same conference */ 930 /* if all members already have the same conference */
934 if (all_conf) 931 if (all_conf)
935 return; 932 return;
@@ -940,6 +937,9 @@ conf_software:
940 if (current_conf >= 0) { 937 if (current_conf >= 0) {
941join_members: 938join_members:
942 list_for_each_entry(member, &conf->mlist, list) { 939 list_for_each_entry(member, &conf->mlist, list) {
940 /* in case of hdlc, change to software */
941 if (member->dsp->hdlc)
942 goto conf_software;
943 /* join to current conference */ 943 /* join to current conference */
944 if (member->dsp->hfc_conf == current_conf) 944 if (member->dsp->hfc_conf == current_conf)
945 continue; 945 continue;
@@ -1135,6 +1135,25 @@ dsp_cmx_conf(struct dsp *dsp, u32 conf_id)
1135 return 0; 1135 return 0;
1136} 1136}
1137 1137
1138#ifdef CMX_DELAY_DEBUG
1139int delaycount;
1140static void
1141showdelay(struct dsp *dsp, int samples, int delay)
1142{
1143 char bar[] = "--------------------------------------------------|";
1144 int sdelay;
1145
1146 delaycount += samples;
1147 if (delaycount < 8000)
1148 return;
1149 delaycount = 0;
1150
1151 sdelay = delay * 50 / (dsp_poll << 2);
1152
1153 printk(KERN_DEBUG "DELAY (%s) %3d >%s\n", dsp->name, delay,
1154 sdelay > 50 ? "..." : bar + 50 - sdelay);
1155}
1156#endif
1138 1157
1139/* 1158/*
1140 * audio data is received from card 1159 * audio data is received from card
@@ -1168,11 +1187,18 @@ dsp_cmx_receive(struct dsp *dsp, struct sk_buff *skb)
1168 dsp->rx_init = 0; 1187 dsp->rx_init = 0;
1169 if (dsp->features.unordered) { 1188 if (dsp->features.unordered) {
1170 dsp->rx_R = (hh->id & CMX_BUFF_MASK); 1189 dsp->rx_R = (hh->id & CMX_BUFF_MASK);
1171 dsp->rx_W = (dsp->rx_R + dsp->cmx_delay) 1190 if (dsp->cmx_delay)
1172 & CMX_BUFF_MASK; 1191 dsp->rx_W = (dsp->rx_R + dsp->cmx_delay)
1192 & CMX_BUFF_MASK;
1193 else
1194 dsp->rx_W = (dsp->rx_R + (dsp_poll >> 1))
1195 & CMX_BUFF_MASK;
1173 } else { 1196 } else {
1174 dsp->rx_R = 0; 1197 dsp->rx_R = 0;
1175 dsp->rx_W = dsp->cmx_delay; 1198 if (dsp->cmx_delay)
1199 dsp->rx_W = dsp->cmx_delay;
1200 else
1201 dsp->rx_W = dsp_poll >> 1;
1176 } 1202 }
1177 } 1203 }
1178 /* if frame contains time code, write directly */ 1204 /* if frame contains time code, write directly */
@@ -1185,19 +1211,25 @@ dsp_cmx_receive(struct dsp *dsp, struct sk_buff *skb)
1185 * we set our new read pointer, and write silence to buffer 1211 * we set our new read pointer, and write silence to buffer
1186 */ 1212 */
1187 if (((dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK) >= CMX_BUFF_HALF) { 1213 if (((dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK) >= CMX_BUFF_HALF) {
1188 if (dsp_debug & DEBUG_DSP_CMX) 1214 if (dsp_debug & DEBUG_DSP_CLOCK)
1189 printk(KERN_DEBUG 1215 printk(KERN_DEBUG
1190 "cmx_receive(dsp=%lx): UNDERRUN (or overrun the " 1216 "cmx_receive(dsp=%lx): UNDERRUN (or overrun the "
1191 "maximum delay), adjusting read pointer! " 1217 "maximum delay), adjusting read pointer! "
1192 "(inst %s)\n", (u_long)dsp, dsp->name); 1218 "(inst %s)\n", (u_long)dsp, dsp->name);
1193 /* flush buffer */ 1219 /* flush rx buffer and set delay to dsp_poll / 2 */
1194 if (dsp->features.unordered) { 1220 if (dsp->features.unordered) {
1195 dsp->rx_R = (hh->id & CMX_BUFF_MASK); 1221 dsp->rx_R = (hh->id & CMX_BUFF_MASK);
1196 dsp->rx_W = (dsp->rx_R + dsp->cmx_delay) 1222 if (dsp->cmx_delay)
1197 & CMX_BUFF_MASK; 1223 dsp->rx_W = (dsp->rx_R + dsp->cmx_delay)
1224 & CMX_BUFF_MASK;
1225 dsp->rx_W = (dsp->rx_R + (dsp_poll >> 1))
1226 & CMX_BUFF_MASK;
1198 } else { 1227 } else {
1199 dsp->rx_R = 0; 1228 dsp->rx_R = 0;
1200 dsp->rx_W = dsp->cmx_delay; 1229 if (dsp->cmx_delay)
1230 dsp->rx_W = dsp->cmx_delay;
1231 else
1232 dsp->rx_W = dsp_poll >> 1;
1201 } 1233 }
1202 memset(dsp->rx_buff, dsp_silence, sizeof(dsp->rx_buff)); 1234 memset(dsp->rx_buff, dsp_silence, sizeof(dsp->rx_buff));
1203 } 1235 }
@@ -1205,7 +1237,7 @@ dsp_cmx_receive(struct dsp *dsp, struct sk_buff *skb)
1205 if (dsp->cmx_delay) 1237 if (dsp->cmx_delay)
1206 if (((dsp->rx_W - dsp->rx_R) & CMX_BUFF_MASK) >= 1238 if (((dsp->rx_W - dsp->rx_R) & CMX_BUFF_MASK) >=
1207 (dsp->cmx_delay << 1)) { 1239 (dsp->cmx_delay << 1)) {
1208 if (dsp_debug & DEBUG_DSP_CMX) 1240 if (dsp_debug & DEBUG_DSP_CLOCK)
1209 printk(KERN_DEBUG 1241 printk(KERN_DEBUG
1210 "cmx_receive(dsp=%lx): OVERRUN (because " 1242 "cmx_receive(dsp=%lx): OVERRUN (because "
1211 "twice the delay is reached), adjusting " 1243 "twice the delay is reached), adjusting "
@@ -1243,6 +1275,9 @@ dsp_cmx_receive(struct dsp *dsp, struct sk_buff *skb)
1243 1275
1244 /* increase write-pointer */ 1276 /* increase write-pointer */
1245 dsp->rx_W = ((dsp->rx_W+len) & CMX_BUFF_MASK); 1277 dsp->rx_W = ((dsp->rx_W+len) & CMX_BUFF_MASK);
1278#ifdef CMX_DELAY_DEBUG
1279 showdelay(dsp, len, (dsp->rx_W-dsp->rx_R) & CMX_BUFF_MASK);
1280#endif
1246} 1281}
1247 1282
1248 1283
@@ -1360,8 +1395,12 @@ dsp_cmx_send_member(struct dsp *dsp, int len, s32 *c, int members)
1360 t = (t+1) & CMX_BUFF_MASK; 1395 t = (t+1) & CMX_BUFF_MASK;
1361 r = (r+1) & CMX_BUFF_MASK; 1396 r = (r+1) & CMX_BUFF_MASK;
1362 } 1397 }
1363 if (r != rr) 1398 if (r != rr) {
1399 if (dsp_debug & DEBUG_DSP_CLOCK)
1400 printk(KERN_DEBUG "%s: RX empty\n",
1401 __func__);
1364 memset(d, dsp_silence, (rr-r)&CMX_BUFF_MASK); 1402 memset(d, dsp_silence, (rr-r)&CMX_BUFF_MASK);
1403 }
1365 /* -> if echo is enabled */ 1404 /* -> if echo is enabled */
1366 } else { 1405 } else {
1367 /* 1406 /*
@@ -1540,13 +1579,11 @@ send_packet:
1540 schedule_work(&dsp->workq); 1579 schedule_work(&dsp->workq);
1541} 1580}
1542 1581
1543static u32 samplecount; 1582static u32 jittercount; /* counter for jitter check */;
1544struct timer_list dsp_spl_tl; 1583struct timer_list dsp_spl_tl;
1545u32 dsp_spl_jiffies; /* calculate the next time to fire */ 1584u32 dsp_spl_jiffies; /* calculate the next time to fire */
1546#ifdef UNUSED 1585static u16 dsp_count; /* last sample count */
1547static u32 dsp_start_jiffies; /* jiffies at the time, the calculation begins */ 1586static int dsp_count_valid ; /* if we have last sample count */
1548#endif /* UNUSED */
1549static struct timeval dsp_start_tv; /* time at start of calculation */
1550 1587
1551void 1588void
1552dsp_cmx_send(void *arg) 1589dsp_cmx_send(void *arg)
@@ -1560,38 +1597,32 @@ dsp_cmx_send(void *arg)
1560 int r, rr; 1597 int r, rr;
1561 int jittercheck = 0, delay, i; 1598 int jittercheck = 0, delay, i;
1562 u_long flags; 1599 u_long flags;
1563 struct timeval tv; 1600 u16 length, count;
1564 u32 elapsed;
1565 s16 length;
1566 1601
1567 /* lock */ 1602 /* lock */
1568 spin_lock_irqsave(&dsp_lock, flags); 1603 spin_lock_irqsave(&dsp_lock, flags);
1569 1604
1570 if (!dsp_start_tv.tv_sec) { 1605 if (!dsp_count_valid) {
1571 do_gettimeofday(&dsp_start_tv); 1606 dsp_count = mISDN_clock_get();
1572 length = dsp_poll; 1607 length = dsp_poll;
1608 dsp_count_valid = 1;
1573 } else { 1609 } else {
1574 do_gettimeofday(&tv); 1610 count = mISDN_clock_get();
1575 elapsed = ((tv.tv_sec - dsp_start_tv.tv_sec) * 8000) 1611 length = count - dsp_count;
1576 + ((s32)(tv.tv_usec / 125) - (dsp_start_tv.tv_usec / 125)); 1612 dsp_count = count;
1577 dsp_start_tv.tv_sec = tv.tv_sec;
1578 dsp_start_tv.tv_usec = tv.tv_usec;
1579 length = elapsed;
1580 } 1613 }
1581 if (length > MAX_POLL + 100) 1614 if (length > MAX_POLL + 100)
1582 length = MAX_POLL + 100; 1615 length = MAX_POLL + 100;
1583/* printk(KERN_DEBUG "len=%d dsp_count=0x%x.%04x dsp_poll_diff=0x%x.%04x\n", 1616 /* printk(KERN_DEBUG "len=%d dsp_count=0x%x\n", length, dsp_count); */
1584 length, dsp_count >> 16, dsp_count & 0xffff, dsp_poll_diff >> 16,
1585 dsp_poll_diff & 0xffff);
1586 */
1587 1617
1588 /* 1618 /*
1589 * check if jitter needs to be checked 1619 * check if jitter needs to be checked (this is every second)
1590 * (this is about every second = 8192 samples)
1591 */ 1620 */
1592 samplecount += length; 1621 jittercount += length;
1593 if ((samplecount & 8191) < length) 1622 if (jittercount >= 8000) {
1623 jittercount -= 8000;
1594 jittercheck = 1; 1624 jittercheck = 1;
1625 }
1595 1626
1596 /* loop all members that do not require conference mixing */ 1627 /* loop all members that do not require conference mixing */
1597 list_for_each_entry(dsp, &dsp_ilist, list) { 1628 list_for_each_entry(dsp, &dsp_ilist, list) {
@@ -1704,17 +1735,19 @@ dsp_cmx_send(void *arg)
1704 } 1735 }
1705 /* 1736 /*
1706 * remove rx_delay only if we have delay AND we 1737 * remove rx_delay only if we have delay AND we
1707 * have not preset cmx_delay 1738 * have not preset cmx_delay AND
1739 * the delay is greater dsp_poll
1708 */ 1740 */
1709 if (delay && !dsp->cmx_delay) { 1741 if (delay > dsp_poll && !dsp->cmx_delay) {
1710 if (dsp_debug & DEBUG_DSP_CMX) 1742 if (dsp_debug & DEBUG_DSP_CLOCK)
1711 printk(KERN_DEBUG 1743 printk(KERN_DEBUG
1712 "%s lowest rx_delay of %d bytes for" 1744 "%s lowest rx_delay of %d bytes for"
1713 " dsp %s are now removed.\n", 1745 " dsp %s are now removed.\n",
1714 __func__, delay, 1746 __func__, delay,
1715 dsp->name); 1747 dsp->name);
1716 r = dsp->rx_R; 1748 r = dsp->rx_R;
1717 rr = (r + delay) & CMX_BUFF_MASK; 1749 rr = (r + delay - (dsp_poll >> 1))
1750 & CMX_BUFF_MASK;
1718 /* delete rx-data */ 1751 /* delete rx-data */
1719 while (r != rr) { 1752 while (r != rr) {
1720 p[r] = dsp_silence; 1753 p[r] = dsp_silence;
@@ -1736,15 +1769,16 @@ dsp_cmx_send(void *arg)
1736 * remove delay only if we have delay AND we 1769 * remove delay only if we have delay AND we
1737 * have enabled tx_dejitter 1770 * have enabled tx_dejitter
1738 */ 1771 */
1739 if (delay && dsp->tx_dejitter) { 1772 if (delay > dsp_poll && dsp->tx_dejitter) {
1740 if (dsp_debug & DEBUG_DSP_CMX) 1773 if (dsp_debug & DEBUG_DSP_CLOCK)
1741 printk(KERN_DEBUG 1774 printk(KERN_DEBUG
1742 "%s lowest tx_delay of %d bytes for" 1775 "%s lowest tx_delay of %d bytes for"
1743 " dsp %s are now removed.\n", 1776 " dsp %s are now removed.\n",
1744 __func__, delay, 1777 __func__, delay,
1745 dsp->name); 1778 dsp->name);
1746 r = dsp->tx_R; 1779 r = dsp->tx_R;
1747 rr = (r + delay) & CMX_BUFF_MASK; 1780 rr = (r + delay - (dsp_poll >> 1))
1781 & CMX_BUFF_MASK;
1748 /* delete tx-data */ 1782 /* delete tx-data */
1749 while (r != rr) { 1783 while (r != rr) {
1750 q[r] = dsp_silence; 1784 q[r] = dsp_silence;
@@ -1797,14 +1831,16 @@ dsp_cmx_transmit(struct dsp *dsp, struct sk_buff *skb)
1797 ww = dsp->tx_R; 1831 ww = dsp->tx_R;
1798 p = dsp->tx_buff; 1832 p = dsp->tx_buff;
1799 d = skb->data; 1833 d = skb->data;
1800 space = ww-w; 1834 space = (ww - w - 1) & CMX_BUFF_MASK;
1801 if (space <= 0)
1802 space += CMX_BUFF_SIZE;
1803 /* write-pointer should not overrun nor reach read pointer */ 1835 /* write-pointer should not overrun nor reach read pointer */
1804 if (space-1 < skb->len) 1836 if (space < skb->len) {
1805 /* write to the space we have left */ 1837 /* write to the space we have left */
1806 ww = (ww - 1) & CMX_BUFF_MASK; 1838 ww = (ww - 1) & CMX_BUFF_MASK; /* end one byte prior tx_R */
1807 else 1839 if (dsp_debug & DEBUG_DSP_CLOCK)
1840 printk(KERN_DEBUG "%s: TX overflow space=%d skb->len="
1841 "%d, w=0x%04x, ww=0x%04x\n", __func__, space,
1842 skb->len, w, ww);
1843 } else
1808 /* write until all byte are copied */ 1844 /* write until all byte are copied */
1809 ww = (w + skb->len) & CMX_BUFF_MASK; 1845 ww = (w + skb->len) & CMX_BUFF_MASK;
1810 dsp->tx_W = ww; 1846 dsp->tx_W = ww;
diff --git a/drivers/isdn/mISDN/dsp_core.c b/drivers/isdn/mISDN/dsp_core.c
index 1dc21d803410..3083338716b2 100644
--- a/drivers/isdn/mISDN/dsp_core.c
+++ b/drivers/isdn/mISDN/dsp_core.c
@@ -191,6 +191,8 @@ dsp_rx_off_member(struct dsp *dsp)
191 struct mISDN_ctrl_req cq; 191 struct mISDN_ctrl_req cq;
192 int rx_off = 1; 192 int rx_off = 1;
193 193
194 memset(&cq, 0, sizeof(cq));
195
194 if (!dsp->features_rx_off) 196 if (!dsp->features_rx_off)
195 return; 197 return;
196 198
@@ -249,6 +251,32 @@ dsp_rx_off(struct dsp *dsp)
249 } 251 }
250} 252}
251 253
254/* enable "fill empty" feature */
255static void
256dsp_fill_empty(struct dsp *dsp)
257{
258 struct mISDN_ctrl_req cq;
259
260 memset(&cq, 0, sizeof(cq));
261
262 if (!dsp->ch.peer) {
263 if (dsp_debug & DEBUG_DSP_CORE)
264 printk(KERN_DEBUG "%s: no peer, no fill_empty\n",
265 __func__);
266 return;
267 }
268 cq.op = MISDN_CTRL_FILL_EMPTY;
269 cq.p1 = 1;
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
252static int 280static int
253dsp_control_req(struct dsp *dsp, struct mISDNhead *hh, struct sk_buff *skb) 281dsp_control_req(struct dsp *dsp, struct mISDNhead *hh, struct sk_buff *skb)
254{ 282{
@@ -273,8 +301,9 @@ dsp_control_req(struct dsp *dsp, struct mISDNhead *hh, struct sk_buff *skb)
273 if (dsp_debug & DEBUG_DSP_CORE) 301 if (dsp_debug & DEBUG_DSP_CORE)
274 printk(KERN_DEBUG "%s: start dtmf\n", __func__); 302 printk(KERN_DEBUG "%s: start dtmf\n", __func__);
275 if (len == sizeof(int)) { 303 if (len == sizeof(int)) {
276 printk(KERN_NOTICE "changing DTMF Threshold " 304 if (dsp_debug & DEBUG_DSP_CORE)
277 "to %d\n", *((int *)data)); 305 printk(KERN_NOTICE "changing DTMF Threshold "
306 "to %d\n", *((int *)data));
278 dsp->dtmf.treshold = (*(int *)data) * 10000; 307 dsp->dtmf.treshold = (*(int *)data) * 10000;
279 } 308 }
280 /* init goertzel */ 309 /* init goertzel */
@@ -593,8 +622,6 @@ get_features(struct mISDNchannel *ch)
593 struct dsp *dsp = container_of(ch, struct dsp, ch); 622 struct dsp *dsp = container_of(ch, struct dsp, ch);
594 struct mISDN_ctrl_req cq; 623 struct mISDN_ctrl_req cq;
595 624
596 if (dsp_options & DSP_OPT_NOHARDWARE)
597 return;
598 if (!ch->peer) { 625 if (!ch->peer) {
599 if (dsp_debug & DEBUG_DSP_CORE) 626 if (dsp_debug & DEBUG_DSP_CORE)
600 printk(KERN_DEBUG "%s: no peer, no features\n", 627 printk(KERN_DEBUG "%s: no peer, no features\n",
@@ -610,6 +637,10 @@ get_features(struct mISDNchannel *ch)
610 } 637 }
611 if (cq.op & MISDN_CTRL_RX_OFF) 638 if (cq.op & MISDN_CTRL_RX_OFF)
612 dsp->features_rx_off = 1; 639 dsp->features_rx_off = 1;
640 if (cq.op & MISDN_CTRL_FILL_EMPTY)
641 dsp->features_fill_empty = 1;
642 if (dsp_options & DSP_OPT_NOHARDWARE)
643 return;
613 if ((cq.op & MISDN_CTRL_HW_FEATURES_OP)) { 644 if ((cq.op & MISDN_CTRL_HW_FEATURES_OP)) {
614 cq.op = MISDN_CTRL_HW_FEATURES; 645 cq.op = MISDN_CTRL_HW_FEATURES;
615 *((u_long *)&cq.p1) = (u_long)&dsp->features; 646 *((u_long *)&cq.p1) = (u_long)&dsp->features;
@@ -837,11 +868,14 @@ dsp_function(struct mISDNchannel *ch, struct sk_buff *skb)
837 } 868 }
838 if (dsp->hdlc) { 869 if (dsp->hdlc) {
839 /* hdlc */ 870 /* hdlc */
840 spin_lock_irqsave(&dsp_lock, flags); 871 if (!dsp->b_active) {
841 if (dsp->b_active) { 872 ret = -EIO;
842 skb_queue_tail(&dsp->sendq, skb); 873 break;
843 schedule_work(&dsp->workq);
844 } 874 }
875 hh->prim = PH_DATA_REQ;
876 spin_lock_irqsave(&dsp_lock, flags);
877 skb_queue_tail(&dsp->sendq, skb);
878 schedule_work(&dsp->workq);
845 spin_unlock_irqrestore(&dsp_lock, flags); 879 spin_unlock_irqrestore(&dsp_lock, flags);
846 return 0; 880 return 0;
847 } 881 }
@@ -865,6 +899,9 @@ dsp_function(struct mISDNchannel *ch, struct sk_buff *skb)
865 if (dsp->dtmf.hardware || dsp->dtmf.software) 899 if (dsp->dtmf.hardware || dsp->dtmf.software)
866 dsp_dtmf_goertzel_init(dsp); 900 dsp_dtmf_goertzel_init(dsp);
867 get_features(ch); 901 get_features(ch);
902 /* enable fill_empty feature */
903 if (dsp->features_fill_empty)
904 dsp_fill_empty(dsp);
868 /* send ph_activate */ 905 /* send ph_activate */
869 hh->prim = PH_ACTIVATE_REQ; 906 hh->prim = PH_ACTIVATE_REQ;
870 if (ch->peer) 907 if (ch->peer)
@@ -1105,7 +1142,7 @@ static int dsp_init(void)
1105 } else { 1142 } else {
1106 poll = 8; 1143 poll = 8;
1107 while (poll <= MAX_POLL) { 1144 while (poll <= MAX_POLL) {
1108 tics = poll * HZ / 8000; 1145 tics = (poll * HZ) / 8000;
1109 if (tics * 8000 == poll * HZ) { 1146 if (tics * 8000 == poll * HZ) {
1110 dsp_tics = tics; 1147 dsp_tics = tics;
1111 dsp_poll = poll; 1148 dsp_poll = poll;
diff --git a/drivers/isdn/mISDN/dsp_pipeline.c b/drivers/isdn/mISDN/dsp_pipeline.c
index 83639be7f7ad..bf999bdc41c3 100644
--- a/drivers/isdn/mISDN/dsp_pipeline.c
+++ b/drivers/isdn/mISDN/dsp_pipeline.c
@@ -75,6 +75,15 @@ static struct device_attribute element_attributes[] = {
75 __ATTR(args, 0444, attr_show_args, NULL), 75 __ATTR(args, 0444, attr_show_args, NULL),
76}; 76};
77 77
78static void
79mISDN_dsp_dev_release(struct device *dev)
80{
81 struct dsp_element_entry *entry =
82 container_of(dev, struct dsp_element_entry, dev);
83 list_del(&entry->list);
84 kfree(entry);
85}
86
78int mISDN_dsp_element_register(struct mISDN_dsp_element *elem) 87int mISDN_dsp_element_register(struct mISDN_dsp_element *elem)
79{ 88{
80 struct dsp_element_entry *entry; 89 struct dsp_element_entry *entry;
@@ -83,13 +92,14 @@ int mISDN_dsp_element_register(struct mISDN_dsp_element *elem)
83 if (!elem) 92 if (!elem)
84 return -EINVAL; 93 return -EINVAL;
85 94
86 entry = kzalloc(sizeof(struct dsp_element_entry), GFP_KERNEL); 95 entry = kzalloc(sizeof(struct dsp_element_entry), GFP_ATOMIC);
87 if (!entry) 96 if (!entry)
88 return -ENOMEM; 97 return -ENOMEM;
89 98
90 entry->elem = elem; 99 entry->elem = elem;
91 100
92 entry->dev.class = elements_class; 101 entry->dev.class = elements_class;
102 entry->dev.release = mISDN_dsp_dev_release;
93 dev_set_drvdata(&entry->dev, elem); 103 dev_set_drvdata(&entry->dev, elem);
94 dev_set_name(&entry->dev, elem->name); 104 dev_set_name(&entry->dev, elem->name);
95 ret = device_register(&entry->dev); 105 ret = device_register(&entry->dev);
@@ -98,6 +108,7 @@ int mISDN_dsp_element_register(struct mISDN_dsp_element *elem)
98 __func__, elem->name); 108 __func__, elem->name);
99 goto err1; 109 goto err1;
100 } 110 }
111 list_add_tail(&entry->list, &dsp_elements);
101 112
102 for (i = 0; i < (sizeof(element_attributes) 113 for (i = 0; i < (sizeof(element_attributes)
103 / sizeof(struct device_attribute)); ++i) 114 / sizeof(struct device_attribute)); ++i)
@@ -109,14 +120,15 @@ int mISDN_dsp_element_register(struct mISDN_dsp_element *elem)
109 goto err2; 120 goto err2;
110 } 121 }
111 122
112 list_add_tail(&entry->list, &dsp_elements); 123#ifdef PIPELINE_DEBUG
113
114 printk(KERN_DEBUG "%s: %s registered\n", __func__, elem->name); 124 printk(KERN_DEBUG "%s: %s registered\n", __func__, elem->name);
125#endif
115 126
116 return 0; 127 return 0;
117 128
118err2: 129err2:
119 device_unregister(&entry->dev); 130 device_unregister(&entry->dev);
131 return ret;
120err1: 132err1:
121 kfree(entry); 133 kfree(entry);
122 return ret; 134 return ret;
@@ -132,11 +144,11 @@ void mISDN_dsp_element_unregister(struct mISDN_dsp_element *elem)
132 144
133 list_for_each_entry_safe(entry, n, &dsp_elements, list) 145 list_for_each_entry_safe(entry, n, &dsp_elements, list)
134 if (entry->elem == elem) { 146 if (entry->elem == elem) {
135 list_del(&entry->list);
136 device_unregister(&entry->dev); 147 device_unregister(&entry->dev);
137 kfree(entry); 148#ifdef PIPELINE_DEBUG
138 printk(KERN_DEBUG "%s: %s unregistered\n", 149 printk(KERN_DEBUG "%s: %s unregistered\n",
139 __func__, elem->name); 150 __func__, elem->name);
151#endif
140 return; 152 return;
141 } 153 }
142 printk(KERN_ERR "%s: element %s not in list.\n", __func__, elem->name); 154 printk(KERN_ERR "%s: element %s not in list.\n", __func__, elem->name);
@@ -173,7 +185,9 @@ void dsp_pipeline_module_exit(void)
173 kfree(entry); 185 kfree(entry);
174 } 186 }
175 187
188#ifdef PIPELINE_DEBUG
176 printk(KERN_DEBUG "%s: dsp pipeline module exited\n", __func__); 189 printk(KERN_DEBUG "%s: dsp pipeline module exited\n", __func__);
190#endif
177} 191}
178 192
179int dsp_pipeline_init(struct dsp_pipeline *pipeline) 193int dsp_pipeline_init(struct dsp_pipeline *pipeline)
@@ -239,7 +253,7 @@ int dsp_pipeline_build(struct dsp_pipeline *pipeline, const char *cfg)
239 if (!len) 253 if (!len)
240 return 0; 254 return 0;
241 255
242 dup = kmalloc(len + 1, GFP_KERNEL); 256 dup = kmalloc(len + 1, GFP_ATOMIC);
243 if (!dup) 257 if (!dup)
244 return 0; 258 return 0;
245 strcpy(dup, cfg); 259 strcpy(dup, cfg);
@@ -256,9 +270,9 @@ int dsp_pipeline_build(struct dsp_pipeline *pipeline, const char *cfg)
256 elem = entry->elem; 270 elem = entry->elem;
257 271
258 pipeline_entry = kmalloc(sizeof(struct 272 pipeline_entry = kmalloc(sizeof(struct
259 dsp_pipeline_entry), GFP_KERNEL); 273 dsp_pipeline_entry), GFP_ATOMIC);
260 if (!pipeline_entry) { 274 if (!pipeline_entry) {
261 printk(KERN_DEBUG "%s: failed to add " 275 printk(KERN_ERR "%s: failed to add "
262 "entry to pipeline: %s (out of " 276 "entry to pipeline: %s (out of "
263 "memory)\n", __func__, elem->name); 277 "memory)\n", __func__, elem->name);
264 incomplete = 1; 278 incomplete = 1;
@@ -286,7 +300,7 @@ int dsp_pipeline_build(struct dsp_pipeline *pipeline, const char *cfg)
286 args : ""); 300 args : "");
287#endif 301#endif
288 } else { 302 } else {
289 printk(KERN_DEBUG "%s: failed " 303 printk(KERN_ERR "%s: failed "
290 "to add entry to pipeline: " 304 "to add entry to pipeline: "
291 "%s (new() returned NULL)\n", 305 "%s (new() returned NULL)\n",
292 __func__, elem->name); 306 __func__, elem->name);
@@ -301,7 +315,7 @@ int dsp_pipeline_build(struct dsp_pipeline *pipeline, const char *cfg)
301 if (found) 315 if (found)
302 found = 0; 316 found = 0;
303 else { 317 else {
304 printk(KERN_DEBUG "%s: element not found, skipping: " 318 printk(KERN_ERR "%s: element not found, skipping: "
305 "%s\n", __func__, name); 319 "%s\n", __func__, name);
306 incomplete = 1; 320 incomplete = 1;
307 } 321 }
diff --git a/drivers/isdn/mISDN/hwchannel.c b/drivers/isdn/mISDN/hwchannel.c
index 2596fba4e614..ab1168a110ae 100644
--- a/drivers/isdn/mISDN/hwchannel.c
+++ b/drivers/isdn/mISDN/hwchannel.c
@@ -50,9 +50,6 @@ bchannel_bh(struct work_struct *ws)
50 50
51 if (test_and_clear_bit(FLG_RECVQUEUE, &bch->Flags)) { 51 if (test_and_clear_bit(FLG_RECVQUEUE, &bch->Flags)) {
52 while ((skb = skb_dequeue(&bch->rqueue))) { 52 while ((skb = skb_dequeue(&bch->rqueue))) {
53 if (bch->rcount >= 64)
54 printk(KERN_WARNING "B-channel %p receive "
55 "queue if full, but empties...\n", bch);
56 bch->rcount--; 53 bch->rcount--;
57 if (likely(bch->ch.peer)) { 54 if (likely(bch->ch.peer)) {
58 err = bch->ch.recv(bch->ch.peer, skb); 55 err = bch->ch.recv(bch->ch.peer, skb);
@@ -169,6 +166,25 @@ recv_Dchannel(struct dchannel *dch)
169EXPORT_SYMBOL(recv_Dchannel); 166EXPORT_SYMBOL(recv_Dchannel);
170 167
171void 168void
169recv_Echannel(struct dchannel *ech, struct dchannel *dch)
170{
171 struct mISDNhead *hh;
172
173 if (ech->rx_skb->len < 2) { /* at least 2 for sapi / tei */
174 dev_kfree_skb(ech->rx_skb);
175 ech->rx_skb = NULL;
176 return;
177 }
178 hh = mISDN_HEAD_P(ech->rx_skb);
179 hh->prim = PH_DATA_E_IND;
180 hh->id = get_sapi_tei(ech->rx_skb->data);
181 skb_queue_tail(&dch->rqueue, ech->rx_skb);
182 ech->rx_skb = NULL;
183 schedule_event(dch, FLG_RECVQUEUE);
184}
185EXPORT_SYMBOL(recv_Echannel);
186
187void
172recv_Bchannel(struct bchannel *bch) 188recv_Bchannel(struct bchannel *bch)
173{ 189{
174 struct mISDNhead *hh; 190 struct mISDNhead *hh;
@@ -177,8 +193,10 @@ recv_Bchannel(struct bchannel *bch)
177 hh->prim = PH_DATA_IND; 193 hh->prim = PH_DATA_IND;
178 hh->id = MISDN_ID_ANY; 194 hh->id = MISDN_ID_ANY;
179 if (bch->rcount >= 64) { 195 if (bch->rcount >= 64) {
180 dev_kfree_skb(bch->rx_skb); 196 printk(KERN_WARNING "B-channel %p receive queue overflow, "
181 bch->rx_skb = NULL; 197 "fushing!\n", bch);
198 skb_queue_purge(&bch->rqueue);
199 bch->rcount = 0;
182 return; 200 return;
183 } 201 }
184 bch->rcount++; 202 bch->rcount++;
@@ -200,8 +218,10 @@ void
200recv_Bchannel_skb(struct bchannel *bch, struct sk_buff *skb) 218recv_Bchannel_skb(struct bchannel *bch, struct sk_buff *skb)
201{ 219{
202 if (bch->rcount >= 64) { 220 if (bch->rcount >= 64) {
203 dev_kfree_skb(skb); 221 printk(KERN_WARNING "B-channel %p receive queue overflow, "
204 return; 222 "fushing!\n", bch);
223 skb_queue_purge(&bch->rqueue);
224 bch->rcount = 0;
205 } 225 }
206 bch->rcount++; 226 bch->rcount++;
207 skb_queue_tail(&bch->rqueue, skb); 227 skb_queue_tail(&bch->rqueue, skb);
@@ -245,8 +265,12 @@ confirm_Bsend(struct bchannel *bch)
245{ 265{
246 struct sk_buff *skb; 266 struct sk_buff *skb;
247 267
248 if (bch->rcount >= 64) 268 if (bch->rcount >= 64) {
249 return; 269 printk(KERN_WARNING "B-channel %p receive queue overflow, "
270 "fushing!\n", bch);
271 skb_queue_purge(&bch->rqueue);
272 bch->rcount = 0;
273 }
250 skb = _alloc_mISDN_skb(PH_DATA_CNF, mISDN_HEAD_ID(bch->tx_skb), 274 skb = _alloc_mISDN_skb(PH_DATA_CNF, mISDN_HEAD_ID(bch->tx_skb),
251 0, NULL, GFP_ATOMIC); 275 0, NULL, GFP_ATOMIC);
252 if (!skb) { 276 if (!skb) {
diff --git a/drivers/isdn/mISDN/l1oip_core.c b/drivers/isdn/mISDN/l1oip_core.c
index 0884dd6892f8..abe574989572 100644
--- a/drivers/isdn/mISDN/l1oip_core.c
+++ b/drivers/isdn/mISDN/l1oip_core.c
@@ -777,6 +777,8 @@ fail:
777static void 777static void
778l1oip_socket_close(struct l1oip *hc) 778l1oip_socket_close(struct l1oip *hc)
779{ 779{
780 struct dchannel *dch = hc->chan[hc->d_idx].dch;
781
780 /* kill thread */ 782 /* kill thread */
781 if (hc->socket_thread) { 783 if (hc->socket_thread) {
782 if (debug & DEBUG_L1OIP_SOCKET) 784 if (debug & DEBUG_L1OIP_SOCKET)
@@ -785,6 +787,16 @@ l1oip_socket_close(struct l1oip *hc)
785 send_sig(SIGTERM, hc->socket_thread, 0); 787 send_sig(SIGTERM, hc->socket_thread, 0);
786 wait_for_completion(&hc->socket_complete); 788 wait_for_completion(&hc->socket_complete);
787 } 789 }
790
791 /* if active, we send up a PH_DEACTIVATE and deactivate */
792 if (test_bit(FLG_ACTIVE, &dch->Flags)) {
793 if (debug & (DEBUG_L1OIP_MSG|DEBUG_L1OIP_SOCKET))
794 printk(KERN_DEBUG "%s: interface become deactivated "
795 "due to timeout\n", __func__);
796 test_and_clear_bit(FLG_ACTIVE, &dch->Flags);
797 _queue_data(&dch->dev.D, PH_DEACTIVATE_IND, MISDN_ID_ANY, 0,
798 NULL, GFP_ATOMIC);
799 }
788} 800}
789 801
790static int 802static int
@@ -944,7 +956,8 @@ channel_dctrl(struct dchannel *dch, struct mISDN_ctrl_req *cq)
944 956
945 switch (cq->op) { 957 switch (cq->op) {
946 case MISDN_CTRL_GETOP: 958 case MISDN_CTRL_GETOP:
947 cq->op = MISDN_CTRL_SETPEER | MISDN_CTRL_UNSETPEER; 959 cq->op = MISDN_CTRL_SETPEER | MISDN_CTRL_UNSETPEER
960 | MISDN_CTRL_GETPEER;
948 break; 961 break;
949 case MISDN_CTRL_SETPEER: 962 case MISDN_CTRL_SETPEER:
950 hc->remoteip = (u32)cq->p1; 963 hc->remoteip = (u32)cq->p1;
@@ -964,6 +977,13 @@ channel_dctrl(struct dchannel *dch, struct mISDN_ctrl_req *cq)
964 hc->remoteip = 0; 977 hc->remoteip = 0;
965 l1oip_socket_open(hc); 978 l1oip_socket_open(hc);
966 break; 979 break;
980 case MISDN_CTRL_GETPEER:
981 if (debug & DEBUG_L1OIP_SOCKET)
982 printk(KERN_DEBUG "%s: getting ip address.\n",
983 __func__);
984 cq->p1 = hc->remoteip;
985 cq->p2 = hc->remoteport | (hc->localport << 16);
986 break;
967 default: 987 default:
968 printk(KERN_WARNING "%s: unknown Op %x\n", 988 printk(KERN_WARNING "%s: unknown Op %x\n",
969 __func__, cq->op); 989 __func__, cq->op);
@@ -1413,7 +1433,8 @@ init_card(struct l1oip *hc, int pri, int bundle)
1413 hc->chan[i + ch].bch = bch; 1433 hc->chan[i + ch].bch = bch;
1414 set_channelmap(bch->nr, dch->dev.channelmap); 1434 set_channelmap(bch->nr, dch->dev.channelmap);
1415 } 1435 }
1416 ret = mISDN_register_device(&dch->dev, hc->name); 1436 /* TODO: create a parent device for this driver */
1437 ret = mISDN_register_device(&dch->dev, NULL, hc->name);
1417 if (ret) 1438 if (ret)
1418 return ret; 1439 return ret;
1419 hc->registered = 1; 1440 hc->registered = 1;
diff --git a/drivers/isdn/mISDN/layer1.c b/drivers/isdn/mISDN/layer1.c
index b73e952d12cf..e826eeb1ecec 100644
--- a/drivers/isdn/mISDN/layer1.c
+++ b/drivers/isdn/mISDN/layer1.c
@@ -101,7 +101,7 @@ l1m_debug(struct FsmInst *fi, char *fmt, ...)
101 va_list va; 101 va_list va;
102 102
103 va_start(va, fmt); 103 va_start(va, fmt);
104 printk(KERN_DEBUG "%s: ", l1->dch->dev.name); 104 printk(KERN_DEBUG "%s: ", dev_name(&l1->dch->dev.dev));
105 vprintk(fmt, va); 105 vprintk(fmt, va);
106 printk("\n"); 106 printk("\n");
107 va_end(va); 107 va_end(va);
diff --git a/drivers/isdn/mISDN/socket.c b/drivers/isdn/mISDN/socket.c
index 37a2de18cfd0..508945d1b9c1 100644
--- a/drivers/isdn/mISDN/socket.c
+++ b/drivers/isdn/mISDN/socket.c
@@ -381,7 +381,7 @@ data_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
381 memcpy(di.channelmap, dev->channelmap, 381 memcpy(di.channelmap, dev->channelmap,
382 sizeof(di.channelmap)); 382 sizeof(di.channelmap));
383 di.nrbchan = dev->nrbchan; 383 di.nrbchan = dev->nrbchan;
384 strcpy(di.name, dev->name); 384 strcpy(di.name, dev_name(&dev->dev));
385 if (copy_to_user((void __user *)arg, &di, sizeof(di))) 385 if (copy_to_user((void __user *)arg, &di, sizeof(di)))
386 err = -EFAULT; 386 err = -EFAULT;
387 } else 387 } else
@@ -460,6 +460,8 @@ data_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
460{ 460{
461 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr; 461 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
462 struct sock *sk = sock->sk; 462 struct sock *sk = sock->sk;
463 struct hlist_node *node;
464 struct sock *csk;
463 int err = 0; 465 int err = 0;
464 466
465 if (*debug & DEBUG_SOCKET) 467 if (*debug & DEBUG_SOCKET)
@@ -480,6 +482,26 @@ data_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
480 err = -ENODEV; 482 err = -ENODEV;
481 goto done; 483 goto done;
482 } 484 }
485
486 if (sk->sk_protocol < ISDN_P_B_START) {
487 read_lock_bh(&data_sockets.lock);
488 sk_for_each(csk, node, &data_sockets.head) {
489 if (sk == csk)
490 continue;
491 if (_pms(csk)->dev != _pms(sk)->dev)
492 continue;
493 if (csk->sk_protocol >= ISDN_P_B_START)
494 continue;
495 if (IS_ISDN_P_TE(csk->sk_protocol)
496 == IS_ISDN_P_TE(sk->sk_protocol))
497 continue;
498 read_unlock_bh(&data_sockets.lock);
499 err = -EBUSY;
500 goto done;
501 }
502 read_unlock_bh(&data_sockets.lock);
503 }
504
483 _pms(sk)->ch.send = mISDN_send; 505 _pms(sk)->ch.send = mISDN_send;
484 _pms(sk)->ch.ctrl = mISDN_ctrl; 506 _pms(sk)->ch.ctrl = mISDN_ctrl;
485 507
@@ -639,12 +661,27 @@ base_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
639 memcpy(di.channelmap, dev->channelmap, 661 memcpy(di.channelmap, dev->channelmap,
640 sizeof(di.channelmap)); 662 sizeof(di.channelmap));
641 di.nrbchan = dev->nrbchan; 663 di.nrbchan = dev->nrbchan;
642 strcpy(di.name, dev->name); 664 strcpy(di.name, dev_name(&dev->dev));
643 if (copy_to_user((void __user *)arg, &di, sizeof(di))) 665 if (copy_to_user((void __user *)arg, &di, sizeof(di)))
644 err = -EFAULT; 666 err = -EFAULT;
645 } else 667 } else
646 err = -ENODEV; 668 err = -ENODEV;
647 break; 669 break;
670 case IMSETDEVNAME:
671 {
672 struct mISDN_devrename dn;
673 if (copy_from_user(&dn, (void __user *)arg,
674 sizeof(dn))) {
675 err = -EFAULT;
676 break;
677 }
678 dev = get_mdevice(dn.id);
679 if (dev)
680 err = device_rename(&dev->dev, dn.name);
681 else
682 err = -ENODEV;
683 }
684 break;
648 default: 685 default:
649 err = -EINVAL; 686 err = -EINVAL;
650 } 687 }
diff --git a/drivers/isdn/mISDN/stack.c b/drivers/isdn/mISDN/stack.c
index d55b14ae4e99..e2f45019ebf0 100644
--- a/drivers/isdn/mISDN/stack.c
+++ b/drivers/isdn/mISDN/stack.c
@@ -172,7 +172,8 @@ send_msg_to_layer(struct mISDNstack *st, struct sk_buff *skb)
172 else 172 else
173 printk(KERN_WARNING 173 printk(KERN_WARNING
174 "%s: dev(%s) prim(%x) id(%x) no channel\n", 174 "%s: dev(%s) prim(%x) id(%x) no channel\n",
175 __func__, st->dev->name, hh->prim, hh->id); 175 __func__, dev_name(&st->dev->dev), hh->prim,
176 hh->id);
176 } else if (lm == 0x8) { 177 } else if (lm == 0x8) {
177 WARN_ON(lm == 0x8); 178 WARN_ON(lm == 0x8);
178 ch = get_channel4id(st, hh->id); 179 ch = get_channel4id(st, hh->id);
@@ -181,11 +182,12 @@ send_msg_to_layer(struct mISDNstack *st, struct sk_buff *skb)
181 else 182 else
182 printk(KERN_WARNING 183 printk(KERN_WARNING
183 "%s: dev(%s) prim(%x) id(%x) no channel\n", 184 "%s: dev(%s) prim(%x) id(%x) no channel\n",
184 __func__, st->dev->name, hh->prim, hh->id); 185 __func__, dev_name(&st->dev->dev), hh->prim,
186 hh->id);
185 } else { 187 } else {
186 /* broadcast not handled yet */ 188 /* broadcast not handled yet */
187 printk(KERN_WARNING "%s: dev(%s) prim %x not delivered\n", 189 printk(KERN_WARNING "%s: dev(%s) prim %x not delivered\n",
188 __func__, st->dev->name, hh->prim); 190 __func__, dev_name(&st->dev->dev), hh->prim);
189 } 191 }
190 return -ESRCH; 192 return -ESRCH;
191} 193}
@@ -209,7 +211,8 @@ mISDNStackd(void *data)
209 unlock_kernel(); 211 unlock_kernel();
210#endif 212#endif
211 if (*debug & DEBUG_MSG_THREAD) 213 if (*debug & DEBUG_MSG_THREAD)
212 printk(KERN_DEBUG "mISDNStackd %s started\n", st->dev->name); 214 printk(KERN_DEBUG "mISDNStackd %s started\n",
215 dev_name(&st->dev->dev));
213 216
214 if (st->notify != NULL) { 217 if (st->notify != NULL) {
215 complete(st->notify); 218 complete(st->notify);
@@ -245,7 +248,7 @@ mISDNStackd(void *data)
245 printk(KERN_DEBUG 248 printk(KERN_DEBUG
246 "%s: %s prim(%x) id(%x) " 249 "%s: %s prim(%x) id(%x) "
247 "send call(%d)\n", 250 "send call(%d)\n",
248 __func__, st->dev->name, 251 __func__, dev_name(&st->dev->dev),
249 mISDN_HEAD_PRIM(skb), 252 mISDN_HEAD_PRIM(skb),
250 mISDN_HEAD_ID(skb), err); 253 mISDN_HEAD_ID(skb), err);
251 dev_kfree_skb(skb); 254 dev_kfree_skb(skb);
@@ -288,7 +291,7 @@ mISDNStackd(void *data)
288 mISDN_STACK_ACTION_MASK)); 291 mISDN_STACK_ACTION_MASK));
289 if (*debug & DEBUG_MSG_THREAD) 292 if (*debug & DEBUG_MSG_THREAD)
290 printk(KERN_DEBUG "%s: %s wake status %08lx\n", 293 printk(KERN_DEBUG "%s: %s wake status %08lx\n",
291 __func__, st->dev->name, st->status); 294 __func__, dev_name(&st->dev->dev), st->status);
292 test_and_set_bit(mISDN_STACK_ACTIVE, &st->status); 295 test_and_set_bit(mISDN_STACK_ACTIVE, &st->status);
293 296
294 test_and_clear_bit(mISDN_STACK_WAKEUP, &st->status); 297 test_and_clear_bit(mISDN_STACK_WAKEUP, &st->status);
@@ -303,15 +306,16 @@ mISDNStackd(void *data)
303#ifdef MISDN_MSG_STATS 306#ifdef MISDN_MSG_STATS
304 printk(KERN_DEBUG "mISDNStackd daemon for %s proceed %d " 307 printk(KERN_DEBUG "mISDNStackd daemon for %s proceed %d "
305 "msg %d sleep %d stopped\n", 308 "msg %d sleep %d stopped\n",
306 st->dev->name, st->msg_cnt, st->sleep_cnt, st->stopped_cnt); 309 dev_name(&st->dev->dev), st->msg_cnt, st->sleep_cnt,
310 st->stopped_cnt);
307 printk(KERN_DEBUG 311 printk(KERN_DEBUG
308 "mISDNStackd daemon for %s utime(%ld) stime(%ld)\n", 312 "mISDNStackd daemon for %s utime(%ld) stime(%ld)\n",
309 st->dev->name, st->thread->utime, st->thread->stime); 313 dev_name(&st->dev->dev), st->thread->utime, st->thread->stime);
310 printk(KERN_DEBUG 314 printk(KERN_DEBUG
311 "mISDNStackd daemon for %s nvcsw(%ld) nivcsw(%ld)\n", 315 "mISDNStackd daemon for %s nvcsw(%ld) nivcsw(%ld)\n",
312 st->dev->name, st->thread->nvcsw, st->thread->nivcsw); 316 dev_name(&st->dev->dev), st->thread->nvcsw, st->thread->nivcsw);
313 printk(KERN_DEBUG "mISDNStackd daemon for %s killed now\n", 317 printk(KERN_DEBUG "mISDNStackd daemon for %s killed now\n",
314 st->dev->name); 318 dev_name(&st->dev->dev));
315#endif 319#endif
316 test_and_set_bit(mISDN_STACK_KILLED, &st->status); 320 test_and_set_bit(mISDN_STACK_KILLED, &st->status);
317 test_and_clear_bit(mISDN_STACK_RUNNING, &st->status); 321 test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
@@ -401,15 +405,16 @@ create_stack(struct mISDNdevice *dev)
401 newst->own.send = mISDN_queue_message; 405 newst->own.send = mISDN_queue_message;
402 newst->own.recv = mISDN_queue_message; 406 newst->own.recv = mISDN_queue_message;
403 if (*debug & DEBUG_CORE_FUNC) 407 if (*debug & DEBUG_CORE_FUNC)
404 printk(KERN_DEBUG "%s: st(%s)\n", __func__, newst->dev->name); 408 printk(KERN_DEBUG "%s: st(%s)\n", __func__,
409 dev_name(&newst->dev->dev));
405 newst->notify = &done; 410 newst->notify = &done;
406 newst->thread = kthread_run(mISDNStackd, (void *)newst, "mISDN_%s", 411 newst->thread = kthread_run(mISDNStackd, (void *)newst, "mISDN_%s",
407 newst->dev->name); 412 dev_name(&newst->dev->dev));
408 if (IS_ERR(newst->thread)) { 413 if (IS_ERR(newst->thread)) {
409 err = PTR_ERR(newst->thread); 414 err = PTR_ERR(newst->thread);
410 printk(KERN_ERR 415 printk(KERN_ERR
411 "mISDN:cannot create kernel thread for %s (%d)\n", 416 "mISDN:cannot create kernel thread for %s (%d)\n",
412 newst->dev->name, err); 417 dev_name(&newst->dev->dev), err);
413 delete_teimanager(dev->teimgr); 418 delete_teimanager(dev->teimgr);
414 kfree(newst); 419 kfree(newst);
415 } else 420 } else
@@ -428,29 +433,21 @@ connect_layer1(struct mISDNdevice *dev, struct mISDNchannel *ch,
428 433
429 if (*debug & DEBUG_CORE_FUNC) 434 if (*debug & DEBUG_CORE_FUNC)
430 printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n", 435 printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
431 __func__, dev->name, protocol, adr->dev, adr->channel, 436 __func__, dev_name(&dev->dev), protocol, adr->dev,
432 adr->sapi, adr->tei); 437 adr->channel, adr->sapi, adr->tei);
433 switch (protocol) { 438 switch (protocol) {
434 case ISDN_P_NT_S0: 439 case ISDN_P_NT_S0:
435 case ISDN_P_NT_E1: 440 case ISDN_P_NT_E1:
436 case ISDN_P_TE_S0: 441 case ISDN_P_TE_S0:
437 case ISDN_P_TE_E1: 442 case ISDN_P_TE_E1:
438#ifdef PROTOCOL_CHECK
439 /* this should be enhanced */
440 if (!list_empty(&dev->D.st->layer2)
441 && dev->D.protocol != protocol)
442 return -EBUSY;
443 if (!hlist_empty(&dev->D.st->l1sock.head)
444 && dev->D.protocol != protocol)
445 return -EBUSY;
446#endif
447 ch->recv = mISDN_queue_message; 443 ch->recv = mISDN_queue_message;
448 ch->peer = &dev->D.st->own; 444 ch->peer = &dev->D.st->own;
449 ch->st = dev->D.st; 445 ch->st = dev->D.st;
450 rq.protocol = protocol; 446 rq.protocol = protocol;
451 rq.adr.channel = 0; 447 rq.adr.channel = adr->channel;
452 err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq); 448 err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
453 printk(KERN_DEBUG "%s: ret 1 %d\n", __func__, err); 449 printk(KERN_DEBUG "%s: ret %d (dev %d)\n", __func__, err,
450 dev->id);
454 if (err) 451 if (err)
455 return err; 452 return err;
456 write_lock_bh(&dev->D.st->l1sock.lock); 453 write_lock_bh(&dev->D.st->l1sock.lock);
@@ -473,7 +470,7 @@ connect_Bstack(struct mISDNdevice *dev, struct mISDNchannel *ch,
473 470
474 if (*debug & DEBUG_CORE_FUNC) 471 if (*debug & DEBUG_CORE_FUNC)
475 printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n", 472 printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
476 __func__, dev->name, protocol, 473 __func__, dev_name(&dev->dev), protocol,
477 adr->dev, adr->channel, adr->sapi, 474 adr->dev, adr->channel, adr->sapi,
478 adr->tei); 475 adr->tei);
479 ch->st = dev->D.st; 476 ch->st = dev->D.st;
@@ -529,7 +526,7 @@ create_l2entity(struct mISDNdevice *dev, struct mISDNchannel *ch,
529 526
530 if (*debug & DEBUG_CORE_FUNC) 527 if (*debug & DEBUG_CORE_FUNC)
531 printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n", 528 printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
532 __func__, dev->name, protocol, 529 __func__, dev_name(&dev->dev), protocol,
533 adr->dev, adr->channel, adr->sapi, 530 adr->dev, adr->channel, adr->sapi,
534 adr->tei); 531 adr->tei);
535 rq.protocol = ISDN_P_TE_S0; 532 rq.protocol = ISDN_P_TE_S0;
@@ -541,15 +538,6 @@ create_l2entity(struct mISDNdevice *dev, struct mISDNchannel *ch,
541 if (dev->Dprotocols & (1 << ISDN_P_NT_E1)) 538 if (dev->Dprotocols & (1 << ISDN_P_NT_E1))
542 rq.protocol = ISDN_P_NT_E1; 539 rq.protocol = ISDN_P_NT_E1;
543 case ISDN_P_LAPD_TE: 540 case ISDN_P_LAPD_TE:
544#ifdef PROTOCOL_CHECK
545 /* this should be enhanced */
546 if (!list_empty(&dev->D.st->layer2)
547 && dev->D.protocol != protocol)
548 return -EBUSY;
549 if (!hlist_empty(&dev->D.st->l1sock.head)
550 && dev->D.protocol != protocol)
551 return -EBUSY;
552#endif
553 ch->recv = mISDN_queue_message; 541 ch->recv = mISDN_queue_message;
554 ch->peer = &dev->D.st->own; 542 ch->peer = &dev->D.st->own;
555 ch->st = dev->D.st; 543 ch->st = dev->D.st;
@@ -590,7 +578,7 @@ delete_channel(struct mISDNchannel *ch)
590 } 578 }
591 if (*debug & DEBUG_CORE_FUNC) 579 if (*debug & DEBUG_CORE_FUNC)
592 printk(KERN_DEBUG "%s: st(%s) protocol(%x)\n", __func__, 580 printk(KERN_DEBUG "%s: st(%s) protocol(%x)\n", __func__,
593 ch->st->dev->name, ch->protocol); 581 dev_name(&ch->st->dev->dev), ch->protocol);
594 if (ch->protocol >= ISDN_P_B_START) { 582 if (ch->protocol >= ISDN_P_B_START) {
595 if (ch->peer) { 583 if (ch->peer) {
596 ch->peer->ctrl(ch->peer, CLOSE_CHANNEL, NULL); 584 ch->peer->ctrl(ch->peer, CLOSE_CHANNEL, NULL);
@@ -643,7 +631,7 @@ delete_stack(struct mISDNdevice *dev)
643 631
644 if (*debug & DEBUG_CORE_FUNC) 632 if (*debug & DEBUG_CORE_FUNC)
645 printk(KERN_DEBUG "%s: st(%s)\n", __func__, 633 printk(KERN_DEBUG "%s: st(%s)\n", __func__,
646 st->dev->name); 634 dev_name(&st->dev->dev));
647 if (dev->teimgr) 635 if (dev->teimgr)
648 delete_teimanager(dev->teimgr); 636 delete_teimanager(dev->teimgr);
649 if (st->thread) { 637 if (st->thread) {
diff --git a/drivers/isdn/mISDN/tei.c b/drivers/isdn/mISDN/tei.c
index 5c43d19e7c11..b452dead8fd0 100644
--- a/drivers/isdn/mISDN/tei.c
+++ b/drivers/isdn/mISDN/tei.c
@@ -968,9 +968,9 @@ create_teimgr(struct manager *mgr, struct channel_req *crq)
968 968
969 if (*debug & DEBUG_L2_TEI) 969 if (*debug & DEBUG_L2_TEI)
970 printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n", 970 printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
971 __func__, mgr->ch.st->dev->name, crq->protocol, 971 __func__, dev_name(&mgr->ch.st->dev->dev),
972 crq->adr.dev, crq->adr.channel, crq->adr.sapi, 972 crq->protocol, crq->adr.dev, crq->adr.channel,
973 crq->adr.tei); 973 crq->adr.sapi, crq->adr.tei);
974 if (crq->adr.sapi != 0) /* not supported yet */ 974 if (crq->adr.sapi != 0) /* not supported yet */
975 return -EINVAL; 975 return -EINVAL;
976 if (crq->adr.tei > GROUP_TEI) 976 if (crq->adr.tei > GROUP_TEI)
diff --git a/include/linux/mISDNhw.h b/include/linux/mISDNhw.h
index e794dfb87504..97ffdc1d3442 100644
--- a/include/linux/mISDNhw.h
+++ b/include/linux/mISDNhw.h
@@ -57,20 +57,21 @@
57#define FLG_L2DATA 14 /* channel use L2 DATA primitivs */ 57#define FLG_L2DATA 14 /* channel use L2 DATA primitivs */
58#define FLG_ORIGIN 15 /* channel is on origin site */ 58#define FLG_ORIGIN 15 /* channel is on origin site */
59/* channel specific stuff */ 59/* channel specific stuff */
60#define FLG_FILLEMPTY 16 /* fill fifo on first frame (empty) */
60/* arcofi specific */ 61/* arcofi specific */
61#define FLG_ARCOFI_TIMER 16 62#define FLG_ARCOFI_TIMER 17
62#define FLG_ARCOFI_ERROR 17 63#define FLG_ARCOFI_ERROR 18
63/* isar specific */ 64/* isar specific */
64#define FLG_INITIALIZED 16 65#define FLG_INITIALIZED 17
65#define FLG_DLEETX 17 66#define FLG_DLEETX 18
66#define FLG_LASTDLE 18 67#define FLG_LASTDLE 19
67#define FLG_FIRST 19 68#define FLG_FIRST 20
68#define FLG_LASTDATA 20 69#define FLG_LASTDATA 21
69#define FLG_NMD_DATA 21 70#define FLG_NMD_DATA 22
70#define FLG_FTI_RUN 22 71#define FLG_FTI_RUN 23
71#define FLG_LL_OK 23 72#define FLG_LL_OK 24
72#define FLG_LL_CONN 24 73#define FLG_LL_CONN 25
73#define FLG_DTMFSEND 25 74#define FLG_DTMFSEND 26
74 75
75/* workq events */ 76/* workq events */
76#define FLG_RECVQUEUE 30 77#define FLG_RECVQUEUE 30
@@ -183,6 +184,7 @@ extern void queue_ch_frame(struct mISDNchannel *, u_int,
183extern int dchannel_senddata(struct dchannel *, struct sk_buff *); 184extern int dchannel_senddata(struct dchannel *, struct sk_buff *);
184extern int bchannel_senddata(struct bchannel *, struct sk_buff *); 185extern int bchannel_senddata(struct bchannel *, struct sk_buff *);
185extern void recv_Dchannel(struct dchannel *); 186extern void recv_Dchannel(struct dchannel *);
187extern void recv_Echannel(struct dchannel *, struct dchannel *);
186extern void recv_Bchannel(struct bchannel *); 188extern void recv_Bchannel(struct bchannel *);
187extern void recv_Dchannel_skb(struct dchannel *, struct sk_buff *); 189extern void recv_Dchannel_skb(struct dchannel *, struct sk_buff *);
188extern void recv_Bchannel_skb(struct bchannel *, struct sk_buff *); 190extern void recv_Bchannel_skb(struct bchannel *, struct sk_buff *);
diff --git a/include/linux/mISDNif.h b/include/linux/mISDNif.h
index 8f2d60da04e7..557477ac3d5b 100644
--- a/include/linux/mISDNif.h
+++ b/include/linux/mISDNif.h
@@ -36,8 +36,8 @@
36 * - should be incremented on every checkin 36 * - should be incremented on every checkin
37 */ 37 */
38#define MISDN_MAJOR_VERSION 1 38#define MISDN_MAJOR_VERSION 1
39#define MISDN_MINOR_VERSION 0 39#define MISDN_MINOR_VERSION 1
40#define MISDN_RELEASE 19 40#define MISDN_RELEASE 20
41 41
42/* primitives for information exchange 42/* primitives for information exchange
43 * generell format 43 * generell format
@@ -80,6 +80,7 @@
80#define PH_DEACTIVATE_IND 0x0202 80#define PH_DEACTIVATE_IND 0x0202
81#define PH_DEACTIVATE_CNF 0x4202 81#define PH_DEACTIVATE_CNF 0x4202
82#define PH_DATA_IND 0x2002 82#define PH_DATA_IND 0x2002
83#define PH_DATA_E_IND 0x3002
83#define MPH_ACTIVATE_IND 0x0502 84#define MPH_ACTIVATE_IND 0x0502
84#define MPH_DEACTIVATE_IND 0x0602 85#define MPH_DEACTIVATE_IND 0x0602
85#define MPH_INFORMATION_IND 0x0702 86#define MPH_INFORMATION_IND 0x0702
@@ -199,6 +200,18 @@
199#define ISDN_P_NT_S0 0x02 200#define ISDN_P_NT_S0 0x02
200#define ISDN_P_TE_E1 0x03 201#define ISDN_P_TE_E1 0x03
201#define ISDN_P_NT_E1 0x04 202#define ISDN_P_NT_E1 0x04
203#define ISDN_P_TE_UP0 0x05
204#define ISDN_P_NT_UP0 0x06
205
206#define IS_ISDN_P_TE(p) ((p == ISDN_P_TE_S0) || (p == ISDN_P_TE_E1) || \
207 (p == ISDN_P_TE_UP0) || (p == ISDN_P_LAPD_TE))
208#define IS_ISDN_P_NT(p) ((p == ISDN_P_NT_S0) || (p == ISDN_P_NT_E1) || \
209 (p == ISDN_P_NT_UP0) || (p == ISDN_P_LAPD_NT))
210#define IS_ISDN_P_S0(p) ((p == ISDN_P_TE_S0) || (p == ISDN_P_NT_S0))
211#define IS_ISDN_P_E1(p) ((p == ISDN_P_TE_E1) || (p == ISDN_P_NT_E1))
212#define IS_ISDN_P_UP0(p) ((p == ISDN_P_TE_UP0) || (p == ISDN_P_NT_UP0))
213
214
202#define ISDN_P_LAPD_TE 0x10 215#define ISDN_P_LAPD_TE 0x10
203#define ISDN_P_LAPD_NT 0x11 216#define ISDN_P_LAPD_NT 0x11
204 217
@@ -255,16 +268,6 @@ struct sockaddr_mISDN {
255 unsigned char tei; 268 unsigned char tei;
256}; 269};
257 270
258/* timer device ioctl */
259#define IMADDTIMER _IOR('I', 64, int)
260#define IMDELTIMER _IOR('I', 65, int)
261/* socket ioctls */
262#define IMGETVERSION _IOR('I', 66, int)
263#define IMGETCOUNT _IOR('I', 67, int)
264#define IMGETDEVINFO _IOR('I', 68, int)
265#define IMCTRLREQ _IOR('I', 69, int)
266#define IMCLEAR_L2 _IOR('I', 70, int)
267
268struct mISDNversion { 271struct mISDNversion {
269 unsigned char major; 272 unsigned char major;
270 unsigned char minor; 273 unsigned char minor;
@@ -281,6 +284,40 @@ struct mISDN_devinfo {
281 char name[MISDN_MAX_IDLEN]; 284 char name[MISDN_MAX_IDLEN];
282}; 285};
283 286
287struct mISDN_devrename {
288 u_int id;
289 char name[MISDN_MAX_IDLEN]; /* new name */
290};
291
292/* MPH_INFORMATION_REQ payload */
293struct ph_info_ch {
294 __u32 protocol;
295 __u64 Flags;
296};
297
298struct ph_info_dch {
299 struct ph_info_ch ch;
300 __u16 state;
301 __u16 num_bch;
302};
303
304struct ph_info {
305 struct ph_info_dch dch;
306 struct ph_info_ch bch[];
307};
308
309/* timer device ioctl */
310#define IMADDTIMER _IOR('I', 64, int)
311#define IMDELTIMER _IOR('I', 65, int)
312
313/* socket ioctls */
314#define IMGETVERSION _IOR('I', 66, int)
315#define IMGETCOUNT _IOR('I', 67, int)
316#define IMGETDEVINFO _IOR('I', 68, int)
317#define IMCTRLREQ _IOR('I', 69, int)
318#define IMCLEAR_L2 _IOR('I', 70, int)
319#define IMSETDEVNAME _IOR('I', 71, struct mISDN_devrename)
320
284static inline int 321static inline int
285test_channelmap(u_int nr, u_char *map) 322test_channelmap(u_int nr, u_char *map)
286{ 323{
@@ -312,6 +349,8 @@ clear_channelmap(u_int nr, u_char *map)
312#define MISDN_CTRL_SETPEER 0x0040 349#define MISDN_CTRL_SETPEER 0x0040
313#define MISDN_CTRL_UNSETPEER 0x0080 350#define MISDN_CTRL_UNSETPEER 0x0080
314#define MISDN_CTRL_RX_OFF 0x0100 351#define MISDN_CTRL_RX_OFF 0x0100
352#define MISDN_CTRL_FILL_EMPTY 0x0200
353#define MISDN_CTRL_GETPEER 0x0400
315#define MISDN_CTRL_HW_FEATURES_OP 0x2000 354#define MISDN_CTRL_HW_FEATURES_OP 0x2000
316#define MISDN_CTRL_HW_FEATURES 0x2001 355#define MISDN_CTRL_HW_FEATURES 0x2001
317#define MISDN_CTRL_HFC_OP 0x4000 356#define MISDN_CTRL_HFC_OP 0x4000
@@ -362,6 +401,7 @@ struct mISDN_ctrl_req {
362#define DEBUG_L2_TEI 0x00100000 401#define DEBUG_L2_TEI 0x00100000
363#define DEBUG_L2_TEIFSM 0x00200000 402#define DEBUG_L2_TEIFSM 0x00200000
364#define DEBUG_TIMER 0x01000000 403#define DEBUG_TIMER 0x01000000
404#define DEBUG_CLOCK 0x02000000
365 405
366#define mISDN_HEAD_P(s) ((struct mISDNhead *)&s->cb[0]) 406#define mISDN_HEAD_P(s) ((struct mISDNhead *)&s->cb[0])
367#define mISDN_HEAD_PRIM(s) (((struct mISDNhead *)&s->cb[0])->prim) 407#define mISDN_HEAD_PRIM(s) (((struct mISDNhead *)&s->cb[0])->prim)
@@ -375,6 +415,7 @@ struct mISDN_ctrl_req {
375struct mISDNchannel; 415struct mISDNchannel;
376struct mISDNdevice; 416struct mISDNdevice;
377struct mISDNstack; 417struct mISDNstack;
418struct mISDNclock;
378 419
379struct channel_req { 420struct channel_req {
380 u_int protocol; 421 u_int protocol;
@@ -423,7 +464,6 @@ struct mISDN_sock {
423struct mISDNdevice { 464struct mISDNdevice {
424 struct mISDNchannel D; 465 struct mISDNchannel D;
425 u_int id; 466 u_int id;
426 char name[MISDN_MAX_IDLEN];
427 u_int Dprotocols; 467 u_int Dprotocols;
428 u_int Bprotocols; 468 u_int Bprotocols;
429 u_int nrbchan; 469 u_int nrbchan;
@@ -452,6 +492,16 @@ struct mISDNstack {
452#endif 492#endif
453}; 493};
454 494
495typedef int (clockctl_func_t)(void *, int);
496
497struct mISDNclock {
498 struct list_head list;
499 char name[64];
500 int pri;
501 clockctl_func_t *ctl;
502 void *priv;
503};
504
455/* global alloc/queue functions */ 505/* global alloc/queue functions */
456 506
457static inline struct sk_buff * 507static inline struct sk_buff *
@@ -498,12 +548,23 @@ _queue_data(struct mISDNchannel *ch, u_int prim,
498 548
499/* global register/unregister functions */ 549/* global register/unregister functions */
500 550
501extern int mISDN_register_device(struct mISDNdevice *, char *name); 551extern int mISDN_register_device(struct mISDNdevice *,
552 struct device *parent, char *name);
502extern void mISDN_unregister_device(struct mISDNdevice *); 553extern void mISDN_unregister_device(struct mISDNdevice *);
503extern int mISDN_register_Bprotocol(struct Bprotocol *); 554extern int mISDN_register_Bprotocol(struct Bprotocol *);
504extern void mISDN_unregister_Bprotocol(struct Bprotocol *); 555extern void mISDN_unregister_Bprotocol(struct Bprotocol *);
556extern struct mISDNclock *mISDN_register_clock(char *, int, clockctl_func_t *,
557 void *);
558extern void mISDN_unregister_clock(struct mISDNclock *);
559
560static inline struct mISDNdevice *dev_to_mISDN(struct device *dev)
561{
562 return dev_get_drvdata(dev);
563}
505 564
506extern void set_channel_address(struct mISDNchannel *, u_int, u_int); 565extern void set_channel_address(struct mISDNchannel *, u_int, u_int);
566extern void mISDN_clock_update(struct mISDNclock *, int, struct timeval *);
567extern unsigned short mISDN_clock_get(void);
507 568
508#endif /* __KERNEL__ */ 569#endif /* __KERNEL__ */
509#endif /* mISDNIF_H */ 570#endif /* mISDNIF_H */
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-08 05:06:08 -0500