一般在编写嵌入式Linux内核驱动时，最简单的情况下往往只需要写一个简单的misc驱动，它仅需要兼容一种硬件外设和一种特定的芯片平台即可，这种驱动的最大缺点就是可扩展性和可移植性较差，往往在单板硬件上存在小幅的改动就需要更改驱动源代码，有时在甚至在硬件上增加了一个相同的外设时需要重新为其写一个几乎一模一样的驱动。

一个好的Linux内核驱动是要求在尽量小的改动下能够快速适配于不同的平台，且能够支持多设备。Linux内核针对没有挂接在物理总线（PCI、I2C和USB等等）上的嵌入式设备设计了一套platform总线驱动框架，这种框架能够很好的解决满足一般嵌入式外设驱动的要求。但如果存在较多功能类似但又不尽相同的的外设就需要为其设计对应的子系统来统一管理，Linux内核里存在许多各式各样的子系统，有相当复杂的也有比较简单的，它们不仅统一管理了不同类型的外设驱动也屏蔽了他们的差异并向用户空间提供了统一的接口。例如统一管理RTC驱动的RTC子系统、统一管理图形显示设备的framebuffer子系统，甚至非常庞大且复杂的网络子系统和文件系统子系统等等。

今次本文参考内核RTC子系统并提取出一个简单的demo驱动子系统框架示例程序，可适用于一些简单的Linux设备驱动开发。

示例环境：

单板硬件：树莓派b

源码链接：https://github.com/luckyapple1028/linux-demo-subsys-module

一、demo子系统框架

框架结构图：

示例程序列表：demo_core.c、demo_dev.c、demo_interface.c、demo_proc.c、demo_sysfs.c、xxx_demo_driver.c、xxx_demo_device.c、demo-core.h、demo_dev.h、demo.h

1、demo_core

demo驱动程序的管理的核心，向设备驱动程序提供接口，完成驱动程序向内核的的注册和卸载。

2、demo_dev

负责demo驱动的字符设备文件的管理，包括注册和注销字符设备，定义了包括read、write、ioctl等一系列设备控制接口。

3、demo_interface.c

提供了demo设备iotcl控制的函数接口，负责对下层实际的驱动接口进行统一管理和调用。

4、demo_proc.c

提供了proc文件系统的demo设备查询和控制接口。

5、demo_sysfs.c

提供了sys文件系统的demo设备查询和控制接口，依赖于标准的Linux设备驱动模型。

6、xxx_demo_driver.c

具体外设的驱动程序，不同的外设针对自己的特点可分别实现，是真正具有差异性的部分，然后统一向demo子系统注册。本文中作为示例驱动依赖于platform驱动模型。

7、xxx_demo_device.c

具体外设，同本文中设备驱动xxx_demo_driver匹配，负责注册platform设备并向驱动程序传入具体的物理外设参数。（注：本文这里使用的是传统的方法，在新的Linux中可用Device Tree代替）。

二、结构体

1、xxx_demo

struct xxx_demo {
	struct demo_device *demo;				/* demo子系统通用设备指针 */
	struct timer_list xxx_demo_timer;
	unsigned long xxx_demo_data;
	/* something else */
};

2、demo_device

struct demo_device
{
	struct device dev;
	struct module *owner;

	int id;
	char name[DEMO_DEVICE_NAME_SIZE];

	const struct demo_class_ops *ops;
	struct mutex ops_lock;

	struct cdev char_dev;
	unsigned long flags;

	unsigned long irq_data;
	spinlock_t irq_lock;
	wait_queue_head_t irq_queue;
	struct fasync_struct *async_queue;

	/* some demo data */
	struct demo_data demo_data;
};

3、demo_data

struct demo_data
{
	unsigned long text_data;
	/* something else */
};

该结构包含在demo_device结构体中，包含了一些demo驱动中通用性的参数以及demo子系统为了屏蔽底层差异并向用户提供统一接口时需要而提取出来的需要统一管理的参数等等，这里仅示例性的列了一个demo_data数据。

