source: trunk/target/linux/brcm47xx/patches-2.6.32/270-ehci-ssb.patch @ 21543

Last change on this file since 21543 was 21543, checked in by hauke, 6 years ago

brcm47xx: refresh patches

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

    ---
     drivers/usb/host/Kconfig    |   13 ++
     drivers/usb/host/ehci-hcd.c |   12 ++
     drivers/usb/host/ehci-ssb.c |  201 ++++++++++++++++++++++++++++++++++++++++++++
     drivers/usb/host/ohci-ssb.c |   23 +++++
     4 files changed, 247 insertions(+), 2 deletions(-)
    
    a b config USB_OXU210HP_HCD 
    132132          To compile this driver as a module, choose M here: the 
    133133          module will be called oxu210hp-hcd. 
    134134 
     135config USB_EHCI_HCD_SSB 
     136        bool "EHCI support for Broadcom SSB EHCI core" 
     137        depends on USB_EHCI_HCD && SSB && EXPERIMENTAL 
     138        default n 
     139        ---help--- 
     140          Support for the Sonics Silicon Backplane (SSB) attached 
     141          Broadcom USB EHCI core. 
     142 
     143          This device is present in some embedded devices with 
     144          Broadcom based SSB bus. 
     145 
     146          If unsure, say N. 
     147 
    135148config USB_ISP116X_HCD 
    136149        tristate "ISP116X HCD support" 
    137150        depends on USB 
  • drivers/usb/host/ehci-hcd.c

    a b MODULE_LICENSE ("GPL"); 
    11421142#define PLATFORM_DRIVER         ehci_atmel_driver 
    11431143#endif 
    11441144 
    1145 #if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \ 
    1146     !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) 
     1145#ifdef CONFIG_USB_EHCI_HCD_SSB 
     1146#include "ehci-ssb.c" 
     1147#define SSB_EHCI_DRIVER         ssb_ehci_driver 
     1148#endif 
     1149 
     1150#if !defined(PCI_DRIVER) && \ 
     1151    !defined(PLATFORM_DRIVER) && \ 
     1152    !defined(PS3_SYSTEM_BUS_DRIVER) && \ 
     1153    !defined(OF_PLATFORM_DRIVER) && \ 
     1154    !defined(SSB_EHCI_DRIVER) 
    11471155#error "missing bus glue for ehci-hcd" 
    11481156#endif 
    11491157 
  • new file drivers/usb/host/ehci-ssb.c

    - +  
     1/* 
     2 * Sonics Silicon Backplane 
     3 * Broadcom USB-core EHCI driver (SSB bus glue) 
     4 * 
     5 * Copyright 2007 Steven Brown <sbrown@cortland.com> 
     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 * Derived from the USBcore related parts of Broadcom-SB 
     20 * Copyright 2005 Broadcom Corporation 
     21 * 
     22 * Licensed under the GNU/GPL. See COPYING for details. 
     23 */ 
     24#include <linux/ssb/ssb.h> 
     25 
     26#define SSB_OHCI_TMSLOW_HOSTMODE        (1 << 29) 
     27 
     28struct ssb_ehci_device { 
     29        struct ehci_hcd ehci; /* _must_ be at the beginning. */ 
     30 
     31        u32 enable_flags; 
     32}; 
     33 
     34static inline 
     35struct ssb_ehci_device *hcd_to_ssb_ehci(struct usb_hcd *hcd) 
     36{ 
     37        return (struct ssb_ehci_device *)(hcd->hcd_priv); 
     38} 
     39 
     40static int ssb_ehci_reset(struct usb_hcd *hcd) 
     41{ 
     42        struct ehci_hcd *ehci = hcd_to_ehci(hcd); 
     43        int err; 
     44 
     45        ehci->caps = hcd->regs; 
     46        ehci->regs = hcd->regs + 
     47                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase)); 
     48 
     49        dbg_hcs_params(ehci, "reset"); 
     50        dbg_hcc_params(ehci, "reset"); 
     51 
     52        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params); 
     53 
     54        err = ehci_halt(ehci); 
     55 
     56        if (err) 
     57                return err; 
     58 
     59        err = ehci_init(hcd); 
     60 
     61        if (err) 
     62                return err; 
     63 
     64        ehci_reset(ehci); 
     65 
     66        return err; 
     67} 
     68 
     69static const struct hc_driver ssb_ehci_hc_driver = { 
     70        .description            = "ssb-usb-ehci", 
     71        .product_desc           = "SSB EHCI Controller", 
     72        .hcd_priv_size          = sizeof(struct ssb_ehci_device), 
     73 
     74        .irq                    = ehci_irq, 
     75        .flags                  = HCD_MEMORY | HCD_USB2, 
     76 
     77        .reset                  = ssb_ehci_reset, 
     78        .start                  = ehci_run, 
     79        .stop                   = ehci_stop, 
     80        .shutdown               = ehci_shutdown, 
     81 
     82        .urb_enqueue            = ehci_urb_enqueue, 
     83        .urb_dequeue            = ehci_urb_dequeue, 
     84        .endpoint_disable       = ehci_endpoint_disable, 
     85        .endpoint_reset         = ehci_endpoint_reset, 
     86 
     87        .get_frame_number       = ehci_get_frame, 
     88 
     89        .hub_status_data        = ehci_hub_status_data, 
     90        .hub_control            = ehci_hub_control, 
     91        .bus_suspend            = ehci_bus_suspend, 
     92        .bus_resume             = ehci_bus_resume, 
     93        .relinquish_port        = ehci_relinquish_port, 
     94        .port_handed_over       = ehci_port_handed_over, 
     95 
     96        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete, 
     97}; 
     98 
     99static void ssb_ehci_detach(struct ssb_device *dev, struct usb_hcd *hcd) 
     100{ 
     101        if (hcd->driver->shutdown) 
     102                hcd->driver->shutdown(hcd); 
     103 
     104        usb_remove_hcd(hcd); 
     105 
     106        iounmap(hcd->regs); 
     107        release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 
     108 
     109        usb_put_hcd(hcd); 
     110} 
     111EXPORT_SYMBOL_GPL(ssb_ehci_detach); 
     112 
     113static int ssb_ehci_attach(struct ssb_device *dev, struct usb_hcd **ehci_hcd) 
     114{ 
     115        struct ssb_ehci_device *ehcidev; 
     116        struct usb_hcd *hcd; 
     117        int err = -ENOMEM; 
     118        u32 tmp, flags = 0; 
     119 
     120        hcd = usb_create_hcd(&ssb_ehci_hc_driver, dev->dev, 
     121                             dev_name(dev->dev)); 
     122        if (!hcd) 
     123                goto err_dev_disable; 
     124 
     125        ehcidev = hcd_to_ssb_ehci(hcd); 
     126        ehcidev->enable_flags = flags; 
     127        tmp = ssb_read32(dev, SSB_ADMATCH0); 
     128        hcd->rsrc_start = ssb_admatch_base(tmp) + 0x800; /* ehci core offset */ 
     129        hcd->rsrc_len = 0x100; /* ehci reg block size */ 
     130        /* 
     131         * start & size modified per sbutils.c 
     132         */ 
     133        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len); 
     134        if (!hcd->regs) 
     135                goto err_put_hcd; 
     136        err = usb_add_hcd(hcd, dev->irq, IRQF_SHARED | IRQF_DISABLED); 
     137        if (err) 
     138                goto err_iounmap; 
     139 
     140        *ehci_hcd = hcd; 
     141 
     142        return err; 
     143 
     144err_iounmap: 
     145        iounmap(hcd->regs); 
     146err_put_hcd: 
     147        usb_put_hcd(hcd); 
     148err_dev_disable: 
     149        ssb_device_disable(dev, flags); 
     150        return err; 
     151} 
     152EXPORT_SYMBOL_GPL(ssb_ehci_attach); 
     153 
     154static const struct ssb_device_id ssb_ehci_table[] = { 
     155        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_USB20_HOST, SSB_ANY_REV), 
     156        SSB_DEVTABLE_END 
     157}; 
     158MODULE_DEVICE_TABLE(ssb, ssb_ehci_table); 
  • drivers/usb/host/ohci-ssb.c

    a b  
    1717 */ 
    1818#include <linux/ssb/ssb.h> 
    1919 
     20extern int ssb_ehci_attach(struct ssb_device *dev, struct usb_hcd **hcd); 
     21extern void ssb_ehci_detach(struct ssb_device *dev, struct usb_hcd *hcd); 
    2022 
    2123#define SSB_OHCI_TMSLOW_HOSTMODE        (1 << 29) 
    2224 
    struct ssb_ohci_device { 
    2426        struct ohci_hcd ohci; /* _must_ be at the beginning. */ 
    2527 
    2628        u32 enable_flags; 
     29        struct usb_hcd *ehci_hcd; 
    2730}; 
    2831 
    2932static inline 
    static const struct hc_driver ssb_ohci_h 
    9295static void ssb_ohci_detach(struct ssb_device *dev) 
    9396{ 
    9497        struct usb_hcd *hcd = ssb_get_drvdata(dev); 
     98#ifdef CONFIG_USB_EHCI_HCD_SSB 
     99        struct ssb_ohci_device *ohcidev = hcd_to_ssb_ohci(hcd); 
     100#endif 
    95101 
    96102        usb_remove_hcd(hcd); 
    97103        iounmap(hcd->regs); 
    98104        usb_put_hcd(hcd); 
     105 
     106#ifdef CONFIG_USB_EHCI_HCD_SSB 
     107        /* 
     108         * Also detach ehci function 
     109         */ 
     110        if (dev->id.coreid == SSB_DEV_USB20_HOST) 
     111                ssb_ehci_detach(dev, ohcidev->ehci_hcd); 
     112#endif 
    99113        ssb_device_disable(dev, 0); 
    100114} 
    101115 
     116 
    102117static int ssb_ohci_attach(struct ssb_device *dev) 
    103118{ 
    104119        struct ssb_ohci_device *ohcidev; 
    static int ssb_ohci_attach(struct ssb_de 
    165180 
    166181        ssb_set_drvdata(dev, hcd); 
    167182 
     183#ifdef CONFIG_USB_EHCI_HCD_SSB 
     184        /* 
     185         * attach ehci function in this core 
     186         */ 
     187        if (dev->id.coreid == SSB_DEV_USB20_HOST) 
     188                err = ssb_ehci_attach(dev, &(ohcidev->ehci_hcd)); 
     189#endif 
     190 
    168191        return err; 
    169192 
    170193err_iounmap: 
Note: See TracBrowser for help on using the repository browser.