Sensor在内核中的驱动框架【转】

本文转载自：http://blog.csdn.net/armfpga123/article/details/52840370

内核中对sensor的抽象：drivers/sensors/sensors_class.c
模块初始化函数：

1. static int __init sensors_init(void)
2. {
3. sensors_class = class_create(THIS_MODULE, "sensors");
4. if (IS_ERR(sensors_class))
5. return PTR_ERR(sensors_class);
6. sensors_class->dev_attrs = sensors_class_attrs;
7. return 0;
8. }

创建sensor的类class，通过sensors_class->dev_attrs = sensors_class_attrs;在sysfs文件系统下面创建设备节点，上层调用读写函数往文件节点读写数据时，相应的show和store函数就会被调用。sensors_class_attrs的定义如下：

1. static struct device_attribute sensors_class_attrs[] = {
2. __ATTR(name, 0444, sensors_name_show, NULL),
3. __ATTR(vendor, 0444, sensors_vendor_show, NULL),
4. __ATTR(version, 0444, sensors_version_show, NULL),
5. __ATTR(handle, 0444, sensors_handle_show, NULL),
6. __ATTR(type, 0444, sensors_type_show, NULL),
7. __ATTR(max_range, 0444, sensors_max_range_show, NULL),
8. __ATTR(resolution, 0444, sensors_resolution_show, NULL),
9. __ATTR(sensor_power, 0444, sensors_power_show, NULL),
10. __ATTR(min_delay, 0444, sensors_min_delay_show, NULL),
11. __ATTR(fifo_reserved_event_count, 0444, sensors_fifo_event_show, NULL),
12. __ATTR(fifo_max_event_count, 0444, sensors_fifo_max_show, NULL),
13. __ATTR(max_delay, 0444, sensors_max_delay_show, NULL),
14. __ATTR(flags, 0444, sensors_flags_show, NULL),
15. __ATTR(enable, 0664, sensors_enable_show, sensors_enable_store),
16. __ATTR(enable_wakeup, 0664, sensors_enable_wakeup_show,
17. sensors_enable_wakeup_store),
18. __ATTR(poll_delay, 0664, sensors_delay_show, sensors_delay_store),
19. __ATTR(self_test, 0440, sensors_test_show, NULL),
20. __ATTR(max_latency, 0660, sensors_max_latency_show,
21. sensors_max_latency_store),
22. __ATTR(flush, 0660, sensors_flush_show, sensors_flush_store),
23. __ATTR(calibrate, 0664, sensors_calibrate_show,
24. sensors_calibrate_store),
25. __ATTR_NULL,
26. };

具体的sensor驱动程序会调用sensors_classdev_register函数注册自己，以地磁传感器mmc3524为例，在驱动的proble函数中，有如下代码：

1. memsic->cdev = sensors_cdev;
2. memsic->cdev.sensors_enable = mmc3524x_set_enable;
3. memsic->cdev.sensors_poll_delay = mmc3524x_set_poll_delay;
4. res = sensors_classdev_register(&memsic->idev->dev, &memsic->cdev);

mmc3524的数据结构如下，里面有个struct sensors_classdev    cdev;成员，上面的代码设置cdev的enable和poll_delay函数指针指向驱动程序的函数，供sensor的HAL层调用。

