drivers/pcmcia/rsrc_nonstatic.c

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