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