drivers/iio/pressure/icp10100.c

   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");