4、demo_class_ops

struct demo_class_ops {
	int (*open)(struct device *);
	void (*release)(struct device *);
	int (*ioctl)(struct device *, unsigned int, unsigned long);
	int (*set_data)(struct device *, struct demo_ctl_data *);
	int (*get_data)(struct device *, struct demo_ctl_data *);
	int (*proc)(struct device *, struct seq_file *);
	int (*read_callback)(struct device *, int data);
};

三、demo子系统和驱动程序流程分析

1、demo子系统初始化

这里demo子系统的初始化符合大多数Linux外设驱动子系统初始化方案，来简单走读一下代码：

/* demo子系统初始化 */
static int __init demo_core_init(void)
{ 
	/* 创建 demo class */
	demo_class = class_create(THIS_MODULE, "demo");
	if (IS_ERR(demo_class)) {
		pr_err("couldn't create class\n");
		return PTR_ERR(demo_class);
	}

	/* demo 设备驱动初始化 */
	demo_dev_init();

	/* demo proc初始化 */
	demo_proc_init();
	
	/* demo sysfs初始化 */
	demo_sysfs_init(demo_class);

	pr_info("demo subsys init success\n");	
	return 0;
}

void __init demo_dev_init(void)
{
	int err;

	err = alloc_chrdev_region(&demo_devt, 0, DEMO_DEV_MAX, "demo");
	if (err < 0)
		pr_err("failed to allocate char dev region\n");
}

void __init demo_proc_init(void)
{
	/* 创建 demo proc 目录 */
	demo_proc = proc_mkdir("driver/demo", NULL);
}

void __init demo_sysfs_init(struct class *demo_class)
{
	/* 绑定通用sys节点，在注册设备时会依次生成 */
	demo_class->dev_groups = demo_groups;
}

static struct attribute *demo_attrs[] = {
	&dev_attr_demo_name.attr,
	&dev_attr_demo_data.attr,
	NULL,
};
ATTRIBUTE_GROUPS(demo);

这里的demo子系统初始化流程只是一个简单的框架模型，对于具体的设备子系统还会进行一些其他部件的初始化。分析完初始化流程后来简单看一下反初始化流程：

static void __exit demo_core_exit(void)
{
	demo_proc_exit();
	demo_dev_exit();
	class_destroy(demo_class);
	ida_destroy(&demo_ida);
	
	pr_info("demo subsys exit success\n");
}

反初始化流程可以视为初始化流程的一个逆过程，非常直白。下面来分析一个具体的驱动程序是如何完成初始化并注册到demo子系统中的。

2、驱动注册总体流程

具体驱动的初始化流程视具体的物理特性可以千变万化，对于依赖于I2C通信的外设可以通过I2C总线完成初始化、对于依赖于SPI通信的外设则可以通过SPI总线完成初始化，本文为了简单起见使用了虚拟的platform总线来进行驱动的匹配和注册操作，来详细分析一下代码：

xxx_demo_driver：

static struct platform_driver xxx_demo_driver = {
	.driver	= {
		.name    = "xxx_demo_device",   
		.owner	 = THIS_MODULE,
	},
	.probe   = xxx_demo_driver_probe,
	.remove  = xxx_demo_driver_remove,
};

static struct platform_device demo0_device = {
	.name		= "xxx_demo_device",
	.id		    = 0,
	.dev		= {
		.release	= demo_device_release,
	}
};

static struct platform_device demo1_device = {
	.name		= "xxx_demo_device",
	.id		    = 1,
	.dev		= {
		.release	= demo_device_release,
	}
};

