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