1 /* 2 * rsrc_nonstatic.c -- Resource management routines for !SS_CAP_STATIC_MAP sockets 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License version 2 as 6 * published by the Free Software Foundation. 7 * 8 * The initial developer of the original code is David A. Hinds 9 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds 10 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. 11 * 12 * (C) 1999 David A. Hinds 13 */ 14 15 #include <linux/module.h> 16 #include <linux/moduleparam.h> 17 #include <linux/init.h> 18 #include <linux/interrupt.h> 19 #include <linux/kernel.h> 20 #include <linux/errno.h> 21 #include <linux/types.h> 22 #include <linux/slab.h> 23 #include <linux/ioport.h> 24 #include <linux/timer.h> 25 #include <linux/pci.h> 26 #include <linux/device.h> 27 28 #include <asm/irq.h> 29 #include <asm/io.h> 30 31 #include <pcmcia/cs_types.h> 32 #include <pcmcia/ss.h> 33 #include <pcmcia/cs.h> 34 #include <pcmcia/bulkmem.h> 35 #include <pcmcia/cistpl.h> 36 #include "cs_internal.h" 37 38 MODULE_AUTHOR("David A. Hinds, Dominik Brodowski"); 39 MODULE_LICENSE("GPL"); 40 41 /* Parameters that can be set with 'insmod' */ 42 43 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444) 44 45 INT_MODULE_PARM(probe_mem, 1); /* memory probe? */ 46 #ifdef CONFIG_PCMCIA_PROBE 47 INT_MODULE_PARM(probe_io, 1); /* IO port probe? */ 48 INT_MODULE_PARM(mem_limit, 0x10000); 49 #endif 50 51 /* for io_db and mem_db */ 52 struct resource_map { 53 u_long base, num; 54 struct resource_map *next; 55 }; 56 57 struct socket_data { 58 struct resource_map mem_db; 59 struct resource_map io_db; 60 unsigned int rsrc_mem_probe; 61 }; 62 63 static DEFINE_MUTEX(rsrc_mutex); 64 #define MEM_PROBE_LOW (1 << 0) 65 #define MEM_PROBE_HIGH (1 << 1) 66 67 68 /*====================================================================== 69 70 Linux resource management extensions 71 72 ======================================================================*/ 73 74 static struct resource * 75 make_resource(resource_size_t b, resource_size_t n, int flags, char *name) 76 { 77 struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL); 78 79 if (res) { 80 res->name = name; 81 res->start = b; 82 res->end = b + n - 1; 83 res->flags = flags; 84 } 85 return res; 86 } 87 88 static struct resource * 89 claim_region(struct pcmcia_socket *s, resource_size_t base, 90 resource_size_t size, int type, char *name) 91 { 92 struct resource *res, *parent; 93 94 parent = type & IORESOURCE_MEM ? &iomem_resource : &ioport_resource; 95 res = make_resource(base, size, type | IORESOURCE_BUSY, name); 96 97 if (res) { 98 #ifdef CONFIG_PCI 99 if (s && s->cb_dev) 100 parent = pci_find_parent_resource(s->cb_dev, res); 101 #endif 102 if (!parent || request_resource(parent, res)) { 103 kfree(res); 104 res = NULL; 105 } 106 } 107 return res; 108 } 109 110 static void free_region(struct resource *res) 111 { 112 if (res) { 113 release_resource(res); 114 kfree(res); 115 } 116 } 117 118 /*====================================================================== 119 120 These manage the internal databases of available resources. 121 122 ======================================================================*/ 123 124 static int add_interval(struct resource_map *map, u_long base, u_long num) 125 { 126 struct resource_map *p, *q; 127 128 for (p = map; ; p = p->next) { 129 if ((p != map) && (p->base+p->num-1 >= base)) 130 return -1; 131 if ((p->next == map) || (p->next->base > base+num-1)) 132 break; 133 } 134 q = kmalloc(sizeof(struct resource_map), GFP_KERNEL); 135 if (!q) return CS_OUT_OF_RESOURCE; 136 q->base = base; q->num = num; 137 q->next = p->next; p->next = q; 138 return CS_SUCCESS; 139 } 140 141 /*====================================================================*/ 142 143 static int sub_interval(struct resource_map *map, u_long base, u_long num) 144 { 145 struct resource_map *p, *q; 146 147 for (p = map; ; p = q) { 148 q = p->next; 149 if (q == map) 150 break; 151 if ((q->base+q->num > base) && (base+num > q->base)) { 152 if (q->base >= base) { 153 if (q->base+q->num <= base+num) { 154 /* Delete whole block */ 155 p->next = q->next; 156 kfree(q); 157 /* don't advance the pointer yet */ 158 q = p; 159 } else { 160 /* Cut off bit from the front */ 161 q->num = q->base + q->num - base - num; 162 q->base = base + num; 163 } 164 } else if (q->base+q->num <= base+num) { 165 /* Cut off bit from the end */ 166 q->num = base - q->base; 167 } else { 168 /* Split the block into two pieces */ 169 p = kmalloc(sizeof(struct resource_map), GFP_KERNEL); 170 if (!p) return CS_OUT_OF_RESOURCE; 171 p->base = base+num; 172 p->num = q->base+q->num - p->base; 173 q->num = base - q->base; 174 p->next = q->next ; q->next = p; 175 } 176 } 177 } 178 return CS_SUCCESS; 179 } 180 181 /*====================================================================== 182 183 These routines examine a region of IO or memory addresses to 184 determine what ranges might be genuinely available. 185 186 ======================================================================*/ 187 188 #ifdef CONFIG_PCMCIA_PROBE 189 static void do_io_probe(struct pcmcia_socket *s, unsigned int base, 190 unsigned int num) 191 { 192 struct resource *res; 193 struct socket_data *s_data = s->resource_data; 194 unsigned int i, j, bad; 195 int any; 196 u_char *b, hole, most; 197 198 printk(KERN_INFO "cs: IO port probe %#x-%#x:", 199 base, base+num-1); 200 201 /* First, what does a floating port look like? */ 202 b = kzalloc(256, GFP_KERNEL); 203 if (!b) { 204 printk(KERN_ERR "do_io_probe: unable to kmalloc 256 bytes"); 205 return; 206 } 207 for (i = base, most = 0; i < base+num; i += 8) { 208 res = claim_region(NULL, i, 8, IORESOURCE_IO, "PCMCIA IO probe"); 209 if (!res) 210 continue; 211 hole = inb(i); 212 for (j = 1; j < 8; j++) 213 if (inb(i+j) != hole) break; 214 free_region(res); 215 if ((j == 8) && (++b[hole] > b[most])) 216 most = hole; 217 if (b[most] == 127) break; 218 } 219 kfree(b); 220 221 bad = any = 0; 222 for (i = base; i < base+num; i += 8) { 223 res = claim_region(NULL, i, 8, IORESOURCE_IO, "PCMCIA IO probe"); 224 if (!res) 225 continue; 226 for (j = 0; j < 8; j++) 227 if (inb(i+j) != most) break; 228 free_region(res); 229 if (j < 8) { 230 if (!any) 231 printk(" excluding"); 232 if (!bad) 233 bad = any = i; 234 } else { 235 if (bad) { 236 sub_interval(&s_data->io_db, bad, i-bad); 237 printk(" %#x-%#x", bad, i-1); 238 bad = 0; 239 } 240 } 241 } 242 if (bad) { 243 if ((num > 16) && (bad == base) && (i == base+num)) { 244 printk(" nothing: probe failed.\n"); 245 return; 246 } else { 247 sub_interval(&s_data->io_db, bad, i-bad); 248 printk(" %#x-%#x", bad, i-1); 249 } 250 } 251 252 printk(any ? "\n" : " clean.\n"); 253 } 254 #endif 255 256 /*====================================================================== 257 258 This is tricky... when we set up CIS memory, we try to validate 259 the memory window space allocations. 260 261 ======================================================================*/ 262 263 /* Validation function for cards with a valid CIS */ 264 static int readable(struct pcmcia_socket *s, struct resource *res, cisinfo_t *info) 265 { 266 int ret = -1; 267 268 s->cis_mem.res = res; 269 s->cis_virt = ioremap(res->start, s->map_size); 270 if (s->cis_virt) { 271 ret = pccard_validate_cis(s, BIND_FN_ALL, info); 272 /* invalidate mapping and CIS cache */ 273 iounmap(s->cis_virt); 274 s->cis_virt = NULL; 275 destroy_cis_cache(s); 276 } 277 s->cis_mem.res = NULL; 278 if ((ret != 0) || (info->Chains == 0)) 279 return 0; 280 return 1; 281 } 282 283 /* Validation function for simple memory cards */ 284 static int checksum(struct pcmcia_socket *s, struct resource *res) 285 { 286 pccard_mem_map map; 287 int i, a = 0, b = -1, d; 288 void __iomem *virt; 289 290 virt = ioremap(res->start, s->map_size); 291 if (virt) { 292 map.map = 0; 293 map.flags = MAP_ACTIVE; 294 map.speed = 0; 295 map.res = res; 296 map.card_start = 0; 297 s->ops->set_mem_map(s, &map); 298 299 /* Don't bother checking every word... */ 300 for (i = 0; i < s->map_size; i += 44) { 301 d = readl(virt+i); 302 a += d; 303 b &= d; 304 } 305 306 map.flags = 0; 307 s->ops->set_mem_map(s, &map); 308 309 iounmap(virt); 310 } 311 312 return (b == -1) ? -1 : (a>>1); 313 } 314 315 static int 316 cis_readable(struct pcmcia_socket *s, unsigned long base, unsigned long size) 317 { 318 struct resource *res1, *res2; 319 cisinfo_t info1, info2; 320 int ret = 0; 321 322 res1 = claim_region(s, base, size/2, IORESOURCE_MEM, "cs memory probe"); 323 res2 = claim_region(s, base + size/2, size/2, IORESOURCE_MEM, "cs memory probe"); 324 325 if (res1 && res2) { 326 ret = readable(s, res1, &info1); 327 ret += readable(s, res2, &info2); 328 } 329 330 free_region(res2); 331 free_region(res1); 332 333 return (ret == 2) && (info1.Chains == info2.Chains); 334 } 335 336 static int 337 checksum_match(struct pcmcia_socket *s, unsigned long base, unsigned long size) 338 { 339 struct resource *res1, *res2; 340 int a = -1, b = -1; 341 342 res1 = claim_region(s, base, size/2, IORESOURCE_MEM, "cs memory probe"); 343 res2 = claim_region(s, base + size/2, size/2, IORESOURCE_MEM, "cs memory probe"); 344 345 if (res1 && res2) { 346 a = checksum(s, res1); 347 b = checksum(s, res2); 348 } 349 350 free_region(res2); 351 free_region(res1); 352 353 return (a == b) && (a >= 0); 354 } 355 356 /*====================================================================== 357 358 The memory probe. If the memory list includes a 64K-aligned block 359 below 1MB, we probe in 64K chunks, and as soon as we accumulate at 360 least mem_limit free space, we quit. 361 362 ======================================================================*/ 363 364 static int do_mem_probe(u_long base, u_long num, struct pcmcia_socket *s) 365 { 366 struct socket_data *s_data = s->resource_data; 367 u_long i, j, bad, fail, step; 368 369 printk(KERN_INFO "cs: memory probe 0x%06lx-0x%06lx:", 370 base, base+num-1); 371 bad = fail = 0; 372 step = (num < 0x20000) ? 0x2000 : ((num>>4) & ~0x1fff); 373 /* don't allow too large steps */ 374 if (step > 0x800000) 375 step = 0x800000; 376 /* cis_readable wants to map 2x map_size */ 377 if (step < 2 * s->map_size) 378 step = 2 * s->map_size; 379 for (i = j = base; i < base+num; i = j + step) { 380 if (!fail) { 381 for (j = i; j < base+num; j += step) { 382 if (cis_readable(s, j, step)) 383 break; 384 } 385 fail = ((i == base) && (j == base+num)); 386 } 387 if (fail) { 388 for (j = i; j < base+num; j += 2*step) 389 if (checksum_match(s, j, step) && 390 checksum_match(s, j + step, step)) 391 break; 392 } 393 if (i != j) { 394 if (!bad) printk(" excluding"); 395 printk(" %#05lx-%#05lx", i, j-1); 396 sub_interval(&s_data->mem_db, i, j-i); 397 bad += j-i; 398 } 399 } 400 printk(bad ? "\n" : " clean.\n"); 401 return (num - bad); 402 } 403 404 #ifdef CONFIG_PCMCIA_PROBE 405 406 static u_long inv_probe(struct resource_map *m, struct pcmcia_socket *s) 407 { 408 struct socket_data *s_data = s->resource_data; 409 u_long ok; 410 if (m == &s_data->mem_db) 411 return 0; 412 ok = inv_probe(m->next, s); 413 if (ok) { 414 if (m->base >= 0x100000) 415 sub_interval(&s_data->mem_db, m->base, m->num); 416 return ok; 417 } 418 if (m->base < 0x100000) 419 return 0; 420 return do_mem_probe(m->base, m->num, s); 421 } 422 423 static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask) 424 { 425 struct resource_map *m, mm; 426 static unsigned char order[] = { 0xd0, 0xe0, 0xc0, 0xf0 }; 427 unsigned long b, i, ok = 0; 428 struct socket_data *s_data = s->resource_data; 429 430 /* We do up to four passes through the list */ 431 if (probe_mask & MEM_PROBE_HIGH) { 432 if (inv_probe(s_data->mem_db.next, s) > 0) 433 return 0; 434 printk(KERN_NOTICE "cs: warning: no high memory space " 435 "available!\n"); 436 return -ENODEV; 437 } 438 439 for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) { 440 mm = *m; 441 /* Only probe < 1 MB */ 442 if (mm.base >= 0x100000) 443 continue; 444 if ((mm.base | mm.num) & 0xffff) { 445 ok += do_mem_probe(mm.base, mm.num, s); 446 continue; 447 } 448 /* Special probe for 64K-aligned block */ 449 for (i = 0; i < 4; i++) { 450 b = order[i] << 12; 451 if ((b >= mm.base) && (b+0x10000 <= mm.base+mm.num)) { 452 if (ok >= mem_limit) 453 sub_interval(&s_data->mem_db, b, 0x10000); 454 else 455 ok += do_mem_probe(b, 0x10000, s); 456 } 457 } 458 } 459 460 if (ok > 0) 461 return 0; 462 463 return -ENODEV; 464 } 465 466 #else /* CONFIG_PCMCIA_PROBE */ 467 468 static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask) 469 { 470 struct resource_map *m, mm; 471 struct socket_data *s_data = s->resource_data; 472 unsigned long ok = 0; 473 474 for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) { 475 mm = *m; 476 ok += do_mem_probe(mm.base, mm.num, s); 477 } 478 if (ok > 0) 479 return 0; 480 return -ENODEV; 481 } 482 483 #endif /* CONFIG_PCMCIA_PROBE */ 484 485 486 /* 487 * Locking note: Must be called with skt_mutex held! 488 */ 489 static int pcmcia_nonstatic_validate_mem(struct pcmcia_socket *s) 490 { 491 struct socket_data *s_data = s->resource_data; 492 unsigned int probe_mask = MEM_PROBE_LOW; 493 int ret = 0; 494 495 if (!probe_mem) 496 return 0; 497 498 mutex_lock(&rsrc_mutex); 499 500 if (s->features & SS_CAP_PAGE_REGS) 501 probe_mask = MEM_PROBE_HIGH; 502 503 if (probe_mask & ~s_data->rsrc_mem_probe) { 504 if (s->state & SOCKET_PRESENT) 505 ret = validate_mem(s, probe_mask); 506 if (!ret) 507 s_data->rsrc_mem_probe |= probe_mask; 508 } 509 510 mutex_unlock(&rsrc_mutex); 511 512 return ret; 513 } 514 515 struct pcmcia_align_data { 516 unsigned long mask; 517 unsigned long offset; 518 struct resource_map *map; 519 }; 520 521 static void 522 pcmcia_common_align(void *align_data, struct resource *res, 523 resource_size_t size, resource_size_t align) 524 { 525 struct pcmcia_align_data *data = align_data; 526 resource_size_t start; 527 /* 528 * Ensure that we have the correct start address 529 */ 530 start = (res->start & ~data->mask) + data->offset; 531 if (start < res->start) 532 start += data->mask + 1; 533 res->start = start; 534 } 535 536 static void 537 pcmcia_align(void *align_data, struct resource *res, resource_size_t size, 538 resource_size_t align) 539 { 540 struct pcmcia_align_data *data = align_data; 541 struct resource_map *m; 542 543 pcmcia_common_align(data, res, size, align); 544 545 for (m = data->map->next; m != data->map; m = m->next) { 546 unsigned long start = m->base; 547 unsigned long end = m->base + m->num - 1; 548 549 /* 550 * If the lower resources are not available, try aligning 551 * to this entry of the resource database to see if it'll 552 * fit here. 553 */ 554 if (res->start < start) { 555 res->start = start; 556 pcmcia_common_align(data, res, size, align); 557 } 558 559 /* 560 * If we're above the area which was passed in, there's 561 * no point proceeding. 562 */ 563 if (res->start >= res->end) 564 break; 565 566 if ((res->start + size - 1) <= end) 567 break; 568 } 569 570 /* 571 * If we failed to find something suitable, ensure we fail. 572 */ 573 if (m == data->map) 574 res->start = res->end; 575 } 576 577 /* 578 * Adjust an existing IO region allocation, but making sure that we don't 579 * encroach outside the resources which the user supplied. 580 */ 581 static int nonstatic_adjust_io_region(struct resource *res, unsigned long r_start, 582 unsigned long r_end, struct pcmcia_socket *s) 583 { 584 struct resource_map *m; 585 struct socket_data *s_data = s->resource_data; 586 int ret = -ENOMEM; 587 588 mutex_lock(&rsrc_mutex); 589 for (m = s_data->io_db.next; m != &s_data->io_db; m = m->next) { 590 unsigned long start = m->base; 591 unsigned long end = m->base + m->num - 1; 592 593 if (start > r_start || r_end > end) 594 continue; 595 596 ret = adjust_resource(res, r_start, r_end - r_start + 1); 597 break; 598 } 599 mutex_unlock(&rsrc_mutex); 600 601 return ret; 602 } 603 604 /*====================================================================== 605 606 These find ranges of I/O ports or memory addresses that are not 607 currently allocated by other devices. 608 609 The 'align' field should reflect the number of bits of address 610 that need to be preserved from the initial value of *base. It 611 should be a power of two, greater than or equal to 'num'. A value 612 of 0 means that all bits of *base are significant. *base should 613 also be strictly less than 'align'. 614 615 ======================================================================*/ 616 617 static struct resource *nonstatic_find_io_region(unsigned long base, int num, 618 unsigned long align, struct pcmcia_socket *s) 619 { 620 struct resource *res = make_resource(0, num, IORESOURCE_IO, s->dev.bus_id); 621 struct socket_data *s_data = s->resource_data; 622 struct pcmcia_align_data data; 623 unsigned long min = base; 624 int ret; 625 626 if (align == 0) 627 align = 0x10000; 628 629 data.mask = align - 1; 630 data.offset = base & data.mask; 631 data.map = &s_data->io_db; 632 633 mutex_lock(&rsrc_mutex); 634 #ifdef CONFIG_PCI 635 if (s->cb_dev) { 636 ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num, 1, 637 min, 0, pcmcia_align, &data); 638 } else 639 #endif 640 ret = allocate_resource(&ioport_resource, res, num, min, ~0UL, 641 1, pcmcia_align, &data); 642 mutex_unlock(&rsrc_mutex); 643 644 if (ret != 0) { 645 kfree(res); 646 res = NULL; 647 } 648 return res; 649 } 650 651 static struct resource * nonstatic_find_mem_region(u_long base, u_long num, 652 u_long align, int low, struct pcmcia_socket *s) 653 { 654 struct resource *res = make_resource(0, num, IORESOURCE_MEM, s->dev.bus_id); 655 struct socket_data *s_data = s->resource_data; 656 struct pcmcia_align_data data; 657 unsigned long min, max; 658 int ret, i; 659 660 low = low || !(s->features & SS_CAP_PAGE_REGS); 661 662 data.mask = align - 1; 663 data.offset = base & data.mask; 664 data.map = &s_data->mem_db; 665 666 for (i = 0; i < 2; i++) { 667 if (low) { 668 max = 0x100000UL; 669 min = base < max ? base : 0; 670 } else { 671 max = ~0UL; 672 min = 0x100000UL + base; 673 } 674 675 mutex_lock(&rsrc_mutex); 676 #ifdef CONFIG_PCI 677 if (s->cb_dev) { 678 ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num, 679 1, min, 0, 680 pcmcia_align, &data); 681 } else 682 #endif 683 ret = allocate_resource(&iomem_resource, res, num, min, 684 max, 1, pcmcia_align, &data); 685 mutex_unlock(&rsrc_mutex); 686 if (ret == 0 || low) 687 break; 688 low = 1; 689 } 690 691 if (ret != 0) { 692 kfree(res); 693 res = NULL; 694 } 695 return res; 696 } 697 698 699 static int adjust_memory(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end) 700 { 701 struct socket_data *data = s->resource_data; 702 unsigned long size = end - start + 1; 703 int ret = 0; 704 705 if (end < start) 706 return -EINVAL; 707 708 mutex_lock(&rsrc_mutex); 709 switch (action) { 710 case ADD_MANAGED_RESOURCE: 711 ret = add_interval(&data->mem_db, start, size); 712 break; 713 case REMOVE_MANAGED_RESOURCE: 714 ret = sub_interval(&data->mem_db, start, size); 715 if (!ret) { 716 struct pcmcia_socket *socket; 717 down_read(&pcmcia_socket_list_rwsem); 718 list_for_each_entry(socket, &pcmcia_socket_list, socket_list) 719 release_cis_mem(socket); 720 up_read(&pcmcia_socket_list_rwsem); 721 } 722 break; 723 default: 724 ret = -EINVAL; 725 } 726 mutex_unlock(&rsrc_mutex); 727 728 return ret; 729 } 730 731 732 static int adjust_io(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end) 733 { 734 struct socket_data *data = s->resource_data; 735 unsigned long size = end - start + 1; 736 int ret = 0; 737 738 if (end < start) 739 return -EINVAL; 740 741 if (end > IO_SPACE_LIMIT) 742 return -EINVAL; 743 744 mutex_lock(&rsrc_mutex); 745 switch (action) { 746 case ADD_MANAGED_RESOURCE: 747 if (add_interval(&data->io_db, start, size) != 0) { 748 ret = -EBUSY; 749 break; 750 } 751 #ifdef CONFIG_PCMCIA_PROBE 752 if (probe_io) 753 do_io_probe(s, start, size); 754 #endif 755 break; 756 case REMOVE_MANAGED_RESOURCE: 757 sub_interval(&data->io_db, start, size); 758 break; 759 default: 760 ret = -EINVAL; 761 break; 762 } 763 mutex_unlock(&rsrc_mutex); 764 765 return ret; 766 } 767 768 769 static int nonstatic_adjust_resource_info(struct pcmcia_socket *s, adjust_t *adj) 770 { 771 unsigned long end; 772 773 switch (adj->Resource) { 774 case RES_MEMORY_RANGE: 775 end = adj->resource.memory.Base + adj->resource.memory.Size - 1; 776 return adjust_memory(s, adj->Action, adj->resource.memory.Base, end); 777 case RES_IO_RANGE: 778 end = adj->resource.io.BasePort + adj->resource.io.NumPorts - 1; 779 return adjust_io(s, adj->Action, adj->resource.io.BasePort, end); 780 } 781 return CS_UNSUPPORTED_FUNCTION; 782 } 783 784 #ifdef CONFIG_PCI 785 static int nonstatic_autoadd_resources(struct pcmcia_socket *s) 786 { 787 struct resource *res; 788 int i, done = 0; 789 790 if (!s->cb_dev || !s->cb_dev->bus) 791 return -ENODEV; 792 793 #if defined(CONFIG_X86) 794 /* If this is the root bus, the risk of hitting 795 * some strange system devices which aren't protected 796 * by either ACPI resource tables or properly requested 797 * resources is too big. Therefore, don't do auto-adding 798 * of resources at the moment. 799 */ 800 if (s->cb_dev->bus->number == 0) 801 return -EINVAL; 802 #endif 803 804 for (i=0; i < PCI_BUS_NUM_RESOURCES; i++) { 805 res = s->cb_dev->bus->resource[i]; 806 if (!res) 807 continue; 808 809 if (res->flags & IORESOURCE_IO) { 810 if (res == &ioport_resource) 811 continue; 812 printk(KERN_INFO "pcmcia: parent PCI bridge I/O " 813 "window: 0x%llx - 0x%llx\n", 814 (unsigned long long)res->start, 815 (unsigned long long)res->end); 816 if (!adjust_io(s, ADD_MANAGED_RESOURCE, res->start, res->end)) 817 done |= IORESOURCE_IO; 818 819 } 820 821 if (res->flags & IORESOURCE_MEM) { 822 if (res == &iomem_resource) 823 continue; 824 printk(KERN_INFO "pcmcia: parent PCI bridge Memory " 825 "window: 0x%llx - 0x%llx\n", 826 (unsigned long long)res->start, 827 (unsigned long long)res->end); 828 if (!adjust_memory(s, ADD_MANAGED_RESOURCE, res->start, res->end)) 829 done |= IORESOURCE_MEM; 830 } 831 } 832 833 /* if we got at least one of IO, and one of MEM, we can be glad and 834 * activate the PCMCIA subsystem */ 835 if (done == (IORESOURCE_MEM | IORESOURCE_IO)) 836 s->resource_setup_done = 1; 837 838 return 0; 839 } 840 841 #else 842 843 static inline int nonstatic_autoadd_resources(struct pcmcia_socket *s) 844 { 845 return -ENODEV; 846 } 847 848 #endif 849 850 851 static int nonstatic_init(struct pcmcia_socket *s) 852 { 853 struct socket_data *data; 854 855 data = kzalloc(sizeof(struct socket_data), GFP_KERNEL); 856 if (!data) 857 return -ENOMEM; 858 859 data->mem_db.next = &data->mem_db; 860 data->io_db.next = &data->io_db; 861 862 s->resource_data = (void *) data; 863 864 nonstatic_autoadd_resources(s); 865 866 return 0; 867 } 868 869 static void nonstatic_release_resource_db(struct pcmcia_socket *s) 870 { 871 struct socket_data *data = s->resource_data; 872 struct resource_map *p, *q; 873 874 mutex_lock(&rsrc_mutex); 875 for (p = data->mem_db.next; p != &data->mem_db; p = q) { 876 q = p->next; 877 kfree(p); 878 } 879 for (p = data->io_db.next; p != &data->io_db; p = q) { 880 q = p->next; 881 kfree(p); 882 } 883 mutex_unlock(&rsrc_mutex); 884 } 885 886 887 struct pccard_resource_ops pccard_nonstatic_ops = { 888 .validate_mem = pcmcia_nonstatic_validate_mem, 889 .adjust_io_region = nonstatic_adjust_io_region, 890 .find_io = nonstatic_find_io_region, 891 .find_mem = nonstatic_find_mem_region, 892 .adjust_resource = nonstatic_adjust_resource_info, 893 .init = nonstatic_init, 894 .exit = nonstatic_release_resource_db, 895 }; 896 EXPORT_SYMBOL(pccard_nonstatic_ops); 897 898 899 /* sysfs interface to the resource database */ 900 901 static ssize_t show_io_db(struct device *dev, 902 struct device_attribute *attr, char *buf) 903 { 904 struct pcmcia_socket *s = dev_get_drvdata(dev); 905 struct socket_data *data; 906 struct resource_map *p; 907 ssize_t ret = 0; 908 909 mutex_lock(&rsrc_mutex); 910 data = s->resource_data; 911 912 for (p = data->io_db.next; p != &data->io_db; p = p->next) { 913 if (ret > (PAGE_SIZE - 10)) 914 continue; 915 ret += snprintf (&buf[ret], (PAGE_SIZE - ret - 1), 916 "0x%08lx - 0x%08lx\n", 917 ((unsigned long) p->base), 918 ((unsigned long) p->base + p->num - 1)); 919 } 920 921 mutex_unlock(&rsrc_mutex); 922 return (ret); 923 } 924 925 static ssize_t store_io_db(struct device *dev, 926 struct device_attribute *attr, 927 const char *buf, size_t count) 928 { 929 struct pcmcia_socket *s = dev_get_drvdata(dev); 930 unsigned long start_addr, end_addr; 931 unsigned int add = ADD_MANAGED_RESOURCE; 932 ssize_t ret = 0; 933 934 ret = sscanf (buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr); 935 if (ret != 2) { 936 ret = sscanf (buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr); 937 add = REMOVE_MANAGED_RESOURCE; 938 if (ret != 2) { 939 ret = sscanf (buf, "0x%lx - 0x%lx", &start_addr, &end_addr); 940 add = ADD_MANAGED_RESOURCE; 941 if (ret != 2) 942 return -EINVAL; 943 } 944 } 945 if (end_addr < start_addr) 946 return -EINVAL; 947 948 ret = adjust_io(s, add, start_addr, end_addr); 949 if (!ret) 950 s->resource_setup_new = 1; 951 952 return ret ? ret : count; 953 } 954 static DEVICE_ATTR(available_resources_io, 0600, show_io_db, store_io_db); 955 956 static ssize_t show_mem_db(struct device *dev, 957 struct device_attribute *attr, char *buf) 958 { 959 struct pcmcia_socket *s = dev_get_drvdata(dev); 960 struct socket_data *data; 961 struct resource_map *p; 962 ssize_t ret = 0; 963 964 mutex_lock(&rsrc_mutex); 965 data = s->resource_data; 966 967 for (p = data->mem_db.next; p != &data->mem_db; p = p->next) { 968 if (ret > (PAGE_SIZE - 10)) 969 continue; 970 ret += snprintf (&buf[ret], (PAGE_SIZE - ret - 1), 971 "0x%08lx - 0x%08lx\n", 972 ((unsigned long) p->base), 973 ((unsigned long) p->base + p->num - 1)); 974 } 975 976 mutex_unlock(&rsrc_mutex); 977 return (ret); 978 } 979 980 static ssize_t store_mem_db(struct device *dev, 981 struct device_attribute *attr, 982 const char *buf, size_t count) 983 { 984 struct pcmcia_socket *s = dev_get_drvdata(dev); 985 unsigned long start_addr, end_addr; 986 unsigned int add = ADD_MANAGED_RESOURCE; 987 ssize_t ret = 0; 988 989 ret = sscanf (buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr); 990 if (ret != 2) { 991 ret = sscanf (buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr); 992 add = REMOVE_MANAGED_RESOURCE; 993 if (ret != 2) { 994 ret = sscanf (buf, "0x%lx - 0x%lx", &start_addr, &end_addr); 995 add = ADD_MANAGED_RESOURCE; 996 if (ret != 2) 997 return -EINVAL; 998 } 999 } 1000 if (end_addr < start_addr) 1001 return -EINVAL; 1002 1003 ret = adjust_memory(s, add, start_addr, end_addr); 1004 if (!ret) 1005 s->resource_setup_new = 1; 1006 1007 return ret ? ret : count; 1008 } 1009 static DEVICE_ATTR(available_resources_mem, 0600, show_mem_db, store_mem_db); 1010 1011 static struct device_attribute *pccard_rsrc_attributes[] = { 1012 &dev_attr_available_resources_io, 1013 &dev_attr_available_resources_mem, 1014 NULL, 1015 }; 1016 1017 static int __devinit pccard_sysfs_add_rsrc(struct device *dev, 1018 struct class_interface *class_intf) 1019 { 1020 struct pcmcia_socket *s = dev_get_drvdata(dev); 1021 struct device_attribute **attr; 1022 int ret = 0; 1023 if (s->resource_ops != &pccard_nonstatic_ops) 1024 return 0; 1025 1026 for (attr = pccard_rsrc_attributes; *attr; attr++) { 1027 ret = device_create_file(dev, *attr); 1028 if (ret) 1029 break; 1030 } 1031 1032 return ret; 1033 } 1034 1035 static void __devexit pccard_sysfs_remove_rsrc(struct device *dev, 1036 struct class_interface *class_intf) 1037 { 1038 struct pcmcia_socket *s = dev_get_drvdata(dev); 1039 struct device_attribute **attr; 1040 1041 if (s->resource_ops != &pccard_nonstatic_ops) 1042 return; 1043 1044 for (attr = pccard_rsrc_attributes; *attr; attr++) 1045 device_remove_file(dev, *attr); 1046 } 1047 1048 static struct class_interface pccard_rsrc_interface = { 1049 .class = &pcmcia_socket_class, 1050 .add_dev = &pccard_sysfs_add_rsrc, 1051 .remove_dev = __devexit_p(&pccard_sysfs_remove_rsrc), 1052 }; 1053 1054 static int __init nonstatic_sysfs_init(void) 1055 { 1056 return class_interface_register(&pccard_rsrc_interface); 1057 } 1058 1059 static void __exit nonstatic_sysfs_exit(void) 1060 { 1061 class_interface_unregister(&pccard_rsrc_interface); 1062 } 1063 1064 module_init(nonstatic_sysfs_init); 1065 module_exit(nonstatic_sysfs_exit); 1066