static int xxx_demo_driver_probe(struct platform_device *pdev)
{
	struct xxx_demo *xxx_demo = NULL;
	int ret = 0;
	
	/* 申请驱动结构内存并保存为platform的私有数据 */
	xxx_demo = devm_kzalloc(&pdev->dev, sizeof(struct xxx_demo), GFP_KERNEL);
	if (!xxx_demo)
		return -ENOMEM;

	platform_set_drvdata(pdev, xxx_demo);

	/* 获取平台资源 */
	/* do something */

	
	/* 执行驱动相关初始化(包括外设硬件、锁、队列等)*/
	xxx_demo->xxx_demo_data = 0;
	/* do something */
	init_timer(&xxx_demo->xxx_demo_timer);
	xxx_demo->xxx_demo_timer.function = xxx_demo_time;
	xxx_demo->xxx_demo_timer.data = (unsigned long)xxx_demo;
	xxx_demo->xxx_demo_timer.expires = jiffies + HZ;
	add_timer(&xxx_demo->xxx_demo_timer);

	/* 向 demo 子系统注册设备 */
	xxx_demo->demo = devm_demo_device_register(&pdev->dev, "xxx_demo",
				&xxx_demo_ops, THIS_MODULE);
	if (IS_ERR(xxx_demo->demo)) {
		dev_err(&pdev->dev, "unable to register the demo class device\n");
		ret = PTR_ERR(xxx_demo->demo);
		goto err;
	}
	
	return 0;

err:
	del_timer_sync(&xxx_demo->xxx_demo_timer);
	return ret;
}

/* demo设备注册澹(使用devm机制) */
struct demo_device *devm_demo_device_register(struct device *dev,
					const char *name,
					const struct demo_class_ops *ops,
					struct module *owner)
{
	struct demo_device **ptr, *demo;

	ptr = devres_alloc(devm_demo_device_release, sizeof(*ptr), GFP_KERNEL);
	if (!ptr)
		return ERR_PTR(-ENOMEM);

	/* 注册 demo 设备 */
	demo = demo_device_register(name, dev, ops, owner);
	if (!IS_ERR(demo)) {
		*ptr = demo;
		devres_add(dev, ptr);
	} else {
		devres_free(ptr);
	}

	return demo;
}

/* demo设备注册 */
struct demo_device *demo_device_register(const char *name, struct device *dev,
					const struct demo_class_ops *ops,
					struct module *owner)
{
	struct demo_device *demo;
	int of_id = -1, id = -1, err;

	/* 获取ID号 */
	if (dev->of_node)
		of_id = of_alias_get_id(dev->of_node, "demo");
	else if (dev->parent && dev->parent->of_node)
		of_id = of_alias_get_id(dev->parent->of_node, "demo");

	if (of_id >= 0) {
		id = ida_simple_get(&demo_ida, of_id, of_id + 1, GFP_KERNEL);
		if (id < 0)
			dev_warn(dev, "/aliases ID %d not available\n", of_id);
	}

	if (id < 0) {
		id = ida_simple_get(&demo_ida, 0, 0, GFP_KERNEL);
		if (id < 0) {
			err = id;
			goto exit;
		}
	}

	/* 开始分配内存 */
	demo = kzalloc(sizeof(struct demo_device), GFP_KERNEL);
	if (demo == NULL) {
		err = -ENOMEM;
		goto exit_ida;
	}

	/* demo 结构初始化 */
	demo->id = id;
	demo->ops = ops;
	demo->owner = owner;
	demo->dev.parent = dev;
	demo->dev.class = demo_class;
	demo->dev.release = demo_device_release;

	mutex_init(&demo->ops_lock);
	spin_lock_init(&demo->irq_lock);
	init_waitqueue_head(&demo->irq_queue);

	strlcpy(demo->name, name, DEMO_DEVICE_NAME_SIZE);
	dev_set_name(&demo->dev, "demo%d", id);

	/* 字符设备初始化 */
	demo_dev_prepare(demo);

	err = device_register(&demo->dev);
	if (err) {
		put_device(&demo->dev);
		goto exit_kfree;
	}

