Thermal: Merge thermal framwork changes from Linux-next
Jinyoung Park [Mon, 26 Nov 2012 22:40:28 +0000 (14:40 -0800)]
There are some massive changes for thermal in Linux-next. They will be
released in Linux kernel-3.7. But several of them are needed for new thermal
management. So merged them from Linux-next to android-tegra-nv-3.4.

This is change list from Linux-next.
- thermal: Fix potential NULL pointer accesses
- thermal, cpufreq: Fix build when CPU_FREQ_TABLE isn't configured
- Thermal: Refactor thermal.h file
- Thermal: Move thermal_instance to thermal_core.h
- Thermal: Add get trend, get instance API's to thermal_sys
- Thermal: Add platform level information to thermal.h
- Thermal: Pass zone parameters as argument to tzd_register
- Thermal: Add thermal governor registration APIs
- Thermal: Add a policy sysfs attribute
- Thermal: Update binding logic based on platform data
- Thermal: Make thermal_cdev_update as a global function
- Thermal: Introduce fair_share thermal governor
- Thermal: Introduce a step_wise thermal governor
- Thermal: Add a thermal notifier for user space
- Thermal: Remove throttling logic out of thermal_sys.c
- Thermal: Add a notification API
- Thermal: Add documentation for platform layer data
- Thermal: Provide option to choose default thermal governor
- Thermal: Fix oops and unlocking in thermal_sys.c
- thermal: step_wise: Add missing static storage class specifiers
- thermal: fair_share: Add missing static storage class specifiers
- thermal: user_space: Add missing static storage class specifiers
- Thermal: add indent for code alignment.
- Thermal: fix bug of counting cpu frequencies.
- Thermal: Remove the cooling_cpufreq_list.

Bug 1059470

Change-Id: I9fc9d1ee6c1b99da21cad309f740a3762512f11c
Signed-off-by: Jinyoung Park <jinyoungp@nvidia.com>
Reviewed-on: http://git-master/r/166320
Reviewed-by: Diwakar Tundlam <dtundlam@nvidia.com>

14 files changed:
Documentation/thermal/sysfs-api.txt
drivers/acpi/thermal.c
drivers/platform/x86/acerhdf.c
drivers/platform/x86/intel_mid_thermal.c
drivers/thermal/Kconfig
drivers/thermal/Makefile
drivers/thermal/cpu_cooling.c
drivers/thermal/fair_share.c [new file with mode: 0644]
drivers/thermal/spear_thermal.c
drivers/thermal/step_wise.c [new file with mode: 0644]
drivers/thermal/thermal_core.h [new file with mode: 0644]
drivers/thermal/thermal_sys.c
drivers/thermal/user_space.c [new file with mode: 0644]
include/linux/thermal.h

index ca1a1a3..88c0233 100644 (file)
@@ -112,6 +112,29 @@ temperature) and throttle appropriate devices.
     trip: indicates which trip point the cooling devices is associated with
          in this thermal zone.
 
+1.4 Thermal Zone Parameters
+1.4.1 struct thermal_bind_params
+    This structure defines the following parameters that are used to bind
+    a zone with a cooling device for a particular trip point.
+    .cdev: The cooling device pointer
+    .weight: The 'influence' of a particular cooling device on this zone.
+             This is on a percentage scale. The sum of all these weights
+             (for a particular zone) cannot exceed 100.
+    .trip_mask:This is a bit mask that gives the binding relation between
+               this thermal zone and cdev, for a particular trip point.
+               If nth bit is set, then the cdev and thermal zone are bound
+               for trip point n.
+    .match: This call back returns success(0) if the 'tz and cdev' need to
+           be bound, as per platform data.
+1.4.2 struct thermal_zone_params
+    This structure defines the platform level parameters for a thermal zone.
+    This data, for each thermal zone should come from the platform layer.
+    This is an optional feature where some platforms can choose not to
+    provide this data.
+    .governor_name: Name of the thermal governor used for this zone
+    .num_tbps: Number of thermal_bind_params entries for this zone
+    .tbp: thermal_bind_params entries
+
 2. sysfs attributes structure
 
 RO     read only value
@@ -126,6 +149,7 @@ Thermal zone device sys I/F, created once it's registered:
     |---type:                  Type of the thermal zone
     |---temp:                  Current temperature
     |---mode:                  Working mode of the thermal zone
+    |---policy:                        Thermal governor used for this zone
     |---trip_point_[0-*]_temp: Trip point temperature
     |---trip_point_[0-*]_type: Trip point type
     |---trip_point_[0-*]_hyst: Hysteresis value for this trip point
@@ -187,6 +211,10 @@ mode
                          charge of the thermal management.
        RW, Optional
 
+policy
+       One of the various thermal governors used for a particular zone.
+       RW, Required
+
 trip_point_[0-*]_temp
        The temperature above which trip point will be fired.
        Unit: millidegree Celsius
@@ -264,6 +292,7 @@ method, the sys I/F structure will be built like this:
     |---type:                  acpitz
     |---temp:                  37000
     |---mode:                  enabled
+    |---policy:                        step_wise
     |---trip_point_0_temp:     100000
     |---trip_point_0_type:     critical
     |---trip_point_1_temp:     80000
@@ -305,3 +334,38 @@ to a thermal_zone_device when it registers itself with the framework. The
 event will be one of:{THERMAL_AUX0, THERMAL_AUX1, THERMAL_CRITICAL,
 THERMAL_DEV_FAULT}. Notification can be sent when the current temperature
 crosses any of the configured thresholds.
+
+5. Export Symbol APIs:
+
+5.1: get_tz_trend:
+This function returns the trend of a thermal zone, i.e the rate of change
+of temperature of the thermal zone. Ideally, the thermal sensor drivers
+are supposed to implement the callback. If they don't, the thermal
+framework calculated the trend by comparing the previous and the current
+temperature values.
+
+5.2:get_thermal_instance:
+This function returns the thermal_instance corresponding to a given
+{thermal_zone, cooling_device, trip_point} combination. Returns NULL
+if such an instance does not exist.
+
+5.3:notify_thermal_framework:
+This function handles the trip events from sensor drivers. It starts
+throttling the cooling devices according to the policy configured.
+For CRITICAL and HOT trip points, this notifies the respective drivers,
+and does actual throttling for other trip points i.e ACTIVE and PASSIVE.
+The throttling policy is based on the configured platform data; if no
+platform data is provided, this uses the step_wise throttling policy.
+
+5.4:thermal_cdev_update:
+This function serves as an arbitrator to set the state of a cooling
+device. It sets the cooling device to the deepest cooling state if
+possible.
+
+5.5:thermal_register_governor:
+This function lets the various thermal governors to register themselves
+with the Thermal framework. At run time, depending on a zone's platform
+data, a particular governor is used for throttling.
+
+5.6:thermal_unregister_governor:
+This function unregisters a governor from the thermal framework.
index a0b1e88..c65fdc0 100644 (file)
@@ -896,14 +896,14 @@ static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz)
        if (tz->trips.passive.flags.valid)
                tz->thermal_zone =
                        thermal_zone_device_register("acpitz", trips, 0, tz,
-                                                    &acpi_thermal_zone_ops,
+                                               &acpi_thermal_zone_ops, NULL,
                                                     tz->trips.passive.tsp*100,
                                                     tz->polling_frequency*100);
        else
                tz->thermal_zone =
                        thermal_zone_device_register("acpitz", trips, 0, tz,
-                                                    &acpi_thermal_zone_ops, 0,
-                                                    tz->polling_frequency*100);
+                                               &acpi_thermal_zone_ops, NULL,
+                                               0, tz->polling_frequency*100);
        if (IS_ERR(tz->thermal_zone))
                return -ENODEV;
 
index aa1c500..29a718d 100644 (file)
@@ -662,7 +662,7 @@ static int acerhdf_register_thermal(void)
                return -EINVAL;
 
        thz_dev = thermal_zone_device_register("acerhdf", 1, 0, NULL,
-                                             &acerhdf_dev_ops, 0,
+                                             &acerhdf_dev_ops, NULL, 0,
                                              (kernelmode) ? interval*1000 : 0);
        if (IS_ERR(thz_dev))
                return -EINVAL;
