Home | History | Annotate | Download | only in libsensors 
      1 /*
      2  * Copyright 2013 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 <hardware/sensors.h>
     18 #include <fcntl.h>
     19 #include <errno.h>
     20 #include <dirent.h>
     21 #include <math.h>
     22 #include <poll.h>
     23 #include <pthread.h>
     24 #include <stdlib.h>
     25 
     26 #include <linux/input.h>
     27 
     28 #include <utils/Atomic.h>
     29 #include <utils/Log.h>
     30 
     31 #include "sensors.h"
     32 #include "MPLSensor.h"
     33 #include "LightSensor.h"
     34 #include "ProximitySensor.h"
     35 
     36 /*****************************************************************************/
     37 /* The SENSORS Module */
     38 
     39 #ifdef ENABLE_DMP_SCREEN_AUTO_ROTATION
     40 #define GLOBAL_SENSORS (MPLSensor::NumSensors + 1)
     41 #else
     42 #define GLOBAL_SENSORS MPLSensor::NumSensors
     43 #endif
     44 
     45 #define LOCAL_SENSORS (2)
     46 
     47 #define SENSORS_LIGHT_HANDLE        (ID_L)
     48 #define SENSORS_PROXIMITY_HANDLE    (ID_PX)
     49 
     50 static struct sensor_t sSensorList[GLOBAL_SENSORS + LOCAL_SENSORS] = {
     51     {
     52         .name       = "Light Sensor",
     53         .vendor     = "Avago Technologies",
     54         .version    = 1,
     55         .handle     = SENSORS_LIGHT_HANDLE,
     56         .type       = SENSOR_TYPE_LIGHT,
     57         .maxRange   = 30000.0f,
     58         .resolution = 1.0f,
     59         .power      = 0.5f,
     60         .minDelay   = 100000,
     61         .reserved   = {}
     62     },
     63     {
     64         .name       = "Proximity Sensor",
     65         .vendor     = "Avago Technologies",
     66         .version    = 1,
     67         .handle     = SENSORS_PROXIMITY_HANDLE,
     68         .type       = SENSOR_TYPE_PROXIMITY,
     69         .maxRange   = 5.0f,
     70         .resolution = 1.0f,
     71         .power      = 0.5f,
     72         .minDelay   = 100000,
     73         .reserved   = {}
     74     },
     75 };
     76 static int sensors = (sizeof(sSensorList) / sizeof(sensor_t));
     77 
     78 static int open_sensors(const struct hw_module_t* module, const char* id,
     79                         struct hw_device_t** device);
     80 
     81 static int sensors__get_sensors_list(struct sensors_module_t* module,
     82                                      struct sensor_t const** list)
     83 {
     84     *list = sSensorList;
     85     return sensors;
     86 }
     87 
     88 static struct hw_module_methods_t sensors_module_methods = {
     89         open: open_sensors
     90 };
     91 
     92 struct sensors_module_t HAL_MODULE_INFO_SYM = {
     93     common: {
     94         tag: HARDWARE_MODULE_TAG,
     95         version_major: 1,
     96         version_minor: 0,
     97         id: SENSORS_HARDWARE_MODULE_ID,
     98         name: "LGE Sensor module",
     99         author: "LG Electronics Inc.",
    100         methods: &sensors_module_methods,
    101         dso: NULL,
    102         reserved: {0}
    103     },
    104     get_sensors_list: sensors__get_sensors_list,
    105 };
    106 
    107 struct sensors_poll_context_t {
    108     sensors_poll_device_1_t device; // must be first
    109 
    110     sensors_poll_context_t();
    111     ~sensors_poll_context_t();
    112     int activate(int handle, int enabled);
    113     int setDelay(int handle, int64_t ns);
    114     int pollEvents(sensors_event_t* data, int count);
    115     int batch(int handle, int flags, int64_t period_ns, int64_t timeout);
    116 
    117     // return true if the constructor is completed
    118     bool isValid() { return mInitialized; };
    119     int flush(int handle);
    120 
    121 private:
    122     enum {
    123         mpl = 0,
    124         compass,
    125         dmpOrient,
    126         dmpSign,
    127         dmpPed,
    128         light,
    129         proximity,
    130         numSensorDrivers,   // wake pipe goes here
    131         numFds,
    132     };
    133 
    134     static const size_t wake = numFds - 1;
    135     static const char WAKE_MESSAGE = 'W';
    136     struct pollfd mPollFds[numFds];
    137     int mWritePipeFd;
    138     SensorBase *mSensor[numSensorDrivers];
    139     CompassSensor *mCompassSensor;
    140     // return true if the constructor is completed
    141     bool mInitialized;
    142 
    143     int handleToDriver(int handle) const {
    144         switch (handle) {
    145             case ID_GY:
    146             case ID_RG:
    147             case ID_A:
    148             case ID_M:
    149             case ID_RM:
    150             case ID_PS:
    151             case ID_O:
    152             case ID_RV:
    153             case ID_GRV:
    154             case ID_LA:
    155             case ID_GR:
    156             case ID_SM:
    157             case ID_P:
    158             case ID_SC:
    159             case ID_GMRV:
    160             case ID_SO:
    161                 return mpl;
    162             case ID_L:
    163                 return light;
    164             case ID_PX:
    165                 return proximity;
    166         }
    167         return -EINVAL;
    168     }
    169 };
    170 
    171 /******************************************************************************/
    172 
    173 sensors_poll_context_t::sensors_poll_context_t() {
    174     /* TODO: Handle external pressure sensor */
    175     mCompassSensor = new CompassSensor();
    176     MPLSensor *mplSensor = new MPLSensor(mCompassSensor);
    177     mInitialized = false;
    178     // Must clean this up early or else the destructor will make a mess.
    179     memset(mSensor, 0, sizeof(mSensor));
    180 
    181     // setup the callback object for handing mpl callbacks
    182     setCallbackObject(mplSensor);
    183 
    184     // populate the sensor list
    185     sensors = LOCAL_SENSORS +
    186        mplSensor->populateSensorList(sSensorList + LOCAL_SENSORS,
    187                sizeof(sSensorList[0]) * (ARRAY_SIZE(sSensorList) - LOCAL_SENSORS));
    188 
    189     mSensor[mpl] = mplSensor;
    190     mPollFds[mpl].fd = mSensor[mpl]->getFd();
    191     mPollFds[mpl].events = POLLIN;
    192     mPollFds[mpl].revents = 0;
    193 
    194     mSensor[compass] = mplSensor;
    195     mPollFds[compass].fd = mCompassSensor->getFd();
    196     mPollFds[compass].events = POLLIN;
    197     mPollFds[compass].revents = 0;
    198 
    199     mSensor[dmpOrient] = mplSensor;
    200     mPollFds[dmpOrient].fd = ((MPLSensor*) mSensor[dmpOrient])->getDmpOrientFd();
    201     mPollFds[dmpOrient].events = POLLPRI;
    202     mPollFds[dmpOrient].revents = 0;
    203 
    204     mSensor[dmpSign] = mplSensor;
    205     mPollFds[dmpSign].fd = ((MPLSensor*) mSensor[dmpSign])->getDmpSignificantMotionFd();
    206     mPollFds[dmpSign].events = POLLPRI;
    207     mPollFds[dmpSign].revents = 0;
    208 
    209     mSensor[dmpPed] = mplSensor;
    210     mPollFds[dmpPed].fd = ((MPLSensor*) mSensor[dmpPed])->getDmpPedometerFd();
    211     mPollFds[dmpPed].events = POLLPRI;
    212     mPollFds[dmpPed].revents = 0;
    213 
    214     mSensor[light] = new LightSensor();
    215     mPollFds[light].fd = mSensor[light]->getFd();
    216     mPollFds[light].events = POLLIN;
    217     mPollFds[light].revents = 0;
    218 
    219     mSensor[proximity] = new ProximitySensor();
    220     mPollFds[proximity].fd = mSensor[proximity]->getFd();
    221     mPollFds[proximity].events = POLLIN;
    222     mPollFds[proximity].revents = 0;
    223 
    224     if (mPollFds[light].fd < 0 || mPollFds[proximity].fd < 0) {
    225         delete mCompassSensor;
    226         return;
    227     }
    228 
    229     /* Timer based sensor initialization */
    230     int wakeFds[2];
    231     int result = pipe(wakeFds);
    232     ALOGE_IF(result < 0, "error creating wake pipe (%s)", strerror(errno));
    233     fcntl(wakeFds[0], F_SETFL, O_NONBLOCK);
    234     fcntl(wakeFds[1], F_SETFL, O_NONBLOCK);
    235     mWritePipeFd = wakeFds[1];
    236 
    237     mPollFds[wake].fd = wakeFds[0];
    238     mPollFds[wake].events = POLLIN;
    239     mPollFds[wake].revents = 0;
    240     mInitialized = true;
    241 }
    242 
    243 sensors_poll_context_t::~sensors_poll_context_t() {
    244     for (int i=0 ; i<numSensorDrivers ; i++) {
    245         delete mSensor[i];
    246     }
    247     delete mCompassSensor;
    248     close(mPollFds[wake].fd);
    249     close(mWritePipeFd);
    250     mInitialized = false;
    251 }
    252 
    253 int sensors_poll_context_t::activate(int handle, int enabled) {
    254     if (!mInitialized) return -EINVAL;
    255     int index = handleToDriver(handle);
    256     if (index < 0) return index;
    257     int err =  mSensor[index]->enable(handle, enabled);
    258     if (!err) {
    259         const char wakeMessage(WAKE_MESSAGE);
    260         int result = write(mWritePipeFd, &wakeMessage, 1);
    261         ALOGE_IF(result < 0, "error sending wake message (%s)", strerror(errno));
    262     }
    263     return err;
    264 }
    265 
    266 int sensors_poll_context_t::setDelay(int handle, int64_t ns)
    267 {
    268     int index = handleToDriver(handle);
    269     if (index < 0) return index;
    270     return mSensor[index]->setDelay(handle, ns);
    271 }
    272 
    273 int sensors_poll_context_t::pollEvents(sensors_event_t *data, int count)
    274 {
    275     int nbEvents = 0;
    276     int n = 0;
    277     int nb, polltime = -1;
    278 
    279     do {
    280         for (int i = 0; count && i < numSensorDrivers; i++) {
    281             SensorBase* const sensor(mSensor[i]);
    282             if (mPollFds[i].revents & (POLLIN | POLLPRI)) {
    283                 nb = 0;
    284                 if (i == mpl) {
    285                     ((MPLSensor*) sensor)->buildMpuEvent();
    286                     mPollFds[i].revents = 0;
    287                     nb = ((MPLSensor*) sensor)->readEvents(data, count);
    288                     if (nb > 0) {
    289                         count -= nb;
    290                         nbEvents += nb;
    291                         data += nb;
    292                     }
    293                 } else if (i == compass) {
    294                     ((MPLSensor*) sensor)->buildCompassEvent();
    295                     mPollFds[i].revents = 0;
    296                     nb = ((MPLSensor*) sensor)->readEvents(data, count);
    297                     if (nb > 0) {
    298                         count -= nb;
    299                         nbEvents += nb;
    300                         data += nb;
    301                     }
    302                 } else if (i == dmpOrient) {
    303                     nb = ((MPLSensor*) sensor)->readDmpOrientEvents(data, count);
    304                     mPollFds[dmpOrient].revents= 0;
    305                     if (isDmpScreenAutoRotationEnabled() && nb > 0) {
    306                         count -= nb;
    307                         nbEvents += nb;
    308                         data += nb;
    309                     }
    310                 } else if (i == dmpSign) {
    311                     ALOGI("HAL: dmpSign interrupt");
    312                     nb = ((MPLSensor*) sensor)->readDmpSignificantMotionEvents(data, count);
    313                     mPollFds[i].revents = 0;
    314                     count -= nb;
    315                     nbEvents += nb;
    316                     data += nb;
    317                 } else if (i == dmpPed) {
    318                     ALOGI("HAL: dmpPed interrupt");
    319                     nb = ((MPLSensor*) sensor)->readDmpPedometerEvents(data, count, ID_P, SENSOR_TYPE_STEP_DETECTOR, 0);
    320                     mPollFds[i].revents = 0;
    321                     count -= nb;
    322                     nbEvents += nb;
    323                     data += nb;
    324                 } else {
    325                     // LightSensor and ProximitySensor
    326                     nb = sensor->readEvents(data, count);
    327                     if (nb < count) {
    328                         // no more data for this sensor
    329                         mPollFds[i].revents = 0;
    330                     }
    331                     count -= nb;
    332                     nbEvents += nb;
    333                     data += nb;
    334                 }
    335                 ALOGI_IF(0, "sensors_mpl:readEvents() - nb=%d, count=%d, nbEvents=%d, data->timestamp=%lld, data->data[0]=%f,",
    336                         nb, count, nbEvents, data->timestamp, data->data[0]);
    337             }
    338         }
    339 
    340         /* to see if any step counter events */
    341         if (((MPLSensor*) mSensor[mpl])->hasStepCountPendingEvents() == true) {
    342             nb = 0;
    343             nb = ((MPLSensor*) mSensor[mpl])->readDmpPedometerEvents(data, count, ID_SC, SENSOR_TYPE_STEP_COUNTER, 0);
    344             ALOGI_IF(0, "sensors_mpl:readStepCount() - nb=%d, count=%d, nbEvents=%d, data->timestamp=%lld, data->data[0]=%f,",
    345                     nb, count, nbEvents, data->timestamp, data->data[0]);
    346             if (nb > 0) {
    347                 count -= nb;
    348                 nbEvents += nb;
    349                 data += nb;
    350             }
    351         }
    352         if (count) {
    353             do {
    354                 n = poll(mPollFds, numFds, nbEvents ? 0 : polltime);
    355             } while (n < 0 && errno == EINTR);
    356             if (n < 0) {
    357                 ALOGE("poll() failed (%s)", strerror(errno));
    358                 return -errno;
    359             }
    360             if (mPollFds[wake].revents & (POLLIN | POLLPRI)) {
    361                 char msg;
    362                 int result = read(mPollFds[wake].fd, &msg, 1);
    363                 ALOGE_IF(result < 0, "error reading from wake pipe (%s)", strerror(errno));
    364                 ALOGE_IF(msg != WAKE_MESSAGE, "unknown message on wake queue (0x%02x)", int(msg));
    365                 mPollFds[wake].revents = 0;
    366             }
    367         }
    368     } while (n && count);
    369 
    370     return nbEvents;
    371 }
    372 
    373 int sensors_poll_context_t::batch(int handle, int flags, int64_t period_ns, int64_t timeout)
    374 {
    375     int index = handleToDriver(handle);
    376     if (index < 0) return index;
    377     return mSensor[index]->batch(handle, flags, period_ns, timeout);
    378 }
    379 
    380 int sensors_poll_context_t::flush(int handle)
    381 {
    382     int index = handleToDriver(handle);
    383     if (index < 0) return index;
    384     return mSensor[index]->flush(handle);
    385 }
    386 /******************************************************************************/
    387 
    388 static int poll__close(struct hw_device_t *dev)
    389 {
    390     sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;
    391     if (ctx) {
    392         delete ctx;
    393     }
    394     return 0;
    395 }
    396 
    397 static int poll__activate(struct sensors_poll_device_t *dev,
    398                           int handle, int enabled)
    399 {
    400     sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;
    401     return ctx->activate(handle, enabled);
    402 }
    403 
    404 static int poll__setDelay(struct sensors_poll_device_t *dev,
    405                           int handle, int64_t ns)
    406 {
    407     sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;
    408     int s= ctx->setDelay(handle, ns);
    409     return s;
    410 }
    411 
    412 static int poll__poll(struct sensors_poll_device_t *dev,
    413                       sensors_event_t* data, int count)
    414 {
    415     sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;
    416     return ctx->pollEvents(data, count);
    417 }
    418 
    419 static int poll__batch(struct sensors_poll_device_1 *dev,
    420                       int handle, int flags, int64_t period_ns, int64_t timeout)
    421 {
    422     sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;
    423     return ctx->batch(handle, flags, period_ns, timeout);
    424 }
    425 
    426 static int poll__flush(struct sensors_poll_device_1 *dev,
    427                       int handle)
    428 {
    429     sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;
    430     return ctx->flush(handle);
    431 }
    432 /******************************************************************************/
    433 
    434 /** Open a new instance of a sensor device using name */
    435 static int open_sensors(const struct hw_module_t* module, const char* id,
    436                         struct hw_device_t** device)
    437 {
    438     int status = -EINVAL;
    439     sensors_poll_context_t *dev = new sensors_poll_context_t();
    440 
    441     if (!dev->isValid()) {
    442         ALOGE("Failed to open the sensors");
    443         return status;
    444     }
    445 
    446     memset(&dev->device, 0, sizeof(sensors_poll_device_1));
    447 
    448     dev->device.common.tag = HARDWARE_DEVICE_TAG;
    449     dev->device.common.version  = SENSORS_DEVICE_API_VERSION_1_0;
    450     dev->device.common.module   = const_cast<hw_module_t*>(module);
    451     dev->device.common.close    = poll__close;
    452     dev->device.activate        = poll__activate;
    453     dev->device.setDelay        = poll__setDelay;
    454     dev->device.poll            = poll__poll;
    455 
    456     /* Batch processing */
    457     dev->device.batch           = poll__batch;
    458     dev->device.flush           = poll__flush;
    459 
    460     *device = &dev->device.common;
    461     status = 0;
    462 
    463     return status;
    464 }
    465