1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * tsys01.c - Support for Measurement-Specialties tsys01 temperature sensor 4 * 5 * Copyright (c) 2015 Measurement-Specialties 6 * 7 * Datasheet: 8 * http://www.meas-spec.com/downloads/TSYS01_Digital_Temperature_Sensor.pdf 9 */ 10 11 #include <linux/iio/iio.h> 12 #include <linux/iio/sysfs.h> 13 #include <linux/device.h> 14 #include <linux/mutex.h> 15 #include <linux/module.h> 16 #include <linux/mod_devicetable.h> 17 #include <linux/init.h> 18 #include <linux/kernel.h> 19 #include <linux/stat.h> 20 #include "../common/ms_sensors/ms_sensors_i2c.h" 21 22 /* TSYS01 Commands */ 23 #define TSYS01_RESET 0x1E 24 #define TSYS01_CONVERSION_START 0x48 25 #define TSYS01_ADC_READ 0x00 26 #define TSYS01_PROM_READ 0xA0 27 28 #define TSYS01_PROM_WORDS_NB 8 29 30 struct tsys01_dev { 31 void *client; 32 struct mutex lock; /* lock during conversion */ 33 34 int (*reset)(void *cli, u8 cmd, unsigned int delay); 35 int (*convert_and_read)(void *cli, u8 conv, u8 rd, 36 unsigned int delay, u32 *adc); 37 int (*read_prom_word)(void *cli, int cmd, u16 *word); 38 39 u16 prom[TSYS01_PROM_WORDS_NB]; 40 }; 41 42 /* Multiplication coefficients for temperature computation */ 43 static const int coeff_mul[] = { -1500000, 1000000, -2000000, 44 4000000, -2000000 }; 45 46 static int tsys01_read_temperature(struct iio_dev *indio_dev, 47 s32 *temperature) 48 { 49 int ret, i; 50 u32 adc; 51 s64 temp = 0; 52 struct tsys01_dev *dev_data = iio_priv(indio_dev); 53 54 mutex_lock(&dev_data->lock); 55 ret = dev_data->convert_and_read(dev_data->client, 56 TSYS01_CONVERSION_START, 57 TSYS01_ADC_READ, 9000, &adc); 58 mutex_unlock(&dev_data->lock); 59 if (ret) 60 return ret; 61 62 adc >>= 8; 63 64 /* Temperature algorithm */ 65 for (i = 4; i > 0; i--) { 66 temp += coeff_mul[i] * 67 (s64)dev_data->prom[5 - i]; 68 temp *= (s64)adc; 69 temp = div64_s64(temp, 100000); 70 } 71 temp *= 10; 72 temp += coeff_mul[0] * (s64)dev_data->prom[5]; 73 temp = div64_s64(temp, 100000); 74 75 *temperature = temp; 76 77 return 0; 78 } 79 80 static int tsys01_read_raw(struct iio_dev *indio_dev, 81 struct iio_chan_spec const *channel, int *val, 82 int *val2, long mask) 83 { 84 int ret; 85 s32 temperature; 86 87 switch (mask) { 88 case IIO_CHAN_INFO_PROCESSED: 89 switch (channel->type) { 90 case IIO_TEMP: /* in milli °C */ 91 ret = tsys01_read_temperature(indio_dev, &temperature); 92 if (ret) 93 return ret; 94 *val = temperature; 95 96 return IIO_VAL_INT; 97 default: 98 return -EINVAL; 99 } 100 default: 101 return -EINVAL; 102 } 103 } 104 105 static const struct iio_chan_spec tsys01_channels[] = { 106 { 107 .type = IIO_TEMP, 108 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_PROCESSED), 109 } 110 }; 111 112 static const struct iio_info tsys01_info = { 113 .read_raw = tsys01_read_raw, 114 }; 115 116 static bool tsys01_crc_valid(u16 *n_prom) 117 { 118 u8 cnt; 119 u8 sum = 0; 120 121 for (cnt = 0; cnt < TSYS01_PROM_WORDS_NB; cnt++) 122 sum += ((n_prom[0] >> 8) + (n_prom[0] & 0xFF)); 123 124 return (sum == 0); 125 } 126 127 static int tsys01_read_prom(struct iio_dev *indio_dev) 128 { 129 int i, ret; 130 struct tsys01_dev *dev_data = iio_priv(indio_dev); 131 char buf[7 * TSYS01_PROM_WORDS_NB + 1]; 132 char *ptr = buf; 133 134 for (i = 0; i < TSYS01_PROM_WORDS_NB; i++) { 135 ret = dev_data->read_prom_word(dev_data->client, 136 TSYS01_PROM_READ + (i << 1), 137 &dev_data->prom[i]); 138 if (ret) 139 return ret; 140 141 ret = sprintf(ptr, "0x%04x ", dev_data->prom[i]); 142 ptr += ret; 143 } 144 145 if (!tsys01_crc_valid(dev_data->prom)) { 146 dev_err(&indio_dev->dev, "prom crc check error\n"); 147 return -ENODEV; 148 } 149 *ptr = 0; 150 dev_info(&indio_dev->dev, "PROM coefficients : %s\n", buf); 151 152 return 0; 153 } 154 155 static int tsys01_probe(struct iio_dev *indio_dev, struct device *dev) 156 { 157 int ret; 158 struct tsys01_dev *dev_data = iio_priv(indio_dev); 159 160 mutex_init(&dev_data->lock); 161 162 indio_dev->info = &tsys01_info; 163 indio_dev->name = dev->driver->name; 164 indio_dev->modes = INDIO_DIRECT_MODE; 165 indio_dev->channels = tsys01_channels; 166 indio_dev->num_channels = ARRAY_SIZE(tsys01_channels); 167 168 ret = dev_data->reset(dev_data->client, TSYS01_RESET, 3000); 169 if (ret) 170 return ret; 171 172 ret = tsys01_read_prom(indio_dev); 173 if (ret) 174 return ret; 175 176 return devm_iio_device_register(dev, indio_dev); 177 } 178 179 static int tsys01_i2c_probe(struct i2c_client *client) 180 { 181 struct tsys01_dev *dev_data; 182 struct iio_dev *indio_dev; 183 184 if (!i2c_check_functionality(client->adapter, 185 I2C_FUNC_SMBUS_WORD_DATA | 186 I2C_FUNC_SMBUS_WRITE_BYTE | 187 I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { 188 dev_err(&client->dev, 189 "Adapter does not support some i2c transaction\n"); 190 return -EOPNOTSUPP; 191 } 192 193 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*dev_data)); 194 if (!indio_dev) 195 return -ENOMEM; 196 197 dev_data = iio_priv(indio_dev); 198 dev_data->client = client; 199 dev_data->reset = ms_sensors_reset; 200 dev_data->read_prom_word = ms_sensors_read_prom_word; 201 dev_data->convert_and_read = ms_sensors_convert_and_read; 202 203 i2c_set_clientdata(client, indio_dev); 204 205 return tsys01_probe(indio_dev, &client->dev); 206 } 207 208 static const struct i2c_device_id tsys01_id[] = { 209 {"tsys01", 0}, 210 {} 211 }; 212 MODULE_DEVICE_TABLE(i2c, tsys01_id); 213 214 static const struct of_device_id tsys01_of_match[] = { 215 { .compatible = "meas,tsys01", }, 216 { }, 217 }; 218 MODULE_DEVICE_TABLE(of, tsys01_of_match); 219 220 static struct i2c_driver tsys01_driver = { 221 .probe_new = tsys01_i2c_probe, 222 .id_table = tsys01_id, 223 .driver = { 224 .name = "tsys01", 225 .of_match_table = tsys01_of_match, 226 }, 227 }; 228 229 module_i2c_driver(tsys01_driver); 230 231 MODULE_DESCRIPTION("Measurement-Specialties tsys01 temperature driver"); 232 MODULE_AUTHOR("William Markezana <william.markezana@meas-spec.com>"); 233 MODULE_AUTHOR("Ludovic Tancerel <ludovic.tancerel@maplehightech.com>"); 234 MODULE_LICENSE("GPL v2"); 235 MODULE_IMPORT_NS(IIO_MEAS_SPEC_SENSORS); 236