字符驱动学习

原创已于 2024-10-23 10:33:43 修改 · 438 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#学习 #哈希算法 #算法

于 2016-08-31 12:10:22 首次发布

AndroidPlatform LinuxEmbedded 专栏收录该内容

39 篇文章

订阅专栏

写完第一个hello world 的驱动以后，想编写一个比较完整的字符设备驱动，就把《linux 设备驱动开发详解》上的globalmem驱动写了一下，写完以后，发现了几个问题，没有自动生成设备节点，在多设备的支持中，两个设备的关系不明确。搜集了一下资料，编写了一个能够自动生成设备节点的字符驱动。

在字符驱动中，内核提供了三个函数来注册一组字符设备编号，这三个函数分别是 register_chrdev_region()、alloc_chrdev_region() 和 register_chrdev()。这三个函数都会调用一个共用的 __register_chrdev_region() 函数来注册一组设备编号范围（即一个char_device_struct 结构）。

register_chrdev_region(dev_t first,unsigned int count,char *name)

First :要分配的设备编号范围的初始值(次设备号常设为0);

Count:连续编号范围.

Name:编号相关联的设备名称. (/proc/devices);

动态分配:

Int alloc_chrdev_region(dev_t *dev,unsigned int firstminor,unsigned int count,char *name);

Firstminor : 通常为0;

*dev:存放返回的设备号;

char_device_struct 结构体：

static struct char_device_struct {

struct char_device_struct *next; // 指向散列冲突链表中的下一个元素的指针

unsigned int major; // 主设备号

unsigned int baseminor; // 起始次设备号

int minorct; // 设备编号的范围大小

char name[64]; // 处理该设备编号范围内的设备驱动的名称

struct file_operations *fops; // 没有使用

struct cdev *cdev; // 指向字符设备驱动程序描述符的指针

} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];

使用udev自动生成设备节点的函数：

class_create(…)在/drivers/base/class.c中实现：

