tlv493d.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Driver for the Infineon TLV493D Low-Power 3D Magnetic Sensor
  4 *
  5 * Copyright (C) 2025 Dixit Parmar <dixitparmar19@gmail.com>
  6 */
  7
  8#include <linux/array_size.h>
  9#include <linux/bits.h>
 10#include <linux/bitfield.h>
 11#include <linux/cleanup.h>
 12#include <linux/delay.h>
 13#include <linux/dev_printk.h>
 14#include <linux/i2c.h>
 15#include <linux/iopoll.h>
 16#include <linux/module.h>
 17#include <linux/mod_devicetable.h>
 18#include <linux/pm.h>
 19#include <linux/pm_runtime.h>
 20#include <linux/regulator/consumer.h>
 21#include <linux/types.h>
 22#include <linux/units.h>
 23
 24#include <linux/iio/buffer.h>
 25#include <linux/iio/iio.h>
 26#include <linux/iio/trigger_consumer.h>
 27#include <linux/iio/triggered_buffer.h>
 28
 29/*
 30 * TLV493D sensor I2C communication note:
 31 *
 32 * The sensor supports only direct byte-stream write starting from the
 33 * register address 0x0. So for any modification to be made to any write
 34 * registers, it must be written starting from the register address  0x0.
 35 * I2C write operation should not contain the register address in the I2C
 36 * frame, it should contain only raw byte stream for the write registers.
 37 * I2C Frame: |S|SlaveAddr Wr|Ack|Byte[0]|Ack|Byte[1]|Ack|.....|Sp|
 38 *
 39 * Same as the write operation, reading from the sensor registers is also
 40 * performed starting from the register address 0x0 for as many bytes as
 41 * need to be read.
 42 * I2C read operation should not contain the register address in the I2C frame.
 43 * I2C Frame: |S|SlaveAddr Rd|Ack|Byte[0]|Ack|Byte[1]|Ack|.....|Sp|
 44 */
 45
 46#define TLV493D_RD_REG_BX	0x00
 47#define TLV493D_RD_REG_BY	0x01
 48#define TLV493D_RD_REG_BZ	0x02
 49#define TLV493D_RD_REG_TEMP	0x03
 50#define TLV493D_RD_REG_BX2	0x04
 51#define TLV493D_RD_REG_BZ2	0x05
 52#define TLV493D_RD_REG_TEMP2	0x06
 53#define TLV493D_RD_REG_RES1	0x07
 54#define TLV493D_RD_REG_RES2	0x08
 55#define TLV493D_RD_REG_RES3	0x09
 56#define TLV493D_RD_REG_MAX	0x0a
 57
 58#define TLV493D_WR_REG_MODE1	0x01
 59#define TLV493D_WR_REG_MODE2	0x03
 60#define TLV493D_WR_REG_MAX	0x04
 61
 62#define TLV493D_BX_MAG_X_AXIS_MSB	GENMASK(7, 0)
 63#define TLV493D_BX2_MAG_X_AXIS_LSB	GENMASK(7, 4)
 64#define TLV493D_BY_MAG_Y_AXIS_MSB	GENMASK(7, 0)
 65#define TLV493D_BX2_MAG_Y_AXIS_LSB	GENMASK(3, 0)
 66#define TLV493D_BZ_MAG_Z_AXIS_MSB	GENMASK(7, 0)
 67#define TLV493D_BZ2_MAG_Z_AXIS_LSB	GENMASK(3, 0)
 68#define TLV493D_TEMP_TEMP_MSB		GENMASK(7, 4)
 69#define TLV493D_TEMP2_TEMP_LSB		GENMASK(7, 0)
 70#define TLV493D_TEMP_CHANNEL		GENMASK(1, 0)
 71#define TLV493D_MODE1_MOD_LOWFAST	GENMASK(1, 0)
 72#define TLV493D_MODE2_LP_PERIOD	BIT(6)
 73#define TLV493D_RD_REG_RES1_WR_MASK	GENMASK(4, 3)
 74#define TLV493D_RD_REG_RES2_WR_MASK	GENMASK(7, 0)
 75#define TLV493D_RD_REG_RES3_WR_MASK	GENMASK(4, 0)
 76
 77enum tlv493d_channels {
 78	TLV493D_AXIS_X,
 79	TLV493D_AXIS_Y,
 80	TLV493D_AXIS_Z,
 81	TLV493D_TEMPERATURE,
 82};
 83
 84enum tlv493d_op_mode {
 85	TLV493D_OP_MODE_POWERDOWN,
 86	TLV493D_OP_MODE_FAST,
 87	TLV493D_OP_MODE_LOWPOWER,
 88	TLV493D_OP_MODE_ULTRA_LOWPOWER,
 89	TLV493D_OP_MODE_MASTERCONTROLLED,
 90};
 91
 92struct tlv493d_data {
 93	struct i2c_client *client;
 94	/* protects from simultaneous sensor access and register readings */
 95	struct mutex lock;
 96	enum tlv493d_op_mode mode;
 97	u8 wr_regs[TLV493D_WR_REG_MAX];
 98};
 99