	/* 字符设备、sysfs设备和proc设备注册添加 */
	demo_dev_add_device(demo);
	demo_sysfs_add_device(demo);
	demo_proc_add_device(demo);

	dev_notice(dev, "demo core: registered %s as %s\n", demo->name, dev_name(&demo->dev));

	return demo;

exit_kfree:
	kfree(demo);

exit_ida:
	ida_simple_remove(&demo_ida, id);

exit:
	dev_err(dev, "demo core: unable to register %s, err = %d\n", name, err);
	return ERR_PTR(err);
}

注册函数接下来向内核申请demo_device结构的内存并进行赋值，分别赋值了id号、demo驱动操作函数指针ops，初始化了demo->dev结构，指定了parent为pedv->dev、class为demo_class、并指定了结构释放回调函数，然后初始化了锁和等待队列。注意这里的函数指针ops指向了xxx_demo_driver中实现的xxx_demo_ops：

struct demo_class_ops xxx_demo_ops = {
	.open		= xxx_demo_open,
	.release	= xxx_demo_release,
	.ioctl		= xxx_demo_ioctl,
	.set_data	= xxx_demo_set_data,
	.get_data	= xxx_demo_get_data,
	.proc		= xxx_demo_proc,
	.read_callback	= xxx_demo_read,
};

然后对设备名进行赋值，demo->name为“xxx_demo”，demo->dev.name为“demoX”，后一个名字会作为/dev/目录设备文件、procfs节点文件及sysfs节点目录的名字。同样的可以针对不同的需求进行其他不同组件的初始化。接下来调用demo_dev_prepare函数根据分配的id号和字符设备号初始化字符设备结构：

void demo_dev_prepare(struct demo_device *demo)
{
	if (!demo_devt)
		return;

	if (demo->id >= DEMO_DEV_MAX) {
		dev_warn(&demo->dev, "%s: too many demo devices\n", demo->name);
		return;
	}

	/* 字符设备结构初始化 */
	demo->dev.devt = MKDEV(MAJOR(demo_devt), demo->id);

	cdev_init(&demo->char_dev, &demo_dev_fops);
	demo->char_dev.owner = demo->owner;
}

可以看到字符设备号由子系统初始化时分配的主设备号和id号作为次设备好组成，然后绑定fops函数结构demo_dev_fops：

static const struct file_operations demo_dev_fops = {
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.read		= demo_dev_read,
	.poll		= demo_dev_poll,
	.unlocked_ioctl	= demo_dev_ioctl,
	.open		= demo_dev_open,
	.release	= demo_dev_release,
	.fasync		= demo_dev_fasync,
};

初始化完字符设备结构后接下来调用device_register()函数向Linux内核注册设备，注册完成后就会在/sys目录下生成对应的目录并生成前文中绑定的attr属性文件demo_data和 demo_name。接着调用demo_dev_add_device()函数向内核添加字符设备，添加完成后会在/dev目录下生成对应的/demoX设备节点。

void demo_dev_add_device(struct demo_device *demo)
{
	/* 注册字符设备 */
	if (cdev_add(&demo->char_dev, demo->dev.devt, 1))
		dev_warn(&demo->dev, "%s: failed to add char device %d:%d\n",
			demo->name, MAJOR(demo_devt), demo->id);
	else
		dev_dbg(&demo->dev, "%s: dev (%d:%d)\n", demo->name,
			MAJOR(demo_devt), demo->id);
}

注册函数接着调用demo_sysfs_add_device函数用来创建一些特殊性的attr节点。

void demo_sysfs_add_device(struct demo_device *demo)
{
	int err;

	/* 条件判断 */
	/* do something */

	/* 为需要的设备创建一些特殊的 sys 节点 */
	err = device_create_file(&demo->dev, &dev_attr_demodata);
	if (err)
		dev_err(demo->dev.parent,
			"failed to create alarm attribute, %d\n", err);
}

