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