From: Tom Rini <tr...@ti.com>

The USB spec says that 32 bytes is the minimum required alignment.
However on some platforms we have a larger minimum requirement for cache
coherency.  In those cases, use that value rather than the USB spec
minimum.  We add a cpp check to <usb.h> to define USB_DMA_MINALIGN and
make use of it in ehci-hcd.c and musb_core.h.  We cannot use MAX() here
as we are not allowed to have tests inside of align(...).

Signed-off-by: Tom Rini <tr...@ti.com>
[ilya.yanok]: fix size alignment, drop (incorrect) rounding
when invalidating the buffer. If we got unaligned buffer from the
upper layer -- that's definetely a bug so it's good to buzz
about it. But we have to align the buffer length -- upper layers
should take care to reserve enough space.
Signed-off-by: Ilya Yanok <ilya.ya...@cogentembedded.com>
[marek.vasut]: introduce some crazy macro voodoo
Signed-off-by: Marek Vasut <ma...@denx.de>
---
 drivers/usb/host/ehci-hcd.c  |   81 ++++++++++++++++++++++++------------------
 drivers/usb/musb/musb_core.h |    2 +-
 include/usb.h                |   10 ++++++
 3 files changed, 57 insertions(+), 36 deletions(-)

diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 04300be..5199560 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -34,7 +34,10 @@ struct ehci_hccr *hccr;      /* R/O registers, not need for 
volatile */
 volatile struct ehci_hcor *hcor;
 
 static uint16_t portreset;
