source: trunk/target/linux/brcm47xx/patches-3.2/0031-USB-EHCI-Add-a-generic-platform-device-driver.patch @ 29756

Last change on this file since 29756 was 29756, checked in by hauke, 4 years ago

brcm47xx: add support for kernel 3.2

File size: 6.5 KB
  • drivers/usb/host/Kconfig

    From 2ade1c32109d2f17fdfc0b414411d4ee7f828706 Mon Sep 17 00:00:00 2001
    From: Hauke Mehrtens <hauke@hauke-m.de>
    Date: Sat, 26 Nov 2011 21:28:56 +0100
    Subject: [PATCH 18/30] USB: EHCI: Add a generic platform device driver
    
    This adds a generic driver for platform devices. It works like the PCI
    driver and is based on it. This is for devices which do not have an own
    bus but their EHCI controller works like a PCI controller. It will be
    used for the Broadcom bcma and ssb USB EHCI controller.
    
    Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de>
    ---
     drivers/usb/host/Kconfig         |   10 ++
     drivers/usb/host/ehci-hcd.c      |    5 +
     drivers/usb/host/ehci-platform.c |  211 ++++++++++++++++++++++++++++++++++++++
     3 files changed, 226 insertions(+), 0 deletions(-)
     create mode 100644 drivers/usb/host/ehci-platform.c
    
    a b config USB_OHCI_HCD_PLATFORM 
    388388 
    389389          If unsure, say N. 
    390390 
     391config USB_EHCI_HCD_PLATFORM 
     392        bool "Generic EHCI driver for a platform device" 
     393        depends on USB_EHCI_HCD && EXPERIMENTAL 
     394        default n 
     395        ---help--- 
     396          Adds an EHCI host driver for a generic platform device, which 
     397          provieds a memory space and an irq. 
     398 
     399          If unsure, say N. 
     400 
    391401config USB_OHCI_BIG_ENDIAN_DESC 
    392402        bool 
    393403        depends on USB_OHCI_HCD 
  • drivers/usb/host/ehci-hcd.c

    a b MODULE_LICENSE ("GPL"); 
    13291329#define PLATFORM_DRIVER         ehci_xls_driver 
    13301330#endif 
    13311331 
     1332#ifdef CONFIG_USB_EHCI_HCD_PLATFORM 
     1333#include "ehci-platform.c" 
     1334#define PLATFORM_DRIVER         ehci_platform_driver 
     1335#endif 
     1336 
    13321337#if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \ 
    13331338    !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) && \ 
    13341339    !defined(XILINX_OF_PLATFORM_DRIVER) 
  • new file drivers/usb/host/ehci-platform.c

    - +  
     1/* 
     2 * Generic platform ehci driver 
     3 * 
     4 * Copyright 2007 Steven Brown <sbrown@cortland.com> 
     5 * Copyright 2010-2011 Hauke Mehrtens <hauke@hauke-m.de> 
     6 * 
     7 * Derived from the ohci-ssb driver 
     8 * Copyright 2007 Michael Buesch <mb@bu3sch.de> 
     9 * 
     10 * Derived from the EHCI-PCI driver 
     11 * Copyright (c) 2000-2004 by David Brownell 
     12 * 
     13 * Derived from the ohci-pci driver 
     14 * Copyright 1999 Roman Weissgaerber 
     15 * Copyright 2000-2002 David Brownell 
     16 * Copyright 1999 Linus Torvalds 
     17 * Copyright 1999 Gregory P. Smith 
     18 * 
     19 * Licensed under the GNU/GPL. See COPYING for details. 
     20 */ 
     21#include <linux/platform_device.h> 
     22 
     23static int ehci_platform_reset(struct usb_hcd *hcd) 
     24{ 
     25        struct ehci_hcd *ehci = hcd_to_ehci(hcd); 
     26        int retval; 
     27 
     28        ehci->caps = hcd->regs; 
     29        ehci->regs = hcd->regs + 
     30                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase)); 
     31 
     32        dbg_hcs_params(ehci, "reset"); 
     33        dbg_hcc_params(ehci, "reset"); 
     34 
     35        /* cache this readonly data; minimize chip reads */ 
     36        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params); 
     37 
     38        retval = ehci_halt(ehci); 
     39        if (retval) 
     40                return retval; 
     41 
     42        /* data structure init */ 
     43        retval = ehci_init(hcd); 
     44        if (retval) 
     45                return retval; 
     46 
     47        ehci_reset(ehci); 
     48 
     49        ehci_port_power(ehci, 1); 
     50 
     51        return retval; 
     52} 
     53 
     54static const struct hc_driver ehci_platform_hc_driver = { 
     55        .description            = "platform-usb-ehci", 
     56        .product_desc           = "Generic Platform EHCI Controller", 
     57        .hcd_priv_size          = sizeof(struct ehci_hcd), 
     58 
     59        .irq                    = ehci_irq, 
     60        .flags                  = HCD_MEMORY | HCD_USB2, 
     61 
     62        .reset                  = ehci_platform_reset, 
     63        .start                  = ehci_run, 
     64        .stop                   = ehci_stop, 
     65        .shutdown               = ehci_shutdown, 
     66 
     67        .urb_enqueue            = ehci_urb_enqueue, 
     68        .urb_dequeue            = ehci_urb_dequeue, 
     69        .endpoint_disable       = ehci_endpoint_disable, 
     70        .endpoint_reset         = ehci_endpoint_reset, 
     71 
     72        .get_frame_number       = ehci_get_frame, 
     73 
     74        .hub_status_data        = ehci_hub_status_data, 
     75        .hub_control            = ehci_hub_control, 
     76#if defined(CONFIG_PM) 
     77        .bus_suspend            = ehci_bus_suspend, 
     78        .bus_resume             = ehci_bus_resume, 
     79#endif 
     80        .relinquish_port        = ehci_relinquish_port, 
     81        .port_handed_over       = ehci_port_handed_over, 
     82 
     83        .update_device          = ehci_update_device, 
     84 
     85        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete, 
     86}; 
     87 
     88static int ehci_platform_attach(struct platform_device *dev) 
     89{ 
     90        struct usb_hcd *hcd; 
     91        struct resource *res_irq, *res_mem; 
     92        int err = -ENOMEM; 
     93 
     94        hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev, 
     95                             dev_name(&dev->dev)); 
     96        if (!hcd) 
     97                goto err_return; 
     98 
     99        res_irq = platform_get_resource(dev, IORESOURCE_IRQ, 0); 
     100        if (!res_irq) { 
     101                err = -ENXIO; 
     102                goto err_return; 
     103        } 
     104        res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0); 
     105        if (!res_mem) { 
     106                err = -ENXIO; 
     107                goto err_return; 
     108        } 
     109        hcd->rsrc_start = res_mem->start; 
     110        hcd->rsrc_len = res_mem->end - res_mem->start + 1; 
     111 
     112        /* 
     113         * start & size modified per sbutils.c 
     114         */ 
     115        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len); 
     116        if (!hcd->regs) 
     117                goto err_put_hcd; 
     118        err = usb_add_hcd(hcd, res_irq->start, IRQF_SHARED); 
     119        if (err) 
     120                goto err_iounmap; 
     121 
     122        platform_set_drvdata(dev, hcd); 
     123 
     124        return err; 
     125 
     126err_iounmap: 
     127        iounmap(hcd->regs); 
     128err_put_hcd: 
     129        usb_put_hcd(hcd); 
     130err_return: 
     131        return err; 
     132} 
     133 
     134static int ehci_platform_probe(struct platform_device *dev) 
     135{ 
     136        int err; 
     137 
     138        if (usb_disabled()) 
     139                return -ENODEV; 
     140 
     141        err = ehci_platform_attach(dev); 
     142 
     143        return err; 
     144} 
     145 
     146static int ehci_platform_remove(struct platform_device *dev) 
     147{ 
     148        struct usb_hcd *hcd; 
     149 
     150        hcd = platform_get_drvdata(dev); 
     151        if (!hcd) 
     152                return -ENODEV; 
     153 
     154        usb_remove_hcd(hcd); 
     155        iounmap(hcd->regs); 
     156        release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 
     157        usb_put_hcd(hcd); 
     158 
     159        return 0; 
     160} 
     161 
     162static void ehci_platform_shutdown(struct platform_device *dev) 
     163{ 
     164        struct usb_hcd *hcd; 
     165 
     166        hcd = platform_get_drvdata(dev); 
     167        if (!hcd) 
     168                return; 
     169 
     170        if (hcd->driver->shutdown) 
     171                hcd->driver->shutdown(hcd); 
     172} 
     173 
     174#ifdef CONFIG_PM 
     175 
     176static int ehci_platform_suspend(struct platform_device *dev, 
     177                                 pm_message_t state) 
     178{ 
     179        return 0; 
     180} 
     181 
     182static int ehci_platform_resume(struct platform_device *dev) 
     183{ 
     184        struct usb_hcd *hcd = platform_get_drvdata(dev); 
     185 
     186        ehci_finish_controller_resume(hcd); 
     187        return 0; 
     188} 
     189 
     190#else /* !CONFIG_PM */ 
     191#define ehci_platform_suspend   NULL 
     192#define ehci_platform_resume    NULL 
     193#endif /* CONFIG_PM */ 
     194 
     195static const struct platform_device_id ehci_platform_table[] = { 
     196        { "ehci-platform", 0 }, 
     197        { } 
     198}; 
     199MODULE_DEVICE_TABLE(platform, ehci_platform_table); 
     200 
     201static struct platform_driver ehci_platform_driver = { 
     202        .id_table       = ehci_platform_table, 
     203        .probe          = ehci_platform_probe, 
     204        .remove         = ehci_platform_remove, 
     205        .shutdown       = ehci_platform_shutdown, 
     206        .suspend        = ehci_platform_suspend, 
     207        .resume         = ehci_platform_resume, 
     208        .driver         = { 
     209                .name   = "ehci-platform", 
     210        } 
     211}; 
Note: See TracBrowser for help on using the repository browser.