1 /* 2 * Renesas USB driver 3 * 4 * Copyright (C) 2011 Renesas Solutions Corp. 5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 6 * 7 * This program is distributed in the hope that it will be useful, 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 * GNU General Public License for more details. 11 * 12 * You should have received a copy of the GNU General Public License 13 * along with this program; if not, write to the Free Software 14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 15 * 16 */ 17 #include <linux/err.h> 18 #include <linux/gpio.h> 19 #include <linux/io.h> 20 #include <linux/module.h> 21 #include <linux/of_device.h> 22 #include <linux/of_gpio.h> 23 #include <linux/pm_runtime.h> 24 #include <linux/slab.h> 25 #include <linux/sysfs.h> 26 #include "common.h" 27 #include "rcar2.h" 28 29 /* 30 * image of renesas_usbhs 31 * 32 * ex) gadget case 33 34 * mod.c 35 * mod_gadget.c 36 * mod_host.c pipe.c fifo.c 37 * 38 * +-------+ +-----------+ 39 * | pipe0 |------>| fifo pio | 40 * +------------+ +-------+ +-----------+ 41 * | mod_gadget |=====> | pipe1 |--+ 42 * +------------+ +-------+ | +-----------+ 43 * | pipe2 | | +-| fifo dma0 | 44 * +------------+ +-------+ | | +-----------+ 45 * | mod_host | | pipe3 |<-|--+ 46 * +------------+ +-------+ | +-----------+ 47 * | .... | +--->| fifo dma1 | 48 * | .... | +-----------+ 49 */ 50 51 52 #define USBHSF_RUNTIME_PWCTRL (1 << 0) 53 54 /* status */ 55 #define usbhsc_flags_init(p) do {(p)->flags = 0; } while (0) 56 #define usbhsc_flags_set(p, b) ((p)->flags |= (b)) 57 #define usbhsc_flags_clr(p, b) ((p)->flags &= ~(b)) 58 #define usbhsc_flags_has(p, b) ((p)->flags & (b)) 59 60 /* 61 * platform call back 62 * 63 * renesas usb support platform callback function. 64 * Below macro call it. 65 * if platform doesn't have callback, it return 0 (no error) 66 */ 67 #define usbhs_platform_call(priv, func, args...)\ 68 (!(priv) ? -ENODEV : \ 69 !((priv)->pfunc.func) ? 0 : \ 70 (priv)->pfunc.func(args)) 71 72 /* 73 * common functions 74 */ 75 u16 usbhs_read(struct usbhs_priv *priv, u32 reg) 76 { 77 return ioread16(priv->base + reg); 78 } 79 80 void usbhs_write(struct usbhs_priv *priv, u32 reg, u16 data) 81 { 82 iowrite16(data, priv->base + reg); 83 } 84 85 void usbhs_bset(struct usbhs_priv *priv, u32 reg, u16 mask, u16 data) 86 { 87 u16 val = usbhs_read(priv, reg); 88 89 val &= ~mask; 90 val |= data & mask; 91 92 usbhs_write(priv, reg, val); 93 } 94 95 struct usbhs_priv *usbhs_pdev_to_priv(struct platform_device *pdev) 96 { 97 return dev_get_drvdata(&pdev->dev); 98 } 99 100 /* 101 * syscfg functions 102 */ 103 static void usbhs_sys_clock_ctrl(struct usbhs_priv *priv, int enable) 104 { 105 usbhs_bset(priv, SYSCFG, SCKE, enable ? SCKE : 0); 106 } 107 108 void usbhs_sys_host_ctrl(struct usbhs_priv *priv, int enable) 109 { 110 u16 mask = DCFM | DRPD | DPRPU | HSE | USBE; 111 u16 val = DCFM | DRPD | HSE | USBE; 112 int has_otg = usbhs_get_dparam(priv, has_otg); 113 114 if (has_otg) 115 usbhs_bset(priv, DVSTCTR, (EXTLP | PWEN), (EXTLP | PWEN)); 116 117 /* 118 * if enable 119 * 120 * - select Host mode 121 * - D+ Line/D- Line Pull-down 122 */ 123 usbhs_bset(priv, SYSCFG, mask, enable ? val : 0); 124 } 125 126 void usbhs_sys_function_ctrl(struct usbhs_priv *priv, int enable) 127 { 128 u16 mask = DCFM | DRPD | DPRPU | HSE | USBE; 129 u16 val = DPRPU | HSE | USBE; 130 131 /* 132 * if enable 133 * 134 * - select Function mode 135 * - D+ Line Pull-up 136 */ 137 usbhs_bset(priv, SYSCFG, mask, enable ? val : 0); 138 } 139 140 void usbhs_sys_function_pullup(struct usbhs_priv *priv, int enable) 141 { 142 usbhs_bset(priv, SYSCFG, DPRPU, enable ? DPRPU : 0); 143 } 144 145 void usbhs_sys_set_test_mode(struct usbhs_priv *priv, u16 mode) 146 { 147 usbhs_write(priv, TESTMODE, mode); 148 } 149 150 /* 151 * frame functions 152 */ 153 int usbhs_frame_get_num(struct usbhs_priv *priv) 154 { 155 return usbhs_read(priv, FRMNUM) & FRNM_MASK; 156 } 157 158 /* 159 * usb request functions 160 */ 161 void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req) 162 { 163 u16 val; 164 165 val = usbhs_read(priv, USBREQ); 166 req->bRequest = (val >> 8) & 0xFF; 167 req->bRequestType = (val >> 0) & 0xFF; 168 169 req->wValue = usbhs_read(priv, USBVAL); 170 req->wIndex = usbhs_read(priv, USBINDX); 171 req->wLength = usbhs_read(priv, USBLENG); 172 } 173 174 void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req) 175 { 176 usbhs_write(priv, USBREQ, (req->bRequest << 8) | req->bRequestType); 177 usbhs_write(priv, USBVAL, req->wValue); 178 usbhs_write(priv, USBINDX, req->wIndex); 179 usbhs_write(priv, USBLENG, req->wLength); 180 181 usbhs_bset(priv, DCPCTR, SUREQ, SUREQ); 182 } 183 184 /* 185 * bus/vbus functions 186 */ 187 void usbhs_bus_send_sof_enable(struct usbhs_priv *priv) 188 { 189 u16 status = usbhs_read(priv, DVSTCTR) & (USBRST | UACT); 190 191 if (status != USBRST) { 192 struct device *dev = usbhs_priv_to_dev(priv); 193 dev_err(dev, "usbhs should be reset\n"); 194 } 195 196 usbhs_bset(priv, DVSTCTR, (USBRST | UACT), UACT); 197 } 198 199 void usbhs_bus_send_reset(struct usbhs_priv *priv) 200 { 201 usbhs_bset(priv, DVSTCTR, (USBRST | UACT), USBRST); 202 } 203 204 int usbhs_bus_get_speed(struct usbhs_priv *priv) 205 { 206 u16 dvstctr = usbhs_read(priv, DVSTCTR); 207 208 switch (RHST & dvstctr) { 209 case RHST_LOW_SPEED: 210 return USB_SPEED_LOW; 211 case RHST_FULL_SPEED: 212 return USB_SPEED_FULL; 213 case RHST_HIGH_SPEED: 214 return USB_SPEED_HIGH; 215 } 216 217 return USB_SPEED_UNKNOWN; 218 } 219 220 int usbhs_vbus_ctrl(struct usbhs_priv *priv, int enable) 221 { 222 struct platform_device *pdev = usbhs_priv_to_pdev(priv); 223 224 return usbhs_platform_call(priv, set_vbus, pdev, enable); 225 } 226 227 static void usbhsc_bus_init(struct usbhs_priv *priv) 228 { 229 usbhs_write(priv, DVSTCTR, 0); 230 231 usbhs_vbus_ctrl(priv, 0); 232 } 233 234 /* 235 * device configuration 236 */ 237 int usbhs_set_device_config(struct usbhs_priv *priv, int devnum, 238 u16 upphub, u16 hubport, u16 speed) 239 { 240 struct device *dev = usbhs_priv_to_dev(priv); 241 u16 usbspd = 0; 242 u32 reg = DEVADD0 + (2 * devnum); 243 244 if (devnum > 10) { 245 dev_err(dev, "cannot set speed to unknown device %d\n", devnum); 246 return -EIO; 247 } 248 249 if (upphub > 0xA) { 250 dev_err(dev, "unsupported hub number %d\n", upphub); 251 return -EIO; 252 } 253 254 switch (speed) { 255 case USB_SPEED_LOW: 256 usbspd = USBSPD_SPEED_LOW; 257 break; 258 case USB_SPEED_FULL: 259 usbspd = USBSPD_SPEED_FULL; 260 break; 261 case USB_SPEED_HIGH: 262 usbspd = USBSPD_SPEED_HIGH; 263 break; 264 default: 265 dev_err(dev, "unsupported speed %d\n", speed); 266 return -EIO; 267 } 268 269 usbhs_write(priv, reg, UPPHUB(upphub) | 270 HUBPORT(hubport)| 271 USBSPD(usbspd)); 272 273 return 0; 274 } 275 276 /* 277 * local functions 278 */ 279 static void usbhsc_set_buswait(struct usbhs_priv *priv) 280 { 281 int wait = usbhs_get_dparam(priv, buswait_bwait); 282 283 /* set bus wait if platform have */ 284 if (wait) 285 usbhs_bset(priv, BUSWAIT, 0x000F, wait); 286 } 287 288 /* 289 * platform default param 290 */ 291 292 /* commonly used on old SH-Mobile SoCs */ 293 static u32 usbhsc_default_pipe_type[] = { 294 USB_ENDPOINT_XFER_CONTROL, 295 USB_ENDPOINT_XFER_ISOC, 296 USB_ENDPOINT_XFER_ISOC, 297 USB_ENDPOINT_XFER_BULK, 298 USB_ENDPOINT_XFER_BULK, 299 USB_ENDPOINT_XFER_BULK, 300 USB_ENDPOINT_XFER_INT, 301 USB_ENDPOINT_XFER_INT, 302 USB_ENDPOINT_XFER_INT, 303 USB_ENDPOINT_XFER_INT, 304 }; 305 306 /* commonly used on newer SH-Mobile and R-Car SoCs */ 307 static u32 usbhsc_new_pipe_type[] = { 308 USB_ENDPOINT_XFER_CONTROL, 309 USB_ENDPOINT_XFER_ISOC, 310 USB_ENDPOINT_XFER_ISOC, 311 USB_ENDPOINT_XFER_BULK, 312 USB_ENDPOINT_XFER_BULK, 313 USB_ENDPOINT_XFER_BULK, 314 USB_ENDPOINT_XFER_INT, 315 USB_ENDPOINT_XFER_INT, 316 USB_ENDPOINT_XFER_INT, 317 USB_ENDPOINT_XFER_BULK, 318 USB_ENDPOINT_XFER_BULK, 319 USB_ENDPOINT_XFER_BULK, 320 USB_ENDPOINT_XFER_BULK, 321 USB_ENDPOINT_XFER_BULK, 322 USB_ENDPOINT_XFER_BULK, 323 USB_ENDPOINT_XFER_BULK, 324 }; 325 326 /* 327 * power control 328 */ 329 static void usbhsc_power_ctrl(struct usbhs_priv *priv, int enable) 330 { 331 struct platform_device *pdev = usbhs_priv_to_pdev(priv); 332 struct device *dev = usbhs_priv_to_dev(priv); 333 334 if (enable) { 335 /* enable PM */ 336 pm_runtime_get_sync(dev); 337 338 /* enable platform power */ 339 usbhs_platform_call(priv, power_ctrl, pdev, priv->base, enable); 340 341 /* USB on */ 342 usbhs_sys_clock_ctrl(priv, enable); 343 } else { 344 /* USB off */ 345 usbhs_sys_clock_ctrl(priv, enable); 346 347 /* disable platform power */ 348 usbhs_platform_call(priv, power_ctrl, pdev, priv->base, enable); 349 350 /* disable PM */ 351 pm_runtime_put_sync(dev); 352 } 353 } 354 355 /* 356 * hotplug 357 */ 358 static void usbhsc_hotplug(struct usbhs_priv *priv) 359 { 360 struct platform_device *pdev = usbhs_priv_to_pdev(priv); 361 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 362 int id; 363 int enable; 364 int ret; 365 366 /* 367 * get vbus status from platform 368 */ 369 enable = usbhs_platform_call(priv, get_vbus, pdev); 370 371 /* 372 * get id from platform 373 */ 374 id = usbhs_platform_call(priv, get_id, pdev); 375 376 if (enable && !mod) { 377 ret = usbhs_mod_change(priv, id); 378 if (ret < 0) 379 return; 380 381 dev_dbg(&pdev->dev, "%s enable\n", __func__); 382 383 /* power on */ 384 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 385 usbhsc_power_ctrl(priv, enable); 386 387 /* bus init */ 388 usbhsc_set_buswait(priv); 389 usbhsc_bus_init(priv); 390 391 /* module start */ 392 usbhs_mod_call(priv, start, priv); 393 394 } else if (!enable && mod) { 395 dev_dbg(&pdev->dev, "%s disable\n", __func__); 396 397 /* module stop */ 398 usbhs_mod_call(priv, stop, priv); 399 400 /* bus init */ 401 usbhsc_bus_init(priv); 402 403 /* power off */ 404 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 405 usbhsc_power_ctrl(priv, enable); 406 407 usbhs_mod_change(priv, -1); 408 409 /* reset phy for next connection */ 410 usbhs_platform_call(priv, phy_reset, pdev); 411 } 412 } 413 414 /* 415 * notify hotplug 416 */ 417 static void usbhsc_notify_hotplug(struct work_struct *work) 418 { 419 struct usbhs_priv *priv = container_of(work, 420 struct usbhs_priv, 421 notify_hotplug_work.work); 422 usbhsc_hotplug(priv); 423 } 424 425 static int usbhsc_drvcllbck_notify_hotplug(struct platform_device *pdev) 426 { 427 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev); 428 int delay = usbhs_get_dparam(priv, detection_delay); 429 430 /* 431 * This functions will be called in interrupt. 432 * To make sure safety context, 433 * use workqueue for usbhs_notify_hotplug 434 */ 435 schedule_delayed_work(&priv->notify_hotplug_work, 436 msecs_to_jiffies(delay)); 437 return 0; 438 } 439 440 /* 441 * platform functions 442 */ 443 static const struct of_device_id usbhs_of_match[] = { 444 { 445 .compatible = "renesas,usbhs-r8a7790", 446 .data = (void *)USBHS_TYPE_R8A7790, 447 }, 448 { 449 .compatible = "renesas,usbhs-r8a7791", 450 .data = (void *)USBHS_TYPE_R8A7791, 451 }, 452 { }, 453 }; 454 MODULE_DEVICE_TABLE(of, usbhs_of_match); 455 456 static struct renesas_usbhs_platform_info *usbhs_parse_dt(struct device *dev) 457 { 458 struct renesas_usbhs_platform_info *info; 459 struct renesas_usbhs_driver_param *dparam; 460 const struct of_device_id *of_id = of_match_device(usbhs_of_match, dev); 461 u32 tmp; 462 int gpio; 463 464 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL); 465 if (!info) 466 return NULL; 467 468 dparam = &info->driver_param; 469 dparam->type = of_id ? (u32)of_id->data : 0; 470 if (!of_property_read_u32(dev->of_node, "renesas,buswait", &tmp)) 471 dparam->buswait_bwait = tmp; 472 gpio = of_get_named_gpio_flags(dev->of_node, "renesas,enable-gpio", 0, 473 NULL); 474 if (gpio > 0) 475 dparam->enable_gpio = gpio; 476 477 return info; 478 } 479 480 static int usbhs_probe(struct platform_device *pdev) 481 { 482 struct renesas_usbhs_platform_info *info = dev_get_platdata(&pdev->dev); 483 struct renesas_usbhs_driver_callback *dfunc; 484 struct usbhs_priv *priv; 485 struct resource *res, *irq_res; 486 int ret; 487 488 /* check device node */ 489 if (pdev->dev.of_node) 490 info = pdev->dev.platform_data = usbhs_parse_dt(&pdev->dev); 491 492 /* check platform information */ 493 if (!info) { 494 dev_err(&pdev->dev, "no platform information\n"); 495 return -EINVAL; 496 } 497 498 /* platform data */ 499 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 500 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 501 if (!res || !irq_res) { 502 dev_err(&pdev->dev, "Not enough Renesas USB platform resources.\n"); 503 return -ENODEV; 504 } 505 506 /* usb private data */ 507 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 508 if (!priv) { 509 dev_err(&pdev->dev, "Could not allocate priv\n"); 510 return -ENOMEM; 511 } 512 513 priv->base = devm_ioremap_resource(&pdev->dev, res); 514 if (IS_ERR(priv->base)) 515 return PTR_ERR(priv->base); 516 517 /* 518 * care platform info 519 */ 520 521 memcpy(&priv->dparam, 522 &info->driver_param, 523 sizeof(struct renesas_usbhs_driver_param)); 524 525 switch (priv->dparam.type) { 526 case USBHS_TYPE_R8A7790: 527 case USBHS_TYPE_R8A7791: 528 priv->pfunc = usbhs_rcar2_ops; 529 if (!priv->dparam.pipe_type) { 530 priv->dparam.pipe_type = usbhsc_new_pipe_type; 531 priv->dparam.pipe_size = 532 ARRAY_SIZE(usbhsc_new_pipe_type); 533 } 534 break; 535 default: 536 if (!info->platform_callback.get_id) { 537 dev_err(&pdev->dev, "no platform callbacks"); 538 return -EINVAL; 539 } 540 memcpy(&priv->pfunc, 541 &info->platform_callback, 542 sizeof(struct renesas_usbhs_platform_callback)); 543 break; 544 } 545 546 /* set driver callback functions for platform */ 547 dfunc = &info->driver_callback; 548 dfunc->notify_hotplug = usbhsc_drvcllbck_notify_hotplug; 549 550 /* set default param if platform doesn't have */ 551 if (!priv->dparam.pipe_type) { 552 priv->dparam.pipe_type = usbhsc_default_pipe_type; 553 priv->dparam.pipe_size = ARRAY_SIZE(usbhsc_default_pipe_type); 554 } 555 if (!priv->dparam.pio_dma_border) 556 priv->dparam.pio_dma_border = 64; /* 64byte */ 557 558 /* FIXME */ 559 /* runtime power control ? */ 560 if (priv->pfunc.get_vbus) 561 usbhsc_flags_set(priv, USBHSF_RUNTIME_PWCTRL); 562 563 /* 564 * priv settings 565 */ 566 priv->irq = irq_res->start; 567 if (irq_res->flags & IORESOURCE_IRQ_SHAREABLE) 568 priv->irqflags = IRQF_SHARED; 569 priv->pdev = pdev; 570 INIT_DELAYED_WORK(&priv->notify_hotplug_work, usbhsc_notify_hotplug); 571 spin_lock_init(usbhs_priv_to_lock(priv)); 572 573 /* call pipe and module init */ 574 ret = usbhs_pipe_probe(priv); 575 if (ret < 0) 576 return ret; 577 578 ret = usbhs_fifo_probe(priv); 579 if (ret < 0) 580 goto probe_end_pipe_exit; 581 582 ret = usbhs_mod_probe(priv); 583 if (ret < 0) 584 goto probe_end_fifo_exit; 585 586 /* dev_set_drvdata should be called after usbhs_mod_init */ 587 platform_set_drvdata(pdev, priv); 588 589 /* 590 * deviece reset here because 591 * USB device might be used in boot loader. 592 */ 593 usbhs_sys_clock_ctrl(priv, 0); 594 595 /* check GPIO determining if USB function should be enabled */ 596 if (priv->dparam.enable_gpio) { 597 gpio_request_one(priv->dparam.enable_gpio, GPIOF_IN, NULL); 598 ret = !gpio_get_value(priv->dparam.enable_gpio); 599 gpio_free(priv->dparam.enable_gpio); 600 if (ret) { 601 dev_warn(&pdev->dev, 602 "USB function not selected (GPIO %d)\n", 603 priv->dparam.enable_gpio); 604 ret = -ENOTSUPP; 605 goto probe_end_mod_exit; 606 } 607 } 608 609 /* 610 * platform call 611 * 612 * USB phy setup might depend on CPU/Board. 613 * If platform has its callback functions, 614 * call it here. 615 */ 616 ret = usbhs_platform_call(priv, hardware_init, pdev); 617 if (ret < 0) { 618 dev_err(&pdev->dev, "platform prove failed.\n"); 619 goto probe_end_mod_exit; 620 } 621 622 /* reset phy for connection */ 623 usbhs_platform_call(priv, phy_reset, pdev); 624 625 /* power control */ 626 pm_runtime_enable(&pdev->dev); 627 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) { 628 usbhsc_power_ctrl(priv, 1); 629 usbhs_mod_autonomy_mode(priv); 630 } 631 632 /* 633 * manual call notify_hotplug for cold plug 634 */ 635 ret = usbhsc_drvcllbck_notify_hotplug(pdev); 636 if (ret < 0) 637 goto probe_end_call_remove; 638 639 dev_info(&pdev->dev, "probed\n"); 640 641 return ret; 642 643 probe_end_call_remove: 644 usbhs_platform_call(priv, hardware_exit, pdev); 645 probe_end_mod_exit: 646 usbhs_mod_remove(priv); 647 probe_end_fifo_exit: 648 usbhs_fifo_remove(priv); 649 probe_end_pipe_exit: 650 usbhs_pipe_remove(priv); 651 652 dev_info(&pdev->dev, "probe failed\n"); 653 654 return ret; 655 } 656 657 static int usbhs_remove(struct platform_device *pdev) 658 { 659 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev); 660 struct renesas_usbhs_platform_info *info = dev_get_platdata(&pdev->dev); 661 struct renesas_usbhs_driver_callback *dfunc = &info->driver_callback; 662 663 dev_dbg(&pdev->dev, "usb remove\n"); 664 665 dfunc->notify_hotplug = NULL; 666 667 /* power off */ 668 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 669 usbhsc_power_ctrl(priv, 0); 670 671 pm_runtime_disable(&pdev->dev); 672 673 usbhs_platform_call(priv, hardware_exit, pdev); 674 usbhs_mod_remove(priv); 675 usbhs_fifo_remove(priv); 676 usbhs_pipe_remove(priv); 677 678 return 0; 679 } 680 681 static int usbhsc_suspend(struct device *dev) 682 { 683 struct usbhs_priv *priv = dev_get_drvdata(dev); 684 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 685 686 if (mod) { 687 usbhs_mod_call(priv, stop, priv); 688 usbhs_mod_change(priv, -1); 689 } 690 691 if (mod || !usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 692 usbhsc_power_ctrl(priv, 0); 693 694 return 0; 695 } 696 697 static int usbhsc_resume(struct device *dev) 698 { 699 struct usbhs_priv *priv = dev_get_drvdata(dev); 700 struct platform_device *pdev = usbhs_priv_to_pdev(priv); 701 702 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 703 usbhsc_power_ctrl(priv, 1); 704 705 usbhs_platform_call(priv, phy_reset, pdev); 706 707 usbhsc_drvcllbck_notify_hotplug(pdev); 708 709 return 0; 710 } 711 712 static int usbhsc_runtime_nop(struct device *dev) 713 { 714 /* Runtime PM callback shared between ->runtime_suspend() 715 * and ->runtime_resume(). Simply returns success. 716 * 717 * This driver re-initializes all registers after 718 * pm_runtime_get_sync() anyway so there is no need 719 * to save and restore registers here. 720 */ 721 return 0; 722 } 723 724 static const struct dev_pm_ops usbhsc_pm_ops = { 725 .suspend = usbhsc_suspend, 726 .resume = usbhsc_resume, 727 .runtime_suspend = usbhsc_runtime_nop, 728 .runtime_resume = usbhsc_runtime_nop, 729 }; 730 731 static struct platform_driver renesas_usbhs_driver = { 732 .driver = { 733 .name = "renesas_usbhs", 734 .pm = &usbhsc_pm_ops, 735 .of_match_table = of_match_ptr(usbhs_of_match), 736 }, 737 .probe = usbhs_probe, 738 .remove = usbhs_remove, 739 }; 740 741 module_platform_driver(renesas_usbhs_driver); 742 743 MODULE_LICENSE("GPL"); 744 MODULE_DESCRIPTION("Renesas USB driver"); 745 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); 746