Linux内核访问外设I O资源的方式

我就是我 2022-03-26 17:49 229阅读 0赞

[http://blog.csdn.net/woshixingaaa/archive/2011/05/15/6421954.aspx][http_blog.csdn.net_woshixingaaa_archive_2011_05_15_6421954.aspx]    
首先介绍一下I/O端口和I/O内存。

1. I/O端口：当一个寄存器或内存位于I/O空间时，称其为I/O端口。

2. I/O内存：当一个寄存器或内存位于内存空间时，称其为I/O内存。

再来看一下I/O寄存器和常规内存的区别：I/O寄存器具有边际效应（side effect），而内存操作则没有,内存写操作的唯一结果就是在指定位置存贮一个数值；内存读操作则仅仅是返回指定位置最后一次写入的数值。何为边际效应呢？就是读取某个地址时可能导致该地址内容发生变化。比如很多设备的中断状态寄存器只要一读取，便自动清零。

现在来看一看如何在Linux驱动程序中使用I/O端口和I/O内存。

使用I/O端口的步骤：

1.  申请

2.  访问

3.  释放

申请I/O端口：

在尚未对这些端口进行申请之前我们是不应该对这些端口进行操作的。内核为我们提供了一个注册用的接口：

1.  \#include <linux/ioport.h>  
2.  **struct** resource \*request\_region(unsigned **long** first, unsigned **long** n, **const** **char** \*name);

这个函数告诉内核，我们要使用起始于first的n个端口，参数name应该是设备的名称。如果分配成功，则返回非NULL。如果request\_region返回NULL，那么我们就不能使用这些期望的端口。

访问I/O端口：

访问I/O端口时，多数硬件都会把8位，16位和32位的端口区分开。因此，C语言程序中必须调用不同的函数来访问大小不同的端口。

1.  unsigned inb(unsigned port);  
2.  **void** outb(unsigned **char** **byte**, unsigned port);

字节（ 8 位宽度）读写端口。

1.  unsigned inw(unsigned port);  
2.  **void** outw(unsigned **short** word, unsigned port);

读写 16 位端口。

1.  unsigned inl(unsigned port);  
2.  **void** outl(unsigned longword, unsigned port);

读写32位端口。

释放I/O端口：

如果不在使用某组I/O端口（可能在卸载模块时），则应该使用下面的函数将这些端口返回给系统：  
**void** release\_region(unsigned **long** start, unsigned **long** n);

使用I/O内存的步骤：

1. 申请

2. 映射

3. 访问

4. 释放

根据计算机平台和所使用总线的不同，I/O内存可能是，也可能不是通过页表访问的。如果访问是经由页表进行的，内核必须首先安排物理地址使其对设备驱动程序可见（这通常意味着在进行任何I/O之前必须先调用ioremap）。如果访问无需页表，那么I/O内存区域就非常类似于I/O端口，可以使用适当形式的函数读写它们。

I/O内存申请：  
**struct** resource \*request\_mem\_region(unsigned **long** start, unsigned **long** len, **char** \*name);

该函数从start开始分配len字节长的内存区域。如果成功，返回非NULL指针；否则返回NULL值。

I/O内存映射：

1.  \#include<asm/io.h>  
2.  **void** \*ioremap(unsigned **long** phys\_addr, unsigned **long** size);

把物理地址转化成虚拟地址，返回值是虚拟地址。  
 **void**  \*iounmap( **void**  \*addr);

解除映射。

I/O内存访问：

从内存中读取：

1.  unsigned **int** ioread8(**void** \*addr);  
2.  unsigned **int** ioread16(**void** \*addr);  
3.  unsigned **int** ioread32(**void** \*addr);

其中addr应该是从ioremap获得的地址。

还有一组写入I/O内存类似函数：

1.  **void** iowrite8(u8 value, **void** \*addr);   
2.  **void** iowrite16(u16 value, **void** \*addr);  
3.  **void** iowrite32(u32 value, **void** \*addr);

I/O 内存释放：  
**void**  release\_mem\_region(unsigned  **long**  start, unsigned  **long**  len);     
 像 I/O 内存一样使用 I/O 端口：  
**void**  \*ioport\_map(unsigned  **long**  port, unsigned  **int**  count);

该函数重新映射count个I/O端口，使其看起来像I/O内存。此后，驱动程序可在该函数返回的地址上使用ioread8及其同类的函数。

当不再需要这种映射时，需要调用下面的函数来撤销：  
**void** ioport\_unmap(**void** \*addr);

上边的是基础知识。

在我们的开发板上内存映射分3个层次（下边的所有内核代码使用的是linux3.6.30.4）：

1.开发板的层次

如：声卡，网卡和开发板相关的部分

2.最小系统的层次

系统必须的几个，如GPIO,IRQ,MEMCTRL,UART。

3.其他系统的层次

不影响开机的部分，如USB,LCD,ADC。

开发板mapio的初始化：

smdk2440\_map\_io函数中会调用：

1.  **static** **struct** map\_desc smdk2440\_iodesc\[\] \_\_initdata = \{  
2.      /\* ISA IO Space map (memory space selected by A24) \*/  
3.      \{  
4.          .**virtual**    = (u32)S3C24XX\_VA\_ISA\_WORD,  
5.          .pfn        = \_\_phys\_to\_pfn(S3C2410\_CS2),  
6.          .length     = 0x10000,  
7.          .type       = MT\_DEVICE,  
8.      \}, \{  
9.          .**virtual**    = (u32)S3C24XX\_VA\_ISA\_WORD + 0x10000,  
10.         .pfn        = \_\_phys\_to\_pfn(S3C2410\_CS2 + (1<<24)),  
11.         .length     = SZ\_4M,  
12.         .type       = MT\_DEVICE,  
13.     \}, \{  
14.         .**virtual**    = (u32)S3C24XX\_VA\_ISA\_BYTE,  
15.         .pfn        = \_\_phys\_to\_pfn(S3C2410\_CS2),  
16.         .length     = 0x10000,  
17.         .type       = MT\_DEVICE,  
18.     \}, \{  
19.         .**virtual**    = (u32)S3C24XX\_VA\_ISA\_BYTE + 0x10000,  
20.         .pfn        = \_\_phys\_to\_pfn(S3C2410\_CS2 + (1<<24)),  
21.         .length     = SZ\_4M,  
22.         .type       = MT\_DEVICE,  
23.     \},\{  
24.         .**virtual**    = (u32)S3C2410\_ADDR(0x07600000),  
25.         .pfn        = \_\_phys\_to\_pfn(0x40000000),  
26.         .length     =SZ\_4K,  
27.         .type       = MT\_DEVICE,  
28.     \}  
29. \};

最小系统IO初始化：

s3c24xx\_init\_io函数会调用：

1.  iotable\_init(s3c\_iodesc,ARRAY\_SIZE(s3c\_iodesc));  
2.  /\* minimal IO mapping \*/  
3.  **static** **struct** map\_desc s3c\_iodesc\[\] \_\_initdata = \{  
4.      IODESC\_ENT(GPIO),  
5.      IODESC\_ENT(IRQ),  
6.      IODESC\_ENT(MEMCTRL),  
7.      IODESC\_ENT(UART)  
8.  \};

这个部分是系统启动必须的映射。后续会调用（ cpu->map\_io ） (mach\_desc,size) ；来完成其他映射。这个函数会调用：

1.  Iotable\_init(s3c2440\_iodesc,ARRAY\_SIZE(s3c2440\_iodesc));  
2.  /\* Initial IO mappings \*/  
3.  **static** **struct** map\_desc s3c2410\_iodesc\[\] \_\_initdata = \{  
4.      IODESC\_ENT(CLKPWR),  
5.      IODESC\_ENT(TIMER),  
6.      IODESC\_ENT(WATCHDOG),  
7.  \};

所以，如果新添加一个驱动，首先要看是否完成了IO映射，如果没有的话，就在开发板部分加入。Linux内核访问外设I/O资源的方式有两种：动态映射和静态映射(map\_desc)。

动态映射方式上边已经讲述，这里着重讲述静态映射——通过map\_desc结构静态创建I/O资源映射表。内核提供了在系统启动时通过map\_desc结构体静态创建I/O资源到内核地址空间的线性映射表（即page table）的方式。这种映射表是一种一一映射的关系。程序员可以自己定义该I/O内存资源映射后的虚拟地址。创建好静态映射表，在内核或驱动中访问该I/O资源时则无需再进行ioremap动态映射，可以直接通过映射后的I/O虚拟地址去访问。下面详细分析这种机制的原理并举例说明如何通过这种静态映射的方式访问外设I/O内存资源。

内核提供了一个重要的结构体struct machine\_desc，这个结构体在内核移植中起到相当重要的作用，内核通过machine\_desc结构体来控制系统体系架构相关部分的初始化。machine\_desc结构体包含了体系结构相关部分的几个重要成员的初始化函数，包括map\_io,init\_irq,init\_machine以及phys\_io，timer成员等。

machine\_desc结构体定义如下：

1.  **struct** machine\_desc \{  
2.      /\* 
3.       \* Note! The first four elements are used 
4.       \* by assembler code in head.S, head-common.S 
5.       \*/  
6.      unsigned **int**        nr;     /\* architecture number  \*/  
7.      unsigned **int**        phys\_io;    /\* start of physical io \*/  
8.      unsigned **int**        io\_pg\_offst;    /\* byte offset for io  
9.                           \* page tabe entry  \*/  
10.     **const** **char**      \*name;      /\* architecture name    \*/  
11.     unsigned **long**       boot\_params;    /\* tagged list      \*/  
12.     unsigned **int**        video\_start;    /\* start of video RAM   \*/  
13.     unsigned **int**        video\_end;  /\* end of video RAM \*/  
14.     unsigned **int**        reserve\_lp0 :1; /\* never has lp0    \*/  
15.     unsigned **int**        reserve\_lp1 :1; /\* never has lp1    \*/  
16.     unsigned **int**        reserve\_lp2 :1; /\* never has lp2    \*/  
17.     unsigned **int**        soft\_reboot :1; /\* soft reboot      \*/  
18.     **void**            (\*fixup)(**struct** machine\_desc \*,  
19.                      **struct** tag \*, **char** \*\*,  
20.                      **struct** meminfo \*);  
21.     **void**            (\*map\_io)(**void**);/\* IO mapping function  \*/  
22.     **void**            (\*init\_irq)(**void**);  
23.     **struct** sys\_timer    \*timer;     /\* system tick timer    \*/  
24.     **void**            (\*init\_machine)(**void**);  
25. \};

这里的map\_io成员即内核提供给用户的创建外设I/O资源到内核虚拟地址静态映射表的接口函数。map\_io成员函数会在系统初始化过程中被调用，流程如下：

start\_kernel->setup\_arch()->paging\_init()->devicemaps\_init()中被调用。

machine\_desc结构体通过MACHINE\_START宏来初始化。

1.  MACHINE\_START定义在arch/arm/include/asm/mach/arch.h中  
2.  /\* 
3.   \* Set of macros to define architecture features.  This is built into 
4.   \* a table by the linker. 
5.   \*/  
6.  \#define MACHINE\_START(\_type,\_name)          /  
7.  **static** **const** **struct** machine\_desc \_\_mach\_desc\_\#\#\_type    /  
8.   \_\_used                         /  
9.   \_\_attribute\_\_((\_\_section\_\_(".arch.info.init"))) = \{    /  
10.     .nr     = MACH\_TYPE\_\#\#\_type,        /  
11.     .name       = \_name,  
12. \#define MACHINE\_END             /  
13. \};

用户可以在定义 machine\_desc 结构时指定 map\_io 的接口函数。 s3c2410 machine\_desc 结构体如下定义：

1.  MACHINE\_START(S3C2440, "SMDK2440")  
2.      /\* Maintainer: Ben Dooks <ben@fluff.org> \*/  
3.      .phys\_io    = S3C2410\_PA\_UART,  
4.      .io\_pg\_offst    = (((u32)S3C24XX\_VA\_UART) >> 18) & 0xfffc,  
5.      .boot\_params    = S3C2410\_SDRAM\_PA + 0x100,  
6.      .init\_irq   = s3c24xx\_init\_irq,  
7.      .map\_io     = smdk2440\_map\_io,  
8.      .init\_machine   = smdk2440\_machine\_init,  
9.      .timer      = &s3c24xx\_timer,  
10. MACHINE\_END

展开后的结果是：

1.  **static** **const** **struct** machine\_desc \_\_mach\_desc\_SMDK2410  
2.   \_\_attribute\_used\_\_  
3.   \_\_attribute\_\_((\_\_section\_\_(".arch.info.init"))) = \{  
4.   .nr = MACH\_TYPE\_SMDK2410, /\* architecture number \*/  
5.   .name = "SMDK2410", /\* architecture name \*/  
6.   /\* Maintainer: Jonas Dietsche \*/  
7.   .phys\_io = S3C2410\_PA\_UART, /\* start of physical io \*/  
8.   .io\_pg\_offst = (((u32)S3C24XX\_VA\_UART) >> 18) & 0xfffc,  
9.   .boot\_params = S3C2410\_SDRAM\_PA + 0x100, /\* tagged list \*/  
10.  .map\_io = smdk2410\_map\_io, /\* IO mapping function \*/  
11.  .init\_irq = s3c24xx\_init\_irq,  
12.  .init\_machine = smdk\_machine\_init,  
13.  .timer = &s3c24xx\_timer,  
14. \}

下边是 smdk2440\_map\_io 函数：

1.  **static** **void** \_\_init smdk2440\_map\_io(**void**)  
2.  \{  
3.      s3c24xx\_init\_io(smdk2440\_iodesc, ARRAY\_SIZE(smdk2440\_iodesc));  
4.      s3c24xx\_init\_clocks(12000000);  
5.      s3c24xx\_init\_uarts(smdk2440\_uartcfgs, ARRAY\_SIZE(smdk2440\_uartcfgs));  
6.  \}

它调用了 s3c24xx\_init\_io 函数：

1.  **void** \_\_init s3c24xx\_init\_io(**struct** map\_desc \*mach\_desc, **int** size)  
2.  \{  
3.      unsigned **long** idcode = 0x0;  
4.      /\* initialise the io descriptors we need for initialisation \*/  
5.      iotable\_init(mach\_desc, size);  
6.      iotable\_init(s3c\_iodesc, ARRAY\_SIZE(s3c\_iodesc));  
7.      **if** (cpu\_architecture() >= CPU\_ARCH\_ARMv5) \{  
8.          idcode = s3c24xx\_read\_idcode\_v5();  
9.      \} **else** \{  
10.         idcode = s3c24xx\_read\_idcode\_v4();  
11.     \}  
12.     arm\_pm\_restart = s3c24xx\_pm\_restart;  
13.     s3c\_init\_cpu(idcode, cpu\_ids, ARRAY\_SIZE(cpu\_ids));  
14. \}  
15. /\* 
16.  \* Create the architecture specific mappings 
17.  \*/  
18. **void** \_\_init iotable\_init(**struct** map\_desc \*io\_desc, **int** nr)  
19. \{  
20.     **int** i;  
21.     **for** (i = 0; i < nr; i++)  
22.         create\_mapping(io\_desc + i);  
23. \}

所以，smdk2410\_map\_io最终调用iotable\_init建立映射表。

iotable\_init函数的参数有两个：一个是map\_desc结构体，另一个是该结构体的数量nr。这里最关键的就是struct map\_desc，map\_desc结构的定义如下：

map\_desc定义在arch/arm/include/asm/mach/map.h中，

1.  **struct** map\_desc \{  
2.      unsigned **long** **virtual**;   /\*映射后的虚拟地址\*/  
3.      unsigned **long** pfn;     /\*I/O资源物理地址所在的页帧号\*/  
4.      unsigned **long** length;   /\*I/O资源长度\*/   
5.      unsigned **int** type;      /\*I/O资源类型\*/  
6.  \};

create\_mapping函数就是通过map\_desc提供的信息创建线性映射表的。

这样的话我们就可以知道了创建I/O映射表的大致流程为：只要定义相应的I/O资源的map\_desc结构体，并将该结构体传给iotable\_init函数执行，就可以创建相应的I/O资源到内核虚拟地址空间的映射表了。我们来看看s3c2410是怎么定义map\_desc结构体的。

1.  **static** **struct** map\_desc s3c2410\_iodesc\[\] \_\_initdata = \{  
2.      IODESC\_ENT(CLKPWR),  
3.      IODESC\_ENT(TIMER),  
4.      IODESC\_ENT(WATCHDOG),  
5.  \};

IODESC\_ENT 定义在 arch/arm/plat-s3c/include/plat/cpu.h 中，展开后等价于：

1.  **static** **struct** map\_desc s3c2410\_iodesc\[\] \_\_initdata = \{  
2.      \{  
3.          .**virtual**    =     (unsigned **long**)S3C24XX\_VA\_ TIMER),  
4.          .pfn        =     \_\_phys\_to\_pfn(S3C24XX\_PA\_ TIMER),  
5.          .length    =    S3C24XX\_SZ\_ TIMER,  
6.          .type    =     MT\_DEVICE  
7.      \},  
8.      ……  
9.  \};

