用mmap写Linux用户空间驱动

       

一、    mmap函数解析：

        函数原型：

#include <sys/mman.h>
void *mmap(void *start, size_t length，int prot， int flags，int fd，off_t offset)；
int munmap(void *start, size_t length)；

        函数功能：
mmap将一个文件或者其它对象映射进内存。文件被映射到多个页上，如果文件的大小不是所有页的大小之和，最后一个页不被使用的空间将会清零。munmap执行相反的操作，删除特定地址区域的对象映射。

        参数说明：

start：映射区的开始地址。
length：映射区的长度。
prot：期望的内存保护标志，不能与文件的打开模式冲突。是以下的某个值，可以通过or运算合理地组合在一起
PROT_EXEC //页内容可以被执行
PROT_READ  //页内容可以被读取
PROT_WRITE //页可以被写入
PROT_NONE  //页不可访问
flags：指定映射对象的类型，映射选项和映射页是否可以共享。它的值可以是一个或者多个以下位的组合体
MAP_FIXED //使用指定的映射起始地址，如果由start和len参数指定的内存区重叠于现存的映射空间，重叠部分将会被丢弃。如果指定的起始地址不可用，操作将会失败。并且起始地址必须落在页的边界上。
MAP_SHARED //与其它所有映射这个对象的进程共享映射空间。对共享区的写入，相当于输出到文件。直到msync()或者munmap()被调用，文件实际上不会被更新。
MAP_PRIVATE //建立一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件。这个标志和以上标志是互斥的，只能使用其中一个。
MAP_DENYWRITE //这个标志被忽略。
MAP_EXECUTABLE //同上
MAP_NORESERVE //不要为这个映射保留交换空间。当交换空间被保留，对映射区修改的可能会得到保证。当交换空间不被保留，同时内存不足，对映射区的修改会引起段违例信号。
MAP_LOCKED //锁定映射区的页面，从而防止页面被交换出内存。
MAP_GROWSDOWN //用于堆栈，告诉内核VM系统，映射区可以向下扩展。
MAP_ANONYMOUS //匿名映射，映射区不与任何文件关联。
MAP_ANON //MAP_ANONYMOUS的别称，不再被使用。
MAP_FILE //兼容标志，被忽略。
MAP_32BIT //将映射区放在进程地址空间的低2GB，MAP_FIXED指定时会被忽略。当前这个标志只在x86-64平台上得到支持。
MAP_POPULATE //为文件映射通过预读的方式准备好页表。随后对映射区的访问不会被页违例阻塞。
MAP_NONBLOCK //仅和MAP_POPULATE一起使用时才有意义。不执行预读，只为已存在于内存中的页面建立页表入口。
fd：有效的文件描述词。如果MAP_ANONYMOUS被设定，为了兼容问题，其值应为-1。
offset：被映射对象内容的起点。

        返回值说明：

成功执行时，mmap()返回被映射区的指针，munmap()返回0。失败时，mmap()返回MAP_FAILED[其值为(void *)-1]，munmap返回-1。errno被设为以下的某个值   
EACCES：访问出错
EAGAIN：文件已被锁定，或者太多的内存已被锁定
EBADF：fd不是有效的文件描述词
EINVAL：一个或者多个参数无效
ENFILE：已达到系统对打开文件的限制
ENODEV：指定文件所在的文件系统不支持内存映射
ENOMEM：内存不足，或者进程已超出最大内存映射数量
EPERM：权能不足，操作不允许
ETXTBSY：已写的方式打开文件，同时指定MAP_DENYWRITE标志
SIGSEGV：试着向只读区写入
SIGBUS：试着访问不属于进程的内存区

 

二、    Linux驱动程序的两种形式：

下面任然以AT91Sam9260系列ARM9开发板中对GPIO的控制为例进行讲解，Linux内核为2.6.19版本。

       内核层驱动：

遵循Linux内核关于各种硬件架构驱动的游戏规则编写，把驱动程序编译进内核或者编译为模块，这中方法符合驱动的底层含义，但需要程序员对Linux底层实现机制有一定了解，难度相对要大一些。下面的驱动实现对GPIO PB17的输出控制。

 

[cpp] view plaincopy

