summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--BoardConfig.mk3
-rw-r--r--libsensors/AccelSensor.cpp168
-rw-r--r--libsensors/AccelSensor.h72
-rw-r--r--libsensors/AkmSensor.cpp281
-rw-r--r--libsensors/AkmSensor.h63
-rw-r--r--libsensors/Android.mk72
-rw-r--r--libsensors/GyroSensor.cpp181
-rw-r--r--libsensors/GyroSensor.h55
-rw-r--r--libsensors/InputEventReader.cpp89
-rw-r--r--libsensors/InputEventReader.h47
-rw-r--r--libsensors/LightSensor.cpp152
-rw-r--r--libsensors/LightSensor.h55
-rw-r--r--libsensors/MODULE_LICENSE_APACHE20
-rw-r--r--libsensors/PressureSensor.cpp155
-rw-r--r--libsensors/PressureSensor.h54
-rw-r--r--libsensors/ProximitySensor.cpp164
-rw-r--r--libsensors/ProximitySensor.h55
-rw-r--r--libsensors/SensorBase.cpp141
-rw-r--r--libsensors/SensorBase.h70
-rw-r--r--libsensors/ak8973b.h51
-rw-r--r--libsensors/ak8975-reg.h48
-rw-r--r--libsensors/ak8975.h73
-rw-r--r--libsensors/akm8975.c612
-rw-r--r--libsensors/akmdfs/AK8975Driver.c318
-rw-r--r--libsensors/akmdfs/AK8975Driver.h102
-rw-r--r--libsensors/akmdfs/AKFS_APIs.c389
-rw-r--r--libsensors/akmdfs/AKFS_APIs.h69
-rw-r--r--libsensors/akmdfs/AKFS_APIs_8975/AKFS_AK8975.c44
-rw-r--r--libsensors/akmdfs/AKFS_APIs_8975/AKFS_AK8975.h50
-rw-r--r--libsensors/akmdfs/AKFS_APIs_8975/AKFS_AOC.c333
-rw-r--r--libsensors/akmdfs/AKFS_APIs_8975/AKFS_AOC.h53
-rw-r--r--libsensors/akmdfs/AKFS_APIs_8975/AKFS_Configure.h37
-rw-r--r--libsensors/akmdfs/AKFS_APIs_8975/AKFS_Device.c110
-rw-r--r--libsensors/akmdfs/AKFS_APIs_8975/AKFS_Device.h107
-rw-r--r--libsensors/akmdfs/AKFS_APIs_8975/AKFS_Direction.c133
-rw-r--r--libsensors/akmdfs/AKFS_APIs_8975/AKFS_Direction.h39
-rw-r--r--libsensors/akmdfs/AKFS_APIs_8975/AKFS_Math.h47
-rw-r--r--libsensors/akmdfs/AKFS_APIs_8975/AKFS_VNorm.c107
-rw-r--r--libsensors/akmdfs/AKFS_APIs_8975/AKFS_VNorm.h46
-rw-r--r--libsensors/akmdfs/AKFS_CSpec.h38
-rw-r--r--libsensors/akmdfs/AKFS_Common.h141
-rw-r--r--libsensors/akmdfs/AKFS_Compass.h84
-rw-r--r--libsensors/akmdfs/AKFS_Disp.c89
-rw-r--r--libsensors/akmdfs/AKFS_Disp.h52
-rw-r--r--libsensors/akmdfs/AKFS_FileIO.c130
-rw-r--r--libsensors/akmdfs/AKFS_FileIO.h39
-rw-r--r--libsensors/akmdfs/AKFS_Measure.c410
-rw-r--r--libsensors/akmdfs/AKFS_Measure.h70
-rw-r--r--libsensors/akmdfs/NOTICE202
-rw-r--r--libsensors/akmdfs/Version.txt31
-rw-r--r--libsensors/akmdfs/main.c293
-rw-r--r--libsensors/cm36651_light.c264
-rw-r--r--libsensors/cm36651_proximity.c213
-rw-r--r--libsensors/input.c336
-rw-r--r--libsensors/lps331ap.c244
-rw-r--r--libsensors/lsm330dlc_accel.h185
-rw-r--r--libsensors/lsm330dlc_acceleration.c390
-rw-r--r--libsensors/lsm330dlc_gyroscope.c256
-rw-r--r--libsensors/sensors.cpp395
-rw-r--r--libsensors/sensors.h112
-rw-r--r--libsensors/smdk4x12_sensors.c295
-rw-r--r--libsensors/smdk4x12_sensors.h102
62 files changed, 2395 insertions, 6621 deletions
diff --git a/BoardConfig.mk b/BoardConfig.mk
index cabfc99..001780d 100644
--- a/BoardConfig.mk
+++ b/BoardConfig.mk
@@ -31,9 +31,6 @@ COMMON_GLOBAL_CFLAGS += -DDISABLE_ASHMEM_TRACKING
# Graphics
TARGET_REQUIRES_SYNCHRONOUS_SETSURFACE := true
-# Sensors
-BOARD_USES_OPENSOURCE_SENSORS := false
-
# Bluetooth
BOARD_BLUETOOTH_BDROID_BUILDCFG_INCLUDE_DIR := device/samsung/i9300/bluetooth
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, &params->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, &params->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(&params->m_aocv, params->mfv_hdata, &params->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,
- &params->mfv_ho, &params->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, &params->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