1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2012 Freescale Semiconductor, Inc. 4 * Copyright (C) 2012 Marek Vasut <marex@denx.de> 5 * on behalf of DENX Software Engineering GmbH 6 */ 7 8 #include <linux/module.h> 9 #include <linux/of_platform.h> 10 #include <linux/platform_device.h> 11 #include <linux/pm_runtime.h> 12 #include <linux/usb/chipidea.h> 13 #include <linux/usb/of.h> 14 #include <linux/clk.h> 15 #include <linux/pinctrl/consumer.h> 16 #include <linux/pm_qos.h> 17 18 #include "ci.h" 19 #include "ci_hdrc_imx.h" 20 21 struct ci_hdrc_imx_platform_flag { 22 unsigned int flags; 23 }; 24 25 static const struct ci_hdrc_imx_platform_flag imx23_usb_data = { 26 .flags = CI_HDRC_TURN_VBUS_EARLY_ON | 27 CI_HDRC_DISABLE_STREAMING, 28 }; 29 30 static const struct ci_hdrc_imx_platform_flag imx27_usb_data = { 31 .flags = CI_HDRC_DISABLE_STREAMING, 32 }; 33 34 static const struct ci_hdrc_imx_platform_flag imx28_usb_data = { 35 .flags = CI_HDRC_IMX28_WRITE_FIX | 36 CI_HDRC_TURN_VBUS_EARLY_ON | 37 CI_HDRC_DISABLE_STREAMING, 38 }; 39 40 static const struct ci_hdrc_imx_platform_flag imx6q_usb_data = { 41 .flags = CI_HDRC_SUPPORTS_RUNTIME_PM | 42 CI_HDRC_TURN_VBUS_EARLY_ON | 43 CI_HDRC_DISABLE_STREAMING, 44 }; 45 46 static const struct ci_hdrc_imx_platform_flag imx6sl_usb_data = { 47 .flags = CI_HDRC_SUPPORTS_RUNTIME_PM | 48 CI_HDRC_TURN_VBUS_EARLY_ON | 49 CI_HDRC_DISABLE_HOST_STREAMING, 50 }; 51 52 static const struct ci_hdrc_imx_platform_flag imx6sx_usb_data = { 53 .flags = CI_HDRC_SUPPORTS_RUNTIME_PM | 54 CI_HDRC_TURN_VBUS_EARLY_ON | 55 CI_HDRC_DISABLE_HOST_STREAMING, 56 }; 57 58 static const struct ci_hdrc_imx_platform_flag imx6ul_usb_data = { 59 .flags = CI_HDRC_SUPPORTS_RUNTIME_PM | 60 CI_HDRC_TURN_VBUS_EARLY_ON, 61 }; 62 63 static const struct ci_hdrc_imx_platform_flag imx7d_usb_data = { 64 .flags = CI_HDRC_SUPPORTS_RUNTIME_PM, 65 }; 66 67 static const struct ci_hdrc_imx_platform_flag imx7ulp_usb_data = { 68 .flags = CI_HDRC_SUPPORTS_RUNTIME_PM | 69 CI_HDRC_PMQOS, 70 }; 71 72 static const struct of_device_id ci_hdrc_imx_dt_ids[] = { 73 { .compatible = "fsl,imx23-usb", .data = &imx23_usb_data}, 74 { .compatible = "fsl,imx28-usb", .data = &imx28_usb_data}, 75 { .compatible = "fsl,imx27-usb", .data = &imx27_usb_data}, 76 { .compatible = "fsl,imx6q-usb", .data = &imx6q_usb_data}, 77 { .compatible = "fsl,imx6sl-usb", .data = &imx6sl_usb_data}, 78 { .compatible = "fsl,imx6sx-usb", .data = &imx6sx_usb_data}, 79 { .compatible = "fsl,imx6ul-usb", .data = &imx6ul_usb_data}, 80 { .compatible = "fsl,imx7d-usb", .data = &imx7d_usb_data}, 81 { .compatible = "fsl,imx7ulp-usb", .data = &imx7ulp_usb_data}, 82 { /* sentinel */ } 83 }; 84 MODULE_DEVICE_TABLE(of, ci_hdrc_imx_dt_ids); 85 86 struct ci_hdrc_imx_data { 87 struct usb_phy *phy; 88 struct platform_device *ci_pdev; 89 struct clk *clk; 90 struct imx_usbmisc_data *usbmisc_data; 91 bool supports_runtime_pm; 92 bool override_phy_control; 93 bool in_lpm; 94 struct pinctrl *pinctrl; 95 struct pinctrl_state *pinctrl_hsic_active; 96 struct regulator *hsic_pad_regulator; 97 /* SoC before i.mx6 (except imx23/imx28) needs three clks */ 98 bool need_three_clks; 99 struct clk *clk_ipg; 100 struct clk *clk_ahb; 101 struct clk *clk_per; 102 /* --------------------------------- */ 103 struct pm_qos_request pm_qos_req; 104 const struct ci_hdrc_imx_platform_flag *plat_data; 105 }; 106 107 /* Common functions shared by usbmisc drivers */ 108 109 static struct imx_usbmisc_data *usbmisc_get_init_data(struct device *dev) 110 { 111 struct platform_device *misc_pdev; 112 struct device_node *np = dev->of_node; 113 struct of_phandle_args args; 114 struct imx_usbmisc_data *data; 115 int ret; 116 117 /* 118 * In case the fsl,usbmisc property is not present this device doesn't 119 * need usbmisc. Return NULL (which is no error here) 120 */ 121 if (!of_get_property(np, "fsl,usbmisc", NULL)) 122 return NULL; 123 124 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 125 if (!data) 126 return ERR_PTR(-ENOMEM); 127 128 ret = of_parse_phandle_with_args(np, "fsl,usbmisc", "#index-cells", 129 0, &args); 130 if (ret) { 131 dev_err(dev, "Failed to parse property fsl,usbmisc, errno %d\n", 132 ret); 133 return ERR_PTR(ret); 134 } 135 136 data->index = args.args[0]; 137 138 misc_pdev = of_find_device_by_node(args.np); 139 of_node_put(args.np); 140 141 if (!misc_pdev || !platform_get_drvdata(misc_pdev)) 142 return ERR_PTR(-EPROBE_DEFER); 143 144 data->dev = &misc_pdev->dev; 145 146 /* 147 * Check the various over current related properties. If over current 148 * detection is disabled we're not interested in the polarity. 149 */ 150 if (of_find_property(np, "disable-over-current", NULL)) { 151 data->disable_oc = 1; 152 } else if (of_find_property(np, "over-current-active-high", NULL)) { 153 data->oc_pol_active_low = 0; 154 data->oc_pol_configured = 1; 155 } else if (of_find_property(np, "over-current-active-low", NULL)) { 156 data->oc_pol_active_low = 1; 157 data->oc_pol_configured = 1; 158 } else { 159 dev_warn(dev, "No over current polarity defined\n"); 160 } 161 162 data->pwr_pol = of_property_read_bool(np, "power-active-high"); 163 data->evdo = of_property_read_bool(np, "external-vbus-divider"); 164 165 if (of_usb_get_phy_mode(np) == USBPHY_INTERFACE_MODE_ULPI) 166 data->ulpi = 1; 167 168 return data; 169 } 170 171 /* End of common functions shared by usbmisc drivers*/ 172 static int imx_get_clks(struct device *dev) 173 { 174 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 175 int ret = 0; 176 177 data->clk_ipg = devm_clk_get(dev, "ipg"); 178 if (IS_ERR(data->clk_ipg)) { 179 /* If the platform only needs one clocks */ 180 data->clk = devm_clk_get(dev, NULL); 181 if (IS_ERR(data->clk)) { 182 ret = PTR_ERR(data->clk); 183 dev_err(dev, 184 "Failed to get clks, err=%ld,%ld\n", 185 PTR_ERR(data->clk), PTR_ERR(data->clk_ipg)); 186 return ret; 187 } 188 return ret; 189 } 190 191 data->clk_ahb = devm_clk_get(dev, "ahb"); 192 if (IS_ERR(data->clk_ahb)) { 193 ret = PTR_ERR(data->clk_ahb); 194 dev_err(dev, 195 "Failed to get ahb clock, err=%d\n", ret); 196 return ret; 197 } 198 199 data->clk_per = devm_clk_get(dev, "per"); 200 if (IS_ERR(data->clk_per)) { 201 ret = PTR_ERR(data->clk_per); 202 dev_err(dev, 203 "Failed to get per clock, err=%d\n", ret); 204 return ret; 205 } 206 207 data->need_three_clks = true; 208 return ret; 209 } 210 211 static int imx_prepare_enable_clks(struct device *dev) 212 { 213 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 214 int ret = 0; 215 216 if (data->need_three_clks) { 217 ret = clk_prepare_enable(data->clk_ipg); 218 if (ret) { 219 dev_err(dev, 220 "Failed to prepare/enable ipg clk, err=%d\n", 221 ret); 222 return ret; 223 } 224 225 ret = clk_prepare_enable(data->clk_ahb); 226 if (ret) { 227 dev_err(dev, 228 "Failed to prepare/enable ahb clk, err=%d\n", 229 ret); 230 clk_disable_unprepare(data->clk_ipg); 231 return ret; 232 } 233 234 ret = clk_prepare_enable(data->clk_per); 235 if (ret) { 236 dev_err(dev, 237 "Failed to prepare/enable per clk, err=%d\n", 238 ret); 239 clk_disable_unprepare(data->clk_ahb); 240 clk_disable_unprepare(data->clk_ipg); 241 return ret; 242 } 243 } else { 244 ret = clk_prepare_enable(data->clk); 245 if (ret) { 246 dev_err(dev, 247 "Failed to prepare/enable clk, err=%d\n", 248 ret); 249 return ret; 250 } 251 } 252 253 return ret; 254 } 255 256 static void imx_disable_unprepare_clks(struct device *dev) 257 { 258 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 259 260 if (data->need_three_clks) { 261 clk_disable_unprepare(data->clk_per); 262 clk_disable_unprepare(data->clk_ahb); 263 clk_disable_unprepare(data->clk_ipg); 264 } else { 265 clk_disable_unprepare(data->clk); 266 } 267 } 268 269 static int ci_hdrc_imx_notify_event(struct ci_hdrc *ci, unsigned int event) 270 { 271 struct device *dev = ci->dev->parent; 272 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 273 int ret = 0; 274 struct imx_usbmisc_data *mdata = data->usbmisc_data; 275 276 switch (event) { 277 case CI_HDRC_IMX_HSIC_ACTIVE_EVENT: 278 if (data->pinctrl) { 279 ret = pinctrl_select_state(data->pinctrl, 280 data->pinctrl_hsic_active); 281 if (ret) 282 dev_err(dev, 283 "hsic_active select failed, err=%d\n", 284 ret); 285 } 286 break; 287 case CI_HDRC_IMX_HSIC_SUSPEND_EVENT: 288 ret = imx_usbmisc_hsic_set_connect(mdata); 289 if (ret) 290 dev_err(dev, 291 "hsic_set_connect failed, err=%d\n", ret); 292 break; 293 case CI_HDRC_CONTROLLER_VBUS_EVENT: 294 if (ci->vbus_active) 295 ret = imx_usbmisc_charger_detection(mdata, true); 296 else 297 ret = imx_usbmisc_charger_detection(mdata, false); 298 if (ci->usb_phy) 299 schedule_work(&ci->usb_phy->chg_work); 300 break; 301 default: 302 break; 303 } 304 305 return ret; 306 } 307 308 static int ci_hdrc_imx_probe(struct platform_device *pdev) 309 { 310 struct ci_hdrc_imx_data *data; 311 struct ci_hdrc_platform_data pdata = { 312 .name = dev_name(&pdev->dev), 313 .capoffset = DEF_CAPOFFSET, 314 .notify_event = ci_hdrc_imx_notify_event, 315 }; 316 int ret; 317 const struct of_device_id *of_id; 318 const struct ci_hdrc_imx_platform_flag *imx_platform_flag; 319 struct device_node *np = pdev->dev.of_node; 320 struct device *dev = &pdev->dev; 321 322 of_id = of_match_device(ci_hdrc_imx_dt_ids, dev); 323 if (!of_id) 324 return -ENODEV; 325 326 imx_platform_flag = of_id->data; 327 328 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); 329 if (!data) 330 return -ENOMEM; 331 332 data->plat_data = imx_platform_flag; 333 pdata.flags |= imx_platform_flag->flags; 334 platform_set_drvdata(pdev, data); 335 data->usbmisc_data = usbmisc_get_init_data(dev); 336 if (IS_ERR(data->usbmisc_data)) 337 return PTR_ERR(data->usbmisc_data); 338 339 if ((of_usb_get_phy_mode(dev->of_node) == USBPHY_INTERFACE_MODE_HSIC) 340 && data->usbmisc_data) { 341 pdata.flags |= CI_HDRC_IMX_IS_HSIC; 342 data->usbmisc_data->hsic = 1; 343 data->pinctrl = devm_pinctrl_get(dev); 344 if (PTR_ERR(data->pinctrl) == -ENODEV) 345 data->pinctrl = NULL; 346 else if (IS_ERR(data->pinctrl)) { 347 if (PTR_ERR(data->pinctrl) != -EPROBE_DEFER) 348 dev_err(dev, "pinctrl get failed, err=%ld\n", 349 PTR_ERR(data->pinctrl)); 350 return PTR_ERR(data->pinctrl); 351 } 352 353 data->hsic_pad_regulator = 354 devm_regulator_get_optional(dev, "hsic"); 355 if (PTR_ERR(data->hsic_pad_regulator) == -ENODEV) { 356 /* no pad regualator is needed */ 357 data->hsic_pad_regulator = NULL; 358 } else if (IS_ERR(data->hsic_pad_regulator)) { 359 if (PTR_ERR(data->hsic_pad_regulator) != -EPROBE_DEFER) 360 dev_err(dev, 361 "Get HSIC pad regulator error: %ld\n", 362 PTR_ERR(data->hsic_pad_regulator)); 363 return PTR_ERR(data->hsic_pad_regulator); 364 } 365 366 if (data->hsic_pad_regulator) { 367 ret = regulator_enable(data->hsic_pad_regulator); 368 if (ret) { 369 dev_err(dev, 370 "Failed to enable HSIC pad regulator\n"); 371 return ret; 372 } 373 } 374 } 375 376 /* HSIC pinctrl handling */ 377 if (data->pinctrl) { 378 struct pinctrl_state *pinctrl_hsic_idle; 379 380 pinctrl_hsic_idle = pinctrl_lookup_state(data->pinctrl, "idle"); 381 if (IS_ERR(pinctrl_hsic_idle)) { 382 dev_err(dev, 383 "pinctrl_hsic_idle lookup failed, err=%ld\n", 384 PTR_ERR(pinctrl_hsic_idle)); 385 return PTR_ERR(pinctrl_hsic_idle); 386 } 387 388 ret = pinctrl_select_state(data->pinctrl, pinctrl_hsic_idle); 389 if (ret) { 390 dev_err(dev, "hsic_idle select failed, err=%d\n", ret); 391 return ret; 392 } 393 394 data->pinctrl_hsic_active = pinctrl_lookup_state(data->pinctrl, 395 "active"); 396 if (IS_ERR(data->pinctrl_hsic_active)) { 397 dev_err(dev, 398 "pinctrl_hsic_active lookup failed, err=%ld\n", 399 PTR_ERR(data->pinctrl_hsic_active)); 400 return PTR_ERR(data->pinctrl_hsic_active); 401 } 402 } 403 404 if (pdata.flags & CI_HDRC_PMQOS) 405 cpu_latency_qos_add_request(&data->pm_qos_req, 0); 406 407 ret = imx_get_clks(dev); 408 if (ret) 409 goto disable_hsic_regulator; 410 411 ret = imx_prepare_enable_clks(dev); 412 if (ret) 413 goto disable_hsic_regulator; 414 415 data->phy = devm_usb_get_phy_by_phandle(dev, "fsl,usbphy", 0); 416 if (IS_ERR(data->phy)) { 417 ret = PTR_ERR(data->phy); 418 /* Return -EINVAL if no usbphy is available */ 419 if (ret == -ENODEV) 420 data->phy = NULL; 421 else 422 goto err_clk; 423 } 424 425 pdata.usb_phy = data->phy; 426 if (data->usbmisc_data) 427 data->usbmisc_data->usb_phy = data->phy; 428 429 if ((of_device_is_compatible(np, "fsl,imx53-usb") || 430 of_device_is_compatible(np, "fsl,imx51-usb")) && pdata.usb_phy && 431 of_usb_get_phy_mode(np) == USBPHY_INTERFACE_MODE_ULPI) { 432 pdata.flags |= CI_HDRC_OVERRIDE_PHY_CONTROL; 433 data->override_phy_control = true; 434 usb_phy_init(pdata.usb_phy); 435 } 436 437 if (pdata.flags & CI_HDRC_SUPPORTS_RUNTIME_PM) 438 data->supports_runtime_pm = true; 439 440 ret = imx_usbmisc_init(data->usbmisc_data); 441 if (ret) { 442 dev_err(dev, "usbmisc init failed, ret=%d\n", ret); 443 goto err_clk; 444 } 445 446 data->ci_pdev = ci_hdrc_add_device(dev, 447 pdev->resource, pdev->num_resources, 448 &pdata); 449 if (IS_ERR(data->ci_pdev)) { 450 ret = PTR_ERR(data->ci_pdev); 451 if (ret != -EPROBE_DEFER) 452 dev_err(dev, "ci_hdrc_add_device failed, err=%d\n", 453 ret); 454 goto err_clk; 455 } 456 457 if (data->usbmisc_data) { 458 if (!IS_ERR(pdata.id_extcon.edev) || 459 of_property_read_bool(np, "usb-role-switch")) 460 data->usbmisc_data->ext_id = 1; 461 462 if (!IS_ERR(pdata.vbus_extcon.edev) || 463 of_property_read_bool(np, "usb-role-switch")) 464 data->usbmisc_data->ext_vbus = 1; 465 466 /* usbmisc needs to know dr mode to choose wakeup setting */ 467 data->usbmisc_data->available_role = 468 ci_hdrc_query_available_role(data->ci_pdev); 469 } 470 471 ret = imx_usbmisc_init_post(data->usbmisc_data); 472 if (ret) { 473 dev_err(dev, "usbmisc post failed, ret=%d\n", ret); 474 goto disable_device; 475 } 476 477 if (data->supports_runtime_pm) { 478 pm_runtime_set_active(dev); 479 pm_runtime_enable(dev); 480 } 481 482 device_set_wakeup_capable(dev, true); 483 484 return 0; 485 486 disable_device: 487 ci_hdrc_remove_device(data->ci_pdev); 488 err_clk: 489 imx_disable_unprepare_clks(dev); 490 disable_hsic_regulator: 491 if (data->hsic_pad_regulator) 492 /* don't overwrite original ret (cf. EPROBE_DEFER) */ 493 regulator_disable(data->hsic_pad_regulator); 494 if (pdata.flags & CI_HDRC_PMQOS) 495 cpu_latency_qos_remove_request(&data->pm_qos_req); 496 data->ci_pdev = NULL; 497 return ret; 498 } 499 500 static int ci_hdrc_imx_remove(struct platform_device *pdev) 501 { 502 struct ci_hdrc_imx_data *data = platform_get_drvdata(pdev); 503 504 if (data->supports_runtime_pm) { 505 pm_runtime_get_sync(&pdev->dev); 506 pm_runtime_disable(&pdev->dev); 507 pm_runtime_put_noidle(&pdev->dev); 508 } 509 if (data->ci_pdev) 510 ci_hdrc_remove_device(data->ci_pdev); 511 if (data->override_phy_control) 512 usb_phy_shutdown(data->phy); 513 if (data->ci_pdev) { 514 imx_disable_unprepare_clks(&pdev->dev); 515 if (data->plat_data->flags & CI_HDRC_PMQOS) 516 cpu_latency_qos_remove_request(&data->pm_qos_req); 517 if (data->hsic_pad_regulator) 518 regulator_disable(data->hsic_pad_regulator); 519 } 520 521 return 0; 522 } 523 524 static void ci_hdrc_imx_shutdown(struct platform_device *pdev) 525 { 526 ci_hdrc_imx_remove(pdev); 527 } 528 529 static int __maybe_unused imx_controller_suspend(struct device *dev) 530 { 531 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 532 int ret = 0; 533 534 dev_dbg(dev, "at %s\n", __func__); 535 536 ret = imx_usbmisc_hsic_set_clk(data->usbmisc_data, false); 537 if (ret) { 538 dev_err(dev, "usbmisc hsic_set_clk failed, ret=%d\n", ret); 539 return ret; 540 } 541 542 imx_disable_unprepare_clks(dev); 543 if (data->plat_data->flags & CI_HDRC_PMQOS) 544 cpu_latency_qos_remove_request(&data->pm_qos_req); 545 546 data->in_lpm = true; 547 548 return 0; 549 } 550 551 static int __maybe_unused imx_controller_resume(struct device *dev) 552 { 553 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 554 int ret = 0; 555 556 dev_dbg(dev, "at %s\n", __func__); 557 558 if (!data->in_lpm) { 559 WARN_ON(1); 560 return 0; 561 } 562 563 if (data->plat_data->flags & CI_HDRC_PMQOS) 564 cpu_latency_qos_add_request(&data->pm_qos_req, 0); 565 566 ret = imx_prepare_enable_clks(dev); 567 if (ret) 568 return ret; 569 570 data->in_lpm = false; 571 572 ret = imx_usbmisc_set_wakeup(data->usbmisc_data, false); 573 if (ret) { 574 dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret); 575 goto clk_disable; 576 } 577 578 ret = imx_usbmisc_hsic_set_clk(data->usbmisc_data, true); 579 if (ret) { 580 dev_err(dev, "usbmisc hsic_set_clk failed, ret=%d\n", ret); 581 goto hsic_set_clk_fail; 582 } 583 584 return 0; 585 586 hsic_set_clk_fail: 587 imx_usbmisc_set_wakeup(data->usbmisc_data, true); 588 clk_disable: 589 imx_disable_unprepare_clks(dev); 590 return ret; 591 } 592 593 static int __maybe_unused ci_hdrc_imx_suspend(struct device *dev) 594 { 595 int ret; 596 597 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 598 599 if (data->in_lpm) 600 /* The core's suspend doesn't run */ 601 return 0; 602 603 if (device_may_wakeup(dev)) { 604 ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true); 605 if (ret) { 606 dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", 607 ret); 608 return ret; 609 } 610 } 611 612 return imx_controller_suspend(dev); 613 } 614 615 static int __maybe_unused ci_hdrc_imx_resume(struct device *dev) 616 { 617 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 618 int ret; 619 620 ret = imx_controller_resume(dev); 621 if (!ret && data->supports_runtime_pm) { 622 pm_runtime_disable(dev); 623 pm_runtime_set_active(dev); 624 pm_runtime_enable(dev); 625 } 626 627 return ret; 628 } 629 630 static int __maybe_unused ci_hdrc_imx_runtime_suspend(struct device *dev) 631 { 632 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 633 int ret; 634 635 if (data->in_lpm) { 636 WARN_ON(1); 637 return 0; 638 } 639 640 ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true); 641 if (ret) { 642 dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret); 643 return ret; 644 } 645 646 return imx_controller_suspend(dev); 647 } 648 649 static int __maybe_unused ci_hdrc_imx_runtime_resume(struct device *dev) 650 { 651 return imx_controller_resume(dev); 652 } 653 654 static const struct dev_pm_ops ci_hdrc_imx_pm_ops = { 655 SET_SYSTEM_SLEEP_PM_OPS(ci_hdrc_imx_suspend, ci_hdrc_imx_resume) 656 SET_RUNTIME_PM_OPS(ci_hdrc_imx_runtime_suspend, 657 ci_hdrc_imx_runtime_resume, NULL) 658 }; 659 static struct platform_driver ci_hdrc_imx_driver = { 660 .probe = ci_hdrc_imx_probe, 661 .remove = ci_hdrc_imx_remove, 662 .shutdown = ci_hdrc_imx_shutdown, 663 .driver = { 664 .name = "imx_usb", 665 .of_match_table = ci_hdrc_imx_dt_ids, 666 .pm = &ci_hdrc_imx_pm_ops, 667 }, 668 }; 669 670 module_platform_driver(ci_hdrc_imx_driver); 671 672 MODULE_ALIAS("platform:imx-usb"); 673 MODULE_LICENSE("GPL"); 674 MODULE_DESCRIPTION("CI HDRC i.MX USB binding"); 675 MODULE_AUTHOR("Marek Vasut <marex@denx.de>"); 676 MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>"); 677