该函数可以在进入后执行一些条件判断，用来判别是否需要创建attr属性文件。本示例程序中创建了一个dev_attr_demodata属性文件并绑定show和set函数为demo_sysfs_show_demodata()和demo_sysfs_set_demodata()。注册函数最后调用demo_proc_add_device()在/proc/driver/demo目录下创建名为“demoX”（dev_name(&demo->dev)）的文件并绑定文件操作函数：

void demo_proc_add_device(struct demo_device *demo)
{
	/* 为新注册的设备分配 proc */
	proc_create_data(dev_name(&demo->dev), 0, demo_proc, &demo_proc_fops, demo);
}

static const struct file_operations demo_proc_fops = {
	.open		= demo_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= demo_proc_release,
};

static int xxx_demo_driver_remove(struct platform_device *pdev)
{
	struct xxx_demo *xxx_demo = platform_get_drvdata(pdev);

	/* 执行驱动相关去初始化(包括外设硬件、锁、队列等)*/
	del_timer_sync(&xxx_demo->xxx_demo_timer);	
	/* do something */

	/* 向 demo 子系统注销设备 */
	devm_demo_device_unregister(&pdev->dev, xxx_demo->demo);

	/* 释放驱动结构内存 */
	devm_kfree(&pdev->dev, xxx_demo);
	
	return 0;
}

void devm_demo_device_unregister(struct device *dev, struct demo_device *demo)
{
	int res;

	/* 注销 demo 设备 */
	res = devres_release(dev, devm_demo_device_release,
				devm_demo_device_match, demo);
	
	WARN_ON(res);
}

static void devm_demo_device_release(struct device *dev, void *res)
{
	struct demo_device *demo = *(struct demo_device **)res;

	demo_device_unregister(demo);
}

void demo_device_unregister(struct demo_device *demo)
{
	if (get_device(&demo->dev) != NULL) {
		mutex_lock(&demo->ops_lock);
		demo_sysfs_del_device(demo);
		demo_dev_del_device(demo);
		demo_proc_del_device(demo);
		device_unregister(&demo->dev);
		demo->ops = NULL;
		mutex_unlock(&demo->ops_lock);
		put_device(&demo->dev);
	}
}

static void demo_device_release(struct device *dev)
{
	struct demo_device *demo = to_demo_device(dev);
	ida_simple_remove(&demo_ida, demo->id);
	kfree(demo);
}

3、应用调用总体流程

应用层可以通过设备文件/dev/demoX设备文件、procfs和sys属性文件同内核demo子系统进行交互。首先来看前面注册的demo_dev_fops函数集合中的open函数

static int demo_dev_open(struct inode *inode, struct file *file)
{
	struct demo_device *demo = container_of(inode->i_cdev, struct demo_device, char_dev);
	const struct demo_class_ops *ops = demo->ops;
	int err;

	if (test_and_set_bit_lock(DEMO_DEV_BUSY, &demo->flags))
		return -EBUSY;

	file->private_data = demo;

	/* 调用驱动层 open 实现 */
	err = ops->open ? ops->open(demo->dev.parent) : 0;
	if (err == 0) {
		spin_lock_irq(&demo->irq_lock);
		/* do something while open */
		demo->irq_data = 0;
		spin_unlock_irq(&demo->irq_lock);

		return 0;
	}

	clear_bit_unlock(DEMO_DEV_BUSY, &demo->flags);
	return err;
}

另外值得注意的是，这里是如何找到对应的demo_device结构实例的？若驱动注册了多个结构实例会有何影响呢？

关键就在本函数的第一条语句中，在inode的i_cdev指针中保存了用户想要打开设备文件的cdev结构地址，然而该结构又包含在demo_device结构中，通过它即可找到对应的demo_device实例了。同时由于Linux进程在每打开一个文件后都会创建一个file结构，这里将找到的demo_device实例绑定为该file结构的私有数据，以后用户空间对该设备节点的其他系统调用操作都将能够准确的找到该demo_device结构，不会出现错误。例如，前文中注册了两个demo设备，在/dev目录下就会生成两个设备文件demo0和demo1。当用户程序open demo0，就会调用到这里的open函数并通过保存在该demo0文件中的设备号找到对应的cdev结构，最后通过该cedv结构找到对应的demo_device结构，而不会对demo1存在影响。用户进程在open了设备后就可以调用read、ioctl等系统调用了，来分别看一下。