1. #include <linux/module.h>  
2. #include <linux/types.h>  
3. #include <linux/fs.h>  
4. #include <linux/types.h>  
5. #include <linux/kernel.h>  
6. #include <linux/init.h>  
7. #include <linux/platform_device.h>  
8. #include <linux/cdev.h>  
9. #include <linux/ioctl.h>  
10. #include <linux/gpio.h>  
11. #include <linux/errno.h>  
12. #include <asm/arch/hardware.h>  
13. #include <asm/arch/gpio.h>  
14. #include <asm/uaccess.h>  
15. #include <asm/io.h>  
16. #include <asm/hardware.h>  
17. #include <asm/arch/at91_pio.h>  
18.   
19.   
20. /*******************************************/  
21. void led_on(unsigned int led_num)  
22. {      
23.      at91_set_gpio_output(AT91_PIN_PB17 + led_num,1);  
24. }  
25.   
26. void led_off(unsigned int led_num)  
27. {      
28.      at91_set_gpio_output(AT91_PIN_PB17 + led_num,0);  
29. }  
30.   
31. struct light_dev  
32. {  
33.     struct cdev cdev;  
34.     unsigned char value;  
35. };  
36.   
37. struct light_dev *light_devp;  
38. int light_major = 249;  
39.   
40. MODULE_AUTHOR("Cun Tian Rui");  
41. MODULE_LICENSE("Dual BSD/GPL");  
42.   
43.   
44. int light_open(struct inode *inode,struct file *filp)  
45. {  
46.     struct light_dev *dev;  
47.     dev = container_of(inode->i_cdev,struct light_dev,cdev);  
48.     filp->private_data = dev;  
49.     return 0;  
50. }  
51.   
52. int light_release(struct inode *inode,struct file *filp)  
53. {  
54.     return 0;      
55. }  
56.   
57.   
58. // ioctl  
59. int light_ioctl(struct inode *inode,struct file *filp,unsigned int cmd,  
60. unsigned long arg)  
61. {  
62.     struct light_dev *dev = filp->private_data;  
63.   
64.     switch(cmd)  
65.     {  
66.         case 0:  
67.             dev->value = 0;  
68.             led_on(arg);           
69.         break;  
70.   
71.         case 1:  
72.             dev->value = 1;  
73.             led_off(arg);  
74.         break;  
75.   
76.         default:  
77.   
78.             return -ENOTTY;  
79.         // break;  
80.     }  
81.   
82.     return 0;  
83. }       
84.   
85. struct file_operations light_fops =   
86. {  
87.     .owner = THIS_MODULE,  
88.     .ioctl = light_ioctl,  
89.     .open  = light_open,  
90.     .release = light_release,  
91. };  
92.   
93.   
94. static void light_setup_cdev(struct light_dev *dev,int index)  
95. {  
96.     int err,devno = MKDEV(light_major,index);  
97.   
98.     cdev_init(&dev->cdev,&light_fops);  
99.     dev->cdev.owner = THIS_MODULE;  
100.     dev->cdev.ops = &light_fops;  
101.   
102.     err = cdev_add(&dev->cdev,devno,1);  
103.   
104.     if(err)  
105.     {  
106.         printk(KERN_NOTICE "Error %d adding LED%d",err,index);  
107.     }  
108. }  
109.   
110.   
111. int light_init(void)  
112. {  
113.     int result;  
114.   
115.     dev_t dev = MKDEV(light_major,0);  
116.     if(light_major)  
117.     {  
118.           
119.         result = register_chrdev_region(dev,1,"CTRLED");  
120.     }  
121.   
122.     if(result < 0)  
123.     {  
124.         return result;  
125.     }  
126.   
127.     light_devp = kmalloc(sizeof(struct light_dev),GFP_KERNEL);  
128.     if(!light_devp)  
129.     {  
130.         result = - ENOMEM;  
131.         goto fail_malloc;  
132.     }  
133.   
134.     memset(light_devp,0,sizeof(struct light_dev));  
135.     light_setup_cdev(light_devp,0);  
136.       
137.   
138.     return 0;  
139.   
140.     fail_malloc:unregister_chrdev_region(dev,light_devp);  
141.     return result;  
142.       
143. }  
144.   
145. void light_cleanup(void)  
146. {  
147.     cdev_del(&light_devp->cdev);     
148.     kfree(light_devp);  
149.     unregister_chrdev_region(MKDEV(light_major,0),1);    
150. }  
151.   
152. module_init(light_init);  
153. module_exit(light_cleanup);  

 

        用户空间驱动：

