drivers/iio/amplifiers/ad8366.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * AD8366 and similar Gain Amplifiers
   4  * This driver supports the following gain amplifiers:
   5  *   AD8366 Dual-Digital Variable Gain Amplifier (VGA)
   6  *   ADA4961 BiCMOS RF Digital Gain Amplifier (DGA)
   7  *   ADL5240 Digitally controlled variable gain amplifier (VGA)
   8  *
   9  * Copyright 2012-2019 Analog Devices Inc.
  10  */
  11
  12 #include <linux/device.h>
  13 #include <linux/kernel.h>
  14 #include <linux/slab.h>
  15 #include <linux/sysfs.h>
  16 #include <linux/spi/spi.h>
  17 #include <linux/regulator/consumer.h>
  18 #include <linux/gpio/consumer.h>
  19 #include <linux/err.h>
  20 #include <linux/module.h>
  21 #include <linux/bitrev.h>
  22
  23 #include <linux/iio/iio.h>
  24 #include <linux/iio/sysfs.h>
  25
  26 enum ad8366_type {
  27         ID_AD8366,
  28         ID_ADA4961,
  29         ID_ADL5240,
  30 };
  31
  32 struct ad8366_info {
  33         int gain_min;
  34         int gain_max;
  35 };
  36
  37 struct ad8366_state {
  38         struct spi_device       *spi;
  39         struct regulator        *reg;
  40         struct mutex            lock; /* protect sensor state */
  41         struct gpio_desc        *reset_gpio;
  42         unsigned char           ch[2];
  43         enum ad8366_type        type;
  44         struct ad8366_info      *info;
  45         /*
  46          * DMA (thus cache coherency maintenance) requires the
  47          * transfer buffers to live in their own cache lines.
  48          */
  49         unsigned char           data[2] ____cacheline_aligned;
  50 };
  51
  52 static struct ad8366_info ad8366_infos[] = {
  53         [ID_AD8366] = {
  54                 .gain_min = 4500,
  55                 .gain_max = 20500,
  56         },
  57         [ID_ADA4961] = {
  58                 .gain_min = -6000,
  59                 .gain_max = 15000,
  60         },
  61         [ID_ADL5240] = {
  62                 .gain_min = -11500,
  63                 .gain_max = 20000,
  64         },
  65 };
  66
  67 static int ad8366_write(struct iio_dev *indio_dev,
  68                         unsigned char ch_a, unsigned char ch_b)
  69 {
  70         struct ad8366_state *st = iio_priv(indio_dev);
  71         int ret;
  72
  73         switch (st->type) {
  74         case ID_AD8366:
  75                 ch_a = bitrev8(ch_a & 0x3F);
  76                 ch_b = bitrev8(ch_b & 0x3F);
  77
  78                 st->data[0] = ch_b >> 4;
  79                 st->data[1] = (ch_b << 4) | (ch_a >> 2);
  80                 break;
  81         case ID_ADA4961:
  82                 st->data[0] = ch_a & 0x1F;
  83                 break;
  84         case ID_ADL5240:
  85                 st->data[0] = (ch_a & 0x3F);
  86                 break;
  87         }
  88
  89         ret = spi_write(st->spi, st->data, indio_dev->num_channels);
  90         if (ret < 0)
  91                 dev_err(&indio_dev->dev, "write failed (%d)", ret);
  92
  93         return ret;
  94 }
  95
  96 static int ad8366_read_raw(struct iio_dev *indio_dev,
  97                            struct iio_chan_spec const *chan,
  98                            int *val,
  99                            int *val2,
 100                            long m)
 101 {
 102         struct ad8366_state *st = iio_priv(indio_dev);
 103         int ret;
 104         int code, gain = 0;
 105
 106         mutex_lock(&st->lock);
 107         switch (m) {
 108         case IIO_CHAN_INFO_HARDWAREGAIN:
 109                 code = st->ch[chan->channel];
 110
 111                 switch (st->type) {
 112                 case ID_AD8366:
 113                         gain = code * 253 + 4500;
 114                         break;
 115                 case ID_ADA4961:
 116                         gain = 15000 - code * 1000;
 117                         break;
 118                 case ID_ADL5240:
 119                         gain = 20000 - 31500 + code * 500;
 120                         break;
 121                 }
 122
 123                 /* Values in dB */
 124                 *val = gain / 1000;
 125                 *val2 = (gain % 1000) * 1000;
 126
 127                 ret = IIO_VAL_INT_PLUS_MICRO_DB;
 128                 break;
 129         default:
 130                 ret = -EINVAL;
 131         }
 132         mutex_unlock(&st->lock);
 133
 134         return ret;
 135 };
 136
 137 static int ad8366_write_raw(struct iio_dev *indio_dev,
 138                             struct iio_chan_spec const *chan,
 139                             int val,
 140                             int val2,
 141                             long mask)
 142 {
 143         struct ad8366_state *st = iio_priv(indio_dev);
 144         struct ad8366_info *inf = st->info;
 145         int code = 0, gain;
 146         int ret;
 147
 148         /* Values in dB */
 149         if (val < 0)
 150                 gain = (val * 1000) - (val2 / 1000);
 151         else
 152                 gain = (val * 1000) + (val2 / 1000);
 153
 154         if (gain > inf->gain_max || gain < inf->gain_min)
 155                 return -EINVAL;
 156
 157         switch (st->type) {
 158         case ID_AD8366:
 159                 code = (gain - 4500) / 253;
 160                 break;
 161         case ID_ADA4961:
 162                 code = (15000 - gain) / 1000;
 163                 break;
 164         case ID_ADL5240:
 165                 code = ((gain - 500 - 20000) / 500) & 0x3F;
 166                 break;
 167         }
 168
 169         mutex_lock(&st->lock);
 170         switch (mask) {
 171         case IIO_CHAN_INFO_HARDWAREGAIN:
 172                 st->ch[chan->channel] = code;
 173                 ret = ad8366_write(indio_dev, st->ch[0], st->ch[1]);
 174                 break;
 175         default:
 176                 ret = -EINVAL;
 177         }
 178         mutex_unlock(&st->lock);
 179
 180         return ret;
 181 }
 182
 183 static const struct iio_info ad8366_info = {
 184         .read_raw = &ad8366_read_raw,
 185         .write_raw = &ad8366_write_raw,
 186 };
 187
 188 #define AD8366_CHAN(_channel) {                         \
 189         .type = IIO_VOLTAGE,                            \
 190         .output = 1,                                    \
 191         .indexed = 1,                                   \
 192         .channel = _channel,                            \
 193         .info_mask_separate = BIT(IIO_CHAN_INFO_HARDWAREGAIN),\
 194 }
 195
 196 static const struct iio_chan_spec ad8366_channels[] = {
 197         AD8366_CHAN(0),
 198         AD8366_CHAN(1),
 199 };
 200
 201 static const struct iio_chan_spec ada4961_channels[] = {
 202         AD8366_CHAN(0),
 203 };
 204
 205 static int ad8366_probe(struct spi_device *spi)
 206 {
 207         struct iio_dev *indio_dev;
 208         struct ad8366_state *st;
 209         int ret;
 210
 211         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
 212         if (indio_dev == NULL)
 213                 return -ENOMEM;
 214
 215         st = iio_priv(indio_dev);
 216
 217         st->reg = devm_regulator_get(&spi->dev, "vcc");
 218         if (!IS_ERR(st->reg)) {
 219                 ret = regulator_enable(st->reg);
 220                 if (ret)
 221                         return ret;
 222         }
 223
 224         spi_set_drvdata(spi, indio_dev);
 225         mutex_init(&st->lock);
 226         st->spi = spi;
 227         st->type = spi_get_device_id(spi)->driver_data;
 228
 229         switch (st->type) {
 230         case ID_AD8366:
 231                 indio_dev->channels = ad8366_channels;
 232                 indio_dev->num_channels = ARRAY_SIZE(ad8366_channels);
 233                 break;
 234         case ID_ADA4961:
 235         case ID_ADL5240:
 236                 st->reset_gpio = devm_gpiod_get(&spi->dev, "reset",
 237                         GPIOD_OUT_HIGH);
 238                 indio_dev->channels = ada4961_channels;
 239                 indio_dev->num_channels = ARRAY_SIZE(ada4961_channels);
 240                 break;
 241         default:
 242                 dev_err(&spi->dev, "Invalid device ID\n");
 243                 ret = -EINVAL;
 244                 goto error_disable_reg;
 245         }
 246
 247         st->info = &ad8366_infos[st->type];
 248         indio_dev->dev.parent = &spi->dev;
 249         indio_dev->name = spi_get_device_id(spi)->name;
 250         indio_dev->info = &ad8366_info;
 251         indio_dev->modes = INDIO_DIRECT_MODE;
 252
 253         ret = ad8366_write(indio_dev, 0 , 0);
 254         if (ret < 0)
 255                 goto error_disable_reg;
 256
 257         ret = iio_device_register(indio_dev);
 258         if (ret)
 259                 goto error_disable_reg;
 260
 261         return 0;
 262
 263 error_disable_reg:
 264         if (!IS_ERR(st->reg))
 265                 regulator_disable(st->reg);
 266
 267         return ret;
 268 }
 269
 270 static int ad8366_remove(struct spi_device *spi)
 271 {
 272         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 273         struct ad8366_state *st = iio_priv(indio_dev);
 274         struct regulator *reg = st->reg;
 275
 276         iio_device_unregister(indio_dev);
 277
 278         if (!IS_ERR(reg))
 279                 regulator_disable(reg);
 280
 281         return 0;
 282 }
 283
 284 static const struct spi_device_id ad8366_id[] = {
 285         {"ad8366",  ID_AD8366},
 286         {"ada4961", ID_ADA4961},
 287         {"adl5240", ID_ADL5240},
 288         {}
 289 };
 290 MODULE_DEVICE_TABLE(spi, ad8366_id);
 291
 292 static struct spi_driver ad8366_driver = {
 293         .driver = {
 294                 .name   = KBUILD_MODNAME,
 295         },
 296         .probe          = ad8366_probe,
 297         .remove         = ad8366_remove,
 298         .id_table       = ad8366_id,
 299 };
 300
 301 module_spi_driver(ad8366_driver);
 302
 303 MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
 304 MODULE_DESCRIPTION("Analog Devices AD8366 and similar Gain Amplifiers");
 305 MODULE_LICENSE("GPL v2");