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/ss.h> 32#include <pcmcia/cistpl.h> 33#include "cs_internal.h" 34 35/* moved to rsrc_mgr.c 36MODULE_AUTHOR("David A. Hinds, Dominik Brodowski"); 37MODULE_LICENSE("GPL"); 38*/ 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 44INT_MODULE_PARM(probe_mem, 1); /* memory probe? */ 45#ifdef CONFIG_PCMCIA_PROBE 46INT_MODULE_PARM(probe_io, 1); /* IO port probe? */ 47INT_MODULE_PARM(mem_limit, 0x10000); 48#endif 49 50/* for io_db and mem_db */ 51struct resource_map { 52 u_long base, num; 53 struct resource_map *next; 54}; 55 56struct socket_data { 57 struct resource_map mem_db; 58 struct resource_map mem_db_valid; 59 struct resource_map io_db; 60}; 61 62#define MEM_PROBE_LOW (1 << 0) 63#define MEM_PROBE_HIGH (1 << 1) 64 65/* Action field */ 66#define REMOVE_MANAGED_RESOURCE 1 67#define ADD_MANAGED_RESOURCE 2 68 69/*====================================================================== 70 71 Linux resource management extensions 72 73======================================================================*/ 74 75static struct resource * 76claim_region(struct pcmcia_socket *s, resource_size_t base, 77 resource_size_t size, int type, char *name) 78{ 79 struct resource *res, *parent; 80 81 parent = type & IORESOURCE_MEM ? &iomem_resource : &ioport_resource; 82 res = pcmcia_make_resource(base, size, type | IORESOURCE_BUSY, name); 83 84 if (res) { 85#ifdef CONFIG_PCI 86 if (s && s->cb_dev) 87 parent = pci_find_parent_resource(s->cb_dev, res); 88#endif 89 if (!parent || request_resource(parent, res)) { 90 kfree(res); 91 res = NULL; 92 } 93 } 94 return res; 95} 96 97static void free_region(struct resource *res) 98{ 99 if (res) { 100 release_resource(res); 101 kfree(res); 102 } 103} 104 105/*====================================================================== 106 107 These manage the internal databases of available resources. 108 109======================================================================*/ 110 111static int add_interval(struct resource_map *map, u_long base, u_long num) 112{ 113 struct resource_map *p, *q; 114 115 for (p = map; ; p = p->next) { 116 if ((p != map) && (p->base+p->num >= base)) { 117 p->num = max(num + base - p->base, p->num); 118 return 0; 119 } 120 if ((p->next == map) || (p->next->base > base+num-1)) 121 break; 122 } 123 q = kmalloc(sizeof(struct resource_map), GFP_KERNEL); 124 if (!q) { 125 printk(KERN_WARNING "out of memory to update resources\n"); 126 return -ENOMEM; 127 } 128 q->base = base; q->num = num; 129 q->next = p->next; p->next = q; 130 return 0; 131} 132 133/*====================================================================*/ 134 135static int sub_interval(struct resource_map *map, u_long base, u_long num) 136{ 137 struct resource_map *p, *q; 138 139 for (p = map; ; p = q) { 140 q = p->next; 141 if (q == map) 142 break; 143 if ((q->base+q->num > base) && (base+num > q->base)) { 144 if (q->base >= base) { 145 if (q->base+q->num <= base+num) { 146 /* Delete whole block */ 147 p->next = q->next; 148 kfree(q); 149 /* don't advance the pointer yet */ 150 q = p; 151 } else { 152 /* Cut off bit from the front */ 153 q->num = q->base + q->num - base - num; 154 q->base = base + num; 155 } 156 } else if (q->base+q->num <= base+num) { 157 /* Cut off bit from the end */ 158 q->num = base - q->base; 159 } else { 160 /* Split the block into two pieces */ 161 p = kmalloc(sizeof(struct resource_map), 162 GFP_KERNEL); 163 if (!p) { 164 printk(KERN_WARNING "out of memory to update resources\n"); 165 return -ENOMEM; 166 } 167 p->base = base+num; 168 p->num = q->base+q->num - p->base; 169 q->num = base - q->base; 170 p->next = q->next ; q->next = p; 171 } 172 } 173 } 174 return 0; 175} 176 177/*====================================================================== 178 179 These routines examine a region of IO or memory addresses to 180 determine what ranges might be genuinely available. 181 182======================================================================*/ 183 184#ifdef CONFIG_PCMCIA_PROBE 185static void do_io_probe(struct pcmcia_socket *s, unsigned int base, 186 unsigned int num) 187{ 188 struct resource *res; 189 struct socket_data *s_data = s->resource_data; 190 unsigned int i, j, bad; 191 int any; 192 u_char *b, hole, most; 193 194 dev_printk(KERN_INFO, &s->dev, "cs: IO port probe %#x-%#x:", 195 base, base+num-1); 196 197 /* First, what does a floating port look like? */ 198 b = kzalloc(256, GFP_KERNEL); 199 if (!b) { 200 printk("\n"); 201 dev_printk(KERN_ERR, &s->dev, 202 "do_io_probe: unable to kmalloc 256 bytes"); 203 return; 204 } 205 for (i = base, most = 0; i < base+num; i += 8) { 206 res = claim_region(s, i, 8, IORESOURCE_IO, "PCMCIA ioprobe"); 207 if (!res) 208 continue; 209 hole = inb(i); 210 for (j = 1; j < 8; j++) 211 if (inb(i+j) != hole) 212 break; 213 free_region(res); 214 if ((j == 8) && (++b[hole] > b[most])) 215 most = hole; 216 if (b[most] == 127) 217 break; 218 } 219 kfree(b); 220 221 bad = any = 0; 222 for (i = base; i < base+num; i += 8) { 223 res = claim_region(s, i, 8, IORESOURCE_IO, "PCMCIA ioprobe"); 224 if (!res) { 225 if (!any) 226 printk(" excluding"); 227 if (!bad) 228 bad = any = i; 229 continue; 230 } 231 for (j = 0; j < 8; j++) 232 if (inb(i+j) != most) 233 break; 234 free_region(res); 235 if (j < 8) { 236 if (!any) 237 printk(" excluding"); 238 if (!bad) 239 bad = any = i; 240 } else { 241 if (bad) { 242 sub_interval(&s_data->io_db, bad, i-bad); 243 printk(" %#x-%#x", bad, i-1); 244 bad = 0; 245 } 246 } 247 } 248 if (bad) { 249 if ((num > 16) && (bad == base) && (i == base+num)) { 250 sub_interval(&s_data->io_db, bad, i-bad); 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/** 266 * readable() - iomem validation function for cards with a valid CIS 267 */ 268static int readable(struct pcmcia_socket *s, struct resource *res, 269 unsigned int *count) 270{ 271 int ret = -EINVAL; 272 273 if (s->fake_cis) { 274 dev_dbg(&s->dev, "fake CIS is being used: can't validate mem\n"); 275 return 0; 276 } 277 278 s->cis_mem.res = res; 279 s->cis_virt = ioremap(res->start, s->map_size); 280 if (s->cis_virt) { 281 mutex_unlock(&s->ops_mutex); 282 /* as we're only called from pcmcia.c, we're safe */ 283 if (s->callback->validate) 284 ret = s->callback->validate(s, count); 285 /* invalidate mapping */ 286 mutex_lock(&s->ops_mutex); 287 iounmap(s->cis_virt); 288 s->cis_virt = NULL; 289 } 290 s->cis_mem.res = NULL; 291 if ((ret) || (*count == 0)) 292 return -EINVAL; 293 return 0; 294} 295 296/** 297 * checksum() - iomem validation function for simple memory cards 298 */ 299static int checksum(struct pcmcia_socket *s, struct resource *res, 300 unsigned int *value) 301{ 302 pccard_mem_map map; 303 int i, a = 0, b = -1, d; 304 void __iomem *virt; 305 306 virt = ioremap(res->start, s->map_size); 307 if (virt) { 308 map.map = 0; 309 map.flags = MAP_ACTIVE; 310 map.speed = 0; 311 map.res = res; 312 map.card_start = 0; 313 s->ops->set_mem_map(s, &map); 314 315 /* Don't bother checking every word... */ 316 for (i = 0; i < s->map_size; i += 44) { 317 d = readl(virt+i); 318 a += d; 319 b &= d; 320 } 321 322 map.flags = 0; 323 s->ops->set_mem_map(s, &map); 324 325 iounmap(virt); 326 } 327 328 if (b == -1) 329 return -EINVAL; 330 331 *value = a; 332 333 return 0; 334} 335 336/** 337 * do_validate_mem() - low level validate a memory region for PCMCIA use 338 * @s: PCMCIA socket to validate 339 * @base: start address of resource to check 340 * @size: size of resource to check 341 * @validate: validation function to use 342 * 343 * do_validate_mem() splits up the memory region which is to be checked 344 * into two parts. Both are passed to the @validate() function. If 345 * @validate() returns non-zero, or the value parameter to @validate() 346 * is zero, or the value parameter is different between both calls, 347 * the check fails, and -EINVAL is returned. Else, 0 is returned. 348 */ 349static int do_validate_mem(struct pcmcia_socket *s, 350 unsigned long base, unsigned long size, 351 int validate (struct pcmcia_socket *s, 352 struct resource *res, 353 unsigned int *value)) 354{ 355 struct socket_data *s_data = s->resource_data; 356 struct resource *res1, *res2; 357 unsigned int info1 = 1, info2 = 1; 358 int ret = -EINVAL; 359 360 res1 = claim_region(s, base, size/2, IORESOURCE_MEM, "PCMCIA memprobe"); 361 res2 = claim_region(s, base + size/2, size/2, IORESOURCE_MEM, 362 "PCMCIA memprobe"); 363 364 if (res1 && res2) { 365 ret = 0; 366 if (validate) { 367 ret = validate(s, res1, &info1); 368 ret += validate(s, res2, &info2); 369 } 370 } 371 372 free_region(res2); 373 free_region(res1); 374 375 dev_dbg(&s->dev, "cs: memory probe 0x%06lx-0x%06lx: %p %p %u %u %u", 376 base, base+size-1, res1, res2, ret, info1, info2); 377 378 if ((ret) || (info1 != info2) || (info1 == 0)) 379 return -EINVAL; 380 381 if (validate && !s->fake_cis) { 382 /* move it to the validated data set */ 383 add_interval(&s_data->mem_db_valid, base, size); 384 sub_interval(&s_data->mem_db, base, size); 385 } 386 387 return 0; 388} 389 390 391/** 392 * do_mem_probe() - validate a memory region for PCMCIA use 393 * @s: PCMCIA socket to validate 394 * @base: start address of resource to check 395 * @num: size of resource to check 396 * @validate: validation function to use 397 * @fallback: validation function to use if validate fails 398 * 399 * do_mem_probe() checks a memory region for use by the PCMCIA subsystem. 400 * To do so, the area is split up into sensible parts, and then passed 401 * into the @validate() function. Only if @validate() and @fallback() fail, 402 * the area is marked as unavaibale for use by the PCMCIA subsystem. The 403 * function returns the size of the usable memory area. 404 */ 405static int do_mem_probe(struct pcmcia_socket *s, u_long base, u_long num, 406 int validate (struct pcmcia_socket *s, 407 struct resource *res, 408 unsigned int *value), 409 int fallback (struct pcmcia_socket *s, 410 struct resource *res, 411 unsigned int *value)) 412{ 413 struct socket_data *s_data = s->resource_data; 414 u_long i, j, bad, fail, step; 415 416 dev_printk(KERN_INFO, &s->dev, "cs: memory probe 0x%06lx-0x%06lx:", 417 base, base+num-1); 418 bad = fail = 0; 419 step = (num < 0x20000) ? 0x2000 : ((num>>4) & ~0x1fff); 420 /* don't allow too large steps */ 421 if (step > 0x800000) 422 step = 0x800000; 423 /* cis_readable wants to map 2x map_size */ 424 if (step < 2 * s->map_size) 425 step = 2 * s->map_size; 426 for (i = j = base; i < base+num; i = j + step) { 427 if (!fail) { 428 for (j = i; j < base+num; j += step) { 429 if (!do_validate_mem(s, j, step, validate)) 430 break; 431 } 432 fail = ((i == base) && (j == base+num)); 433 } 434 if ((fail) && (fallback)) { 435 for (j = i; j < base+num; j += step) 436 if (!do_validate_mem(s, j, step, fallback)) 437 break; 438 } 439 if (i != j) { 440 if (!bad) 441 printk(" excluding"); 442 printk(" %#05lx-%#05lx", i, j-1); 443 sub_interval(&s_data->mem_db, i, j-i); 444 bad += j-i; 445 } 446 } 447 printk(bad ? "\n" : " clean.\n"); 448 return num - bad; 449} 450 451 452#ifdef CONFIG_PCMCIA_PROBE 453 454/** 455 * inv_probe() - top-to-bottom search for one usuable high memory area 456 * @s: PCMCIA socket to validate 457 * @m: resource_map to check 458 */ 459static u_long inv_probe(struct resource_map *m, struct pcmcia_socket *s) 460{ 461 struct socket_data *s_data = s->resource_data; 462 u_long ok; 463 if (m == &s_data->mem_db) 464 return 0; 465 ok = inv_probe(m->next, s); 466 if (ok) { 467 if (m->base >= 0x100000) 468 sub_interval(&s_data->mem_db, m->base, m->num); 469 return ok; 470 } 471 if (m->base < 0x100000) 472 return 0; 473 return do_mem_probe(s, m->base, m->num, readable, checksum); 474} 475 476/** 477 * validate_mem() - memory probe function 478 * @s: PCMCIA socket to validate 479 * @probe_mask: MEM_PROBE_LOW | MEM_PROBE_HIGH 480 * 481 * The memory probe. If the memory list includes a 64K-aligned block 482 * below 1MB, we probe in 64K chunks, and as soon as we accumulate at 483 * least mem_limit free space, we quit. Returns 0 on usuable ports. 484 */ 485static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask) 486{ 487 struct resource_map *m, mm; 488 static unsigned char order[] = { 0xd0, 0xe0, 0xc0, 0xf0 }; 489 unsigned long b, i, ok = 0; 490 struct socket_data *s_data = s->resource_data; 491 492 /* We do up to four passes through the list */ 493 if (probe_mask & MEM_PROBE_HIGH) { 494 if (inv_probe(s_data->mem_db.next, s) > 0) 495 return 0; 496 if (s_data->mem_db_valid.next != &s_data->mem_db_valid) 497 return 0; 498 dev_printk(KERN_NOTICE, &s->dev, 499 "cs: warning: no high memory space available!\n"); 500 return -ENODEV; 501 } 502 503 for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) { 504 mm = *m; 505 /* Only probe < 1 MB */ 506 if (mm.base >= 0x100000) 507 continue; 508 if ((mm.base | mm.num) & 0xffff) { 509 ok += do_mem_probe(s, mm.base, mm.num, readable, 510 checksum); 511 continue; 512 } 513 /* Special probe for 64K-aligned block */ 514 for (i = 0; i < 4; i++) { 515 b = order[i] << 12; 516 if ((b >= mm.base) && (b+0x10000 <= mm.base+mm.num)) { 517 if (ok >= mem_limit) 518 sub_interval(&s_data->mem_db, b, 0x10000); 519 else 520 ok += do_mem_probe(s, b, 0x10000, 521 readable, checksum); 522 } 523 } 524 } 525 526 if (ok > 0) 527 return 0; 528 529 return -ENODEV; 530} 531 532#else /* CONFIG_PCMCIA_PROBE */ 533 534/** 535 * validate_mem() - memory probe function 536 * @s: PCMCIA socket to validate 537 * @probe_mask: ignored 538 * 539 * Returns 0 on usuable ports. 540 */ 541static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask) 542{ 543 struct resource_map *m, mm; 544 struct socket_data *s_data = s->resource_data; 545 unsigned long ok = 0; 546 547 for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) { 548 mm = *m; 549 ok += do_mem_probe(s, mm.base, mm.num, readable, checksum); 550 } 551 if (ok > 0) 552 return 0; 553 return -ENODEV; 554} 555 556#endif /* CONFIG_PCMCIA_PROBE */ 557 558 559/** 560 * pcmcia_nonstatic_validate_mem() - try to validate iomem for PCMCIA use 561 * @s: PCMCIA socket to validate 562 * 563 * This is tricky... when we set up CIS memory, we try to validate 564 * the memory window space allocations. 565 * 566 * Locking note: Must be called with skt_mutex held! 567 */ 568static int pcmcia_nonstatic_validate_mem(struct pcmcia_socket *s) 569{ 570 struct socket_data *s_data = s->resource_data; 571 unsigned int probe_mask = MEM_PROBE_LOW; 572 int ret; 573 574 if (!probe_mem || !(s->state & SOCKET_PRESENT)) 575 return 0; 576 577 if (s->features & SS_CAP_PAGE_REGS) 578 probe_mask = MEM_PROBE_HIGH; 579 580 ret = validate_mem(s, probe_mask); 581 582 if (s_data->mem_db_valid.next != &s_data->mem_db_valid) 583 return 0; 584 585 return ret; 586} 587 588struct pcmcia_align_data { 589 unsigned long mask; 590 unsigned long offset; 591 struct resource_map *map; 592}; 593 594static resource_size_t pcmcia_common_align(struct pcmcia_align_data *align_data, 595 resource_size_t start) 596{ 597 resource_size_t ret; 598 /* 599 * Ensure that we have the correct start address 600 */ 601 ret = (start & ~align_data->mask) + align_data->offset; 602 if (ret < start) 603 ret += align_data->mask + 1; 604 return ret; 605} 606 607static resource_size_t 608pcmcia_align(void *align_data, const struct resource *res, 609 resource_size_t size, resource_size_t align) 610{ 611 struct pcmcia_align_data *data = align_data; 612 struct resource_map *m; 613 resource_size_t start; 614 615 start = pcmcia_common_align(data, res->start); 616 617 for (m = data->map->next; m != data->map; m = m->next) { 618 unsigned long map_start = m->base; 619 unsigned long map_end = m->base + m->num - 1; 620 621 /* 622 * If the lower resources are not available, try aligning 623 * to this entry of the resource database to see if it'll 624 * fit here. 625 */ 626 if (start < map_start) 627 start = pcmcia_common_align(data, map_start); 628 629 /* 630 * If we're above the area which was passed in, there's 631 * no point proceeding. 632 */ 633 if (start >= res->end) 634 break; 635 636 if ((start + size - 1) <= map_end) 637 break; 638 } 639 640 /* 641 * If we failed to find something suitable, ensure we fail. 642 */ 643 if (m == data->map) 644 start = res->end; 645 646 return start; 647} 648 649/* 650 * Adjust an existing IO region allocation, but making sure that we don't 651 * encroach outside the resources which the user supplied. 652 */ 653static int __nonstatic_adjust_io_region(struct pcmcia_socket *s, 654 unsigned long r_start, 655 unsigned long r_end) 656{ 657 struct resource_map *m; 658 struct socket_data *s_data = s->resource_data; 659 int ret = -ENOMEM; 660 661 for (m = s_data->io_db.next; m != &s_data->io_db; m = m->next) { 662 unsigned long start = m->base; 663 unsigned long end = m->base + m->num - 1; 664 665 if (start > r_start || r_end > end) 666 continue; 667 668 ret = 0; 669 } 670 671 return ret; 672} 673 674/*====================================================================== 675 676 These find ranges of I/O ports or memory addresses that are not 677 currently allocated by other devices. 678 679 The 'align' field should reflect the number of bits of address 680 that need to be preserved from the initial value of *base. It 681 should be a power of two, greater than or equal to 'num'. A value 682 of 0 means that all bits of *base are significant. *base should 683 also be strictly less than 'align'. 684 685======================================================================*/ 686 687static struct resource *__nonstatic_find_io_region(struct pcmcia_socket *s, 688 unsigned long base, int num, 689 unsigned long align) 690{ 691 struct resource *res = pcmcia_make_resource(0, num, IORESOURCE_IO, 692 dev_name(&s->dev)); 693 struct socket_data *s_data = s->resource_data; 694 struct pcmcia_align_data data; 695 unsigned long min = base; 696 int ret; 697 698 data.mask = align - 1; 699 data.offset = base & data.mask; 700 data.map = &s_data->io_db; 701 702#ifdef CONFIG_PCI 703 if (s->cb_dev) { 704 ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num, 1, 705 min, 0, pcmcia_align, &data); 706 } else 707#endif 708 ret = allocate_resource(&ioport_resource, res, num, min, ~0UL, 709 1, pcmcia_align, &data); 710 711 if (ret != 0) { 712 kfree(res); 713 res = NULL; 714 } 715 return res; 716} 717 718static int nonstatic_find_io(struct pcmcia_socket *s, unsigned int attr, 719 unsigned int *base, unsigned int num, 720 unsigned int align, struct resource **parent) 721{ 722 int i, ret = 0; 723 724 /* Check for an already-allocated window that must conflict with 725 * what was asked for. It is a hack because it does not catch all 726 * potential conflicts, just the most obvious ones. 727 */ 728 for (i = 0; i < MAX_IO_WIN; i++) { 729 if (!s->io[i].res) 730 continue; 731 732 if (!*base) 733 continue; 734 735 if ((s->io[i].res->start & (align-1)) == *base) 736 return -EBUSY; 737 } 738 739 for (i = 0; i < MAX_IO_WIN; i++) { 740 struct resource *res = s->io[i].res; 741 unsigned int try; 742 743 if (res && (res->flags & IORESOURCE_BITS) != 744 (attr & IORESOURCE_BITS)) 745 continue; 746 747 if (!res) { 748 if (align == 0) 749 align = 0x10000; 750 751 res = s->io[i].res = __nonstatic_find_io_region(s, 752 *base, num, 753 align); 754 if (!res) 755 return -EINVAL; 756 757 *base = res->start; 758 s->io[i].res->flags = 759 ((res->flags & ~IORESOURCE_BITS) | 760 (attr & IORESOURCE_BITS)); 761 s->io[i].InUse = num; 762 *parent = res; 763 return 0; 764 } 765 766 /* Try to extend top of window */ 767 try = res->end + 1; 768 if ((*base == 0) || (*base == try)) { 769 ret = __nonstatic_adjust_io_region(s, res->start, 770 res->end + num); 771 if (!ret) { 772 ret = adjust_resource(s->io[i].res, res->start, 773 resource_size(res) + num); 774 if (ret) 775 continue; 776 *base = try; 777 s->io[i].InUse += num; 778 *parent = res; 779 return 0; 780 } 781 } 782 783 /* Try to extend bottom of window */ 784 try = res->start - num; 785 if ((*base == 0) || (*base == try)) { 786 ret = __nonstatic_adjust_io_region(s, 787 res->start - num, 788 res->end); 789 if (!ret) { 790 ret = adjust_resource(s->io[i].res, 791 res->start - num, 792 resource_size(res) + num); 793 if (ret) 794 continue; 795 *base = try; 796 s->io[i].InUse += num; 797 *parent = res; 798 return 0; 799 } 800 } 801 } 802 803 return -EINVAL; 804} 805 806 807static struct resource *nonstatic_find_mem_region(u_long base, u_long num, 808 u_long align, int low, struct pcmcia_socket *s) 809{ 810 struct resource *res = pcmcia_make_resource(0, num, IORESOURCE_MEM, 811 dev_name(&s->dev)); 812 struct socket_data *s_data = s->resource_data; 813 struct pcmcia_align_data data; 814 unsigned long min, max; 815 int ret, i, j; 816 817 low = low || !(s->features & SS_CAP_PAGE_REGS); 818 819 data.mask = align - 1; 820 data.offset = base & data.mask; 821 822 for (i = 0; i < 2; i++) { 823 data.map = &s_data->mem_db_valid; 824 if (low) { 825 max = 0x100000UL; 826 min = base < max ? base : 0; 827 } else { 828 max = ~0UL; 829 min = 0x100000UL + base; 830 } 831 832 for (j = 0; j < 2; j++) { 833#ifdef CONFIG_PCI 834 if (s->cb_dev) { 835 ret = pci_bus_alloc_resource(s->cb_dev->bus, 836 res, num, 1, min, 0, 837 pcmcia_align, &data); 838 } else 839#endif 840 { 841 ret = allocate_resource(&iomem_resource, 842 res, num, min, max, 1, 843 pcmcia_align, &data); 844 } 845 if (ret == 0) 846 break; 847 data.map = &s_data->mem_db; 848 } 849 if (ret == 0 || low) 850 break; 851 low = 1; 852 } 853 854 if (ret != 0) { 855 kfree(res); 856 res = NULL; 857 } 858 return res; 859} 860 861 862static int adjust_memory(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end) 863{ 864 struct socket_data *data = s->resource_data; 865 unsigned long size = end - start + 1; 866 int ret = 0; 867 868 if (end < start) 869 return -EINVAL; 870 871 switch (action) { 872 case ADD_MANAGED_RESOURCE: 873 ret = add_interval(&data->mem_db, start, size); 874 if (!ret) 875 do_mem_probe(s, start, size, NULL, NULL); 876 break; 877 case REMOVE_MANAGED_RESOURCE: 878 ret = sub_interval(&data->mem_db, start, size); 879 break; 880 default: 881 ret = -EINVAL; 882 } 883 884 return ret; 885} 886 887 888static int adjust_io(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end) 889{ 890 struct socket_data *data = s->resource_data; 891 unsigned long size; 892 int ret = 0; 893 894#if defined(CONFIG_X86) 895 /* on x86, avoid anything < 0x100 for it is often used for 896 * legacy platform devices */ 897 if (start < 0x100) 898 start = 0x100; 899#endif 900 901 size = end - start + 1; 902 903 if (end < start) 904 return -EINVAL; 905 906 if (end > IO_SPACE_LIMIT) 907 return -EINVAL; 908 909 switch (action) { 910 case ADD_MANAGED_RESOURCE: 911 if (add_interval(&data->io_db, start, size) != 0) { 912 ret = -EBUSY; 913 break; 914 } 915#ifdef CONFIG_PCMCIA_PROBE 916 if (probe_io) 917 do_io_probe(s, start, size); 918#endif 919 break; 920 case REMOVE_MANAGED_RESOURCE: 921 sub_interval(&data->io_db, start, size); 922 break; 923 default: 924 ret = -EINVAL; 925 break; 926 } 927 928 return ret; 929} 930 931 932#ifdef CONFIG_PCI 933static int nonstatic_autoadd_resources(struct pcmcia_socket *s) 934{ 935 struct resource *res; 936 int i, done = 0; 937 938 if (!s->cb_dev || !s->cb_dev->bus) 939 return -ENODEV; 940 941#if defined(CONFIG_X86) 942 /* If this is the root bus, the risk of hitting some strange 943 * system devices is too high: If a driver isn't loaded, the 944 * resources are not claimed; even if a driver is loaded, it 945 * may not request all resources or even the wrong one. We 946 * can neither trust the rest of the kernel nor ACPI/PNP and 947 * CRS parsing to get it right. Therefore, use several 948 * safeguards: 949 * 950 * - Do not auto-add resources if the CardBus bridge is on 951 * the PCI root bus 952 * 953 * - Avoid any I/O ports < 0x100. 954 * 955 * - On PCI-PCI bridges, only use resources which are set up 956 * exclusively for the secondary PCI bus: the risk of hitting 957 * system devices is quite low, as they usually aren't 958 * connected to the secondary PCI bus. 959 */ 960 if (s->cb_dev->bus->number == 0) 961 return -EINVAL; 962 963 for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) { 964 res = s->cb_dev->bus->resource[i]; 965#else 966 pci_bus_for_each_resource(s->cb_dev->bus, res, i) { 967#endif 968 if (!res) 969 continue; 970 971 if (res->flags & IORESOURCE_IO) { 972 /* safeguard against the root resource, where the 973 * risk of hitting any other device would be too 974 * high */ 975 if (res == &ioport_resource) 976 continue; 977 978 dev_printk(KERN_INFO, &s->cb_dev->dev, 979 "pcmcia: parent PCI bridge window: %pR\n", 980 res); 981 if (!adjust_io(s, ADD_MANAGED_RESOURCE, res->start, res->end)) 982 done |= IORESOURCE_IO; 983 984 } 985 986 if (res->flags & IORESOURCE_MEM) { 987 /* safeguard against the root resource, where the 988 * risk of hitting any other device would be too 989 * high */ 990 if (res == &iomem_resource) 991 continue; 992 993 dev_printk(KERN_INFO, &s->cb_dev->dev, 994 "pcmcia: parent PCI bridge window: %pR\n", 995 res); 996 if (!adjust_memory(s, ADD_MANAGED_RESOURCE, res->start, res->end)) 997 done |= IORESOURCE_MEM; 998 } 999 } 1000 1001 /* if we got at least one of IO, and one of MEM, we can be glad and 1002 * activate the PCMCIA subsystem */ 1003 if (done == (IORESOURCE_MEM | IORESOURCE_IO)) 1004 s->resource_setup_done = 1; 1005 1006 return 0; 1007} 1008 1009#else 1010 1011static inline int nonstatic_autoadd_resources(struct pcmcia_socket *s) 1012{ 1013 return -ENODEV; 1014} 1015 1016#endif 1017 1018 1019static int nonstatic_init(struct pcmcia_socket *s) 1020{ 1021 struct socket_data *data; 1022 1023 data = kzalloc(sizeof(struct socket_data), GFP_KERNEL); 1024 if (!data) 1025 return -ENOMEM; 1026 1027 data->mem_db.next = &data->mem_db; 1028 data->mem_db_valid.next = &data->mem_db_valid; 1029 data->io_db.next = &data->io_db; 1030 1031 s->resource_data = (void *) data; 1032 1033 nonstatic_autoadd_resources(s); 1034 1035 return 0; 1036} 1037 1038static void nonstatic_release_resource_db(struct pcmcia_socket *s) 1039{ 1040 struct socket_data *data = s->resource_data; 1041 struct resource_map *p, *q; 1042 1043 for (p = data->mem_db_valid.next; p != &data->mem_db_valid; p = q) { 1044 q = p->next; 1045 kfree(p); 1046 } 1047 for (p = data->mem_db.next; p != &data->mem_db; p = q) { 1048 q = p->next; 1049 kfree(p); 1050 } 1051 for (p = data->io_db.next; p != &data->io_db; p = q) { 1052 q = p->next; 1053 kfree(p); 1054 } 1055} 1056 1057 1058struct pccard_resource_ops pccard_nonstatic_ops = { 1059 .validate_mem = pcmcia_nonstatic_validate_mem, 1060 .find_io = nonstatic_find_io, 1061 .find_mem = nonstatic_find_mem_region, 1062 .init = nonstatic_init, 1063 .exit = nonstatic_release_resource_db, 1064}; 1065EXPORT_SYMBOL(pccard_nonstatic_ops); 1066 1067 1068/* sysfs interface to the resource database */ 1069 1070static ssize_t show_io_db(struct device *dev, 1071 struct device_attribute *attr, char *buf) 1072{ 1073 struct pcmcia_socket *s = dev_get_drvdata(dev); 1074 struct socket_data *data; 1075 struct resource_map *p; 1076 ssize_t ret = 0; 1077 1078 mutex_lock(&s->ops_mutex); 1079 data = s->resource_data; 1080 1081 for (p = data->io_db.next; p != &data->io_db; p = p->next) { 1082 if (ret > (PAGE_SIZE - 10)) 1083 continue; 1084 ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1), 1085 "0x%08lx - 0x%08lx\n", 1086 ((unsigned long) p->base), 1087 ((unsigned long) p->base + p->num - 1)); 1088 } 1089 1090 mutex_unlock(&s->ops_mutex); 1091 return ret; 1092} 1093 1094static ssize_t store_io_db(struct device *dev, 1095 struct device_attribute *attr, 1096 const char *buf, size_t count) 1097{ 1098 struct pcmcia_socket *s = dev_get_drvdata(dev); 1099 unsigned long start_addr, end_addr; 1100 unsigned int add = ADD_MANAGED_RESOURCE; 1101 ssize_t ret = 0; 1102 1103 ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr); 1104 if (ret != 2) { 1105 ret = sscanf(buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr); 1106 add = REMOVE_MANAGED_RESOURCE; 1107 if (ret != 2) { 1108 ret = sscanf(buf, "0x%lx - 0x%lx", &start_addr, 1109 &end_addr); 1110 add = ADD_MANAGED_RESOURCE; 1111 if (ret != 2) 1112 return -EINVAL; 1113 } 1114 } 1115 if (end_addr < start_addr) 1116 return -EINVAL; 1117 1118 mutex_lock(&s->ops_mutex); 1119 ret = adjust_io(s, add, start_addr, end_addr); 1120 mutex_unlock(&s->ops_mutex); 1121 1122 return ret ? ret : count; 1123} 1124static DEVICE_ATTR(available_resources_io, 0600, show_io_db, store_io_db); 1125 1126static ssize_t show_mem_db(struct device *dev, 1127 struct device_attribute *attr, char *buf) 1128{ 1129 struct pcmcia_socket *s = dev_get_drvdata(dev); 1130 struct socket_data *data; 1131 struct resource_map *p; 1132 ssize_t ret = 0; 1133 1134 mutex_lock(&s->ops_mutex); 1135 data = s->resource_data; 1136 1137 for (p = data->mem_db_valid.next; p != &data->mem_db_valid; 1138 p = p->next) { 1139 if (ret > (PAGE_SIZE - 10)) 1140 continue; 1141 ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1), 1142 "0x%08lx - 0x%08lx\n", 1143 ((unsigned long) p->base), 1144 ((unsigned long) p->base + p->num - 1)); 1145 } 1146 1147 for (p = data->mem_db.next; p != &data->mem_db; p = p->next) { 1148 if (ret > (PAGE_SIZE - 10)) 1149 continue; 1150 ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1), 1151 "0x%08lx - 0x%08lx\n", 1152 ((unsigned long) p->base), 1153 ((unsigned long) p->base + p->num - 1)); 1154 } 1155 1156 mutex_unlock(&s->ops_mutex); 1157 return ret; 1158} 1159 1160static ssize_t store_mem_db(struct device *dev, 1161 struct device_attribute *attr, 1162 const char *buf, size_t count) 1163{ 1164 struct pcmcia_socket *s = dev_get_drvdata(dev); 1165 unsigned long start_addr, end_addr; 1166 unsigned int add = ADD_MANAGED_RESOURCE; 1167 ssize_t ret = 0; 1168 1169 ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr); 1170 if (ret != 2) { 1171 ret = sscanf(buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr); 1172 add = REMOVE_MANAGED_RESOURCE; 1173 if (ret != 2) { 1174 ret = sscanf(buf, "0x%lx - 0x%lx", &start_addr, 1175 &end_addr); 1176 add = ADD_MANAGED_RESOURCE; 1177 if (ret != 2) 1178 return -EINVAL; 1179 } 1180 } 1181 if (end_addr < start_addr) 1182 return -EINVAL; 1183 1184 mutex_lock(&s->ops_mutex); 1185 ret = adjust_memory(s, add, start_addr, end_addr); 1186 mutex_unlock(&s->ops_mutex); 1187 1188 return ret ? ret : count; 1189} 1190static DEVICE_ATTR(available_resources_mem, 0600, show_mem_db, store_mem_db); 1191 1192static struct attribute *pccard_rsrc_attributes[] = { 1193 &dev_attr_available_resources_io.attr, 1194 &dev_attr_available_resources_mem.attr, 1195 NULL, 1196}; 1197 1198static const struct attribute_group rsrc_attributes = { 1199 .attrs = pccard_rsrc_attributes, 1200}; 1201 1202static int __devinit pccard_sysfs_add_rsrc(struct device *dev, 1203 struct class_interface *class_intf) 1204{ 1205 struct pcmcia_socket *s = dev_get_drvdata(dev); 1206 1207 if (s->resource_ops != &pccard_nonstatic_ops) 1208 return 0; 1209 return sysfs_create_group(&dev->kobj, &rsrc_attributes); 1210} 1211 1212static void __devexit pccard_sysfs_remove_rsrc(struct device *dev, 1213 struct class_interface *class_intf) 1214{ 1215 struct pcmcia_socket *s = dev_get_drvdata(dev); 1216 1217 if (s->resource_ops != &pccard_nonstatic_ops) 1218 return; 1219 sysfs_remove_group(&dev->kobj, &rsrc_attributes); 1220} 1221 1222static struct class_interface pccard_rsrc_interface __refdata = { 1223 .class = &pcmcia_socket_class, 1224 .add_dev = &pccard_sysfs_add_rsrc, 1225 .remove_dev = __devexit_p(&pccard_sysfs_remove_rsrc), 1226}; 1227 1228static int __init nonstatic_sysfs_init(void) 1229{ 1230 return class_interface_register(&pccard_rsrc_interface); 1231} 1232 1233static void __exit nonstatic_sysfs_exit(void) 1234{ 1235 class_interface_unregister(&pccard_rsrc_interface); 1236} 1237 1238module_init(nonstatic_sysfs_init); 1239module_exit(nonstatic_sysfs_exit); 1240