blob: b85f59e8a4b84f8ff71d38be18c185bdab33484c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/kernel/resource.c
3 *
4 * Copyright (C) 1999 Linus Torvalds
5 * Copyright (C) 1999 Martin Mares <mj@ucw.cz>
6 *
7 * Arbitrary resource management.
8 */
9
Octavian Purdila65fed8f2012-07-30 14:42:58 -070010#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
Paul Gortmaker9984de12011-05-23 14:51:41 -040012#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#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>
Alan Cox8b6d0432010-03-29 19:38:00 +020020#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/seq_file.h>
Tejun Heo9ac78492007-01-20 16:00:26 +090022#include <linux/device.h>
Suresh Siddhad68612b2008-10-28 11:45:42 -070023#include <linux/pfn.h>
Yasuaki Ishimatsuebff7d82013-04-29 15:08:56 -070024#include <linux/mm.h>
Jiang Liu90e97822015-02-05 13:44:43 +080025#include <linux/resource_ext.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <asm/io.h>
27
28
29struct resource ioport_resource = {
30 .name = "PCI IO",
Greg Kroah-Hartman6550e072006-06-12 17:11:31 -070031 .start = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 .end = IO_SPACE_LIMIT,
33 .flags = IORESOURCE_IO,
34};
Linus Torvalds1da177e2005-04-16 15:20:36 -070035EXPORT_SYMBOL(ioport_resource);
36
37struct resource iomem_resource = {
38 .name = "PCI mem",
Greg Kroah-Hartman6550e072006-06-12 17:11:31 -070039 .start = 0,
40 .end = -1,
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 .flags = IORESOURCE_MEM,
42};
Linus Torvalds1da177e2005-04-16 15:20:36 -070043EXPORT_SYMBOL(iomem_resource);
44
Ram Pai23c570a2011-07-05 23:44:30 -070045/* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070053static DEFINE_RWLOCK(resource_lock);
54
Yasuaki Ishimatsuebff7d82013-04-29 15:08:56 -070055/*
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
Vivek Goyal8c86e702014-08-08 14:25:50 -070063static struct resource *next_resource(struct resource *p, bool sibling_only)
Linus Torvalds1da177e2005-04-16 15:20:36 -070064{
Vivek Goyal8c86e702014-08-08 14:25:50 -070065 /* Caller wants to traverse through siblings only */
66 if (sibling_only)
67 return p->sibling;
68
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 if (p->child)
70 return p->child;
71 while (!p->sibling && p->parent)
72 p = p->parent;
73 return p->sibling;
74}
75
Vivek Goyal8c86e702014-08-08 14:25:50 -070076static 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
Ingo Molnar13eb8372008-09-26 10:10:12 +020083#ifdef CONFIG_PROC_FS
84
85enum { MAX_IORES_LEVEL = 5 };
86
Linus Torvalds1da177e2005-04-16 15:20:36 -070087static 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;
Linus Torvalds51d7b122016-04-14 12:05:37 -0700108 unsigned long long start, end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 int width = root->end < 0x10000 ? 4 : 8;
110 int depth;
111
112 for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)
113 if (p->parent == root)
114 break;
Linus Torvalds51d7b122016-04-14 12:05:37 -0700115
116 if (file_ns_capable(m->file, &init_user_ns, CAP_SYS_ADMIN)) {
117 start = r->start;
118 end = r->end;
119 } else {
120 start = end = 0;
121 }
122
Greg Kroah-Hartman685143ac2006-06-12 15:18:31 -0700123 seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 depth * 2, "",
Linus Torvalds51d7b122016-04-14 12:05:37 -0700125 width, start,
126 width, end,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 r->name ? r->name : "<BAD>");
128 return 0;
129}
130
Helge Deller15ad7cd2006-12-06 20:40:36 -0800131static const struct seq_operations resource_op = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 .start = r_start,
133 .next = r_next,
134 .stop = r_stop,
135 .show = r_show,
136};
137
138static int ioports_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 = &ioport_resource;
144 }
145 return res;
146}
147
148static int iomem_open(struct inode *inode, struct file *file)
149{
150 int res = seq_open(file, &resource_op);
151 if (!res) {
152 struct seq_file *m = file->private_data;
153 m->private = &iomem_resource;
154 }
155 return res;
156}
157
Helge Deller15ad7cd2006-12-06 20:40:36 -0800158static const struct file_operations proc_ioports_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 .open = ioports_open,
160 .read = seq_read,
161 .llseek = seq_lseek,
162 .release = seq_release,
163};
164
Helge Deller15ad7cd2006-12-06 20:40:36 -0800165static const struct file_operations proc_iomem_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 .open = iomem_open,
167 .read = seq_read,
168 .llseek = seq_lseek,
169 .release = seq_release,
170};
171
172static int __init ioresources_init(void)
173{
Denis V. Lunevc33fff02008-04-29 01:02:31 -0700174 proc_create("ioports", 0, NULL, &proc_ioports_operations);
175 proc_create("iomem", 0, NULL, &proc_iomem_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 return 0;
177}
178__initcall(ioresources_init);
179
180#endif /* CONFIG_PROC_FS */
181
Yasuaki Ishimatsuebff7d82013-04-29 15:08:56 -0700182static void free_resource(struct resource *res)
183{
184 if (!res)
185 return;
186
187 if (!PageSlab(virt_to_head_page(res))) {
188 spin_lock(&bootmem_resource_lock);
189 res->sibling = bootmem_resource_free;
190 bootmem_resource_free = res;
191 spin_unlock(&bootmem_resource_lock);
192 } else {
193 kfree(res);
194 }
195}
196
197static struct resource *alloc_resource(gfp_t flags)
198{
199 struct resource *res = NULL;
200
201 spin_lock(&bootmem_resource_lock);
202 if (bootmem_resource_free) {
203 res = bootmem_resource_free;
204 bootmem_resource_free = res->sibling;
205 }
206 spin_unlock(&bootmem_resource_lock);
207
208 if (res)
209 memset(res, 0, sizeof(struct resource));
210 else
211 res = kzalloc(sizeof(struct resource), flags);
212
213 return res;
214}
215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216/* Return the conflict entry if you can't request it */
217static struct resource * __request_resource(struct resource *root, struct resource *new)
218{
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700219 resource_size_t start = new->start;
220 resource_size_t end = new->end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 struct resource *tmp, **p;
222
223 if (end < start)
224 return root;
225 if (start < root->start)
226 return root;
227 if (end > root->end)
228 return root;
229 p = &root->child;
230 for (;;) {
231 tmp = *p;
232 if (!tmp || tmp->start > end) {
233 new->sibling = tmp;
234 *p = new;
235 new->parent = root;
236 return NULL;
237 }
238 p = &tmp->sibling;
239 if (tmp->end < start)
240 continue;
241 return tmp;
242 }
243}
244
Toshi Kaniff3cc952016-03-09 12:47:04 -0700245static int __release_resource(struct resource *old, bool release_child)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246{
Toshi Kaniff3cc952016-03-09 12:47:04 -0700247 struct resource *tmp, **p, *chd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
249 p = &old->parent->child;
250 for (;;) {
251 tmp = *p;
252 if (!tmp)
253 break;
254 if (tmp == old) {
Toshi Kaniff3cc952016-03-09 12:47:04 -0700255 if (release_child || !(tmp->child)) {
256 *p = tmp->sibling;
257 } else {
258 for (chd = tmp->child;; chd = chd->sibling) {
259 chd->parent = tmp->parent;
260 if (!(chd->sibling))
261 break;
262 }
263 *p = tmp->child;
264 chd->sibling = tmp->sibling;
265 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 old->parent = NULL;
267 return 0;
268 }
269 p = &tmp->sibling;
270 }
271 return -EINVAL;
272}
273
Yinghai Lu5eeec0e2009-12-22 15:02:22 -0800274static void __release_child_resources(struct resource *r)
275{
276 struct resource *tmp, *p;
277 resource_size_t size;
278
279 p = r->child;
280 r->child = NULL;
281 while (p) {
282 tmp = p;
283 p = p->sibling;
284
285 tmp->parent = NULL;
286 tmp->sibling = NULL;
287 __release_child_resources(tmp);
288
289 printk(KERN_DEBUG "release child resource %pR\n", tmp);
290 /* need to restore size, and keep flags */
291 size = resource_size(tmp);
292 tmp->start = 0;
293 tmp->end = size - 1;
294 }
295}
296
297void release_child_resources(struct resource *r)
298{
299 write_lock(&resource_lock);
300 __release_child_resources(r);
301 write_unlock(&resource_lock);
302}
303
Randy Dunlape1ca66d1b2006-10-03 01:13:51 -0700304/**
Bjorn Helgaas66f12072010-03-11 17:01:09 -0700305 * request_resource_conflict - request and reserve an I/O or memory resource
306 * @root: root resource descriptor
307 * @new: resource descriptor desired by caller
308 *
309 * Returns 0 for success, conflict resource on error.
310 */
311struct resource *request_resource_conflict(struct resource *root, struct resource *new)
312{
313 struct resource *conflict;
314
315 write_lock(&resource_lock);
316 conflict = __request_resource(root, new);
317 write_unlock(&resource_lock);
318 return conflict;
319}
320
321/**
Randy Dunlape1ca66d1b2006-10-03 01:13:51 -0700322 * request_resource - request and reserve an I/O or memory resource
323 * @root: root resource descriptor
324 * @new: resource descriptor desired by caller
325 *
326 * Returns 0 for success, negative error code on error.
327 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328int request_resource(struct resource *root, struct resource *new)
329{
330 struct resource *conflict;
331
Bjorn Helgaas66f12072010-03-11 17:01:09 -0700332 conflict = request_resource_conflict(root, new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 return conflict ? -EBUSY : 0;
334}
335
336EXPORT_SYMBOL(request_resource);
337
Randy Dunlape1ca66d1b2006-10-03 01:13:51 -0700338/**
Randy Dunlape1ca66d1b2006-10-03 01:13:51 -0700339 * release_resource - release a previously reserved resource
340 * @old: resource pointer
341 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342int release_resource(struct resource *old)
343{
344 int retval;
345
346 write_lock(&resource_lock);
Toshi Kaniff3cc952016-03-09 12:47:04 -0700347 retval = __release_resource(old, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 write_unlock(&resource_lock);
349 return retval;
350}
351
352EXPORT_SYMBOL(release_resource);
353
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700354/*
Toshi Kani3f336472016-01-26 21:57:29 +0100355 * Finds the lowest iomem resource existing within [res->start.res->end).
356 * The caller must specify res->start, res->end, res->flags, and optionally
Toshi Kania8fc4252016-01-26 21:57:32 +0100357 * desc. If found, returns 0, res is overwritten, if not found, returns -1.
Toshi Kani3f336472016-01-26 21:57:29 +0100358 * This function walks the whole tree and not just first level children until
359 * and unless first_level_children_only is true.
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700360 */
Toshi Kani3f336472016-01-26 21:57:29 +0100361static int find_next_iomem_res(struct resource *res, unsigned long desc,
Toshi Kania8fc4252016-01-26 21:57:32 +0100362 bool first_level_children_only)
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700363{
364 resource_size_t start, end;
365 struct resource *p;
Vivek Goyal8c86e702014-08-08 14:25:50 -0700366 bool sibling_only = false;
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700367
368 BUG_ON(!res);
369
370 start = res->start;
371 end = res->end;
KAMEZAWA Hiroyuki58c1b5b2006-08-05 12:15:01 -0700372 BUG_ON(start >= end);
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700373
Vivek Goyal800df622014-08-29 15:18:29 -0700374 if (first_level_children_only)
375 sibling_only = true;
376
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700377 read_lock(&resource_lock);
Vivek Goyal8c86e702014-08-08 14:25:50 -0700378
Vivek Goyal800df622014-08-29 15:18:29 -0700379 for (p = iomem_resource.child; p; p = next_resource(p, sibling_only)) {
Toshi Kania3650d52016-01-26 21:57:18 +0100380 if ((p->flags & res->flags) != res->flags)
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700381 continue;
Toshi Kani3f336472016-01-26 21:57:29 +0100382 if ((desc != IORES_DESC_NONE) && (desc != p->desc))
383 continue;
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700384 if (p->start > end) {
385 p = NULL;
386 break;
387 }
KAMEZAWA Hiroyuki58c1b5b2006-08-05 12:15:01 -0700388 if ((p->end >= start) && (p->start < end))
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700389 break;
390 }
Vivek Goyal8c86e702014-08-08 14:25:50 -0700391
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700392 read_unlock(&resource_lock);
393 if (!p)
394 return -1;
395 /* copy data */
KAMEZAWA Hiroyuki0f04ab52006-08-05 12:14:59 -0700396 if (res->start < p->start)
397 res->start = p->start;
398 if (res->end > p->end)
399 res->end = p->end;
Tom Lendacky0e4c12b2017-10-20 09:30:52 -0500400 res->flags = p->flags;
401 res->desc = p->desc;
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700402 return 0;
403}
KAMEZAWA Hiroyuki908eedc2009-09-22 16:45:46 -0700404
Tom Lendacky4ac2aed2017-10-20 09:30:50 -0500405static int __walk_iomem_res_desc(struct resource *res, unsigned long desc,
406 bool first_level_children_only,
Tom Lendacky1d2e7332017-10-20 09:30:51 -0500407 void *arg,
408 int (*func)(struct resource *, void *))
Tom Lendacky4ac2aed2017-10-20 09:30:50 -0500409{
410 u64 orig_end = res->end;
411 int ret = -1;
412
413 while ((res->start < res->end) &&
414 !find_next_iomem_res(res, desc, first_level_children_only)) {
Tom Lendacky1d2e7332017-10-20 09:30:51 -0500415 ret = (*func)(res, arg);
Tom Lendacky4ac2aed2017-10-20 09:30:50 -0500416 if (ret)
417 break;
418
419 res->start = res->end + 1;
420 res->end = orig_end;
421 }
422
423 return ret;
424}
425
KAMEZAWA Hiroyuki908eedc2009-09-22 16:45:46 -0700426/*
Vivek Goyal8c86e702014-08-08 14:25:50 -0700427 * Walks through iomem resources and calls func() with matching resource
428 * ranges. This walks through whole tree and not just first level children.
429 * All the memory ranges which overlap start,end and also match flags and
Toshi Kani3f336472016-01-26 21:57:29 +0100430 * desc are valid candidates.
431 *
432 * @desc: I/O resource descriptor. Use IORES_DESC_NONE to skip @desc check.
433 * @flags: I/O resource flags
434 * @start: start addr
435 * @end: end addr
436 *
437 * NOTE: For a new descriptor search, define a new IORES_DESC in
438 * <linux/ioport.h> and set it in 'desc' of a target resource entry.
439 */
440int walk_iomem_res_desc(unsigned long desc, unsigned long flags, u64 start,
Tom Lendacky1d2e7332017-10-20 09:30:51 -0500441 u64 end, void *arg, int (*func)(struct resource *, void *))
Toshi Kani3f336472016-01-26 21:57:29 +0100442{
443 struct resource res;
Toshi Kani3f336472016-01-26 21:57:29 +0100444
445 res.start = start;
446 res.end = end;
447 res.flags = flags;
Toshi Kani3f336472016-01-26 21:57:29 +0100448
Tom Lendacky4ac2aed2017-10-20 09:30:50 -0500449 return __walk_iomem_res_desc(&res, desc, false, arg, func);
Toshi Kani3f336472016-01-26 21:57:29 +0100450}
Dan Williamsd76401a2018-06-02 11:43:39 -0700451EXPORT_SYMBOL_GPL(walk_iomem_res_desc);
Toshi Kani3f336472016-01-26 21:57:29 +0100452
453/*
Toshi Kanibd7e6cb2016-01-26 21:57:26 +0100454 * This function calls the @func callback against all memory ranges of type
455 * System RAM which are marked as IORESOURCE_SYSTEM_RAM and IORESOUCE_BUSY.
456 * Now, this function is only for System RAM, it deals with full ranges and
457 * not PFNs. If resources are not PFN-aligned, dealing with PFNs can truncate
458 * ranges.
Vivek Goyal8c86e702014-08-08 14:25:50 -0700459 */
460int walk_system_ram_res(u64 start, u64 end, void *arg,
Tom Lendacky1d2e7332017-10-20 09:30:51 -0500461 int (*func)(struct resource *, void *))
Vivek Goyal8c86e702014-08-08 14:25:50 -0700462{
463 struct resource res;
Vivek Goyal8c86e702014-08-08 14:25:50 -0700464
465 res.start = start;
466 res.end = end;
Toshi Kanibd7e6cb2016-01-26 21:57:26 +0100467 res.flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
Tom Lendacky4ac2aed2017-10-20 09:30:50 -0500468
469 return __walk_iomem_res_desc(&res, IORES_DESC_NONE, true,
470 arg, func);
Vivek Goyal8c86e702014-08-08 14:25:50 -0700471}
472
Tom Lendacky0e4c12b2017-10-20 09:30:52 -0500473/*
474 * This function calls the @func callback against all memory ranges, which
475 * are ranges marked as IORESOURCE_MEM and IORESOUCE_BUSY.
476 */
477int walk_mem_res(u64 start, u64 end, void *arg,
478 int (*func)(struct resource *, void *))
479{
480 struct resource res;
481
482 res.start = start;
483 res.end = end;
484 res.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
485
486 return __walk_iomem_res_desc(&res, IORES_DESC_NONE, true,
487 arg, func);
488}
489
Vivek Goyal8c86e702014-08-08 14:25:50 -0700490#if !defined(CONFIG_ARCH_HAS_WALK_MEMORY)
491
492/*
Toshi Kanibd7e6cb2016-01-26 21:57:26 +0100493 * This function calls the @func callback against all memory ranges of type
494 * System RAM which are marked as IORESOURCE_SYSTEM_RAM and IORESOUCE_BUSY.
495 * It is to be used only for System RAM.
KAMEZAWA Hiroyuki908eedc2009-09-22 16:45:46 -0700496 */
497int walk_system_ram_range(unsigned long start_pfn, unsigned long nr_pages,
498 void *arg, int (*func)(unsigned long, unsigned long, void *))
KAMEZAWA Hiroyuki75884fb2007-10-16 01:26:10 -0700499{
500 struct resource res;
Wu Fengguang37b99dd2010-03-01 21:55:51 +0800501 unsigned long pfn, end_pfn;
KAMEZAWA Hiroyuki75884fb2007-10-16 01:26:10 -0700502 u64 orig_end;
503 int ret = -1;
KAMEZAWA Hiroyuki908eedc2009-09-22 16:45:46 -0700504
KAMEZAWA Hiroyuki75884fb2007-10-16 01:26:10 -0700505 res.start = (u64) start_pfn << PAGE_SHIFT;
506 res.end = ((u64)(start_pfn + nr_pages) << PAGE_SHIFT) - 1;
Toshi Kanibd7e6cb2016-01-26 21:57:26 +0100507 res.flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
KAMEZAWA Hiroyuki75884fb2007-10-16 01:26:10 -0700508 orig_end = res.end;
KAMEZAWA Hiroyuki908eedc2009-09-22 16:45:46 -0700509 while ((res.start < res.end) &&
Toshi Kania8fc4252016-01-26 21:57:32 +0100510 (find_next_iomem_res(&res, IORES_DESC_NONE, true) >= 0)) {
Wu Fengguang37b99dd2010-03-01 21:55:51 +0800511 pfn = (res.start + PAGE_SIZE - 1) >> PAGE_SHIFT;
512 end_pfn = (res.end + 1) >> PAGE_SHIFT;
513 if (end_pfn > pfn)
H. Peter Anvinf4149662010-03-02 11:21:09 -0800514 ret = (*func)(pfn, end_pfn - pfn, arg);
KAMEZAWA Hiroyuki75884fb2007-10-16 01:26:10 -0700515 if (ret)
516 break;
517 res.start = res.end + 1;
518 res.end = orig_end;
519 }
520 return ret;
521}
522
KAMEZAWA Hiroyuki2842f112006-06-27 02:53:36 -0700523#endif
524
Wu Fengguang61ef2482010-01-22 16:16:19 +0800525static int __is_ram(unsigned long pfn, unsigned long nr_pages, void *arg)
526{
527 return 1;
528}
Tom Lendacky4ac2aed2017-10-20 09:30:50 -0500529
Wu Fengguang61ef2482010-01-22 16:16:19 +0800530/*
531 * This generic page_is_ram() returns true if specified address is
Toshi Kanibd7e6cb2016-01-26 21:57:26 +0100532 * registered as System RAM in iomem_resource list.
Wu Fengguang61ef2482010-01-22 16:16:19 +0800533 */
Andrew Mortone5273002010-01-26 16:31:19 -0800534int __weak page_is_ram(unsigned long pfn)
Wu Fengguang61ef2482010-01-22 16:16:19 +0800535{
536 return walk_system_ram_range(pfn, 1, NULL, __is_ram) == 1;
537}
Chen Gongc5a13032013-06-06 15:20:51 -0700538EXPORT_SYMBOL_GPL(page_is_ram);
Wu Fengguang61ef2482010-01-22 16:16:19 +0800539
Dan Williams124fe202015-08-10 23:07:05 -0400540/**
541 * region_intersects() - determine intersection of region with known resources
542 * @start: region start address
543 * @size: size of region
Toshi Kani1c29f252016-01-26 21:57:28 +0100544 * @flags: flags of resource (in iomem_resource)
545 * @desc: descriptor of resource (in iomem_resource) or IORES_DESC_NONE
Mike Travis67cf13c2014-10-13 15:54:03 -0700546 *
Dan Williams124fe202015-08-10 23:07:05 -0400547 * Check if the specified region partially overlaps or fully eclipses a
Toshi Kani1c29f252016-01-26 21:57:28 +0100548 * resource identified by @flags and @desc (optional with IORES_DESC_NONE).
549 * Return REGION_DISJOINT if the region does not overlap @flags/@desc,
550 * return REGION_MIXED if the region overlaps @flags/@desc and another
551 * resource, and return REGION_INTERSECTS if the region overlaps @flags/@desc
552 * and no other defined resource. Note that REGION_INTERSECTS is also
553 * returned in the case when the specified region overlaps RAM and undefined
554 * memory holes.
Dan Williams124fe202015-08-10 23:07:05 -0400555 *
556 * region_intersect() is used by memory remapping functions to ensure
557 * the user is not remapping RAM and is a vast speed up over walking
558 * through the resource table page by page.
Mike Travis67cf13c2014-10-13 15:54:03 -0700559 */
Toshi Kani1c29f252016-01-26 21:57:28 +0100560int region_intersects(resource_size_t start, size_t size, unsigned long flags,
561 unsigned long desc)
Mike Travis67cf13c2014-10-13 15:54:03 -0700562{
Dan Williams124fe202015-08-10 23:07:05 -0400563 resource_size_t end = start + size - 1;
564 int type = 0; int other = 0;
565 struct resource *p;
Mike Travis67cf13c2014-10-13 15:54:03 -0700566
567 read_lock(&resource_lock);
568 for (p = iomem_resource.child; p ; p = p->sibling) {
Toshi Kani1c29f252016-01-26 21:57:28 +0100569 bool is_type = (((p->flags & flags) == flags) &&
570 ((desc == IORES_DESC_NONE) ||
571 (desc == p->desc)));
Mike Travis67cf13c2014-10-13 15:54:03 -0700572
Dan Williams124fe202015-08-10 23:07:05 -0400573 if (start >= p->start && start <= p->end)
574 is_type ? type++ : other++;
575 if (end >= p->start && end <= p->end)
576 is_type ? type++ : other++;
577 if (p->start >= start && p->end <= end)
578 is_type ? type++ : other++;
Mike Travis67cf13c2014-10-13 15:54:03 -0700579 }
580 read_unlock(&resource_lock);
Dan Williams124fe202015-08-10 23:07:05 -0400581
582 if (other == 0)
583 return type ? REGION_INTERSECTS : REGION_DISJOINT;
584
585 if (type)
586 return REGION_MIXED;
587
588 return REGION_DISJOINT;
Mike Travis67cf13c2014-10-13 15:54:03 -0700589}
Toshi Kani1c29f252016-01-26 21:57:28 +0100590EXPORT_SYMBOL_GPL(region_intersects);
Mike Travis67cf13c2014-10-13 15:54:03 -0700591
Bjorn Helgaasfcb11912010-12-16 10:38:46 -0700592void __weak arch_remove_reservations(struct resource *avail)
593{
594}
595
Bjorn Helgaasa9cea012010-10-26 15:41:13 -0600596static resource_size_t simple_align_resource(void *data,
597 const struct resource *avail,
598 resource_size_t size,
599 resource_size_t align)
600{
601 return avail->start;
602}
603
Bjorn Helgaas5d6b1fa2010-10-26 15:41:18 -0600604static void resource_clip(struct resource *res, resource_size_t min,
605 resource_size_t max)
606{
607 if (res->start < min)
608 res->start = min;
609 if (res->end > max)
610 res->end = max;
611}
612
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613/*
Ram Pai23c570a2011-07-05 23:44:30 -0700614 * Find empty slot in the resource tree with the given range and
615 * alignment constraints
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 */
Ram Pai23c570a2011-07-05 23:44:30 -0700617static int __find_resource(struct resource *root, struct resource *old,
618 struct resource *new,
619 resource_size_t size,
620 struct resource_constraint *constraint)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621{
622 struct resource *this = root->child;
Bjorn Helgaasa1862e32010-10-26 15:41:28 -0600623 struct resource tmp = *new, avail, alloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
Dominik Brodowski0e2c8b82009-12-20 10:50:02 +0100625 tmp.start = root->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 /*
Bjorn Helgaasc0f5ac542010-12-16 10:38:41 -0700627 * Skip past an allocated resource that starts at 0, since the assignment
628 * of this->start - 1 to tmp->end below would cause an underflow.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 */
Ram Pai23c570a2011-07-05 23:44:30 -0700630 if (this && this->start == root->start) {
631 tmp.start = (this == old) ? old->start : this->end + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 this = this->sibling;
633 }
Bjorn Helgaasc0f5ac542010-12-16 10:38:41 -0700634 for(;;) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 if (this)
Ram Pai23c570a2011-07-05 23:44:30 -0700636 tmp.end = (this == old) ? this->end : this->start - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 else
Dominik Brodowski0e2c8b82009-12-20 10:50:02 +0100638 tmp.end = root->end;
Bjorn Helgaas5d6b1fa2010-10-26 15:41:18 -0600639
Ram Pai47ea91b2011-09-22 15:48:58 +0800640 if (tmp.end < tmp.start)
641 goto next;
642
Ram Pai23c570a2011-07-05 23:44:30 -0700643 resource_clip(&tmp, constraint->min, constraint->max);
Bjorn Helgaasfcb11912010-12-16 10:38:46 -0700644 arch_remove_reservations(&tmp);
Bjorn Helgaasa9cea012010-10-26 15:41:13 -0600645
Bjorn Helgaasa1862e32010-10-26 15:41:28 -0600646 /* Check for overflow after ALIGN() */
Ram Pai23c570a2011-07-05 23:44:30 -0700647 avail.start = ALIGN(tmp.start, constraint->align);
Bjorn Helgaasa1862e32010-10-26 15:41:28 -0600648 avail.end = tmp.end;
Bjorn Helgaas5edb93b2014-02-04 19:32:28 -0800649 avail.flags = new->flags & ~IORESOURCE_UNSET;
Bjorn Helgaasa1862e32010-10-26 15:41:28 -0600650 if (avail.start >= tmp.start) {
Bjorn Helgaas5edb93b2014-02-04 19:32:28 -0800651 alloc.flags = avail.flags;
Ram Pai23c570a2011-07-05 23:44:30 -0700652 alloc.start = constraint->alignf(constraint->alignf_data, &avail,
653 size, constraint->align);
Bjorn Helgaasa1862e32010-10-26 15:41:28 -0600654 alloc.end = alloc.start + size - 1;
Takashi Iwai60bb83b2018-04-13 15:35:13 -0700655 if (alloc.start <= alloc.end &&
656 resource_contains(&avail, &alloc)) {
Bjorn Helgaasa1862e32010-10-26 15:41:28 -0600657 new->start = alloc.start;
658 new->end = alloc.end;
659 return 0;
660 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 }
Ram Pai47ea91b2011-09-22 15:48:58 +0800662
663next: if (!this || this->end == root->end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 break;
Ram Pai47ea91b2011-09-22 15:48:58 +0800665
Ram Pai23c570a2011-07-05 23:44:30 -0700666 if (this != old)
667 tmp.start = this->end + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 this = this->sibling;
669 }
670 return -EBUSY;
671}
672
Ram Pai23c570a2011-07-05 23:44:30 -0700673/*
674 * Find empty slot in the resource tree given range and alignment.
675 */
676static int find_resource(struct resource *root, struct resource *new,
677 resource_size_t size,
678 struct resource_constraint *constraint)
679{
680 return __find_resource(root, NULL, new, size, constraint);
681}
682
Randy Dunlape1ca66d1b2006-10-03 01:13:51 -0700683/**
Ram Pai23c570a2011-07-05 23:44:30 -0700684 * reallocate_resource - allocate a slot in the resource tree given range & alignment.
685 * The resource will be relocated if the new size cannot be reallocated in the
686 * current location.
687 *
688 * @root: root resource descriptor
689 * @old: resource descriptor desired by caller
690 * @newsize: new size of the resource descriptor
691 * @constraint: the size and alignment constraints to be met.
692 */
Daeseok Youn28ab49f2014-04-03 14:48:36 -0700693static int reallocate_resource(struct resource *root, struct resource *old,
Ram Pai23c570a2011-07-05 23:44:30 -0700694 resource_size_t newsize,
695 struct resource_constraint *constraint)
696{
697 int err=0;
698 struct resource new = *old;
699 struct resource *conflict;
700
701 write_lock(&resource_lock);
702
703 if ((err = __find_resource(root, old, &new, newsize, constraint)))
704 goto out;
705
706 if (resource_contains(&new, old)) {
707 old->start = new.start;
708 old->end = new.end;
709 goto out;
710 }
711
712 if (old->child) {
713 err = -EBUSY;
714 goto out;
715 }
716
717 if (resource_contains(old, &new)) {
718 old->start = new.start;
719 old->end = new.end;
720 } else {
Toshi Kaniff3cc952016-03-09 12:47:04 -0700721 __release_resource(old, true);
Ram Pai23c570a2011-07-05 23:44:30 -0700722 *old = new;
723 conflict = __request_resource(root, old);
724 BUG_ON(conflict);
725 }
726out:
727 write_unlock(&resource_lock);
728 return err;
729}
730
731
732/**
733 * allocate_resource - allocate empty slot in the resource tree given range & alignment.
734 * The resource will be reallocated with a new size if it was already allocated
Randy Dunlape1ca66d1b2006-10-03 01:13:51 -0700735 * @root: root resource descriptor
736 * @new: resource descriptor desired by caller
737 * @size: requested resource region size
Wei Yangee5e5682012-05-31 16:26:05 -0700738 * @min: minimum boundary to allocate
739 * @max: maximum boundary to allocate
Randy Dunlape1ca66d1b2006-10-03 01:13:51 -0700740 * @align: alignment requested, in bytes
741 * @alignf: alignment function, optional, called if not NULL
742 * @alignf_data: arbitrary data to pass to the @alignf function
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 */
744int allocate_resource(struct resource *root, struct resource *new,
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700745 resource_size_t size, resource_size_t min,
746 resource_size_t max, resource_size_t align,
Dominik Brodowskib26b2d42010-01-01 17:40:49 +0100747 resource_size_t (*alignf)(void *,
Dominik Brodowski3b7a17f2010-01-01 17:40:50 +0100748 const struct resource *,
Dominik Brodowskib26b2d42010-01-01 17:40:49 +0100749 resource_size_t,
750 resource_size_t),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 void *alignf_data)
752{
753 int err;
Ram Pai23c570a2011-07-05 23:44:30 -0700754 struct resource_constraint constraint;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
Bjorn Helgaasa9cea012010-10-26 15:41:13 -0600756 if (!alignf)
757 alignf = simple_align_resource;
758
Ram Pai23c570a2011-07-05 23:44:30 -0700759 constraint.min = min;
760 constraint.max = max;
761 constraint.align = align;
762 constraint.alignf = alignf;
763 constraint.alignf_data = alignf_data;
764
765 if ( new->parent ) {
766 /* resource is already allocated, try reallocating with
767 the new constraints */
768 return reallocate_resource(root, new, size, &constraint);
769 }
770
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 write_lock(&resource_lock);
Ram Pai23c570a2011-07-05 23:44:30 -0700772 err = find_resource(root, new, size, &constraint);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 if (err >= 0 && __request_resource(root, new))
774 err = -EBUSY;
775 write_unlock(&resource_lock);
776 return err;
777}
778
779EXPORT_SYMBOL(allocate_resource);
780
Geert Uytterhoeven1c388912011-05-07 20:53:16 +0200781/**
782 * lookup_resource - find an existing resource by a resource start address
783 * @root: root resource descriptor
784 * @start: resource start address
785 *
786 * Returns a pointer to the resource if found, NULL otherwise
787 */
788struct resource *lookup_resource(struct resource *root, resource_size_t start)
789{
790 struct resource *res;
791
792 read_lock(&resource_lock);
793 for (res = root->child; res; res = res->sibling) {
794 if (res->start == start)
795 break;
796 }
797 read_unlock(&resource_lock);
798
799 return res;
800}
801
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700802/*
803 * Insert a resource into the resource tree. If successful, return NULL,
804 * otherwise return the conflicting resource (compare to __request_resource())
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 */
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700806static struct resource * __insert_resource(struct resource *parent, struct resource *new)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 struct resource *first, *next;
809
Matthew Wilcoxd33b6fb2006-06-30 02:31:24 -0700810 for (;; parent = first) {
Matthew Wilcoxd33b6fb2006-06-30 02:31:24 -0700811 first = __request_resource(parent, new);
812 if (!first)
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700813 return first;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
Matthew Wilcoxd33b6fb2006-06-30 02:31:24 -0700815 if (first == parent)
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700816 return first;
Huang Shijie5de1cb22010-10-27 15:34:52 -0700817 if (WARN_ON(first == new)) /* duplicated insertion */
818 return first;
Matthew Wilcoxd33b6fb2006-06-30 02:31:24 -0700819
820 if ((first->start > new->start) || (first->end < new->end))
821 break;
822 if ((first->start == new->start) && (first->end == new->end))
823 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 }
825
826 for (next = first; ; next = next->sibling) {
827 /* Partial overlap? Bad, and unfixable */
828 if (next->start < new->start || next->end > new->end)
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700829 return next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 if (!next->sibling)
831 break;
832 if (next->sibling->start > new->end)
833 break;
834 }
835
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 new->parent = parent;
837 new->sibling = next->sibling;
838 new->child = first;
839
840 next->sibling = NULL;
841 for (next = first; next; next = next->sibling)
842 next->parent = new;
843
844 if (parent->child == first) {
845 parent->child = new;
846 } else {
847 next = parent->child;
848 while (next->sibling != first)
849 next = next->sibling;
850 next->sibling = new;
851 }
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700852 return NULL;
853}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700855/**
Bjorn Helgaas66f12072010-03-11 17:01:09 -0700856 * insert_resource_conflict - Inserts resource in the resource tree
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700857 * @parent: parent of the new resource
858 * @new: new resource to insert
859 *
Bjorn Helgaas66f12072010-03-11 17:01:09 -0700860 * Returns 0 on success, conflict resource if the resource can't be inserted.
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700861 *
Bjorn Helgaas66f12072010-03-11 17:01:09 -0700862 * This function is equivalent to request_resource_conflict when no conflict
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700863 * happens. If a conflict happens, and the conflicting resources
864 * entirely fit within the range of the new resource, then the new
865 * resource is inserted and the conflicting resources become children of
866 * the new resource.
Toshi Kaniff3cc952016-03-09 12:47:04 -0700867 *
868 * This function is intended for producers of resources, such as FW modules
869 * and bus drivers.
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700870 */
Bjorn Helgaas66f12072010-03-11 17:01:09 -0700871struct resource *insert_resource_conflict(struct resource *parent, struct resource *new)
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700872{
873 struct resource *conflict;
874
875 write_lock(&resource_lock);
876 conflict = __insert_resource(parent, new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 write_unlock(&resource_lock);
Bjorn Helgaas66f12072010-03-11 17:01:09 -0700878 return conflict;
879}
880
881/**
882 * insert_resource - Inserts a resource in the resource tree
883 * @parent: parent of the new resource
884 * @new: new resource to insert
885 *
886 * Returns 0 on success, -EBUSY if the resource can't be inserted.
Toshi Kaniff3cc952016-03-09 12:47:04 -0700887 *
888 * This function is intended for producers of resources, such as FW modules
889 * and bus drivers.
Bjorn Helgaas66f12072010-03-11 17:01:09 -0700890 */
891int insert_resource(struct resource *parent, struct resource *new)
892{
893 struct resource *conflict;
894
895 conflict = insert_resource_conflict(parent, new);
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700896 return conflict ? -EBUSY : 0;
897}
Toshi Kani8095d0f2016-03-09 12:47:05 -0700898EXPORT_SYMBOL_GPL(insert_resource);
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700899
900/**
901 * insert_resource_expand_to_fit - Insert a resource into the resource tree
Randy Dunlap6781f4a2008-08-31 20:31:55 -0700902 * @root: root resource descriptor
Linus Torvaldsbef69ea2008-08-29 20:18:31 -0700903 * @new: new resource to insert
904 *
905 * Insert a resource into the resource tree, possibly expanding it in order
906 * to make it encompass any conflicting resources.
907 */
908void insert_resource_expand_to_fit(struct resource *root, struct resource *new)
909{
910 if (new->parent)
911 return;
912
913 write_lock(&resource_lock);
914 for (;;) {
915 struct resource *conflict;
916
917 conflict = __insert_resource(root, new);
918 if (!conflict)
919 break;
920 if (conflict == root)
921 break;
922
923 /* Ok, expand resource to cover the conflict, then try again .. */
924 if (conflict->start < new->start)
925 new->start = conflict->start;
926 if (conflict->end > new->end)
927 new->end = conflict->end;
928
929 printk("Expanded resource %s due to conflict with %s\n", new->name, conflict->name);
930 }
931 write_unlock(&resource_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932}
933
Toshi Kaniff3cc952016-03-09 12:47:04 -0700934/**
935 * remove_resource - Remove a resource in the resource tree
936 * @old: resource to remove
937 *
938 * Returns 0 on success, -EINVAL if the resource is not valid.
939 *
940 * This function removes a resource previously inserted by insert_resource()
941 * or insert_resource_conflict(), and moves the children (if any) up to
942 * where they were before. insert_resource() and insert_resource_conflict()
943 * insert a new resource, and move any conflicting resources down to the
944 * children of the new resource.
945 *
946 * insert_resource(), insert_resource_conflict() and remove_resource() are
947 * intended for producers of resources, such as FW modules and bus drivers.
948 */
949int remove_resource(struct resource *old)
950{
951 int retval;
952
953 write_lock(&resource_lock);
954 retval = __release_resource(old, false);
955 write_unlock(&resource_lock);
956 return retval;
957}
Toshi Kani8095d0f2016-03-09 12:47:05 -0700958EXPORT_SYMBOL_GPL(remove_resource);
Toshi Kaniff3cc952016-03-09 12:47:04 -0700959
Toshi Kaniae8e3a92013-04-29 15:08:17 -0700960static int __adjust_resource(struct resource *res, resource_size_t start,
961 resource_size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962{
963 struct resource *tmp, *parent = res->parent;
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -0700964 resource_size_t end = start + size - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 int result = -EBUSY;
966
Yinghai Lu82ec90e2012-05-17 18:51:11 -0700967 if (!parent)
968 goto skip;
969
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 if ((start < parent->start) || (end > parent->end))
971 goto out;
972
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 if (res->sibling && (res->sibling->start <= end))
974 goto out;
975
976 tmp = parent->child;
977 if (tmp != res) {
978 while (tmp->sibling != res)
979 tmp = tmp->sibling;
980 if (start <= tmp->end)
981 goto out;
982 }
983
Yinghai Lu82ec90e2012-05-17 18:51:11 -0700984skip:
985 for (tmp = res->child; tmp; tmp = tmp->sibling)
986 if ((tmp->start < start) || (tmp->end > end))
987 goto out;
988
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 res->start = start;
990 res->end = end;
991 result = 0;
992
993 out:
Toshi Kaniae8e3a92013-04-29 15:08:17 -0700994 return result;
995}
996
997/**
998 * adjust_resource - modify a resource's start and size
999 * @res: resource to modify
1000 * @start: new start value
1001 * @size: new size
1002 *
1003 * Given an existing resource, change its start and size to match the
1004 * arguments. Returns 0 on success, -EBUSY if it can't fit.
1005 * Existing children of the resource are assumed to be immutable.
1006 */
1007int adjust_resource(struct resource *res, resource_size_t start,
1008 resource_size_t size)
1009{
1010 int result;
1011
1012 write_lock(&resource_lock);
1013 result = __adjust_resource(res, start, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 write_unlock(&resource_lock);
1015 return result;
1016}
Cong Wang24105742012-02-03 21:42:39 +08001017EXPORT_SYMBOL(adjust_resource);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018
Yinghai Lu268364a2008-09-04 21:02:44 +02001019static void __init __reserve_region_with_split(struct resource *root,
1020 resource_size_t start, resource_size_t end,
1021 const char *name)
1022{
1023 struct resource *parent = root;
1024 struct resource *conflict;
Yasuaki Ishimatsuebff7d82013-04-29 15:08:56 -07001025 struct resource *res = alloc_resource(GFP_ATOMIC);
T Makphaibulchoke4965f562012-10-04 17:16:55 -07001026 struct resource *next_res = NULL;
Bjorn Helgaasf37e2332017-12-01 14:07:18 -06001027 int type = resource_type(root);
Yinghai Lu268364a2008-09-04 21:02:44 +02001028
1029 if (!res)
1030 return;
1031
1032 res->name = name;
1033 res->start = start;
1034 res->end = end;
Bjorn Helgaasf37e2332017-12-01 14:07:18 -06001035 res->flags = type | IORESOURCE_BUSY;
Toshi Kani43ee4932016-01-26 21:57:19 +01001036 res->desc = IORES_DESC_NONE;
Yinghai Lu268364a2008-09-04 21:02:44 +02001037
T Makphaibulchoke4965f562012-10-04 17:16:55 -07001038 while (1) {
Yinghai Lu268364a2008-09-04 21:02:44 +02001039
T Makphaibulchoke4965f562012-10-04 17:16:55 -07001040 conflict = __request_resource(parent, res);
1041 if (!conflict) {
1042 if (!next_res)
1043 break;
1044 res = next_res;
1045 next_res = NULL;
1046 continue;
1047 }
Yinghai Lu268364a2008-09-04 21:02:44 +02001048
T Makphaibulchoke4965f562012-10-04 17:16:55 -07001049 /* conflict covered whole area */
1050 if (conflict->start <= res->start &&
1051 conflict->end >= res->end) {
Yasuaki Ishimatsuebff7d82013-04-29 15:08:56 -07001052 free_resource(res);
T Makphaibulchoke4965f562012-10-04 17:16:55 -07001053 WARN_ON(next_res);
1054 break;
1055 }
Yinghai Lu268364a2008-09-04 21:02:44 +02001056
T Makphaibulchoke4965f562012-10-04 17:16:55 -07001057 /* failed, split and try again */
1058 if (conflict->start > res->start) {
1059 end = res->end;
1060 res->end = conflict->start - 1;
1061 if (conflict->end < end) {
Yasuaki Ishimatsuebff7d82013-04-29 15:08:56 -07001062 next_res = alloc_resource(GFP_ATOMIC);
T Makphaibulchoke4965f562012-10-04 17:16:55 -07001063 if (!next_res) {
Yasuaki Ishimatsuebff7d82013-04-29 15:08:56 -07001064 free_resource(res);
T Makphaibulchoke4965f562012-10-04 17:16:55 -07001065 break;
1066 }
1067 next_res->name = name;
1068 next_res->start = conflict->end + 1;
1069 next_res->end = end;
Bjorn Helgaasf37e2332017-12-01 14:07:18 -06001070 next_res->flags = type | IORESOURCE_BUSY;
Toshi Kani43ee4932016-01-26 21:57:19 +01001071 next_res->desc = IORES_DESC_NONE;
T Makphaibulchoke4965f562012-10-04 17:16:55 -07001072 }
1073 } else {
1074 res->start = conflict->end + 1;
1075 }
1076 }
1077
Yinghai Lu268364a2008-09-04 21:02:44 +02001078}
1079
Paul Mundtbea92112008-10-22 19:31:11 +09001080void __init reserve_region_with_split(struct resource *root,
Yinghai Lu268364a2008-09-04 21:02:44 +02001081 resource_size_t start, resource_size_t end,
1082 const char *name)
1083{
Octavian Purdila65fed8f2012-07-30 14:42:58 -07001084 int abort = 0;
1085
Yinghai Lu268364a2008-09-04 21:02:44 +02001086 write_lock(&resource_lock);
Octavian Purdila65fed8f2012-07-30 14:42:58 -07001087 if (root->start > start || root->end < end) {
1088 pr_err("requested range [0x%llx-0x%llx] not in root %pr\n",
1089 (unsigned long long)start, (unsigned long long)end,
1090 root);
1091 if (start > root->end || end < root->start)
1092 abort = 1;
1093 else {
1094 if (end > root->end)
1095 end = root->end;
1096 if (start < root->start)
1097 start = root->start;
1098 pr_err("fixing request to [0x%llx-0x%llx]\n",
1099 (unsigned long long)start,
1100 (unsigned long long)end);
1101 }
1102 dump_stack();
1103 }
1104 if (!abort)
1105 __reserve_region_with_split(root, start, end, name);
Yinghai Lu268364a2008-09-04 21:02:44 +02001106 write_unlock(&resource_lock);
1107}
1108
Ivan Kokshaysky88452562008-03-30 19:50:14 +04001109/**
1110 * resource_alignment - calculate resource's alignment
1111 * @res: resource pointer
1112 *
1113 * Returns alignment on success, 0 (invalid alignment) on failure.
1114 */
1115resource_size_t resource_alignment(struct resource *res)
1116{
1117 switch (res->flags & (IORESOURCE_SIZEALIGN | IORESOURCE_STARTALIGN)) {
1118 case IORESOURCE_SIZEALIGN:
Magnus Damm1a4e5642008-07-29 22:32:57 -07001119 return resource_size(res);
Ivan Kokshaysky88452562008-03-30 19:50:14 +04001120 case IORESOURCE_STARTALIGN:
1121 return res->start;
1122 default:
1123 return 0;
1124 }
1125}
1126
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127/*
1128 * This is compatibility stuff for IO resources.
1129 *
1130 * Note how this, unlike the above, knows about
1131 * the IO flag meanings (busy etc).
1132 *
Randy Dunlape1ca66d1b2006-10-03 01:13:51 -07001133 * request_region creates a new busy region.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 *
Randy Dunlape1ca66d1b2006-10-03 01:13:51 -07001135 * release_region releases a matching busy region.
1136 */
1137
Alan Cox8b6d0432010-03-29 19:38:00 +02001138static DECLARE_WAIT_QUEUE_HEAD(muxed_resource_wait);
1139
Randy Dunlape1ca66d1b2006-10-03 01:13:51 -07001140/**
1141 * __request_region - create a new busy resource region
1142 * @parent: parent resource descriptor
1143 * @start: resource start address
1144 * @n: resource region size
1145 * @name: reserving caller's ID string
Randy Dunlap6ae301e2009-01-15 13:51:01 -08001146 * @flags: IO resource flags
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 */
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -07001148struct resource * __request_region(struct resource *parent,
1149 resource_size_t start, resource_size_t n,
Arjan van de Vene8de1482008-10-22 19:55:31 -07001150 const char *name, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151{
Alan Cox8b6d0432010-03-29 19:38:00 +02001152 DECLARE_WAITQUEUE(wait, current);
Yasuaki Ishimatsuebff7d82013-04-29 15:08:56 -07001153 struct resource *res = alloc_resource(GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154
Bjorn Helgaasc26ec882008-10-15 22:05:14 -07001155 if (!res)
1156 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157
Bjorn Helgaasc26ec882008-10-15 22:05:14 -07001158 res->name = name;
1159 res->start = start;
1160 res->end = start + n - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
Bjorn Helgaasc26ec882008-10-15 22:05:14 -07001162 write_lock(&resource_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163
Bjorn Helgaasc26ec882008-10-15 22:05:14 -07001164 for (;;) {
1165 struct resource *conflict;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166
Toshi Kani4e0d8f7e2016-03-09 12:47:03 -07001167 res->flags = resource_type(parent) | resource_ext_type(parent);
1168 res->flags |= IORESOURCE_BUSY | flags;
1169 res->desc = parent->desc;
1170
Bjorn Helgaasc26ec882008-10-15 22:05:14 -07001171 conflict = __request_resource(parent, res);
1172 if (!conflict)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 break;
Bjorn Helgaasc26ec882008-10-15 22:05:14 -07001174 if (conflict != parent) {
Simon Guinot59ceeaa2015-09-10 00:15:18 +02001175 if (!(conflict->flags & IORESOURCE_BUSY)) {
1176 parent = conflict;
Bjorn Helgaasc26ec882008-10-15 22:05:14 -07001177 continue;
Simon Guinot59ceeaa2015-09-10 00:15:18 +02001178 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 }
Alan Cox8b6d0432010-03-29 19:38:00 +02001180 if (conflict->flags & flags & IORESOURCE_MUXED) {
1181 add_wait_queue(&muxed_resource_wait, &wait);
1182 write_unlock(&resource_lock);
1183 set_current_state(TASK_UNINTERRUPTIBLE);
1184 schedule();
1185 remove_wait_queue(&muxed_resource_wait, &wait);
1186 write_lock(&resource_lock);
1187 continue;
1188 }
Bjorn Helgaasc26ec882008-10-15 22:05:14 -07001189 /* Uhhuh, that didn't work out.. */
Yasuaki Ishimatsuebff7d82013-04-29 15:08:56 -07001190 free_resource(res);
Bjorn Helgaasc26ec882008-10-15 22:05:14 -07001191 res = NULL;
1192 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 }
Bjorn Helgaasc26ec882008-10-15 22:05:14 -07001194 write_unlock(&resource_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 return res;
1196}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197EXPORT_SYMBOL(__request_region);
1198
Randy Dunlape1ca66d1b2006-10-03 01:13:51 -07001199/**
Randy Dunlape1ca66d1b2006-10-03 01:13:51 -07001200 * __release_region - release a previously reserved resource region
1201 * @parent: parent resource descriptor
1202 * @start: resource start address
1203 * @n: resource region size
1204 *
1205 * The described resource region must match a currently busy region.
1206 */
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -07001207void __release_region(struct resource *parent, resource_size_t start,
1208 resource_size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209{
1210 struct resource **p;
Greg Kroah-Hartmand75fc8b2006-06-12 16:09:23 -07001211 resource_size_t end;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212
1213 p = &parent->child;
1214 end = start + n - 1;
1215
1216 write_lock(&resource_lock);
1217
1218 for (;;) {
1219 struct resource *res = *p;
1220
1221 if (!res)
1222 break;
1223 if (res->start <= start && res->end >= end) {
1224 if (!(res->flags & IORESOURCE_BUSY)) {
1225 p = &res->child;
1226 continue;
1227 }
1228 if (res->start != start || res->end != end)
1229 break;
1230 *p = res->sibling;
1231 write_unlock(&resource_lock);
Alan Cox8b6d0432010-03-29 19:38:00 +02001232 if (res->flags & IORESOURCE_MUXED)
1233 wake_up(&muxed_resource_wait);
Yasuaki Ishimatsuebff7d82013-04-29 15:08:56 -07001234 free_resource(res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 return;
1236 }
1237 p = &res->sibling;
1238 }
1239
1240 write_unlock(&resource_lock);
1241
Greg Kroah-Hartman685143ac2006-06-12 15:18:31 -07001242 printk(KERN_WARNING "Trying to free nonexistent resource "
1243 "<%016llx-%016llx>\n", (unsigned long long)start,
1244 (unsigned long long)end);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246EXPORT_SYMBOL(__release_region);
1247
Toshi Kani825f7872013-04-29 15:08:19 -07001248#ifdef CONFIG_MEMORY_HOTREMOVE
1249/**
1250 * release_mem_region_adjustable - release a previously reserved memory region
1251 * @parent: parent resource descriptor
1252 * @start: resource start address
1253 * @size: resource region size
1254 *
1255 * This interface is intended for memory hot-delete. The requested region
1256 * is released from a currently busy memory resource. The requested region
1257 * must either match exactly or fit into a single busy resource entry. In
1258 * the latter case, the remaining resource is adjusted accordingly.
1259 * Existing children of the busy memory resource must be immutable in the
1260 * request.
1261 *
1262 * Note:
1263 * - Additional release conditions, such as overlapping region, can be
1264 * supported after they are confirmed as valid cases.
1265 * - When a busy memory resource gets split into two entries, the code
1266 * assumes that all children remain in the lower address entry for
1267 * simplicity. Enhance this logic when necessary.
1268 */
1269int release_mem_region_adjustable(struct resource *parent,
1270 resource_size_t start, resource_size_t size)
1271{
1272 struct resource **p;
1273 struct resource *res;
1274 struct resource *new_res;
1275 resource_size_t end;
1276 int ret = -EINVAL;
1277
1278 end = start + size - 1;
1279 if ((start < parent->start) || (end > parent->end))
1280 return ret;
1281
Yasuaki Ishimatsuebff7d82013-04-29 15:08:56 -07001282 /* The alloc_resource() result gets checked later */
1283 new_res = alloc_resource(GFP_KERNEL);
Toshi Kani825f7872013-04-29 15:08:19 -07001284
1285 p = &parent->child;
1286 write_lock(&resource_lock);
1287
1288 while ((res = *p)) {
1289 if (res->start >= end)
1290 break;
1291
1292 /* look for the next resource if it does not fit into */
1293 if (res->start > start || res->end < end) {
1294 p = &res->sibling;
1295 continue;
1296 }
1297
1298 if (!(res->flags & IORESOURCE_MEM))
1299 break;
1300
1301 if (!(res->flags & IORESOURCE_BUSY)) {
1302 p = &res->child;
1303 continue;
1304 }
1305
1306 /* found the target resource; let's adjust accordingly */
1307 if (res->start == start && res->end == end) {
1308 /* free the whole entry */
1309 *p = res->sibling;
Yasuaki Ishimatsuebff7d82013-04-29 15:08:56 -07001310 free_resource(res);
Toshi Kani825f7872013-04-29 15:08:19 -07001311 ret = 0;
1312 } else if (res->start == start && res->end != end) {
1313 /* adjust the start */
1314 ret = __adjust_resource(res, end + 1,
1315 res->end - end);
1316 } else if (res->start != start && res->end == end) {
1317 /* adjust the end */
1318 ret = __adjust_resource(res, res->start,
1319 start - res->start);
1320 } else {
1321 /* split into two entries */
1322 if (!new_res) {
1323 ret = -ENOMEM;
1324 break;
1325 }
1326 new_res->name = res->name;
1327 new_res->start = end + 1;
1328 new_res->end = res->end;
1329 new_res->flags = res->flags;
Toshi Kani43ee4932016-01-26 21:57:19 +01001330 new_res->desc = res->desc;
Toshi Kani825f7872013-04-29 15:08:19 -07001331 new_res->parent = res->parent;
1332 new_res->sibling = res->sibling;
1333 new_res->child = NULL;
1334
1335 ret = __adjust_resource(res, res->start,
1336 start - res->start);
1337 if (ret)
1338 break;
1339 res->sibling = new_res;
1340 new_res = NULL;
1341 }
1342
1343 break;
1344 }
1345
1346 write_unlock(&resource_lock);
Yasuaki Ishimatsuebff7d82013-04-29 15:08:56 -07001347 free_resource(new_res);
Toshi Kani825f7872013-04-29 15:08:19 -07001348 return ret;
1349}
1350#endif /* CONFIG_MEMORY_HOTREMOVE */
1351
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352/*
Tejun Heo9ac78492007-01-20 16:00:26 +09001353 * Managed region resource
1354 */
Thierry Reding8d388212014-08-01 14:15:10 +02001355static void devm_resource_release(struct device *dev, void *ptr)
1356{
1357 struct resource **r = ptr;
1358
1359 release_resource(*r);
1360}
1361
1362/**
1363 * devm_request_resource() - request and reserve an I/O or memory resource
1364 * @dev: device for which to request the resource
1365 * @root: root of the resource tree from which to request the resource
1366 * @new: descriptor of the resource to request
1367 *
1368 * This is a device-managed version of request_resource(). There is usually
1369 * no need to release resources requested by this function explicitly since
1370 * that will be taken care of when the device is unbound from its driver.
1371 * If for some reason the resource needs to be released explicitly, because
1372 * of ordering issues for example, drivers must call devm_release_resource()
1373 * rather than the regular release_resource().
1374 *
1375 * When a conflict is detected between any existing resources and the newly
1376 * requested resource, an error message will be printed.
1377 *
1378 * Returns 0 on success or a negative error code on failure.
1379 */
1380int devm_request_resource(struct device *dev, struct resource *root,
1381 struct resource *new)
1382{
1383 struct resource *conflict, **ptr;
1384
1385 ptr = devres_alloc(devm_resource_release, sizeof(*ptr), GFP_KERNEL);
1386 if (!ptr)
1387 return -ENOMEM;
1388
1389 *ptr = new;
1390
1391 conflict = request_resource_conflict(root, new);
1392 if (conflict) {
1393 dev_err(dev, "resource collision: %pR conflicts with %s %pR\n",
1394 new, conflict->name, conflict);
1395 devres_free(ptr);
1396 return -EBUSY;
1397 }
1398
1399 devres_add(dev, ptr);
1400 return 0;
1401}
1402EXPORT_SYMBOL(devm_request_resource);
1403
1404static int devm_resource_match(struct device *dev, void *res, void *data)
1405{
1406 struct resource **ptr = res;
1407
1408 return *ptr == data;
1409}
1410
1411/**
1412 * devm_release_resource() - release a previously requested resource
1413 * @dev: device for which to release the resource
1414 * @new: descriptor of the resource to release
1415 *
1416 * Releases a resource previously requested using devm_request_resource().
1417 */
1418void devm_release_resource(struct device *dev, struct resource *new)
1419{
1420 WARN_ON(devres_release(dev, devm_resource_release, devm_resource_match,
1421 new));
1422}
1423EXPORT_SYMBOL(devm_release_resource);
1424
Tejun Heo9ac78492007-01-20 16:00:26 +09001425struct region_devres {
1426 struct resource *parent;
1427 resource_size_t start;
1428 resource_size_t n;
1429};
1430
1431static void devm_region_release(struct device *dev, void *res)
1432{
1433 struct region_devres *this = res;
1434
1435 __release_region(this->parent, this->start, this->n);
1436}
1437
1438static int devm_region_match(struct device *dev, void *res, void *match_data)
1439{
1440 struct region_devres *this = res, *match = match_data;
1441
1442 return this->parent == match->parent &&
1443 this->start == match->start && this->n == match->n;
1444}
1445
1446struct resource * __devm_request_region(struct device *dev,
1447 struct resource *parent, resource_size_t start,
1448 resource_size_t n, const char *name)
1449{
1450 struct region_devres *dr = NULL;
1451 struct resource *res;
1452
1453 dr = devres_alloc(devm_region_release, sizeof(struct region_devres),
1454 GFP_KERNEL);
1455 if (!dr)
1456 return NULL;
1457
1458 dr->parent = parent;
1459 dr->start = start;
1460 dr->n = n;
1461
Arjan van de Vene8de1482008-10-22 19:55:31 -07001462 res = __request_region(parent, start, n, name, 0);
Tejun Heo9ac78492007-01-20 16:00:26 +09001463 if (res)
1464 devres_add(dev, dr);
1465 else
1466 devres_free(dr);
1467
1468 return res;
1469}
1470EXPORT_SYMBOL(__devm_request_region);
1471
1472void __devm_release_region(struct device *dev, struct resource *parent,
1473 resource_size_t start, resource_size_t n)
1474{
1475 struct region_devres match_data = { parent, start, n };
1476
1477 __release_region(parent, start, n);
1478 WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match,
1479 &match_data));
1480}
1481EXPORT_SYMBOL(__devm_release_region);
1482
1483/*
Bjorn Helgaasffd2e8d2017-12-01 11:50:33 -06001484 * Reserve I/O ports or memory based on "reserve=" kernel parameter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 */
1486#define MAXRESERVE 4
1487static int __init reserve_setup(char *str)
1488{
1489 static int reserved;
1490 static struct resource reserve[MAXRESERVE];
1491
1492 for (;;) {
Zhang Rui8bc1ad72009-06-30 11:41:31 -07001493 unsigned int io_start, io_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 int x = reserved;
Bjorn Helgaasffd2e8d2017-12-01 11:50:33 -06001495 struct resource *parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496
Bjorn Helgaasffd2e8d2017-12-01 11:50:33 -06001497 if (get_option(&str, &io_start) != 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 break;
Bjorn Helgaasffd2e8d2017-12-01 11:50:33 -06001499 if (get_option(&str, &io_num) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 break;
1501 if (x < MAXRESERVE) {
1502 struct resource *res = reserve + x;
Bjorn Helgaasffd2e8d2017-12-01 11:50:33 -06001503
1504 /*
1505 * If the region starts below 0x10000, we assume it's
1506 * I/O port space; otherwise assume it's memory.
1507 */
1508 if (io_start < 0x10000) {
1509 res->flags = IORESOURCE_IO;
1510 parent = &ioport_resource;
1511 } else {
1512 res->flags = IORESOURCE_MEM;
1513 parent = &iomem_resource;
1514 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 res->name = "reserved";
1516 res->start = io_start;
1517 res->end = io_start + io_num - 1;
Bjorn Helgaasffd2e8d2017-12-01 11:50:33 -06001518 res->flags |= IORESOURCE_BUSY;
Toshi Kani43ee4932016-01-26 21:57:19 +01001519 res->desc = IORES_DESC_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 res->child = NULL;
Bjorn Helgaasffd2e8d2017-12-01 11:50:33 -06001521 if (request_resource(parent, res) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 reserved = x+1;
1523 }
1524 }
1525 return 1;
1526}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527__setup("reserve=", reserve_setup);
Suresh Siddha379daf62008-09-25 18:43:34 -07001528
1529/*
1530 * Check if the requested addr and size spans more than any slot in the
1531 * iomem resource tree.
1532 */
1533int iomem_map_sanity_check(resource_size_t addr, unsigned long size)
1534{
1535 struct resource *p = &iomem_resource;
1536 int err = 0;
1537 loff_t l;
1538
1539 read_lock(&resource_lock);
1540 for (p = p->child; p ; p = r_next(NULL, p, &l)) {
1541 /*
1542 * We can probably skip the resources without
1543 * IORESOURCE_IO attribute?
1544 */
1545 if (p->start >= addr + size)
1546 continue;
1547 if (p->end < addr)
1548 continue;
Suresh Siddhad68612b2008-10-28 11:45:42 -07001549 if (PFN_DOWN(p->start) <= PFN_DOWN(addr) &&
1550 PFN_DOWN(p->end) >= PFN_DOWN(addr + size - 1))
Suresh Siddha379daf62008-09-25 18:43:34 -07001551 continue;
Arjan van de Ven3ac526692008-12-13 09:15:27 -08001552 /*
1553 * if a resource is "BUSY", it's not a hardware resource
1554 * but a driver mapping of such a resource; we don't want
1555 * to warn for those; some drivers legitimately map only
1556 * partial hardware resources. (example: vesafb)
1557 */
1558 if (p->flags & IORESOURCE_BUSY)
1559 continue;
1560
Bjorn Helgaase4c72962014-04-14 15:38:11 -06001561 printk(KERN_WARNING "resource sanity check: requesting [mem %#010llx-%#010llx], which spans more than %s %pR\n",
Ingo Molnar13eb8372008-09-26 10:10:12 +02001562 (unsigned long long)addr,
1563 (unsigned long long)(addr + size - 1),
Bjorn Helgaase4c72962014-04-14 15:38:11 -06001564 p->name, p);
Suresh Siddha379daf62008-09-25 18:43:34 -07001565 err = -1;
1566 break;
1567 }
1568 read_unlock(&resource_lock);
1569
1570 return err;
1571}
Arjan van de Vene8de1482008-10-22 19:55:31 -07001572
1573#ifdef CONFIG_STRICT_DEVMEM
1574static int strict_iomem_checks = 1;
1575#else
1576static int strict_iomem_checks;
1577#endif
1578
1579/*
1580 * check if an address is reserved in the iomem resource tree
Yaowei Bai9825b452018-02-06 15:41:28 -08001581 * returns true if reserved, false if not reserved.
Arjan van de Vene8de1482008-10-22 19:55:31 -07001582 */
Yaowei Bai9825b452018-02-06 15:41:28 -08001583bool iomem_is_exclusive(u64 addr)
Arjan van de Vene8de1482008-10-22 19:55:31 -07001584{
1585 struct resource *p = &iomem_resource;
Yaowei Bai9825b452018-02-06 15:41:28 -08001586 bool err = false;
Arjan van de Vene8de1482008-10-22 19:55:31 -07001587 loff_t l;
1588 int size = PAGE_SIZE;
1589
1590 if (!strict_iomem_checks)
Yaowei Bai9825b452018-02-06 15:41:28 -08001591 return false;
Arjan van de Vene8de1482008-10-22 19:55:31 -07001592
1593 addr = addr & PAGE_MASK;
1594
1595 read_lock(&resource_lock);
1596 for (p = p->child; p ; p = r_next(NULL, p, &l)) {
1597 /*
1598 * We can probably skip the resources without
1599 * IORESOURCE_IO attribute?
1600 */
1601 if (p->start >= addr + size)
1602 break;
1603 if (p->end < addr)
1604 continue;
Dan Williams90a545e2015-11-23 15:49:03 -08001605 /*
1606 * A resource is exclusive if IORESOURCE_EXCLUSIVE is set
1607 * or CONFIG_IO_STRICT_DEVMEM is enabled and the
1608 * resource is busy.
1609 */
1610 if ((p->flags & IORESOURCE_BUSY) == 0)
1611 continue;
1612 if (IS_ENABLED(CONFIG_IO_STRICT_DEVMEM)
1613 || p->flags & IORESOURCE_EXCLUSIVE) {
Yaowei Bai9825b452018-02-06 15:41:28 -08001614 err = true;
Arjan van de Vene8de1482008-10-22 19:55:31 -07001615 break;
1616 }
1617 }
1618 read_unlock(&resource_lock);
1619
1620 return err;
1621}
1622
Jiang Liu90e97822015-02-05 13:44:43 +08001623struct resource_entry *resource_list_create_entry(struct resource *res,
1624 size_t extra_size)
1625{
1626 struct resource_entry *entry;
1627
1628 entry = kzalloc(sizeof(*entry) + extra_size, GFP_KERNEL);
1629 if (entry) {
1630 INIT_LIST_HEAD(&entry->node);
1631 entry->res = res ? res : &entry->__res;
1632 }
1633
1634 return entry;
1635}
1636EXPORT_SYMBOL(resource_list_create_entry);
1637
1638void resource_list_free(struct list_head *head)
1639{
1640 struct resource_entry *entry, *tmp;
1641
1642 list_for_each_entry_safe(entry, tmp, head, node)
1643 resource_list_destroy_entry(entry);
1644}
1645EXPORT_SYMBOL(resource_list_free);
1646
Arjan van de Vene8de1482008-10-22 19:55:31 -07001647static int __init strict_iomem(char *str)
1648{
1649 if (strstr(str, "relaxed"))
1650 strict_iomem_checks = 0;
1651 if (strstr(str, "strict"))
1652 strict_iomem_checks = 1;
1653 return 1;
1654}
1655
1656__setup("iomem=", strict_iomem);