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 const struct thermal_trip *trip, 114 enum thermal_trend *trend) 115 { 116 struct ti_thermal_data *data = thermal_zone_device_priv(tz); 117 struct ti_bandgap *bgp; 118 int id, tr, ret = 0; 119 120 bgp = data->bgp; 121 id = data->sensor_id; 122 123 ret = ti_bandgap_get_trend(bgp, id, &tr); 124 if (ret) 125 return ret; 126 127 if (tr > 0) 128 *trend = THERMAL_TREND_RAISING; 129 else if (tr < 0) 130 *trend = THERMAL_TREND_DROPPING; 131 else 132 *trend = THERMAL_TREND_STABLE; 133 134 return 0; 135 } 136 137 static const struct thermal_zone_device_ops ti_of_thermal_ops = { 138 .get_temp = __ti_thermal_get_temp, 139 .get_trend = __ti_thermal_get_trend, 140 }; 141 142 static struct ti_thermal_data 143 *ti_thermal_build_data(struct ti_bandgap *bgp, int id) 144 { 145 struct ti_thermal_data *data; 146 147 data = devm_kzalloc(bgp->dev, sizeof(*data), GFP_KERNEL); 148 if (!data) { 149 dev_err(bgp->dev, "kzalloc fail\n"); 150 return NULL; 151 } 152 data->sensor_id = id; 153 data->bgp = bgp; 154 data->mode = THERMAL_DEVICE_ENABLED; 155 /* pcb_tz will be either valid or PTR_ERR() */ 156 data->pcb_tz = thermal_zone_get_zone_by_name("pcb"); 157 INIT_WORK(&data->thermal_wq, ti_thermal_work); 158 159 return data; 160 } 161 162 int ti_thermal_expose_sensor(struct ti_bandgap *bgp, int id, 163 char *domain) 164 { 165 struct ti_thermal_data *data; 166 167 data = ti_bandgap_get_sensor_data(bgp, id); 168 169 if (IS_ERR_OR_NULL(data)) 170 data = ti_thermal_build_data(bgp, id); 171 172 if (!data) 173 return -EINVAL; 174 175 /* in case this is specified by DT */ 176 data->ti_thermal = devm_thermal_of_zone_register(bgp->dev, id, 177 data, &ti_of_thermal_ops); 178 if (IS_ERR(data->ti_thermal)) { 179 dev_err(bgp->dev, "thermal zone device is NULL\n"); 180 return PTR_ERR(data->ti_thermal); 181 } 182 183 ti_bandgap_set_sensor_data(bgp, id, data); 184 ti_bandgap_write_update_interval(bgp, data->sensor_id, 185 TI_BANDGAP_UPDATE_INTERVAL_MS); 186 187 devm_thermal_add_hwmon_sysfs(bgp->dev, data->ti_thermal); 188 189 return 0; 190 } 191 192 int ti_thermal_remove_sensor(struct ti_bandgap *bgp, int id) 193 { 194 struct ti_thermal_data *data; 195 196 data = ti_bandgap_get_sensor_data(bgp, id); 197 198 if (!IS_ERR_OR_NULL(data) && data->ti_thermal) { 199 if (data->our_zone) 200 thermal_zone_device_unregister(data->ti_thermal); 201 } 202 203 return 0; 204 } 205 206 int ti_thermal_report_sensor_temperature(struct ti_bandgap *bgp, int id) 207 { 208 struct ti_thermal_data *data; 209 210 data = ti_bandgap_get_sensor_data(bgp, id); 211 212 schedule_work(&data->thermal_wq); 213 214 return 0; 215 } 216 217 int ti_thermal_register_cpu_cooling(struct ti_bandgap *bgp, int id) 218 { 219 struct ti_thermal_data *data; 220 struct device_node *np = bgp->dev->of_node; 221 222 /* 223 * We are assuming here that if one deploys the zone 224 * using DT, then it must be aware that the cooling device 225 * loading has to happen via cpufreq driver. 226 */ 227 if (of_property_present(np, "#thermal-sensor-cells")) 228 return 0; 229 230 data = ti_bandgap_get_sensor_data(bgp, id); 231 if (!data || IS_ERR(data)) 232 data = ti_thermal_build_data(bgp, id); 233 234 if (!data) 235 return -EINVAL; 236 237 data->policy = cpufreq_cpu_get(0); 238 if (!data->policy) { 239 pr_debug("%s: CPUFreq policy not found\n", __func__); 240 return -EPROBE_DEFER; 241 } 242 243 /* Register cooling device */ 244 data->cool_dev = cpufreq_cooling_register(data->policy); 245 if (IS_ERR(data->cool_dev)) { 246 int ret = PTR_ERR(data->cool_dev); 247 dev_err(bgp->dev, "Failed to register cpu cooling device %d\n", 248 ret); 249 cpufreq_cpu_put(data->policy); 250 251 return ret; 252 } 253 ti_bandgap_set_sensor_data(bgp, id, data); 254 255 return 0; 256 } 257 258 int ti_thermal_unregister_cpu_cooling(struct ti_bandgap *bgp, int id) 259 { 260 struct ti_thermal_data *data; 261 262 data = ti_bandgap_get_sensor_data(bgp, id); 263 264 if (!IS_ERR_OR_NULL(data)) { 265 cpufreq_cooling_unregister(data->cool_dev); 266 if (data->policy) 267 cpufreq_cpu_put(data->policy); 268 } 269 270 return 0; 271 } 272