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