2 * rsrc_nonstatic.c -- Resource management routines for !SS_CAP_STATIC_MAP sockets
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.
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.
12 * (C) 1999 David A. Hinds
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>
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"
39 MODULE_AUTHOR("David A. Hinds, Dominik Brodowski");
40 MODULE_LICENSE("GPL");
42 /* Parameters that can be set with 'insmod' */
44 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
46 INT_MODULE_PARM(probe_mem, 1); /* memory probe? */
47 #ifdef CONFIG_PCMCIA_PROBE
48 INT_MODULE_PARM(probe_io, 1); /* IO port probe? */
49 INT_MODULE_PARM(mem_limit, 0x10000);
52 /* for io_db and mem_db */
55 struct resource_map *next;
59 struct resource_map mem_db;
60 struct resource_map io_db;
61 unsigned int rsrc_mem_probe;
64 static DECLARE_MUTEX(rsrc_sem);
65 #define MEM_PROBE_LOW (1 << 0)
66 #define MEM_PROBE_HIGH (1 << 1)
69 /*======================================================================
71 Linux resource management extensions
73 ======================================================================*/
75 static struct resource *
76 make_resource(unsigned long b, unsigned long n, int flags, char *name)
78 struct resource *res = kmalloc(sizeof(*res), GFP_KERNEL);
81 memset(res, 0, sizeof(*res));
90 static struct resource *
91 claim_region(struct pcmcia_socket *s, unsigned long base, unsigned long size,
94 struct resource *res, *parent;
96 parent = type & IORESOURCE_MEM ? &iomem_resource : &ioport_resource;
97 res = make_resource(base, size, type | IORESOURCE_BUSY, name);
102 parent = pci_find_parent_resource(s->cb_dev, res);
104 if (!parent || request_resource(parent, res)) {
112 static void free_region(struct resource *res)
115 release_resource(res);
120 /*======================================================================
122 These manage the internal databases of available resources.
124 ======================================================================*/
126 static int add_interval(struct resource_map *map, u_long base, u_long num)
128 struct resource_map *p, *q;
130 for (p = map; ; p = p->next) {
131 if ((p != map) && (p->base+p->num-1 >= base))
133 if ((p->next == map) || (p->next->base > base+num-1))
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;
143 /*====================================================================*/
145 static int sub_interval(struct resource_map *map, u_long base, u_long num)
147 struct resource_map *p, *q;
149 for (p = map; ; p = q) {
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 */
159 /* don't advance the pointer yet */
162 /* Cut off bit from the front */
163 q->num = q->base + q->num - base - num;
164 q->base = base + num;
166 } else if (q->base+q->num <= base+num) {
167 /* Cut off bit from the end */
168 q->num = base - q->base;
170 /* Split the block into two pieces */
171 p = kmalloc(sizeof(struct resource_map), GFP_KERNEL);
172 if (!p) return CS_OUT_OF_RESOURCE;
174 p->num = q->base+q->num - p->base;
175 q->num = base - q->base;
176 p->next = q->next ; q->next = p;
183 /*======================================================================
185 These routines examine a region of IO or memory addresses to
186 determine what ranges might be genuinely available.
188 ======================================================================*/
190 #ifdef CONFIG_PCMCIA_PROBE
191 static void do_io_probe(struct pcmcia_socket *s, kio_addr_t base, kio_addr_t num)
193 struct resource *res;
194 struct socket_data *s_data = s->resource_data;
195 kio_addr_t i, j, bad;
197 u_char *b, hole, most;
199 printk(KERN_INFO "cs: IO port probe %#lx-%#lx:",
202 /* First, what does a floating port look like? */
203 b = kmalloc(256, GFP_KERNEL);
205 printk(KERN_ERR "do_io_probe: unable to kmalloc 256 bytes");
209 for (i = base, most = 0; i < base+num; i += 8) {
210 res = claim_region(NULL, i, 8, IORESOURCE_IO, "PCMCIA IO probe");
214 for (j = 1; j < 8; j++)
215 if (inb(i+j) != hole) break;
217 if ((j == 8) && (++b[hole] > b[most]))
219 if (b[most] == 127) break;
224 for (i = base; i < base+num; i += 8) {
225 res = claim_region(NULL, i, 8, IORESOURCE_IO, "PCMCIA IO probe");
228 for (j = 0; j < 8; j++)
229 if (inb(i+j) != most) break;
233 printk(" excluding");
238 sub_interval(&s_data->io_db, bad, i-bad);
239 printk(" %#lx-%#lx", bad, i-1);
245 if ((num > 16) && (bad == base) && (i == base+num)) {
246 printk(" nothing: probe failed.\n");
249 sub_interval(&s_data->io_db, bad, i-bad);
250 printk(" %#lx-%#lx", bad, i-1);
254 printk(any ? "\n" : " clean.\n");
258 /*======================================================================
260 This is tricky... when we set up CIS memory, we try to validate
261 the memory window space allocations.
263 ======================================================================*/
265 /* Validation function for cards with a valid CIS */
266 static int readable(struct pcmcia_socket *s, struct resource *res, cisinfo_t *info)
270 s->cis_mem.res = res;
271 s->cis_virt = ioremap(res->start, s->map_size);
273 ret = pccard_validate_cis(s, BIND_FN_ALL, info);
274 /* invalidate mapping and CIS cache */
275 iounmap(s->cis_virt);
277 destroy_cis_cache(s);
279 s->cis_mem.res = NULL;
280 if ((ret != 0) || (info->Chains == 0))
285 /* Validation function for simple memory cards */
286 static int checksum(struct pcmcia_socket *s, struct resource *res)
289 int i, a = 0, b = -1, d;
292 virt = ioremap(res->start, s->map_size);
295 map.flags = MAP_ACTIVE;
299 s->ops->set_mem_map(s, &map);
301 /* Don't bother checking every word... */
302 for (i = 0; i < s->map_size; i += 44) {
309 s->ops->set_mem_map(s, &map);
314 return (b == -1) ? -1 : (a>>1);
318 cis_readable(struct pcmcia_socket *s, unsigned long base, unsigned long size)
320 struct resource *res1, *res2;
321 cisinfo_t info1, info2;
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");
328 ret = readable(s, res1, &info1);
329 ret += readable(s, res2, &info2);
335 return (ret == 2) && (info1.Chains == info2.Chains);
339 checksum_match(struct pcmcia_socket *s, unsigned long base, unsigned long size)
341 struct resource *res1, *res2;
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");
348 a = checksum(s, res1);
349 b = checksum(s, res2);
355 return (a == b) && (a >= 0);
358 /*======================================================================
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.
364 ======================================================================*/
366 static int do_mem_probe(u_long base, u_long num, struct pcmcia_socket *s)
368 struct socket_data *s_data = s->resource_data;
369 u_long i, j, bad, fail, step;
371 printk(KERN_INFO "cs: memory probe 0x%06lx-0x%06lx:",
374 step = (num < 0x20000) ? 0x2000 : ((num>>4) & ~0x1fff);
375 /* cis_readable wants to map 2x map_size */
376 if (step < 2 * s->map_size)
377 step = 2 * s->map_size;
378 for (i = j = base; i < base+num; i = j + step) {
380 for (j = i; j < base+num; j += step) {
381 if (cis_readable(s, j, step))
384 fail = ((i == base) && (j == base+num));
387 for (j = i; j < base+num; j += 2*step)
388 if (checksum_match(s, j, step) &&
389 checksum_match(s, j + step, step))
393 if (!bad) printk(" excluding");
394 printk(" %#05lx-%#05lx", i, j-1);
395 sub_interval(&s_data->mem_db, i, j-i);
399 printk(bad ? "\n" : " clean.\n");
403 #ifdef CONFIG_PCMCIA_PROBE
405 static u_long inv_probe(struct resource_map *m, struct pcmcia_socket *s)
407 struct socket_data *s_data = s->resource_data;
409 if (m == &s_data->mem_db)
411 ok = inv_probe(m->next, s);
413 if (m->base >= 0x100000)
414 sub_interval(&s_data->mem_db, m->base, m->num);
417 if (m->base < 0x100000)
419 return do_mem_probe(m->base, m->num, s);
422 static void validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
424 struct resource_map *m, mm;
425 static u_char order[] = { 0xd0, 0xe0, 0xc0, 0xf0 };
427 struct socket_data *s_data = s->resource_data;
429 /* We do up to four passes through the list */
430 if (probe_mask & MEM_PROBE_HIGH) {
431 if (inv_probe(s_data->mem_db.next, s) > 0)
433 printk(KERN_NOTICE "cs: warning: no high memory space "
436 if ((probe_mask & MEM_PROBE_LOW) == 0)
438 for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) {
440 /* Only probe < 1 MB */
441 if (mm.base >= 0x100000) continue;
442 if ((mm.base | mm.num) & 0xffff) {
443 ok += do_mem_probe(mm.base, mm.num, s);
446 /* Special probe for 64K-aligned block */
447 for (i = 0; i < 4; i++) {
449 if ((b >= mm.base) && (b+0x10000 <= mm.base+mm.num)) {
451 sub_interval(&s_data->mem_db, b, 0x10000);
453 ok += do_mem_probe(b, 0x10000, s);
459 #else /* CONFIG_PCMCIA_PROBE */
461 static void validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
463 struct resource_map *m, mm;
464 struct socket_data *s_data = s->resource_data;
466 for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) {
468 if (do_mem_probe(mm.base, mm.num, s))
473 #endif /* CONFIG_PCMCIA_PROBE */
477 * Locking note: Must be called with skt_sem held!
479 static void pcmcia_nonstatic_validate_mem(struct pcmcia_socket *s)
481 struct socket_data *s_data = s->resource_data;
483 unsigned int probe_mask;
487 probe_mask = MEM_PROBE_LOW;
488 if (s->features & SS_CAP_PAGE_REGS)
489 probe_mask = MEM_PROBE_HIGH;
491 if (probe_mask & ~s_data->rsrc_mem_probe) {
492 s_data->rsrc_mem_probe |= probe_mask;
494 if (s->state & SOCKET_PRESENT)
495 validate_mem(s, probe_mask);
502 struct pcmcia_align_data {
504 unsigned long offset;
505 struct resource_map *map;
509 pcmcia_common_align(void *align_data, struct resource *res,
510 unsigned long size, unsigned long align)
512 struct pcmcia_align_data *data = align_data;
515 * Ensure that we have the correct start address
517 start = (res->start & ~data->mask) + data->offset;
518 if (start < res->start)
519 start += data->mask + 1;
524 pcmcia_align(void *align_data, struct resource *res,
525 unsigned long size, unsigned long align)
527 struct pcmcia_align_data *data = align_data;
528 struct resource_map *m;
530 pcmcia_common_align(data, res, size, align);
532 for (m = data->map->next; m != data->map; m = m->next) {
533 unsigned long start = m->base;
534 unsigned long end = m->base + m->num - 1;
537 * If the lower resources are not available, try aligning
538 * to this entry of the resource database to see if it'll
541 if (res->start < start) {
543 pcmcia_common_align(data, res, size, align);
547 * If we're above the area which was passed in, there's
548 * no point proceeding.
550 if (res->start >= res->end)
553 if ((res->start + size - 1) <= end)
558 * If we failed to find something suitable, ensure we fail.
561 res->start = res->end;
565 * Adjust an existing IO region allocation, but making sure that we don't
566 * encroach outside the resources which the user supplied.
568 static int nonstatic_adjust_io_region(struct resource *res, unsigned long r_start,
569 unsigned long r_end, struct pcmcia_socket *s)
571 struct resource_map *m;
572 struct socket_data *s_data = s->resource_data;
576 for (m = s_data->io_db.next; m != &s_data->io_db; m = m->next) {
577 unsigned long start = m->base;
578 unsigned long end = m->base + m->num - 1;
580 if (start > r_start || r_end > end)
583 ret = adjust_resource(res, r_start, r_end - r_start + 1);
591 /*======================================================================
593 These find ranges of I/O ports or memory addresses that are not
594 currently allocated by other devices.
596 The 'align' field should reflect the number of bits of address
597 that need to be preserved from the initial value of *base. It
598 should be a power of two, greater than or equal to 'num'. A value
599 of 0 means that all bits of *base are significant. *base should
600 also be strictly less than 'align'.
602 ======================================================================*/
604 static struct resource *nonstatic_find_io_region(unsigned long base, int num,
605 unsigned long align, struct pcmcia_socket *s)
607 struct resource *res = make_resource(0, num, IORESOURCE_IO, s->dev.class_id);
608 struct socket_data *s_data = s->resource_data;
609 struct pcmcia_align_data data;
610 unsigned long min = base;
616 data.mask = align - 1;
617 data.offset = base & data.mask;
618 data.map = &s_data->io_db;
623 ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num, 1,
624 min, 0, pcmcia_align, &data);
627 ret = allocate_resource(&ioport_resource, res, num, min, ~0UL,
628 1, pcmcia_align, &data);
638 static struct resource * nonstatic_find_mem_region(u_long base, u_long num,
639 u_long align, int low, struct pcmcia_socket *s)
641 struct resource *res = make_resource(0, num, IORESOURCE_MEM, s->dev.class_id);
642 struct socket_data *s_data = s->resource_data;
643 struct pcmcia_align_data data;
644 unsigned long min, max;
647 low = low || !(s->features & SS_CAP_PAGE_REGS);
649 data.mask = align - 1;
650 data.offset = base & data.mask;
651 data.map = &s_data->mem_db;
653 for (i = 0; i < 2; i++) {
656 min = base < max ? base : 0;
659 min = 0x100000UL + base;
665 ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num,
667 pcmcia_align, &data);
670 ret = allocate_resource(&iomem_resource, res, num, min,
671 max, 1, pcmcia_align, &data);
686 static int adjust_memory(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end)
688 struct socket_data *data = s->resource_data;
689 unsigned long size = end - start + 1;
697 case ADD_MANAGED_RESOURCE:
698 ret = add_interval(&data->mem_db, start, size);
700 case REMOVE_MANAGED_RESOURCE:
701 ret = sub_interval(&data->mem_db, start, size);
703 struct pcmcia_socket *socket;
704 down_read(&pcmcia_socket_list_rwsem);
705 list_for_each_entry(socket, &pcmcia_socket_list, socket_list)
706 release_cis_mem(socket);
707 up_read(&pcmcia_socket_list_rwsem);
719 static int adjust_io(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end)
721 struct socket_data *data = s->resource_data;
722 unsigned long size = end - start + 1;
728 if (end > IO_SPACE_LIMIT)
733 case ADD_MANAGED_RESOURCE:
734 if (add_interval(&data->io_db, start, size) != 0) {
738 #ifdef CONFIG_PCMCIA_PROBE
740 do_io_probe(s, start, size);
743 case REMOVE_MANAGED_RESOURCE:
744 sub_interval(&data->io_db, start, size);
756 static int nonstatic_adjust_resource_info(struct pcmcia_socket *s, adjust_t *adj)
760 switch (adj->Resource) {
761 case RES_MEMORY_RANGE:
762 end = adj->resource.memory.Base + adj->resource.memory.Size - 1;
763 return adjust_memory(s, adj->Action, adj->resource.memory.Base, end);
765 end = adj->resource.io.BasePort + adj->resource.io.NumPorts - 1;
766 return adjust_io(s, adj->Action, adj->resource.io.BasePort, end);
768 return CS_UNSUPPORTED_FUNCTION;
771 static int nonstatic_init(struct pcmcia_socket *s)
773 struct socket_data *data;
775 data = kmalloc(sizeof(struct socket_data), GFP_KERNEL);
778 memset(data, 0, sizeof(struct socket_data));
780 data->mem_db.next = &data->mem_db;
781 data->io_db.next = &data->io_db;
783 s->resource_data = (void *) data;
788 static void nonstatic_release_resource_db(struct pcmcia_socket *s)
790 struct socket_data *data = s->resource_data;
791 struct resource_map *p, *q;
794 for (p = data->mem_db.next; p != &data->mem_db; p = q) {
798 for (p = data->io_db.next; p != &data->io_db; p = q) {
806 struct pccard_resource_ops pccard_nonstatic_ops = {
807 .validate_mem = pcmcia_nonstatic_validate_mem,
808 .adjust_io_region = nonstatic_adjust_io_region,
809 .find_io = nonstatic_find_io_region,
810 .find_mem = nonstatic_find_mem_region,
811 .adjust_resource = nonstatic_adjust_resource_info,
812 .init = nonstatic_init,
813 .exit = nonstatic_release_resource_db,
815 EXPORT_SYMBOL(pccard_nonstatic_ops);
818 /* sysfs interface to the resource database */
820 static ssize_t show_io_db(struct class_device *class_dev, char *buf)
822 struct pcmcia_socket *s = class_get_devdata(class_dev);
823 struct socket_data *data;
824 struct resource_map *p;
828 data = s->resource_data;
830 for (p = data->io_db.next; p != &data->io_db; p = p->next) {
831 if (ret > (PAGE_SIZE - 10))
833 ret += snprintf (&buf[ret], (PAGE_SIZE - ret - 1),
834 "0x%08lx - 0x%08lx\n",
835 ((unsigned long) p->base),
836 ((unsigned long) p->base + p->num - 1));
843 static ssize_t store_io_db(struct class_device *class_dev, const char *buf, size_t count)
845 struct pcmcia_socket *s = class_get_devdata(class_dev);
846 unsigned long start_addr, end_addr;
847 unsigned int add = ADD_MANAGED_RESOURCE;
850 ret = sscanf (buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
852 ret = sscanf (buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
853 add = REMOVE_MANAGED_RESOURCE;
855 ret = sscanf (buf, "0x%lx - 0x%lx", &start_addr, &end_addr);
856 add = ADD_MANAGED_RESOURCE;
861 if (end_addr <= start_addr)
864 ret = adjust_io(s, add, start_addr, end_addr);
866 return ret ? ret : count;
868 static CLASS_DEVICE_ATTR(available_resources_io, 0600, show_io_db, store_io_db);
870 static ssize_t show_mem_db(struct class_device *class_dev, char *buf)
872 struct pcmcia_socket *s = class_get_devdata(class_dev);
873 struct socket_data *data;
874 struct resource_map *p;
878 data = s->resource_data;
880 for (p = data->mem_db.next; p != &data->mem_db; p = p->next) {
881 if (ret > (PAGE_SIZE - 10))
883 ret += snprintf (&buf[ret], (PAGE_SIZE - ret - 1),
884 "0x%08lx - 0x%08lx\n",
885 ((unsigned long) p->base),
886 ((unsigned long) p->base + p->num - 1));
893 static ssize_t store_mem_db(struct class_device *class_dev, const char *buf, size_t count)
895 struct pcmcia_socket *s = class_get_devdata(class_dev);
896 unsigned long start_addr, end_addr;
897 unsigned int add = ADD_MANAGED_RESOURCE;
900 ret = sscanf (buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
902 ret = sscanf (buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
903 add = REMOVE_MANAGED_RESOURCE;
905 ret = sscanf (buf, "0x%lx - 0x%lx", &start_addr, &end_addr);
906 add = ADD_MANAGED_RESOURCE;
911 if (end_addr <= start_addr)
914 ret = adjust_memory(s, add, start_addr, end_addr);
916 return ret ? ret : count;
918 static CLASS_DEVICE_ATTR(available_resources_mem, 0600, show_mem_db, store_mem_db);
920 static struct class_device_attribute *pccard_rsrc_attributes[] = {
921 &class_device_attr_available_resources_io,
922 &class_device_attr_available_resources_mem,
926 static int __devinit pccard_sysfs_add_rsrc(struct class_device *class_dev)
928 struct pcmcia_socket *s = class_get_devdata(class_dev);
929 struct class_device_attribute **attr;
931 if (s->resource_ops != &pccard_nonstatic_ops)
934 for (attr = pccard_rsrc_attributes; *attr; attr++) {
935 ret = class_device_create_file(class_dev, *attr);
943 static void __devexit pccard_sysfs_remove_rsrc(struct class_device *class_dev)
945 struct pcmcia_socket *s = class_get_devdata(class_dev);
946 struct class_device_attribute **attr;
948 if (s->resource_ops != &pccard_nonstatic_ops)
951 for (attr = pccard_rsrc_attributes; *attr; attr++)
952 class_device_remove_file(class_dev, *attr);
955 static struct class_interface pccard_rsrc_interface = {
956 .class = &pcmcia_socket_class,
957 .add = &pccard_sysfs_add_rsrc,
958 .remove = __devexit_p(&pccard_sysfs_remove_rsrc),
961 static int __init nonstatic_sysfs_init(void)
963 return class_interface_register(&pccard_rsrc_interface);
966 static void __exit nonstatic_sysfs_exit(void)
968 class_interface_unregister(&pccard_rsrc_interface);
971 module_init(nonstatic_sysfs_init);
972 module_exit(nonstatic_sysfs_exit);