drivers/staging/iio/impedance-analyzer/ad5933.c

   1 /*
   2  * AD5933 AD5934 Impedance Converter, Network Analyzer
   3  *
   4  * Copyright 2011 Analog Devices Inc.
   5  *
   6  * Licensed under the GPL-2.
   7  */
   8
   9 #include <linux/interrupt.h>
  10 #include <linux/device.h>
  11 #include <linux/kernel.h>
  12 #include <linux/sysfs.h>
  13 #include <linux/i2c.h>
  14 #include <linux/regulator/consumer.h>
  15 #include <linux/slab.h>
  16 #include <linux/types.h>
  17 #include <linux/err.h>
  18 #include <linux/delay.h>
  19 #include <linux/module.h>
  20 #include <asm/div64.h>
  21
  22 #include "../iio.h"
  23 #include "../sysfs.h"
  24 #include "../buffer_generic.h"
  25 #include "../ring_sw.h"
  26
  27 #include "ad5933.h"
  28
  29 /* AD5933/AD5934 Registers */
  30 #define AD5933_REG_CONTROL_HB           0x80    /* R/W, 2 bytes */
  31 #define AD5933_REG_CONTROL_LB           0x81    /* R/W, 2 bytes */
  32 #define AD5933_REG_FREQ_START           0x82    /* R/W, 3 bytes */
  33 #define AD5933_REG_FREQ_INC             0x85    /* R/W, 3 bytes */
  34 #define AD5933_REG_INC_NUM              0x88    /* R/W, 2 bytes, 9 bit */
  35 #define AD5933_REG_SETTLING_CYCLES      0x8A    /* R/W, 2 bytes */
  36 #define AD5933_REG_STATUS               0x8F    /* R, 1 byte */
  37 #define AD5933_REG_TEMP_DATA            0x92    /* R, 2 bytes*/
  38 #define AD5933_REG_REAL_DATA            0x94    /* R, 2 bytes*/
  39 #define AD5933_REG_IMAG_DATA            0x96    /* R, 2 bytes*/
  40
  41 /* AD5933_REG_CONTROL_HB Bits */
  42 #define AD5933_CTRL_INIT_START_FREQ     (0x1 << 4)
  43 #define AD5933_CTRL_START_SWEEP         (0x2 << 4)
  44 #define AD5933_CTRL_INC_FREQ            (0x3 << 4)
  45 #define AD5933_CTRL_REPEAT_FREQ         (0x4 << 4)
  46 #define AD5933_CTRL_MEASURE_TEMP        (0x9 << 4)
  47 #define AD5933_CTRL_POWER_DOWN          (0xA << 4)
  48 #define AD5933_CTRL_STANDBY             (0xB << 4)
  49
  50 #define AD5933_CTRL_RANGE_2000mVpp      (0x0 << 1)
  51 #define AD5933_CTRL_RANGE_200mVpp       (0x1 << 1)
  52 #define AD5933_CTRL_RANGE_400mVpp       (0x2 << 1)
  53 #define AD5933_CTRL_RANGE_1000mVpp      (0x3 << 1)
  54 #define AD5933_CTRL_RANGE(x)            ((x) << 1)
  55
  56 #define AD5933_CTRL_PGA_GAIN_1          (0x1 << 0)
  57 #define AD5933_CTRL_PGA_GAIN_5          (0x0 << 0)
  58
  59 /* AD5933_REG_CONTROL_LB Bits */
  60 #define AD5933_CTRL_RESET               (0x1 << 4)
  61 #define AD5933_CTRL_INT_SYSCLK          (0x0 << 3)
  62 #define AD5933_CTRL_EXT_SYSCLK          (0x1 << 3)
  63
  64 /* AD5933_REG_STATUS Bits */
  65 #define AD5933_STAT_TEMP_VALID          (0x1 << 0)
  66 #define AD5933_STAT_DATA_VALID          (0x1 << 1)
  67 #define AD5933_STAT_SWEEP_DONE          (0x1 << 2)
  68
  69 /* I2C Block Commands */
  70 #define AD5933_I2C_BLOCK_WRITE          0xA0
  71 #define AD5933_I2C_BLOCK_READ           0xA1
  72 #define AD5933_I2C_ADDR_POINTER         0xB0
  73
  74 /* Device Specs */
  75 #define AD5933_INT_OSC_FREQ_Hz          16776000
  76 #define AD5933_MAX_OUTPUT_FREQ_Hz       100000
  77 #define AD5933_MAX_RETRIES              100
  78
  79 #define AD5933_OUT_RANGE                1
  80 #define AD5933_OUT_RANGE_AVAIL          2
  81 #define AD5933_OUT_SETTLING_CYCLES      3
  82 #define AD5933_IN_PGA_GAIN              4
  83 #define AD5933_IN_PGA_GAIN_AVAIL        5
  84 #define AD5933_FREQ_POINTS              6
  85
  86 #define AD5933_POLL_TIME_ms             10
  87 #define AD5933_INIT_EXCITATION_TIME_ms  100
  88
  89 struct ad5933_state {
  90         struct i2c_client               *client;
  91         struct regulator                *reg;
  92         struct ad5933_platform_data     *pdata;
  93         struct delayed_work             work;
  94         unsigned long                   mclk_hz;
  95         unsigned char                   ctrl_hb;
  96         unsigned char                   ctrl_lb;
  97         unsigned                        range_avail[4];
  98         unsigned short                  vref_mv;
  99         unsigned short                  settling_cycles;
 100         unsigned short                  freq_points;
 101         unsigned                        freq_start;
 102         unsigned                        freq_inc;
 103         unsigned                        state;
 104         unsigned                        poll_time_jiffies;
 105 };
 106
 107 static struct ad5933_platform_data ad5933_default_pdata  = {
 108         .vref_mv = 3300,
 109 };
 110
 111 static struct iio_chan_spec ad5933_channels[] = {
 112         IIO_CHAN(IIO_TEMP, 0, 1, 1, NULL, 0, 0, 0,
 113                  0, AD5933_REG_TEMP_DATA, IIO_ST('s', 14, 16, 0), 0),
 114         /* Ring Channels */
 115         IIO_CHAN(IIO_VOLTAGE, 0, 1, 0, "real_raw", 0, 0,
 116                  (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 117                  AD5933_REG_REAL_DATA, 0, IIO_ST('s', 16, 16, 0), 0),
 118         IIO_CHAN(IIO_VOLTAGE, 0, 1, 0, "imag_raw", 0, 0,
 119                  (1 << IIO_CHAN_INFO_SCALE_SEPARATE),
 120                  AD5933_REG_IMAG_DATA, 1, IIO_ST('s', 16, 16, 0), 0),
 121 };
 122
 123 static int ad5933_i2c_write(struct i2c_client *client,
 124                               u8 reg, u8 len, u8 *data)
 125 {
 126         int ret;
 127
 128         while (len--) {
 129                 ret = i2c_smbus_write_byte_data(client, reg++, *data++);
 130                 if (ret < 0) {
 131                         dev_err(&client->dev, "I2C write error\n");
 132                         return ret;
 133                 }
 134         }
 135         return 0;
 136 }
 137
 138 static int ad5933_i2c_read(struct i2c_client *client,
 139                               u8 reg, u8 len, u8 *data)
 140 {
 141         int ret;
 142
 143         while (len--) {
 144                 ret = i2c_smbus_read_byte_data(client, reg++);
 145                 if (ret < 0) {
 146                         dev_err(&client->dev, "I2C read error\n");
 147                         return ret;
 148                 }
 149                 *data++ = ret;
 150         }
 151         return 0;
 152 }
 153
 154 static int ad5933_cmd(struct ad5933_state *st, unsigned char cmd)
 155 {
 156         unsigned char dat = st->ctrl_hb | cmd;
 157
 158         return ad5933_i2c_write(st->client,
 159                         AD5933_REG_CONTROL_HB, 1, &dat);
 160 }
 161
 162 static int ad5933_reset(struct ad5933_state *st)
 163 {
 164         unsigned char dat = st->ctrl_lb | AD5933_CTRL_RESET;
 165         return ad5933_i2c_write(st->client,
 166                         AD5933_REG_CONTROL_LB, 1, &dat);
 167 }
 168
 169 static int ad5933_wait_busy(struct ad5933_state *st, unsigned char event)
 170 {
 171         unsigned char val, timeout = AD5933_MAX_RETRIES;
 172         int ret;
 173
 174         while (timeout--) {
 175                 ret =  ad5933_i2c_read(st->client, AD5933_REG_STATUS, 1, &val);
 176                 if (ret < 0)
 177                         return ret;
 178                 if (val & event)
 179                         return val;
 180                 cpu_relax();
 181                 mdelay(1);
 182         }
 183
 184         return -EAGAIN;
 185 }
 186
 187 static int ad5933_set_freq(struct ad5933_state *st,
 188                            unsigned reg, unsigned long freq)
 189 {
 190         unsigned long long freqreg;
 191         union {
 192                 u32 d32;
 193                 u8 d8[4];
 194         } dat;
 195
 196         freqreg = (u64) freq * (u64) (1 << 27);
 197         do_div(freqreg, st->mclk_hz / 4);
 198
 199         switch (reg) {
 200         case AD5933_REG_FREQ_START:
 201                 st->freq_start = freq;
 202                 break;
 203         case AD5933_REG_FREQ_INC:
 204                 st->freq_inc = freq;
 205                 break;
 206         default:
 207                 return -EINVAL;
 208         }
 209
 210         dat.d32 = cpu_to_be32(freqreg);
 211         return ad5933_i2c_write(st->client, reg, 3, &dat.d8[1]);
 212 }
 213
 214 static int ad5933_setup(struct ad5933_state *st)
 215 {
 216         unsigned short dat;
 217         int ret;
 218
 219         ret = ad5933_reset(st);
 220         if (ret < 0)
 221                 return ret;
 222
 223         ret = ad5933_set_freq(st, AD5933_REG_FREQ_START, 10000);
 224         if (ret < 0)
 225                 return ret;
 226
 227         ret = ad5933_set_freq(st, AD5933_REG_FREQ_INC, 200);
 228         if (ret < 0)
 229                 return ret;
 230
 231         st->settling_cycles = 10;
 232         dat = cpu_to_be16(st->settling_cycles);
 233
 234         ret = ad5933_i2c_write(st->client,
 235                         AD5933_REG_SETTLING_CYCLES, 2, (u8 *)&dat);
 236         if (ret < 0)
 237                 return ret;
 238
 239         st->freq_points = 100;
 240         dat = cpu_to_be16(st->freq_points);
 241
 242         return ad5933_i2c_write(st->client, AD5933_REG_INC_NUM, 2, (u8 *)&dat);
 243 }
 244
 245 static void ad5933_calc_out_ranges(struct ad5933_state *st)
 246 {
 247         int i;
 248         unsigned normalized_3v3[4] = {1980, 198, 383, 970};
 249
 250         for (i = 0; i < 4; i++)
 251                 st->range_avail[i] = normalized_3v3[i] * st->vref_mv / 3300;
 252
 253 }
 254
 255 /*
 256  * handles: AD5933_REG_FREQ_START and AD5933_REG_FREQ_INC
 257  */
 258
 259 static ssize_t ad5933_show_frequency(struct device *dev,
 260                                         struct device_attribute *attr,
 261                                         char *buf)
 262 {
 263         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 264         struct ad5933_state *st = iio_priv(indio_dev);
 265         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 266         int ret;
 267         unsigned long long freqreg;
 268         union {
 269                 u32 d32;
 270                 u8 d8[4];
 271         } dat;
 272
 273         mutex_lock(&indio_dev->mlock);
 274         ret = ad5933_i2c_read(st->client, this_attr->address, 3, &dat.d8[1]);
 275         mutex_unlock(&indio_dev->mlock);
 276         if (ret < 0)
 277                 return ret;
 278
 279         freqreg = be32_to_cpu(dat.d32) & 0xFFFFFF;
 280
 281         freqreg = (u64) freqreg * (u64) (st->mclk_hz / 4);
 282         do_div(freqreg, 1 << 27);
 283
 284         return sprintf(buf, "%d\n", (int) freqreg);
 285 }
 286
 287 static ssize_t ad5933_store_frequency(struct device *dev,
 288                                          struct device_attribute *attr,
 289                                          const char *buf,
 290                                          size_t len)
 291 {
 292         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 293         struct ad5933_state *st = iio_priv(indio_dev);
 294         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 295         long val;
 296         int ret;
 297
 298         ret = strict_strtoul(buf, 10, &val);
 299         if (ret)
 300                 return ret;
 301
 302         if (val > AD5933_MAX_OUTPUT_FREQ_Hz)
 303                 return -EINVAL;
 304
 305         mutex_lock(&indio_dev->mlock);
 306         ret = ad5933_set_freq(st, this_attr->address, val);
 307         mutex_unlock(&indio_dev->mlock);
 308
 309         return ret ? ret : len;
 310 }
 311
 312 static IIO_DEVICE_ATTR(out_voltage0_freq_start, S_IRUGO | S_IWUSR,
 313                         ad5933_show_frequency,
 314                         ad5933_store_frequency,
 315                         AD5933_REG_FREQ_START);
 316
 317 static IIO_DEVICE_ATTR(out_voltage0_freq_increment, S_IRUGO | S_IWUSR,
 318                         ad5933_show_frequency,
 319                         ad5933_store_frequency,
 320                         AD5933_REG_FREQ_INC);
 321
 322 static ssize_t ad5933_show(struct device *dev,
 323                                         struct device_attribute *attr,
 324                                         char *buf)
 325 {
 326         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 327         struct ad5933_state *st = iio_priv(indio_dev);
 328         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 329         int ret = 0, len = 0;
 330
 331         mutex_lock(&indio_dev->mlock);
 332         switch (this_attr->address) {
 333         case AD5933_OUT_RANGE:
 334                 len = sprintf(buf, "%d\n",
 335                               st->range_avail[(st->ctrl_hb >> 1) & 0x3]);
 336                 break;
 337         case AD5933_OUT_RANGE_AVAIL:
 338                 len = sprintf(buf, "%d %d %d %d\n", st->range_avail[0],
 339                               st->range_avail[3], st->range_avail[2],
 340                               st->range_avail[1]);
 341                 break;
 342         case AD5933_OUT_SETTLING_CYCLES:
 343                 len = sprintf(buf, "%d\n", st->settling_cycles);
 344                 break;
 345         case AD5933_IN_PGA_GAIN:
 346                 len = sprintf(buf, "%s\n",
 347                               (st->ctrl_hb & AD5933_CTRL_PGA_GAIN_1) ?
 348                               "1" : "0.2");
 349                 break;
 350         case AD5933_IN_PGA_GAIN_AVAIL:
 351                 len = sprintf(buf, "1 0.2\n");
 352                 break;
 353         case AD5933_FREQ_POINTS:
 354                 len = sprintf(buf, "%d\n", st->freq_points);
 355                 break;
 356         default:
 357                 ret = -EINVAL;
 358         }
 359
 360         mutex_unlock(&indio_dev->mlock);
 361         return ret ? ret : len;
 362 }
 363
 364 static ssize_t ad5933_store(struct device *dev,
 365                                          struct device_attribute *attr,
 366                                          const char *buf,
 367                                          size_t len)
 368 {
 369         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 370         struct ad5933_state *st = iio_priv(indio_dev);
 371         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 372         long val;
 373         int i, ret = 0;
 374         unsigned short dat;
 375
 376         if (this_attr->address != AD5933_IN_PGA_GAIN) {
 377                 ret = strict_strtol(buf, 10, &val);
 378                 if (ret)
 379                         return ret;
 380         }
 381
 382         mutex_lock(&indio_dev->mlock);
 383         switch (this_attr->address) {
 384         case AD5933_OUT_RANGE:
 385                 for (i = 0; i < 4; i++)
 386                         if (val == st->range_avail[i]) {
 387                                 st->ctrl_hb &= ~AD5933_CTRL_RANGE(0x3);
 388                                 st->ctrl_hb |= AD5933_CTRL_RANGE(i);
 389                                 ret = ad5933_cmd(st, 0);
 390                                 break;
 391                         }
 392                 ret = -EINVAL;
 393                 break;
 394         case AD5933_IN_PGA_GAIN:
 395                 if (sysfs_streq(buf, "1")) {
 396                         st->ctrl_hb |= AD5933_CTRL_PGA_GAIN_1;
 397                 } else if (sysfs_streq(buf, "0.2")) {
 398                         st->ctrl_hb &= ~AD5933_CTRL_PGA_GAIN_1;
 399                 } else {
 400                         ret = -EINVAL;
 401                         break;
 402                 }
 403                 ret = ad5933_cmd(st, 0);
 404                 break;
 405         case AD5933_OUT_SETTLING_CYCLES:
 406                 val = clamp(val, 0L, 0x7FFL);
 407                 st->settling_cycles = val;
 408
 409                 /* 2x, 4x handling, see datasheet */
 410                 if (val > 511)
 411                         val = (val >> 1) | (1 << 9);
 412                 else if (val > 1022)
 413                         val = (val >> 2) | (3 << 9);
 414
 415                 dat = cpu_to_be16(val);
 416                 ret = ad5933_i2c_write(st->client,
 417                                 AD5933_REG_SETTLING_CYCLES, 2, (u8 *)&dat);
 418                 break;
 419         case AD5933_FREQ_POINTS:
 420                 val = clamp(val, 0L, 511L);
 421                 st->freq_points = val;
 422
 423                 dat = cpu_to_be16(val);
 424                 ret = ad5933_i2c_write(st->client, AD5933_REG_INC_NUM, 2,
 425                                        (u8 *)&dat);
 426                 break;
 427         default:
 428                 ret = -EINVAL;
 429         }
 430
 431         mutex_unlock(&indio_dev->mlock);
 432         return ret ? ret : len;
 433 }
 434
 435 static IIO_DEVICE_ATTR(out_voltage0_scale, S_IRUGO | S_IWUSR,
 436                         ad5933_show,
 437                         ad5933_store,
 438                         AD5933_OUT_RANGE);
 439
 440 static IIO_DEVICE_ATTR(out_voltage0_scale_available, S_IRUGO,
 441                         ad5933_show,
 442                         NULL,
 443                         AD5933_OUT_RANGE_AVAIL);
 444
 445 static IIO_DEVICE_ATTR(in_voltage0_scale, S_IRUGO | S_IWUSR,
 446                         ad5933_show,
 447                         ad5933_store,
 448                         AD5933_IN_PGA_GAIN);
 449
 450 static IIO_DEVICE_ATTR(in_voltage0_scale_available, S_IRUGO,
 451                         ad5933_show,
 452                         NULL,
 453                         AD5933_IN_PGA_GAIN_AVAIL);
 454
 455 static IIO_DEVICE_ATTR(out_voltage0_freq_points, S_IRUGO | S_IWUSR,
 456                         ad5933_show,
 457                         ad5933_store,
 458                         AD5933_FREQ_POINTS);
 459
 460 static IIO_DEVICE_ATTR(out_voltage0_settling_cycles, S_IRUGO | S_IWUSR,
 461                         ad5933_show,
 462                         ad5933_store,
 463                         AD5933_OUT_SETTLING_CYCLES);
 464
 465 /* note:
 466  * ideally we would handle the scale attributes via the iio_info
 467  * (read|write)_raw methods, however this part is a untypical since we
 468  * don't create dedicated sysfs channel attributes for out0 and in0.
 469  */
 470 static struct attribute *ad5933_attributes[] = {
 471         &iio_dev_attr_out_voltage0_scale.dev_attr.attr,
 472         &iio_dev_attr_out_voltage0_scale_available.dev_attr.attr,
 473         &iio_dev_attr_out_voltage0_freq_start.dev_attr.attr,
 474         &iio_dev_attr_out_voltage0_freq_increment.dev_attr.attr,
 475         &iio_dev_attr_out_voltage0_freq_points.dev_attr.attr,
 476         &iio_dev_attr_out_voltage0_settling_cycles.dev_attr.attr,
 477         &iio_dev_attr_in_voltage0_scale.dev_attr.attr,
 478         &iio_dev_attr_in_voltage0_scale_available.dev_attr.attr,
 479         NULL
 480 };
 481
 482 static const struct attribute_group ad5933_attribute_group = {
 483         .attrs = ad5933_attributes,
 484 };
 485
 486 static int ad5933_read_raw(struct iio_dev *indio_dev,
 487                            struct iio_chan_spec const *chan,
 488                            int *val,
 489                            int *val2,
 490                            long m)
 491 {
 492         struct ad5933_state *st = iio_priv(indio_dev);
 493         unsigned short dat;
 494         int ret = -EINVAL;
 495
 496         mutex_lock(&indio_dev->mlock);
 497         switch (m) {
 498         case 0:
 499                 if (iio_buffer_enabled(indio_dev)) {
 500                         ret = -EBUSY;
 501                         goto out;
 502                 }
 503                 ret = ad5933_cmd(st, AD5933_CTRL_MEASURE_TEMP);
 504                 if (ret < 0)
 505                         goto out;
 506                 ret = ad5933_wait_busy(st, AD5933_STAT_TEMP_VALID);
 507                 if (ret < 0)
 508                         goto out;
 509
 510                 ret = ad5933_i2c_read(st->client,
 511                                 AD5933_REG_TEMP_DATA, 2,
 512                                 (u8 *)&dat);
 513                 if (ret < 0)
 514                         goto out;
 515                 mutex_unlock(&indio_dev->mlock);
 516                 ret = be16_to_cpu(dat);
 517                 /* Temp in Milli degrees Celsius */
 518                 if (ret < 8192)
 519                         *val = ret * 1000 / 32;
 520                 else
 521                         *val = (ret - 16384) * 1000 / 32;
 522
 523                 return IIO_VAL_INT;
 524         }
 525
 526 out:
 527         mutex_unlock(&indio_dev->mlock);
 528         return ret;
 529 }
 530
 531 static const struct iio_info ad5933_info = {
 532         .read_raw = &ad5933_read_raw,
 533         .attrs = &ad5933_attribute_group,
 534         .driver_module = THIS_MODULE,
 535 };
 536
 537 static int ad5933_ring_preenable(struct iio_dev *indio_dev)
 538 {
 539         struct ad5933_state *st = iio_priv(indio_dev);
 540         struct iio_buffer *ring = indio_dev->buffer;
 541         size_t d_size;
 542         int ret;
 543
 544         if (!ring->scan_count)
 545                 return -EINVAL;
 546
 547         d_size = ring->scan_count *
 548                  ad5933_channels[1].scan_type.storagebits / 8;
 549
 550         if (indio_dev->buffer->access->set_bytes_per_datum)
 551                 indio_dev->buffer->access->
 552                         set_bytes_per_datum(indio_dev->buffer, d_size);
 553
 554         ret = ad5933_reset(st);
 555         if (ret < 0)
 556                 return ret;
 557
 558         ret = ad5933_cmd(st, AD5933_CTRL_STANDBY);
 559         if (ret < 0)
 560                 return ret;
 561
 562         ret = ad5933_cmd(st, AD5933_CTRL_INIT_START_FREQ);
 563         if (ret < 0)
 564                 return ret;
 565
 566         st->state = AD5933_CTRL_INIT_START_FREQ;
 567
 568         return 0;
 569 }
 570
 571 static int ad5933_ring_postenable(struct iio_dev *indio_dev)
 572 {
 573         struct ad5933_state *st = iio_priv(indio_dev);
 574
 575         /* AD5933_CTRL_INIT_START_FREQ:
 576          * High Q complex circuits require a long time to reach steady state.
 577          * To facilitate the measurement of such impedances, this mode allows
 578          * the user full control of the settling time requirement before
 579          * entering start frequency sweep mode where the impedance measurement
 580          * takes place. In this mode the impedance is excited with the
 581          * programmed start frequency (ad5933_ring_preenable),
 582          * but no measurement takes place.
 583          */
 584
 585         schedule_delayed_work(&st->work,
 586                               msecs_to_jiffies(AD5933_INIT_EXCITATION_TIME_ms));
 587         return 0;
 588 }
 589
 590 static int ad5933_ring_postdisable(struct iio_dev *indio_dev)
 591 {
 592         struct ad5933_state *st = iio_priv(indio_dev);
 593
 594         cancel_delayed_work_sync(&st->work);
 595         return ad5933_cmd(st, AD5933_CTRL_POWER_DOWN);
 596 }
 597
 598 static const struct iio_buffer_setup_ops ad5933_ring_setup_ops = {
 599         .preenable = &ad5933_ring_preenable,
 600         .postenable = &ad5933_ring_postenable,
 601         .postdisable = &ad5933_ring_postdisable,
 602 };
 603
 604 static int ad5933_register_ring_funcs_and_init(struct iio_dev *indio_dev)
 605 {
 606         indio_dev->buffer = iio_sw_rb_allocate(indio_dev);
 607         if (!indio_dev->buffer)
 608                 return -ENOMEM;
 609
 610         /* Effectively select the ring buffer implementation */
 611         indio_dev->buffer->access = &ring_sw_access_funcs;
 612
 613         /* Ring buffer functions - here trigger setup related */
 614         indio_dev->buffer->setup_ops = &ad5933_ring_setup_ops;
 615
 616         indio_dev->modes |= INDIO_BUFFER_HARDWARE;
 617
 618         return 0;
 619 }
 620
 621 static void ad5933_work(struct work_struct *work)
 622 {
 623         struct ad5933_state *st = container_of(work,
 624                 struct ad5933_state, work.work);
 625         struct iio_dev *indio_dev = i2c_get_clientdata(st->client);
 626         struct iio_buffer *ring = indio_dev->buffer;
 627         signed short buf[2];
 628         unsigned char status;
 629
 630         mutex_lock(&indio_dev->mlock);
 631         if (st->state == AD5933_CTRL_INIT_START_FREQ) {
 632                 /* start sweep */
 633                 ad5933_cmd(st, AD5933_CTRL_START_SWEEP);
 634                 st->state = AD5933_CTRL_START_SWEEP;
 635                 schedule_delayed_work(&st->work, st->poll_time_jiffies);
 636                 mutex_unlock(&indio_dev->mlock);
 637                 return;
 638         }
 639
 640         ad5933_i2c_read(st->client, AD5933_REG_STATUS, 1, &status);
 641
 642         if (status & AD5933_STAT_DATA_VALID) {
 643                 ad5933_i2c_read(st->client,
 644                                 test_bit(1, ring->scan_mask) ?
 645                                 AD5933_REG_REAL_DATA : AD5933_REG_IMAG_DATA,
 646                                 ring->scan_count * 2, (u8 *)buf);
 647
 648                 if (ring->scan_count == 2) {
 649                         buf[0] = be16_to_cpu(buf[0]);
 650                         buf[1] = be16_to_cpu(buf[1]);
 651                 } else {
 652                         buf[0] = be16_to_cpu(buf[0]);
 653                 }
 654                 /* save datum to the ring */
 655                 ring->access->store_to(ring, (u8 *)buf, iio_get_time_ns());
 656         } else {
 657                 /* no data available - try again later */
 658                 schedule_delayed_work(&st->work, st->poll_time_jiffies);
 659                 mutex_unlock(&indio_dev->mlock);
 660                 return;
 661         }
 662
 663         if (status & AD5933_STAT_SWEEP_DONE) {
 664                 /* last sample received - power down do nothing until
 665                  * the ring enable is toggled */
 666                 ad5933_cmd(st, AD5933_CTRL_POWER_DOWN);
 667         } else {
 668                 /* we just received a valid datum, move on to the next */
 669                 ad5933_cmd(st, AD5933_CTRL_INC_FREQ);
 670                 schedule_delayed_work(&st->work, st->poll_time_jiffies);
 671         }
 672
 673         mutex_unlock(&indio_dev->mlock);
 674 }
 675
 676 static int __devinit ad5933_probe(struct i2c_client *client,
 677                                    const struct i2c_device_id *id)
 678 {
 679         int ret, voltage_uv = 0;
 680         struct ad5933_platform_data *pdata = client->dev.platform_data;
 681         struct ad5933_state *st;
 682         struct iio_dev *indio_dev = iio_allocate_device(sizeof(*st));
 683         if (indio_dev == NULL)
 684                 return -ENOMEM;
 685
 686         st = iio_priv(indio_dev);
 687         i2c_set_clientdata(client, indio_dev);
 688         st->client = client;
 689
 690         if (!pdata)
 691                 st->pdata = &ad5933_default_pdata;
 692         else
 693                 st->pdata = pdata;
 694
 695         st->reg = regulator_get(&client->dev, "vcc");
 696         if (!IS_ERR(st->reg)) {
 697                 ret = regulator_enable(st->reg);
 698                 if (ret)
 699                         goto error_put_reg;
 700                 voltage_uv = regulator_get_voltage(st->reg);
 701         }
 702
 703         if (voltage_uv)
 704                 st->vref_mv = voltage_uv / 1000;
 705         else
 706                 st->vref_mv = st->pdata->vref_mv;
 707
 708         if (st->pdata->ext_clk_Hz) {
 709                 st->mclk_hz = st->pdata->ext_clk_Hz;
 710                 st->ctrl_lb = AD5933_CTRL_EXT_SYSCLK;
 711         } else {
 712                 st->mclk_hz = AD5933_INT_OSC_FREQ_Hz;
 713                 st->ctrl_lb = AD5933_CTRL_INT_SYSCLK;
 714         }
 715
 716         ad5933_calc_out_ranges(st);
 717         INIT_DELAYED_WORK(&st->work, ad5933_work);
 718         st->poll_time_jiffies = msecs_to_jiffies(AD5933_POLL_TIME_ms);
 719
 720         indio_dev->dev.parent = &client->dev;
 721         indio_dev->info = &ad5933_info;
 722         indio_dev->name = id->name;
 723         indio_dev->modes = INDIO_DIRECT_MODE;
 724         indio_dev->channels = ad5933_channels;
 725         indio_dev->num_channels = 1; /* only register temp0_input */
 726
 727         ret = ad5933_register_ring_funcs_and_init(indio_dev);
 728         if (ret)
 729                 goto error_disable_reg;
 730
 731         /* skip temp0_input, register in0_(real|imag)_raw */
 732         ret = iio_buffer_register(indio_dev, &ad5933_channels[1], 2);
 733         if (ret)
 734                 goto error_unreg_ring;
 735
 736         /* enable both REAL and IMAG channels by default */
 737         iio_scan_mask_set(indio_dev->buffer, 0);
 738         iio_scan_mask_set(indio_dev->buffer, 1);
 739
 740         ret = ad5933_setup(st);
 741         if (ret)
 742                 goto error_uninitialize_ring;
 743
 744         ret = iio_device_register(indio_dev);
 745         if (ret)
 746                 goto error_uninitialize_ring;
 747
 748         return 0;
 749
 750 error_uninitialize_ring:
 751         iio_buffer_unregister(indio_dev);
 752 error_unreg_ring:
 753         iio_sw_rb_free(indio_dev->buffer);
 754 error_disable_reg:
 755         if (!IS_ERR(st->reg))
 756                 regulator_disable(st->reg);
 757 error_put_reg:
 758         if (!IS_ERR(st->reg))
 759                 regulator_put(st->reg);
 760
 761         iio_free_device(indio_dev);
 762
 763         return ret;
 764 }
 765
 766 static __devexit int ad5933_remove(struct i2c_client *client)
 767 {
 768         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 769         struct ad5933_state *st = iio_priv(indio_dev);
 770
 771         iio_device_unregister(indio_dev);
 772         iio_buffer_unregister(indio_dev);
 773         iio_sw_rb_free(indio_dev->buffer);
 774         if (!IS_ERR(st->reg)) {
 775                 regulator_disable(st->reg);
 776                 regulator_put(st->reg);
 777         }
 778         iio_free_device(indio_dev);
 779
 780         return 0;
 781 }
 782
 783 static const struct i2c_device_id ad5933_id[] = {
 784         { "ad5933", 0 },
 785         { "ad5934", 0 },
 786         {}
 787 };
 788
 789 MODULE_DEVICE_TABLE(i2c, ad5933_id);
 790
 791 static struct i2c_driver ad5933_driver = {
 792         .driver = {
 793                 .name = "ad5933",
 794         },
 795         .probe = ad5933_probe,
 796         .remove = __devexit_p(ad5933_remove),
 797         .id_table = ad5933_id,
 798 };
 799
 800 static __init int ad5933_init(void)
 801 {
 802         return i2c_add_driver(&ad5933_driver);
 803 }
 804 module_init(ad5933_init);
 805
 806 static __exit void ad5933_exit(void)
 807 {
 808         i2c_del_driver(&ad5933_driver);
 809 }
 810 module_exit(ad5933_exit);
 811
 812 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 813 MODULE_DESCRIPTION("Analog Devices AD5933 Impedance Conv. Network Analyzer");
 814 MODULE_LICENSE("GPL v2");