这种方式使用mmap函数将硬件地址映射到进程空间，从而可以在用户层通过指针操作映射后的地址，从而控制硬件，绕过了内核实现，避开了read，write等函数调用。

 

[cpp] view plaincopy

1. #include <sys/types.h>  
2. #include <stdio.h>  
3. #include <sys/ioctl.h>  
4. #include <sys/mman.h>  
5. #include <fcntl.h>  
6. #include <memory.h>  
7.   
8. #define PIOB_Base 0xFFFFF600  
9. #define PIOB_PER  0x0  
10. #define PIOB_OER  0x10  
11. #define PIOB_CODR 0x34  
12. #define PIOB_SODR 0x30  
13.   
14.   
15.   
16. volatile unsigned int *map_base=NULL;  
17. volatile unsigned int *SODR =NULL;   
18. volatile unsigned int *CODR =NULL;  
19. int fd;  
20.   
21.   
22. int main(int argc ,char *argv[])  
23. {  
24.    int state;  
25.    fd = open("/dev/mem", O_RDWR|O_SYNC) ;  
26.    if(fd == -1) return -1;  
27.    map_base=(volatile unsigned int*)mmap(NULL,0x200,PROT_READ|PROT_WRITE,MAP_SHARED,fd,PIOB_Base);  
28.    if(map_base==NULL || map_base ==MAP_FAILED)  
29.     printf("Can't mmap/n");  
30.    else printf(" mmap success/n");  
31.    SODR = (volatile unsigned int*)(map_base+PIOB_SODR);  
32.    CODR = (volatile unsigned int*)(map_base+PIOB_CODR);  
33.    *(volatile unsigned int*)(map_base+PIOB_PER)|= 1<<17;  
34.    *(volatile unsigned int*)(map_base+PIOB_OER)|= 1<<17;  
35.    while(1)  
36.     {  
37.     printf("please input 1 or 0/n");  
38.     scanf("%d",&state);  
39.         if(state)  
40.        *(volatile unsigned int*)SODR= (1<<17);  
41.     else  
42.            *(volatile unsigned int*)CODR = (1<<17);  
43.     }  
44.    close(fd);  
45.    munmap((void*)map_base,0xff);   
46.    return 0;  
47. }  

三、    用户空间驱动的优缺点：

从上面的例子可以看到，用户空间驱动避开了内核复杂的实现机制，似乎更简单，那为什么硬件驱动不都在用户层面完成呢？有时编写一个所谓的用户空间设备驱动对比钻研内核是一个明智的选择。但为什么事实上多数情况下使用的是内核层面的驱动。

        用户空间驱动的优点：

2       完整的 C 库可以连接. 驱动可以进行许多奇怪的任务, 不用依靠外面的程序(实现使用策略的工具程序, 常常随着驱动自身发布)；

2       程序员可以在驱动代码上运行常用的调试器, 而不必走调试一个运行中的内核的弯路；

2       如果一个用户空间驱动挂起了, 你可简单地杀掉它. 驱动的问题不可能挂起整个系统, 除非被控制的硬件真的疯掉了；

2       用户内存是可交换的, 不象内核内存. 一个不常使用的却有很大一个驱动的设备不会占据别的程序可以用到的 RAM, 除了在它实际在用时；

2       一个精心设计的驱动程序仍然可以, 如同内核空间驱动, 允许对设备的并行存取；

2       如果你必须编写一个封闭源码的驱动, 用户空间的选项使你容易避免不明朗的许可的情况和改变的内核接口带来的问题；

2       一种在用户空间工作的情况可能是有意义的, 当你开始处理新的没有用过的硬件时. 这样你可以学习去管理你的硬件, 不必担心挂起整个系统. 一旦你完成了, 在一个内核模块中封装软件就会是一个简单操作了。

       用户空间驱动的缺点：

2     中断在用户空间无法用. 在某些平台上有对这个限制的解决方法, 例如在 IA32体系上的 vm86 系统调用；

2     只可能通过内存映射 /dev/mem 来使用 DMA, 而且只有特权用户可以这样做；

2     存取 I/O 端口只能在调用 ioperm 或者 iopl 之后. 此外，不是所有的平台支持这些系统调用, 而存取/dev/port可能太慢而无效率. 这些系统调用和设备文件都要求特权用户；

2     响应时间慢, 因为需要上下文切换在客户和硬件之间传递信息或动作；

