drivers/iio/magnetometer/tmag5273.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for the TI TMAG5273 Low-Power Linear 3D Hall-Effect Sensor
   4  *
   5  * Copyright (C) 2022 WolfVision GmbH
   6  *
   7  * Author: Gerald Loacker <gerald.loacker@wolfvision.net>
   8  */
   9
  10 #include <linux/bitfield.h>
  11 #include <linux/bits.h>
  12 #include <linux/delay.h>
  13 #include <linux/module.h>
  14 #include <linux/i2c.h>
  15 #include <linux/regmap.h>
  16 #include <linux/pm_runtime.h>
  17
  18 #include <linux/iio/iio.h>
  19 #include <linux/iio/sysfs.h>
  20
  21 #define TMAG5273_DEVICE_CONFIG_1         0x00
  22 #define TMAG5273_DEVICE_CONFIG_2         0x01
  23 #define TMAG5273_SENSOR_CONFIG_1         0x02
  24 #define TMAG5273_SENSOR_CONFIG_2         0x03
  25 #define TMAG5273_X_THR_CONFIG            0x04
  26 #define TMAG5273_Y_THR_CONFIG            0x05
  27 #define TMAG5273_Z_THR_CONFIG            0x06
  28 #define TMAG5273_T_CONFIG                0x07
  29 #define TMAG5273_INT_CONFIG_1            0x08
  30 #define TMAG5273_MAG_GAIN_CONFIG         0x09
  31 #define TMAG5273_MAG_OFFSET_CONFIG_1     0x0A
  32 #define TMAG5273_MAG_OFFSET_CONFIG_2     0x0B
  33 #define TMAG5273_I2C_ADDRESS             0x0C
  34 #define TMAG5273_DEVICE_ID               0x0D
  35 #define TMAG5273_MANUFACTURER_ID_LSB     0x0E
  36 #define TMAG5273_MANUFACTURER_ID_MSB     0x0F
  37 #define TMAG5273_T_MSB_RESULT            0x10
  38 #define TMAG5273_T_LSB_RESULT            0x11
  39 #define TMAG5273_X_MSB_RESULT            0x12
  40 #define TMAG5273_X_LSB_RESULT            0x13
  41 #define TMAG5273_Y_MSB_RESULT            0x14
  42 #define TMAG5273_Y_LSB_RESULT            0x15
  43 #define TMAG5273_Z_MSB_RESULT            0x16
  44 #define TMAG5273_Z_LSB_RESULT            0x17
  45 #define TMAG5273_CONV_STATUS             0x18
  46 #define TMAG5273_ANGLE_RESULT_MSB        0x19
  47 #define TMAG5273_ANGLE_RESULT_LSB        0x1A
  48 #define TMAG5273_MAGNITUDE_RESULT        0x1B
  49 #define TMAG5273_DEVICE_STATUS           0x1C
  50 #define TMAG5273_MAX_REG                 TMAG5273_DEVICE_STATUS
  51
  52 #define TMAG5273_AUTOSLEEP_DELAY_MS      5000
  53 #define TMAG5273_MAX_AVERAGE             32
  54
  55 /*
  56  * bits in the TMAG5273_MANUFACTURER_ID_LSB / MSB register
  57  * 16-bit unique manufacturer ID 0x49 / 0x54 = "TI"
  58  */
  59 #define TMAG5273_MANUFACTURER_ID         0x5449
  60
  61 /* bits in the TMAG5273_DEVICE_CONFIG_1 register */
  62 #define TMAG5273_AVG_MODE_MASK           GENMASK(4, 2)
  63 #define TMAG5273_AVG_1_MODE              FIELD_PREP(TMAG5273_AVG_MODE_MASK, 0)
  64 #define TMAG5273_AVG_2_MODE              FIELD_PREP(TMAG5273_AVG_MODE_MASK, 1)
  65 #define TMAG5273_AVG_4_MODE              FIELD_PREP(TMAG5273_AVG_MODE_MASK, 2)
  66 #define TMAG5273_AVG_8_MODE              FIELD_PREP(TMAG5273_AVG_MODE_MASK, 3)
  67 #define TMAG5273_AVG_16_MODE             FIELD_PREP(TMAG5273_AVG_MODE_MASK, 4)
  68 #define TMAG5273_AVG_32_MODE             FIELD_PREP(TMAG5273_AVG_MODE_MASK, 5)
  69
  70 /* bits in the TMAG5273_DEVICE_CONFIG_2 register */
  71 #define TMAG5273_OP_MODE_MASK            GENMASK(1, 0)
  72 #define TMAG5273_OP_MODE_STANDBY         FIELD_PREP(TMAG5273_OP_MODE_MASK, 0)
  73 #define TMAG5273_OP_MODE_SLEEP           FIELD_PREP(TMAG5273_OP_MODE_MASK, 1)
  74 #define TMAG5273_OP_MODE_CONT            FIELD_PREP(TMAG5273_OP_MODE_MASK, 2)
  75 #define TMAG5273_OP_MODE_WAKEUP          FIELD_PREP(TMAG5273_OP_MODE_MASK, 3)
  76
  77 /* bits in the TMAG5273_SENSOR_CONFIG_1 register */
  78 #define TMAG5273_MAG_CH_EN_MASK          GENMASK(7, 4)
  79 #define TMAG5273_MAG_CH_EN_X_Y_Z         7
  80
  81 /* bits in the TMAG5273_SENSOR_CONFIG_2 register */
  82 #define TMAG5273_Z_RANGE_MASK            BIT(0)
  83 #define TMAG5273_X_Y_RANGE_MASK          BIT(1)
  84 #define TMAG5273_ANGLE_EN_MASK           GENMASK(3, 2)
  85 #define TMAG5273_ANGLE_EN_OFF            0
  86 #define TMAG5273_ANGLE_EN_X_Y            1
  87 #define TMAG5273_ANGLE_EN_Y_Z            2
  88 #define TMAG5273_ANGLE_EN_X_Z            3
  89
  90 /* bits in the TMAG5273_T_CONFIG register */
  91 #define TMAG5273_T_CH_EN                 BIT(0)
  92
  93 /* bits in the TMAG5273_DEVICE_ID register */
  94 #define TMAG5273_VERSION_MASK            GENMASK(1, 0)
  95
  96 /* bits in the TMAG5273_CONV_STATUS register */
  97 #define TMAG5273_CONV_STATUS_COMPLETE    BIT(0)
  98
  99 enum tmag5273_channels {
 100         TEMPERATURE = 0,
 101         AXIS_X,
 102         AXIS_Y,
 103         AXIS_Z,
 104         ANGLE,
 105         MAGNITUDE,
 106 };
 107
 108 enum tmag5273_scale_index {
 109         MAGN_RANGE_LOW = 0,
 110         MAGN_RANGE_HIGH,
 111         MAGN_RANGE_NUM
 112 };
 113
 114 /* state container for the TMAG5273 driver */
 115 struct tmag5273_data {
 116         struct device *dev;
 117         unsigned int devid;
 118         unsigned int version;
 119         char name[16];
 120         unsigned int conv_avg;
 121         unsigned int scale;
 122         enum tmag5273_scale_index scale_index;
 123         unsigned int angle_measurement;
 124         struct regmap *map;
 125         struct regulator *vcc;
 126
 127         /*
 128          * Locks the sensor for exclusive use during a measurement (which
 129          * involves several register transactions so the regmap lock is not
 130          * enough) so that measurements get serialized in a
 131          * first-come-first-serve manner.
 132          */
 133         struct mutex lock;
 134 };
 135
 136 static const char *const tmag5273_angle_names[] = { "off", "x-y", "y-z", "x-z" };
 137
 138 /*
 139  * Averaging enables additional sampling of the sensor data to reduce the noise
 140  * effect, but also increases conversion time.
 141  */
 142 static const unsigned int tmag5273_avg_table[] = {
 143         1, 2, 4, 8, 16, 32,
 144 };
 145
 146 /*
 147  * Magnetic resolution in Gauss for different TMAG5273 versions.
 148  * Scale[Gauss] = Range[mT] * 1000 / 2^15 * 10, (1 mT = 10 Gauss)
 149  * Only version 1 and 2 are valid, version 0 and 3 are reserved.
 150  */
 151 static const struct iio_val_int_plus_micro tmag5273_scale[][MAGN_RANGE_NUM] = {
 152         { { 0,     0 }, { 0,     0 } },
 153         { { 0, 12200 }, { 0, 24400 } },
 154         { { 0, 40600 }, { 0, 81200 } },
 155         { { 0,     0 }, { 0,     0 } },
 156 };
 157
 158 static int tmag5273_get_measure(struct tmag5273_data *data, s16 *t, s16 *x,
 159                                 s16 *y, s16 *z, u16 *angle, u16 *magnitude)
 160 {
 161         unsigned int status, val;
 162         __be16 reg_data[4];
 163         int ret;
 164
 165         mutex_lock(&data->lock);
 166
 167         /*
 168          * Max. conversion time is 2425 us in 32x averaging mode for all three
 169          * channels. Since we are in continuous measurement mode, a measurement
 170          * may already be there, so poll for completed measurement with
 171          * timeout.
 172          */
 173         ret = regmap_read_poll_timeout(data->map, TMAG5273_CONV_STATUS, status,
 174                                        status & TMAG5273_CONV_STATUS_COMPLETE,
 175                                        100, 10000);
 176         if (ret) {
 177                 dev_err(data->dev, "timeout waiting for measurement\n");
 178                 goto out_unlock;
 179         }
 180
 181         ret = regmap_bulk_read(data->map, TMAG5273_T_MSB_RESULT, reg_data,
 182                                sizeof(reg_data));
 183         if (ret)
 184                 goto out_unlock;
 185         *t = be16_to_cpu(reg_data[0]);
 186         *x = be16_to_cpu(reg_data[1]);
 187         *y = be16_to_cpu(reg_data[2]);
 188         *z = be16_to_cpu(reg_data[3]);
 189
 190         ret = regmap_bulk_read(data->map, TMAG5273_ANGLE_RESULT_MSB,
 191                                &reg_data[0], sizeof(reg_data[0]));
 192         if (ret)
 193                 goto out_unlock;
 194         /*
 195          * angle has 9 bits integer value and 4 bits fractional part
 196          * 15 14 13 12 11 10 9  8  7  6  5  4  3  2  1  0
 197          * 0  0  0  a  a  a  a  a  a  a  a  a  f  f  f  f
 198          */
 199         *angle = be16_to_cpu(reg_data[0]);
 200
 201         ret = regmap_read(data->map, TMAG5273_MAGNITUDE_RESULT, &val);
 202         if (ret < 0)
 203                 goto out_unlock;
 204         *magnitude = val;
 205
 206 out_unlock:
 207         mutex_unlock(&data->lock);
 208         return ret;
 209 }
 210
 211 static int tmag5273_write_osr(struct tmag5273_data *data, int val)
 212 {
 213         int i;
 214
 215         if (val == data->conv_avg)
 216                 return 0;
 217
 218         for (i = 0; i < ARRAY_SIZE(tmag5273_avg_table); i++) {
 219                 if (tmag5273_avg_table[i] == val)
 220                         break;
 221         }
 222         if (i == ARRAY_SIZE(tmag5273_avg_table))
 223                 return -EINVAL;
 224         data->conv_avg = val;
 225
 226         return regmap_update_bits(data->map, TMAG5273_DEVICE_CONFIG_1,
 227                                   TMAG5273_AVG_MODE_MASK,
 228                                   FIELD_PREP(TMAG5273_AVG_MODE_MASK, i));
 229 }
 230
 231 static int tmag5273_write_scale(struct tmag5273_data *data, int scale_micro)
 232 {
 233         u32 value;
 234         int i;
 235
 236         for (i = 0; i < ARRAY_SIZE(tmag5273_scale[0]); i++) {
 237                 if (tmag5273_scale[data->version][i].micro == scale_micro)
 238                         break;
 239         }
 240         if (i == ARRAY_SIZE(tmag5273_scale[0]))
 241                 return -EINVAL;
 242         data->scale_index = i;
 243
 244         if (data->scale_index == MAGN_RANGE_LOW)
 245                 value = 0;
 246         else
 247                 value = TMAG5273_Z_RANGE_MASK | TMAG5273_X_Y_RANGE_MASK;
 248
 249         return regmap_update_bits(data->map, TMAG5273_SENSOR_CONFIG_2,
 250                                   TMAG5273_Z_RANGE_MASK | TMAG5273_X_Y_RANGE_MASK, value);
 251 }
 252
 253 static int tmag5273_read_avail(struct iio_dev *indio_dev,
 254                                struct iio_chan_spec const *chan,
 255                                const int **vals, int *type, int *length,
 256                                long mask)
 257 {
 258         struct tmag5273_data *data = iio_priv(indio_dev);
 259
 260         switch (mask) {
 261         case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
 262                 *vals = tmag5273_avg_table;
 263                 *type = IIO_VAL_INT;
 264                 *length = ARRAY_SIZE(tmag5273_avg_table);
 265                 return IIO_AVAIL_LIST;
 266         case IIO_CHAN_INFO_SCALE:
 267                 switch (chan->type) {
 268                 case IIO_MAGN:
 269                         *type = IIO_VAL_INT_PLUS_MICRO;
 270                         *vals = (int *)tmag5273_scale[data->version];
 271                         *length = ARRAY_SIZE(tmag5273_scale[data->version]) *
 272                                   MAGN_RANGE_NUM;
 273                         return IIO_AVAIL_LIST;
 274                 default:
 275                         return -EINVAL;
 276                 }
 277         default:
 278                 return -EINVAL;
 279         }
 280 }
 281
 282 static int tmag5273_read_raw(struct iio_dev *indio_dev,
 283                              const struct iio_chan_spec *chan, int *val,
 284                              int *val2, long mask)
 285 {
 286         struct tmag5273_data *data = iio_priv(indio_dev);
 287         s16 t, x, y, z;
 288         u16 angle, magnitude;
 289         int ret;
 290
 291         switch (mask) {
 292         case IIO_CHAN_INFO_PROCESSED:
 293         case IIO_CHAN_INFO_RAW:
 294                 ret = pm_runtime_resume_and_get(data->dev);
 295                 if (ret < 0)
 296                         return ret;
 297
 298                 ret = tmag5273_get_measure(data, &t, &x, &y, &z, &angle, &magnitude);
 299                 if (ret)
 300                         return ret;
 301
 302                 pm_runtime_mark_last_busy(data->dev);
 303                 pm_runtime_put_autosuspend(data->dev);
 304
 305                 switch (chan->address) {
 306                 case TEMPERATURE:
 307                         *val = t;
 308                         return IIO_VAL_INT;
 309                 case AXIS_X:
 310                         *val = x;
 311                         return IIO_VAL_INT;
 312                 case AXIS_Y:
 313                         *val = y;
 314                         return IIO_VAL_INT;
 315                 case AXIS_Z:
 316                         *val = z;
 317                         return IIO_VAL_INT;
 318                 case ANGLE:
 319                         *val = angle;
 320                         return IIO_VAL_INT;
 321                 case MAGNITUDE:
 322                         *val = magnitude;
 323                         return IIO_VAL_INT;
 324                 default:
 325                         return -EINVAL;
 326                 }
 327         case IIO_CHAN_INFO_SCALE:
 328                 switch (chan->type) {
 329                 case IIO_TEMP:
 330                         /*
 331                          * Convert device specific value to millicelsius.
 332                          * Resolution from the sensor is 60.1 LSB/celsius and
 333                          * the reference value at 25 celsius is 17508 LSBs.
 334                          */
 335                         *val = 10000;
 336                         *val2 = 601;
 337                         return IIO_VAL_FRACTIONAL;
 338                 case IIO_MAGN:
 339                         /* Magnetic resolution in uT */
 340                         *val = 0;
 341                         *val2 = tmag5273_scale[data->version]
 342                                               [data->scale_index].micro;
 343                         return IIO_VAL_INT_PLUS_MICRO;
 344                 case IIO_ANGL:
 345                         /*
 346                          * Angle is in degrees and has four fractional bits,
 347                          * therefore use 1/16 * pi/180 to convert to radians.
 348                          */
 349                         *val = 1000;
 350                         *val2 = 916732;
 351                         return IIO_VAL_FRACTIONAL;
 352                 default:
 353                         return -EINVAL;
 354                 }
 355         case IIO_CHAN_INFO_OFFSET:
 356                 switch (chan->type) {
 357                 case IIO_TEMP:
 358                         *val = -266314;
 359                         return IIO_VAL_INT;
 360                 default:
 361                         return -EINVAL;
 362                 }
 363         case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
 364                 *val = data->conv_avg;
 365                 return IIO_VAL_INT;
 366
 367         default:
 368                 return -EINVAL;
 369         }
 370 }
 371
 372 static int tmag5273_write_raw(struct iio_dev *indio_dev,
 373                               struct iio_chan_spec const *chan, int val,
 374                               int val2, long mask)
 375 {
 376         struct tmag5273_data *data = iio_priv(indio_dev);
 377
 378         switch (mask) {
 379         case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
 380                 return tmag5273_write_osr(data, val);
 381         case IIO_CHAN_INFO_SCALE:
 382                 switch (chan->type) {
 383                 case IIO_MAGN:
 384                         if (val)
 385                                 return -EINVAL;
 386                         return tmag5273_write_scale(data, val2);
 387                 default:
 388                         return -EINVAL;
 389                 }
 390         default:
 391                 return -EINVAL;
 392         }
 393 }
 394
 395 #define TMAG5273_AXIS_CHANNEL(axis, index)                                   \
 396         {                                                                    \
 397                 .type = IIO_MAGN,                                            \
 398                 .modified = 1,                                               \
 399                 .channel2 = IIO_MOD_##axis,                                  \
 400                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |               \
 401                                       BIT(IIO_CHAN_INFO_SCALE),              \
 402                 .info_mask_shared_by_type_available =                        \
 403                                       BIT(IIO_CHAN_INFO_SCALE),              \
 404                 .info_mask_shared_by_all =                                   \
 405                                       BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \
 406                 .info_mask_shared_by_all_available =                         \
 407                                       BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \
 408                 .address = index,                                            \
 409                 .scan_index = index,                                         \
 410                 .scan_type = {                                               \
 411                         .sign = 's',                                         \
 412                         .realbits = 16,                                      \
 413                         .storagebits = 16,                                   \
 414                         .endianness = IIO_CPU,                               \
 415                 },                                                           \
 416         }
 417
 418 static const struct iio_chan_spec tmag5273_channels[] = {
 419         {
 420                 .type = IIO_TEMP,
 421                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 422                         BIT(IIO_CHAN_INFO_SCALE) |
 423                         BIT(IIO_CHAN_INFO_OFFSET),
 424                 .address = TEMPERATURE,
 425                 .scan_index = TEMPERATURE,
 426                 .scan_type = {
 427                         .sign = 'u',
 428                         .realbits = 16,
 429                         .storagebits = 16,
 430                         .endianness = IIO_CPU,
 431                 },
 432         },
 433         TMAG5273_AXIS_CHANNEL(X, AXIS_X),
 434         TMAG5273_AXIS_CHANNEL(Y, AXIS_Y),
 435         TMAG5273_AXIS_CHANNEL(Z, AXIS_Z),
 436         {
 437                 .type = IIO_ANGL,
 438                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 439                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
 440                 .info_mask_shared_by_all =
 441                                       BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
 442                 .info_mask_shared_by_all_available =
 443                                       BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
 444                 .address = ANGLE,
 445                 .scan_index = ANGLE,
 446                 .scan_type = {
 447                         .sign = 'u',
 448                         .realbits = 16,
 449                         .storagebits = 16,
 450                         .endianness = IIO_CPU,
 451                 },
 452         },
 453         {
 454                 .type = IIO_DISTANCE,
 455                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 456                 .info_mask_shared_by_all =
 457                                       BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
 458                 .info_mask_shared_by_all_available =
 459                                       BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
 460                 .address = MAGNITUDE,
 461                 .scan_index = MAGNITUDE,
 462                 .scan_type = {
 463                         .sign = 'u',
 464                         .realbits = 16,
 465                         .storagebits = 16,
 466                         .endianness = IIO_CPU,
 467                 },
 468         },
 469         IIO_CHAN_SOFT_TIMESTAMP(6),
 470 };
 471
 472 static const struct iio_info tmag5273_info = {
 473         .read_avail = tmag5273_read_avail,
 474         .read_raw = tmag5273_read_raw,
 475         .write_raw = tmag5273_write_raw,
 476 };
 477
 478 static bool tmag5273_volatile_reg(struct device *dev, unsigned int reg)
 479 {
 480         return reg >= TMAG5273_T_MSB_RESULT && reg <= TMAG5273_MAGNITUDE_RESULT;
 481 }
 482
 483 static const struct regmap_config tmag5273_regmap_config = {
 484         .reg_bits = 8,
 485         .val_bits = 8,
 486         .max_register = TMAG5273_MAX_REG,
 487         .volatile_reg = tmag5273_volatile_reg,
 488 };
 489
 490 static int tmag5273_set_operating_mode(struct tmag5273_data *data,
 491                                        unsigned int val)
 492 {
 493         return regmap_write(data->map, TMAG5273_DEVICE_CONFIG_2, val);
 494 }
 495
 496 static void tmag5273_read_device_property(struct tmag5273_data *data)
 497 {
 498         struct device *dev = data->dev;
 499         const char *str;
 500         int ret;
 501
 502         data->angle_measurement = TMAG5273_ANGLE_EN_X_Y;
 503
 504         ret = device_property_read_string(dev, "ti,angle-measurement", &str);
 505         if (ret)
 506                 return;
 507
 508         ret = match_string(tmag5273_angle_names,
 509                            ARRAY_SIZE(tmag5273_angle_names), str);
 510         if (ret >= 0)
 511                 data->angle_measurement = ret;
 512 }
 513
 514 static void tmag5273_wake_up(struct tmag5273_data *data)
 515 {
 516         int val;
 517
 518         /* Wake up the chip by sending a dummy I2C command */
 519         regmap_read(data->map, TMAG5273_DEVICE_ID, &val);
 520         /*
 521          * Time to go to stand-by mode from sleep mode is 50us
 522          * typically, during this time no I2C access is possible.
 523          */
 524         usleep_range(80, 200);
 525 }
 526
 527 static int tmag5273_chip_init(struct tmag5273_data *data)
 528 {
 529         int ret;
 530
 531         ret = regmap_write(data->map, TMAG5273_DEVICE_CONFIG_1,
 532                            TMAG5273_AVG_32_MODE);
 533         if (ret)
 534                 return ret;
 535         data->conv_avg = 32;
 536
 537         ret = regmap_write(data->map, TMAG5273_DEVICE_CONFIG_2,
 538                            TMAG5273_OP_MODE_CONT);
 539         if (ret)
 540                 return ret;
 541
 542         ret = regmap_write(data->map, TMAG5273_SENSOR_CONFIG_1,
 543                            FIELD_PREP(TMAG5273_MAG_CH_EN_MASK,
 544                                       TMAG5273_MAG_CH_EN_X_Y_Z));
 545         if (ret)
 546                 return ret;
 547
 548         ret = regmap_write(data->map, TMAG5273_SENSOR_CONFIG_2,
 549                            FIELD_PREP(TMAG5273_ANGLE_EN_MASK,
 550                                       data->angle_measurement));
 551         if (ret)
 552                 return ret;
 553         data->scale_index = MAGN_RANGE_LOW;
 554
 555         return regmap_write(data->map, TMAG5273_T_CONFIG, TMAG5273_T_CH_EN);
 556 }
 557
 558 static int tmag5273_check_device_id(struct tmag5273_data *data)
 559 {
 560         __le16 devid;
 561         int val, ret;
 562
 563         ret = regmap_read(data->map, TMAG5273_DEVICE_ID, &val);
 564         if (ret)
 565                 return dev_err_probe(data->dev, ret, "failed to power on device\n");
 566         data->version = FIELD_PREP(TMAG5273_VERSION_MASK, val);
 567
 568         ret = regmap_bulk_read(data->map, TMAG5273_MANUFACTURER_ID_LSB, &devid,
 569                                sizeof(devid));
 570         if (ret)
 571                 return dev_err_probe(data->dev, ret, "failed to read device ID\n");
 572         data->devid = le16_to_cpu(devid);
 573
 574         switch (data->devid) {
 575         case TMAG5273_MANUFACTURER_ID:
 576                 /*
 577                  * The device name matches the orderable part number. 'x' stands
 578                  * for A, B, C or D devices, which have different I2C addresses.
 579                  * Versions 1 or 2 (0 and 3 is reserved) stands for different
 580                  * magnetic strengths.
 581                  */
 582                 snprintf(data->name, sizeof(data->name), "tmag5273x%1u", data->version);
 583                 if (data->version < 1 || data->version > 2)
 584                         dev_warn(data->dev, "Unsupported device %s\n", data->name);
 585                 return 0;
 586         default:
 587                 /*
 588                  * Only print warning in case of unknown device ID to allow
 589                  * fallback compatible in device tree.
 590                  */
 591                 dev_warn(data->dev, "Unknown device ID 0x%x\n", data->devid);
 592                 return 0;
 593         }
 594 }
 595
 596 static void tmag5273_power_down(void *data)
 597 {
 598         tmag5273_set_operating_mode(data, TMAG5273_OP_MODE_SLEEP);
 599 }
 600
 601 static int tmag5273_probe(struct i2c_client *i2c)
 602 {
 603         struct device *dev = &i2c->dev;
 604         struct tmag5273_data *data;
 605         struct iio_dev *indio_dev;
 606         int ret;
 607
 608         indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
 609         if (!indio_dev)
 610                 return -ENOMEM;
 611
 612         data = iio_priv(indio_dev);
 613         data->dev = dev;
 614         i2c_set_clientdata(i2c, indio_dev);
 615
 616         data->map = devm_regmap_init_i2c(i2c, &tmag5273_regmap_config);
 617         if (IS_ERR(data->map))
 618                 return dev_err_probe(dev, PTR_ERR(data->map),
 619                                      "failed to allocate register map\n");
 620
 621         mutex_init(&data->lock);
 622
 623         ret = devm_regulator_get_enable(dev, "vcc");
 624         if (ret)
 625                 return dev_err_probe(dev, ret, "failed to enable regulator\n");
 626
 627         tmag5273_wake_up(data);
 628
 629         ret = tmag5273_check_device_id(data);
 630         if (ret)
 631                 return ret;
 632
 633         ret = tmag5273_set_operating_mode(data, TMAG5273_OP_MODE_CONT);
 634         if (ret)
 635                 return dev_err_probe(dev, ret, "failed to power on device\n");
 636
 637         /*
 638          * Register powerdown deferred callback which suspends the chip
 639          * after module unloaded.
 640          *
 641          * TMAG5273 should be in SUSPEND mode in the two cases:
 642          * 1) When driver is loaded, but we do not have any data or
 643          *    configuration requests to it (we are solving it using
 644          *    autosuspend feature).
 645          * 2) When driver is unloaded and device is not used (devm action is
 646          *    used in this case).
 647          */
 648         ret = devm_add_action_or_reset(dev, tmag5273_power_down, data);
 649         if (ret)
 650                 return dev_err_probe(dev, ret, "failed to add powerdown action\n");
 651
 652         ret = pm_runtime_set_active(dev);
 653         if (ret < 0)
 654                 return ret;
 655
 656         ret = devm_pm_runtime_enable(dev);
 657         if (ret)
 658                 return ret;
 659
 660         pm_runtime_get_noresume(dev);
 661         pm_runtime_set_autosuspend_delay(dev, TMAG5273_AUTOSLEEP_DELAY_MS);
 662         pm_runtime_use_autosuspend(dev);
 663
 664         tmag5273_read_device_property(data);
 665
 666         ret = tmag5273_chip_init(data);
 667         if (ret)
 668                 return dev_err_probe(dev, ret, "failed to init device\n");
 669
 670         indio_dev->info = &tmag5273_info;
 671         indio_dev->modes = INDIO_DIRECT_MODE;
 672         indio_dev->name = data->name;
 673         indio_dev->channels = tmag5273_channels;
 674         indio_dev->num_channels = ARRAY_SIZE(tmag5273_channels);
 675
 676         pm_runtime_mark_last_busy(dev);
 677         pm_runtime_put_autosuspend(dev);
 678
 679         ret = devm_iio_device_register(dev, indio_dev);
 680         if (ret)
 681                 return dev_err_probe(dev, ret, "device register failed\n");
 682
 683         return 0;
 684 }
 685
 686 static int tmag5273_runtime_suspend(struct device *dev)
 687 {
 688         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 689         struct tmag5273_data *data = iio_priv(indio_dev);
 690         int ret;
 691
 692         ret = tmag5273_set_operating_mode(data, TMAG5273_OP_MODE_SLEEP);
 693         if (ret)
 694                 dev_err(dev, "failed to power off device (%pe)\n", ERR_PTR(ret));
 695
 696         return ret;
 697 }
 698
 699 static int tmag5273_runtime_resume(struct device *dev)
 700 {
 701         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 702         struct tmag5273_data *data = iio_priv(indio_dev);
 703         int ret;
 704
 705         tmag5273_wake_up(data);
 706
 707         ret = tmag5273_set_operating_mode(data, TMAG5273_OP_MODE_CONT);
 708         if (ret)
 709                 dev_err(dev, "failed to power on device (%pe)\n", ERR_PTR(ret));
 710
 711         return ret;
 712 }
 713
 714 static DEFINE_RUNTIME_DEV_PM_OPS(tmag5273_pm_ops,
 715                                  tmag5273_runtime_suspend, tmag5273_runtime_resume,
 716                                  NULL);
 717
 718 static const struct i2c_device_id tmag5273_id[] = {
 719         { "tmag5273" },
 720         { /* sentinel */ }
 721 };
 722 MODULE_DEVICE_TABLE(i2c, tmag5273_id);
 723
 724 static const struct of_device_id tmag5273_of_match[] = {
 725         { .compatible = "ti,tmag5273" },
 726         { /* sentinel */ }
 727 };
 728 MODULE_DEVICE_TABLE(of, tmag5273_of_match);
 729
 730 static struct i2c_driver tmag5273_driver = {
 731         .driver  = {
 732                 .name = "tmag5273",
 733                 .of_match_table = tmag5273_of_match,
 734                 .pm = pm_ptr(&tmag5273_pm_ops),
 735         },
 736         .probe_new = tmag5273_probe,
 737         .id_table = tmag5273_id,
 738 };
 739 module_i2c_driver(tmag5273_driver);
 740
 741 MODULE_DESCRIPTION("TI TMAG5273 Low-Power Linear 3D Hall-Effect Sensor driver");
 742 MODULE_AUTHOR("Gerald Loacker <gerald.loacker@wolfvision.net>");
 743 MODULE_LICENSE("GPL");