RK3566添加湿度传感器以及浅析hal层

RK3566添加一款温湿度传感器gxht3x.挂在i2c总线下。驱动部分就不多做解析。大致流程硬件接好i2c线以及vcc gnd。后看数据手册。初始化寄存器，然后要读数据的话读那个寄存器，读出来的数据要做一个转化,然后实现open read write ioctl函数就行了。本文主要讲解hal层 。直接贴驱动代码。

/* drivers/input/sensors/temperature/tmp_ms5607.c
 *
 * Copyright (C) 2012-2015 ROCKCHIP.
 * Author: luowei <lw@rock-chips.com>
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/of_gpio.h>
#include <linux/i2c.h>
#include <asm/io.h>
#include <asm/uaccess.h>

#include <linux/miscdevice.h>
#include <linux/gpio.h>
#include <linux/uaccess.h>
#include <asm/atomic.h>
#include <linux/delay.h>
#include <linux/freezer.h>
#ifdef CONFIG_HAS_EARLYSUSPEND
#include <linux/earlysuspend.h>
#endif
#include <linux/sensor-dev.h>


static int sensor_active(struct i2c_client *client, int enable, int rate)
{
	int result = 0;
	return result;
}



static int sensor_init(struct i2c_client *client)
{
	int result = 0;
	return result;
}


static int sensor_i2c_write(struct i2c_client *client,
			    unsigned int len, unsigned char const *data)
{
	struct i2c_msg msgs[1];
	int res;

	msgs[0].addr = 0x44;
	msgs[0].flags = 0;	/* write */
	msgs[0].buf = (unsigned char *)data;
	msgs[0].len = len;

	res = i2c_transfer(client->adapter, msgs, 1);
	printk("wzf---i2c_transfer count = %d\n", res);
	return res;

}

static int senosr_i2c_read(struct i2c_client *client,
			   unsigned int len, unsigned char *data)
{
	struct i2c_msg msgs[1];
	int res;
	printk("wzf:-----addr = %x-----\n",(int)client->addr);
	msgs[0].addr = 0x44;
	msgs[0].flags = I2C_M_RD;
	msgs[0].buf = data;
	msgs[0].len = len;

	res = i2c_transfer(client->adapter, msgs, 1);
	printk("wzf---i2c_transfer count = %d\n", res);
	return res;

}

static int humidity_report_value(struct input_dev *input, int data)
{
	//get temperature, high and temperature from register data
	printk("ms5607-----hum report data= %d\n",data);
	input_report_abs(input, ABS_VOLUME, data);
	input_sync(input);
	msleep(100);
	return 0;
}

static int sensor_report_value(struct i2c_client *client)
{
	
    int ret = 0;
	unsigned int tem = 0,hum = 0;
	int Temperature=0,Humidity=0;

	char recvbuffer[6];
	char sendbuffer[2] = {0x2C,0x10};
	struct sensor_private_data *sensor =
	    (struct sensor_private_data *) i2c_get_clientdata(client);
	printk("wzf:--------%s---------\n",__func__);

	memset(recvbuffer, 0, 6);
	ret = sensor_i2c_write(client, 2, sendbuffer);
	if (!ret){
		printk("sensor_i2c_read failed!\n");
		//return -1;
	}
	msleep(2);
	ret = senosr_i2c_read(client, 6, recvbuffer);
	if (!ret){
		printk("sensor_i2c_read failed!\n");
		//return -1;
	}
	printk("read recvbuffer= %s-----\n",recvbuffer);
	tem = ((recvbuffer[0]<<8) | recvbuffer[1]);//温度拼接
	hum = ((recvbuffer[3]<<8) | recvbuffer[4]);//湿度拼接
	printk("wzf:ms5607 hum =%d\n",hum);
	printk("wzf:ms5607 temp =%d\n",tem);
	/*转换实际温度*/
	Temperature= (175* tem/65535-45) ;// T = -45 + 175 * tem / (2^16-1)
	//Temperature =(315*tem/65535-49);
	Humidity= (100* hum/65535);// RH = hum*100 / (2^16-1)
	printk("---Temp : %d  Hum: %d ----\n",Temperature,Humidity);
	//Humidity=950;
	if(!Humidity)
		return 0;
	ret = humidity_report_value(sensor->input_dev, Humidity);
	return 0;
}


