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 */
24 struct 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
32 struct thermal_hwmon_attr {
33 struct device_attribute attr;
34 char name[16];
35 };
36
37 /* one temperature input for each thermal zone */
38 struct 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
45 static LIST_HEAD(thermal_hwmon_list);
46
47 static DEFINE_MUTEX(thermal_hwmon_list_lock);
48
49 static ssize_t
temp_input_show(struct device * dev,struct device_attribute * attr,char * buf)50 temp_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, &temperature);
62
63 if (ret)
64 return ret;
65
66 return sprintf(buf, "%d\n", temperature);
67 }
68
69 static ssize_t
temp_crit_show(struct device * dev,struct device_attribute * attr,char * buf)70 temp_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 if (device_is_registered(&tz->device))
84 ret = tz->ops->get_crit_temp(tz, &temperature);
85 else
86 ret = -ENODEV;
87
88 mutex_unlock(&tz->lock);
89
90 if (ret)
91 return ret;
92
93 return sprintf(buf, "%d\n", temperature);
94 }
95
96
97 static struct thermal_hwmon_device *
thermal_hwmon_lookup_by_type(const struct thermal_zone_device * tz)98 thermal_hwmon_lookup_by_type(const struct thermal_zone_device *tz)
99 {
100 struct thermal_hwmon_device *hwmon;
101 char type[THERMAL_NAME_LENGTH];
102
103 mutex_lock(&thermal_hwmon_list_lock);
104 list_for_each_entry(hwmon, &thermal_hwmon_list, node) {
105 strcpy(type, tz->type);
106 strreplace(type, '-', '_');
107 if (!strcmp(hwmon->type, type)) {
108 mutex_unlock(&thermal_hwmon_list_lock);
109 return hwmon;
110 }
111 }
112 mutex_unlock(&thermal_hwmon_list_lock);
113
114 return NULL;
115 }
116
117 /* Find the temperature input matching a given thermal zone */
118 static struct thermal_hwmon_temp *
thermal_hwmon_lookup_temp(const struct thermal_hwmon_device * hwmon,const struct thermal_zone_device * tz)119 thermal_hwmon_lookup_temp(const struct thermal_hwmon_device *hwmon,
120 const struct thermal_zone_device *tz)
121 {
122 struct thermal_hwmon_temp *temp;
123
124 mutex_lock(&thermal_hwmon_list_lock);
125 list_for_each_entry(temp, &hwmon->tz_list, hwmon_node)
126 if (temp->tz == tz) {
127 mutex_unlock(&thermal_hwmon_list_lock);
128 return temp;
129 }
130 mutex_unlock(&thermal_hwmon_list_lock);
131
132 return NULL;
133 }
134
thermal_zone_crit_temp_valid(struct thermal_zone_device * tz)135 static bool thermal_zone_crit_temp_valid(struct thermal_zone_device *tz)
136 {
137 int temp;
138 return tz->ops->get_crit_temp && !tz->ops->get_crit_temp(tz, &temp);
139 }
140
thermal_add_hwmon_sysfs(struct thermal_zone_device * tz)141 int thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
142 {
143 struct thermal_hwmon_device *hwmon;
144 struct thermal_hwmon_temp *temp;
145 int new_hwmon_device = 1;
146 int result;
147
148 hwmon = thermal_hwmon_lookup_by_type(tz);
149 if (hwmon) {
150 new_hwmon_device = 0;
151 goto register_sys_interface;
152 }
153
154 hwmon = kzalloc(sizeof(*hwmon), GFP_KERNEL);
155 if (!hwmon)
156 return -ENOMEM;
157
158 INIT_LIST_HEAD(&hwmon->tz_list);
159 strscpy(hwmon->type, tz->type, THERMAL_NAME_LENGTH);
160 strreplace(hwmon->type, '-', '_');
161 hwmon->device = hwmon_device_register_for_thermal(&tz->device,
162 hwmon->type, hwmon);
163 if (IS_ERR(hwmon->device)) {
164 result = PTR_ERR(hwmon->device);
165 goto free_mem;
166 }
167
168 register_sys_interface:
169 temp = kzalloc(sizeof(*temp), GFP_KERNEL);
170 if (!temp) {
171 result = -ENOMEM;
172 goto unregister_name;
173 }
174
175 temp->tz = tz;
176 hwmon->count++;
177
178 snprintf(temp->temp_input.name, sizeof(temp->temp_input.name),
179 "temp%d_input", hwmon->count);
180 temp->temp_input.attr.attr.name = temp->temp_input.name;
181 temp->temp_input.attr.attr.mode = 0444;
182 temp->temp_input.attr.show = temp_input_show;
183 sysfs_attr_init(&temp->temp_input.attr.attr);
184 result = device_create_file(hwmon->device, &temp->temp_input.attr);
185 if (result)
186 goto free_temp_mem;
187
188 if (thermal_zone_crit_temp_valid(tz)) {
189 snprintf(temp->temp_crit.name,
190 sizeof(temp->temp_crit.name),
191 "temp%d_crit", hwmon->count);
192 temp->temp_crit.attr.attr.name = temp->temp_crit.name;
193 temp->temp_crit.attr.attr.mode = 0444;
194 temp->temp_crit.attr.show = temp_crit_show;
195 sysfs_attr_init(&temp->temp_crit.attr.attr);
196 result = device_create_file(hwmon->device,
197 &temp->temp_crit.attr);
198 if (result)
199 goto unregister_input;
200 }
201
202 mutex_lock(&thermal_hwmon_list_lock);
203 if (new_hwmon_device)
204 list_add_tail(&hwmon->node, &thermal_hwmon_list);
205 list_add_tail(&temp->hwmon_node, &hwmon->tz_list);
206 mutex_unlock(&thermal_hwmon_list_lock);
207
208 return 0;
209
210 unregister_input:
211 device_remove_file(hwmon->device, &temp->temp_input.attr);
212 free_temp_mem:
213 kfree(temp);
214 unregister_name:
215 if (new_hwmon_device)
216 hwmon_device_unregister(hwmon->device);
217 free_mem:
218 kfree(hwmon);
219
220 return result;
221 }
222 EXPORT_SYMBOL_GPL(thermal_add_hwmon_sysfs);
223
thermal_remove_hwmon_sysfs(struct thermal_zone_device * tz)224 void thermal_remove_hwmon_sysfs(struct thermal_zone_device *tz)
225 {
226 struct thermal_hwmon_device *hwmon;
227 struct thermal_hwmon_temp *temp;
228
229 hwmon = thermal_hwmon_lookup_by_type(tz);
230 if (unlikely(!hwmon)) {
231 /* Should never happen... */
232 dev_dbg(&tz->device, "hwmon device lookup failed!\n");
233 return;
234 }
235
236 temp = thermal_hwmon_lookup_temp(hwmon, tz);
237 if (unlikely(!temp)) {
238 /* Should never happen... */
239 dev_dbg(&tz->device, "temperature input lookup failed!\n");
240 return;
241 }
242
243 device_remove_file(hwmon->device, &temp->temp_input.attr);
244 if (thermal_zone_crit_temp_valid(tz))
245 device_remove_file(hwmon->device, &temp->temp_crit.attr);
246
247 mutex_lock(&thermal_hwmon_list_lock);
248 list_del(&temp->hwmon_node);
249 kfree(temp);
250 if (!list_empty(&hwmon->tz_list)) {
251 mutex_unlock(&thermal_hwmon_list_lock);
252 return;
253 }
254 list_del(&hwmon->node);
255 mutex_unlock(&thermal_hwmon_list_lock);
256
257 hwmon_device_unregister(hwmon->device);
258 kfree(hwmon);
259 }
260 EXPORT_SYMBOL_GPL(thermal_remove_hwmon_sysfs);
261
devm_thermal_hwmon_release(struct device * dev,void * res)262 static void devm_thermal_hwmon_release(struct device *dev, void *res)
263 {
264 thermal_remove_hwmon_sysfs(*(struct thermal_zone_device **)res);
265 }
266
devm_thermal_add_hwmon_sysfs(struct device * dev,struct thermal_zone_device * tz)267 int devm_thermal_add_hwmon_sysfs(struct device *dev, struct thermal_zone_device *tz)
268 {
269 struct thermal_zone_device **ptr;
270 int ret;
271
272 ptr = devres_alloc(devm_thermal_hwmon_release, sizeof(*ptr),
273 GFP_KERNEL);
274 if (!ptr) {
275 dev_warn(dev, "Failed to allocate device resource data\n");
276 return -ENOMEM;
277 }
278
279 ret = thermal_add_hwmon_sysfs(tz);
280 if (ret) {
281 dev_warn(dev, "Failed to add hwmon sysfs attributes\n");
282 devres_free(ptr);
283 return ret;
284 }
285
286 *ptr = tz;
287 devres_add(dev, ptr);
288
289 return ret;
290 }
291 EXPORT_SYMBOL_GPL(devm_thermal_add_hwmon_sysfs);
292
293 MODULE_IMPORT_NS(HWMON_THERMAL);
294