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