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