linux/drivers/usb/host/ehci-omap.c
<<
>>
Prefs
   1/*
   2 * ehci-omap.c - driver for USBHOST on OMAP3/4 processors
   3 *
   4 * Bus Glue for the EHCI controllers in OMAP3/4
   5 * Tested on several OMAP3 boards, and OMAP4 Pandaboard
   6 *
   7 * Copyright (C) 2007-2013 Texas Instruments, Inc.
   8 *      Author: Vikram Pandita <vikram.pandita@ti.com>
   9 *      Author: Anand Gadiyar <gadiyar@ti.com>
  10 *      Author: Keshava Munegowda <keshava_mgowda@ti.com>
  11 *      Author: Roger Quadros <rogerq@ti.com>
  12 *
  13 * Copyright (C) 2009 Nokia Corporation
  14 *      Contact: Felipe Balbi <felipe.balbi@nokia.com>
  15 *
  16 * Based on "ehci-fsl.c" and "ehci-au1xxx.c" ehci glue layers
  17 *
  18 * This program is free software; you can redistribute it and/or modify
  19 * it under the terms of the GNU General Public License as published by
  20 * the Free Software Foundation; either version 2 of the License, or
  21 * (at your option) any later version.
  22 *
  23 * This program is distributed in the hope that it will be useful,
  24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26 * GNU General Public License for more details.
  27 *
  28 * You should have received a copy of the GNU General Public License
  29 * along with this program; if not, write to the Free Software
  30 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  31 *
  32 */
  33
  34#include <linux/kernel.h>
  35#include <linux/module.h>
  36#include <linux/io.h>
  37#include <linux/platform_device.h>
  38#include <linux/slab.h>
  39#include <linux/usb/ulpi.h>
  40#include <linux/pm_runtime.h>
  41#include <linux/gpio.h>
  42#include <linux/clk.h>
  43#include <linux/usb.h>
  44#include <linux/usb/hcd.h>
  45#include <linux/of.h>
  46#include <linux/dma-mapping.h>
  47
  48#include "ehci.h"
  49
  50#include <linux/platform_data/usb-omap.h>
  51
  52/* EHCI Register Set */
  53#define EHCI_INSNREG04                                  (0xA0)
  54#define EHCI_INSNREG04_DISABLE_UNSUSPEND                (1 << 5)
  55#define EHCI_INSNREG05_ULPI                             (0xA4)
  56#define EHCI_INSNREG05_ULPI_CONTROL_SHIFT               31
  57#define EHCI_INSNREG05_ULPI_PORTSEL_SHIFT               24
  58#define EHCI_INSNREG05_ULPI_OPSEL_SHIFT                 22
  59#define EHCI_INSNREG05_ULPI_REGADD_SHIFT                16
  60#define EHCI_INSNREG05_ULPI_EXTREGADD_SHIFT             8
  61#define EHCI_INSNREG05_ULPI_WRDATA_SHIFT                0
  62
  63#define DRIVER_DESC "OMAP-EHCI Host Controller driver"
  64
  65static const char hcd_name[] = "ehci-omap";
  66
  67/*-------------------------------------------------------------------------*/
  68
  69struct omap_hcd {
  70        struct usb_phy *phy[OMAP3_HS_USB_PORTS]; /* one PHY for each port */
  71        int nports;
  72};
  73
  74static inline void ehci_write(void __iomem *base, u32 reg, u32 val)
  75{
  76        __raw_writel(val, base + reg);
  77}
  78
  79static inline u32 ehci_read(void __iomem *base, u32 reg)
  80{
  81        return __raw_readl(base + reg);
  82}
  83
  84/* configure so an HC device and id are always provided */
  85/* always called with process context; sleeping is OK */
  86
  87static struct hc_driver __read_mostly ehci_omap_hc_driver;
  88
  89static const struct ehci_driver_overrides ehci_omap_overrides __initdata = {
  90        .extra_priv_size = sizeof(struct omap_hcd),
  91};
  92
  93/**
  94 * ehci_hcd_omap_probe - initialize TI-based HCDs
  95 *
  96 * Allocates basic resources for this USB host controller, and
  97 * then invokes the start() method for the HCD associated with it
  98 * through the hotplug entry's driver_data.
  99 */
 100static int ehci_hcd_omap_probe(struct platform_device *pdev)
 101{
 102        struct device *dev = &pdev->dev;
 103        struct usbhs_omap_platform_data *pdata = dev->platform_data;
 104        struct resource *res;
 105        struct usb_hcd  *hcd;
 106        void __iomem *regs;
 107        int ret = -ENODEV;
 108        int irq;
 109        int i;
 110        struct omap_hcd *omap;
 111
 112        if (usb_disabled())
 113                return -ENODEV;
 114
 115        if (!dev->parent) {
 116                dev_err(dev, "Missing parent device\n");
 117                return -ENODEV;
 118        }
 119
 120        /* For DT boot, get platform data from parent. i.e. usbhshost */
 121        if (dev->of_node) {
 122                pdata = dev->parent->platform_data;
 123                dev->platform_data = pdata;
 124        }
 125
 126        if (!pdata) {
 127                dev_err(dev, "Missing platform data\n");
 128                return -ENODEV;
 129        }
 130
 131        irq = platform_get_irq(pdev, 0);
 132        if (irq < 0) {
 133                dev_err(dev, "EHCI irq failed\n");
 134                return -ENODEV;
 135        }
 136
 137        res =  platform_get_resource(pdev, IORESOURCE_MEM, 0);
 138        regs = devm_ioremap_resource(dev, res);
 139        if (IS_ERR(regs))
 140                return PTR_ERR(regs);
 141
 142        /*
 143         * Right now device-tree probed devices don't get dma_mask set.
 144         * Since shared usb code relies on it, set it here for now.
 145         * Once we have dma capability bindings this can go away.
 146         */
 147        if (!dev->dma_mask)
 148                dev->dma_mask = &dev->coherent_dma_mask;
 149        if (!dev->coherent_dma_mask)
 150                dev->coherent_dma_mask = DMA_BIT_MASK(32);
 151
 152        hcd = usb_create_hcd(&ehci_omap_hc_driver, dev,
 153                        dev_name(dev));
 154        if (!hcd) {
 155                dev_err(dev, "Failed to create HCD\n");
 156                return -ENOMEM;
 157        }
 158
 159        hcd->rsrc_start = res->start;
 160        hcd->rsrc_len = resource_size(res);
 161        hcd->regs = regs;
 162        hcd_to_ehci(hcd)->caps = regs;
 163
 164        omap = (struct omap_hcd *)hcd_to_ehci(hcd)->priv;
 165        omap->nports = pdata->nports;
 166
 167        platform_set_drvdata(pdev, hcd);
 168
 169        /* get the PHY devices if needed */
 170        for (i = 0 ; i < omap->nports ; i++) {
 171                struct usb_phy *phy;
 172
 173                /* get the PHY device */
 174                if (dev->of_node)
 175                        phy = devm_usb_get_phy_by_phandle(dev, "phys", i);
 176                else
 177                        phy = devm_usb_get_phy_dev(dev, i);
 178                if (IS_ERR(phy)) {
 179                        /* Don't bail out if PHY is not absolutely necessary */
 180                        if (pdata->port_mode[i] != OMAP_EHCI_PORT_MODE_PHY)
 181                                continue;
 182
 183                        ret = PTR_ERR(phy);
 184                        dev_err(dev, "Can't get PHY device for port %d: %d\n",
 185                                        i, ret);
 186                        goto err_phy;
 187                }
 188
 189                omap->phy[i] = phy;
 190        }
 191
 192        pm_runtime_enable(dev);
 193        pm_runtime_get_sync(dev);
 194
 195        /*
 196         * An undocumented "feature" in the OMAP3 EHCI controller,
 197         * causes suspended ports to be taken out of suspend when
 198         * the USBCMD.Run/Stop bit is cleared (for example when
 199         * we do ehci_bus_suspend).
 200         * This breaks suspend-resume if the root-hub is allowed
 201         * to suspend. Writing 1 to this undocumented register bit
 202         * disables this feature and restores normal behavior.
 203         */
 204        ehci_write(regs, EHCI_INSNREG04,
 205                                EHCI_INSNREG04_DISABLE_UNSUSPEND);
 206
 207        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
 208        if (ret) {
 209                dev_err(dev, "failed to add hcd with err %d\n", ret);
 210                goto err_pm_runtime;
 211        }
 212
 213        /*
 214         * Bring PHYs out of reset.
 215         * Even though HSIC mode is a PHY-less mode, the reset
 216         * line exists between the chips and can be modelled
 217         * as a PHY device for reset control.
 218         */
 219        for (i = 0; i < omap->nports; i++) {
 220                if (!omap->phy[i])
 221                        continue;
 222
 223                usb_phy_init(omap->phy[i]);
 224                /* bring PHY out of suspend */
 225                usb_phy_set_suspend(omap->phy[i], 0);
 226        }
 227
 228        return 0;
 229
 230err_pm_runtime:
 231        pm_runtime_put_sync(dev);
 232
 233err_phy:
 234        for (i = 0; i < omap->nports; i++) {
 235                if (omap->phy[i])
 236                        usb_phy_shutdown(omap->phy[i]);
 237        }
 238
 239        usb_put_hcd(hcd);
 240
 241        return ret;
 242}
 243
 244
 245/**
 246 * ehci_hcd_omap_remove - shutdown processing for EHCI HCDs
 247 * @pdev: USB Host Controller being removed
 248 *
 249 * Reverses the effect of usb_ehci_hcd_omap_probe(), first invoking
 250 * the HCD's stop() method.  It is always called from a thread
 251 * context, normally "rmmod", "apmd", or something similar.
 252 */
 253static int ehci_hcd_omap_remove(struct platform_device *pdev)
 254{
 255        struct device *dev = &pdev->dev;
 256        struct usb_hcd *hcd = dev_get_drvdata(dev);
 257        struct omap_hcd *omap = (struct omap_hcd *)hcd_to_ehci(hcd)->priv;
 258        int i;
 259
 260        usb_remove_hcd(hcd);
 261
 262        for (i = 0; i < omap->nports; i++) {
 263                if (omap->phy[i])
 264                        usb_phy_shutdown(omap->phy[i]);
 265        }
 266
 267        usb_put_hcd(hcd);
 268        pm_runtime_put_sync(dev);
 269        pm_runtime_disable(dev);
 270
 271        return 0;
 272}
 273
 274static void ehci_hcd_omap_shutdown(struct platform_device *pdev)
 275{
 276        struct usb_hcd *hcd = dev_get_drvdata(&pdev->dev);
 277
 278        if (hcd->driver->shutdown)
 279                hcd->driver->shutdown(hcd);
 280}
 281
 282static const struct of_device_id omap_ehci_dt_ids[] = {
 283        { .compatible = "ti,ehci-omap" },
 284        { }
 285};
 286
 287MODULE_DEVICE_TABLE(of, omap_ehci_dt_ids);
 288
 289static struct platform_driver ehci_hcd_omap_driver = {
 290        .probe                  = ehci_hcd_omap_probe,
 291        .remove                 = ehci_hcd_omap_remove,
 292        .shutdown               = ehci_hcd_omap_shutdown,
 293        /*.suspend              = ehci_hcd_omap_suspend, */
 294        /*.resume               = ehci_hcd_omap_resume, */
 295        .driver = {
 296                .name           = hcd_name,
 297                .of_match_table = of_match_ptr(omap_ehci_dt_ids),
 298        }
 299};
 300
 301/*-------------------------------------------------------------------------*/
 302
 303static int __init ehci_omap_init(void)
 304{
 305        if (usb_disabled())
 306                return -ENODEV;
 307
 308        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
 309
 310        ehci_init_driver(&ehci_omap_hc_driver, &ehci_omap_overrides);
 311        return platform_driver_register(&ehci_hcd_omap_driver);
 312}
 313module_init(ehci_omap_init);
 314
 315static void __exit ehci_omap_cleanup(void)
 316{
 317        platform_driver_unregister(&ehci_hcd_omap_driver);
 318}
 319module_exit(ehci_omap_cleanup);
 320
 321MODULE_ALIAS("platform:ehci-omap");
 322MODULE_AUTHOR("Texas Instruments, Inc.");
 323MODULE_AUTHOR("Felipe Balbi <felipe.balbi@nokia.com>");
 324MODULE_AUTHOR("Roger Quadros <rogerq@ti.com>");
 325
 326MODULE_DESCRIPTION(DRIVER_DESC);
 327MODULE_LICENSE("GPL");
 328