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