10 files changed, 536 insertions, 173 deletions

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index c30bac8503bc..74c5a8e467e8 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -116,7 +116,7 @@ void acpi_numa_arch_fixup(void);
 
 #ifdef CONFIG_ACPI_HOTPLUG_CPU
 /* Arch dependent functions for cpu hotplug support */
-int acpi_map_lsapic(acpi_handle handle, int *pcpu);
+int acpi_map_lsapic(acpi_handle handle, int physid, int *pcpu);
 int acpi_unmap_lsapic(int cpu);
 #endif /* CONFIG_ACPI_HOTPLUG_CPU */
 
diff --git a/include/linux/backlight.h b/include/linux/backlight.h
index 53b77949c79d..5f9cd963213d 100644
--- a/include/linux/backlight.h
+++ b/include/linux/backlight.h
@@ -100,6 +100,9 @@ struct backlight_device {
         /* The framebuffer notifier block */
         struct notifier_block fb_notif;
 
+        /* list entry of all registered backlight devices */
+        struct list_head entry;
+
         struct device dev;
 };
 
@@ -123,6 +126,7 @@ extern void devm_backlight_device_unregister(struct device *dev,
                                         struct backlight_device *bd);
 extern void backlight_force_update(struct backlight_device *bd,
                                    enum backlight_update_reason reason);
+extern bool backlight_device_registered(enum backlight_type type);
 
 #define to_backlight_device(obj) container_of(obj, struct backlight_device, dev)
 
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index bd0c4598d03b..abc9ca778456 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -4,8 +4,11 @@
 
 #ifdef  __KERNEL__
 #define BIT(nr)                 (1UL << (nr))
+#define BIT_ULL(nr)             (1ULL << (nr))
 #define BIT_MASK(nr)            (1UL << ((nr) % BITS_PER_LONG))
 #define BIT_WORD(nr)            ((nr) / BITS_PER_LONG)
+#define BIT_ULL_MASK(nr)        (1ULL << ((nr) % BITS_PER_LONG_LONG))
+#define BIT_ULL_WORD(nr)        ((nr) / BITS_PER_LONG_LONG)
 #define BITS_PER_BYTE           8
 #define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
 #endif
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index fbd25c3c2923..03e235ad1bba 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -188,19 +188,6 @@ extern void cpu_hotplug_enable(void);
 void clear_tasks_mm_cpumask(int cpu);
 int cpu_down(unsigned int cpu);
 
-#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
-extern void cpu_hotplug_driver_lock(void);
-extern void cpu_hotplug_driver_unlock(void);
-#else
-static inline void cpu_hotplug_driver_lock(void)
-{
-}
-
-static inline void cpu_hotplug_driver_unlock(void)
-{
-}
-#endif
-
 #else           /* CONFIG_HOTPLUG_CPU */
 
 static inline void cpu_hotplug_begin(void) {}
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index fcabc42d66ab..5bd6ab9b0c27 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -85,6 +85,20 @@ struct cpufreq_policy {
         struct list_head        policy_list;
         struct kobject          kobj;
         struct completion       kobj_unregister;
+
+        /*
+         * The rules for this semaphore:
+         * - Any routine that wants to read from the policy structure will
+         *   do a down_read on this semaphore.
+         * - Any routine that will write to the policy structure and/or may take away
+         *   the policy altogether (eg. CPU hotplug), will hold this lock in write
+         *   mode before doing so.
+         *
+         * Additional rules:
+         * - Lock should not be held across
+         *     __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT);
+         */
+        struct rw_semaphore     rwsem;
 };
 
 /* Only for ACPI */
