URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [kernel/] [resource.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 *      linux/kernel/resource.c
 *
 * Copyright (C) 1999   Linus Torvalds
 * Copyright (C) 1999   Martin Mares <mj@ucw.cz>
 *
 * Arbitrary resource management.
 */
 
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/ioport.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/device.h>
#include <asm/io.h>
 
 
struct resource ioport_resource = {
        .name   = "PCI IO",
        .start  = 0,
        .end    = IO_SPACE_LIMIT,
        .flags  = IORESOURCE_IO,
};
EXPORT_SYMBOL(ioport_resource);
 
struct resource iomem_resource = {
        .name   = "PCI mem",
        .start  = 0,
        .end    = -1,
        .flags  = IORESOURCE_MEM,
};
EXPORT_SYMBOL(iomem_resource);
 
static DEFINE_RWLOCK(resource_lock);
 
#ifdef CONFIG_PROC_FS
 
enum { MAX_IORES_LEVEL = 5 };
 
static void *r_next(struct seq_file *m, void *v, loff_t *pos)
{
        struct resource *p = v;
        (*pos)++;
        if (p->child)
                return p->child;
        while (!p->sibling && p->parent)
                p = p->parent;
        return p->sibling;
}
 
static void *r_start(struct seq_file *m, loff_t *pos)
        __acquires(resource_lock)
{
        struct resource *p = m->private;
        loff_t l = 0;
        read_lock(&resource_lock);
        for (p = p->child; p && l < *pos; p = r_next(m, p, &l))
                ;
        return p;
}
 
static void r_stop(struct seq_file *m, void *v)
        __releases(resource_lock)
{
        read_unlock(&resource_lock);
}
 
static int r_show(struct seq_file *m, void *v)
{
        struct resource *root = m->private;
        struct resource *r = v, *p;
        int width = root->end < 0x10000 ? 4 : 8;
        int depth;
 
        for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)
                if (p->parent == root)
                        break;
        seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
                        depth * 2, "",
                        width, (unsigned long long) r->start,
                        width, (unsigned long long) r->end,
                        r->name ? r->name : "<BAD>");
        return 0;
}
 
static const struct seq_operations resource_op = {
        .start  = r_start,
        .next   = r_next,
        .stop   = r_stop,
        .show   = r_show,
};
 
static int ioports_open(struct inode *inode, struct file *file)
{
        int res = seq_open(file, &resource_op);
        if (!res) {
                struct seq_file *m = file->private_data;
                m->private = &ioport_resource;
        }
        return res;
}
 
static int iomem_open(struct inode *inode, struct file *file)
{
        int res = seq_open(file, &resource_op);
        if (!res) {
                struct seq_file *m = file->private_data;
                m->private = &iomem_resource;
        }
        return res;
}
 
static const struct file_operations proc_ioports_operations = {
        .open           = ioports_open,
        .read           = seq_read,
        .llseek         = seq_lseek,
        .release        = seq_release,
};
 
static const struct file_operations proc_iomem_operations = {
        .open           = iomem_open,
        .read           = seq_read,
        .llseek         = seq_lseek,
        .release        = seq_release,
};
 
static int __init ioresources_init(void)
{
        struct proc_dir_entry *entry;
 
        entry = create_proc_entry("ioports", 0, NULL);
        if (entry)
                entry->proc_fops = &proc_ioports_operations;
        entry = create_proc_entry("iomem", 0, NULL);
        if (entry)
                entry->proc_fops = &proc_iomem_operations;
        return 0;
}
__initcall(ioresources_init);
 
#endif /* CONFIG_PROC_FS */
 
/* 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;
        }
}
 
static int __release_resource(struct resource *old)
{
        struct resource *tmp, **p;
 
        p = &old->parent->child;
        for (;;) {
                tmp = *p;
                if (!tmp)
                        break;
                if (tmp == old) {
                        *p = tmp->sibling;
                        old->parent = NULL;
                        return 0;
                }
                p = &tmp->sibling;
        }
        return -EINVAL;
}
 
/**
 * request_resource - request and reserve an I/O or memory resource
 * @root: root resource descriptor
 * @new: resource descriptor desired by caller
 *
 * Returns 0 for success, negative error code on error.
 */
int request_resource(struct resource *root, struct resource *new)
{
        struct resource *conflict;
 
        write_lock(&resource_lock);
        conflict = __request_resource(root, new);
        write_unlock(&resource_lock);
        return conflict ? -EBUSY : 0;
}
 
EXPORT_SYMBOL(request_resource);
 
/**
 * release_resource - release a previously reserved resource
 * @old: resource pointer
 */
int release_resource(struct resource *old)
{
        int retval;
 
        write_lock(&resource_lock);
        retval = __release_resource(old);
        write_unlock(&resource_lock);
        return retval;
}
 
EXPORT_SYMBOL(release_resource);
 
#ifdef CONFIG_MEMORY_HOTPLUG
/*
 * Finds the lowest memory reosurce exists within [res->start.res->end)
 * the caller must specify res->start, res->end, res->flags.
 * If found, returns 0, res is overwritten, if not found, returns -1.
 */
