SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/pcmcia/rsrc_nonstatic.c

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