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/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>
31 #include <pcmcia/cs_types.h>
32 #include <pcmcia/ss.h>
33 #include <pcmcia/cs.h>
34 #include <pcmcia/cistpl.h>
35 #include "cs_internal.h"
37 MODULE_AUTHOR("David A. Hinds, Dominik Brodowski");
38 MODULE_LICENSE("GPL");
40 /* Parameters that can be set with 'insmod' */
42 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
44 INT_MODULE_PARM(probe_mem, 1); /* memory probe? */
45 #ifdef CONFIG_PCMCIA_PROBE
46 INT_MODULE_PARM(probe_io, 1); /* IO port probe? */
47 INT_MODULE_PARM(mem_limit, 0x10000);
50 /* for io_db and mem_db */
53 struct resource_map *next;
57 struct resource_map mem_db;
58 struct resource_map io_db;
59 unsigned int rsrc_mem_probe;
62 #define MEM_PROBE_LOW (1 << 0)
63 #define MEM_PROBE_HIGH (1 << 1)
66 /*======================================================================
68 Linux resource management extensions
70 ======================================================================*/
72 static struct resource *
73 make_resource(resource_size_t b, resource_size_t n, int flags, const char *name)
75 struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
86 static struct resource *
87 claim_region(struct pcmcia_socket *s, resource_size_t base,
88 resource_size_t size, int type, char *name)
90 struct resource *res, *parent;
92 parent = type & IORESOURCE_MEM ? &iomem_resource : &ioport_resource;
93 res = make_resource(base, size, type | IORESOURCE_BUSY, name);
98 parent = pci_find_parent_resource(s->cb_dev, res);
100 if (!parent || request_resource(parent, res)) {
108 static void free_region(struct resource *res)
111 release_resource(res);
116 /*======================================================================
118 These manage the internal databases of available resources.
120 ======================================================================*/
122 static int add_interval(struct resource_map *map, u_long base, u_long num)
124 struct resource_map *p, *q;
126 for (p = map; ; p = p->next) {
127 if ((p != map) && (p->base+p->num-1 >= base))
129 if ((p->next == map) || (p->next->base > base+num-1))
132 q = kmalloc(sizeof(struct resource_map), GFP_KERNEL);
134 printk(KERN_WARNING "out of memory to update resources\n");
137 q->base = base; q->num = num;
138 q->next = p->next; p->next = q;
142 /*====================================================================*/
144 static int sub_interval(struct resource_map *map, u_long base, u_long num)
146 struct resource_map *p, *q;
148 for (p = map; ; p = q) {
152 if ((q->base+q->num > base) && (base+num > q->base)) {
153 if (q->base >= base) {
154 if (q->base+q->num <= base+num) {
155 /* Delete whole block */
158 /* don't advance the pointer yet */
161 /* Cut off bit from the front */
162 q->num = q->base + q->num - base - num;
163 q->base = base + num;
165 } else if (q->base+q->num <= base+num) {
166 /* Cut off bit from the end */
167 q->num = base - q->base;
169 /* Split the block into two pieces */
170 p = kmalloc(sizeof(struct resource_map),
173 printk(KERN_WARNING "out of memory to update resources\n");
177 p->num = q->base+q->num - p->base;
178 q->num = base - q->base;
179 p->next = q->next ; q->next = p;
186 /*======================================================================
188 These routines examine a region of IO or memory addresses to
189 determine what ranges might be genuinely available.
191 ======================================================================*/
193 #ifdef CONFIG_PCMCIA_PROBE
194 static void do_io_probe(struct pcmcia_socket *s, unsigned int base,
197 struct resource *res;
198 struct socket_data *s_data = s->resource_data;
199 unsigned int i, j, bad;
201 u_char *b, hole, most;
203 dev_printk(KERN_INFO, &s->dev, "cs: IO port probe %#x-%#x:",
206 /* First, what does a floating port look like? */
207 b = kzalloc(256, GFP_KERNEL);
210 dev_printk(KERN_ERR, &s->dev,
211 "do_io_probe: unable to kmalloc 256 bytes");
214 for (i = base, most = 0; i < base+num; i += 8) {
215 res = claim_region(NULL, i, 8, IORESOURCE_IO, "PCMCIA ioprobe");
219 for (j = 1; j < 8; j++)
220 if (inb(i+j) != hole)
223 if ((j == 8) && (++b[hole] > b[most]))
231 for (i = base; i < base+num; i += 8) {
232 res = claim_region(NULL, i, 8, IORESOURCE_IO, "PCMCIA ioprobe");
235 for (j = 0; j < 8; j++)
236 if (inb(i+j) != most)
241 printk(" excluding");
246 sub_interval(&s_data->io_db, bad, i-bad);
247 printk(" %#x-%#x", bad, i-1);
253 if ((num > 16) && (bad == base) && (i == base+num)) {
254 printk(" nothing: probe failed.\n");
257 sub_interval(&s_data->io_db, bad, i-bad);
258 printk(" %#x-%#x", bad, i-1);
262 printk(any ? "\n" : " clean.\n");
266 /*======================================================================*/
269 * readable() - iomem validation function for cards with a valid CIS
271 static int readable(struct pcmcia_socket *s, struct resource *res,
276 s->cis_mem.res = res;
277 s->cis_virt = ioremap(res->start, s->map_size);
279 mutex_unlock(&s->ops_mutex);
280 /* as we're only called from pcmcia.c, we're safe */
281 if (s->callback->validate)
282 ret = s->callback->validate(s, count);
283 /* invalidate mapping */
284 mutex_lock(&s->ops_mutex);
285 iounmap(s->cis_virt);
288 s->cis_mem.res = NULL;
289 if ((ret) || (*count == 0))
295 * checksum() - iomem validation function for simple memory cards
297 static int checksum(struct pcmcia_socket *s, struct resource *res,
301 int i, a = 0, b = -1, d;
304 virt = ioremap(res->start, s->map_size);
307 map.flags = MAP_ACTIVE;
311 s->ops->set_mem_map(s, &map);
313 /* Don't bother checking every word... */
314 for (i = 0; i < s->map_size; i += 44) {
321 s->ops->set_mem_map(s, &map);
335 * do_validate_mem() - low level validate a memory region for PCMCIA use
336 * @s: PCMCIA socket to validate
337 * @base: start address of resource to check
338 * @size: size of resource to check
339 * @validate: validation function to use
341 * do_validate_mem() splits up the memory region which is to be checked
342 * into two parts. Both are passed to the @validate() function. If
343 * @validate() returns non-zero, or the value parameter to @validate()
344 * is zero, or the value parameter is different between both calls,
345 * the check fails, and -EINVAL is returned. Else, 0 is returned.
347 static int do_validate_mem(struct pcmcia_socket *s,
348 unsigned long base, unsigned long size,
349 int validate (struct pcmcia_socket *s,
350 struct resource *res,
351 unsigned int *value))
353 struct resource *res1, *res2;
354 unsigned int info1 = 1, info2 = 1;
357 res1 = claim_region(s, base, size/2, IORESOURCE_MEM, "PCMCIA memprobe");
358 res2 = claim_region(s, base + size/2, size/2, IORESOURCE_MEM,
364 ret = validate(s, res1, &info1);
365 ret += validate(s, res2, &info2);
372 dev_dbg(&s->dev, "cs: memory probe 0x%06lx-0x%06lx: %p %p %u %u %u",
373 base, base+size-1, res1, res2, ret, info1, info2);
375 if ((ret) || (info1 != info2) || (info1 == 0))
383 * do_mem_probe() - validate a memory region for PCMCIA use
384 * @s: PCMCIA socket to validate
385 * @base: start address of resource to check
386 * @num: size of resource to check
387 * @validate: validation function to use
388 * @fallback: validation function to use if validate fails
390 * do_mem_probe() checks a memory region for use by the PCMCIA subsystem.
391 * To do so, the area is split up into sensible parts, and then passed
392 * into the @validate() function. Only if @validate() and @fallback() fail,
393 * the area is marked as unavaibale for use by the PCMCIA subsystem. The
394 * function returns the size of the usable memory area.
396 static int do_mem_probe(struct pcmcia_socket *s, u_long base, u_long num,
397 int validate (struct pcmcia_socket *s,
398 struct resource *res,
399 unsigned int *value),
400 int fallback (struct pcmcia_socket *s,
401 struct resource *res,
402 unsigned int *value))
404 struct socket_data *s_data = s->resource_data;
405 u_long i, j, bad, fail, step;
407 dev_printk(KERN_INFO, &s->dev, "cs: memory probe 0x%06lx-0x%06lx:",
410 step = (num < 0x20000) ? 0x2000 : ((num>>4) & ~0x1fff);
411 /* don't allow too large steps */
414 /* cis_readable wants to map 2x map_size */
415 if (step < 2 * s->map_size)
416 step = 2 * s->map_size;
417 for (i = j = base; i < base+num; i = j + step) {
419 for (j = i; j < base+num; j += step) {
420 if (!do_validate_mem(s, j, step, validate))
423 fail = ((i == base) && (j == base+num));
425 if ((fail) && (fallback)) {
426 for (j = i; j < base+num; j += step)
427 if (!do_validate_mem(s, j, step, fallback))
432 printk(" excluding");
433 printk(" %#05lx-%#05lx", i, j-1);
434 sub_interval(&s_data->mem_db, i, j-i);
438 printk(bad ? "\n" : " clean.\n");
443 #ifdef CONFIG_PCMCIA_PROBE
446 * inv_probe() - top-to-bottom search for one usuable high memory area
447 * @s: PCMCIA socket to validate
448 * @m: resource_map to check
450 static u_long inv_probe(struct resource_map *m, struct pcmcia_socket *s)
452 struct socket_data *s_data = s->resource_data;
454 if (m == &s_data->mem_db)
456 ok = inv_probe(m->next, s);
458 if (m->base >= 0x100000)
459 sub_interval(&s_data->mem_db, m->base, m->num);
462 if (m->base < 0x100000)
464 return do_mem_probe(s, m->base, m->num, readable, checksum);
468 * validate_mem() - memory probe function
469 * @s: PCMCIA socket to validate
470 * @probe_mask: MEM_PROBE_LOW | MEM_PROBE_HIGH
472 * The memory probe. If the memory list includes a 64K-aligned block
473 * below 1MB, we probe in 64K chunks, and as soon as we accumulate at
474 * least mem_limit free space, we quit. Returns 0 on usuable ports.
476 static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
478 struct resource_map *m, mm;
479 static unsigned char order[] = { 0xd0, 0xe0, 0xc0, 0xf0 };
480 unsigned long b, i, ok = 0;
481 struct socket_data *s_data = s->resource_data;
483 /* We do up to four passes through the list */
484 if (probe_mask & MEM_PROBE_HIGH) {
485 if (inv_probe(s_data->mem_db.next, s) > 0)
487 dev_printk(KERN_NOTICE, &s->dev,
488 "cs: warning: no high memory space available!\n");
492 for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) {
494 /* Only probe < 1 MB */
495 if (mm.base >= 0x100000)
497 if ((mm.base | mm.num) & 0xffff) {
498 ok += do_mem_probe(s, mm.base, mm.num, readable,
502 /* Special probe for 64K-aligned block */
503 for (i = 0; i < 4; i++) {
505 if ((b >= mm.base) && (b+0x10000 <= mm.base+mm.num)) {
507 sub_interval(&s_data->mem_db, b, 0x10000);
509 ok += do_mem_probe(s, b, 0x10000,
521 #else /* CONFIG_PCMCIA_PROBE */
524 * validate_mem() - memory probe function
525 * @s: PCMCIA socket to validate
526 * @probe_mask: ignored
528 * Returns 0 on usuable ports.
530 static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
532 struct resource_map *m, mm;
533 struct socket_data *s_data = s->resource_data;
534 unsigned long ok = 0;
536 for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) {
538 ok += do_mem_probe(s, mm.base, mm.num, readable, checksum);
545 #endif /* CONFIG_PCMCIA_PROBE */
549 * pcmcia_nonstatic_validate_mem() - try to validate iomem for PCMCIA use
550 * @s: PCMCIA socket to validate
552 * This is tricky... when we set up CIS memory, we try to validate
553 * the memory window space allocations.
555 * Locking note: Must be called with skt_mutex held!
557 static int pcmcia_nonstatic_validate_mem(struct pcmcia_socket *s)
559 struct socket_data *s_data = s->resource_data;
560 unsigned int probe_mask = MEM_PROBE_LOW;
566 if (s->features & SS_CAP_PAGE_REGS)
567 probe_mask = MEM_PROBE_HIGH;
569 if (probe_mask & ~s_data->rsrc_mem_probe) {
570 if (s->state & SOCKET_PRESENT) {
571 ret = validate_mem(s, probe_mask);
573 s_data->rsrc_mem_probe |= probe_mask;
580 struct pcmcia_align_data {
582 unsigned long offset;
583 struct resource_map *map;
587 pcmcia_common_align(void *align_data, struct resource *res,
588 resource_size_t size, resource_size_t align)
590 struct pcmcia_align_data *data = align_data;
591 resource_size_t start;
593 * Ensure that we have the correct start address
595 start = (res->start & ~data->mask) + data->offset;
596 if (start < res->start)
597 start += data->mask + 1;
602 pcmcia_align(void *align_data, struct resource *res, resource_size_t size,
603 resource_size_t align)
605 struct pcmcia_align_data *data = align_data;
606 struct resource_map *m;
608 pcmcia_common_align(data, res, size, align);
610 for (m = data->map->next; m != data->map; m = m->next) {
611 unsigned long start = m->base;
612 unsigned long end = m->base + m->num - 1;
615 * If the lower resources are not available, try aligning
616 * to this entry of the resource database to see if it'll
619 if (res->start < start) {
621 pcmcia_common_align(data, res, size, align);
625 * If we're above the area which was passed in, there's
626 * no point proceeding.
628 if (res->start >= res->end)
631 if ((res->start + size - 1) <= end)
636 * If we failed to find something suitable, ensure we fail.
639 res->start = res->end;
643 * Adjust an existing IO region allocation, but making sure that we don't
644 * encroach outside the resources which the user supplied.
646 static int nonstatic_adjust_io_region(struct resource *res, unsigned long r_start,
647 unsigned long r_end, struct pcmcia_socket *s)
649 struct resource_map *m;
650 struct socket_data *s_data = s->resource_data;
653 for (m = s_data->io_db.next; m != &s_data->io_db; m = m->next) {
654 unsigned long start = m->base;
655 unsigned long end = m->base + m->num - 1;
657 if (start > r_start || r_end > end)
660 ret = adjust_resource(res, r_start, r_end - r_start + 1);
667 /*======================================================================
669 These find ranges of I/O ports or memory addresses that are not
670 currently allocated by other devices.
672 The 'align' field should reflect the number of bits of address
673 that need to be preserved from the initial value of *base. It
674 should be a power of two, greater than or equal to 'num'. A value
675 of 0 means that all bits of *base are significant. *base should
676 also be strictly less than 'align'.
678 ======================================================================*/
680 static struct resource *nonstatic_find_io_region(unsigned long base, int num,
681 unsigned long align, struct pcmcia_socket *s)
683 struct resource *res = make_resource(0, num, IORESOURCE_IO, dev_name(&s->dev));
684 struct socket_data *s_data = s->resource_data;
685 struct pcmcia_align_data data;
686 unsigned long min = base;
692 data.mask = align - 1;
693 data.offset = base & data.mask;
694 data.map = &s_data->io_db;
698 ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num, 1,
699 min, 0, pcmcia_align, &data);
702 ret = allocate_resource(&ioport_resource, res, num, min, ~0UL,
703 1, pcmcia_align, &data);
712 static struct resource *nonstatic_find_mem_region(u_long base, u_long num,
713 u_long align, int low, struct pcmcia_socket *s)
715 struct resource *res = make_resource(0, num, IORESOURCE_MEM, dev_name(&s->dev));
716 struct socket_data *s_data = s->resource_data;
717 struct pcmcia_align_data data;
718 unsigned long min, max;
721 low = low || !(s->features & SS_CAP_PAGE_REGS);
723 data.mask = align - 1;
724 data.offset = base & data.mask;
725 data.map = &s_data->mem_db;
727 for (i = 0; i < 2; i++) {
730 min = base < max ? base : 0;
733 min = 0x100000UL + base;
738 ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num,
740 pcmcia_align, &data);
743 ret = allocate_resource(&iomem_resource, res, num, min,
744 max, 1, pcmcia_align, &data);
758 static int adjust_memory(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end)
760 struct socket_data *data = s->resource_data;
761 unsigned long size = end - start + 1;
768 case ADD_MANAGED_RESOURCE:
769 ret = add_interval(&data->mem_db, start, size);
771 do_mem_probe(s, start, size, NULL, NULL);
773 case REMOVE_MANAGED_RESOURCE:
774 ret = sub_interval(&data->mem_db, start, size);
784 static int adjust_io(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end)
786 struct socket_data *data = s->resource_data;
787 unsigned long size = end - start + 1;
793 if (end > IO_SPACE_LIMIT)
797 case ADD_MANAGED_RESOURCE:
798 if (add_interval(&data->io_db, start, size) != 0) {
802 #ifdef CONFIG_PCMCIA_PROBE
804 do_io_probe(s, start, size);
807 case REMOVE_MANAGED_RESOURCE:
808 sub_interval(&data->io_db, start, size);
820 static int nonstatic_autoadd_resources(struct pcmcia_socket *s)
822 struct resource *res;
825 if (!s->cb_dev || !s->cb_dev->bus)
828 #if defined(CONFIG_X86)
829 /* If this is the root bus, the risk of hitting
830 * some strange system devices which aren't protected
831 * by either ACPI resource tables or properly requested
832 * resources is too big. Therefore, don't do auto-adding
833 * of resources at the moment.
835 if (s->cb_dev->bus->number == 0)
839 for (i = 0; i < PCI_BUS_NUM_RESOURCES; i++) {
840 res = s->cb_dev->bus->resource[i];
844 if (res->flags & IORESOURCE_IO) {
845 if (res == &ioport_resource)
847 dev_printk(KERN_INFO, &s->cb_dev->dev,
848 "pcmcia: parent PCI bridge I/O "
849 "window: 0x%llx - 0x%llx\n",
850 (unsigned long long)res->start,
851 (unsigned long long)res->end);
852 if (!adjust_io(s, ADD_MANAGED_RESOURCE, res->start, res->end))
853 done |= IORESOURCE_IO;
857 if (res->flags & IORESOURCE_MEM) {
858 if (res == &iomem_resource)
860 dev_printk(KERN_INFO, &s->cb_dev->dev,
861 "pcmcia: parent PCI bridge Memory "
862 "window: 0x%llx - 0x%llx\n",
863 (unsigned long long)res->start,
864 (unsigned long long)res->end);
865 if (!adjust_memory(s, ADD_MANAGED_RESOURCE, res->start, res->end))
866 done |= IORESOURCE_MEM;
870 /* if we got at least one of IO, and one of MEM, we can be glad and
871 * activate the PCMCIA subsystem */
872 if (done == (IORESOURCE_MEM | IORESOURCE_IO))
873 s->resource_setup_done = 1;
880 static inline int nonstatic_autoadd_resources(struct pcmcia_socket *s)
888 static int nonstatic_init(struct pcmcia_socket *s)
890 struct socket_data *data;
892 data = kzalloc(sizeof(struct socket_data), GFP_KERNEL);
896 data->mem_db.next = &data->mem_db;
897 data->io_db.next = &data->io_db;
899 s->resource_data = (void *) data;
901 nonstatic_autoadd_resources(s);
906 static void nonstatic_release_resource_db(struct pcmcia_socket *s)
908 struct socket_data *data = s->resource_data;
909 struct resource_map *p, *q;
911 for (p = data->mem_db.next; p != &data->mem_db; p = q) {
915 for (p = data->io_db.next; p != &data->io_db; p = q) {
922 struct pccard_resource_ops pccard_nonstatic_ops = {
923 .validate_mem = pcmcia_nonstatic_validate_mem,
924 .adjust_io_region = nonstatic_adjust_io_region,
925 .find_io = nonstatic_find_io_region,
926 .find_mem = nonstatic_find_mem_region,
928 .add_mem = adjust_memory,
929 .init = nonstatic_init,
930 .exit = nonstatic_release_resource_db,
932 EXPORT_SYMBOL(pccard_nonstatic_ops);
935 /* sysfs interface to the resource database */
937 static ssize_t show_io_db(struct device *dev,
938 struct device_attribute *attr, char *buf)
940 struct pcmcia_socket *s = dev_get_drvdata(dev);
941 struct socket_data *data;
942 struct resource_map *p;
945 mutex_lock(&s->ops_mutex);
946 data = s->resource_data;
948 for (p = data->io_db.next; p != &data->io_db; p = p->next) {
949 if (ret > (PAGE_SIZE - 10))
951 ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1),
952 "0x%08lx - 0x%08lx\n",
953 ((unsigned long) p->base),
954 ((unsigned long) p->base + p->num - 1));
957 mutex_unlock(&s->ops_mutex);
961 static ssize_t store_io_db(struct device *dev,
962 struct device_attribute *attr,
963 const char *buf, size_t count)
965 struct pcmcia_socket *s = dev_get_drvdata(dev);
966 unsigned long start_addr, end_addr;
967 unsigned int add = ADD_MANAGED_RESOURCE;
970 ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
972 ret = sscanf(buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
973 add = REMOVE_MANAGED_RESOURCE;
975 ret = sscanf(buf, "0x%lx - 0x%lx", &start_addr,
977 add = ADD_MANAGED_RESOURCE;
982 if (end_addr < start_addr)
985 mutex_lock(&s->ops_mutex);
986 ret = adjust_io(s, add, start_addr, end_addr);
988 s->resource_setup_new = 1;
989 mutex_unlock(&s->ops_mutex);
991 return ret ? ret : count;
993 static DEVICE_ATTR(available_resources_io, 0600, show_io_db, store_io_db);
995 static ssize_t show_mem_db(struct device *dev,
996 struct device_attribute *attr, char *buf)
998 struct pcmcia_socket *s = dev_get_drvdata(dev);
999 struct socket_data *data;
1000 struct resource_map *p;
1003 mutex_lock(&s->ops_mutex);
1004 data = s->resource_data;
1006 for (p = data->mem_db.next; p != &data->mem_db; p = p->next) {
1007 if (ret > (PAGE_SIZE - 10))
1009 ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1),
1010 "0x%08lx - 0x%08lx\n",
1011 ((unsigned long) p->base),
1012 ((unsigned long) p->base + p->num - 1));
1015 mutex_unlock(&s->ops_mutex);
1019 static ssize_t store_mem_db(struct device *dev,
1020 struct device_attribute *attr,
1021 const char *buf, size_t count)
1023 struct pcmcia_socket *s = dev_get_drvdata(dev);
1024 unsigned long start_addr, end_addr;
1025 unsigned int add = ADD_MANAGED_RESOURCE;
1028 ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
1030 ret = sscanf(buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
1031 add = REMOVE_MANAGED_RESOURCE;
1033 ret = sscanf(buf, "0x%lx - 0x%lx", &start_addr,
1035 add = ADD_MANAGED_RESOURCE;
1040 if (end_addr < start_addr)
1043 mutex_lock(&s->ops_mutex);
1044 ret = adjust_memory(s, add, start_addr, end_addr);
1046 s->resource_setup_new = 1;
1047 mutex_unlock(&s->ops_mutex);
1049 return ret ? ret : count;
1051 static DEVICE_ATTR(available_resources_mem, 0600, show_mem_db, store_mem_db);
1053 static struct attribute *pccard_rsrc_attributes[] = {
1054 &dev_attr_available_resources_io.attr,
1055 &dev_attr_available_resources_mem.attr,
1059 static const struct attribute_group rsrc_attributes = {
1060 .attrs = pccard_rsrc_attributes,
1063 static int __devinit pccard_sysfs_add_rsrc(struct device *dev,
1064 struct class_interface *class_intf)
1066 struct pcmcia_socket *s = dev_get_drvdata(dev);
1068 if (s->resource_ops != &pccard_nonstatic_ops)
1070 return sysfs_create_group(&dev->kobj, &rsrc_attributes);
1073 static void __devexit pccard_sysfs_remove_rsrc(struct device *dev,
1074 struct class_interface *class_intf)
1076 struct pcmcia_socket *s = dev_get_drvdata(dev);
1078 if (s->resource_ops != &pccard_nonstatic_ops)
1080 sysfs_remove_group(&dev->kobj, &rsrc_attributes);
1083 static struct class_interface pccard_rsrc_interface __refdata = {
1084 .class = &pcmcia_socket_class,
1085 .add_dev = &pccard_sysfs_add_rsrc,
1086 .remove_dev = __devexit_p(&pccard_sysfs_remove_rsrc),
1089 static int __init nonstatic_sysfs_init(void)
1091 return class_interface_register(&pccard_rsrc_interface);
1094 static void __exit nonstatic_sysfs_exit(void)
1096 class_interface_unregister(&pccard_rsrc_interface);
1099 module_init(nonstatic_sysfs_init);
1100 module_exit(nonstatic_sysfs_exit);