Linux 设备驱动 ====> 字符驱动

开始从头学起linux 设备驱动，当然是先从字符驱动看起。

下面仿照着书上的例子，写了一个misc 字符驱动。

[cpp] view plaincopy

1. root@jay-LJ:/home/jay/globalmem# tree globalmem/  
2. globalmem/  
3. ├── globalmem.c  
4. └── Makefile  

首先咱来看下Makefile， 其实这东西都一个模子，

[cpp] view plaincopy

1. KVERS   =   $(shell uname -r)  
2.   
3. obj-m   +=  globalmem.o  
4.   
5. build:  kernel_modules  
6.   
7. kernel_modules:  
8.     make -C /lib/modules/$(KVERS)/build/ M=$(CURDIR) modules  
9.   
10. clean:  
11.     make -C /lib/modules/$(KVERS)/build/ M=$(CURDIR) clean  

然后是我们的驱动文件globalmem.c，我们从init函数看起

[cpp] view plaincopy

1. int globalmem_init(void)  
2. {  
3.     int result;  
4.     globalmem_devp = kmalloc(sizeof(struct globalmem_dev) ,GFP_KERNEL);  
5.     if(!globalmem_devp) {  
6.         result = -ENOMEM;  
7.         goto fail_malloc;  
8.     }  
9.     memset(globalmem_devp, 0, sizeof(struct globalmem_dev));  
10.       
11.     globalmem_devp->mdev = mdev_struct;  
12.   
13.     result = misc_register(&(globalmem_devp->mdev));  
14.     if(result<0)  
15.         return result;  
16.     else  
17.         return 0;  
18.   
19. fail_malloc:  
20.     return result;  
21. }  

首先是给我们的全局指针变量分配内存

[cpp] view plaincopy

1. globalmem_devp = kmalloc(sizeof(struct globalmem_dev) ,GFP_KERNEL);  
2. if(!globalmem_devp) {  
3.     result = -ENOMEM;  
4.     goto fail_malloc;  
5. }  
6. memset(globalmem_devp, 0, sizeof(struct globalmem_dev));  

看下这个指针的定义

[html] view plaincopy

1. struct globalmem_dev {  
2.     struct miscdevice mdev;  
3.     unsigned char mem[GLOBALMEM_SIZE];  
4. };  
5.   
6. struct globalmem_dev *globalmem_devp;  

globalmem_dev结构体中内嵌了一个miscdevice结构体，这个结构体就是描述我们的misc字符驱动的结构体，若想注册一个misc 字符设备就必须包含有这样一个结构体，

[cpp] view plaincopy

1. struct miscdevice  {  
2.     int minor;  
3.     const char *name;  
4.     const struct file_operations *fops;  
5.     struct list_head list;  
6.     struct device *parent;  
7.     struct device *this_device;  
8. };  

这个结构体描述了这个驱动的信息，包含次设备号， 文件操作结构体，驱动名称等。

内存分配结束之后是调用misc_register来注册我们的misc驱动，使用misc字符驱动相对于标准的字符驱动写起来简单。

然后是exit函数，跟init相反：

[cpp] view plaincopy

1. void globalmem_exit(void)  
2. {  
3.     misc_deregister(&(globalmem_devp->mdev));  
4.     if(globalmem_devp)  
5.         kfree(globalmem_devp);  
6. }  
7.   
8. module_init(globalmem_init);  
9. module_exit(globalmem_exit);  

千万别忘了最后要释放我们分配的内存。

然后使我们的miscdevice和fops结构体

[cpp] view plaincopy

1. static const struct file_operations globalmem_fops = {  
2.     .owner = THIS_MODULE,  
3.     .open = globalmem_open,  
4.     .release = globalmem_release,  
5.     .unlocked_ioctl = globalmem_ioctl,  
6.     .read = globalmem_read,  
7.     .write = globalmem_write,  
8. };  
9.   
10. static struct miscdevice mdev_struct = {  
11.     .minor = MISC_DYNAMIC_MINOR,  
12.     .name = "globalmem",  
13.     .fops = &globalmem_fops,  
14. };  

这里主要是这个file_operations接头体的定义，这里主要是把这个结构体中我们想要实现的读，写等方法与对应的回调函数挂钩起来。

然后就是我们的读写函数了

[cpp] view plaincopy