2     更不好的是，如果驱动已被交换到硬盘, 响应时间会长到不可接受。 使用 mlock 系统调用可能会有帮助，但是常常的你将需要锁住许多内存页, 因为一个用户空间程序依赖大量的库代码. mlock, 也, 限制在授权用户上。最重要的设备不能在用户空间处理, 包括但不限于, 网络接口和块设备。

 

    下面来看在前面的基础上加上中断的情况，由于用户空间不能操作中断，所以只能使用内核驱动，下面贴出代码，具体解析我在《GPIO中断程序》一文中有讲述，此处不再赘述。

[cpp] view plaincopy

1. /* 
2.  * PB18_IRQTest.c 
3.  * This is  a test program for sam9260, using PB19(J5_18 pin) input a signal to PB18(J5_16 pin), 
4.  * PB18 receive this signal as IRQ and make the LED linking on PB17((J5_14 pin)) turn on or turn off    
5.  * 
6.  *           @Author: Cun Tian Rui  
7.  *           @Date :March.18.2011 
8.  */  
9.   
10. #include <linux/types.h>  
11. #include <linux/kernel.h>  
12. #include <linux/module.h>  
13. #include <linux/init.h>  
14. #include <linux/platform_device.h>  
15. #include <linux/cdev.h>  
16. #include <linux/ioctl.h>  
17. #include <linux/fs.h>  
18. #include <linux/gpio.h>  
19. #include <asm/arch/hardware.h>  
20. #include <asm/arch/gpio.h>  
21. #include <linux/interrupt.h>  
22. #include <asm/io.h>  
23. #include <asm/arch/board.h>  
24. #include <linux/cdev.h>  
25. #include <asm/arch/gpio.h>  
26. #include <asm/uaccess.h>  
27. #include <asm/io.h>  
28. #include <asm/arch/at91_pio.h>  
29. #include <asm/arch/at91_aic.h>  
30. #include <asm/arch/at91_pmc.h>  
31.   
32. void led_on()  
33. {      
34.      at91_set_gpio_output(AT91_PIN_PB17,1);  
35. }  
36.   
37. void led_off()  
38. {      
39.      at91_set_gpio_output(AT91_PIN_PB17 ,0);  
40. }  
41.   
42. struct light_dev *light_devp;  
43. int light_major = 200;  
44.   
45. struct light_dev  
46. {  
47.     struct cdev cdev;  
48.     unsigned char value;  
49. };  
50.   
51. MODULE_AUTHOR("Cun Tian Rui");  
52. MODULE_LICENSE("Dual BSD/GPL");  
53.   
54.   
55. static void io_init(void)  
56. {  
57.     at91_set_gpio_input(AT91_PIN_PB18, 1);          
58.     at91_set_deglitch(AT91_PIN_PB18, 1);   
59.     at91_sys_write(1 + PIO_IDR,  1<<18);  
60.     at91_sys_write(1 + PIO_IER,  (~(1<<18)));  
61.     at91_sys_write(AT91_PMC_PCER, 1 << 3);  
62. }  
63.   
64.   
65. struct gpio_irq_desc  
66. {  
67.     int irq;  
68.     unsigned long flags;  
69.     char *name;  
70. };  
71.   
72. static struct gpio_irq_desc PB18_IRQ={AT91_PIN_PB18,AT91_AIC_SRCTYPE_LOW,"PB18"};  
73.   
74. static irqreturn_t PB18_intHandle(int irq, void *dev_id)  
75. {  
76.     led_on();  
77.     return IRQ_RETVAL(IRQ_HANDLED);  
78. }  
79.   
80. int light_open(struct inode *inode,struct file *filp)  
81. {  
82.     int err;  
83.     struct light_dev *dev;  
84.     dev = container_of(inode->i_cdev,struct light_dev,cdev);  
85.     filp->private_data = dev;  
86.     io_init();  
87.     err = request_irq(PB18_IRQ.irq,PB18_intHandle,PB18_IRQ.flags,PB18_IRQ.name,(void*)0);  
88.     if(err)   
89.         {  
90.         free_irq(PB18_IRQ.irq,(void*)0);  
91.         return  -EBUSY;  
92.     }  
93.       
94.     return 0;  
95. }  
96.   
97. int light_release(struct inode *inode,struct file *filp)  
98. {  
99.     free_irq(PB18_IRQ.irq,(void*)0);  
100.     return 0;      
101. }  
102.   
103.   
104.   
105. // ioctl  
106. int light_ioctl(struct inode *inode,struct file *filp,unsigned int cmd,  
107. unsigned long arg)  
108. {  
109.     struct light_dev *dev = filp->private_data;  
110.   
111.     switch(cmd)  
112.     {  
113.         case 0:  
114.             at91_set_gpio_output(AT91_PIN_PB19,0);       
115.         break;  
116.   
117.         case 1:  
118.           at91_set_gpio_output(AT91_PIN_PB19,1);  
119.        led_off();  
120.         break;  
121.   
122.         default:  
123.   
124.             return -ENOTTY;  
125.         // break;  
126.     }  
127.   
128.     return 0;  
129. }       
130.   
131. struct file_operations light_fops =   
132. {  
133.     .owner = THIS_MODULE,  
134.     .ioctl = light_ioctl,  
135.     .open  = light_open,  
136.     .release = light_release,  
137. };  
138.   
139.   
140. static void light_setup_cdev(struct light_dev *dev,int index)  
141. {  
142.     int err,devno = MKDEV(light_major,index);  
143.   
144.     cdev_init(&dev->cdev,&light_fops);  
145.     dev->cdev.owner = THIS_MODULE;  
146.     dev->cdev.ops = &light_fops;  
147.   
148.     err = cdev_add(&dev->cdev,devno,1);  
149.   
150.     if(err)  
151.     {  
152.         printk(KERN_NOTICE "Error %d adding LED%d",err,index);  
153.     }  
154. }  
155.   
156.   
157. int light_init(void)  
158. {  
159.     int result;  
160.   
161.     dev_t dev = MKDEV(light_major,0);  
162.     if(light_major)  
163.     {  
164.           
165.         result = register_chrdev_region(dev,1,"PB18_IRQTest");  
166.     }  
167.   
168.     if(result < 0)  
169.     {  
170.         return result;  
171.     }  
172.   
173.     light_devp = kmalloc(sizeof(struct light_dev),GFP_KERNEL);  
174.     if(!light_devp)  
175.     {  
176.         result = - ENOMEM;  
177.         goto fail_malloc;  
178.     }  
179.   
180.     memset(light_devp,0,sizeof(struct light_dev));  
181.     light_setup_cdev(light_devp,0);  
182.       
183.   
184.     return 0;  
185.   
186.     fail_malloc:unregister_chrdev_region(dev,light_devp);  
187.     return result;  
188.       
189. }  
190.   
191. void light_cleanup(void)  
192. {  
193.     cdev_del(&light_devp->cdev);     
194.     kfree(light_devp);  
195.     unregister_chrdev_region(MKDEV(light_major,0),1);    
196. }  
197.   
198. module_init(light_init);  
199. module_exit(light_cleanup);  

 

