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   * - Monitor interrrupt generation.
  22   * - Control of internal reference.
  23   */
  24
  25 #include <linux/interrupt.h>
  26 #include <linux/gpio.h>
  27 #include <linux/workqueue.h>
  28 #include <linux/device.h>
  29 #include <linux/kernel.h>
  30 #include <linux/sysfs.h>
  31 #include <linux/list.h>
  32 #include <linux/i2c.h>
  33 #include <linux/rtc.h>
  34 #include <linux/regulator/consumer.h>
  35 #include <linux/slab.h>
  36
  37 #include "../iio.h"
  38 #include "../sysfs.h"
  39
  40 #include "../ring_generic.h"
  41 #include "adc.h"
  42 #include "max1363.h"
  43
  44 /* Here we claim all are 16 bits. This currently does no harm and saves
  45  * us a lot of scan element listings */
  46
  47 #define MAX1363_SCAN_EL(number)                                         \
  48         IIO_SCAN_EL_C(in##number, number, IIO_UNSIGNED(16), 0, NULL);
  49 #define MAX1363_SCAN_EL_D(p, n, number)                                 \
  50         IIO_SCAN_NAMED_EL_C(in##p##m##in##n, in##p-in##n,               \
  51                         number, IIO_SIGNED(16), 0 , NULL);
  52
  53 static MAX1363_SCAN_EL(0);
  54 static MAX1363_SCAN_EL(1);
  55 static MAX1363_SCAN_EL(2);
  56 static MAX1363_SCAN_EL(3);
  57 static MAX1363_SCAN_EL(4);
  58 static MAX1363_SCAN_EL(5);
  59 static MAX1363_SCAN_EL(6);
  60 static MAX1363_SCAN_EL(7);
  61 static MAX1363_SCAN_EL(8);
  62 static MAX1363_SCAN_EL(9);
  63 static MAX1363_SCAN_EL(10);
  64 static MAX1363_SCAN_EL(11);
  65 static MAX1363_SCAN_EL_D(0, 1, 12);
  66 static MAX1363_SCAN_EL_D(2, 3, 13);
  67 static MAX1363_SCAN_EL_D(4, 5, 14);
  68 static MAX1363_SCAN_EL_D(6, 7, 15);
  69 static MAX1363_SCAN_EL_D(8, 9, 16);
  70 static MAX1363_SCAN_EL_D(10, 11, 17);
  71 static MAX1363_SCAN_EL_D(1, 0, 18);
  72 static MAX1363_SCAN_EL_D(3, 2, 19);
  73 static MAX1363_SCAN_EL_D(5, 4, 20);
  74 static MAX1363_SCAN_EL_D(7, 6, 21);
  75 static MAX1363_SCAN_EL_D(9, 8, 22);
  76 static MAX1363_SCAN_EL_D(11, 10, 23);
  77
  78 static const struct max1363_mode max1363_mode_table[] = {
  79         /* All of the single channel options first */
  80         MAX1363_MODE_SINGLE(0, 1 << 0),
  81         MAX1363_MODE_SINGLE(1, 1 << 1),
  82         MAX1363_MODE_SINGLE(2, 1 << 2),
  83         MAX1363_MODE_SINGLE(3, 1 << 3),
  84         MAX1363_MODE_SINGLE(4, 1 << 4),
  85         MAX1363_MODE_SINGLE(5, 1 << 5),
  86         MAX1363_MODE_SINGLE(6, 1 << 6),
  87         MAX1363_MODE_SINGLE(7, 1 << 7),
  88         MAX1363_MODE_SINGLE(8, 1 << 8),
  89         MAX1363_MODE_SINGLE(9, 1 << 9),
  90         MAX1363_MODE_SINGLE(10, 1 << 10),
  91         MAX1363_MODE_SINGLE(11, 1 << 11),
  92
  93         MAX1363_MODE_DIFF_SINGLE(0, 1, 1 << 12),
  94         MAX1363_MODE_DIFF_SINGLE(2, 3, 1 << 13),
  95         MAX1363_MODE_DIFF_SINGLE(4, 5, 1 << 14),
  96         MAX1363_MODE_DIFF_SINGLE(6, 7, 1 << 15),
  97         MAX1363_MODE_DIFF_SINGLE(8, 9, 1 << 16),
  98         MAX1363_MODE_DIFF_SINGLE(10, 11, 1 << 17),
  99         MAX1363_MODE_DIFF_SINGLE(1, 0, 1 << 18),
 100         MAX1363_MODE_DIFF_SINGLE(3, 2, 1 << 19),
 101         MAX1363_MODE_DIFF_SINGLE(5, 4, 1 << 20),
 102         MAX1363_MODE_DIFF_SINGLE(7, 6, 1 << 21),
 103         MAX1363_MODE_DIFF_SINGLE(9, 8, 1 << 22),
 104         MAX1363_MODE_DIFF_SINGLE(11, 10, 1 << 23),
 105
 106         /* The multichannel scans next */
 107         MAX1363_MODE_SCAN_TO_CHANNEL(1, 0x003),
 108         MAX1363_MODE_SCAN_TO_CHANNEL(2, 0x007),
 109         MAX1236_MODE_SCAN_MID_TO_CHANNEL(2, 3, 0x00C),
 110         MAX1363_MODE_SCAN_TO_CHANNEL(3, 0x00F),
 111         MAX1363_MODE_SCAN_TO_CHANNEL(4, 0x01F),
 112         MAX1363_MODE_SCAN_TO_CHANNEL(5, 0x03F),
 113         MAX1363_MODE_SCAN_TO_CHANNEL(6, 0x07F),
 114         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 7, 0x0C0),
 115         MAX1363_MODE_SCAN_TO_CHANNEL(7, 0x0FF),
 116         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 8, 0x1C0),
 117         MAX1363_MODE_SCAN_TO_CHANNEL(8, 0x1FF),
 118         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 9, 0x3C0),
 119         MAX1363_MODE_SCAN_TO_CHANNEL(9, 0x3FF),
 120         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 10, 0x7C0),
 121         MAX1363_MODE_SCAN_TO_CHANNEL(10, 0x7FF),
 122         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 11, 0xFC0),
 123         MAX1363_MODE_SCAN_TO_CHANNEL(11, 0xFFF),
 124
 125         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(2, 2, 0x003000),
 126         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(4, 3, 0x007000),
 127         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(6, 4, 0x00F000),
 128         MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(8, 2, 0x018000),
 129         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(8, 5, 0x01F000),
 130         MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(10, 3, 0x038000),
 131         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(10, 6, 0x3F000),
 132         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(3, 2, 0x0C0000),
 133         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(5, 3, 0x1C0000),
 134         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(7, 4, 0x3C0000),
 135         MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(9, 2, 0x600000),
 136         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(9, 5, 0x7C0000),
 137         MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(11, 3, 0xE00000),
 138         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(11, 6, 0xFC0000),
 139 };
 140
 141 const struct max1363_mode
 142 *max1363_match_mode(u32 mask, const struct max1363_chip_info *ci)
 143 {
 144         int i;
 145         if (mask)
 146                 for (i = 0; i < ci->num_modes; i++)
 147                         if (!((~max1363_mode_table[ci->mode_list[i]].modemask) &
 148                               mask))
 149                                 return &max1363_mode_table[ci->mode_list[i]];
 150         return NULL;
 151 };
 152
 153 static ssize_t max1363_show_precision(struct device *dev,
 154                                 struct device_attribute *attr,
 155                                 char *buf)
 156 {
 157         struct iio_dev *dev_info = dev_get_drvdata(dev);
 158         struct max1363_state *st = iio_dev_get_devdata(dev_info);
 159         return sprintf(buf, "%d\n", st->chip_info->bits);
 160 }
 161
 162 static IIO_DEVICE_ATTR(in_precision, S_IRUGO, max1363_show_precision,
 163                        NULL, 0);
 164
 165 static int max1363_write_basic_config(struct i2c_client *client,
 166                                       unsigned char d1,
 167                                       unsigned char d2)
 168 {
 169         int ret;
 170         u8 *tx_buf = kmalloc(2 , GFP_KERNEL);
 171
 172         if (!tx_buf)
 173                 return -ENOMEM;
 174         tx_buf[0] = d1;
 175         tx_buf[1] = d2;
 176
 177         ret = i2c_master_send(client, tx_buf, 2);
 178         kfree(tx_buf);
 179
 180         return (ret > 0) ? 0 : ret;
 181 }
 182
 183 int max1363_set_scan_mode(struct max1363_state *st)
 184 {
 185         st->configbyte &= ~(MAX1363_CHANNEL_SEL_MASK
 186                             | MAX1363_SCAN_MASK
 187                             | MAX1363_SE_DE_MASK);
 188         st->configbyte |= st->current_mode->conf;
 189
 190         return max1363_write_basic_config(st->client,
 191                                           st->setupbyte,
 192                                           st->configbyte);
 193 }
 194
 195 static ssize_t max1363_read_single_channel(struct device *dev,
 196                                    struct device_attribute *attr,
 197                                    char *buf)
 198 {
 199         struct iio_dev *dev_info = dev_get_drvdata(dev);
 200         struct max1363_state *st = iio_dev_get_devdata(dev_info);
 201         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 202         struct i2c_client *client = st->client;
 203         int ret = 0, len = 0;
 204         s32 data ;
 205         char rxbuf[2];
 206         long mask;
 207
 208         mutex_lock(&dev_info->mlock);
 209         /* If ring buffer capture is occuring, query the buffer */
 210         if (iio_ring_enabled(dev_info)) {
 211                 mask = max1363_mode_table[this_attr->address].modemask;
 212                 data = max1363_single_channel_from_ring(mask, st);
 213                 if (data < 0) {
 214                         ret = data;
 215                         goto error_ret;
 216                 }
 217         } else {
 218                 /* Check to see if current scan mode is correct */
 219                 if (st->current_mode !=
 220                     &max1363_mode_table[this_attr->address]) {
 221                         /* Update scan mode if needed */
 222                         st->current_mode
 223                                 = &max1363_mode_table[this_attr->address];
 224                         ret = max1363_set_scan_mode(st);
 225                         if (ret)
 226                                 goto error_ret;
 227                 }
 228                 if (st->chip_info->bits != 8) {
 229                         /* Get reading */
 230                         data = i2c_master_recv(client, rxbuf, 2);
 231                         if (data < 0) {
 232                                 ret = data;
 233                                 goto error_ret;
 234                         }
 235
 236                         data = (s32)(rxbuf[1]) | ((s32)(rxbuf[0] & 0x0F)) << 8;
 237                 } else {
 238                         /* Get reading */
 239                         data = i2c_master_recv(client, rxbuf, 1);
 240                         if (data < 0) {
 241                                 ret = data;
 242                                 goto error_ret;
 243                         }
 244                         data = rxbuf[0];
 245                 }
 246         }
 247         /* Pretty print the result */
 248         len = sprintf(buf, "%u\n", data);
 249
 250 error_ret:
 251         mutex_unlock(&dev_info->mlock);
 252         return ret ? ret : len;
 253 }
 254
 255 /* Direct read attribtues */
 256 static IIO_DEV_ATTR_IN_RAW(0, max1363_read_single_channel, _s0);
 257 static IIO_DEV_ATTR_IN_RAW(1, max1363_read_single_channel, _s1);
 258 static IIO_DEV_ATTR_IN_RAW(2, max1363_read_single_channel, _s2);
 259 static IIO_DEV_ATTR_IN_RAW(3, max1363_read_single_channel, _s3);
 260 static IIO_DEV_ATTR_IN_RAW(4, max1363_read_single_channel, _s4);
 261 static IIO_DEV_ATTR_IN_RAW(5, max1363_read_single_channel, _s5);
 262 static IIO_DEV_ATTR_IN_RAW(6, max1363_read_single_channel, _s6);
 263 static IIO_DEV_ATTR_IN_RAW(7, max1363_read_single_channel, _s7);
 264 static IIO_DEV_ATTR_IN_RAW(8, max1363_read_single_channel, _s8);
 265 static IIO_DEV_ATTR_IN_RAW(9, max1363_read_single_channel, _s9);
 266 static IIO_DEV_ATTR_IN_RAW(10, max1363_read_single_channel, _s10);
 267 static IIO_DEV_ATTR_IN_RAW(11, max1363_read_single_channel, _s11);
 268
 269 static IIO_DEV_ATTR_IN_DIFF_RAW(0, 1, max1363_read_single_channel, d0m1);
 270 static IIO_DEV_ATTR_IN_DIFF_RAW(2, 3, max1363_read_single_channel, d2m3);
 271 static IIO_DEV_ATTR_IN_DIFF_RAW(4, 5, max1363_read_single_channel, d4m5);
 272 static IIO_DEV_ATTR_IN_DIFF_RAW(6, 7, max1363_read_single_channel, d6m7);
 273 static IIO_DEV_ATTR_IN_DIFF_RAW(8, 9, max1363_read_single_channel, d8m9);
 274 static IIO_DEV_ATTR_IN_DIFF_RAW(10, 11, max1363_read_single_channel, d10m11);
 275 static IIO_DEV_ATTR_IN_DIFF_RAW(1, 0, max1363_read_single_channel, d1m0);
 276 static IIO_DEV_ATTR_IN_DIFF_RAW(3, 2, max1363_read_single_channel, d3m2);
 277 static IIO_DEV_ATTR_IN_DIFF_RAW(5, 4, max1363_read_single_channel, d5m4);
 278 static IIO_DEV_ATTR_IN_DIFF_RAW(7, 6, max1363_read_single_channel, d7m6);
 279 static IIO_DEV_ATTR_IN_DIFF_RAW(9, 8, max1363_read_single_channel, d9m8);
 280 static IIO_DEV_ATTR_IN_DIFF_RAW(11, 10, max1363_read_single_channel, d11m10);
 281
 282
 283 static ssize_t max1363_show_scale(struct device *dev,
 284                                 struct device_attribute *attr,
 285                                 char *buf)
 286 {
 287         /* Driver currently only support internal vref */
 288         struct iio_dev *dev_info = dev_get_drvdata(dev);
 289         struct max1363_state *st = iio_dev_get_devdata(dev_info);
 290         /* Corresponds to Vref / 2^(bits) */
 291
 292         if ((1 << (st->chip_info->bits + 1))
 293             > st->chip_info->int_vref_mv)
 294                 return sprintf(buf, "0.5\n");
 295         else
 296                 return sprintf(buf, "%d\n",
 297                         st->chip_info->int_vref_mv >> st->chip_info->bits);
 298 }
 299
 300 static IIO_DEVICE_ATTR(in_scale, S_IRUGO, max1363_show_scale, NULL, 0);
 301
 302 static ssize_t max1363_show_name(struct device *dev,
 303                                  struct device_attribute *attr,
 304                                  char *buf)
 305 {
 306         struct iio_dev *dev_info = dev_get_drvdata(dev);
 307         struct max1363_state *st = iio_dev_get_devdata(dev_info);
 308         return sprintf(buf, "%s\n", st->chip_info->name);
 309 }
 310
 311 static IIO_DEVICE_ATTR(name, S_IRUGO, max1363_show_name, NULL, 0);
 312
 313 /* Applies to max1363 */
 314 static const enum max1363_modes max1363_mode_list[] = {
 315         _s0, _s1, _s2, _s3,
 316         s0to1, s0to2, s0to3,
 317         d0m1, d2m3, d1m0, d3m2,
 318         d0m1to2m3, d1m0to3m2,
 319 };
 320
 321 static struct attribute *max1363_device_attrs[] = {
 322         &iio_dev_attr_in0_raw.dev_attr.attr,
 323         &iio_dev_attr_in1_raw.dev_attr.attr,
 324         &iio_dev_attr_in2_raw.dev_attr.attr,
 325         &iio_dev_attr_in3_raw.dev_attr.attr,
 326         &iio_dev_attr_in0min1_raw.dev_attr.attr,
 327         &iio_dev_attr_in2min3_raw.dev_attr.attr,
 328         &iio_dev_attr_in1min0_raw.dev_attr.attr,
 329         &iio_dev_attr_in3min2_raw.dev_attr.attr,
 330         &iio_dev_attr_name.dev_attr.attr,
 331         &iio_dev_attr_in_scale.dev_attr.attr,
 332         NULL
 333 };
 334
 335 static struct attribute_group max1363_dev_attr_group = {
 336         .attrs = max1363_device_attrs,
 337 };
 338
 339 static struct attribute *max1363_scan_el_attrs[] = {
 340         &iio_scan_el_in0.dev_attr.attr,
 341         &iio_scan_el_in1.dev_attr.attr,
 342         &iio_scan_el_in2.dev_attr.attr,
 343         &iio_scan_el_in3.dev_attr.attr,
 344         &iio_scan_el_in0min1.dev_attr.attr,
 345         &iio_scan_el_in2min3.dev_attr.attr,
 346         &iio_scan_el_in1min0.dev_attr.attr,
 347         &iio_scan_el_in3min2.dev_attr.attr,
 348         &iio_dev_attr_in_precision.dev_attr.attr,
 349         NULL,
 350 };
 351
 352 static struct attribute_group max1363_scan_el_group = {
 353         .name = "scan_elements",
 354         .attrs = max1363_scan_el_attrs,
 355 };
 356
 357 /* Appies to max1236, max1237 */
 358 static const enum max1363_modes max1236_mode_list[] = {
 359         _s0, _s1, _s2, _s3,
 360         s0to1, s0to2, s0to3,
 361         d0m1, d2m3, d1m0, d3m2,
 362         d0m1to2m3, d1m0to3m2,
 363         s2to3,
 364 };
 365
 366 /* Applies to max1238, max1239 */
 367 static const enum max1363_modes max1238_mode_list[] = {
 368         _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7, _s8, _s9, _s10, _s11,
 369         s0to1, s0to2, s0to3, s0to4, s0to5, s0to6,
 370         s0to7, s0to8, s0to9, s0to10, s0to11,
 371         d0m1, d2m3, d4m5, d6m7, d8m9, d10m11,
 372         d1m0, d3m2, d5m4, d7m6, d9m8, d11m10,
 373         d0m1to2m3, d0m1to4m5, d0m1to6m7, d0m1to8m9, d0m1to10m11,
 374         d1m0to3m2, d1m0to5m4, d1m0to7m6, d1m0to9m8, d1m0to11m10,
 375         s6to7, s6to8, s6to9, s6to10, s6to11,
 376         d6m7to8m9, d6m7to10m11, d7m6to9m8, d7m6to11m10,
 377 };
 378
 379 static struct attribute *max1238_device_attrs[] = {
 380         &iio_dev_attr_in0_raw.dev_attr.attr,
 381         &iio_dev_attr_in1_raw.dev_attr.attr,
 382         &iio_dev_attr_in2_raw.dev_attr.attr,
 383         &iio_dev_attr_in3_raw.dev_attr.attr,
 384         &iio_dev_attr_in4_raw.dev_attr.attr,
 385         &iio_dev_attr_in5_raw.dev_attr.attr,
 386         &iio_dev_attr_in6_raw.dev_attr.attr,
 387         &iio_dev_attr_in7_raw.dev_attr.attr,
 388         &iio_dev_attr_in8_raw.dev_attr.attr,
 389         &iio_dev_attr_in9_raw.dev_attr.attr,
 390         &iio_dev_attr_in10_raw.dev_attr.attr,
 391         &iio_dev_attr_in11_raw.dev_attr.attr,
 392         &iio_dev_attr_in0min1_raw.dev_attr.attr,
 393         &iio_dev_attr_in2min3_raw.dev_attr.attr,
 394         &iio_dev_attr_in4min5_raw.dev_attr.attr,
 395         &iio_dev_attr_in6min7_raw.dev_attr.attr,
 396         &iio_dev_attr_in8min9_raw.dev_attr.attr,
 397         &iio_dev_attr_in10min11_raw.dev_attr.attr,
 398         &iio_dev_attr_in1min0_raw.dev_attr.attr,
 399         &iio_dev_attr_in3min2_raw.dev_attr.attr,
 400         &iio_dev_attr_in5min4_raw.dev_attr.attr,
 401         &iio_dev_attr_in7min6_raw.dev_attr.attr,
 402         &iio_dev_attr_in9min8_raw.dev_attr.attr,
 403         &iio_dev_attr_in11min10_raw.dev_attr.attr,
 404         &iio_dev_attr_name.dev_attr.attr,
 405         &iio_dev_attr_in_scale.dev_attr.attr,
 406         NULL
 407 };
 408
 409 static struct attribute_group max1238_dev_attr_group = {
 410         .attrs = max1238_device_attrs,
 411 };
 412
 413 static struct attribute *max1238_scan_el_attrs[] = {
 414         &iio_scan_el_in0.dev_attr.attr,
 415         &iio_scan_el_in1.dev_attr.attr,
 416         &iio_scan_el_in2.dev_attr.attr,
 417         &iio_scan_el_in3.dev_attr.attr,
 418         &iio_scan_el_in4.dev_attr.attr,
 419         &iio_scan_el_in5.dev_attr.attr,
 420         &iio_scan_el_in6.dev_attr.attr,
 421         &iio_scan_el_in7.dev_attr.attr,
 422         &iio_scan_el_in8.dev_attr.attr,
 423         &iio_scan_el_in9.dev_attr.attr,
 424         &iio_scan_el_in10.dev_attr.attr,
 425         &iio_scan_el_in11.dev_attr.attr,
 426         &iio_scan_el_in0min1.dev_attr.attr,
 427         &iio_scan_el_in2min3.dev_attr.attr,
 428         &iio_scan_el_in4min5.dev_attr.attr,
 429         &iio_scan_el_in6min7.dev_attr.attr,
 430         &iio_scan_el_in8min9.dev_attr.attr,
 431         &iio_scan_el_in10min11.dev_attr.attr,
 432         &iio_scan_el_in1min0.dev_attr.attr,
 433         &iio_scan_el_in3min2.dev_attr.attr,
 434         &iio_scan_el_in5min4.dev_attr.attr,
 435         &iio_scan_el_in7min6.dev_attr.attr,
 436         &iio_scan_el_in9min8.dev_attr.attr,
 437         &iio_scan_el_in11min10.dev_attr.attr,
 438         &iio_dev_attr_in_precision.dev_attr.attr,
 439         NULL,
 440 };
 441
 442 static struct attribute_group max1238_scan_el_group = {
 443         .name = "scan_elements",
 444         .attrs = max1238_scan_el_attrs,
 445 };
 446
 447
 448 static const enum max1363_modes max11607_mode_list[] = {
 449         _s0, _s1, _s2, _s3,
 450         s0to1, s0to2, s0to3,
 451         s2to3,
 452         d0m1, d2m3, d1m0, d3m2,
 453         d0m1to2m3, d1m0to3m2,
 454 };
 455
 456 static const enum max1363_modes max11608_mode_list[] = {
 457         _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7,
 458         s0to1, s0to2, s0to3, s0to4, s0to5, s0to6, s0to7,
 459         s6to7,
 460         d0m1, d2m3, d4m5, d6m7,
 461         d1m0, d3m2, d5m4, d7m6,
 462         d0m1to2m3, d0m1to4m5, d0m1to6m7,
 463         d1m0to3m2, d1m0to5m4, d1m0to7m6,
 464 };
 465
 466 static struct attribute *max11608_device_attrs[] = {
 467         &iio_dev_attr_in0_raw.dev_attr.attr,
 468         &iio_dev_attr_in1_raw.dev_attr.attr,
 469         &iio_dev_attr_in2_raw.dev_attr.attr,
 470         &iio_dev_attr_in3_raw.dev_attr.attr,
 471         &iio_dev_attr_in4_raw.dev_attr.attr,
 472         &iio_dev_attr_in5_raw.dev_attr.attr,
 473         &iio_dev_attr_in6_raw.dev_attr.attr,
 474         &iio_dev_attr_in7_raw.dev_attr.attr,
 475         &iio_dev_attr_in0min1_raw.dev_attr.attr,
 476         &iio_dev_attr_in2min3_raw.dev_attr.attr,
 477         &iio_dev_attr_in4min5_raw.dev_attr.attr,
 478         &iio_dev_attr_in6min7_raw.dev_attr.attr,
 479         &iio_dev_attr_in1min0_raw.dev_attr.attr,
 480         &iio_dev_attr_in3min2_raw.dev_attr.attr,
 481         &iio_dev_attr_in5min4_raw.dev_attr.attr,
 482         &iio_dev_attr_in7min6_raw.dev_attr.attr,
 483         &iio_dev_attr_name.dev_attr.attr,
 484         &iio_dev_attr_in_scale.dev_attr.attr,
 485         NULL
 486 };
 487
 488 static struct attribute_group max11608_dev_attr_group = {
 489         .attrs = max11608_device_attrs,
 490 };
 491
 492 static struct attribute *max11608_scan_el_attrs[] = {
 493         &iio_scan_el_in0.dev_attr.attr,
 494         &iio_scan_el_in1.dev_attr.attr,
 495         &iio_scan_el_in2.dev_attr.attr,
 496         &iio_scan_el_in3.dev_attr.attr,
 497         &iio_scan_el_in4.dev_attr.attr,
 498         &iio_scan_el_in5.dev_attr.attr,
 499         &iio_scan_el_in6.dev_attr.attr,
 500         &iio_scan_el_in7.dev_attr.attr,
 501         &iio_scan_el_in0min1.dev_attr.attr,
 502         &iio_scan_el_in2min3.dev_attr.attr,
 503         &iio_scan_el_in4min5.dev_attr.attr,
 504         &iio_scan_el_in6min7.dev_attr.attr,
 505         &iio_scan_el_in1min0.dev_attr.attr,
 506         &iio_scan_el_in3min2.dev_attr.attr,
 507         &iio_scan_el_in5min4.dev_attr.attr,
 508         &iio_scan_el_in7min6.dev_attr.attr,
 509         &iio_dev_attr_in_precision.dev_attr.attr,
 510 };
 511
 512 static struct attribute_group max11608_scan_el_group = {
 513         .name = "scan_elements",
 514         .attrs = max11608_scan_el_attrs,
 515 };
 516
 517 enum { max1361,
 518        max1362,
 519        max1363,
 520        max1364,
 521        max1036,
 522        max1037,
 523        max1038,
 524        max1039,
 525        max1136,
 526        max1137,
 527        max1138,
 528        max1139,
 529        max1236,
 530        max1237,
 531        max1238,
 532        max1239,
 533        max11600,
 534        max11601,
 535        max11602,
 536        max11603,
 537        max11604,
 538        max11605,
 539        max11606,
 540        max11607,
 541        max11608,
 542        max11609,
 543        max11610,
 544        max11611,
 545        max11612,
 546        max11613,
 547        max11614,
 548        max11615,
 549        max11616,
 550        max11617,
 551 };
 552
 553 /* max1363 and max1368 tested - rest from data sheet */
 554 static const struct max1363_chip_info max1363_chip_info_tbl[] = {
 555         {
 556                 .name = "max1361",
 557                 .num_inputs = 4,
 558                 .bits = 10,
 559                 .int_vref_mv = 2048,
 560                 .monitor_mode = 1,
 561                 .mode_list = max1363_mode_list,
 562                 .num_modes = ARRAY_SIZE(max1363_mode_list),
 563                 .default_mode = s0to3,
 564                 .dev_attrs = &max1363_dev_attr_group,
 565                 .scan_attrs = &max1363_scan_el_group,
 566         }, {
 567                 .name = "max1362",
 568                 .num_inputs = 4,
 569                 .bits = 10,
 570                 .int_vref_mv = 4096,
 571                 .monitor_mode = 1,
 572                 .mode_list = max1363_mode_list,
 573                 .num_modes = ARRAY_SIZE(max1363_mode_list),
 574                 .default_mode = s0to3,
 575                 .dev_attrs = &max1363_dev_attr_group,
 576                 .scan_attrs = &max1363_scan_el_group,
 577         }, {
 578                 .name = "max1363",
 579                 .num_inputs = 4,
 580                 .bits = 12,
 581                 .int_vref_mv = 2048,
 582                 .monitor_mode = 1,
 583                 .mode_list = max1363_mode_list,
 584                 .num_modes = ARRAY_SIZE(max1363_mode_list),
 585                 .default_mode = s0to3,
 586                 .dev_attrs = &max1363_dev_attr_group,
 587                 .scan_attrs = &max1363_scan_el_group,
 588         }, {
 589                 .name = "max1364",
 590                 .num_inputs = 4,
 591                 .bits = 12,
 592                 .int_vref_mv = 4096,
 593                 .monitor_mode = 1,
 594                 .mode_list = max1363_mode_list,
 595                 .num_modes = ARRAY_SIZE(max1363_mode_list),
 596                 .default_mode = s0to3,
 597                 .dev_attrs = &max1363_dev_attr_group,
 598                 .scan_attrs = &max1363_scan_el_group,
 599         }, {
 600                 .name = "max1036",
 601                 .num_inputs = 4,
 602                 .bits = 8,
 603                 .int_vref_mv = 4096,
 604                 .mode_list = max1236_mode_list,
 605                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 606                 .default_mode = s0to3,
 607                 .dev_attrs = &max1363_dev_attr_group,
 608                 .scan_attrs = &max1363_scan_el_group,
 609         }, {
 610                 .name = "max1037",
 611                 .num_inputs = 4,
 612                 .bits = 8,
 613                 .int_vref_mv = 2048,
 614                 .mode_list = max1236_mode_list,
 615                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 616                 .default_mode = s0to3,
 617                 .dev_attrs = &max1363_dev_attr_group,
 618                 .scan_attrs = &max1363_scan_el_group,
 619         }, {
 620                 .name = "max1038",
 621                 .num_inputs = 12,
 622                 .bits = 8,
 623                 .int_vref_mv = 4096,
 624                 .mode_list = max1238_mode_list,
 625                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 626                 .default_mode = s0to11,
 627                 .dev_attrs = &max1238_dev_attr_group,
 628                 .scan_attrs = &max1238_scan_el_group,
 629         }, {
 630                 .name = "max1039",
 631                 .num_inputs = 12,
 632                 .bits = 8,
 633                 .int_vref_mv = 2048,
 634                 .mode_list = max1238_mode_list,
 635                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 636                 .default_mode = s0to11,
 637                 .dev_attrs = &max1238_dev_attr_group,
 638                 .scan_attrs = &max1238_scan_el_group,
 639         }, {
 640                 .name = "max1136",
 641                 .num_inputs = 4,
 642                 .bits = 10,
 643                 .int_vref_mv = 4096,
 644                 .mode_list = max1236_mode_list,
 645                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 646                 .default_mode = s0to3,
 647                 .dev_attrs = &max1363_dev_attr_group,
 648                 .scan_attrs = &max1363_scan_el_group,
 649         }, {
 650                 .name = "max1137",
 651                 .num_inputs = 4,
 652                 .bits = 10,
 653                 .int_vref_mv = 2048,
 654                 .mode_list = max1236_mode_list,
 655                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 656                 .default_mode = s0to3,
 657                 .dev_attrs = &max1363_dev_attr_group,
 658                 .scan_attrs = &max1363_scan_el_group,
 659         }, {
 660                 .name = "max1138",
 661                 .num_inputs = 12,
 662                 .bits = 10,
 663                 .int_vref_mv = 4096,
 664                 .mode_list = max1238_mode_list,
 665                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 666                 .default_mode = s0to11,
 667                 .dev_attrs = &max1238_dev_attr_group,
 668                 .scan_attrs = &max1238_scan_el_group,
 669         }, {
 670                 .name = "max1139",
 671                 .num_inputs = 12,
 672                 .bits = 10,
 673                 .int_vref_mv = 2048,
 674                 .mode_list = max1238_mode_list,
 675                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 676                 .default_mode = s0to11,
 677                 .dev_attrs = &max1238_dev_attr_group,
 678                 .scan_attrs = &max1238_scan_el_group,
 679         }, {
 680                 .name = "max1236",
 681                 .num_inputs = 4,
 682                 .bits = 12,
 683                 .int_vref_mv = 4096,
 684                 .mode_list = max1236_mode_list,
 685                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 686                 .default_mode = s0to3,
 687                 .dev_attrs = &max1363_dev_attr_group,
 688                 .scan_attrs = &max1363_scan_el_group,
 689         }, {
 690                 .name = "max1237",
 691                 .num_inputs = 4,
 692                 .bits = 12,
 693                 .int_vref_mv = 2048,
 694                 .mode_list = max1236_mode_list,
 695                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 696                 .default_mode = s0to3,
 697                 .dev_attrs = &max1363_dev_attr_group,
 698                 .scan_attrs = &max1363_scan_el_group,
 699         }, {
 700                 .name = "max1238",
 701                 .num_inputs = 12,
 702                 .bits = 12,
 703                 .int_vref_mv = 4096,
 704                 .mode_list = max1238_mode_list,
 705                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 706                 .default_mode = s0to11,
 707                 .dev_attrs = &max1238_dev_attr_group,
 708                 .scan_attrs = &max1238_scan_el_group,
 709         }, {
 710                 .name = "max1239",
 711                 .num_inputs = 12,
 712                 .bits = 12,
 713                 .int_vref_mv = 2048,
 714                 .mode_list = max1238_mode_list,
 715                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 716                 .default_mode = s0to11,
 717                 .dev_attrs = &max1238_dev_attr_group,
 718                 .scan_attrs = &max1238_scan_el_group,
 719         }, {
 720                 .name = "max11600",
 721                 .num_inputs = 4,
 722                 .bits = 8,
 723                 .int_vref_mv = 4096,
 724                 .mode_list = max11607_mode_list,
 725                 .num_modes = ARRAY_SIZE(max11607_mode_list),
 726                 .default_mode = s0to3,
 727                 .dev_attrs = &max1363_dev_attr_group,
 728                 .scan_attrs = &max1363_scan_el_group,
 729         }, {
 730                 .name = "max11601",
 731                 .num_inputs = 4,
 732                 .bits = 8,
 733                 .int_vref_mv = 2048,
 734                 .mode_list = max11607_mode_list,
 735                 .num_modes = ARRAY_SIZE(max11607_mode_list),
 736                 .default_mode = s0to3,
 737                 .dev_attrs = &max1363_dev_attr_group,
 738                 .scan_attrs = &max1363_scan_el_group,
 739         }, {
 740                 .name = "max11602",
 741                 .num_inputs = 8,
 742                 .bits = 8,
 743                 .int_vref_mv = 4096,
 744                 .mode_list = max11608_mode_list,
 745                 .num_modes = ARRAY_SIZE(max11608_mode_list),
 746                 .default_mode = s0to7,
 747                 .dev_attrs = &max11608_dev_attr_group,
 748                 .scan_attrs = &max11608_scan_el_group,
 749         }, {
 750                 .name = "max11603",
 751                 .num_inputs = 8,
 752                 .bits = 8,
 753                 .int_vref_mv = 2048,
 754                 .mode_list = max11608_mode_list,
 755                 .num_modes = ARRAY_SIZE(max11608_mode_list),
 756                 .default_mode = s0to7,
 757                 .dev_attrs = &max11608_dev_attr_group,
 758                 .scan_attrs = &max11608_scan_el_group,
 759         }, {
 760                 .name = "max11604",
 761                 .num_inputs = 12,
 762                 .bits = 8,
 763                 .int_vref_mv = 4098,
 764                 .mode_list = max1238_mode_list,
 765                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 766                 .default_mode = s0to11,
 767                 .dev_attrs = &max1238_dev_attr_group,
 768                 .scan_attrs = &max1238_scan_el_group,
 769         }, {
 770                 .name = "max11605",
 771                 .num_inputs = 12,
 772                 .bits = 8,
 773                 .int_vref_mv = 2048,
 774                 .mode_list = max1238_mode_list,
 775                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 776                 .default_mode = s0to11,
 777                 .dev_attrs = &max1238_dev_attr_group,
 778                 .scan_attrs = &max1238_scan_el_group,
 779         }, {
 780                 .name = "max11606",
 781                 .num_inputs = 4,
 782                 .bits = 10,
 783                 .int_vref_mv = 4096,
 784                 .mode_list = max11607_mode_list,
 785                 .num_modes = ARRAY_SIZE(max11607_mode_list),
 786                 .default_mode = s0to3,
 787                 .dev_attrs = &max1363_dev_attr_group,
 788                 .scan_attrs = &max1363_scan_el_group,
 789         }, {
 790                 .name = "max11607",
 791                 .num_inputs = 4,
 792                 .bits = 10,
 793                 .int_vref_mv = 2048,
 794                 .mode_list = max11607_mode_list,
 795                 .num_modes = ARRAY_SIZE(max11607_mode_list),
 796                 .default_mode = s0to3,
 797                 .dev_attrs = &max1363_dev_attr_group,
 798                 .scan_attrs = &max1363_scan_el_group,
 799         }, {
 800                 .name = "max11608",
 801                 .num_inputs = 8,
 802                 .bits = 10,
 803                 .int_vref_mv = 4096,
 804                 .mode_list = max11608_mode_list,
 805                 .num_modes = ARRAY_SIZE(max11608_mode_list),
 806                 .default_mode = s0to7,
 807                 .dev_attrs = &max11608_dev_attr_group,
 808                 .scan_attrs = &max11608_scan_el_group,
 809         }, {
 810                 .name = "max11609",
 811                 .num_inputs = 8,
 812                 .bits = 10,
 813                 .int_vref_mv = 2048,
 814                 .mode_list = max11608_mode_list,
 815                 .num_modes = ARRAY_SIZE(max11608_mode_list),
 816                 .default_mode = s0to7,
 817                 .dev_attrs = &max11608_dev_attr_group,
 818                 .scan_attrs = &max11608_scan_el_group,
 819         }, {
 820                 .name = "max11610",
 821                 .num_inputs = 12,
 822                 .bits = 10,
 823                 .int_vref_mv = 4098,
 824                 .mode_list = max1238_mode_list,
 825                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 826                 .default_mode = s0to11,
 827                 .dev_attrs = &max1238_dev_attr_group,
 828                 .scan_attrs = &max1238_scan_el_group,
 829         }, {
 830                 .name = "max11611",
 831                 .num_inputs = 12,
 832                 .bits = 10,
 833                 .int_vref_mv = 2048,
 834                 .mode_list = max1238_mode_list,
 835                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 836                 .default_mode = s0to11,
 837                 .dev_attrs = &max1238_dev_attr_group,
 838                 .scan_attrs = &max1238_scan_el_group,
 839         }, {
 840                 .name = "max11612",
 841                 .num_inputs = 4,
 842                 .bits = 12,
 843                 .int_vref_mv = 4096,
 844                 .mode_list = max11607_mode_list,
 845                 .num_modes = ARRAY_SIZE(max11607_mode_list),
 846                 .default_mode = s0to3,
 847                 .dev_attrs = &max1363_dev_attr_group,
 848                 .scan_attrs = &max1363_scan_el_group,
 849         }, {
 850                 .name = "max11613",
 851                 .num_inputs = 4,
 852                 .bits = 12,
 853                 .int_vref_mv = 2048,
 854                 .mode_list = max11607_mode_list,
 855                 .num_modes = ARRAY_SIZE(max11607_mode_list),
 856                 .default_mode = s0to3,
 857                 .dev_attrs = &max1363_dev_attr_group,
 858                 .scan_attrs = &max1363_scan_el_group,
 859         }, {
 860                 .name = "max11614",
 861                 .num_inputs = 8,
 862                 .bits = 12,
 863                 .int_vref_mv = 4096,
 864                 .mode_list = max11608_mode_list,
 865                 .num_modes = ARRAY_SIZE(max11608_mode_list),
 866                 .default_mode = s0to7,
 867                 .dev_attrs = &max11608_dev_attr_group,
 868                 .scan_attrs = &max11608_scan_el_group,
 869         }, {
 870                 .name = "max11615",
 871                 .num_inputs = 8,
 872                 .bits = 12,
 873                 .int_vref_mv = 2048,
 874                 .mode_list = max11608_mode_list,
 875                 .num_modes = ARRAY_SIZE(max11608_mode_list),
 876                 .default_mode = s0to7,
 877                 .dev_attrs = &max11608_dev_attr_group,
 878                 .scan_attrs = &max11608_scan_el_group,
 879         }, {
 880                 .name = "max11616",
 881                 .num_inputs = 12,
 882                 .bits = 12,
 883                 .int_vref_mv = 4098,
 884                 .mode_list = max1238_mode_list,
 885                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 886                 .default_mode = s0to11,
 887                 .dev_attrs = &max1238_dev_attr_group,
 888                 .scan_attrs = &max1238_scan_el_group,
 889         }, {
 890                 .name = "max11617",
 891                 .num_inputs = 12,
 892                 .bits = 12,
 893                 .int_vref_mv = 2048,
 894                 .mode_list = max1238_mode_list,
 895                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 896                 .default_mode = s0to11,
 897                 .dev_attrs = &max1238_dev_attr_group,
 898                 .scan_attrs = &max1238_scan_el_group,
 899         }
 900 };
 901
 902 static int max1363_initial_setup(struct max1363_state *st)
 903 {
 904         st->setupbyte = MAX1363_SETUP_AIN3_IS_AIN3_REF_IS_VDD
 905                 | MAX1363_SETUP_POWER_UP_INT_REF
 906                 | MAX1363_SETUP_INT_CLOCK
 907                 | MAX1363_SETUP_UNIPOLAR
 908                 | MAX1363_SETUP_NORESET;
 909
 910         /* Set scan mode writes the config anyway so wait until then*/
 911         st->setupbyte = MAX1363_SETUP_BYTE(st->setupbyte);
 912         st->current_mode = &max1363_mode_table[st->chip_info->default_mode];
 913         st->configbyte = MAX1363_CONFIG_BYTE(st->configbyte);
 914
 915         return max1363_set_scan_mode(st);
 916 }
 917
 918 static int __devinit max1363_probe(struct i2c_client *client,
 919                                    const struct i2c_device_id *id)
 920 {
 921         int ret, i, regdone = 0;
 922         struct max1363_state *st = kzalloc(sizeof(*st), GFP_KERNEL);
 923         if (st == NULL) {
 924                 ret = -ENOMEM;
 925                 goto error_ret;
 926         }
 927
 928         /* this is only used for device removal purposes */
 929         i2c_set_clientdata(client, st);
 930
 931         atomic_set(&st->protect_ring, 0);
 932
 933         /* Find the chip model specific data */
 934         for (i = 0; i < ARRAY_SIZE(max1363_chip_info_tbl); i++)
 935                 if (!strcmp(max1363_chip_info_tbl[i].name, id->name)) {
 936                         st->chip_info = &max1363_chip_info_tbl[i];
 937                         break;
 938                 };
 939         /* Unsupported chip */
 940         if (!st->chip_info) {
 941                 dev_err(&client->dev, "%s is not supported\n", id->name);
 942                 ret = -ENODEV;
 943                 goto error_free_st;
 944         }
 945
 946         st->reg = regulator_get(&client->dev, "vcc");
 947         if (!IS_ERR(st->reg)) {
 948                 ret = regulator_enable(st->reg);
 949                 if (ret)
 950                         goto error_put_reg;
 951         }
 952         st->client = client;
 953
 954         st->indio_dev = iio_allocate_device();
 955         if (st->indio_dev == NULL) {
 956                 ret = -ENOMEM;
 957                 goto error_disable_reg;
 958         }
 959
 960         st->indio_dev->available_scan_masks
 961                 = kzalloc(sizeof(*st->indio_dev->available_scan_masks)*
 962                           (st->chip_info->num_modes + 1), GFP_KERNEL);
 963         if (!st->indio_dev->available_scan_masks) {
 964                 ret = -ENOMEM;
 965                 goto error_free_device;
 966         }
 967
 968         for (i = 0; i < st->chip_info->num_modes; i++)
 969                 st->indio_dev->available_scan_masks[i] =
 970                         max1363_mode_table[st->chip_info->mode_list[i]]
 971                         .modemask;
 972         /* Estabilish that the iio_dev is a child of the i2c device */
 973         st->indio_dev->dev.parent = &client->dev;
 974         st->indio_dev->attrs = st->chip_info->dev_attrs;
 975
 976         /* Todo: this shouldn't be here. */
 977         st->indio_dev->scan_el_attrs = st->chip_info->scan_attrs;
 978         st->indio_dev->dev_data = (void *)(st);
 979         st->indio_dev->driver_module = THIS_MODULE;
 980         st->indio_dev->modes = INDIO_DIRECT_MODE;
 981
 982         ret = max1363_initial_setup(st);
 983         if (ret)
 984                 goto error_free_available_scan_masks;
 985
 986         ret = max1363_register_ring_funcs_and_init(st->indio_dev);
 987         if (ret)
 988                 goto error_free_available_scan_masks;
 989
 990         ret = iio_device_register(st->indio_dev);
 991         if (ret)
 992                 goto error_cleanup_ring;
 993         regdone = 1;
 994         ret = max1363_initialize_ring(st->indio_dev->ring);
 995         if (ret)
 996                 goto error_cleanup_ring;
 997         return 0;
 998 error_cleanup_ring:
 999         max1363_ring_cleanup(st->indio_dev);
1000 error_free_available_scan_masks:
1001         kfree(st->indio_dev->available_scan_masks);
1002 error_free_device:
1003         if (!regdone)
1004                 iio_free_device(st->indio_dev);
1005         else
1006                 iio_device_unregister(st->indio_dev);
1007 error_disable_reg:
1008         if (!IS_ERR(st->reg))
1009                 regulator_disable(st->reg);
1010 error_put_reg:
1011         if (!IS_ERR(st->reg))
1012                 regulator_put(st->reg);
1013 error_free_st:
1014         i2c_set_clientdata(client, NULL);
1015         kfree(st);
1016
1017 error_ret:
1018         return ret;
1019 }
1020
1021 static int max1363_remove(struct i2c_client *client)
1022 {
1023         struct max1363_state *st = i2c_get_clientdata(client);
1024         struct iio_dev *indio_dev = st->indio_dev;
1025         max1363_uninitialize_ring(indio_dev->ring);
1026         max1363_ring_cleanup(indio_dev);
1027         kfree(st->indio_dev->available_scan_masks);
1028         iio_device_unregister(indio_dev);
1029         if (!IS_ERR(st->reg)) {
1030                 regulator_disable(st->reg);
1031                 regulator_put(st->reg);
1032         }
1033         i2c_set_clientdata(client, NULL);
1034         kfree(st);
1035
1036         return 0;
1037 }
1038
1039 static const struct i2c_device_id max1363_id[] = {
1040         { "max1361", max1361 },
1041         { "max1362", max1362 },
1042         { "max1363", max1363 },
1043         { "max1364", max1364 },
1044         { "max1036", max1036 },
1045         { "max1037", max1037 },
1046         { "max1038", max1038 },
1047         { "max1039", max1039 },
1048         { "max1136", max1136 },
1049         { "max1137", max1137 },
1050         { "max1138", max1138 },
1051         { "max1139", max1139 },
1052         { "max1236", max1236 },
1053         { "max1237", max1237 },
1054         { "max1238", max1238 },
1055         { "max1239", max1239 },
1056         { "max11600", max11600 },
1057         { "max11601", max11601 },
1058         { "max11602", max11602 },
1059         { "max11603", max11603 },
1060         { "max11604", max11604 },
1061         { "max11605", max11605 },
1062         { "max11606", max11606 },
1063         { "max11607", max11607 },
1064         { "max11608", max11608 },
1065         { "max11609", max11609 },
1066         { "max11610", max11610 },
1067         { "max11611", max11611 },
1068         { "max11612", max11612 },
1069         { "max11613", max11613 },
1070         { "max11614", max11614 },
1071         { "max11615", max11615 },
1072         { "max11616", max11616 },
1073         { "max11617", max11617 },
1074         {}
1075 };
1076
1077 MODULE_DEVICE_TABLE(i2c, max1363_id);
1078
1079 static struct i2c_driver max1363_driver = {
1080         .driver = {
1081                 .name = "max1363",
1082         },
1083         .probe = max1363_probe,
1084         .remove = max1363_remove,
1085         .id_table = max1363_id,
1086 };
1087
1088 static __init int max1363_init(void)
1089 {
1090         return i2c_add_driver(&max1363_driver);
1091 }
1092
1093 static __exit void max1363_exit(void)
1094 {
1095         i2c_del_driver(&max1363_driver);
1096 }
1097
1098 MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>");
1099 MODULE_DESCRIPTION("Maxim 1363 ADC");
1100 MODULE_LICENSE("GPL v2");
1101
1102 module_init(max1363_init);
1103 module_exit(max1363_exit);