usb: ehci: fully align interrupt QHs/QTDs

[karo-tx-uboot.git] / drivers / usb / host / ehci-hcd.c

diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 706cf0cb7dba246c2c567b5da4111590bb9679b9..6017090ebeec93092953cc53266cd6de4a745dc7 100644 (file)
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -36,16 +36,13 @@
 #define CONFIG_USB_MAX_CONTROLLER_COUNT 1
 #endif
 
-static struct ehci_ctrl {
-       struct ehci_hccr *hccr; /* R/O registers, not need for volatile */
-       struct ehci_hcor *hcor;
-       int rootdev;
-       uint16_t portreset;
-       struct QH qh_list __aligned(USB_DMA_MINALIGN);
-       struct QH periodic_queue __aligned(USB_DMA_MINALIGN);
-       uint32_t *periodic_list;
-       int ntds;
-} ehcic[CONFIG_USB_MAX_CONTROLLER_COUNT];
+/*
+ * EHCI spec page 20 says that the HC may take up to 16 uFrames (= 4ms) to halt.
+ * Let's time out after 8 to have a little safety margin on top of that.
+ */
+#define HCHALT_TIMEOUT (8 * 1000)
+
+static struct ehci_ctrl ehcic[CONFIG_USB_MAX_CONTROLLER_COUNT];
 
 #define ALIGN_END_ADDR(type, ptr, size)                        \
        ((uint32_t)(ptr) + roundup((size) * sizeof(type), USB_DMA_MINALIGN))
@@ -199,6 +196,39 @@ out:
        return ret;
 }
 
