request_mem_region __request_region(iomem_resource,(start),(n),(name))

本文主要是介绍request_mem_region __request_region(iomem_resource,(start),(n),(name))，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

linux下request_mem_region的粗略理解

文章来源:http://gliethttp.cublog.cn

Linux把基于I/O映射方式的I/O端口和基于内存映射方式的I/O端口资源统称为“I/O区域”（I/O Region）。I/O Region仍然是一种I/O资源，因此它仍然可以用resource结构类型来描述。

Linux是以一种倒置的树形结构来管理每一类I/O资源（如：I/O端口、外设内存、DMA和IRQ）的。每一类I/O资源都对应有一颗倒置的资源树，树中的每一个节点都是一个resource结构，而树的根结点root则描述了该类资源的整个资源空间。

1.结构体
  1.1>struct resource iomem_resource ={"PCI mem", 0x00000000, 0xffffffff, IORESOURCE_MEM };
  1.2>struct resource {
                constchar*name;
                unsignedlong start, end;
                unsignedlong flags;
                struct resource *parent,*sibling,*child;
             };
2.调用函数
  request_mem_region(S1D_PHYSICAL_REG_ADDR,S1D_PHYSICAL_REG_SIZE,"EpsonFB_RG")
#define request_mem_region(start,n,name) __request_region(&iomem_resource,(start),(n),(name))
__request_region检查是否可以安全占用起始物理地址S1D_PHYSICAL_REG_ADDR之后的连续S1D_PHYSICAL_REG_SIZE字节大小空间

struct resource * __request_region(struct resource *parent,unsignedlong start,unsignedlong n,constchar*name)
{
    struct resource *res = kmalloc(sizeof(*res), GFP_KERNEL);

    if(res){
        memset(res, 0,sizeof(*res));
        res->name = name;
        res->start = start;
        res->end = start + n - 1;
        res->flags = IORESOURCE_BUSY;

        write_lock(&resource_lock);

        for(;;){
            struct resource *conflict;

            conflict = __request_resource(parent, res);    //sibling parent下的所有单元,检测申请部分是否存在交叠冲突
            if(!conflict)                                 //conflict=0;申请成功,正常安置了[start,end]到相应位置
                break;
            if(conflict != parent){
                parent = conflict;
                if(!(conflict->flags & IORESOURCE_BUSY))
                    continue;
            }
             kfree(res);                                   //检测到了资源交叠冲突,kfree归还kmalloc申请的内存
            res =NULL;
            break;
        }
        write_unlock(&resource_lock);
    }
    return res;
}

staticstruct resource * __request_resource(struct resource *root,struct resource *new)
{
    unsignedlong start =new->start;
    unsignedlong end =new->end;
    struct resource *tmp,**p;

    if(end < start)
        return root;
    if(start < root->start)
        return root;
    if(end > root->end)
        return root;
    p =&root->child;                                      //root下的第一个链表元素*p.[child链表是以I/O资源物理地址从低到高的顺序排列的]
    for(;;){
        tmp =*p;
        if(!tmp || tmp->start > end){
            new->sibling = tmp;
            *p =new;
//可以从root->child=null开始我们的分析考虑,此时tmp=null,那么第一个申请将以!tmp条件满足而进入
//这时root->child的值为new指针,new->sibling = tmp = null;当第二次申请发生时:如果tmp->start > end成立,
//那么,root->child的值为new指针,new->sibling = tmp;这样就链接上了，空间分布图如:
//child=[start,end]-->[tmp->start,tmp->end](1);如果条件tmp->start > end不成立，那么只能是!tmp条件进入
//那么,root->child的值不变,tmp->sibling = new;new->sibling = tmp = null这样就链接上了，空间分布图如:
//child=[child->start,child->end]-->[start,end](2);
//当第三次申请发生时:如果start在(2)中的[child->end,end]之间,那么tmp->end < start将成立,继而continue,
//此时tmp = (2)中的[start,end],因为tmp->start < end,所以继续执行p = &tmp->slibing = null,
//因为tmp->end > start,所以资源冲突,返回(2)中的[start,end]域
//综上的两个边界值情况和一个中间值情况的分析,可以知道代码实现了一个从地地址到高地址的顺序链表
//模型图:childe=[a,b]-->[c,d]-->[e,f],此时有一个[x,y]需要插入进去,tmp作为sibling指针游动
//tmp指向child=[a,b],
//tmp指向[a,b],当tmp->start>y时,插入后的链接图为:child=[x,y]-->[a,b]-->[c,d]-->[e,f]-->null;当tmp->end>=x时,冲突返回tmp
//tmp指向[c,d],当tmp->start>y时,插入后的链接图为:child=[a,b]-->[x,y]-->[c,d]-->[e,f]-->null;当tmp->end>=x时,冲突返回tmp
//tmp指向[e,f],当tmp->start>y时,插入后的链接图为:child=[a,b]-->[c,d]-->[x,y]-->[e,f]-->null;当tmp->end>=x时,冲突返回tmp
//tmp指向null                  ,插入后的链接图为:child=[a,b]-->[c,d]-->[e,f]-->[x,y]-->null;
//顺利的达到了检测冲突,顺序链接的目的
            new->parent = root;
            returnNULL;
        }
        p =&tmp->sibling;
        if(tmp->end < start)
            continue;
        return tmp;
    }
}