1// SPDX-License-Identifier: GPL-2.0
2/*
3 * thermal_hwmon.c - Generic Thermal Management hwmon support.
4 *
5 * Code based on Intel thermal_core.c. Copyrights of the original code:
6 * Copyright (C) 2008 Intel Corp
7 * Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com>
8 * Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com>
9 *
10 * Copyright (C) 2013 Texas Instruments
11 * Copyright (C) 2013 Eduardo Valentin <eduardo.valentin@ti.com>
12 */
13#include <linux/err.h>
14#include <linux/export.h>
15#include <linux/hwmon.h>
16#include <linux/slab.h>
17#include <linux/thermal.h>
18
19#include "thermal_hwmon.h"
20#include "thermal_core.h"
21
22/* hwmon sys I/F */
23/* thermal zone devices with the same type share one hwmon device */
24struct thermal_hwmon_device {
25 char type[THERMAL_NAME_LENGTH];
26 struct device *device;
27 int count;
28 struct list_head tz_list;
29 struct list_head node;
30};
31
32struct thermal_hwmon_attr {
33 struct device_attribute attr;
34 char name[16];
35};
36
37/* one temperature input for each thermal zone */
38struct thermal_hwmon_temp {
39 struct list_head hwmon_node;
40 struct thermal_zone_device *tz;
41 struct thermal_hwmon_attr temp_input; /* hwmon sys attr */
42 struct thermal_hwmon_attr temp_crit; /* hwmon sys attr */
43};
44
45static LIST_HEAD(thermal_hwmon_list);
46
47static DEFINE_MUTEX(thermal_hwmon_list_lock);
48
49static ssize_t
50temp_input_show(struct device *dev, struct device_attribute *attr, char *buf)
51{
52 int temperature;
53 int ret;
54 struct thermal_hwmon_attr *hwmon_attr
55 = container_of(attr, struct thermal_hwmon_attr, attr);
56 struct thermal_hwmon_temp *temp
57 = container_of(hwmon_attr, struct thermal_hwmon_temp,
58 temp_input);
59 struct thermal_zone_device *tz = temp->tz;
60
61 ret = thermal_zone_get_temp(tz, temp: &temperature);
62
63 if (ret)
64 return ret;
65
66 return sprintf(buf, fmt: "%d\n", temperature);
67}
68
69static ssize_t
70temp_crit_show(struct device *dev, struct device_attribute *attr, char *buf)
71{
72 struct thermal_hwmon_attr *hwmon_attr
73 = container_of(attr, struct thermal_hwmon_attr, attr);
74 struct thermal_hwmon_temp *temp
75 = container_of(hwmon_attr, struct thermal_hwmon_temp,
76 temp_crit);
77 struct thermal_zone_device *tz = temp->tz;
78 int temperature;
79 int ret;
80
81 mutex_lock(&tz->lock);
82
83 ret = tz->ops.get_crit_temp(tz, &temperature);
84
85 mutex_unlock(lock: &tz->lock);
86
87 if (ret)
88 return ret;
89
90 return sprintf(buf, fmt: "%d\n", temperature);
91}
92
93
94static struct thermal_hwmon_device *
95thermal_hwmon_lookup_by_type(const struct thermal_zone_device *tz)
96{
97 struct thermal_hwmon_device *hwmon;
98 char type[THERMAL_NAME_LENGTH];
99
100 mutex_lock(&thermal_hwmon_list_lock);
101 list_for_each_entry(hwmon, &thermal_hwmon_list, node) {
102 strcpy(p: type, q: tz->type);
103 strreplace(str: type, old: '-', new: '_');
104 if (!strcmp(hwmon->type, type)) {
105 mutex_unlock(lock: &thermal_hwmon_list_lock);
106 return hwmon;
107 }
108 }
109 mutex_unlock(lock: &thermal_hwmon_list_lock);
110
111 return NULL;
112}
113
114/* Find the temperature input matching a given thermal zone */
115static struct thermal_hwmon_temp *
116thermal_hwmon_lookup_temp(const struct thermal_hwmon_device *hwmon,
117 const struct thermal_zone_device *tz)
118{
119 struct thermal_hwmon_temp *temp;
120
121 mutex_lock(&thermal_hwmon_list_lock);
122 list_for_each_entry(temp, &hwmon->tz_list, hwmon_node)
123 if (temp->tz == tz) {
124 mutex_unlock(lock: &thermal_hwmon_list_lock);
125 return temp;
126 }
127 mutex_unlock(lock: &thermal_hwmon_list_lock);
128
129 return NULL;
130}
131
132static bool thermal_zone_crit_temp_valid(struct thermal_zone_device *tz)
133{
134 int temp;
135 return tz->ops.get_crit_temp && !tz->ops.get_crit_temp(tz, &temp);
136}
137
138int thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
139{
140 struct thermal_hwmon_device *hwmon;
141 struct thermal_hwmon_temp *temp;
142 int new_hwmon_device = 1;
143 int result;
144
145 hwmon = thermal_hwmon_lookup_by_type(tz);
146 if (hwmon) {
147 new_hwmon_device = 0;
148 goto register_sys_interface;
149 }
150
151 hwmon = kzalloc(size: sizeof(*hwmon), GFP_KERNEL);
152 if (!hwmon)
153 return -ENOMEM;
154
155 INIT_LIST_HEAD(list: &hwmon->tz_list);
156 strscpy(hwmon->type, tz->type, THERMAL_NAME_LENGTH);
157 strreplace(str: hwmon->type, old: '-', new: '_');
158 hwmon->device = hwmon_device_register_for_thermal(dev: &tz->device,
159 name: hwmon->type, drvdata: hwmon);
160 if (IS_ERR(ptr: hwmon->device)) {
161 result = PTR_ERR(ptr: hwmon->device);
162 goto free_mem;
163 }
164
165 register_sys_interface:
166 temp = kzalloc(size: sizeof(*temp), GFP_KERNEL);
167 if (!temp) {
168 result = -ENOMEM;
169 goto unregister_name;
170 }
171
172 temp->tz = tz;
173 hwmon->count++;
174
175 snprintf(buf: temp->temp_input.name, size: sizeof(temp->temp_input.name),
176 fmt: "temp%d_input", hwmon->count);
177 temp->temp_input.attr.attr.name = temp->temp_input.name;
178 temp->temp_input.attr.attr.mode = 0444;
179 temp->temp_input.attr.show = temp_input_show;
180 sysfs_attr_init(&temp->temp_input.attr.attr);
181 result = device_create_file(device: hwmon->device, entry: &temp->temp_input.attr);
182 if (result)
183 goto free_temp_mem;
184
185 if (thermal_zone_crit_temp_valid(tz)) {
186 snprintf(buf: temp->temp_crit.name,
187 size: sizeof(temp->temp_crit.name),
188 fmt: "temp%d_crit", hwmon->count);
189 temp->temp_crit.attr.attr.name = temp->temp_crit.name;
190 temp->temp_crit.attr.attr.mode = 0444;
191 temp->temp_crit.attr.show = temp_crit_show;
192 sysfs_attr_init(&temp->temp_crit.attr.attr);
193 result = device_create_file(device: hwmon->device,
194 entry: &temp->temp_crit.attr);
195 if (result)
196 goto unregister_input;
197 }
198
199 mutex_lock(&thermal_hwmon_list_lock);
200 if (new_hwmon_device)
201 list_add_tail(new: &hwmon->node, head: &thermal_hwmon_list);
202 list_add_tail(new: &temp->hwmon_node, head: &hwmon->tz_list);
203 mutex_unlock(lock: &thermal_hwmon_list_lock);
204
205 return 0;
206
207 unregister_input:
208 device_remove_file(dev: hwmon->device, attr: &temp->temp_input.attr);
209 free_temp_mem:
210 kfree(objp: temp);
211 unregister_name:
212 if (new_hwmon_device)
213 hwmon_device_unregister(dev: hwmon->device);
214 free_mem:
215 kfree(objp: hwmon);
216
217 return result;
218}
219EXPORT_SYMBOL_GPL(thermal_add_hwmon_sysfs);
220
221void thermal_remove_hwmon_sysfs(struct thermal_zone_device *tz)
222{
223 struct thermal_hwmon_device *hwmon;
224 struct thermal_hwmon_temp *temp;
225
226 hwmon = thermal_hwmon_lookup_by_type(tz);
227 if (unlikely(!hwmon)) {
228 /* Should never happen... */
229 dev_dbg(&tz->device, "hwmon device lookup failed!\n");
230 return;
231 }
232
233 temp = thermal_hwmon_lookup_temp(hwmon, tz);
234 if (unlikely(!temp)) {
235 /* Should never happen... */
236 dev_dbg(&tz->device, "temperature input lookup failed!\n");
237 return;
238 }
239
240 device_remove_file(dev: hwmon->device, attr: &temp->temp_input.attr);
241 if (thermal_zone_crit_temp_valid(tz))
242 device_remove_file(dev: hwmon->device, attr: &temp->temp_crit.attr);
243
244 mutex_lock(&thermal_hwmon_list_lock);
245 list_del(entry: &temp->hwmon_node);
246 kfree(objp: temp);
247 if (!list_empty(head: &hwmon->tz_list)) {
248 mutex_unlock(lock: &thermal_hwmon_list_lock);
249 return;
250 }
251 list_del(entry: &hwmon->node);
252 mutex_unlock(lock: &thermal_hwmon_list_lock);
253
254 hwmon_device_unregister(dev: hwmon->device);
255 kfree(objp: hwmon);
256}
257EXPORT_SYMBOL_GPL(thermal_remove_hwmon_sysfs);
258
259static void devm_thermal_hwmon_release(struct device *dev, void *res)
260{
261 thermal_remove_hwmon_sysfs(*(struct thermal_zone_device **)res);
262}
263
264int devm_thermal_add_hwmon_sysfs(struct device *dev, struct thermal_zone_device *tz)
265{
266 struct thermal_zone_device **ptr;
267 int ret;
268
269 ptr = devres_alloc(devm_thermal_hwmon_release, sizeof(*ptr),
270 GFP_KERNEL);
271 if (!ptr) {
272 dev_warn(dev, "Failed to allocate device resource data\n");
273 return -ENOMEM;
274 }
275
276 ret = thermal_add_hwmon_sysfs(tz);
277 if (ret) {
278 dev_warn(dev, "Failed to add hwmon sysfs attributes\n");
279 devres_free(res: ptr);
280 return ret;
281 }
282
283 *ptr = tz;
284 devres_add(dev, res: ptr);
285
286 return ret;
287}
288EXPORT_SYMBOL_GPL(devm_thermal_add_hwmon_sysfs);
289
290MODULE_IMPORT_NS(HWMON_THERMAL);
291

source code of linux/drivers/thermal/thermal_hwmon.c