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
77 enum tlv493d_channels {
78 TLV493D_AXIS_X,
79 TLV493D_AXIS_Y,
80 TLV493D_AXIS_Z,
81 TLV493D_TEMPERATURE,
82 };
83
84 enum 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
92 struct 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 */
110 static 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
tlv493d_write_all_regs(struct tlv493d_data * data)118 static 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
tlv493d_set_operating_mode(struct tlv493d_data * data,enum tlv493d_op_mode mode)132 static 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
tlv493d_get_channel_data(u8 * b,enum tlv493d_channels ch)167 static 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]) >> 4;
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
tlv493d_get_measurements(struct tlv493d_data * data,s16 * x,s16 * y,s16 * z,s16 * t)193 static 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
232 out_put_autosuspend:
233 pm_runtime_put_autosuspend(dev);
234 return ret;
235 }
236
tlv493d_init(struct tlv493d_data * data)237 static 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
tlv493d_read_raw(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,int * val,int * val2,long mask)269 static 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
tlv493d_trigger_handler(int irq,void * ptr)340 static 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
366 out_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
389 static 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
410 static const struct iio_info tlv493d_info = {
411 .read_raw = tlv493d_read_raw,
412 };
413
414 static const unsigned long tlv493d_scan_masks[] = { GENMASK(3, 0), 0 };
415
tlv493d_probe(struct i2c_client * client)416 static 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
tlv493d_runtime_suspend(struct device * dev)484 static 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
tlv493d_runtime_resume(struct device * dev)491 static 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
498 static DEFINE_RUNTIME_DEV_PM_OPS(tlv493d_pm_ops, tlv493d_runtime_suspend,
499 tlv493d_runtime_resume, NULL);
500
501 static const struct i2c_device_id tlv493d_id[] = {
502 { "tlv493d" },
503 { }
504 };
505 MODULE_DEVICE_TABLE(i2c, tlv493d_id);
506
507 static const struct of_device_id tlv493d_of_match[] = {
508 { .compatible = "infineon,tlv493d-a1b6" },
509 { }
510 };
511 MODULE_DEVICE_TABLE(of, tlv493d_of_match);
512
513 static 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 };
522 module_i2c_driver(tlv493d_driver);
523
524 MODULE_LICENSE("GPL");
525 MODULE_DESCRIPTION("Infineon TLV493D Low-Power 3D Magnetic Sensor");
526 MODULE_AUTHOR("Dixit Parmar <dixitparmar19@gmail.com>");
527