static int find_next_system_ram(struct resource *res)
{
        resource_size_t start, end;
        struct resource *p;
 
        BUG_ON(!res);
 
        start = res->start;
        end = res->end;
        BUG_ON(start >= end);
 
        read_lock(&resource_lock);
        for (p = iomem_resource.child; p ; p = p->sibling) {
                /* system ram is just marked as IORESOURCE_MEM */
                if (p->flags != res->flags)
                        continue;
                if (p->start > end) {
                        p = NULL;
                        break;
                }
                if ((p->end >= start) && (p->start < end))
                        break;
        }
        read_unlock(&resource_lock);
        if (!p)
                return -1;
        /* copy data */
        if (res->start < p->start)
                res->start = p->start;
        if (res->end > p->end)
                res->end = p->end;
        return 0;
}
int
walk_memory_resource(unsigned long start_pfn, unsigned long nr_pages, void *arg,
                        int (*func)(unsigned long, unsigned long, void *))
{
        struct resource res;
        unsigned long pfn, len;
        u64 orig_end;
        int ret = -1;
        res.start = (u64) start_pfn << PAGE_SHIFT;
        res.end = ((u64)(start_pfn + nr_pages) << PAGE_SHIFT) - 1;
        res.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
        orig_end = res.end;
        while ((res.start < res.end) && (find_next_system_ram(&res) >= 0)) {
                pfn = (unsigned long)(res.start >> PAGE_SHIFT);
                len = (unsigned long)((res.end + 1 - res.start) >> PAGE_SHIFT);
                ret = (*func)(pfn, len, arg);
                if (ret)
                        break;
                res.start = res.end + 1;
                res.end = orig_end;
        }
        return ret;
}
 
#endif
 
/*
 * Find empty slot in the resource tree given range and alignment.
 */
static int find_resource(struct resource *root, struct resource *new,
                         resource_size_t size, resource_size_t min,
                         resource_size_t max, resource_size_t align,
                         void (*alignf)(void *, struct resource *,
                                        resource_size_t, resource_size_t),
                         void *alignf_data)
{
        struct resource *this = root->child;
 
        new->start = root->start;
        /*
         * Skip past an allocated resource that starts at 0, since the assignment
         * of this->start - 1 to new->end below would cause an underflow.
         */
        if (this && this->start == 0) {
                new->start = this->end + 1;
                this = this->sibling;
        }
        for(;;) {
                if (this)
                        new->end = this->start - 1;
                else
                        new->end = root->end;
                if (new->start < min)
                        new->start = min;
                if (new->end > max)
                        new->end = max;
                new->start = ALIGN(new->start, align);
                if (alignf)
                        alignf(alignf_data, new, size, align);
                if (new->start < new->end && new->end - new->start >= size - 1) {
                        new->end = new->start + size - 1;
                        return 0;
                }
                if (!this)
                        break;
                new->start = this->end + 1;
                this = this->sibling;
        }
        return -EBUSY;
}
 
/**
 * allocate_resource - allocate empty slot in the resource tree given range & alignment
 * @root: root resource descriptor
 * @new: resource descriptor desired by caller
 * @size: requested resource region size
 * @min: minimum size to allocate
 * @max: maximum size to allocate
 * @align: alignment requested, in bytes
 * @alignf: alignment function, optional, called if not NULL
 * @alignf_data: arbitrary data to pass to the @alignf function
 */
int allocate_resource(struct resource *root, struct resource *new,
                      resource_size_t size, resource_size_t min,
                      resource_size_t max, resource_size_t align,
                      void (*alignf)(void *, struct resource *,
                                     resource_size_t, resource_size_t),
                      void *alignf_data)
{
        int err;
 
        write_lock(&resource_lock);
        err = find_resource(root, new, size, min, max, align, alignf, alignf_data);
        if (err >= 0 && __request_resource(root, new))
                err = -EBUSY;
        write_unlock(&resource_lock);
        return err;
}
 
EXPORT_SYMBOL(allocate_resource);
 
/**
 * insert_resource - Inserts a resource in the resource tree
 * @parent: parent of the new resource
 * @new: new resource to insert
 *
 * Returns 0 on success, -EBUSY if the resource can't be inserted.
 *
 * This function is equivalent to request_resource when no conflict
 * happens. If a conflict happens, and the conflicting resources
 * entirely fit within the range of the new resource, then the new
 * resource is inserted and the conflicting resources become children of
 * the new resource.
 */
