• 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) ", 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只是用来记录申请的端口
  • 相关阅读:
    cgic: CGI的C函数库
    linux下的webserver BOA及CGIC库的使用指南（转帖）
    UDP 收/发 广播包
    winsock 收发广播包
    Linux系统下UDP发送和接收广播消息小例子
    uboot里读sd卡内容
    uboot从SD卡烧写内核和文件系统
    intellij 创建一个文件自动就add到git了，这个怎么取消
    内部类和外部类之间的相互调用
    JDK8的新特性——Lambda表达式
  • 原文地址：https://www.cnblogs.com/timssd/p/4781094.html
Copyright © 2020-2023  润新知