?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ecryptfs: fix use with tmpfs by removing d_drop from ecryptfs_destroy_inode
[linux/fpc-iii.git] / drivers / pcmcia / rsrc_nonstatic.c
blob4663b3fa9f9616a66db5214fc6f5ef16c1b37dc0
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 (end < start)
814 return -EINVAL;
815
816 if (end > IO_SPACE_LIMIT)
817 return -EINVAL;
818
819 switch (action) {
820 case ADD_MANAGED_RESOURCE:
821 if (add_interval(&data->io_db, start, size) != 0) {
822 ret = -EBUSY;
823 break;
824 }
825 #ifdef CONFIG_PCMCIA_PROBE
826 if (probe_io)
827 do_io_probe(s, start, size);
828 #endif
829 break;
830 case REMOVE_MANAGED_RESOURCE:
831 sub_interval(&data->io_db, start, size);
832 break;
833 default:
834 ret = -EINVAL;
835 break;
836 }
837
838 return ret;
839 }
840
841
842 #ifdef CONFIG_PCI
843 static int nonstatic_autoadd_resources(struct pcmcia_socket *s)
844 {
845 struct resource *res;
846 int i, done = 0;
847
848 if (!s->cb_dev || !s->cb_dev->bus)
849 return -ENODEV;
850
851 #if defined(CONFIG_X86)
852 /* If this is the root bus, the risk of hitting
853 * some strange system devices which aren't protected
854 * by either ACPI resource tables or properly requested
855 * resources is too big. Therefore, don't do auto-adding
856 * of resources at the moment.
857 */
858 if (s->cb_dev->bus->number == 0)
859 return -EINVAL;
860 #endif
861
862 pci_bus_for_each_resource(s->cb_dev->bus, res, i) {
863 if (!res)
864 continue;
865
866 if (res->flags & IORESOURCE_IO) {
867 if (res == &ioport_resource)
868 continue;
869 dev_printk(KERN_INFO, &s->cb_dev->dev,
870 "pcmcia: parent PCI bridge I/O "
871 "window: 0x%llx - 0x%llx\n",
872 (unsigned long long)res->start,
873 (unsigned long long)res->end);
874 if (!adjust_io(s, ADD_MANAGED_RESOURCE, res->start, res->end))
875 done |= IORESOURCE_IO;
876
877 }
878
879 if (res->flags & IORESOURCE_MEM) {
880 if (res == &iomem_resource)
881 continue;
882 dev_printk(KERN_INFO, &s->cb_dev->dev,
883 "pcmcia: parent PCI bridge Memory "
884 "window: 0x%llx - 0x%llx\n",
885 (unsigned long long)res->start,
886 (unsigned long long)res->end);
887 if (!adjust_memory(s, ADD_MANAGED_RESOURCE, res->start, res->end))
888 done |= IORESOURCE_MEM;
889 }
890 }
891
892 /* if we got at least one of IO, and one of MEM, we can be glad and
893 * activate the PCMCIA subsystem */
894 if (done == (IORESOURCE_MEM | IORESOURCE_IO))
895 s->resource_setup_done = 1;
896
897 return 0;
898 }
899
900 #else
901
902 static inline int nonstatic_autoadd_resources(struct pcmcia_socket *s)
903 {
904 return -ENODEV;
905 }
906
907 #endif
908
909
910 static int nonstatic_init(struct pcmcia_socket *s)
911 {
912 struct socket_data *data;
913
914 data = kzalloc(sizeof(struct socket_data), GFP_KERNEL);
915 if (!data)
916 return -ENOMEM;
917
918 data->mem_db.next = &data->mem_db;
919 data->mem_db_valid.next = &data->mem_db_valid;
920 data->io_db.next = &data->io_db;
921
922 s->resource_data = (void *) data;
923
924 nonstatic_autoadd_resources(s);
925
926 return 0;
927 }
928
929 static void nonstatic_release_resource_db(struct pcmcia_socket *s)
930 {
931 struct socket_data *data = s->resource_data;
932 struct resource_map *p, *q;
933
934 for (p = data->mem_db_valid.next; p != &data->mem_db_valid; p = q) {
935 q = p->next;
936 kfree(p);
937 }
938 for (p = data->mem_db.next; p != &data->mem_db; p = q) {
939 q = p->next;
940 kfree(p);
941 }
942 for (p = data->io_db.next; p != &data->io_db; p = q) {
943 q = p->next;
944 kfree(p);
945 }
946 }
947
948
949 struct pccard_resource_ops pccard_nonstatic_ops = {
950 .validate_mem = pcmcia_nonstatic_validate_mem,
951 .adjust_io_region = nonstatic_adjust_io_region,
952 .find_io = nonstatic_find_io_region,
953 .find_mem = nonstatic_find_mem_region,
954 .add_io = adjust_io,
955 .add_mem = adjust_memory,
956 .init = nonstatic_init,
957 .exit = nonstatic_release_resource_db,
958 };
959 EXPORT_SYMBOL(pccard_nonstatic_ops);
960
961
962 /* sysfs interface to the resource database */
963
964 static ssize_t show_io_db(struct device *dev,
965 struct device_attribute *attr, char *buf)
966 {
967 struct pcmcia_socket *s = dev_get_drvdata(dev);
968 struct socket_data *data;
969 struct resource_map *p;
970 ssize_t ret = 0;
971
972 mutex_lock(&s->ops_mutex);
973 data = s->resource_data;
974
975 for (p = data->io_db.next; p != &data->io_db; p = p->next) {
976 if (ret > (PAGE_SIZE - 10))
977 continue;
978 ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1),
979 "0x%08lx - 0x%08lx\n",
980 ((unsigned long) p->base),
981 ((unsigned long) p->base + p->num - 1));
982 }
983
984 mutex_unlock(&s->ops_mutex);
985 return ret;
986 }
987
988 static ssize_t store_io_db(struct device *dev,
989 struct device_attribute *attr,
990 const char *buf, size_t count)
991 {
992 struct pcmcia_socket *s = dev_get_drvdata(dev);
993 unsigned long start_addr, end_addr;
994 unsigned int add = ADD_MANAGED_RESOURCE;
995 ssize_t ret = 0;
996
997 ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
998 if (ret != 2) {
999 ret = sscanf(buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
1000 add = REMOVE_MANAGED_RESOURCE;
1001 if (ret != 2) {
1002 ret = sscanf(buf, "0x%lx - 0x%lx", &start_addr,
1003 &end_addr);
1004 add = ADD_MANAGED_RESOURCE;
1005 if (ret != 2)
1006 return -EINVAL;
1007 }
1008 }
1009 if (end_addr < start_addr)
1010 return -EINVAL;
1011
1012 mutex_lock(&s->ops_mutex);
1013 ret = adjust_io(s, add, start_addr, end_addr);
1014 if (!ret)
1015 s->resource_setup_new = 1;
1016 mutex_unlock(&s->ops_mutex);
1017
1018 return ret ? ret : count;
1019 }
1020 static DEVICE_ATTR(available_resources_io, 0600, show_io_db, store_io_db);
1021
1022 static ssize_t show_mem_db(struct device *dev,
1023 struct device_attribute *attr, char *buf)
1024 {
1025 struct pcmcia_socket *s = dev_get_drvdata(dev);
1026 struct socket_data *data;
1027 struct resource_map *p;
1028 ssize_t ret = 0;
1029
1030 mutex_lock(&s->ops_mutex);
1031 data = s->resource_data;
1032
1033 for (p = data->mem_db_valid.next; p != &data->mem_db_valid;
1034 p = p->next) {
1035 if (ret > (PAGE_SIZE - 10))
1036 continue;
1037 ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1),
1038 "0x%08lx - 0x%08lx\n",
1039 ((unsigned long) p->base),
1040 ((unsigned long) p->base + p->num - 1));
1041 }
1042
1043 for (p = data->mem_db.next; p != &data->mem_db; p = p->next) {
1044 if (ret > (PAGE_SIZE - 10))
1045 continue;
1046 ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1),
1047 "0x%08lx - 0x%08lx\n",
1048 ((unsigned long) p->base),
1049 ((unsigned long) p->base + p->num - 1));
1050 }
1051
1052 mutex_unlock(&s->ops_mutex);
1053 return ret;
1054 }
1055
1056 static ssize_t store_mem_db(struct device *dev,
1057 struct device_attribute *attr,
1058 const char *buf, size_t count)
1059 {
1060 struct pcmcia_socket *s = dev_get_drvdata(dev);
1061 unsigned long start_addr, end_addr;
1062 unsigned int add = ADD_MANAGED_RESOURCE;
1063 ssize_t ret = 0;
1064
1065 ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
1066 if (ret != 2) {
1067 ret = sscanf(buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
1068 add = REMOVE_MANAGED_RESOURCE;
1069 if (ret != 2) {
1070 ret = sscanf(buf, "0x%lx - 0x%lx", &start_addr,
1071 &end_addr);
1072 add = ADD_MANAGED_RESOURCE;
1073 if (ret != 2)
1074 return -EINVAL;
1075 }
1076 }
1077 if (end_addr < start_addr)
1078 return -EINVAL;
1079
1080 mutex_lock(&s->ops_mutex);
1081 ret = adjust_memory(s, add, start_addr, end_addr);
1082 if (!ret)
1083 s->resource_setup_new = 1;
1084 mutex_unlock(&s->ops_mutex);
1085
1086 return ret ? ret : count;
1087 }
1088 static DEVICE_ATTR(available_resources_mem, 0600, show_mem_db, store_mem_db);
1089
1090 static struct attribute *pccard_rsrc_attributes[] = {
1091 &dev_attr_available_resources_io.attr,
1092 &dev_attr_available_resources_mem.attr,
1093 NULL,
1094 };
1095
1096 static const struct attribute_group rsrc_attributes = {
1097 .attrs = pccard_rsrc_attributes,
1098 };
1099
1100 static int __devinit pccard_sysfs_add_rsrc(struct device *dev,
1101 struct class_interface *class_intf)
1102 {
1103 struct pcmcia_socket *s = dev_get_drvdata(dev);
1104
1105 if (s->resource_ops != &pccard_nonstatic_ops)
1106 return 0;
1107 return sysfs_create_group(&dev->kobj, &rsrc_attributes);
1108 }
1109
1110 static void __devexit pccard_sysfs_remove_rsrc(struct device *dev,
1111 struct class_interface *class_intf)
1112 {
1113 struct pcmcia_socket *s = dev_get_drvdata(dev);
1114
1115 if (s->resource_ops != &pccard_nonstatic_ops)
1116 return;
1117 sysfs_remove_group(&dev->kobj, &rsrc_attributes);
1118 }
1119
1120 static struct class_interface pccard_rsrc_interface __refdata = {
1121 .class = &pcmcia_socket_class,
1122 .add_dev = &pccard_sysfs_add_rsrc,
1123 .remove_dev = __devexit_p(&pccard_sysfs_remove_rsrc),
1124 };
1125
1126 static int __init nonstatic_sysfs_init(void)
1127 {
1128 return class_interface_register(&pccard_rsrc_interface);
1129 }
1130
1131 static void __exit nonstatic_sysfs_exit(void)
1132 {
1133 class_interface_unregister(&pccard_rsrc_interface);
1134 }
1135
1136 module_init(nonstatic_sysfs_init);
1137 module_exit(nonstatic_sysfs_exit);
Linux with added FPC-III support