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