1. int globalmem_open(struct inode *inode, struct file *filp)  
2. {  
3.     printk(KERN_INFO "globalmem open!\n");  
4.     filp->private_data = globalmem_devp;   
5.     return 0;  
6. }  
7.   
8. int globalmem_release(struct inode *inode ,struct file *filp)  
9. {  
10.     printk(KERN_INFO "globalmem release!\n");  
11.     return 0;  
12. }  
13.   
14. static int globalmem_ioctl(struct inode *inode, struct file *filp,   
15.         unsigned int cmd, unsigned long arg)  
16. {  
17.     struct globalmem_dev *dev = filp->private_data;  //get global data pointer  
18.   
19.     switch(cmd) {  
20.         case    MEM_CLEAR:  
21.             memset(dev->mem, 0, GLOBALMEM_SIZE);  
22.             printk(KERN_INFO "clear globalmem!\n");\  
23.             break;  
24.   
25.         default:  
26.             return -EINVAL;  
27.     }  
28.   
29.     return 0;  
30. }  
31.   
32. static ssize_t globalmem_read(struct file *filp, char __user *buf,size_t size,  
33.         loff_t *ppos)  
34. {  
35.     unsigned long p = *ppos;  
36.     unsigned int count = size;  
37.     int ret = 0;  
38.     struct globalmem_dev *dev = filp->private_data;  //get global data pointer  
39.       
40.     if(p>=GLOBALMEM_SIZE)  
41.         return 0;  
42.     if(count > GLOBALMEM_SIZE-p)  
43.         count = GLOBALMEM_SIZE-p;  
44.   
45.     if(copy_to_user(buf, (void *)(dev->mem + p), count))   
46.         ret = -EFAULT;  
47.     else {  
48.         *ppos += count;  
49.         ret = count;  
50.           
51.         printk(KERN_INFO "read %u bytes(s) from %lu\n",count,p);  
52.     }  
53.   
54.     return ret;  
55. }  
56.   
57. static ssize_t globalmem_write(struct file *filp, const char __user *buf,  
58.         size_t size, loff_t *ppos)  
59. {  
60.     unsigned long p = *ppos;  
61.     unsigned int count = size;  
62.     int ret = 0;  
63.     struct globalmem_dev *dev = filp->private_data;  //get global data pointer  
64.   
65.     if(p >= GLOBALMEM_SIZE)  
66.         return 0;  
67.     if(count > GLOBALMEM_SIZE - p)  
68.         count = GLOBALMEM_SIZE - p;  
69.   
70.     if(copy_from_user(dev->mem+p, buf, count)) {  
71.         printk(KERN_INFO "copy from user error!!\n");  
72.         ret = -EFAULT;  
73.     }  
74.     else {  
75.         *ppos += count;  
76.         ret = count;  
77.         printk(KERN_INFO "written %u bytes(s) from %lu\n",count,p);  
78.     }  
79.   
80.     return ret;  
81. }  

我这里实现了open release write read四个方法，open方法很简单，把我们的自己定义的全局的结构体指针保存到我们驱动中的私有指针，这样的话，在我们别的方法中就可以直接用这个私有指针来获取我们的全局结构体指针，

[cpp] view plaincopy

1. filp->private_data = globalmem_devp;   

保存指针，

[cpp] view plaincopy

1. struct globalmem_dev *dev = filp->private_data;  //get global data p  

获取指针。

在我们的read/write中是与用户空间进行数据处理的过程，主要是调用了copy_from_user和copy_to_user这2个函数实现的，实现了从用户态到内核态的数据传递。

在应用层使用read/write来进行系统调用call到我们这边的read/write回调函数。

============================================================

接下来我们来测试一下我们的驱动，

编译

[cpp] view plaincopy

1. root@jay-LJ:/home/jay/globalmem/globalmem# make  
2. make -C /lib/modules/2.6.35-22-generic/build/ M=/home/jay/globalmem/globalmem modules  
3. make[1]: Entering directory `/usr/src/linux-headers-2.6.35-22-generic'  
4.   CC [M]  /home/jay/globalmem/globalmem/globalmem.o  
5. /home/jay/globalmem/globalmem/globalmem.c:110: warning: initialization from incompatible pointer type  
6.   Building modules, stage 2.  
7.   MODPOST 1 modules  
8.   CC      /home/jay/globalmem/globalmem/globalmem.mod.o  
9.   LD [M]  /home/jay/globalmem/globalmem/globalmem.ko  
10. make[1]: Leaving directory `/usr/src/linux-headers-2.6.35-22-generic'  

加载

insmod globalmem.ko

查看驱动

[plain] view plaincopy

1. root@jay-LJ:/home/jay/globalmem/globalmem# ls -l /dev/globalmem   
2. crw------- 1 root root 10, 53 2012-03-27 21:11 /dev/globalmem  

进行读写测试

[plain] view plaincopy

1. root@jay-LJ:/dev# chmod 666 globalmem   
2. root@jay-LJ:/dev# echo "Hello globalmem driver" > globalmem   
3. root@jay-LJ:/dev# cat globalmem   
4. Hello globalmem driver  
5. root@jay-LJ:/dev#   

当然了，我们也可以自己写一个测试的应用程序来测试我们的驱动。

结束。

转自http://blog.csdn.net/zhangjie201412