drivers/iio/common/cros_ec_sensors/cros_ec_sensors_core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * cros_ec_sensors_core - Common function for Chrome OS EC sensor driver.
   4  *
   5  * Copyright (C) 2016 Google, Inc
   6  */
   7
   8 #include <linux/delay.h>
   9 #include <linux/device.h>
  10 #include <linux/iio/buffer.h>
  11 #include <linux/iio/common/cros_ec_sensors_core.h>
  12 #include <linux/iio/iio.h>
  13 #include <linux/iio/kfifo_buf.h>
  14 #include <linux/iio/trigger_consumer.h>
  15 #include <linux/kernel.h>
  16 #include <linux/mfd/cros_ec.h>
  17 #include <linux/module.h>
  18 #include <linux/slab.h>
  19 #include <linux/platform_data/cros_ec_commands.h>
  20 #include <linux/platform_data/cros_ec_proto.h>
  21 #include <linux/platform_data/cros_ec_sensorhub.h>
  22 #include <linux/platform_device.h>
  23
  24 static char *cros_ec_loc[] = {
  25         [MOTIONSENSE_LOC_BASE] = "base",
  26         [MOTIONSENSE_LOC_LID] = "lid",
  27         [MOTIONSENSE_LOC_MAX] = "unknown",
  28 };
  29
  30 static int cros_ec_get_host_cmd_version_mask(struct cros_ec_device *ec_dev,
  31                                              u16 cmd_offset, u16 cmd, u32 *mask)
  32 {
  33         int ret;
  34         struct {
  35                 struct cros_ec_command msg;
  36                 union {
  37                         struct ec_params_get_cmd_versions params;
  38                         struct ec_response_get_cmd_versions resp;
  39                 };
  40         } __packed buf = {
  41                 .msg = {
  42                         .command = EC_CMD_GET_CMD_VERSIONS + cmd_offset,
  43                         .insize = sizeof(struct ec_response_get_cmd_versions),
  44                         .outsize = sizeof(struct ec_params_get_cmd_versions)
  45                         },
  46                 .params = {.cmd = cmd}
  47         };
  48
  49         ret = cros_ec_cmd_xfer_status(ec_dev, &buf.msg);
  50         if (ret >= 0)
  51                 *mask = buf.resp.version_mask;
  52         return ret;
  53 }
  54
  55 static void get_default_min_max_freq(enum motionsensor_type type,
  56                                      u32 *min_freq,
  57                                      u32 *max_freq)
  58 {
  59         switch (type) {
  60         case MOTIONSENSE_TYPE_ACCEL:
  61         case MOTIONSENSE_TYPE_GYRO:
  62                 *min_freq = 12500;
  63                 *max_freq = 100000;
  64                 break;
  65         case MOTIONSENSE_TYPE_MAG:
  66                 *min_freq = 5000;
  67                 *max_freq = 25000;
  68                 break;
  69         case MOTIONSENSE_TYPE_PROX:
  70         case MOTIONSENSE_TYPE_LIGHT:
  71                 *min_freq = 100;
  72                 *max_freq = 50000;
  73                 break;
  74         case MOTIONSENSE_TYPE_BARO:
  75                 *min_freq = 250;
  76                 *max_freq = 20000;
  77                 break;
  78         case MOTIONSENSE_TYPE_ACTIVITY:
  79         default:
  80                 *min_freq = 0;
  81                 *max_freq = 0;
  82                 break;
  83         }
  84 }
  85
  86 int cros_ec_sensors_core_init(struct platform_device *pdev,
  87                               struct iio_dev *indio_dev,
  88                               bool physical_device)
  89 {
  90         struct device *dev = &pdev->dev;
  91         struct cros_ec_sensors_core_state *state = iio_priv(indio_dev);
  92         struct cros_ec_sensorhub *sensor_hub = dev_get_drvdata(dev->parent);
  93         struct cros_ec_dev *ec = sensor_hub->ec;
  94         struct cros_ec_sensor_platform *sensor_platform = dev_get_platdata(dev);
  95         u32 ver_mask;
  96         int ret, i;
  97
  98         platform_set_drvdata(pdev, indio_dev);
  99
 100         state->ec = ec->ec_dev;
 101         state->msg = devm_kzalloc(&pdev->dev,
 102                                 max((u16)sizeof(struct ec_params_motion_sense),
 103                                 state->ec->max_response), GFP_KERNEL);
 104         if (!state->msg)
 105                 return -ENOMEM;
 106
 107         state->resp = (struct ec_response_motion_sense *)state->msg->data;
 108
 109         mutex_init(&state->cmd_lock);
 110
 111         ret = cros_ec_get_host_cmd_version_mask(state->ec,
 112                                                 ec->cmd_offset,
 113                                                 EC_CMD_MOTION_SENSE_CMD,
 114                                                 &ver_mask);
 115         if (ret < 0)
 116                 return ret;
 117
 118         /* Set up the host command structure. */
 119         state->msg->version = fls(ver_mask) - 1;
 120         state->msg->command = EC_CMD_MOTION_SENSE_CMD + ec->cmd_offset;
 121         state->msg->outsize = sizeof(struct ec_params_motion_sense);
 122
 123         indio_dev->dev.parent = &pdev->dev;
 124         indio_dev->name = pdev->name;
 125
 126         if (physical_device) {
 127                 indio_dev->modes = INDIO_DIRECT_MODE;
 128
 129                 state->param.cmd = MOTIONSENSE_CMD_INFO;
 130                 state->param.info.sensor_num = sensor_platform->sensor_num;
 131                 ret = cros_ec_motion_send_host_cmd(state, 0);
 132                 if (ret) {
 133                         dev_warn(dev, "Can not access sensor info\n");
 134                         return ret;
 135                 }
 136                 state->type = state->resp->info.type;
 137                 state->loc = state->resp->info.location;
 138
 139                 /* Set sign vector, only used for backward compatibility. */
 140                 memset(state->sign, 1, CROS_EC_SENSOR_MAX_AXIS);
 141
 142                 for (i = CROS_EC_SENSOR_X; i < CROS_EC_SENSOR_MAX_AXIS; i++)
 143                         state->calib[i].scale = MOTION_SENSE_DEFAULT_SCALE;
 144
 145                 /* 0 is a correct value used to stop the device */
 146                 state->frequencies[0] = 0;
 147                 if (state->msg->version < 3) {
 148                         get_default_min_max_freq(state->resp->info.type,
 149                                                  &state->frequencies[1],
 150                                                  &state->frequencies[2]);
 151                 } else {
 152                         state->frequencies[1] =
 153                             state->resp->info_3.min_frequency;
 154                         state->frequencies[2] =
 155                             state->resp->info_3.max_frequency;
 156                 }
 157         }
 158
 159         return 0;
 160 }
 161 EXPORT_SYMBOL_GPL(cros_ec_sensors_core_init);
 162
 163 int cros_ec_motion_send_host_cmd(struct cros_ec_sensors_core_state *state,
 164                                  u16 opt_length)
 165 {
 166         int ret;
 167
 168         if (opt_length)
 169                 state->msg->insize = min(opt_length, state->ec->max_response);
 170         else
 171                 state->msg->insize = state->ec->max_response;
 172
 173         memcpy(state->msg->data, &state->param, sizeof(state->param));
 174
 175         ret = cros_ec_cmd_xfer_status(state->ec, state->msg);
 176         if (ret < 0)
 177                 return ret;
 178
 179         if (ret &&
 180             state->resp != (struct ec_response_motion_sense *)state->msg->data)
 181                 memcpy(state->resp, state->msg->data, ret);
 182
 183         return 0;
 184 }
 185 EXPORT_SYMBOL_GPL(cros_ec_motion_send_host_cmd);
 186
 187 static ssize_t cros_ec_sensors_calibrate(struct iio_dev *indio_dev,
 188                 uintptr_t private, const struct iio_chan_spec *chan,
 189                 const char *buf, size_t len)
 190 {
 191         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 192         int ret, i;
 193         bool calibrate;
 194
 195         ret = strtobool(buf, &calibrate);
 196         if (ret < 0)
 197                 return ret;
 198         if (!calibrate)
 199                 return -EINVAL;
 200
 201         mutex_lock(&st->cmd_lock);
 202         st->param.cmd = MOTIONSENSE_CMD_PERFORM_CALIB;
 203         ret = cros_ec_motion_send_host_cmd(st, 0);
 204         if (ret != 0) {
 205                 dev_warn(&indio_dev->dev, "Unable to calibrate sensor\n");
 206         } else {
 207                 /* Save values */
 208                 for (i = CROS_EC_SENSOR_X; i < CROS_EC_SENSOR_MAX_AXIS; i++)
 209                         st->calib[i].offset = st->resp->perform_calib.offset[i];
 210         }
 211         mutex_unlock(&st->cmd_lock);
 212
 213         return ret ? ret : len;
 214 }
 215
 216 static ssize_t cros_ec_sensors_id(struct iio_dev *indio_dev,
 217                                   uintptr_t private,
 218                                   const struct iio_chan_spec *chan, char *buf)
 219 {
 220         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 221
 222         return snprintf(buf, PAGE_SIZE, "%d\n", st->param.info.sensor_num);
 223 }
 224
 225 static ssize_t cros_ec_sensors_loc(struct iio_dev *indio_dev,
 226                 uintptr_t private, const struct iio_chan_spec *chan,
 227                 char *buf)
 228 {
 229         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 230
 231         return snprintf(buf, PAGE_SIZE, "%s\n", cros_ec_loc[st->loc]);
 232 }
 233
 234 const struct iio_chan_spec_ext_info cros_ec_sensors_ext_info[] = {
 235         {
 236                 .name = "calibrate",
 237                 .shared = IIO_SHARED_BY_ALL,
 238                 .write = cros_ec_sensors_calibrate
 239         },
 240         {
 241                 .name = "id",
 242                 .shared = IIO_SHARED_BY_ALL,
 243                 .read = cros_ec_sensors_id
 244         },
 245         {
 246                 .name = "location",
 247                 .shared = IIO_SHARED_BY_ALL,
 248                 .read = cros_ec_sensors_loc
 249         },
 250         { },
 251 };
 252 EXPORT_SYMBOL_GPL(cros_ec_sensors_ext_info);
 253
 254 /**
 255  * cros_ec_sensors_idx_to_reg - convert index into offset in shared memory
 256  * @st:         pointer to state information for device
 257  * @idx:        sensor index (should be element of enum sensor_index)
 258  *
 259  * Return:      address to read at
 260  */
 261 static unsigned int cros_ec_sensors_idx_to_reg(
 262                                         struct cros_ec_sensors_core_state *st,
 263                                         unsigned int idx)
 264 {
 265         /*
 266          * When using LPC interface, only space for 2 Accel and one Gyro.
 267          * First halfword of MOTIONSENSE_TYPE_ACCEL is used by angle.
 268          */
 269         if (st->type == MOTIONSENSE_TYPE_ACCEL)
 270                 return EC_MEMMAP_ACC_DATA + sizeof(u16) *
 271                         (1 + idx + st->param.info.sensor_num *
 272                          CROS_EC_SENSOR_MAX_AXIS);
 273
 274         return EC_MEMMAP_GYRO_DATA + sizeof(u16) * idx;
 275 }
 276
 277 static int cros_ec_sensors_cmd_read_u8(struct cros_ec_device *ec,
 278                                        unsigned int offset, u8 *dest)
 279 {
 280         return ec->cmd_readmem(ec, offset, 1, dest);
 281 }
 282
 283 static int cros_ec_sensors_cmd_read_u16(struct cros_ec_device *ec,
 284                                          unsigned int offset, u16 *dest)
 285 {
 286         __le16 tmp;
 287         int ret = ec->cmd_readmem(ec, offset, 2, &tmp);
 288
 289         if (ret >= 0)
 290                 *dest = le16_to_cpu(tmp);
 291
 292         return ret;
 293 }
 294
 295 /**
 296  * cros_ec_sensors_read_until_not_busy() - read until is not busy
 297  *
 298  * @st: pointer to state information for device
 299  *
 300  * Read from EC status byte until it reads not busy.
 301  * Return: 8-bit status if ok, -errno on failure.
 302  */
 303 static int cros_ec_sensors_read_until_not_busy(
 304                                         struct cros_ec_sensors_core_state *st)
 305 {
 306         struct cros_ec_device *ec = st->ec;
 307         u8 status;
 308         int ret, attempts = 0;
 309
 310         ret = cros_ec_sensors_cmd_read_u8(ec, EC_MEMMAP_ACC_STATUS, &status);
 311         if (ret < 0)
 312                 return ret;
 313
 314         while (status & EC_MEMMAP_ACC_STATUS_BUSY_BIT) {
 315                 /* Give up after enough attempts, return error. */
 316                 if (attempts++ >= 50)
 317                         return -EIO;
 318
 319                 /* Small delay every so often. */
 320                 if (attempts % 5 == 0)
 321                         msleep(25);
 322
 323                 ret = cros_ec_sensors_cmd_read_u8(ec, EC_MEMMAP_ACC_STATUS,
 324                                                   &status);
 325                 if (ret < 0)
 326                         return ret;
 327         }
 328
 329         return status;
 330 }
 331
 332 /**
 333  * read_ec_sensors_data_unsafe() - read acceleration data from EC shared memory
 334  * @indio_dev:  pointer to IIO device
 335  * @scan_mask:  bitmap of the sensor indices to scan
 336  * @data:       location to store data
 337  *
 338  * This is the unsafe function for reading the EC data. It does not guarantee
 339  * that the EC will not modify the data as it is being read in.
 340  *
 341  * Return: 0 on success, -errno on failure.
 342  */
 343 static int cros_ec_sensors_read_data_unsafe(struct iio_dev *indio_dev,
 344                          unsigned long scan_mask, s16 *data)
 345 {
 346         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 347         struct cros_ec_device *ec = st->ec;
 348         unsigned int i;
 349         int ret;
 350
 351         /* Read all sensors enabled in scan_mask. Each value is 2 bytes. */
 352         for_each_set_bit(i, &scan_mask, indio_dev->masklength) {
 353                 ret = cros_ec_sensors_cmd_read_u16(ec,
 354                                              cros_ec_sensors_idx_to_reg(st, i),
 355                                              data);
 356                 if (ret < 0)
 357                         return ret;
 358
 359                 *data *= st->sign[i];
 360                 data++;
 361         }
 362
 363         return 0;
 364 }
 365
 366 /**
 367  * cros_ec_sensors_read_lpc() - read acceleration data from EC shared memory.
 368  * @indio_dev: pointer to IIO device.
 369  * @scan_mask: bitmap of the sensor indices to scan.
 370  * @data: location to store data.
 371  *
 372  * Note: this is the safe function for reading the EC data. It guarantees
 373  * that the data sampled was not modified by the EC while being read.
 374  *
 375  * Return: 0 on success, -errno on failure.
 376  */
 377 int cros_ec_sensors_read_lpc(struct iio_dev *indio_dev,
 378                              unsigned long scan_mask, s16 *data)
 379 {
 380         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 381         struct cros_ec_device *ec = st->ec;
 382         u8 samp_id = 0xff, status = 0;
 383         int ret, attempts = 0;
 384
 385         /*
 386          * Continually read all data from EC until the status byte after
 387          * all reads reflects that the EC is not busy and the sample id
 388          * matches the sample id from before all reads. This guarantees
 389          * that data read in was not modified by the EC while reading.
 390          */
 391         while ((status & (EC_MEMMAP_ACC_STATUS_BUSY_BIT |
 392                           EC_MEMMAP_ACC_STATUS_SAMPLE_ID_MASK)) != samp_id) {
 393                 /* If we have tried to read too many times, return error. */
 394                 if (attempts++ >= 5)
 395                         return -EIO;
 396
 397                 /* Read status byte until EC is not busy. */
 398                 ret = cros_ec_sensors_read_until_not_busy(st);
 399                 if (ret < 0)
 400                         return ret;
 401
 402                 /*
 403                  * Store the current sample id so that we can compare to the
 404                  * sample id after reading the data.
 405                  */
 406                 samp_id = ret & EC_MEMMAP_ACC_STATUS_SAMPLE_ID_MASK;
 407
 408                 /* Read all EC data, format it, and store it into data. */
 409                 ret = cros_ec_sensors_read_data_unsafe(indio_dev, scan_mask,
 410                                                        data);
 411                 if (ret < 0)
 412                         return ret;
 413
 414                 /* Read status byte. */
 415                 ret = cros_ec_sensors_cmd_read_u8(ec, EC_MEMMAP_ACC_STATUS,
 416                                                   &status);
 417                 if (ret < 0)
 418                         return ret;
 419         }
 420
 421         return 0;
 422 }
 423 EXPORT_SYMBOL_GPL(cros_ec_sensors_read_lpc);
 424
 425 int cros_ec_sensors_read_cmd(struct iio_dev *indio_dev,
 426                              unsigned long scan_mask, s16 *data)
 427 {
 428         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 429         int ret;
 430         unsigned int i;
 431
 432         /* Read all sensor data through a command. */
 433         st->param.cmd = MOTIONSENSE_CMD_DATA;
 434         ret = cros_ec_motion_send_host_cmd(st, sizeof(st->resp->data));
 435         if (ret != 0) {
 436                 dev_warn(&indio_dev->dev, "Unable to read sensor data\n");
 437                 return ret;
 438         }
 439
 440         for_each_set_bit(i, &scan_mask, indio_dev->masklength) {
 441                 *data = st->resp->data.data[i];
 442                 data++;
 443         }
 444
 445         return 0;
 446 }
 447 EXPORT_SYMBOL_GPL(cros_ec_sensors_read_cmd);
 448
 449 irqreturn_t cros_ec_sensors_capture(int irq, void *p)
 450 {
 451         struct iio_poll_func *pf = p;
 452         struct iio_dev *indio_dev = pf->indio_dev;
 453         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 454         int ret;
 455
 456         mutex_lock(&st->cmd_lock);
 457
 458         /* Clear capture data. */
 459         memset(st->samples, 0, indio_dev->scan_bytes);
 460
 461         /* Read data based on which channels are enabled in scan mask. */
 462         ret = st->read_ec_sensors_data(indio_dev,
 463                                        *(indio_dev->active_scan_mask),
 464                                        (s16 *)st->samples);
 465         if (ret < 0)
 466                 goto done;
 467
 468         iio_push_to_buffers_with_timestamp(indio_dev, st->samples,
 469                                            iio_get_time_ns(indio_dev));
 470
 471 done:
 472         /*
 473          * Tell the core we are done with this trigger and ready for the
 474          * next one.
 475          */
 476         iio_trigger_notify_done(indio_dev->trig);
 477
 478         mutex_unlock(&st->cmd_lock);
 479
 480         return IRQ_HANDLED;
 481 }
 482 EXPORT_SYMBOL_GPL(cros_ec_sensors_capture);
 483
 484 int cros_ec_sensors_core_read(struct cros_ec_sensors_core_state *st,
 485                           struct iio_chan_spec const *chan,
 486                           int *val, int *val2, long mask)
 487 {
 488         int ret;
 489
 490         switch (mask) {
 491         case IIO_CHAN_INFO_SAMP_FREQ:
 492                 st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
 493                 st->param.ec_rate.data =
 494                         EC_MOTION_SENSE_NO_VALUE;
 495
 496                 ret = cros_ec_motion_send_host_cmd(st, 0);
 497                 if (ret)
 498                         break;
 499
 500                 *val = st->resp->ec_rate.ret;
 501                 ret = IIO_VAL_INT;
 502                 break;
 503         case IIO_CHAN_INFO_FREQUENCY:
 504                 st->param.cmd = MOTIONSENSE_CMD_SENSOR_ODR;
 505                 st->param.sensor_odr.data =
 506                         EC_MOTION_SENSE_NO_VALUE;
 507
 508                 ret = cros_ec_motion_send_host_cmd(st, 0);
 509                 if (ret)
 510                         break;
 511
 512                 *val = st->resp->sensor_odr.ret;
 513                 ret = IIO_VAL_INT;
 514                 break;
 515         default:
 516                 ret = -EINVAL;
 517                 break;
 518         }
 519
 520         return ret;
 521 }
 522 EXPORT_SYMBOL_GPL(cros_ec_sensors_core_read);
 523
 524 int cros_ec_sensors_core_read_avail(struct iio_dev *indio_dev,
 525                                     struct iio_chan_spec const *chan,
 526                                     const int **vals,
 527                                     int *type,
 528                                     int *length,
 529                                     long mask)
 530 {
 531         struct cros_ec_sensors_core_state *state = iio_priv(indio_dev);
 532
 533         switch (mask) {
 534         case IIO_CHAN_INFO_SAMP_FREQ:
 535                 *length = ARRAY_SIZE(state->frequencies);
 536                 *vals = (const int *)&state->frequencies;
 537                 *type = IIO_VAL_INT;
 538                 return IIO_AVAIL_LIST;
 539         }
 540
 541         return -EINVAL;
 542 }
 543 EXPORT_SYMBOL_GPL(cros_ec_sensors_core_read_avail);
 544
 545 int cros_ec_sensors_core_write(struct cros_ec_sensors_core_state *st,
 546                                struct iio_chan_spec const *chan,
 547                                int val, int val2, long mask)
 548 {
 549         int ret;
 550
 551         switch (mask) {
 552         case IIO_CHAN_INFO_FREQUENCY:
 553                 st->param.cmd = MOTIONSENSE_CMD_SENSOR_ODR;
 554                 st->param.sensor_odr.data = val;
 555
 556                 /* Always roundup, so caller gets at least what it asks for. */
 557                 st->param.sensor_odr.roundup = 1;
 558
 559                 ret = cros_ec_motion_send_host_cmd(st, 0);
 560                 break;
 561         case IIO_CHAN_INFO_SAMP_FREQ:
 562                 st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
 563                 st->param.ec_rate.data = val;
 564
 565                 ret = cros_ec_motion_send_host_cmd(st, 0);
 566                 if (ret)
 567                         break;
 568                 st->curr_sampl_freq = val;
 569                 break;
 570         default:
 571                 ret = -EINVAL;
 572                 break;
 573         }
 574         return ret;
 575 }
 576 EXPORT_SYMBOL_GPL(cros_ec_sensors_core_write);
 577
 578 static int __maybe_unused cros_ec_sensors_prepare(struct device *dev)
 579 {
 580         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 581         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 582
 583         if (st->curr_sampl_freq == 0)
 584                 return 0;
 585
 586         /*
 587          * If the sensors are sampled at high frequency, we will not be able to
 588          * sleep. Set sampling to a long period if necessary.
 589          */
 590         if (st->curr_sampl_freq < CROS_EC_MIN_SUSPEND_SAMPLING_FREQUENCY) {
 591                 mutex_lock(&st->cmd_lock);
 592                 st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
 593                 st->param.ec_rate.data = CROS_EC_MIN_SUSPEND_SAMPLING_FREQUENCY;
 594                 cros_ec_motion_send_host_cmd(st, 0);
 595                 mutex_unlock(&st->cmd_lock);
 596         }
 597         return 0;
 598 }
 599
 600 static void __maybe_unused cros_ec_sensors_complete(struct device *dev)
 601 {
 602         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 603         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 604
 605         if (st->curr_sampl_freq == 0)
 606                 return;
 607
 608         if (st->curr_sampl_freq < CROS_EC_MIN_SUSPEND_SAMPLING_FREQUENCY) {
 609                 mutex_lock(&st->cmd_lock);
 610                 st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
 611                 st->param.ec_rate.data = st->curr_sampl_freq;
 612                 cros_ec_motion_send_host_cmd(st, 0);
 613                 mutex_unlock(&st->cmd_lock);
 614         }
 615 }
 616
 617 const struct dev_pm_ops cros_ec_sensors_pm_ops = {
 618 #ifdef CONFIG_PM_SLEEP
 619         .prepare = cros_ec_sensors_prepare,
 620         .complete = cros_ec_sensors_complete
 621 #endif
 622 };
 623 EXPORT_SYMBOL_GPL(cros_ec_sensors_pm_ops);
 624
 625 MODULE_DESCRIPTION("ChromeOS EC sensor hub core functions");
 626 MODULE_LICENSE("GPL v2");