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