openwrt-xburst/target/linux/generic-2.4/patches/201-hfc_usb_backport.patch

--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -38,7 +38,7 @@ subdir-$(CONFIG_FUSION)		+= message/fusi
 subdir-$(CONFIG_MD)		+= md
 subdir-$(CONFIG_IEEE1394)	+= ieee1394
 subdir-$(CONFIG_PNP)		+= pnp
-subdir-$(CONFIG_ISDN_BOOL)	+= isdn
+subdir-$(CONFIG_ISDN)		+= isdn
 subdir-$(CONFIG_ATM)		+= atm
 subdir-$(CONFIG_FC4)		+= fc4
 
--- a/drivers/isdn/hisax/hfc_usb.c
+++ b/drivers/isdn/hisax/hfc_usb.c
@@ -1,13 +1,11 @@
-/* $Id: hfc_usb.c,v 2.3 2001/07/06 21:30:11 werner Exp $
+/*
+ * hfc_usb.c
  *
+ * modular HiSax ISDN driver for Colognechip HFC-USB chip
  *
- *
- * Author       (C) 2001 Werner Cornelius (werner@isdn-development.de)
- *              modular driver for Colognechip HFC-USB chip
- *              as plugin for HiSax isdn driver
- *              type approval valid for HFC-S USB based TAs
- *
- * Copyright 2001  by Werner Cornelius (werner@isdn-development.de)
+ * Authors : Peter Sprenger  (sprenger@moving-byters.de)
+ *           Martin Bachem   (info@colognechip.com)
+ *           based on the first hfc_usb driver of Werner Cornelius (werner@isdn-development.de)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,70 +21,90 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
- */
+ * 2005_Mar_16 grsch
+ *      ported 2.6.8 hfc_usb.c to 2.4.20 format
+ *      Gregor Schaffrath <gschaff@ran-dom.org>
+*/
+
 
 #include <linux/types.h>
 #include <linux/stddef.h>
 #include <linux/timer.h>
 #include <linux/config.h>
-#include <linux/isdn_compat.h>
 #include <linux/init.h>
 #include "hisax.h"
 #include <linux/module.h>
 #include <linux/kernel_stat.h>
-#include <linux/tqueue.h>
 #include <linux/usb.h>
 #include <linux/kernel.h>
 #include <linux/smp_lock.h>
 #include <linux/sched.h>
+#include "hisax_if.h"
 #include "hisax_loadable.h"
 
+static const char *hfcusb_revision = "4.0";
+
+/*
+	to enable much mire debug messages in this driver, define
+			VERBOSE_USB_DEBUG and VERBOSE_ISDN_DEBUG
+	below
+*/
+
+#define VERBOSE_USB_DEBUG 
+#define VERBOSE_ISDN_DEBUG 
+
 #define INCLUDE_INLINE_FUNCS
 
+#define TRUE  1
+#define FALSE 0
+
+
 /***********/
 /* defines */
 /***********/
-#define HFC_CTRL_TIMEOUT 5	/* 5ms timeout writing/reading regs */
-#define HFC_TIMER_T3     7000	/* timeout for l1 activation timer */
-
-#define HFCUSB_L1_STATECHANGE   0	/* L1 state changed */
-#define HFCUSB_L1_DRX           1	/* D-frame received */
-#define HFCUSB_L1_ERX           2	/* E-frame received */
-#define HFCUSB_L1_DTX           4	/* D-frames completed */
-
-#define MAX_BCH_SIZE        2048	/* allowed B-channel packet size */
-
-#define HFCUSB_RX_THRESHOLD 64	/* threshold for fifo report bit rx */
-#define HFCUSB_TX_THRESHOLD 64	/* threshold for fifo report bit tx */
-
-#define HFCUSB_CHIP_ID    0x16	/* Chip ID register index */
-#define HFCUSB_CIRM       0x00	/* cirm register index */
-#define HFCUSB_USB_SIZE   0x07	/* int length register */
-#define HFCUSB_USB_SIZE_I 0x06	/* iso length register */
-#define HFCUSB_F_CROSS    0x0b	/* bit order register */
-#define HFCUSB_CLKDEL     0x37	/* bit delay register */
-#define HFCUSB_CON_HDLC   0xfa	/* channel connect register */
+#define HFC_CTRL_TIMEOUT	20  //(HZ * USB_CTRL_GET_TIMEOUT)
+/* 5ms timeout writing/reading regs */
+#define HFC_TIMER_T3     8000      /* timeout for l1 activation timer */
+#define HFC_TIMER_T4     500       /* time for state change interval */
+
+#define HFCUSB_L1_STATECHANGE   0  /* L1 state changed */
+#define HFCUSB_L1_DRX           1  /* D-frame received */
+#define HFCUSB_L1_ERX           2  /* E-frame received */
+#define HFCUSB_L1_DTX           4  /* D-frames completed */
+
+#define MAX_BCH_SIZE        2048   /* allowed B-channel packet size */
+
+#define HFCUSB_RX_THRESHOLD 64     /* threshold for fifo report bit rx */
+#define HFCUSB_TX_THRESHOLD 64     /* threshold for fifo report bit tx */
+
+#define HFCUSB_CHIP_ID    0x16     /* Chip ID register index */
+#define HFCUSB_CIRM       0x00     /* cirm register index */
+#define HFCUSB_USB_SIZE   0x07     /* int length register */
+#define HFCUSB_USB_SIZE_I 0x06     /* iso length register */
+#define HFCUSB_F_CROSS    0x0b     /* bit order register */
+#define HFCUSB_CLKDEL     0x37     /* bit delay register */
+#define HFCUSB_CON_HDLC   0xfa     /* channel connect register */
 #define HFCUSB_HDLC_PAR   0xfb
-#define HFCUSB_SCTRL      0x31	/* S-bus control register (tx) */
-#define HFCUSB_SCTRL_E    0x32	/* same for E and special funcs */
-#define HFCUSB_SCTRL_R    0x33	/* S-bus control register (rx) */
-#define HFCUSB_F_THRES    0x0c	/* threshold register */
-#define HFCUSB_FIFO       0x0f	/* fifo select register */
-#define HFCUSB_F_USAGE    0x1a	/* fifo usage register */
+#define HFCUSB_SCTRL      0x31     /* S-bus control register (tx) */
+#define HFCUSB_SCTRL_E    0x32     /* same for E and special funcs */
+#define HFCUSB_SCTRL_R    0x33     /* S-bus control register (rx) */
+#define HFCUSB_F_THRES    0x0c     /* threshold register */
+#define HFCUSB_FIFO       0x0f     /* fifo select register */
+#define HFCUSB_F_USAGE    0x1a     /* fifo usage register */
 #define HFCUSB_MST_MODE0  0x14
 #define HFCUSB_MST_MODE1  0x15
 #define HFCUSB_P_DATA     0x1f
 #define HFCUSB_INC_RES_F  0x0e
 #define HFCUSB_STATES     0x30
 
-#define HFCUSB_CHIPID 0x40	/* ID value of HFC-USB */
+#define HFCUSB_CHIPID 0x40         /* ID value of HFC-USB */
 
 /******************/
 /* fifo registers */
 /******************/
-#define HFCUSB_NUM_FIFOS   8	/* maximum number of fifos */
-#define HFCUSB_B1_TX       0	/* index for B1 transmit bulk/int */
-#define HFCUSB_B1_RX       1	/* index for B1 receive bulk/int */
+#define HFCUSB_NUM_FIFOS   8       /* maximum number of fifos */
+#define HFCUSB_B1_TX       0       /* index for B1 transmit bulk/int */
+#define HFCUSB_B1_RX       1       /* index for B1 receive bulk/int */
 #define HFCUSB_B2_TX       2
 #define HFCUSB_B2_RX       3
 #define HFCUSB_D_TX        4
@@ -94,198 +112,162 @@
 #define HFCUSB_PCM_TX      6
 #define HFCUSB_PCM_RX      7
 
-/************/
-/* LED mask */
-/************/
-#define LED_DRIVER         0x1
-#define LED_L1             0x2
-#define LED_BCH            0x4
+/*
+* used to switch snd_transfer_mode for different TA modes e.g. the Billion USB TA just
+* supports ISO out, while the Cologne Chip EVAL TA just supports BULK out
+*/
+#define USB_INT		0
+#define USB_BULK	1
+#define USB_ISOC	2
+
+#define ISOC_PACKETS_D	8
+#define ISOC_PACKETS_B	8
+#define ISO_BUFFER_SIZE	128
+
+// ISO send definitions
+#define SINK_MAX	68
+#define SINK_MIN	48
+#define SINK_DMIN	12
+#define SINK_DMAX	18
+#define BITLINE_INF	(-64*8)
+
+
+
 
 /**********/
 /* macros */
 /**********/
-#define Write_hfc(a,b,c) usb_control_msg((a)->dev,(a)->ctrl_out_pipe,0,0x40,(c),(b),0,0,HFC_CTRL_TIMEOUT)
-#define Read_hfc(a,b,c) usb_control_msg((a)->dev,(a)->ctrl_in_pipe,1,0xC0,0,(b),(c),1,HFC_CTRL_TIMEOUT)
-
-#ifdef COMPAT_HAS_USB_IDTAB
-/****************************************/
-/* data defining the devices to be used */
-/****************************************/
-static __devinitdata const struct usb_device_id hfc_usb_idtab[3] = {
-	{USB_DEVICE(0x959, 0x2bd0)},	/* Colognechip ROM */
-	{USB_DEVICE(0x7b0, 0x0006)},	/* USB TA 128 */
-	{}			/* end with an all-zeroes entry */
-};
-#endif
+#define write_usb(a,b,c) usb_control_msg((a)->dev,(a)->ctrl_out_pipe,0,0x40,(c),(b),NULL,0,HFC_CTRL_TIMEOUT)
+#define read_usb(a,b,c) usb_control_msg((a)->dev,(a)->ctrl_in_pipe,1,0xC0,0,(b),(c),1,HFC_CTRL_TIMEOUT)
 
 /*************************************************/
 /* entry and size of output/input control buffer */
 /*************************************************/
 #define HFC_CTRL_BUFSIZE 32
