1 /*
2  * Copyright (C) 2010 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 #include <inttypes.h>
18 #include <math.h>
19 #include <stdint.h>
20 #include <sys/types.h>
21 
22 #include <utils/Atomic.h>
23 #include <utils/Errors.h>
24 #include <utils/Singleton.h>
25 
26 #include <binder/BinderService.h>
27 #include <binder/Parcel.h>
28 #include <binder/IServiceManager.h>
29 
30 #include <hardware/sensors.h>
31 
32 #include "SensorDevice.h"
33 #include "SensorService.h"
34 
35 namespace android {
36 // ---------------------------------------------------------------------------
37 
ANDROID_SINGLETON_STATIC_INSTANCE(SensorDevice)38 ANDROID_SINGLETON_STATIC_INSTANCE(SensorDevice)
39 
40 SensorDevice::SensorDevice()
41     :  mSensorDevice(0),
42        mSensorModule(0) {
43     status_t err = hw_get_module(SENSORS_HARDWARE_MODULE_ID,
44             (hw_module_t const**)&mSensorModule);
45 
46     ALOGE_IF(err, "couldn't load %s module (%s)",
47             SENSORS_HARDWARE_MODULE_ID, strerror(-err));
48 
49     if (mSensorModule) {
50         err = sensors_open_1(&mSensorModule->common, &mSensorDevice);
51 
52         ALOGE_IF(err, "couldn't open device for module %s (%s)",
53                 SENSORS_HARDWARE_MODULE_ID, strerror(-err));
54 
55         if (mSensorDevice) {
56             if (mSensorDevice->common.version == SENSORS_DEVICE_API_VERSION_1_1 ||
57                 mSensorDevice->common.version == SENSORS_DEVICE_API_VERSION_1_2) {
58                 ALOGE(">>>> WARNING <<< Upgrade sensor HAL to version 1_3");
59             }
60 
61             sensor_t const* list;
62             ssize_t count = mSensorModule->get_sensors_list(mSensorModule, &list);
63             mActivationCount.setCapacity(count);
64             Info model;
65             for (size_t i=0 ; i<size_t(count) ; i++) {
66                 mActivationCount.add(list[i].handle, model);
67                 mSensorDevice->activate(
68                         reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
69                         list[i].handle, 0);
70             }
71         }
72     }
73 }
74 
handleDynamicSensorConnection(int handle,bool connected)75 void SensorDevice::handleDynamicSensorConnection(int handle, bool connected) {
76     if (connected) {
77         Info model;
78         mActivationCount.add(handle, model);
79         mSensorDevice->activate(
80                 reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice), handle, 0);
81     } else {
82         mActivationCount.removeItem(handle);
83     }
84 }
85 
dump() const86 std::string SensorDevice::dump() const {
87     if (!mSensorModule) return "HAL not initialized\n";
88 
89     String8 result;
90     sensor_t const* list;
91     int count = mSensorModule->get_sensors_list(mSensorModule, &list);
92 
93     result.appendFormat("HAL: %s (%s), version %#010x\n",
94                         mSensorModule->common.name,
95                         mSensorModule->common.author,
96                         getHalDeviceVersion());
97     result.appendFormat("Total %d h/w sensors, %zu running:\n", count, mActivationCount.size());
98 
99     Mutex::Autolock _l(mLock);
100     for (int i = 0 ; i < count ; i++) {
101         const Info& info = mActivationCount.valueFor(list[i].handle);
102         if (info.batchParams.isEmpty()) continue;
103         result.appendFormat("0x%08x) active-count = %zu; ", list[i].handle,
104                             info.batchParams.size());
105 
106         result.append("sampling_period(ms) = {");
107         for (size_t j = 0; j < info.batchParams.size(); j++) {
108             const BatchParams& params = info.batchParams.valueAt(j);
109             result.appendFormat("%.1f%s", params.batchDelay / 1e6f,
110                                 j < info.batchParams.size() - 1 ? ", " : "");
111         }
112         result.appendFormat("}, selected = %.1f ms; ", info.bestBatchParams.batchDelay / 1e6f);
113 
114         result.append("batching_period(ms) = {");
115         for (size_t j = 0; j < info.batchParams.size(); j++) {
116             BatchParams params = info.batchParams.valueAt(j);
117             result.appendFormat("%.1f%s", params.batchTimeout / 1e6f,
118                                 j < info.batchParams.size() - 1 ? ", " : "");
119         }
120         result.appendFormat("}, selected = %.1f ms\n", info.bestBatchParams.batchTimeout / 1e6f);
121     }
122     return result.string();
123 }
124 
getSensorList(sensor_t const ** list)125 ssize_t SensorDevice::getSensorList(sensor_t const** list) {
126     if (!mSensorModule) return NO_INIT;
127     ssize_t count = mSensorModule->get_sensors_list(mSensorModule, list);
128     return count;
129 }
130 
initCheck() const131 status_t SensorDevice::initCheck() const {
132     return mSensorDevice && mSensorModule ? NO_ERROR : NO_INIT;
133 }
134 
poll(sensors_event_t * buffer,size_t count)135 ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
136     if (!mSensorDevice) return NO_INIT;
137     ssize_t c;
138     do {
139         c = mSensorDevice->poll(reinterpret_cast<struct sensors_poll_device_t *> (mSensorDevice),
140                                 buffer, count);
141     } while (c == -EINTR);
142     return c;
143 }
144 
autoDisable(void * ident,int handle)145 void SensorDevice::autoDisable(void *ident, int handle) {
146     Info& info( mActivationCount.editValueFor(handle) );
147     Mutex::Autolock _l(mLock);
148     info.removeBatchParamsForIdent(ident);
149 }
150 
activate(void * ident,int handle,int enabled)151 status_t SensorDevice::activate(void* ident, int handle, int enabled) {
152     if (!mSensorDevice) return NO_INIT;
153     status_t err(NO_ERROR);
154     bool actuateHardware = false;
155 
156     Mutex::Autolock _l(mLock);
157     Info& info( mActivationCount.editValueFor(handle) );
158 
159     ALOGD_IF(DEBUG_CONNECTIONS,
160              "SensorDevice::activate: ident=%p, handle=0x%08x, enabled=%d, count=%zu",
161              ident, handle, enabled, info.batchParams.size());
162 
163     if (enabled) {
164         ALOGD_IF(DEBUG_CONNECTIONS, "enable index=%zd", info.batchParams.indexOfKey(ident));
165 
166         if (isClientDisabledLocked(ident)) {
167             return INVALID_OPERATION;
168         }
169 
170         if (info.batchParams.indexOfKey(ident) >= 0) {
171           if (info.numActiveClients() == 1) {
172               // This is the first connection, we need to activate the underlying h/w sensor.
173               actuateHardware = true;
174           }
175         } else {
176             // Log error. Every activate call should be preceded by a batch() call.
177             ALOGE("\t >>>ERROR: activate called without batch");
178         }
179     } else {
180         ALOGD_IF(DEBUG_CONNECTIONS, "disable index=%zd", info.batchParams.indexOfKey(ident));
181 
182         if (info.removeBatchParamsForIdent(ident) >= 0) {
183             if (info.numActiveClients() == 0) {
184                 // This is the last connection, we need to de-activate the underlying h/w sensor.
185                 actuateHardware = true;
186             } else {
187                 const int halVersion = getHalDeviceVersion();
188                 if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) {
189                     // Call batch for this sensor with the previously calculated best effort
190                     // batch_rate and timeout. One of the apps has unregistered for sensor
191                     // events, and the best effort batch parameters might have changed.
192                     ALOGD_IF(DEBUG_CONNECTIONS,
193                              "\t>>> actuating h/w batch %d %d %" PRId64 " %" PRId64, handle,
194                              info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
195                              info.bestBatchParams.batchTimeout);
196                     mSensorDevice->batch(mSensorDevice, handle,info.bestBatchParams.flags,
197                                          info.bestBatchParams.batchDelay,
198                                          info.bestBatchParams.batchTimeout);
199                 }
200             }
201         } else {
202             // sensor wasn't enabled for this ident
203         }
204 
205         if (isClientDisabledLocked(ident)) {
206             return NO_ERROR;
207         }
208     }
209 
210     if (actuateHardware) {
211         ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w activate handle=%d enabled=%d", handle,
212                  enabled);
213         err = mSensorDevice->activate(
214                 reinterpret_cast<struct sensors_poll_device_t *> (mSensorDevice), handle, enabled);
215         ALOGE_IF(err, "Error %s sensor %d (%s)", enabled ? "activating" : "disabling", handle,
216                  strerror(-err));
217 
218         if (err != NO_ERROR && enabled) {
219             // Failure when enabling the sensor. Clean up on failure.
220             info.removeBatchParamsForIdent(ident);
221         }
222     }
223 
224     // On older devices which do not support batch, call setDelay().
225     if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_1 && info.numActiveClients() > 0) {
226         ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w setDelay %d %" PRId64, handle,
227                  info.bestBatchParams.batchDelay);
228         mSensorDevice->setDelay(
229                 reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
230                 handle, info.bestBatchParams.batchDelay);
231     }
232     return err;
233 }
234 
batch(void * ident,int handle,int flags,int64_t samplingPeriodNs,int64_t maxBatchReportLatencyNs)235 status_t SensorDevice::batch(void* ident, int handle, int flags, int64_t samplingPeriodNs,
236                              int64_t maxBatchReportLatencyNs) {
237     if (!mSensorDevice) return NO_INIT;
238 
239     if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
240         samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
241     }
242 
243     const int halVersion = getHalDeviceVersion();
244     if (halVersion < SENSORS_DEVICE_API_VERSION_1_1 && maxBatchReportLatencyNs != 0) {
245         // Batch is not supported on older devices return invalid operation.
246         return INVALID_OPERATION;
247     }
248 
249     ALOGD_IF(DEBUG_CONNECTIONS,
250              "SensorDevice::batch: ident=%p, handle=0x%08x, flags=%d, period_ns=%" PRId64 " timeout=%" PRId64,
251              ident, handle, flags, samplingPeriodNs, maxBatchReportLatencyNs);
252 
253     Mutex::Autolock _l(mLock);
254     Info& info(mActivationCount.editValueFor(handle));
255 
256     if (info.batchParams.indexOfKey(ident) < 0) {
257         BatchParams params(flags, samplingPeriodNs, maxBatchReportLatencyNs);
258         info.batchParams.add(ident, params);
259     } else {
260         // A batch has already been called with this ident. Update the batch parameters.
261         info.setBatchParamsForIdent(ident, flags, samplingPeriodNs, maxBatchReportLatencyNs);
262     }
263 
264     BatchParams prevBestBatchParams = info.bestBatchParams;
265     // Find the minimum of all timeouts and batch_rates for this sensor.
266     info.selectBatchParams();
267 
268     ALOGD_IF(DEBUG_CONNECTIONS,
269              "\t>>> curr_period=%" PRId64 " min_period=%" PRId64
270              " curr_timeout=%" PRId64 " min_timeout=%" PRId64,
271              prevBestBatchParams.batchDelay, info.bestBatchParams.batchDelay,
272              prevBestBatchParams.batchTimeout, info.bestBatchParams.batchTimeout);
273 
274     status_t err(NO_ERROR);
275     // If the min period or min timeout has changed since the last batch call, call batch.
276     if (prevBestBatchParams != info.bestBatchParams) {
277         if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) {
278             ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w BATCH %d %d %" PRId64 " %" PRId64, handle,
279                      info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
280                      info.bestBatchParams.batchTimeout);
281             err = mSensorDevice->batch(mSensorDevice, handle, info.bestBatchParams.flags,
282                                        info.bestBatchParams.batchDelay,
283                                        info.bestBatchParams.batchTimeout);
284         } else {
285             // For older devices which do not support batch, call setDelay() after activate() is
286             // called. Some older devices may not support calling setDelay before activate(), so
287             // call setDelay in SensorDevice::activate() method.
288         }
289         if (err != NO_ERROR) {
290             ALOGE("sensor batch failed %p %d %d %" PRId64 " %" PRId64 " err=%s",
291                   mSensorDevice, handle,
292                   info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
293                   info.bestBatchParams.batchTimeout, strerror(-err));
294             info.removeBatchParamsForIdent(ident);
295         }
296     }
297     return err;
298 }
299 
setDelay(void * ident,int handle,int64_t samplingPeriodNs)300 status_t SensorDevice::setDelay(void* ident, int handle, int64_t samplingPeriodNs) {
301     if (!mSensorDevice) return NO_INIT;
302     if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
303         samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
304     }
305     Mutex::Autolock _l(mLock);
306     if (isClientDisabledLocked(ident)) return INVALID_OPERATION;
307     Info& info( mActivationCount.editValueFor(handle) );
308     // If the underlying sensor is NOT in continuous mode, setDelay() should return an error.
309     // Calling setDelay() in batch mode is an invalid operation.
310     if (info.bestBatchParams.batchTimeout != 0) {
311       return INVALID_OPERATION;
312     }
313     ssize_t index = info.batchParams.indexOfKey(ident);
314     if (index < 0) {
315         return BAD_INDEX;
316     }
317     BatchParams& params = info.batchParams.editValueAt(index);
318     params.batchDelay = samplingPeriodNs;
319     info.selectBatchParams();
320     return mSensorDevice->setDelay(reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
321                                    handle, info.bestBatchParams.batchDelay);
322 }
323 
getHalDeviceVersion() const324 int SensorDevice::getHalDeviceVersion() const {
325     if (!mSensorDevice) return -1;
326     return mSensorDevice->common.version;
327 }
328 
flush(void * ident,int handle)329 status_t SensorDevice::flush(void* ident, int handle) {
330     if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_1) {
331         return INVALID_OPERATION;
332     }
333     if (isClientDisabled(ident)) return INVALID_OPERATION;
334     ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w flush %d", handle);
335     return mSensorDevice->flush(mSensorDevice, handle);
336 }
337 
isClientDisabled(void * ident)338 bool SensorDevice::isClientDisabled(void* ident) {
339     Mutex::Autolock _l(mLock);
340     return isClientDisabledLocked(ident);
341 }
342 
isClientDisabledLocked(void * ident)343 bool SensorDevice::isClientDisabledLocked(void* ident) {
344     return mDisabledClients.indexOf(ident) >= 0;
345 }
346 
enableAllSensors()347 void SensorDevice::enableAllSensors() {
348     Mutex::Autolock _l(mLock);
349     mDisabledClients.clear();
350     const int halVersion = getHalDeviceVersion();
351     for (size_t i = 0; i< mActivationCount.size(); ++i) {
352         Info& info = mActivationCount.editValueAt(i);
353         if (info.batchParams.isEmpty()) continue;
354         info.selectBatchParams();
355         const int sensor_handle = mActivationCount.keyAt(i);
356         ALOGD_IF(DEBUG_CONNECTIONS, "\t>> reenable actuating h/w sensor enable handle=%d ",
357                    sensor_handle);
358         status_t err(NO_ERROR);
359         if (halVersion > SENSORS_DEVICE_API_VERSION_1_0) {
360             err = mSensorDevice->batch(mSensorDevice, sensor_handle,
361                  info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
362                  info.bestBatchParams.batchTimeout);
363             ALOGE_IF(err, "Error calling batch on sensor %d (%s)", sensor_handle, strerror(-err));
364         }
365 
366         if (err == NO_ERROR) {
367             err = mSensorDevice->activate(
368                     reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
369                     sensor_handle, 1);
370             ALOGE_IF(err, "Error activating sensor %d (%s)", sensor_handle, strerror(-err));
371         }
372 
373         if (halVersion <= SENSORS_DEVICE_API_VERSION_1_0) {
374              err = mSensorDevice->setDelay(
375                     reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
376                     sensor_handle, info.bestBatchParams.batchDelay);
377              ALOGE_IF(err, "Error calling setDelay sensor %d (%s)", sensor_handle, strerror(-err));
378         }
379     }
380 }
381 
disableAllSensors()382 void SensorDevice::disableAllSensors() {
383     Mutex::Autolock _l(mLock);
384    for (size_t i = 0; i< mActivationCount.size(); ++i) {
385         const Info& info = mActivationCount.valueAt(i);
386         // Check if this sensor has been activated previously and disable it.
387         if (info.batchParams.size() > 0) {
388            const int sensor_handle = mActivationCount.keyAt(i);
389            ALOGD_IF(DEBUG_CONNECTIONS, "\t>> actuating h/w sensor disable handle=%d ",
390                    sensor_handle);
391            mSensorDevice->activate(
392                    reinterpret_cast<struct sensors_poll_device_t *> (mSensorDevice),
393                    sensor_handle, 0);
394            // Add all the connections that were registered for this sensor to the disabled
395            // clients list.
396            for (size_t j = 0; j < info.batchParams.size(); ++j) {
397                mDisabledClients.add(info.batchParams.keyAt(j));
398            }
399         }
400     }
401 }
402 
injectSensorData(const sensors_event_t * injected_sensor_event)403 status_t SensorDevice::injectSensorData(const sensors_event_t *injected_sensor_event) {
404       ALOGD_IF(DEBUG_CONNECTIONS,
405               "sensor_event handle=%d ts=%" PRId64 " data=%.2f, %.2f, %.2f %.2f %.2f %.2f",
406                injected_sensor_event->sensor,
407                injected_sensor_event->timestamp, injected_sensor_event->data[0],
408                injected_sensor_event->data[1], injected_sensor_event->data[2],
409                injected_sensor_event->data[3], injected_sensor_event->data[4],
410                injected_sensor_event->data[5]);
411       if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_4) {
412           return INVALID_OPERATION;
413       }
414       return mSensorDevice->inject_sensor_data(mSensorDevice, injected_sensor_event);
415 }
416 
setMode(uint32_t mode)417 status_t SensorDevice::setMode(uint32_t mode) {
418      if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_4) {
419           return INVALID_OPERATION;
420      }
421      return mSensorModule->set_operation_mode(mode);
422 }
423 
424 // ---------------------------------------------------------------------------
425 
numActiveClients()426 int SensorDevice::Info::numActiveClients() {
427     SensorDevice& device(SensorDevice::getInstance());
428     int num = 0;
429     for (size_t i = 0; i < batchParams.size(); ++i) {
430         if (!device.isClientDisabledLocked(batchParams.keyAt(i))) {
431             ++num;
432         }
433     }
434     return num;
435 }
436 
setBatchParamsForIdent(void * ident,int flags,int64_t samplingPeriodNs,int64_t maxBatchReportLatencyNs)437 status_t SensorDevice::Info::setBatchParamsForIdent(void* ident, int flags,
438                                                     int64_t samplingPeriodNs,
439                                                     int64_t maxBatchReportLatencyNs) {
440     ssize_t index = batchParams.indexOfKey(ident);
441     if (index < 0) {
442         ALOGE("Info::setBatchParamsForIdent(ident=%p, period_ns=%" PRId64 " timeout=%" PRId64 ") failed (%s)",
443               ident, samplingPeriodNs, maxBatchReportLatencyNs, strerror(-index));
444         return BAD_INDEX;
445     }
446     BatchParams& params = batchParams.editValueAt(index);
447     params.flags = flags;
448     params.batchDelay = samplingPeriodNs;
449     params.batchTimeout = maxBatchReportLatencyNs;
450     return NO_ERROR;
451 }
452 
selectBatchParams()453 void SensorDevice::Info::selectBatchParams() {
454     BatchParams bestParams(0, -1, -1);
455     SensorDevice& device(SensorDevice::getInstance());
456 
457     for (size_t i = 0; i < batchParams.size(); ++i) {
458         if (device.isClientDisabledLocked(batchParams.keyAt(i))) continue;
459         BatchParams params = batchParams.valueAt(i);
460         if (bestParams.batchDelay == -1 || params.batchDelay < bestParams.batchDelay) {
461             bestParams.batchDelay = params.batchDelay;
462         }
463         if (bestParams.batchTimeout == -1 || params.batchTimeout < bestParams.batchTimeout) {
464             bestParams.batchTimeout = params.batchTimeout;
465         }
466     }
467     bestBatchParams = bestParams;
468 }
469 
removeBatchParamsForIdent(void * ident)470 ssize_t SensorDevice::Info::removeBatchParamsForIdent(void* ident) {
471     ssize_t idx = batchParams.removeItem(ident);
472     if (idx >= 0) {
473         selectBatchParams();
474     }
475     return idx;
476 }
477 
478 // ---------------------------------------------------------------------------
479 }; // namespace android
480 
481