dump_cis: Work on files only, not devices
Make the input file parameter mandatory and link directly to the CIS
tuple parser. Remove all device access.
Strip out some definitions that were for kernel use only.
Remove now-incorrect version strings.
diff --git a/Makefile b/Makefile
index d2868ec..10667d6 100644
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,7 @@
all: $(SRCS) $(HDRS) $(TOOLS)
-dump_cis: dump_cis.o
+dump_cis: dump_cis.o cistpl.o
yacc_cis.o: yacc_cis.c
$(CC) -MD $(CFLAGS) $(CPPFLAGS) -c $<
diff --git a/cistpl.c b/cistpl.c
index 404b8e4..6875ac8 100644
--- a/cistpl.c
+++ b/cistpl.c
@@ -2,8 +2,6 @@
PCMCIA Card Information Structure parser
- cistpl.c 1.101 2003/12/15 03:58:03
-
The contents of this file are subject to the Mozilla Public
License Version 1.1 (the "License"); you may not use this file
except in compliance with the License. You may obtain a copy of
@@ -31,31 +29,16 @@
======================================================================*/
-#define __NO_VERSION__
+#include <stddef.h>
-#include <linux/config.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/string.h>
-#include <linux/major.h>
-#include <linux/errno.h>
-#include <linux/timer.h>
-#include <linux/slab.h>
-#include <linux/mm.h>
-#include <linux/sched.h>
-#include <linux/pci.h>
-#include <linux/ioport.h>
-#include <asm/io.h>
#include <asm/byteorder.h>
+#define le16_to_cpu __le16_to_cpu
+#define le32_to_cpu __le32_to_cpu
#include <pcmcia/cs_types.h>
-#include <pcmcia/bus_ops.h>
-#include <pcmcia/ss.h>
#include <pcmcia/cs.h>
#include <pcmcia/bulkmem.h>
-#include <pcmcia/cisreg.h>
#include <pcmcia/cistpl.h>
-#include "cs_internal.h"
static const u_char mantissa[] = {
10, 12, 13, 15, 20, 25, 30, 35,
@@ -74,552 +57,6 @@
(mantissa[((v)>>3)&15] * exponent[(v)&7] / 10)
#define POWER_SCALE(v) (exponent[(v)&7])
-/* Upper limit on reasonable # of tuples */
-#define MAX_TUPLES 200
-
-/*====================================================================*/
-
-/* Parameters that can be set with 'insmod' */
-
-#define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i")
-
-INT_MODULE_PARM(cis_width, 0); /* 16-bit CIS? */
-
-/*======================================================================
-
- Low-level functions to read and write CIS memory. I think the
- write routine is only useful for writing one-byte registers.
-
-======================================================================*/
-
-/* Bits in attr field */
-#define IS_ATTR 1
-#define IS_INDIRECT 8
-
-static int setup_cis_mem(socket_info_t *s);
-
-static void set_cis_map(socket_info_t *s, pccard_mem_map *mem)
-{
- s->ss_entry(s->sock, SS_SetMemMap, mem);
- if (s->cap.features & SS_CAP_STATIC_MAP) {
- if (s->cis_virt)
- bus_iounmap(s->cap.bus, s->cis_virt);
- s->cis_virt = bus_ioremap(s->cap.bus, mem->sys_start,
- s->cap.map_size);
- }
-}
-
-int read_cis_mem(socket_info_t *s, int attr, u_int addr,
- u_int len, void *ptr)
-{
- pccard_mem_map *mem = &s->cis_mem;
- u_char *sys, *buf = ptr;
-
- DEBUG(3, "cs: read_cis_mem(%d, %#x, %u)\n", attr, addr, len);
- if (setup_cis_mem(s) != 0) {
- memset(ptr, 0xff, len);
- return -1;
- }
- mem->flags = MAP_ACTIVE | ((cis_width) ? MAP_16BIT : 0);
-
- if (attr & IS_INDIRECT) {
- /* Indirect accesses use a bunch of special registers at fixed
- locations in common memory */
- u_char flags = ICTRL0_COMMON|ICTRL0_AUTOINC|ICTRL0_BYTEGRAN;
- if (attr & IS_ATTR) { addr *= 2; flags = ICTRL0_AUTOINC; }
- mem->card_start = 0; mem->flags = MAP_ACTIVE;
- set_cis_map(s, mem);
- sys = s->cis_virt;
- bus_writeb(s->cap.bus, flags, sys+CISREG_ICTRL0);
- bus_writeb(s->cap.bus, addr & 0xff, sys+CISREG_IADDR0);
- bus_writeb(s->cap.bus, (addr>>8) & 0xff, sys+CISREG_IADDR1);
- bus_writeb(s->cap.bus, (addr>>16) & 0xff, sys+CISREG_IADDR2);
- bus_writeb(s->cap.bus, (addr>>24) & 0xff, sys+CISREG_IADDR3);
- for ( ; len > 0; len--, buf++)
- *buf = bus_readb(s->cap.bus, sys+CISREG_IDATA0);
- } else {
- u_int inc = 1;
- if (attr) { mem->flags |= MAP_ATTRIB; inc++; addr *= 2; }
- sys += (addr & (s->cap.map_size-1));
- mem->card_start = addr & ~(s->cap.map_size-1);
- while (len) {
- set_cis_map(s, mem);
- sys = s->cis_virt + (addr & (s->cap.map_size-1));
- for ( ; len > 0; len--, buf++, sys += inc) {
- if (sys == s->cis_virt+s->cap.map_size) break;
- *buf = bus_readb(s->cap.bus, sys);
- }
- mem->card_start += s->cap.map_size;
- addr = 0;
- }
- }
- DEBUG(3, "cs: %#2.2x %#2.2x %#2.2x %#2.2x ...\n",
- *(u_char *)(ptr+0), *(u_char *)(ptr+1),
- *(u_char *)(ptr+2), *(u_char *)(ptr+3));
- return 0;
-}
-
-void write_cis_mem(socket_info_t *s, int attr, u_int addr,
- u_int len, void *ptr)
-{
- pccard_mem_map *mem = &s->cis_mem;
- u_char *sys, *buf = ptr;
-
- DEBUG(3, "cs: write_cis_mem(%d, %#x, %u)\n", attr, addr, len);
- if (setup_cis_mem(s) != 0) return;
- mem->flags = MAP_ACTIVE | ((cis_width) ? MAP_16BIT : 0);
-
- if (attr & IS_INDIRECT) {
- /* Indirect accesses use a bunch of special registers at fixed
- locations in common memory */
- u_char flags = ICTRL0_COMMON|ICTRL0_AUTOINC|ICTRL0_BYTEGRAN;
- if (attr & IS_ATTR) { addr *= 2; flags = ICTRL0_AUTOINC; }
- mem->card_start = 0; mem->flags = MAP_ACTIVE;
- set_cis_map(s, mem);
- sys = s->cis_virt;
- bus_writeb(s->cap.bus, flags, sys+CISREG_ICTRL0);
- bus_writeb(s->cap.bus, addr & 0xff, sys+CISREG_IADDR0);
- bus_writeb(s->cap.bus, (addr>>8) & 0xff, sys+CISREG_IADDR1);
- bus_writeb(s->cap.bus, (addr>>16) & 0xff, sys+CISREG_IADDR2);
- bus_writeb(s->cap.bus, (addr>>24) & 0xff, sys+CISREG_IADDR3);
- for ( ; len > 0; len--, buf++)
- bus_writeb(s->cap.bus, *buf, sys+CISREG_IDATA0);
- } else {
- int inc = 1;
- if (attr & IS_ATTR) { mem->flags |= MAP_ATTRIB; inc++; addr *= 2; }
- mem->card_start = addr & ~(s->cap.map_size-1);
- while (len) {
- set_cis_map(s, mem);
- sys = s->cis_virt + (addr & (s->cap.map_size-1));
- for ( ; len > 0; len--, buf++, sys += inc) {
- if (sys == s->cis_virt+s->cap.map_size) break;
- bus_writeb(s->cap.bus, *buf, sys);
- }
- mem->card_start += s->cap.map_size;
- addr = 0;
- }
- }
-}
-
-/*======================================================================
-
- This is tricky... when we set up CIS memory, we try to validate
- the memory window space allocations.
-
-======================================================================*/
-
-/* Scratch pointer to the socket we use for validation */
-static socket_info_t *vs = NULL;
-
-/* Validation function for cards with a valid CIS */
-static int cis_readable(u_long base)
-{
- cisinfo_t info1, info2;
- int ret;
- vs->cis_mem.sys_start = base;
- vs->cis_mem.sys_stop = base+vs->cap.map_size-1;
- vs->cis_virt = bus_ioremap(vs->cap.bus, base, vs->cap.map_size);
- ret = validate_cis(vs->clients, &info1);
- /* invalidate mapping and CIS cache */
- bus_iounmap(vs->cap.bus, vs->cis_virt); vs->cis_used = 0;
- if ((ret != 0) || (info1.Chains == 0))
- return 0;
- vs->cis_mem.sys_start = base+vs->cap.map_size;
- vs->cis_mem.sys_stop = base+2*vs->cap.map_size-1;
- vs->cis_virt = bus_ioremap(vs->cap.bus, base+vs->cap.map_size,
- vs->cap.map_size);
- ret = validate_cis(vs->clients, &info2);
- bus_iounmap(vs->cap.bus, vs->cis_virt); vs->cis_used = 0;
- return ((ret == 0) && (info1.Chains == info2.Chains));
-}
-
-/* Validation function for simple memory cards */
-static int checksum(u_long base)
-{
- int i, a, b, d;
- vs->cis_mem.sys_start = base;
- vs->cis_mem.sys_stop = base+vs->cap.map_size-1;
- vs->cis_virt = bus_ioremap(vs->cap.bus, base, vs->cap.map_size);
- vs->cis_mem.card_start = 0;
- vs->cis_mem.flags = MAP_ACTIVE;
- vs->ss_entry(vs->sock, SS_SetMemMap, &vs->cis_mem);
- /* Don't bother checking every word... */
- a = 0; b = -1;
- for (i = 0; i < vs->cap.map_size; i += 44) {
- d = bus_readl(vs->cap.bus, vs->cis_virt+i);
- a += d; b &= d;
- }
- bus_iounmap(vs->cap.bus, vs->cis_virt);
- return (b == -1) ? -1 : (a>>1);
-}
-
-static int checksum_match(u_long base)
-{
- int a = checksum(base), b = checksum(base+vs->cap.map_size);
- return ((a == b) && (a >= 0));
-}
-
-static int setup_cis_mem(socket_info_t *s)
-{
- if (!(s->cap.features & SS_CAP_STATIC_MAP) &&
- (s->cis_mem.sys_start == 0)) {
- int low = !(s->cap.features & SS_CAP_PAGE_REGS);
- vs = s;
- validate_mem(cis_readable, checksum_match, low);
- s->cis_mem.sys_start = 0;
- vs = NULL;
- if (find_mem_region(&s->cis_mem.sys_start, s->cap.map_size,
- s->cap.map_size, low, "card services")) {
- printk(KERN_NOTICE "cs: unable to map card memory!\n");
- return -1;
- }
- s->cis_mem.sys_stop = s->cis_mem.sys_start+s->cap.map_size-1;
- s->cis_virt = bus_ioremap(s->cap.bus, s->cis_mem.sys_start,
- s->cap.map_size);
- }
- return 0;
-}
-
-void release_cis_mem(socket_info_t *s)
-{
- if (s->cis_mem.sys_start != 0) {
- s->cis_mem.flags &= ~MAP_ACTIVE;
- s->ss_entry(s->sock, SS_SetMemMap, &s->cis_mem);
- if (!(s->cap.features & SS_CAP_STATIC_MAP))
- release_mem_region(s->cis_mem.sys_start, s->cap.map_size);
- bus_iounmap(s->cap.bus, s->cis_virt);
- s->cis_mem.sys_start = 0;
- s->cis_virt = NULL;
- }
-}
-
-/*======================================================================
-
- This is a wrapper around read_cis_mem, with the same interface,
- but which caches information, for cards whose CIS may not be
- readable all the time.
-
-======================================================================*/
-
-static void read_cis_cache(socket_info_t *s, int attr, u_int addr,
- u_int len, void *ptr)
-{
- int i, ret;
- char *caddr;
-
- if (s->fake_cis) {
- if (s->fake_cis_len > addr+len)
- memcpy(ptr, s->fake_cis+addr, len);
- else
- memset(ptr, 0xff, len);
- return;
- }
- caddr = s->cis_cache;
- for (i = 0; i < s->cis_used; i++) {
- if ((s->cis_table[i].addr == addr) &&
- (s->cis_table[i].len == len) &&
- (s->cis_table[i].attr == attr)) break;
- caddr += s->cis_table[i].len;
- }
- if (i < s->cis_used) {
- memcpy(ptr, caddr, len);
- return;
- }
-#ifdef CONFIG_CARDBUS
- if (s->state & SOCKET_CARDBUS)
- ret = read_cb_mem(s, 0, attr, addr, len, ptr);
- else
-#endif
- ret = read_cis_mem(s, attr, addr, len, ptr);
- /* Copy data into the cache, if there is room */
- if ((ret == 0) && (i < MAX_CIS_TABLE) &&
- (caddr+len < s->cis_cache+MAX_CIS_DATA)) {
- s->cis_table[i].addr = addr;
- s->cis_table[i].len = len;
- s->cis_table[i].attr = attr;
- s->cis_used++;
- memcpy(caddr, ptr, len);
- }
-}
-
-/*======================================================================
-
- This verifies if the CIS of a card matches what is in the CIS
- cache.
-
-======================================================================*/
-
-int verify_cis_cache(socket_info_t *s)
-{
- char *buf, *caddr;
- int i;
-
- buf = kmalloc(256, GFP_KERNEL);
- if (buf == NULL)
- return -1;
- caddr = s->cis_cache;
- for (i = 0; i < s->cis_used; i++) {
-#ifdef CONFIG_CARDBUS
- if (s->state & SOCKET_CARDBUS)
- read_cb_mem(s, 0, s->cis_table[i].attr, s->cis_table[i].addr,
- s->cis_table[i].len, buf);
- else
-#endif
- read_cis_mem(s, s->cis_table[i].attr, s->cis_table[i].addr,
- s->cis_table[i].len, buf);
- if (memcmp(buf, caddr, s->cis_table[i].len) != 0)
- break;
- caddr += s->cis_table[i].len;
- }
- kfree(buf);
- return (i < s->cis_used);
-}
-
-/*======================================================================
-
- For really bad cards, we provide a facility for uploading a
- replacement CIS.
-
-======================================================================*/
-
-int replace_cis(client_handle_t handle, cisdump_t *cis)
-{
- socket_info_t *s;
- if (CHECK_HANDLE(handle))
- return CS_BAD_HANDLE;
- s = SOCKET(handle);
- if (s->fake_cis != NULL) {
- kfree(s->fake_cis);
- s->fake_cis = NULL;
- }
- if (cis->Length > CISTPL_MAX_CIS_SIZE)
- return CS_BAD_SIZE;
- s->fake_cis = kmalloc(cis->Length, GFP_KERNEL);
- if (s->fake_cis == NULL)
- return CS_OUT_OF_RESOURCE;
- s->fake_cis_len = cis->Length;
- memcpy(s->fake_cis, cis->Data, cis->Length);
- return CS_SUCCESS;
-}
-
-/*======================================================================
-
- The high-level CIS tuple services
-
-======================================================================*/
-
-typedef struct tuple_flags {
- u_int link_space:4;
- u_int has_link:1;
- u_int mfc_fn:3;
- u_int space:4;
-} tuple_flags;
-
-#define LINK_SPACE(f) (((tuple_flags *)(&(f)))->link_space)
-#define HAS_LINK(f) (((tuple_flags *)(&(f)))->has_link)
-#define MFC_FN(f) (((tuple_flags *)(&(f)))->mfc_fn)
-#define SPACE(f) (((tuple_flags *)(&(f)))->space)
-
-int get_next_tuple(client_handle_t handle, tuple_t *tuple);
-
-int get_first_tuple(client_handle_t handle, tuple_t *tuple)
-{
- socket_info_t *s;
- if (CHECK_HANDLE(handle))
- return CS_BAD_HANDLE;
- s = SOCKET(handle);
- if (!(s->state & SOCKET_PRESENT))
- return CS_NO_CARD;
- tuple->TupleLink = tuple->Flags = 0;
-#ifdef CONFIG_CARDBUS
- if (s->state & SOCKET_CARDBUS) {
- u_int ptr;
- pcibios_read_config_dword(s->cap.cardbus, 0, 0x28, &ptr);
- tuple->CISOffset = ptr & ~7;
- SPACE(tuple->Flags) = (ptr & 7);
- } else
-#endif
- {
- /* Assume presence of a LONGLINK_C to address 0 */
- tuple->CISOffset = tuple->LinkOffset = 0;
- SPACE(tuple->Flags) = HAS_LINK(tuple->Flags) = 1;
- }
- if (!(s->state & SOCKET_CARDBUS) && (s->functions > 1) &&
- !(tuple->Attributes & TUPLE_RETURN_COMMON)) {
- cisdata_t req = tuple->DesiredTuple;
- tuple->DesiredTuple = CISTPL_LONGLINK_MFC;
- if (get_next_tuple(handle, tuple) == CS_SUCCESS) {
- tuple->DesiredTuple = CISTPL_LINKTARGET;
- if (get_next_tuple(handle, tuple) != CS_SUCCESS)
- return CS_NO_MORE_ITEMS;
- } else
- tuple->CISOffset = tuple->TupleLink = 0;
- tuple->DesiredTuple = req;
- }
- return get_next_tuple(handle, tuple);
-}
-
-static int follow_link(socket_info_t *s, tuple_t *tuple)
-{
- u_char link[5];
- u_int ofs;
-
- if (MFC_FN(tuple->Flags)) {
- /* Get indirect link from the MFC tuple */
- read_cis_cache(s, LINK_SPACE(tuple->Flags),
- tuple->LinkOffset, 5, link);
- ofs = le32_to_cpu(*(u_int *)(link+1));
- SPACE(tuple->Flags) = (link[0] == CISTPL_MFC_ATTR);
- /* Move to the next indirect link */
- tuple->LinkOffset += 5;
- MFC_FN(tuple->Flags)--;
- } else if (HAS_LINK(tuple->Flags)) {
- ofs = tuple->LinkOffset;
- SPACE(tuple->Flags) = LINK_SPACE(tuple->Flags);
- HAS_LINK(tuple->Flags) = 0;
- } else {
- return -1;
- }
- if (!(s->state & SOCKET_CARDBUS) && SPACE(tuple->Flags)) {
- /* This is ugly, but a common CIS error is to code the long
- link offset incorrectly, so we check the right spot... */
- read_cis_cache(s, SPACE(tuple->Flags), ofs, 5, link);
- if ((link[0] == CISTPL_LINKTARGET) && (link[1] >= 3) &&
- (strncmp(link+2, "CIS", 3) == 0))
- return ofs;
- /* Then, we try the wrong spot... */
- ofs = ofs >> 1;
- }
- read_cis_cache(s, SPACE(tuple->Flags), ofs, 5, link);
- if ((link[0] != CISTPL_LINKTARGET) || (link[1] < 3) ||
- (strncmp(link+2, "CIS", 3) != 0))
- return -1;
- return ofs;
-}
-
-int get_next_tuple(client_handle_t handle, tuple_t *tuple)
-{
- socket_info_t *s;
- u_char link[2], tmp;
- int ofs, i, attr;
-
- if (CHECK_HANDLE(handle))
- return CS_BAD_HANDLE;
- s = SOCKET(handle);
- if (!(s->state & SOCKET_PRESENT))
- return CS_NO_CARD;
-
- link[1] = tuple->TupleLink;
- ofs = tuple->CISOffset + tuple->TupleLink;
- attr = SPACE(tuple->Flags);
-
- for (i = 0; i < MAX_TUPLES; i++) {
- if (link[1] == 0xff) {
- link[0] = CISTPL_END;
- } else {
- read_cis_cache(s, attr, ofs, 2, link);
- if (link[0] == CISTPL_NULL) {
- ofs++; continue;
- }
- }
-
- /* End of chain? Follow long link if possible */
- if (link[0] == CISTPL_END) {
- if ((ofs = follow_link(s, tuple)) < 0)
- return CS_NO_MORE_ITEMS;
- attr = SPACE(tuple->Flags);
- read_cis_cache(s, attr, ofs, 2, link);
- }
-
- /* Is this a link tuple? Make a note of it */
- if ((link[0] == CISTPL_LONGLINK_A) ||
- (link[0] == CISTPL_LONGLINK_C) ||
- (link[0] == CISTPL_LONGLINK_MFC) ||
- (link[0] == CISTPL_LINKTARGET) ||
- (link[0] == CISTPL_INDIRECT) ||
- (link[0] == CISTPL_NO_LINK)) {
- switch (link[0]) {
- case CISTPL_LONGLINK_A:
- HAS_LINK(tuple->Flags) = 1;
- LINK_SPACE(tuple->Flags) = attr | IS_ATTR;
- read_cis_cache(s, attr, ofs+2, 4, &tuple->LinkOffset);
- break;
- case CISTPL_LONGLINK_C:
- HAS_LINK(tuple->Flags) = 1;
- LINK_SPACE(tuple->Flags) = attr & ~IS_ATTR;
- read_cis_cache(s, attr, ofs+2, 4, &tuple->LinkOffset);
- break;
- case CISTPL_INDIRECT:
- HAS_LINK(tuple->Flags) = 1;
- LINK_SPACE(tuple->Flags) = IS_ATTR | IS_INDIRECT;
- tuple->LinkOffset = 0;
- break;
- case CISTPL_LONGLINK_MFC:
- tuple->LinkOffset = ofs + 3;
- LINK_SPACE(tuple->Flags) = attr;
- if (handle->Function == BIND_FN_ALL) {
- /* Follow all the MFC links */
- read_cis_cache(s, attr, ofs+2, 1, &tmp);
- MFC_FN(tuple->Flags) = tmp;
- } else {
- /* Follow exactly one of the links */
- MFC_FN(tuple->Flags) = 1;
- tuple->LinkOffset += handle->Function * 5;
- }
- break;
- case CISTPL_NO_LINK:
- HAS_LINK(tuple->Flags) = 0;
- break;
- }
- if ((tuple->Attributes & TUPLE_RETURN_LINK) &&
- (tuple->DesiredTuple == RETURN_FIRST_TUPLE))
- break;
- } else
- if (tuple->DesiredTuple == RETURN_FIRST_TUPLE)
- break;
-
- if (link[0] == tuple->DesiredTuple)
- break;
- ofs += link[1] + 2;
- }
- if (i == MAX_TUPLES) {
- DEBUG(1, "cs: overrun in get_next_tuple for socket %d\n",
- handle->Socket);
- return CS_NO_MORE_ITEMS;
- }
-
- tuple->TupleCode = link[0];
- tuple->TupleLink = link[1];
- tuple->CISOffset = ofs + 2;
- return CS_SUCCESS;
-}
-
-/*====================================================================*/
-
-#define _MIN(a, b) (((a) < (b)) ? (a) : (b))
-
-int get_tuple_data(client_handle_t handle, tuple_t *tuple)
-{
- socket_info_t *s;
- u_int len;
-
- if (CHECK_HANDLE(handle))
- return CS_BAD_HANDLE;
-
- s = SOCKET(handle);
-
- if (tuple->TupleLink < tuple->TupleOffset)
- return CS_NO_MORE_ITEMS;
- len = tuple->TupleLink - tuple->TupleOffset;
- tuple->TupleDataLen = tuple->TupleLink;
- if (len == 0)
- return CS_SUCCESS;
- read_cis_cache(s, SPACE(tuple->Flags),
- tuple->CISOffset + tuple->TupleOffset,
- _MIN(len, tuple->TupleDataMax), tuple->TupleData);
- return CS_SUCCESS;
-}
-
/*======================================================================
Parsing routines for individual tuples
@@ -1136,8 +573,6 @@
/*====================================================================*/
-#ifdef CONFIG_CARDBUS
-
static int parse_bar(tuple_t *tuple, cistpl_bar_t *bar)
{
u_char *p;
@@ -1235,8 +670,6 @@
return CS_SUCCESS;
}
-#endif
-
/*====================================================================*/
static int parse_device_geo(tuple_t *tuple, cistpl_device_geo_t *geo)
@@ -1324,7 +757,7 @@
/*====================================================================*/
-int parse_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
+int parse_tuple(tuple_t *tuple, cisparse_t *parse)
{
int ret = CS_SUCCESS;
@@ -1335,7 +768,6 @@
case CISTPL_DEVICE_A:
ret = parse_device(tuple, &parse->device);
break;
-#ifdef CONFIG_CARDBUS
case CISTPL_BAR:
ret = parse_bar(tuple, &parse->bar);
break;
@@ -1345,7 +777,6 @@
case CISTPL_CFTABLE_ENTRY_CB:
ret = parse_cftable_entry_cb(tuple, &parse->cftable_entry_cb);
break;
-#endif
case CISTPL_CHECKSUM:
ret = parse_checksum(tuple, &parse->checksum);
break;
@@ -1405,98 +836,3 @@
}
return ret;
}
-
-/*======================================================================
-
- This is used internally by Card Services to look up CIS stuff.
-
-======================================================================*/
-
-int read_tuple(client_handle_t handle, cisdata_t code, void *parse)
-{
- tuple_t tuple;
- cisdata_t *buf;
- int ret;
-
- buf = kmalloc(255, GFP_KERNEL);
- if (buf == NULL)
- return CS_OUT_OF_RESOURCE;
- tuple.DesiredTuple = code;
- tuple.Attributes = TUPLE_RETURN_COMMON;
- ret = CardServices(GetFirstTuple, handle, &tuple, NULL);
- if (ret != CS_SUCCESS) goto done;
- tuple.TupleData = buf;
- tuple.TupleOffset = 0;
- tuple.TupleDataMax = 255;
- ret = CardServices(GetTupleData, handle, &tuple, NULL);
- if (ret != CS_SUCCESS) goto done;
- ret = CardServices(ParseTuple, handle, &tuple, parse);
-done:
- kfree(buf);
- return ret;
-}
-
-/*======================================================================
-
- This tries to determine if a card has a sensible CIS. It returns
- the number of tuples in the CIS, or 0 if the CIS looks bad. The
- checks include making sure several critical tuples are present and
- valid; seeing if the total number of tuples is reasonable; and
- looking for tuples that use reserved codes.
-
-======================================================================*/
-
-int validate_cis(client_handle_t handle, cisinfo_t *info)
-{
- tuple_t tuple;
- cisparse_t *p;
- int ret, reserved, dev_ok = 0, ident_ok = 0;
-
- if (CHECK_HANDLE(handle))
- return CS_BAD_HANDLE;
- p = kmalloc(sizeof(*p), GFP_KERNEL);
- if (p == NULL)
- return CS_OUT_OF_RESOURCE;
-
- info->Chains = reserved = 0;
- tuple.DesiredTuple = RETURN_FIRST_TUPLE;
- tuple.Attributes = TUPLE_RETURN_COMMON;
- ret = get_first_tuple(handle, &tuple);
- if (ret != CS_SUCCESS)
- goto done;
-
- /* First tuple should be DEVICE; we should really have either that
- or a CFTABLE_ENTRY of some sort */
- if ((tuple.TupleCode == CISTPL_DEVICE) ||
- (read_tuple(handle, CISTPL_CFTABLE_ENTRY, p) == CS_SUCCESS) ||
- (read_tuple(handle, CISTPL_CFTABLE_ENTRY_CB, p) == CS_SUCCESS))
- dev_ok++;
-
- /* All cards should have a MANFID tuple, and/or a VERS_1 or VERS_2
- tuple, for card identification. Certain old D-Link and Linksys
- cards have only a broken VERS_2 tuple; hence the bogus test. */
- if ((read_tuple(handle, CISTPL_MANFID, p) == CS_SUCCESS) ||
- (read_tuple(handle, CISTPL_VERS_1, p) == CS_SUCCESS) ||
- (read_tuple(handle, CISTPL_VERS_2, p) != CS_NO_MORE_ITEMS))
- ident_ok++;
-
- if (!dev_ok && !ident_ok)
- goto done;
-
- for (info->Chains = 1; info->Chains < MAX_TUPLES; info->Chains++) {
- ret = get_next_tuple(handle, &tuple);
- if (ret != CS_SUCCESS) break;
- if (((tuple.TupleCode > 0x23) && (tuple.TupleCode < 0x40)) ||
- ((tuple.TupleCode > 0x47) && (tuple.TupleCode < 0x80)) ||
- ((tuple.TupleCode > 0x90) && (tuple.TupleCode < 0xff)))
- reserved++;
- }
- if ((info->Chains == MAX_TUPLES) || (reserved > 5) ||
- ((!dev_ok || !ident_ok) && (info->Chains > 10)))
- info->Chains = 0;
-
-done:
- kfree(p);
- return CS_SUCCESS;
-}
-
diff --git a/dump_cis.c b/dump_cis.c
index aa5cd9f..5c8fa0b 100644
--- a/dump_cis.c
+++ b/dump_cis.c
@@ -50,54 +50,7 @@
static int verbose = 0;
static char indent[10] = " ";
-/*====================================================================*/
-
-static int major = 0;
-
-static int lookup_dev(char *name)
-{
- FILE *f;
- int n;
- char s[32], t[32];
-
- f = fopen("/proc/devices", "r");
- if (f == NULL)
- return -1;
- while (fgets(s, 32, f) != NULL) {
- if (sscanf(s, "%d %s", &n, t) == 2)
- if (strcmp(name, t) == 0)
- break;
- }
- fclose(f);
- if (strcmp(name, t) == 0)
- return n;
- else
- return -1;
-}
-
-/*====================================================================*/
-
-static int open_sock(int sock)
-{
- static char *paths[] = {
- "/var/lib/pcmcia", "/var/run", "/dev", "/tmp", NULL
- };
- int fd;
- char **p, fn[64];
- dev_t dev = (major<<8) + sock;
-
- for (p = paths; *p; p++) {
- sprintf(fn, "%s/dc%d", *p, getpid());
- if (mknod(fn, (S_IFCHR|S_IREAD|S_IWRITE), dev) == 0) {
- fd = open(fn, O_RDONLY);
- unlink(fn);
- if (fd >= 0)
- return fd;
- if (errno == ENODEV) break;
- }
- }
- return -1;
-} /* open_sock */
+extern int parse_tuple(tuple_t *tup, cisparse_t *parse);
/*====================================================================*/
@@ -985,40 +938,18 @@
return 0;
}
-static int get_tuple(int fd, ds_ioctl_arg_t *arg, int first)
-{
- int cmd = (first) ? DS_GET_FIRST_TUPLE : DS_GET_NEXT_TUPLE;
- if (ioctl(fd, cmd, arg) != 0) {
- if (errno == ENODEV)
- printf("%sno card\n", indent);
- else if (errno != ENODATA)
- printf("%sget tuple: %s\n", indent, strerror(errno));
- return -1;
- }
- if (ioctl(fd, DS_GET_TUPLE_DATA, arg) != 0) {
- printf("%sget tuple data: %s\n", indent, strerror(errno));
- return -1;
- }
- return 0;
-}
-
/*====================================================================*/
-#define MAX_SOCKS 8
-
int main(int argc, char *argv[])
{
- int i, fd, pfd = -1;
+ int fd;
ds_ioctl_arg_t arg;
int optch, errflg, first;
- int force = 0;
char *infile = NULL;
errflg = 0;
while ((optch = getopt(argc, argv, "fvi:")) != -1) {
switch (optch) {
- case 'f':
- force = 1; break;
case 'v':
verbose = 1; break;
case 'i':
@@ -1027,76 +958,39 @@
errflg = 1; break;
}
}
- if (errflg || (optind < argc)) {
- fprintf(stderr, "usage: %s [-v] [-f] [-i infile]\n", argv[0]);
+ if (errflg || !infile || (optind < argc)) {
+ fprintf(stderr, "usage: %s [-v] -i infile\n", argv[0]);
exit(EXIT_FAILURE);
}
- major = lookup_dev("pcmcia");
- if (major < 0) {
- fprintf(stderr, "no pcmcia driver in /proc/devices\n");
- exit(EXIT_FAILURE);
- }
-
- for (i = 0; (i < MAX_SOCKS) && !(i && infile); i++) {
- nfn = cur = 0;
- if (infile) {
- indent[0] = '\0';
- fd = open(infile, O_RDONLY);
- if (fd < 0) {
- perror("open()");
- return -1;
- }
- pfd = open_sock(0);
- } else {
- strcpy(indent, " ");
- fd = pfd = open_sock(i);
- }
- if (pfd < 0)
- break;
- if (!verbose && (i > 0)) putchar('\n');
- if (!infile) printf("Socket %d:\n", i);
-
- if (!force && !infile) {
- if (ioctl(fd, DS_VALIDATE_CIS, &arg) != 0) {
- printf("%svalidate CIS: %s\n", indent, strerror(errno));
- continue;
- }
- if (arg.cisinfo.Chains == 0) {
- printf("%sno CIS present\n", indent);
- continue;
- }
- }
-
- arg.tuple.TupleDataMax = sizeof(arg.tuple_parse.data);
- arg.tuple.Attributes = TUPLE_RETURN_LINK | TUPLE_RETURN_COMMON;
- arg.tuple.DesiredTuple = RETURN_FIRST_TUPLE;
- arg.tuple.TupleOffset = 0;
-
- for (first = 1; ; first = 0) {
- if (infile) {
- if (get_tuple_buf(fd, &arg, first) != 0) break;
- } else {
- if (get_tuple(fd, &arg, first) != 0) break;
- }
- if (verbose) print_tuple(&arg.tuple_parse);
- if (ioctl(pfd, DS_PARSE_TUPLE, &arg) == 0)
- print_parse(&arg.tuple_parse);
- else if (errno != ENOSYS)
- printf("%sparse error: %s\n", indent,
- strerror(errno));
- if (verbose) putchar('\n');
- if (arg.tuple.TupleCode == CISTPL_END)
- break;
- }
-
- if (!verbose && (nfn > 0))
- printf("%s}\n", indent+2);
- }
- if ((i == 0) && (pfd < 0)) {
+ nfn = cur = 0;
+ indent[0] = '\0';
+ fd = open(infile, O_RDONLY);
+ if (fd < 0) {
perror("open()");
return -1;
}
-
+
+ arg.tuple.TupleDataMax = sizeof(arg.tuple_parse.data);
+ arg.tuple.Attributes = TUPLE_RETURN_LINK | TUPLE_RETURN_COMMON;
+ arg.tuple.DesiredTuple = RETURN_FIRST_TUPLE;
+ arg.tuple.TupleOffset = 0;
+ arg.tuple.TupleData = arg.tuple_parse.data;
+
+ for (first = 1; ; first = 0) {
+ if (get_tuple_buf(fd, &arg, first) != 0) break;
+ if (verbose) print_tuple(&arg.tuple_parse);
+ if (parse_tuple(&arg.tuple_parse.tuple, &arg.tuple_parse.parse) == 0)
+ print_parse(&arg.tuple_parse);
+ else
+ printf("%sparse error\n", indent);
+ if (verbose) putchar('\n');
+ if (arg.tuple.TupleCode == CISTPL_END)
+ break;
+ }
+
+ if (!verbose && (nfn > 0))
+ printf("%s}\n", indent+2);
+
return 0;
}
diff --git a/pcmcia/bulkmem.h b/pcmcia/bulkmem.h
index 7748d44..fa05e69 100644
--- a/pcmcia/bulkmem.h
+++ b/pcmcia/bulkmem.h
@@ -1,8 +1,6 @@
/*
* Definitions for bulk memory services
*
- * bulkmem.h 1.13 2001/08/24 12:16:12
- *
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License
@@ -27,7 +25,6 @@
* other provisions required by the GPL. If you do not delete the
* provisions above, a recipient may use your version of this file
* under either the MPL or the GPL.
- * bulkmem.h 1.3 1995/05/27 04:49:49
*/
#ifndef _LINUX_BULKMEM_H
@@ -186,10 +183,4 @@
MTDSetVpp, MTDRDYMask
};
-#ifdef IN_CARD_SERVICES
-extern int MTDHelperEntry(int func, void *a1, void *a2);
-#else
-extern int MTDHelperEntry(int func, ...);
-#endif
-
#endif /* _LINUX_BULKMEM_H */
diff --git a/pcmcia/ds.h b/pcmcia/ds.h
index b372e59..61336fa 100644
--- a/pcmcia/ds.h
+++ b/pcmcia/ds.h
@@ -1,6 +1,4 @@
/*
- * ds.h 1.58 2001/10/04 03:15:22
- *
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License
@@ -30,7 +28,6 @@
#ifndef _LINUX_DS_H
#define _LINUX_DS_H
-#include <pcmcia/driver_ops.h>
#include <pcmcia/bulkmem.h>
typedef struct tuple_parse_t {
@@ -77,72 +74,4 @@
cisdump_t cisdump;
} ds_ioctl_arg_t;
-#define DS_GET_CARD_SERVICES_INFO _IOR ('d', 1, servinfo_t)
-#define DS_ADJUST_RESOURCE_INFO _IOWR('d', 2, adjust_t)
-#define DS_GET_CONFIGURATION_INFO _IOWR('d', 3, config_info_t)
-#define DS_GET_FIRST_TUPLE _IOWR('d', 4, tuple_t)
-#define DS_GET_NEXT_TUPLE _IOWR('d', 5, tuple_t)
-#define DS_GET_TUPLE_DATA _IOWR('d', 6, tuple_parse_t)
-#define DS_PARSE_TUPLE _IOWR('d', 7, tuple_parse_t)
-#define DS_RESET_CARD _IO ('d', 8)
-#define DS_GET_STATUS _IOWR('d', 9, cs_status_t)
-#define DS_ACCESS_CONFIGURATION_REGISTER _IOWR('d', 10, conf_reg_t)
-#define DS_VALIDATE_CIS _IOR ('d', 11, cisinfo_t)
-#define DS_SUSPEND_CARD _IO ('d', 12)
-#define DS_RESUME_CARD _IO ('d', 13)
-#define DS_EJECT_CARD _IO ('d', 14)
-#define DS_INSERT_CARD _IO ('d', 15)
-#define DS_GET_FIRST_REGION _IOWR('d', 16, region_info_t)
-#define DS_GET_NEXT_REGION _IOWR('d', 17, region_info_t)
-#define DS_REPLACE_CIS _IOWR('d', 18, cisdump_t)
-#define DS_GET_FIRST_WINDOW _IOR ('d', 19, win_info_t)
-#define DS_GET_NEXT_WINDOW _IOWR('d', 20, win_info_t)
-#define DS_GET_MEM_PAGE _IOWR('d', 21, win_info_t)
-
-#define DS_BIND_REQUEST _IOWR('d', 60, bind_info_t)
-#define DS_GET_DEVICE_INFO _IOWR('d', 61, bind_info_t)
-#define DS_GET_NEXT_DEVICE _IOWR('d', 62, bind_info_t)
-#define DS_UNBIND_REQUEST _IOW ('d', 63, bind_info_t)
-#define DS_BIND_MTD _IOWR('d', 64, mtd_info_t)
-
-#ifdef __KERNEL__
-
-typedef struct dev_link_t {
- dev_node_t *dev;
- u_int state, open;
- wait_queue_head_t pending;
- struct timer_list release;
- client_handle_t handle;
- io_req_t io;
- irq_req_t irq;
- config_req_t conf;
- window_handle_t win;
- void *priv;
- struct dev_link_t *next;
-} dev_link_t;
-
-/* Flags for device state */
-#define DEV_PRESENT 0x01
-#define DEV_CONFIG 0x02
-#define DEV_STALE_CONFIG 0x04 /* release on close */
-#define DEV_STALE_LINK 0x08 /* detach on release */
-#define DEV_CONFIG_PENDING 0x10
-#define DEV_RELEASE_PENDING 0x20
-#define DEV_SUSPEND 0x40
-#define DEV_BUSY 0x80
-
-#define DEV_OK(l) \
- ((l) && ((l->state & ~DEV_BUSY) == (DEV_CONFIG|DEV_PRESENT)))
-
-int register_pccard_driver(dev_info_t *dev_info,
- dev_link_t *(*attach)(void),
- void (*detach)(dev_link_t *));
-
-int unregister_pccard_driver(dev_info_t *dev_info);
-
-#define register_pcmcia_driver register_pccard_driver
-#define unregister_pcmcia_driver unregister_pccard_driver
-
-#endif /* __KERNEL__ */
-
#endif /* _LINUX_DS_H */
