LXR linux/drivers/usb/host/ehci-omap.c

   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-2011 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 *
  12 * Copyright (C) 2009 Nokia Corporation
  13 *      Contact: Felipe Balbi <felipe.balbi@nokia.com>
  14 *
  15 * Based on "ehci-fsl.c" and "ehci-au1xxx.c" ehci glue layers
  16 *
  17 * This program is free software; you can redistribute it and/or modify
  18 * it under the terms of the GNU General Public License as published by
  19 * the Free Software Foundation; either version 2 of the License, or
  20 * (at your option) any later version.
  21 *
  22 * This program is distributed in the hope that it will be useful,
  23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25 * GNU General Public License for more details.
  26 *
  27 * You should have received a copy of the GNU General Public License
  28 * along with this program; if not, write to the Free Software
  29 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  30 *
  31 * TODO (last updated Feb 27, 2010):
  32 *      - add kernel-doc
  33 *      - enable AUTOIDLE
  34 *      - add suspend/resume
  35 *      - add HSIC and TLL support
  36 *      - convert to use hwmod and runtime PM
  37 */
  38
  39#include <linux/platform_device.h>
  40#include <linux/slab.h>
  41#include <linux/usb/ulpi.h>
  42#include <linux/regulator/consumer.h>
  43#include <linux/pm_runtime.h>
  44#include <linux/gpio.h>
  45#include <linux/clk.h>
  46
  47#include <linux/platform_data/usb-omap.h>
  48
  49/* EHCI Register Set */
  50#define EHCI_INSNREG04                                  (0xA0)
  51#define EHCI_INSNREG04_DISABLE_UNSUSPEND                (1 << 5)
  52#define EHCI_INSNREG05_ULPI                             (0xA4)
  53#define EHCI_INSNREG05_ULPI_CONTROL_SHIFT               31
  54#define EHCI_INSNREG05_ULPI_PORTSEL_SHIFT               24
  55#define EHCI_INSNREG05_ULPI_OPSEL_SHIFT                 22
  56#define EHCI_INSNREG05_ULPI_REGADD_SHIFT                16
  57#define EHCI_INSNREG05_ULPI_EXTREGADD_SHIFT             8
  58#define EHCI_INSNREG05_ULPI_WRDATA_SHIFT                0
  59
  60/*-------------------------------------------------------------------------*/
  61
  62static const struct hc_driver ehci_omap_hc_driver;
  63
  64
  65static inline void ehci_write(void __iomem *base, u32 reg, u32 val)
  66{
  67        __raw_writel(val, base + reg);
  68}
  69
  70static inline u32 ehci_read(void __iomem *base, u32 reg)
  71{
  72        return __raw_readl(base + reg);
  73}
  74
  75
  76static void omap_ehci_soft_phy_reset(struct usb_hcd *hcd, u8 port)
  77{
  78        unsigned long timeout = jiffies + msecs_to_jiffies(1000);
  79        unsigned reg = 0;
  80
  81        reg = ULPI_FUNC_CTRL_RESET
  82                /* FUNCTION_CTRL_SET register */
  83                | (ULPI_SET(ULPI_FUNC_CTRL) << EHCI_INSNREG05_ULPI_REGADD_SHIFT)
  84                /* Write */
  85                | (2 << EHCI_INSNREG05_ULPI_OPSEL_SHIFT)
  86                /* PORTn */
  87                | ((port + 1) << EHCI_INSNREG05_ULPI_PORTSEL_SHIFT)
  88                /* start ULPI access*/
  89                | (1 << EHCI_INSNREG05_ULPI_CONTROL_SHIFT);
  90
  91        ehci_write(hcd->regs, EHCI_INSNREG05_ULPI, reg);
  92
  93        /* Wait for ULPI access completion */
  94        while ((ehci_read(hcd->regs, EHCI_INSNREG05_ULPI)
  95                        & (1 << EHCI_INSNREG05_ULPI_CONTROL_SHIFT))) {
  96                cpu_relax();
  97
  98                if (time_after(jiffies, timeout)) {
  99                        dev_dbg(hcd->self.controller,
 100                                        "phy reset operation timed out\n");
 101                        break;
 102                }
 103        }
 104}
 105
 106static int omap_ehci_init(struct usb_hcd *hcd)
 107{
 108        struct ehci_hcd         *ehci = hcd_to_ehci(hcd);
 109        int                     rc;
 110        struct usbhs_omap_platform_data *pdata;
 111
 112        pdata = hcd->self.controller->platform_data;
 113
 114        /* Hold PHYs in reset while initializing EHCI controller */
 115        if (pdata->phy_reset) {
 116                if (gpio_is_valid(pdata->reset_gpio_port[0]))
 117                        gpio_set_value_cansleep(pdata->reset_gpio_port[0], 0);
 118
 119                if (gpio_is_valid(pdata->reset_gpio_port[1]))
 120                        gpio_set_value_cansleep(pdata->reset_gpio_port[1], 0);
 121
 122                /* Hold the PHY in RESET for enough time till DIR is high */
 123                udelay(10);
 124        }
 125
 126        /* Soft reset the PHY using PHY reset command over ULPI */
 127        if (pdata->port_mode[0] == OMAP_EHCI_PORT_MODE_PHY)
 128                omap_ehci_soft_phy_reset(hcd, 0);
 129        if (pdata->port_mode[1] == OMAP_EHCI_PORT_MODE_PHY)
 130                omap_ehci_soft_phy_reset(hcd, 1);
 131
 132        /* we know this is the memory we want, no need to ioremap again */
 133        ehci->caps = hcd->regs;
 134
 135        rc = ehci_setup(hcd);
 136
 137        if (pdata->phy_reset) {
 138                /* Hold the PHY in RESET for enough time till
 139                 * PHY is settled and ready
 140                 */
 141                udelay(10);
 142
 143                if (gpio_is_valid(pdata->reset_gpio_port[0]))
 144                        gpio_set_value_cansleep(pdata->reset_gpio_port[0], 1);
 145
 146                if (gpio_is_valid(pdata->reset_gpio_port[1]))
 147                        gpio_set_value_cansleep(pdata->reset_gpio_port[1], 1);
 148        }
 149
 150        return rc;
 151}
 152
 153static void disable_put_regulator(
 154                struct usbhs_omap_platform_data *pdata)
 155{
 156        int i;
 157
 158        for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) {
 159                if (pdata->regulator[i]) {
 160                        regulator_disable(pdata->regulator[i]);
 161                        regulator_put(pdata->regulator[i]);
 162                }
 163        }
 164}
 165
 166/* configure so an HC device and id are always provided */
 167/* always called with process context; sleeping is OK */
 168
 169/**
 170 * ehci_hcd_omap_probe - initialize TI-based HCDs
 171 *
 172 * Allocates basic resources for this USB host controller, and
 173 * then invokes the start() method for the HCD associated with it
 174 * through the hotplug entry's driver_data.
 175 */
 176static int ehci_hcd_omap_probe(struct platform_device *pdev)
 177{
 178        struct device                           *dev = &pdev->dev;
 179        struct usbhs_omap_platform_data         *pdata = dev->platform_data;
 180        struct resource                         *res;
 181        struct usb_hcd                          *hcd;
 182        void __iomem                            *regs;
 183        int                                     ret = -ENODEV;
 184        int                                     irq;
 185        int                                     i;
 186        char                                    supply[7];
 187
 188        if (usb_disabled())
 189                return -ENODEV;
 190
 191        if (!dev->parent) {
 192                dev_err(dev, "Missing parent device\n");
 193                return -ENODEV;
 194        }
 195
 196        irq = platform_get_irq_byname(pdev, "ehci-irq");
 197        if (irq < 0) {
 198                dev_err(dev, "EHCI irq failed\n");
 199                return -ENODEV;
 200        }
 201
 202        res =  platform_get_resource_byname(pdev,
 203                                IORESOURCE_MEM, "ehci");
 204        if (!res) {
 205                dev_err(dev, "UHH EHCI get resource failed\n");
 206                return -ENODEV;
 207        }
 208
 209        regs = ioremap(res->start, resource_size(res));
 210        if (!regs) {
 211                dev_err(dev, "UHH EHCI ioremap failed\n");
 212                return -ENOMEM;
 213        }
 214
 215        hcd = usb_create_hcd(&ehci_omap_hc_driver, dev,
 216                        dev_name(dev));
 217        if (!hcd) {
 218                dev_err(dev, "failed to create hcd with err %d\n", ret);
 219                ret = -ENOMEM;
 220                goto err_io;
 221        }
 222
 223        hcd->rsrc_start = res->start;
 224        hcd->rsrc_len = resource_size(res);
 225        hcd->regs = regs;
 226
 227        /* get ehci regulator and enable */
 228        for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) {
 229                if (pdata->port_mode[i] != OMAP_EHCI_PORT_MODE_PHY) {
 230                        pdata->regulator[i] = NULL;
 231                        continue;
 232                }
 233                snprintf(supply, sizeof(supply), "hsusb%d", i);
 234                pdata->regulator[i] = regulator_get(dev, supply);
 235                if (IS_ERR(pdata->regulator[i])) {
 236                        pdata->regulator[i] = NULL;
 237                        dev_dbg(dev,
 238                        "failed to get ehci port%d regulator\n", i);
 239                } else {
 240                        regulator_enable(pdata->regulator[i]);
 241                }
 242        }
 243
 244        pm_runtime_enable(dev);
 245        pm_runtime_get_sync(dev);
 246
 247        /*
 248         * An undocumented "feature" in the OMAP3 EHCI controller,
 249         * causes suspended ports to be taken out of suspend when
 250         * the USBCMD.Run/Stop bit is cleared (for example when
 251         * we do ehci_bus_suspend).
 252         * This breaks suspend-resume if the root-hub is allowed
 253         * to suspend. Writing 1 to this undocumented register bit
 254         * disables this feature and restores normal behavior.
 255         */
 256        ehci_write(regs, EHCI_INSNREG04,
 257                                EHCI_INSNREG04_DISABLE_UNSUSPEND);
 258
 259        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
 260        if (ret) {
 261                dev_err(dev, "failed to add hcd with err %d\n", ret);
 262                goto err_pm_runtime;
 263        }
 264
 265
 266        return 0;
 267
 268err_pm_runtime:
 269        disable_put_regulator(pdata);
 270        pm_runtime_put_sync(dev);
 271        usb_put_hcd(hcd);
 272
 273err_io:
 274        iounmap(regs);
 275        return ret;
 276}
 277
 278
 279/**
 280 * ehci_hcd_omap_remove - shutdown processing for EHCI HCDs
 281 * @pdev: USB Host Controller being removed
 282 *
 283 * Reverses the effect of usb_ehci_hcd_omap_probe(), first invoking
 284 * the HCD's stop() method.  It is always called from a thread
 285 * context, normally "rmmod", "apmd", or something similar.
 286 */
 287static int ehci_hcd_omap_remove(struct platform_device *pdev)
 288{
 289        struct device *dev                              = &pdev->dev;
 290        struct usb_hcd *hcd                             = dev_get_drvdata(dev);
 291
 292        usb_remove_hcd(hcd);
 293        disable_put_regulator(dev->platform_data);
 294        iounmap(hcd->regs);
 295        usb_put_hcd(hcd);
 296
 297        pm_runtime_put_sync(dev);
 298        pm_runtime_disable(dev);
 299
 300        return 0;
 301}
 302
 303static void ehci_hcd_omap_shutdown(struct platform_device *pdev)
 304{
 305        struct usb_hcd *hcd = dev_get_drvdata(&pdev->dev);
 306
 307        if (hcd->driver->shutdown)
 308                hcd->driver->shutdown(hcd);
 309}
 310
 311static struct platform_driver ehci_hcd_omap_driver = {
 312        .probe                  = ehci_hcd_omap_probe,
 313        .remove                 = ehci_hcd_omap_remove,
 314        .shutdown               = ehci_hcd_omap_shutdown,
 315        /*.suspend              = ehci_hcd_omap_suspend, */
 316        /*.resume               = ehci_hcd_omap_resume, */
 317        .driver = {
 318                .name           = "ehci-omap",
 319        }
 320};
 321
 322/*-------------------------------------------------------------------------*/
 323
 324static const struct hc_driver ehci_omap_hc_driver = {
 325        .description            = hcd_name,
 326        .product_desc           = "OMAP-EHCI Host Controller",
 327        .hcd_priv_size          = sizeof(struct ehci_hcd),
 328
 329        /*
 330         * generic hardware linkage
 331         */
 332        .irq                    = ehci_irq,
 333        .flags                  = HCD_MEMORY | HCD_USB2,
 334
 335        /*
 336         * basic lifecycle operations
 337         */
 338        .reset                  = omap_ehci_init,
 339        .start                  = ehci_run,
 340        .stop                   = ehci_stop,
 341        .shutdown               = ehci_shutdown,
 342
 343        /*
 344         * managing i/o requests and associated device resources
 345         */
 346        .urb_enqueue            = ehci_urb_enqueue,
 347        .urb_dequeue            = ehci_urb_dequeue,
 348        .endpoint_disable       = ehci_endpoint_disable,
 349        .endpoint_reset         = ehci_endpoint_reset,
 350
 351        /*
 352         * scheduling support
 353         */
 354        .get_frame_number       = ehci_get_frame,
 355
 356        /*
 357         * root hub support
 358         */
 359        .hub_status_data        = ehci_hub_status_data,
 360        .hub_control            = ehci_hub_control,
 361        .bus_suspend            = ehci_bus_suspend,
 362        .bus_resume             = ehci_bus_resume,
 363
 364        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
 365};
 366
 367MODULE_ALIAS("platform:ehci-omap");
 368MODULE_AUTHOR("Texas Instruments, Inc.");
 369MODULE_AUTHOR("Felipe Balbi <felipe.balbi@nokia.com>");
 370
 371