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/of_gpio.h> 11 #include <linux/platform_device.h> 12 #include <linux/pm_runtime.h> 13 #include <linux/dma-mapping.h> 14 #include <linux/usb/chipidea.h> 15 #include <linux/usb/of.h> 16 #include <linux/clk.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 of_device_id ci_hdrc_imx_dt_ids[] = { 68 { .compatible = "fsl,imx23-usb", .data = &imx23_usb_data}, 69 { .compatible = "fsl,imx28-usb", .data = &imx28_usb_data}, 70 { .compatible = "fsl,imx27-usb", .data = &imx27_usb_data}, 71 { .compatible = "fsl,imx6q-usb", .data = &imx6q_usb_data}, 72 { .compatible = "fsl,imx6sl-usb", .data = &imx6sl_usb_data}, 73 { .compatible = "fsl,imx6sx-usb", .data = &imx6sx_usb_data}, 74 { .compatible = "fsl,imx6ul-usb", .data = &imx6ul_usb_data}, 75 { .compatible = "fsl,imx7d-usb", .data = &imx7d_usb_data}, 76 { /* sentinel */ } 77 }; 78 MODULE_DEVICE_TABLE(of, ci_hdrc_imx_dt_ids); 79 80 struct ci_hdrc_imx_data { 81 struct usb_phy *phy; 82 struct platform_device *ci_pdev; 83 struct clk *clk; 84 struct imx_usbmisc_data *usbmisc_data; 85 bool supports_runtime_pm; 86 bool override_phy_control; 87 bool in_lpm; 88 /* SoC before i.mx6 (except imx23/imx28) needs three clks */ 89 bool need_three_clks; 90 struct clk *clk_ipg; 91 struct clk *clk_ahb; 92 struct clk *clk_per; 93 /* --------------------------------- */ 94 }; 95 96 /* Common functions shared by usbmisc drivers */ 97 98 static struct imx_usbmisc_data *usbmisc_get_init_data(struct device *dev) 99 { 100 struct platform_device *misc_pdev; 101 struct device_node *np = dev->of_node; 102 struct of_phandle_args args; 103 struct imx_usbmisc_data *data; 104 int ret; 105 106 /* 107 * In case the fsl,usbmisc property is not present this device doesn't 108 * need usbmisc. Return NULL (which is no error here) 109 */ 110 if (!of_get_property(np, "fsl,usbmisc", NULL)) 111 return NULL; 112 113 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 114 if (!data) 115 return ERR_PTR(-ENOMEM); 116 117 ret = of_parse_phandle_with_args(np, "fsl,usbmisc", "#index-cells", 118 0, &args); 119 if (ret) { 120 dev_err(dev, "Failed to parse property fsl,usbmisc, errno %d\n", 121 ret); 122 return ERR_PTR(ret); 123 } 124 125 data->index = args.args[0]; 126 127 misc_pdev = of_find_device_by_node(args.np); 128 of_node_put(args.np); 129 130 if (!misc_pdev || !platform_get_drvdata(misc_pdev)) 131 return ERR_PTR(-EPROBE_DEFER); 132 133 data->dev = &misc_pdev->dev; 134 135 if (of_find_property(np, "disable-over-current", NULL)) 136 data->disable_oc = 1; 137 138 if (of_find_property(np, "over-current-active-high", NULL)) 139 data->oc_polarity = 1; 140 141 if (of_find_property(np, "external-vbus-divider", NULL)) 142 data->evdo = 1; 143 144 if (of_usb_get_phy_mode(np) == USBPHY_INTERFACE_MODE_ULPI) 145 data->ulpi = 1; 146 147 return data; 148 } 149 150 /* End of common functions shared by usbmisc drivers*/ 151 static int imx_get_clks(struct device *dev) 152 { 153 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 154 int ret = 0; 155 156 data->clk_ipg = devm_clk_get(dev, "ipg"); 157 if (IS_ERR(data->clk_ipg)) { 158 /* If the platform only needs one clocks */ 159 data->clk = devm_clk_get(dev, NULL); 160 if (IS_ERR(data->clk)) { 161 ret = PTR_ERR(data->clk); 162 dev_err(dev, 163 "Failed to get clks, err=%ld,%ld\n", 164 PTR_ERR(data->clk), PTR_ERR(data->clk_ipg)); 165 return ret; 166 } 167 return ret; 168 } 169 170 data->clk_ahb = devm_clk_get(dev, "ahb"); 171 if (IS_ERR(data->clk_ahb)) { 172 ret = PTR_ERR(data->clk_ahb); 173 dev_err(dev, 174 "Failed to get ahb clock, err=%d\n", ret); 175 return ret; 176 } 177 178 data->clk_per = devm_clk_get(dev, "per"); 179 if (IS_ERR(data->clk_per)) { 180 ret = PTR_ERR(data->clk_per); 181 dev_err(dev, 182 "Failed to get per clock, err=%d\n", ret); 183 return ret; 184 } 185 186 data->need_three_clks = true; 187 return ret; 188 } 189 190 static int imx_prepare_enable_clks(struct device *dev) 191 { 192 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 193 int ret = 0; 194 195 if (data->need_three_clks) { 196 ret = clk_prepare_enable(data->clk_ipg); 197 if (ret) { 198 dev_err(dev, 199 "Failed to prepare/enable ipg clk, err=%d\n", 200 ret); 201 return ret; 202 } 203 204 ret = clk_prepare_enable(data->clk_ahb); 205 if (ret) { 206 dev_err(dev, 207 "Failed to prepare/enable ahb clk, err=%d\n", 208 ret); 209 clk_disable_unprepare(data->clk_ipg); 210 return ret; 211 } 212 213 ret = clk_prepare_enable(data->clk_per); 214 if (ret) { 215 dev_err(dev, 216 "Failed to prepare/enable per clk, err=%d\n", 217 ret); 218 clk_disable_unprepare(data->clk_ahb); 219 clk_disable_unprepare(data->clk_ipg); 220 return ret; 221 } 222 } else { 223 ret = clk_prepare_enable(data->clk); 224 if (ret) { 225 dev_err(dev, 226 "Failed to prepare/enable clk, err=%d\n", 227 ret); 228 return ret; 229 } 230 } 231 232 return ret; 233 } 234 235 static void imx_disable_unprepare_clks(struct device *dev) 236 { 237 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 238 239 if (data->need_three_clks) { 240 clk_disable_unprepare(data->clk_per); 241 clk_disable_unprepare(data->clk_ahb); 242 clk_disable_unprepare(data->clk_ipg); 243 } else { 244 clk_disable_unprepare(data->clk); 245 } 246 } 247 248 static int ci_hdrc_imx_probe(struct platform_device *pdev) 249 { 250 struct ci_hdrc_imx_data *data; 251 struct ci_hdrc_platform_data pdata = { 252 .name = dev_name(&pdev->dev), 253 .capoffset = DEF_CAPOFFSET, 254 }; 255 int ret; 256 const struct of_device_id *of_id; 257 const struct ci_hdrc_imx_platform_flag *imx_platform_flag; 258 struct device_node *np = pdev->dev.of_node; 259 260 of_id = of_match_device(ci_hdrc_imx_dt_ids, &pdev->dev); 261 if (!of_id) 262 return -ENODEV; 263 264 imx_platform_flag = of_id->data; 265 266 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); 267 if (!data) 268 return -ENOMEM; 269 270 platform_set_drvdata(pdev, data); 271 data->usbmisc_data = usbmisc_get_init_data(&pdev->dev); 272 if (IS_ERR(data->usbmisc_data)) 273 return PTR_ERR(data->usbmisc_data); 274 275 ret = imx_get_clks(&pdev->dev); 276 if (ret) 277 return ret; 278 279 ret = imx_prepare_enable_clks(&pdev->dev); 280 if (ret) 281 return ret; 282 283 data->phy = devm_usb_get_phy_by_phandle(&pdev->dev, "fsl,usbphy", 0); 284 if (IS_ERR(data->phy)) { 285 ret = PTR_ERR(data->phy); 286 /* Return -EINVAL if no usbphy is available */ 287 if (ret == -ENODEV) 288 ret = -EINVAL; 289 goto err_clk; 290 } 291 292 pdata.usb_phy = data->phy; 293 294 if (of_device_is_compatible(np, "fsl,imx53-usb") && pdata.usb_phy && 295 of_usb_get_phy_mode(np) == USBPHY_INTERFACE_MODE_ULPI) { 296 pdata.flags |= CI_HDRC_OVERRIDE_PHY_CONTROL; 297 data->override_phy_control = true; 298 usb_phy_init(pdata.usb_phy); 299 } 300 301 pdata.flags |= imx_platform_flag->flags; 302 if (pdata.flags & CI_HDRC_SUPPORTS_RUNTIME_PM) 303 data->supports_runtime_pm = true; 304 305 ret = imx_usbmisc_init(data->usbmisc_data); 306 if (ret) { 307 dev_err(&pdev->dev, "usbmisc init failed, ret=%d\n", ret); 308 goto err_clk; 309 } 310 311 data->ci_pdev = ci_hdrc_add_device(&pdev->dev, 312 pdev->resource, pdev->num_resources, 313 &pdata); 314 if (IS_ERR(data->ci_pdev)) { 315 ret = PTR_ERR(data->ci_pdev); 316 if (ret != -EPROBE_DEFER) 317 dev_err(&pdev->dev, 318 "ci_hdrc_add_device failed, err=%d\n", ret); 319 goto err_clk; 320 } 321 322 ret = imx_usbmisc_init_post(data->usbmisc_data); 323 if (ret) { 324 dev_err(&pdev->dev, "usbmisc post failed, ret=%d\n", ret); 325 goto disable_device; 326 } 327 328 if (data->supports_runtime_pm) { 329 pm_runtime_set_active(&pdev->dev); 330 pm_runtime_enable(&pdev->dev); 331 } 332 333 device_set_wakeup_capable(&pdev->dev, true); 334 335 return 0; 336 337 disable_device: 338 ci_hdrc_remove_device(data->ci_pdev); 339 err_clk: 340 imx_disable_unprepare_clks(&pdev->dev); 341 return ret; 342 } 343 344 static int ci_hdrc_imx_remove(struct platform_device *pdev) 345 { 346 struct ci_hdrc_imx_data *data = platform_get_drvdata(pdev); 347 348 if (data->supports_runtime_pm) { 349 pm_runtime_get_sync(&pdev->dev); 350 pm_runtime_disable(&pdev->dev); 351 pm_runtime_put_noidle(&pdev->dev); 352 } 353 ci_hdrc_remove_device(data->ci_pdev); 354 if (data->override_phy_control) 355 usb_phy_shutdown(data->phy); 356 imx_disable_unprepare_clks(&pdev->dev); 357 358 return 0; 359 } 360 361 static void ci_hdrc_imx_shutdown(struct platform_device *pdev) 362 { 363 ci_hdrc_imx_remove(pdev); 364 } 365 366 #ifdef CONFIG_PM 367 static int imx_controller_suspend(struct device *dev) 368 { 369 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 370 371 dev_dbg(dev, "at %s\n", __func__); 372 373 imx_disable_unprepare_clks(dev); 374 data->in_lpm = true; 375 376 return 0; 377 } 378 379 static int imx_controller_resume(struct device *dev) 380 { 381 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 382 int ret = 0; 383 384 dev_dbg(dev, "at %s\n", __func__); 385 386 if (!data->in_lpm) { 387 WARN_ON(1); 388 return 0; 389 } 390 391 ret = imx_prepare_enable_clks(dev); 392 if (ret) 393 return ret; 394 395 data->in_lpm = false; 396 397 ret = imx_usbmisc_set_wakeup(data->usbmisc_data, false); 398 if (ret) { 399 dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret); 400 goto clk_disable; 401 } 402 403 return 0; 404 405 clk_disable: 406 imx_disable_unprepare_clks(dev); 407 return ret; 408 } 409 410 #ifdef CONFIG_PM_SLEEP 411 static int ci_hdrc_imx_suspend(struct device *dev) 412 { 413 int ret; 414 415 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 416 417 if (data->in_lpm) 418 /* The core's suspend doesn't run */ 419 return 0; 420 421 if (device_may_wakeup(dev)) { 422 ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true); 423 if (ret) { 424 dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", 425 ret); 426 return ret; 427 } 428 } 429 430 return imx_controller_suspend(dev); 431 } 432 433 static int ci_hdrc_imx_resume(struct device *dev) 434 { 435 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 436 int ret; 437 438 ret = imx_controller_resume(dev); 439 if (!ret && data->supports_runtime_pm) { 440 pm_runtime_disable(dev); 441 pm_runtime_set_active(dev); 442 pm_runtime_enable(dev); 443 } 444 445 return ret; 446 } 447 #endif /* CONFIG_PM_SLEEP */ 448 449 static int ci_hdrc_imx_runtime_suspend(struct device *dev) 450 { 451 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 452 int ret; 453 454 if (data->in_lpm) { 455 WARN_ON(1); 456 return 0; 457 } 458 459 ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true); 460 if (ret) { 461 dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret); 462 return ret; 463 } 464 465 return imx_controller_suspend(dev); 466 } 467 468 static int ci_hdrc_imx_runtime_resume(struct device *dev) 469 { 470 return imx_controller_resume(dev); 471 } 472 473 #endif /* CONFIG_PM */ 474 475 static const struct dev_pm_ops ci_hdrc_imx_pm_ops = { 476 SET_SYSTEM_SLEEP_PM_OPS(ci_hdrc_imx_suspend, ci_hdrc_imx_resume) 477 SET_RUNTIME_PM_OPS(ci_hdrc_imx_runtime_suspend, 478 ci_hdrc_imx_runtime_resume, NULL) 479 }; 480 static struct platform_driver ci_hdrc_imx_driver = { 481 .probe = ci_hdrc_imx_probe, 482 .remove = ci_hdrc_imx_remove, 483 .shutdown = ci_hdrc_imx_shutdown, 484 .driver = { 485 .name = "imx_usb", 486 .of_match_table = ci_hdrc_imx_dt_ids, 487 .pm = &ci_hdrc_imx_pm_ops, 488 }, 489 }; 490 491 module_platform_driver(ci_hdrc_imx_driver); 492 493 MODULE_ALIAS("platform:imx-usb"); 494 MODULE_LICENSE("GPL v2"); 495 MODULE_DESCRIPTION("CI HDRC i.MX USB binding"); 496 MODULE_AUTHOR("Marek Vasut <marex@denx.de>"); 497 MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>"); 498