mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-29 23:53:32 +00:00
17e8351a77
The thermal code uses int, long and unsigned long for temperatures in different places. Using an unsigned type limits the thermal framework to positive temperatures without need. Also several drivers currently will report temperatures near UINT_MAX for temperatures below 0°C. This will probably immediately shut the machine down due to overtemperature if started below 0°C. 'long' is 64bit on several architectures. This is not needed since INT_MAX °mC is above the melting point of all known materials. Consistently use a plain 'int' for temperatures throughout the thermal code and the drivers. This only changes the places in the drivers where the temperature is passed around as pointer, when drivers internally use another type this is not changed. Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de> Acked-by: Geert Uytterhoeven <geert+renesas@glider.be> Reviewed-by: Jean Delvare <jdelvare@suse.de> Reviewed-by: Lukasz Majewski <l.majewski@samsung.com> Reviewed-by: Darren Hart <dvhart@linux.intel.com> Reviewed-by: Heiko Stuebner <heiko@sntech.de> Reviewed-by: Peter Feuerer <peter@piie.net> Cc: Punit Agrawal <punit.agrawal@arm.com> Cc: Zhang Rui <rui.zhang@intel.com> Cc: Eduardo Valentin <edubezval@gmail.com> Cc: linux-pm@vger.kernel.org Cc: linux-kernel@vger.kernel.org Cc: Jean Delvare <jdelvare@suse.de> Cc: Peter Feuerer <peter@piie.net> Cc: Heiko Stuebner <heiko@sntech.de> Cc: Lukasz Majewski <l.majewski@samsung.com> Cc: Stephen Warren <swarren@wwwdotorg.org> Cc: Thierry Reding <thierry.reding@gmail.com> Cc: linux-acpi@vger.kernel.org Cc: platform-driver-x86@vger.kernel.org Cc: linux-arm-kernel@lists.infradead.org Cc: linux-omap@vger.kernel.org Cc: linux-samsung-soc@vger.kernel.org Cc: Guenter Roeck <linux@roeck-us.net> Cc: Rafael J. Wysocki <rjw@rjwysocki.net> Cc: Maxime Ripard <maxime.ripard@free-electrons.com> Cc: Darren Hart <dvhart@infradead.org> Cc: lm-sensors@lm-sensors.org Signed-off-by: Zhang Rui <rui.zhang@intel.com>
340 lines
7.9 KiB
C
340 lines
7.9 KiB
C
/*
|
|
* INT3400 thermal driver
|
|
*
|
|
* Copyright (C) 2014, Intel Corporation
|
|
* Authors: Zhang Rui <rui.zhang@intel.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/acpi.h>
|
|
#include <linux/thermal.h>
|
|
#include "acpi_thermal_rel.h"
|
|
|
|
enum int3400_thermal_uuid {
|
|
INT3400_THERMAL_PASSIVE_1,
|
|
INT3400_THERMAL_ACTIVE,
|
|
INT3400_THERMAL_CRITICAL,
|
|
INT3400_THERMAL_MAXIMUM_UUID,
|
|
};
|
|
|
|
static u8 *int3400_thermal_uuids[INT3400_THERMAL_MAXIMUM_UUID] = {
|
|
"42A441D6-AE6A-462b-A84B-4A8CE79027D3",
|
|
"3A95C389-E4B8-4629-A526-C52C88626BAE",
|
|
"97C68AE7-15FA-499c-B8C9-5DA81D606E0A",
|
|
};
|
|
|
|
struct int3400_thermal_priv {
|
|
struct acpi_device *adev;
|
|
struct thermal_zone_device *thermal;
|
|
int mode;
|
|
int art_count;
|
|
struct art *arts;
|
|
int trt_count;
|
|
struct trt *trts;
|
|
u8 uuid_bitmap;
|
|
int rel_misc_dev_res;
|
|
int current_uuid_index;
|
|
};
|
|
|
|
static ssize_t available_uuids_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
struct int3400_thermal_priv *priv = platform_get_drvdata(pdev);
|
|
int i;
|
|
int length = 0;
|
|
|
|
for (i = 0; i < INT3400_THERMAL_MAXIMUM_UUID; i++) {
|
|
if (priv->uuid_bitmap & (1 << i))
|
|
if (PAGE_SIZE - length > 0)
|
|
length += snprintf(&buf[length],
|
|
PAGE_SIZE - length,
|
|
"%s\n",
|
|
int3400_thermal_uuids[i]);
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
static ssize_t current_uuid_show(struct device *dev,
|
|
struct device_attribute *devattr, char *buf)
|
|
{
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
struct int3400_thermal_priv *priv = platform_get_drvdata(pdev);
|
|
|
|
if (priv->uuid_bitmap & (1 << priv->current_uuid_index))
|
|
return sprintf(buf, "%s\n",
|
|
int3400_thermal_uuids[priv->current_uuid_index]);
|
|
else
|
|
return sprintf(buf, "INVALID\n");
|
|
}
|
|
|
|
static ssize_t current_uuid_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
struct int3400_thermal_priv *priv = platform_get_drvdata(pdev);
|
|
int i;
|
|
|
|
for (i = 0; i < INT3400_THERMAL_MAXIMUM_UUID; ++i) {
|
|
if ((priv->uuid_bitmap & (1 << i)) &&
|
|
!(strncmp(buf, int3400_thermal_uuids[i],
|
|
sizeof(int3400_thermal_uuids[i]) - 1))) {
|
|
priv->current_uuid_index = i;
|
|
return count;
|
|
}
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static DEVICE_ATTR(current_uuid, 0644, current_uuid_show, current_uuid_store);
|
|
static DEVICE_ATTR_RO(available_uuids);
|
|
static struct attribute *uuid_attrs[] = {
|
|
&dev_attr_available_uuids.attr,
|
|
&dev_attr_current_uuid.attr,
|
|
NULL
|
|
};
|
|
|
|
static struct attribute_group uuid_attribute_group = {
|
|
.attrs = uuid_attrs,
|
|
.name = "uuids"
|
|
};
|
|
|
|
static int int3400_thermal_get_uuids(struct int3400_thermal_priv *priv)
|
|
{
|
|
struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER, NULL};
|
|
union acpi_object *obja, *objb;
|
|
int i, j;
|
|
int result = 0;
|
|
acpi_status status;
|
|
|
|
status = acpi_evaluate_object(priv->adev->handle, "IDSP", NULL, &buf);
|
|
if (ACPI_FAILURE(status))
|
|
return -ENODEV;
|
|
|
|
obja = (union acpi_object *)buf.pointer;
|
|
if (obja->type != ACPI_TYPE_PACKAGE) {
|
|
result = -EINVAL;
|
|
goto end;
|
|
}
|
|
|
|
for (i = 0; i < obja->package.count; i++) {
|
|
objb = &obja->package.elements[i];
|
|
if (objb->type != ACPI_TYPE_BUFFER) {
|
|
result = -EINVAL;
|
|
goto end;
|
|
}
|
|
|
|
/* UUID must be 16 bytes */
|
|
if (objb->buffer.length != 16) {
|
|
result = -EINVAL;
|
|
goto end;
|
|
}
|
|
|
|
for (j = 0; j < INT3400_THERMAL_MAXIMUM_UUID; j++) {
|
|
u8 uuid[16];
|
|
|
|
acpi_str_to_uuid(int3400_thermal_uuids[j], uuid);
|
|
if (!strncmp(uuid, objb->buffer.pointer, 16)) {
|
|
priv->uuid_bitmap |= (1 << j);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
end:
|
|
kfree(buf.pointer);
|
|
return result;
|
|
}
|
|
|
|
static int int3400_thermal_run_osc(acpi_handle handle,
|
|
enum int3400_thermal_uuid uuid, bool enable)
|
|
{
|
|
u32 ret, buf[2];
|
|
acpi_status status;
|
|
int result = 0;
|
|
struct acpi_osc_context context = {
|
|
.uuid_str = int3400_thermal_uuids[uuid],
|
|
.rev = 1,
|
|
.cap.length = 8,
|
|
};
|
|
|
|
buf[OSC_QUERY_DWORD] = 0;
|
|
buf[OSC_SUPPORT_DWORD] = enable;
|
|
|
|
context.cap.pointer = buf;
|
|
|
|
status = acpi_run_osc(handle, &context);
|
|
if (ACPI_SUCCESS(status)) {
|
|
ret = *((u32 *)(context.ret.pointer + 4));
|
|
if (ret != enable)
|
|
result = -EPERM;
|
|
} else
|
|
result = -EPERM;
|
|
|
|
kfree(context.ret.pointer);
|
|
return result;
|
|
}
|
|
|
|
static int int3400_thermal_get_temp(struct thermal_zone_device *thermal,
|
|
int *temp)
|
|
{
|
|
*temp = 20 * 1000; /* faked temp sensor with 20C */
|
|
return 0;
|
|
}
|
|
|
|
static int int3400_thermal_get_mode(struct thermal_zone_device *thermal,
|
|
enum thermal_device_mode *mode)
|
|
{
|
|
struct int3400_thermal_priv *priv = thermal->devdata;
|
|
|
|
if (!priv)
|
|
return -EINVAL;
|
|
|
|
*mode = priv->mode;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int int3400_thermal_set_mode(struct thermal_zone_device *thermal,
|
|
enum thermal_device_mode mode)
|
|
{
|
|
struct int3400_thermal_priv *priv = thermal->devdata;
|
|
bool enable;
|
|
int result = 0;
|
|
|
|
if (!priv)
|
|
return -EINVAL;
|
|
|
|
if (mode == THERMAL_DEVICE_ENABLED)
|
|
enable = true;
|
|
else if (mode == THERMAL_DEVICE_DISABLED)
|
|
enable = false;
|
|
else
|
|
return -EINVAL;
|
|
|
|
if (enable != priv->mode) {
|
|
priv->mode = enable;
|
|
result = int3400_thermal_run_osc(priv->adev->handle,
|
|
priv->current_uuid_index,
|
|
enable);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static struct thermal_zone_device_ops int3400_thermal_ops = {
|
|
.get_temp = int3400_thermal_get_temp,
|
|
};
|
|
|
|
static struct thermal_zone_params int3400_thermal_params = {
|
|
.governor_name = "user_space",
|
|
.no_hwmon = true,
|
|
};
|
|
|
|
static int int3400_thermal_probe(struct platform_device *pdev)
|
|
{
|
|
struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
|
|
struct int3400_thermal_priv *priv;
|
|
int result;
|
|
|
|
if (!adev)
|
|
return -ENODEV;
|
|
|
|
priv = kzalloc(sizeof(struct int3400_thermal_priv), GFP_KERNEL);
|
|
if (!priv)
|
|
return -ENOMEM;
|
|
|
|
priv->adev = adev;
|
|
|
|
result = int3400_thermal_get_uuids(priv);
|
|
if (result)
|
|
goto free_priv;
|
|
|
|
result = acpi_parse_art(priv->adev->handle, &priv->art_count,
|
|
&priv->arts, true);
|
|
if (result)
|
|
dev_dbg(&pdev->dev, "_ART table parsing error\n");
|
|
|
|
result = acpi_parse_trt(priv->adev->handle, &priv->trt_count,
|
|
&priv->trts, true);
|
|
if (result)
|
|
dev_dbg(&pdev->dev, "_TRT table parsing error\n");
|
|
|
|
platform_set_drvdata(pdev, priv);
|
|
|
|
if (priv->uuid_bitmap & 1 << INT3400_THERMAL_PASSIVE_1) {
|
|
int3400_thermal_ops.get_mode = int3400_thermal_get_mode;
|
|
int3400_thermal_ops.set_mode = int3400_thermal_set_mode;
|
|
}
|
|
priv->thermal = thermal_zone_device_register("INT3400 Thermal", 0, 0,
|
|
priv, &int3400_thermal_ops,
|
|
&int3400_thermal_params, 0, 0);
|
|
if (IS_ERR(priv->thermal)) {
|
|
result = PTR_ERR(priv->thermal);
|
|
goto free_art_trt;
|
|
}
|
|
|
|
priv->rel_misc_dev_res = acpi_thermal_rel_misc_device_add(
|
|
priv->adev->handle);
|
|
|
|
result = sysfs_create_group(&pdev->dev.kobj, &uuid_attribute_group);
|
|
if (result)
|
|
goto free_zone;
|
|
|
|
return 0;
|
|
|
|
free_zone:
|
|
thermal_zone_device_unregister(priv->thermal);
|
|
free_art_trt:
|
|
kfree(priv->trts);
|
|
kfree(priv->arts);
|
|
free_priv:
|
|
kfree(priv);
|
|
return result;
|
|
}
|
|
|
|
static int int3400_thermal_remove(struct platform_device *pdev)
|
|
{
|
|
struct int3400_thermal_priv *priv = platform_get_drvdata(pdev);
|
|
|
|
if (!priv->rel_misc_dev_res)
|
|
acpi_thermal_rel_misc_device_remove(priv->adev->handle);
|
|
|
|
sysfs_remove_group(&pdev->dev.kobj, &uuid_attribute_group);
|
|
thermal_zone_device_unregister(priv->thermal);
|
|
kfree(priv->trts);
|
|
kfree(priv->arts);
|
|
kfree(priv);
|
|
return 0;
|
|
}
|
|
|
|
static const struct acpi_device_id int3400_thermal_match[] = {
|
|
{"INT3400", 0},
|
|
{}
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(acpi, int3400_thermal_match);
|
|
|
|
static struct platform_driver int3400_thermal_driver = {
|
|
.probe = int3400_thermal_probe,
|
|
.remove = int3400_thermal_remove,
|
|
.driver = {
|
|
.name = "int3400 thermal",
|
|
.acpi_match_table = ACPI_PTR(int3400_thermal_match),
|
|
},
|
|
};
|
|
|
|
module_platform_driver(int3400_thermal_driver);
|
|
|
|
MODULE_DESCRIPTION("INT3400 Thermal driver");
|
|
MODULE_AUTHOR("Zhang Rui <rui.zhang@intel.com>");
|
|
MODULE_LICENSE("GPL");
|