source: trunk/target/linux/brcm63xx/patches-2.6.39/011-add_bcm63xx_ehci_controller.patch @ 27945

Last change on this file since 27945 was 27945, checked in by florian, 5 years ago

[kernel] add ignore_oc in struct ehci_hcd

File size: 4.6 KB
  • new file drivers/usb/host/ehci-bcm63xx.c

    Signed-off-by: Maxime Bizon <mbizon@freebox.fr>
    ---
     drivers/usb/host/ehci-bcm63xx.c |  154 +++++++++++++++++++++++++++++++++++++++
     drivers/usb/host/ehci-hcd.c     |    5 +
     2 files changed, 159 insertions(+), 0 deletions(-)
     create mode 100644 drivers/usb/host/ehci-bcm63xx.c
    
    - +  
     1/* 
     2 * This file is subject to the terms and conditions of the GNU General Public 
     3 * License.  See the file "COPYING" in the main directory of this archive 
     4 * for more details. 
     5 * 
     6 * Copyright (C) 2008 Maxime Bizon <mbizon@freebox.fr> 
     7 */ 
     8 
     9#include <linux/init.h> 
     10#include <linux/platform_device.h> 
     11#include <bcm63xx_cpu.h> 
     12#include <bcm63xx_regs.h> 
     13#include <bcm63xx_io.h> 
     14 
     15static int ehci_bcm63xx_setup(struct usb_hcd *hcd) 
     16{ 
     17        struct ehci_hcd *ehci = hcd_to_ehci(hcd); 
     18        int retval; 
     19 
     20        retval = ehci_halt(ehci); 
     21        if (retval) 
     22                return retval; 
     23 
     24        retval = ehci_init(hcd); 
     25        if (retval) 
     26                return retval; 
     27 
     28        ehci_reset(ehci); 
     29        ehci_port_power(ehci, 0); 
     30 
     31        return retval; 
     32} 
     33 
     34 
     35static const struct hc_driver ehci_bcm63xx_hc_driver = { 
     36        .description =          hcd_name, 
     37        .product_desc =         "BCM63XX integrated EHCI controller", 
     38        .hcd_priv_size =        sizeof(struct ehci_hcd), 
     39 
     40        .irq =                  ehci_irq, 
     41        .flags =                HCD_MEMORY | HCD_USB2, 
     42 
     43        .reset =                ehci_bcm63xx_setup, 
     44        .start =                ehci_run, 
     45        .stop =                 ehci_stop, 
     46        .shutdown =             ehci_shutdown, 
     47 
     48        .urb_enqueue =          ehci_urb_enqueue, 
     49        .urb_dequeue =          ehci_urb_dequeue, 
     50        .endpoint_disable =     ehci_endpoint_disable, 
     51 
     52        .get_frame_number =     ehci_get_frame, 
     53 
     54        .hub_status_data =      ehci_hub_status_data, 
     55        .hub_control =          ehci_hub_control, 
     56        .bus_suspend =          ehci_bus_suspend, 
     57        .bus_resume =           ehci_bus_resume, 
     58        .relinquish_port =      ehci_relinquish_port, 
     59        .port_handed_over =     ehci_port_handed_over, 
     60}; 
     61 
     62static int __devinit ehci_hcd_bcm63xx_drv_probe(struct platform_device *pdev) 
     63{ 
     64        struct resource *res_mem; 
     65        struct usb_hcd *hcd; 
     66        struct ehci_hcd *ehci; 
     67        u32 reg; 
     68        int ret, irq; 
     69 
     70        res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
     71        irq = platform_get_irq(pdev, 0);; 
     72        if (!res_mem || irq < 0) 
     73                return -ENODEV; 
     74 
     75        reg = bcm_rset_readl(RSET_USBH_PRIV, USBH_PRIV_SWAP_REG); 
     76        reg &= ~USBH_PRIV_SWAP_EHCI_DATA_MASK; 
     77        reg |= USBH_PRIV_SWAP_EHCI_ENDN_MASK; 
     78        bcm_rset_writel(RSET_USBH_PRIV, reg, USBH_PRIV_SWAP_REG); 
     79 
     80        /* 
     81         * The magic value comes for the original vendor BSP and is 
     82         * needed for USB to work. Datasheet does not help, so the 
     83         * magic value is used as-is. 
     84         */ 
     85        bcm_rset_writel(RSET_USBH_PRIV, 0x1c0020, USBH_PRIV_TEST_REG); 
     86 
     87        hcd = usb_create_hcd(&ehci_bcm63xx_hc_driver, &pdev->dev, "bcm63xx"); 
     88        if (!hcd) 
     89                return -ENOMEM; 
     90        hcd->rsrc_start = res_mem->start; 
     91        hcd->rsrc_len = res_mem->end - res_mem->start + 1; 
     92 
     93        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) { 
     94                pr_debug("request_mem_region failed\n"); 
     95                ret = -EBUSY; 
     96                goto out; 
     97        } 
     98 
     99        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len); 
     100        if (!hcd->regs) { 
     101                pr_debug("ioremap failed\n"); 
     102                ret = -EIO; 
     103                goto out1; 
     104        } 
     105 
     106        ehci = hcd_to_ehci(hcd); 
     107        ehci->big_endian_mmio = 1; 
     108        ehci->big_endian_desc = 0; 
     109        ehci->caps = hcd->regs; 
     110        ehci->regs = hcd->regs + 
     111                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase)); 
     112        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params); 
     113        ehci->sbrn = 0x20; 
     114        ehci->ignore_oc = 1; 
     115 
     116        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED); 
     117        if (ret) 
     118                goto out2; 
     119 
     120        platform_set_drvdata(pdev, hcd); 
     121        return 0; 
     122 
     123out2: 
     124        iounmap(hcd->regs); 
     125out1: 
     126        release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 
     127out: 
     128        usb_put_hcd(hcd); 
     129        return ret; 
     130} 
     131 
     132static int __devexit ehci_hcd_bcm63xx_drv_remove(struct platform_device *pdev) 
     133{ 
     134        struct usb_hcd *hcd; 
     135 
     136        hcd = platform_get_drvdata(pdev); 
     137        usb_remove_hcd(hcd); 
     138        iounmap(hcd->regs); 
     139        usb_put_hcd(hcd); 
     140        release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 
     141        platform_set_drvdata(pdev, NULL); 
     142        return 0; 
     143} 
     144 
     145static struct platform_driver ehci_hcd_bcm63xx_driver = { 
     146        .probe          = ehci_hcd_bcm63xx_drv_probe, 
     147        .remove         = __devexit_p(ehci_hcd_bcm63xx_drv_remove), 
     148        .shutdown       = usb_hcd_platform_shutdown, 
     149        .driver         = { 
     150                .name   = "bcm63xx_ehci", 
     151                .owner  = THIS_MODULE, 
     152        }, 
     153}; 
     154 
     155MODULE_ALIAS("platform:bcm63xx_ehci"); 
  • drivers/usb/host/ehci-hcd.c

    a b MODULE_LICENSE ("GPL"); 
    12671267#define PLATFORM_DRIVER         tegra_ehci_driver 
    12681268#endif 
    12691269 
     1270#ifdef CONFIG_BCM63XX 
     1271#include "ehci-bcm63xx.c" 
     1272#define PLATFORM_DRIVER         ehci_hcd_bcm63xx_driver 
     1273#endif 
     1274 
    12701275#if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \ 
    12711276    !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) && \ 
    12721277    !defined(XILINX_OF_PLATFORM_DRIVER) 
Note: See TracBrowser for help on using the repository browser.