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#define LOG_TAG "Sensors" 18//#define FUNC_LOG ALOGV("%s", __PRETTY_FUNCTION__) 19#define FUNC_LOG 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 <stdlib.h> 29 30#include <utils/Atomic.h> 31#include <utils/Log.h> 32 33#include "sensors.h" 34 35#include "MPLSensor.h" 36#include "LightSensor.h" 37#include "PressureSensor.h" 38 39 40/*****************************************************************************/ 41 42#define DELAY_OUT_TIME 0x7FFFFFFF 43 44#define SENSORS_ROTATION_VECTOR (1<<ID_RV) 45#define SENSORS_LINEAR_ACCEL (1<<ID_LA) 46#define SENSORS_GRAVITY (1<<ID_GR) 47#define SENSORS_GYROSCOPE (1<<ID_GY) 48#define SENSORS_ACCELERATION (1<<ID_A) 49#define SENSORS_MAGNETIC_FIELD (1<<ID_M) 50#define SENSORS_ORIENTATION (1<<ID_O) 51#define SENSORS_LIGHT (1<<ID_L) 52#define SENSORS_PROXIMITY (1<<ID_P) 53#define SENSORS_PRESSURE (1<<ID_PR) 54 55#define SENSORS_ROTATION_VECTOR_HANDLE (ID_RV) 56#define SENSORS_LINEAR_ACCEL_HANDLE (ID_LA) 57#define SENSORS_GRAVITY_HANDLE (ID_GR) 58#define SENSORS_GYROSCOPE_HANDLE (ID_GY) 59#define SENSORS_RAW_GYROSCOPE_HANDLE (ID_RG) 60#define SENSORS_ACCELERATION_HANDLE (ID_A) 61#define SENSORS_MAGNETIC_FIELD_HANDLE (ID_M) 62#define SENSORS_ORIENTATION_HANDLE (ID_O) 63#define SENSORS_LIGHT_HANDLE (ID_L) 64#define SENSORS_PROXIMITY_HANDLE (ID_P) 65#define SENSORS_PRESSURE_HANDLE (ID_PR) 66#define AKM_FTRACE 0 67#define AKM_DEBUG 0 68#define AKM_DATA 0 69 70/*****************************************************************************/ 71 72/* The SENSORS Module */ 73#define LOCAL_SENSORS (2) 74static struct sensor_t sSensorList[LOCAL_SENSORS + MPLSensor::numSensors] = { 75 { "BH1721fvc Light sensor", 76 "Rohm", 77 1, SENSORS_LIGHT_HANDLE, 78 SENSOR_TYPE_LIGHT, 65528.0f, 1.0f, 0.20f, 16000, { } }, 79 { "BMP182 Pressure sensor", 80 "Bosch", 81 1, SENSORS_PRESSURE_HANDLE, 82 SENSOR_TYPE_PRESSURE, 1100.0f, 0.01f, 0.06f, 50000, { } }, 83}; 84static int numSensors = LOCAL_SENSORS; 85 86static int open_sensors(const struct hw_module_t* module, const char* id, 87 struct hw_device_t** device); 88 89 90static int sensors__get_sensors_list(struct sensors_module_t* module, 91 struct sensor_t const** list) 92{ 93 *list = sSensorList; 94 return numSensors; 95} 96 97static struct hw_module_methods_t sensors_module_methods = { 98 open: open_sensors 99}; 100 101struct sensors_module_t HAL_MODULE_INFO_SYM = { 102 common: { 103 tag: HARDWARE_MODULE_TAG, 104 version_major: 1, 105 version_minor: 0, 106 id: SENSORS_HARDWARE_MODULE_ID, 107 name: "Samsung Sensor module", 108 author: "Samsung Electronic Company", 109 methods: &sensors_module_methods, 110 dso: 0, 111 reserved: {}, 112 }, 113 get_sensors_list: sensors__get_sensors_list, 114}; 115 116struct sensors_poll_context_t { 117 struct sensors_poll_device_t device; // must be first 118 119 sensors_poll_context_t(); 120 ~sensors_poll_context_t(); 121 int activate(int handle, int enabled); 122 int setDelay(int handle, int64_t ns); 123 int pollEvents(sensors_event_t* data, int count); 124 125 // Will return true if the constructor completed 126 bool isValid() { return mInitialized; }; 127 128private: 129 // Will be true if the constructor completed 130 bool mInitialized; 131 132 enum { 133 mpl = 0, 134 compass, 135 light, 136 pressure, 137 numSensorDrivers, // wake pipe goes here 138 numFds, 139 }; 140 141 static const size_t wake = numFds - 1; 142 static const char WAKE_MESSAGE = 'W'; 143 struct pollfd mPollFds[numFds]; 144 int mWritePipeFd; 145 SensorBase* mSensors[numSensorDrivers]; 146 147 int handleToDriver(int handle) const { 148 switch (handle) { 149 case ID_RV: 150 case ID_LA: 151 case ID_GR: 152 case ID_GY: 153 case ID_RG: 154 case ID_A: 155 case ID_M: 156 case ID_O: 157 return mpl; 158 case ID_L: 159 return light; 160 case ID_PR: 161 return pressure; 162 } 163 return -EINVAL; 164 } 165}; 166 167/*****************************************************************************/ 168 169sensors_poll_context_t::sensors_poll_context_t() 170{ 171 FUNC_LOG; 172 CompassSensor *p_compasssensor = new CompassSensor(); 173 MPLSensor *p_mplsen = new MPLSensor(p_compasssensor); 174 mInitialized = false; 175 // Must clean this up early or else the destructor will make a mess. 176 memset(mSensors, 0, sizeof(mSensors)); 177 178 if (!p_mplsen->isValid()) { 179 delete p_compasssensor; 180 return; 181 } 182 183 setCallbackObject(p_mplsen); //setup the callback object for handing mpl callbacks 184 numSensors = 185 LOCAL_SENSORS + 186 p_mplsen->populateSensorList(sSensorList + LOCAL_SENSORS, 187 sizeof(sSensorList[0]) * (ARRAY_SIZE(sSensorList) - LOCAL_SENSORS)); 188 189 mSensors[mpl] = p_mplsen; 190 mPollFds[mpl].fd = mSensors[mpl]->getFd(); 191 mPollFds[mpl].events = POLLIN; 192 mPollFds[mpl].revents = 0; 193 194 mSensors[compass] = p_mplsen; 195 mPollFds[compass].fd = ((MPLSensor*)mSensors[mpl])->getCompassFd(); 196 mPollFds[compass].events = POLLIN; 197 mPollFds[compass].revents = 0; 198 199 mSensors[light] = new LightSensor(); 200 mPollFds[light].fd = mSensors[light]->getFd(); 201 mPollFds[light].events = POLLIN; 202 mPollFds[light].revents = 0; 203 204 mSensors[pressure] = new PressureSensor(); 205 mPollFds[pressure].fd = mSensors[pressure]->getFd(); 206 mPollFds[pressure].events = POLLIN; 207 mPollFds[pressure].revents = 0; 208 209 int wakeFds[2]; 210 int result = pipe(wakeFds); 211 ALOGE_IF(result<0, "error creating wake pipe (%s)", strerror(errno)); 212 fcntl(wakeFds[0], F_SETFL, O_NONBLOCK); 213 fcntl(wakeFds[1], F_SETFL, O_NONBLOCK); 214 mWritePipeFd = wakeFds[1]; 215 216 mPollFds[wake].fd = wakeFds[0]; 217 mPollFds[wake].events = POLLIN; 218 mPollFds[wake].revents = 0; 219 mInitialized = true; 220} 221 222sensors_poll_context_t::~sensors_poll_context_t() 223{ 224 FUNC_LOG; 225 for (int i=0 ; i<numSensorDrivers ; i++) { 226 delete mSensors[i]; 227 } 228 close(mPollFds[wake].fd); 229 close(mWritePipeFd); 230 mInitialized = false; 231} 232 233int sensors_poll_context_t::activate(int handle, int enabled) 234{ 235 FUNC_LOG; 236 if (!mInitialized) return -EINVAL; 237 int index = handleToDriver(handle); 238 if (index < 0) return index; 239 int err = mSensors[index]->enable(handle, enabled); 240 if (!err) { 241 const char wakeMessage(WAKE_MESSAGE); 242 int result = write(mWritePipeFd, &wakeMessage, 1); 243 ALOGE_IF(result<0, "error sending wake message (%s)", strerror(errno)); 244 } 245 return err; 246} 247 248int sensors_poll_context_t::setDelay(int handle, int64_t ns) 249{ 250 FUNC_LOG; 251 int index = handleToDriver(handle); 252 if (index < 0) return index; 253 return mSensors[index]->setDelay(handle, ns); 254} 255 256int sensors_poll_context_t::pollEvents(sensors_event_t* data, int count) 257{ 258 //FUNC_LOG; 259 int nbEvents = 0; 260 int n = 0; 261 int polltime = -1; 262 do { 263 for (int i=0 ; count && i<numSensorDrivers ; i++) { 264 SensorBase* const sensor(mSensors[i]); 265 // See if we have some pending events from the last poll() 266 if ((mPollFds[i].revents & (POLLIN | POLLPRI)) || (sensor->hasPendingEvents())) { 267 int nb; 268 if (i == compass) { 269 /* result is hardcoded to 0 */ 270 ((MPLSensor*) sensor)->readCompassEvents(NULL, count); 271 nb = ((MPLSensor*) mSensors[mpl])->executeOnData(data, count); 272 } 273 else if (i == mpl) { 274 /* result is hardcoded to 0 */ 275 sensor->readEvents(NULL, count); 276 nb = ((MPLSensor*) mSensors[mpl])->executeOnData(data, count); 277 mPollFds[i].revents = 0; 278 } 279 else { 280 nb = sensor->readEvents(data, count); 281 } 282 if (nb < count) { 283 // no more data for this sensor 284 mPollFds[i].revents = 0; 285 } 286 count -= nb; 287 nbEvents += nb; 288 data += nb; 289 } 290 } 291 if (count) { 292 do { 293 n = poll(mPollFds, numFds, nbEvents ? 0 : polltime); 294 } while (n < 0 && errno == EINTR); 295 if (n < 0) { 296 ALOGE("poll() failed (%s)", strerror(errno)); 297 return -errno; 298 } 299 if (mPollFds[wake].revents & (POLLIN | POLLPRI)) { 300 char msg; 301 int result = read(mPollFds[wake].fd, &msg, 1); 302 ALOGE_IF(result<0, "error reading from wake pipe (%s)", strerror(errno)); 303 ALOGE_IF(msg != WAKE_MESSAGE, "unknown message on wake queue (0x%02x)", int(msg)); 304 mPollFds[wake].revents = 0; 305 } 306 } 307 // if we have events and space, go read them 308 } while (n && count); 309 310 return nbEvents; 311} 312 313/*****************************************************************************/ 314 315static int poll__close(struct hw_device_t *dev) 316{ 317 FUNC_LOG; 318 sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev; 319 if (ctx) { 320 delete ctx; 321 } 322 return 0; 323} 324 325static int poll__activate(struct sensors_poll_device_t *dev, 326 int handle, int enabled) 327{ 328 FUNC_LOG; 329 sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev; 330 return ctx->activate(handle, enabled); 331} 332 333static int poll__setDelay(struct sensors_poll_device_t *dev, 334 int handle, int64_t ns) 335{ 336 FUNC_LOG; 337 sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev; 338 return ctx->setDelay(handle, ns); 339} 340 341static int poll__poll(struct sensors_poll_device_t *dev, 342 sensors_event_t* data, int count) 343{ 344 FUNC_LOG; 345 sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev; 346 return ctx->pollEvents(data, count); 347} 348 349/*****************************************************************************/ 350 351/** Open a new instance of a sensor device using name */ 352static int open_sensors(const struct hw_module_t* module, const char* id, 353 struct hw_device_t** device) 354{ 355 FUNC_LOG; 356 int status = -EINVAL; 357 sensors_poll_context_t *dev = new sensors_poll_context_t(); 358 359 if (!dev->isValid()) { 360 ALOGE("Failed to open the sensors"); 361 return status; 362 } 363 364 memset(&dev->device, 0, sizeof(sensors_poll_device_t)); 365 366 dev->device.common.tag = HARDWARE_DEVICE_TAG; 367 dev->device.common.version = 0; 368 dev->device.common.module = const_cast<hw_module_t*>(module); 369 dev->device.common.close = poll__close; 370 dev->device.activate = poll__activate; 371 dev->device.setDelay = poll__setDelay; 372 dev->device.poll = poll__poll; 373 374 *device = &dev->device.common; 375 status = 0; 376 377 return status; 378} 379