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