io端口

io端口

***********************************************************

 

io端口设备访问流程为

-----------------------------------------------------------

1 request_region() 1 request_region() 

2 ioport_map() 2 in() outb()

3 ioread8() iowrite8() ... 3 release_region()

4 ioport_unmap()

5 release_region()

****************** ******************

映射到内存空间 不映射到内存空间

-----------------------------------------------------------

先看 request_region

 

例子

惠普的一个设备

 

drivers/input/serio/hp_sdc.c 

-------------------------------------

if (request_region(hp_sdc.data_io, 2, hp_sdc_driver.name))

        goto err0;                     

 

如果request_region 分配端口成功，返回非空指针。

 

1. drivers/input/serio/hp_sdc.c
   
2. -------------------------------------
   
3. if (request_region(hp_sdc.data_io, 2, hp_sdc_driver.name))
   
4.         goto err0;
   
6.     如果request_region 分配端口成功，返回非空指针。
8. request_region
9. -------------------------------------
   
10. ->./include/linux/ioport.h:
    
11.     #define request_region(start,n,name) \
    
12.         __request_region(&ioport_resource, (start), (n), (name), 0)
    
13. =====================================
    
15. ioport_resource
16. -------------------------------------
    
17. -->kernel/resource.c
    
18.     struct resource ioport_resource = {
    
19.         .name = "PCI IO",
    
20.         .start = 0,
    
21.         .end = IO_SPACE_LIMIT,
    
22.         .flags = IORESOURCE_IO,
    
23.     };
    
24.     EXPORT_SYMBOL(ioport_resource);
    
26. __request_region
27. -------------------------------------
    
28. -->kernel/resource.c
    
29.     struct resource * __request_region(struct resource *parent,
    
30.                             resource_size_t start, resource_size_t n,
    
31.                             const char *name, int flags)
    
32.     {
    
33.         struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
    
35.         if (!res)return NULL;
    
37.         res->name = name;
    
38.         res->start = start;
    
39.         res->end = start + n - 1;
    
40.         res->flags = IORESOURCE_BUSY;
    
41.         res->flags |= flags;
    
43.         write_lock(&resource_lock);
    
45.         for (;;) {
    
46.                 struct resource *conflict;
    
48.                 conflict = __request_resource(parent, res);
    
49.                 if (!conflict) break; //申请成功
    
50.                 if (conflict != parent) {
    
51.                         parent = conflict;
    
52.                         if (!(conflict->flags & IORESOURCE_BUSY))
    
53.                                 continue;
    
54.                 }
    
56.                 /* Uhhuh, that didn't work out.. */
    
57.                 kfree(res);
    
58.                 res = NULL;
    
59.                 break;
    
60.         }
    
61.         write_unlock(&resource_lock);
    
62.         return res;
    
63.     }
    
64.     EXPORT_SYMBOL(__request_region);
    
65. =====================================
    
67. kzalloc
68. -------------------------------------
    
69. --->include/linux/slab.h
    
70.     static inline void *kzalloc(size_t size, gfp_t flags)
    
71.     {
    
72.             return kmalloc(size, flags | __GFP_ZERO);
    
73.     }
    
75. __request_resource
76. -------------------------------------
    
77. --->kernel/resource.c
    
78.     static struct resource *
    
79.         __request_resource(struct resource *root,
    
80.                 struct resource *new)
    
81.     {
    
82.         resource_size_t start = new->start;
    
83.         resource_size_t end = new->end;
    
84.         struct resource *tmp, **p;
    
86.         if (end < start) return root;
    
87.         if (start < root->start) return root;
    
88.         if (end > root->end) return root;
    
89.         p = &root->child;
    
90.         for (;;) {
    
91.                 tmp = *p;
    
92.                 if (!tmp || tmp->start > end) {
    
93.                         new->sibling = tmp;
    
94.                         *p = new;
    
95.                         new->parent = root;
    
96.                         return NULL; //成功
    
97.                 }
    
98.                 p = &tmp->sibling;
    
99.                 if (tmp->end < start) continue;
    
100.                 return tmp;
     
101.         }
     
102. }
     
103. =====================================

 

-------------------------------------

ioport_resource 小结

-------------------------------------

这是一个只有两层的树，第二层横向是个链

下面的图就是这个结构

% child指针

单线 parent指针

== sibling 指针

可以很容易得出如下特点

父节点会把子节点的范围包含

1 S :申请的io口的数量  S(i) > 0 

2 s :申请的io的起始地址 0

3 s(i+j) > s(i)

4 j,i=1,2,3, ...

 

ioport_resource

-------------------------------------

              ioport_resource (0,0xffff)

    % ↑          ↑          ↑

  % /            |            \

↓ /              |             \

(s1,s1+S1)==>   (s2,s2+S2)==>   (s3,s3+S3)==>

到此我们可以判断端口号的范围是 0-0xffff， 那么他和物理地址以及虚拟地址的关系呢？

如果有关系，从申请内存的kzalloc(sizeof(*res), GFP_KERNEL)句考察应该是个好入口。

接下来就是看 kmalloc(size, GFP_KERNEL | __GFP_ZERO)了

 

个人感觉没有多大关系。因为申请的关键性标志为 GFP_KERNEL,这表示申请的是内核常规内存。具体有没有关系，如果有，有什么样的关系，等看了kmalloc再说。

接着应该看

 

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

 

 

***********************************************************

ioport_map ioport_unmap

***********************************************************

 

1. lib/iomap.c
   
2. -------------------------------------
   
3.     #define PIO_OFFSET 0x10000UL //64k
   