@@ -180,13 +194,6 @@ __ATTR(_name, 0644, show_##_name, store_##_name)
 struct cpufreq_driver {
         char                    name[CPUFREQ_NAME_LEN];
         u8                      flags;
-        /*
-         * This should be set by platforms having multiple clock-domains, i.e.
-         * supporting multiple policies. With this sysfs directories of governor
-         * would be created in cpu/cpu<num>/cpufreq/ directory and so they can
-         * use the same governor with different tunables for different clusters.
-         */
-        bool                    have_governor_per_policy;
 
         /* needed by all drivers */
         int     (*init)         (struct cpufreq_policy *policy);
@@ -194,9 +201,11 @@ struct cpufreq_driver {
 
         /* define one out of two */
         int     (*setpolicy)    (struct cpufreq_policy *policy);
-        int     (*target)       (struct cpufreq_policy *policy,
+        int     (*target)       (struct cpufreq_policy *policy, /* Deprecated */
                                  unsigned int target_freq,
                                  unsigned int relation);
+        int     (*target_index) (struct cpufreq_policy *policy,
+                                 unsigned int index);
 
         /* should be defined, if possible */
         unsigned int    (*get)  (unsigned int cpu);
@@ -211,13 +220,29 @@ struct cpufreq_driver {
 };
 
 /* flags */
-#define CPUFREQ_STICKY          0x01    /* the driver isn't removed even if
-                                         * all ->init() calls failed */
-#define CPUFREQ_CONST_LOOPS     0x02    /* loops_per_jiffy or other kernel
-                                         * "constants" aren't affected by
-                                         * frequency transitions */
-#define CPUFREQ_PM_NO_WARN      0x04    /* don't warn on suspend/resume speed
-                                         * mismatches */
+#define CPUFREQ_STICKY          (1 << 0)        /* driver isn't removed even if
+                                                   all ->init() calls failed */
+#define CPUFREQ_CONST_LOOPS     (1 << 1)        /* loops_per_jiffy or other
+                                                   kernel "constants" aren't
+                                                   affected by frequency
+                                                   transitions */
+#define CPUFREQ_PM_NO_WARN      (1 << 2)        /* don't warn on suspend/resume
+                                                   speed mismatches */
+
+/*
+ * This should be set by platforms having multiple clock-domains, i.e.
+ * supporting multiple policies. With this sysfs directories of governor would
+ * be created in cpu/cpu<num>/cpufreq/ directory and so they can use the same
+ * governor with different tunables for different clusters.
+ */
+#define CPUFREQ_HAVE_GOVERNOR_PER_POLICY (1 << 3)
+
+/*
+ * Driver will do POSTCHANGE notifications from outside of their ->target()
+ * routine and so must set cpufreq_driver->flags with this flag, so that core
+ * can handle them specially.
+ */
+#define CPUFREQ_ASYNC_NOTIFICATION  (1 << 4)
 
 int cpufreq_register_driver(struct cpufreq_driver *driver_data);
 int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
@@ -240,6 +265,13 @@ static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,
         return;
 }
 
+static inline void
+cpufreq_verify_within_cpu_limits(struct cpufreq_policy *policy)
+{
+        cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
+                        policy->cpuinfo.max_freq);
+}
+
 /*********************************************************************
  *                     CPUFREQ NOTIFIER INTERFACE                    *
  *********************************************************************/
@@ -392,6 +424,7 @@ int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
 
 int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
                                    struct cpufreq_frequency_table *table);
+int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy);
 
 int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
                                    struct cpufreq_frequency_table *table,
@@ -407,8 +440,20 @@ struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
 
 /* the following are really really optional */
 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
+extern struct freq_attr *cpufreq_generic_attr[];
 void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table,
                                       unsigned int cpu);
 void cpufreq_frequency_table_put_attr(unsigned int cpu);
+int cpufreq_table_validate_and_show(struct cpufreq_policy *policy,
+                                      struct cpufreq_frequency_table *table);
+
+int cpufreq_generic_init(struct cpufreq_policy *policy,
+                struct cpufreq_frequency_table *table,
+                unsigned int transition_latency);
+static inline int cpufreq_generic_exit(struct cpufreq_policy *policy)
+{
+        cpufreq_frequency_table_put_attr(policy->cpu);
+        return 0;
+}
 
 #endif /* _LINUX_CPUFREQ_H */
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index 781addc66f03..50fcbb0ac4e7 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -114,7 +114,7 @@ struct cpuidle_driver {
         int                     safe_state_index;
 
         /* the driver handles the cpus in cpumask */
-        struct cpumask       *cpumask;
+        struct cpumask          *cpumask;
 };
 
 #ifdef CONFIG_CPU_IDLE
