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