mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 19:29:37 +00:00
![Zhang Rui](/assets/img/avatar_default.png)
there are three concepts represent backlight in int3406_thermal driver. 1. the raw brightness value from native graphics driver. 2. the percentage numbers from ACPI _BCL control method. 3. the consecutive numbers represent cooling states. int3406_thermal driver 1. uses value from DDDL/DDPC as the lower/upper limit, which is consistent with ACPI _BCL control methods. 2. reads current and maximum brightness from the native graphics driver. 3. expose them to thermal sysfs I/F This patch fixes the code that switches between the raw brightness value and the cooling state, which results in bogus value in thermal sysfs I/F. Signed-off-by: Zhang Rui <rui.zhang@intel.com>
213 lines
5.4 KiB
C
213 lines
5.4 KiB
C
/*
|
|
* INT3406 thermal driver for display participant device
|
|
*
|
|
* Copyright (C) 2016, Intel Corporation
|
|
* Authors: Aaron Lu <aaron.lu@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/backlight.h>
|
|
#include <linux/thermal.h>
|
|
#include <acpi/video.h>
|
|
|
|
#define INT3406_BRIGHTNESS_LIMITS_CHANGED 0x80
|
|
|
|
struct int3406_thermal_data {
|
|
int upper_limit;
|
|
int lower_limit;
|
|
acpi_handle handle;
|
|
struct acpi_video_device_brightness *br;
|
|
struct backlight_device *raw_bd;
|
|
struct thermal_cooling_device *cooling_dev;
|
|
};
|
|
|
|
/*
|
|
* According to the ACPI spec,
|
|
* "Each brightness level is represented by a number between 0 and 100,
|
|
* and can be thought of as a percentage. For example, 50 can be 50%
|
|
* power consumption or 50% brightness, as defined by the OEM."
|
|
*
|
|
* As int3406 device uses this value to communicate with the native
|
|
* graphics driver, we make the assumption that it represents
|
|
* the percentage of brightness only
|
|
*/
|
|
#define ACPI_TO_RAW(v, d) (d->raw_bd->props.max_brightness * v / 100)
|
|
#define RAW_TO_ACPI(v, d) (v * 100 / d->raw_bd->props.max_brightness)
|
|
|
|
static int
|
|
int3406_thermal_get_max_state(struct thermal_cooling_device *cooling_dev,
|
|
unsigned long *state)
|
|
{
|
|
struct int3406_thermal_data *d = cooling_dev->devdata;
|
|
|
|
*state = d->upper_limit - d->lower_limit;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
int3406_thermal_set_cur_state(struct thermal_cooling_device *cooling_dev,
|
|
unsigned long state)
|
|
{
|
|
struct int3406_thermal_data *d = cooling_dev->devdata;
|
|
int acpi_level, raw_level;
|
|
|
|
if (state > d->upper_limit - d->lower_limit)
|
|
return -EINVAL;
|
|
|
|
acpi_level = d->br->levels[d->upper_limit - state];
|
|
|
|
raw_level = ACPI_TO_RAW(acpi_level, d);
|
|
|
|
return backlight_device_set_brightness(d->raw_bd, raw_level);
|
|
}
|
|
|
|
static int
|
|
int3406_thermal_get_cur_state(struct thermal_cooling_device *cooling_dev,
|
|
unsigned long *state)
|
|
{
|
|
struct int3406_thermal_data *d = cooling_dev->devdata;
|
|
int acpi_level;
|
|
int index;
|
|
|
|
acpi_level = RAW_TO_ACPI(d->raw_bd->props.brightness, d);
|
|
|
|
/*
|
|
* There is no 1:1 mapping between the firmware interface level
|
|
* with the raw interface level, we will have to find one that is
|
|
* right above it.
|
|
*/
|
|
for (index = d->lower_limit; index < d->upper_limit; index++) {
|
|
if (acpi_level <= d->br->levels[index])
|
|
break;
|
|
}
|
|
|
|
*state = d->upper_limit - index;
|
|
return 0;
|
|
}
|
|
|
|
static const struct thermal_cooling_device_ops video_cooling_ops = {
|
|
.get_max_state = int3406_thermal_get_max_state,
|
|
.get_cur_state = int3406_thermal_get_cur_state,
|
|
.set_cur_state = int3406_thermal_set_cur_state,
|
|
};
|
|
|
|
static int int3406_thermal_get_index(int *array, int nr, int value)
|
|
{
|
|
int i;
|
|
|
|
for (i = 2; i < nr; i++) {
|
|
if (array[i] == value)
|
|
break;
|
|
}
|
|
return i == nr ? -ENOENT : i;
|
|
}
|
|
|
|
static void int3406_thermal_get_limit(struct int3406_thermal_data *d)
|
|
{
|
|
acpi_status status;
|
|
unsigned long long lower_limit, upper_limit;
|
|
|
|
status = acpi_evaluate_integer(d->handle, "DDDL", NULL, &lower_limit);
|
|
if (ACPI_SUCCESS(status))
|
|
d->lower_limit = int3406_thermal_get_index(d->br->levels,
|
|
d->br->count, lower_limit);
|
|
|
|
status = acpi_evaluate_integer(d->handle, "DDPC", NULL, &upper_limit);
|
|
if (ACPI_SUCCESS(status))
|
|
d->upper_limit = int3406_thermal_get_index(d->br->levels,
|
|
d->br->count, upper_limit);
|
|
|
|
/* lower_limit and upper_limit should be always set */
|
|
d->lower_limit = d->lower_limit > 0 ? d->lower_limit : 2;
|
|
d->upper_limit = d->upper_limit > 0 ? d->upper_limit : d->br->count - 1;
|
|
}
|
|
|
|
static void int3406_notify(acpi_handle handle, u32 event, void *data)
|
|
{
|
|
if (event == INT3406_BRIGHTNESS_LIMITS_CHANGED)
|
|
int3406_thermal_get_limit(data);
|
|
}
|
|
|
|
static int int3406_thermal_probe(struct platform_device *pdev)
|
|
{
|
|
struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
|
|
struct int3406_thermal_data *d;
|
|
struct backlight_device *bd;
|
|
int ret;
|
|
|
|
if (!ACPI_HANDLE(&pdev->dev))
|
|
return -ENODEV;
|
|
|
|
d = devm_kzalloc(&pdev->dev, sizeof(*d), GFP_KERNEL);
|
|
if (!d)
|
|
return -ENOMEM;
|
|
d->handle = ACPI_HANDLE(&pdev->dev);
|
|
|
|
bd = backlight_device_get_by_type(BACKLIGHT_RAW);
|
|
if (!bd)
|
|
return -ENODEV;
|
|
d->raw_bd = bd;
|
|
|
|
ret = acpi_video_get_levels(ACPI_COMPANION(&pdev->dev), &d->br, NULL);
|
|
if (ret)
|
|
return ret;
|
|
|
|
int3406_thermal_get_limit(d);
|
|
|
|
d->cooling_dev = thermal_cooling_device_register(acpi_device_bid(adev),
|
|
d, &video_cooling_ops);
|
|
if (IS_ERR(d->cooling_dev))
|
|
goto err;
|
|
|
|
ret = acpi_install_notify_handler(adev->handle, ACPI_DEVICE_NOTIFY,
|
|
int3406_notify, d);
|
|
if (ret)
|
|
goto err_cdev;
|
|
|
|
platform_set_drvdata(pdev, d);
|
|
|
|
return 0;
|
|
|
|
err_cdev:
|
|
thermal_cooling_device_unregister(d->cooling_dev);
|
|
err:
|
|
kfree(d->br);
|
|
return -ENODEV;
|
|
}
|
|
|
|
static int int3406_thermal_remove(struct platform_device *pdev)
|
|
{
|
|
struct int3406_thermal_data *d = platform_get_drvdata(pdev);
|
|
|
|
thermal_cooling_device_unregister(d->cooling_dev);
|
|
kfree(d->br);
|
|
return 0;
|
|
}
|
|
|
|
static const struct acpi_device_id int3406_thermal_match[] = {
|
|
{"INT3406", 0},
|
|
{}
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(acpi, int3406_thermal_match);
|
|
|
|
static struct platform_driver int3406_thermal_driver = {
|
|
.probe = int3406_thermal_probe,
|
|
.remove = int3406_thermal_remove,
|
|
.driver = {
|
|
.name = "int3406 thermal",
|
|
.acpi_match_table = int3406_thermal_match,
|
|
},
|
|
};
|
|
|
|
module_platform_driver(int3406_thermal_driver);
|
|
|
|
MODULE_DESCRIPTION("INT3406 Thermal driver");
|
|
MODULE_LICENSE("GPL v2");
|