struct sensor_operate humidity_gxht3x_ops = {
	.name				= "hum_gxht3x",
	.type				= SENSOR_TYPE_HUMIDITY,	//sensor type and it should be correct
	.id_i2c				= HUMIDITY_ID_GXHT3X,	//i2c id number
	.read_reg			= SENSOR_UNKNOW_DATA,	//read data
	.read_len			= 2,			//data length
	.id_reg				= SENSOR_UNKNOW_DATA,	//read device id from this register
	.id_data 			= SENSOR_UNKNOW_DATA,	//device id
	.precision			= 16,		//8 bits
	.ctrl_reg 			= SENSOR_UNKNOW_DATA,	//enable or disable
	.int_status_reg 		= SENSOR_UNKNOW_DATA,	//intterupt status register
	.range				= {0,65535},		//range
	.trig				= IRQF_TRIGGER_LOW | IRQF_ONESHOT | IRQF_SHARED,
	.active				= sensor_active,
	.init				= sensor_init,
	.report				= sensor_report_value,
};

/****************operate according to sensor chip:end************/
static int humidity_gxht3x_probe(struct i2c_client *client, const struct i2c_device_id *devid)
{
	printk("wzf:----%s----\n",__func__);
	return sensor_register_device(client, NULL, devid, &humidity_gxht3x_ops);
}

static int humidity_gxht3x_remove(struct i2c_client *client)
{
	return sensor_unregister_device(client, NULL, &humidity_gxht3x_ops);
}

static const struct i2c_device_id humidity_gxht3x_id[] = {
	{"hum_gxht3x", HUMIDITY_ID_GXHT3X},
	{}
};

static struct i2c_driver humidity_ms5607_driver = {
	.probe = humidity_gxht3x_probe,
	.remove = humidity_gxht3x_remove,
	.shutdown = sensor_shutdown,
	.id_table = humidity_gxht3x_id,
	.driver = {
		.name = "humidity_gxht3x",
	#ifdef CONFIG_PM
		.pm = &sensor_pm_ops,
	#endif
	},
};

module_i2c_driver(humidity_ms5607_driver);

MODULE_AUTHOR("luowei <lw@rock-chips.com>");
MODULE_DESCRIPTION("ms5607 temperature driver");
MODULE_LICENSE("GPL");

接下来对hal层进行浅析hal对于驱动来说还是要会的。我也不会，在网上找资料找出来的如有错误希望各位大佬能指出。


以上资料来自博主~未来可期点击看大佬的文章
总结一下：
对于我们的湿度传感器来说：（kernel 层驱动通过i2c读取寄存器拿到湿度数据） —fileoperation---->（hardware层通过open节点，以及ioctl获取到数据，填充这些结构体.hw_device_t 填充模块ID 名称 描述 版本等信息。hw_moule_ts实现功能函数。等jni层获取到该结构体指针的时候可以调用这些功能函数）------jni-------->（framewark层注册java native interface.java本地接口，以便上层调用）------->apk.
那我们看hal层代码就先从这三个结构体入手。

hardware\libhardware\include\hardware\hardware.h
struct hw_module_t;
struct hw_module_methods_t;
struct hw_device_t;

/**
 * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
 * and the fields of this data structure must begin with hw_module_t
 * followed by module specific information.
 */