这里 S3C24XX\_PA\_TIMER 和 S3C24XX\_VA\_TIMER 为定义在 arch/arm/plat-s3c24xx/include/plat/map.h 内 TIMER 寄存器的物理地址和虚拟地址。在这里 map\_desc 结构体的 virtual 成员被初始化为 S3C24XX\_VA\_TIMER ， pfn 成员值通过 \_\_phys\_to\_pfn 内核函数计算，只要传递给它该 I/O 的物理地址就可行了。 Length 为映射资源的大小。 MT\_DEVICE 为 I/O 类型，通常定义为 MT\_DEVICE 。这里最重要的即 virtual 成员的值 S3C24XX\_VA\_ TIMER ，这个值即该 I/O 资源映射后的内核虚拟地址，创建映射表成功后，便可以在内核或驱动中直接通过该虚拟地址访问这个 I/O 资源。

1.  /\* Timers \*/  
2.  \#define S3C24XX\_VA\_TIMER   S3C\_VA\_TIMER  
3.  \#define S3C2410\_PA\_TIMER   (0x51000000)  
4.  \#define S3C24XX\_SZ\_TIMER   SZ\_1M  
5.  \#define S3C\_VA\_TIMER    S3C\_ADDR(0x00300000)    /\* timer block \*/  
6.  \#define S3C\_ADDR\_BASE   (0xF4000000)  
7.  \#ifndef \_\_ASSEMBLY\_\_  
8.  \#define S3C\_ADDR(x) ((void \_\_iomem \_\_force \*)S3C\_ADDR\_BASE + (x))  
9.  \#else  
10. \#define S3C\_ADDR(x) (S3C\_ADDR\_BASE + (x))  
11. \#endif

