aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/isdn/hardware/mISDN
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2009-01-09 18:27:39 -0500
committerLinus Torvalds <torvalds@linux-foundation.org>2009-01-09 18:27:39 -0500
commit2fb585a10e421b4eeae066eb99080bd7e4512079 (patch)
treeb8ca32933de26e9198490acfb5a4df093fdd8ef9 /drivers/isdn/hardware/mISDN
parent31aeb6c815549948571eec988ad9728c27d7a68d (diff)
parent69f52adb2d534afc41fcc658f155e01f0b322f9e (diff)
Merge branch 'for_2.6.29' of git://git.kernel.org/pub/scm/linux/kernel/git/kkeil/ISDN-2.6
* 'for_2.6.29' of git://git.kernel.org/pub/scm/linux/kernel/git/kkeil/ISDN-2.6: (28 commits) mISDN: Add HFC USB driver mISDN: Add layer1 prim MPH_INFORMATION_REQ mISDN: Fix kernel crash when doing hardware conference with more than two members mISDN: Added missing create_l1() call mISDN: Add MODULE_DEVICE_TABLE() to hfcpci mISDN: Minor cleanups mISDN: Create /sys/class/mISDN mISDN: Add missing release functions mISDN: Add different different timer settings for hfc-pci mISDN: Minor fixes mISDN: Correct busy device detection mISDN: Fix deactivation, if peer IP is removed from l1oip instance. mISDN: Add ISDN_P_TE_UP0 / ISDN_P_NT_UP0 mISDN: Fix irq detection mISDN: Add ISDN sample clock API to mISDN core mISDN: Return error on E-channel access mISDN: Add E-Channel logging features mISDN: Use protocol to detect D-channel mISDN: Fixed more indexing bugs mISDN: Make debug output a little bit more verbose ...
Diffstat (limited to 'drivers/isdn/hardware/mISDN')
-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
8 files changed, 2915 insertions, 164 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__ */
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-20 10:31:24 -0500