-static struct QH qh_list __attribute__((aligned(32)));
+DEFINE_CACHE_ALIGN_BUFFER(struct QH, qh_list, 1);
+
+#define ALIGN_END_ADDR(type, ptr, size)                        \
+       ((uint32_t)(ptr) + roundup((size) * sizeof(type), USB_DMA_MINALIGN))
 
 static struct descriptor {
        struct usb_hub_descriptor hub;
@@ -172,13 +175,13 @@ static int ehci_td_buffer(struct qTD *td, void *buf, 
size_t sz)
 {
        uint32_t delta, next;
        uint32_t addr = (uint32_t)buf;
-       size_t rsz = roundup(sz, 32);
+       size_t rsz = roundup(sz, USB_DMA_MINALIGN);
        int idx;
 
        if (sz != rsz)
                debug("EHCI-HCD: Misaligned buffer size (%08x)\n", sz);
 
-       if (addr & 31)
+       if (addr != ALIGN(addr, USB_DMA_MINALIGN))
                debug("EHCI-HCD: Misaligned buffer address (%p)\n", buf);
 
        idx = 0;
@@ -207,8 +210,8 @@ static int
 ehci_submit_async(struct usb_device *dev, unsigned long pipe, void *buffer,
                   int length, struct devrequest *req)
 {
-       static struct QH qh __attribute__((aligned(32)));
-       static struct qTD qtd[3] __attribute__((aligned (32)));
+       ALLOC_CACHE_ALIGN_BUFFER(struct QH, qh, 1);
+       ALLOC_CACHE_ALIGN_BUFFER(struct qTD, qtd, 3);
        int qtd_counter = 0;
 
        volatile struct qTD *vtd;
@@ -229,8 +232,8 @@ ehci_submit_async(struct usb_device *dev, unsigned long 
pipe, void *buffer,
                      le16_to_cpu(req->value), le16_to_cpu(req->value),
                      le16_to_cpu(req->index));
 
-       memset(&qh, 0, sizeof(struct QH));
-       memset(qtd, 0, sizeof(qtd));
+       memset(qh, 0, sizeof(struct QH));
+       memset(qtd, 0, 3 * sizeof(*qtd));
 
        toggle = usb_gettoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));
 
@@ -244,7 +247,7 @@ ehci_submit_async(struct usb_device *dev, unsigned long 
pipe, void *buffer,
         *   qh_overlay.qt_next ...... 13-10 H
         * - qh_overlay.qt_altnext
         */
-       qh.qh_link = cpu_to_hc32((uint32_t)&qh_list | QH_LINK_TYPE_QH);
+       qh->qh_link = cpu_to_hc32((uint32_t)qh_list | QH_LINK_TYPE_QH);
        c = (usb_pipespeed(pipe) != USB_SPEED_HIGH &&
             usb_pipeendpoint(pipe) == 0) ? 1 : 0;
        endpt = (8 << 28) |
@@ -255,14 +258,14 @@ ehci_submit_async(struct usb_device *dev, unsigned long 
pipe, void *buffer,
            (usb_pipespeed(pipe) << 12) |
            (usb_pipeendpoint(pipe) << 8) |
            (0 << 7) | (usb_pipedevice(pipe) << 0);
-       qh.qh_endpt1 = cpu_to_hc32(endpt);
+       qh->qh_endpt1 = cpu_to_hc32(endpt);
        endpt = (1 << 30) |
            (dev->portnr << 23) |
            (dev->parent->devnum << 16) | (0 << 8) | (0 << 0);
-       qh.qh_endpt2 = cpu_to_hc32(endpt);
-       qh.qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
+       qh->qh_endpt2 = cpu_to_hc32(endpt);
+       qh->qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
 
-       tdp = &qh.qh_overlay.qt_next;
+       tdp = &qh->qh_overlay.qt_next;
 
        if (req != NULL) {
                /*
@@ -340,13 +343,13 @@ ehci_submit_async(struct usb_device *dev, unsigned long 
pipe, void *buffer,
                tdp = &qtd[qtd_counter++].qt_next;
        }
 
-       qh_list.qh_link = cpu_to_hc32((uint32_t)&qh | QH_LINK_TYPE_QH);
+       qh_list->qh_link = cpu_to_hc32((uint32_t)qh | QH_LINK_TYPE_QH);
 
        /* Flush dcache */
-       flush_dcache_range((uint32_t)&qh_list,
-               (uint32_t)&qh_list + sizeof(struct QH));
-       flush_dcache_range((uint32_t)&qh, (uint32_t)&qh + sizeof(struct QH));
-       flush_dcache_range((uint32_t)qtd, (uint32_t)qtd + sizeof(qtd));
+       flush_dcache_range((uint32_t)qh_list,
+               ALIGN_END_ADDR(struct QH, qh_list, 1));
+       flush_dcache_range((uint32_t)qh, ALIGN_END_ADDR(struct QH, qh, 1));
+       flush_dcache_range((uint32_t)qtd, ALIGN_END_ADDR(struct qTD, qtd, 3));
 
        usbsts = ehci_readl(&hcor->or_usbsts);
        ehci_writel(&hcor->or_usbsts, (usbsts & 0x3f));
@@ -369,12 +372,12 @@ ehci_submit_async(struct usb_device *dev, unsigned long 
pipe, void *buffer,
        timeout = USB_TIMEOUT_MS(pipe);
        do {
                /* Invalidate dcache */
-               invalidate_dcache_range((uint32_t)&qh_list,
-                       (uint32_t)&qh_list + sizeof(struct QH));
-               invalidate_dcache_range((uint32_t)&qh,
-                       (uint32_t)&qh + sizeof(struct QH));
+               invalidate_dcache_range((uint32_t)qh_list,
+                       ALIGN_END_ADDR(struct QH, qh_list, 1));
+               invalidate_dcache_range((uint32_t)qh,
+                       ALIGN_END_ADDR(struct QH, qh, 1));
                invalidate_dcache_range((uint32_t)qtd,
-                       (uint32_t)qtd + sizeof(qtd));
+                       ALIGN_END_ADDR(struct qTD, qtd, 3));
 
                token = hc32_to_cpu(vtd->qt_token);
                if (!(token & 0x80))
@@ -382,9 +385,17 @@ ehci_submit_async(struct usb_device *dev, unsigned long 
pipe, void *buffer,
                WATCHDOG_RESET();
        } while (get_timer(ts) < timeout);
 
-       /* Invalidate the memory area occupied by buffer */
-       invalidate_dcache_range(((uint32_t)buffer & ~31),
-               ((uint32_t)buffer & ~31) + roundup(length, 32));
+       /*
+        * Invalidate the memory area occupied by buffer
+        * Don't try to fix the buffer alignment, if it isn't properly
+        * aligned it's upper layer's fault so let invalidate_dcache_range()
+        * vow about it. But we have to fix the length as it's actual
+        * transfer length and can be unaligned. This is potentially
+        * dangerous operation, it's responsibility of the calling
+        * code to make sure enough space is reserved.
+        */
+       invalidate_dcache_range((uint32_t)buffer,
+               ALIGN_END_ADDR(u8, buffer, length));
 
        /* Check that the TD processing happened */
        if (token & 0x80) {
@@ -403,9 +414,9 @@ ehci_submit_async(struct usb_device *dev, unsigned long 
pipe, void *buffer,
                goto fail;
        }
 
-       qh_list.qh_link = cpu_to_hc32((uint32_t)&qh_list | QH_LINK_TYPE_QH);
+       qh_list->qh_link = cpu_to_hc32((uint32_t)qh_list | QH_LINK_TYPE_QH);
 
-       token = hc32_to_cpu(qh.qh_overlay.qt_token);
+       token = hc32_to_cpu(qh->qh_overlay.qt_token);
        if (!(token & 0x80)) {
                debug("TOKEN=%#x\n", token);
                switch (token & 0xfc) {
@@ -733,16 +744,16 @@ int usb_lowlevel_init(void)
 #endif
 
        /* Set head of reclaim list */
-       memset(&qh_list, 0, sizeof(qh_list));
-       qh_list.qh_link = cpu_to_hc32((uint32_t)&qh_list | QH_LINK_TYPE_QH);
-       qh_list.qh_endpt1 = cpu_to_hc32((1 << 15) | (USB_SPEED_HIGH << 12));
-       qh_list.qh_curtd = cpu_to_hc32(QT_NEXT_TERMINATE);
-       qh_list.qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
-       qh_list.qh_overlay.qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
-       qh_list.qh_overlay.qt_token = cpu_to_hc32(0x40);
+       memset(qh_list, 0, sizeof(*qh_list));
+       qh_list->qh_link = cpu_to_hc32((uint32_t)qh_list | QH_LINK_TYPE_QH);
+       qh_list->qh_endpt1 = cpu_to_hc32((1 << 15) | (USB_SPEED_HIGH << 12));
+       qh_list->qh_curtd = cpu_to_hc32(QT_NEXT_TERMINATE);
+       qh_list->qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
+       qh_list->qh_overlay.qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
+       qh_list->qh_overlay.qt_token = cpu_to_hc32(0x40);
 
        /* Set async. queue head pointer. */
-       ehci_writel(&hcor->or_asynclistaddr, (uint32_t)&qh_list);
+       ehci_writel(&hcor->or_asynclistaddr, (uint32_t)qh_list);
 
        reg = ehci_readl(&hccr->cr_hcsparams);
        descriptor.hub.bNbrPorts = HCS_N_PORTS(reg);
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index a8adcce..e914369 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -145,7 +145,7 @@ struct musb_regs {
                struct musb_epN_regs epN;
        } ep[16];
 
-} __attribute__((packed, aligned(32)));
+} __attribute__((packed, aligned(USB_DMA_MINALIGN)));
 #endif
 
 /*
diff --git a/include/usb.h b/include/usb.h
index 6da91e7..ba3d169 100644
--- a/include/usb.h
+++ b/include/usb.h
@@ -29,6 +29,16 @@
 #include <usb_defs.h>
 #include <usbdescriptors.h>
 
+/*
+ * The EHCI spec says that we must align to at least 32 bytes.  However,
+ * some platforms require larger alignment.
+ */
+#if ARCH_DMA_MINALIGN > 32
+#define USB_DMA_MINALIGN       ARCH_DMA_MINALIGN
+#else
+#define USB_DMA_MINALIGN       32
+#endif
+
 /* Everything is aribtrary */
 #define USB_ALTSETTINGALLOC            4
 #define USB_MAXALTSETTING              128     /* Hard limit */
-- 
1.7.10.4

_______________________________________________
U-Boot mailing list
U-Boot@lists.denx.de
http://lists.denx.de/mailman/listinfo/u-boot

Reply via email to