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