drivers/staging/iio/adc/ad799x_core.c

   1 /*
   2  * iio/adc/ad799x.c
   3  * Copyright (C) 2010 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/workqueue.h>
  27 #include <linux/device.h>
  28 #include <linux/kernel.h>
  29 #include <linux/sysfs.h>
  30 #include <linux/list.h>
  31 #include <linux/i2c.h>
  32 #include <linux/regulator/consumer.h>
  33 #include <linux/slab.h>
  34 #include <linux/types.h>
  35 #include <linux/err.h>
  36
  37 #include "../iio.h"
  38 #include "../sysfs.h"
  39
  40 #include "../ring_generic.h"
  41 #include "adc.h"
  42 #include "ad799x.h"
  43
  44 /*
  45  * ad799x register access by I2C
  46  */
  47 static int ad799x_i2c_read16(struct ad799x_state *st, u8 reg, u16 *data)
  48 {
  49         struct i2c_client *client = st->client;
  50         int ret = 0;
  51
  52         ret = i2c_smbus_read_word_data(client, reg);
  53         if (ret < 0) {
  54                 dev_err(&client->dev, "I2C read error\n");
  55                 return ret;
  56         }
  57
  58         *data = swab16((u16)ret);
  59
  60         return 0;
  61 }
  62
  63 static int ad799x_i2c_read8(struct ad799x_state *st, u8 reg, u8 *data)
  64 {
  65         struct i2c_client *client = st->client;
  66         int ret = 0;
  67
  68         ret = i2c_smbus_read_byte_data(client, reg);
  69         if (ret < 0) {
  70                 dev_err(&client->dev, "I2C read error\n");
  71                 return ret;
  72         }
  73
  74         *data = (u8)ret;
  75
  76         return 0;
  77 }
  78
  79 static int ad799x_i2c_write16(struct ad799x_state *st, u8 reg, u16 data)
  80 {
  81         struct i2c_client *client = st->client;
  82         int ret = 0;
  83
  84         ret = i2c_smbus_write_word_data(client, reg, swab16(data));
  85         if (ret < 0)
  86                 dev_err(&client->dev, "I2C write error\n");
  87
  88         return ret;
  89 }
  90
  91 static int ad799x_i2c_write8(struct ad799x_state *st, u8 reg, u8 data)
  92 {
  93         struct i2c_client *client = st->client;
  94         int ret = 0;
  95
  96         ret = i2c_smbus_write_byte_data(client, reg, data);
  97         if (ret < 0)
  98                 dev_err(&client->dev, "I2C write error\n");
  99
 100         return ret;
 101 }
 102
 103 static int ad799x_scan_el_set_state(struct iio_scan_el *scan_el,
 104                                        struct iio_dev *indio_dev,
 105                                        bool state)
 106 {
 107         struct ad799x_state *st = indio_dev->dev_data;
 108         return ad799x_set_scan_mode(st, st->indio_dev->ring->scan_mask);
 109 }
 110
 111 /* Here we claim all are 16 bits. This currently does no harm and saves
 112  * us a lot of scan element listings */
 113
 114 #define AD799X_SCAN_EL(number)                                          \
 115         IIO_SCAN_EL_C(in##number, number, 0, ad799x_scan_el_set_state);
 116
 117 static AD799X_SCAN_EL(0);
 118 static AD799X_SCAN_EL(1);
 119 static AD799X_SCAN_EL(2);
 120 static AD799X_SCAN_EL(3);
 121 static AD799X_SCAN_EL(4);
 122 static AD799X_SCAN_EL(5);
 123 static AD799X_SCAN_EL(6);
 124 static AD799X_SCAN_EL(7);
 125
 126 static ssize_t ad799x_show_type(struct device *dev,
 127                                 struct device_attribute *attr,
 128                                 char *buf)
 129 {
 130         struct iio_ring_buffer *ring = dev_get_drvdata(dev);
 131         struct iio_dev *indio_dev = ring->indio_dev;
 132         struct ad799x_state *st = indio_dev->dev_data;
 133
 134         return sprintf(buf, "%c%d/%d\n", st->chip_info->sign,
 135                        st->chip_info->bits, AD799X_STORAGEBITS);
 136 }
 137 static IIO_DEVICE_ATTR(in_type, S_IRUGO, ad799x_show_type, NULL, 0);
 138
 139 static int ad7991_5_9_set_scan_mode(struct ad799x_state *st, unsigned mask)
 140 {
 141         return i2c_smbus_write_byte(st->client,
 142                 st->config | (mask << AD799X_CHANNEL_SHIFT));
 143 }
 144
 145 static int ad7992_3_4_set_scan_mode(struct ad799x_state *st, unsigned mask)
 146 {
 147         return ad799x_i2c_write8(st, AD7998_CONF_REG,
 148                 st->config | (mask << AD799X_CHANNEL_SHIFT));
 149 }
 150
 151 static int ad7997_8_set_scan_mode(struct ad799x_state *st, unsigned mask)
 152 {
 153         return ad799x_i2c_write16(st, AD7998_CONF_REG,
 154                 st->config | (mask << AD799X_CHANNEL_SHIFT));
 155 }
 156
 157 int ad799x_set_scan_mode(struct ad799x_state *st, unsigned mask)
 158 {
 159         int ret;
 160
 161         if (st->chip_info->ad799x_set_scan_mode != NULL) {
 162                 ret = st->chip_info->ad799x_set_scan_mode(st, mask);
 163                 return (ret > 0) ? 0 : ret;
 164         }
 165
 166         return 0;
 167 }
 168
 169 static ssize_t ad799x_read_single_channel(struct device *dev,
 170                                    struct device_attribute *attr,
 171                                    char *buf)
 172 {
 173         struct iio_dev *dev_info = dev_get_drvdata(dev);
 174         struct ad799x_state *st = iio_dev_get_devdata(dev_info);
 175         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 176         int ret = 0, len = 0;
 177         u32 data ;
 178         u16 rxbuf[1];
 179         u8 cmd;
 180         long mask;
 181
 182         mutex_lock(&dev_info->mlock);
 183         mask = 1 << this_attr->address;
 184         /* If ring buffer capture is occuring, query the buffer */
 185         if (iio_ring_enabled(dev_info)) {
 186                 data = ret = ad799x_single_channel_from_ring(st, mask);
 187                 if (ret < 0)
 188                         goto error_ret;
 189                 ret = 0;
 190         } else {
 191                 switch (st->id) {
 192                 case ad7991:
 193                 case ad7995:
 194                 case ad7999:
 195                         cmd = st->config | (mask << AD799X_CHANNEL_SHIFT);
 196                         break;
 197                 case ad7992:
 198                 case ad7993:
 199                 case ad7994:
 200                         cmd = mask << AD799X_CHANNEL_SHIFT;
 201                         break;
 202                 case ad7997:
 203                 case ad7998:
 204                         cmd = (this_attr->address <<
 205                                 AD799X_CHANNEL_SHIFT) | AD7997_8_READ_SINGLE;
 206                         break;
 207                 default:
 208                         cmd = 0;
 209
 210                 }
 211                 ret = ad799x_i2c_read16(st, cmd, rxbuf);
 212                 if (ret < 0)
 213                         goto error_ret;
 214
 215                 data = rxbuf[0];
 216         }
 217
 218         /* Pretty print the result */
 219         len = sprintf(buf, "%u\n", data & ((1 << (st->chip_info->bits)) - 1));
 220
 221 error_ret:
 222         mutex_unlock(&dev_info->mlock);
 223         return ret ? ret : len;
 224 }
 225
 226 static ssize_t ad799x_read_frequency(struct device *dev,
 227                                         struct device_attribute *attr,
 228                                         char *buf)
 229 {
 230         struct iio_dev *dev_info = dev_get_drvdata(dev);
 231         struct ad799x_state *st = iio_dev_get_devdata(dev_info);
 232
 233         int ret, len = 0;
 234         u8 val;
 235         ret = ad799x_i2c_read8(st, AD7998_CYCLE_TMR_REG, &val);
 236         if (ret)
 237                 return ret;
 238
 239         val &= AD7998_CYC_MASK;
 240
 241         switch (val) {
 242         case AD7998_CYC_DIS:
 243                 len = sprintf(buf, "0\n");
 244                 break;
 245         case AD7998_CYC_TCONF_32:
 246                 len = sprintf(buf, "15625\n");
 247                 break;
 248         case AD7998_CYC_TCONF_64:
 249                 len = sprintf(buf, "7812\n");
 250                 break;
 251         case AD7998_CYC_TCONF_128:
 252                 len = sprintf(buf, "3906\n");
 253                 break;
 254         case AD7998_CYC_TCONF_256:
 255                 len = sprintf(buf, "1953\n");
 256                 break;
 257         case AD7998_CYC_TCONF_512:
 258                 len = sprintf(buf, "976\n");
 259                 break;
 260         case AD7998_CYC_TCONF_1024:
 261                 len = sprintf(buf, "488\n");
 262                 break;
 263         case AD7998_CYC_TCONF_2048:
 264                 len = sprintf(buf, "244\n");
 265                 break;
 266         }
 267         return len;
 268 }
 269
 270 static ssize_t ad799x_write_frequency(struct device *dev,
 271                                          struct device_attribute *attr,
 272                                          const char *buf,
 273                                          size_t len)
 274 {
 275         struct iio_dev *dev_info = dev_get_drvdata(dev);
 276         struct ad799x_state *st = iio_dev_get_devdata(dev_info);
 277
 278         long val;
 279         int ret;
 280         u8 t;
 281
 282         ret = strict_strtol(buf, 10, &val);
 283         if (ret)
 284                 return ret;
 285
 286         mutex_lock(&dev_info->mlock);
 287         ret = ad799x_i2c_read8(st, AD7998_CYCLE_TMR_REG, &t);
 288         if (ret)
 289                 goto error_ret_mutex;
 290         /* Wipe the bits clean */
 291         t &= ~AD7998_CYC_MASK;
 292
 293         switch (val) {
 294         case 15625:
 295                 t |= AD7998_CYC_TCONF_32;
 296                 break;
 297         case 7812:
 298                 t |= AD7998_CYC_TCONF_64;
 299                 break;
 300         case 3906:
 301                 t |= AD7998_CYC_TCONF_128;
 302                 break;
 303         case 1953:
 304                 t |= AD7998_CYC_TCONF_256;
 305                 break;
 306         case 976:
 307                 t |= AD7998_CYC_TCONF_512;
 308                 break;
 309         case 488:
 310                 t |= AD7998_CYC_TCONF_1024;
 311                 break;
 312         case 244:
 313                 t |= AD7998_CYC_TCONF_2048;
 314                 break;
 315         case  0:
 316                 t |= AD7998_CYC_DIS;
 317                 break;
 318         default:
 319                 ret = -EINVAL;
 320                 goto error_ret_mutex;
 321         }
 322
 323         ret = ad799x_i2c_write8(st, AD7998_CYCLE_TMR_REG, t);
 324
 325 error_ret_mutex:
 326         mutex_unlock(&dev_info->mlock);
 327
 328         return ret ? ret : len;
 329 }
 330
 331
 332 static ssize_t ad799x_read_channel_config(struct device *dev,
 333                                         struct device_attribute *attr,
 334                                         char *buf)
 335 {
 336         struct iio_dev *dev_info = dev_get_drvdata(dev);
 337         struct ad799x_state *st = iio_dev_get_devdata(dev_info);
 338         struct iio_event_attr *this_attr = to_iio_event_attr(attr);
 339
 340         int ret;
 341         u16 val;
 342         ret = ad799x_i2c_read16(st, this_attr->mask, &val);
 343         if (ret)
 344                 return ret;
 345
 346         return sprintf(buf, "%d\n", val);
 347 }
 348
 349 static ssize_t ad799x_write_channel_config(struct device *dev,
 350                                          struct device_attribute *attr,
 351                                          const char *buf,
 352                                          size_t len)
 353 {
 354         struct iio_dev *dev_info = dev_get_drvdata(dev);
 355         struct ad799x_state *st = iio_dev_get_devdata(dev_info);
 356         struct iio_event_attr *this_attr = to_iio_event_attr(attr);
 357
 358         long val;
 359         int ret;
 360
 361         ret = strict_strtol(buf, 10, &val);
 362         if (ret)
 363                 return ret;
 364
 365         mutex_lock(&dev_info->mlock);
 366         ret = ad799x_i2c_write16(st, this_attr->mask, val);
 367         mutex_unlock(&dev_info->mlock);
 368
 369         return ret ? ret : len;
 370 }
 371
 372 static void ad799x_interrupt_bh(struct work_struct *work_s)
 373 {
 374         struct ad799x_state *st = container_of(work_s,
 375                 struct ad799x_state, work_thresh);
 376         u8 status;
 377         int i;
 378
 379         if (ad799x_i2c_read8(st, AD7998_ALERT_STAT_REG, &status))
 380                 goto err_out;
 381
 382         if (!status)
 383                 goto err_out;
 384
 385         ad799x_i2c_write8(st, AD7998_ALERT_STAT_REG, AD7998_ALERT_STAT_CLEAR);
 386
 387         for (i = 0; i < 8; i++) {
 388                 if (status & (1 << i))
 389                         iio_push_event(st->indio_dev, 0,
 390                                 i & 0x1 ?
 391                                 IIO_EVENT_CODE_IN_HIGH_THRESH(i >> 1) :
 392                                 IIO_EVENT_CODE_IN_LOW_THRESH(i >> 1),
 393                                 st->last_timestamp);
 394         }
 395
 396 err_out:
 397         enable_irq(st->client->irq);
 398 }
 399
 400 static int ad799x_interrupt(struct iio_dev *dev_info,
 401                 int index,
 402                 s64 timestamp,
 403                 int no_test)
 404 {
 405         struct ad799x_state *st = dev_info->dev_data;
 406
 407         st->last_timestamp = timestamp;
 408         schedule_work(&st->work_thresh);
 409         return 0;
 410 }
 411
 412 IIO_EVENT_SH(ad799x, &ad799x_interrupt);
 413
 414 /* Direct read attribtues */
 415 static IIO_DEV_ATTR_IN_RAW(0, ad799x_read_single_channel, 0);
 416 static IIO_DEV_ATTR_IN_RAW(1, ad799x_read_single_channel, 1);
 417 static IIO_DEV_ATTR_IN_RAW(2, ad799x_read_single_channel, 2);
 418 static IIO_DEV_ATTR_IN_RAW(3, ad799x_read_single_channel, 3);
 419 static IIO_DEV_ATTR_IN_RAW(4, ad799x_read_single_channel, 4);
 420 static IIO_DEV_ATTR_IN_RAW(5, ad799x_read_single_channel, 5);
 421 static IIO_DEV_ATTR_IN_RAW(6, ad799x_read_single_channel, 6);
 422 static IIO_DEV_ATTR_IN_RAW(7, ad799x_read_single_channel, 7);
 423
 424 static ssize_t ad799x_show_scale(struct device *dev,
 425                                 struct device_attribute *attr,
 426                                 char *buf)
 427 {
 428         /* Driver currently only support internal vref */
 429         struct iio_dev *dev_info = dev_get_drvdata(dev);
 430         struct ad799x_state *st = iio_dev_get_devdata(dev_info);
 431
 432         /* Corresponds to Vref / 2^(bits) */
 433         unsigned int scale_uv = (st->int_vref_mv * 1000) >> st->chip_info->bits;
 434
 435         return sprintf(buf, "%d.%d\n", scale_uv / 1000, scale_uv % 1000);
 436 }
 437
 438 static IIO_DEVICE_ATTR(in_scale, S_IRUGO, ad799x_show_scale, NULL, 0);
 439
 440 static ssize_t ad799x_show_name(struct device *dev,
 441                                  struct device_attribute *attr,
 442                                  char *buf)
 443 {
 444         struct iio_dev *dev_info = dev_get_drvdata(dev);
 445         struct ad799x_state *st = iio_dev_get_devdata(dev_info);
 446         return sprintf(buf, "%s\n", st->client->name);
 447 }
 448
 449 static IIO_DEVICE_ATTR(name, S_IRUGO, ad799x_show_name, NULL, 0);
 450
 451 static struct attribute *ad7991_5_9_3_4_device_attrs[] = {
 452         &iio_dev_attr_in0_raw.dev_attr.attr,
 453         &iio_dev_attr_in1_raw.dev_attr.attr,
 454         &iio_dev_attr_in2_raw.dev_attr.attr,
 455         &iio_dev_attr_in3_raw.dev_attr.attr,
 456         &iio_dev_attr_name.dev_attr.attr,
 457         &iio_dev_attr_in_scale.dev_attr.attr,
 458         NULL
 459 };
 460
 461 static struct attribute_group ad7991_5_9_3_4_dev_attr_group = {
 462         .attrs = ad7991_5_9_3_4_device_attrs,
 463 };
 464
 465 static struct attribute *ad7991_5_9_3_4_scan_el_attrs[] = {
 466         &iio_scan_el_in0.dev_attr.attr,
 467         &iio_const_attr_in0_index.dev_attr.attr,
 468         &iio_scan_el_in1.dev_attr.attr,
 469         &iio_const_attr_in1_index.dev_attr.attr,
 470         &iio_scan_el_in2.dev_attr.attr,
 471         &iio_const_attr_in2_index.dev_attr.attr,
 472         &iio_scan_el_in3.dev_attr.attr,
 473         &iio_const_attr_in3_index.dev_attr.attr,
 474         &iio_dev_attr_in_type.dev_attr.attr,
 475         NULL,
 476 };
 477
 478 static struct attribute_group ad7991_5_9_3_4_scan_el_group = {
 479         .name = "scan_elements",
 480         .attrs = ad7991_5_9_3_4_scan_el_attrs,
 481 };
 482
 483 static struct attribute *ad7992_device_attrs[] = {
 484         &iio_dev_attr_in0_raw.dev_attr.attr,
 485         &iio_dev_attr_in1_raw.dev_attr.attr,
 486         &iio_dev_attr_name.dev_attr.attr,
 487         &iio_dev_attr_in_scale.dev_attr.attr,
 488         NULL
 489 };
 490
 491 static struct attribute_group ad7992_dev_attr_group = {
 492         .attrs = ad7992_device_attrs,
 493 };
 494
 495 static struct attribute *ad7992_scan_el_attrs[] = {
 496         &iio_scan_el_in0.dev_attr.attr,
 497         &iio_const_attr_in0_index.dev_attr.attr,
 498         &iio_scan_el_in1.dev_attr.attr,
 499         &iio_const_attr_in1_index.dev_attr.attr,
 500         &iio_dev_attr_in_type.dev_attr.attr,
 501         NULL,
 502 };
 503
 504 static struct attribute_group ad7992_scan_el_group = {
 505         .name = "scan_elements",
 506         .attrs = ad7992_scan_el_attrs,
 507 };
 508
 509 static struct attribute *ad7997_8_device_attrs[] = {
 510         &iio_dev_attr_in0_raw.dev_attr.attr,
 511         &iio_dev_attr_in1_raw.dev_attr.attr,
 512         &iio_dev_attr_in2_raw.dev_attr.attr,
 513         &iio_dev_attr_in3_raw.dev_attr.attr,
 514         &iio_dev_attr_in4_raw.dev_attr.attr,
 515         &iio_dev_attr_in5_raw.dev_attr.attr,
 516         &iio_dev_attr_in6_raw.dev_attr.attr,
 517         &iio_dev_attr_in7_raw.dev_attr.attr,
 518         &iio_dev_attr_name.dev_attr.attr,
 519         &iio_dev_attr_in_scale.dev_attr.attr,
 520         NULL
 521 };
 522
 523 static struct attribute_group ad7997_8_dev_attr_group = {
 524         .attrs = ad7997_8_device_attrs,
 525 };
 526
 527 static struct attribute *ad7997_8_scan_el_attrs[] = {
 528         &iio_scan_el_in0.dev_attr.attr,
 529         &iio_const_attr_in0_index.dev_attr.attr,
 530         &iio_scan_el_in1.dev_attr.attr,
 531         &iio_const_attr_in1_index.dev_attr.attr,
 532         &iio_scan_el_in2.dev_attr.attr,
 533         &iio_const_attr_in2_index.dev_attr.attr,
 534         &iio_scan_el_in3.dev_attr.attr,
 535         &iio_const_attr_in3_index.dev_attr.attr,
 536         &iio_scan_el_in4.dev_attr.attr,
 537         &iio_const_attr_in4_index.dev_attr.attr,
 538         &iio_scan_el_in5.dev_attr.attr,
 539         &iio_const_attr_in5_index.dev_attr.attr,
 540         &iio_scan_el_in6.dev_attr.attr,
 541         &iio_const_attr_in6_index.dev_attr.attr,
 542         &iio_scan_el_in7.dev_attr.attr,
 543         &iio_const_attr_in7_index.dev_attr.attr,
 544         &iio_dev_attr_in_type.dev_attr.attr,
 545         NULL,
 546 };
 547
 548 static struct attribute_group ad7997_8_scan_el_group = {
 549         .name = "scan_elements",
 550         .attrs = ad7997_8_scan_el_attrs,
 551 };
 552
 553 IIO_EVENT_ATTR_SH(in0_thresh_low_value,
 554                   iio_event_ad799x,
 555                   ad799x_read_channel_config,
 556                   ad799x_write_channel_config,
 557                   AD7998_DATALOW_CH1_REG);
 558
 559 IIO_EVENT_ATTR_SH(in0_thresh_high_value,
 560                   iio_event_ad799x,
 561                   ad799x_read_channel_config,
 562                   ad799x_write_channel_config,
 563                   AD7998_DATAHIGH_CH1_REG);
 564
 565 IIO_EVENT_ATTR_SH(in0_thresh_both_hyst_raw,
 566                   iio_event_ad799x,
 567                   ad799x_read_channel_config,
 568                   ad799x_write_channel_config,
 569                   AD7998_HYST_CH1_REG);
 570
 571 IIO_EVENT_ATTR_SH(in1_thresh_low_value,
 572                   iio_event_ad799x,
 573                   ad799x_read_channel_config,
 574                   ad799x_write_channel_config,
 575                   AD7998_DATALOW_CH2_REG);
 576
 577 IIO_EVENT_ATTR_SH(in1_thresh_high_value,
 578                   iio_event_ad799x,
 579                   ad799x_read_channel_config,
 580                   ad799x_write_channel_config,
 581                   AD7998_DATAHIGH_CH2_REG);
 582
 583 IIO_EVENT_ATTR_SH(in1_thresh_both_hyst_raw,
 584                   iio_event_ad799x,
 585                   ad799x_read_channel_config,
 586                   ad799x_write_channel_config,
 587                   AD7998_HYST_CH2_REG);
 588
 589 IIO_EVENT_ATTR_SH(in2_thresh_low_value,
 590                   iio_event_ad799x,
 591                   ad799x_read_channel_config,
 592                   ad799x_write_channel_config,
 593                   AD7998_DATALOW_CH3_REG);
 594
 595 IIO_EVENT_ATTR_SH(in2_thresh_high_value,
 596                   iio_event_ad799x,
 597                   ad799x_read_channel_config,
 598                   ad799x_write_channel_config,
 599                   AD7998_DATAHIGH_CH3_REG);
 600
 601 IIO_EVENT_ATTR_SH(in2_thresh_both_hyst_raw,
 602                   iio_event_ad799x,
 603                   ad799x_read_channel_config,
 604                   ad799x_write_channel_config,
 605                   AD7998_HYST_CH3_REG);
 606
 607 IIO_EVENT_ATTR_SH(in3_thresh_low_value,
 608                   iio_event_ad799x,
 609                   ad799x_read_channel_config,
 610                   ad799x_write_channel_config,
 611                   AD7998_DATALOW_CH4_REG);
 612
 613 IIO_EVENT_ATTR_SH(in3_thresh_high_value,
 614                   iio_event_ad799x,
 615                   ad799x_read_channel_config,
 616                   ad799x_write_channel_config,
 617                   AD7998_DATAHIGH_CH4_REG);
 618
 619 IIO_EVENT_ATTR_SH(in3_thresh_both_hyst_raw,
 620                   iio_event_ad799x,
 621                   ad799x_read_channel_config,
 622                   ad799x_write_channel_config,
 623                   AD7998_HYST_CH4_REG);
 624
 625 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
 626                               ad799x_read_frequency,
 627                               ad799x_write_frequency);
 628 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("15625 7812 3906 1953 976 488 244 0");
 629
 630 static struct attribute *ad7993_4_7_8_event_attributes[] = {
 631         &iio_event_attr_in0_thresh_low_value.dev_attr.attr,
 632         &iio_event_attr_in0_thresh_high_value.dev_attr.attr,
 633         &iio_event_attr_in0_thresh_both_hyst_raw.dev_attr.attr,
 634         &iio_event_attr_in1_thresh_low_value.dev_attr.attr,
 635         &iio_event_attr_in1_thresh_high_value.dev_attr.attr,
 636         &iio_event_attr_in1_thresh_both_hyst_raw.dev_attr.attr,
 637         &iio_event_attr_in2_thresh_low_value.dev_attr.attr,
 638         &iio_event_attr_in2_thresh_high_value.dev_attr.attr,
 639         &iio_event_attr_in2_thresh_both_hyst_raw.dev_attr.attr,
 640         &iio_event_attr_in3_thresh_low_value.dev_attr.attr,
 641         &iio_event_attr_in3_thresh_high_value.dev_attr.attr,
 642         &iio_event_attr_in3_thresh_both_hyst_raw.dev_attr.attr,
 643         &iio_dev_attr_sampling_frequency.dev_attr.attr,
 644         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 645         NULL,
 646 };
 647
 648 static struct attribute_group ad7993_4_7_8_event_attrs_group = {
 649         .attrs = ad7993_4_7_8_event_attributes,
 650 };
 651
 652 static struct attribute *ad7992_event_attributes[] = {
 653         &iio_event_attr_in0_thresh_low_value.dev_attr.attr,
 654         &iio_event_attr_in0_thresh_high_value.dev_attr.attr,
 655         &iio_event_attr_in0_thresh_both_hyst_raw.dev_attr.attr,
 656         &iio_event_attr_in1_thresh_low_value.dev_attr.attr,
 657         &iio_event_attr_in1_thresh_high_value.dev_attr.attr,
 658         &iio_event_attr_in1_thresh_both_hyst_raw.dev_attr.attr,
 659         &iio_dev_attr_sampling_frequency.dev_attr.attr,
 660         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 661         NULL,
 662 };
 663
 664 static struct attribute_group ad7992_event_attrs_group = {
 665         .attrs = ad7992_event_attributes,
 666 };
 667
 668 static const struct ad799x_chip_info ad799x_chip_info_tbl[] = {
 669         [ad7991] = {
 670                 .num_inputs = 4,
 671                 .bits = 12,
 672                 .sign = IIO_SCAN_EL_TYPE_UNSIGNED,
 673                 .int_vref_mv = 4096,
 674                 .dev_attrs = &ad7991_5_9_3_4_dev_attr_group,
 675                 .scan_attrs = &ad7991_5_9_3_4_scan_el_group,
 676                 .ad799x_set_scan_mode = ad7991_5_9_set_scan_mode,
 677         },
 678         [ad7995] = {
 679                 .num_inputs = 4,
 680                 .bits = 10,
 681                 .sign = IIO_SCAN_EL_TYPE_UNSIGNED,
 682                 .int_vref_mv = 1024,
 683                 .dev_attrs = &ad7991_5_9_3_4_dev_attr_group,
 684                 .scan_attrs = &ad7991_5_9_3_4_scan_el_group,
 685                 .ad799x_set_scan_mode = ad7991_5_9_set_scan_mode,
 686         },
 687         [ad7999] = {
 688                 .num_inputs = 4,
 689                 .bits = 10,
 690                 .sign = IIO_SCAN_EL_TYPE_UNSIGNED,
 691                 .int_vref_mv = 1024,
 692                 .dev_attrs = &ad7991_5_9_3_4_dev_attr_group,
 693                 .scan_attrs = &ad7991_5_9_3_4_scan_el_group,
 694                 .ad799x_set_scan_mode = ad7991_5_9_set_scan_mode,
 695         },
 696         [ad7992] = {
 697                 .num_inputs = 2,
 698                 .bits = 12,
 699                 .sign = IIO_SCAN_EL_TYPE_UNSIGNED,
 700                 .int_vref_mv = 4096,
 701                 .monitor_mode = true,
 702                 .default_config = AD7998_ALERT_EN,
 703                 .dev_attrs = &ad7992_dev_attr_group,
 704                 .scan_attrs = &ad7992_scan_el_group,
 705                 .event_attrs = &ad7992_event_attrs_group,
 706                 .ad799x_set_scan_mode = ad7992_3_4_set_scan_mode,
 707         },
 708         [ad7993] = {
 709                 .num_inputs = 4,
 710                 .bits = 10,
 711                 .sign = IIO_SCAN_EL_TYPE_UNSIGNED,
 712                 .int_vref_mv = 1024,
 713                 .monitor_mode = true,
 714                 .default_config = AD7998_ALERT_EN,
 715                 .dev_attrs = &ad7991_5_9_3_4_dev_attr_group,
 716                 .scan_attrs = &ad7991_5_9_3_4_scan_el_group,
 717                 .event_attrs = &ad7993_4_7_8_event_attrs_group,
 718                 .ad799x_set_scan_mode = ad7992_3_4_set_scan_mode,
 719         },
 720         [ad7994] = {
 721                 .num_inputs = 4,
 722                 .bits = 12,
 723                 .sign = IIO_SCAN_EL_TYPE_UNSIGNED,
 724                 .int_vref_mv = 4096,
 725                 .monitor_mode = true,
 726                 .default_config = AD7998_ALERT_EN,
 727                 .dev_attrs = &ad7991_5_9_3_4_dev_attr_group,
 728                 .scan_attrs = &ad7991_5_9_3_4_scan_el_group,
 729                 .event_attrs = &ad7993_4_7_8_event_attrs_group,
 730                 .ad799x_set_scan_mode = ad7992_3_4_set_scan_mode,
 731         },
 732         [ad7997] = {
 733                 .num_inputs = 8,
 734                 .bits = 10,
 735                 .sign = IIO_SCAN_EL_TYPE_UNSIGNED,
 736                 .int_vref_mv = 1024,
 737                 .monitor_mode = true,
 738                 .default_config = AD7998_ALERT_EN,
 739                 .dev_attrs = &ad7997_8_dev_attr_group,
 740                 .scan_attrs = &ad7997_8_scan_el_group,
 741                 .event_attrs = &ad7993_4_7_8_event_attrs_group,
 742                 .ad799x_set_scan_mode = ad7997_8_set_scan_mode,
 743         },
 744         [ad7998] = {
 745                 .num_inputs = 8,
 746                 .bits = 12,
 747                 .sign = IIO_SCAN_EL_TYPE_UNSIGNED,
 748                 .int_vref_mv = 4096,
 749                 .monitor_mode = true,
 750                 .default_config = AD7998_ALERT_EN,
 751                 .dev_attrs = &ad7997_8_dev_attr_group,
 752                 .scan_attrs = &ad7997_8_scan_el_group,
 753                 .event_attrs = &ad7993_4_7_8_event_attrs_group,
 754                 .ad799x_set_scan_mode = ad7997_8_set_scan_mode,
 755         },
 756 };
 757
 758 static int __devinit ad799x_probe(struct i2c_client *client,
 759                                    const struct i2c_device_id *id)
 760 {
 761         int ret, regdone = 0;
 762         struct ad799x_platform_data *pdata = client->dev.platform_data;
 763         struct ad799x_state *st = kzalloc(sizeof(*st), GFP_KERNEL);
 764         if (st == NULL) {
 765                 ret = -ENOMEM;
 766                 goto error_ret;
 767         }
 768
 769         /* this is only used for device removal purposes */
 770         i2c_set_clientdata(client, st);
 771
 772         atomic_set(&st->protect_ring, 0);
 773         st->id = id->driver_data;
 774         st->chip_info = &ad799x_chip_info_tbl[st->id];
 775         st->config = st->chip_info->default_config;
 776
 777         /* TODO: Add pdata options for filtering and bit delay */
 778
 779         if (pdata)
 780                 st->int_vref_mv = pdata->vref_mv;
 781         else
 782                 st->int_vref_mv = st->chip_info->int_vref_mv;
 783
 784         st->reg = regulator_get(&client->dev, "vcc");
 785         if (!IS_ERR(st->reg)) {
 786                 ret = regulator_enable(st->reg);
 787                 if (ret)
 788                         goto error_put_reg;
 789         }
 790         st->client = client;
 791
 792         st->indio_dev = iio_allocate_device();
 793         if (st->indio_dev == NULL) {
 794                 ret = -ENOMEM;
 795                 goto error_disable_reg;
 796         }
 797
 798         /* Estabilish that the iio_dev is a child of the i2c device */
 799         st->indio_dev->dev.parent = &client->dev;
 800         st->indio_dev->attrs = st->chip_info->dev_attrs;
 801         st->indio_dev->event_attrs = st->chip_info->event_attrs;
 802
 803         st->indio_dev->dev_data = (void *)(st);
 804         st->indio_dev->driver_module = THIS_MODULE;
 805         st->indio_dev->modes = INDIO_DIRECT_MODE;
 806         st->indio_dev->num_interrupt_lines = 1;
 807
 808         ret = ad799x_set_scan_mode(st, 0);
 809         if (ret)
 810                 goto error_free_device;
 811
 812         ret = ad799x_register_ring_funcs_and_init(st->indio_dev);
 813         if (ret)
 814                 goto error_free_device;
 815
 816         ret = iio_device_register(st->indio_dev);
 817         if (ret)
 818                 goto error_cleanup_ring;
 819         regdone = 1;
 820
 821         ret = iio_ring_buffer_register(st->indio_dev->ring, 0);
 822         if (ret)
 823                 goto error_cleanup_ring;
 824
 825         if (client->irq > 0 && st->chip_info->monitor_mode) {
 826                 INIT_WORK(&st->work_thresh, ad799x_interrupt_bh);
 827
 828                 ret = iio_register_interrupt_line(client->irq,
 829                                 st->indio_dev,
 830                                 0,
 831                                 IRQF_TRIGGER_FALLING,
 832                                 client->name);
 833                 if (ret)
 834                         goto error_cleanup_ring;
 835
 836                 /*
 837                  * The event handler list element refer to iio_event_ad799x.
 838                  * All event attributes bind to the same event handler.
 839                  * So, only register event handler once.
 840                  */
 841                 iio_add_event_to_list(&iio_event_ad799x,
 842                                 &st->indio_dev->interrupts[0]->ev_list);
 843         }
 844
 845         return 0;
 846 error_cleanup_ring:
 847         ad799x_ring_cleanup(st->indio_dev);
 848 error_free_device:
 849         if (!regdone)
 850                 iio_free_device(st->indio_dev);
 851         else
 852                 iio_device_unregister(st->indio_dev);
 853 error_disable_reg:
 854         if (!IS_ERR(st->reg))
 855                 regulator_disable(st->reg);
 856 error_put_reg:
 857         if (!IS_ERR(st->reg))
 858                 regulator_put(st->reg);
 859         kfree(st);
 860 error_ret:
 861         return ret;
 862 }
 863
 864 static __devexit int ad799x_remove(struct i2c_client *client)
 865 {
 866         struct ad799x_state *st = i2c_get_clientdata(client);
 867         struct iio_dev *indio_dev = st->indio_dev;
 868
 869         if (client->irq > 0 && st->chip_info->monitor_mode)
 870                 iio_unregister_interrupt_line(indio_dev, 0);
 871
 872         iio_ring_buffer_unregister(indio_dev->ring);
 873         ad799x_ring_cleanup(indio_dev);
 874         iio_device_unregister(indio_dev);
 875         if (!IS_ERR(st->reg)) {
 876                 regulator_disable(st->reg);
 877                 regulator_put(st->reg);
 878         }
 879         kfree(st);
 880
 881         return 0;
 882 }
 883
 884 static const struct i2c_device_id ad799x_id[] = {
 885         { "ad7991", ad7991 },
 886         { "ad7995", ad7995 },
 887         { "ad7999", ad7999 },
 888         { "ad7992", ad7992 },
 889         { "ad7993", ad7993 },
 890         { "ad7994", ad7994 },
 891         { "ad7997", ad7997 },
 892         { "ad7998", ad7998 },
 893         {}
 894 };
 895
 896 MODULE_DEVICE_TABLE(i2c, ad799x_id);
 897
 898 static struct i2c_driver ad799x_driver = {
 899         .driver = {
 900                 .name = "ad799x",
 901         },
 902         .probe = ad799x_probe,
 903         .remove = __devexit_p(ad799x_remove),
 904         .id_table = ad799x_id,
 905 };
 906
 907 static __init int ad799x_init(void)
 908 {
 909         return i2c_add_driver(&ad799x_driver);
 910 }
 911
 912 static __exit void ad799x_exit(void)
 913 {
 914         i2c_del_driver(&ad799x_driver);
 915 }
 916
 917 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 918 MODULE_DESCRIPTION("Analog Devices AD799x ADC");
 919 MODULE_LICENSE("GPL v2");
 920 MODULE_ALIAS("i2c:ad799x");
 921
 922 module_init(ad799x_init);
 923 module_exit(ad799x_exit);