typedef struct hw_module_t {
    /** tag must be initialized to HARDWARE_MODULE_TAG */
    uint32_t tag;

    /**
     * The API version of the implemented module. The module owner is
     * responsible for updating the version when a module interface has
     * changed.
     *
     * The derived modules such as gralloc and audio own and manage this field.
     * The module user must interpret the version field to decide whether or
     * not to inter-operate with the supplied module implementation.
     * For example, SurfaceFlinger is responsible for making sure that
     * it knows how to manage different versions of the gralloc-module API,
     * and AudioFlinger must know how to do the same for audio-module API.
     *
     * The module API version should include a major and a minor component.
     * For example, version 1.0 could be represented as 0x0100. This format
     * implies that versions 0x0100-0x01ff are all API-compatible.
     *
     * In the future, libhardware will expose a hw_get_module_version()
     * (or equivalent) function that will take minimum/maximum supported
     * versions as arguments and would be able to reject modules with
     * versions outside of the supplied range.
     */
    uint16_t module_api_version;
#define version_major module_api_version
    /**
     * version_major/version_minor defines are supplied here for temporary
     * source code compatibility. They will be removed in the next version.
     * ALL clients must convert to the new version format.
     */

    /**
     * The API version of the HAL module interface. This is meant to
     * version the hw_module_t, hw_module_methods_t, and hw_device_t
     * structures and definitions.
     *
     * The HAL interface owns this field. Module users/implementations
     * must NOT rely on this value for version information.
     *
     * Presently, 0 is the only valid value.
     */
    uint16_t hal_api_version;
#define version_minor hal_api_version

    /** Identifier of module */
    const char *id;

    /** Name of this module */
    const char *name;

    /** Author/owner/implementor of the module */
    const char *author;

    /** Modules methods */
    struct hw_module_methods_t* methods;

    /** module's dso */
    void* dso;

#ifdef __LP64__
    uint64_t reserved[32-7];
#else
    /** padding to 128 bytes, reserved for future use */
    uint32_t reserved[32-7];
#endif

} hw_module_t;

typedef struct hw_module_methods_t {
    /** Open a specific device */
    int (*open)(const struct hw_module_t* module, const char* id,
            struct hw_device_t** device);

} hw_module_methods_t;

/**
 * Every device data structure must begin with hw_device_t
 * followed by module specific public methods and attributes.
 */
typedef struct hw_device_t {
    /** tag must be initialized to HARDWARE_DEVICE_TAG */
    uint32_t tag;

    /**
     * Version of the module-specific device API. This value is used by
     * the derived-module user to manage different device implementations.
     *
     * The module user is responsible for checking the module_api_version
     * and device version fields to ensure that the user is capable of
     * communicating with the specific module implementation.
     *
     * One module can support multiple devices with different versions. This
     * can be useful when a device interface changes in an incompatible way
     * but it is still necessary to support older implementations at the same
     * time. One such example is the Camera 2.0 API.
     *
     * This field is interpreted by the module user and is ignored by the
     * HAL interface itself.
     */
    uint32_t version;

    /** reference to the module this device belongs to */
    struct hw_module_t* module;

    /** padding reserved for future use */
#ifdef __LP64__
    uint64_t reserved[12];
#else
    uint32_t reserved[12];
#endif

    /** Close this device */
    int (*close)(struct hw_device_t* device);

} hw_device_t;

然后我们在看sensor中定义的结构体

\hardware\libhardware\include\hardware\sensors.h
/**
 * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
 * and the fields of this data structure must begin with hw_module_t
 * followed by module specific information.
 */
struct sensors_module_t {
    struct hw_module_t common;

    /**
     * Enumerate all available sensors. The list is returned in "list".
     * return number of sensors in the list
     */
    int (*get_sensors_list)(struct sensors_module_t* module,
            struct sensor_t const** list);

    /**
     *  Place the module in a specific mode. The following modes are defined
     *
     *  0 - Normal operation. Default state of the module.
     *  1 - Loopback mode. Data is injected for the supported
     *      sensors by the sensor service in this mode.
     * return 0 on success
     *         -EINVAL if requested mode is not supported
     *         -EPERM if operation is not allowed
     */
    int (*set_operation_mode)(unsigned int mode);
};

/*
 * sensors_poll_device_t is used with SENSORS_DEVICE_API_VERSION_0_1
 * and is present for backward binary and source compatibility.
 * See the Sensors HAL interface section for complete descriptions of the
 * following functions:
 * http://source.android.com/devices/sensors/index.html#hal
 */
struct sensors_poll_device_t {
    struct hw_device_t common;
    int (*activate)(struct sensors_poll_device_t *dev,
            int sensor_handle, int enabled);
    int (*setDelay)(struct sensors_poll_device_t *dev,
            int sensor_handle, int64_t sampling_period_ns);
    int (*poll)(struct sensors_poll_device_t *dev,
            sensors_event_t* data, int count);
};

这里主要定义了俩个结构体 :struct sensors_module_t , 里面包含了 hw_module_t ; 那hw_module_t我们之前说是填充模块信息的包括ID 名称等等。但是它里面还包含了俩个函数 get_sensors_list 这个函数将返回所有可以的传感器列表。set_operation_mode：将模块设置特定模式：0 正常模式 1回环模式。第二个结构体：struct sensors_poll_device_t ，里面包含了struct hw_device_t；struct hw_device_t里面是特定的实现函数，但是我们还要增加我们自己的功能函数activate ，setDelay ，poll。
ok，我查看在libhardware下的头文件定义。接下来看具体的实现。

