blob: 203e579ebbd22e77e5413f86995bce689cc87508 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <pcmcia/cistpl.h>
35#include "cs_internal.h"
36
37MODULE_AUTHOR("David A. Hinds, Dominik Brodowski");
38MODULE_LICENSE("GPL");
39
40/* Parameters that can be set with 'insmod' */
41
42#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
43
44INT_MODULE_PARM(probe_mem, 1); /* memory probe? */
45#ifdef CONFIG_PCMCIA_PROBE
46INT_MODULE_PARM(probe_io, 1); /* IO port probe? */
47INT_MODULE_PARM(mem_limit, 0x10000);
48#endif
49
50/* for io_db and mem_db */
51struct resource_map {
52 u_long base, num;
53 struct resource_map *next;
54};
55
56struct socket_data {
57 struct resource_map mem_db;
58 struct resource_map io_db;
59 unsigned int rsrc_mem_probe;
60};
61
Dominik Brodowski7fe908d2006-01-10 21:20:36 +010062static DEFINE_MUTEX(rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063#define MEM_PROBE_LOW (1 << 0)
64#define MEM_PROBE_HIGH (1 << 1)
65
66
67/*======================================================================
68
69 Linux resource management extensions
70
71======================================================================*/
72
73static struct resource *
Greg Kroah-Hartman2427ddd2006-06-12 17:07:52 -070074make_resource(resource_size_t b, resource_size_t n, int flags, char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -070075{
Dominik Brodowski8084b372005-12-11 21:18:26 +010076 struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78 if (res) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 res->name = name;
80 res->start = b;
81 res->end = b + n - 1;
82 res->flags = flags;
83 }
84 return res;
85}
86
87static struct resource *
Greg Kroah-Hartman2427ddd2006-06-12 17:07:52 -070088claim_region(struct pcmcia_socket *s, resource_size_t base,
89 resource_size_t size, int type, char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -070090{
91 struct resource *res, *parent;
92
93 parent = type & IORESOURCE_MEM ? &iomem_resource : &ioport_resource;
94 res = make_resource(base, size, type | IORESOURCE_BUSY, name);
95
96 if (res) {
97#ifdef CONFIG_PCI
98 if (s && s->cb_dev)
99 parent = pci_find_parent_resource(s->cb_dev, res);
100#endif
101 if (!parent || request_resource(parent, res)) {
102 kfree(res);
103 res = NULL;
104 }
105 }
106 return res;
107}
108
109static void free_region(struct resource *res)
110{
111 if (res) {
112 release_resource(res);
113 kfree(res);
114 }
115}
116
117/*======================================================================
118
119 These manage the internal databases of available resources.
120
121======================================================================*/
122
123static int add_interval(struct resource_map *map, u_long base, u_long num)
124{
125 struct resource_map *p, *q;
126
127 for (p = map; ; p = p->next) {
128 if ((p != map) && (p->base+p->num-1 >= base))
129 return -1;
130 if ((p->next == map) || (p->next->base > base+num-1))
131 break;
132 }
133 q = kmalloc(sizeof(struct resource_map), GFP_KERNEL);
134 if (!q) return CS_OUT_OF_RESOURCE;
135 q->base = base; q->num = num;
136 q->next = p->next; p->next = q;
137 return CS_SUCCESS;
138}
139
140/*====================================================================*/
141
142static int sub_interval(struct resource_map *map, u_long base, u_long num)
143{
144 struct resource_map *p, *q;
145
146 for (p = map; ; p = q) {
147 q = p->next;
148 if (q == map)
149 break;
150 if ((q->base+q->num > base) && (base+num > q->base)) {
151 if (q->base >= base) {
152 if (q->base+q->num <= base+num) {
153 /* Delete whole block */
154 p->next = q->next;
155 kfree(q);
156 /* don't advance the pointer yet */
157 q = p;
158 } else {
159 /* Cut off bit from the front */
160 q->num = q->base + q->num - base - num;
161 q->base = base + num;
162 }
163 } else if (q->base+q->num <= base+num) {
164 /* Cut off bit from the end */
165 q->num = base - q->base;
166 } else {
167 /* Split the block into two pieces */
168 p = kmalloc(sizeof(struct resource_map), GFP_KERNEL);
169 if (!p) return CS_OUT_OF_RESOURCE;
170 p->base = base+num;
171 p->num = q->base+q->num - p->base;
172 q->num = base - q->base;
173 p->next = q->next ; q->next = p;
174 }
175 }
176 }
177 return CS_SUCCESS;
178}
179
180/*======================================================================
181
182 These routines examine a region of IO or memory addresses to
183 determine what ranges might be genuinely available.
184
185======================================================================*/
186
187#ifdef CONFIG_PCMCIA_PROBE
Olof Johansson906da802008-02-04 22:27:35 -0800188static void do_io_probe(struct pcmcia_socket *s, unsigned int base,
189 unsigned int num)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190{
191 struct resource *res;
192 struct socket_data *s_data = s->resource_data;
Olof Johansson906da802008-02-04 22:27:35 -0800193 unsigned int i, j, bad;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 int any;
195 u_char *b, hole, most;
196
Olof Johansson906da802008-02-04 22:27:35 -0800197 printk(KERN_INFO "cs: IO port probe %#x-%#x:",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 base, base+num-1);
199
200 /* First, what does a floating port look like? */
Dominik Brodowski8084b372005-12-11 21:18:26 +0100201 b = kzalloc(256, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 if (!b) {
203 printk(KERN_ERR "do_io_probe: unable to kmalloc 256 bytes");
204 return;
205 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 for (i = base, most = 0; i < base+num; i += 8) {
207 res = claim_region(NULL, i, 8, IORESOURCE_IO, "PCMCIA IO probe");
208 if (!res)
209 continue;
210 hole = inb(i);
211 for (j = 1; j < 8; j++)
212 if (inb(i+j) != hole) break;
213 free_region(res);
214 if ((j == 8) && (++b[hole] > b[most]))
215 most = hole;
216 if (b[most] == 127) break;
217 }
218 kfree(b);
219
220 bad = any = 0;
221 for (i = base; i < base+num; i += 8) {
222 res = claim_region(NULL, i, 8, IORESOURCE_IO, "PCMCIA IO probe");
223 if (!res)
224 continue;
225 for (j = 0; j < 8; j++)
226 if (inb(i+j) != most) break;
227 free_region(res);
228 if (j < 8) {
229 if (!any)
230 printk(" excluding");
231 if (!bad)
232 bad = any = i;
233 } else {
234 if (bad) {
235 sub_interval(&s_data->io_db, bad, i-bad);
Olof Johansson906da802008-02-04 22:27:35 -0800236 printk(" %#x-%#x", bad, i-1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 bad = 0;
238 }
239 }
240 }
241 if (bad) {
242 if ((num > 16) && (bad == base) && (i == base+num)) {
243 printk(" nothing: probe failed.\n");
244 return;
245 } else {
246 sub_interval(&s_data->io_db, bad, i-bad);
Olof Johansson906da802008-02-04 22:27:35 -0800247 printk(" %#x-%#x", bad, i-1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 }
249 }
250
251 printk(any ? "\n" : " clean.\n");
252}
253#endif
254
255/*======================================================================
256
257 This is tricky... when we set up CIS memory, we try to validate
258 the memory window space allocations.
259
260======================================================================*/
261
262/* Validation function for cards with a valid CIS */
Dominik Brodowskic5081d52008-06-19 20:12:34 +0200263static int readable(struct pcmcia_socket *s, struct resource *res,
264 unsigned int *count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265{
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) {
Dominik Brodowskic5081d52008-06-19 20:12:34 +0200271 ret = pccard_validate_cis(s, BIND_FN_ALL, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 /* 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;
Dominik Brodowski0e09c862008-07-28 16:37:10 +0200278 if ((ret != 0) || (*count == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 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;
Dominik Brodowskic5081d52008-06-19 20:12:34 +0200319 unsigned int info1, info2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 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
Dominik Brodowskic5081d52008-06-19 20:12:34 +0200333 return (ret == 2) && (info1 == info2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334}
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);
Dominik Brodowski2ad0a0a2005-06-27 16:28:58 -0700373 /* don't allow too large steps */
374 if (step > 0x800000)
375 step = 0x800000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 /* 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{
Dominik Brodowskide759142005-09-28 19:41:56 +0200408 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421}
422
Dominik Brodowskide759142005-09-28 19:41:56 +0200423static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424{
Dominik Brodowskide759142005-09-28 19:41:56 +0200425 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Dominik Brodowskide759142005-09-28 19:41:56 +0200430 /* 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 }
Dominik Brodowskide759142005-09-28 19:41:56 +0200438
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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 }
Dominik Brodowskide759142005-09-28 19:41:56 +0200459
460 if (ok > 0)
461 return 0;
462
463 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464}
465
466#else /* CONFIG_PCMCIA_PROBE */
467
Andrew Morton2cff9442005-11-16 21:29:26 -0800468static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469{
470 struct resource_map *m, mm;
471 struct socket_data *s_data = s->resource_data;
Andrew Morton2cff9442005-11-16 21:29:26 -0800472 unsigned long ok = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
474 for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) {
475 mm = *m;
Andrew Morton2cff9442005-11-16 21:29:26 -0800476 ok += do_mem_probe(mm.base, mm.num, s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 }
Andrew Morton2cff9442005-11-16 21:29:26 -0800478 if (ok > 0)
479 return 0;
480 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481}
482
483#endif /* CONFIG_PCMCIA_PROBE */
484
485
486/*
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100487 * Locking note: Must be called with skt_mutex held!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 */
Dominik Brodowskide759142005-09-28 19:41:56 +0200489static int pcmcia_nonstatic_validate_mem(struct pcmcia_socket *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490{
491 struct socket_data *s_data = s->resource_data;
Dominik Brodowskide759142005-09-28 19:41:56 +0200492 unsigned int probe_mask = MEM_PROBE_LOW;
493 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
Dominik Brodowskide759142005-09-28 19:41:56 +0200495 if (!probe_mem)
496 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100498 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
Dominik Brodowskide759142005-09-28 19:41:56 +0200500 if (s->features & SS_CAP_PAGE_REGS)
501 probe_mask = MEM_PROBE_HIGH;
502
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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 s_data->rsrc_mem_probe |= probe_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 }
Dominik Brodowskide759142005-09-28 19:41:56 +0200509
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100510 mutex_unlock(&rsrc_mutex);
Dominik Brodowskide759142005-09-28 19:41:56 +0200511
512 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513}
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,
Greg Kroah-Hartman2427ddd2006-06-12 17:07:52 -0700523 resource_size_t size, resource_size_t align)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524{
525 struct pcmcia_align_data *data = align_data;
Greg Kroah-Hartman2427ddd2006-06-12 17:07:52 -0700526 resource_size_t start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 /*
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
Greg Kroah-Hartman2427ddd2006-06-12 17:07:52 -0700537pcmcia_align(void *align_data, struct resource *res, resource_size_t size,
538 resource_size_t align)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539{
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
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100588 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 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 }
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100599 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
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
Dominik Brodowskie94e15f2005-06-27 16:28:15 -0700617static struct resource *nonstatic_find_io_region(unsigned long base, int num,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 unsigned long align, struct pcmcia_socket *s)
619{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200620 struct resource *res = make_resource(0, num, IORESOURCE_IO, s->dev.bus_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 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
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100633 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634#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);
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100642 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
644 if (ret != 0) {
645 kfree(res);
646 res = NULL;
647 }
648 return res;
649}
650
Dominik Brodowskie94e15f2005-06-27 16:28:15 -0700651static struct resource * nonstatic_find_mem_region(u_long base, u_long num,
652 u_long align, int low, struct pcmcia_socket *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200654 struct resource *res = make_resource(0, num, IORESOURCE_MEM, s->dev.bus_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 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
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100675 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676#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);
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100685 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 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
Dominik Brodowski22916632005-06-27 16:28:46 -0700699static int adjust_memory(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 struct socket_data *data = s->resource_data;
Dominik Brodowski22916632005-06-27 16:28:46 -0700702 unsigned long size = end - start + 1;
703 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704
Dominik Brodowski1146bc72005-09-28 19:28:37 +0200705 if (end < start)
Dominik Brodowski22916632005-06-27 16:28:46 -0700706 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100708 mutex_lock(&rsrc_mutex);
Dominik Brodowski22916632005-06-27 16:28:46 -0700709 switch (action) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 case ADD_MANAGED_RESOURCE:
Dominik Brodowski22916632005-06-27 16:28:46 -0700711 ret = add_interval(&data->mem_db, start, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 break;
713 case REMOVE_MANAGED_RESOURCE:
Dominik Brodowski22916632005-06-27 16:28:46 -0700714 ret = sub_interval(&data->mem_db, start, size);
715 if (!ret) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 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:
Dominik Brodowski22916632005-06-27 16:28:46 -0700724 ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 }
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100726 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
728 return ret;
729}
730
731
Dominik Brodowski22916632005-06-27 16:28:46 -0700732static int adjust_io(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733{
734 struct socket_data *data = s->resource_data;
Dominik Brodowski22916632005-06-27 16:28:46 -0700735 unsigned long size = end - start + 1;
736 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737
Dominik Brodowski1146bc72005-09-28 19:28:37 +0200738 if (end < start)
Dominik Brodowski22916632005-06-27 16:28:46 -0700739 return -EINVAL;
740
741 if (end > IO_SPACE_LIMIT)
742 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100744 mutex_lock(&rsrc_mutex);
Dominik Brodowski22916632005-06-27 16:28:46 -0700745 switch (action) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 case ADD_MANAGED_RESOURCE:
Dominik Brodowski22916632005-06-27 16:28:46 -0700747 if (add_interval(&data->io_db, start, size) != 0) {
748 ret = -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 break;
750 }
751#ifdef CONFIG_PCMCIA_PROBE
752 if (probe_io)
Dominik Brodowski22916632005-06-27 16:28:46 -0700753 do_io_probe(s, start, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754#endif
755 break;
756 case REMOVE_MANAGED_RESOURCE:
Dominik Brodowski22916632005-06-27 16:28:46 -0700757 sub_interval(&data->io_db, start, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 break;
759 default:
Dominik Brodowski22916632005-06-27 16:28:46 -0700760 ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 break;
762 }
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100763 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
765 return ret;
766}
767
768
Dominik Brodowski3c299762005-06-27 16:28:46 -0700769#ifdef CONFIG_PCI
770static int nonstatic_autoadd_resources(struct pcmcia_socket *s)
771{
772 struct resource *res;
773 int i, done = 0;
774
775 if (!s->cb_dev || !s->cb_dev->bus)
776 return -ENODEV;
777
Brian Gerst0d078f62005-10-30 14:59:20 -0800778#if defined(CONFIG_X86)
Dominik Brodowskib6d00f02005-06-27 16:29:02 -0700779 /* If this is the root bus, the risk of hitting
780 * some strange system devices which aren't protected
781 * by either ACPI resource tables or properly requested
782 * resources is too big. Therefore, don't do auto-adding
783 * of resources at the moment.
784 */
785 if (s->cb_dev->bus->number == 0)
786 return -EINVAL;
787#endif
788
Dominik Brodowski3c299762005-06-27 16:28:46 -0700789 for (i=0; i < PCI_BUS_NUM_RESOURCES; i++) {
790 res = s->cb_dev->bus->resource[i];
791 if (!res)
792 continue;
793
794 if (res->flags & IORESOURCE_IO) {
795 if (res == &ioport_resource)
796 continue;
Greg Kroah-Hartman490ab722006-06-12 15:17:34 -0700797 printk(KERN_INFO "pcmcia: parent PCI bridge I/O "
798 "window: 0x%llx - 0x%llx\n",
799 (unsigned long long)res->start,
800 (unsigned long long)res->end);
Dominik Brodowski3c299762005-06-27 16:28:46 -0700801 if (!adjust_io(s, ADD_MANAGED_RESOURCE, res->start, res->end))
802 done |= IORESOURCE_IO;
803
804 }
805
806 if (res->flags & IORESOURCE_MEM) {
807 if (res == &iomem_resource)
808 continue;
Greg Kroah-Hartman490ab722006-06-12 15:17:34 -0700809 printk(KERN_INFO "pcmcia: parent PCI bridge Memory "
810 "window: 0x%llx - 0x%llx\n",
811 (unsigned long long)res->start,
812 (unsigned long long)res->end);
Dominik Brodowski3c299762005-06-27 16:28:46 -0700813 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 */
Dominik Brodowski54bb5672005-09-28 19:29:59 +0200820 if (done == (IORESOURCE_MEM | IORESOURCE_IO))
Dominik Brodowski3c299762005-06-27 16:28:46 -0700821 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
Dominik Brodowski8084b372005-12-11 21:18:26 +0100840 data = kzalloc(sizeof(struct socket_data), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 if (!data)
842 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
844 data->mem_db.next = &data->mem_db;
845 data->io_db.next = &data->io_db;
846
847 s->resource_data = (void *) data;
848
Dominik Brodowski3c299762005-06-27 16:28:46 -0700849 nonstatic_autoadd_resources(s);
850
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 return 0;
852}
853
854static void nonstatic_release_resource_db(struct pcmcia_socket *s)
855{
856 struct socket_data *data = s->resource_data;
857 struct resource_map *p, *q;
858
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100859 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 for (p = data->mem_db.next; p != &data->mem_db; p = q) {
861 q = p->next;
862 kfree(p);
863 }
864 for (p = data->io_db.next; p != &data->io_db; p = q) {
865 q = p->next;
866 kfree(p);
867 }
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100868 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869}
870
871
872struct pccard_resource_ops pccard_nonstatic_ops = {
873 .validate_mem = pcmcia_nonstatic_validate_mem,
874 .adjust_io_region = nonstatic_adjust_io_region,
875 .find_io = nonstatic_find_io_region,
876 .find_mem = nonstatic_find_mem_region,
Dominik Brodowskic5023802008-06-19 19:02:52 +0200877 .add_io = adjust_io,
878 .add_mem = adjust_memory,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 .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
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200887static ssize_t show_io_db(struct device *dev,
888 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200890 struct pcmcia_socket *s = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 struct socket_data *data;
892 struct resource_map *p;
893 ssize_t ret = 0;
894
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100895 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 data = s->resource_data;
897
898 for (p = data->io_db.next; p != &data->io_db; p = p->next) {
899 if (ret > (PAGE_SIZE - 10))
900 continue;
901 ret += snprintf (&buf[ret], (PAGE_SIZE - ret - 1),
902 "0x%08lx - 0x%08lx\n",
903 ((unsigned long) p->base),
904 ((unsigned long) p->base + p->num - 1));
905 }
906
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100907 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 return (ret);
909}
910
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200911static ssize_t store_io_db(struct device *dev,
912 struct device_attribute *attr,
913 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200915 struct pcmcia_socket *s = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 unsigned long start_addr, end_addr;
Dominik Brodowski22916632005-06-27 16:28:46 -0700917 unsigned int add = ADD_MANAGED_RESOURCE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 ssize_t ret = 0;
919
920 ret = sscanf (buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
921 if (ret != 2) {
922 ret = sscanf (buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
Dominik Brodowski22916632005-06-27 16:28:46 -0700923 add = REMOVE_MANAGED_RESOURCE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 if (ret != 2) {
925 ret = sscanf (buf, "0x%lx - 0x%lx", &start_addr, &end_addr);
Dominik Brodowski22916632005-06-27 16:28:46 -0700926 add = ADD_MANAGED_RESOURCE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 if (ret != 2)
928 return -EINVAL;
929 }
930 }
Dominik Brodowski1146bc72005-09-28 19:28:37 +0200931 if (end_addr < start_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 return -EINVAL;
933
Dominik Brodowski22916632005-06-27 16:28:46 -0700934 ret = adjust_io(s, add, start_addr, end_addr);
Dominik Brodowski3c299762005-06-27 16:28:46 -0700935 if (!ret)
936 s->resource_setup_new = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
938 return ret ? ret : count;
939}
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200940static DEVICE_ATTR(available_resources_io, 0600, show_io_db, store_io_db);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200942static ssize_t show_mem_db(struct device *dev,
943 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200945 struct pcmcia_socket *s = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 struct socket_data *data;
947 struct resource_map *p;
948 ssize_t ret = 0;
949
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100950 mutex_lock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 data = s->resource_data;
952
953 for (p = data->mem_db.next; p != &data->mem_db; p = p->next) {
954 if (ret > (PAGE_SIZE - 10))
955 continue;
956 ret += snprintf (&buf[ret], (PAGE_SIZE - ret - 1),
957 "0x%08lx - 0x%08lx\n",
958 ((unsigned long) p->base),
959 ((unsigned long) p->base + p->num - 1));
960 }
961
Dominik Brodowski7fe908d2006-01-10 21:20:36 +0100962 mutex_unlock(&rsrc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 return (ret);
964}
965
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200966static ssize_t store_mem_db(struct device *dev,
967 struct device_attribute *attr,
968 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200970 struct pcmcia_socket *s = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 unsigned long start_addr, end_addr;
Dominik Brodowski22916632005-06-27 16:28:46 -0700972 unsigned int add = ADD_MANAGED_RESOURCE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 ssize_t ret = 0;
974
975 ret = sscanf (buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
976 if (ret != 2) {
977 ret = sscanf (buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
Dominik Brodowski22916632005-06-27 16:28:46 -0700978 add = REMOVE_MANAGED_RESOURCE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 if (ret != 2) {
980 ret = sscanf (buf, "0x%lx - 0x%lx", &start_addr, &end_addr);
Dominik Brodowski22916632005-06-27 16:28:46 -0700981 add = ADD_MANAGED_RESOURCE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 if (ret != 2)
983 return -EINVAL;
984 }
985 }
Dominik Brodowski1146bc72005-09-28 19:28:37 +0200986 if (end_addr < start_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 return -EINVAL;
988
Dominik Brodowski22916632005-06-27 16:28:46 -0700989 ret = adjust_memory(s, add, start_addr, end_addr);
Dominik Brodowski3c299762005-06-27 16:28:46 -0700990 if (!ret)
991 s->resource_setup_new = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
993 return ret ? ret : count;
994}
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200995static DEVICE_ATTR(available_resources_mem, 0600, show_mem_db, store_mem_db);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996
David Brownell7d578962008-06-12 12:13:55 -0700997static struct attribute *pccard_rsrc_attributes[] = {
998 &dev_attr_available_resources_io.attr,
999 &dev_attr_available_resources_mem.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 NULL,
1001};
1002
David Brownell7d578962008-06-12 12:13:55 -07001003static const struct attribute_group rsrc_attributes = {
1004 .attrs = pccard_rsrc_attributes,
1005};
1006
Greg Kroah-Hartman87373312006-09-12 17:00:10 +02001007static int __devinit pccard_sysfs_add_rsrc(struct device *dev,
Dmitry Torokhovd8539d82005-09-15 02:01:36 -05001008 struct class_interface *class_intf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +02001010 struct pcmcia_socket *s = dev_get_drvdata(dev);
David Brownell7d578962008-06-12 12:13:55 -07001011
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 if (s->resource_ops != &pccard_nonstatic_ops)
1013 return 0;
David Brownell7d578962008-06-12 12:13:55 -07001014 return sysfs_create_group(&dev->kobj, &rsrc_attributes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015}
1016
Greg Kroah-Hartman87373312006-09-12 17:00:10 +02001017static void __devexit pccard_sysfs_remove_rsrc(struct device *dev,
Dmitry Torokhovd8539d82005-09-15 02:01:36 -05001018 struct class_interface *class_intf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019{
Greg Kroah-Hartman87373312006-09-12 17:00:10 +02001020 struct pcmcia_socket *s = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021
1022 if (s->resource_ops != &pccard_nonstatic_ops)
1023 return;
David Brownell7d578962008-06-12 12:13:55 -07001024 sysfs_remove_group(&dev->kobj, &rsrc_attributes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025}
1026
Sam Ravnborged49f5d2008-05-01 04:34:50 -07001027static struct class_interface pccard_rsrc_interface __refdata = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 .class = &pcmcia_socket_class,
Greg Kroah-Hartman87373312006-09-12 17:00:10 +02001029 .add_dev = &pccard_sysfs_add_rsrc,
1030 .remove_dev = __devexit_p(&pccard_sysfs_remove_rsrc),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031};
1032
1033static int __init nonstatic_sysfs_init(void)
1034{
1035 return class_interface_register(&pccard_rsrc_interface);
1036}
1037
1038static void __exit nonstatic_sysfs_exit(void)
1039{
1040 class_interface_unregister(&pccard_rsrc_interface);
1041}
1042
1043module_init(nonstatic_sysfs_init);
1044module_exit(nonstatic_sysfs_exit);