1 /* 2 * Copyright (C) 2009 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 /* this implements a sensors hardware library for the Android emulator. 18 * the following code should be built as a shared library that will be 19 * placed into /system/lib/hw/sensors.goldfish.so 20 * 21 * it will be loaded by the code in hardware/libhardware/hardware.c 22 * which is itself called from com_android_server_SensorService.cpp 23 */ 24 25 26 /* we connect with the emulator through the "sensors" qemud service 27 */ 28 #define SENSORS_SERVICE_NAME "sensors" 29 30 #define LOG_TAG "QemuSensors" 31 32 #include <unistd.h> 33 #include <fcntl.h> 34 #include <errno.h> 35 #include <string.h> 36 #include <log/log.h> 37 #include <cutils/sockets.h> 38 #include <hardware/sensors.h> 39 40 #if 0 41 #define D(...) ALOGD(__VA_ARGS__) 42 #else 43 #define D(...) ((void)0) 44 #endif 45 46 #define E(...) ALOGE(__VA_ARGS__) 47 48 #include "qemud.h" 49 50 /** SENSOR IDS AND NAMES 51 **/ 52 53 #define MAX_NUM_SENSORS 10 54 55 #define SUPPORTED_SENSORS ((1<<MAX_NUM_SENSORS)-1) 56 57 #define ID_BASE SENSORS_HANDLE_BASE 58 #define ID_ACCELERATION (ID_BASE+0) 59 #define ID_GYROSCOPE (ID_BASE+1) 60 #define ID_MAGNETIC_FIELD (ID_BASE+2) 61 #define ID_ORIENTATION (ID_BASE+3) 62 #define ID_TEMPERATURE (ID_BASE+4) 63 #define ID_PROXIMITY (ID_BASE+5) 64 #define ID_LIGHT (ID_BASE+6) 65 #define ID_PRESSURE (ID_BASE+7) 66 #define ID_HUMIDITY (ID_BASE+8) 67 #define ID_MAGNETIC_FIELD_UNCALIBRATED (ID_BASE+9) 68 69 #define SENSORS_ACCELERATION (1 << ID_ACCELERATION) 70 #define SENSORS_GYROSCOPE (1 << ID_GYROSCOPE) 71 #define SENSORS_MAGNETIC_FIELD (1 << ID_MAGNETIC_FIELD) 72 #define SENSORS_ORIENTATION (1 << ID_ORIENTATION) 73 #define SENSORS_TEMPERATURE (1 << ID_TEMPERATURE) 74 #define SENSORS_PROXIMITY (1 << ID_PROXIMITY) 75 #define SENSORS_LIGHT (1 << ID_LIGHT) 76 #define SENSORS_PRESSURE (1 << ID_PRESSURE) 77 #define SENSORS_HUMIDITY (1 << ID_HUMIDITY) 78 #define SENSORS_MAGNETIC_FIELD_UNCALIBRATED (1 << ID_MAGNETIC_FIELD_UNCALIBRATED) 79 80 #define ID_CHECK(x) ((unsigned)((x) - ID_BASE) < MAX_NUM_SENSORS) 81 82 #define SENSORS_LIST \ 83 SENSOR_(ACCELERATION,"acceleration") \ 84 SENSOR_(GYROSCOPE,"gyroscope") \ 85 SENSOR_(MAGNETIC_FIELD,"magnetic-field") \ 86 SENSOR_(ORIENTATION,"orientation") \ 87 SENSOR_(TEMPERATURE,"temperature") \ 88 SENSOR_(PROXIMITY,"proximity") \ 89 SENSOR_(LIGHT, "light") \ 90 SENSOR_(PRESSURE, "pressure") \ 91 SENSOR_(HUMIDITY, "humidity") \ 92 SENSOR_(MAGNETIC_FIELD_UNCALIBRATED,"magnetic-field-uncalibrated") \ 93 94 static const struct { 95 const char* name; 96 int id; } _sensorIds[MAX_NUM_SENSORS] = 97 { 98 #define SENSOR_(x,y) { y, ID_##x }, 99 SENSORS_LIST 100 #undef SENSOR_ 101 }; 102 103 static const char* 104 _sensorIdToName( int id ) 105 { 106 int nn; 107 for (nn = 0; nn < MAX_NUM_SENSORS; nn++) 108 if (id == _sensorIds[nn].id) 109 return _sensorIds[nn].name; 110 return "<UNKNOWN>"; 111 } 112 113 static int 114 _sensorIdFromName( const char* name ) 115 { 116 int nn; 117 118 if (name == NULL) 119 return -1; 120 121 for (nn = 0; nn < MAX_NUM_SENSORS; nn++) 122 if (!strcmp(name, _sensorIds[nn].name)) 123 return _sensorIds[nn].id; 124 125 return -1; 126 } 127 128 /* return the current time in nanoseconds */ 129 static int64_t now_ns(void) { 130 struct timespec ts; 131 clock_gettime(CLOCK_MONOTONIC, &ts); 132 return (int64_t)ts.tv_sec * 1000000000 + ts.tv_nsec; 133 } 134 135 /** SENSORS POLL DEVICE 136 ** 137 ** This one is used to read sensor data from the hardware. 138 ** We implement this by simply reading the data from the 139 ** emulator through the QEMUD channel. 140 **/ 141 142 typedef struct SensorDevice { 143 struct sensors_poll_device_1 device; 144 sensors_event_t sensors[MAX_NUM_SENSORS]; 145 uint32_t pendingSensors; 146 int64_t timeStart; 147 int64_t timeOffset; 148 uint32_t active_sensors; 149 int fd; 150 pthread_mutex_t lock; 151 } SensorDevice; 152 153 /* Grab the file descriptor to the emulator's sensors service pipe. 154 * This function returns a file descriptor on success, or -errno on 155 * failure, and assumes the SensorDevice instance's lock is held. 156 * 157 * This is needed because set_delay(), poll() and activate() can be called 158 * from different threads, and poll() is blocking. 159 * 160 * Note that the emulator's sensors service creates a new client for each 161 * connection through qemud_channel_open(), where each client has its own 162 * delay and set of activated sensors. This precludes calling 163 * qemud_channel_open() on each request, because a typical emulated system 164 * will do something like: 165 * 166 * 1) On a first thread, de-activate() all sensors first, then call poll(), 167 * which results in the thread blocking. 168 * 169 * 2) On a second thread, slightly later, call set_delay() then activate() 170 * to enable the acceleration sensor. 171 * 172 * The system expects this to unblock the first thread which will receive 173 * new sensor events after the activate() call in 2). 174 * 175 * This cannot work if both threads don't use the same connection. 176 * 177 * TODO(digit): This protocol is brittle, implement another control channel 178 * for set_delay()/activate()/batch() when supporting HAL 1.3 179 */ 180 static int sensor_device_get_fd_locked(SensorDevice* dev) { 181 /* Create connection to service on first call */ 182 if (dev->fd < 0) { 183 dev->fd = qemud_channel_open(SENSORS_SERVICE_NAME); 184 if (dev->fd < 0) { 185 int ret = -errno; 186 E("%s: Could not open connection to service: %s", __FUNCTION__, 187 strerror(-ret)); 188 return ret; 189 } 190 } 191 return dev->fd; 192 } 193 194 /* Send a command to the sensors virtual device. |dev| is a device instance and 195 * |cmd| is a zero-terminated command string. Return 0 on success, or -errno 196 * on failure. */ 197 static int sensor_device_send_command_locked(SensorDevice* dev, 198 const char* cmd) { 199 int fd = sensor_device_get_fd_locked(dev); 200 if (fd < 0) { 201 return fd; 202 } 203 204 int ret = 0; 205 if (qemud_channel_send(fd, cmd, strlen(cmd)) < 0) { 206 ret = -errno; 207 E("%s(fd=%d): ERROR: %s", __FUNCTION__, fd, strerror(errno)); 208 } 209 return ret; 210 } 211 212 /* Pick up one pending sensor event. On success, this returns the sensor 213 * id, and sets |*event| accordingly. On failure, i.e. if there are no 214 * pending events, return -EINVAL. 215 * 216 * Note: The device's lock must be acquired. 217 */ 218 static int sensor_device_pick_pending_event_locked(SensorDevice* d, 219 sensors_event_t* event) 220 { 221 uint32_t mask = SUPPORTED_SENSORS & d->pendingSensors; 222 if (mask) { 223 uint32_t i = 31 - __builtin_clz(mask); 224 d->pendingSensors &= ~(1U << i); 225 // Copy the structure 226 *event = d->sensors[i]; 227 228 if (d->sensors[i].type == SENSOR_TYPE_META_DATA) { 229 // sensor_device_poll_event_locked() will leave 230 // the meta-data in place until we have it. 231 // Set |type| to something other than META_DATA 232 // so sensor_device_poll_event_locked() can 233 // continue. 234 d->sensors[i].type = SENSOR_TYPE_META_DATA + 1; 235 } else { 236 event->sensor = i; 237 event->version = sizeof(*event); 238 } 239 240 D("%s: %d [%f, %f, %f]", __FUNCTION__, 241 i, 242 event->data[0], 243 event->data[1], 244 event->data[2]); 245 return i; 246 } 247 E("No sensor to return!!! pendingSensors=0x%08x", d->pendingSensors); 248 // we may end-up in a busy loop, slow things down, just in case. 249 usleep(1000); 250 return -EINVAL; 251 } 252 253 /* Block until new sensor events are reported by the emulator, or if a 254 * 'wake' command is received through the service. On succes, return 0 255 * and updates the |pendingEvents| and |sensors| fields of |dev|. 256 * On failure, return -errno. 257 * 258 * Note: The device lock must be acquired when calling this function, and 259 * will still be held on return. However, the function releases the 260 * lock temporarily during the blocking wait. 261 */ 262 static int sensor_device_poll_event_locked(SensorDevice* dev) 263 { 264 D("%s: dev=%p", __FUNCTION__, dev); 265 266 int fd = sensor_device_get_fd_locked(dev); 267 if (fd < 0) { 268 E("%s: Could not get pipe channel: %s", __FUNCTION__, strerror(-fd)); 269 return fd; 270 } 271 272 // Accumulate pending events into |events| and |new_sensors| mask 273 // until a 'sync' or 'wake' command is received. This also simplifies the 274 // code a bit. 275 uint32_t new_sensors = 0U; 276 sensors_event_t* events = dev->sensors; 277 278 int64_t event_time = -1; 279 int ret = 0; 280 281 for (;;) { 282 /* Release the lock since we're going to block on recv() */ 283 pthread_mutex_unlock(&dev->lock); 284 285 /* read the next event */ 286 char buff[256]; 287 int len = qemud_channel_recv(fd, buff, sizeof(buff) - 1U); 288 /* re-acquire the lock to modify the device state. */ 289 pthread_mutex_lock(&dev->lock); 290 291 if (len < 0) { 292 ret = -errno; 293 E("%s(fd=%d): Could not receive event data len=%d, errno=%d: %s", 294 __FUNCTION__, fd, len, errno, strerror(errno)); 295 break; 296 } 297 buff[len] = 0; 298 D("%s(fd=%d): received [%s]", __FUNCTION__, fd, buff); 299 300 301 /* "wake" is sent from the emulator to exit this loop. */ 302 /* TODO(digit): Is it still needed? */ 303 if (!strcmp((const char*)buff, "wake")) { 304 ret = 0x7FFFFFFF; 305 break; 306 } 307 308 float params[3]; 309 310 // If the existing entry for this sensor is META_DATA, 311 // do not overwrite it. We can resume saving sensor 312 // values after that meta data has been received. 313 314 /* "acceleration:<x>:<y>:<z>" corresponds to an acceleration event */ 315 if (sscanf(buff, "acceleration:%g:%g:%g", params+0, params+1, params+2) 316 == 3) { 317 new_sensors |= SENSORS_ACCELERATION; 318 if (events[ID_ACCELERATION].type == SENSOR_TYPE_META_DATA) continue; 319 events[ID_ACCELERATION].acceleration.x = params[0]; 320 events[ID_ACCELERATION].acceleration.y = params[1]; 321 events[ID_ACCELERATION].acceleration.z = params[2]; 322 events[ID_ACCELERATION].type = SENSOR_TYPE_ACCELEROMETER; 323 continue; 324 } 325 326 /* "gyroscope:<x>:<y>:<z>" corresponds to a gyroscope event */ 327 if (sscanf(buff, "gyroscope:%g:%g:%g", params+0, params+1, params+2) 328 == 3) { 329 new_sensors |= SENSORS_GYROSCOPE; 330 if (events[ID_GYROSCOPE].type == SENSOR_TYPE_META_DATA) continue; 331 events[ID_GYROSCOPE].gyro.x = params[0]; 332 events[ID_GYROSCOPE].gyro.y = params[1]; 333 events[ID_GYROSCOPE].gyro.z = params[2]; 334 events[ID_GYROSCOPE].type = SENSOR_TYPE_GYROSCOPE; 335 continue; 336 } 337 338 /* "orientation:<azimuth>:<pitch>:<roll>" is sent when orientation 339 * changes */ 340 if (sscanf(buff, "orientation:%g:%g:%g", params+0, params+1, params+2) 341 == 3) { 342 new_sensors |= SENSORS_ORIENTATION; 343 if (events[ID_ORIENTATION].type == SENSOR_TYPE_META_DATA) continue; 344 events[ID_ORIENTATION].orientation.azimuth = params[0]; 345 events[ID_ORIENTATION].orientation.pitch = params[1]; 346 events[ID_ORIENTATION].orientation.roll = params[2]; 347 events[ID_ORIENTATION].orientation.status = 348 SENSOR_STATUS_ACCURACY_HIGH; 349 events[ID_ORIENTATION].type = SENSOR_TYPE_ORIENTATION; 350 continue; 351 } 352 353 /* "magnetic:<x>:<y>:<z>" is sent for the params of the magnetic 354 * field */ 355 if (sscanf(buff, "magnetic:%g:%g:%g", params+0, params+1, params+2) 356 == 3) { 357 new_sensors |= SENSORS_MAGNETIC_FIELD; 358 if (events[ID_MAGNETIC_FIELD].type == SENSOR_TYPE_META_DATA) continue; 359 events[ID_MAGNETIC_FIELD].magnetic.x = params[0]; 360 events[ID_MAGNETIC_FIELD].magnetic.y = params[1]; 361 events[ID_MAGNETIC_FIELD].magnetic.z = params[2]; 362 events[ID_MAGNETIC_FIELD].magnetic.status = 363 SENSOR_STATUS_ACCURACY_HIGH; 364 events[ID_MAGNETIC_FIELD].type = SENSOR_TYPE_MAGNETIC_FIELD; 365 continue; 366 } 367 368 if (sscanf(buff, "magnetic-uncalibrated:%g:%g:%g", params+0, params+1, params+2) 369 == 3) { 370 new_sensors |= SENSORS_MAGNETIC_FIELD_UNCALIBRATED; 371 if (events[ID_MAGNETIC_FIELD_UNCALIBRATED].type == SENSOR_TYPE_META_DATA) continue; 372 events[ID_MAGNETIC_FIELD_UNCALIBRATED].magnetic.x = params[0]; 373 events[ID_MAGNETIC_FIELD_UNCALIBRATED].magnetic.y = params[1]; 374 events[ID_MAGNETIC_FIELD_UNCALIBRATED].magnetic.z = params[2]; 375 events[ID_MAGNETIC_FIELD_UNCALIBRATED].magnetic.status = 376 SENSOR_STATUS_ACCURACY_HIGH; 377 events[ID_MAGNETIC_FIELD_UNCALIBRATED].type = SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED; 378 continue; 379 } 380 381 /* "temperature:<celsius>" */ 382 if (sscanf(buff, "temperature:%g", params+0) == 1) { 383 new_sensors |= SENSORS_TEMPERATURE; 384 if (events[ID_TEMPERATURE].type == SENSOR_TYPE_META_DATA) continue; 385 events[ID_TEMPERATURE].temperature = params[0]; 386 events[ID_TEMPERATURE].type = SENSOR_TYPE_AMBIENT_TEMPERATURE; 387 continue; 388 } 389 390 /* "proximity:<value>" */ 391 if (sscanf(buff, "proximity:%g", params+0) == 1) { 392 new_sensors |= SENSORS_PROXIMITY; 393 if (events[ID_PROXIMITY].type == SENSOR_TYPE_META_DATA) continue; 394 events[ID_PROXIMITY].distance = params[0]; 395 events[ID_PROXIMITY].type = SENSOR_TYPE_PROXIMITY; 396 continue; 397 } 398 /* "light:<lux>" */ 399 if (sscanf(buff, "light:%g", params+0) == 1) { 400 new_sensors |= SENSORS_LIGHT; 401 if (events[ID_LIGHT].type == SENSOR_TYPE_META_DATA) continue; 402 events[ID_LIGHT].light = params[0]; 403 events[ID_LIGHT].type = SENSOR_TYPE_LIGHT; 404 continue; 405 } 406 407 /* "pressure:<hpa>" */ 408 if (sscanf(buff, "pressure:%g", params+0) == 1) { 409 new_sensors |= SENSORS_PRESSURE; 410 if (events[ID_PRESSURE].type == SENSOR_TYPE_META_DATA) continue; 411 events[ID_PRESSURE].pressure = params[0]; 412 events[ID_PRESSURE].type = SENSOR_TYPE_PRESSURE; 413 continue; 414 } 415 416 /* "humidity:<percent>" */ 417 if (sscanf(buff, "humidity:%g", params+0) == 1) { 418 new_sensors |= SENSORS_HUMIDITY; 419 if (events[ID_HUMIDITY].type == SENSOR_TYPE_META_DATA) continue; 420 events[ID_HUMIDITY].relative_humidity = params[0]; 421 events[ID_HUMIDITY].type = SENSOR_TYPE_RELATIVE_HUMIDITY; 422 continue; 423 } 424 425 /* "sync:<time>" is sent after a series of sensor events. 426 * where 'time' is expressed in micro-seconds and corresponds 427 * to the VM time when the real poll occured. 428 */ 429 if (sscanf(buff, "sync:%lld", &event_time) == 1) { 430 if (new_sensors) { 431 goto out; 432 } 433 D("huh ? sync without any sensor data ?"); 434 continue; 435 } 436 D("huh ? unsupported command"); 437 } 438 out: 439 if (new_sensors) { 440 /* update the time of each new sensor event. */ 441 dev->pendingSensors |= new_sensors; 442 int64_t t = (event_time < 0) ? 0 : event_time * 1000LL; 443 444 /* Use the time at the first "sync:" as the base for later 445 * time values. 446 * CTS tests require sensors to return an event timestamp (sync) that is 447 * strictly before the time of the event arrival. We don't actually have 448 * a time syncronization protocol here, and the only data point is the 449 * "sync:" timestamp - which is an emulator's timestamp of a clock that 450 * is synced with the guest clock, and it only the timestamp after all 451 * events were sent. 452 * To make it work, let's compare the calculated timestamp with current 453 * time and take the lower value - we don't believe in events from the 454 * future anyway. 455 */ 456 const int64_t now = now_ns(); 457 458 if (dev->timeStart == 0) { 459 dev->timeStart = now; 460 dev->timeOffset = dev->timeStart - t; 461 } 462 t += dev->timeOffset; 463 if (t > now) { 464 t = now; 465 } 466 467 while (new_sensors) { 468 uint32_t i = 31 - __builtin_clz(new_sensors); 469 new_sensors &= ~(1U << i); 470 dev->sensors[i].timestamp = t; 471 } 472 } 473 return ret; 474 } 475 476 /** SENSORS POLL DEVICE FUNCTIONS **/ 477 478 static int sensor_device_close(struct hw_device_t* dev0) 479 { 480 SensorDevice* dev = (void*)dev0; 481 // Assume that there are no other threads blocked on poll() 482 if (dev->fd >= 0) { 483 close(dev->fd); 484 dev->fd = -1; 485 } 486 pthread_mutex_destroy(&dev->lock); 487 free(dev); 488 return 0; 489 } 490 491 /* Return an array of sensor data. This function blocks until there is sensor 492 * related events to report. On success, it will write the events into the 493 * |data| array, which contains |count| items. The function returns the number 494 * of events written into the array, which shall never be greater than |count|. 495 * On error, return -errno code. 496 * 497 * Note that according to the sensor HAL [1], it shall never return 0! 498 * 499 * [1] http://source.android.com/devices/sensors/hal-interface.html 500 */ 501 static int sensor_device_poll(struct sensors_poll_device_t *dev0, 502 sensors_event_t* data, int count) 503 { 504 SensorDevice* dev = (void*)dev0; 505 D("%s: dev=%p data=%p count=%d ", __FUNCTION__, dev, data, count); 506 507 if (count <= 0) { 508 return -EINVAL; 509 } 510 511 int result = 0; 512 pthread_mutex_lock(&dev->lock); 513 if (!dev->pendingSensors) { 514 /* Block until there are pending events. Note that this releases 515 * the lock during the blocking call, then re-acquires it before 516 * returning. */ 517 int ret = sensor_device_poll_event_locked(dev); 518 if (ret < 0) { 519 result = ret; 520 goto out; 521 } 522 if (!dev->pendingSensors) { 523 /* 'wake' event received before any sensor data. */ 524 result = -EIO; 525 goto out; 526 } 527 } 528 /* Now read as many pending events as needed. */ 529 int i; 530 for (i = 0; i < count; i++) { 531 if (!dev->pendingSensors) { 532 break; 533 } 534 int ret = sensor_device_pick_pending_event_locked(dev, data); 535 if (ret < 0) { 536 if (!result) { 537 result = ret; 538 } 539 break; 540 } 541 data++; 542 result++; 543 } 544 out: 545 pthread_mutex_unlock(&dev->lock); 546 D("%s: result=%d", __FUNCTION__, result); 547 return result; 548 } 549 550 static int sensor_device_activate(struct sensors_poll_device_t *dev0, 551 int handle, 552 int enabled) 553 { 554 SensorDevice* dev = (void*)dev0; 555 556 D("%s: handle=%s (%d) enabled=%d", __FUNCTION__, 557 _sensorIdToName(handle), handle, enabled); 558 559 /* Sanity check */ 560 if (!ID_CHECK(handle)) { 561 E("%s: bad handle ID", __FUNCTION__); 562 return -EINVAL; 563 } 564 565 /* Exit early if sensor is already enabled/disabled. */ 566 uint32_t mask = (1U << handle); 567 uint32_t sensors = enabled ? mask : 0; 568 569 pthread_mutex_lock(&dev->lock); 570 571 uint32_t active = dev->active_sensors; 572 uint32_t new_sensors = (active & ~mask) | (sensors & mask); 573 uint32_t changed = active ^ new_sensors; 574 575 int ret = 0; 576 if (changed) { 577 /* Send command to the emulator. */ 578 char command[64]; 579 snprintf(command, 580 sizeof command, 581 "set:%s:%d", 582 _sensorIdToName(handle), 583 enabled != 0); 584 585 ret = sensor_device_send_command_locked(dev, command); 586 if (ret < 0) { 587 E("%s: when sending command errno=%d: %s", __FUNCTION__, -ret, 588 strerror(-ret)); 589 } else { 590 dev->active_sensors = new_sensors; 591 } 592 } 593 pthread_mutex_unlock(&dev->lock); 594 return ret; 595 } 596 597 static int sensor_device_default_flush( 598 struct sensors_poll_device_1* dev0, 599 int handle) { 600 601 SensorDevice* dev = (void*)dev0; 602 603 D("%s: handle=%s (%d)", __FUNCTION__, 604 _sensorIdToName(handle), handle); 605 606 /* Sanity check */ 607 if (!ID_CHECK(handle)) { 608 E("%s: bad handle ID", __FUNCTION__); 609 return -EINVAL; 610 } 611 612 pthread_mutex_lock(&dev->lock); 613 dev->sensors[handle].version = META_DATA_VERSION; 614 dev->sensors[handle].type = SENSOR_TYPE_META_DATA; 615 dev->sensors[handle].sensor = 0; 616 dev->sensors[handle].timestamp = 0; 617 dev->sensors[handle].meta_data.sensor = handle; 618 dev->sensors[handle].meta_data.what = META_DATA_FLUSH_COMPLETE; 619 dev->pendingSensors |= (1U << handle); 620 pthread_mutex_unlock(&dev->lock); 621 622 return 0; 623 } 624 625 static int sensor_device_set_delay(struct sensors_poll_device_t *dev0, 626 int handle __unused, 627 int64_t ns) 628 { 629 SensorDevice* dev = (void*)dev0; 630 631 int ms = (int)(ns / 1000000); 632 D("%s: dev=%p delay-ms=%d", __FUNCTION__, dev, ms); 633 634 char command[64]; 635 snprintf(command, sizeof command, "set-delay:%d", ms); 636 637 pthread_mutex_lock(&dev->lock); 638 int ret = sensor_device_send_command_locked(dev, command); 639 pthread_mutex_unlock(&dev->lock); 640 if (ret < 0) { 641 E("%s: Could not send command: %s", __FUNCTION__, strerror(-ret)); 642 } 643 return ret; 644 } 645 646 static int sensor_device_default_batch( 647 struct sensors_poll_device_1* dev, 648 int sensor_handle, 649 int flags, 650 int64_t sampling_period_ns, 651 int64_t max_report_latency_ns) { 652 return sensor_device_set_delay(dev, sensor_handle, sampling_period_ns); 653 } 654 655 /** MODULE REGISTRATION SUPPORT 656 ** 657 ** This is required so that hardware/libhardware/hardware.c 658 ** will dlopen() this library appropriately. 659 **/ 660 661 /* 662 * the following is the list of all supported sensors. 663 * this table is used to build sSensorList declared below 664 * according to which hardware sensors are reported as 665 * available from the emulator (see get_sensors_list below) 666 * 667 * note: numerical values for maxRange/resolution/power for 668 * all sensors but light, pressure and humidity were 669 * taken from the reference AK8976A implementation 670 */ 671 static const struct sensor_t sSensorListInit[] = { 672 { .name = "Goldfish 3-axis Accelerometer", 673 .vendor = "The Android Open Source Project", 674 .version = 1, 675 .handle = ID_ACCELERATION, 676 .type = SENSOR_TYPE_ACCELEROMETER, 677 .maxRange = 2.8f, 678 .resolution = 1.0f/4032.0f, 679 .power = 3.0f, 680 .minDelay = 10000, 681 .maxDelay = 60 * 1000 * 1000, 682 .fifoReservedEventCount = 0, 683 .fifoMaxEventCount = 0, 684 .stringType = 0, 685 .requiredPermission = 0, 686 .flags = SENSOR_FLAG_CONTINUOUS_MODE, 687 .reserved = {} 688 }, 689 690 { .name = "Goldfish 3-axis Gyroscope", 691 .vendor = "The Android Open Source Project", 692 .version = 1, 693 .handle = ID_GYROSCOPE, 694 .type = SENSOR_TYPE_GYROSCOPE, 695 .maxRange = 11.1111111, 696 .resolution = 1.0f/1000.0f, 697 .power = 3.0f, 698 .minDelay = 10000, 699 .maxDelay = 60 * 1000 * 1000, 700 .reserved = {} 701 }, 702 703 { .name = "Goldfish 3-axis Magnetic field sensor", 704 .vendor = "The Android Open Source Project", 705 .version = 1, 706 .handle = ID_MAGNETIC_FIELD, 707 .type = SENSOR_TYPE_MAGNETIC_FIELD, 708 .maxRange = 2000.0f, 709 .resolution = 1.0f, 710 .power = 6.7f, 711 .minDelay = 10000, 712 .maxDelay = 60 * 1000 * 1000, 713 .fifoReservedEventCount = 0, 714 .fifoMaxEventCount = 0, 715 .stringType = 0, 716 .requiredPermission = 0, 717 .flags = SENSOR_FLAG_CONTINUOUS_MODE, 718 .reserved = {} 719 }, 720 721 { .name = "Goldfish Orientation sensor", 722 .vendor = "The Android Open Source Project", 723 .version = 1, 724 .handle = ID_ORIENTATION, 725 .type = SENSOR_TYPE_ORIENTATION, 726 .maxRange = 360.0f, 727 .resolution = 1.0f, 728 .power = 9.7f, 729 .minDelay = 10000, 730 .maxDelay = 60 * 1000 * 1000, 731 .fifoReservedEventCount = 0, 732 .fifoMaxEventCount = 0, 733 .stringType = 0, 734 .requiredPermission = 0, 735 .flags = SENSOR_FLAG_CONTINUOUS_MODE, 736 .reserved = {} 737 }, 738 739 { .name = "Goldfish Temperature sensor", 740 .vendor = "The Android Open Source Project", 741 .version = 1, 742 .handle = ID_TEMPERATURE, 743 .type = SENSOR_TYPE_AMBIENT_TEMPERATURE, 744 .maxRange = 80.0f, 745 .resolution = 1.0f, 746 .power = 0.0f, 747 .minDelay = 10000, 748 .maxDelay = 60 * 1000 * 1000, 749 .fifoReservedEventCount = 0, 750 .fifoMaxEventCount = 0, 751 .stringType = 0, 752 .requiredPermission = 0, 753 .flags = SENSOR_FLAG_CONTINUOUS_MODE, 754 .reserved = {} 755 }, 756 757 { .name = "Goldfish Proximity sensor", 758 .vendor = "The Android Open Source Project", 759 .version = 1, 760 .handle = ID_PROXIMITY, 761 .type = SENSOR_TYPE_PROXIMITY, 762 .maxRange = 1.0f, 763 .resolution = 1.0f, 764 .power = 20.0f, 765 .minDelay = 10000, 766 .maxDelay = 60 * 1000 * 1000, 767 .fifoReservedEventCount = 0, 768 .fifoMaxEventCount = 0, 769 .stringType = 0, 770 .requiredPermission = 0, 771 .flags = SENSOR_FLAG_WAKE_UP | SENSOR_FLAG_ON_CHANGE_MODE, 772 .reserved = {} 773 }, 774 775 { .name = "Goldfish Light sensor", 776 .vendor = "The Android Open Source Project", 777 .version = 1, 778 .handle = ID_LIGHT, 779 .type = SENSOR_TYPE_LIGHT, 780 .maxRange = 40000.0f, 781 .resolution = 1.0f, 782 .power = 20.0f, 783 .minDelay = 10000, 784 .maxDelay = 60 * 1000 * 1000, 785 .fifoReservedEventCount = 0, 786 .fifoMaxEventCount = 0, 787 .stringType = 0, 788 .requiredPermission = 0, 789 .flags = SENSOR_FLAG_ON_CHANGE_MODE, 790 .reserved = {} 791 }, 792 793 { .name = "Goldfish Pressure sensor", 794 .vendor = "The Android Open Source Project", 795 .version = 1, 796 .handle = ID_PRESSURE, 797 .type = SENSOR_TYPE_PRESSURE, 798 .maxRange = 800.0f, 799 .resolution = 1.0f, 800 .power = 20.0f, 801 .minDelay = 10000, 802 .maxDelay = 60 * 1000 * 1000, 803 .fifoReservedEventCount = 0, 804 .fifoMaxEventCount = 0, 805 .stringType = 0, 806 .requiredPermission = 0, 807 .flags = SENSOR_FLAG_CONTINUOUS_MODE, 808 .reserved = {} 809 }, 810 811 { .name = "Goldfish Humidity sensor", 812 .vendor = "The Android Open Source Project", 813 .version = 1, 814 .handle = ID_HUMIDITY, 815 .type = SENSOR_TYPE_RELATIVE_HUMIDITY, 816 .maxRange = 100.0f, 817 .resolution = 1.0f, 818 .power = 20.0f, 819 .minDelay = 10000, 820 .maxDelay = 60 * 1000 * 1000, 821 .fifoReservedEventCount = 0, 822 .fifoMaxEventCount = 0, 823 .stringType = 0, 824 .requiredPermission = 0, 825 .flags = SENSOR_FLAG_CONTINUOUS_MODE, 826 .reserved = {} 827 }, 828 829 { .name = "Goldfish 3-axis Magnetic field sensor (uncalibrated)", 830 .vendor = "The Android Open Source Project", 831 .version = 1, 832 .handle = ID_MAGNETIC_FIELD_UNCALIBRATED, 833 .type = SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED, 834 .maxRange = 2000.0f, 835 .resolution = 1.0f, 836 .power = 6.7f, 837 .minDelay = 10000, 838 .maxDelay = 60 * 1000 * 1000, 839 .reserved = {} 840 }, 841 }; 842 843 static struct sensor_t sSensorList[MAX_NUM_SENSORS]; 844 845 static int sensors__get_sensors_list(struct sensors_module_t* module __unused, 846 struct sensor_t const** list) 847 { 848 int fd = qemud_channel_open(SENSORS_SERVICE_NAME); 849 char buffer[12]; 850 int mask, nn, count; 851 int ret = 0; 852 853 if (fd < 0) { 854 E("%s: no qemud connection", __FUNCTION__); 855 goto out; 856 } 857 ret = qemud_channel_send(fd, "list-sensors", -1); 858 if (ret < 0) { 859 E("%s: could not query sensor list: %s", __FUNCTION__, 860 strerror(errno)); 861 goto out; 862 } 863 ret = qemud_channel_recv(fd, buffer, sizeof buffer-1); 864 if (ret < 0) { 865 E("%s: could not receive sensor list: %s", __FUNCTION__, 866 strerror(errno)); 867 goto out; 868 } 869 buffer[ret] = 0; 870 871 /* the result is a integer used as a mask for available sensors */ 872 mask = atoi(buffer); 873 count = 0; 874 for (nn = 0; nn < MAX_NUM_SENSORS; nn++) { 875 if (((1 << nn) & mask) == 0) 876 continue; 877 sSensorList[count++] = sSensorListInit[nn]; 878 } 879 D("%s: returned %d sensors (mask=%d)", __FUNCTION__, count, mask); 880 *list = sSensorList; 881 882 ret = count; 883 out: 884 if (fd >= 0) { 885 close(fd); 886 } 887 return ret; 888 } 889 890 891 static int 892 open_sensors(const struct hw_module_t* module, 893 const char* name, 894 struct hw_device_t* *device) 895 { 896 int status = -EINVAL; 897 898 D("%s: name=%s", __FUNCTION__, name); 899 900 if (!strcmp(name, SENSORS_HARDWARE_POLL)) { 901 SensorDevice *dev = malloc(sizeof(*dev)); 902 903 memset(dev, 0, sizeof(*dev)); 904 905 dev->device.common.tag = HARDWARE_DEVICE_TAG; 906 dev->device.common.version = SENSORS_DEVICE_API_VERSION_1_3; 907 dev->device.common.module = (struct hw_module_t*) module; 908 dev->device.common.close = sensor_device_close; 909 dev->device.poll = sensor_device_poll; 910 dev->device.activate = sensor_device_activate; 911 dev->device.setDelay = sensor_device_set_delay; 912 913 // (dev->sensors[i].type == SENSOR_TYPE_META_DATA) is 914 // sticky. Don't start off with that setting. 915 for (int idx = 0; idx < MAX_NUM_SENSORS; idx++) { 916 dev->sensors[idx].type = SENSOR_TYPE_META_DATA + 1; 917 } 918 919 // Version 1.3-specific functions 920 dev->device.batch = sensor_device_default_batch; 921 dev->device.flush = sensor_device_default_flush; 922 923 dev->fd = -1; 924 pthread_mutex_init(&dev->lock, NULL); 925 926 *device = &dev->device.common; 927 status = 0; 928 } 929 return status; 930 } 931 932 933 static struct hw_module_methods_t sensors_module_methods = { 934 .open = open_sensors 935 }; 936 937 struct sensors_module_t HAL_MODULE_INFO_SYM = { 938 .common = { 939 .tag = HARDWARE_MODULE_TAG, 940 .version_major = 1, 941 .version_minor = 3, 942 .id = SENSORS_HARDWARE_MODULE_ID, 943 .name = "Goldfish SENSORS Module", 944 .author = "The Android Open Source Project", 945 .methods = &sensors_module_methods, 946 }, 947 .get_sensors_list = sensors__get_sensors_list 948 }; 949
