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 static DEFINE_MUTEX(rsrc_mutex);
63 #define MEM_PROBE_LOW (1 << 0)
64 #define MEM_PROBE_HIGH (1 << 1)
67 /*======================================================================
69 Linux resource management extensions
71 ======================================================================*/
73 static struct resource *
74 make_resource(resource_size_t b, resource_size_t n, int flags, const char *name)
76 struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
87 static struct resource *
88 claim_region(struct pcmcia_socket *s, resource_size_t base,
89 resource_size_t size, int type, char *name)
91 struct resource *res, *parent;
93 parent = type & IORESOURCE_MEM ? &iomem_resource : &ioport_resource;
94 res = make_resource(base, size, type | IORESOURCE_BUSY, name);
99 parent = pci_find_parent_resource(s->cb_dev, res);
101 if (!parent || request_resource(parent, res)) {
109 static void free_region(struct resource *res)
112 release_resource(res);
117 /*======================================================================
119 These manage the internal databases of available resources.
121 ======================================================================*/
123 static int add_interval(struct resource_map *map, u_long base, u_long num)
125 struct resource_map *p, *q;
127 for (p = map; ; p = p->next) {
128 if ((p != map) && (p->base+p->num-1 >= base))
130 if ((p->next == map) || (p->next->base > base+num-1))
133 q = kmalloc(sizeof(struct resource_map), GFP_KERNEL);
135 printk(KERN_WARNING "out of memory to update resources\n");
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),
174 printk(KERN_WARNING "out of memory to update resources\n");
178 p->num = q->base+q->num - p->base;
179 q->num = base - q->base;
180 p->next = q->next ; q->next = p;
187 /*======================================================================
189 These routines examine a region of IO or memory addresses to
190 determine what ranges might be genuinely available.
192 ======================================================================*/
194 #ifdef CONFIG_PCMCIA_PROBE
195 static void do_io_probe(struct pcmcia_socket *s, unsigned int base,
198 struct resource *res;
199 struct socket_data *s_data = s->resource_data;
200 unsigned int i, j, bad;
202 u_char *b, hole, most;
204 dev_printk(KERN_INFO, &s->dev, "cs: IO port probe %#x-%#x:",
207 /* First, what does a floating port look like? */
208 b = kzalloc(256, GFP_KERNEL);
211 dev_printk(KERN_ERR, &s->dev,
212 "do_io_probe: unable to kmalloc 256 bytes");
215 for (i = base, most = 0; i < base+num; i += 8) {
216 res = claim_region(NULL, i, 8, IORESOURCE_IO, "PCMCIA ioprobe");
220 for (j = 1; j < 8; j++)
221 if (inb(i+j) != hole)
224 if ((j == 8) && (++b[hole] > b[most]))
232 for (i = base; i < base+num; i += 8) {
233 res = claim_region(NULL, i, 8, IORESOURCE_IO, "PCMCIA ioprobe");
236 for (j = 0; j < 8; j++)
237 if (inb(i+j) != most)
242 printk(" excluding");
247 sub_interval(&s_data->io_db, bad, i-bad);
248 printk(" %#x-%#x", bad, i-1);
254 if ((num > 16) && (bad == base) && (i == base+num)) {
255 printk(" nothing: probe failed.\n");
258 sub_interval(&s_data->io_db, bad, i-bad);
259 printk(" %#x-%#x", bad, i-1);
263 printk(any ? "\n" : " clean.\n");
267 /*======================================================================
269 This is tricky... when we set up CIS memory, we try to validate
270 the memory window space allocations.
272 ======================================================================*/
274 /* Validation function for cards with a valid CIS */
275 static int readable(struct pcmcia_socket *s, struct resource *res,
280 s->cis_mem.res = res;
281 s->cis_virt = ioremap(res->start, s->map_size);
283 ret = pccard_validate_cis(s, count);
284 /* invalidate mapping and CIS cache */
285 iounmap(s->cis_virt);
287 destroy_cis_cache(s);
289 s->cis_mem.res = NULL;
290 if ((ret != 0) || (*count == 0))
295 /* Validation function for simple memory cards */
296 static int checksum(struct pcmcia_socket *s, struct resource *res)
299 int i, a = 0, b = -1, d;
302 virt = ioremap(res->start, s->map_size);
305 map.flags = MAP_ACTIVE;
309 s->ops->set_mem_map(s, &map);
311 /* Don't bother checking every word... */
312 for (i = 0; i < s->map_size; i += 44) {
319 s->ops->set_mem_map(s, &map);
324 return (b == -1) ? -1 : (a>>1);
328 cis_readable(struct pcmcia_socket *s, unsigned long base, unsigned long size)
330 struct resource *res1, *res2;
331 unsigned int info1, info2;
334 res1 = claim_region(s, base, size/2, IORESOURCE_MEM, "PCMCIA memprobe");
335 res2 = claim_region(s, base + size/2, size/2, IORESOURCE_MEM,
339 ret = readable(s, res1, &info1);
340 ret += readable(s, res2, &info2);
346 return (ret == 2) && (info1 == info2);
350 checksum_match(struct pcmcia_socket *s, unsigned long base, unsigned long size)
352 struct resource *res1, *res2;
355 res1 = claim_region(s, base, size/2, IORESOURCE_MEM, "PCMCIA memprobe");
356 res2 = claim_region(s, base + size/2, size/2, IORESOURCE_MEM,
360 a = checksum(s, res1);
361 b = checksum(s, res2);
367 return (a == b) && (a >= 0);
370 /*======================================================================
372 The memory probe. If the memory list includes a 64K-aligned block
373 below 1MB, we probe in 64K chunks, and as soon as we accumulate at
374 least mem_limit free space, we quit.
376 ======================================================================*/
378 static int do_mem_probe(u_long base, u_long num, struct pcmcia_socket *s)
380 struct socket_data *s_data = s->resource_data;
381 u_long i, j, bad, fail, step;
383 dev_printk(KERN_INFO, &s->dev, "cs: memory probe 0x%06lx-0x%06lx:",
386 step = (num < 0x20000) ? 0x2000 : ((num>>4) & ~0x1fff);
387 /* don't allow too large steps */
390 /* cis_readable wants to map 2x map_size */
391 if (step < 2 * s->map_size)
392 step = 2 * s->map_size;
393 for (i = j = base; i < base+num; i = j + step) {
395 for (j = i; j < base+num; j += step) {
396 if (cis_readable(s, j, step))
399 fail = ((i == base) && (j == base+num));
402 for (j = i; j < base+num; j += 2*step)
403 if (checksum_match(s, j, step) &&
404 checksum_match(s, j + step, step))
409 printk(" excluding");
410 printk(" %#05lx-%#05lx", i, j-1);
411 sub_interval(&s_data->mem_db, i, j-i);
415 printk(bad ? "\n" : " clean.\n");
419 #ifdef CONFIG_PCMCIA_PROBE
421 static u_long inv_probe(struct resource_map *m, struct pcmcia_socket *s)
423 struct socket_data *s_data = s->resource_data;
425 if (m == &s_data->mem_db)
427 ok = inv_probe(m->next, s);
429 if (m->base >= 0x100000)
430 sub_interval(&s_data->mem_db, m->base, m->num);
433 if (m->base < 0x100000)
435 return do_mem_probe(m->base, m->num, s);
438 static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
440 struct resource_map *m, mm;
441 static unsigned char order[] = { 0xd0, 0xe0, 0xc0, 0xf0 };
442 unsigned long b, i, ok = 0;
443 struct socket_data *s_data = s->resource_data;
445 /* We do up to four passes through the list */
446 if (probe_mask & MEM_PROBE_HIGH) {
447 if (inv_probe(s_data->mem_db.next, s) > 0)
449 dev_printk(KERN_NOTICE, &s->dev,
450 "cs: warning: no high memory space available!\n");
454 for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) {
456 /* Only probe < 1 MB */
457 if (mm.base >= 0x100000)
459 if ((mm.base | mm.num) & 0xffff) {
460 ok += do_mem_probe(mm.base, mm.num, s);
463 /* Special probe for 64K-aligned block */
464 for (i = 0; i < 4; i++) {
466 if ((b >= mm.base) && (b+0x10000 <= mm.base+mm.num)) {
468 sub_interval(&s_data->mem_db, b, 0x10000);
470 ok += do_mem_probe(b, 0x10000, s);
481 #else /* CONFIG_PCMCIA_PROBE */
483 static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask)
485 struct resource_map *m, mm;
486 struct socket_data *s_data = s->resource_data;
487 unsigned long ok = 0;
489 for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) {
491 ok += do_mem_probe(mm.base, mm.num, s);
498 #endif /* CONFIG_PCMCIA_PROBE */
502 * Locking note: Must be called with skt_mutex held!
504 static int pcmcia_nonstatic_validate_mem(struct pcmcia_socket *s)
506 struct socket_data *s_data = s->resource_data;
507 unsigned int probe_mask = MEM_PROBE_LOW;
513 mutex_lock(&rsrc_mutex);
515 if (s->features & SS_CAP_PAGE_REGS)
516 probe_mask = MEM_PROBE_HIGH;
518 if (probe_mask & ~s_data->rsrc_mem_probe) {
519 if (s->state & SOCKET_PRESENT)
520 ret = validate_mem(s, probe_mask);
522 s_data->rsrc_mem_probe |= probe_mask;
525 mutex_unlock(&rsrc_mutex);
530 struct pcmcia_align_data {
532 unsigned long offset;
533 struct resource_map *map;
536 static resource_size_t
537 pcmcia_common_align(void *align_data, const struct resource *res,
538 resource_size_t size, resource_size_t align)
540 struct pcmcia_align_data *data = align_data;
541 resource_size_t start;
543 * Ensure that we have the correct start address
545 start = (res->start & ~data->mask) + data->offset;
546 if (start < res->start)
547 start += data->mask + 1;
551 static resource_size_t
552 pcmcia_align(void *align_data, const struct resource *res,
553 resource_size_t size, resource_size_t align)
555 struct pcmcia_align_data *data = align_data;
556 struct resource_map *m;
557 resource_size_t start;
559 start = pcmcia_common_align(data, res, size, align);
561 for (m = data->map->next; m != data->map; m = m->next) {
562 unsigned long start = m->base;
563 unsigned long end = m->base + m->num - 1;
566 * If the lower resources are not available, try aligning
567 * to this entry of the resource database to see if it'll
570 if (res->start < start) {
571 start = pcmcia_common_align(data, res, size, align);
575 * If we're above the area which was passed in, there's
576 * no point proceeding.
578 if (res->start >= res->end)
581 if ((res->start + size - 1) <= end)
586 * If we failed to find something suitable, ensure we fail.
595 * Adjust an existing IO region allocation, but making sure that we don't
596 * encroach outside the resources which the user supplied.
598 static int nonstatic_adjust_io_region(struct resource *res, unsigned long r_start,
599 unsigned long r_end, struct pcmcia_socket *s)
601 struct resource_map *m;
602 struct socket_data *s_data = s->resource_data;
605 mutex_lock(&rsrc_mutex);
606 for (m = s_data->io_db.next; m != &s_data->io_db; m = m->next) {
607 unsigned long start = m->base;
608 unsigned long end = m->base + m->num - 1;
610 if (start > r_start || r_end > end)
613 ret = adjust_resource(res, r_start, r_end - r_start + 1);
616 mutex_unlock(&rsrc_mutex);
621 /*======================================================================
623 These find ranges of I/O ports or memory addresses that are not
624 currently allocated by other devices.
626 The 'align' field should reflect the number of bits of address
627 that need to be preserved from the initial value of *base. It
628 should be a power of two, greater than or equal to 'num'. A value
629 of 0 means that all bits of *base are significant. *base should
630 also be strictly less than 'align'.
632 ======================================================================*/
634 static struct resource *nonstatic_find_io_region(unsigned long base, int num,
635 unsigned long align, struct pcmcia_socket *s)
637 struct resource *res = make_resource(0, num, IORESOURCE_IO, dev_name(&s->dev));
638 struct socket_data *s_data = s->resource_data;
639 struct pcmcia_align_data data;
640 unsigned long min = base;
646 data.mask = align - 1;
647 data.offset = base & data.mask;
648 data.map = &s_data->io_db;
650 mutex_lock(&rsrc_mutex);
653 ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num, 1,
654 min, 0, pcmcia_align, &data);
657 ret = allocate_resource(&ioport_resource, res, num, min, ~0UL,
658 1, pcmcia_align, &data);
659 mutex_unlock(&rsrc_mutex);
668 static struct resource *nonstatic_find_mem_region(u_long base, u_long num,
669 u_long align, int low, struct pcmcia_socket *s)
671 struct resource *res = make_resource(0, num, IORESOURCE_MEM, dev_name(&s->dev));
672 struct socket_data *s_data = s->resource_data;
673 struct pcmcia_align_data data;
674 unsigned long min, max;
677 low = low || !(s->features & SS_CAP_PAGE_REGS);
679 data.mask = align - 1;
680 data.offset = base & data.mask;
681 data.map = &s_data->mem_db;
683 for (i = 0; i < 2; i++) {
686 min = base < max ? base : 0;
689 min = 0x100000UL + base;
692 mutex_lock(&rsrc_mutex);
695 ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num,
697 pcmcia_align, &data);
700 ret = allocate_resource(&iomem_resource, res, num, min,
701 max, 1, pcmcia_align, &data);
702 mutex_unlock(&rsrc_mutex);
716 static int adjust_memory(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end)
718 struct socket_data *data = s->resource_data;
719 unsigned long size = end - start + 1;
725 mutex_lock(&rsrc_mutex);
727 case ADD_MANAGED_RESOURCE:
728 ret = add_interval(&data->mem_db, start, size);
730 case REMOVE_MANAGED_RESOURCE:
731 ret = sub_interval(&data->mem_db, start, size);
733 struct pcmcia_socket *socket;
734 down_read(&pcmcia_socket_list_rwsem);
735 list_for_each_entry(socket, &pcmcia_socket_list, socket_list)
736 release_cis_mem(socket);
737 up_read(&pcmcia_socket_list_rwsem);
743 mutex_unlock(&rsrc_mutex);
749 static int adjust_io(struct pcmcia_socket *s, unsigned int action, unsigned long start, unsigned long end)
751 struct socket_data *data = s->resource_data;
752 unsigned long size = end - start + 1;
758 if (end > IO_SPACE_LIMIT)
761 mutex_lock(&rsrc_mutex);
763 case ADD_MANAGED_RESOURCE:
764 if (add_interval(&data->io_db, start, size) != 0) {
768 #ifdef CONFIG_PCMCIA_PROBE
770 do_io_probe(s, start, size);
773 case REMOVE_MANAGED_RESOURCE:
774 sub_interval(&data->io_db, start, size);
780 mutex_unlock(&rsrc_mutex);
787 static int nonstatic_autoadd_resources(struct pcmcia_socket *s)
789 struct resource *res;
792 if (!s->cb_dev || !s->cb_dev->bus)
795 #if defined(CONFIG_X86)
796 /* If this is the root bus, the risk of hitting
797 * some strange system devices which aren't protected
798 * by either ACPI resource tables or properly requested
799 * resources is too big. Therefore, don't do auto-adding
800 * of resources at the moment.
802 if (s->cb_dev->bus->number == 0)
806 pci_bus_for_each_resource(s->cb_dev->bus, res, i) {
810 if (res->flags & IORESOURCE_IO) {
811 if (res == &ioport_resource)
813 dev_printk(KERN_INFO, &s->cb_dev->dev,
814 "pcmcia: parent PCI bridge I/O "
815 "window: 0x%llx - 0x%llx\n",
816 (unsigned long long)res->start,
817 (unsigned long long)res->end);
818 if (!adjust_io(s, ADD_MANAGED_RESOURCE, res->start, res->end))
819 done |= IORESOURCE_IO;
823 if (res->flags & IORESOURCE_MEM) {
824 if (res == &iomem_resource)
826 dev_printk(KERN_INFO, &s->cb_dev->dev,
827 "pcmcia: parent PCI bridge Memory "
828 "window: 0x%llx - 0x%llx\n",
829 (unsigned long long)res->start,
830 (unsigned long long)res->end);
831 if (!adjust_memory(s, ADD_MANAGED_RESOURCE, res->start, res->end))
832 done |= IORESOURCE_MEM;
836 /* if we got at least one of IO, and one of MEM, we can be glad and
837 * activate the PCMCIA subsystem */
838 if (done == (IORESOURCE_MEM | IORESOURCE_IO))
839 s->resource_setup_done = 1;
846 static inline int nonstatic_autoadd_resources(struct pcmcia_socket *s)
854 static int nonstatic_init(struct pcmcia_socket *s)
856 struct socket_data *data;
858 data = kzalloc(sizeof(struct socket_data), GFP_KERNEL);
862 data->mem_db.next = &data->mem_db;
863 data->io_db.next = &data->io_db;
865 s->resource_data = (void *) data;
867 nonstatic_autoadd_resources(s);
872 static void nonstatic_release_resource_db(struct pcmcia_socket *s)
874 struct socket_data *data = s->resource_data;
875 struct resource_map *p, *q;
877 mutex_lock(&rsrc_mutex);
878 for (p = data->mem_db.next; p != &data->mem_db; p = q) {
882 for (p = data->io_db.next; p != &data->io_db; p = q) {
886 mutex_unlock(&rsrc_mutex);
890 struct pccard_resource_ops pccard_nonstatic_ops = {
891 .validate_mem = pcmcia_nonstatic_validate_mem,
892 .adjust_io_region = nonstatic_adjust_io_region,
893 .find_io = nonstatic_find_io_region,
894 .find_mem = nonstatic_find_mem_region,
896 .add_mem = adjust_memory,
897 .init = nonstatic_init,
898 .exit = nonstatic_release_resource_db,
900 EXPORT_SYMBOL(pccard_nonstatic_ops);
903 /* sysfs interface to the resource database */
905 static ssize_t show_io_db(struct device *dev,
906 struct device_attribute *attr, char *buf)
908 struct pcmcia_socket *s = dev_get_drvdata(dev);
909 struct socket_data *data;
910 struct resource_map *p;
913 mutex_lock(&rsrc_mutex);
914 data = s->resource_data;
916 for (p = data->io_db.next; p != &data->io_db; p = p->next) {
917 if (ret > (PAGE_SIZE - 10))
919 ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1),
920 "0x%08lx - 0x%08lx\n",
921 ((unsigned long) p->base),
922 ((unsigned long) p->base + p->num - 1));
925 mutex_unlock(&rsrc_mutex);
929 static ssize_t store_io_db(struct device *dev,
930 struct device_attribute *attr,
931 const char *buf, size_t count)
933 struct pcmcia_socket *s = dev_get_drvdata(dev);
934 unsigned long start_addr, end_addr;
935 unsigned int add = ADD_MANAGED_RESOURCE;
938 ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
940 ret = sscanf(buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
941 add = REMOVE_MANAGED_RESOURCE;
943 ret = sscanf(buf, "0x%lx - 0x%lx", &start_addr,
945 add = ADD_MANAGED_RESOURCE;
950 if (end_addr < start_addr)
953 ret = adjust_io(s, add, start_addr, end_addr);
955 s->resource_setup_new = 1;
957 return ret ? ret : count;
959 static DEVICE_ATTR(available_resources_io, 0600, show_io_db, store_io_db);
961 static ssize_t show_mem_db(struct device *dev,
962 struct device_attribute *attr, char *buf)
964 struct pcmcia_socket *s = dev_get_drvdata(dev);
965 struct socket_data *data;
966 struct resource_map *p;
969 mutex_lock(&rsrc_mutex);
970 data = s->resource_data;
972 for (p = data->mem_db.next; p != &data->mem_db; p = p->next) {
973 if (ret > (PAGE_SIZE - 10))
975 ret += snprintf(&buf[ret], (PAGE_SIZE - ret - 1),
976 "0x%08lx - 0x%08lx\n",
977 ((unsigned long) p->base),
978 ((unsigned long) p->base + p->num - 1));
981 mutex_unlock(&rsrc_mutex);
985 static ssize_t store_mem_db(struct device *dev,
986 struct device_attribute *attr,
987 const char *buf, size_t count)
989 struct pcmcia_socket *s = dev_get_drvdata(dev);
990 unsigned long start_addr, end_addr;
991 unsigned int add = ADD_MANAGED_RESOURCE;
994 ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr);
996 ret = sscanf(buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr);
997 add = REMOVE_MANAGED_RESOURCE;
999 ret = sscanf(buf, "0x%lx - 0x%lx", &start_addr,
1001 add = ADD_MANAGED_RESOURCE;
1006 if (end_addr < start_addr)
1009 ret = adjust_memory(s, add, start_addr, end_addr);
1011 s->resource_setup_new = 1;
1013 return ret ? ret : count;
1015 static DEVICE_ATTR(available_resources_mem, 0600, show_mem_db, store_mem_db);
1017 static struct attribute *pccard_rsrc_attributes[] = {
1018 &dev_attr_available_resources_io.attr,
1019 &dev_attr_available_resources_mem.attr,
1023 static const struct attribute_group rsrc_attributes = {
1024 .attrs = pccard_rsrc_attributes,
1027 static int __devinit pccard_sysfs_add_rsrc(struct device *dev,
1028 struct class_interface *class_intf)
1030 struct pcmcia_socket *s = dev_get_drvdata(dev);
1032 if (s->resource_ops != &pccard_nonstatic_ops)
1034 return sysfs_create_group(&dev->kobj, &rsrc_attributes);
1037 static void __devexit pccard_sysfs_remove_rsrc(struct device *dev,
1038 struct class_interface *class_intf)
1040 struct pcmcia_socket *s = dev_get_drvdata(dev);
1042 if (s->resource_ops != &pccard_nonstatic_ops)
1044 sysfs_remove_group(&dev->kobj, &rsrc_attributes);
1047 static struct class_interface pccard_rsrc_interface __refdata = {
1048 .class = &pcmcia_socket_class,
1049 .add_dev = &pccard_sysfs_add_rsrc,
1050 .remove_dev = __devexit_p(&pccard_sysfs_remove_rsrc),
1053 static int __init nonstatic_sysfs_init(void)
1055 return class_interface_register(&pccard_rsrc_interface);
1058 static void __exit nonstatic_sysfs_exit(void)
1060 class_interface_unregister(&pccard_rsrc_interface);
1063 module_init(nonstatic_sysfs_init);
1064 module_exit(nonstatic_sysfs_exit);