drivers/staging/iio/adc/max1363_core.c

   1  /*
   2  * linux/drivers/industrialio/adc/max1363.c
   3  * Copyright (C) 2008 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  * - Sysfs scan interface currently assumes unipolar mode.
  24  */
  25
  26 #include <linux/interrupt.h>
  27 #include <linux/gpio.h>
  28 #include <linux/workqueue.h>
  29 #include <linux/device.h>
  30 #include <linux/kernel.h>
  31 #include <linux/sysfs.h>
  32 #include <linux/list.h>
  33 #include <linux/i2c.h>
  34 #include <linux/rtc.h>
  35 #include <linux/regulator/consumer.h>
  36 #include <linux/slab.h>
  37
  38 #include "../iio.h"
  39 #include "../sysfs.h"
  40
  41 #include "max1363.h"
  42
  43 /* Available scan modes.
  44  * Awkwardly the associated enum is in the header so it is available to
  45  * the ring buffer code.
  46  */
  47 static const struct  max1363_mode max1363_mode_table[] = {
  48         MAX1363_MODE_SINGLE(0),
  49         MAX1363_MODE_SINGLE(1),
  50         MAX1363_MODE_SINGLE(2),
  51         MAX1363_MODE_SINGLE(3),
  52         MAX1363_MODE_SINGLE(4),
  53         MAX1363_MODE_SINGLE(5),
  54         MAX1363_MODE_SINGLE(6),
  55         MAX1363_MODE_SINGLE(7),
  56         MAX1363_MODE_SINGLE(8),
  57         MAX1363_MODE_SINGLE(9),
  58         MAX1363_MODE_SINGLE(10),
  59         MAX1363_MODE_SINGLE(11),
  60
  61         MAX1363_MODE_SINGLE_TIMES_8(0),
  62         MAX1363_MODE_SINGLE_TIMES_8(1),
  63         MAX1363_MODE_SINGLE_TIMES_8(2),
  64         MAX1363_MODE_SINGLE_TIMES_8(3),
  65         MAX1363_MODE_SINGLE_TIMES_8(4),
  66         MAX1363_MODE_SINGLE_TIMES_8(5),
  67         MAX1363_MODE_SINGLE_TIMES_8(6),
  68         MAX1363_MODE_SINGLE_TIMES_8(7),
  69         MAX1363_MODE_SINGLE_TIMES_8(8),
  70         MAX1363_MODE_SINGLE_TIMES_8(9),
  71         MAX1363_MODE_SINGLE_TIMES_8(10),
  72         MAX1363_MODE_SINGLE_TIMES_8(11),
  73
  74         MAX1363_MODE_SCAN_TO_CHANNEL(1),
  75         MAX1363_MODE_SCAN_TO_CHANNEL(2),
  76         MAX1363_MODE_SCAN_TO_CHANNEL(3),
  77         MAX1363_MODE_SCAN_TO_CHANNEL(4),
  78         MAX1363_MODE_SCAN_TO_CHANNEL(5),
  79         MAX1363_MODE_SCAN_TO_CHANNEL(6),
  80         MAX1363_MODE_SCAN_TO_CHANNEL(7),
  81         MAX1363_MODE_SCAN_TO_CHANNEL(8),
  82         MAX1363_MODE_SCAN_TO_CHANNEL(9),
  83         MAX1363_MODE_SCAN_TO_CHANNEL(10),
  84         MAX1363_MODE_SCAN_TO_CHANNEL(11),
  85
  86         MAX1363_MODE_DIFF_SINGLE(0, 1),
  87         MAX1363_MODE_DIFF_SINGLE(2, 3),
  88         MAX1363_MODE_DIFF_SINGLE(4, 5),
  89         MAX1363_MODE_DIFF_SINGLE(6, 7),
  90         MAX1363_MODE_DIFF_SINGLE(8, 9),
  91         MAX1363_MODE_DIFF_SINGLE(10, 11),
  92         MAX1363_MODE_DIFF_SINGLE(1, 0),
  93         MAX1363_MODE_DIFF_SINGLE(3, 2),
  94         MAX1363_MODE_DIFF_SINGLE(5, 4),
  95         MAX1363_MODE_DIFF_SINGLE(7, 6),
  96         MAX1363_MODE_DIFF_SINGLE(9, 8),
  97         MAX1363_MODE_DIFF_SINGLE(11, 10),
  98
  99         MAX1363_MODE_DIFF_SINGLE_TIMES_8(0, 1),
 100         MAX1363_MODE_DIFF_SINGLE_TIMES_8(2, 3),
 101         MAX1363_MODE_DIFF_SINGLE_TIMES_8(4, 5),
 102         MAX1363_MODE_DIFF_SINGLE_TIMES_8(6, 7),
 103         MAX1363_MODE_DIFF_SINGLE_TIMES_8(8, 9),
 104         MAX1363_MODE_DIFF_SINGLE_TIMES_8(10, 11),
 105         MAX1363_MODE_DIFF_SINGLE_TIMES_8(1, 0),
 106         MAX1363_MODE_DIFF_SINGLE_TIMES_8(3, 2),
 107         MAX1363_MODE_DIFF_SINGLE_TIMES_8(5, 4),
 108         MAX1363_MODE_DIFF_SINGLE_TIMES_8(7, 6),
 109         MAX1363_MODE_DIFF_SINGLE_TIMES_8(9, 8),
 110         MAX1363_MODE_DIFF_SINGLE_TIMES_8(11, 10),
 111
 112         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(0-1...2-3, 2, 2),
 113         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(0-1...4-5, 4, 3),
 114         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(0-1...6-7, 6, 4),
 115         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(0-1...8-9, 8, 5),
 116         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(0-1...10-11, 10, 6),
 117         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(1-0...3-2, 3, 2),
 118         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(1-0...5-4, 5, 3),
 119         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(1-0...7-6, 7, 4),
 120         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(1-0...9-8, 9, 5),
 121         MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(1-0...11-10, 11, 6),
 122
 123         MAX1236_MODE_SCAN_MID_TO_CHANNEL(2, 3),
 124         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 7),
 125         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 8),
 126         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 9),
 127         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 10),
 128         MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 11),
 129
 130         MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL_NAMED(6-7...8-9, 8, 2),
 131         MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL_NAMED(6-7...10-11, 10, 3),
 132         MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL_NAMED(7-6...9-8, 9, 2),
 133         MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL_NAMED(7-6...11-10, 11, 3),
 134 };
 135
 136 /* Applies to max1363 */
 137 static const enum max1363_modes max1363_mode_list[] = {
 138         _s0, _s1, _s2, _s3,
 139         se0, se1, se2, se3,
 140         s0to1, s0to2, s0to3,
 141         d0m1, d2m3, d1m0, d3m2,
 142         de0m1, de2m3, de1m0, de3m2,
 143         d0m1to2m3, d1m0to3m2,
 144 };
 145
 146 /* Appies to max1236, max1237 */
 147 static const enum max1363_modes max1236_mode_list[] = {
 148         _s0, _s1, _s2, _s3,
 149         se0, se1, se2, se3,
 150         s0to1, s0to2, s0to3,
 151         d0m1, d2m3, d1m0, d3m2,
 152         de0m1, de2m3, de1m0, de3m2,
 153         d0m1to2m3, d1m0to3m2,
 154         s2to3,
 155 };
 156
 157 /* Applies to max1238, max1239 */
 158 static const enum max1363_modes max1238_mode_list[] = {
 159         _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7, _s8, _s9, _s10, _s11,
 160         se0, se1, se2, se3, se4, se5, se6, se7, se8, se9, se10, se11,
 161         s0to1, s0to2, s0to3, s0to4, s0to5, s0to6,
 162         s0to7, s0to8, s0to9, s0to10, s0to11,
 163         d0m1, d2m3, d4m5, d6m7, d8m9, d10m11,
 164         d1m0, d3m2, d5m4, d7m6, d9m8, d11m10,
 165         de0m1, de2m3, de4m5, de6m7, de8m9, de10m11,
 166         de1m0, de3m2, de5m4, de7m6, de9m8, de11m10,
 167         d0m1to2m3, d0m1to4m5, d0m1to6m7, d0m1to8m9, d0m1to10m11,
 168         d1m0to3m2, d1m0to5m4, d1m0to7m6, d1m0to9m8, d1m0to11m10,
 169         s6to7, s6to8, s6to9, s6to10, s6to11,
 170         s6m7to8m9, s6m7to10m11, s7m6to9m8, s7m6to11m10,
 171 };
 172
 173
 174 enum { max1361,
 175        max1362,
 176        max1363,
 177        max1364,
 178        max1136,
 179        max1137,
 180        max1138,
 181        max1139,
 182        max1236,
 183        max1237,
 184        max1238,
 185        max1239,
 186 };
 187
 188 /* max1363 and max1368 tested - rest from data sheet */
 189 static const struct max1363_chip_info max1363_chip_info_tbl[] = {
 190         {
 191                 .name = "max1361",
 192                 .num_inputs = 4,
 193                 .monitor_mode = 1,
 194                 .mode_list = max1363_mode_list,
 195                 .num_modes = ARRAY_SIZE(max1363_mode_list),
 196                 .default_mode = s0to3,
 197         }, {
 198                 .name = "max1362",
 199                 .num_inputs = 4,
 200                 .monitor_mode = 1,
 201                 .mode_list = max1363_mode_list,
 202                 .num_modes = ARRAY_SIZE(max1363_mode_list),
 203                 .default_mode = s0to3,
 204         }, {
 205                 .name = "max1363",
 206                 .num_inputs = 4,
 207                 .monitor_mode = 1,
 208                 .mode_list = max1363_mode_list,
 209                 .num_modes = ARRAY_SIZE(max1363_mode_list),
 210                 .default_mode = s0to3,
 211         }, {
 212                 .name = "max1364",
 213                 .num_inputs = 4,
 214                 .monitor_mode = 1,
 215                 .mode_list = max1363_mode_list,
 216                 .num_modes = ARRAY_SIZE(max1363_mode_list),
 217                 .default_mode = s0to3,
 218         }, {
 219                 .name = "max1136",
 220                 .num_inputs = 4,
 221                 .int_vref_mv = 4096,
 222                 .mode_list = max1236_mode_list,
 223                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 224                 .default_mode = s0to3,
 225         }, {
 226                 .name = "max1137",
 227                 .num_inputs = 4,
 228                 .int_vref_mv = 2048,
 229                 .mode_list = max1236_mode_list,
 230                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 231                 .default_mode = s0to3,
 232         }, {
 233                 .name = "max1138",
 234                 .num_inputs = 12,
 235                 .int_vref_mv = 4096,
 236                 .mode_list = max1238_mode_list,
 237                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 238                 .default_mode = s0to11,
 239         }, {
 240                 .name = "max1139",
 241                 .num_inputs = 12,
 242                 .int_vref_mv = 2048,
 243                 .mode_list = max1238_mode_list,
 244                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 245                 .default_mode = s0to11,
 246         }, {
 247                 .name = "max1236",
 248                 .num_inputs = 4,
 249                 .int_vref_mv = 4096,
 250                 .mode_list = max1236_mode_list,
 251                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 252                 .default_mode = s0to3,
 253         }, {
 254                 .name = "max1237",
 255                 .num_inputs = 4,
 256                 .int_vref_mv = 2048,
 257                 .mode_list = max1236_mode_list,
 258                 .num_modes = ARRAY_SIZE(max1236_mode_list),
 259                 .default_mode = s0to3,
 260         }, {
 261                 .name = "max1238",
 262                 .num_inputs = 12,
 263                 .int_vref_mv = 4096,
 264                 .mode_list = max1238_mode_list,
 265                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 266                 .default_mode = s0to11,
 267         }, {
 268                 .name = "max1239",
 269                 .num_inputs = 12,
 270                 .int_vref_mv = 2048,
 271                 .mode_list = max1238_mode_list,
 272                 .num_modes = ARRAY_SIZE(max1238_mode_list),
 273                 .default_mode = s0to11,
 274         },
 275 };
 276
 277 static int max1363_write_basic_config(struct i2c_client *client,
 278                                       unsigned char d1,
 279                                       unsigned char d2)
 280 {
 281         int ret;
 282         u8 *tx_buf = kmalloc(2 , GFP_KERNEL);
 283         if (!tx_buf)
 284                 return -ENOMEM;
 285         tx_buf[0] = d1;
 286         tx_buf[1] = d2;
 287
 288         ret = i2c_master_send(client, tx_buf, 2);
 289         kfree(tx_buf);
 290         return (ret > 0) ? 0 : ret;
 291 }
 292
 293 static int max1363_set_scan_mode(struct max1363_state *st)
 294 {
 295         st->configbyte &= ~(MAX1363_CHANNEL_SEL_MASK
 296                             | MAX1363_SCAN_MASK
 297                             | MAX1363_SE_DE_MASK);
 298         st->configbyte |= st->current_mode->conf;
 299
 300         return max1363_write_basic_config(st->client,
 301                                           st->setupbyte,
 302                                           st->configbyte);
 303 }
 304
 305 static int max1363_initial_setup(struct max1363_state *st)
 306 {
 307         st->setupbyte = MAX1363_SETUP_AIN3_IS_AIN3_REF_IS_VDD
 308                 | MAX1363_SETUP_POWER_UP_INT_REF
 309                 | MAX1363_SETUP_INT_CLOCK
 310                 | MAX1363_SETUP_UNIPOLAR
 311                 | MAX1363_SETUP_NORESET;
 312
 313         /* Set scan mode writes the config anyway so wait until then*/
 314         st->setupbyte = MAX1363_SETUP_BYTE(st->setupbyte);
 315         st->current_mode = &max1363_mode_table[st->chip_info->default_mode];
 316         st->configbyte = MAX1363_CONFIG_BYTE(st->configbyte);
 317
 318         return max1363_set_scan_mode(st);
 319 }
 320
 321 static ssize_t max1363_show_av_scan_modes(struct device *dev,
 322                                           struct device_attribute *attr,
 323                                           char *buf)
 324 {
 325         struct iio_dev *dev_info = dev_get_drvdata(dev);
 326         struct max1363_state *st = dev_info->dev_data;
 327         int i, len = 0;
 328
 329         for (i = 0; i < st->chip_info->num_modes; i++)
 330                 len += sprintf(buf + len, "%s ",
 331                                max1363_mode_table[st->chip_info
 332                                                   ->mode_list[i]].name);
 333         len += sprintf(buf + len, "\n");
 334
 335         return len;
 336 }
 337
 338
 339 /* The dev here is the sysfs related one, not the underlying i2c one */
 340 static ssize_t max1363_scan_direct(struct device *dev,
 341                                    struct device_attribute *attr,
 342                                    char *buf)
 343 {
 344         struct iio_dev *dev_info = dev_get_drvdata(dev);
 345         struct max1363_state *st = dev_info->dev_data;
 346         int len = 0, ret, i;
 347         struct i2c_client *client = st->client;
 348         char *rxbuf;
 349
 350         if (st->current_mode->numvals == 0)
 351                 return 0;
 352         rxbuf = kmalloc(st->current_mode->numvals*2, GFP_KERNEL);
 353         if (rxbuf == NULL)
 354                 return -ENOMEM;
 355
 356         /* Interpretation depends on whether these are signed or not!*/
 357         /* Assume not for now */
 358         ret = i2c_master_recv(client, rxbuf, st->current_mode->numvals*2);
 359
 360         if (ret < 0)
 361                 return ret;
 362         for (i = 0; i < st->current_mode->numvals; i++)
 363                 len += sprintf(buf+len, "%d ",
 364                                ((int)(rxbuf[i*2+0]&0x0F) << 8)
 365                                + ((int)(rxbuf[i*2+1])));
 366         kfree(rxbuf);
 367         len += sprintf(buf + len, "\n");
 368
 369         return len;
 370 }
 371
 372 static ssize_t max1363_scan(struct device *dev,
 373                             struct device_attribute *attr,
 374                             char *buf)
 375 {
 376         struct iio_dev *dev_info = dev_get_drvdata(dev);
 377         int ret;
 378
 379         mutex_lock(&dev_info->mlock);
 380         if (dev_info->currentmode == INDIO_RING_TRIGGERED)
 381                 ret = max1363_scan_from_ring(dev, attr, buf);
 382         else
 383                 ret = max1363_scan_direct(dev, attr, buf);
 384         mutex_unlock(&dev_info->mlock);
 385
 386         return ret;
 387 }
 388
 389 /* Cannot query the device, so use local copy of state */
 390 static ssize_t max1363_show_scan_mode(struct device *dev,
 391                                       struct device_attribute *attr,
 392                                       char *buf)
 393 {
 394         struct iio_dev *dev_info = dev_get_drvdata(dev);
 395         struct max1363_state *st = dev_info->dev_data;
 396
 397         return sprintf(buf, "%s\n", st->current_mode->name);
 398 }
 399
 400 static const struct max1363_mode
 401 *__max1363_find_mode_in_ci(const struct max1363_chip_info *info,
 402                                   const char *buf)
 403 {
 404         int i;
 405         for (i = 0; i <  info->num_modes; i++)
 406                 if (strcmp(max1363_mode_table[info->mode_list[i]].name, buf)
 407                     == 0)
 408                         return &max1363_mode_table[info->mode_list[i]];
 409         return NULL;
 410 }
 411
 412 static ssize_t max1363_store_scan_mode(struct device *dev,
 413                                        struct device_attribute *attr,
 414                                        const char *buf,
 415                                        size_t len)
 416 {
 417         struct iio_dev *dev_info = dev_get_drvdata(dev);
 418         struct max1363_state *st = dev_info->dev_data;
 419         const struct max1363_mode *new_mode;
 420         int ret;
 421
 422         mutex_lock(&dev_info->mlock);
 423         new_mode = NULL;
 424         /* Avoid state changes if a ring buffer is enabled */
 425         if (!iio_ring_enabled(dev_info)) {
 426                 new_mode
 427                         = __max1363_find_mode_in_ci(st->chip_info, buf);
 428                 if (!new_mode) {
 429                         ret = -EINVAL;
 430                         goto error_ret;
 431                 }
 432                 st->current_mode = new_mode;
 433                 ret =  max1363_set_scan_mode(st);
 434                 if (ret)
 435                         goto error_ret;
 436         } else {
 437                 ret = -EBUSY;
 438                 goto error_ret;
 439         }
 440         mutex_unlock(&dev_info->mlock);
 441
 442         return len;
 443
 444 error_ret:
 445         mutex_unlock(&dev_info->mlock);
 446
 447         return ret;
 448 }
 449
 450 IIO_DEV_ATTR_AVAIL_SCAN_MODES(max1363_show_av_scan_modes);
 451 IIO_DEV_ATTR_SCAN_MODE(S_IRUGO | S_IWUSR,
 452                        max1363_show_scan_mode,
 453                        max1363_store_scan_mode);
 454
 455 IIO_DEV_ATTR_SCAN(max1363_scan);
 456
 457 static ssize_t max1363_show_name(struct device *dev,
 458                                  struct device_attribute *attr,
 459                                  char *buf)
 460 {
 461         struct iio_dev *dev_info = dev_get_drvdata(dev);
 462         struct max1363_state *st = dev_info->dev_data;
 463         return sprintf(buf, "%s\n", st->chip_info->name);
 464 }
 465
 466 IIO_DEVICE_ATTR(name, S_IRUGO, max1363_show_name, NULL, 0);
 467
 468 /*name export */
 469
 470 static struct attribute *max1363_attributes[] = {
 471         &iio_dev_attr_available_scan_modes.dev_attr.attr,
 472         &iio_dev_attr_scan_mode.dev_attr.attr,
 473         &iio_dev_attr_scan.dev_attr.attr,
 474         &iio_dev_attr_name.dev_attr.attr,
 475         NULL,
 476 };
 477
 478 static const struct attribute_group max1363_attribute_group = {
 479         .attrs = max1363_attributes,
 480 };
 481
 482 static int __devinit max1363_probe(struct i2c_client *client,
 483                                    const struct i2c_device_id *id)
 484 {
 485         int ret, i, regdone = 0;
 486         struct max1363_state *st = kzalloc(sizeof(*st), GFP_KERNEL);
 487         if (st == NULL) {
 488                 ret = -ENOMEM;
 489                 goto error_ret;
 490         }
 491
 492         /* this is only used for device removal purposes */
 493         i2c_set_clientdata(client, st);
 494
 495         atomic_set(&st->protect_ring, 0);
 496
 497         /* Find the chip model specific data */
 498         for (i = 0; i < ARRAY_SIZE(max1363_chip_info_tbl); i++)
 499                 if (!strcmp(max1363_chip_info_tbl[i].name, id->name)) {
 500                         st->chip_info = &max1363_chip_info_tbl[i];
 501                         break;
 502                 };
 503         /* Unsupported chip */
 504         if (!st->chip_info) {
 505                 dev_err(&client->dev, "%s is not supported\n", id->name);
 506                 ret = -ENODEV;
 507                 goto error_free_st;
 508         }
 509         st->reg = regulator_get(&client->dev, "vcc");
 510         if (!IS_ERR(st->reg)) {
 511                 ret = regulator_enable(st->reg);
 512                 if (ret)
 513                         goto error_put_reg;
 514         }
 515         st->client = client;
 516
 517         st->indio_dev = iio_allocate_device();
 518         if (st->indio_dev == NULL) {
 519                 ret = -ENOMEM;
 520                 goto error_disable_reg;
 521         }
 522
 523         /* Estabilish that the iio_dev is a child of the i2c device */
 524         st->indio_dev->dev.parent = &client->dev;
 525         st->indio_dev->attrs = &max1363_attribute_group;
 526         st->indio_dev->dev_data = (void *)(st);
 527         st->indio_dev->driver_module = THIS_MODULE;
 528         st->indio_dev->modes = INDIO_DIRECT_MODE;
 529
 530         ret = max1363_initial_setup(st);
 531         if (ret)
 532                 goto error_free_device;
 533
 534         ret = max1363_register_ring_funcs_and_init(st->indio_dev);
 535         if (ret)
 536                 goto error_free_device;
 537
 538         ret = iio_device_register(st->indio_dev);
 539         if (ret)
 540                 goto error_cleanup_ring;
 541         regdone = 1;
 542         ret = max1363_initialize_ring(st->indio_dev->ring);
 543         if (ret)
 544                 goto error_cleanup_ring;
 545         return 0;
 546 error_cleanup_ring:
 547         max1363_ring_cleanup(st->indio_dev);
 548 error_free_device:
 549         if (!regdone)
 550                 iio_free_device(st->indio_dev);
 551         else
 552                 iio_device_unregister(st->indio_dev);
 553 error_disable_reg:
 554         if (!IS_ERR(st->reg))
 555                 regulator_disable(st->reg);
 556 error_put_reg:
 557         if (!IS_ERR(st->reg))
 558                 regulator_put(st->reg);
 559 error_free_st:
 560         i2c_set_clientdata(client, NULL);
 561         kfree(st);
 562
 563 error_ret:
 564         return ret;
 565 }
 566
 567 static int max1363_remove(struct i2c_client *client)
 568 {
 569         struct max1363_state *st = i2c_get_clientdata(client);
 570         struct iio_dev *indio_dev = st->indio_dev;
 571         max1363_uninitialize_ring(indio_dev->ring);
 572         max1363_ring_cleanup(indio_dev);
 573         iio_device_unregister(indio_dev);
 574         if (!IS_ERR(st->reg)) {
 575                 regulator_disable(st->reg);
 576                 regulator_put(st->reg);
 577         }
 578         i2c_set_clientdata(client, NULL);
 579         kfree(st);
 580
 581         return 0;
 582 }
 583
 584 static const struct i2c_device_id max1363_id[] = {
 585         { "max1361", max1361 },
 586         { "max1362", max1362 },
 587         { "max1363", max1363 },
 588         { "max1364", max1364 },
 589         { "max1136", max1136 },
 590         { "max1137", max1137 },
 591         { "max1138", max1138 },
 592         { "max1139", max1139 },
 593         { "max1236", max1236 },
 594         { "max1237", max1237 },
 595         { "max1238", max1238 },
 596         { "max1239", max1239 },
 597         {}
 598 };
 599
 600 MODULE_DEVICE_TABLE(i2c, max1363_id);
 601
 602 static struct i2c_driver max1363_driver = {
 603         .driver = {
 604                 .name = "max1363",
 605         },
 606         .probe = max1363_probe,
 607         .remove = max1363_remove,
 608         .id_table = max1363_id,
 609 };
 610
 611 static __init int max1363_init(void)
 612 {
 613         return i2c_add_driver(&max1363_driver);
 614 }
 615
 616 static __exit void max1363_exit(void)
 617 {
 618         i2c_del_driver(&max1363_driver);
 619 }
 620
 621 MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>");
 622 MODULE_DESCRIPTION("Maxim 1363 ADC");
 623 MODULE_LICENSE("GPL v2");
 624
 625 module_init(max1363_init);
 626 module_exit(max1363_exit);