From 771378bb05c16d5aa9d7913b4947068795852055 Mon Sep 17 00:00:00 2001 From: Aaro Koskinen Date: Thu, 13 Jun 2013 01:00:31 +0300 Subject: [PATCH] staging: octeon-usb: octeon-hcd: use tabs for code indent Replace spaces with tabs where possible. Signed-off-by: Aaro Koskinen Signed-off-by: Greg Kroah-Hartman --- drivers/staging/octeon-usb/octeon-hcd.c | 1254 +++++++++++------------ 1 file changed, 627 insertions(+), 627 deletions(-) diff --git a/drivers/staging/octeon-usb/octeon-hcd.c b/drivers/staging/octeon-usb/octeon-hcd.c index 08de25f94754..05c86ff8563e 100644 --- a/drivers/staging/octeon-usb/octeon-hcd.c +++ b/drivers/staging/octeon-usb/octeon-hcd.c @@ -35,10 +35,10 @@ #define DEBUG_FATAL(format, ...) printk(format, ##__VA_ARGS__) struct octeon_hcd { - spinlock_t lock; - cvmx_usb_state_t usb; - struct tasklet_struct dequeue_tasklet; - struct list_head dequeue_list; + spinlock_t lock; + cvmx_usb_state_t usb; + struct tasklet_struct dequeue_tasklet; + struct list_head dequeue_list; }; /* convert between an HCD pointer and the corresponding struct octeon_hcd */ @@ -59,75 +59,75 @@ static inline struct octeon_hcd *cvmx_usb_to_octeon(cvmx_usb_state_t *p) static irqreturn_t octeon_usb_irq(struct usb_hcd *hcd) { - struct octeon_hcd *priv = hcd_to_octeon(hcd); - unsigned long flags; - DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); - spin_lock_irqsave(&priv->lock, flags); - cvmx_usb_poll(&priv->usb); - spin_unlock_irqrestore(&priv->lock, flags); - return IRQ_HANDLED; + struct octeon_hcd *priv = hcd_to_octeon(hcd); + unsigned long flags; + DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); + spin_lock_irqsave(&priv->lock, flags); + cvmx_usb_poll(&priv->usb); + spin_unlock_irqrestore(&priv->lock, flags); + return IRQ_HANDLED; } static void octeon_usb_port_callback(cvmx_usb_state_t *usb, - cvmx_usb_callback_t reason, - cvmx_usb_complete_t status, - int pipe_handle, - int submit_handle, - int bytes_transferred, - void *user_data) + cvmx_usb_callback_t reason, + cvmx_usb_complete_t status, + int pipe_handle, + int submit_handle, + int bytes_transferred, + void *user_data) { - struct octeon_hcd *priv = cvmx_usb_to_octeon(usb); - DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); - spin_unlock(&priv->lock); - usb_hcd_poll_rh_status(octeon_to_hcd(priv)); - spin_lock(&priv->lock); + struct octeon_hcd *priv = cvmx_usb_to_octeon(usb); + DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); + spin_unlock(&priv->lock); + usb_hcd_poll_rh_status(octeon_to_hcd(priv)); + spin_lock(&priv->lock); } static int octeon_usb_start(struct usb_hcd *hcd) { - struct octeon_hcd *priv = hcd_to_octeon(hcd); - unsigned long flags; - DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); - hcd->state = HC_STATE_RUNNING; - spin_lock_irqsave(&priv->lock, flags); - cvmx_usb_register_callback(&priv->usb, CVMX_USB_CALLBACK_PORT_CHANGED, - octeon_usb_port_callback, NULL); - spin_unlock_irqrestore(&priv->lock, flags); - return 0; + struct octeon_hcd *priv = hcd_to_octeon(hcd); + unsigned long flags; + DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); + hcd->state = HC_STATE_RUNNING; + spin_lock_irqsave(&priv->lock, flags); + cvmx_usb_register_callback(&priv->usb, CVMX_USB_CALLBACK_PORT_CHANGED, + octeon_usb_port_callback, NULL); + spin_unlock_irqrestore(&priv->lock, flags); + return 0; } static void octeon_usb_stop(struct usb_hcd *hcd) { - struct octeon_hcd *priv = hcd_to_octeon(hcd); - unsigned long flags; - DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); - spin_lock_irqsave(&priv->lock, flags); - cvmx_usb_register_callback(&priv->usb, CVMX_USB_CALLBACK_PORT_CHANGED, - NULL, NULL); - spin_unlock_irqrestore(&priv->lock, flags); - hcd->state = HC_STATE_HALT; + struct octeon_hcd *priv = hcd_to_octeon(hcd); + unsigned long flags; + DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); + spin_lock_irqsave(&priv->lock, flags); + cvmx_usb_register_callback(&priv->usb, CVMX_USB_CALLBACK_PORT_CHANGED, + NULL, NULL); + spin_unlock_irqrestore(&priv->lock, flags); + hcd->state = HC_STATE_HALT; } static int octeon_usb_get_frame_number(struct usb_hcd *hcd) { - struct octeon_hcd *priv = hcd_to_octeon(hcd); - DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); - return cvmx_usb_get_frame_number(&priv->usb); + struct octeon_hcd *priv = hcd_to_octeon(hcd); + DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); + return cvmx_usb_get_frame_number(&priv->usb); } static void octeon_usb_urb_complete_callback(cvmx_usb_state_t *usb, - cvmx_usb_callback_t reason, - cvmx_usb_complete_t status, - int pipe_handle, - int submit_handle, - int bytes_transferred, - void *user_data) + cvmx_usb_callback_t reason, + cvmx_usb_complete_t status, + int pipe_handle, + int submit_handle, + int bytes_transferred, + void *user_data) { - struct octeon_hcd *priv = cvmx_usb_to_octeon(usb); - struct urb *urb = user_data; - DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); - urb->actual_length = bytes_transferred; - urb->hcpriv = NULL; + struct octeon_hcd *priv = cvmx_usb_to_octeon(usb); + struct urb *urb = user_data; + DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); + urb->actual_length = bytes_transferred; + urb->hcpriv = NULL; if (!list_empty(&urb->urb_list)) { /* @@ -141,598 +141,598 @@ static void octeon_usb_urb_complete_callback(cvmx_usb_state_t *usb, INIT_LIST_HEAD(&urb->urb_list); } - /* For Isochronous transactions we need to update the URB packet status - list from data in our private copy */ - if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) { - int i; - /* The pointer to the private list is stored in the setup_packet field */ - cvmx_usb_iso_packet_t *iso_packet = (cvmx_usb_iso_packet_t *)urb->setup_packet; - /* Recalculate the transfer size by adding up each packet */ - urb->actual_length = 0; - for (i=0; inumber_of_packets; i++) { - if (iso_packet[i].status == CVMX_USB_COMPLETE_SUCCESS) { - urb->iso_frame_desc[i].status = 0; - urb->iso_frame_desc[i].actual_length = iso_packet[i].length; - urb->actual_length += urb->iso_frame_desc[i].actual_length; - } else { - DEBUG_ERROR("%s: ISOCHRONOUS packet=%d of %d status=%d pipe=%d submit=%d size=%d\n", - __FUNCTION__, i, urb->number_of_packets, - iso_packet[i].status, pipe_handle, - submit_handle, iso_packet[i].length); - urb->iso_frame_desc[i].status = -EREMOTEIO; - } - } - /* Free the private list now that we don't need it anymore */ - kfree(iso_packet); - urb->setup_packet = NULL; - } - - switch (status) { - case CVMX_USB_COMPLETE_SUCCESS: - urb->status = 0; - break; - case CVMX_USB_COMPLETE_CANCEL: - if (urb->status == 0) - urb->status = -ENOENT; - break; - case CVMX_USB_COMPLETE_STALL: - DEBUG_ERROR("%s: status=stall pipe=%d submit=%d size=%d\n", __FUNCTION__, pipe_handle, submit_handle, bytes_transferred); - urb->status = -EPIPE; - break; - case CVMX_USB_COMPLETE_BABBLEERR: - DEBUG_ERROR("%s: status=babble pipe=%d submit=%d size=%d\n", __FUNCTION__, pipe_handle, submit_handle, bytes_transferred); - urb->status = -EPIPE; - break; - case CVMX_USB_COMPLETE_SHORT: - DEBUG_ERROR("%s: status=short pipe=%d submit=%d size=%d\n", __FUNCTION__, pipe_handle, submit_handle, bytes_transferred); - urb->status = -EREMOTEIO; - break; - case CVMX_USB_COMPLETE_ERROR: - case CVMX_USB_COMPLETE_XACTERR: - case CVMX_USB_COMPLETE_DATATGLERR: - case CVMX_USB_COMPLETE_FRAMEERR: - DEBUG_ERROR("%s: status=%d pipe=%d submit=%d size=%d\n", __FUNCTION__, status, pipe_handle, submit_handle, bytes_transferred); - urb->status = -EPROTO; - break; - } - spin_unlock(&priv->lock); - usb_hcd_giveback_urb(octeon_to_hcd(priv), urb, urb->status); - spin_lock(&priv->lock); + /* For Isochronous transactions we need to update the URB packet status + list from data in our private copy */ + if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) { + int i; + /* The pointer to the private list is stored in the setup_packet field */ + cvmx_usb_iso_packet_t *iso_packet = (cvmx_usb_iso_packet_t *) urb->setup_packet; + /* Recalculate the transfer size by adding up each packet */ + urb->actual_length = 0; + for (i = 0; i < urb->number_of_packets; i++) { + if (iso_packet[i].status == CVMX_USB_COMPLETE_SUCCESS) { + urb->iso_frame_desc[i].status = 0; + urb->iso_frame_desc[i].actual_length = iso_packet[i].length; + urb->actual_length += urb->iso_frame_desc[i].actual_length; + } else { + DEBUG_ERROR("%s: ISOCHRONOUS packet=%d of %d status=%d pipe=%d submit=%d size=%d\n", + __FUNCTION__, i, urb->number_of_packets, + iso_packet[i].status, pipe_handle, + submit_handle, iso_packet[i].length); + urb->iso_frame_desc[i].status = -EREMOTEIO; + } + } + /* Free the private list now that we don't need it anymore */ + kfree(iso_packet); + urb->setup_packet = NULL; + } + + switch (status) { + case CVMX_USB_COMPLETE_SUCCESS: + urb->status = 0; + break; + case CVMX_USB_COMPLETE_CANCEL: + if (urb->status == 0) + urb->status = -ENOENT; + break; + case CVMX_USB_COMPLETE_STALL: + DEBUG_ERROR("%s: status=stall pipe=%d submit=%d size=%d\n", __FUNCTION__, pipe_handle, submit_handle, bytes_transferred); + urb->status = -EPIPE; + break; + case CVMX_USB_COMPLETE_BABBLEERR: + DEBUG_ERROR("%s: status=babble pipe=%d submit=%d size=%d\n", __FUNCTION__, pipe_handle, submit_handle, bytes_transferred); + urb->status = -EPIPE; + break; + case CVMX_USB_COMPLETE_SHORT: + DEBUG_ERROR("%s: status=short pipe=%d submit=%d size=%d\n", __FUNCTION__, pipe_handle, submit_handle, bytes_transferred); + urb->status = -EREMOTEIO; + break; + case CVMX_USB_COMPLETE_ERROR: + case CVMX_USB_COMPLETE_XACTERR: + case CVMX_USB_COMPLETE_DATATGLERR: + case CVMX_USB_COMPLETE_FRAMEERR: + DEBUG_ERROR("%s: status=%d pipe=%d submit=%d size=%d\n", __FUNCTION__, status, pipe_handle, submit_handle, bytes_transferred); + urb->status = -EPROTO; + break; + } + spin_unlock(&priv->lock); + usb_hcd_giveback_urb(octeon_to_hcd(priv), urb, urb->status); + spin_lock(&priv->lock); } static int octeon_usb_urb_enqueue(struct usb_hcd *hcd, - struct urb *urb, - gfp_t mem_flags) + struct urb *urb, + gfp_t mem_flags) { - struct octeon_hcd *priv = hcd_to_octeon(hcd); - int submit_handle = -1; - int pipe_handle; - unsigned long flags; - cvmx_usb_iso_packet_t *iso_packet; - struct usb_host_endpoint *ep = urb->ep; - - DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); - - urb->status = 0; - INIT_LIST_HEAD(&urb->urb_list); /* not enqueued on dequeue_list */ - spin_lock_irqsave(&priv->lock, flags); - - if (!ep->hcpriv) { - cvmx_usb_transfer_t transfer_type; - cvmx_usb_speed_t speed; - int split_device = 0; - int split_port = 0; - switch (usb_pipetype(urb->pipe)) { - case PIPE_ISOCHRONOUS: - transfer_type = CVMX_USB_TRANSFER_ISOCHRONOUS; - break; - case PIPE_INTERRUPT: - transfer_type = CVMX_USB_TRANSFER_INTERRUPT; - break; - case PIPE_CONTROL: - transfer_type = CVMX_USB_TRANSFER_CONTROL; - break; - default: - transfer_type = CVMX_USB_TRANSFER_BULK; - break; - } - switch (urb->dev->speed) { - case USB_SPEED_LOW: - speed = CVMX_USB_SPEED_LOW; - break; - case USB_SPEED_FULL: - speed = CVMX_USB_SPEED_FULL; - break; - default: - speed = CVMX_USB_SPEED_HIGH; - break; - } - /* For slow devices on high speed ports we need to find the hub that - does the speed translation so we know where to send the split - transactions */ - if (speed != CVMX_USB_SPEED_HIGH) { - /* Start at this device and work our way up the usb tree */ - struct usb_device *dev = urb->dev; - while (dev->parent) { - /* If our parent is high speed then he'll receive the splits */ - if (dev->parent->speed == USB_SPEED_HIGH) { - split_device = dev->parent->devnum; - split_port = dev->portnum; - break; - } - /* Move up the tree one level. If we make it all the way up the - tree, then the port must not be in high speed mode and we - don't need a split */ - dev = dev->parent; - } - } - pipe_handle = cvmx_usb_open_pipe(&priv->usb, - 0, - usb_pipedevice(urb->pipe), - usb_pipeendpoint(urb->pipe), - speed, - le16_to_cpu(ep->desc.wMaxPacketSize) & 0x7ff, - transfer_type, - usb_pipein(urb->pipe) ? CVMX_USB_DIRECTION_IN : CVMX_USB_DIRECTION_OUT, - urb->interval, - (le16_to_cpu(ep->desc.wMaxPacketSize)>>11) & 0x3, - split_device, - split_port); - if (pipe_handle < 0) { - spin_unlock_irqrestore(&priv->lock, flags); - DEBUG_ERROR("OcteonUSB: %s failed to create pipe\n", __FUNCTION__); - return -ENOMEM; - } - ep->hcpriv = (void*)(0x10000L + pipe_handle); - } - else - pipe_handle = 0xffff & (long)ep->hcpriv; - - switch (usb_pipetype(urb->pipe)) { - case PIPE_ISOCHRONOUS: - DEBUG_SUBMIT("OcteonUSB: %s submit isochronous to %d.%d\n", __FUNCTION__, usb_pipedevice(urb->pipe), usb_pipeendpoint(urb->pipe)); - /* Allocate a structure to use for our private list of isochronous - packets */ - iso_packet = kmalloc(urb->number_of_packets * sizeof(cvmx_usb_iso_packet_t), GFP_ATOMIC); - if (iso_packet) { - int i; - /* Fill the list with the data from the URB */ - for (i=0; inumber_of_packets; i++) { - iso_packet[i].offset = urb->iso_frame_desc[i].offset; - iso_packet[i].length = urb->iso_frame_desc[i].length; - iso_packet[i].status = CVMX_USB_COMPLETE_ERROR; - } - /* Store a pointer to the list in uthe URB setup_pakcet field. - We know this currently isn't being used and this saves us - a bunch of logic */ - urb->setup_packet = (char*)iso_packet; - submit_handle = cvmx_usb_submit_isochronous(&priv->usb, pipe_handle, - urb->start_frame, - 0 /* flags */, - urb->number_of_packets, - iso_packet, - urb->transfer_dma, - urb->transfer_buffer_length, - octeon_usb_urb_complete_callback, - urb); - /* If submit failed we need to free our private packet list */ - if (submit_handle < 0) { - urb->setup_packet = NULL; - kfree(iso_packet); - } - } - break; - case PIPE_INTERRUPT: - DEBUG_SUBMIT("OcteonUSB: %s submit interrupt to %d.%d\n", __FUNCTION__, usb_pipedevice(urb->pipe), usb_pipeendpoint(urb->pipe)); - submit_handle = cvmx_usb_submit_interrupt(&priv->usb, pipe_handle, - urb->transfer_dma, - urb->transfer_buffer_length, - octeon_usb_urb_complete_callback, - urb); - break; - case PIPE_CONTROL: - DEBUG_SUBMIT("OcteonUSB: %s submit control to %d.%d\n", __FUNCTION__, usb_pipedevice(urb->pipe), usb_pipeendpoint(urb->pipe)); - submit_handle = cvmx_usb_submit_control(&priv->usb, pipe_handle, - urb->setup_dma, - urb->transfer_dma, - urb->transfer_buffer_length, - octeon_usb_urb_complete_callback, - urb); - break; - case PIPE_BULK: - DEBUG_SUBMIT("OcteonUSB: %s submit bulk to %d.%d\n", __FUNCTION__, usb_pipedevice(urb->pipe), usb_pipeendpoint(urb->pipe)); - submit_handle = cvmx_usb_submit_bulk(&priv->usb, pipe_handle, - urb->transfer_dma, - urb->transfer_buffer_length, - octeon_usb_urb_complete_callback, - urb); - break; - } - if (submit_handle < 0) { - spin_unlock_irqrestore(&priv->lock, flags); - DEBUG_ERROR("OcteonUSB: %s failed to submit\n", __FUNCTION__); - return -ENOMEM; - } - urb->hcpriv = (void*)(long)(((submit_handle & 0xffff) << 16) | pipe_handle); - spin_unlock_irqrestore(&priv->lock, flags); - return 0; + struct octeon_hcd *priv = hcd_to_octeon(hcd); + int submit_handle = -1; + int pipe_handle; + unsigned long flags; + cvmx_usb_iso_packet_t *iso_packet; + struct usb_host_endpoint *ep = urb->ep; + + DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); + + urb->status = 0; + INIT_LIST_HEAD(&urb->urb_list); /* not enqueued on dequeue_list */ + spin_lock_irqsave(&priv->lock, flags); + + if (!ep->hcpriv) { + cvmx_usb_transfer_t transfer_type; + cvmx_usb_speed_t speed; + int split_device = 0; + int split_port = 0; + switch (usb_pipetype(urb->pipe)) { + case PIPE_ISOCHRONOUS: + transfer_type = CVMX_USB_TRANSFER_ISOCHRONOUS; + break; + case PIPE_INTERRUPT: + transfer_type = CVMX_USB_TRANSFER_INTERRUPT; + break; + case PIPE_CONTROL: + transfer_type = CVMX_USB_TRANSFER_CONTROL; + break; + default: + transfer_type = CVMX_USB_TRANSFER_BULK; + break; + } + switch (urb->dev->speed) { + case USB_SPEED_LOW: + speed = CVMX_USB_SPEED_LOW; + break; + case USB_SPEED_FULL: + speed = CVMX_USB_SPEED_FULL; + break; + default: + speed = CVMX_USB_SPEED_HIGH; + break; + } + /* For slow devices on high speed ports we need to find the hub that + does the speed translation so we know where to send the split + transactions */ + if (speed != CVMX_USB_SPEED_HIGH) { + /* Start at this device and work our way up the usb tree */ + struct usb_device *dev = urb->dev; + while (dev->parent) { + /* If our parent is high speed then he'll receive the splits */ + if (dev->parent->speed == USB_SPEED_HIGH) { + split_device = dev->parent->devnum; + split_port = dev->portnum; + break; + } + /* Move up the tree one level. If we make it all the way up the + tree, then the port must not be in high speed mode and we + don't need a split */ + dev = dev->parent; + } + } + pipe_handle = cvmx_usb_open_pipe(&priv->usb, + 0, + usb_pipedevice(urb->pipe), + usb_pipeendpoint(urb->pipe), + speed, + le16_to_cpu(ep->desc.wMaxPacketSize) & 0x7ff, + transfer_type, + usb_pipein(urb->pipe) ? CVMX_USB_DIRECTION_IN : CVMX_USB_DIRECTION_OUT, + urb->interval, + (le16_to_cpu(ep->desc.wMaxPacketSize) >> 11) & 0x3, + split_device, + split_port); + if (pipe_handle < 0) { + spin_unlock_irqrestore(&priv->lock, flags); + DEBUG_ERROR("OcteonUSB: %s failed to create pipe\n", __FUNCTION__); + return -ENOMEM; + } + ep->hcpriv = (void *)(0x10000L + pipe_handle); + } + else + pipe_handle = 0xffff & (long)ep->hcpriv; + + switch (usb_pipetype(urb->pipe)) { + case PIPE_ISOCHRONOUS: + DEBUG_SUBMIT("OcteonUSB: %s submit isochronous to %d.%d\n", __FUNCTION__, usb_pipedevice(urb->pipe), usb_pipeendpoint(urb->pipe)); + /* Allocate a structure to use for our private list of isochronous + packets */ + iso_packet = kmalloc(urb->number_of_packets * sizeof(cvmx_usb_iso_packet_t), GFP_ATOMIC); + if (iso_packet) { + int i; + /* Fill the list with the data from the URB */ + for (i = 0; i < urb->number_of_packets; i++) { + iso_packet[i].offset = urb->iso_frame_desc[i].offset; + iso_packet[i].length = urb->iso_frame_desc[i].length; + iso_packet[i].status = CVMX_USB_COMPLETE_ERROR; + } + /* Store a pointer to the list in uthe URB setup_pakcet field. + We know this currently isn't being used and this saves us + a bunch of logic */ + urb->setup_packet = (char *)iso_packet; + submit_handle = cvmx_usb_submit_isochronous(&priv->usb, pipe_handle, + urb->start_frame, + 0 /* flags */ , + urb->number_of_packets, + iso_packet, + urb->transfer_dma, + urb->transfer_buffer_length, + octeon_usb_urb_complete_callback, + urb); + /* If submit failed we need to free our private packet list */ + if (submit_handle < 0) { + urb->setup_packet = NULL; + kfree(iso_packet); + } + } + break; + case PIPE_INTERRUPT: + DEBUG_SUBMIT("OcteonUSB: %s submit interrupt to %d.%d\n", __FUNCTION__, usb_pipedevice(urb->pipe), usb_pipeendpoint(urb->pipe)); + submit_handle = cvmx_usb_submit_interrupt(&priv->usb, pipe_handle, + urb->transfer_dma, + urb->transfer_buffer_length, + octeon_usb_urb_complete_callback, + urb); + break; + case PIPE_CONTROL: + DEBUG_SUBMIT("OcteonUSB: %s submit control to %d.%d\n", __FUNCTION__, usb_pipedevice(urb->pipe), usb_pipeendpoint(urb->pipe)); + submit_handle = cvmx_usb_submit_control(&priv->usb, pipe_handle, + urb->setup_dma, + urb->transfer_dma, + urb->transfer_buffer_length, + octeon_usb_urb_complete_callback, + urb); + break; + case PIPE_BULK: + DEBUG_SUBMIT("OcteonUSB: %s submit bulk to %d.%d\n", __FUNCTION__, usb_pipedevice(urb->pipe), usb_pipeendpoint(urb->pipe)); + submit_handle = cvmx_usb_submit_bulk(&priv->usb, pipe_handle, + urb->transfer_dma, + urb->transfer_buffer_length, + octeon_usb_urb_complete_callback, + urb); + break; + } + if (submit_handle < 0) { + spin_unlock_irqrestore(&priv->lock, flags); + DEBUG_ERROR("OcteonUSB: %s failed to submit\n", __FUNCTION__); + return -ENOMEM; + } + urb->hcpriv = (void *)(long)(((submit_handle & 0xffff) << 16) | pipe_handle); + spin_unlock_irqrestore(&priv->lock, flags); + return 0; } static void octeon_usb_urb_dequeue_work(unsigned long arg) { - unsigned long flags; - struct octeon_hcd *priv = (struct octeon_hcd *)arg; - - spin_lock_irqsave(&priv->lock, flags); - - while (!list_empty(&priv->dequeue_list)) { - int pipe_handle; - int submit_handle; - struct urb *urb = container_of(priv->dequeue_list.next, struct urb, urb_list); - list_del(&urb->urb_list); - /* not enqueued on dequeue_list */ - INIT_LIST_HEAD(&urb->urb_list); - pipe_handle = 0xffff & (long)urb->hcpriv; - submit_handle = ((long)urb->hcpriv) >> 16; - cvmx_usb_cancel(&priv->usb, pipe_handle, submit_handle); - } - - spin_unlock_irqrestore(&priv->lock, flags); + unsigned long flags; + struct octeon_hcd *priv = (struct octeon_hcd *)arg; + + spin_lock_irqsave(&priv->lock, flags); + + while (!list_empty(&priv->dequeue_list)) { + int pipe_handle; + int submit_handle; + struct urb *urb = container_of(priv->dequeue_list.next, struct urb, urb_list); + list_del(&urb->urb_list); + /* not enqueued on dequeue_list */ + INIT_LIST_HEAD(&urb->urb_list); + pipe_handle = 0xffff & (long)urb->hcpriv; + submit_handle = ((long)urb->hcpriv) >> 16; + cvmx_usb_cancel(&priv->usb, pipe_handle, submit_handle); + } + + spin_unlock_irqrestore(&priv->lock, flags); } static int octeon_usb_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) { - struct octeon_hcd *priv = hcd_to_octeon(hcd); - unsigned long flags; + struct octeon_hcd *priv = hcd_to_octeon(hcd); + unsigned long flags; - DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); + DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); - if (!urb->dev) - return -EINVAL; + if (!urb->dev) + return -EINVAL; - spin_lock_irqsave(&priv->lock, flags); + spin_lock_irqsave(&priv->lock, flags); - urb->status = status; - list_add_tail(&urb->urb_list, &priv->dequeue_list); + urb->status = status; + list_add_tail(&urb->urb_list, &priv->dequeue_list); - spin_unlock_irqrestore(&priv->lock, flags); + spin_unlock_irqrestore(&priv->lock, flags); - tasklet_schedule(&priv->dequeue_tasklet); + tasklet_schedule(&priv->dequeue_tasklet); - return 0; + return 0; } static void octeon_usb_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep) { - DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); - if (ep->hcpriv) { - struct octeon_hcd *priv = hcd_to_octeon(hcd); - int pipe_handle = 0xffff & (long)ep->hcpriv; - unsigned long flags; - spin_lock_irqsave(&priv->lock, flags); - cvmx_usb_cancel_all(&priv->usb, pipe_handle); - if (cvmx_usb_close_pipe(&priv->usb, pipe_handle)) - DEBUG_ERROR("OcteonUSB: Closing pipe %d failed\n", pipe_handle); - spin_unlock_irqrestore(&priv->lock, flags); - ep->hcpriv = NULL; - } + DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); + if (ep->hcpriv) { + struct octeon_hcd *priv = hcd_to_octeon(hcd); + int pipe_handle = 0xffff & (long)ep->hcpriv; + unsigned long flags; + spin_lock_irqsave(&priv->lock, flags); + cvmx_usb_cancel_all(&priv->usb, pipe_handle); + if (cvmx_usb_close_pipe(&priv->usb, pipe_handle)) + DEBUG_ERROR("OcteonUSB: Closing pipe %d failed\n", pipe_handle); + spin_unlock_irqrestore(&priv->lock, flags); + ep->hcpriv = NULL; + } } static int octeon_usb_hub_status_data(struct usb_hcd *hcd, char *buf) { - struct octeon_hcd *priv = hcd_to_octeon(hcd); - cvmx_usb_port_status_t port_status; - unsigned long flags; + struct octeon_hcd *priv = hcd_to_octeon(hcd); + cvmx_usb_port_status_t port_status; + unsigned long flags; - DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); + DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); - spin_lock_irqsave(&priv->lock, flags); - port_status = cvmx_usb_get_status(&priv->usb); - spin_unlock_irqrestore(&priv->lock, flags); - buf[0] = 0; - buf[0] = port_status.connect_change << 1; + spin_lock_irqsave(&priv->lock, flags); + port_status = cvmx_usb_get_status(&priv->usb); + spin_unlock_irqrestore(&priv->lock, flags); + buf[0] = 0; + buf[0] = port_status.connect_change << 1; - return(buf[0] != 0); + return (buf[0] != 0); } static int octeon_usb_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, u16 wIndex, char *buf, u16 wLength) { - struct octeon_hcd *priv = hcd_to_octeon(hcd); - cvmx_usb_port_status_t usb_port_status; - int port_status; - struct usb_hub_descriptor *desc; - unsigned long flags; - - switch (typeReq) { - case ClearHubFeature: - DEBUG_ROOT_HUB("OcteonUSB: ClearHubFeature\n"); - switch (wValue) { - case C_HUB_LOCAL_POWER: - case C_HUB_OVER_CURRENT: - /* Nothing required here */ - break; - default: - return -EINVAL; - } - break; - case ClearPortFeature: - DEBUG_ROOT_HUB("OcteonUSB: ClearPortFeature"); - if (wIndex != 1) { - DEBUG_ROOT_HUB(" INVALID\n"); - return -EINVAL; - } - - switch (wValue) { - case USB_PORT_FEAT_ENABLE: - DEBUG_ROOT_HUB(" ENABLE"); - spin_lock_irqsave(&priv->lock, flags); - cvmx_usb_disable(&priv->usb); - spin_unlock_irqrestore(&priv->lock, flags); - break; - case USB_PORT_FEAT_SUSPEND: - DEBUG_ROOT_HUB(" SUSPEND"); - /* Not supported on Octeon */ - break; - case USB_PORT_FEAT_POWER: - DEBUG_ROOT_HUB(" POWER"); - /* Not supported on Octeon */ - break; - case USB_PORT_FEAT_INDICATOR: - DEBUG_ROOT_HUB(" INDICATOR"); - /* Port inidicator not supported */ - break; - case USB_PORT_FEAT_C_CONNECTION: - DEBUG_ROOT_HUB(" C_CONNECTION"); - /* Clears drivers internal connect status change flag */ - spin_lock_irqsave(&priv->lock, flags); - cvmx_usb_set_status(&priv->usb, cvmx_usb_get_status(&priv->usb)); - spin_unlock_irqrestore(&priv->lock, flags); - break; - case USB_PORT_FEAT_C_RESET: - DEBUG_ROOT_HUB(" C_RESET"); - /* Clears the driver's internal Port Reset Change flag */ - spin_lock_irqsave(&priv->lock, flags); - cvmx_usb_set_status(&priv->usb, cvmx_usb_get_status(&priv->usb)); - spin_unlock_irqrestore(&priv->lock, flags); - break; - case USB_PORT_FEAT_C_ENABLE: - DEBUG_ROOT_HUB(" C_ENABLE"); - /* Clears the driver's internal Port Enable/Disable Change flag */ - spin_lock_irqsave(&priv->lock, flags); - cvmx_usb_set_status(&priv->usb, cvmx_usb_get_status(&priv->usb)); - spin_unlock_irqrestore(&priv->lock, flags); - break; - case USB_PORT_FEAT_C_SUSPEND: - DEBUG_ROOT_HUB(" C_SUSPEND"); - /* Clears the driver's internal Port Suspend Change flag, - which is set when resume signaling on the host port is - complete */ - break; - case USB_PORT_FEAT_C_OVER_CURRENT: - DEBUG_ROOT_HUB(" C_OVER_CURRENT"); - /* Clears the driver's overcurrent Change flag */ - spin_lock_irqsave(&priv->lock, flags); - cvmx_usb_set_status(&priv->usb, cvmx_usb_get_status(&priv->usb)); - spin_unlock_irqrestore(&priv->lock, flags); - break; - default: - DEBUG_ROOT_HUB(" UNKNOWN\n"); - return -EINVAL; - } - DEBUG_ROOT_HUB("\n"); - break; - case GetHubDescriptor: - DEBUG_ROOT_HUB("OcteonUSB: GetHubDescriptor\n"); - desc = (struct usb_hub_descriptor *)buf; - desc->bDescLength = 9; - desc->bDescriptorType = 0x29; - desc->bNbrPorts = 1; - desc->wHubCharacteristics = 0x08; - desc->bPwrOn2PwrGood = 1; - desc->bHubContrCurrent = 0; - desc->u.hs.DeviceRemovable[0] = 0; - desc->u.hs.DeviceRemovable[1] = 0xff; - break; - case GetHubStatus: - DEBUG_ROOT_HUB("OcteonUSB: GetHubStatus\n"); - *(__le32 *)buf = 0; - break; - case GetPortStatus: - DEBUG_ROOT_HUB("OcteonUSB: GetPortStatus"); - if (wIndex != 1) { - DEBUG_ROOT_HUB(" INVALID\n"); - return -EINVAL; - } - - spin_lock_irqsave(&priv->lock, flags); - usb_port_status = cvmx_usb_get_status(&priv->usb); - spin_unlock_irqrestore(&priv->lock, flags); - port_status = 0; - - if (usb_port_status.connect_change) { - port_status |= (1 << USB_PORT_FEAT_C_CONNECTION); - DEBUG_ROOT_HUB(" C_CONNECTION"); - } - - if (usb_port_status.port_enabled) { - port_status |= (1 << USB_PORT_FEAT_C_ENABLE); - DEBUG_ROOT_HUB(" C_ENABLE"); - } - - if (usb_port_status.connected) { - port_status |= (1 << USB_PORT_FEAT_CONNECTION); - DEBUG_ROOT_HUB(" CONNECTION"); - } - - if (usb_port_status.port_enabled) { - port_status |= (1 << USB_PORT_FEAT_ENABLE); - DEBUG_ROOT_HUB(" ENABLE"); - } - - if (usb_port_status.port_over_current) { - port_status |= (1 << USB_PORT_FEAT_OVER_CURRENT); - DEBUG_ROOT_HUB(" OVER_CURRENT"); - } - - if (usb_port_status.port_powered) { - port_status |= (1 << USB_PORT_FEAT_POWER); - DEBUG_ROOT_HUB(" POWER"); - } - - if (usb_port_status.port_speed == CVMX_USB_SPEED_HIGH) { - port_status |= USB_PORT_STAT_HIGH_SPEED; - DEBUG_ROOT_HUB(" HIGHSPEED"); - } else if (usb_port_status.port_speed == CVMX_USB_SPEED_LOW) { - port_status |= (1 << USB_PORT_FEAT_LOWSPEED); - DEBUG_ROOT_HUB(" LOWSPEED"); - } - - *((__le32 *)buf) = cpu_to_le32(port_status); - DEBUG_ROOT_HUB("\n"); - break; - case SetHubFeature: - DEBUG_ROOT_HUB("OcteonUSB: SetHubFeature\n"); - /* No HUB features supported */ - break; - case SetPortFeature: - DEBUG_ROOT_HUB("OcteonUSB: SetPortFeature"); - if (wIndex != 1) { - DEBUG_ROOT_HUB(" INVALID\n"); - return -EINVAL; - } - - switch (wValue) { - case USB_PORT_FEAT_SUSPEND: - DEBUG_ROOT_HUB(" SUSPEND\n"); - return -EINVAL; - case USB_PORT_FEAT_POWER: - DEBUG_ROOT_HUB(" POWER\n"); - return -EINVAL; - case USB_PORT_FEAT_RESET: - DEBUG_ROOT_HUB(" RESET\n"); - spin_lock_irqsave(&priv->lock, flags); - cvmx_usb_disable(&priv->usb); - if (cvmx_usb_enable(&priv->usb)) - DEBUG_ERROR("Failed to enable the port\n"); - spin_unlock_irqrestore(&priv->lock, flags); - return 0; - case USB_PORT_FEAT_INDICATOR: - DEBUG_ROOT_HUB(" INDICATOR\n"); - /* Not supported */ - break; - default: - DEBUG_ROOT_HUB(" UNKNOWN\n"); - return -EINVAL; - } - break; - default: - DEBUG_ROOT_HUB("OcteonUSB: Unknown root hub request\n"); - return -EINVAL; - } - return 0; + struct octeon_hcd *priv = hcd_to_octeon(hcd); + cvmx_usb_port_status_t usb_port_status; + int port_status; + struct usb_hub_descriptor *desc; + unsigned long flags; + + switch (typeReq) { + case ClearHubFeature: + DEBUG_ROOT_HUB("OcteonUSB: ClearHubFeature\n"); + switch (wValue) { + case C_HUB_LOCAL_POWER: + case C_HUB_OVER_CURRENT: + /* Nothing required here */ + break; + default: + return -EINVAL; + } + break; + case ClearPortFeature: + DEBUG_ROOT_HUB("OcteonUSB: ClearPortFeature"); + if (wIndex != 1) { + DEBUG_ROOT_HUB(" INVALID\n"); + return -EINVAL; + } + + switch (wValue) { + case USB_PORT_FEAT_ENABLE: + DEBUG_ROOT_HUB(" ENABLE"); + spin_lock_irqsave(&priv->lock, flags); + cvmx_usb_disable(&priv->usb); + spin_unlock_irqrestore(&priv->lock, flags); + break; + case USB_PORT_FEAT_SUSPEND: + DEBUG_ROOT_HUB(" SUSPEND"); + /* Not supported on Octeon */ + break; + case USB_PORT_FEAT_POWER: + DEBUG_ROOT_HUB(" POWER"); + /* Not supported on Octeon */ + break; + case USB_PORT_FEAT_INDICATOR: + DEBUG_ROOT_HUB(" INDICATOR"); + /* Port inidicator not supported */ + break; + case USB_PORT_FEAT_C_CONNECTION: + DEBUG_ROOT_HUB(" C_CONNECTION"); + /* Clears drivers internal connect status change flag */ + spin_lock_irqsave(&priv->lock, flags); + cvmx_usb_set_status(&priv->usb, cvmx_usb_get_status(&priv->usb)); + spin_unlock_irqrestore(&priv->lock, flags); + break; + case USB_PORT_FEAT_C_RESET: + DEBUG_ROOT_HUB(" C_RESET"); + /* Clears the driver's internal Port Reset Change flag */ + spin_lock_irqsave(&priv->lock, flags); + cvmx_usb_set_status(&priv->usb, cvmx_usb_get_status(&priv->usb)); + spin_unlock_irqrestore(&priv->lock, flags); + break; + case USB_PORT_FEAT_C_ENABLE: + DEBUG_ROOT_HUB(" C_ENABLE"); + /* Clears the driver's internal Port Enable/Disable Change flag */ + spin_lock_irqsave(&priv->lock, flags); + cvmx_usb_set_status(&priv->usb, cvmx_usb_get_status(&priv->usb)); + spin_unlock_irqrestore(&priv->lock, flags); + break; + case USB_PORT_FEAT_C_SUSPEND: + DEBUG_ROOT_HUB(" C_SUSPEND"); + /* Clears the driver's internal Port Suspend Change flag, + which is set when resume signaling on the host port is + complete */ + break; + case USB_PORT_FEAT_C_OVER_CURRENT: + DEBUG_ROOT_HUB(" C_OVER_CURRENT"); + /* Clears the driver's overcurrent Change flag */ + spin_lock_irqsave(&priv->lock, flags); + cvmx_usb_set_status(&priv->usb, cvmx_usb_get_status(&priv->usb)); + spin_unlock_irqrestore(&priv->lock, flags); + break; + default: + DEBUG_ROOT_HUB(" UNKNOWN\n"); + return -EINVAL; + } + DEBUG_ROOT_HUB("\n"); + break; + case GetHubDescriptor: + DEBUG_ROOT_HUB("OcteonUSB: GetHubDescriptor\n"); + desc = (struct usb_hub_descriptor *)buf; + desc->bDescLength = 9; + desc->bDescriptorType = 0x29; + desc->bNbrPorts = 1; + desc->wHubCharacteristics = 0x08; + desc->bPwrOn2PwrGood = 1; + desc->bHubContrCurrent = 0; + desc->u.hs.DeviceRemovable[0] = 0; + desc->u.hs.DeviceRemovable[1] = 0xff; + break; + case GetHubStatus: + DEBUG_ROOT_HUB("OcteonUSB: GetHubStatus\n"); + *(__le32 *) buf = 0; + break; + case GetPortStatus: + DEBUG_ROOT_HUB("OcteonUSB: GetPortStatus"); + if (wIndex != 1) { + DEBUG_ROOT_HUB(" INVALID\n"); + return -EINVAL; + } + + spin_lock_irqsave(&priv->lock, flags); + usb_port_status = cvmx_usb_get_status(&priv->usb); + spin_unlock_irqrestore(&priv->lock, flags); + port_status = 0; + + if (usb_port_status.connect_change) { + port_status |= (1 << USB_PORT_FEAT_C_CONNECTION); + DEBUG_ROOT_HUB(" C_CONNECTION"); + } + + if (usb_port_status.port_enabled) { + port_status |= (1 << USB_PORT_FEAT_C_ENABLE); + DEBUG_ROOT_HUB(" C_ENABLE"); + } + + if (usb_port_status.connected) { + port_status |= (1 << USB_PORT_FEAT_CONNECTION); + DEBUG_ROOT_HUB(" CONNECTION"); + } + + if (usb_port_status.port_enabled) { + port_status |= (1 << USB_PORT_FEAT_ENABLE); + DEBUG_ROOT_HUB(" ENABLE"); + } + + if (usb_port_status.port_over_current) { + port_status |= (1 << USB_PORT_FEAT_OVER_CURRENT); + DEBUG_ROOT_HUB(" OVER_CURRENT"); + } + + if (usb_port_status.port_powered) { + port_status |= (1 << USB_PORT_FEAT_POWER); + DEBUG_ROOT_HUB(" POWER"); + } + + if (usb_port_status.port_speed == CVMX_USB_SPEED_HIGH) { + port_status |= USB_PORT_STAT_HIGH_SPEED; + DEBUG_ROOT_HUB(" HIGHSPEED"); + } else if (usb_port_status.port_speed == CVMX_USB_SPEED_LOW) { + port_status |= (1 << USB_PORT_FEAT_LOWSPEED); + DEBUG_ROOT_HUB(" LOWSPEED"); + } + + *((__le32 *) buf) = cpu_to_le32(port_status); + DEBUG_ROOT_HUB("\n"); + break; + case SetHubFeature: + DEBUG_ROOT_HUB("OcteonUSB: SetHubFeature\n"); + /* No HUB features supported */ + break; + case SetPortFeature: + DEBUG_ROOT_HUB("OcteonUSB: SetPortFeature"); + if (wIndex != 1) { + DEBUG_ROOT_HUB(" INVALID\n"); + return -EINVAL; + } + + switch (wValue) { + case USB_PORT_FEAT_SUSPEND: + DEBUG_ROOT_HUB(" SUSPEND\n"); + return -EINVAL; + case USB_PORT_FEAT_POWER: + DEBUG_ROOT_HUB(" POWER\n"); + return -EINVAL; + case USB_PORT_FEAT_RESET: + DEBUG_ROOT_HUB(" RESET\n"); + spin_lock_irqsave(&priv->lock, flags); + cvmx_usb_disable(&priv->usb); + if (cvmx_usb_enable(&priv->usb)) + DEBUG_ERROR("Failed to enable the port\n"); + spin_unlock_irqrestore(&priv->lock, flags); + return 0; + case USB_PORT_FEAT_INDICATOR: + DEBUG_ROOT_HUB(" INDICATOR\n"); + /* Not supported */ + break; + default: + DEBUG_ROOT_HUB(" UNKNOWN\n"); + return -EINVAL; + } + break; + default: + DEBUG_ROOT_HUB("OcteonUSB: Unknown root hub request\n"); + return -EINVAL; + } + return 0; } static const struct hc_driver octeon_hc_driver = { - .description = "Octeon USB", - .product_desc = "Octeon Host Controller", - .hcd_priv_size = sizeof(struct octeon_hcd), - .irq = octeon_usb_irq, - .flags = HCD_MEMORY | HCD_USB2, - .start = octeon_usb_start, - .stop = octeon_usb_stop, - .urb_enqueue = octeon_usb_urb_enqueue, - .urb_dequeue = octeon_usb_urb_dequeue, - .endpoint_disable = octeon_usb_endpoint_disable, - .get_frame_number = octeon_usb_get_frame_number, - .hub_status_data = octeon_usb_hub_status_data, - .hub_control = octeon_usb_hub_control, + .description = "Octeon USB", + .product_desc = "Octeon Host Controller", + .hcd_priv_size = sizeof(struct octeon_hcd), + .irq = octeon_usb_irq, + .flags = HCD_MEMORY | HCD_USB2, + .start = octeon_usb_start, + .stop = octeon_usb_stop, + .urb_enqueue = octeon_usb_urb_enqueue, + .urb_dequeue = octeon_usb_urb_dequeue, + .endpoint_disable = octeon_usb_endpoint_disable, + .get_frame_number = octeon_usb_get_frame_number, + .hub_status_data = octeon_usb_hub_status_data, + .hub_control = octeon_usb_hub_control, }; static int octeon_usb_driver_probe(struct device *dev) { - int status; - int usb_num = to_platform_device(dev)->id; - int irq = platform_get_irq(to_platform_device(dev), 0); - struct octeon_hcd *priv; - struct usb_hcd *hcd; - unsigned long flags; - - DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); - - /* Set the DMA mask to 64bits so we get buffers already translated for - DMA */ - dev->coherent_dma_mask = ~0; - dev->dma_mask = &dev->coherent_dma_mask; - - hcd = usb_create_hcd(&octeon_hc_driver, dev, dev_name(dev)); - if (!hcd) { - DEBUG_FATAL("OcteonUSB: Failed to allocate memory for HCD\n"); - return -1; - } - hcd->uses_new_polling = 1; - priv = (struct octeon_hcd *)hcd->hcd_priv; - - spin_lock_init(&priv->lock); - - tasklet_init(&priv->dequeue_tasklet, octeon_usb_urb_dequeue_work, (unsigned long)priv); - INIT_LIST_HEAD(&priv->dequeue_list); - - //status = cvmx_usb_initialize(&priv->usb, usb_num, CVMX_USB_INITIALIZE_FLAGS_CLOCK_AUTO | CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO | CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS | CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLBACKS); - status = cvmx_usb_initialize(&priv->usb, usb_num, CVMX_USB_INITIALIZE_FLAGS_CLOCK_AUTO); - if (status) { - DEBUG_FATAL("OcteonUSB: USB initialization failed with %d\n", status); - kfree(hcd); - return -1; - } - - /* This delay is needed for CN3010, but I don't know why... */ - mdelay(10); - - spin_lock_irqsave(&priv->lock, flags); - cvmx_usb_poll(&priv->usb); - spin_unlock_irqrestore(&priv->lock, flags); - - status = usb_add_hcd(hcd, irq, IRQF_SHARED); - if (status) { - DEBUG_FATAL("OcteonUSB: USB add HCD failed with %d\n", status); - kfree(hcd); - return -1; - } - - printk("OcteonUSB: Registered HCD for port %d on irq %d\n", usb_num, irq); - - return 0; + int status; + int usb_num = to_platform_device(dev)->id; + int irq = platform_get_irq(to_platform_device(dev), 0); + struct octeon_hcd *priv; + struct usb_hcd *hcd; + unsigned long flags; + + DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); + + /* Set the DMA mask to 64bits so we get buffers already translated for + DMA */ + dev->coherent_dma_mask = ~0; + dev->dma_mask = &dev->coherent_dma_mask; + + hcd = usb_create_hcd(&octeon_hc_driver, dev, dev_name(dev)); + if (!hcd) { + DEBUG_FATAL("OcteonUSB: Failed to allocate memory for HCD\n"); + return -1; + } + hcd->uses_new_polling = 1; + priv = (struct octeon_hcd *)hcd->hcd_priv; + + spin_lock_init(&priv->lock); + + tasklet_init(&priv->dequeue_tasklet, octeon_usb_urb_dequeue_work, (unsigned long)priv); + INIT_LIST_HEAD(&priv->dequeue_list); + + //status = cvmx_usb_initialize(&priv->usb, usb_num, CVMX_USB_INITIALIZE_FLAGS_CLOCK_AUTO | CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO | CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS | CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLBACKS); + status = cvmx_usb_initialize(&priv->usb, usb_num, CVMX_USB_INITIALIZE_FLAGS_CLOCK_AUTO); + if (status) { + DEBUG_FATAL("OcteonUSB: USB initialization failed with %d\n", status); + kfree(hcd); + return -1; + } + + /* This delay is needed for CN3010, but I don't know why... */ + mdelay(10); + + spin_lock_irqsave(&priv->lock, flags); + cvmx_usb_poll(&priv->usb); + spin_unlock_irqrestore(&priv->lock, flags); + + status = usb_add_hcd(hcd, irq, IRQF_SHARED); + if (status) { + DEBUG_FATAL("OcteonUSB: USB add HCD failed with %d\n", status); + kfree(hcd); + return -1; + } + + printk("OcteonUSB: Registered HCD for port %d on irq %d\n", usb_num, irq); + + return 0; } static int octeon_usb_driver_remove(struct device *dev) { - int status; - struct usb_hcd *hcd = dev_get_drvdata(dev); - struct octeon_hcd *priv = hcd_to_octeon(hcd); - unsigned long flags; + int status; + struct usb_hcd *hcd = dev_get_drvdata(dev); + struct octeon_hcd *priv = hcd_to_octeon(hcd); + unsigned long flags; - DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); + DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); - usb_remove_hcd(hcd); - tasklet_kill(&priv->dequeue_tasklet); - spin_lock_irqsave(&priv->lock, flags); - status = cvmx_usb_shutdown(&priv->usb); - spin_unlock_irqrestore(&priv->lock, flags); - if (status) - DEBUG_FATAL("OcteonUSB: USB shutdown failed with %d\n", status); + usb_remove_hcd(hcd); + tasklet_kill(&priv->dequeue_tasklet); + spin_lock_irqsave(&priv->lock, flags); + status = cvmx_usb_shutdown(&priv->usb); + spin_unlock_irqrestore(&priv->lock, flags); + if (status) + DEBUG_FATAL("OcteonUSB: USB shutdown failed with %d\n", status); - kfree(hcd); + kfree(hcd); - return 0; + return 0; } static struct device_driver octeon_usb_driver = { - .name = "OcteonUSB", - .bus = &platform_bus_type, - .probe = octeon_usb_driver_probe, - .remove = octeon_usb_driver_remove, + .name = "OcteonUSB", + .bus = &platform_bus_type, + .probe = octeon_usb_driver_probe, + .remove = octeon_usb_driver_remove, }; @@ -741,18 +741,18 @@ struct platform_device *pdev_glob[MAX_USB_PORTS]; static int octeon_usb_registered; static int __init octeon_usb_module_init(void) { - int num_devices = cvmx_usb_get_num_ports(); - int device; + int num_devices = cvmx_usb_get_num_ports(); + int device; - if (usb_disabled() || num_devices == 0) - return -ENODEV; + if (usb_disabled() || num_devices == 0) + return -ENODEV; - if (driver_register(&octeon_usb_driver)) { - DEBUG_FATAL("OcteonUSB: Failed to register driver\n"); - return -ENOMEM; - } - octeon_usb_registered = 1; - printk("OcteonUSB: Detected %d ports\n", num_devices); + if (driver_register(&octeon_usb_driver)) { + DEBUG_FATAL("OcteonUSB: Failed to register driver\n"); + return -ENOMEM; + } + octeon_usb_registered = 1; + printk("OcteonUSB: Detected %d ports\n", num_devices); /* * Only cn52XX and cn56XX have DWC_OTG USB hardware and the @@ -774,36 +774,36 @@ static int __init octeon_usb_module_init(void) cvmx_write_csr(CVMX_IOB_N2C_L2C_PRI_CNT, pri_cnt.u64); } - for (device = 0; device < num_devices; device++) { - struct resource irq_resource; - struct platform_device *pdev; - memset(&irq_resource, 0, sizeof(irq_resource)); - irq_resource.start = (device==0) ? OCTEON_IRQ_USB0 : OCTEON_IRQ_USB1; - irq_resource.end = irq_resource.start; - irq_resource.flags = IORESOURCE_IRQ; - pdev = platform_device_register_simple((char*)octeon_usb_driver.name, device, &irq_resource, 1); - if (IS_ERR(pdev)) { - DEBUG_FATAL("OcteonUSB: Failed to allocate platform device for USB%d\n", device); - driver_unregister(&octeon_usb_driver); - octeon_usb_registered = 0; - return PTR_ERR(pdev); - } - if (device < MAX_USB_PORTS) - pdev_glob[device] = pdev; - - } - return 0; + for (device = 0; device < num_devices; device++) { + struct resource irq_resource; + struct platform_device *pdev; + memset(&irq_resource, 0, sizeof(irq_resource)); + irq_resource.start = (device == 0) ? OCTEON_IRQ_USB0 : OCTEON_IRQ_USB1; + irq_resource.end = irq_resource.start; + irq_resource.flags = IORESOURCE_IRQ; + pdev = platform_device_register_simple((char *)octeon_usb_driver. name, device, &irq_resource, 1); + if (IS_ERR(pdev)) { + DEBUG_FATAL("OcteonUSB: Failed to allocate platform device for USB%d\n", device); + driver_unregister(&octeon_usb_driver); + octeon_usb_registered = 0; + return PTR_ERR(pdev); + } + if (device < MAX_USB_PORTS) + pdev_glob[device] = pdev; + + } + return 0; } static void __exit octeon_usb_module_cleanup(void) { - int i; - DEBUG_CALL("OcteonUSB: %s called\n", __FUNCTION__); - for (i = 0; i