kernel/resource.c

   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
  29 struct resource ioport_resource = {
  30         .name   = "PCI IO",
  31         .start  = 0,
  32         .end    = IO_SPACE_LIMIT,
  33         .flags  = IORESOURCE_IO,
  34 };
  35 EXPORT_SYMBOL(ioport_resource);
  36
  37 struct resource iomem_resource = {
  38         .name   = "PCI mem",
  39         .start  = 0,
  40         .end    = -1,
  41         .flags  = IORESOURCE_MEM,
  42 };
  43 EXPORT_SYMBOL(iomem_resource);
  44
  45 /* constraints to be met while allocating resources */
  46 struct 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
  53 static 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  */
  60 static struct resource *bootmem_resource_free;
  61 static DEFINE_SPINLOCK(bootmem_resource_lock);
  62
  63 static 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
  76 static 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
  85 enum { MAX_IORES_LEVEL = 5 };
  86
  87 static 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
  98 static void r_stop(struct seq_file *m, void *v)
  99         __releases(resource_lock)
 100 {
 101         read_unlock(&resource_lock);
 102 }
 103
 104 static 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
 122 static const struct seq_operations resource_op = {
 123         .start  = r_start,
 124         .next   = r_next,
 125         .stop   = r_stop,
 126         .show   = r_show,
 127 };
 128
 129 static 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
 139 static 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
 149 static 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
 156 static 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
 163 static 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
 173 static 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
 188 static 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 */
 208 static 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
 236 static 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
 255 static 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
 278 void 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  */
 292 struct 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  */
 309 int 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
 317 EXPORT_SYMBOL(request_resource);
 318
 319 /**
 320  * release_resource - release a previously reserved resource
 321  * @old: resource pointer
 322  */
 323 int 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
 333 EXPORT_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  */
 342 static 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  */
 395 int 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  */
 424 int 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  */
 453 int 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
 481 static 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  */
 489 int __weak page_is_ram(unsigned long pfn)
 490 {
 491         return walk_system_ram_range(pfn, 1, NULL, __is_ram) == 1;
 492 }
 493 EXPORT_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  */
 513 int 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
 542 void __weak arch_remove_reservations(struct resource *avail)
 543 {
 544 }
 545
 546 static 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
 554 static 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  */
 567 static 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
 612 next:           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  */
 625 static 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  */
 642 static 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         }
 675 out:
 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  */
 693 int 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
 728 EXPORT_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  */
 737 struct 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  */
 755 static 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  */
 817 struct 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  */
 834 int 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  */
 850 void 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
 876 static 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
 900 skip:
 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  */
 923 int 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 }
 933 EXPORT_SYMBOL(adjust_resource);
 934
 935 static 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
 993 void __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  */
1028 resource_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
1051 static 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  */
1061 struct 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 }
1108 EXPORT_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  */
1118 void __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 }
1157 EXPORT_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  */
1180 int 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  */
1265 static 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  */
1290 int 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 }
1312 EXPORT_SYMBOL(devm_request_resource);
1313
1314 static 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  */
1328 void 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 }
1333 EXPORT_SYMBOL(devm_release_resource);
1334
1335 struct region_devres {
1336         struct resource *parent;
1337         resource_size_t start;
1338         resource_size_t n;
1339 };
1340
1341 static 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
1348 static 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
1356 struct 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 }
1380 EXPORT_SYMBOL(__devm_request_region);
1381
1382 void __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 }
1391 EXPORT_SYMBOL(__devm_release_region);
1392
1393 /*
1394  * Called from init/main.c to reserve IO ports.
1395  */
1396 #define MAXRESERVE 4
1397 static 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  */
1430 int 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
1471 static int strict_iomem_checks = 1;
1472 #else
1473 static 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  */
1480 int 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
1513 struct 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 }
1526 EXPORT_SYMBOL(resource_list_create_entry);
1527
1528 void 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 }
1535 EXPORT_SYMBOL(resource_list_free);
1536
1537 static 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);