+static int ehci_shutdown(struct ehci_ctrl *ctrl)
+{
+       int i, ret = 0;
+       uint32_t cmd, reg;
+
+       if (!ctrl || !ctrl->hcor)
+               return -EINVAL;
+
+       cmd = ehci_readl(&ctrl->hcor->or_usbcmd);
+       cmd &= ~(CMD_PSE | CMD_ASE);
+       ehci_writel(&ctrl->hcor->or_usbcmd, cmd);
+       ret = handshake(&ctrl->hcor->or_usbsts, STS_ASS | STS_PSS, 0,
+               100 * 1000);
+
+       if (!ret) {
+               for (i = 0; i < CONFIG_SYS_USB_EHCI_MAX_ROOT_PORTS; i++) {
+                       reg = ehci_readl(&ctrl->hcor->or_portsc[i]);
+                       reg |= EHCI_PS_SUSP;
+                       ehci_writel(&ctrl->hcor->or_portsc[i], reg);
+               }
+
+               cmd &= ~CMD_RUN;
+               ehci_writel(&ctrl->hcor->or_usbcmd, cmd);
+               ret = handshake(&ctrl->hcor->or_usbsts, STS_HALT, STS_HALT,
+                       HCHALT_TIMEOUT);
+       }
+
+       if (ret)
+               puts("EHCI failed to shut down host controller.\n");
+
+       return ret;
+}
+
 static int ehci_td_buffer(struct qTD *td, void *buf, size_t sz)
 {
        uint32_t delta, next;
@@ -365,6 +395,7 @@ ehci_submit_async(struct usb_device *dev, unsigned long pipe, void *buffer,
                QH_ENDPT2_UFCMASK(0) | QH_ENDPT2_UFSMASK(0);
        qh->qh_endpt2 = cpu_to_hc32(endpt);
        qh->qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
+       qh->qh_overlay.qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
 
        tdp = &qh->qh_overlay.qt_next;
 
@@ -817,6 +848,7 @@ ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *buffer,
                        }
                        break;
                case USB_PORT_FEAT_TEST:
+                       ehci_shutdown(ctrl);
                        reg &= ~(0xf << 16);
                        reg |= ((le16_to_cpu(req->index) >> 8) & 0xf) << 16;
                        ehci_writel(status_reg, reg);
@@ -887,31 +919,37 @@ unknown:
 
 int usb_lowlevel_stop(int index)
 {
+       ehci_shutdown(&ehcic[index]);
        return ehci_hcd_stop(index);
 }
 
-int usb_lowlevel_init(int index, void **controller)
+int usb_lowlevel_init(int index, enum usb_init_type init, void **controller)
 {
        uint32_t reg;
        uint32_t cmd;
        struct QH *qh_list;
        struct QH *periodic;
        int i;
+       int rc;
 
-       if (ehci_hcd_init(index, &ehcic[index].hccr, &ehcic[index].hcor))
-               return -1;
+       rc = ehci_hcd_init(index, init, &ehcic[index].hccr, &ehcic[index].hcor);
+       if (rc)
+               return rc;
+       if (init == USB_INIT_DEVICE)
+               goto done;
 
        /* EHCI spec section 4.1 */
        if (ehci_reset(index))
                return -1;
 
 #if defined(CONFIG_EHCI_HCD_INIT_AFTER_RESET)
-       if (ehci_hcd_init(index, &ehcic[index].hccr, &ehcic[index].hcor))
-               return -1;
+       rc = ehci_hcd_init(index, init, &ehcic[index].hccr, &ehcic[index].hcor);
+       if (rc)
+               return rc;
 #endif
        /* Set the high address word (aka segment) for 64-bit controller */
        if (ehci_readl(&ehcic[index].hccr->cr_hccparams) & 1)
-               ehci_writel(ehcic[index].hcor->or_ctrldssegment, 0);
+               ehci_writel(&ehcic[index].hcor->or_ctrldssegment, 0);
 
        qh_list = &ehcic[index].qh_list;
 
@@ -954,7 +992,9 @@ int usb_lowlevel_init(int index, void **controller)
         *         Split Transactions will be spread across microframes using
         *         S-mask and C-mask.
         */
-       ehcic[index].periodic_list = memalign(4096, 1024*4);
+       if (ehcic[index].periodic_list == NULL)
+               ehcic[index].periodic_list = memalign(4096, 1024 * 4);
+
        if (!ehcic[index].periodic_list)
                return -ENOMEM;
        for (i = 0; i < 1024; i++) {
@@ -1006,7 +1046,7 @@ int usb_lowlevel_init(int index, void **controller)
        printf("USB EHCI %x.%02x\n", reg >> 8, reg & 0xff);
 
        ehcic[index].rootdev = 0;
-
+done:
        *controller = &ehcic[index];
        return 0;
 }
@@ -1122,14 +1162,16 @@ create_int_queue(struct usb_device *dev, unsigned long pipe, int queuesize,
                debug("ehci intr queue: out of memory\n");
                goto fail1;
        }
-       result->first = memalign(32, sizeof(struct QH) * queuesize);
+       result->first = memalign(USB_DMA_MINALIGN,
+                                sizeof(struct QH) * queuesize);
        if (!result->first) {
                debug("ehci intr queue: out of memory\n");
                goto fail2;
        }
        result->current = result->first;
        result->last = result->first + queuesize - 1;
-       result->tds = memalign(32, sizeof(struct qTD) * queuesize);
+       result->tds = memalign(USB_DMA_MINALIGN,
+                              sizeof(struct qTD) * queuesize);
        if (!result->tds) {
                debug("ehci intr queue: out of memory\n");
                goto fail3;
@@ -1147,6 +1189,7 @@ create_int_queue(struct usb_device *dev, unsigned long pipe, int queuesize,
                        qh->qh_link = QH_LINK_TERMINATE;
 
                qh->qh_overlay.qt_next = (uint32_t)td;
+               qh->qh_overlay.qt_altnext = QT_NEXT_TERMINATE;
                qh->qh_endpt1 = (0 << 28) | /* No NAK reload (ehci 4.9) */
                        (usb_maxpacket(dev, pipe) << 16) | /* MPS */
                        (1 << 14) |