1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * mlx90632.c - Melexis MLX90632 contactless IR temperature sensor 4 * 5 * Copyright (c) 2017 Melexis <cmo@melexis.com> 6 * 7 * Driver for the Melexis MLX90632 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 #include <linux/iio/sysfs.h> 28 29 /* Memory sections addresses */ 30 #define MLX90632_ADDR_RAM 0x4000 /* Start address of ram */ 31 #define MLX90632_ADDR_EEPROM 0x2480 /* Start address of user eeprom */ 32 33 /* EEPROM addresses - used at startup */ 34 #define MLX90632_EE_CTRL 0x24d4 /* Control register initial value */ 35 #define MLX90632_EE_I2C_ADDR 0x24d5 /* I2C address register initial value */ 36 #define MLX90632_EE_VERSION 0x240b /* EEPROM version reg address */ 37 #define MLX90632_EE_P_R 0x240c /* P_R calibration register 32bit */ 38 #define MLX90632_EE_P_G 0x240e /* P_G calibration register 32bit */ 39 #define MLX90632_EE_P_T 0x2410 /* P_T calibration register 32bit */ 40 #define MLX90632_EE_P_O 0x2412 /* P_O calibration register 32bit */ 41 #define MLX90632_EE_Aa 0x2414 /* Aa calibration register 32bit */ 42 #define MLX90632_EE_Ab 0x2416 /* Ab calibration register 32bit */ 43 #define MLX90632_EE_Ba 0x2418 /* Ba calibration register 32bit */ 44 #define MLX90632_EE_Bb 0x241a /* Bb calibration register 32bit */ 45 #define MLX90632_EE_Ca 0x241c /* Ca calibration register 32bit */ 46 #define MLX90632_EE_Cb 0x241e /* Cb calibration register 32bit */ 47 #define MLX90632_EE_Da 0x2420 /* Da calibration register 32bit */ 48 #define MLX90632_EE_Db 0x2422 /* Db calibration register 32bit */ 49 #define MLX90632_EE_Ea 0x2424 /* Ea calibration register 32bit */ 50 #define MLX90632_EE_Eb 0x2426 /* Eb calibration register 32bit */ 51 #define MLX90632_EE_Fa 0x2428 /* Fa calibration register 32bit */ 52 #define MLX90632_EE_Fb 0x242a /* Fb calibration register 32bit */ 53 #define MLX90632_EE_Ga 0x242c /* Ga calibration register 32bit */ 54 55 #define MLX90632_EE_Gb 0x242e /* Gb calibration register 16bit */ 56 #define MLX90632_EE_Ka 0x242f /* Ka calibration register 16bit */ 57 58 #define MLX90632_EE_Ha 0x2481 /* Ha customer calib value reg 16bit */ 59 #define MLX90632_EE_Hb 0x2482 /* Hb customer calib value reg 16bit */ 60 61 #define MLX90632_EE_MEDICAL_MEAS1 0x24E1 /* Medical measurement 1 16bit */ 62 #define MLX90632_EE_MEDICAL_MEAS2 0x24E2 /* Medical measurement 2 16bit */ 63 #define MLX90632_EE_EXTENDED_MEAS1 0x24F1 /* Extended measurement 1 16bit */ 64 #define MLX90632_EE_EXTENDED_MEAS2 0x24F2 /* Extended measurement 2 16bit */ 65 #define MLX90632_EE_EXTENDED_MEAS3 0x24F3 /* Extended measurement 3 16bit */ 66 67 /* Register addresses - volatile */ 68 #define MLX90632_REG_I2C_ADDR 0x3000 /* Chip I2C address register */ 69 70 /* Control register address - volatile */ 71 #define MLX90632_REG_CONTROL 0x3001 /* Control Register address */ 72 #define MLX90632_CFG_PWR_MASK GENMASK(2, 1) /* PowerMode Mask */ 73 #define MLX90632_CFG_MTYP_MASK GENMASK(8, 4) /* Meas select Mask */ 74 #define MLX90632_CFG_SOB_MASK BIT(11) 75 76 /* PowerModes statuses */ 77 #define MLX90632_PWR_STATUS(ctrl_val) (ctrl_val << 1) 78 #define MLX90632_PWR_STATUS_HALT MLX90632_PWR_STATUS(0) /* hold */ 79 #define MLX90632_PWR_STATUS_SLEEP_STEP MLX90632_PWR_STATUS(1) /* sleep step */ 80 #define MLX90632_PWR_STATUS_STEP MLX90632_PWR_STATUS(2) /* step */ 81 #define MLX90632_PWR_STATUS_CONTINUOUS MLX90632_PWR_STATUS(3) /* continuous */ 82 83 #define MLX90632_EE_RR GENMASK(10, 8) /* Only Refresh Rate bits */ 84 #define MLX90632_REFRESH_RATE(ee_val) FIELD_GET(MLX90632_EE_RR, ee_val) 85 /* Extract Refresh Rate from ee register */ 86 #define MLX90632_REFRESH_RATE_STATUS(refresh_rate) (refresh_rate << 8) 87 88 /* Measurement types */ 89 #define MLX90632_MTYP_MEDICAL 0 90 #define MLX90632_MTYP_EXTENDED 17 91 92 /* Measurement type select*/ 93 #define MLX90632_MTYP_STATUS(ctrl_val) (ctrl_val << 4) 94 #define MLX90632_MTYP_STATUS_MEDICAL MLX90632_MTYP_STATUS(MLX90632_MTYP_MEDICAL) 95 #define MLX90632_MTYP_STATUS_EXTENDED MLX90632_MTYP_STATUS(MLX90632_MTYP_EXTENDED) 96 97 /* I2C command register - volatile */ 98 #define MLX90632_REG_I2C_CMD 0x3005 /* I2C command Register address */ 99 100 /* Device status register - volatile */ 101 #define MLX90632_REG_STATUS 0x3fff /* Device status register */ 102 #define MLX90632_STAT_BUSY BIT(10) /* Device busy indicator */ 103 #define MLX90632_STAT_EE_BUSY BIT(9) /* EEPROM busy indicator */ 104 #define MLX90632_STAT_BRST BIT(8) /* Brown out reset indicator */ 105 #define MLX90632_STAT_CYCLE_POS GENMASK(6, 2) /* Data position */ 106 #define MLX90632_STAT_DATA_RDY BIT(0) /* Data ready indicator */ 107 108 /* RAM_MEAS address-es for each channel */ 109 #define MLX90632_RAM_1(meas_num) (MLX90632_ADDR_RAM + 3 * meas_num) 110 #define MLX90632_RAM_2(meas_num) (MLX90632_ADDR_RAM + 3 * meas_num + 1) 111 #define MLX90632_RAM_3(meas_num) (MLX90632_ADDR_RAM + 3 * meas_num + 2) 112 113 /* Name important RAM_MEAS channels */ 114 #define MLX90632_RAM_DSP5_EXTENDED_AMBIENT_1 MLX90632_RAM_3(17) 115 #define MLX90632_RAM_DSP5_EXTENDED_AMBIENT_2 MLX90632_RAM_3(18) 116 #define MLX90632_RAM_DSP5_EXTENDED_OBJECT_1 MLX90632_RAM_1(17) 117 #define MLX90632_RAM_DSP5_EXTENDED_OBJECT_2 MLX90632_RAM_2(17) 118 #define MLX90632_RAM_DSP5_EXTENDED_OBJECT_3 MLX90632_RAM_1(18) 119 #define MLX90632_RAM_DSP5_EXTENDED_OBJECT_4 MLX90632_RAM_2(18) 120 #define MLX90632_RAM_DSP5_EXTENDED_OBJECT_5 MLX90632_RAM_1(19) 121 #define MLX90632_RAM_DSP5_EXTENDED_OBJECT_6 MLX90632_RAM_2(19) 122 123 /* Magic constants */ 124 #define MLX90632_ID_MEDICAL 0x0105 /* EEPROM DSPv5 Medical device id */ 125 #define MLX90632_ID_CONSUMER 0x0205 /* EEPROM DSPv5 Consumer device id */ 126 #define MLX90632_ID_EXTENDED 0x0505 /* EEPROM DSPv5 Extended range device id */ 127 #define MLX90632_ID_MASK GENMASK(14, 0) /* DSP version and device ID in EE_VERSION */ 128 #define MLX90632_DSP_VERSION 5 /* DSP version */ 129 #define MLX90632_DSP_MASK GENMASK(7, 0) /* DSP version in EE_VERSION */ 130 #define MLX90632_RESET_CMD 0x0006 /* Reset sensor (address or global) */ 131 #define MLX90632_REF_12 12LL /* ResCtrlRef value of Ch 1 or Ch 2 */ 132 #define MLX90632_REF_3 12LL /* ResCtrlRef value of Channel 3 */ 133 #define MLX90632_MAX_MEAS_NUM 31 /* Maximum measurements in list */ 134 #define MLX90632_SLEEP_DELAY_MS 6000 /* Autosleep delay */ 135 #define MLX90632_EXTENDED_LIMIT 27000 /* Extended mode raw value limit */ 136 #define MLX90632_MEAS_MAX_TIME 2000 /* Max measurement time in ms for the lowest refresh rate */ 137 138 /** 139 * struct mlx90632_data - private data for the MLX90632 device 140 * @client: I2C client of the device 141 * @lock: Internal mutex for multiple reads for single measurement 142 * @regmap: Regmap of the device 143 * @emissivity: Object emissivity from 0 to 1000 where 1000 = 1. 144 * @mtyp: Measurement type physical sensor configuration for extended range 145 * calculations 146 * @object_ambient_temperature: Ambient temperature at object (might differ of 147 * the ambient temperature of sensor. 148 * @regulator: Regulator of the device 149 * @powerstatus: Current POWER status of the device 150 * @interaction_ts: Timestamp of the last temperature read that is used 151 * for power management in jiffies 152 */ 153 struct mlx90632_data { 154 struct i2c_client *client; 155 struct mutex lock; 156 struct regmap *regmap; 157 u16 emissivity; 158 u8 mtyp; 159 u32 object_ambient_temperature; 160 struct regulator *regulator; 161 int powerstatus; 162 unsigned long interaction_ts; 163 }; 164 165 static const struct regmap_range mlx90632_volatile_reg_range[] = { 166 regmap_reg_range(MLX90632_REG_I2C_ADDR, MLX90632_REG_CONTROL), 167 regmap_reg_range(MLX90632_REG_I2C_CMD, MLX90632_REG_I2C_CMD), 168 regmap_reg_range(MLX90632_REG_STATUS, MLX90632_REG_STATUS), 169 regmap_reg_range(MLX90632_RAM_1(0), 170 MLX90632_RAM_3(MLX90632_MAX_MEAS_NUM)), 171 }; 172 173 static const struct regmap_access_table mlx90632_volatile_regs_tbl = { 174 .yes_ranges = mlx90632_volatile_reg_range, 175 .n_yes_ranges = ARRAY_SIZE(mlx90632_volatile_reg_range), 176 }; 177 178 static const struct regmap_range mlx90632_read_reg_range[] = { 179 regmap_reg_range(MLX90632_EE_VERSION, MLX90632_EE_Ka), 180 regmap_reg_range(MLX90632_EE_CTRL, MLX90632_EE_I2C_ADDR), 181 regmap_reg_range(MLX90632_EE_Ha, MLX90632_EE_Hb), 182 regmap_reg_range(MLX90632_EE_MEDICAL_MEAS1, MLX90632_EE_MEDICAL_MEAS2), 183 regmap_reg_range(MLX90632_EE_EXTENDED_MEAS1, MLX90632_EE_EXTENDED_MEAS3), 184 regmap_reg_range(MLX90632_REG_I2C_ADDR, MLX90632_REG_CONTROL), 185 regmap_reg_range(MLX90632_REG_I2C_CMD, MLX90632_REG_I2C_CMD), 186 regmap_reg_range(MLX90632_REG_STATUS, MLX90632_REG_STATUS), 187 regmap_reg_range(MLX90632_RAM_1(0), 188 MLX90632_RAM_3(MLX90632_MAX_MEAS_NUM)), 189 }; 190 191 static const struct regmap_access_table mlx90632_readable_regs_tbl = { 192 .yes_ranges = mlx90632_read_reg_range, 193 .n_yes_ranges = ARRAY_SIZE(mlx90632_read_reg_range), 194 }; 195 196 static const struct regmap_range mlx90632_no_write_reg_range[] = { 197 regmap_reg_range(MLX90632_EE_VERSION, MLX90632_EE_Ka), 198 regmap_reg_range(MLX90632_RAM_1(0), 199 MLX90632_RAM_3(MLX90632_MAX_MEAS_NUM)), 200 }; 201 202 static const struct regmap_access_table mlx90632_writeable_regs_tbl = { 203 .no_ranges = mlx90632_no_write_reg_range, 204 .n_no_ranges = ARRAY_SIZE(mlx90632_no_write_reg_range), 205 }; 206 207 static const struct regmap_config mlx90632_regmap = { 208 .reg_bits = 16, 209 .val_bits = 16, 210 211 .volatile_table = &mlx90632_volatile_regs_tbl, 212 .rd_table = &mlx90632_readable_regs_tbl, 213 .wr_table = &mlx90632_writeable_regs_tbl, 214 215 .use_single_read = true, 216 .use_single_write = true, 217 .reg_format_endian = REGMAP_ENDIAN_BIG, 218 .val_format_endian = REGMAP_ENDIAN_BIG, 219 .cache_type = REGCACHE_RBTREE, 220 }; 221 222 static int mlx90632_pwr_set_sleep_step(struct regmap *regmap) 223 { 224 struct mlx90632_data *data = 225 iio_priv(dev_get_drvdata(regmap_get_device(regmap))); 226 int ret; 227 228 if (data->powerstatus == MLX90632_PWR_STATUS_SLEEP_STEP) 229 return 0; 230 231 ret = regmap_write_bits(regmap, MLX90632_REG_CONTROL, MLX90632_CFG_PWR_MASK, 232 MLX90632_PWR_STATUS_SLEEP_STEP); 233 if (ret < 0) 234 return ret; 235 236 data->powerstatus = MLX90632_PWR_STATUS_SLEEP_STEP; 237 return 0; 238 } 239 240 static int mlx90632_pwr_continuous(struct regmap *regmap) 241 { 242 struct mlx90632_data *data = 243 iio_priv(dev_get_drvdata(regmap_get_device(regmap))); 244 int ret; 245 246 if (data->powerstatus == MLX90632_PWR_STATUS_CONTINUOUS) 247 return 0; 248 249 ret = regmap_write_bits(regmap, MLX90632_REG_CONTROL, MLX90632_CFG_PWR_MASK, 250 MLX90632_PWR_STATUS_CONTINUOUS); 251 if (ret < 0) 252 return ret; 253 254 data->powerstatus = MLX90632_PWR_STATUS_CONTINUOUS; 255 return 0; 256 } 257 258 /** 259 * mlx90632_reset_delay() - Give the mlx90632 some time to reset properly 260 * If this is not done, the following I2C command(s) will not be accepted. 261 */ 262 static void mlx90632_reset_delay(void) 263 { 264 usleep_range(150, 200); 265 } 266 267 static int mlx90632_get_measurement_time(struct regmap *regmap, u16 meas) 268 { 269 unsigned int reg; 270 int ret; 271 272 ret = regmap_read(regmap, meas, ®); 273 if (ret < 0) 274 return ret; 275 276 return MLX90632_MEAS_MAX_TIME >> FIELD_GET(MLX90632_EE_RR, reg); 277 } 278 279 static int mlx90632_calculate_dataset_ready_time(struct mlx90632_data *data) 280 { 281 unsigned int refresh_time; 282 int ret; 283 284 if (data->mtyp == MLX90632_MTYP_MEDICAL) { 285 ret = mlx90632_get_measurement_time(data->regmap, 286 MLX90632_EE_MEDICAL_MEAS1); 287 if (ret < 0) 288 return ret; 289 290 refresh_time = ret; 291 292 ret = mlx90632_get_measurement_time(data->regmap, 293 MLX90632_EE_MEDICAL_MEAS2); 294 if (ret < 0) 295 return ret; 296 297 refresh_time += ret; 298 } else { 299 ret = mlx90632_get_measurement_time(data->regmap, 300 MLX90632_EE_EXTENDED_MEAS1); 301 if (ret < 0) 302 return ret; 303 304 refresh_time = ret; 305 306 ret = mlx90632_get_measurement_time(data->regmap, 307 MLX90632_EE_EXTENDED_MEAS2); 308 if (ret < 0) 309 return ret; 310 311 refresh_time += ret; 312 313 ret = mlx90632_get_measurement_time(data->regmap, 314 MLX90632_EE_EXTENDED_MEAS3); 315 if (ret < 0) 316 return ret; 317 318 refresh_time += ret; 319 } 320 321 return refresh_time; 322 } 323 324 /** 325 * mlx90632_perform_measurement() - Trigger and retrieve current measurement cycle 326 * @data: pointer to mlx90632_data object containing regmap information 327 * 328 * Perform a measurement and return latest measurement cycle position reported 329 * by sensor. This is a blocking function for 500ms, as that is default sensor 330 * refresh rate. 331 */ 332 static int mlx90632_perform_measurement(struct mlx90632_data *data) 333 { 334 unsigned int reg_status; 335 int ret; 336 337 ret = regmap_clear_bits(data->regmap, MLX90632_REG_STATUS, 338 MLX90632_STAT_DATA_RDY); 339 if (ret < 0) 340 return ret; 341 342 ret = regmap_read_poll_timeout(data->regmap, MLX90632_REG_STATUS, reg_status, 343 !(reg_status & MLX90632_STAT_DATA_RDY), 10000, 344 100 * 10000); 345 346 if (ret < 0) { 347 dev_err(&data->client->dev, "data not ready"); 348 return -ETIMEDOUT; 349 } 350 351 return (reg_status & MLX90632_STAT_CYCLE_POS) >> 2; 352 } 353 354 /** 355 * mlx90632_perform_measurement_burst() - Trigger and retrieve current measurement 356 * cycle in step sleep mode 357 * @data: pointer to mlx90632_data object containing regmap information 358 * 359 * Perform a measurement and return 2 as measurement cycle position reported 360 * by sensor. This is a blocking function for amount dependent on the sensor 361 * refresh rate. 362 */ 363 static int mlx90632_perform_measurement_burst(struct mlx90632_data *data) 364 { 365 unsigned int reg_status; 366 int ret; 367 368 ret = regmap_write_bits(data->regmap, MLX90632_REG_CONTROL, 369 MLX90632_CFG_SOB_MASK, MLX90632_CFG_SOB_MASK); 370 if (ret < 0) 371 return ret; 372 373 ret = mlx90632_calculate_dataset_ready_time(data); 374 if (ret < 0) 375 return ret; 376 377 msleep(ret); /* Wait minimum time for dataset to be ready */ 378 379 ret = regmap_read_poll_timeout(data->regmap, MLX90632_REG_STATUS, 380 reg_status, 381 (reg_status & MLX90632_STAT_BUSY) == 0, 382 10000, 100 * 10000); 383 if (ret < 0) { 384 dev_err(&data->client->dev, "data not ready"); 385 return -ETIMEDOUT; 386 } 387 388 return 2; 389 } 390 391 static int mlx90632_set_meas_type(struct mlx90632_data *data, u8 type) 392 { 393 int current_powerstatus; 394 int ret; 395 396 if (data->mtyp == type) 397 return 0; 398 399 current_powerstatus = data->powerstatus; 400 ret = mlx90632_pwr_continuous(data->regmap); 401 if (ret < 0) 402 return ret; 403 404 ret = regmap_write(data->regmap, MLX90632_REG_I2C_CMD, MLX90632_RESET_CMD); 405 if (ret < 0) 406 return ret; 407 408 mlx90632_reset_delay(); 409 410 ret = regmap_update_bits(data->regmap, MLX90632_REG_CONTROL, 411 (MLX90632_CFG_MTYP_MASK | MLX90632_CFG_PWR_MASK), 412 (MLX90632_MTYP_STATUS(type) | MLX90632_PWR_STATUS_HALT)); 413 if (ret < 0) 414 return ret; 415 416 data->mtyp = type; 417 data->powerstatus = MLX90632_PWR_STATUS_HALT; 418 419 if (current_powerstatus == MLX90632_PWR_STATUS_SLEEP_STEP) 420 return mlx90632_pwr_set_sleep_step(data->regmap); 421 422 return mlx90632_pwr_continuous(data->regmap); 423 } 424 425 static int mlx90632_channel_new_select(int perform_ret, uint8_t *channel_new, 426 uint8_t *channel_old) 427 { 428 switch (perform_ret) { 429 case 1: 430 *channel_new = 1; 431 *channel_old = 2; 432 break; 433 case 2: 434 *channel_new = 2; 435 *channel_old = 1; 436 break; 437 default: 438 return -ECHRNG; 439 } 440 441 return 0; 442 } 443 444 static int mlx90632_read_ambient_raw(struct regmap *regmap, 445 s16 *ambient_new_raw, s16 *ambient_old_raw) 446 { 447 unsigned int read_tmp; 448 int ret; 449 450 ret = regmap_read(regmap, MLX90632_RAM_3(1), &read_tmp); 451 if (ret < 0) 452 return ret; 453 *ambient_new_raw = (s16)read_tmp; 454 455 ret = regmap_read(regmap, MLX90632_RAM_3(2), &read_tmp); 456 if (ret < 0) 457 return ret; 458 *ambient_old_raw = (s16)read_tmp; 459 460 return ret; 461 } 462 463 static int mlx90632_read_object_raw(struct regmap *regmap, 464 int perform_measurement_ret, 465 s16 *object_new_raw, s16 *object_old_raw) 466 { 467 unsigned int read_tmp; 468 u8 channel_old = 0; 469 u8 channel = 0; 470 s16 read; 471 int ret; 472 473 ret = mlx90632_channel_new_select(perform_measurement_ret, &channel, 474 &channel_old); 475 if (ret != 0) 476 return ret; 477 478 ret = regmap_read(regmap, MLX90632_RAM_2(channel), &read_tmp); 479 if (ret < 0) 480 return ret; 481 482 read = (s16)read_tmp; 483 484 ret = regmap_read(regmap, MLX90632_RAM_1(channel), &read_tmp); 485 if (ret < 0) 486 return ret; 487 *object_new_raw = (read + (s16)read_tmp) / 2; 488 489 ret = regmap_read(regmap, MLX90632_RAM_2(channel_old), &read_tmp); 490 if (ret < 0) 491 return ret; 492 read = (s16)read_tmp; 493 494 ret = regmap_read(regmap, MLX90632_RAM_1(channel_old), &read_tmp); 495 if (ret < 0) 496 return ret; 497 *object_old_raw = (read + (s16)read_tmp) / 2; 498 499 return ret; 500 } 501 502 static int mlx90632_read_all_channel(struct mlx90632_data *data, 503 s16 *ambient_new_raw, s16 *ambient_old_raw, 504 s16 *object_new_raw, s16 *object_old_raw) 505 { 506 s32 measurement; 507 int ret; 508 509 mutex_lock(&data->lock); 510 ret = mlx90632_set_meas_type(data, MLX90632_MTYP_MEDICAL); 511 if (ret < 0) 512 goto read_unlock; 513 514 switch (data->powerstatus) { 515 case MLX90632_PWR_STATUS_CONTINUOUS: 516 ret = mlx90632_perform_measurement(data); 517 if (ret < 0) 518 goto read_unlock; 519 520 break; 521 case MLX90632_PWR_STATUS_SLEEP_STEP: 522 ret = mlx90632_perform_measurement_burst(data); 523 if (ret < 0) 524 goto read_unlock; 525 526 break; 527 default: 528 ret = -EOPNOTSUPP; 529 goto read_unlock; 530 } 531 532 measurement = ret; /* If we came here ret holds the measurement position */ 533 534 ret = mlx90632_read_ambient_raw(data->regmap, ambient_new_raw, 535 ambient_old_raw); 536 if (ret < 0) 537 goto read_unlock; 538 539 ret = mlx90632_read_object_raw(data->regmap, measurement, 540 object_new_raw, object_old_raw); 541 read_unlock: 542 mutex_unlock(&data->lock); 543 return ret; 544 } 545 546 static int mlx90632_read_ambient_raw_extended(struct regmap *regmap, 547 s16 *ambient_new_raw, s16 *ambient_old_raw) 548 { 549 unsigned int read_tmp; 550 int ret; 551 552 ret = regmap_read(regmap, MLX90632_RAM_DSP5_EXTENDED_AMBIENT_1, &read_tmp); 553 if (ret < 0) 554 return ret; 555 *ambient_new_raw = (s16)read_tmp; 556 557 ret = regmap_read(regmap, MLX90632_RAM_DSP5_EXTENDED_AMBIENT_2, &read_tmp); 558 if (ret < 0) 559 return ret; 560 *ambient_old_raw = (s16)read_tmp; 561 562 return 0; 563 } 564 565 static int mlx90632_read_object_raw_extended(struct regmap *regmap, s16 *object_new_raw) 566 { 567 unsigned int read_tmp; 568 s32 read; 569 int ret; 570 571 ret = regmap_read(regmap, MLX90632_RAM_DSP5_EXTENDED_OBJECT_1, &read_tmp); 572 if (ret < 0) 573 return ret; 574 read = (s16)read_tmp; 575 576 ret = regmap_read(regmap, MLX90632_RAM_DSP5_EXTENDED_OBJECT_2, &read_tmp); 577 if (ret < 0) 578 return ret; 579 read = read - (s16)read_tmp; 580 581 ret = regmap_read(regmap, MLX90632_RAM_DSP5_EXTENDED_OBJECT_3, &read_tmp); 582 if (ret < 0) 583 return ret; 584 read = read - (s16)read_tmp; 585 586 ret = regmap_read(regmap, MLX90632_RAM_DSP5_EXTENDED_OBJECT_4, &read_tmp); 587 if (ret < 0) 588 return ret; 589 read = (read + (s16)read_tmp) / 2; 590 591 ret = regmap_read(regmap, MLX90632_RAM_DSP5_EXTENDED_OBJECT_5, &read_tmp); 592 if (ret < 0) 593 return ret; 594 read = read + (s16)read_tmp; 595 596 ret = regmap_read(regmap, MLX90632_RAM_DSP5_EXTENDED_OBJECT_6, &read_tmp); 597 if (ret < 0) 598 return ret; 599 read = read + (s16)read_tmp; 600 601 if (read > S16_MAX || read < S16_MIN) 602 return -ERANGE; 603 604 *object_new_raw = read; 605 606 return 0; 607 } 608 609 static int mlx90632_read_all_channel_extended(struct mlx90632_data *data, s16 *object_new_raw, 610 s16 *ambient_new_raw, s16 *ambient_old_raw) 611 { 612 s32 ret, meas; 613 614 mutex_lock(&data->lock); 615 ret = mlx90632_set_meas_type(data, MLX90632_MTYP_EXTENDED); 616 if (ret < 0) 617 goto read_unlock; 618 619 switch (data->powerstatus) { 620 case MLX90632_PWR_STATUS_CONTINUOUS: 621 ret = read_poll_timeout(mlx90632_perform_measurement, meas, meas == 19, 622 50000, 800000, false, data); 623 if (ret) 624 goto read_unlock; 625 break; 626 case MLX90632_PWR_STATUS_SLEEP_STEP: 627 ret = mlx90632_perform_measurement_burst(data); 628 if (ret < 0) 629 goto read_unlock; 630 break; 631 default: 632 ret = -EOPNOTSUPP; 633 goto read_unlock; 634 } 635 636 ret = mlx90632_read_object_raw_extended(data->regmap, object_new_raw); 637 if (ret < 0) 638 goto read_unlock; 639 640 ret = mlx90632_read_ambient_raw_extended(data->regmap, ambient_new_raw, ambient_old_raw); 641 642 read_unlock: 643 mutex_unlock(&data->lock); 644 return ret; 645 } 646 647 static int mlx90632_read_ee_register(struct regmap *regmap, u16 reg_lsb, 648 s32 *reg_value) 649 { 650 unsigned int read; 651 u32 value; 652 int ret; 653 654 ret = regmap_read(regmap, reg_lsb, &read); 655 if (ret < 0) 656 return ret; 657 658 value = read; 659 660 ret = regmap_read(regmap, reg_lsb + 1, &read); 661 if (ret < 0) 662 return ret; 663 664 *reg_value = (read << 16) | (value & 0xffff); 665 666 return 0; 667 } 668 669 static s64 mlx90632_preprocess_temp_amb(s16 ambient_new_raw, 670 s16 ambient_old_raw, s16 Gb) 671 { 672 s64 VR_Ta, kGb, tmp; 673 674 kGb = ((s64)Gb * 1000LL) >> 10ULL; 675 VR_Ta = (s64)ambient_old_raw * 1000000LL + 676 kGb * div64_s64(((s64)ambient_new_raw * 1000LL), 677 (MLX90632_REF_3)); 678 tmp = div64_s64( 679 div64_s64(((s64)ambient_new_raw * 1000000000000LL), 680 (MLX90632_REF_3)), VR_Ta); 681 return div64_s64(tmp << 19ULL, 1000LL); 682 } 683 684 static s64 mlx90632_preprocess_temp_obj(s16 object_new_raw, s16 object_old_raw, 685 s16 ambient_new_raw, 686 s16 ambient_old_raw, s16 Ka) 687 { 688 s64 VR_IR, kKa, tmp; 689 690 kKa = ((s64)Ka * 1000LL) >> 10ULL; 691 VR_IR = (s64)ambient_old_raw * 1000000LL + 692 kKa * div64_s64(((s64)ambient_new_raw * 1000LL), 693 (MLX90632_REF_3)); 694 tmp = div64_s64( 695 div64_s64(((s64)((object_new_raw + object_old_raw) / 2) 696 * 1000000000000LL), (MLX90632_REF_12)), 697 VR_IR); 698 return div64_s64((tmp << 19ULL), 1000LL); 699 } 700 701 static s64 mlx90632_preprocess_temp_obj_extended(s16 object_new_raw, s16 ambient_new_raw, 702 s16 ambient_old_raw, s16 Ka) 703 { 704 s64 VR_IR, kKa, tmp; 705 706 kKa = ((s64)Ka * 1000LL) >> 10ULL; 707 VR_IR = (s64)ambient_old_raw * 1000000LL + 708 kKa * div64_s64((s64)ambient_new_raw * 1000LL, 709 MLX90632_REF_3); 710 tmp = div64_s64( 711 div64_s64((s64) object_new_raw * 1000000000000LL, MLX90632_REF_12), 712 VR_IR); 713 return div64_s64(tmp << 19ULL, 1000LL); 714 } 715 716 static s32 mlx90632_calc_temp_ambient(s16 ambient_new_raw, s16 ambient_old_raw, 717 s32 P_T, s32 P_R, s32 P_G, s32 P_O, s16 Gb) 718 { 719 s64 Asub, Bsub, Ablock, Bblock, Cblock, AMB, sum; 720 721 AMB = mlx90632_preprocess_temp_amb(ambient_new_raw, ambient_old_raw, 722 Gb); 723 Asub = ((s64)P_T * 10000000000LL) >> 44ULL; 724 Bsub = AMB - (((s64)P_R * 1000LL) >> 8ULL); 725 Ablock = Asub * (Bsub * Bsub); 726 Bblock = (div64_s64(Bsub * 10000000LL, P_G)) << 20ULL; 727 Cblock = ((s64)P_O * 10000000000LL) >> 8ULL; 728 729 sum = div64_s64(Ablock, 1000000LL) + Bblock + Cblock; 730 731 return div64_s64(sum, 10000000LL); 732 } 733 734 static s32 mlx90632_calc_temp_object_iteration(s32 prev_object_temp, s64 object, 735 s64 TAdut, s64 TAdut4, s32 Fa, s32 Fb, 736 s32 Ga, s16 Ha, s16 Hb, 737 u16 emissivity) 738 { 739 s64 calcedKsTO, calcedKsTA, ir_Alpha, Alpha_corr; 740 s64 Ha_customer, Hb_customer; 741 742 Ha_customer = ((s64)Ha * 1000000LL) >> 14ULL; 743 Hb_customer = ((s64)Hb * 100) >> 10ULL; 744 745 calcedKsTO = ((s64)((s64)Ga * (prev_object_temp - 25 * 1000LL) 746 * 1000LL)) >> 36LL; 747 calcedKsTA = ((s64)(Fb * (TAdut - 25 * 1000000LL))) >> 36LL; 748 Alpha_corr = div64_s64((((s64)(Fa * 10000000000LL) >> 46LL) 749 * Ha_customer), 1000LL); 750 Alpha_corr *= ((s64)(1 * 1000000LL + calcedKsTO + calcedKsTA)); 751 Alpha_corr = emissivity * div64_s64(Alpha_corr, 100000LL); 752 Alpha_corr = div64_s64(Alpha_corr, 1000LL); 753 ir_Alpha = div64_s64((s64)object * 10000000LL, Alpha_corr); 754 755 return (int_sqrt64(int_sqrt64(ir_Alpha * 1000000000000LL + TAdut4)) 756 - 27315 - Hb_customer) * 10; 757 } 758 759 static s64 mlx90632_calc_ta4(s64 TAdut, s64 scale) 760 { 761 return (div64_s64(TAdut, scale) + 27315) * 762 (div64_s64(TAdut, scale) + 27315) * 763 (div64_s64(TAdut, scale) + 27315) * 764 (div64_s64(TAdut, scale) + 27315); 765 } 766 767 static s32 mlx90632_calc_temp_object(s64 object, s64 ambient, s32 Ea, s32 Eb, 768 s32 Fa, s32 Fb, s32 Ga, s16 Ha, s16 Hb, 769 u16 tmp_emi) 770 { 771 s64 kTA, kTA0, TAdut, TAdut4; 772 s64 temp = 25000; 773 s8 i; 774 775 kTA = (Ea * 1000LL) >> 16LL; 776 kTA0 = (Eb * 1000LL) >> 8LL; 777 TAdut = div64_s64(((ambient - kTA0) * 1000000LL), kTA) + 25 * 1000000LL; 778 TAdut4 = mlx90632_calc_ta4(TAdut, 10000LL); 779 780 /* Iterations of calculation as described in datasheet */ 781 for (i = 0; i < 5; ++i) { 782 temp = mlx90632_calc_temp_object_iteration(temp, object, TAdut, TAdut4, 783 Fa, Fb, Ga, Ha, Hb, 784 tmp_emi); 785 } 786 return temp; 787 } 788 789 static s32 mlx90632_calc_temp_object_extended(s64 object, s64 ambient, s64 reflected, 790 s32 Ea, s32 Eb, s32 Fa, s32 Fb, s32 Ga, 791 s16 Ha, s16 Hb, u16 tmp_emi) 792 { 793 s64 kTA, kTA0, TAdut, TAdut4, Tr4, TaTr4; 794 s64 temp = 25000; 795 s8 i; 796 797 kTA = (Ea * 1000LL) >> 16LL; 798 kTA0 = (Eb * 1000LL) >> 8LL; 799 TAdut = div64_s64((ambient - kTA0) * 1000000LL, kTA) + 25 * 1000000LL; 800 Tr4 = mlx90632_calc_ta4(reflected, 10); 801 TAdut4 = mlx90632_calc_ta4(TAdut, 10000LL); 802 TaTr4 = Tr4 - div64_s64(Tr4 - TAdut4, tmp_emi) * 1000; 803 804 /* Iterations of calculation as described in datasheet */ 805 for (i = 0; i < 5; ++i) { 806 temp = mlx90632_calc_temp_object_iteration(temp, object, TAdut, TaTr4, 807 Fa / 2, Fb, Ga, Ha, Hb, 808 tmp_emi); 809 } 810 811 return temp; 812 } 813 814 static int mlx90632_calc_object_dsp105(struct mlx90632_data *data, int *val) 815 { 816 s16 ambient_new_raw, ambient_old_raw, object_new_raw, object_old_raw; 817 s32 Ea, Eb, Fa, Fb, Ga; 818 unsigned int read_tmp; 819 s64 object, ambient; 820 s16 Ha, Hb, Gb, Ka; 821 int ret; 822 823 ret = mlx90632_read_ee_register(data->regmap, MLX90632_EE_Ea, &Ea); 824 if (ret < 0) 825 return ret; 826 ret = mlx90632_read_ee_register(data->regmap, MLX90632_EE_Eb, &Eb); 827 if (ret < 0) 828 return ret; 829 ret = mlx90632_read_ee_register(data->regmap, MLX90632_EE_Fa, &Fa); 830 if (ret < 0) 831 return ret; 832 ret = mlx90632_read_ee_register(data->regmap, MLX90632_EE_Fb, &Fb); 833 if (ret < 0) 834 return ret; 835 ret = mlx90632_read_ee_register(data->regmap, MLX90632_EE_Ga, &Ga); 836 if (ret < 0) 837 return ret; 838 ret = regmap_read(data->regmap, MLX90632_EE_Ha, &read_tmp); 839 if (ret < 0) 840 return ret; 841 Ha = (s16)read_tmp; 842 ret = regmap_read(data->regmap, MLX90632_EE_Hb, &read_tmp); 843 if (ret < 0) 844 return ret; 845 Hb = (s16)read_tmp; 846 ret = regmap_read(data->regmap, MLX90632_EE_Gb, &read_tmp); 847 if (ret < 0) 848 return ret; 849 Gb = (s16)read_tmp; 850 ret = regmap_read(data->regmap, MLX90632_EE_Ka, &read_tmp); 851 if (ret < 0) 852 return ret; 853 Ka = (s16)read_tmp; 854 855 ret = mlx90632_read_all_channel(data, 856 &ambient_new_raw, &ambient_old_raw, 857 &object_new_raw, &object_old_raw); 858 if (ret < 0) 859 return ret; 860 861 if (object_new_raw > MLX90632_EXTENDED_LIMIT && 862 data->mtyp == MLX90632_MTYP_EXTENDED) { 863 ret = mlx90632_read_all_channel_extended(data, &object_new_raw, 864 &ambient_new_raw, &ambient_old_raw); 865 if (ret < 0) 866 return ret; 867 868 /* Use extended mode calculations */ 869 ambient = mlx90632_preprocess_temp_amb(ambient_new_raw, 870 ambient_old_raw, Gb); 871 object = mlx90632_preprocess_temp_obj_extended(object_new_raw, 872 ambient_new_raw, 873 ambient_old_raw, Ka); 874 *val = mlx90632_calc_temp_object_extended(object, ambient, 875 data->object_ambient_temperature, 876 Ea, Eb, Fa, Fb, Ga, 877 Ha, Hb, data->emissivity); 878 return 0; 879 } 880 881 ambient = mlx90632_preprocess_temp_amb(ambient_new_raw, 882 ambient_old_raw, Gb); 883 object = mlx90632_preprocess_temp_obj(object_new_raw, 884 object_old_raw, 885 ambient_new_raw, 886 ambient_old_raw, Ka); 887 888 *val = mlx90632_calc_temp_object(object, ambient, Ea, Eb, Fa, Fb, Ga, 889 Ha, Hb, data->emissivity); 890 return 0; 891 } 892 893 static int mlx90632_calc_ambient_dsp105(struct mlx90632_data *data, int *val) 894 { 895 s16 ambient_new_raw, ambient_old_raw; 896 unsigned int read_tmp; 897 s32 PT, PR, PG, PO; 898 int ret; 899 s16 Gb; 900 901 ret = mlx90632_read_ee_register(data->regmap, MLX90632_EE_P_R, &PR); 902 if (ret < 0) 903 return ret; 904 ret = mlx90632_read_ee_register(data->regmap, MLX90632_EE_P_G, &PG); 905 if (ret < 0) 906 return ret; 907 ret = mlx90632_read_ee_register(data->regmap, MLX90632_EE_P_T, &PT); 908 if (ret < 0) 909 return ret; 910 ret = mlx90632_read_ee_register(data->regmap, MLX90632_EE_P_O, &PO); 911 if (ret < 0) 912 return ret; 913 ret = regmap_read(data->regmap, MLX90632_EE_Gb, &read_tmp); 914 if (ret < 0) 915 return ret; 916 Gb = (s16)read_tmp; 917 918 ret = mlx90632_read_ambient_raw(data->regmap, &ambient_new_raw, 919 &ambient_old_raw); 920 if (ret < 0) 921 return ret; 922 *val = mlx90632_calc_temp_ambient(ambient_new_raw, ambient_old_raw, 923 PT, PR, PG, PO, Gb); 924 return ret; 925 } 926 927 static int mlx90632_get_refresh_rate(struct mlx90632_data *data, 928 int *refresh_rate) 929 { 930 unsigned int meas1; 931 int ret; 932 933 ret = regmap_read(data->regmap, MLX90632_EE_MEDICAL_MEAS1, &meas1); 934 if (ret < 0) 935 return ret; 936 937 *refresh_rate = MLX90632_REFRESH_RATE(meas1); 938 939 return ret; 940 } 941 942 static const int mlx90632_freqs[][2] = { 943 {0, 500000}, 944 {1, 0}, 945 {2, 0}, 946 {4, 0}, 947 {8, 0}, 948 {16, 0}, 949 {32, 0}, 950 {64, 0} 951 }; 952 953 /** 954 * mlx90632_pm_interraction_wakeup() - Measure time between user interactions to change powermode 955 * @data: pointer to mlx90632_data object containing interaction_ts information 956 * 957 * Switch to continuous mode when interaction is faster than MLX90632_MEAS_MAX_TIME. Update the 958 * interaction_ts for each function call with the jiffies to enable measurement between function 959 * calls. Initial value of the interaction_ts needs to be set before this function call. 960 */ 961 static int mlx90632_pm_interraction_wakeup(struct mlx90632_data *data) 962 { 963 unsigned long now; 964 int ret; 965 966 now = jiffies; 967 if (time_in_range(now, data->interaction_ts, 968 data->interaction_ts + 969 msecs_to_jiffies(MLX90632_MEAS_MAX_TIME + 100))) { 970 if (data->powerstatus == MLX90632_PWR_STATUS_SLEEP_STEP) { 971 ret = mlx90632_pwr_continuous(data->regmap); 972 if (ret < 0) 973 return ret; 974 } 975 } 976 977 data->interaction_ts = now; 978 979 return 0; 980 } 981 982 static int mlx90632_read_raw(struct iio_dev *indio_dev, 983 struct iio_chan_spec const *channel, int *val, 984 int *val2, long mask) 985 { 986 struct mlx90632_data *data = iio_priv(indio_dev); 987 int ret; 988 int cr; 989 990 pm_runtime_get_sync(&data->client->dev); 991 ret = mlx90632_pm_interraction_wakeup(data); 992 if (ret < 0) 993 goto mlx90632_read_raw_pm; 994 995 switch (mask) { 996 case IIO_CHAN_INFO_PROCESSED: 997 switch (channel->channel2) { 998 case IIO_MOD_TEMP_AMBIENT: 999 ret = mlx90632_calc_ambient_dsp105(data, val); 1000 if (ret < 0) 1001 goto mlx90632_read_raw_pm; 1002 1003 ret = IIO_VAL_INT; 1004 break; 1005 case IIO_MOD_TEMP_OBJECT: 1006 ret = mlx90632_calc_object_dsp105(data, val); 1007 if (ret < 0) 1008 goto mlx90632_read_raw_pm; 1009 1010 ret = IIO_VAL_INT; 1011 break; 1012 default: 1013 ret = -EINVAL; 1014 break; 1015 } 1016 break; 1017 case IIO_CHAN_INFO_CALIBEMISSIVITY: 1018 if (data->emissivity == 1000) { 1019 *val = 1; 1020 *val2 = 0; 1021 } else { 1022 *val = 0; 1023 *val2 = data->emissivity * 1000; 1024 } 1025 ret = IIO_VAL_INT_PLUS_MICRO; 1026 break; 1027 case IIO_CHAN_INFO_CALIBAMBIENT: 1028 *val = data->object_ambient_temperature; 1029 ret = IIO_VAL_INT; 1030 break; 1031 case IIO_CHAN_INFO_SAMP_FREQ: 1032 ret = mlx90632_get_refresh_rate(data, &cr); 1033 if (ret < 0) 1034 goto mlx90632_read_raw_pm; 1035 1036 *val = mlx90632_freqs[cr][0]; 1037 *val2 = mlx90632_freqs[cr][1]; 1038 ret = IIO_VAL_INT_PLUS_MICRO; 1039 break; 1040 default: 1041 ret = -EINVAL; 1042 break; 1043 } 1044 1045 mlx90632_read_raw_pm: 1046 pm_runtime_mark_last_busy(&data->client->dev); 1047 pm_runtime_put_autosuspend(&data->client->dev); 1048 return ret; 1049 } 1050 1051 static int mlx90632_write_raw(struct iio_dev *indio_dev, 1052 struct iio_chan_spec const *channel, int val, 1053 int val2, long mask) 1054 { 1055 struct mlx90632_data *data = iio_priv(indio_dev); 1056 1057 switch (mask) { 1058 case IIO_CHAN_INFO_CALIBEMISSIVITY: 1059 /* Confirm we are within 0 and 1.0 */ 1060 if (val < 0 || val2 < 0 || val > 1 || 1061 (val == 1 && val2 != 0)) 1062 return -EINVAL; 1063 data->emissivity = val * 1000 + val2 / 1000; 1064 return 0; 1065 case IIO_CHAN_INFO_CALIBAMBIENT: 1066 data->object_ambient_temperature = val; 1067 return 0; 1068 default: 1069 return -EINVAL; 1070 } 1071 } 1072 1073 static int mlx90632_read_avail(struct iio_dev *indio_dev, 1074 struct iio_chan_spec const *chan, 1075 const int **vals, int *type, int *length, 1076 long mask) 1077 { 1078 switch (mask) { 1079 case IIO_CHAN_INFO_SAMP_FREQ: 1080 *vals = (int *)mlx90632_freqs; 1081 *type = IIO_VAL_INT_PLUS_MICRO; 1082 *length = 2 * ARRAY_SIZE(mlx90632_freqs); 1083 return IIO_AVAIL_LIST; 1084 default: 1085 return -EINVAL; 1086 } 1087 } 1088 1089 static const struct iio_chan_spec mlx90632_channels[] = { 1090 { 1091 .type = IIO_TEMP, 1092 .modified = 1, 1093 .channel2 = IIO_MOD_TEMP_AMBIENT, 1094 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), 1095 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), 1096 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_SAMP_FREQ), 1097 }, 1098 { 1099 .type = IIO_TEMP, 1100 .modified = 1, 1101 .channel2 = IIO_MOD_TEMP_OBJECT, 1102 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 1103 BIT(IIO_CHAN_INFO_CALIBEMISSIVITY) | BIT(IIO_CHAN_INFO_CALIBAMBIENT), 1104 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), 1105 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_SAMP_FREQ), 1106 }, 1107 }; 1108 1109 static const struct iio_info mlx90632_info = { 1110 .read_raw = mlx90632_read_raw, 1111 .write_raw = mlx90632_write_raw, 1112 .read_avail = mlx90632_read_avail, 1113 }; 1114 1115 static void mlx90632_sleep(void *_data) 1116 { 1117 struct mlx90632_data *data = _data; 1118 1119 mlx90632_pwr_set_sleep_step(data->regmap); 1120 } 1121 1122 static int mlx90632_suspend(struct mlx90632_data *data) 1123 { 1124 regcache_mark_dirty(data->regmap); 1125 1126 dev_dbg(&data->client->dev, "Requesting suspend"); 1127 return mlx90632_pwr_set_sleep_step(data->regmap); 1128 } 1129 1130 static int mlx90632_wakeup(struct mlx90632_data *data) 1131 { 1132 int ret; 1133 1134 ret = regcache_sync(data->regmap); 1135 if (ret < 0) { 1136 dev_err(&data->client->dev, 1137 "Failed to sync regmap registers: %d\n", ret); 1138 return ret; 1139 } 1140 1141 dev_dbg(&data->client->dev, "Requesting wake-up\n"); 1142 return mlx90632_pwr_continuous(data->regmap); 1143 } 1144 1145 static void mlx90632_disable_regulator(void *_data) 1146 { 1147 struct mlx90632_data *data = _data; 1148 int ret; 1149 1150 ret = regulator_disable(data->regulator); 1151 if (ret < 0) 1152 dev_err(regmap_get_device(data->regmap), 1153 "Failed to disable power regulator: %d\n", ret); 1154 } 1155 1156 static int mlx90632_enable_regulator(struct mlx90632_data *data) 1157 { 1158 int ret; 1159 1160 ret = regulator_enable(data->regulator); 1161 if (ret < 0) { 1162 dev_err(regmap_get_device(data->regmap), "Failed to enable power regulator!\n"); 1163 return ret; 1164 } 1165 1166 mlx90632_reset_delay(); 1167 1168 return ret; 1169 } 1170 1171 static int mlx90632_probe(struct i2c_client *client) 1172 { 1173 const struct i2c_device_id *id = i2c_client_get_device_id(client); 1174 struct mlx90632_data *mlx90632; 1175 struct iio_dev *indio_dev; 1176 struct regmap *regmap; 1177 unsigned int read; 1178 int ret; 1179 1180 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*mlx90632)); 1181 if (!indio_dev) { 1182 dev_err(&client->dev, "Failed to allocate device\n"); 1183 return -ENOMEM; 1184 } 1185 1186 regmap = devm_regmap_init_i2c(client, &mlx90632_regmap); 1187 if (IS_ERR(regmap)) { 1188 ret = PTR_ERR(regmap); 1189 dev_err(&client->dev, "Failed to allocate regmap: %d\n", ret); 1190 return ret; 1191 } 1192 1193 mlx90632 = iio_priv(indio_dev); 1194 i2c_set_clientdata(client, indio_dev); 1195 mlx90632->client = client; 1196 mlx90632->regmap = regmap; 1197 mlx90632->mtyp = MLX90632_MTYP_MEDICAL; 1198 mlx90632->powerstatus = MLX90632_PWR_STATUS_HALT; 1199 1200 mutex_init(&mlx90632->lock); 1201 indio_dev->name = id->name; 1202 indio_dev->modes = INDIO_DIRECT_MODE; 1203 indio_dev->info = &mlx90632_info; 1204 indio_dev->channels = mlx90632_channels; 1205 indio_dev->num_channels = ARRAY_SIZE(mlx90632_channels); 1206 1207 mlx90632->regulator = devm_regulator_get(&client->dev, "vdd"); 1208 if (IS_ERR(mlx90632->regulator)) 1209 return dev_err_probe(&client->dev, PTR_ERR(mlx90632->regulator), 1210 "failed to get vdd regulator"); 1211 1212 ret = mlx90632_enable_regulator(mlx90632); 1213 if (ret < 0) 1214 return ret; 1215 1216 ret = devm_add_action_or_reset(&client->dev, mlx90632_disable_regulator, 1217 mlx90632); 1218 if (ret < 0) { 1219 dev_err(&client->dev, "Failed to setup regulator cleanup action %d\n", 1220 ret); 1221 return ret; 1222 } 1223 1224 ret = mlx90632_wakeup(mlx90632); 1225 if (ret < 0) { 1226 dev_err(&client->dev, "Wakeup failed: %d\n", ret); 1227 return ret; 1228 } 1229 1230 ret = devm_add_action_or_reset(&client->dev, mlx90632_sleep, mlx90632); 1231 if (ret < 0) { 1232 dev_err(&client->dev, "Failed to setup low power cleanup action %d\n", 1233 ret); 1234 return ret; 1235 } 1236 1237 ret = regmap_read(mlx90632->regmap, MLX90632_EE_VERSION, &read); 1238 if (ret < 0) { 1239 dev_err(&client->dev, "read of version failed: %d\n", ret); 1240 return ret; 1241 } 1242 read = read & MLX90632_ID_MASK; 1243 if (read == MLX90632_ID_MEDICAL) { 1244 dev_dbg(&client->dev, 1245 "Detected Medical EEPROM calibration %x\n", read); 1246 } else if (read == MLX90632_ID_CONSUMER) { 1247 dev_dbg(&client->dev, 1248 "Detected Consumer EEPROM calibration %x\n", read); 1249 } else if (read == MLX90632_ID_EXTENDED) { 1250 dev_dbg(&client->dev, 1251 "Detected Extended range EEPROM calibration %x\n", read); 1252 mlx90632->mtyp = MLX90632_MTYP_EXTENDED; 1253 } else if ((read & MLX90632_DSP_MASK) == MLX90632_DSP_VERSION) { 1254 dev_dbg(&client->dev, 1255 "Detected Unknown EEPROM calibration %x\n", read); 1256 } else { 1257 dev_err(&client->dev, 1258 "Wrong DSP version %x (expected %x)\n", 1259 read, MLX90632_DSP_VERSION); 1260 return -EPROTONOSUPPORT; 1261 } 1262 1263 mlx90632->emissivity = 1000; 1264 mlx90632->object_ambient_temperature = 25000; /* 25 degrees milliCelsius */ 1265 mlx90632->interaction_ts = jiffies; /* Set initial value */ 1266 1267 pm_runtime_get_noresume(&client->dev); 1268 pm_runtime_set_active(&client->dev); 1269 1270 ret = devm_pm_runtime_enable(&client->dev); 1271 if (ret) 1272 return ret; 1273 1274 pm_runtime_set_autosuspend_delay(&client->dev, MLX90632_SLEEP_DELAY_MS); 1275 pm_runtime_use_autosuspend(&client->dev); 1276 pm_runtime_put_autosuspend(&client->dev); 1277 1278 return devm_iio_device_register(&client->dev, indio_dev); 1279 } 1280 1281 static const struct i2c_device_id mlx90632_id[] = { 1282 { "mlx90632" }, 1283 { } 1284 }; 1285 MODULE_DEVICE_TABLE(i2c, mlx90632_id); 1286 1287 static const struct of_device_id mlx90632_of_match[] = { 1288 { .compatible = "melexis,mlx90632" }, 1289 { } 1290 }; 1291 MODULE_DEVICE_TABLE(of, mlx90632_of_match); 1292 1293 static int mlx90632_pm_suspend(struct device *dev) 1294 { 1295 struct mlx90632_data *data = iio_priv(dev_get_drvdata(dev)); 1296 int ret; 1297 1298 ret = mlx90632_suspend(data); 1299 if (ret < 0) 1300 return ret; 1301 1302 ret = regulator_disable(data->regulator); 1303 if (ret < 0) 1304 dev_err(regmap_get_device(data->regmap), 1305 "Failed to disable power regulator: %d\n", ret); 1306 1307 return ret; 1308 } 1309 1310 static int mlx90632_pm_resume(struct device *dev) 1311 { 1312 struct mlx90632_data *data = iio_priv(dev_get_drvdata(dev)); 1313 int ret; 1314 1315 ret = mlx90632_enable_regulator(data); 1316 if (ret < 0) 1317 return ret; 1318 1319 return mlx90632_wakeup(data); 1320 } 1321 1322 static int mlx90632_pm_runtime_suspend(struct device *dev) 1323 { 1324 struct mlx90632_data *data = iio_priv(dev_get_drvdata(dev)); 1325 1326 return mlx90632_pwr_set_sleep_step(data->regmap); 1327 } 1328 1329 static const struct dev_pm_ops mlx90632_pm_ops = { 1330 SYSTEM_SLEEP_PM_OPS(mlx90632_pm_suspend, mlx90632_pm_resume) 1331 RUNTIME_PM_OPS(mlx90632_pm_runtime_suspend, NULL, NULL) 1332 }; 1333 1334 static struct i2c_driver mlx90632_driver = { 1335 .driver = { 1336 .name = "mlx90632", 1337 .of_match_table = mlx90632_of_match, 1338 .pm = pm_ptr(&mlx90632_pm_ops), 1339 }, 1340 .probe = mlx90632_probe, 1341 .id_table = mlx90632_id, 1342 }; 1343 module_i2c_driver(mlx90632_driver); 1344 1345 MODULE_AUTHOR("Crt Mori <cmo@melexis.com>"); 1346 MODULE_DESCRIPTION("Melexis MLX90632 contactless Infra Red temperature sensor driver"); 1347 MODULE_LICENSE("GPL v2"); 1348