drivers/iio/chemical/atlas-ezo-sensor.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * atlas-ezo-sensor.c - Support for Atlas Scientific EZO sensors
   4  *
   5  * Copyright (C) 2020 Konsulko Group
   6  * Author: Matt Ranostay <matt.ranostay@konsulko.com>
   7  */
   8
   9 #include <linux/init.h>
  10 #include <linux/delay.h>
  11 #include <linux/mod_devicetable.h>
  12 #include <linux/module.h>
  13 #include <linux/mutex.h>
  14 #include <linux/property.h>
  15 #include <linux/err.h>
  16 #include <linux/i2c.h>
  17
  18 #include <linux/iio/iio.h>
  19
  20 #define ATLAS_EZO_DRV_NAME              "atlas-ezo-sensor"
  21 #define ATLAS_INT_TIME_IN_MS            950
  22 #define ATLAS_INT_HUM_TIME_IN_MS        350
  23
  24 enum {
  25         ATLAS_CO2_EZO,
  26         ATLAS_O2_EZO,
  27         ATLAS_HUM_EZO,
  28 };
  29
  30 struct atlas_ezo_device {
  31         const struct iio_chan_spec *channels;
  32         int num_channels;
  33         int delay;
  34 };
  35
  36 struct atlas_ezo_data {
  37         struct i2c_client *client;
  38         const struct atlas_ezo_device *chip;
  39
  40         /* lock to avoid multiple concurrent read calls */
  41         struct mutex lock;
  42
  43         u8 buffer[8];
  44 };
  45
  46 #define ATLAS_CONCENTRATION_CHANNEL(_modifier) \
  47         { \
  48                 .type = IIO_CONCENTRATION, \
  49                 .modified = 1,\
  50                 .channel2 = _modifier, \
  51                 .info_mask_separate = \
  52                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), \
  53                 .scan_index = 0, \
  54                 .scan_type =  { \
  55                         .sign = 'u', \
  56                         .realbits = 32, \
  57                         .storagebits = 32, \
  58                         .endianness = IIO_CPU, \
  59                 }, \
  60         }
  61
  62 static const struct iio_chan_spec atlas_co2_ezo_channels[] = {
  63         ATLAS_CONCENTRATION_CHANNEL(IIO_MOD_CO2),
  64 };
  65
  66 static const struct iio_chan_spec atlas_o2_ezo_channels[] = {
  67         ATLAS_CONCENTRATION_CHANNEL(IIO_MOD_O2),
  68 };
  69
  70 static const struct iio_chan_spec atlas_hum_ezo_channels[] = {
  71         {
  72                 .type = IIO_HUMIDITYRELATIVE,
  73                 .info_mask_separate =
  74                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  75                 .scan_index = 0,
  76                 .scan_type =  {
  77                         .sign = 'u',
  78                         .realbits = 32,
  79                         .storagebits = 32,
  80                         .endianness = IIO_CPU,
  81                 },
  82         },
  83 };
  84
  85 static struct atlas_ezo_device atlas_ezo_devices[] = {
  86         [ATLAS_CO2_EZO] = {
  87                 .channels = atlas_co2_ezo_channels,
  88                 .num_channels = 1,
  89                 .delay = ATLAS_INT_TIME_IN_MS,
  90         },
  91         [ATLAS_O2_EZO] = {
  92                 .channels = atlas_o2_ezo_channels,
  93                 .num_channels = 1,
  94                 .delay = ATLAS_INT_TIME_IN_MS,
  95         },
  96         [ATLAS_HUM_EZO] = {
  97                 .channels = atlas_hum_ezo_channels,
  98                 .num_channels = 1,
  99                 .delay = ATLAS_INT_HUM_TIME_IN_MS,
 100         },
 101 };
 102
 103 static void atlas_ezo_sanitize(char *buf)
 104 {
 105         char *ptr = strchr(buf, '.');
 106
 107         if (!ptr)
 108                 return;
 109
 110         memmove(ptr, ptr + 1, strlen(ptr));
 111 }
 112
 113 static int atlas_ezo_read_raw(struct iio_dev *indio_dev,
 114                           struct iio_chan_spec const *chan,
 115                           int *val, int *val2, long mask)
 116 {
 117         struct atlas_ezo_data *data = iio_priv(indio_dev);
 118         struct i2c_client *client = data->client;
 119
 120         if (chan->type != IIO_CONCENTRATION)
 121                 return -EINVAL;
 122
 123         switch (mask) {
 124         case IIO_CHAN_INFO_RAW: {
 125                 int ret;
 126                 long tmp;
 127
 128                 mutex_lock(&data->lock);
 129
 130                 tmp = i2c_smbus_write_byte(client, 'R');
 131
 132                 if (tmp < 0) {
 133                         mutex_unlock(&data->lock);
 134                         return tmp;
 135                 }
 136
 137                 msleep(data->chip->delay);
 138
 139                 tmp = i2c_master_recv(client, data->buffer, sizeof(data->buffer));
 140
 141                 if (tmp < 0 || data->buffer[0] != 1) {
 142                         mutex_unlock(&data->lock);
 143                         return -EBUSY;
 144                 }
 145
 146                 /* removing floating point for fixed number representation */
 147                 atlas_ezo_sanitize(data->buffer + 2);
 148
 149                 ret = kstrtol(data->buffer + 1, 10, &tmp);
 150
 151                 *val = tmp;
 152
 153                 mutex_unlock(&data->lock);
 154
 155                 return ret ? ret : IIO_VAL_INT;
 156         }
 157         case IIO_CHAN_INFO_SCALE:
 158                 switch (chan->type) {
 159                 case IIO_HUMIDITYRELATIVE:
 160                         *val = 10;
 161                         return IIO_VAL_INT;
 162                 case IIO_CONCENTRATION:
 163                         break;
 164                 default:
 165                         return -EINVAL;
 166                 }
 167
 168                 /* IIO_CONCENTRATION modifiers */
 169                 switch (chan->channel2) {
 170                 case IIO_MOD_CO2:
 171                         *val = 0;
 172                         *val2 = 100; /* 0.0001 */
 173                         return IIO_VAL_INT_PLUS_MICRO;
 174                 case IIO_MOD_O2:
 175                         *val = 100;
 176                         return IIO_VAL_INT;
 177                 }
 178                 return -EINVAL;
 179         }
 180
 181         return 0;
 182 }
 183
 184 static const struct iio_info atlas_info = {
 185         .read_raw = atlas_ezo_read_raw,
 186 };
 187
 188 static const struct i2c_device_id atlas_ezo_id[] = {
 189         { "atlas-co2-ezo", (kernel_ulong_t)&atlas_ezo_devices[ATLAS_CO2_EZO] },
 190         { "atlas-o2-ezo", (kernel_ulong_t)&atlas_ezo_devices[ATLAS_O2_EZO] },
 191         { "atlas-hum-ezo", (kernel_ulong_t)&atlas_ezo_devices[ATLAS_HUM_EZO] },
 192         {}
 193 };
 194 MODULE_DEVICE_TABLE(i2c, atlas_ezo_id);
 195
 196 static const struct of_device_id atlas_ezo_dt_ids[] = {
 197         { .compatible = "atlas,co2-ezo", .data = &atlas_ezo_devices[ATLAS_CO2_EZO], },
 198         { .compatible = "atlas,o2-ezo", .data = &atlas_ezo_devices[ATLAS_O2_EZO], },
 199         { .compatible = "atlas,hum-ezo", .data = &atlas_ezo_devices[ATLAS_HUM_EZO], },
 200         {}
 201 };
 202 MODULE_DEVICE_TABLE(of, atlas_ezo_dt_ids);
 203
 204 static int atlas_ezo_probe(struct i2c_client *client)
 205 {
 206         const struct atlas_ezo_device *chip;
 207         struct atlas_ezo_data *data;
 208         struct iio_dev *indio_dev;
 209
 210         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 211         if (!indio_dev)
 212                 return -ENOMEM;
 213
 214         chip = i2c_get_match_data(client);
 215         if (!chip)
 216                 return -EINVAL;
 217
 218         indio_dev->info = &atlas_info;
 219         indio_dev->name = ATLAS_EZO_DRV_NAME;
 220         indio_dev->channels = chip->channels;
 221         indio_dev->num_channels = chip->num_channels;
 222         indio_dev->modes = INDIO_DIRECT_MODE;
 223
 224         data = iio_priv(indio_dev);
 225         data->client = client;
 226         data->chip = chip;
 227         mutex_init(&data->lock);
 228
 229         return devm_iio_device_register(&client->dev, indio_dev);
 230 };
 231
 232 static struct i2c_driver atlas_ezo_driver = {
 233         .driver = {
 234                 .name   = ATLAS_EZO_DRV_NAME,
 235                 .of_match_table = atlas_ezo_dt_ids,
 236         },
 237         .probe          = atlas_ezo_probe,
 238         .id_table       = atlas_ezo_id,
 239 };
 240 module_i2c_driver(atlas_ezo_driver);
 241
 242 MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
 243 MODULE_DESCRIPTION("Atlas Scientific EZO sensors");
 244 MODULE_LICENSE("GPL");