1 /* 2 * linux/kernel/resource.c 3 * 4 * Copyright (C) 1999 Linus Torvalds 5 * Copyright (C) 1999 Martin Mares <mj@ucw.cz> 6 * 7 * Arbitrary resource management. 8 */ 9 10 #include <linux/module.h> 11 #include <linux/errno.h> 12 #include <linux/ioport.h> 13 #include <linux/init.h> 14 #include <linux/slab.h> 15 #include <linux/spinlock.h> 16 #include <linux/fs.h> 17 #include <linux/proc_fs.h> 18 #include <linux/seq_file.h> 19 #include <linux/device.h> 20 #include <asm/io.h> 21 22 23 struct resource ioport_resource = { 24 .name = "PCI IO", 25 .start = 0, 26 .end = IO_SPACE_LIMIT, 27 .flags = IORESOURCE_IO, 28 }; 29 EXPORT_SYMBOL(ioport_resource); 30 31 struct resource iomem_resource = { 32 .name = "PCI mem", 33 .start = 0, 34 .end = -1, 35 .flags = IORESOURCE_MEM, 36 }; 37 EXPORT_SYMBOL(iomem_resource); 38 39 static DEFINE_RWLOCK(resource_lock); 40 41 #ifdef CONFIG_PROC_FS 42 43 enum { MAX_IORES_LEVEL = 5 }; 44 45 static void *r_next(struct seq_file *m, void *v, loff_t *pos) 46 { 47 struct resource *p = v; 48 (*pos)++; 49 if (p->child) 50 return p->child; 51 while (!p->sibling && p->parent) 52 p = p->parent; 53 return p->sibling; 54 } 55 56 static void *r_start(struct seq_file *m, loff_t *pos) 57 __acquires(resource_lock) 58 { 59 struct resource *p = m->private; 60 loff_t l = 0; 61 read_lock(&resource_lock); 62 for (p = p->child; p && l < *pos; p = r_next(m, p, &l)) 63 ; 64 return p; 65 } 66 67 static void r_stop(struct seq_file *m, void *v) 68 __releases(resource_lock) 69 { 70 read_unlock(&resource_lock); 71 } 72 73 static int r_show(struct seq_file *m, void *v) 74 { 75 struct resource *root = m->private; 76 struct resource *r = v, *p; 77 int width = root->end < 0x10000 ? 4 : 8; 78 int depth; 79 80 for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent) 81 if (p->parent == root) 82 break; 83 seq_printf(m, "%*s%0*llx-%0*llx : %s\n", 84 depth * 2, "", 85 width, (unsigned long long) r->start, 86 width, (unsigned long long) r->end, 87 r->name ? r->name : "<BAD>"); 88 return 0; 89 } 90 91 static const struct seq_operations resource_op = { 92 .start = r_start, 93 .next = r_next, 94 .stop = r_stop, 95 .show = r_show, 96 }; 97 98 static int ioports_open(struct inode *inode, struct file *file) 99 { 100 int res = seq_open(file, &resource_op); 101 if (!res) { 102 struct seq_file *m = file->private_data; 103 m->private = &ioport_resource; 104 } 105 return res; 106 } 107 108 static int iomem_open(struct inode *inode, struct file *file) 109 { 110 int res = seq_open(file, &resource_op); 111 if (!res) { 112 struct seq_file *m = file->private_data; 113 m->private = &iomem_resource; 114 } 115 return res; 116 } 117 118 static const struct file_operations proc_ioports_operations = { 119 .open = ioports_open, 120 .read = seq_read, 121 .llseek = seq_lseek, 122 .release = seq_release, 123 }; 124 125 static const struct file_operations proc_iomem_operations = { 126 .open = iomem_open, 127 .read = seq_read, 128 .llseek = seq_lseek, 129 .release = seq_release, 130 }; 131 132 static int __init ioresources_init(void) 133 { 134 struct proc_dir_entry *entry; 135 136 entry = create_proc_entry("ioports", 0, NULL); 137 if (entry) 138 entry->proc_fops = &proc_ioports_operations; 139 entry = create_proc_entry("iomem", 0, NULL); 140 if (entry) 141 entry->proc_fops = &proc_iomem_operations; 142 return 0; 143 } 144 __initcall(ioresources_init); 145 146 #endif /* CONFIG_PROC_FS */ 147 148 /* Return the conflict entry if you can't request it */ 149 static struct resource * __request_resource(struct resource *root, struct resource *new) 150 { 151 resource_size_t start = new->start; 152 resource_size_t end = new->end; 153 struct resource *tmp, **p; 154 155 if (end < start) 156 return root; 157 if (start < root->start) 158 return root; 159 if (end > root->end) 160 return root; 161 p = &root->child; 162 for (;;) { 163 tmp = *p; 164 if (!tmp || tmp->start > end) { 165 new->sibling = tmp; 166 *p = new; 167 new->parent = root; 168 return NULL; 169 } 170 p = &tmp->sibling; 171 if (tmp->end < start) 172 continue; 173 return tmp; 174 } 175 } 176 177 static int __release_resource(struct resource *old) 178 { 179 struct resource *tmp, **p; 180 181 p = &old->parent->child; 182 for (;;) { 183 tmp = *p; 184 if (!tmp) 185 break; 186 if (tmp == old) { 187 *p = tmp->sibling; 188 old->parent = NULL; 189 return 0; 190 } 191 p = &tmp->sibling; 192 } 193 return -EINVAL; 194 } 195 196 /** 197 * request_resource - request and reserve an I/O or memory resource 198 * @root: root resource descriptor 199 * @new: resource descriptor desired by caller 200 * 201 * Returns 0 for success, negative error code on error. 202 */ 203 int request_resource(struct resource *root, struct resource *new) 204 { 205 struct resource *conflict; 206 207 write_lock(&resource_lock); 208 conflict = __request_resource(root, new); 209 write_unlock(&resource_lock); 210 return conflict ? -EBUSY : 0; 211 } 212 213 EXPORT_SYMBOL(request_resource); 214 215 /** 216 * release_resource - release a previously reserved resource 217 * @old: resource pointer 218 */ 219 int release_resource(struct resource *old) 220 { 221 int retval; 222 223 write_lock(&resource_lock); 224 retval = __release_resource(old); 225 write_unlock(&resource_lock); 226 return retval; 227 } 228 229 EXPORT_SYMBOL(release_resource); 230 231 #ifdef CONFIG_MEMORY_HOTPLUG 232 /* 233 * Finds the lowest memory reosurce exists within [res->start.res->end) 234 * the caller must specify res->start, res->end, res->flags. 235 * If found, returns 0, res is overwritten, if not found, returns -1. 236 */ 237 int find_next_system_ram(struct resource *res) 238 { 239 resource_size_t start, end; 240 struct resource *p; 241 242 BUG_ON(!res); 243 244 start = res->start; 245 end = res->end; 246 BUG_ON(start >= end); 247 248 read_lock(&resource_lock); 249 for (p = iomem_resource.child; p ; p = p->sibling) { 250 /* system ram is just marked as IORESOURCE_MEM */ 251 if (p->flags != res->flags) 252 continue; 253 if (p->start > end) { 254 p = NULL; 255 break; 256 } 257 if ((p->end >= start) && (p->start < end)) 258 break; 259 } 260 read_unlock(&resource_lock); 261 if (!p) 262 return -1; 263 /* copy data */ 264 if (res->start < p->start) 265 res->start = p->start; 266 if (res->end > p->end) 267 res->end = p->end; 268 return 0; 269 } 270 #endif 271 272 /* 273 * Find empty slot in the resource tree given range and alignment. 274 */ 275 static int find_resource(struct resource *root, struct resource *new, 276 resource_size_t size, resource_size_t min, 277 resource_size_t max, resource_size_t align, 278 void (*alignf)(void *, struct resource *, 279 resource_size_t, resource_size_t), 280 void *alignf_data) 281 { 282 struct resource *this = root->child; 283 284 new->start = root->start; 285 /* 286 * Skip past an allocated resource that starts at 0, since the assignment 287 * of this->start - 1 to new->end below would cause an underflow. 288 */ 289 if (this && this->start == 0) { 290 new->start = this->end + 1; 291 this = this->sibling; 292 } 293 for(;;) { 294 if (this) 295 new->end = this->start - 1; 296 else 297 new->end = root->end; 298 if (new->start < min) 299 new->start = min; 300 if (new->end > max) 301 new->end = max; 302 new->start = ALIGN(new->start, align); 303 if (alignf) 304 alignf(alignf_data, new, size, align); 305 if (new->start < new->end && new->end - new->start >= size - 1) { 306 new->end = new->start + size - 1; 307 return 0; 308 } 309 if (!this) 310 break; 311 new->start = this->end + 1; 312 this = this->sibling; 313 } 314 return -EBUSY; 315 } 316 317 /** 318 * allocate_resource - allocate empty slot in the resource tree given range & alignment 319 * @root: root resource descriptor 320 * @new: resource descriptor desired by caller 321 * @size: requested resource region size 322 * @min: minimum size to allocate 323 * @max: maximum size to allocate 324 * @align: alignment requested, in bytes 325 * @alignf: alignment function, optional, called if not NULL 326 * @alignf_data: arbitrary data to pass to the @alignf function 327 */ 328 int allocate_resource(struct resource *root, struct resource *new, 329 resource_size_t size, resource_size_t min, 330 resource_size_t max, resource_size_t align, 331 void (*alignf)(void *, struct resource *, 332 resource_size_t, resource_size_t), 333 void *alignf_data) 334 { 335 int err; 336 337 write_lock(&resource_lock); 338 err = find_resource(root, new, size, min, max, align, alignf, alignf_data); 339 if (err >= 0 && __request_resource(root, new)) 340 err = -EBUSY; 341 write_unlock(&resource_lock); 342 return err; 343 } 344 345 EXPORT_SYMBOL(allocate_resource); 346 347 /** 348 * insert_resource - Inserts a resource in the resource tree 349 * @parent: parent of the new resource 350 * @new: new resource to insert 351 * 352 * Returns 0 on success, -EBUSY if the resource can't be inserted. 353 * 354 * This function is equivalent to request_resource when no conflict 355 * happens. If a conflict happens, and the conflicting resources 356 * entirely fit within the range of the new resource, then the new 357 * resource is inserted and the conflicting resources become children of 358 * the new resource. 359 */ 360 int insert_resource(struct resource *parent, struct resource *new) 361 { 362 int result; 363 struct resource *first, *next; 364 365 write_lock(&resource_lock); 366 367 for (;; parent = first) { 368 result = 0; 369 first = __request_resource(parent, new); 370 if (!first) 371 goto out; 372 373 result = -EBUSY; 374 if (first == parent) 375 goto out; 376 377 if ((first->start > new->start) || (first->end < new->end)) 378 break; 379 if ((first->start == new->start) && (first->end == new->end)) 380 break; 381 } 382 383 for (next = first; ; next = next->sibling) { 384 /* Partial overlap? Bad, and unfixable */ 385 if (next->start < new->start || next->end > new->end) 386 goto out; 387 if (!next->sibling) 388 break; 389 if (next->sibling->start > new->end) 390 break; 391 } 392 393 result = 0; 394 395 new->parent = parent; 396 new->sibling = next->sibling; 397 new->child = first; 398 399 next->sibling = NULL; 400 for (next = first; next; next = next->sibling) 401 next->parent = new; 402 403 if (parent->child == first) { 404 parent->child = new; 405 } else { 406 next = parent->child; 407 while (next->sibling != first) 408 next = next->sibling; 409 next->sibling = new; 410 } 411 412 out: 413 write_unlock(&resource_lock); 414 return result; 415 } 416 417 /** 418 * adjust_resource - modify a resource's start and size 419 * @res: resource to modify 420 * @start: new start value 421 * @size: new size 422 * 423 * Given an existing resource, change its start and size to match the 424 * arguments. Returns 0 on success, -EBUSY if it can't fit. 425 * Existing children of the resource are assumed to be immutable. 426 */ 427 int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size) 428 { 429 struct resource *tmp, *parent = res->parent; 430 resource_size_t end = start + size - 1; 431 int result = -EBUSY; 432 433 write_lock(&resource_lock); 434 435 if ((start < parent->start) || (end > parent->end)) 436 goto out; 437 438 for (tmp = res->child; tmp; tmp = tmp->sibling) { 439 if ((tmp->start < start) || (tmp->end > end)) 440 goto out; 441 } 442 443 if (res->sibling && (res->sibling->start <= end)) 444 goto out; 445 446 tmp = parent->child; 447 if (tmp != res) { 448 while (tmp->sibling != res) 449 tmp = tmp->sibling; 450 if (start <= tmp->end) 451 goto out; 452 } 453 454 res->start = start; 455 res->end = end; 456 result = 0; 457 458 out: 459 write_unlock(&resource_lock); 460 return result; 461 } 462 463 EXPORT_SYMBOL(adjust_resource); 464 465 /* 466 * This is compatibility stuff for IO resources. 467 * 468 * Note how this, unlike the above, knows about 469 * the IO flag meanings (busy etc). 470 * 471 * request_region creates a new busy region. 472 * 473 * check_region returns non-zero if the area is already busy. 474 * 475 * release_region releases a matching busy region. 476 */ 477 478 /** 479 * __request_region - create a new busy resource region 480 * @parent: parent resource descriptor 481 * @start: resource start address 482 * @n: resource region size 483 * @name: reserving caller's ID string 484 */ 485 struct resource * __request_region(struct resource *parent, 486 resource_size_t start, resource_size_t n, 487 const char *name) 488 { 489 struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL); 490 491 if (res) { 492 res->name = name; 493 res->start = start; 494 res->end = start + n - 1; 495 res->flags = IORESOURCE_BUSY; 496 497 write_lock(&resource_lock); 498 499 for (;;) { 500 struct resource *conflict; 501 502 conflict = __request_resource(parent, res); 503 if (!conflict) 504 break; 505 if (conflict != parent) { 506 parent = conflict; 507 if (!(conflict->flags & IORESOURCE_BUSY)) 508 continue; 509 } 510 511 /* Uhhuh, that didn't work out.. */ 512 kfree(res); 513 res = NULL; 514 break; 515 } 516 write_unlock(&resource_lock); 517 } 518 return res; 519 } 520 EXPORT_SYMBOL(__request_region); 521 522 /** 523 * __check_region - check if a resource region is busy or free 524 * @parent: parent resource descriptor 525 * @start: resource start address 526 * @n: resource region size 527 * 528 * Returns 0 if the region is free at the moment it is checked, 529 * returns %-EBUSY if the region is busy. 530 * 531 * NOTE: 532 * This function is deprecated because its use is racy. 533 * Even if it returns 0, a subsequent call to request_region() 534 * may fail because another driver etc. just allocated the region. 535 * Do NOT use it. It will be removed from the kernel. 536 */ 537 int __check_region(struct resource *parent, resource_size_t start, 538 resource_size_t n) 539 { 540 struct resource * res; 541 542 res = __request_region(parent, start, n, "check-region"); 543 if (!res) 544 return -EBUSY; 545 546 release_resource(res); 547 kfree(res); 548 return 0; 549 } 550 EXPORT_SYMBOL(__check_region); 551 552 /** 553 * __release_region - release a previously reserved resource region 554 * @parent: parent resource descriptor 555 * @start: resource start address 556 * @n: resource region size 557 * 558 * The described resource region must match a currently busy region. 559 */ 560 void __release_region(struct resource *parent, resource_size_t start, 561 resource_size_t n) 562 { 563 struct resource **p; 564 resource_size_t end; 565 566 p = &parent->child; 567 end = start + n - 1; 568 569 write_lock(&resource_lock); 570 571 for (;;) { 572 struct resource *res = *p; 573 574 if (!res) 575 break; 576 if (res->start <= start && res->end >= end) { 577 if (!(res->flags & IORESOURCE_BUSY)) { 578 p = &res->child; 579 continue; 580 } 581 if (res->start != start || res->end != end) 582 break; 583 *p = res->sibling; 584 write_unlock(&resource_lock); 585 kfree(res); 586 return; 587 } 588 p = &res->sibling; 589 } 590 591 write_unlock(&resource_lock); 592 593 printk(KERN_WARNING "Trying to free nonexistent resource " 594 "<%016llx-%016llx>\n", (unsigned long long)start, 595 (unsigned long long)end); 596 } 597 EXPORT_SYMBOL(__release_region); 598 599 /* 600 * Managed region resource 601 */ 602 struct region_devres { 603 struct resource *parent; 604 resource_size_t start; 605 resource_size_t n; 606 }; 607 608 static void devm_region_release(struct device *dev, void *res) 609 { 610 struct region_devres *this = res; 611 612 __release_region(this->parent, this->start, this->n); 613 } 614 615 static int devm_region_match(struct device *dev, void *res, void *match_data) 616 { 617 struct region_devres *this = res, *match = match_data; 618 619 return this->parent == match->parent && 620 this->start == match->start && this->n == match->n; 621 } 622 623 struct resource * __devm_request_region(struct device *dev, 624 struct resource *parent, resource_size_t start, 625 resource_size_t n, const char *name) 626 { 627 struct region_devres *dr = NULL; 628 struct resource *res; 629 630 dr = devres_alloc(devm_region_release, sizeof(struct region_devres), 631 GFP_KERNEL); 632 if (!dr) 633 return NULL; 634 635 dr->parent = parent; 636 dr->start = start; 637 dr->n = n; 638 639 res = __request_region(parent, start, n, name); 640 if (res) 641 devres_add(dev, dr); 642 else 643 devres_free(dr); 644 645 return res; 646 } 647 EXPORT_SYMBOL(__devm_request_region); 648 649 void __devm_release_region(struct device *dev, struct resource *parent, 650 resource_size_t start, resource_size_t n) 651 { 652 struct region_devres match_data = { parent, start, n }; 653 654 __release_region(parent, start, n); 655 WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match, 656 &match_data)); 657 } 658 EXPORT_SYMBOL(__devm_release_region); 659 660 /* 661 * Called from init/main.c to reserve IO ports. 662 */ 663 #define MAXRESERVE 4 664 static int __init reserve_setup(char *str) 665 { 666 static int reserved; 667 static struct resource reserve[MAXRESERVE]; 668 669 for (;;) { 670 int io_start, io_num; 671 int x = reserved; 672 673 if (get_option (&str, &io_start) != 2) 674 break; 675 if (get_option (&str, &io_num) == 0) 676 break; 677 if (x < MAXRESERVE) { 678 struct resource *res = reserve + x; 679 res->name = "reserved"; 680 res->start = io_start; 681 res->end = io_start + io_num - 1; 682 res->flags = IORESOURCE_BUSY; 683 res->child = NULL; 684 if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0) 685 reserved = x+1; 686 } 687 } 688 return 1; 689 } 690 691 __setup("reserve=", reserve_setup); 692