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 bool runtime_pm; 24 }; 25 26 static const struct ci_hdrc_imx_platform_flag imx23_usb_data = { 27 .flags = CI_HDRC_TURN_VBUS_EARLY_ON | 28 CI_HDRC_DISABLE_STREAMING, 29 }; 30 31 static const struct ci_hdrc_imx_platform_flag imx27_usb_data = { 32 CI_HDRC_DISABLE_STREAMING, 33 }; 34 35 static const struct ci_hdrc_imx_platform_flag imx28_usb_data = { 36 .flags = CI_HDRC_IMX28_WRITE_FIX | 37 CI_HDRC_TURN_VBUS_EARLY_ON | 38 CI_HDRC_DISABLE_STREAMING, 39 }; 40 41 static const struct ci_hdrc_imx_platform_flag imx6q_usb_data = { 42 .flags = CI_HDRC_SUPPORTS_RUNTIME_PM | 43 CI_HDRC_TURN_VBUS_EARLY_ON | 44 CI_HDRC_DISABLE_STREAMING, 45 }; 46 47 static const struct ci_hdrc_imx_platform_flag imx6sl_usb_data = { 48 .flags = CI_HDRC_SUPPORTS_RUNTIME_PM | 49 CI_HDRC_TURN_VBUS_EARLY_ON | 50 CI_HDRC_DISABLE_HOST_STREAMING, 51 }; 52 53 static const struct ci_hdrc_imx_platform_flag imx6sx_usb_data = { 54 .flags = CI_HDRC_SUPPORTS_RUNTIME_PM | 55 CI_HDRC_TURN_VBUS_EARLY_ON | 56 CI_HDRC_DISABLE_HOST_STREAMING, 57 }; 58 59 static const struct ci_hdrc_imx_platform_flag imx6ul_usb_data = { 60 .flags = CI_HDRC_SUPPORTS_RUNTIME_PM | 61 CI_HDRC_TURN_VBUS_EARLY_ON, 62 }; 63 64 static const struct ci_hdrc_imx_platform_flag imx7d_usb_data = { 65 .flags = CI_HDRC_SUPPORTS_RUNTIME_PM, 66 }; 67 68 static const struct of_device_id ci_hdrc_imx_dt_ids[] = { 69 { .compatible = "fsl,imx23-usb", .data = &imx23_usb_data}, 70 { .compatible = "fsl,imx28-usb", .data = &imx28_usb_data}, 71 { .compatible = "fsl,imx27-usb", .data = &imx27_usb_data}, 72 { .compatible = "fsl,imx6q-usb", .data = &imx6q_usb_data}, 73 { .compatible = "fsl,imx6sl-usb", .data = &imx6sl_usb_data}, 74 { .compatible = "fsl,imx6sx-usb", .data = &imx6sx_usb_data}, 75 { .compatible = "fsl,imx6ul-usb", .data = &imx6ul_usb_data}, 76 { .compatible = "fsl,imx7d-usb", .data = &imx7d_usb_data}, 77 { /* sentinel */ } 78 }; 79 MODULE_DEVICE_TABLE(of, ci_hdrc_imx_dt_ids); 80 81 struct ci_hdrc_imx_data { 82 struct usb_phy *phy; 83 struct platform_device *ci_pdev; 84 struct clk *clk; 85 struct imx_usbmisc_data *usbmisc_data; 86 bool supports_runtime_pm; 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 259 of_id = of_match_device(ci_hdrc_imx_dt_ids, &pdev->dev); 260 if (!of_id) 261 return -ENODEV; 262 263 imx_platform_flag = of_id->data; 264 265 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); 266 if (!data) 267 return -ENOMEM; 268 269 platform_set_drvdata(pdev, data); 270 data->usbmisc_data = usbmisc_get_init_data(&pdev->dev); 271 if (IS_ERR(data->usbmisc_data)) 272 return PTR_ERR(data->usbmisc_data); 273 274 ret = imx_get_clks(&pdev->dev); 275 if (ret) 276 return ret; 277 278 ret = imx_prepare_enable_clks(&pdev->dev); 279 if (ret) 280 return ret; 281 282 data->phy = devm_usb_get_phy_by_phandle(&pdev->dev, "fsl,usbphy", 0); 283 if (IS_ERR(data->phy)) { 284 ret = PTR_ERR(data->phy); 285 /* Return -EINVAL if no usbphy is available */ 286 if (ret == -ENODEV) 287 ret = -EINVAL; 288 goto err_clk; 289 } 290 291 pdata.usb_phy = data->phy; 292 pdata.flags |= imx_platform_flag->flags; 293 if (pdata.flags & CI_HDRC_SUPPORTS_RUNTIME_PM) 294 data->supports_runtime_pm = true; 295 296 ret = imx_usbmisc_init(data->usbmisc_data); 297 if (ret) { 298 dev_err(&pdev->dev, "usbmisc init failed, ret=%d\n", ret); 299 goto err_clk; 300 } 301 302 data->ci_pdev = ci_hdrc_add_device(&pdev->dev, 303 pdev->resource, pdev->num_resources, 304 &pdata); 305 if (IS_ERR(data->ci_pdev)) { 306 ret = PTR_ERR(data->ci_pdev); 307 if (ret != -EPROBE_DEFER) 308 dev_err(&pdev->dev, 309 "ci_hdrc_add_device failed, err=%d\n", ret); 310 goto err_clk; 311 } 312 313 ret = imx_usbmisc_init_post(data->usbmisc_data); 314 if (ret) { 315 dev_err(&pdev->dev, "usbmisc post failed, ret=%d\n", ret); 316 goto disable_device; 317 } 318 319 if (data->supports_runtime_pm) { 320 pm_runtime_set_active(&pdev->dev); 321 pm_runtime_enable(&pdev->dev); 322 } 323 324 device_set_wakeup_capable(&pdev->dev, true); 325 326 return 0; 327 328 disable_device: 329 ci_hdrc_remove_device(data->ci_pdev); 330 err_clk: 331 imx_disable_unprepare_clks(&pdev->dev); 332 return ret; 333 } 334 335 static int ci_hdrc_imx_remove(struct platform_device *pdev) 336 { 337 struct ci_hdrc_imx_data *data = platform_get_drvdata(pdev); 338 339 if (data->supports_runtime_pm) { 340 pm_runtime_get_sync(&pdev->dev); 341 pm_runtime_disable(&pdev->dev); 342 pm_runtime_put_noidle(&pdev->dev); 343 } 344 ci_hdrc_remove_device(data->ci_pdev); 345 imx_disable_unprepare_clks(&pdev->dev); 346 347 return 0; 348 } 349 350 static void ci_hdrc_imx_shutdown(struct platform_device *pdev) 351 { 352 ci_hdrc_imx_remove(pdev); 353 } 354 355 #ifdef CONFIG_PM 356 static int imx_controller_suspend(struct device *dev) 357 { 358 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 359 360 dev_dbg(dev, "at %s\n", __func__); 361 362 imx_disable_unprepare_clks(dev); 363 data->in_lpm = true; 364 365 return 0; 366 } 367 368 static int imx_controller_resume(struct device *dev) 369 { 370 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 371 int ret = 0; 372 373 dev_dbg(dev, "at %s\n", __func__); 374 375 if (!data->in_lpm) { 376 WARN_ON(1); 377 return 0; 378 } 379 380 ret = imx_prepare_enable_clks(dev); 381 if (ret) 382 return ret; 383 384 data->in_lpm = false; 385 386 ret = imx_usbmisc_set_wakeup(data->usbmisc_data, false); 387 if (ret) { 388 dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret); 389 goto clk_disable; 390 } 391 392 return 0; 393 394 clk_disable: 395 imx_disable_unprepare_clks(dev); 396 return ret; 397 } 398 399 #ifdef CONFIG_PM_SLEEP 400 static int ci_hdrc_imx_suspend(struct device *dev) 401 { 402 int ret; 403 404 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 405 406 if (data->in_lpm) 407 /* The core's suspend doesn't run */ 408 return 0; 409 410 if (device_may_wakeup(dev)) { 411 ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true); 412 if (ret) { 413 dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", 414 ret); 415 return ret; 416 } 417 } 418 419 return imx_controller_suspend(dev); 420 } 421 422 static int ci_hdrc_imx_resume(struct device *dev) 423 { 424 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 425 int ret; 426 427 ret = imx_controller_resume(dev); 428 if (!ret && data->supports_runtime_pm) { 429 pm_runtime_disable(dev); 430 pm_runtime_set_active(dev); 431 pm_runtime_enable(dev); 432 } 433 434 return ret; 435 } 436 #endif /* CONFIG_PM_SLEEP */ 437 438 static int ci_hdrc_imx_runtime_suspend(struct device *dev) 439 { 440 struct ci_hdrc_imx_data *data = dev_get_drvdata(dev); 441 int ret; 442 443 if (data->in_lpm) { 444 WARN_ON(1); 445 return 0; 446 } 447 448 ret = imx_usbmisc_set_wakeup(data->usbmisc_data, true); 449 if (ret) { 450 dev_err(dev, "usbmisc set_wakeup failed, ret=%d\n", ret); 451 return ret; 452 } 453 454 return imx_controller_suspend(dev); 455 } 456 457 static int ci_hdrc_imx_runtime_resume(struct device *dev) 458 { 459 return imx_controller_resume(dev); 460 } 461 462 #endif /* CONFIG_PM */ 463 464 static const struct dev_pm_ops ci_hdrc_imx_pm_ops = { 465 SET_SYSTEM_SLEEP_PM_OPS(ci_hdrc_imx_suspend, ci_hdrc_imx_resume) 466 SET_RUNTIME_PM_OPS(ci_hdrc_imx_runtime_suspend, 467 ci_hdrc_imx_runtime_resume, NULL) 468 }; 469 static struct platform_driver ci_hdrc_imx_driver = { 470 .probe = ci_hdrc_imx_probe, 471 .remove = ci_hdrc_imx_remove, 472 .shutdown = ci_hdrc_imx_shutdown, 473 .driver = { 474 .name = "imx_usb", 475 .of_match_table = ci_hdrc_imx_dt_ids, 476 .pm = &ci_hdrc_imx_pm_ops, 477 }, 478 }; 479 480 module_platform_driver(ci_hdrc_imx_driver); 481 482 MODULE_ALIAS("platform:imx-usb"); 483 MODULE_LICENSE("GPL v2"); 484 MODULE_DESCRIPTION("CI HDRC i.MX USB binding"); 485 MODULE_AUTHOR("Marek Vasut <marex@denx.de>"); 486 MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>"); 487