1ca3de46bSShawn Guo /* 2ca3de46bSShawn Guo * Copyright 2013 Freescale Semiconductor, Inc. 3ca3de46bSShawn Guo * 4ca3de46bSShawn Guo * This program is free software; you can redistribute it and/or modify 5ca3de46bSShawn Guo * it under the terms of the GNU General Public License version 2 as 6ca3de46bSShawn Guo * published by the Free Software Foundation. 7ca3de46bSShawn Guo * 8ca3de46bSShawn Guo */ 9ca3de46bSShawn Guo 10329fe7b1SAnson Huang #include <linux/clk.h> 11ca3de46bSShawn Guo #include <linux/cpu_cooling.h> 12ca3de46bSShawn Guo #include <linux/cpufreq.h> 13ca3de46bSShawn Guo #include <linux/delay.h> 14ca3de46bSShawn Guo #include <linux/device.h> 15ca3de46bSShawn Guo #include <linux/init.h> 1637713a1eSPhilipp Zabel #include <linux/interrupt.h> 17ca3de46bSShawn Guo #include <linux/io.h> 18ca3de46bSShawn Guo #include <linux/kernel.h> 19ca3de46bSShawn Guo #include <linux/mfd/syscon.h> 20ca3de46bSShawn Guo #include <linux/module.h> 21ca3de46bSShawn Guo #include <linux/of.h> 22ca3de46bSShawn Guo #include <linux/platform_device.h> 23ca3de46bSShawn Guo #include <linux/regmap.h> 24ca3de46bSShawn Guo #include <linux/slab.h> 25ca3de46bSShawn Guo #include <linux/thermal.h> 26ca3de46bSShawn Guo #include <linux/types.h> 27ca3de46bSShawn Guo 28ca3de46bSShawn Guo #define REG_SET 0x4 29ca3de46bSShawn Guo #define REG_CLR 0x8 30ca3de46bSShawn Guo #define REG_TOG 0xc 31ca3de46bSShawn Guo 32ca3de46bSShawn Guo #define MISC0 0x0150 33ca3de46bSShawn Guo #define MISC0_REFTOP_SELBIASOFF (1 << 3) 34ca3de46bSShawn Guo 35ca3de46bSShawn Guo #define TEMPSENSE0 0x0180 3637713a1eSPhilipp Zabel #define TEMPSENSE0_ALARM_VALUE_SHIFT 20 3737713a1eSPhilipp Zabel #define TEMPSENSE0_ALARM_VALUE_MASK (0xfff << TEMPSENSE0_ALARM_VALUE_SHIFT) 38ca3de46bSShawn Guo #define TEMPSENSE0_TEMP_CNT_SHIFT 8 39ca3de46bSShawn Guo #define TEMPSENSE0_TEMP_CNT_MASK (0xfff << TEMPSENSE0_TEMP_CNT_SHIFT) 40ca3de46bSShawn Guo #define TEMPSENSE0_FINISHED (1 << 2) 41ca3de46bSShawn Guo #define TEMPSENSE0_MEASURE_TEMP (1 << 1) 42ca3de46bSShawn Guo #define TEMPSENSE0_POWER_DOWN (1 << 0) 43ca3de46bSShawn Guo 44ca3de46bSShawn Guo #define TEMPSENSE1 0x0190 45ca3de46bSShawn Guo #define TEMPSENSE1_MEASURE_FREQ 0xffff 46ca3de46bSShawn Guo 47ca3de46bSShawn Guo #define OCOTP_ANA1 0x04e0 48ca3de46bSShawn Guo 49ca3de46bSShawn Guo /* The driver supports 1 passive trip point and 1 critical trip point */ 50ca3de46bSShawn Guo enum imx_thermal_trip { 51ca3de46bSShawn Guo IMX_TRIP_PASSIVE, 52ca3de46bSShawn Guo IMX_TRIP_CRITICAL, 53ca3de46bSShawn Guo IMX_TRIP_NUM, 54ca3de46bSShawn Guo }; 55ca3de46bSShawn Guo 56ca3de46bSShawn Guo /* 57ca3de46bSShawn Guo * It defines the temperature in millicelsius for passive trip point 58ca3de46bSShawn Guo * that will trigger cooling action when crossed. 59ca3de46bSShawn Guo */ 60ca3de46bSShawn Guo #define IMX_TEMP_PASSIVE 85000 61ca3de46bSShawn Guo 62ca3de46bSShawn Guo #define IMX_POLLING_DELAY 2000 /* millisecond */ 63ca3de46bSShawn Guo #define IMX_PASSIVE_DELAY 1000 64ca3de46bSShawn Guo 65749e8be7SAnson Huang #define FACTOR0 10000000 66749e8be7SAnson Huang #define FACTOR1 15976 67749e8be7SAnson Huang #define FACTOR2 4297157 68749e8be7SAnson Huang 69ca3de46bSShawn Guo struct imx_thermal_data { 70ca3de46bSShawn Guo struct thermal_zone_device *tz; 71ca3de46bSShawn Guo struct thermal_cooling_device *cdev; 72ca3de46bSShawn Guo enum thermal_device_mode mode; 73ca3de46bSShawn Guo struct regmap *tempmon; 74749e8be7SAnson Huang u32 c1, c2; /* See formula in imx_get_sensor_data() */ 75017e5142SPhilipp Zabel unsigned long temp_passive; 76017e5142SPhilipp Zabel unsigned long temp_critical; 7737713a1eSPhilipp Zabel unsigned long alarm_temp; 7837713a1eSPhilipp Zabel unsigned long last_temp; 7937713a1eSPhilipp Zabel bool irq_enabled; 8037713a1eSPhilipp Zabel int irq; 81329fe7b1SAnson Huang struct clk *thermal_clk; 82ca3de46bSShawn Guo }; 83ca3de46bSShawn Guo 8437713a1eSPhilipp Zabel static void imx_set_alarm_temp(struct imx_thermal_data *data, 8537713a1eSPhilipp Zabel signed long alarm_temp) 8637713a1eSPhilipp Zabel { 8737713a1eSPhilipp Zabel struct regmap *map = data->tempmon; 8837713a1eSPhilipp Zabel int alarm_value; 8937713a1eSPhilipp Zabel 9037713a1eSPhilipp Zabel data->alarm_temp = alarm_temp; 91749e8be7SAnson Huang alarm_value = (data->c2 - alarm_temp) / data->c1; 9237713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_ALARM_VALUE_MASK); 9337713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, alarm_value << 9437713a1eSPhilipp Zabel TEMPSENSE0_ALARM_VALUE_SHIFT); 9537713a1eSPhilipp Zabel } 9637713a1eSPhilipp Zabel 97ca3de46bSShawn Guo static int imx_get_temp(struct thermal_zone_device *tz, unsigned long *temp) 98ca3de46bSShawn Guo { 99ca3de46bSShawn Guo struct imx_thermal_data *data = tz->devdata; 100ca3de46bSShawn Guo struct regmap *map = data->tempmon; 101ca3de46bSShawn Guo unsigned int n_meas; 10237713a1eSPhilipp Zabel bool wait; 103ca3de46bSShawn Guo u32 val; 104ca3de46bSShawn Guo 10537713a1eSPhilipp Zabel if (data->mode == THERMAL_DEVICE_ENABLED) { 10637713a1eSPhilipp Zabel /* Check if a measurement is currently in progress */ 10737713a1eSPhilipp Zabel regmap_read(map, TEMPSENSE0, &val); 10837713a1eSPhilipp Zabel wait = !(val & TEMPSENSE0_FINISHED); 10937713a1eSPhilipp Zabel } else { 110ca3de46bSShawn Guo /* 111ca3de46bSShawn Guo * Every time we measure the temperature, we will power on the 112ca3de46bSShawn Guo * temperature sensor, enable measurements, take a reading, 113ca3de46bSShawn Guo * disable measurements, power off the temperature sensor. 114ca3de46bSShawn Guo */ 115ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 116ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP); 117ca3de46bSShawn Guo 11837713a1eSPhilipp Zabel wait = true; 11937713a1eSPhilipp Zabel } 12037713a1eSPhilipp Zabel 121ca3de46bSShawn Guo /* 122ca3de46bSShawn Guo * According to the temp sensor designers, it may require up to ~17us 123ca3de46bSShawn Guo * to complete a measurement. 124ca3de46bSShawn Guo */ 12537713a1eSPhilipp Zabel if (wait) 126ca3de46bSShawn Guo usleep_range(20, 50); 127ca3de46bSShawn Guo 128ca3de46bSShawn Guo regmap_read(map, TEMPSENSE0, &val); 12937713a1eSPhilipp Zabel 13037713a1eSPhilipp Zabel if (data->mode != THERMAL_DEVICE_ENABLED) { 131ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP); 132ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 13337713a1eSPhilipp Zabel } 134ca3de46bSShawn Guo 135ca3de46bSShawn Guo if ((val & TEMPSENSE0_FINISHED) == 0) { 136ca3de46bSShawn Guo dev_dbg(&tz->device, "temp measurement never finished\n"); 137ca3de46bSShawn Guo return -EAGAIN; 138ca3de46bSShawn Guo } 139ca3de46bSShawn Guo 140ca3de46bSShawn Guo n_meas = (val & TEMPSENSE0_TEMP_CNT_MASK) >> TEMPSENSE0_TEMP_CNT_SHIFT; 141ca3de46bSShawn Guo 142ca3de46bSShawn Guo /* See imx_get_sensor_data() for formula derivation */ 143749e8be7SAnson Huang *temp = data->c2 - n_meas * data->c1; 144ca3de46bSShawn Guo 14537713a1eSPhilipp Zabel /* Update alarm value to next higher trip point */ 14637713a1eSPhilipp Zabel if (data->alarm_temp == data->temp_passive && *temp >= data->temp_passive) 14737713a1eSPhilipp Zabel imx_set_alarm_temp(data, data->temp_critical); 14837713a1eSPhilipp Zabel if (data->alarm_temp == data->temp_critical && *temp < data->temp_passive) { 14937713a1eSPhilipp Zabel imx_set_alarm_temp(data, data->temp_passive); 15037713a1eSPhilipp Zabel dev_dbg(&tz->device, "thermal alarm off: T < %lu\n", 15137713a1eSPhilipp Zabel data->alarm_temp / 1000); 15237713a1eSPhilipp Zabel } 15337713a1eSPhilipp Zabel 15437713a1eSPhilipp Zabel if (*temp != data->last_temp) { 155ca3de46bSShawn Guo dev_dbg(&tz->device, "millicelsius: %ld\n", *temp); 15637713a1eSPhilipp Zabel data->last_temp = *temp; 15737713a1eSPhilipp Zabel } 15837713a1eSPhilipp Zabel 15937713a1eSPhilipp Zabel /* Reenable alarm IRQ if temperature below alarm temperature */ 16037713a1eSPhilipp Zabel if (!data->irq_enabled && *temp < data->alarm_temp) { 16137713a1eSPhilipp Zabel data->irq_enabled = true; 16237713a1eSPhilipp Zabel enable_irq(data->irq); 163ca3de46bSShawn Guo } 164ca3de46bSShawn Guo 165ca3de46bSShawn Guo return 0; 166ca3de46bSShawn Guo } 167ca3de46bSShawn Guo 168ca3de46bSShawn Guo static int imx_get_mode(struct thermal_zone_device *tz, 169ca3de46bSShawn Guo enum thermal_device_mode *mode) 170ca3de46bSShawn Guo { 171ca3de46bSShawn Guo struct imx_thermal_data *data = tz->devdata; 172ca3de46bSShawn Guo 173ca3de46bSShawn Guo *mode = data->mode; 174ca3de46bSShawn Guo 175ca3de46bSShawn Guo return 0; 176ca3de46bSShawn Guo } 177ca3de46bSShawn Guo 178ca3de46bSShawn Guo static int imx_set_mode(struct thermal_zone_device *tz, 179ca3de46bSShawn Guo enum thermal_device_mode mode) 180ca3de46bSShawn Guo { 181ca3de46bSShawn Guo struct imx_thermal_data *data = tz->devdata; 18237713a1eSPhilipp Zabel struct regmap *map = data->tempmon; 183ca3de46bSShawn Guo 184ca3de46bSShawn Guo if (mode == THERMAL_DEVICE_ENABLED) { 185ca3de46bSShawn Guo tz->polling_delay = IMX_POLLING_DELAY; 186ca3de46bSShawn Guo tz->passive_delay = IMX_PASSIVE_DELAY; 18737713a1eSPhilipp Zabel 18837713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 18937713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP); 19037713a1eSPhilipp Zabel 19137713a1eSPhilipp Zabel if (!data->irq_enabled) { 19237713a1eSPhilipp Zabel data->irq_enabled = true; 19337713a1eSPhilipp Zabel enable_irq(data->irq); 19437713a1eSPhilipp Zabel } 195ca3de46bSShawn Guo } else { 19637713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP); 19737713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 19837713a1eSPhilipp Zabel 199ca3de46bSShawn Guo tz->polling_delay = 0; 200ca3de46bSShawn Guo tz->passive_delay = 0; 20137713a1eSPhilipp Zabel 20237713a1eSPhilipp Zabel if (data->irq_enabled) { 20337713a1eSPhilipp Zabel disable_irq(data->irq); 20437713a1eSPhilipp Zabel data->irq_enabled = false; 20537713a1eSPhilipp Zabel } 206ca3de46bSShawn Guo } 207ca3de46bSShawn Guo 208ca3de46bSShawn Guo data->mode = mode; 209ca3de46bSShawn Guo thermal_zone_device_update(tz); 210ca3de46bSShawn Guo 211ca3de46bSShawn Guo return 0; 212ca3de46bSShawn Guo } 213ca3de46bSShawn Guo 214ca3de46bSShawn Guo static int imx_get_trip_type(struct thermal_zone_device *tz, int trip, 215ca3de46bSShawn Guo enum thermal_trip_type *type) 216ca3de46bSShawn Guo { 217ca3de46bSShawn Guo *type = (trip == IMX_TRIP_PASSIVE) ? THERMAL_TRIP_PASSIVE : 218ca3de46bSShawn Guo THERMAL_TRIP_CRITICAL; 219ca3de46bSShawn Guo return 0; 220ca3de46bSShawn Guo } 221ca3de46bSShawn Guo 222ca3de46bSShawn Guo static int imx_get_crit_temp(struct thermal_zone_device *tz, 223ca3de46bSShawn Guo unsigned long *temp) 224ca3de46bSShawn Guo { 225017e5142SPhilipp Zabel struct imx_thermal_data *data = tz->devdata; 226017e5142SPhilipp Zabel 227017e5142SPhilipp Zabel *temp = data->temp_critical; 228ca3de46bSShawn Guo return 0; 229ca3de46bSShawn Guo } 230ca3de46bSShawn Guo 231ca3de46bSShawn Guo static int imx_get_trip_temp(struct thermal_zone_device *tz, int trip, 232ca3de46bSShawn Guo unsigned long *temp) 233ca3de46bSShawn Guo { 234017e5142SPhilipp Zabel struct imx_thermal_data *data = tz->devdata; 235017e5142SPhilipp Zabel 236017e5142SPhilipp Zabel *temp = (trip == IMX_TRIP_PASSIVE) ? data->temp_passive : 237017e5142SPhilipp Zabel data->temp_critical; 238017e5142SPhilipp Zabel return 0; 239017e5142SPhilipp Zabel } 240017e5142SPhilipp Zabel 241017e5142SPhilipp Zabel static int imx_set_trip_temp(struct thermal_zone_device *tz, int trip, 242017e5142SPhilipp Zabel unsigned long temp) 243017e5142SPhilipp Zabel { 244017e5142SPhilipp Zabel struct imx_thermal_data *data = tz->devdata; 245017e5142SPhilipp Zabel 246017e5142SPhilipp Zabel if (trip == IMX_TRIP_CRITICAL) 247017e5142SPhilipp Zabel return -EPERM; 248017e5142SPhilipp Zabel 249017e5142SPhilipp Zabel if (temp > IMX_TEMP_PASSIVE) 250017e5142SPhilipp Zabel return -EINVAL; 251017e5142SPhilipp Zabel 252017e5142SPhilipp Zabel data->temp_passive = temp; 253017e5142SPhilipp Zabel 25437713a1eSPhilipp Zabel imx_set_alarm_temp(data, temp); 25537713a1eSPhilipp Zabel 256ca3de46bSShawn Guo return 0; 257ca3de46bSShawn Guo } 258ca3de46bSShawn Guo 259ca3de46bSShawn Guo static int imx_bind(struct thermal_zone_device *tz, 260ca3de46bSShawn Guo struct thermal_cooling_device *cdev) 261ca3de46bSShawn Guo { 262ca3de46bSShawn Guo int ret; 263ca3de46bSShawn Guo 264ca3de46bSShawn Guo ret = thermal_zone_bind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev, 265ca3de46bSShawn Guo THERMAL_NO_LIMIT, 266ca3de46bSShawn Guo THERMAL_NO_LIMIT); 267ca3de46bSShawn Guo if (ret) { 268ca3de46bSShawn Guo dev_err(&tz->device, 269ca3de46bSShawn Guo "binding zone %s with cdev %s failed:%d\n", 270ca3de46bSShawn Guo tz->type, cdev->type, ret); 271ca3de46bSShawn Guo return ret; 272ca3de46bSShawn Guo } 273ca3de46bSShawn Guo 274ca3de46bSShawn Guo return 0; 275ca3de46bSShawn Guo } 276ca3de46bSShawn Guo 277ca3de46bSShawn Guo static int imx_unbind(struct thermal_zone_device *tz, 278ca3de46bSShawn Guo struct thermal_cooling_device *cdev) 279ca3de46bSShawn Guo { 280ca3de46bSShawn Guo int ret; 281ca3de46bSShawn Guo 282ca3de46bSShawn Guo ret = thermal_zone_unbind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev); 283ca3de46bSShawn Guo if (ret) { 284ca3de46bSShawn Guo dev_err(&tz->device, 285ca3de46bSShawn Guo "unbinding zone %s with cdev %s failed:%d\n", 286ca3de46bSShawn Guo tz->type, cdev->type, ret); 287ca3de46bSShawn Guo return ret; 288ca3de46bSShawn Guo } 289ca3de46bSShawn Guo 290ca3de46bSShawn Guo return 0; 291ca3de46bSShawn Guo } 292ca3de46bSShawn Guo 293cbb07bb3SEduardo Valentin static struct thermal_zone_device_ops imx_tz_ops = { 294ca3de46bSShawn Guo .bind = imx_bind, 295ca3de46bSShawn Guo .unbind = imx_unbind, 296ca3de46bSShawn Guo .get_temp = imx_get_temp, 297ca3de46bSShawn Guo .get_mode = imx_get_mode, 298ca3de46bSShawn Guo .set_mode = imx_set_mode, 299ca3de46bSShawn Guo .get_trip_type = imx_get_trip_type, 300ca3de46bSShawn Guo .get_trip_temp = imx_get_trip_temp, 301ca3de46bSShawn Guo .get_crit_temp = imx_get_crit_temp, 302017e5142SPhilipp Zabel .set_trip_temp = imx_set_trip_temp, 303ca3de46bSShawn Guo }; 304ca3de46bSShawn Guo 305ca3de46bSShawn Guo static int imx_get_sensor_data(struct platform_device *pdev) 306ca3de46bSShawn Guo { 307ca3de46bSShawn Guo struct imx_thermal_data *data = platform_get_drvdata(pdev); 308ca3de46bSShawn Guo struct regmap *map; 309ca3de46bSShawn Guo int t1, t2, n1, n2; 310ca3de46bSShawn Guo int ret; 311ca3de46bSShawn Guo u32 val; 312749e8be7SAnson Huang u64 temp64; 313ca3de46bSShawn Guo 314ca3de46bSShawn Guo map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, 315ca3de46bSShawn Guo "fsl,tempmon-data"); 316ca3de46bSShawn Guo if (IS_ERR(map)) { 317ca3de46bSShawn Guo ret = PTR_ERR(map); 318ca3de46bSShawn Guo dev_err(&pdev->dev, "failed to get sensor regmap: %d\n", ret); 319ca3de46bSShawn Guo return ret; 320ca3de46bSShawn Guo } 321ca3de46bSShawn Guo 322ca3de46bSShawn Guo ret = regmap_read(map, OCOTP_ANA1, &val); 323ca3de46bSShawn Guo if (ret) { 324ca3de46bSShawn Guo dev_err(&pdev->dev, "failed to read sensor data: %d\n", ret); 325ca3de46bSShawn Guo return ret; 326ca3de46bSShawn Guo } 327ca3de46bSShawn Guo 328ca3de46bSShawn Guo if (val == 0 || val == ~0) { 329ca3de46bSShawn Guo dev_err(&pdev->dev, "invalid sensor calibration data\n"); 330ca3de46bSShawn Guo return -EINVAL; 331ca3de46bSShawn Guo } 332ca3de46bSShawn Guo 333ca3de46bSShawn Guo /* 334ca3de46bSShawn Guo * Sensor data layout: 335ca3de46bSShawn Guo * [31:20] - sensor value @ 25C 336ca3de46bSShawn Guo * [19:8] - sensor value of hot 337ca3de46bSShawn Guo * [7:0] - hot temperature value 338749e8be7SAnson Huang * Use universal formula now and only need sensor value @ 25C 339749e8be7SAnson Huang * slope = 0.4297157 - (0.0015976 * 25C fuse) 340ca3de46bSShawn Guo */ 341ca3de46bSShawn Guo n1 = val >> 20; 342ca3de46bSShawn Guo n2 = (val & 0xfff00) >> 8; 343ca3de46bSShawn Guo t2 = val & 0xff; 344ca3de46bSShawn Guo t1 = 25; /* t1 always 25C */ 345ca3de46bSShawn Guo 346ca3de46bSShawn Guo /* 347749e8be7SAnson Huang * Derived from linear interpolation: 348749e8be7SAnson Huang * slope = 0.4297157 - (0.0015976 * 25C fuse) 349749e8be7SAnson Huang * slope = (FACTOR2 - FACTOR1 * n1) / FACTOR0 350749e8be7SAnson Huang * (Nmeas - n1) / (Tmeas - t1) = slope 351ca3de46bSShawn Guo * We want to reduce this down to the minimum computation necessary 352ca3de46bSShawn Guo * for each temperature read. Also, we want Tmeas in millicelsius 353ca3de46bSShawn Guo * and we don't want to lose precision from integer division. So... 354749e8be7SAnson Huang * Tmeas = (Nmeas - n1) / slope + t1 355749e8be7SAnson Huang * milli_Tmeas = 1000 * (Nmeas - n1) / slope + 1000 * t1 356749e8be7SAnson Huang * milli_Tmeas = -1000 * (n1 - Nmeas) / slope + 1000 * t1 357749e8be7SAnson Huang * Let constant c1 = (-1000 / slope) 358749e8be7SAnson Huang * milli_Tmeas = (n1 - Nmeas) * c1 + 1000 * t1 359749e8be7SAnson Huang * Let constant c2 = n1 *c1 + 1000 * t1 360749e8be7SAnson Huang * milli_Tmeas = c2 - Nmeas * c1 361ca3de46bSShawn Guo */ 362749e8be7SAnson Huang temp64 = FACTOR0; 363749e8be7SAnson Huang temp64 *= 1000; 364749e8be7SAnson Huang do_div(temp64, FACTOR1 * n1 - FACTOR2); 365749e8be7SAnson Huang data->c1 = temp64; 366749e8be7SAnson Huang data->c2 = n1 * data->c1 + 1000 * t1; 367ca3de46bSShawn Guo 368017e5142SPhilipp Zabel /* 369017e5142SPhilipp Zabel * Set the default passive cooling trip point to 20 °C below the 370017e5142SPhilipp Zabel * maximum die temperature. Can be changed from userspace. 371017e5142SPhilipp Zabel */ 372017e5142SPhilipp Zabel data->temp_passive = 1000 * (t2 - 20); 373017e5142SPhilipp Zabel 374017e5142SPhilipp Zabel /* 375017e5142SPhilipp Zabel * The maximum die temperature is t2, let's give 5 °C cushion 376017e5142SPhilipp Zabel * for noise and possible temperature rise between measurements. 377017e5142SPhilipp Zabel */ 378017e5142SPhilipp Zabel data->temp_critical = 1000 * (t2 - 5); 379017e5142SPhilipp Zabel 380ca3de46bSShawn Guo return 0; 381ca3de46bSShawn Guo } 382ca3de46bSShawn Guo 38337713a1eSPhilipp Zabel static irqreturn_t imx_thermal_alarm_irq(int irq, void *dev) 38437713a1eSPhilipp Zabel { 38537713a1eSPhilipp Zabel struct imx_thermal_data *data = dev; 38637713a1eSPhilipp Zabel 38737713a1eSPhilipp Zabel disable_irq_nosync(irq); 38837713a1eSPhilipp Zabel data->irq_enabled = false; 38937713a1eSPhilipp Zabel 39037713a1eSPhilipp Zabel return IRQ_WAKE_THREAD; 39137713a1eSPhilipp Zabel } 39237713a1eSPhilipp Zabel 39337713a1eSPhilipp Zabel static irqreturn_t imx_thermal_alarm_irq_thread(int irq, void *dev) 39437713a1eSPhilipp Zabel { 39537713a1eSPhilipp Zabel struct imx_thermal_data *data = dev; 39637713a1eSPhilipp Zabel 39737713a1eSPhilipp Zabel dev_dbg(&data->tz->device, "THERMAL ALARM: T > %lu\n", 39837713a1eSPhilipp Zabel data->alarm_temp / 1000); 39937713a1eSPhilipp Zabel 40037713a1eSPhilipp Zabel thermal_zone_device_update(data->tz); 40137713a1eSPhilipp Zabel 40237713a1eSPhilipp Zabel return IRQ_HANDLED; 40337713a1eSPhilipp Zabel } 40437713a1eSPhilipp Zabel 405ca3de46bSShawn Guo static int imx_thermal_probe(struct platform_device *pdev) 406ca3de46bSShawn Guo { 407ca3de46bSShawn Guo struct imx_thermal_data *data; 408ca3de46bSShawn Guo struct cpumask clip_cpus; 409ca3de46bSShawn Guo struct regmap *map; 41037713a1eSPhilipp Zabel int measure_freq; 411ca3de46bSShawn Guo int ret; 412ca3de46bSShawn Guo 413ca3de46bSShawn Guo data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); 414ca3de46bSShawn Guo if (!data) 415ca3de46bSShawn Guo return -ENOMEM; 416ca3de46bSShawn Guo 417ca3de46bSShawn Guo map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "fsl,tempmon"); 418ca3de46bSShawn Guo if (IS_ERR(map)) { 419ca3de46bSShawn Guo ret = PTR_ERR(map); 420ca3de46bSShawn Guo dev_err(&pdev->dev, "failed to get tempmon regmap: %d\n", ret); 421ca3de46bSShawn Guo return ret; 422ca3de46bSShawn Guo } 423ca3de46bSShawn Guo data->tempmon = map; 424ca3de46bSShawn Guo 42537713a1eSPhilipp Zabel data->irq = platform_get_irq(pdev, 0); 42637713a1eSPhilipp Zabel if (data->irq < 0) 42737713a1eSPhilipp Zabel return data->irq; 42837713a1eSPhilipp Zabel 42937713a1eSPhilipp Zabel ret = devm_request_threaded_irq(&pdev->dev, data->irq, 43037713a1eSPhilipp Zabel imx_thermal_alarm_irq, imx_thermal_alarm_irq_thread, 43137713a1eSPhilipp Zabel 0, "imx_thermal", data); 43237713a1eSPhilipp Zabel if (ret < 0) { 43337713a1eSPhilipp Zabel dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret); 43437713a1eSPhilipp Zabel return ret; 43537713a1eSPhilipp Zabel } 43637713a1eSPhilipp Zabel 437ca3de46bSShawn Guo platform_set_drvdata(pdev, data); 438ca3de46bSShawn Guo 439ca3de46bSShawn Guo ret = imx_get_sensor_data(pdev); 440ca3de46bSShawn Guo if (ret) { 441ca3de46bSShawn Guo dev_err(&pdev->dev, "failed to get sensor data\n"); 442ca3de46bSShawn Guo return ret; 443ca3de46bSShawn Guo } 444ca3de46bSShawn Guo 445ca3de46bSShawn Guo /* Make sure sensor is in known good state for measurements */ 446ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 447ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP); 448ca3de46bSShawn Guo regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ); 449ca3de46bSShawn Guo regmap_write(map, MISC0 + REG_SET, MISC0_REFTOP_SELBIASOFF); 450ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 451ca3de46bSShawn Guo 452ca3de46bSShawn Guo cpumask_set_cpu(0, &clip_cpus); 453ca3de46bSShawn Guo data->cdev = cpufreq_cooling_register(&clip_cpus); 454ca3de46bSShawn Guo if (IS_ERR(data->cdev)) { 455ca3de46bSShawn Guo ret = PTR_ERR(data->cdev); 456ca3de46bSShawn Guo dev_err(&pdev->dev, 457ca3de46bSShawn Guo "failed to register cpufreq cooling device: %d\n", ret); 458ca3de46bSShawn Guo return ret; 459ca3de46bSShawn Guo } 460ca3de46bSShawn Guo 461ca3de46bSShawn Guo data->tz = thermal_zone_device_register("imx_thermal_zone", 462017e5142SPhilipp Zabel IMX_TRIP_NUM, 463017e5142SPhilipp Zabel BIT(IMX_TRIP_PASSIVE), data, 464ca3de46bSShawn Guo &imx_tz_ops, NULL, 465ca3de46bSShawn Guo IMX_PASSIVE_DELAY, 466ca3de46bSShawn Guo IMX_POLLING_DELAY); 467ca3de46bSShawn Guo if (IS_ERR(data->tz)) { 468ca3de46bSShawn Guo ret = PTR_ERR(data->tz); 469ca3de46bSShawn Guo dev_err(&pdev->dev, 470ca3de46bSShawn Guo "failed to register thermal zone device %d\n", ret); 471ca3de46bSShawn Guo cpufreq_cooling_unregister(data->cdev); 472ca3de46bSShawn Guo return ret; 473ca3de46bSShawn Guo } 474ca3de46bSShawn Guo 475329fe7b1SAnson Huang data->thermal_clk = devm_clk_get(&pdev->dev, NULL); 476329fe7b1SAnson Huang if (IS_ERR(data->thermal_clk)) { 477329fe7b1SAnson Huang dev_warn(&pdev->dev, "failed to get thermal clk!\n"); 478329fe7b1SAnson Huang } else { 479329fe7b1SAnson Huang /* 480329fe7b1SAnson Huang * Thermal sensor needs clk on to get correct value, normally 481329fe7b1SAnson Huang * we should enable its clk before taking measurement and disable 482329fe7b1SAnson Huang * clk after measurement is done, but if alarm function is enabled, 483329fe7b1SAnson Huang * hardware will auto measure the temperature periodically, so we 484329fe7b1SAnson Huang * need to keep the clk always on for alarm function. 485329fe7b1SAnson Huang */ 486329fe7b1SAnson Huang ret = clk_prepare_enable(data->thermal_clk); 487329fe7b1SAnson Huang if (ret) 488329fe7b1SAnson Huang dev_warn(&pdev->dev, "failed to enable thermal clk: %d\n", ret); 489329fe7b1SAnson Huang } 490329fe7b1SAnson Huang 49137713a1eSPhilipp Zabel /* Enable measurements at ~ 10 Hz */ 49237713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ); 49337713a1eSPhilipp Zabel measure_freq = DIV_ROUND_UP(32768, 10); /* 10 Hz */ 49437713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE1 + REG_SET, measure_freq); 49537713a1eSPhilipp Zabel imx_set_alarm_temp(data, data->temp_passive); 49637713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 49737713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP); 49837713a1eSPhilipp Zabel 49937713a1eSPhilipp Zabel data->irq_enabled = true; 500ca3de46bSShawn Guo data->mode = THERMAL_DEVICE_ENABLED; 501ca3de46bSShawn Guo 502ca3de46bSShawn Guo return 0; 503ca3de46bSShawn Guo } 504ca3de46bSShawn Guo 505ca3de46bSShawn Guo static int imx_thermal_remove(struct platform_device *pdev) 506ca3de46bSShawn Guo { 507ca3de46bSShawn Guo struct imx_thermal_data *data = platform_get_drvdata(pdev); 50837713a1eSPhilipp Zabel struct regmap *map = data->tempmon; 50937713a1eSPhilipp Zabel 51037713a1eSPhilipp Zabel /* Disable measurements */ 51137713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 512329fe7b1SAnson Huang if (!IS_ERR(data->thermal_clk)) 513329fe7b1SAnson Huang clk_disable_unprepare(data->thermal_clk); 514ca3de46bSShawn Guo 515ca3de46bSShawn Guo thermal_zone_device_unregister(data->tz); 516ca3de46bSShawn Guo cpufreq_cooling_unregister(data->cdev); 517ca3de46bSShawn Guo 518ca3de46bSShawn Guo return 0; 519ca3de46bSShawn Guo } 520ca3de46bSShawn Guo 521ca3de46bSShawn Guo #ifdef CONFIG_PM_SLEEP 522ca3de46bSShawn Guo static int imx_thermal_suspend(struct device *dev) 523ca3de46bSShawn Guo { 524ca3de46bSShawn Guo struct imx_thermal_data *data = dev_get_drvdata(dev); 525ca3de46bSShawn Guo struct regmap *map = data->tempmon; 526ca3de46bSShawn Guo 527ca3de46bSShawn Guo /* 528b46cce59SAnson Huang * Need to disable thermal sensor, otherwise, when thermal core 529b46cce59SAnson Huang * try to get temperature before thermal sensor resume, a wrong 530b46cce59SAnson Huang * temperature will be read as the thermal sensor is powered 531b46cce59SAnson Huang * down. 532ca3de46bSShawn Guo */ 533b46cce59SAnson Huang regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP); 534b46cce59SAnson Huang regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 535b46cce59SAnson Huang data->mode = THERMAL_DEVICE_DISABLED; 536ca3de46bSShawn Guo 537ca3de46bSShawn Guo return 0; 538ca3de46bSShawn Guo } 539ca3de46bSShawn Guo 540ca3de46bSShawn Guo static int imx_thermal_resume(struct device *dev) 541ca3de46bSShawn Guo { 542b46cce59SAnson Huang struct imx_thermal_data *data = dev_get_drvdata(dev); 543b46cce59SAnson Huang struct regmap *map = data->tempmon; 544b46cce59SAnson Huang 545b46cce59SAnson Huang /* Enabled thermal sensor after resume */ 546b46cce59SAnson Huang regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 547b46cce59SAnson Huang regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP); 548b46cce59SAnson Huang data->mode = THERMAL_DEVICE_ENABLED; 549b46cce59SAnson Huang 550ca3de46bSShawn Guo return 0; 551ca3de46bSShawn Guo } 552ca3de46bSShawn Guo #endif 553ca3de46bSShawn Guo 554ca3de46bSShawn Guo static SIMPLE_DEV_PM_OPS(imx_thermal_pm_ops, 555ca3de46bSShawn Guo imx_thermal_suspend, imx_thermal_resume); 556ca3de46bSShawn Guo 557ca3de46bSShawn Guo static const struct of_device_id of_imx_thermal_match[] = { 558ca3de46bSShawn Guo { .compatible = "fsl,imx6q-tempmon", }, 559ca3de46bSShawn Guo { /* end */ } 560ca3de46bSShawn Guo }; 561dd268632SRussell King MODULE_DEVICE_TABLE(of, of_imx_thermal_match); 562ca3de46bSShawn Guo 563ca3de46bSShawn Guo static struct platform_driver imx_thermal = { 564ca3de46bSShawn Guo .driver = { 565ca3de46bSShawn Guo .name = "imx_thermal", 566ca3de46bSShawn Guo .owner = THIS_MODULE, 567ca3de46bSShawn Guo .pm = &imx_thermal_pm_ops, 568ca3de46bSShawn Guo .of_match_table = of_imx_thermal_match, 569ca3de46bSShawn Guo }, 570ca3de46bSShawn Guo .probe = imx_thermal_probe, 571ca3de46bSShawn Guo .remove = imx_thermal_remove, 572ca3de46bSShawn Guo }; 573ca3de46bSShawn Guo module_platform_driver(imx_thermal); 574ca3de46bSShawn Guo 575ca3de46bSShawn Guo MODULE_AUTHOR("Freescale Semiconductor, Inc."); 576ca3de46bSShawn Guo MODULE_DESCRIPTION("Thermal driver for Freescale i.MX SoCs"); 577ca3de46bSShawn Guo MODULE_LICENSE("GPL v2"); 578ca3de46bSShawn Guo MODULE_ALIAS("platform:imx-thermal"); 579