ohci-omap.c

   1 // SPDX-License-Identifier: GPL-1.0+
   2 /*
   3  * OHCI HCD (Host Controller Driver) for USB.
   4  *
   5  * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
   6  * (C) Copyright 2000-2005 David Brownell
   7  * (C) Copyright 2002 Hewlett-Packard Company
   8  *
   9  * OMAP Bus Glue
  10  *
  11  * Modified for OMAP by Tony Lindgren <tony@atomide.com>
  12  * Based on the 2.4 OMAP OHCI driver originally done by MontaVista Software Inc.
  13  * and on ohci-sa1111.c by Christopher Hoover <ch@hpl.hp.com>
  14  *
  15  * This file is licenced under the GPL.
  16  */
  17
  18 #include <linux/clk.h>
  19 #include <linux/dma-mapping.h>
  20 #include <linux/err.h>
  21 #include <linux/gpio/consumer.h>
  22 #include <linux/io.h>
  23 #include <linux/jiffies.h>
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/usb/otg.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/platform_data/usb-omap1.h>
  29 #include <linux/soc/ti/omap1-usb.h>
  30 #include <linux/soc/ti/omap1-mux.h>
  31 #include <linux/soc/ti/omap1-soc.h>
  32 #include <linux/soc/ti/omap1-io.h>
  33 #include <linux/signal.h>
  34 #include <linux/usb.h>
  35 #include <linux/usb/hcd.h>
  36
  37 #include "ohci.h"
  38
  39 #include <asm/io.h>
  40 #include <asm/mach-types.h>
  41
  42 #define DRIVER_DESC "OHCI OMAP driver"
  43
  44 struct ohci_omap_priv {
  45         struct clk *usb_host_ck;
  46         struct clk *usb_dc_ck;
  47         struct gpio_desc *power;
  48         struct gpio_desc *overcurrent;
  49 };
  50
  51 static const char hcd_name[] = "ohci-omap";
  52 static struct hc_driver __read_mostly ohci_omap_hc_driver;
  53
  54 #define hcd_to_ohci_omap_priv(h) \
  55         ((struct ohci_omap_priv *)hcd_to_ohci(h)->priv)
  56
  57 static void omap_ohci_clock_power(struct ohci_omap_priv *priv, int on)
  58 {
  59         if (on) {
  60                 clk_enable(priv->usb_dc_ck);
  61                 clk_enable(priv->usb_host_ck);
  62                 /* guesstimate for T5 == 1x 32K clock + APLL lock time */
  63                 udelay(100);
  64         } else {
  65                 clk_disable(priv->usb_host_ck);
  66                 clk_disable(priv->usb_dc_ck);
  67         }
  68 }
  69
  70 static void start_hnp(struct ohci_hcd *ohci)
  71 {
  72         struct usb_hcd *hcd = ohci_to_hcd(ohci);
  73         const unsigned  port = hcd->self.otg_port - 1;
  74         unsigned long   flags;
  75         u32 l;
  76
  77         otg_start_hnp(hcd->usb_phy->otg);
  78
  79         local_irq_save(flags);
  80         hcd->usb_phy->otg->state = OTG_STATE_A_SUSPEND;
  81         writel (RH_PS_PSS, &ohci->regs->roothub.portstatus [port]);
  82         l = omap_readl(OTG_CTRL);
  83         l &= ~OTG_A_BUSREQ;
  84         omap_writel(l, OTG_CTRL);
  85         local_irq_restore(flags);
  86 }
  87
  88 /*-------------------------------------------------------------------------*/
  89
  90 static int ohci_omap_reset(struct usb_hcd *hcd)
  91 {
  92         struct ohci_hcd         *ohci = hcd_to_ohci(hcd);
  93         struct omap_usb_config  *config = dev_get_platdata(hcd->self.controller);
  94         struct ohci_omap_priv   *priv = hcd_to_ohci_omap_priv(hcd);
  95         int                     need_transceiver = (config->otg != 0);
  96         int                     ret;
  97
  98         dev_dbg(hcd->self.controller, "starting USB Controller\n");
  99
 100         if (config->otg) {
 101                 hcd->self.otg_port = config->otg;
 102                 /* default/minimum OTG power budget:  8 mA */
 103                 hcd->power_budget = 8;
 104         }
 105
 106         /* XXX OMAP16xx only */
 107         if (config->ocpi_enable)
 108                 config->ocpi_enable();
 109
 110         if (IS_ENABLED(CONFIG_USB_OTG) && need_transceiver) {
 111                 hcd->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
 112                 if (!IS_ERR_OR_NULL(hcd->usb_phy)) {
 113                         int     status = otg_set_host(hcd->usb_phy->otg,
 114                                                 &ohci_to_hcd(ohci)->self);
 115                         dev_dbg(hcd->self.controller, "init %s phy, status %d\n",
 116                                         hcd->usb_phy->label, status);
 117                         if (status) {
 118                                 usb_put_phy(hcd->usb_phy);
 119                                 return status;
 120                         }
 121                 } else {
 122                         return -EPROBE_DEFER;
 123                 }
 124                 hcd->skip_phy_initialization = 1;
 125                 ohci->start_hnp = start_hnp;
 126         }
 127
 128         omap_ohci_clock_power(priv, 1);
 129
 130         if (config->lb_reset)
 131                 config->lb_reset();
 132
 133         ret = ohci_setup(hcd);
 134         if (ret < 0)
 135                 return ret;
 136
 137         if (config->otg || config->rwc) {
 138                 ohci->hc_control = OHCI_CTRL_RWC;
 139                 writel(OHCI_CTRL_RWC, &ohci->regs->control);
 140         }
 141
 142         /* board-specific power switching and overcurrent support */
 143         if (machine_is_omap_osk()) {
 144                 u32     rh = roothub_a (ohci);
 145
 146                 /* power switching (ganged by default) */
 147                 rh &= ~RH_A_NPS;
 148
 149                 /* TPS2045 switch for internal transceiver (port 1) */
 150                 if (machine_is_omap_osk()) {
 151                         ohci_to_hcd(ohci)->power_budget = 250;
 152
 153                         rh &= ~RH_A_NOCP;
 154
 155                         /* gpio9 for overcurrent detction */
 156                         omap_cfg_reg(W8_1610_GPIO9);
 157
 158                         /* for paranoia's sake:  disable USB.PUEN */
 159                         omap_cfg_reg(W4_USB_HIGHZ);
 160                 }
 161                 ohci_writel(ohci, rh, &ohci->regs->roothub.a);
 162                 ohci->flags &= ~OHCI_QUIRK_HUB_POWER;
 163         } else if (machine_is_nokia770()) {
 164                 /* We require a self-powered hub, which should have
 165                  * plenty of power. */
 166                 ohci_to_hcd(ohci)->power_budget = 0;
 167         }
 168
 169         /* FIXME hub_wq hub requests should manage power switching */
 170         if (config->transceiver_power)
 171                 return config->transceiver_power(1);
 172
 173         if (priv->power)
 174                 gpiod_set_value_cansleep(priv->power, 0);
 175
 176         /* board init will have already handled HMC and mux setup.
 177          * any external transceiver should already be initialized
 178          * too, so all configured ports use the right signaling now.
 179          */
 180
 181         return 0;
 182 }
 183
 184 /*-------------------------------------------------------------------------*/
 185
 186 /**
 187  * ohci_hcd_omap_probe - initialize OMAP-based HCDs
 188  * @pdev:       USB controller to probe
 189  *
 190  * Context: task context, might sleep
 191  *
 192  * Allocates basic resources for this USB host controller, and
 193  * then invokes the start() method for the HCD associated with it
 194  * through the hotplug entry's driver_data.
 195  */
 196 static int ohci_hcd_omap_probe(struct platform_device *pdev)
 197 {
 198         int retval, irq;
 199         struct usb_hcd *hcd = 0;
 200         struct ohci_omap_priv *priv;
 201
 202         if (pdev->num_resources != 2) {
 203                 dev_err(&pdev->dev, "invalid num_resources: %i\n",
 204                        pdev->num_resources);
 205                 return -ENODEV;
 206         }
 207
 208         if (pdev->resource[0].flags != IORESOURCE_MEM
 209                         || pdev->resource[1].flags != IORESOURCE_IRQ) {
 210                 dev_err(&pdev->dev, "invalid resource type\n");
 211                 return -ENODEV;
 212         }
 213
 214         hcd = usb_create_hcd(&ohci_omap_hc_driver, &pdev->dev,
 215                         dev_name(&pdev->dev));
 216         if (!hcd)
 217                 return -ENOMEM;
 218
 219         hcd->rsrc_start = pdev->resource[0].start;
 220         hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
 221         priv = hcd_to_ohci_omap_priv(hcd);
 222
 223         /* Obtain two optional GPIO lines */
 224         priv->power = devm_gpiod_get_optional(&pdev->dev, "power", GPIOD_ASIS);
 225         if (IS_ERR(priv->power)) {
 226                 retval = PTR_ERR(priv->power);
 227                 goto err_put_hcd;
 228         }
 229         if (priv->power)
 230                 gpiod_set_consumer_name(priv->power, "OHCI power");
 231
 232         /*
 233          * This "overcurrent" GPIO line isn't really used in the code,
 234          * but has a designated hardware function.
 235          * TODO: implement proper overcurrent handling.
 236          */
 237         priv->overcurrent = devm_gpiod_get_optional(&pdev->dev, "overcurrent",
 238                                                     GPIOD_IN);
 239         if (IS_ERR(priv->overcurrent)) {
 240                 retval = PTR_ERR(priv->overcurrent);
 241                 goto err_put_hcd;
 242         }
 243         if (priv->overcurrent)
 244                 gpiod_set_consumer_name(priv->overcurrent, "OHCI overcurrent");
 245
 246         priv->usb_host_ck = clk_get(&pdev->dev, "usb_hhc_ck");
 247         if (IS_ERR(priv->usb_host_ck)) {
 248                 retval = PTR_ERR(priv->usb_host_ck);
 249                 goto err_put_hcd;
 250         }
 251
 252         retval = clk_prepare(priv->usb_host_ck);
 253         if (retval)
 254                 goto err_put_host_ck;
 255
 256         if (!cpu_is_omap15xx())
 257                 priv->usb_dc_ck = clk_get(&pdev->dev, "usb_dc_ck");
 258         else
 259                 priv->usb_dc_ck = clk_get(&pdev->dev, "lb_ck");
 260
 261         if (IS_ERR(priv->usb_dc_ck)) {
 262                 retval = PTR_ERR(priv->usb_dc_ck);
 263                 goto err_unprepare_host_ck;
 264         }
 265
 266         retval = clk_prepare(priv->usb_dc_ck);
 267         if (retval)
 268                 goto err_put_dc_ck;
 269
 270         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
 271                 dev_dbg(&pdev->dev, "request_mem_region failed\n");
 272                 retval = -EBUSY;
 273                 goto err_unprepare_dc_ck;
 274         }
 275
 276         hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
 277         if (!hcd->regs) {
 278                 dev_err(&pdev->dev, "can't ioremap OHCI HCD\n");
 279                 retval = -ENOMEM;
 280                 goto err2;
 281         }
 282
 283         irq = platform_get_irq(pdev, 0);
 284         if (irq < 0) {
 285                 retval = irq;
 286                 goto err3;
 287         }
 288         retval = usb_add_hcd(hcd, irq, 0);
 289         if (retval)
 290                 goto err3;
 291
 292         device_wakeup_enable(hcd->self.controller);
 293         return 0;
 294 err3:
 295         iounmap(hcd->regs);
 296 err2:
 297         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 298 err_unprepare_dc_ck:
 299         clk_unprepare(priv->usb_dc_ck);
 300 err_put_dc_ck:
 301         clk_put(priv->usb_dc_ck);
 302 err_unprepare_host_ck:
 303         clk_unprepare(priv->usb_host_ck);
 304 err_put_host_ck:
 305         clk_put(priv->usb_host_ck);
 306 err_put_hcd:
 307         usb_put_hcd(hcd);
 308         return retval;
 309 }
 310
 311
 312 /* may be called with controller, bus, and devices active */
 313
 314 /**
 315  * ohci_hcd_omap_remove - shutdown processing for OMAP-based HCDs
 316  * @pdev: USB Host Controller being removed
 317  *
 318  * Context: task context, might sleep
 319  *
 320  * Reverses the effect of ohci_hcd_omap_probe(), first invoking
 321  * the HCD's stop() method.  It is always called from a thread
 322  * context, normally "rmmod", "apmd", or something similar.
 323  */
 324 static void ohci_hcd_omap_remove(struct platform_device *pdev)
 325 {
 326         struct usb_hcd  *hcd = platform_get_drvdata(pdev);
 327         struct ohci_omap_priv *priv = hcd_to_ohci_omap_priv(hcd);
 328
 329         dev_dbg(hcd->self.controller, "stopping USB Controller\n");
 330         usb_remove_hcd(hcd);
 331         omap_ohci_clock_power(priv, 0);
 332         if (!IS_ERR_OR_NULL(hcd->usb_phy)) {
 333                 (void) otg_set_host(hcd->usb_phy->otg, 0);
 334                 usb_put_phy(hcd->usb_phy);
 335         }
 336         iounmap(hcd->regs);
 337         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 338         clk_unprepare(priv->usb_dc_ck);
 339         clk_put(priv->usb_dc_ck);
 340         clk_unprepare(priv->usb_host_ck);
 341         clk_put(priv->usb_host_ck);
 342         usb_put_hcd(hcd);
 343 }
 344
 345 /*-------------------------------------------------------------------------*/
 346
 347 #ifdef  CONFIG_PM
 348
 349 static int ohci_omap_suspend(struct platform_device *pdev, pm_message_t message)
 350 {
 351         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 352         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
 353         struct ohci_omap_priv *priv = hcd_to_ohci_omap_priv(hcd);
 354         bool do_wakeup = device_may_wakeup(&pdev->dev);
 355         int ret;
 356
 357         if (time_before(jiffies, ohci->next_statechange))
 358                 msleep(5);
 359         ohci->next_statechange = jiffies;
 360
 361         ret = ohci_suspend(hcd, do_wakeup);
 362         if (ret)
 363                 return ret;
 364
 365         omap_ohci_clock_power(priv, 0);
 366         return ret;
 367 }
 368
 369 static int ohci_omap_resume(struct platform_device *dev)
 370 {
 371         struct usb_hcd  *hcd = platform_get_drvdata(dev);
 372         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
 373         struct ohci_omap_priv *priv = hcd_to_ohci_omap_priv(hcd);
 374
 375         if (time_before(jiffies, ohci->next_statechange))
 376                 msleep(5);
 377         ohci->next_statechange = jiffies;
 378
 379         omap_ohci_clock_power(priv, 1);
 380         ohci_resume(hcd, false);
 381         return 0;
 382 }
 383
 384 #endif
 385
 386 /*-------------------------------------------------------------------------*/
 387
 388 /*
 389  * Driver definition to register with the OMAP bus
 390  */
 391 static struct platform_driver ohci_hcd_omap_driver = {
 392         .probe          = ohci_hcd_omap_probe,
 393         .remove_new     = ohci_hcd_omap_remove,
 394         .shutdown       = usb_hcd_platform_shutdown,
 395 #ifdef  CONFIG_PM
 396         .suspend        = ohci_omap_suspend,
 397         .resume         = ohci_omap_resume,
 398 #endif
 399         .driver         = {
 400                 .name   = "ohci",
 401         },
 402 };
 403
 404 static const struct ohci_driver_overrides omap_overrides __initconst = {
 405         .product_desc   = "OMAP OHCI",
 406         .reset          = ohci_omap_reset,
 407         .extra_priv_size = sizeof(struct ohci_omap_priv),
 408 };
 409
 410 static int __init ohci_omap_init(void)
 411 {
 412         if (usb_disabled())
 413                 return -ENODEV;
 414
 415         ohci_init_driver(&ohci_omap_hc_driver, &omap_overrides);
 416         return platform_driver_register(&ohci_hcd_omap_driver);
 417 }
 418 module_init(ohci_omap_init);
 419
 420 static void __exit ohci_omap_cleanup(void)
 421 {
 422         platform_driver_unregister(&ohci_hcd_omap_driver);
 423 }
 424 module_exit(ohci_omap_cleanup);
 425
 426 MODULE_DESCRIPTION(DRIVER_DESC);
 427 MODULE_ALIAS("platform:ohci");
 428 MODULE_LICENSE("GPL");