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> 114d753aa7SViresh Kumar #include <linux/cpufreq.h> 12ca3de46bSShawn Guo #include <linux/cpu_cooling.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> 28ae621557SLeonard Crestez #include <linux/nvmem-consumer.h> 29ca3de46bSShawn Guo 30ca3de46bSShawn Guo #define REG_SET 0x4 31ca3de46bSShawn Guo #define REG_CLR 0x8 32ca3de46bSShawn Guo #define REG_TOG 0xc 33ca3de46bSShawn Guo 34ca3de46bSShawn Guo #define MISC0 0x0150 35ca3de46bSShawn Guo #define MISC0_REFTOP_SELBIASOFF (1 << 3) 363c94f17eSAnson Huang #define MISC1 0x0160 373c94f17eSAnson Huang #define MISC1_IRQ_TEMPHIGH (1 << 29) 383c94f17eSAnson Huang /* Below LOW and PANIC bits are only for TEMPMON_IMX6SX */ 393c94f17eSAnson Huang #define MISC1_IRQ_TEMPLOW (1 << 28) 403c94f17eSAnson Huang #define MISC1_IRQ_TEMPPANIC (1 << 27) 41ca3de46bSShawn Guo 42ca3de46bSShawn Guo #define TEMPSENSE0 0x0180 4337713a1eSPhilipp Zabel #define TEMPSENSE0_ALARM_VALUE_SHIFT 20 4437713a1eSPhilipp Zabel #define TEMPSENSE0_ALARM_VALUE_MASK (0xfff << TEMPSENSE0_ALARM_VALUE_SHIFT) 45ca3de46bSShawn Guo #define TEMPSENSE0_TEMP_CNT_SHIFT 8 46ca3de46bSShawn Guo #define TEMPSENSE0_TEMP_CNT_MASK (0xfff << TEMPSENSE0_TEMP_CNT_SHIFT) 47ca3de46bSShawn Guo #define TEMPSENSE0_FINISHED (1 << 2) 48ca3de46bSShawn Guo #define TEMPSENSE0_MEASURE_TEMP (1 << 1) 49ca3de46bSShawn Guo #define TEMPSENSE0_POWER_DOWN (1 << 0) 50ca3de46bSShawn Guo 51ca3de46bSShawn Guo #define TEMPSENSE1 0x0190 52ca3de46bSShawn Guo #define TEMPSENSE1_MEASURE_FREQ 0xffff 533c94f17eSAnson Huang /* Below TEMPSENSE2 is only for TEMPMON_IMX6SX */ 543c94f17eSAnson Huang #define TEMPSENSE2 0x0290 553c94f17eSAnson Huang #define TEMPSENSE2_LOW_VALUE_SHIFT 0 563c94f17eSAnson Huang #define TEMPSENSE2_LOW_VALUE_MASK 0xfff 573c94f17eSAnson Huang #define TEMPSENSE2_PANIC_VALUE_SHIFT 16 583c94f17eSAnson Huang #define TEMPSENSE2_PANIC_VALUE_MASK 0xfff0000 59ca3de46bSShawn Guo 60a2291badSTim Harvey #define OCOTP_MEM0 0x0480 61ca3de46bSShawn Guo #define OCOTP_ANA1 0x04e0 62ca3de46bSShawn Guo 63ca3de46bSShawn Guo /* The driver supports 1 passive trip point and 1 critical trip point */ 64ca3de46bSShawn Guo enum imx_thermal_trip { 65ca3de46bSShawn Guo IMX_TRIP_PASSIVE, 66ca3de46bSShawn Guo IMX_TRIP_CRITICAL, 67ca3de46bSShawn Guo IMX_TRIP_NUM, 68ca3de46bSShawn Guo }; 69ca3de46bSShawn Guo 70ca3de46bSShawn Guo #define IMX_POLLING_DELAY 2000 /* millisecond */ 71ca3de46bSShawn Guo #define IMX_PASSIVE_DELAY 1000 72ca3de46bSShawn Guo 733c94f17eSAnson Huang #define TEMPMON_IMX6Q 1 743c94f17eSAnson Huang #define TEMPMON_IMX6SX 2 753c94f17eSAnson Huang 763c94f17eSAnson Huang struct thermal_soc_data { 773c94f17eSAnson Huang u32 version; 783c94f17eSAnson Huang }; 793c94f17eSAnson Huang 803c94f17eSAnson Huang static struct thermal_soc_data thermal_imx6q_data = { 813c94f17eSAnson Huang .version = TEMPMON_IMX6Q, 823c94f17eSAnson Huang }; 833c94f17eSAnson Huang 843c94f17eSAnson Huang static struct thermal_soc_data thermal_imx6sx_data = { 853c94f17eSAnson Huang .version = TEMPMON_IMX6SX, 863c94f17eSAnson Huang }; 873c94f17eSAnson Huang 88ca3de46bSShawn Guo struct imx_thermal_data { 894d753aa7SViresh Kumar struct cpufreq_policy *policy; 90ca3de46bSShawn Guo struct thermal_zone_device *tz; 91ca3de46bSShawn Guo struct thermal_cooling_device *cdev; 92ca3de46bSShawn Guo enum thermal_device_mode mode; 93ca3de46bSShawn Guo struct regmap *tempmon; 94ae621557SLeonard Crestez u32 c1, c2; /* See formula in imx_init_calib() */ 9517e8351aSSascha Hauer int temp_passive; 9617e8351aSSascha Hauer int temp_critical; 97a2291badSTim Harvey int temp_max; 9817e8351aSSascha Hauer int alarm_temp; 9917e8351aSSascha Hauer int last_temp; 10037713a1eSPhilipp Zabel bool irq_enabled; 10137713a1eSPhilipp Zabel int irq; 102329fe7b1SAnson Huang struct clk *thermal_clk; 1033c94f17eSAnson Huang const struct thermal_soc_data *socdata; 104a2291badSTim Harvey const char *temp_grade; 105ca3de46bSShawn Guo }; 106ca3de46bSShawn Guo 1073c94f17eSAnson Huang static void imx_set_panic_temp(struct imx_thermal_data *data, 10817e8351aSSascha Hauer int panic_temp) 1093c94f17eSAnson Huang { 1103c94f17eSAnson Huang struct regmap *map = data->tempmon; 1113c94f17eSAnson Huang int critical_value; 1123c94f17eSAnson Huang 1133c94f17eSAnson Huang critical_value = (data->c2 - panic_temp) / data->c1; 1143c94f17eSAnson Huang regmap_write(map, TEMPSENSE2 + REG_CLR, TEMPSENSE2_PANIC_VALUE_MASK); 1153c94f17eSAnson Huang regmap_write(map, TEMPSENSE2 + REG_SET, critical_value << 1163c94f17eSAnson Huang TEMPSENSE2_PANIC_VALUE_SHIFT); 1173c94f17eSAnson Huang } 1183c94f17eSAnson Huang 11937713a1eSPhilipp Zabel static void imx_set_alarm_temp(struct imx_thermal_data *data, 12017e8351aSSascha Hauer int alarm_temp) 12137713a1eSPhilipp Zabel { 12237713a1eSPhilipp Zabel struct regmap *map = data->tempmon; 12337713a1eSPhilipp Zabel int alarm_value; 12437713a1eSPhilipp Zabel 12537713a1eSPhilipp Zabel data->alarm_temp = alarm_temp; 126749e8be7SAnson Huang alarm_value = (data->c2 - alarm_temp) / data->c1; 12737713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_ALARM_VALUE_MASK); 12837713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, alarm_value << 12937713a1eSPhilipp Zabel TEMPSENSE0_ALARM_VALUE_SHIFT); 13037713a1eSPhilipp Zabel } 13137713a1eSPhilipp Zabel 13217e8351aSSascha Hauer static int imx_get_temp(struct thermal_zone_device *tz, int *temp) 133ca3de46bSShawn Guo { 134ca3de46bSShawn Guo struct imx_thermal_data *data = tz->devdata; 135ca3de46bSShawn Guo struct regmap *map = data->tempmon; 136ca3de46bSShawn Guo unsigned int n_meas; 13737713a1eSPhilipp Zabel bool wait; 138ca3de46bSShawn Guo u32 val; 139ca3de46bSShawn Guo 14037713a1eSPhilipp Zabel if (data->mode == THERMAL_DEVICE_ENABLED) { 14137713a1eSPhilipp Zabel /* Check if a measurement is currently in progress */ 14237713a1eSPhilipp Zabel regmap_read(map, TEMPSENSE0, &val); 14337713a1eSPhilipp Zabel wait = !(val & TEMPSENSE0_FINISHED); 14437713a1eSPhilipp Zabel } else { 145ca3de46bSShawn Guo /* 146ca3de46bSShawn Guo * Every time we measure the temperature, we will power on the 147ca3de46bSShawn Guo * temperature sensor, enable measurements, take a reading, 148ca3de46bSShawn Guo * disable measurements, power off the temperature sensor. 149ca3de46bSShawn Guo */ 150ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 151ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP); 152ca3de46bSShawn Guo 15337713a1eSPhilipp Zabel wait = true; 15437713a1eSPhilipp Zabel } 15537713a1eSPhilipp Zabel 156ca3de46bSShawn Guo /* 157ca3de46bSShawn Guo * According to the temp sensor designers, it may require up to ~17us 158ca3de46bSShawn Guo * to complete a measurement. 159ca3de46bSShawn Guo */ 16037713a1eSPhilipp Zabel if (wait) 161ca3de46bSShawn Guo usleep_range(20, 50); 162ca3de46bSShawn Guo 163ca3de46bSShawn Guo regmap_read(map, TEMPSENSE0, &val); 16437713a1eSPhilipp Zabel 16537713a1eSPhilipp Zabel if (data->mode != THERMAL_DEVICE_ENABLED) { 166ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP); 167ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 16837713a1eSPhilipp Zabel } 169ca3de46bSShawn Guo 170ca3de46bSShawn Guo if ((val & TEMPSENSE0_FINISHED) == 0) { 171ca3de46bSShawn Guo dev_dbg(&tz->device, "temp measurement never finished\n"); 172ca3de46bSShawn Guo return -EAGAIN; 173ca3de46bSShawn Guo } 174ca3de46bSShawn Guo 175ca3de46bSShawn Guo n_meas = (val & TEMPSENSE0_TEMP_CNT_MASK) >> TEMPSENSE0_TEMP_CNT_SHIFT; 176ca3de46bSShawn Guo 177ae621557SLeonard Crestez /* See imx_init_calib() for formula derivation */ 178749e8be7SAnson Huang *temp = data->c2 - n_meas * data->c1; 179ca3de46bSShawn Guo 1803c94f17eSAnson Huang /* Update alarm value to next higher trip point for TEMPMON_IMX6Q */ 1813c94f17eSAnson Huang if (data->socdata->version == TEMPMON_IMX6Q) { 1823c94f17eSAnson Huang if (data->alarm_temp == data->temp_passive && 1833c94f17eSAnson Huang *temp >= data->temp_passive) 18437713a1eSPhilipp Zabel imx_set_alarm_temp(data, data->temp_critical); 1853c94f17eSAnson Huang if (data->alarm_temp == data->temp_critical && 1863c94f17eSAnson Huang *temp < data->temp_passive) { 18737713a1eSPhilipp Zabel imx_set_alarm_temp(data, data->temp_passive); 18817e8351aSSascha Hauer dev_dbg(&tz->device, "thermal alarm off: T < %d\n", 18937713a1eSPhilipp Zabel data->alarm_temp / 1000); 19037713a1eSPhilipp Zabel } 1913c94f17eSAnson Huang } 19237713a1eSPhilipp Zabel 19337713a1eSPhilipp Zabel if (*temp != data->last_temp) { 19417e8351aSSascha Hauer dev_dbg(&tz->device, "millicelsius: %d\n", *temp); 19537713a1eSPhilipp Zabel data->last_temp = *temp; 19637713a1eSPhilipp Zabel } 19737713a1eSPhilipp Zabel 19837713a1eSPhilipp Zabel /* Reenable alarm IRQ if temperature below alarm temperature */ 19937713a1eSPhilipp Zabel if (!data->irq_enabled && *temp < data->alarm_temp) { 20037713a1eSPhilipp Zabel data->irq_enabled = true; 20137713a1eSPhilipp Zabel enable_irq(data->irq); 202ca3de46bSShawn Guo } 203ca3de46bSShawn Guo 204ca3de46bSShawn Guo return 0; 205ca3de46bSShawn Guo } 206ca3de46bSShawn Guo 207ca3de46bSShawn Guo static int imx_get_mode(struct thermal_zone_device *tz, 208ca3de46bSShawn Guo enum thermal_device_mode *mode) 209ca3de46bSShawn Guo { 210ca3de46bSShawn Guo struct imx_thermal_data *data = tz->devdata; 211ca3de46bSShawn Guo 212ca3de46bSShawn Guo *mode = data->mode; 213ca3de46bSShawn Guo 214ca3de46bSShawn Guo return 0; 215ca3de46bSShawn Guo } 216ca3de46bSShawn Guo 217ca3de46bSShawn Guo static int imx_set_mode(struct thermal_zone_device *tz, 218ca3de46bSShawn Guo enum thermal_device_mode mode) 219ca3de46bSShawn Guo { 220ca3de46bSShawn Guo struct imx_thermal_data *data = tz->devdata; 22137713a1eSPhilipp Zabel struct regmap *map = data->tempmon; 222ca3de46bSShawn Guo 223ca3de46bSShawn Guo if (mode == THERMAL_DEVICE_ENABLED) { 224ca3de46bSShawn Guo tz->polling_delay = IMX_POLLING_DELAY; 225ca3de46bSShawn Guo tz->passive_delay = IMX_PASSIVE_DELAY; 22637713a1eSPhilipp Zabel 22737713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 22837713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP); 22937713a1eSPhilipp Zabel 23037713a1eSPhilipp Zabel if (!data->irq_enabled) { 23137713a1eSPhilipp Zabel data->irq_enabled = true; 23237713a1eSPhilipp Zabel enable_irq(data->irq); 23337713a1eSPhilipp Zabel } 234ca3de46bSShawn Guo } else { 23537713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP); 23637713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 23737713a1eSPhilipp Zabel 238ca3de46bSShawn Guo tz->polling_delay = 0; 239ca3de46bSShawn Guo tz->passive_delay = 0; 24037713a1eSPhilipp Zabel 24137713a1eSPhilipp Zabel if (data->irq_enabled) { 24237713a1eSPhilipp Zabel disable_irq(data->irq); 24337713a1eSPhilipp Zabel data->irq_enabled = false; 24437713a1eSPhilipp Zabel } 245ca3de46bSShawn Guo } 246ca3de46bSShawn Guo 247ca3de46bSShawn Guo data->mode = mode; 2480e70f466SSrinivas Pandruvada thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED); 249ca3de46bSShawn Guo 250ca3de46bSShawn Guo return 0; 251ca3de46bSShawn Guo } 252ca3de46bSShawn Guo 253ca3de46bSShawn Guo static int imx_get_trip_type(struct thermal_zone_device *tz, int trip, 254ca3de46bSShawn Guo enum thermal_trip_type *type) 255ca3de46bSShawn Guo { 256ca3de46bSShawn Guo *type = (trip == IMX_TRIP_PASSIVE) ? THERMAL_TRIP_PASSIVE : 257ca3de46bSShawn Guo THERMAL_TRIP_CRITICAL; 258ca3de46bSShawn Guo return 0; 259ca3de46bSShawn Guo } 260ca3de46bSShawn Guo 26117e8351aSSascha Hauer static int imx_get_crit_temp(struct thermal_zone_device *tz, int *temp) 262ca3de46bSShawn Guo { 263017e5142SPhilipp Zabel struct imx_thermal_data *data = tz->devdata; 264017e5142SPhilipp Zabel 265017e5142SPhilipp Zabel *temp = data->temp_critical; 266ca3de46bSShawn Guo return 0; 267ca3de46bSShawn Guo } 268ca3de46bSShawn Guo 269ca3de46bSShawn Guo static int imx_get_trip_temp(struct thermal_zone_device *tz, int trip, 27017e8351aSSascha Hauer int *temp) 271ca3de46bSShawn Guo { 272017e5142SPhilipp Zabel struct imx_thermal_data *data = tz->devdata; 273017e5142SPhilipp Zabel 274017e5142SPhilipp Zabel *temp = (trip == IMX_TRIP_PASSIVE) ? data->temp_passive : 275017e5142SPhilipp Zabel data->temp_critical; 276017e5142SPhilipp Zabel return 0; 277017e5142SPhilipp Zabel } 278017e5142SPhilipp Zabel 279017e5142SPhilipp Zabel static int imx_set_trip_temp(struct thermal_zone_device *tz, int trip, 28017e8351aSSascha Hauer int temp) 281017e5142SPhilipp Zabel { 282017e5142SPhilipp Zabel struct imx_thermal_data *data = tz->devdata; 283017e5142SPhilipp Zabel 284a2291badSTim Harvey /* do not allow changing critical threshold */ 285017e5142SPhilipp Zabel if (trip == IMX_TRIP_CRITICAL) 286017e5142SPhilipp Zabel return -EPERM; 287017e5142SPhilipp Zabel 288a2291badSTim Harvey /* do not allow passive to be set higher than critical */ 289a2291badSTim Harvey if (temp < 0 || temp > data->temp_critical) 290017e5142SPhilipp Zabel return -EINVAL; 291017e5142SPhilipp Zabel 292017e5142SPhilipp Zabel data->temp_passive = temp; 293017e5142SPhilipp Zabel 29437713a1eSPhilipp Zabel imx_set_alarm_temp(data, temp); 29537713a1eSPhilipp Zabel 296ca3de46bSShawn Guo return 0; 297ca3de46bSShawn Guo } 298ca3de46bSShawn Guo 299ca3de46bSShawn Guo static int imx_bind(struct thermal_zone_device *tz, 300ca3de46bSShawn Guo struct thermal_cooling_device *cdev) 301ca3de46bSShawn Guo { 302ca3de46bSShawn Guo int ret; 303ca3de46bSShawn Guo 304ca3de46bSShawn Guo ret = thermal_zone_bind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev, 305ca3de46bSShawn Guo THERMAL_NO_LIMIT, 3066cd9e9f6SKapileshwar Singh THERMAL_NO_LIMIT, 3076cd9e9f6SKapileshwar Singh THERMAL_WEIGHT_DEFAULT); 308ca3de46bSShawn Guo if (ret) { 309ca3de46bSShawn Guo dev_err(&tz->device, 310ca3de46bSShawn Guo "binding zone %s with cdev %s failed:%d\n", 311ca3de46bSShawn Guo tz->type, cdev->type, ret); 312ca3de46bSShawn Guo return ret; 313ca3de46bSShawn Guo } 314ca3de46bSShawn Guo 315ca3de46bSShawn Guo return 0; 316ca3de46bSShawn Guo } 317ca3de46bSShawn Guo 318ca3de46bSShawn Guo static int imx_unbind(struct thermal_zone_device *tz, 319ca3de46bSShawn Guo struct thermal_cooling_device *cdev) 320ca3de46bSShawn Guo { 321ca3de46bSShawn Guo int ret; 322ca3de46bSShawn Guo 323ca3de46bSShawn Guo ret = thermal_zone_unbind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev); 324ca3de46bSShawn Guo if (ret) { 325ca3de46bSShawn Guo dev_err(&tz->device, 326ca3de46bSShawn Guo "unbinding zone %s with cdev %s failed:%d\n", 327ca3de46bSShawn Guo tz->type, cdev->type, ret); 328ca3de46bSShawn Guo return ret; 329ca3de46bSShawn Guo } 330ca3de46bSShawn Guo 331ca3de46bSShawn Guo return 0; 332ca3de46bSShawn Guo } 333ca3de46bSShawn Guo 334cbb07bb3SEduardo Valentin static struct thermal_zone_device_ops imx_tz_ops = { 335ca3de46bSShawn Guo .bind = imx_bind, 336ca3de46bSShawn Guo .unbind = imx_unbind, 337ca3de46bSShawn Guo .get_temp = imx_get_temp, 338ca3de46bSShawn Guo .get_mode = imx_get_mode, 339ca3de46bSShawn Guo .set_mode = imx_set_mode, 340ca3de46bSShawn Guo .get_trip_type = imx_get_trip_type, 341ca3de46bSShawn Guo .get_trip_temp = imx_get_trip_temp, 342ca3de46bSShawn Guo .get_crit_temp = imx_get_crit_temp, 343017e5142SPhilipp Zabel .set_trip_temp = imx_set_trip_temp, 344ca3de46bSShawn Guo }; 345ca3de46bSShawn Guo 346e4bb2240SUwe Kleine-König static int imx_init_calib(struct platform_device *pdev, u32 ocotp_ana1) 347ca3de46bSShawn Guo { 348ca3de46bSShawn Guo struct imx_thermal_data *data = platform_get_drvdata(pdev); 3494e5f61caSUwe Kleine-König int n1; 350749e8be7SAnson Huang u64 temp64; 351ca3de46bSShawn Guo 352e4bb2240SUwe Kleine-König if (ocotp_ana1 == 0 || ocotp_ana1 == ~0) { 353ca3de46bSShawn Guo dev_err(&pdev->dev, "invalid sensor calibration data\n"); 354ca3de46bSShawn Guo return -EINVAL; 355ca3de46bSShawn Guo } 356ca3de46bSShawn Guo 357ca3de46bSShawn Guo /* 358c5bbdb4bSUwe Kleine-König * The sensor is calibrated at 25 °C (aka T1) and the value measured 359c5bbdb4bSUwe Kleine-König * (aka N1) at this temperature is provided in bits [31:20] in the 360c5bbdb4bSUwe Kleine-König * i.MX's OCOTP value ANA1. 361c5bbdb4bSUwe Kleine-König * To find the actual temperature T, the following formula has to be used 362c5bbdb4bSUwe Kleine-König * when reading value n from the sensor: 363c5bbdb4bSUwe Kleine-König * 3644e5f61caSUwe Kleine-König * T = T1 + (N - N1) / (0.4148468 - 0.0015423 * N1) °C + 3.580661 °C 3654e5f61caSUwe Kleine-König * = [T1' - N1 / (0.4148468 - 0.0015423 * N1) °C] + N / (0.4148468 - 0.0015423 * N1) °C 3664e5f61caSUwe Kleine-König * = [T1' + N1 / (0.0015423 * N1 - 0.4148468) °C] - N / (0.0015423 * N1 - 0.4148468) °C 367c5bbdb4bSUwe Kleine-König * = c2 - c1 * N 368c5bbdb4bSUwe Kleine-König * 369c5bbdb4bSUwe Kleine-König * with 370c5bbdb4bSUwe Kleine-König * 3714e5f61caSUwe Kleine-König * T1' = 28.580661 °C 3724e5f61caSUwe Kleine-König * c1 = 1 / (0.0015423 * N1 - 0.4297157) °C 3734e5f61caSUwe Kleine-König * c2 = T1' + N1 / (0.0015423 * N1 - 0.4148468) °C 3744e5f61caSUwe Kleine-König * = T1' + N1 * c1 375ca3de46bSShawn Guo */ 376e4bb2240SUwe Kleine-König n1 = ocotp_ana1 >> 20; 377ca3de46bSShawn Guo 3784e5f61caSUwe Kleine-König temp64 = 10000000; /* use 10^7 as fixed point constant for values in formula */ 379c5bbdb4bSUwe Kleine-König temp64 *= 1000; /* to get result in °mC */ 3804e5f61caSUwe Kleine-König do_div(temp64, 15423 * n1 - 4148468); 381749e8be7SAnson Huang data->c1 = temp64; 3824e5f61caSUwe Kleine-König data->c2 = n1 * data->c1 + 28581; 383ca3de46bSShawn Guo 384ae621557SLeonard Crestez return 0; 385a2291badSTim Harvey } 386a2291badSTim Harvey 387e4bb2240SUwe Kleine-König static void imx_init_temp_grade(struct platform_device *pdev, u32 ocotp_mem0) 388ae621557SLeonard Crestez { 389ae621557SLeonard Crestez struct imx_thermal_data *data = platform_get_drvdata(pdev); 390ae621557SLeonard Crestez 391a2291badSTim Harvey /* The maximum die temp is specified by the Temperature Grade */ 392e4bb2240SUwe Kleine-König switch ((ocotp_mem0 >> 6) & 0x3) { 393339d7492SUwe Kleine-König case 0: /* Commercial (0 to 95 °C) */ 394a2291badSTim Harvey data->temp_grade = "Commercial"; 395a2291badSTim Harvey data->temp_max = 95000; 396a2291badSTim Harvey break; 397339d7492SUwe Kleine-König case 1: /* Extended Commercial (-20 °C to 105 °C) */ 398a2291badSTim Harvey data->temp_grade = "Extended Commercial"; 399a2291badSTim Harvey data->temp_max = 105000; 400a2291badSTim Harvey break; 401339d7492SUwe Kleine-König case 2: /* Industrial (-40 °C to 105 °C) */ 402a2291badSTim Harvey data->temp_grade = "Industrial"; 403a2291badSTim Harvey data->temp_max = 105000; 404a2291badSTim Harvey break; 405339d7492SUwe Kleine-König case 3: /* Automotive (-40 °C to 125 °C) */ 406a2291badSTim Harvey data->temp_grade = "Automotive"; 407a2291badSTim Harvey data->temp_max = 125000; 408a2291badSTim Harvey break; 409a2291badSTim Harvey } 410017e5142SPhilipp Zabel 411017e5142SPhilipp Zabel /* 412339d7492SUwe Kleine-König * Set the critical trip point at 5 °C under max 413339d7492SUwe Kleine-König * Set the passive trip point at 10 °C under max (changeable via sysfs) 414017e5142SPhilipp Zabel */ 415a2291badSTim Harvey data->temp_critical = data->temp_max - (1000 * 5); 416a2291badSTim Harvey data->temp_passive = data->temp_max - (1000 * 10); 417ae621557SLeonard Crestez } 418ae621557SLeonard Crestez 419ae621557SLeonard Crestez static int imx_init_from_tempmon_data(struct platform_device *pdev) 420ae621557SLeonard Crestez { 421ae621557SLeonard Crestez struct regmap *map; 422ae621557SLeonard Crestez int ret; 423ae621557SLeonard Crestez u32 val; 424ae621557SLeonard Crestez 425ae621557SLeonard Crestez map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, 426ae621557SLeonard Crestez "fsl,tempmon-data"); 427ae621557SLeonard Crestez if (IS_ERR(map)) { 428ae621557SLeonard Crestez ret = PTR_ERR(map); 429ae621557SLeonard Crestez dev_err(&pdev->dev, "failed to get sensor regmap: %d\n", ret); 430ae621557SLeonard Crestez return ret; 431ae621557SLeonard Crestez } 432ae621557SLeonard Crestez 433ae621557SLeonard Crestez ret = regmap_read(map, OCOTP_ANA1, &val); 434ae621557SLeonard Crestez if (ret) { 435ae621557SLeonard Crestez dev_err(&pdev->dev, "failed to read sensor data: %d\n", ret); 436ae621557SLeonard Crestez return ret; 437ae621557SLeonard Crestez } 438ae621557SLeonard Crestez ret = imx_init_calib(pdev, val); 439ae621557SLeonard Crestez if (ret) 440ae621557SLeonard Crestez return ret; 441ae621557SLeonard Crestez 442ae621557SLeonard Crestez ret = regmap_read(map, OCOTP_MEM0, &val); 443ae621557SLeonard Crestez if (ret) { 444ae621557SLeonard Crestez dev_err(&pdev->dev, "failed to read sensor data: %d\n", ret); 445ae621557SLeonard Crestez return ret; 446ae621557SLeonard Crestez } 447ae621557SLeonard Crestez imx_init_temp_grade(pdev, val); 448ae621557SLeonard Crestez 449ae621557SLeonard Crestez return 0; 450ae621557SLeonard Crestez } 451ae621557SLeonard Crestez 452ae621557SLeonard Crestez static int imx_init_from_nvmem_cells(struct platform_device *pdev) 453ae621557SLeonard Crestez { 454ae621557SLeonard Crestez int ret; 455ae621557SLeonard Crestez u32 val; 456ae621557SLeonard Crestez 457ae621557SLeonard Crestez ret = nvmem_cell_read_u32(&pdev->dev, "calib", &val); 458ae621557SLeonard Crestez if (ret) 459ae621557SLeonard Crestez return ret; 460ae621557SLeonard Crestez imx_init_calib(pdev, val); 461ae621557SLeonard Crestez 462ae621557SLeonard Crestez ret = nvmem_cell_read_u32(&pdev->dev, "temp_grade", &val); 463ae621557SLeonard Crestez if (ret) 464ae621557SLeonard Crestez return ret; 465ae621557SLeonard Crestez imx_init_temp_grade(pdev, val); 466017e5142SPhilipp Zabel 467ca3de46bSShawn Guo return 0; 468ca3de46bSShawn Guo } 469ca3de46bSShawn Guo 47037713a1eSPhilipp Zabel static irqreturn_t imx_thermal_alarm_irq(int irq, void *dev) 47137713a1eSPhilipp Zabel { 47237713a1eSPhilipp Zabel struct imx_thermal_data *data = dev; 47337713a1eSPhilipp Zabel 47437713a1eSPhilipp Zabel disable_irq_nosync(irq); 47537713a1eSPhilipp Zabel data->irq_enabled = false; 47637713a1eSPhilipp Zabel 47737713a1eSPhilipp Zabel return IRQ_WAKE_THREAD; 47837713a1eSPhilipp Zabel } 47937713a1eSPhilipp Zabel 48037713a1eSPhilipp Zabel static irqreturn_t imx_thermal_alarm_irq_thread(int irq, void *dev) 48137713a1eSPhilipp Zabel { 48237713a1eSPhilipp Zabel struct imx_thermal_data *data = dev; 48337713a1eSPhilipp Zabel 48417e8351aSSascha Hauer dev_dbg(&data->tz->device, "THERMAL ALARM: T > %d\n", 48537713a1eSPhilipp Zabel data->alarm_temp / 1000); 48637713a1eSPhilipp Zabel 4870e70f466SSrinivas Pandruvada thermal_zone_device_update(data->tz, THERMAL_EVENT_UNSPECIFIED); 48837713a1eSPhilipp Zabel 48937713a1eSPhilipp Zabel return IRQ_HANDLED; 49037713a1eSPhilipp Zabel } 49137713a1eSPhilipp Zabel 4923c94f17eSAnson Huang static const struct of_device_id of_imx_thermal_match[] = { 4933c94f17eSAnson Huang { .compatible = "fsl,imx6q-tempmon", .data = &thermal_imx6q_data, }, 4943c94f17eSAnson Huang { .compatible = "fsl,imx6sx-tempmon", .data = &thermal_imx6sx_data, }, 4953c94f17eSAnson Huang { /* end */ } 4963c94f17eSAnson Huang }; 4973c94f17eSAnson Huang MODULE_DEVICE_TABLE(of, of_imx_thermal_match); 4983c94f17eSAnson Huang 499ca3de46bSShawn Guo static int imx_thermal_probe(struct platform_device *pdev) 500ca3de46bSShawn Guo { 501ca3de46bSShawn Guo struct imx_thermal_data *data; 502ca3de46bSShawn Guo struct regmap *map; 50337713a1eSPhilipp Zabel int measure_freq; 504ca3de46bSShawn Guo int ret; 505ca3de46bSShawn Guo 506ca3de46bSShawn Guo data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); 507ca3de46bSShawn Guo if (!data) 508ca3de46bSShawn Guo return -ENOMEM; 509ca3de46bSShawn Guo 510ca3de46bSShawn Guo map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "fsl,tempmon"); 511ca3de46bSShawn Guo if (IS_ERR(map)) { 512ca3de46bSShawn Guo ret = PTR_ERR(map); 513ca3de46bSShawn Guo dev_err(&pdev->dev, "failed to get tempmon regmap: %d\n", ret); 514ca3de46bSShawn Guo return ret; 515ca3de46bSShawn Guo } 516ca3de46bSShawn Guo data->tempmon = map; 517ca3de46bSShawn Guo 518829bc78aSCorentin LABBE data->socdata = of_device_get_match_data(&pdev->dev); 5198b051ec3SShailendra Verma if (!data->socdata) { 5208b051ec3SShailendra Verma dev_err(&pdev->dev, "no device match found\n"); 5218b051ec3SShailendra Verma return -ENODEV; 5228b051ec3SShailendra Verma } 5233c94f17eSAnson Huang 5243c94f17eSAnson Huang /* make sure the IRQ flag is clear before enabling irq on i.MX6SX */ 5253c94f17eSAnson Huang if (data->socdata->version == TEMPMON_IMX6SX) { 5263c94f17eSAnson Huang regmap_write(map, MISC1 + REG_CLR, MISC1_IRQ_TEMPHIGH | 5273c94f17eSAnson Huang MISC1_IRQ_TEMPLOW | MISC1_IRQ_TEMPPANIC); 5283c94f17eSAnson Huang /* 5293c94f17eSAnson Huang * reset value of LOW ALARM is incorrect, set it to lowest 5303c94f17eSAnson Huang * value to avoid false trigger of low alarm. 5313c94f17eSAnson Huang */ 5323c94f17eSAnson Huang regmap_write(map, TEMPSENSE2 + REG_SET, 5333c94f17eSAnson Huang TEMPSENSE2_LOW_VALUE_MASK); 5343c94f17eSAnson Huang } 5353c94f17eSAnson Huang 53637713a1eSPhilipp Zabel data->irq = platform_get_irq(pdev, 0); 53737713a1eSPhilipp Zabel if (data->irq < 0) 53837713a1eSPhilipp Zabel return data->irq; 53937713a1eSPhilipp Zabel 540ca3de46bSShawn Guo platform_set_drvdata(pdev, data); 541ca3de46bSShawn Guo 542ae621557SLeonard Crestez if (of_find_property(pdev->dev.of_node, "nvmem-cells", NULL)) { 543ae621557SLeonard Crestez ret = imx_init_from_nvmem_cells(pdev); 544ae621557SLeonard Crestez if (ret == -EPROBE_DEFER) 545ca3de46bSShawn Guo return ret; 546ae621557SLeonard Crestez if (ret) { 547ae621557SLeonard Crestez dev_err(&pdev->dev, "failed to init from nvmem: %d\n", 548ae621557SLeonard Crestez ret); 549ae621557SLeonard Crestez return ret; 550ae621557SLeonard Crestez } 551ae621557SLeonard Crestez } else { 552ae621557SLeonard Crestez ret = imx_init_from_tempmon_data(pdev); 553ae621557SLeonard Crestez if (ret) { 554ae621557SLeonard Crestez dev_err(&pdev->dev, "failed to init from from fsl,tempmon-data\n"); 555ae621557SLeonard Crestez return ret; 556ae621557SLeonard Crestez } 557ca3de46bSShawn Guo } 558ca3de46bSShawn Guo 559ca3de46bSShawn Guo /* Make sure sensor is in known good state for measurements */ 560ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 561ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP); 562ca3de46bSShawn Guo regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ); 563ca3de46bSShawn Guo regmap_write(map, MISC0 + REG_SET, MISC0_REFTOP_SELBIASOFF); 564ca3de46bSShawn Guo regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 565ca3de46bSShawn Guo 5664d753aa7SViresh Kumar data->policy = cpufreq_cpu_get(0); 5674d753aa7SViresh Kumar if (!data->policy) { 5684d753aa7SViresh Kumar pr_debug("%s: CPUFreq policy not found\n", __func__); 5694d753aa7SViresh Kumar return -EPROBE_DEFER; 5704d753aa7SViresh Kumar } 5714d753aa7SViresh Kumar 5724d753aa7SViresh Kumar data->cdev = cpufreq_cooling_register(data->policy); 573ca3de46bSShawn Guo if (IS_ERR(data->cdev)) { 574ca3de46bSShawn Guo ret = PTR_ERR(data->cdev); 575ca3de46bSShawn Guo dev_err(&pdev->dev, 5764d753aa7SViresh Kumar "failed to register cpufreq cooling device: %d\n", ret); 5774d753aa7SViresh Kumar cpufreq_cpu_put(data->policy); 578ca3de46bSShawn Guo return ret; 579ca3de46bSShawn Guo } 580ca3de46bSShawn Guo 58190a21ff5SHeiner Kallweit data->thermal_clk = devm_clk_get(&pdev->dev, NULL); 58290a21ff5SHeiner Kallweit if (IS_ERR(data->thermal_clk)) { 58390a21ff5SHeiner Kallweit ret = PTR_ERR(data->thermal_clk); 58490a21ff5SHeiner Kallweit if (ret != -EPROBE_DEFER) 58590a21ff5SHeiner Kallweit dev_err(&pdev->dev, 58690a21ff5SHeiner Kallweit "failed to get thermal clk: %d\n", ret); 58790a21ff5SHeiner Kallweit cpufreq_cooling_unregister(data->cdev); 5884d753aa7SViresh Kumar cpufreq_cpu_put(data->policy); 58990a21ff5SHeiner Kallweit return ret; 59090a21ff5SHeiner Kallweit } 59190a21ff5SHeiner Kallweit 59290a21ff5SHeiner Kallweit /* 59390a21ff5SHeiner Kallweit * Thermal sensor needs clk on to get correct value, normally 59490a21ff5SHeiner Kallweit * we should enable its clk before taking measurement and disable 59590a21ff5SHeiner Kallweit * clk after measurement is done, but if alarm function is enabled, 59690a21ff5SHeiner Kallweit * hardware will auto measure the temperature periodically, so we 59790a21ff5SHeiner Kallweit * need to keep the clk always on for alarm function. 59890a21ff5SHeiner Kallweit */ 59990a21ff5SHeiner Kallweit ret = clk_prepare_enable(data->thermal_clk); 60090a21ff5SHeiner Kallweit if (ret) { 60190a21ff5SHeiner Kallweit dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret); 60290a21ff5SHeiner Kallweit cpufreq_cooling_unregister(data->cdev); 6034d753aa7SViresh Kumar cpufreq_cpu_put(data->policy); 60490a21ff5SHeiner Kallweit return ret; 60590a21ff5SHeiner Kallweit } 60690a21ff5SHeiner Kallweit 607ca3de46bSShawn Guo data->tz = thermal_zone_device_register("imx_thermal_zone", 608017e5142SPhilipp Zabel IMX_TRIP_NUM, 609017e5142SPhilipp Zabel BIT(IMX_TRIP_PASSIVE), data, 610ca3de46bSShawn Guo &imx_tz_ops, NULL, 611ca3de46bSShawn Guo IMX_PASSIVE_DELAY, 612ca3de46bSShawn Guo IMX_POLLING_DELAY); 613ca3de46bSShawn Guo if (IS_ERR(data->tz)) { 614ca3de46bSShawn Guo ret = PTR_ERR(data->tz); 615ca3de46bSShawn Guo dev_err(&pdev->dev, 616ca3de46bSShawn Guo "failed to register thermal zone device %d\n", ret); 61790a21ff5SHeiner Kallweit clk_disable_unprepare(data->thermal_clk); 618ca3de46bSShawn Guo cpufreq_cooling_unregister(data->cdev); 6194d753aa7SViresh Kumar cpufreq_cpu_put(data->policy); 620ca3de46bSShawn Guo return ret; 621ca3de46bSShawn Guo } 622ca3de46bSShawn Guo 623a2291badSTim Harvey dev_info(&pdev->dev, "%s CPU temperature grade - max:%dC" 624a2291badSTim Harvey " critical:%dC passive:%dC\n", data->temp_grade, 625a2291badSTim Harvey data->temp_max / 1000, data->temp_critical / 1000, 626a2291badSTim Harvey data->temp_passive / 1000); 627a2291badSTim Harvey 62837713a1eSPhilipp Zabel /* Enable measurements at ~ 10 Hz */ 62937713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ); 63037713a1eSPhilipp Zabel measure_freq = DIV_ROUND_UP(32768, 10); /* 10 Hz */ 63137713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE1 + REG_SET, measure_freq); 63237713a1eSPhilipp Zabel imx_set_alarm_temp(data, data->temp_passive); 6333c94f17eSAnson Huang 6343c94f17eSAnson Huang if (data->socdata->version == TEMPMON_IMX6SX) 6353c94f17eSAnson Huang imx_set_panic_temp(data, data->temp_critical); 6363c94f17eSAnson Huang 63737713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 63837713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP); 63937713a1eSPhilipp Zabel 64084866ee5SBai Ping ret = devm_request_threaded_irq(&pdev->dev, data->irq, 64184866ee5SBai Ping imx_thermal_alarm_irq, imx_thermal_alarm_irq_thread, 64284866ee5SBai Ping 0, "imx_thermal", data); 64384866ee5SBai Ping if (ret < 0) { 64484866ee5SBai Ping dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret); 64584866ee5SBai Ping clk_disable_unprepare(data->thermal_clk); 64684866ee5SBai Ping thermal_zone_device_unregister(data->tz); 64784866ee5SBai Ping cpufreq_cooling_unregister(data->cdev); 6484d753aa7SViresh Kumar cpufreq_cpu_put(data->policy); 64984866ee5SBai Ping return ret; 65084866ee5SBai Ping } 65184866ee5SBai Ping 65237713a1eSPhilipp Zabel data->irq_enabled = true; 653ca3de46bSShawn Guo data->mode = THERMAL_DEVICE_ENABLED; 654ca3de46bSShawn Guo 655ca3de46bSShawn Guo return 0; 656ca3de46bSShawn Guo } 657ca3de46bSShawn Guo 658ca3de46bSShawn Guo static int imx_thermal_remove(struct platform_device *pdev) 659ca3de46bSShawn Guo { 660ca3de46bSShawn Guo struct imx_thermal_data *data = platform_get_drvdata(pdev); 66137713a1eSPhilipp Zabel struct regmap *map = data->tempmon; 66237713a1eSPhilipp Zabel 66337713a1eSPhilipp Zabel /* Disable measurements */ 66437713a1eSPhilipp Zabel regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 665329fe7b1SAnson Huang if (!IS_ERR(data->thermal_clk)) 666329fe7b1SAnson Huang clk_disable_unprepare(data->thermal_clk); 667ca3de46bSShawn Guo 668ca3de46bSShawn Guo thermal_zone_device_unregister(data->tz); 669ca3de46bSShawn Guo cpufreq_cooling_unregister(data->cdev); 6704d753aa7SViresh Kumar cpufreq_cpu_put(data->policy); 671ca3de46bSShawn Guo 672ca3de46bSShawn Guo return 0; 673ca3de46bSShawn Guo } 674ca3de46bSShawn Guo 675ca3de46bSShawn Guo #ifdef CONFIG_PM_SLEEP 676ca3de46bSShawn Guo static int imx_thermal_suspend(struct device *dev) 677ca3de46bSShawn Guo { 678ca3de46bSShawn Guo struct imx_thermal_data *data = dev_get_drvdata(dev); 679ca3de46bSShawn Guo struct regmap *map = data->tempmon; 680ca3de46bSShawn Guo 681ca3de46bSShawn Guo /* 682b46cce59SAnson Huang * Need to disable thermal sensor, otherwise, when thermal core 683b46cce59SAnson Huang * try to get temperature before thermal sensor resume, a wrong 684b46cce59SAnson Huang * temperature will be read as the thermal sensor is powered 685b46cce59SAnson Huang * down. 686ca3de46bSShawn Guo */ 687b46cce59SAnson Huang regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP); 688b46cce59SAnson Huang regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN); 689b46cce59SAnson Huang data->mode = THERMAL_DEVICE_DISABLED; 690d26eef8bSAnson Huang clk_disable_unprepare(data->thermal_clk); 691ca3de46bSShawn Guo 692ca3de46bSShawn Guo return 0; 693ca3de46bSShawn Guo } 694ca3de46bSShawn Guo 695ca3de46bSShawn Guo static int imx_thermal_resume(struct device *dev) 696ca3de46bSShawn Guo { 697b46cce59SAnson Huang struct imx_thermal_data *data = dev_get_drvdata(dev); 698b46cce59SAnson Huang struct regmap *map = data->tempmon; 699e3bdc8d7SArvind Yadav int ret; 700b46cce59SAnson Huang 701e3bdc8d7SArvind Yadav ret = clk_prepare_enable(data->thermal_clk); 702e3bdc8d7SArvind Yadav if (ret) 703e3bdc8d7SArvind Yadav return ret; 704b46cce59SAnson Huang /* Enabled thermal sensor after resume */ 705b46cce59SAnson Huang regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN); 706b46cce59SAnson Huang regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP); 707b46cce59SAnson Huang data->mode = THERMAL_DEVICE_ENABLED; 708b46cce59SAnson Huang 709ca3de46bSShawn Guo return 0; 710ca3de46bSShawn Guo } 711ca3de46bSShawn Guo #endif 712ca3de46bSShawn Guo 713ca3de46bSShawn Guo static SIMPLE_DEV_PM_OPS(imx_thermal_pm_ops, 714ca3de46bSShawn Guo imx_thermal_suspend, imx_thermal_resume); 715ca3de46bSShawn Guo 716ca3de46bSShawn Guo static struct platform_driver imx_thermal = { 717ca3de46bSShawn Guo .driver = { 718ca3de46bSShawn Guo .name = "imx_thermal", 719ca3de46bSShawn Guo .pm = &imx_thermal_pm_ops, 720ca3de46bSShawn Guo .of_match_table = of_imx_thermal_match, 721ca3de46bSShawn Guo }, 722ca3de46bSShawn Guo .probe = imx_thermal_probe, 723ca3de46bSShawn Guo .remove = imx_thermal_remove, 724ca3de46bSShawn Guo }; 725ca3de46bSShawn Guo module_platform_driver(imx_thermal); 726ca3de46bSShawn Guo 727ca3de46bSShawn Guo MODULE_AUTHOR("Freescale Semiconductor, Inc."); 728ca3de46bSShawn Guo MODULE_DESCRIPTION("Thermal driver for Freescale i.MX SoCs"); 729ca3de46bSShawn Guo MODULE_LICENSE("GPL v2"); 730ca3de46bSShawn Guo MODULE_ALIAS("platform:imx-thermal"); 731