drivers/staging/iio/magnetometer/hmc5843_core.c

   1 /*
   2  * Device driver for the the HMC5843 multi-chip module designed
   3  * for low field magnetic sensing.
   4  *
   5  * Copyright (C) 2010 Texas Instruments
   6  *
   7  * Author: Shubhrajyoti Datta <shubhrajyoti@ti.com>
   8  * Acknowledgment: Jonathan Cameron <jic23@kernel.org> for valuable inputs.
   9  * Support for HMC5883 and HMC5883L by Peter Meerwald <pmeerw@pmeerw.net>.
  10  * Split to multiple files by Josef Gajdusek <atx@atx.name> - 2014
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/regmap.h>
  26 #include <linux/iio/iio.h>
  27 #include <linux/iio/sysfs.h>
  28 #include <linux/iio/trigger_consumer.h>
  29 #include <linux/iio/buffer.h>
  30 #include <linux/iio/triggered_buffer.h>
  31 #include <linux/delay.h>
  32
  33 #include "hmc5843.h"
  34
  35 /*
  36  * Range gain settings in (+-)Ga
  37  * Beware: HMC5843 and HMC5883 have different recommended sensor field
  38  * ranges; default corresponds to +-1.0 Ga and +-1.3 Ga, respectively
  39  */
  40 #define HMC5843_RANGE_GAIN_OFFSET               0x05
  41 #define HMC5843_RANGE_GAIN_DEFAULT              0x01
  42 #define HMC5843_RANGE_GAIN_MASK         0xe0
  43
  44 /* Device status */
  45 #define HMC5843_DATA_READY                      0x01
  46 #define HMC5843_DATA_OUTPUT_LOCK                0x02
  47
  48 /* Mode register configuration */
  49 #define HMC5843_MODE_CONVERSION_CONTINUOUS      0x00
  50 #define HMC5843_MODE_CONVERSION_SINGLE          0x01
  51 #define HMC5843_MODE_IDLE                       0x02
  52 #define HMC5843_MODE_SLEEP                      0x03
  53 #define HMC5843_MODE_MASK                       0x03
  54
  55 /*
  56  * HMC5843: Minimum data output rate
  57  * HMC5883: Typical data output rate
  58  */
  59 #define HMC5843_RATE_OFFSET                     0x02
  60 #define HMC5843_RATE_DEFAULT                    0x04
  61 #define HMC5843_RATE_MASK               0x1c
  62
  63 /* Device measurement configuration */
  64 #define HMC5843_MEAS_CONF_NORMAL                0x00
  65 #define HMC5843_MEAS_CONF_POSITIVE_BIAS         0x01
  66 #define HMC5843_MEAS_CONF_NEGATIVE_BIAS         0x02
  67 #define HMC5843_MEAS_CONF_MASK                  0x03
  68
  69 /*
  70  * API for setting the measurement configuration to
  71  * Normal, Positive bias and Negative bias
  72  *
  73  * From the datasheet:
  74  * 0 - Normal measurement configuration (default): In normal measurement
  75  *     configuration the device follows normal measurement flow. Pins BP
  76  *     and BN are left floating and high impedance.
  77  *
  78  * 1 - Positive bias configuration: In positive bias configuration, a
  79  *     positive current is forced across the resistive load on pins BP
  80  *     and BN.
  81  *
  82  * 2 - Negative bias configuration. In negative bias configuration, a
  83  *     negative current is forced across the resistive load on pins BP
  84  *     and BN.
  85  *
  86  * 3 - Only available on HMC5983. Magnetic sensor is disabled.
  87  *     Temperature sensor is enabled.
  88  */
  89
  90 static const char *const hmc5843_meas_conf_modes[] = {"normal", "positivebias",
  91                                                       "negativebias"};
  92
  93 static const char *const hmc5983_meas_conf_modes[] = {"normal", "positivebias",
  94                                                       "negativebias",
  95                                                       "disabled"};
  96 /* Scaling factors: 10000000/Gain */
  97 static const int hmc5843_regval_to_nanoscale[] = {
  98         6173, 7692, 10309, 12821, 18868, 21739, 25641, 35714
  99 };
 100
 101 static const int hmc5883_regval_to_nanoscale[] = {
 102         7812, 9766, 13021, 16287, 24096, 27701, 32573, 45662
 103 };
 104
 105 static const int hmc5883l_regval_to_nanoscale[] = {
 106         7299, 9174, 12195, 15152, 22727, 25641, 30303, 43478
 107 };
 108
 109 /*
 110  * From the datasheet:
 111  * Value        | HMC5843               | HMC5883/HMC5883L
 112  *              | Data output rate (Hz) | Data output rate (Hz)
 113  * 0            | 0.5                   | 0.75
 114  * 1            | 1                     | 1.5
 115  * 2            | 2                     | 3
 116  * 3            | 5                     | 7.5
 117  * 4            | 10 (default)          | 15
 118  * 5            | 20                    | 30
 119  * 6            | 50                    | 75
 120  * 7            | Not used              | Not used
 121  */
 122 static const int hmc5843_regval_to_samp_freq[][2] = {
 123         {0, 500000}, {1, 0}, {2, 0}, {5, 0}, {10, 0}, {20, 0}, {50, 0}
 124 };
 125
 126 static const int hmc5883_regval_to_samp_freq[][2] = {
 127         {0, 750000}, {1, 500000}, {3, 0}, {7, 500000}, {15, 0}, {30, 0},
 128         {75, 0}
 129 };
 130
 131 static const int hmc5983_regval_to_samp_freq[][2] = {
 132         {0, 750000}, {1, 500000}, {3, 0}, {7, 500000}, {15, 0}, {30, 0},
 133         {75, 0}, {220, 0}
 134 };
 135
 136 /* Describe chip variants */
 137 struct hmc5843_chip_info {
 138         const struct iio_chan_spec *channels;
 139         const int (*regval_to_samp_freq)[2];
 140         const int n_regval_to_samp_freq;
 141         const int *regval_to_nanoscale;
 142         const int n_regval_to_nanoscale;
 143 };
 144
 145 /* The lower two bits contain the current conversion mode */
 146 static s32 hmc5843_set_mode(struct hmc5843_data *data, u8 operating_mode)
 147 {
 148         int ret;
 149
 150         mutex_lock(&data->lock);
 151         ret = regmap_update_bits(data->regmap, HMC5843_MODE_REG,
 152                                  HMC5843_MODE_MASK, operating_mode);
 153         mutex_unlock(&data->lock);
 154
 155         return ret;
 156 }
 157
 158 static int hmc5843_wait_measurement(struct hmc5843_data *data)
 159 {
 160         int tries = 150;
 161         unsigned int val;
 162         int ret;
 163
 164         while (tries-- > 0) {
 165                 ret = regmap_read(data->regmap, HMC5843_STATUS_REG, &val);
 166                 if (ret < 0)
 167                         return ret;
 168                 if (val & HMC5843_DATA_READY)
 169                         break;
 170                 msleep(20);
 171         }
 172
 173         if (tries < 0) {
 174                 dev_err(data->dev, "data not ready\n");
 175                 return -EIO;
 176         }
 177
 178         return 0;
 179 }
 180
 181 /* Return the measurement value from the specified channel */
 182 static int hmc5843_read_measurement(struct hmc5843_data *data,
 183                                     int idx, int *val)
 184 {
 185         __be16 values[3];
 186         int ret;
 187
 188         mutex_lock(&data->lock);
 189         ret = hmc5843_wait_measurement(data);
 190         if (ret < 0) {
 191                 mutex_unlock(&data->lock);
 192                 return ret;
 193         }
 194         ret = regmap_bulk_read(data->regmap, HMC5843_DATA_OUT_MSB_REGS,
 195                                values, sizeof(values));
 196         mutex_unlock(&data->lock);
 197         if (ret < 0)
 198                 return ret;
 199
 200         *val = sign_extend32(be16_to_cpu(values[idx]), 15);
 201         return IIO_VAL_INT;
 202 }
 203
 204 static int hmc5843_set_meas_conf(struct hmc5843_data *data, u8 meas_conf)
 205 {
 206         int ret;
 207
 208         mutex_lock(&data->lock);
 209         ret = regmap_update_bits(data->regmap, HMC5843_CONFIG_REG_A,
 210                                  HMC5843_MEAS_CONF_MASK, meas_conf);
 211         mutex_unlock(&data->lock);
 212
 213         return ret;
 214 }
 215
 216 static
 217 int hmc5843_show_measurement_configuration(struct iio_dev *indio_dev,
 218                                            const struct iio_chan_spec *chan)
 219 {
 220         struct hmc5843_data *data = iio_priv(indio_dev);
 221         unsigned int val;
 222         int ret;
 223
 224         ret = regmap_read(data->regmap, HMC5843_CONFIG_REG_A, &val);
 225         if (ret)
 226                 return ret;
 227
 228         return val & HMC5843_MEAS_CONF_MASK;
 229 }
 230
 231 static
 232 int hmc5843_set_measurement_configuration(struct iio_dev *indio_dev,
 233                                           const struct iio_chan_spec *chan,
 234                                           unsigned int meas_conf)
 235 {
 236         struct hmc5843_data *data = iio_priv(indio_dev);
 237
 238         return hmc5843_set_meas_conf(data, meas_conf);
 239 }
 240
 241 static const struct iio_enum hmc5843_meas_conf_enum = {
 242         .items = hmc5843_meas_conf_modes,
 243         .num_items = ARRAY_SIZE(hmc5843_meas_conf_modes),
 244         .get = hmc5843_show_measurement_configuration,
 245         .set = hmc5843_set_measurement_configuration,
 246 };
 247
 248 static const struct iio_chan_spec_ext_info hmc5843_ext_info[] = {
 249         IIO_ENUM("meas_conf", true, &hmc5843_meas_conf_enum),
 250         IIO_ENUM_AVAILABLE("meas_conf", &hmc5843_meas_conf_enum),
 251         { },
 252 };
 253
 254 static const struct iio_enum hmc5983_meas_conf_enum = {
 255         .items = hmc5983_meas_conf_modes,
 256         .num_items = ARRAY_SIZE(hmc5983_meas_conf_modes),
 257         .get = hmc5843_show_measurement_configuration,
 258         .set = hmc5843_set_measurement_configuration,
 259 };
 260
 261 static const struct iio_chan_spec_ext_info hmc5983_ext_info[] = {
 262         IIO_ENUM("meas_conf", true, &hmc5983_meas_conf_enum),
 263         IIO_ENUM_AVAILABLE("meas_conf", &hmc5983_meas_conf_enum),
 264         { },
 265 };
 266
 267 static
 268 ssize_t hmc5843_show_samp_freq_avail(struct device *dev,
 269                                      struct device_attribute *attr, char *buf)
 270 {
 271         struct hmc5843_data *data = iio_priv(dev_to_iio_dev(dev));
 272         size_t len = 0;
 273         int i;
 274
 275         for (i = 0; i < data->variant->n_regval_to_samp_freq; i++)
 276                 len += scnprintf(buf + len, PAGE_SIZE - len,
 277                         "%d.%d ", data->variant->regval_to_samp_freq[i][0],
 278                         data->variant->regval_to_samp_freq[i][1]);
 279
 280         /* replace trailing space by newline */
 281         buf[len - 1] = '\n';
 282
 283         return len;
 284 }
 285
 286 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(hmc5843_show_samp_freq_avail);
 287
 288 static int hmc5843_set_samp_freq(struct hmc5843_data *data, u8 rate)
 289 {
 290         int ret;
 291
 292         mutex_lock(&data->lock);
 293         ret = regmap_update_bits(data->regmap, HMC5843_CONFIG_REG_A,
 294                                  HMC5843_RATE_MASK,
 295                                  rate << HMC5843_RATE_OFFSET);
 296         mutex_unlock(&data->lock);
 297
 298         return ret;
 299 }
 300
 301 static int hmc5843_get_samp_freq_index(struct hmc5843_data *data,
 302                                        int val, int val2)
 303 {
 304         int i;
 305
 306         for (i = 0; i < data->variant->n_regval_to_samp_freq; i++)
 307                 if (val == data->variant->regval_to_samp_freq[i][0] &&
 308                     val2 == data->variant->regval_to_samp_freq[i][1])
 309                         return i;
 310
 311         return -EINVAL;
 312 }
 313
 314 static int hmc5843_set_range_gain(struct hmc5843_data *data, u8 range)
 315 {
 316         int ret;
 317
 318         mutex_lock(&data->lock);
 319         ret = regmap_update_bits(data->regmap, HMC5843_CONFIG_REG_B,
 320                                  HMC5843_RANGE_GAIN_MASK,
 321                                  range << HMC5843_RANGE_GAIN_OFFSET);
 322         mutex_unlock(&data->lock);
 323
 324         return ret;
 325 }
 326
 327 static ssize_t hmc5843_show_scale_avail(struct device *dev,
 328                                         struct device_attribute *attr,
 329                                         char *buf)
 330 {
 331         struct hmc5843_data *data = iio_priv(dev_to_iio_dev(dev));
 332
 333         size_t len = 0;
 334         int i;
 335
 336         for (i = 0; i < data->variant->n_regval_to_nanoscale; i++)
 337                 len += scnprintf(buf + len, PAGE_SIZE - len,
 338                         "0.%09d ", data->variant->regval_to_nanoscale[i]);
 339
 340         /* replace trailing space by newline */
 341         buf[len - 1] = '\n';
 342
 343         return len;
 344 }
 345
 346 static IIO_DEVICE_ATTR(scale_available, S_IRUGO,
 347         hmc5843_show_scale_avail, NULL, 0);
 348
 349 static int hmc5843_get_scale_index(struct hmc5843_data *data, int val, int val2)
 350 {
 351         int i;
 352
 353         if (val)
 354                 return -EINVAL;
 355
 356         for (i = 0; i < data->variant->n_regval_to_nanoscale; i++)
 357                 if (val2 == data->variant->regval_to_nanoscale[i])
 358                         return i;
 359
 360         return -EINVAL;
 361 }
 362
 363 static int hmc5843_read_raw(struct iio_dev *indio_dev,
 364                             struct iio_chan_spec const *chan,
 365                             int *val, int *val2, long mask)
 366 {
 367         struct hmc5843_data *data = iio_priv(indio_dev);
 368         unsigned int rval;
 369         int ret;
 370
 371         switch (mask) {
 372         case IIO_CHAN_INFO_RAW:
 373                 return hmc5843_read_measurement(data, chan->scan_index, val);
 374         case IIO_CHAN_INFO_SCALE:
 375                 ret = regmap_read(data->regmap, HMC5843_CONFIG_REG_B, &rval);
 376                 if (ret < 0)
 377                         return ret;
 378                 rval >>= HMC5843_RANGE_GAIN_OFFSET;
 379                 *val = 0;
 380                 *val2 = data->variant->regval_to_nanoscale[rval];
 381                 return IIO_VAL_INT_PLUS_NANO;
 382         case IIO_CHAN_INFO_SAMP_FREQ:
 383                 ret = regmap_read(data->regmap, HMC5843_CONFIG_REG_A, &rval);
 384                 if (ret < 0)
 385                         return ret;
 386                 rval >>= HMC5843_RATE_OFFSET;
 387                 *val = data->variant->regval_to_samp_freq[rval][0];
 388                 *val2 = data->variant->regval_to_samp_freq[rval][1];
 389                 return IIO_VAL_INT_PLUS_MICRO;
 390         }
 391         return -EINVAL;
 392 }
 393
 394 static int hmc5843_write_raw(struct iio_dev *indio_dev,
 395                              struct iio_chan_spec const *chan,
 396                              int val, int val2, long mask)
 397 {
 398         struct hmc5843_data *data = iio_priv(indio_dev);
 399         int rate, range;
 400
 401         switch (mask) {
 402         case IIO_CHAN_INFO_SAMP_FREQ:
 403                 rate = hmc5843_get_samp_freq_index(data, val, val2);
 404                 if (rate < 0)
 405                         return -EINVAL;
 406
 407                 return hmc5843_set_samp_freq(data, rate);
 408         case IIO_CHAN_INFO_SCALE:
 409                 range = hmc5843_get_scale_index(data, val, val2);
 410                 if (range < 0)
 411                         return -EINVAL;
 412
 413                 return hmc5843_set_range_gain(data, range);
 414         default:
 415                 return -EINVAL;
 416         }
 417 }
 418
 419 static int hmc5843_write_raw_get_fmt(struct iio_dev *indio_dev,
 420                                      struct iio_chan_spec const *chan,
 421                                      long mask)
 422 {
 423         switch (mask) {
 424         case IIO_CHAN_INFO_SAMP_FREQ:
 425                 return IIO_VAL_INT_PLUS_MICRO;
 426         case IIO_CHAN_INFO_SCALE:
 427                 return IIO_VAL_INT_PLUS_NANO;
 428         default:
 429                 return -EINVAL;
 430         }
 431 }
 432
 433 static irqreturn_t hmc5843_trigger_handler(int irq, void *p)
 434 {
 435         struct iio_poll_func *pf = p;
 436         struct iio_dev *indio_dev = pf->indio_dev;
 437         struct hmc5843_data *data = iio_priv(indio_dev);
 438         int ret;
 439
 440         mutex_lock(&data->lock);
 441         ret = hmc5843_wait_measurement(data);
 442         if (ret < 0) {
 443                 mutex_unlock(&data->lock);
 444                 goto done;
 445         }
 446
 447         ret = regmap_bulk_read(data->regmap, HMC5843_DATA_OUT_MSB_REGS,
 448                                data->buffer, 3 * sizeof(__be16));
 449
 450         mutex_unlock(&data->lock);
 451         if (ret < 0)
 452                 goto done;
 453
 454         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
 455                                            iio_get_time_ns());
 456
 457 done:
 458         iio_trigger_notify_done(indio_dev->trig);
 459
 460         return IRQ_HANDLED;
 461 }
 462
 463 #define HMC5843_CHANNEL(axis, idx)                                      \
 464         {                                                               \
 465                 .type = IIO_MAGN,                                       \
 466                 .modified = 1,                                          \
 467                 .channel2 = IIO_MOD_##axis,                             \
 468                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
 469                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
 470                         BIT(IIO_CHAN_INFO_SAMP_FREQ),                   \
 471                 .scan_index = idx,                                      \
 472                 .scan_type = {                                          \
 473                         .sign = 's',                                    \
 474                         .realbits = 16,                                 \
 475                         .storagebits = 16,                              \
 476                         .endianness = IIO_BE,                           \
 477                 },                                                      \
 478                 .ext_info = hmc5843_ext_info,   \
 479         }
 480
 481 #define HMC5983_CHANNEL(axis, idx)                                      \
 482         {                                                               \
 483                 .type = IIO_MAGN,                                       \
 484                 .modified = 1,                                          \
 485                 .channel2 = IIO_MOD_##axis,                             \
 486                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
 487                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
 488                         BIT(IIO_CHAN_INFO_SAMP_FREQ),                   \
 489                 .scan_index = idx,                                      \
 490                 .scan_type = {                                          \
 491                         .sign = 's',                                    \
 492                         .realbits = 16,                                 \
 493                         .storagebits = 16,                              \
 494                         .endianness = IIO_BE,                           \
 495                 },                                                      \
 496                 .ext_info = hmc5983_ext_info,   \
 497         }
 498
 499 static const struct iio_chan_spec hmc5843_channels[] = {
 500         HMC5843_CHANNEL(X, 0),
 501         HMC5843_CHANNEL(Y, 1),
 502         HMC5843_CHANNEL(Z, 2),
 503         IIO_CHAN_SOFT_TIMESTAMP(3),
 504 };
 505
 506 /* Beware: Y and Z are exchanged on HMC5883 and 5983 */
 507 static const struct iio_chan_spec hmc5883_channels[] = {
 508         HMC5843_CHANNEL(X, 0),
 509         HMC5843_CHANNEL(Z, 1),
 510         HMC5843_CHANNEL(Y, 2),
 511         IIO_CHAN_SOFT_TIMESTAMP(3),
 512 };
 513
 514 static const struct iio_chan_spec hmc5983_channels[] = {
 515         HMC5983_CHANNEL(X, 0),
 516         HMC5983_CHANNEL(Z, 1),
 517         HMC5983_CHANNEL(Y, 2),
 518         IIO_CHAN_SOFT_TIMESTAMP(3),
 519 };
 520
 521 static struct attribute *hmc5843_attributes[] = {
 522         &iio_dev_attr_scale_available.dev_attr.attr,
 523         &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
 524         NULL
 525 };
 526
 527 static const struct attribute_group hmc5843_group = {
 528         .attrs = hmc5843_attributes,
 529 };
 530
 531 static const struct hmc5843_chip_info hmc5843_chip_info_tbl[] = {
 532         [HMC5843_ID] = {
 533                 .channels = hmc5843_channels,
 534                 .regval_to_samp_freq = hmc5843_regval_to_samp_freq,
 535                 .n_regval_to_samp_freq =
 536                                 ARRAY_SIZE(hmc5843_regval_to_samp_freq),
 537                 .regval_to_nanoscale = hmc5843_regval_to_nanoscale,
 538                 .n_regval_to_nanoscale =
 539                                 ARRAY_SIZE(hmc5843_regval_to_nanoscale),
 540         },
 541         [HMC5883_ID] = {
 542                 .channels = hmc5883_channels,
 543                 .regval_to_samp_freq = hmc5883_regval_to_samp_freq,
 544                 .n_regval_to_samp_freq =
 545                                 ARRAY_SIZE(hmc5883_regval_to_samp_freq),
 546                 .regval_to_nanoscale = hmc5883_regval_to_nanoscale,
 547                 .n_regval_to_nanoscale =
 548                                 ARRAY_SIZE(hmc5883_regval_to_nanoscale),
 549         },
 550         [HMC5883L_ID] = {
 551                 .channels = hmc5883_channels,
 552                 .regval_to_samp_freq = hmc5883_regval_to_samp_freq,
 553                 .n_regval_to_samp_freq =
 554                                 ARRAY_SIZE(hmc5883_regval_to_samp_freq),
 555                 .regval_to_nanoscale = hmc5883l_regval_to_nanoscale,
 556                 .n_regval_to_nanoscale =
 557                                 ARRAY_SIZE(hmc5883l_regval_to_nanoscale),
 558         },
 559         [HMC5983_ID] = {
 560                 .channels = hmc5983_channels,
 561                 .regval_to_samp_freq = hmc5983_regval_to_samp_freq,
 562                 .n_regval_to_samp_freq =
 563                                 ARRAY_SIZE(hmc5983_regval_to_samp_freq),
 564                 .regval_to_nanoscale = hmc5883l_regval_to_nanoscale,
 565                 .n_regval_to_nanoscale =
 566                                 ARRAY_SIZE(hmc5883l_regval_to_nanoscale),
 567         }
 568 };
 569
 570 static int hmc5843_init(struct hmc5843_data *data)
 571 {
 572         int ret;
 573         u8 id[3];
 574
 575         ret = regmap_bulk_read(data->regmap, HMC5843_ID_REG,
 576                                id, ARRAY_SIZE(id));
 577         if (ret < 0)
 578                 return ret;
 579         if (id[0] != 'H' || id[1] != '4' || id[2] != '3') {
 580                 dev_err(data->dev, "no HMC5843/5883/5883L/5983 sensor\n");
 581                 return -ENODEV;
 582         }
 583
 584         ret = hmc5843_set_meas_conf(data, HMC5843_MEAS_CONF_NORMAL);
 585         if (ret < 0)
 586                 return ret;
 587         ret = hmc5843_set_samp_freq(data, HMC5843_RATE_DEFAULT);
 588         if (ret < 0)
 589                 return ret;
 590         ret = hmc5843_set_range_gain(data, HMC5843_RANGE_GAIN_DEFAULT);
 591         if (ret < 0)
 592                 return ret;
 593         return hmc5843_set_mode(data, HMC5843_MODE_CONVERSION_CONTINUOUS);
 594 }
 595
 596 static const struct iio_info hmc5843_info = {
 597         .attrs = &hmc5843_group,
 598         .read_raw = hmc5843_read_raw,
 599         .write_raw = hmc5843_write_raw,
 600         .write_raw_get_fmt = hmc5843_write_raw_get_fmt,
 601         .driver_module = THIS_MODULE,
 602 };
 603
 604 static const unsigned long hmc5843_scan_masks[] = {0x7, 0};
 605
 606 int hmc5843_common_suspend(struct device *dev)
 607 {
 608         return hmc5843_set_mode(iio_priv(dev_get_drvdata(dev)),
 609                                 HMC5843_MODE_SLEEP);
 610 }
 611 EXPORT_SYMBOL(hmc5843_common_suspend);
 612
 613 int hmc5843_common_resume(struct device *dev)
 614 {
 615         return hmc5843_set_mode(iio_priv(dev_get_drvdata(dev)),
 616                 HMC5843_MODE_CONVERSION_CONTINUOUS);
 617 }
 618 EXPORT_SYMBOL(hmc5843_common_resume);
 619
 620 int hmc5843_common_probe(struct device *dev, struct regmap *regmap,
 621                          enum hmc5843_ids id, const char *name)
 622 {
 623         struct hmc5843_data *data;
 624         struct iio_dev *indio_dev;
 625         int ret;
 626
 627         indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
 628         if (!indio_dev)
 629                 return -ENOMEM;
 630
 631         dev_set_drvdata(dev, indio_dev);
 632
 633         /* default settings at probe */
 634         data = iio_priv(indio_dev);
 635         data->dev = dev;
 636         data->regmap = regmap;
 637         data->variant = &hmc5843_chip_info_tbl[id];
 638         mutex_init(&data->lock);
 639
 640         indio_dev->dev.parent = dev;
 641         indio_dev->name = name;
 642         indio_dev->info = &hmc5843_info;
 643         indio_dev->modes = INDIO_DIRECT_MODE;
 644         indio_dev->channels = data->variant->channels;
 645         indio_dev->num_channels = 4;
 646         indio_dev->available_scan_masks = hmc5843_scan_masks;
 647
 648         ret = hmc5843_init(data);
 649         if (ret < 0)
 650                 return ret;
 651
 652         ret = iio_triggered_buffer_setup(indio_dev, NULL,
 653                                          hmc5843_trigger_handler, NULL);
 654         if (ret < 0)
 655                 goto buffer_setup_err;
 656
 657         ret = iio_device_register(indio_dev);
 658         if (ret < 0)
 659                 goto buffer_cleanup;
 660
 661         return 0;
 662
 663 buffer_cleanup:
 664         iio_triggered_buffer_cleanup(indio_dev);
 665 buffer_setup_err:
 666         hmc5843_set_mode(iio_priv(indio_dev), HMC5843_MODE_SLEEP);
 667         return ret;
 668 }
 669 EXPORT_SYMBOL(hmc5843_common_probe);
 670
 671 int hmc5843_common_remove(struct device *dev)
 672 {
 673         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 674
 675         iio_device_unregister(indio_dev);
 676         iio_triggered_buffer_cleanup(indio_dev);
 677
 678         /*  sleep mode to save power */
 679         hmc5843_set_mode(iio_priv(indio_dev), HMC5843_MODE_SLEEP);
 680
 681         return 0;
 682 }
 683 EXPORT_SYMBOL(hmc5843_common_remove);
 684
 685 MODULE_AUTHOR("Shubhrajyoti Datta <shubhrajyoti@ti.com>");
 686 MODULE_DESCRIPTION("HMC5843/5883/5883L/5983 core driver");
 687 MODULE_LICENSE("GPL");