[adm5120] minor usb driver cleanup
[openwrt/svn-archive/archive.git] / target / linux / adm5120-2.6 / files / drivers / usb / host / adm5120-hcd.c
index 875dc6c..03e401a 100644 (file)
@@ -89,7 +89,6 @@ MODULE_AUTHOR("Jeroen Vreeken (pe1rxq@amsat.org)");
 #define ADMHCD_REG_PORTSTATUS1         0x7c
 #define ADMHCD_REG_HOSTHEAD            0x80
 
-
 #define ADMHCD_NUMPORTS                2
 
 struct admhcd_ed {
@@ -136,9 +135,9 @@ struct admhcd_td {
 
 static int admhcd_td_err[16] = {
        0,              /* No */
-       -EREMOTEIO,             /* CRC */
+       -EREMOTEIO,     /* CRC */
        -EREMOTEIO,     /* bit stuff */
-       -EREMOTEIO,             /* data toggle */
+       -EREMOTEIO,     /* data toggle */
        -EPIPE,         /* stall */
        -ETIMEDOUT,     /* timeout */
        -EPROTO,        /* pid err */
@@ -203,14 +202,14 @@ static void admhcd_lock(struct admhcd *ahcd)
 {
        spin_lock_irqsave(&ahcd->lock, ahcd->flags);
        ahcd->dma_en = admhcd_reg_get(ahcd, ADMHCD_REG_HOSTCONTROL) &
-           ADMHCD_DMA_EN;
+               ADMHCD_DMA_EN;
        admhcd_reg_set(ahcd, ADMHCD_REG_HOSTCONTROL, ADMHCD_STATE_OP);
 }
 
 static void admhcd_unlock(struct admhcd *ahcd)
 {
        admhcd_reg_set(ahcd, ADMHCD_REG_HOSTCONTROL,
-           ADMHCD_STATE_OP | ahcd->dma_en);
+               ADMHCD_STATE_OP | ahcd->dma_en);
        spin_unlock_irqrestore(&ahcd->lock, ahcd->flags);
 }
 
@@ -218,12 +217,12 @@ static struct admhcd_td *admhcd_td_alloc(struct admhcd_ed *ed, struct urb *urb)
 {
        struct admhcd_td *tdn, *td;
 
-       tdn = kmalloc(sizeof(struct admhcd_td), GFP_ATOMIC);
+       tdn = kzalloc(sizeof(*tdn), GFP_ATOMIC);
        if (!tdn)
                return NULL;
+
        tdn->real = tdn;
        tdn = (struct admhcd_td *)KSEG1ADDR(tdn);
-       memset(tdn, 0, sizeof(struct admhcd_td));
        if (ed->cur == NULL) {
                ed->cur = tdn;
                ed->head = tdn;
@@ -265,7 +264,7 @@ static void admhcd_td_free(struct admhcd_ed *ed, struct urb *urb)
    in the DMA chain
  */
 static struct admhcd_ed *admhcd_get_ed(struct admhcd *ahcd,
-    struct usb_host_endpoint *ep, struct urb *urb)
+               struct usb_host_endpoint *ep, struct urb *urb)
 {
        struct admhcd_ed *hosthead;
        struct admhcd_ed *found = NULL, *ed = NULL;
@@ -284,10 +283,9 @@ static struct admhcd_ed *admhcd_get_ed(struct admhcd *ahcd,
                }
        }
        if (!found) {
-               found = kmalloc(sizeof(struct admhcd_ed), GFP_ATOMIC);
+               found = kzalloc(sizeof(*found), GFP_ATOMIC);
                if (!found)
                        goto out;
-               memset(found, 0, sizeof(struct admhcd_ed));
                found->real = found;
                found->ep = ep;
                found = (struct admhcd_ed *)KSEG1ADDR(found);
@@ -313,7 +311,7 @@ out:
 }
 
 static struct admhcd_td *admhcd_td_fill(u32 control, struct admhcd_td *td,
-    dma_addr_t data, int len)
+               dma_addr_t data, int len)
 {
        td->buffer = data;
        td->buflen = len;
@@ -342,7 +340,7 @@ static void admhcd_ed_start(struct admhcd *ahcd, struct admhcd_ed *ed)
        ahcd->dma_en |= ADMHCD_DMA_EN;
 }
 
-static irqreturn_t adm5120hcd_irq(struct usb_hcd *hcd)
+static irqreturn_t admhcd_irq(struct usb_hcd *hcd)
 {
        struct admhcd *ahcd = hcd_to_admhcd(hcd);
        u32 intstatus;
@@ -350,12 +348,14 @@ static irqreturn_t adm5120hcd_irq(struct usb_hcd *hcd)
        intstatus = admhcd_reg_get(ahcd, ADMHCD_REG_INTSTATUS);
        if (intstatus & ADMHCD_INT_FATAL) {
                admhcd_reg_set(ahcd, ADMHCD_REG_INTSTATUS, ADMHCD_INT_FATAL);
-               //
+               /* FIXME: handle fatal interrupts */
        }
+
        if (intstatus & ADMHCD_INT_SW) {
                admhcd_reg_set(ahcd, ADMHCD_REG_INTSTATUS, ADMHCD_INT_SW);
-               //
+               /* FIXME: handle software interrupts */
        }
+
        if (intstatus & ADMHCD_INT_TD) {
                struct admhcd_ed *ed, *head;
 
@@ -389,7 +389,7 @@ static irqreturn_t adm5120hcd_irq(struct usb_hcd *hcd)
 }
 
 static int admhcd_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *ep,
-    struct urb *urb, gfp_t mem_flags)
+               struct urb *urb, gfp_t mem_flags)
 {
        struct admhcd *ahcd = hcd_to_admhcd(hcd);
        struct admhcd_ed *ed;
@@ -404,26 +404,26 @@ static int admhcd_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *ep,
                return -ENOMEM;
 
        switch(usb_pipetype(pipe)) {
-               case PIPE_CONTROL:
-                       size = 2;
-               case PIPE_INTERRUPT:
-               case PIPE_BULK:
-               default:
-                       size += urb->transfer_buffer_length / 4096;
-                       if (urb->transfer_buffer_length % 4096)
-                               size++;
-                       if (size == 0)
-                               size++;
-                       else if (urb->transfer_flags & URB_ZERO_PACKET &&
-                           !(urb->transfer_buffer_length %
-                             usb_maxpacket(urb->dev, pipe, usb_pipeout(pipe)))) {
-                               size++;
-                               zero = 1;
-                       }
-                       break;
-               case PIPE_ISOCHRONOUS:
-                       size = urb->number_of_packets;
-                       break;
+       case PIPE_CONTROL:
+               size = 2;
+       case PIPE_INTERRUPT:
+       case PIPE_BULK:
+       default:
+               size += urb->transfer_buffer_length / 4096;
+               if (urb->transfer_buffer_length % 4096)
+                       size++;
+               if (size == 0)
+                       size++;
+               else if (urb->transfer_flags & URB_ZERO_PACKET &&
+                   !(urb->transfer_buffer_length %
+                     usb_maxpacket(urb->dev, pipe, usb_pipeout(pipe)))) {
+                       size++;
+                       zero = 1;
+               }
+               break;
+       case PIPE_ISOCHRONOUS:
+               size = urb->number_of_packets;
+               break;
        }
 
        admhcd_lock(ahcd);
@@ -451,52 +451,52 @@ static int admhcd_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *ep,
        }
 
        switch(usb_pipetype(pipe)) {
-               case PIPE_CONTROL:
-                       td = admhcd_td_fill(ADMHCD_TD_SETUP | ADMHCD_TD_DATA0,
-                           td, (dma_addr_t)urb->setup_packet, 8);
-                       while (data_len > 0) {
-                               td = admhcd_td_fill(ADMHCD_TD_DATA1
-                                   | ADMHCD_TD_R |
-                                   (usb_pipeout(pipe) ?
-                                   ADMHCD_TD_OUT : ADMHCD_TD_IN), td,
-                                   data, data_len % 4097);
-                               data_len -= 4096;
-                       }
-                       admhcd_td_fill(ADMHCD_TD_DATA1 | (usb_pipeout(pipe) ?
-                           ADMHCD_TD_IN : ADMHCD_TD_OUT), td,
-                           data, 0);
-                       break;
-               case PIPE_INTERRUPT:
-               case PIPE_BULK:
-                       //info ok for interrupt?
-                       i = 0;
-                       while(data_len > 4096) {
-                               td = admhcd_td_fill((usb_pipeout(pipe) ?
-                                   ADMHCD_TD_OUT :
-                                   ADMHCD_TD_IN | ADMHCD_TD_R) |
-                                   (i ? ADMHCD_TD_TOGGLE : toggle), td,
-                                   data, 4096);
-                               data += 4096;
-                               data_len -= 4096;
-                               i++;
-                       }
+       case PIPE_CONTROL:
+               td = admhcd_td_fill(ADMHCD_TD_SETUP | ADMHCD_TD_DATA0,
+                   td, (dma_addr_t)urb->setup_packet, 8);
+               while (data_len > 0) {
+                       td = admhcd_td_fill(ADMHCD_TD_DATA1
+                           | ADMHCD_TD_R |
+                           (usb_pipeout(pipe) ?
+                           ADMHCD_TD_OUT : ADMHCD_TD_IN), td,
+                           data, data_len % 4097);
+                       data_len -= 4096;
+               }
+               admhcd_td_fill(ADMHCD_TD_DATA1 | (usb_pipeout(pipe) ?
+                   ADMHCD_TD_IN : ADMHCD_TD_OUT), td,
+                   data, 0);
+               break;
+       case PIPE_INTERRUPT:
+       case PIPE_BULK:
+               //info ok for interrupt?
+               i = 0;
+               while(data_len > 4096) {
                        td = admhcd_td_fill((usb_pipeout(pipe) ?
-                           ADMHCD_TD_OUT : ADMHCD_TD_IN) |
-                           (i ? ADMHCD_TD_TOGGLE : toggle), td, data, data_len);
+                           ADMHCD_TD_OUT :
+                           ADMHCD_TD_IN | ADMHCD_TD_R) |
+                           (i ? ADMHCD_TD_TOGGLE : toggle), td,
+                           data, 4096);
+                       data += 4096;
+                       data_len -= 4096;
                        i++;
-                       if (zero)
-                               admhcd_td_fill((usb_pipeout(pipe) ?
-                                   ADMHCD_TD_OUT : ADMHCD_TD_IN) |
-                                   (i ? ADMHCD_TD_TOGGLE : toggle), td, 0, 0);
-                       break;
-               case PIPE_ISOCHRONOUS:
-                       for (i = 0; i < urb->number_of_packets; i++) {
-                               td = admhcd_td_fill(ADMHCD_TD_ISO |
-                                   ((urb->start_frame + i) & 0xffff), td,
-                                   data + urb->iso_frame_desc[i].offset,
-                                   urb->iso_frame_desc[i].length);
-                       }
-                       break;
+               }
+               td = admhcd_td_fill((usb_pipeout(pipe) ?
+                   ADMHCD_TD_OUT : ADMHCD_TD_IN) |
+                   (i ? ADMHCD_TD_TOGGLE : toggle), td, data, data_len);
+               i++;
+               if (zero)
+                       admhcd_td_fill((usb_pipeout(pipe) ?
+                           ADMHCD_TD_OUT : ADMHCD_TD_IN) |
+                           (i ? ADMHCD_TD_TOGGLE : toggle), td, 0, 0);
+               break;
+       case PIPE_ISOCHRONOUS:
+               for (i = 0; i < urb->number_of_packets; i++) {
+                       td = admhcd_td_fill(ADMHCD_TD_ISO |
+                           ((urb->start_frame + i) & 0xffff), td,
+                           data + urb->iso_frame_desc[i].offset,
+                           urb->iso_frame_desc[i].length);
+               }
+               break;
        }
        urb->hcpriv = ed;
        admhcd_ed_start(ahcd, ed);
