Linux内核学习－字符设备驱动学习（二）

在Linux内核学习－字符设备驱动学习（一）中编写字符设备驱动的一种方法，但是需要手动创建设备节点。

有没有能够自动的创建设备节点的呢？

有！使用class_create()和device_create()函数可以自动创建节点。

class_create : 创建class
class_destroy : 销毁class
class_device_create : 创建device
class_device_destroy : 销毁device

class_create()
-------------------------------------------------
linux-2.6.22/include/linux/device.h
struct class *class_create(struct module *owner, const char *name)
class_create - create a struct class structure
@owner: pointer to the module that is to "own" this struct class
@name: pointer to a string for the name of this class.
在/sys/class/下创建类目录

class_device_create()
-------------------------------------------------
linux-2.6.22/include/linux/device.h
struct class_device *class_device_create(struct class *cls,
struct class_device *parent,
dev_t devt,
struct device *device,
const char *fmt, ...)

class_device_create - creates a class device and registers it with sysfs
@cls: pointer to the struct class that this device should be registered to.
@parent: pointer to the parent struct class_device of this new device, if any.
@devt: the dev_t for the char device to be added.
@device: a pointer to a struct device that is assiociated with this class device.
@fmt: string for the class device's name
在驱动模块初始化函数中实现设备节点的自动创建

设备驱动文件char01.c

[cpp] view plain copy print ?

1. #include <linux/init.h>
2. #include <linux/module.h>
3. #include <linux/cdev.h>
4. #include <linux/device.h>
5. #include <linux/kdev_t.h>
6. #include <linux/fs.h>
7. /
8. int char01_open(struct inode *inode, struct file *filp)
9. {
10. printk("char01 open!/n");
11. return 0;
12. }
14. int char01_release(struct inode *inode, struct file *filp)
15. {
16. printk("char01 release!/n");
17. return 0;
18. }
20. ssize_t char01_read(struct file *filp, char *buf,
21. size_t count, loff_t *fpos)
22. {
23. printk("char01 read!/n");
24. return 0;
25. }
27. ssize_t char01_write(struct file *filp, const char *buf,
28. size_t count, loff_t *fpos)
29. {
30. printk("char01 write!/n");
31. return 0;
32. }
34. int char01_ioctl(struct inode *inode, struct file *filp,
35. unsigned int cmd, unsigned long param)
36. {
37. printk("char01 ioctl!/n");
38. printk("cmd:%d param:%ld/n", cmd, param);
39. return 0;
40. }
41. /
42. struct file_operations fops =
43. {
44. .owner = THIS_MODULE,
45. .open = char01_open,
46. .release = char01_release,
47. .read = char01_read,
48. .write = char01_write,
49. .ioctl = char01_ioctl
50. };
51. dev_t devno;
52. struct class *pclass;
53. struct cdev dev;
55. int char01_dev_init(void)
56. {
57. int result;
58. result = alloc_chrdev_region(&devno, 0, 1, "char01");
59. if (result != 0)
60. {
61. printk("alloc_chrdev_region failed!/n");
62. goto ERR1;
63. }
65. cdev_init(&dev, &fops);
66. dev.owner = THIS_MODULE;
67. dev.ops = &fops;
68. result = cdev_add(&dev, devno, 1);
69. if (result != 0)
70. {
71. printk("cdev_add failed!/n");
72. goto ERR2;
73. }
75. pclass = class_create(THIS_MODULE, "char01");
76. if (IS_ERR(pclass))
77. {
78. printk("class_create failed!/n");
79. goto ERR3;
80. }
82. device_create(pclass, NULL, devno, NULL, "char01");
84. return 0;
85. ERR3:
86. cdev_del(&dev);
87. ERR2:
88. unregister_chrdev_region(devno, 1);
89. ERR1:
90. return -1;
91. }
92. /
93. /
94. /
95. static int __init char01_init(void)
96. {
97. printk("module char01 init!/n");
98. return char01_dev_init();
99. }
101. static void __exit char01_exit(void)
102. {
103. printk("module char01 exit!/n");
104. class_destroy(pclass);
105. device_destroy(pclass,devno);
106. cdev_del(&dev);
107. unregister_chrdev_region(devno, 1);
108. }
109. /
110. MODULE_LICENSE("Dual BSD/GPL");
111. MODULE_AUTHOR("Yao.GUET");
112. module_init(char01_init);
113. module_exit(char01_exit);
114. /

