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>"); 527