　　/**

　　* 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.

　　* This is used to create a struct class pointer that can then be used

　　* in calls to device_create().

　　* Note, the pointer created here is to be destroyed when finished by

　　* making a call to class_destroy().

struct class *class_create(struct module *owner, cONst char *name)

第一个参数指定类的所有者是哪个模块，第二个参数指定类名。

device_create(…)函数在/drivers/base/core.c中实现：

　　/**

　　* device_create - creates a device and registers it with sysfs

　　* @class: pointer to the struct class that this device should be registered to

　　* @parent: pointer to the parent struct device of this new device, if any

　　* @devt: the dev_t for the char device to be added

　　* @fmt: string for the device's name

　　* This funcTIon can be used by char device classes. A struct device

　　* will be created in sysfs, registered to the specified class.

　　* A "dev" file will be created, showing the dev_t for the device, if

　　* the dev_t is not 0,0.

　　* If a pointer to a parent struct device is passed in, the newly created

　　* struct device will be a child of that device in sysfs.

　　* The pointer to the struct device will be returned from the call.

　　* Any further sysfs files that might be required can be created using this

　　* pointer.

　　* Note: the struct class passed to this function must have previously

　　* been created with a call to class_create().

struct device *device_create(struct class *class, struct device *parent, dev_t devt, const char *fmt, ...)

第一个参数指定所要创建的设备所从属的类，第二个参数是这个设备的父设备，如果没有就指定为NULL，第三个参数是设备号，第四个参数是设备名称，第五个参数是从设备号。

下面的代码就是支持两个设备节点，但是两个设备节点支持同一个设备。

static struct class *cdev_class;
static int __init gm_cdev_init(void)
{
int result;
dev_t devno = MKDEV(MAJOR_NR, 0);
if(0 != MAJOR_NR){
result = register_chrdev_region(devno, 2, DEV_NAME); //注册设备支持两个设备，此设备号从0开始
} else {
result = alloc_chrdev_region(&devno, 0, 2, DEV_NAME);
MAJOR_NR = MAJOR(devno);
}
printk(KERN_CRIT"hello\n");
if(result < 0)
return result;
gm_cdevp = kmalloc(2*sizeof(struct gm_cdev_t), GFP_KERNEL);
if(NULL == gm_cdevp){
unregister_chrdev_region(MKDEV(MAJOR_NR, 0), 2);
result = -ENOMEM;
}
memset(gm_cdevp, 0, 2*sizeof(struct gm_cdev_t));
gm_setup_cdev(&gm_cdevp[0], 0);
gm_setup_cdev(&gm_cdevp[0], 1);
//gm_setup_cdev(&gm_cdevp[1], 1); //使用这一行的话支持两个设备
cdev_class = class_create(THIS_MODULE, DEV_NAME);
if(IS_ERR(cdev_class))
return PTR_ERR(cdev_class);
device_create(cdev_class, NULL, MKDEV(MAJOR_NR, 0), NULL, DEV_NAME"%d", 0); //生成 /dev/gmem0 节点
device_create(cdev_class, NULL, MKDEV(MAJOR_NR, 1), NULL, DEV_NAME"%d", 1); //生成 /dev/gmem1 节点
return 0;
}
void gm_cdev_exit(void)
{
cdev_del(&gm_cdevp[0].cdev);
cdev_del(&gm_cdevp[0].cdev);
device_destroy(cdev_class, MKDEV(MAJOR_NR, 0)); //delete device node under /dev
device_destroy(cdev_class, MKDEV(MAJOR_NR, 1)); //delete device node under /dev
class_destroy(cdev_class); //delete class created by us
kfree(gm_cdevp);
unregister_chrdev_region(MKDEV(MAJOR_NR, 0), 2);
}

root@wang:/work/wanghuan/drives# ls

cdev.c cdev.ko hello.c Makefile modules.order

root@wang:/work/wanghuan/drives# insmod cdev.ko

root@wang:/work/wanghuan/drives# lsmod | grep cdev

cdev 1853 0

root@wang:/work/wanghuan/drives# ls /dev/gmem* -l

crw------- 1 root root 250, 0 2011-06-12 14:00 /dev/gmem0

crw------- 1 root root 250, 1 2011-06-12 14:00 /dev/gmem1

root@wang:/work/wanghuan/drives# ls > /dev/gmem0

root@wang:/work/wanghuan/drives# cat /dev/gmem1

cdev.c

cdev.ko

hello.c

Makefile

modules.order

下面的代码就是支持两个设备节点，但是两个设备节点支持不同的设备。

static struct class *cdev_class;
static int __init gm_cdev_init(void)
{
int result;
dev_t devno = MKDEV(MAJOR_NR, 0);
if(0 != MAJOR_NR){
result = register_chrdev_region(devno, 2, DEV_NAME); //注册设备支持两个设备，此设备号从0开始
} else {
result = alloc_chrdev_region(&devno, 0, 2, DEV_NAME);
MAJOR_NR = MAJOR(devno);
}
printk(KERN_CRIT"hello\n");
if(result < 0)
return result;
gm_cdevp = kmalloc(2*sizeof(struct gm_cdev_t), GFP_KERNEL);
if(NULL == gm_cdevp){
unregister_chrdev_region(MKDEV(MAJOR_NR, 0), 2);
result = -ENOMEM;
}
memset(gm_cdevp, 0, 2*sizeof(struct gm_cdev_t));
gm_setup_cdev(&gm_cdevp[0], 0);
//gm_setup_cdev(&gm_cdevp[0], 1);
gm_setup_cdev(&gm_cdevp[1], 1); //使用这一行的话支持两个设备
cdev_class = class_create(THIS_MODULE, DEV_NAME);
if(IS_ERR(cdev_class))
return PTR_ERR(cdev_class);
device_create(cdev_class, NULL, MKDEV(MAJOR_NR, 0), NULL, DEV_NAME"%d", 0); //生成 /dev/gmem0 节点
device_create(cdev_class, NULL, MKDEV(MAJOR_NR, 1), NULL, DEV_NAME"%d", 1); //生成 /dev/gmem1 节点
return 0;
}
void gm_cdev_exit(void)
{
cdev_del(&gm_cdevp[0].cdev);
cdev_del(&gm_cdevp[1].cdev);
device_destroy(cdev_class, MKDEV(MAJOR_NR, 0)); //delete device node under /dev
device_destroy(cdev_class, MKDEV(MAJOR_NR, 1)); //delete device node under /dev
class_destroy(cdev_class); //delete class created by us
kfree(gm_cdevp);
unregister_chrdev_region(MKDEV(MAJOR_NR, 0), 2);
}
root@wang:/work/wanghuan/drives# ls
cdev.c cdev.ko hello.c Makefile modules.order
root@wang:/work/wanghuan/drives# insmod cdev.ko
root@wang:/work/wanghuan/drives# lsmod | grep cdev
cdev 1853 0
root@wang:/work/wanghuan/drives# ls /dev/gmem* -l
crw------- 1 root root 250, 0 2011-06-12 14:08 /dev/gmem0
crw------- 1 root root 250, 1 2011-06-12 14:08 /dev/gmem1
root@wang:/work/wanghuan/drives# ls > /dev/gmem0
root@wang:/work/wanghuan/drives# cat /dev/gmem1
root@wang:/work/wanghuan/drives# cat /dev/gmem0
cdev.c
cdev.ko
hello.c
Makefile
modules.order
1. /**
2. * =====================================================================================
3. * Filename: cdev.c
4. * Description: 字符设备驱动模型
5. * Version: 1.0
6. * Created: 2011年06月02日 19时27分50秒
7. * Revision: none
8. * Compiler: gcc
9. *
10. * Author: wanghuan,
11. * Company:
12. * =====================================================================================
13. */
15. #include <linux/module.h>
16. #include <linux/types.h>
17. #include <linux/fs.h> /* file_operation */
18. #include <linux/errno.h> /* Error number */
19. #include <linux/mm.h>
20. #include <linux/sched.h>
21. #include <linux/slab.h>
22. #include <linux/init.h> /* __init __exit */
23. #include <linux/device.h>
24. #include <linux/cdev.h>
25. #include <asm/io.h>
26. #include <asm/system.h>
27. #include <asm/uaccess.h> /* copy_to_user, copy_from_user */
28. #include <linux/kernel.h> /* printk() */
30. #define GLOBALMEM_SIZE 0x1000
31. #define MEM_CLEAN 0x1
32. #define DEV_NAME "gmem"
33. #define MEM_CLEAR _IO(GLOBALMEM_SIZE, 0)
35. static int MAJOR_NR = 250; /* Driver Major Number */
36. //static int MINOR_NR = 0; /* Driver Major Number */
38. struct gm_cdev_t{
39. struct cdev cdev;
40. unsigned char mem[GLOBALMEM_SIZE];
41. };
42. static struct gm_cdev_t *gm_cdevp;
44. static int gm_open(struct inode *inode, struct file *filp)
45. {
46. struct gm_cdev_t *dev;
47. dev = container_of(inode->i_cdev, struct gm_cdev_t, cdev);
48. filp->private_data = dev;
49. return 0;
50. }
51. static int gm_release(struct inode *inode, struct file *filp)
52. {
53. filp->private_data = NULL;
54. return 0;
55. }
56. static ssize_t gm_read(struct file *filp, char __user *buf, size_t count, loff_t *fpos)
57. {
58. unsigned long p = *fpos;
59. int ret = 0;
61. struct gm_cdev_t *dev = filp->private_data;
62. if(p >= GLOBALMEM_SIZE)
63. return 0;
65. if(count > GLOBALMEM_SIZE - p)
66. count = GLOBALMEM_SIZE -p;
68. if(copy_to_user(buf, (void*)(dev->mem) + p, count))
69. ret = -EFAULT;
70. else{
71. *fpos +=count;
72. ret =count;
74. printk(KERN_INFO "read %d butes from %ld \n", count, p);
75. }
77. return ret;
78. }
80. static ssize_t gm_write(struct file *filp, const char __user *buf, size_t count, loff_t *fpos)
81. {
82. unsigned long p = *fpos;
83. int ret = 0;
85. struct gm_cdev_t *dev = filp->private_data;
86. if(p >= GLOBALMEM_SIZE)
87. return 0;
89. if(p >= GLOBALMEM_SIZE - p)
90. count = GLOBALMEM_SIZE - p;
92. if(copy_from_user(dev->mem + p, buf, count))
93. ret = - EFAULT;
94. else{
95. *fpos +=count;
96. ret = count;
98. printk(KERN_INFO "write %d butes from %ld \n", count, p);
99. }
101. return ret;
102. }
104. static loff_t gm_llseek(struct file *filp, loff_t offset, int orig)
105. {
106. loff_t ret;
107. switch(orig){
108. case 0:
109. if(offset < 0){
110. ret = -EFAULT;
111. break;
112. }
113. if((unsigned int)offset > GLOBALMEM_SIZE){
114. ret = -EFAULT;
115. break;
116. }
118. filp->f_pos = (unsigned int)offset;
119. ret = filp->f_pos;
120. break;
121. case 1:
122. if(filp->f_pos + offset > GLOBALMEM_SIZE){
123. ret = -EFAULT;
124. break;
125. }
127. if(filp->f_pos + offset < 0){
128. ret = -EFAULT;
129. break;
130. }
132. filp->f_pos += offset;
133. ret = filp->f_pos;
134. break;
135. default:
136. ret = -EFAULT;
137. }
138. return ret;
139. }
141. static int gm_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
142. {
143. struct gm_cdev_t *dev = filp->private_data;
144. switch(cmd){
145. case MEM_CLEAR:
146. memset(dev->mem, 0, GLOBALMEM_SIZE);
147. printk(KERN_INFO "globalmem is set to zero \n");
148. break;
149. default:
150. return -EINVAL;
151. }
153. return 0;
154. }
156. static const struct file_operations gm_fops = {
157. .owner = THIS_MODULE,
158. .open = gm_open,
159. .release = gm_release,
160. .read = gm_read,
161. .write = gm_write,
162. .ioctl = gm_ioctl,
163. .llseek = gm_llseek,
164. };
166. static void gm_setup_cdev(struct gm_cdev_t *gm_cdev, int minor)
167. {
168. int err;
169. dev_t devno = MKDEV(MAJOR_NR, minor);
171. cdev_init(&gm_cdev->cdev, &gm_fops);
172. gm_cdevp->cdev.owner = THIS_MODULE;
173. err = cdev_add(&gm_cdev->cdev, devno, 1);
174. if(err != 0)
175. printk(KERN_NOTICE "Error %d adding gmen", err);
176. }
178. static struct class *cdev_class;
179. static int __init gm_cdev_init(void)
180. {
181. int result;
182. dev_t devno = MKDEV(MAJOR_NR, 0);
184. if(0 != MAJOR_NR){
185. result = register_chrdev_region(devno, 2, DEV_NAME); //注册设备支持两个设备，此设备号从0开始
186. } else {
187. result = alloc_chrdev_region(&devno, 0, 2, DEV_NAME);
188. MAJOR_NR = MAJOR(devno);
189. }
191. printk(KERN_CRIT"hello\n");
192. if(result < 0)
193. return result;
195. gm_cdevp = kmalloc(2*sizeof(struct gm_cdev_t), GFP_KERNEL);
196. if(NULL == gm_cdevp){
197. unregister_chrdev_region(MKDEV(MAJOR_NR, 0), 2);
198. result = -ENOMEM;
199. }
201. memset(gm_cdevp, 0, 2*sizeof(struct gm_cdev_t));
202. gm_setup_cdev(&gm_cdevp[0], 0);
203. //gm_setup_cdev(&gm_cdevp[0], 1);
204. gm_setup_cdev(&gm_cdevp[1], 1);
206. cdev_class = class_create(THIS_MODULE, DEV_NAME);
207. if(IS_ERR(cdev_class))
208. return PTR_ERR(cdev_class);
210. device_create(cdev_class, NULL, MKDEV(MAJOR_NR, 0), NULL, DEV_NAME"%d", 0);
211. device_create(cdev_class, NULL, MKDEV(MAJOR_NR, 1), NULL, DEV_NAME"%d", 1);
212. return 0;
213. }
215. void gm_cdev_exit(void)
216. {
217. cdev_del(&gm_cdevp[0].cdev);
218. cdev_del(&gm_cdevp[1].cdev);
220. device_destroy(cdev_class, MKDEV(MAJOR_NR, 0)); //delete device node under /dev
221. device_destroy(cdev_class, MKDEV(MAJOR_NR, 1)); //delete device node under /dev
222. class_destroy(cdev_class); //delete class created by us
224. kfree(gm_cdevp);
225. unregister_chrdev_region(MKDEV(MAJOR_NR, 0), 2); //由于注册了两个设备，最后一个参数为 2
226. }
228. module_init(gm_cdev_init);
229. module_exit(gm_cdev_exit);
230. MODULE_LICENSE("GPL");
231. MODULE_AUTHOR("wanghuan");