| /* |
| * Copyright (C) 2008-2014 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 "Sensors" |
| |
| #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 "sensors.h" |
| #include "CwMcuSensor.h" |
| |
| /*****************************************************************************/ |
| |
| #define DELAY_OUT_TIME 0x7FFFFFFF |
| |
| #define LIGHT_SENSOR_POLLTIME 2000000000 |
| |
| /*****************************************************************************/ |
| static const struct sensor_t sSensorList[] = { |
| {.name = "Accelerometer Sensor", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_A, |
| .type = SENSOR_TYPE_ACCELEROMETER, |
| .maxRange = RANGE_A, |
| .resolution = CONVERT_A, |
| .power = 0.17f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE, |
| .reserved = {} |
| }, |
| {.name = "Magnetic field Sensor", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_M, |
| .type = SENSOR_TYPE_MAGNETIC_FIELD, |
| .maxRange = 200.0f, |
| .resolution = CONVERT_M, |
| .power = 5.0f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE, |
| .reserved = {} |
| }, |
| {.name = "Gyroscope Sensor", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_GY, |
| .type = SENSOR_TYPE_GYROSCOPE, |
| .maxRange = 2000.0f, |
| .resolution = CONVERT_GYRO, |
| .power = 6.1f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE, |
| .reserved = {} |
| }, |
| {.name = "CM32181 Light sensor", |
| .vendor = "Capella Microsystems", |
| .version = 1, |
| .handle = ID_L, |
| .type = SENSOR_TYPE_LIGHT, |
| .maxRange = 10240.0f, |
| .resolution = 1.0f, |
| .power = 0.15f, |
| .minDelay = 0, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 0, |
| .stringType = NULL, |
| .requiredPermission = NULL, |
| .maxDelay = 0, |
| .flags = SENSOR_FLAG_ON_CHANGE_MODE, |
| .reserved = {} |
| }, |
| {.name = "Pressure Sensor", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_PS, |
| .type = SENSOR_TYPE_PRESSURE, |
| .maxRange = 2000, |
| .resolution = 1.0f, |
| .power = 0.0027f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE, |
| .reserved = {} |
| }, |
| {.name = "CWGD Orientation Sensor", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_O, |
| .type = SENSOR_TYPE_ORIENTATION, |
| .maxRange = 360.0f, |
| .resolution = 0.1f, |
| .power = 11.27f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE, |
| .reserved = {} |
| }, |
| {.name = "Rotation Vector", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_RV, |
| .type = SENSOR_TYPE_ROTATION_VECTOR, |
| .maxRange = 1.0f, |
| .resolution = 0.0001f, |
| .power = 11.27f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE, |
| .reserved = {} |
| }, |
| {.name = "Linear Acceleration", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_LA, |
| .type = SENSOR_TYPE_LINEAR_ACCELERATION, |
| .maxRange = RANGE_A, |
| .resolution = 0.01, |
| .power = 11.27f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE, |
| .reserved = {} |
| }, |
| {.name = "Gravity", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_G, |
| .type = SENSOR_TYPE_GRAVITY, |
| .maxRange = GRAVITY_EARTH, |
| .resolution = 0.01, |
| .power = 11.27f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE, |
| .reserved = {} |
| }, |
| {.name = "Magnetic Uncalibrated", |
| .vendor = "hTC Corp.", |
| .version = 1, |
| .handle = ID_CW_MAGNETIC_UNCALIBRATED, |
| .type = SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED, |
| .maxRange = 200.0f, |
| .resolution = CONVERT_M, |
| .power = 5.0f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 610, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE, |
| .reserved = {} |
| }, |
| {.name = "Gyroscope Uncalibrated", |
| .vendor = "hTC Corp.", |
| .version = 1, |
| .handle = ID_CW_GYROSCOPE_UNCALIBRATED, |
| .type = SENSOR_TYPE_GYROSCOPE_UNCALIBRATED, |
| .maxRange = 2000.0f, |
| .resolution = CONVERT_GYRO, |
| .power = 6.1f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 610, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE, |
| .reserved = {} |
| }, |
| {.name = "Game Rotation Vector", |
| .vendor = "hTC Corp.", |
| .version = 1, |
| .handle = ID_CW_GAME_ROTATION_VECTOR, |
| .type = SENSOR_TYPE_GAME_ROTATION_VECTOR, |
| .maxRange = 1.0f, |
| .resolution = 0.0001f, |
| .power = 11.27f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE, |
| .reserved = {} |
| }, |
| {.name = "Geomagnetic Rotation Vector", |
| .vendor = "hTC Corp.", |
| .version = 1, |
| .handle = ID_CW_GEOMAGNETIC_ROTATION_VECTOR, |
| .type = SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR, |
| .maxRange = 1.0f, |
| .resolution = 0.0001f, |
| .power = 11.27f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE, |
| .reserved = {} |
| }, |
| {.name = "Significant Motion", |
| .vendor = "hTC Corp.", |
| .version = 1, |
| .handle = ID_CW_SIGNIFICANT_MOTION, |
| .type = SENSOR_TYPE_SIGNIFICANT_MOTION, |
| .maxRange = 200.0f, |
| .resolution = 1.0f, |
| .power = 0.17f, |
| .minDelay = -1, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 0, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 0, |
| .flags = SENSOR_FLAG_ONE_SHOT_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "Step Detector", |
| .vendor = "hTC Corp.", |
| .version = 1, |
| .handle = ID_CW_STEP_DETECTOR, |
| .type = SENSOR_TYPE_STEP_DETECTOR, |
| .maxRange = 200.0f, |
| .resolution = 1.0f, |
| .power = 0.17f, |
| .minDelay = 0, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 0, |
| .flags = SENSOR_FLAG_SPECIAL_REPORTING_MODE, |
| .reserved = {} |
| }, |
| {.name = "Step Counter", |
| .vendor = "hTC Corp.", |
| .version = 1, |
| .handle = ID_CW_STEP_COUNTER, |
| .type = SENSOR_TYPE_STEP_COUNTER, |
| .maxRange = 200.0f, |
| .resolution = 1.0f, |
| .power = 0.17f, |
| .minDelay = 0, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 0, |
| .flags = SENSOR_FLAG_ON_CHANGE_MODE, |
| .reserved = {} |
| }, |
| |
| |
| {.name = "Accelerometer Sensor (WAKE_UP)", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_A_W, |
| .type = SENSOR_TYPE_ACCELEROMETER, |
| .maxRange = RANGE_A, |
| .resolution = CONVERT_A, |
| .power = 0.17f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "Magnetic field Sensor (WAKE_UP)", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_M_W, |
| .type = SENSOR_TYPE_MAGNETIC_FIELD, |
| .maxRange = 200.0f, |
| .resolution = CONVERT_M, |
| .power = 5.0f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "Gyroscope Sensor (WAKE_UP)", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_GY_W, |
| .type = SENSOR_TYPE_GYROSCOPE, |
| .maxRange = 2000.0f, |
| .resolution = CONVERT_GYRO, |
| .power = 6.1f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "Pressure Sensor (WAKE_UP)", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_PS_W, |
| .type = SENSOR_TYPE_PRESSURE, |
| .maxRange = 2000, |
| .resolution = 1.0f, |
| .power = 0.0027f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "CWGD Orientation Sensor (WAKE_UP)", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_O_W, |
| .type = SENSOR_TYPE_ORIENTATION, |
| .maxRange = 360.0f, |
| .resolution = 0.1f, |
| .power = 11.27f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "Rotation Vector (WAKE_UP)", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_RV_W, |
| .type = SENSOR_TYPE_ROTATION_VECTOR, |
| .maxRange = 1.0f, |
| .resolution = 0.0001f, |
| .power = 11.27f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "Linear Acceleration (WAKE_UP)", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_LA_W, |
| .type = SENSOR_TYPE_LINEAR_ACCELERATION, |
| .maxRange = RANGE_A, |
| .resolution = 0.01, |
| .power = 11.27f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "Gravity (WAKE_UP)", |
| .vendor = "HTC Group Ltd.", |
| .version = 1, |
| .handle = ID_G_W, |
| .type = SENSOR_TYPE_GRAVITY, |
| .maxRange = GRAVITY_EARTH, |
| .resolution = 0.01, |
| .power = 11.27f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "Magnetic Uncalibrated (WAKE_UP)", |
| .vendor = "hTC Corp.", |
| .version = 1, |
| .handle = ID_CW_MAGNETIC_UNCALIBRATED_W, |
| .type = SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED, |
| .maxRange = 200.0f, |
| .resolution = CONVERT_M, |
| .power = 5.0f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 610, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "Gyroscope Uncalibrated (WAKE_UP)", |
| .vendor = "hTC Corp.", |
| .version = 1, |
| .handle = ID_CW_GYROSCOPE_UNCALIBRATED_W, |
| .type = SENSOR_TYPE_GYROSCOPE_UNCALIBRATED, |
| .maxRange = 2000.0f, |
| .resolution = CONVERT_GYRO, |
| .power = 6.1f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 610, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "Game Rotation Vector (WAKE_UP)", |
| .vendor = "hTC Corp.", |
| .version = 1, |
| .handle = ID_CW_GAME_ROTATION_VECTOR_W, |
| .type = SENSOR_TYPE_GAME_ROTATION_VECTOR, |
| .maxRange = 1.0f, |
| .resolution = 0.0001f, |
| .power = 11.27f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "Geomagnetic Rotation Vector (WAKE_UP)", |
| .vendor = "hTC Corp.", |
| .version = 1, |
| .handle = ID_CW_GEOMAGNETIC_ROTATION_VECTOR_W, |
| .type = SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR, |
| .maxRange = 1.0f, |
| .resolution = 0.0001f, |
| .power = 11.27f, |
| .minDelay = 10000, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 200000, |
| .flags = SENSOR_FLAG_CONTINUOUS_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "Step Detector (WAKE_UP)", |
| .vendor = "hTC Corp.", |
| .version = 1, |
| .handle = ID_CW_STEP_DETECTOR_W, |
| .type = SENSOR_TYPE_STEP_DETECTOR, |
| .maxRange = 200.0f, |
| .resolution = 1.0f, |
| .power = 0.17f, |
| .minDelay = 0, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 0, |
| .flags = SENSOR_FLAG_SPECIAL_REPORTING_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| {.name = "Step Counter (WAKE_UP)", |
| .vendor = "hTC Corp.", |
| .version = 1, |
| .handle = ID_CW_STEP_COUNTER_W, |
| .type = SENSOR_TYPE_STEP_COUNTER, |
| .maxRange = 200.0f, |
| .resolution = 1.0f, |
| .power = 0.17f, |
| .minDelay = 0, |
| .fifoReservedEventCount = 0, |
| .fifoMaxEventCount = 1220, |
| .stringType = 0, |
| .requiredPermission = 0, |
| .maxDelay = 0, |
| .flags = SENSOR_FLAG_ON_CHANGE_MODE | SENSOR_FLAG_WAKE_UP, |
| .reserved = {} |
| }, |
| }; |
| |
| static int open_sensors(const struct hw_module_t* module, const char* id, |
| struct hw_device_t** device); |
| |
| static int sensors__get_sensors_list(struct sensors_module_t*, |
| struct sensor_t const** list) |
| { |
| *list = sSensorList; |
| return ARRAY_SIZE(sSensorList); |
| } |
| |
| static struct hw_module_methods_t sensors_module_methods = { |
| open: 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: "Sensor module", |
| author: "Electronic Company", |
| methods: &sensors_module_methods, |
| dso: NULL, |
| reserved: { }, |
| }, |
| get_sensors_list: sensors__get_sensors_list, |
| }; |
| |
| struct sensors_poll_context_t { |
| sensors_poll_device_1_t device; // must be first |
| |
| sensors_poll_context_t(); |
| ~sensors_poll_context_t(); |
| int activate(int handle, int enabled); |
| int setDelay(int handle, int64_t ns); |
| int pollEvents(sensors_event_t* data, int count); |
| int batch(int handle, int flags, int64_t period_ns, int64_t timeout); |
| int flush(int handle); |
| |
| private: |
| enum { |
| cwmcu = 0, |
| numSensorDrivers, |
| numFds, |
| }; |
| |
| static const size_t wake = numFds - 1; |
| static const char WAKE_MESSAGE = 'W'; |
| struct pollfd mPollFds[numFds]; |
| int mWritePipeFd; |
| SensorBase* mSensors[numSensorDrivers]; |
| |
| int handleToDriver(int handle) const { |
| switch (handle) { |
| case ID_A: |
| case ID_M: |
| case ID_GY: |
| case ID_L: |
| case ID_PS: |
| case ID_O: |
| case ID_RV: |
| case ID_LA: |
| case ID_G: |
| case ID_CW_MAGNETIC_UNCALIBRATED: |
| case ID_CW_GYROSCOPE_UNCALIBRATED: |
| case ID_CW_GAME_ROTATION_VECTOR: |
| case ID_CW_GEOMAGNETIC_ROTATION_VECTOR: |
| case ID_CW_SIGNIFICANT_MOTION: |
| case ID_CW_STEP_DETECTOR: |
| case ID_CW_STEP_COUNTER: |
| case ID_A_W: |
| case ID_M_W: |
| case ID_GY_W: |
| case ID_PS_W: |
| case ID_O_W: |
| case ID_RV_W: |
| case ID_LA_W: |
| case ID_G_W: |
| case ID_CW_MAGNETIC_UNCALIBRATED_W: |
| case ID_CW_GYROSCOPE_UNCALIBRATED_W: |
| case ID_CW_GAME_ROTATION_VECTOR_W: |
| case ID_CW_GEOMAGNETIC_ROTATION_VECTOR_W: |
| case ID_CW_STEP_DETECTOR_W: |
| case ID_CW_STEP_COUNTER_W: |
| return cwmcu; |
| } |
| return -EINVAL; |
| } |
| }; |
| |
| /*****************************************************************************/ |
| |
| sensors_poll_context_t::sensors_poll_context_t() |
| { |
| mSensors[cwmcu] = new CwMcuSensor(); |
| mPollFds[cwmcu].fd = mSensors[cwmcu]->getFd(); |
| mPollFds[cwmcu].events = POLLIN; |
| mPollFds[cwmcu].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[wake].fd = wakeFds[0]; |
| mPollFds[wake].events = POLLIN; |
| mPollFds[wake].revents = 0; |
| } |
| |
| sensors_poll_context_t::~sensors_poll_context_t() { |
| for (int i=0 ; i<numSensorDrivers ; i++) { |
| delete mSensors[i]; |
| } |
| close(mPollFds[wake].fd); |
| close(mWritePipeFd); |
| } |
| |
| int sensors_poll_context_t::activate(int handle, int enabled) { |
| int index = handleToDriver(handle); |
| if (index < 0) return index; |
| int err = mSensors[index]->setEnable(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 sensors_poll_context_t::setDelay(int handle, int64_t ns) { |
| |
| int index = handleToDriver(handle); |
| if (index < 0) return index; |
| return mSensors[index]->setDelay(handle, ns); |
| } |
| |
| int 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() |
| for (int i=0 ; count && i<numSensorDrivers ; i++) { |
| SensorBase* const sensor(mSensors[i]); |
| if ((mPollFds[i].revents & POLLIN) || (sensor->hasPendingEvents())) { |
| int nb = sensor->readEvents(data, count); |
| if (nb < count) { |
| // no more data for this sensor |
| mPollFds[i].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[wake].revents & POLLIN) { |
| char msg(WAKE_MESSAGE); |
| int result = read(mPollFds[wake].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[wake].revents = 0; |
| } |
| } |
| // if we have events and space, go read them |
| } while (n && count); |
| return nbEvents; |
| } |
| |
| int sensors_poll_context_t::batch(int handle, int flags, int64_t period_ns, int64_t timeout) |
| { |
| int index = handleToDriver(handle); |
| |
| if (index < 0) |
| return index; |
| |
| int err = mSensors[index]->batch(handle, flags, period_ns, timeout); |
| |
| return err; |
| } |
| |
| int sensors_poll_context_t::flush(int handle) |
| { |
| int index = handleToDriver(handle); |
| |
| if (index < 0) |
| return index; |
| |
| int err = mSensors[index]->flush(handle); |
| |
| return err; |
| } |
| |
| |
| /*****************************************************************************/ |
| |
| static int poll__close(struct hw_device_t *dev) |
| { |
| sensors_poll_context_t *ctx = reinterpret_cast<sensors_poll_context_t *>(dev); |
| if (ctx) { |
| delete ctx; |
| } |
| return 0; |
| } |
| |
| static int poll__activate(struct sensors_poll_device_t *dev, |
| int handle, int enabled) { |
| sensors_poll_context_t *ctx = reinterpret_cast<sensors_poll_context_t *>(dev); |
| return ctx->activate(handle, enabled); |
| } |
| |
| static int poll__setDelay(struct sensors_poll_device_t *dev, |
| int handle, int64_t ns) { |
| sensors_poll_context_t *ctx = reinterpret_cast<sensors_poll_context_t *>(dev); |
| return ctx->setDelay(handle, ns); |
| } |
| |
| static int poll__poll(struct sensors_poll_device_t *dev, |
| sensors_event_t* data, int count) { |
| sensors_poll_context_t *ctx = reinterpret_cast<sensors_poll_context_t *>(dev); |
| return ctx->pollEvents(data, count); |
| } |
| |
| static int poll__batch(struct sensors_poll_device_1 *dev, |
| int handle, int flags, int64_t period_ns, int64_t timeout) |
| { |
| sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev; |
| return ctx->batch(handle, flags, period_ns, timeout); |
| } |
| |
| static int poll__flush(struct sensors_poll_device_1 *dev, |
| int handle) |
| { |
| sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev; |
| return ctx->flush(handle); |
| } |
| /*****************************************************************************/ |
| |
| // Open a new instance of a sensor device using name |
| static int open_sensors(const struct hw_module_t* module, const char*, |
| struct hw_device_t** device) |
| { |
| sensors_poll_context_t *dev = new sensors_poll_context_t(); |
| |
| memset(&dev->device, 0, sizeof(sensors_poll_device_1_t)); |
| |
| dev->device.common.tag = HARDWARE_DEVICE_TAG; |
| dev->device.common.version = SENSORS_DEVICE_API_VERSION_1_3; |
| dev->device.common.module = const_cast<hw_module_t*>(module); |
| dev->device.common.close = poll__close; |
| dev->device.activate = poll__activate; |
| dev->device.setDelay = poll__setDelay; |
| dev->device.poll = poll__poll; |
| |
| // Batch processing |
| dev->device.batch = poll__batch; |
| dev->device.flush = poll__flush; |
| |
| *device = &dev->device.common; |
| |
| return 0; |
| } |
| |