int insert_resource(struct resource *parent, struct resource *new)
{
        int result;
        struct resource *first, *next;
 
        write_lock(&resource_lock);
 
        for (;; parent = first) {
                result = 0;
                first = __request_resource(parent, new);
                if (!first)
                        goto out;
 
                result = -EBUSY;
                if (first == parent)
                        goto out;
 
                if ((first->start > new->start) || (first->end < new->end))
                        break;
                if ((first->start == new->start) && (first->end == new->end))
                        break;
        }
 
        for (next = first; ; next = next->sibling) {
                /* Partial overlap? Bad, and unfixable */
                if (next->start < new->start || next->end > new->end)
                        goto out;
                if (!next->sibling)
                        break;
                if (next->sibling->start > new->end)
                        break;
        }
 
        result = 0;
 
        new->parent = parent;
        new->sibling = next->sibling;
        new->child = first;
 
        next->sibling = NULL;
        for (next = first; next; next = next->sibling)
                next->parent = new;
 
        if (parent->child == first) {
                parent->child = new;
        } else {
                next = parent->child;
                while (next->sibling != first)
                        next = next->sibling;
                next->sibling = new;
        }
 
 out:
        write_unlock(&resource_lock);
        return result;
}
 
/**
 * adjust_resource - modify a resource's start and size
 * @res: resource to modify
 * @start: new start value
 * @size: new size
 *
 * Given an existing resource, change its start and size to match the
 * arguments.  Returns 0 on success, -EBUSY if it can't fit.
 * Existing children of the resource are assumed to be immutable.
 */
int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size)
{
        struct resource *tmp, *parent = res->parent;
        resource_size_t end = start + size - 1;
        int result = -EBUSY;
 
        write_lock(&resource_lock);
 
        if ((start < parent->start) || (end > parent->end))
                goto out;
 
        for (tmp = res->child; tmp; tmp = tmp->sibling) {
                if ((tmp->start < start) || (tmp->end > end))
                        goto out;
        }
 
        if (res->sibling && (res->sibling->start <= end))
                goto out;
 
        tmp = parent->child;
        if (tmp != res) {
                while (tmp->sibling != res)
                        tmp = tmp->sibling;
                if (start <= tmp->end)
                        goto out;
        }
 
        res->start = start;
        res->end = end;
        result = 0;
 
 out:
        write_unlock(&resource_lock);
        return result;
}
 
EXPORT_SYMBOL(adjust_resource);
 
/*
 * This is compatibility stuff for IO resources.
 *
 * Note how this, unlike the above, knows about
 * the IO flag meanings (busy etc).
 *
 * request_region creates a new busy region.
 *
 * check_region returns non-zero if the area is already busy.
 *
 * release_region releases a matching busy region.
 */
 
/**
 * __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
 */
struct resource * __request_region(struct resource *parent,
                                   resource_size_t start, resource_size_t n,
                                   const char *name)
{
        struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
 
        if (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);
                        if (!conflict)
                                break;
                        if (conflict != parent) {
                                parent = conflict;
                                if (!(conflict->flags & IORESOURCE_BUSY))
                                        continue;
                        }
 
                        /* Uhhuh, that didn't work out.. */
                        kfree(res);
                        res = NULL;
                        break;
                }
                write_unlock(&resource_lock);
        }
        return res;
}
EXPORT_SYMBOL(__request_region);
 
/**
 * __check_region - check if a resource region is busy or free
 * @parent: parent resource descriptor
 * @start: resource start address
 * @n: resource region size
 *
 * Returns 0 if the region is free at the moment it is checked,
 * returns %-EBUSY if the region is busy.
 *
 * NOTE:
 * This function is deprecated because its use is racy.
 * Even if it returns 0, a subsequent call to request_region()
 * may fail because another driver etc. just allocated the region.
 * Do NOT use it.  It will be removed from the kernel.
 */
int __check_region(struct resource *parent, resource_size_t start,
                        resource_size_t n)
{
        struct resource * res;
 
        res = __request_region(parent, start, n, "check-region");
        if (!res)
                return -EBUSY;
 
        release_resource(res);
        kfree(res);
        return 0;
}
EXPORT_SYMBOL(__check_region);
 
/**
 * __release_region - release a previously reserved resource region
 * @parent: parent resource descriptor
 * @start: resource start address
 * @n: resource region size
 *
 * The described resource region must match a currently busy region.
 */
void __release_region(struct resource *parent, resource_size_t start,
                        resource_size_t n)
{
        struct resource **p;
        resource_size_t end;
 
        p = &parent->child;
        end = start + n - 1;
 
        write_lock(&resource_lock);
 
        for (;;) {
                struct resource *res = *p;
 
                if (!res)
                        break;
                if (res->start <= start && res->end >= end) {
                        if (!(res->flags & IORESOURCE_BUSY)) {
                                p = &res->child;
                                continue;
                        }
                        if (res->start != start || res->end != end)
                                break;
                        *p = res->sibling;
                        write_unlock(&resource_lock);
                        kfree(res);
                        return;
                }
                p = &res->sibling;
        }
 
        write_unlock(&resource_lock);
 
        printk(KERN_WARNING "Trying to free nonexistent resource "
                "<%016llx-%016llx>\n", (unsigned long long)start,
                (unsigned long long)end);
}
EXPORT_SYMBOL(__release_region);
 
/*
 * Managed region resource
 */
struct region_devres {
        struct resource *parent;
        resource_size_t start;
        resource_size_t n;
};
 
static void devm_region_release(struct device *dev, void *res)
{
        struct region_devres *this = res;
 
        __release_region(this->parent, this->start, this->n);
}
 
