1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * OMAP thermal driver interface
4  *
5  * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/
6  * Contact:
7  *   Eduardo Valentin <eduardo.valentin@ti.com>
8  */
9 
10 #include <linux/device.h>
11 #include <linux/err.h>
12 #include <linux/mutex.h>
13 #include <linux/gfp.h>
14 #include <linux/kernel.h>
15 #include <linux/workqueue.h>
16 #include <linux/thermal.h>
17 #include <linux/cpufreq.h>
18 #include <linux/cpumask.h>
19 #include <linux/cpu_cooling.h>
20 #include <linux/of.h>
21 
22 #include "ti-thermal.h"
23 #include "ti-bandgap.h"
24 #include "../thermal_hwmon.h"
25 
26 #define TI_BANDGAP_UPDATE_INTERVAL_MS 250
27 
28 /* common data structures */
29 struct ti_thermal_data {
30 	struct cpufreq_policy *policy;
31 	struct thermal_zone_device *ti_thermal;
32 	struct thermal_zone_device *pcb_tz;
33 	struct thermal_cooling_device *cool_dev;
34 	struct ti_bandgap *bgp;
35 	enum thermal_device_mode mode;
36 	struct work_struct thermal_wq;
37 	int sensor_id;
38 	bool our_zone;
39 };
40 
41 static void ti_thermal_work(struct work_struct *work)
42 {
43 	struct ti_thermal_data *data = container_of(work,
44 					struct ti_thermal_data, thermal_wq);
45 
46 	thermal_zone_device_update(data->ti_thermal, THERMAL_EVENT_UNSPECIFIED);
47 
48 	dev_dbg(data->bgp->dev, "updated thermal zone %s\n",
49 		thermal_zone_device_type(data->ti_thermal));
50 }
51 
52 /**
53  * ti_thermal_hotspot_temperature - returns sensor extrapolated temperature
54  * @t:	omap sensor temperature
55  * @s:	omap sensor slope value
56  * @c:	omap sensor const value
57  */
58 static inline int ti_thermal_hotspot_temperature(int t, int s, int c)
59 {
60 	int delta = t * s / 1000 + c;
61 
62 	if (delta < 0)
63 		delta = 0;
64 
65 	return t + delta;
66 }
67 
68 /* thermal zone ops */
69 /* Get temperature callback function for thermal zone */
70 static inline int __ti_thermal_get_temp(struct thermal_zone_device *tz, int *temp)
71 {
72 	struct thermal_zone_device *pcb_tz = NULL;
73 	struct ti_thermal_data *data = thermal_zone_device_priv(tz);
74 	struct ti_bandgap *bgp;
75 	const struct ti_temp_sensor *s;
76 	int ret, tmp, slope, constant;
77 	int pcb_temp;
78 
79 	if (!data)
80 		return 0;
81 
82 	bgp = data->bgp;
83 	s = &bgp->conf->sensors[data->sensor_id];
84 
85 	ret = ti_bandgap_read_temperature(bgp, data->sensor_id, &tmp);
86 	if (ret)
87 		return ret;
88 
89 	/* Default constants */
90 	slope = thermal_zone_get_slope(tz);
91 	constant = thermal_zone_get_offset(tz);
92 
93 	pcb_tz = data->pcb_tz;
94 	/* In case pcb zone is available, use the extrapolation rule with it */
95 	if (!IS_ERR(pcb_tz)) {
96 		ret = thermal_zone_get_temp(pcb_tz, &pcb_temp);
97 		if (!ret) {
98 			tmp -= pcb_temp; /* got a valid PCB temp */
99 			slope = s->slope_pcb;
100 			constant = s->constant_pcb;
101 		} else {
102 			dev_err(bgp->dev,
103 				"Failed to read PCB state. Using defaults\n");
104 			ret = 0;
105 		}
106 	}
107 	*temp = ti_thermal_hotspot_temperature(tmp, slope, constant);
108 
109 	return ret;
110 }
111 
112 static int __ti_thermal_get_trend(struct thermal_zone_device *tz,
113 				  struct thermal_trip *trip, enum thermal_trend *trend)
114 {
115 	struct ti_thermal_data *data = thermal_zone_device_priv(tz);
116 	struct ti_bandgap *bgp;
117 	int id, tr, ret = 0;
118 
119 	bgp = data->bgp;
120 	id = data->sensor_id;
121 
122 	ret = ti_bandgap_get_trend(bgp, id, &tr);
123 	if (ret)
124 		return ret;
125 
126 	if (tr > 0)
127 		*trend = THERMAL_TREND_RAISING;
128 	else if (tr < 0)
129 		*trend = THERMAL_TREND_DROPPING;
130 	else
131 		*trend = THERMAL_TREND_STABLE;
132 
133 	return 0;
134 }
135 
136 static const struct thermal_zone_device_ops ti_of_thermal_ops = {
137 	.get_temp = __ti_thermal_get_temp,
138 	.get_trend = __ti_thermal_get_trend,
139 };
140 
141 static struct ti_thermal_data
142 *ti_thermal_build_data(struct ti_bandgap *bgp, int id)
143 {
144 	struct ti_thermal_data *data;
145 
146 	data = devm_kzalloc(bgp->dev, sizeof(*data), GFP_KERNEL);
147 	if (!data) {
148 		dev_err(bgp->dev, "kzalloc fail\n");
149 		return NULL;
150 	}
151 	data->sensor_id = id;
152 	data->bgp = bgp;
153 	data->mode = THERMAL_DEVICE_ENABLED;
154 	/* pcb_tz will be either valid or PTR_ERR() */
155 	data->pcb_tz = thermal_zone_get_zone_by_name("pcb");
156 	INIT_WORK(&data->thermal_wq, ti_thermal_work);
157 
158 	return data;
159 }
160 
161 int ti_thermal_expose_sensor(struct ti_bandgap *bgp, int id,
162 			     char *domain)
163 {
164 	struct ti_thermal_data *data;
165 
166 	data = ti_bandgap_get_sensor_data(bgp, id);
167 
168 	if (IS_ERR_OR_NULL(data))
169 		data = ti_thermal_build_data(bgp, id);
170 
171 	if (!data)
172 		return -EINVAL;
173 
174 	/* in case this is specified by DT */
175 	data->ti_thermal = devm_thermal_of_zone_register(bgp->dev, id,
176 					data, &ti_of_thermal_ops);
177 	if (IS_ERR(data->ti_thermal)) {
178 		dev_err(bgp->dev, "thermal zone device is NULL\n");
179 		return PTR_ERR(data->ti_thermal);
180 	}
181 
182 	ti_bandgap_set_sensor_data(bgp, id, data);
183 	ti_bandgap_write_update_interval(bgp, data->sensor_id,
184 					 TI_BANDGAP_UPDATE_INTERVAL_MS);
185 
186 	devm_thermal_add_hwmon_sysfs(bgp->dev, data->ti_thermal);
187 
188 	return 0;
189 }
190 
191 int ti_thermal_remove_sensor(struct ti_bandgap *bgp, int id)
192 {
193 	struct ti_thermal_data *data;
194 
195 	data = ti_bandgap_get_sensor_data(bgp, id);
196 
197 	if (!IS_ERR_OR_NULL(data) && data->ti_thermal) {
198 		if (data->our_zone)
199 			thermal_zone_device_unregister(data->ti_thermal);
200 	}
201 
202 	return 0;
203 }
204 
205 int ti_thermal_report_sensor_temperature(struct ti_bandgap *bgp, int id)
206 {
207 	struct ti_thermal_data *data;
208 
209 	data = ti_bandgap_get_sensor_data(bgp, id);
210 
211 	schedule_work(&data->thermal_wq);
212 
213 	return 0;
214 }
215 
216 int ti_thermal_register_cpu_cooling(struct ti_bandgap *bgp, int id)
217 {
218 	struct ti_thermal_data *data;
219 	struct device_node *np = bgp->dev->of_node;
220 
221 	/*
222 	 * We are assuming here that if one deploys the zone
223 	 * using DT, then it must be aware that the cooling device
224 	 * loading has to happen via cpufreq driver.
225 	 */
226 	if (of_property_present(np, "#thermal-sensor-cells"))
227 		return 0;
228 
229 	data = ti_bandgap_get_sensor_data(bgp, id);
230 	if (!data || IS_ERR(data))
231 		data = ti_thermal_build_data(bgp, id);
232 
233 	if (!data)
234 		return -EINVAL;
235 
236 	data->policy = cpufreq_cpu_get(0);
237 	if (!data->policy) {
238 		pr_debug("%s: CPUFreq policy not found\n", __func__);
239 		return -EPROBE_DEFER;
240 	}
241 
242 	/* Register cooling device */
243 	data->cool_dev = cpufreq_cooling_register(data->policy);
244 	if (IS_ERR(data->cool_dev)) {
245 		int ret = PTR_ERR(data->cool_dev);
246 		dev_err(bgp->dev, "Failed to register cpu cooling device %d\n",
247 			ret);
248 		cpufreq_cpu_put(data->policy);
249 
250 		return ret;
251 	}
252 	ti_bandgap_set_sensor_data(bgp, id, data);
253 
254 	return 0;
255 }
256 
257 int ti_thermal_unregister_cpu_cooling(struct ti_bandgap *bgp, int id)
258 {
259 	struct ti_thermal_data *data;
260 
261 	data = ti_bandgap_get_sensor_data(bgp, id);
262 
263 	if (!IS_ERR_OR_NULL(data)) {
264 		cpufreq_cooling_unregister(data->cool_dev);
265 		if (data->policy)
266 			cpufreq_cpu_put(data->policy);
267 	}
268 
269 	return 0;
270 }
271