drivers/usb/host/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/signal.h>
  29 #include <linux/usb.h>
  30 #include <linux/usb/hcd.h>
  31
  32 #include "ohci.h"
  33
  34 #include <asm/io.h>
  35 #include <asm/mach-types.h>
  36
  37 #include <mach/mux.h>
  38
  39 #include <mach/hardware.h>
  40 #include <mach/usb.h>
  41
  42
  43 /* OMAP-1510 OHCI has its own MMU for DMA */
  44 #define OMAP1510_LB_MEMSIZE     32      /* Should be same as SDRAM size */
  45 #define OMAP1510_LB_CLOCK_DIV   0xfffec10c
  46 #define OMAP1510_LB_MMU_CTL     0xfffec208
  47 #define OMAP1510_LB_MMU_LCK     0xfffec224
  48 #define OMAP1510_LB_MMU_LD_TLB  0xfffec228
  49 #define OMAP1510_LB_MMU_CAM_H   0xfffec22c
  50 #define OMAP1510_LB_MMU_CAM_L   0xfffec230
  51 #define OMAP1510_LB_MMU_RAM_H   0xfffec234
  52 #define OMAP1510_LB_MMU_RAM_L   0xfffec238
  53
  54 #define DRIVER_DESC "OHCI OMAP driver"
  55
  56 struct ohci_omap_priv {
  57         struct clk *usb_host_ck;
  58         struct clk *usb_dc_ck;
  59         struct gpio_desc *power;
  60         struct gpio_desc *overcurrent;
  61 };
  62
  63 static const char hcd_name[] = "ohci-omap";
  64 static struct hc_driver __read_mostly ohci_omap_hc_driver;
  65
  66 #define hcd_to_ohci_omap_priv(h) \
  67         ((struct ohci_omap_priv *)hcd_to_ohci(h)->priv)
  68
  69 static void omap_ohci_clock_power(struct ohci_omap_priv *priv, int on)
  70 {
  71         if (on) {
  72                 clk_enable(priv->usb_dc_ck);
  73                 clk_enable(priv->usb_host_ck);
  74                 /* guesstimate for T5 == 1x 32K clock + APLL lock time */
  75                 udelay(100);
  76         } else {
  77                 clk_disable(priv->usb_host_ck);
  78                 clk_disable(priv->usb_dc_ck);
  79         }
  80 }
  81
  82 /*
  83  * Board specific gang-switched transceiver power on/off.
  84  * NOTE:  OSK supplies power from DC, not battery.
  85  */
  86 static int omap_ohci_transceiver_power(struct ohci_omap_priv *priv, int on)
  87 {
  88         if (on) {
  89                 if (machine_is_omap_innovator() && cpu_is_omap1510())
  90                         __raw_writeb(__raw_readb(INNOVATOR_FPGA_CAM_USB_CONTROL)
  91                                 | ((1 << 5/*usb1*/) | (1 << 3/*usb2*/)),
  92                                INNOVATOR_FPGA_CAM_USB_CONTROL);
  93                 else if (priv->power)
  94                         gpiod_set_value(priv->power, 0);
  95         } else {
  96                 if (machine_is_omap_innovator() && cpu_is_omap1510())
  97                         __raw_writeb(__raw_readb(INNOVATOR_FPGA_CAM_USB_CONTROL)
  98                                 & ~((1 << 5/*usb1*/) | (1 << 3/*usb2*/)),
  99                                INNOVATOR_FPGA_CAM_USB_CONTROL);
 100                 else if (priv->power)
 101                         gpiod_set_value(priv->power, 1);
 102         }
 103
 104         return 0;
 105 }
 106
 107 #ifdef CONFIG_ARCH_OMAP15XX
 108 /*
 109  * OMAP-1510 specific Local Bus clock on/off
 110  */
 111 static int omap_1510_local_bus_power(int on)
 112 {
 113         if (on) {
 114                 omap_writel((1 << 1) | (1 << 0), OMAP1510_LB_MMU_CTL);
 115                 udelay(200);
 116         } else {
 117                 omap_writel(0, OMAP1510_LB_MMU_CTL);
 118         }
 119
 120         return 0;
 121 }
 122
 123 /*
 124  * OMAP-1510 specific Local Bus initialization
 125  * NOTE: This assumes 32MB memory size in OMAP1510LB_MEMSIZE.
 126  *       See also arch/mach-omap/memory.h for __virt_to_dma() and
 127  *       __dma_to_virt() which need to match with the physical
 128  *       Local Bus address below.
 129  */
 130 static int omap_1510_local_bus_init(void)
 131 {
 132         unsigned int tlb;
 133         unsigned long lbaddr, physaddr;
 134
 135         omap_writel((omap_readl(OMAP1510_LB_CLOCK_DIV) & 0xfffffff8) | 0x4,
 136                OMAP1510_LB_CLOCK_DIV);
 137
 138         /* Configure the Local Bus MMU table */
 139         for (tlb = 0; tlb < OMAP1510_LB_MEMSIZE; tlb++) {
 140                 lbaddr = tlb * 0x00100000 + OMAP1510_LB_OFFSET;
 141                 physaddr = tlb * 0x00100000 + PHYS_OFFSET;
 142                 omap_writel((lbaddr & 0x0fffffff) >> 22, OMAP1510_LB_MMU_CAM_H);
 143                 omap_writel(((lbaddr & 0x003ffc00) >> 6) | 0xc,
 144                        OMAP1510_LB_MMU_CAM_L);
 145                 omap_writel(physaddr >> 16, OMAP1510_LB_MMU_RAM_H);
 146                 omap_writel((physaddr & 0x0000fc00) | 0x300, OMAP1510_LB_MMU_RAM_L);
 147                 omap_writel(tlb << 4, OMAP1510_LB_MMU_LCK);
 148                 omap_writel(0x1, OMAP1510_LB_MMU_LD_TLB);
 149         }
 150
 151         /* Enable the walking table */
 152         omap_writel(omap_readl(OMAP1510_LB_MMU_CTL) | (1 << 3), OMAP1510_LB_MMU_CTL);
 153         udelay(200);
 154
 155         return 0;
 156 }
 157 #else
 158 #define omap_1510_local_bus_power(x)    {}
 159 #define omap_1510_local_bus_init()      {}
 160 #endif
 161
 162 #ifdef  CONFIG_USB_OTG
 163
 164 static void start_hnp(struct ohci_hcd *ohci)
 165 {
 166         struct usb_hcd *hcd = ohci_to_hcd(ohci);
 167         const unsigned  port = hcd->self.otg_port - 1;
 168         unsigned long   flags;
 169         u32 l;
 170
 171         otg_start_hnp(hcd->usb_phy->otg);
 172
 173         local_irq_save(flags);
 174         hcd->usb_phy->otg->state = OTG_STATE_A_SUSPEND;
 175         writel (RH_PS_PSS, &ohci->regs->roothub.portstatus [port]);
 176         l = omap_readl(OTG_CTRL);
 177         l &= ~OTG_A_BUSREQ;
 178         omap_writel(l, OTG_CTRL);
 179         local_irq_restore(flags);
 180 }
 181
 182 #endif
 183
 184 /*-------------------------------------------------------------------------*/
 185
 186 static int ohci_omap_reset(struct usb_hcd *hcd)
 187 {
 188         struct ohci_hcd         *ohci = hcd_to_ohci(hcd);
 189         struct omap_usb_config  *config = dev_get_platdata(hcd->self.controller);
 190         struct ohci_omap_priv   *priv = hcd_to_ohci_omap_priv(hcd);
 191         int                     need_transceiver = (config->otg != 0);
 192         int                     ret;
 193
 194         dev_dbg(hcd->self.controller, "starting USB Controller\n");
 195
 196         if (config->otg) {
 197                 hcd->self.otg_port = config->otg;
 198                 /* default/minimum OTG power budget:  8 mA */
 199                 hcd->power_budget = 8;
 200         }
 201
 202         /* boards can use OTG transceivers in non-OTG modes */
 203         need_transceiver = need_transceiver
 204                         || machine_is_omap_h2() || machine_is_omap_h3();
 205
 206         /* XXX OMAP16xx only */
 207         if (config->ocpi_enable)
 208                 config->ocpi_enable();
 209
 210 #ifdef  CONFIG_USB_OTG
 211         if (need_transceiver) {
 212                 hcd->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
 213                 if (!IS_ERR_OR_NULL(hcd->usb_phy)) {
 214                         int     status = otg_set_host(hcd->usb_phy->otg,
 215                                                 &ohci_to_hcd(ohci)->self);
 216                         dev_dbg(hcd->self.controller, "init %s phy, status %d\n",
 217                                         hcd->usb_phy->label, status);
 218                         if (status) {
 219                                 usb_put_phy(hcd->usb_phy);
 220                                 return status;
 221                         }
 222                 } else {
 223                         return -EPROBE_DEFER;
 224                 }
 225                 hcd->skip_phy_initialization = 1;
 226                 ohci->start_hnp = start_hnp;
 227         }
 228 #endif
 229
 230         omap_ohci_clock_power(priv, 1);
 231
 232         if (cpu_is_omap15xx()) {
 233                 omap_1510_local_bus_power(1);
 234                 omap_1510_local_bus_init();
 235         }
 236
 237         ret = ohci_setup(hcd);
 238         if (ret < 0)
 239                 return ret;
 240
 241         if (config->otg || config->rwc) {
 242                 ohci->hc_control = OHCI_CTRL_RWC;
 243                 writel(OHCI_CTRL_RWC, &ohci->regs->control);
 244         }
 245
 246         /* board-specific power switching and overcurrent support */
 247         if (machine_is_omap_osk() || machine_is_omap_innovator()) {
 248                 u32     rh = roothub_a (ohci);
 249
 250                 /* power switching (ganged by default) */
 251                 rh &= ~RH_A_NPS;
 252
 253                 /* TPS2045 switch for internal transceiver (port 1) */
 254                 if (machine_is_omap_osk()) {
 255                         ohci_to_hcd(ohci)->power_budget = 250;
 256
 257                         rh &= ~RH_A_NOCP;
 258
 259                         /* gpio9 for overcurrent detction */
 260                         omap_cfg_reg(W8_1610_GPIO9);
 261
 262                         /* for paranoia's sake:  disable USB.PUEN */
 263                         omap_cfg_reg(W4_USB_HIGHZ);
 264                 }
 265                 ohci_writel(ohci, rh, &ohci->regs->roothub.a);
 266                 ohci->flags &= ~OHCI_QUIRK_HUB_POWER;
 267         } else if (machine_is_nokia770()) {
 268                 /* We require a self-powered hub, which should have
 269                  * plenty of power. */
 270                 ohci_to_hcd(ohci)->power_budget = 0;
 271         }
 272
 273         /* FIXME hub_wq hub requests should manage power switching */
 274         omap_ohci_transceiver_power(priv, 1);
 275
 276         /* board init will have already handled HMC and mux setup.
 277          * any external transceiver should already be initialized
 278          * too, so all configured ports use the right signaling now.
 279          */
 280
 281         return 0;
 282 }
 283
 284 /*-------------------------------------------------------------------------*/
 285
 286 /**
 287  * ohci_hcd_omap_probe - initialize OMAP-based HCDs
 288  * Context: !in_interrupt()
 289  *
 290  * Allocates basic resources for this USB host controller, and
 291  * then invokes the start() method for the HCD associated with it
 292  * through the hotplug entry's driver_data.
 293  */
 294 static int ohci_hcd_omap_probe(struct platform_device *pdev)
 295 {
 296         int retval, irq;
 297         struct usb_hcd *hcd = 0;
 298         struct ohci_omap_priv *priv;
 299
 300         if (pdev->num_resources != 2) {
 301                 dev_err(&pdev->dev, "invalid num_resources: %i\n",
 302                        pdev->num_resources);
 303                 return -ENODEV;
 304         }
 305
 306         if (pdev->resource[0].flags != IORESOURCE_MEM
 307                         || pdev->resource[1].flags != IORESOURCE_IRQ) {
 308                 dev_err(&pdev->dev, "invalid resource type\n");
 309                 return -ENODEV;
 310         }
 311
 312         hcd = usb_create_hcd(&ohci_omap_hc_driver, &pdev->dev,
 313                         dev_name(&pdev->dev));
 314         if (!hcd)
 315                 return -ENOMEM;
 316
 317         hcd->rsrc_start = pdev->resource[0].start;
 318         hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
 319         priv = hcd_to_ohci_omap_priv(hcd);
 320
 321         /* Obtain two optional GPIO lines */
 322         priv->power = devm_gpiod_get_optional(&pdev->dev, "power", GPIOD_ASIS);
 323         if (IS_ERR(priv->power)) {
 324                 retval = PTR_ERR(priv->power);
 325                 goto err_put_hcd;
 326         }
 327         if (priv->power)
 328                 gpiod_set_consumer_name(priv->power, "OHCI power");
 329
 330         /*
 331          * This "overcurrent" GPIO line isn't really used in the code,
 332          * but has a designated hardware function.
 333          * TODO: implement proper overcurrent handling.
 334          */
 335         priv->overcurrent = devm_gpiod_get_optional(&pdev->dev, "overcurrent",
 336                                                     GPIOD_IN);
 337         if (IS_ERR(priv->overcurrent)) {
 338                 retval = PTR_ERR(priv->overcurrent);
 339                 goto err_put_hcd;
 340         }
 341         if (priv->overcurrent)
 342                 gpiod_set_consumer_name(priv->overcurrent, "OHCI overcurrent");
 343
 344         priv->usb_host_ck = clk_get(&pdev->dev, "usb_hhc_ck");
 345         if (IS_ERR(priv->usb_host_ck)) {
 346                 retval = PTR_ERR(priv->usb_host_ck);
 347                 goto err_put_hcd;
 348         }
 349
 350         if (!cpu_is_omap15xx())
 351                 priv->usb_dc_ck = clk_get(&pdev->dev, "usb_dc_ck");
 352         else
 353                 priv->usb_dc_ck = clk_get(&pdev->dev, "lb_ck");
 354
 355         if (IS_ERR(priv->usb_dc_ck)) {
 356                 retval = PTR_ERR(priv->usb_dc_ck);
 357                 goto err_put_host_ck;
 358         }
 359
 360         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
 361                 dev_dbg(&pdev->dev, "request_mem_region failed\n");
 362                 retval = -EBUSY;
 363                 goto err_put_dc_ck;
 364         }
 365
 366         hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
 367         if (!hcd->regs) {
 368                 dev_err(&pdev->dev, "can't ioremap OHCI HCD\n");
 369                 retval = -ENOMEM;
 370                 goto err2;
 371         }
 372
 373         irq = platform_get_irq(pdev, 0);
 374         if (irq < 0) {
 375                 retval = -ENXIO;
 376                 goto err3;
 377         }
 378         retval = usb_add_hcd(hcd, irq, 0);
 379         if (retval)
 380                 goto err3;
 381
 382         device_wakeup_enable(hcd->self.controller);
 383         return 0;
 384 err3:
 385         iounmap(hcd->regs);
 386 err2:
 387         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 388 err_put_dc_ck:
 389         clk_put(priv->usb_dc_ck);
 390 err_put_host_ck:
 391         clk_put(priv->usb_host_ck);
 392 err_put_hcd:
 393         usb_put_hcd(hcd);
 394         return retval;
 395 }
 396
 397
 398 /* may be called with controller, bus, and devices active */
 399
 400 /**
 401  * ohci_hcd_omap_remove - shutdown processing for OMAP-based HCDs
 402  * @dev: USB Host Controller being removed
 403  * Context: !in_interrupt()
 404  *
 405  * Reverses the effect of ohci_hcd_omap_probe(), first invoking
 406  * the HCD's stop() method.  It is always called from a thread
 407  * context, normally "rmmod", "apmd", or something similar.
 408  */
 409 static int ohci_hcd_omap_remove(struct platform_device *pdev)
 410 {
 411         struct usb_hcd  *hcd = platform_get_drvdata(pdev);
 412         struct ohci_omap_priv *priv = hcd_to_ohci_omap_priv(hcd);
 413
 414         dev_dbg(hcd->self.controller, "stopping USB Controller\n");
 415         usb_remove_hcd(hcd);
 416         omap_ohci_clock_power(priv, 0);
 417         if (!IS_ERR_OR_NULL(hcd->usb_phy)) {
 418                 (void) otg_set_host(hcd->usb_phy->otg, 0);
 419                 usb_put_phy(hcd->usb_phy);
 420         }
 421         iounmap(hcd->regs);
 422         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 423         clk_put(priv->usb_dc_ck);
 424         clk_put(priv->usb_host_ck);
 425         usb_put_hcd(hcd);
 426         return 0;
 427 }
 428
 429 /*-------------------------------------------------------------------------*/
 430
 431 #ifdef  CONFIG_PM
 432
 433 static int ohci_omap_suspend(struct platform_device *pdev, pm_message_t message)
 434 {
 435         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 436         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
 437         struct ohci_omap_priv *priv = hcd_to_ohci_omap_priv(hcd);
 438         bool do_wakeup = device_may_wakeup(&pdev->dev);
 439         int ret;
 440
 441         if (time_before(jiffies, ohci->next_statechange))
 442                 msleep(5);
 443         ohci->next_statechange = jiffies;
 444
 445         ret = ohci_suspend(hcd, do_wakeup);
 446         if (ret)
 447                 return ret;
 448
 449         omap_ohci_clock_power(priv, 0);
 450         return ret;
 451 }
 452
 453 static int ohci_omap_resume(struct platform_device *dev)
 454 {
 455         struct usb_hcd  *hcd = platform_get_drvdata(dev);
 456         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
 457         struct ohci_omap_priv *priv = hcd_to_ohci_omap_priv(hcd);
 458
 459         if (time_before(jiffies, ohci->next_statechange))
 460                 msleep(5);
 461         ohci->next_statechange = jiffies;
 462
 463         omap_ohci_clock_power(priv, 1);
 464         ohci_resume(hcd, false);
 465         return 0;
 466 }
 467
 468 #endif
 469
 470 /*-------------------------------------------------------------------------*/
 471
 472 /*
 473  * Driver definition to register with the OMAP bus
 474  */
 475 static struct platform_driver ohci_hcd_omap_driver = {
 476         .probe          = ohci_hcd_omap_probe,
 477         .remove         = ohci_hcd_omap_remove,
 478         .shutdown       = usb_hcd_platform_shutdown,
 479 #ifdef  CONFIG_PM
 480         .suspend        = ohci_omap_suspend,
 481         .resume         = ohci_omap_resume,
 482 #endif
 483         .driver         = {
 484                 .name   = "ohci",
 485         },
 486 };
 487
 488 static const struct ohci_driver_overrides omap_overrides __initconst = {
 489         .product_desc   = "OMAP OHCI",
 490         .reset          = ohci_omap_reset,
 491         .extra_priv_size = sizeof(struct ohci_omap_priv),
 492 };
 493
 494 static int __init ohci_omap_init(void)
 495 {
 496         if (usb_disabled())
 497                 return -ENODEV;
 498
 499         pr_info("%s: " DRIVER_DESC "\n", hcd_name);
 500
 501         ohci_init_driver(&ohci_omap_hc_driver, &omap_overrides);
 502         return platform_driver_register(&ohci_hcd_omap_driver);
 503 }
 504 module_init(ohci_omap_init);
 505
 506 static void __exit ohci_omap_cleanup(void)
 507 {
 508         platform_driver_unregister(&ohci_hcd_omap_driver);
 509 }
 510 module_exit(ohci_omap_cleanup);
 511
 512 MODULE_DESCRIPTION(DRIVER_DESC);
 513 MODULE_ALIAS("platform:ohci");
 514 MODULE_LICENSE("GPL");