drivers/staging/iio/adc/ad799x_core.c

   1 /*
   2  * iio/adc/ad799x.c
   3  * Copyright (C) 2010-1011 Michael Hennerich, Analog Devices Inc.
   4  *
   5  * based on iio/adc/max1363
   6  * Copyright (C) 2008-2010 Jonathan Cameron
   7  *
   8  * based on linux/drivers/i2c/chips/max123x
   9  * Copyright (C) 2002-2004 Stefan Eletzhofer
  10  *
  11  * based on linux/drivers/acron/char/pcf8583.c
  12  * Copyright (C) 2000 Russell King
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License version 2 as
  16  * published by the Free Software Foundation.
  17  *
  18  * ad799x.c
  19  *
  20  * Support for ad7991, ad7995, ad7999, ad7992, ad7993, ad7994, ad7997,
  21  * ad7998 and similar chips.
  22  *
  23  */
  24
  25 #include <linux/interrupt.h>
  26 #include <linux/device.h>
  27 #include <linux/kernel.h>
  28 #include <linux/sysfs.h>
  29 #include <linux/i2c.h>
  30 #include <linux/regulator/consumer.h>
  31 #include <linux/slab.h>
  32 #include <linux/types.h>
  33 #include <linux/err.h>
  34 #include <linux/module.h>
  35
  36 #include "../iio.h"
  37 #include "../sysfs.h"
  38 #include "../ring_generic.h"
  39
  40 #include "ad799x.h"
  41
  42 /*
  43  * ad799x register access by I2C
  44  */
  45 static int ad799x_i2c_read16(struct ad799x_state *st, u8 reg, u16 *data)
  46 {
  47         struct i2c_client *client = st->client;
  48         int ret = 0;
  49
  50         ret = i2c_smbus_read_word_data(client, reg);
  51         if (ret < 0) {
  52                 dev_err(&client->dev, "I2C read error\n");
  53                 return ret;
  54         }
  55
  56         *data = swab16((u16)ret);
  57
  58         return 0;
  59 }
  60
  61 static int ad799x_i2c_read8(struct ad799x_state *st, u8 reg, u8 *data)
  62 {
  63         struct i2c_client *client = st->client;
  64         int ret = 0;
  65
  66         ret = i2c_smbus_read_byte_data(client, reg);
  67         if (ret < 0) {
  68                 dev_err(&client->dev, "I2C read error\n");
  69                 return ret;
  70         }
  71
  72         *data = (u8)ret;
  73
  74         return 0;
  75 }
  76
  77 static int ad799x_i2c_write16(struct ad799x_state *st, u8 reg, u16 data)
  78 {
  79         struct i2c_client *client = st->client;
  80         int ret = 0;
  81
  82         ret = i2c_smbus_write_word_data(client, reg, swab16(data));
  83         if (ret < 0)
  84                 dev_err(&client->dev, "I2C write error\n");
  85
  86         return ret;
  87 }
  88
  89 static int ad799x_i2c_write8(struct ad799x_state *st, u8 reg, u8 data)
  90 {
  91         struct i2c_client *client = st->client;
  92         int ret = 0;
  93
  94         ret = i2c_smbus_write_byte_data(client, reg, data);
  95         if (ret < 0)
  96                 dev_err(&client->dev, "I2C write error\n");
  97
  98         return ret;
  99 }
 100
 101 int ad7997_8_set_scan_mode(struct ad799x_state *st, unsigned mask)
 102 {
 103         return ad799x_i2c_write16(st, AD7998_CONF_REG,
 104                 st->config | (mask << AD799X_CHANNEL_SHIFT));
 105 }
 106
 107 static int ad799x_scan_direct(struct ad799x_state *st, unsigned ch)
 108 {
 109         u16 rxbuf;
 110         u8 cmd;
 111         int ret;
 112
 113         switch (st->id) {
 114         case ad7991:
 115         case ad7995:
 116         case ad7999:
 117                 cmd = st->config | ((1 << ch) << AD799X_CHANNEL_SHIFT);
 118                 break;
 119         case ad7992:
 120         case ad7993:
 121         case ad7994:
 122                 cmd = (1 << ch) << AD799X_CHANNEL_SHIFT;
 123                 break;
 124         case ad7997:
 125         case ad7998:
 126                 cmd = (ch << AD799X_CHANNEL_SHIFT) | AD7997_8_READ_SINGLE;
 127                 break;
 128         default:
 129                 return -EINVAL;
 130         }
 131
 132         ret = ad799x_i2c_read16(st, cmd, &rxbuf);
 133         if (ret < 0)
 134                 return ret;
 135
 136         return rxbuf;
 137 }
 138
 139 static int ad799x_read_raw(struct iio_dev *dev_info,
 140                            struct iio_chan_spec const *chan,
 141                            int *val,
 142                            int *val2,
 143                            long m)
 144 {
 145         int ret;
 146         struct ad799x_state *st = iio_priv(dev_info);
 147         unsigned int scale_uv;
 148
 149         switch (m) {
 150         case 0:
 151                 mutex_lock(&dev_info->mlock);
 152                 if (iio_ring_enabled(dev_info))
 153                         ret = ad799x_single_channel_from_ring(st,
 154                                 1 << chan->address);
 155                 else
 156                         ret = ad799x_scan_direct(st, chan->address);
 157                 mutex_unlock(&dev_info->mlock);
 158
 159                 if (ret < 0)
 160                         return ret;
 161                 *val = (ret >> st->chip_info->channel[0].scan_type.shift) &
 162                         RES_MASK(st->chip_info->channel[0].scan_type.realbits);
 163                 return IIO_VAL_INT;
 164         case (1 << IIO_CHAN_INFO_SCALE_SHARED):
 165                 scale_uv = (st->int_vref_mv * 1000)
 166                         >> st->chip_info->channel[0].scan_type.realbits;
 167                 *val =  scale_uv / 1000;
 168                 *val2 = (scale_uv % 1000) * 1000;
 169                 return IIO_VAL_INT_PLUS_MICRO;
 170         }
 171         return -EINVAL;
 172 }
 173
 174 static ssize_t ad799x_read_frequency(struct device *dev,
 175                                         struct device_attribute *attr,
 176                                         char *buf)
 177 {
 178         struct iio_dev *dev_info = dev_get_drvdata(dev);
 179         struct ad799x_state *st = iio_priv(dev_info);
 180
 181         int ret, len = 0;
 182         u8 val;
 183         ret = ad799x_i2c_read8(st, AD7998_CYCLE_TMR_REG, &val);
 184         if (ret)
 185                 return ret;
 186
 187         val &= AD7998_CYC_MASK;
 188
 189         switch (val) {
 190         case AD7998_CYC_DIS:
 191                 len = sprintf(buf, "0\n");
 192                 break;
 193         case AD7998_CYC_TCONF_32:
 194                 len = sprintf(buf, "15625\n");
 195                 break;
 196         case AD7998_CYC_TCONF_64:
 197                 len = sprintf(buf, "7812\n");
 198                 break;
 199         case AD7998_CYC_TCONF_128:
 200                 len = sprintf(buf, "3906\n");
 201                 break;
 202         case AD7998_CYC_TCONF_256:
 203                 len = sprintf(buf, "1953\n");
 204                 break;
 205         case AD7998_CYC_TCONF_512:
 206                 len = sprintf(buf, "976\n");
 207                 break;
 208         case AD7998_CYC_TCONF_1024:
 209                 len = sprintf(buf, "488\n");
 210                 break;
 211         case AD7998_CYC_TCONF_2048:
 212                 len = sprintf(buf, "244\n");
 213                 break;
 214         }
 215         return len;
 216 }
 217
 218 static ssize_t ad799x_write_frequency(struct device *dev,
 219                                          struct device_attribute *attr,
 220                                          const char *buf,
 221                                          size_t len)
 222 {
 223         struct iio_dev *dev_info = dev_get_drvdata(dev);
 224         struct ad799x_state *st = iio_priv(dev_info);
 225
 226         long val;
 227         int ret;
 228         u8 t;
 229
 230         ret = strict_strtol(buf, 10, &val);
 231         if (ret)
 232                 return ret;
 233
 234         mutex_lock(&dev_info->mlock);
 235         ret = ad799x_i2c_read8(st, AD7998_CYCLE_TMR_REG, &t);
 236         if (ret)
 237                 goto error_ret_mutex;
 238         /* Wipe the bits clean */
 239         t &= ~AD7998_CYC_MASK;
 240
 241         switch (val) {
 242         case 15625:
 243                 t |= AD7998_CYC_TCONF_32;
 244                 break;
 245         case 7812:
 246                 t |= AD7998_CYC_TCONF_64;
 247                 break;
 248         case 3906:
 249                 t |= AD7998_CYC_TCONF_128;
 250                 break;
 251         case 1953:
 252                 t |= AD7998_CYC_TCONF_256;
 253                 break;
 254         case 976:
 255                 t |= AD7998_CYC_TCONF_512;
 256                 break;
 257         case 488:
 258                 t |= AD7998_CYC_TCONF_1024;
 259                 break;
 260         case 244:
 261                 t |= AD7998_CYC_TCONF_2048;
 262                 break;
 263         case  0:
 264                 t |= AD7998_CYC_DIS;
 265                 break;
 266         default:
 267                 ret = -EINVAL;
 268                 goto error_ret_mutex;
 269         }
 270
 271         ret = ad799x_i2c_write8(st, AD7998_CYCLE_TMR_REG, t);
 272
 273 error_ret_mutex:
 274         mutex_unlock(&dev_info->mlock);
 275
 276         return ret ? ret : len;
 277 }
 278
 279 static ssize_t ad799x_read_channel_config(struct device *dev,
 280                                         struct device_attribute *attr,
 281                                         char *buf)
 282 {
 283         struct iio_dev *dev_info = dev_get_drvdata(dev);
 284         struct ad799x_state *st = iio_priv(dev_info);
 285         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 286
 287         int ret;
 288         u16 val;
 289         ret = ad799x_i2c_read16(st, this_attr->address, &val);
 290         if (ret)
 291                 return ret;
 292
 293         return sprintf(buf, "%d\n", val);
 294 }
 295
 296 static ssize_t ad799x_write_channel_config(struct device *dev,
 297                                          struct device_attribute *attr,
 298                                          const char *buf,
 299                                          size_t len)
 300 {
 301         struct iio_dev *dev_info = dev_get_drvdata(dev);
 302         struct ad799x_state *st = iio_priv(dev_info);
 303         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 304
 305         long val;
 306         int ret;
 307
 308         ret = strict_strtol(buf, 10, &val);
 309         if (ret)
 310                 return ret;
 311
 312         mutex_lock(&dev_info->mlock);
 313         ret = ad799x_i2c_write16(st, this_attr->address, val);
 314         mutex_unlock(&dev_info->mlock);
 315
 316         return ret ? ret : len;
 317 }
 318
 319 static irqreturn_t ad799x_event_handler(int irq, void *private)
 320 {
 321         struct iio_dev *indio_dev = private;
 322         struct ad799x_state *st = iio_priv(private);
 323         u8 status;
 324         int i, ret;
 325
 326         ret = ad799x_i2c_read8(st, AD7998_ALERT_STAT_REG, &status);
 327         if (ret)
 328                 return ret;
 329
 330         if (!status)
 331                 return -EIO;
 332
 333         ad799x_i2c_write8(st, AD7998_ALERT_STAT_REG, AD7998_ALERT_STAT_CLEAR);
 334
 335         for (i = 0; i < 8; i++) {
 336                 if (status & (1 << i))
 337                         iio_push_event(indio_dev, 0,
 338                                        i & 0x1 ?
 339                                        IIO_UNMOD_EVENT_CODE(IIO_IN,
 340                                                             (i >> 1),
 341                                                             IIO_EV_TYPE_THRESH,
 342                                                             IIO_EV_DIR_RISING) :
 343                                        IIO_UNMOD_EVENT_CODE(IIO_IN,
 344                                                             (i >> 1),
 345                                                             IIO_EV_TYPE_THRESH,
 346                                                             IIO_EV_DIR_FALLING),
 347                                        iio_get_time_ns());
 348         }
 349
 350         return IRQ_HANDLED;
 351 }
 352
 353 static IIO_DEVICE_ATTR(in0_thresh_low_value,
 354                        S_IRUGO | S_IWUSR,
 355                        ad799x_read_channel_config,
 356                        ad799x_write_channel_config,
 357                        AD7998_DATALOW_CH1_REG);
 358
 359 static IIO_DEVICE_ATTR(in0_thresh_high_value,
 360                        S_IRUGO | S_IWUSR,
 361                        ad799x_read_channel_config,
 362                        ad799x_write_channel_config,
 363                        AD7998_DATAHIGH_CH1_REG);
 364
 365 static IIO_DEVICE_ATTR(in0_thresh_both_hyst_raw,
 366                        S_IRUGO | S_IWUSR,
 367                        ad799x_read_channel_config,
 368                        ad799x_write_channel_config,
 369                        AD7998_HYST_CH1_REG);
 370
 371 static IIO_DEVICE_ATTR(in1_thresh_low_value,
 372                        S_IRUGO | S_IWUSR,
 373                        ad799x_read_channel_config,
 374                        ad799x_write_channel_config,
 375                        AD7998_DATALOW_CH2_REG);
 376
 377 static IIO_DEVICE_ATTR(in1_thresh_high_value,
 378                        S_IRUGO | S_IWUSR,
 379                        ad799x_read_channel_config,
 380                        ad799x_write_channel_config,
 381                        AD7998_DATAHIGH_CH2_REG);
 382
 383 static IIO_DEVICE_ATTR(in1_thresh_both_hyst_raw,
 384                        S_IRUGO | S_IWUSR,
 385                        ad799x_read_channel_config,
 386                        ad799x_write_channel_config,
 387                        AD7998_HYST_CH2_REG);
 388
 389 static IIO_DEVICE_ATTR(in2_thresh_low_value,
 390                        S_IRUGO | S_IWUSR,
 391                        ad799x_read_channel_config,
 392                        ad799x_write_channel_config,
 393                        AD7998_DATALOW_CH3_REG);
 394
 395 static IIO_DEVICE_ATTR(in2_thresh_high_value,
 396                        S_IRUGO | S_IWUSR,
 397                        ad799x_read_channel_config,
 398                        ad799x_write_channel_config,
 399                        AD7998_DATAHIGH_CH3_REG);
 400
 401 static IIO_DEVICE_ATTR(in2_thresh_both_hyst_raw,
 402                        S_IRUGO | S_IWUSR,
 403                        ad799x_read_channel_config,
 404                        ad799x_write_channel_config,
 405                        AD7998_HYST_CH3_REG);
 406
 407 static IIO_DEVICE_ATTR(in3_thresh_low_value,
 408                        S_IRUGO | S_IWUSR,
 409                        ad799x_read_channel_config,
 410                        ad799x_write_channel_config,
 411                        AD7998_DATALOW_CH4_REG);
 412
 413 static IIO_DEVICE_ATTR(in3_thresh_high_value,
 414                        S_IRUGO | S_IWUSR,
 415                        ad799x_read_channel_config,
 416                        ad799x_write_channel_config,
 417                        AD7998_DATAHIGH_CH4_REG);
 418
 419 static IIO_DEVICE_ATTR(in3_thresh_both_hyst_raw,
 420                        S_IRUGO | S_IWUSR,
 421                        ad799x_read_channel_config,
 422                        ad799x_write_channel_config,
 423                        AD7998_HYST_CH4_REG);
 424
 425 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
 426                               ad799x_read_frequency,
 427                               ad799x_write_frequency);
 428 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("15625 7812 3906 1953 976 488 244 0");
 429
 430 static struct attribute *ad7993_4_7_8_event_attributes[] = {
 431         &iio_dev_attr_in0_thresh_low_value.dev_attr.attr,
 432         &iio_dev_attr_in0_thresh_high_value.dev_attr.attr,
 433         &iio_dev_attr_in0_thresh_both_hyst_raw.dev_attr.attr,
 434         &iio_dev_attr_in1_thresh_low_value.dev_attr.attr,
 435         &iio_dev_attr_in1_thresh_high_value.dev_attr.attr,
 436         &iio_dev_attr_in1_thresh_both_hyst_raw.dev_attr.attr,
 437         &iio_dev_attr_in2_thresh_low_value.dev_attr.attr,
 438         &iio_dev_attr_in2_thresh_high_value.dev_attr.attr,
 439         &iio_dev_attr_in2_thresh_both_hyst_raw.dev_attr.attr,
 440         &iio_dev_attr_in3_thresh_low_value.dev_attr.attr,
 441         &iio_dev_attr_in3_thresh_high_value.dev_attr.attr,
 442         &iio_dev_attr_in3_thresh_both_hyst_raw.dev_attr.attr,
 443         &iio_dev_attr_sampling_frequency.dev_attr.attr,
 444         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 445         NULL,
 446 };
 447
 448 static struct attribute_group ad7993_4_7_8_event_attrs_group = {
 449         .attrs = ad7993_4_7_8_event_attributes,
 450         .name = "events",
 451 };
 452
 453 static struct attribute *ad7992_event_attributes[] = {
 454         &iio_dev_attr_in0_thresh_low_value.dev_attr.attr,
 455         &iio_dev_attr_in0_thresh_high_value.dev_attr.attr,
 456         &iio_dev_attr_in0_thresh_both_hyst_raw.dev_attr.attr,
 457         &iio_dev_attr_in1_thresh_low_value.dev_attr.attr,
 458         &iio_dev_attr_in1_thresh_high_value.dev_attr.attr,
 459         &iio_dev_attr_in1_thresh_both_hyst_raw.dev_attr.attr,
 460         &iio_dev_attr_sampling_frequency.dev_attr.attr,
 461         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 462         NULL,
 463 };
 464
 465 static struct attribute_group ad7992_event_attrs_group = {
 466         .attrs = ad7992_event_attributes,
 467         .name = "events",
 468 };
 469
 470 static const struct iio_info ad7991_info = {
 471         .read_raw = &ad799x_read_raw,
 472         .driver_module = THIS_MODULE,
 473 };
 474
 475 static const struct iio_info ad7992_info = {
 476         .read_raw = &ad799x_read_raw,
 477         .num_interrupt_lines = 1,
 478         .event_attrs = &ad7992_event_attrs_group,
 479         .driver_module = THIS_MODULE,
 480 };
 481
 482 static const struct iio_info ad7993_4_7_8_info = {
 483         .read_raw = &ad799x_read_raw,
 484         .num_interrupt_lines = 1,
 485         .event_attrs = &ad7993_4_7_8_event_attrs_group,
 486         .driver_module = THIS_MODULE,
 487 };
 488
 489 static const struct ad799x_chip_info ad799x_chip_info_tbl[] = {
 490         [ad7991] = {
 491                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
 492                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 493                                        0, 0, IIO_ST('u', 12, 16, 0), 0),
 494                 .channel[1] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
 495                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 496                                        1, 1, IIO_ST('u', 12, 16, 0), 0),
 497                 .channel[2] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 2, 0,
 498                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 499                                        2, 2, IIO_ST('u', 12, 16, 0), 0),
 500                 .channel[3] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 3, 0,
 501                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 502                                        3, 3, IIO_ST('u', 12, 16, 0), 0),
 503                 .channel[4] = IIO_CHAN_SOFT_TIMESTAMP(4),
 504                 .num_channels = 5,
 505                 .int_vref_mv = 4096,
 506                 .info = &ad7991_info,
 507         },
 508         [ad7995] = {
 509                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
 510                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 511                                        0, 0, IIO_ST('u', 10, 16, 0), 0),
 512                 .channel[1] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
 513                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 514                                        1, 1, IIO_ST('u', 10, 16, 0), 0),
 515                 .channel[2] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 2, 0,
 516                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 517                                        2, 2, IIO_ST('u', 10, 16, 0), 0),
 518                 .channel[3] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 3, 0,
 519                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 520                                        3, 3, IIO_ST('u', 10, 16, 0), 0),
 521                 .channel[4] = IIO_CHAN_SOFT_TIMESTAMP(4),
 522                 .num_channels = 5,
 523                 .int_vref_mv = 1024,
 524                 .info = &ad7991_info,
 525         },
 526         [ad7999] = {
 527                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
 528                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 529                                        0, 0, IIO_ST('u', 10, 16, 0), 0),
 530                 .channel[1] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
 531                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 532                                        1, 1, IIO_ST('u', 10, 16, 0), 0),
 533                 .channel[2] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 2, 0,
 534                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 535                                        2, 2, IIO_ST('u', 10, 16, 0), 0),
 536                 .channel[3] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 3, 0,
 537                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 538                                        3, 3, IIO_ST('u', 10, 16, 0), 0),
 539                 .channel[4] = IIO_CHAN_SOFT_TIMESTAMP(4),
 540                 .num_channels = 5,
 541                 .int_vref_mv = 1024,
 542                 .info = &ad7991_info,
 543         },
 544         [ad7992] = {
 545                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
 546                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 547                                        0, 0, IIO_ST('u', 12, 16, 0), 0),
 548                 .channel[1] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
 549                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 550                                        1, 1, IIO_ST('u', 12, 16, 0), 0),
 551                 .channel[2] = IIO_CHAN_SOFT_TIMESTAMP(2),
 552                 .num_channels = 3,
 553                 .int_vref_mv = 4096,
 554                 .default_config = AD7998_ALERT_EN,
 555                 .info = &ad7992_info,
 556         },
 557         [ad7993] = {
 558                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
 559                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 560                                        0, 0, IIO_ST('u', 10, 16, 0), 0),
 561                 .channel[1] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
 562                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 563                                        1, 1, IIO_ST('u', 10, 16, 0), 0),
 564                 .channel[2] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 2, 0,
 565                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 566                                        2, 2, IIO_ST('u', 10, 16, 0), 0),
 567                 .channel[3] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 3, 0,
 568                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 569                                        3, 3, IIO_ST('u', 10, 16, 0), 0),
 570                 .channel[4] = IIO_CHAN_SOFT_TIMESTAMP(4),
 571                 .num_channels = 5,
 572                 .int_vref_mv = 1024,
 573                 .default_config = AD7998_ALERT_EN,
 574                 .info = &ad7993_4_7_8_info,
 575         },
 576         [ad7994] = {
 577                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
 578                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 579                                        0, 0, IIO_ST('u', 12, 16, 0), 0),
 580                 .channel[1] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
 581                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 582                                        1, 1, IIO_ST('u', 12, 16, 0), 0),
 583                 .channel[2] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 2, 0,
 584                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 585                                        2, 2, IIO_ST('u', 12, 16, 0), 0),
 586                 .channel[3] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 3, 0,
 587                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 588                                        3, 3, IIO_ST('u', 12, 16, 0), 0),
 589                 .channel[4] = IIO_CHAN_SOFT_TIMESTAMP(4),
 590                 .num_channels = 5,
 591                 .int_vref_mv = 4096,
 592                 .default_config = AD7998_ALERT_EN,
 593                 .info = &ad7993_4_7_8_info,
 594         },
 595         [ad7997] = {
 596                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
 597                                           (1 << IIO_CHAN_INFO_SCALE_SHARED),
 598                                           0, 0, IIO_ST('u', 10, 16, 0), 0),
 599                 .channel[1] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
 600                                           (1 << IIO_CHAN_INFO_SCALE_SHARED),
 601                                           1, 1, IIO_ST('u', 10, 16, 0), 0),
 602                 .channel[2] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 2, 0,
 603                                           (1 << IIO_CHAN_INFO_SCALE_SHARED),
 604                                           2, 2, IIO_ST('u', 10, 16, 0), 0),
 605                 .channel[3] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 3, 0,
 606                                           (1 << IIO_CHAN_INFO_SCALE_SHARED),
 607                                           3, 3, IIO_ST('u', 10, 16, 0), 0),
 608                 .channel[4] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 4, 0,
 609                                           (1 << IIO_CHAN_INFO_SCALE_SHARED),
 610                                           4, 4, IIO_ST('u', 10, 16, 0), 0),
 611                 .channel[5] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 5, 0,
 612                                           (1 << IIO_CHAN_INFO_SCALE_SHARED),
 613                                           5, 5, IIO_ST('u', 10, 16, 0), 0),
 614                 .channel[6] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 6, 0,
 615                                           (1 << IIO_CHAN_INFO_SCALE_SHARED),
 616                                           6, 6, IIO_ST('u', 10, 16, 0), 0),
 617                 .channel[7] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 7, 0,
 618                                           (1 << IIO_CHAN_INFO_SCALE_SHARED),
 619                                           7, 7, IIO_ST('u', 10, 16, 0), 0),
 620                 .channel[8] = IIO_CHAN_SOFT_TIMESTAMP(8),
 621                 .num_channels = 9,
 622                 .int_vref_mv = 1024,
 623                 .default_config = AD7998_ALERT_EN,
 624                 .info = &ad7993_4_7_8_info,
 625         },
 626         [ad7998] = {
 627                 .channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
 628                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 629                                        0, 0, IIO_ST('u', 12, 16, 0), 0),
 630                 .channel[1] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
 631                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 632                                        1, 1, IIO_ST('u', 12, 16, 0), 0),
 633                 .channel[2] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 2, 0,
 634                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 635                                        2, 2, IIO_ST('u', 12, 16, 0), 0),
 636                 .channel[3] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 3, 0,
 637                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 638                                        3, 3, IIO_ST('u', 12, 16, 0), 0),
 639                 .channel[4] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 4, 0,
 640                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 641                                        4, 4, IIO_ST('u', 12, 16, 0), 0),
 642                 .channel[5] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 5, 0,
 643                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 644                                        5, 5, IIO_ST('u', 12, 16, 0), 0),
 645                 .channel[6] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 6, 0,
 646                                        (1 << IIO_CHAN_INFO_SCALE_SHARED),
 647                                        6, 6, IIO_ST('u', 12, 16, 0), 0),
 648                 .channel[7] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 7, 0,
 649                                           (1 << IIO_CHAN_INFO_SCALE_SHARED),
 650                                           7, 7, IIO_ST('u', 12, 16, 0), 0),
 651                 .channel[8] = IIO_CHAN_SOFT_TIMESTAMP(8),
 652                 .num_channels = 9,
 653                 .int_vref_mv = 4096,
 654                 .default_config = AD7998_ALERT_EN,
 655                 .info = &ad7993_4_7_8_info,
 656         },
 657 };
 658
 659 static int __devinit ad799x_probe(struct i2c_client *client,
 660                                    const struct i2c_device_id *id)
 661 {
 662         int ret, regdone = 0;
 663         struct ad799x_platform_data *pdata = client->dev.platform_data;
 664         struct ad799x_state *st;
 665         struct iio_dev *indio_dev = iio_allocate_device(sizeof(*st));
 666
 667         if (indio_dev == NULL)
 668                 return -ENOMEM;
 669
 670         st = iio_priv(indio_dev);
 671         /* this is only used for device removal purposes */
 672         i2c_set_clientdata(client, indio_dev);
 673
 674         st->id = id->driver_data;
 675         st->chip_info = &ad799x_chip_info_tbl[st->id];
 676         st->config = st->chip_info->default_config;
 677
 678         /* TODO: Add pdata options for filtering and bit delay */
 679
 680         if (pdata)
 681                 st->int_vref_mv = pdata->vref_mv;
 682         else
 683                 st->int_vref_mv = st->chip_info->int_vref_mv;
 684
 685         st->reg = regulator_get(&client->dev, "vcc");
 686         if (!IS_ERR(st->reg)) {
 687                 ret = regulator_enable(st->reg);
 688                 if (ret)
 689                         goto error_put_reg;
 690         }
 691         st->client = client;
 692
 693         indio_dev->dev.parent = &client->dev;
 694         indio_dev->name = id->name;
 695         indio_dev->info = st->chip_info->info;
 696         indio_dev->name = id->name;
 697
 698         indio_dev->modes = INDIO_DIRECT_MODE;
 699         indio_dev->channels = st->chip_info->channel;
 700         indio_dev->num_channels = st->chip_info->num_channels;
 701
 702         ret = ad799x_register_ring_funcs_and_init(indio_dev);
 703         if (ret)
 704                 goto error_disable_reg;
 705
 706         ret = iio_device_register(indio_dev);
 707         if (ret)
 708                 goto error_cleanup_ring;
 709         regdone = 1;
 710
 711         ret = iio_ring_buffer_register_ex(indio_dev, 0,
 712                                           indio_dev->channels,
 713                                           indio_dev->num_channels);
 714         if (ret)
 715                 goto error_cleanup_ring;
 716
 717         if (client->irq > 0) {
 718                 ret = request_threaded_irq(client->irq,
 719                                            NULL,
 720                                            ad799x_event_handler,
 721                                            IRQF_TRIGGER_FALLING |
 722                                            IRQF_ONESHOT,
 723                                            client->name,
 724                                            indio_dev);
 725                 if (ret)
 726                         goto error_cleanup_ring;
 727         }
 728
 729         return 0;
 730
 731 error_cleanup_ring:
 732         ad799x_ring_cleanup(indio_dev);
 733 error_disable_reg:
 734         if (!IS_ERR(st->reg))
 735                 regulator_disable(st->reg);
 736 error_put_reg:
 737         if (!IS_ERR(st->reg))
 738                 regulator_put(st->reg);
 739         if (regdone)
 740                 iio_device_unregister(indio_dev);
 741         else
 742                 iio_free_device(indio_dev);
 743
 744         return ret;
 745 }
 746
 747 static __devexit int ad799x_remove(struct i2c_client *client)
 748 {
 749         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 750         struct ad799x_state *st = iio_priv(indio_dev);
 751
 752         if (client->irq > 0)
 753                 free_irq(client->irq, indio_dev);
 754
 755         iio_ring_buffer_unregister(indio_dev);
 756         ad799x_ring_cleanup(indio_dev);
 757         if (!IS_ERR(st->reg)) {
 758                 regulator_disable(st->reg);
 759                 regulator_put(st->reg);
 760         }
 761         iio_device_unregister(indio_dev);
 762
 763         return 0;
 764 }
 765
 766 static const struct i2c_device_id ad799x_id[] = {
 767         { "ad7991", ad7991 },
 768         { "ad7995", ad7995 },
 769         { "ad7999", ad7999 },
 770         { "ad7992", ad7992 },
 771         { "ad7993", ad7993 },
 772         { "ad7994", ad7994 },
 773         { "ad7997", ad7997 },
 774         { "ad7998", ad7998 },
 775         {}
 776 };
 777
 778 MODULE_DEVICE_TABLE(i2c, ad799x_id);
 779
 780 static struct i2c_driver ad799x_driver = {
 781         .driver = {
 782                 .name = "ad799x",
 783         },
 784         .probe = ad799x_probe,
 785         .remove = __devexit_p(ad799x_remove),
 786         .id_table = ad799x_id,
 787 };
 788
 789 static __init int ad799x_init(void)
 790 {
 791         return i2c_add_driver(&ad799x_driver);
 792 }
 793
 794 static __exit void ad799x_exit(void)
 795 {
 796         i2c_del_driver(&ad799x_driver);
 797 }
 798
 799 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 800 MODULE_DESCRIPTION("Analog Devices AD799x ADC");
 801 MODULE_LICENSE("GPL v2");
 802 MODULE_ALIAS("i2c:ad799x");
 803
 804 module_init(ad799x_init);
 805 module_exit(ad799x_exit);