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