1 /* 2 * OMAP thermal driver interface 3 * 4 * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/ 5 * Contact: 6 * Eduardo Valentin <eduardo.valentin@ti.com> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * version 2 as published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 20 * 02110-1301 USA 21 * 22 */ 23 24 #include <linux/device.h> 25 #include <linux/err.h> 26 #include <linux/mutex.h> 27 #include <linux/gfp.h> 28 #include <linux/kernel.h> 29 #include <linux/workqueue.h> 30 #include <linux/thermal.h> 31 #include <linux/cpumask.h> 32 #include <linux/cpu_cooling.h> 33 #include <linux/of.h> 34 35 #include "ti-thermal.h" 36 #include "ti-bandgap.h" 37 38 /* common data structures */ 39 struct ti_thermal_data { 40 struct thermal_zone_device *ti_thermal; 41 struct thermal_zone_device *pcb_tz; 42 struct thermal_cooling_device *cool_dev; 43 struct ti_bandgap *bgp; 44 enum thermal_device_mode mode; 45 struct work_struct thermal_wq; 46 int sensor_id; 47 bool our_zone; 48 }; 49 50 static void ti_thermal_work(struct work_struct *work) 51 { 52 struct ti_thermal_data *data = container_of(work, 53 struct ti_thermal_data, thermal_wq); 54 55 thermal_zone_device_update(data->ti_thermal, THERMAL_EVENT_UNSPECIFIED); 56 57 dev_dbg(&data->ti_thermal->device, "updated thermal zone %s\n", 58 data->ti_thermal->type); 59 } 60 61 /** 62 * ti_thermal_hotspot_temperature - returns sensor extrapolated temperature 63 * @t: omap sensor temperature 64 * @s: omap sensor slope value 65 * @c: omap sensor const value 66 */ 67 static inline int ti_thermal_hotspot_temperature(int t, int s, int c) 68 { 69 int delta = t * s / 1000 + c; 70 71 if (delta < 0) 72 delta = 0; 73 74 return t + delta; 75 } 76 77 /* thermal zone ops */ 78 /* Get temperature callback function for thermal zone */ 79 static inline int __ti_thermal_get_temp(void *devdata, int *temp) 80 { 81 struct thermal_zone_device *pcb_tz = NULL; 82 struct ti_thermal_data *data = devdata; 83 struct ti_bandgap *bgp; 84 const struct ti_temp_sensor *s; 85 int ret, tmp, slope, constant; 86 int pcb_temp; 87 88 if (!data) 89 return 0; 90 91 bgp = data->bgp; 92 s = &bgp->conf->sensors[data->sensor_id]; 93 94 ret = ti_bandgap_read_temperature(bgp, data->sensor_id, &tmp); 95 if (ret) 96 return ret; 97 98 /* Default constants */ 99 slope = s->slope; 100 constant = s->constant; 101 102 pcb_tz = data->pcb_tz; 103 /* In case pcb zone is available, use the extrapolation rule with it */ 104 if (!IS_ERR(pcb_tz)) { 105 ret = thermal_zone_get_temp(pcb_tz, &pcb_temp); 106 if (!ret) { 107 tmp -= pcb_temp; /* got a valid PCB temp */ 108 slope = s->slope_pcb; 109 constant = s->constant_pcb; 110 } else { 111 dev_err(bgp->dev, 112 "Failed to read PCB state. Using defaults\n"); 113 ret = 0; 114 } 115 } 116 *temp = ti_thermal_hotspot_temperature(tmp, slope, constant); 117 118 return ret; 119 } 120 121 static inline int ti_thermal_get_temp(struct thermal_zone_device *thermal, 122 int *temp) 123 { 124 struct ti_thermal_data *data = thermal->devdata; 125 126 return __ti_thermal_get_temp(data, temp); 127 } 128 129 /* Bind callback functions for thermal zone */ 130 static int ti_thermal_bind(struct thermal_zone_device *thermal, 131 struct thermal_cooling_device *cdev) 132 { 133 struct ti_thermal_data *data = thermal->devdata; 134 int id; 135 136 if (!data || IS_ERR(data)) 137 return -ENODEV; 138 139 /* check if this is the cooling device we registered */ 140 if (data->cool_dev != cdev) 141 return 0; 142 143 id = data->sensor_id; 144 145 /* Simple thing, two trips, one passive another critical */ 146 return thermal_zone_bind_cooling_device(thermal, 0, cdev, 147 /* bind with min and max states defined by cpu_cooling */ 148 THERMAL_NO_LIMIT, 149 THERMAL_NO_LIMIT, 150 THERMAL_WEIGHT_DEFAULT); 151 } 152 153 /* Unbind callback functions for thermal zone */ 154 static int ti_thermal_unbind(struct thermal_zone_device *thermal, 155 struct thermal_cooling_device *cdev) 156 { 157 struct ti_thermal_data *data = thermal->devdata; 158 159 if (!data || IS_ERR(data)) 160 return -ENODEV; 161 162 /* check if this is the cooling device we registered */ 163 if (data->cool_dev != cdev) 164 return 0; 165 166 /* Simple thing, two trips, one passive another critical */ 167 return thermal_zone_unbind_cooling_device(thermal, 0, cdev); 168 } 169 170 /* Get mode callback functions for thermal zone */ 171 static int ti_thermal_get_mode(struct thermal_zone_device *thermal, 172 enum thermal_device_mode *mode) 173 { 174 struct ti_thermal_data *data = thermal->devdata; 175 176 if (data) 177 *mode = data->mode; 178 179 return 0; 180 } 181 182 /* Set mode callback functions for thermal zone */ 183 static int ti_thermal_set_mode(struct thermal_zone_device *thermal, 184 enum thermal_device_mode mode) 185 { 186 struct ti_thermal_data *data = thermal->devdata; 187 struct ti_bandgap *bgp; 188 189 bgp = data->bgp; 190 191 if (!data->ti_thermal) { 192 dev_notice(&thermal->device, "thermal zone not registered\n"); 193 return 0; 194 } 195 196 mutex_lock(&data->ti_thermal->lock); 197 198 if (mode == THERMAL_DEVICE_ENABLED) 199 data->ti_thermal->polling_delay = FAST_TEMP_MONITORING_RATE; 200 else 201 data->ti_thermal->polling_delay = 0; 202 203 mutex_unlock(&data->ti_thermal->lock); 204 205 data->mode = mode; 206 ti_bandgap_write_update_interval(bgp, data->sensor_id, 207 data->ti_thermal->polling_delay); 208 thermal_zone_device_update(data->ti_thermal, THERMAL_EVENT_UNSPECIFIED); 209 dev_dbg(&thermal->device, "thermal polling set for duration=%d msec\n", 210 data->ti_thermal->polling_delay); 211 212 return 0; 213 } 214 215 /* Get trip type callback functions for thermal zone */ 216 static int ti_thermal_get_trip_type(struct thermal_zone_device *thermal, 217 int trip, enum thermal_trip_type *type) 218 { 219 if (!ti_thermal_is_valid_trip(trip)) 220 return -EINVAL; 221 222 if (trip + 1 == OMAP_TRIP_NUMBER) 223 *type = THERMAL_TRIP_CRITICAL; 224 else 225 *type = THERMAL_TRIP_PASSIVE; 226 227 return 0; 228 } 229 230 /* Get trip temperature callback functions for thermal zone */ 231 static int ti_thermal_get_trip_temp(struct thermal_zone_device *thermal, 232 int trip, int *temp) 233 { 234 if (!ti_thermal_is_valid_trip(trip)) 235 return -EINVAL; 236 237 *temp = ti_thermal_get_trip_value(trip); 238 239 return 0; 240 } 241 242 static int __ti_thermal_get_trend(void *p, int trip, enum thermal_trend *trend) 243 { 244 struct ti_thermal_data *data = p; 245 struct ti_bandgap *bgp; 246 int id, tr, ret = 0; 247 248 bgp = data->bgp; 249 id = data->sensor_id; 250 251 ret = ti_bandgap_get_trend(bgp, id, &tr); 252 if (ret) 253 return ret; 254 255 if (tr > 0) 256 *trend = THERMAL_TREND_RAISING; 257 else if (tr < 0) 258 *trend = THERMAL_TREND_DROPPING; 259 else 260 *trend = THERMAL_TREND_STABLE; 261 262 return 0; 263 } 264 265 /* Get the temperature trend callback functions for thermal zone */ 266 static int ti_thermal_get_trend(struct thermal_zone_device *thermal, 267 int trip, enum thermal_trend *trend) 268 { 269 return __ti_thermal_get_trend(thermal->devdata, trip, trend); 270 } 271 272 /* Get critical temperature callback functions for thermal zone */ 273 static int ti_thermal_get_crit_temp(struct thermal_zone_device *thermal, 274 int *temp) 275 { 276 /* shutdown zone */ 277 return ti_thermal_get_trip_temp(thermal, OMAP_TRIP_NUMBER - 1, temp); 278 } 279 280 static const struct thermal_zone_of_device_ops ti_of_thermal_ops = { 281 .get_temp = __ti_thermal_get_temp, 282 .get_trend = __ti_thermal_get_trend, 283 }; 284 285 static struct thermal_zone_device_ops ti_thermal_ops = { 286 .get_temp = ti_thermal_get_temp, 287 .get_trend = ti_thermal_get_trend, 288 .bind = ti_thermal_bind, 289 .unbind = ti_thermal_unbind, 290 .get_mode = ti_thermal_get_mode, 291 .set_mode = ti_thermal_set_mode, 292 .get_trip_type = ti_thermal_get_trip_type, 293 .get_trip_temp = ti_thermal_get_trip_temp, 294 .get_crit_temp = ti_thermal_get_crit_temp, 295 }; 296 297 static struct ti_thermal_data 298 *ti_thermal_build_data(struct ti_bandgap *bgp, int id) 299 { 300 struct ti_thermal_data *data; 301 302 data = devm_kzalloc(bgp->dev, sizeof(*data), GFP_KERNEL); 303 if (!data) { 304 dev_err(bgp->dev, "kzalloc fail\n"); 305 return NULL; 306 } 307 data->sensor_id = id; 308 data->bgp = bgp; 309 data->mode = THERMAL_DEVICE_ENABLED; 310 /* pcb_tz will be either valid or PTR_ERR() */ 311 data->pcb_tz = thermal_zone_get_zone_by_name("pcb"); 312 INIT_WORK(&data->thermal_wq, ti_thermal_work); 313 314 return data; 315 } 316 317 int ti_thermal_expose_sensor(struct ti_bandgap *bgp, int id, 318 char *domain) 319 { 320 struct ti_thermal_data *data; 321 322 data = ti_bandgap_get_sensor_data(bgp, id); 323 324 if (!data || IS_ERR(data)) 325 data = ti_thermal_build_data(bgp, id); 326 327 if (!data) 328 return -EINVAL; 329 330 /* in case this is specified by DT */ 331 data->ti_thermal = devm_thermal_zone_of_sensor_register(bgp->dev, id, 332 data, &ti_of_thermal_ops); 333 if (IS_ERR(data->ti_thermal)) { 334 /* Create thermal zone */ 335 data->ti_thermal = thermal_zone_device_register(domain, 336 OMAP_TRIP_NUMBER, 0, data, &ti_thermal_ops, 337 NULL, FAST_TEMP_MONITORING_RATE, 338 FAST_TEMP_MONITORING_RATE); 339 if (IS_ERR(data->ti_thermal)) { 340 dev_err(bgp->dev, "thermal zone device is NULL\n"); 341 return PTR_ERR(data->ti_thermal); 342 } 343 data->ti_thermal->polling_delay = FAST_TEMP_MONITORING_RATE; 344 data->our_zone = true; 345 } 346 ti_bandgap_set_sensor_data(bgp, id, data); 347 ti_bandgap_write_update_interval(bgp, data->sensor_id, 348 data->ti_thermal->polling_delay); 349 350 return 0; 351 } 352 353 int ti_thermal_remove_sensor(struct ti_bandgap *bgp, int id) 354 { 355 struct ti_thermal_data *data; 356 357 data = ti_bandgap_get_sensor_data(bgp, id); 358 359 if (data && data->ti_thermal) { 360 if (data->our_zone) 361 thermal_zone_device_unregister(data->ti_thermal); 362 } 363 364 return 0; 365 } 366 367 int ti_thermal_report_sensor_temperature(struct ti_bandgap *bgp, int id) 368 { 369 struct ti_thermal_data *data; 370 371 data = ti_bandgap_get_sensor_data(bgp, id); 372 373 schedule_work(&data->thermal_wq); 374 375 return 0; 376 } 377 378 int ti_thermal_register_cpu_cooling(struct ti_bandgap *bgp, int id) 379 { 380 struct ti_thermal_data *data; 381 struct device_node *np = bgp->dev->of_node; 382 383 /* 384 * We are assuming here that if one deploys the zone 385 * using DT, then it must be aware that the cooling device 386 * loading has to happen via cpufreq driver. 387 */ 388 if (of_find_property(np, "#thermal-sensor-cells", NULL)) 389 return 0; 390 391 data = ti_bandgap_get_sensor_data(bgp, id); 392 if (!data || IS_ERR(data)) 393 data = ti_thermal_build_data(bgp, id); 394 395 if (!data) 396 return -EINVAL; 397 398 /* Register cooling device */ 399 data->cool_dev = cpufreq_cooling_register(cpu_present_mask); 400 if (IS_ERR(data->cool_dev)) { 401 int ret = PTR_ERR(data->cool_dev); 402 403 if (ret != -EPROBE_DEFER) 404 dev_err(bgp->dev, 405 "Failed to register cpu cooling device %d\n", 406 ret); 407 408 return ret; 409 } 410 ti_bandgap_set_sensor_data(bgp, id, data); 411 412 return 0; 413 } 414 415 int ti_thermal_unregister_cpu_cooling(struct ti_bandgap *bgp, int id) 416 { 417 struct ti_thermal_data *data; 418 419 data = ti_bandgap_get_sensor_data(bgp, id); 420 421 if (data) 422 cpufreq_cooling_unregister(data->cool_dev); 423 424 return 0; 425 } 426