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