1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "Sensors"
18
19#include <hardware/sensors.h>
20#include <fcntl.h>
21#include <errno.h>
22#include <dirent.h>
23#include <math.h>
24#include <poll.h>
25#include <pthread.h>
26#include <stdlib.h>
27
28#include <linux/input.h>
29
30#include <utils/Atomic.h>
31#include <utils/Log.h>
32
33#include "sensors.h"
34
35#if defined SENSORHAL_ACC_ADXL346
36#include "AdxlSensor.h"
37#elif defined SENSORHAL_ACC_KXTF9
38#include "KionixSensor.h"
39#else
40#error "Sensor configuration ERROR: No sensor is defined."
41#endif
42
43#include "AkmSensor.h"
44
45/*****************************************************************************/
46
47#define DELAY_OUT_TIME 0x7FFFFFFF
48
49#define LIGHT_SENSOR_POLLTIME    2000000000
50
51
52#define SENSORS_ACCELERATION     (1<<ID_A)
53#define SENSORS_MAGNETIC_FIELD   (1<<ID_M)
54#define SENSORS_ORIENTATION      (1<<ID_O)
55
56#define SENSORS_ACCELERATION_HANDLE     0
57#define SENSORS_MAGNETIC_FIELD_HANDLE   1
58#define SENSORS_ORIENTATION_HANDLE      2
59
60/*****************************************************************************/
61
62/* The SENSORS Module */
63static const struct sensor_t sSensorList[] = {
64        { "AK8975 3-axis Magnetic field sensor",
65          "Asahi Kasei Microdevices",
66          1,
67		  SENSORS_MAGNETIC_FIELD_HANDLE,
68          SENSOR_TYPE_MAGNETIC_FIELD, 1228.8f,
69		  CONVERT_M, 0.35f, 10000, 0, 0, { } },
70#ifdef SENSORHAL_ACC_ADXL346
71        { "Analog Devices ADXL345/6 3-axis Accelerometer",
72          "ADI",
73          1, SENSORS_ACCELERATION_HANDLE,
74          SENSOR_TYPE_ACCELEROMETER, (GRAVITY_EARTH * 16.0f),
75		  (GRAVITY_EARTH * 16.0f) / 4096.0f, 0.145f, 10000, 0, 0, { } },
76        { "AK8975 Orientation sensor",
77          "Asahi Kasei Microdevices",
78          1, SENSORS_ORIENTATION_HANDLE,
79          SENSOR_TYPE_ORIENTATION, 360.0f,
80		  CONVERT_O, 0.495f, 10000, 0, 0, { } }
81#endif
82#ifdef SENSORHAL_ACC_KXTF9
83        { "Kionix KXTF9 3-axis Accelerometer",
84          "Kionix",
85          1, SENSORS_ACCELERATION_HANDLE,
86          SENSOR_TYPE_ACCELEROMETER, (GRAVITY_EARTH * 2.0f),
87		  (GRAVITY_EARTH) / 1024.0f, 0.7f, 10000, 0,0, { } },
88        { "AK8975 Orientation sensor",
89          "Asahi Kasei Microdevices",
90          1, SENSORS_ORIENTATION_HANDLE,
91          SENSOR_TYPE_ORIENTATION, 360.0f,
92		  CONVERT_O, 1.05f, 10000, 0, 0, { } }
93#endif
94};
95
96
97static int open_sensors(const struct hw_module_t* module, const char* id,
98                        struct hw_device_t** device);
99
100static int sensors__get_sensors_list(struct sensors_module_t* module,
101                                     struct sensor_t const** list)
102{
103        *list = sSensorList;
104        return ARRAY_SIZE(sSensorList);
105}
106
107static struct hw_module_methods_t sensors_module_methods = {
108        open: open_sensors
109};
110
111struct sensors_module_t HAL_MODULE_INFO_SYM = {
112        common: {
113                tag: HARDWARE_MODULE_TAG,
114                version_major: 1,
115                version_minor: 0,
116                id: SENSORS_HARDWARE_MODULE_ID,
117                name: "AKM Sensor module",
118                author: "Asahi Kasei Microdevices",
119                methods: &sensors_module_methods,
120        },
121        get_sensors_list: sensors__get_sensors_list,
122};
123
124struct sensors_poll_context_t {
125    struct sensors_poll_device_t device; // must be first
126
127        sensors_poll_context_t();
128        ~sensors_poll_context_t();
129    int activate(int handle, int enabled);
130    int setDelay(int handle, int64_t ns);
131    int setDelay_sub(int handle, int64_t ns);
132    int pollEvents(sensors_event_t* data, int count);
133
134private:
135    enum {
136        acc          = 0,
137        akm          = 1,
138        numSensorDrivers,
139        numFds,
140    };
141
142    static const size_t wake = numFds - 1;
143    static const char WAKE_MESSAGE = 'W';
144    struct pollfd mPollFds[numFds];
145    int mWritePipeFd;
146    SensorBase* mSensors[numSensorDrivers];
147
148	/* These function will be different depends on
149	 * which sensor is implemented in AKMD program.
150	 */
151    int handleToDriver(int handle);
152	int proxy_enable(int handle, int enabled);
153	int proxy_setDelay(int handle, int64_t ns);
154};
155
156/*****************************************************************************/
157
158sensors_poll_context_t::sensors_poll_context_t()
159{
160#ifdef SENSORHAL_ACC_ADXL346
161    mSensors[acc] = new AdxlSensor();
162#endif
163#ifdef SENSORHAL_ACC_KXTF9
164    mSensors[acc] = new KionixSensor();
165#endif
166    mPollFds[acc].fd = mSensors[acc]->getFd();
167    mPollFds[acc].events = POLLIN;
168    mPollFds[acc].revents = 0;
169
170    mSensors[akm] = new AkmSensor();
171    mPollFds[akm].fd = mSensors[akm]->getFd();
172    mPollFds[akm].events = POLLIN;
173    mPollFds[akm].revents = 0;
174
175    int wakeFds[2];
176    int result = pipe(wakeFds);
177    ALOGE_IF(result<0, "error creating wake pipe (%s)", strerror(errno));
178    fcntl(wakeFds[0], F_SETFL, O_NONBLOCK);
179    fcntl(wakeFds[1], F_SETFL, O_NONBLOCK);
180    mWritePipeFd = wakeFds[1];
181
182    mPollFds[wake].fd = wakeFds[0];
183    mPollFds[wake].events = POLLIN;
184    mPollFds[wake].revents = 0;
185}
186
187sensors_poll_context_t::~sensors_poll_context_t() {
188    for (int i=0 ; i<numSensorDrivers ; i++) {
189        delete mSensors[i];
190    }
191    close(mPollFds[wake].fd);
192    close(mWritePipeFd);
193}
194
195int sensors_poll_context_t::handleToDriver(int handle) {
196	switch (handle) {
197		case ID_A:
198			return acc;
199		case ID_M:
200		case ID_O:
201			return akm;
202	}
203	return -EINVAL;
204}
205
206int sensors_poll_context_t::activate(int handle, int enabled) {
207	int drv = handleToDriver(handle);
208	int err;
209
210	switch (handle) {
211		case ID_A:
212		case ID_M:
213			/* No dependencies */
214			break;
215
216		case ID_O:
217			/* These sensors depend on ID_A and ID_M */
218			mSensors[handleToDriver(ID_A)]->setEnable(ID_A, enabled);
219			mSensors[handleToDriver(ID_M)]->setEnable(ID_M, enabled);
220			break;
221
222		default:
223			return -EINVAL;
224	}
225	err = mSensors[drv]->setEnable(handle, enabled);
226
227    if (enabled && !err) {
228        const char wakeMessage(WAKE_MESSAGE);
229        int result = write(mWritePipeFd, &wakeMessage, 1);
230        ALOGE_IF(result<0, "error sending wake message (%s)", strerror(errno));
231    }
232    return err;
233}
234
235int sensors_poll_context_t::setDelay(int handle, int64_t ns) {
236	switch (handle) {
237		case ID_A:
238		case ID_M:
239			/* No dependencies */
240			break;
241
242		case ID_O:
243			/* These sensors depend on ID_A and ID_M */
244			setDelay_sub(ID_A, ns);
245			setDelay_sub(ID_M, ns);
246			break;
247
248		default:
249			return -EINVAL;
250	}
251	return setDelay_sub(handle, ns);
252}
253
254int sensors_poll_context_t::setDelay_sub(int handle, int64_t ns) {
255	int drv = handleToDriver(handle);
256	int en = mSensors[drv]->getEnable(handle);
257	int64_t cur = mSensors[drv]->getDelay(handle);
258	int err = 0;
259
260	if (en <= 1) {
261		/* no dependencies */
262		if (cur != ns) {
263			err = mSensors[drv]->setDelay(handle, ns);
264		}
265	} else {
266		/* has dependencies, choose shorter interval */
267		if (cur > ns) {
268			err = mSensors[drv]->setDelay(handle, ns);
269		}
270	}
271	return err;
272}
273
274int sensors_poll_context_t::pollEvents(sensors_event_t* data, int count)
275{
276    int nbEvents = 0;
277    int n = 0;
278
279    do {
280        // see if we have some leftover from the last poll()
281        for (int i=0 ; count && i<numSensorDrivers ; i++) {
282            SensorBase* const sensor(mSensors[i]);
283            if ((mPollFds[i].revents & POLLIN) || (sensor->hasPendingEvents())) {
284                int nb = sensor->readEvents(data, count);
285                if (nb < count) {
286                    // no more data for this sensor
287                    mPollFds[i].revents = 0;
288                }
289				if ((0 != nb) && (acc == i)) {
290					((AkmSensor*)(mSensors[akm]))->setAccel(&data[nb-1]);
291				}
292                count -= nb;
293                nbEvents += nb;
294                data += nb;
295            }
296        }
297
298        if (count) {
299            // we still have some room, so try to see if we can get
300            // some events immediately or just wait if we don't have
301            // anything to return
302            n = poll(mPollFds, numFds, nbEvents ? 0 : -1);
303            if (n<0) {
304                ALOGE("poll() failed (%s)", strerror(errno));
305                return -errno;
306            }
307            if (mPollFds[wake].revents & POLLIN) {
308                char msg;
309                int result = read(mPollFds[wake].fd, &msg, 1);
310                ALOGE_IF(result<0, "error reading from wake pipe (%s)", strerror(errno));
311                ALOGE_IF(msg != WAKE_MESSAGE, "unknown message on wake queue (0x%02x)", int(msg));
312                mPollFds[wake].revents = 0;
313            }
314        }
315        // if we have events and space, go read them
316    } while (n && count);
317
318    return nbEvents;
319}
320
321/*****************************************************************************/
322
323static int poll__close(struct hw_device_t *dev)
324{
325    sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;
326    if (ctx) {
327        delete ctx;
328    }
329    return 0;
330}
331
332static int poll__activate(struct sensors_poll_device_t *dev,
333        int handle, int enabled) {
334    sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;
335    return ctx->activate(handle, enabled);
336}
337
338static int poll__setDelay(struct sensors_poll_device_t *dev,
339        int handle, int64_t ns) {
340    sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;
341    return ctx->setDelay(handle, ns);
342}
343
344static int poll__poll(struct sensors_poll_device_t *dev,
345        sensors_event_t* data, int count) {
346    sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;
347    return ctx->pollEvents(data, count);
348}
349
350/*****************************************************************************/
351
352/** Open a new instance of a sensor device using name */
353static int open_sensors(const struct hw_module_t* module, const char* id,
354                        struct hw_device_t** device)
355{
356        int status = -EINVAL;
357        sensors_poll_context_t *dev = new sensors_poll_context_t();
358
359        memset(&dev->device, 0, sizeof(sensors_poll_device_t));
360
361        dev->device.common.tag = HARDWARE_DEVICE_TAG;
362        dev->device.common.version  = 0;
363        dev->device.common.module   = const_cast<hw_module_t*>(module);
364        dev->device.common.close    = poll__close;
365        dev->device.activate        = poll__activate;
366        dev->device.setDelay        = poll__setDelay;
367        dev->device.poll            = poll__poll;
368
369        *device = &dev->device.common;
370        status = 0;
371
372        return status;
373}
374
375