| Message ID | 1347946506-18449-12-git-send-email-durgadoss.r@intel.com (mailing list archive) |
|---|---|
| State | Accepted, archived |
| Headers | show |
On ?, 2012-09-18 at 11:05 +0530, Durgadoss R wrote: > This patch adds a simple step_wise governor to the > generic thermal layer. This algorithm throttles the > cooling devices in a linear fashion. If the 'trend' > is heating, it throttles by one step. And if the > thermal trend is cooling it de-throttles by one step. > > This actually moves the throttling logic from thermal_sys.c > and puts inside step_wise.c, without any change. This is > always selected as the default governor. > > Signed-off-by: Durgadoss R <durgadoss.r@intel.com> > --- > drivers/thermal/Kconfig | 7 ++ > drivers/thermal/Makefile | 1 + > drivers/thermal/step_wise.c | 194 +++++++++++++++++++++++++++++++++++++++++++ > 3 files changed, 202 insertions(+) > create mode 100644 drivers/thermal/step_wise.c > > diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig > index 2200912..9f6a3aa 100644 > --- a/drivers/thermal/Kconfig > +++ b/drivers/thermal/Kconfig > @@ -4,6 +4,7 @@ > > menuconfig THERMAL > tristate "Generic Thermal sysfs driver" > + select STEP_WISE > help > Generic Thermal Sysfs driver offers a generic mechanism for > thermal management. Usually it's made up of one or more thermal > @@ -59,3 +60,9 @@ config FAIR_SHARE > 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 if we always wants CONFIG_STEP_WISE built in, why bother to export this config option to users? IMO, something like menuconfig THERMAL tristate "Generic Thermal sysfs driver" select STEP_WISE config STEP_WISE bool depends on THERMAL is enough, SETP_WISE will always be selected. further more, we even do not need a config option for this governor, just "obj-y += step_wise.o" in Makefile. another question would be, as this governor registration function is fs_initcall(), what if a platform thermal driver is registered and gets a thermal event before this governor being registered? thanks, rui > diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile > index 30540dd..4e53c00 100644 > --- a/drivers/thermal/Makefile > +++ b/drivers/thermal/Makefile > @@ -8,3 +8,4 @@ obj-$(CONFIG_SPEAR_THERMAL) += spear_thermal.o > obj-$(CONFIG_RCAR_THERMAL) += rcar_thermal.o > obj-$(CONFIG_EXYNOS_THERMAL) += exynos_thermal.o > obj-$(CONFIG_FAIR_SHARE) += fair_share.o > +obj-$(CONFIG_STEP_WISE) += step_wise.o > diff --git a/drivers/thermal/step_wise.c b/drivers/thermal/step_wise.c > new file mode 100644 > index 0000000..3f9cfcf > --- /dev/null > +++ b/drivers/thermal/step_wise.c > @@ -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. > + */ > +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; > +} > + > +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"); -- To unsubscribe from this list: send the line "unsubscribe linux-acpi" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
SGkgUnVpLA0KDQoNCj4gLS0tLS1PcmlnaW5hbCBNZXNzYWdlLS0tLS0NCj4gRnJvbTogbGludXgt YWNwaS1vd25lckB2Z2VyLmtlcm5lbC5vcmcgW21haWx0bzpsaW51eC1hY3BpLQ0KPiBvd25lckB2 Z2VyLmtlcm5lbC5vcmddIE9uIEJlaGFsZiBPZiBaaGFuZyBSdWkNCj4gU2VudDogVHVlc2RheSwg U2VwdGVtYmVyIDE4LCAyMDEyIDEyOjQ0IFBNDQo+IFRvOiBSLCBEdXJnYWRvc3MNCj4gQ2M6IGxl bmJAa2VybmVsLm9yZzsgbGludXgtYWNwaUB2Z2VyLmtlcm5lbC5vcmc7IGVkdWFyZG8udmFsZW50 aW5AdGkuY29tDQo+IFN1YmplY3Q6IFJlOiBbUEFUQ0h2NCAxMS8xNV0gVGhlcm1hbDogSW50cm9k dWNlIGEgc3RlcF93aXNlIHRoZXJtYWwNCj4gZ292ZXJub3INCj4gDQo+IE9uIOS6jCwgMjAxMi0w OS0xOCBhdCAxMTowNSArMDUzMCwgRHVyZ2Fkb3NzIFIgd3JvdGU6DQo+ID4gVGhpcyBwYXRjaCBh ZGRzIGEgc2ltcGxlIHN0ZXBfd2lzZSBnb3Zlcm5vciB0byB0aGUNCj4gPiBnZW5lcmljIHRoZXJt YWwgbGF5ZXIuIFRoaXMgYWxnb3JpdGhtIHRocm90dGxlcyB0aGUNCj4gPiBjb29saW5nIGRldmlj ZXMgaW4gYSBsaW5lYXIgZmFzaGlvbi4gSWYgdGhlICd0cmVuZCcNCj4gPiBpcyBoZWF0aW5nLCBp dCB0aHJvdHRsZXMgYnkgb25lIHN0ZXAuIEFuZCBpZiB0aGUNCj4gPiB0aGVybWFsIHRyZW5kIGlz IGNvb2xpbmcgaXQgZGUtdGhyb3R0bGVzIGJ5IG9uZSBzdGVwLg0KPiA+DQo+ID4gVGhpcyBhY3R1 YWxseSBtb3ZlcyB0aGUgdGhyb3R0bGluZyBsb2dpYyBmcm9tIHRoZXJtYWxfc3lzLmMNCj4gPiBh bmQgcHV0cyBpbnNpZGUgc3RlcF93aXNlLmMsIHdpdGhvdXQgYW55IGNoYW5nZS4gVGhpcyBpcw0K PiA+IGFsd2F5cyBzZWxlY3RlZCBhcyB0aGUgZGVmYXVsdCBnb3Zlcm5vci4NCj4gPg0KPiA+IFNp Z25lZC1vZmYtYnk6IER1cmdhZG9zcyBSIDxkdXJnYWRvc3MuckBpbnRlbC5jb20+DQo+ID4gLS0t DQo+ID4gIGRyaXZlcnMvdGhlcm1hbC9LY29uZmlnICAgICB8ICAgIDcgKysNCj4gPiAgZHJpdmVy cy90aGVybWFsL01ha2VmaWxlICAgIHwgICAgMSArDQo+ID4gIGRyaXZlcnMvdGhlcm1hbC9zdGVw X3dpc2UuYyB8ICAxOTQNCj4gKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKw0KPiA+ICAzIGZpbGVzIGNoYW5nZWQsIDIwMiBpbnNlcnRpb25zKCspDQo+ID4gIGNyZWF0 ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3RoZXJtYWwvc3RlcF93aXNlLmMNCj4gPg0KPiA+IGRpZmYg LS1naXQgYS9kcml2ZXJzL3RoZXJtYWwvS2NvbmZpZyBiL2RyaXZlcnMvdGhlcm1hbC9LY29uZmln DQo+ID4gaW5kZXggMjIwMDkxMi4uOWY2YTNhYSAxMDA2NDQNCj4gPiAtLS0gYS9kcml2ZXJzL3Ro ZXJtYWwvS2NvbmZpZw0KPiA+ICsrKyBiL2RyaXZlcnMvdGhlcm1hbC9LY29uZmlnDQo+ID4gQEAg LTQsNiArNCw3IEBADQo+ID4NCj4gPiAgbWVudWNvbmZpZyBUSEVSTUFMDQo+ID4gIAl0cmlzdGF0 ZSAiR2VuZXJpYyBUaGVybWFsIHN5c2ZzIGRyaXZlciINCj4gPiArCXNlbGVjdCBTVEVQX1dJU0UN Cj4gPiAgCWhlbHANCj4gPiAgCSAgR2VuZXJpYyBUaGVybWFsIFN5c2ZzIGRyaXZlciBvZmZlcnMg YSBnZW5lcmljIG1lY2hhbmlzbSBmb3INCj4gPiAgCSAgdGhlcm1hbCBtYW5hZ2VtZW50LiBVc3Vh bGx5IGl0J3MgbWFkZSB1cCBvZiBvbmUgb3IgbW9yZSB0aGVybWFsDQo+ID4gQEAgLTU5LDMgKzYw LDkgQEAgY29uZmlnIEZBSVJfU0hBUkUNCj4gPiAgCWRlcGVuZHMgb24gVEhFUk1BTA0KPiA+ICAJ aGVscA0KPiA+ICAJICBFbmFibGUgdGhpcyB0byBtYW5hZ2UgcGxhdGZvcm0gdGhlcm1hbHMgdXNp bmcgZmFpci1zaGFyZSBnb3Zlcm5vci4NCj4gPiArDQo+ID4gK2NvbmZpZyBTVEVQX1dJU0UNCj4g PiArCWJvb2wgIlN0ZXBfd2lzZSB0aGVybWFsIGdvdmVybm9yIg0KPiA+ICsJZGVwZW5kcyBvbiBU SEVSTUFMDQo+ID4gKwloZWxwDQo+ID4gKwkgIEVuYWJsZSB0aGlzIHRvIG1hbmFnZSBwbGF0Zm9y bSB0aGVybWFscyB1c2luZyBhIHNpbXBsZSBsaW5lYXINCj4gDQo+IGlmIHdlIGFsd2F5cyB3YW50 cyBDT05GSUdfU1RFUF9XSVNFIGJ1aWx0IGluLCB3aHkgYm90aGVyIHRvIGV4cG9ydCB0aGlzDQo+ IGNvbmZpZyBvcHRpb24gdG8gdXNlcnM/DQo+IA0KPiBJTU8sIHNvbWV0aGluZyBsaWtlDQo+ICBt ZW51Y29uZmlnIFRIRVJNQUwNCj4gICAJdHJpc3RhdGUgIkdlbmVyaWMgVGhlcm1hbCBzeXNmcyBk cml2ZXIiDQo+IAlzZWxlY3QgU1RFUF9XSVNFDQo+IA0KPiAgY29uZmlnIFNURVBfV0lTRQ0KPiAJ Ym9vbA0KPiAJZGVwZW5kcyBvbiBUSEVSTUFMDQo+IA0KPiBpcyBlbm91Z2gsIFNFVFBfV0lTRSB3 aWxsIGFsd2F5cyBiZSBzZWxlY3RlZC4NCj4gDQo+IGZ1cnRoZXIgbW9yZSwgd2UgZXZlbiBkbyBu b3QgbmVlZCBhIGNvbmZpZyBvcHRpb24gZm9yIHRoaXMgZ292ZXJub3IsDQo+IGp1c3QgIm9iai15 ICs9IHN0ZXBfd2lzZS5vIiBpbiBNYWtlZmlsZS4NCg0KWWVzLCBUaG91Z2h0IHRocm91Z2ggdGhp cy4gQnV0IEkgdGhvdWdodCBpdCB3b3VsZCBiZSBnb29kIHRvIGFsaWduIHRoaXMNCndpdGggdGhl IHJlc3Qgb2YgdGhlIGdvdmVybm9ycy4NCg0KPiANCj4gYW5vdGhlciBxdWVzdGlvbiB3b3VsZCBi ZSwNCj4gYXMgdGhpcyBnb3Zlcm5vciByZWdpc3RyYXRpb24gZnVuY3Rpb24gaXMgZnNfaW5pdGNh bGwoKSwNCj4gd2hhdCBpZiBhIHBsYXRmb3JtIHRoZXJtYWwgZHJpdmVyIGlzIHJlZ2lzdGVyZWQg YW5kIGdldHMgYSB0aGVybWFsIGV2ZW50DQo+IGJlZm9yZSB0aGlzIGdvdmVybm9yIGJlaW5nIHJl Z2lzdGVyZWQ/DQoNCldvbmRlciBpZiB0aGlzIGNhbiBoYXBwZW4gd2l0aCB0aGUgY3VycmVudCBj b2RlLCBzaW5jZSB0aGUNCnRoZXJtYWxfc3lzLmMgYWxzbyBsb2FkcyB3aXRoIGZzX2luaXRjYWxs Lg0KDQpUaGFua3MsDQpEdXJnYQ0K -- To unsubscribe from this list: send the line "unsubscribe linux-acpi" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On ?, 2012-09-18 at 02:11 -0600, R, Durgadoss wrote: > Hi Rui, > > > > -----Original Message----- > > From: linux-acpi-owner@vger.kernel.org [mailto:linux-acpi- > > owner@vger.kernel.org] On Behalf Of Zhang Rui > > Sent: Tuesday, September 18, 2012 12:44 PM > > To: R, Durgadoss > > Cc: lenb@kernel.org; linux-acpi@vger.kernel.org; eduardo.valentin@ti.com > > Subject: Re: [PATCHv4 11/15] Thermal: Introduce a step_wise thermal > > governor > > > > On ?, 2012-09-18 at 11:05 +0530, Durgadoss R wrote: > > > This patch adds a simple step_wise governor to the > > > generic thermal layer. This algorithm throttles the > > > cooling devices in a linear fashion. If the 'trend' > > > is heating, it throttles by one step. And if the > > > thermal trend is cooling it de-throttles by one step. > > > > > > This actually moves the throttling logic from thermal_sys.c > > > and puts inside step_wise.c, without any change. This is > > > always selected as the default governor. > > > > > > Signed-off-by: Durgadoss R <durgadoss.r@intel.com> > > > --- > > > drivers/thermal/Kconfig | 7 ++ > > > drivers/thermal/Makefile | 1 + > > > drivers/thermal/step_wise.c | 194 > > +++++++++++++++++++++++++++++++++++++++++++ > > > 3 files changed, 202 insertions(+) > > > create mode 100644 drivers/thermal/step_wise.c > > > > > > diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig > > > index 2200912..9f6a3aa 100644 > > > --- a/drivers/thermal/Kconfig > > > +++ b/drivers/thermal/Kconfig > > > @@ -4,6 +4,7 @@ > > > > > > menuconfig THERMAL > > > tristate "Generic Thermal sysfs driver" > > > + select STEP_WISE > > > help > > > Generic Thermal Sysfs driver offers a generic mechanism for > > > thermal management. Usually it's made up of one or more thermal > > > @@ -59,3 +60,9 @@ config FAIR_SHARE > > > 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 > > > > if we always wants CONFIG_STEP_WISE built in, why bother to export this > > config option to users? > > > > IMO, something like > > menuconfig THERMAL > > tristate "Generic Thermal sysfs driver" > > select STEP_WISE > > > > config STEP_WISE > > bool > > depends on THERMAL > > > > is enough, SETP_WISE will always be selected. > > > > further more, we even do not need a config option for this governor, > > just "obj-y += step_wise.o" in Makefile. > > Yes, Thought through this. But I thought it would be good to align this > with the rest of the governors. > we'd better follow cpufreq governor to allow users to select the default governor, or else this configure option is needless because we never want it to be cleared with CONFIG_THERMAL=y. > > > > another question would be, > > as this governor registration function is fs_initcall(), > > what if a platform thermal driver is registered and gets a thermal event > > before this governor being registered? > > Wonder if this can happen with the current code, since the > thermal_sys.c also loads with fs_initcall. > you're right. this is not a problem. thanks, rui -- To unsubscribe from this list: send the line "unsubscribe linux-acpi" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi Rui, > -----Original Message----- > From: Zhang, Rui > Sent: Tuesday, September 18, 2012 1:52 PM > To: R, Durgadoss > Cc: lenb@kernel.org; linux-acpi@vger.kernel.org; eduardo.valentin@ti.com > Subject: RE: [PATCHv4 11/15] Thermal: Introduce a step_wise thermal > governor > > On ?, 2012-09-18 at 02:11 -0600, R, Durgadoss wrote: > > Hi Rui, > > > > > > > -----Original Message----- > > > From: linux-acpi-owner@vger.kernel.org [mailto:linux-acpi- > > > owner@vger.kernel.org] On Behalf Of Zhang Rui > > > Sent: Tuesday, September 18, 2012 12:44 PM > > > To: R, Durgadoss > > > Cc: lenb@kernel.org; linux-acpi@vger.kernel.org; > eduardo.valentin@ti.com > > > Subject: Re: [PATCHv4 11/15] Thermal: Introduce a step_wise thermal > > > governor > > > > > > On ?, 2012-09-18 at 11:05 +0530, Durgadoss R wrote: > > > > This patch adds a simple step_wise governor to the > > > > generic thermal layer. This algorithm throttles the > > > > cooling devices in a linear fashion. If the 'trend' > > > > is heating, it throttles by one step. And if the > > > > thermal trend is cooling it de-throttles by one step. > > > > > > > > This actually moves the throttling logic from thermal_sys.c > > > > and puts inside step_wise.c, without any change. This is > > > > always selected as the default governor. > > > > > > > > Signed-off-by: Durgadoss R <durgadoss.r@intel.com> > > > > --- > > > > drivers/thermal/Kconfig | 7 ++ > > > > drivers/thermal/Makefile | 1 + > > > > drivers/thermal/step_wise.c | 194 > > > +++++++++++++++++++++++++++++++++++++++++++ > > > > 3 files changed, 202 insertions(+) > > > > create mode 100644 drivers/thermal/step_wise.c > > > > > > > > diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig > > > > index 2200912..9f6a3aa 100644 > > > > --- a/drivers/thermal/Kconfig > > > > +++ b/drivers/thermal/Kconfig > > > > @@ -4,6 +4,7 @@ > > > > > > > > menuconfig THERMAL > > > > tristate "Generic Thermal sysfs driver" > > > > + select STEP_WISE > > > > help > > > > Generic Thermal Sysfs driver offers a generic mechanism for > > > > thermal management. Usually it's made up of one or more thermal > > > > @@ -59,3 +60,9 @@ config FAIR_SHARE > > > > 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 > > > > > > if we always wants CONFIG_STEP_WISE built in, why bother to export > this > > > config option to users? > > > > > > IMO, something like > > > menuconfig THERMAL > > > tristate "Generic Thermal sysfs driver" > > > select STEP_WISE > > > > > > config STEP_WISE > > > bool > > > depends on THERMAL > > > > > > is enough, SETP_WISE will always be selected. > > > > > > further more, we even do not need a config option for this governor, > > > just "obj-y += step_wise.o" in Makefile. > > > > Yes, Thought through this. But I thought it would be good to align this > > with the rest of the governors. > > > > we'd better follow cpufreq governor to allow users to select the default > governor, or else this configure option is needless because we never > want it to be cleared with CONFIG_THERMAL=y. I would prefer not to give any configure option, which exactly is our old behavior. In this case, you want me to fix it and re-send 11/15 or you are reviewing and should I wait for comments on other patches ? Thanks, Durga
diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig index 2200912..9f6a3aa 100644 --- a/drivers/thermal/Kconfig +++ b/drivers/thermal/Kconfig @@ -4,6 +4,7 @@ menuconfig THERMAL tristate "Generic Thermal sysfs driver" + select STEP_WISE help Generic Thermal Sysfs driver offers a generic mechanism for thermal management. Usually it's made up of one or more thermal @@ -59,3 +60,9 @@ config FAIR_SHARE 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 diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile index 30540dd..4e53c00 100644 --- a/drivers/thermal/Makefile +++ b/drivers/thermal/Makefile @@ -8,3 +8,4 @@ obj-$(CONFIG_SPEAR_THERMAL) += spear_thermal.o obj-$(CONFIG_RCAR_THERMAL) += rcar_thermal.o obj-$(CONFIG_EXYNOS_THERMAL) += exynos_thermal.o obj-$(CONFIG_FAIR_SHARE) += fair_share.o +obj-$(CONFIG_STEP_WISE) += step_wise.o diff --git a/drivers/thermal/step_wise.c b/drivers/thermal/step_wise.c new file mode 100644 index 0000000..3f9cfcf --- /dev/null +++ b/drivers/thermal/step_wise.c @@ -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. + */ +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; +} + +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");
This patch adds a simple step_wise governor to the generic thermal layer. This algorithm throttles the cooling devices in a linear fashion. If the 'trend' is heating, it throttles by one step. And if the thermal trend is cooling it de-throttles by one step. This actually moves the throttling logic from thermal_sys.c and puts inside step_wise.c, without any change. This is always selected as the default governor. Signed-off-by: Durgadoss R <durgadoss.r@intel.com> --- drivers/thermal/Kconfig | 7 ++ drivers/thermal/Makefile | 1 + drivers/thermal/step_wise.c | 194 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 202 insertions(+) create mode 100644 drivers/thermal/step_wise.c