Android: android sensors, HAL范例

来自：http://blog.csdn.net/zmyde2010/article/details/6266384

从源码找到的一个例子，写的很优雅，不知道HAL怎么写的同学可以好好学习一下：

[cpp]  view plain copy

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. #define LOG_NDEBUG 1  
20.   
21. #include <hardware/sensors.h>  
22. #include <fcntl.h>  
23. #include <errno.h>  
24. #include <dirent.h>  
25. #include <math.h>  
26. #include <poll.h>  
27. #include <pthread.h>  
28. #include <sys/select.h>  
29.   
30. #include <linux/input.h>  
31. #include <linux/akm8973.h>  
32. #include <linux/capella_cm3602.h>  
33. #include <linux/lightsensor.h>  
34.   
35. #include <cutils/atomic.h>  
36. #include <cutils/log.h>  
37. #include <cutils/native_handle.h>  
38.   
39. #define __MAX(a,b) ((a)>=(b)?(a):(b))  
40.   
41. /*****************************************************************************/  
42.   
43. #define MAX_NUM_SENSORS 6  
44.   
45. #define SUPPORTED_SENSORS  ((1<<MAX_NUM_SENSORS)-1)  
46.   
47. #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))  
48.   
49. #define ID_A  (0)  
50. #define ID_M  (1)  
51. #define ID_O  (2)  
52. #define ID_T  (3)  
53. #define ID_P  (4)  
54. #define ID_L  (5)  
55.   
56. static int id_to_sensor[MAX_NUM_SENSORS] = {  
57.     [ID_A] = SENSOR_TYPE_ACCELEROMETER,  
58.     [ID_M] = SENSOR_TYPE_MAGNETIC_FIELD,  
59.     [ID_O] = SENSOR_TYPE_ORIENTATION,  
60.     [ID_T] = SENSOR_TYPE_TEMPERATURE,  
61.     [ID_P] = SENSOR_TYPE_PROXIMITY,  
62.     [ID_L] = SENSOR_TYPE_LIGHT,  
63. };  
64.   
65. #define SENSORS_AKM_ACCELERATION   (1<<ID_A)  
66. #define SENSORS_AKM_MAGNETIC_FIELD (1<<ID_M)  
67. #define SENSORS_AKM_ORIENTATION    (1<<ID_O)  
68. #define SENSORS_AKM_TEMPERATURE    (1<<ID_T)  
69. #define SENSORS_AKM_GROUP          ((1<<ID_A)|(1<<ID_M)|(1<<ID_O)|(1<<ID_T))  
70.   
71. #define SENSORS_CM_PROXIMITY       (1<<ID_P)  
72. #define SENSORS_CM_GROUP           (1<<ID_P)  
73.   
74. #define SENSORS_LIGHT              (1<<ID_L)  
75. #define SENSORS_LIGHT_GROUP        (1<<ID_L)  
76.   
77. /*****************************************************************************/  
78.   
79. struct sensors_control_context_t {  
80.     struct sensors_control_device_t device; // must be first  
81.     int akmd_fd;  
82.     int cmd_fd;  
83.     int lsd_fd;  
84.     uint32_t active_sensors;  
85. };  
86.   
87. struct sensors_data_context_t {  
88.     struct sensors_data_device_t device; // must be first  
89.     int events_fd[3];  
90.     sensors_data_t sensors[MAX_NUM_SENSORS];  
91.     uint32_t pendingSensors;  
92. };  
93.   
94. /* 
95.  * The SENSORS Module 
96.  */  
97.   
98. /* the CM3602 is a binary proximity sensor that triggers around 9 cm on 
99.  * this hardware */  
100. #define PROXIMITY_THRESHOLD_CM  9.0f  
101.   
102. /* 
103.  * the AK8973 has a 8-bit ADC but the firmware seems to average 16 samples, 
104.  * or at least makes its calibration on 12-bits values. This increases the 
105.  * resolution by 4 bits. 
106.  */  
107.   
108. static const struct sensor_t sSensorList[] = {  
109.         { "BMA150 3-axis Accelerometer",  
110.                 "Bosh",  
111.                 1, SENSORS_HANDLE_BASE+ID_A,  
112.                 SENSOR_TYPE_ACCELEROMETER, 4.0f*9.81f, (4.0f*9.81f)/256.0f, 0.2f, { } },  
113.         { "AK8973 3-axis Magnetic field sensor",  
114.                 "Asahi Kasei",  
115.                 1, SENSORS_HANDLE_BASE+ID_M,  
116.                 SENSOR_TYPE_MAGNETIC_FIELD, 2000.0f, 1.0f/16.0f, 6.8f, { } },  
117.         { "AK8973 Orientation sensor",  
118.                 "Asahi Kasei",  
119.                 1, SENSORS_HANDLE_BASE+ID_O,  
120.                 SENSOR_TYPE_ORIENTATION, 360.0f, 1.0f, 7.0f, { } },  
121.         { "CM3602 Proximity sensor",  
122.                 "Capella Microsystems",  
123.                 1, SENSORS_HANDLE_BASE+ID_P,  
124.                 SENSOR_TYPE_PROXIMITY,  
125.                 PROXIMITY_THRESHOLD_CM, PROXIMITY_THRESHOLD_CM,  
126.                 0.5f, { } },  
127.         { "CM3602 Light sensor",  
128.                 "Capella Microsystems",  
129.                 1, SENSORS_HANDLE_BASE+ID_L,  
130.                 SENSOR_TYPE_LIGHT, 10240.0f, 1.0f, 0.5f, { } },  
131. };  
132.   
133. static const float sLuxValues[8] = {  
134.     10.0,  
135.     160.0,  
136.     225.0,  
137.     320.0,  
138.     640.0,  
139.     1280.0,  
140.     2600.0,  
141.     10240.0  
142. };  
143.   
144. static int open_sensors(const struct hw_module_t* module, const char* name,  
145.         struct hw_device_t** device);  
146.   
147. static int sensors__get_sensors_list(struct sensors_module_t* module,  
148.         struct sensor_t const** list)  
149. {  
150.     *list = sSensorList;  
151.     return ARRAY_SIZE(sSensorList);  
152. }  
153.   
154. static struct hw_module_methods_t sensors_module_methods = {  
155.     .open = open_sensors  
156. };  
157.   
158. const struct sensors_module_t HAL_MODULE_INFO_SYM = {  
159.     .common = {  
160.         .tag = HARDWARE_MODULE_TAG,  
161.         .version_major = 1,  
162.         .version_minor = 0,  
163.         .id = SENSORS_HARDWARE_MODULE_ID,  
164.         .name = "AK8973A & CM3602 Sensors Module",  
165.         .author = "The Android Open Source Project",  
166.         .methods = &sensors_module_methods,  
167.     },  
168.     .get_sensors_list = sensors__get_sensors_list  
169. };  
170.   
171. /*****************************************************************************/  
172.   
173. #define AKM_DEVICE_NAME     "/dev/akm8973_aot"  
174. #define CM_DEVICE_NAME      "/dev/cm3602"  
175. #define LS_DEVICE_NAME      "/dev/lightsensor"  
176.   
177.   
178. // sensor IDs must be a power of two and  
179. // must match values in SensorManager.java  
180. #define EVENT_TYPE_ACCEL_X          ABS_X  
181. #define EVENT_TYPE_ACCEL_Y          ABS_Z  
182. #define EVENT_TYPE_ACCEL_Z          ABS_Y  
183. #define EVENT_TYPE_ACCEL_STATUS     ABS_WHEEL  
184.   
185. #define EVENT_TYPE_YAW              ABS_RX  
186. #define EVENT_TYPE_PITCH            ABS_RY  
187. #define EVENT_TYPE_ROLL             ABS_RZ  
188. #define EVENT_TYPE_ORIENT_STATUS    ABS_RUDDER  
189.   
190. #define EVENT_TYPE_MAGV_X           ABS_HAT0X  
191. #define EVENT_TYPE_MAGV_Y           ABS_HAT0Y  
192. #define EVENT_TYPE_MAGV_Z           ABS_BRAKE  
193.   
194. #define EVENT_TYPE_TEMPERATURE      ABS_THROTTLE  
195. #define EVENT_TYPE_STEP_COUNT       ABS_GAS  
196. #define EVENT_TYPE_PROXIMITY        ABS_DISTANCE  
197. #define EVENT_TYPE_LIGHT            ABS_MISC  
198.   
199. // 720 LSG = 1G  
200. #define LSG                         (720.0f)  
201.   
202.   
203. // conversion of acceleration data to SI units (m/s^2)  
204. #define CONVERT_A                   (GRAVITY_EARTH / LSG)  
205. #define CONVERT_A_X                 (-CONVERT_A)  
206. #define CONVERT_A_Y                 (CONVERT_A)  
207. #define CONVERT_A_Z                 (-CONVERT_A)  
208.   
209. // conversion of magnetic data to uT units  
210. #define CONVERT_M                   (1.0f/16.0f)  
211. #define CONVERT_M_X                 (-CONVERT_M)  
212. #define CONVERT_M_Y                 (-CONVERT_M)  
213. #define CONVERT_M_Z                 (CONVERT_M)  
214.   
215. #define SENSOR_STATE_MASK           (0x7FFF)  
216.   
217. /*****************************************************************************/  
218.   
219. static int open_inputs(int mode, int *akm_fd, int *p_fd, int *l_fd)  
220. {  
221.     /* scan all input drivers and look for "compass" */  
222.     int fd = -1;  
223.     const char *dirname = "/dev/input";  
224.     char devname[PATH_MAX];  
225.     char *filename;  
226.     DIR *dir;  
227.     struct dirent *de;  
228.     dir = opendir(dirname);  
229.     if(dir == NULL)  
230.         return -1;  
231.     strcpy(devname, dirname);  
232.     filename = devname + strlen(devname);  
233.     *filename++ = '/';  
234.     *akm_fd = *p_fd = -1;  
235.     while((de = readdir(dir))) {  
236.         if(de->d_name[0] == '.' &&  
237.            (de->d_name[1] == '/0' ||  
238.             (de->d_name[1] == '.' && de->d_name[2] == '/0')))  
239.             continue;  
240.         strcpy(filename, de->d_name);  
241.         fd = open(devname, mode);  
242.         if (fd>=0) {  
243.             char name[80];  
244.             if (ioctl(fd, EVIOCGNAME(sizeof(name) - 1), &name) < 1) {  
245.                 name[0] = '/0';  
246.             }  
247.             if (!strcmp(name, "compass")) {  
248.                 LOGV("using %s (name=%s)", devname, name);  
249.                 *akm_fd = fd;  
250.             }  
251.             else if (!strcmp(name, "proximity")) {  
252.                 LOGV("using %s (name=%s)", devname, name);  
253.                 *p_fd = fd;  
254.             }  
255.             else if (!strcmp(name, "lightsensor-level")) {  
256.                 LOGV("using %s (name=%s)", devname, name);  
257.                 *l_fd = fd;  
258.             }  
259.             else  
260.                 close(fd);  
261.         }  
262.     }  
263.     closedir(dir);  
264.   
265.     fd = 0;  
266.     if (*akm_fd < 0) {  
267.         LOGE("Couldn't find or open 'compass' driver (%s)", strerror(errno));  
268.         fd = -1;  
269.     }  
270.     if (*p_fd < 0) {  
271.         LOGE("Couldn't find or open 'proximity' driver (%s)", strerror(errno));  
272.         fd = -1;  
273.     }  
274.     if (*l_fd < 0) {  
275.         LOGE("Couldn't find or open 'light' driver (%s)", strerror(errno));  
276.         fd = -1;  
277.     }  
278.     return fd;  
279. }  
280.   
281. static int open_akm(struct sensors_control_context_t* dev)  
282. {  
283.     if (dev->akmd_fd < 0) {  
284.         dev->akmd_fd = open(AKM_DEVICE_NAME, O_RDONLY);  
285.         LOGV("%s, fd=%d", __PRETTY_FUNCTION__, dev->akmd_fd);  
286.         LOGE_IF(dev->akmd_fd<0, "Couldn't open %s (%s)",  
287.                 AKM_DEVICE_NAME, strerror(errno));  
288.         if (dev->akmd_fd >= 0) {  
289.             dev->active_sensors &= ~SENSORS_AKM_GROUP;  
290.         }  
291.     }  
292.     return dev->akmd_fd;  
293. }  
294.   
295. static void close_akm(struct sensors_control_context_t* dev)  
296. {  
297.     if (dev->akmd_fd >= 0) {  
298.         LOGV("%s, fd=%d", __PRETTY_FUNCTION__, dev->akmd_fd);  
299.         close(dev->akmd_fd);  
300.         dev->akmd_fd = -1;  
301.     }  
302. }  
303.   
304. static uint32_t read_akm_sensors_state(int fd)  
305. {  
306.     short flags;  
307.     uint32_t sensors = 0;  
308.     // read the actual value of all sensors  
309.     if (!ioctl(fd, ECS_IOCTL_APP_GET_MFLAG, &flags)) {  
310.         if (flags)  sensors |= SENSORS_AKM_ORIENTATION;  
311.         else        sensors &= ~SENSORS_AKM_ORIENTATION;  
312.     }  
313.     if (!ioctl(fd, ECS_IOCTL_APP_GET_AFLAG, &flags)) {  
314.         if (flags)  sensors |= SENSORS_AKM_ACCELERATION;  
315.         else        sensors &= ~SENSORS_AKM_ACCELERATION;  
316.     }  
317.     if (!ioctl(fd, ECS_IOCTL_APP_GET_TFLAG, &flags)) {  
318.         if (flags)  sensors |= SENSORS_AKM_TEMPERATURE;  
319.         else        sensors &= ~SENSORS_AKM_TEMPERATURE;  
320.     }  
321.     if (!ioctl(fd, ECS_IOCTL_APP_GET_MVFLAG, &flags)) {  
322.         if (flags)  sensors |= SENSORS_AKM_MAGNETIC_FIELD;  
323.         else        sensors &= ~SENSORS_AKM_MAGNETIC_FIELD;  
324.     }  
325.     return sensors;  
326. }  
327.   
328. static uint32_t enable_disable_akm(struct sensors_control_context_t *dev,  
329.                                    uint32_t active, uint32_t sensors,  
330.                                    uint32_t mask)  
331. {  
332.     uint32_t now_active_akm_sensors;  
333.   
334.     int fd = open_akm(dev);  
335.     if (fd < 0)  
336.         return 0;  
337.   
338.     LOGV("(before) akm sensors = %08x, real = %08x",  
339.          sensors, read_akm_sensors_state(fd));  
340.   
341.     short flags;  
342.     if (mask & SENSORS_AKM_ORIENTATION) {  
343.         flags = (sensors & SENSORS_AKM_ORIENTATION) ? 1 : 0;  
344.         if (ioctl(fd, ECS_IOCTL_APP_SET_MFLAG, &flags) < 0) {  
345.             LOGE("ECS_IOCTL_APP_SET_MFLAG error (%s)", strerror(errno));  
346.         }  
347.     }  
348.     if (mask & SENSORS_AKM_ACCELERATION) {  
349.         flags = (sensors & SENSORS_AKM_ACCELERATION) ? 1 : 0;  
350.         if (ioctl(fd, ECS_IOCTL_APP_SET_AFLAG, &flags) < 0) {  
351.             LOGE("ECS_IOCTL_APP_SET_AFLAG error (%s)", strerror(errno));  
352.         }  
353.     }  
354.     if (mask & SENSORS_AKM_TEMPERATURE) {  
355.         flags = (sensors & SENSORS_AKM_TEMPERATURE) ? 1 : 0;  
356.         if (ioctl(fd, ECS_IOCTL_APP_SET_TFLAG, &flags) < 0) {  
357.             LOGE("ECS_IOCTL_APP_SET_TFLAG error (%s)", strerror(errno));  
358.         }  
359.     }  
360.     if (mask & SENSORS_AKM_MAGNETIC_FIELD) {  
361.         flags = (sensors & SENSORS_AKM_MAGNETIC_FIELD) ? 1 : 0;  
362.         if (ioctl(fd, ECS_IOCTL_APP_SET_MVFLAG, &flags) < 0) {  
363.             LOGE("ECS_IOCTL_APP_SET_MVFLAG error (%s)", strerror(errno));  
364.         }  
365.     }  
366.   
367.     now_active_akm_sensors = read_akm_sensors_state(fd);  
368.   
369.     LOGV("(after) akm sensors = %08x, real = %08x",  
370.          sensors, now_active_akm_sensors);  
371.   
372.     if (!sensors)  
373.         close_akm(dev);  
374.   
375.     return now_active_akm_sensors;  
376. }  
377.   
378. static uint32_t read_cm_sensors_state(int fd)  
379. {  
380.     int flags;  
381.     uint32_t sensors = 0;  
382.     // read the actual value of all sensors  
383.     if (!ioctl(fd, CAPELLA_CM3602_IOCTL_GET_ENABLED, &flags)) {  
384.         if (flags)  sensors |= SENSORS_CM_PROXIMITY;  
385.         else        sensors &= ~SENSORS_CM_PROXIMITY;  
386.     }  
387.   
388.     return sensors;  
389. }  
390.   
391. static int open_cm(struct sensors_control_context_t* dev)  
392. {  
393.     if (dev->cmd_fd < 0) {  
394.         dev->cmd_fd = open(CM_DEVICE_NAME, O_RDONLY);  
395.         LOGV("%s, fd=%d", __PRETTY_FUNCTION__, dev->cmd_fd);  
396.         LOGE_IF(dev->cmd_fd<0, "Couldn't open %s (%s)",  
397.                 CM_DEVICE_NAME, strerror(errno));  
398.         if (dev->cmd_fd >= 0) {  
399.             dev->active_sensors &= ~SENSORS_CM_GROUP;  
400.         }  
401.     }  
402.     return dev->cmd_fd;  
403. }  
404.   
405. static void close_cm(struct sensors_control_context_t* dev)  
406. {  
407.     if (dev->cmd_fd >= 0) {  
408.         LOGV("%s, fd=%d", __PRETTY_FUNCTION__, dev->cmd_fd);  
409.         close(dev->cmd_fd);  
410.         dev->cmd_fd = -1;  
411.     }  
412. }  
413.   
414. static int enable_disable_cm(struct sensors_control_context_t *dev,  
415.                              uint32_t active, uint32_t sensors, uint32_t mask)  
416. {  
417.     int rc = 0;  
418.     uint32_t now_active_cm_sensors;  
419.     int fd = open_cm(dev);  
420.   
421.     if (fd < 0) {  
422.         LOGE("Couldn't open %s (%s)", CM_DEVICE_NAME, strerror(errno));  
423.         return 0;  
424.     }  
425.   
426.     LOGV("(before) cm sensors = %08x, real = %08x",  
427.          sensors, read_cm_sensors_state(fd));  
428.   
429.     if (mask & SENSORS_CM_PROXIMITY) {  
430.         int flags = (sensors & SENSORS_CM_PROXIMITY) ? 1 : 0;  
431.         rc = ioctl(fd, CAPELLA_CM3602_IOCTL_ENABLE, &flags);  
432.         if (rc < 0)  
433.             LOGE("CAPELLA_CM3602_IOCTL_ENABLE error (%s)", strerror(errno));  
434.     }  
435.   
436.     now_active_cm_sensors = read_cm_sensors_state(fd);  
437.   
438.     LOGV("(after) cm sensors = %08x, real = %08x",  
439.          sensors, now_active_cm_sensors);  
440.   
441.     return now_active_cm_sensors;  
442. }  
443.   
444. static uint32_t read_ls_sensors_state(int fd)  
445. {  
446.     int flags;  
447.     uint32_t sensors = 0;  
448.     // read the actual value of all sensors  
449.     if (!ioctl(fd, LIGHTSENSOR_IOCTL_GET_ENABLED, &flags)) {  
450.         if (flags)  sensors |= SENSORS_LIGHT;  
451.         else        sensors &= ~SENSORS_LIGHT;  
452.     }  
453.   
454.     return sensors;  
455. }  
456.   
457. static int open_ls(struct sensors_control_context_t* dev)  
458. {  
459.     if (dev->lsd_fd < 0) {  
460.         dev->lsd_fd = open(LS_DEVICE_NAME, O_RDONLY);  
461.         LOGV("%s, fd=%d", __PRETTY_FUNCTION__, dev->lsd_fd);  
462.         LOGE_IF(dev->lsd_fd<0, "Couldn't open %s (%s)",  
463.                 LS_DEVICE_NAME, strerror(errno));  
464.         if (dev->lsd_fd >= 0) {  
465.             dev->active_sensors &= ~SENSORS_LIGHT_GROUP;  
466.         }  
467.     }  
468.     return dev->lsd_fd;  
469. }  
470.   
471. static void close_ls(struct sensors_control_context_t* dev)  
472. {  
473.     if (dev->lsd_fd >= 0) {  
474.         LOGV("%s, fd=%d", __PRETTY_FUNCTION__, dev->lsd_fd);  
475.         close(dev->lsd_fd);  
476.         dev->lsd_fd = -1;  
477.     }  
478. }  
479.   
480. static int enable_disable_ls(struct sensors_control_context_t *dev,  
481.                              uint32_t active, uint32_t sensors, uint32_t mask)  
482. {  
483.     int rc = 0;  
484.     uint32_t now_active_ls_sensors;  
485.     int fd = open_ls(dev);  
486.   
487.     if (fd < 0) {  
488.         LOGE("Couldn't open %s (%s)", LS_DEVICE_NAME, strerror(errno));  
489.         return 0;  
490.     }  
491.   
492.     LOGV("(before) ls sensors = %08x, real = %08x",  
493.          sensors, read_ls_sensors_state(fd));  
494.   
495.     if (mask & SENSORS_LIGHT) {  
496.         int flags = (sensors & SENSORS_LIGHT) ? 1 : 0;  
497.         rc = ioctl(fd, LIGHTSENSOR_IOCTL_ENABLE, &flags);  
498.         if (rc < 0)  
499.             LOGE("LIGHTSENSOR_IOCTL_ENABLE error (%s)", strerror(errno));  
500.     }  
501.   
502.     now_active_ls_sensors = read_ls_sensors_state(fd);  
503.   
504.     LOGV("(after) ls sensors = %08x, real = %08x",  
505.          sensors, now_active_ls_sensors);  
506.   
507.     return now_active_ls_sensors;  
508. }  
509.   
510. /*****************************************************************************/  
511.   
512. static native_handle_t* control__open_data_source(struct sensors_control_context_t *dev)  
513. {  
514.     native_handle_t* handle;  
515.     int akm_fd, p_fd, l_fd;  
516.   
517.     if (open_inputs(O_RDONLY, &akm_fd, &p_fd, &l_fd) < 0 ||  
518.             akm_fd < 0 || p_fd < 0 || l_fd < 0) {  
519.         return NULL;  
520.     }  
521.   
522.     handle = native_handle_create(3, 0);  
523.     handle->data[0] = akm_fd;  
524.     handle->data[1] = p_fd;  
525.     handle->data[2] = l_fd;  
526.   
527.     return handle;  
528. }  
529.   
530. static int control__activate(struct sensors_control_context_t *dev,  
531.         int handle, int enabled)  
532. {  
533.     if ((handle < SENSORS_HANDLE_BASE) ||  
534.             (handle >= SENSORS_HANDLE_BASE+MAX_NUM_SENSORS))  
535.         return -1;  
536.   
537.     uint32_t mask = (1 << handle);  
538.     uint32_t sensors = enabled ? mask : 0;  
539.   
540.     uint32_t active = dev->active_sensors;  
541.     uint32_t new_sensors = (active & ~mask) | (sensors & mask);  
542.     uint32_t changed = active ^ new_sensors;  
543.   
544.     if (changed) {  
545.         if (!active && new_sensors)  
546.             // force all sensors to be updated  
547.             changed = SUPPORTED_SENSORS;  
548.   
549.         dev->active_sensors =  
550.             enable_disable_akm(dev,  
551.                                active & SENSORS_AKM_GROUP,  
552.                                new_sensors & SENSORS_AKM_GROUP,  
553.                                changed & SENSORS_AKM_GROUP) |  
554.             enable_disable_cm(dev,  
555.                               active & SENSORS_CM_GROUP,  
556.                               new_sensors & SENSORS_CM_GROUP,  
557.                               changed & SENSORS_CM_GROUP) |  
558.             enable_disable_ls(dev,  
559.                               active & SENSORS_LIGHT_GROUP,  
560.                               new_sensors & SENSORS_LIGHT_GROUP,  
561.                               changed & SENSORS_LIGHT_GROUP);  
562.     }  
563.   
564.     return 0;  
565. }  
566.   
567. static int control__set_delay(struct sensors_control_context_t *dev, int32_t ms)  
568. {  
569. #ifdef ECS_IOCTL_APP_SET_DELAY  
570.     if (dev->akmd_fd <= 0) {  
571.         return -1;  
572.     }  
573.     short delay = ms;  
574.     if (!ioctl(dev->akmd_fd, ECS_IOCTL_APP_SET_DELAY, &delay)) {  
575.         return -errno;  
576.     }  
577.     return 0;  
578. #else  
579.     return -1;  
580. #endif  
581. }  
582.   
583. static int control__wake(struct sensors_control_context_t *dev)  
584. {  
585.     int err = 0;  
586.     int akm_fd, p_fd, l_fd;  
587.     if (open_inputs(O_RDWR, &akm_fd, &p_fd, &l_fd) < 0 ||  
588.             akm_fd < 0 || p_fd < 0 || l_fd < 0) {  
589.         return -1;  
590.     }  
591.   
592.     struct input_event event[1];  
593.     event[0].type = EV_SYN;  
594.     event[0].code = SYN_CONFIG;  
595.     event[0].value = 0;  
596.   
597.     err = write(akm_fd, event, sizeof(event));  
598.     LOGV_IF(err<0, "control__wake(compass), fd=%d (%s)",  
599.             akm_fd, strerror(errno));  
600.     close(akm_fd);  
601.   
602.     err = write(p_fd, event, sizeof(event));  
603.     LOGV_IF(err<0, "control__wake(proximity), fd=%d (%s)",  
604.             p_fd, strerror(errno));  
605.     close(p_fd);  
606.   
607.     err = write(l_fd, event, sizeof(event));  
608.     LOGV_IF(err<0, "control__wake(light), fd=%d (%s)",  
609.             l_fd, strerror(errno));  
610.     close(l_fd);  
611.   
612.     return err;  
613. }  
614.   
615. /*****************************************************************************/  
616.   
617. static int data__data_open(struct sensors_data_context_t *dev, native_handle_t* handle)  
618. {  
619.     int i;  
620.     struct input_absinfo absinfo;  
621.     memset(&dev->sensors, 0, sizeof(dev->sensors));  
622.   
623.     for (i = 0; i < MAX_NUM_SENSORS; i++) {  
624.         // by default all sensors have high accuracy  
625.         // (we do this because we don't get an update if the value doesn't  
626.         // change).  
627.         dev->sensors[i].vector.status = SENSOR_STATUS_ACCURACY_HIGH;  
628.     }  
629.   
630.     dev->sensors[ID_A].sensor = SENSOR_TYPE_ACCELEROMETER;  
631.     dev->sensors[ID_M].sensor = SENSOR_TYPE_MAGNETIC_FIELD;  
632.     dev->sensors[ID_O].sensor = SENSOR_TYPE_ORIENTATION;  
633.     dev->sensors[ID_T].sensor = SENSOR_TYPE_TEMPERATURE;  
634.     dev->sensors[ID_P].sensor = SENSOR_TYPE_PROXIMITY;  
635.     dev->sensors[ID_L].sensor = SENSOR_TYPE_LIGHT;  
636.   
637.     dev->events_fd[0] = dup(handle->data[0]);  
638.     dev->events_fd[1] = dup(handle->data[1]);  
639.     dev->events_fd[2] = dup(handle->data[2]);  
640.     LOGV("data__data_open: compass fd = %d", handle->data[0]);  
641.     LOGV("data__data_open: proximity fd = %d", handle->data[1]);  
642.     LOGV("data__data_open: light fd = %d", handle->data[2]);  
643.     // Framework will close the handle  
644.     native_handle_delete(handle);  
645.   
646.     dev->pendingSensors = 0;  
647.     if (!ioctl(dev->events_fd[1], EVIOCGABS(ABS_DISTANCE), &absinfo)) {  
648.         LOGV("proximity sensor initial value %d/n", absinfo.value);  
649.         dev->pendingSensors |= SENSORS_CM_PROXIMITY;  
650.         // FIXME: we should save here absinfo.{minimum, maximum, etc}  
651.         //        and use them to scale the return value according to  
652.         //        the sensor description.  
653.         dev->sensors[ID_P].distance = (float)absinfo.value;  
654.     }  
655.     else LOGE("Cannot get proximity sensor initial value: %s/n",  
656.               strerror(errno));  
657.   
658.     return 0;  
659. }  
660.   
661. static int data__data_close(struct sensors_data_context_t *dev)  
662. {  
663.     if (dev->events_fd[0] >= 0) {  
664.         //LOGV("(data close) about to close compass fd=%d", dev->events_fd[0]);  
665.         close(dev->events_fd[0]);  
666.         dev->events_fd[0] = -1;  
667.     }  
668.     if (dev->events_fd[1] >= 0) {  
669.         //LOGV("(data close) about to close proximity fd=%d", dev->events_fd[1]);  
670.         close(dev->events_fd[1]);  
671.         dev->events_fd[1] = -1;  
672.     }  
673.     if (dev->events_fd[2] >= 0) {  
674.         //LOGV("(data close) about to close light fd=%d", dev->events_fd[1]);  
675.         close(dev->events_fd[2]);  
676.         dev->events_fd[2] = -1;  
677.     }  
678.     return 0;  
679. }  
680.   
681. static int pick_sensor(struct sensors_data_context_t *dev,  
682.         sensors_data_t* values)  
683. {  
684.     uint32_t mask = SUPPORTED_SENSORS;  
685.     while (mask) {  
686.         uint32_t i = 31 - __builtin_clz(mask);  
687.         mask &= ~(1<<i);  
688.         if (dev->pendingSensors & (1<<i)) {  
689.             dev->pendingSensors &= ~(1<<i);  
690.             *values = dev->sensors[i];  
691.             values->sensor = id_to_sensor[i];  
692.             LOGV_IF(0, "%d [%f, %f, %f]",  
693.                     values->sensor,  
694.                     values->vector.x,  
695.                     values->vector.y,  
696.                     values->vector.z);  
697.             return i;  
698.         }  
699.     }  
700.   
701.     LOGE("no sensor to return: pendingSensors = %08x", dev->pendingSensors);  
702.     return -1;  
703. }  
704.   
705. static uint32_t data__poll_process_akm_abs(struct sensors_data_context_t *dev,  
706.                                            int fd __attribute__((unused)),  
707.                                            struct input_event *event)  
708. {  
709.     uint32_t new_sensors = 0;  
710.     if (event->type == EV_ABS) {  
711.         LOGV("compass type: %d code: %d value: %-5d time: %ds",  
712.              event->type, event->code, event->value,  
713.              (int)event->time.tv_sec);  
714.         switch (event->code) {  
715.         case EVENT_TYPE_ACCEL_X:  
716.             new_sensors |= SENSORS_AKM_ACCELERATION;  
717.             dev->sensors[ID_A].acceleration.x = event->value * CONVERT_A_X;  
718.             break;  
719.         case EVENT_TYPE_ACCEL_Y:  
720.             new_sensors |= SENSORS_AKM_ACCELERATION;  
721.             dev->sensors[ID_A].acceleration.y = event->value * CONVERT_A_Y;  
722.             break;  
723.         case EVENT_TYPE_ACCEL_Z:  
724.             new_sensors |= SENSORS_AKM_ACCELERATION;  
725.             dev->sensors[ID_A].acceleration.z = event->value * CONVERT_A_Z;  
726.             break;  
727.         case EVENT_TYPE_MAGV_X:  
728.             new_sensors |= SENSORS_AKM_MAGNETIC_FIELD;  
729.             dev->sensors[ID_M].magnetic.x = event->value * CONVERT_M_X;  
730.             break;  
731.         case EVENT_TYPE_MAGV_Y:  
732.             new_sensors |= SENSORS_AKM_MAGNETIC_FIELD;  
733.             dev->sensors[ID_M].magnetic.y = event->value * CONVERT_M_Y;  
734.             break;  
735.         case EVENT_TYPE_MAGV_Z:  
736.             new_sensors |= SENSORS_AKM_MAGNETIC_FIELD;  
737.             dev->sensors[ID_M].magnetic.z = event->value * CONVERT_M_Z;  
738.             break;  
739.         case EVENT_TYPE_YAW:  
740.             new_sensors |= SENSORS_AKM_ORIENTATION;  
741.             dev->sensors[ID_O].orientation.azimuth =  event->value;  
742.             break;  
743.         case EVENT_TYPE_PITCH:  
744.             new_sensors |= SENSORS_AKM_ORIENTATION;  
745.             dev->sensors[ID_O].orientation.pitch = event->value;  
746.             break;  
747.         case EVENT_TYPE_ROLL:  
748.             new_sensors |= SENSORS_AKM_ORIENTATION;  
749.             dev->sensors[ID_O].orientation.roll = -event->value;  
750.             break;  
751.         case EVENT_TYPE_TEMPERATURE:  
752.             new_sensors |= SENSORS_AKM_TEMPERATURE;  
753.             dev->sensors[ID_T].temperature = event->value;  
754.             break;  
755.         case EVENT_TYPE_STEP_COUNT:  
756.             // step count (only reported in MODE_FFD)  
757.             // we do nothing with it for now.  
758.             break;  
759.         case EVENT_TYPE_ACCEL_STATUS:  
760.             // accuracy of the calibration (never returned!)  
761.             //LOGV("G-Sensor status %d", event->value);  
762.             break;  
763.         case EVENT_TYPE_ORIENT_STATUS: {  
764.             // accuracy of the calibration  
765.             uint32_t v = (uint32_t)(event->value & SENSOR_STATE_MASK);  
766.             LOGV_IF(dev->sensors[ID_O].orientation.status != (uint8_t)v,  
767.                     "M-Sensor status %d", v);  
768.             dev->sensors[ID_O].orientation.status = (uint8_t)v;  
769.         }  
770.             break;  
771.         }  
772.     }  
773.   
774.     return new_sensors;  
775. }  
776.   
777. static uint32_t data__poll_process_cm_abs(struct sensors_data_context_t *dev,  
778.                                            int fd __attribute__((unused)),  
779.                                           struct input_event *event)  
780. {  
781.     uint32_t new_sensors = 0;  
782.     if (event->type == EV_ABS) {  
783.         LOGV("proximity type: %d code: %d value: %-5d time: %ds",  
784.              event->type, event->code, event->value,  
785.              (int)event->time.tv_sec);  
786.         if (event->code == EVENT_TYPE_PROXIMITY) {  
787.             new_sensors |= SENSORS_CM_PROXIMITY;  
788.             /* event->value seems to be 0 or 1, scale it to the threshold */  
789.             dev->sensors[ID_P].distance = event->value * PROXIMITY_THRESHOLD_CM;  
790.         }  
791.     }  
792.     return new_sensors;  
793. }  
794.   
795. static uint32_t data__poll_process_ls_abs(struct sensors_data_context_t *dev,  
796.                                           int fd __attribute__((unused)),  
797.                                           struct input_event *event)  
798. {  
799.     uint32_t new_sensors = 0;  
800.     if (event->type == EV_ABS) {  
801.         LOGV("light-level type: %d code: %d value: %-5d time: %ds",  
802.              event->type, event->code, event->value,  
803.              (int)event->time.tv_sec);  
804.         if (event->code == EVENT_TYPE_LIGHT) {  
805.             struct input_absinfo absinfo;  
806.             int index;  
807.             if (!ioctl(fd, EVIOCGABS(ABS_DISTANCE), &absinfo)) {  
808.                 index = event->value;  
809.                 if (index >= 0) {  
810.                     new_sensors |= SENSORS_LIGHT;  
811.                     if (index >= ARRAY_SIZE(sLuxValues)) {  
812.                         index = ARRAY_SIZE(sLuxValues) - 1;  
813.                     }  
814.                     dev->sensors[ID_L].light = sLuxValues[index];  
815.                 }  
816.             }  
817.         }  
818.     }  
819.     return new_sensors;  
820. }  
821.   
822. static void data__poll_process_syn(struct sensors_data_context_t *dev,  
823.                                    struct input_event *event,  
824.                                    uint32_t new_sensors)  
825. {  
826.     if (new_sensors) {  
827.         dev->pendingSensors |= new_sensors;  
828.         int64_t t = event->time.tv_sec*1000000000LL +  
829.             event->time.tv_usec*1000;  
830.         while (new_sensors) {  
831.             uint32_t i = 31 - __builtin_clz(new_sensors);  
832.             new_sensors &= ~(1<<i);  
833.             dev->sensors[i].time = t;  
834.         }  
835.     }  
836. }  
837.   
838. static int data__poll(struct sensors_data_context_t *dev, sensors_data_t* values)  
839. {  
840.     int akm_fd = dev->events_fd[0];  
841.     int cm_fd = dev->events_fd[1];  
842.     int ls_fd = dev->events_fd[2];  
843.   
844.     if (akm_fd < 0) {  
845.         LOGE("invalid compass file descriptor, fd=%d", akm_fd);  
846.         return -1;  
847.     }  
848.   
849.     if (cm_fd < 0) {  
850.         LOGE("invalid proximity-sensor file descriptor, fd=%d", cm_fd);  
851.         return -1;  
852.     }  
853.   
854.     if (ls_fd < 0) {  
855.         LOGE("invalid light-sensor file descriptor, fd=%d", ls_fd);  
856.         return -1;  
857.     }  
858.   
859.     // there are pending sensors, returns them now...  
860.     if (dev->pendingSensors) {  
861.         LOGV("pending sensors 0x%08x", dev->pendingSensors);  
862.         return pick_sensor(dev, values);  
863.     }  
864.   
865.     // wait until we get a complete event for an enabled sensor  
866.     uint32_t new_sensors = 0;  
867.     while (1) {  
868.         /* read the next event; first, read the compass event, then the 
869.            proximity event */  
870.         struct input_event event;  
871.         int got_syn = 0;  
872.         int exit = 0;  
873.         int nread;  
874.         fd_set rfds;  
875.         int n;  
876.   
877.         FD_ZERO(&rfds);  
878.         FD_SET(akm_fd, &rfds);  
879.         FD_SET(cm_fd, &rfds);  
880.         FD_SET(ls_fd, &rfds);  
881.         n = select(__MAX(akm_fd, __MAX(cm_fd, ls_fd)) + 1, &rfds,  
882.                    NULL, NULL, NULL);  
883.         LOGV("return from select: %d/n", n);  
884.         if (n < 0) {  
885.             LOGE("%s: error from select(%d, %d): %s",  
886.                  __FUNCTION__,  
887.                  akm_fd, cm_fd, strerror(errno));  
888.             return -1;  
889.         }  
890.   
891.         if (FD_ISSET(akm_fd, &rfds)) {  
892.             nread = read(akm_fd, &event, sizeof(event));  
893.             if (nread == sizeof(event)) {  
894.                 new_sensors |= data__poll_process_akm_abs(dev, akm_fd, &event);  
895.                 LOGV("akm abs %08x", new_sensors);  
896.                 got_syn = event.type == EV_SYN;  
897.                 exit = got_syn && event.code == SYN_CONFIG;  
898.                 if (got_syn) {  
899.                     LOGV("akm syn %08x", new_sensors);  
900.                     data__poll_process_syn(dev, &event, new_sensors);  
901.                     new_sensors = 0;  
902.                 }  
903.             }  
904.             else LOGE("akm read too small %d", nread);  
905.         }  
906.         else LOGV("akm fd is not set");  
907.   
908.         if (FD_ISSET(cm_fd, &rfds)) {  
909.             nread = read(cm_fd, &event, sizeof(event));  
910.             if (nread == sizeof(event)) {  
911.                 new_sensors |= data__poll_process_cm_abs(dev, cm_fd, &event);  
912.                 LOGV("cm abs %08x", new_sensors);  
913.                 got_syn |= event.type == EV_SYN;  
914.                 exit |= got_syn && event.code == SYN_CONFIG;  
915.                 if (got_syn) {  
916.                     LOGV("cm syn %08x", new_sensors);  
917.                     data__poll_process_syn(dev, &event, new_sensors);  
918.                     new_sensors = 0;  
919.                 }  
920.             }  
921.             else LOGE("cm read too small %d", nread);  
922.         }  
923.         else LOGV("cm fd is not set");  
924.   
925.         if (FD_ISSET(ls_fd, &rfds)) {  
926.             nread = read(ls_fd, &event, sizeof(event));  
927.             if (nread == sizeof(event)) {  
928.                 new_sensors |= data__poll_process_ls_abs(dev, ls_fd, &event);  
929.                 LOGV("ls abs %08x", new_sensors);  
930.                 got_syn |= event.type == EV_SYN;  
931.                 exit |= got_syn && event.code == SYN_CONFIG;  
932.                 if (got_syn) {  
933.                     LOGV("ls syn %08x", new_sensors);  
934.                     data__poll_process_syn(dev, &event, new_sensors);  
935.                     new_sensors = 0;  
936.                 }  
937.             }  
938.             else LOGE("ls read too small %d", nread);  
939.         }  
940.         else LOGV("ls fd is not set");  
941.   
942.         if (exit) {  
943.             // we use SYN_CONFIG to signal that we need to exit the  
944.             // main loop.  
945.             //LOGV("got empty message: value=%d", event->value);  
946.             LOGV("exit");  
947.             return 0x7FFFFFFF;  
948.         }  
949.   
950.         if (got_syn && dev->pendingSensors) {  
951.             LOGV("got syn, picking sensor");  
952.             return pick_sensor(dev, values);  
953.         }  
954.     }  
955. }  
956.   
957. /*****************************************************************************/  
958.   
959. static int control__close(struct hw_device_t *dev)  
960. {  
961.     struct sensors_control_context_t* ctx =  
962.         (struct sensors_control_context_t*)dev;  
963.     if (ctx) {  
964.         close_akm(ctx);  
965.         close_cm(ctx);  
966.         close_ls(ctx);  
967.         free(ctx);  
968.     }  
969.     return 0;  
970. }  
971.   
972. static int data__close(struct hw_device_t *dev)  
973. {  
974.     struct sensors_data_context_t* ctx = (struct sensors_data_context_t*)dev;  
975.     if (ctx) {  
976.         data__data_close(ctx);  
977.         free(ctx);  
978.     }  
979.     return 0;  
980. }  
981.   
982.   
983. /** Open a new instance of a sensor device using name */  
984. static int open_sensors(const struct hw_module_t* module, const char* name,  
985.         struct hw_device_t** device)  
986. {  
987.     int status = -EINVAL;  
988.     if (!strcmp(name, SENSORS_HARDWARE_CONTROL)) {  
989.         struct sensors_control_context_t *dev;  
990.         dev = malloc(sizeof(*dev));  
991.         memset(dev, 0, sizeof(*dev));  
992.         dev->akmd_fd = -1;  
993.         dev->cmd_fd = -1;  
994.         dev->lsd_fd = -1;  
995.         dev->device.common.tag = HARDWARE_DEVICE_TAG;  
996.         dev->device.common.version = 0;  
997.         dev->device.common.module = module;  
998.         dev->device.common.close = control__close;  
999.         dev->device.open_data_source = control__open_data_source;  
1000.         dev->device.activate = control__activate;  
1001.         dev->device.set_delay= control__set_delay;  
1002.         dev->device.wake = control__wake;  
1003.         *device = &dev->device.common;  
1004.     } else if (!strcmp(name, SENSORS_HARDWARE_DATA)) {  
1005.         struct sensors_data_context_t *dev;  
1006.         dev = malloc(sizeof(*dev));  
1007.         memset(dev, 0, sizeof(*dev));  
1008.         dev->events_fd[0] = -1;  
1009.         dev->events_fd[1] = -1;  
1010.         dev->events_fd[2] = -1;  
1011.         dev->device.common.tag = HARDWARE_DEVICE_TAG;  
1012.         dev->device.common.version = 0;  
1013.         dev->device.common.module = module;  
1014.         dev->device.common.close = data__close;  
1015.         dev->device.data_open = data__data_open;  
1016.         dev->device.data_close = data__data_close;  
1017.         dev->device.poll = data__poll;  
1018.         *device = &dev->device.common;  
1019.     }  
1020.     return status;  
1021. }