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) != 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 &&
 523                                 ((p->flags & flags) == flags);
 524
 525                 if (start >= p->start && start <= p->end)
 526                         is_type ? type++ : other++;
 527                 if (end >= p->start && end <= p->end)
 528                         is_type ? type++ : other++;
 529                 if (p->start >= start && p->end <= end)
 530                         is_type ? type++ : other++;
 531         }
 532         read_unlock(&resource_lock);
 533
 534         if (other == 0)
 535                 return type ? REGION_INTERSECTS : REGION_DISJOINT;
 536
 537         if (type)
 538                 return REGION_MIXED;
 539
 540         return REGION_DISJOINT;
 541 }
 542
 543 void __weak arch_remove_reservations(struct resource *avail)
 544 {
 545 }
 546
 547 static resource_size_t simple_align_resource(void *data,
 548                                              const struct resource *avail,
 549                                              resource_size_t size,
 550                                              resource_size_t align)
 551 {
 552         return avail->start;
 553 }
 554
 555 static void resource_clip(struct resource *res, resource_size_t min,
 556                           resource_size_t max)
 557 {
 558         if (res->start < min)
 559                 res->start = min;
 560         if (res->end > max)
 561                 res->end = max;
 562 }
 563
 564 /*
 565  * Find empty slot in the resource tree with the given range and
 566  * alignment constraints
 567  */
 568 static int __find_resource(struct resource *root, struct resource *old,
 569                          struct resource *new,
 570                          resource_size_t  size,
 571                          struct resource_constraint *constraint)
 572 {
 573         struct resource *this = root->child;
 574         struct resource tmp = *new, avail, alloc;
 575
 576         tmp.start = root->start;
 577         /*
 578          * Skip past an allocated resource that starts at 0, since the assignment
 579          * of this->start - 1 to tmp->end below would cause an underflow.
 580          */
 581         if (this && this->start == root->start) {
 582                 tmp.start = (this == old) ? old->start : this->end + 1;
 583                 this = this->sibling;
 584         }
 585         for(;;) {
 586                 if (this)
 587                         tmp.end = (this == old) ?  this->end : this->start - 1;
 588                 else
 589                         tmp.end = root->end;
 590
 591                 if (tmp.end < tmp.start)
 592                         goto next;
 593
 594                 resource_clip(&tmp, constraint->min, constraint->max);
 595                 arch_remove_reservations(&tmp);
 596
 597                 /* Check for overflow after ALIGN() */
 598                 avail.start = ALIGN(tmp.start, constraint->align);
 599                 avail.end = tmp.end;
 600                 avail.flags = new->flags & ~IORESOURCE_UNSET;
 601                 if (avail.start >= tmp.start) {
 602                         alloc.flags = avail.flags;
 603                         alloc.start = constraint->alignf(constraint->alignf_data, &avail,
 604                                         size, constraint->align);
 605                         alloc.end = alloc.start + size - 1;
 606                         if (resource_contains(&avail, &alloc)) {
 607                                 new->start = alloc.start;
 608                                 new->end = alloc.end;
 609                                 return 0;
 610                         }
 611                 }
 612
 613 next:           if (!this || this->end == root->end)
 614                         break;
 615
 616                 if (this != old)
 617                         tmp.start = this->end + 1;
 618                 this = this->sibling;
 619         }
 620         return -EBUSY;
 621 }
 622
 623 /*
 624  * Find empty slot in the resource tree given range and alignment.
 625  */
 626 static int find_resource(struct resource *root, struct resource *new,
 627                         resource_size_t size,
 628                         struct resource_constraint  *constraint)
 629 {
 630         return  __find_resource(root, NULL, new, size, constraint);
 631 }
 632
 633 /**
 634  * reallocate_resource - allocate a slot in the resource tree given range & alignment.
 635  *      The resource will be relocated if the new size cannot be reallocated in the
 636  *      current location.
 637  *
 638  * @root: root resource descriptor
 639  * @old:  resource descriptor desired by caller
 640  * @newsize: new size of the resource descriptor
 641  * @constraint: the size and alignment constraints to be met.
 642  */
 643 static int reallocate_resource(struct resource *root, struct resource *old,
 644                         resource_size_t newsize,
 645                         struct resource_constraint  *constraint)
 646 {
 647         int err=0;
 648         struct resource new = *old;
 649         struct resource *conflict;
 650
 651         write_lock(&resource_lock);
 652
 653         if ((err = __find_resource(root, old, &new, newsize, constraint)))
 654                 goto out;
 655
 656         if (resource_contains(&new, old)) {
 657                 old->start = new.start;
 658                 old->end = new.end;
 659                 goto out;
 660         }
 661
 662         if (old->child) {
 663                 err = -EBUSY;
 664                 goto out;
 665         }
 666
 667         if (resource_contains(old, &new)) {
 668                 old->start = new.start;
 669                 old->end = new.end;
 670         } else {
 671                 __release_resource(old);
 672                 *old = new;
 673                 conflict = __request_resource(root, old);
 674                 BUG_ON(conflict);
 675         }
 676 out:
 677         write_unlock(&resource_lock);
 678         return err;
 679 }
 680
 681
 682 /**
 683  * allocate_resource - allocate empty slot in the resource tree given range & alignment.
 684  *      The resource will be reallocated with a new size if it was already allocated
 685  * @root: root resource descriptor
 686  * @new: resource descriptor desired by caller
 687  * @size: requested resource region size
 688  * @min: minimum boundary to allocate
 689  * @max: maximum boundary to allocate
 690  * @align: alignment requested, in bytes
 691  * @alignf: alignment function, optional, called if not NULL
 692  * @alignf_data: arbitrary data to pass to the @alignf function
 693  */
 694 int allocate_resource(struct resource *root, struct resource *new,
 695                       resource_size_t size, resource_size_t min,
 696                       resource_size_t max, resource_size_t align,
 697                       resource_size_t (*alignf)(void *,
 698                                                 const struct resource *,
 699                                                 resource_size_t,
 700                                                 resource_size_t),
 701                       void *alignf_data)
 702 {
 703         int err;
 704         struct resource_constraint constraint;
 705
 706         if (!alignf)
 707                 alignf = simple_align_resource;
 708
 709         constraint.min = min;
 710         constraint.max = max;
 711         constraint.align = align;
 712         constraint.alignf = alignf;
 713         constraint.alignf_data = alignf_data;
 714
 715         if ( new->parent ) {
 716                 /* resource is already allocated, try reallocating with
 717                    the new constraints */
 718                 return reallocate_resource(root, new, size, &constraint);
 719         }
 720
 721         write_lock(&resource_lock);
 722         err = find_resource(root, new, size, &constraint);
 723         if (err >= 0 && __request_resource(root, new))
 724                 err = -EBUSY;
 725         write_unlock(&resource_lock);
 726         return err;
 727 }
 728
 729 EXPORT_SYMBOL(allocate_resource);
 730
 731 /**
 732  * lookup_resource - find an existing resource by a resource start address
 733  * @root: root resource descriptor
 734  * @start: resource start address
 735  *
 736  * Returns a pointer to the resource if found, NULL otherwise
 737  */
 738 struct resource *lookup_resource(struct resource *root, resource_size_t start)
 739 {
 740         struct resource *res;
 741
 742         read_lock(&resource_lock);
 743         for (res = root->child; res; res = res->sibling) {
 744                 if (res->start == start)
 745                         break;
 746         }
 747         read_unlock(&resource_lock);
 748
 749         return res;
 750 }
 751
 752 /*
 753  * Insert a resource into the resource tree. If successful, return NULL,
 754  * otherwise return the conflicting resource (compare to __request_resource())
 755  */
 756 static struct resource * __insert_resource(struct resource *parent, struct resource *new)
 757 {
 758         struct resource *first, *next;
 759
 760         for (;; parent = first) {
 761                 first = __request_resource(parent, new);
 762                 if (!first)
 763                         return first;
 764
 765                 if (first == parent)
 766                         return first;
 767                 if (WARN_ON(first == new))      /* duplicated insertion */
 768                         return first;
 769
 770                 if ((first->start > new->start) || (first->end < new->end))
 771                         break;
 772                 if ((first->start == new->start) && (first->end == new->end))
 773                         break;
 774         }
 775
 776         for (next = first; ; next = next->sibling) {
 777                 /* Partial overlap? Bad, and unfixable */
 778                 if (next->start < new->start || next->end > new->end)
 779                         return next;
 780                 if (!next->sibling)
 781                         break;
 782                 if (next->sibling->start > new->end)
 783                         break;
 784         }
 785
 786         new->parent = parent;
 787         new->sibling = next->sibling;
 788         new->child = first;
 789
 790         next->sibling = NULL;
 791         for (next = first; next; next = next->sibling)
 792                 next->parent = new;
 793
 794         if (parent->child == first) {
 795                 parent->child = new;
 796         } else {
 797                 next = parent->child;
 798                 while (next->sibling != first)
 799                         next = next->sibling;
 800                 next->sibling = new;
 801         }
 802         return NULL;
 803 }
 804
 805 /**
 806  * insert_resource_conflict - Inserts resource in the resource tree
 807  * @parent: parent of the new resource
 808  * @new: new resource to insert
 809  *
 810  * Returns 0 on success, conflict resource if the resource can't be inserted.
 811  *
 812  * This function is equivalent to request_resource_conflict when no conflict
 813  * happens. If a conflict happens, and the conflicting resources
 814  * entirely fit within the range of the new resource, then the new
 815  * resource is inserted and the conflicting resources become children of
 816  * the new resource.
 817  */
 818 struct resource *insert_resource_conflict(struct resource *parent, struct resource *new)
 819 {
 820         struct resource *conflict;
 821
 822         write_lock(&resource_lock);
 823         conflict = __insert_resource(parent, new);
 824         write_unlock(&resource_lock);
 825         return conflict;
 826 }
 827
 828 /**
 829  * insert_resource - Inserts a resource in the resource tree
 830  * @parent: parent of the new resource
 831  * @new: new resource to insert
 832  *
 833  * Returns 0 on success, -EBUSY if the resource can't be inserted.
 834  */
 835 int insert_resource(struct resource *parent, struct resource *new)
 836 {
 837         struct resource *conflict;
 838
 839         conflict = insert_resource_conflict(parent, new);
 840         return conflict ? -EBUSY : 0;
 841 }
 842
 843 /**
 844  * insert_resource_expand_to_fit - Insert a resource into the resource tree
 845  * @root: root resource descriptor
 846  * @new: new resource to insert
 847  *
 848  * Insert a resource into the resource tree, possibly expanding it in order
 849  * to make it encompass any conflicting resources.
 850  */
 851 void insert_resource_expand_to_fit(struct resource *root, struct resource *new)
 852 {
 853         if (new->parent)
 854                 return;
 855
 856         write_lock(&resource_lock);
 857         for (;;) {
 858                 struct resource *conflict;
 859
 860                 conflict = __insert_resource(root, new);
 861                 if (!conflict)
 862                         break;
 863                 if (conflict == root)
 864                         break;
 865
 866                 /* Ok, expand resource to cover the conflict, then try again .. */
 867                 if (conflict->start < new->start)
 868                         new->start = conflict->start;
 869                 if (conflict->end > new->end)
 870                         new->end = conflict->end;
 871
 872                 printk("Expanded resource %s due to conflict with %s\n", new->name, conflict->name);
 873         }
 874         write_unlock(&resource_lock);
 875 }
 876
 877 static int __adjust_resource(struct resource *res, resource_size_t start,
 878                                 resource_size_t size)
 879 {
 880         struct resource *tmp, *parent = res->parent;
 881         resource_size_t end = start + size - 1;
 882         int result = -EBUSY;
 883
 884         if (!parent)
 885                 goto skip;
 886
 887         if ((start < parent->start) || (end > parent->end))
 888                 goto out;
 889
 890         if (res->sibling && (res->sibling->start <= end))
 891                 goto out;
 892
 893         tmp = parent->child;
 894         if (tmp != res) {
 895                 while (tmp->sibling != res)
 896                         tmp = tmp->sibling;
 897                 if (start <= tmp->end)
 898                         goto out;
 899         }
 900
 901 skip:
 902         for (tmp = res->child; tmp; tmp = tmp->sibling)
 903                 if ((tmp->start < start) || (tmp->end > end))
 904                         goto out;
 905
 906         res->start = start;
 907         res->end = end;
 908         result = 0;
 909
 910  out:
 911         return result;
 912 }
 913
 914 /**
 915  * adjust_resource - modify a resource's start and size
 916  * @res: resource to modify
 917  * @start: new start value
 918  * @size: new size
 919  *
 920  * Given an existing resource, change its start and size to match the
 921  * arguments.  Returns 0 on success, -EBUSY if it can't fit.
 922  * Existing children of the resource are assumed to be immutable.
 923  */
 924 int adjust_resource(struct resource *res, resource_size_t start,
 925                         resource_size_t size)
 926 {
 927         int result;
 928
 929         write_lock(&resource_lock);
 930         result = __adjust_resource(res, start, size);
 931         write_unlock(&resource_lock);
 932         return result;
 933 }
 934 EXPORT_SYMBOL(adjust_resource);
 935
 936 static void __init __reserve_region_with_split(struct resource *root,
 937                 resource_size_t start, resource_size_t end,
 938                 const char *name)
 939 {
 940         struct resource *parent = root;
 941         struct resource *conflict;
 942         struct resource *res = alloc_resource(GFP_ATOMIC);
 943         struct resource *next_res = NULL;
 944
 945         if (!res)
 946                 return;
 947
 948         res->name = name;
 949         res->start = start;
 950         res->end = end;
 951         res->flags = IORESOURCE_BUSY;
 952         res->desc = IORES_DESC_NONE;
 953
 954         while (1) {
 955
 956                 conflict = __request_resource(parent, res);
 957                 if (!conflict) {
 958                         if (!next_res)
 959                                 break;
 960                         res = next_res;
 961                         next_res = NULL;
 962                         continue;
 963                 }
 964
 965                 /* conflict covered whole area */
 966                 if (conflict->start <= res->start &&
 967                                 conflict->end >= res->end) {
 968                         free_resource(res);
 969                         WARN_ON(next_res);
 970                         break;
 971                 }
 972
 973                 /* failed, split and try again */
 974                 if (conflict->start > res->start) {
 975                         end = res->end;
 976                         res->end = conflict->start - 1;
 977                         if (conflict->end < end) {
 978                                 next_res = alloc_resource(GFP_ATOMIC);
 979                                 if (!next_res) {
 980                                         free_resource(res);
 981                                         break;
 982                                 }
 983                                 next_res->name = name;
 984                                 next_res->start = conflict->end + 1;
 985                                 next_res->end = end;
 986                                 next_res->flags = IORESOURCE_BUSY;
 987                                 next_res->desc = IORES_DESC_NONE;
 988                         }
 989                 } else {
 990                         res->start = conflict->end + 1;
 991                 }
 992         }
 993
 994 }
 995
 996 void __init reserve_region_with_split(struct resource *root,
 997                 resource_size_t start, resource_size_t end,
 998                 const char *name)
 999 {
1000         int abort = 0;
1001
1002         write_lock(&resource_lock);
1003         if (root->start > start || root->end < end) {
1004                 pr_err("requested range [0x%llx-0x%llx] not in root %pr\n",
1005                        (unsigned long long)start, (unsigned long long)end,
1006                        root);
1007                 if (start > root->end || end < root->start)
1008                         abort = 1;
1009                 else {
1010                         if (end > root->end)
1011                                 end = root->end;
1012                         if (start < root->start)
1013                                 start = root->start;
1014                         pr_err("fixing request to [0x%llx-0x%llx]\n",
1015                                (unsigned long long)start,
1016                                (unsigned long long)end);
1017                 }
1018                 dump_stack();
1019         }
1020         if (!abort)
1021                 __reserve_region_with_split(root, start, end, name);
1022         write_unlock(&resource_lock);
1023 }
1024
1025 /**
1026  * resource_alignment - calculate resource's alignment
1027  * @res: resource pointer
1028  *
1029  * Returns alignment on success, 0 (invalid alignment) on failure.
1030  */
1031 resource_size_t resource_alignment(struct resource *res)
1032 {
1033         switch (res->flags & (IORESOURCE_SIZEALIGN | IORESOURCE_STARTALIGN)) {
1034         case IORESOURCE_SIZEALIGN:
1035                 return resource_size(res);
1036         case IORESOURCE_STARTALIGN:
1037                 return res->start;
1038         default:
1039                 return 0;
1040         }
1041 }
1042
1043 /*
1044  * This is compatibility stuff for IO resources.
1045  *
1046  * Note how this, unlike the above, knows about
1047  * the IO flag meanings (busy etc).
1048  *
1049  * request_region creates a new busy region.
1050  *
1051  * release_region releases a matching busy region.
1052  */
1053
1054 static DECLARE_WAIT_QUEUE_HEAD(muxed_resource_wait);
1055
1056 /**
1057  * __request_region - create a new busy resource region
1058  * @parent: parent resource descriptor
1059  * @start: resource start address
1060  * @n: resource region size
1061  * @name: reserving caller's ID string
1062  * @flags: IO resource flags
1063  */
1064 struct resource * __request_region(struct resource *parent,
1065                                    resource_size_t start, resource_size_t n,
1066                                    const char *name, int flags)
1067 {
1068         DECLARE_WAITQUEUE(wait, current);
1069         struct resource *res = alloc_resource(GFP_KERNEL);
1070
1071         if (!res)
1072                 return NULL;
1073
1074         res->name = name;
1075         res->start = start;
1076         res->end = start + n - 1;
1077         res->flags = resource_type(parent) | resource_ext_type(parent);
1078         res->flags |= IORESOURCE_BUSY | flags;
1079         res->desc = IORES_DESC_NONE;
1080
1081         write_lock(&resource_lock);
1082
1083         for (;;) {
1084                 struct resource *conflict;
1085
1086                 conflict = __request_resource(parent, res);
1087                 if (!conflict)
1088                         break;
1089                 if (conflict != parent) {
1090                         parent = conflict;
1091                         if (!(conflict->flags & IORESOURCE_BUSY))
1092                                 continue;
1093                 }
1094                 if (conflict->flags & flags & IORESOURCE_MUXED) {
1095                         add_wait_queue(&muxed_resource_wait, &wait);
1096                         write_unlock(&resource_lock);
1097                         set_current_state(TASK_UNINTERRUPTIBLE);
1098                         schedule();
1099                         remove_wait_queue(&muxed_resource_wait, &wait);
1100                         write_lock(&resource_lock);
1101                         continue;
1102                 }
1103                 /* Uhhuh, that didn't work out.. */
1104                 free_resource(res);
1105                 res = NULL;
1106                 break;
1107         }
1108         write_unlock(&resource_lock);
1109         return res;
1110 }
1111 EXPORT_SYMBOL(__request_region);
1112
1113 /**
1114  * __release_region - release a previously reserved resource region
1115  * @parent: parent resource descriptor
1116  * @start: resource start address
1117  * @n: resource region size
1118  *
1119  * The described resource region must match a currently busy region.
1120  */
1121 void __release_region(struct resource *parent, resource_size_t start,
1122                         resource_size_t n)
1123 {
1124         struct resource **p;
1125         resource_size_t end;
1126
1127         p = &parent->child;
1128         end = start + n - 1;
1129
1130         write_lock(&resource_lock);
1131
1132         for (;;) {
1133                 struct resource *res = *p;
1134
1135                 if (!res)
1136                         break;
1137                 if (res->start <= start && res->end >= end) {
1138                         if (!(res->flags & IORESOURCE_BUSY)) {
1139                                 p = &res->child;
1140                                 continue;
1141                         }
1142                         if (res->start != start || res->end != end)
1143                                 break;
1144                         *p = res->sibling;
1145                         write_unlock(&resource_lock);
1146                         if (res->flags & IORESOURCE_MUXED)
1147                                 wake_up(&muxed_resource_wait);
1148                         free_resource(res);
1149                         return;
1150                 }
1151                 p = &res->sibling;
1152         }
1153
1154         write_unlock(&resource_lock);
1155
1156         printk(KERN_WARNING "Trying to free nonexistent resource "
1157                 "<%016llx-%016llx>\n", (unsigned long long)start,
1158                 (unsigned long long)end);
1159 }
1160 EXPORT_SYMBOL(__release_region);
1161
1162 #ifdef CONFIG_MEMORY_HOTREMOVE
1163 /**
1164  * release_mem_region_adjustable - release a previously reserved memory region
1165  * @parent: parent resource descriptor
1166  * @start: resource start address
1167  * @size: resource region size
1168  *
1169  * This interface is intended for memory hot-delete.  The requested region
1170  * is released from a currently busy memory resource.  The requested region
1171  * must either match exactly or fit into a single busy resource entry.  In
1172  * the latter case, the remaining resource is adjusted accordingly.
1173  * Existing children of the busy memory resource must be immutable in the
1174  * request.
1175  *
1176  * Note:
1177  * - Additional release conditions, such as overlapping region, can be
1178  *   supported after they are confirmed as valid cases.
1179  * - When a busy memory resource gets split into two entries, the code
1180  *   assumes that all children remain in the lower address entry for
1181  *   simplicity.  Enhance this logic when necessary.
1182  */
1183 int release_mem_region_adjustable(struct resource *parent,
1184                         resource_size_t start, resource_size_t size)
1185 {
1186         struct resource **p;
1187         struct resource *res;
1188         struct resource *new_res;
1189         resource_size_t end;
1190         int ret = -EINVAL;
1191
1192         end = start + size - 1;
1193         if ((start < parent->start) || (end > parent->end))
1194                 return ret;
1195
1196         /* The alloc_resource() result gets checked later */
1197         new_res = alloc_resource(GFP_KERNEL);
1198
1199         p = &parent->child;
1200         write_lock(&resource_lock);
1201
1202         while ((res = *p)) {
1203                 if (res->start >= end)
1204                         break;
1205
1206                 /* look for the next resource if it does not fit into */
1207                 if (res->start > start || res->end < end) {
1208                         p = &res->sibling;
1209                         continue;
1210                 }
1211
1212                 if (!(res->flags & IORESOURCE_MEM))
1213                         break;
1214
1215                 if (!(res->flags & IORESOURCE_BUSY)) {
1216                         p = &res->child;
1217                         continue;
1218                 }
1219
1220                 /* found the target resource; let's adjust accordingly */
1221                 if (res->start == start && res->end == end) {
1222                         /* free the whole entry */
1223                         *p = res->sibling;
1224                         free_resource(res);
1225                         ret = 0;
1226                 } else if (res->start == start && res->end != end) {
1227                         /* adjust the start */
1228                         ret = __adjust_resource(res, end + 1,
1229                                                 res->end - end);
1230                 } else if (res->start != start && res->end == end) {
1231                         /* adjust the end */
1232                         ret = __adjust_resource(res, res->start,
1233                                                 start - res->start);
1234                 } else {
1235                         /* split into two entries */
1236                         if (!new_res) {
1237                                 ret = -ENOMEM;
1238                                 break;
1239                         }
1240                         new_res->name = res->name;
1241                         new_res->start = end + 1;
1242                         new_res->end = res->end;
1243                         new_res->flags = res->flags;
1244                         new_res->desc = res->desc;
1245                         new_res->parent = res->parent;
1246                         new_res->sibling = res->sibling;
1247                         new_res->child = NULL;
1248
1249                         ret = __adjust_resource(res, res->start,
1250                                                 start - res->start);
1251                         if (ret)
1252                                 break;
1253                         res->sibling = new_res;
1254                         new_res = NULL;
1255                 }
1256
1257                 break;
1258         }
1259
1260         write_unlock(&resource_lock);
1261         free_resource(new_res);
1262         return ret;
1263 }
1264 #endif  /* CONFIG_MEMORY_HOTREMOVE */
1265
1266 /*
1267  * Managed region resource
1268  */
1269 static void devm_resource_release(struct device *dev, void *ptr)
1270 {
1271         struct resource **r = ptr;
1272
1273         release_resource(*r);
1274 }
1275
1276 /**
1277  * devm_request_resource() - request and reserve an I/O or memory resource
1278  * @dev: device for which to request the resource
1279  * @root: root of the resource tree from which to request the resource
1280  * @new: descriptor of the resource to request
1281  *
1282  * This is a device-managed version of request_resource(). There is usually
1283  * no need to release resources requested by this function explicitly since
1284  * that will be taken care of when the device is unbound from its driver.
1285  * If for some reason the resource needs to be released explicitly, because
1286  * of ordering issues for example, drivers must call devm_release_resource()
1287  * rather than the regular release_resource().
1288  *
1289  * When a conflict is detected between any existing resources and the newly
1290  * requested resource, an error message will be printed.
1291  *
1292  * Returns 0 on success or a negative error code on failure.
1293  */
1294 int devm_request_resource(struct device *dev, struct resource *root,
1295                           struct resource *new)
1296 {
1297         struct resource *conflict, **ptr;
1298
1299         ptr = devres_alloc(devm_resource_release, sizeof(*ptr), GFP_KERNEL);
1300         if (!ptr)
1301                 return -ENOMEM;
1302
1303         *ptr = new;
1304
1305         conflict = request_resource_conflict(root, new);
1306         if (conflict) {
1307                 dev_err(dev, "resource collision: %pR conflicts with %s %pR\n",
1308                         new, conflict->name, conflict);
1309                 devres_free(ptr);
1310                 return -EBUSY;
1311         }
1312
1313         devres_add(dev, ptr);
1314         return 0;
1315 }
1316 EXPORT_SYMBOL(devm_request_resource);
1317
1318 static int devm_resource_match(struct device *dev, void *res, void *data)
1319 {
1320         struct resource **ptr = res;
1321
1322         return *ptr == data;
1323 }
1324
1325 /**
1326  * devm_release_resource() - release a previously requested resource
1327  * @dev: device for which to release the resource
1328  * @new: descriptor of the resource to release
1329  *
1330  * Releases a resource previously requested using devm_request_resource().
1331  */
1332 void devm_release_resource(struct device *dev, struct resource *new)
1333 {
1334         WARN_ON(devres_release(dev, devm_resource_release, devm_resource_match,
1335                                new));
1336 }
1337 EXPORT_SYMBOL(devm_release_resource);
1338
1339 struct region_devres {
1340         struct resource *parent;
1341         resource_size_t start;
1342         resource_size_t n;
1343 };
1344
1345 static void devm_region_release(struct device *dev, void *res)
1346 {
1347         struct region_devres *this = res;
1348
1349         __release_region(this->parent, this->start, this->n);
1350 }
1351
1352 static int devm_region_match(struct device *dev, void *res, void *match_data)
1353 {
1354         struct region_devres *this = res, *match = match_data;
1355
1356         return this->parent == match->parent &&
1357                 this->start == match->start && this->n == match->n;
1358 }
1359
1360 struct resource * __devm_request_region(struct device *dev,
1361                                 struct resource *parent, resource_size_t start,
1362                                 resource_size_t n, const char *name)
1363 {
1364         struct region_devres *dr = NULL;
1365         struct resource *res;
1366
1367         dr = devres_alloc(devm_region_release, sizeof(struct region_devres),
1368                           GFP_KERNEL);
1369         if (!dr)
1370                 return NULL;
1371
1372         dr->parent = parent;
1373         dr->start = start;
1374         dr->n = n;
1375
1376         res = __request_region(parent, start, n, name, 0);
1377         if (res)
1378                 devres_add(dev, dr);
1379         else
1380                 devres_free(dr);
1381
1382         return res;
1383 }
1384 EXPORT_SYMBOL(__devm_request_region);
1385
1386 void __devm_release_region(struct device *dev, struct resource *parent,
1387                            resource_size_t start, resource_size_t n)
1388 {
1389         struct region_devres match_data = { parent, start, n };
1390
1391         __release_region(parent, start, n);
1392         WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match,
1393                                &match_data));
1394 }
1395 EXPORT_SYMBOL(__devm_release_region);
1396
1397 /*
1398  * Called from init/main.c to reserve IO ports.
1399  */
1400 #define MAXRESERVE 4
1401 static int __init reserve_setup(char *str)
1402 {
1403         static int reserved;
1404         static struct resource reserve[MAXRESERVE];
1405
1406         for (;;) {
1407                 unsigned int io_start, io_num;
1408                 int x = reserved;
1409
1410                 if (get_option (&str, &io_start) != 2)
1411                         break;
1412                 if (get_option (&str, &io_num)   == 0)
1413                         break;
1414                 if (x < MAXRESERVE) {
1415                         struct resource *res = reserve + x;
1416                         res->name = "reserved";
1417                         res->start = io_start;
1418                         res->end = io_start + io_num - 1;
1419                         res->flags = IORESOURCE_BUSY;
1420                         res->desc = IORES_DESC_NONE;
1421                         res->child = NULL;
1422                         if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0)
1423                                 reserved = x+1;
1424                 }
1425         }
1426         return 1;
1427 }
1428
1429 __setup("reserve=", reserve_setup);
1430
1431 /*
1432  * Check if the requested addr and size spans more than any slot in the
1433  * iomem resource tree.
1434  */
1435 int iomem_map_sanity_check(resource_size_t addr, unsigned long size)
1436 {
1437         struct resource *p = &iomem_resource;
1438         int err = 0;
1439         loff_t l;
1440
1441         read_lock(&resource_lock);
1442         for (p = p->child; p ; p = r_next(NULL, p, &l)) {
1443                 /*
1444                  * We can probably skip the resources without
1445                  * IORESOURCE_IO attribute?
1446                  */
1447                 if (p->start >= addr + size)
1448                         continue;
1449                 if (p->end < addr)
1450                         continue;
1451                 if (PFN_DOWN(p->start) <= PFN_DOWN(addr) &&
1452                     PFN_DOWN(p->end) >= PFN_DOWN(addr + size - 1))
1453                         continue;
1454                 /*
1455                  * if a resource is "BUSY", it's not a hardware resource
1456                  * but a driver mapping of such a resource; we don't want
1457                  * to warn for those; some drivers legitimately map only
1458                  * partial hardware resources. (example: vesafb)
1459                  */
1460                 if (p->flags & IORESOURCE_BUSY)
1461                         continue;
1462
1463                 printk(KERN_WARNING "resource sanity check: requesting [mem %#010llx-%#010llx], which spans more than %s %pR\n",
1464                        (unsigned long long)addr,
1465                        (unsigned long long)(addr + size - 1),
1466                        p->name, p);
1467                 err = -1;
1468                 break;
1469         }
1470         read_unlock(&resource_lock);
1471
1472         return err;
1473 }
1474
1475 #ifdef CONFIG_STRICT_DEVMEM
1476 static int strict_iomem_checks = 1;
1477 #else
1478 static int strict_iomem_checks;
1479 #endif
1480
1481 /*
1482  * check if an address is reserved in the iomem resource tree
1483  * returns 1 if reserved, 0 if not reserved.
1484  */
1485 int iomem_is_exclusive(u64 addr)
1486 {
1487         struct resource *p = &iomem_resource;
1488         int err = 0;
1489         loff_t l;
1490         int size = PAGE_SIZE;
1491
1492         if (!strict_iomem_checks)
1493                 return 0;
1494
1495         addr = addr & PAGE_MASK;
1496
1497         read_lock(&resource_lock);
1498         for (p = p->child; p ; p = r_next(NULL, p, &l)) {
1499                 /*
1500                  * We can probably skip the resources without
1501                  * IORESOURCE_IO attribute?
1502                  */
1503                 if (p->start >= addr + size)
1504                         break;
1505                 if (p->end < addr)
1506                         continue;
1507                 /*
1508                  * A resource is exclusive if IORESOURCE_EXCLUSIVE is set
1509                  * or CONFIG_IO_STRICT_DEVMEM is enabled and the
1510                  * resource is busy.
1511                  */
1512                 if ((p->flags & IORESOURCE_BUSY) == 0)
1513                         continue;
1514                 if (IS_ENABLED(CONFIG_IO_STRICT_DEVMEM)
1515                                 || p->flags & IORESOURCE_EXCLUSIVE) {
1516                         err = 1;
1517                         break;
1518                 }
1519         }
1520         read_unlock(&resource_lock);
1521
1522         return err;
1523 }
1524
1525 struct resource_entry *resource_list_create_entry(struct resource *res,
1526                                                   size_t extra_size)
1527 {
1528         struct resource_entry *entry;
1529
1530         entry = kzalloc(sizeof(*entry) + extra_size, GFP_KERNEL);
1531         if (entry) {
1532                 INIT_LIST_HEAD(&entry->node);
1533                 entry->res = res ? res : &entry->__res;
1534         }
1535
1536         return entry;
1537 }
1538 EXPORT_SYMBOL(resource_list_create_entry);
1539
1540 void resource_list_free(struct list_head *head)
1541 {
1542         struct resource_entry *entry, *tmp;
1543
1544         list_for_each_entry_safe(entry, tmp, head, node)
1545                 resource_list_destroy_entry(entry);
1546 }
1547 EXPORT_SYMBOL(resource_list_free);
1548
1549 static int __init strict_iomem(char *str)
1550 {
1551         if (strstr(str, "relaxed"))
1552                 strict_iomem_checks = 0;
1553         if (strstr(str, "strict"))
1554                 strict_iomem_checks = 1;
1555         return 1;
1556 }
1557
1558 __setup("iomem=", strict_iomem);