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