/* * usb-host.c: ETRAX 100LX USB Host Controller Driver (HCD) * * Copyright (c) 2001 Axis Communications AB. * * $Id: usb-host.c,v 1.13 2001/11/13 12:06:17 pkj Exp $ * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "usb-host.h" #define ETRAX_USB_HC_IRQ USB_HC_IRQ_NBR #define ETRAX_USB_RX_IRQ USB_DMA_RX_IRQ_NBR #define ETRAX_USB_TX_IRQ USB_DMA_TX_IRQ_NBR static const char *usb_hcd_version = "$Revision: 1.13 $"; #undef KERN_DEBUG #define KERN_DEBUG "" #undef USB_DEBUG_RH #undef USB_DEBUG_EP #undef USB_DEBUG_DESC #undef USB_DEBUG_TRACE #undef USB_DEBUG_CTRL #undef USB_DEBUG_BULK #undef USB_DEBUG_INTR #ifdef USB_DEBUG_RH #define dbg_rh(format, arg...) printk(KERN_DEBUG __FILE__ ": (RH) " format "\n" , ## arg) #else #define dbg_rh(format, arg...) do {} while (0) #endif #ifdef USB_DEBUG_EP #define dbg_ep(format, arg...) printk(KERN_DEBUG __FILE__ ": (EP) " format "\n" , ## arg) #else #define dbg_ep(format, arg...) do {} while (0) #endif #ifdef USB_DEBUG_CTRL #define dbg_ctrl(format, arg...) printk(KERN_DEBUG __FILE__ ": (CTRL) " format "\n" , ## arg) #else #define dbg_ctrl(format, arg...) do {} while (0) #endif #ifdef USB_DEBUG_BULK #define dbg_bulk(format, arg...) printk(KERN_DEBUG __FILE__ ": (BULK) " format "\n" , ## arg) #else #define dbg_bulk(format, arg...) do {} while (0) #endif #ifdef USB_DEBUG_INTR #define dbg_intr(format, arg...) printk(KERN_DEBUG __FILE__ ": (INTR) " format "\n" , ## arg) #else #define dbg_intr(format, arg...) do {} while (0) #endif #ifdef USB_DEBUG_TRACE #define DBFENTER (printk(KERN_DEBUG __FILE__ ": Entering: " __FUNCTION__ "\n")) #define DBFEXIT (printk(KERN_DEBUG __FILE__ ": Exiting: " __FUNCTION__ "\n")) #else #define DBFENTER do {} while (0) #define DBFEXIT do {} while (0) #endif /*------------------------------------------------------------------- Virtual Root Hub -------------------------------------------------------------------*/ static __u8 root_hub_dev_des[] = { 0x12, /* __u8 bLength; */ 0x01, /* __u8 bDescriptorType; Device */ 0x00, /* __u16 bcdUSB; v1.0 */ 0x01, 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */ 0x00, /* __u8 bDeviceSubClass; */ 0x00, /* __u8 bDeviceProtocol; */ 0x08, /* __u8 bMaxPacketSize0; 8 Bytes */ 0x00, /* __u16 idVendor; */ 0x00, 0x00, /* __u16 idProduct; */ 0x00, 0x00, /* __u16 bcdDevice; */ 0x00, 0x00, /* __u8 iManufacturer; */ 0x02, /* __u8 iProduct; */ 0x01, /* __u8 iSerialNumber; */ 0x01 /* __u8 bNumConfigurations; */ }; /* Configuration descriptor */ static __u8 root_hub_config_des[] = { 0x09, /* __u8 bLength; */ 0x02, /* __u8 bDescriptorType; Configuration */ 0x19, /* __u16 wTotalLength; */ 0x00, 0x01, /* __u8 bNumInterfaces; */ 0x01, /* __u8 bConfigurationValue; */ 0x00, /* __u8 iConfiguration; */ 0x40, /* __u8 bmAttributes; Bit 7: Bus-powered */ 0x00, /* __u8 MaxPower; */ /* interface */ 0x09, /* __u8 if_bLength; */ 0x04, /* __u8 if_bDescriptorType; Interface */ 0x00, /* __u8 if_bInterfaceNumber; */ 0x00, /* __u8 if_bAlternateSetting; */ 0x01, /* __u8 if_bNumEndpoints; */ 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */ 0x00, /* __u8 if_bInterfaceSubClass; */ 0x00, /* __u8 if_bInterfaceProtocol; */ 0x00, /* __u8 if_iInterface; */ /* endpoint */ 0x07, /* __u8 ep_bLength; */ 0x05, /* __u8 ep_bDescriptorType; Endpoint */ 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */ 0x03, /* __u8 ep_bmAttributes; Interrupt */ 0x08, /* __u16 ep_wMaxPacketSize; 8 Bytes */ 0x00, 0xff /* __u8 ep_bInterval; 255 ms */ }; static __u8 root_hub_hub_des[] = { 0x09, /* __u8 bLength; */ 0x29, /* __u8 bDescriptorType; Hub-descriptor */ 0x02, /* __u8 bNbrPorts; */ 0x00, /* __u16 wHubCharacteristics; */ 0x00, 0x01, /* __u8 bPwrOn2pwrGood; 2ms */ 0x00, /* __u8 bHubContrCurrent; 0 mA */ 0x00, /* __u8 DeviceRemovable; *** 7 Ports max *** */ 0xff /* __u8 PortPwrCtrlMask; *** 7 ports max *** */ }; #define OK(x) len = (x); dbg_rh("OK(%d): line: %d", x, __LINE__); break #define CHECK_ALIGN(x) if (((__u32)(x)) & 0x00000003) \ {panic("Alignment check (DWORD) failed at %s:%s:%d\n", __FILE__, __FUNCTION__, __LINE__);} static unsigned long submit_urb_count = 0; //#define ETRAX_USB_INTR_IRQ //#define ETRAX_USB_INTR_ERROR_FATAL #define RX_BUF_SIZE 32768 #define RX_DESC_BUF_SIZE 64 #define NBR_OF_RX_DESC (RX_BUF_SIZE / RX_DESC_BUF_SIZE) #define NBR_OF_EP_DESC 32 #define MAX_INTR_INTERVAL 128 static __u32 ep_usage_bitmask; static __u32 ep_really_active; static __u32 ep_out_traffic; static unsigned char RxBuf[RX_BUF_SIZE]; static USB_IN_Desc_t RxDescList[NBR_OF_RX_DESC] __attribute__ ((aligned (4))); static volatile USB_IN_Desc_t *myNextRxDesc; static volatile USB_IN_Desc_t *myLastRxDesc; static volatile USB_IN_Desc_t *myPrevRxDesc; static USB_EP_Desc_t TxCtrlEPList[NBR_OF_EP_DESC] __attribute__ ((aligned (4))); static USB_EP_Desc_t TxBulkEPList[NBR_OF_EP_DESC] __attribute__ ((aligned (4))); static USB_EP_Desc_t TxIntrEPList[MAX_INTR_INTERVAL] __attribute__ ((aligned (4))); static USB_SB_Desc_t TxIntrSB_zout __attribute__ ((aligned (4))); static urb_t *URB_List[NBR_OF_EP_DESC]; static kmem_cache_t *usb_desc_cache; static struct usb_bus *etrax_usb_bus; #ifdef USB_DEBUG_DESC static void dump_urb (purb_t purb); #endif static void init_rx_buffers(void); static int etrax_rh_unlink_urb (urb_t *urb); static void etrax_rh_send_irq(urb_t *urb); static void etrax_rh_init_int_timer(urb_t *urb); static void etrax_rh_int_timer_do(unsigned long ptr); static void etrax_usb_setup_epid(int epid, char devnum, char endpoint, char packsize, char slow, char out_traffic); static int etrax_usb_lookup_epid(unsigned char devnum, char endpoint, char slow, int maxp, char out_traffic); static int etrax_usb_allocate_epid(void); static void etrax_usb_free_epid(int epid); static void cleanup_sb(USB_SB_Desc_t *sb); static void etrax_usb_do_ctrl_hw_add(urb_t *urb, int epid, char maxlen); static void etrax_usb_do_bulk_hw_add(urb_t *urb, int epid, char maxlen); static int etrax_usb_submit_ctrl_urb(urb_t *urb); static int etrax_usb_submit_urb(urb_t *urb); static int etrax_usb_unlink_urb(urb_t *urb); static int etrax_usb_get_frame_number(struct usb_device *usb_dev); static int etrax_usb_allocate_dev(struct usb_device *usb_dev); static int etrax_usb_deallocate_dev(struct usb_device *usb_dev); static void etrax_usb_tx_interrupt(int irq, void *vhc, struct pt_regs *regs); static void etrax_usb_rx_interrupt(int irq, void *vhc, struct pt_regs *regs); static void etrax_usb_hc_intr_top_half(int irq, void *vhc, struct pt_regs *regs); static int etrax_rh_submit_urb (urb_t *urb); static int etrax_usb_hc_init(void); static void etrax_usb_hc_cleanup(void); static struct usb_operations etrax_usb_device_operations = { etrax_usb_allocate_dev, etrax_usb_deallocate_dev, etrax_usb_get_frame_number, etrax_usb_submit_urb, etrax_usb_unlink_urb }; #ifdef USB_DEBUG_DESC static void dump_urb(purb_t purb) { printk("\nurb :0x%08X\n", purb); printk("next :0x%08X\n", purb->next); printk("dev :0x%08X\n", purb->dev); printk("pipe :0x%08X\n", purb->pipe); printk("status :%d\n", purb->status); printk("transfer_flags :0x%08X\n", purb->transfer_flags); printk("transfer_buffer :0x%08X\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 :0x%08X\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 :0x%08X\n", purb->context); printk("complete :0x%08X\n\n", purb->complete); } static void dump_in_desc(USB_IN_Desc_t *in) { printk("\nUSB_IN_Desc at 0x%08X\n", in); printk(" sw_len : 0x%04X (%d)\n", in->sw_len, in->sw_len); printk(" command : 0x%04X\n", in->command); printk(" next : 0x%08X\n", in->next); printk(" buf : 0x%08X\n", in->buf); printk(" hw_len : 0x%04X (%d)\n", in->hw_len, in->hw_len); printk(" status : 0x%04X\n\n", in->status); } static void dump_sb_desc(USB_SB_Desc_t *sb) { printk("\nUSB_SB_Desc at 0x%08X\n", sb); printk(" sw_len : 0x%04X (%d)\n", sb->sw_len, sb->sw_len); printk(" command : 0x%04X\n", sb->command); printk(" next : 0x%08X\n", sb->next); printk(" buf : 0x%08X\n\n", sb->buf); } static void dump_ep_desc(USB_EP_Desc_t *ep) { printk("\nUSB_EP_Desc at 0x%08X\n", ep); printk(" hw_len : 0x%04X (%d)\n", ep->hw_len, ep->hw_len); printk(" command : 0x%08X\n", ep->command); printk(" sub : 0x%08X\n", ep->sub); printk(" nep : 0x%08X\n\n", ep->nep); } #else #define dump_urb(...) do {} while (0) #define dump_in_desc(...) do {} while (0) #define dump_sb_desc(...) do {} while (0) #define dump_ep_desc(...) do {} while (0) #endif static void init_rx_buffers(void) { int i; DBFENTER; for (i = 0; i < (NBR_OF_RX_DESC - 1); i++) { RxDescList[i].sw_len = RX_DESC_BUF_SIZE; RxDescList[i].command = 0; RxDescList[i].next = virt_to_phys(&RxDescList[i + 1]); RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE)); RxDescList[i].hw_len = 0; RxDescList[i].status = 0; } RxDescList[i].sw_len = RX_DESC_BUF_SIZE; RxDescList[i].command = IO_STATE(USB_IN_command, eol, yes); RxDescList[i].next = virt_to_phys(&RxDescList[0]); RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE)); RxDescList[i].hw_len = 0; RxDescList[i].status = 0; myNextRxDesc = &RxDescList[0]; myLastRxDesc = &RxDescList[NBR_OF_RX_DESC - 1]; myPrevRxDesc = &RxDescList[NBR_OF_RX_DESC - 1]; *R_DMA_CH9_FIRST = virt_to_phys(myNextRxDesc); *R_DMA_CH9_CMD = IO_STATE(R_DMA_CH9_CMD, cmd, start); DBFEXIT; } static void init_tx_ctrl_ep(void) { int i; DBFENTER; for (i = 0; i < (NBR_OF_EP_DESC - 1); i++) { TxCtrlEPList[i].hw_len = 0; TxCtrlEPList[i].command = IO_FIELD(USB_EP_command, epid, i); TxCtrlEPList[i].sub = 0; TxCtrlEPList[i].nep = virt_to_phys(&TxCtrlEPList[i + 1]); } TxCtrlEPList[i].hw_len = 0; TxCtrlEPList[i].command = IO_STATE(USB_EP_command, eol, yes) | IO_FIELD(USB_EP_command, epid, i); TxCtrlEPList[i].sub = 0; TxCtrlEPList[i].nep = virt_to_phys(&TxCtrlEPList[0]); *R_DMA_CH8_SUB1_EP = virt_to_phys(&TxCtrlEPList[0]); *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB1_CMD, cmd, start); DBFEXIT; } static void init_tx_bulk_ep(void) { int i; DBFENTER; for (i = 0; i < (NBR_OF_EP_DESC - 1); i++) { TxBulkEPList[i].hw_len = 0; TxBulkEPList[i].command = IO_FIELD(USB_EP_command, epid, i); TxBulkEPList[i].sub = 0; TxBulkEPList[i].nep = virt_to_phys(&TxBulkEPList[i + 1]); } TxBulkEPList[i].hw_len = 0; TxBulkEPList[i].command = IO_STATE(USB_EP_command, eol, yes) | IO_FIELD(USB_EP_command, epid, i); TxBulkEPList[i].sub = 0; TxBulkEPList[i].nep = virt_to_phys(&TxBulkEPList[0]); *R_DMA_CH8_SUB0_EP = virt_to_phys(&TxBulkEPList[0]); *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start); DBFEXIT; } static void init_tx_intr_ep(void) { int i; DBFENTER; TxIntrSB_zout.sw_len = 0; TxIntrSB_zout.next = 0; TxIntrSB_zout.buf = 0; TxIntrSB_zout.command = IO_FIELD(USB_SB_command, rem, 0) | IO_STATE(USB_SB_command, tt, zout) | IO_STATE(USB_SB_command, full, yes) | IO_STATE(USB_SB_command, eot, yes) | IO_STATE(USB_SB_command, eol, yes); for (i = 0; i < (MAX_INTR_INTERVAL - 1); i++) { TxIntrEPList[i].hw_len = 0; TxIntrEPList[i].command = IO_STATE(USB_EP_command, eof, yes) | IO_STATE(USB_EP_command, enable, yes) | IO_FIELD(USB_EP_command, epid, 0); TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout); TxIntrEPList[i].nep = virt_to_phys(&TxIntrEPList[i + 1]); } TxIntrEPList[i].hw_len = 0; TxIntrEPList[i].command = IO_STATE(USB_EP_command, eof, yes) | IO_STATE(USB_EP_command, enable, yes) | IO_FIELD(USB_EP_command, epid, 0); TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout); TxIntrEPList[i].nep = virt_to_phys(&TxIntrEPList[0]); *R_DMA_CH8_SUB2_EP = virt_to_phys(&TxIntrEPList[0]); *R_DMA_CH8_SUB2_CMD = IO_STATE(R_DMA_CH8_SUB2_CMD, cmd, start); DBFEXIT; } static int etrax_usb_unlink_intr_urb(urb_t *urb) { USB_EP_Desc_t *tmp_ep; USB_EP_Desc_t *first_ep; USB_EP_Desc_t *ep_desc; int epid; char devnum; char endpoint; char slow; int maxlen; char out_traffic; int i; DBFENTER; devnum = usb_pipedevice(urb->pipe); endpoint = usb_pipeendpoint(urb->pipe); slow = usb_pipeslow(urb->pipe); maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe)); out_traffic = usb_pipeout(urb->pipe); epid = etrax_usb_lookup_epid(devnum, endpoint, slow, maxlen, out_traffic); if (epid == -1) { err("Trying to unlink urb that is not in traffic queue!!"); return -1; /* fix this */ } *R_DMA_CH8_SUB2_CMD = IO_STATE(R_DMA_CH8_SUB2_CMD, cmd, stop); /* Somehow wait for the DMA to finish current activities */ i = jiffies + 100; while (jiffies < i); first_ep = &TxIntrEPList[0]; tmp_ep = first_ep; do { if (IO_EXTRACT(USB_EP_command, epid, ((USB_EP_Desc_t *)phys_to_virt(tmp_ep->nep))->command) == epid) { /* Unlink it !!! */ dbg_intr("Found urb to unlink for epid %d", epid); ep_desc = phys_to_virt(tmp_ep->nep); tmp_ep->nep = ep_desc->nep; kmem_cache_free(usb_desc_cache, phys_to_virt(ep_desc->sub)); kmem_cache_free(usb_desc_cache, ep_desc); } tmp_ep = phys_to_virt(tmp_ep->nep); } while (tmp_ep != first_ep); /* We should really try to move the EP register to an EP that is not removed instead of restarting, but this will work too */ *R_DMA_CH8_SUB2_EP = virt_to_phys(&TxIntrEPList[0]); *R_DMA_CH8_SUB2_CMD = IO_STATE(R_DMA_CH8_SUB2_CMD, cmd, start); clear_bit(epid, (void *)&ep_really_active); URB_List[epid] = NULL; etrax_usb_free_epid(epid); DBFEXIT; return 0; } void etrax_usb_do_intr_recover(int epid) { USB_EP_Desc_t *first_ep, *tmp_ep; first_ep = (USB_EP_Desc_t *)phys_to_virt(*R_DMA_CH8_SUB2_EP); tmp_ep = first_ep; do { if (IO_EXTRACT(USB_EP_command, epid, tmp_ep->command) == epid && !(tmp_ep->command & IO_MASK(USB_EP_command, enable))) { tmp_ep->command |= IO_STATE(USB_EP_command, enable, yes); } tmp_ep = (USB_EP_Desc_t *)phys_to_virt(tmp_ep->nep); } while (tmp_ep != first_ep); } static int etrax_usb_submit_intr_urb(urb_t *urb) { USB_EP_Desc_t *tmp_ep; USB_EP_Desc_t *first_ep; int epid; char devnum; char endpoint; char maxlen; char out_traffic; char slow; int interval; int i; etrax_urb_priv_t *urb_priv; DBFENTER; devnum = usb_pipedevice(urb->pipe); endpoint = usb_pipeendpoint(urb->pipe); maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe)); out_traffic = usb_pipeout(urb->pipe); slow = usb_pipeslow(urb->pipe); interval = urb->interval; dbg_intr("Intr traffic for dev %d, endpoint %d, maxlen %d, slow %d", devnum, endpoint, maxlen, slow); epid = etrax_usb_lookup_epid(devnum, endpoint, slow, maxlen, out_traffic); if (epid == -1) { epid = etrax_usb_allocate_epid(); if (epid == -1) { /* We're out of endpoints, return some error */ err("We're out of endpoints"); return -ENOMEM; } /* Now we have to fill in this ep */ etrax_usb_setup_epid(epid, devnum, endpoint, maxlen, slow, out_traffic); } /* Ok, now we got valid endpoint, lets insert some traffic */ urb_priv = (etrax_urb_priv_t *)kmalloc(sizeof(etrax_urb_priv_t), GFP_KERNEL); urb_priv->first_sb = 0; urb_priv->rx_offset = 0; urb_priv->eot = 0; INIT_LIST_HEAD(&urb_priv->ep_in_list); urb->hcpriv = urb_priv; /* This is safe since there cannot be any other URB's for this epid */ URB_List[epid] = urb; #if 0 first_ep = (USB_EP_Desc_t *)phys_to_virt(*R_DMA_CH8_SUB2_EP); #else first_ep = &TxIntrEPList[0]; #endif /* Round of the interval to 2^n, it is obvious that this code favours smaller numbers, but that is actually a good thing */ for (i = 0; interval; i++) { interval = interval >> 1; } urb->interval = interval = 1 << (i - 1); dbg_intr("Interval rounded to %d", interval); tmp_ep = first_ep; i = 0; do { if (tmp_ep->command & IO_MASK(USB_EP_command, eof)) { if ((i % interval) == 0) { /* Insert the traffic ep after tmp_ep */ USB_EP_Desc_t *traffic_ep; USB_SB_Desc_t *traffic_sb; traffic_ep = (USB_EP_Desc_t *) kmem_cache_alloc(usb_desc_cache, GFP_KERNEL); traffic_sb = (USB_SB_Desc_t *) kmem_cache_alloc(usb_desc_cache, GFP_KERNEL); traffic_ep->hw_len = 0; traffic_ep->command = IO_FIELD(USB_EP_command, epid, epid) | IO_STATE(USB_EP_command, enable, yes); traffic_ep->sub = virt_to_phys(traffic_sb); if (usb_pipein(urb->pipe)) { traffic_sb->sw_len = urb->transfer_buffer_length ? (urb->transfer_buffer_length - 1) / maxlen + 1 : 0; traffic_sb->next = 0; traffic_sb->buf = 0; traffic_sb->command = IO_FIELD(USB_SB_command, rem, urb->transfer_buffer_length % maxlen) | IO_STATE(USB_SB_command, tt, in) | IO_STATE(USB_SB_command, eot, yes) | IO_STATE(USB_SB_command, eol, yes); } else if (usb_pipeout(urb->pipe)) { traffic_sb->sw_len = urb->transfer_buffer_length; traffic_sb->next = 0; traffic_sb->buf = virt_to_phys(urb->transfer_buffer); traffic_sb->command = IO_FIELD(USB_SB_command, rem, 0) | IO_STATE(USB_SB_command, tt, out) | IO_STATE(USB_SB_command, eot, yes) | IO_STATE(USB_SB_command, eol, yes) | IO_STATE(USB_SB_command, full, yes); } traffic_ep->nep = tmp_ep->nep; tmp_ep->nep = virt_to_phys(traffic_ep); dbg_intr("One ep sucessfully inserted"); } i++; } tmp_ep = (USB_EP_Desc_t *)phys_to_virt(tmp_ep->nep); } while (tmp_ep != first_ep); set_bit(epid, (void *)&ep_really_active); *R_DMA_CH8_SUB2_CMD = IO_STATE(R_DMA_CH8_SUB2_CMD, cmd, start); DBFEXIT; return 0; } static void handle_intr_transfer_attn(int epid, int status) { urb_t *old_urb; DBFENTER; old_urb = URB_List[epid]; /* if (status == 0 && IN) find data and copy to urb */ if (status == 0 && usb_pipein(old_urb->pipe)) { unsigned long flags; etrax_urb_priv_t *urb_priv; struct list_head *entry; struct in_chunk *in; urb_priv = (etrax_urb_priv_t *)old_urb->hcpriv; save_flags(flags); cli(); list_for_each(entry, &urb_priv->ep_in_list) { in = list_entry(entry, struct in_chunk, list); memcpy(old_urb->transfer_buffer, in->data, in->length); old_urb->actual_length = in->length; old_urb->status = status; if (old_urb->complete) { old_urb->complete(old_urb); } list_del(entry); kfree(in->data); kfree(in); } restore_flags(flags); } else if (status != 0) { warn("Some sort of error for INTR EP !!!!"); #ifdef ETRAX_USB_INTR_ERROR_FATAL /* This means that an INTR error is fatal for that endpoint */ etrax_usb_unlink_intr_urb(old_urb); old_urb->status = status; if (old_urb->complete) { old_urb->complete(old_urb); } #else /* In this case we reenable the disabled endpoint(s) */ etrax_usb_do_intr_recover(epid); #endif } DBFEXIT; } static int etrax_rh_unlink_urb (urb_t *urb) { etrax_hc_t *hc; DBFENTER; hc = urb->dev->bus->hcpriv; if (hc->rh.urb == urb) { hc->rh.send = 0; del_timer(&hc->rh.rh_int_timer); } DBFEXIT; return 0; } static void etrax_rh_send_irq(urb_t *urb) { __u16 data = 0; etrax_hc_t *hc = urb->dev->bus->hcpriv; // static prev_wPortStatus_1 = 0; // static prev_wPortStatus_2 = 0; /* DBFENTER; */ /* dbg_rh("R_USB_FM_NUMBER : 0x%08X", *R_USB_FM_NUMBER); dbg_rh("R_USB_FM_REMAINING: 0x%08X", *R_USB_FM_REMAINING); */ data |= (hc->rh.wPortChange_1) ? (1 << 1) : 0; data |= (hc->rh.wPortChange_2) ? (1 << 2) : 0; *((__u16 *)urb->transfer_buffer) = cpu_to_le16(data); urb->actual_length = 1; urb->status = 0; if (data && hc->rh.send && urb->complete) { dbg_rh("wPortChange_1: 0x%04X", hc->rh.wPortChange_1); dbg_rh("wPortChange_2: 0x%04X", hc->rh.wPortChange_2); urb->complete(urb); } /* DBFEXIT; */ } static void etrax_rh_init_int_timer(urb_t *urb) { etrax_hc_t *hc; /* DBFENTER; */ hc = urb->dev->bus->hcpriv; hc->rh.interval = urb->interval; init_timer(&hc->rh.rh_int_timer); hc->rh.rh_int_timer.function = etrax_rh_int_timer_do; hc->rh.rh_int_timer.data = (unsigned long)urb; hc->rh.rh_int_timer.expires = jiffies + ((HZ * hc->rh.interval) / 1000); add_timer(&hc->rh.rh_int_timer); /* DBFEXIT; */ } static void etrax_rh_int_timer_do(unsigned long ptr) { urb_t *urb; etrax_hc_t *hc; /* DBFENTER; */ urb = (urb_t*)ptr; hc = urb->dev->bus->hcpriv; if (hc->rh.send) { etrax_rh_send_irq(urb); } etrax_rh_init_int_timer(urb); /* DBFEXIT; */ } static void etrax_usb_setup_epid(int epid, char devnum, char endpoint, char packsize, char slow, char out_traffic) { unsigned long flags; DBFENTER; save_flags(flags); cli(); if (test_bit(epid, (void *)&ep_usage_bitmask)) { restore_flags(flags); warn("Trying to setup used epid %d", epid); DBFEXIT; return; } set_bit(epid, (void *)&ep_usage_bitmask); *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid); nop(); *R_USB_EPT_DATA = IO_STATE(R_USB_EPT_DATA, valid, yes) | IO_FIELD(R_USB_EPT_DATA, ep, endpoint) | IO_FIELD(R_USB_EPT_DATA, dev, devnum) | IO_FIELD(R_USB_EPT_DATA, max_len, packsize) | IO_FIELD(R_USB_EPT_DATA, low_speed, slow); if (out_traffic) set_bit(epid, (void *)&ep_out_traffic); else clear_bit(epid, (void *)&ep_out_traffic); restore_flags(flags); dbg_ep("Setting up ep_id %d with devnum %d, endpoint %d and max_len %d (%s)", epid, devnum, endpoint, packsize, out_traffic ? "OUT" : "IN"); DBFEXIT; } static void etrax_usb_free_epid(int epid) { unsigned long flags; DBFENTER; if (!test_bit(epid, (void *)&ep_usage_bitmask)) { warn("Trying to free unused epid %d", epid); DBFEXIT; return; } save_flags(flags); cli(); *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid); nop(); while (*R_USB_EPT_DATA & IO_MASK(R_USB_EPT_DATA, hold)) printk("+"); *R_USB_EPT_DATA = 0; clear_bit(epid, (void *)&ep_usage_bitmask); restore_flags(flags); dbg_ep("epid: %d freed", epid); DBFEXIT; } static int etrax_usb_lookup_epid(unsigned char devnum, char endpoint, char slow, int maxp, char out_traffic) { int i; unsigned long flags; __u32 data; DBFENTER; save_flags(flags); cli(); /* Skip first ep_id since it is reserved when intr. or iso traffic is used */ for (i = 0; i < NBR_OF_EP_DESC; i++) { if (test_bit(i, (void *)&ep_usage_bitmask) && test_bit(i, (void *)&ep_out_traffic) == out_traffic) { *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, i); nop(); data = *R_USB_EPT_DATA; if ((IO_MASK(R_USB_EPT_DATA, valid) & data) && (IO_EXTRACT(R_USB_EPT_DATA, dev, data) == devnum) && (IO_EXTRACT(R_USB_EPT_DATA, ep, data) == endpoint) && (IO_EXTRACT(R_USB_EPT_DATA, low_speed, data) == slow) && (IO_EXTRACT(R_USB_EPT_DATA, max_len, data) == maxp)) { restore_flags(flags); dbg_ep("Found ep_id %d for devnum %d, endpoint %d (%s)", i, devnum, endpoint, out_traffic ? "OUT" : "IN"); DBFEXIT; return i; } } } restore_flags(flags); dbg_ep("Found no ep_id for devnum %d, endpoint %d (%s)", devnum, endpoint, out_traffic ? "OUT" : "IN"); DBFEXIT; return -1; } static int etrax_usb_allocate_epid(void) { int i; DBFENTER; for (i = 0; i < NBR_OF_EP_DESC; i++) { if (!test_bit(i, (void *)&ep_usage_bitmask)) { dbg_ep("Found free ep_id at %d", i); DBFEXIT; return i; } } dbg_ep("Found no free ep_id's"); DBFEXIT; return -1; } static int etrax_usb_submit_bulk_urb(urb_t *urb) { int epid; char devnum; char endpoint; char maxlen; char out_traffic; char slow; urb_t *tmp_urb; unsigned long flags; DBFENTER; devnum = usb_pipedevice(urb->pipe); endpoint = usb_pipeendpoint(urb->pipe); maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe)); out_traffic = usb_pipeout(urb->pipe); slow = usb_pipeslow(urb->pipe); epid = etrax_usb_lookup_epid(devnum, endpoint, slow, maxlen, out_traffic); if (epid == -1) { epid = etrax_usb_allocate_epid(); if (epid == -1) { /* We're out of endpoints, return some error */ err("We're out of endpoints"); return -ENOMEM; } /* Now we have to fill in this ep */ etrax_usb_setup_epid(epid, devnum, endpoint, maxlen, slow, out_traffic); } /* Ok, now we got valid endpoint, lets insert some traffic */ urb->status = -EINPROGRESS; save_flags(flags); cli(); if (URB_List[epid]) { /* Find end of list and add */ for (tmp_urb = URB_List[epid]; tmp_urb->next; tmp_urb = tmp_urb->next) dump_urb(tmp_urb); tmp_urb->next = urb; restore_flags(flags); } else { /* If this is the first URB, add the URB and do HW add */ URB_List[epid] = urb; restore_flags(flags); etrax_usb_do_bulk_hw_add(urb, epid, maxlen); } DBFEXIT; return 0; } static void etrax_usb_do_bulk_hw_add(urb_t *urb, int epid, char maxlen) { USB_SB_Desc_t *sb_desc_1; etrax_urb_priv_t *urb_priv; unsigned long flags; DBFENTER; urb_priv = kmalloc(sizeof(etrax_urb_priv_t), GFP_KERNEL); sb_desc_1 = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, GFP_KERNEL); if (usb_pipeout(urb->pipe)) { dbg_bulk("Bulk transfer for epid %d is OUT", epid); dbg_bulk("transfer_buffer_length == %d", urb->transfer_buffer_length); dbg_bulk("actual_length == %d", urb->actual_length); if (urb->transfer_buffer_length > 0xffff) { panic(__FILE__ __FUNCTION__ ":urb->transfer_buffer_length > 0xffff\n"); } sb_desc_1->sw_len = urb->transfer_buffer_length; /* was actual_length */ sb_desc_1->command = IO_FIELD(USB_SB_command, rem, 0) | IO_STATE(USB_SB_command, tt, out) | #if 0 IO_STATE(USB_SB_command, full, no) | #else IO_STATE(USB_SB_command, full, yes) | #endif IO_STATE(USB_SB_command, eot, yes) | IO_STATE(USB_SB_command, eol, yes); dbg_bulk("transfer_buffer is at 0x%08X", urb->transfer_buffer); sb_desc_1->buf = virt_to_phys(urb->transfer_buffer); sb_desc_1->next = 0; } else if (usb_pipein(urb->pipe)) { dbg_bulk("Transfer for epid %d is IN", epid); dbg_bulk("transfer_buffer_length = %d", urb->transfer_buffer_length); dbg_bulk("rem is calculated to %d", urb->transfer_buffer_length % maxlen); sb_desc_1->sw_len = urb->transfer_buffer_length ? (urb->transfer_buffer_length - 1) / maxlen + 1 : 0; dbg_bulk("sw_len got %d", sb_desc_1->sw_len); dbg_bulk("transfer_buffer is at 0x%08X", urb->transfer_buffer); sb_desc_1->command = IO_FIELD(USB_SB_command, rem, urb->transfer_buffer_length % maxlen) | IO_STATE(USB_SB_command, tt, in) | IO_STATE(USB_SB_command, eot, yes) | IO_STATE(USB_SB_command, eol, yes); sb_desc_1->buf = 0; sb_desc_1->next = 0; urb_priv->rx_offset = 0; urb_priv->eot = 0; } urb_priv->first_sb = sb_desc_1; urb->hcpriv = (void *)urb_priv; /* Reset toggle bits and reset error count, remeber to di and ei */ /* Warning: it is possible that this locking doesn't work with bottom-halves */ save_flags(flags); cli(); *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid); nop(); if (*R_USB_EPT_DATA & IO_MASK(R_USB_EPT_DATA, hold)) { panic("Hold was set in %s\n", __FUNCTION__); } *R_USB_EPT_DATA &= ~(IO_MASK(R_USB_EPT_DATA, error_count_in) | IO_MASK(R_USB_EPT_DATA, error_count_out)); if (usb_pipeout(urb->pipe)) { char toggle = usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe), usb_pipeout(urb->pipe)); *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_out); *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_out, toggle); } else { char toggle = usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe), usb_pipeout(urb->pipe)); *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_in); *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_in, toggle); } /* Enable the EP descr. */ set_bit(epid, (void *)&ep_really_active); TxBulkEPList[epid].sub = virt_to_phys(sb_desc_1); TxBulkEPList[epid].hw_len = 0; TxBulkEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes); restore_flags(flags); if (!(*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd))) { *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start); } DBFEXIT; } static void handle_bulk_transfer_attn(int epid, int status) { urb_t *old_urb; etrax_urb_priv_t *hc_priv; unsigned long flags; DBFENTER; clear_bit(epid, (void *)&ep_really_active); old_urb = URB_List[epid]; URB_List[epid] = old_urb->next; /* if (status == 0 && IN) find data and copy to urb */ if (status == 0 && usb_pipein(old_urb->pipe)) { etrax_urb_priv_t *urb_priv; urb_priv = (etrax_urb_priv_t *)old_urb->hcpriv; save_flags(flags); cli(); if (urb_priv->eot == 1) { old_urb->actual_length = urb_priv->rx_offset; } else { if (urb_priv->rx_offset == 0) { status = 0; } else { status = -EPROTO; } old_urb->actual_length = 0; err("(BULK) No eot set in IN data!!! rx_offset is: %d", urb_priv->rx_offset); } restore_flags(flags); } save_flags(flags); cli(); *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid); nop(); if (usb_pipeout(old_urb->pipe)) { char toggle = IO_EXTRACT(R_USB_EPT_DATA, t_out, *R_USB_EPT_DATA); usb_settoggle(old_urb->dev, usb_pipeendpoint(old_urb->pipe), usb_pipeout(old_urb->pipe), toggle); } else { char toggle = IO_EXTRACT(R_USB_EPT_DATA, t_in, *R_USB_EPT_DATA); usb_settoggle(old_urb->dev, usb_pipeendpoint(old_urb->pipe), usb_pipeout(old_urb->pipe), toggle); } restore_flags(flags); /* If there are any more URB's in the list we'd better start sending */ if (URB_List[epid]) { etrax_usb_do_bulk_hw_add(URB_List[epid], epid, usb_maxpacket(URB_List[epid]->dev, URB_List[epid]->pipe, usb_pipeout(URB_List[epid]->pipe))); } #if 1 else { /* This means that this EP is now free, deconfigure it */ etrax_usb_free_epid(epid); } #endif /* Remember to free the SB's */ hc_priv = (etrax_urb_priv_t *)old_urb->hcpriv; cleanup_sb(hc_priv->first_sb); kfree(hc_priv); old_urb->status = status; if (old_urb->complete) { old_urb->complete(old_urb); } DBFEXIT; } /* ---------------------------------------------------------------------------- */ static int etrax_usb_submit_ctrl_urb(urb_t *urb) { int epid; char devnum; char endpoint; char maxlen; char out_traffic; char slow; urb_t *tmp_urb; unsigned long flags; DBFENTER; devnum = usb_pipedevice(urb->pipe); endpoint = usb_pipeendpoint(urb->pipe); maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe)); out_traffic = usb_pipeout(urb->pipe); slow = usb_pipeslow(urb->pipe); epid = etrax_usb_lookup_epid(devnum, endpoint, slow, maxlen, out_traffic); if (epid == -1) { epid = etrax_usb_allocate_epid(); if (epid == -1) { /* We're out of endpoints, return some error */ err("We're out of endpoints"); return -ENOMEM; } /* Now we have to fill in this ep */ etrax_usb_setup_epid(epid, devnum, endpoint, maxlen, slow, out_traffic); } /* Ok, now we got valid endpoint, lets insert some traffic */ urb->status = -EINPROGRESS; save_flags(flags); cli(); if (URB_List[epid]) { /* Find end of list and add */ for (tmp_urb = URB_List[epid]; tmp_urb->next; tmp_urb = tmp_urb->next) dump_urb(tmp_urb); tmp_urb->next = urb; restore_flags(flags); } else { /* If this is the first URB, add the URB and do HW add */ URB_List[epid] = urb; restore_flags(flags); etrax_usb_do_ctrl_hw_add(urb, epid, maxlen); } DBFEXIT; return 0; } static void etrax_usb_do_ctrl_hw_add(urb_t *urb, int epid, char maxlen) { USB_SB_Desc_t *sb_desc_1; USB_SB_Desc_t *sb_desc_2; USB_SB_Desc_t *sb_desc_3; etrax_urb_priv_t *urb_priv; unsigned long flags; DBFENTER; urb_priv = kmalloc(sizeof(etrax_urb_priv_t), GFP_KERNEL); sb_desc_1 = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, GFP_KERNEL); sb_desc_2 = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, GFP_KERNEL); if (!(sb_desc_1 && sb_desc_2)) { panic("kmem_cache_alloc in ctrl_hw_add gave NULL pointers !!!\n"); } sb_desc_1->sw_len = 8; sb_desc_1->command = IO_FIELD(USB_SB_command, rem, 0) | IO_STATE(USB_SB_command, tt, setup) | IO_STATE(USB_SB_command, full, yes) | IO_STATE(USB_SB_command, eot, yes); sb_desc_1->buf = virt_to_phys(urb->setup_packet); sb_desc_1->next = virt_to_phys(sb_desc_2); dump_sb_desc(sb_desc_1); if (usb_pipeout(urb->pipe)) { dbg_ctrl("Transfer for epid %d is OUT", epid); /* If this Control OUT transfer has an optional data stage we add an OUT token before the mandatory IN (status) token, hence the reordered SB list */ if (urb->transfer_buffer) { dbg_ctrl("This OUT transfer has an extra data stage"); sb_desc_3 = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, GFP_KERNEL); sb_desc_1->next = virt_to_phys(sb_desc_3); sb_desc_3->sw_len = urb->transfer_buffer_length; sb_desc_3->command = IO_STATE(USB_SB_command, tt, out) | IO_STATE(USB_SB_command, full, yes) | IO_STATE(USB_SB_command, eot, yes); sb_desc_3->buf = virt_to_phys(urb->transfer_buffer); sb_desc_3->next = virt_to_phys(sb_desc_2); } sb_desc_2->sw_len = 1; sb_desc_2->command = IO_FIELD(USB_SB_command, rem, 0) | IO_STATE(USB_SB_command, tt, in) | IO_STATE(USB_SB_command, eot, yes) | IO_STATE(USB_SB_command, eol, yes); sb_desc_2->buf = 0; sb_desc_2->next = 0; dump_sb_desc(sb_desc_2); } else if (usb_pipein(urb->pipe)) { dbg_ctrl("Transfer for epid %d is IN", epid); dbg_ctrl("transfer_buffer_length = %d", urb->transfer_buffer_length); dbg_ctrl("rem is calculated to %d", urb->transfer_buffer_length % maxlen); sb_desc_3 = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, GFP_KERNEL); sb_desc_2->sw_len = urb->transfer_buffer_length ? (urb->transfer_buffer_length - 1) / maxlen + 1 : 0; dbg_ctrl("sw_len got %d", sb_desc_2->sw_len); sb_desc_2->command = IO_FIELD(USB_SB_command, rem, urb->transfer_buffer_length % maxlen) | IO_STATE(USB_SB_command, tt, in) | IO_STATE(USB_SB_command, eot, yes); sb_desc_2->buf = 0; sb_desc_2->next = virt_to_phys(sb_desc_3); dump_sb_desc(sb_desc_2); sb_desc_3->sw_len = 1; sb_desc_3->command = IO_FIELD(USB_SB_command, rem, 0) | IO_STATE(USB_SB_command, tt, zout) | IO_STATE(USB_SB_command, full, yes) | IO_STATE(USB_SB_command, eot, yes) | IO_STATE(USB_SB_command, eol, yes); sb_desc_3->buf = 0; sb_desc_3->next = 0; dump_sb_desc(sb_desc_3); urb_priv->rx_offset = 0; urb_priv->eot = 0; } urb_priv->first_sb = sb_desc_1; urb->hcpriv = (void *)urb_priv; /* Reset toggle bits and reset error count, remeber to di and ei */ /* Warning: it is possible that this locking doesn't work with bottom-halves */ save_flags(flags); cli(); *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid); nop(); if (*R_USB_EPT_DATA & IO_MASK(R_USB_EPT_DATA, hold)) { panic("Hold was set in %s\n", __FUNCTION__); } *R_USB_EPT_DATA &= ~(IO_MASK(R_USB_EPT_DATA, error_count_in) | IO_MASK(R_USB_EPT_DATA, error_count_out) | IO_MASK(R_USB_EPT_DATA, t_in) | IO_MASK(R_USB_EPT_DATA, t_out)); /* Enable the EP descr. */ set_bit(epid, (void *)&ep_really_active); TxCtrlEPList[epid].sub = virt_to_phys(sb_desc_1); TxCtrlEPList[epid].hw_len = 0; TxCtrlEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes); restore_flags(flags); dump_ep_desc(&TxCtrlEPList[epid]); if (!(*R_DMA_CH8_SUB1_CMD & IO_MASK(R_DMA_CH8_SUB1_CMD, cmd))) { *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB1_CMD, cmd, start); } DBFEXIT; } static int etrax_usb_submit_urb(urb_t *urb) { etrax_hc_t *hc; int rval = -EINVAL; DBFENTER; urb->next = NULL; dump_urb(urb); submit_urb_count++; hc = (etrax_hc_t*) urb->dev->bus->hcpriv; if (usb_pipedevice(urb->pipe) == hc->rh.devnum) { /* This request if for the Virtual Root Hub */ rval = etrax_rh_submit_urb(urb); } else if (usb_pipetype(urb->pipe) == PIPE_CONTROL) { rval = etrax_usb_submit_ctrl_urb(urb); } else if (usb_pipetype(urb->pipe) == PIPE_BULK) { rval = etrax_usb_submit_bulk_urb(urb); } else if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) { int bustime; if (urb->bandwidth == 0) { bustime = usb_check_bandwidth(urb->dev, urb); if (bustime < 0) { rval = bustime; } else { usb_claim_bandwidth(urb->dev, urb, bustime, 0); rval = etrax_usb_submit_intr_urb(urb); } } } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) { warn("Isochronous traffic is not supported !!!"); rval = -EINVAL; } DBFEXIT; return rval; } static int etrax_usb_unlink_urb(urb_t *urb) { etrax_hc_t *hc = urb->dev->bus->hcpriv; int epid; int devnum, endpoint, slow, maxlen, out_traffic; etrax_urb_priv_t *hc_priv; unsigned long flags; DBFENTER; dump_urb(urb); devnum = usb_pipedevice(urb->pipe); endpoint = usb_pipeendpoint(urb->pipe); slow = usb_pipeslow(urb->pipe); maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe)); out_traffic = usb_pipeout(urb->pipe); epid = etrax_usb_lookup_epid(devnum, endpoint, slow, maxlen, out_traffic); if (epid == -1) return 0; if (usb_pipedevice(urb->pipe) == hc->rh.devnum) { int ret; ret = etrax_rh_unlink_urb(urb); DBFEXIT; return ret; } else if (usb_pipetype(URB_List[epid]->pipe) == PIPE_INTERRUPT) { int ret; ret = etrax_usb_unlink_intr_urb(urb); urb->status = -ENOENT; if (urb->complete) { urb->complete(urb); } DBFEXIT; return ret; } info("Unlink of BULK or CTRL"); save_flags(flags); cli(); for (epid = 0; epid < 32; epid++) { urb_t *u = URB_List[epid]; urb_t *prev = NULL; int pos = 0; for (; u; u = u->next) { pos++; if (u == urb) { if (!prev) { URB_List[epid] = u->next; } else { prev->next = u->next; } restore_flags(flags); if (!prev) { if (usb_pipetype(u->pipe) == PIPE_CONTROL) { if (TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) { /* The EP was enabled, disable it and wait */ TxCtrlEPList[epid].command &= ~IO_MASK(USB_EP_command, enable); while (*R_DMA_CH8_SUB1_EP == virt_to_phys(&TxCtrlEPList[epid])); } } else if (usb_pipetype(u->pipe) == PIPE_BULK) { if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) { TxBulkEPList[epid].command &= ~IO_MASK(USB_EP_command, enable); while (*R_DMA_CH8_SUB0_EP == virt_to_phys(&TxBulkEPList[epid])); } } } info("Found urb at epid %d, pos %d", epid, pos); u->status = -ENOENT; if (u->complete) { u->complete(u); } hc_priv = (etrax_urb_priv_t *)u->hcpriv; cleanup_sb(hc_priv->first_sb); kfree(hc_priv); DBFEXIT; return 0; } prev = u; } } restore_flags(flags); DBFEXIT; return 0; } static int etrax_usb_get_frame_number(struct usb_device *usb_dev) { DBFENTER; DBFEXIT; return (*R_USB_FM_NUMBER); } static int etrax_usb_allocate_dev(struct usb_device *usb_dev) { DBFENTER; DBFEXIT; return 0; } static int etrax_usb_deallocate_dev(struct usb_device *usb_dev) { DBFENTER; DBFEXIT; return 0; } static void etrax_usb_tx_interrupt(int irq, void *vhc, struct pt_regs *regs) { DBFENTER; if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub0_descr)) { info("dma8_sub0_descr (BULK) intr."); *R_DMA_CH8_SUB0_CLR_INTR = IO_STATE(R_DMA_CH8_SUB0_CLR_INTR, clr_descr, do); } if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub1_descr)) { info("dma8_sub1_descr (CTRL) intr."); *R_DMA_CH8_SUB1_CLR_INTR = IO_STATE(R_DMA_CH8_SUB1_CLR_INTR, clr_descr, do); } if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub2_descr)) { info("dma8_sub2_descr (INT) intr."); *R_DMA_CH8_SUB2_CLR_INTR = IO_STATE(R_DMA_CH8_SUB2_CLR_INTR, clr_descr, do); } if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub3_descr)) { info("dma8_sub3_descr (ISO) intr."); *R_DMA_CH8_SUB3_CLR_INTR = IO_STATE(R_DMA_CH8_SUB3_CLR_INTR, clr_descr, do); } DBFEXIT; } static void etrax_usb_rx_interrupt(int irq, void *vhc, struct pt_regs *regs) { int epid = 0; urb_t *urb; etrax_urb_priv_t *urb_priv; *R_DMA_CH9_CLR_INTR = IO_STATE(R_DMA_CH9_CLR_INTR, clr_eop, do); while (myNextRxDesc->status & IO_MASK(USB_IN_status, eop)) { if (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata)) { goto skip_out; } if (myNextRxDesc->status & IO_MASK(USB_IN_status, error)) { goto skip_out; } epid = IO_EXTRACT(USB_IN_status, epid, myNextRxDesc->status); urb = URB_List[epid]; if (urb && usb_pipein(urb->pipe)) { urb_priv = (etrax_urb_priv_t *)urb->hcpriv; if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) { struct in_chunk *in; dbg_intr("Packet for epid %d in rx buffers", epid); in = kmalloc(sizeof(struct in_chunk), GFP_ATOMIC); in->length = myNextRxDesc->hw_len; in->data = kmalloc(in->length, GFP_ATOMIC); memcpy(in->data, phys_to_virt(myNextRxDesc->buf), in->length); list_add_tail(&in->list, &urb_priv->ep_in_list); #ifndef ETRAX_USB_INTR_IRQ etrax_usb_hc_intr_top_half(irq, vhc, regs); #endif } else { if ((urb_priv->rx_offset + myNextRxDesc->hw_len) > urb->transfer_buffer_length) { err("Packet (epid: %d) in RX buffer (%d) was bigger " "than the URB has room for (%d)!!!", epid, urb_priv->rx_offset + myNextRxDesc->hw_len, urb->transfer_buffer_length); goto skip_out; } memcpy(urb->transfer_buffer + urb_priv->rx_offset, phys_to_virt(myNextRxDesc->buf), myNextRxDesc->hw_len); urb_priv->rx_offset += myNextRxDesc->hw_len; } if (myNextRxDesc->status & IO_MASK(USB_IN_status, eot)) { urb_priv->eot = 1; } } else { err("This is almost fatal, inpacket for epid %d which does not exist " " or is out!!!\nURB was at 0x%08lX", epid, (unsigned long)urb); goto skip_out; } skip_out: myPrevRxDesc = myNextRxDesc; myPrevRxDesc->command |= IO_MASK(USB_IN_command, eol); myLastRxDesc->command &= ~IO_MASK(USB_IN_command, eol); myLastRxDesc = myPrevRxDesc; myNextRxDesc->status = 0; myNextRxDesc = phys_to_virt(myNextRxDesc->next); } } static void cleanup_sb(USB_SB_Desc_t *sb) { USB_SB_Desc_t *next_sb; DBFENTER; if (sb == NULL) { err("cleanup_sb was given a NULL pointer"); return; } while (!(sb->command & IO_MASK(USB_SB_command, eol))) { next_sb = (USB_SB_Desc_t *)phys_to_virt(sb->next); kmem_cache_free(usb_desc_cache, sb); sb = next_sb; } kmem_cache_free(usb_desc_cache, sb); DBFEXIT; } static void handle_control_transfer_attn(int epid, int status) { urb_t *old_urb; etrax_urb_priv_t *hc_priv; DBFENTER; clear_bit(epid, (void *)&ep_really_active); old_urb = URB_List[epid]; URB_List[epid] = old_urb->next; /* if (status == 0 && IN) find data and copy to urb */ if (status == 0 && usb_pipein(old_urb->pipe)) { unsigned long flags; etrax_urb_priv_t *urb_priv; urb_priv = (etrax_urb_priv_t *)old_urb->hcpriv; save_flags(flags); cli(); if (urb_priv->eot == 1) { old_urb->actual_length = urb_priv->rx_offset; dbg_ctrl("urb_priv->rx_offset: %d in handle_control_attn", urb_priv->rx_offset); } else { status = -EPROTO; old_urb->actual_length = 0; err("(CTRL) No eot set in IN data!!! rx_offset: %d", urb_priv->rx_offset); } restore_flags(flags); } /* If there are any more URB's in the list we'd better start sending */ if (URB_List[epid]) { etrax_usb_do_ctrl_hw_add(URB_List[epid], epid, usb_maxpacket(URB_List[epid]->dev, URB_List[epid]->pipe, usb_pipeout(URB_List[epid]->pipe))); } #if 1 else { /* This means that this EP is now free, deconfigure it */ etrax_usb_free_epid(epid); } #endif /* Remember to free the SB's */ hc_priv = (etrax_urb_priv_t *)old_urb->hcpriv; cleanup_sb(hc_priv->first_sb); kfree(hc_priv); old_urb->status = status; if (old_urb->complete) { old_urb->complete(old_urb); } DBFEXIT; } static void etrax_usb_hc_intr_bottom_half(void *data) { struct usb_reg_context *reg = (struct usb_reg_context *)data; int error_code; int epid; __u32 r_usb_ept_data; etrax_hc_t *hc = reg->hc; __u16 r_usb_rh_port_status_1; __u16 r_usb_rh_port_status_2; DBFENTER; if (reg->r_usb_irq_mask_read & IO_MASK(R_USB_IRQ_MASK_READ, port_status)) { /* The Etrax RH does not include a wPortChange register, so this has to be handled in software. See section 11.16.2.6.2 in USB 1.1 spec for details. */ r_usb_rh_port_status_1 = reg->r_usb_rh_port_status_1; r_usb_rh_port_status_2 = reg->r_usb_rh_port_status_2; dbg_rh("port_status pending"); dbg_rh("r_usb_rh_port_status_1: 0x%04X", r_usb_rh_port_status_1); dbg_rh("r_usb_rh_port_status_2: 0x%04X", r_usb_rh_port_status_2); /* C_PORT_CONNECTION is set on any transition */ hc->rh.wPortChange_1 |= ((r_usb_rh_port_status_1 & (1 << RH_PORT_CONNECTION)) != (hc->rh.prev_wPortStatus_1 & (1 << RH_PORT_CONNECTION))) ? (1 << RH_PORT_CONNECTION) : 0; hc->rh.wPortChange_2 |= ((r_usb_rh_port_status_2 & (1 << RH_PORT_CONNECTION)) != (hc->rh.prev_wPortStatus_2 & (1 << RH_PORT_CONNECTION))) ? (1 << RH_PORT_CONNECTION) : 0; /* C_PORT_ENABLE is _only_ set on a one to zero transition */ hc->rh.wPortChange_1 |= ((hc->rh.prev_wPortStatus_1 & (1 << RH_PORT_ENABLE)) && !(r_usb_rh_port_status_1 & (1 << RH_PORT_ENABLE))) ? (1 << RH_PORT_ENABLE) : 0; hc->rh.wPortChange_2 |= ((hc->rh.prev_wPortStatus_2 & (1 << RH_PORT_ENABLE)) && !(r_usb_rh_port_status_2 & (1 << RH_PORT_ENABLE))) ? (1 << RH_PORT_ENABLE) : 0; /* C_PORT_SUSPEND seems difficult, lets ignore it.. (for now) */ /* C_PORT_RESET is _only_ set on a transition from the resetting state to the enabled state */ hc->rh.wPortChange_1 |= ((hc->rh.prev_wPortStatus_1 & (1 << RH_PORT_RESET)) && (r_usb_rh_port_status_1 & (1 << RH_PORT_ENABLE))) ? (1 << RH_PORT_RESET) : 0; hc->rh.wPortChange_2 |= ((hc->rh.prev_wPortStatus_2 & (1 << RH_PORT_RESET)) && (r_usb_rh_port_status_2 & (1 << RH_PORT_ENABLE))) ? (1 << RH_PORT_RESET) : 0; hc->rh.prev_wPortStatus_1 = r_usb_rh_port_status_1; hc->rh.prev_wPortStatus_2 = r_usb_rh_port_status_2; } for (epid = 0; epid < 32; epid++) { unsigned long flags; save_flags(flags); cli(); *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid); nop(); r_usb_ept_data = *R_USB_EPT_DATA; restore_flags(flags); if (r_usb_ept_data & IO_MASK(R_USB_EPT_DATA, hold)) { warn("Was hold for epid %d", epid); continue; } if (!(r_usb_ept_data & IO_MASK(R_USB_EPT_DATA, valid))) { continue; } if (test_bit(epid, (void *)®->r_usb_epid_attn)) { if (URB_List[epid] == NULL) { err("R_USB_EPT_DATA is 0x%08X", r_usb_ept_data); err("submit urb has been called %lu times..", submit_urb_count); err("EPID_ATTN for epid %d, with NULL entry in list", epid); return; } dbg_ep("r_usb_ept_data [%d] == 0x%08X", epid, r_usb_ept_data); error_code = IO_EXTRACT(R_USB_EPT_DATA, error_code, r_usb_ept_data); if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) { /* no_error means that this urb was sucessfully sent or that we have some undefinde error*/ if (IO_EXTRACT(R_USB_EPT_DATA, error_count_out, r_usb_ept_data) == 3 || IO_EXTRACT(R_USB_EPT_DATA, error_count_in, r_usb_ept_data) == 3) { /* Actually there were transmission errors */ warn("Undefined error for epid %d", epid); if (usb_pipetype(URB_List[epid]->pipe) == PIPE_CONTROL) { handle_control_transfer_attn(epid, -EPROTO); } else if (usb_pipetype(URB_List[epid]->pipe) == PIPE_BULK) { handle_bulk_transfer_attn(epid, -EPROTO); } else if (usb_pipetype(URB_List[epid]->pipe) == PIPE_INTERRUPT) { handle_intr_transfer_attn(epid, -EPROTO); } } else { if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) { if (usb_pipetype(URB_List[epid]->pipe) == PIPE_INTERRUPT) { etrax_usb_do_intr_recover(epid); } else { panic("Epid attention for epid %d (none INTR), with no errors and no " "exessive retry r_usb_status is 0x%02X\n", epid, reg->r_usb_status); } } else if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) { panic("Epid attention for epid %d, with no errors and no " "exessive retry r_usb_status is 0x%02X\n", epid, reg->r_usb_status); } warn("Epid attention for epid %d, with no errors and no " "exessive retry r_usb_status is 0x%02X", epid, reg->r_usb_status); warn("OUT error count: %d", IO_EXTRACT(R_USB_EPT_DATA, error_count_out, r_usb_ept_data)); warn("IN error count: %d", IO_EXTRACT(R_USB_EPT_DATA, error_count_in, r_usb_ept_data)); } } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, stall)) { warn("Stall for epid %d", epid); if (usb_pipetype(URB_List[epid]->pipe) == PIPE_CONTROL) { handle_control_transfer_attn(epid, -EPIPE); } else if (usb_pipetype(URB_List[epid]->pipe) == PIPE_BULK) { handle_bulk_transfer_attn(epid, -EPIPE); } else if (usb_pipetype(URB_List[epid]->pipe) == PIPE_INTERRUPT) { handle_intr_transfer_attn(epid, -EPIPE); } } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, bus_error)) { panic("USB bus error for epid %d\n", epid); } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, buffer_error)) { warn("Buffer error for epid %d", epid); if (usb_pipetype(URB_List[epid]->pipe) == PIPE_CONTROL) { handle_control_transfer_attn(epid, -EPROTO); } else if (usb_pipetype(URB_List[epid]->pipe) == PIPE_BULK) { handle_bulk_transfer_attn(epid, -EPROTO); } else if (usb_pipetype(URB_List[epid]->pipe) == PIPE_INTERRUPT) { handle_intr_transfer_attn(epid, -EPROTO); } } } else if (test_bit(epid, (void *)&ep_really_active)) { /* Should really be else if (testbit(really active)) */ if (usb_pipetype(URB_List[epid]->pipe) == PIPE_CONTROL) { if (!(TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable))) { /* Now we have to verify that this CTRL endpoint got disabled cause it reached end of list with no error */ if (IO_EXTRACT(R_USB_EPT_DATA, error_code, r_usb_ept_data) == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) { /* This means that the endpoint has no error, is disabled and had inserted traffic, i.e. transfer sucessfully completed */ dbg_ctrl("Last SB for CTRL %d sent sucessfully", epid); handle_control_transfer_attn(epid, 0); } } } else if (usb_pipetype(URB_List[epid]->pipe) == PIPE_BULK) { if (!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable))) { /* Now we have to verify that this BULK endpoint go disabled cause it reached end of list with no error */ if (IO_EXTRACT(R_USB_EPT_DATA, error_code, r_usb_ept_data) == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) { /* This means that the endpoint has no error, is disabled and had inserted traffic, i.e. transfer sucessfully completed */ dbg_bulk("Last SB for BULK %d sent sucessfully", epid); handle_bulk_transfer_attn(epid, 0); } } } else if (usb_pipetype(URB_List[epid]->pipe) == PIPE_INTERRUPT) { handle_intr_transfer_attn(epid, 0); } } } kfree(reg); DBFEXIT; } static void etrax_usb_hc_intr_top_half(int irq, void *vhc, struct pt_regs *regs) { struct usb_reg_context *reg; DBFENTER; reg = (struct usb_reg_context *)kmalloc(sizeof(struct usb_reg_context), GFP_ATOMIC); if (!(reg)) { panic("kmalloc failed in top_half\n"); } reg->hc = (etrax_hc_t *)vhc; reg->r_usb_irq_mask_read = *R_USB_IRQ_MASK_READ; reg->r_usb_status = *R_USB_STATUS; #if 0 if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) { panic("r_usb_status said perror\n"); } if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) { panic("r_usb_status said ourun !!!\n"); } #endif reg->r_usb_epid_attn = *R_USB_EPID_ATTN; reg->r_usb_rh_port_status_1 = *R_USB_RH_PORT_STATUS_1; reg->r_usb_rh_port_status_2 = *R_USB_RH_PORT_STATUS_2; reg->usb_bh.sync = 0; reg->usb_bh.routine = etrax_usb_hc_intr_bottom_half; reg->usb_bh.data = reg; queue_task(®->usb_bh, &tq_immediate); mark_bh(IMMEDIATE_BH); DBFEXIT; } static int etrax_rh_submit_urb(urb_t *urb) { struct usb_device *usb_dev = urb->dev; etrax_hc_t *hc = usb_dev->bus->hcpriv; unsigned int pipe = urb->pipe; devrequest *cmd = (devrequest *) urb->setup_packet; void *data = urb->transfer_buffer; int leni = urb->transfer_buffer_length; int len = 0; int stat = 0; __u16 bmRType_bReq; __u16 wValue; __u16 wIndex; __u16 wLength; DBFENTER; if (usb_pipetype (pipe) == PIPE_INTERRUPT) { dbg_rh("Root-Hub submit IRQ: every %d ms", urb->interval); hc->rh.urb = urb; hc->rh.send = 1; hc->rh.interval = urb->interval; etrax_rh_init_int_timer(urb); DBFEXIT; return 0; } bmRType_bReq = cmd->requesttype | cmd->request << 8; wValue = le16_to_cpu(cmd->value); wIndex = le16_to_cpu(cmd->index); wLength = le16_to_cpu(cmd->length); dbg_rh("bmRType_bReq : 0x%04X (%d)", bmRType_bReq, bmRType_bReq); dbg_rh("wValue : 0x%04X (%d)", wValue, wValue); dbg_rh("wIndex : 0x%04X (%d)", wIndex, wIndex); dbg_rh("wLength : 0x%04X (%d)", wLength, wLength); switch (bmRType_bReq) { /* Request Destination: without flags: Device, RH_INTERFACE: interface, RH_ENDPOINT: endpoint, RH_CLASS means HUB here, RH_OTHER | RH_CLASS almost ever means HUB_PORT here */ case RH_GET_STATUS: *(__u16 *) data = cpu_to_le16 (1); OK (2); case RH_GET_STATUS | RH_INTERFACE: *(__u16 *) data = cpu_to_le16 (0); OK (2); case RH_GET_STATUS | RH_ENDPOINT: *(__u16 *) data = cpu_to_le16 (0); OK (2); case RH_GET_STATUS | RH_CLASS: *(__u32 *) data = cpu_to_le32 (0); OK (4); /* hub power ** */ case RH_GET_STATUS | RH_OTHER | RH_CLASS: if (wIndex == 1) { *((__u16*)data) = cpu_to_le16(hc->rh.prev_wPortStatus_1); *((__u16*)data + 1) = cpu_to_le16(hc->rh.wPortChange_1); } else if (wIndex == 2) { *((__u16*)data) = cpu_to_le16(hc->rh.prev_wPortStatus_2); *((__u16*)data + 1) = cpu_to_le16(hc->rh.wPortChange_2); } else { dbg_rh("RH_GET_STATUS whith invalid wIndex !!"); OK(0); } OK(4); case RH_CLEAR_FEATURE | RH_ENDPOINT: switch (wValue) { case (RH_ENDPOINT_STALL): OK (0); } break; case RH_CLEAR_FEATURE | RH_CLASS: switch (wValue) { case (RH_C_HUB_OVER_CURRENT): OK (0); /* hub power over current ** */ } break; case RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS: switch (wValue) { case (RH_PORT_ENABLE): if (wIndex == 1) { dbg_rh("trying to do disable of port 1"); *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, yes); while (hc->rh.prev_wPortStatus_1 & IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes)); *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, no); dbg_rh("Port 1 is disabled"); } else if (wIndex == 2) { dbg_rh("trying to do disable of port 2"); *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, yes); while (hc->rh.prev_wPortStatus_2 & IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, yes)); *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, no); dbg_rh("Port 2 is disabled"); } else { dbg_rh("RH_CLEAR_FEATURE->RH_PORT_ENABLE " "with invalid wIndex == %d!!", wIndex); } OK (0); case (RH_PORT_SUSPEND): /* Opposite to suspend should be resume, so well do a resume */ if (wIndex == 1) { *R_USB_COMMAND = IO_STATE(R_USB_COMMAND, port_sel, port1) | IO_STATE(R_USB_COMMAND, port_cmd, resume)| IO_STATE(R_USB_COMMAND, ctrl_cmd, nop); } else if (wIndex == 2) { *R_USB_COMMAND = IO_STATE(R_USB_COMMAND, port_sel, port2) | IO_STATE(R_USB_COMMAND, port_cmd, resume)| IO_STATE(R_USB_COMMAND, ctrl_cmd, nop); } else { dbg_rh("RH_CLEAR_FEATURE->RH_PORT_SUSPEND " "with invalid wIndex == %d!!", wIndex); } OK (0); case (RH_PORT_POWER): OK (0); /* port power ** */ case (RH_C_PORT_CONNECTION): if (wIndex == 1) { hc->rh.wPortChange_1 &= ~(1 << RH_PORT_CONNECTION); } else if (wIndex == 2) { hc->rh.wPortChange_2 &= ~(1 << RH_PORT_CONNECTION); } else { dbg_rh("RH_CLEAR_FEATURE->RH_C_PORT_CONNECTION " "with invalid wIndex == %d!!", wIndex); } OK (0); case (RH_C_PORT_ENABLE): if (wIndex == 1) { hc->rh.wPortChange_1 &= ~(1 << RH_PORT_ENABLE); } else if (wIndex == 2) { hc->rh.wPortChange_2 &= ~(1 << RH_PORT_ENABLE); } else { dbg_rh("RH_CLEAR_FEATURE->RH_C_PORT_ENABLE " "with invalid wIndex == %d!!", wIndex); } OK (0); case (RH_C_PORT_SUSPEND): /*** WR_RH_PORTSTAT(RH_PS_PSSC); */ OK (0); case (RH_C_PORT_OVER_CURRENT): OK (0); /* port power over current ** */ case (RH_C_PORT_RESET): if (wIndex == 1) { hc->rh.wPortChange_1 &= ~(1 << RH_PORT_RESET); } else if (wIndex == 2) { dbg_rh("This is wPortChange before clear: 0x%04X", hc->rh.wPortChange_2); hc->rh.wPortChange_2 &= ~(1 << RH_PORT_RESET); dbg_rh("This is wPortChange after clear: 0x%04X", hc->rh.wPortChange_2); } else { dbg_rh("RH_CLEAR_FEATURE->RH_C_PORT_RESET " "with invalid index == %d!!", wIndex); } OK (0); } break; case RH_SET_FEATURE | RH_OTHER | RH_CLASS: switch (wValue) { case (RH_PORT_SUSPEND): if (wIndex == 1) { *R_USB_COMMAND = IO_STATE(R_USB_COMMAND, port_sel, port1) | IO_STATE(R_USB_COMMAND, port_cmd, suspend) | IO_STATE(R_USB_COMMAND, ctrl_cmd, nop); } else if (wIndex == 2) { *R_USB_COMMAND = IO_STATE(R_USB_COMMAND, port_sel, port2) | IO_STATE(R_USB_COMMAND, port_cmd, suspend) | IO_STATE(R_USB_COMMAND, ctrl_cmd, nop); } else { dbg_rh("RH_SET_FEATURE->RH_C_PORT_SUSPEND " "with invalid wIndex == %d!!", wIndex); } OK (0); case (RH_PORT_RESET): if (wIndex == 1) { int port1_retry; port1_redo: dbg_rh("Doing reset of port 1"); *R_USB_COMMAND = IO_STATE(R_USB_COMMAND, port_cmd, reset) | IO_STATE(R_USB_COMMAND, port_sel, port1); /* We must once again wait at least 10ms for the device to recover */ port1_retry = 0; while (!((*((volatile __u16 *)&hc->rh.prev_wPortStatus_1)) & IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes))) { printk(""); if (port1_retry++ >= 10000) {goto port1_redo;} } /* This only seems to work if we use printk, not even schedule() works !!! WHY ?? */ udelay(15000); } else if (wIndex == 2) { int port2_retry; port2_redo: dbg_rh("Doing reset of port 2"); *R_USB_COMMAND = IO_STATE(R_USB_COMMAND, port_cmd, reset) | IO_STATE(R_USB_COMMAND, port_sel, port2); /* We must once again wait at least 10ms for the device to recover */ port2_retry = 0; while (!((*((volatile __u16 *)&hc->rh.prev_wPortStatus_2)) & IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, yes))) { printk(""); if (port2_retry++ >= 10000) {goto port2_redo;} } /* This only seems to work if we use printk, not even schedule() works !!! WHY ?? */ udelay(15000); } /* Try to bring the HC into running state */ *R_USB_COMMAND = IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run); nop(); while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy)); dbg_rh("...Done"); OK(0); case (RH_PORT_POWER): OK (0); /* port power ** */ case (RH_PORT_ENABLE): /* There is no rh port enable command in the Etrax USB interface!!!! */ OK (0); } break; case RH_SET_ADDRESS: hc->rh.devnum = wValue; dbg_rh("RH address set to: %d", hc->rh.devnum); OK (0); case RH_GET_DESCRIPTOR: switch ((wValue & 0xff00) >> 8) { case (0x01): /* device descriptor */ len = min_t(unsigned int, leni, min_t(unsigned int, sizeof (root_hub_dev_des), wLength)); memcpy (data, root_hub_dev_des, len); OK (len); case (0x02): /* configuration descriptor */ len = min_t(unsigned int, leni, min_t(unsigned int, sizeof (root_hub_config_des), wLength)); memcpy (data, root_hub_config_des, len); OK (len); case (0x03): /* string descriptors */ len = usb_root_hub_string (wValue & 0xff, 0xff, "ETRAX 100LX", data, wLength); if (len > 0) { OK(min(leni, len)); } else stat = -EPIPE; } break; case RH_GET_DESCRIPTOR | RH_CLASS: root_hub_hub_des[2] = hc->rh.numports; len = min_t(unsigned int, leni, min_t(unsigned int, sizeof (root_hub_hub_des), wLength)); memcpy (data, root_hub_hub_des, len); OK (len); case RH_GET_CONFIGURATION: *(__u8 *) data = 0x01; OK (1); case RH_SET_CONFIGURATION: OK (0); default: stat = -EPIPE; } urb->actual_length = len; urb->status = stat; urb->dev = NULL; if (urb->complete) { urb->complete (urb); } DBFEXIT; return 0; } static int __init etrax_usb_hc_init(void) { static etrax_hc_t *hc; struct usb_bus *bus; struct usb_device *usb_rh; DBFENTER; info("ETRAX 100LX USB-HCD %s (c) 2001 Axis Communications AB\n", usb_hcd_version); hc = kmalloc(sizeof(etrax_hc_t), GFP_KERNEL); /* We use kmem_cache_* to make sure that all DMA desc. are dword aligned */ usb_desc_cache = kmem_cache_create("usb_desc_cache", sizeof(USB_EP_Desc_t), 0, 0, 0, 0); if (!usb_desc_cache) { panic("USB Desc Cache allocation failed !!!\n"); } etrax_usb_bus = bus = usb_alloc_bus(&etrax_usb_device_operations); hc->bus = bus; bus->hcpriv = hc; /* Initalize RH to the default address. And make sure that we have no status change indication */ hc->rh.numports = 2; /* The RH has two ports */ hc->rh.devnum = 0; hc->rh.wPortChange_1 = 0; hc->rh.wPortChange_2 = 0; /* Also initate the previous values to zero */ hc->rh.prev_wPortStatus_1 = 0; hc->rh.prev_wPortStatus_2 = 0; /* Initialize the intr-traffic flags */ hc->intr.sleeping = 0; hc->intr.wq = NULL; /* Initially all ep's are free except ep 0 */ ep_usage_bitmask = 0; set_bit(0, (void *)&ep_usage_bitmask); ep_really_active = 0; ep_out_traffic = 0; memset(URB_List, 0, sizeof(URB_List)); /* This code should really be moved */ if (request_dma(USB_TX_DMA_NBR, "ETRAX 100LX built-in USB (Tx)")) { err("Could not allocate DMA ch 8 for USB"); etrax_usb_hc_cleanup(); DBFEXIT; return -1; } if (request_dma(USB_RX_DMA_NBR, "ETRAX 100LX built-in USB (Rx)")) { err("Could not allocate DMA ch 9 for USB"); etrax_usb_hc_cleanup(); DBFEXIT; return -1; } #if 0 /* Moved to head.S */ *R_GEN_CONFIG = genconfig_shadow = (genconfig_shadow & ~(IO_MASK(R_GEN_CONFIG, usb1) | IO_MASK(R_GEN_CONFIG, usb2) | IO_MASK(R_GEN_CONFIG, dma8) | IO_MASK(R_GEN_CONFIG, dma9))) | IO_STATE(R_GEN_CONFIG, dma8, usb) | IO_STATE(R_GEN_CONFIG, dma9, usb) #ifdef CONFIG_ETRAX_USB_HOST_PORT1 | IO_STATE(R_GEN_CONFIG, usb1, select) #endif #ifdef CONFIG_ETRAX_USB_HOST_PORT2 | IO_STATE(R_GEN_CONFIG, usb2, select) #endif ; #endif usb_register_bus(hc->bus); /* We may have to set more bits, but these are the obvious ones */ *R_IRQ_MASK2_SET = IO_STATE(R_IRQ_MASK2_SET, dma8_sub0_descr, set) | IO_STATE(R_IRQ_MASK2_SET, dma8_sub1_descr, set) | IO_STATE(R_IRQ_MASK2_SET, dma8_sub2_descr, set) | IO_STATE(R_IRQ_MASK2_SET, dma8_sub3_descr, set); *R_IRQ_MASK2_SET = IO_STATE(R_IRQ_MASK2_SET, dma9_eop, set) | IO_STATE(R_IRQ_MASK2_SET, dma9_descr, set); *R_USB_IRQ_MASK_SET = IO_STATE(R_USB_IRQ_MASK_SET, ctl_status, set) | IO_STATE(R_USB_IRQ_MASK_SET, ctl_eot, set) | IO_STATE(R_USB_IRQ_MASK_SET, bulk_eot, set) | #ifdef ETRAX_USB_INTR_IRQ IO_STATE(R_USB_IRQ_MASK_SET, intr_eot, set) | #endif IO_STATE(R_USB_IRQ_MASK_SET, epid_attn, set) | IO_STATE(R_USB_IRQ_MASK_SET, port_status, set); if (request_irq(ETRAX_USB_HC_IRQ, etrax_usb_hc_intr_top_half, 0, "ETRAX 100LX built-in USB (HC)", hc)) { err("Could not allocate IRQ %d for USB", ETRAX_USB_HC_IRQ); etrax_usb_hc_cleanup(); DBFEXIT; return -1; } if (request_irq(ETRAX_USB_RX_IRQ, etrax_usb_rx_interrupt, 0, "ETRAX 100LX built-in USB (Rx)", hc)) { err("Could not allocate IRQ %d for USB", ETRAX_USB_RX_IRQ); etrax_usb_hc_cleanup(); DBFEXIT; return -1; } if (request_irq(ETRAX_USB_TX_IRQ, etrax_usb_tx_interrupt, 0, "ETRAX 100LX built-in USB (Tx)", hc)) { err("Could not allocate IRQ %d for USB", ETRAX_USB_TX_IRQ); etrax_usb_hc_cleanup(); DBFEXIT; return -1; } /* Reset the USB interface (configures as HC) */ *R_USB_COMMAND = IO_STATE(R_USB_COMMAND, ctrl_cmd, reset) | IO_STATE(R_USB_COMMAND, port_cmd, reset); nop(); while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy)); #if 1 /* Initate PSTART to all unallocatable bit times */ *R_USB_FM_PSTART = IO_FIELD(R_USB_FM_PSTART, value, 10000); #endif #ifdef CONFIG_ETRAX_USB_HOST_PORT1 *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, no); #endif #ifdef CONFIG_ETRAX_USB_HOST_PORT2 *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, no); #endif *R_USB_COMMAND = IO_STATE(R_USB_COMMAND, ctrl_cmd, host_config) | IO_STATE(R_USB_COMMAND, port_cmd, reset); nop(); while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy)); *R_USB_COMMAND = IO_STATE(R_USB_COMMAND, port_sel, port1) | IO_STATE(R_USB_COMMAND, port_cmd, reset); nop(); while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy)); /* Here we must wait at least 10ms so the device has time to recover */ udelay(15000); init_rx_buffers(); init_tx_bulk_ep(); init_tx_ctrl_ep(); init_tx_intr_ep(); /* This works. It seems like the host_run command only has effect when a device is connected, i.e. it has to be done when a interrup */ *R_USB_COMMAND = IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run); nop(); while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy)); usb_rh = usb_alloc_dev(NULL, hc->bus); hc->bus->root_hub = usb_rh; usb_connect(usb_rh); usb_new_device(usb_rh); DBFEXIT; return 0; } static void etrax_usb_hc_cleanup(void) { DBFENTER; free_irq(ETRAX_USB_HC_IRQ, NULL); free_irq(ETRAX_USB_RX_IRQ, NULL); free_irq(ETRAX_USB_TX_IRQ, NULL); free_dma(USB_TX_DMA_NBR); free_dma(USB_RX_DMA_NBR); usb_deregister_bus(etrax_usb_bus); DBFEXIT; } module_init(etrax_usb_hc_init); module_exit(etrax_usb_hc_cleanup);