arch/arm/mach-omap2/omap_device.c

   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);