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