/* ----------------------------------------------------------------------------- * Copyright (c) 2011 Ozmo Inc * Released under the GNU General Public License Version 2 (GPLv2). * * This file provides the implementation of a USB host controller device that * does not have any associated hardware. Instead the virtual device is * connected to the WiFi network and emulates the operation of a USB hcd by * receiving and sending network frames. * Note: * We take great pains to reduce the amount of code where interrupts need to be * disabled and in this respect we are different from standard HCD's. In * particular we don't want in_irq() code bleeding over to the protocol side of * the driver. * The troublesome functions are the urb enqueue and dequeue functions both of * which can be called in_irq(). So for these functions we put the urbs into a * queue and request a tasklet to process them. This means that a spinlock with * interrupts disabled must be held for insertion and removal but most code is * is in tasklet or soft irq context. The lock that protects this list is called * the tasklet lock and serves the purpose of the 'HCD lock' which must be held * when calling the following functions. * usb_hcd_link_urb_to_ep() * usb_hcd_unlink_urb_from_ep() * usb_hcd_flush_endpoint() * usb_hcd_check_unlink_urb() * ----------------------------------------------------------------------------- */ #include <linux/platform_device.h> #include <linux/usb.h> #include <linux/slab.h> #include <linux/export.h> #include "linux/usb/hcd.h" #include <asm/unaligned.h> #include "ozdbg.h" #include "ozusbif.h" #include "ozurbparanoia.h" #include "ozhcd.h" /* * Number of units of buffering to capture for an isochronous IN endpoint before * allowing data to be indicated up. */ #define OZ_IN_BUFFERING_UNITS 100 /* Name of our platform device. */ #define OZ_PLAT_DEV_NAME "ozwpan" /*EP0 timeout before ep0 request is again added to TX queue. (13*8 = 98mSec) */ #define EP0_TIMEOUT_COUNTER 13 /* Debounce time HCD driver should wait before unregistering. */ #define OZ_HUB_DEBOUNCE_TIMEOUT 1500 /* * Used to link urbs together and also store some status information for each * urb. * A cache of these are kept in a pool to reduce number of calls to kmalloc. */ struct oz_urb_link { struct list_head link; struct urb *urb; struct oz_port *port; u8 req_id; u8 ep_num; unsigned submit_counter; }; static struct kmem_cache *oz_urb_link_cache; /* Holds state information about a USB endpoint. */ #define OZ_EP_BUFFER_SIZE_ISOC (1024 * 24) #define OZ_EP_BUFFER_SIZE_INT 512 struct oz_endpoint { struct list_head urb_list; /* List of oz_urb_link items. */ struct list_head link; /* For isoc ep, links in to isoc lists of oz_port. */ struct timespec timestamp; int credit; int credit_ceiling; u8 ep_num; u8 attrib; u8 *buffer; int buffer_size; int in_ix; int out_ix; int buffered_units; unsigned flags; int start_frame; }; /* Bits in the flags field. */ #define OZ_F_EP_BUFFERING 0x1 #define OZ_F_EP_HAVE_STREAM 0x2 /* Holds state information about a USB interface. */ struct oz_interface { unsigned ep_mask; u8 alt; }; /* Holds state information about an hcd port. */ #define OZ_NB_ENDPOINTS 16 struct oz_port { unsigned flags; unsigned status; void *hpd; struct oz_hcd *ozhcd; spinlock_t port_lock; u8 bus_addr; u8 next_req_id; u8 config_num; int num_iface; struct oz_interface *iface; struct oz_endpoint *out_ep[OZ_NB_ENDPOINTS]; struct oz_endpoint *in_ep[OZ_NB_ENDPOINTS]; struct list_head isoc_out_ep; struct list_head isoc_in_ep; }; #define OZ_PORT_F_PRESENT 0x1 #define OZ_PORT_F_CHANGED 0x2 #define OZ_PORT_F_DYING 0x4 /* Data structure in the private context area of struct usb_hcd. */ #define OZ_NB_PORTS 8 struct oz_hcd { spinlock_t hcd_lock; struct list_head urb_pending_list; struct list_head urb_cancel_list; struct list_head orphanage; int conn_port; /* Port that is currently connecting, -1 if none.*/ struct oz_port ports[OZ_NB_PORTS]; uint flags; struct usb_hcd *hcd; }; /* Bits in flags field. */ #define OZ_HDC_F_SUSPENDED 0x1 /* * Static function prototypes. */ static int oz_hcd_start(struct usb_hcd *hcd); static void oz_hcd_stop(struct usb_hcd *hcd); static void oz_hcd_shutdown(struct usb_hcd *hcd); static int oz_hcd_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags); static int oz_hcd_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status); static void oz_hcd_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep); static void oz_hcd_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep); static int oz_hcd_get_frame_number(struct usb_hcd *hcd); static int oz_hcd_hub_status_data(struct usb_hcd *hcd, char *buf); static int oz_hcd_hub_control(struct usb_hcd *hcd, u16 req_type, u16 wvalue, u16 windex, char *buf, u16 wlength); static int oz_hcd_bus_suspend(struct usb_hcd *hcd); static int oz_hcd_bus_resume(struct usb_hcd *hcd); static int oz_plat_probe(struct platform_device *dev); static int oz_plat_remove(struct platform_device *dev); static void oz_plat_shutdown(struct platform_device *dev); static int oz_plat_suspend(struct platform_device *dev, pm_message_t msg); static int oz_plat_resume(struct platform_device *dev); static void oz_urb_process_tasklet(unsigned long unused); static int oz_build_endpoints_for_config(struct usb_hcd *hcd, struct oz_port *port, struct usb_host_config *config, gfp_t mem_flags); static void oz_clean_endpoints_for_config(struct usb_hcd *hcd, struct oz_port *port); static int oz_build_endpoints_for_interface(struct usb_hcd *hcd, struct oz_port *port, struct usb_host_interface *intf, gfp_t mem_flags); static void oz_clean_endpoints_for_interface(struct usb_hcd *hcd, struct oz_port *port, int if_ix); static void oz_process_ep0_urb(struct oz_hcd *ozhcd, struct urb *urb, gfp_t mem_flags); static struct oz_urb_link *oz_remove_urb(struct oz_endpoint *ep, struct urb *urb); static void oz_hcd_clear_orphanage(struct oz_hcd *ozhcd, int status); /* * Static external variables. */ static struct platform_device *g_plat_dev; static struct oz_hcd *g_ozhcd; static DEFINE_SPINLOCK(g_hcdlock); /* Guards g_ozhcd. */ static const char g_hcd_name[] = "Ozmo WPAN"; static DEFINE_SPINLOCK(g_tasklet_lock); static struct tasklet_struct g_urb_process_tasklet; static struct tasklet_struct g_urb_cancel_tasklet; static atomic_t g_pending_urbs = ATOMIC_INIT(0); static atomic_t g_usb_frame_number = ATOMIC_INIT(0); static const struct hc_driver g_oz_hc_drv = { .description = g_hcd_name, .product_desc = "Ozmo Devices WPAN", .hcd_priv_size = sizeof(struct oz_hcd), .flags = HCD_USB11, .start = oz_hcd_start, .stop = oz_hcd_stop, .shutdown = oz_hcd_shutdown, .urb_enqueue = oz_hcd_urb_enqueue, .urb_dequeue = oz_hcd_urb_dequeue, .endpoint_disable = oz_hcd_endpoint_disable, .endpoint_reset = oz_hcd_endpoint_reset, .get_frame_number = oz_hcd_get_frame_number, .hub_status_data = oz_hcd_hub_status_data, .hub_control = oz_hcd_hub_control, .bus_suspend = oz_hcd_bus_suspend, .bus_resume = oz_hcd_bus_resume, }; static struct platform_driver g_oz_plat_drv = { .probe = oz_plat_probe, .remove = oz_plat_remove, .shutdown = oz_plat_shutdown, .suspend = oz_plat_suspend, .resume = oz_plat_resume, .driver = { .name = OZ_PLAT_DEV_NAME, .owner = THIS_MODULE, }, }; /* * Gets our private context area (which is of type struct oz_hcd) from the * usb_hcd structure. * Context: any */ static inline struct oz_hcd *oz_hcd_private(struct usb_hcd *hcd) { return (struct oz_hcd *)hcd->hcd_priv; } /* * Searches list of ports to find the index of the one with a specified USB * bus address. If none of the ports has the bus address then the connection * port is returned, if there is one or -1 otherwise. * Context: any */ static int oz_get_port_from_addr(struct oz_hcd *ozhcd, u8 bus_addr) { int i; for (i = 0; i < OZ_NB_PORTS; i++) { if (ozhcd->ports[i].bus_addr == bus_addr) return i; } return ozhcd->conn_port; } /* * Context: any */ static struct oz_urb_link *oz_alloc_urb_link(void) { return kmem_cache_alloc(oz_urb_link_cache, GFP_ATOMIC); } /* * Context: any */ static void oz_free_urb_link(struct oz_urb_link *urbl) { if (!urbl) return; kmem_cache_free(oz_urb_link_cache, urbl); } /* * Allocates endpoint structure and optionally a buffer. If a buffer is * allocated it immediately follows the endpoint structure. * Context: softirq */ static struct oz_endpoint *oz_ep_alloc(int buffer_size, gfp_t mem_flags) { struct oz_endpoint *ep = kzalloc(sizeof(struct oz_endpoint)+buffer_size, mem_flags); if (ep) { INIT_LIST_HEAD(&ep->urb_list); INIT_LIST_HEAD(&ep->link); ep->credit = -1; if (buffer_size) { ep->buffer_size = buffer_size; ep->buffer = (u8 *)(ep+1); } } return ep; } /* * Pre-condition: Must be called with g_tasklet_lock held and interrupts * disabled. * Context: softirq or process */ static struct oz_urb_link *oz_uncancel_urb(struct oz_hcd *ozhcd, struct urb *urb) { struct oz_urb_link *urbl; list_for_each_entry(urbl, &ozhcd->urb_cancel_list, link) { if (urb == urbl->urb) { list_del_init(&urbl->link); return urbl; } } return NULL; } /* * This is called when we have finished processing an urb. It unlinks it from * the ep and returns it to the core. * Context: softirq or process */ static void oz_complete_urb(struct usb_hcd *hcd, struct urb *urb, int status) { struct oz_hcd *ozhcd = oz_hcd_private(hcd); unsigned long irq_state; struct oz_urb_link *cancel_urbl; spin_lock_irqsave(&g_tasklet_lock, irq_state); usb_hcd_unlink_urb_from_ep(hcd, urb); /* Clear hcpriv which will prevent it being put in the cancel list * in the event that an attempt is made to cancel it. */ urb->hcpriv = NULL; /* Walk the cancel list in case the urb is already sitting there. * Since we process the cancel list in a tasklet rather than in * the dequeue function this could happen. */ cancel_urbl = oz_uncancel_urb(ozhcd, urb); /* Note: we release lock but do not enable local irqs. * It appears that usb_hcd_giveback_urb() expects irqs to be disabled, * or at least other host controllers disable interrupts at this point * so we do the same. We must, however, release the lock otherwise a * deadlock will occur if an urb is submitted to our driver in the urb * completion function. Because we disable interrupts it is possible * that the urb_enqueue function can be called with them disabled. */ spin_unlock(&g_tasklet_lock); if (oz_forget_urb(urb)) { oz_dbg(ON, "ERROR Unknown URB %p\n", urb); } else { atomic_dec(&g_pending_urbs); usb_hcd_giveback_urb(hcd, urb, status); } spin_lock(&g_tasklet_lock); spin_unlock_irqrestore(&g_tasklet_lock, irq_state); if (cancel_urbl) oz_free_urb_link(cancel_urbl); } /* * Deallocates an endpoint including deallocating any associated stream and * returning any queued urbs to the core. * Context: softirq */ static void oz_ep_free(struct oz_port *port, struct oz_endpoint *ep) { if (port) { LIST_HEAD(list); struct oz_hcd *ozhcd = port->ozhcd; if (ep->flags & OZ_F_EP_HAVE_STREAM) oz_usb_stream_delete(port->hpd, ep->ep_num); /* Transfer URBs to the orphanage while we hold the lock. */ spin_lock_bh(&ozhcd->hcd_lock); /* Note: this works even if ep->urb_list is empty.*/ list_replace_init(&ep->urb_list, &list); /* Put the URBs in the orphanage. */ list_splice_tail(&list, &ozhcd->orphanage); spin_unlock_bh(&ozhcd->hcd_lock); } oz_dbg(ON, "Freeing endpoint memory\n"); kfree(ep); } /* * Context: softirq */ static void oz_complete_buffered_urb(struct oz_port *port, struct oz_endpoint *ep, struct urb *urb) { int data_len, available_space, copy_len; data_len = ep->buffer[ep->out_ix]; if (data_len <= urb->transfer_buffer_length) available_space = data_len; else available_space = urb->transfer_buffer_length; if (++ep->out_ix == ep->buffer_size) ep->out_ix = 0; copy_len = ep->buffer_size - ep->out_ix; if (copy_len >= available_space) copy_len = available_space; memcpy(urb->transfer_buffer, &ep->buffer[ep->out_ix], copy_len); if (copy_len < available_space) { memcpy((urb->transfer_buffer + copy_len), ep->buffer, (available_space - copy_len)); ep->out_ix = available_space - copy_len; } else { ep->out_ix += copy_len; } urb->actual_length = available_space; if (ep->out_ix == ep->buffer_size) ep->out_ix = 0; ep->buffered_units--; oz_dbg(ON, "Trying to give back buffered frame of size=%d\n", available_space); oz_complete_urb(port->ozhcd->hcd, urb, 0); } /* * Context: softirq */ static int oz_enqueue_ep_urb(struct oz_port *port, u8 ep_addr, int in_dir, struct urb *urb, u8 req_id) { struct oz_urb_link *urbl; struct oz_endpoint *ep = NULL; int err = 0; if (ep_addr >= OZ_NB_ENDPOINTS) { oz_dbg(ON, "%s: Invalid endpoint number\n", __func__); return -EINVAL; } urbl = oz_alloc_urb_link(); if (!urbl) return -ENOMEM; urbl->submit_counter = 0; urbl->urb = urb; urbl->req_id = req_id; urbl->ep_num = ep_addr; /* Hold lock while we insert the URB into the list within the * endpoint structure. */ spin_lock_bh(&port->ozhcd->hcd_lock); /* If the urb has been unlinked while out of any list then * complete it now. */ if (urb->unlinked) { spin_unlock_bh(&port->ozhcd->hcd_lock); oz_dbg(ON, "urb %p unlinked so complete immediately\n", urb); oz_complete_urb(port->ozhcd->hcd, urb, 0); oz_free_urb_link(urbl); return 0; } if (in_dir) ep = port->in_ep[ep_addr]; else ep = port->out_ep[ep_addr]; if (!ep) { err = -ENOMEM; goto out; } /*For interrupt endpoint check for buffered data * & complete urb */ if (((ep->attrib & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) && ep->buffered_units > 0) { oz_free_urb_link(urbl); spin_unlock_bh(&port->ozhcd->hcd_lock); oz_complete_buffered_urb(port, ep, urb); return 0; } if (port->hpd) { list_add_tail(&urbl->link, &ep->urb_list); if (!in_dir && ep_addr && (ep->credit < 0)) { getrawmonotonic(&ep->timestamp); ep->credit = 0; } } else { err = -EPIPE; } out: spin_unlock_bh(&port->ozhcd->hcd_lock); if (err) oz_free_urb_link(urbl); return err; } /* * Removes an urb from the queue in the endpoint. * Returns 0 if it is found and -EIDRM otherwise. * Context: softirq */ static int oz_dequeue_ep_urb(struct oz_port *port, u8 ep_addr, int in_dir, struct urb *urb) { struct oz_urb_link *urbl = NULL; struct oz_endpoint *ep; spin_lock_bh(&port->ozhcd->hcd_lock); if (in_dir) ep = port->in_ep[ep_addr]; else ep = port->out_ep[ep_addr]; if (ep) { struct list_head *e; list_for_each(e, &ep->urb_list) { urbl = list_entry(e, struct oz_urb_link, link); if (urbl->urb == urb) { list_del_init(e); break; } urbl = NULL; } } spin_unlock_bh(&port->ozhcd->hcd_lock); if (urbl) oz_free_urb_link(urbl); return urbl ? 0 : -EIDRM; } /* * Finds an urb given its request id. * Context: softirq */ static struct urb *oz_find_urb_by_id(struct oz_port *port, int ep_ix, u8 req_id) { struct oz_hcd *ozhcd = port->ozhcd; struct urb *urb = NULL; struct oz_urb_link *urbl; struct oz_endpoint *ep; spin_lock_bh(&ozhcd->hcd_lock); ep = port->out_ep[ep_ix]; if (ep) { struct list_head *e; list_for_each(e, &ep->urb_list) { urbl = list_entry(e, struct oz_urb_link, link); if (urbl->req_id == req_id) { urb = urbl->urb; list_del_init(e); break; } } } spin_unlock_bh(&ozhcd->hcd_lock); /* If urb is non-zero then we we must have an urb link to delete. */ if (urb) oz_free_urb_link(urbl); return urb; } /* * Pre-condition: Port lock must be held. * Context: softirq */ static void oz_acquire_port(struct oz_port *port, void *hpd) { INIT_LIST_HEAD(&port->isoc_out_ep); INIT_LIST_HEAD(&port->isoc_in_ep); port->flags |= OZ_PORT_F_PRESENT | OZ_PORT_F_CHANGED; port->status |= USB_PORT_STAT_CONNECTION | (USB_PORT_STAT_C_CONNECTION << 16); oz_usb_get(hpd); port->hpd = hpd; } /* * Context: softirq */ static struct oz_hcd *oz_hcd_claim(void) { struct oz_hcd *ozhcd; spin_lock_bh(&g_hcdlock); ozhcd = g_ozhcd; if (ozhcd) usb_get_hcd(ozhcd->hcd); spin_unlock_bh(&g_hcdlock); return ozhcd; } /* * Context: softirq */ static inline void oz_hcd_put(struct oz_hcd *ozhcd) { if (ozhcd) usb_put_hcd(ozhcd->hcd); } /* * This is called by the protocol handler to notify that a PD has arrived. * We allocate a port to associate with the PD and create a structure for * endpoint 0. This port is made the connection port. * In the event that one of the other port is already a connection port then * we fail. * TODO We should be able to do better than fail and should be able remember * that this port needs configuring and make it the connection port once the * current connection port has been assigned an address. Collisions here are * probably very rare indeed. * Context: softirq */ struct oz_port *oz_hcd_pd_arrived(void *hpd) { int i; struct oz_port *hport; struct oz_hcd *ozhcd; struct oz_endpoint *ep; ozhcd = oz_hcd_claim(); if (!ozhcd) return NULL; /* Allocate an endpoint object in advance (before holding hcd lock) to * use for out endpoint 0. */ ep = oz_ep_alloc(0, GFP_ATOMIC); if (!ep) goto err_put; spin_lock_bh(&ozhcd->hcd_lock); if (ozhcd->conn_port >= 0) goto err_unlock; for (i = 0; i < OZ_NB_PORTS; i++) { struct oz_port *port = &ozhcd->ports[i]; spin_lock(&port->port_lock); if (!(port->flags & (OZ_PORT_F_PRESENT | OZ_PORT_F_CHANGED))) { oz_acquire_port(port, hpd); spin_unlock(&port->port_lock); break; } spin_unlock(&port->port_lock); } if (i == OZ_NB_PORTS) goto err_unlock; ozhcd->conn_port = i; hport = &ozhcd->ports[i]; hport->out_ep[0] = ep; spin_unlock_bh(&ozhcd->hcd_lock); if (ozhcd->flags & OZ_HDC_F_SUSPENDED) usb_hcd_resume_root_hub(ozhcd->hcd); usb_hcd_poll_rh_status(ozhcd->hcd); oz_hcd_put(ozhcd); return hport; err_unlock: spin_unlock_bh(&ozhcd->hcd_lock); oz_ep_free(NULL, ep); err_put: oz_hcd_put(ozhcd); return NULL; } /* * This is called by the protocol handler to notify that the PD has gone away. * We need to deallocate all resources and then request that the root hub is * polled. We release the reference we hold on the PD. * Context: softirq */ void oz_hcd_pd_departed(struct oz_port *port) { struct oz_hcd *ozhcd; void *hpd; struct oz_endpoint *ep = NULL; if (port == NULL) { oz_dbg(ON, "%s: port = 0\n", __func__); return; } ozhcd = port->ozhcd; if (ozhcd == NULL) return; /* Check if this is the connection port - if so clear it. */ spin_lock_bh(&ozhcd->hcd_lock); if ((ozhcd->conn_port >= 0) && (port == &ozhcd->ports[ozhcd->conn_port])) { oz_dbg(ON, "Clearing conn_port\n"); ozhcd->conn_port = -1; } spin_lock(&port->port_lock); port->flags |= OZ_PORT_F_DYING; spin_unlock(&port->port_lock); spin_unlock_bh(&ozhcd->hcd_lock); oz_clean_endpoints_for_config(ozhcd->hcd, port); spin_lock_bh(&port->port_lock); hpd = port->hpd; port->hpd = NULL; port->bus_addr = 0xff; port->config_num = 0; port->flags &= ~(OZ_PORT_F_PRESENT | OZ_PORT_F_DYING); port->flags |= OZ_PORT_F_CHANGED; port->status &= ~(USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE); port->status |= (USB_PORT_STAT_C_CONNECTION << 16); /* If there is an endpont 0 then clear the pointer while we hold * the spinlock be we deallocate it after releasing the lock. */ if (port->out_ep[0]) { ep = port->out_ep[0]; port->out_ep[0] = NULL; } spin_unlock_bh(&port->port_lock); if (ep) oz_ep_free(port, ep); usb_hcd_poll_rh_status(ozhcd->hcd); oz_usb_put(hpd); } /* * Context: softirq */ void oz_hcd_pd_reset(void *hpd, void *hport) { /* Cleanup the current configuration and report reset to the core. */ struct oz_port *port = (struct oz_port *)hport; struct oz_hcd *ozhcd = port->ozhcd; oz_dbg(ON, "PD Reset\n"); spin_lock_bh(&port->port_lock); port->flags |= OZ_PORT_F_CHANGED; port->status |= USB_PORT_STAT_RESET; port->status |= (USB_PORT_STAT_C_RESET << 16); spin_unlock_bh(&port->port_lock); oz_clean_endpoints_for_config(ozhcd->hcd, port); usb_hcd_poll_rh_status(ozhcd->hcd); } /* * Context: softirq */ void oz_hcd_get_desc_cnf(void *hport, u8 req_id, int status, const u8 *desc, int length, int offset, int total_size) { struct oz_port *port = (struct oz_port *)hport; struct urb *urb; int err = 0; oz_dbg(ON, "oz_hcd_get_desc_cnf length = %d offs = %d tot_size = %d\n", length, offset, total_size); urb = oz_find_urb_by_id(port, 0, req_id); if (!urb) return; if (status == 0) { int copy_len; int required_size = urb->transfer_buffer_length; if (required_size > total_size) required_size = total_size; copy_len = required_size-offset; if (length <= copy_len) copy_len = length; memcpy(urb->transfer_buffer+offset, desc, copy_len); offset += copy_len; if (offset < required_size) { struct usb_ctrlrequest *setup = (struct usb_ctrlrequest *)urb->setup_packet; unsigned wvalue = le16_to_cpu(setup->wValue); if (oz_enqueue_ep_urb(port, 0, 0, urb, req_id)) err = -ENOMEM; else if (oz_usb_get_desc_req(port->hpd, req_id, setup->bRequestType, (u8)(wvalue>>8), (u8)wvalue, setup->wIndex, offset, required_size-offset)) { oz_dequeue_ep_urb(port, 0, 0, urb); err = -ENOMEM; } if (err == 0) return; } } urb->actual_length = total_size; oz_complete_urb(port->ozhcd->hcd, urb, 0); } /* * Context: softirq */ static void oz_display_conf_type(u8 t) { switch (t) { case USB_REQ_GET_STATUS: oz_dbg(ON, "USB_REQ_GET_STATUS - cnf\n"); break; case USB_REQ_CLEAR_FEATURE: oz_dbg(ON, "USB_REQ_CLEAR_FEATURE - cnf\n"); break; case USB_REQ_SET_FEATURE: oz_dbg(ON, "USB_REQ_SET_FEATURE - cnf\n"); break; case USB_REQ_SET_ADDRESS: oz_dbg(ON, "USB_REQ_SET_ADDRESS - cnf\n"); break; case USB_REQ_GET_DESCRIPTOR: oz_dbg(ON, "USB_REQ_GET_DESCRIPTOR - cnf\n"); break; case USB_REQ_SET_DESCRIPTOR: oz_dbg(ON, "USB_REQ_SET_DESCRIPTOR - cnf\n"); break; case USB_REQ_GET_CONFIGURATION: oz_dbg(ON, "USB_REQ_GET_CONFIGURATION - cnf\n"); break; case USB_REQ_SET_CONFIGURATION: oz_dbg(ON, "USB_REQ_SET_CONFIGURATION - cnf\n"); break; case USB_REQ_GET_INTERFACE: oz_dbg(ON, "USB_REQ_GET_INTERFACE - cnf\n"); break; case USB_REQ_SET_INTERFACE: oz_dbg(ON, "USB_REQ_SET_INTERFACE - cnf\n"); break; case USB_REQ_SYNCH_FRAME: oz_dbg(ON, "USB_REQ_SYNCH_FRAME - cnf\n"); break; } } /* * Context: softirq */ static void oz_hcd_complete_set_config(struct oz_port *port, struct urb *urb, u8 rcode, u8 config_num) { int rc = 0; struct usb_hcd *hcd = port->ozhcd->hcd; if (rcode == 0) { port->config_num = config_num; oz_clean_endpoints_for_config(hcd, port); if (oz_build_endpoints_for_config(hcd, port, &urb->dev->config[port->config_num-1], GFP_ATOMIC)) { rc = -ENOMEM; } } else { rc = -ENOMEM; } oz_complete_urb(hcd, urb, rc); } /* * Context: softirq */ static void oz_hcd_complete_set_interface(struct oz_port *port, struct urb *urb, u8 rcode, u8 if_num, u8 alt) { struct usb_hcd *hcd = port->ozhcd->hcd; int rc = 0; if ((rcode == 0) && (port->config_num > 0)) { struct usb_host_config *config; struct usb_host_interface *intf; oz_dbg(ON, "Set interface %d alt %d\n", if_num, alt); oz_clean_endpoints_for_interface(hcd, port, if_num); config = &urb->dev->config[port->config_num-1]; intf = &config->intf_cache[if_num]->altsetting[alt]; if (oz_build_endpoints_for_interface(hcd, port, intf, GFP_ATOMIC)) rc = -ENOMEM; else port->iface[if_num].alt = alt; } else { rc = -ENOMEM; } oz_complete_urb(hcd, urb, rc); } /* * Context: softirq */ void oz_hcd_control_cnf(void *hport, u8 req_id, u8 rcode, const u8 *data, int data_len) { struct oz_port *port = (struct oz_port *)hport; struct urb *urb; struct usb_ctrlrequest *setup; struct usb_hcd *hcd = port->ozhcd->hcd; unsigned windex; unsigned wvalue; oz_dbg(ON, "oz_hcd_control_cnf rcode=%u len=%d\n", rcode, data_len); urb = oz_find_urb_by_id(port, 0, req_id); if (!urb) { oz_dbg(ON, "URB not found\n"); return; } setup = (struct usb_ctrlrequest *)urb->setup_packet; windex = le16_to_cpu(setup->wIndex); wvalue = le16_to_cpu(setup->wValue); if ((setup->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) { /* Standard requests */ oz_display_conf_type(setup->bRequest); switch (setup->bRequest) { case USB_REQ_SET_CONFIGURATION: oz_hcd_complete_set_config(port, urb, rcode, (u8)wvalue); break; case USB_REQ_SET_INTERFACE: oz_hcd_complete_set_interface(port, urb, rcode, (u8)windex, (u8)wvalue); break; default: oz_complete_urb(hcd, urb, 0); } } else { int copy_len; oz_dbg(ON, "VENDOR-CLASS - cnf\n"); if (data_len) { if (data_len <= urb->transfer_buffer_length) copy_len = data_len; else copy_len = urb->transfer_buffer_length; memcpy(urb->transfer_buffer, data, copy_len); urb->actual_length = copy_len; } oz_complete_urb(hcd, urb, 0); } } /* * Context: softirq-serialized */ static int oz_hcd_buffer_data(struct oz_endpoint *ep, const u8 *data, int data_len) { int space; int copy_len; if (!ep->buffer) return -1; space = ep->out_ix-ep->in_ix-1; if (space < 0) space += ep->buffer_size; if (space < (data_len+1)) { oz_dbg(ON, "Buffer full\n"); return -1; } ep->buffer[ep->in_ix] = (u8)data_len; if (++ep->in_ix == ep->buffer_size) ep->in_ix = 0; copy_len = ep->buffer_size - ep->in_ix; if (copy_len > data_len) copy_len = data_len; memcpy(&ep->buffer[ep->in_ix], data, copy_len); if (copy_len < data_len) { memcpy(ep->buffer, data+copy_len, data_len-copy_len); ep->in_ix = data_len-copy_len; } else { ep->in_ix += copy_len; } if (ep->in_ix == ep->buffer_size) ep->in_ix = 0; ep->buffered_units++; return 0; } /* * Context: softirq-serialized */ void oz_hcd_data_ind(void *hport, u8 endpoint, const u8 *data, int data_len) { struct oz_port *port = (struct oz_port *)hport; struct oz_endpoint *ep; struct oz_hcd *ozhcd = port->ozhcd; spin_lock_bh(&ozhcd->hcd_lock); ep = port->in_ep[endpoint & USB_ENDPOINT_NUMBER_MASK]; if (ep == NULL) goto done; switch (ep->attrib & USB_ENDPOINT_XFERTYPE_MASK) { case USB_ENDPOINT_XFER_INT: case USB_ENDPOINT_XFER_BULK: if (!list_empty(&ep->urb_list)) { struct oz_urb_link *urbl = list_first_entry(&ep->urb_list, struct oz_urb_link, link); struct urb *urb; int copy_len; list_del_init(&urbl->link); spin_unlock_bh(&ozhcd->hcd_lock); urb = urbl->urb; oz_free_urb_link(urbl); if (data_len <= urb->transfer_buffer_length) copy_len = data_len; else copy_len = urb->transfer_buffer_length; memcpy(urb->transfer_buffer, data, copy_len); urb->actual_length = copy_len; oz_complete_urb(port->ozhcd->hcd, urb, 0); return; } oz_dbg(ON, "buffering frame as URB is not available\n"); oz_hcd_buffer_data(ep, data, data_len); break; case USB_ENDPOINT_XFER_ISOC: oz_hcd_buffer_data(ep, data, data_len); break; } done: spin_unlock_bh(&ozhcd->hcd_lock); } /* * Context: unknown */ static inline int oz_usb_get_frame_number(void) { return atomic_inc_return(&g_usb_frame_number); } /* * Context: softirq */ int oz_hcd_heartbeat(void *hport) { int rc = 0; struct oz_port *port = (struct oz_port *)hport; struct oz_hcd *ozhcd = port->ozhcd; struct oz_urb_link *urbl, *n; LIST_HEAD(xfr_list); struct urb *urb; struct oz_endpoint *ep; struct timespec ts, delta; getrawmonotonic(&ts); /* Check the OUT isoc endpoints to see if any URB data can be sent. */ spin_lock_bh(&ozhcd->hcd_lock); list_for_each_entry(ep, &port->isoc_out_ep, link) { if (ep->credit < 0) continue; delta = timespec_sub(ts, ep->timestamp); ep->credit += div_u64(timespec_to_ns(&delta), NSEC_PER_MSEC); if (ep->credit > ep->credit_ceiling) ep->credit = ep->credit_ceiling; ep->timestamp = ts; while (ep->credit && !list_empty(&ep->urb_list)) { urbl = list_first_entry(&ep->urb_list, struct oz_urb_link, link); urb = urbl->urb; if ((ep->credit + 1) < urb->number_of_packets) break; ep->credit -= urb->number_of_packets; if (ep->credit < 0) ep->credit = 0; list_move_tail(&urbl->link, &xfr_list); } } spin_unlock_bh(&ozhcd->hcd_lock); /* Send to PD and complete URBs. */ list_for_each_entry_safe(urbl, n, &xfr_list, link) { urb = urbl->urb; list_del_init(&urbl->link); urb->error_count = 0; urb->start_frame = oz_usb_get_frame_number(); oz_usb_send_isoc(port->hpd, urbl->ep_num, urb); oz_free_urb_link(urbl); oz_complete_urb(port->ozhcd->hcd, urb, 0); } /* Check the IN isoc endpoints to see if any URBs can be completed. */ spin_lock_bh(&ozhcd->hcd_lock); list_for_each_entry(ep, &port->isoc_in_ep, link) { if (ep->flags & OZ_F_EP_BUFFERING) { if (ep->buffered_units >= OZ_IN_BUFFERING_UNITS) { ep->flags &= ~OZ_F_EP_BUFFERING; ep->credit = 0; ep->timestamp = ts; ep->start_frame = 0; } continue; } delta = timespec_sub(ts, ep->timestamp); ep->credit += div_u64(timespec_to_ns(&delta), NSEC_PER_MSEC); ep->timestamp = ts; list_for_each_entry_safe(urbl, n, &ep->urb_list, link) { struct urb *urb = urbl->urb; int len = 0; int copy_len; int i; if (ep->credit < urb->number_of_packets) break; if (ep->buffered_units < urb->number_of_packets) break; urb->actual_length = 0; for (i = 0; i < urb->number_of_packets; i++) { len = ep->buffer[ep->out_ix]; if (++ep->out_ix == ep->buffer_size) ep->out_ix = 0; copy_len = ep->buffer_size - ep->out_ix; if (copy_len > len) copy_len = len; memcpy(urb->transfer_buffer, &ep->buffer[ep->out_ix], copy_len); if (copy_len < len) { memcpy(urb->transfer_buffer+copy_len, ep->buffer, len-copy_len); ep->out_ix = len-copy_len; } else ep->out_ix += copy_len; if (ep->out_ix == ep->buffer_size) ep->out_ix = 0; urb->iso_frame_desc[i].offset = urb->actual_length; urb->actual_length += len; urb->iso_frame_desc[i].actual_length = len; urb->iso_frame_desc[i].status = 0; } ep->buffered_units -= urb->number_of_packets; urb->error_count = 0; urb->start_frame = ep->start_frame; ep->start_frame += urb->number_of_packets; list_move_tail(&urbl->link, &xfr_list); ep->credit -= urb->number_of_packets; } } if (!list_empty(&port->isoc_out_ep) || !list_empty(&port->isoc_in_ep)) rc = 1; spin_unlock_bh(&ozhcd->hcd_lock); /* Complete the filled URBs. */ list_for_each_entry_safe(urbl, n, &xfr_list, link) { urb = urbl->urb; list_del_init(&urbl->link); oz_free_urb_link(urbl); oz_complete_urb(port->ozhcd->hcd, urb, 0); } /* Check if there are any ep0 requests that have timed out. * If so resent to PD. */ ep = port->out_ep[0]; if (ep) { spin_lock_bh(&ozhcd->hcd_lock); list_for_each_entry_safe(urbl, n, &ep->urb_list, link) { if (urbl->submit_counter > EP0_TIMEOUT_COUNTER) { oz_dbg(ON, "Request 0x%p timeout\n", urbl->urb); list_move_tail(&urbl->link, &xfr_list); urbl->submit_counter = 0; } else { urbl->submit_counter++; } } if (!list_empty(&ep->urb_list)) rc = 1; spin_unlock_bh(&ozhcd->hcd_lock); list_for_each_entry_safe(urbl, n, &xfr_list, link) { oz_dbg(ON, "Resending request to PD\n"); oz_process_ep0_urb(ozhcd, urbl->urb, GFP_ATOMIC); oz_free_urb_link(urbl); } } return rc; } /* * Context: softirq */ static int oz_build_endpoints_for_interface(struct usb_hcd *hcd, struct oz_port *port, struct usb_host_interface *intf, gfp_t mem_flags) { struct oz_hcd *ozhcd = port->ozhcd; int i; int if_ix = intf->desc.bInterfaceNumber; int request_heartbeat = 0; oz_dbg(ON, "interface[%d] = %p\n", if_ix, intf); if (if_ix >= port->num_iface || port->iface == NULL) return -ENOMEM; for (i = 0; i < intf->desc.bNumEndpoints; i++) { struct usb_host_endpoint *hep = &intf->endpoint[i]; u8 ep_addr = hep->desc.bEndpointAddress; u8 ep_num = ep_addr & USB_ENDPOINT_NUMBER_MASK; struct oz_endpoint *ep; int buffer_size = 0; oz_dbg(ON, "%d bEndpointAddress = %x\n", i, ep_addr); if (ep_addr & USB_ENDPOINT_DIR_MASK) { switch (hep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { case USB_ENDPOINT_XFER_ISOC: buffer_size = OZ_EP_BUFFER_SIZE_ISOC; break; case USB_ENDPOINT_XFER_INT: buffer_size = OZ_EP_BUFFER_SIZE_INT; break; } } ep = oz_ep_alloc(buffer_size, mem_flags); if (!ep) { oz_clean_endpoints_for_interface(hcd, port, if_ix); return -ENOMEM; } ep->attrib = hep->desc.bmAttributes; ep->ep_num = ep_num; if ((ep->attrib & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC) { oz_dbg(ON, "wMaxPacketSize = %d\n", usb_endpoint_maxp(&hep->desc)); ep->credit_ceiling = 200; if (ep_addr & USB_ENDPOINT_DIR_MASK) { ep->flags |= OZ_F_EP_BUFFERING; } else { ep->flags |= OZ_F_EP_HAVE_STREAM; if (oz_usb_stream_create(port->hpd, ep_num)) ep->flags &= ~OZ_F_EP_HAVE_STREAM; } } spin_lock_bh(&ozhcd->hcd_lock); if (ep_addr & USB_ENDPOINT_DIR_MASK) { port->in_ep[ep_num] = ep; port->iface[if_ix].ep_mask |= (1<<(ep_num+OZ_NB_ENDPOINTS)); if ((ep->attrib & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC) { list_add_tail(&ep->link, &port->isoc_in_ep); request_heartbeat = 1; } } else { port->out_ep[ep_num] = ep; port->iface[if_ix].ep_mask |= (1<<ep_num); if ((ep->attrib & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC) { list_add_tail(&ep->link, &port->isoc_out_ep); request_heartbeat = 1; } } spin_unlock_bh(&ozhcd->hcd_lock); if (request_heartbeat && port->hpd) oz_usb_request_heartbeat(port->hpd); } return 0; } /* * Context: softirq */ static void oz_clean_endpoints_for_interface(struct usb_hcd *hcd, struct oz_port *port, int if_ix) { struct oz_hcd *ozhcd = port->ozhcd; unsigned mask; int i; LIST_HEAD(ep_list); struct oz_endpoint *ep, *n; oz_dbg(ON, "Deleting endpoints for interface %d\n", if_ix); if (if_ix >= port->num_iface) return; spin_lock_bh(&ozhcd->hcd_lock); mask = port->iface[if_ix].ep_mask; port->iface[if_ix].ep_mask = 0; for (i = 0; i < OZ_NB_ENDPOINTS; i++) { struct list_head *e; /* Gather OUT endpoints. */ if ((mask & (1<<i)) && port->out_ep[i]) { e = &port->out_ep[i]->link; port->out_ep[i] = NULL; /* Remove from isoc list if present. */ list_move_tail(e, &ep_list); } /* Gather IN endpoints. */ if ((mask & (1<<(i+OZ_NB_ENDPOINTS))) && port->in_ep[i]) { e = &port->in_ep[i]->link; port->in_ep[i] = NULL; list_move_tail(e, &ep_list); } } spin_unlock_bh(&ozhcd->hcd_lock); list_for_each_entry_safe(ep, n, &ep_list, link) { list_del_init(&ep->link); oz_ep_free(port, ep); } } /* * Context: softirq */ static int oz_build_endpoints_for_config(struct usb_hcd *hcd, struct oz_port *port, struct usb_host_config *config, gfp_t mem_flags) { struct oz_hcd *ozhcd = port->ozhcd; int i; int num_iface = config->desc.bNumInterfaces; if (num_iface) { struct oz_interface *iface; iface = kmalloc_array(num_iface, sizeof(struct oz_interface), mem_flags | __GFP_ZERO); if (!iface) return -ENOMEM; spin_lock_bh(&ozhcd->hcd_lock); port->iface = iface; port->num_iface = num_iface; spin_unlock_bh(&ozhcd->hcd_lock); } for (i = 0; i < num_iface; i++) { struct usb_host_interface *intf = &config->intf_cache[i]->altsetting[0]; if (oz_build_endpoints_for_interface(hcd, port, intf, mem_flags)) goto fail; } return 0; fail: oz_clean_endpoints_for_config(hcd, port); return -1; } /* * Context: softirq */ static void oz_clean_endpoints_for_config(struct usb_hcd *hcd, struct oz_port *port) { struct oz_hcd *ozhcd = port->ozhcd; int i; oz_dbg(ON, "Deleting endpoints for configuration\n"); for (i = 0; i < port->num_iface; i++) oz_clean_endpoints_for_interface(hcd, port, i); spin_lock_bh(&ozhcd->hcd_lock); if (port->iface) { oz_dbg(ON, "Freeing interfaces object\n"); kfree(port->iface); port->iface = NULL; } port->num_iface = 0; spin_unlock_bh(&ozhcd->hcd_lock); } /* * Context: tasklet */ static void *oz_claim_hpd(struct oz_port *port) { void *hpd; struct oz_hcd *ozhcd = port->ozhcd; spin_lock_bh(&ozhcd->hcd_lock); hpd = port->hpd; if (hpd) oz_usb_get(hpd); spin_unlock_bh(&ozhcd->hcd_lock); return hpd; } /* * Context: tasklet */ static void oz_process_ep0_urb(struct oz_hcd *ozhcd, struct urb *urb, gfp_t mem_flags) { struct usb_ctrlrequest *setup; unsigned windex; unsigned wvalue; unsigned wlength; void *hpd; u8 req_id; int rc = 0; unsigned complete = 0; int port_ix = -1; struct oz_port *port = NULL; oz_dbg(URB, "[%s]:(%p)\n", __func__, urb); port_ix = oz_get_port_from_addr(ozhcd, urb->dev->devnum); if (port_ix < 0) { rc = -EPIPE; goto out; } port = &ozhcd->ports[port_ix]; if (((port->flags & OZ_PORT_F_PRESENT) == 0) || (port->flags & OZ_PORT_F_DYING)) { oz_dbg(ON, "Refusing URB port_ix = %d devnum = %d\n", port_ix, urb->dev->devnum); rc = -EPIPE; goto out; } /* Store port in private context data. */ urb->hcpriv = port; setup = (struct usb_ctrlrequest *)urb->setup_packet; windex = le16_to_cpu(setup->wIndex); wvalue = le16_to_cpu(setup->wValue); wlength = le16_to_cpu(setup->wLength); oz_dbg(CTRL_DETAIL, "bRequestType = %x\n", setup->bRequestType); oz_dbg(CTRL_DETAIL, "bRequest = %x\n", setup->bRequest); oz_dbg(CTRL_DETAIL, "wValue = %x\n", wvalue); oz_dbg(CTRL_DETAIL, "wIndex = %x\n", windex); oz_dbg(CTRL_DETAIL, "wLength = %x\n", wlength); req_id = port->next_req_id++; hpd = oz_claim_hpd(port); if (hpd == NULL) { oz_dbg(ON, "Cannot claim port\n"); rc = -EPIPE; goto out; } if ((setup->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) { /* Standard requests */ switch (setup->bRequest) { case USB_REQ_GET_DESCRIPTOR: oz_dbg(ON, "USB_REQ_GET_DESCRIPTOR - req\n"); break; case USB_REQ_SET_ADDRESS: oz_dbg(ON, "USB_REQ_SET_ADDRESS - req\n"); oz_dbg(ON, "Port %d address is 0x%x\n", ozhcd->conn_port, (u8)le16_to_cpu(setup->wValue)); spin_lock_bh(&ozhcd->hcd_lock); if (ozhcd->conn_port >= 0) { ozhcd->ports[ozhcd->conn_port].bus_addr = (u8)le16_to_cpu(setup->wValue); oz_dbg(ON, "Clearing conn_port\n"); ozhcd->conn_port = -1; } spin_unlock_bh(&ozhcd->hcd_lock); complete = 1; break; case USB_REQ_SET_CONFIGURATION: oz_dbg(ON, "USB_REQ_SET_CONFIGURATION - req\n"); break; case USB_REQ_GET_CONFIGURATION: /* We short circuit this case and reply directly since * we have the selected configuration number cached. */ oz_dbg(ON, "USB_REQ_GET_CONFIGURATION - reply now\n"); if (urb->transfer_buffer_length >= 1) { urb->actual_length = 1; *((u8 *)urb->transfer_buffer) = port->config_num; complete = 1; } else { rc = -EPIPE; } break; case USB_REQ_GET_INTERFACE: /* We short circuit this case and reply directly since * we have the selected interface alternative cached. */ oz_dbg(ON, "USB_REQ_GET_INTERFACE - reply now\n"); if (urb->transfer_buffer_length >= 1) { urb->actual_length = 1; *((u8 *)urb->transfer_buffer) = port->iface[(u8)windex].alt; oz_dbg(ON, "interface = %d alt = %d\n", windex, port->iface[(u8)windex].alt); complete = 1; } else { rc = -EPIPE; } break; case USB_REQ_SET_INTERFACE: oz_dbg(ON, "USB_REQ_SET_INTERFACE - req\n"); break; } } if (!rc && !complete) { int data_len = 0; if ((setup->bRequestType & USB_DIR_IN) == 0) data_len = wlength; urb->actual_length = data_len; if (oz_usb_control_req(port->hpd, req_id, setup, urb->transfer_buffer, data_len)) { rc = -ENOMEM; } else { /* Note: we are queuing the request after we have * submitted it to be transmitted. If the request were * to complete before we queued it then it would not * be found in the queue. It seems impossible for * this to happen but if it did the request would * be resubmitted so the problem would hopefully * resolve itself. Putting the request into the * queue before it has been sent is worse since the * urb could be cancelled while we are using it * to build the request. */ if (oz_enqueue_ep_urb(port, 0, 0, urb, req_id)) rc = -ENOMEM; } } oz_usb_put(hpd); out: if (rc || complete) { oz_dbg(ON, "Completing request locally\n"); oz_complete_urb(ozhcd->hcd, urb, rc); } else { oz_usb_request_heartbeat(port->hpd); } } /* * Context: tasklet */ static int oz_urb_process(struct oz_hcd *ozhcd, struct urb *urb) { int rc = 0; struct oz_port *port = urb->hcpriv; u8 ep_addr; /* When we are paranoid we keep a list of urbs which we check against * before handing one back. This is just for debugging during * development and should be turned off in the released driver. */ oz_remember_urb(urb); /* Check buffer is valid. */ if (!urb->transfer_buffer && urb->transfer_buffer_length) return -EINVAL; /* Check if there is a device at the port - refuse if not. */ if ((port->flags & OZ_PORT_F_PRESENT) == 0) return -EPIPE; ep_addr = usb_pipeendpoint(urb->pipe); if (ep_addr) { /* If the request is not for EP0 then queue it. */ if (oz_enqueue_ep_urb(port, ep_addr, usb_pipein(urb->pipe), urb, 0)) rc = -EPIPE; } else { oz_process_ep0_urb(ozhcd, urb, GFP_ATOMIC); } return rc; } /* * Context: tasklet */ static void oz_urb_process_tasklet(unsigned long unused) { unsigned long irq_state; struct urb *urb; struct oz_hcd *ozhcd = oz_hcd_claim(); struct oz_urb_link *urbl, *n; int rc = 0; if (ozhcd == NULL) return; /* This is called from a tasklet so is in softirq context but the urb * list is filled from any context so we need to lock * appropriately while removing urbs. */ spin_lock_irqsave(&g_tasklet_lock, irq_state); list_for_each_entry_safe(urbl, n, &ozhcd->urb_pending_list, link) { list_del_init(&urbl->link); spin_unlock_irqrestore(&g_tasklet_lock, irq_state); urb = urbl->urb; oz_free_urb_link(urbl); rc = oz_urb_process(ozhcd, urb); if (rc) oz_complete_urb(ozhcd->hcd, urb, rc); spin_lock_irqsave(&g_tasklet_lock, irq_state); } spin_unlock_irqrestore(&g_tasklet_lock, irq_state); oz_hcd_put(ozhcd); } /* * This function searches for the urb in any of the lists it could be in. * If it is found it is removed from the list and completed. If the urb is * being processed then it won't be in a list so won't be found. However, the * call to usb_hcd_check_unlink_urb() will set the value of the unlinked field * to a non-zero value. When an attempt is made to put the urb back in a list * the unlinked field will be checked and the urb will then be completed. * Context: tasklet */ static void oz_urb_cancel(struct oz_port *port, u8 ep_num, struct urb *urb) { struct oz_urb_link *urbl = NULL; struct list_head *e; struct oz_hcd *ozhcd; unsigned long irq_state; u8 ix; if (port == NULL) { oz_dbg(ON, "%s: ERROR: (%p) port is null\n", __func__, urb); return; } ozhcd = port->ozhcd; if (ozhcd == NULL) { oz_dbg(ON, "%s; ERROR: (%p) ozhcd is null\n", __func__, urb); return; } /* Look in the tasklet queue. */ spin_lock_irqsave(&g_tasklet_lock, irq_state); list_for_each(e, &ozhcd->urb_cancel_list) { urbl = list_entry(e, struct oz_urb_link, link); if (urb == urbl->urb) { list_del_init(e); spin_unlock_irqrestore(&g_tasklet_lock, irq_state); goto out2; } } spin_unlock_irqrestore(&g_tasklet_lock, irq_state); urbl = NULL; /* Look in the orphanage. */ spin_lock_irqsave(&ozhcd->hcd_lock, irq_state); list_for_each(e, &ozhcd->orphanage) { urbl = list_entry(e, struct oz_urb_link, link); if (urbl->urb == urb) { list_del(e); oz_dbg(ON, "Found urb in orphanage\n"); goto out; } } ix = (ep_num & 0xf); urbl = NULL; if ((ep_num & USB_DIR_IN) && ix) urbl = oz_remove_urb(port->in_ep[ix], urb); else urbl = oz_remove_urb(port->out_ep[ix], urb); out: spin_unlock_irqrestore(&ozhcd->hcd_lock, irq_state); out2: if (urbl) { urb->actual_length = 0; oz_free_urb_link(urbl); oz_complete_urb(ozhcd->hcd, urb, -EPIPE); } } /* * Context: tasklet */ static void oz_urb_cancel_tasklet(unsigned long unused) { unsigned long irq_state; struct urb *urb; struct oz_urb_link *urbl, *n; struct oz_hcd *ozhcd = oz_hcd_claim(); if (ozhcd == NULL) return; spin_lock_irqsave(&g_tasklet_lock, irq_state); list_for_each_entry_safe(urbl, n, &ozhcd->urb_cancel_list, link) { list_del_init(&urbl->link); spin_unlock_irqrestore(&g_tasklet_lock, irq_state); urb = urbl->urb; if (urb->unlinked) oz_urb_cancel(urbl->port, urbl->ep_num, urb); oz_free_urb_link(urbl); spin_lock_irqsave(&g_tasklet_lock, irq_state); } spin_unlock_irqrestore(&g_tasklet_lock, irq_state); oz_hcd_put(ozhcd); } /* * Context: unknown */ static void oz_hcd_clear_orphanage(struct oz_hcd *ozhcd, int status) { if (ozhcd) { struct oz_urb_link *urbl, *n; list_for_each_entry_safe(urbl, n, &ozhcd->orphanage, link) { list_del(&urbl->link); oz_complete_urb(ozhcd->hcd, urbl->urb, status); oz_free_urb_link(urbl); } } } /* * Context: unknown */ static int oz_hcd_start(struct usb_hcd *hcd) { hcd->power_budget = 200; hcd->state = HC_STATE_RUNNING; hcd->uses_new_polling = 1; return 0; } /* * Context: unknown */ static void oz_hcd_stop(struct usb_hcd *hcd) { } /* * Context: unknown */ static void oz_hcd_shutdown(struct usb_hcd *hcd) { } /* * Called to queue an urb for the device. * This function should return a non-zero error code if it fails the urb but * should not call usb_hcd_giveback_urb(). * Context: any */ static int oz_hcd_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags) { struct oz_hcd *ozhcd = oz_hcd_private(hcd); int rc; int port_ix; struct oz_port *port; unsigned long irq_state; struct oz_urb_link *urbl; oz_dbg(URB, "%s: (%p)\n", __func__, urb); if (unlikely(ozhcd == NULL)) { oz_dbg(URB, "Refused urb(%p) not ozhcd\n", urb); return -EPIPE; } if (unlikely(hcd->state != HC_STATE_RUNNING)) { oz_dbg(URB, "Refused urb(%p) not running\n", urb); return -EPIPE; } port_ix = oz_get_port_from_addr(ozhcd, urb->dev->devnum); if (port_ix < 0) return -EPIPE; port = &ozhcd->ports[port_ix]; if (port == NULL) return -EPIPE; if (!(port->flags & OZ_PORT_F_PRESENT) || (port->flags & OZ_PORT_F_CHANGED)) { oz_dbg(ON, "Refusing URB port_ix = %d devnum = %d\n", port_ix, urb->dev->devnum); return -EPIPE; } urb->hcpriv = port; /* Put request in queue for processing by tasklet. */ urbl = oz_alloc_urb_link(); if (unlikely(urbl == NULL)) return -ENOMEM; urbl->urb = urb; spin_lock_irqsave(&g_tasklet_lock, irq_state); rc = usb_hcd_link_urb_to_ep(hcd, urb); if (unlikely(rc)) { spin_unlock_irqrestore(&g_tasklet_lock, irq_state); oz_free_urb_link(urbl); return rc; } list_add_tail(&urbl->link, &ozhcd->urb_pending_list); spin_unlock_irqrestore(&g_tasklet_lock, irq_state); tasklet_schedule(&g_urb_process_tasklet); atomic_inc(&g_pending_urbs); return 0; } /* * Context: tasklet */ static struct oz_urb_link *oz_remove_urb(struct oz_endpoint *ep, struct urb *urb) { struct oz_urb_link *urbl; if (unlikely(ep == NULL)) return NULL; list_for_each_entry(urbl, &ep->urb_list, link) { if (urbl->urb == urb) { list_del_init(&urbl->link); if (usb_pipeisoc(urb->pipe)) { ep->credit -= urb->number_of_packets; if (ep->credit < 0) ep->credit = 0; } return urbl; } } return NULL; } /* * Called to dequeue a previously submitted urb for the device. * Context: any */ static int oz_hcd_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) { struct oz_hcd *ozhcd = oz_hcd_private(hcd); struct oz_urb_link *urbl; int rc; unsigned long irq_state; oz_dbg(URB, "%s: (%p)\n", __func__, urb); urbl = oz_alloc_urb_link(); if (unlikely(urbl == NULL)) return -ENOMEM; spin_lock_irqsave(&g_tasklet_lock, irq_state); /* The following function checks the urb is still in the queue * maintained by the core and that the unlinked field is zero. * If both are true the function sets the unlinked field and returns * zero. Otherwise it returns an error. */ rc = usb_hcd_check_unlink_urb(hcd, urb, status); /* We have to check we haven't completed the urb or are about * to complete it. When we do we set hcpriv to 0 so if this has * already happened we don't put the urb in the cancel queue. */ if ((rc == 0) && urb->hcpriv) { urbl->urb = urb; urbl->port = (struct oz_port *)urb->hcpriv; urbl->ep_num = usb_pipeendpoint(urb->pipe); if (usb_pipein(urb->pipe)) urbl->ep_num |= USB_DIR_IN; list_add_tail(&urbl->link, &ozhcd->urb_cancel_list); spin_unlock_irqrestore(&g_tasklet_lock, irq_state); tasklet_schedule(&g_urb_cancel_tasklet); } else { spin_unlock_irqrestore(&g_tasklet_lock, irq_state); oz_free_urb_link(urbl); } return rc; } /* * Context: unknown */ static void oz_hcd_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep) { } /* * Context: unknown */ static void oz_hcd_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep) { } /* * Context: unknown */ static int oz_hcd_get_frame_number(struct usb_hcd *hcd) { oz_dbg(ON, "oz_hcd_get_frame_number\n"); return oz_usb_get_frame_number(); } /* * Context: softirq * This is called as a consquence of us calling usb_hcd_poll_rh_status() and we * always do that in softirq context. */ static int oz_hcd_hub_status_data(struct usb_hcd *hcd, char *buf) { struct oz_hcd *ozhcd = oz_hcd_private(hcd); int i; buf[0] = 0; buf[1] = 0; spin_lock_bh(&ozhcd->hcd_lock); for (i = 0; i < OZ_NB_PORTS; i++) { if (ozhcd->ports[i].flags & OZ_PORT_F_CHANGED) { oz_dbg(HUB, "Port %d changed\n", i); ozhcd->ports[i].flags &= ~OZ_PORT_F_CHANGED; if (i < 7) buf[0] |= 1 << (i + 1); else buf[1] |= 1 << (i - 7); } } spin_unlock_bh(&ozhcd->hcd_lock); if (buf[0] != 0 || buf[1] != 0) return 2; return 0; } /* * Context: process */ static void oz_get_hub_descriptor(struct usb_hcd *hcd, struct usb_hub_descriptor *desc) { memset(desc, 0, sizeof(*desc)); desc->bDescriptorType = 0x29; desc->bDescLength = 9; desc->wHubCharacteristics = (__force __u16)cpu_to_le16(0x0001); desc->bNbrPorts = OZ_NB_PORTS; } /* * Context: process */ static int oz_set_port_feature(struct usb_hcd *hcd, u16 wvalue, u16 windex) { struct oz_port *port; u8 port_id = (u8)windex; struct oz_hcd *ozhcd = oz_hcd_private(hcd); unsigned set_bits = 0; unsigned clear_bits = 0; if ((port_id < 1) || (port_id > OZ_NB_PORTS)) return -EPIPE; port = &ozhcd->ports[port_id-1]; switch (wvalue) { case USB_PORT_FEAT_CONNECTION: oz_dbg(HUB, "USB_PORT_FEAT_CONNECTION\n"); break; case USB_PORT_FEAT_ENABLE: oz_dbg(HUB, "USB_PORT_FEAT_ENABLE\n"); break; case USB_PORT_FEAT_SUSPEND: oz_dbg(HUB, "USB_PORT_FEAT_SUSPEND\n"); break; case USB_PORT_FEAT_OVER_CURRENT: oz_dbg(HUB, "USB_PORT_FEAT_OVER_CURRENT\n"); break; case USB_PORT_FEAT_RESET: oz_dbg(HUB, "USB_PORT_FEAT_RESET\n"); set_bits = USB_PORT_STAT_ENABLE | (USB_PORT_STAT_C_RESET<<16); clear_bits = USB_PORT_STAT_RESET; ozhcd->ports[port_id-1].bus_addr = 0; break; case USB_PORT_FEAT_POWER: oz_dbg(HUB, "USB_PORT_FEAT_POWER\n"); set_bits |= USB_PORT_STAT_POWER; break; case USB_PORT_FEAT_LOWSPEED: oz_dbg(HUB, "USB_PORT_FEAT_LOWSPEED\n"); break; case USB_PORT_FEAT_C_CONNECTION: oz_dbg(HUB, "USB_PORT_FEAT_C_CONNECTION\n"); break; case USB_PORT_FEAT_C_ENABLE: oz_dbg(HUB, "USB_PORT_FEAT_C_ENABLE\n"); break; case USB_PORT_FEAT_C_SUSPEND: oz_dbg(HUB, "USB_PORT_FEAT_C_SUSPEND\n"); break; case USB_PORT_FEAT_C_OVER_CURRENT: oz_dbg(HUB, "USB_PORT_FEAT_C_OVER_CURRENT\n"); break; case USB_PORT_FEAT_C_RESET: oz_dbg(HUB, "USB_PORT_FEAT_C_RESET\n"); break; case USB_PORT_FEAT_TEST: oz_dbg(HUB, "USB_PORT_FEAT_TEST\n"); break; case USB_PORT_FEAT_INDICATOR: oz_dbg(HUB, "USB_PORT_FEAT_INDICATOR\n"); break; default: oz_dbg(HUB, "Other %d\n", wvalue); break; } if (set_bits || clear_bits) { spin_lock_bh(&port->port_lock); port->status &= ~clear_bits; port->status |= set_bits; spin_unlock_bh(&port->port_lock); } oz_dbg(HUB, "Port[%d] status = 0x%x\n", port_id, port->status); return 0; } /* * Context: process */ static int oz_clear_port_feature(struct usb_hcd *hcd, u16 wvalue, u16 windex) { struct oz_port *port; u8 port_id = (u8)windex; struct oz_hcd *ozhcd = oz_hcd_private(hcd); unsigned clear_bits = 0; if ((port_id < 1) || (port_id > OZ_NB_PORTS)) return -EPIPE; port = &ozhcd->ports[port_id-1]; switch (wvalue) { case USB_PORT_FEAT_CONNECTION: oz_dbg(HUB, "USB_PORT_FEAT_CONNECTION\n"); break; case USB_PORT_FEAT_ENABLE: oz_dbg(HUB, "USB_PORT_FEAT_ENABLE\n"); clear_bits = USB_PORT_STAT_ENABLE; break; case USB_PORT_FEAT_SUSPEND: oz_dbg(HUB, "USB_PORT_FEAT_SUSPEND\n"); break; case USB_PORT_FEAT_OVER_CURRENT: oz_dbg(HUB, "USB_PORT_FEAT_OVER_CURRENT\n"); break; case USB_PORT_FEAT_RESET: oz_dbg(HUB, "USB_PORT_FEAT_RESET\n"); break; case USB_PORT_FEAT_POWER: oz_dbg(HUB, "USB_PORT_FEAT_POWER\n"); clear_bits |= USB_PORT_STAT_POWER; break; case USB_PORT_FEAT_LOWSPEED: oz_dbg(HUB, "USB_PORT_FEAT_LOWSPEED\n"); break; case USB_PORT_FEAT_C_CONNECTION: oz_dbg(HUB, "USB_PORT_FEAT_C_CONNECTION\n"); clear_bits = (USB_PORT_STAT_C_CONNECTION << 16); break; case USB_PORT_FEAT_C_ENABLE: oz_dbg(HUB, "USB_PORT_FEAT_C_ENABLE\n"); clear_bits = (USB_PORT_STAT_C_ENABLE << 16); break; case USB_PORT_FEAT_C_SUSPEND: oz_dbg(HUB, "USB_PORT_FEAT_C_SUSPEND\n"); break; case USB_PORT_FEAT_C_OVER_CURRENT: oz_dbg(HUB, "USB_PORT_FEAT_C_OVER_CURRENT\n"); break; case USB_PORT_FEAT_C_RESET: oz_dbg(HUB, "USB_PORT_FEAT_C_RESET\n"); clear_bits = (USB_PORT_FEAT_C_RESET << 16); break; case USB_PORT_FEAT_TEST: oz_dbg(HUB, "USB_PORT_FEAT_TEST\n"); break; case USB_PORT_FEAT_INDICATOR: oz_dbg(HUB, "USB_PORT_FEAT_INDICATOR\n"); break; default: oz_dbg(HUB, "Other %d\n", wvalue); break; } if (clear_bits) { spin_lock_bh(&port->port_lock); port->status &= ~clear_bits; spin_unlock_bh(&port->port_lock); } oz_dbg(HUB, "Port[%d] status = 0x%x\n", port_id, ozhcd->ports[port_id-1].status); return 0; } /* * Context: process */ static int oz_get_port_status(struct usb_hcd *hcd, u16 windex, char *buf) { struct oz_hcd *ozhcd; u32 status; if ((windex < 1) || (windex > OZ_NB_PORTS)) return -EPIPE; ozhcd = oz_hcd_private(hcd); oz_dbg(HUB, "GetPortStatus windex = %d\n", windex); status = ozhcd->ports[windex-1].status; put_unaligned(cpu_to_le32(status), (__le32 *)buf); oz_dbg(HUB, "Port[%d] status = %x\n", windex, status); return 0; } /* * Context: process */ static int oz_hcd_hub_control(struct usb_hcd *hcd, u16 req_type, u16 wvalue, u16 windex, char *buf, u16 wlength) { int err = 0; switch (req_type) { case ClearHubFeature: oz_dbg(HUB, "ClearHubFeature: %d\n", req_type); break; case ClearPortFeature: err = oz_clear_port_feature(hcd, wvalue, windex); break; case GetHubDescriptor: oz_get_hub_descriptor(hcd, (struct usb_hub_descriptor *)buf); break; case GetHubStatus: oz_dbg(HUB, "GetHubStatus: req_type = 0x%x\n", req_type); put_unaligned(cpu_to_le32(0), (__le32 *)buf); break; case GetPortStatus: err = oz_get_port_status(hcd, windex, buf); break; case SetHubFeature: oz_dbg(HUB, "SetHubFeature: %d\n", req_type); break; case SetPortFeature: err = oz_set_port_feature(hcd, wvalue, windex); break; default: oz_dbg(HUB, "Other: %d\n", req_type); break; } return err; } /* * Context: process */ static int oz_hcd_bus_suspend(struct usb_hcd *hcd) { struct oz_hcd *ozhcd; ozhcd = oz_hcd_private(hcd); spin_lock_bh(&ozhcd->hcd_lock); hcd->state = HC_STATE_SUSPENDED; ozhcd->flags |= OZ_HDC_F_SUSPENDED; spin_unlock_bh(&ozhcd->hcd_lock); return 0; } /* * Context: process */ static int oz_hcd_bus_resume(struct usb_hcd *hcd) { struct oz_hcd *ozhcd; ozhcd = oz_hcd_private(hcd); spin_lock_bh(&ozhcd->hcd_lock); ozhcd->flags &= ~OZ_HDC_F_SUSPENDED; hcd->state = HC_STATE_RUNNING; spin_unlock_bh(&ozhcd->hcd_lock); return 0; } static void oz_plat_shutdown(struct platform_device *dev) { } /* * Context: process */ static int oz_plat_probe(struct platform_device *dev) { int i; int err; struct usb_hcd *hcd; struct oz_hcd *ozhcd; hcd = usb_create_hcd(&g_oz_hc_drv, &dev->dev, dev_name(&dev->dev)); if (hcd == NULL) { oz_dbg(ON, "Failed to created hcd object OK\n"); return -ENOMEM; } ozhcd = oz_hcd_private(hcd); memset(ozhcd, 0, sizeof(*ozhcd)); INIT_LIST_HEAD(&ozhcd->urb_pending_list); INIT_LIST_HEAD(&ozhcd->urb_cancel_list); INIT_LIST_HEAD(&ozhcd->orphanage); ozhcd->hcd = hcd; ozhcd->conn_port = -1; spin_lock_init(&ozhcd->hcd_lock); for (i = 0; i < OZ_NB_PORTS; i++) { struct oz_port *port = &ozhcd->ports[i]; port->ozhcd = ozhcd; port->flags = 0; port->status = 0; port->bus_addr = 0xff; spin_lock_init(&port->port_lock); } err = usb_add_hcd(hcd, 0, 0); if (err) { oz_dbg(ON, "Failed to add hcd object OK\n"); usb_put_hcd(hcd); return -1; } device_wakeup_enable(hcd->self.controller); spin_lock_bh(&g_hcdlock); g_ozhcd = ozhcd; spin_unlock_bh(&g_hcdlock); return 0; } /* * Context: unknown */ static int oz_plat_remove(struct platform_device *dev) { struct usb_hcd *hcd = platform_get_drvdata(dev); struct oz_hcd *ozhcd; if (hcd == NULL) return -1; ozhcd = oz_hcd_private(hcd); spin_lock_bh(&g_hcdlock); if (ozhcd == g_ozhcd) g_ozhcd = NULL; spin_unlock_bh(&g_hcdlock); oz_dbg(ON, "Clearing orphanage\n"); oz_hcd_clear_orphanage(ozhcd, -EPIPE); oz_dbg(ON, "Removing hcd\n"); usb_remove_hcd(hcd); usb_put_hcd(hcd); return 0; } /* * Context: unknown */ static int oz_plat_suspend(struct platform_device *dev, pm_message_t msg) { return 0; } /* * Context: unknown */ static int oz_plat_resume(struct platform_device *dev) { return 0; } /* * Context: process */ int oz_hcd_init(void) { int err; if (usb_disabled()) return -ENODEV; oz_urb_link_cache = KMEM_CACHE(oz_urb_link, 0); if (!oz_urb_link_cache) return -ENOMEM; tasklet_init(&g_urb_process_tasklet, oz_urb_process_tasklet, 0); tasklet_init(&g_urb_cancel_tasklet, oz_urb_cancel_tasklet, 0); err = platform_driver_register(&g_oz_plat_drv); oz_dbg(ON, "platform_driver_register() returned %d\n", err); if (err) goto error; g_plat_dev = platform_device_alloc(OZ_PLAT_DEV_NAME, -1); if (g_plat_dev == NULL) { err = -ENOMEM; goto error1; } oz_dbg(ON, "platform_device_alloc() succeeded\n"); err = platform_device_add(g_plat_dev); if (err) goto error2; oz_dbg(ON, "platform_device_add() succeeded\n"); return 0; error2: platform_device_put(g_plat_dev); error1: platform_driver_unregister(&g_oz_plat_drv); error: tasklet_disable(&g_urb_process_tasklet); tasklet_disable(&g_urb_cancel_tasklet); oz_dbg(ON, "oz_hcd_init() failed %d\n", err); return err; } /* * Context: process */ void oz_hcd_term(void) { msleep(OZ_HUB_DEBOUNCE_TIMEOUT); tasklet_kill(&g_urb_process_tasklet); tasklet_kill(&g_urb_cancel_tasklet); platform_device_unregister(g_plat_dev); platform_driver_unregister(&g_oz_plat_drv); oz_dbg(ON, "Pending urbs:%d\n", atomic_read(&g_pending_urbs)); kmem_cache_destroy(oz_urb_link_cache); }