| /* |
| * Copyright (C) 2017 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. |
| */ |
| #pragma once |
| |
| #include <vector> |
| |
| #include "common/libs/threads/cuttlefish_thread.h" |
| #include "common/libs/fs/shared_fd.h" |
| #include "guest/hals/sensors/sensors.h" |
| #include "guest/hals/sensors/sensors_hal.h" |
| |
| namespace avd { |
| |
| // Used for sending control messages to the receiver thread. |
| // The sensor_handle field may be left unused if it is not needed. |
| enum ControlMessageType { |
| THREAD_STOP, |
| SENSOR_STATE_UPDATE |
| }; |
| typedef struct { |
| ControlMessageType message_type; |
| uint8_t sensor_handle; |
| } SensorControlMessage; |
| |
| #if VSOC_SENSORS_DEVICE_API_VERSION_ATLEAST(1_0) |
| // Last updated to HAL 1.4 |
| // Version history: |
| // Before jb, jb-mr1 SENSORS_DEVICE_API_VERSION_0_1 (no version in sensors.h) |
| // jb-mr2: SENSORS_DEVICE_API_VERSION_1_0 |
| // k: SENSORS_DEVICE_API_VERSION_1_1 |
| // l, l-mr1: SENSORS_DEVICE_API_VERSION_1_3 |
| // m, n, n-mr1: SENSORS_DEVICE_API_VERSION_1_4 |
| #else |
| // Pre-1.0 sensors do not define the sensors_poll_device_1 type. |
| typedef sensors_poll_device_t sensors_poll_device_1; |
| #endif |
| |
| class GceSensors : public sensors_poll_device_1 { |
| public: |
| GceSensors(); |
| ~GceSensors(); |
| |
| /** |
| ** SENSOR HAL API FUNCTIONS FOR MODULE |
| **/ |
| |
| // Gets a list of all supported sensors and stores in list. |
| // Returns the number of supported sensors. |
| static int GetSensorsList(struct sensors_module_t* module, |
| struct sensor_t const** list); |
| |
| // Place the module in a specific mode. The following modes are defined |
| // |
| // 0 - Normal operation. Default state of the module. |
| // 1 - Loopback mode. Data is injected for the supported |
| // sensors by the sensor service in this mode. |
| // @return 0 on success |
| // -EINVAL if requested mode is not supported |
| // -EPERM if operation is not allowed |
| static int SetOperationMode(unsigned int mode); |
| |
| |
| /** |
| ** SENSOR HAL API FUNCTIONS FOR DEVICE |
| **/ |
| // Opens the device. |
| static int Open(const struct hw_module_t* module, const char* name, |
| struct hw_device_t** device); |
| |
| // Closes the device, closing all sensors. |
| int Close(); |
| |
| // Activate (or deactivate) the sensor with the given handle. |
| // |
| // One-shot sensors deactivate themselves automatically upon receiving an |
| // event, and they must still accept to be deactivated through a call to |
| // activate(..., enabled=0). |
| // Non-wake-up sensors never prevent the SoC from going into suspend mode; |
| // that is, the HAL shall not hold a partial wake-lock on behalf of |
| // applications. |
| // |
| // If enabled is 1 and the sensor is already activated, this function is a |
| // no-op and succeeds. |
| // |
| // If enabled is 0 and the sensor is already deactivated, this function is a |
| // no-op and succeeds. |
| // |
| // This function returns 0 on success and a negative error number otherwise. |
| int Activate(int handle, int enabled); |
| |
| // Sets the delay (in ns) for the sensor with the given handle. |
| // Deprecated as of HAL 1.1 |
| // Called after activate() |
| int SetDelay(int handle, int64_t sampling_period_ns); |
| |
| // Returns an array of sensor data by filling the data argument. |
| // This function must block until events are available. It will return |
| // the number of events read on success, or a negative number in case of |
| // an error. |
| int Poll(sensors_event_t* data, int count); |
| |
| #if VSOC_SENSORS_DEVICE_API_VERSION_ATLEAST(1_0) |
| // Sets a sensor’s parameters, including sampling frequency and maximum |
| // report latency. This function can be called while the sensor is |
| // activated, in which case it must not cause any sensor measurements to |
| // be lost: transitioning from one sampling rate to the other cannot cause |
| // lost events, nor can transitioning from a high maximum report latency to |
| // a low maximum report latency. |
| // |
| // Before SENSORS_DEVICE_API_VERSION_1_3, flags included: |
| // SENSORS_BATCH_DRY_RUN |
| // SENSORS_BATCH_WAKE_UPON_FIFO_FULL |
| // |
| // After SENSORS_DEVICE_API_VERSION_1_3 see WAKE_UPON_FIFO_FULL |
| // in sensor_t.flags |
| int Batch(int sensor_handle, int flags, int64_t sampling_period_ns, |
| int64_t max_report_latency_ns) { |
| // TODO: Add support for maximum report latency with max_report_latency_ns. |
| return SetDelay(sensor_handle, sampling_period_ns); |
| } |
| #endif |
| |
| #if VSOC_SENSORS_DEVICE_API_VERSION_ATLEAST(1_1) |
| // Adds a META_DATA_FLUSH_COMPLETE event (sensors_event_meta_data_t) |
| // to the end of the "batch mode" FIFO for the specified sensor and flushes |
| // the FIFO. |
| // |
| // If the FIFO is empty or if the sensor doesn't support batching (FIFO |
| // size zero), it should return SUCCESS along with a trivial |
| // META_DATA_FLUSH_COMPLETE event added to the event stream. This applies to |
| // all sensors other than one-shot sensors. |
| // |
| // If the sensor is a one-shot sensor, flush must return -EINVAL and not |
| // generate any flush complete metadata. |
| // |
| // If the sensor is not active at the time flush() is called, flush() should |
| // return -EINVAL. |
| int Flush(int sensor_handle) { |
| return -EINVAL; |
| } |
| #endif |
| |
| #if VSOC_SENSORS_DEVICE_API_VERSION_ATLEAST(1_4) |
| // Inject a single sensor sample to be to this device. |
| // data points to the sensor event to be injected |
| // @return 0 on success |
| // -EPERM if operation is not allowed |
| // -EINVAL if sensor event cannot be injected |
| int InjectSensorData(const sensors_event_t *data) { |
| return -EINVAL; |
| } |
| #endif |
| |
| private: |
| typedef std::vector<SensorState*> SensorStateVector; |
| typedef std::vector<sensors_event_t> FifoType; |
| // Total number of sensors supported by this HAL. |
| static int total_sensor_count_; |
| // Vector of static sensor information for sensors supported by this HAL. |
| // Indexed by the handle. Length must always be equal to total_sensor_count_. |
| static SensorInfo* sensor_infos_; |
| // Vector of sensor state information, indexed by the handle. |
| // Assumption here is that the sensor handles will start at 0 and be |
| // contiguous up to the number of supported sensors. |
| SensorStateVector sensor_states_; |
| // Keep track of the time when the thread in Poll() is scheduled to wake. |
| avd::time::MonotonicTimePoint current_deadline_; |
| |
| // Ordered set of sensor values. |
| // TODO(ghartman): Simulate FIFO overflow. |
| FifoType fifo_; |
| // Thread to handle new connections. |
| pthread_t receiver_thread_; |
| // Socket to receive sensor events on. |
| avd::SharedFD sensor_listener_socket_; |
| // Socket for listener thread to receive control messages. |
| avd::SharedFD control_receiver_socket_; |
| // Socket to send control messages to listener thread. |
| avd::SharedFD control_sender_socket_; |
| |
| // Lock to protect shared state, including |
| // sensor_states_ and next_deadline_. |
| // Associated with deadline_change_ condition variable. |
| avd::Mutex sensor_state_lock_; |
| // Condition variable to signal changes in the deadline. |
| avd::ConditionVariable deadline_change_; |
| |
| // When events are arriving from a client, we report only |
| // when they arrive, rather than at a fixed cycle. After not |
| // receiving a real event for both a given number of periods |
| // and a given time period, we will give up and resume |
| // sending mock events. |
| const static int kInjectedEventWaitPeriods; |
| const static avd::time::Nanoseconds kInjectedEventWaitTime; |
| |
| /** |
| ** UTILITY FUNCTIONS |
| **/ |
| |
| // Receive data from remoter. |
| void* Receiver(); |
| |
| // Notifies the remoter that the HAL is awake and ready. |
| inline bool NotifyRemoter(); |
| |
| // Looks through all active sensor deadlines, and finds the one that |
| // is coming up next. If this is not next_deadline_, then the deadline |
| // has changed. Update it and signal the Poll thread. |
| // This should be called anytime the next deadline may have changed. |
| // Can only be called while holding sensor_state_lock_. |
| // Returns true if the deadline has changed. |
| avd::time::MonotonicTimePoint UpdateDeadline(); |
| |
| // Sends an update for the sensor with the given handle to the remoter. |
| // Update will be enqueued for receiver, not send immediately. |
| inline bool UpdateRemoterState(int handle); |
| |
| // Sends a control event to the listener. |
| inline bool SendControlMessage(SensorControlMessage msg); |
| |
| // Populates the list of static sensor info. Returns the number |
| // of sensors supported. Should only be called once. |
| static inline int RegisterSensors(); |
| |
| }; |
| |
| } //namespace avd |
| |