hardware\rockchip\sensor\st\sensors.c
/*  sensors_module_t 填充hw_module_t的 模块描述 */
 struct sensors_module_t HAL_MODULE_INFO_SYM = {
    .common = {
        .tag = HARDWARE_MODULE_TAG,
        .version_major = 1,
        .version_minor = 0,
        .id = SENSORS_HARDWARE_MODULE_ID,
        .name = "Rockchip Sensors Module",
        .author = "The RKdroid Project",
        .methods = &sensors_module_methods,
    },
    .get_sensors_list = sensors__get_sensors_list
};
/* hw_module_methods_t 实现open函数  */
static struct hw_module_methods_t sensors_module_methods = {
    .open = open_sensors
};
/* 实现sensor.h中 sensors_module_t结构体中 get_sensors_list函数  */
static int sensors__get_sensors_list(struct sensors_module_t* module,
        struct sensor_t const** list)
{
    *list = sSensorList;
    return ARRAY_SIZE(sSensorList);
}

那么sensors_poll_device_t的几个函数的实现都没有写？？？这个要看具体设备再具体实现。
直接看湿度传感器hal层结构体定义。

hardware\rockchip\sensor\st\HumiditySensor.h
class HumiditySensor : public SensorBase {
    int mEnabled;
    InputEventCircularReader mInputReader;
    sensors_event_t mPendingEvent;  
    bool mHasPendingEvent;

    
    int setInitialState();

public:
            HumiditySensor();
    virtual ~HumiditySensor();

    virtual int setDelay(int32_t handle, int64_t ns);
    virtual int enable(int32_t handle, int enabled);
    virtual int readEvents(sensors_event_t* data, int count);   
    virtual bool hasPendingEvents() const;
    virtual int isActivated(int handle);
    void processEvent(int code, int value);
};

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

#define HUMIDITY_IOCTL_MAGIC			'h'
#define HUMIDITY_IOCTL_GET_ENABLED	_IOR(HUMIDITY_IOCTL_MAGIC, 1, int *)
#define HUMIDITY_IOCTL_ENABLE			_IOW(HUMIDITY_IOCTL_MAGIC, 2, int *)
#define HUMIDITY_IOCTL_DISABLE		_IOW(HUMIDITY_IOCTL_MAGIC, 3, int *)
#define HUMIDITY_IOCTL_SET_DELAY		_IOW(HUMIDITY_IOCTL_MAGIC, 4, int *)

class HumiditySensor : public SensorBase ； 可以看出class HumiditySensor 继承了SensorBase，那我们看一下class SensorBase

struct sensors_event_t;

class SensorBase {
protected:
    const char* dev_name;
    const char* data_name;
    int         dev_fd;
    int         data_fd;

    static int openInput(const char* inputName);
    static int64_t getTimestamp();
    static int64_t timevalToNano(timeval const& t) {
        return t.tv_sec*1000000000LL + t.tv_usec*1000;
    }

    int open_device();
    int close_device();

public:
            SensorBase(
                    const char* dev_name,
                    const char* data_name);

    virtual ~SensorBase();

    virtual int readEvents(sensors_event_t* data, int count) = 0;
    virtual bool hasPendingEvents() const;
    virtual int getFd() const;
    virtual int setDelay(int32_t handle, int64_t ns);
    virtual int enable(int32_t handle, int enabled) = 0;
    virtual int isActivated(int handle);
};

这里的setdelay isActivated readEvents不就是sensors_poll_device_t里面的功能实现函数。同时在HumiditySensor类里面也实现了这几个函数。查看class HumiditySensor里面成员的实现。

