高通HAL层之bmp18x.cpp

继续上一个链接内容所讲：http://www.cnblogs.com/linhaostudy/p/8430583.html

下面bmp18x sensor为例进行分析。

BMP18x Sensor：

我们以打开bmp180为例，代码为hardware\qcom\sensors\Bmp180.cpp：

 PressureSensor::PressureSensor(char *name)
     : SensorBase(NULL, "bmp18x"),
       mInputReader(),
       mHasPendingEvent(false),
       mEnabledTime()
 {
     mPendingEvent.version = sizeof(sensors_event_t);
     mPendingEvent.sensor = SENSORS_PRESSURE_HANDLE;
     mPendingEvent.type = SENSOR_TYPE_PRESSURE;
     memset(mPendingEvent.data, , sizeof(mPendingEvent.data));

     if (data_fd) {
         strlcpy(input_sysfs_path, SYSFS_CLASS, sizeof(input_sysfs_path));
         strlcat(input_sysfs_path, name, sizeof(input_sysfs_path));
         strlcat(input_sysfs_path, "/", sizeof(input_sysfs_path));
         input_sysfs_path_len = strlen(input_sysfs_path);
         ALOGI("The pressure sensor path is %s",input_sysfs_path);
         enable(, );
     }
 }

 PressureSensor::PressureSensor(char *name)
     : SensorBase(NULL, "bmp18x"),
       mInputReader(),
       mHasPendingEvent(false),
       mEnabledTime()
 {
     mPendingEvent.version = sizeof(sensors_event_t);
     mPendingEvent.sensor = SENSORS_PRESSURE_HANDLE;
     mPendingEvent.type = SENSOR_TYPE_PRESSURE;
     memset(mPendingEvent.data, , sizeof(mPendingEvent.data));

     if (data_fd) {
         strlcpy(input_sysfs_path, SYSFS_CLASS, sizeof(input_sysfs_path));
         strlcat(input_sysfs_path, name, sizeof(input_sysfs_path));
         strlcat(input_sysfs_path, "/", sizeof(input_sysfs_path));
         input_sysfs_path_len = strlen(input_sysfs_path);
         ALOGI("The pressure sensor path is %s",input_sysfs_path);
         enable(, );
     }
 }

mPendingEvent是一个sensors_event_t结构体，首先对sensor、type等赋值，然后调用enable打开；

 /**
  *  @brief        This function will enable/disable sensor.
  *  @param[in]    handle
  *                  which sensor to enable/disable.
  *  @param[in]    en
  *                  en=1, enable;
  *                  en=0, disable
  *  @return       if the operation is successful.
  */
 int PressureSensor::enable(int32_t handle, int en)
 {
     VFUNC_LOG;

     int res = ;

     LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %d > %s (%lld)",
             en, pressureSysFs.pressure_enable, getTimestamp());
     res = write_sysfs_int(pressureSysFs.pressure_enable, en);

     return res;
 }

其实就是对SYSFS_CLASS路径下的文件的enable节点写值“1”；

SYSFS_CLASS的路径为（hardware\qcom\sensors\sensors.h）：

1 #define SYSFS_CLASS        "/sys/class/sensors/"

注意，不要忽略了SensorBase(NULL, "bmp18x")，我们看一下它做了什么？

 /*****************************************************************************/

 SensorBase::SensorBase(
         const char* dev_name,
         const char* data_name,
         const struct SensorContext* context /* = NULL */)
         : dev_name(dev_name), data_name(data_name), algo(NULL),
         dev_fd(-), data_fd(-), mEnabled(), mHasPendingMetadata()
 {
         if (context != NULL) {
                 CalibrationManager& cm(CalibrationManager::getInstance());
                 algo = cm.getCalAlgo(context->sensor);

                 /* Set up the sensors_meta_data_event_t event*/
                 meta_data.version = META_DATA_VERSION;
                 meta_data.sensor = context->sensor->handle;
                 meta_data.type = SENSOR_TYPE_META_DATA;
                 meta_data.reserved0 = ;
                 meta_data.timestamp = 0LL;
                 meta_data.meta_data.what = META_DATA_FLUSH_COMPLETE;
                 meta_data.meta_data.sensor = context->sensor->handle;
         }

         if (data_name) {
                 data_fd = openInput(data_name);
         }
 }