static ssize_t demo_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
	struct demo_device *demo = file->private_data;
	
	DECLARE_WAITQUEUE(wait, current);
	unsigned long data;
	ssize_t ret;

	/* 对读取数据量进行保护 */
	if (count != sizeof(unsigned int) && count < sizeof(unsigned long))
		return -EINVAL;

	/* 等待数据就绪 */
	add_wait_queue(&demo->irq_queue, &wait);
	do {
		__set_current_state(TASK_INTERRUPTIBLE);

		spin_lock_irq(&demo->irq_lock);
		data = demo->irq_data;
		demo->irq_data = 0;
		spin_unlock_irq(&demo->irq_lock);

		if (data != 0) {
			ret = 0;
			break;
		}
		if (file->f_flags & O_NONBLOCK) {
			ret = -EAGAIN;
			break;
		}
		if (signal_pending(current)) {
			ret = -ERESTARTSYS;
			break;
		}
		schedule();
	} while (1);
	set_current_state(TASK_RUNNING);
	remove_wait_queue(&demo->irq_queue, &wait);

	/* 从domo驱动层中读取数据并传输到应用层 */
	if (ret == 0) {
		if (demo->ops->read_callback)
			data = demo->ops->read_callback(demo->dev.parent,
						       data);

		if (sizeof(int) != sizeof(long) &&
		    count == sizeof(unsigned int))
			ret = put_user(data, (unsigned int __user *)buf) ?:
				sizeof(unsigned int);
		else
			ret = put_user(data, (unsigned long __user *)buf) ?:
				sizeof(unsigned long);
	}
	return ret;
}

static unsigned int demo_dev_poll(struct file *file, poll_table *wait)
{
	struct demo_device *demo = file->private_data;
	unsigned long data;

	/* 加入等待队列 */
	poll_wait(file, &demo->irq_queue, wait);

	/* 读取数据并判断条件是否满足(若不满足本调用进程会睡眠) */
	data = demo->irq_data;

	return (data != 0) ? (POLLIN | POLLRDNORM) : 0;
}

static long demo_dev_ioctl(struct file *file,
		unsigned int cmd, unsigned long arg)
{
	struct demo_device *demo = file->private_data;
	struct demo_ctl_data demo_ctl;
	const struct demo_class_ops *ops = demo->ops;
	void __user *uarg = (void __user *) arg;
	int err = 0;

	err = mutex_lock_interruptible(&demo->ops_lock);
	if (err)
		return err;

	switch (cmd) {

	case DEMO_IOCTL_SET:
		/* 进程权限限制(可选), 详见capability.h */
		if (!capable(CAP_SYS_RESOURCE)) {
			err = -EACCES;
			goto done;
		}

		mutex_unlock(&demo->ops_lock);

		if (copy_from_user(&demo_ctl, uarg, sizeof(demo_ctl)))
			return -EFAULT;

		/* demo 示例设置命令函数 */
		return demo_test_set(demo, &demo_ctl);
		
	case DEMO_IOCTL_GET:
		mutex_unlock(&demo->ops_lock);

		/* demo 示例获取命令函数 */
		err = demo_test_get(demo, &demo_ctl);
		if (err < 0)
			return err;

		if (copy_to_user(uarg, &demo_ctl, sizeof(demo_ctl))) 
			return -EFAULT;

		return err;
		
	default:
		/* 尝试使用驱动程序的 ioctl 接口 */
		if (ops->ioctl) {
			err = ops->ioctl(demo->dev.parent, cmd, arg);
			if (err == -ENOIOCTLCMD)
				err = -ENOTTY;
		} else
			err = -ENOTTY;
		break;
	}

done:
	mutex_unlock(&demo->ops_lock);
	return err;
}

