drivers/usb/host/ohci-da8xx.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * OHCI HCD (Host Controller Driver) for USB.
   4  *
   5  * TI DA8xx (OMAP-L1x) Bus Glue
   6  *
   7  * Derived from: ohci-omap.c and ohci-s3c2410.c
   8  * Copyright (C) 2008-2009 MontaVista Software, Inc. <source@mvista.com>
   9  */
  10
  11 #include <linux/clk.h>
  12 #include <linux/gpio/consumer.h>
  13 #include <linux/io.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/jiffies.h>
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/of.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/phy/phy.h>
  21 #include <linux/platform_data/usb-davinci.h>
  22 #include <linux/regulator/consumer.h>
  23 #include <linux/usb.h>
  24 #include <linux/usb/hcd.h>
  25 #include <asm/unaligned.h>
  26
  27 #include "ohci.h"
  28
  29 #define DRIVER_DESC "DA8XX"
  30 #define DRV_NAME "ohci-da8xx"
  31
  32 static struct hc_driver __read_mostly ohci_da8xx_hc_driver;
  33
  34 static int (*orig_ohci_hub_control)(struct usb_hcd  *hcd, u16 typeReq,
  35                         u16 wValue, u16 wIndex, char *buf, u16 wLength);
  36 static int (*orig_ohci_hub_status_data)(struct usb_hcd *hcd, char *buf);
  37
  38 struct da8xx_ohci_hcd {
  39         struct usb_hcd *hcd;
  40         struct clk *usb11_clk;
  41         struct phy *usb11_phy;
  42         struct regulator *vbus_reg;
  43         struct notifier_block nb;
  44         struct gpio_desc *oc_gpio;
  45 };
  46
  47 #define to_da8xx_ohci(hcd) (struct da8xx_ohci_hcd *)(hcd_to_ohci(hcd)->priv)
  48
  49 /* Over-current indicator change bitmask */
  50 static volatile u16 ocic_mask;
  51
  52 static int ohci_da8xx_enable(struct usb_hcd *hcd)
  53 {
  54         struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
  55         int ret;
  56
  57         ret = clk_prepare_enable(da8xx_ohci->usb11_clk);
  58         if (ret)
  59                 return ret;
  60
  61         ret = phy_init(da8xx_ohci->usb11_phy);
  62         if (ret)
  63                 goto err_phy_init;
  64
  65         ret = phy_power_on(da8xx_ohci->usb11_phy);
  66         if (ret)
  67                 goto err_phy_power_on;
  68
  69         return 0;
  70
  71 err_phy_power_on:
  72         phy_exit(da8xx_ohci->usb11_phy);
  73 err_phy_init:
  74         clk_disable_unprepare(da8xx_ohci->usb11_clk);
  75
  76         return ret;
  77 }
  78
  79 static void ohci_da8xx_disable(struct usb_hcd *hcd)
  80 {
  81         struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
  82
  83         phy_power_off(da8xx_ohci->usb11_phy);
  84         phy_exit(da8xx_ohci->usb11_phy);
  85         clk_disable_unprepare(da8xx_ohci->usb11_clk);
  86 }
  87
  88 static int ohci_da8xx_set_power(struct usb_hcd *hcd, int on)
  89 {
  90         struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
  91         struct device *dev = hcd->self.controller;
  92         int ret;
  93
  94         if (!da8xx_ohci->vbus_reg)
  95                 return 0;
  96
  97         if (on) {
  98                 ret = regulator_enable(da8xx_ohci->vbus_reg);
  99                 if (ret) {
 100                         dev_err(dev, "Failed to enable regulator: %d\n", ret);
 101                         return ret;
 102                 }
 103         } else {
 104                 ret = regulator_disable(da8xx_ohci->vbus_reg);
 105                 if (ret) {
 106                         dev_err(dev, "Failed  to disable regulator: %d\n", ret);
 107                         return ret;
 108                 }
 109         }
 110
 111         return 0;
 112 }
 113
 114 static int ohci_da8xx_get_power(struct usb_hcd *hcd)
 115 {
 116         struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
 117
 118         if (da8xx_ohci->vbus_reg)
 119                 return regulator_is_enabled(da8xx_ohci->vbus_reg);
 120
 121         return 1;
 122 }
 123
 124 static int ohci_da8xx_get_oci(struct usb_hcd *hcd)
 125 {
 126         struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
 127         unsigned int flags;
 128         int ret;
 129
 130         if (da8xx_ohci->oc_gpio)
 131                 return gpiod_get_value_cansleep(da8xx_ohci->oc_gpio);
 132
 133         if (!da8xx_ohci->vbus_reg)
 134                 return 0;
 135
 136         ret = regulator_get_error_flags(da8xx_ohci->vbus_reg, &flags);
 137         if (ret)
 138                 return ret;
 139
 140         if (flags & REGULATOR_ERROR_OVER_CURRENT)
 141                 return 1;
 142
 143         return 0;
 144 }
 145
 146 static int ohci_da8xx_has_set_power(struct usb_hcd *hcd)
 147 {
 148         struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
 149
 150         if (da8xx_ohci->vbus_reg)
 151                 return 1;
 152
 153         return 0;
 154 }
 155
 156 static int ohci_da8xx_has_oci(struct usb_hcd *hcd)
 157 {
 158         struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
 159
 160         if (da8xx_ohci->oc_gpio)
 161                 return 1;
 162
 163         if (da8xx_ohci->vbus_reg)
 164                 return 1;
 165
 166         return 0;
 167 }
 168
 169 static int ohci_da8xx_has_potpgt(struct usb_hcd *hcd)
 170 {
 171         struct device *dev              = hcd->self.controller;
 172         struct da8xx_ohci_root_hub *hub = dev_get_platdata(dev);
 173
 174         if (hub && hub->potpgt)
 175                 return 1;
 176
 177         return 0;
 178 }
 179
 180 static int ohci_da8xx_regulator_event(struct notifier_block *nb,
 181                                 unsigned long event, void *data)
 182 {
 183         struct da8xx_ohci_hcd *da8xx_ohci =
 184                                 container_of(nb, struct da8xx_ohci_hcd, nb);
 185
 186         if (event & REGULATOR_EVENT_OVER_CURRENT) {
 187                 ocic_mask |= 1 << 1;
 188                 ohci_da8xx_set_power(da8xx_ohci->hcd, 0);
 189         }
 190
 191         return 0;
 192 }
 193
 194 static irqreturn_t ohci_da8xx_oc_thread(int irq, void *data)
 195 {
 196         struct da8xx_ohci_hcd *da8xx_ohci = data;
 197         struct device *dev = da8xx_ohci->hcd->self.controller;
 198         int ret;
 199
 200         if (gpiod_get_value_cansleep(da8xx_ohci->oc_gpio) &&
 201             da8xx_ohci->vbus_reg) {
 202                 ret = regulator_disable(da8xx_ohci->vbus_reg);
 203                 if (ret)
 204                         dev_err(dev, "Failed to disable regulator: %d\n", ret);
 205         }
 206
 207         return IRQ_HANDLED;
 208 }
 209
 210 static int ohci_da8xx_register_notify(struct usb_hcd *hcd)
 211 {
 212         struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd);
 213         struct device *dev              = hcd->self.controller;
 214         int ret = 0;
 215
 216         if (!da8xx_ohci->oc_gpio && da8xx_ohci->vbus_reg) {
 217                 da8xx_ohci->nb.notifier_call = ohci_da8xx_regulator_event;
 218                 ret = devm_regulator_register_notifier(da8xx_ohci->vbus_reg,
 219                                                 &da8xx_ohci->nb);
 220         }
 221
 222         if (ret)
 223                 dev_err(dev, "Failed to register notifier: %d\n", ret);
 224
 225         return ret;
 226 }
 227
 228 static int ohci_da8xx_reset(struct usb_hcd *hcd)
 229 {
 230         struct device *dev              = hcd->self.controller;
 231         struct da8xx_ohci_root_hub *hub = dev_get_platdata(dev);
 232         struct ohci_hcd *ohci           = hcd_to_ohci(hcd);
 233         int result;
 234         u32 rh_a;
 235
 236         dev_dbg(dev, "starting USB controller\n");
 237
 238         result = ohci_da8xx_enable(hcd);
 239         if (result < 0)
 240                 return result;
 241
 242         /*
 243          * DA8xx only have 1 port connected to the pins but the HC root hub
 244          * register A reports 2 ports, thus we'll have to override it...
 245          */
 246         ohci->num_ports = 1;
 247
 248         result = ohci_setup(hcd);
 249         if (result < 0) {
 250                 ohci_da8xx_disable(hcd);
 251                 return result;
 252         }
 253
 254         /*
 255          * Since we're providing a board-specific root hub port power control
 256          * and over-current reporting, we have to override the HC root hub A
 257          * register's default value, so that ohci_hub_control() could return
 258          * the correct hub descriptor...
 259          */
 260         rh_a = ohci_readl(ohci, &ohci->regs->roothub.a);
 261         if (ohci_da8xx_has_set_power(hcd)) {
 262                 rh_a &= ~RH_A_NPS;
 263                 rh_a |=  RH_A_PSM;
 264         }
 265         if (ohci_da8xx_has_oci(hcd)) {
 266                 rh_a &= ~RH_A_NOCP;
 267                 rh_a |=  RH_A_OCPM;
 268         }
 269         if (ohci_da8xx_has_potpgt(hcd)) {
 270                 rh_a &= ~RH_A_POTPGT;
 271                 rh_a |= hub->potpgt << 24;
 272         }
 273         ohci_writel(ohci, rh_a, &ohci->regs->roothub.a);
 274
 275         return result;
 276 }
 277
 278 /*
 279  * Update the status data from the hub with the over-current indicator change.
 280  */
 281 static int ohci_da8xx_hub_status_data(struct usb_hcd *hcd, char *buf)
 282 {
 283         int length              = orig_ohci_hub_status_data(hcd, buf);
 284
 285         /* See if we have OCIC bit set on port 1 */
 286         if (ocic_mask & (1 << 1)) {
 287                 dev_dbg(hcd->self.controller, "over-current indicator change "
 288                         "on port 1\n");
 289
 290                 if (!length)
 291                         length = 1;
 292
 293                 buf[0] |= 1 << 1;
 294         }
 295         return length;
 296 }
 297
 298 /*
 299  * Look at the control requests to the root hub and see if we need to override.
 300  */
 301 static int ohci_da8xx_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
 302                                   u16 wIndex, char *buf, u16 wLength)
 303 {
 304         struct device *dev              = hcd->self.controller;
 305         int temp;
 306
 307         switch (typeReq) {
 308         case GetPortStatus:
 309                 /* Check the port number */
 310                 if (wIndex != 1)
 311                         break;
 312
 313                 dev_dbg(dev, "GetPortStatus(%u)\n", wIndex);
 314
 315                 temp = roothub_portstatus(hcd_to_ohci(hcd), wIndex - 1);
 316
 317                 /* The port power status (PPS) bit defaults to 1 */
 318                 if (!ohci_da8xx_get_power(hcd))
 319                         temp &= ~RH_PS_PPS;
 320
 321                 /* The port over-current indicator (POCI) bit is always 0 */
 322                 if (ohci_da8xx_get_oci(hcd) > 0)
 323                         temp |=  RH_PS_POCI;
 324
 325                 /* The over-current indicator change (OCIC) bit is 0 too */
 326                 if (ocic_mask & (1 << wIndex))
 327                         temp |=  RH_PS_OCIC;
 328
 329                 put_unaligned(cpu_to_le32(temp), (__le32 *)buf);
 330                 return 0;
 331         case SetPortFeature:
 332                 temp = 1;
 333                 goto check_port;
 334         case ClearPortFeature:
 335                 temp = 0;
 336
 337 check_port:
 338                 /* Check the port number */
 339                 if (wIndex != 1)
 340                         break;
 341
 342                 switch (wValue) {
 343                 case USB_PORT_FEAT_POWER:
 344                         dev_dbg(dev, "%sPortFeature(%u): %s\n",
 345                                 temp ? "Set" : "Clear", wIndex, "POWER");
 346
 347                         return ohci_da8xx_set_power(hcd, temp) ? -EPIPE : 0;
 348                 case USB_PORT_FEAT_C_OVER_CURRENT:
 349                         dev_dbg(dev, "%sPortFeature(%u): %s\n",
 350                                 temp ? "Set" : "Clear", wIndex,
 351                                 "C_OVER_CURRENT");
 352
 353                         if (temp)
 354                                 ocic_mask |= 1 << wIndex;
 355                         else
 356                                 ocic_mask &= ~(1 << wIndex);
 357                         return 0;
 358                 }
 359         }
 360
 361         return orig_ohci_hub_control(hcd, typeReq, wValue,
 362                         wIndex, buf, wLength);
 363 }
 364
 365 /*-------------------------------------------------------------------------*/
 366 #ifdef CONFIG_OF
 367 static const struct of_device_id da8xx_ohci_ids[] = {
 368         { .compatible = "ti,da830-ohci" },
 369         { }
 370 };
 371 MODULE_DEVICE_TABLE(of, da8xx_ohci_ids);
 372 #endif
 373
 374 static int ohci_da8xx_probe(struct platform_device *pdev)
 375 {
 376         struct da8xx_ohci_hcd *da8xx_ohci;
 377         struct device *dev = &pdev->dev;
 378         int error, hcd_irq, oc_irq;
 379         struct usb_hcd  *hcd;
 380         struct resource *mem;
 381
 382         hcd = usb_create_hcd(&ohci_da8xx_hc_driver, dev, dev_name(dev));
 383         if (!hcd)
 384                 return -ENOMEM;
 385
 386         da8xx_ohci = to_da8xx_ohci(hcd);
 387         da8xx_ohci->hcd = hcd;
 388
 389         da8xx_ohci->usb11_clk = devm_clk_get(dev, NULL);
 390         if (IS_ERR(da8xx_ohci->usb11_clk)) {
 391                 error = PTR_ERR(da8xx_ohci->usb11_clk);
 392                 if (error != -EPROBE_DEFER)
 393                         dev_err(dev, "Failed to get clock.\n");
 394                 goto err;
 395         }
 396
 397         da8xx_ohci->usb11_phy = devm_phy_get(dev, "usb-phy");
 398         if (IS_ERR(da8xx_ohci->usb11_phy)) {
 399                 error = PTR_ERR(da8xx_ohci->usb11_phy);
 400                 if (error != -EPROBE_DEFER)
 401                         dev_err(dev, "Failed to get phy.\n");
 402                 goto err;
 403         }
 404
 405         da8xx_ohci->vbus_reg = devm_regulator_get_optional(dev, "vbus");
 406         if (IS_ERR(da8xx_ohci->vbus_reg)) {
 407                 error = PTR_ERR(da8xx_ohci->vbus_reg);
 408                 if (error == -ENODEV) {
 409                         da8xx_ohci->vbus_reg = NULL;
 410                 } else if (error == -EPROBE_DEFER) {
 411                         goto err;
 412                 } else {
 413                         dev_err(dev, "Failed to get regulator\n");
 414                         goto err;
 415                 }
 416         }
 417
 418         da8xx_ohci->oc_gpio = devm_gpiod_get_optional(dev, "oc", GPIOD_IN);
 419         if (IS_ERR(da8xx_ohci->oc_gpio)) {
 420                 error = PTR_ERR(da8xx_ohci->oc_gpio);
 421                 goto err;
 422         }
 423
 424         if (da8xx_ohci->oc_gpio) {
 425                 oc_irq = gpiod_to_irq(da8xx_ohci->oc_gpio);
 426                 if (oc_irq < 0) {
 427                         error = oc_irq;
 428                         goto err;
 429                 }
 430
 431                 error = devm_request_threaded_irq(dev, oc_irq, NULL,
 432                                 ohci_da8xx_oc_thread, IRQF_TRIGGER_RISING |
 433                                 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 434                                 "OHCI over-current indicator", da8xx_ohci);
 435                 if (error)
 436                         goto err;
 437         }
 438
 439         hcd->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &mem);
 440         if (IS_ERR(hcd->regs)) {
 441                 error = PTR_ERR(hcd->regs);
 442                 goto err;
 443         }
 444         hcd->rsrc_start = mem->start;
 445         hcd->rsrc_len = resource_size(mem);
 446
 447         hcd_irq = platform_get_irq(pdev, 0);
 448         if (hcd_irq < 0) {
 449                 error = -ENODEV;
 450                 goto err;
 451         }
 452
 453         error = usb_add_hcd(hcd, hcd_irq, 0);
 454         if (error)
 455                 goto err;
 456
 457         device_wakeup_enable(hcd->self.controller);
 458
 459         error = ohci_da8xx_register_notify(hcd);
 460         if (error)
 461                 goto err_remove_hcd;
 462
 463         return 0;
 464
 465 err_remove_hcd:
 466         usb_remove_hcd(hcd);
 467 err:
 468         usb_put_hcd(hcd);
 469         return error;
 470 }
 471
 472 static void ohci_da8xx_remove(struct platform_device *pdev)
 473 {
 474         struct usb_hcd  *hcd = platform_get_drvdata(pdev);
 475
 476         usb_remove_hcd(hcd);
 477         usb_put_hcd(hcd);
 478 }
 479
 480 #ifdef CONFIG_PM
 481 static int ohci_da8xx_suspend(struct platform_device *pdev,
 482                                 pm_message_t message)
 483 {
 484         struct usb_hcd  *hcd    = platform_get_drvdata(pdev);
 485         struct ohci_hcd *ohci   = hcd_to_ohci(hcd);
 486         bool            do_wakeup       = device_may_wakeup(&pdev->dev);
 487         int             ret;
 488
 489
 490         if (time_before(jiffies, ohci->next_statechange))
 491                 msleep(5);
 492         ohci->next_statechange = jiffies;
 493
 494         ret = ohci_suspend(hcd, do_wakeup);
 495         if (ret)
 496                 return ret;
 497
 498         ohci_da8xx_disable(hcd);
 499         hcd->state = HC_STATE_SUSPENDED;
 500
 501         return ret;
 502 }
 503
 504 static int ohci_da8xx_resume(struct platform_device *dev)
 505 {
 506         struct usb_hcd  *hcd    = platform_get_drvdata(dev);
 507         struct ohci_hcd *ohci   = hcd_to_ohci(hcd);
 508         int ret;
 509
 510         if (time_before(jiffies, ohci->next_statechange))
 511                 msleep(5);
 512         ohci->next_statechange = jiffies;
 513
 514         ret = ohci_da8xx_enable(hcd);
 515         if (ret)
 516                 return ret;
 517
 518         ohci_resume(hcd, false);
 519
 520         return 0;
 521 }
 522 #endif
 523
 524 static const struct ohci_driver_overrides da8xx_overrides __initconst = {
 525         .reset           = ohci_da8xx_reset,
 526         .extra_priv_size = sizeof(struct da8xx_ohci_hcd),
 527 };
 528
 529 /*
 530  * Driver definition to register with platform structure.
 531  */
 532 static struct platform_driver ohci_hcd_da8xx_driver = {
 533         .probe          = ohci_da8xx_probe,
 534         .remove_new     = ohci_da8xx_remove,
 535         .shutdown       = usb_hcd_platform_shutdown,
 536 #ifdef  CONFIG_PM
 537         .suspend        = ohci_da8xx_suspend,
 538         .resume         = ohci_da8xx_resume,
 539 #endif
 540         .driver         = {
 541                 .name   = DRV_NAME,
 542                 .of_match_table = of_match_ptr(da8xx_ohci_ids),
 543         },
 544 };
 545
 546 static int __init ohci_da8xx_init(void)
 547 {
 548
 549         if (usb_disabled())
 550                 return -ENODEV;
 551
 552         ohci_init_driver(&ohci_da8xx_hc_driver, &da8xx_overrides);
 553
 554         /*
 555          * The Davinci da8xx HW has some unusual quirks, which require
 556          * da8xx-specific workarounds. We override certain hc_driver
 557          * functions here to achieve that. We explicitly do not enhance
 558          * ohci_driver_overrides to allow this more easily, since this
 559          * is an unusual case, and we don't want to encourage others to
 560          * override these functions by making it too easy.
 561          */
 562
 563         orig_ohci_hub_control = ohci_da8xx_hc_driver.hub_control;
 564         orig_ohci_hub_status_data = ohci_da8xx_hc_driver.hub_status_data;
 565
 566         ohci_da8xx_hc_driver.hub_status_data     = ohci_da8xx_hub_status_data;
 567         ohci_da8xx_hc_driver.hub_control         = ohci_da8xx_hub_control;
 568
 569         return platform_driver_register(&ohci_hcd_da8xx_driver);
 570 }
 571 module_init(ohci_da8xx_init);
 572
 573 static void __exit ohci_da8xx_exit(void)
 574 {
 575         platform_driver_unregister(&ohci_hcd_da8xx_driver);
 576 }
 577 module_exit(ohci_da8xx_exit);
 578 MODULE_DESCRIPTION(DRIVER_DESC);
 579 MODULE_LICENSE("GPL");
 580 MODULE_ALIAS("platform:" DRV_NAME);