diff options
author | Felix Fietkau <nbd@openwrt.org> | 2006-01-10 19:43:00 +0000 |
---|---|---|
committer | Felix Fietkau <nbd@openwrt.org> | 2006-01-10 19:43:00 +0000 |
commit | fbc6b140a51f4faa9b995eb965b6e69ebb541f3f (patch) | |
tree | 4f317d291370cf0af876f446896c66a3a503be97 /target/linux/generic-2.4/patches/201-hfc_usb_backport.patch | |
parent | d9e36255b00d6bbcdedeba7ab9e22f37f8ed79bc (diff) | |
download | upstream-fbc6b140a51f4faa9b995eb965b6e69ebb541f3f.tar.gz upstream-fbc6b140a51f4faa9b995eb965b6e69ebb541f3f.tar.bz2 upstream-fbc6b140a51f4faa9b995eb965b6e69ebb541f3f.zip |
large target/linux cleanup
git-svn-id: svn://svn.openwrt.org/openwrt/trunk/openwrt@2877 3c298f89-4303-0410-b956-a3cf2f4a3e73
Diffstat (limited to 'target/linux/generic-2.4/patches/201-hfc_usb_backport.patch')
-rw-r--r-- | target/linux/generic-2.4/patches/201-hfc_usb_backport.patch | 2663 |
1 files changed, 2663 insertions, 0 deletions
diff --git a/target/linux/generic-2.4/patches/201-hfc_usb_backport.patch b/target/linux/generic-2.4/patches/201-hfc_usb_backport.patch new file mode 100644 index 0000000000..4ef20fa8ba --- /dev/null +++ b/target/linux/generic-2.4/patches/201-hfc_usb_backport.patch @@ -0,0 +1,2663 @@ +diff -rNu linux-2.4.29.old/drivers/Makefile linux-2.4.29/drivers/Makefile +--- linux-2.4.29.old/drivers/Makefile 2005-03-22 14:47:41.000000000 +0100 ++++ linux-2.4.29/drivers/Makefile 2005-03-22 15:15:20.012957872 +0100 +@@ -38,7 +38,7 @@ + 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 + +diff -rNu linux-2.4.29.old/drivers/isdn/hisax/hfc_usb.c linux-2.4.29/drivers/isdn/hisax/hfc_usb.c +--- linux-2.4.29.old/drivers/isdn/hisax/hfc_usb.c 2005-03-22 15:13:58.233390256 +0100 ++++ linux-2.4.29/drivers/isdn/hisax/hfc_usb.c 2005-03-22 15:14:57.475384104 +0100 +@@ -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 @@ + /* 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); ++ |