首页 / 操作系统 / Linux / Linux 设备驱动 ====> 字符驱动

开始从头学起linux 设备驱动，当然是先从字符驱动看起。相关阅读：Linux 设备驱动 ====> 并发控制 --- 原子操作 http://www.linuxidc.com/Linux/2012-03/57580.htm下面仿照着书上的例子，写了一个misc 字符驱动。

1. root@www.linuxidc.com:/home/jay/globalmem# tree globalmem/  
2. globalmem/  
3. ├── globalmem.c  
4. └── Makefile  

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

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函数看起

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

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

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））;  

看下这个指针的定义

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 字符设备就必须包含有这样一个结构体，

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相反：

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结构体

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