2 * linux/kernel/resource.c
4 * Copyright (C) 1999 Linus Torvalds
5 * Copyright (C) 1999 Martin Mares <mj@ucw.cz>
7 * Arbitrary resource management.
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>
17 #include <linux/proc_fs.h>
18 #include <linux/seq_file.h>
19 #include <linux/device.h>
23 struct resource ioport_resource = {
26 .end = IO_SPACE_LIMIT,
27 .flags = IORESOURCE_IO,
29 EXPORT_SYMBOL(ioport_resource);
31 struct resource iomem_resource = {
35 .flags = IORESOURCE_MEM,
37 EXPORT_SYMBOL(iomem_resource);
39 static DEFINE_RWLOCK(resource_lock);
43 enum { MAX_IORES_LEVEL = 5 };
45 static void *r_next(struct seq_file *m, void *v, loff_t *pos)
47 struct resource *p = v;
51 while (!p->sibling && p->parent)
56 static void *r_start(struct seq_file *m, loff_t *pos)
57 __acquires(resource_lock)
59 struct resource *p = m->private;
61 read_lock(&resource_lock);
62 for (p = p->child; p && l < *pos; p = r_next(m, p, &l))
67 static void r_stop(struct seq_file *m, void *v)
68 __releases(resource_lock)
70 read_unlock(&resource_lock);
73 static int r_show(struct seq_file *m, void *v)
75 struct resource *root = m->private;
76 struct resource *r = v, *p;
77 int width = root->end < 0x10000 ? 4 : 8;
80 for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)
81 if (p->parent == root)
83 seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
85 width, (unsigned long long) r->start,
86 width, (unsigned long long) r->end,
87 r->name ? r->name : "<BAD>");
91 static const struct seq_operations resource_op = {
98 static int ioports_open(struct inode *inode, struct file *file)
100 int res = seq_open(file, &resource_op);
102 struct seq_file *m = file->private_data;
103 m->private = &ioport_resource;
108 static int iomem_open(struct inode *inode, struct file *file)
110 int res = seq_open(file, &resource_op);
112 struct seq_file *m = file->private_data;
113 m->private = &iomem_resource;
118 static const struct file_operations proc_ioports_operations = {
119 .open = ioports_open,
122 .release = seq_release,
125 static const struct file_operations proc_iomem_operations = {
129 .release = seq_release,
132 static int __init ioresources_init(void)
134 struct proc_dir_entry *entry;
136 entry = create_proc_entry("ioports", 0, NULL);
138 entry->proc_fops = &proc_ioports_operations;
139 entry = create_proc_entry("iomem", 0, NULL);
141 entry->proc_fops = &proc_iomem_operations;
144 __initcall(ioresources_init);
146 #endif /* CONFIG_PROC_FS */
148 /* Return the conflict entry if you can't request it */
149 static struct resource * __request_resource(struct resource *root, struct resource *new)
151 resource_size_t start = new->start;
152 resource_size_t end = new->end;
153 struct resource *tmp, **p;
157 if (start < root->start)
164 if (!tmp || tmp->start > end) {
171 if (tmp->end < start)
177 static int __release_resource(struct resource *old)
179 struct resource *tmp, **p;
181 p = &old->parent->child;
197 * request_resource - request and reserve an I/O or memory resource
198 * @root: root resource descriptor
199 * @new: resource descriptor desired by caller
201 * Returns 0 for success, negative error code on error.
203 int request_resource(struct resource *root, struct resource *new)
205 struct resource *conflict;
207 write_lock(&resource_lock);
208 conflict = __request_resource(root, new);
209 write_unlock(&resource_lock);
210 return conflict ? -EBUSY : 0;
213 EXPORT_SYMBOL(request_resource);
216 * release_resource - release a previously reserved resource
217 * @old: resource pointer
219 int release_resource(struct resource *old)
223 write_lock(&resource_lock);
224 retval = __release_resource(old);
225 write_unlock(&resource_lock);
229 EXPORT_SYMBOL(release_resource);
231 #ifdef CONFIG_MEMORY_HOTPLUG
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.
237 int find_next_system_ram(struct resource *res)
239 resource_size_t start, end;
246 BUG_ON(start >= end);
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)
253 if (p->start > end) {
257 if ((p->end >= start) && (p->start < end))
260 read_unlock(&resource_lock);
264 if (res->start < p->start)
265 res->start = p->start;
266 if (res->end > p->end)
273 * Find empty slot in the resource tree given range and alignment.
275 static int find_resource(struct resource *root, struct resource *new,
276 resource_size_t size, resource_size_t min,
277 resource_size_t max, resource_size_t align,
278 void (*alignf)(void *, struct resource *,
279 resource_size_t, resource_size_t),
282 struct resource *this = root->child;
284 new->start = root->start;
286 * Skip past an allocated resource that starts at 0, since the assignment
287 * of this->start - 1 to new->end below would cause an underflow.
289 if (this && this->start == 0) {
290 new->start = this->end + 1;
291 this = this->sibling;
295 new->end = this->start - 1;
297 new->end = root->end;
298 if (new->start < min)
302 new->start = ALIGN(new->start, align);
304 alignf(alignf_data, new, size, align);
305 if (new->start < new->end && new->end - new->start >= size - 1) {
306 new->end = new->start + size - 1;
311 new->start = this->end + 1;
312 this = this->sibling;
318 * allocate_resource - allocate empty slot in the resource tree given range & alignment
319 * @root: root resource descriptor
320 * @new: resource descriptor desired by caller
321 * @size: requested resource region size
322 * @min: minimum size to allocate
323 * @max: maximum size to allocate
324 * @align: alignment requested, in bytes
325 * @alignf: alignment function, optional, called if not NULL
326 * @alignf_data: arbitrary data to pass to the @alignf function
328 int allocate_resource(struct resource *root, struct resource *new,
329 resource_size_t size, resource_size_t min,
330 resource_size_t max, resource_size_t align,
331 void (*alignf)(void *, struct resource *,
332 resource_size_t, resource_size_t),
337 write_lock(&resource_lock);
338 err = find_resource(root, new, size, min, max, align, alignf, alignf_data);
339 if (err >= 0 && __request_resource(root, new))
341 write_unlock(&resource_lock);
345 EXPORT_SYMBOL(allocate_resource);
348 * insert_resource - Inserts a resource in the resource tree
349 * @parent: parent of the new resource
350 * @new: new resource to insert
352 * Returns 0 on success, -EBUSY if the resource can't be inserted.
354 * This function is equivalent to request_resource when no conflict
355 * happens. If a conflict happens, and the conflicting resources
356 * entirely fit within the range of the new resource, then the new
357 * resource is inserted and the conflicting resources become children of
360 int insert_resource(struct resource *parent, struct resource *new)
363 struct resource *first, *next;
365 write_lock(&resource_lock);
367 for (;; parent = first) {
369 first = __request_resource(parent, new);
377 if ((first->start > new->start) || (first->end < new->end))
379 if ((first->start == new->start) && (first->end == new->end))
383 for (next = first; ; next = next->sibling) {
384 /* Partial overlap? Bad, and unfixable */
385 if (next->start < new->start || next->end > new->end)
389 if (next->sibling->start > new->end)
395 new->parent = parent;
396 new->sibling = next->sibling;
399 next->sibling = NULL;
400 for (next = first; next; next = next->sibling)
403 if (parent->child == first) {
406 next = parent->child;
407 while (next->sibling != first)
408 next = next->sibling;
413 write_unlock(&resource_lock);
418 * adjust_resource - modify a resource's start and size
419 * @res: resource to modify
420 * @start: new start value
423 * Given an existing resource, change its start and size to match the
424 * arguments. Returns 0 on success, -EBUSY if it can't fit.
425 * Existing children of the resource are assumed to be immutable.
427 int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size)
429 struct resource *tmp, *parent = res->parent;
430 resource_size_t end = start + size - 1;
433 write_lock(&resource_lock);
435 if ((start < parent->start) || (end > parent->end))
438 for (tmp = res->child; tmp; tmp = tmp->sibling) {
439 if ((tmp->start < start) || (tmp->end > end))
443 if (res->sibling && (res->sibling->start <= end))
448 while (tmp->sibling != res)
450 if (start <= tmp->end)
459 write_unlock(&resource_lock);
463 EXPORT_SYMBOL(adjust_resource);
466 * This is compatibility stuff for IO resources.
468 * Note how this, unlike the above, knows about
469 * the IO flag meanings (busy etc).
471 * request_region creates a new busy region.
473 * check_region returns non-zero if the area is already busy.
475 * release_region releases a matching busy region.
479 * __request_region - create a new busy resource region
480 * @parent: parent resource descriptor
481 * @start: resource start address
482 * @n: resource region size
483 * @name: reserving caller's ID string
485 struct resource * __request_region(struct resource *parent,
486 resource_size_t start, resource_size_t n,
489 struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
494 res->end = start + n - 1;
495 res->flags = IORESOURCE_BUSY;
497 write_lock(&resource_lock);
500 struct resource *conflict;
502 conflict = __request_resource(parent, res);
505 if (conflict != parent) {
507 if (!(conflict->flags & IORESOURCE_BUSY))
511 /* Uhhuh, that didn't work out.. */
516 write_unlock(&resource_lock);
520 EXPORT_SYMBOL(__request_region);
523 * __check_region - check if a resource region is busy or free
524 * @parent: parent resource descriptor
525 * @start: resource start address
526 * @n: resource region size
528 * Returns 0 if the region is free at the moment it is checked,
529 * returns %-EBUSY if the region is busy.
532 * This function is deprecated because its use is racy.
533 * Even if it returns 0, a subsequent call to request_region()
534 * may fail because another driver etc. just allocated the region.
535 * Do NOT use it. It will be removed from the kernel.
537 int __check_region(struct resource *parent, resource_size_t start,
540 struct resource * res;
542 res = __request_region(parent, start, n, "check-region");
546 release_resource(res);
550 EXPORT_SYMBOL(__check_region);
553 * __release_region - release a previously reserved resource region
554 * @parent: parent resource descriptor
555 * @start: resource start address
556 * @n: resource region size
558 * The described resource region must match a currently busy region.
560 void __release_region(struct resource *parent, resource_size_t start,
569 write_lock(&resource_lock);
572 struct resource *res = *p;
576 if (res->start <= start && res->end >= end) {
577 if (!(res->flags & IORESOURCE_BUSY)) {
581 if (res->start != start || res->end != end)
584 write_unlock(&resource_lock);
591 write_unlock(&resource_lock);
593 printk(KERN_WARNING "Trying to free nonexistent resource "
594 "<%016llx-%016llx>\n", (unsigned long long)start,
595 (unsigned long long)end);
597 EXPORT_SYMBOL(__release_region);
600 * Managed region resource
602 struct region_devres {
603 struct resource *parent;
604 resource_size_t start;
608 static void devm_region_release(struct device *dev, void *res)
610 struct region_devres *this = res;
612 __release_region(this->parent, this->start, this->n);
615 static int devm_region_match(struct device *dev, void *res, void *match_data)
617 struct region_devres *this = res, *match = match_data;
619 return this->parent == match->parent &&
620 this->start == match->start && this->n == match->n;
623 struct resource * __devm_request_region(struct device *dev,
624 struct resource *parent, resource_size_t start,
625 resource_size_t n, const char *name)
627 struct region_devres *dr = NULL;
628 struct resource *res;
630 dr = devres_alloc(devm_region_release, sizeof(struct region_devres),
639 res = __request_region(parent, start, n, name);
647 EXPORT_SYMBOL(__devm_request_region);
649 void __devm_release_region(struct device *dev, struct resource *parent,
650 resource_size_t start, resource_size_t n)
652 struct region_devres match_data = { parent, start, n };
654 __release_region(parent, start, n);
655 WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match,
658 EXPORT_SYMBOL(__devm_release_region);
661 * Called from init/main.c to reserve IO ports.
664 static int __init reserve_setup(char *str)
667 static struct resource reserve[MAXRESERVE];
670 int io_start, io_num;
673 if (get_option (&str, &io_start) != 2)
675 if (get_option (&str, &io_num) == 0)
677 if (x < MAXRESERVE) {
678 struct resource *res = reserve + x;
679 res->name = "reserved";
680 res->start = io_start;
681 res->end = io_start + io_num - 1;
682 res->flags = IORESOURCE_BUSY;
684 if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0)
691 __setup("reserve=", reserve_setup);