1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2020 InvenSense, Inc. 4 * 5 * Driver for InvenSense ICP-1010xx barometric pressure and temperature sensor. 6 * 7 * Datasheet: 8 * http://www.invensense.com/wp-content/uploads/2018/01/DS-000186-ICP-101xx-v1.2.pdf 9 */ 10 11 #include <linux/device.h> 12 #include <linux/module.h> 13 #include <linux/i2c.h> 14 #include <linux/pm_runtime.h> 15 #include <linux/crc8.h> 16 #include <linux/mutex.h> 17 #include <linux/delay.h> 18 #include <linux/log2.h> 19 #include <linux/math64.h> 20 #include <linux/regulator/consumer.h> 21 #include <linux/iio/iio.h> 22 23 #define ICP10100_ID_REG_GET(_reg) ((_reg) & 0x003F) 24 #define ICP10100_ID_REG 0x08 25 #define ICP10100_RESPONSE_WORD_LENGTH 3 26 #define ICP10100_CRC8_WORD_LENGTH 2 27 #define ICP10100_CRC8_POLYNOMIAL 0x31 28 #define ICP10100_CRC8_INIT 0xFF 29 30 enum icp10100_mode { 31 ICP10100_MODE_LP, /* Low power mode: 1x sampling */ 32 ICP10100_MODE_N, /* Normal mode: 2x sampling */ 33 ICP10100_MODE_LN, /* Low noise mode: 4x sampling */ 34 ICP10100_MODE_ULN, /* Ultra low noise mode: 8x sampling */ 35 ICP10100_MODE_NB, 36 }; 37 38 struct icp10100_state { 39 struct mutex lock; 40 struct i2c_client *client; 41 struct regulator *vdd; 42 enum icp10100_mode mode; 43 int16_t cal[4]; 44 }; 45 46 struct icp10100_command { 47 __be16 cmd; 48 unsigned long wait_us; 49 unsigned long wait_max_us; 50 size_t response_word_nb; 51 }; 52 53 static const struct icp10100_command icp10100_cmd_soft_reset = { 54 .cmd = cpu_to_be16(0x805D), 55 .wait_us = 170, 56 .wait_max_us = 200, 57 .response_word_nb = 0, 58 }; 59 60 static const struct icp10100_command icp10100_cmd_read_id = { 61 .cmd = cpu_to_be16(0xEFC8), 62 .wait_us = 0, 63 .response_word_nb = 1, 64 }; 65 66 static const struct icp10100_command icp10100_cmd_read_otp = { 67 .cmd = cpu_to_be16(0xC7F7), 68 .wait_us = 0, 69 .response_word_nb = 1, 70 }; 71 72 static const struct icp10100_command icp10100_cmd_measure[] = { 73 [ICP10100_MODE_LP] = { 74 .cmd = cpu_to_be16(0x401A), 75 .wait_us = 1800, 76 .wait_max_us = 2000, 77 .response_word_nb = 3, 78 }, 79 [ICP10100_MODE_N] = { 80 .cmd = cpu_to_be16(0x48A3), 81 .wait_us = 6300, 82 .wait_max_us = 6500, 83 .response_word_nb = 3, 84 }, 85 [ICP10100_MODE_LN] = { 86 .cmd = cpu_to_be16(0x5059), 87 .wait_us = 23800, 88 .wait_max_us = 24000, 89 .response_word_nb = 3, 90 }, 91 [ICP10100_MODE_ULN] = { 92 .cmd = cpu_to_be16(0x58E0), 93 .wait_us = 94500, 94 .wait_max_us = 94700, 95 .response_word_nb = 3, 96 }, 97 }; 98 99 static const uint8_t icp10100_switch_mode_otp[] = 100 {0xC5, 0x95, 0x00, 0x66, 0x9c}; 101 102 DECLARE_CRC8_TABLE(icp10100_crc8_table); 103 104 static inline int icp10100_i2c_xfer(struct i2c_adapter *adap, 105 struct i2c_msg *msgs, int num) 106 { 107 int ret; 108 109 ret = i2c_transfer(adap, msgs, num); 110 if (ret < 0) 111 return ret; 112 113 if (ret != num) 114 return -EIO; 115 116 return 0; 117 } 118 119 static int icp10100_send_cmd(struct icp10100_state *st, 120 const struct icp10100_command *cmd, 121 __be16 *buf, size_t buf_len) 122 { 123 size_t size = cmd->response_word_nb * ICP10100_RESPONSE_WORD_LENGTH; 124 uint8_t data[16]; 125 uint8_t *ptr; 126 uint8_t *buf_ptr = (uint8_t *)buf; 127 struct i2c_msg msgs[2] = { 128 { 129 .addr = st->client->addr, 130 .flags = 0, 131 .len = 2, 132 .buf = (uint8_t *)&cmd->cmd, 133 }, { 134 .addr = st->client->addr, 135 .flags = I2C_M_RD, 136 .len = size, 137 .buf = data, 138 }, 139 }; 140 uint8_t crc; 141 unsigned int i; 142 int ret; 143 144 if (size > sizeof(data)) 145 return -EINVAL; 146 147 if (cmd->response_word_nb > 0 && 148 (buf == NULL || buf_len < (cmd->response_word_nb * 2))) 149 return -EINVAL; 150 151 dev_dbg(&st->client->dev, "sending cmd %#x\n", be16_to_cpu(cmd->cmd)); 152 153 if (cmd->response_word_nb > 0 && cmd->wait_us == 0) { 154 /* direct command-response without waiting */ 155 ret = icp10100_i2c_xfer(st->client->adapter, msgs, 156 ARRAY_SIZE(msgs)); 157 if (ret) 158 return ret; 159 } else { 160 /* transfer command write */ 161 ret = icp10100_i2c_xfer(st->client->adapter, &msgs[0], 1); 162 if (ret) 163 return ret; 164 if (cmd->wait_us > 0) 165 usleep_range(cmd->wait_us, cmd->wait_max_us); 166 /* transfer response read if needed */ 167 if (cmd->response_word_nb > 0) { 168 ret = icp10100_i2c_xfer(st->client->adapter, &msgs[1], 1); 169 if (ret) 170 return ret; 171 } else { 172 return 0; 173 } 174 } 175 176 /* process read words with crc checking */ 177 for (i = 0; i < cmd->response_word_nb; ++i) { 178 ptr = &data[i * ICP10100_RESPONSE_WORD_LENGTH]; 179 crc = crc8(icp10100_crc8_table, ptr, ICP10100_CRC8_WORD_LENGTH, 180 ICP10100_CRC8_INIT); 181 if (crc != ptr[ICP10100_CRC8_WORD_LENGTH]) { 182 dev_err(&st->client->dev, "crc error recv=%#x calc=%#x\n", 183 ptr[ICP10100_CRC8_WORD_LENGTH], crc); 184 return -EIO; 185 } 186 *buf_ptr++ = ptr[0]; 187 *buf_ptr++ = ptr[1]; 188 } 189 190 return 0; 191 } 192 193 static int icp10100_read_cal_otp(struct icp10100_state *st) 194 { 195 __be16 val; 196 int i; 197 int ret; 198 199 /* switch into OTP read mode */ 200 ret = i2c_master_send(st->client, icp10100_switch_mode_otp, 201 ARRAY_SIZE(icp10100_switch_mode_otp)); 202 if (ret < 0) 203 return ret; 204 if (ret != ARRAY_SIZE(icp10100_switch_mode_otp)) 205 return -EIO; 206 207 /* read 4 calibration values */ 208 for (i = 0; i < 4; ++i) { 209 ret = icp10100_send_cmd(st, &icp10100_cmd_read_otp, 210 &val, sizeof(val)); 211 if (ret) 212 return ret; 213 st->cal[i] = be16_to_cpu(val); 214 dev_dbg(&st->client->dev, "cal[%d] = %d\n", i, st->cal[i]); 215 } 216 217 return 0; 218 } 219 220 static int icp10100_init_chip(struct icp10100_state *st) 221 { 222 __be16 val; 223 uint16_t id; 224 int ret; 225 226 /* read and check id */ 227 ret = icp10100_send_cmd(st, &icp10100_cmd_read_id, &val, sizeof(val)); 228 if (ret) 229 return ret; 230 id = ICP10100_ID_REG_GET(be16_to_cpu(val)); 231 if (id != ICP10100_ID_REG) { 232 dev_err(&st->client->dev, "invalid id %#x\n", id); 233 return -ENODEV; 234 } 235 236 /* read calibration data from OTP */ 237 ret = icp10100_read_cal_otp(st); 238 if (ret) 239 return ret; 240 241 /* reset chip */ 242 return icp10100_send_cmd(st, &icp10100_cmd_soft_reset, NULL, 0); 243 } 244 245 static int icp10100_get_measures(struct icp10100_state *st, 246 uint32_t *pressure, uint16_t *temperature) 247 { 248 const struct icp10100_command *cmd; 249 __be16 measures[3]; 250 int ret; 251 252 pm_runtime_get_sync(&st->client->dev); 253 254 mutex_lock(&st->lock); 255 cmd = &icp10100_cmd_measure[st->mode]; 256 ret = icp10100_send_cmd(st, cmd, measures, sizeof(measures)); 257 mutex_unlock(&st->lock); 258 if (ret) 259 goto error_measure; 260 261 *pressure = (be16_to_cpu(measures[0]) << 8) | 262 (be16_to_cpu(measures[1]) >> 8); 263 *temperature = be16_to_cpu(measures[2]); 264 265 pm_runtime_mark_last_busy(&st->client->dev); 266 error_measure: 267 pm_runtime_put_autosuspend(&st->client->dev); 268 return ret; 269 } 270 271 static uint32_t icp10100_get_pressure(struct icp10100_state *st, 272 uint32_t raw_pressure, uint16_t raw_temp) 273 { 274 static int32_t p_calib[] = {45000, 80000, 105000}; 275 static int32_t lut_lower = 3670016; 276 static int32_t lut_upper = 12058624; 277 static int32_t inv_quadr_factor = 16777216; 278 static int32_t offset_factor = 2048; 279 int64_t val1, val2; 280 int32_t p_lut[3]; 281 int32_t t, t_square; 282 int64_t a, b, c; 283 uint32_t pressure_mPa; 284 285 dev_dbg(&st->client->dev, "raw: pressure = %u, temp = %u\n", 286 raw_pressure, raw_temp); 287 288 /* compute p_lut values */ 289 t = (int32_t)raw_temp - 32768; 290 t_square = t * t; 291 val1 = (int64_t)st->cal[0] * (int64_t)t_square; 292 p_lut[0] = lut_lower + (int32_t)div_s64(val1, inv_quadr_factor); 293 val1 = (int64_t)st->cal[1] * (int64_t)t_square; 294 p_lut[1] = offset_factor * st->cal[3] + 295 (int32_t)div_s64(val1, inv_quadr_factor); 296 val1 = (int64_t)st->cal[2] * (int64_t)t_square; 297 p_lut[2] = lut_upper + (int32_t)div_s64(val1, inv_quadr_factor); 298 dev_dbg(&st->client->dev, "p_lut = [%d, %d, %d]\n", 299 p_lut[0], p_lut[1], p_lut[2]); 300 301 /* compute a, b, c factors */ 302 val1 = (int64_t)p_lut[0] * (int64_t)p_lut[1] * 303 (int64_t)(p_calib[0] - p_calib[1]) + 304 (int64_t)p_lut[1] * (int64_t)p_lut[2] * 305 (int64_t)(p_calib[1] - p_calib[2]) + 306 (int64_t)p_lut[2] * (int64_t)p_lut[0] * 307 (int64_t)(p_calib[2] - p_calib[0]); 308 val2 = (int64_t)p_lut[2] * (int64_t)(p_calib[0] - p_calib[1]) + 309 (int64_t)p_lut[0] * (int64_t)(p_calib[1] - p_calib[2]) + 310 (int64_t)p_lut[1] * (int64_t)(p_calib[2] - p_calib[0]); 311 c = div64_s64(val1, val2); 312 dev_dbg(&st->client->dev, "val1 = %lld, val2 = %lld, c = %lld\n", 313 val1, val2, c); 314 val1 = (int64_t)p_calib[0] * (int64_t)p_lut[0] - 315 (int64_t)p_calib[1] * (int64_t)p_lut[1] - 316 (int64_t)(p_calib[1] - p_calib[0]) * c; 317 val2 = (int64_t)p_lut[0] - (int64_t)p_lut[1]; 318 a = div64_s64(val1, val2); 319 dev_dbg(&st->client->dev, "val1 = %lld, val2 = %lld, a = %lld\n", 320 val1, val2, a); 321 b = ((int64_t)p_calib[0] - a) * ((int64_t)p_lut[0] + c); 322 dev_dbg(&st->client->dev, "b = %lld\n", b); 323 324 /* 325 * pressure_Pa = a + (b / (c + raw_pressure)) 326 * pressure_mPa = 1000 * pressure_Pa 327 */ 328 pressure_mPa = 1000LL * a + div64_s64(1000LL * b, c + raw_pressure); 329 330 return pressure_mPa; 331 } 332 333 static int icp10100_read_raw_measures(struct iio_dev *indio_dev, 334 struct iio_chan_spec const *chan, 335 int *val, int *val2) 336 { 337 struct icp10100_state *st = iio_priv(indio_dev); 338 uint32_t raw_pressure; 339 uint16_t raw_temp; 340 uint32_t pressure_mPa; 341 int ret; 342 343 ret = iio_device_claim_direct_mode(indio_dev); 344 if (ret) 345 return ret; 346 347 ret = icp10100_get_measures(st, &raw_pressure, &raw_temp); 348 if (ret) 349 goto error_release; 350 351 switch (chan->type) { 352 case IIO_PRESSURE: 353 pressure_mPa = icp10100_get_pressure(st, raw_pressure, 354 raw_temp); 355 /* mPa to kPa */ 356 *val = pressure_mPa / 1000000; 357 *val2 = pressure_mPa % 1000000; 358 ret = IIO_VAL_INT_PLUS_MICRO; 359 break; 360 case IIO_TEMP: 361 *val = raw_temp; 362 ret = IIO_VAL_INT; 363 break; 364 default: 365 ret = -EINVAL; 366 break; 367 } 368 369 error_release: 370 iio_device_release_direct_mode(indio_dev); 371 return ret; 372 } 373 374 static int icp10100_read_raw(struct iio_dev *indio_dev, 375 struct iio_chan_spec const *chan, 376 int *val, int *val2, long mask) 377 { 378 struct icp10100_state *st = iio_priv(indio_dev); 379 380 switch (mask) { 381 case IIO_CHAN_INFO_RAW: 382 case IIO_CHAN_INFO_PROCESSED: 383 return icp10100_read_raw_measures(indio_dev, chan, val, val2); 384 case IIO_CHAN_INFO_SCALE: 385 switch (chan->type) { 386 case IIO_TEMP: 387 /* 1000 * 175°C / 65536 in m°C */ 388 *val = 2; 389 *val2 = 670288; 390 return IIO_VAL_INT_PLUS_MICRO; 391 default: 392 return -EINVAL; 393 } 394 break; 395 case IIO_CHAN_INFO_OFFSET: 396 switch (chan->type) { 397 case IIO_TEMP: 398 /* 1000 * -45°C in m°C */ 399 *val = -45000; 400 return IIO_VAL_INT; 401 default: 402 return -EINVAL; 403 } 404 break; 405 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 406 mutex_lock(&st->lock); 407 *val = 1 << st->mode; 408 mutex_unlock(&st->lock); 409 return IIO_VAL_INT; 410 default: 411 return -EINVAL; 412 } 413 } 414 415 static int icp10100_read_avail(struct iio_dev *indio_dev, 416 struct iio_chan_spec const *chan, 417 const int **vals, int *type, int *length, 418 long mask) 419 { 420 static int oversamplings[] = {1, 2, 4, 8}; 421 422 switch (mask) { 423 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 424 *vals = oversamplings; 425 *type = IIO_VAL_INT; 426 *length = ARRAY_SIZE(oversamplings); 427 return IIO_AVAIL_LIST; 428 default: 429 return -EINVAL; 430 } 431 } 432 433 static int icp10100_write_raw(struct iio_dev *indio_dev, 434 struct iio_chan_spec const *chan, 435 int val, int val2, long mask) 436 { 437 struct icp10100_state *st = iio_priv(indio_dev); 438 unsigned int mode; 439 int ret; 440 441 switch (mask) { 442 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 443 /* oversampling is always positive and a power of 2 */ 444 if (val <= 0 || !is_power_of_2(val)) 445 return -EINVAL; 446 mode = ilog2(val); 447 if (mode >= ICP10100_MODE_NB) 448 return -EINVAL; 449 ret = iio_device_claim_direct_mode(indio_dev); 450 if (ret) 451 return ret; 452 mutex_lock(&st->lock); 453 st->mode = mode; 454 mutex_unlock(&st->lock); 455 iio_device_release_direct_mode(indio_dev); 456 return 0; 457 default: 458 return -EINVAL; 459 } 460 } 461 462 static int icp10100_write_raw_get_fmt(struct iio_dev *indio_dev, 463 struct iio_chan_spec const *chan, 464 long mask) 465 { 466 switch (mask) { 467 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 468 return IIO_VAL_INT; 469 default: 470 return -EINVAL; 471 } 472 } 473 474 static const struct iio_info icp10100_info = { 475 .read_raw = icp10100_read_raw, 476 .read_avail = icp10100_read_avail, 477 .write_raw = icp10100_write_raw, 478 .write_raw_get_fmt = icp10100_write_raw_get_fmt, 479 }; 480 481 static const struct iio_chan_spec icp10100_channels[] = { 482 { 483 .type = IIO_PRESSURE, 484 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), 485 .info_mask_shared_by_all = 486 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 487 .info_mask_shared_by_all_available = 488 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 489 }, { 490 .type = IIO_TEMP, 491 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 492 BIT(IIO_CHAN_INFO_SCALE) | 493 BIT(IIO_CHAN_INFO_OFFSET), 494 .info_mask_shared_by_all = 495 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 496 .info_mask_shared_by_all_available = 497 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), 498 }, 499 }; 500 501 static int icp10100_enable_regulator(struct icp10100_state *st) 502 { 503 int ret; 504 505 ret = regulator_enable(st->vdd); 506 if (ret) 507 return ret; 508 msleep(100); 509 510 return 0; 511 } 512 513 static void icp10100_disable_regulator_action(void *data) 514 { 515 struct icp10100_state *st = data; 516 int ret; 517 518 ret = regulator_disable(st->vdd); 519 if (ret) 520 dev_err(&st->client->dev, "error %d disabling vdd\n", ret); 521 } 522 523 static void icp10100_pm_disable(void *data) 524 { 525 struct device *dev = data; 526 527 pm_runtime_put_sync_suspend(dev); 528 pm_runtime_disable(dev); 529 } 530 531 static int icp10100_probe(struct i2c_client *client, 532 const struct i2c_device_id *id) 533 { 534 struct iio_dev *indio_dev; 535 struct icp10100_state *st; 536 int ret; 537 538 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 539 dev_err(&client->dev, "plain i2c transactions not supported\n"); 540 return -ENODEV; 541 } 542 543 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*st)); 544 if (!indio_dev) 545 return -ENOMEM; 546 547 i2c_set_clientdata(client, indio_dev); 548 indio_dev->name = client->name; 549 indio_dev->modes = INDIO_DIRECT_MODE; 550 indio_dev->channels = icp10100_channels; 551 indio_dev->num_channels = ARRAY_SIZE(icp10100_channels); 552 indio_dev->info = &icp10100_info; 553 554 st = iio_priv(indio_dev); 555 mutex_init(&st->lock); 556 st->client = client; 557 st->mode = ICP10100_MODE_N; 558 559 st->vdd = devm_regulator_get(&client->dev, "vdd"); 560 if (IS_ERR(st->vdd)) 561 return PTR_ERR(st->vdd); 562 563 ret = icp10100_enable_regulator(st); 564 if (ret) 565 return ret; 566 567 ret = devm_add_action_or_reset(&client->dev, 568 icp10100_disable_regulator_action, st); 569 if (ret) 570 return ret; 571 572 /* has to be done before the first i2c communication */ 573 crc8_populate_msb(icp10100_crc8_table, ICP10100_CRC8_POLYNOMIAL); 574 575 ret = icp10100_init_chip(st); 576 if (ret) { 577 dev_err(&client->dev, "init chip error %d\n", ret); 578 return ret; 579 } 580 581 /* enable runtime pm with autosuspend delay of 2s */ 582 pm_runtime_get_noresume(&client->dev); 583 pm_runtime_set_active(&client->dev); 584 pm_runtime_enable(&client->dev); 585 pm_runtime_set_autosuspend_delay(&client->dev, 2000); 586 pm_runtime_use_autosuspend(&client->dev); 587 pm_runtime_put(&client->dev); 588 ret = devm_add_action_or_reset(&client->dev, icp10100_pm_disable, 589 &client->dev); 590 if (ret) 591 return ret; 592 593 return devm_iio_device_register(&client->dev, indio_dev); 594 } 595 596 static int __maybe_unused icp10100_suspend(struct device *dev) 597 { 598 struct icp10100_state *st = iio_priv(dev_get_drvdata(dev)); 599 int ret; 600 601 mutex_lock(&st->lock); 602 ret = regulator_disable(st->vdd); 603 mutex_unlock(&st->lock); 604 605 return ret; 606 } 607 608 static int __maybe_unused icp10100_resume(struct device *dev) 609 { 610 struct icp10100_state *st = iio_priv(dev_get_drvdata(dev)); 611 int ret; 612 613 mutex_lock(&st->lock); 614 615 ret = icp10100_enable_regulator(st); 616 if (ret) 617 goto out_unlock; 618 619 /* reset chip */ 620 ret = icp10100_send_cmd(st, &icp10100_cmd_soft_reset, NULL, 0); 621 622 out_unlock: 623 mutex_unlock(&st->lock); 624 return ret; 625 } 626 627 static UNIVERSAL_DEV_PM_OPS(icp10100_pm, icp10100_suspend, icp10100_resume, 628 NULL); 629 630 static const struct of_device_id icp10100_of_match[] = { 631 { 632 .compatible = "invensense,icp10100", 633 }, 634 { } 635 }; 636 MODULE_DEVICE_TABLE(of, icp10100_of_match); 637 638 static const struct i2c_device_id icp10100_id[] = { 639 { "icp10100", 0 }, 640 { } 641 }; 642 MODULE_DEVICE_TABLE(i2c, icp10100_id); 643 644 static struct i2c_driver icp10100_driver = { 645 .driver = { 646 .name = "icp10100", 647 .pm = &icp10100_pm, 648 .of_match_table = of_match_ptr(icp10100_of_match), 649 }, 650 .probe = icp10100_probe, 651 .id_table = icp10100_id, 652 }; 653 module_i2c_driver(icp10100_driver); 654 655 MODULE_AUTHOR("InvenSense, Inc."); 656 MODULE_DESCRIPTION("InvenSense icp10100 driver"); 657 MODULE_LICENSE("GPL"); 658