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