drivers/usb/host/ohci-at91.c

   1 /*
   2  * OHCI HCD (Host Controller Driver) for USB.
   3  *
   4  *  Copyright (C) 2004 SAN People (Pty) Ltd.
   5  *  Copyright (C) 2005 Thibaut VARENE <varenet@parisc-linux.org>
   6  *
   7  * AT91 Bus Glue
   8  *
   9  * Based on fragments of 2.4 driver by Rick Bronson.
  10  * Based on ohci-omap.c
  11  *
  12  * This file is licenced under the GPL.
  13  */
  14
  15 #include <linux/clk.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/of_platform.h>
  18 #include <linux/of_gpio.h>
  19 #include <linux/platform_data/atmel.h>
  20
  21 #include <mach/hardware.h>
  22 #include <asm/gpio.h>
  23
  24 #include <mach/cpu.h>
  25
  26 #ifndef CONFIG_ARCH_AT91
  27 #error "CONFIG_ARCH_AT91 must be defined."
  28 #endif
  29
  30 #define valid_port(index)       ((index) >= 0 && (index) < AT91_MAX_USBH_PORTS)
  31 #define at91_for_each_port(index)       \
  32                 for ((index) = 0; (index) < AT91_MAX_USBH_PORTS; (index)++)
  33
  34 /* interface, function and usb clocks; sometimes also an AHB clock */
  35 static struct clk *iclk, *fclk, *uclk, *hclk;
  36 static int clocked;
  37
  38 extern int usb_disabled(void);
  39
  40 /*-------------------------------------------------------------------------*/
  41
  42 static void at91_start_clock(void)
  43 {
  44         if (IS_ENABLED(CONFIG_COMMON_CLK)) {
  45                 clk_set_rate(uclk, 48000000);
  46                 clk_prepare_enable(uclk);
  47         }
  48         clk_prepare_enable(hclk);
  49         clk_prepare_enable(iclk);
  50         clk_prepare_enable(fclk);
  51         clocked = 1;
  52 }
  53
  54 static void at91_stop_clock(void)
  55 {
  56         clk_disable_unprepare(fclk);
  57         clk_disable_unprepare(iclk);
  58         clk_disable_unprepare(hclk);
  59         if (IS_ENABLED(CONFIG_COMMON_CLK))
  60                 clk_disable_unprepare(uclk);
  61         clocked = 0;
  62 }
  63
  64 static void at91_start_hc(struct platform_device *pdev)
  65 {
  66         struct usb_hcd *hcd = platform_get_drvdata(pdev);
  67         struct ohci_regs __iomem *regs = hcd->regs;
  68
  69         dev_dbg(&pdev->dev, "start\n");
  70
  71         /*
  72          * Start the USB clocks.
  73          */
  74         at91_start_clock();
  75
  76         /*
  77          * The USB host controller must remain in reset.
  78          */
  79         writel(0, &regs->control);
  80 }
  81
  82 static void at91_stop_hc(struct platform_device *pdev)
  83 {
  84         struct usb_hcd *hcd = platform_get_drvdata(pdev);
  85         struct ohci_regs __iomem *regs = hcd->regs;
  86
  87         dev_dbg(&pdev->dev, "stop\n");
  88
  89         /*
  90          * Put the USB host controller into reset.
  91          */
  92         writel(0, &regs->control);
  93
  94         /*
  95          * Stop the USB clocks.
  96          */
  97         at91_stop_clock();
  98 }
  99
 100
 101 /*-------------------------------------------------------------------------*/
 102
 103 static void usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *);
 104
 105 /* configure so an HC device and id are always provided */
 106 /* always called with process context; sleeping is OK */
 107
 108
 109 /**
 110  * usb_hcd_at91_probe - initialize AT91-based HCDs
 111  * Context: !in_interrupt()
 112  *
 113  * Allocates basic resources for this USB host controller, and
 114  * then invokes the start() method for the HCD associated with it
 115  * through the hotplug entry's driver_data.
 116  */
 117 static int usb_hcd_at91_probe(const struct hc_driver *driver,
 118                         struct platform_device *pdev)
 119 {
 120         int retval;
 121         struct usb_hcd *hcd = NULL;
 122
 123         if (pdev->num_resources != 2) {
 124                 pr_debug("hcd probe: invalid num_resources");
 125                 return -ENODEV;
 126         }
 127
 128         if ((pdev->resource[0].flags != IORESOURCE_MEM)
 129                         || (pdev->resource[1].flags != IORESOURCE_IRQ)) {
 130                 pr_debug("hcd probe: invalid resource type\n");
 131                 return -ENODEV;
 132         }
 133
 134         hcd = usb_create_hcd(driver, &pdev->dev, "at91");
 135         if (!hcd)
 136                 return -ENOMEM;
 137         hcd->rsrc_start = pdev->resource[0].start;
 138         hcd->rsrc_len = resource_size(&pdev->resource[0]);
 139
 140         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
 141                 pr_debug("request_mem_region failed\n");
 142                 retval = -EBUSY;
 143                 goto err1;
 144         }
 145
 146         hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
 147         if (!hcd->regs) {
 148                 pr_debug("ioremap failed\n");
 149                 retval = -EIO;
 150                 goto err2;
 151         }
 152
 153         iclk = clk_get(&pdev->dev, "ohci_clk");
 154         if (IS_ERR(iclk)) {
 155                 dev_err(&pdev->dev, "failed to get ohci_clk\n");
 156                 retval = PTR_ERR(iclk);
 157                 goto err3;
 158         }
 159         fclk = clk_get(&pdev->dev, "uhpck");
 160         if (IS_ERR(fclk)) {
 161                 dev_err(&pdev->dev, "failed to get uhpck\n");
 162                 retval = PTR_ERR(fclk);
 163                 goto err4;
 164         }
 165         hclk = clk_get(&pdev->dev, "hclk");
 166         if (IS_ERR(hclk)) {
 167                 dev_err(&pdev->dev, "failed to get hclk\n");
 168                 retval = PTR_ERR(hclk);
 169                 goto err5;
 170         }
 171         if (IS_ENABLED(CONFIG_COMMON_CLK)) {
 172                 uclk = clk_get(&pdev->dev, "usb_clk");
 173                 if (IS_ERR(uclk)) {
 174                         dev_err(&pdev->dev, "failed to get uclk\n");
 175                         retval = PTR_ERR(uclk);
 176                         goto err6;
 177                 }
 178         }
 179
 180         at91_start_hc(pdev);
 181         ohci_hcd_init(hcd_to_ohci(hcd));
 182
 183         retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED);
 184         if (retval == 0)
 185                 return retval;
 186
 187         /* Error handling */
 188         at91_stop_hc(pdev);
 189
 190         if (IS_ENABLED(CONFIG_COMMON_CLK))
 191                 clk_put(uclk);
 192  err6:
 193         clk_put(hclk);
 194  err5:
 195         clk_put(fclk);
 196  err4:
 197         clk_put(iclk);
 198
 199  err3:
 200         iounmap(hcd->regs);
 201
 202  err2:
 203         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 204
 205  err1:
 206         usb_put_hcd(hcd);
 207         return retval;
 208 }
 209
 210
 211 /* may be called with controller, bus, and devices active */
 212
 213 /**
 214  * usb_hcd_at91_remove - shutdown processing for AT91-based HCDs
 215  * @dev: USB Host Controller being removed
 216  * Context: !in_interrupt()
 217  *
 218  * Reverses the effect of usb_hcd_at91_probe(), first invoking
 219  * the HCD's stop() method.  It is always called from a thread
 220  * context, "rmmod" or something similar.
 221  *
 222  */
 223 static void usb_hcd_at91_remove(struct usb_hcd *hcd,
 224                                 struct platform_device *pdev)
 225 {
 226         usb_remove_hcd(hcd);
 227         at91_stop_hc(pdev);
 228         iounmap(hcd->regs);
 229         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 230         usb_put_hcd(hcd);
 231
 232         if (IS_ENABLED(CONFIG_COMMON_CLK))
 233                 clk_put(uclk);
 234         clk_put(hclk);
 235         clk_put(fclk);
 236         clk_put(iclk);
 237         fclk = iclk = hclk = NULL;
 238 }
 239
 240 /*-------------------------------------------------------------------------*/
 241
 242 static int
 243 ohci_at91_reset (struct usb_hcd *hcd)
 244 {
 245         struct at91_usbh_data   *board = dev_get_platdata(hcd->self.controller);
 246         struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
 247         int                     ret;
 248
 249         if ((ret = ohci_init(ohci)) < 0)
 250                 return ret;
 251
 252         ohci->num_ports = board->ports;
 253         return 0;
 254 }
 255
 256 static int
 257 ohci_at91_start (struct usb_hcd *hcd)
 258 {
 259         struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
 260         int                     ret;
 261
 262         if ((ret = ohci_run(ohci)) < 0) {
 263                 dev_err(hcd->self.controller, "can't start %s\n",
 264                         hcd->self.bus_name);
 265                 ohci_stop(hcd);
 266                 return ret;
 267         }
 268         return 0;
 269 }
 270
 271 static void ohci_at91_usb_set_power(struct at91_usbh_data *pdata, int port, int enable)
 272 {
 273         if (!valid_port(port))
 274                 return;
 275
 276         if (!gpio_is_valid(pdata->vbus_pin[port]))
 277                 return;
 278
 279         gpio_set_value(pdata->vbus_pin[port],
 280                        pdata->vbus_pin_active_low[port] ^ enable);
 281 }
 282
 283 static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port)
 284 {
 285         if (!valid_port(port))
 286                 return -EINVAL;
 287
 288         if (!gpio_is_valid(pdata->vbus_pin[port]))
 289                 return -EINVAL;
 290
 291         return gpio_get_value(pdata->vbus_pin[port]) ^
 292                 pdata->vbus_pin_active_low[port];
 293 }
 294
 295 /*
 296  * Update the status data from the hub with the over-current indicator change.
 297  */
 298 static int ohci_at91_hub_status_data(struct usb_hcd *hcd, char *buf)
 299 {
 300         struct at91_usbh_data *pdata = dev_get_platdata(hcd->self.controller);
 301         int length = ohci_hub_status_data(hcd, buf);
 302         int port;
 303
 304         at91_for_each_port(port) {
 305                 if (pdata->overcurrent_changed[port]) {
 306                         if (!length)
 307                                 length = 1;
 308                         buf[0] |= 1 << (port + 1);
 309                 }
 310         }
 311
 312         return length;
 313 }
 314
 315 /*
 316  * Look at the control requests to the root hub and see if we need to override.
 317  */
 318 static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
 319                                  u16 wIndex, char *buf, u16 wLength)
 320 {
 321         struct at91_usbh_data *pdata = dev_get_platdata(hcd->self.controller);
 322         struct usb_hub_descriptor *desc;
 323         int ret = -EINVAL;
 324         u32 *data = (u32 *)buf;
 325
 326         dev_dbg(hcd->self.controller,
 327                 "ohci_at91_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n",
 328                 hcd, typeReq, wValue, wIndex, buf, wLength);
 329
 330         wIndex--;
 331
 332         switch (typeReq) {
 333         case SetPortFeature:
 334                 if (wValue == USB_PORT_FEAT_POWER) {
 335                         dev_dbg(hcd->self.controller, "SetPortFeat: POWER\n");
 336                         if (valid_port(wIndex)) {
 337                                 ohci_at91_usb_set_power(pdata, wIndex, 1);
 338                                 ret = 0;
 339                         }
 340
 341                         goto out;
 342                 }
 343                 break;
 344
 345         case ClearPortFeature:
 346                 switch (wValue) {
 347                 case USB_PORT_FEAT_C_OVER_CURRENT:
 348                         dev_dbg(hcd->self.controller,
 349                                 "ClearPortFeature: C_OVER_CURRENT\n");
 350
 351                         if (valid_port(wIndex)) {
 352                                 pdata->overcurrent_changed[wIndex] = 0;
 353                                 pdata->overcurrent_status[wIndex] = 0;
 354                         }
 355
 356                         goto out;
 357
 358                 case USB_PORT_FEAT_OVER_CURRENT:
 359                         dev_dbg(hcd->self.controller,
 360                                 "ClearPortFeature: OVER_CURRENT\n");
 361
 362                         if (valid_port(wIndex))
 363                                 pdata->overcurrent_status[wIndex] = 0;
 364
 365                         goto out;
 366
 367                 case USB_PORT_FEAT_POWER:
 368                         dev_dbg(hcd->self.controller,
 369                                 "ClearPortFeature: POWER\n");
 370
 371                         if (valid_port(wIndex)) {
 372                                 ohci_at91_usb_set_power(pdata, wIndex, 0);
 373                                 return 0;
 374                         }
 375                 }
 376                 break;
 377         }
 378
 379         ret = ohci_hub_control(hcd, typeReq, wValue, wIndex + 1, buf, wLength);
 380         if (ret)
 381                 goto out;
 382
 383         switch (typeReq) {
 384         case GetHubDescriptor:
 385
 386                 /* update the hub's descriptor */
 387
 388                 desc = (struct usb_hub_descriptor *)buf;
 389
 390                 dev_dbg(hcd->self.controller, "wHubCharacteristics 0x%04x\n",
 391                         desc->wHubCharacteristics);
 392
 393                 /* remove the old configurations for power-switching, and
 394                  * over-current protection, and insert our new configuration
 395                  */
 396
 397                 desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_LPSM);
 398                 desc->wHubCharacteristics |= cpu_to_le16(0x0001);
 399
 400                 if (pdata->overcurrent_supported) {
 401                         desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_OCPM);
 402                         desc->wHubCharacteristics |=  cpu_to_le16(0x0008|0x0001);
 403                 }
 404
 405                 dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n",
 406                         desc->wHubCharacteristics);
 407
 408                 return ret;
 409
 410         case GetPortStatus:
 411                 /* check port status */
 412
 413                 dev_dbg(hcd->self.controller, "GetPortStatus(%d)\n", wIndex);
 414
 415                 if (valid_port(wIndex)) {
 416                         if (!ohci_at91_usb_get_power(pdata, wIndex))
 417                                 *data &= ~cpu_to_le32(RH_PS_PPS);
 418
 419                         if (pdata->overcurrent_changed[wIndex])
 420                                 *data |= cpu_to_le32(RH_PS_OCIC);
 421
 422                         if (pdata->overcurrent_status[wIndex])
 423                                 *data |= cpu_to_le32(RH_PS_POCI);
 424                 }
 425         }
 426
 427  out:
 428         return ret;
 429 }
 430
 431 /*-------------------------------------------------------------------------*/
 432
 433 static const struct hc_driver ohci_at91_hc_driver = {
 434         .description =          hcd_name,
 435         .product_desc =         "AT91 OHCI",
 436         .hcd_priv_size =        sizeof(struct ohci_hcd),
 437
 438         /*
 439          * generic hardware linkage
 440          */
 441         .irq =                  ohci_irq,
 442         .flags =                HCD_USB11 | HCD_MEMORY,
 443
 444         /*
 445          * basic lifecycle operations
 446          */
 447         .reset =                ohci_at91_reset,
 448         .start =                ohci_at91_start,
 449         .stop =                 ohci_stop,
 450         .shutdown =             ohci_shutdown,
 451
 452         /*
 453          * managing i/o requests and associated device resources
 454          */
 455         .urb_enqueue =          ohci_urb_enqueue,
 456         .urb_dequeue =          ohci_urb_dequeue,
 457         .endpoint_disable =     ohci_endpoint_disable,
 458
 459         /*
 460          * scheduling support
 461          */
 462         .get_frame_number =     ohci_get_frame,
 463
 464         /*
 465          * root hub support
 466          */
 467         .hub_status_data =      ohci_at91_hub_status_data,
 468         .hub_control =          ohci_at91_hub_control,
 469 #ifdef CONFIG_PM
 470         .bus_suspend =          ohci_bus_suspend,
 471         .bus_resume =           ohci_bus_resume,
 472 #endif
 473         .start_port_reset =     ohci_start_port_reset,
 474 };
 475
 476 /*-------------------------------------------------------------------------*/
 477
 478 static irqreturn_t ohci_hcd_at91_overcurrent_irq(int irq, void *data)
 479 {
 480         struct platform_device *pdev = data;
 481         struct at91_usbh_data *pdata = dev_get_platdata(&pdev->dev);
 482         int val, gpio, port;
 483
 484         /* From the GPIO notifying the over-current situation, find
 485          * out the corresponding port */
 486         at91_for_each_port(port) {
 487                 if (gpio_is_valid(pdata->overcurrent_pin[port]) &&
 488                                 gpio_to_irq(pdata->overcurrent_pin[port]) == irq) {
 489                         gpio = pdata->overcurrent_pin[port];
 490                         break;
 491                 }
 492         }
 493
 494         if (port == AT91_MAX_USBH_PORTS) {
 495                 dev_err(& pdev->dev, "overcurrent interrupt from unknown GPIO\n");
 496                 return IRQ_HANDLED;
 497         }
 498
 499         val = gpio_get_value(gpio);
 500
 501         /* When notified of an over-current situation, disable power
 502            on the corresponding port, and mark this port in
 503            over-current. */
 504         if (!val) {
 505                 ohci_at91_usb_set_power(pdata, port, 0);
 506                 pdata->overcurrent_status[port]  = 1;
 507                 pdata->overcurrent_changed[port] = 1;
 508         }
 509
 510         dev_dbg(& pdev->dev, "overcurrent situation %s\n",
 511                 val ? "exited" : "notified");
 512
 513         return IRQ_HANDLED;
 514 }
 515
 516 #ifdef CONFIG_OF
 517 static const struct of_device_id at91_ohci_dt_ids[] = {
 518         { .compatible = "atmel,at91rm9200-ohci" },
 519         { /* sentinel */ }
 520 };
 521
 522 MODULE_DEVICE_TABLE(of, at91_ohci_dt_ids);
 523
 524 static int ohci_at91_of_init(struct platform_device *pdev)
 525 {
 526         struct device_node *np = pdev->dev.of_node;
 527         int i, gpio;
 528         enum of_gpio_flags flags;
 529         struct at91_usbh_data   *pdata;
 530         u32 ports;
 531
 532         if (!np)
 533                 return 0;
 534
 535         /* Right now device-tree probed devices don't get dma_mask set.
 536          * Since shared usb code relies on it, set it here for now.
 537          * Once we have dma capability bindings this can go away.
 538          */
 539         if (!pdev->dev.dma_mask)
 540                 pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
 541         if (!pdev->dev.coherent_dma_mask)
 542                 pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
 543
 544         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
 545         if (!pdata)
 546                 return -ENOMEM;
 547
 548         if (!of_property_read_u32(np, "num-ports", &ports))
 549                 pdata->ports = ports;
 550
 551         at91_for_each_port(i) {
 552                 gpio = of_get_named_gpio_flags(np, "atmel,vbus-gpio", i, &flags);
 553                 pdata->vbus_pin[i] = gpio;
 554                 if (!gpio_is_valid(gpio))
 555                         continue;
 556                 pdata->vbus_pin_active_low[i] = flags & OF_GPIO_ACTIVE_LOW;
 557         }
 558
 559         at91_for_each_port(i)
 560                 pdata->overcurrent_pin[i] =
 561                         of_get_named_gpio_flags(np, "atmel,oc-gpio", i, &flags);
 562
 563         pdev->dev.platform_data = pdata;
 564
 565         return 0;
 566 }
 567 #else
 568 static int ohci_at91_of_init(struct platform_device *pdev)
 569 {
 570         return 0;
 571 }
 572 #endif
 573
 574 /*-------------------------------------------------------------------------*/
 575
 576 static int ohci_hcd_at91_drv_probe(struct platform_device *pdev)
 577 {
 578         struct at91_usbh_data   *pdata;
 579         int                     i;
 580         int                     gpio;
 581         int                     ret;
 582
 583         ret = ohci_at91_of_init(pdev);
 584         if (ret)
 585                 return ret;
 586
 587         pdata = dev_get_platdata(&pdev->dev);
 588
 589         if (pdata) {
 590                 at91_for_each_port(i) {
 591                         /*
 592                          * do not configure PIO if not in relation with
 593                          * real USB port on board
 594                          */
 595                         if (i >= pdata->ports) {
 596                                 pdata->vbus_pin[i] = -EINVAL;
 597                                 pdata->overcurrent_pin[i] = -EINVAL;
 598                                 break;
 599                         }
 600
 601                         if (!gpio_is_valid(pdata->vbus_pin[i]))
 602                                 continue;
 603                         gpio = pdata->vbus_pin[i];
 604
 605                         ret = gpio_request(gpio, "ohci_vbus");
 606                         if (ret) {
 607                                 dev_err(&pdev->dev,
 608                                         "can't request vbus gpio %d\n", gpio);
 609                                 continue;
 610                         }
 611                         ret = gpio_direction_output(gpio,
 612                                                 !pdata->vbus_pin_active_low[i]);
 613                         if (ret) {
 614                                 dev_err(&pdev->dev,
 615                                         "can't put vbus gpio %d as output %d\n",
 616                                         gpio, !pdata->vbus_pin_active_low[i]);
 617                                 gpio_free(gpio);
 618                                 continue;
 619                         }
 620
 621                         ohci_at91_usb_set_power(pdata, i, 1);
 622                 }
 623
 624                 at91_for_each_port(i) {
 625                         if (!gpio_is_valid(pdata->overcurrent_pin[i]))
 626                                 continue;
 627                         gpio = pdata->overcurrent_pin[i];
 628
 629                         ret = gpio_request(gpio, "ohci_overcurrent");
 630                         if (ret) {
 631                                 dev_err(&pdev->dev,
 632                                         "can't request overcurrent gpio %d\n",
 633                                         gpio);
 634                                 continue;
 635                         }
 636
 637                         ret = gpio_direction_input(gpio);
 638                         if (ret) {
 639                                 dev_err(&pdev->dev,
 640                                         "can't configure overcurrent gpio %d as input\n",
 641                                         gpio);
 642                                 gpio_free(gpio);
 643                                 continue;
 644                         }
 645
 646                         ret = request_irq(gpio_to_irq(gpio),
 647                                           ohci_hcd_at91_overcurrent_irq,
 648                                           IRQF_SHARED, "ohci_overcurrent", pdev);
 649                         if (ret) {
 650                                 gpio_free(gpio);
 651                                 dev_err(&pdev->dev,
 652                                         "can't get gpio IRQ for overcurrent\n");
 653                         }
 654                 }
 655         }
 656
 657         device_init_wakeup(&pdev->dev, 1);
 658         return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev);
 659 }
 660
 661 static int ohci_hcd_at91_drv_remove(struct platform_device *pdev)
 662 {
 663         struct at91_usbh_data   *pdata = dev_get_platdata(&pdev->dev);
 664         int                     i;
 665
 666         if (pdata) {
 667                 at91_for_each_port(i) {
 668                         if (!gpio_is_valid(pdata->vbus_pin[i]))
 669                                 continue;
 670                         ohci_at91_usb_set_power(pdata, i, 0);
 671                         gpio_free(pdata->vbus_pin[i]);
 672                 }
 673
 674                 at91_for_each_port(i) {
 675                         if (!gpio_is_valid(pdata->overcurrent_pin[i]))
 676                                 continue;
 677                         free_irq(gpio_to_irq(pdata->overcurrent_pin[i]), pdev);
 678                         gpio_free(pdata->overcurrent_pin[i]);
 679                 }
 680         }
 681
 682         device_init_wakeup(&pdev->dev, 0);
 683         usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev);
 684         return 0;
 685 }
 686
 687 #ifdef CONFIG_PM
 688
 689 static int
 690 ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg)
 691 {
 692         struct usb_hcd  *hcd = platform_get_drvdata(pdev);
 693         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
 694
 695         if (device_may_wakeup(&pdev->dev))
 696                 enable_irq_wake(hcd->irq);
 697
 698         /*
 699          * The integrated transceivers seem unable to notice disconnect,
 700          * reconnect, or wakeup without the 48 MHz clock active.  so for
 701          * correctness, always discard connection state (using reset).
 702          *
 703          * REVISIT: some boards will be able to turn VBUS off...
 704          */
 705         if (at91_suspend_entering_slow_clock()) {
 706                 ohci_usb_reset (ohci);
 707                 /* flush the writes */
 708                 (void) ohci_readl (ohci, &ohci->regs->control);
 709                 at91_stop_clock();
 710         }
 711
 712         return 0;
 713 }
 714
 715 static int ohci_hcd_at91_drv_resume(struct platform_device *pdev)
 716 {
 717         struct usb_hcd  *hcd = platform_get_drvdata(pdev);
 718
 719         if (device_may_wakeup(&pdev->dev))
 720                 disable_irq_wake(hcd->irq);
 721
 722         if (!clocked)
 723                 at91_start_clock();
 724
 725         ohci_resume(hcd, false);
 726         return 0;
 727 }
 728 #else
 729 #define ohci_hcd_at91_drv_suspend NULL
 730 #define ohci_hcd_at91_drv_resume  NULL
 731 #endif
 732
 733 MODULE_ALIAS("platform:at91_ohci");
 734
 735 static struct platform_driver ohci_hcd_at91_driver = {
 736         .probe          = ohci_hcd_at91_drv_probe,
 737         .remove         = ohci_hcd_at91_drv_remove,
 738         .shutdown       = usb_hcd_platform_shutdown,
 739         .suspend        = ohci_hcd_at91_drv_suspend,
 740         .resume         = ohci_hcd_at91_drv_resume,
 741         .driver         = {
 742                 .name   = "at91_ohci",
 743                 .owner  = THIS_MODULE,
 744                 .of_match_table = of_match_ptr(at91_ohci_dt_ids),
 745         },
 746 };