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 #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 <linux/pfn.h> 21 #include <asm/io.h> 22 23 24 struct resource ioport_resource = { 25 .name = "PCI IO", 26 .start = 0, 27 .end = IO_SPACE_LIMIT, 28 .flags = IORESOURCE_IO, 29 }; 30 EXPORT_SYMBOL(ioport_resource); 31 32 struct resource iomem_resource = { 33 .name = "PCI mem", 34 .start = 0, 35 .end = -1, 36 .flags = IORESOURCE_MEM, 37 }; 38 EXPORT_SYMBOL(iomem_resource); 39 40 static DEFINE_RWLOCK(resource_lock); 41 42 static void *r_next(struct seq_file *m, void *v, loff_t *pos) 43 { 44 struct resource *p = v; 45 (*pos)++; 46 if (p->child) 47 return p->child; 48 while (!p->sibling && p->parent) 49 p = p->parent; 50 return p->sibling; 51 } 52 53 #ifdef CONFIG_PROC_FS 54 55 enum { MAX_IORES_LEVEL = 5 }; 56 57 static void *r_start(struct seq_file *m, loff_t *pos) 58 __acquires(resource_lock) 59 { 60 struct resource *p = m->private; 61 loff_t l = 0; 62 read_lock(&resource_lock); 63 for (p = p->child; p && l < *pos; p = r_next(m, p, &l)) 64 ; 65 return p; 66 } 67 68 static void r_stop(struct seq_file *m, void *v) 69 __releases(resource_lock) 70 { 71 read_unlock(&resource_lock); 72 } 73 74 static int r_show(struct seq_file *m, void *v) 75 { 76 struct resource *root = m->private; 77 struct resource *r = v, *p; 78 int width = root->end < 0x10000 ? 4 : 8; 79 int depth; 80 81 for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent) 82 if (p->parent == root) 83 break; 84 seq_printf(m, "%*s%0*llx-%0*llx : %s\n", 85 depth * 2, "", 86 width, (unsigned long long) r->start, 87 width, (unsigned long long) r->end, 88 r->name ? r->name : "<BAD>"); 89 return 0; 90 } 91 92 static const struct seq_operations resource_op = { 93 .start = r_start, 94 .next = r_next, 95 .stop = r_stop, 96 .show = r_show, 97 }; 98 99 static int ioports_open(struct inode *inode, struct file *file) 100 { 101 int res = seq_open(file, &resource_op); 102 if (!res) { 103 struct seq_file *m = file->private_data; 104 m->private = &ioport_resource; 105 } 106 return res; 107 } 108 109 static int iomem_open(struct inode *inode, struct file *file) 110 { 111 int res = seq_open(file, &resource_op); 112 if (!res) { 113 struct seq_file *m = file->private_data; 114 m->private = &iomem_resource; 115 } 116 return res; 117 } 118 119 static const struct file_operations proc_ioports_operations = { 120 .open = ioports_open, 121 .read = seq_read, 122 .llseek = seq_lseek, 123 .release = seq_release, 124 }; 125 126 static const struct file_operations proc_iomem_operations = { 127 .open = iomem_open, 128 .read = seq_read, 129 .llseek = seq_lseek, 130 .release = seq_release, 131 }; 132 133 static int __init ioresources_init(void) 134 { 135 proc_create("ioports", 0, NULL, &proc_ioports_operations); 136 proc_create("iomem", 0, NULL, &proc_iomem_operations); 137 return 0; 138 } 139 __initcall(ioresources_init); 140 141 #endif /* CONFIG_PROC_FS */ 142 143 /* Return the conflict entry if you can't request it */ 144 static struct resource * __request_resource(struct resource *root, struct resource *new) 145 { 146 resource_size_t start = new->start; 147 resource_size_t end = new->end; 148 struct resource *tmp, **p; 149 150 if (end < start) 151 return root; 152 if (start < root->start) 153 return root; 154 if (end > root->end) 155 return root; 156 p = &root->child; 157 for (;;) { 158 tmp = *p; 159 if (!tmp || tmp->start > end) { 160 new->sibling = tmp; 161 *p = new; 162 new->parent = root; 163 return NULL; 164 } 165 p = &tmp->sibling; 166 if (tmp->end < start) 167 continue; 168 return tmp; 169 } 170 } 171 172 static int __release_resource(struct resource *old) 173 { 174 struct resource *tmp, **p; 175 176 p = &old->parent->child; 177 for (;;) { 178 tmp = *p; 179 if (!tmp) 180 break; 181 if (tmp == old) { 182 *p = tmp->sibling; 183 old->parent = NULL; 184 return 0; 185 } 186 p = &tmp->sibling; 187 } 188 return -EINVAL; 189 } 190 191 /** 192 * request_resource - request and reserve an I/O or memory resource 193 * @root: root resource descriptor 194 * @new: resource descriptor desired by caller 195 * 196 * Returns 0 for success, negative error code on error. 197 */ 198 int request_resource(struct resource *root, struct resource *new) 199 { 200 struct resource *conflict; 201 202 write_lock(&resource_lock); 203 conflict = __request_resource(root, new); 204 write_unlock(&resource_lock); 205 return conflict ? -EBUSY : 0; 206 } 207 208 EXPORT_SYMBOL(request_resource); 209 210 /** 211 * release_resource - release a previously reserved resource 212 * @old: resource pointer 213 */ 214 int release_resource(struct resource *old) 215 { 216 int retval; 217 218 write_lock(&resource_lock); 219 retval = __release_resource(old); 220 write_unlock(&resource_lock); 221 return retval; 222 } 223 224 EXPORT_SYMBOL(release_resource); 225 226 #if !defined(CONFIG_ARCH_HAS_WALK_MEMORY) 227 /* 228 * Finds the lowest memory reosurce exists within [res->start.res->end) 229 * the caller must specify res->start, res->end, res->flags and "name". 230 * If found, returns 0, res is overwritten, if not found, returns -1. 231 */ 232 static int find_next_system_ram(struct resource *res, char *name) 233 { 234 resource_size_t start, end; 235 struct resource *p; 236 237 BUG_ON(!res); 238 239 start = res->start; 240 end = res->end; 241 BUG_ON(start >= end); 242 243 read_lock(&resource_lock); 244 for (p = iomem_resource.child; p ; p = p->sibling) { 245 /* system ram is just marked as IORESOURCE_MEM */ 246 if (p->flags != res->flags) 247 continue; 248 if (name && strcmp(p->name, name)) 249 continue; 250 if (p->start > end) { 251 p = NULL; 252 break; 253 } 254 if ((p->end >= start) && (p->start < end)) 255 break; 256 } 257 read_unlock(&resource_lock); 258 if (!p) 259 return -1; 260 /* copy data */ 261 if (res->start < p->start) 262 res->start = p->start; 263 if (res->end > p->end) 264 res->end = p->end; 265 return 0; 266 } 267 268 /* 269 * This function calls callback against all memory range of "System RAM" 270 * which are marked as IORESOURCE_MEM and IORESOUCE_BUSY. 271 * Now, this function is only for "System RAM". 272 */ 273 int walk_system_ram_range(unsigned long start_pfn, unsigned long nr_pages, 274 void *arg, int (*func)(unsigned long, unsigned long, void *)) 275 { 276 struct resource res; 277 unsigned long pfn, len; 278 u64 orig_end; 279 int ret = -1; 280 281 res.start = (u64) start_pfn << PAGE_SHIFT; 282 res.end = ((u64)(start_pfn + nr_pages) << PAGE_SHIFT) - 1; 283 res.flags = IORESOURCE_MEM | IORESOURCE_BUSY; 284 orig_end = res.end; 285 while ((res.start < res.end) && 286 (find_next_system_ram(&res, "System RAM") >= 0)) { 287 pfn = (unsigned long)(res.start >> PAGE_SHIFT); 288 len = (unsigned long)((res.end + 1 - res.start) >> PAGE_SHIFT); 289 ret = (*func)(pfn, len, arg); 290 if (ret) 291 break; 292 res.start = res.end + 1; 293 res.end = orig_end; 294 } 295 return ret; 296 } 297 298 #endif 299 300 /* 301 * Find empty slot in the resource tree given range and alignment. 302 */ 303 static int find_resource(struct resource *root, struct resource *new, 304 resource_size_t size, resource_size_t min, 305 resource_size_t max, resource_size_t align, 306 void (*alignf)(void *, struct resource *, 307 resource_size_t, resource_size_t), 308 void *alignf_data) 309 { 310 struct resource *this = root->child; 311 struct resource tmp = *new; 312 313 tmp.start = root->start; 314 /* 315 * Skip past an allocated resource that starts at 0, since the assignment 316 * of this->start - 1 to tmp->end below would cause an underflow. 317 */ 318 if (this && this->start == 0) { 319 tmp.start = this->end + 1; 320 this = this->sibling; 321 } 322 for(;;) { 323 if (this) 324 tmp.end = this->start - 1; 325 else 326 tmp.end = root->end; 327 if (tmp.start < min) 328 tmp.start = min; 329 if (tmp.end > max) 330 tmp.end = max; 331 tmp.start = ALIGN(tmp.start, align); 332 if (alignf) 333 alignf(alignf_data, &tmp, size, align); 334 if (tmp.start < tmp.end && tmp.end - tmp.start >= size - 1) { 335 new->start = tmp.start; 336 new->end = tmp.start + size - 1; 337 return 0; 338 } 339 if (!this) 340 break; 341 tmp.start = this->end + 1; 342 this = this->sibling; 343 } 344 return -EBUSY; 345 } 346 347 /** 348 * allocate_resource - allocate empty slot in the resource tree given range & alignment 349 * @root: root resource descriptor 350 * @new: resource descriptor desired by caller 351 * @size: requested resource region size 352 * @min: minimum size to allocate 353 * @max: maximum size to allocate 354 * @align: alignment requested, in bytes 355 * @alignf: alignment function, optional, called if not NULL 356 * @alignf_data: arbitrary data to pass to the @alignf function 357 */ 358 int allocate_resource(struct resource *root, struct resource *new, 359 resource_size_t size, resource_size_t min, 360 resource_size_t max, resource_size_t align, 361 void (*alignf)(void *, struct resource *, 362 resource_size_t, resource_size_t), 363 void *alignf_data) 364 { 365 int err; 366 367 write_lock(&resource_lock); 368 err = find_resource(root, new, size, min, max, align, alignf, alignf_data); 369 if (err >= 0 && __request_resource(root, new)) 370 err = -EBUSY; 371 write_unlock(&resource_lock); 372 return err; 373 } 374 375 EXPORT_SYMBOL(allocate_resource); 376 377 /* 378 * Insert a resource into the resource tree. If successful, return NULL, 379 * otherwise return the conflicting resource (compare to __request_resource()) 380 */ 381 static struct resource * __insert_resource(struct resource *parent, struct resource *new) 382 { 383 struct resource *first, *next; 384 385 for (;; parent = first) { 386 first = __request_resource(parent, new); 387 if (!first) 388 return first; 389 390 if (first == parent) 391 return first; 392 393 if ((first->start > new->start) || (first->end < new->end)) 394 break; 395 if ((first->start == new->start) && (first->end == new->end)) 396 break; 397 } 398 399 for (next = first; ; next = next->sibling) { 400 /* Partial overlap? Bad, and unfixable */ 401 if (next->start < new->start || next->end > new->end) 402 return next; 403 if (!next->sibling) 404 break; 405 if (next->sibling->start > new->end) 406 break; 407 } 408 409 new->parent = parent; 410 new->sibling = next->sibling; 411 new->child = first; 412 413 next->sibling = NULL; 414 for (next = first; next; next = next->sibling) 415 next->parent = new; 416 417 if (parent->child == first) { 418 parent->child = new; 419 } else { 420 next = parent->child; 421 while (next->sibling != first) 422 next = next->sibling; 423 next->sibling = new; 424 } 425 return NULL; 426 } 427 428 /** 429 * insert_resource - Inserts a resource in the resource tree 430 * @parent: parent of the new resource 431 * @new: new resource to insert 432 * 433 * Returns 0 on success, -EBUSY if the resource can't be inserted. 434 * 435 * This function is equivalent to request_resource when no conflict 436 * happens. If a conflict happens, and the conflicting resources 437 * entirely fit within the range of the new resource, then the new 438 * resource is inserted and the conflicting resources become children of 439 * the new resource. 440 */ 441 int insert_resource(struct resource *parent, struct resource *new) 442 { 443 struct resource *conflict; 444 445 write_lock(&resource_lock); 446 conflict = __insert_resource(parent, new); 447 write_unlock(&resource_lock); 448 return conflict ? -EBUSY : 0; 449 } 450 451 /** 452 * insert_resource_expand_to_fit - Insert a resource into the resource tree 453 * @root: root resource descriptor 454 * @new: new resource to insert 455 * 456 * Insert a resource into the resource tree, possibly expanding it in order 457 * to make it encompass any conflicting resources. 458 */ 459 void insert_resource_expand_to_fit(struct resource *root, struct resource *new) 460 { 461 if (new->parent) 462 return; 463 464 write_lock(&resource_lock); 465 for (;;) { 466 struct resource *conflict; 467 468 conflict = __insert_resource(root, new); 469 if (!conflict) 470 break; 471 if (conflict == root) 472 break; 473 474 /* Ok, expand resource to cover the conflict, then try again .. */ 475 if (conflict->start < new->start) 476 new->start = conflict->start; 477 if (conflict->end > new->end) 478 new->end = conflict->end; 479 480 printk("Expanded resource %s due to conflict with %s\n", new->name, conflict->name); 481 } 482 write_unlock(&resource_lock); 483 } 484 485 /** 486 * adjust_resource - modify a resource's start and size 487 * @res: resource to modify 488 * @start: new start value 489 * @size: new size 490 * 491 * Given an existing resource, change its start and size to match the 492 * arguments. Returns 0 on success, -EBUSY if it can't fit. 493 * Existing children of the resource are assumed to be immutable. 494 */ 495 int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size) 496 { 497 struct resource *tmp, *parent = res->parent; 498 resource_size_t end = start + size - 1; 499 int result = -EBUSY; 500 501 write_lock(&resource_lock); 502 503 if ((start < parent->start) || (end > parent->end)) 504 goto out; 505 506 for (tmp = res->child; tmp; tmp = tmp->sibling) { 507 if ((tmp->start < start) || (tmp->end > end)) 508 goto out; 509 } 510 511 if (res->sibling && (res->sibling->start <= end)) 512 goto out; 513 514 tmp = parent->child; 515 if (tmp != res) { 516 while (tmp->sibling != res) 517 tmp = tmp->sibling; 518 if (start <= tmp->end) 519 goto out; 520 } 521 522 res->start = start; 523 res->end = end; 524 result = 0; 525 526 out: 527 write_unlock(&resource_lock); 528 return result; 529 } 530 531 static void __init __reserve_region_with_split(struct resource *root, 532 resource_size_t start, resource_size_t end, 533 const char *name) 534 { 535 struct resource *parent = root; 536 struct resource *conflict; 537 struct resource *res = kzalloc(sizeof(*res), GFP_ATOMIC); 538 539 if (!res) 540 return; 541 542 res->name = name; 543 res->start = start; 544 res->end = end; 545 res->flags = IORESOURCE_BUSY; 546 547 conflict = __request_resource(parent, res); 548 if (!conflict) 549 return; 550 551 /* failed, split and try again */ 552 kfree(res); 553 554 /* conflict covered whole area */ 555 if (conflict->start <= start && conflict->end >= end) 556 return; 557 558 if (conflict->start > start) 559 __reserve_region_with_split(root, start, conflict->start-1, name); 560 if (conflict->end < end) 561 __reserve_region_with_split(root, conflict->end+1, end, name); 562 } 563 564 void __init reserve_region_with_split(struct resource *root, 565 resource_size_t start, resource_size_t end, 566 const char *name) 567 { 568 write_lock(&resource_lock); 569 __reserve_region_with_split(root, start, end, name); 570 write_unlock(&resource_lock); 571 } 572 573 EXPORT_SYMBOL(adjust_resource); 574 575 /** 576 * resource_alignment - calculate resource's alignment 577 * @res: resource pointer 578 * 579 * Returns alignment on success, 0 (invalid alignment) on failure. 580 */ 581 resource_size_t resource_alignment(struct resource *res) 582 { 583 switch (res->flags & (IORESOURCE_SIZEALIGN | IORESOURCE_STARTALIGN)) { 584 case IORESOURCE_SIZEALIGN: 585 return resource_size(res); 586 case IORESOURCE_STARTALIGN: 587 return res->start; 588 default: 589 return 0; 590 } 591 } 592 593 /* 594 * This is compatibility stuff for IO resources. 595 * 596 * Note how this, unlike the above, knows about 597 * the IO flag meanings (busy etc). 598 * 599 * request_region creates a new busy region. 600 * 601 * check_region returns non-zero if the area is already busy. 602 * 603 * release_region releases a matching busy region. 604 */ 605 606 /** 607 * __request_region - create a new busy resource region 608 * @parent: parent resource descriptor 609 * @start: resource start address 610 * @n: resource region size 611 * @name: reserving caller's ID string 612 * @flags: IO resource flags 613 */ 614 struct resource * __request_region(struct resource *parent, 615 resource_size_t start, resource_size_t n, 616 const char *name, int flags) 617 { 618 struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL); 619 620 if (!res) 621 return NULL; 622 623 res->name = name; 624 res->start = start; 625 res->end = start + n - 1; 626 res->flags = IORESOURCE_BUSY; 627 res->flags |= flags; 628 629 write_lock(&resource_lock); 630 631 for (;;) { 632 struct resource *conflict; 633 634 conflict = __request_resource(parent, res); 635 if (!conflict) 636 break; 637 if (conflict != parent) { 638 parent = conflict; 639 if (!(conflict->flags & IORESOURCE_BUSY)) 640 continue; 641 } 642 643 /* Uhhuh, that didn't work out.. */ 644 kfree(res); 645 res = NULL; 646 break; 647 } 648 write_unlock(&resource_lock); 649 return res; 650 } 651 EXPORT_SYMBOL(__request_region); 652 653 /** 654 * __check_region - check if a resource region is busy or free 655 * @parent: parent resource descriptor 656 * @start: resource start address 657 * @n: resource region size 658 * 659 * Returns 0 if the region is free at the moment it is checked, 660 * returns %-EBUSY if the region is busy. 661 * 662 * NOTE: 663 * This function is deprecated because its use is racy. 664 * Even if it returns 0, a subsequent call to request_region() 665 * may fail because another driver etc. just allocated the region. 666 * Do NOT use it. It will be removed from the kernel. 667 */ 668 int __check_region(struct resource *parent, resource_size_t start, 669 resource_size_t n) 670 { 671 struct resource * res; 672 673 res = __request_region(parent, start, n, "check-region", 0); 674 if (!res) 675 return -EBUSY; 676 677 release_resource(res); 678 kfree(res); 679 return 0; 680 } 681 EXPORT_SYMBOL(__check_region); 682 683 /** 684 * __release_region - release a previously reserved resource region 685 * @parent: parent resource descriptor 686 * @start: resource start address 687 * @n: resource region size 688 * 689 * The described resource region must match a currently busy region. 690 */ 691 void __release_region(struct resource *parent, resource_size_t start, 692 resource_size_t n) 693 { 694 struct resource **p; 695 resource_size_t end; 696 697 p = &parent->child; 698 end = start + n - 1; 699 700 write_lock(&resource_lock); 701 702 for (;;) { 703 struct resource *res = *p; 704 705 if (!res) 706 break; 707 if (res->start <= start && res->end >= end) { 708 if (!(res->flags & IORESOURCE_BUSY)) { 709 p = &res->child; 710 continue; 711 } 712 if (res->start != start || res->end != end) 713 break; 714 *p = res->sibling; 715 write_unlock(&resource_lock); 716 kfree(res); 717 return; 718 } 719 p = &res->sibling; 720 } 721 722 write_unlock(&resource_lock); 723 724 printk(KERN_WARNING "Trying to free nonexistent resource " 725 "<%016llx-%016llx>\n", (unsigned long long)start, 726 (unsigned long long)end); 727 } 728 EXPORT_SYMBOL(__release_region); 729 730 /* 731 * Managed region resource 732 */ 733 struct region_devres { 734 struct resource *parent; 735 resource_size_t start; 736 resource_size_t n; 737 }; 738 739 static void devm_region_release(struct device *dev, void *res) 740 { 741 struct region_devres *this = res; 742 743 __release_region(this->parent, this->start, this->n); 744 } 745 746 static int devm_region_match(struct device *dev, void *res, void *match_data) 747 { 748 struct region_devres *this = res, *match = match_data; 749 750 return this->parent == match->parent && 751 this->start == match->start && this->n == match->n; 752 } 753 754 struct resource * __devm_request_region(struct device *dev, 755 struct resource *parent, resource_size_t start, 756 resource_size_t n, const char *name) 757 { 758 struct region_devres *dr = NULL; 759 struct resource *res; 760 761 dr = devres_alloc(devm_region_release, sizeof(struct region_devres), 762 GFP_KERNEL); 763 if (!dr) 764 return NULL; 765 766 dr->parent = parent; 767 dr->start = start; 768 dr->n = n; 769 770 res = __request_region(parent, start, n, name, 0); 771 if (res) 772 devres_add(dev, dr); 773 else 774 devres_free(dr); 775 776 return res; 777 } 778 EXPORT_SYMBOL(__devm_request_region); 779 780 void __devm_release_region(struct device *dev, struct resource *parent, 781 resource_size_t start, resource_size_t n) 782 { 783 struct region_devres match_data = { parent, start, n }; 784 785 __release_region(parent, start, n); 786 WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match, 787 &match_data)); 788 } 789 EXPORT_SYMBOL(__devm_release_region); 790 791 /* 792 * Called from init/main.c to reserve IO ports. 793 */ 794 #define MAXRESERVE 4 795 static int __init reserve_setup(char *str) 796 { 797 static int reserved; 798 static struct resource reserve[MAXRESERVE]; 799 800 for (;;) { 801 unsigned int io_start, io_num; 802 int x = reserved; 803 804 if (get_option (&str, &io_start) != 2) 805 break; 806 if (get_option (&str, &io_num) == 0) 807 break; 808 if (x < MAXRESERVE) { 809 struct resource *res = reserve + x; 810 res->name = "reserved"; 811 res->start = io_start; 812 res->end = io_start + io_num - 1; 813 res->flags = IORESOURCE_BUSY; 814 res->child = NULL; 815 if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0) 816 reserved = x+1; 817 } 818 } 819 return 1; 820 } 821 822 __setup("reserve=", reserve_setup); 823 824 /* 825 * Check if the requested addr and size spans more than any slot in the 826 * iomem resource tree. 827 */ 828 int iomem_map_sanity_check(resource_size_t addr, unsigned long size) 829 { 830 struct resource *p = &iomem_resource; 831 int err = 0; 832 loff_t l; 833 834 read_lock(&resource_lock); 835 for (p = p->child; p ; p = r_next(NULL, p, &l)) { 836 /* 837 * We can probably skip the resources without 838 * IORESOURCE_IO attribute? 839 */ 840 if (p->start >= addr + size) 841 continue; 842 if (p->end < addr) 843 continue; 844 if (PFN_DOWN(p->start) <= PFN_DOWN(addr) && 845 PFN_DOWN(p->end) >= PFN_DOWN(addr + size - 1)) 846 continue; 847 /* 848 * if a resource is "BUSY", it's not a hardware resource 849 * but a driver mapping of such a resource; we don't want 850 * to warn for those; some drivers legitimately map only 851 * partial hardware resources. (example: vesafb) 852 */ 853 if (p->flags & IORESOURCE_BUSY) 854 continue; 855 856 printk(KERN_WARNING "resource map sanity check conflict: " 857 "0x%llx 0x%llx 0x%llx 0x%llx %s\n", 858 (unsigned long long)addr, 859 (unsigned long long)(addr + size - 1), 860 (unsigned long long)p->start, 861 (unsigned long long)p->end, 862 p->name); 863 err = -1; 864 break; 865 } 866 read_unlock(&resource_lock); 867 868 return err; 869 } 870 871 #ifdef CONFIG_STRICT_DEVMEM 872 static int strict_iomem_checks = 1; 873 #else 874 static int strict_iomem_checks; 875 #endif 876 877 /* 878 * check if an address is reserved in the iomem resource tree 879 * returns 1 if reserved, 0 if not reserved. 880 */ 881 int iomem_is_exclusive(u64 addr) 882 { 883 struct resource *p = &iomem_resource; 884 int err = 0; 885 loff_t l; 886 int size = PAGE_SIZE; 887 888 if (!strict_iomem_checks) 889 return 0; 890 891 addr = addr & PAGE_MASK; 892 893 read_lock(&resource_lock); 894 for (p = p->child; p ; p = r_next(NULL, p, &l)) { 895 /* 896 * We can probably skip the resources without 897 * IORESOURCE_IO attribute? 898 */ 899 if (p->start >= addr + size) 900 break; 901 if (p->end < addr) 902 continue; 903 if (p->flags & IORESOURCE_BUSY && 904 p->flags & IORESOURCE_EXCLUSIVE) { 905 err = 1; 906 break; 907 } 908 } 909 read_unlock(&resource_lock); 910 911 return err; 912 } 913 914 static int __init strict_iomem(char *str) 915 { 916 if (strstr(str, "relaxed")) 917 strict_iomem_checks = 0; 918 if (strstr(str, "strict")) 919 strict_iomem_checks = 1; 920 return 1; 921 } 922 923 __setup("iomem=", strict_iomem); 924