static int devm_region_match(struct device *dev, void *res, void *match_data)
{
        struct region_devres *this = res, *match = match_data;
 
        return this->parent == match->parent &&
                this->start == match->start && this->n == match->n;
}
 
struct resource * __devm_request_region(struct device *dev,
                                struct resource *parent, resource_size_t start,
                                resource_size_t n, const char *name)
{
        struct region_devres *dr = NULL;
        struct resource *res;
 
        dr = devres_alloc(devm_region_release, sizeof(struct region_devres),
                          GFP_KERNEL);
        if (!dr)
                return NULL;
 
        dr->parent = parent;
        dr->start = start;
        dr->n = n;
 
        res = __request_region(parent, start, n, name);
        if (res)
                devres_add(dev, dr);
        else
                devres_free(dr);
 
        return res;
}
EXPORT_SYMBOL(__devm_request_region);
 
void __devm_release_region(struct device *dev, struct resource *parent,
                           resource_size_t start, resource_size_t n)
{
        struct region_devres match_data = { parent, start, n };
 
        __release_region(parent, start, n);
        WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match,
                               &match_data));
}
EXPORT_SYMBOL(__devm_release_region);
 
/*
 * Called from init/main.c to reserve IO ports.
 */
#define MAXRESERVE 4
static int __init reserve_setup(char *str)
{
        static int reserved;
        static struct resource reserve[MAXRESERVE];
 
        for (;;) {
                int io_start, io_num;
                int x = reserved;
 
                if (get_option (&str, &io_start) != 2)
                        break;
                if (get_option (&str, &io_num)   == 0)
                        break;
                if (x < MAXRESERVE) {
                        struct resource *res = reserve + x;
                        res->name = "reserved";
                        res->start = io_start;
                        res->end = io_start + io_num - 1;
                        res->flags = IORESOURCE_BUSY;
                        res->child = NULL;
                        if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0)
                                reserved = x+1;
                }
        }
        return 1;
}
 