@@ -551,6 +551,7 @@ static void admhcd_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoin
        }
        for (edt = head; edt->next != ed; edt = edt->next);
        edt->next = ed->next;
+
 out_free:
        kfree(ed->real);
 out:
@@ -591,7 +592,7 @@ static __u8 root_hub_hub_des[] = {
 };
 
 static int admhcd_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
-    u16 wIndex, char *buf, u16 wLength)
+               u16 wIndex, char *buf, u16 wLength)
 {
        struct admhcd *ahcd = hcd_to_admhcd(hcd);
        int retval = 0, len;
@@ -707,45 +708,45 @@ static int admhcd_start(struct usb_hcd *hcd)
 
        spin_lock_irqsave(&ahcd->lock, flags);
 
-       /* Initialise the HCD registers */
-        admhcd_reg_set(ahcd, ADMHCD_REG_INTENABLE, 0);
-        mdelay(10);
+       /* Initialise the HCD registers */
+       admhcd_reg_set(ahcd, ADMHCD_REG_INTENABLE, 0);
+       mdelay(10);
 
-        admhcd_reg_set(ahcd, ADMHCD_REG_CONTROL, ADMHCD_SW_RESET);
+       admhcd_reg_set(ahcd, ADMHCD_REG_CONTROL, ADMHCD_SW_RESET);
 
-        while (admhcd_reg_get(ahcd, ADMHCD_REG_CONTROL) & ADMHCD_SW_RESET) {
+       while (admhcd_reg_get(ahcd, ADMHCD_REG_CONTROL) & ADMHCD_SW_RESET) {
                printk(KERN_WARNING PFX "waiting for reset to complete\n");
-                mdelay(1);
+               mdelay(1);
        }
 
        hcd->uses_new_polling = 1;
 
        /* Enable USB host mode */
-        admhcd_reg_set(ahcd, ADMHCD_REG_CONTROL, ADMHCD_HOST_EN);
+       admhcd_reg_set(ahcd, ADMHCD_REG_CONTROL, ADMHCD_HOST_EN);
 
        /* Set host specific settings */
-        admhcd_reg_set(ahcd, ADMHCD_REG_HOSTHEAD, 0x00000000);
-        admhcd_reg_set(ahcd, ADMHCD_REG_FMINTERVAL, 0x20002edf);
-        admhcd_reg_set(ahcd, ADMHCD_REG_LSTHRESH, 0x628);
+       admhcd_reg_set(ahcd, ADMHCD_REG_HOSTHEAD, 0x00000000);
+       admhcd_reg_set(ahcd, ADMHCD_REG_FMINTERVAL, 0x20002edf);
+       admhcd_reg_set(ahcd, ADMHCD_REG_LSTHRESH, 0x628);
 
        /* Set interrupts */
-        admhcd_reg_set(ahcd, ADMHCD_REG_INTENABLE,
-            ADMHCD_INT_ACT | ADMHCD_INT_FATAL | ADMHCD_INT_SW | ADMHCD_INT_TD);
-        admhcd_reg_set(ahcd, ADMHCD_REG_INTSTATUS,
-            ADMHCD_INT_ACT | ADMHCD_INT_FATAL | ADMHCD_INT_SW | ADMHCD_INT_TD);
+       admhcd_reg_set(ahcd, ADMHCD_REG_INTENABLE, ADMHCD_INT_ACT |
+               ADMHCD_INT_FATAL | ADMHCD_INT_SW | ADMHCD_INT_TD);
+       admhcd_reg_set(ahcd, ADMHCD_REG_INTSTATUS, ADMHCD_INT_ACT |
+               ADMHCD_INT_FATAL | ADMHCD_INT_SW | ADMHCD_INT_TD);
 
        /* Power on all ports */
-        admhcd_reg_set(ahcd, ADMHCD_REG_RHDESCR, ADMHCD_NPS | ADMHCD_LPSC);
+       admhcd_reg_set(ahcd, ADMHCD_REG_RHDESCR, ADMHCD_NPS | ADMHCD_LPSC);
 
        /* HCD is now operationnal */
-        admhcd_reg_set(ahcd, ADMHCD_REG_HOSTCONTROL, ADMHCD_STATE_OP);
+       admhcd_reg_set(ahcd, ADMHCD_REG_HOSTCONTROL, ADMHCD_STATE_OP);
 
-               hcd->state = HC_STATE_RUNNING;
+       hcd->state = HC_STATE_RUNNING;
 
        spin_unlock_irqrestore(&ahcd->lock, flags);
 
        printk(KERN_DEBUG PFX "returning 0 from admhcd_start\n");
-               return 0;
+       return 0;
 }
 
 static int admhcd_sw_reset(struct admhcd *ahcd)
@@ -757,11 +758,11 @@ static int admhcd_sw_reset(struct admhcd *ahcd)
        spin_lock_irqsave(&ahcd->lock, flags);
 
        admhcd_reg_set(ahcd, ADMHCD_REG_INTENABLE, 0);
-        mdelay(10);
+       mdelay(10);
 
-        admhcd_reg_set(ahcd, ADMHCD_REG_CONTROL, ADMHCD_SW_RESET);
+       admhcd_reg_set(ahcd, ADMHCD_REG_CONTROL, ADMHCD_SW_RESET);
 
-        while (--retries) {
+       while (--retries) {
                mdelay(1);
                if (!(admhcd_reg_get(ahcd, ADMHCD_REG_CONTROL) & ADMHCD_SW_RESET))
                        break;
@@ -777,7 +778,7 @@ static int admhcd_sw_reset(struct admhcd *ahcd)
 static int admhcd_reset(struct usb_hcd *hcd)
 {
        struct admhcd *ahcd = hcd_to_admhcd(hcd);
-        u32 state = 0;
+       u32 state = 0;
        int ret, timeout = 15; /* ms */
        unsigned long t;
 
@@ -787,32 +788,32 @@ static int admhcd_reset(struct usb_hcd *hcd)
 
        t = jiffies + msecs_to_jiffies(timeout);
        do {
-                spin_lock_irq(&ahcd->lock);
-                state = admhcd_reg_get(ahcd, ADMHCD_REG_HOSTCONTROL);
-                spin_unlock_irq(&ahcd->lock);
+               spin_lock_irq(&ahcd->lock);
+               state = admhcd_reg_get(ahcd, ADMHCD_REG_HOSTCONTROL);
+               spin_unlock_irq(&ahcd->lock);
                state &= ADMHCD_STATE_MASK;
-                if (state == ADMHCD_STATE_RST)
-                        break;
-                msleep(4);
+               if (state == ADMHCD_STATE_RST)
+                       break;
+               msleep(4);
        } while (time_before_eq(jiffies, t));
 
-        if (state != ADMHCD_STATE_RST) {
-                printk(KERN_WARNING "%s: device not ready after %dms\n",
+       if (state != ADMHCD_STATE_RST) {
+               printk(KERN_WARNING "%s: device not ready after %dms\n",
                        hcd_name, timeout);
-                ret = -ENODEV;
-        }
+               ret = -ENODEV;
+       }
 
-        return ret;
+       return ret;
 }
 
 static void admhcd_stop(struct usb_hcd *hcd)
 {
        struct admhcd *ahcd = hcd_to_admhcd(hcd);
-        unsigned long flags;
+       unsigned long flags;
        u32 val;
 
-        spin_lock_irqsave(&ahcd->lock, flags);
-        admhcd_reg_set(ahcd, ADMHCD_REG_INTENABLE, 0);
+       spin_lock_irqsave(&ahcd->lock, flags);
+       admhcd_reg_set(ahcd, ADMHCD_REG_INTENABLE, 0);
 
        /* Set global control of power for ports */
        val = admhcd_reg_get(ahcd, ADMHCD_REG_RHDESCR);
@@ -830,7 +831,7 @@ static struct hc_driver adm5120_hc_driver = {
        .description =          hcd_name,
        .product_desc =         "ADM5120 HCD",
        .hcd_priv_size =        sizeof(struct admhcd),
-       .irq =                  adm5120hcd_irq,
+       .irq =                  admhcd_irq,
        .flags =                HCD_USB11,
        .urb_enqueue =          admhcd_urb_enqueue,
        .urb_dequeue =          admhcd_urb_dequeue,
@@ -847,51 +848,51 @@ static struct hc_driver adm5120_hc_driver = {
 
 static int __init adm5120hcd_probe(struct platform_device *pdev)
 {
-        struct usb_hcd *hcd;
-        struct admhcd *ahcd;
+       struct usb_hcd *hcd;
+       struct admhcd *ahcd;
        struct resource *data;
        void __iomem *data_reg;
 
-        int err = 0, irq;
+       int err = 0, irq;
 
        if (pdev->num_resources < 2) {
                printk(KERN_WARNING PFX "not enough resources\n");
                err = -ENODEV;
                goto out;
-        }
+       }
 
        irq = platform_get_irq(pdev, 0);
        data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
        if (pdev->dev.dma_mask) {
-                printk(KERN_DEBUG PFX "no we won't dma\n");
-                return -EINVAL;
-        }
+               printk(KERN_DEBUG PFX "no we won't dma\n");
+               return -EINVAL;
+       }
 
        if (!data || irq < 0) {
                printk(KERN_DEBUG PFX "either IRQ or data resource is invalid\n");
-                err = -ENODEV;
-                goto out;
-        }
+               err = -ENODEV;
+               goto out;
+       }
 
-        if (!request_mem_region(data->start, resource_len(data), hcd_name)) {
+       if (!request_mem_region(data->start, resource_len(data), hcd_name)) {
                printk(KERN_DEBUG PFX "cannot request memory regions for the data resource\n");
-                err = -EBUSY;
-                goto out;
-        }
+               err = -EBUSY;
+               goto out;
+       }
 
-        data_reg = ioremap(data->start, resource_len(data));
-        if (data_reg == NULL) {
+       data_reg = ioremap(data->start, resource_len(data));
+       if (data_reg == NULL) {
                printk(KERN_DEBUG PFX "unable to ioremap\n");
-                err = -ENOMEM;
-                goto out_mem;
+               err = -ENOMEM;
+               goto out_mem;
         }
 
        hcd = usb_create_hcd(&adm5120_hc_driver, &pdev->dev, pdev->dev.bus_id);
-        if (!hcd) {
+       if (!hcd) {
                printk(KERN_DEBUG PFX "unable to create the hcd\n");
                err = -ENOMEM;
-                goto out_unmap;
+               goto out_unmap;
        }
 
        hcd->rsrc_start = data->start;