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 fallthrough; 248 default: 249 od = to_omap_device(pdev); 250 if (od) 251 od->_driver_status = event; 252 } 253 254 return NOTIFY_DONE; 255 } 256 257 /** 258 * _omap_device_enable_hwmods - call omap_hwmod_enable() on all hwmods 259 * @od: struct omap_device *od 260 * 261 * Enable all underlying hwmods. Returns 0. 262 */ 263 static int _omap_device_enable_hwmods(struct omap_device *od) 264 { 265 int ret = 0; 266 int i; 267 268 for (i = 0; i < od->hwmods_cnt; i++) 269 ret |= omap_hwmod_enable(od->hwmods[i]); 270 271 return ret; 272 } 273 274 /** 275 * _omap_device_idle_hwmods - call omap_hwmod_idle() on all hwmods 276 * @od: struct omap_device *od 277 * 278 * Idle all underlying hwmods. Returns 0. 279 */ 280 static int _omap_device_idle_hwmods(struct omap_device *od) 281 { 282 int ret = 0; 283 int i; 284 285 for (i = 0; i < od->hwmods_cnt; i++) 286 ret |= omap_hwmod_idle(od->hwmods[i]); 287 288 return ret; 289 } 290 291 /* Public functions for use by core code */ 292 293 /** 294 * omap_device_alloc - allocate an omap_device 295 * @pdev: platform_device that will be included in this omap_device 296 * @ohs: ptr to the omap_hwmod for this omap_device 297 * @oh_cnt: the size of the ohs list 298 * 299 * Convenience function for allocating an omap_device structure and filling 300 * hwmods, and resources. 301 * 302 * Returns an struct omap_device pointer or ERR_PTR() on error; 303 */ 304 static struct omap_device *omap_device_alloc(struct platform_device *pdev, 305 struct omap_hwmod **ohs, int oh_cnt) 306 { 307 int ret = -ENOMEM; 308 struct omap_device *od; 309 int i; 310 struct omap_hwmod **hwmods; 311 312 od = kzalloc(sizeof(struct omap_device), GFP_KERNEL); 313 if (!od) 314 goto oda_exit1; 315 316 od->hwmods_cnt = oh_cnt; 317 318 hwmods = kmemdup(ohs, sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL); 319 if (!hwmods) 320 goto oda_exit2; 321 322 od->hwmods = hwmods; 323 od->pdev = pdev; 324 pdev->archdata.od = od; 325 326 for (i = 0; i < oh_cnt; i++) { 327 hwmods[i]->od = od; 328 _add_hwmod_clocks_clkdev(od, hwmods[i]); 329 } 330 331 return od; 332 333 oda_exit2: 334 kfree(od); 335 oda_exit1: 336 dev_err(&pdev->dev, "omap_device: build failed (%d)\n", ret); 337 338 return ERR_PTR(ret); 339 } 340 341 static void omap_device_delete(struct omap_device *od) 342 { 343 if (!od) 344 return; 345 346 od->pdev->archdata.od = NULL; 347 kfree(od->hwmods); 348 kfree(od); 349 } 350 351 #ifdef CONFIG_PM 352 static int _od_runtime_suspend(struct device *dev) 353 { 354 struct platform_device *pdev = to_platform_device(dev); 355 int ret; 356 357 ret = pm_generic_runtime_suspend(dev); 358 if (ret) 359 return ret; 360 361 return omap_device_idle(pdev); 362 } 363 364 static int _od_runtime_resume(struct device *dev) 365 { 366 struct platform_device *pdev = to_platform_device(dev); 367 int ret; 368 369 ret = omap_device_enable(pdev); 370 if (ret) { 371 dev_err(dev, "use pm_runtime_put_sync_suspend() in driver?\n"); 372 return ret; 373 } 374 375 return pm_generic_runtime_resume(dev); 376 } 377 378 static int _od_fail_runtime_suspend(struct device *dev) 379 { 380 dev_warn(dev, "%s: FIXME: missing hwmod/omap_dev info\n", __func__); 381 return -ENODEV; 382 } 383 384 static int _od_fail_runtime_resume(struct device *dev) 385 { 386 dev_warn(dev, "%s: FIXME: missing hwmod/omap_dev info\n", __func__); 387 return -ENODEV; 388 } 389 390 #endif 391 392 #ifdef CONFIG_SUSPEND 393 static int _od_suspend_noirq(struct device *dev) 394 { 395 struct platform_device *pdev = to_platform_device(dev); 396 struct omap_device *od = to_omap_device(pdev); 397 int ret; 398 399 /* Don't attempt late suspend on a driver that is not bound */ 400 if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER) 401 return 0; 402 403 ret = pm_generic_suspend_noirq(dev); 404 405 if (!ret && !pm_runtime_status_suspended(dev)) { 406 if (pm_generic_runtime_suspend(dev) == 0) { 407 omap_device_idle(pdev); 408 od->flags |= OMAP_DEVICE_SUSPENDED; 409 } 410 } 411 412 return ret; 413 } 414 415 static int _od_resume_noirq(struct device *dev) 416 { 417 struct platform_device *pdev = to_platform_device(dev); 418 struct omap_device *od = to_omap_device(pdev); 419 420 if (od->flags & OMAP_DEVICE_SUSPENDED) { 421 od->flags &= ~OMAP_DEVICE_SUSPENDED; 422 omap_device_enable(pdev); 423 pm_generic_runtime_resume(dev); 424 } 425 426 return pm_generic_resume_noirq(dev); 427 } 428 #else 429 #define _od_suspend_noirq NULL 430 #define _od_resume_noirq NULL 431 #endif 432 433 static struct dev_pm_domain omap_device_fail_pm_domain = { 434 .ops = { 435 SET_RUNTIME_PM_OPS(_od_fail_runtime_suspend, 436 _od_fail_runtime_resume, NULL) 437 } 438 }; 439 440 static struct dev_pm_domain omap_device_pm_domain = { 441 .ops = { 442 SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume, 443 NULL) 444 USE_PLATFORM_PM_SLEEP_OPS 445 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(_od_suspend_noirq, 446 _od_resume_noirq) 447 } 448 }; 449 450 /* Public functions for use by device drivers through struct platform_data */ 451 452 /** 453 * omap_device_enable - fully activate an omap_device 454 * @pdev: the platform device to activate 455 * 456 * Do whatever is necessary for the hwmods underlying omap_device @od 457 * to be accessible and ready to operate. This generally involves 458 * enabling clocks, setting SYSCONFIG registers; and in the future may 459 * involve remuxing pins. Device drivers should call this function 460 * indirectly via pm_runtime_get*(). Returns -EINVAL if called when 461 * the omap_device is already enabled, or passes along the return 462 * value of _omap_device_enable_hwmods(). 463 */ 464 int omap_device_enable(struct platform_device *pdev) 465 { 466 int ret; 467 struct omap_device *od; 468 469 od = to_omap_device(pdev); 470 471 if (od->_state == OMAP_DEVICE_STATE_ENABLED) { 472 dev_warn(&pdev->dev, 473 "omap_device: %s() called from invalid state %d\n", 474 __func__, od->_state); 475 return -EINVAL; 476 } 477 478 ret = _omap_device_enable_hwmods(od); 479 480 if (ret == 0) 481 od->_state = OMAP_DEVICE_STATE_ENABLED; 482 483 return ret; 484 } 485 486 /** 487 * omap_device_idle - idle an omap_device 488 * @pdev: The platform_device (omap_device) to idle 489 * 490 * Idle omap_device @od. Device drivers call this function indirectly 491 * via pm_runtime_put*(). Returns -EINVAL if the omap_device is not 492 * currently enabled, or passes along the return value of 493 * _omap_device_idle_hwmods(). 494 */ 495 int omap_device_idle(struct platform_device *pdev) 496 { 497 int ret; 498 struct omap_device *od; 499 500 od = to_omap_device(pdev); 501 502 if (od->_state != OMAP_DEVICE_STATE_ENABLED) { 503 dev_warn(&pdev->dev, 504 "omap_device: %s() called from invalid state %d\n", 505 __func__, od->_state); 506 return -EINVAL; 507 } 508 509 ret = _omap_device_idle_hwmods(od); 510 511 if (ret == 0) 512 od->_state = OMAP_DEVICE_STATE_IDLE; 513 514 return ret; 515 } 516 517 /** 518 * omap_device_assert_hardreset - set a device's hardreset line 519 * @pdev: struct platform_device * to reset 520 * @name: const char * name of the reset line 521 * 522 * Set the hardreset line identified by @name on the IP blocks 523 * associated with the hwmods backing the platform_device @pdev. All 524 * of the hwmods associated with @pdev must have the same hardreset 525 * line linked to them for this to work. Passes along the return value 526 * of omap_hwmod_assert_hardreset() in the event of any failure, or 527 * returns 0 upon success. 528 */ 529 int omap_device_assert_hardreset(struct platform_device *pdev, const char *name) 530 { 531 struct omap_device *od = to_omap_device(pdev); 532 int ret = 0; 533 int i; 534 535 for (i = 0; i < od->hwmods_cnt; i++) { 536 ret = omap_hwmod_assert_hardreset(od->hwmods[i], name); 537 if (ret) 538 break; 539 } 540 541 return ret; 542 } 543 544 /** 545 * omap_device_deassert_hardreset - release a device's hardreset line 546 * @pdev: struct platform_device * to reset 547 * @name: const char * name of the reset line 548 * 549 * Release the hardreset line identified by @name on the IP blocks 550 * associated with the hwmods backing the platform_device @pdev. All 551 * of the hwmods associated with @pdev must have the same hardreset 552 * line linked to them for this to work. Passes along the return 553 * value of omap_hwmod_deassert_hardreset() in the event of any 554 * failure, or returns 0 upon success. 555 */ 556 int omap_device_deassert_hardreset(struct platform_device *pdev, 557 const char *name) 558 { 559 struct omap_device *od = to_omap_device(pdev); 560 int ret = 0; 561 int i; 562 563 for (i = 0; i < od->hwmods_cnt; i++) { 564 ret = omap_hwmod_deassert_hardreset(od->hwmods[i], name); 565 if (ret) 566 break; 567 } 568 569 return ret; 570 } 571 572 static struct notifier_block platform_nb = { 573 .notifier_call = _omap_device_notifier_call, 574 }; 575 576 static int __init omap_device_init(void) 577 { 578 bus_register_notifier(&platform_bus_type, &platform_nb); 579 return 0; 580 } 581 omap_postcore_initcall(omap_device_init); 582 583 /** 584 * omap_device_late_idle - idle devices without drivers 585 * @dev: struct device * associated with omap_device 586 * @data: unused 587 * 588 * Check the driver bound status of this device, and idle it 589 * if there is no driver attached. 590 */ 591 static int __init omap_device_late_idle(struct device *dev, void *data) 592 { 593 struct platform_device *pdev = to_platform_device(dev); 594 struct omap_device *od = to_omap_device(pdev); 595 int i; 596 597 if (!od) 598 return 0; 599 600 /* 601 * If omap_device state is enabled, but has no driver bound, 602 * idle it. 603 */ 604 605 /* 606 * Some devices (like memory controllers) are always kept 607 * enabled, and should not be idled even with no drivers. 608 */ 609 for (i = 0; i < od->hwmods_cnt; i++) 610 if (od->hwmods[i]->flags & HWMOD_INIT_NO_IDLE) 611 return 0; 612 613 if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER && 614 od->_driver_status != BUS_NOTIFY_BIND_DRIVER) { 615 if (od->_state == OMAP_DEVICE_STATE_ENABLED) { 616 dev_warn(dev, "%s: enabled but no driver. Idling\n", 617 __func__); 618 omap_device_idle(pdev); 619 } 620 } 621 622 return 0; 623 } 624 625 static int __init omap_device_late_init(void) 626 { 627 bus_for_each_dev(&platform_bus_type, NULL, NULL, omap_device_late_idle); 628 629 return 0; 630 } 631 omap_late_initcall_sync(omap_device_late_init); 632