1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Copyright 2013 Freescale Semiconductor, Inc. 4 5 #include <linux/clk.h> 6 #include <linux/cpu.h> 7 #include <linux/cpufreq.h> 8 #include <linux/cpu_cooling.h> 9 #include <linux/delay.h> 10 #include <linux/device.h> 11 #include <linux/init.h> 12 #include <linux/interrupt.h> 13 #include <linux/io.h> 14 #include <linux/kernel.h> 15 #include <linux/mfd/syscon.h> 16 #include <linux/module.h> 17 #include <linux/of.h> 18 #include <linux/of_device.h> 19 #include <linux/platform_device.h> 20 #include <linux/regmap.h> 21 #include <linux/slab.h> 22 #include <linux/thermal.h> 23 #include <linux/types.h> 24 #include <linux/nvmem-consumer.h> 25 26 #define REG_SET 0x4 27 #define REG_CLR 0x8 28 #define REG_TOG 0xc 29 30 /* i.MX6 specific */ 31 #define IMX6_MISC0 0x0150 32 #define IMX6_MISC0_REFTOP_SELBIASOFF (1 << 3) 33 #define IMX6_MISC1 0x0160 34 #define IMX6_MISC1_IRQ_TEMPHIGH (1 << 29) 35 /* Below LOW and PANIC bits are only for TEMPMON_IMX6SX */ 36 #define IMX6_MISC1_IRQ_TEMPLOW (1 << 28) 37 #define IMX6_MISC1_IRQ_TEMPPANIC (1 << 27) 38 39 #define IMX6_TEMPSENSE0 0x0180 40 #define IMX6_TEMPSENSE0_ALARM_VALUE_SHIFT 20 41 #define IMX6_TEMPSENSE0_ALARM_VALUE_MASK (0xfff << 20) 42 #define IMX6_TEMPSENSE0_TEMP_CNT_SHIFT 8 43 #define IMX6_TEMPSENSE0_TEMP_CNT_MASK (0xfff << 8) 44 #define IMX6_TEMPSENSE0_FINISHED (1 << 2) 45 #define IMX6_TEMPSENSE0_MEASURE_TEMP (1 << 1) 46 #define IMX6_TEMPSENSE0_POWER_DOWN (1 << 0) 47 48 #define IMX6_TEMPSENSE1 0x0190 49 #define IMX6_TEMPSENSE1_MEASURE_FREQ 0xffff 50 #define IMX6_TEMPSENSE1_MEASURE_FREQ_SHIFT 0 51 52 #define OCOTP_MEM0 0x0480 53 #define OCOTP_ANA1 0x04e0 54 55 /* Below TEMPSENSE2 is only for TEMPMON_IMX6SX */ 56 #define IMX6_TEMPSENSE2 0x0290 57 #define IMX6_TEMPSENSE2_LOW_VALUE_SHIFT 0 58 #define IMX6_TEMPSENSE2_LOW_VALUE_MASK 0xfff 59 #define IMX6_TEMPSENSE2_PANIC_VALUE_SHIFT 16 60 #define IMX6_TEMPSENSE2_PANIC_VALUE_MASK 0xfff0000 61 62 /* i.MX7 specific */ 63 #define IMX7_ANADIG_DIGPROG 0x800 64 #define IMX7_TEMPSENSE0 0x300 65 #define IMX7_TEMPSENSE0_PANIC_ALARM_SHIFT 18 66 #define IMX7_TEMPSENSE0_PANIC_ALARM_MASK (0x1ff << 18) 67 #define IMX7_TEMPSENSE0_HIGH_ALARM_SHIFT 9 68 #define IMX7_TEMPSENSE0_HIGH_ALARM_MASK (0x1ff << 9) 69 #define IMX7_TEMPSENSE0_LOW_ALARM_SHIFT 0 70 #define IMX7_TEMPSENSE0_LOW_ALARM_MASK 0x1ff 71 72 #define IMX7_TEMPSENSE1 0x310 73 #define IMX7_TEMPSENSE1_MEASURE_FREQ_SHIFT 16 74 #define IMX7_TEMPSENSE1_MEASURE_FREQ_MASK (0xffff << 16) 75 #define IMX7_TEMPSENSE1_FINISHED (1 << 11) 76 #define IMX7_TEMPSENSE1_MEASURE_TEMP (1 << 10) 77 #define IMX7_TEMPSENSE1_POWER_DOWN (1 << 9) 78 #define IMX7_TEMPSENSE1_TEMP_VALUE_SHIFT 0 79 #define IMX7_TEMPSENSE1_TEMP_VALUE_MASK 0x1ff 80 81 /* The driver supports 1 passive trip point and 1 critical trip point */ 82 enum imx_thermal_trip { 83 IMX_TRIP_PASSIVE, 84 IMX_TRIP_CRITICAL, 85 IMX_TRIP_NUM, 86 }; 87 88 #define IMX_POLLING_DELAY 2000 /* millisecond */ 89 #define IMX_PASSIVE_DELAY 1000 90 91 #define TEMPMON_IMX6Q 1 92 #define TEMPMON_IMX6SX 2 93 #define TEMPMON_IMX7D 3 94 95 struct thermal_soc_data { 96 u32 version; 97 98 u32 sensor_ctrl; 99 u32 power_down_mask; 100 u32 measure_temp_mask; 101 102 u32 measure_freq_ctrl; 103 u32 measure_freq_mask; 104 u32 measure_freq_shift; 105 106 u32 temp_data; 107 u32 temp_value_mask; 108 u32 temp_value_shift; 109 u32 temp_valid_mask; 110 111 u32 panic_alarm_ctrl; 112 u32 panic_alarm_mask; 113 u32 panic_alarm_shift; 114 115 u32 high_alarm_ctrl; 116 u32 high_alarm_mask; 117 u32 high_alarm_shift; 118 119 u32 low_alarm_ctrl; 120 u32 low_alarm_mask; 121 u32 low_alarm_shift; 122 }; 123 124 static struct thermal_soc_data thermal_imx6q_data = { 125 .version = TEMPMON_IMX6Q, 126 127 .sensor_ctrl = IMX6_TEMPSENSE0, 128 .power_down_mask = IMX6_TEMPSENSE0_POWER_DOWN, 129 .measure_temp_mask = IMX6_TEMPSENSE0_MEASURE_TEMP, 130 131 .measure_freq_ctrl = IMX6_TEMPSENSE1, 132 .measure_freq_shift = IMX6_TEMPSENSE1_MEASURE_FREQ_SHIFT, 133 .measure_freq_mask = IMX6_TEMPSENSE1_MEASURE_FREQ, 134 135 .temp_data = IMX6_TEMPSENSE0, 136 .temp_value_mask = IMX6_TEMPSENSE0_TEMP_CNT_MASK, 137 .temp_value_shift = IMX6_TEMPSENSE0_TEMP_CNT_SHIFT, 138 .temp_valid_mask = IMX6_TEMPSENSE0_FINISHED, 139 140 .high_alarm_ctrl = IMX6_TEMPSENSE0, 141 .high_alarm_mask = IMX6_TEMPSENSE0_ALARM_VALUE_MASK, 142 .high_alarm_shift = IMX6_TEMPSENSE0_ALARM_VALUE_SHIFT, 143 }; 144 145 static struct thermal_soc_data thermal_imx6sx_data = { 146 .version = TEMPMON_IMX6SX, 147 148 .sensor_ctrl = IMX6_TEMPSENSE0, 149 .power_down_mask = IMX6_TEMPSENSE0_POWER_DOWN, 150 .measure_temp_mask = IMX6_TEMPSENSE0_MEASURE_TEMP, 151 152 .measure_freq_ctrl = IMX6_TEMPSENSE1, 153 .measure_freq_shift = IMX6_TEMPSENSE1_MEASURE_FREQ_SHIFT, 154 .measure_freq_mask = IMX6_TEMPSENSE1_MEASURE_FREQ, 155 156 .temp_data = IMX6_TEMPSENSE0, 157 .temp_value_mask = IMX6_TEMPSENSE0_TEMP_CNT_MASK, 158 .temp_value_shift = IMX6_TEMPSENSE0_TEMP_CNT_SHIFT, 159 .temp_valid_mask = IMX6_TEMPSENSE0_FINISHED, 160 161 .high_alarm_ctrl = IMX6_TEMPSENSE0, 162 .high_alarm_mask = IMX6_TEMPSENSE0_ALARM_VALUE_MASK, 163 .high_alarm_shift = IMX6_TEMPSENSE0_ALARM_VALUE_SHIFT, 164 165 .panic_alarm_ctrl = IMX6_TEMPSENSE2, 166 .panic_alarm_mask = IMX6_TEMPSENSE2_PANIC_VALUE_MASK, 167 .panic_alarm_shift = IMX6_TEMPSENSE2_PANIC_VALUE_SHIFT, 168 169 .low_alarm_ctrl = IMX6_TEMPSENSE2, 170 .low_alarm_mask = IMX6_TEMPSENSE2_LOW_VALUE_MASK, 171 .low_alarm_shift = IMX6_TEMPSENSE2_LOW_VALUE_SHIFT, 172 }; 173 174 static struct thermal_soc_data thermal_imx7d_data = { 175 .version = TEMPMON_IMX7D, 176 177 .sensor_ctrl = IMX7_TEMPSENSE1, 178 .power_down_mask = IMX7_TEMPSENSE1_POWER_DOWN, 179 .measure_temp_mask = IMX7_TEMPSENSE1_MEASURE_TEMP, 180 181 .measure_freq_ctrl = IMX7_TEMPSENSE1, 182 .measure_freq_shift = IMX7_TEMPSENSE1_MEASURE_FREQ_SHIFT, 183 .measure_freq_mask = IMX7_TEMPSENSE1_MEASURE_FREQ_MASK, 184 185 .temp_data = IMX7_TEMPSENSE1, 186 .temp_value_mask = IMX7_TEMPSENSE1_TEMP_VALUE_MASK, 187 .temp_value_shift = IMX7_TEMPSENSE1_TEMP_VALUE_SHIFT, 188 .temp_valid_mask = IMX7_TEMPSENSE1_FINISHED, 189 190 .panic_alarm_ctrl = IMX7_TEMPSENSE1, 191 .panic_alarm_mask = IMX7_TEMPSENSE0_PANIC_ALARM_MASK, 192 .panic_alarm_shift = IMX7_TEMPSENSE0_PANIC_ALARM_SHIFT, 193 194 .high_alarm_ctrl = IMX7_TEMPSENSE0, 195 .high_alarm_mask = IMX7_TEMPSENSE0_HIGH_ALARM_MASK, 196 .high_alarm_shift = IMX7_TEMPSENSE0_HIGH_ALARM_SHIFT, 197 198 .low_alarm_ctrl = IMX7_TEMPSENSE0, 199 .low_alarm_mask = IMX7_TEMPSENSE0_LOW_ALARM_MASK, 200 .low_alarm_shift = IMX7_TEMPSENSE0_LOW_ALARM_SHIFT, 201 }; 202 203 struct imx_thermal_data { 204 struct cpufreq_policy *policy; 205 struct thermal_zone_device *tz; 206 struct thermal_cooling_device *cdev; 207 enum thermal_device_mode mode; 208 struct regmap *tempmon; 209 u32 c1, c2; /* See formula in imx_init_calib() */ 210 int temp_passive; 211 int temp_critical; 212 int temp_max; 213 int alarm_temp; 214 int last_temp; 215 bool irq_enabled; 216 int irq; 217 struct clk *thermal_clk; 218 const struct thermal_soc_data *socdata; 219 const char *temp_grade; 220 }; 221 222 static void imx_set_panic_temp(struct imx_thermal_data *data, 223 int panic_temp) 224 { 225 const struct thermal_soc_data *soc_data = data->socdata; 226 struct regmap *map = data->tempmon; 227 int critical_value; 228 229 critical_value = (data->c2 - panic_temp) / data->c1; 230 231 regmap_write(map, soc_data->panic_alarm_ctrl + REG_CLR, 232 soc_data->panic_alarm_mask); 233 regmap_write(map, soc_data->panic_alarm_ctrl + REG_SET, 234 critical_value << soc_data->panic_alarm_shift); 235 } 236 237 static void imx_set_alarm_temp(struct imx_thermal_data *data, 238 int alarm_temp) 239 { 240 struct regmap *map = data->tempmon; 241 const struct thermal_soc_data *soc_data = data->socdata; 242 int alarm_value; 243 244 data->alarm_temp = alarm_temp; 245 246 if (data->socdata->version == TEMPMON_IMX7D) 247 alarm_value = alarm_temp / 1000 + data->c1 - 25; 248 else 249 alarm_value = (data->c2 - alarm_temp) / data->c1; 250 251 regmap_write(map, soc_data->high_alarm_ctrl + REG_CLR, 252 soc_data->high_alarm_mask); 253 regmap_write(map, soc_data->high_alarm_ctrl + REG_SET, 254 alarm_value << soc_data->high_alarm_shift); 255 } 256 257 static int imx_get_temp(struct thermal_zone_device *tz, int *temp) 258 { 259 struct imx_thermal_data *data = tz->devdata; 260 const struct thermal_soc_data *soc_data = data->socdata; 261 struct regmap *map = data->tempmon; 262 unsigned int n_meas; 263 bool wait; 264 u32 val; 265 266 if (data->mode == THERMAL_DEVICE_ENABLED) { 267 /* Check if a measurement is currently in progress */ 268 regmap_read(map, soc_data->temp_data, &val); 269 wait = !(val & soc_data->temp_valid_mask); 270 } else { 271 /* 272 * Every time we measure the temperature, we will power on the 273 * temperature sensor, enable measurements, take a reading, 274 * disable measurements, power off the temperature sensor. 275 */ 276 regmap_write(map, soc_data->sensor_ctrl + REG_CLR, 277 soc_data->power_down_mask); 278 regmap_write(map, soc_data->sensor_ctrl + REG_SET, 279 soc_data->measure_temp_mask); 280 281 wait = true; 282 } 283 284 /* 285 * According to the temp sensor designers, it may require up to ~17us 286 * to complete a measurement. 287 */ 288 if (wait) 289 usleep_range(20, 50); 290 291 regmap_read(map, soc_data->temp_data, &val); 292 293 if (data->mode != THERMAL_DEVICE_ENABLED) { 294 regmap_write(map, soc_data->sensor_ctrl + REG_CLR, 295 soc_data->measure_temp_mask); 296 regmap_write(map, soc_data->sensor_ctrl + REG_SET, 297 soc_data->power_down_mask); 298 } 299 300 if ((val & soc_data->temp_valid_mask) == 0) { 301 dev_dbg(&tz->device, "temp measurement never finished\n"); 302 return -EAGAIN; 303 } 304 305 n_meas = (val & soc_data->temp_value_mask) 306 >> soc_data->temp_value_shift; 307 308 /* See imx_init_calib() for formula derivation */ 309 if (data->socdata->version == TEMPMON_IMX7D) 310 *temp = (n_meas - data->c1 + 25) * 1000; 311 else 312 *temp = data->c2 - n_meas * data->c1; 313 314 /* Update alarm value to next higher trip point for TEMPMON_IMX6Q */ 315 if (data->socdata->version == TEMPMON_IMX6Q) { 316 if (data->alarm_temp == data->temp_passive && 317 *temp >= data->temp_passive) 318 imx_set_alarm_temp(data, data->temp_critical); 319 if (data->alarm_temp == data->temp_critical && 320 *temp < data->temp_passive) { 321 imx_set_alarm_temp(data, data->temp_passive); 322 dev_dbg(&tz->device, "thermal alarm off: T < %d\n", 323 data->alarm_temp / 1000); 324 } 325 } 326 327 if (*temp != data->last_temp) { 328 dev_dbg(&tz->device, "millicelsius: %d\n", *temp); 329 data->last_temp = *temp; 330 } 331 332 /* Reenable alarm IRQ if temperature below alarm temperature */ 333 if (!data->irq_enabled && *temp < data->alarm_temp) { 334 data->irq_enabled = true; 335 enable_irq(data->irq); 336 } 337 338 return 0; 339 } 340 341 static int imx_get_mode(struct thermal_zone_device *tz, 342 enum thermal_device_mode *mode) 343 { 344 struct imx_thermal_data *data = tz->devdata; 345 346 *mode = data->mode; 347 348 return 0; 349 } 350 351 static int imx_set_mode(struct thermal_zone_device *tz, 352 enum thermal_device_mode mode) 353 { 354 struct imx_thermal_data *data = tz->devdata; 355 struct regmap *map = data->tempmon; 356 const struct thermal_soc_data *soc_data = data->socdata; 357 358 if (mode == THERMAL_DEVICE_ENABLED) { 359 tz->polling_delay = IMX_POLLING_DELAY; 360 tz->passive_delay = IMX_PASSIVE_DELAY; 361 362 regmap_write(map, soc_data->sensor_ctrl + REG_CLR, 363 soc_data->power_down_mask); 364 regmap_write(map, soc_data->sensor_ctrl + REG_SET, 365 soc_data->measure_temp_mask); 366 367 if (!data->irq_enabled) { 368 data->irq_enabled = true; 369 enable_irq(data->irq); 370 } 371 } else { 372 regmap_write(map, soc_data->sensor_ctrl + REG_CLR, 373 soc_data->measure_temp_mask); 374 regmap_write(map, soc_data->sensor_ctrl + REG_SET, 375 soc_data->power_down_mask); 376 377 tz->polling_delay = 0; 378 tz->passive_delay = 0; 379 380 if (data->irq_enabled) { 381 disable_irq(data->irq); 382 data->irq_enabled = false; 383 } 384 } 385 386 data->mode = mode; 387 thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED); 388 389 return 0; 390 } 391 392 static int imx_get_trip_type(struct thermal_zone_device *tz, int trip, 393 enum thermal_trip_type *type) 394 { 395 *type = (trip == IMX_TRIP_PASSIVE) ? THERMAL_TRIP_PASSIVE : 396 THERMAL_TRIP_CRITICAL; 397 return 0; 398 } 399 400 static int imx_get_crit_temp(struct thermal_zone_device *tz, int *temp) 401 { 402 struct imx_thermal_data *data = tz->devdata; 403 404 *temp = data->temp_critical; 405 return 0; 406 } 407 408 static int imx_get_trip_temp(struct thermal_zone_device *tz, int trip, 409 int *temp) 410 { 411 struct imx_thermal_data *data = tz->devdata; 412 413 *temp = (trip == IMX_TRIP_PASSIVE) ? data->temp_passive : 414 data->temp_critical; 415 return 0; 416 } 417 418 static int imx_set_trip_temp(struct thermal_zone_device *tz, int trip, 419 int temp) 420 { 421 struct imx_thermal_data *data = tz->devdata; 422 423 /* do not allow changing critical threshold */ 424 if (trip == IMX_TRIP_CRITICAL) 425 return -EPERM; 426 427 /* do not allow passive to be set higher than critical */ 428 if (temp < 0 || temp > data->temp_critical) 429 return -EINVAL; 430 431 data->temp_passive = temp; 432 433 imx_set_alarm_temp(data, temp); 434 435 return 0; 436 } 437 438 static int imx_bind(struct thermal_zone_device *tz, 439 struct thermal_cooling_device *cdev) 440 { 441 int ret; 442 443 ret = thermal_zone_bind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev, 444 THERMAL_NO_LIMIT, 445 THERMAL_NO_LIMIT, 446 THERMAL_WEIGHT_DEFAULT); 447 if (ret) { 448 dev_err(&tz->device, 449 "binding zone %s with cdev %s failed:%d\n", 450 tz->type, cdev->type, ret); 451 return ret; 452 } 453 454 return 0; 455 } 456 457 static int imx_unbind(struct thermal_zone_device *tz, 458 struct thermal_cooling_device *cdev) 459 { 460 int ret; 461 462 ret = thermal_zone_unbind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev); 463 if (ret) { 464 dev_err(&tz->device, 465 "unbinding zone %s with cdev %s failed:%d\n", 466 tz->type, cdev->type, ret); 467 return ret; 468 } 469 470 return 0; 471 } 472 473 static struct thermal_zone_device_ops imx_tz_ops = { 474 .bind = imx_bind, 475 .unbind = imx_unbind, 476 .get_temp = imx_get_temp, 477 .get_mode = imx_get_mode, 478 .set_mode = imx_set_mode, 479 .get_trip_type = imx_get_trip_type, 480 .get_trip_temp = imx_get_trip_temp, 481 .get_crit_temp = imx_get_crit_temp, 482 .set_trip_temp = imx_set_trip_temp, 483 }; 484 485 static int imx_init_calib(struct platform_device *pdev, u32 ocotp_ana1) 486 { 487 struct imx_thermal_data *data = platform_get_drvdata(pdev); 488 int n1; 489 u64 temp64; 490 491 if (ocotp_ana1 == 0 || ocotp_ana1 == ~0) { 492 dev_err(&pdev->dev, "invalid sensor calibration data\n"); 493 return -EINVAL; 494 } 495 496 /* 497 * On i.MX7D, we only use the calibration data at 25C to get the temp, 498 * Tmeas = ( Nmeas - n1) + 25; n1 is the fuse value for 25C. 499 */ 500 if (data->socdata->version == TEMPMON_IMX7D) { 501 data->c1 = (ocotp_ana1 >> 9) & 0x1ff; 502 return 0; 503 } 504 505 /* 506 * The sensor is calibrated at 25 °C (aka T1) and the value measured 507 * (aka N1) at this temperature is provided in bits [31:20] in the 508 * i.MX's OCOTP value ANA1. 509 * To find the actual temperature T, the following formula has to be used 510 * when reading value n from the sensor: 511 * 512 * T = T1 + (N - N1) / (0.4148468 - 0.0015423 * N1) °C + 3.580661 °C 513 * = [T1' - N1 / (0.4148468 - 0.0015423 * N1) °C] + N / (0.4148468 - 0.0015423 * N1) °C 514 * = [T1' + N1 / (0.0015423 * N1 - 0.4148468) °C] - N / (0.0015423 * N1 - 0.4148468) °C 515 * = c2 - c1 * N 516 * 517 * with 518 * 519 * T1' = 28.580661 °C 520 * c1 = 1 / (0.0015423 * N1 - 0.4297157) °C 521 * c2 = T1' + N1 / (0.0015423 * N1 - 0.4148468) °C 522 * = T1' + N1 * c1 523 */ 524 n1 = ocotp_ana1 >> 20; 525 526 temp64 = 10000000; /* use 10^7 as fixed point constant for values in formula */ 527 temp64 *= 1000; /* to get result in °mC */ 528 do_div(temp64, 15423 * n1 - 4148468); 529 data->c1 = temp64; 530 data->c2 = n1 * data->c1 + 28581; 531 532 return 0; 533 } 534 535 static void imx_init_temp_grade(struct platform_device *pdev, u32 ocotp_mem0) 536 { 537 struct imx_thermal_data *data = platform_get_drvdata(pdev); 538 539 /* The maximum die temp is specified by the Temperature Grade */ 540 switch ((ocotp_mem0 >> 6) & 0x3) { 541 case 0: /* Commercial (0 to 95 °C) */ 542 data->temp_grade = "Commercial"; 543 data->temp_max = 95000; 544 break; 545 case 1: /* Extended Commercial (-20 °C to 105 °C) */ 546 data->temp_grade = "Extended Commercial"; 547 data->temp_max = 105000; 548 break; 549 case 2: /* Industrial (-40 °C to 105 °C) */ 550 data->temp_grade = "Industrial"; 551 data->temp_max = 105000; 552 break; 553 case 3: /* Automotive (-40 °C to 125 °C) */ 554 data->temp_grade = "Automotive"; 555 data->temp_max = 125000; 556 break; 557 } 558 559 /* 560 * Set the critical trip point at 5 °C under max 561 * Set the passive trip point at 10 °C under max (changeable via sysfs) 562 */ 563 data->temp_critical = data->temp_max - (1000 * 5); 564 data->temp_passive = data->temp_max - (1000 * 10); 565 } 566 567 static int imx_init_from_tempmon_data(struct platform_device *pdev) 568 { 569 struct regmap *map; 570 int ret; 571 u32 val; 572 573 map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, 574 "fsl,tempmon-data"); 575 if (IS_ERR(map)) { 576 ret = PTR_ERR(map); 577 dev_err(&pdev->dev, "failed to get sensor regmap: %d\n", ret); 578 return ret; 579 } 580 581 ret = regmap_read(map, OCOTP_ANA1, &val); 582 if (ret) { 583 dev_err(&pdev->dev, "failed to read sensor data: %d\n", ret); 584 return ret; 585 } 586 ret = imx_init_calib(pdev, val); 587 if (ret) 588 return ret; 589 590 ret = regmap_read(map, OCOTP_MEM0, &val); 591 if (ret) { 592 dev_err(&pdev->dev, "failed to read sensor data: %d\n", ret); 593 return ret; 594 } 595 imx_init_temp_grade(pdev, val); 596 597 return 0; 598 } 599 600 static int imx_init_from_nvmem_cells(struct platform_device *pdev) 601 { 602 int ret; 603 u32 val; 604 605 ret = nvmem_cell_read_u32(&pdev->dev, "calib", &val); 606 if (ret) 607 return ret; 608 imx_init_calib(pdev, val); 609 610 ret = nvmem_cell_read_u32(&pdev->dev, "temp_grade", &val); 611 if (ret) 612 return ret; 613 imx_init_temp_grade(pdev, val); 614 615 return 0; 616 } 617 618 static irqreturn_t imx_thermal_alarm_irq(int irq, void *dev) 619 { 620 struct imx_thermal_data *data = dev; 621 622 disable_irq_nosync(irq); 623 data->irq_enabled = false; 624 625 return IRQ_WAKE_THREAD; 626 } 627 628 static irqreturn_t imx_thermal_alarm_irq_thread(int irq, void *dev) 629 { 630 struct imx_thermal_data *data = dev; 631 632 dev_dbg(&data->tz->device, "THERMAL ALARM: T > %d\n", 633 data->alarm_temp / 1000); 634 635 thermal_zone_device_update(data->tz, THERMAL_EVENT_UNSPECIFIED); 636 637 return IRQ_HANDLED; 638 } 639 640 static const struct of_device_id of_imx_thermal_match[] = { 641 { .compatible = "fsl,imx6q-tempmon", .data = &thermal_imx6q_data, }, 642 { .compatible = "fsl,imx6sx-tempmon", .data = &thermal_imx6sx_data, }, 643 { .compatible = "fsl,imx7d-tempmon", .data = &thermal_imx7d_data, }, 644 { /* end */ } 645 }; 646 MODULE_DEVICE_TABLE(of, of_imx_thermal_match); 647 648 /* 649 * Create cooling device in case no #cooling-cells property is available in 650 * CPU node 651 */ 652 static int imx_thermal_register_legacy_cooling(struct imx_thermal_data *data) 653 { 654 struct device_node *np = of_get_cpu_node(data->policy->cpu, NULL); 655 int ret; 656 657 if (!np || !of_find_property(np, "#cooling-cells", NULL)) { 658 data->cdev = cpufreq_cooling_register(data->policy); 659 if (IS_ERR(data->cdev)) { 660 ret = PTR_ERR(data->cdev); 661 cpufreq_cpu_put(data->policy); 662 return ret; 663 } 664 } 665 666 return 0; 667 } 668 669 static int imx_thermal_probe(struct platform_device *pdev) 670 { 671 struct imx_thermal_data *data; 672 struct regmap *map; 673 int measure_freq; 674 int ret; 675 676 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); 677 if (!data) 678 return -ENOMEM; 679 680 map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "fsl,tempmon"); 681 if (IS_ERR(map)) { 682 ret = PTR_ERR(map); 683 dev_err(&pdev->dev, "failed to get tempmon regmap: %d\n", ret); 684 return ret; 685 } 686 data->tempmon = map; 687 688 data->socdata = of_device_get_match_data(&pdev->dev); 689 if (!data->socdata) { 690 dev_err(&pdev->dev, "no device match found\n"); 691 return -ENODEV; 692 } 693 694 /* make sure the IRQ flag is clear before enabling irq on i.MX6SX */ 695 if (data->socdata->version == TEMPMON_IMX6SX) { 696 regmap_write(map, IMX6_MISC1 + REG_CLR, 697 IMX6_MISC1_IRQ_TEMPHIGH | IMX6_MISC1_IRQ_TEMPLOW 698 | IMX6_MISC1_IRQ_TEMPPANIC); 699 /* 700 * reset value of LOW ALARM is incorrect, set it to lowest 701 * value to avoid false trigger of low alarm. 702 */ 703 regmap_write(map, data->socdata->low_alarm_ctrl + REG_SET, 704 data->socdata->low_alarm_mask); 705 } 706 707 data->irq = platform_get_irq(pdev, 0); 708 if (data->irq < 0) 709 return data->irq; 710 711 platform_set_drvdata(pdev, data); 712 713 if (of_find_property(pdev->dev.of_node, "nvmem-cells", NULL)) { 714 ret = imx_init_from_nvmem_cells(pdev); 715 if (ret == -EPROBE_DEFER) 716 return ret; 717 if (ret) { 718 dev_err(&pdev->dev, "failed to init from nvmem: %d\n", 719 ret); 720 return ret; 721 } 722 } else { 723 ret = imx_init_from_tempmon_data(pdev); 724 if (ret) { 725 dev_err(&pdev->dev, "failed to init from from fsl,tempmon-data\n"); 726 return ret; 727 } 728 } 729 730 /* Make sure sensor is in known good state for measurements */ 731 regmap_write(map, data->socdata->sensor_ctrl + REG_CLR, 732 data->socdata->power_down_mask); 733 regmap_write(map, data->socdata->sensor_ctrl + REG_CLR, 734 data->socdata->measure_temp_mask); 735 regmap_write(map, data->socdata->measure_freq_ctrl + REG_CLR, 736 data->socdata->measure_freq_mask); 737 if (data->socdata->version != TEMPMON_IMX7D) 738 regmap_write(map, IMX6_MISC0 + REG_SET, 739 IMX6_MISC0_REFTOP_SELBIASOFF); 740 regmap_write(map, data->socdata->sensor_ctrl + REG_SET, 741 data->socdata->power_down_mask); 742 743 data->policy = cpufreq_cpu_get(0); 744 if (!data->policy) { 745 pr_debug("%s: CPUFreq policy not found\n", __func__); 746 return -EPROBE_DEFER; 747 } 748 749 ret = imx_thermal_register_legacy_cooling(data); 750 if (ret) { 751 dev_err(&pdev->dev, 752 "failed to register cpufreq cooling device: %d\n", ret); 753 return ret; 754 } 755 756 data->thermal_clk = devm_clk_get(&pdev->dev, NULL); 757 if (IS_ERR(data->thermal_clk)) { 758 ret = PTR_ERR(data->thermal_clk); 759 if (ret != -EPROBE_DEFER) 760 dev_err(&pdev->dev, 761 "failed to get thermal clk: %d\n", ret); 762 cpufreq_cooling_unregister(data->cdev); 763 cpufreq_cpu_put(data->policy); 764 return ret; 765 } 766 767 /* 768 * Thermal sensor needs clk on to get correct value, normally 769 * we should enable its clk before taking measurement and disable 770 * clk after measurement is done, but if alarm function is enabled, 771 * hardware will auto measure the temperature periodically, so we 772 * need to keep the clk always on for alarm function. 773 */ 774 ret = clk_prepare_enable(data->thermal_clk); 775 if (ret) { 776 dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret); 777 cpufreq_cooling_unregister(data->cdev); 778 cpufreq_cpu_put(data->policy); 779 return ret; 780 } 781 782 data->tz = thermal_zone_device_register("imx_thermal_zone", 783 IMX_TRIP_NUM, 784 BIT(IMX_TRIP_PASSIVE), data, 785 &imx_tz_ops, NULL, 786 IMX_PASSIVE_DELAY, 787 IMX_POLLING_DELAY); 788 if (IS_ERR(data->tz)) { 789 ret = PTR_ERR(data->tz); 790 dev_err(&pdev->dev, 791 "failed to register thermal zone device %d\n", ret); 792 clk_disable_unprepare(data->thermal_clk); 793 cpufreq_cooling_unregister(data->cdev); 794 cpufreq_cpu_put(data->policy); 795 return ret; 796 } 797 798 dev_info(&pdev->dev, "%s CPU temperature grade - max:%dC" 799 " critical:%dC passive:%dC\n", data->temp_grade, 800 data->temp_max / 1000, data->temp_critical / 1000, 801 data->temp_passive / 1000); 802 803 /* Enable measurements at ~ 10 Hz */ 804 regmap_write(map, data->socdata->measure_freq_ctrl + REG_CLR, 805 data->socdata->measure_freq_mask); 806 measure_freq = DIV_ROUND_UP(32768, 10); /* 10 Hz */ 807 regmap_write(map, data->socdata->measure_freq_ctrl + REG_SET, 808 measure_freq << data->socdata->measure_freq_shift); 809 imx_set_alarm_temp(data, data->temp_passive); 810 811 if (data->socdata->version == TEMPMON_IMX6SX) 812 imx_set_panic_temp(data, data->temp_critical); 813 814 regmap_write(map, data->socdata->sensor_ctrl + REG_CLR, 815 data->socdata->power_down_mask); 816 regmap_write(map, data->socdata->sensor_ctrl + REG_SET, 817 data->socdata->measure_temp_mask); 818 819 data->irq_enabled = true; 820 data->mode = THERMAL_DEVICE_ENABLED; 821 822 ret = devm_request_threaded_irq(&pdev->dev, data->irq, 823 imx_thermal_alarm_irq, imx_thermal_alarm_irq_thread, 824 0, "imx_thermal", data); 825 if (ret < 0) { 826 dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret); 827 clk_disable_unprepare(data->thermal_clk); 828 thermal_zone_device_unregister(data->tz); 829 cpufreq_cooling_unregister(data->cdev); 830 cpufreq_cpu_put(data->policy); 831 return ret; 832 } 833 834 return 0; 835 } 836 837 static int imx_thermal_remove(struct platform_device *pdev) 838 { 839 struct imx_thermal_data *data = platform_get_drvdata(pdev); 840 struct regmap *map = data->tempmon; 841 842 /* Disable measurements */ 843 regmap_write(map, data->socdata->sensor_ctrl + REG_SET, 844 data->socdata->power_down_mask); 845 if (!IS_ERR(data->thermal_clk)) 846 clk_disable_unprepare(data->thermal_clk); 847 848 thermal_zone_device_unregister(data->tz); 849 cpufreq_cooling_unregister(data->cdev); 850 cpufreq_cpu_put(data->policy); 851 852 return 0; 853 } 854 855 #ifdef CONFIG_PM_SLEEP 856 static int imx_thermal_suspend(struct device *dev) 857 { 858 struct imx_thermal_data *data = dev_get_drvdata(dev); 859 struct regmap *map = data->tempmon; 860 861 /* 862 * Need to disable thermal sensor, otherwise, when thermal core 863 * try to get temperature before thermal sensor resume, a wrong 864 * temperature will be read as the thermal sensor is powered 865 * down. 866 */ 867 regmap_write(map, data->socdata->sensor_ctrl + REG_CLR, 868 data->socdata->measure_temp_mask); 869 regmap_write(map, data->socdata->sensor_ctrl + REG_SET, 870 data->socdata->power_down_mask); 871 data->mode = THERMAL_DEVICE_DISABLED; 872 clk_disable_unprepare(data->thermal_clk); 873 874 return 0; 875 } 876 877 static int imx_thermal_resume(struct device *dev) 878 { 879 struct imx_thermal_data *data = dev_get_drvdata(dev); 880 struct regmap *map = data->tempmon; 881 int ret; 882 883 ret = clk_prepare_enable(data->thermal_clk); 884 if (ret) 885 return ret; 886 /* Enabled thermal sensor after resume */ 887 regmap_write(map, data->socdata->sensor_ctrl + REG_CLR, 888 data->socdata->power_down_mask); 889 regmap_write(map, data->socdata->sensor_ctrl + REG_SET, 890 data->socdata->measure_temp_mask); 891 data->mode = THERMAL_DEVICE_ENABLED; 892 893 return 0; 894 } 895 #endif 896 897 static SIMPLE_DEV_PM_OPS(imx_thermal_pm_ops, 898 imx_thermal_suspend, imx_thermal_resume); 899 900 static struct platform_driver imx_thermal = { 901 .driver = { 902 .name = "imx_thermal", 903 .pm = &imx_thermal_pm_ops, 904 .of_match_table = of_imx_thermal_match, 905 }, 906 .probe = imx_thermal_probe, 907 .remove = imx_thermal_remove, 908 }; 909 module_platform_driver(imx_thermal); 910 911 MODULE_AUTHOR("Freescale Semiconductor, Inc."); 912 MODULE_DESCRIPTION("Thermal driver for Freescale i.MX SoCs"); 913 MODULE_LICENSE("GPL v2"); 914 MODULE_ALIAS("platform:imx-thermal"); 915