Sensor在Linux内核中的驱动分析
内核中对sensor的抽象：drivers/sensors/sensors_class.c
模块初始化函数：
模块初始化函数：
static int __init sensors_init(void)
{
sensors_class = class_create(THIS_MODULE, "sensors");
if (IS_ERR(sensors_class))
return PTR_ERR(sensors_class);
sensors_class->dev_attrs = sensors_class_attrs;
return 0;
}static struct device_attribute sensors_class_attrs[] = {
__ATTR(name, 0444, sensors_name_show, NULL),
__ATTR(vendor, 0444, sensors_vendor_show, NULL),
__ATTR(version, 0444, sensors_version_show, NULL),
__ATTR(handle, 0444, sensors_handle_show, NULL),
__ATTR(type, 0444, sensors_type_show, NULL),
__ATTR(max_range, 0444, sensors_max_range_show, NULL),
__ATTR(resolution, 0444, sensors_resolution_show, NULL),
__ATTR(sensor_power, 0444, sensors_power_show, NULL),
__ATTR(min_delay, 0444, sensors_min_delay_show, NULL),
__ATTR(fifo_reserved_event_count, 0444, sensors_fifo_event_show, NULL),
__ATTR(fifo_max_event_count, 0444, sensors_fifo_max_show, NULL),
__ATTR(max_delay, 0444, sensors_max_delay_show, NULL),
__ATTR(flags, 0444, sensors_flags_show, NULL),
__ATTR(enable, 0664, sensors_enable_show, sensors_enable_store),
__ATTR(enable_wakeup, 0664, sensors_enable_wakeup_show,
sensors_enable_wakeup_store),
__ATTR(poll_delay, 0664, sensors_delay_show, sensors_delay_store),
__ATTR(self_test, 0440, sensors_test_show, NULL),
__ATTR(max_latency, 0660, sensors_max_latency_show,
sensors_max_latency_store),
__ATTR(flush, 0660, sensors_flush_show, sensors_flush_store),
__ATTR(calibrate, 0664, sensors_calibrate_show,
sensors_calibrate_store),
__ATTR_NULL,
};memsic->cdev = sensors_cdev;
memsic->cdev.sensors_enable = mmc3524x_set_enable;
memsic->cdev.sensors_poll_delay = mmc3524x_set_poll_delay;
res = sensors_classdev_register(&memsic->idev->dev, &memsic->cdev);mmc3524的数据结构如下，里面有个struct sensors_classdev cdev;成员，上面的代码设置cdev的enable和poll_delay函数指针指向驱动程序的函数，供sensor的HAL层调用。
struct mmc3524x_data {
struct mutex ecompass_lock;
struct mutex ops_lock;
struct workqueue_struct *data_wq;
struct delayed_work dwork;
struct sensors_classdev cdev;
struct mmc3524x_vec last;
struct i2c_client *i2c;
struct input_dev *idev;
struct regulator *vdd;
struct regulator *vio;
struct regmap *regmap;
int dir;
int auto_report;
int enable;
int poll_interval;
int power_enabled;
unsigned long timeout;
int sensors_classdev_register(struct device *parent,
struct sensors_classdev *sensors_cdev)
{
sensors_cdev->dev = device_create(sensors_class, parent, 0,
sensors_cdev, "%s", sensors_cdev->name);
if (IS_ERR(sensors_cdev->dev))
return PTR_ERR(sensors_cdev->dev);
down_write(&sensors_list_lock);
list_add_tail(&sensors_cdev->node, &sensors_list);
up_write(&sensors_list_lock);
pr_debug("Registered sensors device: %s\n",
sensors_cdev->name);
return 0;
}struct device *device_create(struct class *class, struct device *parent,
dev_t devt, void *drvdata, const char *fmt, ...)
{
va_list vargs;
struct device *dev;
va_start(vargs, fmt);
dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
va_end(vargs);
return dev;
}struct device *device_create_vargs(struct class *class, struct device *parent,
dev_t devt, void *drvdata, const char *fmt,
va_list args)
{
struct device *dev = NULL;
int retval = -ENODEV;
if (class == NULL || IS_ERR(class))
goto error;
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev) {
retval = -ENOMEM;
goto error;
}
dev->devt = devt;
dev->class = class;
dev->parent = parent;
dev->release = device_create_release;
dev_set_drvdata(dev, drvdata);
retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
if (retval)
goto error;
retval = device_register(dev);
if (retval)
goto error;
return dev;
error:
put_device(dev);
return ERR_PTR(retval);
}dev_set_drvdataint dev_set_drvdata(struct device *dev, void *data)
{
int error;
if (!dev->p) {
error = device_private_init(dev);
if (error)
return error;
}
dev->p->driver_data = data;
return 0;
}static ssize_t sensors_enable_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev);
ssize_t ret = -EINVAL;
unsigned long data = 0;
ret = kstrtoul(buf, 10, &data);
if (ret)
return ret;
if (data > 1) {
dev_err(dev, "Invalid value of input, input=%ld\n", data);
return -EINVAL;
}
if (sensors_cdev->sensors_enable == NULL) {
dev_err(dev, "Invalid sensor class enable handle\n");
return -EINVAL;
}
ret = sensors_cdev->sensors_enable(sensors_cdev, data);
if (ret)
return ret;
sensors_cdev->enabled = data;
return size;
}
static ssize_t sensors_enable_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%u\n",
sensors_cdev->enabled);
}void *dev_get_drvdata(const struct device *dev)
{
if (dev && dev->p)
return dev->p->driver_data;
return NULL;
}int CompassSensor::enable(int32_t, int en) {
int flags = en ? 1 : 0;
compass_algo_args arg;
arg.common.enable = flags;
char propBuf[PROPERTY_VALUE_MAX];
property_get("sensors.compass.loopback", propBuf, "0");
if (strcmp(propBuf, "1") == 0) {
ALOGE("sensors.compass.loopback is set");
mEnabled = flags;
mEnabledTime = 0;
return 0;
}
if (flags != mEnabled) {
int fd;
if ((algo != NULL) && (algo->methods->config != NULL)) {
if (algo->methods->config(CMD_ENABLE, (sensor_algo_args*)&arg)) {
ALOGW("Calling enable config failed for compass");
}
}
strlcpy(&input_sysfs_path[input_sysfs_path_len],
SYSFS_ENABLE, SYSFS_MAXLEN);
fd = open(input_sysfs_path, O_RDWR);
if (fd >= 0) {
char buf[2];
int err;
buf[1] = 0;
if (flags) {
buf[0] = '1';
mEnabledTime = getTimestamp() + IGNORE_EVENT_TIME;
} else {
buf[0] = '0';
}
err = write(fd, buf, sizeof(buf));
close(fd);
mEnabled = flags;
return 0;
}
ALOGE("CompassSensor: failed to open %s", input_sysfs_path);
return -1;
}
return 0;
}static int mmc3524x_set_enable(struct sensors_classdev *sensors_cdev,
unsigned int enable)
{
int rc = 0;
struct mmc3524x_data *memsic = container_of(sensors_cdev,
struct mmc3524x_data, cdev);
mutex_lock(&memsic->ops_lock);
if (enable && (!memsic->enable)) {
rc = mmc3524x_power_set(memsic, true);
if (rc) {
dev_err(&memsic->i2c->dev, "Power up failed\n");
goto exit;
}
/* send TM cmd before read */
rc = regmap_write(memsic->regmap, MMC3524X_REG_CTRL,
MMC3524X_CTRL_TM);
if (rc) {
dev_err(&memsic->i2c->dev, "write reg %d failed.(%d)\n",
MMC3524X_REG_CTRL, rc);
goto exit;
}
memsic->timeout = jiffies;
if (memsic->auto_report)
queue_delayed_work(memsic->data_wq,
&memsic->dwork,
msecs_to_jiffies(memsic->poll_interval));
} else if ((!enable) && memsic->enable) {
if (memsic->auto_report)
cancel_delayed_work_sync(&memsic->dwork);
if (mmc3524x_power_set(memsic, false))
dev_warn(&memsic->i2c->dev, "Power off failed\n");
} else {
dev_warn(&memsic->i2c->dev,
"ignore enable state change from %d to %d\n",
memsic->enable, enable);
}
memsic->enable = enable;
exit:
mutex_unlock(&memsic->ops_lock);
return rc;
static void mmc3524x_poll(struct work_struct *work)
{
int ret;
s8 *tmp;
struct mmc3524x_vec vec;
struct mmc3524x_vec report;
struct mmc3524x_data *memsic = container_of((struct delayed_work *)work,
struct mmc3524x_data, dwork);
ktime_t timestamp;
vec.x = vec.y = vec.z = 0;
ret = mmc3524x_read_xyz(memsic, &vec);
if (ret) {
dev_warn(&memsic->i2c->dev, "read xyz failed\n");
goto exit;
}
tmp = &mmc3524x_rotation_matrix[memsic->dir][0];
report.x = tmp[0] * vec.x + tmp[1] * vec.y + tmp[2] * vec.z;
report.y = tmp[3] * vec.x + tmp[4] * vec.y + tmp[5] * vec.z;
report.z = tmp[6] * vec.x + tmp[7] * vec.y + tmp[8] * vec.z;
timestamp = ktime_get_boottime();
input_report_abs(memsic->idev, ABS_X, report.x);
input_report_abs(memsic->idev, ABS_Y, report.y);
input_report_abs(memsic->idev, ABS_Z, report.z);
input_event(memsic->idev,
EV_SYN, SYN_TIME_SEC,
ktime_to_timespec(timestamp).tv_sec);
input_event(memsic->idev,
EV_SYN, SYN_TIME_NSEC,
ktime_to_timespec(timestamp).tv_nsec);
input_sync(memsic->idev);
exit:
queue_delayed_work(memsic->data_wq,
&memsic->dwork,
msecs_to_jiffies(memsic->poll_interval));
}