字符驱动之初始化设备及自动mknod（未实验）

初始化设备，添加设备后，通过类创建和设备创建函数可以自动mknod。

1、cdev 相关函数

**初始化cdev：**

void cdev_init(struct cdev *cdev, const struct file_operations *fops);
cdev:待初始化的cdev对象
fops:可以在设备上执行的操作函数集合


**添加cdev：**
int cdev_add(struct cdev *cdev, dev_t dev, unsigned count);
cdev:待 添加到内核的cdev对象
dev:设备号
count:待添加的设备个数
返回：成功返回0，失败返回负值


**删除cdev：**
void cdev_del(struct cdev *cdev);
cdev:待从内核删除的cdev对象

2、类与设备创建函数

**自动创建设备文件**
定义在<linux/device.h>中
class结构：该结构体类型变量对应一个设备类，被创建的类存放在/sys目录下面
device结构：该结构体类型变量对应设备，被创建的设备存放于/sys目录下面
在加载驱动模块时，用户空间中的udev会自动响应device_create()函数，在/sys下寻找对应的类，从而为这个设备在/dev目录下创建设备文件


**类创建**
为设备驱动创建一个设备类
struct class *class_create(struct module *owner, const char *name);
owner:创建设备类的驱动模块拥有者
name:待创建的设备类的类名称
返回：创建好的设备类的指针，失败返回NULL


**类销毁**
销毁设备驱动创建的对应设备类
void class_destroy(struct class *cls);
cls:待销毁的设备类

**设备创建**
为设备创建对应的设备文件
struct device *device_create(struct class *class, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...);
class:待创建的设备所属设备类
parent:指向可能存在的父设备的指针
devt:待创建设备的设备号（包括主设备号和次设备号）
drvdata:设备保留的驱动私有数据指针
fmt:待创建的设备文件名称
返回：创建好的device的指针，失败返回NULL


**设备销毁**
删除设备对应的设备文件
void device_destroy(struct class *class, dev_t dev);
class:待销毁的设备所属设备类

devt:待销毁设备的设备号（包括主设备号和次设备号）

1. #include <linux/init.h>  
2. #include <linux/module.h>  
3. #include <linux/fs.h>  
4. #include <linux/cdev.h>  
5. #include <linux/device.h>  
6.   
7. MODULE_LICENSE("GPL");  
8. #define CDD_MAJOR   200
9. #define CDD_MINOR   0  
10. #define CDD_COUNT   1  
11. dev_t dev = 0;  
12. u32 cdd_major = 0;  
13. u32 cdd_minor = 0;  
14. /*定义cdev类型的变量*/  
15. struct cdev cdd_cdev;  
16.   
17. struct classclass *dev_class = NULL;  
18. struct device *dev_device = NULL;  
19.   
20. int cdd_open(struct inode* inode, struct file *filp)  
21. {  
22.     printk("enter cdd_open!\n");  
23.     return 0;  
24. }  
25.   
26. int cdd_read(struct file *filp, char __user *buf, size_t count, loff_t *offset)  
27. {  
28.     printk("enter cdd_read!\n");  
29.     return 0;  
30. }  
31.   
32. int cdd_write(struct file *filp, const char __user *buf, size_t count, loff_t *offset)  
33. {  
34.     printk("enter cdd_write!\n");  
35.     return 0;  
36. }  
37.   
38. int cdd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long data)  
39. {  
40.     printk("enter cdd_ioctl!\n");  
41.     return 0;  
42. }  
43.   
44. int cdd_release(struct inode *inode, struct file *filp)  
45. {  
46.     printk("enter cdd_release!\n");  
47.     return 0;  
48. }  
49.   
50. struct file_operations cdd_fops = {  
51.     .owner = THIS_MODULE,  
52.     .open = cdd_open,  
53.     .read = cdd_read,  
54.     .write = cdd_write,  
55.     .ioctl = cdd_ioctl,  
56.     .release = cdd_release,  
57.     };  
58.   
59. int __init cdd_init(void)  
60. {  
61.     int ret = 0;  
62.     if(cdd_major){  
63.         dev = MKDEV(CDD_MAJOR, CDD_MINOR);//生成设备号  
64.         //注册设备号;1、要注册的起始设备号2、连续注册的设备号个数3、名字  
65.         ret = register_chrdev_region(dev, CDD_COUNT, "cdd_demo");  
66.     }else{  
67.         // 动态分配设备号  
68.         ret = alloc_chrdev_region(&dev, cdd_minor, CDD_COUNT, "cdd_demo02");  
69.     }  
70.       
71.     if(ret < 0){  
72.         printk("register_chrdev_region failed!\n");  
73.         goto failure_register_chrdev;  
74.     }  
75.     //获取主设备号  
76.     cdd_major = MAJOR(dev);  
77.     printk("cdd_major = %d\n", cdd_major);  
78.   
79.     /*初始化cdev*/  
80.     cdev_init(&cdd_cdev, &cdd_fops);  
81.     /*添加cdev到内核*/  
82.     ret = cdev_add(&cdd_cdev, dev, CDD_COUNT);  
83.     if(ret < 0){  
84.         printk("cdev_add failed!\n");  
85.         goto failure_cdev_add;  
86.     }  
87.     /*自动创建设备节点文件*/  
88.     //1.注册设备类  /sys/class/cdd_class的文件夹  
89.     dev_class = class_create(THIS_MODULE, "cdd_class");  
90.     if(IS_ERR(dev_class)){  
91.         printk("class_create failed!\n");  
92.         ret = PTR_ERR("dev_class");  
93.         goto failure_class_create;  
94.     }  
95.     //2.注册设备  /sys/class/cdd_class/cdd0   /dev/cdd0  
96.     dev_device = device_create(dev_class, NULL, dev, NULL, "cdd0", cdd_minor);  
97.     if(IS_ERR(dev_device)){  
98.         printk("device_create failed!\n");  
99.         ret = PTR_ERR(dev_device);  
100.         goto failure_device_create;  
101.     }  
102.     return 0;  
103. failure_device_create:  
104.     class_destroy(dev_class);  
105. failure_class_create:  
106.     cdev_del(&cdd_cdev);  
107. failure_cdev_add:  
108.     unregister_chrdev_region(dev, CDD_COUNT);  
109. failure_register_chrdev:  
110.     return ret;  
111. }  
112.   
113. void __exit cdd_exit(void)  
114. {  
115. /*逆序消除*/  
116.     //从内核中删除设备  
117.     device_destroy(dev_class, dev);  
118.     //从内核中删除设备类  
119.     class_destroy(dev_class);  
120.     //从内核中删除cdev  
121.     cdev_del(&cdd_cdev);  
122.     //注销设备号  
123.     unregister_chrdev_region(dev, CDD_COUNT);  
124. }     
125.   
126. module_init(cdd_init);  
127. module_exit(cdd_exit);