iio/potentiostat/lmp91000.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * lmp91000.c - Support for Texas Instruments digital potentiostats
0004  *
0005  * Copyright (C) 2016, 2018
0006  * Author: Matt Ranostay <matt.ranostay@konsulko.com>
0007  *
0008  * TODO: bias voltage + polarity control, and multiple chip support
0009  */
0010
0011 #include <linux/module.h>
0012 #include <linux/i2c.h>
0013 #include <linux/delay.h>
0014 #include <linux/mod_devicetable.h>
0015 #include <linux/regmap.h>
0016 #include <linux/iio/iio.h>
0017 #include <linux/iio/buffer.h>
0018 #include <linux/iio/consumer.h>
0019 #include <linux/iio/trigger.h>
0020 #include <linux/iio/trigger_consumer.h>
0021 #include <linux/iio/triggered_buffer.h>
0022
0023 #define LMP91000_REG_LOCK       0x01
0024 #define LMP91000_REG_TIACN      0x10
0025 #define LMP91000_REG_TIACN_GAIN_SHIFT   2
0026
0027 #define LMP91000_REG_REFCN      0x11
0028 #define LMP91000_REG_REFCN_EXT_REF  0x20
0029 #define LMP91000_REG_REFCN_50_ZERO  0x80
0030
0031 #define LMP91000_REG_MODECN     0x12
0032 #define LMP91000_REG_MODECN_3LEAD   0x03
0033 #define LMP91000_REG_MODECN_TEMP    0x07
0034
0035 #define LMP91000_DRV_NAME   "lmp91000"
0036
0037 static const int lmp91000_tia_gain[] = { 0, 2750, 3500, 7000, 14000, 35000,
0038                      120000, 350000 };
0039
0040 static const int lmp91000_rload[] = { 10, 33, 50, 100 };
0041
0042 #define LMP91000_TEMP_BASE  -40
0043
0044 static const u16 lmp91000_temp_lut[] = {
0045     1875, 1867, 1860, 1852, 1844, 1836, 1828, 1821, 1813, 1805,
0046     1797, 1789, 1782, 1774, 1766, 1758, 1750, 1742, 1734, 1727,
0047     1719, 1711, 1703, 1695, 1687, 1679, 1671, 1663, 1656, 1648,
0048     1640, 1632, 1624, 1616, 1608, 1600, 1592, 1584, 1576, 1568,
0049     1560, 1552, 1544, 1536, 1528, 1520, 1512, 1504, 1496, 1488,
0050     1480, 1472, 1464, 1456, 1448, 1440, 1432, 1424, 1415, 1407,
0051     1399, 1391, 1383, 1375, 1367, 1359, 1351, 1342, 1334, 1326,
0052     1318, 1310, 1302, 1293, 1285, 1277, 1269, 1261, 1253, 1244,
0053     1236, 1228, 1220, 1212, 1203, 1195, 1187, 1179, 1170, 1162,
0054     1154, 1146, 1137, 1129, 1121, 1112, 1104, 1096, 1087, 1079,
0055     1071, 1063, 1054, 1046, 1038, 1029, 1021, 1012, 1004,  996,
0056      987,  979,  971,  962,  954,  945,  937,  929,  920,  912,
0057      903,  895,  886,  878,  870,  861 };
0058
0059 static const struct regmap_config lmp91000_regmap_config = {
0060     .reg_bits = 8,
0061     .val_bits = 8,
0062 };
0063
0064 struct lmp91000_data {
0065     struct regmap *regmap;
0066     struct device *dev;
0067
0068     struct iio_trigger *trig;
0069     struct iio_cb_buffer *cb_buffer;
0070     struct iio_channel *adc_chan;
0071
0072     struct completion completion;
0073     u8 chan_select;
0074     /* 64-bit data + 64-bit naturally aligned timestamp */
0075     u32 buffer[4] __aligned(8);
0076 };
0077
0078 static const struct iio_chan_spec lmp91000_channels[] = {
0079     { /* chemical channel mV */
0080         .type = IIO_VOLTAGE,
0081         .channel = 0,
0082         .address = LMP91000_REG_MODECN_3LEAD,
0083         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
0084                       BIT(IIO_CHAN_INFO_OFFSET) |
0085                       BIT(IIO_CHAN_INFO_SCALE),
0086         .scan_index = 0,
0087         .scan_type = {
0088             .sign = 's',
0089             .realbits = 32,
0090             .storagebits = 32,
0091         },
0092     },
0093     IIO_CHAN_SOFT_TIMESTAMP(1),
0094     { /* temperature channel mV */
0095         .type = IIO_TEMP,
0096         .channel = 1,
0097         .address = LMP91000_REG_MODECN_TEMP,
0098         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
0099         .scan_index = -1,
0100     },
0101 };
0102
0103 static int lmp91000_read(struct lmp91000_data *data, int channel, int *val)
0104 {
0105     int state, ret;
0106
0107     ret = regmap_read(data->regmap, LMP91000_REG_MODECN, &state);
0108     if (ret)
0109         return -EINVAL;
0110
0111     ret = regmap_write(data->regmap, LMP91000_REG_MODECN, channel);
0112     if (ret)
0113         return -EINVAL;
0114
0115     /* delay till first temperature reading is complete */
0116     if (state != channel && channel == LMP91000_REG_MODECN_TEMP)
0117         usleep_range(3000, 4000);
0118
0119     data->chan_select = channel != LMP91000_REG_MODECN_3LEAD;
0120
0121     iio_trigger_poll_chained(data->trig);
0122
0123     ret = wait_for_completion_timeout(&data->completion, HZ);
0124     reinit_completion(&data->completion);
0125
0126     if (!ret)
0127         return -ETIMEDOUT;
0128
0129     *val = data->buffer[data->chan_select];
0130
0131     return 0;
0132 }
0133
0134 static irqreturn_t lmp91000_buffer_handler(int irq, void *private)
0135 {
0136     struct iio_poll_func *pf = private;
0137     struct iio_dev *indio_dev = pf->indio_dev;
0138     struct lmp91000_data *data = iio_priv(indio_dev);
0139     int ret, val;
0140
0141     memset(data->buffer, 0, sizeof(data->buffer));
0142
0143     ret = lmp91000_read(data, LMP91000_REG_MODECN_3LEAD, &val);
0144     if (!ret) {
0145         data->buffer[0] = val;
0146         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
0147                            iio_get_time_ns(indio_dev));
0148     }
0149
0150     iio_trigger_notify_done(indio_dev->trig);
0151
0152     return IRQ_HANDLED;
0153 }
0154
0155 static int lmp91000_read_raw(struct iio_dev *indio_dev,
0156                  struct iio_chan_spec const *chan,
0157                  int *val, int *val2, long mask)
0158 {
0159     struct lmp91000_data *data = iio_priv(indio_dev);
0160
0161     switch (mask) {
0162     case IIO_CHAN_INFO_RAW:
0163     case IIO_CHAN_INFO_PROCESSED: {
0164         int ret = iio_channel_start_all_cb(data->cb_buffer);
0165
0166         if (ret)
0167             return ret;
0168
0169         ret = lmp91000_read(data, chan->address, val);
0170
0171         iio_channel_stop_all_cb(data->cb_buffer);
0172
0173         if (ret)
0174             return ret;
0175
0176         if (mask == IIO_CHAN_INFO_PROCESSED) {
0177             int tmp, i;
0178
0179             ret = iio_convert_raw_to_processed(data->adc_chan,
0180                                *val, &tmp, 1);
0181             if (ret)
0182                 return ret;
0183
0184             for (i = 0; i < ARRAY_SIZE(lmp91000_temp_lut); i++)
0185                 if (lmp91000_temp_lut[i] < tmp)
0186                     break;
0187
0188             *val = (LMP91000_TEMP_BASE + i) * 1000;
0189         }
0190         return IIO_VAL_INT;
0191     }
0192     case IIO_CHAN_INFO_OFFSET:
0193         return iio_read_channel_offset(data->adc_chan, val, val2);
0194     case IIO_CHAN_INFO_SCALE:
0195         return iio_read_channel_scale(data->adc_chan, val, val2);
0196     }
0197
0198     return -EINVAL;
0199 }
0200
0201 static const struct iio_info lmp91000_info = {
0202     .read_raw = lmp91000_read_raw,
0203 };
0204
0205 static int lmp91000_read_config(struct lmp91000_data *data)
0206 {
0207     struct device *dev = data->dev;
0208     unsigned int reg, val;
0209     int i, ret;
0210
0211     ret = device_property_read_u32(dev, "ti,tia-gain-ohm", &val);
0212     if (ret) {
0213         if (!device_property_read_bool(dev, "ti,external-tia-resistor")) {
0214             dev_err(dev, "no ti,tia-gain-ohm defined and external resistor not specified\n");
0215             return ret;
0216         }
0217         val = 0;
0218     }
0219
0220     ret = -EINVAL;
0221     for (i = 0; i < ARRAY_SIZE(lmp91000_tia_gain); i++) {
0222         if (lmp91000_tia_gain[i] == val) {
0223             reg = i << LMP91000_REG_TIACN_GAIN_SHIFT;
0224             ret = 0;
0225             break;
0226         }
0227     }
0228
0229     if (ret) {
0230         dev_err(dev, "invalid ti,tia-gain-ohm %d\n", val);
0231         return ret;
0232     }
0233
0234     ret = device_property_read_u32(dev, "ti,rload-ohm", &val);
0235     if (ret) {
0236         val = 100;
0237         dev_info(dev, "no ti,rload-ohm defined, default to %d\n", val);
0238     }
0239
0240     ret = -EINVAL;
0241     for (i = 0; i < ARRAY_SIZE(lmp91000_rload); i++) {
0242         if (lmp91000_rload[i] == val) {
0243             reg |= i;
0244             ret = 0;
0245             break;
0246         }
0247     }
0248
0249     if (ret) {
0250         dev_err(dev, "invalid ti,rload-ohm %d\n", val);
0251         return ret;
0252     }
0253
0254     regmap_write(data->regmap, LMP91000_REG_LOCK, 0);
0255     regmap_write(data->regmap, LMP91000_REG_TIACN, reg);
0256     regmap_write(data->regmap, LMP91000_REG_REFCN,
0257              LMP91000_REG_REFCN_EXT_REF | LMP91000_REG_REFCN_50_ZERO);
0258     regmap_write(data->regmap, LMP91000_REG_LOCK, 1);
0259
0260     return 0;
0261 }
0262
0263 static int lmp91000_buffer_cb(const void *val, void *private)
0264 {
0265     struct iio_dev *indio_dev = private;
0266     struct lmp91000_data *data = iio_priv(indio_dev);
0267
0268     data->buffer[data->chan_select] = *((int *)val);
0269     complete_all(&data->completion);
0270
0271     return 0;
0272 }
0273
0274 static int lmp91000_buffer_postenable(struct iio_dev *indio_dev)
0275 {
0276     struct lmp91000_data *data = iio_priv(indio_dev);
0277
0278     return iio_channel_start_all_cb(data->cb_buffer);
0279 }
0280
0281 static int lmp91000_buffer_predisable(struct iio_dev *indio_dev)
0282 {
0283     struct lmp91000_data *data = iio_priv(indio_dev);
0284
0285     iio_channel_stop_all_cb(data->cb_buffer);
0286
0287     return 0;
0288 }
0289
0290 static const struct iio_buffer_setup_ops lmp91000_buffer_setup_ops = {
0291     .postenable = lmp91000_buffer_postenable,
0292     .predisable = lmp91000_buffer_predisable,
0293 };
0294
0295 static int lmp91000_probe(struct i2c_client *client,
0296               const struct i2c_device_id *id)
0297 {
0298     struct device *dev = &client->dev;
0299     struct lmp91000_data *data;
0300     struct iio_dev *indio_dev;
0301     int ret;
0302
0303     indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
0304     if (!indio_dev)
0305         return -ENOMEM;
0306
0307     indio_dev->info = &lmp91000_info;
0308     indio_dev->channels = lmp91000_channels;
0309     indio_dev->num_channels = ARRAY_SIZE(lmp91000_channels);
0310     indio_dev->name = LMP91000_DRV_NAME;
0311     indio_dev->modes = INDIO_DIRECT_MODE;
0312     i2c_set_clientdata(client, indio_dev);
0313
0314     data = iio_priv(indio_dev);
0315     data->dev = dev;
0316     data->regmap = devm_regmap_init_i2c(client, &lmp91000_regmap_config);
0317     if (IS_ERR(data->regmap)) {
0318         dev_err(dev, "regmap initialization failed.\n");
0319         return PTR_ERR(data->regmap);
0320     }
0321
0322     data->trig = devm_iio_trigger_alloc(dev, "%s-mux%d",
0323                         indio_dev->name,
0324                         iio_device_id(indio_dev));
0325     if (!data->trig) {
0326         dev_err(dev, "cannot allocate iio trigger.\n");
0327         return -ENOMEM;
0328     }
0329
0330     init_completion(&data->completion);
0331
0332     ret = lmp91000_read_config(data);
0333     if (ret)
0334         return ret;
0335
0336     ret = iio_trigger_set_immutable(iio_channel_cb_get_iio_dev(data->cb_buffer),
0337                     data->trig);
0338     if (ret) {
0339         dev_err(dev, "cannot set immutable trigger.\n");
0340         return ret;
0341     }
0342
0343     ret = iio_trigger_register(data->trig);
0344     if (ret) {
0345         dev_err(dev, "cannot register iio trigger.\n");
0346         return ret;
0347     }
0348
0349     ret = iio_triggered_buffer_setup(indio_dev, NULL,
0350                      &lmp91000_buffer_handler,
0351                      &lmp91000_buffer_setup_ops);
0352     if (ret)
0353         goto error_unreg_trigger;
0354
0355     data->cb_buffer = iio_channel_get_all_cb(dev, &lmp91000_buffer_cb,
0356                          indio_dev);
0357
0358     if (IS_ERR(data->cb_buffer)) {
0359         if (PTR_ERR(data->cb_buffer) == -ENODEV)
0360             ret = -EPROBE_DEFER;
0361         else
0362             ret = PTR_ERR(data->cb_buffer);
0363
0364         goto error_unreg_buffer;
0365     }
0366
0367     data->adc_chan = iio_channel_cb_get_channels(data->cb_buffer);
0368
0369     ret = iio_device_register(indio_dev);
0370     if (ret)
0371         goto error_unreg_cb_buffer;
0372
0373     return 0;
0374
0375 error_unreg_cb_buffer:
0376     iio_channel_release_all_cb(data->cb_buffer);
0377
0378 error_unreg_buffer:
0379     iio_triggered_buffer_cleanup(indio_dev);
0380
0381 error_unreg_trigger:
0382     iio_trigger_unregister(data->trig);
0383
0384     return ret;
0385 }
0386
0387 static int lmp91000_remove(struct i2c_client *client)
0388 {
0389     struct iio_dev *indio_dev = i2c_get_clientdata(client);
0390     struct lmp91000_data *data = iio_priv(indio_dev);
0391
0392     iio_device_unregister(indio_dev);
0393
0394     iio_channel_stop_all_cb(data->cb_buffer);
0395     iio_channel_release_all_cb(data->cb_buffer);
0396
0397     iio_triggered_buffer_cleanup(indio_dev);
0398     iio_trigger_unregister(data->trig);
0399
0400     return 0;
0401 }
0402
0403 static const struct of_device_id lmp91000_of_match[] = {
0404     { .compatible = "ti,lmp91000", },
0405     { .compatible = "ti,lmp91002", },
0406     { },
0407 };
0408 MODULE_DEVICE_TABLE(of, lmp91000_of_match);
0409
0410 static const struct i2c_device_id lmp91000_id[] = {
0411     { "lmp91000", 0 },
0412     { "lmp91002", 0 },
0413     {}
0414 };
0415 MODULE_DEVICE_TABLE(i2c, lmp91000_id);
0416
0417 static struct i2c_driver lmp91000_driver = {
0418     .driver = {
0419         .name = LMP91000_DRV_NAME,
0420         .of_match_table = lmp91000_of_match,
0421     },
0422     .probe = lmp91000_probe,
0423     .remove = lmp91000_remove,
0424     .id_table = lmp91000_id,
0425 };
0426 module_i2c_driver(lmp91000_driver);
0427
0428 MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
0429 MODULE_DESCRIPTION("LMP91000 digital potentiostat");
0430 MODULE_LICENSE("GPL");