1 files changed, 150 insertions, 42 deletions

diff --git a/arch/arm/plat-omap/omap_device.c b/arch/arm/plat-omap/omap_device.c
index d2b160942ccc..49fc0df0c21f 100644
--- a/arch/arm/plat-omap/omap_device.c
+++ b/arch/arm/plat-omap/omap_device.c
@@ -82,20 +82,18 @@
 #include <linux/slab.h>
 #include <linux/err.h>
 #include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/clkdev.h>
+#include <linux/pm_runtime.h>
 
 #include <plat/omap_device.h>
 #include <plat/omap_hwmod.h>
+#include <plat/clock.h>
 
 /* These parameters are passed to _omap_device_{de,}activate() */
 #define USE_WAKEUP_LAT                  0
 #define IGNORE_WAKEUP_LAT               1
 
-/*
- * OMAP_DEVICE_MAGIC: used to determine whether a struct omap_device
- * obtained via container_of() is in fact a struct omap_device
- */
-#define OMAP_DEVICE_MAGIC                0xf00dcafe
-
 /* Private functions */
 
 /**
@@ -243,10 +241,90 @@ static inline struct omap_device *_find_by_pdev(struct platform_device *pdev)
         return container_of(pdev, struct omap_device, pdev);
 }
 
+/**
+ * _add_optional_clock_clkdev - Add clkdev entry for hwmod optional clocks
+ * @od: struct omap_device *od
+ *
+ * For every optional clock present per hwmod per omap_device, this function
+ * adds an entry in the clkdev table of the form <dev-id=dev_name, con-id=role>
+ * if it does not exist already.
+ *
+ * The function is called from inside omap_device_build_ss(), after
+ * omap_device_register.
+ *
+ * This allows drivers to get a pointer to its optional clocks based on its role
+ * by calling clk_get(<dev*>, <role>).
+ *
+ * No return value.
+ */
+static void _add_optional_clock_clkdev(struct omap_device *od,
+                                      struct omap_hwmod *oh)
+{
+        int i;
+
+        for (i = 0; i < oh->opt_clks_cnt; i++) {
+                struct omap_hwmod_opt_clk *oc;
+                struct clk *r;
+                struct clk_lookup *l;
+
+                oc = &oh->opt_clks[i];
+
+                if (!oc->_clk)
+                        continue;
+
+                r = clk_get_sys(dev_name(&od->pdev.dev), oc->role);
+                if (!IS_ERR(r))
+                        continue; /* clkdev entry exists */
+
+                r = omap_clk_get_by_name((char *)oc->clk);
+                if (IS_ERR(r)) {
+                        pr_err("omap_device: %s: omap_clk_get_by_name for %s failed\n",
+                               dev_name(&od->pdev.dev), oc->clk);
+                        continue;
+                }
+
+                l = clkdev_alloc(r, oc->role, dev_name(&od->pdev.dev));
+                if (!l) {
+                        pr_err("omap_device: %s: clkdev_alloc for %s failed\n",
+                               dev_name(&od->pdev.dev), oc->role);
+                        return;
+                }
+                clkdev_add(l);
+        }
+}
+
 
 /* Public functions for use by core code */
 
 /**
+ * omap_device_get_context_loss_count - get lost context count
+ * @od: struct omap_device *
+ *
+ * Using the primary hwmod, query the context loss count for this
+ * device.
+ *
+ * Callers should consider context for this device lost any time this
+ * function returns a value different than the value the caller got
+ * the last time it called this function.
+ *
+ * If any hwmods exist for the omap_device assoiated with @pdev,
+ * return the context loss counter for that hwmod, otherwise return
+ * zero.
+ */
+u32 omap_device_get_context_loss_count(struct platform_device *pdev)
+{
+        struct omap_device *od;
+        u32 ret = 0;
+
+        od = _find_by_pdev(pdev);
+
+        if (od->hwmods_cnt)
+                ret = omap_hwmod_get_context_loss_count(od->hwmods[0]);
+
+        return ret;
+}
+
+/**
  * omap_device_count_resources - count number of struct resource entries needed
  * @od: struct omap_device *
  *
@@ -257,12 +335,11 @@ static inline struct omap_device *_find_by_pdev(struct platform_device *pdev)
  */
 int omap_device_count_resources(struct omap_device *od)
 {
-        struct omap_hwmod *oh;
         int c = 0;
         int i;
 
-        for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++)
-                c += omap_hwmod_count_resources(oh);
+        for (i = 0; i < od->hwmods_cnt; i++)
+                c += omap_hwmod_count_resources(od->hwmods[i]);
 
         pr_debug("omap_device: %s: counted %d total resources across %d "
                  "hwmods\n", od->pdev.name, c, od->hwmods_cnt);
