arch/arm/plat-omap/omap_device.c

   1
   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 program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License version 2 as
  15  * published by the Free Software Foundation.
  16  *
  17  * This code provides a consistent interface for OMAP device drivers
  18  * to control power management and interconnect properties of their
  19  * devices.
  20  *
  21  * In the medium- to long-term, this code should either be
  22  * a) implemented via arch-specific pointers in platform_data
  23  * or
  24  * b) implemented as a proper omap_bus/omap_device in Linux, no more
  25  *    platform_data func pointers
  26  *
  27  *
  28  * Guidelines for usage by driver authors:
  29  *
  30  * 1. These functions are intended to be used by device drivers via
  31  * function pointers in struct platform_data.  As an example,
  32  * omap_device_enable() should be passed to the driver as
  33  *
  34  * struct foo_driver_platform_data {
  35  * ...
  36  *      int (*device_enable)(struct platform_device *pdev);
  37  * ...
  38  * }
  39  *
  40  * Note that the generic "device_enable" name is used, rather than
  41  * "omap_device_enable".  This is so other architectures can pass in their
  42  * own enable/disable functions here.
  43  *
  44  * This should be populated during device setup:
  45  *
  46  * ...
  47  * pdata->device_enable = omap_device_enable;
  48  * ...
  49  *
  50  * 2. Drivers should first check to ensure the function pointer is not null
  51  * before calling it, as in:
  52  *
  53  * if (pdata->device_enable)
  54  *     pdata->device_enable(pdev);
  55  *
  56  * This allows other architectures that don't use similar device_enable()/
  57  * device_shutdown() functions to execute normally.
  58  *
  59  * ...
  60  *
  61  * Suggested usage by device drivers:
  62  *
  63  * During device initialization:
  64  * device_enable()
  65  *
  66  * During device idle:
  67  * (save remaining device context if necessary)
  68  * device_idle();
  69  *
  70  * During device resume:
  71  * device_enable();
  72  * (restore context if necessary)
  73  *
  74  * During device shutdown:
  75  * device_shutdown()
  76  * (device must be reinitialized at this point to use it again)
  77  *
  78  */
  79 #undef DEBUG
  80
  81 #include <linux/kernel.h>
  82 #include <linux/export.h>
  83 #include <linux/platform_device.h>
  84 #include <linux/slab.h>
  85 #include <linux/err.h>
  86 #include <linux/io.h>
  87 #include <linux/clk.h>
  88 #include <linux/clkdev.h>
  89 #include <linux/pm_runtime.h>
  90 #include <linux/of.h>
  91 #include <linux/notifier.h>
  92
  93 #include <plat/omap_device.h>
  94 #include <plat/omap_hwmod.h>
  95 #include <plat/clock.h>
  96
  97 /* These parameters are passed to _omap_device_{de,}activate() */
  98 #define USE_WAKEUP_LAT                  0
  99 #define IGNORE_WAKEUP_LAT               1
 100
 101 static int omap_early_device_register(struct platform_device *pdev);
 102
 103 static struct omap_device_pm_latency omap_default_latency[] = {
 104         {
 105                 .deactivate_func = omap_device_idle_hwmods,
 106                 .activate_func   = omap_device_enable_hwmods,
 107                 .flags = OMAP_DEVICE_LATENCY_AUTO_ADJUST,
 108         }
 109 };
 110
 111 /* Private functions */
 112
 113 /**
 114  * _omap_device_activate - increase device readiness
 115  * @od: struct omap_device *
 116  * @ignore_lat: increase to latency target (0) or full readiness (1)?
 117  *
 118  * Increase readiness of omap_device @od (thus decreasing device
 119  * wakeup latency, but consuming more power).  If @ignore_lat is
 120  * IGNORE_WAKEUP_LAT, make the omap_device fully active.  Otherwise,
 121  * if @ignore_lat is USE_WAKEUP_LAT, and the device's maximum wakeup
 122  * latency is greater than the requested maximum wakeup latency, step
 123  * backwards in the omap_device_pm_latency table to ensure the
 124  * device's maximum wakeup latency is less than or equal to the
 125  * requested maximum wakeup latency.  Returns 0.
 126  */
 127 static int _omap_device_activate(struct omap_device *od, u8 ignore_lat)
 128 {
 129         struct timespec a, b, c;
 130
 131         dev_dbg(&od->pdev->dev, "omap_device: activating\n");
 132
 133         while (od->pm_lat_level > 0) {
 134                 struct omap_device_pm_latency *odpl;
 135                 unsigned long long act_lat = 0;
 136
 137                 od->pm_lat_level--;
 138
 139                 odpl = od->pm_lats + od->pm_lat_level;
 140
 141                 if (!ignore_lat &&
 142                     (od->dev_wakeup_lat <= od->_dev_wakeup_lat_limit))
 143                         break;
 144
 145                 read_persistent_clock(&a);
 146
 147                 /* XXX check return code */
 148                 odpl->activate_func(od);
 149
 150                 read_persistent_clock(&b);
 151
 152                 c = timespec_sub(b, a);
 153                 act_lat = timespec_to_ns(&c);
 154
 155                 dev_dbg(&od->pdev->dev,
 156                         "omap_device: pm_lat %d: activate: elapsed time "
 157                         "%llu nsec\n", od->pm_lat_level, act_lat);
 158
 159                 if (act_lat > odpl->activate_lat) {
 160                         odpl->activate_lat_worst = act_lat;
 161                         if (odpl->flags & OMAP_DEVICE_LATENCY_AUTO_ADJUST) {
 162                                 odpl->activate_lat = act_lat;
 163                                 dev_dbg(&od->pdev->dev,
 164                                         "new worst case activate latency "
 165                                         "%d: %llu\n",
 166                                         od->pm_lat_level, act_lat);
 167                         } else
 168                                 dev_warn(&od->pdev->dev,
 169                                          "activate latency %d "
 170                                          "higher than exptected. (%llu > %d)\n",
 171                                          od->pm_lat_level, act_lat,
 172                                          odpl->activate_lat);
 173                 }
 174
 175                 od->dev_wakeup_lat -= odpl->activate_lat;
 176         }
 177
 178         return 0;
 179 }
 180
 181 /**
 182  * _omap_device_deactivate - decrease device readiness
 183  * @od: struct omap_device *
 184  * @ignore_lat: decrease to latency target (0) or full inactivity (1)?
 185  *
 186  * Decrease readiness of omap_device @od (thus increasing device
 187  * wakeup latency, but conserving power).  If @ignore_lat is
 188  * IGNORE_WAKEUP_LAT, make the omap_device fully inactive.  Otherwise,
 189  * if @ignore_lat is USE_WAKEUP_LAT, and the device's maximum wakeup
 190  * latency is less than the requested maximum wakeup latency, step
 191  * forwards in the omap_device_pm_latency table to ensure the device's
 192  * maximum wakeup latency is less than or equal to the requested
 193  * maximum wakeup latency.  Returns 0.
 194  */
 195 static int _omap_device_deactivate(struct omap_device *od, u8 ignore_lat)
 196 {
 197         struct timespec a, b, c;
 198
 199         dev_dbg(&od->pdev->dev, "omap_device: deactivating\n");
 200
 201         while (od->pm_lat_level < od->pm_lats_cnt) {
 202                 struct omap_device_pm_latency *odpl;
 203                 unsigned long long deact_lat = 0;
 204
 205                 odpl = od->pm_lats + od->pm_lat_level;
 206
 207                 if (!ignore_lat &&
 208                     ((od->dev_wakeup_lat + odpl->activate_lat) >
 209                      od->_dev_wakeup_lat_limit))
 210                         break;
 211
 212                 read_persistent_clock(&a);
 213
 214                 /* XXX check return code */
 215                 odpl->deactivate_func(od);
 216
 217                 read_persistent_clock(&b);
 218
 219                 c = timespec_sub(b, a);
 220                 deact_lat = timespec_to_ns(&c);
 221
 222                 dev_dbg(&od->pdev->dev,
 223                         "omap_device: pm_lat %d: deactivate: elapsed time "
 224                         "%llu nsec\n", od->pm_lat_level, deact_lat);
 225
 226                 if (deact_lat > odpl->deactivate_lat) {
 227                         odpl->deactivate_lat_worst = deact_lat;
 228                         if (odpl->flags & OMAP_DEVICE_LATENCY_AUTO_ADJUST) {
 229                                 odpl->deactivate_lat = deact_lat;
 230                                 dev_dbg(&od->pdev->dev,
 231                                         "new worst case deactivate latency "
 232                                         "%d: %llu\n",
 233                                         od->pm_lat_level, deact_lat);
 234                         } else
 235                                 dev_warn(&od->pdev->dev,
 236                                          "deactivate latency %d "
 237                                          "higher than exptected. (%llu > %d)\n",
 238                                          od->pm_lat_level, deact_lat,
 239                                          odpl->deactivate_lat);
 240                 }
 241
 242                 od->dev_wakeup_lat += odpl->activate_lat;
 243
 244                 od->pm_lat_level++;
 245         }
 246
 247         return 0;
 248 }
 249
 250 static void _add_clkdev(struct omap_device *od, const char *clk_alias,
 251                        const char *clk_name)
 252 {
 253         struct clk *r;
 254         struct clk_lookup *l;
 255
 256         if (!clk_alias || !clk_name)
 257                 return;
 258
 259         dev_dbg(&od->pdev->dev, "Creating %s -> %s\n", clk_alias, clk_name);
 260
 261         r = clk_get_sys(dev_name(&od->pdev->dev), clk_alias);
 262         if (!IS_ERR(r)) {
 263                 dev_warn(&od->pdev->dev,
 264                          "alias %s already exists\n", clk_alias);
 265                 clk_put(r);
 266                 return;
 267         }
 268
 269         r = omap_clk_get_by_name(clk_name);
 270         if (IS_ERR(r)) {
 271                 dev_err(&od->pdev->dev,
 272                         "omap_clk_get_by_name for %s failed\n", clk_name);
 273                 return;
 274         }
 275
 276         l = clkdev_alloc(r, clk_alias, dev_name(&od->pdev->dev));
 277         if (!l) {
 278                 dev_err(&od->pdev->dev,
 279                         "clkdev_alloc for %s failed\n", clk_alias);
 280                 return;
 281         }
 282
 283         clkdev_add(l);
 284 }
 285
 286 /**
 287  * _add_hwmod_clocks_clkdev - Add clkdev entry for hwmod optional clocks
 288  * and main clock
 289  * @od: struct omap_device *od
 290  * @oh: struct omap_hwmod *oh
 291  *
 292  * For the main clock and every optional clock present per hwmod per
 293  * omap_device, this function adds an entry in the clkdev table of the
 294  * form <dev-id=dev_name, con-id=role> if it does not exist already.
 295  *
 296  * The function is called from inside omap_device_build_ss(), after
 297  * omap_device_register.
 298  *
 299  * This allows drivers to get a pointer to its optional clocks based on its role
 300  * by calling clk_get(<dev*>, <role>).
 301  * In the case of the main clock, a "fck" alias is used.
 302  *
 303  * No return value.
 304  */
 305 static void _add_hwmod_clocks_clkdev(struct omap_device *od,
 306                                      struct omap_hwmod *oh)
 307 {
 308         int i;
 309
 310         _add_clkdev(od, "fck", oh->main_clk);
 311
 312         for (i = 0; i < oh->opt_clks_cnt; i++)
 313                 _add_clkdev(od, oh->opt_clks[i].role, oh->opt_clks[i].clk);
 314 }
 315
 316
 317 /**
 318  * omap_device_build_from_dt - build an omap_device with multiple hwmods
 319  * @pdev_name: name of the platform_device driver to use
 320  * @pdev_id: this platform_device's connection ID
 321  * @oh: ptr to the single omap_hwmod that backs this omap_device
 322  * @pdata: platform_data ptr to associate with the platform_device
 323  * @pdata_len: amount of memory pointed to by @pdata
 324  * @pm_lats: pointer to a omap_device_pm_latency array for this device
 325  * @pm_lats_cnt: ARRAY_SIZE() of @pm_lats
 326  * @is_early_device: should the device be registered as an early device or not
 327  *
 328  * Function for building an omap_device already registered from device-tree
 329  *
 330  * Returns 0 or PTR_ERR() on error.
 331  */
 332 static int omap_device_build_from_dt(struct platform_device *pdev)
 333 {
 334         struct omap_hwmod **hwmods;
 335         struct omap_device *od;
 336         struct omap_hwmod *oh;
 337         struct device_node *node = pdev->dev.of_node;
 338         const char *oh_name;
 339         int oh_cnt, i, ret = 0;
 340
 341         oh_cnt = of_property_count_strings(node, "ti,hwmods");
 342         if (!oh_cnt || IS_ERR_VALUE(oh_cnt)) {
 343                 dev_dbg(&pdev->dev, "No 'hwmods' to build omap_device\n");
 344                 return -ENODEV;
 345         }
 346
 347         hwmods = kzalloc(sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL);
 348         if (!hwmods) {
 349                 ret = -ENOMEM;
 350                 goto odbfd_exit;
 351         }
 352
 353         for (i = 0; i < oh_cnt; i++) {
 354                 of_property_read_string_index(node, "ti,hwmods", i, &oh_name);
 355                 oh = omap_hwmod_lookup(oh_name);
 356                 if (!oh) {
 357                         dev_err(&pdev->dev, "Cannot lookup hwmod '%s'\n",
 358                                 oh_name);
 359                         ret = -EINVAL;
 360                         goto odbfd_exit1;
 361                 }
 362                 hwmods[i] = oh;
 363         }
 364
 365         od = omap_device_alloc(pdev, hwmods, oh_cnt, NULL, 0);
 366         if (!od) {
 367                 dev_err(&pdev->dev, "Cannot allocate omap_device for :%s\n",
 368                         oh_name);
 369                 ret = PTR_ERR(od);
 370                 goto odbfd_exit1;
 371         }
 372
 373         if (of_get_property(node, "ti,no_idle_on_suspend", NULL))
 374                 omap_device_disable_idle_on_suspend(pdev);
 375
 376         pdev->dev.pm_domain = &omap_device_pm_domain;
 377
 378 odbfd_exit1:
 379         kfree(hwmods);
 380 odbfd_exit:
 381         return ret;
 382 }
 383
 384 static int _omap_device_notifier_call(struct notifier_block *nb,
 385                                       unsigned long event, void *dev)
 386 {
 387         struct platform_device *pdev = to_platform_device(dev);
 388
 389         switch (event) {
 390         case BUS_NOTIFY_ADD_DEVICE:
 391                 if (pdev->dev.of_node)
 392                         omap_device_build_from_dt(pdev);
 393                 break;
 394
 395         case BUS_NOTIFY_DEL_DEVICE:
 396                 if (pdev->archdata.od)
 397                         omap_device_delete(pdev->archdata.od);
 398                 break;
 399         }
 400
 401         return NOTIFY_DONE;
 402 }
 403
 404
 405 /* Public functions for use by core code */
 406
 407 /**
 408  * omap_device_get_context_loss_count - get lost context count
 409  * @od: struct omap_device *
 410  *
 411  * Using the primary hwmod, query the context loss count for this
 412  * device.
 413  *
 414  * Callers should consider context for this device lost any time this
 415  * function returns a value different than the value the caller got
 416  * the last time it called this function.
 417  *
 418  * If any hwmods exist for the omap_device assoiated with @pdev,
 419  * return the context loss counter for that hwmod, otherwise return
 420  * zero.
 421  */
 422 int omap_device_get_context_loss_count(struct platform_device *pdev)
 423 {
 424         struct omap_device *od;
 425         u32 ret = 0;
 426
 427         od = to_omap_device(pdev);
 428
 429         if (od->hwmods_cnt)
 430                 ret = omap_hwmod_get_context_loss_count(od->hwmods[0]);
 431
 432         return ret;
 433 }
 434
 435 /**
 436  * omap_device_count_resources - count number of struct resource entries needed
 437  * @od: struct omap_device *
 438  *
 439  * Count the number of struct resource entries needed for this
 440  * omap_device @od.  Used by omap_device_build_ss() to determine how
 441  * much memory to allocate before calling
 442  * omap_device_fill_resources().  Returns the count.
 443  */
 444 static int omap_device_count_resources(struct omap_device *od)
 445 {
 446         int c = 0;
 447         int i;
 448
 449         for (i = 0; i < od->hwmods_cnt; i++)
 450                 c += omap_hwmod_count_resources(od->hwmods[i]);
 451
 452         pr_debug("omap_device: %s: counted %d total resources across %d "
 453                  "hwmods\n", od->pdev->name, c, od->hwmods_cnt);
 454
 455         return c;
 456 }
 457
 458 /**
 459  * omap_device_fill_resources - fill in array of struct resource
 460  * @od: struct omap_device *
 461  * @res: pointer to an array of struct resource to be filled in
 462  *
 463  * Populate one or more empty struct resource pointed to by @res with
 464  * the resource data for this omap_device @od.  Used by
 465  * omap_device_build_ss() after calling omap_device_count_resources().
 466  * Ideally this function would not be needed at all.  If omap_device
 467  * replaces platform_device, then we can specify our own
 468  * get_resource()/ get_irq()/etc functions that use the underlying
 469  * omap_hwmod information.  Or if platform_device is extended to use
 470  * subarchitecture-specific function pointers, the various
 471  * platform_device functions can simply call omap_device internal
 472  * functions to get device resources.  Hacking around the existing
 473  * platform_device code wastes memory.  Returns 0.
 474  */
 475 static int omap_device_fill_resources(struct omap_device *od,
 476                                       struct resource *res)
 477 {
 478         int c = 0;
 479         int i, r;
 480
 481         for (i = 0; i < od->hwmods_cnt; i++) {
 482                 r = omap_hwmod_fill_resources(od->hwmods[i], res);
 483                 res += r;
 484                 c += r;
 485         }
 486
 487         return 0;
 488 }
 489
 490 /**
 491  * omap_device_alloc - allocate an omap_device
 492  * @pdev: platform_device that will be included in this omap_device
 493  * @oh: ptr to the single omap_hwmod that backs this omap_device
 494  * @pdata: platform_data ptr to associate with the platform_device
 495  * @pdata_len: amount of memory pointed to by @pdata
 496  * @pm_lats: pointer to a omap_device_pm_latency array for this device
 497  * @pm_lats_cnt: ARRAY_SIZE() of @pm_lats
 498  *
 499  * Convenience function for allocating an omap_device structure and filling
 500  * hwmods, resources and pm_latency attributes.
 501  *
 502  * Returns an struct omap_device pointer or ERR_PTR() on error;
 503  */
 504 struct omap_device *omap_device_alloc(struct platform_device *pdev,
 505                                         struct omap_hwmod **ohs, int oh_cnt,
 506                                         struct omap_device_pm_latency *pm_lats,
 507                                         int pm_lats_cnt)
 508 {
 509         int ret = -ENOMEM;
 510         struct omap_device *od;
 511         struct resource *res = NULL;
 512         int i, res_count;
 513         struct omap_hwmod **hwmods;
 514
 515         od = kzalloc(sizeof(struct omap_device), GFP_KERNEL);
 516         if (!od) {
 517                 ret = -ENOMEM;
 518                 goto oda_exit1;
 519         }
 520         od->hwmods_cnt = oh_cnt;
 521
 522         hwmods = kmemdup(ohs, sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL);
 523         if (!hwmods)
 524                 goto oda_exit2;
 525
 526         od->hwmods = hwmods;
 527         od->pdev = pdev;
 528
 529         /*
 530          * HACK: Ideally the resources from DT should match, and hwmod
 531          * should just add the missing ones. Since the name is not
 532          * properly populated by DT, stick to hwmod resources only.
 533          */
 534         if (pdev->num_resources && pdev->resource)
 535                 dev_warn(&pdev->dev, "%s(): resources already allocated %d\n",
 536                         __func__, pdev->num_resources);
 537
 538         res_count = omap_device_count_resources(od);
 539         if (res_count > 0) {
 540                 dev_dbg(&pdev->dev, "%s(): resources allocated from hwmod %d\n",
 541                         __func__, res_count);
 542                 res = kzalloc(sizeof(struct resource) * res_count, GFP_KERNEL);
 543                 if (!res)
 544                         goto oda_exit3;
 545
 546                 omap_device_fill_resources(od, res);
 547
 548                 ret = platform_device_add_resources(pdev, res, res_count);
 549                 kfree(res);
 550
 551                 if (ret)
 552                         goto oda_exit3;
 553         }
 554
 555         if (!pm_lats) {
 556                 pm_lats = omap_default_latency;
 557                 pm_lats_cnt = ARRAY_SIZE(omap_default_latency);
 558         }
 559
 560         od->pm_lats_cnt = pm_lats_cnt;
 561         od->pm_lats = kmemdup(pm_lats,
 562                         sizeof(struct omap_device_pm_latency) * pm_lats_cnt,
 563                         GFP_KERNEL);
 564         if (!od->pm_lats)
 565                 goto oda_exit3;
 566
 567         pdev->archdata.od = od;
 568
 569         for (i = 0; i < oh_cnt; i++) {
 570                 hwmods[i]->od = od;
 571                 _add_hwmod_clocks_clkdev(od, hwmods[i]);
 572         }
 573
 574         return od;
 575
 576 oda_exit3:
 577         kfree(hwmods);
 578 oda_exit2:
 579         kfree(od);
 580 oda_exit1:
 581         dev_err(&pdev->dev, "omap_device: build failed (%d)\n", ret);
 582
 583         return ERR_PTR(ret);
 584 }
 585
 586 void omap_device_delete(struct omap_device *od)
 587 {
 588         if (!od)
 589                 return;
 590
 591         od->pdev->archdata.od = NULL;
 592         kfree(od->pm_lats);
 593         kfree(od->hwmods);
 594         kfree(od);
 595 }
 596
 597 /**
 598  * omap_device_build - build and register an omap_device with one omap_hwmod
 599  * @pdev_name: name of the platform_device driver to use
 600  * @pdev_id: this platform_device's connection ID
 601  * @oh: ptr to the single omap_hwmod that backs this omap_device
 602  * @pdata: platform_data ptr to associate with the platform_device
 603  * @pdata_len: amount of memory pointed to by @pdata
 604  * @pm_lats: pointer to a omap_device_pm_latency array for this device
 605  * @pm_lats_cnt: ARRAY_SIZE() of @pm_lats
 606  * @is_early_device: should the device be registered as an early device or not
 607  *
 608  * Convenience function for building and registering a single
 609  * omap_device record, which in turn builds and registers a
 610  * platform_device record.  See omap_device_build_ss() for more
 611  * information.  Returns ERR_PTR(-EINVAL) if @oh is NULL; otherwise,
 612  * passes along the return value of omap_device_build_ss().
 613  */
 614 struct platform_device __init *omap_device_build(const char *pdev_name, int pdev_id,
 615                                       struct omap_hwmod *oh, void *pdata,
 616                                       int pdata_len,
 617                                       struct omap_device_pm_latency *pm_lats,
 618                                       int pm_lats_cnt, int is_early_device)
 619 {
 620         struct omap_hwmod *ohs[] = { oh };
 621
 622         if (!oh)
 623                 return ERR_PTR(-EINVAL);
 624
 625         return omap_device_build_ss(pdev_name, pdev_id, ohs, 1, pdata,
 626                                     pdata_len, pm_lats, pm_lats_cnt,
 627                                     is_early_device);
 628 }
 629
 630 /**
 631  * omap_device_build_ss - build and register an omap_device with multiple hwmods
 632  * @pdev_name: name of the platform_device driver to use
 633  * @pdev_id: this platform_device's connection ID
 634  * @oh: ptr to the single omap_hwmod that backs this omap_device
 635  * @pdata: platform_data ptr to associate with the platform_device
 636  * @pdata_len: amount of memory pointed to by @pdata
 637  * @pm_lats: pointer to a omap_device_pm_latency array for this device
 638  * @pm_lats_cnt: ARRAY_SIZE() of @pm_lats
 639  * @is_early_device: should the device be registered as an early device or not
 640  *
 641  * Convenience function for building and registering an omap_device
 642  * subsystem record.  Subsystem records consist of multiple
 643  * omap_hwmods.  This function in turn builds and registers a
 644  * platform_device record.  Returns an ERR_PTR() on error, or passes
 645  * along the return value of omap_device_register().
 646  */
 647 struct platform_device __init *omap_device_build_ss(const char *pdev_name, int pdev_id,
 648                                          struct omap_hwmod **ohs, int oh_cnt,
 649                                          void *pdata, int pdata_len,
 650                                          struct omap_device_pm_latency *pm_lats,
 651                                          int pm_lats_cnt, int is_early_device)
 652 {
 653         int ret = -ENOMEM;
 654         struct platform_device *pdev;
 655         struct omap_device *od;
 656
 657         if (!ohs || oh_cnt == 0 || !pdev_name)
 658                 return ERR_PTR(-EINVAL);
 659
 660         if (!pdata && pdata_len > 0)
 661                 return ERR_PTR(-EINVAL);
 662
 663         pdev = platform_device_alloc(pdev_name, pdev_id);
 664         if (!pdev) {
 665                 ret = -ENOMEM;
 666                 goto odbs_exit;
 667         }
 668
 669         /* Set the dev_name early to allow dev_xxx in omap_device_alloc */
 670         if (pdev->id != -1)
 671                 dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);
 672         else
 673                 dev_set_name(&pdev->dev, "%s", pdev->name);
 674
 675         od = omap_device_alloc(pdev, ohs, oh_cnt, pm_lats, pm_lats_cnt);
 676         if (!od)
 677                 goto odbs_exit1;
 678
 679         ret = platform_device_add_data(pdev, pdata, pdata_len);
 680         if (ret)
 681                 goto odbs_exit2;
 682
 683         if (is_early_device)
 684                 ret = omap_early_device_register(pdev);
 685         else
 686                 ret = omap_device_register(pdev);
 687         if (ret)
 688                 goto odbs_exit2;
 689
 690         return pdev;
 691
 692 odbs_exit2:
 693         omap_device_delete(od);
 694 odbs_exit1:
 695         platform_device_put(pdev);
 696 odbs_exit:
 697
 698         pr_err("omap_device: %s: build failed (%d)\n", pdev_name, ret);
 699
 700         return ERR_PTR(ret);
 701 }
 702
 703 /**
 704  * omap_early_device_register - register an omap_device as an early platform
 705  * device.
 706  * @od: struct omap_device * to register
 707  *
 708  * Register the omap_device structure.  This currently just calls
 709  * platform_early_add_device() on the underlying platform_device.
 710  * Returns 0 by default.
 711  */
 712 static int __init omap_early_device_register(struct platform_device *pdev)
 713 {
 714         struct platform_device *devices[1];
 715
 716         devices[0] = pdev;
 717         early_platform_add_devices(devices, 1);
 718         return 0;
 719 }
 720
 721 #ifdef CONFIG_PM_RUNTIME
 722 static int _od_runtime_suspend(struct device *dev)
 723 {
 724         struct platform_device *pdev = to_platform_device(dev);
 725         int ret;
 726
 727         ret = pm_generic_runtime_suspend(dev);
 728
 729         if (!ret)
 730                 omap_device_idle(pdev);
 731
 732         return ret;
 733 }
 734
 735 static int _od_runtime_idle(struct device *dev)
 736 {
 737         return pm_generic_runtime_idle(dev);
 738 }
 739
 740 static int _od_runtime_resume(struct device *dev)
 741 {
 742         struct platform_device *pdev = to_platform_device(dev);
 743
 744         omap_device_enable(pdev);
 745
 746         return pm_generic_runtime_resume(dev);
 747 }
 748 #endif
 749
 750 #ifdef CONFIG_SUSPEND
 751 static int _od_suspend_noirq(struct device *dev)
 752 {
 753         struct platform_device *pdev = to_platform_device(dev);
 754         struct omap_device *od = to_omap_device(pdev);
 755         int ret;
 756
 757         ret = pm_generic_suspend_noirq(dev);
 758
 759         if (!ret && !pm_runtime_status_suspended(dev)) {
 760                 if (pm_generic_runtime_suspend(dev) == 0) {
 761                         if (!(od->flags & OMAP_DEVICE_NO_IDLE_ON_SUSPEND))
 762                                 omap_device_idle(pdev);
 763                         od->flags |= OMAP_DEVICE_SUSPENDED;
 764                 }
 765         }
 766
 767         return ret;
 768 }
 769
 770 static int _od_resume_noirq(struct device *dev)
 771 {
 772         struct platform_device *pdev = to_platform_device(dev);
 773         struct omap_device *od = to_omap_device(pdev);
 774
 775         if ((od->flags & OMAP_DEVICE_SUSPENDED) &&
 776             !pm_runtime_status_suspended(dev)) {
 777                 od->flags &= ~OMAP_DEVICE_SUSPENDED;
 778                 if (!(od->flags & OMAP_DEVICE_NO_IDLE_ON_SUSPEND))
 779                         omap_device_enable(pdev);
 780                 pm_generic_runtime_resume(dev);
 781         }
 782
 783         return pm_generic_resume_noirq(dev);
 784 }
 785 #else
 786 #define _od_suspend_noirq NULL
 787 #define _od_resume_noirq NULL
 788 #endif
 789
 790 struct dev_pm_domain omap_device_pm_domain = {
 791         .ops = {
 792                 SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume,
 793                                    _od_runtime_idle)
 794                 USE_PLATFORM_PM_SLEEP_OPS
 795                 .suspend_noirq = _od_suspend_noirq,
 796                 .resume_noirq = _od_resume_noirq,
 797         }
 798 };
 799
 800 /**
 801  * omap_device_register - register an omap_device with one omap_hwmod
 802  * @od: struct omap_device * to register
 803  *
 804  * Register the omap_device structure.  This currently just calls
 805  * platform_device_register() on the underlying platform_device.
 806  * Returns the return value of platform_device_register().
 807  */
 808 int omap_device_register(struct platform_device *pdev)
 809 {
 810         pr_debug("omap_device: %s: registering\n", pdev->name);
 811
 812         pdev->dev.pm_domain = &omap_device_pm_domain;
 813         return platform_device_add(pdev);
 814 }
 815
 816
 817 /* Public functions for use by device drivers through struct platform_data */
 818
 819 /**
 820  * omap_device_enable - fully activate an omap_device
 821  * @od: struct omap_device * to activate
 822  *
 823  * Do whatever is necessary for the hwmods underlying omap_device @od
 824  * to be accessible and ready to operate.  This generally involves
 825  * enabling clocks, setting SYSCONFIG registers; and in the future may
 826  * involve remuxing pins.  Device drivers should call this function
 827  * (through platform_data function pointers) where they would normally
 828  * enable clocks, etc.  Returns -EINVAL if called when the omap_device
 829  * is already enabled, or passes along the return value of
 830  * _omap_device_activate().
 831  */
 832 int omap_device_enable(struct platform_device *pdev)
 833 {
 834         int ret;
 835         struct omap_device *od;
 836
 837         od = to_omap_device(pdev);
 838
 839         if (od->_state == OMAP_DEVICE_STATE_ENABLED) {
 840                 dev_warn(&pdev->dev,
 841                          "omap_device: %s() called from invalid state %d\n",
 842                          __func__, od->_state);
 843                 return -EINVAL;
 844         }
 845
 846         /* Enable everything if we're enabling this device from scratch */
 847         if (od->_state == OMAP_DEVICE_STATE_UNKNOWN)
 848                 od->pm_lat_level = od->pm_lats_cnt;
 849
 850         ret = _omap_device_activate(od, IGNORE_WAKEUP_LAT);
 851
 852         od->dev_wakeup_lat = 0;
 853         od->_dev_wakeup_lat_limit = UINT_MAX;
 854         od->_state = OMAP_DEVICE_STATE_ENABLED;
 855
 856         return ret;
 857 }
 858
 859 /**
 860  * omap_device_idle - idle an omap_device
 861  * @od: struct omap_device * to idle
 862  *
 863  * Idle omap_device @od by calling as many .deactivate_func() entries
 864  * in the omap_device's pm_lats table as is possible without exceeding
 865  * the device's maximum wakeup latency limit, pm_lat_limit.  Device
 866  * drivers should call this function (through platform_data function
 867  * pointers) where they would normally disable clocks after operations
 868  * complete, etc..  Returns -EINVAL if the omap_device is not
 869  * currently enabled, or passes along the return value of
 870  * _omap_device_deactivate().
 871  */
 872 int omap_device_idle(struct platform_device *pdev)
 873 {
 874         int ret;
 875         struct omap_device *od;
 876
 877         od = to_omap_device(pdev);
 878
 879         if (od->_state != OMAP_DEVICE_STATE_ENABLED) {
 880                 dev_warn(&pdev->dev,
 881                          "omap_device: %s() called from invalid state %d\n",
 882                          __func__, od->_state);
 883                 return -EINVAL;
 884         }
 885
 886         ret = _omap_device_deactivate(od, USE_WAKEUP_LAT);
 887
 888         od->_state = OMAP_DEVICE_STATE_IDLE;
 889
 890         return ret;
 891 }
 892
 893 /**
 894  * omap_device_shutdown - shut down an omap_device
 895  * @od: struct omap_device * to shut down
 896  *
 897  * Shut down omap_device @od by calling all .deactivate_func() entries
 898  * in the omap_device's pm_lats table and then shutting down all of
 899  * the underlying omap_hwmods.  Used when a device is being "removed"
 900  * or a device driver is being unloaded.  Returns -EINVAL if the
 901  * omap_device is not currently enabled or idle, or passes along the
 902  * return value of _omap_device_deactivate().
 903  */
 904 int omap_device_shutdown(struct platform_device *pdev)
 905 {
 906         int ret, i;
 907         struct omap_device *od;
 908
 909         od = to_omap_device(pdev);
 910
 911         if (od->_state != OMAP_DEVICE_STATE_ENABLED &&
 912             od->_state != OMAP_DEVICE_STATE_IDLE) {
 913                 dev_warn(&pdev->dev,
 914                          "omap_device: %s() called from invalid state %d\n",
 915                          __func__, od->_state);
 916                 return -EINVAL;
 917         }
 918
 919         ret = _omap_device_deactivate(od, IGNORE_WAKEUP_LAT);
 920
 921         for (i = 0; i < od->hwmods_cnt; i++)
 922                 omap_hwmod_shutdown(od->hwmods[i]);
 923
 924         od->_state = OMAP_DEVICE_STATE_SHUTDOWN;
 925
 926         return ret;
 927 }
 928
 929 /**
 930  * omap_device_align_pm_lat - activate/deactivate device to match wakeup lat lim
 931  * @od: struct omap_device *
 932  *
 933  * When a device's maximum wakeup latency limit changes, call some of
 934  * the .activate_func or .deactivate_func function pointers in the
 935  * omap_device's pm_lats array to ensure that the device's maximum
 936  * wakeup latency is less than or equal to the new latency limit.
 937  * Intended to be called by OMAP PM code whenever a device's maximum
 938  * wakeup latency limit changes (e.g., via
 939  * omap_pm_set_dev_wakeup_lat()).  Returns 0 if nothing needs to be
 940  * done (e.g., if the omap_device is not currently idle, or if the
 941  * wakeup latency is already current with the new limit) or passes
 942  * along the return value of _omap_device_deactivate() or
 943  * _omap_device_activate().
 944  */
 945 int omap_device_align_pm_lat(struct platform_device *pdev,
 946                              u32 new_wakeup_lat_limit)
 947 {
 948         int ret = -EINVAL;
 949         struct omap_device *od;
 950
 951         od = to_omap_device(pdev);
 952
 953         if (new_wakeup_lat_limit == od->dev_wakeup_lat)
 954                 return 0;
 955
 956         od->_dev_wakeup_lat_limit = new_wakeup_lat_limit;
 957
 958         if (od->_state != OMAP_DEVICE_STATE_IDLE)
 959                 return 0;
 960         else if (new_wakeup_lat_limit > od->dev_wakeup_lat)
 961                 ret = _omap_device_deactivate(od, USE_WAKEUP_LAT);
 962         else if (new_wakeup_lat_limit < od->dev_wakeup_lat)
 963                 ret = _omap_device_activate(od, USE_WAKEUP_LAT);
 964
 965         return ret;
 966 }
 967
 968 /**
 969  * omap_device_get_pwrdm - return the powerdomain * associated with @od
 970  * @od: struct omap_device *
 971  *
 972  * Return the powerdomain associated with the first underlying
 973  * omap_hwmod for this omap_device.  Intended for use by core OMAP PM
 974  * code.  Returns NULL on error or a struct powerdomain * upon
 975  * success.
 976  */
 977 struct powerdomain *omap_device_get_pwrdm(struct omap_device *od)
 978 {
 979         /*
 980          * XXX Assumes that all omap_hwmod powerdomains are identical.
 981          * This may not necessarily be true.  There should be a sanity
 982          * check in here to WARN() if any difference appears.
 983          */
 984         if (!od->hwmods_cnt)
 985                 return NULL;
 986
 987         return omap_hwmod_get_pwrdm(od->hwmods[0]);
 988 }
 989
 990 /**
 991  * omap_device_get_mpu_rt_va - return the MPU's virtual addr for the hwmod base
 992  * @od: struct omap_device *
 993  *
 994  * Return the MPU's virtual address for the base of the hwmod, from
 995  * the ioremap() that the hwmod code does.  Only valid if there is one
 996  * hwmod associated with this device.  Returns NULL if there are zero
 997  * or more than one hwmods associated with this omap_device;
 998  * otherwise, passes along the return value from
 999  * omap_hwmod_get_mpu_rt_va().
1000  */
1001 void __iomem *omap_device_get_rt_va(struct omap_device *od)
1002 {
1003         if (od->hwmods_cnt != 1)
1004                 return NULL;
1005
1006         return omap_hwmod_get_mpu_rt_va(od->hwmods[0]);
1007 }
1008
1009 /**
1010  * omap_device_get_by_hwmod_name() - convert a hwmod name to
1011  * device pointer.
1012  * @oh_name: name of the hwmod device
1013  *
1014  * Returns back a struct device * pointer associated with a hwmod
1015  * device represented by a hwmod_name
1016  */
1017 struct device *omap_device_get_by_hwmod_name(const char *oh_name)
1018 {
1019         struct omap_hwmod *oh;
1020
1021         if (!oh_name) {
1022                 WARN(1, "%s: no hwmod name!\n", __func__);
1023                 return ERR_PTR(-EINVAL);
1024         }
1025
1026         oh = omap_hwmod_lookup(oh_name);
1027         if (IS_ERR_OR_NULL(oh)) {
1028                 WARN(1, "%s: no hwmod for %s\n", __func__,
1029                         oh_name);
1030                 return ERR_PTR(oh ? PTR_ERR(oh) : -ENODEV);
1031         }
1032         if (IS_ERR_OR_NULL(oh->od)) {
1033                 WARN(1, "%s: no omap_device for %s\n", __func__,
1034                         oh_name);
1035                 return ERR_PTR(oh->od ? PTR_ERR(oh->od) : -ENODEV);
1036         }
1037
1038         if (IS_ERR_OR_NULL(oh->od->pdev))
1039                 return ERR_PTR(oh->od->pdev ? PTR_ERR(oh->od->pdev) : -ENODEV);
1040
1041         return &oh->od->pdev->dev;
1042 }
1043 EXPORT_SYMBOL(omap_device_get_by_hwmod_name);
1044
1045 /*
1046  * Public functions intended for use in omap_device_pm_latency
1047  * .activate_func and .deactivate_func function pointers
1048  */
1049
1050 /**
1051  * omap_device_enable_hwmods - call omap_hwmod_enable() on all hwmods
1052  * @od: struct omap_device *od
1053  *
1054  * Enable all underlying hwmods.  Returns 0.
1055  */
1056 int omap_device_enable_hwmods(struct omap_device *od)
1057 {
1058         int i;
1059
1060         for (i = 0; i < od->hwmods_cnt; i++)
1061                 omap_hwmod_enable(od->hwmods[i]);
1062
1063         /* XXX pass along return value here? */
1064         return 0;
1065 }
1066
1067 /**
1068  * omap_device_idle_hwmods - call omap_hwmod_idle() on all hwmods
1069  * @od: struct omap_device *od
1070  *
1071  * Idle all underlying hwmods.  Returns 0.
1072  */
1073 int omap_device_idle_hwmods(struct omap_device *od)
1074 {
1075         int i;
1076
1077         for (i = 0; i < od->hwmods_cnt; i++)
1078                 omap_hwmod_idle(od->hwmods[i]);
1079
1080         /* XXX pass along return value here? */
1081         return 0;
1082 }
1083
1084 /**
1085  * omap_device_disable_clocks - disable all main and interface clocks
1086  * @od: struct omap_device *od
1087  *
1088  * Disable the main functional clock and interface clock for all of the
1089  * omap_hwmods associated with the omap_device.  Returns 0.
1090  */
1091 int omap_device_disable_clocks(struct omap_device *od)
1092 {
1093         int i;
1094
1095         for (i = 0; i < od->hwmods_cnt; i++)
1096                 omap_hwmod_disable_clocks(od->hwmods[i]);
1097
1098         /* XXX pass along return value here? */
1099         return 0;
1100 }
1101
1102 /**
1103  * omap_device_enable_clocks - enable all main and interface clocks
1104  * @od: struct omap_device *od
1105  *
1106  * Enable the main functional clock and interface clock for all of the
1107  * omap_hwmods associated with the omap_device.  Returns 0.
1108  */
1109 int omap_device_enable_clocks(struct omap_device *od)
1110 {
1111         int i;
1112
1113         for (i = 0; i < od->hwmods_cnt; i++)
1114                 omap_hwmod_enable_clocks(od->hwmods[i]);
1115
1116         /* XXX pass along return value here? */
1117         return 0;
1118 }
1119
1120 static struct notifier_block platform_nb = {
1121         .notifier_call = _omap_device_notifier_call,
1122 };
1123
1124 static int __init omap_device_init(void)
1125 {
1126         bus_register_notifier(&platform_bus_type, &platform_nb);
1127         return 0;
1128 }
1129 core_initcall(omap_device_init);