index 6e309dd..5c14194 100644 (file)
@@ -499,7 +499,7 @@ static int mid_thermal_probe(struct platform_device *pdev)
                        goto err;
                }
                pinfo->tzd[i] = thermal_zone_device_register(name[i],
-                               0, 0, td_info, &tzd_ops, 0, 0);
+                               0, 0, td_info, &tzd_ops, NULL, 0, 0);
                if (IS_ERR(pinfo->tzd[i])) {
                        kfree(td_info);
                        ret = PTR_ERR(pinfo->tzd[i]);
index 3111f40..18852b7 100644 (file)
@@ -22,6 +22,7 @@ config THERMAL_HWMON
 config CPU_THERMAL
        bool "generic cpu cooling support"
        depends on THERMAL && CPU_FREQ
+       select CPU_FREQ_TABLE
        help
          This implements the generic cpu cooling mechanism through frequency
          reduction, cpu hotplug and any other ways of reducing temperature. An
@@ -37,3 +38,52 @@ config SPEAR_THERMAL
        help
          Enable this to plug the SPEAr thermal sensor driver into the Linux
          thermal framework
+
+config FAIR_SHARE
+       bool "Fair-share thermal governor"
+       depends on THERMAL
+       help
+         Enable this to manage platform thermals using fair-share governor.
+
+config STEP_WISE
+       bool "Step_wise thermal governor"
+       depends on THERMAL
+       help
+         Enable this to manage platform thermals using a simple linear
+
+config USER_SPACE
+       bool "User_space thermal governor"
+       depends on THERMAL
+       help
+         Enable this to let the user space manage the platform thermals.
+
+choice
+       prompt "Default Thermal governor"
+       depends on THERMAL
+       default THERMAL_DEFAULT_GOV_STEP_WISE
+       help
+         This option sets which thermal governor shall be loaded at
+         startup. If in doubt, select 'step_wise'.
+
+config THERMAL_DEFAULT_GOV_STEP_WISE
+       bool "step_wise"
+       select STEP_WISE
+       help
+         Use the step_wise governor as default. This throttles the
+         devices one step at a time.
+
+config THERMAL_DEFAULT_GOV_FAIR_SHARE
+       bool "fair_share"
+       select FAIR_SHARE
+       help
+         Use the fair_share governor as default. This throttles the
+         devices based on their 'contribution' to a zone. The
+         contribution should be provided through platform data.
+
+config THERMAL_DEFAULT_GOV_USER_SPACE
+       bool "user_space"
+       select USER_SPACE
+       help
+         Select this if you want to let the user space manage the
+         platform thermals.
+endchoice
index 19edccc..8f2199a 100644 (file)
@@ -7,3 +7,6 @@ obj-$(CONFIG_SPEAR_THERMAL)             += spear_thermal.o
 obj-$(CONFIG_CPU_THERMAL)              += cpu_cooling.o
 obj-$(CONFIG_SPEAR_THERMAL)            += spear_thermal.o
 obj-$(CONFIG_RCAR_THERMAL)     += rcar_thermal.o
+obj-$(CONFIG_FAIR_SHARE)               += fair_share.o
+obj-$(CONFIG_STEP_WISE)                        += step_wise.o
+obj-$(CONFIG_USER_SPACE)               += user_space.o
index 9050c1b..9144f86 100644 (file)
@@ -58,8 +58,9 @@ struct cpufreq_cooling_device {
 };
 static LIST_HEAD(cooling_cpufreq_list);
 static DEFINE_IDR(cpufreq_idr);
+static DEFINE_MUTEX(cooling_cpufreq_lock);
 
-static struct mutex cooling_cpufreq_lock;
+static unsigned int cpufreq_dev_count;
 
 /* notify_table passes value to the CPUFREQ_ADJUST callback function. */
 #define NOTIFY_INVALID NULL
@@ -240,42 +241,32 @@ static int cpufreq_thermal_notifier(struct notifier_block *nb,
 static int cpufreq_get_max_state(struct thermal_cooling_device *cdev,
                                 unsigned long *state)
 {
-       int ret = -EINVAL, i = 0;
-       struct cpufreq_cooling_device *cpufreq_device;
-       struct cpumask *maskPtr;
+       struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
+       struct cpumask *maskPtr = &cpufreq_device->allowed_cpus;
        unsigned int cpu;
        struct cpufreq_frequency_table *table;
+       unsigned long count = 0;
+       int i = 0;
 
-       mutex_lock(&cooling_cpufreq_lock);
-       list_for_each_entry(cpufreq_device, &cooling_cpufreq_list, node) {
-               if (cpufreq_device && cpufreq_device->cool_dev == cdev)
-                       break;
-       }
-       if (cpufreq_device == NULL)
-               goto return_get_max_state;
-
-       maskPtr = &cpufreq_device->allowed_cpus;
        cpu = cpumask_any(maskPtr);
        table = cpufreq_frequency_get_table(cpu);
        if (!table) {
                *state = 0;
-               ret = 0;
-               goto return_get_max_state;
+               return 0;
        }
 
-       while (table[i].frequency != CPUFREQ_TABLE_END) {
+       for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
                if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
                        continue;
-               i++;
+               count++;
        }
-       if (i > 0) {
-               *state = --i;
-               ret = 0;
+
+       if (count > 0) {
+               *state = --count;
+               return 0;
        }
 
-return_get_max_state:
-       mutex_unlock(&cooling_cpufreq_lock);
-       return ret;
+       return -EINVAL;
 }
 
 /**
@@ -286,20 +277,10 @@ return_get_max_state:
 static int cpufreq_get_cur_state(struct thermal_cooling_device *cdev,
                                 unsigned long *state)
 {
-       int ret = -EINVAL;
-       struct cpufreq_cooling_device *cpufreq_device;
+       struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
 
-       mutex_lock(&cooling_cpufreq_lock);
-       list_for_each_entry(cpufreq_device, &cooling_cpufreq_list, node) {
-               if (cpufreq_device && cpufreq_device->cool_dev == cdev) {
-                       *state = cpufreq_device->cpufreq_state;
-                       ret = 0;
-                       break;
-               }
-       }
-       mutex_unlock(&cooling_cpufreq_lock);
-
-       return ret;
+       *state = cpufreq_device->cpufreq_state;
+       return 0;
 }
 
 /**
@@ -310,22 +291,9 @@ static int cpufreq_get_cur_state(struct thermal_cooling_device *cdev,
 static int cpufreq_set_cur_state(struct thermal_cooling_device *cdev,
                                 unsigned long state)
 {
-       int ret = -EINVAL;
-       struct cpufreq_cooling_device *cpufreq_device;
+       struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
 
-       mutex_lock(&cooling_cpufreq_lock);
-       list_for_each_entry(cpufreq_device, &cooling_cpufreq_list, node) {
-               if (cpufreq_device && cpufreq_device->cool_dev == cdev) {
-                       ret = 0;
-                       break;
-               }
-       }
-       if (!ret)
-               ret = cpufreq_apply_cooling(cpufreq_device, state);
-
-       mutex_unlock(&cooling_cpufreq_lock);
-
-       return ret;
+       return cpufreq_apply_cooling(cpufreq_device, state);
 }
 
 /* Bind cpufreq callbacks to thermal cooling device ops */
@@ -349,14 +317,11 @@ struct thermal_cooling_device *cpufreq_cooling_register(
 {
        struct thermal_cooling_device *cool_dev;
        struct cpufreq_cooling_device *cpufreq_dev = NULL;
-       unsigned int cpufreq_dev_count = 0, min = 0, max = 0;
+       unsigned int min = 0, max = 0;
        char dev_name[THERMAL_NAME_LENGTH];
        int ret = 0, i;
        struct cpufreq_policy policy;
 
-       list_for_each_entry(cpufreq_dev, &cooling_cpufreq_list, node)
-               cpufreq_dev_count++;
-
        /*Verify that all the clip cpus have same freq_min, freq_max limit*/
        for_each_cpu(i, clip_cpus) {
                /*continue if cpufreq policy not found and not return error*/
@@ -369,7 +334,7 @@ struct thermal_cooling_device *cpufreq_cooling_register(
                        if (min != policy.cpuinfo.min_freq ||
                                max != policy.cpuinfo.max_freq)
                                return ERR_PTR(-EINVAL);
-}
+               }
        }
        cpufreq_dev = kzalloc(sizeof(struct cpufreq_cooling_device),
                        GFP_KERNEL);
@@ -378,9 +343,6 @@ struct thermal_cooling_device *cpufreq_cooling_register(
 
        cpumask_copy(&cpufreq_dev->allowed_cpus, clip_cpus);
 
-       if (cpufreq_dev_count == 0)
-               mutex_init(&cooling_cpufreq_lock);
-
        ret = get_idr(&cpufreq_idr, &cpufreq_dev->id);
        if (ret) {
                kfree(cpufreq_dev);
@@ -399,12 +361,12 @@ struct thermal_cooling_device *cpufreq_cooling_register(
        cpufreq_dev->cool_dev = cool_dev;
        cpufreq_dev->cpufreq_state = 0;
        mutex_lock(&cooling_cpufreq_lock);
-       list_add_tail(&cpufreq_dev->node, &cooling_cpufreq_list);
 
        /* Register the notifier for first cpufreq cooling device */
        if (cpufreq_dev_count == 0)
                cpufreq_register_notifier(&thermal_cpufreq_notifier_block,
                                                CPUFREQ_POLICY_NOTIFIER);
+       cpufreq_dev_count++;
 
        mutex_unlock(&cooling_cpufreq_lock);
        return cool_dev;
@@ -417,33 +379,20 @@ EXPORT_SYMBOL(cpufreq_cooling_register);
  */
 void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev)
 {
-       struct cpufreq_cooling_device *cpufreq_dev = NULL;
-       unsigned int cpufreq_dev_count = 0;
+       struct cpufreq_cooling_device *cpufreq_dev = cdev->devdata;
 
        mutex_lock(&cooling_cpufreq_lock);
-       list_for_each_entry(cpufreq_dev, &cooling_cpufreq_list, node) {
-               if (cpufreq_dev && cpufreq_dev->cool_dev == cdev)
-                       break;
-               cpufreq_dev_count++;
-       }
-
-       if (!cpufreq_dev || cpufreq_dev->cool_dev != cdev) {
-               mutex_unlock(&cooling_cpufreq_lock);
-               return;
-       }
-
-       list_del(&cpufreq_dev->node);
+       cpufreq_dev_count--;
 
        /* Unregister the notifier for the last cpufreq cooling device */
-       if (cpufreq_dev_count == 1) {
+       if (cpufreq_dev_count == 0) {
                cpufreq_unregister_notifier(&thermal_cpufreq_notifier_block,
                                        CPUFREQ_POLICY_NOTIFIER);
        }
        mutex_unlock(&cooling_cpufreq_lock);
+
        thermal_cooling_device_unregister(cpufreq_dev->cool_dev);
        release_idr(&cpufreq_idr, cpufreq_dev->id);
-       if (cpufreq_dev_count == 1)
-               mutex_destroy(&cooling_cpufreq_lock);
        kfree(cpufreq_dev);
 }
 EXPORT_SYMBOL(cpufreq_cooling_unregister);
diff --git a/drivers/thermal/fair_share.c b/drivers/thermal/fair_share.c
new file mode 100644 (file)
index 0000000..792479f
--- /dev/null
@@ -0,0 +1,133 @@
+/*
+ *  fair_share.c - A simple weight based Thermal governor
+ *
+ *  Copyright (C) 2012 Intel Corp
+ *  Copyright (C) 2012 Durgadoss R <durgadoss.r@intel.com>
+ *
+ *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that 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.,
+ *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/thermal.h>
+
+#include "thermal_core.h"
+
+/**
+ * get_trip_level: - obtains the current trip level for a zone
+ * @tz:                thermal zone device
+ */
+static int get_trip_level(struct thermal_zone_device *tz)
+{
+       int count = 0;
+       unsigned long trip_temp;
+
+       if (tz->trips == 0 || !tz->ops->get_trip_temp)
+               return 0;
+
+       for (count = 0; count < tz->trips; count++) {
+               tz->ops->get_trip_temp(tz, count, &trip_temp);
+               if (tz->temperature < trip_temp)
+                       break;
+       }
+       return count;
+}
+
+static long get_target_state(struct thermal_zone_device *tz,
+               struct thermal_cooling_device *cdev, int weight, int level)
+{
+       unsigned long max_state;
+
+       cdev->ops->get_max_state(cdev, &max_state);
+
+       return (long)(weight * level * max_state) / (100 * tz->trips);
+}
+
+/**
+ * fair_share_throttle - throttles devices asscciated with the given zone
+ * @tz - thermal_zone_device
+ *
+ * Throttling Logic: This uses three parameters to calculate the new
+ * throttle state of the cooling devices associated with the given zone.
+ *
+ * Parameters used for Throttling:
+ * P1. max_state: Maximum throttle state exposed by the cooling device.
+ * P2. weight[i]/100:
+ *     How 'effective' the 'i'th device is, in cooling the given zone.
+ * P3. cur_trip_level/max_no_of_trips:
+ *     This describes the extent to which the devices should be throttled.
+ *     We do not want to throttle too much when we trip a lower temperature,
+ *     whereas the throttling is at full swing if we trip critical levels.
+ *     (Heavily assumes the trip points are in ascending order)
+ * new_state of cooling device = P3 * P2 * P1
+ */
+static int fair_share_throttle(struct thermal_zone_device *tz, int trip)
+{
+       const struct thermal_zone_params *tzp;
+       struct thermal_cooling_device *cdev;
+       struct thermal_instance *instance;
+       int i;
+       int cur_trip_level = get_trip_level(tz);
+
+       if (!tz->tzp || !tz->tzp->tbp)
+               return -EINVAL;
+
+       tzp = tz->tzp;
+
+       for (i = 0; i < tzp->num_tbps; i++) {
+               if (!tzp->tbp[i].cdev)
+                       continue;
+
+               cdev = tzp->tbp[i].cdev;
+               instance = get_thermal_instance(tz, cdev, trip);
+               if (!instance)
+                       continue;
+
+               instance->target = get_target_state(tz, cdev,
+                                       tzp->tbp[i].weight, cur_trip_level);
+
+               instance->cdev->updated = false;
+               thermal_cdev_update(cdev);
+       }
+       return 0;
+}
+
+static struct thermal_governor thermal_gov_fair_share = {
+       .name           = "fair_share",
+       .throttle       = fair_share_throttle,
+       .owner          = THIS_MODULE,
+};
+
+static int __init thermal_gov_fair_share_init(void)
+{
+       return thermal_register_governor(&thermal_gov_fair_share);
+}
+
+static void __exit thermal_gov_fair_share_exit(void)
+{
+       thermal_unregister_governor(&thermal_gov_fair_share);
+}
+
+/* This should load after thermal framework */
+fs_initcall(thermal_gov_fair_share_init);
+module_exit(thermal_gov_fair_share_exit);
+
+MODULE_AUTHOR("Durgadoss R");
+MODULE_DESCRIPTION("A simple weight based thermal throttling governor");
+MODULE_LICENSE("GPL");
index b55840a..a2aa7c6 100644 (file)
@@ -148,7 +148,7 @@ static int spear_thermal_probe(struct platform_device *pdev)
        writel_relaxed(stdev->flags, stdev->thermal_base);
 
        spear_thermal = thermal_zone_device_register("spear_thermal", 0, 0,
-                               stdev, &ops, 0, 0);
+                               stdev, &ops, NULL, 0, 0);
        if (IS_ERR(spear_thermal)) {
                dev_err(&pdev->dev, "thermal zone device is NULL\n");
                ret = PTR_ERR(spear_thermal);
diff --git a/drivers/thermal/step_wise.c b/drivers/thermal/step_wise.c
new file mode 100644 (file)
index 0000000..1242cff
--- /dev/null
@@ -0,0 +1,194 @@
+/*
+ *  step_wise.c - A step-by-step Thermal throttling governor
+ *
+ *  Copyright (C) 2012 Intel Corp
+ *  Copyright (C) 2012 Durgadoss R <durgadoss.r@intel.com>
+ *
+ *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that 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.,
+ *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/thermal.h>
+
+#include "thermal_core.h"
+
+/*
+ * If the temperature is higher than a trip point,
+ *    a. if the trend is THERMAL_TREND_RAISING, use higher cooling
+ *       state for this trip point
+ *    b. if the trend is THERMAL_TREND_DROPPING, use lower cooling
+ *       state for this trip point
+ */
+static unsigned long get_target_state(struct thermal_instance *instance,
+                                       enum thermal_trend trend)
+{
+       struct thermal_cooling_device *cdev = instance->cdev;
+       unsigned long cur_state;
+
+       cdev->ops->get_cur_state(cdev, &cur_state);
+
+       if (trend == THERMAL_TREND_RAISING) {
+               cur_state = cur_state < instance->upper ?
+                           (cur_state + 1) : instance->upper;
+       } else if (trend == THERMAL_TREND_DROPPING) {
+               cur_state = cur_state > instance->lower ?
+                           (cur_state - 1) : instance->lower;
+       }
+
+       return cur_state;
+}
+
+static void update_passive_instance(struct thermal_zone_device *tz,
+                               enum thermal_trip_type type, int value)
+{
+       /*
+        * If value is +1, activate a passive instance.
+        * If value is -1, deactivate a passive instance.
+        */
+       if (type == THERMAL_TRIP_PASSIVE || type == THERMAL_TRIPS_NONE)
+               tz->passive += value;
+}
+
+static void update_instance_for_throttle(struct thermal_zone_device *tz,
+                               int trip, enum thermal_trip_type trip_type,
+                               enum thermal_trend trend)
+{
+       struct thermal_instance *instance;
+
+       list_for_each_entry(instance, &tz->thermal_instances, tz_node) {
+               if (instance->trip != trip)
+                       continue;
+
+               instance->target = get_target_state(instance, trend);
+
+               /* Activate a passive thermal instance */
+               if (instance->target == THERMAL_NO_TARGET)
+                       update_passive_instance(tz, trip_type, 1);
+
+               instance->cdev->updated = false; /* cdev needs update */
+       }
+}
+
+static void update_instance_for_dethrottle(struct thermal_zone_device *tz,
+                               int trip, enum thermal_trip_type trip_type)
+{
+       struct thermal_instance *instance;
+       struct thermal_cooling_device *cdev;
+       unsigned long cur_state;
+
+       list_for_each_entry(instance, &tz->thermal_instances, tz_node) {
+               if (instance->trip != trip ||
+                       instance->target == THERMAL_NO_TARGET)
+                       continue;
+
+               cdev = instance->cdev;
+               cdev->ops->get_cur_state(cdev, &cur_state);
+
+               instance->target = cur_state > instance->lower ?
+                           (cur_state - 1) : THERMAL_NO_TARGET;
+
+               /* Deactivate a passive thermal instance */
+               if (instance->target == THERMAL_NO_TARGET)
+                       update_passive_instance(tz, trip_type, -1);
+
+               cdev->updated = false; /* cdev needs update */
+       }
+}
+
+static void thermal_zone_trip_update(struct thermal_zone_device *tz, int trip)
+{
+       long trip_temp;
+       enum thermal_trip_type trip_type;
+       enum thermal_trend trend;
+
+       if (trip == THERMAL_TRIPS_NONE) {
+               trip_temp = tz->forced_passive;
+               trip_type = THERMAL_TRIPS_NONE;
+       } else {
+               tz->ops->get_trip_temp(tz, trip, &trip_temp);
+               tz->ops->get_trip_type(tz, trip, &trip_type);
+       }
+
+       trend = get_tz_trend(tz, trip);
+
+       mutex_lock(&tz->lock);
+
+       if (tz->temperature >= trip_temp)
+               update_instance_for_throttle(tz, trip, trip_type, trend);
+       else
+               update_instance_for_dethrottle(tz, trip, trip_type);
+
+       mutex_unlock(&tz->lock);
+}
+
+/**
+ * step_wise_throttle - throttles devices asscciated with the given zone
+ * @tz - thermal_zone_device
+ * @trip - the trip point
+ * @trip_type - type of the trip point
+ *
+ * Throttling Logic: This uses the trend of the thermal zone to throttle.
+ * If the thermal zone is 'heating up' this throttles all the cooling
+ * devices associated with the zone and its particular trip point, by one
+ * step. If the zone is 'cooling down' it brings back the performance of
+ * the devices by one step.
+ */
+static int step_wise_throttle(struct thermal_zone_device *tz, int trip)
+{
+       struct thermal_instance *instance;
+
+       thermal_zone_trip_update(tz, trip);
+
+       if (tz->forced_passive)
+               thermal_zone_trip_update(tz, THERMAL_TRIPS_NONE);
+
+       mutex_lock(&tz->lock);
+
+       list_for_each_entry(instance, &tz->thermal_instances, tz_node)
+               thermal_cdev_update(instance->cdev);
+
+       mutex_unlock(&tz->lock);
+
+       return 0;
+}
+
+static struct thermal_governor thermal_gov_step_wise = {
+       .name           = DEFAULT_THERMAL_GOVERNOR,
+       .throttle       = step_wise_throttle,
+       .owner          = THIS_MODULE,
+};
+
+static int __init thermal_gov_step_wise_init(void)
+{
+       return thermal_register_governor(&thermal_gov_step_wise);
+}
+
+static void __exit thermal_gov_step_wise_exit(void)
+{
+       thermal_unregister_governor(&thermal_gov_step_wise);
+}
+
+/* This should load after thermal framework */
+fs_initcall(thermal_gov_step_wise_init);
+module_exit(thermal_gov_step_wise_exit);
+
+MODULE_AUTHOR("Durgadoss R");
+MODULE_DESCRIPTION("A step-by-step thermal throttling governor");
+MODULE_LICENSE("GPL");
diff --git a/drivers/thermal/thermal_core.h b/drivers/thermal/thermal_core.h
new file mode 100644 (file)
index 0000000..0d3205a
--- /dev/null
@@ -0,0 +1,53 @@
+/*
+ *  thermal_core.h
+ *
+ *  Copyright (C) 2012  Intel Corp
+ *  Author: Durgadoss R <durgadoss.r@intel.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that 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.,
+ *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+#ifndef __THERMAL_CORE_H__
+#define __THERMAL_CORE_H__
+
+#include <linux/device.h>
+#include <linux/thermal.h>
+
+/* Initial state of a cooling device during binding */
+#define THERMAL_NO_TARGET -1UL
+
+/*
+ * This structure is used to describe the behavior of
+ * a certain cooling device on a certain trip point
+ * in a certain thermal zone
+ */
+struct thermal_instance {
+       int id;
+       char name[THERMAL_NAME_LENGTH];
+       struct thermal_zone_device *tz;
+       struct thermal_cooling_device *cdev;
+       int trip;
+       unsigned long upper;    /* Highest cooling state for this trip point */
+       unsigned long lower;    /* Lowest cooling state for this trip point */
+       unsigned long target;   /* expected cooling state */
+       char attr_name[THERMAL_NAME_LENGTH];
+       struct device_attribute attr;
+       struct list_head tz_node; /* node in tz->thermal_instances */
+       struct list_head cdev_node; /* node in cdev->thermal_instances */
+};
+
+#endif /* __THERMAL_CORE_H__ */
index da2c104..506cbf2 100644 (file)
 #include <net/netlink.h>
 #include <net/genetlink.h>
 
+#include "thermal_core.h"
+
 MODULE_AUTHOR("Zhang Rui");
 MODULE_DESCRIPTION("Generic thermal management sysfs support");
 MODULE_LICENSE("GPL");
 
-#define THERMAL_NO_TARGET -1UL
-/*
- * This structure is used to describe the behavior of
- * a certain cooling device on a certain trip point
- * in a certain thermal zone
- */
-struct thermal_instance {
-       int id;
-       char name[THERMAL_NAME_LENGTH];
-       struct thermal_zone_device *tz;
-       struct thermal_cooling_device *cdev;
-       int trip;
-       unsigned long upper;    /* Highest cooling state for this trip point */
-       unsigned long lower;    /* Lowest cooling state for this trip point */
-       unsigned long target;   /* expected cooling state */
-       char attr_name[THERMAL_NAME_LENGTH];
-       struct device_attribute attr;
-       struct list_head tz_node; /* node in tz->thermal_instances */
-       struct list_head cdev_node; /* node in cdev->thermal_instances */
-};
-
 static DEFINE_IDR(thermal_tz_idr);
 static DEFINE_IDR(thermal_cdev_idr);
 static DEFINE_MUTEX(thermal_idr_lock);
 
 static LIST_HEAD(thermal_tz_list);
 static LIST_HEAD(thermal_cdev_list);
+static LIST_HEAD(thermal_governor_list);
+
 static DEFINE_MUTEX(thermal_list_lock);
+static DEFINE_MUTEX(thermal_governor_lock);
+
+static struct thermal_governor *__find_governor(const char *name)
+{
+       struct thermal_governor *pos;
+
+       list_for_each_entry(pos, &thermal_governor_list, governor_list)
+               if (!strnicmp(name, pos->name, THERMAL_NAME_LENGTH))
+                       return pos;
+
+       return NULL;
+}
+
+int thermal_register_governor(struct thermal_governor *governor)
+{
+       int err;
+       const char *name;
+       struct thermal_zone_device *pos;
+
+       if (!governor)
+               return -EINVAL;
+
+       mutex_lock(&thermal_governor_lock);
+
+       err = -EBUSY;
+       if (__find_governor(governor->name) == NULL) {
+               err = 0;
+               list_add(&governor->governor_list, &thermal_governor_list);
+       }
+
+       mutex_lock(&thermal_list_lock);
+
+       list_for_each_entry(pos, &thermal_tz_list, node) {
+               if (pos->governor)
+                       continue;
+               if (pos->tzp)
+                       name = pos->tzp->governor_name;
+               else
+                       name = DEFAULT_THERMAL_GOVERNOR;
+               if (!strnicmp(name, governor->name, THERMAL_NAME_LENGTH))
+                       pos->governor = governor;
+       }
+
+       mutex_unlock(&thermal_list_lock);
+       mutex_unlock(&thermal_governor_lock);
+
+       return err;
+}
+EXPORT_SYMBOL_GPL(thermal_register_governor);
+
+void thermal_unregister_governor(struct thermal_governor *governor)
+{
+       struct thermal_zone_device *pos;
+
+       if (!governor)
+               return;
+
+       mutex_lock(&thermal_governor_lock);
+
+       if (__find_governor(governor->name) == NULL)
+               goto exit;
+
+       mutex_lock(&thermal_list_lock);
+
+       list_for_each_entry(pos, &thermal_tz_list, node) {
+               if (!strnicmp(pos->governor->name, governor->name,
+                                               THERMAL_NAME_LENGTH))
+                       pos->governor = NULL;
+       }
+
+       mutex_unlock(&thermal_list_lock);
+       list_del(&governor->governor_list);
+exit:
+       mutex_unlock(&thermal_governor_lock);
+       return;
+}
+EXPORT_SYMBOL_GPL(thermal_unregister_governor);
 
 static int get_idr(struct idr *idr, struct mutex *lock, int *id)
 {
@@ -101,6 +161,264 @@ static void release_idr(struct idr *idr, struct mutex *lock, int id)
                mutex_unlock(lock);
 }
 
+int get_tz_trend(struct thermal_zone_device *tz, int trip)
+{
+       enum thermal_trend trend;
+
+       if (!tz->ops->get_trend || tz->ops->get_trend(tz, trip, &trend)) {
+               if (tz->temperature > tz->last_temperature)
+                       trend = THERMAL_TREND_RAISING;
+               else if (tz->temperature < tz->last_temperature)
+                       trend = THERMAL_TREND_DROPPING;
+               else
+                       trend = THERMAL_TREND_STABLE;
+       }
+
+       return trend;
+}
+EXPORT_SYMBOL(get_tz_trend);
+
+struct thermal_instance *get_thermal_instance(struct thermal_zone_device *tz,
+                       struct thermal_cooling_device *cdev, int trip)
+{
+       struct thermal_instance *pos = NULL;
+       struct thermal_instance *target_instance = NULL;
+
+       mutex_lock(&tz->lock);
+       mutex_lock(&cdev->lock);
+
+       list_for_each_entry(pos, &tz->thermal_instances, tz_node) {
+               if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
+                       target_instance = pos;
+                       break;
+               }
+       }
+
+       mutex_unlock(&cdev->lock);
+       mutex_unlock(&tz->lock);
+
+       return target_instance;
+}
+EXPORT_SYMBOL(get_thermal_instance);
+
+static void print_bind_err_msg(struct thermal_zone_device *tz,
+                       struct thermal_cooling_device *cdev, int ret)
+{
+       dev_err(&tz->device, "binding zone %s with cdev %s failed:%d\n",
+                               tz->type, cdev->type, ret);
+}
+
+static void __bind(struct thermal_zone_device *tz, int mask,
+                       struct thermal_cooling_device *cdev)
+{
+       int i, ret;
+
+       for (i = 0; i < tz->trips; i++) {
+               if (mask & (1 << i)) {
+                       ret = thermal_zone_bind_cooling_device(tz, i, cdev,
+                                       THERMAL_NO_LIMIT, THERMAL_NO_LIMIT);
+                       if (ret)
+                               print_bind_err_msg(tz, cdev, ret);
+               }
+       }
+}
+
+static void __unbind(struct thermal_zone_device *tz, int mask,
+                       struct thermal_cooling_device *cdev)
+{
+       int i;
+
+       for (i = 0; i < tz->trips; i++)
+               if (mask & (1 << i))
+                       thermal_zone_unbind_cooling_device(tz, i, cdev);
+}
+
+static void bind_cdev(struct thermal_cooling_device *cdev)
+{
+       int i, ret;
+       const struct thermal_zone_params *tzp;
+       struct thermal_zone_device *pos = NULL;
+
+       mutex_lock(&thermal_list_lock);
+
+       list_for_each_entry(pos, &thermal_tz_list, node) {
+               if (!pos->tzp && !pos->ops->bind)
+                       continue;
+
+               if (!pos->tzp && pos->ops->bind) {
+                       ret = pos->ops->bind(pos, cdev);
+                       if (ret)
+                               print_bind_err_msg(pos, cdev, ret);
+               }
+
+               tzp = pos->tzp;
+               if (!tzp || !tzp->tbp)
+                       continue;
+
+               for (i = 0; i < tzp->num_tbps; i++) {
+                       if (tzp->tbp[i].cdev || !tzp->tbp[i].match)
+                               continue;
+                       if (tzp->tbp[i].match(pos, cdev))
+                               continue;
+                       tzp->tbp[i].cdev = cdev;
+                       __bind(pos, tzp->tbp[i].trip_mask, cdev);
+               }
+       }
+
+       mutex_unlock(&thermal_list_lock);
+}
+
+static void bind_tz(struct thermal_zone_device *tz)
+{
+       int i, ret;
+       struct thermal_cooling_device *pos = NULL;
+       const struct thermal_zone_params *tzp = tz->tzp;
+
+       if (!tzp && !tz->ops->bind)
+               return;
+
+       mutex_lock(&thermal_list_lock);
+
+       /* If there is no platform data, try to use ops->bind */
+       if (!tzp && tz->ops->bind) {
+               list_for_each_entry(pos, &thermal_cdev_list, node) {
+                       ret = tz->ops->bind(tz, pos);
+                       if (ret)
+                               print_bind_err_msg(tz, pos, ret);
+               }
+               goto exit;
+       }
+
+       if (!tzp || !tzp->tbp)
+               goto exit;
+
+       list_for_each_entry(pos, &thermal_cdev_list, node) {
+               for (i = 0; i < tzp->num_tbps; i++) {
+                       if (tzp->tbp[i].cdev || !tzp->tbp[i].match)
+                               continue;
+                       if (tzp->tbp[i].match(tz, pos))
+                               continue;
+                       tzp->tbp[i].cdev = pos;
+                       __bind(tz, tzp->tbp[i].trip_mask, pos);
+               }
+       }
+exit:
+       mutex_unlock(&thermal_list_lock);
+}
+
+static void thermal_zone_device_set_polling(struct thermal_zone_device *tz,
+                                           int delay)
+{
+       cancel_delayed_work(&(tz->poll_queue));
+
+       if (!delay)
+               return;
+
+       if (delay > 1000)
+               queue_delayed_work(system_freezable_wq, &(tz->poll_queue),
+                                     round_jiffies(msecs_to_jiffies(delay)));
+       else
+               queue_delayed_work(system_freezable_wq, &(tz->poll_queue),
+                                     msecs_to_jiffies(delay));
+}
+
+static void monitor_thermal_zone(struct thermal_zone_device *tz)
+{
+       mutex_lock(&tz->lock);
+
+       if (tz->passive)
+               thermal_zone_device_set_polling(tz, tz->passive_delay);
+       else if (tz->polling_delay)
+               thermal_zone_device_set_polling(tz, tz->polling_delay);
+       else
+               thermal_zone_device_set_polling(tz, 0);
+
+       mutex_unlock(&tz->lock);
+}
+
+static void handle_non_critical_trips(struct thermal_zone_device *tz,
+                       int trip, enum thermal_trip_type trip_type)
+{
+       tz->governor->throttle(tz, trip);
+}
+
+static void handle_critical_trips(struct thermal_zone_device *tz,
+                               int trip, enum thermal_trip_type trip_type)
+{
+       long trip_temp;
+
+       tz->ops->get_trip_temp(tz, trip, &trip_temp);
+
+       /* If we have not crossed the trip_temp, we do not care. */
+       if (tz->temperature < trip_temp)
+               return;
+
+       if (tz->ops->notify)
+               tz->ops->notify(tz, trip, trip_type);
+
+       if (trip_type == THERMAL_TRIP_CRITICAL) {
+               pr_emerg("Critical temperature reached(%d C),shutting down\n",
+                        tz->temperature / 1000);
+               orderly_poweroff(true);
+       }
+}
+
+static void handle_thermal_trip(struct thermal_zone_device *tz, int trip)
+{
+       enum thermal_trip_type type;
+
+       tz->ops->get_trip_type(tz, trip, &type);
+
+       if (type == THERMAL_TRIP_CRITICAL || type == THERMAL_TRIP_HOT)
+               handle_critical_trips(tz, trip, type);
+       else
+               handle_non_critical_trips(tz, trip, type);
+       /*
+        * Alright, we handled this trip successfully.
+        * So, start monitoring again.
+        */
+       monitor_thermal_zone(tz);
+}
+
+static void update_temperature(struct thermal_zone_device *tz)
+{
+       long temp;
+       int ret;
+
+       mutex_lock(&tz->lock);
+
+       ret = tz->ops->get_temp(tz, &temp);
+       if (ret) {
+               pr_warn("failed to read out thermal zone %d\n", tz->id);
+               goto exit;
+       }
+
+       tz->last_temperature = tz->temperature;
+       tz->temperature = temp;
+
+exit:
+       mutex_unlock(&tz->lock);
+}
+
+void thermal_zone_device_update(struct thermal_zone_device *tz)
+{
+       int count;
+
+       update_temperature(tz);
+
+       for (count = 0; count < tz->trips; count++)
+               handle_thermal_trip(tz, count);
+}
+EXPORT_SYMBOL(thermal_zone_device_update);
+
+static void thermal_zone_device_check(struct work_struct *work)
+{
+       struct thermal_zone_device *tz = container_of(work, struct
+                                                     thermal_zone_device,
+                                                     poll_queue.work);
+       thermal_zone_device_update(tz);
+}
+
 /* sys I/F for thermal zone */
 
 #define to_thermal_zone(_dev) \
@@ -354,10 +672,41 @@ passive_show(struct device *dev, struct device_attribute *attr,
        return sprintf(buf, "%d\n", tz->forced_passive);
 }
 
+static ssize_t
+policy_store(struct device *dev, struct device_attribute *attr,
+                   const char *buf, size_t count)
+{
+       int ret = -EINVAL;
+       struct thermal_zone_device *tz = to_thermal_zone(dev);
+       struct thermal_governor *gov;
+
+       mutex_lock(&thermal_governor_lock);
+
+       gov = __find_governor(buf);
+       if (!gov)
+               goto exit;
+
+       tz->governor = gov;
+       ret = count;
+
+exit:
+       mutex_unlock(&thermal_governor_lock);
+       return ret;
+}
+
+static ssize_t
+policy_show(struct device *dev, struct device_attribute *devattr, char *buf)
+{
+       struct thermal_zone_device *tz = to_thermal_zone(dev);
+
+       return sprintf(buf, "%s\n", tz->governor->name);
+}
+
 static DEVICE_ATTR(type, 0444, type_show, NULL);
 static DEVICE_ATTR(temp, 0444, temp_show, NULL);
 static DEVICE_ATTR(mode, 0644, mode_show, mode_store);
 static DEVICE_ATTR(passive, S_IRUGO | S_IWUSR, passive_show, passive_store);
+static DEVICE_ATTR(policy, S_IRUGO | S_IWUSR, policy_show, policy_store);
 
 /* sys I/F for cooling device */
 #define to_cooling_device(_dev)        \
@@ -700,30 +1049,6 @@ thermal_remove_hwmon_sysfs(struct thermal_zone_device *tz)
 }
 #endif
 
-static void thermal_zone_device_set_polling(struct thermal_zone_device *tz,
-                                           int delay)
-{
-       cancel_delayed_work(&(tz->poll_queue));
-
-       if (!delay)
-               return;
-
-       if (delay > 1000)
-               queue_delayed_work(system_freezable_wq, &(tz->poll_queue),
-                                     round_jiffies(msecs_to_jiffies(delay)));
-       else
-               queue_delayed_work(system_freezable_wq, &(tz->poll_queue),
-                                     msecs_to_jiffies(delay));
-}
-
-static void thermal_zone_device_check(struct work_struct *work)
-{
-       struct thermal_zone_device *tz = container_of(work, struct
-                                                     thermal_zone_device,
-                                                     poll_queue.work);
-       thermal_zone_device_update(tz);
-}
-
 /**
  * thermal_zone_bind_cooling_device - bind a cooling device to a thermal zone
  * @tz:                thermal zone device
@@ -898,10 +1223,9 @@ thermal_cooling_device_register(char *type, void *devdata,
                                const struct thermal_cooling_device_ops *ops)
 {
        struct thermal_cooling_device *cdev;
-       struct thermal_zone_device *pos;
        int result;
 
-       if (strlen(type) >= THERMAL_NAME_LENGTH)
+       if (type && strlen(type) >= THERMAL_NAME_LENGTH)
                return ERR_PTR(-EINVAL);
 
        if (!ops || !ops->get_max_state || !ops->get_cur_state ||
@@ -918,7 +1242,7 @@ thermal_cooling_device_register(char *type, void *devdata,
                return ERR_PTR(result);
        }
 
-       strcpy(cdev->type, type);
+       strcpy(cdev->type, type ? : "");
        mutex_init(&cdev->lock);
        INIT_LIST_HEAD(&cdev->thermal_instances);
        cdev->ops = ops;
@@ -948,20 +1272,15 @@ thermal_cooling_device_register(char *type, void *devdata,
        if (result)
                goto unregister;
 
+       /* Add 'this' new cdev to the global cdev list */
        mutex_lock(&thermal_list_lock);
        list_add(&cdev->node, &thermal_cdev_list);
-       list_for_each_entry(pos, &thermal_tz_list, node) {
-               if (!pos->ops->bind)
-                       continue;
-               result = pos->ops->bind(pos, cdev);
-               if (result)
-                       break;
-
-       }
        mutex_unlock(&thermal_list_lock);
 
-       if (!result)
-               return cdev;
+       /* Update binding information for 'this' new cdev */
+       bind_cdev(cdev);
+
+       return cdev;
 
 unregister:
        release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id);
@@ -977,10 +1296,10 @@ EXPORT_SYMBOL(thermal_cooling_device_register);
  * thermal_cooling_device_unregister() must be called when the device is no
  * longer needed.
  */
-void thermal_cooling_device_unregister(struct
-                                      thermal_cooling_device
-                                      *cdev)
+void thermal_cooling_device_unregister(struct thermal_cooling_device *cdev)
 {
+       int i;
+       const struct thermal_zone_params *tzp;
        struct thermal_zone_device *tz;
        struct thermal_cooling_device *pos = NULL;
 
@@ -997,12 +1316,28 @@ void thermal_cooling_device_unregister(struct
                return;
        }
        list_del(&cdev->node);
+
+       /* Unbind all thermal zones associated with 'this' cdev */
        list_for_each_entry(tz, &thermal_tz_list, node) {
-               if (!tz->ops->unbind)
+               if (tz->ops->unbind) {
+                       tz->ops->unbind(tz, cdev);
                        continue;
-               tz->ops->unbind(tz, cdev);
+               }
+
+               if (!tz->tzp || !tz->tzp->tbp)
+                       continue;
+
+               tzp = tz->tzp;
+               for (i = 0; i < tzp->num_tbps; i++) {
+                       if (tzp->tbp[i].cdev == cdev) {
+                               __unbind(tz, tzp->tbp[i].trip_mask, cdev);
+                               tzp->tbp[i].cdev = NULL;
+                       }
+               }
        }
+
        mutex_unlock(&thermal_list_lock);
+
        if (cdev->type[0])
                device_remove_file(&cdev->device, &dev_attr_cdev_type);
        device_remove_file(&cdev->device, &dev_attr_max_state);
@@ -1014,7 +1349,7 @@ void thermal_cooling_device_unregister(struct
 }
 EXPORT_SYMBOL(thermal_cooling_device_unregister);
 
-static void thermal_cdev_do_update(struct thermal_cooling_device *cdev)
+void thermal_cdev_update(struct thermal_cooling_device *cdev)
 {
        struct thermal_instance *instance;
        unsigned long target = 0;
@@ -1035,183 +1370,25 @@ static void thermal_cdev_do_update(struct thermal_cooling_device *cdev)
        cdev->ops->set_cur_state(cdev, target);
        cdev->updated = true;
 }
+EXPORT_SYMBOL(thermal_cdev_update);
 
-static void thermal_zone_do_update(struct thermal_zone_device *tz)
-{
-       struct thermal_instance *instance;
-
-       list_for_each_entry(instance, &tz->thermal_instances, tz_node)
-               thermal_cdev_do_update(instance->cdev);
-}
-
-/*
- * Cooling algorithm for both active and passive cooling
- *
- * 1. if the temperature is higher than a trip point,
- *    a. if the trend is THERMAL_TREND_RAISING, use higher cooling
- *       state for this trip point
- *    b. if the trend is THERMAL_TREND_DROPPING, use lower cooling
- *       state for this trip point
- *
- * 2. if the temperature is lower than a trip point, use lower
- *    cooling state for this trip point
- *
- * Note that this behaves the same as the previous passive cooling
- * algorithm.
- */
-
-static void thermal_zone_trip_update(struct thermal_zone_device *tz,
-                                    int trip, long temp)
-{
-       struct thermal_instance *instance;
-       struct thermal_cooling_device *cdev = NULL;
-       unsigned long cur_state, max_state;
-       long trip_temp;
-       enum thermal_trip_type trip_type;
-       enum thermal_trend trend;
-
-       if (trip == THERMAL_TRIPS_NONE) {
-               trip_temp = tz->forced_passive;
-               trip_type = THERMAL_TRIPS_NONE;
-       } else {
-               tz->ops->get_trip_temp(tz, trip, &trip_temp);
-               tz->ops->get_trip_type(tz, trip, &trip_type);
-       }
-
-       if (!tz->ops->get_trend || tz->ops->get_trend(tz, trip, &trend)) {
-               /*
-                * compare the current temperature and previous temperature
-                * to get the thermal trend, if no special requirement
-                */
-               if (tz->temperature > tz->last_temperature)
-                       trend = THERMAL_TREND_RAISING;
-               else if (tz->temperature < tz->last_temperature)
-                       trend = THERMAL_TREND_DROPPING;
-               else
-                       trend = THERMAL_TREND_STABLE;
-       }
-
-       if (temp >= trip_temp) {
-               list_for_each_entry(instance, &tz->thermal_instances, tz_node) {
-                       if (instance->trip != trip)
-                               continue;
-
-                       cdev = instance->cdev;
-
-                       cdev->ops->get_cur_state(cdev, &cur_state);
-                       cdev->ops->get_max_state(cdev, &max_state);
-
-                       if (trend == THERMAL_TREND_RAISING) {
-                               cur_state = cur_state < instance->upper ?
-                                           (cur_state + 1) : instance->upper;
-                       } else if (trend == THERMAL_TREND_DROPPING) {
-                               cur_state = cur_state > instance->lower ?
-                                   (cur_state - 1) : instance->lower;
-                       }
-
-                       /* activate a passive thermal instance */
-                       if ((trip_type == THERMAL_TRIP_PASSIVE ||
-                            trip_type == THERMAL_TRIPS_NONE) &&
-                            instance->target == THERMAL_NO_TARGET)
-                               tz->passive++;
-
-                       instance->target = cur_state;
-                       cdev->updated = false; /* cooling device needs update */
-               }
-       } else {        /* below trip */
-               list_for_each_entry(instance, &tz->thermal_instances, tz_node) {
-                       if (instance->trip != trip)
-                               continue;
-
-                       /* Do not use the inactive thermal instance */
-                       if (instance->target == THERMAL_NO_TARGET)
-                               continue;
-                       cdev = instance->cdev;
-                       cdev->ops->get_cur_state(cdev, &cur_state);
-
-                       cur_state = cur_state > instance->lower ?
-                                   (cur_state - 1) : THERMAL_NO_TARGET;
-
-                       /* deactivate a passive thermal instance */
-                       if ((trip_type == THERMAL_TRIP_PASSIVE ||
-                            trip_type == THERMAL_TRIPS_NONE) &&
-                            cur_state == THERMAL_NO_TARGET)
-                               tz->passive--;
-                       instance->target = cur_state;
-                       cdev->updated = false; /* cooling device needs update */
-               }
-       }
-
-       return;
-}
 /**
- * thermal_zone_device_update - force an update of a thermal zone's state
- * @ttz:       the thermal zone to update
+ * notify_thermal_framework - Sensor drivers use this API to notify framework
+ * @tz:                thermal zone device
+ * @trip:      indicates which trip point has been crossed
+ *
+ * This function handles the trip events from sensor drivers. It starts
+ * throttling the cooling devices according to the policy configured.
+ * For CRITICAL and HOT trip points, this notifies the respective drivers,
+ * and does actual throttling for other trip points i.e ACTIVE and PASSIVE.
+ * The throttling policy is based on the configured platform data; if no
+ * platform data is provided, this uses the step_wise throttling policy.
  */
-
-void thermal_zone_device_update(struct thermal_zone_device *tz)
+void notify_thermal_framework(struct thermal_zone_device *tz, int trip)
 {
-       int count, ret = 0;
-       long temp, trip_temp;
-       enum thermal_trip_type trip_type;
-
-       mutex_lock(&tz->lock);
-
-       if (tz->ops->get_temp(tz, &temp)) {
-               /* get_temp failed - retry it later */
-               pr_warn("failed to read out thermal zone %d\n", tz->id);
-               goto leave;
-       }
-
-       tz->last_temperature = tz->temperature;
-       tz->temperature = temp;
-
-       for (count = 0; count < tz->trips; count++) {
-               tz->ops->get_trip_type(tz, count, &trip_type);
-               tz->ops->get_trip_temp(tz, count, &trip_temp);
-
-               switch (trip_type) {
-               case THERMAL_TRIP_CRITICAL:
-                       if (temp >= trip_temp) {
-                               if (tz->ops->notify)
-                                       ret = tz->ops->notify(tz, count,
-                                                             trip_type);
-                               if (!ret) {
-                                       pr_emerg("Critical temperature reached (%ld C), shutting down\n",
-                                                temp/1000);
-                                       orderly_poweroff(true);
-                               }
-                       }
-                       break;
-               case THERMAL_TRIP_HOT:
-                       if (temp >= trip_temp)
-                               if (tz->ops->notify)
-                                       tz->ops->notify(tz, count, trip_type);
-                       break;
-               case THERMAL_TRIP_ACTIVE:
-                       thermal_zone_trip_update(tz, count, temp);
-                       break;
-               case THERMAL_TRIP_PASSIVE:
-                       if (temp >= trip_temp || tz->passive)
-                               thermal_zone_trip_update(tz, count, temp);
-                       break;
-               }
-       }
-
-       if (tz->forced_passive)
-               thermal_zone_trip_update(tz, THERMAL_TRIPS_NONE, temp);
-       thermal_zone_do_update(tz);
-
-leave:
-       if (tz->passive)
-               thermal_zone_device_set_polling(tz, tz->passive_delay);
-       else if (tz->polling_delay)
-               thermal_zone_device_set_polling(tz, tz->polling_delay);
-       else
-               thermal_zone_device_set_polling(tz, 0);
-       mutex_unlock(&tz->lock);
+       handle_thermal_trip(tz, trip);
 }
-EXPORT_SYMBOL(thermal_zone_device_update);
+EXPORT_SYMBOL(notify_thermal_framework);
 
 struct thermal_zone_device *thermal_zone_device_find(void *data,
        int (*match)(struct thermal_zone_device *, void *))
@@ -1340,6 +1517,7 @@ static void remove_trip_attrs(struct thermal_zone_device *tz)
  * @mask:      a bit string indicating the writeablility of trip points
  * @devdata:   private device data
  * @ops:       standard thermal zone device callbacks
+ * @tzp:       thermal zone platform parameters
  * @passive_delay: number of milliseconds to wait between polls when
  *                performing passive cooling
  * @polling_delay: number of milliseconds to wait between polls when checking
@@ -1352,16 +1530,16 @@ static void remove_trip_attrs(struct thermal_zone_device *tz)
 struct thermal_zone_device *thermal_zone_device_register(const char *type,
        int trips, int mask, void *devdata,
        const struct thermal_zone_device_ops *ops,
+       const struct thermal_zone_params *tzp,
        int passive_delay, int polling_delay)
 {
        struct thermal_zone_device *tz;
-       struct thermal_cooling_device *pos;
        enum thermal_trip_type trip_type;
        int result;
        int count;
        int passive = 0;
 
-       if (strlen(type) >= THERMAL_NAME_LENGTH)
+       if (type && strlen(type) >= THERMAL_NAME_LENGTH)
                return ERR_PTR(-EINVAL);
 
        if (trips > THERMAL_MAX_TRIPS || trips < 0 || mask >> trips)
@@ -1383,8 +1561,9 @@ struct thermal_zone_device *thermal_zone_device_register(const char *type,
                return ERR_PTR(result);
        }
 
-       strcpy(tz->type, type);
+       strcpy(tz->type, type ? : "");
        tz->ops = ops;
+       tz->tzp = tzp;
        tz->device.class = &thermal_class;
        tz->devdata = devdata;
        tz->trips = trips;
@@ -1426,27 +1605,38 @@ struct thermal_zone_device *thermal_zone_device_register(const char *type,
                        passive = 1;
        }
 
-       if (!passive)
-               result = device_create_file(&tz->device,
-                                           &dev_attr_passive);
+       if (!passive) {
+               result = device_create_file(&tz->device, &dev_attr_passive);
+               if (result)
+                       goto unregister;
+       }
 
+       /* Create policy attribute */
+       result = device_create_file(&tz->device, &dev_attr_policy);
        if (result)
                goto unregister;
 
+       /* Update 'this' zone's governor information */
+       mutex_lock(&thermal_governor_lock);
+
+       if (tz->tzp)
+               tz->governor = __find_governor(tz->tzp->governor_name);
+       else
+               tz->governor = __find_governor(DEFAULT_THERMAL_GOVERNOR);
+
+       mutex_unlock(&thermal_governor_lock);
+
        result = thermal_add_hwmon_sysfs(tz);
        if (result)
                goto unregister;
 
        mutex_lock(&thermal_list_lock);
        list_add_tail(&tz->node, &thermal_tz_list);
-       if (ops->bind)
-               list_for_each_entry(pos, &thermal_cdev_list, node) {
-               result = ops->bind(tz, pos);
-               if (result)
-                       break;
-               }
        mutex_unlock(&thermal_list_lock);
 
+       /* Bind cooling devices for this zone */
+       bind_tz(tz);
+
        INIT_DELAYED_WORK(&(tz->poll_queue), thermal_zone_device_check);
 
        thermal_zone_device_update(tz);
@@ -1467,12 +1657,16 @@ EXPORT_SYMBOL(thermal_zone_device_register);
  */
 void thermal_zone_device_unregister(struct thermal_zone_device *tz)
 {
+       int i;
+       const struct thermal_zone_params *tzp;
        struct thermal_cooling_device *cdev;
        struct thermal_zone_device *pos = NULL;
 
        if (!tz)
                return;
 
+       tzp = tz->tzp;
+
        mutex_lock(&thermal_list_lock);
        list_for_each_entry(pos, &thermal_tz_list, node)
            if (pos == tz)
@@ -1483,9 +1677,25 @@ void thermal_zone_device_unregister(struct thermal_zone_device *tz)
                return;
        }
        list_del(&tz->node);
-       if (tz->ops->unbind)
-               list_for_each_entry(cdev, &thermal_cdev_list, node)
-                   tz->ops->unbind(tz, cdev);
+
+       /* Unbind all cdevs associated with 'this' thermal zone */
+       list_for_each_entry(cdev, &thermal_cdev_list, node) {
+               if (tz->ops->unbind) {
+                       tz->ops->unbind(tz, cdev);
+                       continue;
+               }
+
+               if (!tzp || !tzp->tbp)
+                       break;
+
+               for (i = 0; i < tzp->num_tbps; i++) {
+                       if (tzp->tbp[i].cdev == cdev) {
+                               __unbind(tz, tzp->tbp[i].trip_mask, cdev);
+                               tzp->tbp[i].cdev = NULL;
+                       }
+               }
+       }
+
        mutex_unlock(&thermal_list_lock);
 
        thermal_zone_device_set_polling(tz, 0);
@@ -1495,7 +1705,9 @@ void thermal_zone_device_unregister(struct thermal_zone_device *tz)
        device_remove_file(&tz->device, &dev_attr_temp);
        if (tz->ops->get_mode)
                device_remove_file(&tz->device, &dev_attr_mode);
+       device_remove_file(&tz->device, &dev_attr_policy);
        remove_trip_attrs(tz);
+       tz->governor = NULL;
 
        thermal_remove_hwmon_sysfs(tz);
        release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);
diff --git a/drivers/thermal/user_space.c b/drivers/thermal/user_space.c
new file mode 100644 (file)
index 0000000..6bbb380
--- /dev/null
@@ -0,0 +1,68 @@
+/*
+ *  user_space.c - A simple user space Thermal events notifier
+ *
+ *  Copyright (C) 2012 Intel Corp
+ *  Copyright (C) 2012 Durgadoss R <durgadoss.r@intel.com>
+ *
+ *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that 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.,
+ *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/thermal.h>
+
+#include "thermal_core.h"
+
+/**
+ * notify_user_space - Notifies user space about thermal events
+ * @tz - thermal_zone_device
+ *
+ * This function notifies the user space through UEvents.
+ */
+static int notify_user_space(struct thermal_zone_device *tz, int trip)
+{
+       mutex_lock(&tz->lock);
+       kobject_uevent(&tz->device.kobj, KOBJ_CHANGE);
+       mutex_unlock(&tz->lock);
+       return 0;
+}
+
+static struct thermal_governor thermal_gov_user_space = {
+       .name           = "user_space",
+       .throttle       = notify_user_space,
+       .owner          = THIS_MODULE,
+};
+
+static int __init thermal_gov_user_space_init(void)
+{
+       return thermal_register_governor(&thermal_gov_user_space);
+}
+
+static void __exit thermal_gov_user_space_exit(void)
+{
+       thermal_unregister_governor(&thermal_gov_user_space);
+}
+
+/* This should load after thermal framework */
+fs_initcall(thermal_gov_user_space_init);
+module_exit(thermal_gov_user_space_exit);
+
+MODULE_AUTHOR("Durgadoss R");
+MODULE_DESCRIPTION("A user space Thermal notifier");
+MODULE_LICENSE("GPL");
index 5b176ac..b5d675f 100644 (file)
 #include <linux/device.h>
 #include <linux/workqueue.h>
 
+#define THERMAL_TRIPS_NONE     -1
+#define THERMAL_MAX_TRIPS      12
+#define THERMAL_NAME_LENGTH    20
+
+/* No upper/lower limit requirement */
+#define THERMAL_NO_LIMIT       -1UL
+
+/* Unit conversion macros */
+#define KELVIN_TO_CELSIUS(t)   (long)(((long)t-2732 >= 0) ?    \
+                               ((long)t-2732+5)/10 : ((long)t-2732-5)/10)
+#define CELSIUS_TO_KELVIN(t)   ((t)*10+2732)
+
+/* Adding event notification support elements */
+#define THERMAL_GENL_FAMILY_NAME                "thermal_event"
+#define THERMAL_GENL_VERSION                    0x01
+#define THERMAL_GENL_MCAST_GROUP_NAME           "thermal_mc_group"
+
+/* Default Thermal Governor: Does Linear Throttling */
+#define DEFAULT_THERMAL_GOVERNOR       "step_wise"
+
 struct thermal_zone_device;
 struct thermal_cooling_device;
 
@@ -50,6 +70,30 @@ enum thermal_trend {
        THERMAL_TREND_DROPPING, /* temperature is dropping */
 };
 
+/* Events supported by Thermal Netlink */
+enum events {
+       THERMAL_AUX0,
+       THERMAL_AUX1,
+       THERMAL_CRITICAL,
+       THERMAL_DEV_FAULT,
+};
+
+/* attributes of thermal_genl_family */
+enum {
+       THERMAL_GENL_ATTR_UNSPEC,
+       THERMAL_GENL_ATTR_EVENT,
+       __THERMAL_GENL_ATTR_MAX,
+};
+#define THERMAL_GENL_ATTR_MAX (__THERMAL_GENL_ATTR_MAX - 1)
+
+/* commands supported by the thermal_genl_family */
+enum {
+       THERMAL_GENL_CMD_UNSPEC,
+       THERMAL_GENL_CMD_EVENT,
+       __THERMAL_GENL_CMD_MAX,
+};
+#define THERMAL_GENL_CMD_MAX (__THERMAL_GENL_CMD_MAX - 1)
+
 struct thermal_zone_device_ops {
        int (*bind) (struct thermal_zone_device *,
                     struct thermal_cooling_device *);
@@ -83,11 +127,6 @@ struct thermal_cooling_device_ops {
        int (*set_cur_state) (struct thermal_cooling_device *, unsigned long);
 };
 
-#define THERMAL_NO_LIMIT -1UL /* no upper/lower limit requirement */
-
-#define THERMAL_TRIPS_NONE -1
-#define THERMAL_MAX_TRIPS 12
-#define THERMAL_NAME_LENGTH 20
 struct thermal_cooling_device {
        int id;
        char type[THERMAL_NAME_LENGTH];
@@ -100,10 +139,6 @@ struct thermal_cooling_device {
        struct list_head node;
 };
 
-#define KELVIN_TO_CELSIUS(t)   (long)(((long)t-2732 >= 0) ?    \
-                               ((long)t-2732+5)/10 : ((long)t-2732-5)/10)
-#define CELSIUS_TO_KELVIN(t)   ((t)*10+2732)
-
 struct thermal_attr {
        struct device_attribute attr;
        char name[THERMAL_NAME_LENGTH];
@@ -125,46 +160,61 @@ struct thermal_zone_device {
        int passive;
        unsigned int forced_passive;
        const struct thermal_zone_device_ops *ops;
+       const struct thermal_zone_params *tzp;
+       struct thermal_governor *governor;
        struct list_head thermal_instances;
        struct idr idr;
        struct mutex lock; /* protect thermal_instances list */
        struct list_head node;
        struct delayed_work poll_queue;
 };
-/* Adding event notification support elements */
-#define THERMAL_GENL_FAMILY_NAME                "thermal_event"
-#define THERMAL_GENL_VERSION                    0x01
-#define THERMAL_GENL_MCAST_GROUP_NAME           "thermal_mc_group"
 
-enum events {
-       THERMAL_AUX0,
-       THERMAL_AUX1,
-       THERMAL_CRITICAL,
-       THERMAL_DEV_FAULT,
+/* Structure that holds thermal governor information */
+struct thermal_governor {
+       char name[THERMAL_NAME_LENGTH];
+       int (*throttle)(struct thermal_zone_device *tz, int trip);
+       struct list_head        governor_list;
+       struct module           *owner;
 };
 
-struct thermal_genl_event {
-       u32 orig;
-       enum events event;
+/* Structure that holds binding parameters for a zone */
+struct thermal_bind_params {
+       struct thermal_cooling_device *cdev;
+
+       /*
+        * This is a measure of 'how effectively these devices can
+        * cool 'this' thermal zone. The shall be determined by platform
+        * characterization. This is on a 'percentage' scale.
+        * See Documentation/thermal/sysfs-api.txt for more information.
+        */
+       int weight;
+
+       /*
+        * This is a bit mask that gives the binding relation between this
+        * thermal zone and cdev, for a particular trip point.
+        * See Documentation/thermal/sysfs-api.txt for more information.
+        */
+       int trip_mask;
+       int (*match) (struct thermal_zone_device *tz,
+                       struct thermal_cooling_device *cdev);
 };
-/* attributes of thermal_genl_family */
-enum {
-       THERMAL_GENL_ATTR_UNSPEC,
-       THERMAL_GENL_ATTR_EVENT,
-       __THERMAL_GENL_ATTR_MAX,
+
+/* Structure to define Thermal Zone parameters */
+struct thermal_zone_params {
+       char governor_name[THERMAL_NAME_LENGTH];
+       int num_tbps;   /* Number of tbp entries */
+       struct thermal_bind_params *tbp;
 };
-#define THERMAL_GENL_ATTR_MAX (__THERMAL_GENL_ATTR_MAX - 1)
 
-/* commands supported by the thermal_genl_family */
-enum {
-       THERMAL_GENL_CMD_UNSPEC,
-       THERMAL_GENL_CMD_EVENT,
-       __THERMAL_GENL_CMD_MAX,
+struct thermal_genl_event {
+       u32 orig;
+       enum events event;
 };
-#define THERMAL_GENL_CMD_MAX (__THERMAL_GENL_CMD_MAX - 1)
 
+/* Function declarations */
 struct thermal_zone_device *thermal_zone_device_register(const char *, int, int,
-               void *, const struct thermal_zone_device_ops *, int, int);
+               void *, const struct thermal_zone_device_ops *,
+               const struct thermal_zone_params *, int, int);
 void thermal_zone_device_unregister(struct thermal_zone_device *);
 
 int thermal_zone_bind_cooling_device(struct thermal_zone_device *, int,
@@ -173,12 +223,22 @@ int thermal_zone_bind_cooling_device(struct thermal_zone_device *, int,
 int thermal_zone_unbind_cooling_device(struct thermal_zone_device *, int,
                                       struct thermal_cooling_device *);
 void thermal_zone_device_update(struct thermal_zone_device *);
+
 struct thermal_cooling_device *thermal_cooling_device_register(char *, void *,
                const struct thermal_cooling_device_ops *);
 void thermal_cooling_device_unregister(struct thermal_cooling_device *);
 struct thermal_zone_device *thermal_zone_device_find(void *data,
        int (*match)(struct thermal_zone_device *, void *));
 
+int get_tz_trend(struct thermal_zone_device *, int);
+struct thermal_instance *get_thermal_instance(struct thermal_zone_device *,
+               struct thermal_cooling_device *, int);
+void thermal_cdev_update(struct thermal_cooling_device *);
+void notify_thermal_framework(struct thermal_zone_device *, int);
+
+int thermal_register_governor(struct thermal_governor *);
+void thermal_unregister_governor(struct thermal_governor *);
+
 #ifdef CONFIG_NET
 extern int thermal_generate_netlink_event(u32 orig, enum events event);
 #else