1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * omap_device implementation 4 * 5 * Copyright (C) 2009-2010 Nokia Corporation 6 * Paul Walmsley, Kevin Hilman 7 * 8 * Developed in collaboration with (alphabetical order): Benoit 9 * Cousson, Thara Gopinath, Tony Lindgren, Rajendra Nayak, Vikram 10 * Pandita, Sakari Poussa, Anand Sawant, Santosh Shilimkar, Richard 11 * Woodruff 12 * 13 * This code provides a consistent interface for OMAP device drivers 14 * to control power management and interconnect properties of their 15 * devices. 16 * 17 * In the medium- to long-term, this code should be implemented as a 18 * proper omap_bus/omap_device in Linux, no more platform_data func 19 * pointers 20 */ 21 #undef DEBUG 22 23 #include <linux/kernel.h> 24 #include <linux/platform_device.h> 25 #include <linux/slab.h> 26 #include <linux/err.h> 27 #include <linux/io.h> 28 #include <linux/clk.h> 29 #include <linux/clkdev.h> 30 #include <linux/pm_domain.h> 31 #include <linux/pm_runtime.h> 32 #include <linux/of.h> 33 #include <linux/of_address.h> 34 #include <linux/of_irq.h> 35 #include <linux/notifier.h> 36 37 #include "common.h" 38 #include "soc.h" 39 #include "omap_device.h" 40 #include "omap_hwmod.h" 41 42 static struct omap_device *omap_device_alloc(struct platform_device *pdev, 43 struct omap_hwmod **ohs, int oh_cnt); 44 static void omap_device_delete(struct omap_device *od); 45 static struct dev_pm_domain omap_device_fail_pm_domain; 46 static struct dev_pm_domain omap_device_pm_domain; 47 48 /* Private functions */ 49 50 static void _add_clkdev(struct omap_device *od, const char *clk_alias, 51 const char *clk_name) 52 { 53 struct clk *r; 54 int rc; 55 56 if (!clk_alias || !clk_name) 57 return; 58 59 dev_dbg(&od->pdev->dev, "Creating %s -> %s\n", clk_alias, clk_name); 60 61 r = clk_get_sys(dev_name(&od->pdev->dev), clk_alias); 62 if (!IS_ERR(r)) { 63 dev_dbg(&od->pdev->dev, 64 "alias %s already exists\n", clk_alias); 65 clk_put(r); 66 return; 67 } 68 69 r = clk_get_sys(NULL, clk_name); 70 71 if (IS_ERR(r)) { 72 struct of_phandle_args clkspec; 73 74 clkspec.np = of_find_node_by_name(NULL, clk_name); 75 76 r = of_clk_get_from_provider(&clkspec); 77 78 rc = clk_register_clkdev(r, clk_alias, 79 dev_name(&od->pdev->dev)); 80 } else { 81 rc = clk_add_alias(clk_alias, dev_name(&od->pdev->dev), 82 clk_name, NULL); 83 } 84 85 if (rc) { 86 if (rc == -ENODEV || rc == -ENOMEM) 87 dev_err(&od->pdev->dev, 88 "clkdev_alloc for %s failed\n", clk_alias); 89 else 90 dev_err(&od->pdev->dev, 91 "clk_get for %s failed\n", clk_name); 92 } 93 } 94 95 /** 96 * _add_hwmod_clocks_clkdev - Add clkdev entry for hwmod optional clocks 97 * and main clock 98 * @od: struct omap_device *od 99 * @oh: struct omap_hwmod *oh 100 * 101 * For the main clock and every optional clock present per hwmod per 102 * omap_device, this function adds an entry in the clkdev table of the 103 * form <dev-id=dev_name, con-id=role> if it does not exist already. 104 * 105 * This allows drivers to get a pointer to its optional clocks based on its role 106 * by calling clk_get(<dev*>, <role>). 107 * In the case of the main clock, a "fck" alias is used. 108 * 109 * No return value. 110 */ 111 static void _add_hwmod_clocks_clkdev(struct omap_device *od, 112 struct omap_hwmod *oh) 113 { 114 int i; 115 116 _add_clkdev(od, "fck", oh->main_clk); 117 118 for (i = 0; i < oh->opt_clks_cnt; i++) 119 _add_clkdev(od, oh->opt_clks[i].role, oh->opt_clks[i].clk); 120 } 121 122 123 /** 124 * omap_device_build_from_dt - build an omap_device with multiple hwmods 125 * @pdev: The platform device to update. 126 * 127 * Function for building an omap_device already registered from device-tree 128 * 129 * Returns 0 or PTR_ERR() on error. 130 */ 131 static int omap_device_build_from_dt(struct platform_device *pdev) 132 { 133 struct omap_hwmod **hwmods; 134 struct omap_device *od; 135 struct omap_hwmod *oh; 136 struct device_node *node = pdev->dev.of_node; 137 struct resource res; 138 const char *oh_name; 139 int oh_cnt, i, ret = 0; 140 bool device_active = false, skip_pm_domain = false; 141 142 oh_cnt = of_property_count_strings(node, "ti,hwmods"); 143 if (oh_cnt <= 0) { 144 dev_dbg(&pdev->dev, "No 'hwmods' to build omap_device\n"); 145 return -ENODEV; 146 } 147 148 /* SDMA still needs special handling for omap_device_build() */ 149 ret = of_property_read_string_index(node, "ti,hwmods", 0, &oh_name); 150 if (!ret && (!strncmp("dma_system", oh_name, 10) || 151 !strncmp("dma", oh_name, 3))) 152 skip_pm_domain = true; 153 154 /* Use ti-sysc driver instead of omap_device? */ 155 if (!skip_pm_domain && 156 !omap_hwmod_parse_module_range(NULL, node, &res)) 157 return -ENODEV; 158 159 hwmods = kcalloc(oh_cnt, sizeof(struct omap_hwmod *), GFP_KERNEL); 160 if (!hwmods) { 161 ret = -ENOMEM; 162 goto odbfd_exit; 163 } 164 165 for (i = 0; i < oh_cnt; i++) { 166 of_property_read_string_index(node, "ti,hwmods", i, &oh_name); 167 oh = omap_hwmod_lookup(oh_name); 168 if (!oh) { 169 dev_err(&pdev->dev, "Cannot lookup hwmod '%s'\n", 170 oh_name); 171 ret = -EINVAL; 172 goto odbfd_exit1; 173 } 174 hwmods[i] = oh; 175 if (oh->flags & HWMOD_INIT_NO_IDLE) 176 device_active = true; 177 } 178 179 od = omap_device_alloc(pdev, hwmods, oh_cnt); 180 if (IS_ERR(od)) { 181 dev_err(&pdev->dev, "Cannot allocate omap_device for :%s\n", 182 oh_name); 183 ret = PTR_ERR(od); 184 goto odbfd_exit1; 185 } 186 187 /* Fix up missing resource names */ 188 for (i = 0; i < pdev->num_resources; i++) { 189 struct resource *r = &pdev->resource[i]; 190 191 if (r->name == NULL) 192 r->name = dev_name(&pdev->dev); 193 } 194 195 if (!skip_pm_domain) { 196 dev_pm_domain_set(&pdev->dev, &omap_device_pm_domain); 197 if (device_active) { 198 omap_device_enable(pdev); 199 pm_runtime_set_active(&pdev->dev); 200 } 201 } 202 203 odbfd_exit1: 204 kfree(hwmods); 205 odbfd_exit: 206 /* if data/we are at fault.. load up a fail handler */ 207 if (ret) 208 dev_pm_domain_set(&pdev->dev, &omap_device_fail_pm_domain); 209 210 return ret; 211 } 212 213 static int _omap_device_notifier_call(struct notifier_block *nb, 214 unsigned long event, void *dev) 215 { 216 struct platform_device *pdev = to_platform_device(dev); 217 struct omap_device *od; 218 int err; 219 220 switch (event) { 221 case BUS_NOTIFY_REMOVED_DEVICE: 222 if (pdev->archdata.od) 223 omap_device_delete(pdev->archdata.od); 224 break; 225 case BUS_NOTIFY_UNBOUND_DRIVER: 226 od = to_omap_device(pdev); 227 if (od && (od->_state == OMAP_DEVICE_STATE_ENABLED)) { 228 dev_info(dev, "enabled after unload, idling\n"); 229 err = omap_device_idle(pdev); 230 if (err) 231 dev_err(dev, "failed to idle\n"); 232 } 233 break; 234 case BUS_NOTIFY_BIND_DRIVER: 235 od = to_omap_device(pdev); 236 if (od) { 237 od->_driver_status = BUS_NOTIFY_BIND_DRIVER; 238 if (od->_state == OMAP_DEVICE_STATE_ENABLED && 239 pm_runtime_status_suspended(dev)) { 240 pm_runtime_set_active(dev); 241 } 242 } 243 break; 244 case BUS_NOTIFY_ADD_DEVICE: 245 if (pdev->dev.of_node) 246 omap_device_build_from_dt(pdev); 247 omap_auxdata_legacy_init(dev); 248 fallthrough; 249 default: 250 od = to_omap_device(pdev); 251 if (od) 252 od->_driver_status = event; 253 } 254 255 return NOTIFY_DONE; 256 } 257 258 /** 259 * _omap_device_enable_hwmods - call omap_hwmod_enable() on all hwmods 260 * @od: struct omap_device *od 261 * 262 * Enable all underlying hwmods. Returns 0. 263 */ 264 static int _omap_device_enable_hwmods(struct omap_device *od) 265 { 266 int ret = 0; 267 int i; 268 269 for (i = 0; i < od->hwmods_cnt; i++) 270 ret |= omap_hwmod_enable(od->hwmods[i]); 271 272 return ret; 273 } 274 275 /** 276 * _omap_device_idle_hwmods - call omap_hwmod_idle() on all hwmods 277 * @od: struct omap_device *od 278 * 279 * Idle all underlying hwmods. Returns 0. 280 */ 281 static int _omap_device_idle_hwmods(struct omap_device *od) 282 { 283 int ret = 0; 284 int i; 285 286 for (i = 0; i < od->hwmods_cnt; i++) 287 ret |= omap_hwmod_idle(od->hwmods[i]); 288 289 return ret; 290 } 291 292 /* Public functions for use by core code */ 293 294 /** 295 * omap_device_alloc - allocate an omap_device 296 * @pdev: platform_device that will be included in this omap_device 297 * @ohs: ptr to the omap_hwmod for this omap_device 298 * @oh_cnt: the size of the ohs list 299 * 300 * Convenience function for allocating an omap_device structure and filling 301 * hwmods, and resources. 302 * 303 * Returns an struct omap_device pointer or ERR_PTR() on error; 304 */ 305 static struct omap_device *omap_device_alloc(struct platform_device *pdev, 306 struct omap_hwmod **ohs, int oh_cnt) 307 { 308 int ret = -ENOMEM; 309 struct omap_device *od; 310 int i; 311 struct omap_hwmod **hwmods; 312 313 od = kzalloc(sizeof(struct omap_device), GFP_KERNEL); 314 if (!od) 315 goto oda_exit1; 316 317 od->hwmods_cnt = oh_cnt; 318 319 hwmods = kmemdup(ohs, sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL); 320 if (!hwmods) 321 goto oda_exit2; 322 323 od->hwmods = hwmods; 324 od->pdev = pdev; 325 pdev->archdata.od = od; 326 327 for (i = 0; i < oh_cnt; i++) { 328 hwmods[i]->od = od; 329 _add_hwmod_clocks_clkdev(od, hwmods[i]); 330 } 331 332 return od; 333 334 oda_exit2: 335 kfree(od); 336 oda_exit1: 337 dev_err(&pdev->dev, "omap_device: build failed (%d)\n", ret); 338 339 return ERR_PTR(ret); 340 } 341 342 static void omap_device_delete(struct omap_device *od) 343 { 344 if (!od) 345 return; 346 347 od->pdev->archdata.od = NULL; 348 kfree(od->hwmods); 349 kfree(od); 350 } 351 352 #ifdef CONFIG_PM 353 static int _od_runtime_suspend(struct device *dev) 354 { 355 struct platform_device *pdev = to_platform_device(dev); 356 int ret; 357 358 ret = pm_generic_runtime_suspend(dev); 359 if (ret) 360 return ret; 361 362 return omap_device_idle(pdev); 363 } 364 365 static int _od_runtime_resume(struct device *dev) 366 { 367 struct platform_device *pdev = to_platform_device(dev); 368 int ret; 369 370 ret = omap_device_enable(pdev); 371 if (ret) { 372 dev_err(dev, "use pm_runtime_put_sync_suspend() in driver?\n"); 373 return ret; 374 } 375 376 return pm_generic_runtime_resume(dev); 377 } 378 379 static int _od_fail_runtime_suspend(struct device *dev) 380 { 381 dev_warn(dev, "%s: FIXME: missing hwmod/omap_dev info\n", __func__); 382 return -ENODEV; 383 } 384 385 static int _od_fail_runtime_resume(struct device *dev) 386 { 387 dev_warn(dev, "%s: FIXME: missing hwmod/omap_dev info\n", __func__); 388 return -ENODEV; 389 } 390 391 #endif 392 393 #ifdef CONFIG_SUSPEND 394 static int _od_suspend_noirq(struct device *dev) 395 { 396 struct platform_device *pdev = to_platform_device(dev); 397 struct omap_device *od = to_omap_device(pdev); 398 int ret; 399 400 /* Don't attempt late suspend on a driver that is not bound */ 401 if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER) 402 return 0; 403 404 ret = pm_generic_suspend_noirq(dev); 405 406 if (!ret && !pm_runtime_status_suspended(dev)) { 407 if (pm_generic_runtime_suspend(dev) == 0) { 408 omap_device_idle(pdev); 409 od->flags |= OMAP_DEVICE_SUSPENDED; 410 } 411 } 412 413 return ret; 414 } 415 416 static int _od_resume_noirq(struct device *dev) 417 { 418 struct platform_device *pdev = to_platform_device(dev); 419 struct omap_device *od = to_omap_device(pdev); 420 421 if (od->flags & OMAP_DEVICE_SUSPENDED) { 422 od->flags &= ~OMAP_DEVICE_SUSPENDED; 423 omap_device_enable(pdev); 424 pm_generic_runtime_resume(dev); 425 } 426 427 return pm_generic_resume_noirq(dev); 428 } 429 #else 430 #define _od_suspend_noirq NULL 431 #define _od_resume_noirq NULL 432 #endif 433 434 static struct dev_pm_domain omap_device_fail_pm_domain = { 435 .ops = { 436 SET_RUNTIME_PM_OPS(_od_fail_runtime_suspend, 437 _od_fail_runtime_resume, NULL) 438 } 439 }; 440 441 static struct dev_pm_domain omap_device_pm_domain = { 442 .ops = { 443 SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume, 444 NULL) 445 USE_PLATFORM_PM_SLEEP_OPS 446 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(_od_suspend_noirq, 447 _od_resume_noirq) 448 } 449 }; 450 451 /* Public functions for use by device drivers through struct platform_data */ 452 453 /** 454 * omap_device_enable - fully activate an omap_device 455 * @pdev: the platform device to activate 456 * 457 * Do whatever is necessary for the hwmods underlying omap_device @od 458 * to be accessible and ready to operate. This generally involves 459 * enabling clocks, setting SYSCONFIG registers; and in the future may 460 * involve remuxing pins. Device drivers should call this function 461 * indirectly via pm_runtime_get*(). Returns -EINVAL if called when 462 * the omap_device is already enabled, or passes along the return 463 * value of _omap_device_enable_hwmods(). 464 */ 465 int omap_device_enable(struct platform_device *pdev) 466 { 467 int ret; 468 struct omap_device *od; 469 470 od = to_omap_device(pdev); 471 472 if (od->_state == OMAP_DEVICE_STATE_ENABLED) { 473 dev_warn(&pdev->dev, 474 "omap_device: %s() called from invalid state %d\n", 475 __func__, od->_state); 476 return -EINVAL; 477 } 478 479 ret = _omap_device_enable_hwmods(od); 480 481 if (ret == 0) 482 od->_state = OMAP_DEVICE_STATE_ENABLED; 483 484 return ret; 485 } 486 487 /** 488 * omap_device_idle - idle an omap_device 489 * @pdev: The platform_device (omap_device) to idle 490 * 491 * Idle omap_device @od. Device drivers call this function indirectly 492 * via pm_runtime_put*(). Returns -EINVAL if the omap_device is not 493 * currently enabled, or passes along the return value of 494 * _omap_device_idle_hwmods(). 495 */ 496 int omap_device_idle(struct platform_device *pdev) 497 { 498 int ret; 499 struct omap_device *od; 500 501 od = to_omap_device(pdev); 502 503 if (od->_state != OMAP_DEVICE_STATE_ENABLED) { 504 dev_warn(&pdev->dev, 505 "omap_device: %s() called from invalid state %d\n", 506 __func__, od->_state); 507 return -EINVAL; 508 } 509 510 ret = _omap_device_idle_hwmods(od); 511 512 if (ret == 0) 513 od->_state = OMAP_DEVICE_STATE_IDLE; 514 515 return ret; 516 } 517 518 /** 519 * omap_device_assert_hardreset - set a device's hardreset line 520 * @pdev: struct platform_device * to reset 521 * @name: const char * name of the reset line 522 * 523 * Set the hardreset line identified by @name on the IP blocks 524 * associated with the hwmods backing the platform_device @pdev. All 525 * of the hwmods associated with @pdev must have the same hardreset 526 * line linked to them for this to work. Passes along the return value 527 * of omap_hwmod_assert_hardreset() in the event of any failure, or 528 * returns 0 upon success. 529 */ 530 int omap_device_assert_hardreset(struct platform_device *pdev, const char *name) 531 { 532 struct omap_device *od = to_omap_device(pdev); 533 int ret = 0; 534 int i; 535 536 for (i = 0; i < od->hwmods_cnt; i++) { 537 ret = omap_hwmod_assert_hardreset(od->hwmods[i], name); 538 if (ret) 539 break; 540 } 541 542 return ret; 543 } 544 545 /** 546 * omap_device_deassert_hardreset - release a device's hardreset line 547 * @pdev: struct platform_device * to reset 548 * @name: const char * name of the reset line 549 * 550 * Release the hardreset line identified by @name on the IP blocks 551 * associated with the hwmods backing the platform_device @pdev. All 552 * of the hwmods associated with @pdev must have the same hardreset 553 * line linked to them for this to work. Passes along the return 554 * value of omap_hwmod_deassert_hardreset() in the event of any 555 * failure, or returns 0 upon success. 556 */ 557 int omap_device_deassert_hardreset(struct platform_device *pdev, 558 const char *name) 559 { 560 struct omap_device *od = to_omap_device(pdev); 561 int ret = 0; 562 int i; 563 564 for (i = 0; i < od->hwmods_cnt; i++) { 565 ret = omap_hwmod_deassert_hardreset(od->hwmods[i], name); 566 if (ret) 567 break; 568 } 569 570 return ret; 571 } 572 573 static struct notifier_block platform_nb = { 574 .notifier_call = _omap_device_notifier_call, 575 }; 576 577 static int __init omap_device_init(void) 578 { 579 bus_register_notifier(&platform_bus_type, &platform_nb); 580 return 0; 581 } 582 omap_postcore_initcall(omap_device_init); 583 584 /** 585 * omap_device_late_idle - idle devices without drivers 586 * @dev: struct device * associated with omap_device 587 * @data: unused 588 * 589 * Check the driver bound status of this device, and idle it 590 * if there is no driver attached. 591 */ 592 static int __init omap_device_late_idle(struct device *dev, void *data) 593 { 594 struct platform_device *pdev = to_platform_device(dev); 595 struct omap_device *od = to_omap_device(pdev); 596 int i; 597 598 if (!od) 599 return 0; 600 601 /* 602 * If omap_device state is enabled, but has no driver bound, 603 * idle it. 604 */ 605 606 /* 607 * Some devices (like memory controllers) are always kept 608 * enabled, and should not be idled even with no drivers. 609 */ 610 for (i = 0; i < od->hwmods_cnt; i++) 611 if (od->hwmods[i]->flags & HWMOD_INIT_NO_IDLE) 612 return 0; 613 614 if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER && 615 od->_driver_status != BUS_NOTIFY_BIND_DRIVER) { 616 if (od->_state == OMAP_DEVICE_STATE_ENABLED) { 617 dev_warn(dev, "%s: enabled but no driver. Idling\n", 618 __func__); 619 omap_device_idle(pdev); 620 } 621 } 622 623 return 0; 624 } 625 626 static int __init omap_device_late_init(void) 627 { 628 bus_for_each_dev(&platform_bus_type, NULL, NULL, omap_device_late_idle); 629 630 return 0; 631 } 632 omap_late_initcall_sync(omap_device_late_init); 633