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/config.h>
  16 #include <linux/module.h>
  17 #include <linux/moduleparam.h>
  18 #include <linux/init.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/kernel.h>
  21 #include <linux/errno.h>
  22 #include <linux/types.h>
  23 #include <linux/slab.h>
  24 #include <linux/ioport.h>
  25 #include <linux/timer.h>
  26 #include <linux/pci.h>
  27 #include <asm/irq.h>
  28 #include <asm/io.h>
  29
  30 #include <pcmcia/cs_types.h>
  31 #include <pcmcia/ss.h>
  32 #include <pcmcia/cs.h>
  33 #include <pcmcia/bulkmem.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 DECLARE_MUTEX(rsrc_sem);
  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(unsigned long b, unsigned long n, int flags, char *name)
  75 {
  76         struct resource *res = kmalloc(sizeof(*res), GFP_KERNEL);
  77
  78         if (res) {
  79                 memset(res, 0, sizeof(*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, unsigned long base, unsigned long size,
  90              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 = kmalloc(256, GFP_KERNEL);
 202     if (!b) {
 203             printk(KERN_ERR "do_io_probe: unable to kmalloc 256 bytes");
 204             return;
 205     }
 206     memset(b, 0, 256);
 207     for (i = base, most = 0; i < base+num; i += 8) {
 208         res = claim_region(NULL, i, 8, IORESOURCE_IO, "PCMCIA IO probe");
 209         if (!res)
 210             continue;
 211         hole = inb(i);
 212         for (j = 1; j < 8; j++)
 213             if (inb(i+j) != hole) break;
 214         free_region(res);
 215         if ((j == 8) && (++b[hole] > b[most]))
 216             most = hole;
 217         if (b[most] == 127) break;
 218     }
 219     kfree(b);
 220
 221     bad = any = 0;
 222     for (i = base; i < base+num; i += 8) {
 223         res = claim_region(NULL, i, 8, IORESOURCE_IO, "PCMCIA IO probe");
 224         if (!res)
 225             continue;
 226         for (j = 0; j < 8; j++)
 227             if (inb(i+j) != most) break;
 228         free_region(res);
 229         if (j < 8) {
 230             if (!any)
 231                 printk(" excluding");
 232             if (!bad)
 233                 bad = any = i;
 234         } else {
 235             if (bad) {
 236                 sub_interval(&s_data->io_db, bad, i-bad);
 237                 printk(" %#lx-%#lx", bad, i-1);
 238                 bad = 0;
 239             }
 240         }
 241     }
 242     if (bad) {
 243         if ((num > 16) && (bad == base) && (i == base+num)) {
 244             printk(" nothing: probe failed.\n");
 245             return;
 246         } else {
 247             sub_interval(&s_data->io_db, bad, i-bad);
 248             printk(" %#lx-%#lx", bad, i-1);
 249         }
 250     }
 251
 252     printk(any ? "\n" : " clean.\n");
 253 }
 254 #endif
 255
 256 /*======================================================================
 257
 258     This is tricky... when we set up CIS memory, we try to validate
 259     the memory window space allocations.
 260
 261 ======================================================================*/
 262
 263 /* Validation function for cards with a valid CIS */
 264 static int readable(struct pcmcia_socket *s, struct resource *res, cisinfo_t *info)
 265 {
 266         int ret = -1;
 267
 268         s->cis_mem.res = res;
 269         s->cis_virt = ioremap(res->start, s->map_size);
 270         if (s->cis_virt) {
 271                 ret = pccard_validate_cis(s, BIND_FN_ALL, info);
 272                 /* invalidate mapping and CIS cache */
 273                 iounmap(s->cis_virt);
 274                 s->cis_virt = NULL;
 275                 destroy_cis_cache(s);
 276         }
 277         s->cis_mem.res = NULL;
 278         if ((ret != 0) || (info->Chains == 0))
 279                 return 0;
 280         return 1;
 281 }
 282
 283 /* Validation function for simple memory cards */
 284 static int checksum(struct pcmcia_socket *s, struct resource *res)
 285 {
 286         pccard_mem_map map;
 287         int i, a = 0, b = -1, d;
 288         void __iomem *virt;
 289
 290         virt = ioremap(res->start, s->map_size);
 291         if (virt) {
 292                 map.map = 0;
 293                 map.flags = MAP_ACTIVE;
 294                 map.speed = 0;
 295                 map.res = res;
 296                 map.card_start = 0;
 297                 s->ops->set_mem_map(s, &map);
 298
 299                 /* Don't bother checking every word... */
 300                 for (i = 0; i < s->map_size; i += 44) {
 301                         d = readl(virt+i);
 302                         a += d;
 303                         b &= d;
 304                 }
 305
 306                 map.flags = 0;
 307                 s->ops->set_mem_map(s, &map);
 308
 309                 iounmap(virt);
 310         }
 311
 312         return (b == -1) ? -1 : (a>>1);
 313 }
 314
 315 static int
 316 cis_readable(struct pcmcia_socket *s, unsigned long base, unsigned long size)
 317 {
 318         struct resource *res1, *res2;
 319         cisinfo_t info1, info2;
 320         int ret = 0;
 321
 322         res1 = claim_region(s, base, size/2, IORESOURCE_MEM, "cs memory probe");
 323         res2 = claim_region(s, base + size/2, size/2, IORESOURCE_MEM, "cs memory probe");
 324
 325         if (res1 && res2) {
 326                 ret = readable(s, res1, &info1);
 327                 ret += readable(s, res2, &info2);
 328         }
 329
 330         free_region(res2);
 331         free_region(res1);
 332
 333         return (ret == 2) && (info1.Chains == info2.Chains);
 334 }
 335
 336 static int
 337 checksum_match(struct pcmcia_socket *s, unsigned long base, unsigned long size)
 338 {
 339         struct resource *res1, *res2;
 340         int a = -1, b = -1;
 341
 342         res1 = claim_region(s, base, size/2, IORESOURCE_MEM, "cs memory probe");
 343         res2 = claim_region(s, base + size/2, size/2, IORESOURCE_MEM, "cs memory probe");
 344
 345         if (res1 && res2) {
 346                 a = checksum(s, res1);
 347                 b = checksum(s, res2);
 348         }
 349
 350         free_region(res2);
 351         free_region(res1);
 352
 353         return (a == b) && (a >= 0);
 354 }
 355
 356 /*======================================================================
 357
 358     The memory probe.  If the memory list includes a 64K-aligned block
 359     below 1MB, we probe in 64K chunks, and as soon as we accumulate at
 360     least mem_limit free space, we quit.
 361
 362 ======================================================================*/
 363
 364 static int do_mem_probe(u_long base, u_long num, struct pcmcia_socket *s)
 365 {
 366     struct socket_data *s_data = s->resource_data;
 367     u_long i, j, bad, fail, step;
 368
 369     printk(KERN_INFO "cs: memory probe 0x%06lx-0x%06lx:",
 370            base, base+num-1);
 371     bad = fail = 0;
 372     step = (num < 0x20000) ? 0x2000 : ((num>>4) & ~0x1fff);
 373     /* cis_readable wants to map 2x map_size */
 374     if (step < 2 * s->map_size)
 375         step = 2 * s->map_size;
 376     for (i = j = base; i < base+num; i = j + step) {
 377         if (!fail) {
 378             for (j = i; j < base+num; j += step) {
 379                 if (cis_readable(s, j, step))
 380                     break;
 381             }
 382             fail = ((i == base) && (j == base+num));
 383         }
 384         if (fail) {
 385             for (j = i; j < base+num; j += 2*step)
 386                 if (checksum_match(s, j, step) &&
 387                     checksum_match(s, j + step, step))
 388                     break;
 389         }
 390         if (i != j) {
 391             if (!bad) printk(" excluding");
 392             printk(" %#05lx-%#05lx", i, j-1);
 393             sub_interval(&s_data->mem_db, i, j-i);
 394             bad += j-i;
 395         }
 396     }
 397     printk(bad ? "\n" : " clean.\n");
 398     return (num - bad);
 399 }
 400
 401 #ifdef CONFIG_PCMCIA_PROBE
 402
 403 static u_long inv_probe(struct resource_map *m, struct pcmcia_socket *s)
 404 {
 405     struct socket_data *s_data = s->resource_data;
 406     u_long ok;
 407     if (m == &s_data->mem_db)
 408         return 0;
 409     ok = inv_probe(m->next, s);
 410     if (ok) {
 411         if (m->base >= 0x100000)
 412             sub_interval(&s_data->mem_db, m->base, m->num);
 413         return ok;
 414     }
 415     if (m->base < 0x100000)
 416         return 0;
 417     return do_mem_probe(m->base, m->num, s);
 418 }
 419
 420 static void validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
 421 {
 422     struct resource_map *m, mm;
 423     static u_char order[] = { 0xd0, 0xe0, 0xc0, 0xf0 };
 424     u_long b, i, ok = 0;
 425     struct socket_data *s_data = s->resource_data;
 426
 427     /* We do up to four passes through the list */
 428     if (probe_mask & MEM_PROBE_HIGH) {
 429         if (inv_probe(s_data->mem_db.next, s) > 0)
 430             return;
 431         printk(KERN_NOTICE "cs: warning: no high memory space "
 432                "available!\n");
 433     }
 434     if ((probe_mask & MEM_PROBE_LOW) == 0)
 435         return;
 436     for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) {
 437         mm = *m;
 438         /* Only probe < 1 MB */
 439         if (mm.base >= 0x100000) continue;
 440         if ((mm.base | mm.num) & 0xffff) {
 441             ok += do_mem_probe(mm.base, mm.num, s);
 442             continue;
 443         }
 444         /* Special probe for 64K-aligned block */
 445         for (i = 0; i < 4; i++) {
 446             b = order[i] << 12;
 447             if ((b >= mm.base) && (b+0x10000 <= mm.base+mm.num)) {
 448                 if (ok >= mem_limit)
 449                     sub_interval(&s_data->mem_db, b, 0x10000);
 450                 else
 451                     ok += do_mem_probe(b, 0x10000, s);
 452             }
 453         }
 454     }
 455 }
 456
 457 #else /* CONFIG_PCMCIA_PROBE */
 458
 459 static void validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
 460 {
 461         struct resource_map *m, mm;
 462         struct socket_data *s_data = s->resource_data;
 463
 464         for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) {
 465                 mm = *m;
 466                 if (do_mem_probe(mm.base, mm.num, s))
 467                         break;
 468         }
 469 }
 470
 471 #endif /* CONFIG_PCMCIA_PROBE */
 472
 473
 474 /*
 475  * Locking note: this is the only place where we take
 476  * both rsrc_sem and skt_sem.
 477  */
 478 static void pcmcia_nonstatic_validate_mem(struct pcmcia_socket *s)
 479 {
 480         struct socket_data *s_data = s->resource_data;
 481         if (probe_mem) {
 482                 unsigned int probe_mask;
 483
 484                 down(&rsrc_sem);
 485
 486                 probe_mask = MEM_PROBE_LOW;
 487                 if (s->features & SS_CAP_PAGE_REGS)
 488                         probe_mask = MEM_PROBE_HIGH;
 489
 490                 if (probe_mask & ~s_data->rsrc_mem_probe) {
 491                         s_data->rsrc_mem_probe |= probe_mask;
 492
 493                         down(&s->skt_sem);
 494
 495                         if (s->state & SOCKET_PRESENT)
 496                                 validate_mem(s, probe_mask);
 497
 498                         up(&s->skt_sem);
 499                 }
 500
 501                 up(&rsrc_sem);
 502         }
 503 }
 504
 505 struct pcmcia_align_data {
 506         unsigned long   mask;
 507         unsigned long   offset;
 508         struct resource_map     *map;
 509 };
 510
 511 static void
 512 pcmcia_common_align(void *align_data, struct resource *res,
 513                     unsigned long size, unsigned long align)
 514 {
 515         struct pcmcia_align_data *data = align_data;
 516         unsigned long start;
 517         /*
 518          * Ensure that we have the correct start address
 519          */
 520         start = (res->start & ~data->mask) + data->offset;
 521         if (start < res->start)
 522                 start += data->mask + 1;
 523         res->start = start;
 524 }
 525
 526 static void
 527 pcmcia_align(void *align_data, struct resource *res,
 528              unsigned long size, unsigned long align)
 529 {
 530         struct pcmcia_align_data *data = align_data;
 531         struct resource_map *m;
 532
 533         pcmcia_common_align(data, res, size, align);
 534
 535         for (m = data->map->next; m != data->map; m = m->next) {
 536                 unsigned long start = m->base;
 537                 unsigned long end = m->base + m->num - 1;
 538
 539                 /*
 540                  * If the lower resources are not available, try aligning
 541                  * to this entry of the resource database to see if it'll
 542                  * fit here.
 543                  */
 544                 if (res->start < start) {
 545                         res->start = start;
 546                         pcmcia_common_align(data, res, size, align);
 547                 }
 548
 549                 /*
 550                  * If we're above the area which was passed in, there's
 551                  * no point proceeding.
 552                  */
 553                 if (res->start >= res->end)
 554                         break;
 555
 556                 if ((res->start + size - 1) <= end)
 557                         break;
 558         }
 559
 560         /*
 561          * If we failed to find something suitable, ensure we fail.
 562          */
 563         if (m == data->map)
 564                 res->start = res->end;
 565 }
 566
 567 /*
 568  * Adjust an existing IO region allocation, but making sure that we don't
 569  * encroach outside the resources which the user supplied.
 570  */
 571 static int nonstatic_adjust_io_region(struct resource *res, unsigned long r_start,
 572                                       unsigned long r_end, struct pcmcia_socket *s)
 573 {
 574         struct resource_map *m;
 575         struct socket_data *s_data = s->resource_data;
 576         int ret = -ENOMEM;
 577
 578         down(&rsrc_sem);
 579         for (m = s_data->io_db.next; m != &s_data->io_db; m = m->next) {
 580                 unsigned long start = m->base;
 581                 unsigned long end = m->base + m->num - 1;
 582
 583                 if (start > r_start || r_end > end)
 584                         continue;
 585
 586                 ret = adjust_resource(res, r_start, r_end - r_start + 1);
 587                 break;
 588         }
 589         up(&rsrc_sem);
 590
 591         return ret;
 592 }
 593
 594 /*======================================================================
 595
 596     These find ranges of I/O ports or memory addresses that are not
 597     currently allocated by other devices.
 598
 599     The 'align' field should reflect the number of bits of address
 600     that need to be preserved from the initial value of *base.  It
 601     should be a power of two, greater than or equal to 'num'.  A value
 602     of 0 means that all bits of *base are significant.  *base should
 603     also be strictly less than 'align'.
 604
 605 ======================================================================*/
 606
 607 struct resource *nonstatic_find_io_region(unsigned long base, int num,
 608                    unsigned long align, struct pcmcia_socket *s)
 609 {
 610         struct resource *res = make_resource(0, num, IORESOURCE_IO, s->dev.class_id);
 611         struct socket_data *s_data = s->resource_data;
 612         struct pcmcia_align_data data;
 613         unsigned long min = base;
 614         int ret;
 615
 616         if (align == 0)
 617                 align = 0x10000;
 618
 619         data.mask = align - 1;
 620         data.offset = base & data.mask;
 621         data.map = &s_data->io_db;
 622
 623         down(&rsrc_sem);
 624 #ifdef CONFIG_PCI
 625         if (s->cb_dev) {
 626                 ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num, 1,
 627                                              min, 0, pcmcia_align, &data);
 628         } else
 629 #endif
 630                 ret = allocate_resource(&ioport_resource, res, num, min, ~0UL,
 631                                         1, pcmcia_align, &data);
 632         up(&rsrc_sem);
 633
 634         if (ret != 0) {
 635                 kfree(res);
 636                 res = NULL;
 637         }
 638         return res;
 639 }
 640
 641 struct resource * nonstatic_find_mem_region(u_long base, u_long num, u_long align,
 642                                  int low, struct pcmcia_socket *s)
 643 {
 644         struct resource *res = make_resource(0, num, IORESOURCE_MEM, s->dev.class_id);
 645         struct socket_data *s_data = s->resource_data;
 646         struct pcmcia_align_data data;
 647         unsigned long min, max;
 648         int ret, i;
 649
 650         low = low || !(s->features & SS_CAP_PAGE_REGS);
 651
 652         data.mask = align - 1;
 653         data.offset = base & data.mask;
 654         data.map = &s_data->mem_db;
 655
 656         for (i = 0; i < 2; i++) {
 657                 if (low) {
 658                         max = 0x100000UL;
 659                         min = base < max ? base : 0;
 660                 } else {
 661                         max = ~0UL;
 662                         min = 0x100000UL + base;
 663                 }
 664
 665                 down(&rsrc_sem);
 666 #ifdef CONFIG_PCI
 667                 if (s->cb_dev) {
 668                         ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num,
 669                                                      1, min, 0,
 670                                                      pcmcia_align, &data);
 671                 } else
 672 #endif
 673                         ret = allocate_resource(&iomem_resource, res, num, min,
 674                                                 max, 1, pcmcia_align, &data);
 675                 up(&rsrc_sem);
 676                 if (ret == 0 || low)
 677                         break;
 678                 low = 1;
 679         }
 680
 681         if (ret != 0) {
 682                 kfree(res);
 683                 res = NULL;
 684         }
 685         return res;
 686 }
 687
 688
 689 static int adjust_memory(struct pcmcia_socket *s, adjust_t *adj)
 690 {
 691         u_long base, num;
 692         struct socket_data *data = s->resource_data;
 693         int ret;
 694
 695         base = adj->resource.memory.Base;
 696         num = adj->resource.memory.Size;
 697         if ((num == 0) || (base+num-1 < base))
 698                 return CS_BAD_SIZE;
 699
 700         ret = CS_SUCCESS;
 701
 702         down(&rsrc_sem);
 703         switch (adj->Action) {
 704         case ADD_MANAGED_RESOURCE:
 705                 ret = add_interval(&data->mem_db, base, num);
 706                 break;
 707         case REMOVE_MANAGED_RESOURCE:
 708                 ret = sub_interval(&data->mem_db, base, num);
 709                 if (ret == CS_SUCCESS) {
 710                         struct pcmcia_socket *socket;
 711                         down_read(&pcmcia_socket_list_rwsem);
 712                         list_for_each_entry(socket, &pcmcia_socket_list, socket_list)
 713                                 release_cis_mem(socket);
 714                         up_read(&pcmcia_socket_list_rwsem);
 715                 }
 716                 break;
 717         default:
 718                 ret = CS_UNSUPPORTED_FUNCTION;
 719         }
 720         up(&rsrc_sem);
 721
 722         return ret;
 723 }
 724
 725
 726 static int adjust_io(struct pcmcia_socket *s, adjust_t *adj)
 727 {
 728         struct socket_data *data = s->resource_data;
 729         kio_addr_t base, num;
 730         int ret = CS_SUCCESS;
 731
 732         base = adj->resource.io.BasePort;
 733         num = adj->resource.io.NumPorts;
 734         if ((base < 0) || (base > 0xffff))
 735                 return CS_BAD_BASE;
 736         if ((num <= 0) || (base+num > 0x10000) || (base+num <= base))
 737                 return CS_BAD_SIZE;
 738
 739         down(&rsrc_sem);
 740         switch (adj->Action) {
 741         case ADD_MANAGED_RESOURCE:
 742                 if (add_interval(&data->io_db, base, num) != 0) {
 743                         ret = CS_IN_USE;
 744                         break;
 745                 }
 746 #ifdef CONFIG_PCMCIA_PROBE
 747                 if (probe_io)
 748                         do_io_probe(s, base, num);
 749 #endif
 750                 break;
 751         case REMOVE_MANAGED_RESOURCE:
 752                 sub_interval(&data->io_db, base, num);
 753                 break;
 754         default:
 755                 ret = CS_UNSUPPORTED_FUNCTION;
 756                 break;
 757         }
 758         up(&rsrc_sem);
 759
 760         return ret;
 761 }
 762
 763
 764 static int nonstatic_adjust_resource_info(struct pcmcia_socket *s, adjust_t *adj)
 765 {
 766         switch (adj->Resource) {
 767         case RES_MEMORY_RANGE:
 768                 return adjust_memory(s, adj);
 769         case RES_IO_RANGE:
 770                 return adjust_io(s, adj);
 771         }
 772         return CS_UNSUPPORTED_FUNCTION;
 773 }
 774
 775 static int nonstatic_init(struct pcmcia_socket *s)
 776 {
 777         struct socket_data *data;
 778
 779         data = kmalloc(sizeof(struct socket_data), GFP_KERNEL);
 780         if (!data)
 781                 return -ENOMEM;
 782
 783         data->mem_db.next = &data->mem_db;
 784         data->io_db.next = &data->io_db;
 785
 786         s->resource_data = (void *) data;
 787
 788         return 0;
 789 }
 790
 791 static void nonstatic_release_resource_db(struct pcmcia_socket *s)
 792 {
 793         struct socket_data *data = s->resource_data;
 794         struct resource_map *p, *q;
 795
 796         down(&rsrc_sem);
 797         for (p = data->mem_db.next; p != &data->mem_db; p = q) {
 798                 q = p->next;
 799                 kfree(p);
 800         }
 801         for (p = data->io_db.next; p != &data->io_db; p = q) {
 802                 q = p->next;
 803                 kfree(p);
 804         }
 805         up(&rsrc_sem);
 806 }
 807
 808
 809 struct pccard_resource_ops pccard_nonstatic_ops = {
 810         .validate_mem = pcmcia_nonstatic_validate_mem,
 811         .adjust_io_region = nonstatic_adjust_io_region,
 812         .find_io = nonstatic_find_io_region,
 813         .find_mem = nonstatic_find_mem_region,
 814         .adjust_resource = nonstatic_adjust_resource_info,
 815         .init = nonstatic_init,
 816         .exit = nonstatic_release_resource_db,
 817 };
 818 EXPORT_SYMBOL(pccard_nonstatic_ops);