字符驱动学习

chituhuan

    写完第一个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.  */
    
14. 
    
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() */
    
29. 
    
30. #define GLOBALMEM_SIZE 0x1000
    
31. #define MEM_CLEAN 0x1
    
32. #define DEV_NAME "gmem"
    
33. #define MEM_CLEAR _IO(GLOBALMEM_SIZE, 0)
    
34. 
    
35. static int MAJOR_NR = 250;        /* Driver Major Number */
    
36. //static int MINOR_NR = 0;        /* Driver Major Number */
    
37. 
    
38. struct gm_cdev_t{
    
39.     struct cdev cdev;
    
40.     unsigned char mem[GLOBALMEM_SIZE];
    
41. };
    
42. static struct gm_cdev_t *gm_cdevp;
    
43. 
    
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;
    
60.     
    
61.     struct gm_cdev_t *dev = filp->private_data;
    
62.     if(p >= GLOBALMEM_SIZE)
    
63.         return 0;
    
64. 
    
65.     if(count > GLOBALMEM_SIZE - p)
    
66.         count = GLOBALMEM_SIZE -p;
    
67. 
    
68.     if(copy_to_user(buf, (void*)(dev->mem) + p, count))
    
69.         ret = -EFAULT;
    
70.     else{
    
71.         *fpos +=count;
    
72.         ret =count;
    
73. 
    
74.         printk(KERN_INFO "read %d butes from %ld \n", count, p);
    
75.     }
    
76. 
    
77.     return ret;
    
78. }
    
79. 
    
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;
    
84. 
    
85.     struct gm_cdev_t *dev = filp->private_data;
    
86.     if(p >= GLOBALMEM_SIZE)
    
87.      return 0;
    
88.     
    
89.     if(p >= GLOBALMEM_SIZE - p)
    
90.         count = GLOBALMEM_SIZE - p;
    
91. 
    
92.     if(copy_from_user(dev->mem + p, buf, count))
    
93.         ret = - EFAULT;
    
94.     else{
    
95.         *fpos +=count;
    
96.         ret = count;
    
97. 
    
98.         printk(KERN_INFO "write %d butes from %ld \n", count, p);
    
99.     }
    
100. 
     
101.     return ret;
     
102. }
     
103. 
     
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.             }
     
117. 
     
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.             }
     
126. 
     
127.             if(filp->f_pos + offset < 0){
     
128.                 ret = -EFAULT;
     
129.                 break;
     
130.             }
     
131. 
     
132.             filp->f_pos += offset;
     
133.             ret = filp->f_pos;
     
134.             break;
     
135.         default:
     
136.             ret = -EFAULT;
     
137.     }
     
138.     return ret;
     
139. }
     
140. 
     
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.     }
     
152. 
     
153.     return 0;
     
154. }
     
155. 
     
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. };
     
165. 
     
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);
     
170.     
     
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. }
     
177. 
     
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);
     
183. 
     
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.     }
     
190. 
     
191.     printk(KERN_CRIT"hello\n");
     
192.     if(result < 0)
     
193.         return result;
     
194. 
     
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.     }
     
200. 
     
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);
     
205. 
     
206.     cdev_class = class_create(THIS_MODULE, DEV_NAME);
     
207.     if(IS_ERR(cdev_class))
     
208.         return PTR_ERR(cdev_class);
     
209. 
     
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. }
     
214. 
     
215. void gm_cdev_exit(void)
     
216. {
     
217.     cdev_del(&gm_cdevp[0].cdev);
     
218.     cdev_del(&gm_cdevp[1].cdev);
     
219. 
     
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
     
223. 
     
224.     kfree(gm_cdevp);
     
225.     unregister_chrdev_region(MKDEV(MAJOR_NR, 0), 2); //由于注册了两个设备，最后一个参数为 2
     
226. }
     
227. 
     
228. module_init(gm_cdev_init);
     
229. module_exit(gm_cdev_exit);
     
230. MODULE_LICENSE("GPL");
     
231. MODULE_AUTHOR("wanghuan");