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