int demo_test_set(struct demo_device *demo, struct demo_ctl_data *demo_ctl)
{
	int err = 0;

	err = mutex_lock_interruptible(&demo->ops_lock);
	if (err)
		return err;	

	if (demo->ops == NULL)
		err = -ENODEV;
	else if (!demo->ops->set_data)
		err = -EINVAL;
	else {
		/* do somerhing */
		demo->demo_data.text_data = demo_ctl->data;

		/* 调用驱动层接口 */
		err = demo->ops->set_data(demo->dev.parent, demo_ctl);
	}
	mutex_unlock(&demo->ops_lock);

	return err;	
}

int demo_test_get(struct demo_device *demo, struct demo_ctl_data *demo_ctl)
{
	int err = 0;

	err = mutex_lock_interruptible(&demo->ops_lock);
	if (err)
		return err;	

	if (demo->ops == NULL)
		err = -ENODEV;
	else if (!demo->ops->get_data)
		err = -EINVAL;
	else {
		/* do somerhing */
		demo_ctl->data = demo->demo_data.text_data;

		/* 调用驱动层接口 */
		err = demo->ops->get_data(demo->dev.parent, demo_ctl);
	}
	mutex_unlock(&demo->ops_lock);

	return err;	
}

本示例程序这两个函数实现的较为简单，分别是设置和返回demo_data中的text_data值，然后如果驱动程序实现了自己的get_data和set_data函数接口则会调用它们，这里的思想有点类似面向对象中的派生。在前文中已经看到xxx_demo_driver驱动程序中已经实现了这两个接口：

static int xxx_demo_set_data(struct device *dev, struct demo_ctl_data *ctrl_data)
{
	struct xxx_demo *xxx_demo = dev_get_drvdata(dev);
	
	printk(KERN_INFO "xxx demo set data\n");

	xxx_demo->xxx_demo_data = ctrl_data->data;
	return 0;
}

static int xxx_demo_get_data(struct device *dev, struct demo_ctl_data *ctrl_data)
{
	struct xxx_demo *xxx_demo = dev_get_drvdata(dev);
	
	printk(KERN_INFO "xxx demo get data\n");

	ctrl_data->data = xxx_demo->xxx_demo_data;
	return 0;
}

static int demo_dev_release(struct inode *inode, struct file *file)
{
	struct demo_device *demo = file->private_data;

	/* do something while exit */

	/* 调用驱动层 release 实现 */
	if (demo->ops->release)
		demo->ops->release(demo->dev.parent);

	clear_bit_unlock(DEMO_DEV_BUSY, &demo->flags);
	return 0;
}

static const struct file_operations demo_proc_fops = {
	.open		= demo_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= demo_proc_release,
};

static int demo_proc_show(struct seq_file *seq, void *offset)
{
	int err = 0;
	struct demo_device *demo = seq->private;
	const struct demo_class_ops *ops = demo->ops;

	/* 输出需要的subsys proc信息 */
	seq_printf(seq, "demo_com_data\t: %ld\n", demo->demo_data.text_data);
	seq_printf(seq, "\n");

	/* 输出驱动层proc信息 */
	if (ops->proc)
		err = ops->proc(demo->dev.parent, seq);

	return err;
}

static int xxx_demo_proc(struct device *dev, struct seq_file *seq)
{
	struct xxx_demo *xxx_demo = dev_get_drvdata(dev);

	seq_printf(seq, "xxx_demo_data\t: %ld\n", xxx_demo->xxx_demo_data);
	seq_printf(seq, "\n");

	return 0;
}

static ssize_t
demo_name_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%s\n", to_demo_device(dev)->name);
}
static DEVICE_ATTR_RO(demo_name);