在ARM9中，如果从nand启动，sram被映射到bank0,在启动后这个sram可以用作其他用途。下边是测试程序sram.c：

1.  \#include <linux/init.h>  
2.  \#include <linux/module.h>  
3.  \#include <linux/ioport.h>  
4.  \#include <asm/mach/map.h>  
5.  \#include <mach/hardware.h>  
6.  **void** sram\_test(**void**)\{  
7.      **void** \*test;  
8.      **char** sram\[\] = "my\_iomap\_test success";  
9.      test = (**void**\*)S3C2410\_ADDR(0x07600000);  
10.     memcpy(test,sram,**sizeof**(sram));  
11.     printk(test);  
12.     printk("/n");  
13. \}  
14. **static** **int** \_\_init my\_iomap\_init(**void**)\{  
15.     **struct** resource \*ret;  
16.     printk("my\_iomap\_test init/n");  
17.     ret = request\_mem\_region(0x0000000,0x1000,"sram");  
18.     **if**(ret == NULL)\{  
19.         printk("io memory request fail!/n");  
20.         **return** -1;  
21.     \}  
22.     sram\_test();  
23.     **return** 0;  
24. \}  
25. **static** **void** \_\_exit my\_iomap\_exit(**void**)\{  
26.     printk("my\_iomap\_test exit/n");  
27.     release\_mem\_region(0x00000000,0x1000);  
28. \}  
29. module\_init(my\_iomap\_init);  
30. module\_exit(my\_iomap\_exit);  
31. MODULE\_LICENSE("GPL");  
32. MODULE\_AUTHOR("liwanpeng");

