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