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