100/*
101 * Different mode has different measurement sampling time, this time is
102 * used in deriving the sleep and timeout while reading the data from
103 * sensor in polling.
104 * Power-down mode: No measurement.
105 * Fast mode: Freq:3.3 KHz. Measurement time:305 usec.
106 * Low-power mode: Freq:100 Hz. Measurement time:10 msec.
107 * Ultra low-power mode: Freq:10 Hz. Measurement time:100 msec.
108 * Master controlled mode: Freq:3.3 Khz. Measurement time:305 usec.
109 */
110static const u32 tlv493d_sample_rate_us[] = {
111	[TLV493D_OP_MODE_POWERDOWN] = 0,
112	[TLV493D_OP_MODE_FAST] = 305,
113	[TLV493D_OP_MODE_LOWPOWER] = 10 * USEC_PER_MSEC,
114	[TLV493D_OP_MODE_ULTRA_LOWPOWER] = 100 * USEC_PER_MSEC,
115	[TLV493D_OP_MODE_MASTERCONTROLLED] = 305,
116};
117
118static int tlv493d_write_all_regs(struct tlv493d_data *data)
119{
120	int ret;
121	struct device *dev = &data->client->dev;
122
123	ret = i2c_master_send(data->client, data->wr_regs, ARRAY_SIZE(data->wr_regs));
124	if (ret < 0) {
125		dev_err(dev, "i2c write registers failed, error: %d\n", ret);
126		return ret;
127	}
128
129	return 0;
130}
131
132static int tlv493d_set_operating_mode(struct tlv493d_data *data, enum tlv493d_op_mode mode)
133{
134	u8 *mode1_cfg = &data->wr_regs[TLV493D_WR_REG_MODE1];
135	u8 *mode2_cfg = &data->wr_regs[TLV493D_WR_REG_MODE2];
136
137	switch (mode) {
138	case TLV493D_OP_MODE_POWERDOWN:
139		FIELD_MODIFY(TLV493D_MODE1_MOD_LOWFAST, mode1_cfg, 0);
140		FIELD_MODIFY(TLV493D_MODE2_LP_PERIOD, mode2_cfg, 0);
141		break;
142
143	case TLV493D_OP_MODE_FAST:
144		FIELD_MODIFY(TLV493D_MODE1_MOD_LOWFAST, mode1_cfg, 1);
145		FIELD_MODIFY(TLV493D_MODE2_LP_PERIOD, mode2_cfg, 0);
146		break;
147
148	case TLV493D_OP_MODE_LOWPOWER:
149		FIELD_MODIFY(TLV493D_MODE1_MOD_LOWFAST, mode1_cfg, 2);
150		FIELD_MODIFY(TLV493D_MODE2_LP_PERIOD, mode2_cfg, 1);
151		break;
152
153	case TLV493D_OP_MODE_ULTRA_LOWPOWER:
154		FIELD_MODIFY(TLV493D_MODE1_MOD_LOWFAST, mode1_cfg, 2);
155		FIELD_MODIFY(TLV493D_MODE2_LP_PERIOD, mode2_cfg, 0);
156		break;
157
158	case TLV493D_OP_MODE_MASTERCONTROLLED:
159		FIELD_MODIFY(TLV493D_MODE1_MOD_LOWFAST, mode1_cfg, 3);
160		FIELD_MODIFY(TLV493D_MODE2_LP_PERIOD, mode2_cfg, 0);
161		break;
162	}
163
164	return tlv493d_write_all_regs(data);
165}
166
167static s16 tlv493d_get_channel_data(u8 *b, enum tlv493d_channels ch)
168{
169	u16 val;
170
171	switch (ch) {
172	case TLV493D_AXIS_X:
173		val = FIELD_GET(TLV493D_BX_MAG_X_AXIS_MSB, b[TLV493D_RD_REG_BX]) << 4 |
174		      FIELD_GET(TLV493D_BX2_MAG_X_AXIS_LSB, b[TLV493D_RD_REG_BX2]);
175		break;
176	case TLV493D_AXIS_Y:
177		val = FIELD_GET(TLV493D_BY_MAG_Y_AXIS_MSB, b[TLV493D_RD_REG_BY]) << 4 |
178		      FIELD_GET(TLV493D_BX2_MAG_Y_AXIS_LSB, b[TLV493D_RD_REG_BX2]);
179		break;
180	case TLV493D_AXIS_Z:
181		val = FIELD_GET(TLV493D_BZ_MAG_Z_AXIS_MSB, b[TLV493D_RD_REG_BZ]) << 4 |
182		      FIELD_GET(TLV493D_BZ2_MAG_Z_AXIS_LSB, b[TLV493D_RD_REG_BZ2]);
183		break;
184	case TLV493D_TEMPERATURE:
185		val = FIELD_GET(TLV493D_TEMP_TEMP_MSB, b[TLV493D_RD_REG_TEMP]) << 8 |
186		      FIELD_GET(TLV493D_TEMP2_TEMP_LSB, b[TLV493D_RD_REG_TEMP2]);
187		break;
188	}
189
190	return sign_extend32(val, 11);
191}
192
193static int tlv493d_get_measurements(struct tlv493d_data *data, s16 *x, s16 *y,
194				    s16 *z, s16 *t)
195{
196	u8 buff[7] = {};
197	int err, ret;
198	struct device *dev = &data->client->dev;
199	u32 sleep_us = tlv493d_sample_rate_us[data->mode];
200
201	guard(mutex)(&data->lock);
202
203	ret = pm_runtime_resume_and_get(dev);
204	if (ret < 0)
205		return ret;
206
207	/*
208	 * Poll until data is valid.
209	 * For a valid data TLV493D_TEMP_CHANNEL bit of TLV493D_RD_REG_TEMP
210	 * should be set to 0. The sampling time depends on the sensor mode.
211	 * Poll 3x the time of the sampling time.
212	 */
213	ret = read_poll_timeout(i2c_master_recv, err,
214			err || !FIELD_GET(TLV493D_TEMP_CHANNEL, buff[TLV493D_RD_REG_TEMP]),
215			sleep_us, 3 * sleep_us, false, data->client, buff,
216			ARRAY_SIZE(buff));
217	if (ret) {
218		dev_err(dev, "i2c read poll timeout, error:%d\n", ret);
219		goto out_put_autosuspend;
220	}
221	if (err < 0) {
222		dev_err(dev, "i2c read data failed, error:%d\n", err);
223		ret = err;
224		goto out_put_autosuspend;
225	}
226
227	*x = tlv493d_get_channel_data(buff, TLV493D_AXIS_X);
228	*y = tlv493d_get_channel_data(buff, TLV493D_AXIS_Y);
229	*z = tlv493d_get_channel_data(buff, TLV493D_AXIS_Z);
230	*t = tlv493d_get_channel_data(buff, TLV493D_TEMPERATURE);
231
232out_put_autosuspend:
233	pm_runtime_put_autosuspend(dev);
234	return ret;
235}
236
237static int tlv493d_init(struct tlv493d_data *data)
238{
239	int ret;
240	u8 buff[TLV493D_RD_REG_MAX];
241	struct device *dev = &data->client->dev;
242
243	/*
244	 * The sensor initialization requires below steps to be followed,
245	 * 1. Power-up sensor.
246	 * 2. Read and store read-registers map (0x0-0x9).
247	 * 3. Copy values from read reserved registers to write reserved fields
248	 *    (0x0-0x3).
249	 * 4. Set operating mode.
250	 * 5. Write to all registers.
251	 */
252	ret = i2c_master_recv(data->client, buff, ARRAY_SIZE(buff));
253	if (ret < 0)
254		return dev_err_probe(dev, ret, "i2c read failed\n");
255
256	/* Write register 0x0 is reserved. Does not require to be updated.*/
257	data->wr_regs[0] = 0;
258	data->wr_regs[1] = buff[TLV493D_RD_REG_RES1] & TLV493D_RD_REG_RES1_WR_MASK;
259	data->wr_regs[2] = buff[TLV493D_RD_REG_RES2] & TLV493D_RD_REG_RES2_WR_MASK;
260	data->wr_regs[3] = buff[TLV493D_RD_REG_RES3] & TLV493D_RD_REG_RES3_WR_MASK;
261
262	ret = tlv493d_set_operating_mode(data, data->mode);
263	if (ret < 0)
264		return dev_err_probe(dev, ret, "failed to set operating mode\n");
265
266	return 0;
267}
268
269static int tlv493d_read_raw(struct iio_dev *indio_dev,
270			const struct iio_chan_spec *chan, int *val,
271			int *val2, long mask)
272{
273	struct tlv493d_data *data = iio_priv(indio_dev);
274	s16 x, y, z, t;
275	int ret;
276
277	switch (mask) {
278	case IIO_CHAN_INFO_RAW:
279		ret = tlv493d_get_measurements(data, &x, &y, &z, &t);
280		if (ret)
281			return ret;
282
283		switch (chan->address) {
284		case TLV493D_AXIS_X:
285			*val = x;
286			return IIO_VAL_INT;
287		case TLV493D_AXIS_Y:
288			*val = y;
289			return IIO_VAL_INT;
290		case TLV493D_AXIS_Z:
291			*val = z;
292			return IIO_VAL_INT;
293		case TLV493D_TEMPERATURE:
294			*val = t;
295			return IIO_VAL_INT;
296		default:
297			return -EINVAL;
298		}
299	case IIO_CHAN_INFO_SCALE:
300		switch (chan->type) {
301		case IIO_MAGN:
302			/*
303			 * Magnetic field scale: 0.0098 mTesla (i.e. 9.8 µT)
304			 * Magnetic field in Gauss: mT * 10 = 0.098.
305			 */
306			*val = 98;
307			*val2 = 1000;
308			return IIO_VAL_FRACTIONAL;
309		case IIO_TEMP:
310			/*
311			 * Temperature scale: 1.1 °C per LSB, expressed as 1100 m°C
312			 * Returned as integer for IIO core to apply:
313			 * temp = (raw + offset) * scale
314			 */
315			*val = 1100;
316			return IIO_VAL_INT;
317		default:
318			return -EINVAL;
319		}
320	case IIO_CHAN_INFO_OFFSET:
321		switch (chan->type) {
322		case IIO_TEMP:
323			/*
324			 * Temperature offset includes sensor-specific raw offset
325			 * plus compensation for +25°C bias in formula.
326			 * offset = -raw_offset + (25000 / 1100)
327			 * -340 + 22.72 = -317.28
328			 */
329			*val = -31728;
330			*val2 = 100;
331			return IIO_VAL_FRACTIONAL;
332		default:
333			return -EINVAL;
334		}
335	default:
336		return -EINVAL;
337	}
338}
339
340static irqreturn_t tlv493d_trigger_handler(int irq, void *ptr)
341{
342	int ret;
343	s16 x, y, z, t;
344	struct iio_poll_func *pf = ptr;
345	struct iio_dev *indio_dev = pf->indio_dev;
346	struct tlv493d_data *data = iio_priv(indio_dev);
347	struct device *dev = &data->client->dev;
348	struct {
349		s16 channels[3];
350		s16 temperature;
351		aligned_s64 timestamp;
352	} scan;
353
354	ret = tlv493d_get_measurements(data, &x, &y, &z, &t);
355	if (ret) {
356		dev_err(dev, "failed to read sensor data\n");
357		goto out_trigger_notify;
358	}
359
360	scan.channels[0] = x;
361	scan.channels[1] = y;
362	scan.channels[2] = z;
363	scan.temperature = t;
364	iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan), pf->timestamp);
365
366out_trigger_notify:
367	iio_trigger_notify_done(indio_dev->trig);
368
369	return IRQ_HANDLED;
370}
371
372#define TLV493D_AXIS_CHANNEL(axis, index)			\
373	{							\
374		.type = IIO_MAGN,				\
375		.modified = 1,					\
376		.channel2 = IIO_MOD_##axis,			\
377		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |	\
378				BIT(IIO_CHAN_INFO_SCALE),	\
379		.address = index,				\
380		.scan_index = index,				\
381		.scan_type = {					\
382			.sign = 's',				\
383			.realbits = 12,				\
384			.storagebits = 16,			\
385			.endianness = IIO_CPU,			\
386		},						\
387	}
388
389static const struct iio_chan_spec tlv493d_channels[] = {
390	TLV493D_AXIS_CHANNEL(X, TLV493D_AXIS_X),
391	TLV493D_AXIS_CHANNEL(Y, TLV493D_AXIS_Y),
392	TLV493D_AXIS_CHANNEL(Z, TLV493D_AXIS_Z),
393	{
394		.type = IIO_TEMP,
395		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
396				BIT(IIO_CHAN_INFO_SCALE) |
397				BIT(IIO_CHAN_INFO_OFFSET),
398		.address = TLV493D_TEMPERATURE,
399		.scan_index = TLV493D_TEMPERATURE,
400		.scan_type = {
401			.sign = 's',
402			.realbits = 12,
403			.storagebits = 16,
404			.endianness = IIO_CPU,
405		},
406	},
407	IIO_CHAN_SOFT_TIMESTAMP(4),
408};
409
410static const struct iio_info tlv493d_info = {
411	.read_raw = tlv493d_read_raw,
412};
413
414static const unsigned long tlv493d_scan_masks[] = { GENMASK(3, 0), 0 };
415
416static int tlv493d_probe(struct i2c_client *client)
417{
418	struct device *dev = &client->dev;
419	struct iio_dev *indio_dev;
420	struct tlv493d_data *data;
421	int ret;
422
423	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
424	if (!indio_dev)
425		return -ENOMEM;
426
427	data = iio_priv(indio_dev);
428	data->client = client;
429	i2c_set_clientdata(client, indio_dev);
430
431	ret = devm_mutex_init(dev, &data->lock);
432	if (ret)
433		return ret;
434
435	ret = devm_regulator_get_enable(dev, "vdd");
436	if (ret)
437		return dev_err_probe(dev, ret, "failed to enable regulator\n");
438
439	/*
440	 * Setting Sensor default operating mode to Master-Controlled mode since
441	 * it performs measurement cycle only on-request and stays in Power-Down
442	 * state until next cycle is initiated.
443	 */
444	data->mode = TLV493D_OP_MODE_MASTERCONTROLLED;
445	ret = tlv493d_init(data);
446	if (ret)
447		return dev_err_probe(dev, ret, "failed to initialize\n");
448
449	indio_dev->info = &tlv493d_info;
450	indio_dev->modes = INDIO_DIRECT_MODE;
451	indio_dev->name = client->name;
452	indio_dev->channels = tlv493d_channels;
453	indio_dev->num_channels = ARRAY_SIZE(tlv493d_channels);
454	indio_dev->available_scan_masks = tlv493d_scan_masks;
455
456	ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
457					      iio_pollfunc_store_time,
458					      tlv493d_trigger_handler,
459					      NULL);
460	if (ret)
461		return dev_err_probe(dev, ret, "iio triggered buffer setup failed\n");
462
463	ret = pm_runtime_set_active(dev);
464	if (ret)
465		return ret;
466
467	ret = devm_pm_runtime_enable(dev);
468	if (ret)
469		return ret;
470
471	pm_runtime_get_noresume(dev);
472	pm_runtime_set_autosuspend_delay(dev, 500);
473	pm_runtime_use_autosuspend(dev);
474
475	pm_runtime_put_autosuspend(dev);
476
477	ret = devm_iio_device_register(dev, indio_dev);
478	if (ret)
479		return dev_err_probe(dev, ret, "iio device register failed\n");
480
481	return 0;
482}
483
484static int tlv493d_runtime_suspend(struct device *dev)
485{
486	struct tlv493d_data *data = iio_priv(dev_get_drvdata(dev));
487
488	return tlv493d_set_operating_mode(data, TLV493D_OP_MODE_POWERDOWN);
489}
490
491static int tlv493d_runtime_resume(struct device *dev)
492{
493	struct tlv493d_data *data = iio_priv(dev_get_drvdata(dev));
494
495	return tlv493d_set_operating_mode(data, data->mode);
496}
497
498static DEFINE_RUNTIME_DEV_PM_OPS(tlv493d_pm_ops, tlv493d_runtime_suspend,
499				 tlv493d_runtime_resume, NULL);
500
501static const struct i2c_device_id tlv493d_id[] = {
502	{ "tlv493d" },
503	{ }
504};
505MODULE_DEVICE_TABLE(i2c, tlv493d_id);
506
507static const struct of_device_id tlv493d_of_match[] = {
508	{ .compatible = "infineon,tlv493d-a1b6" },
509	{ }
510};
511MODULE_DEVICE_TABLE(of, tlv493d_of_match);
512
513static struct i2c_driver tlv493d_driver = {
514	.driver = {
515		.name = "tlv493d",
516		.of_match_table = tlv493d_of_match,
517		.pm = pm_ptr(&tlv493d_pm_ops),
518	},
519	.probe = tlv493d_probe,
520	.id_table = tlv493d_id,
521};
522module_i2c_driver(tlv493d_driver);
523
524MODULE_LICENSE("GPL");
525MODULE_DESCRIPTION("Infineon TLV493D Low-Power 3D Magnetic Sensor");
526MODULE_AUTHOR("Dixit Parmar <dixitparmar19@gmail.com>");