1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Senseair Sunrise 006-0-0007 CO2 sensor driver. 4 * 5 * Copyright (C) 2021 Jacopo Mondi 6 * 7 * List of features not yet supported by the driver: 8 * - controllable EN pin 9 * - single-shot operations using the nDRY pin. 10 * - ABC/target calibration 11 */ 12 13 #include <linux/bitops.h> 14 #include <linux/i2c.h> 15 #include <linux/kernel.h> 16 #include <linux/mod_devicetable.h> 17 #include <linux/module.h> 18 #include <linux/mutex.h> 19 #include <linux/regmap.h> 20 #include <linux/time64.h> 21 22 #include <linux/iio/iio.h> 23 24 #define DRIVER_NAME "sunrise_co2" 25 26 #define SUNRISE_ERROR_STATUS_REG 0x00 27 #define SUNRISE_CO2_FILTERED_COMP_REG 0x06 28 #define SUNRISE_CHIP_TEMPERATURE_REG 0x08 29 #define SUNRISE_CALIBRATION_STATUS_REG 0x81 30 #define SUNRISE_CALIBRATION_COMMAND_REG 0x82 31 #define SUNRISE_CALIBRATION_FACTORY_CMD 0x7c02 32 #define SUNRISE_CALIBRATION_BACKGROUND_CMD 0x7c06 33 /* 34 * The calibration timeout is not characterized in the datasheet. 35 * Use 30 seconds as a reasonable upper limit. 36 */ 37 #define SUNRISE_CALIBRATION_TIMEOUT_US (30 * USEC_PER_SEC) 38 39 struct sunrise_dev { 40 struct i2c_client *client; 41 struct regmap *regmap; 42 /* Protects access to IIO attributes. */ 43 struct mutex lock; 44 bool ignore_nak; 45 }; 46 47 /* Custom regmap read/write operations: perform unlocked access to the i2c bus. */ 48 49 static int sunrise_regmap_read(void *context, const void *reg_buf, 50 size_t reg_size, void *val_buf, size_t val_size) 51 { 52 struct i2c_client *client = context; 53 struct sunrise_dev *sunrise = i2c_get_clientdata(client); 54 union i2c_smbus_data data; 55 int ret; 56 57 if (reg_size != 1 || !val_size) 58 return -EINVAL; 59 60 memset(&data, 0, sizeof(data)); 61 data.block[0] = val_size; 62 63 /* 64 * Wake up sensor by sending sensor address: START, sensor address, 65 * STOP. Sensor will not ACK this byte. 66 * 67 * The chip enters a low power state after 15ms without 68 * communications or after a complete read/write sequence. 69 */ 70 __i2c_smbus_xfer(client->adapter, client->addr, 71 sunrise->ignore_nak ? I2C_M_IGNORE_NAK : 0, 72 I2C_SMBUS_WRITE, 0, I2C_SMBUS_BYTE_DATA, &data); 73 74 usleep_range(500, 1500); 75 76 ret = __i2c_smbus_xfer(client->adapter, client->addr, client->flags, 77 I2C_SMBUS_READ, ((u8 *)reg_buf)[0], 78 I2C_SMBUS_I2C_BLOCK_DATA, &data); 79 if (ret < 0) 80 return ret; 81 82 memcpy(val_buf, &data.block[1], data.block[0]); 83 84 return 0; 85 } 86 87 static int sunrise_regmap_write(void *context, const void *val_buf, size_t count) 88 { 89 struct i2c_client *client = context; 90 struct sunrise_dev *sunrise = i2c_get_clientdata(client); 91 union i2c_smbus_data data; 92 93 /* Discard reg address from values count. */ 94 if (!count) 95 return -EINVAL; 96 count--; 97 98 memset(&data, 0, sizeof(data)); 99 data.block[0] = count; 100 memcpy(&data.block[1], (u8 *)val_buf + 1, count); 101 102 __i2c_smbus_xfer(client->adapter, client->addr, 103 sunrise->ignore_nak ? I2C_M_IGNORE_NAK : 0, 104 I2C_SMBUS_WRITE, 0, I2C_SMBUS_BYTE_DATA, &data); 105 106 usleep_range(500, 1500); 107 108 return __i2c_smbus_xfer(client->adapter, client->addr, client->flags, 109 I2C_SMBUS_WRITE, ((u8 *)val_buf)[0], 110 I2C_SMBUS_I2C_BLOCK_DATA, &data); 111 } 112 113 /* 114 * Sunrise i2c read/write operations: lock the i2c segment to avoid losing the 115 * wake up session. Use custom regmap operations that perform unlocked access to 116 * the i2c bus. 117 */ 118 static int sunrise_read_byte(struct sunrise_dev *sunrise, u8 reg) 119 { 120 const struct i2c_client *client = sunrise->client; 121 const struct device *dev = &client->dev; 122 unsigned int val; 123 int ret; 124 125 i2c_lock_bus(client->adapter, I2C_LOCK_SEGMENT); 126 ret = regmap_read(sunrise->regmap, reg, &val); 127 i2c_unlock_bus(client->adapter, I2C_LOCK_SEGMENT); 128 if (ret) { 129 dev_err(dev, "Read byte failed: reg 0x%02x (%d)\n", reg, ret); 130 return ret; 131 } 132 133 return val; 134 } 135 136 static int sunrise_read_word(struct sunrise_dev *sunrise, u8 reg, u16 *val) 137 { 138 const struct i2c_client *client = sunrise->client; 139 const struct device *dev = &client->dev; 140 __be16 be_val; 141 int ret; 142 143 i2c_lock_bus(client->adapter, I2C_LOCK_SEGMENT); 144 ret = regmap_bulk_read(sunrise->regmap, reg, &be_val, sizeof(be_val)); 145 i2c_unlock_bus(client->adapter, I2C_LOCK_SEGMENT); 146 if (ret) { 147 dev_err(dev, "Read word failed: reg 0x%02x (%d)\n", reg, ret); 148 return ret; 149 } 150 151 *val = be16_to_cpu(be_val); 152 153 return 0; 154 } 155 156 static int sunrise_write_byte(struct sunrise_dev *sunrise, u8 reg, u8 val) 157 { 158 const struct i2c_client *client = sunrise->client; 159 const struct device *dev = &client->dev; 160 int ret; 161 162 i2c_lock_bus(client->adapter, I2C_LOCK_SEGMENT); 163 ret = regmap_write(sunrise->regmap, reg, val); 164 i2c_unlock_bus(client->adapter, I2C_LOCK_SEGMENT); 165 if (ret) 166 dev_err(dev, "Write byte failed: reg 0x%02x (%d)\n", reg, ret); 167 168 return ret; 169 } 170 171 static int sunrise_write_word(struct sunrise_dev *sunrise, u8 reg, u16 data) 172 { 173 const struct i2c_client *client = sunrise->client; 174 const struct device *dev = &client->dev; 175 __be16 be_data = cpu_to_be16(data); 176 int ret; 177 178 i2c_lock_bus(client->adapter, I2C_LOCK_SEGMENT); 179 ret = regmap_bulk_write(sunrise->regmap, reg, &be_data, sizeof(be_data)); 180 i2c_unlock_bus(client->adapter, I2C_LOCK_SEGMENT); 181 if (ret) 182 dev_err(dev, "Write word failed: reg 0x%02x (%d)\n", reg, ret); 183 184 return ret; 185 } 186 187 /* Trigger a calibration cycle. */ 188 189 enum { 190 SUNRISE_CALIBRATION_FACTORY, 191 SUNRISE_CALIBRATION_BACKGROUND, 192 }; 193 194 static const struct sunrise_calib_data { 195 u16 cmd; 196 u8 bit; 197 const char * const name; 198 } calib_data[] = { 199 [SUNRISE_CALIBRATION_FACTORY] = { 200 SUNRISE_CALIBRATION_FACTORY_CMD, 201 BIT(2), 202 "factory_calibration", 203 }, 204 [SUNRISE_CALIBRATION_BACKGROUND] = { 205 SUNRISE_CALIBRATION_BACKGROUND_CMD, 206 BIT(5), 207 "background_calibration", 208 }, 209 }; 210 211 static int sunrise_calibrate(struct sunrise_dev *sunrise, 212 const struct sunrise_calib_data *data) 213 { 214 unsigned int status; 215 int ret; 216 217 /* Reset the calibration status reg. */ 218 ret = sunrise_write_byte(sunrise, SUNRISE_CALIBRATION_STATUS_REG, 0x00); 219 if (ret) 220 return ret; 221 222 /* Write a calibration command and poll the calibration status bit. */ 223 ret = sunrise_write_word(sunrise, SUNRISE_CALIBRATION_COMMAND_REG, data->cmd); 224 if (ret) 225 return ret; 226 227 dev_dbg(&sunrise->client->dev, "%s in progress\n", data->name); 228 229 /* 230 * Calibration takes several seconds, so the sleep time between reads 231 * can be pretty relaxed. 232 */ 233 return read_poll_timeout(sunrise_read_byte, status, status & data->bit, 234 200000, SUNRISE_CALIBRATION_TIMEOUT_US, false, 235 sunrise, SUNRISE_CALIBRATION_STATUS_REG); 236 } 237 238 static ssize_t sunrise_cal_factory_write(struct iio_dev *iiodev, 239 uintptr_t private, 240 const struct iio_chan_spec *chan, 241 const char *buf, size_t len) 242 { 243 struct sunrise_dev *sunrise = iio_priv(iiodev); 244 bool enable; 245 int ret; 246 247 ret = kstrtobool(buf, &enable); 248 if (ret) 249 return ret; 250 251 if (!enable) 252 return len; 253 254 mutex_lock(&sunrise->lock); 255 ret = sunrise_calibrate(sunrise, &calib_data[SUNRISE_CALIBRATION_FACTORY]); 256 mutex_unlock(&sunrise->lock); 257 if (ret) 258 return ret; 259 260 return len; 261 } 262 263 static ssize_t sunrise_cal_background_write(struct iio_dev *iiodev, 264 uintptr_t private, 265 const struct iio_chan_spec *chan, 266 const char *buf, size_t len) 267 { 268 struct sunrise_dev *sunrise = iio_priv(iiodev); 269 bool enable; 270 int ret; 271 272 ret = kstrtobool(buf, &enable); 273 if (ret) 274 return ret; 275 276 if (!enable) 277 return len; 278 279 mutex_lock(&sunrise->lock); 280 ret = sunrise_calibrate(sunrise, &calib_data[SUNRISE_CALIBRATION_BACKGROUND]); 281 mutex_unlock(&sunrise->lock); 282 if (ret) 283 return ret; 284 285 return len; 286 } 287 288 /* Enumerate and retrieve the chip error status. */ 289 enum { 290 SUNRISE_ERROR_FATAL, 291 SUNRISE_ERROR_I2C, 292 SUNRISE_ERROR_ALGORITHM, 293 SUNRISE_ERROR_CALIBRATION, 294 SUNRISE_ERROR_SELF_DIAGNOSTIC, 295 SUNRISE_ERROR_OUT_OF_RANGE, 296 SUNRISE_ERROR_MEMORY, 297 SUNRISE_ERROR_NO_MEASUREMENT, 298 SUNRISE_ERROR_LOW_VOLTAGE, 299 SUNRISE_ERROR_MEASUREMENT_TIMEOUT, 300 }; 301 302 static const char * const sunrise_error_statuses[] = { 303 [SUNRISE_ERROR_FATAL] = "error_fatal", 304 [SUNRISE_ERROR_I2C] = "error_i2c", 305 [SUNRISE_ERROR_ALGORITHM] = "error_algorithm", 306 [SUNRISE_ERROR_CALIBRATION] = "error_calibration", 307 [SUNRISE_ERROR_SELF_DIAGNOSTIC] = "error_self_diagnostic", 308 [SUNRISE_ERROR_OUT_OF_RANGE] = "error_out_of_range", 309 [SUNRISE_ERROR_MEMORY] = "error_memory", 310 [SUNRISE_ERROR_NO_MEASUREMENT] = "error_no_measurement", 311 [SUNRISE_ERROR_LOW_VOLTAGE] = "error_low_voltage", 312 [SUNRISE_ERROR_MEASUREMENT_TIMEOUT] = "error_measurement_timeout", 313 }; 314 315 static const struct iio_enum sunrise_error_statuses_enum = { 316 .items = sunrise_error_statuses, 317 .num_items = ARRAY_SIZE(sunrise_error_statuses), 318 }; 319 320 static ssize_t sunrise_error_status_read(struct iio_dev *iiodev, 321 uintptr_t private, 322 const struct iio_chan_spec *chan, 323 char *buf) 324 { 325 struct sunrise_dev *sunrise = iio_priv(iiodev); 326 unsigned long errors; 327 ssize_t len = 0; 328 u16 value; 329 int ret; 330 u8 i; 331 332 mutex_lock(&sunrise->lock); 333 ret = sunrise_read_word(sunrise, SUNRISE_ERROR_STATUS_REG, &value); 334 if (ret) { 335 mutex_unlock(&sunrise->lock); 336 return ret; 337 } 338 339 errors = value; 340 for_each_set_bit(i, &errors, ARRAY_SIZE(sunrise_error_statuses)) 341 len += sysfs_emit_at(buf, len, "%s ", sunrise_error_statuses[i]); 342 343 if (len) 344 buf[len - 1] = '\n'; 345 346 mutex_unlock(&sunrise->lock); 347 348 return len; 349 } 350 351 static const struct iio_chan_spec_ext_info sunrise_concentration_ext_info[] = { 352 /* Calibration triggers. */ 353 { 354 .name = "calibration_factory", 355 .write = sunrise_cal_factory_write, 356 .shared = IIO_SEPARATE, 357 }, 358 { 359 .name = "calibration_background", 360 .write = sunrise_cal_background_write, 361 .shared = IIO_SEPARATE, 362 }, 363 364 /* Error statuses. */ 365 { 366 .name = "error_status", 367 .read = sunrise_error_status_read, 368 .shared = IIO_SHARED_BY_ALL, 369 }, 370 { 371 .name = "error_status_available", 372 .shared = IIO_SHARED_BY_ALL, 373 .read = iio_enum_available_read, 374 .private = (uintptr_t)&sunrise_error_statuses_enum, 375 }, 376 {} 377 }; 378 379 static const struct iio_chan_spec sunrise_channels[] = { 380 { 381 .type = IIO_CONCENTRATION, 382 .modified = 1, 383 .channel2 = IIO_MOD_CO2, 384 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 385 BIT(IIO_CHAN_INFO_SCALE), 386 .ext_info = sunrise_concentration_ext_info, 387 }, 388 { 389 .type = IIO_TEMP, 390 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 391 BIT(IIO_CHAN_INFO_SCALE), 392 }, 393 }; 394 395 static int sunrise_read_raw(struct iio_dev *iio_dev, 396 const struct iio_chan_spec *chan, 397 int *val, int *val2, long mask) 398 { 399 struct sunrise_dev *sunrise = iio_priv(iio_dev); 400 u16 value; 401 int ret; 402 403 switch (mask) { 404 case IIO_CHAN_INFO_RAW: 405 switch (chan->type) { 406 case IIO_CONCENTRATION: 407 mutex_lock(&sunrise->lock); 408 ret = sunrise_read_word(sunrise, SUNRISE_CO2_FILTERED_COMP_REG, 409 &value); 410 mutex_unlock(&sunrise->lock); 411 412 if (ret) 413 return ret; 414 415 *val = value; 416 return IIO_VAL_INT; 417 418 case IIO_TEMP: 419 mutex_lock(&sunrise->lock); 420 ret = sunrise_read_word(sunrise, SUNRISE_CHIP_TEMPERATURE_REG, 421 &value); 422 mutex_unlock(&sunrise->lock); 423 424 if (ret) 425 return ret; 426 427 *val = value; 428 return IIO_VAL_INT; 429 430 default: 431 return -EINVAL; 432 } 433 434 case IIO_CHAN_INFO_SCALE: 435 switch (chan->type) { 436 case IIO_CONCENTRATION: 437 /* 438 * 1 / 10^4 to comply with IIO scale for CO2 439 * (percentage). The chip CO2 reading range is [400 - 440 * 5000] ppm which corresponds to [0,004 - 0,5] %. 441 */ 442 *val = 1; 443 *val2 = 10000; 444 return IIO_VAL_FRACTIONAL; 445 446 case IIO_TEMP: 447 /* x10 to comply with IIO scale (millidegrees celsius). */ 448 *val = 10; 449 return IIO_VAL_INT; 450 451 default: 452 return -EINVAL; 453 } 454 455 default: 456 return -EINVAL; 457 } 458 } 459 460 static const struct iio_info sunrise_info = { 461 .read_raw = sunrise_read_raw, 462 }; 463 464 static const struct regmap_bus sunrise_regmap_bus = { 465 .read = sunrise_regmap_read, 466 .write = sunrise_regmap_write, 467 }; 468 469 static const struct regmap_config sunrise_regmap_config = { 470 .reg_bits = 8, 471 .val_bits = 8, 472 }; 473 474 static int sunrise_probe(struct i2c_client *client) 475 { 476 struct sunrise_dev *sunrise; 477 struct iio_dev *iio_dev; 478 479 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA | 480 I2C_FUNC_SMBUS_BLOCK_DATA)) { 481 dev_err(&client->dev, 482 "Adapter does not support required functionalities\n"); 483 return -EOPNOTSUPP; 484 } 485 486 iio_dev = devm_iio_device_alloc(&client->dev, sizeof(*sunrise)); 487 if (!iio_dev) 488 return -ENOMEM; 489 490 sunrise = iio_priv(iio_dev); 491 sunrise->client = client; 492 mutex_init(&sunrise->lock); 493 494 i2c_set_clientdata(client, sunrise); 495 496 sunrise->regmap = devm_regmap_init(&client->dev, &sunrise_regmap_bus, 497 client, &sunrise_regmap_config); 498 if (IS_ERR(sunrise->regmap)) { 499 dev_err(&client->dev, "Failed to initialize regmap\n"); 500 return PTR_ERR(sunrise->regmap); 501 } 502 503 /* 504 * The chip nacks the wake up message. If the adapter does not support 505 * protocol mangling do not set the I2C_M_IGNORE_NAK flag at the expense 506 * of possible cruft in the logs. 507 */ 508 if (i2c_check_functionality(client->adapter, I2C_FUNC_PROTOCOL_MANGLING)) 509 sunrise->ignore_nak = true; 510 511 iio_dev->info = &sunrise_info; 512 iio_dev->name = DRIVER_NAME; 513 iio_dev->channels = sunrise_channels; 514 iio_dev->num_channels = ARRAY_SIZE(sunrise_channels); 515 iio_dev->modes = INDIO_DIRECT_MODE; 516 517 return devm_iio_device_register(&client->dev, iio_dev); 518 } 519 520 static const struct of_device_id sunrise_of_match[] = { 521 { .compatible = "senseair,sunrise-006-0-0007" }, 522 {} 523 }; 524 MODULE_DEVICE_TABLE(of, sunrise_of_match); 525 526 static struct i2c_driver sunrise_driver = { 527 .driver = { 528 .name = DRIVER_NAME, 529 .of_match_table = sunrise_of_match, 530 }, 531 .probe = sunrise_probe, 532 }; 533 module_i2c_driver(sunrise_driver); 534 535 MODULE_AUTHOR("Jacopo Mondi <jacopo@jmondi.org>"); 536 MODULE_DESCRIPTION("Senseair Sunrise 006-0-0007 CO2 sensor IIO driver"); 537 MODULE_LICENSE("GPL v2"); 538