drivers/staging/iio/adc/max1363_core.c

   1  /*
   2   * iio/adc/max1363.c
   3   * Copyright (C) 2008-2010 Jonathan Cameron
   4   *
   5   * based on linux/drivers/i2c/chips/max123x
   6   * Copyright (C) 2002-2004 Stefan Eletzhofer
   7   *
   8   * based on linux/drivers/acron/char/pcf8583.c
   9   * Copyright (C) 2000 Russell King
  10   *
  11   * This program is free software; you can redistribute it and/or modify
  12   * it under the terms of the GNU General Public License version 2 as
  13   * published by the Free Software Foundation.
  14   *
  15   * max1363.c
  16   *
  17   * Partial support for max1363 and similar chips.
  18   *
  19   * Not currently implemented.
  20   *
  21   * - Control of internal reference.
  22   */
  23
  24 #include <linux/interrupt.h>
  25 #include <linux/device.h>
  26 #include <linux/kernel.h>
  27 #include <linux/sysfs.h>
  28 #include <linux/list.h>
  29 #include <linux/i2c.h>
  30 #include <linux/regulator/consumer.h>
  31 #include <linux/slab.h>
  32 #include <linux/err.h>
  33
  34 #include "../iio.h"
  35 #include "../sysfs.h"
  36
  37 #include "../ring_generic.h"
  38 #include "adc.h"
  39 #include "max1363.h"
  40
  41 /* Here we claim all are 16 bits. This currently does no harm and saves
  42  * us a lot of scan element listings */
  43
  44 static const struct max1363_mode max1363_mode_table[] = {
  45         /* All of the single channel options first */
  46         MAX1363_MODE_SINGLE(0, 1 << 0),
  47         MAX1363_MODE_SINGLE(1, 1 << 1),
  48         MAX1363_MODE_SINGLE(2, 1 << 2),
  49         MAX1363_MODE_SINGLE(3, 1 << 3),
  50         MAX1363_MODE_SINGLE(4, 1 << 4),
  51         MAX1363_MODE_SINGLE(5, 1 << 5),
  52         MAX1363_MODE_SINGLE(6, 1 << 6),
  53         MAX1363_MODE_SINGLE(7, 1 << 7),
  54         MAX1363_MODE_SINGLE(8, 1 << 8),
  55         MAX1363_MODE_SINGLE(9, 1 << 9),
  56         MAX1363_MODE_SINGLE(10, 1 << 10),
  57         MAX1363_MODE_SINGLE(11, 1 << 11),
  58
  59         MAX1363_MODE_DIFF_SINGLE(0, 1, 1 << 12),
  60         MAX1363_MODE_DIFF_SINGLE(2, 3, 1 << 13),
  61         MAX1363_MODE_DIFF_SINGLE(4, 5, 1 << 14),
  62         MAX1363_MODE_DIFF_SINGLE(6, 7, 1 << 15),
  63         MAX1363_MODE_DIFF_SINGLE(8, 9, 1 << 16),
  64         MAX1363_MODE_DIFF_SINGLE(10, 11, 1 << 17),
  65         MAX1363_MODE_DIFF_SINGLE(1, 0, 1 << 18),
  66         MAX1363_MODE_DIFF_SINGLE(3, 2, 1 << 19),
  67         MAX1363_MODE_DIFF_SINGLE(5, 4, 1 << 20),
  68         MAX1363_MODE_DIFF_SINGLE(7, 6, 1 << 21),
  69         MAX1363_MODE_DIFF_SINGLE(9, 8, 1 << 22),
  70         MAX1363_MODE_DIFF_SINGLE(11, 10, 1 << 23),
  71
  72         /* The multichannel scans next */
  73         MAX1363_MODE_SCAN_TO_CHANNEL(1, 0x003),
  74         MAX1363_MODE_SCAN_TO_CHANNEL(2, 0x007),
  75         MAX1236_MODE_SCAN_MID_TO_CHANNEL(2, 3, 0x00C),
  76         MAX1363_MODE_SCAN_TO_CHANNEL(3, 0x00F),
  77         MAX1363_MODE_SCAN_TO_CHANNEL(4, 0x01F),
  78         MAX1363_MODE_SCAN_TO_CHANNEL(5, 0x03F),
  79         MAX1363_MODE_SCAN_TO_CHANNEL(6, 0x07F),
  80         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 7, 0x0C0),
  81         MAX1363_MODE_SCAN_TO_CHANNEL(7, 0x0FF),
  82         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 8, 0x1C0),
  83         MAX1363_MODE_SCAN_TO_CHANNEL(8, 0x1FF),
  84         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 9, 0x3C0),
  85         MAX1363_MODE_SCAN_TO_CHANNEL(9, 0x3FF),
  86         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 10, 0x7C0),
  87         MAX1363_MODE_SCAN_TO_CHANNEL(10, 0x7FF),
  88         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 11, 0xFC0),
  89         MAX1363_MODE_SCAN_TO_CHANNEL(11, 0xFFF),
  90
  91         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(2, 2, 0x003000),
  92         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(4, 3, 0x007000),
  93         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(6, 4, 0x00F000),
  94         MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(8, 2, 0x018000),
  95         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(8, 5, 0x01F000),
  96         MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(10, 3, 0x038000),
  97         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(10, 6, 0x3F000),
  98         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(3, 2, 0x0C0000),
  99         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(5, 3, 0x1C0000),
 100         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(7, 4, 0x3C0000),
 101         MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(9, 2, 0x600000),
 102         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(9, 5, 0x7C0000),
 103         MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(11, 3, 0xE00000),
 104         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(11, 6, 0xFC0000),
 105 };
 106
 107 const struct max1363_mode
 108 *max1363_match_mode(u32 mask, const struct max1363_chip_info *ci)
 109 {
 110         int i;
 111         if (mask)
 112                 for (i = 0; i < ci->num_modes; i++)
 113                         if (!((~max1363_mode_table[ci->mode_list[i]].modemask) &
 114                               mask))
 115                                 return &max1363_mode_table[ci->mode_list[i]];
 116         return NULL;
 117 }
 118
 119 static int max1363_write_basic_config(struct i2c_client *client,
 120                                       unsigned char d1,
 121                                       unsigned char d2)
 122 {
 123         int ret;
 124         u8 *tx_buf = kmalloc(2, GFP_KERNEL);
 125
 126         if (!tx_buf)
 127                 return -ENOMEM;
 128         tx_buf[0] = d1;
 129         tx_buf[1] = d2;
 130
 131         ret = i2c_master_send(client, tx_buf, 2);
 132         kfree(tx_buf);
 133
 134         return (ret > 0) ? 0 : ret;
 135 }
 136
 137 int max1363_set_scan_mode(struct max1363_state *st)
 138 {
 139         st->configbyte &= ~(MAX1363_CHANNEL_SEL_MASK
 140                             | MAX1363_SCAN_MASK
 141                             | MAX1363_SE_DE_MASK);
 142         st->configbyte |= st->current_mode->conf;
 143
 144         return max1363_write_basic_config(st->client,
 145                                           st->setupbyte,
 146                                           st->configbyte);
 147 }
 148
 149 static int max1363_read_single_chan(struct iio_dev *indio_dev,
 150                                     struct iio_chan_spec const *chan,
 151                                     int *val,
 152                                     long m)
 153 {
 154         int ret = 0;
 155         s32 data;
 156         char rxbuf[2];
 157         long mask;
 158         struct max1363_state *st = iio_priv(indio_dev);
 159         struct i2c_client *client = st->client;
 160
 161         mutex_lock(&indio_dev->mlock);
 162         /*
 163          * If monitor mode is enabled, the method for reading a single
 164          * channel will have to be rather different and has not yet
 165          * been implemented.
 166          */
 167         if (st->monitor_on) {
 168                 ret = -EBUSY;
 169                 goto error_ret;
 170         }
 171
 172         /* If ring buffer capture is occurring, query the buffer */
 173         if (iio_ring_enabled(indio_dev)) {
 174                 mask = max1363_mode_table[chan->address].modemask;
 175                 data = max1363_single_channel_from_ring(mask, st);
 176                 if (data < 0) {
 177                         ret = data;
 178                         goto error_ret;
 179                 }
 180         } else {
 181                 /* Check to see if current scan mode is correct */
 182                 if (st->current_mode !=
 183                     &max1363_mode_table[chan->address]) {
 184                         /* Update scan mode if needed */
 185                         st->current_mode
 186                                 = &max1363_mode_table[chan->address];
 187                         ret = max1363_set_scan_mode(st);
 188                         if (ret)
 189                                 goto error_ret;
 190                 }
 191                 if (st->chip_info->bits != 8) {
 192                         /* Get reading */
 193                         data = i2c_master_recv(client, rxbuf, 2);
 194                         if (data < 0) {
 195                                 ret = data;
 196                                 goto error_ret;
 197                         }
 198                         data = (s32)(rxbuf[1]) | ((s32)(rxbuf[0] & 0x0F)) << 8;
 199                 } else {
 200                         /* Get reading */
 201                         data = i2c_master_recv(client, rxbuf, 1);
 202                         if (data < 0) {
 203                                 ret = data;
 204                                 goto error_ret;
 205                         }
 206                         data = rxbuf[0];
 207                 }
 208         }
 209         *val = data;
 210 error_ret:
 211         mutex_unlock(&indio_dev->mlock);
 212         return ret;
 213
 214 }
 215
 216 static int max1363_read_raw(struct iio_dev *indio_dev,
 217                             struct iio_chan_spec const *chan,
 218                             int *val,
 219                             int *val2,
 220                             long m)
 221 {
 222         struct max1363_state *st = iio_priv(indio_dev);
 223         int ret;
 224         switch (m) {
 225         case 0:
 226                 ret = max1363_read_single_chan(indio_dev, chan, val, m);
 227                 if (ret)
 228                         return ret;
 229                 return IIO_VAL_INT;
 230         case (1 << IIO_CHAN_INFO_SCALE_SHARED):
 231                 if ((1 << (st->chip_info->bits + 1)) >
 232                     st->chip_info->int_vref_mv) {
 233                         *val = 0;
 234                         *val2 = 500000;
 235                         return IIO_VAL_INT_PLUS_MICRO;
 236                 } else {
 237                         *val = (st->chip_info->int_vref_mv)
 238                                 >> st->chip_info->bits;
 239                         return IIO_VAL_INT;
 240                 }
 241         default:
 242                 return -EINVAL;
 243         }
 244         return 0;
 245 }
 246
 247 /* Applies to max1363 */
 248 static const enum max1363_modes max1363_mode_list[] = {
 249         _s0, _s1, _s2, _s3,
 250         s0to1, s0to2, s0to3,
 251         d0m1, d2m3, d1m0, d3m2,
 252         d0m1to2m3, d1m0to3m2,
 253 };
 254
 255 #define MAX1363_EV_M                                            \
 256         (IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING)      \
 257          | IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING))
 258 #define MAX1363_INFO_MASK (1 << IIO_CHAN_INFO_SCALE_SHARED)
 259
 260 static struct iio_chan_spec max1363_channels[] = {
 261         IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0, MAX1363_INFO_MASK,
 262                  _s0, 0, IIO_ST('u', 12, 16, 0), MAX1363_EV_M),
 263         IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0, MAX1363_INFO_MASK,
 264                  _s1, 1, IIO_ST('u', 12, 16, 0), MAX1363_EV_M),
 265         IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 2, 0, MAX1363_INFO_MASK,
 266                  _s2, 2, IIO_ST('u', 12, 16, 0), MAX1363_EV_M),
 267         IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 3, 0, MAX1363_INFO_MASK,
 268                  _s3, 3, IIO_ST('u', 12, 16, 0), MAX1363_EV_M),
 269         IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 0, 1, MAX1363_INFO_MASK,
 270                  d0m1, 4, IIO_ST('s', 12, 16, 0), MAX1363_EV_M),
 271         IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 2, 3, MAX1363_INFO_MASK,
 272                  d2m3, 5, IIO_ST('s', 12, 16, 0), MAX1363_EV_M),
 273         IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 1, 0, MAX1363_INFO_MASK,
 274                  d1m0, 6, IIO_ST('s', 12, 16, 0), MAX1363_EV_M),
 275         IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 3, 2, MAX1363_INFO_MASK,
 276                  d3m2, 7, IIO_ST('s', 12, 16, 0), MAX1363_EV_M),
 277         IIO_CHAN_SOFT_TIMESTAMP(8)
 278 };
 279
 280 static struct iio_chan_spec max1361_channels[] = {
 281         IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0, MAX1363_INFO_MASK,
 282                  _s0, 0, IIO_ST('u', 10, 16, 0), MAX1363_EV_M),
 283         IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0, MAX1363_INFO_MASK,
 284                  _s1, 1, IIO_ST('u', 10, 16, 0), MAX1363_EV_M),
 285         IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 2, 0, MAX1363_INFO_MASK,
 286                  _s2, 2, IIO_ST('u', 10, 16, 0), MAX1363_EV_M),
 287         IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 3, 0, MAX1363_INFO_MASK,
 288                  _s3, 3, IIO_ST('u', 10, 16, 0), MAX1363_EV_M),
 289         IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 0, 1, MAX1363_INFO_MASK,
 290                  d0m1, 4, IIO_ST('s', 10, 16, 0), MAX1363_EV_M),
 291         IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 2, 3, MAX1363_INFO_MASK,
 292                  d2m3, 5, IIO_ST('s', 10, 16, 0), MAX1363_EV_M),
 293         IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 1, 0, MAX1363_INFO_MASK,
 294                  d1m0, 6, IIO_ST('s', 10, 16, 0), MAX1363_EV_M),
 295         IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 3, 2, MAX1363_INFO_MASK,
 296                  d3m2, 7, IIO_ST('s', 10, 16, 0), MAX1363_EV_M),
 297         IIO_CHAN_SOFT_TIMESTAMP(8)
 298 };
 299
 300 #define MAX1363_CHAN_U(num, address, scan_index, bits)          \
 301         IIO_CHAN(IIO_IN, 0, 1, 0, NULL, num, 0, MAX1363_INFO_MASK,      \
 302                  address, scan_index, IIO_ST('u', bits,         \
 303                                              (bits == 8) ? 8 : 16, 0), 0)
 304 /* bipolar channel */
 305 #define MAX1363_CHAN_B(num, num2, address, scan_index, bits)            \
 306         IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, num, num2, MAX1363_INFO_MASK,\
 307                  address, scan_index, IIO_ST('s', bits,         \
 308                                              (bits == 8) ? 8 : 16, 0), 0)
 309
 310 #define MAX1363_4X_CHANS(bits) {                \
 311         MAX1363_CHAN_U(0, _s0, 0, bits),        \
 312         MAX1363_CHAN_U(1, _s1, 1, bits),        \
 313         MAX1363_CHAN_U(2, _s2, 2, bits),        \
 314         MAX1363_CHAN_U(3, _s3, 3, bits),        \
 315         MAX1363_CHAN_B(0, 1, d0m1, 4, bits),    \
 316         MAX1363_CHAN_B(2, 3, d2m3, 5, bits),    \
 317         MAX1363_CHAN_B(1, 0, d1m0, 6, bits),    \
 318         MAX1363_CHAN_B(3, 2, d3m2, 7, bits),    \
 319         IIO_CHAN_SOFT_TIMESTAMP(8)              \
 320         }
 321
 322 static struct iio_chan_spec max1036_channels[] = MAX1363_4X_CHANS(8);
 323 static struct iio_chan_spec max1136_channels[] = MAX1363_4X_CHANS(10);
 324 static struct iio_chan_spec max1236_channels[] = MAX1363_4X_CHANS(12);
 325
 326 /* Appies to max1236, max1237 */
 327 static const enum max1363_modes max1236_mode_list[] = {
 328         _s0, _s1, _s2, _s3,
 329         s0to1, s0to2, s0to3,
 330         d0m1, d2m3, d1m0, d3m2,
 331         d0m1to2m3, d1m0to3m2,
 332         s2to3,
 333 };
 334
 335 /* Applies to max1238, max1239 */
 336 static const enum max1363_modes max1238_mode_list[] = {
 337         _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7, _s8, _s9, _s10, _s11,
 338         s0to1, s0to2, s0to3, s0to4, s0to5, s0to6,
 339         s0to7, s0to8, s0to9, s0to10, s0to11,
 340         d0m1, d2m3, d4m5, d6m7, d8m9, d10m11,
 341         d1m0, d3m2, d5m4, d7m6, d9m8, d11m10,
 342         d0m1to2m3, d0m1to4m5, d0m1to6m7, d0m1to8m9, d0m1to10m11,
 343         d1m0to3m2, d1m0to5m4, d1m0to7m6, d1m0to9m8, d1m0to11m10,
 344         s6to7, s6to8, s6to9, s6to10, s6to11,
 345         d6m7to8m9, d6m7to10m11, d7m6to9m8, d7m6to11m10,
 346 };
 347
 348 #define MAX1363_12X_CHANS(bits) {                       \
 349         MAX1363_CHAN_U(0, _s0, 0, bits),                \
 350         MAX1363_CHAN_U(1, _s1, 1, bits),                \
 351         MAX1363_CHAN_U(2, _s2, 2, bits),                \
 352         MAX1363_CHAN_U(3, _s3, 3, bits),                \
 353         MAX1363_CHAN_U(4, _s4, 4, bits),                \
 354         MAX1363_CHAN_U(5, _s5, 5, bits),                \
 355         MAX1363_CHAN_U(6, _s6, 6, bits),                \
 356         MAX1363_CHAN_U(7, _s7, 7, bits),                \
 357         MAX1363_CHAN_U(8, _s8, 8, bits),                \
 358         MAX1363_CHAN_U(9, _s9, 9, bits),                \
 359         MAX1363_CHAN_U(10, _s10, 10, bits),             \
 360         MAX1363_CHAN_U(11, _s11, 11, bits),             \
 361         MAX1363_CHAN_B(0, 1, d0m1, 12, bits),           \
 362         MAX1363_CHAN_B(2, 3, d2m3, 13, bits),           \
 363         MAX1363_CHAN_B(4, 5, d4m5, 14, bits),           \
 364         MAX1363_CHAN_B(6, 7, d6m7, 15, bits),           \
 365         MAX1363_CHAN_B(8, 9, d8m9, 16, bits),           \
 366         MAX1363_CHAN_B(10, 11, d10m11, 17, bits),       \
 367         MAX1363_CHAN_B(1, 0, d1m0, 18, bits),           \
 368         MAX1363_CHAN_B(3, 2, d3m2, 19, bits),           \
 369         MAX1363_CHAN_B(5, 4, d5m4, 20, bits),           \
 370         MAX1363_CHAN_B(7, 6, d7m6, 21, bits),           \
 371         MAX1363_CHAN_B(9, 8, d9m8, 22, bits),           \
 372         MAX1363_CHAN_B(11, 10, d11m10, 23, bits),       \
 373         IIO_CHAN_SOFT_TIMESTAMP(24)                     \
 374         }
 375 static struct iio_chan_spec max1038_channels[] = MAX1363_12X_CHANS(8);
 376 static struct iio_chan_spec max1138_channels[] = MAX1363_12X_CHANS(10);
 377 static struct iio_chan_spec max1238_channels[] = MAX1363_12X_CHANS(12);
 378
 379 static const enum max1363_modes max11607_mode_list[] = {
 380         _s0, _s1, _s2, _s3,
 381         s0to1, s0to2, s0to3,
 382         s2to3,
 383         d0m1, d2m3, d1m0, d3m2,
 384         d0m1to2m3, d1m0to3m2,
 385 };
 386
 387 static const enum max1363_modes max11608_mode_list[] = {
 388         _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7,
 389         s0to1, s0to2, s0to3, s0to4, s0to5, s0to6, s0to7,
 390         s6to7,
 391         d0m1, d2m3, d4m5, d6m7,
 392         d1m0, d3m2, d5m4, d7m6,
 393         d0m1to2m3, d0m1to4m5, d0m1to6m7,
 394         d1m0to3m2, d1m0to5m4, d1m0to7m6,
 395 };
 396
 397 #define MAX1363_8X_CHANS(bits) {                                \
 398                 MAX1363_CHAN_U(0, _s0, 0, bits),                \
 399                         MAX1363_CHAN_U(1, _s1, 1, bits),        \
 400                         MAX1363_CHAN_U(2, _s2, 2, bits),        \
 401                         MAX1363_CHAN_U(3, _s3, 3, bits),        \
 402                         MAX1363_CHAN_U(4, _s4, 4, bits),        \
 403                         MAX1363_CHAN_U(5, _s5, 5, bits),        \
 404                         MAX1363_CHAN_U(6, _s6, 6, bits),        \
 405                         MAX1363_CHAN_U(7, _s7, 7, bits),        \
 406                         MAX1363_CHAN_B(0, 1, d0m1, 8, bits),    \
 407                         MAX1363_CHAN_B(2, 3, d2m3, 9, bits),    \
 408                         MAX1363_CHAN_B(4, 5, d4m5, 10, bits),   \
 409                         MAX1363_CHAN_B(6, 7, d6m7, 11, bits),   \
 410                         MAX1363_CHAN_B(1, 0, d1m0, 12, bits),   \
 411                         MAX1363_CHAN_B(3, 2, d3m2, 13, bits),   \
 412                         MAX1363_CHAN_B(5, 4, d5m4, 14, bits),   \
 413                         MAX1363_CHAN_B(7, 6, d7m6, 15, bits),   \
 414                         IIO_CHAN_SOFT_TIMESTAMP(16)             \
 415                 }
 416 static struct iio_chan_spec max11602_channels[] = MAX1363_8X_CHANS(8);
 417 static struct iio_chan_spec max11608_channels[] = MAX1363_8X_CHANS(10);
 418 static struct iio_chan_spec max11614_channels[] = MAX1363_8X_CHANS(12);
 419
 420 static const enum max1363_modes max11644_mode_list[] = {
 421         _s0, _s1, s0to1, d0m1, d1m0,
 422 };
 423
 424 #define MAX1363_2X_CHANS(bits) {                        \
 425         MAX1363_CHAN_U(0, _s0, 0, bits),                \
 426         MAX1363_CHAN_U(1, _s1, 1, bits),                \
 427         MAX1363_CHAN_B(0, 1, d0m1, 2, bits),            \
 428         MAX1363_CHAN_B(1, 0, d1m0, 3, bits),            \
 429         IIO_CHAN_SOFT_TIMESTAMP(4)                      \
 430         }
 431
 432 static struct iio_chan_spec max11646_channels[] = MAX1363_2X_CHANS(10);
 433 static struct iio_chan_spec max11644_channels[] = MAX1363_2X_CHANS(12);
 434
 435 enum { max1361,
 436        max1362,
 437        max1363,
 438        max1364,
 439        max1036,
 440        max1037,
 441        max1038,
 442        max1039,
 443        max1136,
 444        max1137,
 445        max1138,
 446        max1139,
 447        max1236,
 448        max1237,
 449        max1238,
 450        max1239,
 451        max11600,
 452        max11601,
 453        max11602,
 454        max11603,
 455        max11604,
 456        max11605,
 457        max11606,
 458        max11607,
 459        max11608,
 460        max11609,
 461        max11610,
 462        max11611,
 463        max11612,
 464        max11613,
 465        max11614,
 466        max11615,
 467        max11616,
 468        max11617,
 469        max11644,
 470        max11645,
 471        max11646,
 472        max11647
 473 };
 474
 475 /* max1363 and max1368 tested - rest from data sheet */
 476 static const struct max1363_chip_info max1363_chip_info_tbl[] = {
 477         [max1361] = {
 478                 .bits = 10,
 479                 .int_vref_mv = 2048,
 480                 .monitor_mode = 1,
 481                 .mode_list = max1363_mode_list,
 482                 .num_modes = ARRAY_SIZE(max1363_mode_list),
 483                 .default_mode = s0to3,
 484                 .channels = max1361_channels,
 485                 .num_channels = ARRAY_SIZE(max1361_channels),
 486         },
 487         [max1362] = {
 488                 .bits = 10,
 489                 .int_vref_mv = 4096,
 490                 .monitor_mode = 1,
 491                 .mode_list = max1363_mode_list,
 492                 .num_modes = ARRAY_SIZE(max1363_mode_list),
 493                 .default_mode = s0to3,
 494                 .channels = max1361_channels,
 495                 .num_channels = ARRAY_SIZE(max1361_channels),
 496         },
 497         [max1363] = {
 498                 .bits = 12,
 499                 .int_vref_mv = 2048,
 500                 .monitor_mode = 1,
 501                 .mode_list = max1363_mode_list,
 502                 .num_modes = ARRAY_SIZE(max1363_mode_list),
 503                 .default_mode = s0to3,
 504                 .channels = max1363_channels,
 505                 .num_channels = ARRAY_SIZE(max1363_channels),
 506         },
 507         [max1364] = {
 508                 .bits = 12,
 509                 .int_vref_mv = 4096,
 510                 .monitor_mode = 1,
 511                 .mode_list = max1363_mode_list,
 512                 .num_modes = ARRAY_SIZE(max1363_mode_list),
 513                 .default_mode = s0to3,
 514                 .channels = max1363_channels,
 515                 .num_channels = ARRAY_SIZE(max1363_channels),
 516         },
 517         [max1036] = {
 518                 .bits = 8,
 519                 .int_vref_mv = 4096,
 520                 .mode_list = max1236_mode_list,
 521                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 522                 .default_mode = s0to3,
 523                 .channels = max1036_channels,
 524                 .num_channels = ARRAY_SIZE(max1036_channels),
 525         },
 526         [max1037] = {
 527                 .bits = 8,
 528                 .int_vref_mv = 2048,
 529                 .mode_list = max1236_mode_list,
 530                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 531                 .default_mode = s0to3,
 532                 .channels = max1036_channels,
 533                 .num_channels = ARRAY_SIZE(max1036_channels),
 534         },
 535         [max1038] = {
 536                 .bits = 8,
 537                 .int_vref_mv = 4096,
 538                 .mode_list = max1238_mode_list,
 539                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 540                 .default_mode = s0to11,
 541                 .channels = max1038_channels,
 542                 .num_channels = ARRAY_SIZE(max1038_channels),
 543         },
 544         [max1039] = {
 545                 .bits = 8,
 546                 .int_vref_mv = 2048,
 547                 .mode_list = max1238_mode_list,
 548                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 549                 .default_mode = s0to11,
 550                 .channels = max1038_channels,
 551                 .num_channels = ARRAY_SIZE(max1038_channels),
 552         },
 553         [max1136] = {
 554                 .bits = 10,
 555                 .int_vref_mv = 4096,
 556                 .mode_list = max1236_mode_list,
 557                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 558                 .default_mode = s0to3,
 559                 .channels = max1136_channels,
 560                 .num_channels = ARRAY_SIZE(max1136_channels),
 561         },
 562         [max1137] = {
 563                 .bits = 10,
 564                 .int_vref_mv = 2048,
 565                 .mode_list = max1236_mode_list,
 566                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 567                 .default_mode = s0to3,
 568                 .channels = max1136_channels,
 569                 .num_channels = ARRAY_SIZE(max1136_channels),
 570         },
 571         [max1138] = {
 572                 .bits = 10,
 573                 .int_vref_mv = 4096,
 574                 .mode_list = max1238_mode_list,
 575                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 576                 .default_mode = s0to11,
 577                 .channels = max1138_channels,
 578                 .num_channels = ARRAY_SIZE(max1138_channels),
 579         },
 580         [max1139] = {
 581                 .bits = 10,
 582                 .int_vref_mv = 2048,
 583                 .mode_list = max1238_mode_list,
 584                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 585                 .default_mode = s0to11,
 586                 .channels = max1138_channels,
 587                 .num_channels = ARRAY_SIZE(max1138_channels),
 588         },
 589         [max1236] = {
 590                 .bits = 12,
 591                 .int_vref_mv = 4096,
 592                 .mode_list = max1236_mode_list,
 593                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 594                 .default_mode = s0to3,
 595                 .channels = max1236_channels,
 596                 .num_channels = ARRAY_SIZE(max1236_channels),
 597         },
 598         [max1237] = {
 599                 .bits = 12,
 600                 .int_vref_mv = 2048,
 601                 .mode_list = max1236_mode_list,
 602                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 603                 .default_mode = s0to3,
 604                 .channels = max1236_channels,
 605                 .num_channels = ARRAY_SIZE(max1236_channels),
 606         },
 607         [max1238] = {
 608                 .bits = 12,
 609                 .int_vref_mv = 4096,
 610                 .mode_list = max1238_mode_list,
 611                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 612                 .default_mode = s0to11,
 613                 .channels = max1238_channels,
 614                 .num_channels = ARRAY_SIZE(max1238_channels),
 615         },
 616         [max1239] = {
 617                 .bits = 12,
 618                 .int_vref_mv = 2048,
 619                 .mode_list = max1238_mode_list,
 620                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 621                 .default_mode = s0to11,
 622                 .channels = max1238_channels,
 623                 .num_channels = ARRAY_SIZE(max1238_channels),
 624         },
 625         [max11600] = {
 626                 .bits = 8,
 627                 .int_vref_mv = 4096,
 628                 .mode_list = max11607_mode_list,
 629                 .num_modes = ARRAY_SIZE(max11607_mode_list),
 630                 .default_mode = s0to3,
 631                 .channels = max1036_channels,
 632                 .num_channels = ARRAY_SIZE(max1036_channels),
 633         },
 634         [max11601] = {
 635                 .bits = 8,
 636                 .int_vref_mv = 2048,
 637                 .mode_list = max11607_mode_list,
 638                 .num_modes = ARRAY_SIZE(max11607_mode_list),
 639                 .default_mode = s0to3,
 640                 .channels = max1036_channels,
 641                 .num_channels = ARRAY_SIZE(max1036_channels),
 642         },
 643         [max11602] = {
 644                 .bits = 8,
 645                 .int_vref_mv = 4096,
 646                 .mode_list = max11608_mode_list,
 647                 .num_modes = ARRAY_SIZE(max11608_mode_list),
 648                 .default_mode = s0to7,
 649                 .channels = max11602_channels,
 650                 .num_channels = ARRAY_SIZE(max11602_channels),
 651         },
 652         [max11603] = {
 653                 .bits = 8,
 654                 .int_vref_mv = 2048,
 655                 .mode_list = max11608_mode_list,
 656                 .num_modes = ARRAY_SIZE(max11608_mode_list),
 657                 .default_mode = s0to7,
 658                 .channels = max11602_channels,
 659                 .num_channels = ARRAY_SIZE(max11602_channels),
 660         },
 661         [max11604] = {
 662                 .bits = 8,
 663                 .int_vref_mv = 4098,
 664                 .mode_list = max1238_mode_list,
 665                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 666                 .default_mode = s0to11,
 667                 .channels = max1238_channels,
 668                 .num_channels = ARRAY_SIZE(max1238_channels),
 669         },
 670         [max11605] = {
 671                 .bits = 8,
 672                 .int_vref_mv = 2048,
 673                 .mode_list = max1238_mode_list,
 674                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 675                 .default_mode = s0to11,
 676                 .channels = max1238_channels,
 677                 .num_channels = ARRAY_SIZE(max1238_channels),
 678         },
 679         [max11606] = {
 680                 .bits = 10,
 681                 .int_vref_mv = 4096,
 682                 .mode_list = max11607_mode_list,
 683                 .num_modes = ARRAY_SIZE(max11607_mode_list),
 684                 .default_mode = s0to3,
 685                 .channels = max1136_channels,
 686                 .num_channels = ARRAY_SIZE(max1136_channels),
 687         },
 688         [max11607] = {
 689                 .bits = 10,
 690                 .int_vref_mv = 2048,
 691                 .mode_list = max11607_mode_list,
 692                 .num_modes = ARRAY_SIZE(max11607_mode_list),
 693                 .default_mode = s0to3,
 694                 .channels = max1136_channels,
 695                 .num_channels = ARRAY_SIZE(max1136_channels),
 696         },
 697         [max11608] = {
 698                 .bits = 10,
 699                 .int_vref_mv = 4096,
 700                 .mode_list = max11608_mode_list,
 701                 .num_modes = ARRAY_SIZE(max11608_mode_list),
 702                 .default_mode = s0to7,
 703                 .channels = max11608_channels,
 704                 .num_channels = ARRAY_SIZE(max11608_channels),
 705         },
 706         [max11609] = {
 707                 .bits = 10,
 708                 .int_vref_mv = 2048,
 709                 .mode_list = max11608_mode_list,
 710                 .num_modes = ARRAY_SIZE(max11608_mode_list),
 711                 .default_mode = s0to7,
 712                 .channels = max11608_channels,
 713                 .num_channels = ARRAY_SIZE(max11608_channels),
 714         },
 715         [max11610] = {
 716                 .bits = 10,
 717                 .int_vref_mv = 4098,
 718                 .mode_list = max1238_mode_list,
 719                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 720                 .default_mode = s0to11,
 721                 .channels = max1238_channels,
 722                 .num_channels = ARRAY_SIZE(max1238_channels),
 723         },
 724         [max11611] = {
 725                 .bits = 10,
 726                 .int_vref_mv = 2048,
 727                 .mode_list = max1238_mode_list,
 728                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 729                 .default_mode = s0to11,
 730                 .channels = max1238_channels,
 731                 .num_channels = ARRAY_SIZE(max1238_channels),
 732         },
 733         [max11612] = {
 734                 .bits = 12,
 735                 .int_vref_mv = 4096,
 736                 .mode_list = max11607_mode_list,
 737                 .num_modes = ARRAY_SIZE(max11607_mode_list),
 738                 .default_mode = s0to3,
 739                 .channels = max1363_channels,
 740                 .num_channels = ARRAY_SIZE(max1363_channels),
 741         },
 742         [max11613] = {
 743                 .bits = 12,
 744                 .int_vref_mv = 2048,
 745                 .mode_list = max11607_mode_list,
 746                 .num_modes = ARRAY_SIZE(max11607_mode_list),
 747                 .default_mode = s0to3,
 748                 .channels = max1363_channels,
 749                 .num_channels = ARRAY_SIZE(max1363_channels),
 750         },
 751         [max11614] = {
 752                 .bits = 12,
 753                 .int_vref_mv = 4096,
 754                 .mode_list = max11608_mode_list,
 755                 .num_modes = ARRAY_SIZE(max11608_mode_list),
 756                 .default_mode = s0to7,
 757                 .channels = max11614_channels,
 758                 .num_channels = ARRAY_SIZE(max11614_channels),
 759         },
 760         [max11615] = {
 761                 .bits = 12,
 762                 .int_vref_mv = 2048,
 763                 .mode_list = max11608_mode_list,
 764                 .num_modes = ARRAY_SIZE(max11608_mode_list),
 765                 .default_mode = s0to7,
 766                 .channels = max11614_channels,
 767                 .num_channels = ARRAY_SIZE(max11614_channels),
 768         },
 769         [max11616] = {
 770                 .bits = 12,
 771                 .int_vref_mv = 4098,
 772                 .mode_list = max1238_mode_list,
 773                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 774                 .default_mode = s0to11,
 775                 .channels = max1238_channels,
 776                 .num_channels = ARRAY_SIZE(max1238_channels),
 777         },
 778         [max11617] = {
 779                 .bits = 12,
 780                 .int_vref_mv = 2048,
 781                 .mode_list = max1238_mode_list,
 782                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 783                 .default_mode = s0to11,
 784                 .channels = max1238_channels,
 785                 .num_channels = ARRAY_SIZE(max1238_channels),
 786         },
 787         [max11644] = {
 788                 .bits = 12,
 789                 .int_vref_mv = 2048,
 790                 .mode_list = max11644_mode_list,
 791                 .num_modes = ARRAY_SIZE(max11644_mode_list),
 792                 .default_mode = s0to1,
 793                 .channels = max11644_channels,
 794                 .num_channels = ARRAY_SIZE(max11644_channels),
 795         },
 796         [max11645] = {
 797                 .bits = 12,
 798                 .int_vref_mv = 4096,
 799                 .mode_list = max11644_mode_list,
 800                 .num_modes = ARRAY_SIZE(max11644_mode_list),
 801                 .default_mode = s0to1,
 802                 .channels = max11644_channels,
 803                 .num_channels = ARRAY_SIZE(max11644_channels),
 804         },
 805         [max11646] = {
 806                 .bits = 10,
 807                 .int_vref_mv = 2048,
 808                 .mode_list = max11644_mode_list,
 809                 .num_modes = ARRAY_SIZE(max11644_mode_list),
 810                 .default_mode = s0to1,
 811                 .channels = max11644_channels,
 812                 .num_channels = ARRAY_SIZE(max11646_channels),
 813         },
 814         [max11647] = {
 815                 .bits = 10,
 816                 .int_vref_mv = 4096,
 817                 .mode_list = max11644_mode_list,
 818                 .num_modes = ARRAY_SIZE(max11644_mode_list),
 819                 .default_mode = s0to1,
 820                 .channels = max11644_channels,
 821                 .num_channels = ARRAY_SIZE(max11646_channels),
 822         },
 823 };
 824
 825 static const int max1363_monitor_speeds[] = { 133000, 665000, 33300, 16600,
 826                                               8300, 4200, 2000, 1000 };
 827
 828 static ssize_t max1363_monitor_show_freq(struct device *dev,
 829                                         struct device_attribute *attr,
 830                                         char *buf)
 831 {
 832         struct max1363_state *st = iio_priv(dev_get_drvdata(dev));
 833         return sprintf(buf, "%d\n", max1363_monitor_speeds[st->monitor_speed]);
 834 }
 835
 836 static ssize_t max1363_monitor_store_freq(struct device *dev,
 837                                         struct device_attribute *attr,
 838                                         const char *buf,
 839                                         size_t len)
 840 {
 841         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 842         struct max1363_state *st = iio_priv(indio_dev);
 843         int i, ret;
 844         unsigned long val;
 845         bool found = false;
 846
 847         ret = strict_strtoul(buf, 10, &val);
 848         if (ret)
 849                 return -EINVAL;
 850         for (i = 0; i < ARRAY_SIZE(max1363_monitor_speeds); i++)
 851                 if (val == max1363_monitor_speeds[i]) {
 852                         found = true;
 853                         break;
 854                 }
 855         if (!found)
 856                 return -EINVAL;
 857
 858         mutex_lock(&indio_dev->mlock);
 859         st->monitor_speed = i;
 860         mutex_unlock(&indio_dev->mlock);
 861
 862         return 0;
 863 }
 864
 865 static IIO_DEV_ATTR_SAMP_FREQ(S_IRUGO | S_IWUSR,
 866                         max1363_monitor_show_freq,
 867                         max1363_monitor_store_freq);
 868
 869 static IIO_CONST_ATTR(sampling_frequency_available,
 870                 "133000 665000 33300 16600 8300 4200 2000 1000");
 871
 872 static int max1363_read_thresh(struct iio_dev *indio_dev,
 873                                int event_code,
 874                                int *val)
 875 {
 876         struct max1363_state *st = iio_priv(indio_dev);
 877         if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) == IIO_EV_DIR_FALLING)
 878                 *val = st->thresh_low[IIO_EVENT_CODE_EXTRACT_NUM(event_code)];
 879         else
 880                 *val = st->thresh_high[IIO_EVENT_CODE_EXTRACT_NUM(event_code)];
 881         return 0;
 882 }
 883
 884 static int max1363_write_thresh(struct iio_dev *indio_dev,
 885                                 int event_code,
 886                                 int val)
 887 {
 888         struct max1363_state *st = iio_priv(indio_dev);
 889         /* make it handle signed correctly as well */
 890         switch (st->chip_info->bits) {
 891         case 10:
 892                 if (val > 0x3FF)
 893                         return -EINVAL;
 894                 break;
 895         case 12:
 896                 if (val > 0xFFF)
 897                         return -EINVAL;
 898                 break;
 899         }
 900
 901         switch (IIO_EVENT_CODE_EXTRACT_DIR(event_code)) {
 902         case IIO_EV_DIR_FALLING:
 903                 st->thresh_low[IIO_EVENT_CODE_EXTRACT_NUM(event_code)] = val;
 904                 break;
 905         case IIO_EV_DIR_RISING:
 906                 st->thresh_high[IIO_EVENT_CODE_EXTRACT_NUM(event_code)] = val;
 907                 break;
 908         }
 909
 910         return 0;
 911 }
 912
 913 static irqreturn_t max1363_event_handler(int irq, void *private)
 914 {
 915         struct iio_dev *indio_dev = private;
 916         struct max1363_state *st = iio_priv(indio_dev);
 917         s64 timestamp = iio_get_time_ns();
 918         u8 rx;
 919         u8 tx[2] = { st->setupbyte,
 920                      MAX1363_MON_INT_ENABLE | (st->monitor_speed << 1) | 0xF0 };
 921
 922         i2c_master_recv(st->client, &rx, 1);
 923         /* todo - begging for use of for_each_set_bit */
 924         if (rx & (1 << 0))
 925                 iio_push_event(indio_dev, 0,
 926                         IIO_EVENT_CODE_IN_LOW_THRESH(3),
 927                         timestamp);
 928         if (rx & (1 << 1))
 929                 iio_push_event(indio_dev, 0,
 930                         IIO_EVENT_CODE_IN_HIGH_THRESH(3),
 931                         timestamp);
 932         if (rx & (1 << 2))
 933                 iio_push_event(indio_dev, 0,
 934                         IIO_EVENT_CODE_IN_LOW_THRESH(2),
 935                         timestamp);
 936         if (rx & (1 << 3))
 937                 iio_push_event(indio_dev, 0,
 938                         IIO_EVENT_CODE_IN_HIGH_THRESH(2),
 939                         timestamp);
 940         if (rx & (1 << 4))
 941                 iio_push_event(indio_dev, 0,
 942                         IIO_EVENT_CODE_IN_LOW_THRESH(1),
 943                         timestamp);
 944         if (rx & (1 << 5))
 945                 iio_push_event(indio_dev, 0,
 946                         IIO_EVENT_CODE_IN_HIGH_THRESH(1),
 947                         timestamp);
 948         if (rx & (1 << 6))
 949                 iio_push_event(indio_dev, 0,
 950                         IIO_EVENT_CODE_IN_LOW_THRESH(0),
 951                         timestamp);
 952         if (rx & (1 << 7))
 953                 iio_push_event(indio_dev, 0,
 954                         IIO_EVENT_CODE_IN_HIGH_THRESH(0),
 955                         timestamp);
 956         i2c_master_send(st->client, tx, 2);
 957
 958         return IRQ_HANDLED;
 959 }
 960
 961 static int max1363_read_event_config(struct iio_dev *indio_dev,
 962                                      int event_code)
 963 {
 964         struct max1363_state *st = iio_priv(indio_dev);
 965
 966         int val;
 967         int number = IIO_EVENT_CODE_EXTRACT_NUM(event_code);
 968         mutex_lock(&indio_dev->mlock);
 969         if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) == IIO_EV_DIR_FALLING)
 970                 val = (1 << number) & st->mask_low;
 971         else
 972                 val = (1 << number) & st->mask_high;
 973         mutex_unlock(&indio_dev->mlock);
 974
 975         return val;
 976 }
 977
 978 static int max1363_monitor_mode_update(struct max1363_state *st, int enabled)
 979 {
 980         u8 *tx_buf;
 981         int ret, i = 3, j;
 982         unsigned long numelements;
 983         int len;
 984         long modemask;
 985
 986         if (!enabled) {
 987                 /* transition to ring capture is not currently supported */
 988                 st->setupbyte &= ~MAX1363_SETUP_MONITOR_SETUP;
 989                 st->configbyte &= ~MAX1363_SCAN_MASK;
 990                 st->monitor_on = false;
 991                 return max1363_write_basic_config(st->client,
 992                                                 st->setupbyte,
 993                                                 st->configbyte);
 994         }
 995
 996         /* Ensure we are in the relevant mode */
 997         st->setupbyte |= MAX1363_SETUP_MONITOR_SETUP;
 998         st->configbyte &= ~(MAX1363_CHANNEL_SEL_MASK
 999                             | MAX1363_SCAN_MASK
1000                         | MAX1363_SE_DE_MASK);
1001         st->configbyte |= MAX1363_CONFIG_SCAN_MONITOR_MODE;
1002         if ((st->mask_low | st->mask_high) & 0x0F) {
1003                 st->configbyte |= max1363_mode_table[s0to3].conf;
1004                 modemask = max1363_mode_table[s0to3].modemask;
1005         } else if ((st->mask_low | st->mask_high) & 0x30) {
1006                 st->configbyte |= max1363_mode_table[d0m1to2m3].conf;
1007                 modemask = max1363_mode_table[d0m1to2m3].modemask;
1008         } else {
1009                 st->configbyte |= max1363_mode_table[d1m0to3m2].conf;
1010                 modemask = max1363_mode_table[d1m0to3m2].modemask;
1011         }
1012         numelements = hweight_long(modemask);
1013         len = 3 * numelements + 3;
1014         tx_buf = kmalloc(len, GFP_KERNEL);
1015         if (!tx_buf) {
1016                 ret = -ENOMEM;
1017                 goto error_ret;
1018         }
1019         tx_buf[0] = st->configbyte;
1020         tx_buf[1] = st->setupbyte;
1021         tx_buf[2] = (st->monitor_speed << 1);
1022
1023         /*
1024          * So we need to do yet another bit of nefarious scan mode
1025          * setup to match what we need.
1026          */
1027         for (j = 0; j < 8; j++)
1028                 if (modemask & (1 << j)) {
1029                         /* Establish the mode is in the scan */
1030                         if (st->mask_low & (1 << j)) {
1031                                 tx_buf[i] = (st->thresh_low[j] >> 4) & 0xFF;
1032                                 tx_buf[i + 1] = (st->thresh_low[j] << 4) & 0xF0;
1033                         } else if (j < 4) {
1034                                 tx_buf[i] = 0;
1035                                 tx_buf[i + 1] = 0;
1036                         } else {
1037                                 tx_buf[i] = 0x80;
1038                                 tx_buf[i + 1] = 0;
1039                         }
1040                         if (st->mask_high & (1 << j)) {
1041                                 tx_buf[i + 1] |=
1042                                         (st->thresh_high[j] >> 8) & 0x0F;
1043                                 tx_buf[i + 2] = st->thresh_high[j] & 0xFF;
1044                         } else if (j < 4) {
1045                                 tx_buf[i + 1] |= 0x0F;
1046                                 tx_buf[i + 2] = 0xFF;
1047                         } else {
1048                                 tx_buf[i + 1] |= 0x07;
1049                                 tx_buf[i + 2] = 0xFF;
1050                         }
1051                         i += 3;
1052                 }
1053
1054
1055         ret = i2c_master_send(st->client, tx_buf, len);
1056         if (ret < 0)
1057                 goto error_ret;
1058         if (ret != len) {
1059                 ret = -EIO;
1060                 goto error_ret;
1061         }
1062
1063         /*
1064          * Now that we hopefully have sensible thresholds in place it is
1065          * time to turn the interrupts on.
1066          * It is unclear from the data sheet if this should be necessary
1067          * (i.e. whether monitor mode setup is atomic) but it appears to
1068          * be in practice.
1069          */
1070         tx_buf[0] = st->setupbyte;
1071         tx_buf[1] = MAX1363_MON_INT_ENABLE | (st->monitor_speed << 1) | 0xF0;
1072         ret = i2c_master_send(st->client, tx_buf, 2);
1073         if (ret < 0)
1074                 goto error_ret;
1075         if (ret != 2) {
1076                 ret = -EIO;
1077                 goto error_ret;
1078         }
1079         ret = 0;
1080         st->monitor_on = true;
1081 error_ret:
1082
1083         kfree(tx_buf);
1084
1085         return ret;
1086 }
1087
1088 /*
1089  * To keep this manageable we always use one of 3 scan modes.
1090  * Scan 0...3, 0-1,2-3 and 1-0,3-2
1091  */
1092
1093 static inline int __max1363_check_event_mask(int thismask, int checkmask)
1094 {
1095         int ret = 0;
1096         /* Is it unipolar */
1097         if (thismask < 4) {
1098                 if (checkmask & ~0x0F) {
1099                         ret = -EBUSY;
1100                         goto error_ret;
1101                 }
1102         } else if (thismask < 6) {
1103                 if (checkmask & ~0x30) {
1104                         ret = -EBUSY;
1105                         goto error_ret;
1106                 }
1107         } else if (checkmask & ~0xC0)
1108                 ret = -EBUSY;
1109 error_ret:
1110         return ret;
1111 }
1112
1113 static int max1363_write_event_config(struct iio_dev *indio_dev,
1114                                       int event_code,
1115                                       int state)
1116 {
1117         int ret = 0;
1118         struct max1363_state *st = iio_priv(indio_dev);
1119         u16 unifiedmask;
1120         int number = IIO_EVENT_CODE_EXTRACT_NUM(event_code);
1121
1122         mutex_lock(&indio_dev->mlock);
1123         unifiedmask = st->mask_low | st->mask_high;
1124         if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) == IIO_EV_DIR_FALLING) {
1125
1126                 if (state == 0)
1127                         st->mask_low &= ~(1 << number);
1128                 else {
1129                         ret = __max1363_check_event_mask((1 << number),
1130                                                          unifiedmask);
1131                         if (ret)
1132                                 goto error_ret;
1133                         st->mask_low |= (1 << number);
1134                 }
1135         } else {
1136                 if (state == 0)
1137                         st->mask_high &= ~(1 << number);
1138                 else {
1139                         ret = __max1363_check_event_mask((1 << number),
1140                                                          unifiedmask);
1141                         if (ret)
1142                                 goto error_ret;
1143                         st->mask_high |= (1 << number);
1144                 }
1145         }
1146
1147         max1363_monitor_mode_update(st, !!(st->mask_high | st->mask_low));
1148 error_ret:
1149         mutex_unlock(&indio_dev->mlock);
1150
1151         return ret;
1152 }
1153
1154 /*
1155  * As with scan_elements, only certain sets of these can
1156  * be combined.
1157  */
1158 static struct attribute *max1363_event_attributes[] = {
1159         &iio_dev_attr_sampling_frequency.dev_attr.attr,
1160         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
1161         NULL,
1162 };
1163
1164 static struct attribute_group max1363_event_attribute_group = {
1165         .attrs = max1363_event_attributes,
1166 };
1167
1168 static int max1363_initial_setup(struct max1363_state *st)
1169 {
1170         st->setupbyte = MAX1363_SETUP_AIN3_IS_AIN3_REF_IS_VDD
1171                 | MAX1363_SETUP_POWER_UP_INT_REF
1172                 | MAX1363_SETUP_INT_CLOCK
1173                 | MAX1363_SETUP_UNIPOLAR
1174                 | MAX1363_SETUP_NORESET;
1175
1176         /* Set scan mode writes the config anyway so wait until then*/
1177         st->setupbyte = MAX1363_SETUP_BYTE(st->setupbyte);
1178         st->current_mode = &max1363_mode_table[st->chip_info->default_mode];
1179         st->configbyte = MAX1363_CONFIG_BYTE(st->configbyte);
1180
1181         return max1363_set_scan_mode(st);
1182 }
1183
1184 static int __devinit max1363_probe(struct i2c_client *client,
1185                                    const struct i2c_device_id *id)
1186 {
1187         int ret, i, regdone = 0;
1188         struct max1363_state *st;
1189         struct iio_dev *indio_dev;
1190         struct regulator *reg;
1191
1192         reg = regulator_get(&client->dev, "vcc");
1193         if (!IS_ERR(reg)) {
1194                 ret = regulator_enable(reg);
1195                 if (ret)
1196                         goto error_put_reg;
1197         }
1198
1199         indio_dev = iio_allocate_device(sizeof(struct max1363_state));
1200         if (indio_dev == NULL) {
1201                 ret = -ENOMEM;
1202                 goto error_disable_reg;
1203         }
1204         st = iio_priv(indio_dev);
1205         st->reg = reg;
1206         /* this is only used for device removal purposes */
1207         i2c_set_clientdata(client, indio_dev);
1208
1209         st->chip_info = &max1363_chip_info_tbl[id->driver_data];
1210         st->client = client;
1211
1212         indio_dev->available_scan_masks
1213                 = kzalloc(sizeof(*indio_dev->available_scan_masks)*
1214                           (st->chip_info->num_modes + 1), GFP_KERNEL);
1215         if (!indio_dev->available_scan_masks) {
1216                 ret = -ENOMEM;
1217                 goto error_free_device;
1218         }
1219
1220         for (i = 0; i < st->chip_info->num_modes; i++)
1221                 indio_dev->available_scan_masks[i] =
1222                         max1363_mode_table[st->chip_info->mode_list[i]]
1223                         .modemask;
1224         /* Estabilish that the iio_dev is a child of the i2c device */
1225         indio_dev->dev.parent = &client->dev;
1226         indio_dev->name = id->name;
1227         indio_dev->read_event_value = &max1363_read_thresh;
1228         indio_dev->write_event_value = &max1363_write_thresh;
1229         indio_dev->read_event_config = &max1363_read_event_config;
1230         indio_dev->write_event_config = &max1363_write_event_config;
1231         indio_dev->channels = st->chip_info->channels;
1232         indio_dev->num_channels = st->chip_info->num_channels;
1233         indio_dev->read_raw = &max1363_read_raw;
1234         /* Todo: this shouldn't be here. */
1235         indio_dev->driver_module = THIS_MODULE;
1236         indio_dev->modes = INDIO_DIRECT_MODE;
1237         if (st->chip_info->monitor_mode && client->irq) {
1238                 indio_dev->num_interrupt_lines = 1;
1239                 indio_dev->event_attrs
1240                         = &max1363_event_attribute_group;
1241         }
1242
1243         ret = max1363_initial_setup(st);
1244         if (ret)
1245                 goto error_free_available_scan_masks;
1246
1247         ret = max1363_register_ring_funcs_and_init(indio_dev);
1248         if (ret)
1249                 goto error_free_available_scan_masks;
1250
1251         ret = iio_device_register(indio_dev);
1252         if (ret)
1253                 goto error_cleanup_ring;
1254         regdone = 1;
1255         ret = iio_ring_buffer_register_ex(indio_dev->ring, 0,
1256                                           st->chip_info->channels,
1257                                           st->chip_info->num_channels);
1258         if (ret)
1259                 goto error_cleanup_ring;
1260
1261         if (st->chip_info->monitor_mode && client->irq) {
1262                 ret = request_threaded_irq(st->client->irq,
1263                                            NULL,
1264                                            &max1363_event_handler,
1265                                            IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1266                                            "max1363_event",
1267                                            indio_dev);
1268
1269                 if (ret)
1270                         goto error_uninit_ring;
1271         }
1272
1273         return 0;
1274 error_uninit_ring:
1275         iio_ring_buffer_unregister(indio_dev->ring);
1276 error_cleanup_ring:
1277         max1363_ring_cleanup(indio_dev);
1278 error_free_available_scan_masks:
1279         kfree(indio_dev->available_scan_masks);
1280 error_free_device:
1281         if (!regdone)
1282                 iio_free_device(indio_dev);
1283         else
1284                 iio_device_unregister(indio_dev);
1285 error_disable_reg:
1286         if (!IS_ERR(st->reg))
1287                 regulator_disable(st->reg);
1288 error_put_reg:
1289         if (!IS_ERR(st->reg))
1290                 regulator_put(st->reg);
1291
1292         return ret;
1293 }
1294
1295 static int max1363_remove(struct i2c_client *client)
1296 {
1297         struct iio_dev *indio_dev = i2c_get_clientdata(client);
1298         struct max1363_state *st = iio_priv(indio_dev);
1299         struct regulator *reg = st->reg;
1300
1301         if (st->chip_info->monitor_mode && client->irq)
1302                 free_irq(st->client->irq, indio_dev);
1303         iio_ring_buffer_unregister(indio_dev->ring);
1304         max1363_ring_cleanup(indio_dev);
1305         kfree(indio_dev->available_scan_masks);
1306         if (!IS_ERR(reg)) {
1307                 regulator_disable(reg);
1308                 regulator_put(reg);
1309         }
1310         iio_device_unregister(indio_dev);
1311
1312         return 0;
1313 }
1314
1315 static const struct i2c_device_id max1363_id[] = {
1316         { "max1361", max1361 },
1317         { "max1362", max1362 },
1318         { "max1363", max1363 },
1319         { "max1364", max1364 },
1320         { "max1036", max1036 },
1321         { "max1037", max1037 },
1322         { "max1038", max1038 },
1323         { "max1039", max1039 },
1324         { "max1136", max1136 },
1325         { "max1137", max1137 },
1326         { "max1138", max1138 },
1327         { "max1139", max1139 },
1328         { "max1236", max1236 },
1329         { "max1237", max1237 },
1330         { "max1238", max1238 },
1331         { "max1239", max1239 },
1332         { "max11600", max11600 },
1333         { "max11601", max11601 },
1334         { "max11602", max11602 },
1335         { "max11603", max11603 },
1336         { "max11604", max11604 },
1337         { "max11605", max11605 },
1338         { "max11606", max11606 },
1339         { "max11607", max11607 },
1340         { "max11608", max11608 },
1341         { "max11609", max11609 },
1342         { "max11610", max11610 },
1343         { "max11611", max11611 },
1344         { "max11612", max11612 },
1345         { "max11613", max11613 },
1346         { "max11614", max11614 },
1347         { "max11615", max11615 },
1348         { "max11616", max11616 },
1349         { "max11617", max11617 },
1350         {}
1351 };
1352
1353 MODULE_DEVICE_TABLE(i2c, max1363_id);
1354
1355 static struct i2c_driver max1363_driver = {
1356         .driver = {
1357                 .name = "max1363",
1358         },
1359         .probe = max1363_probe,
1360         .remove = max1363_remove,
1361         .id_table = max1363_id,
1362 };
1363
1364 static __init int max1363_init(void)
1365 {
1366         return i2c_add_driver(&max1363_driver);
1367 }
1368
1369 static __exit void max1363_exit(void)
1370 {
1371         i2c_del_driver(&max1363_driver);
1372 }
1373
1374 MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>");
1375 MODULE_DESCRIPTION("Maxim 1363 ADC");
1376 MODULE_LICENSE("GPL v2");
1377
1378 module_init(max1363_init);
1379 module_exit(max1363_exit);