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> 223c94f17eSAnson Huang #include <linux/of_device.h> 23ca3de46bSShawn Guo #include <linux/platform_device.h> 24ca3de46bSShawn Guo #include <linux/regmap.h> 25ca3de46bSShawn Guo #include <linux/slab.h> 26ca3de46bSShawn Guo #include <linux/thermal.h> 27ca3de46bSShawn Guo #include <linux/types.h> 28ca3de46bSShawn Guo 29ca3de46bSShawn Guo #define REG_SET 0x4 30ca3de46bSShawn Guo #define REG_CLR 0x8 31ca3de46bSShawn Guo #define REG_TOG 0xc 32ca3de46bSShawn Guo 33ca3de46bSShawn Guo #define MISC0 0x0150 34ca3de46bSShawn Guo #define MISC0_REFTOP_SELBIASOFF (1 << 3) 353c94f17eSAnson Huang #define MISC1 0x0160 363c94f17eSAnson Huang #define MISC1_IRQ_TEMPHIGH (1 << 29) 373c94f17eSAnson Huang /* Below LOW and PANIC bits are only for TEMPMON_IMX6SX */ 383c94f17eSAnson Huang #define MISC1_IRQ_TEMPLOW (1 << 28) 393c94f17eSAnson Huang #define MISC1_IRQ_TEMPPANIC (1 << 27) 40ca3de46bSShawn Guo 41ca3de46bSShawn Guo #define TEMPSENSE0 0x0180 4237713a1eSPhilipp Zabel #define TEMPSENSE0_ALARM_VALUE_SHIFT 20 4337713a1eSPhilipp Zabel #define TEMPSENSE0_ALARM_VALUE_MASK (0xfff << TEMPSENSE0_ALARM_VALUE_SHIFT) 44ca3de46bSShawn Guo #define TEMPSENSE0_TEMP_CNT_SHIFT 8 45ca3de46bSShawn Guo #define TEMPSENSE0_TEMP_CNT_MASK (0xfff << TEMPSENSE0_TEMP_CNT_SHIFT) 46ca3de46bSShawn Guo #define TEMPSENSE0_FINISHED (1 << 2) 47ca3de46bSShawn Guo #define TEMPSENSE0_MEASURE_TEMP (1 << 1) 48ca3de46bSShawn Guo #define TEMPSENSE0_POWER_DOWN (1 << 0) 49ca3de46bSShawn Guo 50ca3de46bSShawn Guo #define TEMPSENSE1 0x0190 51ca3de46bSShawn Guo #define TEMPSENSE1_MEASURE_FREQ 0xffff 523c94f17eSAnson Huang /* Below TEMPSENSE2 is only for TEMPMON_IMX6SX */ 533c94f17eSAnson Huang #define TEMPSENSE2 0x0290 543c94f17eSAnson Huang #define TEMPSENSE2_LOW_VALUE_SHIFT 0 553c94f17eSAnson Huang #define TEMPSENSE2_LOW_VALUE_MASK 0xfff 563c94f17eSAnson Huang #define TEMPSENSE2_PANIC_VALUE_SHIFT 16 573c94f17eSAnson Huang #define TEMPSENSE2_PANIC_VALUE_MASK 0xfff0000 58ca3de46bSShawn Guo 59ca3de46bSShawn Guo #define OCOTP_ANA1 0x04e0 60ca3de46bSShawn Guo 61ca3de46bSShawn Guo /* The driver supports 1 passive trip point and 1 critical trip point */ 62ca3de46bSShawn Guo enum imx_thermal_trip { 63ca3de46bSShawn Guo IMX_TRIP_PASSIVE, 64ca3de46bSShawn Guo IMX_TRIP_CRITICAL, 65ca3de46bSShawn Guo IMX_TRIP_NUM, 66ca3de46bSShawn Guo }; 67ca3de46bSShawn Guo 68ca3de46bSShawn Guo /* 69ca3de46bSShawn Guo * It defines the temperature in millicelsius for passive trip point 70ca3de46bSShawn Guo * that will trigger cooling action when crossed. 71ca3de46bSShawn Guo */ 72ca3de46bSShawn Guo #define IMX_TEMP_PASSIVE 85000 73ca3de46bSShawn Guo 74ca3de46bSShawn Guo #define IMX_POLLING_DELAY 2000 /* millisecond */ 75ca3de46bSShawn Guo #define IMX_PASSIVE_DELAY 1000 76ca3de46bSShawn Guo 77749e8be7SAnson Huang #define FACTOR0 10000000 78749e8be7SAnson Huang #define FACTOR1 15976 79749e8be7SAnson Huang #define FACTOR2 4297157 80749e8be7SAnson Huang 813c94f17eSAnson Huang #define TEMPMON_IMX6Q 1 823c94f17eSAnson Huang #define TEMPMON_IMX6SX 2 833c94f17eSAnson Huang 843c94f17eSAnson Huang struct thermal_soc_data { 853c94f17eSAnson Huang u32 version; 863c94f17eSAnson Huang }; 873c94f17eSAnson Huang 883c94f17eSAnson Huang static struct thermal_soc_data thermal_imx6q_data = { 893c94f17eSAnson Huang .version = TEMPMON_IMX6Q, 903c94f17eSAnson Huang }; 913c94f17eSAnson Huang 923c94f17eSAnson Huang static struct thermal_soc_data thermal_imx6sx_data = { 933c94f17eSAnson Huang .version = TEMPMON_IMX6SX, 943c94f17eSAnson Huang }; 953c94f17eSAnson Huang 96ca3de46bSShawn Guo struct imx_thermal_data { 97ca3de46bSShawn Guo struct thermal_zone_device *tz; 98ca3de46bSShawn Guo struct thermal_cooling_device *cdev; 99ca3de46bSShawn Guo enum thermal_device_mode mode; 100ca3de46bSShawn Guo struct regmap *tempmon; 101749e8be7SAnson Huang u32 c1, c2; /* See formula in imx_get_sensor_data() */ 102017e5142SPhilipp Zabel unsigned long temp_passive; 103017e5142SPhilipp Zabel unsigned long temp_critical; 10437713a1eSPhilipp Zabel unsigned long alarm_temp; 10537713a1eSPhilipp Zabel unsigned long last_temp; 10637713a1eSPhilipp Zabel bool irq_enabled; 10737713a1eSPhilipp Zabel int irq; 108329fe7b1SAnson Huang struct clk *thermal_clk; 1093c94f17eSAnson Huang const struct thermal_soc_data *socdata; 110ca3de46bSShawn Guo }; 111ca3de46bSShawn Guo 1123c94f17eSAnson Huang static void imx_set_panic_temp(struct imx_thermal_data *data, 1133c94f17eSAnson Huang signed long panic_temp) 1143c94f17eSAnson Huang { 1153c94f17eSAnson Huang struct regmap *map = data->tempmon; 1163c94f17eSAnson Huang int critical_value; 1173c94f17eSAnson Huang 1183c94f17eSAnson Huang critical_value = (data->c2 - panic_temp) / data->c1; 1193c94f17eSAnson Huang regmap_write(map, TEMPSENSE2 + REG_CLR, TEMPSENSE2_PANIC_VALUE_MASK); 1203c94f17eSAnson Huang regmap_write(map, TEMPSENSE2 + REG_SET, critical_value << 1213c94f17eSAnson Huang TEMPSENSE2_PANIC_VALUE_SHIFT); 1223c94f17eSAnson Huang } 1233c94f17eSAnson Huang 12437713a1eSPhilipp Zabel static void imx_set_alarm_temp(struct imx_thermal_data *data, 12537713a1eSPhilipp Zabel signed long alarm_temp) 12637713a1eSPhilipp Zabel { 12737713a1eSPhilipp Zabel struct regmap *map = data->tempmon; 12837713a1eSPhilipp Zabel int alarm_value; 12937713a1eSPhilipp Zabel 13037713a1eSPhilipp Zabel data->alarm_temp = alarm_temp; 131749e8be7SAnson Huang alarm_value = (data->c2 - alarm_temp) / data->c1; 13237713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_ALARM_VALUE_MASK); 13337713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, alarm_value << 13437713a1eSPhilipp Zabel TEMPSENSE0_ALARM_VALUE_SHIFT); 13537713a1eSPhilipp Zabel } 13637713a1eSPhilipp Zabel 137ca3de46bSShawn Guo static int imx_get_temp(struct thermal_zone_device *tz, unsigned long *temp) 138ca3de46bSShawn Guo { 139ca3de46bSShawn Guo struct imx_thermal_data *data = tz->devdata; 140ca3de46bSShawn Guo struct regmap *map = data->tempmon; 141ca3de46bSShawn Guo unsigned int n_meas; 14237713a1eSPhilipp Zabel bool wait; 143ca3de46bSShawn Guo u32 val; 144ca3de46bSShawn Guo 14537713a1eSPhilipp Zabel if (data->mode == THERMAL_DEVICE_ENABLED) { 14637713a1eSPhilipp Zabel /* Check if a measurement is currently in progress */ 14737713a1eSPhilipp Zabel regmap_read(map, TEMPSENSE0, &val); 14837713a1eSPhilipp Zabel wait = !(val & TEMPSENSE0_FINISHED); 14937713a1eSPhilipp Zabel } else { 150ca3de46bSShawn Guo /* 151ca3de46bSShawn Guo * Every time we measure the temperature, we will power on the 152ca3de46bSShawn Guo * temperature sensor, enable measurements, take a reading, 153ca3de46bSShawn Guo * disable measurements, power off the temperature sensor. 154ca3de46bSShawn Guo */ 155ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 156ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP); 157ca3de46bSShawn Guo 15837713a1eSPhilipp Zabel wait = true; 15937713a1eSPhilipp Zabel } 16037713a1eSPhilipp Zabel 161ca3de46bSShawn Guo /* 162ca3de46bSShawn Guo * According to the temp sensor designers, it may require up to ~17us 163ca3de46bSShawn Guo * to complete a measurement. 164ca3de46bSShawn Guo */ 16537713a1eSPhilipp Zabel if (wait) 166ca3de46bSShawn Guo usleep_range(20, 50); 167ca3de46bSShawn Guo 168ca3de46bSShawn Guo regmap_read(map, TEMPSENSE0, &val); 16937713a1eSPhilipp Zabel 17037713a1eSPhilipp Zabel if (data->mode != THERMAL_DEVICE_ENABLED) { 171ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP); 172ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 17337713a1eSPhilipp Zabel } 174ca3de46bSShawn Guo 175ca3de46bSShawn Guo if ((val & TEMPSENSE0_FINISHED) == 0) { 176ca3de46bSShawn Guo dev_dbg(&tz->device, "temp measurement never finished\n"); 177ca3de46bSShawn Guo return -EAGAIN; 178ca3de46bSShawn Guo } 179ca3de46bSShawn Guo 180ca3de46bSShawn Guo n_meas = (val & TEMPSENSE0_TEMP_CNT_MASK) >> TEMPSENSE0_TEMP_CNT_SHIFT; 181ca3de46bSShawn Guo 182ca3de46bSShawn Guo /* See imx_get_sensor_data() for formula derivation */ 183749e8be7SAnson Huang *temp = data->c2 - n_meas * data->c1; 184ca3de46bSShawn Guo 1853c94f17eSAnson Huang /* Update alarm value to next higher trip point for TEMPMON_IMX6Q */ 1863c94f17eSAnson Huang if (data->socdata->version == TEMPMON_IMX6Q) { 1873c94f17eSAnson Huang if (data->alarm_temp == data->temp_passive && 1883c94f17eSAnson Huang *temp >= data->temp_passive) 18937713a1eSPhilipp Zabel imx_set_alarm_temp(data, data->temp_critical); 1903c94f17eSAnson Huang if (data->alarm_temp == data->temp_critical && 1913c94f17eSAnson Huang *temp < data->temp_passive) { 19237713a1eSPhilipp Zabel imx_set_alarm_temp(data, data->temp_passive); 19337713a1eSPhilipp Zabel dev_dbg(&tz->device, "thermal alarm off: T < %lu\n", 19437713a1eSPhilipp Zabel data->alarm_temp / 1000); 19537713a1eSPhilipp Zabel } 1963c94f17eSAnson Huang } 19737713a1eSPhilipp Zabel 19837713a1eSPhilipp Zabel if (*temp != data->last_temp) { 199ca3de46bSShawn Guo dev_dbg(&tz->device, "millicelsius: %ld\n", *temp); 20037713a1eSPhilipp Zabel data->last_temp = *temp; 20137713a1eSPhilipp Zabel } 20237713a1eSPhilipp Zabel 20337713a1eSPhilipp Zabel /* Reenable alarm IRQ if temperature below alarm temperature */ 20437713a1eSPhilipp Zabel if (!data->irq_enabled && *temp < data->alarm_temp) { 20537713a1eSPhilipp Zabel data->irq_enabled = true; 20637713a1eSPhilipp Zabel enable_irq(data->irq); 207ca3de46bSShawn Guo } 208ca3de46bSShawn Guo 209ca3de46bSShawn Guo return 0; 210ca3de46bSShawn Guo } 211ca3de46bSShawn Guo 212ca3de46bSShawn Guo static int imx_get_mode(struct thermal_zone_device *tz, 213ca3de46bSShawn Guo enum thermal_device_mode *mode) 214ca3de46bSShawn Guo { 215ca3de46bSShawn Guo struct imx_thermal_data *data = tz->devdata; 216ca3de46bSShawn Guo 217ca3de46bSShawn Guo *mode = data->mode; 218ca3de46bSShawn Guo 219ca3de46bSShawn Guo return 0; 220ca3de46bSShawn Guo } 221ca3de46bSShawn Guo 222ca3de46bSShawn Guo static int imx_set_mode(struct thermal_zone_device *tz, 223ca3de46bSShawn Guo enum thermal_device_mode mode) 224ca3de46bSShawn Guo { 225ca3de46bSShawn Guo struct imx_thermal_data *data = tz->devdata; 22637713a1eSPhilipp Zabel struct regmap *map = data->tempmon; 227ca3de46bSShawn Guo 228ca3de46bSShawn Guo if (mode == THERMAL_DEVICE_ENABLED) { 229ca3de46bSShawn Guo tz->polling_delay = IMX_POLLING_DELAY; 230ca3de46bSShawn Guo tz->passive_delay = IMX_PASSIVE_DELAY; 23137713a1eSPhilipp Zabel 23237713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 23337713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP); 23437713a1eSPhilipp Zabel 23537713a1eSPhilipp Zabel if (!data->irq_enabled) { 23637713a1eSPhilipp Zabel data->irq_enabled = true; 23737713a1eSPhilipp Zabel enable_irq(data->irq); 23837713a1eSPhilipp Zabel } 239ca3de46bSShawn Guo } else { 24037713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP); 24137713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 24237713a1eSPhilipp Zabel 243ca3de46bSShawn Guo tz->polling_delay = 0; 244ca3de46bSShawn Guo tz->passive_delay = 0; 24537713a1eSPhilipp Zabel 24637713a1eSPhilipp Zabel if (data->irq_enabled) { 24737713a1eSPhilipp Zabel disable_irq(data->irq); 24837713a1eSPhilipp Zabel data->irq_enabled = false; 24937713a1eSPhilipp Zabel } 250ca3de46bSShawn Guo } 251ca3de46bSShawn Guo 252ca3de46bSShawn Guo data->mode = mode; 253ca3de46bSShawn Guo thermal_zone_device_update(tz); 254ca3de46bSShawn Guo 255ca3de46bSShawn Guo return 0; 256ca3de46bSShawn Guo } 257ca3de46bSShawn Guo 258ca3de46bSShawn Guo static int imx_get_trip_type(struct thermal_zone_device *tz, int trip, 259ca3de46bSShawn Guo enum thermal_trip_type *type) 260ca3de46bSShawn Guo { 261ca3de46bSShawn Guo *type = (trip == IMX_TRIP_PASSIVE) ? THERMAL_TRIP_PASSIVE : 262ca3de46bSShawn Guo THERMAL_TRIP_CRITICAL; 263ca3de46bSShawn Guo return 0; 264ca3de46bSShawn Guo } 265ca3de46bSShawn Guo 266ca3de46bSShawn Guo static int imx_get_crit_temp(struct thermal_zone_device *tz, 267ca3de46bSShawn Guo unsigned long *temp) 268ca3de46bSShawn Guo { 269017e5142SPhilipp Zabel struct imx_thermal_data *data = tz->devdata; 270017e5142SPhilipp Zabel 271017e5142SPhilipp Zabel *temp = data->temp_critical; 272ca3de46bSShawn Guo return 0; 273ca3de46bSShawn Guo } 274ca3de46bSShawn Guo 275ca3de46bSShawn Guo static int imx_get_trip_temp(struct thermal_zone_device *tz, int trip, 276ca3de46bSShawn Guo unsigned long *temp) 277ca3de46bSShawn Guo { 278017e5142SPhilipp Zabel struct imx_thermal_data *data = tz->devdata; 279017e5142SPhilipp Zabel 280017e5142SPhilipp Zabel *temp = (trip == IMX_TRIP_PASSIVE) ? data->temp_passive : 281017e5142SPhilipp Zabel data->temp_critical; 282017e5142SPhilipp Zabel return 0; 283017e5142SPhilipp Zabel } 284017e5142SPhilipp Zabel 285017e5142SPhilipp Zabel static int imx_set_trip_temp(struct thermal_zone_device *tz, int trip, 286017e5142SPhilipp Zabel unsigned long temp) 287017e5142SPhilipp Zabel { 288017e5142SPhilipp Zabel struct imx_thermal_data *data = tz->devdata; 289017e5142SPhilipp Zabel 290017e5142SPhilipp Zabel if (trip == IMX_TRIP_CRITICAL) 291017e5142SPhilipp Zabel return -EPERM; 292017e5142SPhilipp Zabel 293017e5142SPhilipp Zabel if (temp > IMX_TEMP_PASSIVE) 294017e5142SPhilipp Zabel return -EINVAL; 295017e5142SPhilipp Zabel 296017e5142SPhilipp Zabel data->temp_passive = temp; 297017e5142SPhilipp Zabel 29837713a1eSPhilipp Zabel imx_set_alarm_temp(data, temp); 29937713a1eSPhilipp Zabel 300ca3de46bSShawn Guo return 0; 301ca3de46bSShawn Guo } 302ca3de46bSShawn Guo 303ca3de46bSShawn Guo static int imx_bind(struct thermal_zone_device *tz, 304ca3de46bSShawn Guo struct thermal_cooling_device *cdev) 305ca3de46bSShawn Guo { 306ca3de46bSShawn Guo int ret; 307ca3de46bSShawn Guo 308ca3de46bSShawn Guo ret = thermal_zone_bind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev, 309ca3de46bSShawn Guo THERMAL_NO_LIMIT, 310ca3de46bSShawn Guo THERMAL_NO_LIMIT); 311ca3de46bSShawn Guo if (ret) { 312ca3de46bSShawn Guo dev_err(&tz->device, 313ca3de46bSShawn Guo "binding zone %s with cdev %s failed:%d\n", 314ca3de46bSShawn Guo tz->type, cdev->type, ret); 315ca3de46bSShawn Guo return ret; 316ca3de46bSShawn Guo } 317ca3de46bSShawn Guo 318ca3de46bSShawn Guo return 0; 319ca3de46bSShawn Guo } 320ca3de46bSShawn Guo 321ca3de46bSShawn Guo static int imx_unbind(struct thermal_zone_device *tz, 322ca3de46bSShawn Guo struct thermal_cooling_device *cdev) 323ca3de46bSShawn Guo { 324ca3de46bSShawn Guo int ret; 325ca3de46bSShawn Guo 326ca3de46bSShawn Guo ret = thermal_zone_unbind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev); 327ca3de46bSShawn Guo if (ret) { 328ca3de46bSShawn Guo dev_err(&tz->device, 329ca3de46bSShawn Guo "unbinding zone %s with cdev %s failed:%d\n", 330ca3de46bSShawn Guo tz->type, cdev->type, ret); 331ca3de46bSShawn Guo return ret; 332ca3de46bSShawn Guo } 333ca3de46bSShawn Guo 334ca3de46bSShawn Guo return 0; 335ca3de46bSShawn Guo } 336ca3de46bSShawn Guo 337cbb07bb3SEduardo Valentin static struct thermal_zone_device_ops imx_tz_ops = { 338ca3de46bSShawn Guo .bind = imx_bind, 339ca3de46bSShawn Guo .unbind = imx_unbind, 340ca3de46bSShawn Guo .get_temp = imx_get_temp, 341ca3de46bSShawn Guo .get_mode = imx_get_mode, 342ca3de46bSShawn Guo .set_mode = imx_set_mode, 343ca3de46bSShawn Guo .get_trip_type = imx_get_trip_type, 344ca3de46bSShawn Guo .get_trip_temp = imx_get_trip_temp, 345ca3de46bSShawn Guo .get_crit_temp = imx_get_crit_temp, 346017e5142SPhilipp Zabel .set_trip_temp = imx_set_trip_temp, 347ca3de46bSShawn Guo }; 348ca3de46bSShawn Guo 349ca3de46bSShawn Guo static int imx_get_sensor_data(struct platform_device *pdev) 350ca3de46bSShawn Guo { 351ca3de46bSShawn Guo struct imx_thermal_data *data = platform_get_drvdata(pdev); 352ca3de46bSShawn Guo struct regmap *map; 353d0f9d64aSAnson Huang int t1, n1; 354ca3de46bSShawn Guo int ret; 355ca3de46bSShawn Guo u32 val; 356749e8be7SAnson Huang u64 temp64; 357ca3de46bSShawn Guo 358ca3de46bSShawn Guo map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, 359ca3de46bSShawn Guo "fsl,tempmon-data"); 360ca3de46bSShawn Guo if (IS_ERR(map)) { 361ca3de46bSShawn Guo ret = PTR_ERR(map); 362ca3de46bSShawn Guo dev_err(&pdev->dev, "failed to get sensor regmap: %d\n", ret); 363ca3de46bSShawn Guo return ret; 364ca3de46bSShawn Guo } 365ca3de46bSShawn Guo 366ca3de46bSShawn Guo ret = regmap_read(map, OCOTP_ANA1, &val); 367ca3de46bSShawn Guo if (ret) { 368ca3de46bSShawn Guo dev_err(&pdev->dev, "failed to read sensor data: %d\n", ret); 369ca3de46bSShawn Guo return ret; 370ca3de46bSShawn Guo } 371ca3de46bSShawn Guo 372ca3de46bSShawn Guo if (val == 0 || val == ~0) { 373ca3de46bSShawn Guo dev_err(&pdev->dev, "invalid sensor calibration data\n"); 374ca3de46bSShawn Guo return -EINVAL; 375ca3de46bSShawn Guo } 376ca3de46bSShawn Guo 377ca3de46bSShawn Guo /* 378ca3de46bSShawn Guo * Sensor data layout: 379ca3de46bSShawn Guo * [31:20] - sensor value @ 25C 380749e8be7SAnson Huang * Use universal formula now and only need sensor value @ 25C 381749e8be7SAnson Huang * slope = 0.4297157 - (0.0015976 * 25C fuse) 382ca3de46bSShawn Guo */ 383ca3de46bSShawn Guo n1 = val >> 20; 384ca3de46bSShawn Guo t1 = 25; /* t1 always 25C */ 385ca3de46bSShawn Guo 386ca3de46bSShawn Guo /* 387749e8be7SAnson Huang * Derived from linear interpolation: 388749e8be7SAnson Huang * slope = 0.4297157 - (0.0015976 * 25C fuse) 389749e8be7SAnson Huang * slope = (FACTOR2 - FACTOR1 * n1) / FACTOR0 390749e8be7SAnson Huang * (Nmeas - n1) / (Tmeas - t1) = slope 391ca3de46bSShawn Guo * We want to reduce this down to the minimum computation necessary 392ca3de46bSShawn Guo * for each temperature read. Also, we want Tmeas in millicelsius 393ca3de46bSShawn Guo * and we don't want to lose precision from integer division. So... 394749e8be7SAnson Huang * Tmeas = (Nmeas - n1) / slope + t1 395749e8be7SAnson Huang * milli_Tmeas = 1000 * (Nmeas - n1) / slope + 1000 * t1 396749e8be7SAnson Huang * milli_Tmeas = -1000 * (n1 - Nmeas) / slope + 1000 * t1 397749e8be7SAnson Huang * Let constant c1 = (-1000 / slope) 398749e8be7SAnson Huang * milli_Tmeas = (n1 - Nmeas) * c1 + 1000 * t1 399749e8be7SAnson Huang * Let constant c2 = n1 *c1 + 1000 * t1 400749e8be7SAnson Huang * milli_Tmeas = c2 - Nmeas * c1 401ca3de46bSShawn Guo */ 402749e8be7SAnson Huang temp64 = FACTOR0; 403749e8be7SAnson Huang temp64 *= 1000; 404749e8be7SAnson Huang do_div(temp64, FACTOR1 * n1 - FACTOR2); 405749e8be7SAnson Huang data->c1 = temp64; 406749e8be7SAnson Huang data->c2 = n1 * data->c1 + 1000 * t1; 407ca3de46bSShawn Guo 408017e5142SPhilipp Zabel /* 409d0f9d64aSAnson Huang * Set the default passive cooling trip point, 410d0f9d64aSAnson Huang * can be changed from userspace. 411017e5142SPhilipp Zabel */ 412d0f9d64aSAnson Huang data->temp_passive = IMX_TEMP_PASSIVE; 413017e5142SPhilipp Zabel 414017e5142SPhilipp Zabel /* 415d0f9d64aSAnson Huang * The maximum die temperature set to 20 C higher than 416d0f9d64aSAnson Huang * IMX_TEMP_PASSIVE. 417017e5142SPhilipp Zabel */ 418d0f9d64aSAnson Huang data->temp_critical = 1000 * 20 + data->temp_passive; 419017e5142SPhilipp Zabel 420ca3de46bSShawn Guo return 0; 421ca3de46bSShawn Guo } 422ca3de46bSShawn Guo 42337713a1eSPhilipp Zabel static irqreturn_t imx_thermal_alarm_irq(int irq, void *dev) 42437713a1eSPhilipp Zabel { 42537713a1eSPhilipp Zabel struct imx_thermal_data *data = dev; 42637713a1eSPhilipp Zabel 42737713a1eSPhilipp Zabel disable_irq_nosync(irq); 42837713a1eSPhilipp Zabel data->irq_enabled = false; 42937713a1eSPhilipp Zabel 43037713a1eSPhilipp Zabel return IRQ_WAKE_THREAD; 43137713a1eSPhilipp Zabel } 43237713a1eSPhilipp Zabel 43337713a1eSPhilipp Zabel static irqreturn_t imx_thermal_alarm_irq_thread(int irq, void *dev) 43437713a1eSPhilipp Zabel { 43537713a1eSPhilipp Zabel struct imx_thermal_data *data = dev; 43637713a1eSPhilipp Zabel 43737713a1eSPhilipp Zabel dev_dbg(&data->tz->device, "THERMAL ALARM: T > %lu\n", 43837713a1eSPhilipp Zabel data->alarm_temp / 1000); 43937713a1eSPhilipp Zabel 44037713a1eSPhilipp Zabel thermal_zone_device_update(data->tz); 44137713a1eSPhilipp Zabel 44237713a1eSPhilipp Zabel return IRQ_HANDLED; 44337713a1eSPhilipp Zabel } 44437713a1eSPhilipp Zabel 4453c94f17eSAnson Huang static const struct of_device_id of_imx_thermal_match[] = { 4463c94f17eSAnson Huang { .compatible = "fsl,imx6q-tempmon", .data = &thermal_imx6q_data, }, 4473c94f17eSAnson Huang { .compatible = "fsl,imx6sx-tempmon", .data = &thermal_imx6sx_data, }, 4483c94f17eSAnson Huang { /* end */ } 4493c94f17eSAnson Huang }; 4503c94f17eSAnson Huang MODULE_DEVICE_TABLE(of, of_imx_thermal_match); 4513c94f17eSAnson Huang 452ca3de46bSShawn Guo static int imx_thermal_probe(struct platform_device *pdev) 453ca3de46bSShawn Guo { 4543c94f17eSAnson Huang const struct of_device_id *of_id = 4553c94f17eSAnson Huang of_match_device(of_imx_thermal_match, &pdev->dev); 456ca3de46bSShawn Guo struct imx_thermal_data *data; 457ca3de46bSShawn Guo struct cpumask clip_cpus; 458ca3de46bSShawn Guo struct regmap *map; 45937713a1eSPhilipp Zabel int measure_freq; 460ca3de46bSShawn Guo int ret; 461ca3de46bSShawn Guo 462491b079dSBai Ping if (!cpufreq_get_current_driver()) { 463491b079dSBai Ping dev_dbg(&pdev->dev, "no cpufreq driver!"); 464491b079dSBai Ping return -EPROBE_DEFER; 465491b079dSBai Ping } 466ca3de46bSShawn Guo data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); 467ca3de46bSShawn Guo if (!data) 468ca3de46bSShawn Guo return -ENOMEM; 469ca3de46bSShawn Guo 470ca3de46bSShawn Guo map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "fsl,tempmon"); 471ca3de46bSShawn Guo if (IS_ERR(map)) { 472ca3de46bSShawn Guo ret = PTR_ERR(map); 473ca3de46bSShawn Guo dev_err(&pdev->dev, "failed to get tempmon regmap: %d\n", ret); 474ca3de46bSShawn Guo return ret; 475ca3de46bSShawn Guo } 476ca3de46bSShawn Guo data->tempmon = map; 477ca3de46bSShawn Guo 4783c94f17eSAnson Huang data->socdata = of_id->data; 4793c94f17eSAnson Huang 4803c94f17eSAnson Huang /* make sure the IRQ flag is clear before enabling irq on i.MX6SX */ 4813c94f17eSAnson Huang if (data->socdata->version == TEMPMON_IMX6SX) { 4823c94f17eSAnson Huang regmap_write(map, MISC1 + REG_CLR, MISC1_IRQ_TEMPHIGH | 4833c94f17eSAnson Huang MISC1_IRQ_TEMPLOW | MISC1_IRQ_TEMPPANIC); 4843c94f17eSAnson Huang /* 4853c94f17eSAnson Huang * reset value of LOW ALARM is incorrect, set it to lowest 4863c94f17eSAnson Huang * value to avoid false trigger of low alarm. 4873c94f17eSAnson Huang */ 4883c94f17eSAnson Huang regmap_write(map, TEMPSENSE2 + REG_SET, 4893c94f17eSAnson Huang TEMPSENSE2_LOW_VALUE_MASK); 4903c94f17eSAnson Huang } 4913c94f17eSAnson Huang 49237713a1eSPhilipp Zabel data->irq = platform_get_irq(pdev, 0); 49337713a1eSPhilipp Zabel if (data->irq < 0) 49437713a1eSPhilipp Zabel return data->irq; 49537713a1eSPhilipp Zabel 49637713a1eSPhilipp Zabel ret = devm_request_threaded_irq(&pdev->dev, data->irq, 49737713a1eSPhilipp Zabel imx_thermal_alarm_irq, imx_thermal_alarm_irq_thread, 49837713a1eSPhilipp Zabel 0, "imx_thermal", data); 49937713a1eSPhilipp Zabel if (ret < 0) { 50037713a1eSPhilipp Zabel dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret); 50137713a1eSPhilipp Zabel return ret; 50237713a1eSPhilipp Zabel } 50337713a1eSPhilipp Zabel 504ca3de46bSShawn Guo platform_set_drvdata(pdev, data); 505ca3de46bSShawn Guo 506ca3de46bSShawn Guo ret = imx_get_sensor_data(pdev); 507ca3de46bSShawn Guo if (ret) { 508ca3de46bSShawn Guo dev_err(&pdev->dev, "failed to get sensor data\n"); 509ca3de46bSShawn Guo return ret; 510ca3de46bSShawn Guo } 511ca3de46bSShawn Guo 512ca3de46bSShawn Guo /* Make sure sensor is in known good state for measurements */ 513ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 514ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP); 515ca3de46bSShawn Guo regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ); 516ca3de46bSShawn Guo regmap_write(map, MISC0 + REG_SET, MISC0_REFTOP_SELBIASOFF); 517ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 518ca3de46bSShawn Guo 519ca3de46bSShawn Guo cpumask_set_cpu(0, &clip_cpus); 520ca3de46bSShawn Guo data->cdev = cpufreq_cooling_register(&clip_cpus); 521ca3de46bSShawn Guo if (IS_ERR(data->cdev)) { 522ca3de46bSShawn Guo ret = PTR_ERR(data->cdev); 523ca3de46bSShawn Guo dev_err(&pdev->dev, 524ca3de46bSShawn Guo "failed to register cpufreq cooling device: %d\n", ret); 525ca3de46bSShawn Guo return ret; 526ca3de46bSShawn Guo } 527ca3de46bSShawn Guo 52890a21ff5SHeiner Kallweit data->thermal_clk = devm_clk_get(&pdev->dev, NULL); 52990a21ff5SHeiner Kallweit if (IS_ERR(data->thermal_clk)) { 53090a21ff5SHeiner Kallweit ret = PTR_ERR(data->thermal_clk); 53190a21ff5SHeiner Kallweit if (ret != -EPROBE_DEFER) 53290a21ff5SHeiner Kallweit dev_err(&pdev->dev, 53390a21ff5SHeiner Kallweit "failed to get thermal clk: %d\n", ret); 53490a21ff5SHeiner Kallweit cpufreq_cooling_unregister(data->cdev); 53590a21ff5SHeiner Kallweit return ret; 53690a21ff5SHeiner Kallweit } 53790a21ff5SHeiner Kallweit 53890a21ff5SHeiner Kallweit /* 53990a21ff5SHeiner Kallweit * Thermal sensor needs clk on to get correct value, normally 54090a21ff5SHeiner Kallweit * we should enable its clk before taking measurement and disable 54190a21ff5SHeiner Kallweit * clk after measurement is done, but if alarm function is enabled, 54290a21ff5SHeiner Kallweit * hardware will auto measure the temperature periodically, so we 54390a21ff5SHeiner Kallweit * need to keep the clk always on for alarm function. 54490a21ff5SHeiner Kallweit */ 54590a21ff5SHeiner Kallweit ret = clk_prepare_enable(data->thermal_clk); 54690a21ff5SHeiner Kallweit if (ret) { 54790a21ff5SHeiner Kallweit dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret); 54890a21ff5SHeiner Kallweit cpufreq_cooling_unregister(data->cdev); 54990a21ff5SHeiner Kallweit return ret; 55090a21ff5SHeiner Kallweit } 55190a21ff5SHeiner Kallweit 552ca3de46bSShawn Guo data->tz = thermal_zone_device_register("imx_thermal_zone", 553017e5142SPhilipp Zabel IMX_TRIP_NUM, 554017e5142SPhilipp Zabel BIT(IMX_TRIP_PASSIVE), data, 555ca3de46bSShawn Guo &imx_tz_ops, NULL, 556ca3de46bSShawn Guo IMX_PASSIVE_DELAY, 557ca3de46bSShawn Guo IMX_POLLING_DELAY); 558ca3de46bSShawn Guo if (IS_ERR(data->tz)) { 559ca3de46bSShawn Guo ret = PTR_ERR(data->tz); 560ca3de46bSShawn Guo dev_err(&pdev->dev, 561ca3de46bSShawn Guo "failed to register thermal zone device %d\n", ret); 56290a21ff5SHeiner Kallweit clk_disable_unprepare(data->thermal_clk); 563ca3de46bSShawn Guo cpufreq_cooling_unregister(data->cdev); 564ca3de46bSShawn Guo return ret; 565ca3de46bSShawn Guo } 566ca3de46bSShawn Guo 56737713a1eSPhilipp Zabel /* Enable measurements at ~ 10 Hz */ 56837713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ); 56937713a1eSPhilipp Zabel measure_freq = DIV_ROUND_UP(32768, 10); /* 10 Hz */ 57037713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE1 + REG_SET, measure_freq); 57137713a1eSPhilipp Zabel imx_set_alarm_temp(data, data->temp_passive); 5723c94f17eSAnson Huang 5733c94f17eSAnson Huang if (data->socdata->version == TEMPMON_IMX6SX) 5743c94f17eSAnson Huang imx_set_panic_temp(data, data->temp_critical); 5753c94f17eSAnson Huang 57637713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 57737713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP); 57837713a1eSPhilipp Zabel 57937713a1eSPhilipp Zabel data->irq_enabled = true; 580ca3de46bSShawn Guo data->mode = THERMAL_DEVICE_ENABLED; 581ca3de46bSShawn Guo 582ca3de46bSShawn Guo return 0; 583ca3de46bSShawn Guo } 584ca3de46bSShawn Guo 585ca3de46bSShawn Guo static int imx_thermal_remove(struct platform_device *pdev) 586ca3de46bSShawn Guo { 587ca3de46bSShawn Guo struct imx_thermal_data *data = platform_get_drvdata(pdev); 58837713a1eSPhilipp Zabel struct regmap *map = data->tempmon; 58937713a1eSPhilipp Zabel 59037713a1eSPhilipp Zabel /* Disable measurements */ 59137713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 592329fe7b1SAnson Huang if (!IS_ERR(data->thermal_clk)) 593329fe7b1SAnson Huang clk_disable_unprepare(data->thermal_clk); 594ca3de46bSShawn Guo 595ca3de46bSShawn Guo thermal_zone_device_unregister(data->tz); 596ca3de46bSShawn Guo cpufreq_cooling_unregister(data->cdev); 597ca3de46bSShawn Guo 598ca3de46bSShawn Guo return 0; 599ca3de46bSShawn Guo } 600ca3de46bSShawn Guo 601ca3de46bSShawn Guo #ifdef CONFIG_PM_SLEEP 602ca3de46bSShawn Guo static int imx_thermal_suspend(struct device *dev) 603ca3de46bSShawn Guo { 604ca3de46bSShawn Guo struct imx_thermal_data *data = dev_get_drvdata(dev); 605ca3de46bSShawn Guo struct regmap *map = data->tempmon; 606ca3de46bSShawn Guo 607ca3de46bSShawn Guo /* 608b46cce59SAnson Huang * Need to disable thermal sensor, otherwise, when thermal core 609b46cce59SAnson Huang * try to get temperature before thermal sensor resume, a wrong 610b46cce59SAnson Huang * temperature will be read as the thermal sensor is powered 611b46cce59SAnson Huang * down. 612ca3de46bSShawn Guo */ 613b46cce59SAnson Huang regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP); 614b46cce59SAnson Huang regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 615b46cce59SAnson Huang data->mode = THERMAL_DEVICE_DISABLED; 616ca3de46bSShawn Guo 617ca3de46bSShawn Guo return 0; 618ca3de46bSShawn Guo } 619ca3de46bSShawn Guo 620ca3de46bSShawn Guo static int imx_thermal_resume(struct device *dev) 621ca3de46bSShawn Guo { 622b46cce59SAnson Huang struct imx_thermal_data *data = dev_get_drvdata(dev); 623b46cce59SAnson Huang struct regmap *map = data->tempmon; 624b46cce59SAnson Huang 625b46cce59SAnson Huang /* Enabled thermal sensor after resume */ 626b46cce59SAnson Huang regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 627b46cce59SAnson Huang regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP); 628b46cce59SAnson Huang data->mode = THERMAL_DEVICE_ENABLED; 629b46cce59SAnson Huang 630ca3de46bSShawn Guo return 0; 631ca3de46bSShawn Guo } 632ca3de46bSShawn Guo #endif 633ca3de46bSShawn Guo 634ca3de46bSShawn Guo static SIMPLE_DEV_PM_OPS(imx_thermal_pm_ops, 635ca3de46bSShawn Guo imx_thermal_suspend, imx_thermal_resume); 636ca3de46bSShawn Guo 637ca3de46bSShawn Guo static struct platform_driver imx_thermal = { 638ca3de46bSShawn Guo .driver = { 639ca3de46bSShawn Guo .name = "imx_thermal", 640ca3de46bSShawn Guo .owner = THIS_MODULE, 641ca3de46bSShawn Guo .pm = &imx_thermal_pm_ops, 642ca3de46bSShawn Guo .of_match_table = of_imx_thermal_match, 643ca3de46bSShawn Guo }, 644ca3de46bSShawn Guo .probe = imx_thermal_probe, 645ca3de46bSShawn Guo .remove = imx_thermal_remove, 646ca3de46bSShawn Guo }; 647ca3de46bSShawn Guo module_platform_driver(imx_thermal); 648ca3de46bSShawn Guo 649ca3de46bSShawn Guo MODULE_AUTHOR("Freescale Semiconductor, Inc."); 650ca3de46bSShawn Guo MODULE_DESCRIPTION("Thermal driver for Freescale i.MX SoCs"); 651ca3de46bSShawn Guo MODULE_LICENSE("GPL v2"); 652ca3de46bSShawn Guo MODULE_ALIAS("platform:imx-thermal"); 653