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