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