usb: dwc_otg: Ported "drivers/usb/dwc_otg_310" from kernel-3.10

Modified some internal interfaces to support kernel-4.4

Change-Id: I1a87b75f5429874d879437b21cbf85eba4473ee0
Signed-off-by: Frank Wang <frank.wang@rock-chips.com>

diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index 8ed451dd651e02a736e1739ed9842a2b8b91db1b..cd944cd41e50739cf74118f86ae1201ab3de2090 100644 (file)
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -151,6 +151,8 @@ source "drivers/usb/phy/Kconfig"
 
 source "drivers/usb/gadget/Kconfig"
 
+source "drivers/usb/dwc_otg_310/Kconfig"
+
 config USB_LED_TRIG
        bool "USB LED Triggers"
        depends on LEDS_CLASS && USB_COMMON && LEDS_TRIGGERS

diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile
index d5c57f1e98fddfffb39c948159558ca4ea09b0f3..bea7098d053ff29f1530a59776ae5f8c0929b9ee 100644 (file)
--- a/drivers/usb/Makefile
+++ b/drivers/usb/Makefile
@@ -53,6 +53,8 @@ obj-$(CONFIG_EARLY_PRINTK_DBGP)       += early/
 obj-$(CONFIG_USB_ATM)          += atm/
 obj-$(CONFIG_USB_SPEEDTOUCH)   += atm/
 
+obj-$(CONFIG_DWC_OTG_310)      += dwc_otg_310/
+
 obj-$(CONFIG_USB_MUSB_HDRC)    += musb/
 obj-$(CONFIG_USB_CHIPIDEA)     += chipidea/
 obj-$(CONFIG_USB_RENESAS_USBHS)        += renesas_usbhs/

