drivers/pcmcia/rsrc_nonstatic.c

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