4.     #define PIO_MASK 0x0ffffUL
5.     #define PIO_RESERVED 0x40000UL //256K
   
6.     #endif
7.     
8.     void __iomem *ioport_map(unsigned long port, unsigned int nr)
   
9.     {
   
10.             if (port > PIO_MASK)
    
11.                     return NULL;
    
12.             return (void __iomem *) (unsigned long) (port + PIO_OFFSET);
    
13.     }
    
14.     void ioport_unmap(void __iomem *addr)
    
15.     {
    
16.             /* Nothing to do */
    
17.     }
    
18.     
19.     __iomem
20.     -------------------------------------
    
21.     include/linux/compiler.h
    
22.     # define __iomem __attribute__((noderef, address_space(2)))
    
23.     //对iomem地址进行检查
    
25. -------------------------------------
    
26. ioport_map ioport_unmap 小结
27. -------------------------------------
    
28.     从port的范围（0-0xffff） 可以看到，映射的地址是10000-0x1ffff， 即(64k) -> (128k-1)的空间。
    
29.     还有一个是PIO_RESERVED 40000,是保留的空间。
    
30.     在搜代码的时候，同时也会在include/asm-generic/io.h文件中出现。而其上方有 #ifndef CONFIG_GENERIC_IOMAP，个人理解是这文件处理的是没有iomap的功能情况。里面的函数大都是空。
    
32. ==============================================================================
    
34. ***********************************************************
    
35.             ioread8() iowrite8()
    
36. ***********************************************************
    
38. lib/iomap.c
    
39.     -------------------------------------
    
40.     #define PIO_RESERVED 0x40000UL
41.     #define PIO_OFFSET 0x10000UL
42.     
43.     unsigned int ioread8(void __iomem *addr)
    
44.     {
    
45.         IO_COND(addr, return inb(port), return readb(addr));
    
46.         return 0xff;
    
47.     }
    
49.     void iowrite8(u8 val, void __iomem *addr)
    
50.     {
    
51.         IO_COND(addr, outb(val,port), writeb(val, addr));
    
52.     }
    
53.     
54.     EXPORT_SYMBOL(ioread8);
    
55.     EXPORT_SYMBOL(iowrite8);
    
56.     
57.     #define IO_COND(addr, is_pio, is_mmio) do { \
    
58.             unsigned long port = (unsigned long __force)addr; \
    
59.             if (port >= PIO_RESERVED) { \
    
60.                     is_mmio; \
    
61.             } else if (port > PIO_OFFSET) { \
    
62.                     port &= PIO_MASK; \
    
63.                     is_pio; \
    
64.             } else \
    
65.                     bad_io_access(port, #is_pio ); \
    
66.     }     while (0)
    
67.     
68.     static void bad_io_access(unsigned long port, const char *access)
    
69.     {
    
70.         static int count = 10;
    
71.         if (count) {
    
72.             count--;
    
73.             WARN(1, KERN_ERR "Bad IO access at port %#lx (%s)\n", port, access);
    
74.         }
    
75.     }
    
76.     
77.     WARN
78.     -------------------------------------
    
79.     ->include/asm-generic/bug.h
    
80.     #define WARN(condition, format...) ({ \
    
81.             int __ret_warn_on = !!(condition); \
    
82.             unlikely(__ret_warn_on); \
    
83.     })
    
84.     
85.     ioread8(addr)意思就是
    
86.         if addr>=256K then readb(addr)
    
87.         else if addr >64K then inb(addr - 64K)
    
88.         else 打印错误
    
89.     
90.     继续追踪 inb 和 readb
91.     =====================================
    
93. include/asm-generic/io.h
    
94.     -------------------------------------
    
95.     #define readb __raw_readb
96.     static inline u8 __raw_readb(const volatile void __iomem *addr)
    
97.     {
    
98.             return *(const volatile u8 __force *) addr;
    
99.     }
    
100.     
101.     #define writeb __raw_writeb
102.     static inline void __raw_writeb(u8 b, volatile void __iomem *addr)
     
103.     {
     
104.             *(volatile u8 __force *) addr = b;
     
105.     }
     
106.     
107.     -------------------------------------
     
108.     static inline u8 inb(unsigned long addr)
     
109.     {
     
110.             return readb((volatile void __iomem *) addr);
     
111.     }
     
112.     static inline void outb(u8 b, unsigned long addr)
     
113.     {
     
114.             writeb(b, (volatile void __iomem *) addr);
     
115.     }
     
117. arch/x86/boot.c
     
118. -------------------------------------
     
119.     static inline u8 inb(u16 port)
     
120.     {
     
121.         u8 v;
     
122.         asm volatile("inb %1,%0" : "=a" (v) : "dN" (port));
     
123.         return v;
     
124.     }
     
125.     static inline void outb(u8 v, u16 port)
     
126.     {
     
127.         asm volatile("outb %0,%1" : : "a" (v), "dN" (port));
     
128.     }

 

 

-------------------------------------

小结

-------------------------------------

在这里，我做一下个人理解，在io映射过以后，使用的是io.h中的函数，包括inb，outb。

如果没有映射，使用的是boot.c中的函数

inb或outb在不同情况下的值比较

boot.c的port值 小于 64k，

io.h中的port值 介于 64K 和 128k 

 

从boot.c中的inb、outb可以看出，端口号一定和在主板的位置（或者是总线地址有关），有什么关系呢？

是不是和BSP有关，怎么有关的？

到这里，不能算完，待深入？

 

不过应该确认的是，端口和申请的resource地址无关，resource只是用来记录申请的端口