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