1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * mlx90635.c - Melexis MLX90635 contactless IR temperature sensor 4 * 5 * Copyright (c) 2023 Melexis <cmo@melexis.com> 6 * 7 * Driver for the Melexis MLX90635 I2C 16-bit IR thermopile sensor 8 */ 9 #include <linux/bitfield.h> 10 #include <linux/delay.h> 11 #include <linux/device.h> 12 #include <linux/err.h> 13 #include <linux/gpio/consumer.h> 14 #include <linux/i2c.h> 15 #include <linux/iopoll.h> 16 #include <linux/jiffies.h> 17 #include <linux/kernel.h> 18 #include <linux/limits.h> 19 #include <linux/mod_devicetable.h> 20 #include <linux/module.h> 21 #include <linux/math64.h> 22 #include <linux/pm_runtime.h> 23 #include <linux/regmap.h> 24 #include <linux/regulator/consumer.h> 25 26 #include <linux/iio/iio.h> 27 28 /* Memory sections addresses */ 29 #define MLX90635_ADDR_RAM 0x0000 /* Start address of ram */ 30 #define MLX90635_ADDR_EEPROM 0x0018 /* Start address of user eeprom */ 31 32 /* EEPROM addresses - used at startup */ 33 #define MLX90635_EE_I2C_CFG 0x0018 /* I2C address register initial value */ 34 #define MLX90635_EE_CTRL1 0x001A /* Control register1 initial value */ 35 #define MLX90635_EE_CTRL2 0x001C /* Control register2 initial value */ 36 37 #define MLX90635_EE_Ha 0x001E /* Ha customer calib value reg 16bit */ 38 #define MLX90635_EE_Hb 0x0020 /* Hb customer calib value reg 16bit */ 39 #define MLX90635_EE_Fa 0x0026 /* Fa calibration register 32bit */ 40 #define MLX90635_EE_FASCALE 0x002A /* Scaling coefficient for Fa register 16bit */ 41 #define MLX90635_EE_Ga 0x002C /* Ga calibration register 16bit */ 42 #define MLX90635_EE_Fb 0x002E /* Fb calibration register 16bit */ 43 #define MLX90635_EE_Ea 0x0030 /* Ea calibration register 32bit */ 44 #define MLX90635_EE_Eb 0x0034 /* Eb calibration register 32bit */ 45 #define MLX90635_EE_P_G 0x0038 /* P_G calibration register 16bit */ 46 #define MLX90635_EE_P_O 0x003A /* P_O calibration register 16bit */ 47 #define MLX90635_EE_Aa 0x003C /* Aa calibration register 16bit */ 48 #define MLX90635_EE_VERSION 0x003E /* Version bits 4:7 and 12:15 */ 49 #define MLX90635_EE_Gb 0x0040 /* Gb calibration register 16bit */ 50 51 /* Device status register - volatile */ 52 #define MLX90635_REG_STATUS 0x0000 53 #define MLX90635_STAT_BUSY BIT(6) /* Device busy indicator */ 54 #define MLX90635_STAT_BRST BIT(5) /* Brown out reset indicator */ 55 #define MLX90635_STAT_CYCLE_POS GENMASK(4, 2) /* Data position */ 56 #define MLX90635_STAT_END_CONV BIT(1) /* End of conversion indicator */ 57 #define MLX90635_STAT_DATA_RDY BIT(0) /* Data ready indicator */ 58 59 /* EEPROM control register address - volatile */ 60 #define MLX90635_REG_EE 0x000C 61 #define MLX90635_EE_ACTIVE BIT(4) /* Power-on EEPROM */ 62 #define MLX90635_EE_BUSY_MASK BIT(15) 63 64 #define MLX90635_REG_CMD 0x0010 /* Command register address */ 65 66 /* Control register1 address - volatile */ 67 #define MLX90635_REG_CTRL1 0x0014 68 #define MLX90635_CTRL1_REFRESH_RATE_MASK GENMASK(2, 0) 69 #define MLX90635_CTRL1_RES_CTRL_MASK GENMASK(4, 3) 70 #define MLX90635_CTRL1_TABLE_MASK BIT(15) /* Table select */ 71 72 /* Control register2 address - volatile */ 73 #define MLX90635_REG_CTRL2 0x0016 74 #define MLX90635_CTRL2_BURST_CNT_MASK GENMASK(10, 6) /* Burst count */ 75 #define MLX90635_CTRL2_MODE_MASK GENMASK(12, 11) /* Power mode */ 76 #define MLX90635_CTRL2_SOB_MASK BIT(15) 77 78 /* PowerModes statuses */ 79 #define MLX90635_PWR_STATUS_HALT 0 80 #define MLX90635_PWR_STATUS_SLEEP_STEP 1 81 #define MLX90635_PWR_STATUS_STEP 2 82 #define MLX90635_PWR_STATUS_CONTINUOUS 3 83 84 /* Measurement data addresses */ 85 #define MLX90635_RESULT_1 0x0002 86 #define MLX90635_RESULT_2 0x0004 87 #define MLX90635_RESULT_3 0x0006 88 #define MLX90635_RESULT_4 0x0008 89 #define MLX90635_RESULT_5 0x000A 90 91 /* Timings (ms) */ 92 #define MLX90635_TIMING_RST_MIN 200 /* Minimum time after addressed reset command */ 93 #define MLX90635_TIMING_RST_MAX 250 /* Maximum time after addressed reset command */ 94 #define MLX90635_TIMING_POLLING 10000 /* Time between bit polling*/ 95 #define MLX90635_TIMING_EE_ACTIVE_MIN 100 /* Minimum time after activating the EEPROM for read */ 96 #define MLX90635_TIMING_EE_ACTIVE_MAX 150 /* Maximum time after activating the EEPROM for read */ 97 98 /* Magic constants */ 99 #define MLX90635_ID_DSPv1 0x01 /* EEPROM DSP version */ 100 #define MLX90635_RESET_CMD 0x0006 /* Reset sensor (address or global) */ 101 #define MLX90635_MAX_MEAS_NUM 31 /* Maximum number of measurements in list */ 102 #define MLX90635_PTAT_DIV 12 /* Used to divide the PTAT value in pre-processing */ 103 #define MLX90635_IR_DIV 24 /* Used to divide the IR value in pre-processing */ 104 #define MLX90635_SLEEP_DELAY_MS 6000 /* Autosleep delay */ 105 #define MLX90635_MEAS_MAX_TIME 2000 /* Max measurement time in ms for the lowest refresh rate */ 106 #define MLX90635_READ_RETRIES 100 /* Number of read retries before quitting with timeout error */ 107 #define MLX90635_VERSION_MASK (GENMASK(15, 12) | GENMASK(7, 4)) 108 #define MLX90635_DSP_VERSION(reg) (((reg & GENMASK(14, 12)) >> 9) | ((reg & GENMASK(6, 4)) >> 4)) 109 #define MLX90635_DSP_FIXED BIT(15) 110 111 112 /** 113 * struct mlx90635_data - private data for the MLX90635 device 114 * @client: I2C client of the device 115 * @lock: Internal mutex because multiple reads are needed for single triggered 116 * measurement to ensure data consistency 117 * @regmap: Regmap of the device registers 118 * @regmap_ee: Regmap of the device EEPROM which can be cached 119 * @emissivity: Object emissivity from 0 to 1000 where 1000 = 1 120 * @regulator: Regulator of the device 121 * @powerstatus: Current POWER status of the device 122 * @interaction_ts: Timestamp of the last temperature read that is used 123 * for power management in jiffies 124 */ 125 struct mlx90635_data { 126 struct i2c_client *client; 127 struct mutex lock; 128 struct regmap *regmap; 129 struct regmap *regmap_ee; 130 u16 emissivity; 131 struct regulator *regulator; 132 int powerstatus; 133 unsigned long interaction_ts; 134 }; 135 136 static const struct regmap_range mlx90635_volatile_reg_range[] = { 137 regmap_reg_range(MLX90635_REG_STATUS, MLX90635_REG_STATUS), 138 regmap_reg_range(MLX90635_RESULT_1, MLX90635_RESULT_5), 139 regmap_reg_range(MLX90635_REG_EE, MLX90635_REG_EE), 140 regmap_reg_range(MLX90635_REG_CMD, MLX90635_REG_CMD), 141 regmap_reg_range(MLX90635_REG_CTRL1, MLX90635_REG_CTRL2), 142 }; 143 144 static const struct regmap_access_table mlx90635_volatile_regs_tbl = { 145 .yes_ranges = mlx90635_volatile_reg_range, 146 .n_yes_ranges = ARRAY_SIZE(mlx90635_volatile_reg_range), 147 }; 148 149 static const struct regmap_range mlx90635_read_reg_range[] = { 150 regmap_reg_range(MLX90635_REG_STATUS, MLX90635_REG_STATUS), 151 regmap_reg_range(MLX90635_RESULT_1, MLX90635_RESULT_5), 152 regmap_reg_range(MLX90635_REG_EE, MLX90635_REG_EE), 153 regmap_reg_range(MLX90635_REG_CMD, MLX90635_REG_CMD), 154 regmap_reg_range(MLX90635_REG_CTRL1, MLX90635_REG_CTRL2), 155 }; 156 157 static const struct regmap_access_table mlx90635_readable_regs_tbl = { 158 .yes_ranges = mlx90635_read_reg_range, 159 .n_yes_ranges = ARRAY_SIZE(mlx90635_read_reg_range), 160 }; 161 162 static const struct regmap_range mlx90635_no_write_reg_range[] = { 163 regmap_reg_range(MLX90635_RESULT_1, MLX90635_RESULT_5), 164 }; 165 166 static const struct regmap_access_table mlx90635_writeable_regs_tbl = { 167 .no_ranges = mlx90635_no_write_reg_range, 168 .n_no_ranges = ARRAY_SIZE(mlx90635_no_write_reg_range), 169 }; 170 171 static const struct regmap_config mlx90635_regmap = { 172 .name = "mlx90635-registers", 173 .reg_stride = 1, 174 .reg_bits = 16, 175 .val_bits = 16, 176 177 .volatile_table = &mlx90635_volatile_regs_tbl, 178 .rd_table = &mlx90635_readable_regs_tbl, 179 .wr_table = &mlx90635_writeable_regs_tbl, 180 181 .use_single_read = true, 182 .use_single_write = true, 183 .can_multi_write = false, 184 .reg_format_endian = REGMAP_ENDIAN_BIG, 185 .val_format_endian = REGMAP_ENDIAN_BIG, 186 .cache_type = REGCACHE_RBTREE, 187 }; 188 189 static const struct regmap_range mlx90635_read_ee_range[] = { 190 regmap_reg_range(MLX90635_EE_I2C_CFG, MLX90635_EE_CTRL2), 191 regmap_reg_range(MLX90635_EE_Ha, MLX90635_EE_Gb), 192 }; 193 194 static const struct regmap_access_table mlx90635_readable_ees_tbl = { 195 .yes_ranges = mlx90635_read_ee_range, 196 .n_yes_ranges = ARRAY_SIZE(mlx90635_read_ee_range), 197 }; 198 199 static const struct regmap_range mlx90635_no_write_ee_range[] = { 200 regmap_reg_range(MLX90635_ADDR_EEPROM, MLX90635_EE_Gb), 201 }; 202 203 static const struct regmap_access_table mlx90635_writeable_ees_tbl = { 204 .no_ranges = mlx90635_no_write_ee_range, 205 .n_no_ranges = ARRAY_SIZE(mlx90635_no_write_ee_range), 206 }; 207 208 static const struct regmap_config mlx90635_regmap_ee = { 209 .name = "mlx90635-eeprom", 210 .reg_stride = 1, 211 .reg_bits = 16, 212 .val_bits = 16, 213 214 .volatile_table = NULL, 215 .rd_table = &mlx90635_readable_ees_tbl, 216 .wr_table = &mlx90635_writeable_ees_tbl, 217 218 .use_single_read = true, 219 .use_single_write = true, 220 .can_multi_write = false, 221 .reg_format_endian = REGMAP_ENDIAN_BIG, 222 .val_format_endian = REGMAP_ENDIAN_BIG, 223 .cache_type = REGCACHE_RBTREE, 224 }; 225 226 /** 227 * mlx90635_reset_delay() - Give the mlx90635 some time to reset properly 228 * If this is not done, the following I2C command(s) will not be accepted. 229 */ 230 static void mlx90635_reset_delay(void) 231 { 232 usleep_range(MLX90635_TIMING_RST_MIN, MLX90635_TIMING_RST_MAX); 233 } 234 235 static int mlx90635_pwr_sleep_step(struct mlx90635_data *data) 236 { 237 int ret; 238 239 if (data->powerstatus == MLX90635_PWR_STATUS_SLEEP_STEP) 240 return 0; 241 242 ret = regmap_write_bits(data->regmap, MLX90635_REG_CTRL2, MLX90635_CTRL2_MODE_MASK, 243 FIELD_PREP(MLX90635_CTRL2_MODE_MASK, MLX90635_PWR_STATUS_SLEEP_STEP)); 244 if (ret < 0) 245 return ret; 246 247 data->powerstatus = MLX90635_PWR_STATUS_SLEEP_STEP; 248 return 0; 249 } 250 251 static int mlx90635_pwr_continuous(struct mlx90635_data *data) 252 { 253 int ret; 254 255 if (data->powerstatus == MLX90635_PWR_STATUS_CONTINUOUS) 256 return 0; 257 258 ret = regmap_write_bits(data->regmap, MLX90635_REG_CTRL2, MLX90635_CTRL2_MODE_MASK, 259 FIELD_PREP(MLX90635_CTRL2_MODE_MASK, MLX90635_PWR_STATUS_CONTINUOUS)); 260 if (ret < 0) 261 return ret; 262 263 data->powerstatus = MLX90635_PWR_STATUS_CONTINUOUS; 264 return 0; 265 } 266 267 static int mlx90635_read_ee_register(struct regmap *regmap, u16 reg_lsb, 268 s32 *reg_value) 269 { 270 unsigned int read; 271 u32 value; 272 int ret; 273 274 ret = regmap_read(regmap, reg_lsb + 2, &read); 275 if (ret < 0) 276 return ret; 277 278 value = read; 279 280 ret = regmap_read(regmap, reg_lsb, &read); 281 if (ret < 0) 282 return ret; 283 284 *reg_value = (read << 16) | (value & 0xffff); 285 286 return 0; 287 } 288 289 static int mlx90635_read_ee_ambient(struct regmap *regmap, s16 *PG, s16 *PO, s16 *Gb) 290 { 291 unsigned int read_tmp; 292 int ret; 293 294 ret = regmap_read(regmap, MLX90635_EE_P_O, &read_tmp); 295 if (ret < 0) 296 return ret; 297 *PO = (s16)read_tmp; 298 299 ret = regmap_read(regmap, MLX90635_EE_P_G, &read_tmp); 300 if (ret < 0) 301 return ret; 302 *PG = (s16)read_tmp; 303 304 ret = regmap_read(regmap, MLX90635_EE_Gb, &read_tmp); 305 if (ret < 0) 306 return ret; 307 *Gb = (u16)read_tmp; 308 309 return 0; 310 } 311 312 static int mlx90635_read_ee_object(struct regmap *regmap, u32 *Ea, u32 *Eb, u32 *Fa, s16 *Fb, 313 s16 *Ga, s16 *Gb, s16 *Ha, s16 *Hb, u16 *Fa_scale) 314 { 315 unsigned int read_tmp; 316 int ret; 317 318 ret = mlx90635_read_ee_register(regmap, MLX90635_EE_Ea, Ea); 319 if (ret < 0) 320 return ret; 321 322 ret = mlx90635_read_ee_register(regmap, MLX90635_EE_Eb, Eb); 323 if (ret < 0) 324 return ret; 325 326 ret = mlx90635_read_ee_register(regmap, MLX90635_EE_Fa, Fa); 327 if (ret < 0) 328 return ret; 329 330 ret = regmap_read(regmap, MLX90635_EE_Ha, &read_tmp); 331 if (ret < 0) 332 return ret; 333 *Ha = (s16)read_tmp; 334 335 ret = regmap_read(regmap, MLX90635_EE_Hb, &read_tmp); 336 if (ret < 0) 337 return ret; 338 *Hb = (s16)read_tmp; 339 340 ret = regmap_read(regmap, MLX90635_EE_Ga, &read_tmp); 341 if (ret < 0) 342 return ret; 343 *Ga = (s16)read_tmp; 344 345 ret = regmap_read(regmap, MLX90635_EE_Gb, &read_tmp); 346 if (ret < 0) 347 return ret; 348 *Gb = (s16)read_tmp; 349 350 ret = regmap_read(regmap, MLX90635_EE_Fb, &read_tmp); 351 if (ret < 0) 352 return ret; 353 *Fb = (s16)read_tmp; 354 355 ret = regmap_read(regmap, MLX90635_EE_FASCALE, &read_tmp); 356 if (ret < 0) 357 return ret; 358 *Fa_scale = (u16)read_tmp; 359 360 return 0; 361 } 362 363 static int mlx90635_calculate_dataset_ready_time(struct mlx90635_data *data, int *refresh_time) 364 { 365 unsigned int reg; 366 int ret; 367 368 ret = regmap_read(data->regmap, MLX90635_REG_CTRL1, ®); 369 if (ret < 0) 370 return ret; 371 372 *refresh_time = 2 * (MLX90635_MEAS_MAX_TIME >> FIELD_GET(MLX90635_CTRL1_REFRESH_RATE_MASK, reg)) + 80; 373 374 return 0; 375 } 376 377 static int mlx90635_perform_measurement_burst(struct mlx90635_data *data) 378 { 379 unsigned int reg_status; 380 int refresh_time; 381 int ret; 382 383 ret = regmap_write_bits(data->regmap, MLX90635_REG_STATUS, 384 MLX90635_STAT_END_CONV, MLX90635_STAT_END_CONV); 385 if (ret < 0) 386 return ret; 387 388 ret = mlx90635_calculate_dataset_ready_time(data, &refresh_time); 389 if (ret < 0) 390 return ret; 391 392 ret = regmap_write_bits(data->regmap, MLX90635_REG_CTRL2, 393 FIELD_PREP(MLX90635_CTRL2_SOB_MASK, 1), 394 FIELD_PREP(MLX90635_CTRL2_SOB_MASK, 1)); 395 if (ret < 0) 396 return ret; 397 398 msleep(refresh_time); /* Wait minimum time for dataset to be ready */ 399 400 ret = regmap_read_poll_timeout(data->regmap, MLX90635_REG_STATUS, reg_status, 401 (!(reg_status & MLX90635_STAT_END_CONV)) == 0, 402 MLX90635_TIMING_POLLING, MLX90635_READ_RETRIES * 10000); 403 if (ret < 0) { 404 dev_err(&data->client->dev, "data not ready"); 405 return -ETIMEDOUT; 406 } 407 408 return 0; 409 } 410 411 static int mlx90635_read_ambient_raw(struct regmap *regmap, 412 s16 *ambient_new_raw, s16 *ambient_old_raw) 413 { 414 unsigned int read_tmp; 415 int ret; 416 417 ret = regmap_read(regmap, MLX90635_RESULT_2, &read_tmp); 418 if (ret < 0) 419 return ret; 420 *ambient_new_raw = (s16)read_tmp; 421 422 ret = regmap_read(regmap, MLX90635_RESULT_3, &read_tmp); 423 if (ret < 0) 424 return ret; 425 *ambient_old_raw = (s16)read_tmp; 426 427 return 0; 428 } 429 430 static int mlx90635_read_object_raw(struct regmap *regmap, s16 *object_raw) 431 { 432 unsigned int read_tmp; 433 s16 read; 434 int ret; 435 436 ret = regmap_read(regmap, MLX90635_RESULT_1, &read_tmp); 437 if (ret < 0) 438 return ret; 439 440 read = (s16)read_tmp; 441 442 ret = regmap_read(regmap, MLX90635_RESULT_4, &read_tmp); 443 if (ret < 0) 444 return ret; 445 *object_raw = (read - (s16)read_tmp) / 2; 446 447 return 0; 448 } 449 450 static int mlx90635_read_all_channel(struct mlx90635_data *data, 451 s16 *ambient_new_raw, s16 *ambient_old_raw, 452 s16 *object_raw) 453 { 454 int ret; 455 456 mutex_lock(&data->lock); 457 if (data->powerstatus == MLX90635_PWR_STATUS_SLEEP_STEP) { 458 /* Trigger measurement in Sleep Step mode */ 459 ret = mlx90635_perform_measurement_burst(data); 460 if (ret < 0) 461 goto read_unlock; 462 } 463 464 ret = mlx90635_read_ambient_raw(data->regmap, ambient_new_raw, 465 ambient_old_raw); 466 if (ret < 0) 467 goto read_unlock; 468 469 ret = mlx90635_read_object_raw(data->regmap, object_raw); 470 read_unlock: 471 mutex_unlock(&data->lock); 472 return ret; 473 } 474 475 static s64 mlx90635_preprocess_temp_amb(s16 ambient_new_raw, 476 s16 ambient_old_raw, s16 Gb) 477 { 478 s64 VR_Ta, kGb, tmp; 479 480 kGb = ((s64)Gb * 1000LL) >> 10ULL; 481 VR_Ta = (s64)ambient_old_raw * 1000000LL + 482 kGb * div64_s64(((s64)ambient_new_raw * 1000LL), 483 (MLX90635_PTAT_DIV)); 484 tmp = div64_s64( 485 div64_s64(((s64)ambient_new_raw * 1000000000000LL), 486 (MLX90635_PTAT_DIV)), VR_Ta); 487 return div64_s64(tmp << 19ULL, 1000LL); 488 } 489 490 static s64 mlx90635_preprocess_temp_obj(s16 object_raw, 491 s16 ambient_new_raw, 492 s16 ambient_old_raw, s16 Gb) 493 { 494 s64 VR_IR, kGb, tmp; 495 496 kGb = ((s64)Gb * 1000LL) >> 10ULL; 497 VR_IR = (s64)ambient_old_raw * 1000000LL + 498 kGb * (div64_s64((s64)ambient_new_raw * 1000LL, 499 MLX90635_PTAT_DIV)); 500 tmp = div64_s64( 501 div64_s64((s64)(object_raw * 1000000LL), 502 MLX90635_IR_DIV) * 1000000LL, 503 VR_IR); 504 return div64_s64((tmp << 19ULL), 1000LL); 505 } 506 507 static s32 mlx90635_calc_temp_ambient(s16 ambient_new_raw, s16 ambient_old_raw, 508 u16 P_G, u16 P_O, s16 Gb) 509 { 510 s64 kPG, kPO, AMB; 511 512 AMB = mlx90635_preprocess_temp_amb(ambient_new_raw, ambient_old_raw, 513 Gb); 514 kPG = ((s64)P_G * 1000000LL) >> 9ULL; 515 kPO = AMB - (((s64)P_O * 1000LL) >> 1ULL); 516 517 return 30 * 1000LL + div64_s64(kPO * 1000000LL, kPG); 518 } 519 520 static s32 mlx90635_calc_temp_object_iteration(s32 prev_object_temp, s64 object, 521 s64 TAdut, s64 TAdut4, s16 Ga, 522 u32 Fa, u16 Fa_scale, s16 Fb, 523 s16 Ha, s16 Hb, u16 emissivity) 524 { 525 s64 calcedGa, calcedGb, calcedFa, Alpha_corr; 526 s64 Ha_customer, Hb_customer; 527 528 Ha_customer = ((s64)Ha * 1000000LL) >> 14ULL; 529 Hb_customer = ((s64)Hb * 100) >> 10ULL; 530 531 calcedGa = ((s64)((s64)Ga * (prev_object_temp - 35 * 1000LL) 532 * 1000LL)) >> 24LL; 533 calcedGb = ((s64)(Fb * (TAdut - 30 * 1000000LL))) >> 24LL; 534 535 Alpha_corr = ((s64)((s64)Fa * Ha_customer * 10000LL) >> Fa_scale); 536 Alpha_corr *= ((s64)(1 * 1000000LL + calcedGa + calcedGb)); 537 538 Alpha_corr = div64_s64(Alpha_corr, 1000LL); 539 Alpha_corr *= emissivity; 540 Alpha_corr = div64_s64(Alpha_corr, 100LL); 541 calcedFa = div64_s64((s64)object * 100000000000LL, Alpha_corr); 542 543 return (int_sqrt64(int_sqrt64(calcedFa * 100000000LL + TAdut4)) 544 - 27315 - Hb_customer) * 10; 545 } 546 547 static s64 mlx90635_calc_ta4(s64 TAdut, s64 scale) 548 { 549 return (div64_s64(TAdut, scale) + 27315) * 550 (div64_s64(TAdut, scale) + 27315) * 551 (div64_s64(TAdut, scale) + 27315) * 552 (div64_s64(TAdut, scale) + 27315); 553 } 554 555 static s32 mlx90635_calc_temp_object(s64 object, s64 ambient, u32 Ea, u32 Eb, 556 s16 Ga, u32 Fa, u16 Fa_scale, s16 Fb, s16 Ha, s16 Hb, 557 u16 tmp_emi) 558 { 559 s64 kTA, kTA0, TAdut, TAdut4; 560 s64 temp = 35000; 561 s8 i; 562 563 kTA = (Ea * 1000LL) >> 16LL; 564 kTA0 = (Eb * 1000LL) >> 8LL; 565 TAdut = div64_s64(((ambient - kTA0) * 1000000LL), kTA) + 30 * 1000000LL; 566 TAdut4 = mlx90635_calc_ta4(TAdut, 10000LL); 567 568 /* Iterations of calculation as described in datasheet */ 569 for (i = 0; i < 5; ++i) { 570 temp = mlx90635_calc_temp_object_iteration(temp, object, TAdut, TAdut4, 571 Ga, Fa, Fa_scale, Fb, Ha, Hb, 572 tmp_emi); 573 } 574 return temp; 575 } 576 577 static int mlx90635_calc_object(struct mlx90635_data *data, int *val) 578 { 579 s16 ambient_new_raw, ambient_old_raw, object_raw; 580 s16 Fb, Ga, Gb, Ha, Hb; 581 s64 object, ambient; 582 u32 Ea, Eb, Fa; 583 u16 Fa_scale; 584 int ret; 585 586 ret = mlx90635_read_ee_object(data->regmap_ee, &Ea, &Eb, &Fa, &Fb, &Ga, &Gb, &Ha, &Hb, &Fa_scale); 587 if (ret < 0) 588 return ret; 589 590 ret = mlx90635_read_all_channel(data, 591 &ambient_new_raw, &ambient_old_raw, 592 &object_raw); 593 if (ret < 0) 594 return ret; 595 596 ambient = mlx90635_preprocess_temp_amb(ambient_new_raw, 597 ambient_old_raw, Gb); 598 object = mlx90635_preprocess_temp_obj(object_raw, 599 ambient_new_raw, 600 ambient_old_raw, Gb); 601 602 *val = mlx90635_calc_temp_object(object, ambient, Ea, Eb, Ga, Fa, Fa_scale, Fb, 603 Ha, Hb, data->emissivity); 604 return 0; 605 } 606 607 static int mlx90635_calc_ambient(struct mlx90635_data *data, int *val) 608 { 609 s16 ambient_new_raw, ambient_old_raw; 610 s16 PG, PO, Gb; 611 int ret; 612 613 ret = mlx90635_read_ee_ambient(data->regmap_ee, &PG, &PO, &Gb); 614 if (ret < 0) 615 return ret; 616 617 mutex_lock(&data->lock); 618 if (data->powerstatus == MLX90635_PWR_STATUS_SLEEP_STEP) { 619 ret = mlx90635_perform_measurement_burst(data); 620 if (ret < 0) 621 goto read_ambient_unlock; 622 } 623 624 ret = mlx90635_read_ambient_raw(data->regmap, &ambient_new_raw, 625 &ambient_old_raw); 626 read_ambient_unlock: 627 mutex_unlock(&data->lock); 628 if (ret < 0) 629 return ret; 630 631 *val = mlx90635_calc_temp_ambient(ambient_new_raw, ambient_old_raw, 632 PG, PO, Gb); 633 return ret; 634 } 635 636 static int mlx90635_get_refresh_rate(struct mlx90635_data *data, 637 unsigned int *refresh_rate) 638 { 639 unsigned int reg; 640 int ret; 641 642 ret = regmap_read(data->regmap, MLX90635_REG_CTRL1, ®); 643 if (ret < 0) 644 return ret; 645 646 *refresh_rate = FIELD_GET(MLX90635_CTRL1_REFRESH_RATE_MASK, reg); 647 648 return 0; 649 } 650 651 static const struct { 652 int val; 653 int val2; 654 } mlx90635_freqs[] = { 655 { 0, 200000 }, 656 { 0, 500000 }, 657 { 0, 900000 }, 658 { 1, 700000 }, 659 { 3, 0 }, 660 { 4, 800000 }, 661 { 6, 900000 }, 662 { 8, 900000 } 663 }; 664 665 /** 666 * mlx90635_pm_interaction_wakeup() - Measure time between user interactions to change powermode 667 * @data: pointer to mlx90635_data object containing interaction_ts information 668 * 669 * Switch to continuous mode when interaction is faster than MLX90635_MEAS_MAX_TIME. Update the 670 * interaction_ts for each function call with the jiffies to enable measurement between function 671 * calls. Initial value of the interaction_ts needs to be set before this function call. 672 */ 673 static int mlx90635_pm_interaction_wakeup(struct mlx90635_data *data) 674 { 675 unsigned long now; 676 int ret; 677 678 now = jiffies; 679 if (time_in_range(now, data->interaction_ts, 680 data->interaction_ts + 681 msecs_to_jiffies(MLX90635_MEAS_MAX_TIME + 100))) { 682 ret = mlx90635_pwr_continuous(data); 683 if (ret < 0) 684 return ret; 685 } 686 687 data->interaction_ts = now; 688 689 return 0; 690 } 691 692 static int mlx90635_read_raw(struct iio_dev *indio_dev, 693 struct iio_chan_spec const *channel, int *val, 694 int *val2, long mask) 695 { 696 struct mlx90635_data *data = iio_priv(indio_dev); 697 int ret; 698 int cr; 699 700 pm_runtime_get_sync(&data->client->dev); 701 ret = mlx90635_pm_interaction_wakeup(data); 702 if (ret < 0) 703 goto mlx90635_read_raw_pm; 704 705 switch (mask) { 706 case IIO_CHAN_INFO_PROCESSED: 707 switch (channel->channel2) { 708 case IIO_MOD_TEMP_AMBIENT: 709 ret = mlx90635_calc_ambient(data, val); 710 if (ret < 0) 711 goto mlx90635_read_raw_pm; 712 713 ret = IIO_VAL_INT; 714 break; 715 case IIO_MOD_TEMP_OBJECT: 716 ret = mlx90635_calc_object(data, val); 717 if (ret < 0) 718 goto mlx90635_read_raw_pm; 719 720 ret = IIO_VAL_INT; 721 break; 722 default: 723 ret = -EINVAL; 724 break; 725 } 726 break; 727 case IIO_CHAN_INFO_CALIBEMISSIVITY: 728 if (data->emissivity == 1000) { 729 *val = 1; 730 *val2 = 0; 731 } else { 732 *val = 0; 733 *val2 = data->emissivity * 1000; 734 } 735 ret = IIO_VAL_INT_PLUS_MICRO; 736 break; 737 case IIO_CHAN_INFO_SAMP_FREQ: 738 ret = mlx90635_get_refresh_rate(data, &cr); 739 if (ret < 0) 740 goto mlx90635_read_raw_pm; 741 742 *val = mlx90635_freqs[cr].val; 743 *val2 = mlx90635_freqs[cr].val2; 744 ret = IIO_VAL_INT_PLUS_MICRO; 745 break; 746 default: 747 ret = -EINVAL; 748 break; 749 } 750 751 mlx90635_read_raw_pm: 752 pm_runtime_mark_last_busy(&data->client->dev); 753 pm_runtime_put_autosuspend(&data->client->dev); 754 return ret; 755 } 756 757 static int mlx90635_write_raw(struct iio_dev *indio_dev, 758 struct iio_chan_spec const *channel, int val, 759 int val2, long mask) 760 { 761 struct mlx90635_data *data = iio_priv(indio_dev); 762 int ret; 763 int i; 764 765 switch (mask) { 766 case IIO_CHAN_INFO_CALIBEMISSIVITY: 767 /* Confirm we are within 0 and 1.0 */ 768 if (val < 0 || val2 < 0 || val > 1 || 769 (val == 1 && val2 != 0)) 770 return -EINVAL; 771 data->emissivity = val * 1000 + val2 / 1000; 772 return 0; 773 case IIO_CHAN_INFO_SAMP_FREQ: 774 for (i = 0; i < ARRAY_SIZE(mlx90635_freqs); i++) { 775 if (val == mlx90635_freqs[i].val && 776 val2 == mlx90635_freqs[i].val2) 777 break; 778 } 779 if (i == ARRAY_SIZE(mlx90635_freqs)) 780 return -EINVAL; 781 782 ret = regmap_write_bits(data->regmap, MLX90635_REG_CTRL1, 783 MLX90635_CTRL1_REFRESH_RATE_MASK, i); 784 785 return ret; 786 default: 787 return -EINVAL; 788 } 789 } 790 791 static int mlx90635_read_avail(struct iio_dev *indio_dev, 792 struct iio_chan_spec const *chan, 793 const int **vals, int *type, int *length, 794 long mask) 795 { 796 switch (mask) { 797 case IIO_CHAN_INFO_SAMP_FREQ: 798 *vals = (int *)mlx90635_freqs; 799 *type = IIO_VAL_INT_PLUS_MICRO; 800 *length = 2 * ARRAY_SIZE(mlx90635_freqs); 801 return IIO_AVAIL_LIST; 802 default: 803 return -EINVAL; 804 } 805 } 806 807 static const struct iio_chan_spec mlx90635_channels[] = { 808 { 809 .type = IIO_TEMP, 810 .modified = 1, 811 .channel2 = IIO_MOD_TEMP_AMBIENT, 812 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), 813 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), 814 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_SAMP_FREQ), 815 }, 816 { 817 .type = IIO_TEMP, 818 .modified = 1, 819 .channel2 = IIO_MOD_TEMP_OBJECT, 820 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 821 BIT(IIO_CHAN_INFO_CALIBEMISSIVITY), 822 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), 823 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_SAMP_FREQ), 824 }, 825 }; 826 827 static const struct iio_info mlx90635_info = { 828 .read_raw = mlx90635_read_raw, 829 .write_raw = mlx90635_write_raw, 830 .read_avail = mlx90635_read_avail, 831 }; 832 833 static void mlx90635_sleep(void *_data) 834 { 835 struct mlx90635_data *data = _data; 836 837 mlx90635_pwr_sleep_step(data); 838 } 839 840 static int mlx90635_suspend(struct mlx90635_data *data) 841 { 842 return mlx90635_pwr_sleep_step(data); 843 } 844 845 static int mlx90635_wakeup(struct mlx90635_data *data) 846 { 847 s16 Fb, Ga, Gb, Ha, Hb, PG, PO; 848 unsigned int dsp_version; 849 u32 Ea, Eb, Fa; 850 u16 Fa_scale; 851 int ret; 852 853 regcache_cache_bypass(data->regmap_ee, false); 854 regcache_cache_only(data->regmap_ee, false); 855 regcache_cache_only(data->regmap, false); 856 857 ret = mlx90635_pwr_continuous(data); 858 if (ret < 0) { 859 dev_err(&data->client->dev, "Switch to continuous mode failed\n"); 860 return ret; 861 } 862 ret = regmap_write_bits(data->regmap, MLX90635_REG_EE, 863 MLX90635_EE_ACTIVE, MLX90635_EE_ACTIVE); 864 if (ret < 0) { 865 dev_err(&data->client->dev, "Powering EEPROM failed\n"); 866 return ret; 867 } 868 usleep_range(MLX90635_TIMING_EE_ACTIVE_MIN, MLX90635_TIMING_EE_ACTIVE_MAX); 869 870 regcache_mark_dirty(data->regmap_ee); 871 872 ret = regcache_sync(data->regmap_ee); 873 if (ret < 0) { 874 dev_err(&data->client->dev, 875 "Failed to sync cache: %d\n", ret); 876 return ret; 877 } 878 879 ret = mlx90635_read_ee_ambient(data->regmap_ee, &PG, &PO, &Gb); 880 if (ret < 0) { 881 dev_err(&data->client->dev, 882 "Failed to read to cache Ambient coefficients EEPROM region: %d\n", ret); 883 return ret; 884 } 885 886 ret = mlx90635_read_ee_object(data->regmap_ee, &Ea, &Eb, &Fa, &Fb, &Ga, &Gb, &Ha, &Hb, &Fa_scale); 887 if (ret < 0) { 888 dev_err(&data->client->dev, 889 "Failed to read to cache Object coefficients EEPROM region: %d\n", ret); 890 return ret; 891 } 892 893 ret = regmap_read(data->regmap_ee, MLX90635_EE_VERSION, &dsp_version); 894 if (ret < 0) { 895 dev_err(&data->client->dev, 896 "Failed to read to cache of EEPROM version: %d\n", ret); 897 return ret; 898 } 899 900 regcache_cache_only(data->regmap_ee, true); 901 902 return ret; 903 } 904 905 static void mlx90635_disable_regulator(void *_data) 906 { 907 struct mlx90635_data *data = _data; 908 int ret; 909 910 ret = regulator_disable(data->regulator); 911 if (ret < 0) 912 dev_err(regmap_get_device(data->regmap), 913 "Failed to disable power regulator: %d\n", ret); 914 } 915 916 static int mlx90635_enable_regulator(struct mlx90635_data *data) 917 { 918 int ret; 919 920 ret = regulator_enable(data->regulator); 921 if (ret < 0) { 922 dev_err(regmap_get_device(data->regmap), "Failed to enable power regulator!\n"); 923 return ret; 924 } 925 926 mlx90635_reset_delay(); 927 928 return ret; 929 } 930 931 static int mlx90635_probe(struct i2c_client *client) 932 { 933 struct mlx90635_data *mlx90635; 934 struct iio_dev *indio_dev; 935 unsigned int dsp_version; 936 struct regmap *regmap; 937 struct regmap *regmap_ee; 938 int ret; 939 940 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*mlx90635)); 941 if (!indio_dev) 942 return dev_err_probe(&client->dev, -ENOMEM, "failed to allocate device\n"); 943 944 regmap = devm_regmap_init_i2c(client, &mlx90635_regmap); 945 if (IS_ERR(regmap)) 946 return dev_err_probe(&client->dev, PTR_ERR(regmap), 947 "failed to allocate regmap\n"); 948 949 regmap_ee = devm_regmap_init_i2c(client, &mlx90635_regmap_ee); 950 if (IS_ERR(regmap_ee)) 951 return dev_err_probe(&client->dev, PTR_ERR(regmap_ee), 952 "failed to allocate EEPROM regmap\n"); 953 954 mlx90635 = iio_priv(indio_dev); 955 i2c_set_clientdata(client, indio_dev); 956 mlx90635->client = client; 957 mlx90635->regmap = regmap; 958 mlx90635->regmap_ee = regmap_ee; 959 mlx90635->powerstatus = MLX90635_PWR_STATUS_SLEEP_STEP; 960 961 mutex_init(&mlx90635->lock); 962 indio_dev->name = "mlx90635"; 963 indio_dev->modes = INDIO_DIRECT_MODE; 964 indio_dev->info = &mlx90635_info; 965 indio_dev->channels = mlx90635_channels; 966 indio_dev->num_channels = ARRAY_SIZE(mlx90635_channels); 967 968 mlx90635->regulator = devm_regulator_get(&client->dev, "vdd"); 969 if (IS_ERR(mlx90635->regulator)) 970 return dev_err_probe(&client->dev, PTR_ERR(mlx90635->regulator), 971 "failed to get vdd regulator"); 972 973 ret = mlx90635_enable_regulator(mlx90635); 974 if (ret < 0) 975 return ret; 976 977 ret = devm_add_action_or_reset(&client->dev, mlx90635_disable_regulator, 978 mlx90635); 979 if (ret < 0) 980 return dev_err_probe(&client->dev, ret, 981 "failed to setup regulator cleanup action\n"); 982 983 ret = mlx90635_wakeup(mlx90635); 984 if (ret < 0) 985 return dev_err_probe(&client->dev, ret, "wakeup failed\n"); 986 987 ret = devm_add_action_or_reset(&client->dev, mlx90635_sleep, mlx90635); 988 if (ret < 0) 989 return dev_err_probe(&client->dev, ret, 990 "failed to setup low power cleanup\n"); 991 992 ret = regmap_read(mlx90635->regmap_ee, MLX90635_EE_VERSION, &dsp_version); 993 if (ret < 0) 994 return dev_err_probe(&client->dev, ret, "read of version failed\n"); 995 996 dsp_version = dsp_version & MLX90635_VERSION_MASK; 997 998 if (FIELD_GET(MLX90635_DSP_FIXED, dsp_version)) { 999 if (MLX90635_DSP_VERSION(dsp_version) == MLX90635_ID_DSPv1) { 1000 dev_dbg(&client->dev, 1001 "Detected DSP v1 calibration %x\n", dsp_version); 1002 } else { 1003 dev_dbg(&client->dev, 1004 "Detected Unknown EEPROM calibration %lx\n", 1005 MLX90635_DSP_VERSION(dsp_version)); 1006 } 1007 } else { 1008 return dev_err_probe(&client->dev, -EPROTONOSUPPORT, 1009 "Wrong fixed top bit %x (expected 0x8X0X)\n", 1010 dsp_version); 1011 } 1012 1013 mlx90635->emissivity = 1000; 1014 mlx90635->interaction_ts = jiffies; /* Set initial value */ 1015 1016 pm_runtime_get_noresume(&client->dev); 1017 pm_runtime_set_active(&client->dev); 1018 1019 ret = devm_pm_runtime_enable(&client->dev); 1020 if (ret) 1021 return dev_err_probe(&client->dev, ret, 1022 "failed to enable powermanagement\n"); 1023 1024 pm_runtime_set_autosuspend_delay(&client->dev, MLX90635_SLEEP_DELAY_MS); 1025 pm_runtime_use_autosuspend(&client->dev); 1026 pm_runtime_put_autosuspend(&client->dev); 1027 1028 return devm_iio_device_register(&client->dev, indio_dev); 1029 } 1030 1031 static const struct i2c_device_id mlx90635_id[] = { 1032 { "mlx90635" }, 1033 { } 1034 }; 1035 MODULE_DEVICE_TABLE(i2c, mlx90635_id); 1036 1037 static const struct of_device_id mlx90635_of_match[] = { 1038 { .compatible = "melexis,mlx90635" }, 1039 { } 1040 }; 1041 MODULE_DEVICE_TABLE(of, mlx90635_of_match); 1042 1043 static int mlx90635_pm_suspend(struct device *dev) 1044 { 1045 struct mlx90635_data *data = iio_priv(dev_get_drvdata(dev)); 1046 int ret; 1047 1048 ret = mlx90635_suspend(data); 1049 if (ret < 0) 1050 return ret; 1051 1052 ret = regulator_disable(data->regulator); 1053 if (ret < 0) 1054 dev_err(regmap_get_device(data->regmap), 1055 "Failed to disable power regulator: %d\n", ret); 1056 1057 return ret; 1058 } 1059 1060 static int mlx90635_pm_resume(struct device *dev) 1061 { 1062 struct mlx90635_data *data = iio_priv(dev_get_drvdata(dev)); 1063 int ret; 1064 1065 ret = mlx90635_enable_regulator(data); 1066 if (ret < 0) 1067 return ret; 1068 1069 return mlx90635_wakeup(data); 1070 } 1071 1072 static int mlx90635_pm_runtime_suspend(struct device *dev) 1073 { 1074 struct mlx90635_data *data = iio_priv(dev_get_drvdata(dev)); 1075 1076 return mlx90635_pwr_sleep_step(data); 1077 } 1078 1079 static const struct dev_pm_ops mlx90635_pm_ops = { 1080 SYSTEM_SLEEP_PM_OPS(mlx90635_pm_suspend, mlx90635_pm_resume) 1081 RUNTIME_PM_OPS(mlx90635_pm_runtime_suspend, NULL, NULL) 1082 }; 1083 1084 static struct i2c_driver mlx90635_driver = { 1085 .driver = { 1086 .name = "mlx90635", 1087 .of_match_table = mlx90635_of_match, 1088 .pm = pm_ptr(&mlx90635_pm_ops), 1089 }, 1090 .probe = mlx90635_probe, 1091 .id_table = mlx90635_id, 1092 }; 1093 module_i2c_driver(mlx90635_driver); 1094 1095 MODULE_AUTHOR("Crt Mori <cmo@melexis.com>"); 1096 MODULE_DESCRIPTION("Melexis MLX90635 contactless Infra Red temperature sensor driver"); 1097 MODULE_LICENSE("GPL"); 1098