diff options
Diffstat (limited to 'libsensors')
61 files changed, 2395 insertions, 6618 deletions
diff --git a/libsensors/AccelSensor.cpp b/libsensors/AccelSensor.cpp new file mode 100644 index 0000000..1a5510c --- /dev/null +++ b/libsensors/AccelSensor.cpp @@ -0,0 +1,168 @@ +/* + * 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 <stdlib.h> +#include <dirent.h> +#include <sys/select.h> +#include <linux/ioctl.h> +#include <linux/types.h> +#include <linux/uinput.h> +#include <cutils/log.h> +#include <cstring> + + +#include "AccelSensor.h" + +#define LOGTAG "AccelerometerSensor" + +// ioctls +#define LSM330DLC_ACCEL_IOCTL_BASE 'a' +#define LSM330DLC_ACCEL_IOCTL_SET_ENABLE \ + _IOW(LSM330DLC_ACCEL_IOCTL_BASE, 9, int) + + +/*****************************************************************************/ +AccelSensor::AccelSensor() + : SensorBase("/dev/acceleration", "accelerometer_sensor"), + mEnabled(0), + mInputReader(4), + mHasPendingEvent(false) +{ + + mPendingEvent.version = sizeof(sensors_event_t); + mPendingEvent.sensor = ID_A; + mPendingEvent.type = SENSOR_TYPE_ACCELEROMETER; + memset(mPendingEvent.data, 0, sizeof(mPendingEvent.data)); + + if (data_fd) { + strcpy(input_sysfs_path, "/sys/class/input/"); + strcat(input_sysfs_path, input_name); + strcat(input_sysfs_path, "/device/"); + input_sysfs_path_len = strlen(input_sysfs_path); + } +} + +AccelSensor::~AccelSensor() { + + // ALOGD("AccelSensor::~AccelSensor()"); + if (mEnabled) { + enable(0, 0); + } +} + +int AccelSensor::setInitialState() { + return 0; +} + +int AccelSensor::enable(int32_t handle, int en) { + int flags = en ? 1 : 0; + int fd; + if (flags != mEnabled) { + strcpy(&input_sysfs_path[input_sysfs_path_len], "enable"); + fd = open(input_sysfs_path, O_RDWR); + if (fd >= 0) { + write(fd, en == 1 ? "1" : "0", 2); + close(fd); + mEnabled = flags; + setInitialState(); + return 0; + } + return -1; + } + return 0; +} + + +bool AccelSensor::hasPendingEvents() const { + /* FIXME probably here should be returning mEnabled but instead + mHasPendingEvents. It does not work, so we cheat.*/ + //ALOGD("AccelSensor::~hasPendingEvents %d", mHasPendingEvent ? 1 : 0 ); + return mHasPendingEvent; +} + + +int AccelSensor::setDelay(int32_t handle, int64_t ns) +{ + int fd; + + if (ns < 10000000) { + ns = 10000000; // Minimum on stock + } + + strcpy(&input_sysfs_path[input_sysfs_path_len], "acc_poll_delay"); + fd = open(input_sysfs_path, O_RDWR); + if (fd >= 0) { + char buf[80]; + sprintf(buf, "%lld", ns / 10000000 * 10); // Some flooring to match stock value + write(fd, buf, strlen(buf)+1); + close(fd); + return 0; + } + return -1; +} + + +int AccelSensor::readEvents(sensors_event_t* data, int count) +{ + if (count < 1) + return -EINVAL; + + if (mHasPendingEvent) { + mHasPendingEvent = false; + mPendingEvent.timestamp = getTimestamp(); + *data = mPendingEvent; + return mEnabled ? 1 : 0; + } + + ssize_t n = mInputReader.fill(data_fd); + if (n < 0) + return n; + int numEventReceived = 0; + input_event const* event; + + while (count && mInputReader.readEvent(&event)) { + int type = event->type; + if (type == EV_REL) { + float value = event->value; + if (event->code == EVENT_TYPE_ACCEL_X) { + mPendingEvent.acceleration.x = value * CONVERT_A_X; + } else if (event->code == EVENT_TYPE_ACCEL_Y) { + mPendingEvent.acceleration.y = value * CONVERT_A_Y; + } else if (event->code == EVENT_TYPE_ACCEL_Z) { + mPendingEvent.acceleration.z = value * CONVERT_A_Z; + } + } else if (type == EV_SYN) { + mPendingEvent.timestamp = timevalToNano(event->time); + if (mEnabled) { + *data++ = mPendingEvent; + count--; + numEventReceived++; + } + } else { + ALOGE("%s: unknown event (type=%d, code=%d)", LOGTAG, + type, event->code); + } + + mInputReader.next(); + } + return numEventReceived++; + +} diff --git a/libsensors/AccelSensor.h b/libsensors/AccelSensor.h new file mode 100644 index 0000000..09508e9 --- /dev/null +++ b/libsensors/AccelSensor.h @@ -0,0 +1,72 @@ +/* + * 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. + */ + +#ifndef ANDROID_SMB380_SENSOR_H +#define ANDROID_SMB380_SENSOR_H + +#include <stdint.h> +#include <errno.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +#include "sensors.h" +#include "SensorBase.h" +#include "InputEventReader.h" + +/*****************************************************************************/ + + +struct smb380acc_t { + short x, /**< holds x-axis acceleration data sign extended. Range -512 to 511. */ + y, /**< holds y-axis acceleration data sign extended. Range -512 to 511. */ + z; /**< holds z-axis acceleration data sign extended. Range -512 to 511. */ +} ; + +/* smb ioctl command label */ +#define IOCTL_SMB_GET_ACC_VALUE 0 +#define DCM_IOC_MAGIC 's' +#define IOC_SET_ACCELEROMETER _IO (DCM_IOC_MAGIC, 0x64) +#define BMA150_CALIBRATION _IOWR(DCM_IOC_MAGIC,48,short) + +#define SMB_POWER_OFF 0 +#define SMB_POWER_ON 1 + +struct input_event; + +class AccelSensor : public SensorBase { + int mEnabled; + InputEventCircularReader mInputReader; + sensors_event_t mPendingEvent; + bool mHasPendingEvent; + char input_sysfs_path[PATH_MAX]; + int input_sysfs_path_len; +// int mUinputDevice; + + int setInitialState(); + +public: + AccelSensor(); + virtual ~AccelSensor(); +// virtual int createUinput(); + virtual int readEvents(sensors_event_t* data, int count); + virtual bool hasPendingEvents() const; + virtual int setDelay(int32_t handle, int64_t ns); + virtual int enable(int32_t handle, int enabled); +}; + +/*****************************************************************************/ + +#endif // ANDROID_GYRO_SENSOR_H diff --git a/libsensors/AkmSensor.cpp b/libsensors/AkmSensor.cpp new file mode 100644 index 0000000..e7e0a4b --- /dev/null +++ b/libsensors/AkmSensor.cpp @@ -0,0 +1,281 @@ +/* + * 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 <cstring> + +#include "ak8973b.h" + +#include <cutils/log.h> +#include "AkmSensor.h" + + +/*****************************************************************************/ + +int (*akm_is_sensor_enabled)(uint32_t sensor_type); +int (*akm_enable_sensor)(uint32_t sensor_type); +int (*akm_disable_sensor)(uint32_t sensor_type); +int (*akm_set_delay)(uint32_t sensor_type, uint64_t delay); + +int stub_is_sensor_enabled(uint32_t sensor_type) { + return 0; +} + +int stub_enable_disable_sensor(uint32_t sensor_type) { + return -ENODEV; +} + +int stub_set_delay(uint32_t sensor_type, uint64_t delay) { + return -ENODEV; +} + +AkmSensor::AkmSensor() +: SensorBase(NULL, NULL), + mEnabled(0), + mPendingMask(0), + mInputReader(32) +{ + /* Open the library before opening the input device. The library + * creates a uinput device. + */ + if (loadAKMLibrary() == 0) { + data_name = "compass_sensor"; + data_fd = openInput("compass_sensor"); + } + + memset(mPendingEvents, 0, sizeof(mPendingEvents)); + + mPendingEvents[Accelerometer].version = sizeof(sensors_event_t); + mPendingEvents[Accelerometer].sensor = ID_A; + mPendingEvents[Accelerometer].type = SENSOR_TYPE_ACCELEROMETER; + mPendingEvents[Accelerometer].acceleration.status = SENSOR_STATUS_UNRELIABLE; + + mPendingEvents[MagneticField].version = sizeof(sensors_event_t); + mPendingEvents[MagneticField].sensor = ID_M; + mPendingEvents[MagneticField].type = SENSOR_TYPE_MAGNETIC_FIELD; + mPendingEvents[MagneticField].magnetic.status = SENSOR_STATUS_UNRELIABLE; + + // read the actual value of all sensors if they're enabled already + struct input_absinfo absinfo; + short flags = 0; + + if (akm_is_sensor_enabled(SENSOR_TYPE_ACCELEROMETER)) { + mEnabled |= 1<<Accelerometer; + if (!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_ACCEL_X), &absinfo)) { + mPendingEvents[Accelerometer].acceleration.x = absinfo.value * CONVERT_A_X; + } + if (!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_ACCEL_Y), &absinfo)) { + mPendingEvents[Accelerometer].acceleration.y = absinfo.value * CONVERT_A_Y; + } + if (!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_ACCEL_Z), &absinfo)) { + mPendingEvents[Accelerometer].acceleration.z = absinfo.value * CONVERT_A_Z; + } + } + if (akm_is_sensor_enabled(SENSOR_TYPE_MAGNETIC_FIELD)) { + mEnabled |= 1<<MagneticField; + if (!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_MAGV_X), &absinfo)) { + mPendingEvents[MagneticField].magnetic.x = absinfo.value * CONVERT_M_X; + } + if (!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_MAGV_Y), &absinfo)) { + mPendingEvents[MagneticField].magnetic.y = absinfo.value * CONVERT_M_Y; + } + if (!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_MAGV_Z), &absinfo)) { + mPendingEvents[MagneticField].magnetic.z = absinfo.value * CONVERT_M_Z; + } + } + + // disable temperature sensor, since it is not supported + akm_disable_sensor(SENSOR_TYPE_TEMPERATURE); +} + +AkmSensor::~AkmSensor() +{ + if (mLibAKM) { + unsigned ref = ::dlclose(mLibAKM); + } +} + +int AkmSensor::enable(int32_t handle, int en) +{ + int what = -1; + + switch (handle) { + case ID_A: what = Accelerometer; break; + case ID_M: what = MagneticField; break; + } + + if (uint32_t(what) >= numSensors) + return -EINVAL; + + int newState = en ? 1 : 0; + int err = 0; + + if ((uint32_t(newState)<<what) != (mEnabled & (1<<what))) { + uint32_t sensor_type; + switch (what) { + case MagneticField: sensor_type = SENSOR_TYPE_MAGNETIC_FIELD; break; + } + short flags = newState; + if (en) + err = akm_enable_sensor(sensor_type); + else + err = akm_disable_sensor(sensor_type); + + ALOGE_IF(err, "Could not change sensor state (%s)", strerror(-err)); + if (!err) { + mEnabled &= ~(1<<what); + mEnabled |= (uint32_t(flags)<<what); + } + } + return err; +} + +int AkmSensor::setDelay(int32_t handle, int64_t ns) +{ + int what = -1; + uint32_t sensor_type = 0; + + if (ns < 0) + return -EINVAL; + + switch (handle) { + case ID_A: sensor_type = SENSOR_TYPE_ACCELEROMETER; break; + case ID_M: sensor_type = SENSOR_TYPE_MAGNETIC_FIELD; break; + } + + if (sensor_type == 0) + return -EINVAL; + + mDelays[what] = ns; + return update_delay(); +} + +int AkmSensor::update_delay() +{ + if (mEnabled) { + uint64_t wanted = -1LLU; + for (int i=0 ; i<numSensors ; i++) { + if (mEnabled & (1<<i)) { + uint64_t ns = mDelays[i]; + wanted = wanted < ns ? wanted : ns; + } + } + short delay = int64_t(wanted) / 1000000; + if (ioctl(dev_fd, ECS_IOCTL_APP_SET_DELAY, &delay)) { + return -errno; + } + } + return 0; +} + + +int AkmSensor::loadAKMLibrary() +{ + mLibAKM = dlopen("libakm.so", RTLD_NOW); + + if (!mLibAKM) { + akm_is_sensor_enabled = stub_is_sensor_enabled; + akm_enable_sensor = stub_enable_disable_sensor; + akm_disable_sensor = stub_enable_disable_sensor; + akm_set_delay = stub_set_delay; + ALOGE("AkmSensor: unable to load AKM Library, %s", dlerror()); + return -ENOENT; + } + + *(void **)&akm_is_sensor_enabled = dlsym(mLibAKM, "akm_is_sensor_enabled"); + *(void **)&akm_enable_sensor = dlsym(mLibAKM, "akm_enable_sensor"); + *(void **)&akm_disable_sensor = dlsym(mLibAKM, "akm_disable_sensor"); + *(void **)&akm_set_delay = dlsym(mLibAKM, "akm_set_delay"); + + return 0; +} + +int AkmSensor::readEvents(sensors_event_t* data, int count) +{ + if (count < 1) + return -EINVAL; + + ssize_t n = mInputReader.fill(data_fd); + if (n < 0) + return n; + + int numEventReceived = 0; + input_event const* event; + + while (count && mInputReader.readEvent(&event)) { + int type = event->type; + if (type == EV_REL) { + processEvent(event->code, event->value); + mInputReader.next(); + } else if (type == EV_SYN) { + int64_t time = timevalToNano(event->time); + for (int j=0 ; count && mPendingMask && j<numSensors ; j++) { + if (mPendingMask & (1<<j)) { + mPendingMask &= ~(1<<j); + mPendingEvents[j].timestamp = time; + if (mEnabled & (1<<j)) { + *data++ = mPendingEvents[j]; + count--; + numEventReceived++; + } + } + } + if (!mPendingMask) { + mInputReader.next(); + } + } else { + ALOGE("AkmSensor: unknown event (type=%d, code=%d)", + type, event->code); + mInputReader.next(); + } + } + return numEventReceived; +} + +void AkmSensor::processEvent(int code, int value) +{ + switch (code) { + case EVENT_TYPE_MAGV_X: + ALOGV("AkmSensor: MAGV_X =>%d", value); + mPendingMask |= 1<<MagneticField; + mPendingEvents[MagneticField].magnetic.x = (float)value * CONVERT_M_X; + break; + case EVENT_TYPE_MAGV_Y: + ALOGV("AkmSensor: MAGV_Y =>%d", value); + mPendingMask |= 1<<MagneticField; + mPendingEvents[MagneticField].magnetic.y = (float)value * CONVERT_M_Y; + break; + case EVENT_TYPE_MAGV_Z: + ALOGV("AkmSensor: MAGV_Z =>%d", value); + mPendingMask |= 1<<MagneticField; + mPendingEvents[MagneticField].magnetic.z = (float)value * CONVERT_M_Z; + break; + case EVENT_TYPE_MAGV_ACC: + ALOGV("AkmSensor: MAGV_ACC=>%d", value); + mPendingMask |= 1<<MagneticField; + mPendingEvents[MagneticField].magnetic.status = value; + default: + ALOGV("AkmSensor: unkown REL event code=%d, value=%d", code, value); + break; + } +} diff --git a/libsensors/AkmSensor.h b/libsensors/AkmSensor.h new file mode 100644 index 0000000..8df3930 --- /dev/null +++ b/libsensors/AkmSensor.h @@ -0,0 +1,63 @@ +/* + * 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. + */ + +#ifndef ANDROID_AKM_SENSOR_H +#define ANDROID_AKM_SENSOR_H + +#include <stdint.h> +#include <errno.h> +#include <sys/cdefs.h> +#include <sys/types.h> + + +#include "sensors.h" +#include "SensorBase.h" +#include "InputEventReader.h" + +/*****************************************************************************/ + +struct input_event; + +class AkmSensor : public SensorBase { +public: + AkmSensor(); + virtual ~AkmSensor(); + + enum { + Accelerometer = 0, + MagneticField = 1, + numSensors + }; + + virtual int setDelay(int32_t handle, int64_t ns); + virtual int enable(int32_t handle, int enabled); + virtual int readEvents(sensors_event_t* data, int count); + void processEvent(int code, int value); + +private: + int loadAKMLibrary(); + int update_delay(); + void *mLibAKM; + uint32_t mEnabled; + uint32_t mPendingMask; + InputEventCircularReader mInputReader; + sensors_event_t mPendingEvents[numSensors]; + uint64_t mDelays[numSensors]; +}; + +/*****************************************************************************/ + +#endif // ANDROID_AKM_SENSOR_H diff --git a/libsensors/Android.mk b/libsensors/Android.mk index 8bdcd66..636ad9d 100644 --- a/libsensors/Android.mk +++ b/libsensors/Android.mk @@ -1,49 +1,47 @@ -# Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr> +# Copyright (C) 2008 The Android Open Source Project # -# This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. +# 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 # -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. +# http://www.apache.org/licenses/LICENSE-2.0 # -# You should have received a copy of the GNU General Public License -# along with this program. If not, see <http://www.gnu.org/licenses/>. -ifeq ($(BOARD_USES_OPENSOURCE_SENSORS),true) +# 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. + + LOCAL_PATH := $(call my-dir) -include $(CLEAR_VARS) +ifneq ($(TARGET_SIMULATOR),true) -LOCAL_SRC_FILES := \ - smdk4x12_sensors.c \ - input.c \ - akm8975.c \ - akmdfs/AKFS_APIs_8975/AKFS_AK8975.c \ - akmdfs/AKFS_APIs_8975/AKFS_AOC.c \ - akmdfs/AKFS_APIs_8975/AKFS_Device.c \ - akmdfs/AKFS_APIs_8975/AKFS_Direction.c \ - akmdfs/AKFS_APIs_8975/AKFS_VNorm.c \ - akmdfs/AKFS_FileIO.c \ - cm36651_proximity.c \ - cm36651_light.c \ - lsm330dlc_acceleration.c \ - lsm330dlc_gyroscope.c \ - lps331ap.c - -LOCAL_C_INCLUDES := \ - $(LOCAL_PATH)/akmdfs \ - $(LOCAL_PATH)/akmdfs/AKFS_APIs_8975 \ - $(LOCAL_PATH) - -LOCAL_SHARED_LIBRARIES := libutils libcutils liblog libhardware -LOCAL_PRELINK_MODULE := false +# HAL module implemenation, not prelinked, and stored in +# hw/<SENSORS_HARDWARE_MODULE_ID>.<ro.product.board>.so +include $(CLEAR_VARS) LOCAL_MODULE := sensors.$(TARGET_BOOTLOADER_BOARD_NAME) + LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw + LOCAL_MODULE_TAGS := optional +LOCAL_CFLAGS := -DLOG_TAG=\"sensorscpp\" +LOCAL_SRC_FILES := \ + sensors.cpp \ + SensorBase.cpp \ + LightSensor.cpp \ + ProximitySensor.cpp \ + AkmSensor.cpp \ + GyroSensor.cpp \ + InputEventReader.cpp \ + AccelSensor.cpp \ + PressureSensor.cpp + +LOCAL_SHARED_LIBRARIES := liblog libcutils libdl +LOCAL_PRELINK_MODULE := false + include $(BUILD_SHARED_LIBRARY) -endif + +endif # !TARGET_SIMULATOR diff --git a/libsensors/GyroSensor.cpp b/libsensors/GyroSensor.cpp new file mode 100644 index 0000000..ceb7d9c --- /dev/null +++ b/libsensors/GyroSensor.cpp @@ -0,0 +1,181 @@ +/* + * 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 <cutils/log.h> +#include <cstring> + +#include "GyroSensor.h" + +#define LOGTAG "GyroSensor" + +#define FETCH_FULL_EVENT_BEFORE_RETURN 1 +#define IGNORE_EVENT_TIME 350000000 +/*****************************************************************************/ + +GyroSensor::GyroSensor() + : SensorBase(NULL, "gyro_sensor"), + mEnabled(0), + mInputReader(4), + mHasPendingEvent(false), + mEnabledTime(0) +{ + mPendingEvent.version = sizeof(sensors_event_t); + mPendingEvent.sensor = ID_GY; + mPendingEvent.type = SENSOR_TYPE_GYROSCOPE; + memset(mPendingEvent.data, 0, sizeof(mPendingEvent.data)); + + if (data_fd) { + strcpy(input_sysfs_path, "/sys/class/input/"); + strcat(input_sysfs_path, input_name); + strcat(input_sysfs_path, "/device/"); + input_sysfs_path_len = strlen(input_sysfs_path); + enable(0, 1); + } +} + +GyroSensor::~GyroSensor() { + if (mEnabled) { + enable(0, 0); + } +} + +int GyroSensor::setInitialState() { + struct input_absinfo absinfo_x; + struct input_absinfo absinfo_y; + struct input_absinfo absinfo_z; + float value; + if (!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_GYRO_X), &absinfo_x) && + !ioctl(data_fd, EVIOCGABS(EVENT_TYPE_GYRO_X), &absinfo_y) && + !ioctl(data_fd, EVIOCGABS(EVENT_TYPE_GYRO_X), &absinfo_z)) { + value = absinfo_x.value; + mPendingEvent.data[0] = value * CONVERT_GYRO_X; + value = absinfo_x.value; + mPendingEvent.data[1] = value * CONVERT_GYRO_Y; + value = absinfo_x.value; + mPendingEvent.data[2] = value * CONVERT_GYRO_Z; + mHasPendingEvent = true; + } + return 0; +} + +int GyroSensor::enable(int32_t handle, int en) { + int flags = en ? 1 : 0; + int fd; + if (flags != mEnabled) { + strcpy(&input_sysfs_path[input_sysfs_path_len], "enable"); + fd = open(input_sysfs_path, O_RDWR); + if (fd >= 0){ + write(fd, en == 1 ? "1" : "0", 2); + close(fd); + mEnabled = flags; + setInitialState(); + + return 0; + } + return -1; + } + return 0; +} + +bool GyroSensor::hasPendingEvents() const { + return mHasPendingEvent; +} + +int GyroSensor::setDelay(int32_t handle, int64_t ns) +{ + int fd; + + strcpy(&input_sysfs_path[input_sysfs_path_len], "poll_delay"); + fd = open(input_sysfs_path, O_RDWR); + if (fd >= 0) { + char buf[80]; + sprintf(buf, "%lld", ns); + write(fd, buf, strlen(buf)+1); + close(fd); + return 0; + } + return -1; +} + +int GyroSensor::readEvents(sensors_event_t* data, int count) +{ + if (count < 1) + return -EINVAL; + + if (mHasPendingEvent) { + mHasPendingEvent = false; + mPendingEvent.timestamp = getTimestamp(); + *data = mPendingEvent; + return mEnabled ? 1 : 0; + } + + ssize_t n = mInputReader.fill(data_fd); + if (n < 0) + return n; + + int numEventReceived = 0; + input_event const* event; + +#if FETCH_FULL_EVENT_BEFORE_RETURN +again: +#endif + while (count && mInputReader.readEvent(&event)) { + int type = event->type; + if (type == EV_REL) { + float value = event->value; + if (event->code == EVENT_TYPE_GYRO_X) { + mPendingEvent.data[0] = value * CONVERT_GYRO_X; + } else if (event->code == EVENT_TYPE_GYRO_Y) { + mPendingEvent.data[1] = value * CONVERT_GYRO_Y; + } else if (event->code == EVENT_TYPE_GYRO_Z) { + mPendingEvent.data[2] = value * CONVERT_GYRO_Z; + } + } else if (type == EV_SYN) { + mPendingEvent.timestamp = timevalToNano(event->time); + if (mEnabled) { + if (mPendingEvent.timestamp >= mEnabledTime) { + *data++ = mPendingEvent; + numEventReceived++; + } + count--; + } + } else { + ALOGE("%s: unknown event (type=%d, code=%d)", LOGTAG, + type, event->code); + } + mInputReader.next(); + } + +#if FETCH_FULL_EVENT_BEFORE_RETURN + /* if we didn't read a complete event, see if we can fill and + try again instead of returning with nothing and redoing poll. */ + if (numEventReceived == 0 && mEnabled == 1) { + n = mInputReader.fill(data_fd); + if (n) + goto again; + } +#endif + + return numEventReceived; +} + diff --git a/libsensors/GyroSensor.h b/libsensors/GyroSensor.h new file mode 100644 index 0000000..e8997de --- /dev/null +++ b/libsensors/GyroSensor.h @@ -0,0 +1,55 @@ +/* + * 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. + */ + +#ifndef ANDROID_GYRO_SENSOR_H +#define ANDROID_GYRO_SENSOR_H + +#include <stdint.h> +#include <errno.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +#include "sensors.h" +#include "SensorBase.h" +#include "InputEventReader.h" + +/*****************************************************************************/ + +struct input_event; + +class GyroSensor : public SensorBase { + int mEnabled; + InputEventCircularReader mInputReader; + sensors_event_t mPendingEvent; + bool mHasPendingEvent; + char input_sysfs_path[PATH_MAX]; + int input_sysfs_path_len; + int64_t mEnabledTime; + + int setInitialState(); + +public: + GyroSensor(); + virtual ~GyroSensor(); + virtual int readEvents(sensors_event_t* data, int count); + virtual bool hasPendingEvents() const; + virtual int setDelay(int32_t handle, int64_t ns); + virtual int enable(int32_t handle, int enabled); +}; + +/*****************************************************************************/ + +#endif // ANDROID_GYRO_SENSOR_H diff --git a/libsensors/InputEventReader.cpp b/libsensors/InputEventReader.cpp new file mode 100644 index 0000000..ab23a22 --- /dev/null +++ b/libsensors/InputEventReader.cpp @@ -0,0 +1,89 @@ +/* + * 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 <stdint.h> +#include <errno.h> +#include <unistd.h> +#include <poll.h> + +#include <sys/cdefs.h> +#include <sys/types.h> +#include <cstring> + +#include <linux/input.h> + +#include <cutils/log.h> + +#include "InputEventReader.h" + +/*****************************************************************************/ + +struct input_event; + +InputEventCircularReader::InputEventCircularReader(size_t numEvents) + : mBuffer(new input_event[numEvents * 2]), + mBufferEnd(mBuffer + numEvents), + mHead(mBuffer), + mCurr(mBuffer), + mFreeSpace(numEvents) +{ +} + +InputEventCircularReader::~InputEventCircularReader() +{ + delete [] mBuffer; +} + +ssize_t InputEventCircularReader::fill(int fd) +{ + size_t numEventsRead = 0; + if (mFreeSpace) { + const ssize_t nread = read(fd, mHead, mFreeSpace * sizeof(input_event)); + if (nread<0 || nread % sizeof(input_event)) { + // we got a partial event!! + return nread<0 ? -errno : -EINVAL; + } + + numEventsRead = nread / sizeof(input_event); + if (numEventsRead) { + mHead += numEventsRead; + mFreeSpace -= numEventsRead; + if (mHead > mBufferEnd) { + size_t s = mHead - mBufferEnd; + memcpy(mBuffer, mBufferEnd, s * sizeof(input_event)); + mHead = mBuffer + s; + } + } + } + + return numEventsRead; +} + +ssize_t InputEventCircularReader::readEvent(input_event const** events) +{ + *events = mCurr; + ssize_t available = (mBufferEnd - mBuffer) - mFreeSpace; + return available ? 1 : 0; +} + +void InputEventCircularReader::next() +{ + mCurr++; + mFreeSpace++; + if (mCurr >= mBufferEnd) { + mCurr = mBuffer; + } +} diff --git a/libsensors/InputEventReader.h b/libsensors/InputEventReader.h new file mode 100644 index 0000000..180aade --- /dev/null +++ b/libsensors/InputEventReader.h @@ -0,0 +1,47 @@ +/* + * 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. + */ + +#ifndef ANDROID_INPUT_EVENT_READER_H +#define ANDROID_INPUT_EVENT_READER_H + +#include <stdint.h> +#include <errno.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +/*****************************************************************************/ + +struct input_event; + +class InputEventCircularReader +{ + struct input_event* const mBuffer; + struct input_event* const mBufferEnd; + struct input_event* mHead; + struct input_event* mCurr; + ssize_t mFreeSpace; + +public: + InputEventCircularReader(size_t numEvents); + ~InputEventCircularReader(); + ssize_t fill(int fd); + ssize_t readEvent(input_event const** events); + void next(); +}; + +/*****************************************************************************/ + +#endif // ANDROID_INPUT_EVENT_READER_H diff --git a/libsensors/LightSensor.cpp b/libsensors/LightSensor.cpp new file mode 100644 index 0000000..405348f --- /dev/null +++ b/libsensors/LightSensor.cpp @@ -0,0 +1,152 @@ +/* + * 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 <cstring> + +#include <cutils/log.h> + +#include "LightSensor.h" + +#define LOGTAG "LightSensor" + +// #define ALOG_NDEBUG 0 + +/*****************************************************************************/ + +LightSensor::LightSensor() + : SensorBase(NULL, "light_sensor"), + mEnabled(0), + mInputReader(4), + mHasPendingEvent(false) +{ + mPendingEvent.version = sizeof(sensors_event_t); + mPendingEvent.sensor = ID_L; + mPendingEvent.type = SENSOR_TYPE_LIGHT; + memset(mPendingEvent.data, 0, sizeof(mPendingEvent.data)); + + if (data_fd) { + strcpy(input_sysfs_path, "/sys/class/input/"); + strcat(input_sysfs_path, input_name); + strcat(input_sysfs_path, "/device/"); + input_sysfs_path_len = strlen(input_sysfs_path); + enable(0, 1); + } +} + +LightSensor::~LightSensor() { + if (mEnabled) { + enable(0, 0); + } +} + +int LightSensor::setInitialState() { + struct input_absinfo absinfo; + if (!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_LIGHT), &absinfo)) { + // make sure to report an event immediately + mHasPendingEvent = true; + mPendingEvent.light = absinfo.value; + } + return 0; +} + +int LightSensor::setDelay(int32_t handle, int64_t ns) +{ + int fd; + + strcpy(&input_sysfs_path[input_sysfs_path_len], "poll_delay"); + fd = open(input_sysfs_path, O_RDWR); + if (fd >= 0) { + char buf[80]; + sprintf(buf, "%lld", ns); + write(fd, buf, strlen(buf)+1); + close(fd); + return 0; + } + return -1; +} + +int LightSensor::enable(int32_t handle, int en) +{ + int flags = en ? 1 : 0; + int err; + int fd; + if (flags != mEnabled) { + strcpy(&input_sysfs_path[input_sysfs_path_len], "enable"); + fd = open(input_sysfs_path, O_RDWR); + if (fd >= 0) { + write(fd, en == 1 ? "1" : "0", 2); + close(fd); + mEnabled = flags; + setInitialState(); + return 0; + } + return -1; + } + return 0; +} + +bool LightSensor::hasPendingEvents() const { + return mHasPendingEvent; +} + +int LightSensor::readEvents(sensors_event_t* data, int count) +{ + if (count < 1) + return -EINVAL; + + if (mHasPendingEvent) { + mHasPendingEvent = false; + mPendingEvent.timestamp = getTimestamp(); + *data = mPendingEvent; + return mEnabled ? 1 : 0; + } + + ssize_t n = mInputReader.fill(data_fd); + if (n < 0) + return n; + + int numEventReceived = 0; + input_event const* event; + + while (count && mInputReader.readEvent(&event)) { + int type = event->type; + if (type == EV_REL) { + if (event->code == EVENT_TYPE_LIGHT) { + mPendingEvent.light = event->value; + } + } else if (type == EV_SYN) { + mPendingEvent.timestamp = timevalToNano(event->time); + if (mEnabled) { + *data++ = mPendingEvent; + count--; + numEventReceived++; + } + } else { + ALOGE("%s: unknown event (type=%d, code=%d)", LOGTAG, + type, event->code); + } + mInputReader.next(); + } + + return numEventReceived; +} diff --git a/libsensors/LightSensor.h b/libsensors/LightSensor.h new file mode 100644 index 0000000..85e65d9 --- /dev/null +++ b/libsensors/LightSensor.h @@ -0,0 +1,55 @@ +/* + * 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. + */ + +#ifndef ANDROID_LIGHT_SENSOR_H +#define ANDROID_LIGHT_SENSOR_H + +#include <stdint.h> +#include <errno.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +#include "sensors.h" +#include "SensorBase.h" +#include "InputEventReader.h" + +/*****************************************************************************/ + +struct input_event; + +class LightSensor : public SensorBase { + int mEnabled; + InputEventCircularReader mInputReader; + sensors_event_t mPendingEvent; + bool mHasPendingEvent; + char input_sysfs_path[PATH_MAX]; + int input_sysfs_path_len; + + float indexToValue(size_t index) const; + int setInitialState(); + +public: + LightSensor(); + virtual ~LightSensor(); + virtual int readEvents(sensors_event_t* data, int count); + virtual bool hasPendingEvents() const; + virtual int setDelay(int32_t handle, int64_t ns); + virtual int enable(int32_t handle, int enabled); +}; + +/*****************************************************************************/ + +#endif // ANDROID_LIGHT_SENSOR_H diff --git a/libsensors/MODULE_LICENSE_APACHE2 b/libsensors/MODULE_LICENSE_APACHE2 new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/libsensors/MODULE_LICENSE_APACHE2 diff --git a/libsensors/PressureSensor.cpp b/libsensors/PressureSensor.cpp new file mode 100644 index 0000000..6539ce0 --- /dev/null +++ b/libsensors/PressureSensor.cpp @@ -0,0 +1,155 @@ +/* + * 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 <cstring> + +#include <cutils/log.h> + +#include "PressureSensor.h" + +#define LOGTAG "PressureSensor" + +#define PRESSURE_CONVERT(x) (x/4096.0f) + +/*****************************************************************************/ + +PressureSensor::PressureSensor() + : SensorBase(NULL, "barometer_sensor"), + mEnabled(0), + mInputReader(4), + mHasPendingEvent(false) +{ + mPendingEvent.version = sizeof(sensors_event_t); + mPendingEvent.sensor = ID_PR; + mPendingEvent.type = SENSOR_TYPE_PRESSURE; + memset(mPendingEvent.data, 0, sizeof(mPendingEvent.data)); + + if (data_fd) { + strcpy(input_sysfs_path, "/sys/class/input/"); + strcat(input_sysfs_path, input_name); + strcat(input_sysfs_path, "/device/"); + input_sysfs_path_len = strlen(input_sysfs_path); + enable(0, 1); + } +} + +PressureSensor::~PressureSensor() { + if (mEnabled) { + enable(0, 0); + } +} + +int PressureSensor::setInitialState() { + struct input_absinfo absinfo; + if (!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_PRESSURE), &absinfo)) { + // make sure to report an event immediately + mHasPendingEvent = true; + mPendingEvent.pressure = PRESSURE_CONVERT(absinfo.value); + } + return 0; +} + +int PressureSensor::enable(int32_t handle, int en) { + int flags = en ? 1 : 0; + int fd; + if (flags != mEnabled) { + strcpy(&input_sysfs_path[input_sysfs_path_len], "enable"); + fd = open(input_sysfs_path, O_RDWR); + if (fd >= 0) { + write(fd, flags == 1 ? "1" : "0", 2); + close(fd); + mEnabled = flags; + setInitialState(); + return 0; + } + + return -1; + } + return 0; +} + +bool PressureSensor::hasPendingEvents() const { + return mHasPendingEvent; +} + +int PressureSensor::setDelay(int32_t handle, int64_t delay) +{ + int fd; + if (delay < 10000000) + delay = 10; + else + delay = delay / 1000000; + strcpy(&input_sysfs_path[input_sysfs_path_len], "poll_delay"); + fd = open(input_sysfs_path, O_RDWR); + if (fd >= 0) { + char buf[80]; + sprintf(buf, "%lld", delay); + write(fd, buf, strlen(buf)+1); + close(fd); + return 0; + } + return -1; +} + + +int PressureSensor::readEvents(sensors_event_t* data, int count) +{ + if (count < 1) + return -EINVAL; + + if (mHasPendingEvent) { + mHasPendingEvent = false; + mPendingEvent.timestamp = getTimestamp(); + *data = mPendingEvent; + return mEnabled ? 1 : 0; + } + + ssize_t n = mInputReader.fill(data_fd); + if (n < 0) + return n; + + int numEventReceived = 0; + input_event const* event; + + while (count && mInputReader.readEvent(&event)) { + int type = event->type; + if (type == EV_REL) { + if (event->code == REL_X) { + mPendingEvent.pressure = PRESSURE_CONVERT(event->value); + } + } else if (type == EV_SYN) { + mPendingEvent.timestamp = timevalToNano(event->time); + if (mEnabled) { + *data++ = mPendingEvent; + count--; + numEventReceived++; + } + } else { + ALOGE("%s: unknown event (type=%d, code=%d)", LOGTAG, + type, event->code); + } + mInputReader.next(); + } + + return numEventReceived; +} diff --git a/libsensors/PressureSensor.h b/libsensors/PressureSensor.h new file mode 100644 index 0000000..9333d44 --- /dev/null +++ b/libsensors/PressureSensor.h @@ -0,0 +1,54 @@ +/* + * 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. + */ + +#ifndef ANDROID_PRESSURE_SENSOR_H +#define ANDROID_PRESSURE_SENSOR_H + +#include <stdint.h> +#include <errno.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +#include "sensors.h" +#include "SensorBase.h" +#include "InputEventReader.h" + +/*****************************************************************************/ + +struct input_event; + +class PressureSensor : public SensorBase { + int mEnabled; + InputEventCircularReader mInputReader; + sensors_event_t mPendingEvent; + bool mHasPendingEvent; + char input_sysfs_path[PATH_MAX]; + int input_sysfs_path_len; + + int setInitialState(); + +public: + PressureSensor(); + virtual ~PressureSensor(); + virtual int readEvents(sensors_event_t* data, int count); + virtual bool hasPendingEvents() const; + virtual int enable(int32_t handle, int enabled); + virtual int setDelay(int32_t handle, int64_t ns); +}; + +/*****************************************************************************/ + +#endif // ANDROID_PRESSURE_SENSOR_H diff --git a/libsensors/ProximitySensor.cpp b/libsensors/ProximitySensor.cpp new file mode 100644 index 0000000..2ba56c1 --- /dev/null +++ b/libsensors/ProximitySensor.cpp @@ -0,0 +1,164 @@ +/* + * 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 <stdio.h> +#include <cstring> +#define ALOG_NDEBUG 0 +#define LOG_NDEBUG 0 +#include <cutils/log.h> + +#include "ProximitySensor.h" +#include "SensorBase.h" + +#define LOGTAG "ProximitySensor" + +/*****************************************************************************/ + +ProximitySensor::ProximitySensor() + : SensorBase(NULL, "proximity_sensor"), + mEnabled(0), + mInputReader(4), + mHasPendingEvent(false) +{ + mPendingEvent.version = sizeof(sensors_event_t); + mPendingEvent.sensor = ID_P; + mPendingEvent.type = SENSOR_TYPE_PROXIMITY; + memset(mPendingEvent.data, 0, sizeof(mPendingEvent.data)); + + if (data_fd) { + ALOGE("%s: got input_name %s", LOGTAG, input_name); + strcpy(input_sysfs_path, "/sys/class/input/"); + strcat(input_sysfs_path, input_name); + strcat(input_sysfs_path, "/device/"); + input_sysfs_path_len = strlen(input_sysfs_path); + enable(0, 1); + } +} + +ProximitySensor::~ProximitySensor() { + if (mEnabled) { + enable(0, 0); + } +} + +int ProximitySensor::setInitialState() { + struct input_absinfo absinfo; + if (!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_PROXIMITY), &absinfo)) { + // make sure to report an event immediately + mHasPendingEvent = true; + mPendingEvent.distance = indexToValue(absinfo.value); + } + return 0; +} + +int ProximitySensor::setDelay(int32_t handle, int64_t ns) +{ + int fd; + + strcpy(&input_sysfs_path[input_sysfs_path_len], "prox_poll_delay"); + fd = open(input_sysfs_path, O_RDWR); + if (fd >= 0) { + char buf[80]; + sprintf(buf, "%lld", ns); + write(fd, buf, strlen(buf)+1); + close(fd); + return 0; + } + return -1; +} + +int ProximitySensor::enable(int32_t handle, int en) { + int fd; + int flags = en ? 1 : 0; + int err; + ALOGD("%s: Enable: %i", __func__, en); + if (flags != mEnabled) { + strcpy(&input_sysfs_path[input_sysfs_path_len], "enable"); + fd = open(input_sysfs_path, O_RDWR); + if (fd >= 0) { + write(fd, en == 1 ? "1" : "0", 2); + close(fd); + mEnabled = flags; + setInitialState(); + return 0; + } + + return -1; + } + return 0; +} + +bool ProximitySensor::hasPendingEvents() const { + return mHasPendingEvent; +} + +int ProximitySensor::readEvents(sensors_event_t* data, int count) +{ + if (count < 1) + return -EINVAL; + + if (mHasPendingEvent) { + mHasPendingEvent = false; + mPendingEvent.timestamp = getTimestamp(); + *data = mPendingEvent; + return mEnabled ? 1 : 0; + } + + ssize_t n = mInputReader.fill(data_fd); + if (n < 0) + return n; + + int numEventReceived = 0; + input_event const* event; + + while (count && mInputReader.readEvent(&event)) { + int type = event->type; + if (type == EV_ABS) { + if (event->code == EVENT_TYPE_PROXIMITY) { + if (event->value != -1) { + // FIXME: not sure why we're getting -1 sometimes + mPendingEvent.distance = indexToValue(event->value); + } + } + } else if (type == EV_SYN) { + mPendingEvent.timestamp = timevalToNano(event->time); + if (mEnabled) { + *data++ = mPendingEvent; + count--; + numEventReceived++; + } + } else { + ALOGE("%s: unknown event (type=%d, code=%d)",LOGTAG, + type, event->code); + } + mInputReader.next(); + } + + return numEventReceived; +} + +float ProximitySensor::indexToValue(size_t index) const +{ + ALOGV("%s: Index = %zu",LOGTAG, index); + return index * PROXIMITY_THRESHOLD_CM; +} diff --git a/libsensors/ProximitySensor.h b/libsensors/ProximitySensor.h new file mode 100644 index 0000000..a6aa851 --- /dev/null +++ b/libsensors/ProximitySensor.h @@ -0,0 +1,55 @@ +/* + * 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. + */ + +#ifndef ANDROID_PROXIMITY_SENSOR_H +#define ANDROID_PROXIMITY_SENSOR_H + +#include <stdint.h> +#include <errno.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +#include "sensors.h" +#include "SensorBase.h" +#include "InputEventReader.h" + +/*****************************************************************************/ + +struct input_event; + +class ProximitySensor : public SensorBase { + int mEnabled; + InputEventCircularReader mInputReader; + sensors_event_t mPendingEvent; + bool mHasPendingEvent; + char input_sysfs_path[PATH_MAX]; + int input_sysfs_path_len; + + int setInitialState(); + float indexToValue(size_t index) const; + +public: + ProximitySensor(); + virtual ~ProximitySensor(); + virtual int readEvents(sensors_event_t* data, int count); + virtual bool hasPendingEvents() const; + virtual int enable(int32_t handle, int enabled); + virtual int setDelay(int32_t handle, int64_t ns); +}; + +/*****************************************************************************/ + +#endif // ANDROID_PROXIMITY_SENSOR_H diff --git a/libsensors/SensorBase.cpp b/libsensors/SensorBase.cpp new file mode 100644 index 0000000..f08ffb7 --- /dev/null +++ b/libsensors/SensorBase.cpp @@ -0,0 +1,141 @@ +/* + * 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 <pthread.h> +#include <cstring> + +#include <cutils/log.h> + +#include <linux/input.h> + +#include "SensorBase.h" + +/*****************************************************************************/ + +SensorBase::SensorBase( + const char* dev_name, + const char* data_name) + : dev_name(dev_name), data_name(data_name), + dev_fd(-1), data_fd(-1) +{ + if (data_name) { + data_fd = openInput(data_name); + } +} + +SensorBase::~SensorBase() { + if (data_fd >= 0) { + close(data_fd); + } + if (dev_fd >= 0) { + close(dev_fd); + } +} + +int SensorBase::open_device() { + if (dev_fd<0 && dev_name) { + dev_fd = open(dev_name, O_RDONLY); + ALOGE_IF(dev_fd<0, "Couldn't open %s (%s)", dev_name, strerror(errno)); + } + return 0; +} + +int SensorBase::close_device() { + if (dev_fd >= 0) { + close(dev_fd); + dev_fd = -1; + } + return 0; +} + +int SensorBase::getFd() const { + if (!data_name) { + return dev_fd; + } + return data_fd; +} + +int SensorBase::setDelay(int32_t handle, int64_t ns) { + return 0; +} + +bool SensorBase::hasPendingEvents() const { + return false; +} + +int64_t SensorBase::getTimestamp() { + struct timespec t; + t.tv_sec = t.tv_nsec = 0; + clock_gettime(CLOCK_MONOTONIC, &t); + return int64_t(t.tv_sec)*1000000000LL + t.tv_nsec; +} + +int SensorBase::openInput(const char* inputName) { + int fd = -1; + const char *dirname = "/dev/input"; + char devname[PATH_MAX]; + char *filename; + DIR *dir; + struct dirent *de; + dir = opendir(dirname); + if(dir == NULL) + return -1; + strcpy(devname, dirname); + filename = devname + strlen(devname); + *filename++ = '/'; + while((de = readdir(dir))) { + if(de->d_name[0] == '.' && + (de->d_name[1] == '\0' || + (de->d_name[1] == '.' && de->d_name[2] == '\0'))) + continue; + strcpy(filename, de->d_name); + fd = open(devname, O_RDONLY); + if (fd>=0) { + char name[80]; + if (ioctl(fd, EVIOCGNAME(sizeof(name) - 1), &name) < 1) { + name[0] = '\0'; + } + if (!strcmp(name, inputName)) { + strcpy(input_name, filename); + break; + } else { + close(fd); + fd = -1; + } + } + } + closedir(dir); + ALOGE_IF(fd<0, "couldn't find '%s' input device", inputName); + + return fd; +} + +int SensorBase::batch(int handle, int flags, int64_t period_ns, int64_t timeout) +{ + return 0; +} + +int SensorBase::flush(int handle) +{ + return 0; +} diff --git a/libsensors/SensorBase.h b/libsensors/SensorBase.h new file mode 100644 index 0000000..13a4ae6 --- /dev/null +++ b/libsensors/SensorBase.h @@ -0,0 +1,70 @@ +/* + * 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. + */ + +#ifndef ANDROID_SENSOR_BASE_H +#define ANDROID_SENSOR_BASE_H + +#include <stdint.h> +#include <errno.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +#include "sensors.h" + + +/*****************************************************************************/ + +struct sensors_event_t; + +class SensorBase { +protected: + const char* dev_name; + const char* data_name; + char input_name[PATH_MAX]; + int dev_fd; + int data_fd; + + int openInput(const char* inputName); + static int64_t getTimestamp(); + + + static int64_t timevalToNano(timeval const& t) { + return t.tv_sec*1000000000LL + t.tv_usec*1000; + } + + int open_device(); + int close_device(); + +public: + SensorBase( + const char* dev_name, + const char* data_name); + + virtual ~SensorBase(); + + virtual int readEvents(sensors_event_t* data, int count) = 0; + virtual bool hasPendingEvents() const; + virtual int getFd() const; + virtual int setDelay(int32_t handle, int64_t ns); + virtual int enable(int32_t handle, int enabled) = 0; + virtual int batch(int handle, int flags, int64_t period_ns, int64_t timeout); + virtual int flush(int handle); + +}; + +/*****************************************************************************/ + +#endif // ANDROID_SENSOR_BASE_H diff --git a/libsensors/ak8973b.h b/libsensors/ak8973b.h new file mode 100644 index 0000000..9b7ab60 --- /dev/null +++ b/libsensors/ak8973b.h @@ -0,0 +1,51 @@ +/* + * Definitions for akm8973 compass chip. + */ +#ifndef AKM8973_H +#define AKM8973_H + +#include <linux/ioctl.h> + +#define AKM8973_I2C_NAME "ak8973b" + +#define AKMIO 0xA1 + +/* IOCTLs for AKM library */ +#define ECS_IOCTL_WRITE _IOW(AKMIO, 0x01, char*) +#define ECS_IOCTL_READ _IOWR(AKMIO, 0x02, char*) +#define ECS_IOCTL_RESET _IO(AKMIO, 0x03) +#define ECS_IOCTL_SET_MODE _IOW(AKMIO, 0x04, short) +#define ECS_IOCTL_GETDATA _IOR(AKMIO, 0x05, char[SENSOR_DATA_SIZE]) +#define ECS_IOCTL_SET_YPR _IOW(AKMIO, 0x06, short[12]) +#define ECS_IOCTL_GET_OPEN_STATUS _IOR(AKMIO, 0x07, int) +#define ECS_IOCTL_GET_CLOSE_STATUS _IOR(AKMIO, 0x08, int) +#define ECS_IOCTL_GET_DELAY _IOR(AKMIO, 0x30, int64_t) +#define ECS_IOCTL_GET_PROJECT_NAME _IOR(AKMIO, 0x0D, char[64]) +#define ECS_IOCTL_GET_MATRIX _IOR(AKMIO, 0x0E, short [4][3][3]) + +/* IOCTLs for APPs */ +#define ECS_IOCTL_APP_SET_MODE _IOW(AKMIO, 0x10, short) +#define ECS_IOCTL_APP_SET_MFLAG _IOW(AKMIO, 0x11, short) +#define ECS_IOCTL_APP_GET_MFLAG _IOW(AKMIO, 0x12, short) +#define ECS_IOCTL_APP_SET_AFLAG _IOW(AKMIO, 0x13, short) +#define ECS_IOCTL_APP_GET_AFLAG _IOR(AKMIO, 0x14, short) +#define ECS_IOCTL_APP_SET_TFLAG _IOR(AKMIO, 0x15, short) +#define ECS_IOCTL_APP_GET_TFLAG _IOR(AKMIO, 0x16, short) +#define ECS_IOCTL_APP_RESET_PEDOMETER _IO(AKMIO, 0x17) +#define ECS_IOCTL_APP_SET_DELAY _IOW(AKMIO, 0x18, int64_t) +#define ECS_IOCTL_APP_GET_DELAY ECS_IOCTL_GET_DELAY + +/* Set raw magnetic vector flag */ +#define ECS_IOCTL_APP_SET_MVFLAG _IOW(AKMIO, 0x19, short) + +/* Get raw magnetic vector flag */ +#define ECS_IOCTL_APP_GET_MVFLAG _IOR(AKMIO, 0x1A, short) + +struct akm8973_platform_data { + short layouts[4][3][3]; + char project_name[64]; + int gpio_RST; + int gpio_INT; +}; + +#endif diff --git a/libsensors/ak8975-reg.h b/libsensors/ak8975-reg.h deleted file mode 100644 index 1a78a27..0000000 --- a/libsensors/ak8975-reg.h +++ /dev/null @@ -1,48 +0,0 @@ -/* linux/drivers/misc/ak8975-reg.h - * - * Copyright (c) 2010 Samsung Electronics Co., Ltd. - * http://www.samsung.com/ - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. -*/ -#ifndef __AK8975_REG__ -#define __AK8975_REG__ - -/* Compass device dependent definition */ -#define AK8975_MODE_SNG_MEASURE 0x01 -#define AK8975_MODE_SELF_TEST 0x08 -#define AK8975_MODE_FUSE_ACCESS 0x0F -#define AK8975_MODE_POWER_DOWN 0x00 - -/* Rx buffer size. i.e ST,TMPS,H1X,H1Y,H1Z*/ -#define SENSOR_DATA_SIZE 8 - -/* Read/Write buffer size.*/ -#define RWBUF_SIZE 16 - -/* AK8975 register address */ -#define AK8975_REG_WIA 0x00 -#define AK8975_REG_INFO 0x01 -#define AK8975_REG_ST1 0x02 -#define AK8975_REG_HXL 0x03 -#define AK8975_REG_HXH 0x04 -#define AK8975_REG_HYL 0x05 -#define AK8975_REG_HYH 0x06 -#define AK8975_REG_HZL 0x07 -#define AK8975_REG_HZH 0x08 -#define AK8975_REG_ST2 0x09 -#define AK8975_REG_CNTL 0x0A -#define AK8975_REG_RSV 0x0B -#define AK8975_REG_ASTC 0x0C -#define AK8975_REG_TS1 0x0D -#define AK8975_REG_TS2 0x0E -#define AK8975_REG_I2CDIS 0x0F - -/* AK8975 fuse-rom address */ -#define AK8975_FUSE_ASAX 0x10 -#define AK8975_FUSE_ASAY 0x11 -#define AK8975_FUSE_ASAZ 0x12 - -#endif /* __AK8975_REG__ */ diff --git a/libsensors/ak8975.h b/libsensors/ak8975.h deleted file mode 100644 index 79a5de4..0000000 --- a/libsensors/ak8975.h +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Copyright (C) 2010 Samsung Electronics. All rights reserved. - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * version 2 as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA - * 02110-1301 USA - */ -#ifndef AKM8975_H -#define AKM8975_H - -#include <linux/ioctl.h> - -#define AKM8975_I2C_NAME "ak8975" - -/* Rx buffer size, i.e from ST1 to ST2 */ -#define SENSOR_DATA_SIZE 8 -#define AKMIO 0xA1 - -/* IOCTLs for AKM library */ -/* WRITE and READ sizes don't include data. On WRITE, the first value is data - * size plus one and the second value is the register address. On READ - * the first value is the data size and second value is the register - * address and the data is written back into the buffer starting at - * the second byte (the length is unchanged). - */ -#define ECS_IOCTL_WRITE _IOW(AKMIO, 0x01, char*) -#define ECS_IOCTL_READ _IOWR(AKMIO, 0x02, char*) -#define ECS_IOCTL_RESET _IO(AKMIO, 0x03) -#define ECS_IOCTL_SET_MODE _IOW(AKMIO, 0x04, short) -#define ECS_IOCTL_GETDATA _IOR(AKMIO, 0x05, \ - char[SENSOR_DATA_SIZE]) -#define ECS_IOCTL_SET_YPR _IOW(AKMIO, 0x06, short[12]) -#define ECS_IOCTL_GET_OPEN_STATUS _IOR(AKMIO, 0x07, int) -#define ECS_IOCTL_GET_CLOSE_STATUS _IOR(AKMIO, 0x08, int) -#define ECS_IOCTL_GET_DELAY _IOR(AKMIO, 0x30, int64_t) -#define ECS_IOCTL_GET_PROJECT_NAME _IOR(AKMIO, 0x0D, char[64]) -#define ECS_IOCTL_GET_MATRIX _IOR(AKMIO, 0x0E, short[4][3][3]) - -/* IOCTLs for APPs */ -#define ECS_IOCTL_APP_SET_MODE _IOW(AKMIO, 0x10, short) -#define ECS_IOCTL_APP_SET_MFLAG _IOW(AKMIO, 0x11, short) -#define ECS_IOCTL_APP_GET_MFLAG _IOR(AKMIO, 0x12, short) -#define ECS_IOCTL_APP_SET_AFLAG _IOW(AKMIO, 0x13, short) -#define ECS_IOCTL_APP_GET_AFLAG _IOR(AKMIO, 0x14, short) -#define ECS_IOCTL_APP_SET_TFLAG _IOW(AKMIO, 0x15, short) -#define ECS_IOCTL_APP_GET_TFLAG _IOR(AKMIO, 0x16, short) -#define ECS_IOCTL_APP_RESET_PEDOMETER _IO(AKMIO, 0x17) -#define ECS_IOCTL_APP_SET_DELAY _IOW(AKMIO, 0x18, int64_t) -#define ECS_IOCTL_APP_GET_DELAY ECS_IOCTL_GET_DELAY - -/* Set raw magnetic vector flag */ -#define ECS_IOCTL_APP_SET_MVFLAG _IOW(AKMIO, 0x19, short) - -/* Get raw magnetic vector flag */ -#define ECS_IOCTL_APP_GET_MVFLAG _IOR(AKMIO, 0x1A, short) - -#ifdef __KERNEL__ -struct akm8975_platform_data { - int gpio_data_ready_int; -}; -#endif - -#endif diff --git a/libsensors/akm8975.c b/libsensors/akm8975.c deleted file mode 100644 index 47771fb..0000000 --- a/libsensors/akm8975.c +++ /dev/null @@ -1,612 +0,0 @@ -/* - * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr> - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - */ - -#include <stdlib.h> -#include <unistd.h> -#include <stdint.h> -#include <fcntl.h> -#include <errno.h> - -#include <hardware/sensors.h> -#include <hardware/hardware.h> - -#define LOG_TAG "smdk4x12_sensors" -#include <utils/Log.h> - -#include "smdk4x12_sensors.h" -#include "ak8975.h" -#include "ak8975-reg.h" - -#include <AKFS_Compass.h> -#include <AKFS_FileIO.h> - -#define AKFS_CONFIG_PATH "/data/misc/akfs.txt" -#define AKFS_PAT PAT3 - -struct akm8975_data { - AK8975PRMS akfs_params; - sensors_vec_t magnetic; - - int64_t delay; - int device_fd; - int uinput_fd; - - pthread_t thread; - pthread_mutex_t mutex; - int thread_continue; -}; - -int akfs_get_magnetic_field(struct akm8975_data *akm8975_data, short *magnetic_data) -{ - AK8975PRMS *params; - int rc, aocret; - float radius; - - if (akm8975_data == NULL || magnetic_data == NULL) - return -EINVAL; - - params = &akm8975_data->akfs_params; - - // Decomposition - // Sensitivity adjustment, i.e. multiply ASA, is done in this function. - rc = AKFS_DecompAK8975(magnetic_data, 1, ¶ms->mi_asa, AKFS_HDATA_SIZE, params->mfv_hdata); - if (rc == AKFS_ERROR) { - ALOGE("Failed to decomp!"); - return -1; - } - - // Adjust coordination - rc = AKFS_Rotate(params->m_hpat, ¶ms->mfv_hdata[0]); - if (rc == AKFS_ERROR) { - ALOGE("Failed to rotate!"); - return -1; - } - - // AOC for magnetometer - // Offset estimation is done in this function - aocret = AKFS_AOC(¶ms->m_aocv, params->mfv_hdata, ¶ms->mfv_ho); - - // Subtract offset - // Then, a magnetic vector, the unit is uT, is stored in mfv_hvbuf. - rc = AKFS_VbNorm(AKFS_HDATA_SIZE, params->mfv_hdata, 1, - ¶ms->mfv_ho, ¶ms->mfv_hs, AK8975_HSENSE_TARGET, - AKFS_HDATA_SIZE, params->mfv_hvbuf); - if (rc == AKFS_ERROR) { - ALOGE("Failed to normalize!"); - return -1; - } - - // Averaging - rc = AKFS_VbAve(AKFS_HDATA_SIZE, params->mfv_hvbuf, CSPEC_HNAVE_V, ¶ms->mfv_hvec); - if (rc == AKFS_ERROR) { - ALOGE("Failed to average!"); - return -1; - } - - // Check the size of magnetic vector - radius = sqrtf( - (params->mfv_hvec.u.x * params->mfv_hvec.u.x) + - (params->mfv_hvec.u.y * params->mfv_hvec.u.y) + - (params->mfv_hvec.u.z * params->mfv_hvec.u.z)); - - // Sanity check result and set accuracy - if ((radius > MAGNETIC_FIELD_EARTH_MAX + 10) || (radius < MAGNETIC_FIELD_EARTH_MIN - 10)) { - params->mi_hstatus = SENSOR_STATUS_UNRELIABLE; - } else if(params->mi_hstatus == SENSOR_STATUS_UNRELIABLE) { - params->mi_hstatus = SENSOR_STATUS_ACCURACY_MEDIUM; - } else if (aocret == AKFS_SUCCESS) { - params->mi_hstatus = SENSOR_STATUS_ACCURACY_HIGH; - } - - akm8975_data->magnetic.x = params->mfv_hvec.u.x; - akm8975_data->magnetic.y = params->mfv_hvec.u.y; - akm8975_data->magnetic.z = params->mfv_hvec.u.z; - akm8975_data->magnetic.status = params->mi_hstatus; - - return 0; -} - -int akfs_init(struct akm8975_data *akm8975_data, char *asa, AKFS_PATNO pat) -{ - AK8975PRMS *params; - - if (akm8975_data == NULL || asa == NULL) - return -EINVAL; - - params = &akm8975_data->akfs_params; - - memset(params, 0, sizeof(AK8975PRMS)); - - // Sensitivity - params->mfv_hs.u.x = AK8975_HSENSE_DEFAULT; - params->mfv_hs.u.y = AK8975_HSENSE_DEFAULT; - params->mfv_hs.u.z = AK8975_HSENSE_DEFAULT; - params->mfv_as.u.x = AK8975_ASENSE_DEFAULT; - params->mfv_as.u.y = AK8975_ASENSE_DEFAULT; - params->mfv_as.u.z = AK8975_ASENSE_DEFAULT; - - // Initialize variables that initial value is not 0. - params->mi_hnaveV = CSPEC_HNAVE_V; - params->mi_hnaveD = CSPEC_HNAVE_D; - params->mi_anaveV = CSPEC_ANAVE_V; - params->mi_anaveD = CSPEC_ANAVE_D; - - // Copy ASA values - params->mi_asa.u.x = asa[0]; - params->mi_asa.u.y = asa[1]; - params->mi_asa.u.z = asa[2]; - - // Copy layout pattern - params->m_hpat = pat; - - return 0; -} - -void *akm8975_thread(void *thread_data) -{ - struct smdk4x12_sensors_handlers *handlers = NULL; - struct akm8975_data *data = NULL; - struct input_event event; - struct timeval time; - char i2c_data[SENSOR_DATA_SIZE] = { 0 }; - short magnetic_data[3]; - short mode; - int64_t before, after; - int diff; - int device_fd; - int uinput_fd; - int rc; - - if (thread_data == NULL) - return NULL; - - handlers = (struct smdk4x12_sensors_handlers *) thread_data; - if (handlers->data == NULL) - return NULL; - - data = (struct akm8975_data *) handlers->data; - - device_fd = data->device_fd; - if (device_fd < 0) - return NULL; - - uinput_fd = data->uinput_fd; - if (uinput_fd < 0) - return NULL; - - while (data->thread_continue) { - pthread_mutex_lock(&data->mutex); - if (!data->thread_continue) - break; - - while (handlers->activated) { - gettimeofday(&time, NULL); - before = timestamp(&time); - - mode = AK8975_MODE_SNG_MEASURE; - rc = ioctl(device_fd, ECS_IOCTL_SET_MODE, &mode); - if (rc < 0) { - ALOGE("%s: Unable to set akm8975 mode", __func__); - return NULL; - } - - memset(&i2c_data, 0, sizeof(i2c_data)); - rc = ioctl(device_fd, ECS_IOCTL_GETDATA, &i2c_data); - if (rc < 0) { - ALOGE("%s: Unable to get akm8975 data", __func__); - return NULL; - } - - if (!(i2c_data[0] & 0x01)) { - ALOGE("%s: akm8975 data is not ready", __func__); - continue; - } - - if (i2c_data[7] & (1 << 2) || i2c_data[7] & (1 << 3)) { - ALOGE("%s: akm8975 data read error or overflow", __func__); - continue; - } - - magnetic_data[0] = (short) (i2c_data[2] << 8) | (i2c_data[1]); - magnetic_data[1] = (short) (i2c_data[4] << 8) | (i2c_data[3]); - magnetic_data[2] = (short) (i2c_data[6] << 8) | (i2c_data[5]); - - rc = akfs_get_magnetic_field(data, (short *) &magnetic_data); - if (rc < 0) { - ALOGE("%s: Unable to get AKFS magnetic field", __func__); - continue; - } - - input_event_set(&event, EV_REL, REL_X, (int) (data->magnetic.x * 1000)); - write(uinput_fd, &event, sizeof(event)); - input_event_set(&event, EV_REL, REL_Y, (int) (data->magnetic.y * 1000)); - write(uinput_fd, &event, sizeof(event)); - input_event_set(&event, EV_REL, REL_Z, (int) (data->magnetic.z * 1000)); - write(uinput_fd, &event, sizeof(event)); - input_event_set(&event, EV_REL, REL_MISC, (int) data->magnetic.status); - write(uinput_fd, &event, sizeof(event)); - input_event_set(&event, EV_SYN, 0, 0); - write(uinput_fd, &event, sizeof(event)); - - gettimeofday(&time, NULL); - after = timestamp(&time); - - diff = (int) (data->delay - (after - before)) / 1000; - if (diff <= 0) - continue; - - usleep(diff); - } - } - return NULL; -} - -int akm8975_init(struct smdk4x12_sensors_handlers *handlers, - struct smdk4x12_sensors_device *device) -{ - struct akm8975_data *data = NULL; - pthread_attr_t thread_attr; - char i2c_data[RWBUF_SIZE] = { 0 }; - short mode; - int device_fd = -1; - int uinput_fd = -1; - int input_fd = -1; - int rc; - int i; - - ALOGD("%s(%p, %p)", __func__, handlers, device); - - if (handlers == NULL || device == NULL) - return -EINVAL; - - data = (struct akm8975_data *) calloc(1, sizeof(struct akm8975_data)); - - device_fd = open("/dev/akm8975", O_RDONLY); - if (device_fd < 0) { - ALOGE("%s: Unable to open device", __func__); - goto error; - } - - mode = AK8975_MODE_POWER_DOWN; - rc = ioctl(device_fd, ECS_IOCTL_SET_MODE, &mode); - if (rc < 0) { - ALOGE("%s: Unable to set akm8975 mode", __func__); - goto error; - } - - mode = AK8975_MODE_FUSE_ACCESS; - rc = ioctl(device_fd, ECS_IOCTL_SET_MODE, &mode); - if (rc < 0) { - ALOGE("%s: Unable to set akm8975 mode", __func__); - goto error; - } - - i2c_data[0] = 3; - i2c_data[1] = AK8975_FUSE_ASAX; - rc = ioctl(device_fd, ECS_IOCTL_READ, &i2c_data); - if (rc < 0) { - ALOGE("%s: Unable to read akm8975 FUSE data", __func__); - goto error; - } - - ALOGD("AKM8975 ASA (Sensitivity Adjustment) values are: (%d, %d, %d)", - i2c_data[1], i2c_data[2], i2c_data[3]); - - rc = akfs_init(data, &i2c_data[1], AKFS_PAT); - if (rc < 0) { - ALOGE("%s: Unable to init AKFS", __func__); - goto error; - } - - i2c_data[0] = 1; - i2c_data[1] = AK8975_REG_WIA; - rc = ioctl(device_fd, ECS_IOCTL_READ, &i2c_data); - if (rc < 0) { - ALOGE("%s: Unable to read akm8975 WIA data", __func__); - goto error; - } - - ALOGD("AKM8975 WIA (Device ID) value is: 0x%x", i2c_data[1]); - - mode = AK8975_MODE_POWER_DOWN; - rc = ioctl(device_fd, ECS_IOCTL_SET_MODE, &mode); - if (rc < 0) { - ALOGE("%s: Unable to set akm8975 mode", __func__); - goto error; - } - - uinput_fd = uinput_rel_create("magnetic"); - if (uinput_fd < 0) { - ALOGD("%s: Unable to create uinput", __func__); - goto error; - } - - input_fd = input_open("magnetic"); - if (input_fd < 0) { - ALOGE("%s: Unable to open magnetic input", __func__); - goto error; - } - - data->thread_continue = 1; - - pthread_mutex_init(&data->mutex, NULL); - pthread_mutex_lock(&data->mutex); - - pthread_attr_init(&thread_attr); - pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); - - rc = pthread_create(&data->thread, &thread_attr, akm8975_thread, (void *) handlers); - if (rc < 0) { - ALOGE("%s: Unable to create akm8975 thread", __func__); - pthread_mutex_destroy(&data->mutex); - goto error; - } - - data->device_fd = device_fd; - data->uinput_fd = uinput_fd; - handlers->poll_fd = input_fd; - handlers->data = (void *) data; - - return 0; - -error: - if (data != NULL) - free(data); - - if (uinput_fd >= 0) - close(uinput_fd); - - if (input_fd >= 0) - close(input_fd); - - if (device_fd >= 0) - close(device_fd); - - handlers->poll_fd = -1; - handlers->data = NULL; - - return -1; -} - -int akm8975_deinit(struct smdk4x12_sensors_handlers *handlers) -{ - struct akm8975_data *data = NULL; - short mode; - int rc; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct akm8975_data *) handlers->data; - - handlers->activated = 0; - data->thread_continue = 0; - pthread_mutex_unlock(&data->mutex); - - pthread_mutex_destroy(&data->mutex); - - if (data->uinput_fd >= 0) { - uinput_destroy(data->uinput_fd); - close(data->uinput_fd); - } - data->uinput_fd = -1; - - if (handlers->poll_fd >= 0) - close(handlers->poll_fd); - handlers->poll_fd = -1; - - mode = AK8975_MODE_POWER_DOWN; - rc = ioctl(data->device_fd, ECS_IOCTL_SET_MODE, &mode); - if (rc < 0) - ALOGE("%s: Unable to set akm8975 mode", __func__); - - if (data->device_fd >= 0) - close(data->device_fd); - data->device_fd = -1; - - free(handlers->data); - handlers->data = NULL; - - return 0; -} - -int akm8975_activate(struct smdk4x12_sensors_handlers *handlers) -{ - struct akm8975_data *data; - AK8975PRMS *akfs_params; - int rc; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct akm8975_data *) handlers->data; - akfs_params = &data->akfs_params; - - // Read settings from a file - rc = AKFS_LoadParameters(akfs_params, AKFS_CONFIG_PATH); - if (rc != AKM_SUCCESS) { - ALOGE("%s: Unable to read AKFS HO parameters", __func__); - akfs_params->mfv_ho.u.x = 0.0f; - akfs_params->mfv_ho.u.y = 0.0f; - akfs_params->mfv_ho.u.z = 0.0f; - } else { - ALOGD("AKM8975 HO (Offset Adjustment) parameters read are: (%f, %f, %f)", - akfs_params->mfv_ho.u.x, akfs_params->mfv_ho.u.y, akfs_params->mfv_ho.u.z); - } - - // Initialize buffer - AKFS_InitBuffer(AKFS_HDATA_SIZE, akfs_params->mfv_hdata); - AKFS_InitBuffer(AKFS_HDATA_SIZE, akfs_params->mfv_hvbuf); - AKFS_InitBuffer(AKFS_ADATA_SIZE, akfs_params->mfv_adata); - AKFS_InitBuffer(AKFS_ADATA_SIZE, akfs_params->mfv_avbuf); - - // Initialize for AOC - AKFS_InitAOC(&akfs_params->m_aocv); - // Initialize magnetic status - akfs_params->mi_hstatus = SENSOR_STATUS_UNRELIABLE; - - handlers->activated = 1; - pthread_mutex_unlock(&data->mutex); - - return 0; -} - -int akm8975_deactivate(struct smdk4x12_sensors_handlers *handlers) -{ - struct akm8975_data *data; - AK8975PRMS *akfs_params; - int device_fd; - short mode; - int empty; - int rc; - int i; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct akm8975_data *) handlers->data; - akfs_params = &data->akfs_params; - - device_fd = data->device_fd; - if (device_fd < 0) - return -1; - - empty = 1; - - if ((akfs_params->mfv_ho.u.x != 0.0f) || (akfs_params->mfv_ho.u.y != 0.0f) || - (akfs_params->mfv_ho.u.z != 0.0f)) { - empty = 0; - } - - if (!empty) { - // Write settings to a file - rc = AKFS_SaveParameters(akfs_params, AKFS_CONFIG_PATH); - if (rc != AKM_SUCCESS) { - ALOGE("%s: Unable to write AKFS HO parameters", __func__); - } else { - ALOGD("AKM8975 HO (Offset Adjustment) parameters written are: (%f, %f, %f)", - akfs_params->mfv_ho.u.x, akfs_params->mfv_ho.u.y, akfs_params->mfv_ho.u.z); - } - } - - mode = AK8975_MODE_POWER_DOWN; - rc = ioctl(device_fd, ECS_IOCTL_SET_MODE, &mode); - if (rc < 0) - ALOGE("%s: Unable to set akm8975 mode", __func__); - - handlers->activated = 0; - - return 0; -} - -int akm8975_set_delay(struct smdk4x12_sensors_handlers *handlers, int64_t delay) -{ - struct akm8975_data *data; - - ALOGD("%s(%p, %" PRId64 ")", __func__, handlers, delay); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct akm8975_data *) handlers->data; - - data->delay = delay; - - return 0; -} - -float akm8975_convert(int value) -{ - return (float) value / 1000.0f; -} - -int akm8975_get_data(struct smdk4x12_sensors_handlers *handlers, - struct sensors_event_t *event) -{ - struct akm8975_data *data; - struct input_event input_event; - int input_fd; - int rc; - -// ALOGD("%s(%p, %p)", __func__, handlers, event); - - if (handlers == NULL || handlers->data == NULL || event == NULL) - return -EINVAL; - - data = (struct akm8975_data *) handlers->data; - - input_fd = handlers->poll_fd; - if (input_fd < 0) - return -1; - - memset(event, 0, sizeof(struct sensors_event_t)); - event->version = sizeof(struct sensors_event_t); - event->sensor = handlers->handle; - event->type = handlers->handle; - - do { - rc = read(input_fd, &input_event, sizeof(input_event)); - if (rc < (int) sizeof(input_event)) - break; - - if (input_event.type == EV_REL) { - switch (input_event.code) { - case REL_X: - event->magnetic.x = akm8975_convert(input_event.value); - break; - case REL_Y: - event->magnetic.y = akm8975_convert(input_event.value); - break; - case REL_Z: - event->magnetic.z = akm8975_convert(input_event.value); - break; - case REL_MISC: - event->magnetic.status = input_event.value; - break; - default: - continue; - } - } else if (input_event.type == EV_SYN) { - if (input_event.code == SYN_REPORT) - event->timestamp = input_timestamp(&input_event); - } - } while (input_event.type != EV_SYN); - - return 0; -} - -struct smdk4x12_sensors_handlers akm8975 = { - .name = "AKM8975", - .handle = SENSOR_TYPE_MAGNETIC_FIELD, - .init = akm8975_init, - .deinit = akm8975_deinit, - .activate = akm8975_activate, - .deactivate = akm8975_deactivate, - .set_delay = akm8975_set_delay, - .get_data = akm8975_get_data, - .activated = 0, - .needed = 0, - .poll_fd = -1, - .data = NULL, -}; diff --git a/libsensors/akmdfs/AK8975Driver.c b/libsensors/akmdfs/AK8975Driver.c deleted file mode 100644 index 003c8d2..0000000 --- a/libsensors/akmdfs/AK8975Driver.c +++ /dev/null @@ -1,318 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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 "AKFS_Common.h" -#include "AK8975Driver.h" - -#define MSENSOR_NAME "/dev/akm8975_dev" - -static int s_fdDev = -1; - -/*! - Open device driver. - This function opens both device drivers of magnetic sensor and acceleration - sensor. Additionally, some initial hardware settings are done, such as - measurement range, built-in filter function and etc. - @return If this function succeeds, the return value is #AKD_SUCCESS. - Otherwise the return value is #AKD_FAIL. - */ -int16_t AKD_InitDevice(void) -{ - if (s_fdDev < 0) { - /* Open magnetic sensor's device driver. */ - if ((s_fdDev = open(MSENSOR_NAME, O_RDWR)) < 0) { - AKMERROR_STR("open"); - return AKD_FAIL; - } - } - - return AKD_SUCCESS; -} - -/*! - Close device driver. - This function closes both device drivers of magnetic sensor and acceleration - sensor. - */ -void AKD_DeinitDevice(void) -{ - if (s_fdDev >= 0) { - close(s_fdDev); - s_fdDev = -1; - } -} - -/*! - Writes data to a register of the AK8975. When more than one byte of data is - specified, the data is written in contiguous locations starting at an address - specified in \a address. - @return If this function succeeds, the return value is #AKD_SUCCESS. Otherwise - the return value is #AKD_FAIL. - @param[in] address Specify the address of a register in which data is to be - written. - @param[in] data Specify data to write or a pointer to a data array containing - the data. When specifying more than one byte of data, specify the starting - address of the array. - @param[in] numberOfBytesToWrite Specify the number of bytes that make up the - data to write. When a pointer to an array is specified in data, this argument - equals the number of elements of the array. - */ -int16_t AKD_TxData( - const BYTE address, - const BYTE * data, - const uint16_t numberOfBytesToWrite) -{ - int i; - char buf[RWBUF_SIZE]; - - if (s_fdDev < 0) { - ALOGE("%s: Device file is not opened.", __FUNCTION__); - return AKD_FAIL; - } - if (numberOfBytesToWrite > (RWBUF_SIZE-2)) { - ALOGE("%s: Tx size is too large.", __FUNCTION__); - return AKD_FAIL; - } - - buf[0] = numberOfBytesToWrite + 1; - buf[1] = address; - - for (i = 0; i < numberOfBytesToWrite; i++) { - buf[i + 2] = data[i]; - } - if (ioctl(s_fdDev, ECS_IOCTL_WRITE, buf) < 0) { - AKMERROR_STR("ioctl"); - return AKD_FAIL; - } else { - -#if ENABLE_AKMDEBUG - AKMDATA(AKMDATA_DRV, "addr(HEX)=%02x data(HEX)=", address); - for (i = 0; i < numberOfBytesToWrite; i++) { - AKMDATA(AKMDATA_DRV, " %02x", data[i]); - } - AKMDATA(AKMDATA_DRV, "\n"); -#endif - return AKD_SUCCESS; - } -} - -/*! - Acquires data from a register or the EEPROM of the AK8975. - @return If this function succeeds, the return value is #AKD_SUCCESS. Otherwise - the return value is #AKD_FAIL. - @param[in] address Specify the address of a register from which data is to be - read. - @param[out] data Specify a pointer to a data array which the read data are - stored. - @param[in] numberOfBytesToRead Specify the number of bytes that make up the - data to read. When a pointer to an array is specified in data, this argument - equals the number of elements of the array. - */ -int16_t AKD_RxData( - const BYTE address, - BYTE * data, - const uint16_t numberOfBytesToRead) -{ - int i; - char buf[RWBUF_SIZE]; - - memset(data, 0, numberOfBytesToRead); - - if (s_fdDev < 0) { - ALOGE("%s: Device file is not opened.", __FUNCTION__); - return AKD_FAIL; - } - if (numberOfBytesToRead > (RWBUF_SIZE-1)) { - ALOGE("%s: Rx size is too large.", __FUNCTION__); - return AKD_FAIL; - } - - buf[0] = numberOfBytesToRead; - buf[1] = address; - - if (ioctl(s_fdDev, ECS_IOCTL_READ, buf) < 0) { - AKMERROR_STR("ioctl"); - return AKD_FAIL; - } else { - for (i = 0; i < numberOfBytesToRead; i++) { - data[i] = buf[i + 1]; - } -#if ENABLE_AKMDEBUG - AKMDATA(AKMDATA_DRV, "addr(HEX)=%02x len=%d data(HEX)=", - address, numberOfBytesToRead); - for (i = 0; i < numberOfBytesToRead; i++) { - AKMDATA(AKMDATA_DRV, " %02x", data[i]); - } - AKMDATA(AKMDATA_DRV, "\n"); -#endif - return AKD_SUCCESS; - } -} - -/*! - Acquire magnetic data from AK8975. If measurement is not done, this function - waits until measurement completion. - @return If this function succeeds, the return value is #AKD_SUCCESS. Otherwise - the return value is #AKD_FAIL. - @param[out] data A magnetic data array. The size should be larger than #SENSOR_DATA_SIZE. - */ -int16_t AKD_GetMagneticData(BYTE data[SENSOR_DATA_SIZE]) -{ - memset(data, 0, SENSOR_DATA_SIZE); - - if (s_fdDev < 0) { - ALOGE("%s: Device file is not opened.", __FUNCTION__); - return AKD_FAIL; - } - - if (ioctl(s_fdDev, ECS_IOCTL_GETDATA, data) < 0) { - AKMERROR_STR("ioctl"); - return AKD_FAIL; - } - - AKMDATA(AKMDATA_DRV, - "bdata(HEX)= %02x %02x %02x %02x %02x %02x %02x %02x\n", - data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]); - - return AKD_SUCCESS; -} - -/*! - Set calculated data to device driver. - @param[in] buf The order of input data depends on driver's specification. - */ -void AKD_SetYPR(const int buf[YPR_DATA_SIZE]) -{ - if (s_fdDev < 0) { - ALOGE("%s: Device file is not opened.", __FUNCTION__); - } else { - if (ioctl(s_fdDev, ECS_IOCTL_SET_YPR, buf) < 0) { - AKMERROR_STR("ioctl"); - } - } -} - -/*! - */ -int AKD_GetOpenStatus(int* status) -{ - if (s_fdDev < 0) { - ALOGE("%s: Device file is not opened.", __FUNCTION__); - return AKD_FAIL; - } - if (ioctl(s_fdDev, ECS_IOCTL_GET_OPEN_STATUS, status) < 0) { - AKMERROR_STR("ioctl"); - return AKD_FAIL; - } - return AKD_SUCCESS; -} - -/*! - */ -int AKD_GetCloseStatus(int* status) -{ - if (s_fdDev < 0) { - ALOGE("%s: Device file is not opened.", __FUNCTION__); - return AKD_FAIL; - } - if (ioctl(s_fdDev, ECS_IOCTL_GET_CLOSE_STATUS, status) < 0) { - AKMERROR_STR("ioctl"); - return AKD_FAIL; - } - return AKD_SUCCESS; -} - -/*! - Set AK8975 to the specific mode. - @return If this function succeeds, the return value is #AKD_SUCCESS. Otherwise - the return value is #AKD_FAIL. - @param[in] mode This value should be one of the AK8975_Mode which is defined in - akm8975.h file. - */ -int16_t AKD_SetMode(const BYTE mode) -{ - if (s_fdDev < 0) { - ALOGE("%s: Device file is not opened.", __FUNCTION__); - return AKD_FAIL; - } - - if (ioctl(s_fdDev, ECS_IOCTL_SET_MODE, &mode) < 0) { - AKMERROR_STR("ioctl"); - return AKD_FAIL; - } - - return AKD_SUCCESS; -} - -/*! - Acquire delay - @return If this function succeeds, the return value is #AKD_SUCCESS. Otherwise - the return value is #AKD_FAIL. - @param[out] delay A delay in nanosecond. - */ -int16_t AKD_GetDelay(int64_t delay[AKM_NUM_SENSORS]) -{ - if (s_fdDev < 0) { - ALOGE("%s: Device file is not opened.\n", __FUNCTION__); - return AKD_FAIL; - } - if (ioctl(s_fdDev, ECS_IOCTL_GET_DELAY, delay) < 0) { - AKMERROR_STR("ioctl"); - return AKD_FAIL; - } - return AKD_SUCCESS; -} - -/*! - Get layout information from device driver, i.e. platform data. - */ -int16_t AKD_GetLayout(int16_t* layout) -{ - char tmp; - - if (s_fdDev < 0) { - ALOGE("%s: Device file is not opened.", __FUNCTION__); - return AKD_FAIL; - } - - if (ioctl(s_fdDev, ECS_IOCTL_GET_LAYOUT, &tmp) < 0) { - AKMERROR_STR("ioctl"); - return AKD_FAIL; - } - - *layout = tmp; - return AKD_SUCCESS; -} - -/* Get acceleration data. */ -int16_t AKD_GetAccelerationData(int16_t data[3]) -{ - if (s_fdDev < 0) { - ALOGE("%s: Device file is not opened.", __FUNCTION__); - return AKD_FAIL; - } - if (ioctl(s_fdDev, ECS_IOCTL_GET_ACCEL, data) < 0) { - AKMERROR_STR("ioctl"); - return AKD_FAIL; - } - - AKMDATA(AKMDATA_DRV, "%s: acc=%d, %d, %d\n", - __FUNCTION__, data[0], data[1], data[2]); - - return AKD_SUCCESS; -} diff --git a/libsensors/akmdfs/AK8975Driver.h b/libsensors/akmdfs/AK8975Driver.h deleted file mode 100644 index 731210d..0000000 --- a/libsensors/akmdfs/AK8975Driver.h +++ /dev/null @@ -1,102 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKMD_INC_AK8975DRIVER_H -#define AKMD_INC_AK8975DRIVER_H - -#include <linux/akm8975.h> /* Device driver */ -#include <stdint.h> /* int8_t, int16_t etc. */ - -/*** Constant definition ******************************************************/ -#define AKD_TRUE 1 /*!< Represents true */ -#define AKD_FALSE 0 /*!< Represents false */ -#define AKD_SUCCESS 1 /*!< Represents success.*/ -#define AKD_FAIL 0 /*!< Represents fail. */ -#define AKD_ERROR -1 /*!< Represents error. */ - -/*! 0:Don't Output data, 1:Output data */ -#define AKD_DBG_DATA 0 -/*! Typical interval in ns */ -#define AK8975_MEASUREMENT_TIME_NS ((AK8975_MEASUREMENT_TIME_US) * 1000) -/*! 720 LSG = 1G = 9.8 m/s2 */ -#define LSG 720 - - -/*** Type declaration *********************************************************/ -typedef unsigned char BYTE; - -/*! - Open device driver. - This function opens device driver of acceleration sensor. - @return If this function succeeds, the return value is #AKD_SUCCESS. Otherwise - the return value is #AKD_FAIL. - */ -typedef int16_t(*ACCFNC_INITDEVICE)(void); - -/*! - Close device driver. - This function closes device drivers of acceleration sensor. - */ -typedef void(*ACCFNC_DEINITDEVICE)(void); - -/*! - Acquire acceleration data from acceleration sensor and convert it to Android - coordinate system. - @return If this function succeeds, the return value is #AKD_SUCCESS. Otherwise - the return value is #AKD_FAIL. - @param[out] data A acceleration data array. The coordinate system of the - acquired data follows the definition of Android. Unit is SmartCompass. - */ -typedef int16_t(*ACCFNC_GETACCDATA)(short data[3]); - - -/*** Global variables *********************************************************/ - -/*** Prototype of Function ***************************************************/ - -int16_t AKD_InitDevice(void); - -void AKD_DeinitDevice(void); - -int16_t AKD_TxData( - const BYTE address, - const BYTE* data, - const uint16_t numberOfBytesToWrite); - -int16_t AKD_RxData( - const BYTE address, - BYTE* data, - const uint16_t numberOfBytesToRead); - -int16_t AKD_GetMagneticData(BYTE data[SENSOR_DATA_SIZE]); - -void AKD_SetYPR(const int buf[YPR_DATA_SIZE]); - -int AKD_GetOpenStatus(int* status); - -int AKD_GetCloseStatus(int* status); - -int16_t AKD_SetMode(const BYTE mode); - -int16_t AKD_GetDelay(int64_t delay[AKM_NUM_SENSORS]); - -int16_t AKD_GetLayout(int16_t* layout); - -int16_t AKD_GetAccelerationData(int16_t data[3]); - -#endif /* AKMD_INC_AK8975DRIVER_H */ - diff --git a/libsensors/akmdfs/AKFS_APIs.c b/libsensors/akmdfs/AKFS_APIs.c deleted file mode 100644 index ace9bc1..0000000 --- a/libsensors/akmdfs/AKFS_APIs.c +++ /dev/null @@ -1,389 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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 "AKFS_Common.h" -#include "AKFS_Disp.h" -#include "AKFS_FileIO.h" -#include "AKFS_APIs.h" - -#ifdef WIN32 -#include "AK8975_LinuxDriver.h" -#endif - -static AK8975PRMS g_prms; - -/*! - Initialize library. At first, 0 is set to all parameters. After that, some - parameters, which should not be 0, are set to specific value. Some of initial - values can be customized by editing the file \c "AKFS_CSpec.h". - @return The return value is #AKM_SUCCESS. - @param[in] hpat Specify a layout pattern number. The number is determined - according to the mount orientation of the magnetometer. - @param[in] regs[3] Specify the ASA values which are read out from - fuse ROM. regs[0] is ASAX, regs[1] is ASAY, regs[2] is ASAZ. - */ -int16 AKFS_Init( - const AKFS_PATNO hpat, - const uint8 regs[] -) -{ - AKMDATA(AKMDATA_DUMP, "%s: hpat=%d, r[0]=0x%02X, r[1]=0x%02X, r[2]=0x%02X\n", - __FUNCTION__, hpat, regs[0], regs[1], regs[2]); - - /* Set 0 to the AK8975 structure. */ - memset(&g_prms, 0, sizeof(AK8975PRMS)); - - /* Sensitivity */ - g_prms.mfv_hs.u.x = AK8975_HSENSE_DEFAULT; - g_prms.mfv_hs.u.y = AK8975_HSENSE_DEFAULT; - g_prms.mfv_hs.u.z = AK8975_HSENSE_DEFAULT; - g_prms.mfv_as.u.x = AK8975_ASENSE_DEFAULT; - g_prms.mfv_as.u.y = AK8975_ASENSE_DEFAULT; - g_prms.mfv_as.u.z = AK8975_ASENSE_DEFAULT; - - /* Initialize variables that initial value is not 0. */ - g_prms.mi_hnaveV = CSPEC_HNAVE_V; - g_prms.mi_hnaveD = CSPEC_HNAVE_D; - g_prms.mi_anaveV = CSPEC_ANAVE_V; - g_prms.mi_anaveD = CSPEC_ANAVE_D; - - /* Copy ASA values */ - g_prms.mi_asa.u.x = regs[0]; - g_prms.mi_asa.u.y = regs[1]; - g_prms.mi_asa.u.z = regs[2]; - - /* Copy layout pattern */ - g_prms.m_hpat = hpat; - - return AKM_SUCCESS; -} - -/*! - Release resources. This function is for future expansion. - @return The return value is #AKM_SUCCESS. - */ -int16 AKFS_Release(void) -{ - return AKM_SUCCESS; -} - -/* - This function is called just before a measurement sequence starts. - This function reads parameters from file, then initializes algorithm - parameters. - @return The return value is #AKM_SUCCESS. - @param[in] path Specify a path to the settings file. - */ -int16 AKFS_Start( - const char* path -) -{ - AKMDATA(AKMDATA_DUMP, "%s: path=%s\n", __FUNCTION__, path); - - /* Read setting files from a file */ - if (AKFS_LoadParameters(&g_prms, path) != AKM_SUCCESS) { - AKMERROR_STR("AKFS_Load"); - } - - /* Initialize buffer */ - AKFS_InitBuffer(AKFS_HDATA_SIZE, g_prms.mfv_hdata); - AKFS_InitBuffer(AKFS_HDATA_SIZE, g_prms.mfv_hvbuf); - AKFS_InitBuffer(AKFS_ADATA_SIZE, g_prms.mfv_adata); - AKFS_InitBuffer(AKFS_ADATA_SIZE, g_prms.mfv_avbuf); - - /* Initialize for AOC */ - AKFS_InitAOC(&g_prms.m_aocv); - /* Initialize magnetic status */ - g_prms.mi_hstatus = 0; - - return AKM_SUCCESS; -} - -/*! - This function is called when a measurement sequence is done. - This fucntion writes parameters to file. - @return The return value is #AKM_SUCCESS. - @param[in] path Specify a path to the settings file. - */ -int16 AKFS_Stop( - const char* path -) -{ - AKMDATA(AKMDATA_DUMP, "%s: path=%s\n", __FUNCTION__, path); - - /* Write setting files to a file */ - if (AKFS_SaveParameters(&g_prms, path) != AKM_SUCCESS) { - AKMERROR_STR("AKFS_Save"); - } - - return AKM_SUCCESS; -} - -/*! - This function is called when new magnetometer data is available. The output - vector format and coordination system follow the Android definition. - @return The return value is #AKM_SUCCESS. - Otherwise the return value is #AKM_FAIL. - @param[in] mag A set of measurement data from magnetometer. X axis value - should be in mag[0], Y axis value should be in mag[1], Z axis value should be - in mag[2]. - @param[in] status A status of magnetometer. This status indicates the result - of measurement data, i.e. overflow, success or fail, etc. - @param[out] vx X axis value of magnetic field vector. - @param[out] vy Y axis value of magnetic field vector. - @param[out] vz Z axis value of magnetic field vector. - @param[out] accuracy Accuracy of magnetic field vector. - */ -int16 AKFS_Get_MAGNETIC_FIELD( - const int16 mag[3], - const int16 status, - AKFLOAT* vx, - AKFLOAT* vy, - AKFLOAT* vz, - int16* accuracy -) -{ - int16 akret; - int16 aocret; - AKFLOAT radius; - - AKMDATA(AKMDATA_DUMP, "%s: m[0]=%d, m[1]=%d, m[2]=%d, st=%d\n", - __FUNCTION__, mag[0], mag[1], mag[2], status); - - /* Decomposition */ - /* Sensitivity adjustment, i.e. multiply ASA, is done in this function. */ - akret = AKFS_DecompAK8975( - mag, - status, - &g_prms.mi_asa, - AKFS_HDATA_SIZE, - g_prms.mfv_hdata - ); - if(akret == AKFS_ERROR) { - AKMERROR; - return AKM_FAIL; - } - - /* Adjust coordination */ - akret = AKFS_Rotate( - g_prms.m_hpat, - &g_prms.mfv_hdata[0] - ); - if (akret == AKFS_ERROR) { - AKMERROR; - return AKM_FAIL; - } - - /* AOC for magnetometer */ - /* Offset estimation is done in this function */ - aocret = AKFS_AOC( - &g_prms.m_aocv, - g_prms.mfv_hdata, - &g_prms.mfv_ho - ); - - /* Subtract offset */ - /* Then, a magnetic vector, the unit is uT, is stored in mfv_hvbuf. */ - akret = AKFS_VbNorm( - AKFS_HDATA_SIZE, - g_prms.mfv_hdata, - 1, - &g_prms.mfv_ho, - &g_prms.mfv_hs, - AK8975_HSENSE_TARGET, - AKFS_HDATA_SIZE, - g_prms.mfv_hvbuf - ); - if(akret == AKFS_ERROR) { - AKMERROR; - return AKM_FAIL; - } - - /* Averaging */ - akret = AKFS_VbAve( - AKFS_HDATA_SIZE, - g_prms.mfv_hvbuf, - CSPEC_HNAVE_V, - &g_prms.mfv_hvec - ); - if (akret == AKFS_ERROR) { - AKMERROR; - return AKM_FAIL; - } - - /* Check the size of magnetic vector */ - radius = AKFS_SQRT( - (g_prms.mfv_hvec.u.x * g_prms.mfv_hvec.u.x) + - (g_prms.mfv_hvec.u.y * g_prms.mfv_hvec.u.y) + - (g_prms.mfv_hvec.u.z * g_prms.mfv_hvec.u.z)); - - if (radius > AKFS_GEOMAG_MAX) { - g_prms.mi_hstatus = 0; - } else { - if (aocret) { - g_prms.mi_hstatus = 3; - } - } - - *vx = g_prms.mfv_hvec.u.x; - *vy = g_prms.mfv_hvec.u.y; - *vz = g_prms.mfv_hvec.u.z; - *accuracy = g_prms.mi_hstatus; - - /* Debug output */ - AKMDATA(AKMDATA_MAG, "Mag(%d):%8.2f, %8.2f, %8.2f\n", - *accuracy, *vx, *vy, *vz); - - return AKM_SUCCESS; -} - -/*! - This function is called when new accelerometer data is available. The output - vector format and coordination system follow the Android definition. - @return The return value is #AKM_SUCCESS when function succeeds. Otherwise - the return value is #AKM_FAIL. - @param[in] acc A set of measurement data from accelerometer. X axis value - should be in acc[0], Y axis value should be in acc[1], Z axis value should be - in acc[2]. - @param[in] status A status of accelerometer. This status indicates the result - of acceleration data, i.e. overflow, success or fail, etc. - @param[out] vx X axis value of acceleration vector. - @param[out] vy Y axis value of acceleration vector. - @param[out] vz Z axis value of acceleration vector. - @param[out] accuracy Accuracy of acceleration vector. - This value is always 3. - */ -int16 AKFS_Get_ACCELEROMETER( - const int16 acc[3], - const int16 status, - AKFLOAT* vx, - AKFLOAT* vy, - AKFLOAT* vz, - int16* accuracy -) -{ - int16 akret; - - AKMDATA(AKMDATA_DUMP, "%s: a[0]=%d, a[1]=%d, a[2]=%d, st=%d\n", - __FUNCTION__, acc[0], acc[1], acc[2], status); - - /* Save data to buffer */ - AKFS_BufShift( - AKFS_ADATA_SIZE, - 1, - g_prms.mfv_adata - ); - g_prms.mfv_adata[0].u.x = acc[0]; - g_prms.mfv_adata[0].u.y = acc[1]; - g_prms.mfv_adata[0].u.z = acc[2]; - - /* Subtract offset, adjust sensitivity */ - /* As a result, a unit of acceleration data in mfv_avbuf is '1G = 9.8' */ - akret = AKFS_VbNorm( - AKFS_ADATA_SIZE, - g_prms.mfv_adata, - 1, - &g_prms.mfv_ao, - &g_prms.mfv_as, - AK8975_ASENSE_TARGET, - AKFS_ADATA_SIZE, - g_prms.mfv_avbuf - ); - if(akret == AKFS_ERROR) { - AKMERROR; - return AKM_FAIL; - } - - /* Averaging */ - akret = AKFS_VbAve( - AKFS_ADATA_SIZE, - g_prms.mfv_avbuf, - CSPEC_ANAVE_V, - &g_prms.mfv_avec - ); - if (akret == AKFS_ERROR) { - AKMERROR; - return AKM_FAIL; - } - - /* Adjust coordination */ - /* It is not needed. Because, the data from AK8975 driver is already - follows Android coordinate system. */ - - *vx = g_prms.mfv_avec.u.x; - *vy = g_prms.mfv_avec.u.y; - *vz = g_prms.mfv_avec.u.z; - *accuracy = 3; - - /* Debug output */ - AKMDATA(AKMDATA_ACC, "Acc(%d):%8.2f, %8.2f, %8.2f\n", - *accuracy, *vx, *vy, *vz); - - return AKM_SUCCESS; -} - -/*! - Get orientation sensor's elements. The vector format and coordination system - follow the Android definition. Before this function is called, magnetic - field vector and acceleration vector should be stored in the buffer by - calling #AKFS_Get_MAGNETIC_FIELD and #AKFS_Get_ACCELEROMETER. - @return The return value is #AKM_SUCCESS when function succeeds. Otherwise - the return value is #AKM_FAIL. - @param[out] azimuth Azimuthal angle in degree. - @param[out] pitch Pitch angle in degree. - @param[out] roll Roll angle in degree. - @param[out] accuracy Accuracy of orientation sensor. - */ -int16 AKFS_Get_ORIENTATION( - AKFLOAT* azimuth, - AKFLOAT* pitch, - AKFLOAT* roll, - int16* accuracy -) -{ - int16 akret; - - /* Azimuth calculation */ - /* Coordination system follows the Android coordination. */ - akret = AKFS_Direction( - AKFS_HDATA_SIZE, - g_prms.mfv_hvbuf, - CSPEC_HNAVE_D, - AKFS_ADATA_SIZE, - g_prms.mfv_avbuf, - CSPEC_ANAVE_D, - &g_prms.mf_azimuth, - &g_prms.mf_pitch, - &g_prms.mf_roll - ); - - if(akret == AKFS_ERROR) { - AKMERROR; - return AKM_FAIL; - } - *azimuth = g_prms.mf_azimuth; - *pitch = g_prms.mf_pitch; - *roll = g_prms.mf_roll; - *accuracy = g_prms.mi_hstatus; - - /* Debug output */ - AKMDATA(AKMDATA_ORI, "Ori(%d):%8.2f, %8.2f, %8.2f\n", - *accuracy, *azimuth, *pitch, *roll); - - return AKM_SUCCESS; -} - diff --git a/libsensors/akmdfs/AKFS_APIs.h b/libsensors/akmdfs/AKFS_APIs.h deleted file mode 100644 index e4d1e48..0000000 --- a/libsensors/akmdfs/AKFS_APIs.h +++ /dev/null @@ -1,69 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_APIS_H -#define AKFS_INC_APIS_H - -/* Include files for AK8975 library. */ -#include "AKFS_Compass.h" - -/*** Constant definition ******************************************************/ -#define AKFS_GEOMAG_MAX 70 - -/*** Type declaration *********************************************************/ - -/*** Global variables *********************************************************/ - -/*** Prototype of function ****************************************************/ -int16 AKFS_Init( - const AKFS_PATNO hpat, - const uint8 regs[] -); - -int16 AKFS_Release(void); - -int16 AKFS_Start(const char* path); - -int16 AKFS_Stop(const char* path); - -int16 AKFS_Get_MAGNETIC_FIELD( - const int16 mag[3], - const int16 status, - AKFLOAT* vx, - AKFLOAT* vy, - AKFLOAT* vz, - int16* accuracy -); - -int16 AKFS_Get_ACCELEROMETER( - const int16 acc[3], - const int16 status, - AKFLOAT* vx, - AKFLOAT* vy, - AKFLOAT* vz, - int16* accuracy -); - -int16 AKFS_Get_ORIENTATION( - AKFLOAT* azimuth, - AKFLOAT* pitch, - AKFLOAT* roll, - int16* accuracy -); - -#endif - diff --git a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_AK8975.c b/libsensors/akmdfs/AKFS_APIs_8975/AKFS_AK8975.c deleted file mode 100644 index 7bac9a1..0000000 --- a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_AK8975.c +++ /dev/null @@ -1,44 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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 "AKFS_AK8975.h" -#include "AKFS_Device.h" - -/*! - */ -int16 AKFS_DecompAK8975( - const int16 mag[3], - const int16 status, - const uint8vec* asa, - const int16 nhdata, - AKFVEC hdata[] -) -{ - /* put st1 and st2 value */ - if (AK8975_ST_ERROR(status)) { - return AKFS_ERROR; - } - - /* magnetic */ - AKFS_BufShift(nhdata, 1, hdata); - hdata[0].u.x = mag[0] * (((asa->u.x)/256.0f) + 0.5f); - hdata[0].u.y = mag[1] * (((asa->u.y)/256.0f) + 0.5f); - hdata[0].u.z = mag[2] * (((asa->u.z)/256.0f) + 0.5f); - - return AKFS_SUCCESS; -} - diff --git a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_AK8975.h b/libsensors/akmdfs/AKFS_APIs_8975/AKFS_AK8975.h deleted file mode 100644 index 25459e3..0000000 --- a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_AK8975.h +++ /dev/null @@ -1,50 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_AK8975_H -#define AKFS_INC_AK8975_H - -#include "AKFS_Device.h" - -/***** Constant definition ****************************************************/ -#define AK8975_BDATA_SIZE 8 - -#define AK8975_HSENSE_DEFAULT 1 -#define AK8975_HSENSE_TARGET 0.3f -#define AK8975_ASENSE_DEFAULT 720 -#define AK8975_ASENSE_TARGET 9.80665f - -#define AK8975_HDATA_CONVERTER(hi, low, asa) \ - (AKFLOAT)((int16)((((uint16)(hi))<<8)+(uint16)(low))*(((asa)/256.0f) + 0.5f)) - -#define AK8975_ST_ERROR(st) (((st)&0x09) != 0x01) - -/***** Type declaration *******************************************************/ - -/***** Prototype of function **************************************************/ -AKLIB_C_API_START -int16 AKFS_DecompAK8975( - const int16 mag[3], - const int16 status, - const uint8vec* asa, - const int16 nhdata, - AKFVEC hdata[] -); -AKLIB_C_API_END - -#endif - diff --git a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_AOC.c b/libsensors/akmdfs/AKFS_APIs_8975/AKFS_AOC.c deleted file mode 100644 index 62b2361..0000000 --- a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_AOC.c +++ /dev/null @@ -1,333 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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 "AKFS_AOC.h" -#include "AKFS_Math.h" - -/* - * CalcR - */ -static AKFLOAT CalcR( - const AKFVEC* x, - const AKFVEC* y -){ - int16 i; - AKFLOAT r; - - r = 0.0; - for(i = 0; i < 3; i++){ - r += (x->v[i]-y->v[i]) * (x->v[i]-y->v[i]); - } - r = sqrt(r); - - return r; -} - -/* - * From4Points2Sphere() - */ -static int16 From4Points2Sphere( - const AKFVEC points[], /*! (i/o) : input vectors */ - AKFVEC* center, /*! (o) : center of sphere */ - AKFLOAT* r /*! (i) : add/subtract value */ -){ - AKFLOAT dif[3][3]; - AKFLOAT r2[3]; - - AKFLOAT A; - AKFLOAT B; - AKFLOAT C; - AKFLOAT D; - AKFLOAT E; - AKFLOAT F; - AKFLOAT G; - - AKFLOAT OU; - AKFLOAT OD; - - int16 i, j; - - for(i = 0; i < 3; i++){ - r2[i] = 0.0; - for(j = 0; j < 3; j++){ - dif[i][j] = points[i].v[j] - points[3].v[j]; - r2[i] += (points[i].v[j]*points[i].v[j] - - points[3].v[j]*points[3].v[j]); - } - r2[i] *= 0.5; - } - - A = dif[0][0]*dif[2][2] - dif[0][2]*dif[2][0]; - B = dif[0][1]*dif[2][0] - dif[0][0]*dif[2][1]; - C = dif[0][0]*dif[2][1] - dif[0][1]*dif[2][0]; - D = dif[0][0]*r2[2] - dif[2][0]*r2[0]; - E = dif[0][0]*dif[1][1] - dif[0][1]*dif[1][0]; - F = dif[1][0]*dif[0][2] - dif[0][0]*dif[1][2]; - G = dif[0][0]*r2[1] - dif[1][0]*r2[0]; - - OU = D*E + B*G; - OD = C*F + A*E; - - if(fabs(OD) < AKFS_EPSILON){ - return -1; - } - - center->v[2] = OU / OD; - - OU = F*center->v[2] + G; - OD = E; - - if(fabs(OD) < AKFS_EPSILON){ - return -1; - } - - center->v[1] = OU / OD; - - OU = r2[0] - dif[0][1]*center->v[1] - dif[0][2]*center->v[2]; - OD = dif[0][0]; - - if(fabs(OD) < AKFS_EPSILON){ - return -1; - } - - center->v[0] = OU / OD; - - *r = CalcR(&points[0], center); - - return 0; - -} - -/* - * MeanVar - */ -static void MeanVar( - const AKFVEC v[], /*!< (i) : input vectors */ - const int16 n, /*!< (i) : number of vectors */ - AKFVEC* mean, /*!< (o) : (max+min)/2 */ - AKFVEC* var /*!< (o) : variation in vectors */ -){ - int16 i; - int16 j; - AKFVEC max; - AKFVEC min; - - for(j = 0; j < 3; j++){ - min.v[j] = v[0].v[j]; - max.v[j] = v[0].v[j]; - for(i = 1; i < n; i++){ - if(v[i].v[j] < min.v[j]){ - min.v[j] = v[i].v[j]; - } - if(v[i].v[j] > max.v[j]){ - max.v[j] = v[i].v[j]; - } - } - mean->v[j] = (max.v[j] + min.v[j]) / 2.0; /*mean */ - var->v[j] = max.v[j] - min.v[j]; /*var */ - } -} - -/* - * Get4points - */ -static void Get4points( - const AKFVEC v[], /*!< (i) : input vectors */ - const int16 n, /*!< (i) : number of vectors */ - AKFVEC out[] /*!< (o) : */ -){ - int16 i, j; - AKFLOAT temp; - AKFLOAT d; - - AKFVEC dv[AKFS_HBUF_SIZE]; - AKFVEC cross; - AKFVEC tempv; - - /* out 0 */ - out[0] = v[0]; - - /* out 1 */ - d = 0.0; - for(i = 1; i < n; i++){ - temp = CalcR(&v[i], &out[0]); - if(d < temp){ - d = temp; - out[1] = v[i]; - } - } - - /* out 2 */ - d = 0.0; - for(j = 0; j < 3; j++){ - dv[0].v[j] = out[1].v[j] - out[0].v[j]; - } - for(i = 1; i < n; i++){ - for(j = 0; j < 3; j++){ - dv[i].v[j] = v[i].v[j] - out[0].v[j]; - } - tempv.v[0] = dv[0].v[1]*dv[i].v[2] - dv[0].v[2]*dv[i].v[1]; - tempv.v[1] = dv[0].v[2]*dv[i].v[0] - dv[0].v[0]*dv[i].v[2]; - tempv.v[2] = dv[0].v[0]*dv[i].v[1] - dv[0].v[1]*dv[i].v[0]; - temp = tempv.u.x * tempv.u.x - + tempv.u.y * tempv.u.y - + tempv.u.z * tempv.u.z; - if(d < temp){ - d = temp; - out[2] = v[i]; - cross = tempv; - } - } - - /* out 3 */ - d = 0.0; - for(i = 1; i < n; i++){ - temp = dv[i].u.x * cross.u.x - + dv[i].u.y * cross.u.y - + dv[i].u.z * cross.u.z; - temp = fabs(temp); - if(d < temp){ - d = temp; - out[3] = v[i]; - } - } -} - -/* - * CheckInitFvec - */ -static int16 CheckInitFvec( - const AKFVEC *v /*!< [in] vector */ -){ - int16 i; - - for(i = 0; i < 3; i++){ - if(AKFS_FMAX <= v->v[i]){ - return 1; /* initvalue */ - } - } - - return 0; /* not initvalue */ -} - -/* - * AKFS_AOC - */ -int16 AKFS_AOC( /*!< (o) : calibration success(1), failure(0) */ - AKFS_AOC_VAR* haocv, /*!< (i/o) : a set of variables */ - const AKFVEC* hdata, /*!< (i) : vectors of data */ - AKFVEC* ho /*!< (i/o) : offset */ -){ - int16 i, j; - int16 num; - AKFLOAT tempf; - AKFVEC tempho; - - AKFVEC fourpoints[4]; - - AKFVEC var; - AKFVEC mean; - - /* buffer new data */ - for(i = 1; i < AKFS_HBUF_SIZE; i++){ - haocv->hbuf[AKFS_HBUF_SIZE-i] = haocv->hbuf[AKFS_HBUF_SIZE-i-1]; - } - haocv->hbuf[0] = *hdata; - - /* Check Init */ - num = 0; - for(i = AKFS_HBUF_SIZE; 3 < i; i--){ - if(CheckInitFvec(&haocv->hbuf[i-1]) == 0){ - num = i; - break; - } - } - if(num < 4){ - return AKFS_ERROR; - } - - /* get 4 points */ - Get4points(haocv->hbuf, num, fourpoints); - - /* estimate offset */ - if(0 != From4Points2Sphere(fourpoints, &tempho, &haocv->hraoc)){ - return AKFS_ERROR; - } - - /* check distance */ - for(i = 0; i < 4; i++){ - for(j = (i+1); j < 4; j++){ - tempf = CalcR(&fourpoints[i], &fourpoints[j]); - if((tempf < haocv->hraoc)||(tempf < AKFS_HR_TH)){ - return AKFS_ERROR; - } - } - } - - /* update offset buffer */ - for(i = 1; i < AKFS_HOBUF_SIZE; i++){ - haocv->hobuf[AKFS_HOBUF_SIZE-i] = haocv->hobuf[AKFS_HOBUF_SIZE-i-1]; - } - haocv->hobuf[0] = tempho; - - /* clear hbuf */ - for(i = (AKFS_HBUF_SIZE>>1); i < AKFS_HBUF_SIZE; i++) { - for(j = 0; j < 3; j++) { - haocv->hbuf[i].v[j]= AKFS_FMAX; - } - } - - /* Check Init */ - if(CheckInitFvec(&haocv->hobuf[AKFS_HOBUF_SIZE-1]) == 1){ - return AKFS_ERROR; - } - - /* Check ovar */ - tempf = haocv->hraoc * AKFS_HO_TH; - MeanVar(haocv->hobuf, AKFS_HOBUF_SIZE, &mean, &var); - if ((var.u.x >= tempf) || (var.u.y >= tempf) || (var.u.z >= tempf)){ - return AKFS_ERROR; - } - - *ho = mean; - - return AKFS_SUCCESS; -} - -/* - * AKFS_InitAOC - */ -void AKFS_InitAOC( - AKFS_AOC_VAR* haocv -){ - int16 i, j; - - /* Initialize buffer */ - for(i = 0; i < AKFS_HBUF_SIZE; i++) { - for(j = 0; j < 3; j++) { - haocv->hbuf[i].v[j]= AKFS_FMAX; - } - } - for(i = 0; i < AKFS_HOBUF_SIZE; i++) { - for(j = 0; j < 3; j++) { - haocv->hobuf[i].v[j]= AKFS_FMAX; - } - } - - haocv->hraoc = 0.0; -} - diff --git a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_AOC.h b/libsensors/akmdfs/AKFS_APIs_8975/AKFS_AOC.h deleted file mode 100644 index ffaaa88..0000000 --- a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_AOC.h +++ /dev/null @@ -1,53 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_AOC_H -#define AKFS_INC_AOC_H - -#include "AKFS_Device.h" - -/***** Constant definition ****************************************************/ -#define AKFS_HBUF_SIZE 20 -#define AKFS_HOBUF_SIZE 4 -#define AKFS_HR_TH 10 -#define AKFS_HO_TH 0.15 - -/***** Macro definition *******************************************************/ - -/***** Type declaration *******************************************************/ -typedef struct _AKFS_AOC_VAR{ - AKFVEC hbuf[AKFS_HBUF_SIZE]; - AKFVEC hobuf[AKFS_HOBUF_SIZE]; - AKFLOAT hraoc; -} AKFS_AOC_VAR; - -/***** Prototype of function **************************************************/ -AKLIB_C_API_START -int16 AKFS_AOC( - AKFS_AOC_VAR* haocv, - const AKFVEC* hdata, - AKFVEC* ho -); - -void AKFS_InitAOC( - AKFS_AOC_VAR* haocv -); - -AKLIB_C_API_END - -#endif - diff --git a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Configure.h b/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Configure.h deleted file mode 100644 index 1f80f48..0000000 --- a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Configure.h +++ /dev/null @@ -1,37 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_CONFIG_H -#define AKFS_INC_CONFIG_H - -/***** Language configuration *************************************************/ -#if defined(__cplusplus) -#define AKLIB_C_API_START extern "C" { -#define AKLIB_C_API_END } -#else -#define AKLIB_C_API_START -#define AKLIB_C_API_END -#endif - -/*! If following line is commented in, double type is used for floating point - calculation */ -/* -#define AKFS_PRECISION_DOUBLE -*/ - -#endif - diff --git a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Device.c b/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Device.c deleted file mode 100644 index 3d99ab1..0000000 --- a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Device.c +++ /dev/null @@ -1,110 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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 "AKFS_Device.h" - -int16 AKFS_InitBuffer( - const int16 ndata, /*!< Size of vector buffer */ - AKFVEC vdata[] /*!< Vector buffer */ -) -{ - int i; - - /* size check */ - if (ndata <= 0) { - return AKFS_ERROR; - } - - for (i=0; i<ndata; i++) { - vdata[i].u.x = AKFS_INIT_VALUE_F; - vdata[i].u.y = AKFS_INIT_VALUE_F; - vdata[i].u.z = AKFS_INIT_VALUE_F; - } - - return AKFS_SUCCESS; -} - -int16 AKFS_BufShift( - const int16 len, /*!< size of buffer */ - const int16 shift, /*!< shift size */ - AKFVEC v[] /*!< buffer */ -) -{ - int16 i; - - if((shift < 1) || (len < shift)) { - return AKFS_ERROR; - } - for (i = len-1; i >= shift; i--) { - v[i] = v[i-shift]; - } - return AKFS_SUCCESS; -} - -int16 AKFS_Rotate( - const AKFS_PATNO pat, - AKFVEC* vec -) -{ - AKFLOAT tmp; - switch(pat){ - /* Obverse */ - case PAT1: - /* This is Android default */ - break; - case PAT2: - tmp = vec->u.x; - vec->u.x = vec->u.y; - vec->u.y = -tmp; - break; - case PAT3: - vec->u.x = -(vec->u.x); - vec->u.y = -(vec->u.y); - break; - case PAT4: - tmp = vec->u.x; - vec->u.x = -(vec->u.y); - vec->u.y = tmp; - break; - /* Reverse */ - case PAT5: - vec->u.x = -(vec->u.x); - vec->u.z = -(vec->u.z); - break; - case PAT6: - tmp = vec->u.x; - vec->u.x = vec->u.y; - vec->u.y = tmp; - vec->u.z = -(vec->u.z); - break; - case PAT7: - vec->u.y = -(vec->u.y); - vec->u.z = -(vec->u.z); - break; - case PAT8: - tmp = vec->u.x; - vec->u.x = -(vec->u.y); - vec->u.y = -tmp; - vec->u.z = -(vec->u.z); - break; - default: - return AKFS_ERROR; - } - - return AKFS_SUCCESS; -} - diff --git a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Device.h b/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Device.h deleted file mode 100644 index 0292d54..0000000 --- a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Device.h +++ /dev/null @@ -1,107 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_DEVICE_H -#define AKFS_INC_DEVICE_H - -#include <float.h> -#include "AKFS_Configure.h" - -/***** Constant definition ****************************************************/ -#define AKFS_ERROR 0 -#define AKFS_SUCCESS 1 - -#define AKFS_HDATA_SIZE 32 -#define AKFS_ADATA_SIZE 32 - -/***** Type declaration *******************************************************/ -typedef signed char int8; -typedef signed short int16; -typedef unsigned char uint8; -typedef unsigned short uint16; - - -#ifdef AKFS_PRECISION_DOUBLE -typedef double AKFLOAT; -#define AKFS_EPSILON DBL_EPSILON -#define AKFS_FMAX DBL_MAX -#define AKFS_FMIN DBL_MIN - -#else -typedef float AKFLOAT; -#define AKFS_EPSILON FLT_EPSILON -#define AKFS_FMAX FLT_MAX -#define AKFS_FMIN FLT_MIN - -#endif - -/* Treat maximum value as initial value */ -#define AKFS_INIT_VALUE_F AKFS_FMAX - -/***** Vector *****/ -typedef union _uint8vec{ - struct { - uint8 x; - uint8 y; - uint8 z; - }u; - uint8 v[3]; -} uint8vec; - -typedef union _AKFVEC{ - struct { - AKFLOAT x; - AKFLOAT y; - AKFLOAT z; - }u; - AKFLOAT v[3]; -} AKFVEC; - -/***** Layout pattern *****/ -typedef enum _AKFS_PATNO { - PAT_INVALID = 0, - PAT1, /* obverse: 1st pin is right down */ - PAT2, /* obverse: 1st pin is left down */ - PAT3, /* obverse: 1st pin is left top */ - PAT4, /* obverse: 1st pin is right top */ - PAT5, /* reverse: 1st pin is left down (from top view) */ - PAT6, /* reverse: 1st pin is left top (from top view) */ - PAT7, /* reverse: 1st pin is right top (from top view) */ - PAT8 /* reverse: 1st pin is right down (from top view) */ -} AKFS_PATNO; - -/***** Prototype of function **************************************************/ -AKLIB_C_API_START -int16 AKFS_InitBuffer( - const int16 ndata, /*!< Size of raw vector buffer */ - AKFVEC vdata[] /*!< Raw vector buffer */ -); - -int16 AKFS_BufShift( - const int16 len, - const int16 shift, - AKFVEC v[] -); - -int16 AKFS_Rotate( - const AKFS_PATNO pat, - AKFVEC* vec -); -AKLIB_C_API_END - -#endif - diff --git a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Direction.c b/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Direction.c deleted file mode 100644 index f47e930..0000000 --- a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Direction.c +++ /dev/null @@ -1,133 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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 "AKFS_Direction.h" -#include "AKFS_VNorm.h" -#include "AKFS_Math.h" - -/* - Coordinate system is right-handed. - X-Axis: from left to right. - Y-Axis: from bottom to top. - Z-Axis: from reverse to obverse. - - azimuth: Rotaion around Z axis, with positive values - when y-axis moves toward the x-axis. - pitch: Rotation around X axis, with positive values - when z-axis moves toward the y-axis. - roll: Rotation around Y axis, with positive values - when x-axis moves toward the z-axis. -*/ - -/* - This function is used internaly, so output is RADIAN! - */ -static void AKFS_Angle( - const AKFVEC* avec, - AKFLOAT* pitch, /* radian */ - AKFLOAT* roll /* radian */ -) -{ - AKFLOAT av; /* Size of vector */ - - av = AKFS_SQRT((avec->u.x)*(avec->u.x) + (avec->u.y)*(avec->u.y) + (avec->u.z)*(avec->u.z)); - - *pitch = AKFS_ASIN(-(avec->u.y) / av); - *roll = AKFS_ASIN((avec->u.x) / av); -} - -/* - This function is used internaly, so output is RADIAN! - */ -static void AKFS_Azimuth( - const AKFVEC* hvec, - const AKFLOAT pitch, /* radian */ - const AKFLOAT roll, /* radian */ - AKFLOAT* azimuth /* radian */ -) -{ - AKFLOAT sinP; /* sin value of pitch angle */ - AKFLOAT cosP; /* cos value of pitch angle */ - AKFLOAT sinR; /* sin value of roll angle */ - AKFLOAT cosR; /* cos value of roll angle */ - AKFLOAT Xh; /* X axis element of vector which is projected to horizontal plane */ - AKFLOAT Yh; /* Y axis element of vector which is projected to horizontal plane */ - - sinP = AKFS_SIN(pitch); - cosP = AKFS_COS(pitch); - sinR = AKFS_SIN(roll); - cosR = AKFS_COS(roll); - - Yh = -(hvec->u.x)*cosR + (hvec->u.z)*sinR; - Xh = (hvec->u.x)*sinP*sinR + (hvec->u.y)*cosP + (hvec->u.z)*sinP*cosR; - - /* atan2(y, x) -> divisor and dividend is opposite from mathematical equation. */ - *azimuth = AKFS_ATAN2(Yh, Xh); -} - -int16 AKFS_Direction( - const int16 nhvec, - const AKFVEC hvec[], - const int16 hnave, - const int16 navec, - const AKFVEC avec[], - const int16 anave, - AKFLOAT* azimuth, - AKFLOAT* pitch, - AKFLOAT* roll -) -{ - AKFVEC have, aave; - AKFLOAT azimuthRad; - AKFLOAT pitchRad; - AKFLOAT rollRad; - - /* arguments check */ - if ((nhvec <= 0) || (navec <= 0) || (hnave <= 0) || (anave <= 0)) { - return AKFS_ERROR; - } - if ((nhvec < hnave) || (navec < anave)) { - return AKFS_ERROR; - } - - /* average */ - if (AKFS_VbAve(nhvec, hvec, hnave, &have) != AKFS_SUCCESS) { - return AKFS_ERROR; - } - if (AKFS_VbAve(navec, avec, anave, &aave) != AKFS_SUCCESS) { - return AKFS_ERROR; - } - - /* calculate pitch and roll */ - AKFS_Angle(&aave, &pitchRad, &rollRad); - - /* calculate azimuth */ - AKFS_Azimuth(&have, pitchRad, rollRad, &azimuthRad); - - *azimuth = RAD2DEG(azimuthRad); - *pitch = RAD2DEG(pitchRad); - *roll = RAD2DEG(rollRad); - - /* Adjust range of azimuth */ - if (*azimuth < 0) { - *azimuth += 360.0f; - } - - return AKFS_SUCCESS; -} - - diff --git a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Direction.h b/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Direction.h deleted file mode 100644 index c08338d..0000000 --- a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Direction.h +++ /dev/null @@ -1,39 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_DIRECTION_H -#define AKFS_INC_DIRECTION_H - -#include "AKFS_Device.h" - -/***** Prototype of function **************************************************/ -AKLIB_C_API_START -int16 AKFS_Direction( - const int16 nhvec, - const AKFVEC hvec[], - const int16 hnave, - const int16 navec, - const AKFVEC avec[], - const int16 anave, - AKFLOAT* azimuth, - AKFLOAT* pitch, - AKFLOAT* roll -); -AKLIB_C_API_END - -#endif - diff --git a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Math.h b/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Math.h deleted file mode 100644 index dfe48b3..0000000 --- a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_Math.h +++ /dev/null @@ -1,47 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_MATH_H -#define AKFS_INC_MATH_H - -#include <math.h> -#include "AKFS_Configure.h" - -/***** Constant definition ****************************************************/ -#define AKFS_PI 3.141592654f -#define RAD2DEG(rad) ((rad)*180.0f/AKFS_PI) - -/***** Macro definition *******************************************************/ - -#ifdef AKFS_PRECISION_DOUBLE -#define AKFS_SIN(x) sin(x) -#define AKFS_COS(x) cos(x) -#define AKFS_ASIN(x) asin(x) -#define AKFS_ACOS(x) acos(x) -#define AKFS_ATAN2(y, x) atan2((y), (x)) -#define AKFS_SQRT(x) sqrt(x) -#else -#define AKFS_SIN(x) sinf(x) -#define AKFS_COS(x) cosf(x) -#define AKFS_ASIN(x) asinf(x) -#define AKFS_ACOS(x) acosf(x) -#define AKFS_ATAN2(y, x) atan2f((y), (x)) -#define AKFS_SQRT(x) sqrtf(x) -#endif - -#endif - diff --git a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_VNorm.c b/libsensors/akmdfs/AKFS_APIs_8975/AKFS_VNorm.c deleted file mode 100644 index ffa934a..0000000 --- a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_VNorm.c +++ /dev/null @@ -1,107 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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 "AKFS_VNorm.h" -#include "AKFS_Device.h" - -/*! - */ -int16 AKFS_VbNorm( - const int16 ndata, /*!< Size of raw vector buffer */ - const AKFVEC vdata[], /*!< Raw vector buffer */ - const int16 nbuf, /*!< Size of data to be buffered */ - const AKFVEC* o, /*!< Offset */ - const AKFVEC* s, /*!< Sensitivity */ - const AKFLOAT tgt, /*!< Target sensitivity */ - const int16 nvec, /*!< Size of normalized vector buffer */ - AKFVEC vvec[] /*!< Normalized vector buffer */ -) -{ - int i; - - /* size check */ - if ((ndata <= 0) || (nvec <= 0) || (nbuf <= 0)) { - return AKFS_ERROR; - } - /* dependency check */ - if ((nbuf < 1) || (ndata < nbuf) || (nvec < nbuf)) { - return AKFS_ERROR; - } - /* sensitivity check */ - if ((s->u.x <= AKFS_EPSILON) || - (s->u.y <= AKFS_EPSILON) || - (s->u.z <= AKFS_EPSILON) || - (tgt <= 0)) { - return AKFS_ERROR; - } - - /* calculate and store data to buffer */ - if (AKFS_BufShift(nvec, nbuf, vvec) != AKFS_SUCCESS) { - return AKFS_ERROR; - } - for (i=0; i<nbuf; i++) { - vvec[i].u.x = ((vdata[i].u.x - o->u.x) / (s->u.x) * (AKFLOAT)tgt); - vvec[i].u.y = ((vdata[i].u.y - o->u.y) / (s->u.y) * (AKFLOAT)tgt); - vvec[i].u.z = ((vdata[i].u.z - o->u.z) / (s->u.z) * (AKFLOAT)tgt); - } - - return AKFS_SUCCESS; -} - -/*! - */ -int16 AKFS_VbAve( - const int16 nvec, /*!< Size of normalized vector buffer */ - const AKFVEC vvec[], /*!< Normalized vector buffer */ - const int16 nave, /*!< Number of averaeg */ - AKFVEC* vave /*!< Averaged vector */ -) -{ - int i; - - /* arguments check */ - if ((nave <= 0) || (nvec <= 0) || (nvec < nave)) { - return AKFS_ERROR; - } - - /* calculate average */ - vave->u.x = 0; - vave->u.y = 0; - vave->u.z = 0; - for (i=0; i<nave; i++) { - if ((vvec[i].u.x == AKFS_INIT_VALUE_F) || - (vvec[i].u.y == AKFS_INIT_VALUE_F) || - (vvec[i].u.z == AKFS_INIT_VALUE_F)) { - break; - } - vave->u.x += vvec[i].u.x; - vave->u.y += vvec[i].u.y; - vave->u.z += vvec[i].u.z; - } - if (i == 0) { - vave->u.x = 0; - vave->u.y = 0; - vave->u.z = 0; - } else { - vave->u.x /= i; - vave->u.y /= i; - vave->u.z /= i; - } - return AKFS_SUCCESS; -} - - diff --git a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_VNorm.h b/libsensors/akmdfs/AKFS_APIs_8975/AKFS_VNorm.h deleted file mode 100644 index c3c9bed..0000000 --- a/libsensors/akmdfs/AKFS_APIs_8975/AKFS_VNorm.h +++ /dev/null @@ -1,46 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_VNORM_H -#define AKFS_INC_VNORM_H - -#include "AKFS_Device.h" - -/***** Prototype of function **************************************************/ -AKLIB_C_API_START -int16 AKFS_VbNorm( - const int16 ndata, /*!< Size of raw vector buffer */ - const AKFVEC vdata[], /*!< Raw vector buffer */ - const int16 nbuf, /*!< Size of data to be buffered */ - const AKFVEC* o, /*!< Offset */ - const AKFVEC* s, /*!< Sensitivity */ - const AKFLOAT tgt, /*!< Target sensitivity */ - const int16 nvec, /*!< Size of normalized vector buffer */ - AKFVEC vvec[] /*!< Normalized vector buffer */ -); - -int16 AKFS_VbAve( - const int16 nvec, /*!< Size of normalized vector buffer */ - const AKFVEC vvec[], /*!< Normalized vector buffer */ - const int16 nave, /*!< Number of averaeg */ - AKFVEC* vave /*!< Averaged vector */ -); - -AKLIB_C_API_END - -#endif - diff --git a/libsensors/akmdfs/AKFS_CSpec.h b/libsensors/akmdfs/AKFS_CSpec.h deleted file mode 100644 index 380f06f..0000000 --- a/libsensors/akmdfs/AKFS_CSpec.h +++ /dev/null @@ -1,38 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_CSPEC_H -#define AKFS_INC_CSPEC_H - -/******************************************************************************* - User defines parameters. - ******************************************************************************/ -/* Parameters for Average */ -/* The number of magnetic/acceleration data to be averaged. */ -#define CSPEC_HNAVE_D 4 -#define CSPEC_ANAVE_D 4 -#define CSPEC_HNAVE_V 8 -#define CSPEC_ANAVE_V 8 - -#ifdef WIN32 -#define CSPEC_SETTING_FILE "akmdfs.txt" -#else -#define CSPEC_SETTING_FILE "/data/misc/akmdfs.txt" -#endif - -#endif - diff --git a/libsensors/akmdfs/AKFS_Common.h b/libsensors/akmdfs/AKFS_Common.h deleted file mode 100644 index 7780801..0000000 --- a/libsensors/akmdfs/AKFS_Common.h +++ /dev/null @@ -1,141 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_COMMON_H -#define AKFS_INC_COMMON_H - -#ifdef WIN32 -#ifndef _WIN32_WINNT -#define _WIN32_WINNT 0x0501 -#endif - -#include <windows.h> -#include <stdio.h> -#include <stdlib.h> -#include <conio.h> -#include <stdarg.h> -#include <crtdbg.h> -#include "Android.h" - -#define DBG_LEVEL DBG_LEVEL4 -#define ENABLE_AKMDEBUG 1 - -#else -#include <stdio.h> /* frpintf */ -#include <stdlib.h> /* atoi */ -#include <string.h> /* memset */ -#include <unistd.h> -#include <stdarg.h> /* va_list */ -#include <utils/Log.h> /* ALOGV */ -#include <errno.h> /* errno */ - -#endif - -/*** Constant definition ******************************************************/ -#define AKM_TRUE 1 /*!< Represents true */ -#define AKM_FALSE 0 /*!< Represents false */ -#define AKM_SUCCESS 1 /*!< Represents success */ -#define AKM_FAIL 0 /*!< Represents fail */ - -#define DBG_LEVEL0 0 /* Critical */ -#define DBG_LEVEL1 1 /* Notice */ -#define DBG_LEVEL2 2 /* Information */ -#define DBG_LEVEL3 3 /* Debug */ -#define DBG_LEVEL4 4 /* Verbose */ - -#ifndef DBG_LEVEL -#define DBG_LEVEL DBG_LEVEL0 -#endif - -#define DATA_AREA01 0x0001 -#define DATA_AREA02 0x0002 -#define DATA_AREA03 0x0004 -#define DATA_AREA04 0x0008 -#define DATA_AREA05 0x0010 -#define DATA_AREA06 0x0020 -#define DATA_AREA07 0x0040 -#define DATA_AREA08 0x0080 -#define DATA_AREA09 0x0100 -#define DATA_AREA10 0x0200 -#define DATA_AREA11 0x0400 -#define DATA_AREA12 0x0800 -#define DATA_AREA13 0x1000 -#define DATA_AREA14 0x2000 -#define DATA_AREA15 0x4000 -#define DATA_AREA16 0x8000 - - -/* Debug area definition */ -#define AKMDATA_DUMP DATA_AREA01 /*<! Dump data */ -#define AKMDATA_BDATA DATA_AREA02 /*<! BDATA */ -#define AKMDATA_MAG DATA_AREA03 /*<! Magnetic Field */ -#define AKMDATA_ACC DATA_AREA04 /*<! Accelerometer */ -#define AKMDATA_ORI DATA_AREA05 /*<! Orientation */ -#define AKMDATA_GETINTERVAL DATA_AREA06 -#define AKMDATA_LOOP DATA_AREA07 -#define AKMDATA_DRV DATA_AREA08 - -#ifndef ENABLE_AKMDEBUG -#define ENABLE_AKMDEBUG 0 /* Eanble debug output when it is 1. */ -#endif - -#define OPMODE_CONSOLE 0x01 -#define OPMODE_FST 0x02 - -/***** Debug Level Output *************************************/ -#if ENABLE_AKMDEBUG -#define AKMDEBUG(level, format, ...) \ - (((level) <= DBG_LEVEL) \ - ? (fprintf(stdout, (format), ##__VA_ARGS__)) \ - : ((void)0)) -#else -#define AKMDEBUG(level, format, ...) -#endif - -/***** Dbg Zone Output ***************************************/ -#if ENABLE_AKMDEBUG -#define AKMDATA(flag, format, ...) \ - ((((int)flag) & g_dbgzone) \ - ? (fprintf(stdout, (format), ##__VA_ARGS__)) \ - : ((void)0)) -#else -#define AKMDATA(flag, format, ...) -#endif - -/***** Log output ********************************************/ -#ifdef AKM_LOG_ENABLE -#define AKM_LOG(format, ...) ALOGD((format), ##__VA_ARGS__) -#else -#define AKM_LOG(format, ...) -#endif - -/***** Error output *******************************************/ -#define AKMERROR \ - ALOGE("%s:%d Error.", __FUNCTION__, __LINE__) - -#define AKMERROR_STR(api) \ - ALOGE("%s:%d %s Error (%s).", \ - __FUNCTION__, __LINE__, (api), strerror(errno)) - -/*** Type declaration *********************************************************/ - -/*** Global variables *********************************************************/ - -/*** Prototype of function ****************************************************/ - -#endif /* AKMD_INC_AKCOMMON_H */ - diff --git a/libsensors/akmdfs/AKFS_Compass.h b/libsensors/akmdfs/AKFS_Compass.h deleted file mode 100644 index aa59285..0000000 --- a/libsensors/akmdfs/AKFS_Compass.h +++ /dev/null @@ -1,84 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_COMPASS_H -#define AKFS_INC_COMPASS_H - -#include "AKFS_Common.h" -#include "AKFS_CSpec.h" - -/****************************************/ -/* Include files for AK8975 library. */ -/****************************************/ -#include "AKFS_AK8975.h" -#include "AKFS_Configure.h" -#include "AKFS_AOC.h" -#include "AKFS_Device.h" -#include "AKFS_Direction.h" -#include "AKFS_Math.h" -#include "AKFS_VNorm.h" - -/*** Constant definition ******************************************************/ - -/*** Type declaration *********************************************************/ -typedef struct _AKSENSOR_DATA{ - AKFLOAT x; - AKFLOAT y; - AKFLOAT z; - int8 status; -} AKSENSOR_DATA; - -/*! A parameter structure. */ -typedef struct _AK8975PRMS{ - /* Variables for Decomp8975. */ - AKFVEC mfv_hdata[AKFS_HDATA_SIZE]; - uint8vec mi_asa; - uint8 mi_st; - - /* Variables forAOC. */ - AKFS_AOC_VAR m_aocv; - - /* Variables for Magnetometer buffer. */ - AKFVEC mfv_hvbuf[AKFS_HDATA_SIZE]; - AKFVEC mfv_ho; - AKFVEC mfv_hs; - AKFS_PATNO m_hpat; - - /* Variables for Accelerometer buffer. */ - AKFVEC mfv_adata[AKFS_ADATA_SIZE]; - AKFVEC mfv_avbuf[AKFS_ADATA_SIZE]; - AKFVEC mfv_ao; - AKFVEC mfv_as; - - /* Variables for Direction. */ - int16 mi_hnaveD; - int16 mi_anaveD; - AKFLOAT mf_azimuth; - AKFLOAT mf_pitch; - AKFLOAT mf_roll; - - /* Variables for vector output */ - int16 mi_hnaveV; - int16 mi_anaveV; - AKFVEC mfv_hvec; - AKFVEC mfv_avec; - int16 mi_hstatus; - -} AK8975PRMS; - -#endif - diff --git a/libsensors/akmdfs/AKFS_Disp.c b/libsensors/akmdfs/AKFS_Disp.c deleted file mode 100644 index 4e7c501..0000000 --- a/libsensors/akmdfs/AKFS_Disp.c +++ /dev/null @@ -1,89 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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 "AKFS_Disp.h" -#include "AKFS_Common.h" - -/*! - Print startup message to Android Log daemon. - */ -void Disp_StartMessage(void) -{ - ALOGI("AK8975 Daemon for Open Source v20120329."); - ALOGI("Debug: %s", ((ENABLE_AKMDEBUG)?("ON"):("OFF"))); - ALOGI("Debug level: %d", DBG_LEVEL); -} - -/*! - Print ending message to Android Log daemon. - */ -void Disp_EndMessage(int ret) -{ - ALOGI("AK8975 for Android end (%d).", ret); -} - -/*! - Print result - */ -void Disp_Result(int buf[YPR_DATA_SIZE]) -{ - AKMDEBUG(DBG_LEVEL1, - "Flag=%d\n", buf[0]); - AKMDEBUG(DBG_LEVEL1, - "Acc(%d):%8.2f, %8.2f, %8.2f\n", - buf[4], REVERT_ACC(buf[1]), REVERT_ACC(buf[2]), REVERT_ACC(buf[3])); - AKMDEBUG(DBG_LEVEL1, - "Mag(%d):%8.2f, %8.2f, %8.2f\n", - buf[8], REVERT_MAG(buf[5]), REVERT_MAG(buf[6]), REVERT_MAG(buf[7])); - AKMDEBUG(DBG_LEVEL1, - "Ori(%d)=%8.2f, %8.2f, %8.2f\n", - buf[8], REVERT_ORI(buf[9]), REVERT_ORI(buf[10]), REVERT_ORI(buf[11])); -} - -/*! - Output main menu to stdout and wait for user input from stdin. - @return Selected mode. - */ -MODE Menu_Main(void) -{ - char msg[20]; - memset(msg, 0, sizeof(msg)); - - AKMDEBUG(DBG_LEVEL1, - " -------------------- AK8975 Console Application -------------------- \n" - " 1. Start measurement. \n" - " 2. Self-test. \n" - " Q. Quit application. \n" - " --------------------------------------------------------------------- \n" - " Please select a number.\n" - " ---> "); - fgets(msg, 10, stdin); - AKMDEBUG(DBG_LEVEL1, "\n"); - - /* BUG : If 2-digits number is input, */ - /* only the first character is compared. */ - if (!strncmp(msg, "1", 1)) { - return MODE_Measure; - } else if (!strncmp(msg, "2", 1)) { - return MODE_SelfTest; - } else if (strncmp(msg, "Q", 1) == 0 || strncmp(msg, "q", 1) == 0) { - return MODE_Quit; - } else { - return MODE_ERROR; - } -} - diff --git a/libsensors/akmdfs/AKFS_Disp.h b/libsensors/akmdfs/AKFS_Disp.h deleted file mode 100644 index 4769e3c..0000000 --- a/libsensors/akmdfs/AKFS_Disp.h +++ /dev/null @@ -1,52 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_DISP_H -#define AKFS_INC_DISP_H - -/* Include file for AK8975 library. */ -#include "AKFS_Compass.h" - -/*** Constant definition ******************************************************/ -#define REVERT_ACC(a) ((float)((a) * 9.8f / 720.0f)) -#define REVERT_MAG(m) ((float)((m) * 0.06f)) -#define REVERT_ORI(o) ((float)((o) / 64.0f)) - -/*** Type declaration *********************************************************/ - -/*! These defined types represents the current mode. */ -typedef enum _MODE { - MODE_ERROR, /*!< Error */ - MODE_Measure, /*!< Measurement */ - MODE_SelfTest, /*!< Self-test */ - MODE_Quit /*!< Quit */ -} MODE; - -/*** Prototype of function ****************************************************/ -/* - Disp_ : Display messages. - Menu_ : Display menu (two or more selection) and wait for user input. - */ - -void Disp_StartMessage(void); -void Disp_EndMessage(int ret); -void Disp_Result(int buf[YPR_DATA_SIZE]); - -MODE Menu_Main(void); - -#endif - diff --git a/libsensors/akmdfs/AKFS_FileIO.c b/libsensors/akmdfs/AKFS_FileIO.c deleted file mode 100644 index 92c2ce9..0000000 --- a/libsensors/akmdfs/AKFS_FileIO.c +++ /dev/null @@ -1,130 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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 "AKFS_FileIO.h" - -/*** Constant definition ******************************************************/ -#ifdef AKFS_PRECISION_DOUBLE -#define AKFS_SCANF_FORMAT "%63s = %lf" -#else -#define AKFS_SCANF_FORMAT "%63s = %f" -#endif -#define AKFS_PRINTF_FORMAT "%s = %f\n" -#define LOAD_BUF_SIZE 64 - -/*! - Load parameters from file which is specified with #path. This function reads - data from a beginning of the file line by line, and check parameter name - sequentially. In otherword, this function depends on the order of eache - parameter described in the file. - @return If function fails, the return value is #AKM_FAIL. When function fails, - the output is undefined. Therefore, parameters which are possibly overwritten - by this function should be initialized again. If function succeeds, the - return value is #AKM_SUCCESS. - @param[out] prms A pointer to #AK8975PRMS structure. Loaded parameter is - stored to the member of this structure. - @param[in] path A path to the setting file. - */ -int16 AKFS_LoadParameters(AK8975PRMS * prms, const char* path) -{ - int16 ret; - char buf[LOAD_BUF_SIZE]; - FILE *fp = NULL; - - /* Open setting file for read. */ - if ((fp = fopen(path, "r")) == NULL) { - AKMERROR_STR("fopen"); - return AKM_FAIL; - } - - ret = 1; - - /* Load data to HO */ - if (fscanf(fp, AKFS_SCANF_FORMAT, buf, &prms->mfv_ho.u.x) != 2) { - ret = 0; - } else { - if (strncmp(buf, "HO.x", sizeof(buf)) != 0) { - ret = 0; - } - } - if (fscanf(fp, AKFS_SCANF_FORMAT, buf, &prms->mfv_ho.u.y) != 2) { - ret = 0; - } else { - if (strncmp(buf, "HO.y", sizeof(buf)) != 0) { - ret = 0; - } - } - if (fscanf(fp, AKFS_SCANF_FORMAT, buf, &prms->mfv_ho.u.z) != 2) { - ret = 0; - } else { - if (strncmp(buf, "HO.z", sizeof(buf)) != 0) { - ret = 0; - } - } - - if (fclose(fp) != 0) { - AKMERROR_STR("fclose"); - ret = 0; - } - - if (ret == 0) { - AKMERROR; - return AKM_FAIL; - } - - return AKM_SUCCESS; -} - -/*! - Save parameters to file which is specified with #path. This function saves - variables when the offsets of magnetic sensor estimated successfully. - @return If function fails, the return value is #AKM_FAIL. When function fails, - the parameter file may collapsed. Therefore, the parameters file should be - discarded. If function succeeds, the return value is #AKM_SUCCESS. - @param[out] prms A pointer to #AK8975PRMS structure. Member variables are - saved to the parameter file. - @param[in] path A path to the setting file. - */ -int16 AKFS_SaveParameters(AK8975PRMS *prms, const char* path) -{ - int16 ret = 1; - FILE *fp; - - /*Open setting file for write. */ - if ((fp = fopen(path, "w")) == NULL) { - AKMERROR_STR("fopen"); - return AKM_FAIL; - } - - /* Save data to HO */ - if (fprintf(fp, AKFS_PRINTF_FORMAT, "HO.x", prms->mfv_ho.u.x) < 0) { ret = 0; } - if (fprintf(fp, AKFS_PRINTF_FORMAT, "HO.y", prms->mfv_ho.u.y) < 0) { ret = 0; } - if (fprintf(fp, AKFS_PRINTF_FORMAT, "HO.z", prms->mfv_ho.u.z) < 0) { ret = 0; } - - if (fclose(fp) != 0) { - AKMERROR_STR("fclose"); - ret = 0; - } - - if (ret == 0) { - AKMERROR; - return AKM_FAIL; - } - - return AKM_SUCCESS; -} - diff --git a/libsensors/akmdfs/AKFS_FileIO.h b/libsensors/akmdfs/AKFS_FileIO.h deleted file mode 100644 index 62f6e77..0000000 --- a/libsensors/akmdfs/AKFS_FileIO.h +++ /dev/null @@ -1,39 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_FILEIO_H -#define AKFS_INC_FILEIO_H - -/* Common include files. */ -#include "AKFS_Common.h" - -/* Include file for AK8975 library. */ -#include "AKFS_Compass.h" - -/*** Constant definition ******************************************************/ - -/*** Type declaration *********************************************************/ - -/*** Global variables *********************************************************/ - -/*** Prototype of function ****************************************************/ -int16 AKFS_LoadParameters(AK8975PRMS *prms, const char* path); - -int16 AKFS_SaveParameters(AK8975PRMS* prms, const char* path); - -#endif - diff --git a/libsensors/akmdfs/AKFS_Measure.c b/libsensors/akmdfs/AKFS_Measure.c deleted file mode 100644 index 84c0843..0000000 --- a/libsensors/akmdfs/AKFS_Measure.c +++ /dev/null @@ -1,410 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifdef WIN32 -#include "AK8975_LinuxDriver.h" -#else -#include "AK8975Driver.h" -#endif - -#include "AKFS_Measure.h" -#include "AKFS_Disp.h" -#include "AKFS_APIs.h" - -/*! - Read sensitivity adjustment data from fuse ROM. - @return If data are read successfully, the return value is #AKM_SUCCESS. - Otherwise the return value is #AKM_FAIL. - @param[out] regs The read ASA values. When this function succeeds, ASAX value - is saved in regs[0], ASAY is saved in regs[1], ASAZ is saved in regs[2]. - */ -int16 AKFS_ReadAK8975FUSEROM( - uint8 regs[3] -) -{ - /* Set to FUSE ROM access mode */ - if (AKD_SetMode(AK8975_MODE_FUSE_ACCESS) != AKD_SUCCESS) { - AKMERROR; - return AKM_FAIL; - } - - /* Read values. ASAX, ASAY, ASAZ */ - if (AKD_RxData(AK8975_FUSE_ASAX, regs, 3) != AKD_SUCCESS) { - AKMERROR; - return AKM_FAIL; - } - - /* Set to PowerDown mode */ - if (AKD_SetMode(AK8975_MODE_POWERDOWN) != AKD_SUCCESS) { - AKMERROR; - return AKM_FAIL; - } - - AKMDEBUG(DBG_LEVEL2, "%s: asa(dec)=%d,%d,%d\n", - __FUNCTION__, regs[0], regs[1], regs[2]); - - return AKM_SUCCESS; -} - -/*! - Carry out self-test. - @return If this function succeeds, the return value is #AKM_SUCCESS. - Otherwise the return value is #AKM_FAIL. - */ -int16 AKFS_SelfTest(void) -{ - BYTE i2cData[SENSOR_DATA_SIZE]; - BYTE asa[3]; - AKFLOAT hdata[3]; - int16 ret; - - /* Set to FUSE ROM access mode */ - if (AKD_SetMode(AK8975_MODE_FUSE_ACCESS) != AKD_SUCCESS) { - AKMERROR; - return AKM_FAIL; - } - - /* Read values from ASAX to ASAZ */ - if (AKD_RxData(AK8975_FUSE_ASAX, asa, 3) != AKD_SUCCESS) { - AKMERROR; - return AKM_FAIL; - } - - /* Set to PowerDown mode */ - if (AKD_SetMode(AK8975_MODE_POWERDOWN) != AKD_SUCCESS) { - AKMERROR; - return AKM_FAIL; - } - - /* Set to self-test mode */ - i2cData[0] = 0x40; - if (AKD_TxData(AK8975_REG_ASTC, i2cData, 1) != AKD_SUCCESS) { - AKMERROR; - return AKM_FAIL; - } - - /* Set to Self-test mode */ - if (AKD_SetMode(AK8975_MODE_SELF_TEST) != AKD_SUCCESS) { - AKMERROR; - return AKM_FAIL; - } - - /* - Wait for DRDY pin changes to HIGH. - Get measurement data from AK8975 - */ - if (AKD_GetMagneticData(i2cData) != AKD_SUCCESS) { - AKMERROR; - return AKM_FAIL; - } - - hdata[0] = AK8975_HDATA_CONVERTER(i2cData[2], i2cData[1], asa[0]); - hdata[1] = AK8975_HDATA_CONVERTER(i2cData[4], i2cData[3], asa[1]); - hdata[2] = AK8975_HDATA_CONVERTER(i2cData[6], i2cData[5], asa[2]); - - /* Test */ - ret = 1; - if ((hdata[0] < AK8975_SELFTEST_MIN_X) || - (AK8975_SELFTEST_MAX_X < hdata[0])) { - ret = 0; - } - if ((hdata[1] < AK8975_SELFTEST_MIN_Y) || - (AK8975_SELFTEST_MAX_Y < hdata[1])) { - ret = 0; - } - if ((hdata[2] < AK8975_SELFTEST_MIN_Z) || - (AK8975_SELFTEST_MAX_Z < hdata[2])) { - ret = 0; - } - - AKMDEBUG(DBG_LEVEL2, "Test(%s):%8.2f, %8.2f, %8.2f\n", - (ret ? "Success" : "fail"), hdata[0], hdata[1], hdata[2]); - - if (ret) { - return AKM_SUCCESS; - } else { - return AKM_FAIL; - } -} - -/*! - This function calculate the duration of sleep for maintaining - the loop keep the period. - This function calculates "minimum - (end - start)". - @return The result of above equation in nanosecond. - @param end The time of after execution. - @param start The time of before execution. - @param minimum Loop period of each execution. - */ -struct timespec AKFS_CalcSleep( - const struct timespec* end, - const struct timespec* start, - const int64_t minimum -) -{ - int64_t endL; - int64_t startL; - int64_t diff; - - struct timespec ret; - - endL = (end->tv_sec * 1000000000) + end->tv_nsec; - startL = (start->tv_sec * 1000000000) + start->tv_nsec; - diff = minimum; - - diff -= (endL - startL); - - /* Don't allow negative value */ - if (diff < 0) { - diff = 0; - } - - /* Convert to timespec */ - if (diff > 1000000000) { - ret.tv_sec = diff / 1000000000; - ret.tv_nsec = diff % 1000000000; - } else { - ret.tv_sec = 0; - ret.tv_nsec = diff; - } - return ret; -} - -/*! - Get interval of each sensors from device driver. - @return If this function succeeds, the return value is #AKM_SUCCESS. - Otherwise the return value is #AKM_FAIL. - @param flag This variable indicates what sensor frequency is updated. - @param minimum This value show the minimum loop period in all sensors. - */ -int16 AKFS_GetInterval( - uint16* flag, - int64_t* minimum -) -{ - /* Accelerometer, Magnetometer, Orientation */ - /* Delay is in nano second unit. */ - /* Negative value means the sensor is disabled.*/ - int64_t delay[AKM_NUM_SENSORS]; - int i; - - if (AKD_GetDelay(delay) < 0) { - AKMERROR; - return AKM_FAIL; - } - AKMDATA(AKMDATA_GETINTERVAL,"delay[A,M,O]=%lld,%lld,%lld\n", - delay[0], delay[1], delay[2]); - - /* update */ - *minimum = 1000000000; - *flag = 0; - for (i=0; i<AKM_NUM_SENSORS; i++) { - /* Set flag */ - if (delay[i] >= 0) { - *flag |= 1 << i; - if (*minimum > delay[i]) { - *minimum = delay[i]; - } - } - } - return AKM_SUCCESS; -} - -/*! - If this program run as console mode, measurement result will be displayed - on console terminal. - @return If this function succeeds, the return value is #AKM_SUCCESS. - Otherwise the return value is #AKM_FAIL. - */ -void AKFS_OutputResult( - const uint16 flag, - const AKSENSOR_DATA* acc, - const AKSENSOR_DATA* mag, - const AKSENSOR_DATA* ori -) -{ - int buf[YPR_DATA_SIZE]; - - /* Store to buffer */ - buf[0] = flag; /* Data flag */ - buf[1] = CONVERT_ACC(acc->x); /* Ax */ - buf[2] = CONVERT_ACC(acc->y); /* Ay */ - buf[3] = CONVERT_ACC(acc->z); /* Az */ - buf[4] = acc->status; /* Acc status */ - buf[5] = CONVERT_MAG(mag->x); /* Mx */ - buf[6] = CONVERT_MAG(mag->y); /* My */ - buf[7] = CONVERT_MAG(mag->z); /* Mz */ - buf[8] = mag->status; /* Mag status */ - buf[9] = CONVERT_ORI(ori->x); /* yaw */ - buf[10] = CONVERT_ORI(ori->y); /* pitch */ - buf[11] = CONVERT_ORI(ori->z); /* roll */ - - if (g_opmode & OPMODE_CONSOLE) { - /* Console mode */ - Disp_Result(buf); - } - - /* Set result to driver */ - AKD_SetYPR(buf); -} - -/*! - This is the main routine of measurement. - */ -void AKFS_MeasureLoop(void) -{ - BYTE i2cData[SENSOR_DATA_SIZE]; /* ST1 ~ ST2 */ - int16 mag[3]; - int16 mstat; - int16 acc[3]; - struct timespec tsstart= {0, 0}; - struct timespec tsend = {0, 0}; - struct timespec doze; - int64_t minimum; - uint16 flag; - AKSENSOR_DATA sv_acc; - AKSENSOR_DATA sv_mag; - AKSENSOR_DATA sv_ori; - AKFLOAT tmpx, tmpy, tmpz; - int16 tmp_accuracy; - - minimum = -1; - -#ifdef WIN32 - clock_init_time(); -#endif - - /* Initialize library functions and device */ - if (AKFS_Start(CSPEC_SETTING_FILE) != AKM_SUCCESS) { - AKMERROR; - goto MEASURE_END; - } - - while (g_stopRequest != AKM_TRUE) { - /* Beginning time */ - if (clock_gettime(CLOCK_MONOTONIC, &tsstart) < 0) { - AKMERROR; - goto MEASURE_END; - } - - /* Get interval */ - if (AKFS_GetInterval(&flag, &minimum) != AKM_SUCCESS) { - AKMERROR; - goto MEASURE_END; - } - - if ((flag & ACC_DATA_READY) || (flag & ORI_DATA_READY)) { - /* Get accelerometer */ - if (AKD_GetAccelerationData(acc) != AKD_SUCCESS) { - AKMERROR; - goto MEASURE_END; - } - - /* Calculate accelerometer vector */ - if (AKFS_Get_ACCELEROMETER(acc, 0, &tmpx, &tmpy, &tmpz, &tmp_accuracy) == AKM_SUCCESS) { - sv_acc.x = tmpx; - sv_acc.y = tmpy; - sv_acc.z = tmpz; - sv_acc.status = tmp_accuracy; - } else { - flag &= ~ACC_DATA_READY; - flag &= ~ORI_DATA_READY; - } - } - - if ((flag & MAG_DATA_READY) || (flag & ORI_DATA_READY)) { - /* Set to measurement mode */ - if (AKD_SetMode(AK8975_MODE_SNG_MEASURE) != AKD_SUCCESS) { - AKMERROR; - goto MEASURE_END; - } - - /* Wait for DRDY and get data from device */ - if (AKD_GetMagneticData(i2cData) != AKD_SUCCESS) { - AKMERROR; - goto MEASURE_END; - } - /* raw data to x,y,z value */ - mag[0] = (int)((int16_t)(i2cData[2]<<8)+((int16_t)i2cData[1])); - mag[1] = (int)((int16_t)(i2cData[4]<<8)+((int16_t)i2cData[3])); - mag[2] = (int)((int16_t)(i2cData[6]<<8)+((int16_t)i2cData[5])); - mstat = i2cData[0] | i2cData[7]; - - AKMDATA(AKMDATA_BDATA, - "bData=%02X,%02X,%02X,%02X,%02X,%02X,%02X,%02X\n", - i2cData[0], i2cData[1], i2cData[2], i2cData[3], - i2cData[4], i2cData[5], i2cData[6], i2cData[7]); - - /* Calculate magnetic field vector */ - if (AKFS_Get_MAGNETIC_FIELD(mag, mstat, &tmpx, &tmpy, &tmpz, &tmp_accuracy) == AKM_SUCCESS) { - sv_mag.x = tmpx; - sv_mag.y = tmpy; - sv_mag.z = tmpz; - sv_mag.status = tmp_accuracy; - } else { - flag &= ~MAG_DATA_READY; - flag &= ~ORI_DATA_READY; - } - } - - if (flag & ORI_DATA_READY) { - if (AKFS_Get_ORIENTATION(&tmpx, &tmpy, &tmpz, &tmp_accuracy) == AKM_SUCCESS) { - sv_ori.x = tmpx; - sv_ori.y = tmpy; - sv_ori.z = tmpz; - sv_ori.status = tmp_accuracy; - } else { - flag &= ~ORI_DATA_READY; - } - } - - /* Output result */ - AKFS_OutputResult(flag, &sv_acc, &sv_mag, &sv_ori); - - /* Ending time */ - if (clock_gettime(CLOCK_MONOTONIC, &tsend) < 0) { - AKMERROR; - goto MEASURE_END; - } - - /* Calculate duration */ - doze = AKFS_CalcSleep(&tsend, &tsstart, minimum); - AKMDATA(AKMDATA_LOOP, "Sleep: %6.2f msec\n", (doze.tv_nsec/1000000.0f)); - nanosleep(&doze, NULL); - -#ifdef WIN32 - if (_kbhit()) { - _getch(); - break; - } -#endif - } - -MEASURE_END: - /* Set to PowerDown mode */ - if (AKD_SetMode(AK8975_MODE_POWERDOWN) != AKD_SUCCESS) { - AKMERROR; - return; - } - - /* Save parameters */ - if (AKFS_Stop(CSPEC_SETTING_FILE) != AKM_SUCCESS) { - AKMERROR; - } -} - - diff --git a/libsensors/akmdfs/AKFS_Measure.h b/libsensors/akmdfs/AKFS_Measure.h deleted file mode 100644 index d156b95..0000000 --- a/libsensors/akmdfs/AKFS_Measure.h +++ /dev/null @@ -1,70 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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. - * - ******************************************************************************/ -#ifndef AKFS_INC_MEASURE_H -#define AKFS_INC_MEASURE_H - -/* Include files for AK8975 library. */ -#include "AKFS_Compass.h" - -/*** Constant definition ******************************************************/ -#define AK8975_SELFTEST_MIN_X -100 -#define AK8975_SELFTEST_MAX_X 100 - -#define AK8975_SELFTEST_MIN_Y -100 -#define AK8975_SELFTEST_MAX_Y 100 - -#define AK8975_SELFTEST_MIN_Z -1000 -#define AK8975_SELFTEST_MAX_Z -300 - -#define CONVERT_ACC(a) ((int)((a) * 720 / 9.8f)) -#define CONVERT_MAG(m) ((int)((m) / 0.06f)) -#define CONVERT_ORI(o) ((int)((o) * 64)) - -/*** Type declaration *********************************************************/ - -/*** Global variables *********************************************************/ - -/*** Prototype of function ****************************************************/ -int16 AKFS_ReadAK8975FUSEROM( - uint8 regs[3] -); - -int16 AKFS_SelfTest(void); - -struct timespec AKFS_CalcSleep( - const struct timespec* end, - const struct timespec* start, - const int64_t minimum -); - -int16 AKFS_GetInterval( - uint16* flag, - int64_t* minimum -); - -void AKFS_OutputResult( - const uint16 flag, - const AKSENSOR_DATA* acc, - const AKSENSOR_DATA* mag, - const AKSENSOR_DATA* ori -); - -void AKFS_MeasureLoop(void); - -#endif - diff --git a/libsensors/akmdfs/NOTICE b/libsensors/akmdfs/NOTICE deleted file mode 100644 index d645695..0000000 --- a/libsensors/akmdfs/NOTICE +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - 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. diff --git a/libsensors/akmdfs/Version.txt b/libsensors/akmdfs/Version.txt deleted file mode 100644 index 3d56b30..0000000 --- a/libsensors/akmdfs/Version.txt +++ /dev/null @@ -1,31 +0,0 @@ -Version - * Console Version 20120329 - 570 AK8975Driver.c - 496 AK8975Driver.h - 579 AKFS_APIs.c - 572 AKFS_APIs.h - 580 AKFS_APIs_8975/AKFS_AK8975.c - 580 AKFS_APIs_8975/AKFS_AK8975.h - 580 AKFS_APIs_8975/AKFS_AOC.c - 580 AKFS_APIs_8975/AKFS_AOC.h - 580 AKFS_APIs_8975/AKFS_Configure.h - 580 AKFS_APIs_8975/AKFS_Device.c - 580 AKFS_APIs_8975/AKFS_Device.h - 580 AKFS_APIs_8975/AKFS_Direction.c - 580 AKFS_APIs_8975/AKFS_Direction.h - 580 AKFS_APIs_8975/AKFS_Math.h - 580 AKFS_APIs_8975/AKFS_VNorm.c - 580 AKFS_APIs_8975/AKFS_VNorm.h - 568 AKFS_CSpec.h - 573 AKFS_Common.h - 572 AKFS_Compass.h - 579 AKFS_Disp.c - 568 AKFS_Disp.h - 568 AKFS_FileIO.c - 549 AKFS_FileIO.h - 573 AKFS_Measure.c - 568 AKFS_Measure.h - 574 Android.mk - 575 NOTICE - 579 main.c - diff --git a/libsensors/akmdfs/main.c b/libsensors/akmdfs/main.c deleted file mode 100644 index a3df0bc..0000000 --- a/libsensors/akmdfs/main.c +++ /dev/null @@ -1,293 +0,0 @@ -/****************************************************************************** - * - * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan - * - * 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 "AKFS_Common.h" -#include "AKFS_Compass.h" -#include "AKFS_Disp.h" -#include "AKFS_FileIO.h" -#include "AKFS_Measure.h" -#include "AKFS_APIs.h" - -#ifndef WIN32 -#include <sched.h> -#include <pthread.h> -#include <linux/input.h> -#endif - -#define ERROR_INITDEVICE (-1) -#define ERROR_OPTPARSE (-2) -#define ERROR_SELF_TEST (-3) -#define ERROR_READ_FUSE (-4) -#define ERROR_INIT (-5) -#define ERROR_GETOPEN_STAT (-6) -#define ERROR_STARTCLONE (-7) -#define ERROR_GETCLOSE_STAT (-8) - -/* Global variable. See AKFS_Common.h file. */ -int g_stopRequest = 0; -int g_opmode = 0; -int g_dbgzone = 0; -int g_mainQuit = AKD_FALSE; - -/* Static variable. */ -static pthread_t s_thread; /*!< Thread handle */ - -/*! - A thread function which is raised when measurement is started. - @param[in] args This parameter is not used currently. - */ -static void* thread_main(void* args) -{ - AKFS_MeasureLoop(); - return ((void*)0); -} - -/*! - Signal handler. This should be used only in DEBUG mode. - @param[in] sig Event - */ -static void signal_handler(int sig) -{ - if (sig == SIGINT) { - ALOGE("SIGINT signal"); - g_stopRequest = 1; - g_mainQuit = AKD_TRUE; - } -} - -/*! - Starts new thread. - @return If this function succeeds, the return value is 1. Otherwise, - the return value is 0. - */ -static int startClone(void) -{ - pthread_attr_t attr; - - pthread_attr_init(&attr); - g_stopRequest = 0; - if (pthread_create(&s_thread, &attr, thread_main, NULL) == 0) { - return 1; - } else { - return 0; - } -} - -/*! - This function parse the option. - @retval 1 Parse succeeds. - @retval 0 Parse failed. - @param[in] argc Argument count - @param[in] argv Argument vector - @param[out] layout_patno - */ -int OptParse( - int argc, - char* argv[], - AKFS_PATNO* layout_patno) -{ -#ifdef WIN32 - /* Static */ -#if defined(AKFS_WIN32_PAT1) - *layout_patno = PAT1; -#elif defined(AKFS_WIN32_PAT2) - *layout_patno = PAT2; -#elif defined(AKFS_WIN32_PAT3) - *layout_patno = PAT3; -#elif defined(AKFS_WIN32_PAT4) - *layout_patno = PAT4; -#elif defined(AKFS_WIN32_PAT5) - *layout_patno = PAT5; -#else - *layout_patno = PAT1; -#endif - g_opmode = OPMODE_CONSOLE; - /*g_opmode = 0;*/ - g_dbgzone = AKMDATA_LOOP | AKMDATA_TEST; -#else - int opt; - char optVal; - - *layout_patno = PAT_INVALID; - - while ((opt = getopt(argc, argv, "sm:z:")) != -1) { - switch(opt){ - case 'm': - optVal = (char)(optarg[0] - '0'); - if ((PAT1 <= optVal) && (optVal <= PAT8)) { - *layout_patno = (AKFS_PATNO)optVal; - AKMDEBUG(DBG_LEVEL2, "%s: Layout=%d\n", __FUNCTION__, optVal); - } - break; - case 's': - g_opmode |= OPMODE_CONSOLE; - break; - case 'z': - /* If error detected, hopefully 0 is returned. */ - errno = 0; - g_dbgzone = (int)strtol(optarg, (char**)NULL, 0); - AKMDEBUG(DBG_LEVEL2, "%s: Dbg Zone=%d\n", __FUNCTION__, g_dbgzone); - break; - default: - ALOGE("%s: Invalid argument", argv[0]); - return 0; - } - } - - /* If layout is not specified with argument, get parameter from driver */ - if (*layout_patno == PAT_INVALID) { - int16_t n; - if (AKD_GetLayout(&n) == AKM_SUCCESS) { - if ((PAT1 <= n) && (n <= PAT8)) { - *layout_patno = (AKFS_PATNO)n; - } - } - } - /* Error */ - if (*layout_patno == PAT_INVALID) { - ALOGE("No layout is specified."); - return 0; - } -#endif - - return 1; -} - -void ConsoleMode(void) -{ - /*** Console Mode *********************************************/ - while (AKD_TRUE) { - /* Select operation */ - switch (Menu_Main()) { - case MODE_SelfTest: - AKFS_SelfTest(); - break; - case MODE_Measure: - /* Reset flag */ - g_stopRequest = 0; - /* Measurement routine */ - AKFS_MeasureLoop(); - break; - - case MODE_Quit: - return; - - default: - AKMDEBUG(DBG_LEVEL0, "Unknown operation mode.\n"); - break; - } - } -} - -int main(int argc, char **argv) -{ - int retValue = 0; - AKFS_PATNO pat; - uint8 regs[3]; - - /* Show the version info of this software. */ - Disp_StartMessage(); - -#if ENABLE_AKMDEBUG - /* Register signal handler */ - signal(SIGINT, signal_handler); -#endif - - /* Open device driver */ - if(AKD_InitDevice() != AKD_SUCCESS) { - retValue = ERROR_INITDEVICE; - goto MAIN_QUIT; - } - - /* Parse command-line options */ - /* This function calls device driver function to get layout */ - if (OptParse(argc, argv, &pat) == 0) { - retValue = ERROR_OPTPARSE; - goto MAIN_QUIT; - } - - /* Self Test */ - if (g_opmode & OPMODE_FST){ - if (AKFS_SelfTest() != AKD_SUCCESS) { - retValue = ERROR_SELF_TEST; - goto MAIN_QUIT; - } - } - - /* OK, then start */ - if (AKFS_ReadAK8975FUSEROM(regs) != AKM_SUCCESS) { - retValue = ERROR_READ_FUSE; - goto MAIN_QUIT; - } - - /* Initialize library. */ - if (AKFS_Init(pat, regs) != AKM_SUCCESS) { - retValue = ERROR_INIT; - goto MAIN_QUIT; - } - - /* Start console mode */ - if (g_opmode & OPMODE_CONSOLE) { - ConsoleMode(); - goto MAIN_QUIT; - } - - /*** Start Daemon ********************************************/ - while (g_mainQuit == AKD_FALSE) { - int st = 0; - /* Wait until device driver is opened. */ - if (AKD_GetOpenStatus(&st) != AKD_SUCCESS) { - retValue = ERROR_GETOPEN_STAT; - goto MAIN_QUIT; - } - if (st == 0) { - ALOGI("Suspended."); - } else { - ALOGI("Compass Opened."); - /* Reset flag */ - g_stopRequest = 0; - /* Start measurement thread. */ - if (startClone() == 0) { - retValue = ERROR_STARTCLONE; - goto MAIN_QUIT; - } - - /* Wait until device driver is closed. */ - if (AKD_GetCloseStatus(&st) != AKD_SUCCESS) { - retValue = ERROR_GETCLOSE_STAT; - g_mainQuit = AKD_TRUE; - } - /* Wait thread completion. */ - g_stopRequest = 1; - pthread_join(s_thread, NULL); - ALOGI("Compass Closed."); - } - } - -MAIN_QUIT: - - /* Release library */ - AKFS_Release(); - /* Close device driver. */ - AKD_DeinitDevice(); - /* Show the last message. */ - Disp_EndMessage(retValue); - - return retValue; -} - - diff --git a/libsensors/cm36651_light.c b/libsensors/cm36651_light.c deleted file mode 100644 index 6781797..0000000 --- a/libsensors/cm36651_light.c +++ /dev/null @@ -1,264 +0,0 @@ -/* - * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr> - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - */ - -#include <stdlib.h> -#include <unistd.h> -#include <stdint.h> -#include <fcntl.h> -#include <errno.h> -#include <math.h> -#include <sys/types.h> -#include <linux/ioctl.h> -#include <linux/input.h> - -#include <hardware/sensors.h> -#include <hardware/hardware.h> - -#define LOG_TAG "smdk4x12_sensors" -#include <utils/Log.h> - -#include "smdk4x12_sensors.h" - -struct cm36651_light_data { - char path_enable[PATH_MAX]; - char path_delay[PATH_MAX]; -}; - -int cm36651_light_init(struct smdk4x12_sensors_handlers *handlers, - struct smdk4x12_sensors_device *device) -{ - struct cm36651_light_data *data = NULL; - char path[PATH_MAX] = { 0 }; - int input_fd = -1; - int rc; - - ALOGD("%s(%p, %p)", __func__, handlers, device); - - if (handlers == NULL) - return -EINVAL; - - data = (struct cm36651_light_data *) calloc(1, sizeof(struct cm36651_light_data)); - - input_fd = input_open("light_sensor"); - if (input_fd < 0) { - ALOGE("%s: Unable to open input", __func__); - goto error; - } - - rc = sysfs_path_prefix("light_sensor", (char *) &path); - if (rc < 0 || path[0] == '\0') { - ALOGE("%s: Unable to open sysfs", __func__); - goto error; - } - - snprintf(data->path_enable, PATH_MAX, "%s/enable", path); - snprintf(data->path_delay, PATH_MAX, "%s/poll_delay", path); - - handlers->poll_fd = input_fd; - handlers->data = (void *) data; - - return 0; - -error: - if (data != NULL) - free(data); - - if (input_fd >= 0) - close(input_fd); - - handlers->poll_fd = -1; - handlers->data = NULL; - - return -1; -} - -int cm36651_light_deinit(struct smdk4x12_sensors_handlers *handlers) -{ - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL) - return -EINVAL; - - if (handlers->poll_fd >= 0) - close(handlers->poll_fd); - handlers->poll_fd = -1; - - if (handlers->data != NULL) - free(handlers->data); - handlers->data = NULL; - - return 0; -} - -int cm36651_light_activate(struct smdk4x12_sensors_handlers *handlers) -{ - struct cm36651_light_data *data; - int rc; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct cm36651_light_data *) handlers->data; - - rc = sysfs_value_write(data->path_enable, 1); - if (rc < 0) { - ALOGE("%s: Unable to write sysfs value", __func__); - return -1; - } - - handlers->activated = 1; - - return 0; -} - -int cm36651_light_deactivate(struct smdk4x12_sensors_handlers *handlers) -{ - struct cm36651_light_data *data; - int rc; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct cm36651_light_data *) handlers->data; - - rc = sysfs_value_write(data->path_enable, 0); - if (rc < 0) { - ALOGE("%s: Unable to write sysfs value", __func__); - return -1; - } - - handlers->activated = 1; - - return 0; -} - -int cm36651_light_set_delay(struct smdk4x12_sensors_handlers *handlers, int64_t delay) -{ - struct cm36651_light_data *data; - int rc; - - ALOGD("%s(%p, %" PRId64 ")", __func__, handlers, delay); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct cm36651_light_data *) handlers->data; - - rc = sysfs_value_write(data->path_delay, delay); - if (rc < 0) { - ALOGE("%s: Unable to write sysfs value", __func__); - return -1; - } - - return 0; -} - -float cm36651_light_convert(int white, int green) -{ - float gwrel = 1.0f; - float aux; - float r1, r2, r3, r4; - - if (green <= 4) - return 0.0f; - else { - if (white > 0) - gwrel = (float) green / (float) white; - - r1 = floorf( (float) (pow((double) green, 1.3341) * 0.0258) ); - - aux = floorf( ((float) green * 0.18f * 9.44f) / gwrel); - r2 = aux; - r3 = aux * 0.77f; - - r4 = floorf( (float) green * ( (gwrel * 1.546) - 0.46) ); - - if (gwrel <= 0.5f) { - return r1; - } else if (gwrel >= 0.9f) { - if (white <= 5999) - return r2; - else - return r3; - } else { - return r4; - } - } -} - -int cm36651_light_get_data(struct smdk4x12_sensors_handlers *handlers, - struct sensors_event_t *event) -{ - struct input_event input_event; - int input_fd; - int green = 0; - int white = 0; - int rc; - -// ALOGD("%s(%p, %p)", __func__, handlers, event); - - if (handlers == NULL || event == NULL) - return -EINVAL; - - input_fd = handlers->poll_fd; - if (input_fd < 0) - return -EINVAL; - - memset(event, 0, sizeof(struct sensors_event_t)); - event->version = sizeof(struct sensors_event_t); - event->sensor = handlers->handle; - event->type = handlers->handle; - - do { - rc = read(input_fd, &input_event, sizeof(input_event)); - if (rc < (int) sizeof(input_event)) - break; - - if (input_event.type == EV_REL) { - if (input_event.code == REL_Y) - green = input_event.value; - if (input_event.code == REL_MISC) - white = input_event.value; - } else if (input_event.type == EV_SYN) { - if (input_event.code == SYN_REPORT) - event->timestamp = input_timestamp(&input_event); - } - } while (input_event.type != EV_SYN); - - event->light = cm36651_light_convert(white, green); - - return 0; -} - -struct smdk4x12_sensors_handlers cm36651_light = { - .name = "CM36651 Light", - .handle = SENSOR_TYPE_LIGHT, - .init = cm36651_light_init, - .deinit = cm36651_light_deinit, - .activate = cm36651_light_activate, - .deactivate = cm36651_light_deactivate, - .set_delay = cm36651_light_set_delay, - .get_data = cm36651_light_get_data, - .activated = 0, - .needed = 0, - .poll_fd = -1, - .data = NULL, -}; diff --git a/libsensors/cm36651_proximity.c b/libsensors/cm36651_proximity.c deleted file mode 100644 index 6529543..0000000 --- a/libsensors/cm36651_proximity.c +++ /dev/null @@ -1,213 +0,0 @@ -/* - * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr> - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - */ - -#include <stdlib.h> -#include <unistd.h> -#include <stdint.h> -#include <fcntl.h> -#include <errno.h> -#include <sys/types.h> -#include <linux/ioctl.h> -#include <linux/input.h> - -#include <hardware/sensors.h> -#include <hardware/hardware.h> - -#define LOG_TAG "smdk4x12_sensors" -#include <utils/Log.h> - -#include "smdk4x12_sensors.h" - -struct cm36651_proximity_data { - char path_enable[PATH_MAX]; -}; - -int cm36651_proximity_init(struct smdk4x12_sensors_handlers *handlers, - struct smdk4x12_sensors_device *device) -{ - struct cm36651_proximity_data *data = NULL; - char path[PATH_MAX] = { 0 }; - int input_fd = -1; - int rc; - - ALOGD("%s(%p, %p)", __func__, handlers, device); - - if (handlers == NULL) - return -EINVAL; - - data = (struct cm36651_proximity_data *) calloc(1, sizeof(struct cm36651_proximity_data)); - - input_fd = input_open("proximity_sensor"); - if (input_fd < 0) { - ALOGE("%s: Unable to open input", __func__); - goto error; - } - - rc = sysfs_path_prefix("proximity_sensor", (char *) &path); - if (rc < 0 || path[0] == '\0') { - ALOGE("%s: Unable to open sysfs", __func__); - goto error; - } - - snprintf(data->path_enable, PATH_MAX, "%s/enable", path); - - handlers->poll_fd = input_fd; - handlers->data = (void *) data; - - return 0; - -error: - if (data != NULL) - free(data); - - if (input_fd >= 0) - close(input_fd); - - handlers->poll_fd = -1; - handlers->data = NULL; - - return -1; -} - -int cm36651_proximity_deinit(struct smdk4x12_sensors_handlers *handlers) -{ - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL) - return -EINVAL; - - if (handlers->poll_fd >= 0) - close(handlers->poll_fd); - handlers->poll_fd = -1; - - if (handlers->data != NULL) - free(handlers->data); - handlers->data = NULL; - - return 0; -} - -int cm36651_proximity_activate(struct smdk4x12_sensors_handlers *handlers) -{ - struct cm36651_proximity_data *data; - int rc; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct cm36651_proximity_data *) handlers->data; - - rc = sysfs_value_write(data->path_enable, 1); - if (rc < 0) { - ALOGE("%s: Unable to write sysfs value", __func__); - return -1; - } - - handlers->activated = 1; - - return 0; -} - -int cm36651_proximity_deactivate(struct smdk4x12_sensors_handlers *handlers) -{ - struct cm36651_proximity_data *data; - int rc; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct cm36651_proximity_data *) handlers->data; - - rc = sysfs_value_write(data->path_enable, 0); - if (rc < 0) { - ALOGE("%s: Unable to write sysfs value", __func__); - return -1; - } - - handlers->activated = 1; - - return 0; -} - -int cm36651_proximity_set_delay(struct smdk4x12_sensors_handlers *handlers, int64_t delay) -{ - ALOGD("%s(%p, %" PRId64 ")", __func__, handlers, delay); - - return 0; -} - -float cm36651_proximity_convert(int value) -{ - return (float) value * 6.0f; -} - -int cm36651_proximity_get_data(struct smdk4x12_sensors_handlers *handlers, - struct sensors_event_t *event) -{ - struct input_event input_event; - int input_fd; - int rc; - -// ALOGD("%s(%p, %p)", __func__, handlers, event); - - if (handlers == NULL || event == NULL) - return -EINVAL; - - input_fd = handlers->poll_fd; - if (input_fd < 0) - return -EINVAL; - - memset(event, 0, sizeof(struct sensors_event_t)); - event->version = sizeof(struct sensors_event_t); - event->sensor = handlers->handle; - event->type = handlers->handle; - - do { - rc = read(input_fd, &input_event, sizeof(input_event)); - if (rc < (int) sizeof(input_event)) - break; - - if (input_event.type == EV_ABS) { - if (input_event.code == ABS_DISTANCE) - event->distance = cm36651_proximity_convert(input_event.value); - } else if (input_event.type == EV_SYN) { - if (input_event.code == SYN_REPORT) - event->timestamp = input_timestamp(&input_event); - } - } while (input_event.type != EV_SYN); - - return 0; -} - -struct smdk4x12_sensors_handlers cm36651_proximity = { - .name = "CM36651 Proximity", - .handle = SENSOR_TYPE_PROXIMITY, - .init = cm36651_proximity_init, - .deinit = cm36651_proximity_deinit, - .activate = cm36651_proximity_activate, - .deactivate = cm36651_proximity_deactivate, - .set_delay = cm36651_proximity_set_delay, - .get_data = cm36651_proximity_get_data, - .activated = 0, - .needed = 0, - .poll_fd = -1, - .data = NULL, -}; diff --git a/libsensors/input.c b/libsensors/input.c deleted file mode 100644 index da3d6d7..0000000 --- a/libsensors/input.c +++ /dev/null @@ -1,336 +0,0 @@ -/* - * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr> - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - */ - -#include <stdlib.h> -#include <unistd.h> -#include <stdint.h> -#include <fcntl.h> -#include <errno.h> -#include <dirent.h> -#include <linux/ioctl.h> -#include <linux/input.h> -#include <linux/uinput.h> - -#define LOG_TAG "smdk4x12_sensors" -#include <utils/Log.h> - -#include "smdk4x12_sensors.h" - -void input_event_set(struct input_event *event, int type, int code, int value) -{ - if (event == NULL) - return; - - memset(event, 0, sizeof(struct input_event)); - - event->type = type, - event->code = code; - event->value = value; - - gettimeofday(&event->time, NULL); -} - -int64_t timestamp(struct timeval *time) -{ - if (time == NULL) - return -1; - - return time->tv_sec * 1000000000LL + time->tv_usec * 1000; -} - -int64_t input_timestamp(struct input_event *event) -{ - if (event == NULL) - return -1; - - return timestamp(&event->time); -} - -int uinput_rel_create(const char *name) -{ - struct uinput_user_dev uinput_dev; - int uinput_fd; - int rc; - - if (name == NULL) - return -1; - - uinput_fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK); - if (uinput_fd < 0) { - ALOGE("%s: Unable to open uinput device", __func__); - goto error; - } - - memset(&uinput_dev, 0, sizeof(uinput_dev)); - - strncpy(uinput_dev.name, name, sizeof(uinput_dev.name)); - uinput_dev.id.bustype = BUS_I2C; - uinput_dev.id.vendor = 0; - uinput_dev.id.product = 0; - uinput_dev.id.version = 0; - - rc = 0; - rc |= ioctl(uinput_fd, UI_SET_EVBIT, EV_REL); - rc |= ioctl(uinput_fd, UI_SET_RELBIT, REL_X); - rc |= ioctl(uinput_fd, UI_SET_RELBIT, REL_Y); - rc |= ioctl(uinput_fd, UI_SET_RELBIT, REL_Z); - rc |= ioctl(uinput_fd, UI_SET_RELBIT, REL_MISC); - rc |= ioctl(uinput_fd, UI_SET_EVBIT, EV_SYN); - - if (rc < 0) { - ALOGE("%s: Unable to set uinput bits", __func__); - goto error; - } - - rc = write(uinput_fd, &uinput_dev, sizeof(uinput_dev)); - if (rc < 0) { - ALOGE("%s: Unable to write uinput device", __func__); - goto error; - } - - rc = ioctl(uinput_fd, UI_DEV_CREATE); - if (rc < 0) { - ALOGE("%s: Unable to create uinput device", __func__); - goto error; - } - - usleep(3000); - - return uinput_fd; - -error: - if (uinput_fd >= 0) - close(uinput_fd); - - return -1; -} - -void uinput_destroy(int uinput_fd) -{ - if (uinput_fd < 0) - return; - - ioctl(uinput_fd, UI_DEV_DESTROY); -} - -int input_open(char *name) -{ - DIR *d; - struct dirent *di; - - char input_name[80] = { 0 }; - char path[PATH_MAX]; - char *c; - int fd; - int rc; - - if (name == NULL) - return -EINVAL; - - d = opendir("/dev/input"); - if (d == NULL) - return -1; - - while ((di = readdir(d))) { - if (di == NULL || strcmp(di->d_name, ".") == 0 || strcmp(di->d_name, "..") == 0) - continue; - - snprintf(path, PATH_MAX, "/dev/input/%s", di->d_name); - fd = open(path, O_RDONLY | O_NONBLOCK); - if (fd < 0) - continue; - - rc = ioctl(fd, EVIOCGNAME(sizeof(input_name) - 1), &input_name); - if (rc < 0) - continue; - - c = strstr((char *) &input_name, "\n"); - if (c != NULL) - *c = '\0'; - - if (strcmp(input_name, name) == 0) - return fd; - else - close(fd); - } - - return -1; -} - -int sysfs_path_prefix(char *name, char *path_prefix) -{ - DIR *d; - struct dirent *di; - - char input_name[80] = { 0 }; - char path[PATH_MAX]; - char *c; - int fd; - - if (name == NULL || path_prefix == NULL) - return -EINVAL; - - d = opendir("/sys/class/input"); - if (d == NULL) - return -1; - - while ((di = readdir(d))) { - if (di == NULL || strcmp(di->d_name, ".") == 0 || strcmp(di->d_name, "..") == 0) - continue; - - snprintf(path, PATH_MAX, "/sys/class/input/%s/name", di->d_name); - - fd = open(path, O_RDONLY); - if (fd < 0) - continue; - - read(fd, &input_name, sizeof(input_name)); - close(fd); - - c = strstr((char *) &input_name, "\n"); - if (c != NULL) - *c = '\0'; - - if (strcmp(input_name, name) == 0) { - snprintf(path_prefix, PATH_MAX, "/sys/class/input/%s", di->d_name); - return 0; - } - } - - return -1; -} - -int64_t sysfs_value_read(char *path) -{ - char buffer[100]; - int64_t value; - int fd = -1; - int rc; - - if (path == NULL) - return -1; - - fd = open(path, O_RDONLY); - if (fd < 0) - goto error; - - rc = read(fd, &buffer, sizeof(buffer)); - if (rc <= 0) - goto error; - - value = (int64_t)strtoimax(buffer, NULL, 10); - goto complete; - -error: - value = -1; - -complete: - if (fd >= 0) - close(fd); - - return value; -} - -int sysfs_value_write(char *path, int64_t value) -{ - char buffer[100]; - int fd = -1; - int rc; - - if (path == NULL) - return -1; - - fd = open(path, O_WRONLY); - if (fd < 0) - goto error; - - snprintf((char *) &buffer, sizeof(buffer), "%" PRId64 "\n", value); - - rc = write(fd, buffer, strlen(buffer)); - if (rc < (int) strlen(buffer)) - goto error; - - rc = 0; - goto complete; - -error: - rc = -1; - -complete: - if (fd >= 0) - close(fd); - - return rc; -} - -int sysfs_string_read(char *path, char *buffer, size_t length) -{ - int fd = -1; - int rc; - - if (path == NULL || buffer == NULL || length == 0) - return -1; - - fd = open(path, O_RDONLY); - if (fd < 0) - goto error; - - rc = read(fd, buffer, length); - if (rc <= 0) - goto error; - - rc = 0; - goto complete; - -error: - rc = -1; - -complete: - if (fd >= 0) - close(fd); - - return rc; -} - -int sysfs_string_write(char *path, char *buffer, size_t length) -{ - int fd = -1; - int rc; - - if (path == NULL || buffer == NULL || length == 0) - return -1; - - fd = open(path, O_WRONLY); - if (fd < 0) - goto error; - - rc = write(fd, buffer, length); - if (rc <= 0) - goto error; - - rc = 0; - goto complete; - -error: - rc = -1; - -complete: - if (fd >= 0) - close(fd); - - return rc; -} diff --git a/libsensors/lps331ap.c b/libsensors/lps331ap.c deleted file mode 100644 index a8ef55a..0000000 --- a/libsensors/lps331ap.c +++ /dev/null @@ -1,244 +0,0 @@ -/* - * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr> - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - */ - -#include <stdlib.h> -#include <unistd.h> -#include <stdint.h> -#include <fcntl.h> -#include <errno.h> -#include <math.h> -#include <sys/types.h> -#include <linux/ioctl.h> -#include <linux/input.h> - -#include <hardware/sensors.h> -#include <hardware/hardware.h> - -#define LOG_TAG "smdk4x12_sensors" -#include <utils/Log.h> - -#include "smdk4x12_sensors.h" - -struct lps331ap_data { - char path_enable[PATH_MAX]; - char path_delay[PATH_MAX]; -}; - -int lps331ap_init(struct smdk4x12_sensors_handlers *handlers, - struct smdk4x12_sensors_device *device) -{ - struct lps331ap_data *data = NULL; - char path[PATH_MAX] = { 0 }; - int input_fd = -1; - int rc; - - ALOGD("%s(%p, %p)", __func__, handlers, device); - - if (handlers == NULL) - return -EINVAL; - - data = (struct lps331ap_data *) calloc(1, sizeof(struct lps331ap_data)); - - input_fd = input_open("barometer_sensor"); - if (input_fd < 0) { - ALOGE("%s: Unable to open input", __func__); - goto error; - } - - rc = sysfs_path_prefix("barometer_sensor", (char *) &path); - if (rc < 0 || path[0] == '\0') { - ALOGE("%s: Unable to open sysfs", __func__); - goto error; - } - - snprintf(data->path_enable, PATH_MAX, "%s/enable", path); - snprintf(data->path_delay, PATH_MAX, "%s/poll_delay", path); - - handlers->poll_fd = input_fd; - handlers->data = (void *) data; - - return 0; - -error: - if (data != NULL) - free(data); - - if (input_fd >= 0) - close(input_fd); - - handlers->poll_fd = -1; - handlers->data = NULL; - - return -1; -} - -int lps331ap_deinit(struct smdk4x12_sensors_handlers *handlers) -{ - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL) - return -EINVAL; - - if (handlers->poll_fd >= 0) - close(handlers->poll_fd); - handlers->poll_fd = -1; - - if (handlers->data != NULL) - free(handlers->data); - handlers->data = NULL; - - return 0; -} - -int lps331ap_activate(struct smdk4x12_sensors_handlers *handlers) -{ - struct lps331ap_data *data; - int rc; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct lps331ap_data *) handlers->data; - - rc = sysfs_value_write(data->path_enable, 1); - if (rc < 0) { - ALOGE("%s: Unable to write sysfs value", __func__); - return -1; - } - - handlers->activated = 1; - - return 0; -} - -int lps331ap_deactivate(struct smdk4x12_sensors_handlers *handlers) -{ - struct lps331ap_data *data; - int rc; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct lps331ap_data *) handlers->data; - - rc = sysfs_value_write(data->path_enable, 0); - if (rc < 0) { - ALOGE("%s: Unable to write sysfs value", __func__); - return -1; - } - - handlers->activated = 1; - - return 0; -} - -int lps331ap_set_delay(struct smdk4x12_sensors_handlers *handlers, int64_t delay) -{ - struct lps331ap_data *data; - int rc; - - ALOGD("%s(%p, %" PRId64 ")", __func__, handlers, delay); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct lps331ap_data *) handlers->data; - - if (delay < 10000000) - delay = 10; - else - delay = delay / 1000000; - - rc = sysfs_value_write(data->path_delay, delay); - if (rc < 0) { - ALOGE("%s: Unable to write sysfs value", __func__); - return -1; - } - - return 0; -} - -float lps331ap_convert(int value) -{ - return value / 4096.0f; -} - -int lps331ap_get_data(struct smdk4x12_sensors_handlers *handlers, - struct sensors_event_t *event) -{ - struct input_event input_event; - int input_fd; - int rc; - -// ALOGD("%s(%p, %p)", __func__, handlers, event); - - if (handlers == NULL || event == NULL) - return -EINVAL; - - input_fd = handlers->poll_fd; - if (input_fd < 0) - return -EINVAL; - - memset(event, 0, sizeof(struct sensors_event_t)); - event->version = sizeof(struct sensors_event_t); - event->sensor = handlers->handle; - event->type = handlers->handle; - - do { - rc = read(input_fd, &input_event, sizeof(input_event)); - if (rc < (int) sizeof(input_event)) - break; - - if (input_event.type == EV_REL) { - switch (input_event.code) { - case REL_X: - event->pressure = lps331ap_convert(input_event.value); - break; - default: - continue; - } - } else if (input_event.type == EV_SYN) { - if (input_event.code == SYN_REPORT && event->pressure != 0) { - event->timestamp = input_timestamp(&input_event); - break; - } else { - return -1; - } - } - } while (1); - - return 0; -} - -struct smdk4x12_sensors_handlers lps331ap = { - .name = "LPS331AP", - .handle = SENSOR_TYPE_PRESSURE, - .init = lps331ap_init, - .deinit = lps331ap_deinit, - .activate = lps331ap_activate, - .deactivate = lps331ap_deactivate, - .set_delay = lps331ap_set_delay, - .get_data = lps331ap_get_data, - .activated = 0, - .needed = 0, - .poll_fd = -1, - .data = NULL, -}; diff --git a/libsensors/lsm330dlc_accel.h b/libsensors/lsm330dlc_accel.h deleted file mode 100644 index ff5f666..0000000 --- a/libsensors/lsm330dlc_accel.h +++ /dev/null @@ -1,185 +0,0 @@ -/* - * Copyright (C) 2011, Samsung Electronics Co. Ltd. All Rights Reserved. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - */ - -#ifndef __LSM330DLC_ACCEL_HEADER__ -#define __LSM330DLC_ACCEL_HEADER__ - -#include <linux/types.h> -#include <linux/ioctl.h> - -/*lsm330dlc_accel registers */ -#define STATUS_AUX 0x07 -#define OUT_1_L 0x08 -#define OUT_1_H 0x09 -#define OUT_2_L 0x0A -#define OUT_2_H 0x0B -#define OUT_3_L 0x0C -#define OUT_3_H 0x0D -#define INT_COUNTER 0x0E -#define WHO_AM_I 0x0F -#define TEMP_CFG_REG 0x1F -#define CTRL_REG1 0x20 /* power control reg */ -#define CTRL_REG2 0x21 /* power control reg */ -#define CTRL_REG3 0x22 /* power control reg */ -#define CTRL_REG4 0x23 /* interrupt control reg */ -#define CTRL_REG5 0x24 /* interrupt control reg */ -#define CTRL_REG6 0x25 -#define REFERENCE 0x26 -#define STATUS_REG 0x27 -#define OUT_X_L 0x28 -#define OUT_X_H 0x29 -#define OUT_Y_L 0x2A -#define OUT_Y_H 0x2B -#define OUT_Z_L 0x2C -#define OUT_Z_H 0x2D -#define FIFO_CTRL_REG 0x2E -#define FIFO_SRC_REG 0x2F -#define INT1_CFG 0x30 -#define INT1_SRC 0x31 -#define INT1_THS 0x32 -#define INT1_DURATION 0x33 -#define INT2_CFG 0x34 -#define INT2_SRC 0x35 -#define INT2_THS 0x36 -#define INT2_DURATION 0x37 -#define CLICK_CFG 0x38 -#define CLICK_SRC 0x39 -#define CLICK_THS 0x3A -#define TIME_LIMIT 0x3B -#define TIME_LATENCY 0x3C -#define TIME_WINDOW 0x3D - -/* CTRL_REG1 */ -#define CTRL_REG1_ODR3 (1 << 7) -#define CTRL_REG1_ODR2 (1 << 6) -#define CTRL_REG1_ODR1 (1 << 5) -#define CTRL_REG1_ODR0 (1 << 4) -#define CTRL_REG1_LPEN (1 << 3) -#define CTRL_REG1_Zen (1 << 2) -#define CTRL_REG1_Yen (1 << 1) -#define CTRL_REG1_Xen (1 << 0) - -#define PM_OFF 0x00 -#define LOW_PWR_MODE 0x4F /* 50HZ */ -#define FASTEST_MODE 0x9F /* 1344Hz */ -#define ENABLE_ALL_AXES 0x07 - -#define ODR1 0x10 /* 1Hz output data rate */ -#define ODR10 0x20 /* 10Hz output data rate */ -#define ODR25 0x30 /* 25Hz output data rate */ -#define ODR50 0x40 /* 50Hz output data rate */ -#define ODR100 0x50 /* 100Hz output data rate */ -#define ODR200 0x60 /* 100Hz output data rate */ -#define ODR400 0x70 /* 400Hz output data rate */ -#define ODR1344 0x90 /* 1344Hz output data rate */ -#define ODR_MASK 0xf0 - -/* CTRL_REG2 */ -#define CTRL_REG2_HPM1 (1 << 7) -#define CTRL_REG2_HPM0 (1 << 6) -#define CTRL_REG2_HPCF2 (1 << 5) -#define CTRL_REG2_HPCF1 (1 << 4) -#define CTRL_REG2_FDS (1 << 3) -#define CTRL_REG2_HPPCLICK (1 << 2) -#define CTRL_REG2_HPIS2 (1 << 1) -#define CTRL_REG2_HPIS1 (1 << 0) - -#define HPM_Normal (CTRL_REG2_HPM1) -#define HPM_Filter (CTRL_REG2_HPM0) - -/* CTRL_REG3 */ -#define I1_CLICK (1 << 7) -#define I1_AOI1 (1 << 6) -#define I1_AOI2 (1 << 5) -#define I1_DRDY1 (1 << 4) -#define I1_DRDY2 (1 << 3) -#define I1_WTM (1 << 2) -#define I1_OVERRUN (1 << 1) - -/* CTRL_REG4 */ -#define CTRL_REG4_BLE (1 << 6) -#define CTRL_REG4_FS1 (1 << 5) -#define CTRL_REG4_FS0 (1 << 4) -#define CTRL_REG4_HR (1 << 3) -#define CTRL_REG4_ST1 (1 << 2) -#define CTRL_REG4_ST0 (1 << 1) -#define CTRL_REG4_SIM (1 << 0) - -#define FS2g 0x00 -#define FS4g (CTRL_REG4_FS0) -#define FS8g (CTRL_REG4_FS1) -#define FS16g (CTRL_REG4_FS1|CTRL_REG4_FS0) - -/* CTRL_REG5 */ -#define BOOT (1 << 7) -#define FIFO_EN (1 << 6) -#define LIR_INT1 (1 << 3) -#define D4D_INT1 (1 << 2) - -/* STATUS_REG */ -#define ZYXOR (1 << 7) -#define ZOR (1 << 6) -#define YOR (1 << 5) -#define XOR (1 << 4) -#define ZYXDA (1 << 3) -#define ZDA (1 << 2) -#define YDA (1 << 1) -#define XDA (1 << 0) - -/* INT1_CFG */ -#define INT_CFG_AOI (1 << 7) -#define INT_CFG_6D (1 << 6) -#define INT_CFG_ZHIE (1 << 5) -#define INT_CFG_ZLIE (1 << 4) -#define INT_CFG_YHIE (1 << 3) -#define INT_CFG_YLIE (1 << 2) -#define INT_CFG_XHIE (1 << 1) -#define INT_CFG_XLIE (1 << 0) - -/* INT1_SRC */ -#define IA (1 << 6) -#define ZH (1 << 5) -#define ZL (1 << 4) -#define YH (1 << 3) -#define YL (1 << 2) -#define XH (1 << 1) -#define XL (1 << 0) - -/* Register Auto-increase */ -#define AC (1 << 7) - -/* dev info */ -#define ACC_DEV_NAME "accelerometer" - -struct lsm330dlc_acc { - __s16 x; - __s16 y; - __s16 z; -}; - -/* For movement recognition*/ -#define USES_MOVEMENT_RECOGNITION - -/* LSM330DLC_ACCEL ioctl command label */ -#define LSM330DLC_ACCEL_IOCTL_BASE 'a' -#define LSM330DLC_ACCEL_IOCTL_SET_DELAY \ - _IOW(LSM330DLC_ACCEL_IOCTL_BASE, 0, int64_t) -#define LSM330DLC_ACCEL_IOCTL_GET_DELAY \ - _IOR(LSM330DLC_ACCEL_IOCTL_BASE, 1, int64_t) -#define LSM330DLC_ACCEL_IOCTL_READ_XYZ\ - _IOR(LSM330DLC_ACCEL_IOCTL_BASE, 8, struct lsm330dlc_acc) -#define LSM330DLC_ACCEL_IOCTL_SET_ENABLE \ - _IOW(LSM330DLC_ACCEL_IOCTL_BASE, 9, int) -#endif diff --git a/libsensors/lsm330dlc_acceleration.c b/libsensors/lsm330dlc_acceleration.c deleted file mode 100644 index 7f6985b..0000000 --- a/libsensors/lsm330dlc_acceleration.c +++ /dev/null @@ -1,390 +0,0 @@ -/* - * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr> - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - */ - -#include <stdlib.h> -#include <unistd.h> -#include <stdint.h> -#include <fcntl.h> -#include <errno.h> - -#include <hardware/sensors.h> -#include <hardware/hardware.h> - -#define LOG_TAG "smdk4x12_sensors" -#include <utils/Log.h> - -#include "smdk4x12_sensors.h" -#include "lsm330dlc_accel.h" - -struct lsm330dlc_acceleration_data { - int64_t delay; - int device_fd; - int uinput_fd; - - pthread_t thread; - pthread_mutex_t mutex; - int thread_continue; -}; - -void *lsm330dlc_acceleration_thread(void *thread_data) -{ - struct smdk4x12_sensors_handlers *handlers = NULL; - struct lsm330dlc_acceleration_data *data = NULL; - struct input_event event; - struct timeval time; - struct lsm330dlc_acc acceleration_data; - int64_t before, after; - int diff; - int device_fd; - int uinput_fd; - int rc; - - if (thread_data == NULL) - return NULL; - - handlers = (struct smdk4x12_sensors_handlers *) thread_data; - if (handlers->data == NULL) - return NULL; - - data = (struct lsm330dlc_acceleration_data *) handlers->data; - - device_fd = data->device_fd; - if (device_fd < 0) - return NULL; - - uinput_fd = data->uinput_fd; - if (uinput_fd < 0) - return NULL; - - while (data->thread_continue) { - pthread_mutex_lock(&data->mutex); - if (!data->thread_continue) - break; - - while (handlers->activated) { - gettimeofday(&time, NULL); - before = timestamp(&time); - - memset(&acceleration_data, 0, sizeof(acceleration_data)); - - rc = ioctl(device_fd, LSM330DLC_ACCEL_IOCTL_READ_XYZ, &acceleration_data); - if (rc < 0) { - ALOGE("%s: Unable to get lsm330dlc acceleration data", __func__); - return NULL; - } - - input_event_set(&event, EV_REL, REL_X, (int) (acceleration_data.x * 1000)); - write(uinput_fd, &event, sizeof(event)); - input_event_set(&event, EV_REL, REL_Y, (int) (acceleration_data.y * 1000)); - write(uinput_fd, &event, sizeof(event)); - input_event_set(&event, EV_REL, REL_Z, (int) (acceleration_data.z * 1000)); - write(uinput_fd, &event, sizeof(event)); - input_event_set(&event, EV_SYN, 0, 0); - write(uinput_fd, &event, sizeof(event)); - -next: - gettimeofday(&time, NULL); - after = timestamp(&time); - - diff = (int) (data->delay - (after - before)) / 1000; - if (diff <= 0) - continue; - - usleep(diff); - } - } - return NULL; -} - -int lsm330dlc_acceleration_init(struct smdk4x12_sensors_handlers *handlers, - struct smdk4x12_sensors_device *device) -{ - struct lsm330dlc_acceleration_data *data = NULL; - pthread_attr_t thread_attr; - int device_fd = -1; - int uinput_fd = -1; - int input_fd = -1; - int rc; - int i; - - ALOGD("%s(%p, %p)", __func__, handlers, device); - - if (handlers == NULL || device == NULL) - return -EINVAL; - - data = (struct lsm330dlc_acceleration_data *) calloc(1, sizeof(struct lsm330dlc_acceleration_data)); - - device_fd = open("/dev/accelerometer", O_RDONLY); - if (device_fd < 0) { - ALOGE("%s: Unable to open device", __func__); - goto error; - } - - uinput_fd = uinput_rel_create("acceleration"); - if (uinput_fd < 0) { - ALOGD("%s: Unable to create uinput", __func__); - goto error; - } - - input_fd = input_open("acceleration"); - if (input_fd < 0) { - ALOGE("%s: Unable to open acceleration input", __func__); - goto error; - } - - data->thread_continue = 1; - - pthread_mutex_init(&data->mutex, NULL); - pthread_mutex_lock(&data->mutex); - - pthread_attr_init(&thread_attr); - pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); - - rc = pthread_create(&data->thread, &thread_attr, lsm330dlc_acceleration_thread, (void *) handlers); - if (rc < 0) { - ALOGE("%s: Unable to create lsm330dlc acceleration thread", __func__); - pthread_mutex_destroy(&data->mutex); - goto error; - } - - data->device_fd = device_fd; - data->uinput_fd = uinput_fd; - handlers->poll_fd = input_fd; - handlers->data = (void *) data; - - return 0; - -error: - if (data != NULL) - free(data); - - if (uinput_fd >= 0) - close(uinput_fd); - - if (input_fd >= 0) - close(input_fd); - - if (device_fd >= 0) - close(device_fd); - - handlers->poll_fd = -1; - handlers->data = NULL; - - return -1; -} - -int lsm330dlc_acceleration_deinit(struct smdk4x12_sensors_handlers *handlers) -{ - struct lsm330dlc_acceleration_data *data = NULL; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct lsm330dlc_acceleration_data *) handlers->data; - - handlers->activated = 0; - data->thread_continue = 0; - pthread_mutex_unlock(&data->mutex); - - pthread_mutex_destroy(&data->mutex); - - if (data->uinput_fd >= 0) { - uinput_destroy(data->uinput_fd); - close(data->uinput_fd); - } - data->uinput_fd = -1; - - if (handlers->poll_fd >= 0) - close(handlers->poll_fd); - handlers->poll_fd = -1; - - if (data->device_fd >= 0) - close(data->device_fd); - data->device_fd = -1; - - free(handlers->data); - handlers->data = NULL; - - return 0; -} - -int lsm330dlc_acceleration_activate(struct smdk4x12_sensors_handlers *handlers) -{ - struct lsm330dlc_acceleration_data *data; - int device_fd; - int enable; - int rc; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct lsm330dlc_acceleration_data *) handlers->data; - - device_fd = data->device_fd; - if (device_fd < 0) - return -1; - - enable = 1; - rc = ioctl(device_fd, LSM330DLC_ACCEL_IOCTL_SET_ENABLE, &enable); - if (rc < 0) { - ALOGE("%s: Unable to set lsm330dlc acceleration enable", __func__); - return -1; - } - - handlers->activated = 1; - pthread_mutex_unlock(&data->mutex); - - return 0; -} - -int lsm330dlc_acceleration_deactivate(struct smdk4x12_sensors_handlers *handlers) -{ - struct lsm330dlc_acceleration_data *data; - int device_fd; - int enable; - int rc; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct lsm330dlc_acceleration_data *) handlers->data; - - device_fd = data->device_fd; - if (device_fd < 0) - return -1; - - enable = 0; - rc = ioctl(device_fd, LSM330DLC_ACCEL_IOCTL_SET_ENABLE, &enable); - if (rc < 0) { - ALOGE("%s: Unable to set lsm330dlc acceleration enable", __func__); - return -1; - } - - handlers->activated = 0; - - return 0; -} - -int lsm330dlc_acceleration_set_delay(struct smdk4x12_sensors_handlers *handlers, int64_t delay) -{ - struct lsm330dlc_acceleration_data *data; - int64_t d; - int device_fd; - int rc; - - ALOGD("%s(%p, %" PRId64 ")", __func__, handlers, delay); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct lsm330dlc_acceleration_data *) handlers->data; - - device_fd = data->device_fd; - if (device_fd < 0) - return -1; - - d = (int64_t) delay; - rc = ioctl(device_fd, LSM330DLC_ACCEL_IOCTL_SET_DELAY, &d); - if (rc < 0) { - ALOGE("%s: Unable to set lsm330dlc acceleration delay", __func__); - return -1; - } - - data->delay = delay; - - return 0; -} - -float lsm330dlc_acceleration_convert(int value) -{ - return (float) (value / 1000.f) * (GRAVITY_EARTH / 1024.0f); -} - -int lsm330dlc_acceleration_get_data(struct smdk4x12_sensors_handlers *handlers, - struct sensors_event_t *event) -{ - struct lsm330dlc_acceleration_data *data; - struct input_event input_event; - int input_fd; - int rc; - -// ALOGD("%s(%p, %p)", __func__, handlers, event); - - if (handlers == NULL || handlers->data == NULL || event == NULL) - return -EINVAL; - - data = (struct lsm330dlc_acceleration_data *) handlers->data; - - input_fd = handlers->poll_fd; - if (input_fd < 0) - return -1; - - memset(event, 0, sizeof(struct sensors_event_t)); - event->version = sizeof(struct sensors_event_t); - event->sensor = handlers->handle; - event->type = handlers->handle; - - event->acceleration.status = SENSOR_STATUS_ACCURACY_MEDIUM; - - do { - rc = read(input_fd, &input_event, sizeof(input_event)); - if (rc < (int) sizeof(input_event)) - break; - - if (input_event.type == EV_REL) { - switch (input_event.code) { - case REL_X: - event->acceleration.x = lsm330dlc_acceleration_convert(input_event.value); - break; - case REL_Y: - event->acceleration.y = lsm330dlc_acceleration_convert(input_event.value); - break; - case REL_Z: - event->acceleration.z = lsm330dlc_acceleration_convert(input_event.value); - break; - default: - continue; - } - } else if (input_event.type == EV_SYN) { - if (input_event.code == SYN_REPORT) - event->timestamp = input_timestamp(&input_event); - } - } while (input_event.type != EV_SYN); - - return 0; -} - -struct smdk4x12_sensors_handlers lsm330dlc_acceleration = { - .name = "LSM330DLC Acceleration", - .handle = SENSOR_TYPE_ACCELEROMETER, - .init = lsm330dlc_acceleration_init, - .deinit = lsm330dlc_acceleration_deinit, - .activate = lsm330dlc_acceleration_activate, - .deactivate = lsm330dlc_acceleration_deactivate, - .set_delay = lsm330dlc_acceleration_set_delay, - .get_data = lsm330dlc_acceleration_get_data, - .activated = 0, - .needed = 0, - .poll_fd = -1, - .data = NULL, -}; diff --git a/libsensors/lsm330dlc_gyroscope.c b/libsensors/lsm330dlc_gyroscope.c deleted file mode 100644 index b91b433..0000000 --- a/libsensors/lsm330dlc_gyroscope.c +++ /dev/null @@ -1,256 +0,0 @@ -/* - * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr> - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - */ - -#include <stdlib.h> -#include <unistd.h> -#include <stdint.h> -#include <fcntl.h> -#include <errno.h> -#include <math.h> -#include <sys/types.h> -#include <linux/ioctl.h> -#include <linux/input.h> - -#include <hardware/sensors.h> -#include <hardware/hardware.h> - -#define LOG_TAG "smdk4x12_sensors" -#include <utils/Log.h> - -#include "smdk4x12_sensors.h" - -struct lsm330dlc_gyroscope_data { - char path_enable[PATH_MAX]; - char path_delay[PATH_MAX]; - - sensors_vec_t gyro; -}; - -int lsm330dlc_gyroscope_init(struct smdk4x12_sensors_handlers *handlers, - struct smdk4x12_sensors_device *device) -{ - struct lsm330dlc_gyroscope_data *data = NULL; - char path[PATH_MAX] = { 0 }; - int input_fd = -1; - int rc; - - ALOGD("%s(%p, %p)", __func__, handlers, device); - - if (handlers == NULL) - return -EINVAL; - - data = (struct lsm330dlc_gyroscope_data *) calloc(1, sizeof(struct lsm330dlc_gyroscope_data)); - - input_fd = input_open("gyro_sensor"); - if (input_fd < 0) { - ALOGE("%s: Unable to open input", __func__); - goto error; - } - - rc = sysfs_path_prefix("gyro_sensor", (char *) &path); - if (rc < 0 || path[0] == '\0') { - ALOGE("%s: Unable to open sysfs", __func__); - goto error; - } - - snprintf(data->path_enable, PATH_MAX, "%s/enable", path); - snprintf(data->path_delay, PATH_MAX, "%s/poll_delay", path); - - handlers->poll_fd = input_fd; - handlers->data = (void *) data; - - return 0; - -error: - if (data != NULL) - free(data); - - if (input_fd >= 0) - close(input_fd); - - handlers->poll_fd = -1; - handlers->data = NULL; - - return -1; -} - -int lsm330dlc_gyroscope_deinit(struct smdk4x12_sensors_handlers *handlers) -{ - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL) - return -EINVAL; - - if (handlers->poll_fd >= 0) - close(handlers->poll_fd); - handlers->poll_fd = -1; - - if (handlers->data != NULL) - free(handlers->data); - handlers->data = NULL; - - return 0; -} - -int lsm330dlc_gyroscope_activate(struct smdk4x12_sensors_handlers *handlers) -{ - struct lsm330dlc_gyroscope_data *data; - int rc; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct lsm330dlc_gyroscope_data *) handlers->data; - - rc = sysfs_value_write(data->path_enable, 1); - if (rc < 0) { - ALOGE("%s: Unable to write sysfs value", __func__); - return -1; - } - - handlers->activated = 1; - - return 0; -} - -int lsm330dlc_gyroscope_deactivate(struct smdk4x12_sensors_handlers *handlers) -{ - struct lsm330dlc_gyroscope_data *data; - int rc; - - ALOGD("%s(%p)", __func__, handlers); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct lsm330dlc_gyroscope_data *) handlers->data; - - rc = sysfs_value_write(data->path_enable, 0); - if (rc < 0) { - ALOGE("%s: Unable to write sysfs value", __func__); - return -1; - } - - handlers->activated = 1; - - return 0; -} - -int lsm330dlc_gyroscope_set_delay(struct smdk4x12_sensors_handlers *handlers, int64_t delay) -{ - struct lsm330dlc_gyroscope_data *data; - int rc; - - ALOGD("%s(%p, %" PRId64 ")", __func__, handlers, delay); - - if (handlers == NULL || handlers->data == NULL) - return -EINVAL; - - data = (struct lsm330dlc_gyroscope_data *) handlers->data; - - rc = sysfs_value_write(data->path_delay, delay); - if (rc < 0) { - ALOGE("%s: Unable to write sysfs value", __func__); - return -1; - } - - return 0; -} - -float lsm330dlc_gyroscope_convert(int value) -{ - return value * (70.0f / 4000.0f) * (3.1415926535f / 180.0f); -} - -int lsm330dlc_gyroscope_get_data(struct smdk4x12_sensors_handlers *handlers, - struct sensors_event_t *event) -{ - struct lsm330dlc_gyroscope_data *data; - struct input_event input_event; - int input_fd; - int rc; - -// ALOGD("%s(%p, %p)", __func__, handlers, event); - - if (handlers == NULL || handlers->data == NULL || event == NULL) - return -EINVAL; - - data = (struct lsm330dlc_gyroscope_data *) handlers->data; - - input_fd = handlers->poll_fd; - if (input_fd < 0) - return -EINVAL; - - memset(event, 0, sizeof(struct sensors_event_t)); - event->version = sizeof(struct sensors_event_t); - event->sensor = handlers->handle; - event->type = handlers->handle; - - event->gyro.x = data->gyro.x; - event->gyro.y = data->gyro.y; - event->gyro.z = data->gyro.z; - - event->gyro.status = SENSOR_STATUS_ACCURACY_MEDIUM; - - do { - rc = read(input_fd, &input_event, sizeof(input_event)); - if (rc < (int) sizeof(input_event)) - break; - - if (input_event.type == EV_REL) { - switch (input_event.code) { - case REL_RX: - event->gyro.x = lsm330dlc_gyroscope_convert(input_event.value); - break; - case REL_RY: - event->gyro.y = lsm330dlc_gyroscope_convert(input_event.value); - break; - case REL_RZ: - event->gyro.z = lsm330dlc_gyroscope_convert(input_event.value); - break; - default: - continue; - } - } else if (input_event.type == EV_SYN) { - if (input_event.code == SYN_REPORT) - event->timestamp = input_timestamp(&input_event); - } - } while (input_event.type != EV_SYN); - - data->gyro.x = event->gyro.x; - data->gyro.y = event->gyro.y; - data->gyro.z = event->gyro.z; - - return 0; -} - -struct smdk4x12_sensors_handlers lsm330dlc_gyroscope = { - .name = "LSM330DLC Gyroscope", - .handle = SENSOR_TYPE_GYROSCOPE, - .init = lsm330dlc_gyroscope_init, - .deinit = lsm330dlc_gyroscope_deinit, - .activate = lsm330dlc_gyroscope_activate, - .deactivate = lsm330dlc_gyroscope_deactivate, - .set_delay = lsm330dlc_gyroscope_set_delay, - .get_data = lsm330dlc_gyroscope_get_data, - .activated = 0, - .needed = 0, - .poll_fd = -1, - .data = NULL, -}; diff --git a/libsensors/sensors.cpp b/libsensors/sensors.cpp new file mode 100644 index 0000000..74b7f21 --- /dev/null +++ b/libsensors/sensors.cpp @@ -0,0 +1,395 @@ +/* + * 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. + */ + +#define ALOG_TAG "Sensors" + +#include <hardware/sensors.h> +#include <fcntl.h> +#include <errno.h> +#include <dirent.h> +#include <math.h> +#include <poll.h> +#include <pthread.h> +#include <stdlib.h> +#include <cstring> + +#include <linux/input.h> + +#include <utils/Atomic.h> +#include <utils/Log.h> + +#include "sensors.h" + +#include "LightSensor.h" +#include "ProximitySensor.h" +#include "AkmSensor.h" +#include "GyroSensor.h" +#include "AccelSensor.h" +#include "PressureSensor.h" + +/*****************************************************************************/ + +#define DELAY_OUT_TIME 0x7FFFFFFF + +#define LIGHT_SENSOR_POLLTIME 2000000000 + + +#define SENSORS_ACCELERATION (1<<ID_A) +#define SENSORS_MAGNETIC_FIELD (1<<ID_M) +#define SENSORS_ORIENTATION (1<<ID_O) +#define SENSORS_LIGHT (1<<ID_L) +#define SENSORS_PROXIMITY (1<<ID_P) +#define SENSORS_GYROSCOPE (1<<ID_GY) +#define SENSORY_PRESSURE (1<<ID_PR) + +#define SENSORS_ACCELERATION_HANDLE 0 +#define SENSORS_MAGNETIC_FIELD_HANDLE 1 +#define SENSORS_ORIENTATION_HANDLE 2 +#define SENSORS_LIGHT_HANDLE 3 +#define SENSORS_PROXIMITY_HANDLE 4 +#define SENSORS_GYROSCOPE_HANDLE 5 +#define SENSORS_PRESSURE_HANDLE 6 + +#define AKM_FTRACE 0 +#define AKM_DEBUG 0 +#define AKM_DATA 0 + +/*****************************************************************************/ + +/* The SENSORS Module */ +static const struct sensor_t sSensorList[] = { + { "LSM330DLC Acceleration Sensor", + "STMicroelectronics", + 1, SENSORS_ACCELERATION_HANDLE, + SENSOR_TYPE_ACCELEROMETER, RANGE_A, 0.0096f, 0.23f, 10000, 0, 0, + SENSOR_STRING_TYPE_ACCELEROMETER, "", 0, SENSOR_FLAG_CONTINUOUS_MODE, { } }, + { "AK8975C Magnetic field Sensor", + "Asahi Kasei Microdevices", + 1, SENSORS_MAGNETIC_FIELD_HANDLE, + SENSOR_TYPE_MAGNETIC_FIELD, 2000.0f, CONVERT_M, 6.8f, 10000, 0, 0, + SENSOR_STRING_TYPE_MAGNETIC_FIELD, "", 0, SENSOR_FLAG_CONTINUOUS_MODE, { } }, + { "LSM330DLC Gyroscope Sensor", + "STMicroelectronics", + 1, SENSORS_GYROSCOPE_HANDLE, + SENSOR_TYPE_GYROSCOPE, RANGE_GYRO, CONVERT_GYRO, 6.1f, 5000, 0, 0, + SENSOR_STRING_TYPE_GYROSCOPE, "", 0, SENSOR_FLAG_CONTINUOUS_MODE, { } }, + { "LPS331AP Pressure sensor", + "STMicroelectronics", + 1, SENSORS_PRESSURE_HANDLE, + SENSOR_TYPE_PRESSURE, 1260.0f, 1.0f / 4096, 0.045f, 40000, 0, 0, + SENSOR_STRING_TYPE_PRESSURE, "", 20000, SENSOR_FLAG_CONTINUOUS_MODE, { } }, + { "CM36651 Proximity Sensor", + "Capella Microsystems", + 1, SENSORS_PROXIMITY_HANDLE, + SENSOR_TYPE_PROXIMITY, 6.0f, 6.0f, 1.3f, 0, 0, 0, + SENSOR_STRING_TYPE_PROXIMITY, "", 0, SENSOR_FLAG_WAKE_UP | SENSOR_FLAG_ON_CHANGE_MODE, { } }, + { "CM36651 Light Sensor", + "Capella Microsystems", + 1, SENSORS_LIGHT_HANDLE, + SENSOR_TYPE_LIGHT, 121240.0f, 1.0f, 0.2f, 0, 0, 0, + SENSOR_STRING_TYPE_LIGHT, "", 0, SENSOR_FLAG_ON_CHANGE_MODE, { } }, +}; + + +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* module, + 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: "Samsung Sensor module", + author: "Samsung Electronic Company", + methods: &sensors_module_methods, + }, + 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); + + // return true if the constructor is completed + bool isValid() { return mInitialized; }; + int flush(int handle); + +private: + enum { + light = 0, + proximity = 1, + akm = 2, + gyro = 3, + accel = 4, + pressure = 5, + numSensorDrivers, + numFds, + }; + + static const size_t wake = numFds - 1; + static const char WAKE_MESSAGE = 'W'; + struct pollfd mPollFds[numFds]; + int mWritePipeFd; + SensorBase* mSensors[numSensorDrivers]; + // return true if the constructor is completed + bool mInitialized; + + int handleToDriver(int handle) const { + switch (handle) { + case ID_A: + return accel; + case ID_M: + case ID_O: + return akm; + case ID_P: + return proximity; + case ID_L: + return light; + case ID_GY: + return gyro; + case ID_PR: + return pressure; + } + return -EINVAL; + } +}; + +/*****************************************************************************/ + +sensors_poll_context_t::sensors_poll_context_t() +{ + mSensors[light] = new LightSensor(); + mPollFds[light].fd = mSensors[light]->getFd(); + mPollFds[light].events = POLLIN; + mPollFds[light].revents = 0; + + mSensors[proximity] = new ProximitySensor(); + mPollFds[proximity].fd = mSensors[proximity]->getFd(); + mPollFds[proximity].events = POLLIN; + mPollFds[proximity].revents = 0; + + mSensors[akm] = new AkmSensor(); + mPollFds[akm].fd = mSensors[akm]->getFd(); + mPollFds[akm].events = POLLIN; + mPollFds[akm].revents = 0; + + mSensors[gyro] = new GyroSensor(); + mPollFds[gyro].fd = mSensors[gyro]->getFd(); + mPollFds[gyro].events = POLLIN; + mPollFds[gyro].revents = 0; + + mSensors[accel] = new AccelSensor(); + mPollFds[accel].fd = mSensors[accel]->getFd(); + mPollFds[accel].events = POLLIN; + mPollFds[accel].revents = 0; + + mSensors[pressure] = new PressureSensor(); + mPollFds[pressure].fd = mSensors[pressure]->getFd(); + mPollFds[pressure].events = POLLIN; + mPollFds[pressure].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; + mInitialized = true; +} + +sensors_poll_context_t::~sensors_poll_context_t() { + for (int i=0 ; i<numSensorDrivers ; i++) { + delete mSensors[i]; + } + close(mPollFds[wake].fd); + close(mWritePipeFd); + mInitialized = false; +} + +int sensors_poll_context_t::activate(int handle, int enabled) { + if (!mInitialized) return -EINVAL; + int index = handleToDriver(handle); + //ALOGI("Sensors: handle: %i", handle); + if (index < 0) return index; + int err = mSensors[index]->enable(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 + n = poll(mPollFds, numFds, nbEvents ? 0 : -1); + if (n<0) { + ALOGE("poll() failed (%s)", strerror(errno)); + return -errno; + } + if (mPollFds[wake].revents & POLLIN) { + char msg; + 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; + return mSensors[index]->batch(handle, flags, period_ns, timeout); +} + +int sensors_poll_context_t::flush(int handle) +{ + int index = handleToDriver(handle); + if (index < 0) return index; + return mSensors[index]->flush(handle); +} + +/*****************************************************************************/ + +static int poll__close(struct hw_device_t *dev) +{ + sensors_poll_context_t *ctx = (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 = (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 = (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 = (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* id, + struct hw_device_t** device) +{ + int status = -EINVAL; + sensors_poll_context_t *dev = new sensors_poll_context_t(); + + memset(&dev->device, 0, sizeof(sensors_poll_device_1)); + + dev->device.common.tag = HARDWARE_DEVICE_TAG; + dev->device.common.version = SENSORS_DEVICE_API_VERSION_1_0; + 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; + status = 0; + + return status; +} + diff --git a/libsensors/sensors.h b/libsensors/sensors.h new file mode 100644 index 0000000..0d61ac2 --- /dev/null +++ b/libsensors/sensors.h @@ -0,0 +1,112 @@ +/* + * 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. + */ + +#ifndef ANDROID_SENSORS_H +#define ANDROID_SENSORS_H + +#include <stdint.h> +#include <errno.h> +#include <sys/cdefs.h> +#include <sys/types.h> + +#include <linux/input.h> + +#include <hardware/hardware.h> +#include <hardware/sensors.h> + +__BEGIN_DECLS + +/*****************************************************************************/ + +#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) + +#define LOG_TAG "sensorscpp" + +#define ID_A (0) +#define ID_M (1) +#define ID_O (2) +#define ID_L (3) +#define ID_P (4) +#define ID_GY (5) +#define ID_PR (6) + +/*****************************************************************************/ + +/* + * The SENSORS Module + */ + +/* the CM3663 is a binary proximity sensor that triggers around 6 cm on + * this hardware */ +#define PROXIMITY_THRESHOLD_CM 6.0f + +/*****************************************************************************/ + +#define EVENT_TYPE_ACCEL_X ABS_X //1 +#define EVENT_TYPE_ACCEL_Y ABS_Y //0 +#define EVENT_TYPE_ACCEL_Z ABS_Z //2 + +#define EVENT_TYPE_YAW ABS_RX //3 +#define EVENT_TYPE_PITCH ABS_RY //4 +#define EVENT_TYPE_ROLL ABS_RZ //5 +#define EVENT_TYPE_ORIENT_STATUS ABS_WHEEL //8 + +#define EVENT_TYPE_MAGV_X ABS_THROTTLE // 6 +#define EVENT_TYPE_MAGV_Y ABS_RUDDER // 7 +#define EVENT_TYPE_MAGV_Z ABS_GAS // 9 +#define EVENT_TYPE_MAGV_ACC ABS_WHEEL // 8 + +#define EVENT_TYPE_TEMPERATURE ABS_THROTTLE +#define EVENT_TYPE_STEP_COUNT ABS_GAS +#define EVENT_TYPE_PROXIMITY ABS_DISTANCE +#define EVENT_TYPE_LIGHT REL_MISC + +#define EVENT_TYPE_GYRO_X REL_RX +#define EVENT_TYPE_GYRO_Y REL_RY +#define EVENT_TYPE_GYRO_Z REL_RZ + +#define EVENT_TYPE_PRESSURE REL_X + +#define LSG (1000.0f) + +// conversion of acceleration data to SI units (m/s^2) +#define RANGE_A (2*GRAVITY_EARTH) +#define RESOLUTION_A (GRAVITY_EARTH / LSG) +#define CONVERT_A (GRAVITY_EARTH / LSG) +#define CONVERT_A_X (CONVERT_A) +#define CONVERT_A_Y (CONVERT_A) +#define CONVERT_A_Z (CONVERT_A) + +// conversion of magnetic data to uT units +#define CONVERT_M (1.0f/16.0f) +#define CONVERT_M_X (-CONVERT_M) +#define CONVERT_M_Y (-CONVERT_M) +#define CONVERT_M_Z (CONVERT_M) + +// conversion of gyro data to SI units (radian/sec) +#define RANGE_GYRO (500.0f*(float)M_PI/180.0f) +#define CONVERT_GYRO ((70.0f / 4000.0f) * ((float)M_PI / 180.0f)) +#define CONVERT_GYRO_X (CONVERT_GYRO) +#define CONVERT_GYRO_Y (CONVERT_GYRO) +#define CONVERT_GYRO_Z (CONVERT_GYRO) + +#define SENSOR_STATE_MASK (0x7FFF) + +/*****************************************************************************/ + +__END_DECLS + +#endif // ANDROID_SENSORS_H diff --git a/libsensors/smdk4x12_sensors.c b/libsensors/smdk4x12_sensors.c deleted file mode 100644 index 4cbc7c2..0000000 --- a/libsensors/smdk4x12_sensors.c +++ /dev/null @@ -1,295 +0,0 @@ -/* - * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr> - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - */ - -#include <stdlib.h> -#include <unistd.h> -#include <stdint.h> -#include <fcntl.h> -#include <errno.h> -#include <poll.h> -#include <sys/select.h> -#include <hardware/sensors.h> -#include <hardware/hardware.h> - -#define LOG_TAG "smdk4x12_sensors" -#include <utils/Log.h> - -#include "smdk4x12_sensors.h" - -/* - * Sensors list - */ - -struct sensor_t smdk4x12_sensors[] = { - { "LSM330DLC 3-Axis Accelerometer", "STMicroelectronics", 1, SENSOR_TYPE_ACCELEROMETER, - SENSOR_TYPE_ACCELEROMETER, 2 * GRAVITY_EARTH, 0.0096f, 0.23f, 10000, 0, 0, SENSOR_STRING_TYPE_ACCELEROMETER, 0, 0, - SENSOR_FLAG_CONTINUOUS_MODE, {}, }, - { "AKM8975C 3-Axis Magnetic Sensor", "Asahi Kasei", 1, SENSOR_TYPE_MAGNETIC_FIELD, - SENSOR_TYPE_MAGNETIC_FIELD, 2000.0f, 1.0f / 16, 6.8f, 10000, 0, 0, SENSOR_STRING_TYPE_MAGNETIC_FIELD, 0, 0, - SENSOR_FLAG_CONTINUOUS_MODE, {}, }, - { "CM36651 Light Sensor", "Capella", 1, SENSOR_TYPE_LIGHT, - SENSOR_TYPE_LIGHT, 121240.0f, 1.0f, 0.2f, 0, 0, 0, SENSOR_STRING_TYPE_LIGHT, 0, 0, - SENSOR_FLAG_ON_CHANGE_MODE, {}, }, - { "CM36651 Proximity Sensor", "Capella", 1, SENSOR_TYPE_PROXIMITY, - SENSOR_TYPE_PROXIMITY, 8.0f, 8.0f, 1.3f, 0, 0, 0, SENSOR_STRING_TYPE_PROXIMITY, 0, 0, - SENSOR_FLAG_WAKE_UP | SENSOR_FLAG_ON_CHANGE_MODE, {}, }, - { "LSM330DLC Gyroscope Sensor", "STMicroelectronics", 1, SENSOR_TYPE_GYROSCOPE, - SENSOR_TYPE_GYROSCOPE, 500.0f * (3.1415926535f / 180.0f), (70.0f / 4000.0f) * (3.1415926535f / 180.0f), 6.1f, 5000, 0, 0, SENSOR_STRING_TYPE_GYROSCOPE, 0, 0, - SENSOR_FLAG_CONTINUOUS_MODE, {}, }, - { "LPS331AP Pressure Sensor", "STMicroelectronics", 1, SENSOR_TYPE_PRESSURE, - SENSOR_TYPE_PRESSURE, 1260.0f, 1.0f / 4096, 0.045f, 40000, 0, 0, SENSOR_STRING_TYPE_PRESSURE, 0, 20000, - SENSOR_FLAG_CONTINUOUS_MODE, {}, }, -}; - -int smdk4x12_sensors_count = sizeof(smdk4x12_sensors) / sizeof(struct sensor_t); - -struct smdk4x12_sensors_handlers *smdk4x12_sensors_handlers[] = { - &lsm330dlc_acceleration, - &akm8975, - &cm36651_proximity, - &cm36651_light, - &lsm330dlc_gyroscope, - &lps331ap, -}; - -int smdk4x12_sensors_handlers_count = sizeof(smdk4x12_sensors_handlers) / - sizeof(struct smdk4x12_sensors_handlers *); - -/* - * SMDK4x12 Sensors - */ - -int smdk4x12_sensors_activate(struct sensors_poll_device_t *dev, int handle, - int enabled) -{ - struct smdk4x12_sensors_device *device; - int i; - - ALOGD("%s(%p, %d, %d)", __func__, dev, handle, enabled); - - if (dev == NULL) - return -EINVAL; - - device = (struct smdk4x12_sensors_device *) dev; - - if (device->handlers == NULL || device->handlers_count <= 0) - return -EINVAL; - - for (i = 0; i < device->handlers_count; i++) { - if (device->handlers[i] == NULL) - continue; - - if (device->handlers[i]->handle == handle) { - if (enabled && device->handlers[i]->activate != NULL) { - device->handlers[i]->needed |= SMDK4x12_SENSORS_NEEDED_API; - if (device->handlers[i]->needed == SMDK4x12_SENSORS_NEEDED_API) - return device->handlers[i]->activate(device->handlers[i]); - else - return 0; - } else if (!enabled && device->handlers[i]->deactivate != NULL) { - device->handlers[i]->needed &= ~SMDK4x12_SENSORS_NEEDED_API; - if (device->handlers[i]->needed == 0) - return device->handlers[i]->deactivate(device->handlers[i]); - else - return 0; - } - } - } - - return -1; -} - -int smdk4x12_sensors_set_delay(struct sensors_poll_device_t *dev, int handle, - int64_t ns) -{ - struct smdk4x12_sensors_device *device; - int i; - - ALOGD("%s(%p, %d, %" PRId64 ")", __func__, dev, handle, ns); - - if (dev == NULL) - return -EINVAL; - - device = (struct smdk4x12_sensors_device *) dev; - - if (device->handlers == NULL || device->handlers_count <= 0) - return -EINVAL; - - for (i = 0; i < device->handlers_count; i++) { - if (device->handlers[i] == NULL) - continue; - - if (device->handlers[i]->handle == handle && device->handlers[i]->set_delay != NULL) - return device->handlers[i]->set_delay(device->handlers[i], ns); - } - - return 0; -} - -int smdk4x12_sensors_poll(struct sensors_poll_device_t *dev, - struct sensors_event_t* data, int count) -{ - struct smdk4x12_sensors_device *device; - int i, j; - int c, n; - int poll_rc, rc; - -// ALOGD("%s(%p, %p, %d)", __func__, dev, data, count); - - if (dev == NULL) - return -EINVAL; - - device = (struct smdk4x12_sensors_device *) dev; - - if (device->handlers == NULL || device->handlers_count <= 0 || - device->poll_fds == NULL || device->poll_fds_count <= 0) - return -EINVAL; - - n = 0; - - do { - poll_rc = poll(device->poll_fds, device->poll_fds_count, n > 0 ? 0 : -1); - if (poll_rc < 0) - return -1; - - for (i = 0; i < device->poll_fds_count; i++) { - if (!(device->poll_fds[i].revents & POLLIN)) - continue; - - for (j = 0; j < device->handlers_count; j++) { - if (device->handlers[j] == NULL || device->handlers[j]->poll_fd != device->poll_fds[i].fd || device->handlers[j]->get_data == NULL) - continue; - - rc = device->handlers[j]->get_data(device->handlers[j], &data[n]); - if (rc < 0) { - device->poll_fds[i].revents = 0; - poll_rc = -1; - } else { - n++; - count--; - } - } - } - } while ((poll_rc > 0 || n < 1) && count > 0); - - return n; -} - -/* - * Interface - */ - -int smdk4x12_sensors_close(hw_device_t *device) -{ - struct smdk4x12_sensors_device *smdk4x12_sensors_device; - int i; - - ALOGD("%s(%p)", __func__, device); - - if (device == NULL) - return -EINVAL; - - smdk4x12_sensors_device = (struct smdk4x12_sensors_device *) device; - - if (smdk4x12_sensors_device->poll_fds != NULL) - free(smdk4x12_sensors_device->poll_fds); - - for (i = 0; i < smdk4x12_sensors_device->handlers_count; i++) { - if (smdk4x12_sensors_device->handlers[i] == NULL || smdk4x12_sensors_device->handlers[i]->deinit == NULL) - continue; - - smdk4x12_sensors_device->handlers[i]->deinit(smdk4x12_sensors_device->handlers[i]); - } - - free(device); - - return 0; -} - -int smdk4x12_sensors_open(const struct hw_module_t* module, const char *id, - struct hw_device_t** device) -{ - struct smdk4x12_sensors_device *smdk4x12_sensors_device; - int p, i; - - ALOGD("%s(%p, %s, %p)", __func__, module, id, device); - - if (module == NULL || device == NULL) - return -EINVAL; - - smdk4x12_sensors_device = (struct smdk4x12_sensors_device *) - calloc(1, sizeof(struct smdk4x12_sensors_device)); - smdk4x12_sensors_device->device.common.tag = HARDWARE_DEVICE_TAG; - smdk4x12_sensors_device->device.common.version = 0; - smdk4x12_sensors_device->device.common.module = (struct hw_module_t *) module; - smdk4x12_sensors_device->device.common.close = smdk4x12_sensors_close; - smdk4x12_sensors_device->device.activate = smdk4x12_sensors_activate; - smdk4x12_sensors_device->device.setDelay = smdk4x12_sensors_set_delay; - smdk4x12_sensors_device->device.poll = smdk4x12_sensors_poll; - smdk4x12_sensors_device->handlers = smdk4x12_sensors_handlers; - smdk4x12_sensors_device->handlers_count = smdk4x12_sensors_handlers_count; - smdk4x12_sensors_device->poll_fds = (struct pollfd *) - calloc(1, smdk4x12_sensors_handlers_count * sizeof(struct pollfd)); - - p = 0; - for (i = 0; i < smdk4x12_sensors_handlers_count; i++) { - if (smdk4x12_sensors_handlers[i] == NULL || smdk4x12_sensors_handlers[i]->init == NULL) - continue; - - smdk4x12_sensors_handlers[i]->init(smdk4x12_sensors_handlers[i], smdk4x12_sensors_device); - if (smdk4x12_sensors_handlers[i]->poll_fd >= 0) { - smdk4x12_sensors_device->poll_fds[p].fd = smdk4x12_sensors_handlers[i]->poll_fd; - smdk4x12_sensors_device->poll_fds[p].events = POLLIN; - p++; - } - } - - smdk4x12_sensors_device->poll_fds_count = p; - - *device = &(smdk4x12_sensors_device->device.common); - - return 0; -} - -int smdk4x12_sensors_get_sensors_list(struct sensors_module_t* module, - const struct sensor_t **sensors_p) -{ - ALOGD("%s(%p, %p)", __func__, module, sensors_p); - - if (sensors_p == NULL) - return -EINVAL; - - *sensors_p = smdk4x12_sensors; - return smdk4x12_sensors_count; -} - -struct hw_module_methods_t smdk4x12_sensors_module_methods = { - .open = smdk4x12_sensors_open, -}; - -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 = "SMDK4x12 Sensors", - .author = "Paul Kocialkowski", - .methods = &smdk4x12_sensors_module_methods, - }, - .get_sensors_list = smdk4x12_sensors_get_sensors_list, -}; diff --git a/libsensors/smdk4x12_sensors.h b/libsensors/smdk4x12_sensors.h deleted file mode 100644 index 7100334..0000000 --- a/libsensors/smdk4x12_sensors.h +++ /dev/null @@ -1,102 +0,0 @@ -/* - * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr> - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - */ - -#include <stdint.h> -#include <poll.h> -#include <linux/input.h> -#define __STDC_FORMAT_MACROS -#include <inttypes.h> - -#include <hardware/sensors.h> -#include <hardware/hardware.h> - -#ifndef _SMDK4x12_SENSORS_H_ -#define _SMDK4x12_SENSORS_H_ - -#define SMDK4x12_SENSORS_NEEDED_API (1 << 0) - -struct smdk4x12_sensors_device; - -struct smdk4x12_sensors_handlers { - char *name; - int handle; - - int (*init)(struct smdk4x12_sensors_handlers *handlers, - struct smdk4x12_sensors_device *device); - int (*deinit)(struct smdk4x12_sensors_handlers *handlers); - int (*activate)(struct smdk4x12_sensors_handlers *handlers); - int (*deactivate)(struct smdk4x12_sensors_handlers *handlers); - int (*set_delay)(struct smdk4x12_sensors_handlers *handlers, - int64_t delay); - int (*get_data)(struct smdk4x12_sensors_handlers *handlers, - struct sensors_event_t *event); - - int activated; - int needed; - int poll_fd; - - void *data; -}; - -struct smdk4x12_sensors_device { - struct sensors_poll_device_t device; - - struct smdk4x12_sensors_handlers **handlers; - int handlers_count; - - struct pollfd *poll_fds; - int poll_fds_count; -}; - -extern struct smdk4x12_sensors_handlers *smdk4x12_sensors_handlers[]; -extern int smdk4x12_sensors_handlers_count; - -int smdk4x12_sensors_activate(struct sensors_poll_device_t *dev, int handle, - int enabled); -int smdk4x12_sensors_set_delay(struct sensors_poll_device_t *dev, int handle, - int64_t ns); -int smdk4x12_sensors_poll(struct sensors_poll_device_t *dev, - struct sensors_event_t* data, int count); - -/* - * Input - */ - -void input_event_set(struct input_event *event, int type, int code, int value); -int64_t timestamp(struct timeval *time); -int64_t input_timestamp(struct input_event *event); -int uinput_rel_create(const char *name); -void uinput_destroy(int uinput_fd); -int input_open(char *name); -int sysfs_path_prefix(char *name, char *path_prefix); -int64_t sysfs_value_read(char *path); -int sysfs_value_write(char *path, int64_t value); -int sysfs_string_read(char *path, char *buffer, size_t length); -int sysfs_string_write(char *path, char *buffer, size_t length); - -/* - * Sensors - */ - -extern struct smdk4x12_sensors_handlers lsm330dlc_acceleration; -extern struct smdk4x12_sensors_handlers akm8975; -extern struct smdk4x12_sensors_handlers cm36651_proximity; -extern struct smdk4x12_sensors_handlers cm36651_light; -extern struct smdk4x12_sensors_handlers lsm330dlc_gyroscope; -extern struct smdk4x12_sensors_handlers lps331ap; - -#endif |