Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
iio: magnetometer: add support for Infineon TLV493D 3D Magentic sensor
The Infineon TLV493D is a Low-Power 3D Magnetic Sensor. The Sensor
applications includes joysticks, control elements (white goods,
multifunction knops), or electric meters (anti tampering) and any
other application that requires accurate angular measurements at
low power consumptions.
The Sensor is configured over I2C, and as part of Sensor measurement
data it provides 3-Axis magnetic fields and temperature core measurement.
The driver supports raw value read and buffered input via external trigger
to allow streaming values with the same sensing timestamp.
While the sensor has an interrupt pin multiplexed with an I2C SCL pin.
But for bus configurations interrupt(INT) is not recommended, unless timing
constraints between I2C data transfers and interrupt pulses are monitored
and aligned.
The Sensor's I2C register map and mode information is described in product
User Manual [1].
Datasheet: https://www.infineon.com/assets/row/public/documents/24/49/infineon-tlv493d-a1b6-datasheet-en.pdf
Link: https://www.mouser.com/pdfDocs/Infineon-TLV493D-A1B6_3DMagnetic-UserManual-v01_03-EN.pdf [1]
Signed-off-by: Dixit Parmar <dixitparmar19@gmail.com>
Reviewed-by: Andy Shevchenko <andy@kernel.org>
Link: https://patch.msgid.link/20250906-tlv493d-sensor-v6_16-rc5-v6-2-b1a62d968353@gmail.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
authored by
Dixit Parmar
and committed by
Jonathan Cameron
106511d2
8efd9d97
+542
+1
MAINTAINERS
+1
MAINTAINERS
···
12014
12014
S: Maintained
12015
12015
W: https://www.infineon.com/part/TLV493D-A1B6
12016
12016
F: Documentation/devicetree/bindings/iio/magnetometer/infineon,tlv493d-a1b6.yaml
12017
+
F: drivers/iio/magnetometer/tlv493d.c
12017
12018
12018
12019
INFINIBAND SUBSYSTEM
12019
12020
M: Jason Gunthorpe <jgg@nvidia.com>
+13
drivers/iio/magnetometer/Kconfig
+13
drivers/iio/magnetometer/Kconfig
···
173
173
To compile this driver as a module, choose M here. The module
174
174
will be called st_magn_spi.
175
175
176
+
config INFINEON_TLV493D
177
+
tristate "Infineon TLV493D Low-Power 3D Magnetic Sensor"
178
+
depends on I2C
179
+
select IIO_BUFFER
180
+
select IIO_TRIGGERED_BUFFER
181
+
help
182
+
Say Y here to add support for the Infineon TLV493D-A1B6 Low-
183
+
Power 3D Magnetic Sensor.
184
+
185
+
This driver can also be compiled as a module.
186
+
To compile this driver as a module, choose M here: the module
187
+
will be called tlv493d.
188
+
176
189
config SENSORS_HMC5843
177
190
tristate
178
191
select IIO_BUFFER
+2
drivers/iio/magnetometer/Makefile
+2
drivers/iio/magnetometer/Makefile
···
23
23
obj-$(CONFIG_IIO_ST_MAGN_I2C_3AXIS) += st_magn_i2c.o
24
24
obj-$(CONFIG_IIO_ST_MAGN_SPI_3AXIS) += st_magn_spi.o
25
25
26
+
obj-$(CONFIG_INFINEON_TLV493D) += tlv493d.o
27
+
26
28
obj-$(CONFIG_SENSORS_HMC5843) += hmc5843_core.o
27
29
obj-$(CONFIG_SENSORS_HMC5843_I2C) += hmc5843_i2c.o
28
30
obj-$(CONFIG_SENSORS_HMC5843_SPI) += hmc5843_spi.o
+526
drivers/iio/magnetometer/tlv493d.c
+526
drivers/iio/magnetometer/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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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>");