drivers/iio/adc/max1027.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2  /*
   3   * iio/adc/max1027.c
   4   * Copyright (C) 2014 Philippe Reynes
   5   *
   6   * based on linux/drivers/iio/ad7923.c
   7   * Copyright 2011 Analog Devices Inc (from AD7923 Driver)
   8   * Copyright 2012 CS Systemes d'Information
   9   *
  10   * max1027.c
  11   *
  12   * Partial support for max1027 and similar chips.
  13   */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/mod_devicetable.h>
  18 #include <linux/spi/spi.h>
  19 #include <linux/delay.h>
  20
  21 #include <linux/iio/iio.h>
  22 #include <linux/iio/buffer.h>
  23 #include <linux/iio/trigger.h>
  24 #include <linux/iio/trigger_consumer.h>
  25 #include <linux/iio/triggered_buffer.h>
  26
  27 #define MAX1027_CONV_REG  BIT(7)
  28 #define MAX1027_SETUP_REG BIT(6)
  29 #define MAX1027_AVG_REG   BIT(5)
  30 #define MAX1027_RST_REG   BIT(4)
  31
  32 /* conversion register */
  33 #define MAX1027_TEMP      BIT(0)
  34 #define MAX1027_SCAN_0_N  (0x00 << 1)
  35 #define MAX1027_SCAN_N_M  (0x01 << 1)
  36 #define MAX1027_SCAN_N    (0x02 << 1)
  37 #define MAX1027_NOSCAN    (0x03 << 1)
  38 #define MAX1027_CHAN(n)   ((n) << 3)
  39
  40 /* setup register */
  41 #define MAX1027_UNIPOLAR  0x02
  42 #define MAX1027_BIPOLAR   0x03
  43 #define MAX1027_REF_MODE0 (0x00 << 2)
  44 #define MAX1027_REF_MODE1 (0x01 << 2)
  45 #define MAX1027_REF_MODE2 (0x02 << 2)
  46 #define MAX1027_REF_MODE3 (0x03 << 2)
  47 #define MAX1027_CKS_MODE0 (0x00 << 4)
  48 #define MAX1027_CKS_MODE1 (0x01 << 4)
  49 #define MAX1027_CKS_MODE2 (0x02 << 4)
  50 #define MAX1027_CKS_MODE3 (0x03 << 4)
  51
  52 /* averaging register */
  53 #define MAX1027_NSCAN_4   0x00
  54 #define MAX1027_NSCAN_8   0x01
  55 #define MAX1027_NSCAN_12  0x02
  56 #define MAX1027_NSCAN_16  0x03
  57 #define MAX1027_NAVG_4    (0x00 << 2)
  58 #define MAX1027_NAVG_8    (0x01 << 2)
  59 #define MAX1027_NAVG_16   (0x02 << 2)
  60 #define MAX1027_NAVG_32   (0x03 << 2)
  61 #define MAX1027_AVG_EN    BIT(4)
  62
  63 /* Device can achieve 300ksps so we assume a 3.33us conversion delay */
  64 #define MAX1027_CONVERSION_UDELAY 4
  65
  66 enum max1027_id {
  67         max1027,
  68         max1029,
  69         max1031,
  70         max1227,
  71         max1229,
  72         max1231,
  73 };
  74
  75 static const struct spi_device_id max1027_id[] = {
  76         {"max1027", max1027},
  77         {"max1029", max1029},
  78         {"max1031", max1031},
  79         {"max1227", max1227},
  80         {"max1229", max1229},
  81         {"max1231", max1231},
  82         {}
  83 };
  84 MODULE_DEVICE_TABLE(spi, max1027_id);
  85
  86 static const struct of_device_id max1027_adc_dt_ids[] = {
  87         { .compatible = "maxim,max1027" },
  88         { .compatible = "maxim,max1029" },
  89         { .compatible = "maxim,max1031" },
  90         { .compatible = "maxim,max1227" },
  91         { .compatible = "maxim,max1229" },
  92         { .compatible = "maxim,max1231" },
  93         {},
  94 };
  95 MODULE_DEVICE_TABLE(of, max1027_adc_dt_ids);
  96
  97 #define MAX1027_V_CHAN(index, depth)                                    \
  98         {                                                               \
  99                 .type = IIO_VOLTAGE,                                    \
 100                 .indexed = 1,                                           \
 101                 .channel = index,                                       \
 102                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
 103                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
 104                 .scan_index = index + 1,                                \
 105                 .scan_type = {                                          \
 106                         .sign = 'u',                                    \
 107                         .realbits = depth,                              \
 108                         .storagebits = 16,                              \
 109                         .shift = (depth == 10) ? 2 : 0,                 \
 110                         .endianness = IIO_BE,                           \
 111                 },                                                      \
 112         }
 113
 114 #define MAX1027_T_CHAN                                                  \
 115         {                                                               \
 116                 .type = IIO_TEMP,                                       \
 117                 .channel = 0,                                           \
 118                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
 119                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
 120                 .scan_index = 0,                                        \
 121                 .scan_type = {                                          \
 122                         .sign = 'u',                                    \
 123                         .realbits = 12,                                 \
 124                         .storagebits = 16,                              \
 125                         .endianness = IIO_BE,                           \
 126                 },                                                      \
 127         }
 128
 129 #define MAX1X27_CHANNELS(depth)                 \
 130         MAX1027_T_CHAN,                         \
 131         MAX1027_V_CHAN(0, depth),               \
 132         MAX1027_V_CHAN(1, depth),               \
 133         MAX1027_V_CHAN(2, depth),               \
 134         MAX1027_V_CHAN(3, depth),               \
 135         MAX1027_V_CHAN(4, depth),               \
 136         MAX1027_V_CHAN(5, depth),               \
 137         MAX1027_V_CHAN(6, depth),               \
 138         MAX1027_V_CHAN(7, depth)
 139
 140 #define MAX1X29_CHANNELS(depth)                 \
 141         MAX1X27_CHANNELS(depth),                \
 142         MAX1027_V_CHAN(8, depth),               \
 143         MAX1027_V_CHAN(9, depth),               \
 144         MAX1027_V_CHAN(10, depth),              \
 145         MAX1027_V_CHAN(11, depth)
 146
 147 #define MAX1X31_CHANNELS(depth)                 \
 148         MAX1X29_CHANNELS(depth),                \
 149         MAX1027_V_CHAN(12, depth),              \
 150         MAX1027_V_CHAN(13, depth),              \
 151         MAX1027_V_CHAN(14, depth),              \
 152         MAX1027_V_CHAN(15, depth)
 153
 154 static const struct iio_chan_spec max1027_channels[] = {
 155         MAX1X27_CHANNELS(10),
 156 };
 157
 158 static const struct iio_chan_spec max1029_channels[] = {
 159         MAX1X29_CHANNELS(10),
 160 };
 161
 162 static const struct iio_chan_spec max1031_channels[] = {
 163         MAX1X31_CHANNELS(10),
 164 };
 165
 166 static const struct iio_chan_spec max1227_channels[] = {
 167         MAX1X27_CHANNELS(12),
 168 };
 169
 170 static const struct iio_chan_spec max1229_channels[] = {
 171         MAX1X29_CHANNELS(12),
 172 };
 173
 174 static const struct iio_chan_spec max1231_channels[] = {
 175         MAX1X31_CHANNELS(12),
 176 };
 177
 178 /*
 179  * These devices are able to scan from 0 to N, N being the highest voltage
 180  * channel requested by the user. The temperature can be included or not,
 181  * but cannot be retrieved alone. Based on the below
 182  * ->available_scan_masks, the core will select the most appropriate
 183  * ->active_scan_mask and the "minimum" number of channels will be
 184  * scanned and pushed to the buffers.
 185  *
 186  * For example, if the user wants channels 1, 4 and 5, all channels from
 187  * 0 to 5 will be scanned and pushed to the IIO buffers. The core will then
 188  * filter out the unneeded samples based on the ->active_scan_mask that has
 189  * been selected and only channels 1, 4 and 5 will be available to the user
 190  * in the shared buffer.
 191  */
 192 #define MAX1X27_SCAN_MASK_TEMP BIT(0)
 193
 194 #define MAX1X27_SCAN_MASKS(temp)                                        \
 195         GENMASK(1, 1 - (temp)), GENMASK(2, 1 - (temp)),                 \
 196         GENMASK(3, 1 - (temp)), GENMASK(4, 1 - (temp)),                 \
 197         GENMASK(5, 1 - (temp)), GENMASK(6, 1 - (temp)),                 \
 198         GENMASK(7, 1 - (temp)), GENMASK(8, 1 - (temp))
 199
 200 #define MAX1X29_SCAN_MASKS(temp)                                        \
 201         MAX1X27_SCAN_MASKS(temp),                                       \
 202         GENMASK(9, 1 - (temp)), GENMASK(10, 1 - (temp)),                \
 203         GENMASK(11, 1 - (temp)), GENMASK(12, 1 - (temp))
 204
 205 #define MAX1X31_SCAN_MASKS(temp)                                        \
 206         MAX1X29_SCAN_MASKS(temp),                                       \
 207         GENMASK(13, 1 - (temp)), GENMASK(14, 1 - (temp)),               \
 208         GENMASK(15, 1 - (temp)), GENMASK(16, 1 - (temp))
 209
 210 static const unsigned long max1027_available_scan_masks[] = {
 211         MAX1X27_SCAN_MASKS(0),
 212         MAX1X27_SCAN_MASKS(1),
 213         0x00000000,
 214 };
 215
 216 static const unsigned long max1029_available_scan_masks[] = {
 217         MAX1X29_SCAN_MASKS(0),
 218         MAX1X29_SCAN_MASKS(1),
 219         0x00000000,
 220 };
 221
 222 static const unsigned long max1031_available_scan_masks[] = {
 223         MAX1X31_SCAN_MASKS(0),
 224         MAX1X31_SCAN_MASKS(1),
 225         0x00000000,
 226 };
 227
 228 struct max1027_chip_info {
 229         const struct iio_chan_spec *channels;
 230         unsigned int num_channels;
 231         const unsigned long *available_scan_masks;
 232 };
 233
 234 static const struct max1027_chip_info max1027_chip_info_tbl[] = {
 235         [max1027] = {
 236                 .channels = max1027_channels,
 237                 .num_channels = ARRAY_SIZE(max1027_channels),
 238                 .available_scan_masks = max1027_available_scan_masks,
 239         },
 240         [max1029] = {
 241                 .channels = max1029_channels,
 242                 .num_channels = ARRAY_SIZE(max1029_channels),
 243                 .available_scan_masks = max1029_available_scan_masks,
 244         },
 245         [max1031] = {
 246                 .channels = max1031_channels,
 247                 .num_channels = ARRAY_SIZE(max1031_channels),
 248                 .available_scan_masks = max1031_available_scan_masks,
 249         },
 250         [max1227] = {
 251                 .channels = max1227_channels,
 252                 .num_channels = ARRAY_SIZE(max1227_channels),
 253                 .available_scan_masks = max1027_available_scan_masks,
 254         },
 255         [max1229] = {
 256                 .channels = max1229_channels,
 257                 .num_channels = ARRAY_SIZE(max1229_channels),
 258                 .available_scan_masks = max1029_available_scan_masks,
 259         },
 260         [max1231] = {
 261                 .channels = max1231_channels,
 262                 .num_channels = ARRAY_SIZE(max1231_channels),
 263                 .available_scan_masks = max1031_available_scan_masks,
 264         },
 265 };
 266
 267 struct max1027_state {
 268         const struct max1027_chip_info  *info;
 269         struct spi_device               *spi;
 270         struct iio_trigger              *trig;
 271         __be16                          *buffer;
 272         struct mutex                    lock;
 273         struct completion               complete;
 274
 275         u8                              reg __aligned(IIO_DMA_MINALIGN);
 276 };
 277
 278 static int max1027_wait_eoc(struct iio_dev *indio_dev)
 279 {
 280         struct max1027_state *st = iio_priv(indio_dev);
 281         unsigned int conversion_time = MAX1027_CONVERSION_UDELAY;
 282         int ret;
 283
 284         if (st->spi->irq) {
 285                 ret = wait_for_completion_timeout(&st->complete,
 286                                                   msecs_to_jiffies(1000));
 287                 reinit_completion(&st->complete);
 288                 if (!ret)
 289                         return -ETIMEDOUT;
 290         } else {
 291                 if (indio_dev->active_scan_mask)
 292                         conversion_time *= hweight32(*indio_dev->active_scan_mask);
 293
 294                 usleep_range(conversion_time, conversion_time * 2);
 295         }
 296
 297         return 0;
 298 }
 299
 300 /* Scan from chan 0 to the highest requested channel. Include temperature on demand. */
 301 static int max1027_configure_chans_and_start(struct iio_dev *indio_dev)
 302 {
 303         struct max1027_state *st = iio_priv(indio_dev);
 304
 305         st->reg = MAX1027_CONV_REG | MAX1027_SCAN_0_N;
 306         st->reg |= MAX1027_CHAN(fls(*indio_dev->active_scan_mask) - 2);
 307         if (*indio_dev->active_scan_mask & MAX1X27_SCAN_MASK_TEMP)
 308                 st->reg |= MAX1027_TEMP;
 309
 310         return spi_write(st->spi, &st->reg, 1);
 311 }
 312
 313 static int max1027_enable_trigger(struct iio_dev *indio_dev, bool enable)
 314 {
 315         struct max1027_state *st = iio_priv(indio_dev);
 316
 317         st->reg = MAX1027_SETUP_REG | MAX1027_REF_MODE2;
 318
 319         /*
 320          * Start acquisition on:
 321          * MODE0: external hardware trigger wired to the cnvst input pin
 322          * MODE2: conversion register write
 323          */
 324         if (enable)
 325                 st->reg |= MAX1027_CKS_MODE0;
 326         else
 327                 st->reg |= MAX1027_CKS_MODE2;
 328
 329         return spi_write(st->spi, &st->reg, 1);
 330 }
 331
 332 static int max1027_read_single_value(struct iio_dev *indio_dev,
 333                                      struct iio_chan_spec const *chan,
 334                                      int *val)
 335 {
 336         int ret;
 337         struct max1027_state *st = iio_priv(indio_dev);
 338
 339         ret = iio_device_claim_direct_mode(indio_dev);
 340         if (ret)
 341                 return ret;
 342
 343         /* Configure conversion register with the requested chan */
 344         st->reg = MAX1027_CONV_REG | MAX1027_CHAN(chan->channel) |
 345                   MAX1027_NOSCAN;
 346         if (chan->type == IIO_TEMP)
 347                 st->reg |= MAX1027_TEMP;
 348         ret = spi_write(st->spi, &st->reg, 1);
 349         if (ret < 0) {
 350                 dev_err(&indio_dev->dev,
 351                         "Failed to configure conversion register\n");
 352                 goto release;
 353         }
 354
 355         /*
 356          * For an unknown reason, when we use the mode "10" (write
 357          * conversion register), the interrupt doesn't occur every time.
 358          * So we just wait the maximum conversion time and deliver the value.
 359          */
 360         ret = max1027_wait_eoc(indio_dev);
 361         if (ret)
 362                 goto release;
 363
 364         /* Read result */
 365         ret = spi_read(st->spi, st->buffer, (chan->type == IIO_TEMP) ? 4 : 2);
 366
 367 release:
 368         iio_device_release_direct_mode(indio_dev);
 369
 370         if (ret < 0)
 371                 return ret;
 372
 373         *val = be16_to_cpu(st->buffer[0]);
 374
 375         return IIO_VAL_INT;
 376 }
 377
 378 static int max1027_read_raw(struct iio_dev *indio_dev,
 379                             struct iio_chan_spec const *chan,
 380                             int *val, int *val2, long mask)
 381 {
 382         int ret = 0;
 383         struct max1027_state *st = iio_priv(indio_dev);
 384
 385         mutex_lock(&st->lock);
 386
 387         switch (mask) {
 388         case IIO_CHAN_INFO_RAW:
 389                 ret = max1027_read_single_value(indio_dev, chan, val);
 390                 break;
 391         case IIO_CHAN_INFO_SCALE:
 392                 switch (chan->type) {
 393                 case IIO_TEMP:
 394                         *val = 1;
 395                         *val2 = 8;
 396                         ret = IIO_VAL_FRACTIONAL;
 397                         break;
 398                 case IIO_VOLTAGE:
 399                         *val = 2500;
 400                         *val2 = chan->scan_type.realbits;
 401                         ret = IIO_VAL_FRACTIONAL_LOG2;
 402                         break;
 403                 default:
 404                         ret = -EINVAL;
 405                         break;
 406                 }
 407                 break;
 408         default:
 409                 ret = -EINVAL;
 410                 break;
 411         }
 412
 413         mutex_unlock(&st->lock);
 414
 415         return ret;
 416 }
 417
 418 static int max1027_debugfs_reg_access(struct iio_dev *indio_dev,
 419                                       unsigned int reg, unsigned int writeval,
 420                                       unsigned int *readval)
 421 {
 422         struct max1027_state *st = iio_priv(indio_dev);
 423         u8 *val = (u8 *)st->buffer;
 424
 425         if (readval) {
 426                 int ret = spi_read(st->spi, val, 2);
 427                 *readval = be16_to_cpu(st->buffer[0]);
 428                 return ret;
 429         }
 430
 431         *val = (u8)writeval;
 432         return spi_write(st->spi, val, 1);
 433 }
 434
 435 static int max1027_set_cnvst_trigger_state(struct iio_trigger *trig, bool state)
 436 {
 437         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 438         int ret;
 439
 440         /*
 441          * In order to disable the convst trigger, start acquisition on
 442          * conversion register write, which basically disables triggering
 443          * conversions upon cnvst changes and thus has the effect of disabling
 444          * the external hardware trigger.
 445          */
 446         ret = max1027_enable_trigger(indio_dev, state);
 447         if (ret)
 448                 return ret;
 449
 450         if (state) {
 451                 ret = max1027_configure_chans_and_start(indio_dev);
 452                 if (ret)
 453                         return ret;
 454         }
 455
 456         return 0;
 457 }
 458
 459 static int max1027_read_scan(struct iio_dev *indio_dev)
 460 {
 461         struct max1027_state *st = iio_priv(indio_dev);
 462         unsigned int scanned_chans;
 463         int ret;
 464
 465         scanned_chans = fls(*indio_dev->active_scan_mask) - 1;
 466         if (*indio_dev->active_scan_mask & MAX1X27_SCAN_MASK_TEMP)
 467                 scanned_chans++;
 468
 469         /* fill buffer with all channel */
 470         ret = spi_read(st->spi, st->buffer, scanned_chans * 2);
 471         if (ret < 0)
 472                 return ret;
 473
 474         iio_push_to_buffers(indio_dev, st->buffer);
 475
 476         return 0;
 477 }
 478
 479 static irqreturn_t max1027_handler(int irq, void *private)
 480 {
 481         struct iio_dev *indio_dev = private;
 482         struct max1027_state *st = iio_priv(indio_dev);
 483
 484         /*
 485          * If buffers are disabled (raw read) or when using external triggers,
 486          * we just need to unlock the waiters which will then handle the data.
 487          *
 488          * When using the internal trigger, we must hand-off the choice of the
 489          * handler to the core which will then lookup through the interrupt tree
 490          * for the right handler registered with iio_triggered_buffer_setup()
 491          * to execute, as this trigger might very well be used in conjunction
 492          * with another device. The core will then call the relevant handler to
 493          * perform the data processing step.
 494          */
 495         if (!iio_buffer_enabled(indio_dev))
 496                 complete(&st->complete);
 497         else
 498                 iio_trigger_poll(indio_dev->trig);
 499
 500         return IRQ_HANDLED;
 501 }
 502
 503 static irqreturn_t max1027_trigger_handler(int irq, void *private)
 504 {
 505         struct iio_poll_func *pf = private;
 506         struct iio_dev *indio_dev = pf->indio_dev;
 507         int ret;
 508
 509         if (!iio_trigger_using_own(indio_dev)) {
 510                 ret = max1027_configure_chans_and_start(indio_dev);
 511                 if (ret)
 512                         goto out;
 513
 514                 /* This is a threaded handler, it is fine to wait for an IRQ */
 515                 ret = max1027_wait_eoc(indio_dev);
 516                 if (ret)
 517                         goto out;
 518         }
 519
 520         ret = max1027_read_scan(indio_dev);
 521 out:
 522         if (ret)
 523                 dev_err(&indio_dev->dev,
 524                         "Cannot read scanned values (%d)\n", ret);
 525
 526         iio_trigger_notify_done(indio_dev->trig);
 527
 528         return IRQ_HANDLED;
 529 }
 530
 531 static const struct iio_trigger_ops max1027_trigger_ops = {
 532         .validate_device = &iio_trigger_validate_own_device,
 533         .set_trigger_state = &max1027_set_cnvst_trigger_state,
 534 };
 535
 536 static const struct iio_info max1027_info = {
 537         .read_raw = &max1027_read_raw,
 538         .debugfs_reg_access = &max1027_debugfs_reg_access,
 539 };
 540
 541 static int max1027_probe(struct spi_device *spi)
 542 {
 543         int ret;
 544         struct iio_dev *indio_dev;
 545         struct max1027_state *st;
 546
 547         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
 548         if (!indio_dev) {
 549                 pr_err("Can't allocate iio device\n");
 550                 return -ENOMEM;
 551         }
 552
 553         st = iio_priv(indio_dev);
 554         st->spi = spi;
 555         st->info = &max1027_chip_info_tbl[spi_get_device_id(spi)->driver_data];
 556
 557         mutex_init(&st->lock);
 558         init_completion(&st->complete);
 559
 560         indio_dev->name = spi_get_device_id(spi)->name;
 561         indio_dev->info = &max1027_info;
 562         indio_dev->modes = INDIO_DIRECT_MODE;
 563         indio_dev->channels = st->info->channels;
 564         indio_dev->num_channels = st->info->num_channels;
 565         indio_dev->available_scan_masks = st->info->available_scan_masks;
 566
 567         st->buffer = devm_kmalloc_array(&indio_dev->dev,
 568                                         indio_dev->num_channels, 2,
 569                                         GFP_KERNEL);
 570         if (!st->buffer)
 571                 return -ENOMEM;
 572
 573         /* Enable triggered buffers */
 574         ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev,
 575                                               &iio_pollfunc_store_time,
 576                                               &max1027_trigger_handler,
 577                                               NULL);
 578         if (ret < 0) {
 579                 dev_err(&indio_dev->dev, "Failed to setup buffer\n");
 580                 return ret;
 581         }
 582
 583         /* If there is an EOC interrupt, register the cnvst hardware trigger */
 584         if (spi->irq) {
 585                 st->trig = devm_iio_trigger_alloc(&spi->dev, "%s-trigger",
 586                                                   indio_dev->name);
 587                 if (!st->trig) {
 588                         ret = -ENOMEM;
 589                         dev_err(&indio_dev->dev,
 590                                 "Failed to allocate iio trigger\n");
 591                         return ret;
 592                 }
 593
 594                 st->trig->ops = &max1027_trigger_ops;
 595                 iio_trigger_set_drvdata(st->trig, indio_dev);
 596                 ret = devm_iio_trigger_register(&indio_dev->dev,
 597                                                 st->trig);
 598                 if (ret < 0) {
 599                         dev_err(&indio_dev->dev,
 600                                 "Failed to register iio trigger\n");
 601                         return ret;
 602                 }
 603
 604                 ret = devm_request_irq(&spi->dev, spi->irq, max1027_handler,
 605                                        IRQF_TRIGGER_FALLING,
 606                                        spi->dev.driver->name, indio_dev);
 607                 if (ret < 0) {
 608                         dev_err(&indio_dev->dev, "Failed to allocate IRQ.\n");
 609                         return ret;
 610                 }
 611         }
 612
 613         /* Internal reset */
 614         st->reg = MAX1027_RST_REG;
 615         ret = spi_write(st->spi, &st->reg, 1);
 616         if (ret < 0) {
 617                 dev_err(&indio_dev->dev, "Failed to reset the ADC\n");
 618                 return ret;
 619         }
 620
 621         /* Disable averaging */
 622         st->reg = MAX1027_AVG_REG;
 623         ret = spi_write(st->spi, &st->reg, 1);
 624         if (ret < 0) {
 625                 dev_err(&indio_dev->dev, "Failed to configure averaging register\n");
 626                 return ret;
 627         }
 628
 629         /* Assume conversion on register write for now */
 630         ret = max1027_enable_trigger(indio_dev, false);
 631         if (ret)
 632                 return ret;
 633
 634         return devm_iio_device_register(&spi->dev, indio_dev);
 635 }
 636
 637 static struct spi_driver max1027_driver = {
 638         .driver = {
 639                 .name   = "max1027",
 640                 .of_match_table = max1027_adc_dt_ids,
 641         },
 642         .probe          = max1027_probe,
 643         .id_table       = max1027_id,
 644 };
 645 module_spi_driver(max1027_driver);
 646
 647 MODULE_AUTHOR("Philippe Reynes <[email protected]>");
 648 MODULE_DESCRIPTION("MAX1X27/MAX1X29/MAX1X31 ADC");
 649 MODULE_LICENSE("GPL v2");