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