projects/linux·blob v2.6.22-rc4 · refs

691 lines · 15.4 KiB

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
10#include <linux/module.h>
11#include <linux/errno.h>
12#include <linux/ioport.h>
13#include <linux/init.h>
14#include <linux/slab.h>
15#include <linux/spinlock.h>
16#include <linux/fs.h>
17#include <linux/proc_fs.h>
18#include <linux/seq_file.h>
19#include <linux/device.h>
20#include <asm/io.h>
21
22
23struct resource ioport_resource = {
24 .name = "PCI IO",
25 .start = 0,
26 .end = IO_SPACE_LIMIT,
27 .flags = IORESOURCE_IO,
28};
29EXPORT_SYMBOL(ioport_resource);
30
31struct resource iomem_resource = {
32 .name = "PCI mem",
33 .start = 0,
34 .end = -1,
35 .flags = IORESOURCE_MEM,
36};
37EXPORT_SYMBOL(iomem_resource);
38
39static DEFINE_RWLOCK(resource_lock);
40
41#ifdef CONFIG_PROC_FS
42
43enum { MAX_IORES_LEVEL = 5 };
44
45static void *r_next(struct seq_file *m, void *v, loff_t *pos)
46{
47 struct resource *p = v;
48 (*pos)++;
49 if (p->child)
50 return p->child;
51 while (!p->sibling && p->parent)
52 p = p->parent;
53 return p->sibling;
54}
55
56static void *r_start(struct seq_file *m, loff_t *pos)
57 __acquires(resource_lock)
58{
59 struct resource *p = m->private;
60 loff_t l = 0;
61 read_lock(&resource_lock);
62 for (p = p->child; p && l < *pos; p = r_next(m, p, &l))
63 ;
64 return p;
65}
66
67static void r_stop(struct seq_file *m, void *v)
68 __releases(resource_lock)
69{
70 read_unlock(&resource_lock);
71}
72
73static int r_show(struct seq_file *m, void *v)
74{
75 struct resource *root = m->private;
76 struct resource *r = v, *p;
77 int width = root->end < 0x10000 ? 4 : 8;
78 int depth;
79
80 for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)
81 if (p->parent == root)
82 break;
83 seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
84 depth * 2, "",
85 width, (unsigned long long) r->start,
86 width, (unsigned long long) r->end,
87 r->name ? r->name : "<BAD>");
88 return 0;
89}
90
91static const struct seq_operations resource_op = {
92 .start = r_start,
93 .next = r_next,
94 .stop = r_stop,
95 .show = r_show,
96};
97
98static int ioports_open(struct inode *inode, struct file *file)
99{
100 int res = seq_open(file, &resource_op);
101 if (!res) {
102 struct seq_file *m = file->private_data;
103 m->private = &ioport_resource;
104 }
105 return res;
106}
107
108static int iomem_open(struct inode *inode, struct file *file)
109{
110 int res = seq_open(file, &resource_op);
111 if (!res) {
112 struct seq_file *m = file->private_data;
113 m->private = &iomem_resource;
114 }
115 return res;
116}
117
118static const struct file_operations proc_ioports_operations = {
119 .open = ioports_open,
120 .read = seq_read,
121 .llseek = seq_lseek,
122 .release = seq_release,
123};
124
125static const struct file_operations proc_iomem_operations = {
126 .open = iomem_open,
127 .read = seq_read,
128 .llseek = seq_lseek,
129 .release = seq_release,
130};
131
132static int __init ioresources_init(void)
133{
134 struct proc_dir_entry *entry;
135
136 entry = create_proc_entry("ioports", 0, NULL);
137 if (entry)
138 entry->proc_fops = &proc_ioports_operations;
139 entry = create_proc_entry("iomem", 0, NULL);
140 if (entry)
141 entry->proc_fops = &proc_iomem_operations;
142 return 0;
143}
144__initcall(ioresources_init);
145
146#endif /* CONFIG_PROC_FS */
147
148/* Return the conflict entry if you can't request it */
149static struct resource * __request_resource(struct resource *root, struct resource *new)
150{
151 resource_size_t start = new->start;
152 resource_size_t end = new->end;
153 struct resource *tmp, **p;
154
155 if (end < start)
156 return root;
157 if (start < root->start)
158 return root;
159 if (end > root->end)
160 return root;
161 p = &root->child;
162 for (;;) {
163 tmp = *p;
164 if (!tmp || tmp->start > end) {
165 new->sibling = tmp;
166 *p = new;
167 new->parent = root;
168 return NULL;
169 }
170 p = &tmp->sibling;
171 if (tmp->end < start)
172 continue;
173 return tmp;
174 }
175}
176
177static int __release_resource(struct resource *old)
178{
179 struct resource *tmp, **p;
180
181 p = &old->parent->child;
182 for (;;) {
183 tmp = *p;
184 if (!tmp)
185 break;
186 if (tmp == old) {
187 *p = tmp->sibling;
188 old->parent = NULL;
189 return 0;
190 }
191 p = &tmp->sibling;
192 }
193 return -EINVAL;
194}
195
196/**
197 * request_resource - request and reserve an I/O or memory resource
198 * @root: root resource descriptor
199 * @new: resource descriptor desired by caller
200 *
201 * Returns 0 for success, negative error code on error.
202 */
203int request_resource(struct resource *root, struct resource *new)
204{
205 struct resource *conflict;
206
207 write_lock(&resource_lock);
208 conflict = __request_resource(root, new);
209 write_unlock(&resource_lock);
210 return conflict ? -EBUSY : 0;
211}
212
213EXPORT_SYMBOL(request_resource);
214
215/**
216 * release_resource - release a previously reserved resource
217 * @old: resource pointer
218 */
219int release_resource(struct resource *old)
220{
221 int retval;
222
223 write_lock(&resource_lock);
224 retval = __release_resource(old);
225 write_unlock(&resource_lock);
226 return retval;
227}
228
229EXPORT_SYMBOL(release_resource);
230
231#ifdef CONFIG_MEMORY_HOTPLUG
232/*
233 * Finds the lowest memory reosurce exists within [res->start.res->end)
234 * the caller must specify res->start, res->end, res->flags.
235 * If found, returns 0, res is overwritten, if not found, returns -1.
236 */
237int find_next_system_ram(struct resource *res)
238{
239 resource_size_t start, end;
240 struct resource *p;
241
242 BUG_ON(!res);
243
244 start = res->start;
245 end = res->end;
246 BUG_ON(start >= end);
247
248 read_lock(&resource_lock);
249 for (p = iomem_resource.child; p ; p = p->sibling) {
250 /* system ram is just marked as IORESOURCE_MEM */
251 if (p->flags != res->flags)
252 continue;
253 if (p->start > end) {
254 p = NULL;
255 break;
256 }
257 if ((p->end >= start) && (p->start < end))
258 break;
259 }
260 read_unlock(&resource_lock);
261 if (!p)
262 return -1;
263 /* copy data */
264 if (res->start < p->start)
265 res->start = p->start;
266 if (res->end > p->end)
267 res->end = p->end;
268 return 0;
269}
270#endif
271
272/*
273 * Find empty slot in the resource tree given range and alignment.
274 */
275static int find_resource(struct resource *root, struct resource *new,
276 resource_size_t size, resource_size_t min,
277 resource_size_t max, resource_size_t align,
278 void (*alignf)(void *, struct resource *,
279 resource_size_t, resource_size_t),
280 void *alignf_data)
281{
282 struct resource *this = root->child;
283
284 new->start = root->start;
285 /*
286 * Skip past an allocated resource that starts at 0, since the assignment
287 * of this->start - 1 to new->end below would cause an underflow.
288 */
289 if (this && this->start == 0) {
290 new->start = this->end + 1;
291 this = this->sibling;
292 }
293 for(;;) {
294 if (this)
295 new->end = this->start - 1;
296 else
297 new->end = root->end;
298 if (new->start < min)
299 new->start = min;
300 if (new->end > max)
301 new->end = max;
302 new->start = ALIGN(new->start, align);
303 if (alignf)
304 alignf(alignf_data, new, size, align);
305 if (new->start < new->end && new->end - new->start >= size - 1) {
306 new->end = new->start + size - 1;
307 return 0;
308 }
309 if (!this)
310 break;
311 new->start = this->end + 1;
312 this = this->sibling;
313 }
314 return -EBUSY;
315}
316
317/**
318 * allocate_resource - allocate empty slot in the resource tree given range & alignment
319 * @root: root resource descriptor
320 * @new: resource descriptor desired by caller
321 * @size: requested resource region size
322 * @min: minimum size to allocate
323 * @max: maximum size to allocate
324 * @align: alignment requested, in bytes
325 * @alignf: alignment function, optional, called if not NULL
326 * @alignf_data: arbitrary data to pass to the @alignf function
327 */
328int allocate_resource(struct resource *root, struct resource *new,
329 resource_size_t size, resource_size_t min,
330 resource_size_t max, resource_size_t align,
331 void (*alignf)(void *, struct resource *,
332 resource_size_t, resource_size_t),
333 void *alignf_data)
334{
335 int err;
336
337 write_lock(&resource_lock);
338 err = find_resource(root, new, size, min, max, align, alignf, alignf_data);
339 if (err >= 0 && __request_resource(root, new))
340 err = -EBUSY;
341 write_unlock(&resource_lock);
342 return err;
343}
344
345EXPORT_SYMBOL(allocate_resource);
346
347/**
348 * insert_resource - Inserts a resource in the resource tree
349 * @parent: parent of the new resource
350 * @new: new resource to insert
351 *
352 * Returns 0 on success, -EBUSY if the resource can't be inserted.
353 *
354 * This function is equivalent to request_resource when no conflict
355 * happens. If a conflict happens, and the conflicting resources
356 * entirely fit within the range of the new resource, then the new
357 * resource is inserted and the conflicting resources become children of
358 * the new resource.
359 */
360int insert_resource(struct resource *parent, struct resource *new)
361{
362 int result;
363 struct resource *first, *next;
364
365 write_lock(&resource_lock);
366
367 for (;; parent = first) {
368 result = 0;
369 first = __request_resource(parent, new);
370 if (!first)
371 goto out;
372
373 result = -EBUSY;
374 if (first == parent)
375 goto out;
376
377 if ((first->start > new->start) || (first->end < new->end))
378 break;
379 if ((first->start == new->start) && (first->end == new->end))
380 break;
381 }
382
383 for (next = first; ; next = next->sibling) {
384 /* Partial overlap? Bad, and unfixable */
385 if (next->start < new->start || next->end > new->end)
386 goto out;
387 if (!next->sibling)
388 break;
389 if (next->sibling->start > new->end)
390 break;
391 }
392
393 result = 0;
394
395 new->parent = parent;
396 new->sibling = next->sibling;
397 new->child = first;
398
399 next->sibling = NULL;
400 for (next = first; next; next = next->sibling)
401 next->parent = new;
402
403 if (parent->child == first) {
404 parent->child = new;
405 } else {
406 next = parent->child;
407 while (next->sibling != first)
408 next = next->sibling;
409 next->sibling = new;
410 }
411
412 out:
413 write_unlock(&resource_lock);
414 return result;
415}
416
417/**
418 * adjust_resource - modify a resource's start and size
419 * @res: resource to modify
420 * @start: new start value
421 * @size: new size
422 *
423 * Given an existing resource, change its start and size to match the
424 * arguments. Returns 0 on success, -EBUSY if it can't fit.
425 * Existing children of the resource are assumed to be immutable.
426 */
427int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size)
428{
429 struct resource *tmp, *parent = res->parent;
430 resource_size_t end = start + size - 1;
431 int result = -EBUSY;
432
433 write_lock(&resource_lock);
434
435 if ((start < parent->start) || (end > parent->end))
436 goto out;
437
438 for (tmp = res->child; tmp; tmp = tmp->sibling) {
439 if ((tmp->start < start) || (tmp->end > end))
440 goto out;
441 }
442
443 if (res->sibling && (res->sibling->start <= end))
444 goto out;
445
446 tmp = parent->child;
447 if (tmp != res) {
448 while (tmp->sibling != res)
449 tmp = tmp->sibling;
450 if (start <= tmp->end)
451 goto out;
452 }
453
454 res->start = start;
455 res->end = end;
456 result = 0;
457
458 out:
459 write_unlock(&resource_lock);
460 return result;
461}
462
463EXPORT_SYMBOL(adjust_resource);
464
465/*
466 * This is compatibility stuff for IO resources.
467 *
468 * Note how this, unlike the above, knows about
469 * the IO flag meanings (busy etc).
470 *
471 * request_region creates a new busy region.
472 *
473 * check_region returns non-zero if the area is already busy.
474 *
475 * release_region releases a matching busy region.
476 */
477
478/**
479 * __request_region - create a new busy resource region
480 * @parent: parent resource descriptor
481 * @start: resource start address
482 * @n: resource region size
483 * @name: reserving caller's ID string
484 */
485struct resource * __request_region(struct resource *parent,
486 resource_size_t start, resource_size_t n,
487 const char *name)
488{
489 struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
490
491 if (res) {
492 res->name = name;
493 res->start = start;
494 res->end = start + n - 1;
495 res->flags = IORESOURCE_BUSY;
496
497 write_lock(&resource_lock);
498
499 for (;;) {
500 struct resource *conflict;
501
502 conflict = __request_resource(parent, res);
503 if (!conflict)
504 break;
505 if (conflict != parent) {
506 parent = conflict;
507 if (!(conflict->flags & IORESOURCE_BUSY))
508 continue;
509 }
510
511 /* Uhhuh, that didn't work out.. */
512 kfree(res);
513 res = NULL;
514 break;
515 }
516 write_unlock(&resource_lock);
517 }
518 return res;
519}
520EXPORT_SYMBOL(__request_region);
521
522/**
523 * __check_region - check if a resource region is busy or free
524 * @parent: parent resource descriptor
525 * @start: resource start address
526 * @n: resource region size
527 *
528 * Returns 0 if the region is free at the moment it is checked,
529 * returns %-EBUSY if the region is busy.
530 *
531 * NOTE:
532 * This function is deprecated because its use is racy.
533 * Even if it returns 0, a subsequent call to request_region()
534 * may fail because another driver etc. just allocated the region.
535 * Do NOT use it. It will be removed from the kernel.
536 */
537int __check_region(struct resource *parent, resource_size_t start,
538 resource_size_t n)
539{
540 struct resource * res;
541
542 res = __request_region(parent, start, n, "check-region");
543 if (!res)
544 return -EBUSY;
545
546 release_resource(res);
547 kfree(res);
548 return 0;
549}
550EXPORT_SYMBOL(__check_region);
551
552/**
553 * __release_region - release a previously reserved resource region
554 * @parent: parent resource descriptor
555 * @start: resource start address
556 * @n: resource region size
557 *
558 * The described resource region must match a currently busy region.
559 */
560void __release_region(struct resource *parent, resource_size_t start,
561 resource_size_t n)
562{
563 struct resource **p;
564 resource_size_t end;
565
566 p = &parent->child;
567 end = start + n - 1;
568
569 write_lock(&resource_lock);
570
571 for (;;) {
572 struct resource *res = *p;
573
574 if (!res)
575 break;
576 if (res->start <= start && res->end >= end) {
577 if (!(res->flags & IORESOURCE_BUSY)) {
578 p = &res->child;
579 continue;
580 }
581 if (res->start != start || res->end != end)
582 break;
583 *p = res->sibling;
584 write_unlock(&resource_lock);
585 kfree(res);
586 return;
587 }
588 p = &res->sibling;
589 }
590
591 write_unlock(&resource_lock);
592
593 printk(KERN_WARNING "Trying to free nonexistent resource "
594 "<%016llx-%016llx>\n", (unsigned long long)start,
595 (unsigned long long)end);
596}
597EXPORT_SYMBOL(__release_region);
598
599/*
600 * Managed region resource
601 */
602struct region_devres {
603 struct resource *parent;
604 resource_size_t start;
605 resource_size_t n;
606};
607
608static void devm_region_release(struct device *dev, void *res)
609{
610 struct region_devres *this = res;
611
612 __release_region(this->parent, this->start, this->n);
613}
614
615static int devm_region_match(struct device *dev, void *res, void *match_data)
616{
617 struct region_devres *this = res, *match = match_data;
618
619 return this->parent == match->parent &&
620 this->start == match->start && this->n == match->n;
621}
622
623struct resource * __devm_request_region(struct device *dev,
624 struct resource *parent, resource_size_t start,
625 resource_size_t n, const char *name)
626{
627 struct region_devres *dr = NULL;
628 struct resource *res;
629
630 dr = devres_alloc(devm_region_release, sizeof(struct region_devres),
631 GFP_KERNEL);
632 if (!dr)
633 return NULL;
634
635 dr->parent = parent;
636 dr->start = start;
637 dr->n = n;
638
639 res = __request_region(parent, start, n, name);
640 if (res)
641 devres_add(dev, dr);
642 else
643 devres_free(dr);
644
645 return res;
646}
647EXPORT_SYMBOL(__devm_request_region);
648
649void __devm_release_region(struct device *dev, struct resource *parent,
650 resource_size_t start, resource_size_t n)
651{
652 struct region_devres match_data = { parent, start, n };
653
654 __release_region(parent, start, n);
655 WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match,
656 &match_data));
657}
658EXPORT_SYMBOL(__devm_release_region);
659
660/*
661 * Called from init/main.c to reserve IO ports.
662 */
663#define MAXRESERVE 4
664static int __init reserve_setup(char *str)
665{
666 static int reserved;
667 static struct resource reserve[MAXRESERVE];
668
669 for (;;) {
670 int io_start, io_num;
671 int x = reserved;
672
673 if (get_option (&str, &io_start) != 2)
674 break;
675 if (get_option (&str, &io_num) == 0)
676 break;
677 if (x < MAXRESERVE) {
678 struct resource *res = reserve + x;
679 res->name = "reserved";
680 res->start = io_start;
681 res->end = io_start + io_num - 1;
682 res->flags = IORESOURCE_BUSY;
683 res->child = NULL;
684 if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0)
685 reserved = x+1;
686 }
687 }
688 return 1;
689}
690
691__setup("reserve=", reserve_setup);