1 /*
2 * Copyright (C) 2012 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 #ifndef ANDROID_SENSORS_INTERFACE_H
18 #define ANDROID_SENSORS_INTERFACE_H
19
20 #include <stdint.h>
21 #include <sys/cdefs.h>
22 #include <sys/types.h>
23
24 #include <hardware/hardware.h>
25 #include <cutils/native_handle.h>
26
27 #include "sensors-base.h"
28
29 __BEGIN_DECLS
30
31 /*****************************************************************************/
32
33 #define SENSORS_HEADER_VERSION 1
34 #define SENSORS_MODULE_API_VERSION_0_1 HARDWARE_MODULE_API_VERSION(0, 1)
35 #define SENSORS_DEVICE_API_VERSION_0_1 HARDWARE_DEVICE_API_VERSION_2(0, 1, SENSORS_HEADER_VERSION)
36 #define SENSORS_DEVICE_API_VERSION_1_0 HARDWARE_DEVICE_API_VERSION_2(1, 0, SENSORS_HEADER_VERSION)
37 #define SENSORS_DEVICE_API_VERSION_1_1 HARDWARE_DEVICE_API_VERSION_2(1, 1, SENSORS_HEADER_VERSION)
38 #define SENSORS_DEVICE_API_VERSION_1_2 HARDWARE_DEVICE_API_VERSION_2(1, 2, SENSORS_HEADER_VERSION)
39 #define SENSORS_DEVICE_API_VERSION_1_3 HARDWARE_DEVICE_API_VERSION_2(1, 3, SENSORS_HEADER_VERSION)
40 #define SENSORS_DEVICE_API_VERSION_1_4 HARDWARE_DEVICE_API_VERSION_2(1, 4, SENSORS_HEADER_VERSION)
41
42 /**
43 * Please see the Sensors section of source.android.com for an
44 * introduction to and detailed descriptions of Android sensor types:
45 * http://source.android.com/devices/sensors/index.html
46 */
47
48 /**
49 * The id of this module
50 */
51 #define SENSORS_HARDWARE_MODULE_ID "sensors"
52
53 /**
54 * Name of the sensors device to open
55 */
56 #define SENSORS_HARDWARE_POLL "poll"
57
58 /**
59 * Sensor handle is greater than 0 and less than INT32_MAX.
60 *
61 * **** Deprecated ****
62 * Defined values below are kept for code compatibility. Note sensor handle can be as large as
63 * INT32_MAX.
64 */
65 #define SENSORS_HANDLE_BASE 0
66 #define SENSORS_HANDLE_BITS 31
67 #define SENSORS_HANDLE_COUNT (1ull<<SENSORS_HANDLE_BITS)
68
69
70 /*
71 * **** Deprecated *****
72 * flags for (*batch)()
73 * Availability: SENSORS_DEVICE_API_VERSION_1_0
74 * see (*batch)() documentation for details.
75 * Deprecated as of SENSORS_DEVICE_API_VERSION_1_3.
76 * WAKE_UP_* sensors replace WAKE_UPON_FIFO_FULL concept.
77 */
78 enum {
79 SENSORS_BATCH_DRY_RUN = 0x00000001,
80 SENSORS_BATCH_WAKE_UPON_FIFO_FULL = 0x00000002
81 };
82
83 /*
84 * what field for meta_data_event_t
85 */
86 enum {
87 /* a previous flush operation has completed */
88 // META_DATA_FLUSH_COMPLETE = 1,
89 META_DATA_VERSION /* always last, leave auto-assigned */
90 };
91
92 /*
93 * The permission to use for body sensors (like heart rate monitors).
94 * See sensor types for more details on what sensors should require this
95 * permission.
96 */
97 #define SENSOR_PERMISSION_BODY_SENSORS "android.permission.BODY_SENSORS"
98
99 /*
100 * sensor flags legacy names
101 *
102 * please use SENSOR_FLAG_* directly for new implementation.
103 * @see sensor_t
104 */
105
106 #define SENSOR_FLAG_MASK(nbit, shift) (((1<<(nbit))-1)<<(shift))
107 #define SENSOR_FLAG_MASK_1(shift) SENSOR_FLAG_MASK(1, shift)
108
109 /*
110 * Mask and shift for reporting mode sensor flags defined above.
111 */
112 #define REPORTING_MODE_SHIFT SENSOR_FLAG_SHIFT_REPORTING_MODE
113 #define REPORTING_MODE_NBIT (3)
114 #define REPORTING_MODE_MASK SENSOR_FLAG_MASK_REPORTING_MODE
115
116 /*
117 * Mask and shift for data_injection mode sensor flags defined above.
118 */
119 #define DATA_INJECTION_SHIFT SENSOR_FLAG_SHIFT_DATA_INJECTION
120 #define DATA_INJECTION_MASK SENSOR_FLAG_DATA_INJECTION
121
122 /*
123 * Mask and shift for dynamic sensor flag.
124 */
125 #define DYNAMIC_SENSOR_SHIFT SENSOR_FLAG_SHIFT_DYNAMIC_SENSOR
126 #define DYNAMIC_SENSOR_MASK SENSOR_FLAG_DYNAMIC_SENSOR
127
128 /*
129 * Mask and shift for sensor additional information support.
130 */
131 #define ADDITIONAL_INFO_SHIFT SENSOR_FLAG_SHIFT_ADDITIONAL_INFO
132 #define ADDITIONAL_INFO_MASK SENSOR_FLAG_ADDITIONAL_INFO
133
134 /*
135 * Legacy alias of SENSOR_TYPE_MAGNETIC_FIELD.
136 *
137 * Previously, the type of a sensor measuring local magnetic field is named
138 * SENSOR_TYPE_GEOMAGNETIC_FIELD and SENSOR_TYPE_MAGNETIC_FIELD is its alias.
139 * SENSOR_TYPE_MAGNETIC_FIELD is redefined as primary name to avoid confusion.
140 * SENSOR_TYPE_GEOMAGNETIC_FIELD is the alias and is deprecating. New implementation must not use
141 * SENSOR_TYPE_GEOMAGNETIC_FIELD.
142 */
143 #define SENSOR_TYPE_GEOMAGNETIC_FIELD SENSOR_TYPE_MAGNETIC_FIELD
144
145 /*
146 * Sensor string types for Android defined sensor types.
147 *
148 * For Android defined sensor types, string type will be override in sensor service and thus no
149 * longer needed to be added to sensor_t data structure.
150 *
151 * These definitions are going to be removed soon.
152 */
153 #define SENSOR_STRING_TYPE_ACCELEROMETER "android.sensor.accelerometer"
154 #define SENSOR_STRING_TYPE_MAGNETIC_FIELD "android.sensor.magnetic_field"
155 #define SENSOR_STRING_TYPE_ORIENTATION "android.sensor.orientation"
156 #define SENSOR_STRING_TYPE_GYROSCOPE "android.sensor.gyroscope"
157 #define SENSOR_STRING_TYPE_LIGHT "android.sensor.light"
158 #define SENSOR_STRING_TYPE_PRESSURE "android.sensor.pressure"
159 #define SENSOR_STRING_TYPE_TEMPERATURE "android.sensor.temperature"
160 #define SENSOR_STRING_TYPE_PROXIMITY "android.sensor.proximity"
161 #define SENSOR_STRING_TYPE_GRAVITY "android.sensor.gravity"
162 #define SENSOR_STRING_TYPE_LINEAR_ACCELERATION "android.sensor.linear_acceleration"
163 #define SENSOR_STRING_TYPE_ROTATION_VECTOR "android.sensor.rotation_vector"
164 #define SENSOR_STRING_TYPE_RELATIVE_HUMIDITY "android.sensor.relative_humidity"
165 #define SENSOR_STRING_TYPE_AMBIENT_TEMPERATURE "android.sensor.ambient_temperature"
166 #define SENSOR_STRING_TYPE_MAGNETIC_FIELD_UNCALIBRATED "android.sensor.magnetic_field_uncalibrated"
167 #define SENSOR_STRING_TYPE_GAME_ROTATION_VECTOR "android.sensor.game_rotation_vector"
168 #define SENSOR_STRING_TYPE_GYROSCOPE_UNCALIBRATED "android.sensor.gyroscope_uncalibrated"
169 #define SENSOR_STRING_TYPE_SIGNIFICANT_MOTION "android.sensor.significant_motion"
170 #define SENSOR_STRING_TYPE_STEP_DETECTOR "android.sensor.step_detector"
171 #define SENSOR_STRING_TYPE_STEP_COUNTER "android.sensor.step_counter"
172 #define SENSOR_STRING_TYPE_GEOMAGNETIC_ROTATION_VECTOR "android.sensor.geomagnetic_rotation_vector"
173 #define SENSOR_STRING_TYPE_HEART_RATE "android.sensor.heart_rate"
174 #define SENSOR_STRING_TYPE_TILT_DETECTOR "android.sensor.tilt_detector"
175 #define SENSOR_STRING_TYPE_WAKE_GESTURE "android.sensor.wake_gesture"
176 #define SENSOR_STRING_TYPE_GLANCE_GESTURE "android.sensor.glance_gesture"
177 #define SENSOR_STRING_TYPE_PICK_UP_GESTURE "android.sensor.pick_up_gesture"
178 #define SENSOR_STRING_TYPE_WRIST_TILT_GESTURE "android.sensor.wrist_tilt_gesture"
179 #define SENSOR_STRING_TYPE_DEVICE_ORIENTATION "android.sensor.device_orientation"
180 #define SENSOR_STRING_TYPE_POSE_6DOF "android.sensor.pose_6dof"
181 #define SENSOR_STRING_TYPE_STATIONARY_DETECT "android.sensor.stationary_detect"
182 #define SENSOR_STRING_TYPE_MOTION_DETECT "android.sensor.motion_detect"
183 #define SENSOR_STRING_TYPE_HEART_BEAT "android.sensor.heart_beat"
184 #define SENSOR_STRING_TYPE_DYNAMIC_SENSOR_META "android.sensor.dynamic_sensor_meta"
185 #define SENSOR_STRING_TYPE_ADDITIONAL_INFO "android.sensor.additional_info"
186 #define SENSOR_STRING_TYPE_LOW_LATENCY_OFFBODY_DETECT "android.sensor.low_latency_offbody_detect"
187 #define SENSOR_STRING_TYPE_ACCELEROMETER_UNCALIBRATED "android.sensor.accelerometer_uncalibrated"
188
189 /**
190 * Values returned by the accelerometer in various locations in the universe.
191 * all values are in SI units (m/s^2)
192 */
193 #define GRAVITY_SUN (275.0f)
194 #define GRAVITY_EARTH (9.80665f)
195
196 /** Maximum magnetic field on Earth's surface */
197 #define MAGNETIC_FIELD_EARTH_MAX (60.0f)
198
199 /** Minimum magnetic field on Earth's surface */
200 #define MAGNETIC_FIELD_EARTH_MIN (30.0f)
201
202 struct sensor_t;
203
204 /**
205 * sensor event data
206 */
207 typedef struct {
208 union {
209 float v[3];
210 struct {
211 float x;
212 float y;
213 float z;
214 };
215 struct {
216 float azimuth;
217 float pitch;
218 float roll;
219 };
220 };
221 int8_t status;
222 uint8_t reserved[3];
223 } sensors_vec_t;
224
225 /**
226 * uncalibrated accelerometer, gyroscope and magnetometer event data
227 */
228 typedef struct {
229 union {
230 float uncalib[3];
231 struct {
232 float x_uncalib;
233 float y_uncalib;
234 float z_uncalib;
235 };
236 };
237 union {
238 float bias[3];
239 struct {
240 float x_bias;
241 float y_bias;
242 float z_bias;
243 };
244 };
245 } uncalibrated_event_t;
246
247 /**
248 * Meta data event data
249 */
250 typedef struct meta_data_event {
251 int32_t what;
252 int32_t sensor;
253 } meta_data_event_t;
254
255 /**
256 * Dynamic sensor meta event. See the description of SENSOR_TYPE_DYNAMIC_SENSOR_META type for
257 * details.
258 */
259 typedef struct dynamic_sensor_meta_event {
260 int32_t connected;
261 int32_t handle;
262 const struct sensor_t * sensor; // should be NULL if connected == false
263 uint8_t uuid[16]; // UUID of a dynamic sensor (using RFC 4122 byte order)
264 // For UUID 12345678-90AB-CDEF-1122-334455667788 the uuid field
265 // should be initialized as:
266 // {0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0x11, ...}
267 } dynamic_sensor_meta_event_t;
268
269 /**
270 * Heart rate event data
271 */
272 typedef struct {
273 // Heart rate in beats per minute.
274 // Set to 0 when status is SENSOR_STATUS_UNRELIABLE or ..._NO_CONTACT
275 float bpm;
276 // Status of the sensor for this reading. Set to one SENSOR_STATUS_...
277 // Note that this value should only be set for sensors that explicitly define
278 // the meaning of this field. This field is not piped through the framework
279 // for other sensors.
280 int8_t status;
281 } heart_rate_event_t;
282
283 typedef struct {
284 int32_t type; // type of payload data, see additional_info_type_t
285 int32_t serial; // sequence number of this frame for this type
286 union {
287 // for each frame, a single data type, either int32_t or float, should be used.
288 int32_t data_int32[14];
289 float data_float[14];
290 };
291 } additional_info_event_t;
292
293 /**
294 * Union of the various types of sensor data
295 * that can be returned.
296 */
297 typedef struct sensors_event_t {
298 /* must be sizeof(struct sensors_event_t) */
299 int32_t version;
300
301 /* sensor identifier */
302 int32_t sensor;
303
304 /* sensor type */
305 int32_t type;
306
307 /* reserved */
308 int32_t reserved0;
309
310 /* time is in nanosecond */
311 int64_t timestamp;
312
313 union {
314 union {
315 float data[16];
316
317 /* acceleration values are in meter per second per second (m/s^2) */
318 sensors_vec_t acceleration;
319
320 /* magnetic vector values are in micro-Tesla (uT) */
321 sensors_vec_t magnetic;
322
323 /* orientation values are in degrees */
324 sensors_vec_t orientation;
325
326 /* gyroscope values are in rad/s */
327 sensors_vec_t gyro;
328
329 /* temperature is in degrees centigrade (Celsius) */
330 float temperature;
331
332 /* distance in centimeters */
333 float distance;
334
335 /* light in SI lux units */
336 float light;
337
338 /* pressure in hectopascal (hPa) */
339 float pressure;
340
341 /* relative humidity in percent */
342 float relative_humidity;
343
344 /* uncalibrated gyroscope values are in rad/s */
345 uncalibrated_event_t uncalibrated_gyro;
346
347 /* uncalibrated magnetometer values are in micro-Teslas */
348 uncalibrated_event_t uncalibrated_magnetic;
349
350 /* uncalibrated accelerometer values are in meter per second per second (m/s^2) */
351 uncalibrated_event_t uncalibrated_accelerometer;
352
353 /* heart rate data containing value in bpm and status */
354 heart_rate_event_t heart_rate;
355
356 /* this is a special event. see SENSOR_TYPE_META_DATA above.
357 * sensors_meta_data_event_t events are all reported with a type of
358 * SENSOR_TYPE_META_DATA. The handle is ignored and must be zero.
359 */
360 meta_data_event_t meta_data;
361
362 /* dynamic sensor meta event. See SENSOR_TYPE_DYNAMIC_SENSOR_META type for details */
363 dynamic_sensor_meta_event_t dynamic_sensor_meta;
364
365 /*
366 * special additional sensor information frame, see
367 * SENSOR_TYPE_ADDITIONAL_INFO for details.
368 */
369 additional_info_event_t additional_info;
370 };
371
372 union {
373 uint64_t data[8];
374
375 /* step-counter */
376 uint64_t step_counter;
377 } u64;
378 };
379
380 /* Reserved flags for internal use. Set to zero. */
381 uint32_t flags;
382
383 uint32_t reserved1[3];
384 } sensors_event_t;
385
386
387 /* see SENSOR_TYPE_META_DATA */
388 typedef sensors_event_t sensors_meta_data_event_t;
389
390
391 /**
392 * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
393 * and the fields of this data structure must begin with hw_module_t
394 * followed by module specific information.
395 */
396 struct sensors_module_t {
397 struct hw_module_t common;
398
399 /**
400 * Enumerate all available sensors. The list is returned in "list".
401 * return number of sensors in the list
402 */
403 int (*get_sensors_list)(struct sensors_module_t* module,
404 struct sensor_t const** list);
405
406 /**
407 * Place the module in a specific mode. The following modes are defined
408 *
409 * 0 - Normal operation. Default state of the module.
410 * 1 - Loopback mode. Data is injected for the supported
411 * sensors by the sensor service in this mode.
412 * return 0 on success
413 * -EINVAL if requested mode is not supported
414 * -EPERM if operation is not allowed
415 */
416 int (*set_operation_mode)(unsigned int mode);
417 };
418
419 struct sensor_t {
420
421 /* Name of this sensor.
422 * All sensors of the same "type" must have a different "name".
423 */
424 const char* name;
425
426 /* vendor of the hardware part */
427 const char* vendor;
428
429 /* version of the hardware part + driver. The value of this field
430 * must increase when the driver is updated in a way that changes the
431 * output of this sensor. This is important for fused sensors when the
432 * fusion algorithm is updated.
433 */
434 int version;
435
436 /* handle that identifies this sensors. This handle is used to reference
437 * this sensor throughout the HAL API.
438 */
439 int handle;
440
441 /* this sensor's type. */
442 int type;
443
444 /* maximum range of this sensor's value in SI units */
445 float maxRange;
446
447 /* smallest difference between two values reported by this sensor */
448 float resolution;
449
450 /* rough estimate of this sensor's power consumption in mA */
451 float power;
452
453 /* this value depends on the reporting mode:
454 *
455 * continuous: minimum sample period allowed in microseconds
456 * on-change : 0
457 * one-shot :-1
458 * special : 0, unless otherwise noted
459 */
460 int32_t minDelay;
461
462 /* number of events reserved for this sensor in the batch mode FIFO.
463 * If there is a dedicated FIFO for this sensor, then this is the
464 * size of this FIFO. If the FIFO is shared with other sensors,
465 * this is the size reserved for that sensor and it can be zero.
466 */
467 uint32_t fifoReservedEventCount;
468
469 /* maximum number of events of this sensor that could be batched.
470 * This is especially relevant when the FIFO is shared between
471 * several sensors; this value is then set to the size of that FIFO.
472 */
473 uint32_t fifoMaxEventCount;
474
475 /* type of this sensor as a string.
476 *
477 * If type is OEM specific or sensor manufacturer specific type
478 * (>=SENSOR_TYPE_DEVICE_PRIVATE_BASE), this string must be defined with reserved domain of
479 * vendor/OEM as a prefix, e.g. com.google.glass.onheaddetector
480 *
481 * For sensors of Android defined types, Android framework will override this value. It is ok to
482 * leave it pointing to an empty string.
483 */
484 const char* stringType;
485
486 /* permission required to see this sensor, register to it and receive data.
487 * Set to "" if no permission is required. Some sensor types like the
488 * heart rate monitor have a mandatory require_permission.
489 * For sensors that always require a specific permission, like the heart
490 * rate monitor, the android framework might overwrite this string
491 * automatically.
492 */
493 const char* requiredPermission;
494
495 /* This value is defined only for continuous mode and on-change sensors. It is the delay between
496 * two sensor events corresponding to the lowest frequency that this sensor supports. When lower
497 * frequencies are requested through batch()/setDelay() the events will be generated at this
498 * frequency instead. It can be used by the framework or applications to estimate when the batch
499 * FIFO may be full.
500 *
501 * NOTE: 1) period_ns is in nanoseconds where as maxDelay/minDelay are in microseconds.
502 * continuous, on-change: maximum sampling period allowed in microseconds.
503 * one-shot, special : 0
504 * 2) maxDelay should always fit within a 32 bit signed integer. It is declared as 64 bit
505 * on 64 bit architectures only for binary compatibility reasons.
506 * Availability: SENSORS_DEVICE_API_VERSION_1_3
507 */
508 #ifdef __LP64__
509 int64_t maxDelay;
510 #else
511 int32_t maxDelay;
512 #endif
513
514 /* Flags for sensor. See SENSOR_FLAG_* above. Only the least significant 32 bits are used here.
515 * It is declared as 64 bit on 64 bit architectures only for binary compatibility reasons.
516 * Availability: SENSORS_DEVICE_API_VERSION_1_3
517 */
518 #ifdef __LP64__
519 uint64_t flags;
520 #else
521 uint32_t flags;
522 #endif
523
524 /* reserved fields, must be zero */
525 void* reserved[2];
526 };
527
528 /**
529 * Shared memory information for a direct channel
530 */
531 struct sensors_direct_mem_t {
532 int type; // enum SENSOR_DIRECT_MEM_...
533 int format; // enum SENSOR_DIRECT_FMT_...
534 size_t size; // size of the memory region, in bytes
535 const struct native_handle *handle; // shared memory handle, which is interpreted differently
536 // depending on type
537 };
538
539 /**
540 * Direct channel report configuration
541 */
542 struct sensors_direct_cfg_t {
543 int rate_level; // enum SENSOR_DIRECT_RATE_...
544 };
545
546 /*
547 * sensors_poll_device_t is used with SENSORS_DEVICE_API_VERSION_0_1
548 * and is present for backward binary and source compatibility.
549 * See the Sensors HAL interface section for complete descriptions of the
550 * following functions:
551 * http://source.android.com/devices/sensors/index.html#hal
552 */
553 struct sensors_poll_device_t {
554 struct hw_device_t common;
555 int (*activate)(struct sensors_poll_device_t *dev,
556 int sensor_handle, int enabled);
557 int (*setDelay)(struct sensors_poll_device_t *dev,
558 int sensor_handle, int64_t sampling_period_ns);
559 int (*poll)(struct sensors_poll_device_t *dev,
560 sensors_event_t* data, int count);
561 };
562
563 /*
564 * struct sensors_poll_device_1 is used in HAL versions >= SENSORS_DEVICE_API_VERSION_1_0
565 */
566 typedef struct sensors_poll_device_1 {
567 union {
568 /* sensors_poll_device_1 is compatible with sensors_poll_device_t,
569 * and can be down-cast to it
570 */
571 struct sensors_poll_device_t v0;
572
573 struct {
574 struct hw_device_t common;
575
576 /* Activate/de-activate one sensor.
577 *
578 * sensor_handle is the handle of the sensor to change.
579 * enabled set to 1 to enable, or 0 to disable the sensor.
580 *
581 * Before sensor activation, existing sensor events that have not
582 * been picked up by poll() should be abandoned so that application
583 * upon new activation request will not get stale events.
584 * (events that are generated during latter activation or during
585 * data injection mode after sensor deactivation)
586 *
587 * Return 0 on success, negative errno code otherwise.
588 */
589 int (*activate)(struct sensors_poll_device_t *dev,
590 int sensor_handle, int enabled);
591
592 /**
593 * Set the events's period in nanoseconds for a given sensor.
594 * If sampling_period_ns > max_delay it will be truncated to
595 * max_delay and if sampling_period_ns < min_delay it will be
596 * replaced by min_delay.
597 */
598 int (*setDelay)(struct sensors_poll_device_t *dev,
599 int sensor_handle, int64_t sampling_period_ns);
600
601 /**
602 * Write an array of sensor_event_t to data. The size of the
603 * available buffer is specified by count. Returns number of
604 * valid sensor_event_t.
605 *
606 * This function should block if there is no sensor event
607 * available when being called. Thus, return value should always be
608 * positive.
609 */
610 int (*poll)(struct sensors_poll_device_t *dev,
611 sensors_event_t* data, int count);
612 };
613 };
614
615
616 /*
617 * Sets a sensor’s parameters, including sampling frequency and maximum
618 * report latency. This function can be called while the sensor is
619 * activated, in which case it must not cause any sensor measurements to
620 * be lost: transitioning from one sampling rate to the other cannot cause
621 * lost events, nor can transitioning from a high maximum report latency to
622 * a low maximum report latency.
623 * See the Batching sensor results page for details:
624 * http://source.android.com/devices/sensors/batching.html
625 */
626 int (*batch)(struct sensors_poll_device_1* dev,
627 int sensor_handle, int flags, int64_t sampling_period_ns,
628 int64_t max_report_latency_ns);
629
630 /*
631 * Flush adds a META_DATA_FLUSH_COMPLETE event (sensors_event_meta_data_t)
632 * to the end of the "batch mode" FIFO for the specified sensor and flushes
633 * the FIFO.
634 * If the FIFO is empty or if the sensor doesn't support batching (FIFO size zero),
635 * it should return SUCCESS along with a trivial META_DATA_FLUSH_COMPLETE event added to the
636 * event stream. This applies to all sensors other than one-shot sensors.
637 * If the sensor is a one-shot sensor, flush must return -EINVAL and not generate
638 * any flush complete metadata.
639 * If the sensor is not active at the time flush() is called, flush() should return
640 * -EINVAL.
641 */
642 int (*flush)(struct sensors_poll_device_1* dev, int sensor_handle);
643
644 /*
645 * Inject a single sensor sample to be to this device.
646 * data points to the sensor event to be injected
647 * return 0 on success
648 * -EPERM if operation is not allowed
649 * -EINVAL if sensor event cannot be injected
650 */
651 int (*inject_sensor_data)(struct sensors_poll_device_1 *dev, const sensors_event_t *data);
652
653 /*
654 * Register/unregister direct report channel.
655 *
656 * A HAL declares support for direct report by setting non-NULL values for both
657 * register_direct_channel and config_direct_report.
658 *
659 * This function has two operation modes:
660 *
661 * Register: mem != NULL, register a channel using supplied shared memory information. By the
662 * time this function returns, sensors must finish initializing shared memory content
663 * (format dependent, see SENSOR_DIRECT_FMT_*).
664 * Parameters:
665 * mem points to a valid struct sensors_direct_mem_t.
666 * channel_handle is ignored.
667 * Return value:
668 * A handle of channel (>0, <INT32_MAX) when success, which later can be referred in
669 * unregister or config_direct_report call, or error code (<0) when failed
670 * Unregister: mem == NULL, unregister a previously registered channel.
671 * Parameters:
672 * mem set to NULL
673 * channel_handle contains handle of channel to be unregistered
674 * Return value:
675 * 0, even if the channel_handle is invalid, in which case it will be a no-op.
676 */
677 int (*register_direct_channel)(struct sensors_poll_device_1 *dev,
678 const struct sensors_direct_mem_t* mem, int channel_handle);
679
680 /*
681 * Configure direct sensor event report in direct channel.
682 *
683 * Start, modify rate or stop direct report of a sensor in a certain direct channel. A special
684 * case is setting sensor handle -1 to stop means to stop all active sensor report on the
685 * channel specified.
686 *
687 * A HAL declares support for direct report by setting non-NULL values for both
688 * register_direct_channel and config_direct_report.
689 *
690 * Parameters:
691 * sensor_handle sensor to be configured. The sensor has to support direct report
692 * mode by setting flags of sensor_t. Also, direct report mode is only
693 * defined for continuous reporting mode sensors.
694 * channel_handle channel handle to be configured.
695 * config direct report parameters, see sensor_direct_cfg_t.
696 * Return value:
697 * - when sensor is started or sensor rate level is changed: return positive identifier of
698 * sensor in specified channel if successful, otherwise return negative error code.
699 * - when sensor is stopped: return 0 for success or negative error code for failure.
700 */
701 int (*config_direct_report)(struct sensors_poll_device_1 *dev,
702 int sensor_handle, int channel_handle, const struct sensors_direct_cfg_t *config);
703
704 /*
705 * Reserved for future use, must be zero.
706 */
707 void (*reserved_procs[5])(void);
708
709 } sensors_poll_device_1_t;
710
711
712 /** convenience API for opening and closing a device */
713
sensors_open(const struct hw_module_t * module,struct sensors_poll_device_t ** device)714 static inline int sensors_open(const struct hw_module_t* module,
715 struct sensors_poll_device_t** device) {
716 return module->methods->open(module,
717 SENSORS_HARDWARE_POLL, TO_HW_DEVICE_T_OPEN(device));
718 }
719
sensors_close(struct sensors_poll_device_t * device)720 static inline int sensors_close(struct sensors_poll_device_t* device) {
721 return device->common.close(&device->common);
722 }
723
sensors_open_1(const struct hw_module_t * module,sensors_poll_device_1_t ** device)724 static inline int sensors_open_1(const struct hw_module_t* module,
725 sensors_poll_device_1_t** device) {
726 return module->methods->open(module,
727 SENSORS_HARDWARE_POLL, TO_HW_DEVICE_T_OPEN(device));
728 }
729
sensors_close_1(sensors_poll_device_1_t * device)730 static inline int sensors_close_1(sensors_poll_device_1_t* device) {
731 return device->common.close(&device->common);
732 }
733
734 __END_DECLS
735
736 #endif // ANDROID_SENSORS_INTERFACE_H
737