@@ -195,16 +195,10 @@ struct cpuidle_governor {
 };
 
 #ifdef CONFIG_CPU_IDLE
-
 extern int cpuidle_register_governor(struct cpuidle_governor *gov);
-extern void cpuidle_unregister_governor(struct cpuidle_governor *gov);
-
 #else
-
 static inline int cpuidle_register_governor(struct cpuidle_governor *gov)
 {return 0;}
-static inline void cpuidle_unregister_governor(struct cpuidle_governor *gov) { }
-
 #endif
 
 #ifdef CONFIG_ARCH_HAS_CPU_RELAX
diff --git a/include/linux/devfreq.h b/include/linux/devfreq.h
index 5f1ab92107e6..7a7cc74d7f27 100644
--- a/include/linux/devfreq.h
+++ b/include/linux/devfreq.h
@@ -15,7 +15,7 @@
 
 #include <linux/device.h>
 #include <linux/notifier.h>
-#include <linux/opp.h>
+#include <linux/pm_opp.h>
 
 #define DEVFREQ_NAME_LEN 16
 
@@ -187,7 +187,7 @@ extern int devfreq_suspend_device(struct devfreq *devfreq);
 extern int devfreq_resume_device(struct devfreq *devfreq);
 
 /* Helper functions for devfreq user device driver with OPP. */
-extern struct opp *devfreq_recommended_opp(struct device *dev,
+extern struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
                                            unsigned long *freq, u32 flags);
 extern int devfreq_register_opp_notifier(struct device *dev,
                                          struct devfreq *devfreq);
@@ -238,7 +238,7 @@ static inline int devfreq_resume_device(struct devfreq *devfreq)
         return 0;
 }
 
