request_region&ioremap

request_mem_region(start,n,name)
//将起始地址为[start, start+n-1]的资源插入根资源iomem_resource中。
//参数start是I/O内存资源的起始物理地址(是CPU的RAM物理地址空间中的物理地址)，参数n指定I/O内存资源的大小。

#define request_mem_region(start,n,name) __request_region(&iomem_resource, (start), (n), (name), 0)

//iomem_resource是所有iomem resurce的parent：
struct resource ioport_resource = {
    .name   = "PCI IO",
    .start  = 0,
    .end    = IO_SPACE_LIMIT,
    .flags  = IORESOURCE_IO,
};
EXPORT_SYMBOL(ioport_resource);

//iomem_resource@resource.c
struct resource iomem_resource = {
    .name   = "PCI mem",
    .start  = 0,
    .end    = -1,
    .flags  = IORESOURCE_MEM,
};
EXPORT_SYMBOL(iomem_resource);


/**
 * __request_region - create a new busy resource region
 * @parent: parent resource descriptor
 * @start: resource start address
 * @n: resource region size
 * @name: reserving caller's ID string
 * @flags: IO resource flags
 */
struct resource * __request_region(struct resource *parent,
                   resource_size_t start, resource_size_t n,
                   const char *name, int flags)
{
    DECLARE_WAITQUEUE(wait, current);
    struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);

    if (!res)
        return NULL;

    res->name = name;
    res->start = start;
    res->end = start + n - 1;
    res->flags = IORESOURCE_BUSY;
    res->flags |= flags;

    write_lock(&resource_lock);

    for (;;) {
        struct resource *conflict;

        conflict = __request_resource(parent, res);
        if (!conflict)
            break;
        if (conflict != parent) {
            parent = conflict;
            if (!(conflict->flags & IORESOURCE_BUSY))
                continue;
        }
        if (conflict->flags & flags & IORESOURCE_MUXED) {
            add_wait_queue(&muxed_resource_wait, &wait);
            write_unlock(&resource_lock);
            set_current_state(TASK_UNINTERRUPTIBLE);
            schedule();
            remove_wait_queue(&muxed_resource_wait, &wait);
            write_lock(&resource_lock);
            continue;
        }
        /* Uhhuh, that didn't work out.. */
        kfree(res);
        res = NULL;
        break;
    }
    write_unlock(&resource_lock);
    return res;
}
EXPORT_SYMBOL(__request_region);

/* Return the conflict entry if you can't request it */
static struct resource * __request_resource(struct resource *root, struct resource *new)
{
    resource_size_t start = new->start;
    resource_size_t 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;
    for (;;) {
        tmp = *p;
        if (!tmp || tmp->start > end) {
            new->sibling = tmp;
            *p = new;
            new->parent = root;
            return NULL;
        }
        p = &tmp->sibling;
        if (tmp->end < start)
            continue;
        return tmp;
    }
}

//注: 调用request_mem_region()不是必须的，但是建议使用。
//    该函数的任务是检查申请的资源是否可用，如果可用则申请成功，并标志为已经使用，其他驱动想再申请该资源时就会失败。