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