9c358e26353427b5a553e900014359c80c4eced2
[linux-2.6.git] / kernel / resource.c
1 /*
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 <linux/pfn.h>
21 #include <asm/io.h>
22
23
24 struct resource ioport_resource = {
25         .name   = "PCI IO",
26         .start  = 0,
27         .end    = IO_SPACE_LIMIT,
28         .flags  = IORESOURCE_IO,
29 };
30 EXPORT_SYMBOL(ioport_resource);
31
32 struct resource iomem_resource = {
33         .name   = "PCI mem",
34         .start  = 0,
35         .end    = -1,
36         .flags  = IORESOURCE_MEM,
37 };
38 EXPORT_SYMBOL(iomem_resource);
39
40 static DEFINE_RWLOCK(resource_lock);
41
42 static void *r_next(struct seq_file *m, void *v, loff_t *pos)
43 {
44         struct resource *p = v;
45         (*pos)++;
46         if (p->child)
47                 return p->child;
48         while (!p->sibling && p->parent)
49                 p = p->parent;
50         return p->sibling;
51 }
52
53 #ifdef CONFIG_PROC_FS
54
55 enum { MAX_IORES_LEVEL = 5 };
56
57 static void *r_start(struct seq_file *m, loff_t *pos)
58         __acquires(resource_lock)
59 {
60         struct resource *p = m->private;
61         loff_t l = 0;
62         read_lock(&resource_lock);
63         for (p = p->child; p && l < *pos; p = r_next(m, p, &l))
64                 ;
65         return p;
66 }
67
68 static void r_stop(struct seq_file *m, void *v)
69         __releases(resource_lock)
70 {
71         read_unlock(&resource_lock);
72 }
73
74 static int r_show(struct seq_file *m, void *v)
75 {
76         struct resource *root = m->private;
77         struct resource *r = v, *p;
78         int width = root->end < 0x10000 ? 4 : 8;
79         int depth;
80
81         for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)
82                 if (p->parent == root)
83                         break;
84         seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
85                         depth * 2, "",
86                         width, (unsigned long long) r->start,
87                         width, (unsigned long long) r->end,
88                         r->name ? r->name : "<BAD>");
89         return 0;
90 }
91
92 static const struct seq_operations resource_op = {
93         .start  = r_start,
94         .next   = r_next,
95         .stop   = r_stop,
96         .show   = r_show,
97 };
98
99 static int ioports_open(struct inode *inode, struct file *file)
100 {
101         int res = seq_open(file, &resource_op);
102         if (!res) {
103                 struct seq_file *m = file->private_data;
104                 m->private = &ioport_resource;
105         }
106         return res;
107 }
108
109 static int iomem_open(struct inode *inode, struct file *file)
110 {
111         int res = seq_open(file, &resource_op);
112         if (!res) {
113                 struct seq_file *m = file->private_data;
114                 m->private = &iomem_resource;
115         }
116         return res;
117 }
118
119 static const struct file_operations proc_ioports_operations = {
120         .open           = ioports_open,
121         .read           = seq_read,
122         .llseek         = seq_lseek,
123         .release        = seq_release,
124 };
125
126 static const struct file_operations proc_iomem_operations = {
127         .open           = iomem_open,
128         .read           = seq_read,
129         .llseek         = seq_lseek,
130         .release        = seq_release,
131 };
132
133 static int __init ioresources_init(void)
134 {
135         proc_create("ioports", 0, NULL, &proc_ioports_operations);
136         proc_create("iomem", 0, NULL, &proc_iomem_operations);
137         return 0;
138 }
139 __initcall(ioresources_init);
140
141 #endif /* CONFIG_PROC_FS */
142
143 /* Return the conflict entry if you can't request it */
144 static struct resource * __request_resource(struct resource *root, struct resource *new)
145 {
146         resource_size_t start = new->start;
147         resource_size_t end = new->end;
148         struct resource *tmp, **p;
149
150         if (end < start)
151                 return root;
152         if (start < root->start)
153                 return root;
154         if (end > root->end)
155                 return root;
156         p = &root->child;
157         for (;;) {
158                 tmp = *p;
159                 if (!tmp || tmp->start > end) {
160                         new->sibling = tmp;
161                         *p = new;
162                         new->parent = root;
163                         return NULL;
164                 }
165                 p = &tmp->sibling;
166                 if (tmp->end < start)
167                         continue;
168                 return tmp;
169         }
170 }
171
172 static int __release_resource(struct resource *old)
173 {
174         struct resource *tmp, **p;
175
176         p = &old->parent->child;
177         for (;;) {
178                 tmp = *p;
179                 if (!tmp)
180                         break;
181                 if (tmp == old) {
182                         *p = tmp->sibling;
183                         old->parent = NULL;
184                         return 0;
185                 }
186                 p = &tmp->sibling;
187         }
188         return -EINVAL;
189 }
190
191 static void __release_child_resources(struct resource *r)
192 {
193         struct resource *tmp, *p;
194         resource_size_t size;
195
196         p = r->child;
197         r->child = NULL;
198         while (p) {
199                 tmp = p;
200                 p = p->sibling;
201
202                 tmp->parent = NULL;
203                 tmp->sibling = NULL;
204                 __release_child_resources(tmp);
205
206                 printk(KERN_DEBUG "release child resource %pR\n", tmp);
207                 /* need to restore size, and keep flags */
208                 size = resource_size(tmp);
209                 tmp->start = 0;
210                 tmp->end = size - 1;
211         }
212 }
213
214 void release_child_resources(struct resource *r)
215 {
216         write_lock(&resource_lock);
217         __release_child_resources(r);
218         write_unlock(&resource_lock);
219 }
220
221 /**
222  * request_resource_conflict - request and reserve an I/O or memory resource
223  * @root: root resource descriptor
224  * @new: resource descriptor desired by caller
225  *
226  * Returns 0 for success, conflict resource on error.
227  */
228 struct resource *request_resource_conflict(struct resource *root, struct resource *new)
229 {
230         struct resource *conflict;
231
232         write_lock(&resource_lock);
233         conflict = __request_resource(root, new);
234         write_unlock(&resource_lock);
235         return conflict;
236 }
237
238 /**
239  * request_resource - request and reserve an I/O or memory resource
240  * @root: root resource descriptor
241  * @new: resource descriptor desired by caller
242  *
243  * Returns 0 for success, negative error code on error.
244  */
245 int request_resource(struct resource *root, struct resource *new)
246 {
247         struct resource *conflict;
248
249         conflict = request_resource_conflict(root, new);
250         return conflict ? -EBUSY : 0;
251 }
252
253 EXPORT_SYMBOL(request_resource);
254
255 /**
256  * release_resource - release a previously reserved resource
257  * @old: resource pointer
258  */
259 int release_resource(struct resource *old)
260 {
261         int retval;
262
263         write_lock(&resource_lock);
264         retval = __release_resource(old);
265         write_unlock(&resource_lock);
266         return retval;
267 }
268
269 EXPORT_SYMBOL(release_resource);
270
271 #if !defined(CONFIG_ARCH_HAS_WALK_MEMORY)
272 /*
273  * Finds the lowest memory reosurce exists within [res->start.res->end)
274  * the caller must specify res->start, res->end, res->flags and "name".
275  * If found, returns 0, res is overwritten, if not found, returns -1.
276  */
277 static int find_next_system_ram(struct resource *res, char *name)
278 {
279         resource_size_t start, end;
280         struct resource *p;
281
282         BUG_ON(!res);
283
284         start = res->start;
285         end = res->end;
286         BUG_ON(start >= end);
287
288         read_lock(&resource_lock);
289         for (p = iomem_resource.child; p ; p = p->sibling) {
290                 /* system ram is just marked as IORESOURCE_MEM */
291                 if (p->flags != res->flags)
292                         continue;
293                 if (name && strcmp(p->name, name))
294                         continue;
295                 if (p->start > end) {
296                         p = NULL;
297                         break;
298                 }
299                 if ((p->end >= start) && (p->start < end))
300                         break;
301         }
302         read_unlock(&resource_lock);
303         if (!p)
304                 return -1;
305         /* copy data */
306         if (res->start < p->start)
307                 res->start = p->start;
308         if (res->end > p->end)
309                 res->end = p->end;
310         return 0;
311 }
312
313 /*
314  * This function calls callback against all memory range of "System RAM"
315  * which are marked as IORESOURCE_MEM and IORESOUCE_BUSY.
316  * Now, this function is only for "System RAM".
317  */
318 int walk_system_ram_range(unsigned long start_pfn, unsigned long nr_pages,
319                 void *arg, int (*func)(unsigned long, unsigned long, void *))
320 {
321         struct resource res;
322         unsigned long pfn, end_pfn;
323         u64 orig_end;
324         int ret = -1;
325
326         res.start = (u64) start_pfn << PAGE_SHIFT;
327         res.end = ((u64)(start_pfn + nr_pages) << PAGE_SHIFT) - 1;
328         res.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
329         orig_end = res.end;
330         while ((res.start < res.end) &&
331                 (find_next_system_ram(&res, "System RAM") >= 0)) {
332                 pfn = (res.start + PAGE_SIZE - 1) >> PAGE_SHIFT;
333                 end_pfn = (res.end + 1) >> PAGE_SHIFT;
334                 if (end_pfn > pfn)
335                         ret = (*func)(pfn, end_pfn - pfn, arg);
336                 if (ret)
337                         break;
338                 res.start = res.end + 1;
339                 res.end = orig_end;
340         }
341         return ret;
342 }
343
344 #endif
345
346 static int __is_ram(unsigned long pfn, unsigned long nr_pages, void *arg)
347 {
348         return 1;
349 }
350 /*
351  * This generic page_is_ram() returns true if specified address is
352  * registered as "System RAM" in iomem_resource list.
353  */
354 int __weak page_is_ram(unsigned long pfn)
355 {
356         return walk_system_ram_range(pfn, 1, NULL, __is_ram) == 1;
357 }
358
359 /*
360  * Find empty slot in the resource tree given range and alignment.
361  */
362 static int find_resource(struct resource *root, struct resource *new,
363                          resource_size_t size, resource_size_t min,
364                          resource_size_t max, resource_size_t align,
365                          resource_size_t (*alignf)(void *,
366                                                    const struct resource *,
367                                                    resource_size_t,
368                                                    resource_size_t),
369                          void *alignf_data)
370 {
371         struct resource *this = root->child;
372         struct resource tmp = *new;
373
374         tmp.start = root->start;
375         /*
376          * Skip past an allocated resource that starts at 0, since the assignment
377          * of this->start - 1 to tmp->end below would cause an underflow.
378          */
379         if (this && this->start == 0) {
380                 tmp.start = this->end + 1;
381                 this = this->sibling;
382         }
383         for(;;) {
384                 if (this)
385                         tmp.end = this->start - 1;
386                 else
387                         tmp.end = root->end;
388                 if (tmp.start < min)
389                         tmp.start = min;
390                 if (tmp.end > max)
391                         tmp.end = max;
392                 tmp.start = ALIGN(tmp.start, align);
393                 if (alignf)
394                         tmp.start = alignf(alignf_data, &tmp, size, align);
395                 if (tmp.start < tmp.end && tmp.end - tmp.start >= size - 1) {
396                         new->start = tmp.start;
397                         new->end = tmp.start + size - 1;
398                         return 0;
399                 }
400                 if (!this)
401                         break;
402                 tmp.start = this->end + 1;
403                 this = this->sibling;
404         }
405         return -EBUSY;
406 }
407
408 /**
409  * allocate_resource - allocate empty slot in the resource tree given range & alignment
410  * @root: root resource descriptor
411  * @new: resource descriptor desired by caller
412  * @size: requested resource region size
413  * @min: minimum size to allocate
414  * @max: maximum size to allocate
415  * @align: alignment requested, in bytes
416  * @alignf: alignment function, optional, called if not NULL
417  * @alignf_data: arbitrary data to pass to the @alignf function
418  */
419 int allocate_resource(struct resource *root, struct resource *new,
420                       resource_size_t size, resource_size_t min,
421                       resource_size_t max, resource_size_t align,
422                       resource_size_t (*alignf)(void *,
423                                                 const struct resource *,
424                                                 resource_size_t,
425                                                 resource_size_t),
426                       void *alignf_data)
427 {
428         int err;
429
430         write_lock(&resource_lock);
431         err = find_resource(root, new, size, min, max, align, alignf, alignf_data);
432         if (err >= 0 && __request_resource(root, new))
433                 err = -EBUSY;
434         write_unlock(&resource_lock);
435         return err;
436 }
437
438 EXPORT_SYMBOL(allocate_resource);
439
440 /*
441  * Insert a resource into the resource tree. If successful, return NULL,
442  * otherwise return the conflicting resource (compare to __request_resource())
443  */
444 static struct resource * __insert_resource(struct resource *parent, struct resource *new)
445 {
446         struct resource *first, *next;
447
448         for (;; parent = first) {
449                 first = __request_resource(parent, new);
450                 if (!first)
451                         return first;
452
453                 if (first == parent)
454                         return first;
455
456                 if ((first->start > new->start) || (first->end < new->end))
457                         break;
458                 if ((first->start == new->start) && (first->end == new->end))
459                         break;
460         }
461
462         for (next = first; ; next = next->sibling) {
463                 /* Partial overlap? Bad, and unfixable */
464                 if (next->start < new->start || next->end > new->end)
465                         return next;
466                 if (!next->sibling)
467                         break;
468                 if (next->sibling->start > new->end)
469                         break;
470         }
471
472         new->parent = parent;
473         new->sibling = next->sibling;
474         new->child = first;
475
476         next->sibling = NULL;
477         for (next = first; next; next = next->sibling)
478                 next->parent = new;
479
480         if (parent->child == first) {
481                 parent->child = new;
482         } else {
483                 next = parent->child;
484                 while (next->sibling != first)
485                         next = next->sibling;
486                 next->sibling = new;
487         }
488         return NULL;
489 }
490
491 /**
492  * insert_resource_conflict - Inserts resource in the resource tree
493  * @parent: parent of the new resource
494  * @new: new resource to insert
495  *
496  * Returns 0 on success, conflict resource if the resource can't be inserted.
497  *
498  * This function is equivalent to request_resource_conflict when no conflict
499  * happens. If a conflict happens, and the conflicting resources
500  * entirely fit within the range of the new resource, then the new
501  * resource is inserted and the conflicting resources become children of
502  * the new resource.
503  */
504 struct resource *insert_resource_conflict(struct resource *parent, struct resource *new)
505 {
506         struct resource *conflict;
507
508         write_lock(&resource_lock);
509         conflict = __insert_resource(parent, new);
510         write_unlock(&resource_lock);
511         return conflict;
512 }
513
514 /**
515  * insert_resource - Inserts a resource in the resource tree
516  * @parent: parent of the new resource
517  * @new: new resource to insert
518  *
519  * Returns 0 on success, -EBUSY if the resource can't be inserted.
520  */
521 int insert_resource(struct resource *parent, struct resource *new)
522 {
523         struct resource *conflict;
524
525         conflict = insert_resource_conflict(parent, new);
526         return conflict ? -EBUSY : 0;
527 }
528
529 /**
530  * insert_resource_expand_to_fit - Insert a resource into the resource tree
531  * @root: root resource descriptor
532  * @new: new resource to insert
533  *
534  * Insert a resource into the resource tree, possibly expanding it in order
535  * to make it encompass any conflicting resources.
536  */
537 void insert_resource_expand_to_fit(struct resource *root, struct resource *new)
538 {
539         if (new->parent)
540                 return;
541
542         write_lock(&resource_lock);
543         for (;;) {
544                 struct resource *conflict;
545
546                 conflict = __insert_resource(root, new);
547                 if (!conflict)
548                         break;
549                 if (conflict == root)
550                         break;
551
552                 /* Ok, expand resource to cover the conflict, then try again .. */
553                 if (conflict->start < new->start)
554                         new->start = conflict->start;
555                 if (conflict->end > new->end)
556                         new->end = conflict->end;
557
558                 printk("Expanded resource %s due to conflict with %s\n", new->name, conflict->name);
559         }
560         write_unlock(&resource_lock);
561 }
562
563 /**
564  * adjust_resource - modify a resource's start and size
565  * @res: resource to modify
566  * @start: new start value
567  * @size: new size
568  *
569  * Given an existing resource, change its start and size to match the
570  * arguments.  Returns 0 on success, -EBUSY if it can't fit.
571  * Existing children of the resource are assumed to be immutable.
572  */
573 int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size)
574 {
575         struct resource *tmp, *parent = res->parent;
576         resource_size_t end = start + size - 1;
577         int result = -EBUSY;
578
579         write_lock(&resource_lock);
580
581         if ((start < parent->start) || (end > parent->end))
582                 goto out;
583
584         for (tmp = res->child; tmp; tmp = tmp->sibling) {
585                 if ((tmp->start < start) || (tmp->end > end))
586                         goto out;
587         }
588
589         if (res->sibling && (res->sibling->start <= end))
590                 goto out;
591
592         tmp = parent->child;
593         if (tmp != res) {
594                 while (tmp->sibling != res)
595                         tmp = tmp->sibling;
596                 if (start <= tmp->end)
597                         goto out;
598         }
599
600         res->start = start;
601         res->end = end;
602         result = 0;
603
604  out:
605         write_unlock(&resource_lock);
606         return result;
607 }
608
609 static void __init __reserve_region_with_split(struct resource *root,
610                 resource_size_t start, resource_size_t end,
611                 const char *name)
612 {
613         struct resource *parent = root;
614         struct resource *conflict;
615         struct resource *res = kzalloc(sizeof(*res), GFP_ATOMIC);
616
617         if (!res)
618                 return;
619
620         res->name = name;
621         res->start = start;
622         res->end = end;
623         res->flags = IORESOURCE_BUSY;
624
625         conflict = __request_resource(parent, res);
626         if (!conflict)
627                 return;
628
629         /* failed, split and try again */
630         kfree(res);
631
632         /* conflict covered whole area */
633         if (conflict->start <= start && conflict->end >= end)
634                 return;
635
636         if (conflict->start > start)
637                 __reserve_region_with_split(root, start, conflict->start-1, name);
638         if (conflict->end < end)
639                 __reserve_region_with_split(root, conflict->end+1, end, name);
640 }
641
642 void __init reserve_region_with_split(struct resource *root,
643                 resource_size_t start, resource_size_t end,
644                 const char *name)
645 {
646         write_lock(&resource_lock);
647         __reserve_region_with_split(root, start, end, name);
648         write_unlock(&resource_lock);
649 }
650
651 EXPORT_SYMBOL(adjust_resource);
652
653 /**
654  * resource_alignment - calculate resource's alignment
655  * @res: resource pointer
656  *
657  * Returns alignment on success, 0 (invalid alignment) on failure.
658  */
659 resource_size_t resource_alignment(struct resource *res)
660 {
661         switch (res->flags & (IORESOURCE_SIZEALIGN | IORESOURCE_STARTALIGN)) {
662         case IORESOURCE_SIZEALIGN:
663                 return resource_size(res);
664         case IORESOURCE_STARTALIGN:
665                 return res->start;
666         default:
667                 return 0;
668         }
669 }
670
671 /*
672  * This is compatibility stuff for IO resources.
673  *
674  * Note how this, unlike the above, knows about
675  * the IO flag meanings (busy etc).
676  *
677  * request_region creates a new busy region.
678  *
679  * check_region returns non-zero if the area is already busy.
680  *
681  * release_region releases a matching busy region.
682  */
683
684 /**
685  * __request_region - create a new busy resource region
686  * @parent: parent resource descriptor
687  * @start: resource start address
688  * @n: resource region size
689  * @name: reserving caller's ID string
690  * @flags: IO resource flags
691  */
692 struct resource * __request_region(struct resource *parent,
693                                    resource_size_t start, resource_size_t n,
694                                    const char *name, int flags)
695 {
696         struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
697
698         if (!res)
699                 return NULL;
700
701         res->name = name;
702         res->start = start;
703         res->end = start + n - 1;
704         res->flags = IORESOURCE_BUSY;
705         res->flags |= flags;
706
707         write_lock(&resource_lock);
708
709         for (;;) {
710                 struct resource *conflict;
711
712                 conflict = __request_resource(parent, res);
713                 if (!conflict)
714                         break;
715                 if (conflict != parent) {
716                         parent = conflict;
717                         if (!(conflict->flags & IORESOURCE_BUSY))
718                                 continue;
719                 }
720
721                 /* Uhhuh, that didn't work out.. */
722                 kfree(res);
723                 res = NULL;
724                 break;
725         }
726         write_unlock(&resource_lock);
727         return res;
728 }
729 EXPORT_SYMBOL(__request_region);
730
731 /**
732  * __check_region - check if a resource region is busy or free
733  * @parent: parent resource descriptor
734  * @start: resource start address
735  * @n: resource region size
736  *
737  * Returns 0 if the region is free at the moment it is checked,
738  * returns %-EBUSY if the region is busy.
739  *
740  * NOTE:
741  * This function is deprecated because its use is racy.
742  * Even if it returns 0, a subsequent call to request_region()
743  * may fail because another driver etc. just allocated the region.
744  * Do NOT use it.  It will be removed from the kernel.
745  */
746 int __check_region(struct resource *parent, resource_size_t start,
747                         resource_size_t n)
748 {
749         struct resource * res;
750
751         res = __request_region(parent, start, n, "check-region", 0);
752         if (!res)
753                 return -EBUSY;
754
755         release_resource(res);
756         kfree(res);
757         return 0;
758 }
759 EXPORT_SYMBOL(__check_region);
760
761 /**
762  * __release_region - release a previously reserved resource region
763  * @parent: parent resource descriptor
764  * @start: resource start address
765  * @n: resource region size
766  *
767  * The described resource region must match a currently busy region.
768  */
769 void __release_region(struct resource *parent, resource_size_t start,
770                         resource_size_t n)
771 {
772         struct resource **p;
773         resource_size_t end;
774
775         p = &parent->child;
776         end = start + n - 1;
777
778         write_lock(&resource_lock);
779
780         for (;;) {
781                 struct resource *res = *p;
782
783                 if (!res)
784                         break;
785                 if (res->start <= start && res->end >= end) {
786                         if (!(res->flags & IORESOURCE_BUSY)) {
787                                 p = &res->child;
788                                 continue;
789                         }
790                         if (res->start != start || res->end != end)
791                                 break;
792                         *p = res->sibling;
793                         write_unlock(&resource_lock);
794                         kfree(res);
795                         return;
796                 }
797                 p = &res->sibling;
798         }
799
800         write_unlock(&resource_lock);
801
802         printk(KERN_WARNING "Trying to free nonexistent resource "
803                 "<%016llx-%016llx>\n", (unsigned long long)start,
804                 (unsigned long long)end);
805 }
806 EXPORT_SYMBOL(__release_region);
807
808 /*
809  * Managed region resource
810  */
811 struct region_devres {
812         struct resource *parent;
813         resource_size_t start;
814         resource_size_t n;
815 };
816
817 static void devm_region_release(struct device *dev, void *res)
818 {
819         struct region_devres *this = res;
820
821         __release_region(this->parent, this->start, this->n);
822 }
823
824 static int devm_region_match(struct device *dev, void *res, void *match_data)
825 {
826         struct region_devres *this = res, *match = match_data;
827
828         return this->parent == match->parent &&
829                 this->start == match->start && this->n == match->n;
830 }
831
832 struct resource * __devm_request_region(struct device *dev,
833                                 struct resource *parent, resource_size_t start,
834                                 resource_size_t n, const char *name)
835 {
836         struct region_devres *dr = NULL;
837         struct resource *res;
838
839         dr = devres_alloc(devm_region_release, sizeof(struct region_devres),
840                           GFP_KERNEL);
841         if (!dr)
842                 return NULL;
843
844         dr->parent = parent;
845         dr->start = start;
846         dr->n = n;
847
848         res = __request_region(parent, start, n, name, 0);
849         if (res)
850                 devres_add(dev, dr);
851         else
852                 devres_free(dr);
853
854         return res;
855 }
856 EXPORT_SYMBOL(__devm_request_region);
857
858 void __devm_release_region(struct device *dev, struct resource *parent,
859                            resource_size_t start, resource_size_t n)
860 {
861         struct region_devres match_data = { parent, start, n };
862
863         __release_region(parent, start, n);
864         WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match,
865                                &match_data));
866 }
867 EXPORT_SYMBOL(__devm_release_region);
868
869 /*
870  * Called from init/main.c to reserve IO ports.
871  */
872 #define MAXRESERVE 4
873 static int __init reserve_setup(char *str)
874 {
875         static int reserved;
876         static struct resource reserve[MAXRESERVE];
877
878         for (;;) {
879                 unsigned int io_start, io_num;
880                 int x = reserved;
881
882                 if (get_option (&str, &io_start) != 2)
883                         break;
884                 if (get_option (&str, &io_num)   == 0)
885                         break;
886                 if (x < MAXRESERVE) {
887                         struct resource *res = reserve + x;
888                         res->name = "reserved";
889                         res->start = io_start;
890                         res->end = io_start + io_num - 1;
891                         res->flags = IORESOURCE_BUSY;
892                         res->child = NULL;
893                         if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0)
894                                 reserved = x+1;
895                 }
896         }
897         return 1;
898 }
899
900 __setup("reserve=", reserve_setup);
901
902 /*
903  * Check if the requested addr and size spans more than any slot in the
904  * iomem resource tree.
905  */
906 int iomem_map_sanity_check(resource_size_t addr, unsigned long size)
907 {
908         struct resource *p = &iomem_resource;
909         int err = 0;
910         loff_t l;
911
912         read_lock(&resource_lock);
913         for (p = p->child; p ; p = r_next(NULL, p, &l)) {
914                 /*
915                  * We can probably skip the resources without
916                  * IORESOURCE_IO attribute?
917                  */
918                 if (p->start >= addr + size)
919                         continue;
920                 if (p->end < addr)
921                         continue;
922                 if (PFN_DOWN(p->start) <= PFN_DOWN(addr) &&
923                     PFN_DOWN(p->end) >= PFN_DOWN(addr + size - 1))
924                         continue;
925                 /*
926                  * if a resource is "BUSY", it's not a hardware resource
927                  * but a driver mapping of such a resource; we don't want
928                  * to warn for those; some drivers legitimately map only
929                  * partial hardware resources. (example: vesafb)
930                  */
931                 if (p->flags & IORESOURCE_BUSY)
932                         continue;
933
934                 printk(KERN_WARNING "resource map sanity check conflict: "
935                        "0x%llx 0x%llx 0x%llx 0x%llx %s\n",
936                        (unsigned long long)addr,
937                        (unsigned long long)(addr + size - 1),
938                        (unsigned long long)p->start,
939                        (unsigned long long)p->end,
940                        p->name);
941                 err = -1;
942                 break;
943         }
944         read_unlock(&resource_lock);
945
946         return err;
947 }
948
949 #ifdef CONFIG_STRICT_DEVMEM
950 static int strict_iomem_checks = 1;
951 #else
952 static int strict_iomem_checks;
953 #endif
954
955 /*
956  * check if an address is reserved in the iomem resource tree
957  * returns 1 if reserved, 0 if not reserved.
958  */
959 int iomem_is_exclusive(u64 addr)
960 {
961         struct resource *p = &iomem_resource;
962         int err = 0;
963         loff_t l;
964         int size = PAGE_SIZE;
965
966         if (!strict_iomem_checks)
967                 return 0;
968
969         addr = addr & PAGE_MASK;
970
971         read_lock(&resource_lock);
972         for (p = p->child; p ; p = r_next(NULL, p, &l)) {
973                 /*
974                  * We can probably skip the resources without
975                  * IORESOURCE_IO attribute?
976                  */
977                 if (p->start >= addr + size)
978                         break;
979                 if (p->end < addr)
980                         continue;
981                 if (p->flags & IORESOURCE_BUSY &&
982                      p->flags & IORESOURCE_EXCLUSIVE) {
983                         err = 1;
984                         break;
985                 }
986         }
987         read_unlock(&resource_lock);
988
989         return err;
990 }
991
992 static int __init strict_iomem(char *str)
993 {
994         if (strstr(str, "relaxed"))
995                 strict_iomem_checks = 0;
996         if (strstr(str, "strict"))
997                 strict_iomem_checks = 1;
998         return 1;
999 }
1000
1001 __setup("iomem=", strict_iomem);