@@ -289,12 +366,11 @@ int omap_device_count_resources(struct omap_device *od)
  */
 int omap_device_fill_resources(struct omap_device *od, struct resource *res)
 {
-        struct omap_hwmod *oh;
         int c = 0;
         int i, r;
 
-        for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++) {
-                r = omap_hwmod_fill_resources(oh, res);
+        for (i = 0; i < od->hwmods_cnt; i++) {
+                r = omap_hwmod_fill_resources(od->hwmods[i], res);
                 res += r;
                 c += r;
         }
@@ -414,15 +490,15 @@ struct omap_device *omap_device_build_ss(const char *pdev_name, int pdev_id,
         od->pm_lats = pm_lats;
         od->pm_lats_cnt = pm_lats_cnt;
 
-        od->magic = OMAP_DEVICE_MAGIC;
-
         if (is_early_device)
                 ret = omap_early_device_register(od);
         else
                 ret = omap_device_register(od);
 
-        for (i = 0; i < oh_cnt; i++)
+        for (i = 0; i < oh_cnt; i++) {
                 hwmods[i]->od = od;
+                _add_optional_clock_clkdev(od, hwmods[i]);
+        }
 
         if (ret)
                 goto odbs_exit4;
@@ -461,6 +537,42 @@ int omap_early_device_register(struct omap_device *od)
         return 0;
 }
 
+static int _od_runtime_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        int ret;
+
+        ret = pm_generic_runtime_suspend(dev);
+
+        if (!ret)
+                omap_device_idle(pdev);
+
+        return ret;
+}
+
+static int _od_runtime_idle(struct device *dev)
+{
+        return pm_generic_runtime_idle(dev);
+}
+
+static int _od_runtime_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+
+        omap_device_enable(pdev);
+
+        return pm_generic_runtime_resume(dev);
+}
+
+static struct dev_power_domain omap_device_power_domain = {
+        .ops = {
+                .runtime_suspend = _od_runtime_suspend,
+                .runtime_idle = _od_runtime_idle,
+                .runtime_resume = _od_runtime_resume,
+                USE_PLATFORM_PM_SLEEP_OPS
+        }
+};
+
 /**
  * omap_device_register - register an omap_device with one omap_hwmod
  * @od: struct omap_device * to register
@@ -473,6 +585,8 @@ int omap_device_register(struct omap_device *od)
 {
         pr_debug("omap_device: %s: registering\n", od->pdev.name);
 
+        od->pdev.dev.parent = &omap_device_parent;
+        od->pdev.dev.pwr_domain = &omap_device_power_domain;
         return platform_device_register(&od->pdev);
 }
 
@@ -566,7 +680,6 @@ int omap_device_shutdown(struct platform_device *pdev)
 {
         int ret, i;
         struct omap_device *od;
-        struct omap_hwmod *oh;
 
         od = _find_by_pdev(pdev);
 
@@ -579,8 +692,8 @@ int omap_device_shutdown(struct platform_device *pdev)
 
         ret = _omap_device_deactivate(od, IGNORE_WAKEUP_LAT);
 
-        for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++)
-                omap_hwmod_shutdown(oh);
+        for (i = 0; i < od->hwmods_cnt; i++)
+                omap_hwmod_shutdown(od->hwmods[i]);
 
         od->_state = OMAP_DEVICE_STATE_SHUTDOWN;
 
@@ -627,18 +740,6 @@ int omap_device_align_pm_lat(struct platform_device *pdev,
 }
 
 /**
- * omap_device_is_valid - Check if pointer is a valid omap_device
- * @od: struct omap_device *
- *
- * Return whether struct omap_device pointer @od points to a valid
- * omap_device.
- */
-bool omap_device_is_valid(struct omap_device *od)
-{
-        return (od && od->magic == OMAP_DEVICE_MAGIC);
-}
-
-/**
  * omap_device_get_pwrdm - return the powerdomain * associated with @od
  * @od: struct omap_device *
  *
@@ -692,11 +793,10 @@ void __iomem *omap_device_get_rt_va(struct omap_device *od)
  */
 int omap_device_enable_hwmods(struct omap_device *od)
 {
-        struct omap_hwmod *oh;
         int i;
 
-        for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++)
-                omap_hwmod_enable(oh);
+        for (i = 0; i < od->hwmods_cnt; i++)
+                omap_hwmod_enable(od->hwmods[i]);
 
         /* XXX pass along return value here? */
         return 0;
@@ -710,11 +810,10 @@ int omap_device_enable_hwmods(struct omap_device *od)
  */
 int omap_device_idle_hwmods(struct omap_device *od)
 {
-        struct omap_hwmod *oh;
         int i;
 
-        for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++)
-                omap_hwmod_idle(oh);
+        for (i = 0; i < od->hwmods_cnt; i++)
+                omap_hwmod_idle(od->hwmods[i]);
 
         /* XXX pass along return value here? */
         return 0;
@@ -729,11 +828,10 @@ int omap_device_idle_hwmods(struct omap_device *od)
  */
 int omap_device_disable_clocks(struct omap_device *od)
 {
-        struct omap_hwmod *oh;
         int i;
 
-        for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++)
-                omap_hwmod_disable_clocks(oh);
+        for (i = 0; i < od->hwmods_cnt; i++)
+                omap_hwmod_disable_clocks(od->hwmods[i]);
 
         /* XXX pass along return value here? */
         return 0;
@@ -748,12 +846,22 @@ int omap_device_disable_clocks(struct omap_device *od)
  */
 int omap_device_enable_clocks(struct omap_device *od)
 {
-        struct omap_hwmod *oh;
         int i;
 
-        for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++)
-                omap_hwmod_enable_clocks(oh);
+        for (i = 0; i < od->hwmods_cnt; i++)
+                omap_hwmod_enable_clocks(od->hwmods[i]);
 
         /* XXX pass along return value here? */
         return 0;
 }
+
+struct device omap_device_parent = {
+        .init_name      = "omap",
+        .parent         = &platform_bus,
+};
+
+static int __init omap_device_init(void)
+{
+        return device_register(&omap_device_parent);
+}
+core_initcall(omap_device_init);