/*
 * Copyright (C) 2010 Motorola, Inc.
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <fcntl.h>
#include <errno.h>
#include <math.h>
#include <poll.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/select.h>

#include "HumiditySensor.h"

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

HumiditySensor::HumiditySensor()
    : SensorBase(HUM_DEVICE_NAME, "humidity"),
      mEnabled(0),
      mInputReader(32),
      mHasPendingEvent(false)
{
	LOGD("new class humidity");
    mPendingEvent.version = sizeof(sensors_event_t);
    mPendingEvent.sensor = ID_HUM;
    mPendingEvent.type = SENSOR_TYPE_RELATIVE_HUMIDITY;
    memset(mPendingEvent.data, 0, sizeof(mPendingEvent.data));

     open_device();

    int flags = 0;
    if ((dev_fd > 0) && (!ioctl(dev_fd, HUMIDITY_IOCTL_GET_ENABLED, &flags))) {
        if (flags) {
            mEnabled = 1;
            setInitialState();
        }
    }
}

HumiditySensor::~HumiditySensor() {
	LOGD("delete class humidity");
    if (dev_fd > 0) {
        close(dev_fd);
        dev_fd = -1;
    }
}

int HumiditySensor::setInitialState() {
    struct input_absinfo absinfo;
    if ((data_fd > 0) && !ioctl(data_fd, EVIOCGABS(EVENT_TYPE_HUMIDITY), &absinfo)) {
        mHasPendingEvent = true;
        mPendingEvent.relative_humidity = CONVERT_B * absinfo.value;
    }
    return 0;
}

int HumiditySensor::enable(int32_t, int en) {
    int flags = en ? 1 : 0;
    int err = 0;
    if (flags != mEnabled) {
        if (dev_fd < 0) {
            open_device();
        }
        err = ioctl(dev_fd, HUMIDITY_IOCTL_ENABLE, &flags);
        err = err<0 ? -errno : 0;
        LOGE_IF(err, "HUMIDITY_IOCTL_ENABLE failed (%s)", strerror(-err));
        if (!err) {
            mEnabled = en ? 1 : 0;
            if (en) {
                setInitialState();
            }
        }
    }
    return err;
}

bool HumiditySensor::hasPendingEvents() const {
    return mHasPendingEvent;
}


int HumiditySensor::setDelay(int32_t handle, int64_t ns)
{
    if (ns < 0)
        return -EINVAL;
	
    if (dev_fd < 0) {
        open_device();
    }

    int delay = ns / 1000000;
    if (ioctl(dev_fd, HUMIDITY_IOCTL_SET_DELAY, &delay)) {
        return -errno;
    }
    return 0;
}

int HumiditySensor::isActivated(int /* handle */)
{
    return mEnabled;
}

int HumiditySensor::readEvents(sensors_event_t* data, int count)
{
    if (count < 1)
        return -EINVAL;

    if (mHasPendingEvent) {
        mHasPendingEvent = false;
        mPendingEvent.timestamp = getTimestamp();
        *data = mPendingEvent;
        return mEnabled ? 1 : 0;
    }

    ssize_t n = mInputReader.fill(data_fd);
    if (n < 0)
        return n;
    int numEventReceived = 0;
    input_event const* event;

    while (count && mInputReader.readEvent(&event)) {
        int type = event->type;
        if (type == EV_ABS) {
            processEvent(event->code, event->value);
        } else if (type == EV_SYN) {
            int64_t time = timevalToNano(event->time);
            mPendingEvent.timestamp = time;
            if (mEnabled) {
                *data++ = mPendingEvent;
                count--;
                numEventReceived++;
            }
        } else {
            ALOGE("HumiditySensor: unknown event (type=%d, code=%d)",
                    type, event->code);
        }
        mInputReader.next();
    }

    return numEventReceived;
}

void HumiditySensor::processEvent(int code, int value)
{
    if (code == EVENT_TYPE_HUMIDITY) {
            //mPendingEvent.relative_humidity = value * CONVERT_B ;
			mPendingEvent.relative_humidity = value;
			LOGD("HUM---%s:value=%d\n",__FUNCTION__, value);
			LOGD("HUM---%s:value * CONVERT_B = %f\n",__FUNCTION__, mPendingEvent.relative_humidity);
    }
}

里面的核心函数就是open 然后ioctl发送不同的魔数去获取到数据。那么我们的hal层拿到数据只是完成了启下作用，即从内核驱动中获取数据。那么我们还要把数据给到JNI。由于hal层和farmware层都是运行在用户空间，jni也是由C/C++编写。并且hal层是以.so的动态库文件的形式存在。那么我们只要在jni包含该库文件就可以。调用到我们的功能函数。