最后给出自己写的一个在用户层读写AT91sam9260SDRAM某一个位置的小程序结束本文。

[cpp] view plaincopy

1. #include <stdio.h>  
2. #include <unistd.h>  
3. #include <sys/mman.h>  
4. #include <sys/types.h>  
5. #include <sys/stat.h>  
6. #include <fcntl.h>  
7.   
8. #define SDRAM_PHY_Position 0x20800000  
9. int main (int args, char* arg[])  
10. {  
11. int i;  
12. int fd;  
13. char* mem;  
14. char *buff = "HELLO";  
15. //open /dev/mem with read and write mode  
16. if ((fd = open ("/dev/mem", O_RDWR)) < 0)      
17. {      
18.        perror ("open error");  
19.        return -1;  
20. }      
21. //map physical memory 0-10 bytes   
22. mem = mmap (0, 10, PROT_READ | PROT_WRITE, MAP_SHARED, fd, SDRAM_PHY_Position);  
23. if (mem == MAP_FAILED) {  
24. perror ("mmap error:");  
25. return 1;  
26. }  
27. //Read old value  
28. for (i = 0; i < 5; i++)   
29. {  
30.        printf("/nold mem[%d]:%d", i, mem[i]);   
31. }  
32. //write memory  
33. memcpy(mem, buff, 5);  
34. //Read new value  
35. for (i = 0; i<5 ; i++)  
36. {  
37.        printf("/nnew mem[%d]:%c", i, mem[i]);  
38. }  
39. printf("/n");  
40. munmap (mem, 10); //destroy map memory  
41.    close (fd);   //close file  
42.    return 0;  
43. }