1. struct mmc3524x_data {
2. struct mutex        ecompass_lock;
3. struct mutex        ops_lock;
4. struct workqueue_struct *data_wq;
5. struct delayed_work dwork;
6. struct sensors_classdev cdev;
7. struct mmc3524x_vec last;
8. struct i2c_client   *i2c;
9. struct input_dev    *idev;
10. struct regulator    *vdd;
11. struct regulator    *vio;
12. struct regmap       *regmap;
13. int         dir;
14. int         auto_report;
15. int         enable;
16. int         poll_interval;
17. int         power_enabled;
18. unsigned long       timeout;

sensors_classdev_register函数是sensor的核心，该函数根据之前创建的sensors_class，在类下面创建设备，前面调用sensors_classdev_register(&memsic->idev->dev, &memsic->cdev);时，将memsic->cdev成员的地址作为device_create函数的第四个参数传入，然后将sensors_cdev放入sensors_list链表。

1. int sensors_classdev_register(struct device *parent,
2. struct sensors_classdev *sensors_cdev)
3. {
4. sensors_cdev->dev = device_create(sensors_class, parent, 0,
5. sensors_cdev, "%s", sensors_cdev->name);
6. if (IS_ERR(sensors_cdev->dev))
7. return PTR_ERR(sensors_cdev->dev);
8. down_write(&sensors_list_lock);
9. list_add_tail(&sensors_cdev->node, &sensors_list);
10. up_write(&sensors_list_lock);
11. pr_debug("Registered sensors device: %s\n",
12. sensors_cdev->name);
13. return 0;
14. }

在device_create函数中，调用device_create_vargs将之前传入的&memsic->cdev传入device_create_vargs函数中。

1. struct device *device_create(struct classclass *class, struct device *parent,
2. dev_t devt, voidvoid *drvdata, const charchar *fmt, ...)
3. {
4. va_list vargs;
5. struct device *dev;
6. va_start(vargs, fmt);
7. dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
8. va_end(vargs);
9. return dev;
10. }

在device_create_vargs函数中，会调用dev_set_drvdata(dev, drvdata);

1. struct device *device_create_vargs(struct classclass *class, struct device *parent,
2. dev_t devt, voidvoid *drvdata, const charchar *fmt,
3. va_list args)
4. {
5. struct device *dev = NULL;
6. int retval = -ENODEV;
7. if (class == NULL || IS_ERR(class))
8. goto error;
9. dev = kzalloc(sizeof(*dev), GFP_KERNEL);
10. if (!dev) {
11. retval = -ENOMEM;
12. goto error;
13. }
14. dev->devt = devt;
15. dev->class = class;
16. dev->parent = parent;
17. dev->release = device_create_release;
18. dev_set_drvdata(dev, drvdata);
19. retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
20. if (retval)
21. goto error;
22. retval = device_register(dev);
23. if (retval)
24. goto error;
25. return dev;
26. error:
27. put_device(dev);
28. return ERR_PTR(retval);
29. }dev_set_drvdata

在dev_set_drvdata函数中，会调用dev->p->driver_data = data;这样dev->p->driver_data就指向了&memsic->cdev。

1. int dev_set_drvdata(struct device *dev, voidvoid *data)
2. {
3. int error;
4. if (!dev->p) {
5. error = device_private_init(dev);
6. if (error)
7. return error;
8. }
9. dev->p->driver_data = data;
10. return 0;
11. }

在sensors_enable_store和sensors_enable_show函数中，会调用dev_get_drvdata函数：

1. static ssize_t sensors_enable_store(struct device *dev,
2. struct device_attribute *attr, const charchar *buf, size_t size)
3. {
4. struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev);
5. ssize_t ret = -EINVAL;
6. unsigned long data = 0;
7. ret = kstrtoul(buf, 10, &data);
8. if (ret)
9. return ret;
10. if (data > 1) {
11. dev_err(dev, "Invalid value of input, input=%ld\n", data);
12. return -EINVAL;
13. }
14. if (sensors_cdev->sensors_enable == NULL) {
15. dev_err(dev, "Invalid sensor class enable handle\n");
16. return -EINVAL;
17. }
18. ret = sensors_cdev->sensors_enable(sensors_cdev, data);
19. if (ret)
20. return ret;
21. sensors_cdev->enabled = data;
22. return size;
23. }
24. <pre name="code" class="objc">static ssize_t sensors_enable_show(struct device *dev,
25. struct device_attribute *attr, charchar *buf)
26. {
27. struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev);
28. return snprintf(buf, PAGE_SIZE, "%u\n",
29. sensors_cdev->enabled);
30. }

dev_get_drvdata函数会返回之前在dev_set_drvdata函数中设置的指针dev->p->driver_data。

1. voidvoid *dev_get_drvdata(const struct device *dev)
2. {
3. if (dev && dev->p)
4. return dev->p->driver_data;
5. return NULL;
6. }

之前在驱动的probe函数中设置了memsic->cdev.sensors_enable = mmc3524x_set_enable;sensors_enable_store函数通过ret = sensors_cdev->sensors_enable(sensors_cdev, data);来调用驱动程序中的enable函数。HAL层会根据sensor的设备节点来找到sensor，调用enable，delay等函数来调用sensor驱动中对应的函数，本例子中对应的文件是：hardware/qcom/sensors/CompassSensor.cpp：

