drivers/staging/iio/adc/ad7606_core.c

   1 /*
   2  * AD7606 SPI ADC driver
   3  *
   4  * Copyright 2011 Analog Devices Inc.
   5  *
   6  * Licensed under the GPL-2.
   7  */
   8
   9 #include <linux/interrupt.h>
  10 #include <linux/workqueue.h>
  11 #include <linux/device.h>
  12 #include <linux/kernel.h>
  13 #include <linux/slab.h>
  14 #include <linux/sysfs.h>
  15 #include <linux/list.h>
  16 #include <linux/regulator/consumer.h>
  17 #include <linux/err.h>
  18 #include <linux/gpio.h>
  19 #include <linux/delay.h>
  20 #include <linux/sched.h>
  21
  22 #include "../iio.h"
  23 #include "../sysfs.h"
  24 #include "../ring_generic.h"
  25 #include "adc.h"
  26
  27 #include "ad7606.h"
  28
  29 int ad7606_reset(struct ad7606_state *st)
  30 {
  31         if (st->have_reset) {
  32                 gpio_set_value(st->pdata->gpio_reset, 1);
  33                 ndelay(100); /* t_reset >= 100ns */
  34                 gpio_set_value(st->pdata->gpio_reset, 0);
  35                 return 0;
  36         }
  37
  38         return -ENODEV;
  39 }
  40
  41 static int ad7606_scan_direct(struct ad7606_state *st, unsigned ch)
  42 {
  43         int ret;
  44
  45         st->done = false;
  46         gpio_set_value(st->pdata->gpio_convst, 1);
  47
  48         ret = wait_event_interruptible(st->wq_data_avail, st->done);
  49         if (ret)
  50                 goto error_ret;
  51
  52         if (st->have_frstdata) {
  53                 ret = st->bops->read_block(st->dev, 1, st->data);
  54                 if (ret)
  55                         goto error_ret;
  56                 if (!gpio_get_value(st->pdata->gpio_frstdata)) {
  57                         /* This should never happen */
  58                         ad7606_reset(st);
  59                         ret = -EIO;
  60                         goto error_ret;
  61                 }
  62                 ret = st->bops->read_block(st->dev,
  63                         st->chip_info->num_channels - 1, &st->data[1]);
  64                 if (ret)
  65                         goto error_ret;
  66         } else {
  67                 ret = st->bops->read_block(st->dev,
  68                         st->chip_info->num_channels, st->data);
  69                 if (ret)
  70                         goto error_ret;
  71         }
  72
  73         ret = st->data[ch];
  74
  75 error_ret:
  76         gpio_set_value(st->pdata->gpio_convst, 0);
  77
  78         return ret;
  79 }
  80
  81 static ssize_t ad7606_scan(struct device *dev,
  82                             struct device_attribute *attr,
  83                             char *buf)
  84 {
  85         struct iio_dev *dev_info = dev_get_drvdata(dev);
  86         struct ad7606_state *st = dev_info->dev_data;
  87         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
  88         int ret;
  89
  90         mutex_lock(&dev_info->mlock);
  91         if (iio_ring_enabled(dev_info))
  92                 ret = ad7606_scan_from_ring(st, this_attr->address);
  93         else
  94                 ret = ad7606_scan_direct(st, this_attr->address);
  95         mutex_unlock(&dev_info->mlock);
  96
  97         if (ret < 0)
  98                 return ret;
  99
 100         return sprintf(buf, "%d\n", (short) ret);
 101 }
 102
 103 static IIO_DEV_ATTR_IN_RAW(0, ad7606_scan, 0);
 104 static IIO_DEV_ATTR_IN_RAW(1, ad7606_scan, 1);
 105 static IIO_DEV_ATTR_IN_RAW(2, ad7606_scan, 2);
 106 static IIO_DEV_ATTR_IN_RAW(3, ad7606_scan, 3);
 107 static IIO_DEV_ATTR_IN_RAW(4, ad7606_scan, 4);
 108 static IIO_DEV_ATTR_IN_RAW(5, ad7606_scan, 5);
 109 static IIO_DEV_ATTR_IN_RAW(6, ad7606_scan, 6);
 110 static IIO_DEV_ATTR_IN_RAW(7, ad7606_scan, 7);
 111
 112 static ssize_t ad7606_show_scale(struct device *dev,
 113                                 struct device_attribute *attr,
 114                                 char *buf)
 115 {
 116         /* Driver currently only support internal vref */
 117         struct iio_dev *dev_info = dev_get_drvdata(dev);
 118         struct ad7606_state *st = iio_dev_get_devdata(dev_info);
 119         unsigned int scale_uv = (st->range * 1000 * 2) >> st->chip_info->bits;
 120
 121         return sprintf(buf, "%d.%03d\n", scale_uv / 1000, scale_uv % 1000);
 122 }
 123 static IIO_DEVICE_ATTR(in_scale, S_IRUGO, ad7606_show_scale, NULL, 0);
 124
 125 static ssize_t ad7606_show_name(struct device *dev,
 126                                  struct device_attribute *attr,
 127                                  char *buf)
 128 {
 129         struct iio_dev *dev_info = dev_get_drvdata(dev);
 130         struct ad7606_state *st = iio_dev_get_devdata(dev_info);
 131
 132         return sprintf(buf, "%s\n", st->chip_info->name);
 133 }
 134
 135 static IIO_DEVICE_ATTR(name, S_IRUGO, ad7606_show_name, NULL, 0);
 136
 137 static ssize_t ad7606_show_range(struct device *dev,
 138                         struct device_attribute *attr, char *buf)
 139 {
 140         struct iio_dev *dev_info = dev_get_drvdata(dev);
 141         struct ad7606_state *st = iio_dev_get_devdata(dev_info);
 142
 143         return sprintf(buf, "%u\n", st->range);
 144 }
 145
 146 static ssize_t ad7606_store_range(struct device *dev,
 147                 struct device_attribute *attr, const char *buf, size_t count)
 148 {
 149         struct iio_dev *dev_info = dev_get_drvdata(dev);
 150         struct ad7606_state *st = iio_dev_get_devdata(dev_info);
 151         unsigned long lval;
 152
 153         if (strict_strtoul(buf, 10, &lval))
 154                 return -EINVAL;
 155         if (!(lval == 5000 || lval == 10000)) {
 156                 dev_err(dev, "range is not supported\n");
 157                 return -EINVAL;
 158         }
 159         mutex_lock(&dev_info->mlock);
 160         gpio_set_value(st->pdata->gpio_range, lval == 10000);
 161         st->range = lval;
 162         mutex_unlock(&dev_info->mlock);
 163
 164         return count;
 165 }
 166
 167 static IIO_DEVICE_ATTR(range, S_IRUGO | S_IWUSR, \
 168                        ad7606_show_range, ad7606_store_range, 0);
 169 static IIO_CONST_ATTR(range_available, "5000 10000");
 170
 171 static ssize_t ad7606_show_oversampling_ratio(struct device *dev,
 172                         struct device_attribute *attr, char *buf)
 173 {
 174         struct iio_dev *dev_info = dev_get_drvdata(dev);
 175         struct ad7606_state *st = iio_dev_get_devdata(dev_info);
 176
 177         return sprintf(buf, "%u\n", st->oversampling);
 178 }
 179
 180 static int ad7606_oversampling_get_index(unsigned val)
 181 {
 182         unsigned char supported[] = {0, 2, 4, 8, 16, 32, 64};
 183         int i;
 184
 185         for (i = 0; i < ARRAY_SIZE(supported); i++)
 186                 if (val == supported[i])
 187                         return i;
 188
 189         return -EINVAL;
 190 }
 191
 192 static ssize_t ad7606_store_oversampling_ratio(struct device *dev,
 193                 struct device_attribute *attr, const char *buf, size_t count)
 194 {
 195         struct iio_dev *dev_info = dev_get_drvdata(dev);
 196         struct ad7606_state *st = iio_dev_get_devdata(dev_info);
 197         unsigned long lval;
 198         int ret;
 199
 200         if (strict_strtoul(buf, 10, &lval))
 201                 return -EINVAL;
 202
 203         ret = ad7606_oversampling_get_index(lval);
 204         if (ret < 0) {
 205                 dev_err(dev, "oversampling %lu is not supported\n", lval);
 206                 return ret;
 207         }
 208
 209         mutex_lock(&dev_info->mlock);
 210         gpio_set_value(st->pdata->gpio_os0, (ret >> 0) & 1);
 211         gpio_set_value(st->pdata->gpio_os1, (ret >> 1) & 1);
 212         gpio_set_value(st->pdata->gpio_os1, (ret >> 2) & 1);
 213         st->oversampling = lval;
 214         mutex_unlock(&dev_info->mlock);
 215
 216         return count;
 217 }
 218
 219 static IIO_DEVICE_ATTR(oversampling_ratio, S_IRUGO | S_IWUSR,
 220                        ad7606_show_oversampling_ratio,
 221                        ad7606_store_oversampling_ratio, 0);
 222 static IIO_CONST_ATTR(oversampling_ratio_available, "0 2 4 8 16 32 64");
 223
 224 static struct attribute *ad7606_attributes[] = {
 225         &iio_dev_attr_in0_raw.dev_attr.attr,
 226         &iio_dev_attr_in1_raw.dev_attr.attr,
 227         &iio_dev_attr_in2_raw.dev_attr.attr,
 228         &iio_dev_attr_in3_raw.dev_attr.attr,
 229         &iio_dev_attr_in4_raw.dev_attr.attr,
 230         &iio_dev_attr_in5_raw.dev_attr.attr,
 231         &iio_dev_attr_in6_raw.dev_attr.attr,
 232         &iio_dev_attr_in7_raw.dev_attr.attr,
 233         &iio_dev_attr_in_scale.dev_attr.attr,
 234         &iio_dev_attr_name.dev_attr.attr,
 235         &iio_dev_attr_range.dev_attr.attr,
 236         &iio_const_attr_range_available.dev_attr.attr,
 237         &iio_dev_attr_oversampling_ratio.dev_attr.attr,
 238         &iio_const_attr_oversampling_ratio_available.dev_attr.attr,
 239         NULL,
 240 };
 241
 242 static mode_t ad7606_attr_is_visible(struct kobject *kobj,
 243                                      struct attribute *attr, int n)
 244 {
 245         struct device *dev = container_of(kobj, struct device, kobj);
 246         struct iio_dev *dev_info = dev_get_drvdata(dev);
 247         struct ad7606_state *st = iio_dev_get_devdata(dev_info);
 248
 249         mode_t mode = attr->mode;
 250
 251         if (st->chip_info->num_channels <= 6 &&
 252                 (attr == &iio_dev_attr_in7_raw.dev_attr.attr ||
 253                 attr == &iio_dev_attr_in6_raw.dev_attr.attr))
 254                 mode = 0;
 255         else if (st->chip_info->num_channels <= 4 &&
 256                 (attr == &iio_dev_attr_in5_raw.dev_attr.attr ||
 257                 attr == &iio_dev_attr_in4_raw.dev_attr.attr))
 258                 mode = 0;
 259         else if (!st->have_os &&
 260                 (attr == &iio_dev_attr_oversampling_ratio.dev_attr.attr ||
 261                 attr ==
 262                 &iio_const_attr_oversampling_ratio_available.dev_attr.attr))
 263                 mode = 0;
 264         else if (!st->have_range &&
 265                 (attr == &iio_dev_attr_range.dev_attr.attr ||
 266                 attr == &iio_const_attr_range_available.dev_attr.attr))
 267                         mode = 0;
 268
 269         return mode;
 270 }
 271
 272 static const struct attribute_group ad7606_attribute_group = {
 273         .attrs = ad7606_attributes,
 274         .is_visible = ad7606_attr_is_visible,
 275 };
 276
 277 static const struct ad7606_chip_info ad7606_chip_info_tbl[] = {
 278         /*
 279          * More devices added in future
 280          */
 281         [ID_AD7606_8] = {
 282                 .name = "ad7606",
 283                 .bits = 16,
 284                 .sign = IIO_SCAN_EL_TYPE_SIGNED,
 285                 .int_vref_mv = 2500,
 286                 .num_channels = 8,
 287         },
 288         [ID_AD7606_6] = {
 289                 .name = "ad7606-6",
 290                 .bits = 16,
 291                 .sign = IIO_SCAN_EL_TYPE_SIGNED,
 292                 .int_vref_mv = 2500,
 293                 .num_channels = 6,
 294         },
 295         [ID_AD7606_4] = {
 296                 .name = "ad7606-4",
 297                 .bits = 16,
 298                 .sign = IIO_SCAN_EL_TYPE_SIGNED,
 299                 .int_vref_mv = 2500,
 300                 .num_channels = 4,
 301         },
 302 };
 303
 304 static int ad7606_request_gpios(struct ad7606_state *st)
 305 {
 306         struct gpio gpio_array[3] = {
 307                 [0] = {
 308                         .gpio =  st->pdata->gpio_os0,
 309                         .flags = GPIOF_DIR_OUT | ((st->oversampling & 1) ?
 310                                  GPIOF_INIT_HIGH : GPIOF_INIT_LOW),
 311                         .label = "AD7606_OS0",
 312                 },
 313                 [1] = {
 314                         .gpio =  st->pdata->gpio_os1,
 315                         .flags = GPIOF_DIR_OUT | ((st->oversampling & 2) ?
 316                                  GPIOF_INIT_HIGH : GPIOF_INIT_LOW),
 317                         .label = "AD7606_OS1",
 318                 },
 319                 [2] = {
 320                         .gpio =  st->pdata->gpio_os2,
 321                         .flags = GPIOF_DIR_OUT | ((st->oversampling & 4) ?
 322                                  GPIOF_INIT_HIGH : GPIOF_INIT_LOW),
 323                         .label = "AD7606_OS2",
 324                 },
 325         };
 326         int ret;
 327
 328         ret = gpio_request_one(st->pdata->gpio_convst, GPIOF_OUT_INIT_LOW,
 329                                "AD7606_CONVST");
 330         if (ret) {
 331                 dev_err(st->dev, "failed to request GPIO CONVST\n");
 332                 return ret;
 333         }
 334
 335         ret = gpio_request_array(gpio_array, ARRAY_SIZE(gpio_array));
 336         if (!ret) {
 337                 st->have_os = true;
 338         }
 339
 340         ret = gpio_request_one(st->pdata->gpio_reset, GPIOF_OUT_INIT_LOW,
 341                                "AD7606_RESET");
 342         if (!ret)
 343                 st->have_reset = true;
 344
 345         ret = gpio_request_one(st->pdata->gpio_range, GPIOF_DIR_OUT |
 346                                ((st->range == 10000) ? GPIOF_INIT_HIGH :
 347                                 GPIOF_INIT_LOW), "AD7606_RANGE");
 348         if (!ret)
 349                 st->have_range = true;
 350
 351         ret = gpio_request_one(st->pdata->gpio_stby, GPIOF_OUT_INIT_HIGH,
 352                                "AD7606_STBY");
 353         if (!ret)
 354                 st->have_stby = true;
 355
 356         if (gpio_is_valid(st->pdata->gpio_frstdata)) {
 357                 ret = gpio_request_one(st->pdata->gpio_frstdata, GPIOF_IN,
 358                                        "AD7606_FRSTDATA");
 359                 if (!ret)
 360                         st->have_frstdata = true;
 361         }
 362
 363         return 0;
 364 }
 365
 366 static void ad7606_free_gpios(struct ad7606_state *st)
 367 {
 368         if (st->have_range)
 369                 gpio_free(st->pdata->gpio_range);
 370
 371         if (st->have_stby)
 372                 gpio_free(st->pdata->gpio_stby);
 373
 374         if (st->have_os) {
 375                 gpio_free(st->pdata->gpio_os0);
 376                 gpio_free(st->pdata->gpio_os1);
 377                 gpio_free(st->pdata->gpio_os2);
 378         }
 379
 380         if (st->have_reset)
 381                 gpio_free(st->pdata->gpio_reset);
 382
 383         if (st->have_frstdata)
 384                 gpio_free(st->pdata->gpio_frstdata);
 385
 386         gpio_free(st->pdata->gpio_convst);
 387 }
 388
 389 /**
 390  *  Interrupt handler
 391  */
 392 static irqreturn_t ad7606_interrupt(int irq, void *dev_id)
 393 {
 394         struct ad7606_state *st = dev_id;
 395
 396         if (iio_ring_enabled(st->indio_dev)) {
 397                 if (!work_pending(&st->poll_work))
 398                         schedule_work(&st->poll_work);
 399         } else {
 400                 st->done = true;
 401                 wake_up_interruptible(&st->wq_data_avail);
 402         }
 403
 404         return IRQ_HANDLED;
 405 };
 406
 407 struct ad7606_state *ad7606_probe(struct device *dev, int irq,
 408                               void __iomem *base_address,
 409                               unsigned id,
 410                               const struct ad7606_bus_ops *bops)
 411 {
 412         struct ad7606_platform_data *pdata = dev->platform_data;
 413         struct ad7606_state *st;
 414         int ret;
 415
 416         st = kzalloc(sizeof(*st), GFP_KERNEL);
 417         if (st == NULL) {
 418                 ret = -ENOMEM;
 419                 goto error_ret;
 420         }
 421
 422         st->dev = dev;
 423         st->id = id;
 424         st->irq = irq;
 425         st->bops = bops;
 426         st->base_address = base_address;
 427         st->range = pdata->default_range == 10000 ? 10000 : 5000;
 428
 429         ret = ad7606_oversampling_get_index(pdata->default_os);
 430         if (ret < 0) {
 431                 dev_warn(dev, "oversampling %d is not supported\n",
 432                          pdata->default_os);
 433                 st->oversampling = 0;
 434         } else {
 435                 st->oversampling = pdata->default_os;
 436         }
 437
 438         st->reg = regulator_get(dev, "vcc");
 439         if (!IS_ERR(st->reg)) {
 440                 ret = regulator_enable(st->reg);
 441                 if (ret)
 442                         goto error_put_reg;
 443         }
 444
 445         st->pdata = pdata;
 446         st->chip_info = &ad7606_chip_info_tbl[id];
 447
 448         atomic_set(&st->protect_ring, 0);
 449
 450         st->indio_dev = iio_allocate_device(0);
 451         if (st->indio_dev == NULL) {
 452                 ret = -ENOMEM;
 453                 goto error_disable_reg;
 454         }
 455
 456         st->indio_dev->dev.parent = dev;
 457         st->indio_dev->attrs = &ad7606_attribute_group;
 458         st->indio_dev->dev_data = (void *)(st);
 459         st->indio_dev->driver_module = THIS_MODULE;
 460         st->indio_dev->modes = INDIO_DIRECT_MODE;
 461         st->indio_dev->name = st->chip_info->name;
 462
 463         init_waitqueue_head(&st->wq_data_avail);
 464
 465         ret = ad7606_request_gpios(st);
 466         if (ret)
 467                 goto error_free_device;
 468
 469         ret = ad7606_reset(st);
 470         if (ret)
 471                 dev_warn(st->dev, "failed to RESET: no RESET GPIO specified\n");
 472
 473         ret = request_irq(st->irq, ad7606_interrupt,
 474                 IRQF_TRIGGER_FALLING, st->chip_info->name, st);
 475         if (ret)
 476                 goto error_free_gpios;
 477
 478         ret = ad7606_register_ring_funcs_and_init(st->indio_dev);
 479         if (ret)
 480                 goto error_free_irq;
 481
 482         ret = iio_device_register(st->indio_dev);
 483         if (ret)
 484                 goto error_free_irq;
 485
 486         ret = iio_ring_buffer_register(st->indio_dev->ring, 0);
 487         if (ret)
 488                 goto error_cleanup_ring;
 489
 490         return st;
 491
 492 error_cleanup_ring:
 493         ad7606_ring_cleanup(st->indio_dev);
 494         iio_device_unregister(st->indio_dev);
 495
 496 error_free_irq:
 497         free_irq(st->irq, st);
 498
 499 error_free_gpios:
 500         ad7606_free_gpios(st);
 501
 502 error_free_device:
 503         iio_free_device(st->indio_dev);
 504
 505 error_disable_reg:
 506         if (!IS_ERR(st->reg))
 507                 regulator_disable(st->reg);
 508 error_put_reg:
 509         if (!IS_ERR(st->reg))
 510                 regulator_put(st->reg);
 511         kfree(st);
 512 error_ret:
 513         return ERR_PTR(ret);
 514 }
 515
 516 int ad7606_remove(struct ad7606_state *st)
 517 {
 518         struct iio_dev *indio_dev = st->indio_dev;
 519         iio_ring_buffer_unregister(indio_dev->ring);
 520         ad7606_ring_cleanup(indio_dev);
 521         iio_device_unregister(indio_dev);
 522         free_irq(st->irq, st);
 523         if (!IS_ERR(st->reg)) {
 524                 regulator_disable(st->reg);
 525                 regulator_put(st->reg);
 526         }
 527
 528         ad7606_free_gpios(st);
 529
 530         kfree(st);
 531         return 0;
 532 }
 533
 534 void ad7606_suspend(struct ad7606_state *st)
 535 {
 536         if (st->have_stby) {
 537                 if (st->have_range)
 538                         gpio_set_value(st->pdata->gpio_range, 1);
 539                 gpio_set_value(st->pdata->gpio_stby, 0);
 540         }
 541 }
 542
 543 void ad7606_resume(struct ad7606_state *st)
 544 {
 545         if (st->have_stby) {
 546                 if (st->have_range)
 547                         gpio_set_value(st->pdata->gpio_range,
 548                                         st->range == 10000);
 549
 550                 gpio_set_value(st->pdata->gpio_stby, 1);
 551                 ad7606_reset(st);
 552         }
 553 }
 554
 555 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 556 MODULE_DESCRIPTION("Analog Devices AD7606 ADC");
 557 MODULE_LICENSE("GPL v2");