blob: 70d2e010e654c410967faa46e50c056e0a7f6b31 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#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
Dominik Brodowski7fe908d2006-01-10 21:20:36 +010063static DEFINE_MUTEX(rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#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 *
Greg Kroah-Hartman2427ddd2006-06-12 17:07:52 -070075make_resource(resource_size_t b, resource_size_t n, int flags, char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -070076{
Dominik Brodowski8084b372005-12-11 21:18:26 +010077 struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79 if (res) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 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 *
Greg Kroah-Hartman2427ddd2006-06-12 17:07:52 -070089claim_region(struct pcmcia_socket *s, resource_size_t base,
90 resource_size_t size, int type, char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
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
Olof Johansson906da809c2008-02-04 22:27:35 -0800189static void do_io_probe(struct pcmcia_socket *s, unsigned int base,
190 unsigned int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191{
192 struct resource *res;
193 struct socket_data *s_data = s->resource_data;
Olof Johansson906da809c2008-02-04 22:27:35 -0800194 unsigned int i, j, bad;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 int any;
196 u_char *b, hole, most;
197
Olof Johansson906da809c2008-02-04 22:27:35 -0800198 printk(KERN_INFO "cs: IO port probe %#x-%#x:",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 base, base+num-1);
200
201 /* First, what does a floating port look like? */
Dominik Brodowski8084b372005-12-11 21:18:26 +0100202 b = kzalloc(256, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 if (!b) {
204 printk(KERN_ERR "do_io_probe: unable to kmalloc 256 bytes");
205 return;
206 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 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);
Olof Johansson906da809c2008-02-04 22:27:35 -0800237 printk(" %#x-%#x", bad, i-1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 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);
Olof Johansson906da809c2008-02-04 22:27:35 -0800248 printk(" %#x-%#x", bad, i-1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 }
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 */
Dominik Brodowskic5081d52008-06-19 20:12:34 +0200264static int readable(struct pcmcia_socket *s, struct resource *res,
265 unsigned int *count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266{
267 int ret = -1;
268
269 s->cis_mem.res = res;
270 s->cis_virt = ioremap(res->start, s->map_size);
271 if (s->cis_virt) {
Dominik Brodowskic5081d52008-06-19 20:12:34 +0200272 ret = pccard_validate_cis(s, BIND_FN_ALL, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 /* invalidate mapping and CIS cache */
274 iounmap(s->cis_virt);
275 s->cis_virt = NULL;
276 destroy_cis_cache(s);
277 }
278 s->cis_mem.res = NULL;
Dominik Brodowskic5081d52008-06-19 20:12:34 +0200279 if ((ret != 0) || (count == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 return 0;
281 return 1;
282}
283
284/* Validation function for simple memory cards */
285static int checksum(struct pcmcia_socket *s, struct resource *res)
286{
287 pccard_mem_map map;
288 int i, a = 0, b = -1, d;
289 void __iomem *virt;
290
291 virt = ioremap(res->start, s->map_size);
292 if (virt) {
293 map.map = 0;
294 map.flags = MAP_ACTIVE;
295 map.speed = 0;
296 map.res = res;
297 map.card_start = 0;
298 s->ops->set_mem_map(s, &map);
299
300 /* Don't bother checking every word... */
301 for (i = 0; i < s->map_size; i += 44) {
302 d = readl(virt+i);
303 a += d;
304 b &= d;
305 }
306
307 map.flags = 0;
308 s->ops->set_mem_map(s, &map);
309
310 iounmap(virt);
311 }
312
313 return (b == -1) ? -1 : (a>>1);
314}
315
316static int
317cis_readable(struct pcmcia_socket *s, unsigned long base, unsigned long size)
318{
319 struct resource *res1, *res2;
Dominik Brodowskic5081d52008-06-19 20:12:34 +0200320 unsigned int info1, info2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 int ret = 0;
322
323 res1 = claim_region(s, base, size/2, IORESOURCE_MEM, "cs memory probe");
324 res2 = claim_region(s, base + size/2, size/2, IORESOURCE_MEM, "cs memory probe");
325
326 if (res1 && res2) {
327 ret = readable(s, res1, &info1);
328 ret += readable(s, res2, &info2);
329 }
330
331 free_region(res2);
332 free_region(res1);
333
Dominik Brodowskic5081d52008-06-19 20:12:34 +0200334 return (ret == 2) && (info1 == info2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335}
336
337static int
338checksum_match(struct pcmcia_socket *s, unsigned long base, unsigned long size)
339{
340 struct resource *res1, *res2;
341 int a = -1, b = -1;
342
343 res1 = claim_region(s, base, size/2, IORESOURCE_MEM, "cs memory probe");
344 res2 = claim_region(s, base + size/2, size/2, IORESOURCE_MEM, "cs memory probe");
345
346 if (res1 && res2) {
347 a = checksum(s, res1);
348 b = checksum(s, res2);
349 }
350
351 free_region(res2);
352 free_region(res1);
353
354 return (a == b) && (a >= 0);
355}
356
357/*======================================================================
358
359 The memory probe. If the memory list includes a 64K-aligned block
360 below 1MB, we probe in 64K chunks, and as soon as we accumulate at
361 least mem_limit free space, we quit.
362
363======================================================================*/
364
365static int do_mem_probe(u_long base, u_long num, struct pcmcia_socket *s)
366{
367 struct socket_data *s_data = s->resource_data;
368 u_long i, j, bad, fail, step;
369
370 printk(KERN_INFO "cs: memory probe 0x%06lx-0x%06lx:",
371 base, base+num-1);
372 bad = fail = 0;
373 step = (num < 0x20000) ? 0x2000 : ((num>>4) & ~0x1fff);
Dominik Brodowski2ad0a0a2005-06-27 16:28:58 -0700374 /* don't allow too large steps */
375 if (step > 0x800000)
376 step = 0x800000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 /* cis_readable wants to map 2x map_size */
378 if (step < 2 * s->map_size)
379 step = 2 * s->map_size;
380 for (i = j = base; i < base+num; i = j + step) {
381 if (!fail) {
382 for (j = i; j < base+num; j += step) {
383 if (cis_readable(s, j, step))
384 break;
385 }
386 fail = ((i == base) && (j == base+num));
387 }
388 if (fail) {
389 for (j = i; j < base+num; j += 2*step)
390 if (checksum_match(s, j, step) &&
391 checksum_match(s, j + step, step))
392 break;
393 }
394 if (i != j) {
395 if (!bad) printk(" excluding");
396 printk(" %#05lx-%#05lx", i, j-1);
397 sub_interval(&s_data->mem_db, i, j-i);
398 bad += j-i;
399 }
400 }
401 printk(bad ? "\n" : " clean.\n");
402 return (num - bad);
403}
404
405#ifdef CONFIG_PCMCIA_PROBE
406
407static u_long inv_probe(struct resource_map *m, struct pcmcia_socket *s)
408{
Dominik Brodowskide759142005-09-28 19:41:56 +0200409 struct socket_data *s_data = s->resource_data;
410 u_long ok;
411 if (m == &s_data->mem_db)
412 return 0;
413 ok = inv_probe(m->next, s);
414 if (ok) {
415 if (m->base >= 0x100000)
416 sub_interval(&s_data->mem_db, m->base, m->num);
417 return ok;
418 }
419 if (m->base < 0x100000)
420 return 0;
421 return do_mem_probe(m->base, m->num, s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422}
423
Dominik Brodowskide759142005-09-28 19:41:56 +0200424static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425{
Dominik Brodowskide759142005-09-28 19:41:56 +0200426 struct resource_map *m, mm;
427 static unsigned char order[] = { 0xd0, 0xe0, 0xc0, 0xf0 };
428 unsigned long b, i, ok = 0;
429 struct socket_data *s_data = s->resource_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
Dominik Brodowskide759142005-09-28 19:41:56 +0200431 /* We do up to four passes through the list */
432 if (probe_mask & MEM_PROBE_HIGH) {
433 if (inv_probe(s_data->mem_db.next, s) > 0)
434 return 0;
435 printk(KERN_NOTICE "cs: warning: no high memory space "
436 "available!\n");
437 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 }
Dominik Brodowskide759142005-09-28 19:41:56 +0200439
440 for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) {
441 mm = *m;
442 /* Only probe < 1 MB */
443 if (mm.base >= 0x100000)
444 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 }
Dominik Brodowskide759142005-09-28 19:41:56 +0200460
461 if (ok > 0)
462 return 0;
463
464 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465}
466
467#else /* CONFIG_PCMCIA_PROBE */
468
Andrew Morton2cff9442005-11-16 21:29:26 -0800469static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470{
471 struct resource_map *m, mm;
472 struct socket_data *s_data = s->resource_data;
Andrew Morton2cff9442005-11-16 21:29:26 -0800473 unsigned long ok = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
475 for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) {
476 mm = *m;
Andrew Morton2cff9442005-11-16 21:29:26 -0800477 ok += do_mem_probe(mm.base, mm.num, s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 }
Andrew Morton2cff9442005-11-16 21:29:26 -0800479 if (ok > 0)
480 return 0;
481 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482}
483
484#endif /* CONFIG_PCMCIA_PROBE */
485
486
487/*
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100488 * Locking note: Must be called with skt_mutex held!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 */
Dominik Brodowskide759142005-09-28 19:41:56 +0200490static int pcmcia_nonstatic_validate_mem(struct pcmcia_socket *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491{
492 struct socket_data *s_data = s->resource_data;
Dominik Brodowskide759142005-09-28 19:41:56 +0200493 unsigned int probe_mask = MEM_PROBE_LOW;
494 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
Dominik Brodowskide759142005-09-28 19:41:56 +0200496 if (!probe_mem)
497 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100499 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Dominik Brodowskide759142005-09-28 19:41:56 +0200501 if (s->features & SS_CAP_PAGE_REGS)
502 probe_mask = MEM_PROBE_HIGH;
503
504 if (probe_mask & ~s_data->rsrc_mem_probe) {
505 if (s->state & SOCKET_PRESENT)
506 ret = validate_mem(s, probe_mask);
507 if (!ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 s_data->rsrc_mem_probe |= probe_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 }
Dominik Brodowskide759142005-09-28 19:41:56 +0200510
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100511 mutex_unlock(&rsrc_mutex);
Dominik Brodowskide759142005-09-28 19:41:56 +0200512
513 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514}
515
516struct pcmcia_align_data {
517 unsigned long mask;
518 unsigned long offset;
519 struct resource_map *map;
520};
521
522static void
523pcmcia_common_align(void *align_data, struct resource *res,
Greg Kroah-Hartman2427ddd2006-06-12 17:07:52 -0700524 resource_size_t size, resource_size_t align)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525{
526 struct pcmcia_align_data *data = align_data;
Greg Kroah-Hartman2427ddd2006-06-12 17:07:52 -0700527 resource_size_t start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 /*
529 * Ensure that we have the correct start address
530 */
531 start = (res->start & ~data->mask) + data->offset;
532 if (start < res->start)
533 start += data->mask + 1;
534 res->start = start;
535}
536
537static void
Greg Kroah-Hartman2427ddd2006-06-12 17:07:52 -0700538pcmcia_align(void *align_data, struct resource *res, resource_size_t size,
539 resource_size_t align)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540{
541 struct pcmcia_align_data *data = align_data;
542 struct resource_map *m;
543
544 pcmcia_common_align(data, res, size, align);
545
546 for (m = data->map->next; m != data->map; m = m->next) {
547 unsigned long start = m->base;
548 unsigned long end = m->base + m->num - 1;
549
550 /*
551 * If the lower resources are not available, try aligning
552 * to this entry of the resource database to see if it'll
553 * fit here.
554 */
555 if (res->start < start) {
556 res->start = start;
557 pcmcia_common_align(data, res, size, align);
558 }
559
560 /*
561 * If we're above the area which was passed in, there's
562 * no point proceeding.
563 */
564 if (res->start >= res->end)
565 break;
566
567 if ((res->start + size - 1) <= end)
568 break;
569 }
570
571 /*
572 * If we failed to find something suitable, ensure we fail.
573 */
574 if (m == data->map)
575 res->start = res->end;
576}
577
578/*
579 * Adjust an existing IO region allocation, but making sure that we don't
580 * encroach outside the resources which the user supplied.
581 */
582static int nonstatic_adjust_io_region(struct resource *res, unsigned long r_start,
583 unsigned long r_end, struct pcmcia_socket *s)
584{
585 struct resource_map *m;
586 struct socket_data *s_data = s->resource_data;
587 int ret = -ENOMEM;
588
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100589 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 for (m = s_data->io_db.next; m != &s_data->io_db; m = m->next) {
591 unsigned long start = m->base;
592 unsigned long end = m->base + m->num - 1;
593
594 if (start > r_start || r_end > end)
595 continue;
596
597 ret = adjust_resource(res, r_start, r_end - r_start + 1);
598 break;
599 }
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100600 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
602 return ret;
603}
604
605/*======================================================================
606
607 These find ranges of I/O ports or memory addresses that are not
608 currently allocated by other devices.
609
610 The 'align' field should reflect the number of bits of address
611 that need to be preserved from the initial value of *base. It
612 should be a power of two, greater than or equal to 'num'. A value
613 of 0 means that all bits of *base are significant. *base should
614 also be strictly less than 'align'.
615
616======================================================================*/
617
Dominik Brodowskie94e15f2005-06-27 16:28:15 -0700618static struct resource *nonstatic_find_io_region(unsigned long base, int num,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 unsigned long align, struct pcmcia_socket *s)
620{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200621 struct resource *res = make_resource(0, num, IORESOURCE_IO, s->dev.bus_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 struct socket_data *s_data = s->resource_data;
623 struct pcmcia_align_data data;
624 unsigned long min = base;
625 int ret;
626
627 if (align == 0)
628 align = 0x10000;
629
630 data.mask = align - 1;
631 data.offset = base & data.mask;
632 data.map = &s_data->io_db;
633
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100634 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635#ifdef CONFIG_PCI
636 if (s->cb_dev) {
637 ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num, 1,
638 min, 0, pcmcia_align, &data);
639 } else
640#endif
641 ret = allocate_resource(&ioport_resource, res, num, min, ~0UL,
642 1, pcmcia_align, &data);
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100643 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
645 if (ret != 0) {
646 kfree(res);
647 res = NULL;
648 }
649 return res;
650}
651
Dominik Brodowskie94e15f2005-06-27 16:28:15 -0700652static struct resource * nonstatic_find_mem_region(u_long base, u_long num,
653 u_long align, int low, struct pcmcia_socket *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200655 struct resource *res = make_resource(0, num, IORESOURCE_MEM, s->dev.bus_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 struct socket_data *s_data = s->resource_data;
657 struct pcmcia_align_data data;
658 unsigned long min, max;
659 int ret, i;
660
661 low = low || !(s->features & SS_CAP_PAGE_REGS);
662
663 data.mask = align - 1;
664 data.offset = base & data.mask;
665 data.map = &s_data->mem_db;
666
667 for (i = 0; i < 2; i++) {
668 if (low) {
669 max = 0x100000UL;
670 min = base < max ? base : 0;
671 } else {
672 max = ~0UL;
673 min = 0x100000UL + base;
674 }
675
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100676 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677#ifdef CONFIG_PCI
678 if (s->cb_dev) {
679 ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num,
680 1, min, 0,
681 pcmcia_align, &data);
682 } else
683#endif
684 ret = allocate_resource(&iomem_resource, res, num, min,
685 max, 1, pcmcia_align, &data);
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100686 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 if (ret == 0 || low)
688 break;
689 low = 1;
690 }
691
692 if (ret != 0) {
693 kfree(res);
694 res = NULL;
695 }
696 return res;
697}
698
699
Dominik Brodowski22916632005-06-27 16:28:46 -0700700static int adjust_memory(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 struct socket_data *data = s->resource_data;
Dominik Brodowski22916632005-06-27 16:28:46 -0700703 unsigned long size = end - start + 1;
704 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
Dominik Brodowski1146bc72005-09-28 19:28:37 +0200706 if (end < start)
Dominik Brodowski22916632005-06-27 16:28:46 -0700707 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100709 mutex_lock(&rsrc_mutex);
Dominik Brodowski22916632005-06-27 16:28:46 -0700710 switch (action) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 case ADD_MANAGED_RESOURCE:
Dominik Brodowski22916632005-06-27 16:28:46 -0700712 ret = add_interval(&data->mem_db, start, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 break;
714 case REMOVE_MANAGED_RESOURCE:
Dominik Brodowski22916632005-06-27 16:28:46 -0700715 ret = sub_interval(&data->mem_db, start, size);
716 if (!ret) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 struct pcmcia_socket *socket;
718 down_read(&pcmcia_socket_list_rwsem);
719 list_for_each_entry(socket, &pcmcia_socket_list, socket_list)
720 release_cis_mem(socket);
721 up_read(&pcmcia_socket_list_rwsem);
722 }
723 break;
724 default:
Dominik Brodowski22916632005-06-27 16:28:46 -0700725 ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 }
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100727 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
729 return ret;
730}
731
732
Dominik Brodowski22916632005-06-27 16:28:46 -0700733static int adjust_io(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734{
735 struct socket_data *data = s->resource_data;
Dominik Brodowski22916632005-06-27 16:28:46 -0700736 unsigned long size = end - start + 1;
737 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
Dominik Brodowski1146bc72005-09-28 19:28:37 +0200739 if (end < start)
Dominik Brodowski22916632005-06-27 16:28:46 -0700740 return -EINVAL;
741
742 if (end > IO_SPACE_LIMIT)
743 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100745 mutex_lock(&rsrc_mutex);
Dominik Brodowski22916632005-06-27 16:28:46 -0700746 switch (action) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 case ADD_MANAGED_RESOURCE:
Dominik Brodowski22916632005-06-27 16:28:46 -0700748 if (add_interval(&data->io_db, start, size) != 0) {
749 ret = -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 break;
751 }
752#ifdef CONFIG_PCMCIA_PROBE
753 if (probe_io)
Dominik Brodowski22916632005-06-27 16:28:46 -0700754 do_io_probe(s, start, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755#endif
756 break;
757 case REMOVE_MANAGED_RESOURCE:
Dominik Brodowski22916632005-06-27 16:28:46 -0700758 sub_interval(&data->io_db, start, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 break;
760 default:
Dominik Brodowski22916632005-06-27 16:28:46 -0700761 ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 break;
763 }
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100764 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
766 return ret;
767}
768
769
Dominik Brodowski3c299762005-06-27 16:28:46 -0700770#ifdef CONFIG_PCI
771static int nonstatic_autoadd_resources(struct pcmcia_socket *s)
772{
773 struct resource *res;
774 int i, done = 0;
775
776 if (!s->cb_dev || !s->cb_dev->bus)
777 return -ENODEV;
778
Brian Gerst0d078f62005-10-30 14:59:20 -0800779#if defined(CONFIG_X86)
Dominik Brodowskib6d00f02005-06-27 16:29:02 -0700780 /* If this is the root bus, the risk of hitting
781 * some strange system devices which aren't protected
782 * by either ACPI resource tables or properly requested
783 * resources is too big. Therefore, don't do auto-adding
784 * of resources at the moment.
785 */
786 if (s->cb_dev->bus->number == 0)
787 return -EINVAL;
788#endif
789
Dominik Brodowski3c299762005-06-27 16:28:46 -0700790 for (i=0; i < PCI_BUS_NUM_RESOURCES; i++) {
791 res = s->cb_dev->bus->resource[i];
792 if (!res)
793 continue;
794
795 if (res->flags & IORESOURCE_IO) {
796 if (res == &ioport_resource)
797 continue;
Greg Kroah-Hartman490ab722006-06-12 15:17:34 -0700798 printk(KERN_INFO "pcmcia: parent PCI bridge I/O "
799 "window: 0x%llx - 0x%llx\n",
800 (unsigned long long)res->start,
801 (unsigned long long)res->end);
Dominik Brodowski3c299762005-06-27 16:28:46 -0700802 if (!adjust_io(s, ADD_MANAGED_RESOURCE, res->start, res->end))
803 done |= IORESOURCE_IO;
804
805 }
806
807 if (res->flags & IORESOURCE_MEM) {
808 if (res == &iomem_resource)
809 continue;
Greg Kroah-Hartman490ab722006-06-12 15:17:34 -0700810 printk(KERN_INFO "pcmcia: parent PCI bridge Memory "
811 "window: 0x%llx - 0x%llx\n",
812 (unsigned long long)res->start,
813 (unsigned long long)res->end);
Dominik Brodowski3c299762005-06-27 16:28:46 -0700814 if (!adjust_memory(s, ADD_MANAGED_RESOURCE, res->start, res->end))
815 done |= IORESOURCE_MEM;
816 }
817 }
818
819 /* if we got at least one of IO, and one of MEM, we can be glad and
820 * activate the PCMCIA subsystem */
Dominik Brodowski54bb5672005-09-28 19:29:59 +0200821 if (done == (IORESOURCE_MEM | IORESOURCE_IO))
Dominik Brodowski3c299762005-06-27 16:28:46 -0700822 s->resource_setup_done = 1;
823
824 return 0;
825}
826
827#else
828
829static inline int nonstatic_autoadd_resources(struct pcmcia_socket *s)
830{
831 return -ENODEV;
832}
833
834#endif
835
836
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837static int nonstatic_init(struct pcmcia_socket *s)
838{
839 struct socket_data *data;
840
Dominik Brodowski8084b372005-12-11 21:18:26 +0100841 data = kzalloc(sizeof(struct socket_data), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 if (!data)
843 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
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
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100860 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 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 }
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100869 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870}
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,
Dominik Brodowskic5023802008-06-19 19:02:52 +0200878 .add_io = adjust_io,
879 .add_mem = adjust_memory,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 .init = nonstatic_init,
881 .exit = nonstatic_release_resource_db,
882};
883EXPORT_SYMBOL(pccard_nonstatic_ops);
884
885
886/* sysfs interface to the resource database */
887
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200888static ssize_t show_io_db(struct device *dev,
889 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200891 struct pcmcia_socket *s = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 struct socket_data *data;
893 struct resource_map *p;
894 ssize_t ret = 0;
895
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100896 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 data = s->resource_data;
898
899 for (p = data->io_db.next; p != &data->io_db; p = p->next) {
900 if (ret > (PAGE_SIZE - 10))
901 continue;
902 ret += snprintf (&buf[ret], (PAGE_SIZE - ret - 1),
903 "0x%08lx - 0x%08lx\n",
904 ((unsigned long) p->base),
905 ((unsigned long) p->base + p->num - 1));
906 }
907
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100908 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 return (ret);
910}
911
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200912static ssize_t store_io_db(struct device *dev,
913 struct device_attribute *attr,
914 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200916 struct pcmcia_socket *s = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 unsigned long start_addr, end_addr;
Dominik Brodowski22916632005-06-27 16:28:46 -0700918 unsigned int add = ADD_MANAGED_RESOURCE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 ssize_t ret = 0;
920
921 ret = sscanf (buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
922 if (ret != 2) {
923 ret = sscanf (buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
Dominik Brodowski22916632005-06-27 16:28:46 -0700924 add = REMOVE_MANAGED_RESOURCE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 if (ret != 2) {
926 ret = sscanf (buf, "0x%lx - 0x%lx", &start_addr, &end_addr);
Dominik Brodowski22916632005-06-27 16:28:46 -0700927 add = ADD_MANAGED_RESOURCE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 if (ret != 2)
929 return -EINVAL;
930 }
931 }
Dominik Brodowski1146bc72005-09-28 19:28:37 +0200932 if (end_addr < start_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 return -EINVAL;
934
Dominik Brodowski22916632005-06-27 16:28:46 -0700935 ret = adjust_io(s, add, start_addr, end_addr);
Dominik Brodowski3c299762005-06-27 16:28:46 -0700936 if (!ret)
937 s->resource_setup_new = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938
939 return ret ? ret : count;
940}
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200941static DEVICE_ATTR(available_resources_io, 0600, show_io_db, store_io_db);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200943static ssize_t show_mem_db(struct device *dev,
944 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200946 struct pcmcia_socket *s = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 struct socket_data *data;
948 struct resource_map *p;
949 ssize_t ret = 0;
950
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100951 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 data = s->resource_data;
953
954 for (p = data->mem_db.next; p != &data->mem_db; p = p->next) {
955 if (ret > (PAGE_SIZE - 10))
956 continue;
957 ret += snprintf (&buf[ret], (PAGE_SIZE - ret - 1),
958 "0x%08lx - 0x%08lx\n",
959 ((unsigned long) p->base),
960 ((unsigned long) p->base + p->num - 1));
961 }
962
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100963 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 return (ret);
965}
966
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200967static ssize_t store_mem_db(struct device *dev,
968 struct device_attribute *attr,
969 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200971 struct pcmcia_socket *s = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 unsigned long start_addr, end_addr;
Dominik Brodowski22916632005-06-27 16:28:46 -0700973 unsigned int add = ADD_MANAGED_RESOURCE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 ssize_t ret = 0;
975
976 ret = sscanf (buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
977 if (ret != 2) {
978 ret = sscanf (buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
Dominik Brodowski22916632005-06-27 16:28:46 -0700979 add = REMOVE_MANAGED_RESOURCE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 if (ret != 2) {
981 ret = sscanf (buf, "0x%lx - 0x%lx", &start_addr, &end_addr);
Dominik Brodowski22916632005-06-27 16:28:46 -0700982 add = ADD_MANAGED_RESOURCE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 if (ret != 2)
984 return -EINVAL;
985 }
986 }
Dominik Brodowski1146bc72005-09-28 19:28:37 +0200987 if (end_addr < start_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 return -EINVAL;
989
Dominik Brodowski22916632005-06-27 16:28:46 -0700990 ret = adjust_memory(s, add, start_addr, end_addr);
Dominik Brodowski3c299762005-06-27 16:28:46 -0700991 if (!ret)
992 s->resource_setup_new = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993
994 return ret ? ret : count;
995}
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200996static DEVICE_ATTR(available_resources_mem, 0600, show_mem_db, store_mem_db);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997
David Brownell7d578962008-06-12 12:13:55 -0700998static struct attribute *pccard_rsrc_attributes[] = {
999 &dev_attr_available_resources_io.attr,
1000 &dev_attr_available_resources_mem.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 NULL,
1002};
1003
David Brownell7d578962008-06-12 12:13:55 -07001004static const struct attribute_group rsrc_attributes = {
1005 .attrs = pccard_rsrc_attributes,
1006};
1007
Greg Kroah-Hartman87373312006-09-12 17:00:10 +02001008static int __devinit pccard_sysfs_add_rsrc(struct device *dev,
Dmitry Torokhovd8539d82005-09-15 02:01:36 -05001009 struct class_interface *class_intf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +02001011 struct pcmcia_socket *s = dev_get_drvdata(dev);
David Brownell7d578962008-06-12 12:13:55 -07001012
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 if (s->resource_ops != &pccard_nonstatic_ops)
1014 return 0;
David Brownell7d578962008-06-12 12:13:55 -07001015 return sysfs_create_group(&dev->kobj, &rsrc_attributes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016}
1017
Greg Kroah-Hartman87373312006-09-12 17:00:10 +02001018static void __devexit pccard_sysfs_remove_rsrc(struct device *dev,
Dmitry Torokhovd8539d82005-09-15 02:01:36 -05001019 struct class_interface *class_intf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +02001021 struct pcmcia_socket *s = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022
1023 if (s->resource_ops != &pccard_nonstatic_ops)
1024 return;
David Brownell7d578962008-06-12 12:13:55 -07001025 sysfs_remove_group(&dev->kobj, &rsrc_attributes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026}
1027
Sam Ravnborged49f5d2008-05-01 04:34:50 -07001028static struct class_interface pccard_rsrc_interface __refdata = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 .class = &pcmcia_socket_class,
Greg Kroah-Hartman87373312006-09-12 17:00:10 +02001030 .add_dev = &pccard_sysfs_add_rsrc,
1031 .remove_dev = __devexit_p(&pccard_sysfs_remove_rsrc),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032};
1033
1034static int __init nonstatic_sysfs_init(void)
1035{
1036 return class_interface_register(&pccard_rsrc_interface);
1037}
1038
1039static void __exit nonstatic_sysfs_exit(void)
1040{
1041 class_interface_unregister(&pccard_rsrc_interface);
1042}
1043
1044module_init(nonstatic_sysfs_init);
1045module_exit(nonstatic_sysfs_exit);