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