1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * ens210.c - Support for ScioSense ens210 temperature & humidity sensor family 4 * 5 * (7-bit I2C slave address 0x43 ENS210) 6 * (7-bit I2C slave address 0x43 ENS210A) 7 * (7-bit I2C slave address 0x44 ENS211) 8 * (7-bit I2C slave address 0x45 ENS212) 9 * (7-bit I2C slave address 0x46 ENS213A) 10 * (7-bit I2C slave address 0x47 ENS215) 11 * 12 * Datasheet: 13 * https://www.sciosense.com/wp-content/uploads/2024/04/ENS21x-Datasheet.pdf 14 * https://www.sciosense.com/wp-content/uploads/2023/12/ENS210-Datasheet.pdf 15 */ 16 17 #include <linux/crc7.h> 18 #include <linux/delay.h> 19 #include <linux/i2c.h> 20 #include <linux/iio/iio.h> 21 #include <linux/mod_devicetable.h> 22 #include <linux/module.h> 23 #include <linux/types.h> 24 25 #include <linux/unaligned.h> 26 27 /* register definitions */ 28 #define ENS210_REG_PART_ID 0x00 29 #define ENS210_REG_DIE_REV 0x02 30 #define ENS210_REG_UID 0x04 31 #define ENS210_REG_SYS_CTRL 0x10 32 #define ENS210_REG_SYS_STAT 0x11 33 #define ENS210_REG_SENS_RUN 0x21 34 #define ENS210_REG_SENS_START 0x22 35 #define ENS210_REG_SENS_STOP 0x23 36 #define ENS210_REG_SENS_STAT 0x24 37 #define ENS210_REG_T_VAL 0x30 38 #define ENS210_REG_H_VAL 0x33 39 40 /* value definitions */ 41 #define ENS210_SENS_START_T_START BIT(0) 42 #define ENS210_SENS_START_H_START BIT(1) 43 44 #define ENS210_SENS_STAT_T_ACTIVE BIT(0) 45 #define ENS210_SENS_STAT_H_ACTIVE BIT(1) 46 47 #define ENS210_SYS_CTRL_LOW_POWER_ENABLE BIT(0) 48 #define ENS210_SYS_CTRL_SYS_RESET BIT(7) 49 50 #define ENS210_SYS_STAT_SYS_ACTIVE BIT(0) 51 52 enum ens210_partnumber { 53 ENS210 = 0x0210, 54 ENS210A = 0xa210, 55 ENS211 = 0x0211, 56 ENS212 = 0x0212, 57 ENS213A = 0xa213, 58 ENS215 = 0x0215, 59 }; 60 61 /** 62 * struct ens210_chip_info - Humidity/Temperature chip specific information 63 * @name: name of device 64 * @part_id: chip identifier 65 * @conv_time_msec: time for conversion calculation in m/s 66 */ 67 struct ens210_chip_info { 68 const char *name; 69 enum ens210_partnumber part_id; 70 unsigned int conv_time_msec; 71 }; 72 73 /** 74 * struct ens210_data - Humidity/Temperature sensor device structure 75 * @client: i2c client 76 * @chip_info: chip specific information 77 * @lock: lock protecting against simultaneous callers of get_measurement 78 * since multiple uninterrupted transactions are required 79 */ 80 struct ens210_data { 81 struct i2c_client *client; 82 const struct ens210_chip_info *chip_info; 83 struct mutex lock; 84 }; 85 86 /* calculate 17-bit crc7 */ 87 static u8 ens210_crc7(u32 val) 88 { 89 unsigned int val_be = (val & 0x1ffff) >> 0x8; 90 91 return crc7_be(0xde, (u8 *)&val_be, 3) >> 1; 92 } 93 94 static int ens210_get_measurement(struct iio_dev *indio_dev, bool temp, int *val) 95 { 96 struct ens210_data *data = iio_priv(indio_dev); 97 struct device *dev = &data->client->dev; 98 u32 regval; 99 u8 regval_le[3]; 100 int ret; 101 102 /* assert read */ 103 ret = i2c_smbus_write_byte_data(data->client, ENS210_REG_SENS_START, 104 temp ? ENS210_SENS_START_T_START : 105 ENS210_SENS_START_H_START); 106 if (ret) 107 return ret; 108 109 /* wait for conversion to be ready */ 110 msleep(data->chip_info->conv_time_msec); 111 112 ret = i2c_smbus_read_byte_data(data->client, ENS210_REG_SENS_STAT); 113 if (ret < 0) 114 return ret; 115 116 /* perform read */ 117 ret = i2c_smbus_read_i2c_block_data( 118 data->client, temp ? ENS210_REG_T_VAL : ENS210_REG_H_VAL, 3, 119 regval_le); 120 if (ret < 0) { 121 dev_err(dev, "failed to read register"); 122 return -EIO; 123 } 124 if (ret != 3) { 125 dev_err(dev, "expected 3 bytes, received %d\n", ret); 126 return -EIO; 127 } 128 129 regval = get_unaligned_le24(regval_le); 130 if (ens210_crc7(regval) != ((regval >> 17) & 0x7f)) { 131 dev_err(dev, "invalid crc\n"); 132 return -EIO; 133 } 134 135 if (!((regval >> 16) & 0x1)) { 136 dev_err(dev, "data is not valid"); 137 return -EIO; 138 } 139 140 *val = regval & GENMASK(15, 0); 141 return IIO_VAL_INT; 142 } 143 144 static int ens210_read_raw(struct iio_dev *indio_dev, 145 struct iio_chan_spec const *channel, int *val, 146 int *val2, long mask) 147 { 148 struct ens210_data *data = iio_priv(indio_dev); 149 int ret; 150 151 switch (mask) { 152 case IIO_CHAN_INFO_RAW: { 153 guard(mutex)(&data->lock); 154 155 ret = ens210_get_measurement(indio_dev, channel->type == IIO_TEMP, 156 val); 157 if (ret) 158 return ret; 159 160 return IIO_VAL_INT; 161 } 162 case IIO_CHAN_INFO_SCALE: 163 if (channel->type == IIO_TEMP) { 164 *val = 15; 165 *val2 = 625000; 166 } else { 167 *val = 1; 168 *val2 = 953125; 169 } 170 return IIO_VAL_INT_PLUS_MICRO; 171 case IIO_CHAN_INFO_OFFSET: 172 *val = -17481; 173 *val2 = 600000; 174 return IIO_VAL_INT_PLUS_MICRO; 175 default: 176 return -EINVAL; 177 } 178 } 179 180 static const struct iio_chan_spec ens210_channels[] = { 181 { 182 .type = IIO_TEMP, 183 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 184 BIT(IIO_CHAN_INFO_SCALE) | 185 BIT(IIO_CHAN_INFO_OFFSET), 186 }, 187 { 188 .type = IIO_HUMIDITYRELATIVE, 189 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 190 BIT(IIO_CHAN_INFO_SCALE), 191 } 192 }; 193 194 static const struct iio_info ens210_info = { 195 .read_raw = ens210_read_raw, 196 }; 197 198 static int ens210_probe(struct i2c_client *client) 199 { 200 struct ens210_data *data; 201 struct iio_dev *indio_dev; 202 uint16_t part_id; 203 int ret; 204 205 if (!i2c_check_functionality(client->adapter, 206 I2C_FUNC_SMBUS_WRITE_BYTE_DATA | 207 I2C_FUNC_SMBUS_WRITE_BYTE | 208 I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { 209 return dev_err_probe(&client->dev, -EOPNOTSUPP, 210 "adapter does not support some i2c transactions\n"); 211 } 212 213 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 214 if (!indio_dev) 215 return -ENOMEM; 216 217 data = iio_priv(indio_dev); 218 data->client = client; 219 mutex_init(&data->lock); 220 data->chip_info = i2c_get_match_data(client); 221 222 ret = devm_regulator_get_enable(&client->dev, "vdd"); 223 if (ret) 224 return ret; 225 226 /* reset device */ 227 ret = i2c_smbus_write_byte_data(client, ENS210_REG_SYS_CTRL, 228 ENS210_SYS_CTRL_SYS_RESET); 229 if (ret) 230 return ret; 231 232 /* wait for device to become active */ 233 usleep_range(4000, 5000); 234 235 /* disable low power mode */ 236 ret = i2c_smbus_write_byte_data(client, ENS210_REG_SYS_CTRL, 0x00); 237 if (ret) 238 return ret; 239 240 /* wait for device to finish */ 241 usleep_range(4000, 5000); 242 243 /* get part_id */ 244 ret = i2c_smbus_read_word_data(client, ENS210_REG_PART_ID); 245 if (ret < 0) 246 return ret; 247 part_id = ret; 248 249 if (part_id != data->chip_info->part_id) { 250 dev_info(&client->dev, 251 "Part ID does not match (0x%04x != 0x%04x)\n", part_id, 252 data->chip_info->part_id); 253 } 254 255 /* reenable low power */ 256 ret = i2c_smbus_write_byte_data(client, ENS210_REG_SYS_CTRL, 257 ENS210_SYS_CTRL_LOW_POWER_ENABLE); 258 if (ret) 259 return ret; 260 261 indio_dev->name = data->chip_info->name; 262 indio_dev->modes = INDIO_DIRECT_MODE; 263 indio_dev->channels = ens210_channels; 264 indio_dev->num_channels = ARRAY_SIZE(ens210_channels); 265 indio_dev->info = &ens210_info; 266 267 return devm_iio_device_register(&client->dev, indio_dev); 268 } 269 270 static const struct ens210_chip_info ens210_chip_info_data = { 271 .name = "ens210", 272 .part_id = ENS210, 273 .conv_time_msec = 130, 274 }; 275 276 static const struct ens210_chip_info ens210a_chip_info_data = { 277 .name = "ens210a", 278 .part_id = ENS210A, 279 .conv_time_msec = 130, 280 }; 281 282 static const struct ens210_chip_info ens211_chip_info_data = { 283 .name = "ens211", 284 .part_id = ENS211, 285 .conv_time_msec = 32, 286 }; 287 288 static const struct ens210_chip_info ens212_chip_info_data = { 289 .name = "ens212", 290 .part_id = ENS212, 291 .conv_time_msec = 32, 292 }; 293 294 static const struct ens210_chip_info ens213a_chip_info_data = { 295 .name = "ens213a", 296 .part_id = ENS213A, 297 .conv_time_msec = 130, 298 }; 299 300 static const struct ens210_chip_info ens215_chip_info_data = { 301 .name = "ens215", 302 .part_id = ENS215, 303 .conv_time_msec = 130, 304 }; 305 306 static const struct of_device_id ens210_of_match[] = { 307 { .compatible = "sciosense,ens210", .data = &ens210_chip_info_data }, 308 { .compatible = "sciosense,ens210a", .data = &ens210a_chip_info_data }, 309 { .compatible = "sciosense,ens211", .data = &ens211_chip_info_data }, 310 { .compatible = "sciosense,ens212", .data = &ens212_chip_info_data }, 311 { .compatible = "sciosense,ens213a", .data = &ens213a_chip_info_data }, 312 { .compatible = "sciosense,ens215", .data = &ens215_chip_info_data }, 313 { } 314 }; 315 MODULE_DEVICE_TABLE(of, ens210_of_match); 316 317 static const struct i2c_device_id ens210_id_table[] = { 318 { .name = "ens210", .driver_data = (kernel_ulong_t)&ens210_chip_info_data }, 319 { .name = "ens210a", .driver_data = (kernel_ulong_t)&ens210a_chip_info_data }, 320 { .name = "ens211", .driver_data = (kernel_ulong_t)&ens211_chip_info_data }, 321 { .name = "ens212", .driver_data = (kernel_ulong_t)&ens212_chip_info_data }, 322 { .name = "ens213a", .driver_data = (kernel_ulong_t)&ens213a_chip_info_data }, 323 { .name = "ens215", .driver_data = (kernel_ulong_t)&ens215_chip_info_data }, 324 { } 325 }; 326 MODULE_DEVICE_TABLE(i2c, ens210_id_table); 327 328 static struct i2c_driver ens210_driver = { 329 .probe = ens210_probe, 330 .id_table = ens210_id_table, 331 .driver = { 332 .name = "ens210", 333 .of_match_table = ens210_of_match, 334 }, 335 }; 336 module_i2c_driver(ens210_driver); 337 338 MODULE_DESCRIPTION("ScioSense ENS210 temperature and humidity sensor driver"); 339 MODULE_AUTHOR("Joshua Felmeden <jfelmeden@thegoodpenguin.co.uk>"); 340 MODULE_LICENSE("GPL"); 341