drivers/iio/temperature/tsys02d.c

   1 /*
   2  * tsys02d.c - Support for Measurement-Specialties tsys02d temperature sensor
   3  *
   4  * Copyright (c) 2015 Measurement-Specialties
   5  *
   6  * Licensed under the GPL-2.
   7  *
   8  * (7-bit I2C slave address 0x40)
   9  *
  10  * Datasheet:
  11  *  http://www.meas-spec.com/downloads/Digital_Sensor_TSYS02D.pdf
  12  */
  13
  14 #include <linux/init.h>
  15 #include <linux/device.h>
  16 #include <linux/kernel.h>
  17 #include <linux/stat.h>
  18 #include <linux/module.h>
  19 #include <linux/iio/iio.h>
  20 #include <linux/iio/sysfs.h>
  21
  22 #include "../common/ms_sensors/ms_sensors_i2c.h"
  23
  24 #define TSYS02D_RESET                           0xFE
  25
  26 static const int tsys02d_samp_freq[4] = { 20, 40, 70, 140 };
  27 /* String copy of the above const for readability purpose */
  28 static const char tsys02d_show_samp_freq[] = "20 40 70 140";
  29
  30 static int tsys02d_read_raw(struct iio_dev *indio_dev,
  31                             struct iio_chan_spec const *channel, int *val,
  32                             int *val2, long mask)
  33 {
  34         int ret;
  35         s32 temperature;
  36         struct ms_ht_dev *dev_data = iio_priv(indio_dev);
  37
  38         switch (mask) {
  39         case IIO_CHAN_INFO_PROCESSED:
  40                 switch (channel->type) {
  41                 case IIO_TEMP:  /* in milli °C */
  42                         ret = ms_sensors_ht_read_temperature(dev_data,
  43                                                              &temperature);
  44                         if (ret)
  45                                 return ret;
  46                         *val = temperature;
  47
  48                         return IIO_VAL_INT;
  49                 default:
  50                         return -EINVAL;
  51                 }
  52         case IIO_CHAN_INFO_SAMP_FREQ:
  53                 *val = tsys02d_samp_freq[dev_data->res_index];
  54
  55                 return IIO_VAL_INT;
  56         default:
  57                 return -EINVAL;
  58         }
  59 }
  60
  61 static int tsys02d_write_raw(struct iio_dev *indio_dev,
  62                              struct iio_chan_spec const *chan,
  63                              int val, int val2, long mask)
  64 {
  65         struct ms_ht_dev *dev_data = iio_priv(indio_dev);
  66         int i, ret;
  67
  68         switch (mask) {
  69         case IIO_CHAN_INFO_SAMP_FREQ:
  70                 i = ARRAY_SIZE(tsys02d_samp_freq);
  71                 while (i-- > 0)
  72                         if (val == tsys02d_samp_freq[i])
  73                                 break;
  74                 if (i < 0)
  75                         return -EINVAL;
  76                 mutex_lock(&dev_data->lock);
  77                 dev_data->res_index = i;
  78                 ret = ms_sensors_write_resolution(dev_data, i);
  79                 mutex_unlock(&dev_data->lock);
  80
  81                 return ret;
  82         default:
  83                 return -EINVAL;
  84         }
  85 }
  86
  87 static const struct iio_chan_spec tsys02d_channels[] = {
  88         {
  89                 .type = IIO_TEMP,
  90                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_PROCESSED),
  91                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
  92         }
  93 };
  94
  95 static ssize_t tsys02_read_battery_low(struct device *dev,
  96                                        struct device_attribute *attr,
  97                                        char *buf)
  98 {
  99         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 100         struct ms_ht_dev *dev_data = iio_priv(indio_dev);
 101
 102         return ms_sensors_show_battery_low(dev_data, buf);
 103 }
 104
 105 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(tsys02d_show_samp_freq);
 106 static IIO_DEVICE_ATTR(battery_low, S_IRUGO,
 107                        tsys02_read_battery_low, NULL, 0);
 108
 109 static struct attribute *tsys02d_attributes[] = {
 110         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 111         &iio_dev_attr_battery_low.dev_attr.attr,
 112         NULL,
 113 };
 114
 115 static const struct attribute_group tsys02d_attribute_group = {
 116         .attrs = tsys02d_attributes,
 117 };
 118
 119 static const struct iio_info tsys02d_info = {
 120         .read_raw = tsys02d_read_raw,
 121         .write_raw = tsys02d_write_raw,
 122         .attrs = &tsys02d_attribute_group,
 123         .driver_module = THIS_MODULE,
 124 };
 125
 126 static int tsys02d_probe(struct i2c_client *client,
 127                          const struct i2c_device_id *id)
 128 {
 129         struct ms_ht_dev *dev_data;
 130         struct iio_dev *indio_dev;
 131         int ret;
 132         u64 serial_number;
 133
 134         if (!i2c_check_functionality(client->adapter,
 135                                      I2C_FUNC_SMBUS_WRITE_BYTE_DATA |
 136                                      I2C_FUNC_SMBUS_WRITE_BYTE |
 137                                      I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
 138                 dev_err(&client->dev,
 139                         "Adapter does not support some i2c transaction\n");
 140                 return -EOPNOTSUPP;
 141         }
 142
 143         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*dev_data));
 144         if (!indio_dev)
 145                 return -ENOMEM;
 146
 147         dev_data = iio_priv(indio_dev);
 148         dev_data->client = client;
 149         dev_data->res_index = 0;
 150         mutex_init(&dev_data->lock);
 151
 152         indio_dev->info = &tsys02d_info;
 153         indio_dev->name = id->name;
 154         indio_dev->dev.parent = &client->dev;
 155         indio_dev->modes = INDIO_DIRECT_MODE;
 156         indio_dev->channels = tsys02d_channels;
 157         indio_dev->num_channels = ARRAY_SIZE(tsys02d_channels);
 158
 159         i2c_set_clientdata(client, indio_dev);
 160
 161         ret = ms_sensors_reset(client, TSYS02D_RESET, 15000);
 162         if (ret)
 163                 return ret;
 164
 165         ret = ms_sensors_read_serial(client, &serial_number);
 166         if (ret)
 167                 return ret;
 168         dev_info(&client->dev, "Serial number : %llx", serial_number);
 169
 170         return devm_iio_device_register(&client->dev, indio_dev);
 171 }
 172
 173 static const struct i2c_device_id tsys02d_id[] = {
 174         {"tsys02d", 0},
 175         {}
 176 };
 177 MODULE_DEVICE_TABLE(i2c, tsys02d_id);
 178
 179 static struct i2c_driver tsys02d_driver = {
 180         .probe = tsys02d_probe,
 181         .id_table = tsys02d_id,
 182         .driver = {
 183                    .name = "tsys02d",
 184                    },
 185 };
 186
 187 module_i2c_driver(tsys02d_driver);
 188
 189 MODULE_DESCRIPTION("Measurement-Specialties tsys02d temperature driver");
 190 MODULE_AUTHOR("William Markezana <william.markezana@meas-spec.com>");
 191 MODULE_AUTHOR("Ludovic Tancerel <ludovic.tancerel@maplehightech.com>");
 192 MODULE_LICENSE("GPL v2");