mirror of
https://github.com/torvalds/linux.git
synced 2024-11-22 12:11:40 +00:00
b1c75b3820
Make the ACPI thermal zone driver use the .should_bind() thermal zone callback to provide the thermal core with the information on whether or not to bind the given cooling device to the given trip point in the given thermal zone. If it returns 'true', the thermal core will bind the cooling device to the trip and the corresponding unbinding will be taken care of automatically by the core on the removal of the involved thermal zone or cooling device. This replaces the .bind() and .unbind() thermal zone callbacks which allows the code to be simplified quite significantly while providing the same functionality. Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com> Reviewed-by: Zhang Rui <rui.zhang@intel.com> Reviewed-by: Daniel Lezcano <daniel.lezcano@linaro.org> Link: https://patch.msgid.link/1812827.VLH7GnMWUR@rjwysocki.net
1089 lines
27 KiB
C
1089 lines
27 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* acpi_thermal.c - ACPI Thermal Zone Driver ($Revision: 41 $)
|
|
*
|
|
* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
|
|
* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
|
|
*
|
|
* This driver fully implements the ACPI thermal policy as described in the
|
|
* ACPI 2.0 Specification.
|
|
*
|
|
* TBD: 1. Implement passive cooling hysteresis.
|
|
* 2. Enhance passive cooling (CPU) states/limit interface to support
|
|
* concepts of 'multiple limiters', upper/lower limits, etc.
|
|
*/
|
|
|
|
#define pr_fmt(fmt) "ACPI: thermal: " fmt
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/dmi.h>
|
|
#include <linux/init.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/types.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/kmod.h>
|
|
#include <linux/reboot.h>
|
|
#include <linux/device.h>
|
|
#include <linux/thermal.h>
|
|
#include <linux/acpi.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/uaccess.h>
|
|
#include <linux/units.h>
|
|
|
|
#include "internal.h"
|
|
|
|
#define ACPI_THERMAL_CLASS "thermal_zone"
|
|
#define ACPI_THERMAL_DEVICE_NAME "Thermal Zone"
|
|
#define ACPI_THERMAL_NOTIFY_TEMPERATURE 0x80
|
|
#define ACPI_THERMAL_NOTIFY_THRESHOLDS 0x81
|
|
#define ACPI_THERMAL_NOTIFY_DEVICES 0x82
|
|
#define ACPI_THERMAL_NOTIFY_CRITICAL 0xF0
|
|
#define ACPI_THERMAL_NOTIFY_HOT 0xF1
|
|
#define ACPI_THERMAL_MODE_ACTIVE 0x00
|
|
|
|
#define ACPI_THERMAL_MAX_ACTIVE 10
|
|
#define ACPI_THERMAL_MAX_LIMIT_STR_LEN 65
|
|
|
|
#define ACPI_THERMAL_TRIP_PASSIVE (-1)
|
|
|
|
#define ACPI_THERMAL_MAX_NR_TRIPS (ACPI_THERMAL_MAX_ACTIVE + 3)
|
|
|
|
/*
|
|
* This exception is thrown out in two cases:
|
|
* 1.An invalid trip point becomes invalid or a valid trip point becomes invalid
|
|
* when re-evaluating the AML code.
|
|
* 2.TODO: Devices listed in _PSL, _ALx, _TZD may change.
|
|
* We need to re-bind the cooling devices of a thermal zone when this occurs.
|
|
*/
|
|
#define ACPI_THERMAL_TRIPS_EXCEPTION(tz, str) \
|
|
do { \
|
|
acpi_handle_info(tz->device->handle, \
|
|
"ACPI thermal trip point %s changed\n" \
|
|
"Please report to linux-acpi@vger.kernel.org\n", str); \
|
|
} while (0)
|
|
|
|
static int act;
|
|
module_param(act, int, 0644);
|
|
MODULE_PARM_DESC(act, "Disable or override all lowest active trip points.");
|
|
|
|
static int crt;
|
|
module_param(crt, int, 0644);
|
|
MODULE_PARM_DESC(crt, "Disable or lower all critical trip points.");
|
|
|
|
static int tzp;
|
|
module_param(tzp, int, 0444);
|
|
MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.");
|
|
|
|
static int off;
|
|
module_param(off, int, 0);
|
|
MODULE_PARM_DESC(off, "Set to disable ACPI thermal support.");
|
|
|
|
static int psv;
|
|
module_param(psv, int, 0644);
|
|
MODULE_PARM_DESC(psv, "Disable or override all passive trip points.");
|
|
|
|
static struct workqueue_struct *acpi_thermal_pm_queue;
|
|
|
|
struct acpi_thermal_trip {
|
|
unsigned long temp_dk;
|
|
struct acpi_handle_list devices;
|
|
};
|
|
|
|
struct acpi_thermal_passive {
|
|
struct acpi_thermal_trip trip;
|
|
unsigned long tc1;
|
|
unsigned long tc2;
|
|
unsigned long delay;
|
|
};
|
|
|
|
struct acpi_thermal_active {
|
|
struct acpi_thermal_trip trip;
|
|
};
|
|
|
|
struct acpi_thermal_trips {
|
|
struct acpi_thermal_passive passive;
|
|
struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
|
|
};
|
|
|
|
struct acpi_thermal {
|
|
struct acpi_device *device;
|
|
acpi_bus_id name;
|
|
unsigned long temp_dk;
|
|
unsigned long last_temp_dk;
|
|
unsigned long polling_frequency;
|
|
volatile u8 zombie;
|
|
struct acpi_thermal_trips trips;
|
|
struct thermal_zone_device *thermal_zone;
|
|
int kelvin_offset; /* in millidegrees */
|
|
struct work_struct thermal_check_work;
|
|
struct mutex thermal_check_lock;
|
|
refcount_t thermal_check_count;
|
|
};
|
|
|
|
/* --------------------------------------------------------------------------
|
|
Thermal Zone Management
|
|
-------------------------------------------------------------------------- */
|
|
|
|
static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
|
|
{
|
|
acpi_status status = AE_OK;
|
|
unsigned long long tmp;
|
|
|
|
if (!tz)
|
|
return -EINVAL;
|
|
|
|
tz->last_temp_dk = tz->temp_dk;
|
|
|
|
status = acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tmp);
|
|
if (ACPI_FAILURE(status))
|
|
return -ENODEV;
|
|
|
|
tz->temp_dk = tmp;
|
|
|
|
acpi_handle_debug(tz->device->handle, "Temperature is %lu dK\n",
|
|
tz->temp_dk);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
|
|
{
|
|
acpi_status status = AE_OK;
|
|
unsigned long long tmp;
|
|
|
|
if (!tz)
|
|
return -EINVAL;
|
|
|
|
status = acpi_evaluate_integer(tz->device->handle, "_TZP", NULL, &tmp);
|
|
if (ACPI_FAILURE(status))
|
|
return -ENODEV;
|
|
|
|
tz->polling_frequency = tmp;
|
|
acpi_handle_debug(tz->device->handle, "Polling frequency is %lu dS\n",
|
|
tz->polling_frequency);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int acpi_thermal_temp(struct acpi_thermal *tz, int temp_deci_k)
|
|
{
|
|
int temp;
|
|
|
|
if (temp_deci_k == THERMAL_TEMP_INVALID)
|
|
return THERMAL_TEMP_INVALID;
|
|
|
|
temp = deci_kelvin_to_millicelsius_with_offset(temp_deci_k,
|
|
tz->kelvin_offset);
|
|
if (temp <= 0)
|
|
return THERMAL_TEMP_INVALID;
|
|
|
|
return temp;
|
|
}
|
|
|
|
static bool acpi_thermal_trip_valid(struct acpi_thermal_trip *acpi_trip)
|
|
{
|
|
return acpi_trip->temp_dk != THERMAL_TEMP_INVALID;
|
|
}
|
|
|
|
static int active_trip_index(struct acpi_thermal *tz,
|
|
struct acpi_thermal_trip *acpi_trip)
|
|
{
|
|
struct acpi_thermal_active *active;
|
|
|
|
active = container_of(acpi_trip, struct acpi_thermal_active, trip);
|
|
return active - tz->trips.active;
|
|
}
|
|
|
|
static long get_passive_temp(struct acpi_thermal *tz)
|
|
{
|
|
int temp;
|
|
|
|
if (acpi_passive_trip_temp(tz->device, &temp))
|
|
return THERMAL_TEMP_INVALID;
|
|
|
|
return temp;
|
|
}
|
|
|
|
static long get_active_temp(struct acpi_thermal *tz, int index)
|
|
{
|
|
int temp;
|
|
|
|
if (acpi_active_trip_temp(tz->device, index, &temp))
|
|
return THERMAL_TEMP_INVALID;
|
|
|
|
/*
|
|
* If an override has been provided, apply it so there are no active
|
|
* trips with thresholds greater than the override.
|
|
*/
|
|
if (act > 0) {
|
|
unsigned long long override = celsius_to_deci_kelvin(act);
|
|
|
|
if (temp > override)
|
|
return override;
|
|
}
|
|
return temp;
|
|
}
|
|
|
|
static void acpi_thermal_update_trip(struct acpi_thermal *tz,
|
|
const struct thermal_trip *trip)
|
|
{
|
|
struct acpi_thermal_trip *acpi_trip = trip->priv;
|
|
|
|
if (trip->type == THERMAL_TRIP_PASSIVE) {
|
|
if (psv > 0)
|
|
return;
|
|
|
|
acpi_trip->temp_dk = get_passive_temp(tz);
|
|
} else {
|
|
int index = active_trip_index(tz, acpi_trip);
|
|
|
|
acpi_trip->temp_dk = get_active_temp(tz, index);
|
|
}
|
|
|
|
if (!acpi_thermal_trip_valid(acpi_trip))
|
|
ACPI_THERMAL_TRIPS_EXCEPTION(tz, "state");
|
|
}
|
|
|
|
static bool update_trip_devices(struct acpi_thermal *tz,
|
|
struct acpi_thermal_trip *acpi_trip,
|
|
int index, bool compare)
|
|
{
|
|
struct acpi_handle_list devices = { 0 };
|
|
char method[] = "_PSL";
|
|
|
|
if (index != ACPI_THERMAL_TRIP_PASSIVE) {
|
|
method[1] = 'A';
|
|
method[2] = 'L';
|
|
method[3] = '0' + index;
|
|
}
|
|
|
|
if (!acpi_evaluate_reference(tz->device->handle, method, NULL, &devices)) {
|
|
acpi_handle_info(tz->device->handle, "%s evaluation failure\n", method);
|
|
return false;
|
|
}
|
|
|
|
if (acpi_handle_list_equal(&acpi_trip->devices, &devices)) {
|
|
acpi_handle_list_free(&devices);
|
|
return true;
|
|
}
|
|
|
|
if (compare)
|
|
ACPI_THERMAL_TRIPS_EXCEPTION(tz, "device");
|
|
|
|
acpi_handle_list_replace(&acpi_trip->devices, &devices);
|
|
return true;
|
|
}
|
|
|
|
static void acpi_thermal_update_trip_devices(struct acpi_thermal *tz,
|
|
const struct thermal_trip *trip)
|
|
{
|
|
struct acpi_thermal_trip *acpi_trip = trip->priv;
|
|
int index = trip->type == THERMAL_TRIP_PASSIVE ?
|
|
ACPI_THERMAL_TRIP_PASSIVE : active_trip_index(tz, acpi_trip);
|
|
|
|
if (update_trip_devices(tz, acpi_trip, index, true))
|
|
return;
|
|
|
|
acpi_trip->temp_dk = THERMAL_TEMP_INVALID;
|
|
ACPI_THERMAL_TRIPS_EXCEPTION(tz, "state");
|
|
}
|
|
|
|
struct adjust_trip_data {
|
|
struct acpi_thermal *tz;
|
|
u32 event;
|
|
};
|
|
|
|
static int acpi_thermal_adjust_trip(struct thermal_trip *trip, void *data)
|
|
{
|
|
struct acpi_thermal_trip *acpi_trip = trip->priv;
|
|
struct adjust_trip_data *atd = data;
|
|
struct acpi_thermal *tz = atd->tz;
|
|
int temp;
|
|
|
|
if (!acpi_trip || !acpi_thermal_trip_valid(acpi_trip))
|
|
return 0;
|
|
|
|
if (atd->event == ACPI_THERMAL_NOTIFY_THRESHOLDS)
|
|
acpi_thermal_update_trip(tz, trip);
|
|
else
|
|
acpi_thermal_update_trip_devices(tz, trip);
|
|
|
|
if (acpi_thermal_trip_valid(acpi_trip))
|
|
temp = acpi_thermal_temp(tz, acpi_trip->temp_dk);
|
|
else
|
|
temp = THERMAL_TEMP_INVALID;
|
|
|
|
thermal_zone_set_trip_temp(tz->thermal_zone, trip, temp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void acpi_queue_thermal_check(struct acpi_thermal *tz)
|
|
{
|
|
if (!work_pending(&tz->thermal_check_work))
|
|
queue_work(acpi_thermal_pm_queue, &tz->thermal_check_work);
|
|
}
|
|
|
|
static void acpi_thermal_trips_update(struct acpi_thermal *tz, u32 event)
|
|
{
|
|
struct adjust_trip_data atd = { .tz = tz, .event = event };
|
|
struct acpi_device *adev = tz->device;
|
|
|
|
/*
|
|
* Use thermal_zone_for_each_trip() to carry out the trip points
|
|
* update, so as to protect thermal_get_trend() from getting stale
|
|
* trip point temperatures and to prevent thermal_zone_device_update()
|
|
* invoked from acpi_thermal_check_fn() from producing inconsistent
|
|
* results.
|
|
*/
|
|
thermal_zone_for_each_trip(tz->thermal_zone,
|
|
acpi_thermal_adjust_trip, &atd);
|
|
acpi_queue_thermal_check(tz);
|
|
acpi_bus_generate_netlink_event(adev->pnp.device_class,
|
|
dev_name(&adev->dev), event, 0);
|
|
}
|
|
|
|
static int acpi_thermal_get_critical_trip(struct acpi_thermal *tz)
|
|
{
|
|
int temp;
|
|
|
|
if (crt > 0) {
|
|
temp = celsius_to_deci_kelvin(crt);
|
|
goto set;
|
|
}
|
|
if (crt == -1) {
|
|
acpi_handle_debug(tz->device->handle, "Critical threshold disabled\n");
|
|
return THERMAL_TEMP_INVALID;
|
|
}
|
|
|
|
if (acpi_critical_trip_temp(tz->device, &temp))
|
|
return THERMAL_TEMP_INVALID;
|
|
|
|
if (temp <= 2732) {
|
|
/*
|
|
* Below zero (Celsius) values clearly aren't right for sure,
|
|
* so discard them as invalid.
|
|
*/
|
|
pr_info(FW_BUG "Invalid critical threshold (%d)\n", temp);
|
|
return THERMAL_TEMP_INVALID;
|
|
}
|
|
|
|
set:
|
|
acpi_handle_debug(tz->device->handle, "Critical threshold [%d]\n", temp);
|
|
return temp;
|
|
}
|
|
|
|
static int acpi_thermal_get_hot_trip(struct acpi_thermal *tz)
|
|
{
|
|
int temp;
|
|
|
|
if (acpi_hot_trip_temp(tz->device, &temp) || temp == THERMAL_TEMP_INVALID) {
|
|
acpi_handle_debug(tz->device->handle, "No hot threshold\n");
|
|
return THERMAL_TEMP_INVALID;
|
|
}
|
|
|
|
acpi_handle_debug(tz->device->handle, "Hot threshold [%d]\n", temp);
|
|
return temp;
|
|
}
|
|
|
|
static bool passive_trip_params_init(struct acpi_thermal *tz)
|
|
{
|
|
unsigned long long tmp;
|
|
acpi_status status;
|
|
|
|
status = acpi_evaluate_integer(tz->device->handle, "_TC1", NULL, &tmp);
|
|
if (ACPI_FAILURE(status))
|
|
return false;
|
|
|
|
tz->trips.passive.tc1 = tmp;
|
|
|
|
status = acpi_evaluate_integer(tz->device->handle, "_TC2", NULL, &tmp);
|
|
if (ACPI_FAILURE(status))
|
|
return false;
|
|
|
|
tz->trips.passive.tc2 = tmp;
|
|
|
|
status = acpi_evaluate_integer(tz->device->handle, "_TFP", NULL, &tmp);
|
|
if (ACPI_SUCCESS(status)) {
|
|
tz->trips.passive.delay = tmp;
|
|
return true;
|
|
}
|
|
|
|
status = acpi_evaluate_integer(tz->device->handle, "_TSP", NULL, &tmp);
|
|
if (ACPI_FAILURE(status))
|
|
return false;
|
|
|
|
tz->trips.passive.delay = tmp * 100;
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool acpi_thermal_init_trip(struct acpi_thermal *tz, int index)
|
|
{
|
|
struct acpi_thermal_trip *acpi_trip;
|
|
long temp;
|
|
|
|
if (index == ACPI_THERMAL_TRIP_PASSIVE) {
|
|
acpi_trip = &tz->trips.passive.trip;
|
|
|
|
if (psv == -1)
|
|
goto fail;
|
|
|
|
if (!passive_trip_params_init(tz))
|
|
goto fail;
|
|
|
|
temp = psv > 0 ? celsius_to_deci_kelvin(psv) :
|
|
get_passive_temp(tz);
|
|
} else {
|
|
acpi_trip = &tz->trips.active[index].trip;
|
|
|
|
if (act == -1)
|
|
goto fail;
|
|
|
|
temp = get_active_temp(tz, index);
|
|
}
|
|
|
|
if (temp == THERMAL_TEMP_INVALID)
|
|
goto fail;
|
|
|
|
if (!update_trip_devices(tz, acpi_trip, index, false))
|
|
goto fail;
|
|
|
|
acpi_trip->temp_dk = temp;
|
|
return true;
|
|
|
|
fail:
|
|
acpi_trip->temp_dk = THERMAL_TEMP_INVALID;
|
|
return false;
|
|
}
|
|
|
|
static void acpi_thermal_get_trip_points(struct acpi_thermal *tz)
|
|
{
|
|
int i;
|
|
|
|
acpi_thermal_init_trip(tz, ACPI_THERMAL_TRIP_PASSIVE);
|
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
|
|
if (!acpi_thermal_init_trip(tz, i))
|
|
break;
|
|
}
|
|
|
|
while (++i < ACPI_THERMAL_MAX_ACTIVE)
|
|
tz->trips.active[i].trip.temp_dk = THERMAL_TEMP_INVALID;
|
|
}
|
|
|
|
/* sys I/F for generic thermal sysfs support */
|
|
|
|
static int thermal_get_temp(struct thermal_zone_device *thermal, int *temp)
|
|
{
|
|
struct acpi_thermal *tz = thermal_zone_device_priv(thermal);
|
|
int result;
|
|
|
|
if (!tz)
|
|
return -EINVAL;
|
|
|
|
result = acpi_thermal_get_temperature(tz);
|
|
if (result)
|
|
return result;
|
|
|
|
*temp = deci_kelvin_to_millicelsius_with_offset(tz->temp_dk,
|
|
tz->kelvin_offset);
|
|
return 0;
|
|
}
|
|
|
|
static int thermal_get_trend(struct thermal_zone_device *thermal,
|
|
const struct thermal_trip *trip,
|
|
enum thermal_trend *trend)
|
|
{
|
|
struct acpi_thermal *tz = thermal_zone_device_priv(thermal);
|
|
struct acpi_thermal_trip *acpi_trip;
|
|
int t;
|
|
|
|
if (!tz || !trip)
|
|
return -EINVAL;
|
|
|
|
acpi_trip = trip->priv;
|
|
if (!acpi_trip || !acpi_thermal_trip_valid(acpi_trip))
|
|
return -EINVAL;
|
|
|
|
switch (trip->type) {
|
|
case THERMAL_TRIP_PASSIVE:
|
|
t = tz->trips.passive.tc1 * (tz->temp_dk -
|
|
tz->last_temp_dk) +
|
|
tz->trips.passive.tc2 * (tz->temp_dk -
|
|
acpi_trip->temp_dk);
|
|
if (t > 0)
|
|
*trend = THERMAL_TREND_RAISING;
|
|
else if (t < 0)
|
|
*trend = THERMAL_TREND_DROPPING;
|
|
else
|
|
*trend = THERMAL_TREND_STABLE;
|
|
|
|
return 0;
|
|
|
|
case THERMAL_TRIP_ACTIVE:
|
|
t = acpi_thermal_temp(tz, tz->temp_dk);
|
|
if (t <= trip->temperature)
|
|
break;
|
|
|
|
*trend = THERMAL_TREND_RAISING;
|
|
|
|
return 0;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static void acpi_thermal_zone_device_hot(struct thermal_zone_device *thermal)
|
|
{
|
|
struct acpi_thermal *tz = thermal_zone_device_priv(thermal);
|
|
|
|
acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
|
|
dev_name(&tz->device->dev),
|
|
ACPI_THERMAL_NOTIFY_HOT, 1);
|
|
}
|
|
|
|
static void acpi_thermal_zone_device_critical(struct thermal_zone_device *thermal)
|
|
{
|
|
struct acpi_thermal *tz = thermal_zone_device_priv(thermal);
|
|
|
|
acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
|
|
dev_name(&tz->device->dev),
|
|
ACPI_THERMAL_NOTIFY_CRITICAL, 1);
|
|
|
|
thermal_zone_device_critical(thermal);
|
|
}
|
|
|
|
static bool acpi_thermal_should_bind_cdev(struct thermal_zone_device *thermal,
|
|
const struct thermal_trip *trip,
|
|
struct thermal_cooling_device *cdev,
|
|
struct cooling_spec *c)
|
|
{
|
|
struct acpi_thermal_trip *acpi_trip = trip->priv;
|
|
struct acpi_device *cdev_adev = cdev->devdata;
|
|
int i;
|
|
|
|
/* Skip critical and hot trips. */
|
|
if (!acpi_trip)
|
|
return false;
|
|
|
|
for (i = 0; i < acpi_trip->devices.count; i++) {
|
|
acpi_handle handle = acpi_trip->devices.handles[i];
|
|
|
|
if (acpi_fetch_acpi_dev(handle) == cdev_adev)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static const struct thermal_zone_device_ops acpi_thermal_zone_ops = {
|
|
.should_bind = acpi_thermal_should_bind_cdev,
|
|
.get_temp = thermal_get_temp,
|
|
.get_trend = thermal_get_trend,
|
|
.hot = acpi_thermal_zone_device_hot,
|
|
.critical = acpi_thermal_zone_device_critical,
|
|
};
|
|
|
|
static int acpi_thermal_zone_sysfs_add(struct acpi_thermal *tz)
|
|
{
|
|
struct device *tzdev = thermal_zone_device(tz->thermal_zone);
|
|
int ret;
|
|
|
|
ret = sysfs_create_link(&tz->device->dev.kobj,
|
|
&tzdev->kobj, "thermal_zone");
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = sysfs_create_link(&tzdev->kobj,
|
|
&tz->device->dev.kobj, "device");
|
|
if (ret)
|
|
sysfs_remove_link(&tz->device->dev.kobj, "thermal_zone");
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void acpi_thermal_zone_sysfs_remove(struct acpi_thermal *tz)
|
|
{
|
|
struct device *tzdev = thermal_zone_device(tz->thermal_zone);
|
|
|
|
sysfs_remove_link(&tz->device->dev.kobj, "thermal_zone");
|
|
sysfs_remove_link(&tzdev->kobj, "device");
|
|
}
|
|
|
|
static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz,
|
|
const struct thermal_trip *trip_table,
|
|
unsigned int trip_count,
|
|
int passive_delay)
|
|
{
|
|
int result;
|
|
|
|
if (trip_count)
|
|
tz->thermal_zone = thermal_zone_device_register_with_trips(
|
|
"acpitz", trip_table, trip_count, tz,
|
|
&acpi_thermal_zone_ops, NULL, passive_delay,
|
|
tz->polling_frequency * 100);
|
|
else
|
|
tz->thermal_zone = thermal_tripless_zone_device_register(
|
|
"acpitz", tz, &acpi_thermal_zone_ops, NULL);
|
|
|
|
if (IS_ERR(tz->thermal_zone))
|
|
return PTR_ERR(tz->thermal_zone);
|
|
|
|
result = acpi_thermal_zone_sysfs_add(tz);
|
|
if (result)
|
|
goto unregister_tzd;
|
|
|
|
result = thermal_zone_device_enable(tz->thermal_zone);
|
|
if (result)
|
|
goto remove_links;
|
|
|
|
dev_info(&tz->device->dev, "registered as thermal_zone%d\n",
|
|
thermal_zone_device_id(tz->thermal_zone));
|
|
|
|
return 0;
|
|
|
|
remove_links:
|
|
acpi_thermal_zone_sysfs_remove(tz);
|
|
unregister_tzd:
|
|
thermal_zone_device_unregister(tz->thermal_zone);
|
|
|
|
return result;
|
|
}
|
|
|
|
static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal *tz)
|
|
{
|
|
thermal_zone_device_disable(tz->thermal_zone);
|
|
acpi_thermal_zone_sysfs_remove(tz);
|
|
thermal_zone_device_unregister(tz->thermal_zone);
|
|
tz->thermal_zone = NULL;
|
|
}
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
Driver Interface
|
|
-------------------------------------------------------------------------- */
|
|
|
|
static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data)
|
|
{
|
|
struct acpi_device *device = data;
|
|
struct acpi_thermal *tz = acpi_driver_data(device);
|
|
|
|
if (!tz)
|
|
return;
|
|
|
|
switch (event) {
|
|
case ACPI_THERMAL_NOTIFY_TEMPERATURE:
|
|
acpi_queue_thermal_check(tz);
|
|
break;
|
|
case ACPI_THERMAL_NOTIFY_THRESHOLDS:
|
|
case ACPI_THERMAL_NOTIFY_DEVICES:
|
|
acpi_thermal_trips_update(tz, event);
|
|
break;
|
|
default:
|
|
acpi_handle_debug(device->handle, "Unsupported event [0x%x]\n",
|
|
event);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* On some platforms, the AML code has dependency about
|
|
* the evaluating order of _TMP and _CRT/_HOT/_PSV/_ACx.
|
|
* 1. On HP Pavilion G4-1016tx, _TMP must be invoked after
|
|
* /_CRT/_HOT/_PSV/_ACx, or else system will be power off.
|
|
* 2. On HP Compaq 6715b/6715s, the return value of _PSV is 0
|
|
* if _TMP has never been evaluated.
|
|
*
|
|
* As this dependency is totally transparent to OS, evaluate
|
|
* all of them once, in the order of _CRT/_HOT/_PSV/_ACx,
|
|
* _TMP, before they are actually used.
|
|
*/
|
|
static void acpi_thermal_aml_dependency_fix(struct acpi_thermal *tz)
|
|
{
|
|
acpi_handle handle = tz->device->handle;
|
|
unsigned long long value;
|
|
int i;
|
|
|
|
acpi_evaluate_integer(handle, "_CRT", NULL, &value);
|
|
acpi_evaluate_integer(handle, "_HOT", NULL, &value);
|
|
acpi_evaluate_integer(handle, "_PSV", NULL, &value);
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
|
|
char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
|
|
acpi_status status;
|
|
|
|
status = acpi_evaluate_integer(handle, name, NULL, &value);
|
|
if (status == AE_NOT_FOUND)
|
|
break;
|
|
}
|
|
acpi_evaluate_integer(handle, "_TMP", NULL, &value);
|
|
}
|
|
|
|
/*
|
|
* The exact offset between Kelvin and degree Celsius is 273.15. However ACPI
|
|
* handles temperature values with a single decimal place. As a consequence,
|
|
* some implementations use an offset of 273.1 and others use an offset of
|
|
* 273.2. Try to find out which one is being used, to present the most
|
|
* accurate and visually appealing number.
|
|
*
|
|
* The heuristic below should work for all ACPI thermal zones which have a
|
|
* critical trip point with a value being a multiple of 0.5 degree Celsius.
|
|
*/
|
|
static void acpi_thermal_guess_offset(struct acpi_thermal *tz, long crit_temp)
|
|
{
|
|
if (crit_temp != THERMAL_TEMP_INVALID && crit_temp % 5 == 1)
|
|
tz->kelvin_offset = 273100;
|
|
else
|
|
tz->kelvin_offset = 273200;
|
|
}
|
|
|
|
static void acpi_thermal_check_fn(struct work_struct *work)
|
|
{
|
|
struct acpi_thermal *tz = container_of(work, struct acpi_thermal,
|
|
thermal_check_work);
|
|
|
|
/*
|
|
* In general, it is not sufficient to check the pending bit, because
|
|
* subsequent instances of this function may be queued after one of them
|
|
* has started running (e.g. if _TMP sleeps). Avoid bailing out if just
|
|
* one of them is running, though, because it may have done the actual
|
|
* check some time ago, so allow at least one of them to block on the
|
|
* mutex while another one is running the update.
|
|
*/
|
|
if (!refcount_dec_not_one(&tz->thermal_check_count))
|
|
return;
|
|
|
|
mutex_lock(&tz->thermal_check_lock);
|
|
|
|
thermal_zone_device_update(tz->thermal_zone, THERMAL_EVENT_UNSPECIFIED);
|
|
|
|
refcount_inc(&tz->thermal_check_count);
|
|
|
|
mutex_unlock(&tz->thermal_check_lock);
|
|
}
|
|
|
|
static void acpi_thermal_free_thermal_zone(struct acpi_thermal *tz)
|
|
{
|
|
int i;
|
|
|
|
acpi_handle_list_free(&tz->trips.passive.trip.devices);
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
|
|
acpi_handle_list_free(&tz->trips.active[i].trip.devices);
|
|
|
|
kfree(tz);
|
|
}
|
|
|
|
static int acpi_thermal_add(struct acpi_device *device)
|
|
{
|
|
struct thermal_trip trip_table[ACPI_THERMAL_MAX_NR_TRIPS] = { 0 };
|
|
struct acpi_thermal_trip *acpi_trip;
|
|
struct thermal_trip *trip;
|
|
struct acpi_thermal *tz;
|
|
int crit_temp, hot_temp;
|
|
int passive_delay = 0;
|
|
int result;
|
|
int i;
|
|
|
|
if (!device)
|
|
return -EINVAL;
|
|
|
|
tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
|
|
if (!tz)
|
|
return -ENOMEM;
|
|
|
|
tz->device = device;
|
|
strcpy(tz->name, device->pnp.bus_id);
|
|
strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
|
|
strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
|
|
device->driver_data = tz;
|
|
|
|
acpi_thermal_aml_dependency_fix(tz);
|
|
|
|
/* Get trip points [_CRT, _PSV, etc.] (required). */
|
|
acpi_thermal_get_trip_points(tz);
|
|
|
|
crit_temp = acpi_thermal_get_critical_trip(tz);
|
|
hot_temp = acpi_thermal_get_hot_trip(tz);
|
|
|
|
/* Get temperature [_TMP] (required). */
|
|
result = acpi_thermal_get_temperature(tz);
|
|
if (result)
|
|
goto free_memory;
|
|
|
|
/* Set the cooling mode [_SCP] to active cooling. */
|
|
acpi_execute_simple_method(tz->device->handle, "_SCP",
|
|
ACPI_THERMAL_MODE_ACTIVE);
|
|
|
|
/* Determine the default polling frequency [_TZP]. */
|
|
if (tzp)
|
|
tz->polling_frequency = tzp;
|
|
else
|
|
acpi_thermal_get_polling_frequency(tz);
|
|
|
|
acpi_thermal_guess_offset(tz, crit_temp);
|
|
|
|
trip = trip_table;
|
|
|
|
if (crit_temp != THERMAL_TEMP_INVALID) {
|
|
trip->type = THERMAL_TRIP_CRITICAL;
|
|
trip->temperature = acpi_thermal_temp(tz, crit_temp);
|
|
trip++;
|
|
}
|
|
|
|
if (hot_temp != THERMAL_TEMP_INVALID) {
|
|
trip->type = THERMAL_TRIP_HOT;
|
|
trip->temperature = acpi_thermal_temp(tz, hot_temp);
|
|
trip++;
|
|
}
|
|
|
|
acpi_trip = &tz->trips.passive.trip;
|
|
if (acpi_thermal_trip_valid(acpi_trip)) {
|
|
passive_delay = tz->trips.passive.delay;
|
|
|
|
trip->type = THERMAL_TRIP_PASSIVE;
|
|
trip->temperature = acpi_thermal_temp(tz, acpi_trip->temp_dk);
|
|
trip->priv = acpi_trip;
|
|
trip++;
|
|
}
|
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
|
|
acpi_trip = &tz->trips.active[i].trip;
|
|
|
|
if (!acpi_thermal_trip_valid(acpi_trip))
|
|
break;
|
|
|
|
trip->type = THERMAL_TRIP_ACTIVE;
|
|
trip->temperature = acpi_thermal_temp(tz, acpi_trip->temp_dk);
|
|
trip->priv = acpi_trip;
|
|
trip++;
|
|
}
|
|
|
|
if (trip == trip_table)
|
|
pr_warn(FW_BUG "No valid trip points!\n");
|
|
|
|
result = acpi_thermal_register_thermal_zone(tz, trip_table,
|
|
trip - trip_table,
|
|
passive_delay);
|
|
if (result)
|
|
goto free_memory;
|
|
|
|
refcount_set(&tz->thermal_check_count, 3);
|
|
mutex_init(&tz->thermal_check_lock);
|
|
INIT_WORK(&tz->thermal_check_work, acpi_thermal_check_fn);
|
|
|
|
pr_info("%s [%s] (%ld C)\n", acpi_device_name(device),
|
|
acpi_device_bid(device), deci_kelvin_to_celsius(tz->temp_dk));
|
|
|
|
result = acpi_dev_install_notify_handler(device, ACPI_DEVICE_NOTIFY,
|
|
acpi_thermal_notify, device);
|
|
if (result)
|
|
goto flush_wq;
|
|
|
|
return 0;
|
|
|
|
flush_wq:
|
|
flush_workqueue(acpi_thermal_pm_queue);
|
|
acpi_thermal_unregister_thermal_zone(tz);
|
|
free_memory:
|
|
acpi_thermal_free_thermal_zone(tz);
|
|
|
|
return result;
|
|
}
|
|
|
|
static void acpi_thermal_remove(struct acpi_device *device)
|
|
{
|
|
struct acpi_thermal *tz;
|
|
|
|
if (!device || !acpi_driver_data(device))
|
|
return;
|
|
|
|
tz = acpi_driver_data(device);
|
|
|
|
acpi_dev_remove_notify_handler(device, ACPI_DEVICE_NOTIFY,
|
|
acpi_thermal_notify);
|
|
|
|
flush_workqueue(acpi_thermal_pm_queue);
|
|
acpi_thermal_unregister_thermal_zone(tz);
|
|
acpi_thermal_free_thermal_zone(tz);
|
|
}
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
static int acpi_thermal_suspend(struct device *dev)
|
|
{
|
|
/* Make sure the previously queued thermal check work has been done */
|
|
flush_workqueue(acpi_thermal_pm_queue);
|
|
return 0;
|
|
}
|
|
|
|
static int acpi_thermal_resume(struct device *dev)
|
|
{
|
|
struct acpi_thermal *tz;
|
|
int i, j, power_state;
|
|
|
|
if (!dev)
|
|
return -EINVAL;
|
|
|
|
tz = acpi_driver_data(to_acpi_device(dev));
|
|
if (!tz)
|
|
return -EINVAL;
|
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
|
|
struct acpi_thermal_trip *acpi_trip = &tz->trips.active[i].trip;
|
|
|
|
if (!acpi_thermal_trip_valid(acpi_trip))
|
|
break;
|
|
|
|
for (j = 0; j < acpi_trip->devices.count; j++) {
|
|
acpi_bus_update_power(acpi_trip->devices.handles[j],
|
|
&power_state);
|
|
}
|
|
}
|
|
|
|
acpi_queue_thermal_check(tz);
|
|
|
|
return AE_OK;
|
|
}
|
|
#else
|
|
#define acpi_thermal_suspend NULL
|
|
#define acpi_thermal_resume NULL
|
|
#endif
|
|
static SIMPLE_DEV_PM_OPS(acpi_thermal_pm, acpi_thermal_suspend, acpi_thermal_resume);
|
|
|
|
static const struct acpi_device_id thermal_device_ids[] = {
|
|
{ACPI_THERMAL_HID, 0},
|
|
{"", 0},
|
|
};
|
|
MODULE_DEVICE_TABLE(acpi, thermal_device_ids);
|
|
|
|
static struct acpi_driver acpi_thermal_driver = {
|
|
.name = "thermal",
|
|
.class = ACPI_THERMAL_CLASS,
|
|
.ids = thermal_device_ids,
|
|
.ops = {
|
|
.add = acpi_thermal_add,
|
|
.remove = acpi_thermal_remove,
|
|
},
|
|
.drv.pm = &acpi_thermal_pm,
|
|
};
|
|
|
|
static int thermal_act(const struct dmi_system_id *d)
|
|
{
|
|
if (act == 0) {
|
|
pr_notice("%s detected: disabling all active thermal trip points\n",
|
|
d->ident);
|
|
act = -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int thermal_nocrt(const struct dmi_system_id *d)
|
|
{
|
|
pr_notice("%s detected: disabling all critical thermal trip point actions.\n",
|
|
d->ident);
|
|
crt = -1;
|
|
return 0;
|
|
}
|
|
|
|
static int thermal_tzp(const struct dmi_system_id *d)
|
|
{
|
|
if (tzp == 0) {
|
|
pr_notice("%s detected: enabling thermal zone polling\n",
|
|
d->ident);
|
|
tzp = 300; /* 300 dS = 30 Seconds */
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int thermal_psv(const struct dmi_system_id *d)
|
|
{
|
|
if (psv == 0) {
|
|
pr_notice("%s detected: disabling all passive thermal trip points\n",
|
|
d->ident);
|
|
psv = -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static const struct dmi_system_id thermal_dmi_table[] __initconst = {
|
|
/*
|
|
* Award BIOS on this AOpen makes thermal control almost worthless.
|
|
* http://bugzilla.kernel.org/show_bug.cgi?id=8842
|
|
*/
|
|
{
|
|
.callback = thermal_act,
|
|
.ident = "AOpen i915GMm-HFS",
|
|
.matches = {
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
|
|
DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
|
|
},
|
|
},
|
|
{
|
|
.callback = thermal_psv,
|
|
.ident = "AOpen i915GMm-HFS",
|
|
.matches = {
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
|
|
DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
|
|
},
|
|
},
|
|
{
|
|
.callback = thermal_tzp,
|
|
.ident = "AOpen i915GMm-HFS",
|
|
.matches = {
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
|
|
DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
|
|
},
|
|
},
|
|
{
|
|
.callback = thermal_nocrt,
|
|
.ident = "Gigabyte GA-7ZX",
|
|
.matches = {
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
|
|
DMI_MATCH(DMI_BOARD_NAME, "7ZX"),
|
|
},
|
|
},
|
|
{}
|
|
};
|
|
|
|
static int __init acpi_thermal_init(void)
|
|
{
|
|
int result;
|
|
|
|
dmi_check_system(thermal_dmi_table);
|
|
|
|
if (off) {
|
|
pr_notice("thermal control disabled\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
acpi_thermal_pm_queue = alloc_workqueue("acpi_thermal_pm",
|
|
WQ_HIGHPRI | WQ_MEM_RECLAIM, 0);
|
|
if (!acpi_thermal_pm_queue)
|
|
return -ENODEV;
|
|
|
|
result = acpi_bus_register_driver(&acpi_thermal_driver);
|
|
if (result < 0) {
|
|
destroy_workqueue(acpi_thermal_pm_queue);
|
|
return -ENODEV;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void __exit acpi_thermal_exit(void)
|
|
{
|
|
acpi_bus_unregister_driver(&acpi_thermal_driver);
|
|
destroy_workqueue(acpi_thermal_pm_queue);
|
|
}
|
|
|
|
module_init(acpi_thermal_init);
|
|
module_exit(acpi_thermal_exit);
|
|
|
|
MODULE_IMPORT_NS(ACPI_THERMAL);
|
|
MODULE_AUTHOR("Paul Diefenbaugh");
|
|
MODULE_DESCRIPTION("ACPI Thermal Zone Driver");
|
|
MODULE_LICENSE("GPL");
|