这里的dev_name为NULL，data_name为bmp18x，设置dev_name和data_name后调用openInput打开设备：

 int SensorBase::openInput(const char* inputName) {
     int fd = -;
     const char *dirname = "/dev/input";
     char devname[PATH_MAX];
     char *filename;
     DIR *dir;
     struct dirent *de;
     dir = opendir(dirname);
     if(dir == NULL)
         return -;
     strlcpy(devname, dirname, PATH_MAX);
     filename = devname + strlen(dirname);
     *filename++ = '/';
     while((de = readdir(dir))) {
         if(de->d_name[] == '.' &&
                 (de->d_name[] == '\0' ||
                         (de->d_name[] == '.' && de->d_name[] == '\0')))
             continue;
         strlcpy(filename, de->d_name, PATH_MAX - strlen(SYSFS_CLASS));
         fd = open(devname, O_RDONLY);
         if (fd>=) {
             char name[];
             if (ioctl(fd, EVIOCGNAME(sizeof(name) - ), &name) < ) {
                 name[] = '\0';
             }
             if (!strcmp(name, inputName)) {
                 strlcpy(input_name, filename, PATH_MAX);
                 break;
             } else {
                 close(fd);
                 fd = -;
             }
         }
     }
     closedir(dir);
     ALOGE_IF(fd<, "couldn't find '%s' input device", inputName);
     return fd;
 }

再继续看一下getInput：

getInput

这个函数的作用就是打开"/dev/input"，查找其中的输入设备名字与传入参数匹配的那一个，这里是"bmp18x"，并返回相应的打开句柄。

到这里sensor就打开了；

Activate、setDelay都是直接调用相应的sensor接口直接调用相应sensor的接口，主要是readEvents：

 int PressureSensor::readEvents(sensors_event_t* data, int count)
 {
     if (count < )
         return -EINVAL;
 　　//这里两个判断都不会进来
     if (mHasPendingEvent) {
         mHasPendingEvent = false;
         mPendingEvent.timestamp = getTimestamp();
         *data = mPendingEvent;
         return mEnabled ?  : ;
     }

     if (mHasPendingMetadata) {
         mHasPendingMetadata--;
         meta_data.timestamp = getTimestamp();
         *data = meta_data;
         return mEnabled ?  : ;
     }

     ssize_t n = mInputReader.fill(data_fd);　　//从输入设备中读取数据  
21     if (n < 0)
         return n;

     int numEventReceived = ;
     input_event const* event;

 #if FETCH_FULL_EVENT_BEFORE_RETURN
 again:
 #endif
     while (count && mInputReader.readEvent(&event)) {//读取当前一个event，返回还有的数据大小  
         int type = event->type;
         if (type == EV_ABS) {//根据kernel上报的input事件来确定相应的数据值
             float value = event->value;
             mPendingEvent.pressure = value * CONVERT_PRESSURE;
         } else if (type == EV_SYN) {
             switch (event->code) {
                 case SYN_TIME_SEC:
                     mUseAbsTimeStamp = true;
                     report_time = event->value*1000000000LL;
                     break;
                 case SYN_TIME_NSEC:
                     mUseAbsTimeStamp = true;
                     mPendingEvent.timestamp = report_time+event->value;
                     break;
                 case SYN_REPORT:
                     if(mUseAbsTimeStamp != true) {
                         mPendingEvent.timestamp = timevalToNano(event->time);
                     }
                     if (mEnabled) {
                         if (mPendingEvent.timestamp >= mEnabledTime) {
                             *data++ = mPendingEvent;
                             numEventReceived++;
                         }
                         count--;
                     }
                     break;
             }
         } else {
             ALOGE("PressureSensor: unknown event (type=%d, code=%d)",
                     type, event->code);
         }
         mInputReader.next();
     }

 #if FETCH_FULL_EVENT_BEFORE_RETURN
     /* if we didn't read a complete event, see if we can fill and
        try again instead of returning with nothing and redoing poll. */
     if (numEventReceived ==  && mEnabled == ) {
         n = mInputReader.fill(data_fd);
         if (n)
             goto again;
     }
 #endif

     return numEventReceived;
 }

这里看一下mInputReader，是一个InputEventCircularReader结构，表示的是一个环形的读入数据缓冲区：

 ssize_t InputEventCircularReader::fill(int fd)
 {
     size_t numEventsRead = ;
     if (mFreeSpace) {
         const ssize_t nread = read(fd, mHead, mFreeSpace * sizeof(input_event));//读取数据
         if (nread< || nread % sizeof(input_event)) {
             // we got a partial event!!
             return nread< ? -errno : -EINVAL;
         }

         numEventsRead = nread / sizeof(input_event);
         // dumpEvents(mHead, numEventsRead);
         D("nread = %ld, numEventsRead = %d.", nread, numEventsRead);
         if (numEventsRead) {
             mHead += numEventsRead;
             mFreeSpace -= numEventsRead;
             if (mHead > mBufferEnd) {
                 size_t s = mHead - mBufferEnd;
                 memcpy(mBuffer, mBufferEnd, s * sizeof(input_event));
                 mHead = mBuffer + s;
             }
         }
     }

     return numEventsRead;
 }

mCurr表示未读事件的第一个，初始为缓冲区首部；

Fill函数是把调用read从相应的输入设备读入数据mHead位置；

readEvent函数返回mCurr和剩余的数据大小；

next函数让mCurr移一个input_event；