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