drivers/iio/common/cros_ec_sensors/cros_ec_sensors_core.c

   1 /*
   2  * cros_ec_sensors_core - Common function for Chrome OS EC sensor driver.
   3  *
   4  * Copyright (C) 2016 Google, Inc
   5  *
   6  * This software is licensed under the terms of the GNU General Public
   7  * License version 2, as published by the Free Software Foundation, and
   8  * may be copied, distributed, and modified under those terms.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  */
  15
  16 #include <linux/delay.h>
  17 #include <linux/device.h>
  18 #include <linux/iio/buffer.h>
  19 #include <linux/iio/common/cros_ec_sensors_core.h>
  20 #include <linux/iio/iio.h>
  21 #include <linux/iio/kfifo_buf.h>
  22 #include <linux/iio/trigger_consumer.h>
  23 #include <linux/kernel.h>
  24 #include <linux/mfd/cros_ec.h>
  25 #include <linux/mfd/cros_ec_commands.h>
  26 #include <linux/module.h>
  27 #include <linux/slab.h>
  28 #include <linux/sysfs.h>
  29 #include <linux/platform_device.h>
  30
  31 static char *cros_ec_loc[] = {
  32         [MOTIONSENSE_LOC_BASE] = "base",
  33         [MOTIONSENSE_LOC_LID] = "lid",
  34         [MOTIONSENSE_LOC_MAX] = "unknown",
  35 };
  36
  37 int cros_ec_sensors_core_init(struct platform_device *pdev,
  38                               struct iio_dev *indio_dev,
  39                               bool physical_device)
  40 {
  41         struct device *dev = &pdev->dev;
  42         struct cros_ec_sensors_core_state *state = iio_priv(indio_dev);
  43         struct cros_ec_dev *ec = dev_get_drvdata(pdev->dev.parent);
  44         struct cros_ec_sensor_platform *sensor_platform = dev_get_platdata(dev);
  45
  46         platform_set_drvdata(pdev, indio_dev);
  47
  48         state->ec = ec->ec_dev;
  49         state->msg = devm_kzalloc(&pdev->dev, sizeof(*state->msg) +
  50                                 max((u16)sizeof(struct ec_params_motion_sense),
  51                                 state->ec->max_response), GFP_KERNEL);
  52         if (!state->msg)
  53                 return -ENOMEM;
  54
  55         state->resp = (struct ec_response_motion_sense *)state->msg->data;
  56
  57         mutex_init(&state->cmd_lock);
  58
  59         /* Set up the host command structure. */
  60         state->msg->version = 2;
  61         state->msg->command = EC_CMD_MOTION_SENSE_CMD + ec->cmd_offset;
  62         state->msg->outsize = sizeof(struct ec_params_motion_sense);
  63
  64         indio_dev->dev.parent = &pdev->dev;
  65         indio_dev->name = pdev->name;
  66
  67         if (physical_device) {
  68                 indio_dev->modes = INDIO_DIRECT_MODE;
  69
  70                 state->param.cmd = MOTIONSENSE_CMD_INFO;
  71                 state->param.info.sensor_num = sensor_platform->sensor_num;
  72                 if (cros_ec_motion_send_host_cmd(state, 0)) {
  73                         dev_warn(dev, "Can not access sensor info\n");
  74                         return -EIO;
  75                 }
  76                 state->type = state->resp->info.type;
  77                 state->loc = state->resp->info.location;
  78         }
  79
  80         return 0;
  81 }
  82 EXPORT_SYMBOL_GPL(cros_ec_sensors_core_init);
  83
  84 int cros_ec_motion_send_host_cmd(struct cros_ec_sensors_core_state *state,
  85                                  u16 opt_length)
  86 {
  87         int ret;
  88
  89         if (opt_length)
  90                 state->msg->insize = min(opt_length, state->ec->max_response);
  91         else
  92                 state->msg->insize = state->ec->max_response;
  93
  94         memcpy(state->msg->data, &state->param, sizeof(state->param));
  95
  96         ret = cros_ec_cmd_xfer_status(state->ec, state->msg);
  97         if (ret < 0)
  98                 return -EIO;
  99
 100         if (ret &&
 101             state->resp != (struct ec_response_motion_sense *)state->msg->data)
 102                 memcpy(state->resp, state->msg->data, ret);
 103
 104         return 0;
 105 }
 106 EXPORT_SYMBOL_GPL(cros_ec_motion_send_host_cmd);
 107
 108 static ssize_t cros_ec_sensors_calibrate(struct iio_dev *indio_dev,
 109                 uintptr_t private, const struct iio_chan_spec *chan,
 110                 const char *buf, size_t len)
 111 {
 112         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 113         int ret, i;
 114         bool calibrate;
 115
 116         ret = strtobool(buf, &calibrate);
 117         if (ret < 0)
 118                 return ret;
 119         if (!calibrate)
 120                 return -EINVAL;
 121
 122         mutex_lock(&st->cmd_lock);
 123         st->param.cmd = MOTIONSENSE_CMD_PERFORM_CALIB;
 124         ret = cros_ec_motion_send_host_cmd(st, 0);
 125         if (ret != 0) {
 126                 dev_warn(&indio_dev->dev, "Unable to calibrate sensor\n");
 127         } else {
 128                 /* Save values */
 129                 for (i = CROS_EC_SENSOR_X; i < CROS_EC_SENSOR_MAX_AXIS; i++)
 130                         st->calib[i] = st->resp->perform_calib.offset[i];
 131         }
 132         mutex_unlock(&st->cmd_lock);
 133
 134         return ret ? ret : len;
 135 }
 136
 137 static ssize_t cros_ec_sensors_loc(struct iio_dev *indio_dev,
 138                 uintptr_t private, const struct iio_chan_spec *chan,
 139                 char *buf)
 140 {
 141         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 142
 143         return snprintf(buf, PAGE_SIZE, "%s\n", cros_ec_loc[st->loc]);
 144 }
 145
 146 const struct iio_chan_spec_ext_info cros_ec_sensors_ext_info[] = {
 147         {
 148                 .name = "calibrate",
 149                 .shared = IIO_SHARED_BY_ALL,
 150                 .write = cros_ec_sensors_calibrate
 151         },
 152         {
 153                 .name = "location",
 154                 .shared = IIO_SHARED_BY_ALL,
 155                 .read = cros_ec_sensors_loc
 156         },
 157         { },
 158 };
 159 EXPORT_SYMBOL_GPL(cros_ec_sensors_ext_info);
 160
 161 /**
 162  * cros_ec_sensors_idx_to_reg - convert index into offset in shared memory
 163  * @st:         pointer to state information for device
 164  * @idx:        sensor index (should be element of enum sensor_index)
 165  *
 166  * Return:      address to read at
 167  */
 168 static unsigned int cros_ec_sensors_idx_to_reg(
 169                                         struct cros_ec_sensors_core_state *st,
 170                                         unsigned int idx)
 171 {
 172         /*
 173          * When using LPC interface, only space for 2 Accel and one Gyro.
 174          * First halfword of MOTIONSENSE_TYPE_ACCEL is used by angle.
 175          */
 176         if (st->type == MOTIONSENSE_TYPE_ACCEL)
 177                 return EC_MEMMAP_ACC_DATA + sizeof(u16) *
 178                         (1 + idx + st->param.info.sensor_num *
 179                          CROS_EC_SENSOR_MAX_AXIS);
 180
 181         return EC_MEMMAP_GYRO_DATA + sizeof(u16) * idx;
 182 }
 183
 184 static int cros_ec_sensors_cmd_read_u8(struct cros_ec_device *ec,
 185                                        unsigned int offset, u8 *dest)
 186 {
 187         return ec->cmd_readmem(ec, offset, 1, dest);
 188 }
 189
 190 static int cros_ec_sensors_cmd_read_u16(struct cros_ec_device *ec,
 191                                          unsigned int offset, u16 *dest)
 192 {
 193         __le16 tmp;
 194         int ret = ec->cmd_readmem(ec, offset, 2, &tmp);
 195
 196         if (ret >= 0)
 197                 *dest = le16_to_cpu(tmp);
 198
 199         return ret;
 200 }
 201
 202 /**
 203  * cros_ec_sensors_read_until_not_busy() - read until is not busy
 204  *
 205  * @st: pointer to state information for device
 206  *
 207  * Read from EC status byte until it reads not busy.
 208  * Return: 8-bit status if ok, -errno on failure.
 209  */
 210 static int cros_ec_sensors_read_until_not_busy(
 211                                         struct cros_ec_sensors_core_state *st)
 212 {
 213         struct cros_ec_device *ec = st->ec;
 214         u8 status;
 215         int ret, attempts = 0;
 216
 217         ret = cros_ec_sensors_cmd_read_u8(ec, EC_MEMMAP_ACC_STATUS, &status);
 218         if (ret < 0)
 219                 return ret;
 220
 221         while (status & EC_MEMMAP_ACC_STATUS_BUSY_BIT) {
 222                 /* Give up after enough attempts, return error. */
 223                 if (attempts++ >= 50)
 224                         return -EIO;
 225
 226                 /* Small delay every so often. */
 227                 if (attempts % 5 == 0)
 228                         msleep(25);
 229
 230                 ret = cros_ec_sensors_cmd_read_u8(ec, EC_MEMMAP_ACC_STATUS,
 231                                                   &status);
 232                 if (ret < 0)
 233                         return ret;
 234         }
 235
 236         return status;
 237 }
 238
 239 /**
 240  * read_ec_sensors_data_unsafe() - read acceleration data from EC shared memory
 241  * @indio_dev:  pointer to IIO device
 242  * @scan_mask:  bitmap of the sensor indices to scan
 243  * @data:       location to store data
 244  *
 245  * This is the unsafe function for reading the EC data. It does not guarantee
 246  * that the EC will not modify the data as it is being read in.
 247  *
 248  * Return: 0 on success, -errno on failure.
 249  */
 250 static int cros_ec_sensors_read_data_unsafe(struct iio_dev *indio_dev,
 251                          unsigned long scan_mask, s16 *data)
 252 {
 253         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 254         struct cros_ec_device *ec = st->ec;
 255         unsigned int i;
 256         int ret;
 257
 258         /* Read all sensors enabled in scan_mask. Each value is 2 bytes. */
 259         for_each_set_bit(i, &scan_mask, indio_dev->masklength) {
 260                 ret = cros_ec_sensors_cmd_read_u16(ec,
 261                                              cros_ec_sensors_idx_to_reg(st, i),
 262                                              data);
 263                 if (ret < 0)
 264                         return ret;
 265
 266                 data++;
 267         }
 268
 269         return 0;
 270 }
 271
 272 int cros_ec_sensors_read_lpc(struct iio_dev *indio_dev,
 273                              unsigned long scan_mask, s16 *data)
 274 {
 275         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 276         struct cros_ec_device *ec = st->ec;
 277         u8 samp_id = 0xff, status = 0;
 278         int ret, attempts = 0;
 279
 280         /*
 281          * Continually read all data from EC until the status byte after
 282          * all reads reflects that the EC is not busy and the sample id
 283          * matches the sample id from before all reads. This guarantees
 284          * that data read in was not modified by the EC while reading.
 285          */
 286         while ((status & (EC_MEMMAP_ACC_STATUS_BUSY_BIT |
 287                           EC_MEMMAP_ACC_STATUS_SAMPLE_ID_MASK)) != samp_id) {
 288                 /* If we have tried to read too many times, return error. */
 289                 if (attempts++ >= 5)
 290                         return -EIO;
 291
 292                 /* Read status byte until EC is not busy. */
 293                 ret = cros_ec_sensors_read_until_not_busy(st);
 294                 if (ret < 0)
 295                         return ret;
 296
 297                 /*
 298                  * Store the current sample id so that we can compare to the
 299                  * sample id after reading the data.
 300                  */
 301                 samp_id = ret & EC_MEMMAP_ACC_STATUS_SAMPLE_ID_MASK;
 302
 303                 /* Read all EC data, format it, and store it into data. */
 304                 ret = cros_ec_sensors_read_data_unsafe(indio_dev, scan_mask,
 305                                                        data);
 306                 if (ret < 0)
 307                         return ret;
 308
 309                 /* Read status byte. */
 310                 ret = cros_ec_sensors_cmd_read_u8(ec, EC_MEMMAP_ACC_STATUS,
 311                                                   &status);
 312                 if (ret < 0)
 313                         return ret;
 314         }
 315
 316         return 0;
 317 }
 318 EXPORT_SYMBOL_GPL(cros_ec_sensors_read_lpc);
 319
 320 int cros_ec_sensors_read_cmd(struct iio_dev *indio_dev,
 321                              unsigned long scan_mask, s16 *data)
 322 {
 323         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 324         int ret;
 325         unsigned int i;
 326
 327         /* Read all sensor data through a command. */
 328         st->param.cmd = MOTIONSENSE_CMD_DATA;
 329         ret = cros_ec_motion_send_host_cmd(st, sizeof(st->resp->data));
 330         if (ret != 0) {
 331                 dev_warn(&indio_dev->dev, "Unable to read sensor data\n");
 332                 return ret;
 333         }
 334
 335         for_each_set_bit(i, &scan_mask, indio_dev->masklength) {
 336                 *data = st->resp->data.data[i];
 337                 data++;
 338         }
 339
 340         return 0;
 341 }
 342 EXPORT_SYMBOL_GPL(cros_ec_sensors_read_cmd);
 343
 344 irqreturn_t cros_ec_sensors_capture(int irq, void *p)
 345 {
 346         struct iio_poll_func *pf = p;
 347         struct iio_dev *indio_dev = pf->indio_dev;
 348         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 349         int ret;
 350
 351         mutex_lock(&st->cmd_lock);
 352
 353         /* Clear capture data. */
 354         memset(st->samples, 0, indio_dev->scan_bytes);
 355
 356         /* Read data based on which channels are enabled in scan mask. */
 357         ret = st->read_ec_sensors_data(indio_dev,
 358                                        *(indio_dev->active_scan_mask),
 359                                        (s16 *)st->samples);
 360         if (ret < 0)
 361                 goto done;
 362
 363         iio_push_to_buffers_with_timestamp(indio_dev, st->samples,
 364                                            iio_get_time_ns(indio_dev));
 365
 366 done:
 367         /*
 368          * Tell the core we are done with this trigger and ready for the
 369          * next one.
 370          */
 371         iio_trigger_notify_done(indio_dev->trig);
 372
 373         mutex_unlock(&st->cmd_lock);
 374
 375         return IRQ_HANDLED;
 376 }
 377 EXPORT_SYMBOL_GPL(cros_ec_sensors_capture);
 378
 379 int cros_ec_sensors_core_read(struct cros_ec_sensors_core_state *st,
 380                           struct iio_chan_spec const *chan,
 381                           int *val, int *val2, long mask)
 382 {
 383         int ret = IIO_VAL_INT;
 384
 385         switch (mask) {
 386         case IIO_CHAN_INFO_SAMP_FREQ:
 387                 st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
 388                 st->param.ec_rate.data =
 389                         EC_MOTION_SENSE_NO_VALUE;
 390
 391                 if (cros_ec_motion_send_host_cmd(st, 0))
 392                         ret = -EIO;
 393                 else
 394                         *val = st->resp->ec_rate.ret;
 395                 break;
 396         case IIO_CHAN_INFO_FREQUENCY:
 397                 st->param.cmd = MOTIONSENSE_CMD_SENSOR_ODR;
 398                 st->param.sensor_odr.data =
 399                         EC_MOTION_SENSE_NO_VALUE;
 400
 401                 if (cros_ec_motion_send_host_cmd(st, 0))
 402                         ret = -EIO;
 403                 else
 404                         *val = st->resp->sensor_odr.ret;
 405                 break;
 406         default:
 407                 break;
 408         }
 409
 410         return ret;
 411 }
 412 EXPORT_SYMBOL_GPL(cros_ec_sensors_core_read);
 413
 414 int cros_ec_sensors_core_write(struct cros_ec_sensors_core_state *st,
 415                                struct iio_chan_spec const *chan,
 416                                int val, int val2, long mask)
 417 {
 418         int ret = 0;
 419
 420         switch (mask) {
 421         case IIO_CHAN_INFO_FREQUENCY:
 422                 st->param.cmd = MOTIONSENSE_CMD_SENSOR_ODR;
 423                 st->param.sensor_odr.data = val;
 424
 425                 /* Always roundup, so caller gets at least what it asks for. */
 426                 st->param.sensor_odr.roundup = 1;
 427
 428                 if (cros_ec_motion_send_host_cmd(st, 0))
 429                         ret = -EIO;
 430                 break;
 431         case IIO_CHAN_INFO_SAMP_FREQ:
 432                 st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
 433                 st->param.ec_rate.data = val;
 434
 435                 if (cros_ec_motion_send_host_cmd(st, 0))
 436                         ret = -EIO;
 437                 else
 438                         st->curr_sampl_freq = val;
 439                 break;
 440         default:
 441                 ret = -EINVAL;
 442                 break;
 443         }
 444         return ret;
 445 }
 446 EXPORT_SYMBOL_GPL(cros_ec_sensors_core_write);
 447
 448 static int __maybe_unused cros_ec_sensors_prepare(struct device *dev)
 449 {
 450         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 451         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 452
 453         if (st->curr_sampl_freq == 0)
 454                 return 0;
 455
 456         /*
 457          * If the sensors are sampled at high frequency, we will not be able to
 458          * sleep. Set sampling to a long period if necessary.
 459          */
 460         if (st->curr_sampl_freq < CROS_EC_MIN_SUSPEND_SAMPLING_FREQUENCY) {
 461                 mutex_lock(&st->cmd_lock);
 462                 st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
 463                 st->param.ec_rate.data = CROS_EC_MIN_SUSPEND_SAMPLING_FREQUENCY;
 464                 cros_ec_motion_send_host_cmd(st, 0);
 465                 mutex_unlock(&st->cmd_lock);
 466         }
 467         return 0;
 468 }
 469
 470 static void __maybe_unused cros_ec_sensors_complete(struct device *dev)
 471 {
 472         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 473         struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
 474
 475         if (st->curr_sampl_freq == 0)
 476                 return;
 477
 478         if (st->curr_sampl_freq < CROS_EC_MIN_SUSPEND_SAMPLING_FREQUENCY) {
 479                 mutex_lock(&st->cmd_lock);
 480                 st->param.cmd = MOTIONSENSE_CMD_EC_RATE;
 481                 st->param.ec_rate.data = st->curr_sampl_freq;
 482                 cros_ec_motion_send_host_cmd(st, 0);
 483                 mutex_unlock(&st->cmd_lock);
 484         }
 485 }
 486
 487 const struct dev_pm_ops cros_ec_sensors_pm_ops = {
 488 #ifdef CONFIG_PM_SLEEP
 489         .prepare = cros_ec_sensors_prepare,
 490         .complete = cros_ec_sensors_complete
 491 #endif
 492 };
 493 EXPORT_SYMBOL_GPL(cros_ec_sensors_pm_ops);
 494
 495 MODULE_DESCRIPTION("ChromeOS EC sensor hub core functions");
 496 MODULE_LICENSE("GPL v2");