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 fallthrough; 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 goto oda_exit1; 339 340 od->hwmods_cnt = oh_cnt; 341 342 hwmods = kmemdup(ohs, sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL); 343 if (!hwmods) 344 goto oda_exit2; 345 346 od->hwmods = hwmods; 347 od->pdev = pdev; 348 pdev->archdata.od = od; 349 350 for (i = 0; i < oh_cnt; i++) { 351 hwmods[i]->od = od; 352 _add_hwmod_clocks_clkdev(od, hwmods[i]); 353 } 354 355 return od; 356 357 oda_exit2: 358 kfree(od); 359 oda_exit1: 360 dev_err(&pdev->dev, "omap_device: build failed (%d)\n", ret); 361 362 return ERR_PTR(ret); 363 } 364 365 void omap_device_delete(struct omap_device *od) 366 { 367 if (!od) 368 return; 369 370 od->pdev->archdata.od = NULL; 371 kfree(od->hwmods); 372 kfree(od); 373 } 374 375 #ifdef CONFIG_PM 376 static int _od_runtime_suspend(struct device *dev) 377 { 378 struct platform_device *pdev = to_platform_device(dev); 379 int ret; 380 381 ret = pm_generic_runtime_suspend(dev); 382 if (ret) 383 return ret; 384 385 return omap_device_idle(pdev); 386 } 387 388 static int _od_runtime_resume(struct device *dev) 389 { 390 struct platform_device *pdev = to_platform_device(dev); 391 int ret; 392 393 ret = omap_device_enable(pdev); 394 if (ret) { 395 dev_err(dev, "use pm_runtime_put_sync_suspend() in driver?\n"); 396 return ret; 397 } 398 399 return pm_generic_runtime_resume(dev); 400 } 401 402 static int _od_fail_runtime_suspend(struct device *dev) 403 { 404 dev_warn(dev, "%s: FIXME: missing hwmod/omap_dev info\n", __func__); 405 return -ENODEV; 406 } 407 408 static int _od_fail_runtime_resume(struct device *dev) 409 { 410 dev_warn(dev, "%s: FIXME: missing hwmod/omap_dev info\n", __func__); 411 return -ENODEV; 412 } 413 414 #endif 415 416 #ifdef CONFIG_SUSPEND 417 static int _od_suspend_noirq(struct device *dev) 418 { 419 struct platform_device *pdev = to_platform_device(dev); 420 struct omap_device *od = to_omap_device(pdev); 421 int ret; 422 423 /* Don't attempt late suspend on a driver that is not bound */ 424 if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER) 425 return 0; 426 427 ret = pm_generic_suspend_noirq(dev); 428 429 if (!ret && !pm_runtime_status_suspended(dev)) { 430 if (pm_generic_runtime_suspend(dev) == 0) { 431 omap_device_idle(pdev); 432 od->flags |= OMAP_DEVICE_SUSPENDED; 433 } 434 } 435 436 return ret; 437 } 438 439 static int _od_resume_noirq(struct device *dev) 440 { 441 struct platform_device *pdev = to_platform_device(dev); 442 struct omap_device *od = to_omap_device(pdev); 443 444 if (od->flags & OMAP_DEVICE_SUSPENDED) { 445 od->flags &= ~OMAP_DEVICE_SUSPENDED; 446 omap_device_enable(pdev); 447 pm_generic_runtime_resume(dev); 448 } 449 450 return pm_generic_resume_noirq(dev); 451 } 452 #else 453 #define _od_suspend_noirq NULL 454 #define _od_resume_noirq NULL 455 #endif 456 457 struct dev_pm_domain omap_device_fail_pm_domain = { 458 .ops = { 459 SET_RUNTIME_PM_OPS(_od_fail_runtime_suspend, 460 _od_fail_runtime_resume, NULL) 461 } 462 }; 463 464 struct dev_pm_domain omap_device_pm_domain = { 465 .ops = { 466 SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume, 467 NULL) 468 USE_PLATFORM_PM_SLEEP_OPS 469 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(_od_suspend_noirq, 470 _od_resume_noirq) 471 } 472 }; 473 474 /** 475 * omap_device_register - register an omap_device with one omap_hwmod 476 * @pdev: the platform device (omap_device) to register. 477 * 478 * Register the omap_device structure. This currently just calls 479 * platform_device_register() on the underlying platform_device. 480 * Returns the return value of platform_device_register(). 481 */ 482 int omap_device_register(struct platform_device *pdev) 483 { 484 pr_debug("omap_device: %s: registering\n", pdev->name); 485 486 dev_pm_domain_set(&pdev->dev, &omap_device_pm_domain); 487 return platform_device_add(pdev); 488 } 489 490 491 /* Public functions for use by device drivers through struct platform_data */ 492 493 /** 494 * omap_device_enable - fully activate an omap_device 495 * @pdev: the platform device to activate 496 * 497 * Do whatever is necessary for the hwmods underlying omap_device @od 498 * to be accessible and ready to operate. This generally involves 499 * enabling clocks, setting SYSCONFIG registers; and in the future may 500 * involve remuxing pins. Device drivers should call this function 501 * indirectly via pm_runtime_get*(). Returns -EINVAL if called when 502 * the omap_device is already enabled, or passes along the return 503 * value of _omap_device_enable_hwmods(). 504 */ 505 int omap_device_enable(struct platform_device *pdev) 506 { 507 int ret; 508 struct omap_device *od; 509 510 od = to_omap_device(pdev); 511 512 if (od->_state == OMAP_DEVICE_STATE_ENABLED) { 513 dev_warn(&pdev->dev, 514 "omap_device: %s() called from invalid state %d\n", 515 __func__, od->_state); 516 return -EINVAL; 517 } 518 519 ret = _omap_device_enable_hwmods(od); 520 521 if (ret == 0) 522 od->_state = OMAP_DEVICE_STATE_ENABLED; 523 524 return ret; 525 } 526 527 /** 528 * omap_device_idle - idle an omap_device 529 * @pdev: The platform_device (omap_device) to idle 530 * 531 * Idle omap_device @od. Device drivers call this function indirectly 532 * via pm_runtime_put*(). Returns -EINVAL if the omap_device is not 533 * currently enabled, or passes along the return value of 534 * _omap_device_idle_hwmods(). 535 */ 536 int omap_device_idle(struct platform_device *pdev) 537 { 538 int ret; 539 struct omap_device *od; 540 541 od = to_omap_device(pdev); 542 543 if (od->_state != OMAP_DEVICE_STATE_ENABLED) { 544 dev_warn(&pdev->dev, 545 "omap_device: %s() called from invalid state %d\n", 546 __func__, od->_state); 547 return -EINVAL; 548 } 549 550 ret = _omap_device_idle_hwmods(od); 551 552 if (ret == 0) 553 od->_state = OMAP_DEVICE_STATE_IDLE; 554 555 return ret; 556 } 557 558 /** 559 * omap_device_assert_hardreset - set a device's hardreset line 560 * @pdev: struct platform_device * to reset 561 * @name: const char * name of the reset line 562 * 563 * Set the hardreset line identified by @name on the IP blocks 564 * associated with the hwmods backing the platform_device @pdev. All 565 * of the hwmods associated with @pdev must have the same hardreset 566 * line linked to them for this to work. Passes along the return value 567 * of omap_hwmod_assert_hardreset() in the event of any failure, or 568 * returns 0 upon success. 569 */ 570 int omap_device_assert_hardreset(struct platform_device *pdev, const char *name) 571 { 572 struct omap_device *od = to_omap_device(pdev); 573 int ret = 0; 574 int i; 575 576 for (i = 0; i < od->hwmods_cnt; i++) { 577 ret = omap_hwmod_assert_hardreset(od->hwmods[i], name); 578 if (ret) 579 break; 580 } 581 582 return ret; 583 } 584 585 /** 586 * omap_device_deassert_hardreset - release a device's hardreset line 587 * @pdev: struct platform_device * to reset 588 * @name: const char * name of the reset line 589 * 590 * Release the hardreset line identified by @name on the IP blocks 591 * associated with the hwmods backing the platform_device @pdev. All 592 * of the hwmods associated with @pdev must have the same hardreset 593 * line linked to them for this to work. Passes along the return 594 * value of omap_hwmod_deassert_hardreset() in the event of any 595 * failure, or returns 0 upon success. 596 */ 597 int omap_device_deassert_hardreset(struct platform_device *pdev, 598 const char *name) 599 { 600 struct omap_device *od = to_omap_device(pdev); 601 int ret = 0; 602 int i; 603 604 for (i = 0; i < od->hwmods_cnt; i++) { 605 ret = omap_hwmod_deassert_hardreset(od->hwmods[i], name); 606 if (ret) 607 break; 608 } 609 610 return ret; 611 } 612 613 /** 614 * omap_device_get_by_hwmod_name() - convert a hwmod name to 615 * device pointer. 616 * @oh_name: name of the hwmod device 617 * 618 * Returns back a struct device * pointer associated with a hwmod 619 * device represented by a hwmod_name 620 */ 621 struct device *omap_device_get_by_hwmod_name(const char *oh_name) 622 { 623 struct omap_hwmod *oh; 624 625 if (!oh_name) { 626 WARN(1, "%s: no hwmod name!\n", __func__); 627 return ERR_PTR(-EINVAL); 628 } 629 630 oh = omap_hwmod_lookup(oh_name); 631 if (!oh) { 632 WARN(1, "%s: no hwmod for %s\n", __func__, 633 oh_name); 634 return ERR_PTR(-ENODEV); 635 } 636 if (!oh->od) { 637 WARN(1, "%s: no omap_device for %s\n", __func__, 638 oh_name); 639 return ERR_PTR(-ENODEV); 640 } 641 642 return &oh->od->pdev->dev; 643 } 644 645 static struct notifier_block platform_nb = { 646 .notifier_call = _omap_device_notifier_call, 647 }; 648 649 static int __init omap_device_init(void) 650 { 651 bus_register_notifier(&platform_bus_type, &platform_nb); 652 return 0; 653 } 654 omap_postcore_initcall(omap_device_init); 655 656 /** 657 * omap_device_late_idle - idle devices without drivers 658 * @dev: struct device * associated with omap_device 659 * @data: unused 660 * 661 * Check the driver bound status of this device, and idle it 662 * if there is no driver attached. 663 */ 664 static int __init omap_device_late_idle(struct device *dev, void *data) 665 { 666 struct platform_device *pdev = to_platform_device(dev); 667 struct omap_device *od = to_omap_device(pdev); 668 int i; 669 670 if (!od) 671 return 0; 672 673 /* 674 * If omap_device state is enabled, but has no driver bound, 675 * idle it. 676 */ 677 678 /* 679 * Some devices (like memory controllers) are always kept 680 * enabled, and should not be idled even with no drivers. 681 */ 682 for (i = 0; i < od->hwmods_cnt; i++) 683 if (od->hwmods[i]->flags & HWMOD_INIT_NO_IDLE) 684 return 0; 685 686 if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER && 687 od->_driver_status != BUS_NOTIFY_BIND_DRIVER) { 688 if (od->_state == OMAP_DEVICE_STATE_ENABLED) { 689 dev_warn(dev, "%s: enabled but no driver. Idling\n", 690 __func__); 691 omap_device_idle(pdev); 692 } 693 } 694 695 return 0; 696 } 697 698 static int __init omap_device_late_init(void) 699 { 700 bus_for_each_dev(&platform_bus_type, NULL, NULL, omap_device_late_idle); 701 702 return 0; 703 } 704 omap_late_initcall_sync(omap_device_late_init); 705