forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
219 lines
5.3 KiB
219 lines
5.3 KiB
// SPDX-License-Identifier: ISC |
|
/* |
|
* Copyright (c) 2014-2015 Qualcomm Atheros, Inc. |
|
*/ |
|
|
|
#include <linux/device.h> |
|
#include <linux/sysfs.h> |
|
#include <linux/thermal.h> |
|
#include <linux/hwmon.h> |
|
#include <linux/hwmon-sysfs.h> |
|
#include "core.h" |
|
#include "debug.h" |
|
#include "wmi-ops.h" |
|
|
|
static int |
|
ath10k_thermal_get_max_throttle_state(struct thermal_cooling_device *cdev, |
|
unsigned long *state) |
|
{ |
|
*state = ATH10K_THERMAL_THROTTLE_MAX; |
|
|
|
return 0; |
|
} |
|
|
|
static int |
|
ath10k_thermal_get_cur_throttle_state(struct thermal_cooling_device *cdev, |
|
unsigned long *state) |
|
{ |
|
struct ath10k *ar = cdev->devdata; |
|
|
|
mutex_lock(&ar->conf_mutex); |
|
*state = ar->thermal.throttle_state; |
|
mutex_unlock(&ar->conf_mutex); |
|
|
|
return 0; |
|
} |
|
|
|
static int |
|
ath10k_thermal_set_cur_throttle_state(struct thermal_cooling_device *cdev, |
|
unsigned long throttle_state) |
|
{ |
|
struct ath10k *ar = cdev->devdata; |
|
|
|
if (throttle_state > ATH10K_THERMAL_THROTTLE_MAX) { |
|
ath10k_warn(ar, "throttle state %ld is exceeding the limit %d\n", |
|
throttle_state, ATH10K_THERMAL_THROTTLE_MAX); |
|
return -EINVAL; |
|
} |
|
mutex_lock(&ar->conf_mutex); |
|
ar->thermal.throttle_state = throttle_state; |
|
ath10k_thermal_set_throttling(ar); |
|
mutex_unlock(&ar->conf_mutex); |
|
return 0; |
|
} |
|
|
|
static const struct thermal_cooling_device_ops ath10k_thermal_ops = { |
|
.get_max_state = ath10k_thermal_get_max_throttle_state, |
|
.get_cur_state = ath10k_thermal_get_cur_throttle_state, |
|
.set_cur_state = ath10k_thermal_set_cur_throttle_state, |
|
}; |
|
|
|
static ssize_t ath10k_thermal_show_temp(struct device *dev, |
|
struct device_attribute *attr, |
|
char *buf) |
|
{ |
|
struct ath10k *ar = dev_get_drvdata(dev); |
|
int ret, temperature; |
|
unsigned long time_left; |
|
|
|
mutex_lock(&ar->conf_mutex); |
|
|
|
/* Can't get temperature when the card is off */ |
|
if (ar->state != ATH10K_STATE_ON) { |
|
ret = -ENETDOWN; |
|
goto out; |
|
} |
|
|
|
reinit_completion(&ar->thermal.wmi_sync); |
|
ret = ath10k_wmi_pdev_get_temperature(ar); |
|
if (ret) { |
|
ath10k_warn(ar, "failed to read temperature %d\n", ret); |
|
goto out; |
|
} |
|
|
|
if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags)) { |
|
ret = -ESHUTDOWN; |
|
goto out; |
|
} |
|
|
|
time_left = wait_for_completion_timeout(&ar->thermal.wmi_sync, |
|
ATH10K_THERMAL_SYNC_TIMEOUT_HZ); |
|
if (!time_left) { |
|
ath10k_warn(ar, "failed to synchronize thermal read\n"); |
|
ret = -ETIMEDOUT; |
|
goto out; |
|
} |
|
|
|
spin_lock_bh(&ar->data_lock); |
|
temperature = ar->thermal.temperature; |
|
spin_unlock_bh(&ar->data_lock); |
|
|
|
/* display in millidegree celcius */ |
|
ret = snprintf(buf, PAGE_SIZE, "%d\n", temperature * 1000); |
|
out: |
|
mutex_unlock(&ar->conf_mutex); |
|
return ret; |
|
} |
|
|
|
void ath10k_thermal_event_temperature(struct ath10k *ar, int temperature) |
|
{ |
|
spin_lock_bh(&ar->data_lock); |
|
ar->thermal.temperature = temperature; |
|
spin_unlock_bh(&ar->data_lock); |
|
complete(&ar->thermal.wmi_sync); |
|
} |
|
|
|
static SENSOR_DEVICE_ATTR(temp1_input, 0444, ath10k_thermal_show_temp, |
|
NULL, 0); |
|
|
|
static struct attribute *ath10k_hwmon_attrs[] = { |
|
&sensor_dev_attr_temp1_input.dev_attr.attr, |
|
NULL, |
|
}; |
|
ATTRIBUTE_GROUPS(ath10k_hwmon); |
|
|
|
void ath10k_thermal_set_throttling(struct ath10k *ar) |
|
{ |
|
u32 period, duration, enabled; |
|
int ret; |
|
|
|
lockdep_assert_held(&ar->conf_mutex); |
|
|
|
if (!test_bit(WMI_SERVICE_THERM_THROT, ar->wmi.svc_map)) |
|
return; |
|
|
|
if (!ar->wmi.ops->gen_pdev_set_quiet_mode) |
|
return; |
|
|
|
if (ar->state != ATH10K_STATE_ON) |
|
return; |
|
|
|
period = ar->thermal.quiet_period; |
|
duration = (period * ar->thermal.throttle_state) / 100; |
|
enabled = duration ? 1 : 0; |
|
|
|
ret = ath10k_wmi_pdev_set_quiet_mode(ar, period, duration, |
|
ATH10K_QUIET_START_OFFSET, |
|
enabled); |
|
if (ret) { |
|
ath10k_warn(ar, "failed to set quiet mode period %u duarion %u enabled %u ret %d\n", |
|
period, duration, enabled, ret); |
|
} |
|
} |
|
|
|
int ath10k_thermal_register(struct ath10k *ar) |
|
{ |
|
struct thermal_cooling_device *cdev; |
|
struct device *hwmon_dev; |
|
int ret; |
|
|
|
if (!test_bit(WMI_SERVICE_THERM_THROT, ar->wmi.svc_map)) |
|
return 0; |
|
|
|
cdev = thermal_cooling_device_register("ath10k_thermal", ar, |
|
&ath10k_thermal_ops); |
|
|
|
if (IS_ERR(cdev)) { |
|
ath10k_err(ar, "failed to setup thermal device result: %ld\n", |
|
PTR_ERR(cdev)); |
|
return -EINVAL; |
|
} |
|
|
|
ret = sysfs_create_link(&ar->dev->kobj, &cdev->device.kobj, |
|
"cooling_device"); |
|
if (ret) { |
|
ath10k_err(ar, "failed to create cooling device symlink\n"); |
|
goto err_cooling_destroy; |
|
} |
|
|
|
ar->thermal.cdev = cdev; |
|
ar->thermal.quiet_period = ATH10K_QUIET_PERIOD_DEFAULT; |
|
|
|
/* Do not register hwmon device when temperature reading is not |
|
* supported by firmware |
|
*/ |
|
if (!(ar->wmi.ops->gen_pdev_get_temperature)) |
|
return 0; |
|
|
|
/* Avoid linking error on devm_hwmon_device_register_with_groups, I |
|
* guess linux/hwmon.h is missing proper stubs. |
|
*/ |
|
if (!IS_REACHABLE(CONFIG_HWMON)) |
|
return 0; |
|
|
|
hwmon_dev = devm_hwmon_device_register_with_groups(ar->dev, |
|
"ath10k_hwmon", ar, |
|
ath10k_hwmon_groups); |
|
if (IS_ERR(hwmon_dev)) { |
|
ath10k_err(ar, "failed to register hwmon device: %ld\n", |
|
PTR_ERR(hwmon_dev)); |
|
ret = -EINVAL; |
|
goto err_remove_link; |
|
} |
|
return 0; |
|
|
|
err_remove_link: |
|
sysfs_remove_link(&ar->dev->kobj, "cooling_device"); |
|
err_cooling_destroy: |
|
thermal_cooling_device_unregister(cdev); |
|
return ret; |
|
} |
|
|
|
void ath10k_thermal_unregister(struct ath10k *ar) |
|
{ |
|
if (!test_bit(WMI_SERVICE_THERM_THROT, ar->wmi.svc_map)) |
|
return; |
|
|
|
sysfs_remove_link(&ar->dev->kobj, "cooling_device"); |
|
thermal_cooling_device_unregister(ar->thermal.cdev); |
|
}
|
|
|