![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rsrc_mgr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / modules|
Return to rsrc_mgr.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / modules |
1.1 ! root 1: /*====================================================================== ! 2: ! 3: Resource management routines ! 4: ! 5: rsrc_mgr.c 1.94 2003/12/12 17:12:53 ! 6: ! 7: The contents of this file are subject to the Mozilla Public ! 8: License Version 1.1 (the "License"); you may not use this file ! 9: except in compliance with the License. You may obtain a copy of ! 10: the License at http://www.mozilla.org/MPL/ ! 11: ! 12: Software distributed under the License is distributed on an "AS ! 13: IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or ! 14: implied. See the License for the specific language governing ! 15: rights and limitations under the License. ! 16: ! 17: The initial developer of the original code is David A. Hinds ! 18: <[email protected]>. Portions created by David A. Hinds ! 19: are Copyright (C) 1999 David A. Hinds. All Rights Reserved. ! 20: ! 21: Alternatively, the contents of this file may be used under the ! 22: terms of the GNU General Public License version 2 (the "GPL"), in ! 23: which case the provisions of the GPL are applicable instead of the ! 24: above. If you wish to allow the use of your version of this file ! 25: only under the terms of the GPL and not to allow others to use ! 26: your version of this file under the MPL, indicate your decision ! 27: by deleting the provisions above and replace them with the notice ! 28: and other provisions required by the GPL. If you do not delete ! 29: the provisions above, a recipient may use your version of this ! 30: file under either the MPL or the GPL. ! 31: ! 32: ======================================================================*/ ! 33: ! 34: #define __NO_VERSION__ ! 35: ! 36: #include <linux/config.h> ! 37: #include <linux/module.h> ! 38: #include <linux/init.h> ! 39: #include <linux/sched.h> ! 40: #include <linux/kernel.h> ! 41: #include <linux/errno.h> ! 42: #include <linux/types.h> ! 43: #include <linux/slab.h> ! 44: #include <linux/ioport.h> ! 45: #include <linux/timer.h> ! 46: #include <linux/spinlock.h> ! 47: #include <asm/irq.h> ! 48: #include <asm/io.h> ! 49: ! 50: #include <pcmcia/cs_types.h> ! 51: #include <pcmcia/ss.h> ! 52: #include <pcmcia/cs.h> ! 53: #include <pcmcia/bulkmem.h> ! 54: #include <pcmcia/cistpl.h> ! 55: #include "cs_internal.h" ! 56: ! 57: /*====================================================================*/ ! 58: ! 59: /* Parameters that can be set with 'insmod' */ ! 60: ! 61: #define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i") ! 62: ! 63: INT_MODULE_PARM(probe_mem, 1); /* memory probe? */ ! 64: #ifdef CONFIG_ISA ! 65: INT_MODULE_PARM(probe_io, 1); /* IO port probe? */ ! 66: INT_MODULE_PARM(mem_limit, 0x10000); ! 67: #endif ! 68: ! 69: /*====================================================================== ! 70: ! 71: The resource_map_t structures are used to track what resources are ! 72: available for allocation for PC Card devices. ! 73: ! 74: ======================================================================*/ ! 75: ! 76: typedef struct resource_map_t { ! 77: u_long base, num; ! 78: struct resource_map_t *next; ! 79: } resource_map_t; ! 80: ! 81: /* Memory resource database */ ! 82: static resource_map_t mem_db = { 0, 0, &mem_db }; ! 83: ! 84: /* IO port resource database */ ! 85: static resource_map_t io_db = { 0, 0, &io_db }; ! 86: ! 87: #ifdef CONFIG_ISA ! 88: ! 89: typedef struct irq_info_t { ! 90: u_int Attributes; ! 91: int time_share, dyn_share; ! 92: struct socket_info_t *Socket; ! 93: } irq_info_t; ! 94: ! 95: /* Table of ISA IRQ assignments */ ! 96: static irq_info_t irq_table[16] = { { 0, 0, 0 }, /* etc */ }; ! 97: ! 98: #endif ! 99: ! 100: /*====================================================================== ! 101: ! 102: Linux resource management extensions ! 103: ! 104: ======================================================================*/ ! 105: ! 106: #ifndef CONFIG_PNP_BIOS ! 107: #define check_io_region(b,n) (0) ! 108: #endif ! 109: ! 110: #if defined(CONFIG_PNP_BIOS) || !defined(HAVE_MEMRESERVE) ! 111: ! 112: #ifdef __SMP__ ! 113: static spinlock_t rsrc_lock = SPIN_LOCK_UNLOCKED; ! 114: #endif ! 115: ! 116: typedef struct resource_entry_t { ! 117: u_long base, num; ! 118: char *name; ! 119: struct resource_entry_t *next; ! 120: } resource_entry_t; ! 121: ! 122: /* Ordered linked lists of allocated IO and memory blocks */ ! 123: #ifdef CONFIG_PNP_BIOS ! 124: static resource_entry_t io_list = { 0, 0, NULL, NULL }; ! 125: #endif ! 126: #ifndef HAVE_MEMRESERVE ! 127: static resource_entry_t mem_list = { 0, 0, NULL, NULL }; ! 128: #endif ! 129: ! 130: static resource_entry_t *find_gap(resource_entry_t *root, ! 131: resource_entry_t *entry) ! 132: { ! 133: resource_entry_t *p; ! 134: ! 135: if (entry->base > entry->base+entry->num-1) ! 136: return NULL; ! 137: for (p = root; ; p = p->next) { ! 138: if ((p != root) && (p->base+p->num-1 >= entry->base)) { ! 139: p = NULL; ! 140: break; ! 141: } ! 142: if ((p->next == NULL) || ! 143: (p->next->base > entry->base+entry->num-1)) ! 144: break; ! 145: } ! 146: return p; ! 147: } ! 148: ! 149: static int register_my_resource(resource_entry_t *list, ! 150: u_long base, u_long num, char *name) ! 151: { ! 152: u_long flags; ! 153: resource_entry_t *p, *entry; ! 154: ! 155: entry = kmalloc(sizeof(resource_entry_t), GFP_ATOMIC); ! 156: if (!entry) return -ENOMEM; ! 157: entry->base = base; ! 158: entry->num = num; ! 159: entry->name = name; ! 160: ! 161: spin_lock_irqsave(&rsrc_lock, flags); ! 162: p = find_gap(list, entry); ! 163: if (p == NULL) { ! 164: spin_unlock_irqrestore(&rsrc_lock, flags); ! 165: kfree(entry); ! 166: return -EBUSY; ! 167: } ! 168: entry->next = p->next; ! 169: p->next = entry; ! 170: spin_unlock_irqrestore(&rsrc_lock, flags); ! 171: return 0; ! 172: } ! 173: ! 174: static void release_my_resource(resource_entry_t *list, ! 175: u_long base, u_long num) ! 176: { ! 177: u_long flags; ! 178: resource_entry_t *p, *q; ! 179: ! 180: spin_lock_irqsave(&rsrc_lock, flags); ! 181: for (p = list; ; p = q) { ! 182: q = p->next; ! 183: if (q == NULL) break; ! 184: if ((q->base == base) && (q->num == num)) { ! 185: p->next = q->next; ! 186: kfree(q); ! 187: spin_unlock_irqrestore(&rsrc_lock, flags); ! 188: return; ! 189: } ! 190: } ! 191: spin_unlock_irqrestore(&rsrc_lock, flags); ! 192: return; ! 193: } ! 194: ! 195: static int check_my_resource(resource_entry_t *list, ! 196: u_long base, u_long num) ! 197: { ! 198: if (register_my_resource(list, base, num, NULL) != 0) ! 199: return -EBUSY; ! 200: release_my_resource(list, base, num); ! 201: return 0; ! 202: } ! 203: ! 204: #ifdef CONFIG_PNP_BIOS ! 205: int check_io_region(u_long base, u_long num) ! 206: { ! 207: return check_my_resource(&io_list, base, num); ! 208: } ! 209: void request_io_region(u_long base, u_long num, char *name) ! 210: { ! 211: register_my_resource(&io_list, base, num, name); ! 212: } ! 213: void release_io_region(u_long base, u_long num) ! 214: { ! 215: release_my_resource(&io_list, base, num); ! 216: } ! 217: #ifdef HAS_PROC_BUS ! 218: int proc_read_io(char *buf, char **start, off_t pos, ! 219: int count, int *eof, void *data) ! 220: { ! 221: resource_entry_t *r; ! 222: u_long flags; ! 223: char *p = buf; ! 224: ! 225: spin_lock_irqsave(&rsrc_lock, flags); ! 226: for (r = io_list.next; r; r = r->next) ! 227: p += sprintf(p, "%04lx-%04lx : %s\n", r->base, ! 228: r->base+r->num-1, r->name); ! 229: spin_unlock_irqrestore(&rsrc_lock, flags); ! 230: return (p - buf); ! 231: } ! 232: #endif ! 233: #endif ! 234: ! 235: #ifndef HAVE_MEMRESERVE ! 236: int check_mem_region(u_long base, u_long num) ! 237: { ! 238: return check_my_resource(&mem_list, base, num); ! 239: } ! 240: void request_mem_region(u_long base, u_long num, char *name) ! 241: { ! 242: register_my_resource(&mem_list, base, num, name); ! 243: } ! 244: void release_mem_region(u_long base, u_long num) ! 245: { ! 246: release_my_resource(&mem_list, base, num); ! 247: } ! 248: #ifdef HAS_PROC_BUS ! 249: int proc_read_mem(char *buf, char **start, off_t pos, ! 250: int count, int *eof, void *data) ! 251: { ! 252: resource_entry_t *r; ! 253: u_long flags; ! 254: char *p = buf; ! 255: ! 256: spin_lock_irqsave(&rsrc_lock, flags); ! 257: for (r = mem_list.next; r; r = r->next) ! 258: p += sprintf(p, "%08lx-%08lx : %s\n", r->base, ! 259: r->base+r->num-1, r->name); ! 260: spin_unlock_irqrestore(&rsrc_lock, flags); ! 261: return (p - buf); ! 262: } ! 263: #endif ! 264: #endif ! 265: ! 266: #endif /* defined(CONFIG_PNP_BIOS) || !defined(HAVE_MEMRESERVE) */ ! 267: ! 268: /*====================================================================== ! 269: ! 270: These manage the internal databases of available resources. ! 271: ! 272: ======================================================================*/ ! 273: ! 274: static int add_interval(resource_map_t *map, u_long base, u_long num) ! 275: { ! 276: resource_map_t *p, *q; ! 277: ! 278: for (p = map; ; p = p->next) { ! 279: if ((p != map) && (p->base+p->num-1 >= base)) ! 280: return -1; ! 281: if ((p->next == map) || (p->next->base > base+num-1)) ! 282: break; ! 283: } ! 284: q = kmalloc(sizeof(resource_map_t), GFP_KERNEL); ! 285: if (!q) return CS_OUT_OF_RESOURCE; ! 286: q->base = base; q->num = num; ! 287: q->next = p->next; p->next = q; ! 288: return CS_SUCCESS; ! 289: } ! 290: ! 291: /*====================================================================*/ ! 292: ! 293: static int sub_interval(resource_map_t *map, u_long base, u_long num) ! 294: { ! 295: resource_map_t *p, *q; ! 296: ! 297: for (p = map; ; p = q) { ! 298: q = p->next; ! 299: if (q == map) ! 300: break; ! 301: if ((q->base+q->num > base) && (base+num > q->base)) { ! 302: if (q->base >= base) { ! 303: if (q->base+q->num <= base+num) { ! 304: /* Delete whole block */ ! 305: p->next = q->next; ! 306: kfree(q); ! 307: /* don't advance the pointer yet */ ! 308: q = p; ! 309: } else { ! 310: /* Cut off bit from the front */ ! 311: q->num = q->base + q->num - base - num; ! 312: q->base = base + num; ! 313: } ! 314: } else if (q->base+q->num <= base+num) { ! 315: /* Cut off bit from the end */ ! 316: q->num = base - q->base; ! 317: } else { ! 318: /* Split the block into two pieces */ ! 319: p = kmalloc(sizeof(resource_map_t), GFP_KERNEL); ! 320: if (!p) return CS_OUT_OF_RESOURCE; ! 321: p->base = base+num; ! 322: p->num = q->base+q->num - p->base; ! 323: q->num = base - q->base; ! 324: p->next = q->next ; q->next = p; ! 325: } ! 326: } ! 327: } ! 328: return CS_SUCCESS; ! 329: } ! 330: ! 331: /*====================================================================== ! 332: ! 333: These routines examine a region of IO or memory addresses to ! 334: determine what ranges might be genuinely available. ! 335: ! 336: ======================================================================*/ ! 337: ! 338: #ifdef CONFIG_ISA ! 339: static void do_io_probe(ioaddr_t base, ioaddr_t num) ! 340: { ! 341: ! 342: ioaddr_t i, j, bad, any; ! 343: u_char *b, hole, most; ! 344: ! 345: printk(KERN_INFO "cs: IO port probe 0x%04x-0x%04x:", ! 346: base, base+num-1); ! 347: ! 348: /* First, what does a floating port look like? */ ! 349: b = kmalloc(256, GFP_KERNEL); ! 350: if (!b) { ! 351: printk(KERN_INFO " kmalloc failed!\n"); ! 352: return; ! 353: } ! 354: memset(b, 0, 256); ! 355: for (i = base, most = 0; i < base+num; i += 8) { ! 356: if (check_region(i, 8) || check_io_region(i, 8)) ! 357: continue; ! 358: hole = inb(i); ! 359: for (j = 1; j < 8; j++) ! 360: if (inb(i+j) != hole) break; ! 361: if ((j == 8) && (++b[hole] > b[most])) ! 362: most = hole; ! 363: if (b[most] == 127) break; ! 364: } ! 365: kfree(b); ! 366: ! 367: bad = any = 0; ! 368: for (i = base; i < base+num; i += 8) { ! 369: if (check_region(i, 8) || check_io_region(i, 8)) ! 370: continue; ! 371: for (j = 0; j < 8; j++) ! 372: if (inb(i+j) != most) break; ! 373: if (j < 8) { ! 374: if (!any) ! 375: printk(" excluding"); ! 376: if (!bad) ! 377: bad = any = i; ! 378: } else { ! 379: if (bad) { ! 380: sub_interval(&io_db, bad, i-bad); ! 381: printk(" %#04x-%#04x", bad, i-1); ! 382: bad = 0; ! 383: } ! 384: } ! 385: } ! 386: if (bad) { ! 387: if ((num > 16) && (bad == base) && (i == base+num)) { ! 388: printk(" nothing: probe failed.\n"); ! 389: return; ! 390: } else { ! 391: sub_interval(&io_db, bad, i-bad); ! 392: printk(" %#04x-%#04x", bad, i-1); ! 393: } ! 394: } ! 395: ! 396: printk(any ? "\n" : " clean.\n"); ! 397: } ! 398: ! 399: static int io_scan; /* = 0 */ ! 400: ! 401: static void invalidate_io(void) ! 402: { ! 403: io_scan = 0; ! 404: } ! 405: ! 406: static void validate_io(void) ! 407: { ! 408: resource_map_t *m, *n; ! 409: if (!probe_io || io_scan++) ! 410: return; ! 411: for (m = io_db.next; m != &io_db; m = n) { ! 412: n = m->next; ! 413: do_io_probe(m->base, m->num); ! 414: } ! 415: } ! 416: ! 417: #else /* CONFIG_ISA */ ! 418: ! 419: #define validate_io() do { } while (0) ! 420: #define invalidate_io() do { } while (0) ! 421: ! 422: #endif /* CONFIG_ISA */ ! 423: ! 424: /*====================================================================== ! 425: ! 426: The memory probe. If the memory list includes a 64K-aligned block ! 427: below 1MB, we probe in 64K chunks, and as soon as we accumulate at ! 428: least mem_limit free space, we quit. ! 429: ! 430: ======================================================================*/ ! 431: ! 432: static int do_mem_probe(u_long base, u_long num, ! 433: int (*is_valid)(u_long), int (*do_cksum)(u_long)) ! 434: { ! 435: u_long i, j, bad, fail, step; ! 436: ! 437: printk(KERN_INFO "cs: memory probe 0x%06lx-0x%06lx:", ! 438: base, base+num-1); ! 439: bad = fail = 0; ! 440: step = (num < 0x20000) ? 0x2000 : ((num>>4) & ~0x1fff); ! 441: for (i = j = base; i < base+num; i = j + step) { ! 442: if (!fail) { ! 443: for (j = i; j < base+num; j += step) ! 444: if ((check_mem_region(j, step) == 0) && is_valid(j)) ! 445: break; ! 446: fail = ((i == base) && (j == base+num)); ! 447: } ! 448: if (fail) { ! 449: for (j = i; j < base+num; j += 2*step) ! 450: if ((check_mem_region(j, 2*step) == 0) && ! 451: do_cksum(j) && do_cksum(j+step)) ! 452: break; ! 453: } ! 454: if (i != j) { ! 455: if (!bad) printk(" excluding"); ! 456: printk(" %#05lx-%#05lx", i, j-1); ! 457: sub_interval(&mem_db, i, j-i); ! 458: bad += j-i; ! 459: } ! 460: } ! 461: printk(bad ? "\n" : " clean.\n"); ! 462: return (num - bad); ! 463: } ! 464: ! 465: #ifdef CONFIG_ISA ! 466: ! 467: static u_long inv_probe(int (*is_valid)(u_long), ! 468: int (*do_cksum)(u_long), ! 469: resource_map_t *m) ! 470: { ! 471: u_long ok; ! 472: if (m == &mem_db) ! 473: return 0; ! 474: ok = inv_probe(is_valid, do_cksum, m->next); ! 475: if (ok) { ! 476: if (m->base >= 0x100000) ! 477: sub_interval(&mem_db, m->base, m->num); ! 478: return ok; ! 479: } ! 480: if (m->base < 0x100000) ! 481: return 0; ! 482: return do_mem_probe(m->base, m->num, is_valid, do_cksum); ! 483: } ! 484: ! 485: static int hi_scan, lo_scan; /* = 0 */ ! 486: ! 487: static void invalidate_mem(void) ! 488: { ! 489: hi_scan = lo_scan = 0; ! 490: } ! 491: ! 492: void validate_mem(int (*is_valid)(u_long), int (*do_cksum)(u_long), ! 493: int force_low) ! 494: { ! 495: resource_map_t *m, mm; ! 496: static u_char order[] = { 0xd0, 0xe0, 0xc0, 0xf0 }; ! 497: u_long b, i, ok = 0; ! 498: ! 499: if (!probe_mem) return; ! 500: /* We do up to four passes through the list */ ! 501: if (!force_low) { ! 502: if (hi_scan++ || (inv_probe(is_valid, do_cksum, mem_db.next) > 0)) ! 503: return; ! 504: printk(KERN_NOTICE "cs: warning: no high memory space " ! 505: "available!\n"); ! 506: } ! 507: if (lo_scan++) return; ! 508: for (m = mem_db.next; m != &mem_db; m = mm.next) { ! 509: mm = *m; ! 510: /* Only probe < 1 MB */ ! 511: if (mm.base >= 0x100000) continue; ! 512: if ((mm.base | mm.num) & 0xffff) { ! 513: ok += do_mem_probe(mm.base, mm.num, is_valid, do_cksum); ! 514: continue; ! 515: } ! 516: /* Special probe for 64K-aligned block */ ! 517: for (i = 0; i < 4; i++) { ! 518: b = order[i] << 12; ! 519: if ((b >= mm.base) && (b+0x10000 <= mm.base+mm.num)) { ! 520: if (ok >= mem_limit) ! 521: sub_interval(&mem_db, b, 0x10000); ! 522: else ! 523: ok += do_mem_probe(b, 0x10000, is_valid, do_cksum); ! 524: } ! 525: } ! 526: } ! 527: } ! 528: ! 529: #else /* CONFIG_ISA */ ! 530: ! 531: #define invalidate_mem() do { } while (0) ! 532: ! 533: void validate_mem(int (*is_valid)(u_long), int (*do_cksum)(u_long), ! 534: int force_low) ! 535: { ! 536: resource_map_t *m, *n; ! 537: static int done = 0; ! 538: ! 539: if (!probe_mem || done++) ! 540: return; ! 541: for (m = mem_db.next; m != &mem_db; m = n) ! 542: n = m->next; ! 543: if (do_mem_probe(m->base, m->num, is_valid, do_cksum)) ! 544: return; ! 545: } ! 546: ! 547: #endif /* CONFIG_ISA */ ! 548: ! 549: /*====================================================================== ! 550: ! 551: These find ranges of I/O ports or memory addresses that are not ! 552: currently allocated by other devices. ! 553: ! 554: The 'align' field should reflect the number of bits of address ! 555: that need to be preserved from the initial value of *base. It ! 556: should be a power of two, greater than or equal to 'num'. A value ! 557: of 0 means that all bits of *base are significant. *base should ! 558: also be strictly less than 'align'. ! 559: ! 560: ======================================================================*/ ! 561: ! 562: int find_io_region(ioaddr_t *base, ioaddr_t num, ioaddr_t align, ! 563: char *name) ! 564: { ! 565: ioaddr_t try; ! 566: resource_map_t *m; ! 567: ! 568: validate_io(); ! 569: for (m = io_db.next; m != &io_db; m = m->next) { ! 570: try = (m->base & ~(align-1)) + *base; ! 571: for (try = (try >= m->base) ? try : try+align; ! 572: (try >= m->base) && (try+num <= m->base+m->num); ! 573: try += align) { ! 574: if ((check_region(try, num) == 0) && ! 575: (check_io_region(try, num) == 0)) { ! 576: *base = try; ! 577: if (name) request_region(try, num, name); ! 578: return 0; ! 579: } ! 580: if (!align) break; ! 581: } ! 582: } ! 583: return -1; ! 584: } ! 585: ! 586: int find_mem_region(u_long *base, u_long num, u_long align, ! 587: int force_low, char *name) ! 588: { ! 589: u_long try; ! 590: resource_map_t *m; ! 591: ! 592: while (1) { ! 593: for (m = mem_db.next; m != &mem_db; m = m->next) { ! 594: /* first pass >1MB, second pass <1MB */ ! 595: if ((force_low != 0) ^ (m->base < 0x100000)) continue; ! 596: try = (m->base & ~(align-1)) + *base; ! 597: for (try = (try >= m->base) ? try : try+align; ! 598: (try >= m->base) && (try+num <= m->base+m->num); ! 599: try += align) { ! 600: if (check_mem_region(try, num) == 0) { ! 601: if (name) request_mem_region(try, num, name); ! 602: *base = try; ! 603: return 0; ! 604: } ! 605: if (!align) break; ! 606: } ! 607: } ! 608: if (force_low) break; ! 609: force_low++; ! 610: } ! 611: return -1; ! 612: } ! 613: ! 614: /*====================================================================== ! 615: ! 616: This checks to see if an interrupt is available, with support ! 617: for interrupt sharing. We don't support reserving interrupts ! 618: yet. If the interrupt is available, we allocate it. ! 619: ! 620: ======================================================================*/ ! 621: ! 622: #ifdef CONFIG_ISA ! 623: ! 624: static void fake_irq(int i, void *d, struct pt_regs *r) { } ! 625: static inline int check_irq(int irq) ! 626: { ! 627: if (request_irq(irq, fake_irq, 0, "bogus", NULL) != 0) ! 628: return -1; ! 629: free_irq(irq, NULL); ! 630: return 0; ! 631: } ! 632: ! 633: int try_irq(u_int Attributes, int irq, int specific) ! 634: { ! 635: irq_info_t *info = &irq_table[irq]; ! 636: if (info->Attributes & RES_ALLOCATED) { ! 637: switch (Attributes & IRQ_TYPE) { ! 638: case IRQ_TYPE_EXCLUSIVE: ! 639: return CS_IN_USE; ! 640: case IRQ_TYPE_TIME: ! 641: if ((info->Attributes & RES_IRQ_TYPE) ! 642: != RES_IRQ_TYPE_TIME) ! 643: return CS_IN_USE; ! 644: if (Attributes & IRQ_FIRST_SHARED) ! 645: return CS_BAD_ATTRIBUTE; ! 646: info->Attributes |= RES_IRQ_TYPE_TIME | RES_ALLOCATED; ! 647: info->time_share++; ! 648: break; ! 649: case IRQ_TYPE_DYNAMIC_SHARING: ! 650: if ((info->Attributes & RES_IRQ_TYPE) ! 651: != RES_IRQ_TYPE_DYNAMIC) ! 652: return CS_IN_USE; ! 653: if (Attributes & IRQ_FIRST_SHARED) ! 654: return CS_BAD_ATTRIBUTE; ! 655: info->Attributes |= RES_IRQ_TYPE_DYNAMIC | RES_ALLOCATED; ! 656: info->dyn_share++; ! 657: break; ! 658: } ! 659: } else { ! 660: if ((info->Attributes & RES_RESERVED) && !specific) ! 661: return CS_IN_USE; ! 662: if (check_irq(irq) != 0) ! 663: return CS_IN_USE; ! 664: switch (Attributes & IRQ_TYPE) { ! 665: case IRQ_TYPE_EXCLUSIVE: ! 666: info->Attributes |= RES_ALLOCATED; ! 667: break; ! 668: case IRQ_TYPE_TIME: ! 669: if (!(Attributes & IRQ_FIRST_SHARED)) ! 670: return CS_BAD_ATTRIBUTE; ! 671: info->Attributes |= RES_IRQ_TYPE_TIME | RES_ALLOCATED; ! 672: info->time_share = 1; ! 673: break; ! 674: case IRQ_TYPE_DYNAMIC_SHARING: ! 675: if (!(Attributes & IRQ_FIRST_SHARED)) ! 676: return CS_BAD_ATTRIBUTE; ! 677: info->Attributes |= RES_IRQ_TYPE_DYNAMIC | RES_ALLOCATED; ! 678: info->dyn_share = 1; ! 679: break; ! 680: } ! 681: } ! 682: return 0; ! 683: } ! 684: ! 685: #endif ! 686: ! 687: /*====================================================================*/ ! 688: ! 689: #ifdef CONFIG_ISA ! 690: ! 691: void undo_irq(u_int Attributes, int irq) ! 692: { ! 693: irq_info_t *info; ! 694: ! 695: info = &irq_table[irq]; ! 696: switch (Attributes & IRQ_TYPE) { ! 697: case IRQ_TYPE_EXCLUSIVE: ! 698: info->Attributes &= RES_RESERVED; ! 699: break; ! 700: case IRQ_TYPE_TIME: ! 701: info->time_share--; ! 702: if (info->time_share == 0) ! 703: info->Attributes &= RES_RESERVED; ! 704: break; ! 705: case IRQ_TYPE_DYNAMIC_SHARING: ! 706: info->dyn_share--; ! 707: if (info->dyn_share == 0) ! 708: info->Attributes &= RES_RESERVED; ! 709: break; ! 710: } ! 711: } ! 712: ! 713: #endif ! 714: ! 715: /*====================================================================== ! 716: ! 717: The various adjust_* calls form the external interface to the ! 718: resource database. ! 719: ! 720: ======================================================================*/ ! 721: ! 722: static int adjust_memory(adjust_t *adj) ! 723: { ! 724: u_long base, num; ! 725: int i, ret; ! 726: ! 727: base = adj->resource.memory.Base; ! 728: num = adj->resource.memory.Size; ! 729: if ((num == 0) || (base+num-1 < base)) ! 730: return CS_BAD_SIZE; ! 731: ! 732: ret = CS_SUCCESS; ! 733: switch (adj->Action) { ! 734: case ADD_MANAGED_RESOURCE: ! 735: ret = add_interval(&mem_db, base, num); ! 736: break; ! 737: case REMOVE_MANAGED_RESOURCE: ! 738: ret = sub_interval(&mem_db, base, num); ! 739: if (ret == CS_SUCCESS) { ! 740: invalidate_mem(); ! 741: for (i = 0; i < sockets; i++) { ! 742: release_cis_mem(socket_table[i]); ! 743: #ifdef CONFIG_CARDBUS ! 744: cb_release_cis_mem(socket_table[i]); ! 745: #endif ! 746: } ! 747: } ! 748: break; ! 749: default: ! 750: ret = CS_UNSUPPORTED_FUNCTION; ! 751: } ! 752: ! 753: return ret; ! 754: } ! 755: ! 756: /*====================================================================*/ ! 757: ! 758: static int adjust_io(adjust_t *adj) ! 759: { ! 760: int base, num; ! 761: ! 762: base = adj->resource.io.BasePort; ! 763: num = adj->resource.io.NumPorts; ! 764: if ((base < 0) || (base > 0xffff)) ! 765: return CS_BAD_BASE; ! 766: if ((num <= 0) || (base+num > 0x10000) || (base+num <= base)) ! 767: return CS_BAD_SIZE; ! 768: ! 769: switch (adj->Action) { ! 770: case ADD_MANAGED_RESOURCE: ! 771: if (add_interval(&io_db, base, num) != 0) ! 772: return CS_IN_USE; ! 773: break; ! 774: case REMOVE_MANAGED_RESOURCE: ! 775: sub_interval(&io_db, base, num); ! 776: invalidate_io(); ! 777: break; ! 778: default: ! 779: return CS_UNSUPPORTED_FUNCTION; ! 780: break; ! 781: } ! 782: ! 783: return CS_SUCCESS; ! 784: } ! 785: ! 786: /*====================================================================*/ ! 787: ! 788: static int adjust_irq(adjust_t *adj) ! 789: { ! 790: #ifdef CONFIG_ISA ! 791: int irq; ! 792: irq_info_t *info; ! 793: ! 794: irq = adj->resource.irq.IRQ; ! 795: if ((irq < 0) || (irq > 15)) ! 796: return CS_BAD_IRQ; ! 797: info = &irq_table[irq]; ! 798: ! 799: switch (adj->Action) { ! 800: case ADD_MANAGED_RESOURCE: ! 801: if (info->Attributes & RES_REMOVED) ! 802: info->Attributes &= ~(RES_REMOVED|RES_ALLOCATED); ! 803: else ! 804: if (adj->Attributes & RES_ALLOCATED) ! 805: return CS_IN_USE; ! 806: if (adj->Attributes & RES_RESERVED) ! 807: info->Attributes |= RES_RESERVED; ! 808: else ! 809: info->Attributes &= ~RES_RESERVED; ! 810: break; ! 811: case REMOVE_MANAGED_RESOURCE: ! 812: if (info->Attributes & RES_REMOVED) ! 813: return 0; ! 814: if (info->Attributes & RES_ALLOCATED) ! 815: return CS_IN_USE; ! 816: info->Attributes |= RES_ALLOCATED|RES_REMOVED; ! 817: info->Attributes &= ~RES_RESERVED; ! 818: break; ! 819: default: ! 820: return CS_UNSUPPORTED_FUNCTION; ! 821: break; ! 822: } ! 823: #endif ! 824: return CS_SUCCESS; ! 825: } ! 826: ! 827: /*====================================================================*/ ! 828: ! 829: int adjust_resource_info(client_handle_t handle, adjust_t *adj) ! 830: { ! 831: if (CHECK_HANDLE(handle)) ! 832: return CS_BAD_HANDLE; ! 833: ! 834: switch (adj->Resource) { ! 835: case RES_MEMORY_RANGE: ! 836: return adjust_memory(adj); ! 837: break; ! 838: case RES_IO_RANGE: ! 839: return adjust_io(adj); ! 840: break; ! 841: case RES_IRQ: ! 842: return adjust_irq(adj); ! 843: break; ! 844: } ! 845: return CS_UNSUPPORTED_FUNCTION; ! 846: } ! 847: ! 848: /*====================================================================*/ ! 849: ! 850: void release_resource_db(void) ! 851: { ! 852: resource_map_t *p, *q; ! 853: #if defined(CONFIG_PNP_BIOS) || !defined(HAVE_MEMRESERVE) ! 854: resource_entry_t *u, *v; ! 855: #endif ! 856: ! 857: for (p = mem_db.next; p != &mem_db; p = q) { ! 858: q = p->next; ! 859: kfree(p); ! 860: } ! 861: for (p = io_db.next; p != &io_db; p = q) { ! 862: q = p->next; ! 863: kfree(p); ! 864: } ! 865: #ifdef CONFIG_PNP_BIOS ! 866: for (u = io_list.next; u; u = v) { ! 867: v = u->next; ! 868: kfree(u); ! 869: } ! 870: #endif ! 871: #ifndef HAVE_MEMRESERVE ! 872: for (u = mem_list.next; u; u = v) { ! 873: v = u->next; ! 874: kfree(u); ! 875: } ! 876: #endif ! 877: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.