-typedef struct {
+typedef struct
+{
 	__u8 hfc_reg;		/* register number */
 	__u8 reg_val;		/* value to be written (or read) */
+	int action;         /* data for action handler */
+
 } ctrl_buft;
 
+typedef struct
+{
+	int vendor;         // vendor id
+	int prod_id;	    // product id
+	char *vend_name;    // vendor string
+	__u8 led_scheme;    // led display scheme
+	__u8 led_invert;    // invert led aux port settings
+	__u8 led_bits[8];   // array of 8 possible LED bitmask settings
+
+} vendor_data;
+
 /***************************************************************/
 /* structure defining input+output fifos (interrupt/bulk mode) */
 /***************************************************************/
-struct hfcusb_data;		/* forward definition */
-typedef struct {
-	int fifonum;		/* fifo index attached to this structure */
-	__u8 fifo_mask;		/* mask for this fifo */
-	int active;		/* fifo is currently active */
+
+struct usb_fifo;			/* forward definition */
+typedef struct iso_urb_struct
+{
+	struct urb *purb;
+	__u8 buffer[ISO_BUFFER_SIZE];	/* buffer incoming/outgoing data */
+	struct usb_fifo *owner_fifo;	// pointer to owner fifo
+} iso_urb_struct;
+
+
+struct hfcusb_data;			/* forward definition */
+typedef struct usb_fifo
+{
+	int fifonum;			/* fifo index attached to this structure */
+	int active;			/* fifo is currently active */
 	struct hfcusb_data *hfc;	/* pointer to main structure */
-	int pipe;		/* address of endpoint */
-	__u8 usb_maxlen;	/* maximum length for usb transfer */
-	int max_size;		/* maximum size of receive/send packet */
-	int transmode;		/* transparent mode selected */
-	int framenum;		/* number of frame when last tx completed */
-	int rx_offset;		/* offset inside rx buffer */
-	int next_complete;	/* complete marker */
-	__u8 *act_ptr;		/* pointer to next data */
-	__u8 intervall;		/* interrupt interval */
-	struct sk_buff *buff;	/* actual used buffer */
-	urb_t urb;		/* transfer structure for usb routines */
-	__u8 buffer[128];	/* buffer incoming/outgoing data */
+	int pipe;			/* address of endpoint */
+	__u8 usb_packet_maxlen;		/* maximum length for usb transfer */
+	unsigned int max_size;		/* maximum size of receive/send packet */
+	__u8 intervall;			/* interrupt interval */
+	struct sk_buff *skbuff; 	/* actual used buffer */
+	struct urb *urb;		/* transfer structure for usb routines */
+	__u8 buffer[128];		/* buffer incoming/outgoing data */
+	int bit_line;			/* how much bits are in the fifo? */
+
+	volatile __u8 usb_transfer_mode;/* switched between ISO and INT */
+	iso_urb_struct iso[2];		/* need two urbs to have one always for pending */
+	struct hisax_if *hif;		/* hisax interface */
+	int delete_flg;			/* only delete skbuff once */
+	int last_urblen;		/* remember length of last packet */
+
 } usb_fifo;
 
+
 /*********************************************/
 /* structure holding all data for one device */
 /*********************************************/
-typedef struct hfcusb_data {
-	struct hisax_drvreg regd;	/* register data and callbacks */
-	struct usb_device *dev;	/* our device */
-	int if_used;		/* used interface number */
-	int alt_used;		/* used alternate config */
-	int ctrl_paksize;	/* control pipe packet size */
+typedef struct hfcusb_data
+{
+	// HiSax Interface for loadable Layer1 drivers
+	struct hisax_d_if d_if;			/* see hisax_if.h */
+	struct hisax_b_if b_if[2];		/* see hisax_if.h */
+	int protocol;
+	
+	struct usb_device *dev;			/* our device */
+	int if_used;				/* used interface number */
+	int alt_used;				/* used alternate config */
+	int ctrl_paksize;			/* control pipe packet size */
 	int ctrl_in_pipe, ctrl_out_pipe;	/* handles for control pipe */
+	int cfg_used;				/* configuration index used */
+	int vend_idx;				// vendor found
+
+	int b_mode[2];				// B-channel mode
+
+	int l1_activated;			// layer 1 activated
+
+	int packet_size,iso_packet_size;	
 
 	/* control pipe background handling */
 	ctrl_buft ctrl_buff[HFC_CTRL_BUFSIZE];	/* buffer holding queued data */
-	volatile int ctrl_in_idx, ctrl_out_idx, ctrl_cnt;	/* input/output pointer + count */
-	urb_t ctrl_urb;		/* transfer structure for control channel */
-	devrequest ctrl_write;	/* buffer for control write request */
-	devrequest ctrl_read;	/* same for read request */
-
-	volatile __u8 dfifo_fill;	/* value read from tx d-fifo */
-	volatile __u8 active_fifos;	/* fifos currently active as bit mask */
-	volatile __u8 threshold_mask;	/* threshold actually reported */
-	volatile __u8 service_request;	/* fifo needs service from task */
-	volatile __u8 ctrl_fifo;	/* last selected fifo */
-	volatile __u8 bch_enables;	/* or mask for sctrl_r and sctrl register values */
-        volatile __u8 led_req;          /* request status of adapters leds */ 
-        volatile __u8 led_act;          /* active status of adapters leds */ 
+	volatile int ctrl_in_idx, ctrl_out_idx,
+		ctrl_cnt;			/* input/output pointer + count */
+	struct urb *ctrl_urb;			/* transfer structure for control channel */
+
+	struct usb_ctrlrequest ctrl_write;	/* buffer for control write request */
+	struct usb_ctrlrequest ctrl_read;	/* same for read request */
+
+	__u8 led_state,led_new_data,led_b_active;
+
+	volatile __u8 threshold_mask;		/* threshold actually reported */
+	volatile __u8 bch_enables;		/* or mask for sctrl_r and sctrl register values */
+
 	usb_fifo fifos[HFCUSB_NUM_FIFOS];	/* structure holding all fifo data */
 
-	/* layer 1 activation/deactivation handling */
-	volatile __u8 l1_state;	/* actual l1 state */
-	volatile ulong l1_event;	/* event mask */
-	struct tq_struct l1_tq;	/* l1 bh structure */
-	struct timer_list t3_timer;	/* timer for activation/deactivation */
-	struct timer_list t4_timer;	/* timer for activation/deactivation */
+	volatile __u8 l1_state;			/* actual l1 state */
+	struct timer_list t3_timer;		/* timer 3 for activation/deactivation */
+	struct timer_list t4_timer;		/* timer 4 for activation/deactivation */
+	struct timer_list led_timer;		/* timer flashing leds */
+
 } hfcusb_data;
 
-#if 0
-static void
-usb_dump_urb(purb_t purb)
-{
-	printk("urb                   :%p\n", purb);
-	printk("next                  :%p\n", purb->next);
-	printk("dev                   :%p\n", purb->dev);
-	printk("pipe                  :%08X\n", purb->pipe);
-	printk("status                :%d\n", purb->status);
-	printk("transfer_flags        :%08X\n", purb->transfer_flags);
-	printk("transfer_buffer       :%p\n", purb->transfer_buffer);
-	printk("transfer_buffer_length:%d\n",
-	       purb->transfer_buffer_length);
-	printk("actual_length         :%d\n", purb->actual_length);
-	printk("setup_packet          :%p\n", purb->setup_packet);
-	printk("start_frame           :%d\n", purb->start_frame);
-	printk("number_of_packets     :%d\n", purb->number_of_packets);
-	printk("interval              :%d\n", purb->interval);
-	printk("error_count           :%d\n", purb->error_count);
-	printk("context               :%p\n", purb->context);
-	printk("complete              :%p\n", purb->complete);
-}
-#endif
 
-/*************************************************************************/
-/* bottom half handler for L1 activation/deactiavtaion + D-chan + E-chan */
-/*************************************************************************/
-static void
-usb_l1d_bh(hfcusb_data * hfc)
-{
+static void collect_rx_frame(usb_fifo *fifo,__u8 *data,int len,int finish);
+
 
-	while (hfc->l1_event) {
-		if (test_and_clear_bit
-		    (HFCUSB_L1_STATECHANGE, &hfc->l1_event)) {
-			if (hfc->l1_state == 7)
-			    hfc->led_req |= LED_L1;
-			else
-			    hfc->led_req &= ~LED_L1;
-			if ((hfc->l1_state == 7) ||
-			    (hfc->l1_state == 3))
-			    hfc->regd.dch_l1l2(hfc->regd.arg_hisax,
-					       (hfc->l1_state ==
-						7) ? (PH_ACTIVATE |
-						      INDICATION)
-					       : (PH_DEACTIVATE | INDICATION),
-					       NULL);
-		}
-		if (test_and_clear_bit(HFCUSB_L1_DRX, &hfc->l1_event)) {
-			hfc->regd.dch_l1l2(hfc->regd.arg_hisax,
-					   PH_DATA | INDICATION,
-					   (void *) 0);
-		}
-		if (test_and_clear_bit(HFCUSB_L1_ERX, &hfc->l1_event)) {
-			hfc->regd.dch_l1l2(hfc->regd.arg_hisax,
-					   PH_DATA | INDICATION,
-					   (void *) 1);
-		}
-		if (test_and_clear_bit(HFCUSB_L1_DTX, &hfc->l1_event)) {
-			hfc->regd.dch_l1l2(hfc->regd.arg_hisax,
-					   PH_DATA | CONFIRM, NULL);
-		}
-	}			/* while */
-}				/* usb_l1d_bh */
 
 /******************************************************/
 /* start next background transfer for control channel */
 /******************************************************/
-static void
-ctrl_start_transfer(hfcusb_data * hfc)
+static void ctrl_start_transfer(hfcusb_data * hfc)
 {
-
-	if (hfc->ctrl_cnt) {
-		switch (hfc->ctrl_buff[hfc->ctrl_out_idx].hfc_reg) {
-			case HFCUSB_F_USAGE:
-				hfc->ctrl_urb.pipe = hfc->ctrl_in_pipe;
-				hfc->ctrl_urb.setup_packet =
-				    (u_char *) & hfc->ctrl_read;
-				hfc->ctrl_urb.transfer_buffer_length = 1;
-				hfc->ctrl_read.index =
-				    hfc->ctrl_buff[hfc->ctrl_out_idx].
-				    hfc_reg;
-				hfc->ctrl_urb.transfer_buffer =
-				    (char *) &hfc->dfifo_fill;
-				break;
-
-			default:	/* write register */
-				hfc->ctrl_urb.pipe = hfc->ctrl_out_pipe;
-				hfc->ctrl_urb.setup_packet =
-				    (u_char *) & hfc->ctrl_write;
-				hfc->ctrl_urb.transfer_buffer = NULL;
-				hfc->ctrl_urb.transfer_buffer_length = 0;
-				hfc->ctrl_write.index =
-				    hfc->ctrl_buff[hfc->ctrl_out_idx].
-				    hfc_reg;
-				hfc->ctrl_write.value =
-				    hfc->ctrl_buff[hfc->ctrl_out_idx].
-				    reg_val;
-				break;
-		}
-		usb_submit_urb(&hfc->ctrl_urb);	/* start transfer */
+	int err;
+	if(hfc->ctrl_cnt)
+	{
+		hfc->ctrl_urb->pipe = hfc->ctrl_out_pipe;
+		hfc->ctrl_urb->setup_packet = (u_char *) & hfc->ctrl_write;
+		hfc->ctrl_urb->transfer_buffer = NULL;
+		hfc->ctrl_urb->transfer_buffer_length = 0;
+		hfc->ctrl_write.wIndex = hfc->ctrl_buff[hfc->ctrl_out_idx].hfc_reg;
+		hfc->ctrl_write.wValue = hfc->ctrl_buff[hfc->ctrl_out_idx].reg_val;
+		err = usb_submit_urb(hfc->ctrl_urb);	/* start transfer */
+		printk(KERN_DEBUG "ctrl_start_transfer: submit %d\n", err);
 	}
 }				/* ctrl_start_transfer */
 
@@ -293,897 +275,1418 @@ ctrl_start_transfer(hfcusb_data * hfc)
 /* queue a control transfer request */
 /* return 0 on success.             */
 /************************************/
-static int
-queue_control_request(hfcusb_data * hfc, __u8 reg, __u8 val)
+static int queue_control_request(hfcusb_data * hfc, __u8 reg, __u8 val,int action)
 {
 	ctrl_buft *buf;
 
-	if (hfc->ctrl_cnt >= HFC_CTRL_BUFSIZE)
-		return (1);	/* no space left */
-	buf = hfc->ctrl_buff + hfc->ctrl_in_idx;	/* pointer to new index */
+#ifdef VERBOSE_USB_DEBUG
+	printk ("HFC_USB: queue_control_request reg: %x, val: %x\n", reg, val);
+#endif
+
+	if(hfc->ctrl_cnt >= HFC_CTRL_BUFSIZE)  return(1);	   /* no space left */
+	buf = &hfc->ctrl_buff[hfc->ctrl_in_idx];	/* pointer to new index */
 	buf->hfc_reg = reg;
 	buf->reg_val = val;
+	buf->action=action;
 	if (++hfc->ctrl_in_idx >= HFC_CTRL_BUFSIZE)
 		hfc->ctrl_in_idx = 0;	/* pointer wrap */
 	if (++hfc->ctrl_cnt == 1)
 		ctrl_start_transfer(hfc);
-	return (0);
-}				/* queue_control_request */
+	return(0);
+}		/* queue_control_request */
 
-/**************************************/
-/* called when timer t3 or t4 expires */
-/**************************************/
-static void
-l1_timer_expire(hfcusb_data * hfc)
-{
-    if (timer_pending(&hfc->t4_timer))
-	del_timer(&hfc->t4_timer);
-    queue_control_request(hfc, HFCUSB_STATES, 0x40);
-    test_and_set_bit(HFCUSB_L1_STATECHANGE,
-		     &hfc->l1_event);
-    queue_task(&hfc->l1_tq, &tq_immediate);
-    mark_bh(IMMEDIATE_BH);
-} /* l1_timer_expire */
-
-/**************************************************/
-/* (re)fills a tx-fifo urb. Queuing is done later */
-/**************************************************/
-static void
-fill_tx_urb(usb_fifo * fifo)
-{
-	struct sk_buff *skb;
-	long flags;
-	int i, ii = 0;
-
-	fifo->urb.dev = fifo->hfc->dev;
-	if ((fifo->buff)
-	    && (fifo->urb.transfer_buffer_length < fifo->usb_maxlen)) {
-		switch (fifo->fifonum) {
-			case HFCUSB_B1_TX:
-			case HFCUSB_B2_TX:
-				skb = fifo->buff;
-				fifo->buff = NULL;
-				fifo->hfc->regd.bch_l1l2(fifo->hfc->regd.
-							 arg_hisax,
-							 (fifo->fifonum ==
-							  HFCUSB_B1_TX) ? 0
-							 : 1,
-							 (PH_DATA |
-							  CONFIRM),
-							 (void *) skb);
-				fifo->hfc->service_request |=
-				    fifo->fifo_mask;
-				return;
-			case HFCUSB_D_TX:
-				dev_kfree_skb_any(fifo->buff);
-				fifo->buff = NULL;
-				save_flags(flags);
-				cli();
-				fifo->hfc->dfifo_fill = 0xff;	/* currently invalid data */
-				queue_control_request(fifo->hfc,
-						      HFCUSB_FIFO,
-						      HFCUSB_D_TX);
-				queue_control_request(fifo->hfc,
-						      HFCUSB_F_USAGE, 0);
-				restore_flags(flags);
-				return;
-			default:
-				return;	/* error, invalid fifo */
-		}
+
+static int control_action_handler(hfcusb_data *hfc,int reg,int val,int action)
+{
+	if(!action) return(1);  // no action defined
+
+	return(0);
+}
+
+
+/***************************************************************/
+/* control completion routine handling background control cmds */
+/***************************************************************/
+static void ctrl_complete(struct urb *urb)
+{
+	hfcusb_data *hfc = (hfcusb_data *) urb->context;
+	ctrl_buft *buf;
+
+	printk(KERN_DEBUG "ctrl_complete cnt %d\n", hfc->ctrl_cnt);
+	urb->dev = hfc->dev;
+	if(hfc->ctrl_cnt)
+	{
+		buf=&hfc->ctrl_buff[hfc->ctrl_out_idx];
+		control_action_handler(hfc,buf->hfc_reg,buf->reg_val,buf->action);
+
+		hfc->ctrl_cnt--;	/* decrement actual count */
+		if(++hfc->ctrl_out_idx >= HFC_CTRL_BUFSIZE) hfc->ctrl_out_idx = 0;	/* pointer wrap */
+
+		ctrl_start_transfer(hfc);	/* start next transfer */
+	}
+}				/* ctrl_complete */
+
+
+
+#define LED_OFF      0   // no LED support
+#define LED_SCHEME1  1	 // LED standard scheme
+#define LED_SCHEME2  2	 // not used yet...
+
+#define LED_POWER_ON	1
+#define LED_POWER_OFF	2
+#define LED_S0_ON		3
+#define LED_S0_OFF		4
+#define LED_B1_ON		5
+#define LED_B1_OFF		6
+#define LED_B1_DATA		7
+#define LED_B2_ON		8
+#define LED_B2_OFF		9
+#define LED_B2_DATA	   10
+
+#define LED_NORMAL   0	 // LEDs are normal
+#define LED_INVERTED 1   // LEDs are inverted
+
+// time for LED flashing
+#define LED_TIME      250
+
+vendor_data vdata[]=
+{
+    {0x959, 0x2bd0, "ISDN USB TA (Cologne Chip HFC-S USB based)", LED_OFF,LED_NORMAL,{4,0,2,1}},     /* CologneChip Eval TA */
+	{0x7b0, 0x0007, "Billion tiny USB ISDN TA 128", LED_SCHEME1,  LED_INVERTED, {8,0x40,0x20,0x10}},  /* Billion TA */
+	{0x742, 0x2008, "Stollmann USB TA",             LED_SCHEME1,  LED_NORMAL,   {4,0,2,1}},           /* Stollmann TA */
+	{0x8e3, 0x0301, "Olitec USB RNIS",              LED_SCHEME1,  LED_NORMAL,   {2,0,1,4}},           /* Olitec TA  */
+	{0x675, 0x1688, "DrayTec USB ISDN TA",          LED_SCHEME1,  LED_NORMAL,   {4,0,2,1}},           /* Draytec TA */
+	{0x7fa, 0x0846, "Bewan Modem RNIS USB",         LED_SCHEME1,  LED_INVERTED, {8,0x40,0x20,0x10}},  /* Bewan TA   */
+	{0}			   // EOL element
+};
+										
+/***************************************************/
+/* write led data to auxport & invert if necessary */
+/***************************************************/
+static void write_led(hfcusb_data * hfc,__u8 led_state)
+{
+	if(led_state!=hfc->led_state)
+	{
+		hfc->led_state=led_state;
+		queue_control_request(hfc, HFCUSB_P_DATA,(vdata[hfc->vend_idx].led_invert) ? ~led_state : led_state,1);
+	}
+}
+
+/******************************************/
+/* invert B-channel LEDs if data is sent  */
+/******************************************/
+static void led_timer(hfcusb_data * hfc)
+{
+   	static int cnt=0;
+	__u8 led_state=hfc->led_state;
+
+	if(cnt)
+	{
+		if(hfc->led_b_active&1) led_state|=vdata[hfc->vend_idx].led_bits[2];
+		if(hfc->led_b_active&2) led_state|=vdata[hfc->vend_idx].led_bits[3];
+	}
+	else
+	{
+		if(!(hfc->led_b_active&1) || hfc->led_new_data&1) led_state&=~vdata[hfc->vend_idx].led_bits[2];
+		if(!(hfc->led_b_active&2) || hfc->led_new_data&2) led_state&=~vdata[hfc->vend_idx].led_bits[3];
 	}
 
-	/* check if new buffer needed */
-	if (!fifo->buff) {
-		switch (fifo->fifonum) {
-			case HFCUSB_B1_TX:
-				if (fifo->hfc->regd.bsk[0])
-					fifo->buff = *fifo->hfc->regd.bsk[0];	/* B1-channel tx buffer */
+	write_led(hfc,led_state);
+	hfc->led_new_data=0;
+
+	cnt=!cnt;
+	// restart 4 hz timer
+	hfc->led_timer.expires = jiffies + (LED_TIME * HZ) / 1000;
+	if(!timer_pending(&hfc->led_timer)) add_timer(&hfc->led_timer);
+}
+
+/**************************/
+/* handle LED requests    */
+/**************************/
+static void handle_led(hfcusb_data * hfc,int event)
+{
+	__u8 led_state=hfc->led_state;
+
+	// if no scheme -> no LED action
+   	if(vdata[hfc->vend_idx].led_scheme==LED_OFF) return;
+
+	switch(event)
+	{
+		case LED_POWER_ON:
+				   led_state|=vdata[hfc->vend_idx].led_bits[0];
+				break;
+		case LED_POWER_OFF: // no Power off handling
+				break;
+		case LED_S0_ON:
+				   led_state|=vdata[hfc->vend_idx].led_bits[1];
+				break;
+		case LED_S0_OFF:
+				   led_state&=~vdata[hfc->vend_idx].led_bits[1];
 				break;
-			case HFCUSB_B2_TX:
-				if (fifo->hfc->regd.bsk[1])
-					fifo->buff = *fifo->hfc->regd.bsk[1];	/* B2-channel tx buffer */
+		case LED_B1_ON:
+					hfc->led_b_active|=1;
 				break;
-			case HFCUSB_D_TX:
-				if (fifo->hfc->regd.dsq)
-					fifo->buff = skb_dequeue(fifo->hfc->regd.dsq);	/* D-channel tx queue */
+		case LED_B1_OFF:
+					hfc->led_b_active&=~1;
 				break;
-			default:
-				return;	/* error, invalid fifo */
+		case LED_B1_DATA:
+				   hfc->led_new_data|=1;
+				break;
+		case LED_B2_ON:
+				   hfc->led_b_active|=2;
+				break;
+		case LED_B2_OFF:
+					hfc->led_b_active&=~2;
+				break;
+		case LED_B2_DATA:
+				   hfc->led_new_data|=2;
+				break;
+	}
+	
+	write_led(hfc,led_state);
+}
+
+/********************************/
+/* called when timer t3 expires */
+/********************************/
+static void l1_timer_expire_t3(hfcusb_data * hfc)
+{
+    //printk (KERN_INFO "HFC-USB: l1_timer_expire_t3\n");
+
+	hfc->d_if.ifc.l1l2(&hfc->d_if.ifc,PH_DEACTIVATE | INDICATION,NULL);
+#ifdef VERBOSE_USB_DEBUG
+	printk(KERN_INFO "PH_DEACTIVATE | INDICATION sent\n");
+#endif
+	hfc->l1_activated=FALSE;
+	handle_led(hfc,LED_S0_OFF);
+}
+
+/********************************/
+/* called when timer t4 expires */
+/********************************/
+static void l1_timer_expire_t4(hfcusb_data * hfc)
+{
+    //printk (KERN_INFO "HFC-USB: l1_timer_expire_t4\n");
+
+	hfc->d_if.ifc.l1l2(&hfc->d_if.ifc,PH_DEACTIVATE | INDICATION,NULL);
+#ifdef VERBOSE_USB_DEBUG
+	printk(KERN_INFO "PH_DEACTIVATE | INDICATION sent\n");
+#endif
+	hfc->l1_activated=FALSE;
+	handle_led(hfc,LED_S0_OFF);
+}
+
+/*****************************/
+/* handle S0 state changes   */
+/*****************************/
+static void state_handler(hfcusb_data * hfc,__u8 state)
+{
+	__u8 old_state;
+
+	old_state=hfc->l1_state;
+
+	// range check
+	if(state==old_state || state<1 || state>8) return;
+
+#ifdef VERBOSE_ISDN_DEBUG
+	printk(KERN_INFO "HFC-USB: new S0 state:%d old_state:%d\n",state,old_state);
+#endif
+
+	if(state<4 || state==7 || state==8)
+	{
+        if(timer_pending(&hfc->t3_timer)) del_timer(&hfc->t3_timer);
+		//printk(KERN_INFO "HFC-USB: T3 deactivated\n");
+	}
+
+	if(state>=7)
+	{
+        if(timer_pending(&hfc->t4_timer)) del_timer(&hfc->t4_timer);
+		//printk(KERN_INFO "HFC-USB: T4 deactivated\n");
+	}
+
+	if(state==7 && !hfc->l1_activated)
+	{
+		hfc->d_if.ifc.l1l2(&hfc->d_if.ifc,PH_ACTIVATE | INDICATION,NULL);
+		//printk(KERN_INFO "HFC-USB: PH_ACTIVATE | INDICATION sent\n");
+		hfc->l1_activated=TRUE;
+		handle_led(hfc,LED_S0_ON);
+	}
+	else
+	if(state<=3 /* && activated*/)
+	{
+		if(old_state==7 || old_state==8)
+		{
+			//printk(KERN_INFO "HFC-USB: T4 activated\n");
+			hfc->t4_timer.expires = jiffies + (HFC_TIMER_T4 * HZ) / 1000;
+			if(!timer_pending(&hfc->t4_timer)) add_timer(&hfc->t4_timer);
 		}
-		if (!fifo->buff) {
-			fifo->active = 0;	/* we are inactive now */
-			fifo->hfc->active_fifos &= ~fifo->fifo_mask;
-			if (fifo->fifonum == HFCUSB_D_TX) {
-				test_and_set_bit(HFCUSB_L1_DTX,
-						 &fifo->hfc->l1_event);
-				queue_task(&fifo->hfc->l1_tq,
-					   &tq_immediate);
-				mark_bh(IMMEDIATE_BH);
-			}
-			return;
+		else
+		{
+			hfc->d_if.ifc.l1l2(&hfc->d_if.ifc,PH_DEACTIVATE | INDICATION,NULL);
+			//printk(KERN_INFO "HFC-USB: PH_DEACTIVATE | INDICATION sent\n");
+			hfc->l1_activated=FALSE;
+			handle_led(hfc,LED_S0_OFF);
 		}
-		fifo->act_ptr = fifo->buff->data;	/* start of data */
-		fifo->active = 1;
-		ii = 1;
-		fifo->hfc->active_fifos |= fifo->fifo_mask;
-		fifo->hfc->service_request &= ~fifo->fifo_mask;
-	}
-	/* fillup the send buffer */
-	i = fifo->buff->len - (fifo->act_ptr - fifo->buff->data);	/* remaining length */
-	fifo->buffer[0] = !fifo->transmode;	/* not eof */
-	if (i > (fifo->usb_maxlen - ii)) {
-		i = fifo->usb_maxlen - ii;
-	}
-	if (i)
-		memcpy(fifo->buffer + ii, fifo->act_ptr, i);
-	fifo->urb.transfer_buffer_length = i + ii;
-        fifo->rx_offset = ii;
-}				/* fill_tx_urb */
-
-/************************************************/
-/* transmit completion routine for all tx fifos */
-/************************************************/
-static void
-tx_complete(purb_t urb)
+	}
+
+	hfc->l1_state=state;
+}
+
+
+/* prepare iso urb */
+static void fill_isoc_urb(struct urb *urb, struct usb_device *dev, unsigned int pipe, void *buf,
+	int num_packets, int packet_size, int interval, usb_complete_t complete, void *context)
 {
-	usb_fifo *fifo = (usb_fifo *) urb->context;	/* pointer to our fifo */
+	int k;
 
-	fifo->hfc->service_request &= ~fifo->fifo_mask;	/* no further handling */
-	fifo->framenum = usb_get_current_frame_number(fifo->hfc->dev);
+	spin_lock_init(&urb->lock);	// do we really need spin_lock_init ?
+	urb->dev = dev;
+	urb->pipe = pipe;
+	urb->complete = complete;
+	urb->number_of_packets = num_packets;
+	urb->transfer_buffer_length = packet_size * num_packets;
+	urb->context = context;
+	urb->transfer_buffer = buf;
+	urb->transfer_flags = 0;
+	urb->transfer_flags = USB_ISO_ASAP;
+	urb->actual_length = 0;
+	urb->interval = interval;
+	for (k = 0; k < num_packets; k++) {
+		urb->iso_frame_desc[k].offset = packet_size * k;
+		urb->iso_frame_desc[k].length = packet_size;
+		urb->iso_frame_desc[k].actual_length = 0;
+	}
+}
 
-	/* check for deactivation or error */
-	if ((!fifo->active) || (urb->status)) {
-		fifo->hfc->active_fifos &= ~fifo->fifo_mask;	/* we are inactive */
-		fifo->active = 0;
-		if ((fifo->buff) && (fifo->fifonum == HFCUSB_D_TX)) {
-			dev_kfree_skb_any(fifo->buff);
+/* allocs urbs and start isoc transfer with two pending urbs to avoid gaps in the transfer chain */
+static int start_isoc_chain(usb_fifo * fifo, int num_packets_per_urb,usb_complete_t complete,int packet_size)
+{
+	int i, k, errcode;
+
+#ifdef VERBOSE_USB_DEBUG
+	printk(KERN_INFO "HFC-USB: starting ISO-chain for Fifo %i\n",  fifo->fifonum);
+#endif
+
+
+	// allocate Memory for Iso out Urbs
+	for (i = 0; i < 2; i++) {
+		if (!(fifo->iso[i].purb)) {
+			fifo->iso[i].purb = usb_alloc_urb(num_packets_per_urb);
+			fifo->iso[i].owner_fifo = (struct usb_fifo *) fifo;
+
+			// Init the first iso
+			if (ISO_BUFFER_SIZE >= (fifo->usb_packet_maxlen * num_packets_per_urb))
+			{
+
+				fill_isoc_urb(fifo->iso[i].purb, fifo->hfc->dev, fifo->pipe, fifo->iso[i].buffer,
+					num_packets_per_urb, fifo->usb_packet_maxlen, fifo->intervall,
+					complete, &fifo->iso[i]);
+
+				memset(fifo->iso[i].buffer, 0, sizeof(fifo->iso[i].buffer));
+
+				// defining packet delimeters in fifo->buffer
+				for(k = 0; k < num_packets_per_urb; k++)
+				{
+					fifo->iso[i].purb->iso_frame_desc[k].offset = k*packet_size;
+					fifo->iso[i].purb->iso_frame_desc[k].length = packet_size;
+				}
+			}
 		}
-		fifo->buff = NULL;
-		return;
+
+		fifo->bit_line = BITLINE_INF;
+
+		errcode = usb_submit_urb(fifo->iso[i].purb);
+		fifo->active = (errcode >= 0) ? 1 : 0;
+		if(errcode < 0)
+		{
+			printk(KERN_INFO "HFC-USB: error submitting ISO URB: %i.%i \n",  errcode, i);
+		};
+
 	}
-	fifo->act_ptr += (urb->transfer_buffer_length - fifo->rx_offset);	/* adjust pointer */
-	fill_tx_urb(fifo);	/* refill the urb */
-	fifo->hfc->threshold_mask |= fifo->fifo_mask;	/* assume threshold reached */
-	if (fifo->buff)
-		fifo->hfc->service_request |= fifo->fifo_mask;	/* need to restart */
-}				/* tx_complete */
 
-/***********************************************/
-/* receive completion routine for all rx fifos */
-/***********************************************/
-static void
-rx_complete(purb_t urb)
+	// errcode = (usb_submit_urb(fifo->iso[0].purb, GFP_KERNEL));
+	return(fifo->active);
+}
+
+/* stops running iso chain and frees their pending urbs */
+static void stop_isoc_chain(usb_fifo * fifo)
 {
-	usb_fifo *fifo = (usb_fifo *) urb->context;	/* pointer to our fifo */
-	hfcusb_data *hfc = fifo->hfc;
-	usb_fifo *txfifo;
-	__u8 last_state;
-	int i, ii, currcnt, hdlci;
-	struct sk_buff *skb;
-
-	urb->dev = hfc->dev; /* security init */
-	if ((!fifo->active) || (urb->status)) {
-		hfc->service_request &= ~fifo->fifo_mask;	/* no further handling */
-		hfc->active_fifos &= ~fifo->fifo_mask;	/* we are inactive */
-		fifo->urb.interval = 0;	/* cancel automatic rescheduling */
-		if (fifo->buff) {
-			dev_kfree_skb_any(fifo->buff);
-			fifo->buff = NULL;
+	int i;
+
+	for(i = 0; i < 2; i++)
+	{
+		if(fifo->iso[i].purb)
+		{
+#ifdef VERBOSE_USB_DEBUG
+			printk(KERN_INFO "HFC-USB: Stopping iso chain for fifo %i.%i\n", fifo->fifonum, i);
+#endif
+			usb_unlink_urb(fifo->iso[i].purb);
+			usb_free_urb(fifo->iso[i].purb);
+			fifo->iso[i].purb = NULL;
 		}
-		return;
 	}
+	if (fifo->urb) {
+		usb_unlink_urb(fifo->urb);
+		usb_free_urb(fifo->urb);
+		fifo->urb = NULL;
+	}
+	fifo->active = 0;
+}
 
-	/* first check for any status changes */
-	if ((urb->actual_length < fifo->rx_offset)
-	    || (urb->actual_length > fifo->usb_maxlen))
-		return;		/* error condition */
-
-	if (fifo->rx_offset) {
-		hfc->threshold_mask = fifo->buffer[1];	/* update threshold status */
-		fifo->next_complete = fifo->buffer[0] & 1;
-		if ((fifo->fifonum == HFCUSB_D_RX) &&
-		    (hfc->led_req != hfc->led_act))
-		    queue_control_request(hfc, HFCUSB_P_DATA, hfc->led_req);
-
-		/* check if rescheduling needed */
-		if ((i =
-		     hfc->service_request & hfc->active_fifos & ~hfc->
-		     threshold_mask)) {
-			currcnt =
-			    usb_get_current_frame_number(hfc->dev);
-			txfifo = hfc->fifos + HFCUSB_B1_TX;
-			ii = 3;
-			while (ii--) {
-				if ((i & txfifo->fifo_mask)
-				    && (currcnt != txfifo->framenum)) {
-					hfc->service_request &=
-					    ~txfifo->fifo_mask;
-					if (!txfifo->buff)
-						fill_tx_urb(txfifo);
-					if (txfifo->buff)
-						usb_submit_urb(&txfifo->
-							       urb);
+// defines how much ISO packets are handled in one URB
+static int iso_packets[8]={ISOC_PACKETS_B,ISOC_PACKETS_B,ISOC_PACKETS_B,ISOC_PACKETS_B,
+	                       ISOC_PACKETS_D,ISOC_PACKETS_D,ISOC_PACKETS_D,ISOC_PACKETS_D};
+
+/*****************************************************/
+/* transmit completion routine for all ISO tx fifos */
+/*****************************************************/
+static void tx_iso_complete(struct urb *urb)
+{
+	iso_urb_struct *context_iso_urb = (iso_urb_struct *) urb->context;
+	usb_fifo *fifo = context_iso_urb->owner_fifo;
+	hfcusb_data *hfc = fifo->hfc;
+	int k, tx_offset, num_isoc_packets, sink, len, current_len,errcode,frame_complete,transp_mode,fifon;
+	__u8 threshbit;
+	__u8 threshtable[8] = { 1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
+
+	fifon=fifo->fifonum;
+	tx_offset=0;
+	// very weird error code when using ohci drivers, for now : ignore this error ...  (MB)
+	if(urb->status == -EOVERFLOW)
+	{
+		urb->status = 0;
+#ifdef VERBOSE_USB_DEBUG
+		printk(KERN_INFO "HFC-USB: ignoring USB DATAOVERRUN  for fifo  %i \n",fifon);
+#endif
+	}
+
+	if(fifo->active && !urb->status)
+	{
+		transp_mode=0;
+		if(fifon<4 && hfc->b_mode[fifon/2]==L1_MODE_TRANS) transp_mode=TRUE;
+
+		threshbit = threshtable[fifon] & hfc->threshold_mask;	// is threshold set for our channel?
+		num_isoc_packets=iso_packets[fifon];
+
+		if(fifon >= HFCUSB_D_TX)
+		{
+			sink = (threshbit) ? SINK_DMIN : SINK_DMAX;	// how much bit go to the sink for D-channel?
+		}
+		else
+		{
+			sink = (threshbit) ? SINK_MIN : SINK_MAX;	// how much bit go to the sink for B-channel?
+		}
+
+		// prepare ISO Urb
+		fill_isoc_urb(urb, fifo->hfc->dev, fifo->pipe,context_iso_urb->buffer, num_isoc_packets,
+			fifo->usb_packet_maxlen, fifo->intervall, tx_iso_complete, urb->context);
+		memset(context_iso_urb->buffer, 0, sizeof(context_iso_urb->buffer));
+
+		frame_complete=FALSE;
+
+		// Generate Iso Packets
+		for(k = 0; k < num_isoc_packets; ++k)
+		{
+			if(fifo->skbuff)
+			{
+				len = fifo->skbuff->len;	// remaining length
+
+				fifo->bit_line -= sink;	// we lower data margin every msec
+				current_len = (0 - fifo->bit_line) / 8;
+				if(current_len > 14) current_len = 14;	// maximum 15 byte for every ISO packet makes our life easier
+				current_len = (len <= current_len) ? len : current_len;
+				fifo->bit_line += current_len * 8;	// how much bit do we put on the line?
+
+				context_iso_urb->buffer[tx_offset] = 0;
+				if(current_len == len)
+				{
+					if(!transp_mode)
+					{
+						context_iso_urb->buffer[tx_offset] = 1;	// here frame completion
+						fifo->bit_line += 32;	// add 2 byte flags and 16bit CRC at end of ISDN frame
+					}
+					frame_complete = TRUE;
+				}
+
+				// copy bytes from buffer into ISO_URB
+				memcpy(context_iso_urb->buffer+tx_offset+1,fifo->skbuff->data,current_len);
+				skb_pull(fifo->skbuff,current_len);
+
+				// define packet delimeters within the URB buffer
+				urb->iso_frame_desc[k].offset = tx_offset;
+				urb->iso_frame_desc[k].length = current_len + 1;
+
+				tx_offset += (current_len + 1);
+				// printk(KERN_INFO "HFC-USB: fifonum:%d,%d bytes to send, %d bytes ISO packet,bitline:%d,sink:%d,threshbit:%d,threshmask:%x\n",fifon,len,current_len,fifo->bit_line,sink,threshbit,hfc->threshold_mask);
+				if(!transp_mode)
+				{
+					if(fifon==HFCUSB_B1_TX) handle_led(hfc,LED_B1_DATA);
+					if(fifon==HFCUSB_B2_TX) handle_led(hfc,LED_B2_DATA);
+				}
+			}
+			else
+			{
+				// we have no more data - generate 1 byte ISO packets
+				urb->iso_frame_desc[k].offset = tx_offset++;
+
+				urb->iso_frame_desc[k].length = 1;
+				fifo->bit_line -= sink;	// we lower data margin every msec
+
+				if(fifo->bit_line < BITLINE_INF)
+				{
+					fifo->bit_line = BITLINE_INF;
+					//printk (KERN_INFO "HFC-USB: BITLINE_INF underrun\n");
 				}
-				txfifo += 2;
 			}
-		}
 
-		/* handle l1 events */
-		if ((fifo->buffer[0] >> 4) != hfc->l1_state) {
-			last_state = hfc->l1_state;
-			hfc->l1_state = fifo->buffer[0] >> 4;	/* update status */
-			if (timer_pending(&hfc->t4_timer))
-			    del_timer(&hfc->t4_timer);
-			if (((hfc->l1_state == 3) && 
-			     ((last_state == 7) || 
-			      (last_state == 8))) || 
-			    ((timer_pending(&hfc->t3_timer) &&
-			    (hfc->l1_state == 8)))) {
-			    hfc->t4_timer.expires = jiffies + 2;
-			    add_timer(&hfc->t4_timer);
-			} else { 
-				if (timer_pending(&hfc->t3_timer)
-				    && (hfc->l1_state == 7))
-					del_timer(&hfc->t3_timer);	/* no longer needed */
-				test_and_set_bit(HFCUSB_L1_STATECHANGE,
-						 &hfc->l1_event);
-				queue_task(&hfc->l1_tq, &tq_immediate);
-				mark_bh(IMMEDIATE_BH);
+			if(frame_complete)
+			{
+				// delete the buffer only once, here or in hfc_usb_l2l1() in a PH_DATA|REQUEST
+				fifo->delete_flg=TRUE;
+
+				fifo->hif->l1l2(fifo->hif,PH_DATA|CONFIRM,(void*)fifo->skbuff->truesize);
+
+				if(fifo->skbuff && fifo->delete_flg)
+				{
+					dev_kfree_skb_any(fifo->skbuff);
+					//printk(KERN_INFO "HFC-USB: skbuff=NULL on fifo:%d\n",fifo->fifonum);
+					fifo->skbuff = NULL;
+					fifo->delete_flg=FALSE;
+				}
+
+				frame_complete=FALSE;
 			}
+        }
+
+		errcode = usb_submit_urb(urb);
+		if(errcode < 0)
+		{
+			printk(KERN_INFO "HFC-USB: error submitting ISO URB: %i \n",  errcode);
+		}
+	}
+	else
+	{
+		if(urb->status)
+		{
+			printk(KERN_INFO "HFC-USB: tx_iso_complete : urb->status %i, fifonum %i\n",  urb->status,fifon);
 		}
 	}
 
-	/* check the length for data and move if present */
-	if (fifo->next_complete || (urb->actual_length > fifo->rx_offset)) {
-		i = fifo->buff->len + urb->actual_length - fifo->rx_offset;	/* new total length */
-		hdlci = (fifo->transmode) ? 0 : 3;
-		if (i <= (fifo->max_size + hdlci)) {
-			memcpy(fifo->act_ptr,
-			       fifo->buffer + fifo->rx_offset,
-			       urb->actual_length - fifo->rx_offset);
-			fifo->act_ptr +=
-			    (urb->actual_length - fifo->rx_offset);
-			fifo->buff->len +=
-			    (urb->actual_length - fifo->rx_offset);
-		} else
-			fifo->buff->len = fifo->max_size + 4;	/* mark frame as to long */
-		if (fifo->next_complete && (urb->actual_length < fifo->usb_maxlen)) {
-		    /* the frame is complete */
-		    fifo->next_complete = 0;
-		    if (((!*(fifo->act_ptr - 1)) || fifo->transmode) &&
-			(fifo->buff->len >= (hdlci + 1))
-			&& (fifo->buff->len <=
-			    (fifo->max_size + hdlci)) &&
-			((skb = dev_alloc_skb(fifo->max_size + hdlci)) != NULL)) {
-			fifo->buff->len -= hdlci;	/* adjust size */
-			switch (fifo->fifonum) {
-			    case HFCUSB_D_RX:
-				skb_queue_tail(hfc->regd.
-					       drq,
-					       fifo->buff);
-				test_and_set_bit
-				    (HFCUSB_L1_DRX,
-				     &hfc->l1_event);
-				queue_task(&hfc->l1_tq,
-					   &tq_immediate);
-				mark_bh(IMMEDIATE_BH);
-				break;
+}				/* tx_iso_complete */
 
-			    case HFCUSB_B1_RX:
-				if (hfc->regd.brq[0]) {
-				    skb_queue_tail
-					(hfc->regd.
-					 brq[0],
-					 fifo->buff);
-				    hfc->regd.
-					bch_l1l2(hfc->
-						 regd.
-						 arg_hisax,
-						 0,
-						 PH_DATA
-						 |
-						 INDICATION,
-						 (void *)
-						 fifo->
-						 buff);
-				} else
-				    dev_kfree_skb_any
-					(fifo->buff);
-				break;
-				
-			    case HFCUSB_B2_RX:
-				if (hfc->regd.brq[1]) {
-				    skb_queue_tail
-					(hfc->regd.
-					 brq[1],
-					 fifo->buff);
-				    hfc->regd.
-					bch_l1l2(hfc->
-						 regd.
-						 arg_hisax,
-						 1,
-						 PH_DATA
-						 |
-						 INDICATION,
-						 (void
-						  *)
-						 fifo->
-						 buff);
-				} else
-				    dev_kfree_skb_any
-					(fifo->buff);
-				break;
+/*****************************************************/
+/* receive completion routine for all ISO tx fifos   */
+/*****************************************************/
+static void rx_iso_complete(struct urb *urb)
+{
+	iso_urb_struct *context_iso_urb = (iso_urb_struct *) urb->context;
+	usb_fifo *fifo = context_iso_urb->owner_fifo;
+	hfcusb_data *hfc = fifo->hfc;
+	int k, len, errcode, offset, num_isoc_packets,fifon;
+	__u8 *buf;
 
-			    case HFCUSB_PCM_RX:
-				skb_queue_tail(&hfc->regd.
-					       erq,
-					       fifo->buff);
-				test_and_set_bit
-				    (HFCUSB_L1_ERX,
-				     &hfc->l1_event);
-				queue_task(&hfc->l1_tq,
-					   &tq_immediate);
-				mark_bh(IMMEDIATE_BH);
-				break;
+	fifon=fifo->fifonum;
+	// very weird error code when using ohci drivers, for now : ignore this error ...  (MB)
+	if(urb->status == -EOVERFLOW)
+	{
+		urb->status = 0;
+#ifdef VERBOSE_USB_DEBUG
+		printk(KERN_INFO "HFC-USB: ignoring USB DATAOVERRUN  for fifo  %i \n",fifon);
+#endif
+	}
 
-			    default:
-				dev_kfree_skb_any(fifo->
-						  buff);
-				break;
+	if(fifo->active && !urb->status)
+	{
+		num_isoc_packets=iso_packets[fifon];
+
+		// Generate D-Channel Iso Packets
+		for(k = 0; k < num_isoc_packets; ++k)
+		{
+			len=urb->iso_frame_desc[k].actual_length;
+			offset=urb->iso_frame_desc[k].offset;
+			buf=context_iso_urb->buffer+offset;
+
+			if(fifo->last_urblen!=fifo->usb_packet_maxlen)
+			{
+				// the threshold mask is in the 2nd status byte
+				hfc->threshold_mask=buf[1];
+				// the S0 state is in the upper half of the 1st status byte
+				state_handler(hfc,buf[0] >> 4);
+				// if we have more than the 2 status bytes -> collect data
+				if(len>2) collect_rx_frame(fifo,buf+2,len-2,buf[0]&1);
 			}
-			fifo->buff = skb;
-		    } 
-		    fifo->buff->len = 0;	/* reset counter */
-		    fifo->act_ptr = fifo->buff->data;	/* and pointer */
+			else collect_rx_frame(fifo,buf,len,0);
+
+			fifo->last_urblen=len;
+
+        }
+
+		// prepare ISO Urb
+		fill_isoc_urb(urb, fifo->hfc->dev, fifo->pipe,context_iso_urb->buffer, num_isoc_packets,
+			fifo->usb_packet_maxlen, fifo->intervall, rx_iso_complete, urb->context);
+
+		errcode = usb_submit_urb(urb);
+		if(errcode < 0)
+		{
+			printk(KERN_INFO "HFC-USB: error submitting ISO URB: %i \n",  errcode);
+		}
+	}
+	else
+	{
+		if(urb->status)
+		{
+			printk(KERN_INFO "HFC-USB: rx_iso_complete : urb->status %i, fifonum %i\n",  urb->status,fifon);
+		}
+	}
+}				/* rx_iso_complete */
+
+
+/*****************************************************/
+/* collect data from interrupt or isochron in        */
+/*****************************************************/
+static void collect_rx_frame(usb_fifo *fifo,__u8 *data,int len,int finish)
+{
+	hfcusb_data *hfc = fifo->hfc;
+	int transp_mode,fifon;
+
+	fifon=fifo->fifonum;
+	transp_mode=0;
+	if(fifon<4 && hfc->b_mode[fifon/2]==L1_MODE_TRANS) transp_mode=TRUE;
+
+	//printk(KERN_INFO "HFC-USB: got %d bytes finish:%d max_size:%d fifo:%d\n",len,finish,fifo->max_size,fifon);
+	if(!fifo->skbuff)
+	{
+		// allocate sk buffer
+		fifo->skbuff=dev_alloc_skb(fifo->max_size + 3);
+		if(!fifo->skbuff)
+		{
+			printk(KERN_INFO "HFC-USB: cannot allocate buffer (dev_alloc_skb) fifo:%d\n",fifon);
+			return;
+		}
+		
+	}
+
+	if(len && fifo->skbuff->len+len<fifo->max_size)
+	{
+		memcpy(skb_put(fifo->skbuff,len),data,len);
+	}
+	else printk(KERN_INFO "HCF-USB: got frame exceeded fifo->max_size:%d\n",fifo->max_size);
+
+	// give transparent data up, when 128 byte are available
+	if(transp_mode && fifo->skbuff->len>=128)
+	{
+		fifo->hif->l1l2(fifo->hif,PH_DATA | INDICATION,fifo->skbuff);
+		fifo->skbuff = NULL;  // buffer was freed from upper layer
+		return;
+	}
+
+	// we have a complete hdlc packet
+	if(finish)
+	{
+		if(!fifo->skbuff->data[fifo->skbuff->len-1])
+		{
+			skb_trim(fifo->skbuff,fifo->skbuff->len-3);  // remove CRC & status
+
+			//printk(KERN_INFO "HFC-USB: got frame %d bytes on fifo:%d\n",fifo->skbuff->len,fifon);
+
+			if(fifon==HFCUSB_PCM_RX) fifo->hif->l1l2(fifo->hif,PH_DATA_E | INDICATION,fifo->skbuff);
+			else fifo->hif->l1l2(fifo->hif,PH_DATA | INDICATION,fifo->skbuff);
+
+			fifo->skbuff = NULL;  // buffer was freed from upper layer
+		}
+		else
+		{
+			printk(KERN_INFO "HFC-USB: got frame %d bytes but CRC ERROR!!!\n",fifo->skbuff->len);
+
+			skb_trim(fifo->skbuff,0);  // clear whole buffer
+		}
+	}
+
+	// LED flashing only in HDLC mode
+	if(!transp_mode)
+	{
+		if(fifon==HFCUSB_B1_RX) handle_led(hfc,LED_B1_DATA);
+		if(fifon==HFCUSB_B2_RX) handle_led(hfc,LED_B2_DATA);
+	}
+}
+
+/***********************************************/
+/* receive completion routine for all rx fifos */
+/***********************************************/
+static void rx_complete(struct urb *urb)
+{
+	int len;
+	__u8 *buf;
+	usb_fifo *fifo = (usb_fifo *) urb->context;	/* pointer to our fifo */
+	hfcusb_data *hfc = fifo->hfc;
+
+	urb->dev = hfc->dev;	/* security init */
+
+	if((!fifo->active) || (urb->status)) {
+#ifdef VERBOSE_USB_DEBUG
+		printk(KERN_INFO "HFC-USB: RX-Fifo %i is going down (%i)\n", fifo->fifonum, urb->status);
+#endif
+		fifo->urb->interval = 0;	/* cancel automatic rescheduling */
+		if(fifo->skbuff) {
+			dev_kfree_skb_any(fifo->skbuff);
+			fifo->skbuff = NULL;
 		}
+		return;
 	}
-	fifo->rx_offset = (urb->actual_length < fifo->usb_maxlen) ? 2 : 0;
-}				/* rx_complete */
+
+	len=urb->actual_length;
+	buf=fifo->buffer;
+
+	if(fifo->last_urblen!=fifo->usb_packet_maxlen) {
+		// the threshold mask is in the 2nd status byte
+		hfc->threshold_mask=buf[1];
+		// the S0 state is in the upper half of the 1st status byte
+		state_handler(hfc,buf[0] >> 4);
+		// if we have more than the 2 status bytes -> collect data
+		if(len>2) collect_rx_frame(fifo,buf+2,urb->actual_length-2,buf[0]&1);
+	} else
+		collect_rx_frame(fifo,buf,urb->actual_length,0);
+
+	fifo->last_urblen=urb->actual_length;
+
+
+}	/* rx_complete */
+
+
 
 /***************************************************/
 /* start the interrupt transfer for the given fifo */
 /***************************************************/
-static void
-start_rx_fifo(usb_fifo * fifo)
+static void start_int_fifo(usb_fifo * fifo)
 {
-	if (fifo->buff)
-		return;		/* still active */
-	if (!
-	    (fifo->buff =
-	     dev_alloc_skb(fifo->max_size + (fifo->transmode ? 0 : 3))))
-		return;
-	fifo->act_ptr = fifo->buff->data;
-	FILL_INT_URB(&fifo->urb, fifo->hfc->dev, fifo->pipe, fifo->buffer,
-		     fifo->usb_maxlen, rx_complete, fifo, fifo->intervall);
-	fifo->next_complete = 0;
-	fifo->rx_offset = 2;
-	fifo->active = 1;	/* must be marked active */
-	fifo->hfc->active_fifos |= fifo->fifo_mask;
-	if (usb_submit_urb(&fifo->urb)) {
+	int errcode;
+
+#ifdef VERBOSE_USB_DEBUG
+	printk(KERN_INFO "HFC-USB: starting intr IN fifo:%d\n", fifo->fifonum);
+#endif
+	if (!fifo->urb) {
+		fifo->urb = usb_alloc_urb(0);
+		if (!fifo->urb)
+			return;
+	}
+	usb_fill_int_urb(fifo->urb, fifo->hfc->dev, fifo->pipe, fifo->buffer,
+				 fifo->usb_packet_maxlen, rx_complete, fifo, fifo->intervall);
+	fifo->active = 1;		/* must be marked active */
+	errcode = usb_submit_urb(fifo->urb);
+
+	if(errcode)
+	{
+		printk(KERN_INFO "HFC-USB: submit URB error(start_int_info): status:%i\n",   errcode);
 		fifo->active = 0;
-		fifo->hfc->active_fifos &= ~fifo->fifo_mask;
-		dev_kfree_skb_any(fifo->buff);
-		fifo->buff = NULL;
+		fifo->skbuff = NULL;
 	}
-}				/* start_rx_fifo */
+} /* start_int_fifo */
 
-/***************************************************************/
-/* control completion routine handling background control cmds */
-/***************************************************************/
-static void
-ctrl_complete(purb_t urb)
+/*****************************/
+/* set the B-channel mode    */
+/*****************************/
+static void set_hfcmode(hfcusb_data *hfc,int channel,int mode)
 {
-	hfcusb_data *hfc = (hfcusb_data *) urb->context;
+	__u8 val,idx_table[2]={0,2};
 
-	urb->dev = hfc->dev;
-	if (hfc->ctrl_cnt) {
-		switch (hfc->ctrl_buff[hfc->ctrl_out_idx].hfc_reg) {
-			case HFCUSB_FIFO:
-				hfc->ctrl_fifo =
-				    hfc->ctrl_buff[hfc->ctrl_out_idx].
-				    reg_val;
-				break;
-			case HFCUSB_F_USAGE:
-				if (!hfc->dfifo_fill) {
-					fill_tx_urb(hfc->fifos +
-						    HFCUSB_D_TX);
-					if (hfc->fifos[HFCUSB_D_TX].buff)
-						usb_submit_urb(&hfc->
-							       fifos
-							       [HFCUSB_D_TX].
-							       urb);
-				} else {
-					queue_control_request(hfc,
-							      HFCUSB_FIFO,
-							      HFCUSB_D_TX);
-					queue_control_request(hfc,
-							      HFCUSB_F_USAGE,
-							      0);
-				}
-				break;
-			case HFCUSB_SCTRL_R:
-				switch (hfc->ctrl_fifo) {
-					case HFCUSB_B1_RX:
-						if (hfc->bch_enables & 1)
-							start_rx_fifo(hfc->
-								      fifos
-								      +
-								      HFCUSB_B1_RX);
-						break;
-					case HFCUSB_B2_RX:
-						if (hfc->bch_enables & 2)
-							start_rx_fifo(hfc->
-								      fifos
-								      +
-								      HFCUSB_B2_RX);
-						break;
-				}
-				if (hfc->bch_enables & 3)
-				    hfc->led_req |= LED_BCH;
-				else
-				    hfc->led_req &= ~LED_BCH;
-				break;
-			case HFCUSB_P_DATA:
-				hfc->led_act =
-				    hfc->ctrl_buff[hfc->ctrl_out_idx].
-				    reg_val;
-				break;
-		}
-		hfc->ctrl_cnt--;	/* decrement actual count */
-		if (++hfc->ctrl_out_idx >= HFC_CTRL_BUFSIZE)
-			hfc->ctrl_out_idx = 0;	/* pointer wrap */
-		ctrl_start_transfer(hfc);	/* start next transfer */
+#ifdef VERBOSE_ISDN_DEBUG
+  printk (KERN_INFO "HFC-USB: setting channel %d to mode %d\n",channel,mode);
+#endif
+
+	hfc->b_mode[channel]=mode;
+
+	// setup CON_HDLC
+	val=0;
+	if(mode!=L1_MODE_NULL) val=8;    // enable fifo?
+	if(mode==L1_MODE_TRANS) val|=2;  // set transparent bit
+
+	queue_control_request(hfc,HFCUSB_FIFO,idx_table[channel],1); // set FIFO to transmit register
+	queue_control_request(hfc,HFCUSB_CON_HDLC,val,1);
+	queue_control_request(hfc,HFCUSB_INC_RES_F,2,1); // reset fifo
+
+	queue_control_request(hfc,HFCUSB_FIFO,idx_table[channel]+1,1); // set FIFO to receive register
+	queue_control_request(hfc,HFCUSB_CON_HDLC,val,1);
+	queue_control_request(hfc,HFCUSB_INC_RES_F,2,1);  // reset fifo
+
+	val=0x40;
+	if(hfc->b_mode[0]) val|=1;
+	if(hfc->b_mode[1]) val|=2;
+	queue_control_request(hfc,HFCUSB_SCTRL,val,1);
+
+	val=0;
+	if(hfc->b_mode[0]) val|=1;
+	if(hfc->b_mode[1]) val|=2;
+	queue_control_request(hfc,HFCUSB_SCTRL_R,val,1);
+
+	if(mode==L1_MODE_NULL)
+	{
+		if(channel) handle_led(hfc,LED_B2_OFF);
+		else handle_led(hfc,LED_B1_OFF);
 	}
-}				/* ctrl_complete */
+	else
+	{
+		if(channel) handle_led(hfc,LED_B2_ON);
+		else handle_led(hfc,LED_B1_ON);
+	}
+}
 
-/*****************************************/
-/* Layer 1 + D channel access from HiSax */
-/*****************************************/
-static void
-hfcusb_l1_access(void *drvarg, int pr, void *arg)
-{
-	hfcusb_data *hfc = (hfcusb_data *) drvarg;
-
-	switch (pr) {
-		case (PH_DATA | REQUEST):
-		case (PH_PULL | INDICATION):
-			skb_queue_tail(hfc->regd.dsq,
-				       (struct sk_buff *) arg);
-			if (!hfc->fifos[HFCUSB_D_TX].active
-			    && !hfc->dfifo_fill) {
-				fill_tx_urb(hfc->fifos + HFCUSB_D_TX);
-				hfc->active_fifos |=
-				    hfc->fifos[HFCUSB_D_TX].fifo_mask;
-				usb_submit_urb(&hfc->fifos[HFCUSB_D_TX].
-					       urb);
-			}
-			break;
-		case (PH_ACTIVATE | REQUEST):
-		    switch (hfc->l1_state) {
-			case 6:
-			case 8:
-				hfc->regd.dch_l1l2(hfc->regd.arg_hisax,
-						   (PH_DEACTIVATE |
-						   INDICATION), NULL);
+/*
+   --------------------------------------------------------------------------------------
+   from here : hisax_if callback routines :
+     - void hfc_usb_d_l2l1(struct hisax_if *hisax_d_if, int pr, void *arg) {
 
-				break;
-			case 7:
-				hfc->regd.dch_l1l2(hfc->regd.arg_hisax,
-						   (PH_ACTIVATE |
-						   INDICATION), NULL);
+   l1 to l2 routines :
+     - static void hfc_usb_l1l2(hfcusb_data * hfc)
 
-				break;
-			default:
-				queue_control_request(hfc, HFCUSB_STATES, 0x60);	/* start activation */
-				hfc->t3_timer.expires =
-				    jiffies + (HFC_TIMER_T3 * HZ) / 1000;
-				if (!timer_pending(&hfc->t3_timer))
-					add_timer(&hfc->t3_timer);
-				break;
-		    }
-		    break;
+*/
 
-		case (PH_DEACTIVATE | REQUEST):
-			queue_control_request(hfc, HFCUSB_STATES, 0x40);	/* start deactivation */
-			break;
-		default:
-			printk(KERN_INFO "unknown hfcusb l1_access 0x%x\n",
-			       pr);
-			break;
-	}
-}				/* hfcusb_l1_access */
-
-/*******************************/
-/* B channel access from HiSax */
-/*******************************/
-static void
-hfcusb_bch_access(void *drvarg, int chan, int pr, void *arg)
-{
-	hfcusb_data *hfc = (hfcusb_data *) drvarg;
-	usb_fifo *fifo = hfc->fifos + (chan ? HFCUSB_B2_TX : HFCUSB_B1_TX);
-	long flags;
-
-	switch (pr) {
-		case (PH_DATA | REQUEST):
-		case (PH_PULL | INDICATION):
-			save_flags(flags);
-			cli();
-			if (!fifo->active) {
-				fill_tx_urb(fifo);
-				hfc->active_fifos |= fifo->fifo_mask;
-				usb_submit_urb(&fifo->urb);
-			}
-			restore_flags(flags);
-			break;
-		case (PH_ACTIVATE | REQUEST):
-			if (!((int) arg)) {
-				hfc->bch_enables &= ~(1 << chan);
-				if (fifo->active) {
-					fifo->active = 0;
-					usb_unlink_urb(&fifo->urb);
+void hfc_usb_l2l1(struct hisax_if *my_hisax_if, int pr, void *arg)
+{
+    usb_fifo *fifo = my_hisax_if->priv;
+	hfcusb_data *hfc = fifo->hfc;
+
+    switch (pr) {
+		case PH_ACTIVATE | REQUEST:
+				if(fifo->fifonum==HFCUSB_D_TX)
+				{
+#ifdef VERBOSE_ISDN_DEBUG
+					printk (KERN_INFO "HFC_USB: hfc_usb_d_l2l1 D-chan: PH_ACTIVATE | REQUEST\n");
+#endif
+					queue_control_request(hfc, HFCUSB_STATES,0x60,1);	/* make activation */
+					hfc->t3_timer.expires = jiffies + (HFC_TIMER_T3 * HZ) / 1000;
+					if(!timer_pending(&hfc->t3_timer)) add_timer(&hfc->t3_timer);
 				}
-				save_flags(flags);
-				cli();
-				queue_control_request(hfc, HFCUSB_FIFO,
-						      fifo->fifonum);
-				queue_control_request(hfc,
-						      HFCUSB_INC_RES_F, 2);
-				queue_control_request(hfc, HFCUSB_CON_HDLC,
-						      9);
-				queue_control_request(hfc, HFCUSB_SCTRL,
-						      0x40 +
-						      hfc->bch_enables);
-				queue_control_request(hfc, HFCUSB_SCTRL_R,
-						      hfc->bch_enables);
-				restore_flags(flags);
-				fifo++;
-				if (fifo->active) {
-					fifo->active = 0;
-					usb_unlink_urb(&fifo->urb);
+				else
+				{
+#ifdef VERBOSE_ISDN_DEBUG
+					printk (KERN_INFO "HFC_USB: hfc_usb_d_l2l1 Bx-chan: PH_ACTIVATE | REQUEST\n");
+#endif
+					set_hfcmode(hfc,(fifo->fifonum==HFCUSB_B1_TX) ? 0 : 1 ,(int)arg);
+					fifo->hif->l1l2(fifo->hif,PH_ACTIVATE | INDICATION, NULL);
 				}
-				return;	/* fifo deactivated */
-			}
-			fifo->transmode = ((int) arg == L1_MODE_TRANS);
-			fifo->max_size =
-			    ((fifo->transmode) ? fifo->
-			     usb_maxlen : MAX_BCH_SIZE);
-			(fifo + 1)->transmode = fifo->transmode;
-			(fifo + 1)->max_size = fifo->max_size;
-			hfc->bch_enables |= (1 << chan);
-			save_flags(flags);
-			cli();
-			queue_control_request(hfc, HFCUSB_FIFO,
-					      fifo->fifonum);
-			queue_control_request(hfc, HFCUSB_CON_HDLC,
-					      ((!fifo->
-						transmode) ? 9 : 11));
-			queue_control_request(hfc, HFCUSB_INC_RES_F, 2);
-			queue_control_request(hfc, HFCUSB_SCTRL,
-					      0x40 + hfc->bch_enables);
-			if ((int) arg == L1_MODE_HDLC)
-				queue_control_request(hfc, HFCUSB_CON_HDLC,
-						      8);
-			queue_control_request(hfc, HFCUSB_FIFO,
-					      fifo->fifonum + 1);
-			queue_control_request(hfc, HFCUSB_CON_HDLC,
-					      ((!fifo->
-						transmode) ? 8 : 10));
-			queue_control_request(hfc, HFCUSB_INC_RES_F, 2);
-			queue_control_request(hfc, HFCUSB_SCTRL_R,
-					      hfc->bch_enables);
-			restore_flags(flags);
-
-			break;
-
-		default:
-			printk(KERN_INFO
-			       "unknown hfcusb bch_access chan %d 0x%x\n",
-			       chan, pr);
-			break;
-	}
-}				/* hfcusb_bch_access */
+                break;
+        case PH_DEACTIVATE | REQUEST:
+				if(fifo->fifonum==HFCUSB_D_TX)
+				{
+#ifdef VERBOSE_ISDN_DEBUG
+					printk (KERN_INFO "HFC_USB: hfc_usb_d_l2l1 D-chan: PH_DEACTIVATE | REQUEST\n");
+#endif
+					printk (KERN_INFO "HFC-USB: ISDN TE device should not deativate...\n");
+				}
+				else
+				{
+#ifdef VERBOSE_ISDN_DEBUG
+					printk (KERN_INFO "HFC_USB: hfc_usb_d_l2l1 Bx-chan: PH_DEACTIVATE | REQUEST\n");
+#endif
+					set_hfcmode(hfc,(fifo->fifonum==HFCUSB_B1_TX) ? 0 : 1 ,(int)L1_MODE_NULL);
+					fifo->hif->l1l2(fifo->hif,PH_DEACTIVATE | INDICATION, NULL);
+				}
+                break;
+		case PH_DATA | REQUEST:
+				if(fifo->skbuff && fifo->delete_flg)
+				{
+					dev_kfree_skb_any(fifo->skbuff);
+					//printk(KERN_INFO "skbuff=NULL on fifo:%d\n",fifo->fifonum);
+					fifo->skbuff = NULL;
+					fifo->delete_flg=FALSE;
+				}
+
+				fifo->skbuff=arg; // we have a new buffer
+
+				//if(fifo->fifonum==HFCUSB_D_TX) printk (KERN_INFO "HFC_USB: hfc_usb_d_l2l1 D-chan: PH_DATA | REQUEST\n");
+				//else printk (KERN_INFO "HFC_USB: hfc_usb_d_l2l1 Bx-chan: PH_DATA | REQUEST\n");
+                break;
+        default:
+                printk (KERN_INFO "HFC_USB: hfc_usb_d_l2l1: unkown state : %#x\n", pr);
+                break;
+    }
+}
+
+// valid configurations
+#define CNF_4INT3ISO  1      // 4 INT IN, 3 ISO OUT
+#define CNF_3INT3ISO  2      // 3 INT IN, 3 ISO OUT
+#define CNF_4ISO3ISO  3      // 4 ISO IN, 3 ISO OUT
+#define CNF_3ISO3ISO  4 	 // 3 ISO IN, 3 ISO OUT
+
+
+/*
+   --------------------------------------------------------------------------------------
+   From here on USB initialization and deactivation related routines are implemented :
+
+   - hfc_usb_init :
+      is the main Entry Point for the USB Subsystem when the device get plugged
+      in. This function calls usb_register with usb_driver as parameter.
+      Here, further entry points for probing (hfc_usb_probe) and disconnecting
+      the device (hfc_usb_disconnect) are published, as the id_table
+
+   - hfc_usb_probe
+      this function is called by the usb subsystem, and steps through the alternate
+      settings of the currently plugged in device to detect all Endpoints needed to
+      run an ISDN TA.
+      Needed EndPoints are
+      3 (+1) IntIn EndPoints   (D-in,  E-in, B1-in, B2-in, (E-in)) or
+      3 (+1) Isochron In Endpoints (D-out, B1-out, B2-out) and 3 IsoOut Endpoints
+      The currently used transfer mode of on the Out-Endpoints will be stored in
+      hfc->usb_transfer_mode and is either USB_INT or USB_ISO
+      When a valid alternate setting could be found, the usb_init (see blow)
+      function is called
+
+   - usb_init
+      Here, the HFC_USB Chip itself gets initialized and the USB framework to send/receive
+      Data to/from the several EndPoints are initialized:
+       The E- and D-Channel Int-In chain gets started
+       The IsoChain for the Iso-Out traffic get started
+
+   - hfc_usb_disconnect
+      this function is called by the usb subsystem and has to free all resources
+      and stop all usb traffic to allow a proper hotplugging disconnect.
+
+*/
 
 /***************************************************************************/
 /* usb_init is called once when a new matching device is detected to setup */
-/* main parmeters. It registers the driver at the main hisax module.       */
+/* main parameters. It registers the driver at the main hisax module.       */
 /* on success 0 is returned.                                               */
 /***************************************************************************/
-static int
-usb_init(hfcusb_data * hfc)
+static int usb_init(hfcusb_data * hfc)
 {
 	usb_fifo *fifo;
-	int i;
+	int i, err;
 	u_char b;
-
+	struct hisax_b_if *p_b_if[2];
+	
 	/* check the chip id */
-	if ((Read_hfc(hfc, HFCUSB_CHIP_ID, &b) != 1) ||
-	    (b != HFCUSB_CHIPID)) {
+	printk(KERN_INFO "HFCUSB_CHIP_ID begin\n");
+	if (read_usb(hfc, HFCUSB_CHIP_ID, &b) != 1) {
+		printk(KERN_INFO "HFC-USB: cannot read chip id\n");
+		return(1); 
+	}
+	printk(KERN_INFO "HFCUSB_CHIP_ID %x\n", b);
+	if (b != HFCUSB_CHIPID) {
 		printk(KERN_INFO "HFC-USB: Invalid chip id 0x%02x\n", b);
-		return (1);
+		return(1);
 	}
 
 	/* first set the needed config, interface and alternate */
-	usb_set_configuration(hfc->dev, 1);
-	usb_set_interface(hfc->dev, hfc->if_used, hfc->alt_used);
+	printk(KERN_INFO "usb_init 1\n");
+//	usb_set_configuration(hfc->dev, 1);
+	printk(KERN_INFO "usb_init 2\n");
+	err = usb_set_interface(hfc->dev, hfc->if_used, hfc->alt_used);
+	printk(KERN_INFO "usb_init usb_set_interface return %d\n", err);
+	/* now we initialize the chip */
+	write_usb(hfc, HFCUSB_CIRM, 8);	    // do reset
+	write_usb(hfc, HFCUSB_CIRM, 0x10);	// aux = output, reset off
 
-        /* init the led state request */
-	hfc->led_req = LED_DRIVER;
+	// set USB_SIZE to match the the wMaxPacketSize for INT or BULK transfers
+	write_usb(hfc, HFCUSB_USB_SIZE,(hfc->packet_size/8) | ((hfc->packet_size/8) << 4));
 
-	/* now we initialise the chip */
-	Write_hfc(hfc, HFCUSB_CIRM, 0x10);	/* aux = output, reset off */
-	Write_hfc(hfc, HFCUSB_P_DATA, 0);       /* leds = off */
-	Write_hfc(hfc, HFCUSB_USB_SIZE,
-		  (hfc->fifos[HFCUSB_B1_TX].usb_maxlen >> 3) |
-		  ((hfc->fifos[HFCUSB_B1_RX].usb_maxlen >> 3) << 4));
+	// set USB_SIZE_I to match the the wMaxPacketSize for ISO transfers
+	write_usb(hfc, HFCUSB_USB_SIZE_I, hfc->iso_packet_size);
 
 	/* enable PCM/GCI master mode */
-	Write_hfc(hfc, HFCUSB_MST_MODE1, 0);	/* set default values */
-	Write_hfc(hfc, HFCUSB_MST_MODE0, 1);	/* enable master mode */
+	write_usb(hfc, HFCUSB_MST_MODE1, 0);	/* set default values */
+	write_usb(hfc, HFCUSB_MST_MODE0, 1);	/* enable master mode */
 
 	/* init the fifos */
-	Write_hfc(hfc, HFCUSB_F_THRES, (HFCUSB_TX_THRESHOLD >> 3) |
-		  ((HFCUSB_RX_THRESHOLD >> 3) << 4));
+	write_usb(hfc, HFCUSB_F_THRES, (HFCUSB_TX_THRESHOLD/8) |((HFCUSB_RX_THRESHOLD/8) << 4));
 
-	for (i = 0, fifo = hfc->fifos + i; i < HFCUSB_NUM_FIFOS;
-	     i++, fifo++) {
-		Write_hfc(hfc, HFCUSB_FIFO, i);	/* select the desired fifo */
-
-		fifo->transmode = 0;	/* hdlc mode selected */
-		fifo->buff = NULL;	/* init buffer pointer */
-		fifo->max_size =
-		    (i <= HFCUSB_B2_RX) ? MAX_BCH_SIZE : MAX_DFRAME_LEN;
-		Write_hfc(hfc, HFCUSB_HDLC_PAR, ((i <= HFCUSB_B2_RX) ? 0 : 2));	/* data length */
-		Write_hfc(hfc, HFCUSB_CON_HDLC, ((i & 1) ? 0x08 : 0x09));	/* rx hdlc, tx fill 1 */
-		Write_hfc(hfc, HFCUSB_INC_RES_F, 2);	/* reset the fifo */
-	}
-
-	Write_hfc(hfc, HFCUSB_CLKDEL, 0x0f);	/* clock delay value */
-	Write_hfc(hfc, HFCUSB_STATES, 3 | 0x10);	/* set deactivated mode */
-	Write_hfc(hfc, HFCUSB_STATES, 3);	/* enable state machine */
+	fifo = hfc->fifos;
+	for(i = 0; i < HFCUSB_NUM_FIFOS; i++)
+	{
+		write_usb(hfc, HFCUSB_FIFO, i);	/* select the desired fifo */
+		fifo[i].skbuff = NULL;	/* init buffer pointer */
+		fifo[i].max_size = (i <= HFCUSB_B2_RX) ? MAX_BCH_SIZE : MAX_DFRAME_LEN;
+		fifo[i].last_urblen=0;
+		write_usb(hfc, HFCUSB_HDLC_PAR, ((i <= HFCUSB_B2_RX) ? 0 : 2));	    // set 2 bit for D- & E-channel
+		write_usb(hfc, HFCUSB_CON_HDLC, ((i==HFCUSB_D_TX) ? 0x09 : 0x08));	// rx hdlc, enable IFF for D-channel
+		write_usb(hfc, HFCUSB_INC_RES_F, 2);	/* reset the fifo */
+	}
 
-	Write_hfc(hfc, HFCUSB_SCTRL_R, 0);	/* disable both B receivers */
-	Write_hfc(hfc, HFCUSB_SCTRL, 0x40);	/* disable B transmitters + cap mode */
+	write_usb(hfc, HFCUSB_CLKDEL, 0x0f);	 /* clock delay value */
+	write_usb(hfc, HFCUSB_STATES, 3 | 0x10); /* set deactivated mode */
+	write_usb(hfc, HFCUSB_STATES, 3);	     /* enable state machine */
+
+	write_usb(hfc, HFCUSB_SCTRL_R, 0);	     /* disable both B receivers */
+	write_usb(hfc, HFCUSB_SCTRL, 0x40);	     /* disable B transmitters + capacitive mode */
+
+	// set both B-channel to not connected
+	hfc->b_mode[0]=L1_MODE_NULL;
+	hfc->b_mode[1]=L1_MODE_NULL;
+
+	hfc->l1_activated=FALSE;
+	hfc->led_state=0;
+	hfc->led_new_data=0;
 
-	/* init the l1 timer */
+	/* init the t3 timer */
 	init_timer(&hfc->t3_timer);
 	hfc->t3_timer.data = (long) hfc;
-	hfc->t3_timer.function = (void *) l1_timer_expire;
+	hfc->t3_timer.function = (void *) l1_timer_expire_t3;
+	/* init the t4 timer */
+	init_timer(&hfc->t4_timer);
 	hfc->t4_timer.data = (long) hfc;
-	hfc->t4_timer.function = (void *) l1_timer_expire;
-	hfc->l1_tq.routine = (void *) (void *) usb_l1d_bh;
-	hfc->l1_tq.sync = 0;
-	hfc->l1_tq.data = hfc;
-
-	/* init the background control machinery */
-	hfc->ctrl_read.requesttype = 0xc0;
-	hfc->ctrl_read.request = 1;
-	hfc->ctrl_read.length = 1;
-	hfc->ctrl_write.requesttype = 0x40;
-	hfc->ctrl_write.request = 0;
-	hfc->ctrl_write.length = 0;
-	FILL_CONTROL_URB(&hfc->ctrl_urb, hfc->dev, hfc->ctrl_out_pipe,
-			 (u_char *) & hfc->ctrl_write, NULL, 0,
-			 ctrl_complete, hfc);
-
-	/* init the TX-urbs */
-	fifo = hfc->fifos + HFCUSB_D_TX;
-	FILL_BULK_URB(&fifo->urb, hfc->dev, fifo->pipe,
-		      (u_char *) fifo->buffer, 0, tx_complete, fifo);
-	fifo = hfc->fifos + HFCUSB_B1_TX;
-	FILL_BULK_URB(&fifo->urb, hfc->dev, fifo->pipe,
-		      (u_char *) fifo->buffer, 0, tx_complete, fifo);
-	fifo = hfc->fifos + HFCUSB_B2_TX;
-	FILL_BULK_URB(&fifo->urb, hfc->dev, fifo->pipe,
-		      (u_char *) fifo->buffer, 0, tx_complete, fifo);
-
-	/* init the E-buffer */
-	skb_queue_head_init(&hfc->regd.erq);
-
-	/* now register ourself at hisax */
-	hfc->regd.version = HISAX_LOAD_VERSION;	/* set our version */
-	hfc->regd.cmd = HISAX_LOAD_REGISTER;	/* register command */
-	hfc->regd.argl1 = (void *) hfc;	/* argument for our local routine */
-	hfc->regd.dch_l2l1 = hfcusb_l1_access;
-	hfc->regd.bch_l2l1 = hfcusb_bch_access;
-	hfc->regd.drvname = "hfc_usb";
-	if (hisax_register_hfcusb(&hfc->regd)) {
-		printk(KERN_INFO "HFC-USB failed to register at hisax\n");
-		Write_hfc(hfc, HFCUSB_CIRM, 0x08);	/* aux = input, reset on */
-		return (1);
-	}
-
-	/* startup the D- and E-channel fifos */
-	start_rx_fifo(hfc->fifos + HFCUSB_D_RX);	/* D-fifo */
-	if (hfc->fifos[HFCUSB_PCM_RX].pipe)
-		start_rx_fifo(hfc->fifos + HFCUSB_PCM_RX);	/* E-fifo */
+	hfc->t4_timer.function = (void *) l1_timer_expire_t4;
+	/* init the led timer */
+	init_timer(&hfc->led_timer);
+	hfc->led_timer.data = (long) hfc;
+	hfc->led_timer.function = (void *) led_timer;
+	// trigger 4 hz led timer
+	hfc->led_timer.expires = jiffies + (LED_TIME * HZ) / 1000;
+	if(!timer_pending(&hfc->led_timer)) add_timer(&hfc->led_timer);
+
+	// init the background machinery for control requests
+	hfc->ctrl_read.bRequestType = 0xc0;
+	hfc->ctrl_read.bRequest = 1;
+	hfc->ctrl_read.wLength = 1;
+	hfc->ctrl_write.bRequestType = 0x40;
+	hfc->ctrl_write.bRequest = 0;
+	hfc->ctrl_write.wLength = 0;
+	usb_fill_control_urb(hfc->ctrl_urb, hfc->dev, hfc->ctrl_out_pipe,(u_char *) & hfc->ctrl_write, NULL, 0, ctrl_complete, hfc);
+					
+	/* Init All Fifos */
+	for(i = 0; i < HFCUSB_NUM_FIFOS; i++)
+	{
+		hfc->fifos[i].iso[0].purb = NULL;
+		hfc->fifos[i].iso[1].purb = NULL;
+		hfc->fifos[i].active = 0;
+	}
+
+	// register like Germaschewski :
+	hfc->d_if.owner = THIS_MODULE;
+	hfc->d_if.ifc.priv = &hfc->fifos[HFCUSB_D_TX];
+	hfc->d_if.ifc.l2l1 = hfc_usb_l2l1;
+
+	for (i=0; i<2; i++)
+	{
+		hfc->b_if[i].ifc.priv = &hfc->fifos[HFCUSB_B1_TX+i*2];
+		hfc->b_if[i].ifc.l2l1 = hfc_usb_l2l1;
+		p_b_if[i] = &hfc->b_if[i];
+	}
+	
+	hfc->protocol = 2;  /* default EURO ISDN, should be a module_param */
+	hisax_register(&hfc->d_if, p_b_if, "hfc_usb", hfc->protocol);
+	
+	for (i=0; i<4; i++)
+		hfc->fifos[i].hif=&p_b_if[i/2]->ifc;
+	for (i=4; i<8; i++)
+		hfc->fifos[i].hif=&hfc->d_if.ifc;
+
+	// 3 (+1) INT IN + 3 ISO OUT
+	if(hfc->cfg_used == CNF_3INT3ISO || hfc->cfg_used == CNF_4INT3ISO)
+	{
+		start_int_fifo(hfc->fifos + HFCUSB_D_RX);	// Int IN D-fifo
+		if(hfc->fifos[HFCUSB_PCM_RX].pipe) start_int_fifo(hfc->fifos + HFCUSB_PCM_RX);	// E-fifo
+		start_int_fifo(hfc->fifos + HFCUSB_B1_RX);	// Int IN B1-fifo
+		start_int_fifo(hfc->fifos + HFCUSB_B2_RX);	// Int IN B2-fifo
+	}
+
+	// 3 (+1) ISO IN + 3 ISO OUT
+	if(hfc->cfg_used==CNF_3ISO3ISO || hfc->cfg_used==CNF_4ISO3ISO)
+	{
+		start_isoc_chain(hfc->fifos + HFCUSB_D_RX, ISOC_PACKETS_D, rx_iso_complete,16);
+		if(hfc->fifos[HFCUSB_PCM_RX].pipe) start_isoc_chain(hfc->fifos + HFCUSB_PCM_RX, ISOC_PACKETS_D, rx_iso_complete,16);
+		start_isoc_chain(hfc->fifos + HFCUSB_B1_RX, ISOC_PACKETS_B, rx_iso_complete,16);
+		start_isoc_chain(hfc->fifos + HFCUSB_B2_RX, ISOC_PACKETS_B, rx_iso_complete,16);
+	}
+
+	start_isoc_chain(hfc->fifos + HFCUSB_D_TX, ISOC_PACKETS_D, tx_iso_complete,1);
+	start_isoc_chain(hfc->fifos + HFCUSB_B1_TX, ISOC_PACKETS_B, tx_iso_complete,1);
+	start_isoc_chain(hfc->fifos + HFCUSB_B2_TX, ISOC_PACKETS_B, tx_iso_complete,1);
+
+	handle_led(hfc,LED_POWER_ON);
+
+	return(0);
+}	/* usb_init */
+
+
+/****************************************/
+/* data defining the devices to be used */
+/****************************************/
+// static __devinitdata const struct usb_device_id hfc_usb_idtab[3] = {
+static struct usb_device_id hfc_usb_idtab[] = {
+	{USB_DEVICE(0x7b0, 0x0007)},	/* Billion USB TA 2 */
+	{USB_DEVICE(0x742, 0x2008)},	/* Stollmann USB TA */
+	{USB_DEVICE(0x959, 0x2bd0)},	/* Colognechip USB eval TA */
+	{USB_DEVICE(0x8e3, 0x0301)},	/* OliTec ISDN USB */
+	{USB_DEVICE(0x675, 0x1688)},	/* DrayTec ISDN USB */
+	{USB_DEVICE(0x7fa, 0x0846)},    /* Bewan ISDN USB TA */
+	{}				/* end with an all-zeroes entry */
+};
+
+MODULE_AUTHOR("Peter Sprenger (sprenger@moving-byters.de)/Martin Bachem (info@colognechip.com)");
+MODULE_DESCRIPTION("HFC I4L USB driver");
+MODULE_DEVICE_TABLE(usb, hfc_usb_idtab);
+MODULE_LICENSE("GPL");
+
+#define EP_NUL 1    // Endpoint at this position not allowed
+#define EP_NOP 2	// all type of endpoints allowed at this position
+#define EP_ISO 3	// Isochron endpoint mandatory at this position
+#define EP_BLK 4	// Bulk endpoint mandatory at this position
+#define EP_INT 5	// Interrupt endpoint mandatory at this position
+
+// this array represents all endpoints possible in the HCF-USB
+// the last 2 entries are the configuration number and the minimum interval for Interrupt endpoints
+int validconf[][18]=
+{
+	// INT in, ISO out config
+	{EP_NUL,EP_INT,EP_NUL,EP_INT,EP_NUL,EP_INT,EP_NOP,EP_INT,EP_ISO,EP_NUL,EP_ISO,EP_NUL,EP_ISO,EP_NUL,EP_NUL,EP_NUL,CNF_4INT3ISO,2},
+	{EP_NUL,EP_INT,EP_NUL,EP_INT,EP_NUL,EP_INT,EP_NUL,EP_NUL,EP_ISO,EP_NUL,EP_ISO,EP_NUL,EP_ISO,EP_NUL,EP_NUL,EP_NUL,CNF_3INT3ISO,2},
+	// ISO in, ISO out config
+	{EP_NUL,EP_NUL,EP_NUL,EP_NUL,EP_NUL,EP_NUL,EP_NUL,EP_NUL,EP_ISO,EP_ISO,EP_ISO,EP_ISO,EP_ISO,EP_ISO,EP_NOP,EP_ISO,CNF_4ISO3ISO,2},
+	{EP_NUL,EP_NUL,EP_NUL,EP_NUL,EP_NUL,EP_NUL,EP_NUL,EP_NUL,EP_ISO,EP_ISO,EP_ISO,EP_ISO,EP_ISO,EP_ISO,EP_NUL,EP_NUL,CNF_3ISO3ISO,2},
+	{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}       // EOL element
+};
+
+// string description of chosen config
+char *conf_str[]=
+{
+	"4 Interrupt IN + 3 Isochron OUT",
+	"3 Interrupt IN + 3 Isochron OUT",
+	"4 Isochron IN + 3 Isochron OUT",
+	"3 Isochron IN + 3 Isochron OUT"
+};
 
-	return (0);
-}				/* usb_init */
 
 /*************************************************/
 /* function called to probe a new plugged device */
 /*************************************************/
-static void *
-hfc_usb_probe(struct usb_device *dev, unsigned int interface
-#ifdef COMPAT_HAS_USB_IDTAB
-	      , const struct usb_device_id *id_table)
-#else
-    )
-#endif
+//static int hfc_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
+static void* hfc_usb_probe(struct usb_device *dev, unsigned int ifnum, const struct usb_device_id *id)
 {
+        //struct usb_device *dev= interface_to_usbdev(intf);
+	struct usb_interface* intf = dev->actconfig->interface + ifnum;
 	hfcusb_data *context;
-	struct usb_interface *ifp = dev->actconfig->interface + interface;
-	struct usb_interface_descriptor *ifdp =
-	    ifp->altsetting + ifp->act_altsetting;
-	struct usb_endpoint_descriptor *epd;
-	int i, idx, ep_msk;
-
-#ifdef COMPAT_HAS_USB_IDTAB
-	if (id_table && (dev->descriptor.idVendor == id_table->idVendor) &&
-	    (dev->descriptor.idProduct == id_table->idProduct) &&
-#else
-	if ((((dev->descriptor.idVendor == 0x959) &&
-	    (dev->descriptor.idProduct == 0x2bd0)) ||
-	    ((dev->descriptor.idVendor == 0x7b0) &&
-	    (dev->descriptor.idProduct == 0x0006))) &&
-#endif
-	    (ifdp->bNumEndpoints >= 6) && (ifdp->bNumEndpoints <= 16)) {
-		if (!(context = kmalloc(sizeof(hfcusb_data), GFP_KERNEL))) {
-			return (NULL);	/* got no mem */
-		};
-		memset(context, 0, sizeof(hfcusb_data));	/* clear the structure */
-		i = ifdp->bNumEndpoints;	/* get number of endpoints */
-		ep_msk = 0;	/* none found */
-		epd = ifdp->endpoint;	/* first endpoint descriptor */
-		while (i-- && ((ep_msk & 0xcf) != 0xcf)) {
-
-			idx = (((epd->bEndpointAddress & 0x7f) - 1) << 1);	/* get endpoint base */
-			if (idx < 7) {
-				switch (epd->bmAttributes) {
-					case USB_ENDPOINT_XFER_INT:
-						if (!
-						    (epd->
-						     bEndpointAddress &
-						     0x80))
-							break;	/* only interrupt in allowed */
-						idx++;	/* input index is odd */
-						context->fifos[idx].pipe =
-						    usb_rcvintpipe(dev,
-								   epd->
-								   bEndpointAddress);
-						break;
-
-					case USB_ENDPOINT_XFER_BULK:
-						if (epd->
-						    bEndpointAddress &
-						    0x80)
-							break;	/* only bulk out allowed */
-						context->fifos[idx].pipe =
-						    usb_sndbulkpipe(dev,
-								    epd->
-								    bEndpointAddress);
-						break;
-					default:
-						context->fifos[idx].pipe = 0;	/* reset data */
-				}	/* switch attribute */
-
-				if (context->fifos[idx].pipe) {
-					context->fifos[idx].fifonum = idx;
-					context->fifos[idx].fifo_mask =
-					    1 << idx;
-					context->fifos[idx].hfc = context;
-					context->fifos[idx].usb_maxlen =
-					    epd->wMaxPacketSize;
-					context->fifos[idx].intervall =
-					    epd->bInterval;
-					ep_msk |= (1 << idx);
-				} else
-					ep_msk &= ~(1 << idx);
-			}	/* idx < 7 */
-			epd++;
-		}
+	//struct usb_host_interface *iface = intf->cur_altsetting;
+	//struct usb_host_interface *iface_used = NULL;
+	//struct usb_host_endpoint *ep;
+	struct usb_endpoint_descriptor* ep;
+	//int ifnum = iface->desc.bInterfaceNumber;
+	struct usb_interface_descriptor* intfdesc = intf->altsetting + intf->act_altsetting;
+	struct usb_interface_descriptor* intfdesc_used = NULL;
+	int i, idx, alt_idx, probe_alt_setting, vend_idx, cfg_used, *vcf, attr, cfg_found, cidx, ep_addr;
+	int cmptbl[16],small_match,iso_packet_size,packet_size,alt_used=0;
+
+//        usb_show_device(dev);
+//	usb_show_device_descriptor(&dev->descriptor);
+//	usb_show_interface_descriptor(&iface->desc);
+	vend_idx=0xffff;
+	for(i=0;vdata[i].vendor;i++)
+	{
+		if(dev->descriptor.idVendor==vdata[i].vendor && dev->descriptor.idProduct==vdata[i].prod_id) vend_idx=i;
+	}
+	
 
-		if ((ep_msk & 0x3f) != 0x3f) {
-			kfree(context);
-			return (NULL);
-		}
-		MOD_INC_USE_COUNT;	/* lock our module */
-		context->dev = dev;	/* save device */
-		context->if_used = interface;	/* save used interface */
-		context->alt_used = ifp->act_altsetting;	/* and alternate config */
-		context->ctrl_paksize = dev->descriptor.bMaxPacketSize0;	/* control size */
-
-		/* create the control pipes needed for register access */
-		context->ctrl_in_pipe = usb_rcvctrlpipe(context->dev, 0);
-		context->ctrl_out_pipe = usb_sndctrlpipe(context->dev, 0);
-
-		/* init the chip and register the driver */
-		if (usb_init(context)) {
-			kfree(context);
-			MOD_DEC_USE_COUNT;
-			return (NULL);
-		}
+#ifdef VERBOSE_USB_DEBUG	
+	printk(KERN_INFO "HFC-USB: probing interface(%d) actalt(%d)\n",
+		ifnum, intfdesc->bAlternateSetting); 
+	/*	printk(KERN_INFO "HFC-USB: probing interface(%d) actalt(%d) minor(%d)\n",
+		ifnum, intfdesc->bAlternateSetting, intf->driver->minor); */
+#endif
 
-		printk(KERN_INFO
-		       "HFC-USB: New device if=%d alt=%d registered\n",
-		       context->if_used, context->alt_used);
-		return (context);
-	}
+	if (vend_idx != 0xffff) {
+#ifdef VERBOSE_USB_DEBUG
+		printk(KERN_INFO "HFC-USB: found vendor idx:%d  name:%s\n",vend_idx,vdata[vend_idx].vend_name);
+#endif
+		/* if vendor and product ID is OK, start probing a matching alternate setting ... */
+		alt_idx = 0;
+		small_match=0xffff;
+		// default settings
+		iso_packet_size=16;
+		packet_size=64;
+
+		while (alt_idx < intf->num_altsetting) {
+		        //iface = intf->altsetting + alt_idx;
+			intfdesc = intf->altsetting + alt_idx;
+			probe_alt_setting = intfdesc->bAlternateSetting;
+			cfg_used=0;
 
-	return (NULL);		/* no matching entry */
-}				/* hfc_usb_probe */
+#ifdef VERBOSE_USB_DEBUG
+			printk(KERN_INFO "HFC-USB: test alt_setting %d\n", probe_alt_setting);
+#endif
+			// check for config EOL element
+			while (validconf[cfg_used][0]) {
+				cfg_found=TRUE;
+				vcf=validconf[cfg_used];
+				ep = intfdesc->endpoint;	/* first endpoint descriptor */
+
+#ifdef VERBOSE_USB_DEBUG
+				printk(KERN_INFO "HFC-USB: (if=%d alt=%d cfg_used=%d)\n",
+					ifnum, probe_alt_setting, cfg_used);
+#endif
+				// copy table
+				memcpy(cmptbl,vcf,16*sizeof(int));
+
+				// check for all endpoints in this alternate setting
+				for (i=0; i < intfdesc->bNumEndpoints; i++) {
+					ep_addr = ep->bEndpointAddress;
+					idx = ((ep_addr & 0x7f)-1)*2;	/* get endpoint base */
+					if (ep_addr & 0x80)
+						idx++;
+					attr = ep->bmAttributes;
+
+					if (cmptbl[idx] == EP_NUL) {
+						printk(KERN_INFO "HFC-USB: cfg_found=FALSE in idx:%d  attr:%d  cmptbl[%d]:%d\n",
+							idx, attr, idx, cmptbl[idx]);
+						cfg_found = FALSE;
+					}
+
+					if (attr == USB_ENDPOINT_XFER_INT && cmptbl[idx] == EP_INT)
+						cmptbl[idx] = EP_NUL;
+					if (attr == USB_ENDPOINT_XFER_BULK && cmptbl[idx] == EP_BLK)
+						cmptbl[idx] = EP_NUL;
+					if (attr == USB_ENDPOINT_XFER_ISOC && cmptbl[idx] == EP_ISO)
+						cmptbl[idx] = EP_NUL;
+
+					// check if all INT endpoints match minimum interval
+					if (attr == USB_ENDPOINT_XFER_INT && ep->bInterval < vcf[17]) {
+#ifdef VERBOSE_USB_DEBUG
+						if (cfg_found)
+							printk(KERN_INFO "HFC-USB: Interrupt Endpoint interval < %d found - skipping config\n",
+								vcf[17]);
+#endif
+						cfg_found = FALSE;
+					}
+
+					ep++;
+				}
+
+				for (i = 0; i < 16; i++) {
+					// printk(KERN_INFO "HFC-USB: cmptbl[%d]:%d\n", i, cmptbl[i]);
+
+					// all entries must be EP_NOP or EP_NUL for a valid config
+					if (cmptbl[i] != EP_NOP && cmptbl[i] != EP_NUL)
+						cfg_found = FALSE;
+				}
+
+				// we check for smallest match, to provide configuration priority
+				// configurations with smaller index have higher priority
+				if (cfg_found) {
+					if (cfg_used < small_match) {
+						small_match = cfg_used;
+						alt_used = probe_alt_setting;
+						//iface_used = iface;
+						intfdesc_used = intfdesc;
+					}
+#ifdef VERBOSE_USB_DEBUG
+					printk(KERN_INFO "HFC-USB: small_match=%x %x\n", small_match, alt_used);
+#endif
+				}
+
+				cfg_used++;
+			}
+
+			alt_idx++;
+		}		/* (alt_idx < intf->num_altsetting) */
+#ifdef VERBOSE_USB_DEBUG
+		printk(KERN_INFO "HFC-USB: final small_match=%x alt_used=%x\n",small_match, alt_used);
+#endif
+		// yiipiee, we found a valid config
+		if (small_match != 0xffff) {
+		        //iface = iface_used;
+		        intfdesc = intfdesc_used;
+
+			if (!(context = kmalloc(sizeof(hfcusb_data), GFP_KERNEL)))
+				return(NULL);  /* got no mem */
+			memset(context, 0, sizeof(hfcusb_data));	/* clear the structure */
+
+			ep = intfdesc->endpoint;	/* first endpoint descriptor */
+			vcf = validconf[small_match];
+
+			for (i = 0; i < intfdesc->bNumEndpoints; i++) {
+				ep_addr = ep->bEndpointAddress;
+				idx = ((ep_addr & 0x7f)-1)*2;	/* get endpoint base */
+				if (ep_addr & 0x80)
+					idx++;
+				cidx = idx & 7;
+				attr = ep->bmAttributes;
+
+				// only initialize used endpoints
+				if (vcf[idx] != EP_NOP && vcf[idx] != EP_NUL) {
+					switch (attr) {
+						case USB_ENDPOINT_XFER_INT:
+							context->fifos[cidx].pipe = usb_rcvintpipe(dev, ep->bEndpointAddress);
+							context->fifos[cidx].usb_transfer_mode = USB_INT;
+							packet_size = ep->wMaxPacketSize; // remember max packet size
+#ifdef VERBOSE_USB_DEBUG
+							printk (KERN_INFO "HFC-USB: Interrupt-In Endpoint found %d ms(idx:%d cidx:%d)!\n",
+								ep->bInterval, idx, cidx);
+#endif
+							break;
+						case USB_ENDPOINT_XFER_BULK:
+							if (ep_addr & 0x80)
+								context->fifos[cidx].pipe = usb_rcvbulkpipe(dev, ep->bEndpointAddress);
+							else
+								context->fifos[cidx].pipe = usb_sndbulkpipe(dev, ep->bEndpointAddress);
+							context->fifos[cidx].usb_transfer_mode = USB_BULK;
+							packet_size = ep->wMaxPacketSize; // remember max packet size
+#ifdef VERBOSE_USB_DEBUG
+							printk (KERN_INFO "HFC-USB: Bulk Endpoint found (idx:%d cidx:%d)!\n",
+								idx, cidx);
+#endif
+							break;
+						case USB_ENDPOINT_XFER_ISOC:
+							if (ep_addr & 0x80)
+								context->fifos[cidx].pipe = usb_rcvisocpipe(dev, ep->bEndpointAddress);
+							else
+								context->fifos[cidx].pipe = usb_sndisocpipe(dev, ep->bEndpointAddress);
+							context->fifos[cidx].usb_transfer_mode = USB_ISOC;
+							iso_packet_size = ep->wMaxPacketSize; // remember max packet size
+#ifdef VERBOSE_USB_DEBUG
+							printk (KERN_INFO "HFC-USB: ISO Endpoint found (idx:%d cidx:%d)!\n",
+								idx, cidx);
+#endif
+							break;
+						default:
+							context->fifos[cidx].pipe = 0;	/* reset data */
+					}	/* switch attribute */
+
+					if (context->fifos[cidx].pipe) {
+						context->fifos[cidx].fifonum = cidx;
+						context->fifos[cidx].hfc = context;
+						context->fifos[cidx].usb_packet_maxlen = ep->wMaxPacketSize;
+						context->fifos[cidx].intervall = ep->bInterval;
+						context->fifos[cidx].skbuff = NULL;
+#ifdef VERBOSE_USB_DEBUG
+						printk (KERN_INFO "HFC-USB: fifo%d pktlen %d interval %d\n",
+							context->fifos[cidx].fifonum,
+							context->fifos[cidx].usb_packet_maxlen,
+							context->fifos[cidx].intervall);
+#endif
+					}
+				}
+
+				ep++;
+			}
+
+			// now share our luck
+			context->dev = dev;						/* save device */
+			context->if_used = ifnum;					/* save used interface */
+			context->alt_used = alt_used;					/* and alternate config */
+			context->ctrl_paksize = dev->descriptor.bMaxPacketSize0;	/* control size */
+			context->cfg_used=vcf[16];					// store used config
+			context->vend_idx=vend_idx;					// store found vendor
+			context->packet_size=packet_size;
+			context->iso_packet_size=iso_packet_size;
+
+			/* create the control pipes needed for register access */
+			context->ctrl_in_pipe = usb_rcvctrlpipe(context->dev, 0);
+			context->ctrl_out_pipe = usb_sndctrlpipe(context->dev, 0);
+			context->ctrl_urb = usb_alloc_urb(0);
+
+			printk(KERN_INFO "HFC-USB: detected \"%s\" configuration: %s (if=%d alt=%d)\n",
+				vdata[vend_idx].vend_name, conf_str[small_match], context->if_used, context->alt_used);
+
+			/* init the chip and register the driver */
+			if (usb_init(context))
+			{
+				if (context->ctrl_urb) {
+					usb_unlink_urb(context->ctrl_urb);
+					usb_free_urb(context->ctrl_urb);
+					context->ctrl_urb = NULL;
+				}
+				kfree(context);
+				return(NULL);
+			}
+			//usb_set_intfdata(intf, context);
+			//intf->private_data = context;
+			return(context);
+		} 
+	}
+	return(NULL);
+}
 
 /****************************************************/
 /* function called when an active device is removed */
 /****************************************************/
-static void
-hfc_usb_disconnect(struct usb_device *usbdev, void *drv_context)
+//static void hfc_usb_disconnect(struct usb_interface *intf)
+static void hfc_usb_disconnect(struct usb_device *usbdev, void* drv_context)
 {
-	hfcusb_data *context = drv_context;
+        //hfcusb_data *context = intf->private_data;
+        hfcusb_data* context = drv_context;
 	int i;
-	struct sk_buff *skb;
 
-	/* tell all fifos to terminate */
-	for (i = 0; i < HFCUSB_NUM_FIFOS; i++)
-		if (context->fifos[i].active) {
-			context->fifos[i].active = 0;
-			usb_unlink_urb(&context->fifos[i].urb);
-		}
-	while (context->active_fifos) {
-		set_current_state(TASK_INTERRUPTIBLE);
-		/* Timeout 10ms */
-		schedule_timeout((10 * HZ) / 1000);
-	}
+	printk(KERN_INFO "HFC-USB: device disconnect\n");
+	
+	//intf->private_data = NULL;
+	if (!context)
+		return;
 	if (timer_pending(&context->t3_timer))
 		del_timer(&context->t3_timer);
-	context->regd.release_driver(context->regd.arg_hisax);
-	while ((skb = skb_dequeue(&context->regd.erq)) != NULL)
-		dev_kfree_skb_any(skb);
+	if (timer_pending(&context->t4_timer))
+		del_timer(&context->t4_timer);
+	if (timer_pending(&context->led_timer))
+		del_timer(&context->led_timer);
+
+	hisax_unregister(&context->d_if);
 
+	/* tell all fifos to terminate */
+	for(i = 0; i < HFCUSB_NUM_FIFOS; i++) {
+		if(context->fifos[i].usb_transfer_mode == USB_ISOC) {
+			if(context->fifos[i].active > 0) {
+	    			stop_isoc_chain(&context->fifos[i]);
+#ifdef VERBOSE_USB_DEBUG
+		    		printk (KERN_INFO "HFC-USB: hfc_usb_disconnect: stopping ISOC chain Fifo no %i\n", i);
+#endif
+ 			}
+		} else {
+			if(context->fifos[i].active > 0) {
+				context->fifos[i].active = 0;
+#ifdef VERBOSE_USB_DEBUG
+				printk (KERN_INFO "HFC-USB: hfc_usb_disconnect: unlinking URB for Fifo no %i\n", i);
+#endif
+			}
+			if (context->fifos[i].urb) {
+				usb_unlink_urb(context->fifos[i].urb);
+				usb_free_urb(context->fifos[i].urb);
+				context->fifos[i].urb = NULL;
+			}
+		}
+		context->fifos[i].active = 0;
+	}
+	if (context->ctrl_urb) {
+		usb_unlink_urb(context->ctrl_urb);
+		usb_free_urb(context->ctrl_urb);
+		context->ctrl_urb = NULL;
+	}
 	kfree(context);		/* free our structure again */
-	MOD_DEC_USE_COUNT;	/* and decrement the usage counter */
 }				/* hfc_usb_disconnect */
 
+
 /************************************/
 /* our driver information structure */
 /************************************/
 static struct usb_driver hfc_drv = {
 	name:"hfc_usb",
-#ifdef COMPAT_HAS_USB_IDTAB
 	id_table:hfc_usb_idtab,
-#endif
 	probe:hfc_usb_probe,
 	disconnect:hfc_usb_disconnect,
 };
 
-static void __exit
-hfc_usb_exit(void)
-{
 
+static void __exit hfc_usb_exit(void)
+{
+#ifdef VERBOSE_USB_DEBUG
+	printk ("HFC-USB: calling \"hfc_usb_exit\" ...\n");
+#endif
 	usb_deregister(&hfc_drv);	/* release our driver */
 	printk(KERN_INFO "HFC-USB module removed\n");
 }
 
-static int __init
-hfc_usb_init(void)
+static int __init hfc_usb_init(void)
 {
-	struct hisax_drvreg drv;
+	printk ("HFC-USB: driver module revision %s loaded\n", hfcusb_revision);
 
-	drv.version = HISAX_LOAD_VERSION;	/* set our version */
-	drv.cmd = HISAX_LOAD_CHKVER;	/* check command only */
-	if (hisax_register_hfcusb(&drv)) {
-		printk(KERN_INFO "HFC-USB <-> hisax version conflict\n");
-		return (-1);	/* unable to register */
-	}
-	if (usb_register(&hfc_drv)) {
-		printk(KERN_INFO
-		       "Unable to register HFC-USB module at usb stack\n");
-		return (-1);	/* unable to register */
+	if(usb_register(&hfc_drv))
+	{
+		printk(KERN_INFO "HFC-USB: Unable to register HFC-USB module at usb stack\n");
+		return(-1);		   /* unable to register */
 	}
-
-	printk(KERN_INFO "HFC-USB module loaded\n");
-	return (0);
+	return(0);
 }
 
+
+
+
+
 module_init(hfc_usb_init);
 module_exit(hfc_usb_exit);
+