在内核中修改：

1.  **static** **struct** map\_desc smdk2440\_iodesc\[\] \_\_initdata = \{  
2.      /\* ISA IO Space map (memory space selected by A24) \*/  
3.    
4.      \{  
5.          .**virtual**    = (u32)S3C24XX\_VA\_ISA\_WORD,  
6.          .pfn        = \_\_phys\_to\_pfn(S3C2410\_CS2),  
7.          .length     = 0x10000,  
8.          .type       = MT\_DEVICE,  
9.      \}, \{  
10.         .**virtual**    = (u32)S3C24XX\_VA\_ISA\_WORD + 0x10000,  
11.         .pfn        = \_\_phys\_to\_pfn(S3C2410\_CS2 + (1<<24)),  
12.         .length     = SZ\_4M,  
13.         .type       = MT\_DEVICE,  
14.     \}, \{  
15.         .**virtual**    = (u32)S3C24XX\_VA\_ISA\_BYTE,  
16.         .pfn        = \_\_phys\_to\_pfn(S3C2410\_CS2),  
17.         .length     = 0x10000,  
18.         .type       = MT\_DEVICE,  
19.     \}, \{  
20.         .**virtual**    = (u32)S3C24XX\_VA\_ISA\_BYTE + 0x10000,  
21.         .pfn        = \_\_phys\_to\_pfn(S3C2410\_CS2 + (1<<24)),  
22.         .length     = SZ\_4M,  
23.         .type       = MT\_DEVICE,  
24.     \},\{  
25.         .**virtual**    = (u32)S3C2410\_ADDR(0x07600000),  
26.         .pfn        = \_\_phys\_to\_pfn(0x00000000),  
27.         .length     =SZ\_4K,  
28.         .type       = MT\_DEVICE,  
29.     \}  
30. \};

测试结果：

1.  \[root@LWP usb\]\# insmod sram.ko   
2.  my\_iomap\_test init  
3.  my\_iomap\_test success

[http_blog.csdn.net_woshixingaaa_archive_2011_05_15_6421954.aspx]: http://blog.csdn.net/woshixingaaa/archive/2011/05/15/6421954.aspx