| /* |
| * Copyright (C) 2008-2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "CrosECSensor" |
| |
| #include <dirent.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <linux/input.h> |
| #include <math.h> |
| #include <poll.h> |
| #include <pthread.h> |
| #include <stdlib.h> |
| |
| #include <utils/Atomic.h> |
| #include <utils/Log.h> |
| |
| #include <hardware/sensors.h> |
| |
| #include "cros_ec_sensors.h" |
| #include "sensors.h" |
| |
| /*****************************************************************************/ |
| |
| /*****************************************************************************/ |
| |
| #define UNSET_FIELD -1 |
| /* |
| * TODO(gwendal): We should guess the fifo size, but |
| * we need to issue an ioctl instead of just reading IIO sysfs. |
| * EC will trigger an interrupt at 2/3 of its FIFO. |
| */ |
| #define CROS_EC_FIFO_SIZE (2048 * 2 / 3) |
| |
| /* Name of iio devices, as reported by cros_ec_dev.c */ |
| const char *cros_ec_sensor_names[] = { |
| [CROS_EC_ACCEL] = "cros-ec-accel", |
| [CROS_EC_GYRO] = "cros-ec-gyro", |
| [CROS_EC_MAG] = "cros-ec-mag", |
| [CROS_EC_PROX] = "cros-ec-prox", |
| [CROS_EC_LIGHT] = "cros-ec-light", |
| [CROS_EC_ACTIVITY] = "cros-ec-activity", |
| [CROS_EC_RING] = "cros-ec-ring", |
| }; |
| |
| /* Name of iio data names, as reported by IIO */ |
| const char *cros_ec_iio_axis_names[] = { |
| [CROS_EC_ACCEL] = "in_accel", |
| [CROS_EC_GYRO] = "in_anglvel", |
| }; |
| |
| /* |
| * cros_ec_activity is shared between sensors interface and |
| * activity interface. |
| * Activity has a separate module is not implemented yet |
| */ |
| |
| /* Activities that belongs to the sensor interface */ |
| const char *cros_ec_gesture_name[] = { |
| [CROS_EC_SIGMO] = "in_activity_still_change_falling_en", |
| }; |
| |
| const int cros_ec_gesture_id[] = { |
| [CROS_EC_SIGMO] = MOTIONSENSE_ACTIVITY_SIG_MOTION, |
| }; |
| |
| |
| /* |
| * Template for sensor_t structure return to motionservice. |
| * |
| * Some parameters (handle, range, resolution) are retreived |
| * from IIO. |
| */ |
| static const struct sensor_t sSensorListTemplate[] = { |
| [CROS_EC_ACCEL] = { |
| name: "CrosEC Accelerometer", |
| vendor: "Google", |
| version: 1, |
| handle: UNSET_FIELD, |
| type: SENSOR_TYPE_ACCELEROMETER, |
| maxRange: UNSET_FIELD, |
| resolution: UNSET_FIELD, |
| power: 0.18f, /* Based on BMI160 */ |
| minDelay: 5000, |
| fifoReservedEventCount: 0, |
| fifoMaxEventCount: CROS_EC_FIFO_SIZE, |
| stringType: SENSOR_STRING_TYPE_ACCELEROMETER, |
| requiredPermission: 0, |
| /* |
| * BMI160 has a problem at 6.25Hz or less, FIFO not readable. |
| * Works at 12.5Hz, so set maxDelay at 80ms |
| */ |
| maxDelay: 80000, |
| flags: SENSOR_FLAG_CONTINUOUS_MODE, |
| reserved: { 0 } |
| }, |
| [CROS_EC_GYRO] = { |
| name: "CrosEC Gyroscope", |
| vendor: "Google", |
| version: 1, |
| handle: UNSET_FIELD, |
| type: SENSOR_TYPE_GYROSCOPE, |
| maxRange: UNSET_FIELD, |
| resolution: UNSET_FIELD, |
| power: 0.85f, |
| minDelay: 5000, |
| fifoReservedEventCount: 0, |
| fifoMaxEventCount: CROS_EC_FIFO_SIZE, |
| stringType: SENSOR_STRING_TYPE_GYROSCOPE, |
| requiredPermission: 0, |
| maxDelay: 80000, |
| flags: SENSOR_FLAG_CONTINUOUS_MODE, |
| reserved: { 0 } |
| }, |
| [CROS_EC_MAG] = { |
| name: "CrosEC Compass", |
| vendor: "Google", |
| version: 1, |
| handle: UNSET_FIELD, |
| type: SENSOR_TYPE_MAGNETIC_FIELD, |
| maxRange: UNSET_FIELD, |
| resolution: UNSET_FIELD, |
| power: 5.0f, /* Based on BMM150 */ |
| /* |
| * BMI150 uses repetition to reduce output noise. |
| * Set ODR at no more than 25Hz. |
| */ |
| minDelay: 40000, |
| fifoReservedEventCount: 0, |
| fifoMaxEventCount: CROS_EC_FIFO_SIZE, |
| stringType: SENSOR_STRING_TYPE_MAGNETIC_FIELD, |
| requiredPermission: 0, |
| maxDelay: 200000, |
| flags: SENSOR_FLAG_CONTINUOUS_MODE, |
| reserved: { 0 } |
| }, |
| [CROS_EC_PROX] = { |
| name: "CrosEC Proximity", |
| vendor: "Google", |
| version: 1, |
| handle: UNSET_FIELD, |
| type: SENSOR_TYPE_PROXIMITY, |
| maxRange: UNSET_FIELD, |
| resolution: UNSET_FIELD, |
| power: 0.12f, /* Based on Si1141 */ |
| minDelay: 20000, |
| fifoReservedEventCount: 0, |
| fifoMaxEventCount: CROS_EC_FIFO_SIZE, |
| stringType: SENSOR_STRING_TYPE_PROXIMITY, |
| requiredPermission: 0, |
| /* Forced mode, can be long: 10s */ |
| maxDelay: 10000000, |
| /* WAKE UP required by API */ |
| flags: SENSOR_FLAG_ON_CHANGE_MODE | SENSOR_FLAG_WAKE_UP, |
| reserved: { 0 } |
| }, |
| [CROS_EC_LIGHT] = { |
| name: "CrosEC Light", |
| vendor: "Google", |
| version: 1, |
| handle: UNSET_FIELD, |
| type: SENSOR_TYPE_LIGHT, |
| maxRange: UNSET_FIELD, |
| resolution: UNSET_FIELD, |
| power: 0.12f, /* Based on Si1141 */ |
| minDelay: 20000, |
| fifoReservedEventCount: 0, |
| fifoMaxEventCount: CROS_EC_FIFO_SIZE, |
| stringType: SENSOR_STRING_TYPE_LIGHT, |
| requiredPermission: 0, |
| /* Forced mode, can be long: 10s */ |
| maxDelay: 10000000, |
| flags: SENSOR_FLAG_ON_CHANGE_MODE, |
| reserved: { 0 } |
| }, |
| }; |
| |
| static const struct sensor_t sGestureListTemplate[] = { |
| [CROS_EC_SIGMO] = { |
| name: "CrosEC Significant Motion", |
| vendor: "Google", |
| version: 1, |
| handle: UNSET_FIELD, |
| type: SENSOR_TYPE_SIGNIFICANT_MOTION, |
| maxRange: 1.0f, |
| resolution: 1.0f, |
| power: 0.18f, /* Based on BMI160 */ |
| minDelay: -1, |
| fifoReservedEventCount: 0, |
| fifoMaxEventCount: 0, |
| stringType: SENSOR_STRING_TYPE_SIGNIFICANT_MOTION, |
| requiredPermission: 0, |
| maxDelay: 0, |
| flags: SENSOR_FLAG_ONE_SHOT_MODE | SENSOR_FLAG_WAKE_UP, |
| reserved: { 0 } |
| }, |
| }; |
| |
| /* We only support the sensors in the lid */ |
| static const char *cros_ec_location = "lid"; |
| |
| static int Stotal_sensor_count_ = 0; |
| static int Stotal_max_sensor_handle_ = 0; |
| static int Stotal_max_gesture_handle_ = 0; |
| |
| static struct sensor_t *Ssensor_list_ = NULL; |
| |
| struct cros_ec_sensor_info *Ssensor_info_ = NULL; |
| struct cros_ec_gesture_info *Sgesture_info_ = NULL; |
| |
| static int cros_ec_open_sensors(const struct hw_module_t *module, |
| const char *id, |
| struct hw_device_t **device); |
| /* |
| * cros_ec_get_sensors_list: entry point that returns the list |
| * of sensors. |
| * |
| * At first invocation, build the list from Ssensor_info_, |
| * then keep returning the same list. |
| * |
| * The expected design is a hardcoded list of sensors. |
| * Therefore we don't have access to |
| */ |
| static int cros_ec_get_sensors_list(struct sensors_module_t*, |
| struct sensor_t const** list) |
| { |
| ALOGD("counting sensors: count %d: sensor_list_ %p\n", |
| Stotal_sensor_count_, Ssensor_list_); |
| |
| if (Stotal_sensor_count_ != 0) { |
| *list = Ssensor_list_; |
| return Stotal_sensor_count_; |
| } |
| |
| for (int i = 0 ; i < Stotal_max_sensor_handle_ ; i++) { |
| if (Ssensor_info_[i].device_name == NULL) |
| continue; |
| |
| Stotal_sensor_count_++; |
| Ssensor_list_ = (sensor_t*)realloc(Ssensor_list_, |
| Stotal_sensor_count_ * sizeof(sensor_t)); |
| if (Ssensor_list_ == NULL) { |
| ALOGI("Unable to allocate Ssensor_list_\n"); |
| return 0; |
| } |
| sensor_t *sensor_data; |
| sensor_data = &Ssensor_info_[i].sensor_data; |
| memcpy(&Ssensor_list_[Stotal_sensor_count_ - 1], sensor_data, |
| sizeof(sensor_t)); |
| } |
| |
| for (int i = 0 ; i < Stotal_max_gesture_handle_ ; i++) { |
| if (Sgesture_info_[i].device_name == NULL) |
| continue; |
| |
| Stotal_sensor_count_++; |
| Ssensor_list_ = (sensor_t*)realloc(Ssensor_list_, |
| Stotal_sensor_count_ * sizeof(sensor_t)); |
| if (Ssensor_list_ == NULL) { |
| ALOGI("Unable to allocate Ssensor_list_\n"); |
| return 0; |
| } |
| sensor_t *sensor_data; |
| sensor_data = &Sgesture_info_[i].sensor_data; |
| memcpy(&Ssensor_list_[Stotal_sensor_count_ - 1], sensor_data, |
| sizeof(sensor_t)); |
| } |
| *list = Ssensor_list_; |
| return Stotal_sensor_count_; |
| } |
| |
| /* |
| * cros_ec_get_sensors_names: Build list of gestures from IIO |
| * |
| * Looking into the cros_ec_activity sensors, looks for events |
| * the sensorserivces are managing. |
| * |
| * We assume only one cros_ec activity sensor. |
| */ |
| static int cros_ec_get_gesture_names(const char *sensor_name) |
| { |
| char path_device[IIO_MAX_DEVICE_NAME_LENGTH]; |
| strcpy(path_device, IIO_DIR); |
| strcat(path_device, sensor_name); |
| strcat(path_device, "/events"); |
| DIR *events_dir; |
| ALOGD("looking at %s:", path_device); |
| events_dir = opendir(path_device); |
| if (events_dir == NULL) |
| return -ENODEV; |
| const struct dirent *ent_event; |
| while (ent_event = readdir(events_dir), ent_event != NULL) { |
| int gesture; |
| for (gesture = 0; gesture < CROS_EC_MAX_GESTURE; gesture++) { |
| if (!strcmp(ent_event->d_name, cros_ec_gesture_name[gesture])) |
| break; |
| } |
| if (gesture == CROS_EC_MAX_GESTURE) |
| continue; |
| int gesture_id = cros_ec_gesture_id[gesture]; |
| if (Stotal_max_gesture_handle_ <= gesture_id) { |
| Sgesture_info_ = (cros_ec_gesture_info*)realloc(Sgesture_info_, |
| (gesture_id + 1) * sizeof(cros_ec_gesture_info)); |
| if (Sgesture_info_ == NULL) |
| return -ENOMEM; |
| memset(&Sgesture_info_[Stotal_max_gesture_handle_], 0, |
| (gesture_id + 1 - Stotal_max_gesture_handle_) * |
| sizeof(cros_ec_gesture_info)); |
| Stotal_max_gesture_handle_ = gesture_id + 1; |
| } |
| cros_ec_gesture_info *gesture_info = &Sgesture_info_[gesture_id]; |
| gesture_info->device_name = strdup(sensor_name); |
| gesture_info->enable_entry = cros_ec_gesture_name[gesture]; |
| |
| sensor_t *sensor_data; |
| sensor_data = &gesture_info->sensor_data; |
| memcpy(sensor_data, &sGestureListTemplate[gesture], sizeof(sensor_t)); |
| sensor_data->handle = CROS_EC_MAX_PHYSICAL_SENSOR + gesture_id; |
| |
| ALOGD("new gesture '%s' on device '%s' : handle: %d\n", |
| gesture_info->enable_entry, gesture_info->device_name, gesture_id); |
| } |
| closedir(events_dir); |
| return 0; |
| } |
| |
| /* |
| * cros_ec_calibrate_3d_sensor: calibrate Accel or Gyro. |
| * |
| * In factory, calibration data is in VPD. |
| * It is available from user space by reading /sys/firmware/vpd/ro/<Key>. |
| * Key names are similar to iio: <type>_<axis>_calibbias, |
| * when type is in_accel or in_anglvel and axis is x,y, or z. |
| */ |
| static int cros_ec_calibrate_3d_sensor(int sensor_type, const char *device_name) |
| { |
| const char vpd_path[] = "/sys/firmware/vpd/ro"; |
| |
| for (int i = X ; i < MAX_AXIS; i++) { |
| char calib_key[IIO_MAX_NAME_LENGTH]; |
| char calib_value[20]; |
| snprintf(calib_key, sizeof(calib_key), "%s_%c_calibbias", |
| cros_ec_iio_axis_names[sensor_type], 'x' + i); |
| if (cros_ec_sysfs_get_attr(vpd_path, calib_key, calib_value)) { |
| ALOGI("Calibration key %s missing.\n", calib_key); |
| continue; |
| } |
| if (cros_ec_sysfs_set_input_attr(device_name, calib_key, |
| calib_value, strlen(calib_value))) { |
| ALOGE("Writing bias %s to %s for device %s failed.\n", |
| calib_key, calib_value, device_name); |
| } |
| } |
| return 0; |
| } |
| |
| /* |
| * cros_ec_get_sensors_names: Build list of sensors from IIO |
| * |
| * Scanning /sys/iio/devices, finds all the sensors managed by the EC. |
| * |
| * Fill Ssensor_info_ global structure. |
| * ring_device_name: name of iio ring buffer. We |
| * will open /dev/<ring_device_name> later |
| * ring_trigger_name: Name of hardware trigger for setting the |
| * ring buffer producer side. |
| */ |
| static int cros_ec_get_sensors_names(char **ring_device_name, |
| char **ring_trigger_name) |
| { |
| /* |
| * If Ssensor_info_ is valid, we don't want to open |
| * the same device twice. |
| */ |
| if (Stotal_max_sensor_handle_ != 0) |
| return -EINVAL; |
| |
| *ring_device_name = NULL; |
| *ring_trigger_name = NULL; |
| |
| DIR *iio_dir; |
| iio_dir = opendir(IIO_DIR); |
| if (iio_dir == NULL) { |
| return -ENODEV; |
| } |
| const struct dirent *ent_device; |
| while (ent_device = readdir(iio_dir), ent_device != NULL) { |
| /* Find the iio directory with the sensor definition */ |
| if (ent_device->d_type != DT_LNK) |
| continue; |
| char path_device[IIO_MAX_DEVICE_NAME_LENGTH]; |
| strcpy(path_device, IIO_DIR); |
| strcat(path_device, ent_device->d_name); |
| |
| char dev_name[IIO_MAX_NAME_LENGTH + 1]; |
| if (cros_ec_sysfs_get_attr(path_device, "name", dev_name)) |
| continue; |
| |
| for (int i = CROS_EC_ACCEL; i < CROS_EC_RING; ++i) { |
| /* We assume only one sensor hub per device. |
| * Otherwise we need to look at the symlink and connect the 2: |
| * iio:device0 -> |
| * ../../../devices/7000c400.i2c/i2c-1/1-001e/cros-ec-dev.0/ |
| * cros-ec-accel.0/iio:device0 |
| * and |
| * ... |
| * iio:device1 -> |
| * ../../../devices/7000c400.i2c/i2c-1/1-001e/cros-ec-dev.0/ |
| * cros-ec-ring.0/iio:device1 |
| */ |
| if (!strcmp(cros_ec_sensor_names[i], dev_name)) { |
| /* |
| * First check if the device belongs to the lid. |
| * (base is keyboard) |
| */ |
| char loc[IIO_MAX_NAME_LENGTH + 1]; |
| if (cros_ec_sysfs_get_attr(path_device, "location", loc)) |
| continue; |
| if (strcmp(cros_ec_location, loc)) |
| continue; |
| |
| char dev_id[40]; |
| if (cros_ec_sysfs_get_attr(path_device, "id", dev_id)) |
| continue; |
| int sensor_id = atoi(dev_id); |
| if (Stotal_max_sensor_handle_ <= sensor_id) { |
| Ssensor_info_ = (cros_ec_sensor_info*)realloc(Ssensor_info_, |
| (sensor_id + 1) * sizeof(cros_ec_sensor_info)); |
| if (Ssensor_info_ == NULL) { |
| closedir(iio_dir); |
| return -ENOMEM; |
| } |
| memset(&Ssensor_info_[Stotal_max_sensor_handle_], 0, |
| (sensor_id + 1 - Stotal_max_sensor_handle_) * |
| sizeof(cros_ec_sensor_info)); |
| Stotal_max_sensor_handle_ = sensor_id + 1; |
| } |
| |
| struct cros_ec_sensor_info *sensor_info = &Ssensor_info_[sensor_id]; |
| sensor_info->type = static_cast<enum cros_ec_sensor_device>(i); |
| |
| if (i == CROS_EC_ACTIVITY) { |
| cros_ec_get_gesture_names(ent_device->d_name); |
| } else { |
| sensor_info->device_name = strdup(ent_device->d_name); |
| char dev_scale[40]; |
| if (cros_ec_sysfs_get_attr(path_device, "scale", dev_scale)) { |
| ALOGE("Unable to read scale\n"); |
| continue; |
| } |
| double scale = atof(dev_scale); |
| |
| sensor_t *sensor_data = &sensor_info->sensor_data; |
| memcpy(sensor_data, &sSensorListTemplate[i], sizeof(sensor_t)); |
| sensor_data->handle = sensor_id; |
| |
| if (sensor_data->type == SENSOR_TYPE_MAGNETIC_FIELD) |
| /* iio units are in Gauss, not micro Telsa */ |
| scale *= 100; |
| if (sensor_data->type == SENSOR_TYPE_PROXIMITY) { |
| /* |
| * Proximity does not detect anything beyond 3m. |
| */ |
| sensor_data->resolution = 1; |
| sensor_data->maxRange = 300; |
| } else { |
| sensor_data->resolution = scale; |
| sensor_data->maxRange = scale * (1 << 15); |
| } |
| |
| if (sensor_data->type == SENSOR_TYPE_ACCELEROMETER || |
| sensor_data->type == SENSOR_TYPE_GYROSCOPE) |
| /* There is an assumption by the calibration code that there is |
| * only one type of sensors per device. |
| * If it needs to change, we will add "location" sysfs key |
| * to find the proper calibration data. |
| */ |
| cros_ec_calibrate_3d_sensor(i, sensor_info->device_name); |
| |
| ALOGD("new dev '%s' handle: %d\n", |
| sensor_info->device_name, sensor_id); |
| } |
| break; |
| } |
| } |
| |
| if (!strcmp(cros_ec_sensor_names[CROS_EC_RING], dev_name)) { |
| *ring_device_name = strdup(ent_device->d_name); |
| } |
| |
| char trigger_name[80]; |
| strcpy(trigger_name, cros_ec_sensor_names[CROS_EC_RING]); |
| strcat(trigger_name, "-trigger"); |
| if (!strncmp(trigger_name, dev_name, strlen(trigger_name))) { |
| *ring_trigger_name = strdup(dev_name); |
| ALOGD("new trigger '%s' \n", *ring_trigger_name); |
| continue; |
| } |
| } |
| closedir(iio_dir); |
| |
| if (*ring_device_name == NULL || *ring_trigger_name == NULL) |
| return -ENODEV; |
| |
| return Stotal_max_sensor_handle_ ? Stotal_max_sensor_handle_ : -ENODEV; |
| } |
| |
| static struct hw_module_methods_t cros_ec_sensors_methods = { |
| open: cros_ec_open_sensors, |
| }; |
| |
| struct sensors_module_t HAL_MODULE_INFO_SYM = { |
| common: { |
| tag: HARDWARE_MODULE_TAG, |
| version_major: 1, |
| version_minor: 0, |
| id: SENSORS_HARDWARE_MODULE_ID, |
| name: "CrosEC sensor hub module", |
| author: "Google", |
| methods: &cros_ec_sensors_methods, |
| dso: NULL, |
| reserved: { 0 }, |
| }, |
| get_sensors_list: cros_ec_get_sensors_list, |
| set_operation_mode: NULL, |
| }; |
| |
| /*****************************************************************************/ |
| cros_ec_sensors_poll_context_t::cros_ec_sensors_poll_context_t( |
| const struct hw_module_t *module, |
| const char *ring_device_name, |
| const char *ring_trigger_name) |
| { |
| memset(&device, 0, sizeof(sensors_poll_device_1_t)); |
| |
| device.common.tag = HARDWARE_DEVICE_TAG; |
| device.common.version = SENSORS_DEVICE_API_VERSION_1_3; |
| device.common.module = const_cast<hw_module_t *>(module); |
| device.common.close = wrapper_close; |
| device.activate = wrapper_activate; |
| device.setDelay = wrapper_setDelay; |
| device.poll = wrapper_poll; |
| |
| // Batch processing |
| device.batch = wrapper_batch; |
| device.flush = wrapper_flush; |
| |
| /* |
| * One more time, assume only one sensor hub in the system. |
| * Find the iio:deviceX with name "cros_ec_ring" |
| * Open /dev/iio:deviceX, enable buffer. |
| */ |
| mSensor = new CrosECSensor( |
| Ssensor_info_, Stotal_max_sensor_handle_, |
| Sgesture_info_, Stotal_max_gesture_handle_, |
| ring_device_name, ring_trigger_name); |
| |
| mPollFds[crosEcRingFd].fd = mSensor->getFd(); |
| mPollFds[crosEcRingFd].events = POLLIN; |
| mPollFds[crosEcRingFd].revents = 0; |
| |
| int wakeFds[2]; |
| int result = pipe(wakeFds); |
| ALOGE_IF(result < 0, "error creating wake pipe (%s)", strerror(errno)); |
| fcntl(wakeFds[0], F_SETFL, O_NONBLOCK); |
| fcntl(wakeFds[1], F_SETFL, O_NONBLOCK); |
| mWritePipeFd = wakeFds[1]; |
| |
| mPollFds[crosEcWakeFd].fd = wakeFds[0]; |
| mPollFds[crosEcWakeFd].events = POLLIN; |
| mPollFds[crosEcWakeFd].revents = 0; |
| } |
| |
| cros_ec_sensors_poll_context_t::~cros_ec_sensors_poll_context_t() { |
| delete mSensor; |
| close(mPollFds[crosEcWakeFd].fd); |
| close(mWritePipeFd); |
| } |
| |
| int cros_ec_sensors_poll_context_t::activate(int handle, int enabled) { |
| int err = mSensor->activate(handle, enabled); |
| |
| if (enabled && !err) { |
| const char wakeMessage(WAKE_MESSAGE); |
| int result = write(mWritePipeFd, &wakeMessage, 1); |
| ALOGE_IF(result<0, "error sending wake message (%s)", strerror(errno)); |
| } |
| return err; |
| } |
| |
| int cros_ec_sensors_poll_context_t::setDelay(int /* handle */, |
| int64_t /* ns */) { |
| /* No supported */ |
| return 0; |
| } |
| |
| int cros_ec_sensors_poll_context_t::pollEvents(sensors_event_t* data, int count) |
| { |
| int nbEvents = 0; |
| int n = 0; |
| do { |
| // see if we have some leftover from the last poll() |
| if (mPollFds[crosEcRingFd].revents & POLLIN) { |
| int nb = mSensor->readEvents(data, count); |
| if (nb < count) { |
| // no more data for this sensor |
| mPollFds[crosEcRingFd].revents = 0; |
| } |
| count -= nb; |
| nbEvents += nb; |
| data += nb; |
| } |
| |
| if (count) { |
| // we still have some room, so try to see if we can get |
| // some events immediately or just wait if we don't have |
| // anything to return |
| do { |
| TEMP_FAILURE_RETRY(n = poll(mPollFds, numFds, |
| nbEvents ? 0 : -1)); |
| } while (n < 0 && errno == EINTR); |
| if (n < 0) { |
| ALOGE("poll() failed (%s)", strerror(errno)); |
| return -errno; |
| } |
| if (mPollFds[crosEcWakeFd].revents & POLLIN) { |
| char msg(WAKE_MESSAGE); |
| int result = read(mPollFds[crosEcWakeFd].fd, &msg, 1); |
| ALOGE_IF(result < 0, |
| "error reading from wake pipe (%s)", strerror(errno)); |
| ALOGE_IF(msg != WAKE_MESSAGE, |
| "unknown message on wake queue (0x%02x)", int(msg)); |
| mPollFds[crosEcWakeFd].revents = 0; |
| } |
| } |
| // if we have events and space, go read them |
| } while (n && count); |
| return nbEvents; |
| } |
| |
| int cros_ec_sensors_poll_context_t::batch(int handle, int /* flags */, |
| int64_t sampling_period_ns, |
| int64_t max_report_latency_ns) |
| { |
| return mSensor->batch(handle, sampling_period_ns, |
| max_report_latency_ns); |
| } |
| |
| int cros_ec_sensors_poll_context_t::flush(int handle) |
| { |
| return mSensor->flush(handle); |
| } |
| |
| |
| /*****************************************************************************/ |
| |
| int cros_ec_sensors_poll_context_t::wrapper_close(struct hw_device_t *dev) |
| { |
| cros_ec_sensors_poll_context_t *ctx = reinterpret_cast<cros_ec_sensors_poll_context_t *>(dev); |
| if (ctx) { |
| delete ctx; |
| } |
| if (Stotal_max_sensor_handle_ != 0) { |
| free(Ssensor_info_); |
| Stotal_max_sensor_handle_ = 0; |
| free(Sgesture_info_); |
| } |
| return 0; |
| } |
| |
| int cros_ec_sensors_poll_context_t::wrapper_activate(struct sensors_poll_device_t *dev, |
| int handle, int enabled) |
| { |
| cros_ec_sensors_poll_context_t *ctx = reinterpret_cast<cros_ec_sensors_poll_context_t *>(dev); |
| return ctx->activate(handle, enabled); |
| } |
| |
| int cros_ec_sensors_poll_context_t::wrapper_setDelay(struct sensors_poll_device_t *dev, |
| int handle, int64_t ns) |
| { |
| cros_ec_sensors_poll_context_t *ctx = reinterpret_cast<cros_ec_sensors_poll_context_t *>(dev); |
| return ctx->setDelay(handle, ns); |
| } |
| |
| int cros_ec_sensors_poll_context_t::wrapper_poll(struct sensors_poll_device_t *dev, |
| sensors_event_t* data, int count) |
| { |
| cros_ec_sensors_poll_context_t *ctx = reinterpret_cast<cros_ec_sensors_poll_context_t *>(dev); |
| return ctx->pollEvents(data, count); |
| } |
| |
| int cros_ec_sensors_poll_context_t::wrapper_batch(struct sensors_poll_device_1 *dev, |
| int handle, int flags, int64_t period_ns, int64_t timeout) |
| { |
| cros_ec_sensors_poll_context_t *ctx = reinterpret_cast<cros_ec_sensors_poll_context_t *>(dev); |
| return ctx->batch(handle, flags, period_ns, timeout); |
| } |
| |
| int cros_ec_sensors_poll_context_t::wrapper_flush(struct sensors_poll_device_1 *dev, |
| int handle) |
| { |
| cros_ec_sensors_poll_context_t *ctx = reinterpret_cast<cros_ec_sensors_poll_context_t *>(dev); |
| return ctx->flush(handle); |
| } |
| |
| /*****************************************************************************/ |
| |
| /* |
| * cros_ec_open_sensors: open entry point. |
| * |
| * Call by sensor service via helper function: sensors_open() |
| * |
| * Create a device the service will use for event polling. |
| * Assume one open/one close. |
| * |
| * Later, sensorservice will use device with an handle to access |
| * a particular sensor. |
| */ |
| static int cros_ec_open_sensors( |
| const struct hw_module_t* module, const char*, |
| struct hw_device_t** device) |
| { |
| char *ring_device_name, *ring_trigger_name; |
| int err; |
| err = cros_ec_get_sensors_names(&ring_device_name, &ring_trigger_name); |
| if (err < 0) |
| return err; |
| |
| cros_ec_sensors_poll_context_t *dev = new cros_ec_sensors_poll_context_t( |
| module, ring_device_name, ring_trigger_name); |
| |
| *device = &dev->device.common; |
| |
| return 0; |
| } |
| |
