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