Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux
[pandora-kernel.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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12 #include <linux/export.h>
13 #include <linux/errno.h>
14 #include <linux/ioport.h>
15 #include <linux/init.h>
16 #include <linux/slab.h>
17 #include <linux/spinlock.h>
18 #include <linux/fs.h>
19 #include <linux/proc_fs.h>
20 #include <linux/sched.h>
21 #include <linux/seq_file.h>
22 #include <linux/device.h>
23 #include <linux/pfn.h>
24 #include <linux/mm.h>
25 #include <asm/io.h>
26
27
28 struct resource ioport_resource = {
29         .name   = "PCI IO",
30         .start  = 0,
31         .end    = IO_SPACE_LIMIT,
32         .flags  = IORESOURCE_IO,
33 };
34 EXPORT_SYMBOL(ioport_resource);
35
36 struct resource iomem_resource = {
37         .name   = "PCI mem",
38         .start  = 0,
39         .end    = -1,
40         .flags  = IORESOURCE_MEM,
41 };
42 EXPORT_SYMBOL(iomem_resource);
43
44 /* constraints to be met while allocating resources */
45 struct resource_constraint {
46         resource_size_t min, max, align;
47         resource_size_t (*alignf)(void *, const struct resource *,
48                         resource_size_t, resource_size_t);
49         void *alignf_data;
50 };
51
52 static DEFINE_RWLOCK(resource_lock);
53
54 /*
55  * For memory hotplug, there is no way to free resource entries allocated
56  * by boot mem after the system is up. So for reusing the resource entry
57  * we need to remember the resource.
58  */
59 static struct resource *bootmem_resource_free;
60 static DEFINE_SPINLOCK(bootmem_resource_lock);
61
62 static struct resource *next_resource(struct resource *p, bool sibling_only)
63 {
64         /* Caller wants to traverse through siblings only */
65         if (sibling_only)
66                 return p->sibling;
67
68         if (p->child)
69                 return p->child;
70         while (!p->sibling && p->parent)
71                 p = p->parent;
72         return p->sibling;
73 }
74
75 static void *r_next(struct seq_file *m, void *v, loff_t *pos)
76 {
77         struct resource *p = v;
78         (*pos)++;
79         return (void *)next_resource(p, false);
80 }
81
82 #ifdef CONFIG_PROC_FS
83
84 enum { MAX_IORES_LEVEL = 5 };
85
86 static void *r_start(struct seq_file *m, loff_t *pos)
87         __acquires(resource_lock)
88 {
89         struct resource *p = m->private;
90         loff_t l = 0;
91         read_lock(&resource_lock);
92         for (p = p->child; p && l < *pos; p = r_next(m, p, &l))
93                 ;
94         return p;
95 }
96
97 static void r_stop(struct seq_file *m, void *v)
98         __releases(resource_lock)
99 {
100         read_unlock(&resource_lock);
101 }
102
103 static int r_show(struct seq_file *m, void *v)
104 {
105         struct resource *root = m->private;
106         struct resource *r = v, *p;
107         int width = root->end < 0x10000 ? 4 : 8;
108         int depth;
109
110         for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)
111                 if (p->parent == root)
112                         break;
113         seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
114                         depth * 2, "",
115                         width, (unsigned long long) r->start,
116                         width, (unsigned long long) r->end,
117                         r->name ? r->name : "<BAD>");
118         return 0;
119 }
120
121 static const struct seq_operations resource_op = {
122         .start  = r_start,
123         .next   = r_next,
124         .stop   = r_stop,
125         .show   = r_show,
126 };
127
128 static int ioports_open(struct inode *inode, struct file *file)
129 {
130         int res = seq_open(file, &resource_op);
131         if (!res) {
132                 struct seq_file *m = file->private_data;
133                 m->private = &ioport_resource;
134         }
135         return res;
136 }
137
138 static int iomem_open(struct inode *inode, struct file *file)
139 {
140         int res = seq_open(file, &resource_op);
141         if (!res) {
142                 struct seq_file *m = file->private_data;
143                 m->private = &iomem_resource;
144         }
145         return res;
146 }
147
148 static const struct file_operations proc_ioports_operations = {
149         .open           = ioports_open,
150         .read           = seq_read,
151         .llseek         = seq_lseek,
152         .release        = seq_release,
153 };
154
155 static const struct file_operations proc_iomem_operations = {
156         .open           = iomem_open,
157         .read           = seq_read,
158         .llseek         = seq_lseek,
159         .release        = seq_release,
160 };
161
162 static int __init ioresources_init(void)
163 {
164         proc_create("ioports", 0, NULL, &proc_ioports_operations);
165         proc_create("iomem", 0, NULL, &proc_iomem_operations);
166         return 0;
167 }
168 __initcall(ioresources_init);
169
170 #endif /* CONFIG_PROC_FS */
171
172 static void free_resource(struct resource *res)
173 {
174         if (!res)
175                 return;
176
177         if (!PageSlab(virt_to_head_page(res))) {
178                 spin_lock(&bootmem_resource_lock);
179                 res->sibling = bootmem_resource_free;
180                 bootmem_resource_free = res;
181                 spin_unlock(&bootmem_resource_lock);
182         } else {
183                 kfree(res);
184         }
185 }
186
187 static struct resource *alloc_resource(gfp_t flags)
188 {
189         struct resource *res = NULL;
190
191         spin_lock(&bootmem_resource_lock);
192         if (bootmem_resource_free) {
193                 res = bootmem_resource_free;
194                 bootmem_resource_free = res->sibling;
195         }
196         spin_unlock(&bootmem_resource_lock);
197
198         if (res)
199                 memset(res, 0, sizeof(struct resource));
200         else
201                 res = kzalloc(sizeof(struct resource), flags);
202
203         return res;
204 }
205
206 /* Return the conflict entry if you can't request it */
207 static struct resource * __request_resource(struct resource *root, struct resource *new)
208 {
209         resource_size_t start = new->start;
210         resource_size_t end = new->end;
211         struct resource *tmp, **p;
212
213         if (end < start)
214                 return root;
215         if (start < root->start)
216                 return root;
217         if (end > root->end)
218                 return root;
219         p = &root->child;
220         for (;;) {
221                 tmp = *p;
222                 if (!tmp || tmp->start > end) {
223                         new->sibling = tmp;
224                         *p = new;
225                         new->parent = root;
226                         return NULL;
227                 }
228                 p = &tmp->sibling;
229                 if (tmp->end < start)
230                         continue;
231                 return tmp;
232         }
233 }
234
235 static int __release_resource(struct resource *old)
236 {
237         struct resource *tmp, **p;
238
239         p = &old->parent->child;
240         for (;;) {
241                 tmp = *p;
242                 if (!tmp)
243                         break;
244                 if (tmp == old) {
245                         *p = tmp->sibling;
246                         old->parent = NULL;
247                         return 0;
248                 }
249                 p = &tmp->sibling;
250         }
251         return -EINVAL;
252 }
253
254 static void __release_child_resources(struct resource *r)
255 {
256         struct resource *tmp, *p;
257         resource_size_t size;
258
259         p = r->child;
260         r->child = NULL;
261         while (p) {
262                 tmp = p;
263                 p = p->sibling;
264
265                 tmp->parent = NULL;
266                 tmp->sibling = NULL;
267                 __release_child_resources(tmp);
268
269                 printk(KERN_DEBUG "release child resource %pR\n", tmp);
270                 /* need to restore size, and keep flags */
271                 size = resource_size(tmp);
272                 tmp->start = 0;
273                 tmp->end = size - 1;
274         }
275 }
276
277 void release_child_resources(struct resource *r)
278 {
279         write_lock(&resource_lock);
280         __release_child_resources(r);
281         write_unlock(&resource_lock);
282 }
283
284 /**
285  * request_resource_conflict - request and reserve an I/O or memory resource
286  * @root: root resource descriptor
287  * @new: resource descriptor desired by caller
288  *
289  * Returns 0 for success, conflict resource on error.
290  */
291 struct resource *request_resource_conflict(struct resource *root, struct resource *new)
292 {
293         struct resource *conflict;
294
295         write_lock(&resource_lock);
296         conflict = __request_resource(root, new);
297         write_unlock(&resource_lock);
298         return conflict;
299 }
300
301 /**
302  * request_resource - request and reserve an I/O or memory resource
303  * @root: root resource descriptor
304  * @new: resource descriptor desired by caller
305  *
306  * Returns 0 for success, negative error code on error.
307  */
308 int request_resource(struct resource *root, struct resource *new)
309 {
310         struct resource *conflict;
311
312         conflict = request_resource_conflict(root, new);
313         return conflict ? -EBUSY : 0;
314 }
315
316 EXPORT_SYMBOL(request_resource);
317
318 /**
319  * release_resource - release a previously reserved resource
320  * @old: resource pointer
321  */
322 int release_resource(struct resource *old)
323 {
324         int retval;
325
326         write_lock(&resource_lock);
327         retval = __release_resource(old);
328         write_unlock(&resource_lock);
329         return retval;
330 }
331
332 EXPORT_SYMBOL(release_resource);
333
334 /*
335  * Finds the lowest iomem reosurce exists with-in [res->start.res->end)
336  * the caller must specify res->start, res->end, res->flags and "name".
337  * If found, returns 0, res is overwritten, if not found, returns -1.
338  * This walks through whole tree and not just first level children
339  * until and unless first_level_children_only is true.
340  */
341 static int find_next_iomem_res(struct resource *res, char *name,
342                                bool first_level_children_only)
343 {
344         resource_size_t start, end;
345         struct resource *p;
346         bool sibling_only = false;
347
348         BUG_ON(!res);
349
350         start = res->start;
351         end = res->end;
352         BUG_ON(start >= end);
353
354         read_lock(&resource_lock);
355
356         if (first_level_children_only) {
357                 p = iomem_resource.child;
358                 sibling_only = true;
359         } else
360                 p = &iomem_resource;
361
362         while ((p = next_resource(p, sibling_only))) {
363                 if (p->flags != res->flags)
364                         continue;
365                 if (name && strcmp(p->name, name))
366                         continue;
367                 if (p->start > end) {
368                         p = NULL;
369                         break;
370                 }
371                 if ((p->end >= start) && (p->start < end))
372                         break;
373         }
374
375         read_unlock(&resource_lock);
376         if (!p)
377                 return -1;
378         /* copy data */
379         if (res->start < p->start)
380                 res->start = p->start;
381         if (res->end > p->end)
382                 res->end = p->end;
383         return 0;
384 }
385
386 /*
387  * Walks through iomem resources and calls func() with matching resource
388  * ranges. This walks through whole tree and not just first level children.
389  * All the memory ranges which overlap start,end and also match flags and
390  * name are valid candidates.
391  *
392  * @name: name of resource
393  * @flags: resource flags
394  * @start: start addr
395  * @end: end addr
396  */
397 int walk_iomem_res(char *name, unsigned long flags, u64 start, u64 end,
398                 void *arg, int (*func)(u64, u64, void *))
399 {
400         struct resource res;
401         u64 orig_end;
402         int ret = -1;
403
404         res.start = start;
405         res.end = end;
406         res.flags = flags;
407         orig_end = res.end;
408         while ((res.start < res.end) &&
409                 (!find_next_iomem_res(&res, name, false))) {
410                 ret = (*func)(res.start, res.end, arg);
411                 if (ret)
412                         break;
413                 res.start = res.end + 1;
414                 res.end = orig_end;
415         }
416         return ret;
417 }
418
419 /*
420  * This function calls callback against all memory range of "System RAM"
421  * which are marked as IORESOURCE_MEM and IORESOUCE_BUSY.
422  * Now, this function is only for "System RAM". This function deals with
423  * full ranges and not pfn. If resources are not pfn aligned, dealing
424  * with pfn can truncate ranges.
425  */
426 int walk_system_ram_res(u64 start, u64 end, void *arg,
427                                 int (*func)(u64, u64, void *))
428 {
429         struct resource res;
430         u64 orig_end;
431         int ret = -1;
432
433         res.start = start;
434         res.end = end;
435         res.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
436         orig_end = res.end;
437         while ((res.start < res.end) &&
438                 (!find_next_iomem_res(&res, "System RAM", true))) {
439                 ret = (*func)(res.start, res.end, arg);
440                 if (ret)
441                         break;
442                 res.start = res.end + 1;
443                 res.end = orig_end;
444         }
445         return ret;
446 }
447
448 #if !defined(CONFIG_ARCH_HAS_WALK_MEMORY)
449
450 /*
451  * This function calls callback against all memory range of "System RAM"
452  * which are marked as IORESOURCE_MEM and IORESOUCE_BUSY.
453  * Now, this function is only for "System RAM".
454  */
455 int walk_system_ram_range(unsigned long start_pfn, unsigned long nr_pages,
456                 void *arg, int (*func)(unsigned long, unsigned long, void *))
457 {
458         struct resource res;
459         unsigned long pfn, end_pfn;
460         u64 orig_end;
461         int ret = -1;
462
463         res.start = (u64) start_pfn << PAGE_SHIFT;
464         res.end = ((u64)(start_pfn + nr_pages) << PAGE_SHIFT) - 1;
465         res.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
466         orig_end = res.end;
467         while ((res.start < res.end) &&
468                 (find_next_iomem_res(&res, "System RAM", true) >= 0)) {
469                 pfn = (res.start + PAGE_SIZE - 1) >> PAGE_SHIFT;
470                 end_pfn = (res.end + 1) >> PAGE_SHIFT;
471                 if (end_pfn > pfn)
472                         ret = (*func)(pfn, end_pfn - pfn, arg);
473                 if (ret)
474                         break;
475                 res.start = res.end + 1;
476                 res.end = orig_end;
477         }
478         return ret;
479 }
480
481 #endif
482
483 static int __is_ram(unsigned long pfn, unsigned long nr_pages, void *arg)
484 {
485         return 1;
486 }
487 /*
488  * This generic page_is_ram() returns true if specified address is
489  * registered as "System RAM" in iomem_resource list.
490  */
491 int __weak page_is_ram(unsigned long pfn)
492 {
493         return walk_system_ram_range(pfn, 1, NULL, __is_ram) == 1;
494 }
495 EXPORT_SYMBOL_GPL(page_is_ram);
496
497 void __weak arch_remove_reservations(struct resource *avail)
498 {
499 }
500
501 static resource_size_t simple_align_resource(void *data,
502                                              const struct resource *avail,
503                                              resource_size_t size,
504                                              resource_size_t align)
505 {
506         return avail->start;
507 }
508
509 static void resource_clip(struct resource *res, resource_size_t min,
510                           resource_size_t max)
511 {
512         if (res->start < min)
513                 res->start = min;
514         if (res->end > max)
515                 res->end = max;
516 }
517
518 /*
519  * Find empty slot in the resource tree with the given range and
520  * alignment constraints
521  */
522 static int __find_resource(struct resource *root, struct resource *old,
523                          struct resource *new,
524                          resource_size_t  size,
525                          struct resource_constraint *constraint)
526 {
527         struct resource *this = root->child;
528         struct resource tmp = *new, avail, alloc;
529
530         tmp.start = root->start;
531         /*
532          * Skip past an allocated resource that starts at 0, since the assignment
533          * of this->start - 1 to tmp->end below would cause an underflow.
534          */
535         if (this && this->start == root->start) {
536                 tmp.start = (this == old) ? old->start : this->end + 1;
537                 this = this->sibling;
538         }
539         for(;;) {
540                 if (this)
541                         tmp.end = (this == old) ?  this->end : this->start - 1;
542                 else
543                         tmp.end = root->end;
544
545                 if (tmp.end < tmp.start)
546                         goto next;
547
548                 resource_clip(&tmp, constraint->min, constraint->max);
549                 arch_remove_reservations(&tmp);
550
551                 /* Check for overflow after ALIGN() */
552                 avail.start = ALIGN(tmp.start, constraint->align);
553                 avail.end = tmp.end;
554                 avail.flags = new->flags & ~IORESOURCE_UNSET;
555                 if (avail.start >= tmp.start) {
556                         alloc.flags = avail.flags;
557                         alloc.start = constraint->alignf(constraint->alignf_data, &avail,
558                                         size, constraint->align);
559                         alloc.end = alloc.start + size - 1;
560                         if (resource_contains(&avail, &alloc)) {
561                                 new->start = alloc.start;
562                                 new->end = alloc.end;
563                                 return 0;
564                         }
565                 }
566
567 next:           if (!this || this->end == root->end)
568                         break;
569
570                 if (this != old)
571                         tmp.start = this->end + 1;
572                 this = this->sibling;
573         }
574         return -EBUSY;
575 }
576
577 /*
578  * Find empty slot in the resource tree given range and alignment.
579  */
580 static int find_resource(struct resource *root, struct resource *new,
581                         resource_size_t size,
582                         struct resource_constraint  *constraint)
583 {
584         return  __find_resource(root, NULL, new, size, constraint);
585 }
586
587 /**
588  * reallocate_resource - allocate a slot in the resource tree given range & alignment.
589  *      The resource will be relocated if the new size cannot be reallocated in the
590  *      current location.
591  *
592  * @root: root resource descriptor
593  * @old:  resource descriptor desired by caller
594  * @newsize: new size of the resource descriptor
595  * @constraint: the size and alignment constraints to be met.
596  */
597 static int reallocate_resource(struct resource *root, struct resource *old,
598                         resource_size_t newsize,
599                         struct resource_constraint  *constraint)
600 {
601         int err=0;
602         struct resource new = *old;
603         struct resource *conflict;
604
605         write_lock(&resource_lock);
606
607         if ((err = __find_resource(root, old, &new, newsize, constraint)))
608                 goto out;
609
610         if (resource_contains(&new, old)) {
611                 old->start = new.start;
612                 old->end = new.end;
613                 goto out;
614         }
615
616         if (old->child) {
617                 err = -EBUSY;
618                 goto out;
619         }
620
621         if (resource_contains(old, &new)) {
622                 old->start = new.start;
623                 old->end = new.end;
624         } else {
625                 __release_resource(old);
626                 *old = new;
627                 conflict = __request_resource(root, old);
628                 BUG_ON(conflict);
629         }
630 out:
631         write_unlock(&resource_lock);
632         return err;
633 }
634
635
636 /**
637  * allocate_resource - allocate empty slot in the resource tree given range & alignment.
638  *      The resource will be reallocated with a new size if it was already allocated
639  * @root: root resource descriptor
640  * @new: resource descriptor desired by caller
641  * @size: requested resource region size
642  * @min: minimum boundary to allocate
643  * @max: maximum boundary to allocate
644  * @align: alignment requested, in bytes
645  * @alignf: alignment function, optional, called if not NULL
646  * @alignf_data: arbitrary data to pass to the @alignf function
647  */
648 int allocate_resource(struct resource *root, struct resource *new,
649                       resource_size_t size, resource_size_t min,
650                       resource_size_t max, resource_size_t align,
651                       resource_size_t (*alignf)(void *,
652                                                 const struct resource *,
653                                                 resource_size_t,
654                                                 resource_size_t),
655                       void *alignf_data)
656 {
657         int err;
658         struct resource_constraint constraint;
659
660         if (!alignf)
661                 alignf = simple_align_resource;
662
663         constraint.min = min;
664         constraint.max = max;
665         constraint.align = align;
666         constraint.alignf = alignf;
667         constraint.alignf_data = alignf_data;
668
669         if ( new->parent ) {
670                 /* resource is already allocated, try reallocating with
671                    the new constraints */
672                 return reallocate_resource(root, new, size, &constraint);
673         }
674
675         write_lock(&resource_lock);
676         err = find_resource(root, new, size, &constraint);
677         if (err >= 0 && __request_resource(root, new))
678                 err = -EBUSY;
679         write_unlock(&resource_lock);
680         return err;
681 }
682
683 EXPORT_SYMBOL(allocate_resource);
684
685 /**
686  * lookup_resource - find an existing resource by a resource start address
687  * @root: root resource descriptor
688  * @start: resource start address
689  *
690  * Returns a pointer to the resource if found, NULL otherwise
691  */
692 struct resource *lookup_resource(struct resource *root, resource_size_t start)
693 {
694         struct resource *res;
695
696         read_lock(&resource_lock);
697         for (res = root->child; res; res = res->sibling) {
698                 if (res->start == start)
699                         break;
700         }
701         read_unlock(&resource_lock);
702
703         return res;
704 }
705
706 /*
707  * Insert a resource into the resource tree. If successful, return NULL,
708  * otherwise return the conflicting resource (compare to __request_resource())
709  */
710 static struct resource * __insert_resource(struct resource *parent, struct resource *new)
711 {
712         struct resource *first, *next;
713
714         for (;; parent = first) {
715                 first = __request_resource(parent, new);
716                 if (!first)
717                         return first;
718
719                 if (first == parent)
720                         return first;
721                 if (WARN_ON(first == new))      /* duplicated insertion */
722                         return first;
723
724                 if ((first->start > new->start) || (first->end < new->end))
725                         break;
726                 if ((first->start == new->start) && (first->end == new->end))
727                         break;
728         }
729
730         for (next = first; ; next = next->sibling) {
731                 /* Partial overlap? Bad, and unfixable */
732                 if (next->start < new->start || next->end > new->end)
733                         return next;
734                 if (!next->sibling)
735                         break;
736                 if (next->sibling->start > new->end)
737                         break;
738         }
739
740         new->parent = parent;
741         new->sibling = next->sibling;
742         new->child = first;
743
744         next->sibling = NULL;
745         for (next = first; next; next = next->sibling)
746                 next->parent = new;
747
748         if (parent->child == first) {
749                 parent->child = new;
750         } else {
751                 next = parent->child;
752                 while (next->sibling != first)
753                         next = next->sibling;
754                 next->sibling = new;
755         }
756         return NULL;
757 }
758
759 /**
760  * insert_resource_conflict - Inserts resource in the resource tree
761  * @parent: parent of the new resource
762  * @new: new resource to insert
763  *
764  * Returns 0 on success, conflict resource if the resource can't be inserted.
765  *
766  * This function is equivalent to request_resource_conflict when no conflict
767  * happens. If a conflict happens, and the conflicting resources
768  * entirely fit within the range of the new resource, then the new
769  * resource is inserted and the conflicting resources become children of
770  * the new resource.
771  */
772 struct resource *insert_resource_conflict(struct resource *parent, struct resource *new)
773 {
774         struct resource *conflict;
775
776         write_lock(&resource_lock);
777         conflict = __insert_resource(parent, new);
778         write_unlock(&resource_lock);
779         return conflict;
780 }
781
782 /**
783  * insert_resource - Inserts a resource in the resource tree
784  * @parent: parent of the new resource
785  * @new: new resource to insert
786  *
787  * Returns 0 on success, -EBUSY if the resource can't be inserted.
788  */
789 int insert_resource(struct resource *parent, struct resource *new)
790 {
791         struct resource *conflict;
792
793         conflict = insert_resource_conflict(parent, new);
794         return conflict ? -EBUSY : 0;
795 }
796
797 /**
798  * insert_resource_expand_to_fit - Insert a resource into the resource tree
799  * @root: root resource descriptor
800  * @new: new resource to insert
801  *
802  * Insert a resource into the resource tree, possibly expanding it in order
803  * to make it encompass any conflicting resources.
804  */
805 void insert_resource_expand_to_fit(struct resource *root, struct resource *new)
806 {
807         if (new->parent)
808                 return;
809
810         write_lock(&resource_lock);
811         for (;;) {
812                 struct resource *conflict;
813
814                 conflict = __insert_resource(root, new);
815                 if (!conflict)
816                         break;
817                 if (conflict == root)
818                         break;
819
820                 /* Ok, expand resource to cover the conflict, then try again .. */
821                 if (conflict->start < new->start)
822                         new->start = conflict->start;
823                 if (conflict->end > new->end)
824                         new->end = conflict->end;
825
826                 printk("Expanded resource %s due to conflict with %s\n", new->name, conflict->name);
827         }
828         write_unlock(&resource_lock);
829 }
830
831 static int __adjust_resource(struct resource *res, resource_size_t start,
832                                 resource_size_t size)
833 {
834         struct resource *tmp, *parent = res->parent;
835         resource_size_t end = start + size - 1;
836         int result = -EBUSY;
837
838         if (!parent)
839                 goto skip;
840
841         if ((start < parent->start) || (end > parent->end))
842                 goto out;
843
844         if (res->sibling && (res->sibling->start <= end))
845                 goto out;
846
847         tmp = parent->child;
848         if (tmp != res) {
849                 while (tmp->sibling != res)
850                         tmp = tmp->sibling;
851                 if (start <= tmp->end)
852                         goto out;
853         }
854
855 skip:
856         for (tmp = res->child; tmp; tmp = tmp->sibling)
857                 if ((tmp->start < start) || (tmp->end > end))
858                         goto out;
859
860         res->start = start;
861         res->end = end;
862         result = 0;
863
864  out:
865         return result;
866 }
867
868 /**
869  * adjust_resource - modify a resource's start and size
870  * @res: resource to modify
871  * @start: new start value
872  * @size: new size
873  *
874  * Given an existing resource, change its start and size to match the
875  * arguments.  Returns 0 on success, -EBUSY if it can't fit.
876  * Existing children of the resource are assumed to be immutable.
877  */
878 int adjust_resource(struct resource *res, resource_size_t start,
879                         resource_size_t size)
880 {
881         int result;
882
883         write_lock(&resource_lock);
884         result = __adjust_resource(res, start, size);
885         write_unlock(&resource_lock);
886         return result;
887 }
888 EXPORT_SYMBOL(adjust_resource);
889
890 static void __init __reserve_region_with_split(struct resource *root,
891                 resource_size_t start, resource_size_t end,
892                 const char *name)
893 {
894         struct resource *parent = root;
895         struct resource *conflict;
896         struct resource *res = alloc_resource(GFP_ATOMIC);
897         struct resource *next_res = NULL;
898
899         if (!res)
900                 return;
901
902         res->name = name;
903         res->start = start;
904         res->end = end;
905         res->flags = IORESOURCE_BUSY;
906
907         while (1) {
908
909                 conflict = __request_resource(parent, res);
910                 if (!conflict) {
911                         if (!next_res)
912                                 break;
913                         res = next_res;
914                         next_res = NULL;
915                         continue;
916                 }
917
918                 /* conflict covered whole area */
919                 if (conflict->start <= res->start &&
920                                 conflict->end >= res->end) {
921                         free_resource(res);
922                         WARN_ON(next_res);
923                         break;
924                 }
925
926                 /* failed, split and try again */
927                 if (conflict->start > res->start) {
928                         end = res->end;
929                         res->end = conflict->start - 1;
930                         if (conflict->end < end) {
931                                 next_res = alloc_resource(GFP_ATOMIC);
932                                 if (!next_res) {
933                                         free_resource(res);
934                                         break;
935                                 }
936                                 next_res->name = name;
937                                 next_res->start = conflict->end + 1;
938                                 next_res->end = end;
939                                 next_res->flags = IORESOURCE_BUSY;
940                         }
941                 } else {
942                         res->start = conflict->end + 1;
943                 }
944         }
945
946 }
947
948 void __init reserve_region_with_split(struct resource *root,
949                 resource_size_t start, resource_size_t end,
950                 const char *name)
951 {
952         int abort = 0;
953
954         write_lock(&resource_lock);
955         if (root->start > start || root->end < end) {
956                 pr_err("requested range [0x%llx-0x%llx] not in root %pr\n",
957                        (unsigned long long)start, (unsigned long long)end,
958                        root);
959                 if (start > root->end || end < root->start)
960                         abort = 1;
961                 else {
962                         if (end > root->end)
963                                 end = root->end;
964                         if (start < root->start)
965                                 start = root->start;
966                         pr_err("fixing request to [0x%llx-0x%llx]\n",
967                                (unsigned long long)start,
968                                (unsigned long long)end);
969                 }
970                 dump_stack();
971         }
972         if (!abort)
973                 __reserve_region_with_split(root, start, end, name);
974         write_unlock(&resource_lock);
975 }
976
977 /**
978  * resource_alignment - calculate resource's alignment
979  * @res: resource pointer
980  *
981  * Returns alignment on success, 0 (invalid alignment) on failure.
982  */
983 resource_size_t resource_alignment(struct resource *res)
984 {
985         switch (res->flags & (IORESOURCE_SIZEALIGN | IORESOURCE_STARTALIGN)) {
986         case IORESOURCE_SIZEALIGN:
987                 return resource_size(res);
988         case IORESOURCE_STARTALIGN:
989                 return res->start;
990         default:
991                 return 0;
992         }
993 }
994
995 /*
996  * This is compatibility stuff for IO resources.
997  *
998  * Note how this, unlike the above, knows about
999  * the IO flag meanings (busy etc).
1000  *
1001  * request_region creates a new busy region.
1002  *
1003  * check_region returns non-zero if the area is already busy.
1004  *
1005  * release_region releases a matching busy region.
1006  */
1007
1008 static DECLARE_WAIT_QUEUE_HEAD(muxed_resource_wait);
1009
1010 /**
1011  * __request_region - create a new busy resource region
1012  * @parent: parent resource descriptor
1013  * @start: resource start address
1014  * @n: resource region size
1015  * @name: reserving caller's ID string
1016  * @flags: IO resource flags
1017  */
1018 struct resource * __request_region(struct resource *parent,
1019                                    resource_size_t start, resource_size_t n,
1020                                    const char *name, int flags)
1021 {
1022         DECLARE_WAITQUEUE(wait, current);
1023         struct resource *res = alloc_resource(GFP_KERNEL);
1024
1025         if (!res)
1026                 return NULL;
1027
1028         res->name = name;
1029         res->start = start;
1030         res->end = start + n - 1;
1031         res->flags = resource_type(parent);
1032         res->flags |= IORESOURCE_BUSY | flags;
1033
1034         write_lock(&resource_lock);
1035
1036         for (;;) {
1037                 struct resource *conflict;
1038
1039                 conflict = __request_resource(parent, res);
1040                 if (!conflict)
1041                         break;
1042                 if (conflict != parent) {
1043                         parent = conflict;
1044                         if (!(conflict->flags & IORESOURCE_BUSY))
1045                                 continue;
1046                 }
1047                 if (conflict->flags & flags & IORESOURCE_MUXED) {
1048                         add_wait_queue(&muxed_resource_wait, &wait);
1049                         write_unlock(&resource_lock);
1050                         set_current_state(TASK_UNINTERRUPTIBLE);
1051                         schedule();
1052                         remove_wait_queue(&muxed_resource_wait, &wait);
1053                         write_lock(&resource_lock);
1054                         continue;
1055                 }
1056                 /* Uhhuh, that didn't work out.. */
1057                 free_resource(res);
1058                 res = NULL;
1059                 break;
1060         }
1061         write_unlock(&resource_lock);
1062         return res;
1063 }
1064 EXPORT_SYMBOL(__request_region);
1065
1066 /**
1067  * __check_region - check if a resource region is busy or free
1068  * @parent: parent resource descriptor
1069  * @start: resource start address
1070  * @n: resource region size
1071  *
1072  * Returns 0 if the region is free at the moment it is checked,
1073  * returns %-EBUSY if the region is busy.
1074  *
1075  * NOTE:
1076  * This function is deprecated because its use is racy.
1077  * Even if it returns 0, a subsequent call to request_region()
1078  * may fail because another driver etc. just allocated the region.
1079  * Do NOT use it.  It will be removed from the kernel.
1080  */
1081 int __check_region(struct resource *parent, resource_size_t start,
1082                         resource_size_t n)
1083 {
1084         struct resource * res;
1085
1086         res = __request_region(parent, start, n, "check-region", 0);
1087         if (!res)
1088                 return -EBUSY;
1089
1090         release_resource(res);
1091         free_resource(res);
1092         return 0;
1093 }
1094 EXPORT_SYMBOL(__check_region);
1095
1096 /**
1097  * __release_region - release a previously reserved resource region
1098  * @parent: parent resource descriptor
1099  * @start: resource start address
1100  * @n: resource region size
1101  *
1102  * The described resource region must match a currently busy region.
1103  */
1104 void __release_region(struct resource *parent, resource_size_t start,
1105                         resource_size_t n)
1106 {
1107         struct resource **p;
1108         resource_size_t end;
1109
1110         p = &parent->child;
1111         end = start + n - 1;
1112
1113         write_lock(&resource_lock);
1114
1115         for (;;) {
1116                 struct resource *res = *p;
1117
1118                 if (!res)
1119                         break;
1120                 if (res->start <= start && res->end >= end) {
1121                         if (!(res->flags & IORESOURCE_BUSY)) {
1122                                 p = &res->child;
1123                                 continue;
1124                         }
1125                         if (res->start != start || res->end != end)
1126                                 break;
1127                         *p = res->sibling;
1128                         write_unlock(&resource_lock);
1129                         if (res->flags & IORESOURCE_MUXED)
1130                                 wake_up(&muxed_resource_wait);
1131                         free_resource(res);
1132                         return;
1133                 }
1134                 p = &res->sibling;
1135         }
1136
1137         write_unlock(&resource_lock);
1138
1139         printk(KERN_WARNING "Trying to free nonexistent resource "
1140                 "<%016llx-%016llx>\n", (unsigned long long)start,
1141                 (unsigned long long)end);
1142 }
1143 EXPORT_SYMBOL(__release_region);
1144
1145 #ifdef CONFIG_MEMORY_HOTREMOVE
1146 /**
1147  * release_mem_region_adjustable - release a previously reserved memory region
1148  * @parent: parent resource descriptor
1149  * @start: resource start address
1150  * @size: resource region size
1151  *
1152  * This interface is intended for memory hot-delete.  The requested region
1153  * is released from a currently busy memory resource.  The requested region
1154  * must either match exactly or fit into a single busy resource entry.  In
1155  * the latter case, the remaining resource is adjusted accordingly.
1156  * Existing children of the busy memory resource must be immutable in the
1157  * request.
1158  *
1159  * Note:
1160  * - Additional release conditions, such as overlapping region, can be
1161  *   supported after they are confirmed as valid cases.
1162  * - When a busy memory resource gets split into two entries, the code
1163  *   assumes that all children remain in the lower address entry for
1164  *   simplicity.  Enhance this logic when necessary.
1165  */
1166 int release_mem_region_adjustable(struct resource *parent,
1167                         resource_size_t start, resource_size_t size)
1168 {
1169         struct resource **p;
1170         struct resource *res;
1171         struct resource *new_res;
1172         resource_size_t end;
1173         int ret = -EINVAL;
1174
1175         end = start + size - 1;
1176         if ((start < parent->start) || (end > parent->end))
1177                 return ret;
1178
1179         /* The alloc_resource() result gets checked later */
1180         new_res = alloc_resource(GFP_KERNEL);
1181
1182         p = &parent->child;
1183         write_lock(&resource_lock);
1184
1185         while ((res = *p)) {
1186                 if (res->start >= end)
1187                         break;
1188
1189                 /* look for the next resource if it does not fit into */
1190                 if (res->start > start || res->end < end) {
1191                         p = &res->sibling;
1192                         continue;
1193                 }
1194
1195                 if (!(res->flags & IORESOURCE_MEM))
1196                         break;
1197
1198                 if (!(res->flags & IORESOURCE_BUSY)) {
1199                         p = &res->child;
1200                         continue;
1201                 }
1202
1203                 /* found the target resource; let's adjust accordingly */
1204                 if (res->start == start && res->end == end) {
1205                         /* free the whole entry */
1206                         *p = res->sibling;
1207                         free_resource(res);
1208                         ret = 0;
1209                 } else if (res->start == start && res->end != end) {
1210                         /* adjust the start */
1211                         ret = __adjust_resource(res, end + 1,
1212                                                 res->end - end);
1213                 } else if (res->start != start && res->end == end) {
1214                         /* adjust the end */
1215                         ret = __adjust_resource(res, res->start,
1216                                                 start - res->start);
1217                 } else {
1218                         /* split into two entries */
1219                         if (!new_res) {
1220                                 ret = -ENOMEM;
1221                                 break;
1222                         }
1223                         new_res->name = res->name;
1224                         new_res->start = end + 1;
1225                         new_res->end = res->end;
1226                         new_res->flags = res->flags;
1227                         new_res->parent = res->parent;
1228                         new_res->sibling = res->sibling;
1229                         new_res->child = NULL;
1230
1231                         ret = __adjust_resource(res, res->start,
1232                                                 start - res->start);
1233                         if (ret)
1234                                 break;
1235                         res->sibling = new_res;
1236                         new_res = NULL;
1237                 }
1238
1239                 break;
1240         }
1241
1242         write_unlock(&resource_lock);
1243         free_resource(new_res);
1244         return ret;
1245 }
1246 #endif  /* CONFIG_MEMORY_HOTREMOVE */
1247
1248 /*
1249  * Managed region resource
1250  */
1251 struct region_devres {
1252         struct resource *parent;
1253         resource_size_t start;
1254         resource_size_t n;
1255 };
1256
1257 static void devm_region_release(struct device *dev, void *res)
1258 {
1259         struct region_devres *this = res;
1260
1261         __release_region(this->parent, this->start, this->n);
1262 }
1263
1264 static int devm_region_match(struct device *dev, void *res, void *match_data)
1265 {
1266         struct region_devres *this = res, *match = match_data;
1267
1268         return this->parent == match->parent &&
1269                 this->start == match->start && this->n == match->n;
1270 }
1271
1272 struct resource * __devm_request_region(struct device *dev,
1273                                 struct resource *parent, resource_size_t start,
1274                                 resource_size_t n, const char *name)
1275 {
1276         struct region_devres *dr = NULL;
1277         struct resource *res;
1278
1279         dr = devres_alloc(devm_region_release, sizeof(struct region_devres),
1280                           GFP_KERNEL);
1281         if (!dr)
1282                 return NULL;
1283
1284         dr->parent = parent;
1285         dr->start = start;
1286         dr->n = n;
1287
1288         res = __request_region(parent, start, n, name, 0);
1289         if (res)
1290                 devres_add(dev, dr);
1291         else
1292                 devres_free(dr);
1293
1294         return res;
1295 }
1296 EXPORT_SYMBOL(__devm_request_region);
1297
1298 void __devm_release_region(struct device *dev, struct resource *parent,
1299                            resource_size_t start, resource_size_t n)
1300 {
1301         struct region_devres match_data = { parent, start, n };
1302
1303         __release_region(parent, start, n);
1304         WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match,
1305                                &match_data));
1306 }
1307 EXPORT_SYMBOL(__devm_release_region);
1308
1309 /*
1310  * Called from init/main.c to reserve IO ports.
1311  */
1312 #define MAXRESERVE 4
1313 static int __init reserve_setup(char *str)
1314 {
1315         static int reserved;
1316         static struct resource reserve[MAXRESERVE];
1317
1318         for (;;) {
1319                 unsigned int io_start, io_num;
1320                 int x = reserved;
1321
1322                 if (get_option (&str, &io_start) != 2)
1323                         break;
1324                 if (get_option (&str, &io_num)   == 0)
1325                         break;
1326                 if (x < MAXRESERVE) {
1327                         struct resource *res = reserve + x;
1328                         res->name = "reserved";
1329                         res->start = io_start;
1330                         res->end = io_start + io_num - 1;
1331                         res->flags = IORESOURCE_BUSY;
1332                         res->child = NULL;
1333                         if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0)
1334                                 reserved = x+1;
1335                 }
1336         }
1337         return 1;
1338 }
1339
1340 __setup("reserve=", reserve_setup);
1341
1342 /*
1343  * Check if the requested addr and size spans more than any slot in the
1344  * iomem resource tree.
1345  */
1346 int iomem_map_sanity_check(resource_size_t addr, unsigned long size)
1347 {
1348         struct resource *p = &iomem_resource;
1349         int err = 0;
1350         loff_t l;
1351
1352         read_lock(&resource_lock);
1353         for (p = p->child; p ; p = r_next(NULL, p, &l)) {
1354                 /*
1355                  * We can probably skip the resources without
1356                  * IORESOURCE_IO attribute?
1357                  */
1358                 if (p->start >= addr + size)
1359                         continue;
1360                 if (p->end < addr)
1361                         continue;
1362                 if (PFN_DOWN(p->start) <= PFN_DOWN(addr) &&
1363                     PFN_DOWN(p->end) >= PFN_DOWN(addr + size - 1))
1364                         continue;
1365                 /*
1366                  * if a resource is "BUSY", it's not a hardware resource
1367                  * but a driver mapping of such a resource; we don't want
1368                  * to warn for those; some drivers legitimately map only
1369                  * partial hardware resources. (example: vesafb)
1370                  */
1371                 if (p->flags & IORESOURCE_BUSY)
1372                         continue;
1373
1374                 printk(KERN_WARNING "resource sanity check: requesting [mem %#010llx-%#010llx], which spans more than %s %pR\n",
1375                        (unsigned long long)addr,
1376                        (unsigned long long)(addr + size - 1),
1377                        p->name, p);
1378                 err = -1;
1379                 break;
1380         }
1381         read_unlock(&resource_lock);
1382
1383         return err;
1384 }
1385
1386 #ifdef CONFIG_STRICT_DEVMEM
1387 static int strict_iomem_checks = 1;
1388 #else
1389 static int strict_iomem_checks;
1390 #endif
1391
1392 /*
1393  * check if an address is reserved in the iomem resource tree
1394  * returns 1 if reserved, 0 if not reserved.
1395  */
1396 int iomem_is_exclusive(u64 addr)
1397 {
1398         struct resource *p = &iomem_resource;
1399         int err = 0;
1400         loff_t l;
1401         int size = PAGE_SIZE;
1402
1403         if (!strict_iomem_checks)
1404                 return 0;
1405
1406         addr = addr & PAGE_MASK;
1407
1408         read_lock(&resource_lock);
1409         for (p = p->child; p ; p = r_next(NULL, p, &l)) {
1410                 /*
1411                  * We can probably skip the resources without
1412                  * IORESOURCE_IO attribute?
1413                  */
1414                 if (p->start >= addr + size)
1415                         break;
1416                 if (p->end < addr)
1417                         continue;
1418                 if (p->flags & IORESOURCE_BUSY &&
1419                      p->flags & IORESOURCE_EXCLUSIVE) {
1420                         err = 1;
1421                         break;
1422                 }
1423         }
1424         read_unlock(&resource_lock);
1425
1426         return err;
1427 }
1428
1429 static int __init strict_iomem(char *str)
1430 {
1431         if (strstr(str, "relaxed"))
1432                 strict_iomem_checks = 0;
1433         if (strstr(str, "strict"))
1434                 strict_iomem_checks = 1;
1435         return 1;
1436 }
1437
1438 __setup("iomem=", strict_iomem);