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