?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pcmcia: do not use ioports < 0x100 on x86
[linux-2.6/btrfs-unstable.git] / drivers / pcmcia / rsrc_nonstatic.c
blobdcc602134d90ddca6e06314cce9c204a9b6bf7d7
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 I/O "
878 "window: 0x%llx - 0x%llx\n",
879 (unsigned long long)res->start,
880 (unsigned long long)res->end);
881 if (!adjust_io(s, ADD_MANAGED_RESOURCE, res->start, res->end))
882 done |= IORESOURCE_IO;
883
884 }
885
886 if (res->flags & IORESOURCE_MEM) {
887 if (res == &iomem_resource)
888 continue;
889 dev_printk(KERN_INFO, &s->cb_dev->dev,
890 "pcmcia: parent PCI bridge Memory "
891 "window: 0x%llx - 0x%llx\n",
892 (unsigned long long)res->start,
893 (unsigned long long)res->end);
894 if (!adjust_memory(s, ADD_MANAGED_RESOURCE, res->start, res->end))
895 done |= IORESOURCE_MEM;
896 }
897 }
898
899 /* if we got at least one of IO, and one of MEM, we can be glad and
900 * activate the PCMCIA subsystem */
901 if (done == (IORESOURCE_MEM | IORESOURCE_IO))
902 s->resource_setup_done = 1;
903
904 return 0;
905 }
906
907 #else
908
909 static inline int nonstatic_autoadd_resources(struct pcmcia_socket *s)
910 {
911 return -ENODEV;
912 }
913
914 #endif
915
916
917 static int nonstatic_init(struct pcmcia_socket *s)
918 {
919 struct socket_data *data;
920
921 data = kzalloc(sizeof(struct socket_data), GFP_KERNEL);
922 if (!data)
923 return -ENOMEM;
924
925 data->mem_db.next = &data->mem_db;
926 data->mem_db_valid.next = &data->mem_db_valid;
927 data->io_db.next = &data->io_db;
928
929 s->resource_data = (void *) data;
930
931 nonstatic_autoadd_resources(s);
932
933 return 0;
934 }
935
936 static void nonstatic_release_resource_db(struct pcmcia_socket *s)
937 {
938 struct socket_data *data = s->resource_data;
939 struct resource_map *p, *q;
940
941 for (p = data->mem_db_valid.next; p != &data->mem_db_valid; p = q) {
942 q = p->next;
943 kfree(p);
944 }
945 for (p = data->mem_db.next; p != &data->mem_db; p = q) {
946 q = p->next;
947 kfree(p);
948 }
949 for (p = data->io_db.next; p != &data->io_db; p = q) {
950 q = p->next;
951 kfree(p);
952 }
953 }
954
955
956 struct pccard_resource_ops pccard_nonstatic_ops = {
957 .validate_mem = pcmcia_nonstatic_validate_mem,
958 .adjust_io_region = nonstatic_adjust_io_region,
959 .find_io = nonstatic_find_io_region,
960 .find_mem = nonstatic_find_mem_region,
961 .add_io = adjust_io,
962 .add_mem = adjust_memory,
963 .init = nonstatic_init,
964 .exit = nonstatic_release_resource_db,
965 };
966 EXPORT_SYMBOL(pccard_nonstatic_ops);
967
968
969 /* sysfs interface to the resource database */
970
971 static ssize_t show_io_db(struct device *dev,
972 struct device_attribute *attr, char *buf)
973 {
974 struct pcmcia_socket *s = dev_get_drvdata(dev);
975 struct socket_data *data;
976 struct resource_map *p;
977 ssize_t ret = 0;
978
979 mutex_lock(&s->ops_mutex);
980 data = s->resource_data;
981
982 for (p = data->io_db.next; p != &data->io_db; p = p->next) {
983 if (ret > (PAGE_SIZE - 10))
984 continue;
985 ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1),
986 "0x%08lx - 0x%08lx\n",
987 ((unsigned long) p->base),
988 ((unsigned long) p->base + p->num - 1));
989 }
990
991 mutex_unlock(&s->ops_mutex);
992 return ret;
993 }
994
995 static ssize_t store_io_db(struct device *dev,
996 struct device_attribute *attr,
997 const char *buf, size_t count)
998 {
999 struct pcmcia_socket *s = dev_get_drvdata(dev);
1000 unsigned long start_addr, end_addr;
1001 unsigned int add = ADD_MANAGED_RESOURCE;
1002 ssize_t ret = 0;
1003
1004 ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
1005 if (ret != 2) {
1006 ret = sscanf(buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
1007 add = REMOVE_MANAGED_RESOURCE;
1008 if (ret != 2) {
1009 ret = sscanf(buf, "0x%lx - 0x%lx", &start_addr,
1010 &end_addr);
1011 add = ADD_MANAGED_RESOURCE;
1012 if (ret != 2)
1013 return -EINVAL;
1014 }
1015 }
1016 if (end_addr < start_addr)
1017 return -EINVAL;
1018
1019 mutex_lock(&s->ops_mutex);
1020 ret = adjust_io(s, add, start_addr, end_addr);
1021 if (!ret)
1022 s->resource_setup_new = 1;
1023 mutex_unlock(&s->ops_mutex);
1024
1025 return ret ? ret : count;
1026 }
1027 static DEVICE_ATTR(available_resources_io, 0600, show_io_db, store_io_db);
1028
1029 static ssize_t show_mem_db(struct device *dev,
1030 struct device_attribute *attr, char *buf)
1031 {
1032 struct pcmcia_socket *s = dev_get_drvdata(dev);
1033 struct socket_data *data;
1034 struct resource_map *p;
1035 ssize_t ret = 0;
1036
1037 mutex_lock(&s->ops_mutex);
1038 data = s->resource_data;
1039
1040 for (p = data->mem_db_valid.next; p != &data->mem_db_valid;
1041 p = p->next) {
1042 if (ret > (PAGE_SIZE - 10))
1043 continue;
1044 ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1),
1045 "0x%08lx - 0x%08lx\n",
1046 ((unsigned long) p->base),
1047 ((unsigned long) p->base + p->num - 1));
1048 }
1049
1050 for (p = data->mem_db.next; p != &data->mem_db; p = p->next) {
1051 if (ret > (PAGE_SIZE - 10))
1052 continue;
1053 ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1),
1054 "0x%08lx - 0x%08lx\n",
1055 ((unsigned long) p->base),
1056 ((unsigned long) p->base + p->num - 1));
1057 }
1058
1059 mutex_unlock(&s->ops_mutex);
1060 return ret;
1061 }
1062
1063 static ssize_t store_mem_db(struct device *dev,
1064 struct device_attribute *attr,
1065 const char *buf, size_t count)
1066 {
1067 struct pcmcia_socket *s = dev_get_drvdata(dev);
1068 unsigned long start_addr, end_addr;
1069 unsigned int add = ADD_MANAGED_RESOURCE;
1070 ssize_t ret = 0;
1071
1072 ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
1073 if (ret != 2) {
1074 ret = sscanf(buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
1075 add = REMOVE_MANAGED_RESOURCE;
1076 if (ret != 2) {
1077 ret = sscanf(buf, "0x%lx - 0x%lx", &start_addr,
1078 &end_addr);
1079 add = ADD_MANAGED_RESOURCE;
1080 if (ret != 2)
1081 return -EINVAL;
1082 }
1083 }
1084 if (end_addr < start_addr)
1085 return -EINVAL;
1086
1087 mutex_lock(&s->ops_mutex);
1088 ret = adjust_memory(s, add, start_addr, end_addr);
1089 if (!ret)
1090 s->resource_setup_new = 1;
1091 mutex_unlock(&s->ops_mutex);
1092
1093 return ret ? ret : count;
1094 }
1095 static DEVICE_ATTR(available_resources_mem, 0600, show_mem_db, store_mem_db);
1096
1097 static struct attribute *pccard_rsrc_attributes[] = {
1098 &dev_attr_available_resources_io.attr,
1099 &dev_attr_available_resources_mem.attr,
1100 NULL,
1101 };
1102
1103 static const struct attribute_group rsrc_attributes = {
1104 .attrs = pccard_rsrc_attributes,
1105 };
1106
1107 static int __devinit pccard_sysfs_add_rsrc(struct device *dev,
1108 struct class_interface *class_intf)
1109 {
1110 struct pcmcia_socket *s = dev_get_drvdata(dev);
1111
1112 if (s->resource_ops != &pccard_nonstatic_ops)
1113 return 0;
1114 return sysfs_create_group(&dev->kobj, &rsrc_attributes);
1115 }
1116
1117 static void __devexit pccard_sysfs_remove_rsrc(struct device *dev,
1118 struct class_interface *class_intf)
1119 {
1120 struct pcmcia_socket *s = dev_get_drvdata(dev);
1121
1122 if (s->resource_ops != &pccard_nonstatic_ops)
1123 return;
1124 sysfs_remove_group(&dev->kobj, &rsrc_attributes);
1125 }
1126
1127 static struct class_interface pccard_rsrc_interface __refdata = {
1128 .class = &pcmcia_socket_class,
1129 .add_dev = &pccard_sysfs_add_rsrc,
1130 .remove_dev = __devexit_p(&pccard_sysfs_remove_rsrc),
1131 };
1132
1133 static int __init nonstatic_sysfs_init(void)
1134 {
1135 return class_interface_register(&pccard_rsrc_interface);
1136 }
1137
1138 static void __exit nonstatic_sysfs_exit(void)
1139 {
1140 class_interface_unregister(&pccard_rsrc_interface);
1141 }
1142
1143 module_init(nonstatic_sysfs_init);
1144 module_exit(nonstatic_sysfs_exit);
(deprecated) Btrfs devel tree