static ssize_t
demo_data_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%ld\n", to_demo_device(dev)->demo_data.text_data);
}

static ssize_t
demo_data_store(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t n)
{
	struct demo_device *demo = to_demo_device(dev);
	unsigned long val = simple_strtoul(buf, NULL, 0);

	if (val >= 4096 || val == 0)
		return -EINVAL;

	demo->demo_data.text_data = (unsigned long)val;

	return n;
}

这里分别设置和输出子系统中的demo_data。最后来看dev_attr_demodata的store接口：

static ssize_t
demo_sysfs_set_demodata(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t n)
{
	struct demo_device *demo = to_demo_device(dev);
	struct demo_ctl_data demo_ctl;	
	unsigned long val = 0;
	ssize_t retval;

	val = simple_strtoul(buf, NULL, 0);

	if (val >= 4096 || val == 0)
		retval = -EINVAL;

	/* 调用interface接口写入驱动数据 */
	demo_ctl.data = (unsigned long)val;

	retval = demo_test_set(demo, &demo_ctl);

	return (retval < 0) ? retval : n;
}

三、demo驱动和子系统演示

ifneq ($(KERNELRELEASE),)

obj-m := demo.o
demo-objs := demo_core.o demo_dev.o demo_interface.o demo_proc.o demo_sysfs.o

obj-m += xxx_demo_driver.o

obj-m += xxx_demo_device.o

else
	
KDIR := /home/apple/raspberry/build/linux-rpi-4.1.y
all:prepare
	make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-bcm2708-linux-gnueabi-
	cp *.ko ./release/	
prepare:
	mkdir release
modules_install:
	make -C $(KDIR) M=$(PWD) modules_install ARCH=arm CROSS_COMPILE=arm-bcm2708-linux-gnueabi-
clean:
	rm -f *.ko *.o *.mod.o *.mod.c *.symvers  modul*
	rm -f ./release/*

endif

读取其中一个就够可以看到输出了：

xxx_demo_data   : 206

这里的xxx_demo_data会一直持续累加（约每1s累加1）

最后在/sys/class/demo目录下可以看到生成的两个目录，他们是指向device目录下对应的链接文件：

root@apple:/sys/class/demo# ls                                                 
demo0  demo1

root@apple:/sys/class/demo# ls -l                                              
total 0
lrwxrwxrwx 1 root root 0 Jan  1 01:26 demo0 -> ../../devices/platform/xxx_demo_device.0/demo/demo0
lrwxrwxrwx 1 root root 0 Jan  1 01:27 demo1 -> ../../devices/platform/xxx_demo_device.1/demo/demo1

打开其中一个可以看到：

root@apple:/sys/class/demo/demo0# ls                                           
demo_data  demo_name  demodata  dev  device  subsystem  uevent

其中demo_data、demo_name和demodata就是前文中程序生成的属性文件了，可以读取和写入数值

root@apple:/sys/class/demo/demo0# cat demodata                                 
0

root@apple:/sys/class/demo/demo0# echo 100 > demo_data                         
root@apple:/sys/class/demo/demo0# cat demodata                                 
100

四、总结

最后总结一下，设计demo子系统的核心用意就在于能够提取出不同demo驱动中相似的部分进行归一化。底层可以有xxx_demo_driver、yyy_demo_driver、zzz_demo_drive等等，他们主要都是为Linux应用提供一个特定的服务，但是它们可能拥有不同的通信总线，不同的寄存器配置，甚至功能也有细微的差别，但是只要能够设计出类似上文中的这么一个demo子系统就可以把这些驱动外设的差异屏蔽起来，子系统要求驱动程序用一套标准的接口与其对接（不支持的功能可以不用实现），这样子系统就可以对这些驱动进行归一化的管理，结构更为清晰，层次更为分明，代码的重复率大大降低，最终为应用程序提供一套标准的接口，应用层序的设计也可以大大的简化。