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