__setup("reserve=", reserve_setup);

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [kernel/] [resource.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* linux/kernel/resource.c`
3			`*`
4			`* Copyright (C) 1999 Linus Torvalds`
5			`* Copyright (C) 1999 Martin Mares <mj@ucw.cz>`
6			`*`
7			`* Arbitrary resource management.`
8			`*/`
9
10			`#include <linux/module.h>`
11			`#include <linux/errno.h>`
12			`#include <linux/ioport.h>`
13			`#include <linux/init.h>`
14			`#include <linux/slab.h>`
15			`#include <linux/spinlock.h>`
16			`#include <linux/fs.h>`
17			`#include <linux/proc_fs.h>`
18			`#include <linux/seq_file.h>`
19			`#include <linux/device.h>`
20			`#include <asm/io.h>`
21
22
23			`struct resource ioport_resource = {`
24			`.name = "PCI IO",`
25			`.start = 0,`
26			`.end = IO_SPACE_LIMIT,`
27			`.flags = IORESOURCE_IO,`
28			`};`
29			`EXPORT_SYMBOL(ioport_resource);`
30
31			`struct resource iomem_resource = {`
32			`.name = "PCI mem",`
33			`.start = 0,`
34			`.end = -1,`
35			`.flags = IORESOURCE_MEM,`
36			`};`
37			`EXPORT_SYMBOL(iomem_resource);`
38
39			`static DEFINE_RWLOCK(resource_lock);`
40
41			`#ifdef CONFIG_PROC_FS`
42
43			`enum { MAX_IORES_LEVEL = 5 };`
44
45			`static void r_next(struct seq_file m, void v, loff_t pos)`
46			`{`
47			`struct resource *p = v;`
48			`(*pos)++;`
49			`if (p->child)`
50			`return p->child;`
51			`while (!p->sibling && p->parent)`
52			`p = p->parent;`
53			`return p->sibling;`
54			`}`
55
56			`static void r_start(struct seq_file m, loff_t *pos)`
57			`__acquires(resource_lock)`
58			`{`
59			`struct resource *p = m->private;`
60			`loff_t l = 0;`
61			`read_lock(&resource_lock);`
62			`for (p = p->child; p && l < *pos; p = r_next(m, p, &l))`
63			`;`
64			`return p;`
65			`}`
66
67			`static void r_stop(struct seq_file m, void v)`
68			`__releases(resource_lock)`
69			`{`
70			`read_unlock(&resource_lock);`
71			`}`
72
73			`static int r_show(struct seq_file m, void v)`
74			`{`
75			`struct resource *root = m->private;`
76			`struct resource r = v, p;`
77			`int width = root->end < 0x10000 ? 4 : 8;`
78			`int depth;`
79
80			`for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)`
81			`if (p->parent == root)`
82			`break;`
83			`seq_printf(m, "%s%0llx-%0*llx : %s\n",`
84			`depth * 2, "",`
85			`width, (unsigned long long) r->start,`
86			`width, (unsigned long long) r->end,`
87			`r->name ? r->name : "<BAD>");`
88			`return 0;`
89			`}`
90
91			`static const struct seq_operations resource_op = {`
92			`.start = r_start,`
93			`.next = r_next,`
94			`.stop = r_stop,`
95			`.show = r_show,`
96			`};`
97
98			`static int ioports_open(struct inode inode, struct file file)`
99			`{`
100			`int res = seq_open(file, &resource_op);`
101			`if (!res) {`
102			`struct seq_file *m = file->private_data;`
103			`m->private = &ioport_resource;`
104			`}`
105			`return res;`
106			`}`
107
108			`static int iomem_open(struct inode inode, struct file file)`
109			`{`
110			`int res = seq_open(file, &resource_op);`
111			`if (!res) {`
112			`struct seq_file *m = file->private_data;`
113			`m->private = &iomem_resource;`
114			`}`
115			`return res;`
116			`}`
117
118			`static const struct file_operations proc_ioports_operations = {`
119			`.open = ioports_open,`
120			`.read = seq_read,`
121			`.llseek = seq_lseek,`
122			`.release = seq_release,`
123			`};`
124
125			`static const struct file_operations proc_iomem_operations = {`
126			`.open = iomem_open,`
127			`.read = seq_read,`
128			`.llseek = seq_lseek,`
129			`.release = seq_release,`
130			`};`
131
132			`static int __init ioresources_init(void)`
133			`{`
134			`struct proc_dir_entry *entry;`
135
136			`entry = create_proc_entry("ioports", 0, NULL);`
137			`if (entry)`
138			`entry->proc_fops = &proc_ioports_operations;`
139			`entry = create_proc_entry("iomem", 0, NULL);`
140			`if (entry)`
141			`entry->proc_fops = &proc_iomem_operations;`
142			`return 0;`
143			`}`
144			`__initcall(ioresources_init);`
145
146			`#endif /* CONFIG_PROC_FS */`
147
148			`/* Return the conflict entry if you can't request it */`
149			`static struct resource * __request_resource(struct resource root, struct resource new)`
150			`{`
151			`resource_size_t start = new->start;`
152			`resource_size_t end = new->end;`
153			`struct resource tmp, *p;`
154
155			`if (end < start)`
156			`return root;`
157			`if (start < root->start)`
158			`return root;`
159			`if (end > root->end)`
160			`return root;`
161			`p = &root->child;`
162			`for (;;) {`
163			`tmp = *p;`
164			`if (!tmp \|\| tmp->start > end) {`
165			`new->sibling = tmp;`
166			`*p = new;`
167			`new->parent = root;`
168			`return NULL;`
169			`}`
170			`p = &tmp->sibling;`
171			`if (tmp->end < start)`
172			`continue;`
173			`return tmp;`
174			`}`
175			`}`
176
177			`static int __release_resource(struct resource *old)`
178			`{`
179			`struct resource tmp, *p;`
180
181			`p = &old->parent->child;`
182			`for (;;) {`
183			`tmp = *p;`
184			`if (!tmp)`
185			`break;`
186			`if (tmp == old) {`
187			`*p = tmp->sibling;`
188			`old->parent = NULL;`
189			`return 0;`
190			`}`
191			`p = &tmp->sibling;`
192			`}`
193			`return -EINVAL;`
194			`}`
195
196			`/**`
197			`* request_resource - request and reserve an I/O or memory resource`
198			`* @root: root resource descriptor`
199			`* @new: resource descriptor desired by caller`
200			`*`
201			`* Returns 0 for success, negative error code on error.`
202			`*/`
203			`int request_resource(struct resource root, struct resource new)`
204			`{`
205			`struct resource *conflict;`
206
207			`write_lock(&resource_lock);`
208			`conflict = __request_resource(root, new);`
209			`write_unlock(&resource_lock);`
210			`return conflict ? -EBUSY : 0;`
211			`}`
212
213			`EXPORT_SYMBOL(request_resource);`
214
215			`/**`
216			`* release_resource - release a previously reserved resource`
217			`* @old: resource pointer`
218			`*/`
219			`int release_resource(struct resource *old)`
220			`{`
221			`int retval;`
222
223			`write_lock(&resource_lock);`
224			`retval = __release_resource(old);`
225			`write_unlock(&resource_lock);`
226			`return retval;`
227			`}`
228
229			`EXPORT_SYMBOL(release_resource);`
230
231			`#ifdef CONFIG_MEMORY_HOTPLUG`
232			`/*`
233			`* Finds the lowest memory reosurce exists within [res->start.res->end)`
234			`* the caller must specify res->start, res->end, res->flags.`
235			`* If found, returns 0, res is overwritten, if not found, returns -1.`
236			`*/`
237			`static int find_next_system_ram(struct resource *res)`
238			`{`
239			`resource_size_t start, end;`
240			`struct resource *p;`
241
242			`BUG_ON(!res);`
243
244			`start = res->start;`
245			`end = res->end;`
246			`BUG_ON(start >= end);`
247
248			`read_lock(&resource_lock);`
249			`for (p = iomem_resource.child; p ; p = p->sibling) {`
250			`/* system ram is just marked as IORESOURCE_MEM */`
251			`if (p->flags != res->flags)`
252			`continue;`
253			`if (p->start > end) {`
254			`p = NULL;`
255			`break;`
256			`}`
257			`if ((p->end >= start) && (p->start < end))`
258			`break;`
259			`}`
260			`read_unlock(&resource_lock);`
261			`if (!p)`
262			`return -1;`
263			`/* copy data */`
264			`if (res->start < p->start)`
265			`res->start = p->start;`
266			`if (res->end > p->end)`
267			`res->end = p->end;`
268			`return 0;`
269			`}`
270			`int`
271			`walk_memory_resource(unsigned long start_pfn, unsigned long nr_pages, void *arg,`
272			`int (func)(unsigned long, unsigned long, void ))`
273			`{`
274			`struct resource res;`
275			`unsigned long pfn, len;`
276			`u64 orig_end;`
277			`int ret = -1;`
278			`res.start = (u64) start_pfn << PAGE_SHIFT;`
279			`res.end = ((u64)(start_pfn + nr_pages) << PAGE_SHIFT) - 1;`
280			`res.flags = IORESOURCE_MEM \| IORESOURCE_BUSY;`
281			`orig_end = res.end;`
282			`while ((res.start < res.end) && (find_next_system_ram(&res) >= 0)) {`
283			`pfn = (unsigned long)(res.start >> PAGE_SHIFT);`
284			`len = (unsigned long)((res.end + 1 - res.start) >> PAGE_SHIFT);`
285			`ret = (*func)(pfn, len, arg);`
286			`if (ret)`
287			`break;`
288			`res.start = res.end + 1;`
289			`res.end = orig_end;`
290			`}`
291			`return ret;`
292			`}`
293
294			`#endif`
295
296			`/*`
297			`* Find empty slot in the resource tree given range and alignment.`
298			`*/`
299			`static int find_resource(struct resource root, struct resource new,`
300			`resource_size_t size, resource_size_t min,`
301			`resource_size_t max, resource_size_t align,`
302			`void (alignf)(void , struct resource *,`
303			`resource_size_t, resource_size_t),`
304			`void *alignf_data)`
305			`{`
306			`struct resource *this = root->child;`
307
308			`new->start = root->start;`
309			`/*`
310			`* Skip past an allocated resource that starts at 0, since the assignment`
311			`* of this->start - 1 to new->end below would cause an underflow.`
312			`*/`
313			`if (this && this->start == 0) {`
314			`new->start = this->end + 1;`
315			`this = this->sibling;`
316			`}`
317			`for(;;) {`
318			`if (this)`
319			`new->end = this->start - 1;`
320			`else`
321			`new->end = root->end;`
322			`if (new->start < min)`
323			`new->start = min;`
324			`if (new->end > max)`
325			`new->end = max;`
326			`new->start = ALIGN(new->start, align);`
327			`if (alignf)`
328			`alignf(alignf_data, new, size, align);`
329			`if (new->start < new->end && new->end - new->start >= size - 1) {`
330			`new->end = new->start + size - 1;`
331			`return 0;`
332			`}`
333			`if (!this)`
334			`break;`
335			`new->start = this->end + 1;`
336			`this = this->sibling;`
337			`}`
338			`return -EBUSY;`
339			`}`
340
341			`/**`
342			`* allocate_resource - allocate empty slot in the resource tree given range & alignment`
343			`* @root: root resource descriptor`
344			`* @new: resource descriptor desired by caller`
345			`* @size: requested resource region size`
346			`* @min: minimum size to allocate`
347			`* @max: maximum size to allocate`
348			`* @align: alignment requested, in bytes`
349			`* @alignf: alignment function, optional, called if not NULL`
350			`* @alignf_data: arbitrary data to pass to the @alignf function`
351			`*/`
352			`int allocate_resource(struct resource root, struct resource new,`
353			`resource_size_t size, resource_size_t min,`
354			`resource_size_t max, resource_size_t align,`
355			`void (alignf)(void , struct resource *,`
356			`resource_size_t, resource_size_t),`
357			`void *alignf_data)`
358			`{`
359			`int err;`
360
361			`write_lock(&resource_lock);`
362			`err = find_resource(root, new, size, min, max, align, alignf, alignf_data);`
363			`if (err >= 0 && __request_resource(root, new))`
364			`err = -EBUSY;`
365			`write_unlock(&resource_lock);`
366			`return err;`
367			`}`
368
369			`EXPORT_SYMBOL(allocate_resource);`
370
371			`/**`
372			`* insert_resource - Inserts a resource in the resource tree`
373			`* @parent: parent of the new resource`
374			`* @new: new resource to insert`
375			`*`
376			`* Returns 0 on success, -EBUSY if the resource can't be inserted.`
377			`*`
378			`* This function is equivalent to request_resource when no conflict`
379			`* happens. If a conflict happens, and the conflicting resources`
380			`* entirely fit within the range of the new resource, then the new`
381			`* resource is inserted and the conflicting resources become children of`
382			`* the new resource.`
383			`*/`
384			`int insert_resource(struct resource parent, struct resource new)`
385			`{`
386			`int result;`
387			`struct resource first, next;`
388
389			`write_lock(&resource_lock);`
390
391			`for (;; parent = first) {`
392			`result = 0;`
393			`first = __request_resource(parent, new);`
394			`if (!first)`
395			`goto out;`
396
397			`result = -EBUSY;`
398			`if (first == parent)`
399			`goto out;`
400
401			`if ((first->start > new->start) \|\| (first->end < new->end))`
402			`break;`
403			`if ((first->start == new->start) && (first->end == new->end))`
404			`break;`
405			`}`
406
407			`for (next = first; ; next = next->sibling) {`
408			`/* Partial overlap? Bad, and unfixable */`
409			`if (next->start < new->start \|\| next->end > new->end)`
410			`goto out;`
411			`if (!next->sibling)`
412			`break;`
413			`if (next->sibling->start > new->end)`
414			`break;`
415			`}`
416
417			`result = 0;`
418
419			`new->parent = parent;`
420			`new->sibling = next->sibling;`
421			`new->child = first;`
422
423			`next->sibling = NULL;`
424			`for (next = first; next; next = next->sibling)`
425			`next->parent = new;`
426
427			`if (parent->child == first) {`
428			`parent->child = new;`
429			`} else {`
430			`next = parent->child;`
431			`while (next->sibling != first)`
432			`next = next->sibling;`
433			`next->sibling = new;`
434			`}`
435
436			`out:`
437			`write_unlock(&resource_lock);`
438			`return result;`
439			`}`
440
441			`/**`
442			`* adjust_resource - modify a resource's start and size`
443			`* @res: resource to modify`
444			`* @start: new start value`
445			`* @size: new size`
446			`*`
447			`* Given an existing resource, change its start and size to match the`
448			`* arguments. Returns 0 on success, -EBUSY if it can't fit.`
449			`* Existing children of the resource are assumed to be immutable.`
450			`*/`
451			`int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size)`
452			`{`
453			`struct resource tmp, parent = res->parent;`
454			`resource_size_t end = start + size - 1;`
455			`int result = -EBUSY;`
456
457			`write_lock(&resource_lock);`
458
459			`if ((start < parent->start) \|\| (end > parent->end))`
460			`goto out;`
461
462			`for (tmp = res->child; tmp; tmp = tmp->sibling) {`
463			`if ((tmp->start < start) \|\| (tmp->end > end))`
464			`goto out;`
465			`}`
466
467			`if (res->sibling && (res->sibling->start <= end))`
468			`goto out;`
469
470			`tmp = parent->child;`
471			`if (tmp != res) {`
472			`while (tmp->sibling != res)`
473			`tmp = tmp->sibling;`
474			`if (start <= tmp->end)`
475			`goto out;`
476			`}`
477
478			`res->start = start;`
479			`res->end = end;`
480			`result = 0;`
481
482			`out:`
483			`write_unlock(&resource_lock);`
484			`return result;`
485			`}`
486
487			`EXPORT_SYMBOL(adjust_resource);`
488
489			`/*`
490			`* This is compatibility stuff for IO resources.`
491			`*`
492			`* Note how this, unlike the above, knows about`
493			`* the IO flag meanings (busy etc).`
494			`*`
495			`* request_region creates a new busy region.`
496			`*`
497			`* check_region returns non-zero if the area is already busy.`
498			`*`
499			`* release_region releases a matching busy region.`
500			`*/`
501
502			`/**`
503			`* __request_region - create a new busy resource region`
504			`* @parent: parent resource descriptor`
505			`* @start: resource start address`
506			`* @n: resource region size`
507			`* @name: reserving caller's ID string`
508			`*/`
509			`struct resource * __request_region(struct resource *parent,`
510			`resource_size_t start, resource_size_t n,`
511			`const char *name)`
512			`{`
513			`struct resource res = kzalloc(sizeof(res), GFP_KERNEL);`
514
515			`if (res) {`
516			`res->name = name;`
517			`res->start = start;`
518			`res->end = start + n - 1;`
519			`res->flags = IORESOURCE_BUSY;`
520
521			`write_lock(&resource_lock);`
522
523			`for (;;) {`
524			`struct resource *conflict;`
525
526			`conflict = __request_resource(parent, res);`
527			`if (!conflict)`
528			`break;`
529			`if (conflict != parent) {`
530			`parent = conflict;`
531			`if (!(conflict->flags & IORESOURCE_BUSY))`
532			`continue;`
533			`}`
534
535			`/* Uhhuh, that didn't work out.. */`
536			`kfree(res);`
537			`res = NULL;`
538			`break;`
539			`}`
540			`write_unlock(&resource_lock);`
541			`}`
542			`return res;`
543			`}`
544			`EXPORT_SYMBOL(__request_region);`
545
546			`/**`
547			`* __check_region - check if a resource region is busy or free`
548			`* @parent: parent resource descriptor`
549			`* @start: resource start address`
550			`* @n: resource region size`
551			`*`
552			`* Returns 0 if the region is free at the moment it is checked,`
553			`* returns %-EBUSY if the region is busy.`
554			`*`
555			`* NOTE:`
556			`* This function is deprecated because its use is racy.`
557			`* Even if it returns 0, a subsequent call to request_region()`
558			`* may fail because another driver etc. just allocated the region.`
559			`* Do NOT use it. It will be removed from the kernel.`
560			`*/`
561			`int __check_region(struct resource *parent, resource_size_t start,`
562			`resource_size_t n)`
563			`{`
564			`struct resource * res;`
565
566			`res = __request_region(parent, start, n, "check-region");`
567			`if (!res)`
568			`return -EBUSY;`
569
570			`release_resource(res);`
571			`kfree(res);`
572			`return 0;`
573			`}`
574			`EXPORT_SYMBOL(__check_region);`
575
576			`/**`
577			`* __release_region - release a previously reserved resource region`
578			`* @parent: parent resource descriptor`
579			`* @start: resource start address`
580			`* @n: resource region size`
581			`*`
582			`* The described resource region must match a currently busy region.`
583			`*/`
584			`void __release_region(struct resource *parent, resource_size_t start,`
585			`resource_size_t n)`
586			`{`
587			`struct resource **p;`
588			`resource_size_t end;`
589
590			`p = &parent->child;`
591			`end = start + n - 1;`
592
593			`write_lock(&resource_lock);`
594
595			`for (;;) {`
596			`struct resource res = p;`
597
598			`if (!res)`
599			`break;`
600			`if (res->start <= start && res->end >= end) {`
601			`if (!(res->flags & IORESOURCE_BUSY)) {`
602			`p = &res->child;`
603			`continue;`
604			`}`
605			`if (res->start != start \|\| res->end != end)`
606			`break;`
607			`*p = res->sibling;`
608			`write_unlock(&resource_lock);`
609			`kfree(res);`
610			`return;`
611			`}`
612			`p = &res->sibling;`
613			`}`
614
615			`write_unlock(&resource_lock);`
616
617			`printk(KERN_WARNING "Trying to free nonexistent resource "`
618			`"<%016llx-%016llx>\n", (unsigned long long)start,`
619			`(unsigned long long)end);`
620			`}`
621			`EXPORT_SYMBOL(__release_region);`
622
623			`/*`
624			`* Managed region resource`
625			`*/`
626			`struct region_devres {`
627			`struct resource *parent;`
628			`resource_size_t start;`
629			`resource_size_t n;`
630			`};`
631
632			`static void devm_region_release(struct device dev, void res)`
633			`{`
634			`struct region_devres *this = res;`
635
636			`__release_region(this->parent, this->start, this->n);`
637			`}`
638
639			`static int devm_region_match(struct device dev, void res, void *match_data)`
640			`{`
641			`struct region_devres this = res, match = match_data;`
642
643			`return this->parent == match->parent &&`
644			`this->start == match->start && this->n == match->n;`
645			`}`
646
647			`struct resource * __devm_request_region(struct device *dev,`
648			`struct resource *parent, resource_size_t start,`
649			`resource_size_t n, const char *name)`
650			`{`
651			`struct region_devres *dr = NULL;`
652			`struct resource *res;`
653
654			`dr = devres_alloc(devm_region_release, sizeof(struct region_devres),`
655			`GFP_KERNEL);`
656			`if (!dr)`
657			`return NULL;`
658
659			`dr->parent = parent;`
660			`dr->start = start;`
661			`dr->n = n;`
662
663			`res = __request_region(parent, start, n, name);`
664			`if (res)`
665			`devres_add(dev, dr);`
666			`else`
667			`devres_free(dr);`
668
669			`return res;`
670			`}`
671			`EXPORT_SYMBOL(__devm_request_region);`
672
673			`void __devm_release_region(struct device dev, struct resource parent,`
674			`resource_size_t start, resource_size_t n)`
675			`{`
676			`struct region_devres match_data = { parent, start, n };`
677
678			`__release_region(parent, start, n);`
679			`WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match,`
680			`&match_data));`
681			`}`
682			`EXPORT_SYMBOL(__devm_release_region);`
683
684			`/*`
685			`* Called from init/main.c to reserve IO ports.`
686			`*/`
687			`#define MAXRESERVE 4`
688			`static int __init reserve_setup(char *str)`
689			`{`
690			`static int reserved;`
691			`static struct resource reserve[MAXRESERVE];`
692
693			`for (;;) {`
694			`int io_start, io_num;`
695			`int x = reserved;`
696
697			`if (get_option (&str, &io_start) != 2)`
698			`break;`
699			`if (get_option (&str, &io_num) == 0)`
700			`break;`
701			`if (x < MAXRESERVE) {`
702			`struct resource *res = reserve + x;`
703			`res->name = "reserved";`
704			`res->start = io_start;`
705			`res->end = io_start + io_num - 1;`
706			`res->flags = IORESOURCE_BUSY;`
707			`res->child = NULL;`
708			`if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0)`
709			`reserved = x+1;`
710			`}`
711			`}`
712			`return 1;`
713			`}`
714
715			`__setup("reserve=", reserve_setup);`