1. int CompassSensor::enable(int32_t, int en) {
2. int flags = en ? 1 : 0;
3. compass_algo_args arg;
4. arg.common.enable = flags;
5. char propBuf[PROPERTY_VALUE_MAX];
6. property_get("sensors.compass.loopback", propBuf, "0");
7. if (strcmp(propBuf, "1") == 0) {
8. ALOGE("sensors.compass.loopback is set");
9. mEnabled = flags;
10. mEnabledTime = 0;
11. return 0;
12. }
13. if (flags != mEnabled) {
14. int fd;
15. if ((algo != NULL) && (algo->methods->config != NULL)) {
16. if (algo->methods->config(CMD_ENABLE, (sensor_algo_args*)&arg)) {
17. ALOGW("Calling enable config failed for compass");
18. }
19. }
20. strlcpy(&input_sysfs_path[input_sysfs_path_len],
21. SYSFS_ENABLE, SYSFS_MAXLEN);
22. fd = open(input_sysfs_path, O_RDWR);
23. if (fd >= 0) {
24. char buf[2];
25. int err;
26. buf[1] = 0;
27. if (flags) {
28. buf[0] = '1';
29. mEnabledTime = getTimestamp() + IGNORE_EVENT_TIME;
30. } else {
31. buf[0] = '0';
32. }
33. err = write(fd, buf, sizeof(buf));
34. close(fd);
35. mEnabled = flags;
36. return 0;
37. }
38. ALOGE("CompassSensor: failed to open %s", input_sysfs_path);
39. return -1;
40. }
41. return 0;
42. }

HAL层的enable函数中，通过write系统调用来调用内核的enable函数，内核的enable函数首先会打开设备的电源，然后通过工作队列函数queue_delayed_work(memsic->data_wq,&memsic->dwork,msecs_to_jiffies(memsic->poll_interval));来调用sensor的mmc3524x_poll函数。

1. static int mmc3524x_set_enable(struct sensors_classdev *sensors_cdev,
2. unsigned int enable)
3. {
4. int rc = 0;
5. struct mmc3524x_data *memsic = container_of(sensors_cdev,
6. struct mmc3524x_data, cdev);
7. mutex_lock(&memsic->ops_lock);
8. if (enable && (!memsic->enable)) {
9. rc = mmc3524x_power_set(memsic, true);
10. if (rc) {
11. dev_err(&memsic->i2c->dev, "Power up failed\n");
12. goto exit;
13. }
14. /* send TM cmd before read */
15. rc = regmap_write(memsic->regmap, MMC3524X_REG_CTRL,
16. MMC3524X_CTRL_TM);
17. if (rc) {
18. dev_err(&memsic->i2c->dev, "write reg %d failed.(%d)\n",
19. MMC3524X_REG_CTRL, rc);
20. goto exit;
21. }
22. memsic->timeout = jiffies;
23. if (memsic->auto_report)
24. queue_delayed_work(memsic->data_wq,
25. &memsic->dwork,
26. msecs_to_jiffies(memsic->poll_interval));
27. } else if ((!enable) && memsic->enable) {
28. if (memsic->auto_report)
29. cancel_delayed_work_sync(&memsic->dwork);
30. if (mmc3524x_power_set(memsic, false))
31. dev_warn(&memsic->i2c->dev, "Power off failed\n");
32. } else {
33. dev_warn(&memsic->i2c->dev,
34. "ignore enable state change from %d to %d\n",
35. memsic->enable, enable);
36. }
37. memsic->enable = enable;
38. exit:
39. mutex_unlock(&memsic->ops_lock);
40. return rc;

mmc3524x_poll函数通过I2C接口获取数据，上报数据。

1. static void mmc3524x_poll(struct work_struct *work)
2. {
3. int ret;
4. s8 *tmp;
5. struct mmc3524x_vec vec;
6. struct mmc3524x_vec report;
7. struct mmc3524x_data *memsic = container_of((struct delayed_work *)work,
8. struct mmc3524x_data, dwork);
9. ktime_t timestamp;
10. vec.x = vec.y = vec.z = 0;
11. ret = mmc3524x_read_xyz(memsic, &vec);
12. if (ret) {
13. dev_warn(&memsic->i2c->dev, "read xyz failed\n");
14. goto exit;
15. }
16. tmp = &mmc3524x_rotation_matrix[memsic->dir][0];
17. report.x = tmp[0] * vec.x + tmp[1] * vec.y + tmp[2] * vec.z;
18. report.y = tmp[3] * vec.x + tmp[4] * vec.y + tmp[5] * vec.z;
19. report.z = tmp[6] * vec.x + tmp[7] * vec.y + tmp[8] * vec.z;
20. timestamp = ktime_get_boottime();
21. input_report_abs(memsic->idev, ABS_X, report.x);
22. input_report_abs(memsic->idev, ABS_Y, report.y);
23. input_report_abs(memsic->idev, ABS_Z, report.z);
24. input_event(memsic->idev,
25. EV_SYN, SYN_TIME_SEC,
26. ktime_to_timespec(timestamp).tv_sec);
27. input_event(memsic->idev,
28. EV_SYN, SYN_TIME_NSEC,
29. ktime_to_timespec(timestamp).tv_nsec);
30. input_sync(memsic->idev);
31. exit:
32. queue_delayed_work(memsic->data_wq,
33. &memsic->dwork,
34. msecs_to_jiffies(memsic->poll_interval));
35. }

 

顶

0