drivers/iio/adc/ltc2497-core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ltc2497-core.c - Common code for Analog Devices/Linear Technology
   4  * LTC2496 and LTC2497 ADCs
   5  *
   6  * Copyright (C) 2017 Analog Devices Inc.
   7  */
   8
   9 #include <linux/delay.h>
  10 #include <linux/iio/iio.h>
  11 #include <linux/iio/driver.h>
  12 #include <linux/module.h>
  13 #include <linux/mutex.h>
  14 #include <linux/regulator/consumer.h>
  15
  16 #include "ltc2497.h"
  17
  18 #define LTC2497_SGL                     BIT(4)
  19 #define LTC2497_DIFF                    0
  20 #define LTC2497_SIGN                    BIT(3)
  21
  22 static int ltc2497core_wait_conv(struct ltc2497core_driverdata *ddata)
  23 {
  24         s64 time_elapsed;
  25
  26         time_elapsed = ktime_ms_delta(ktime_get(), ddata->time_prev);
  27
  28         if (time_elapsed < LTC2497_CONVERSION_TIME_MS) {
  29                 /* delay if conversion time not passed
  30                  * since last read or write
  31                  */
  32                 if (msleep_interruptible(
  33                     LTC2497_CONVERSION_TIME_MS - time_elapsed))
  34                         return -ERESTARTSYS;
  35
  36                 return 0;
  37         }
  38
  39         if (time_elapsed - LTC2497_CONVERSION_TIME_MS <= 0) {
  40                 /* We're in automatic mode -
  41                  * so the last reading is still not outdated
  42                  */
  43                 return 0;
  44         }
  45
  46         return 1;
  47 }
  48
  49 static int ltc2497core_read(struct ltc2497core_driverdata *ddata, u8 address, int *val)
  50 {
  51         int ret;
  52
  53         ret = ltc2497core_wait_conv(ddata);
  54         if (ret < 0)
  55                 return ret;
  56
  57         if (ret || ddata->addr_prev != address) {
  58                 ret = ddata->result_and_measure(ddata, address, NULL);
  59                 if (ret < 0)
  60                         return ret;
  61                 ddata->addr_prev = address;
  62
  63                 if (msleep_interruptible(LTC2497_CONVERSION_TIME_MS))
  64                         return -ERESTARTSYS;
  65         }
  66
  67         ret = ddata->result_and_measure(ddata, address, val);
  68         if (ret < 0)
  69                 return ret;
  70
  71         ddata->time_prev = ktime_get();
  72
  73         return ret;
  74 }
  75
  76 static int ltc2497core_read_raw(struct iio_dev *indio_dev,
  77                             struct iio_chan_spec const *chan,
  78                             int *val, int *val2, long mask)
  79 {
  80         struct ltc2497core_driverdata *ddata = iio_priv(indio_dev);
  81         int ret;
  82
  83         switch (mask) {
  84         case IIO_CHAN_INFO_RAW:
  85                 mutex_lock(&ddata->lock);
  86                 ret = ltc2497core_read(ddata, chan->address, val);
  87                 mutex_unlock(&ddata->lock);
  88                 if (ret < 0)
  89                         return ret;
  90
  91                 return IIO_VAL_INT;
  92
  93         case IIO_CHAN_INFO_SCALE:
  94                 ret = regulator_get_voltage(ddata->ref);
  95                 if (ret < 0)
  96                         return ret;
  97
  98                 *val = ret / 1000;
  99                 *val2 = ddata->chip_info->resolution + 1;
 100
 101                 return IIO_VAL_FRACTIONAL_LOG2;
 102
 103         default:
 104                 return -EINVAL;
 105         }
 106 }
 107
 108 #define LTC2497_CHAN(_chan, _addr, _ds_name) { \
 109         .type = IIO_VOLTAGE, \
 110         .indexed = 1, \
 111         .channel = (_chan), \
 112         .address = (_addr | (_chan / 2) | ((_chan & 1) ? LTC2497_SIGN : 0)), \
 113         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
 114         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
 115         .datasheet_name = (_ds_name), \
 116 }
 117
 118 #define LTC2497_CHAN_DIFF(_chan, _addr) { \
 119         .type = IIO_VOLTAGE, \
 120         .indexed = 1, \
 121         .channel = (_chan) * 2 + ((_addr) & LTC2497_SIGN ? 1 : 0), \
 122         .channel2 = (_chan) * 2 + ((_addr) & LTC2497_SIGN ? 0 : 1),\
 123         .address = (_addr | _chan), \
 124         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
 125         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
 126         .differential = 1, \
 127 }
 128
 129 static const struct iio_chan_spec ltc2497core_channel[] = {
 130         LTC2497_CHAN(0, LTC2497_SGL, "CH0"),
 131         LTC2497_CHAN(1, LTC2497_SGL, "CH1"),
 132         LTC2497_CHAN(2, LTC2497_SGL, "CH2"),
 133         LTC2497_CHAN(3, LTC2497_SGL, "CH3"),
 134         LTC2497_CHAN(4, LTC2497_SGL, "CH4"),
 135         LTC2497_CHAN(5, LTC2497_SGL, "CH5"),
 136         LTC2497_CHAN(6, LTC2497_SGL, "CH6"),
 137         LTC2497_CHAN(7, LTC2497_SGL, "CH7"),
 138         LTC2497_CHAN(8, LTC2497_SGL, "CH8"),
 139         LTC2497_CHAN(9, LTC2497_SGL, "CH9"),
 140         LTC2497_CHAN(10, LTC2497_SGL, "CH10"),
 141         LTC2497_CHAN(11, LTC2497_SGL, "CH11"),
 142         LTC2497_CHAN(12, LTC2497_SGL, "CH12"),
 143         LTC2497_CHAN(13, LTC2497_SGL, "CH13"),
 144         LTC2497_CHAN(14, LTC2497_SGL, "CH14"),
 145         LTC2497_CHAN(15, LTC2497_SGL, "CH15"),
 146         LTC2497_CHAN_DIFF(0, LTC2497_DIFF),
 147         LTC2497_CHAN_DIFF(1, LTC2497_DIFF),
 148         LTC2497_CHAN_DIFF(2, LTC2497_DIFF),
 149         LTC2497_CHAN_DIFF(3, LTC2497_DIFF),
 150         LTC2497_CHAN_DIFF(4, LTC2497_DIFF),
 151         LTC2497_CHAN_DIFF(5, LTC2497_DIFF),
 152         LTC2497_CHAN_DIFF(6, LTC2497_DIFF),
 153         LTC2497_CHAN_DIFF(7, LTC2497_DIFF),
 154         LTC2497_CHAN_DIFF(0, LTC2497_DIFF | LTC2497_SIGN),
 155         LTC2497_CHAN_DIFF(1, LTC2497_DIFF | LTC2497_SIGN),
 156         LTC2497_CHAN_DIFF(2, LTC2497_DIFF | LTC2497_SIGN),
 157         LTC2497_CHAN_DIFF(3, LTC2497_DIFF | LTC2497_SIGN),
 158         LTC2497_CHAN_DIFF(4, LTC2497_DIFF | LTC2497_SIGN),
 159         LTC2497_CHAN_DIFF(5, LTC2497_DIFF | LTC2497_SIGN),
 160         LTC2497_CHAN_DIFF(6, LTC2497_DIFF | LTC2497_SIGN),
 161         LTC2497_CHAN_DIFF(7, LTC2497_DIFF | LTC2497_SIGN),
 162 };
 163
 164 static const struct iio_info ltc2497core_info = {
 165         .read_raw = ltc2497core_read_raw,
 166 };
 167
 168 int ltc2497core_probe(struct device *dev, struct iio_dev *indio_dev)
 169 {
 170         struct ltc2497core_driverdata *ddata = iio_priv(indio_dev);
 171         struct iio_map *plat_data = dev_get_platdata(dev);
 172         int ret;
 173
 174         /*
 175          * Keep using dev_name() for the iio_dev's name on some of the parts,
 176          * since updating it would result in a ABI breakage.
 177          */
 178         if (ddata->chip_info->name)
 179                 indio_dev->name = ddata->chip_info->name;
 180         else
 181                 indio_dev->name = dev_name(dev);
 182
 183         indio_dev->info = &ltc2497core_info;
 184         indio_dev->modes = INDIO_DIRECT_MODE;
 185         indio_dev->channels = ltc2497core_channel;
 186         indio_dev->num_channels = ARRAY_SIZE(ltc2497core_channel);
 187
 188         ret = ddata->result_and_measure(ddata, LTC2497_CONFIG_DEFAULT, NULL);
 189         if (ret < 0)
 190                 return ret;
 191
 192         ddata->ref = devm_regulator_get(dev, "vref");
 193         if (IS_ERR(ddata->ref))
 194                 return dev_err_probe(dev, PTR_ERR(ddata->ref),
 195                                      "Failed to get vref regulator\n");
 196
 197         ret = regulator_enable(ddata->ref);
 198         if (ret < 0) {
 199                 dev_err(dev, "Failed to enable vref regulator: %pe\n",
 200                         ERR_PTR(ret));
 201                 return ret;
 202         }
 203
 204         ret = iio_map_array_register(indio_dev, plat_data);
 205         if (ret) {
 206                 dev_err(&indio_dev->dev, "iio map err: %d\n", ret);
 207                 goto err_regulator_disable;
 208         }
 209
 210         ddata->addr_prev = LTC2497_CONFIG_DEFAULT;
 211         ddata->time_prev = ktime_get();
 212
 213         mutex_init(&ddata->lock);
 214
 215         ret = iio_device_register(indio_dev);
 216         if (ret < 0)
 217                 goto err_array_unregister;
 218
 219         return 0;
 220
 221 err_array_unregister:
 222         iio_map_array_unregister(indio_dev);
 223
 224 err_regulator_disable:
 225         regulator_disable(ddata->ref);
 226
 227         return ret;
 228 }
 229 EXPORT_SYMBOL_NS(ltc2497core_probe, "LTC2497");
 230
 231 void ltc2497core_remove(struct iio_dev *indio_dev)
 232 {
 233         struct ltc2497core_driverdata *ddata = iio_priv(indio_dev);
 234
 235         iio_device_unregister(indio_dev);
 236
 237         iio_map_array_unregister(indio_dev);
 238
 239         regulator_disable(ddata->ref);
 240 }
 241 EXPORT_SYMBOL_NS(ltc2497core_remove, "LTC2497");
 242
 243 MODULE_DESCRIPTION("common code for LTC2496/LTC2497 drivers");
 244 MODULE_LICENSE("GPL v2");