blob: 82aea814d409731e7804d6e553330465d6ab72d9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#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>
Tejun Heo9ac78492007-01-20 16:00:26 +090019#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <asm/io.h>
21
22
23struct resource ioport_resource = {
24 .name = "PCI IO",
Greg Kroah-Hartman6550e072006-06-12 17:11:31 -070025 .start = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -070026 .end = IO_SPACE_LIMIT,
27 .flags = IORESOURCE_IO,
28};
Linus Torvalds1da177e2005-04-16 15:20:36 -070029EXPORT_SYMBOL(ioport_resource);
30
31struct resource iomem_resource = {
32 .name = "PCI mem",
Greg Kroah-Hartman6550e072006-06-12 17:11:31 -070033 .start = 0,
34 .end = -1,
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 .flags = IORESOURCE_MEM,
36};
Linus Torvalds1da177e2005-04-16 15:20:36 -070037EXPORT_SYMBOL(iomem_resource);
38
39static DEFINE_RWLOCK(resource_lock);
40
41#ifdef CONFIG_PROC_FS
42
43enum { MAX_IORES_LEVEL = 5 };
44
45static 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
56static 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
67static void r_stop(struct seq_file *m, void *v)
68 __releases(resource_lock)
69{
70 read_unlock(&resource_lock);
71}
72
73static 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;
Greg Kroah-Hartman685143ac2006-06-12 15:18:31 -070083 seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 depth * 2, "",
Greg Kroah-Hartman685143ac2006-06-12 15:18:31 -070085 width, (unsigned long long) r->start,
86 width, (unsigned long long) r->end,
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 r->name ? r->name : "<BAD>");
88 return 0;
89}
90
Helge Deller15ad7cd2006-12-06 20:40:36 -080091static const struct seq_operations resource_op = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 .start = r_start,
93 .next = r_next,
94 .stop = r_stop,
95 .show = r_show,
96};
97
98static 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
108static 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
Helge Deller15ad7cd2006-12-06 20:40:36 -0800118static const struct file_operations proc_ioports_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 .open = ioports_open,
120 .read = seq_read,
121 .llseek = seq_lseek,
122 .release = seq_release,
123};
124
Helge Deller15ad7cd2006-12-06 20:40:36 -0800125static const struct file_operations proc_iomem_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 .open = iomem_open,
127 .read = seq_read,
128 .llseek = seq_lseek,
129 .release = seq_release,
130};
131
132static 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 */
149static struct resource * __request_resource(struct resource *root, struct resource *new)
150{
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700151 resource_size_t start = new->start;
152 resource_size_t end = new->end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 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
177static 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
Randy Dunlape1ca66d2006-10-03 01:13:51 -0700196/**
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203int 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
213EXPORT_SYMBOL(request_resource);
214
Randy Dunlape1ca66d2006-10-03 01:13:51 -0700215/**
Randy Dunlape1ca66d2006-10-03 01:13:51 -0700216 * release_resource - release a previously reserved resource
217 * @old: resource pointer
218 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219int 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
229EXPORT_SYMBOL(release_resource);
230
Badari Pulavartya99824f2008-02-05 00:10:18 -0800231#if defined(CONFIG_MEMORY_HOTPLUG) && !defined(CONFIG_ARCH_HAS_WALK_MEMORY)
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700232/*
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 */
KAMEZAWA Hiroyuki75884fb2007-10-16 01:26:10 -0700237static int find_next_system_ram(struct resource *res)
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700238{
239 resource_size_t start, end;
240 struct resource *p;
241
242 BUG_ON(!res);
243
244 start = res->start;
245 end = res->end;
KAMEZAWA Hiroyuki58c1b5b2006-08-05 12:15:01 -0700246 BUG_ON(start >= end);
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700247
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 }
KAMEZAWA Hiroyuki58c1b5b2006-08-05 12:15:01 -0700257 if ((p->end >= start) && (p->start < end))
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700258 break;
259 }
260 read_unlock(&resource_lock);
261 if (!p)
262 return -1;
263 /* copy data */
KAMEZAWA Hiroyuki0f04ab52006-08-05 12:14:59 -0700264 if (res->start < p->start)
265 res->start = p->start;
266 if (res->end > p->end)
267 res->end = p->end;
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700268 return 0;
269}
KAMEZAWA Hiroyuki75884fb2007-10-16 01:26:10 -0700270int
271walk_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;
Yasunori Goto887c3cb2007-11-14 16:59:20 -0800280 res.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
KAMEZAWA Hiroyuki75884fb2007-10-16 01:26:10 -0700281 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
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700294#endif
295
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296/*
297 * Find empty slot in the resource tree given range and alignment.
298 */
299static int find_resource(struct resource *root, struct resource *new,
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700300 resource_size_t size, resource_size_t min,
301 resource_size_t max, resource_size_t align,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 void (*alignf)(void *, struct resource *,
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700303 resource_size_t, resource_size_t),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 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;
Nick Wilson8c0e33c2005-06-25 14:59:00 -0700326 new->start = ALIGN(new->start, align);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 if (alignf)
328 alignf(alignf_data, new, size, align);
Lennert Buytenhekb52402c2005-04-16 15:25:58 -0700329 if (new->start < new->end && new->end - new->start >= size - 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 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
Randy Dunlape1ca66d2006-10-03 01:13:51 -0700341/**
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 */
352int allocate_resource(struct resource *root, struct resource *new,
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700353 resource_size_t size, resource_size_t min,
354 resource_size_t max, resource_size_t align,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 void (*alignf)(void *, struct resource *,
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700356 resource_size_t, resource_size_t),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 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
369EXPORT_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 *
Matthew Wilcoxd33b6fb2006-06-30 02:31:24 -0700378 * This function is equivalent to request_resource when no conflict
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 * happens. If a conflict happens, and the conflicting resources
380 * entirely fit within the range of the new resource, then the new
Matthew Wilcoxd33b6fb2006-06-30 02:31:24 -0700381 * resource is inserted and the conflicting resources become children of
382 * the new resource.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 */
384int insert_resource(struct resource *parent, struct resource *new)
385{
386 int result;
387 struct resource *first, *next;
388
389 write_lock(&resource_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Matthew Wilcoxd33b6fb2006-06-30 02:31:24 -0700391 for (;; parent = first) {
392 result = 0;
393 first = __request_resource(parent, new);
394 if (!first)
395 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
Matthew Wilcoxd33b6fb2006-06-30 02:31:24 -0700397 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 }
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
Randy Dunlape1ca66d2006-10-03 01:13:51 -0700441/**
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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 * Given an existing resource, change its start and size to match the
Randy Dunlape1ca66d2006-10-03 01:13:51 -0700448 * arguments. Returns 0 on success, -EBUSY if it can't fit.
449 * Existing children of the resource are assumed to be immutable.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 */
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700451int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452{
453 struct resource *tmp, *parent = res->parent;
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700454 resource_size_t end = start + size - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 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
487EXPORT_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 *
Randy Dunlape1ca66d2006-10-03 01:13:51 -0700495 * request_region creates a new busy region.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 *
Randy Dunlape1ca66d2006-10-03 01:13:51 -0700497 * check_region returns non-zero if the area is already busy.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 *
Randy Dunlape1ca66d2006-10-03 01:13:51 -0700499 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 */
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700509struct resource * __request_region(struct resource *parent,
510 resource_size_t start, resource_size_t n,
511 const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512{
Pekka J Enbergdd392712005-09-06 15:18:31 -0700513 struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
515 if (res) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 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}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544EXPORT_SYMBOL(__request_region);
545
Randy Dunlape1ca66d2006-10-03 01:13:51 -0700546/**
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 */
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700561int __check_region(struct resource *parent, resource_size_t start,
562 resource_size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563{
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}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574EXPORT_SYMBOL(__check_region);
575
Randy Dunlape1ca66d2006-10-03 01:13:51 -0700576/**
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 */
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700584void __release_region(struct resource *parent, resource_size_t start,
585 resource_size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586{
587 struct resource **p;
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700588 resource_size_t end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
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
Greg Kroah-Hartman685143ac2006-06-12 15:18:31 -0700617 printk(KERN_WARNING "Trying to free nonexistent resource "
618 "<%016llx-%016llx>\n", (unsigned long long)start,
619 (unsigned long long)end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621EXPORT_SYMBOL(__release_region);
622
623/*
Tejun Heo9ac78492007-01-20 16:00:26 +0900624 * Managed region resource
625 */
626struct region_devres {
627 struct resource *parent;
628 resource_size_t start;
629 resource_size_t n;
630};
631
632static 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
639static 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
647struct 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}
671EXPORT_SYMBOL(__devm_request_region);
672
673void __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}
682EXPORT_SYMBOL(__devm_release_region);
683
684/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 * Called from init/main.c to reserve IO ports.
686 */
687#define MAXRESERVE 4
688static 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);