* Re: Plumbers: PM constraints micro-conf RFP
From: mark gross @ 2012-05-14 13:35 UTC (permalink / raw)
To: Antti P Miettinen
Cc: Kevin Hilman, Agarwal, Ramesh, markgross, paulmck, pdeschrijver,
Praveen Chidambaram, Amit Kucheria, John Stultz, linux-pm,
jeen.pihet
In-Reply-To: <87vcjz6tli.fsf@amiettinen-lnx.nvidia.com>
On Mon, May 14, 2012 at 11:43:21AM +0300, Antti P Miettinen wrote:
> mark gross <markgross@thegnar.org> writes:
> > I forgot to make clear a few things specific to the Plumbers conference.
> > 1) they need proposals by mid may
> > 2) if you want financial assistance to be part of this micro-conf you
> > need to ask the conference committee and I think I need to recommend you
> > as an important participant. --- Paul, can you clarify this?
> >
> > If we don't get a critical mass as determined by the conference
> > committee we can try again / do more stuff over email. BTW we should be
> > doing more of anyway.
> >
> > --mark
>
> Not being familiar with LPC format - does LPC expect just a presentation
> or should there be also a "paper"? I just registered a blueprint at
>
> https://blueprints.launchpad.net/lpc/+spec/lpc2012-cf-tegra
>
> Is the format OK for a proposal?
That looks good to me. But, Paul would be right person to confirm.
Please be sure to give equal time to the problem statement as well as
your implementation in the presentation. Depending on time constraints,
TBD, you may need to trim back on the talk or not.
The time per talk depends on how much participation we get.
--mark
^ permalink raw reply
* Re: Plumbers: PM constraints micro-conf RFP
From: Antti P Miettinen @ 2012-05-14 8:43 UTC (permalink / raw)
To: markgross
Cc: Kevin Hilman, Agarwal, Ramesh, paulmck, pdeschrijver,
Praveen Chidambaram, Amit Kucheria, John Stultz, linux-pm,
jeen.pihet
In-Reply-To: <20120504141618.GC15928@G62>
mark gross <markgross@thegnar.org> writes:
> I forgot to make clear a few things specific to the Plumbers conference.
> 1) they need proposals by mid may
> 2) if you want financial assistance to be part of this micro-conf you
> need to ask the conference committee and I think I need to recommend you
> as an important participant. --- Paul, can you clarify this?
>
> If we don't get a critical mass as determined by the conference
> committee we can try again / do more stuff over email. BTW we should be
> doing more of anyway.
>
> --mark
Not being familiar with LPC format - does LPC expect just a presentation
or should there be also a "paper"? I just registered a blueprint at
https://blueprints.launchpad.net/lpc/+spec/lpc2012-cf-tegra
Is the format OK for a proposal?
--Antti
^ permalink raw reply
* Re: 3.3.5 regression: resume doesn't switch to X
From: David Miller @ 2012-05-13 20:08 UTC (permalink / raw)
To: jslaby
Cc: jirislaby, greg, linux-kernel, stable, alexander.deucher,
sedat.dilek, linux-pm
In-Reply-To: <4FB0122E.4000603@suse.cz>
From: Jiri Slaby <jslaby@suse.cz>
Date: Sun, 13 May 2012 21:57:34 +0200
> On 05/12/2012 05:43 PM, Greg KH wrote:
>> On Sat, May 12, 2012 at 09:17:28AM +0200, Jiri Slaby wrote:
>>> Hi,
>>
>> <side note, it's stable@vger.kernel.org, not stable@kernel.org>
>
> Ah, fixed. Why it didn't bounce? Is it silently dropped?
vger.kernel.org kills it because it looks like SPAM or a looping
posting since it has Delivered-To: header fields in it when the
copy comes from stable@kernel.org
The kernel.org folks needs to really just take that email alias
down and turn it off, nothing from it makes the list for almost
a year now. It's completely pointless.
^ permalink raw reply
* Re: 3.3.5 regression: resume doesn't switch to X
From: Jiri Slaby @ 2012-05-13 19:57 UTC (permalink / raw)
To: Greg KH
Cc: Jiri Slaby, Linux kernel mailing list, stable, alexander.deucher,
sedat.dilek@gmail.com, linux-pm
In-Reply-To: <20120512154307.GA6023@kroah.com>
On 05/12/2012 05:43 PM, Greg KH wrote:
> On Sat, May 12, 2012 at 09:17:28AM +0200, Jiri Slaby wrote:
>> Hi,
>
> <side note, it's stable@vger.kernel.org, not stable@kernel.org>
Ah, fixed. Why it didn't bounce? Is it silently dropped?
>> since update to 3.3.5, my X doesn't show up after resume from
>> hibernation anymore. The only thing I see is "resuming..." on the
>> console. I can switch to any tty and login in text mode, but cannot
>> switch to X despite it is running. I have to restart whole session to
>> have X again.
>>
>> Now I'm back to 3.3.4 and everything is OK.
>
> Care to run 'git bisect' to find the offending patch?
Hmm, I cannot reproduce. I booted 3.3.5 twice and X did not show up
after resume. Then I booted 3.3.4 and it worked. Now 3.3.5 works too...
So maybe this is uptime related or I hit some race twice in a row?
Anyway now I'm running 3.3.5 and the problem have not recurred yet...
thanks,
--
js
suse labs
^ permalink raw reply
* Re: 3.3.5 regression: resume doesn't switch to X
From: Greg KH @ 2012-05-12 15:43 UTC (permalink / raw)
To: Jiri Slaby; +Cc: linux-pm, Linux kernel mailing list, stable, Jiri Slaby
In-Reply-To: <4FAE0E88.2030703@suse.cz>
On Sat, May 12, 2012 at 09:17:28AM +0200, Jiri Slaby wrote:
> Hi,
<side note, it's stable@vger.kernel.org, not stable@kernel.org>
> since update to 3.3.5, my X doesn't show up after resume from
> hibernation anymore. The only thing I see is "resuming..." on the
> console. I can switch to any tty and login in text mode, but cannot
> switch to X despite it is running. I have to restart whole session to
> have X again.
>
> Now I'm back to 3.3.4 and everything is OK.
Care to run 'git bisect' to find the offending patch?
thanks,
greg k-h
^ permalink raw reply
* Re: [PATCH v4 2/5] hwmon: exynos4: Move thermal sensor driver to driver/thermal directory
From: Guenter Roeck @ 2012-05-12 15:38 UTC (permalink / raw)
To: Amit Daniel Kachhap
Cc: linux-pm@lists.linux-foundation.org, akpm@linux-foundation.org,
linux-samsung-soc@vger.kernel.org, linux-kernel@vger.kernel.org,
durgadoss.r@intel.com, lenb@kernel.org, rui.zhang@intel.com,
linux-acpi@vger.kernel.org, linaro-dev@lists.linaro.org,
lm-sensors@lm-sensors.org, khali@linux-fr.org, patches@linaro.org
In-Reply-To: <1336815645-29625-3-git-send-email-amit.kachhap@linaro.org>
On Sat, May 12, 2012 at 05:40:42AM -0400, Amit Daniel Kachhap wrote:
> This movement is needed because the hwmon entries and corresponding
> sysfs interface is a duplicate of utilities already provided by
> driver/thermal/thermal_sys.c. The goal is to place it in thermal folder
> and add necessary functions to use the in-kernel thermal interfaces.
>
> CC: Guenter Roeck <guenter.roeck@ericsson.com>
> Signed-off-by: Amit Daniel Kachhap <amit.kachhap@linaro.org>
> Signed-off-by: Donggeun Kim <dg77.kim@samsung.com>
Acked-by: Guenter Roeck <guenter.roeck@ericsson.com>
Some suggestions, possibly for later cleanup.
> -
> - data = kzalloc(sizeof(struct exynos4_tmu_data), GFP_KERNEL);
If you use devm_kzalloc, you won't have to free it.
[ ...]
> - data->mem = request_mem_region(data->mem->start,
> - resource_size(data->mem), pdev->name);
Same here, with devm_request_mem_region.
[ ... ]
> - data->base = ioremap(data->mem->start, resource_size(data->mem));
and devm_ioremap
[ ... ]
> - ret = request_irq(data->irq, exynos4_tmu_irq,
and devm_request_irq
Guenter
^ permalink raw reply
* [PATCH v4 5/5] ARM: exynos: Add thermal sensor driver platform data support
From: Amit Daniel Kachhap @ 2012-05-12 9:40 UTC (permalink / raw)
To: linux-pm-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA,
akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b
Cc: linux-samsung-soc-u79uwXL29TY76Z2rM5mHXA,
durgadoss.r-ral2JQCrhuEAvxtiuMwx3w,
patches-QSEj5FYQhm4dnm+yROfE0A,
linux-kernel-u79uwXL29TY76Z2rM5mHXA,
lm-sensors-GZX6beZjE8VD60Wz+7aTrA,
linux-acpi-u79uwXL29TY76Z2rM5mHXA, khali-PUYAD+kWke1g9hUCZPvPmw,
linaro-dev-cunTk1MwBs8s++Sfvej+rw,
rui.zhang-ral2JQCrhuEAvxtiuMwx3w,
guenter.roeck-IzeFyvvaP7pWk0Htik3J/w, lenb-DgEjT+Ai2ygdnm+yROfE0A
In-Reply-To: <1336815645-29625-1-git-send-email-amit.kachhap-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org>
This patch adds necessary default platform data support needed for TMU driver.
This dt/non-dt values are tested for origen exynos4210 and smdk exynos5250 platforms.
Signed-off-by: Amit Daniel Kachhap <amit.kachhap-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org>
---
drivers/thermal/exynos_thermal.c | 111 +++++++++++++++++++++++++++++++++++++-
1 files changed, 110 insertions(+), 1 deletions(-)
diff --git a/drivers/thermal/exynos_thermal.c b/drivers/thermal/exynos_thermal.c
index 48106d8..e4e6759 100644
--- a/drivers/thermal/exynos_thermal.c
+++ b/drivers/thermal/exynos_thermal.c
@@ -662,14 +662,121 @@ static irqreturn_t exynos_tmu_irq(int irq, void *id)
static struct thermal_sensor_conf exynos_sensor_conf = {
.name = "exynos-therm",
.read_temperature = (int (*)(void *))exynos_tmu_read,
+};
+
+#if defined(CONFIG_CPU_EXYNOS4210)
+static struct exynos_tmu_platform_data const exynos4_default_tmu_data = {
+ .threshold = 80,
+ .trigger_levels[0] = 5,
+ .trigger_levels[1] = 20,
+ .trigger_levels[2] = 30,
+ .trigger_level0_en = 1,
+ .trigger_level1_en = 1,
+ .trigger_level2_en = 1,
+ .trigger_level3_en = 0,
+ .gain = 15,
+ .reference_voltage = 7,
+ .cal_type = TYPE_ONE_POINT_TRIMMING,
+ .freq_tab[0] = {
+ .freq_clip_max = 800 * 1000,
+ .temp_level = 85,
+ },
+ .freq_tab[1] = {
+ .freq_clip_max = 200 * 1000,
+ .temp_level = 100,
+ },
+ .freq_tab_count = 2,
+ .type = SOC_ARCH_EXYNOS4,
+};
+#define EXYNOS4_TMU_DRV_DATA (&exynos4_default_tmu_data)
+#else
+#define EXYNOS4_TMU_DRV_DATA (NULL)
+#endif
+
+#if defined(CONFIG_SOC_EXYNOS5250)
+static struct exynos_tmu_platform_data const exynos5_default_tmu_data = {
+ .trigger_levels[0] = 85,
+ .trigger_levels[1] = 103,
+ .trigger_levels[2] = 110,
+ .trigger_level0_en = 1,
+ .trigger_level1_en = 1,
+ .trigger_level2_en = 1,
+ .trigger_level3_en = 0,
+ .gain = 8,
+ .reference_voltage = 16,
+ .noise_cancel_mode = 4,
+ .cal_type = TYPE_ONE_POINT_TRIMMING,
+ .efuse_value = 55,
+ .freq_tab[0] = {
+ .freq_clip_max = 800 * 1000,
+ .temp_level = 85,
+ },
+ .freq_tab[1] = {
+ .freq_clip_max = 200 * 1000,
+ .temp_level = 103,
+ },
+ .freq_tab_count = 2,
+ .type = SOC_ARCH_EXYNOS5,
+};
+#define EXYNOS5_TMU_DRV_DATA (&exynos5_default_tmu_data)
+#else
+#define EXYNOS5_TMU_DRV_DATA (NULL)
+#endif
+
+#ifdef CONFIG_OF
+static const struct of_device_id exynos_tmu_match[] = {
+ {
+ .compatible = "samsung,exynos4-tmu",
+ .data = (void *)EXYNOS4_TMU_DRV_DATA,
+ },
+ {
+ .compatible = "samsung,exynos5-tmu",
+ .data = (void *)EXYNOS5_TMU_DRV_DATA,
+ },
+ {},
+};
+MODULE_DEVICE_TABLE(of, exynos_tmu_match);
+#else
+#define exynos_tmu_match NULL
+#endif
+
+static struct platform_device_id exynos_tmu_driver_ids[] = {
+ {
+ .name = "exynos4-tmu",
+ .driver_data = (kernel_ulong_t)EXYNOS4_TMU_DRV_DATA,
+ },
+ {
+ .name = "exynos5-tmu",
+ .driver_data = (kernel_ulong_t)EXYNOS5_TMU_DRV_DATA,
+ },
+ { },
+};
+MODULE_DEVICE_TABLE(platform, exynos4_tmu_driver_ids);
+
+static inline struct exynos_tmu_platform_data *exynos_get_driver_data(
+ struct platform_device *pdev)
+{
+#ifdef CONFIG_OF
+ if (pdev->dev.of_node) {
+ const struct of_device_id *match;
+ match = of_match_node(exynos_tmu_match, pdev->dev.of_node);
+ if (!match)
+ return NULL;
+ return (struct exynos_tmu_platform_data *) match->data;
+ }
+#endif
+ return (struct exynos_tmu_platform_data *)
+ platform_get_device_id(pdev)->driver_data;
}
-;
static int __devinit exynos_tmu_probe(struct platform_device *pdev)
{
struct exynos_tmu_data *data;
struct exynos_tmu_platform_data *pdata = pdev->dev.platform_data;
int ret, i;
+ if (!pdata)
+ pdata = exynos_get_driver_data(pdev);
+
if (!pdata) {
dev_err(&pdev->dev, "No platform init data supplied.\n");
return -ENODEV;
@@ -832,11 +939,13 @@ static struct platform_driver exynos_tmu_driver = {
.driver = {
.name = "exynos-tmu",
.owner = THIS_MODULE,
+ .of_match_table = exynos_tmu_match,
},
.probe = exynos_tmu_probe,
.remove = __devexit_p(exynos_tmu_remove),
.suspend = exynos_tmu_suspend,
.resume = exynos_tmu_resume,
+ .id_table = exynos_tmu_driver_ids,
};
module_platform_driver(exynos_tmu_driver);
--
1.7.1
^ permalink raw reply related
* [PATCH v4 4/5] thermal: exynos: Register the tmu sensor with the kernel thermal layer
From: Amit Daniel Kachhap @ 2012-05-12 9:40 UTC (permalink / raw)
To: linux-pm-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA,
akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b
Cc: linux-samsung-soc-u79uwXL29TY76Z2rM5mHXA,
durgadoss.r-ral2JQCrhuEAvxtiuMwx3w,
patches-QSEj5FYQhm4dnm+yROfE0A,
linux-kernel-u79uwXL29TY76Z2rM5mHXA,
lm-sensors-GZX6beZjE8VD60Wz+7aTrA,
linux-acpi-u79uwXL29TY76Z2rM5mHXA, khali-PUYAD+kWke1g9hUCZPvPmw,
linaro-dev-cunTk1MwBs8s++Sfvej+rw,
rui.zhang-ral2JQCrhuEAvxtiuMwx3w,
guenter.roeck-IzeFyvvaP7pWk0Htik3J/w, lenb-DgEjT+Ai2ygdnm+yROfE0A
In-Reply-To: <1336815645-29625-1-git-send-email-amit.kachhap-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org>
This code added creates a link between temperature sensors, linux thermal
framework and cooling devices for samsung exynos platform. This layer
monitors the temperature from the sensor and informs the generic thermal
layer to take the necessary cooling action.
Signed-off-by: Amit Daniel Kachhap <amit.kachhap-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org>
---
drivers/thermal/exynos_thermal.c | 344 +++++++++++++++++++++++++-
include/linux/platform_data/exynos_thermal.h | 6 +
2 files changed, 348 insertions(+), 2 deletions(-)
diff --git a/drivers/thermal/exynos_thermal.c b/drivers/thermal/exynos_thermal.c
index cfe4aeb..48106d8 100644
--- a/drivers/thermal/exynos_thermal.c
+++ b/drivers/thermal/exynos_thermal.c
@@ -35,6 +35,9 @@
#include <linux/mutex.h>
#include <linux/err.h>
#include <linux/platform_data/exynos_thermal.h>
+#include <linux/thermal.h>
+#include <linux/cpufreq.h>
+#include <linux/cpu_cooling.h>
#include <linux/of.h>
#include <plat/cpu.h>
@@ -95,6 +98,7 @@
#define ACTIVE_INTERVAL 500
#define IDLE_INTERVAL 10000
+#define MCELSIUS 1000
/* CPU Zone information */
#define PANIC_ZONE 4
@@ -105,6 +109,8 @@
#define GET_ZONE(trip) (trip + 2)
#define GET_TRIP(zone) (zone - 2)
+#define EXYNOS_ZONE_COUNT 3
+
struct exynos_tmu_data {
struct exynos_tmu_platform_data *pdata;
struct resource *mem;
@@ -117,6 +123,309 @@ struct exynos_tmu_data {
u8 temp_error1, temp_error2;
};
+struct thermal_trip_point_conf {
+ int trip_val[MAX_TRIP_COUNT];
+ int trip_count;
+};
+
+struct thermal_cooling_conf {
+ struct freq_clip_table freq_data[MAX_TRIP_COUNT];
+ int freq_clip_count;
+};
+
+struct thermal_sensor_conf {
+ char name[SENSOR_NAME_LEN];
+ int (*read_temperature)(void *data);
+ struct thermal_trip_point_conf trip_data;
+ struct thermal_cooling_conf cooling_data;
+ void *private_data;
+};
+
+struct exynos_thermal_zone {
+ enum thermal_device_mode mode;
+ struct thermal_zone_device *therm_dev;
+ struct thermal_cooling_device *cool_dev[MAX_COOLING_DEVICE];
+ unsigned int cool_dev_size;
+ struct platform_device *exynos4_dev;
+ struct thermal_sensor_conf *sensor_conf;
+};
+
+static struct exynos_thermal_zone *th_zone;
+static void exynos_unregister_thermal(void);
+static int exynos_register_thermal(struct thermal_sensor_conf *sensor_conf);
+
+/* Get mode callback functions for thermal zone */
+static int exynos_get_mode(struct thermal_zone_device *thermal,
+ enum thermal_device_mode *mode)
+{
+ if (th_zone)
+ *mode = th_zone->mode;
+ return 0;
+}
+
+/* Set mode callback functions for thermal zone */
+static int exynos_set_mode(struct thermal_zone_device *thermal,
+ enum thermal_device_mode mode)
+{
+ if (!th_zone->therm_dev) {
+ pr_notice("thermal zone not registered\n");
+ return 0;
+ }
+
+ mutex_lock(&th_zone->therm_dev->lock);
+
+ if (mode == THERMAL_DEVICE_ENABLED)
+ th_zone->therm_dev->polling_delay = IDLE_INTERVAL;
+ else
+ th_zone->therm_dev->polling_delay = 0;
+
+ mutex_unlock(&th_zone->therm_dev->lock);
+
+ th_zone->mode = mode;
+ thermal_zone_device_update(th_zone->therm_dev);
+ pr_info("thermal polling set for duration=%d msec\n",
+ th_zone->therm_dev->polling_delay);
+ return 0;
+}
+
+/*
+ * This function may be called from interrupt based temperature sensor
+ * when threshold is changed.
+ */
+static void exynos_report_trigger(void)
+{
+ unsigned int i;
+ char data[10];
+ char *envp[] = { data, NULL };
+
+ if (!th_zone || !th_zone->therm_dev)
+ return;
+
+ thermal_zone_device_update(th_zone->therm_dev);
+
+ mutex_lock(&th_zone->therm_dev->lock);
+ /* Find the level for which trip happened */
+ for (i = 0; i < th_zone->sensor_conf->trip_data.trip_count; i++) {
+ if (th_zone->therm_dev->last_temperature <
+ th_zone->sensor_conf->trip_data.trip_val[i] * MCELSIUS)
+ break;
+ }
+
+ if (th_zone->mode == THERMAL_DEVICE_ENABLED) {
+ if (i > 0)
+ th_zone->therm_dev->polling_delay = ACTIVE_INTERVAL;
+ else
+ th_zone->therm_dev->polling_delay = IDLE_INTERVAL;
+ }
+
+ snprintf(data, sizeof(data), "%u", i);
+ kobject_uevent_env(&th_zone->therm_dev->device.kobj, KOBJ_CHANGE, envp);
+ mutex_unlock(&th_zone->therm_dev->lock);
+}
+
+/* Get trip type callback functions for thermal zone */
+static int exynos_get_trip_type(struct thermal_zone_device *thermal, int trip,
+ enum thermal_trip_type *type)
+{
+ switch (GET_ZONE(trip)) {
+ case MONITOR_ZONE:
+ case WARN_ZONE:
+ *type = THERMAL_TRIP_ACTIVE;
+ break;
+ case PANIC_ZONE:
+ *type = THERMAL_TRIP_CRITICAL;
+ break;
+ default:
+ return -EINVAL;
+ }
+ return 0;
+}
+
+/* Get trip temperature callback functions for thermal zone */
+static int exynos_get_trip_temp(struct thermal_zone_device *thermal, int trip,
+ unsigned long *temp)
+{
+ if (trip < GET_TRIP(MONITOR_ZONE) || trip > GET_TRIP(PANIC_ZONE))
+ return -EINVAL;
+
+ *temp = th_zone->sensor_conf->trip_data.trip_val[trip];
+ /* convert the temperature into millicelsius */
+ *temp = *temp * MCELSIUS;
+
+ return 0;
+}
+
+/* Get critical temperature callback functions for thermal zone */
+static int exynos_get_crit_temp(struct thermal_zone_device *thermal,
+ unsigned long *temp)
+{
+ int ret;
+ /* Panic zone */
+ ret = exynos_get_trip_temp(thermal, GET_TRIP(PANIC_ZONE), temp);
+ return ret;
+}
+
+/* Bind callback functions for thermal zone */
+static int exynos_bind(struct thermal_zone_device *thermal,
+ struct thermal_cooling_device *cdev)
+{
+ int ret = 0, i;
+
+ /* find the cooling device registered*/
+ for (i = 0; i < th_zone->cool_dev_size; i++)
+ if (cdev == th_zone->cool_dev[i])
+ break;
+
+ /*No matching cooling device*/
+ if (i == th_zone->cool_dev_size)
+ return 0;
+
+ switch (GET_ZONE(i)) {
+ case MONITOR_ZONE:
+ case WARN_ZONE:
+ if (thermal_zone_bind_cooling_device(thermal, i, cdev)) {
+ pr_err("error binding cooling dev inst 0\n");
+ ret = -EINVAL;
+ }
+ break;
+ default:
+ ret = -EINVAL;
+ }
+
+ return ret;
+}
+
+/* Unbind callback functions for thermal zone */
+static int exynos_unbind(struct thermal_zone_device *thermal,
+ struct thermal_cooling_device *cdev)
+{
+ int ret = 0, i;
+
+ /* find the cooling device registered*/
+ for (i = 0; i < th_zone->cool_dev_size; i++)
+ if (cdev == th_zone->cool_dev[i])
+ break;
+
+ /*No matching cooling device*/
+ if (i == th_zone->cool_dev_size)
+ return 0;
+
+ switch (GET_ZONE(i)) {
+ case MONITOR_ZONE:
+ case WARN_ZONE:
+ if (thermal_zone_unbind_cooling_device(thermal, i, cdev)) {
+ pr_err("error unbinding cooling dev\n");
+ ret = -EINVAL;
+ }
+ break;
+ default:
+ ret = -EINVAL;
+ }
+ return ret;
+}
+
+/* Get temperature callback functions for thermal zone */
+static int exynos_get_temp(struct thermal_zone_device *thermal,
+ unsigned long *temp)
+{
+ void *data;
+
+ if (!th_zone->sensor_conf) {
+ pr_info("Temperature sensor not initialised\n");
+ return -EINVAL;
+ }
+ data = th_zone->sensor_conf->private_data;
+ *temp = th_zone->sensor_conf->read_temperature(data);
+ /* convert the temperature into millicelsius */
+ *temp = *temp * MCELSIUS;
+ return 0;
+}
+
+/* Operation callback functions for thermal zone */
+static struct thermal_zone_device_ops const exynos_dev_ops = {
+ .bind = exynos_bind,
+ .unbind = exynos_unbind,
+ .get_temp = exynos_get_temp,
+ .get_mode = exynos_get_mode,
+ .set_mode = exynos_set_mode,
+ .get_trip_type = exynos_get_trip_type,
+ .get_trip_temp = exynos_get_trip_temp,
+ .get_crit_temp = exynos_get_crit_temp,
+};
+
+/* Register with the in-kernel thermal management */
+static int exynos_register_thermal(struct thermal_sensor_conf *sensor_conf)
+{
+ int ret, count, tab_size;
+ struct freq_clip_table *tab_ptr, *clip_data;
+
+ if (!sensor_conf || !sensor_conf->read_temperature) {
+ pr_err("Temperature sensor not initialised\n");
+ return -EINVAL;
+ }
+
+ th_zone = kzalloc(sizeof(struct exynos_thermal_zone), GFP_KERNEL);
+ if (!th_zone)
+ return -ENOMEM;
+
+ th_zone->sensor_conf = sensor_conf;
+
+ tab_ptr = (struct freq_clip_table *)sensor_conf->cooling_data.freq_data;
+ tab_size = sensor_conf->cooling_data.freq_clip_count;
+
+ /* Register the cpufreq cooling device */
+ for (count = 0; count < tab_size; count++) {
+ clip_data = (struct freq_clip_table *)&(tab_ptr[count]);
+ clip_data->mask_val = cpumask_of(0);
+ th_zone->cool_dev[count] = cpufreq_cooling_register(
+ clip_data, 1);
+ if (IS_ERR(th_zone->cool_dev[count])) {
+ pr_err("Failed to register cpufreq cooling device\n");
+ ret = -EINVAL;
+ th_zone->cool_dev_size = count;
+ goto err_unregister;
+ }
+ }
+ th_zone->cool_dev_size = count;
+
+ th_zone->therm_dev = thermal_zone_device_register(sensor_conf->name,
+ EXYNOS_ZONE_COUNT, NULL, &exynos_dev_ops, 0, 0, 0,
+ IDLE_INTERVAL);
+
+ if (IS_ERR(th_zone->therm_dev)) {
+ pr_err("Failed to register thermal zone device\n");
+ ret = -EINVAL;
+ goto err_unregister;
+ }
+ th_zone->mode = THERMAL_DEVICE_ENABLED;
+
+ pr_info("Exynos: Kernel Thermal management registered\n");
+
+ return 0;
+
+err_unregister:
+ exynos_unregister_thermal();
+ return ret;
+}
+
+/* Un-Register with the in-kernel thermal management */
+static void exynos_unregister_thermal(void)
+{
+ int i;
+
+ for (i = 0; i < th_zone->cool_dev_size; i++) {
+ if (th_zone && th_zone->cool_dev[i])
+ cpufreq_cooling_unregister(th_zone->cool_dev[i]);
+ }
+
+ if (th_zone && th_zone->therm_dev)
+ thermal_zone_device_unregister(th_zone->therm_dev);
+
+ kfree(th_zone);
+
+ pr_info("Exynos: Kernel Thermal management unregistered\n");
+}
+
/*
* TMU treats temperature as a mapped temperature code.
* The temperature is converted differently depending on the calibration type.
@@ -337,6 +646,7 @@ static void exynos_tmu_work(struct work_struct *work)
clk_disable(data->clk);
mutex_unlock(&data->lock);
+ exynos_report_trigger();
enable_irq(data->irq);
}
@@ -349,12 +659,16 @@ static irqreturn_t exynos_tmu_irq(int irq, void *id)
return IRQ_HANDLED;
}
-
+static struct thermal_sensor_conf exynos_sensor_conf = {
+ .name = "exynos-therm",
+ .read_temperature = (int (*)(void *))exynos_tmu_read,
+}
+;
static int __devinit exynos_tmu_probe(struct platform_device *pdev)
{
struct exynos_tmu_data *data;
struct exynos_tmu_platform_data *pdata = pdev->dev.platform_data;
- int ret;
+ int ret, i;
if (!pdata) {
dev_err(&pdev->dev, "No platform init data supplied.\n");
@@ -432,6 +746,30 @@ static int __devinit exynos_tmu_probe(struct platform_device *pdev)
exynos_tmu_control(pdev, true);
+ /*Register the sensor with thermal management interface*/
+ (&exynos_sensor_conf)->private_data = data;
+ exynos_sensor_conf.trip_data.trip_count = pdata->trigger_level0_en +
+ pdata->trigger_level1_en + pdata->trigger_level2_en +
+ pdata->trigger_level3_en;
+
+ for (i = 0; i < exynos_sensor_conf.trip_data.trip_count; i++)
+ exynos_sensor_conf.trip_data.trip_val[i] =
+ pdata->threshold + pdata->trigger_levels[i];
+
+ exynos_sensor_conf.cooling_data.freq_clip_count =
+ pdata->freq_tab_count;
+ for (i = 0; i < pdata->freq_tab_count; i++) {
+ exynos_sensor_conf.cooling_data.freq_data[i].freq_clip_max =
+ pdata->freq_tab[i].freq_clip_max;
+ exynos_sensor_conf.cooling_data.freq_data[i].temp_level =
+ pdata->freq_tab[i].temp_level;
+ }
+
+ ret = exynos_register_thermal(&exynos_sensor_conf);
+ if (ret) {
+ dev_err(&pdev->dev, "Failed to register thermal interface\n");
+ goto err_clk;
+ }
return 0;
err_clk:
platform_set_drvdata(pdev, NULL);
@@ -454,6 +792,8 @@ static int __devexit exynos_tmu_remove(struct platform_device *pdev)
exynos_tmu_control(pdev, false);
+ exynos_unregister_thermal();
+
clk_put(data->clk);
free_irq(data->irq, data);
diff --git a/include/linux/platform_data/exynos_thermal.h b/include/linux/platform_data/exynos_thermal.h
index c980af6..858eaca 100644
--- a/include/linux/platform_data/exynos_thermal.h
+++ b/include/linux/platform_data/exynos_thermal.h
@@ -21,6 +21,7 @@
#ifndef _LINUX_EXYNOS_THERMAL_H
#define _LINUX_EXYNOS_THERMAL_H
+#include <linux/cpu_cooling.h>
enum calibration_type {
TYPE_ONE_POINT_TRIMMING,
@@ -72,6 +73,9 @@ enum soc_type {
* @type: determines the type of SOC
* @efuse_value: platform defined fuse value
* @cal_type: calibration type for temperature
+ * @freq_clip_table: Table representing frequency reduction percentage.
+ * @freq_tab_count: Count of the above table as frequency reduction may
+ * applicable to only some of the trigger levels.
*
* This structure is required for configuration of exynos_tmu driver.
*/
@@ -90,5 +94,7 @@ struct exynos_tmu_platform_data {
enum calibration_type cal_type;
enum soc_type type;
+ struct freq_clip_table freq_tab[4];
+ unsigned int freq_tab_count;
};
#endif /* _LINUX_EXYNOS_THERMAL_H */
--
1.7.1
^ permalink raw reply related
* [PATCH v4 3/5] thermal: exynos5: Add exynos5 thermal sensor driver support
From: Amit Daniel Kachhap @ 2012-05-12 9:40 UTC (permalink / raw)
To: linux-pm-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA,
akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b
Cc: linux-samsung-soc-u79uwXL29TY76Z2rM5mHXA,
durgadoss.r-ral2JQCrhuEAvxtiuMwx3w,
patches-QSEj5FYQhm4dnm+yROfE0A,
linux-kernel-u79uwXL29TY76Z2rM5mHXA,
lm-sensors-GZX6beZjE8VD60Wz+7aTrA,
linux-acpi-u79uwXL29TY76Z2rM5mHXA, khali-PUYAD+kWke1g9hUCZPvPmw,
linaro-dev-cunTk1MwBs8s++Sfvej+rw,
rui.zhang-ral2JQCrhuEAvxtiuMwx3w,
guenter.roeck-IzeFyvvaP7pWk0Htik3J/w, lenb-DgEjT+Ai2ygdnm+yROfE0A
In-Reply-To: <1336815645-29625-1-git-send-email-amit.kachhap-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org>
This patch inserts exynos5 TMU sensor changes in the thermal driver.
Some exynos4 changes are made generic for exynos series.
Signed-off-by: SangWook Ju <sw.ju-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org>
Signed-off-by: Amit Daniel Kachhap <amit.kachhap-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org>
---
drivers/thermal/Kconfig | 6 +-
drivers/thermal/exynos_thermal.c | 318 +++++++++++++++++---------
include/linux/platform_data/exynos_thermal.h | 19 ++-
3 files changed, 226 insertions(+), 117 deletions(-)
diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
index b0806cf..04c6796 100644
--- a/drivers/thermal/Kconfig
+++ b/drivers/thermal/Kconfig
@@ -39,10 +39,10 @@ config SPEAR_THERMAL
thermal framework
config EXYNOS_THERMAL
- tristate "Temperature sensor on Samsung EXYNOS4"
- depends on ARCH_EXYNOS4 && THERMAL
+ tristate "Temperature sensor on Samsung EXYNOS"
+ depends on (ARCH_EXYNOS4 || ARCH_EXYNOS5) && THERMAL
help
If you say yes here you get support for TMU (Thermal Managment
- Unit) on SAMSUNG EXYNOS4 series of SoC.
+ Unit) on SAMSUNG EXYNOS series of SoC.
This driver can also be built as a module. If so, the module
will be called exynos4-tmu
diff --git a/drivers/thermal/exynos_thermal.c b/drivers/thermal/exynos_thermal.c
index bda02fe..cfe4aeb 100644
--- a/drivers/thermal/exynos_thermal.c
+++ b/drivers/thermal/exynos_thermal.c
@@ -33,13 +33,29 @@
#include <linux/kobject.h>
#include <linux/io.h>
#include <linux/mutex.h>
-
+#include <linux/err.h>
#include <linux/platform_data/exynos_thermal.h>
-
-#define EXYNOS4_TMU_REG_TRIMINFO 0x0
-#define EXYNOS4_TMU_REG_CONTROL 0x20
-#define EXYNOS4_TMU_REG_STATUS 0x28
-#define EXYNOS4_TMU_REG_CURRENT_TEMP 0x40
+#include <linux/of.h>
+
+#include <plat/cpu.h>
+
+/*Exynos generic registers*/
+#define EXYNOS_TMU_REG_TRIMINFO 0x0
+#define EXYNOS_TMU_REG_CONTROL 0x20
+#define EXYNOS_TMU_REG_STATUS 0x28
+#define EXYNOS_TMU_REG_CURRENT_TEMP 0x40
+#define EXYNOS_TMU_REG_INTEN 0x70
+#define EXYNOS_TMU_REG_INTSTAT 0x74
+#define EXYNOS_TMU_REG_INTCLEAR 0x78
+
+#define EXYNOS_TMU_TRIM_TEMP_MASK 0xff
+#define EXYNOS_TMU_GAIN_SHIFT 8
+#define EXYNOS_TMU_REF_VOLTAGE_SHIFT 24
+#define EXYNOS_TMU_CORE_ON 3
+#define EXYNOS_TMU_CORE_OFF 2
+#define EXYNOS_TMU_DEF_CODE_TO_TEMP_OFFSET 50
+
+/*Exynos4 specific registers*/
#define EXYNOS4_TMU_REG_THRESHOLD_TEMP 0x44
#define EXYNOS4_TMU_REG_TRIG_LEVEL0 0x50
#define EXYNOS4_TMU_REG_TRIG_LEVEL1 0x54
@@ -49,28 +65,52 @@
#define EXYNOS4_TMU_REG_PAST_TEMP1 0x64
#define EXYNOS4_TMU_REG_PAST_TEMP2 0x68
#define EXYNOS4_TMU_REG_PAST_TEMP3 0x6C
-#define EXYNOS4_TMU_REG_INTEN 0x70
-#define EXYNOS4_TMU_REG_INTSTAT 0x74
-#define EXYNOS4_TMU_REG_INTCLEAR 0x78
-#define EXYNOS4_TMU_GAIN_SHIFT 8
-#define EXYNOS4_TMU_REF_VOLTAGE_SHIFT 24
-
-#define EXYNOS4_TMU_TRIM_TEMP_MASK 0xff
-#define EXYNOS4_TMU_CORE_ON 3
-#define EXYNOS4_TMU_CORE_OFF 2
-#define EXYNOS4_TMU_DEF_CODE_TO_TEMP_OFFSET 50
#define EXYNOS4_TMU_TRIG_LEVEL0_MASK 0x1
#define EXYNOS4_TMU_TRIG_LEVEL1_MASK 0x10
#define EXYNOS4_TMU_TRIG_LEVEL2_MASK 0x100
#define EXYNOS4_TMU_TRIG_LEVEL3_MASK 0x1000
#define EXYNOS4_TMU_INTCLEAR_VAL 0x1111
-struct exynos4_tmu_data {
- struct exynos4_tmu_platform_data *pdata;
+/*Exynos5 specific registers*/
+#define EXYNOS5_TMU_TRIMINFO_CON 0x14
+#define EXYNOS5_THD_TEMP_RISE 0x50
+#define EXYNOS5_THD_TEMP_FALL 0x54
+#define EXYNOS5_EMUL_CON 0x80
+
+#define EXYNOS5_TRIMINFO_RELOAD 0x1
+#define EXYNOS5_TMU_CLEAR_RISE_INT 0x111
+#define EXYNOS5_TMU_CLEAR_FALL_INT (0x111 << 16)
+#define EXYNOS5_MUX_ADDR_VALUE 6
+#define EXYNOS5_MUX_ADDR_SHIFT 20
+#define EXYNOS5_TMU_TRIP_MODE_SHIFT 13
+
+#define EFUSE_MIN_VALUE 40
+#define EFUSE_MAX_VALUE 100
+
+/*In-kernel thermal framework related macros & definations*/
+#define SENSOR_NAME_LEN 16
+#define MAX_TRIP_COUNT 8
+#define MAX_COOLING_DEVICE 4
+
+#define ACTIVE_INTERVAL 500
+#define IDLE_INTERVAL 10000
+
+/* CPU Zone information */
+#define PANIC_ZONE 4
+#define WARN_ZONE 3
+#define MONITOR_ZONE 2
+#define SAFE_ZONE 1
+
+#define GET_ZONE(trip) (trip + 2)
+#define GET_TRIP(zone) (zone - 2)
+
+struct exynos_tmu_data {
+ struct exynos_tmu_platform_data *pdata;
struct resource *mem;
void __iomem *base;
int irq;
+ enum soc_type soc;
struct work_struct irq_work;
struct mutex lock;
struct clk *clk;
@@ -81,16 +121,17 @@ struct exynos4_tmu_data {
* TMU treats temperature as a mapped temperature code.
* The temperature is converted differently depending on the calibration type.
*/
-static int temp_to_code(struct exynos4_tmu_data *data, u8 temp)
+static int temp_to_code(struct exynos_tmu_data *data, u8 temp)
{
- struct exynos4_tmu_platform_data *pdata = data->pdata;
+ struct exynos_tmu_platform_data *pdata = data->pdata;
int temp_code;
- /* temp should range between 25 and 125 */
- if (temp < 25 || temp > 125) {
- temp_code = -EINVAL;
- goto out;
- }
+ if (data->soc == SOC_ARCH_EXYNOS4)
+ /* temp should range between 25 and 125 */
+ if (temp < 25 || temp > 125) {
+ temp_code = -EINVAL;
+ goto out;
+ }
switch (pdata->cal_type) {
case TYPE_TWO_POINT_TRIMMING:
@@ -102,7 +143,7 @@ static int temp_to_code(struct exynos4_tmu_data *data, u8 temp)
temp_code = temp + data->temp_error1 - 25;
break;
default:
- temp_code = temp + EXYNOS4_TMU_DEF_CODE_TO_TEMP_OFFSET;
+ temp_code = temp + EXYNOS_TMU_DEF_CODE_TO_TEMP_OFFSET;
break;
}
out:
@@ -113,16 +154,17 @@ out:
* Calculate a temperature value from a temperature code.
* The unit of the temperature is degree Celsius.
*/
-static int code_to_temp(struct exynos4_tmu_data *data, u8 temp_code)
+static int code_to_temp(struct exynos_tmu_data *data, u8 temp_code)
{
- struct exynos4_tmu_platform_data *pdata = data->pdata;
+ struct exynos_tmu_platform_data *pdata = data->pdata;
int temp;
- /* temp_code should range between 75 and 175 */
- if (temp_code < 75 || temp_code > 175) {
- temp = -ENODATA;
- goto out;
- }
+ if (data->soc == SOC_ARCH_EXYNOS4)
+ /* temp_code should range between 75 and 175 */
+ if (temp_code < 75 || temp_code > 175) {
+ temp = -ENODATA;
+ goto out;
+ }
switch (pdata->cal_type) {
case TYPE_TWO_POINT_TRIMMING:
@@ -133,54 +175,92 @@ static int code_to_temp(struct exynos4_tmu_data *data, u8 temp_code)
temp = temp_code - data->temp_error1 + 25;
break;
default:
- temp = temp_code - EXYNOS4_TMU_DEF_CODE_TO_TEMP_OFFSET;
+ temp = temp_code - EXYNOS_TMU_DEF_CODE_TO_TEMP_OFFSET;
break;
}
out:
return temp;
}
-static int exynos4_tmu_initialize(struct platform_device *pdev)
+static int exynos_tmu_initialize(struct platform_device *pdev)
{
- struct exynos4_tmu_data *data = platform_get_drvdata(pdev);
- struct exynos4_tmu_platform_data *pdata = data->pdata;
- unsigned int status, trim_info;
+ struct exynos_tmu_data *data = platform_get_drvdata(pdev);
+ struct exynos_tmu_platform_data *pdata = data->pdata;
+ unsigned int status, trim_info, rising_threshold;
int ret = 0, threshold_code;
mutex_lock(&data->lock);
clk_enable(data->clk);
- status = readb(data->base + EXYNOS4_TMU_REG_STATUS);
+ status = readb(data->base + EXYNOS_TMU_REG_STATUS);
if (!status) {
ret = -EBUSY;
goto out;
}
+ if (data->soc == SOC_ARCH_EXYNOS5) {
+ __raw_writel(EXYNOS5_TRIMINFO_RELOAD,
+ data->base + EXYNOS5_TMU_TRIMINFO_CON);
+ }
/* Save trimming info in order to perform calibration */
- trim_info = readl(data->base + EXYNOS4_TMU_REG_TRIMINFO);
- data->temp_error1 = trim_info & EXYNOS4_TMU_TRIM_TEMP_MASK;
- data->temp_error2 = ((trim_info >> 8) & EXYNOS4_TMU_TRIM_TEMP_MASK);
-
- /* Write temperature code for threshold */
- threshold_code = temp_to_code(data, pdata->threshold);
- if (threshold_code < 0) {
- ret = threshold_code;
- goto out;
+ trim_info = readl(data->base + EXYNOS_TMU_REG_TRIMINFO);
+ data->temp_error1 = trim_info & EXYNOS_TMU_TRIM_TEMP_MASK;
+ data->temp_error2 = ((trim_info >> 8) & EXYNOS_TMU_TRIM_TEMP_MASK);
+
+ if ((EFUSE_MIN_VALUE > data->temp_error1) ||
+ (data->temp_error1 > EFUSE_MAX_VALUE) ||
+ (data->temp_error2 != 0))
+ data->temp_error1 = pdata->efuse_value;
+
+ if (data->soc == SOC_ARCH_EXYNOS4) {
+ /* Write temperature code for threshold */
+ threshold_code = temp_to_code(data, pdata->threshold);
+ if (threshold_code < 0) {
+ ret = threshold_code;
+ goto out;
+ }
+ writeb(threshold_code,
+ data->base + EXYNOS4_TMU_REG_THRESHOLD_TEMP);
+
+ writeb(pdata->trigger_levels[0],
+ data->base + EXYNOS4_TMU_REG_TRIG_LEVEL0);
+ writeb(pdata->trigger_levels[1],
+ data->base + EXYNOS4_TMU_REG_TRIG_LEVEL1);
+ writeb(pdata->trigger_levels[2],
+ data->base + EXYNOS4_TMU_REG_TRIG_LEVEL2);
+ writeb(pdata->trigger_levels[3],
+ data->base + EXYNOS4_TMU_REG_TRIG_LEVEL3);
+
+ writel(EXYNOS4_TMU_INTCLEAR_VAL,
+ data->base + EXYNOS_TMU_REG_INTCLEAR);
+ } else if (data->soc == SOC_ARCH_EXYNOS5) {
+ /* Write temperature code for threshold */
+ threshold_code = temp_to_code(data, pdata->trigger_levels[0]);
+ if (threshold_code < 0) {
+ ret = threshold_code;
+ goto out;
+ }
+ rising_threshold = threshold_code;
+ threshold_code = temp_to_code(data, pdata->trigger_levels[1]);
+ if (threshold_code < 0) {
+ ret = threshold_code;
+ goto out;
+ }
+ rising_threshold |= (threshold_code << 8);
+ threshold_code = temp_to_code(data, pdata->trigger_levels[2]);
+ if (threshold_code < 0) {
+ ret = threshold_code;
+ goto out;
+ }
+ rising_threshold |= (threshold_code << 16);
+
+ writel(rising_threshold,
+ data->base + EXYNOS5_THD_TEMP_RISE);
+ writel(0, data->base + EXYNOS5_THD_TEMP_FALL);
+
+ writel(EXYNOS5_TMU_CLEAR_RISE_INT|EXYNOS5_TMU_CLEAR_FALL_INT,
+ data->base + EXYNOS_TMU_REG_INTCLEAR);
}
- writeb(threshold_code,
- data->base + EXYNOS4_TMU_REG_THRESHOLD_TEMP);
-
- writeb(pdata->trigger_levels[0],
- data->base + EXYNOS4_TMU_REG_TRIG_LEVEL0);
- writeb(pdata->trigger_levels[1],
- data->base + EXYNOS4_TMU_REG_TRIG_LEVEL1);
- writeb(pdata->trigger_levels[2],
- data->base + EXYNOS4_TMU_REG_TRIG_LEVEL2);
- writeb(pdata->trigger_levels[3],
- data->base + EXYNOS4_TMU_REG_TRIG_LEVEL3);
-
- writel(EXYNOS4_TMU_INTCLEAR_VAL,
- data->base + EXYNOS4_TMU_REG_INTCLEAR);
out:
clk_disable(data->clk);
mutex_unlock(&data->lock);
@@ -188,35 +268,41 @@ out:
return ret;
}
-static void exynos4_tmu_control(struct platform_device *pdev, bool on)
+static void exynos_tmu_control(struct platform_device *pdev, bool on)
{
- struct exynos4_tmu_data *data = platform_get_drvdata(pdev);
- struct exynos4_tmu_platform_data *pdata = data->pdata;
+ struct exynos_tmu_data *data = platform_get_drvdata(pdev);
+ struct exynos_tmu_platform_data *pdata = data->pdata;
unsigned int con, interrupt_en;
mutex_lock(&data->lock);
clk_enable(data->clk);
- con = pdata->reference_voltage << EXYNOS4_TMU_REF_VOLTAGE_SHIFT |
- pdata->gain << EXYNOS4_TMU_GAIN_SHIFT;
+ con = pdata->reference_voltage << EXYNOS_TMU_REF_VOLTAGE_SHIFT |
+ pdata->gain << EXYNOS_TMU_GAIN_SHIFT;
+
+ if (data->soc == SOC_ARCH_EXYNOS5) {
+ con |= pdata->noise_cancel_mode << EXYNOS5_TMU_TRIP_MODE_SHIFT;
+ con |= (EXYNOS5_MUX_ADDR_VALUE << EXYNOS5_MUX_ADDR_SHIFT);
+ }
+
if (on) {
- con |= EXYNOS4_TMU_CORE_ON;
+ con |= EXYNOS_TMU_CORE_ON;
interrupt_en = pdata->trigger_level3_en << 12 |
pdata->trigger_level2_en << 8 |
pdata->trigger_level1_en << 4 |
pdata->trigger_level0_en;
} else {
- con |= EXYNOS4_TMU_CORE_OFF;
+ con |= EXYNOS_TMU_CORE_OFF;
interrupt_en = 0; /* Disable all interrupts */
}
- writel(interrupt_en, data->base + EXYNOS4_TMU_REG_INTEN);
- writel(con, data->base + EXYNOS4_TMU_REG_CONTROL);
+ writel(interrupt_en, data->base + EXYNOS_TMU_REG_INTEN);
+ writel(con, data->base + EXYNOS_TMU_REG_CONTROL);
clk_disable(data->clk);
mutex_unlock(&data->lock);
}
-static int exynos4_tmu_read(struct exynos4_tmu_data *data)
+static int exynos_tmu_read(struct exynos_tmu_data *data)
{
u8 temp_code;
int temp;
@@ -224,7 +310,7 @@ static int exynos4_tmu_read(struct exynos4_tmu_data *data)
mutex_lock(&data->lock);
clk_enable(data->clk);
- temp_code = readb(data->base + EXYNOS4_TMU_REG_CURRENT_TEMP);
+ temp_code = readb(data->base + EXYNOS_TMU_REG_CURRENT_TEMP);
temp = code_to_temp(data, temp_code);
clk_disable(data->clk);
@@ -233,25 +319,30 @@ static int exynos4_tmu_read(struct exynos4_tmu_data *data)
return temp;
}
-static void exynos4_tmu_work(struct work_struct *work)
+static void exynos_tmu_work(struct work_struct *work)
{
- struct exynos4_tmu_data *data = container_of(work,
- struct exynos4_tmu_data, irq_work);
+ struct exynos_tmu_data *data = container_of(work,
+ struct exynos_tmu_data, irq_work);
mutex_lock(&data->lock);
clk_enable(data->clk);
- writel(EXYNOS4_TMU_INTCLEAR_VAL, data->base + EXYNOS4_TMU_REG_INTCLEAR);
- enable_irq(data->irq);
+ if (data->soc == SOC_ARCH_EXYNOS5)
+ writel(EXYNOS5_TMU_CLEAR_RISE_INT,
+ data->base + EXYNOS_TMU_REG_INTCLEAR);
+ else
+ writel(EXYNOS4_TMU_INTCLEAR_VAL,
+ data->base + EXYNOS_TMU_REG_INTCLEAR);
clk_disable(data->clk);
mutex_unlock(&data->lock);
+ enable_irq(data->irq);
}
-static irqreturn_t exynos4_tmu_irq(int irq, void *id)
+static irqreturn_t exynos_tmu_irq(int irq, void *id)
{
- struct exynos4_tmu_data *data = id;
+ struct exynos_tmu_data *data = id;
disable_irq_nosync(irq);
schedule_work(&data->irq_work);
@@ -259,18 +350,17 @@ static irqreturn_t exynos4_tmu_irq(int irq, void *id)
return IRQ_HANDLED;
}
-static int __devinit exynos4_tmu_probe(struct platform_device *pdev)
+static int __devinit exynos_tmu_probe(struct platform_device *pdev)
{
- struct exynos4_tmu_data *data;
- struct exynos4_tmu_platform_data *pdata = pdev->dev.platform_data;
+ struct exynos_tmu_data *data;
+ struct exynos_tmu_platform_data *pdata = pdev->dev.platform_data;
int ret;
if (!pdata) {
dev_err(&pdev->dev, "No platform init data supplied.\n");
return -ENODEV;
}
-
- data = kzalloc(sizeof(struct exynos4_tmu_data), GFP_KERNEL);
+ data = kzalloc(sizeof(struct exynos_tmu_data), GFP_KERNEL);
if (!data) {
dev_err(&pdev->dev, "Failed to allocate driver structure\n");
return -ENOMEM;
@@ -283,7 +373,7 @@ static int __devinit exynos4_tmu_probe(struct platform_device *pdev)
goto err_free;
}
- INIT_WORK(&data->irq_work, exynos4_tmu_work);
+ INIT_WORK(&data->irq_work, exynos_tmu_work);
data->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!data->mem) {
@@ -307,9 +397,8 @@ static int __devinit exynos4_tmu_probe(struct platform_device *pdev)
goto err_mem_region;
}
- ret = request_irq(data->irq, exynos4_tmu_irq,
- IRQF_TRIGGER_RISING,
- "exynos4-tmu", data);
+ ret = request_irq(data->irq, exynos_tmu_irq,
+ IRQF_TRIGGER_RISING, "exynos-tmu", data);
if (ret) {
dev_err(&pdev->dev, "Failed to request irq: %d\n", data->irq);
goto err_io_remap;
@@ -322,17 +411,26 @@ static int __devinit exynos4_tmu_probe(struct platform_device *pdev)
goto err_irq;
}
+ if (pdata->type == SOC_ARCH_EXYNOS5 ||
+ pdata->type == SOC_ARCH_EXYNOS4)
+ data->soc = pdata->type;
+ else {
+ ret = -EINVAL;
+ dev_err(&pdev->dev, "Platform not supported\n");
+ goto err_clk;
+ }
+
data->pdata = pdata;
platform_set_drvdata(pdev, data);
mutex_init(&data->lock);
- ret = exynos4_tmu_initialize(pdev);
+ ret = exynos_tmu_initialize(pdev);
if (ret) {
dev_err(&pdev->dev, "Failed to initialize TMU\n");
goto err_clk;
}
- exynos4_tmu_control(pdev, true);
+ exynos_tmu_control(pdev, true);
return 0;
err_clk:
@@ -350,11 +448,11 @@ err_free:
return ret;
}
-static int __devexit exynos4_tmu_remove(struct platform_device *pdev)
+static int __devexit exynos_tmu_remove(struct platform_device *pdev)
{
- struct exynos4_tmu_data *data = platform_get_drvdata(pdev);
+ struct exynos_tmu_data *data = platform_get_drvdata(pdev);
- exynos4_tmu_control(pdev, false);
+ exynos_tmu_control(pdev, false);
clk_put(data->clk);
@@ -371,39 +469,39 @@ static int __devexit exynos4_tmu_remove(struct platform_device *pdev)
}
#ifdef CONFIG_PM
-static int exynos4_tmu_suspend(struct platform_device *pdev, pm_message_t state)
+static int exynos_tmu_suspend(struct platform_device *pdev, pm_message_t state)
{
- exynos4_tmu_control(pdev, false);
+ exynos_tmu_control(pdev, false);
return 0;
}
-static int exynos4_tmu_resume(struct platform_device *pdev)
+static int exynos_tmu_resume(struct platform_device *pdev)
{
- exynos4_tmu_initialize(pdev);
- exynos4_tmu_control(pdev, true);
+ exynos_tmu_initialize(pdev);
+ exynos_tmu_control(pdev, true);
return 0;
}
#else
-#define exynos4_tmu_suspend NULL
-#define exynos4_tmu_resume NULL
+#define exynos_tmu_suspend NULL
+#define exynos_tmu_resume NULL
#endif
-static struct platform_driver exynos4_tmu_driver = {
+static struct platform_driver exynos_tmu_driver = {
.driver = {
- .name = "exynos4-tmu",
+ .name = "exynos-tmu",
.owner = THIS_MODULE,
},
- .probe = exynos4_tmu_probe,
- .remove = __devexit_p(exynos4_tmu_remove),
- .suspend = exynos4_tmu_suspend,
- .resume = exynos4_tmu_resume,
+ .probe = exynos_tmu_probe,
+ .remove = __devexit_p(exynos_tmu_remove),
+ .suspend = exynos_tmu_suspend,
+ .resume = exynos_tmu_resume,
};
-module_platform_driver(exynos4_tmu_driver);
+module_platform_driver(exynos_tmu_driver);
-MODULE_DESCRIPTION("EXYNOS4 TMU Driver");
+MODULE_DESCRIPTION("EXYNOS TMU Driver");
MODULE_AUTHOR("Donggeun Kim <dg77.kim-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org>");
MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:exynos4-tmu");
+MODULE_ALIAS("platform:exynos-tmu");
diff --git a/include/linux/platform_data/exynos_thermal.h b/include/linux/platform_data/exynos_thermal.h
index d6c3f93..c980af6 100644
--- a/include/linux/platform_data/exynos_thermal.h
+++ b/include/linux/platform_data/exynos_thermal.h
@@ -1,5 +1,5 @@
/*
- * exynos_thermal.h - Samsung EXYNOS4 TMU (Thermal Management Unit)
+ * exynos_thermal.h - Samsung EXYNOS TMU (Thermal Management Unit)
*
* Copyright (C) 2011 Samsung Electronics
* Donggeun Kim <dg77.kim-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org>
@@ -28,8 +28,12 @@ enum calibration_type {
TYPE_NONE,
};
+enum soc_type {
+ SOC_ARCH_EXYNOS4 = 1,
+ SOC_ARCH_EXYNOS5,
+};
/**
- * struct exynos4_tmu_platform_data
+ * struct exynos_tmu_platform_data
* @threshold: basic temperature for generating interrupt
* 25 <= threshold <= 125 [unit: degree Celsius]
* @trigger_levels: array for each interrupt levels
@@ -63,11 +67,15 @@ enum calibration_type {
* @reference_voltage: reference voltage of amplifier
* in the positive-TC generator block
* 0 <= reference_voltage <= 31
+ * @noise_cancel_mode: noise cancellation mode
+ * 000, 100, 101, 110 and 111 can be different modes
+ * @type: determines the type of SOC
+ * @efuse_value: platform defined fuse value
* @cal_type: calibration type for temperature
*
- * This structure is required for configuration of exynos4_tmu driver.
+ * This structure is required for configuration of exynos_tmu driver.
*/
-struct exynos4_tmu_platform_data {
+struct exynos_tmu_platform_data {
u8 threshold;
u8 trigger_levels[4];
bool trigger_level0_en;
@@ -77,7 +85,10 @@ struct exynos4_tmu_platform_data {
u8 gain;
u8 reference_voltage;
+ u8 noise_cancel_mode;
+ u32 efuse_value;
enum calibration_type cal_type;
+ enum soc_type type;
};
#endif /* _LINUX_EXYNOS_THERMAL_H */
--
1.7.1
^ permalink raw reply related
* [PATCH v4 2/5] hwmon: exynos4: Move thermal sensor driver to driver/thermal directory
From: Amit Daniel Kachhap @ 2012-05-12 9:40 UTC (permalink / raw)
To: linux-pm, akpm
Cc: linux-samsung-soc, patches, linux-kernel, lm-sensors, linux-acpi,
khali, linaro-dev, guenter.roeck
In-Reply-To: <1336815645-29625-1-git-send-email-amit.kachhap@linaro.org>
This movement is needed because the hwmon entries and corresponding
sysfs interface is a duplicate of utilities already provided by
driver/thermal/thermal_sys.c. The goal is to place it in thermal folder
and add necessary functions to use the in-kernel thermal interfaces.
CC: Guenter Roeck <guenter.roeck@ericsson.com>
Signed-off-by: Amit Daniel Kachhap <amit.kachhap@linaro.org>
Signed-off-by: Donggeun Kim <dg77.kim@samsung.com>
---
Documentation/hwmon/exynos4_tmu | 81 ----
Documentation/thermal/exynos_thermal | 52 +++
drivers/hwmon/Kconfig | 10 -
drivers/hwmon/Makefile | 1 -
drivers/hwmon/exynos4_tmu.c | 514 --------------------------
drivers/thermal/Kconfig | 9 +
drivers/thermal/Makefile | 1 +
drivers/thermal/exynos_thermal.c | 409 ++++++++++++++++++++
include/linux/platform_data/exynos4_tmu.h | 83 ----
include/linux/platform_data/exynos_thermal.h | 83 ++++
10 files changed, 554 insertions(+), 689 deletions(-)
delete mode 100644 Documentation/hwmon/exynos4_tmu
create mode 100644 Documentation/thermal/exynos_thermal
delete mode 100644 drivers/hwmon/exynos4_tmu.c
create mode 100644 drivers/thermal/exynos_thermal.c
delete mode 100644 include/linux/platform_data/exynos4_tmu.h
create mode 100644 include/linux/platform_data/exynos_thermal.h
diff --git a/Documentation/hwmon/exynos4_tmu b/Documentation/hwmon/exynos4_tmu
deleted file mode 100644
index c3c6b41..0000000
--- a/Documentation/hwmon/exynos4_tmu
+++ /dev/null
@@ -1,81 +0,0 @@
-Kernel driver exynos4_tmu
-=================
-
-Supported chips:
-* ARM SAMSUNG EXYNOS4 series of SoC
- Prefix: 'exynos4-tmu'
- Datasheet: Not publicly available
-
-Authors: Donggeun Kim <dg77.kim@samsung.com>
-
-Description
------------
-
-This driver allows to read temperature inside SAMSUNG EXYNOS4 series of SoC.
-
-The chip only exposes the measured 8-bit temperature code value
-through a register.
-Temperature can be taken from the temperature code.
-There are three equations converting from temperature to temperature code.
-
-The three equations are:
- 1. Two point trimming
- Tc = (T - 25) * (TI2 - TI1) / (85 - 25) + TI1
-
- 2. One point trimming
- Tc = T + TI1 - 25
-
- 3. No trimming
- Tc = T + 50
-
- Tc: Temperature code, T: Temperature,
- TI1: Trimming info for 25 degree Celsius (stored at TRIMINFO register)
- Temperature code measured at 25 degree Celsius which is unchanged
- TI2: Trimming info for 85 degree Celsius (stored at TRIMINFO register)
- Temperature code measured at 85 degree Celsius which is unchanged
-
-TMU(Thermal Management Unit) in EXYNOS4 generates interrupt
-when temperature exceeds pre-defined levels.
-The maximum number of configurable threshold is four.
-The threshold levels are defined as follows:
- Level_0: current temperature > trigger_level_0 + threshold
- Level_1: current temperature > trigger_level_1 + threshold
- Level_2: current temperature > trigger_level_2 + threshold
- Level_3: current temperature > trigger_level_3 + threshold
-
- The threshold and each trigger_level are set
- through the corresponding registers.
-
-When an interrupt occurs, this driver notify user space of
-one of four threshold levels for the interrupt
-through kobject_uevent_env and sysfs_notify functions.
-Although an interrupt condition for level_0 can be set,
-it is not notified to user space through sysfs_notify function.
-
-Sysfs Interface
----------------
-name name of the temperature sensor
- RO
-
-temp1_input temperature
- RO
-
-temp1_max temperature for level_1 interrupt
- RO
-
-temp1_crit temperature for level_2 interrupt
- RO
-
-temp1_emergency temperature for level_3 interrupt
- RO
-
-temp1_max_alarm alarm for level_1 interrupt
- RO
-
-temp1_crit_alarm
- alarm for level_2 interrupt
- RO
-
-temp1_emergency_alarm
- alarm for level_3 interrupt
- RO
diff --git a/Documentation/thermal/exynos_thermal b/Documentation/thermal/exynos_thermal
new file mode 100644
index 0000000..2b46f67
--- /dev/null
+++ b/Documentation/thermal/exynos_thermal
@@ -0,0 +1,52 @@
+Kernel driver exynos4_tmu
+=================
+
+Supported chips:
+* ARM SAMSUNG EXYNOS4 series of SoC
+ Prefix: 'exynos4-tmu'
+ Datasheet: Not publicly available
+
+Authors: Donggeun Kim <dg77.kim@samsung.com>
+
+Description
+-----------
+
+This driver allows to read temperature inside SAMSUNG EXYNOS4 series of SoC.
+
+The chip only exposes the measured 8-bit temperature code value
+through a register.
+Temperature can be taken from the temperature code.
+There are three equations converting from temperature to temperature code.
+
+The three equations are:
+ 1. Two point trimming
+ Tc = (T - 25) * (TI2 - TI1) / (85 - 25) + TI1
+
+ 2. One point trimming
+ Tc = T + TI1 - 25
+
+ 3. No trimming
+ Tc = T + 50
+
+ Tc: Temperature code, T: Temperature,
+ TI1: Trimming info for 25 degree Celsius (stored at TRIMINFO register)
+ Temperature code measured at 25 degree Celsius which is unchanged
+ TI2: Trimming info for 85 degree Celsius (stored at TRIMINFO register)
+ Temperature code measured at 85 degree Celsius which is unchanged
+
+TMU(Thermal Management Unit) in EXYNOS4 generates interrupt
+when temperature exceeds pre-defined levels.
+The maximum number of configurable threshold is four.
+The threshold levels are defined as follows:
+ Level_0: current temperature > trigger_level_0 + threshold
+ Level_1: current temperature > trigger_level_1 + threshold
+ Level_2: current temperature > trigger_level_2 + threshold
+ Level_3: current temperature > trigger_level_3 + threshold
+
+ The threshold and each trigger_level are set
+ through the corresponding registers.
+
+When an interrupt occurs, this driver notify kernel thermal framework
+with the function exynos4_report_trigger.
+Although an interrupt condition for level_0 can be set,
+it can be used to synchronize the cooling action.
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 8deedc1..e63d02d 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -314,16 +314,6 @@ config SENSORS_DS1621
This driver can also be built as a module. If so, the module
will be called ds1621.
-config SENSORS_EXYNOS4_TMU
- tristate "Temperature sensor on Samsung EXYNOS4"
- depends on ARCH_EXYNOS4
- help
- If you say yes here you get support for TMU (Thermal Managment
- Unit) on SAMSUNG EXYNOS4 series of SoC.
-
- This driver can also be built as a module. If so, the module
- will be called exynos4-tmu.
-
config SENSORS_I5K_AMB
tristate "FB-DIMM AMB temperature sensor on Intel 5000 series chipsets"
depends on PCI && EXPERIMENTAL
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 6d3f11f..b3e6d6e 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -48,7 +48,6 @@ obj-$(CONFIG_SENSORS_DS1621) += ds1621.o
obj-$(CONFIG_SENSORS_EMC1403) += emc1403.o
obj-$(CONFIG_SENSORS_EMC2103) += emc2103.o
obj-$(CONFIG_SENSORS_EMC6W201) += emc6w201.o
-obj-$(CONFIG_SENSORS_EXYNOS4_TMU) += exynos4_tmu.o
obj-$(CONFIG_SENSORS_F71805F) += f71805f.o
obj-$(CONFIG_SENSORS_F71882FG) += f71882fg.o
obj-$(CONFIG_SENSORS_F75375S) += f75375s.o
diff --git a/drivers/hwmon/exynos4_tmu.c b/drivers/hwmon/exynos4_tmu.c
deleted file mode 100644
index f2359a0..0000000
--- a/drivers/hwmon/exynos4_tmu.c
+++ /dev/null
@@ -1,514 +0,0 @@
-/*
- * exynos4_tmu.c - Samsung EXYNOS4 TMU (Thermal Management Unit)
- *
- * Copyright (C) 2011 Samsung Electronics
- * Donggeun Kim <dg77.kim@samsung.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; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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
- *
- */
-
-#include <linux/module.h>
-#include <linux/err.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/platform_device.h>
-#include <linux/interrupt.h>
-#include <linux/clk.h>
-#include <linux/workqueue.h>
-#include <linux/sysfs.h>
-#include <linux/kobject.h>
-#include <linux/io.h>
-#include <linux/mutex.h>
-
-#include <linux/hwmon.h>
-#include <linux/hwmon-sysfs.h>
-
-#include <linux/platform_data/exynos4_tmu.h>
-
-#define EXYNOS4_TMU_REG_TRIMINFO 0x0
-#define EXYNOS4_TMU_REG_CONTROL 0x20
-#define EXYNOS4_TMU_REG_STATUS 0x28
-#define EXYNOS4_TMU_REG_CURRENT_TEMP 0x40
-#define EXYNOS4_TMU_REG_THRESHOLD_TEMP 0x44
-#define EXYNOS4_TMU_REG_TRIG_LEVEL0 0x50
-#define EXYNOS4_TMU_REG_TRIG_LEVEL1 0x54
-#define EXYNOS4_TMU_REG_TRIG_LEVEL2 0x58
-#define EXYNOS4_TMU_REG_TRIG_LEVEL3 0x5C
-#define EXYNOS4_TMU_REG_PAST_TEMP0 0x60
-#define EXYNOS4_TMU_REG_PAST_TEMP1 0x64
-#define EXYNOS4_TMU_REG_PAST_TEMP2 0x68
-#define EXYNOS4_TMU_REG_PAST_TEMP3 0x6C
-#define EXYNOS4_TMU_REG_INTEN 0x70
-#define EXYNOS4_TMU_REG_INTSTAT 0x74
-#define EXYNOS4_TMU_REG_INTCLEAR 0x78
-
-#define EXYNOS4_TMU_GAIN_SHIFT 8
-#define EXYNOS4_TMU_REF_VOLTAGE_SHIFT 24
-
-#define EXYNOS4_TMU_TRIM_TEMP_MASK 0xff
-#define EXYNOS4_TMU_CORE_ON 3
-#define EXYNOS4_TMU_CORE_OFF 2
-#define EXYNOS4_TMU_DEF_CODE_TO_TEMP_OFFSET 50
-#define EXYNOS4_TMU_TRIG_LEVEL0_MASK 0x1
-#define EXYNOS4_TMU_TRIG_LEVEL1_MASK 0x10
-#define EXYNOS4_TMU_TRIG_LEVEL2_MASK 0x100
-#define EXYNOS4_TMU_TRIG_LEVEL3_MASK 0x1000
-#define EXYNOS4_TMU_INTCLEAR_VAL 0x1111
-
-struct exynos4_tmu_data {
- struct exynos4_tmu_platform_data *pdata;
- struct device *hwmon_dev;
- struct resource *mem;
- void __iomem *base;
- int irq;
- struct work_struct irq_work;
- struct mutex lock;
- struct clk *clk;
- u8 temp_error1, temp_error2;
-};
-
-/*
- * TMU treats temperature as a mapped temperature code.
- * The temperature is converted differently depending on the calibration type.
- */
-static int temp_to_code(struct exynos4_tmu_data *data, u8 temp)
-{
- struct exynos4_tmu_platform_data *pdata = data->pdata;
- int temp_code;
-
- /* temp should range between 25 and 125 */
- if (temp < 25 || temp > 125) {
- temp_code = -EINVAL;
- goto out;
- }
-
- switch (pdata->cal_type) {
- case TYPE_TWO_POINT_TRIMMING:
- temp_code = (temp - 25) *
- (data->temp_error2 - data->temp_error1) /
- (85 - 25) + data->temp_error1;
- break;
- case TYPE_ONE_POINT_TRIMMING:
- temp_code = temp + data->temp_error1 - 25;
- break;
- default:
- temp_code = temp + EXYNOS4_TMU_DEF_CODE_TO_TEMP_OFFSET;
- break;
- }
-out:
- return temp_code;
-}
-
-/*
- * Calculate a temperature value from a temperature code.
- * The unit of the temperature is degree Celsius.
- */
-static int code_to_temp(struct exynos4_tmu_data *data, u8 temp_code)
-{
- struct exynos4_tmu_platform_data *pdata = data->pdata;
- int temp;
-
- /* temp_code should range between 75 and 175 */
- if (temp_code < 75 || temp_code > 175) {
- temp = -ENODATA;
- goto out;
- }
-
- switch (pdata->cal_type) {
- case TYPE_TWO_POINT_TRIMMING:
- temp = (temp_code - data->temp_error1) * (85 - 25) /
- (data->temp_error2 - data->temp_error1) + 25;
- break;
- case TYPE_ONE_POINT_TRIMMING:
- temp = temp_code - data->temp_error1 + 25;
- break;
- default:
- temp = temp_code - EXYNOS4_TMU_DEF_CODE_TO_TEMP_OFFSET;
- break;
- }
-out:
- return temp;
-}
-
-static int exynos4_tmu_initialize(struct platform_device *pdev)
-{
- struct exynos4_tmu_data *data = platform_get_drvdata(pdev);
- struct exynos4_tmu_platform_data *pdata = data->pdata;
- unsigned int status, trim_info;
- int ret = 0, threshold_code;
-
- mutex_lock(&data->lock);
- clk_enable(data->clk);
-
- status = readb(data->base + EXYNOS4_TMU_REG_STATUS);
- if (!status) {
- ret = -EBUSY;
- goto out;
- }
-
- /* Save trimming info in order to perform calibration */
- trim_info = readl(data->base + EXYNOS4_TMU_REG_TRIMINFO);
- data->temp_error1 = trim_info & EXYNOS4_TMU_TRIM_TEMP_MASK;
- data->temp_error2 = ((trim_info >> 8) & EXYNOS4_TMU_TRIM_TEMP_MASK);
-
- /* Write temperature code for threshold */
- threshold_code = temp_to_code(data, pdata->threshold);
- if (threshold_code < 0) {
- ret = threshold_code;
- goto out;
- }
- writeb(threshold_code,
- data->base + EXYNOS4_TMU_REG_THRESHOLD_TEMP);
-
- writeb(pdata->trigger_levels[0],
- data->base + EXYNOS4_TMU_REG_TRIG_LEVEL0);
- writeb(pdata->trigger_levels[1],
- data->base + EXYNOS4_TMU_REG_TRIG_LEVEL1);
- writeb(pdata->trigger_levels[2],
- data->base + EXYNOS4_TMU_REG_TRIG_LEVEL2);
- writeb(pdata->trigger_levels[3],
- data->base + EXYNOS4_TMU_REG_TRIG_LEVEL3);
-
- writel(EXYNOS4_TMU_INTCLEAR_VAL,
- data->base + EXYNOS4_TMU_REG_INTCLEAR);
-out:
- clk_disable(data->clk);
- mutex_unlock(&data->lock);
-
- return ret;
-}
-
-static void exynos4_tmu_control(struct platform_device *pdev, bool on)
-{
- struct exynos4_tmu_data *data = platform_get_drvdata(pdev);
- struct exynos4_tmu_platform_data *pdata = data->pdata;
- unsigned int con, interrupt_en;
-
- mutex_lock(&data->lock);
- clk_enable(data->clk);
-
- con = pdata->reference_voltage << EXYNOS4_TMU_REF_VOLTAGE_SHIFT |
- pdata->gain << EXYNOS4_TMU_GAIN_SHIFT;
- if (on) {
- con |= EXYNOS4_TMU_CORE_ON;
- interrupt_en = pdata->trigger_level3_en << 12 |
- pdata->trigger_level2_en << 8 |
- pdata->trigger_level1_en << 4 |
- pdata->trigger_level0_en;
- } else {
- con |= EXYNOS4_TMU_CORE_OFF;
- interrupt_en = 0; /* Disable all interrupts */
- }
- writel(interrupt_en, data->base + EXYNOS4_TMU_REG_INTEN);
- writel(con, data->base + EXYNOS4_TMU_REG_CONTROL);
-
- clk_disable(data->clk);
- mutex_unlock(&data->lock);
-}
-
-static int exynos4_tmu_read(struct exynos4_tmu_data *data)
-{
- u8 temp_code;
- int temp;
-
- mutex_lock(&data->lock);
- clk_enable(data->clk);
-
- temp_code = readb(data->base + EXYNOS4_TMU_REG_CURRENT_TEMP);
- temp = code_to_temp(data, temp_code);
-
- clk_disable(data->clk);
- mutex_unlock(&data->lock);
-
- return temp;
-}
-
-static void exynos4_tmu_work(struct work_struct *work)
-{
- struct exynos4_tmu_data *data = container_of(work,
- struct exynos4_tmu_data, irq_work);
-
- mutex_lock(&data->lock);
- clk_enable(data->clk);
-
- writel(EXYNOS4_TMU_INTCLEAR_VAL, data->base + EXYNOS4_TMU_REG_INTCLEAR);
-
- kobject_uevent(&data->hwmon_dev->kobj, KOBJ_CHANGE);
-
- enable_irq(data->irq);
-
- clk_disable(data->clk);
- mutex_unlock(&data->lock);
-}
-
-static irqreturn_t exynos4_tmu_irq(int irq, void *id)
-{
- struct exynos4_tmu_data *data = id;
-
- disable_irq_nosync(irq);
- schedule_work(&data->irq_work);
-
- return IRQ_HANDLED;
-}
-
-static ssize_t exynos4_tmu_show_name(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- return sprintf(buf, "exynos4-tmu\n");
-}
-
-static ssize_t exynos4_tmu_show_temp(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- struct exynos4_tmu_data *data = dev_get_drvdata(dev);
- int ret;
-
- ret = exynos4_tmu_read(data);
- if (ret < 0)
- return ret;
-
- /* convert from degree Celsius to millidegree Celsius */
- return sprintf(buf, "%d\n", ret * 1000);
-}
-
-static ssize_t exynos4_tmu_show_alarm(struct device *dev,
- struct device_attribute *devattr, char *buf)
-{
- struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
- struct exynos4_tmu_data *data = dev_get_drvdata(dev);
- struct exynos4_tmu_platform_data *pdata = data->pdata;
- int temp;
- unsigned int trigger_level;
-
- temp = exynos4_tmu_read(data);
- if (temp < 0)
- return temp;
-
- trigger_level = pdata->threshold + pdata->trigger_levels[attr->index];
-
- return sprintf(buf, "%d\n", !!(temp > trigger_level));
-}
-
-static ssize_t exynos4_tmu_show_level(struct device *dev,
- struct device_attribute *devattr, char *buf)
-{
- struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
- struct exynos4_tmu_data *data = dev_get_drvdata(dev);
- struct exynos4_tmu_platform_data *pdata = data->pdata;
- unsigned int temp = pdata->threshold +
- pdata->trigger_levels[attr->index];
-
- return sprintf(buf, "%u\n", temp * 1000);
-}
-
-static DEVICE_ATTR(name, S_IRUGO, exynos4_tmu_show_name, NULL);
-static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, exynos4_tmu_show_temp, NULL, 0);
-
-static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO,
- exynos4_tmu_show_alarm, NULL, 1);
-static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO,
- exynos4_tmu_show_alarm, NULL, 2);
-static SENSOR_DEVICE_ATTR(temp1_emergency_alarm, S_IRUGO,
- exynos4_tmu_show_alarm, NULL, 3);
-
-static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, exynos4_tmu_show_level, NULL, 1);
-static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, exynos4_tmu_show_level, NULL, 2);
-static SENSOR_DEVICE_ATTR(temp1_emergency, S_IRUGO,
- exynos4_tmu_show_level, NULL, 3);
-
-static struct attribute *exynos4_tmu_attributes[] = {
- &dev_attr_name.attr,
- &sensor_dev_attr_temp1_input.dev_attr.attr,
- &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
- &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
- &sensor_dev_attr_temp1_emergency_alarm.dev_attr.attr,
- &sensor_dev_attr_temp1_max.dev_attr.attr,
- &sensor_dev_attr_temp1_crit.dev_attr.attr,
- &sensor_dev_attr_temp1_emergency.dev_attr.attr,
- NULL,
-};
-
-static const struct attribute_group exynos4_tmu_attr_group = {
- .attrs = exynos4_tmu_attributes,
-};
-
-static int __devinit exynos4_tmu_probe(struct platform_device *pdev)
-{
- struct exynos4_tmu_data *data;
- struct exynos4_tmu_platform_data *pdata = pdev->dev.platform_data;
- int ret;
-
- if (!pdata) {
- dev_err(&pdev->dev, "No platform init data supplied.\n");
- return -ENODEV;
- }
-
- data = kzalloc(sizeof(struct exynos4_tmu_data), GFP_KERNEL);
- if (!data) {
- dev_err(&pdev->dev, "Failed to allocate driver structure\n");
- return -ENOMEM;
- }
-
- data->irq = platform_get_irq(pdev, 0);
- if (data->irq < 0) {
- ret = data->irq;
- dev_err(&pdev->dev, "Failed to get platform irq\n");
- goto err_free;
- }
-
- INIT_WORK(&data->irq_work, exynos4_tmu_work);
-
- data->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- if (!data->mem) {
- ret = -ENOENT;
- dev_err(&pdev->dev, "Failed to get platform resource\n");
- goto err_free;
- }
-
- data->mem = request_mem_region(data->mem->start,
- resource_size(data->mem), pdev->name);
- if (!data->mem) {
- ret = -ENODEV;
- dev_err(&pdev->dev, "Failed to request memory region\n");
- goto err_free;
- }
-
- data->base = ioremap(data->mem->start, resource_size(data->mem));
- if (!data->base) {
- ret = -ENODEV;
- dev_err(&pdev->dev, "Failed to ioremap memory\n");
- goto err_mem_region;
- }
-
- ret = request_irq(data->irq, exynos4_tmu_irq,
- IRQF_TRIGGER_RISING,
- "exynos4-tmu", data);
- if (ret) {
- dev_err(&pdev->dev, "Failed to request irq: %d\n", data->irq);
- goto err_io_remap;
- }
-
- data->clk = clk_get(NULL, "tmu_apbif");
- if (IS_ERR(data->clk)) {
- ret = PTR_ERR(data->clk);
- dev_err(&pdev->dev, "Failed to get clock\n");
- goto err_irq;
- }
-
- data->pdata = pdata;
- platform_set_drvdata(pdev, data);
- mutex_init(&data->lock);
-
- ret = exynos4_tmu_initialize(pdev);
- if (ret) {
- dev_err(&pdev->dev, "Failed to initialize TMU\n");
- goto err_clk;
- }
-
- ret = sysfs_create_group(&pdev->dev.kobj, &exynos4_tmu_attr_group);
- if (ret) {
- dev_err(&pdev->dev, "Failed to create sysfs group\n");
- goto err_clk;
- }
-
- data->hwmon_dev = hwmon_device_register(&pdev->dev);
- if (IS_ERR(data->hwmon_dev)) {
- ret = PTR_ERR(data->hwmon_dev);
- dev_err(&pdev->dev, "Failed to register hwmon device\n");
- goto err_create_group;
- }
-
- exynos4_tmu_control(pdev, true);
-
- return 0;
-
-err_create_group:
- sysfs_remove_group(&pdev->dev.kobj, &exynos4_tmu_attr_group);
-err_clk:
- platform_set_drvdata(pdev, NULL);
- clk_put(data->clk);
-err_irq:
- free_irq(data->irq, data);
-err_io_remap:
- iounmap(data->base);
-err_mem_region:
- release_mem_region(data->mem->start, resource_size(data->mem));
-err_free:
- kfree(data);
-
- return ret;
-}
-
-static int __devexit exynos4_tmu_remove(struct platform_device *pdev)
-{
- struct exynos4_tmu_data *data = platform_get_drvdata(pdev);
-
- exynos4_tmu_control(pdev, false);
-
- hwmon_device_unregister(data->hwmon_dev);
- sysfs_remove_group(&pdev->dev.kobj, &exynos4_tmu_attr_group);
-
- clk_put(data->clk);
-
- free_irq(data->irq, data);
-
- iounmap(data->base);
- release_mem_region(data->mem->start, resource_size(data->mem));
-
- platform_set_drvdata(pdev, NULL);
-
- kfree(data);
-
- return 0;
-}
-
-#ifdef CONFIG_PM
-static int exynos4_tmu_suspend(struct platform_device *pdev, pm_message_t state)
-{
- exynos4_tmu_control(pdev, false);
-
- return 0;
-}
-
-static int exynos4_tmu_resume(struct platform_device *pdev)
-{
- exynos4_tmu_initialize(pdev);
- exynos4_tmu_control(pdev, true);
-
- return 0;
-}
-#else
-#define exynos4_tmu_suspend NULL
-#define exynos4_tmu_resume NULL
-#endif
-
-static struct platform_driver exynos4_tmu_driver = {
- .driver = {
- .name = "exynos4-tmu",
- .owner = THIS_MODULE,
- },
- .probe = exynos4_tmu_probe,
- .remove = __devexit_p(exynos4_tmu_remove),
- .suspend = exynos4_tmu_suspend,
- .resume = exynos4_tmu_resume,
-};
-
-module_platform_driver(exynos4_tmu_driver);
-
-MODULE_DESCRIPTION("EXYNOS4 TMU Driver");
-MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:exynos4-tmu");
diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
index d9c529f..b0806cf 100644
--- a/drivers/thermal/Kconfig
+++ b/drivers/thermal/Kconfig
@@ -37,3 +37,12 @@ config SPEAR_THERMAL
help
Enable this to plug the SPEAr thermal sensor driver into the Linux
thermal framework
+
+config EXYNOS_THERMAL
+ tristate "Temperature sensor on Samsung EXYNOS4"
+ depends on ARCH_EXYNOS4 && THERMAL
+ help
+ If you say yes here you get support for TMU (Thermal Managment
+ Unit) on SAMSUNG EXYNOS4 series of SoC.
+ This driver can also be built as a module. If so, the module
+ will be called exynos4-tmu
diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
index 30c456c..4636e35 100644
--- a/drivers/thermal/Makefile
+++ b/drivers/thermal/Makefile
@@ -5,3 +5,4 @@
obj-$(CONFIG_THERMAL) += thermal_sys.o
obj-$(CONFIG_CPU_THERMAL) += cpu_cooling.o
obj-$(CONFIG_SPEAR_THERMAL) += spear_thermal.o
+obj-$(CONFIG_EXYNOS_THERMAL) += exynos_thermal.o
diff --git a/drivers/thermal/exynos_thermal.c b/drivers/thermal/exynos_thermal.c
new file mode 100644
index 0000000..bda02fe
--- /dev/null
+++ b/drivers/thermal/exynos_thermal.c
@@ -0,0 +1,409 @@
+/*
+ * exynos_thermal.c - Samsung EXYNOS TMU (Thermal Management Unit)
+ *
+ * Copyright (C) 2011 Samsung Electronics
+ * Donggeun Kim <dg77.kim@samsung.com>
+ * Amit Daniel Kachhap <amit.kachhap@linaro.org>
+ *
+ * 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/clk.h>
+#include <linux/workqueue.h>
+#include <linux/sysfs.h>
+#include <linux/kobject.h>
+#include <linux/io.h>
+#include <linux/mutex.h>
+
+#include <linux/platform_data/exynos_thermal.h>
+
+#define EXYNOS4_TMU_REG_TRIMINFO 0x0
+#define EXYNOS4_TMU_REG_CONTROL 0x20
+#define EXYNOS4_TMU_REG_STATUS 0x28
+#define EXYNOS4_TMU_REG_CURRENT_TEMP 0x40
+#define EXYNOS4_TMU_REG_THRESHOLD_TEMP 0x44
+#define EXYNOS4_TMU_REG_TRIG_LEVEL0 0x50
+#define EXYNOS4_TMU_REG_TRIG_LEVEL1 0x54
+#define EXYNOS4_TMU_REG_TRIG_LEVEL2 0x58
+#define EXYNOS4_TMU_REG_TRIG_LEVEL3 0x5C
+#define EXYNOS4_TMU_REG_PAST_TEMP0 0x60
+#define EXYNOS4_TMU_REG_PAST_TEMP1 0x64
+#define EXYNOS4_TMU_REG_PAST_TEMP2 0x68
+#define EXYNOS4_TMU_REG_PAST_TEMP3 0x6C
+#define EXYNOS4_TMU_REG_INTEN 0x70
+#define EXYNOS4_TMU_REG_INTSTAT 0x74
+#define EXYNOS4_TMU_REG_INTCLEAR 0x78
+
+#define EXYNOS4_TMU_GAIN_SHIFT 8
+#define EXYNOS4_TMU_REF_VOLTAGE_SHIFT 24
+
+#define EXYNOS4_TMU_TRIM_TEMP_MASK 0xff
+#define EXYNOS4_TMU_CORE_ON 3
+#define EXYNOS4_TMU_CORE_OFF 2
+#define EXYNOS4_TMU_DEF_CODE_TO_TEMP_OFFSET 50
+#define EXYNOS4_TMU_TRIG_LEVEL0_MASK 0x1
+#define EXYNOS4_TMU_TRIG_LEVEL1_MASK 0x10
+#define EXYNOS4_TMU_TRIG_LEVEL2_MASK 0x100
+#define EXYNOS4_TMU_TRIG_LEVEL3_MASK 0x1000
+#define EXYNOS4_TMU_INTCLEAR_VAL 0x1111
+
+struct exynos4_tmu_data {
+ struct exynos4_tmu_platform_data *pdata;
+ struct resource *mem;
+ void __iomem *base;
+ int irq;
+ struct work_struct irq_work;
+ struct mutex lock;
+ struct clk *clk;
+ u8 temp_error1, temp_error2;
+};
+
+/*
+ * TMU treats temperature as a mapped temperature code.
+ * The temperature is converted differently depending on the calibration type.
+ */
+static int temp_to_code(struct exynos4_tmu_data *data, u8 temp)
+{
+ struct exynos4_tmu_platform_data *pdata = data->pdata;
+ int temp_code;
+
+ /* temp should range between 25 and 125 */
+ if (temp < 25 || temp > 125) {
+ temp_code = -EINVAL;
+ goto out;
+ }
+
+ switch (pdata->cal_type) {
+ case TYPE_TWO_POINT_TRIMMING:
+ temp_code = (temp - 25) *
+ (data->temp_error2 - data->temp_error1) /
+ (85 - 25) + data->temp_error1;
+ break;
+ case TYPE_ONE_POINT_TRIMMING:
+ temp_code = temp + data->temp_error1 - 25;
+ break;
+ default:
+ temp_code = temp + EXYNOS4_TMU_DEF_CODE_TO_TEMP_OFFSET;
+ break;
+ }
+out:
+ return temp_code;
+}
+
+/*
+ * Calculate a temperature value from a temperature code.
+ * The unit of the temperature is degree Celsius.
+ */
+static int code_to_temp(struct exynos4_tmu_data *data, u8 temp_code)
+{
+ struct exynos4_tmu_platform_data *pdata = data->pdata;
+ int temp;
+
+ /* temp_code should range between 75 and 175 */
+ if (temp_code < 75 || temp_code > 175) {
+ temp = -ENODATA;
+ goto out;
+ }
+
+ switch (pdata->cal_type) {
+ case TYPE_TWO_POINT_TRIMMING:
+ temp = (temp_code - data->temp_error1) * (85 - 25) /
+ (data->temp_error2 - data->temp_error1) + 25;
+ break;
+ case TYPE_ONE_POINT_TRIMMING:
+ temp = temp_code - data->temp_error1 + 25;
+ break;
+ default:
+ temp = temp_code - EXYNOS4_TMU_DEF_CODE_TO_TEMP_OFFSET;
+ break;
+ }
+out:
+ return temp;
+}
+
+static int exynos4_tmu_initialize(struct platform_device *pdev)
+{
+ struct exynos4_tmu_data *data = platform_get_drvdata(pdev);
+ struct exynos4_tmu_platform_data *pdata = data->pdata;
+ unsigned int status, trim_info;
+ int ret = 0, threshold_code;
+
+ mutex_lock(&data->lock);
+ clk_enable(data->clk);
+
+ status = readb(data->base + EXYNOS4_TMU_REG_STATUS);
+ if (!status) {
+ ret = -EBUSY;
+ goto out;
+ }
+
+ /* Save trimming info in order to perform calibration */
+ trim_info = readl(data->base + EXYNOS4_TMU_REG_TRIMINFO);
+ data->temp_error1 = trim_info & EXYNOS4_TMU_TRIM_TEMP_MASK;
+ data->temp_error2 = ((trim_info >> 8) & EXYNOS4_TMU_TRIM_TEMP_MASK);
+
+ /* Write temperature code for threshold */
+ threshold_code = temp_to_code(data, pdata->threshold);
+ if (threshold_code < 0) {
+ ret = threshold_code;
+ goto out;
+ }
+ writeb(threshold_code,
+ data->base + EXYNOS4_TMU_REG_THRESHOLD_TEMP);
+
+ writeb(pdata->trigger_levels[0],
+ data->base + EXYNOS4_TMU_REG_TRIG_LEVEL0);
+ writeb(pdata->trigger_levels[1],
+ data->base + EXYNOS4_TMU_REG_TRIG_LEVEL1);
+ writeb(pdata->trigger_levels[2],
+ data->base + EXYNOS4_TMU_REG_TRIG_LEVEL2);
+ writeb(pdata->trigger_levels[3],
+ data->base + EXYNOS4_TMU_REG_TRIG_LEVEL3);
+
+ writel(EXYNOS4_TMU_INTCLEAR_VAL,
+ data->base + EXYNOS4_TMU_REG_INTCLEAR);
+out:
+ clk_disable(data->clk);
+ mutex_unlock(&data->lock);
+
+ return ret;
+}
+
+static void exynos4_tmu_control(struct platform_device *pdev, bool on)
+{
+ struct exynos4_tmu_data *data = platform_get_drvdata(pdev);
+ struct exynos4_tmu_platform_data *pdata = data->pdata;
+ unsigned int con, interrupt_en;
+
+ mutex_lock(&data->lock);
+ clk_enable(data->clk);
+
+ con = pdata->reference_voltage << EXYNOS4_TMU_REF_VOLTAGE_SHIFT |
+ pdata->gain << EXYNOS4_TMU_GAIN_SHIFT;
+ if (on) {
+ con |= EXYNOS4_TMU_CORE_ON;
+ interrupt_en = pdata->trigger_level3_en << 12 |
+ pdata->trigger_level2_en << 8 |
+ pdata->trigger_level1_en << 4 |
+ pdata->trigger_level0_en;
+ } else {
+ con |= EXYNOS4_TMU_CORE_OFF;
+ interrupt_en = 0; /* Disable all interrupts */
+ }
+ writel(interrupt_en, data->base + EXYNOS4_TMU_REG_INTEN);
+ writel(con, data->base + EXYNOS4_TMU_REG_CONTROL);
+
+ clk_disable(data->clk);
+ mutex_unlock(&data->lock);
+}
+
+static int exynos4_tmu_read(struct exynos4_tmu_data *data)
+{
+ u8 temp_code;
+ int temp;
+
+ mutex_lock(&data->lock);
+ clk_enable(data->clk);
+
+ temp_code = readb(data->base + EXYNOS4_TMU_REG_CURRENT_TEMP);
+ temp = code_to_temp(data, temp_code);
+
+ clk_disable(data->clk);
+ mutex_unlock(&data->lock);
+
+ return temp;
+}
+
+static void exynos4_tmu_work(struct work_struct *work)
+{
+ struct exynos4_tmu_data *data = container_of(work,
+ struct exynos4_tmu_data, irq_work);
+
+ mutex_lock(&data->lock);
+ clk_enable(data->clk);
+
+ writel(EXYNOS4_TMU_INTCLEAR_VAL, data->base + EXYNOS4_TMU_REG_INTCLEAR);
+
+ enable_irq(data->irq);
+
+ clk_disable(data->clk);
+ mutex_unlock(&data->lock);
+}
+
+static irqreturn_t exynos4_tmu_irq(int irq, void *id)
+{
+ struct exynos4_tmu_data *data = id;
+
+ disable_irq_nosync(irq);
+ schedule_work(&data->irq_work);
+
+ return IRQ_HANDLED;
+}
+
+static int __devinit exynos4_tmu_probe(struct platform_device *pdev)
+{
+ struct exynos4_tmu_data *data;
+ struct exynos4_tmu_platform_data *pdata = pdev->dev.platform_data;
+ int ret;
+
+ if (!pdata) {
+ dev_err(&pdev->dev, "No platform init data supplied.\n");
+ return -ENODEV;
+ }
+
+ data = kzalloc(sizeof(struct exynos4_tmu_data), GFP_KERNEL);
+ if (!data) {
+ dev_err(&pdev->dev, "Failed to allocate driver structure\n");
+ return -ENOMEM;
+ }
+
+ data->irq = platform_get_irq(pdev, 0);
+ if (data->irq < 0) {
+ ret = data->irq;
+ dev_err(&pdev->dev, "Failed to get platform irq\n");
+ goto err_free;
+ }
+
+ INIT_WORK(&data->irq_work, exynos4_tmu_work);
+
+ data->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (!data->mem) {
+ ret = -ENOENT;
+ dev_err(&pdev->dev, "Failed to get platform resource\n");
+ goto err_free;
+ }
+
+ data->mem = request_mem_region(data->mem->start,
+ resource_size(data->mem), pdev->name);
+ if (!data->mem) {
+ ret = -ENODEV;
+ dev_err(&pdev->dev, "Failed to request memory region\n");
+ goto err_free;
+ }
+
+ data->base = ioremap(data->mem->start, resource_size(data->mem));
+ if (!data->base) {
+ ret = -ENODEV;
+ dev_err(&pdev->dev, "Failed to ioremap memory\n");
+ goto err_mem_region;
+ }
+
+ ret = request_irq(data->irq, exynos4_tmu_irq,
+ IRQF_TRIGGER_RISING,
+ "exynos4-tmu", data);
+ if (ret) {
+ dev_err(&pdev->dev, "Failed to request irq: %d\n", data->irq);
+ goto err_io_remap;
+ }
+
+ data->clk = clk_get(NULL, "tmu_apbif");
+ if (IS_ERR(data->clk)) {
+ ret = PTR_ERR(data->clk);
+ dev_err(&pdev->dev, "Failed to get clock\n");
+ goto err_irq;
+ }
+
+ data->pdata = pdata;
+ platform_set_drvdata(pdev, data);
+ mutex_init(&data->lock);
+
+ ret = exynos4_tmu_initialize(pdev);
+ if (ret) {
+ dev_err(&pdev->dev, "Failed to initialize TMU\n");
+ goto err_clk;
+ }
+
+ exynos4_tmu_control(pdev, true);
+
+ return 0;
+err_clk:
+ platform_set_drvdata(pdev, NULL);
+ clk_put(data->clk);
+err_irq:
+ free_irq(data->irq, data);
+err_io_remap:
+ iounmap(data->base);
+err_mem_region:
+ release_mem_region(data->mem->start, resource_size(data->mem));
+err_free:
+ kfree(data);
+
+ return ret;
+}
+
+static int __devexit exynos4_tmu_remove(struct platform_device *pdev)
+{
+ struct exynos4_tmu_data *data = platform_get_drvdata(pdev);
+
+ exynos4_tmu_control(pdev, false);
+
+ clk_put(data->clk);
+
+ free_irq(data->irq, data);
+
+ iounmap(data->base);
+ release_mem_region(data->mem->start, resource_size(data->mem));
+
+ platform_set_drvdata(pdev, NULL);
+
+ kfree(data);
+
+ return 0;
+}
+
+#ifdef CONFIG_PM
+static int exynos4_tmu_suspend(struct platform_device *pdev, pm_message_t state)
+{
+ exynos4_tmu_control(pdev, false);
+
+ return 0;
+}
+
+static int exynos4_tmu_resume(struct platform_device *pdev)
+{
+ exynos4_tmu_initialize(pdev);
+ exynos4_tmu_control(pdev, true);
+
+ return 0;
+}
+#else
+#define exynos4_tmu_suspend NULL
+#define exynos4_tmu_resume NULL
+#endif
+
+static struct platform_driver exynos4_tmu_driver = {
+ .driver = {
+ .name = "exynos4-tmu",
+ .owner = THIS_MODULE,
+ },
+ .probe = exynos4_tmu_probe,
+ .remove = __devexit_p(exynos4_tmu_remove),
+ .suspend = exynos4_tmu_suspend,
+ .resume = exynos4_tmu_resume,
+};
+
+module_platform_driver(exynos4_tmu_driver);
+
+MODULE_DESCRIPTION("EXYNOS4 TMU Driver");
+MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:exynos4-tmu");
diff --git a/include/linux/platform_data/exynos4_tmu.h b/include/linux/platform_data/exynos4_tmu.h
deleted file mode 100644
index 39e038c..0000000
--- a/include/linux/platform_data/exynos4_tmu.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * exynos4_tmu.h - Samsung EXYNOS4 TMU (Thermal Management Unit)
- *
- * Copyright (C) 2011 Samsung Electronics
- * Donggeun Kim <dg77.kim@samsung.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; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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 _LINUX_EXYNOS4_TMU_H
-#define _LINUX_EXYNOS4_TMU_H
-
-enum calibration_type {
- TYPE_ONE_POINT_TRIMMING,
- TYPE_TWO_POINT_TRIMMING,
- TYPE_NONE,
-};
-
-/**
- * struct exynos4_tmu_platform_data
- * @threshold: basic temperature for generating interrupt
- * 25 <= threshold <= 125 [unit: degree Celsius]
- * @trigger_levels: array for each interrupt levels
- * [unit: degree Celsius]
- * 0: temperature for trigger_level0 interrupt
- * condition for trigger_level0 interrupt:
- * current temperature > threshold + trigger_levels[0]
- * 1: temperature for trigger_level1 interrupt
- * condition for trigger_level1 interrupt:
- * current temperature > threshold + trigger_levels[1]
- * 2: temperature for trigger_level2 interrupt
- * condition for trigger_level2 interrupt:
- * current temperature > threshold + trigger_levels[2]
- * 3: temperature for trigger_level3 interrupt
- * condition for trigger_level3 interrupt:
- * current temperature > threshold + trigger_levels[3]
- * @trigger_level0_en:
- * 1 = enable trigger_level0 interrupt,
- * 0 = disable trigger_level0 interrupt
- * @trigger_level1_en:
- * 1 = enable trigger_level1 interrupt,
- * 0 = disable trigger_level1 interrupt
- * @trigger_level2_en:
- * 1 = enable trigger_level2 interrupt,
- * 0 = disable trigger_level2 interrupt
- * @trigger_level3_en:
- * 1 = enable trigger_level3 interrupt,
- * 0 = disable trigger_level3 interrupt
- * @gain: gain of amplifier in the positive-TC generator block
- * 0 <= gain <= 15
- * @reference_voltage: reference voltage of amplifier
- * in the positive-TC generator block
- * 0 <= reference_voltage <= 31
- * @cal_type: calibration type for temperature
- *
- * This structure is required for configuration of exynos4_tmu driver.
- */
-struct exynos4_tmu_platform_data {
- u8 threshold;
- u8 trigger_levels[4];
- bool trigger_level0_en;
- bool trigger_level1_en;
- bool trigger_level2_en;
- bool trigger_level3_en;
-
- u8 gain;
- u8 reference_voltage;
-
- enum calibration_type cal_type;
-};
-#endif /* _LINUX_EXYNOS4_TMU_H */
diff --git a/include/linux/platform_data/exynos_thermal.h b/include/linux/platform_data/exynos_thermal.h
new file mode 100644
index 0000000..d6c3f93
--- /dev/null
+++ b/include/linux/platform_data/exynos_thermal.h
@@ -0,0 +1,83 @@
+/*
+ * exynos_thermal.h - Samsung EXYNOS4 TMU (Thermal Management Unit)
+ *
+ * Copyright (C) 2011 Samsung Electronics
+ * Donggeun Kim <dg77.kim@samsung.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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 _LINUX_EXYNOS_THERMAL_H
+#define _LINUX_EXYNOS_THERMAL_H
+
+enum calibration_type {
+ TYPE_ONE_POINT_TRIMMING,
+ TYPE_TWO_POINT_TRIMMING,
+ TYPE_NONE,
+};
+
+/**
+ * struct exynos4_tmu_platform_data
+ * @threshold: basic temperature for generating interrupt
+ * 25 <= threshold <= 125 [unit: degree Celsius]
+ * @trigger_levels: array for each interrupt levels
+ * [unit: degree Celsius]
+ * 0: temperature for trigger_level0 interrupt
+ * condition for trigger_level0 interrupt:
+ * current temperature > threshold + trigger_levels[0]
+ * 1: temperature for trigger_level1 interrupt
+ * condition for trigger_level1 interrupt:
+ * current temperature > threshold + trigger_levels[1]
+ * 2: temperature for trigger_level2 interrupt
+ * condition for trigger_level2 interrupt:
+ * current temperature > threshold + trigger_levels[2]
+ * 3: temperature for trigger_level3 interrupt
+ * condition for trigger_level3 interrupt:
+ * current temperature > threshold + trigger_levels[3]
+ * @trigger_level0_en:
+ * 1 = enable trigger_level0 interrupt,
+ * 0 = disable trigger_level0 interrupt
+ * @trigger_level1_en:
+ * 1 = enable trigger_level1 interrupt,
+ * 0 = disable trigger_level1 interrupt
+ * @trigger_level2_en:
+ * 1 = enable trigger_level2 interrupt,
+ * 0 = disable trigger_level2 interrupt
+ * @trigger_level3_en:
+ * 1 = enable trigger_level3 interrupt,
+ * 0 = disable trigger_level3 interrupt
+ * @gain: gain of amplifier in the positive-TC generator block
+ * 0 <= gain <= 15
+ * @reference_voltage: reference voltage of amplifier
+ * in the positive-TC generator block
+ * 0 <= reference_voltage <= 31
+ * @cal_type: calibration type for temperature
+ *
+ * This structure is required for configuration of exynos4_tmu driver.
+ */
+struct exynos4_tmu_platform_data {
+ u8 threshold;
+ u8 trigger_levels[4];
+ bool trigger_level0_en;
+ bool trigger_level1_en;
+ bool trigger_level2_en;
+ bool trigger_level3_en;
+
+ u8 gain;
+ u8 reference_voltage;
+
+ enum calibration_type cal_type;
+};
+#endif /* _LINUX_EXYNOS_THERMAL_H */
--
1.7.1
^ permalink raw reply related
* [PATCH v4 1/5] thermal: Add generic cpufreq cooling implementation
From: Amit Daniel Kachhap @ 2012-05-12 9:40 UTC (permalink / raw)
To: linux-pm, akpm
Cc: linux-samsung-soc, patches, linux-kernel, lm-sensors, linux-acpi,
khali, linaro-dev, guenter.roeck
In-Reply-To: <1336815645-29625-1-git-send-email-amit.kachhap@linaro.org>
This patch adds support for generic cpu thermal cooling low level
implementations using frequency scaling up/down based on the registration
parameters. Different cpu related cooling devices can be registered by the
user and the binding of these cooling devices to the corresponding
trip points can be easily done as the registration APIs return the
cooling device pointer. The user of these APIs are responsible for
passing clipping frequency . The drivers can also register to recieve
notification about any cooling action called.
Signed-off-by: Amit Daniel Kachhap <amit.kachhap@linaro.org>
---
Documentation/thermal/cpu-cooling-api.txt | 60 ++++
drivers/thermal/Kconfig | 11 +
drivers/thermal/Makefile | 3 +-
drivers/thermal/cpu_cooling.c | 483 +++++++++++++++++++++++++++++
include/linux/cpu_cooling.h | 99 ++++++
5 files changed, 655 insertions(+), 1 deletions(-)
create mode 100644 Documentation/thermal/cpu-cooling-api.txt
create mode 100644 drivers/thermal/cpu_cooling.c
create mode 100644 include/linux/cpu_cooling.h
diff --git a/Documentation/thermal/cpu-cooling-api.txt b/Documentation/thermal/cpu-cooling-api.txt
new file mode 100644
index 0000000..557adb8
--- /dev/null
+++ b/Documentation/thermal/cpu-cooling-api.txt
@@ -0,0 +1,60 @@
+CPU cooling APIs How To
+===================================
+
+Written by Amit Daniel Kachhap <amit.kachhap@linaro.org>
+
+Updated: 12 May 2012
+
+Copyright (c) 2012 Samsung Electronics Co., Ltd(http://www.samsung.com)
+
+0. Introduction
+
+The generic cpu cooling(freq clipping, cpuhotplug etc) provides
+registration/unregistration APIs to the caller. The binding of the cooling
+devices to the trip point is left for the user. The registration APIs returns
+the cooling device pointer.
+
+1. cpu cooling APIs
+
+1.1 cpufreq registration/unregistration APIs
+1.1.1 struct thermal_cooling_device *cpufreq_cooling_register(
+ struct freq_clip_table *tab_ptr, unsigned int tab_size)
+
+ This interface function registers the cpufreq cooling device with the name
+ "thermal-cpufreq-%x". This api can support multiple instances of cpufreq
+ cooling devices.
+
+ tab_ptr: The table containing the maximum value of frequency to be clipped
+ for each cooling state.
+ .freq_clip_max: Value of frequency to be clipped for each allowed
+ cpus.
+ .temp_level: Temperature level at which the frequency clamping will
+ happen.
+ .mask_val: cpumask of the allowed cpu's
+ tab_size: the total number of cpufreq cooling states.
+
+1.1.2 void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev)
+
+ This interface function unregisters the "thermal-cpufreq-%x" cooling device.
+
+ cdev: Cooling device pointer which has to be unregistered.
+
+
+1.2 CPU cooling action notifier register/unregister interface
+1.2.1 int cputherm_register_notifier(struct notifier_block *nb,
+ unsigned int list)
+
+ This interface registers a driver with cpu cooling layer. The driver will
+ be notified when any cpu cooling action is called.
+
+ nb: notifier function to register
+ list: CPUFREQ_COOLING_START or CPUFREQ_COOLING_STOP
+
+1.2.2 int cputherm_unregister_notifier(struct notifier_block *nb,
+ unsigned int list)
+
+ This interface registers a driver with cpu cooling layer. The driver will
+ be notified when any cpu cooling action is called.
+
+ nb: notifier function to register
+ list: CPUFREQ_COOLING_START or CPUFREQ_COOLING_STOP
diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
index 514a691..d9c529f 100644
--- a/drivers/thermal/Kconfig
+++ b/drivers/thermal/Kconfig
@@ -19,6 +19,17 @@ config THERMAL_HWMON
depends on HWMON=y || HWMON=THERMAL
default y
+config CPU_THERMAL
+ bool "generic cpu cooling support"
+ depends on THERMAL && CPU_FREQ
+ help
+ This implements the generic cpu cooling mechanism through frequency
+ reduction, cpu hotplug and any other ways of reducing temperature. An
+ ACPI version of this already exists(drivers/acpi/processor_thermal.c).
+ This will be useful for platforms using the generic thermal interface
+ and not the ACPI interface.
+ If you want this support, you should say Y or M here.
+
config SPEAR_THERMAL
bool "SPEAr thermal sensor driver"
depends on THERMAL
diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
index a9fff0b..30c456c 100644
--- a/drivers/thermal/Makefile
+++ b/drivers/thermal/Makefile
@@ -3,4 +3,5 @@
#
obj-$(CONFIG_THERMAL) += thermal_sys.o
-obj-$(CONFIG_SPEAR_THERMAL) += spear_thermal.o
\ No newline at end of file
+obj-$(CONFIG_CPU_THERMAL) += cpu_cooling.o
+obj-$(CONFIG_SPEAR_THERMAL) += spear_thermal.o
diff --git a/drivers/thermal/cpu_cooling.c b/drivers/thermal/cpu_cooling.c
new file mode 100644
index 0000000..c40d9a0
--- /dev/null
+++ b/drivers/thermal/cpu_cooling.c
@@ -0,0 +1,483 @@
+/*
+ * linux/drivers/thermal/cpu_cooling.c
+ *
+ * Copyright (C) 2012 Samsung Electronics Co., Ltd(http://www.samsung.com)
+ * Copyright (C) 2012 Amit Daniel <amit.kachhap@linaro.org>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * 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.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/thermal.h>
+#include <linux/platform_device.h>
+#include <linux/cpufreq.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/cpu.h>
+#include <linux/cpu_cooling.h>
+
+/**
+ * struct cpufreq_cooling_device
+ * @id: unique integer value corresponding to each cpufreq_cooling_device
+ * registered.
+ * @cool_dev: thermal_cooling_device pointer to keep track of the the
+ * egistered cooling device.
+ * @tab_ptr: freq_clip_table table containing the maximum value of frequency to
+ * be set for different cooling state.
+ * @tab_size: integer value representing a count of the above table.
+ * @cpufreq_state: integer value representing the current state of cpufreq
+ * cooling devices.
+ * @allowed_cpus: all the cpus involved for this cpufreq_cooling_device.
+ * @node: list_head to link all cpufreq_cooling_device together.
+ *
+ * This structure is required for keeping information of each
+ * cpufreq_cooling_device registered as a list whose head is represented by
+ * cooling_cpufreq_list. In order to prevent corruption of this list a
+ * mutex lock cooling_cpufreq_lock is used.
+ */
+struct cpufreq_cooling_device {
+ int id;
+ struct thermal_cooling_device *cool_dev;
+ struct freq_clip_table *tab_ptr;
+ unsigned int tab_size;
+ unsigned int cpufreq_state;
+ struct cpumask allowed_cpus;
+ struct list_head node;
+};
+static LIST_HEAD(cooling_cpufreq_list);
+static DEFINE_MUTEX(cooling_cpufreq_lock);
+static DEFINE_IDR(cpufreq_idr);
+
+/*per cpu variable to store the previous max frequency allowed*/
+static DEFINE_PER_CPU(unsigned int, max_policy_freq);
+
+/*notify_table passes value to the CPUFREQ_ADJUST callback function.*/
+#define NOTIFY_INVALID NULL
+static struct freq_clip_table *notify_table;
+
+/*Head of the blocking notifier chain to inform about frequency clamping*/
+static BLOCKING_NOTIFIER_HEAD(cputherm_state_notifier_list);
+
+/**
+ * get_idr - function to get a unique id.
+ * @idr: struct idr * handle used to create a id.
+ * @id: int * value generated by this function.
+ */
+static int get_idr(struct idr *idr, int *id)
+{
+ int err;
+again:
+ if (unlikely(idr_pre_get(idr, GFP_KERNEL) == 0))
+ return -ENOMEM;
+
+ mutex_lock(&cooling_cpufreq_lock);
+ err = idr_get_new(idr, NULL, id);
+ mutex_unlock(&cooling_cpufreq_lock);
+
+ if (unlikely(err == -EAGAIN))
+ goto again;
+ else if (unlikely(err))
+ return err;
+
+ *id = *id & MAX_ID_MASK;
+ return 0;
+}
+
+/**
+ * release_idr - function to free the unique id.
+ * @idr: struct idr * handle used for creating the id.
+ * @id: int value representing the unique id.
+ */
+static void release_idr(struct idr *idr, int id)
+{
+ mutex_lock(&cooling_cpufreq_lock);
+ idr_remove(idr, id);
+ mutex_unlock(&cooling_cpufreq_lock);
+}
+
+/**
+ * cputherm_register_notifier - Register a notifier with cpu cooling interface.
+ * @nb: struct notifier_block * with callback info.
+ * @list: integer value for which notification is needed. possible values are
+ * CPUFREQ_COOLING_START and CPUFREQ_COOLING_STOP.
+ *
+ * This exported function registers a driver with cpu cooling layer. The driver
+ * will be notified when any cpu cooling action is called.
+ */
+int cputherm_register_notifier(struct notifier_block *nb, unsigned int list)
+{
+ int ret = 0;
+
+ switch (list) {
+ case CPUFREQ_COOLING_START:
+ case CPUFREQ_COOLING_STOP:
+ ret = blocking_notifier_chain_register(
+ &cputherm_state_notifier_list, nb);
+ break;
+ default:
+ ret = -EINVAL;
+ }
+ return ret;
+}
+EXPORT_SYMBOL(cputherm_register_notifier);
+
+/**
+ * cputherm_unregister_notifier - Un-register a notifier.
+ * @nb: struct notifier_block * with callback info.
+ * @list: integer value for which notification is needed. values possible are
+ * CPUFREQ_COOLING_START or CPUFREQ_COOLING_STOP.
+ *
+ * This exported function un-registers a driver with cpu cooling layer.
+ */
+int cputherm_unregister_notifier(struct notifier_block *nb, unsigned int list)
+{
+ int ret = 0;
+
+ switch (list) {
+ case CPUFREQ_COOLING_START:
+ case CPUFREQ_COOLING_STOP:
+ ret = blocking_notifier_chain_unregister(
+ &cputherm_state_notifier_list, nb);
+ break;
+ default:
+ ret = -EINVAL;
+ }
+ return ret;
+}
+EXPORT_SYMBOL(cputherm_unregister_notifier);
+
+/*Below codes defines functions to be used for cpufreq as cooling device*/
+
+/**
+ * is_cpufreq_valid - function to check if a cpu has frequency transition policy.
+ * @cpu: cpu for which check is needed.
+ */
+static int is_cpufreq_valid(int cpu)
+{
+ struct cpufreq_policy policy;
+ return !cpufreq_get_policy(&policy, cpu);
+}
+
+/**
+ * cpufreq_apply_cooling - function to apply frequency clipping.
+ * @cpufreq_device: cpufreq_cooling_device pointer containing frequency
+ * clipping data.
+ * @cooling_state: value of the cooling state.
+ */
+static int cpufreq_apply_cooling(struct cpufreq_cooling_device *cpufreq_device,
+ unsigned long cooling_state)
+{
+ unsigned int event, cpuid, state;
+ struct freq_clip_table *th_table, *table_ptr;
+ const struct cpumask *maskPtr = &cpufreq_device->allowed_cpus;
+ struct cpufreq_cooling_device *cpufreq_ptr;
+
+ if (cooling_state > cpufreq_device->tab_size)
+ return -EINVAL;
+
+ /*Check if the old cooling action is same as new cooling action*/
+ if (cpufreq_device->cpufreq_state == cooling_state)
+ return 0;
+
+ /*pass cooling table info to the cpufreq_thermal_notifier callback*/
+ notify_table = NOTIFY_INVALID;
+
+ if (cooling_state > 0) {
+ th_table = &(cpufreq_device->tab_ptr[cooling_state - 1]);
+ notify_table = th_table;
+ }
+
+ /*check if any lower clip frequency active in other cpufreq_device's*/
+ list_for_each_entry(cpufreq_ptr, &cooling_cpufreq_list, node) {
+
+ state = cpufreq_ptr->cpufreq_state;
+ if (state == 0 || cpufreq_ptr == cpufreq_device)
+ continue;
+
+ if (!cpumask_equal(&cpufreq_ptr->allowed_cpus,
+ &cpufreq_device->allowed_cpus))
+ continue;
+
+ table_ptr = &(cpufreq_ptr->tab_ptr[state - 1]);
+ if (notify_table == NULL ||
+ (table_ptr->freq_clip_max <
+ notify_table->freq_clip_max))
+ notify_table = table_ptr;
+ }
+
+ cpufreq_device->cpufreq_state = cooling_state;
+
+ if (notify_table != NOTIFY_INVALID) {
+ event = CPUFREQ_COOLING_START;
+ maskPtr = notify_table->mask_val;
+ } else {
+ event = CPUFREQ_COOLING_STOP;
+ }
+
+ blocking_notifier_call_chain(&cputherm_state_notifier_list,
+ event, notify_table);
+
+ for_each_cpu(cpuid, maskPtr) {
+ if (is_cpufreq_valid(cpuid))
+ cpufreq_update_policy(cpuid);
+ }
+
+ notify_table = NOTIFY_INVALID;
+
+ return 0;
+}
+
+/**
+ * cpufreq_thermal_notifier - notifier callback for cpufreq policy change.
+ * @nb: struct notifier_block * with callback info.
+ * @event: value showing cpufreq event for which this function invoked.
+ * @data: callback-specific data
+ */
+static int cpufreq_thermal_notifier(struct notifier_block *nb,
+ unsigned long event, void *data)
+{
+ struct cpufreq_policy *policy = data;
+ unsigned long max_freq = 0;
+
+ if (event != CPUFREQ_ADJUST)
+ return 0;
+
+ if (notify_table != NOTIFY_INVALID) {
+ max_freq = notify_table->freq_clip_max;
+
+ if (!per_cpu(max_policy_freq, policy->cpu))
+ per_cpu(max_policy_freq, policy->cpu) = policy->max;
+ } else {
+ if (per_cpu(max_policy_freq, policy->cpu)) {
+ max_freq = per_cpu(max_policy_freq, policy->cpu);
+ per_cpu(max_policy_freq, policy->cpu) = 0;
+ } else {
+ max_freq = policy->max;
+ }
+ }
+
+ /* Never exceed user_policy.max*/
+ if (max_freq > policy->user_policy.max)
+ max_freq = policy->user_policy.max;
+
+ if (policy->max != max_freq)
+ cpufreq_verify_within_limits(policy, 0, max_freq);
+
+ return 0;
+}
+
+/*
+ * cpufreq cooling device callback functions are defined below
+ */
+
+/**
+ * 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.
+ */
+static int cpufreq_get_max_state(struct thermal_cooling_device *cdev,
+ unsigned long *state)
+{
+ int ret = -EINVAL;
+ struct cpufreq_cooling_device *cpufreq_device;
+
+ 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->tab_size;
+ ret = 0;
+ break;
+ }
+ }
+ mutex_unlock(&cooling_cpufreq_lock);
+ return ret;
+}
+
+/**
+ * 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.
+ */
+static int cpufreq_get_cur_state(struct thermal_cooling_device *cdev,
+ unsigned long *state)
+{
+ int ret = -EINVAL;
+ struct cpufreq_cooling_device *cpufreq_device;
+
+ 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;
+}
+
+/**
+ * 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.
+ */
+static int cpufreq_set_cur_state(struct thermal_cooling_device *cdev,
+ unsigned long state)
+{
+ int ret = -EINVAL;
+ struct cpufreq_cooling_device *cpufreq_device;
+
+ 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;
+}
+
+/*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,
+};
+
+/*Notifier for cpufreq policy change*/
+static struct notifier_block thermal_cpufreq_notifier_block = {
+ .notifier_call = cpufreq_thermal_notifier,
+};
+
+/**
+ * cpufreq_cooling_register - function to create cpufreq cooling device.
+ * @tab_ptr: table ptr containing the maximum value of frequency to be clipped
+ * for each cooling state.
+ * @tab_size: count of entries in the above table.
+ * happen.
+ */
+struct thermal_cooling_device *cpufreq_cooling_register(
+ struct freq_clip_table *tab_ptr, unsigned int tab_size)
+{
+ struct thermal_cooling_device *cool_dev;
+ struct cpufreq_cooling_device *cpufreq_dev = NULL;
+ struct freq_clip_table *clip_tab;
+ unsigned int cpufreq_dev_count = 0;
+ char dev_name[THERMAL_NAME_LENGTH];
+ int ret = 0, id = 0, i;
+
+ if (tab_ptr == NULL || tab_size == 0)
+ return ERR_PTR(-EINVAL);
+
+ list_for_each_entry(cpufreq_dev, &cooling_cpufreq_list, node)
+ cpufreq_dev_count++;
+
+ cpufreq_dev = kzalloc(sizeof(struct cpufreq_cooling_device),
+ GFP_KERNEL);
+ if (!cpufreq_dev)
+ return ERR_PTR(-ENOMEM);
+
+ /*Verify that all the entries of freq_clip_table are present*/
+ for (i = 0; i < tab_size; i++) {
+ clip_tab = ((struct freq_clip_table *)&tab_ptr[i]);
+ if (!clip_tab->freq_clip_max || !clip_tab->mask_val
+ || !clip_tab->temp_level) {
+ kfree(cpufreq_dev);
+ return ERR_PTR(-EINVAL);
+ }
+ /*
+ *Consolidate all the cpumask for all the individual entries
+ *of the trip table. This is useful in resetting all the
+ *clipped frequencies to the normal level for each cpufreq
+ *cooling device.
+ */
+ cpumask_or(&cpufreq_dev->allowed_cpus,
+ &cpufreq_dev->allowed_cpus, clip_tab->mask_val);
+ }
+
+ cpufreq_dev->tab_ptr = tab_ptr;
+ cpufreq_dev->tab_size = tab_size;
+
+ ret = get_idr(&cpufreq_idr, &cpufreq_dev->id);
+ if (ret) {
+ kfree(cpufreq_dev);
+ return ERR_PTR(-EINVAL);
+ }
+
+ sprintf(dev_name, "thermal-cpufreq-%d", cpufreq_dev->id);
+
+ cool_dev = thermal_cooling_device_register(dev_name, cpufreq_dev,
+ &cpufreq_cooling_ops);
+ if (!cool_dev) {
+ release_idr(&cpufreq_idr, cpufreq_dev->id);
+ kfree(cpufreq_dev);
+ return ERR_PTR(-EINVAL);
+ }
+ cpufreq_dev->id = id;
+ cpufreq_dev->cool_dev = cool_dev;
+ 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);
+
+ mutex_unlock(&cooling_cpufreq_lock);
+ return cool_dev;
+}
+EXPORT_SYMBOL(cpufreq_cooling_register);
+
+/**
+ * cpufreq_cooling_unregister - function to remove cpufreq cooling device.
+ * @cdev: thermal cooling device pointer.
+ */
+void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev)
+{
+ struct cpufreq_cooling_device *cpufreq_dev = NULL;
+ unsigned int cpufreq_dev_count = 0;
+
+ 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);
+
+ /*Unregister the notifier for the last cpufreq cooling device*/
+ if (cpufreq_dev_count == 1) {
+ 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);
+ kfree(cpufreq_dev);
+}
+EXPORT_SYMBOL(cpufreq_cooling_unregister);
diff --git a/include/linux/cpu_cooling.h b/include/linux/cpu_cooling.h
new file mode 100644
index 0000000..ed6c096
--- /dev/null
+++ b/include/linux/cpu_cooling.h
@@ -0,0 +1,99 @@
+/*
+ * linux/include/linux/cpu_cooling.h
+ *
+ * Copyright (C) 2012 Samsung Electronics Co., Ltd(http://www.samsung.com)
+ * Copyright (C) 2012 Amit Daniel <amit.kachhap@linaro.org>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * 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 __CPU_COOLING_H__
+#define __CPU_COOLING_H__
+
+#include <linux/thermal.h>
+
+#define CPUFREQ_COOLING_START 0
+#define CPUFREQ_COOLING_STOP 1
+
+/**
+ * struct freq_clip_table
+ * @freq_clip_max: maximum frequency allowed for this cooling state.
+ * @temp_level: Temperature level at which the temperature clipping will
+ * happen.
+ * @mask_val: cpumask of the allowed cpu's where the clipping will take place.
+ *
+ * This structure is required to be filled and passed to the
+ * cpufreq_cooling_unregister function.
+ */
+struct freq_clip_table {
+ unsigned int freq_clip_max;
+ unsigned int temp_level;
+ const struct cpumask *mask_val;
+};
+
+/**
+ * cputherm_register_notifier - Register a notifier with cpu cooling interface.
+ * @nb: struct notifier_block * with callback info.
+ * @list: integer value for which notification is needed. possible values are
+ * CPUFREQ_COOLING_TYPE and CPUHOTPLUG_COOLING_TYPE.
+ *
+ * This exported function registers a driver with cpu cooling layer. The driver
+ * will be notified when any cpu cooling action is called.
+ */
+int cputherm_register_notifier(struct notifier_block *nb, unsigned int list);
+
+/**
+ * cputherm_unregister_notifier - Un-register a notifier.
+ * @nb: struct notifier_block * with callback info.
+ * @list: integer value for which notification is needed. values possible are
+ * CPUFREQ_COOLING_TYPE.
+ *
+ * This exported function un-registers a driver with cpu cooling layer.
+ */
+int cputherm_unregister_notifier(struct notifier_block *nb, unsigned int list);
+
+#ifdef CONFIG_CPU_FREQ
+/**
+ * cpufreq_cooling_register - function to create cpufreq cooling device.
+ * @tab_ptr: table ptr containing the maximum value of frequency to be clipped
+ * for each cooling state.
+ * @tab_size: count of entries in the above table.
+ * @mask_val: cpumask containing the allowed cpu's where frequency clipping can
+ * happen.
+ */
+struct thermal_cooling_device *cpufreq_cooling_register(
+ struct freq_clip_table *tab_ptr, unsigned int tab_size);
+
+/**
+ * cpufreq_cooling_unregister - function to remove cpufreq cooling device.
+ * @cdev: thermal cooling device pointer.
+ */
+void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev);
+#else /*!CONFIG_CPU_FREQ*/
+static inline struct thermal_cooling_device *cpufreq_cooling_register(
+ struct freq_clip_table *tab_ptr, unsigned int tab_size);
+{
+ return NULL;
+}
+static inline void cpufreq_cooling_unregister(
+ struct thermal_cooling_device *cdev)
+{
+ return;
+}
+#endif /*CONFIG_CPU_FREQ*/
+
+#endif /* __CPU_COOLING_H__ */
--
1.7.1
^ permalink raw reply related
* [PATCH v4 0/5] thermal: exynos: Add kernel thermal support for exynos platform
From: Amit Daniel Kachhap @ 2012-05-12 9:40 UTC (permalink / raw)
To: linux-pm, akpm
Cc: linux-samsung-soc, patches, linux-kernel, lm-sensors, linux-acpi,
khali, linaro-dev, guenter.roeck
Hi Andrew/Rui,
As discussed with Rui Zhang, I dropped the patch for new trip type
THERMAL_TRIP_STATE_INSTANCE and made the necessary state magnagement changes
in cpufreq cooling functions. Also I fixed all the review comments suggested
by Andrew. If any other changes please let me know.
This patchset introduces a new generic cooling device based on cpufreq that
can be used on non-ACPI platforms. As a proof of concept, we have drivers for
the following platforms using this mechanism now:
* Samsung Exynos (Exynos4 and Exynos5) in the current patchset.
* TI OMAP (git://git.linaro.org/people/amitdanielk/linux.git omap4460_thermal)
* Freescale i.MX (git://git.linaro.org/people/amitdanielk/linux.git imx6q_thermal)
The is a small change in cpufreq cooling registration APIs, so a minor change is
needed for OMAP and Freescale platforms.
Thanks,
Amit Daniel
Changes since V3:
* Dropped the concept of using new trip type THERMAL_TRIP_STATE_INSTANCE as
discussed with Rui Zhang. This requires adding some state management logic
in cpufreq cooling implementation.
* Many review comments suggested by Andrew Morton
* More documentation added in cpufreq cooling codes.
Changes since V2:
*Added Exynos5 TMU sensor support by enhancing the exynos4 tmu driver. Exynos5 TMU
driver was internally developed by SangWook Ju <sw.ju@samsung.com>.
*Removed cpuhotplug cooling code in this patchset.
*Rebased the patches against 3.4-rc6 kernel.
Changes since V1:
*Moved the sensor driver to driver/thermal folder from driver/hwmon folder
as suggested by Mark Brown and Guenter Roeck
*Added notifier support to notify the registered drivers of any cpu cooling
action. The driver can modify the default cooling behaviour(eg set different
max clip frequency).
*The percentage based frequency replaced with absolute clipped frequency.
*Some more conditional checks when setting max frequency.
*Renamed the new trip type THERMAL_TRIP_STATE_ACTIVE to
THERMAL_TRIP_STATE_INSTANCE
*Many review comments from R, Durgadoss <durgadoss.r@intel.com> and
eduardo.valentin@ti.com implemented.
*Removed cooling stats through debugfs patch
*The V1 based can be found here,
https://lkml.org/lkml/2012/2/22/123
http://lkml.org/lkml/2012/3/3/32
Changes since RFC:
*Changed the cpu cooling registration/unregistration API's to instance based
*Changed the STATE_ACTIVE trip type to pass correct instance id
*Adding support to restore back the policy->max_freq after doing frequency
clipping.
*Moved the trip cooling stats from sysfs node to debugfs node as suggested
by Greg KH greg@kroah.com
*Incorporated several review comments from eduardo.valentin@ti.com
*Moved the Temperature sensor driver from driver/hwmon/ to driver/mfd
as discussed with Guenter Roeck <guenter.roeck@ericsson.com> and
Donggeun Kim <dg77.kim@samsung.com> (https://lkml.org/lkml/2012/1/5/7)
*Some changes according to the changes in common cpu cooling APIs
*The RFC based patches can be found here,
https://lkml.org/lkml/2011/12/13/186
https://lkml.org/lkml/2011/12/21/169
Brief Description:
1) The generic cooling devices code is placed inside driver/thermal/* as
placing inside acpi folder will need un-necessary enabling of acpi code. This
codes is architecture independent.
2) This patchset adds generic cpu cooling low level implementation through
frequency clipping. In future, other cpu related cooling devices may be added
here. An ACPI version of this already exists (drivers/acpi/processor_thermal.c)
. But this will be useful for platforms like ARM using the generic
thermal interface along with the generic cpu cooling devices. The cooling
device registration API's return cooling device pointers which can be easily
binded with the thermal zone trip points. The important APIs exposed are,
a)struct thermal_cooling_device *cpufreq_cooling_register(
struct freq_clip_table *tab_ptr, unsigned int tab_size)
b)void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev)
3) Samsung exynos platform thermal implementation is done using the generic
cpu cooling APIs and the new trip type. The temperature sensor driver present
in the hwmon folder(registered as hwmon driver) is moved to thermal folder
and registered as a thermal driver.
All this patchset is based on Kernel version 3.4-rc6
A simple data/control flow diagrams is shown below,
Core Linux thermal <-----> Exynos thermal interface <----- Temperature Sensor
| |
\|/ |
Cpufreq cooling device <---------------
TODO:
*Will send the DT enablement patches later after the driver is merged.
Amit Daniel Kachhap (5):
thermal: Add generic cpufreq cooling implementation
hwmon: exynos4: Move thermal sensor driver to driver/thermal
directory
thermal: exynos5: Add exynos5 thermal sensor driver support
thermal: exynos: Register the tmu sensor with the kernel thermal
layer
ARM: exynos: Add thermal sensor driver platform data support
Documentation/hwmon/exynos4_tmu | 81 ---
Documentation/thermal/cpu-cooling-api.txt | 60 ++
Documentation/thermal/exynos_thermal | 52 ++
drivers/hwmon/Kconfig | 10 -
drivers/hwmon/Makefile | 1 -
drivers/hwmon/exynos4_tmu.c | 514 --------------
drivers/thermal/Kconfig | 20 +
drivers/thermal/Makefile | 4 +-
drivers/thermal/cpu_cooling.c | 483 +++++++++++++
drivers/thermal/exynos_thermal.c | 956 ++++++++++++++++++++++++++
include/linux/cpu_cooling.h | 99 +++
include/linux/platform_data/exynos4_tmu.h | 83 ---
include/linux/platform_data/exynos_thermal.h | 100 +++
13 files changed, 1773 insertions(+), 690 deletions(-)
delete mode 100644 Documentation/hwmon/exynos4_tmu
create mode 100644 Documentation/thermal/cpu-cooling-api.txt
create mode 100644 Documentation/thermal/exynos_thermal
delete mode 100644 drivers/hwmon/exynos4_tmu.c
create mode 100644 drivers/thermal/cpu_cooling.c
create mode 100644 drivers/thermal/exynos_thermal.c
create mode 100644 include/linux/cpu_cooling.h
delete mode 100644 include/linux/platform_data/exynos4_tmu.h
create mode 100644 include/linux/platform_data/exynos_thermal.h
^ permalink raw reply
* 3.3.5 regression: resume doesn't switch to X
From: Jiri Slaby @ 2012-05-12 7:17 UTC (permalink / raw)
To: stable; +Cc: linux-pm, Linux kernel mailing list, Jiri Slaby
Hi,
since update to 3.3.5, my X doesn't show up after resume from
hibernation anymore. The only thing I see is "resuming..." on the
console. I can switch to any tty and login in text mode, but cannot
switch to X despite it is running. I have to restart whole session to
have X again.
Now I'm back to 3.3.4 and everything is OK.
Using radeon driver on:
01:00.0 VGA compatible controller [0300]: Advanced Micro Devices [AMD]
nee ATI RV515 [Radeon Mobility X1450] [1002:7186]
regards,
--
js
suse labs
^ permalink raw reply
* Re: [PATCHv4 4/4] cpuidle: coupled: add parallel barrier function
From: Rafael J. Wysocki @ 2012-05-11 18:32 UTC (permalink / raw)
To: Colin Cross
Cc: Kevin Hilman, Len Brown, Russell King, Greg Kroah-Hartman,
Kay Sievers, linux-kernel, Amit Kucheria, linux-pm,
Arjan van de Ven, Arnd Bergmann, linux-arm-kernel
In-Reply-To: <CAMbhsRRzc9hPYLZvuwqsOP3RrF1dZVmzM_qfy_xHNL6mhtJzDA@mail.gmail.com>
On Friday, May 11, 2012, Colin Cross wrote:
> On Wed, May 9, 2012 at 2:31 PM, Rafael J. Wysocki <rjw@sisk.pl> wrote:
> > On Tuesday, May 08, 2012, Colin Cross wrote:
> >> Adds cpuidle_coupled_parallel_barrier, which can be used by coupled
> >> cpuidle state enter functions to handle resynchronization after
> >> determining if any cpu needs to abort. The normal use case will
> >> be:
> >>
> >> static bool abort_flag;
> >> static atomic_t abort_barrier;
> >>
> >> int arch_cpuidle_enter(struct cpuidle_device *dev, ...)
> >> {
> >> if (arch_turn_off_irq_controller()) {
> >> /* returns an error if an irq is pending and would be lost
> >> if idle continued and turned off power */
> >> abort_flag = true;
> >> }
> >>
> >> cpuidle_coupled_parallel_barrier(dev, &abort_barrier);
> >>
> >> if (abort_flag) {
> >> /* One of the cpus didn't turn off it's irq controller */
> >> arch_turn_on_irq_controller();
> >> return -EINTR;
> >> }
> >>
> >> /* continue with idle */
> >> ...
> >> }
> >>
> >> This will cause all cpus to abort idle together if one of them needs
> >> to abort.
> >>
> >> Reviewed-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
> >> Tested-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
> >> Reviewed-by: Kevin Hilman <khilman@ti.com>
> >> Tested-by: Kevin Hilman <khilman@ti.com>
> >> Signed-off-by: Colin Cross <ccross@android.com>
> >> ---
> >> drivers/cpuidle/coupled.c | 37 +++++++++++++++++++++++++++++++++++++
> >> include/linux/cpuidle.h | 4 ++++
> >> 2 files changed, 41 insertions(+), 0 deletions(-)
> >>
> >> diff --git a/drivers/cpuidle/coupled.c b/drivers/cpuidle/coupled.c
> >> index 93101fb..3e65de1 100644
> >> --- a/drivers/cpuidle/coupled.c
> >> +++ b/drivers/cpuidle/coupled.c
> >> @@ -130,6 +130,43 @@ struct cpuidle_coupled {
> >> static cpumask_t cpuidle_coupled_poked_mask;
> >>
> >> /**
> >> + * cpuidle_coupled_parallel_barrier - synchronize all online coupled cpus
> >> + * @dev: cpuidle_device of the calling cpu
> >> + * @a: atomic variable to hold the barrier
> >> + *
> >> + * No caller to this function will return from this function until all online
> >> + * cpus in the same coupled group have called this function. Once any caller
> >> + * has returned from this function, the barrier is immediately available for
> >> + * reuse.
> >> + *
> >> + * The atomic variable a must be initialized to 0 before any cpu calls
> >> + * this function, will be reset to 0 before any cpu returns from this function.
> >> + *
> >> + * Must only be called from within a coupled idle state handler
> >> + * (state.enter when state.flags has CPUIDLE_FLAG_COUPLED set).
> >> + *
> >> + * Provides full smp barrier semantics before and after calling.
> >> + */
> >> +void cpuidle_coupled_parallel_barrier(struct cpuidle_device *dev, atomic_t *a)
> >> +{
> >> + int n = dev->coupled->online_count;
> >> +
> >> + smp_mb__before_atomic_inc();
> >> + atomic_inc(a);
> >> +
> >> + while (atomic_read(a) < n)
> >> + cpu_relax();
> >> +
> >> + if (atomic_inc_return(a) == n * 2) {
> >> + atomic_set(a, 0);
> >> + return;
> >> + }
> >> +
> >> + while (atomic_read(a) > n)
> >> + cpu_relax();
> >> +}
> >
> > Well, this looks like "wait until all CPUs execute this code". Don't we have
> > anything like this already somewhere?
> >
> >> +
> >> +/**
> >> * cpuidle_state_is_coupled - check if a state is part of a coupled set
> >> * @dev: struct cpuidle_device for the current cpu
> >> * @drv: struct cpuidle_driver for the platform
> >> diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
> >> index 6038448..5ab7183 100644
> >> --- a/include/linux/cpuidle.h
> >> +++ b/include/linux/cpuidle.h
> >> @@ -183,6 +183,10 @@ static inline int cpuidle_wrap_enter(struct cpuidle_device *dev,
> >>
> >> #endif
> >>
> >> +#ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED
> >> +void cpuidle_coupled_parallel_barrier(struct cpuidle_device *dev, atomic_t *a);
> >> +#endif
> >
> > Why exactly is the extra Kconfig option necessary?
>
> It prevents compiling in coupled.o (2k text section) on the majority
> of kernels that will never use it.
OK, sorry, for some unknown reason it seemed to me that the option was added by
this patch.
Thanks,
Rafael
^ permalink raw reply
* [PATCH 3/3] x86,idle: Set residency to 0 if target Cstate not really enter
From: Youquan Song @ 2012-05-11 15:15 UTC (permalink / raw)
To: linux-acpi, linux-kernel, linux-pm, len.brown, akpm
Cc: arjan, len.brown, suresh.b.siddha, Youquan Song, Youquan Song
In-Reply-To: <1336749357-9133-3-git-send-email-youquan.song@intel.com>
When cpuidle governor choose a C-state to enter for idle CPU, but it notice that
there is tasks request to be executed. So the idle CPU will not really enter
the target C-state and go to run task.
In this situation, it will use the residency of previous really entered target
C-states. Obviously, it is not reasonable.
So, this patch fix it by set the target C-state residency to 0.
Signed-off-by: Youquan Song <youquan.song@intel.com>
---
drivers/cpuidle/cpuidle.c | 1 +
1 files changed, 1 insertions(+), 0 deletions(-)
diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
index 2f0083a..7992417 100644
--- a/drivers/cpuidle/cpuidle.c
+++ b/drivers/cpuidle/cpuidle.c
@@ -136,6 +136,10 @@ int cpuidle_idle_call(void)
/* ask the governor for the next state */
next_state = cpuidle_curr_governor->select(drv, dev);
if (need_resched()) {
+ dev->last_residency = 0;
+ /* give the governor an opportunity to reflect on the outcome */
+ if (cpuidle_curr_governor->reflect)
+ cpuidle_curr_governor->reflect(dev, next_state);
local_irq_enable();
return 0;
}
^ permalink raw reply related
* [PATCH 2/3] x86,idle: Quickly notice prediction failure in general case
From: Youquan Song @ 2012-05-11 15:15 UTC (permalink / raw)
To: linux-acpi, linux-kernel, linux-pm, len.brown, akpm
Cc: arjan, len.brown, suresh.b.siddha, Youquan Song, Youquan Song
In-Reply-To: <1336749357-9133-2-git-send-email-youquan.song@intel.com>
The patch extends the patch to enhance the prediction for repeat mode by add a
timer when menu governor choose a shallow C-state.
The timer is set to time out in 50 milli-seconds by default. It is special twist
that there are no power saving gains even sleep longer than it.
When C-state is waken up prior to the adding timer, the timer will be cancelled
initiatively. When the timer is triggered and menu governor will quickly notice
prediction failure and re-evaluates deeper C-states possibility.
Signed-off-by: Youquan Song <youquan.song@intel.com>
---
| 48 ++++++++++++++++++++++++++------------
1 files changed, 33 insertions(+), 15 deletions(-)
--git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
index 8c23fbd..9f92dd4 100644
--- a/drivers/cpuidle/governors/menu.c
+++ b/drivers/cpuidle/governors/menu.c
@@ -113,6 +113,13 @@ static DEFINE_PER_CPU(int, hrtimer_started);
* represented in the system load average.
*
*/
+
+/*
+ * Default set to 50 milliseconds based on special twist mentioned above that
+ * there are no power gains sleep longer than it.
+ */
+static unsigned int perfect_cstate_ms __read_mostly = 50;
+module_param(perfect_cstate_ms, uint, 0000);
struct menu_device {
int last_state_idx;
@@ -343,26 +350,37 @@ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
data->exit_us = s->exit_latency;
}
}
-
+
+ /* not deepest C-state chosen */
if (data->last_state_idx < drv->state_count - 1) {
+ unsigned int repeat_us = 0;
+ unsigned int perfect_us = 0;
+
+ /*
+ * Set enough timer to recognize the repeat mode broken.
+ * If the timer is time out, the repeat mode prediction
+ * fails,then re-evaluate deeper C-states possibility.
+ * If the timer is not triggered, the timer will be
+ * cancelled when CPU waken up.
+ */
+ repeat_us =
+ (repeat ? (2 * data->predicted_us + MAX_DEVIATION) : 0);
+ perfect_us = perfect_cstate_ms * 1000;
/* Repeat mode detected */
- if (repeat) {
- unsigned int repeat_us = 0;
- /*
- * Set enough timer to recognize the repeat mode broken.
- * If the timer is time out, the repeat mode prediction
- * fails,then re-evaluate deeper C-states possibility.
- * If the timer is not triggered, the timer will be
- * cancelled when CPU waken up.
- */
- repeat_us = 2 * data->predicted_us + MAX_DEVIATION;
- hrtimer_start(hrtmr, ns_to_ktime(1000 * repeat_us),
- HRTIMER_MODE_REL_PINNED);
+ if (repeat && (repeat_us < perfect_us)) {
+ hrtimer_start(hrtmr, ns_to_ktime(1000 * repeat_us),
+ HRTIMER_MODE_REL_PINNED);
+ /* menu hrtimer is started */
+ per_cpu(hrtimer_started, cpu) = 1;
+ } else if (perfect_us < data->expected_us) {
+ /* expected time is larger than adding timer time */
+ hrtimer_start(hrtmr, ns_to_ktime(1000 * perfect_us),
+ HRTIMER_MODE_REL_PINNED);
/* menu hrtimer is started */
per_cpu(hrtimer_started, cpu) = 1;
- }
- }
+ }
+ }
return data->last_state_idx;
}
--
1.6.4.2
^ permalink raw reply related
* [PATCH 1/3] x86,idle: Quickly notice prediction failure for repeat mode
From: Youquan Song @ 2012-05-11 15:15 UTC (permalink / raw)
To: linux-acpi, linux-kernel, linux-pm, len.brown, akpm
Cc: arjan, len.brown, suresh.b.siddha, Youquan Song, Youquan Song
In-Reply-To: <1336749357-9133-1-git-send-email-youquan.song@intel.com>
The prediction for future is difficult and when the cpuidle governor prediction
fails and govenor possibly choose the shallower C-state than it should. How to
quickly notice and find the failure becomes important for power saving.
cpuidle menu governor has a method to predict the repeat pattern if there are 8
C-states residency which are continuous and the same or very close, so it will
predict the next C-states residency will keep same residency time.
We encountered a real case that turbostat utility (tools/power/x86/turbostat)
at kernel 3.3 or early. turbostat utility will read 10 registers one by one at
Sandybridge, so it will generate 10 IPIs to wake up idle CPUs. So cpuidle menu
governor will predict it is repeat mode and there is another IPI wake up idle
CPU soon, so it keeps idle CPU stay at C1 state even though CPU is totally
idle. However, in the turbostat, following 10 registers reading is sleep 5
seconds by default, so the idle CPU will keep at C1 for a long time though it is
idle until break event occurs.
In the patch, a timer is added when menu governor detects a repeat mode and
choose a shallow C-state.The timer will be time out in (2 * predicted_time + 60)
micro-seconds. When repeat mode happens as expected, the timer is not triggered
and CPU waken up from C-states and it will cancel the timer initiatively.
When repeat mode does not happen, the timer will be time out and menu governor
will quickly in (2 * predicted_time + 60) us notice that the repeat mode
prediction fails and re-evaluates deeper C-states possibility.
Signed-off-by: Youquan Song <youquan.song@intel.com>
---
| 68 +++++++++++++++++++++++++++++++++++--
include/linux/tick.h | 6 +++
kernel/time/tick-sched.c | 2 +
3 files changed, 72 insertions(+), 4 deletions(-)
--git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
index 0633575..8c23fbd 100644
--- a/drivers/cpuidle/governors/menu.c
+++ b/drivers/cpuidle/governors/menu.c
@@ -28,6 +28,11 @@
#define MAX_INTERESTING 50000
#define STDDEV_THRESH 400
+/* 60 * 60 > STDDEV_THRESH * INTERVALS = 400 * 8 */
+#define MAX_DEVIATION 60
+
+static DEFINE_PER_CPU(struct hrtimer, menu_hrtimer);
+static DEFINE_PER_CPU(int, hrtimer_started);
/*
* Concepts and ideas behind the menu governor
@@ -191,17 +196,42 @@ static u64 div_round64(u64 dividend, u32 divisor)
return div_u64(dividend + (divisor / 2), divisor);
}
+/* Cancel the hrtimer if it is not triggered yet */
+void menu_hrtimer_cancel(void)
+{
+ int cpu = smp_processor_id();
+ struct hrtimer *hrtmr = &per_cpu(menu_hrtimer, cpu);
+
+ /* The timer is still not time out*/
+ if (per_cpu(hrtimer_started, cpu)) {
+ hrtimer_cancel(hrtmr);
+ per_cpu(hrtimer_started, cpu) = 0;
+ }
+}
+EXPORT_SYMBOL_GPL(menu_hrtimer_cancel);
+
+/* Call back for hrtimer is triggered */
+static enum hrtimer_restart menu_hrtimer_notify(struct hrtimer *hrtimer)
+{
+ int cpu = smp_processor_id();
+
+ per_cpu(hrtimer_started, cpu) = 0;
+
+ return HRTIMER_NORESTART;
+}
+
/*
* Try detecting repeating patterns by keeping track of the last 8
* intervals, and checking if the standard deviation of that set
* of points is below a threshold. If it is... then use the
* average of these 8 points as the estimated value.
*/
-static void detect_repeating_patterns(struct menu_device *data)
+static int detect_repeating_patterns(struct menu_device *data)
{
int i;
uint64_t avg = 0;
uint64_t stddev = 0; /* contains the square of the std deviation */
+ int ret = 0;
/* first calculate average and standard deviation of the past */
for (i = 0; i < INTERVALS; i++)
@@ -210,7 +240,7 @@ static void detect_repeating_patterns(struct menu_device *data)
/* if the avg is beyond the known next tick, it's worthless */
if (avg > data->expected_us)
- return;
+ return 0;
for (i = 0; i < INTERVALS; i++)
stddev += (data->intervals[i] - avg) *
@@ -223,8 +253,12 @@ static void detect_repeating_patterns(struct menu_device *data)
* repeating pattern and predict we keep doing this.
*/
- if (avg && stddev < STDDEV_THRESH)
+ if (avg && stddev < STDDEV_THRESH) {
data->predicted_us = avg;
+ ret = 1;
+ }
+
+ return ret;
}
/**
@@ -240,6 +274,9 @@ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
int i;
int multiplier;
struct timespec t;
+ int repeat = 0;
+ int cpu = smp_processor_id();
+ struct hrtimer *hrtmr = &per_cpu(menu_hrtimer, cpu);
if (data->needs_update) {
menu_update(drv, dev);
@@ -274,7 +311,7 @@ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
data->predicted_us = div_round64(data->expected_us * data->correction_factor[data->bucket],
RESOLUTION * DECAY);
- detect_repeating_patterns(data);
+ repeat = detect_repeating_patterns(data);
/*
* We want to default to C1 (hlt), not to busy polling
@@ -307,6 +344,26 @@ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
}
}
+ if (data->last_state_idx < drv->state_count - 1) {
+
+ /* Repeat mode detected */
+ if (repeat) {
+ unsigned int repeat_us = 0;
+ /*
+ * Set enough timer to recognize the repeat mode broken.
+ * If the timer is time out, the repeat mode prediction
+ * fails,then re-evaluate deeper C-states possibility.
+ * If the timer is not triggered, the timer will be
+ * cancelled when CPU waken up.
+ */
+ repeat_us = 2 * data->predicted_us + MAX_DEVIATION;
+ hrtimer_start(hrtmr, ns_to_ktime(1000 * repeat_us),
+ HRTIMER_MODE_REL_PINNED);
+ /* menu hrtimer is started */
+ per_cpu(hrtimer_started, cpu) = 1;
+ }
+ }
+
return data->last_state_idx;
}
@@ -397,6 +454,9 @@ static int menu_enable_device(struct cpuidle_driver *drv,
struct cpuidle_device *dev)
{
struct menu_device *data = &per_cpu(menu_devices, dev->cpu);
+ struct hrtimer *t = &per_cpu(menu_hrtimer, dev->cpu);
+ hrtimer_init(t, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+ t->function = menu_hrtimer_notify;
memset(data, 0, sizeof(struct menu_device));
diff --git a/include/linux/tick.h b/include/linux/tick.h
index ab8be90..4cea029 100644
--- a/include/linux/tick.h
+++ b/include/linux/tick.h
@@ -142,4 +142,10 @@ static inline u64 get_cpu_idle_time_us(int cpu, u64 *unused) { return -1; }
static inline u64 get_cpu_iowait_time_us(int cpu, u64 *unused) { return -1; }
# endif /* !NO_HZ */
+# ifdef CONFIG_CPU_IDLE_GOV_MENU
+extern void menu_hrtimer_cancel(void);
+# else
+static inline void menu_hrtimer_cancel(void) { return -1; }
+# endif /* CONFIG_CPU_IDLE_GOV_MENU */
+
#endif
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 6a3a5b9..812c1d6 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -499,6 +499,8 @@ void tick_nohz_irq_exit(void)
if (!ts->inidle)
return;
+ /* Cancel the timer because CPU already waken up from the C-states*/
+ menu_hrtimer_cancel();
tick_nohz_stop_sched_tick(ts);
}
@@ -562,6 +564,8 @@ void tick_nohz_idle_exit(void)
ts->inidle = 0;
+ /* Cancel the timer because CPU already waken up from the C-states*/
+ menu_hrtimer_cancel();
if (ts->idle_active || ts->tick_stopped)
now = ktime_get();
^ permalink raw reply related
* [PATCH 0/3] x86,idle: Enhance cpuidle prediction to handle its failure
From: Youquan Song @ 2012-05-11 15:15 UTC (permalink / raw)
To: linux-acpi, linux-kernel, linux-pm, len.brown, akpm
Cc: arjan, len.brown, suresh.b.siddha, Youquan Song, Youquan Song
The prediction for future is difficult and when the cpuidle governor prediction
fails and govenor possibly choose the shallower C-state than it should. How to
quickly notice and find the failure becomes important for power saving.
cpuidle menu governor has a method to predict the repeat pattern if there are 8
C-states residency which are continuous and the same or very close, so it will
predict the next C-states residency will keep same residency time.
We encountered a real case that turbostat utility (tools/power/x86/turbostat)
at kernel 3.3 or early. turbostat utility will read 10 registers one by one at
Sandybridge, so it will generate 10 IPIs to wake up idle CPUs. So cpuidle menu
governor will predict it is repeat mode and there is another IPI wake up idle
CPU soon, so it keeps idle CPU stay at C1 state even though CPU is totally
idle. However, in the turbostat, following 10 registers reading is sleep 5
seconds by default, so the idle CPU will keep at C1 for a long time though it is
idle until break event occurs.
The "old turbostat" is specific case and it is already fix by skip to read CPU
MSRs. But we do not guarantee that other application will not do it like this.
So the proper ways is to enhance the logic of the men governor prediction for
next C-states.
This patchset adds a timer when menu governor choose a non-deepest C-state in
order to wake up quickly from shallow C-state to avoid staying too long at
shallow C-state for prediction failure. If the timer is not triggered and CPU
is waken up from C-state, the timer will be cancelled initiatively to avoid the
adding timer bring affect to system. If the timer is time out, CPU will quickly
be waken up from shallow C-state and re-evaluates deeper C-states possibility.
After plenty of testing and tuning, the patchset get about 1% power efficiency
ehancement in SpecPower2008 on Romley-EP. Especailly, when workload is not so
high < 70%, it can notice 1~3 watts power saving; while workload is high > 80%,
It will cost more power consumption. Another benchmarks non-CPU intensive, like
fio, apache and aio-stress will also get power saving while the performance does
not drop.
While I try to fix the issue, I got a lot of help and suggestion from Arjan,
Thanks a lot Arjan!
Thanks
-Youquan
^ permalink raw reply
* Re: Plumbers: PM constraints micro-conf RFP
From: mark gross @ 2012-05-11 14:14 UTC (permalink / raw)
To: Valentin, Eduardo
Cc: Kevin Hilman, Agarwal, Ramesh, markgross, paulmck,
Praveen Chidambaram, Amit Kucheria, Antti P Miettinen,
John Stultz, linux-pm, Jean Pihet
In-Reply-To: <CAGF5oy8E26sYHi13ayrrOY5qbXepz1U8ErEfF-Ata9k6Zyzz+Q@mail.gmail.com>
On Fri, May 11, 2012 at 10:17:19AM +0300, Valentin, Eduardo wrote:
> Hello Mark,
>
> On Wed, May 2, 2012 at 5:36 PM, mark gross <markgross@thegnar.org> wrote:
> > This is a Request For Participation in a micro-conference at this years
> > Linux plumbers event. For this micro conference to happen we need to
> > reach a certain critical mass WRT participants as measured by submitted
> > talks associated to Power Management Constraints.
>
> Nice! Thanks for proposing this.
>
> >
> > The To: list is populated with folks that I've had interactions with
> > over extending pm-qos or constraint based PM over the past year.
> >
> > If you are working on problems related to constraining the power /
> > performance of devices I am inviting your participation and request you
> > submit a proposal for presenting your problem space (preferred) and or
> > solution to a group of developers looking for a good solution to push
> > upstream. The talks will be about 20 min long as I want to get into
> > some design and implementation discussions after the requirements
> > definition is mostly finished.
> >
> > I am interested in gathering user mode interface needs as well as kernel
> > mode.
> >
> > From a high level pm-constraints is a generalization of pm-qos to include
> > limiting performance as well as its current limiting of device
> > throttling.
> >
> > As performance limiting is typically used for any of the following:
> > 1) staying within thermal operational envelopes
> > 2) avoiding peak current
> > 3) extending battery life in active use cases
> >
> > I invite anyone working in any of these areas or pm-qos applications to
> > participate in this micro-conference.
> >
> > I will organize the micro-conference into 2 parts:
> > 1) problem statements with specific participant examples where
> > constraining the performance or throttling is needed.
>
>
> I could bring something on the use cases where this type of
> constraining could be used. Essentially major focus gets partitioned
> in two areas: For device skin/case temperature management, and IC's
> junction temperature management.
>
This will be great! Getting the common / typical use cases well
represented is the highest priority of the session IMO.
Having a solid understanding of them will drive the requirements and
hopefully make defining the architecture quick, easy and without a lot of
conflicting points of view.
--mark
^ permalink raw reply
* Re: Plumbers: PM constraints micro-conf RFP
From: mark gross @ 2012-05-11 14:10 UTC (permalink / raw)
To: Jean Pihet
Cc: Kevin Hilman, Agarwal, Ramesh, markgross, paulmck,
Praveen Chidambaram, Amit Kucheria, John Stultz, linux-pm,
Antti P Miettinen, jeen.pihet
In-Reply-To: <CAORVsuUna_6oUYRf4_wfWcyR-n8CBMNWsdz5MaECLEdKFYs9SA@mail.gmail.com>
On Fri, May 11, 2012 at 09:02:02AM +0200, Jean Pihet wrote:
> Hi Mark,
>
> On Wed, May 2, 2012 at 4:36 PM, mark gross <markgross@thegnar.org> wrote:
> > This is a Request For Participation in a micro-conference at this years
> > Linux plumbers event. For this micro conference to happen we need to
> > reach a certain critical mass WRT participants as measured by submitted
> > talks associated to Power Management Constraints.
> That looks great! I hope some progress can be made in the area of the
> constraints frameworks design.
>
> > The To: list is populated with folks that I've had interactions with
> > over extending pm-qos or constraint based PM over the past year.
> >
> > If you are working on problems related to constraining the power /
> > performance of devices I am inviting your participation and request you
> > submit a proposal for presenting your problem space (preferred) and or
> > solution to a group of developers looking for a good solution to push
> > upstream. The talks will be about 20 min long as I want to get into
> > some design and implementation discussions after the requirements
> > definition is mostly finished.
> I can have something about the per-device PM QoS, starting from the
> ELC presentation [1], the current status and the next steps.
>
> [1] https://events.linuxfoundation.org/events/embedded-linux-conference/pihet
> The slides can be found at
> https://events.linuxfoundation.org/images/stories/pdf/lf_elc12_pihet.pdf.
>
> I am looking at the travel arrangements and will confirm asap.
>
> > I am interested in gathering user mode interface needs as well as kernel
> > mode.
> An agreement is needed on the APIs, especially for the user space.
>
> >
> > From a high level pm-constraints is a generalization of pm-qos to include
> > limiting performance as well as its current limiting of device
> > throttling.
> >
> > As performance limiting is typically used for any of the following:
> > 1) staying within thermal operational envelopes
> > 2) avoiding peak current
> > 3) extending battery life in active use cases
> >
> > I invite anyone working in any of these areas or pm-qos applications to
> > participate in this micro-conference.
> >
> > I will organize the micro-conference into 2 parts:
> > 1) problem statements with specific participant examples where
> > constraining the performance or throttling is needed.
> >
> > 2) high level design brain storming.
> >
> > If the micro-conference happens (i.e. critical mass is reached) any
> > interested linux-plumbers attendees is very welcome to participate.
> >
> > Please send me an off list email if you want me to add you to my mutt
> > alias of interested parties I'll use to cc people on emails. Note: must
> > of the correspondence will cc linux-pm too.
> >
> > Please submit a proposal if you are interested in participating in this
> > with me. I know a number of people are working in this space for the
> > past few years now. I think its a good time to compare notes and at
> > least consolidate requirements and use cases. Perhaps we'll even come up
> > with a good design to implement in the process.
> >
> > thanks,
> > --mark
>
> Thanks for organizing!
>
I think it will be a good discussion and hopefully we'll make progress
all around on this topic.
BTW I'm sorry for mutilating your name and email in my original
posting.
--mark
^ permalink raw reply
* Re: Plumbers: PM constraints micro-conf RFP
From: Valentin, Eduardo @ 2012-05-11 7:17 UTC (permalink / raw)
To: markgross
Cc: Kevin Hilman, Agarwal, Ramesh, paulmck, Praveen Chidambaram,
Amit Kucheria, Jean Pihet, John Stultz, linux-pm,
Antti P Miettinen
In-Reply-To: <20120502143607.GA21640@G62>
Hello Mark,
On Wed, May 2, 2012 at 5:36 PM, mark gross <markgross@thegnar.org> wrote:
> This is a Request For Participation in a micro-conference at this years
> Linux plumbers event. For this micro conference to happen we need to
> reach a certain critical mass WRT participants as measured by submitted
> talks associated to Power Management Constraints.
Nice! Thanks for proposing this.
>
> The To: list is populated with folks that I've had interactions with
> over extending pm-qos or constraint based PM over the past year.
>
> If you are working on problems related to constraining the power /
> performance of devices I am inviting your participation and request you
> submit a proposal for presenting your problem space (preferred) and or
> solution to a group of developers looking for a good solution to push
> upstream. The talks will be about 20 min long as I want to get into
> some design and implementation discussions after the requirements
> definition is mostly finished.
>
> I am interested in gathering user mode interface needs as well as kernel
> mode.
>
> From a high level pm-constraints is a generalization of pm-qos to include
> limiting performance as well as its current limiting of device
> throttling.
>
> As performance limiting is typically used for any of the following:
> 1) staying within thermal operational envelopes
> 2) avoiding peak current
> 3) extending battery life in active use cases
>
> I invite anyone working in any of these areas or pm-qos applications to
> participate in this micro-conference.
>
> I will organize the micro-conference into 2 parts:
> 1) problem statements with specific participant examples where
> constraining the performance or throttling is needed.
I could bring something on the use cases where this type of
constraining could be used. Essentially major focus gets partitioned
in two areas: For device skin/case temperature management, and IC's
junction temperature management.
I am currently checking the traveling arrangements as well. And
confirming soon.
>
> 2) high level design brain storming.
>
> If the micro-conference happens (i.e. critical mass is reached) any
> interested linux-plumbers attendees is very welcome to participate.
>
> Please send me an off list email if you want me to add you to my mutt
> alias of interested parties I'll use to cc people on emails. Note: must
> of the correspondence will cc linux-pm too.
>
> Please submit a proposal if you are interested in participating in this
> with me. I know a number of people are working in this space for the
> past few years now. I think its a good time to compare notes and at
> least consolidate requirements and use cases. Perhaps we'll even come up
> with a good design to implement in the process.
>
> thanks,
> --mark
>
All best,
--
Eduardo Valentin
^ permalink raw reply
* Re: Plumbers: PM constraints micro-conf RFP
From: Jean Pihet @ 2012-05-11 7:02 UTC (permalink / raw)
To: markgross
Cc: Kevin Hilman, Agarwal, Ramesh, paulmck, Praveen Chidambaram,
Amit Kucheria, John Stultz, linux-pm, Antti P Miettinen,
jeen.pihet
In-Reply-To: <20120502143607.GA21640@G62>
Hi Mark,
On Wed, May 2, 2012 at 4:36 PM, mark gross <markgross@thegnar.org> wrote:
> This is a Request For Participation in a micro-conference at this years
> Linux plumbers event. For this micro conference to happen we need to
> reach a certain critical mass WRT participants as measured by submitted
> talks associated to Power Management Constraints.
That looks great! I hope some progress can be made in the area of the
constraints frameworks design.
> The To: list is populated with folks that I've had interactions with
> over extending pm-qos or constraint based PM over the past year.
>
> If you are working on problems related to constraining the power /
> performance of devices I am inviting your participation and request you
> submit a proposal for presenting your problem space (preferred) and or
> solution to a group of developers looking for a good solution to push
> upstream. The talks will be about 20 min long as I want to get into
> some design and implementation discussions after the requirements
> definition is mostly finished.
I can have something about the per-device PM QoS, starting from the
ELC presentation [1], the current status and the next steps.
[1] https://events.linuxfoundation.org/events/embedded-linux-conference/pihet
The slides can be found at
https://events.linuxfoundation.org/images/stories/pdf/lf_elc12_pihet.pdf.
I am looking at the travel arrangements and will confirm asap.
> I am interested in gathering user mode interface needs as well as kernel
> mode.
An agreement is needed on the APIs, especially for the user space.
>
> From a high level pm-constraints is a generalization of pm-qos to include
> limiting performance as well as its current limiting of device
> throttling.
>
> As performance limiting is typically used for any of the following:
> 1) staying within thermal operational envelopes
> 2) avoiding peak current
> 3) extending battery life in active use cases
>
> I invite anyone working in any of these areas or pm-qos applications to
> participate in this micro-conference.
>
> I will organize the micro-conference into 2 parts:
> 1) problem statements with specific participant examples where
> constraining the performance or throttling is needed.
>
> 2) high level design brain storming.
>
> If the micro-conference happens (i.e. critical mass is reached) any
> interested linux-plumbers attendees is very welcome to participate.
>
> Please send me an off list email if you want me to add you to my mutt
> alias of interested parties I'll use to cc people on emails. Note: must
> of the correspondence will cc linux-pm too.
>
> Please submit a proposal if you are interested in participating in this
> with me. I know a number of people are working in this space for the
> past few years now. I think its a good time to compare notes and at
> least consolidate requirements and use cases. Perhaps we'll even come up
> with a good design to implement in the process.
>
> thanks,
> --mark
Thanks for organizing!
Regards,
Jean
>
> _______________________________________________
> linux-pm mailing list
> linux-pm@lists.linux-foundation.org
> https://lists.linuxfoundation.org/mailman/listinfo/linux-pm
^ permalink raw reply
* Re: [PATCH V3 07/10] ARM: OMAP2+: SmartReflex: Use per-OPP data structure
From: J, KEERTHY @ 2012-05-11 3:51 UTC (permalink / raw)
To: Guyotte, Greg
Cc: Hilman, Kevin, Menon, Nishanth, Paul Walmsley,
linux-kernel@vger.kernel.org, rjw@sisk.pl, Gopinath, Thara,
linux-pm@lists.linux-foundation.org, linux-omap@vger.kernel.org,
Pihet-XID, Jean, linux-arm-kernel@lists.infradead.org
In-Reply-To: <44C9A5C2B412554B8C50A260EB4EF32703971E34@DFLE32.ent.ti.com>
Hi Greg,
Thanks for reviewing.
On Fri, May 11, 2012 at 12:41 AM, Guyotte, Greg <gguyotte@ti.com> wrote:
> Hi Jean,
>
>> -----Original Message-----
>> From: linux-omap-owner@vger.kernel.org [mailto:linux-omap-
>> owner@vger.kernel.org] On Behalf Of J, KEERTHY
>> Sent: Thursday, April 26, 2012 12:41 PM
>> To: linux-omap@vger.kernel.org; linux-arm-kernel@lists.infradead.org;
>> Hilman, Kevin; rjw@sisk.pl; linux-kernel@vger.kernel.org; linux-
>> pm@lists.linux-foundation.org
>> Cc: Pihet-XID, Jean; J, KEERTHY; Paul Walmsley; Gopinath, Thara; Menon,
>> Nishanth
>> Subject: [PATCH V3 07/10] ARM: OMAP2+: SmartReflex: Use per-OPP data
>> structure
>>
>> From: Jean Pihet <j-pihet@ti.com>
>>
>> The SmartReflex driver incorrectly treats some per-OPP data as data
>> common to all OPPs (e.g., ERRMINLIMIT). Move this data into a per-OPP
>> data structure.
>>
>> Furthermore, in order to make the SmartReflex implementation ready for
>> the move to drivers/, remove the dependency from the SR driver code
>> to the voltage layer by querying the data tables only from the SR device
>> init code.
>>
>> Based on Paul's original code for the SmartReflex driver conversion.
>>
>> Signed-off-by: Jean Pihet <j-pihet@ti.com>
>> Signed-off-by: J Keerthy <j-keerthy@ti.com>
>> Cc: Paul Walmsley <paul@pwsan.com>
>> Cc: Thara Gopinath <thara@ti.com>
>> Cc: Nishanth Menon <nm@ti.com>
>> Cc: Kevin Hilman <khilman@ti.com>
>> ---
>> arch/arm/mach-omap2/smartreflex.c | 38 +++++++++++++++++---------------
>> ----
>> arch/arm/mach-omap2/sr_device.c | 36 +++++++++++++++++++++++++++++---
>> --
>> include/linux/power/smartreflex.h | 8 +++++-
>> 3 files changed, 54 insertions(+), 28 deletions(-)
>>
>> diff --git a/arch/arm/mach-omap2/smartreflex.c b/arch/arm/mach-
>> omap2/smartreflex.c
>> index acef08d..20075de 100644
>> --- a/arch/arm/mach-omap2/smartreflex.c
>> +++ b/arch/arm/mach-omap2/smartreflex.c
>> @@ -347,22 +347,23 @@ static void sr_v2_disable(struct omap_sr *sr)
>> sr_write_reg(sr, IRQSTATUS, IRQSTATUS_MCUDISABLEACKINT);
>> }
>>
>> -static u32 sr_retrieve_nvalue(struct omap_sr *sr, u32 efuse_offs)
>> +static struct omap_sr_nvalue_table *sr_retrieve_nvalue_row(
>> + struct omap_sr *sr, u32 efuse_offs)
>> {
>> int i;
>>
>> if (!sr->nvalue_table) {
>> dev_warn(&sr->pdev->dev, "%s: Missing ntarget value table\n",
>> __func__);
>> - return 0;
>> + return NULL;
>> }
>>
>> for (i = 0; i < sr->nvalue_count; i++) {
>> if (sr->nvalue_table[i].efuse_offs == efuse_offs)
>> - return sr->nvalue_table[i].nvalue;
>> + return &sr->nvalue_table[i];
>> }
>>
>> - return 0;
>> + return NULL;
>> }
>>
>> /* Public Functions */
>> @@ -586,7 +587,7 @@ int sr_enable(struct voltagedomain *voltdm, unsigned
>> long volt)
>> {
>> struct omap_volt_data *volt_data;
>> struct omap_sr *sr = _sr_lookup(voltdm);
>> - u32 nvalue_reciprocal;
>> + struct omap_sr_nvalue_table *nvalue_row;
>> int ret;
>>
>> if (IS_ERR(sr)) {
>> @@ -602,16 +603,16 @@ int sr_enable(struct voltagedomain *voltdm, unsigned
>> long volt)
>> return PTR_ERR(volt_data);
>> }
>>
>> - nvalue_reciprocal = sr_retrieve_nvalue(sr, volt_data-
>> >sr_efuse_offs);
>> + nvalue_row = sr_retrieve_nvalue_row(sr, volt_data->sr_efuse_offs);
>>
>> - if (!nvalue_reciprocal) {
>> - dev_warn(&sr->pdev->dev, "%s: NVALUE = 0 at voltage %ld\n",
>> - __func__, volt);
>> + if (!nvalue_row) {
>> + dev_warn(&sr->pdev->dev, "%s: failure getting SR data for this
>> voltage %ld\n",
>> + __func__, volt);
>> return -ENODATA;
>> }
>>
>> /* errminlimit is opp dependent and hence linked to voltage */
>> - sr->err_minlimit = volt_data->sr_errminlimit;
>> + sr->err_minlimit = nvalue_row->errminlimit;
>>
>> pm_runtime_get_sync(&sr->pdev->dev);
>>
>> @@ -624,7 +625,7 @@ int sr_enable(struct voltagedomain *voltdm, unsigned
>> long volt)
>> if (ret)
>> return ret;
>>
>> - sr_write_reg(sr, NVALUERECIPROCAL, nvalue_reciprocal);
>> + sr_write_reg(sr, NVALUERECIPROCAL, nvalue_row->nvalue);
>>
>> /* SRCONFIG - enable SR */
>> sr_modify_reg(sr, SRCONFIG, SRCONFIG_SRENABLE, SRCONFIG_SRENABLE);
>> @@ -872,7 +873,6 @@ static int __init omap_sr_probe(struct platform_device
>> *pdev)
>> struct omap_sr_data *pdata = pdev->dev.platform_data;
>> struct resource *mem, *irq;
>> struct dentry *nvalue_dir;
>> - struct omap_volt_data *volt_data;
>> int i, ret = 0;
>>
>> sr_info = kzalloc(sizeof(struct omap_sr), GFP_KERNEL);
>> @@ -990,12 +990,10 @@ static int __init omap_sr_probe(struct
>> platform_device *pdev)
>> goto err_debugfs;
>> }
>>
>> - omap_voltage_get_volttable(sr_info->voltdm, &volt_data);
>> - if (!volt_data) {
>> - dev_warn(&pdev->dev, "%s: %s: No Voltage table for the"
>> - " corresponding vdd. Cannot create debugfs"
>> - "entries for n-values\n",
>> - __func__, sr_info->name);
>> + if (sr_info->nvalue_count == 0 || !sr_info->nvalue_table) {
>> + dev_warn(&pdev->dev, "%s: %s: No Voltage table for the
>> corresponding vdd. Cannot create debugfs entries for n-values\n",
>> + __func__, sr_info->name);
>> +
>> ret = -ENODATA;
>> goto err_debugfs;
>> }
>> @@ -1003,8 +1001,8 @@ static int __init omap_sr_probe(struct
>> platform_device *pdev)
>> for (i = 0; i < sr_info->nvalue_count; i++) {
>> char name[NVALUE_NAME_LEN + 1];
>>
>> - snprintf(name, sizeof(name), "volt_%d",
>> - volt_data[i].volt_nominal);
>> + snprintf(name, sizeof(name), "volt_%lu",
>> + sr_info->nvalue_table[i].volt_nominal);
>> (void) debugfs_create_x32(name, S_IRUGO | S_IWUSR, nvalue_dir,
>> &(sr_info->nvalue_table[i].nvalue));
>> }
>> diff --git a/arch/arm/mach-omap2/sr_device.c b/arch/arm/mach-
>> omap2/sr_device.c
>> index e081174..e107e39 100644
>> --- a/arch/arm/mach-omap2/sr_device.c
>> +++ b/arch/arm/mach-omap2/sr_device.c
>> @@ -36,7 +36,10 @@ static void __init sr_set_nvalues(struct omap_volt_data
>> *volt_data,
>> struct omap_sr_data *sr_data)
>> {
>> struct omap_sr_nvalue_table *nvalue_table;
>> - int i, count = 0;
>> + int i, j, count = 0;
>> +
>> + sr_data->nvalue_count = 0;
>> + sr_data->nvalue_table = NULL;
>>
>> while (volt_data[count].volt_nominal)
>> count++;
>> @@ -44,8 +47,14 @@ static void __init sr_set_nvalues(struct omap_volt_data
>> *volt_data,
>> nvalue_table = kzalloc(sizeof(struct omap_sr_nvalue_table)*count,
>> GFP_KERNEL);
>>
>> - for (i = 0; i < count; i++) {
>> + if (!nvalue_table) {
>> + pr_err("OMAP: SmartReflex: cannot allocate memory for n-value
>> table\n");
>> + return;
>> + }
>> +
>> + for (i = 0, j = 0; i < count; i++) {
>> u32 v;
>> +
>> /*
>> * In OMAP4 the efuse registers are 24 bit aligned.
>> * A __raw_readl will fail for non-32 bit aligned address
>> @@ -58,15 +67,30 @@ static void __init sr_set_nvalues(struct
>> omap_volt_data *volt_data,
>> omap_ctrl_readb(offset + 1) << 8 |
>> omap_ctrl_readb(offset + 2) << 16;
>> } else {
>> - v = omap_ctrl_readl(volt_data[i].sr_efuse_offs);
>> + v = omap_ctrl_readl(volt_data[i].sr_efuse_offs);
>> }
>>
>> - nvalue_table[i].efuse_offs = volt_data[i].sr_efuse_offs;
>> - nvalue_table[i].nvalue = v;
>> + /*
>> + * Many OMAP SoCs don't have the eFuse values set.
>> + * For example, pretty much all OMAP3xxx before
>> + * ES3.something.
>> + *
>> + * XXX There needs to be some way for board files or
>> + * userspace to add these in.
>> + */
>> + if (v == 0)
>> + continue;
>> +
>> + nvalue_table[j].nvalue = v;
>> + nvalue_table[j].efuse_offs = volt_data[i].sr_efuse_offs;
>> + nvalue_table[j].errminlimit = volt_data[i].sr_errminlimit;
>> + nvalue_table[j].volt_nominal = volt_data[i].volt_nominal;
>> +
>> + j++;
>> }
>>
>> sr_data->nvalue_table = nvalue_table;
>> - sr_data->nvalue_count = count;
>> + sr_data->nvalue_count = j;
>> }
>>
>> static int __init sr_dev_init(struct omap_hwmod *oh, void *user)
>> diff --git a/include/linux/power/smartreflex.h
>> b/include/linux/power/smartreflex.h
>> index 78b795e..222f901 100644
>> --- a/include/linux/power/smartreflex.h
>> +++ b/include/linux/power/smartreflex.h
>> @@ -243,12 +243,16 @@ struct omap_sr_class_data {
>> /**
>> * struct omap_sr_nvalue_table - Smartreflex n-target value info
>> *
>> - * @efuse_offs: The offset of the efuse where n-target values are stored.
>> - * @nvalue: The n-target value.
>> + * @efuse_offs: The offset of the efuse where n-target values are
>> stored.
>> + * @nvalue: The n-target value.
>> + * @errminlimit: The value of the ERRMINLIMIT bitfield for this n-target
>> + * @volt_nominal: microvolts DC that the VDD is initially programmed to
>> */
>> struct omap_sr_nvalue_table {
>> u32 efuse_offs;
>> u32 nvalue;
>> + u32 errminlimit;
>> + unsigned long volt_nominal;
>
> [GG] I would suggest that we also need to add errmaxlimit and errweight fields to this structure. These are very much possible to change per OPP, though it hasn't been common in implementations up to now.
Ok. Since this patch set is focussed on minimal clean up and moving the code
from mach-omap to drivers this is not addressed. I will sure take this up once
this is moved.
>
>> };
>>
>> /**
>> --
>> 1.7.5.4
>>
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-omap" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at http://vger.kernel.org/majordomo-info.html
--
Regards and Thanks,
Keerthy
^ permalink raw reply
* Re: [PATCHv4 4/4] cpuidle: coupled: add parallel barrier function
From: Colin Cross @ 2012-05-10 22:47 UTC (permalink / raw)
To: Rafael J. Wysocki
Cc: Kevin Hilman, Len Brown, Russell King, Greg Kroah-Hartman,
Kay Sievers, linux-kernel, Amit Kucheria, linux-pm,
Arjan van de Ven, Arnd Bergmann, linux-arm-kernel
In-Reply-To: <201205092331.24487.rjw@sisk.pl>
On Wed, May 9, 2012 at 2:31 PM, Rafael J. Wysocki <rjw@sisk.pl> wrote:
> On Tuesday, May 08, 2012, Colin Cross wrote:
>> Adds cpuidle_coupled_parallel_barrier, which can be used by coupled
>> cpuidle state enter functions to handle resynchronization after
>> determining if any cpu needs to abort. The normal use case will
>> be:
>>
>> static bool abort_flag;
>> static atomic_t abort_barrier;
>>
>> int arch_cpuidle_enter(struct cpuidle_device *dev, ...)
>> {
>> if (arch_turn_off_irq_controller()) {
>> /* returns an error if an irq is pending and would be lost
>> if idle continued and turned off power */
>> abort_flag = true;
>> }
>>
>> cpuidle_coupled_parallel_barrier(dev, &abort_barrier);
>>
>> if (abort_flag) {
>> /* One of the cpus didn't turn off it's irq controller */
>> arch_turn_on_irq_controller();
>> return -EINTR;
>> }
>>
>> /* continue with idle */
>> ...
>> }
>>
>> This will cause all cpus to abort idle together if one of them needs
>> to abort.
>>
>> Reviewed-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
>> Tested-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
>> Reviewed-by: Kevin Hilman <khilman@ti.com>
>> Tested-by: Kevin Hilman <khilman@ti.com>
>> Signed-off-by: Colin Cross <ccross@android.com>
>> ---
>> drivers/cpuidle/coupled.c | 37 +++++++++++++++++++++++++++++++++++++
>> include/linux/cpuidle.h | 4 ++++
>> 2 files changed, 41 insertions(+), 0 deletions(-)
>>
>> diff --git a/drivers/cpuidle/coupled.c b/drivers/cpuidle/coupled.c
>> index 93101fb..3e65de1 100644
>> --- a/drivers/cpuidle/coupled.c
>> +++ b/drivers/cpuidle/coupled.c
>> @@ -130,6 +130,43 @@ struct cpuidle_coupled {
>> static cpumask_t cpuidle_coupled_poked_mask;
>>
>> /**
>> + * cpuidle_coupled_parallel_barrier - synchronize all online coupled cpus
>> + * @dev: cpuidle_device of the calling cpu
>> + * @a: atomic variable to hold the barrier
>> + *
>> + * No caller to this function will return from this function until all online
>> + * cpus in the same coupled group have called this function. Once any caller
>> + * has returned from this function, the barrier is immediately available for
>> + * reuse.
>> + *
>> + * The atomic variable a must be initialized to 0 before any cpu calls
>> + * this function, will be reset to 0 before any cpu returns from this function.
>> + *
>> + * Must only be called from within a coupled idle state handler
>> + * (state.enter when state.flags has CPUIDLE_FLAG_COUPLED set).
>> + *
>> + * Provides full smp barrier semantics before and after calling.
>> + */
>> +void cpuidle_coupled_parallel_barrier(struct cpuidle_device *dev, atomic_t *a)
>> +{
>> + int n = dev->coupled->online_count;
>> +
>> + smp_mb__before_atomic_inc();
>> + atomic_inc(a);
>> +
>> + while (atomic_read(a) < n)
>> + cpu_relax();
>> +
>> + if (atomic_inc_return(a) == n * 2) {
>> + atomic_set(a, 0);
>> + return;
>> + }
>> +
>> + while (atomic_read(a) > n)
>> + cpu_relax();
>> +}
>
> Well, this looks like "wait until all CPUs execute this code". Don't we have
> anything like this already somewhere?
>
>> +
>> +/**
>> * cpuidle_state_is_coupled - check if a state is part of a coupled set
>> * @dev: struct cpuidle_device for the current cpu
>> * @drv: struct cpuidle_driver for the platform
>> diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
>> index 6038448..5ab7183 100644
>> --- a/include/linux/cpuidle.h
>> +++ b/include/linux/cpuidle.h
>> @@ -183,6 +183,10 @@ static inline int cpuidle_wrap_enter(struct cpuidle_device *dev,
>>
>> #endif
>>
>> +#ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED
>> +void cpuidle_coupled_parallel_barrier(struct cpuidle_device *dev, atomic_t *a);
>> +#endif
>
> Why exactly is the extra Kconfig option necessary?
It prevents compiling in coupled.o (2k text section) on the majority
of kernels that will never use it.
^ permalink raw reply
* RE: [PATCH V3 07/10] ARM: OMAP2+: SmartReflex: Use per-OPP data structure
From: Guyotte, Greg @ 2012-05-10 19:11 UTC (permalink / raw)
To: J, KEERTHY, linux-omap@vger.kernel.org,
linux-arm-kernel@lists.infradead.org, Hilman, Kevin, rjw@sisk.pl,
linux-kernel@vger.kernel.org, linux-pm@lists.linux-foundation.org
Cc: Pihet-XID, Jean, Paul Walmsley, Gopinath, Thara, Menon, Nishanth
In-Reply-To: <1335462041-4949-8-git-send-email-j-keerthy@ti.com>
Hi Jean,
> -----Original Message-----
> From: linux-omap-owner@vger.kernel.org [mailto:linux-omap-
> owner@vger.kernel.org] On Behalf Of J, KEERTHY
> Sent: Thursday, April 26, 2012 12:41 PM
> To: linux-omap@vger.kernel.org; linux-arm-kernel@lists.infradead.org;
> Hilman, Kevin; rjw@sisk.pl; linux-kernel@vger.kernel.org; linux-
> pm@lists.linux-foundation.org
> Cc: Pihet-XID, Jean; J, KEERTHY; Paul Walmsley; Gopinath, Thara; Menon,
> Nishanth
> Subject: [PATCH V3 07/10] ARM: OMAP2+: SmartReflex: Use per-OPP data
> structure
>
> From: Jean Pihet <j-pihet@ti.com>
>
> The SmartReflex driver incorrectly treats some per-OPP data as data
> common to all OPPs (e.g., ERRMINLIMIT). Move this data into a per-OPP
> data structure.
>
> Furthermore, in order to make the SmartReflex implementation ready for
> the move to drivers/, remove the dependency from the SR driver code
> to the voltage layer by querying the data tables only from the SR device
> init code.
>
> Based on Paul's original code for the SmartReflex driver conversion.
>
> Signed-off-by: Jean Pihet <j-pihet@ti.com>
> Signed-off-by: J Keerthy <j-keerthy@ti.com>
> Cc: Paul Walmsley <paul@pwsan.com>
> Cc: Thara Gopinath <thara@ti.com>
> Cc: Nishanth Menon <nm@ti.com>
> Cc: Kevin Hilman <khilman@ti.com>
> ---
> arch/arm/mach-omap2/smartreflex.c | 38 +++++++++++++++++---------------
> ----
> arch/arm/mach-omap2/sr_device.c | 36 +++++++++++++++++++++++++++++---
> --
> include/linux/power/smartreflex.h | 8 +++++-
> 3 files changed, 54 insertions(+), 28 deletions(-)
>
> diff --git a/arch/arm/mach-omap2/smartreflex.c b/arch/arm/mach-
> omap2/smartreflex.c
> index acef08d..20075de 100644
> --- a/arch/arm/mach-omap2/smartreflex.c
> +++ b/arch/arm/mach-omap2/smartreflex.c
> @@ -347,22 +347,23 @@ static void sr_v2_disable(struct omap_sr *sr)
> sr_write_reg(sr, IRQSTATUS, IRQSTATUS_MCUDISABLEACKINT);
> }
>
> -static u32 sr_retrieve_nvalue(struct omap_sr *sr, u32 efuse_offs)
> +static struct omap_sr_nvalue_table *sr_retrieve_nvalue_row(
> + struct omap_sr *sr, u32 efuse_offs)
> {
> int i;
>
> if (!sr->nvalue_table) {
> dev_warn(&sr->pdev->dev, "%s: Missing ntarget value table\n",
> __func__);
> - return 0;
> + return NULL;
> }
>
> for (i = 0; i < sr->nvalue_count; i++) {
> if (sr->nvalue_table[i].efuse_offs == efuse_offs)
> - return sr->nvalue_table[i].nvalue;
> + return &sr->nvalue_table[i];
> }
>
> - return 0;
> + return NULL;
> }
>
> /* Public Functions */
> @@ -586,7 +587,7 @@ int sr_enable(struct voltagedomain *voltdm, unsigned
> long volt)
> {
> struct omap_volt_data *volt_data;
> struct omap_sr *sr = _sr_lookup(voltdm);
> - u32 nvalue_reciprocal;
> + struct omap_sr_nvalue_table *nvalue_row;
> int ret;
>
> if (IS_ERR(sr)) {
> @@ -602,16 +603,16 @@ int sr_enable(struct voltagedomain *voltdm, unsigned
> long volt)
> return PTR_ERR(volt_data);
> }
>
> - nvalue_reciprocal = sr_retrieve_nvalue(sr, volt_data-
> >sr_efuse_offs);
> + nvalue_row = sr_retrieve_nvalue_row(sr, volt_data->sr_efuse_offs);
>
> - if (!nvalue_reciprocal) {
> - dev_warn(&sr->pdev->dev, "%s: NVALUE = 0 at voltage %ld\n",
> - __func__, volt);
> + if (!nvalue_row) {
> + dev_warn(&sr->pdev->dev, "%s: failure getting SR data for this
> voltage %ld\n",
> + __func__, volt);
> return -ENODATA;
> }
>
> /* errminlimit is opp dependent and hence linked to voltage */
> - sr->err_minlimit = volt_data->sr_errminlimit;
> + sr->err_minlimit = nvalue_row->errminlimit;
>
> pm_runtime_get_sync(&sr->pdev->dev);
>
> @@ -624,7 +625,7 @@ int sr_enable(struct voltagedomain *voltdm, unsigned
> long volt)
> if (ret)
> return ret;
>
> - sr_write_reg(sr, NVALUERECIPROCAL, nvalue_reciprocal);
> + sr_write_reg(sr, NVALUERECIPROCAL, nvalue_row->nvalue);
>
> /* SRCONFIG - enable SR */
> sr_modify_reg(sr, SRCONFIG, SRCONFIG_SRENABLE, SRCONFIG_SRENABLE);
> @@ -872,7 +873,6 @@ static int __init omap_sr_probe(struct platform_device
> *pdev)
> struct omap_sr_data *pdata = pdev->dev.platform_data;
> struct resource *mem, *irq;
> struct dentry *nvalue_dir;
> - struct omap_volt_data *volt_data;
> int i, ret = 0;
>
> sr_info = kzalloc(sizeof(struct omap_sr), GFP_KERNEL);
> @@ -990,12 +990,10 @@ static int __init omap_sr_probe(struct
> platform_device *pdev)
> goto err_debugfs;
> }
>
> - omap_voltage_get_volttable(sr_info->voltdm, &volt_data);
> - if (!volt_data) {
> - dev_warn(&pdev->dev, "%s: %s: No Voltage table for the"
> - " corresponding vdd. Cannot create debugfs"
> - "entries for n-values\n",
> - __func__, sr_info->name);
> + if (sr_info->nvalue_count == 0 || !sr_info->nvalue_table) {
> + dev_warn(&pdev->dev, "%s: %s: No Voltage table for the
> corresponding vdd. Cannot create debugfs entries for n-values\n",
> + __func__, sr_info->name);
> +
> ret = -ENODATA;
> goto err_debugfs;
> }
> @@ -1003,8 +1001,8 @@ static int __init omap_sr_probe(struct
> platform_device *pdev)
> for (i = 0; i < sr_info->nvalue_count; i++) {
> char name[NVALUE_NAME_LEN + 1];
>
> - snprintf(name, sizeof(name), "volt_%d",
> - volt_data[i].volt_nominal);
> + snprintf(name, sizeof(name), "volt_%lu",
> + sr_info->nvalue_table[i].volt_nominal);
> (void) debugfs_create_x32(name, S_IRUGO | S_IWUSR, nvalue_dir,
> &(sr_info->nvalue_table[i].nvalue));
> }
> diff --git a/arch/arm/mach-omap2/sr_device.c b/arch/arm/mach-
> omap2/sr_device.c
> index e081174..e107e39 100644
> --- a/arch/arm/mach-omap2/sr_device.c
> +++ b/arch/arm/mach-omap2/sr_device.c
> @@ -36,7 +36,10 @@ static void __init sr_set_nvalues(struct omap_volt_data
> *volt_data,
> struct omap_sr_data *sr_data)
> {
> struct omap_sr_nvalue_table *nvalue_table;
> - int i, count = 0;
> + int i, j, count = 0;
> +
> + sr_data->nvalue_count = 0;
> + sr_data->nvalue_table = NULL;
>
> while (volt_data[count].volt_nominal)
> count++;
> @@ -44,8 +47,14 @@ static void __init sr_set_nvalues(struct omap_volt_data
> *volt_data,
> nvalue_table = kzalloc(sizeof(struct omap_sr_nvalue_table)*count,
> GFP_KERNEL);
>
> - for (i = 0; i < count; i++) {
> + if (!nvalue_table) {
> + pr_err("OMAP: SmartReflex: cannot allocate memory for n-value
> table\n");
> + return;
> + }
> +
> + for (i = 0, j = 0; i < count; i++) {
> u32 v;
> +
> /*
> * In OMAP4 the efuse registers are 24 bit aligned.
> * A __raw_readl will fail for non-32 bit aligned address
> @@ -58,15 +67,30 @@ static void __init sr_set_nvalues(struct
> omap_volt_data *volt_data,
> omap_ctrl_readb(offset + 1) << 8 |
> omap_ctrl_readb(offset + 2) << 16;
> } else {
> - v = omap_ctrl_readl(volt_data[i].sr_efuse_offs);
> + v = omap_ctrl_readl(volt_data[i].sr_efuse_offs);
> }
>
> - nvalue_table[i].efuse_offs = volt_data[i].sr_efuse_offs;
> - nvalue_table[i].nvalue = v;
> + /*
> + * Many OMAP SoCs don't have the eFuse values set.
> + * For example, pretty much all OMAP3xxx before
> + * ES3.something.
> + *
> + * XXX There needs to be some way for board files or
> + * userspace to add these in.
> + */
> + if (v == 0)
> + continue;
> +
> + nvalue_table[j].nvalue = v;
> + nvalue_table[j].efuse_offs = volt_data[i].sr_efuse_offs;
> + nvalue_table[j].errminlimit = volt_data[i].sr_errminlimit;
> + nvalue_table[j].volt_nominal = volt_data[i].volt_nominal;
> +
> + j++;
> }
>
> sr_data->nvalue_table = nvalue_table;
> - sr_data->nvalue_count = count;
> + sr_data->nvalue_count = j;
> }
>
> static int __init sr_dev_init(struct omap_hwmod *oh, void *user)
> diff --git a/include/linux/power/smartreflex.h
> b/include/linux/power/smartreflex.h
> index 78b795e..222f901 100644
> --- a/include/linux/power/smartreflex.h
> +++ b/include/linux/power/smartreflex.h
> @@ -243,12 +243,16 @@ struct omap_sr_class_data {
> /**
> * struct omap_sr_nvalue_table - Smartreflex n-target value info
> *
> - * @efuse_offs: The offset of the efuse where n-target values are stored.
> - * @nvalue: The n-target value.
> + * @efuse_offs: The offset of the efuse where n-target values are
> stored.
> + * @nvalue: The n-target value.
> + * @errminlimit: The value of the ERRMINLIMIT bitfield for this n-target
> + * @volt_nominal: microvolts DC that the VDD is initially programmed to
> */
> struct omap_sr_nvalue_table {
> u32 efuse_offs;
> u32 nvalue;
> + u32 errminlimit;
> + unsigned long volt_nominal;
[GG] I would suggest that we also need to add errmaxlimit and errweight fields to this structure. These are very much possible to change per OPP, though it hasn't been common in implementations up to now.
> };
>
> /**
> --
> 1.7.5.4
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-omap" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox