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