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