mlx90635.c

   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 */
 125struct 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
 136static 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
 144static 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
 149static 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
 157static 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
 162static const struct regmap_range mlx90635_no_write_reg_range[] = {
 163	regmap_reg_range(MLX90635_RESULT_1, MLX90635_RESULT_5),
 164};
 165
 166static 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
 171static 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
 189static 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
 194static 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
 199static const struct regmap_range mlx90635_no_write_ee_range[] = {
 200	regmap_reg_range(MLX90635_ADDR_EEPROM, MLX90635_EE_Gb),
 201};
 202
 203static 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
 208static 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 */
 230static void mlx90635_reset_delay(void)
 231{
 232	usleep_range(MLX90635_TIMING_RST_MIN, MLX90635_TIMING_RST_MAX);
 233}
 234
 235static 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
 251static 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
 267static 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
 289static 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
 312static 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
 363static 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, &reg);
 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
 377static 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
 411static 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
 430static 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
 450static 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);
 470read_unlock:
 471	mutex_unlock(&data->lock);
 472	return ret;
 473}
 474
 475static 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
 490static 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
 507static 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
 520static 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
 547static 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
 555static 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
 577static 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
 607static 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);
 626read_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
 636static 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, &reg);
 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
 651static 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 */
 673static 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
 692static 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
 751mlx90635_read_raw_pm:
 752	pm_runtime_put_autosuspend(&data->client->dev);
 753	return ret;
 754}
 755
 756static int mlx90635_write_raw(struct iio_dev *indio_dev,
 757			      struct iio_chan_spec const *channel, int val,
 758			      int val2, long mask)
 759{
 760	struct mlx90635_data *data = iio_priv(indio_dev);
 761	int ret;
 762	int i;
 763
 764	switch (mask) {
 765	case IIO_CHAN_INFO_CALIBEMISSIVITY:
 766		/* Confirm we are within 0 and 1.0 */
 767		if (val < 0 || val2 < 0 || val > 1 ||
 768		    (val == 1 && val2 != 0))
 769			return -EINVAL;
 770		data->emissivity = val * 1000 + val2 / 1000;
 771		return 0;
 772	case IIO_CHAN_INFO_SAMP_FREQ:
 773		for (i = 0; i < ARRAY_SIZE(mlx90635_freqs); i++) {
 774			if (val == mlx90635_freqs[i].val &&
 775			    val2 == mlx90635_freqs[i].val2)
 776				break;
 777		}
 778		if (i == ARRAY_SIZE(mlx90635_freqs))
 779			return -EINVAL;
 780
 781		ret = regmap_write_bits(data->regmap, MLX90635_REG_CTRL1,
 782					MLX90635_CTRL1_REFRESH_RATE_MASK, i);
 783
 784		return ret;
 785	default:
 786		return -EINVAL;
 787	}
 788}
 789
 790static int mlx90635_read_avail(struct iio_dev *indio_dev,
 791			       struct iio_chan_spec const *chan,
 792			       const int **vals, int *type, int *length,
 793			       long mask)
 794{
 795	switch (mask) {
 796	case IIO_CHAN_INFO_SAMP_FREQ:
 797		*vals = (int *)mlx90635_freqs;
 798		*type = IIO_VAL_INT_PLUS_MICRO;
 799		*length = 2 * ARRAY_SIZE(mlx90635_freqs);
 800		return IIO_AVAIL_LIST;
 801	default:
 802		return -EINVAL;
 803	}
 804}
 805
 806static const struct iio_chan_spec mlx90635_channels[] = {
 807	{
 808		.type = IIO_TEMP,
 809		.modified = 1,
 810		.channel2 = IIO_MOD_TEMP_AMBIENT,
 811		.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
 812		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
 813		.info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_SAMP_FREQ),
 814	},
 815	{
 816		.type = IIO_TEMP,
 817		.modified = 1,
 818		.channel2 = IIO_MOD_TEMP_OBJECT,
 819		.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
 820			BIT(IIO_CHAN_INFO_CALIBEMISSIVITY),
 821		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
 822		.info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_SAMP_FREQ),
 823	},
 824};
 825
 826static const struct iio_info mlx90635_info = {
 827	.read_raw = mlx90635_read_raw,
 828	.write_raw = mlx90635_write_raw,
 829	.read_avail = mlx90635_read_avail,
 830};
 831
 832static void mlx90635_sleep(void *_data)
 833{
 834	struct mlx90635_data *data = _data;
 835
 836	mlx90635_pwr_sleep_step(data);
 837}
 838
 839static int mlx90635_suspend(struct mlx90635_data *data)
 840{
 841	return mlx90635_pwr_sleep_step(data);
 842}
 843
 844static int mlx90635_wakeup(struct mlx90635_data *data)
 845{
 846	s16 Fb, Ga, Gb, Ha, Hb, PG, PO;
 847	unsigned int dsp_version;
 848	u32 Ea, Eb, Fa;
 849	u16 Fa_scale;
 850	int ret;
 851
 852	regcache_cache_bypass(data->regmap_ee, false);
 853	regcache_cache_only(data->regmap_ee, false);
 854	regcache_cache_only(data->regmap, false);
 855
 856	ret = mlx90635_pwr_continuous(data);
 857	if (ret < 0) {
 858		dev_err(&data->client->dev, "Switch to continuous mode failed\n");
 859		return ret;
 860	}
 861	ret = regmap_write_bits(data->regmap, MLX90635_REG_EE,
 862				MLX90635_EE_ACTIVE, MLX90635_EE_ACTIVE);
 863	if (ret < 0) {
 864		dev_err(&data->client->dev, "Powering EEPROM failed\n");
 865		return ret;
 866	}
 867	usleep_range(MLX90635_TIMING_EE_ACTIVE_MIN, MLX90635_TIMING_EE_ACTIVE_MAX);
 868
 869	regcache_mark_dirty(data->regmap_ee);
 870
 871	ret = regcache_sync(data->regmap_ee);
 872	if (ret < 0) {
 873		dev_err(&data->client->dev,
 874			"Failed to sync cache: %d\n", ret);
 875		return ret;
 876	}
 877
 878	ret = mlx90635_read_ee_ambient(data->regmap_ee, &PG, &PO, &Gb);
 879	if (ret < 0) {
 880		dev_err(&data->client->dev,
 881			"Failed to read to cache Ambient coefficients EEPROM region: %d\n", ret);
 882		return ret;
 883	}
 884
 885	ret = mlx90635_read_ee_object(data->regmap_ee, &Ea, &Eb, &Fa, &Fb, &Ga, &Gb, &Ha, &Hb, &Fa_scale);
 886	if (ret < 0) {
 887		dev_err(&data->client->dev,
 888			"Failed to read to cache Object coefficients EEPROM region: %d\n", ret);
 889		return ret;
 890	}
 891
 892	ret = regmap_read(data->regmap_ee, MLX90635_EE_VERSION, &dsp_version);
 893	if (ret < 0) {
 894		dev_err(&data->client->dev,
 895			"Failed to read to cache of EEPROM version: %d\n", ret);
 896		return ret;
 897	}
 898
 899	regcache_cache_only(data->regmap_ee, true);
 900
 901	return ret;
 902}
 903
 904static void mlx90635_disable_regulator(void *_data)
 905{
 906	struct mlx90635_data *data = _data;
 907	int ret;
 908
 909	ret = regulator_disable(data->regulator);
 910	if (ret < 0)
 911		dev_err(regmap_get_device(data->regmap),
 912			"Failed to disable power regulator: %d\n", ret);
 913}
 914
 915static int mlx90635_enable_regulator(struct mlx90635_data *data)
 916{
 917	int ret;
 918
 919	ret = regulator_enable(data->regulator);
 920	if (ret < 0) {
 921		dev_err(regmap_get_device(data->regmap), "Failed to enable power regulator!\n");
 922		return ret;
 923	}
 924
 925	mlx90635_reset_delay();
 926
 927	return ret;
 928}
 929
 930static int mlx90635_probe(struct i2c_client *client)
 931{
 932	struct mlx90635_data *mlx90635;
 933	struct iio_dev *indio_dev;
 934	unsigned int dsp_version;
 935	struct regmap *regmap;
 936	struct regmap *regmap_ee;
 937	int ret;
 938
 939	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*mlx90635));
 940	if (!indio_dev)
 941		return -ENOMEM;
 942
 943	regmap = devm_regmap_init_i2c(client, &mlx90635_regmap);
 944	if (IS_ERR(regmap))
 945		return dev_err_probe(&client->dev, PTR_ERR(regmap),
 946				     "failed to allocate regmap\n");
 947
 948	regmap_ee = devm_regmap_init_i2c(client, &mlx90635_regmap_ee);
 949	if (IS_ERR(regmap_ee))
 950		return dev_err_probe(&client->dev, PTR_ERR(regmap_ee),
 951				     "failed to allocate EEPROM regmap\n");
 952
 953	mlx90635 = iio_priv(indio_dev);
 954	i2c_set_clientdata(client, indio_dev);
 955	mlx90635->client = client;
 956	mlx90635->regmap = regmap;
 957	mlx90635->regmap_ee = regmap_ee;
 958	mlx90635->powerstatus = MLX90635_PWR_STATUS_SLEEP_STEP;
 959
 960	mutex_init(&mlx90635->lock);
 961	indio_dev->name = "mlx90635";
 962	indio_dev->modes = INDIO_DIRECT_MODE;
 963	indio_dev->info = &mlx90635_info;
 964	indio_dev->channels = mlx90635_channels;
 965	indio_dev->num_channels = ARRAY_SIZE(mlx90635_channels);
 966
 967	mlx90635->regulator = devm_regulator_get(&client->dev, "vdd");
 968	if (IS_ERR(mlx90635->regulator))
 969		return dev_err_probe(&client->dev, PTR_ERR(mlx90635->regulator),
 970				     "failed to get vdd regulator");
 971
 972	ret = mlx90635_enable_regulator(mlx90635);
 973	if (ret < 0)
 974		return ret;
 975
 976	ret = devm_add_action_or_reset(&client->dev, mlx90635_disable_regulator,
 977				       mlx90635);
 978	if (ret < 0)
 979		return ret;
 980
 981	ret = mlx90635_wakeup(mlx90635);
 982	if (ret < 0)
 983		return dev_err_probe(&client->dev, ret, "wakeup failed\n");
 984
 985	ret = devm_add_action_or_reset(&client->dev, mlx90635_sleep, mlx90635);
 986	if (ret < 0)
 987		return ret;
 988
 989	ret = regmap_read(mlx90635->regmap_ee, MLX90635_EE_VERSION, &dsp_version);
 990	if (ret < 0)
 991		return dev_err_probe(&client->dev, ret, "read of version failed\n");
 992
 993	dsp_version = dsp_version & MLX90635_VERSION_MASK;
 994
 995	if (FIELD_GET(MLX90635_DSP_FIXED, dsp_version)) {
 996		if (MLX90635_DSP_VERSION(dsp_version) == MLX90635_ID_DSPv1) {
 997			dev_dbg(&client->dev,
 998				"Detected DSP v1 calibration %x\n", dsp_version);
 999		} else {
1000			dev_dbg(&client->dev,
1001				"Detected Unknown EEPROM calibration %lx\n",
1002				MLX90635_DSP_VERSION(dsp_version));
1003		}
1004	} else {
1005		return dev_err_probe(&client->dev, -EPROTONOSUPPORT,
1006			"Wrong fixed top bit %x (expected 0x8X0X)\n",
1007			dsp_version);
1008	}
1009
1010	mlx90635->emissivity = 1000;
1011	mlx90635->interaction_ts = jiffies; /* Set initial value */
1012
1013	pm_runtime_get_noresume(&client->dev);
1014	pm_runtime_set_active(&client->dev);
1015
1016	ret = devm_pm_runtime_enable(&client->dev);
1017	if (ret)
1018		return dev_err_probe(&client->dev, ret,
1019				     "failed to enable powermanagement\n");
1020
1021	pm_runtime_set_autosuspend_delay(&client->dev, MLX90635_SLEEP_DELAY_MS);
1022	pm_runtime_use_autosuspend(&client->dev);
1023	pm_runtime_put_autosuspend(&client->dev);
1024
1025	return devm_iio_device_register(&client->dev, indio_dev);
1026}
1027
1028static const struct i2c_device_id mlx90635_id[] = {
1029	{ "mlx90635" },
1030	{ }
1031};
1032MODULE_DEVICE_TABLE(i2c, mlx90635_id);
1033
1034static const struct of_device_id mlx90635_of_match[] = {
1035	{ .compatible = "melexis,mlx90635" },
1036	{ }
1037};
1038MODULE_DEVICE_TABLE(of, mlx90635_of_match);
1039
1040static int mlx90635_pm_suspend(struct device *dev)
1041{
1042	struct mlx90635_data *data = iio_priv(dev_get_drvdata(dev));
1043	int ret;
1044
1045	ret = mlx90635_suspend(data);
1046	if (ret < 0)
1047		return ret;
1048
1049	ret = regulator_disable(data->regulator);
1050	if (ret < 0)
1051		dev_err(regmap_get_device(data->regmap),
1052			"Failed to disable power regulator: %d\n", ret);
1053
1054	return ret;
1055}
1056
1057static int mlx90635_pm_resume(struct device *dev)
1058{
1059	struct mlx90635_data *data = iio_priv(dev_get_drvdata(dev));
1060	int ret;
1061
1062	ret = mlx90635_enable_regulator(data);
1063	if (ret < 0)
1064		return ret;
1065
1066	return mlx90635_wakeup(data);
1067}
1068
1069static int mlx90635_pm_runtime_suspend(struct device *dev)
1070{
1071	struct mlx90635_data *data = iio_priv(dev_get_drvdata(dev));
1072
1073	return mlx90635_pwr_sleep_step(data);
1074}
1075
1076static const struct dev_pm_ops mlx90635_pm_ops = {
1077	SYSTEM_SLEEP_PM_OPS(mlx90635_pm_suspend, mlx90635_pm_resume)
1078	RUNTIME_PM_OPS(mlx90635_pm_runtime_suspend, NULL, NULL)
1079};
1080
1081static struct i2c_driver mlx90635_driver = {
1082	.driver = {
1083		.name	= "mlx90635",
1084		.of_match_table = mlx90635_of_match,
1085		.pm	= pm_ptr(&mlx90635_pm_ops),
1086	},
1087	.probe = mlx90635_probe,
1088	.id_table = mlx90635_id,
1089};
1090module_i2c_driver(mlx90635_driver);
1091
1092MODULE_AUTHOR("Crt Mori <cmo@melexis.com>");
1093MODULE_DESCRIPTION("Melexis MLX90635 contactless Infra Red temperature sensor driver");
1094MODULE_LICENSE("GPL");