drivers/usb/host/ohci-da8xx.c

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