diff --git a/drivers/usb/dwc_otg_310/common_port/dwc_common_linux.c b/drivers/usb/dwc_otg_310/common_port/dwc_common_linux.c
index f729139257d69511b09f1a4a687771ae165566b3..794b1dc45b5ca8bdc839a0c56f3db465b1221f37 100755 (executable)
--- a/drivers/usb/dwc_otg_310/common_port/dwc_common_linux.c
+++ b/drivers/usb/dwc_otg_310/common_port/dwc_common_linux.c
@@ -346,7 +346,8 @@ void DWC_DMA_POOL_FREE(dwc_pool_t *pool, void *vaddr, void *daddr)
 void *__DWC_DMA_ALLOC(void *dma_ctx, uint32_t size, dwc_dma_t *dma_addr)
 {
 #if 1 /* def xxCOSIM  Only works for 32-bit cosim */
-       void *buf = dma_alloc_coherent(dma_ctx, (size_t)size, dma_addr, GFP_KERNEL);
+       void *buf = dma_alloc_coherent((struct device *)dma_ctx, (size_t)size,
+                                      dma_addr, GFP_KERNEL);
 #else
        void *buf = dma_alloc_coherent(dma_ctx, (size_t)size, dma_addr, GFP_KERNEL | GFP_DMA32);
 #endif
@@ -360,7 +361,8 @@ void *__DWC_DMA_ALLOC(void *dma_ctx, uint32_t size, dwc_dma_t *dma_addr)
 
 void *__DWC_DMA_ALLOC_ATOMIC(void *dma_ctx, uint32_t size, dwc_dma_t *dma_addr)
 {
-       void *buf = dma_alloc_coherent(NULL, (size_t)size, dma_addr, GFP_ATOMIC);
+       void *buf = dma_alloc_coherent((struct device *)dma_ctx, (size_t)size,
+                                      dma_addr, GFP_ATOMIC);
        if (!buf) {
                return NULL;
        }
@@ -370,7 +372,7 @@ void *__DWC_DMA_ALLOC_ATOMIC(void *dma_ctx, uint32_t size, dwc_dma_t *dma_addr)
 
 void __DWC_DMA_FREE(void *dma_ctx, uint32_t size, void *virt_addr, dwc_dma_t dma_addr)
 {
-       dma_free_coherent(dma_ctx, size, virt_addr, dma_addr);
+       dma_free_coherent((struct device *)dma_ctx, size, virt_addr, dma_addr);
 }
 
 void *__DWC_ALLOC(void *mem_ctx, uint32_t size)
@@ -793,7 +795,6 @@ dwc_timer_t *DWC_TIMER_ALLOC(char *name, dwc_timer_callback_t cb, void *data)
        }
 
        t->scheduled = 0;
-       t->t->base = &boot_tvec_bases;
        t->t->expires = jiffies;
        setup_timer(t->t, timer_callback, (unsigned long)t);
 

diff --git a/drivers/usb/dwc_otg_310/common_port/dwc_os.h b/drivers/usb/dwc_otg_310/common_port/dwc_os.h
index e9105afd989acb2c0e3f45ae8c5a259d108e1c70..b8311e27ef9f33171838524a6b6f951d7b71b3dc 100755 (executable)
--- a/drivers/usb/dwc_otg_310/common_port/dwc_os.h
+++ b/drivers/usb/dwc_otg_310/common_port/dwc_os.h
@@ -672,9 +672,16 @@ extern void __DWC_FREE(void *mem_ctx, void *addr);
 #define DWC_FREE(_addr_) __DWC_FREE(NULL, _addr_)
 
 # ifdef DWC_LINUX
+extern void *dwc_otg_dev;
 #define DWC_DMA_ALLOC(_size_, _dma_) __DWC_DMA_ALLOC(NULL, _size_, _dma_)
 #define DWC_DMA_ALLOC_ATOMIC(_size_, _dma_) __DWC_DMA_ALLOC_ATOMIC(NULL, _size_, _dma_)
 #define DWC_DMA_FREE(_size_, _virt_, _dma_) __DWC_DMA_FREE(NULL, _size_, _virt_, _dma_)
+#define DWC_DEV_DMA_ALLOC(_size_, _dma_) \
+       __DWC_DMA_ALLOC(dwc_otg_dev, _size_, _dma_)
+#define DWC_DEV_DMA_ALLOC_ATOMIC(_size_, _dma_) \
+       __DWC_DMA_ALLOC_ATOMIC(dwc_otg_dev, _size_, _dma_)
+#define DWC_DEV_DMA_FREE(_size_, _virt_, _dma_) \
+       __DWC_DMA_FREE(dwc_otg_dev, _size_, _virt_, _dma_)
 # endif
 
 # if defined(DWC_FREEBSD) || defined(DWC_NETBSD)

diff --git a/drivers/usb/dwc_otg_310/dwc_otg_cfi.c b/drivers/usb/dwc_otg_310/dwc_otg_cfi.c
index 96c5e3eb1d824adbc949fc50cefd110ae57e1f6f..22242345124ccc859761cede6548338dd43db653 100755 (executable)
--- a/drivers/usb/dwc_otg_310/dwc_otg_cfi.c
+++ b/drivers/usb/dwc_otg_310/dwc_otg_cfi.c
@@ -413,14 +413,14 @@ static void cfi_release(cfiobject_t *cfiobj)
        CFI_INFO("%s\n", __func__);
 
        if (cfiobj->buf_in.buf) {
-               DWC_DMA_FREE(CFI_IN_BUF_LEN, cfiobj->buf_in.buf,
-                            cfiobj->buf_in.addr);
+               DWC_DEV_DMA_FREE(CFI_IN_BUF_LEN, cfiobj->buf_in.buf,
+                                cfiobj->buf_in.addr);
                cfiobj->buf_in.buf = NULL;
        }
 
        if (cfiobj->buf_out.buf) {
-               DWC_DMA_FREE(CFI_OUT_BUF_LEN, cfiobj->buf_out.buf,
-                            cfiobj->buf_out.addr);
+               DWC_DEV_DMA_FREE(CFI_OUT_BUF_LEN, cfiobj->buf_out.buf,
+                                cfiobj->buf_out.addr);
                cfiobj->buf_out.buf = NULL;
        }
 

diff --git a/drivers/usb/dwc_otg_310/dwc_otg_driver.c b/drivers/usb/dwc_otg_310/dwc_otg_driver.c
old mode 100755 (executable)
new mode 100644 (file)
index 961db3f..eaf6772
--- a/drivers/usb/dwc_otg_310/dwc_otg_driver.c
+++ b/drivers/usb/dwc_otg_310/dwc_otg_driver.c
@@ -68,6 +68,7 @@ static const char dwc_host20_driver_name[] = "usb20_host";
 static const char dwc_otg20_driver_name[] = "usb20_otg";
 
 dwc_otg_device_t *g_otgdev;
+void *dwc_otg_dev;
 
 extern int pcd_init(struct platform_device *_dev);
 extern int otg20_hcd_init(struct platform_device *_dev);
@@ -1310,7 +1311,7 @@ static const struct of_device_id usb20_otg_of_match[] = {
 #endif
 #ifdef CONFIG_ARM64
        {
-        .compatible = "rockchip,rk3368_usb20_otg",
+        .compatible = "rockchip,rk3368-usb",
         .data = &usb20otg_pdata_rk3368,
         },
 #endif
@@ -1419,6 +1420,7 @@ static int otg20_driver_probe(struct platform_device *_dev)
         */
 
        g_otgdev = dwc_otg_device;
+       dwc_otg_dev = (struct device *)&_dev->dev;
        pldata->privdata = dwc_otg_device;
        dwc_otg_device->pldata = pldata;
 
@@ -1619,7 +1621,9 @@ void rk_usb_power_up(void)
 {
        struct dwc_otg_platform_data *pldata_otg;
        struct dwc_otg_platform_data *pldata_host;
+#ifdef CONFIG_USB_EHCI_RK
        struct rkehci_platform_data *pldata_ehci;
+#endif
 
        if (cpu_is_rk3288()) {
 #ifdef CONFIG_RK_USB_UART
@@ -1673,7 +1677,9 @@ void rk_usb_power_down(void)
 {
        struct dwc_otg_platform_data *pldata_otg;
        struct dwc_otg_platform_data *pldata_host;
+#ifdef CONFIG_USB_EHCI_RK
        struct rkehci_platform_data *pldata_ehci;
+#endif
 
        if (cpu_is_rk3288()) {
 #ifdef CONFIG_RK_USB_UART

diff --git a/drivers/usb/dwc_otg_310/dwc_otg_hcd.c b/drivers/usb/dwc_otg_310/dwc_otg_hcd.c
index 9df43cd1aba17ef10f45f45d01d03a8b790633f2..79abd8229efc17efd3656607150c82adf8785cb4 100755 (executable)
--- a/drivers/usb/dwc_otg_310/dwc_otg_hcd.c
+++ b/drivers/usb/dwc_otg_310/dwc_otg_hcd.c
@@ -828,9 +828,9 @@ static void dwc_otg_hcd_free(dwc_otg_hcd_t *dwc_otg_hcd)
 
        if (dwc_otg_hcd->core_if->dma_enable) {
                if (dwc_otg_hcd->status_buf_dma) {
-                       DWC_DMA_FREE(DWC_OTG_HCD_STATUS_BUF_SIZE,
-                                    dwc_otg_hcd->status_buf,
-                                    dwc_otg_hcd->status_buf_dma);
+                       DWC_DEV_DMA_FREE(DWC_OTG_HCD_STATUS_BUF_SIZE,
+                                        dwc_otg_hcd->status_buf,
+                                        dwc_otg_hcd->status_buf_dma);
                }
        } else if (dwc_otg_hcd->status_buf != NULL) {
                DWC_FREE(dwc_otg_hcd->status_buf);
@@ -932,8 +932,8 @@ int dwc_otg_hcd_init(dwc_otg_hcd_t *hcd, dwc_otg_core_if_t *core_if)
         */
        if (hcd->core_if->dma_enable) {
                hcd->status_buf =
-                   DWC_DMA_ALLOC_ATOMIC(DWC_OTG_HCD_STATUS_BUF_SIZE,
-                                        &hcd->status_buf_dma);
+                   DWC_DEV_DMA_ALLOC_ATOMIC(DWC_OTG_HCD_STATUS_BUF_SIZE,
+                                            &hcd->status_buf_dma);
        } else {
                hcd->status_buf = DWC_ALLOC(DWC_OTG_HCD_STATUS_BUF_SIZE);
        }
@@ -1214,9 +1214,10 @@ static int assign_and_init_hc(dwc_otg_hcd_t *hcd, dwc_otg_qh_t *qh)
                        buf_size = 4096;
                }
                if (!qh->dw_align_buf) {
-                       qh->dw_align_buf = DWC_DMA_ALLOC_ATOMIC(buf_size,
-                                                               &qh->
-                                                               dw_align_buf_dma);
+                       qh->dw_align_buf =
+                               DWC_DEV_DMA_ALLOC_ATOMIC(buf_size,
+                                                        &qh->
+                                                        dw_align_buf_dma);
                        if (!qh->dw_align_buf) {
                                DWC_ERROR
                                    ("%s: Failed to allocate memory to handle "

diff --git a/drivers/usb/dwc_otg_310/dwc_otg_hcd_ddma.c b/drivers/usb/dwc_otg_310/dwc_otg_hcd_ddma.c
index 3169aa272c0c1e0a4c09b66c80a0949d0de9f2bb..a491bb816fb74cef12ad30ae5a2107cbfa0120a5 100755 (executable)
--- a/drivers/usb/dwc_otg_310/dwc_otg_hcd_ddma.c
+++ b/drivers/usb/dwc_otg_310/dwc_otg_hcd_ddma.c
@@ -83,8 +83,9 @@ static int desc_list_alloc(dwc_otg_qh_t *qh)
        int retval = 0;
 
        qh->desc_list = (dwc_otg_host_dma_desc_t *)
-           DWC_DMA_ALLOC_ATOMIC(sizeof(dwc_otg_host_dma_desc_t) * max_desc_num(qh),
-                                &qh->desc_list_dma);
+           DWC_DEV_DMA_ALLOC_ATOMIC(sizeof(dwc_otg_host_dma_desc_t) *
+                                    max_desc_num(qh),
+                                    &qh->desc_list_dma);
 
        if (!qh->desc_list) {
                retval = -DWC_E_NO_MEMORY;
@@ -113,8 +114,8 @@ static int desc_list_alloc(dwc_otg_qh_t *qh)
 static void desc_list_free(dwc_otg_qh_t *qh)
 {
        if (qh->desc_list) {
-               DWC_DMA_FREE(max_desc_num(qh), qh->desc_list,
-                            qh->desc_list_dma);
+               DWC_DEV_DMA_FREE(max_desc_num(qh), qh->desc_list,
+                                qh->desc_list_dma);
                qh->desc_list = NULL;
        }
 
@@ -130,8 +131,8 @@ static int frame_list_alloc(dwc_otg_hcd_t *hcd)
        if (hcd->frame_list)
                return 0;
 
-       hcd->frame_list = DWC_DMA_ALLOC_ATOMIC(4 * MAX_FRLIST_EN_NUM,
-                                              &hcd->frame_list_dma);
+       hcd->frame_list = DWC_DEV_DMA_ALLOC_ATOMIC(4 * MAX_FRLIST_EN_NUM,
+                                                  &hcd->frame_list_dma);
        if (!hcd->frame_list) {
                retval = -DWC_E_NO_MEMORY;
                DWC_ERROR("%s: Frame List allocation failed\n", __func__);
@@ -147,8 +148,8 @@ static void frame_list_free(dwc_otg_hcd_t *hcd)
        if (!hcd->frame_list)
                return;
 
-       DWC_DMA_FREE(4 * MAX_FRLIST_EN_NUM, hcd->frame_list,
-                    hcd->frame_list_dma);
+       DWC_DEV_DMA_FREE(4 * MAX_FRLIST_EN_NUM, hcd->frame_list,
+                        hcd->frame_list_dma);
        hcd->frame_list = NULL;
 }
 

diff --git a/drivers/usb/dwc_otg_310/dwc_otg_hcd_linux.c b/drivers/usb/dwc_otg_310/dwc_otg_hcd_linux.c
index e03109703d1bc52fc9e780b50402e9e0dc4cfcf3..02e7c1220c3b1d1f3897f80ee3a33996c4ad270a 100755 (executable)
--- a/drivers/usb/dwc_otg_310/dwc_otg_hcd_linux.c
+++ b/drivers/usb/dwc_otg_310/dwc_otg_hcd_linux.c
@@ -520,7 +520,7 @@ int otg20_hcd_init(struct platform_device *_dev)
         * IRQ line, and calls hcd_start method.
         */
        irq = platform_get_irq(_dev, 0);
-       retval = usb_add_hcd(hcd, irq, IRQF_SHARED | IRQF_DISABLED);
+       retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (retval < 0) {
                goto error2;
        }
@@ -612,7 +612,7 @@ int host20_hcd_init(struct platform_device *_dev)
         * IRQ line, and calls hcd_start method.
         */
        irq = platform_get_irq(_dev, 0);
-       retval = usb_add_hcd(hcd, irq, IRQF_SHARED | IRQF_DISABLED);
+       retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (retval < 0) {
                goto error2;
        }

diff --git a/drivers/usb/dwc_otg_310/dwc_otg_hcd_queue.c b/drivers/usb/dwc_otg_310/dwc_otg_hcd_queue.c
index 353693f176436d4b06b05910067fa5ef2c066b2f..5f3a4ec23c6d16927612021e0c108e6ddb5fcfa2 100755 (executable)
--- a/drivers/usb/dwc_otg_310/dwc_otg_hcd_queue.c
+++ b/drivers/usb/dwc_otg_310/dwc_otg_hcd_queue.c
@@ -70,7 +70,8 @@ void dwc_otg_hcd_qh_free(dwc_otg_hcd_t *hcd, dwc_otg_qh_t *qh)
                } else {
                        buf_size = hcd->core_if->core_params->max_transfer_size;
                }
-               DWC_DMA_FREE(buf_size, qh->dw_align_buf, qh->dw_align_buf_dma);
+               DWC_DEV_DMA_FREE(buf_size, qh->dw_align_buf,
+                                qh->dw_align_buf_dma);
        }
 
        DWC_FREE(qh);

diff --git a/drivers/usb/dwc_otg_310/dwc_otg_pcd.c b/drivers/usb/dwc_otg_310/dwc_otg_pcd.c
index 00f1ea90c289cb47feba288d51a95dac533467fb..21af8a00e9c7a8143fe5fa4f7c6373e35c27298b 100755 (executable)
--- a/drivers/usb/dwc_otg_310/dwc_otg_pcd.c
+++ b/drivers/usb/dwc_otg_310/dwc_otg_pcd.c
@@ -240,8 +240,8 @@ static dwc_otg_cil_callbacks_t pcd_callbacks = {
 dwc_otg_dev_dma_desc_t *dwc_otg_ep_alloc_desc_chain(dwc_dma_t *dma_desc_addr,
                                                    uint32_t count)
 {
-       return DWC_DMA_ALLOC_ATOMIC(count * sizeof(dwc_otg_dev_dma_desc_t),
-                                   dma_desc_addr);
+       return DWC_DEV_DMA_ALLOC_ATOMIC(count * sizeof(dwc_otg_dev_dma_desc_t),
+                                       dma_desc_addr);
 }
 
 /**
@@ -250,8 +250,8 @@ dwc_otg_dev_dma_desc_t *dwc_otg_ep_alloc_desc_chain(dwc_dma_t *dma_desc_addr,
 void dwc_otg_ep_free_desc_chain(dwc_otg_dev_dma_desc_t *desc_addr,
                                uint32_t dma_desc_addr, uint32_t count)
 {
-       DWC_DMA_FREE(count * sizeof(dwc_otg_dev_dma_desc_t), desc_addr,
-                    dma_desc_addr);
+       DWC_DEV_DMA_FREE(count * sizeof(dwc_otg_dev_dma_desc_t), desc_addr,
+                        dma_desc_addr);
 }
 
 #ifdef DWC_EN_ISOC
@@ -1160,19 +1160,20 @@ dwc_otg_pcd_t *dwc_otg_pcd_init(dwc_otg_core_if_t *core_if)
         */
        if (GET_CORE_IF(pcd)->dma_enable) {
                pcd->setup_pkt =
-                   DWC_DMA_ALLOC_ATOMIC(sizeof(*pcd->setup_pkt) * 5,
-                                        &pcd->setup_pkt_dma_handle);
+                   DWC_DEV_DMA_ALLOC_ATOMIC(sizeof(*pcd->setup_pkt) * 5,
+                                            &pcd->setup_pkt_dma_handle);
                if (pcd->setup_pkt == NULL) {
                        DWC_FREE(pcd);
                        return NULL;
                }
 
                pcd->status_buf =
-                   DWC_DMA_ALLOC_ATOMIC(sizeof(uint16_t),
-                                        &pcd->status_buf_dma_handle);
+                   DWC_DEV_DMA_ALLOC_ATOMIC(sizeof(uint16_t),
+                                            &pcd->status_buf_dma_handle);
                if (pcd->status_buf == NULL) {
-                       DWC_DMA_FREE(sizeof(*pcd->setup_pkt) * 5,
-                                    pcd->setup_pkt, pcd->setup_pkt_dma_handle);
+                       DWC_DEV_DMA_FREE(sizeof(*pcd->setup_pkt) * 5,
+                                        pcd->setup_pkt,
+                                        pcd->setup_pkt_dma_handle);
                        DWC_FREE(pcd);
                        return NULL;
                }
@@ -1214,12 +1215,12 @@ dwc_otg_pcd_t *dwc_otg_pcd_init(dwc_otg_core_if_t *core_if)
                                            (dev_if->setup_desc_addr[0],
                                             dev_if->dma_setup_desc_addr[0], 1);
 
-                               DWC_DMA_FREE(sizeof(*pcd->setup_pkt) * 5,
-                                            pcd->setup_pkt,
-                                            pcd->setup_pkt_dma_handle);
-                               DWC_DMA_FREE(sizeof(*pcd->status_buf),
-                                            pcd->status_buf,
-                                            pcd->status_buf_dma_handle);
+                               DWC_DEV_DMA_FREE(sizeof(*pcd->setup_pkt) * 5,
+                                                pcd->setup_pkt,
+                                                pcd->setup_pkt_dma_handle);
+                               DWC_DEV_DMA_FREE(sizeof(*pcd->status_buf),
+                                                pcd->status_buf,
+                                                pcd->status_buf_dma_handle);
 
                                DWC_FREE(pcd);
 
@@ -1308,10 +1309,10 @@ void dwc_otg_pcd_remove(dwc_otg_pcd_t *pcd)
        }
 
        if (GET_CORE_IF(pcd)->dma_enable) {
-               DWC_DMA_FREE(sizeof(*pcd->setup_pkt) * 5, pcd->setup_pkt,
-                            pcd->setup_pkt_dma_handle);
-               DWC_DMA_FREE(sizeof(uint16_t), pcd->status_buf,
-                            pcd->status_buf_dma_handle);
+               DWC_DEV_DMA_FREE(sizeof(*pcd->setup_pkt) * 5, pcd->setup_pkt,
+                                pcd->setup_pkt_dma_handle);
+               DWC_DEV_DMA_FREE(sizeof(uint16_t), pcd->status_buf,
+                                pcd->status_buf_dma_handle);
                if (GET_CORE_IF(pcd)->dma_desc_enable) {
                        dwc_otg_ep_free_desc_chain(dev_if->setup_desc_addr[0],
                                                   dev_if->dma_setup_desc_addr
@@ -2265,8 +2266,9 @@ int dwc_otg_pcd_ep_queue(dwc_otg_pcd_t *pcd, void *ep_handle,
        req->dw_align_buf = NULL;
        if ((dma_buf & 0x3) && GET_CORE_IF(pcd)->dma_enable
            && !GET_CORE_IF(pcd)->dma_desc_enable)
-               req->dw_align_buf = DWC_DMA_ALLOC_ATOMIC(buflen,
-                                                        &req->dw_align_buf_dma);
+               req->dw_align_buf = DWC_DEV_DMA_ALLOC_ATOMIC(buflen,
+                                                            &req->
+                                                            dw_align_buf_dma);
        DWC_SPINLOCK_IRQSAVE(pcd->lock, &flags);
 
        /*

diff --git a/drivers/usb/dwc_otg_310/dwc_otg_pcd_intr.c b/drivers/usb/dwc_otg_310/dwc_otg_pcd_intr.c
index cdb53717a8ce667bbf9b35d4c3e603f25d54170c..ab0de79be9b7fabaeca238454c95ede876c13fbb 100755 (executable)
--- a/drivers/usb/dwc_otg_310/dwc_otg_pcd_intr.c
+++ b/drivers/usb/dwc_otg_310/dwc_otg_pcd_intr.c
@@ -2489,8 +2489,8 @@ static void complete_ep(dwc_otg_pcd_ep_t *ep)
                                dwc_memcpy(req->buf, req->dw_align_buf,
                                           req->length);
                        }
-                       DWC_DMA_FREE(req->length, req->dw_align_buf,
-                                    req->dw_align_buf_dma);
+                       DWC_DEV_DMA_FREE(req->length, req->dw_align_buf,
+                                        req->dw_align_buf_dma);
                }
 
                dwc_otg_request_done(ep, req, 0);

diff --git a/drivers/usb/dwc_otg_310/dwc_otg_pcd_linux.c b/drivers/usb/dwc_otg_310/dwc_otg_pcd_linux.c
old mode 100755 (executable)
new mode 100644 (file)
index e67384d..a6f2ea7
--- a/drivers/usb/dwc_otg_310/dwc_otg_pcd_linux.c
+++ b/drivers/usb/dwc_otg_310/dwc_otg_pcd_linux.c
@@ -775,8 +775,7 @@ static int dwc_otg_gadget_start(struct usb_gadget *g,
        return 0;
 }
 
-static int dwc_otg_gadget_stop(struct usb_gadget *g,
-                              struct usb_gadget_driver *driver)
+static int dwc_otg_gadget_stop(struct usb_gadget *g)
 {
        return 0;
 }

diff --git a/drivers/usb/dwc_otg_310/usbdev_rk3368.c b/drivers/usb/dwc_otg_310/usbdev_rk3368.c
index 7af3c5488349270ec7143e4e56064becd0783215..ebd263004117b5ad3c1ac16d38df52f667df5a81 100644 (file)
--- a/drivers/usb/dwc_otg_310/usbdev_rk3368.c
+++ b/drivers/usb/dwc_otg_310/usbdev_rk3368.c
@@ -99,15 +99,15 @@ static void usb20otg_clock_init(void *pdata)
        struct dwc_otg_platform_data *usbpdata = pdata;
        struct clk *ahbclk, *phyclk;
 
-       ahbclk = devm_clk_get(usbpdata->dev, "hclk_otg");
+       ahbclk = devm_clk_get(usbpdata->dev, "otg");
        if (IS_ERR(ahbclk)) {
-               dev_err(usbpdata->dev, "Failed to get hclk_usb0\n");
+               dev_err(usbpdata->dev, "Failed to get otg clk\n");
                return;
        }
 
-       phyclk = devm_clk_get(usbpdata->dev, "clk_usbphy0");
+       phyclk = devm_clk_get(usbpdata->dev, "sclk_otgphy0");
        if (IS_ERR(phyclk)) {
-               dev_err(usbpdata->dev, "Failed to get clk_usbphy0\n");
+               dev_err(usbpdata->dev, "Failed to get sclk_otgphy0\n");
                return;
        }