-static inline struct opp *devfreq_recommended_opp(struct device *dev,
+static inline struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
                                            unsigned long *freq, u32 flags)
 {
         return ERR_PTR(-EINVAL);
diff --git a/include/linux/opp.h b/include/linux/opp.h
deleted file mode 100644
index 3aca2b8def33..000000000000
--- a/include/linux/opp.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Generic OPP Interface
- *
- * Copyright (C) 2009-2010 Texas Instruments Incorporated.
- *      Nishanth Menon
- *      Romit Dasgupta
- *      Kevin Hilman
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#ifndef __LINUX_OPP_H__
-#define __LINUX_OPP_H__
-
-#include <linux/err.h>
-#include <linux/cpufreq.h>
-#include <linux/notifier.h>
-
-struct opp;
-struct device;
-
-enum opp_event {
-        OPP_EVENT_ADD, OPP_EVENT_ENABLE, OPP_EVENT_DISABLE,
-};
-
-#if defined(CONFIG_PM_OPP)
-
-unsigned long opp_get_voltage(struct opp *opp);
-
-unsigned long opp_get_freq(struct opp *opp);
-
-int opp_get_opp_count(struct device *dev);
-
-struct opp *opp_find_freq_exact(struct device *dev, unsigned long freq,
-                                bool available);
-
-struct opp *opp_find_freq_floor(struct device *dev, unsigned long *freq);
-
-struct opp *opp_find_freq_ceil(struct device *dev, unsigned long *freq);
-
-int opp_add(struct device *dev, unsigned long freq, unsigned long u_volt);
-
-int opp_enable(struct device *dev, unsigned long freq);
-
-int opp_disable(struct device *dev, unsigned long freq);
-
-struct srcu_notifier_head *opp_get_notifier(struct device *dev);
-#else
-static inline unsigned long opp_get_voltage(struct opp *opp)
-{
-        return 0;
-}
-
-static inline unsigned long opp_get_freq(struct opp *opp)
-{
-        return 0;
-}
-
-static inline int opp_get_opp_count(struct device *dev)
-{
-        return 0;
-}
-
-static inline struct opp *opp_find_freq_exact(struct device *dev,
-                                        unsigned long freq, bool available)
-{
-        return ERR_PTR(-EINVAL);
-}
-
-static inline struct opp *opp_find_freq_floor(struct device *dev,
-                                        unsigned long *freq)
-{
-        return ERR_PTR(-EINVAL);
-}
-
-static inline struct opp *opp_find_freq_ceil(struct device *dev,
-                                        unsigned long *freq)
-{
-        return ERR_PTR(-EINVAL);
-}
-
-static inline int opp_add(struct device *dev, unsigned long freq,
-                                        unsigned long u_volt)
-{
-        return -EINVAL;
-}
-
-static inline int opp_enable(struct device *dev, unsigned long freq)
-{
-        return 0;
-}
-
-static inline int opp_disable(struct device *dev, unsigned long freq)
-{
-        return 0;
-}
-
-static inline struct srcu_notifier_head *opp_get_notifier(struct device *dev)
-{
-        return ERR_PTR(-EINVAL);
-}
-#endif          /* CONFIG_PM_OPP */
-
-#if defined(CONFIG_PM_OPP) && defined(CONFIG_OF)
-int of_init_opp_table(struct device *dev);
-#else
-static inline int of_init_opp_table(struct device *dev)
-{
-        return -EINVAL;
-}
-#endif
-
-#if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
-int opp_init_cpufreq_table(struct device *dev,
-                            struct cpufreq_frequency_table **table);
-void opp_free_cpufreq_table(struct device *dev,
-                                struct cpufreq_frequency_table **table);
-#else
-static inline int opp_init_cpufreq_table(struct device *dev,
-                            struct cpufreq_frequency_table **table)
-{
-        return -EINVAL;
-}
-
-static inline
-void opp_free_cpufreq_table(struct device *dev,
-                                struct cpufreq_frequency_table **table)
-{
-}
-#endif          /* CONFIG_CPU_FREQ */
-
-#endif          /* __LINUX_OPP_H__ */
diff --git a/include/linux/pm_opp.h b/include/linux/pm_opp.h
new file mode 100644
index 000000000000..5151b0059585
--- /dev/null
+++ b/include/linux/pm_opp.h
@@ -0,0 +1,139 @@
+/*
+ * Generic OPP Interface
+ *
+ * Copyright (C) 2009-2010 Texas Instruments Incorporated.
+ *      Nishanth Menon
+ *      Romit Dasgupta
+ *      Kevin Hilman
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __LINUX_OPP_H__
+#define __LINUX_OPP_H__
+
+#include <linux/err.h>
+#include <linux/cpufreq.h>
+#include <linux/notifier.h>
+
+struct dev_pm_opp;
+struct device;
+
+enum dev_pm_opp_event {
+        OPP_EVENT_ADD, OPP_EVENT_ENABLE, OPP_EVENT_DISABLE,
+};
+
+#if defined(CONFIG_PM_OPP)
+
+unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp);
+
+unsigned long dev_pm_opp_get_freq(struct dev_pm_opp *opp);
+
+int dev_pm_opp_get_opp_count(struct device *dev);
+
+struct dev_pm_opp *dev_pm_opp_find_freq_exact(struct device *dev,
+                                              unsigned long freq,
+                                              bool available);
+
+struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,
+                                              unsigned long *freq);
+
+struct dev_pm_opp *dev_pm_opp_find_freq_ceil(struct device *dev,
+                                             unsigned long *freq);
+
+int dev_pm_opp_add(struct device *dev, unsigned long freq,
+                   unsigned long u_volt);
+
+int dev_pm_opp_enable(struct device *dev, unsigned long freq);
+
+int dev_pm_opp_disable(struct device *dev, unsigned long freq);
+
+struct srcu_notifier_head *dev_pm_opp_get_notifier(struct device *dev);
+#else
+static inline unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp)
+{
+        return 0;
+}
+
+static inline unsigned long dev_pm_opp_get_freq(struct dev_pm_opp *opp)
+{
+        return 0;
+}
+
+static inline int dev_pm_opp_get_opp_count(struct device *dev)
+{
+        return 0;
+}
+
+static inline struct dev_pm_opp *dev_pm_opp_find_freq_exact(struct device *dev,
+                                        unsigned long freq, bool available)
+{
+        return ERR_PTR(-EINVAL);
+}
+
+static inline struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,
+                                        unsigned long *freq)
+{
+        return ERR_PTR(-EINVAL);
+}
+
+static inline struct dev_pm_opp *dev_pm_opp_find_freq_ceil(struct device *dev,
+                                        unsigned long *freq)
+{
+        return ERR_PTR(-EINVAL);
+}
+
+static inline int dev_pm_opp_add(struct device *dev, unsigned long freq,
+                                        unsigned long u_volt)
+{
+        return -EINVAL;
+}
+
+static inline int dev_pm_opp_enable(struct device *dev, unsigned long freq)
+{
+        return 0;
+}
+
+static inline int dev_pm_opp_disable(struct device *dev, unsigned long freq)
+{
+        return 0;
+}
+
+static inline struct srcu_notifier_head *dev_pm_opp_get_notifier(
+                                                        struct device *dev)
+{
+        return ERR_PTR(-EINVAL);
+}
+#endif          /* CONFIG_PM_OPP */
+
+#if defined(CONFIG_PM_OPP) && defined(CONFIG_OF)
+int of_init_opp_table(struct device *dev);
+#else
+static inline int of_init_opp_table(struct device *dev)
+{
+        return -EINVAL;
+}
+#endif
+
+#if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
+int dev_pm_opp_init_cpufreq_table(struct device *dev,
+                            struct cpufreq_frequency_table **table);
+void dev_pm_opp_free_cpufreq_table(struct device *dev,
+                                struct cpufreq_frequency_table **table);
+#else
+static inline int dev_pm_opp_init_cpufreq_table(struct device *dev,
+                            struct cpufreq_frequency_table **table)
+{
+        return -EINVAL;
+}
+
+static inline
+void dev_pm_opp_free_cpufreq_table(struct device *dev,
+                                struct cpufreq_frequency_table **table)
+{
+}
+#endif          /* CONFIG_CPU_FREQ */
+
+#endif          /* __LINUX_OPP_H__ */
diff --git a/include/linux/powercap.h b/include/linux/powercap.h
new file mode 100644
index 000000000000..4e250417ee30
--- /dev/null
+++ b/include/linux/powercap.h
@@ -0,0 +1,325 @@
+/*
+ * powercap.h: Data types and headers for sysfs power capping interface
+ * Copyright (c) 2013, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.
+ *
+ */
+
+#ifndef __POWERCAP_H__
+#define __POWERCAP_H__
+
+#include <linux/device.h>
+#include <linux/idr.h>
+
+/*
+ * A power cap class device can contain multiple powercap control_types.
+ * Each control_type can have multiple power zones, which can be independently
+ * controlled. Each power zone can have one or more constraints.
+ */
+
+struct powercap_control_type;
+struct powercap_zone;
+struct powercap_zone_constraint;
+
+/**
+ * struct powercap_control_type_ops - Define control type callbacks
+ * @set_enable:         Enable/Disable whole control type.
+ *                      Default is enabled. But this callback allows all zones
+ *                      to be in disable state and remove any applied power
+ *                      limits. If disabled power zone can only be monitored
+ *                      not controlled.
+ * @get_enable:         get Enable/Disable status.
+ * @release:            Callback to inform that last reference to this
+ *                      control type is closed. So it is safe to free data
+ *                      structure associated with this control type.
+ *                      This callback is mandatory if the client own memory
+ *                      for the control type.
+ *
+ * This structure defines control type callbacks to be implemented by client
+ * drivers
+ */
+struct powercap_control_type_ops {
+        int (*set_enable) (struct powercap_control_type *, bool mode);
+        int (*get_enable) (struct powercap_control_type *, bool *mode);
+        int (*release) (struct powercap_control_type *);
+};
+
+/**
+ * struct powercap_control_type- Defines a powercap control_type
+ * @name:               name of control_type
+ * @dev:                device for this control_type
+ * @idr:                idr to have unique id for its child
+ * @root_node:          Root holding power zones for this control_type
+ * @ops:                Pointer to callback struct
+ * @node_lock:          mutex for control type
+ * @allocated:          This is possible that client owns the memory
+ *                      used by this structure. In this case
+ *                      this flag is set to false by framework to
+ *                      prevent deallocation during release process.
+ *                      Otherwise this flag is set to true.
+ * @ctrl_inst:          link to the control_type list
+ *
+ * Defines powercap control_type. This acts as a container for power
+ * zones, which use same method to control power. E.g. RAPL, RAPL-PCI etc.
+ * All fields are private and should not be used by client drivers.
+ */
+struct powercap_control_type {
+        struct device dev;
+        struct idr idr;
+        int nr_zones;
+        const struct powercap_control_type_ops *ops;
+        struct mutex lock;
+        bool allocated;
+        struct list_head node;
+};
+
+/**
+ * struct powercap_zone_ops - Define power zone callbacks
+ * @get_max_energy_range_uj:    Get maximum range of energy counter in
+ *                              micro-joules.
+ * @get_energy_uj:              Get current energy counter in micro-joules.
+ * @reset_energy_uj:            Reset micro-joules energy counter.
+ * @get_max_power_range_uw:     Get maximum range of power counter in
+ *                              micro-watts.
+ * @get_power_uw:               Get current power counter in micro-watts.
+ * @set_enable:                 Enable/Disable power zone controls.
+ *                              Default is enabled.
+ * @get_enable:                 get Enable/Disable status.
+ * @release:                    Callback to inform that last reference to this
+ *                              control type is closed. So it is safe to free
+ *                              data structure associated with this
+ *                              control type. Mandatory, if client driver owns
+ *                              the power_zone memory.
+ *
+ * This structure defines zone callbacks to be implemented by client drivers.
+ * Client drives can define both energy and power related callbacks. But at
+ * the least one type (either power or energy) is mandatory. Client drivers
+ * should handle mutual exclusion, if required in callbacks.
+ */
+struct powercap_zone_ops {
+        int (*get_max_energy_range_uj) (struct powercap_zone *, u64 *);
+        int (*get_energy_uj) (struct powercap_zone *, u64 *);
+        int (*reset_energy_uj) (struct powercap_zone *);
+        int (*get_max_power_range_uw) (struct powercap_zone *, u64 *);
+        int (*get_power_uw) (struct powercap_zone *, u64 *);
+        int (*set_enable) (struct powercap_zone *, bool mode);
+        int (*get_enable) (struct powercap_zone *, bool *mode);
+        int (*release) (struct powercap_zone *);
+};
+
+#define POWERCAP_ZONE_MAX_ATTRS         6
+#define POWERCAP_CONSTRAINTS_ATTRS      8
+#define MAX_CONSTRAINTS_PER_ZONE        10
+/**
+ * struct powercap_zone- Defines instance of a power cap zone
+ * @id:                 Unique id
+ * @name:               Power zone name.
+ * @control_type_inst:  Control type instance for this zone.
+ * @ops:                Pointer to the zone operation structure.
+ * @dev:                Instance of a device.
+ * @const_id_cnt:       Number of constraint defined.
+ * @idr:                Instance to an idr entry for children zones.
+ * @parent_idr:         To remove reference from the parent idr.
+ * @private_data:       Private data pointer if any for this zone.
+ * @zone_dev_attrs:     Attributes associated with this device.
+ * @zone_attr_count:    Attribute count.
+ * @dev_zone_attr_group: Attribute group for attributes.
+ * @dev_attr_groups:    Attribute group store to register with device.
+ * @allocated:          This is possible that client owns the memory
+ *                      used by this structure. In this case
+ *                      this flag is set to false by framework to
+ *                      prevent deallocation during release process.
+ *                      Otherwise this flag is set to true.
+ * @constraint_ptr:     List of constraints for this zone.
+ *
+ * This defines a power zone instance. The fields of this structure are
+ * private, and should not be used by client drivers.
+ */
+struct powercap_zone {
+        int id;
+        char *name;
+        void *control_type_inst;
+        const struct powercap_zone_ops *ops;
+        struct device dev;
+        int const_id_cnt;
+        struct idr idr;
+        struct idr *parent_idr;
+        void *private_data;
+        struct attribute **zone_dev_attrs;
+        int zone_attr_count;
+        struct attribute_group dev_zone_attr_group;
+        const struct attribute_group *dev_attr_groups[2]; /* 1 group + NULL */
+        bool allocated;
+        struct powercap_zone_constraint *constraints;
+};
+
+/**
+ * struct powercap_zone_constraint_ops - Define constraint callbacks
+ * @set_power_limit_uw:         Set power limit in micro-watts.
+ * @get_power_limit_uw:         Get power limit in micro-watts.
+ * @set_time_window_us:         Set time window in micro-seconds.
+ * @get_time_window_us:         Get time window in micro-seconds.
+ * @get_max_power_uw:           Get max power allowed in micro-watts.
+ * @get_min_power_uw:           Get min power allowed in micro-watts.
+ * @get_max_time_window_us:     Get max time window allowed in micro-seconds.
+ * @get_min_time_window_us:     Get min time window allowed in micro-seconds.
+ * @get_name:                   Get the name of constraint
+ *
+ * This structure is used to define the constraint callbacks for the client
+ * drivers. The following callbacks are mandatory and can't be NULL:
+ *  set_power_limit_uw
+ *  get_power_limit_uw
+ *  set_time_window_us
+ *  get_time_window_us
+ *  get_name
+ *  Client drivers should handle mutual exclusion, if required in callbacks.
+ */
+struct powercap_zone_constraint_ops {
+        int (*set_power_limit_uw) (struct powercap_zone *, int, u64);
+        int (*get_power_limit_uw) (struct powercap_zone *, int, u64 *);
+        int (*set_time_window_us) (struct powercap_zone *, int, u64);
+        int (*get_time_window_us) (struct powercap_zone *, int, u64 *);
+        int (*get_max_power_uw) (struct powercap_zone *, int, u64 *);
+        int (*get_min_power_uw) (struct powercap_zone *, int, u64 *);
+        int (*get_max_time_window_us) (struct powercap_zone *, int, u64 *);
+        int (*get_min_time_window_us) (struct powercap_zone *, int, u64 *);
+        const char *(*get_name) (struct powercap_zone *, int);
+};
+
+/**
+ * struct powercap_zone_constraint- Defines instance of a constraint
+ * @id:                 Instance Id of this constraint.
+ * @power_zone:         Pointer to the power zone for this constraint.
+ * @ops:                Pointer to the constraint callbacks.
+ *
+ * This defines a constraint instance.
+ */
+struct powercap_zone_constraint {
+        int id;
+        struct powercap_zone *power_zone;
+        struct powercap_zone_constraint_ops *ops;
+};
+
+
+/* For clients to get their device pointer, may be used for dev_dbgs */
+#define POWERCAP_GET_DEV(power_zone)    (&power_zone->dev)
+
+/**
+* powercap_set_zone_data() - Set private data for a zone
+* @power_zone:  A pointer to the valid zone instance.
+* @pdata:       A pointer to the user private data.
+*
+* Allows client drivers to associate some private data to zone instance.
+*/
+static inline void powercap_set_zone_data(struct powercap_zone *power_zone,
+                                                void *pdata)
+{
+        if (power_zone)
+                power_zone->private_data = pdata;
+}
+
+/**
+* powercap_get_zone_data() - Get private data for a zone
+* @power_zone:  A pointer to the valid zone instance.
+*
+* Allows client drivers to get private data associate with a zone,
+* using call to powercap_set_zone_data.
+*/
+static inline void *powercap_get_zone_data(struct powercap_zone *power_zone)
+{
+        if (power_zone)
+                return power_zone->private_data;
+        return NULL;
+}
+
+/**
+* powercap_register_control_type() - Register a control_type with framework
+* @control_type:        Pointer to client allocated memory for the control type
+*                       structure storage. If this is NULL, powercap framework
+*                       will allocate memory and own it.
+*                       Advantage of this parameter is that client can embed
+*                       this data in its data structures and allocate in a
+*                       single call, preventing multiple allocations.
+* @control_type_name:   The Name of this control_type, which will be shown
+*                       in the sysfs Interface.
+* @ops:                 Callbacks for control type. This parameter is optional.
+*
+* Used to create a control_type with the power capping class. Here control_type
+* can represent a type of technology, which can control a range of power zones.
+* For example a control_type can be RAPL (Running Average Power Limit)
+* Intel® 64 and IA-32 Processor Architectures. The name can be any string
+* which must be unique, otherwise this function returns NULL.
+* A pointer to the control_type instance is returned on success.
+*/
+struct powercap_control_type *powercap_register_control_type(
+                                struct powercap_control_type *control_type,
+                                const char *name,
+                                const struct powercap_control_type_ops *ops);
+
+/**
+* powercap_unregister_control_type() - Unregister a control_type from framework
+* @instance:    A pointer to the valid control_type instance.
+*
+* Used to unregister a control_type with the power capping class.
+* All power zones registered under this control type have to be unregistered
+* before calling this function, or it will fail with an error code.
+*/
+int powercap_unregister_control_type(struct powercap_control_type *instance);
+
+/* Zone register/unregister API */
+
+/**
+* powercap_register_zone() - Register a power zone
+* @power_zone:  Pointer to client allocated memory for the power zone structure
+*               storage. If this is NULL, powercap framework will allocate
+*               memory and own it. Advantage of this parameter is that client
+*               can embed this data in its data structures and allocate in a
+*               single call, preventing multiple allocations.
+* @control_type: A control_type instance under which this zone operates.
+* @name:        A name for this zone.
+* @parent:      A pointer to the parent power zone instance if any or NULL
+* @ops:         Pointer to zone operation callback structure.
+* @no_constraints: Number of constraints for this zone
+* @const_ops:   Pointer to constraint callback structure
+*
+* Register a power zone under a given control type. A power zone must register
+* a pointer to a structure representing zone callbacks.
+* A power zone can be located under a parent power zone, in which case @parent
+* should point to it.  Otherwise, if @parent is NULL, the new power zone will
+* be located directly under the given control type
+* For each power zone there may be a number of constraints that appear in the
+* sysfs under that zone as attributes with unique numeric IDs.
+* Returns pointer to the power_zone on success.
+*/
+struct powercap_zone *powercap_register_zone(
+                        struct powercap_zone *power_zone,
+                        struct powercap_control_type *control_type,
+                        const char *name,
+                        struct powercap_zone *parent,
+                        const struct powercap_zone_ops *ops,
+                        int nr_constraints,
+                        struct powercap_zone_constraint_ops *const_ops);
+
+/**
+* powercap_unregister_zone() - Unregister a zone device
+* @control_type:        A pointer to the valid instance of a control_type.
+* @power_zone:  A pointer to the valid zone instance for a control_type
+*
+* Used to unregister a zone device for a control_type.  Caller should
+* make sure that children for this zone are unregistered first.
+*/
+int powercap_unregister_zone(struct powercap_control_type *control_type,
+                                struct powercap_zone *power_zone);
+
+#endif