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