#include <linux/init.h> #include <linux/module.h> #include <linux/cdev.h> #include <linux/device.h> #include <linux/kdev_t.h> #include <linux/fs.h> / int char01_open(struct inode *inode, struct file *filp) { printk("char01 open!/n"); return 0; } int char01_release(struct inode *inode, struct file *filp) { printk("char01 release!/n"); return 0; } ssize_t char01_read(struct file *filp, char *buf, size_t count, loff_t *fpos) { printk("char01 read!/n"); return 0; } ssize_t char01_write(struct file *filp, const char *buf, size_t count, loff_t *fpos) { printk("char01 write!/n"); return 0; } int char01_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long param) { printk("char01 ioctl!/n"); printk("cmd:%d param:%ld/n", cmd, param); return 0; } / struct file_operations fops = { .owner = THIS_MODULE, .open = char01_open, .release = char01_release, .read = char01_read, .write = char01_write, .ioctl = char01_ioctl }; dev_t devno; struct class *pclass; struct cdev dev; int char01_dev_init(void) { int result; result = alloc_chrdev_region(&devno, 0, 1, "char01"); if (result != 0) { printk("alloc_chrdev_region failed!/n"); goto ERR1; } cdev_init(&dev, &fops); dev.owner = THIS_MODULE; dev.ops = &fops; result = cdev_add(&dev, devno, 1); if (result != 0) { printk("cdev_add failed!/n"); goto ERR2; } pclass = class_create(THIS_MODULE, "char01"); if (IS_ERR(pclass)) { printk("class_create failed!/n"); goto ERR3; } device_create(pclass, NULL, devno, NULL, "char01"); return 0; ERR3: cdev_del(&dev); ERR2: unregister_chrdev_region(devno, 1); ERR1: return -1; } / / / static int __init char01_init(void) { printk("module char01 init!/n"); return char01_dev_init(); } static void __exit char01_exit(void) { printk("module char01 exit!/n"); class_destroy(pclass); device_destroy(pclass,devno); cdev_del(&dev); unregister_chrdev_region(devno, 1); } / MODULE_LICENSE("Dual BSD/GPL"); MODULE_AUTHOR("Yao.GUET"); module_init(char01_init); module_exit(char01_exit); /

测试文件char01_test.c

[cpp] view plain copy print ?

1. #include <stdio.h>
2. #include <fcntl.h>
3. #include <errno.h>
4. #include <sys/stat.h>
5. /
6. int main(int argc, char *argv)
7. {
8. int fd;
9. fd = open("/dev/char01", O_RDWR);
10. if (fd<0)
11. {
12. printf("open /dev/char01 failed!/n");
13. printf("%s/n", strerror(errno));
14. return -1;
15. }
16. printf("open /dev/char01 ok!/n");
17. ioctl(fd, 0);
18. close(fd);
19. }

#include <stdio.h> #include <fcntl.h> #include <errno.h> #include <sys/stat.h> / int main(int argc, char *argv) { int fd; fd = open("/dev/char01", O_RDWR); if (fd<0) { printf("open /dev/char01 failed!/n"); printf("%s/n", strerror(errno)); return -1; } printf("open /dev/char01 ok!/n"); ioctl(fd, 0); close(fd); }

Makefile文件：

[xhtml] view plain copy print ?

1. obj-m := char01.o
2. PWD := $(shell pwd)
3. K_DIR := /lib/modules/$(shell uname -r)/build
5. all:
6. $(MAKE) -C $(K_DIR) M=$(PWD) modules
7. clean:
8. $(MAKE) -C $(K_DIR) M=$(PWD) clean
9. test:char01_test.o
10. gcc -o $@ $^