The power allocator thermal governor

A governor may need to store its current state between calls to throttle(). That state depends on the thermal zone, so store it as private data in struct thermal_zone_device.

The governors may have two new ops: bind_to_tz() and unbind_from_tz(). When provided, these functions let governors do some initialization and teardown when they are bound/unbound to a tz and possibly store that information in the governor_data field of the struct thermal_zone_device.

Cc Zhang Rui <[email protected]>

Cc Eduardo Valentin <[email protected]>

Signed-off-by Javi Merino <[email protected]>

---
 drivers/thermal/thermal_core.c |   67 +++++++++++++++++++++++++++++++++++-----
 include/linux/thermal.h        |    3 ++
 2 files changed, 62 insertions(+), 8 deletions(-)

drivers/thermal/thermal_core.c +11 -0

index 71b0ec0c370d..ac8e5990a63e 100644
@@ -72,6 +72,45 @@ static struct thermal_governor *__find_governor(const char *name)
  return NULL;
 }
 
+/**
+ * thermal_set_governor() - Switch to another governor
+ * @tz: a valid pointer to a struct thermal_zone_device
+ * @new_gov: pointer to the new governor
+ *
+ * Change the governor of thermal zone @tz.
+ *
+ * Returns 0 on success, an error if the new governor's bind_to_tz() failed.
+ */
+static int thermal_set_governor(struct thermal_zone_device *tz,
+ struct thermal_governor *new_gov)

drivers/thermal/thermal_core.c +12 -0

+ tz->governor = NULL;
+ }
+
+ return ret;
+ }
+ }
+
+ tz->governor = new_gov;
+
+ return ret;
+}
+
 int thermal_register_governor(struct thermal_governor *governor)
 {
  int err;

drivers/thermal/thermal_core.c +15 -6

+ }
  }
 
  mutex_unlock(&thermal_list_lock);

@@ -131,7 +174,7 @@ void thermal_unregister_governor(struct thermal_governor *governor)
  list_for_each_entry(pos, &thermal_tz_list, node) {
  if (!strnicmp(pos->governor->name, governor->name,
  THERMAL_NAME_LENGTH))
- pos->governor = NULL;
+ thermal_set_governor(pos, NULL);
  }
 
  mutex_unlock(&thermal_list_lock);

@@ -756,8 +799,9 @@ policy_store(struct device *dev, struct device_attribute *attr,
  if (!gov)
  goto exit;
 
- tz->governor = gov;
- ret = count;
+ ret = thermal_set_governor(tz, gov);
+ if (!ret)
+ ret = count;
 
 exit:
  mutex_unlock(&thermal_governor_lock);

@@ -1452,6 +1496,7 @@ struct thermal_zone_device *thermal_zone_device_register(const char *type,
  int result;
  int count;
  int passive = 0;
+ struct thermal_governor *governor;
 
  if (type && strlen(type) >= THERMAL_NAME_LENGTH)
  return ERR_PTR(-EINVAL);

@@ -1542,9 +1587,15 @@ struct thermal_zone_device *thermal_zone_device_register(const char *type,
  mutex_lock(&thermal_governor_lock);
 
  if (tz->tzp)
- tz->governor = __find_governor(tz->tzp->governor_name);
+ governor = __find_governor(tz->tzp->governor_name);
  else
- tz->governor = def_governor;
+ governor = def_governor;
+
+ result = thermal_set_governor(tz, governor);
+ if (result) {
+ mutex_unlock(&thermal_governor_lock);
+ goto unregister;
+ }
 
  mutex_unlock(&thermal_governor_lock);
 

@@ -1634,7 +1685,7 @@ void thermal_zone_device_unregister(struct thermal_zone_device *tz)
  device_remove_file(&tz->device, &dev_attr_mode);
  device_remove_file(&tz->device, &dev_attr_policy);
  remove_trip_attrs(tz);
- tz->governor = NULL;
+ thermal_set_governor(tz, NULL);
 
  thermal_remove_hwmon_sysfs(tz);
  release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);

include/linux/thermal.h +0 -0

index f7e11c7ea7d9..baac212f815e 100644

include/linux/thermal.h +0 -1

  int (*throttle)(struct thermal_zone_device *tz, int trip);
  struct list_head governor_list;
 };
--

1.7.9.5

Hello Javi,

Thanks for your patch. Find some comment inline.

Quoted 9 lines · Javi Merino

A governor may need to store its current state between calls to throttle(). That state depends on the thermal zone, so store it as private data in struct thermal_zone_device.

The governors may have two new ops: bind_to_tz() and unbind_from_tz(). When provided, these functions let governors do some initialization and teardown when they are bound/unbound to a tz and possibly store that information in the governor_data field of the struct thermal_zone_device.

Overall the idea is fine to me, although so far we have no case of such need in the current governors. I will have a look on your proposed governor to check futher on this API.

Quoted 33 lines

Cc Zhang Rui <[email protected]>

Cc Eduardo Valentin <[email protected]>

Signed-off-by Javi Merino <[email protected]>

---
 drivers/thermal/thermal_core.c |   67 +++++++++++++++++++++++++++++++++++-----
 include/linux/thermal.h        |    3 ++
 2 files changed, 62 insertions(+), 8 deletions(-)

drivers/thermal/thermal_core.c +16 -0

index 71b0ec0c370d..ac8e5990a63e 100644
@@ -72,6 +72,45 @@ static struct thermal_governor *__find_governor(const char *name)
  return NULL;
 }
 
+/**
+ * thermal_set_governor() - Switch to another governor
+ * @tz: a valid pointer to a struct thermal_zone_device
+ * @new_gov: pointer to the new governor
+ *
+ * Change the governor of thermal zone @tz.
+ *
+ * Returns 0 on success, an error if the new governor's bind_to_tz() failed.
+ */
+static int thermal_set_governor(struct thermal_zone_device *tz,
+ struct thermal_governor *new_gov)
+{
+ int ret = 0;
+
+ if (tz->governor && tz->governor->unbind_from_tz)
+ tz->governor->unbind_from_tz(tz);

drivers/thermal/thermal_core.c static struct thermal_governor *__find_governor(const char *name) · line 95

Quoted 5 lines

drivers/thermal/thermal_core.c +5 -0

+
+ if (new_gov && new_gov->bind_to_tz) {
+ ret = new_gov->bind_to_tz(tz);
+ if (ret) {
+ /* Try to register the old governor again */

I suggest to state in the Documentation that a governor may be called to bind and unbind to same thermal zone several times, as per above code.

drivers/thermal/thermal_core.c static struct thermal_governor *__find_governor(const char *name) · line 101

Quoted 6 lines

drivers/thermal/thermal_core.c +6 -0

+ if (tz->governor && tz->governor->bind_to_tz) {
+ if (tz->governor->bind_to_tz(tz))
+ /*
+ * The new governor failed to register
+ * and the previous one failed as well
+ */

I suggest having a dev_warn here to notify that a zone is now orphan due to switching from one governor to another.

Quoted 17 lines

drivers/thermal/thermal_core.c +12 -0

+ tz->governor = NULL;
+ }
+
+ return ret;
+ }
+ }
+
+ tz->governor = new_gov;
+
+ return ret;
+}
+
 int thermal_register_governor(struct thermal_governor *governor)
 {
  int err;

@@ -104,8 +143,12 @@ int thermal_register_governor(struct thermal_governor *governor)
 

drivers/thermal/thermal_core.c int thermal_register_governor(struct thermal_governor *governor) · line 147

Quoted 6 lines

drivers/thermal/thermal_core.c +2 -2

  name = pos->tzp->governor_name;
 
- if (!strnicmp(name, governor->name, THERMAL_NAME_LENGTH))
- pos->governor = governor;
+ if (!strnicmp(name, governor->name, THERMAL_NAME_LENGTH)) {
+ int ret = thermal_set_governor(pos, governor);

nip: add a blank line between declarations and first statement.

drivers/thermal/thermal_core.c int thermal_register_governor(struct thermal_governor *governor) · line 150

Quoted 3 lines

drivers/thermal/thermal_core.c +3 -0

+ if (ret)
+ pr_warn("Failed to set governor %s for zone %d: %d\n",
+ governor->name, pos->id, ret);

dev_* family of logging functions is preferred in this file.

Quoted 58 lines

drivers/thermal/thermal_core.c +15 -6

+ }
  }
 
  mutex_unlock(&thermal_list_lock);

