| /* |
| * Copyright (C) 2011- 2012 Motorola, Inc. |
| * Copyright (C) 2008 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. |
| */ |
| |
| #include <fcntl.h> |
| #include <errno.h> |
| #include <math.h> |
| #include <poll.h> |
| #include <unistd.h> |
| #include <dirent.h> |
| #include <sys/select.h> |
| #include <dlfcn.h> |
| |
| #include <linux/akm8975.h> |
| #include <linux/stm401.h> |
| |
| #include <cutils/log.h> |
| |
| #include <hardware/mot_sensorhub_stm401.h> |
| |
| #include "stm401_hal.h" |
| |
| /*****************************************************************************/ |
| |
| HubSensor::HubSensor() |
| : SensorBase(SENSORHUB_DEVICE_NAME, SENSORHUB_AS_DATA_NAME), |
| mEnabled(0), |
| mWakeEnabled(0), |
| mPendingMask(0) |
| { |
| // read the actual value of all sensors if they're enabled already |
| struct input_absinfo absinfo; |
| short flags = 0; |
| FILE *fp; |
| int i; |
| int err = 0; |
| |
| memset(mMagCal, 0, sizeof(mMagCal)); |
| |
| open_device(); |
| |
| if (!ioctl(dev_fd, STM401_IOCTL_GET_SENSORS, &flags)) { |
| mEnabled = flags; |
| } |
| |
| if (!ioctl(dev_fd, STM401_IOCTL_GET_WAKESENSORS, &flags)) { |
| mWakeEnabled = flags; |
| } |
| |
| if ((fp = fopen(MAG_CAL_FILE, "r")) != NULL) { |
| for (i=0; i<STM401_MAG_CAL_SIZE; i++) { |
| mMagCal[i] = fgetc(fp); |
| } |
| fclose(fp); |
| err = ioctl(dev_fd, STM401_IOCTL_SET_MAG_CAL, &mMagCal); |
| if (err < 0) { |
| ALOGE("Can't send Mag Cal data"); |
| } |
| } |
| } |
| |
| HubSensor::~HubSensor() |
| { |
| } |
| |
| int HubSensor::enable(int32_t handle, int en) |
| { |
| int newState = en ? 1 : 0; |
| uint32_t new_enabled; |
| int found = 0; |
| int err = 0; |
| |
| new_enabled = mEnabled; |
| switch (handle) { |
| case ID_A: |
| new_enabled &= ~M_ACCEL; |
| if (newState) |
| new_enabled |= M_ACCEL; |
| found = 1; |
| break; |
| case ID_G: |
| new_enabled &= ~M_GYRO; |
| if (newState) |
| new_enabled |= M_GYRO; |
| found = 1; |
| break; |
| case ID_PR: |
| new_enabled &= ~M_PRESSURE; |
| if (newState) |
| new_enabled |= M_PRESSURE; |
| found = 1; |
| break; |
| case ID_M: |
| case ID_O: |
| new_enabled &= ~M_ECOMPASS; |
| if (newState) |
| new_enabled |= M_ECOMPASS; |
| else { |
| FILE *fp; |
| int i; |
| |
| err = ioctl(dev_fd, STM401_IOCTL_GET_MAG_CAL, &mMagCal); |
| if (err < 0) { |
| ALOGE("Can't read Mag Cal data"); |
| } else { |
| if ((fp = fopen(MAG_CAL_FILE, "w")) == NULL) { |
| ALOGE("Can't open Mag Cal file"); |
| } else { |
| for (i=0; i<STM401_MAG_CAL_SIZE; i++) { |
| fputc(mMagCal[i], fp); |
| } |
| fclose(fp); |
| } |
| } |
| } |
| found = 1; |
| break; |
| case ID_T: |
| new_enabled &= ~M_TEMPERATURE; |
| if (newState) |
| new_enabled |= M_TEMPERATURE; |
| found = 1; |
| break; |
| case ID_L: |
| new_enabled &= ~M_ALS; |
| if (newState) |
| new_enabled |= M_ALS; |
| found = 1; |
| break; |
| case ID_LA: |
| new_enabled &= ~M_LIN_ACCEL; |
| if (newState) |
| new_enabled |= M_LIN_ACCEL; |
| found = 1; |
| break; |
| case ID_Q: |
| new_enabled &= ~M_QUATERNION; |
| if (newState) |
| new_enabled |= M_QUATERNION; |
| found = 1; |
| break; |
| case ID_GR: |
| new_enabled &= ~M_GRAVITY; |
| if (newState) |
| new_enabled |= M_GRAVITY; |
| found = 1; |
| break; |
| case ID_DR: |
| new_enabled &= ~M_DISP_ROTATE; |
| if (newState) |
| new_enabled |= M_DISP_ROTATE; |
| found = 1; |
| break; |
| case ID_DB: |
| new_enabled &= ~M_DISP_BRIGHTNESS; |
| if (newState) |
| new_enabled |= M_DISP_BRIGHTNESS; |
| found = 1; |
| break; |
| case ID_UNCALIB_GYRO: |
| new_enabled &= ~M_UNCALIB_GYRO; |
| if (newState) |
| new_enabled |= M_UNCALIB_GYRO; |
| found = 1; |
| break; |
| case ID_UNCALIB_MAG: |
| new_enabled &= ~M_UNCALIB_MAG; |
| if (newState) |
| new_enabled |= M_UNCALIB_MAG; |
| found = 1; |
| break; |
| case ID_STEP_COUNTER: |
| new_enabled &= ~M_STEP_COUNTER; |
| if (newState) |
| new_enabled |= M_STEP_COUNTER; |
| found = 1; |
| break; |
| case ID_STEP_DETECTOR: |
| new_enabled &= ~M_STEP_DETECTOR; |
| if (newState) |
| new_enabled |= M_STEP_DETECTOR; |
| found = 1; |
| break; |
| } |
| |
| if (found && (new_enabled != mEnabled)) { |
| err = ioctl(dev_fd, STM401_IOCTL_SET_SENSORS, &new_enabled); |
| ALOGE_IF(err, "Could not change sensor state (%s)", strerror(-err)); |
| if (!err) { |
| mEnabled = new_enabled; |
| } |
| } |
| |
| new_enabled = mWakeEnabled; |
| found = 0; |
| switch (handle) { |
| case ID_D: |
| new_enabled &= ~M_DOCK; |
| if (newState) |
| new_enabled |= M_DOCK; |
| found = 1; |
| break; |
| case ID_P: |
| new_enabled &= ~M_PROXIMITY; |
| if (newState) |
| new_enabled |= M_PROXIMITY; |
| found = 1; |
| break; |
| case ID_FU: |
| new_enabled &= ~M_FLATUP; |
| if (newState) |
| new_enabled |= M_FLATUP; |
| found = 1; |
| break; |
| case ID_FD: |
| new_enabled &= ~M_FLATDOWN; |
| if (newState) |
| new_enabled |= M_FLATDOWN; |
| found = 1; |
| break; |
| case ID_S: |
| new_enabled &= ~M_STOWED; |
| if (newState) |
| new_enabled |= M_STOWED; |
| found = 1; |
| break; |
| case ID_CA: |
| new_enabled &= ~M_CAMERA_ACT; |
| if (newState) |
| new_enabled |= M_CAMERA_ACT; |
| found = 1; |
| break; |
| case ID_NFC: |
| new_enabled &= ~M_NFC; |
| if (newState) |
| new_enabled |= M_NFC; |
| else { |
| FILE *fp; |
| int i; |
| |
| err = ioctl(dev_fd, STM401_IOCTL_GET_MAG_CAL, &mMagCal); |
| if (err < 0) { |
| ALOGE("Can't read Mag Cal data"); |
| } else { |
| if ((fp = fopen(MAG_CAL_FILE, "w")) == NULL) { |
| ALOGE("Can't open Mag Cal file"); |
| } else { |
| for (i=0; i<STM401_MAG_CAL_SIZE; i++) { |
| fputc(mMagCal[i], fp); |
| } |
| fclose(fp); |
| } |
| } |
| } |
| found = 1; |
| break; |
| case ID_SIM: |
| new_enabled &= ~M_SIM; |
| if (newState) |
| new_enabled |= M_SIM; |
| found = 1; |
| break; |
| } |
| |
| if (found && (new_enabled != mWakeEnabled)) { |
| err = ioctl(dev_fd, STM401_IOCTL_SET_WAKESENSORS, &new_enabled); |
| ALOGE_IF(err, "Could not change sensor state (%s)", strerror(-err)); |
| if (!err) { |
| mWakeEnabled = new_enabled; |
| } |
| } |
| |
| return err; |
| } |
| |
| int HubSensor::setDelay(int32_t handle, int64_t ns) |
| { |
| int status = -EINVAL; |
| |
| if (ns < 0) |
| return -EINVAL; |
| |
| unsigned short delay = int64_t(ns) / 1000000; |
| switch (handle) { |
| case ID_A: status = ioctl(dev_fd, STM401_IOCTL_SET_ACC_DELAY, &delay); break; |
| case ID_G: status = ioctl(dev_fd, STM401_IOCTL_SET_GYRO_DELAY, &delay); break; |
| case ID_PR: status = ioctl(dev_fd, STM401_IOCTL_SET_PRES_DELAY, &delay); break; |
| case ID_M: /* Mag and orientation get set together */ |
| case ID_O: status = ioctl(dev_fd, STM401_IOCTL_SET_MAG_DELAY, &delay); break; |
| case ID_T: status = 0; break; |
| case ID_L: status = 0; break; |
| case ID_LA: status = 0; break; |
| case ID_Q: status = 0; break; |
| case ID_GR: status = 0; break; |
| case ID_DR: status = 0; break; |
| case ID_DB: status = 0; break; |
| case ID_D: status = 0; break; |
| case ID_P: status = 0; break; |
| case ID_FU: status = 0; break; |
| case ID_FD: status = 0; break; |
| case ID_S: status = 0; break; |
| case ID_CA: status = 0; break; |
| case ID_NFC: status = 0; break; |
| case ID_SIM: status = 0; break; |
| case ID_UNCALIB_GYRO: status = ioctl(dev_fd, STM401_IOCTL_SET_GYRO_DELAY, &delay); break; |
| case ID_UNCALIB_MAG: status = ioctl(dev_fd, STM401_IOCTL_SET_MAG_DELAY, &delay); break; |
| case ID_STEP_COUNTER: |
| delay /= 1000; // convert to seconds for pedometer rate |
| if (delay == 0) |
| delay = 1; |
| status = ioctl(dev_fd, STM401_IOCTL_SET_STEP_COUNTER_DELAY, &delay); |
| break; |
| case ID_STEP_DETECTOR:status = 0; break; |
| } |
| return status; |
| } |
| |
| int HubSensor::readEvents(sensors_event_t* data, int count) |
| { |
| int numEventReceived = 0; |
| struct stm401_android_sensor_data buff; |
| int ret; |
| char timeBuf[32]; |
| struct tm* ptm = NULL; |
| struct timeval timeutc; |
| static long int sent_bug2go_sec = 0; |
| |
| if (count < 1) |
| return -EINVAL; |
| while (((ret = read(data_fd, &buff, sizeof(struct stm401_android_sensor_data))) != 0) && count) { |
| /* these sensors are not supported, upload a bug2go if its been at least 10mins since previous bug2go*/ |
| /* remove this if-clause when corruption issue resolved */ |
| if (buff.type == DT_PRESSURE || buff.type == DT_TEMP || buff.type == DT_LIN_ACCEL || |
| buff.type == DT_GRAVITY || buff.type == DT_DOCK || buff.type == DT_QUATERNION || |
| buff.type == DT_NFC) { |
| count--; |
| time(&timeutc.tv_sec); |
| if ((sent_bug2go_sec == 0) || |
| (timeutc.tv_sec - sent_bug2go_sec > 60*10)) { |
| // put timestamp in dropbox file |
| ptm = localtime(&(timeutc.tv_sec)); |
| if (ptm != NULL) { |
| strftime(timeBuf, sizeof(timeBuf), "%m-%d %H:%M:%S", ptm); |
| capture_dump(timeBuf, buff.type, SENSORHUB_DUMPFILE, |
| DROPBOX_FLAG_TEXT | DROPBOX_FLAG_GZIP); |
| } |
| sent_bug2go_sec = timeutc.tv_sec; |
| } |
| continue; |
| } |
| |
| switch (buff.type) { |
| case DT_ACCEL: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_A; |
| data->type = SENSOR_TYPE_ACCELEROMETER; |
| data->acceleration.x = STM16TOH(buff.data+ACCEL_X) * CONVERT_A_X; |
| data->acceleration.y = STM16TOH(buff.data+ACCEL_Y) * CONVERT_A_Y; |
| data->acceleration.z = STM16TOH(buff.data+ACCEL_Z) * CONVERT_A_Z; |
| data->acceleration.status = SENSOR_STATUS_ACCURACY_HIGH; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_GYRO: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_G; |
| data->type = SENSOR_TYPE_GYROSCOPE; |
| data->gyro.x = STM16TOH(buff.data + GYRO_X) * CONVERT_G_P; |
| data->gyro.y = STM16TOH(buff.data + GYRO_Y) * CONVERT_G_R; |
| data->gyro.z = STM16TOH(buff.data + GYRO_Z) * CONVERT_G_Y; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_UNCALIB_GYRO: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_UNCALIB_GYRO; |
| data->type = SENSOR_TYPE_GYROSCOPE_UNCALIBRATED; |
| data->uncalibrated_gyro.x_uncalib = STM16TOH(buff.data + UNCALIB_GYRO_X) * CONVERT_G_P; |
| data->uncalibrated_gyro.y_uncalib = STM16TOH(buff.data + UNCALIB_GYRO_Y) * CONVERT_G_R; |
| data->uncalibrated_gyro.z_uncalib = STM16TOH(buff.data + UNCALIB_GYRO_Z) * CONVERT_G_Y; |
| data->uncalibrated_gyro.x_bias = STM16TOH(buff.data + UNCALIB_GYRO_X_BIAS) * CONVERT_BIAS_G_P; |
| data->uncalibrated_gyro.y_bias = STM16TOH(buff.data + UNCALIB_GYRO_Y_BIAS) * CONVERT_BIAS_G_R; |
| data->uncalibrated_gyro.z_bias = STM16TOH(buff.data + UNCALIB_GYRO_Z_BIAS) * CONVERT_BIAS_G_Y; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_UNCALIB_MAG: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_UNCALIB_MAG; |
| data->type = SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED; |
| data->uncalibrated_magnetic.x_uncalib = STM16TOH(buff.data + UNCALIB_MAGNETIC_X) * CONVERT_M_X; |
| data->uncalibrated_magnetic.y_uncalib = STM16TOH(buff.data + UNCALIB_MAGNETIC_Y) * CONVERT_M_Y; |
| data->uncalibrated_magnetic.z_uncalib = STM16TOH(buff.data + UNCALIB_MAGNETIC_Z) * CONVERT_M_Z; |
| data->uncalibrated_magnetic.x_bias = STM16TOH(buff.data + UNCALIB_MAGNETIC_X_BIAS) * CONVERT_BIAS_M_X; |
| data->uncalibrated_magnetic.y_bias = STM16TOH(buff.data + UNCALIB_MAGNETIC_Y_BIAS) * CONVERT_BIAS_M_Y; |
| data->uncalibrated_magnetic.z_bias = STM16TOH(buff.data + UNCALIB_MAGNETIC_Z_BIAS) * CONVERT_BIAS_M_Z; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_STEP_COUNTER: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_STEP_COUNTER; |
| data->type = SENSOR_TYPE_STEP_COUNTER; |
| data->u64.step_counter = ( |
| (((uint64_t)STM16TOH(buff.data + STEP_COUNTER_3)) << 48) | |
| (((uint64_t)STM16TOH(buff.data + STEP_COUNTER_2)) << 32) | |
| (((uint64_t)STM16TOH(buff.data + STEP_COUNTER_1)) << 16) | |
| (((uint64_t)STM16TOH(buff.data + STEP_COUNTER_0))) ); |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_STEP_DETECTOR: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_STEP_DETECTOR; |
| data->type = SENSOR_TYPE_STEP_DETECTOR; |
| data->data[0] = STM16TOH(buff.data + STEP_DETECTOR); |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_PRESSURE: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_PR; |
| data->type = SENSOR_TYPE_PRESSURE; |
| data->pressure = STM32TOH(buff.data + PRESSURE_PRESSURE) * CONVERT_B; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_MAG: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_M; |
| data->type = SENSOR_TYPE_MAGNETIC_FIELD; |
| data->magnetic.x = STM16TOH(buff.data + MAGNETIC_X) * CONVERT_M_X; |
| data->magnetic.y = STM16TOH(buff.data + MAGNETIC_Y) * CONVERT_M_Y; |
| data->magnetic.z = STM16TOH(buff.data + MAGNETIC_Z) * CONVERT_M_Z; |
| data->magnetic.status = buff.status; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_ORIENT: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_O; |
| data->type = SENSOR_TYPE_ORIENTATION; |
| data->orientation.azimuth = STM16TOH(buff.data + ORIENTATION_AZIMUTH) * CONVERT_O_Y; |
| data->orientation.pitch = STM16TOH(buff.data + ORIENTATION_PITCH) * CONVERT_O_P; |
| // Roll value needs to be negated. |
| data->orientation.roll = -STM16TOH(buff.data + ORIENTATION_ROLL) * CONVERT_O_R; |
| data->orientation.status = buff.status; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_TEMP: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_T; |
| data->type = SENSOR_TYPE_TEMPERATURE; |
| data->temperature = STM16TOH(buff.data + TEMPERATURE_TEMPERATURE) * CONVERT_T; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_ALS: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_L; |
| data->type = SENSOR_TYPE_LIGHT; |
| data->light = (uint16_t)STM16TOH(buff.data + LIGHT_LIGHT); |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_LIN_ACCEL: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_LA; |
| data->type = SENSOR_TYPE_LINEAR_ACCELERATION; |
| data->acceleration.x = STM16TOH(buff.data + ACCEL_X) * CONVERT_A_LIN; |
| data->acceleration.y = STM16TOH(buff.data + ACCEL_Y) * CONVERT_A_LIN; |
| data->acceleration.z = STM16TOH(buff.data + ACCEL_Z) * CONVERT_A_LIN; |
| data->acceleration.status = SENSOR_STATUS_ACCURACY_HIGH; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_QUATERNION: |
| break; |
| case DT_GRAVITY: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_GR; |
| data->type = SENSOR_TYPE_GRAVITY; |
| data->acceleration.x = STM16TOH(buff.data + ACCEL_X) * CONVERT_A_GRAV; |
| data->acceleration.y = STM16TOH(buff.data + ACCEL_Y) * CONVERT_A_GRAV; |
| data->acceleration.z = STM16TOH(buff.data + ACCEL_Z) * CONVERT_A_GRAV; |
| data->acceleration.status = SENSOR_STATUS_ACCURACY_HIGH; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_DISP_ROTATE: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_DR; |
| data->type = SENSOR_TYPE_DISPLAY_ROTATE; |
| if (buff.data[ROTATE_ROTATE] == DISP_FLAT) |
| data->data[0] = DISP_UNKNOWN; |
| else |
| data->data[0] = buff.data[ROTATE_ROTATE]; |
| |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_DISP_BRIGHT: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_DB; |
| data->type = SENSOR_TYPE_DISPLAY_BRIGHTNESS; |
| data->data[0] = buff.data[BRIGHT_BRIGHT]; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_DOCK: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_D; |
| data->type = SENSOR_TYPE_DOCK; |
| data->data[0] = buff.data[DOCK_DOCK]; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_PROX: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_P; |
| data->type = SENSOR_TYPE_PROXIMITY; |
| if (buff.data[PROXIMITY_PROXIMITY] == 0) { |
| data->distance = PROX_UNCOVERED; |
| ALOGE("Proximity uncovered"); |
| } else if (buff.data[PROXIMITY_PROXIMITY] == 1) { |
| data->distance = PROX_COVERED; |
| ALOGE("Proximity covered 1"); |
| } else { |
| data->distance = PROX_SATURATED; |
| ALOGE("Proximity covered 2"); |
| } |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_FLAT_UP: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_FU; |
| data->type = SENSOR_TYPE_FLAT_UP; |
| if (buff.data[FLAT_FLAT] == 0x01) |
| data->data[0] = FLAT_DETECTED; |
| else |
| data->data[0] = FLAT_NOTDETECTED; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_FLAT_DOWN: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_FD; |
| data->type = SENSOR_TYPE_FLAT_DOWN; |
| if (buff.data[FLAT_FLAT] == 0x02) |
| data->data[0] = FLAT_DETECTED; |
| else |
| data->data[0] = FLAT_NOTDETECTED; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_STOWED: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_S; |
| data->type = SENSOR_TYPE_STOWED; |
| data->data[0] = buff.data[STOWED_STOWED]; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_CAMERA_ACT: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_CA; |
| data->type = SENSOR_TYPE_CAMERA_ACTIVATE; |
| data->data[0] = STM401_CAMERA_DATA; |
| data->data[1] = STM16TOH(buff.data + CAMERA_CAMERA); |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_NFC: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_NFC; |
| data->type = SENSOR_TYPE_NFC_DETECT; |
| data->data[0] = buff.data[NFC_NFC]; |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| break; |
| case DT_SIM: |
| data->version = SENSORS_EVENT_T_SIZE; |
| data->sensor = ID_SIM; |
| data->type = SENSOR_TYPE_SIGNIFICANT_MOTION; |
| data->data[0] = STM16TOH(buff.data + SIM); |
| data->timestamp = buff.timestamp; |
| data++; |
| count--; |
| numEventReceived++; |
| enable(ID_SIM, 0); |
| break; |
| case DT_RESET: |
| count--; |
| // put timestamp in dropbox file |
| time(&timeutc.tv_sec); |
| ptm = localtime(&(timeutc.tv_sec)); |
| if (ptm != NULL) { |
| strftime(timeBuf, sizeof(timeBuf), "%m-%d %H:%M:%S", ptm); |
| capture_dump(timeBuf, buff.data[0], SENSORHUB_DUMPFILE, |
| DROPBOX_FLAG_TEXT | DROPBOX_FLAG_GZIP); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| |
| return numEventReceived; |
| } |
| |
| gzFile HubSensor::open_dropbox_file(const char* timestamp, const char* dst, const int flags) |
| { |
| char dropbox_path[128]; |
| pid_t pid = getpid(); |
| |
| snprintf(dropbox_path, sizeof(dropbox_path), "%s/%s:%d:%u-%s", |
| DROPBOX_DIR, DROPBOX_TAG, flags, pid, timestamp); |
| ALOGD("stm401 - dumping to dropbox file[%s]...\n", dropbox_path); |
| |
| return gzopen(dropbox_path, "wb"); |
| } |
| |
| short HubSensor::capture_dump(char* timestamp, const int id, const char* dst, const int flags) |
| { |
| char buffer[COPYSIZE] = {0}; |
| int rc = 0; |
| gzFile dropbox_file = NULL; |
| |
| dropbox_file = open_dropbox_file(timestamp, dst, flags); |
| if(dropbox_file == NULL) { |
| ALOGE("ERROR! unable to open dropbox file[errno:%d(%s)]\n", errno, strerror(errno)); |
| } else { |
| // put timestamp in dropbox file |
| rc = snprintf(buffer, COPYSIZE, "timestamp:%s\n", timestamp); |
| gzwrite(dropbox_file, buffer, rc); |
| rc = snprintf(buffer, COPYSIZE, "reason:%02d\n", id); |
| gzwrite(dropbox_file, buffer, rc); |
| gzclose(dropbox_file); |
| // to commit buffer cache to disk |
| sync(); |
| } |
| |
| return 0; |
| } |