@@ -131,7 +174,7 @@ void thermal_unregister_governor(struct thermal_governor *governor)
  list_for_each_entry(pos, &thermal_tz_list, node) {
  if (!strnicmp(pos->governor->name, governor->name,
  THERMAL_NAME_LENGTH))
- pos->governor = NULL;
+ thermal_set_governor(pos, NULL);
  }
 
  mutex_unlock(&thermal_list_lock);

@@ -756,8 +799,9 @@ policy_store(struct device *dev, struct device_attribute *attr,
  if (!gov)
  goto exit;
 
- tz->governor = gov;
- ret = count;
+ ret = thermal_set_governor(tz, gov);
+ if (!ret)
+ ret = count;
 
 exit:
  mutex_unlock(&thermal_governor_lock);

@@ -1452,6 +1496,7 @@ struct thermal_zone_device *thermal_zone_device_register(const char *type,
  int result;
  int count;
  int passive = 0;
+ struct thermal_governor *governor;
 
  if (type && strlen(type) >= THERMAL_NAME_LENGTH)
  return ERR_PTR(-EINVAL);

@@ -1542,9 +1587,15 @@ struct thermal_zone_device *thermal_zone_device_register(const char *type,
  mutex_lock(&thermal_governor_lock);
 
  if (tz->tzp)
- tz->governor = __find_governor(tz->tzp->governor_name);
+ governor = __find_governor(tz->tzp->governor_name);
  else
- tz->governor = def_governor;
+ governor = def_governor;
+
+ result = thermal_set_governor(tz, governor);
+ if (result) {
+ mutex_unlock(&thermal_governor_lock);
+ goto unregister;
+ }
 
  mutex_unlock(&thermal_governor_lock);
 

@@ -1634,7 +1685,7 @@ void thermal_zone_device_unregister(struct thermal_zone_device *tz)
  device_remove_file(&tz->device, &dev_attr_mode);
  device_remove_file(&tz->device, &dev_attr_policy);
  remove_trip_attrs(tz);
- tz->governor = NULL;
+ thermal_set_governor(tz, NULL);
 

include/linux/thermal.h struct thermal_zone_device { · line 180

Quoted 11 lines

drivers/thermal/thermal_core.c +0 -0

  thermal_remove_hwmon_sysfs(tz);
  release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);

include/linux/thermal.h +1 -0

index f7e11c7ea7d9..baac212f815e 100644
@@ -177,6 +177,7 @@ struct thermal_zone_device {
  struct thermal_zone_device_ops *ops;
  const struct thermal_zone_params *tzp;
  struct thermal_governor *governor;
+ void *governor_data;

Please document this entry.

include/linux/thermal.h struct thermal_zone_device { · line 192

Quoted 9 lines

include/linux/thermal.h +2 -0

  struct list_head thermal_instances;
  struct idr idr;
  struct mutex lock; /* protect thermal_instances list */

@@ -187,6 +188,8 @@ struct thermal_zone_device {
 /* Structure that holds thermal governor information */
 struct thermal_governor {
  char name[THERMAL_NAME_LENGTH];
+ int (*bind_to_tz)(struct thermal_zone_device *tz);
+ void (*unbind_from_tz)(struct thermal_zone_device *tz);

a governor cannot prevent unbinding?

Please, document the proposed operations.

Quoted 5 lines

include/linux/thermal.h +0 -1

  int (*throttle)(struct thermal_zone_device *tz, int trip);
  struct list_head governor_list;
 };
--

1.7.9.5

I request that you update Documentation/thermal/sysfs-api.txt too.

Quoted 4 lines · On Tue, May 13, 2014 at 03:31:08PM +0100, [email protected] wrote:

Hello Javi,

Thanks for your patch. Find some comment inline.

Will do, but I find that the other governor op (throttle) is not documented. Where do you suggest we should put it?

Quoted 9 lines

Quoted 6 lines

+ if (tz->governor && tz->governor->bind_to_tz) {
+ if (tz->governor->bind_to_tz(tz))
+ /*
+ * The new governor failed to register
+ * and the previous one failed as well
+ */

I suggest having a dev_warn here to notify that a zone is now orphan due to switching from one governor to another.

Done

Quoted 17 lines

Quoted 17 lines

+ tz->governor = NULL;
+ }

drivers/thermal/thermal_core.c +10 -0

+
+ return ret;
+ }
+ }
+
+ tz->governor = new_gov;
+
+ return ret;
+}
+
 int thermal_register_governor(struct thermal_governor *governor)
 {
  int err;

@@ -104,8 +143,12 @@ int thermal_register_governor(struct thermal_governor *governor)
 

Quoted 8 lines

drivers/thermal/thermal_core.c int thermal_register_governor(struct thermal_governor *governor) · line 147

Quoted 6 lines

drivers/thermal/thermal_core.c +2 -2

  name = pos->tzp->governor_name;
 
- if (!strnicmp(name, governor->name, THERMAL_NAME_LENGTH))
- pos->governor = governor;
+ if (!strnicmp(name, governor->name, THERMAL_NAME_LENGTH)) {
+ int ret = thermal_set_governor(pos, governor);

nip: add a blank line between declarations and first statement.

Ok

Quoted 5 lines

drivers/thermal/thermal_core.c int thermal_register_governor(struct thermal_governor *governor) · line 150

Quoted 3 lines

drivers/thermal/thermal_core.c +3 -0

+ if (ret)
+ pr_warn("Failed to set governor %s for zone %d: %d\n",
+ governor->name, pos->id, ret);

dev_* family of logging functions is preferred in this file.

Done

Quoted 58 lines

Quoted 58 lines

drivers/thermal/thermal_core.c +15 -6

+ }
  }
 
  mutex_unlock(&thermal_list_lock);

@@ -131,7 +174,7 @@ void thermal_unregister_governor(struct thermal_governor *governor)
  list_for_each_entry(pos, &thermal_tz_list, node) {
  if (!strnicmp(pos->governor->name, governor->name,
  THERMAL_NAME_LENGTH))
- pos->governor = NULL;
+ thermal_set_governor(pos, NULL);
  }
 
  mutex_unlock(&thermal_list_lock);

@@ -756,8 +799,9 @@ policy_store(struct device *dev, struct device_attribute *attr,
  if (!gov)
  goto exit;
 
- tz->governor = gov;
- ret = count;
+ ret = thermal_set_governor(tz, gov);
+ if (!ret)
+ ret = count;
 
 exit:
  mutex_unlock(&thermal_governor_lock);

@@ -1452,6 +1496,7 @@ struct thermal_zone_device *thermal_zone_device_register(const char *type,
  int result;
  int count;
  int passive = 0;
+ struct thermal_governor *governor;
 
  if (type && strlen(type) >= THERMAL_NAME_LENGTH)
  return ERR_PTR(-EINVAL);

@@ -1542,9 +1587,15 @@ struct thermal_zone_device *thermal_zone_device_register(const char *type,
  mutex_lock(&thermal_governor_lock);
 
  if (tz->tzp)
- tz->governor = __find_governor(tz->tzp->governor_name);
+ governor = __find_governor(tz->tzp->governor_name);
  else
- tz->governor = def_governor;
+ governor = def_governor;
+
+ result = thermal_set_governor(tz, governor);
+ if (result) {
+ mutex_unlock(&thermal_governor_lock);
+ goto unregister;
+ }
 
  mutex_unlock(&thermal_governor_lock);
 

@@ -1634,7 +1685,7 @@ void thermal_zone_device_unregister(struct thermal_zone_device *tz)
  device_remove_file(&tz->device, &dev_attr_mode);
  device_remove_file(&tz->device, &dev_attr_policy);
  remove_trip_attrs(tz);
- tz->governor = NULL;
+ thermal_set_governor(tz, NULL);
 

Quoted 13 lines

include/linux/thermal.h struct thermal_zone_device { · line 180

Quoted 11 lines

drivers/thermal/thermal_core.c +0 -0

  thermal_remove_hwmon_sysfs(tz);
  release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);

include/linux/thermal.h +1 -0

index f7e11c7ea7d9..baac212f815e 100644
@@ -177,6 +177,7 @@ struct thermal_zone_device {
  struct thermal_zone_device_ops *ops;
  const struct thermal_zone_params *tzp;
  struct thermal_governor *governor;
+ void *governor_data;

Please document this entry.

Where? None of these entries are documented. I guess I'll have to add a patch that describes each one of them and then add ours.

Quoted 11 lines

include/linux/thermal.h struct thermal_zone_device { · line 192

Quoted 9 lines

include/linux/thermal.h +2 -0

  struct list_head thermal_instances;
  struct idr idr;
  struct mutex lock; /* protect thermal_instances list */

@@ -187,6 +188,8 @@ struct thermal_zone_device {
 /* Structure that holds thermal governor information */
 struct thermal_governor {
  char name[THERMAL_NAME_LENGTH];
+ int (*bind_to_tz)(struct thermal_zone_device *tz);
+ void (*unbind_from_tz)(struct thermal_zone_device *tz);

a governor cannot prevent unbinding?

To me it's like open()/close() or malloc()/free(). You generally can fail to bind, but not fail to unbind. I can change it to an int if you think it is something that we may need.

Quoted 1 line

Please, document the proposed operations.

Same as before, none of the entries in this struct are documented so I'll submit a patch that describes the current ones and then add our new ones in our patch.

Quoted 7 lines

Quoted 5 lines

include/linux/thermal.h +0 -1

  int (*throttle)(struct thermal_zone_device *tz, int trip);
  struct list_head governor_list;
 };
--

1.7.9.5

I request that you update Documentation/thermal/sysfs-api.txt too.

Will do.

Cheers,
Javi

Currently, cooling devices operate on state, even though some (like the cpufreq cooling device) have exported functions to convert frequency to state. Generalize this interface so that governors can operate on other units (e.g. frequency, power,...).

Suggested-by Eduardo Valentin <[email protected]>

Cc Zhang Rui <[email protected]>

Signed-off-by Javi Merino <[email protected]>

---
 drivers/acpi/fan.c                  |   22 ++++++++++++++------
 drivers/acpi/processor_thermal.c    |   23 +++++++++++++++------
 drivers/acpi/video.c                |   22 ++++++++++++++------
 drivers/platform/x86/acerhdf.c      |   24 ++++++++++++++++------
 drivers/platform/x86/intel_menlow.c |   26 +++++++++++++++++-------
 drivers/power/power_supply_core.c   |   24 ++++++++++++++++------
 drivers/thermal/cpu_cooling.c       |   38 ++++++++++++++++++++++++++---------
 drivers/thermal/db8500_thermal.c    |    2 +-
 drivers/thermal/fair_share.c        |    2 +-
 drivers/thermal/intel_powerclamp.c  |   24 ++++++++++++++++------
 drivers/thermal/step_wise.c         |    2 +-
 drivers/thermal/thermal_core.c      |   13 ++++++------
 include/linux/thermal.h             |   13 +++++++++---
 13 files changed, 169 insertions(+), 66 deletions(-)

drivers/acpi/fan.c +16 -6

index 8acf53e62966..55346deb8202 100644
@@ -79,20 +79,26 @@ static struct acpi_driver acpi_fan_driver = {
 
 /* thermal cooling device callbacks */
 static int fan_get_max_state(struct thermal_cooling_device *cdev, unsigned long
-     *state)
+     *state, enum thermal_cooling_unit unit)
 {
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  /* ACPI fan device only support two states: ON/OFF */
  *state = 1;
  return 0;
 }
 
 static int fan_get_cur_state(struct thermal_cooling_device *cdev, unsigned long
-     *state)
+     *state, enum thermal_cooling_unit unit)
 {
  struct acpi_device *device = cdev->devdata;
  int result;
  int acpi_state = ACPI_STATE_D0;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  if (!device)
  return -EINVAL;
 

@@ -106,11 +112,15 @@ static int fan_get_cur_state(struct thermal_cooling_device *cdev, unsigned long
 }
 
 static int
-fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
+fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state,
+  enum thermal_cooling_unit unit)
 {
  struct acpi_device *device = cdev->devdata;
  int result;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  if (!device || (state != 0 && state != 1))
  return -EINVAL;
 

@@ -121,9 +131,9 @@ fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
 }
 
 static const struct thermal_cooling_device_ops fan_cooling_ops = {
- .get_max_state = fan_get_max_state,
- .get_cur_state = fan_get_cur_state,
- .set_cur_state = fan_set_cur_state,
+ .get_max = fan_get_max_state,
+ .get_cur = fan_get_cur_state,
+ .set_cur = fan_set_cur_state,
 };
 
 /* --------------------------------------------------------------------------

drivers/acpi/processor_thermal.c +17 -6

index e003663b2f8e..48179ed9afe5 100644
@@ -200,11 +200,15 @@ static int acpi_processor_max_state(struct acpi_processor *pr)
 }
 static int
 processor_get_max_state(struct thermal_cooling_device *cdev,
- unsigned long *state)
+ unsigned long *state,
+ enum thermal_cooling_unit unit)
 {
  struct acpi_device *device = cdev->devdata;
  struct acpi_processor *pr;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  if (!device)
  return -EINVAL;
 

@@ -218,11 +222,15 @@ processor_get_max_state(struct thermal_cooling_device *cdev,
 
 static int
 processor_get_cur_state(struct thermal_cooling_device *cdev,
- unsigned long *cur_state)
+ unsigned long *cur_state,
+ enum thermal_cooling_unit unit)
 {
  struct acpi_device *device = cdev->devdata;
  struct acpi_processor *pr;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  if (!device)
  return -EINVAL;
 

@@ -238,13 +246,16 @@ processor_get_cur_state(struct thermal_cooling_device *cdev,
 
 static int
 processor_set_cur_state(struct thermal_cooling_device *cdev,
- unsigned long state)
+ unsigned long state, enum thermal_cooling_unit unit)
 {
  struct acpi_device *device = cdev->devdata;
  struct acpi_processor *pr;
  int result = 0;
  int max_pstate;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  if (!device)
  return -EINVAL;
 

@@ -270,7 +281,7 @@ processor_set_cur_state(struct thermal_cooling_device *cdev,
 }
 
 const struct thermal_cooling_device_ops processor_cooling_ops = {
- .get_max_state = processor_get_max_state,
- .get_cur_state = processor_get_cur_state,
- .set_cur_state = processor_set_cur_state,
+ .get_max = processor_get_max_state,
+ .get_cur = processor_get_cur_state,
+ .set_cur = processor_set_cur_state,
 };

drivers/acpi/video.c +16 -6

index 8b6990e417ec..f0aeb4d1ba91 100644
@@ -282,23 +282,29 @@ static const struct backlight_ops acpi_backlight_ops = {
 
 /* thermal cooling device callbacks */
 static int video_get_max_state(struct thermal_cooling_device *cooling_dev, unsigned
-       long *state)
+       long *state, enum thermal_cooling_unit unit)
 {
  struct acpi_device *device = cooling_dev->devdata;
  struct acpi_video_device *video = acpi_driver_data(device);
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  *state = video->brightness->count - 3;
  return 0;
 }
 
 static int video_get_cur_state(struct thermal_cooling_device *cooling_dev, unsigned
-       long *state)
+       long *state, enum thermal_cooling_unit unit)
 {
  struct acpi_device *device = cooling_dev->devdata;
  struct acpi_video_device *video = acpi_driver_data(device);
  unsigned long long level;
  int offset;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  if (acpi_video_device_lcd_get_level_current(video, &level, false))
  return -EINVAL;
  for (offset = 2; offset < video->brightness->count; offset++)

@@ -311,12 +317,16 @@ static int video_get_cur_state(struct thermal_cooling_device *cooling_dev, unsig
 }
 
 static int
-video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long state)
+video_set_cur_state(struct thermal_cooling_device *cooling_dev,
+ unsigned long state, enum thermal_cooling_unit unit)
 {
  struct acpi_device *device = cooling_dev->devdata;
  struct acpi_video_device *video = acpi_driver_data(device);
  int level;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  if (state >= video->brightness->count - 2)
  return -EINVAL;
 

@@ -326,9 +336,9 @@ video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long st
 }
 
 static const struct thermal_cooling_device_ops video_cooling_ops = {
- .get_max_state = video_get_max_state,
- .get_cur_state = video_get_cur_state,
- .set_cur_state = video_set_cur_state,
+ .get_max = video_get_max_state,
+ .get_cur = video_get_cur_state,
+ .set_cur = video_set_cur_state,
 };
 
 /*

drivers/platform/x86/acerhdf.c +18 -6

index f94467c05225..0bb85e240d93 100644
@@ -439,18 +439,26 @@ static struct thermal_zone_device_ops acerhdf_dev_ops = {
  * get maximal fan cooling state
  */
 static int acerhdf_get_max_state(struct thermal_cooling_device *cdev,
- unsigned long *state)
+ unsigned long *state,
+ enum thermal_cooling_unit unit)
 {
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  *state = 1;
 
  return 0;
 }
 
 static int acerhdf_get_cur_state(struct thermal_cooling_device *cdev,
- unsigned long *state)
+ unsigned long *state,
+ enum thermal_cooling_unit unit)
 {
  int err = 0, tmp;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  err = acerhdf_get_fanstate(&tmp);
  if (err)
  return err;

@@ -461,10 +469,14 @@ static int acerhdf_get_cur_state(struct thermal_cooling_device *cdev,
 
 /* change current fan state - is overwritten when running in kernel mode */
 static int acerhdf_set_cur_state(struct thermal_cooling_device *cdev,
- unsigned long state)
+ unsigned long state,
+ enum thermal_cooling_unit unit)
 {
  int cur_temp, cur_state, err = 0;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  if (!kernelmode)
  return 0;
 

@@ -498,9 +510,9 @@ err_out:
 
 /* bind fan callbacks to fan device */
 static struct thermal_cooling_device_ops acerhdf_cooling_ops = {
- .get_max_state = acerhdf_get_max_state,
- .get_cur_state = acerhdf_get_cur_state,
- .set_cur_state = acerhdf_set_cur_state,
+ .get_max = acerhdf_get_max_state,
+ .get_cur = acerhdf_get_cur_state,
+ .set_cur = acerhdf_set_cur_state,
 };
 
 /* suspend / resume functionality */

drivers/platform/x86/intel_menlow.c +19 -7

index e8b46d2c468c..9792da407c46 100644
@@ -61,7 +61,8 @@ static void intel_menlow_unregister_sensor(void);
  * GTHS returning '0' would mean that no bandwidth control states are supported
  */
 static int memory_get_max_bandwidth(struct thermal_cooling_device *cdev,
-    unsigned long *max_state)
+ unsigned long *max_state,
+ enum thermal_cooling_unit unit)
 {
  struct acpi_device *device = cdev->devdata;
  acpi_handle handle = device->handle;

@@ -70,6 +71,9 @@ static int memory_get_max_bandwidth(struct thermal_cooling_device *cdev,
  union acpi_object arg;
  acpi_status status = AE_OK;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  arg_list.count = 1;
  arg_list.pointer = &arg;
  arg.type = ACPI_TYPE_INTEGER;

@@ -87,7 +91,8 @@ static int memory_get_max_bandwidth(struct thermal_cooling_device *cdev,
 }
 
 static int memory_get_cur_bandwidth(struct thermal_cooling_device *cdev,
-    unsigned long *value)
+    unsigned long *value,
+    enum thermal_cooling_unit unit)
 {
  struct acpi_device *device = cdev->devdata;
  acpi_handle handle = device->handle;

@@ -96,6 +101,9 @@ static int memory_get_cur_bandwidth(struct thermal_cooling_device *cdev,
  union acpi_object arg;
  acpi_status status = AE_OK;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  arg_list.count = 1;
  arg_list.pointer = &arg;
  arg.type = ACPI_TYPE_INTEGER;

@@ -110,7 +118,8 @@ static int memory_get_cur_bandwidth(struct thermal_cooling_device *cdev,
 }
 
 static int memory_set_cur_bandwidth(struct thermal_cooling_device *cdev,
-    unsigned long state)
+    unsigned long state,
+    enum thermal_cooling_unit unit)
 {
  struct acpi_device *device = cdev->devdata;
  acpi_handle handle = device->handle;

@@ -120,7 +129,10 @@ static int memory_set_cur_bandwidth(struct thermal_cooling_device *cdev,
  unsigned long long temp;
  unsigned long max_state;
 
- if (memory_get_max_bandwidth(cdev, &max_state))
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
+ if (memory_get_max_bandwidth(cdev, &max_state, THERMAL_UNIT_STATE))
  return -EFAULT;
 
  if (state > max_state)

@@ -143,9 +155,9 @@ static int memory_set_cur_bandwidth(struct thermal_cooling_device *cdev,
 }
 
 static struct thermal_cooling_device_ops memory_cooling_ops = {
- .get_max_state = memory_get_max_bandwidth,
- .get_cur_state = memory_get_cur_bandwidth,
- .set_cur_state = memory_set_cur_bandwidth,
+ .get_max = memory_get_max_bandwidth,
+ .get_cur = memory_get_cur_bandwidth,
+ .set_cur = memory_set_cur_bandwidth,
 };
 
 /*

drivers/power/power_supply_core.c +18 -6

index 26606641fe44..69dc2901a788 100644
@@ -440,12 +440,16 @@ static void psy_unregister_thermal(struct power_supply *psy)
 
 /* thermal cooling device callbacks */
 static int ps_get_max_charge_cntl_limit(struct thermal_cooling_device *tcd,
- unsigned long *state)
+ unsigned long *state,
+ enum thermal_cooling_unit unit)
 {
  struct power_supply *psy;
  union power_supply_propval val;
  int ret;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  psy = tcd->devdata;
  ret = psy->get_property(psy,
  POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, &val);

@@ -456,12 +460,16 @@ static int ps_get_max_charge_cntl_limit(struct thermal_cooling_device *tcd,
 }
 
 static int ps_get_cur_chrage_cntl_limit(struct thermal_cooling_device *tcd,
- unsigned long *state)
+ unsigned long *state,
+ enum thermal_cooling_unit unit)
 {
  struct power_supply *psy;
  union power_supply_propval val;
  int ret;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  psy = tcd->devdata;
  ret = psy->get_property(psy,
  POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &val);

@@ -472,12 +480,16 @@ static int ps_get_cur_chrage_cntl_limit(struct thermal_cooling_device *tcd,
 }
 
 static int ps_set_cur_charge_cntl_limit(struct thermal_cooling_device *tcd,
- unsigned long state)
+ unsigned long state,
+ enum thermal_cooling_unit unit)
 {
  struct power_supply *psy;
  union power_supply_propval val;
  int ret;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  psy = tcd->devdata;
  val.intval = state;
  ret = psy->set_property(psy,

@@ -487,9 +499,9 @@ static int ps_set_cur_charge_cntl_limit(struct thermal_cooling_device *tcd,
 }
 
 static struct thermal_cooling_device_ops psy_tcd_ops = {
- .get_max_state = ps_get_max_charge_cntl_limit,
- .get_cur_state = ps_get_cur_chrage_cntl_limit,
- .set_cur_state = ps_set_cur_charge_cntl_limit,
+ .get_max = ps_get_max_charge_cntl_limit,
+ .get_cur = ps_get_cur_chrage_cntl_limit,
+ .set_cur = ps_set_cur_charge_cntl_limit,
 };
 
 static int psy_register_cooler(struct power_supply *psy)

drivers/thermal/cpu_cooling.c +28 -10

index 4246262c4bd2..f3f4e6b5798e 100644
@@ -348,14 +348,17 @@ static int cpufreq_thermal_notifier(struct notifier_block *nb,
  * cpufreq_get_max_state - callback function to get the max cooling state.
  * @cdev: thermal cooling device pointer.
  * @state: fill this variable with the max cooling state.
+ * @unit: the units in which @state should be in.
  *
- * Callback for the thermal cooling device to return the cpufreq
- * max cooling state.
+ * Callback for the thermal cooling device to return the cpufreq max
+ * cooling state.  Currently only THERMAL_UNIT_STATE is valid for
+ * @unit.
  *
  * Return: 0 on success, an error code otherwise.
  */
 static int cpufreq_get_max_state(struct thermal_cooling_device *cdev,
- unsigned long *state)
+ unsigned long *state,
+ enum thermal_cooling_unit unit)
 {
  struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
  struct cpumask *mask = &cpufreq_device->allowed_cpus;

@@ -363,6 +366,9 @@ static int cpufreq_get_max_state(struct thermal_cooling_device *cdev,
  unsigned int count = 0;
  int ret;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  cpu = cpumask_any(mask);
 
  ret = get_property(cpu, 0, &count, GET_MAXL);

@@ -377,17 +383,23 @@ static int cpufreq_get_max_state(struct thermal_cooling_device *cdev,
  * cpufreq_get_cur_state - callback function to get the current cooling state.
  * @cdev: thermal cooling device pointer.
  * @state: fill this variable with the current cooling state.
+ * @unit: the units in which state should be in
  *
  * Callback for the thermal cooling device to return the cpufreq
- * current cooling state.
+ * current cooling state.  Currently only THERMAL_UNIT_STATE is valid
+ * for @unit.
  *
  * Return: 0 on success, an error code otherwise.
  */
 static int cpufreq_get_cur_state(struct thermal_cooling_device *cdev,
- unsigned long *state)
+ unsigned long *state,
+ enum thermal_cooling_unit unit)
 {
  struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  *state = cpufreq_device->cpufreq_state;
 
  return 0;

@@ -397,25 +409,31 @@ static int cpufreq_get_cur_state(struct thermal_cooling_device *cdev,
  * cpufreq_set_cur_state - callback function to set the current cooling state.
  * @cdev: thermal cooling device pointer.
  * @state: set this variable to the current cooling state.
+ * @unit: the units in which @state should be in.
  *
  * Callback for the thermal cooling device to change the cpufreq
- * current cooling state.
+ * current cooling state.  Currently only THERMAL_UNIT_STATE is valid for
+ * @unit.
  *
  * Return: 0 on success, an error code otherwise.
  */
 static int cpufreq_set_cur_state(struct thermal_cooling_device *cdev,
- unsigned long state)
+ unsigned long state,
+ enum thermal_cooling_unit unit)
 {
  struct cpufreq_cooling_device *cpufreq_device = cdev->devdata;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  return cpufreq_apply_cooling(cpufreq_device, state);
 }
 
 /* Bind cpufreq callbacks to thermal cooling device ops */
 static struct thermal_cooling_device_ops const cpufreq_cooling_ops = {
- .get_max_state = cpufreq_get_max_state,
- .get_cur_state = cpufreq_get_cur_state,
- .set_cur_state = cpufreq_set_cur_state,
+ .get_max = cpufreq_get_max_state,
+ .get_cur = cpufreq_get_cur_state,
+ .set_cur = cpufreq_set_cur_state,
 };
 
 /* Notifier for cpufreq policy change */

drivers/thermal/db8500_thermal.c +1 -1

index 1e3b3bf9f993..0842a2ef88b4 100644
@@ -67,7 +67,7 @@ static int db8500_cdev_bind(struct thermal_zone_device *thermal,
  unsigned long max_state, upper, lower;
  int i, ret = -EINVAL;
 
- cdev->ops->get_max_state(cdev, &max_state);
+ cdev->ops->get_max(cdev, &max_state, THERMAL_UNIT_STATE);
 
  for (i = 0; i < ptrips->num_trips; i++) {
  if (db8500_thermal_match_cdev(cdev, &ptrips->trip_points[i]))

drivers/thermal/fair_share.c +1 -1

index 944ba2f340c8..8e6eb4883bb6 100644
@@ -51,7 +51,7 @@ static long get_target_state(struct thermal_zone_device *tz,
 {
  unsigned long max_state;
 
- cdev->ops->get_max_state(cdev, &max_state);
+ cdev->ops->get_max(cdev, &max_state, THERMAL_UNIT_STATE);
 
  return (long)(weight * level * max_state) / (100 * tz->trips);
 }

drivers/thermal/intel_powerclamp.c +18 -6

index a084325f1386..c32bee16b17a 100644
@@ -616,16 +616,24 @@ static struct notifier_block powerclamp_cpu_notifier = {
 };
 
 static int powerclamp_get_max_state(struct thermal_cooling_device *cdev,
- unsigned long *state)
+ unsigned long *state,
+ enum thermal_cooling_unit unit)
 {
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  *state = MAX_TARGET_RATIO;
 
  return 0;
 }
 
 static int powerclamp_get_cur_state(struct thermal_cooling_device *cdev,
- unsigned long *state)
+ unsigned long *state,
+ enum thermal_cooling_unit unit)
 {
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  if (true == clamping)
  *state = pkg_cstate_ratio_cur;
  else

@@ -636,10 +644,14 @@ static int powerclamp_get_cur_state(struct thermal_cooling_device *cdev,
 }
 
 static int powerclamp_set_cur_state(struct thermal_cooling_device *cdev,
- unsigned long new_target_ratio)
+ unsigned long new_target_ratio,
+ enum thermal_cooling_unit unit)
 {
  int ret = 0;
 
+ if (unit != THERMAL_UNIT_STATE)
+ return -EINVAL;
+
  new_target_ratio = clamp(new_target_ratio, 0UL,
  (unsigned long) (MAX_TARGET_RATIO-1));
  if (set_target_ratio == 0 && new_target_ratio > 0) {

@@ -663,9 +675,9 @@ exit_set:
 
 /* bind to generic thermal layer as cooling device*/
 static struct thermal_cooling_device_ops powerclamp_cooling_ops = {
- .get_max_state = powerclamp_get_max_state,
- .get_cur_state = powerclamp_get_cur_state,
- .set_cur_state = powerclamp_set_cur_state,
+ .get_max = powerclamp_get_max_state,
+ .get_cur = powerclamp_get_cur_state,
+ .set_cur = powerclamp_set_cur_state,
 };
 
 /* runs on Nehalem and later */

drivers/thermal/step_wise.c +1 -1

index f251521baaa2..2a2cd4eba3c3 100644
@@ -58,7 +58,7 @@ static unsigned long get_target_state(struct thermal_instance *instance,
  * Otherwise, we use the current state of the
  * cdev in use to determine the next_target.
  */
- cdev->ops->get_cur_state(cdev, &cur_state);
+ cdev->ops->get_cur(cdev, &cur_state, THERMAL_UNIT_STATE);
  next_target = instance->target;
  dev_dbg(&cdev->device, "cur_state=%ld\n", cur_state);
 

drivers/thermal/thermal_core.c +5 -6

index ac8e5990a63e..5b46603cc7cd 100644
@@ -871,7 +871,7 @@ thermal_cooling_device_max_state_show(struct device *dev,
  unsigned long state;
  int ret;
 
- ret = cdev->ops->get_max_state(cdev, &state);
+ ret = cdev->ops->get_max(cdev, &state, THERMAL_UNIT_STATE);
  if (ret)
  return ret;
  return sprintf(buf, "%ld\n", state);

@@ -885,7 +885,7 @@ thermal_cooling_device_cur_state_show(struct device *dev,
  unsigned long state;
  int ret;
 
- ret = cdev->ops->get_cur_state(cdev, &state);
+ ret = cdev->ops->get_cur(cdev, &state, THERMAL_UNIT_STATE);
  if (ret)
  return ret;
  return sprintf(buf, "%ld\n", state);

@@ -906,7 +906,7 @@ thermal_cooling_device_cur_state_store(struct device *dev,
  if ((long)state < 0)
  return -EINVAL;
 
- result = cdev->ops->set_cur_state(cdev, state);
+ result = cdev->ops->set_cur(cdev, state, THERMAL_UNIT_STATE);
  if (result)
  return result;
  return count;

@@ -983,7 +983,7 @@ int thermal_zone_bind_cooling_device(struct thermal_zone_device *tz,
  if (tz != pos1 || cdev != pos2)
  return -EINVAL;
 
- cdev->ops->get_max_state(cdev, &max_state);
+ cdev->ops->get_max(cdev, &max_state, THERMAL_UNIT_STATE);
 
  /* lower default 0, upper default max_state */
  lower = lower == THERMAL_NO_LIMIT ? 0 : lower;

@@ -1143,8 +1143,7 @@ __thermal_cooling_device_register(struct device_node *np,
  if (type && strlen(type) >= THERMAL_NAME_LENGTH)
  return ERR_PTR(-EINVAL);
 
- if (!ops || !ops->get_max_state || !ops->get_cur_state ||
-    !ops->set_cur_state)
+ if (!ops || !ops->get_max || !ops->get_cur || !ops->set_cur)
  return ERR_PTR(-EINVAL);
 
  cdev = kzalloc(sizeof(struct thermal_cooling_device), GFP_KERNEL);

include/linux/thermal.h +4 -0

index baac212f815e..8d183b8255eb 100644
@@ -106,6 +106,10 @@ enum {
 };
 #define THERMAL_GENL_CMD_MAX (__THERMAL_GENL_CMD_MAX - 1)
 
+enum thermal_cooling_unit {
+ THERMAL_UNIT_STATE,
+};
+
 struct thermal_zone_device_ops {
  int (*bind) (struct thermal_zone_device *,
      struct thermal_cooling_device *);

@@ -135,9 +139,12 @@ struct thermal_zone_device_ops {
 };
 
 struct thermal_cooling_device_ops {

include/linux/thermal.h +0 -1

 struct thermal_cooling_device {
--

1.7.9.5

--
To unsubscribe from this list: send the line "unsubscribe linux-pm" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

Introduce a new thermal_cooling_unit: THERMAL_UNIT_POWER and let cpu_cooling device operate using it as well as "states". This allows governors that call cpufreq_get_max/cpufreq_get_cur/cpufreq_set_cur() with THERMAL_UNIT_POWER to use cpufreq cooling devices.

If the cpu cooling device is registered using {of_,}cpufreq_power_actor_register() instead of {of_,}cpufreq_cooling_register() it uses the current frequency (as reported by cpufreq) as well as load and OPPs for the power calculations. The cpus must have registered their OPPs in the OPP library.

Cc Zhang Rui <[email protected]>

Cc Eduardo Valentin <[email protected]>

Signed-off-by Punit Agrawal <[email protected]>

Signed-off-by Javi Merino <[email protected]>

---
 drivers/thermal/cpu_cooling.c  |  430 ++++++++++++++++++++++++++++++++++++----
 drivers/thermal/thermal_core.c |    4 +-
 include/linux/cpu_cooling.h    |   28 +++
 include/linux/thermal.h        |    4 +
 4 files changed, 422 insertions(+), 44 deletions(-)

drivers/thermal/cpu_cooling.c +25 -0

index f3f4e6b5798e..8052cd1f4a39 100644
@@ -24,10 +24,27 @@
 #include <linux/thermal.h>
 #include <linux/cpufreq.h>
 #include <linux/err.h>
+#include <linux/pm_opp.h>
 #include <linux/slab.h>
 #include <linux/cpu.h>
 #include <linux/cpu_cooling.h>
 
+/* Maximum number of opps we can track */
+#define MAX_NUM_OPPS 32
+
+/**
+ * struct power_table - frequency to power conversion
+ * @frequency:	frequency in KHz
+ * @power:	power in mW
+ *
+ * This structure is built when the cooling device registers and helps
+ * in translating frequency to power and viceversa.
+ */
+struct power_table {
+	u32 frequency;
+	u32 power;
+};
+
 /**
  * struct cpufreq_cooling_device - data for cooling device with cpufreq
  * @id: unique integer value corresponding to each cpufreq_cooling_device

@@ -39,6 +56,14 @@
  * @cpufreq_val: integer value representing the absolute value of the clipped
  *	frequency.
  * @allowed_cpus: all the cpus involved for this cpufreq_cooling_device.
+ * @power_table: array of struct power_table for frequency to power conversion
+ * @power_table_entries: number of entries in the @power_table array
+ * @time_in_idle: previous reading of the absolute time that this cpu was idle
+ * @time_in_idle_timestamp: wall time of the last invocation of
+ *	get_cpu_idle_time_us()
+ * @last_load: load measured by the latest call to cpufreq_get_cur()
+ * @freq: frequency in KHz of the cpus represented by the cooling device
+ * @capacitance: the dynamic power coefficient of these cpus
  *
  * This structure is required for keeping information of each
  * cpufreq_cooling_device registered. In order to prevent corruption of this a

drivers/thermal/cpu_cooling.c +40 -0

 /* notify_table passes value to the CPUFREQ_ADJUST callback function. */
 #define NOTIFY_INVALID NULL

@@ -115,6 +148,59 @@ static int is_cpufreq_valid(int cpu)
 	return !cpufreq_get_policy(&policy, cpu);
 }
 
+static u32 cpu_freq_to_power(struct cpufreq_cooling_device *cpufreq_device,
+			u32 freq)
+{
+	int i;
+	struct power_table *pt = cpufreq_device->power_table;
+
+	for (i = 0; i < cpufreq_device->power_table_entries - 1; i++)
+		if (freq <= pt[i].frequency)
+			break;
+
+	return pt[i].power;
+}
+
+static u32 cpu_power_to_freq(struct cpufreq_cooling_device *cpufreq_device,
+			u32 power)
+{
+	int i;
+	struct power_table *pt = cpufreq_device->power_table;
+
+	for (i = 0; i < cpufreq_device->power_table_entries - 1; i++)
+		if (power <= pt[i].power)
+			break;
+
+	return pt[i].frequency;
+}
+
+/**
+ * get_load - get load for a cpu since last updated
+ * @cpufreq_device: struct cpufreq_cooling_device for this cooling device
+ * @cpu: cpu number
+ *
+ * Return the average load of cpu @cpu in percentage since this
+ * function was last called.
+ */
+static u32 get_load(struct cpufreq_cooling_device *cpufreq_device, int cpu)
+{
+	u32 load;
+	u64 now, now_idle, delta_time, delta_idle;
+
+	now_idle = get_cpu_idle_time(cpu, &now, 0);

drivers/thermal/cpu_cooling.c +22 -0

+	return load;
+}
+
 enum cpufreq_cooling_property {
 	GET_LEVEL,
 	GET_FREQ,

@@ -342,98 +428,193 @@ static int cpufreq_thermal_notifier(struct notifier_block *nb,
 	return 0;
 }
 
+/**
+ * cpufreq_frequency_change - notifier callback for cpufreq frequency changes
+ * @nb:		struct notifier_block * with callback info
+ * @event:	value showing cpufreq event for which this function invoked
+ * @data:	callback-specific data
+ *
+ * Callback to get notifications of frequency changes.  In the
+ * CPUFREQ_POSTCHANGE @event we store the new frequency so that
+ * cpufreq_get_cur() knows the current frequency and can convert it
+ * into power.
+ */
+static int cpufreq_frequency_change(struct notifier_block *nb,
+				unsigned long event, void *data)
+{
+	struct thermal_cooling_device *cdev;
+	struct cpufreq_freqs *freqs = data;
+
+	/* Only update frequency on postchange */
+	if (event != CPUFREQ_POSTCHANGE)

drivers/thermal/cpu_cooling.c +15 -5

+		cpufreq_device = cdev->devdata;
+
+		if (cpumask_test_cpu(freqs->cpu, &cpufreq_device->allowed_cpus))
+			cpufreq_device->freq = freqs->new;
+	}
+
+	mutex_unlock(&thermal_list_lock);
+
+	return NOTIFY_OK;
+}
+
 /* cpufreq cooling device callback functions are defined below */
 
 /**
- * cpufreq_get_max_state - callback function to get the max cooling state.
+ * cpufreq_get_max - callback function to get the max cooling state/power.
  * @cdev: thermal cooling device pointer.
- * @state: fill this variable with the max cooling state.
- * @unit: the units in which @state should be in.
+ * @val: fill this variable with the max cooling state/power.
+ * @unit: whether to put state or power in @val.
  *
  * Callback for the thermal cooling device to return the cpufreq max
- * cooling state.  Currently only THERMAL_UNIT_STATE is valid for
- * @unit.
+ * cooling state/power.  If @unit is THERMAL_UNIT_STATE, @val contains

drivers/thermal/cpu_cooling.c +22 -9

+		unsigned int num_cpus;
+		unsigned long max_freq;
+
+		max_freq = get_cpu_frequency(cpu, 0);
+		if (!max_freq)
+			return -EINVAL;
 
-	if (count > 0)
-		*state = count;
+		num_cpus = cpumask_weight(mask);
+		*val = cpu_freq_to_power(cdev->devdata, max_freq) * num_cpus;
+	} else if (unit == THERMAL_UNIT_STATE) {
+		ret = get_property(cpu, 0, &count, GET_MAXL);
+
+		if (count > 0)
+			*val = count;
+	} else {
+		ret = -EINVAL;
+	}
 
 	return ret;
 }
 
 /**
- * cpufreq_get_cur_state - callback function to get the current cooling state.
+ * cpufreq_get_cur - callback function to get the current cooling state/power.
  * @cdev: thermal cooling device pointer.
- * @state: fill this variable with the current cooling state.
- * @unit: the units in which state should be in
+ * @val: fill this variable with the current cooling state/power.
+ * @unit: whether to put state or power in @val.
  *
  * Callback for the thermal cooling device to return the cpufreq
- * current cooling state.  Currently only THERMAL_UNIT_STATE is valid
- * for @unit.
+ * current cooling state/power.  If @unit is THERMAL_UNIT_STATE, @val
+ * contains the current cooling state; if @unit is THERMAL_UNIT_POWER,
+ * @val is current power consumption in milliwatts.
  *
  * Return: 0 on success, an error code otherwise.
  */
-static int cpufreq_get_cur_state(struct thermal_cooling_device *cdev,
-				 unsigned long *state,

drivers/thermal/cpu_cooling.c +29 -9

+		int cpu;
+		u32 total_load = 0, raw_cpu_power, power = 0;
+
+		raw_cpu_power = cpu_freq_to_power(cpufreq_device,
+						cpufreq_device->freq);
+
+		for_each_cpu(cpu, &cpufreq_device->allowed_cpus) {
+			u32 load;
 
-	*state = cpufreq_device->cpufreq_state;
+			if (!cpu_online(cpu))
+				continue;
+
+			load = get_load(cpufreq_device, cpu);
+			power += (raw_cpu_power * load) / 100;
+			total_load += load;
+		}
+
+		cpufreq_device->last_load = total_load;
+		*val = power;
+	} else if (unit == THERMAL_UNIT_STATE) {
+		*val = cpufreq_device->cpufreq_state;
+	} else {
+		return -EINVAL;
+	}
 
 	return 0;
 }
 
 /**
- * cpufreq_set_cur_state - callback function to set the current cooling state.
+ * cpufreq_set_cur - callback function to set the current cooling state/power.
  * @cdev: thermal cooling device pointer.
- * @state: set this variable to the current cooling state.
- * @unit: the units in which @state should be in.
+ * @val: set this variable to the current cooling state/power.
+ * @unit: whether @val is a cooling state or power.
  *
  * Callback for the thermal cooling device to change the cpufreq
- * current cooling state.  Currently only THERMAL_UNIT_STATE is valid for
- * @unit.
+ * current cooling state/power.  If @unit is THERMAL_UNIT_STATE, @val
+ * is a cooling state; if @unit is THERMAL_UNIT_POWER, @val is the target
+ * power consumption in milliwatts.
  *
  * Return: 0 on success, an error code otherwise.
  */
-static int cpufreq_set_cur_state(struct thermal_cooling_device *cdev,
-				 unsigned long state,
-				 enum thermal_cooling_unit unit)

drivers/thermal/cpu_cooling.c +55 -3

+		unsigned int cpu, freq;
+		u32 normalised_power, last_load;
+
+		cpu = cpumask_any(&cpufreq_device->allowed_cpus);
+		last_load = cpufreq_device->last_load ?
+			cpufreq_device->last_load : 1;
+		normalised_power = (val * 100) / last_load;
+		freq = cpu_power_to_freq(cpufreq_device, normalised_power);
+
+		state = cpufreq_cooling_get_level(cpu, freq);
+		if (state == THERMAL_CSTATE_INVALID) {
+			pr_err("Failed to convert %dKHz for cpu %d into a cdev state\n",
+				freq, cpu);
+			return -EINVAL;
+		}
+	} else if (unit == THERMAL_UNIT_STATE) {
+		state = val;
+	} else {
 		return -EINVAL;
+	}
 
 	return cpufreq_apply_cooling(cpufreq_device, state);
 }
 
 /* Bind cpufreq callbacks to thermal cooling device ops */
 static struct thermal_cooling_device_ops const cpufreq_cooling_ops = {
-	.get_max = cpufreq_get_max_state,
-	.get_cur = cpufreq_get_cur_state,
-	.set_cur = cpufreq_set_cur_state,
+	.get_max = cpufreq_get_max,
+	.get_cur = cpufreq_get_cur,
+	.set_cur = cpufreq_set_cur,
 };
 
 /* Notifier for cpufreq policy change */

@@ -441,10 +622,95 @@ static struct notifier_block thermal_cpufreq_notifier_block = {
 	.notifier_call = cpufreq_thermal_notifier,
 };
 
+/* Notifier for cpufreq frequency changes */
+struct notifier_block cpufreq_transition_notifier = {
+	.notifier_call = cpufreq_frequency_change,
+};
+
+/**
+ * build_cpu_power_table - create a power to frequency table
+ * @cpufreq_dev:	the cpufreq_cooling_device in which to store the table
+ *
+ * Build a power to frequency table for this cpu and store it in
+ * @cpufreq_dev.  This table will be used in cpu_power_to_freq() and
+ * cpu_freq_to_power() to convert between power and frequency
+ * efficiently.  Power is stored in mW, frequency in KHz.  The
+ * resulting table is in ascending order.
+ *
+ * Returns 0 on success, -E* on error.
+ */
+static int build_cpu_power_table(struct cpufreq_cooling_device *cpufreq_dev)
+{
+	struct dev_pm_opp *opp;
+	struct device *dev = NULL;
+	int num_opps, cpu, i, ret = 0;
+	unsigned long freq;
+
+	num_opps = 0;
+
+	rcu_read_lock();
+
+	for_each_cpu(cpu, &cpufreq_dev->allowed_cpus) {
+		dev = get_cpu_device(cpu);
+		if (!dev)
+			continue;
+

drivers/thermal/cpu_cooling.c +10 -0

+		ret = -EINVAL;
+		goto unlock;
+	}
+
+	i = 0;
+	for (freq = 0;
+	     opp = dev_pm_opp_find_freq_ceil(dev, &freq), !IS_ERR(opp);
+	     freq++) {
+		u32 freq_mhz, voltage_mv;
+		u64 power;

drivers/thermal/cpu_cooling.c +62 -3

+		do_div(power, 1000000000);
+
+		/* frequency is stored in power_table in KHz */
+		cpufreq_dev->power_table[i].frequency = freq / 1000;
+		cpufreq_dev->power_table[i].power = power;
+
+		i++;
+	}
+
+	if (i == 0) {
+		ret = PTR_ERR(opp);
+		goto unlock;
+	}
+
+	cpufreq_dev->power_table_entries = i;
+
+unlock:
+	rcu_read_unlock();
+	return ret;
+}
+
 /**
  * __cpufreq_cooling_register - helper function to create cpufreq cooling device
  * @np: a valid struct device_node to the cooling device device tree node
  * @clip_cpus: cpumask of cpus where the frequency constraints will happen.
+ * @capacitance: dynamic power coefficient for these cpus
  *
  * This interface function registers the cpufreq cooling device with the name
  * "thermal-cpufreq-%x". This api can support multiple instances of cpufreq

@@ -456,7 +722,7 @@ static struct notifier_block thermal_cpufreq_notifier_block = {
  */
 static struct thermal_cooling_device *
 __cpufreq_cooling_register(struct device_node *np,
-			   const struct cpumask *clip_cpus)
+			const struct cpumask *clip_cpus, u32 capacitance)
 {
 	struct thermal_cooling_device *cool_dev;
 	struct cpufreq_cooling_device *cpufreq_dev = NULL;

@@ -485,6 +751,7 @@ __cpufreq_cooling_register(struct device_node *np,
 		return ERR_PTR(-ENOMEM);
 
 	cpumask_copy(&cpufreq_dev->allowed_cpus, clip_cpus);
+	cpufreq_dev->capacitance = capacitance;
 
 	ret = get_idr(&cpufreq_idr, &cpufreq_dev->id);
 	if (ret) {

@@ -531,7 +798,7 @@ __cpufreq_cooling_register(struct device_node *np,
 struct thermal_cooling_device *
 cpufreq_cooling_register(const struct cpumask *clip_cpus)
 {
-	return __cpufreq_cooling_register(NULL, clip_cpus);
+	return __cpufreq_cooling_register(NULL, clip_cpus, 0);
 }
 EXPORT_SYMBOL_GPL(cpufreq_cooling_register);
 

@@ -555,11 +822,90 @@ of_cpufreq_cooling_register(struct device_node *np,
 	if (!np)
 		return ERR_PTR(-EINVAL);
 
-	return __cpufreq_cooling_register(np, clip_cpus);
+	return __cpufreq_cooling_register(np, clip_cpus, 0);
 }
 EXPORT_SYMBOL_GPL(of_cpufreq_cooling_register);
 
 /**
+ * of_cpufreq_power_actor_register - function to create a cpu cooling device with power capabilities
+ * @np:		a valid struct device_node to the cooling device tree node
+ * @clip_cpus:	cpumask of cpus where the frequency constraints will happen
+ * @capacitance:	the dynamic power coefficient for these cpus
+ *
+ * Similar to of_cpufreq_cooling_register() this function registers a
+ * cooling device linked to the device tree node provided.  It has a
+ * simple power model so that get_cur/get_max/set_cur can operate with
+ * THERMAL_UNIT_POWER
+ *
+ * The cpus must have registered their OPPs in the OPP library.
+ *
+ * Return: a valid struct thermal_cooling_device pointer on success,
+ * on failure, it returns a corresponding ERR_PTR().
+ */
+struct thermal_cooling_device *
+of_cpufreq_power_actor_register(struct device_node *np,
+				const struct cpumask *clip_cpus,
+				u32 capacitance)
+{
+	struct thermal_cooling_device *cdev, *err_ret;
+	int ret;
+
+	cdev = __cpufreq_cooling_register(np, clip_cpus, capacitance);
+	if (IS_ERR(cdev))
+		return cdev;
+
+	ret = build_cpu_power_table(cdev->devdata);
+	if (ret) {
+		err_ret = ERR_PTR(ret);
+		goto unregister;
+	}
+
+	/*
+	 * You can't register multiple times the same notifier_block.
+	 * The first power actor registered is the only one that

drivers/thermal/cpu_cooling.c +12 -0

+
+/**
+ * cpufreq_power_actor_register - function to create a cpu cooling device with power capabilities
+ * @clip_cpus:	cpumask of cpus where the frequency constraints will happen
+ * @capacitance:	the dynamic power coefficient for these cpus
+ *
+ * Similar to cpufreq_cooling_register() this function registers a
+ * cpufreq cooling device that has a simple power model so that
+ * get_cur/get_max/set_cur can operate with THERMAL_UNIT_POWER.
+ *
+ * See of_cpufreq_power_actor_register() for notes about the
+ * requisites for this to work.

drivers/thermal/cpu_cooling.c +2 -0

+
+/**
  * cpufreq_cooling_unregister - function to remove cpufreq cooling device.
  * @cdev: thermal cooling device pointer.
  *

drivers/thermal/thermal_core.c +2 -2

index 5b46603cc7cd..1efaadf436fa 100644
@@ -50,10 +50,10 @@ static DEFINE_IDR(thermal_cdev_idr);
 static DEFINE_MUTEX(thermal_idr_lock);
 
 static LIST_HEAD(thermal_tz_list);
-static LIST_HEAD(thermal_cdev_list);
+LIST_HEAD(thermal_cdev_list);
 static LIST_HEAD(thermal_governor_list);
 
-static DEFINE_MUTEX(thermal_list_lock);
+DEFINE_MUTEX(thermal_list_lock);
 static DEFINE_MUTEX(thermal_governor_lock);
 
 static struct thermal_governor *def_governor;

include/linux/cpu_cooling.h +28 -0

index c303d383def1..b8d92ac4266b 100644
@@ -36,6 +36,9 @@
 struct thermal_cooling_device *
 cpufreq_cooling_register(const struct cpumask *clip_cpus);
 
+struct thermal_cooling_device *
+cpufreq_power_actor_register(const struct cpumask *clip_cpus, u32 capacitance);
+
 /**
  * of_cpufreq_cooling_register - create cpufreq cooling device based on DT.
  * @np: a valid struct device_node to the cooling device device tree node.

@@ -45,6 +48,11 @@ cpufreq_cooling_register(const struct cpumask *clip_cpus);
 struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct device_node *np,
 			    const struct cpumask *clip_cpus);
+
+struct thermal_cooling_device *
+of_cpufreq_power_actor_register(struct device_node *np,
+				const struct cpumask *clip_cpus,
+				u32 capacitance);
 #else
 static inline struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct device_node *np,

@@ -52,6 +60,14 @@ of_cpufreq_cooling_register(struct device_node *np,
 {
 	return NULL;
 }
+
+static inline struct thermal_cooling_device *
+of_cpufreq_power_actor_register(struct device_node *np,
+				const struct cpumask *clip_cpus,
+				u32 capacitance);
+{
+	return ERR_PTR(-ENOSYS);
+}
 #endif
 
 /**

@@ -73,6 +89,18 @@ of_cpufreq_cooling_register(struct device_node *np,
 {
 	return NULL;
 }
+static inline struct thermal_cooling_device *
+cpufreq_power_actor_register(const struct cpumask *clip_cpus, u32 capacitance)
+{
+	return ERR_PTR(-ENOSYS);
+}
+static inline struct thermal_cooling_device *
+of_cpufreq_power_actor_register(struct device_node *np,
+				const struct cpumask *clip_cpus,
+				u32 capacitance)
+{
+	return ERR_PTR(-ENOSYS);
+}
 static inline
 void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev)
 {

include/linux/thermal.h +4 -0

index 8d183b8255eb..5986f546ca98 100644
@@ -59,6 +59,9 @@
 #define DEFAULT_THERMAL_GOVERNOR       "user_space"
 #endif
 
+extern struct list_head thermal_cdev_list;
+extern struct mutex thermal_list_lock;
+
 struct thermal_zone_device;
 struct thermal_cooling_device;
 

@@ -108,6 +111,7 @@ enum {
 
 enum thermal_cooling_unit {
 	THERMAL_UNIT_STATE,
+	THERMAL_UNIT_POWER,
 };
 
 struct thermal_zone_device_ops {

Signature · 1 line

1.7.9.5