/*
 * cistpl.c -- 16-bit PCMCIA Card Information Structure parser
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * The initial developer of the original code is David A. Hinds
 * <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
 * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
 *
 * (C) 1999		David A. Hinds
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include "../src/cistpl.h"

#define MAX_SOCKETS 8

static int verbose = 1;

static void print_tuple(tuple_t *tup)
{
	int i;
	printf("offset 0x%2.2x, tuple 0x%2.2x, link 0x%2.2x\n",
	       tup->CISOffset, tup->TupleCode,
	       tup->TupleLink);
	for (i = 0; i < tup->TupleDataLen; i++) {
		if (!(i % 16))
			printf("  ");
		printf("%2.2x ", (unsigned char) tup->TupleData[i]);
		if ((i % 16) == 15)
			printf("\n");
	}
	if ((i % 16) != 0)
		putchar('\n');
}

#define IRQ_INFO2_VALID       0x10
#define IRQ_MASK              0x0f
#define IRQ_LEVEL_ID          0x20
#define IRQ_PULSE_ID          0x40
#define IRQ_SHARE_ID          0x80

static void print_funcid(cistpl_funcid_t *fn)
{
	printf("funcid ");
	switch (fn->func) {
	case CISTPL_FUNCID_MULTI:
		printf("multi_function");
		break;
	case CISTPL_FUNCID_MEMORY:
		printf("memory_card");
		break;
	case CISTPL_FUNCID_SERIAL:
		printf("serial_port");
		break;
	case CISTPL_FUNCID_PARALLEL:
		printf("parallel_port");
		break;
	case CISTPL_FUNCID_FIXED:
		printf("fixed_disk");
		break;
	case CISTPL_FUNCID_VIDEO:
		printf("video_adapter");
		break;
	case CISTPL_FUNCID_NETWORK:
		printf("network_adapter");
		break;
	case CISTPL_FUNCID_AIMS:
		printf("aims_card");
		break;
	case CISTPL_FUNCID_SCSI:
		printf("scsi_adapter");
		break;
	default:
		printf("unknown");
		break;
	}
	if (fn->sysinit & CISTPL_SYSINIT_POST)
		printf(" [post]");
	if (fn->sysinit & CISTPL_SYSINIT_ROM)
		printf(" [rom]");
	putchar('\n');
}

/*====================================================================*/

static void print_size(u_int size)
{
	if (size < 1024)
		printf("%ub", size);
	else if (size < 1024*1024)
		printf("%ukb", size/1024);
	else
		printf("%umb", size/(1024*1024));
}

static void print_unit(u_int v, char *unit, char tag)
{
	unsigned int n;
	for (n = 0; (v % 1000) == 0; n++)
		v /= 1000;
	printf("%u", v);
	if (n < strlen(unit))
		putchar(unit[n]);
	putchar(tag);
}

static void print_time(u_int tm, u_long scale)
{
	print_unit(tm * scale, "num", 's');
}

static void print_volt(u_int vi)
{
	print_unit(vi * 10, "um", 'V');
}

static void print_current(u_int ii)
{
	print_unit(ii / 10, "um", 'A');
}

static void print_speed(u_int b)
{
	if (b < 1000)
		printf("%u bits/sec", b);
	else if (b < 1000000)
		printf("%u kb/sec", b/1000);
	else
		printf("%u mb/sec", b/1000000);
}

/*====================================================================*/

static const char *dtype[] = {
	"NULL", "ROM", "OTPROM", "EPROM", "EEPROM", "FLASH", "SRAM",
	"DRAM", "rsvd", "rsvd", "rsvd", "rsvd", "rsvd", "fn_specific",
	"extended", "rsvd"
};

static void print_device(cistpl_device_t *dev)
{
	int i;
	for (i = 0; i < dev->ndev; i++) {
		printf("  %s ", dtype[dev->dev[i].type]);
		printf("%uns, ", dev->dev[i].speed);
		print_size(dev->dev[i].size);
		putchar('\n');
	}
	if (dev->ndev == 0)
		printf("  no_info\n");
}


static void print_power(char *tag, cistpl_power_t *power)
{
	int i, n;
	for (i = n = 0; i < 8; i++)
		if (power->present & (1<<i))
			n++;
	i = 0;
	printf("  %s", tag);
	if (power->present & (1<<CISTPL_POWER_VNOM)) {
		printf(" Vnom "); i++;
		print_volt(power->param[CISTPL_POWER_VNOM]);
	}
	if (power->present & (1<<CISTPL_POWER_VMIN)) {
		printf(" Vmin "); i++;
		print_volt(power->param[CISTPL_POWER_VMIN]);
	}
	if (power->present & (1<<CISTPL_POWER_VMAX)) {
		printf(" Vmax "); i++;
		print_volt(power->param[CISTPL_POWER_VMAX]);
	}
	if (power->present & (1<<CISTPL_POWER_ISTATIC)) {
		printf(" Istatic "); i++;
		print_current(power->param[CISTPL_POWER_ISTATIC]);
	}
	if (power->present & (1<<CISTPL_POWER_IAVG)) {
		if (++i == 5)
			printf("\n");
		printf(" Iavg ");
		print_current(power->param[CISTPL_POWER_IAVG]);
	}
	if (power->present & (1<<CISTPL_POWER_IPEAK)) {
		if (++i == 5)
			printf("\n");
		printf(" Ipeak ");
		print_current(power->param[CISTPL_POWER_IPEAK]);
	}
	if (power->present & (1<<CISTPL_POWER_IDOWN)) {
		if (++i == 5)
			printf("\n");
		printf(" Idown ");
		print_current(power->param[CISTPL_POWER_IDOWN]);
	}
	if (power->flags & CISTPL_POWER_HIGHZ_OK) {
		if (++i == 5)
			printf("\n");
		printf(" [highz OK]");
	}
	if (power->flags & CISTPL_POWER_HIGHZ_REQ) {
		printf(" [highz]");
	}
	putchar('\n');
}

/*====================================================================*/

static void print_cftable_entry(cistpl_cftable_entry_t *entry)
{
	int i;

	printf("cftable_entry 0x%2.2x%s\n", entry->index,
	       (entry->flags & CISTPL_CFTABLE_DEFAULT) ? " [default]" : "");

	if (entry->flags & ~CISTPL_CFTABLE_DEFAULT) {
		if (entry->flags & CISTPL_CFTABLE_BVDS)
			printf(" [bvd]");
		if (entry->flags & CISTPL_CFTABLE_WP)
			printf(" [wp]");
		if (entry->flags & CISTPL_CFTABLE_RDYBSY)
			printf(" [rdybsy]");
		if (entry->flags & CISTPL_CFTABLE_MWAIT)
			printf(" [mwait]");
		if (entry->flags & CISTPL_CFTABLE_AUDIO)
			printf(" [audio]");
		if (entry->flags & CISTPL_CFTABLE_READONLY)
			printf(" [readonly]");
		if (entry->flags & CISTPL_CFTABLE_PWRDOWN)
			printf(" [pwrdown]");
		putchar('\n');
	}

	if (entry->vcc.present)
		print_power("Vcc", &entry->vcc);
	if (entry->vpp1.present)
		print_power("Vpp1", &entry->vpp1);
	if (entry->vpp2.present)
		print_power("Vpp2", &entry->vpp2);

	if ((entry->timing.wait != 0) || (entry->timing.ready != 0) ||
	    (entry->timing.reserved != 0)) {
		printf("  timing");
		if (entry->timing.wait != 0) {
			printf(" wait ");
			print_time(entry->timing.wait, entry->timing.waitscale);
		}
		if (entry->timing.ready != 0) {
			printf(" ready ");
			print_time(entry->timing.ready, entry->timing.rdyscale);
		}
		if (entry->timing.reserved != 0) {
			printf(" reserved ");
			print_time(entry->timing.reserved, entry->timing.rsvscale);
		}
		putchar('\n');
	}

	if (entry->io.nwin) {
		cistpl_io_t *io = &entry->io;
		printf("  io");
		for (i = 0; i < io->nwin; i++) {
			if (i)
				putchar(',');
			printf(" 0x%4.4x-0x%4.4x", io->win[i].base,
			       io->win[i].base+io->win[i].len-1);
		}
		printf(" [lines=%d]", io->flags & CISTPL_IO_LINES_MASK);
		if (io->flags & CISTPL_IO_8BIT)
			printf(" [8bit]");
		if (io->flags & CISTPL_IO_16BIT)
			printf(" [16bit]");
		if (io->flags & CISTPL_IO_RANGE)
			printf(" [range]");
		putchar('\n');
	}

	if (entry->irq.IRQInfo1) {
		printf("  irq ");
		if (entry->irq.IRQInfo1 & IRQ_INFO2_VALID)
			printf("mask 0x%04x", entry->irq.IRQInfo2);
		else
			printf("%u", entry->irq.IRQInfo1 & IRQ_MASK);
		if (entry->irq.IRQInfo1 & IRQ_LEVEL_ID)
			printf(" [level]");
		if (entry->irq.IRQInfo1 & IRQ_PULSE_ID)
			printf(" [pulse]");
		if (entry->irq.IRQInfo1 & IRQ_SHARE_ID)
			printf(" [shared]");
		putchar('\n');
	}

	if (entry->mem.nwin) {
		cistpl_mem_t *mem = &entry->mem;
		printf("  memory");
		for (i = 0; i < mem->nwin; i++) {
			if (i)
				putchar(',');
			printf(" 0x%4.4x-0x%4.4x @ 0x%4.4x",
			       mem->win[i].card_addr,
			       mem->win[i].card_addr + mem->win[i].len-1,
			       mem->win[i].host_addr);
		}
		putchar('\n');
	}

	if (verbose && entry->subtuples)
		printf("  %d bytes in subtuples\n", entry->subtuples);
}

/*====================================================================*/

static void print_cftable_entry_cb(cistpl_cftable_entry_cb_t *entry)
{
	int i;

	printf("cftable_entry_cb 0x%2.2x%s\n", entry->index,
	       (entry->flags & CISTPL_CFTABLE_DEFAULT) ? " [default]" : "");

	if (entry->flags & ~CISTPL_CFTABLE_DEFAULT) {
		printf(" ");
		if (entry->flags & CISTPL_CFTABLE_MASTER)
			printf(" [master]");
		if (entry->flags & CISTPL_CFTABLE_INVALIDATE)
			printf(" [invalidate]");
		if (entry->flags & CISTPL_CFTABLE_VGA_PALETTE)
			printf(" [vga palette]");
		if (entry->flags & CISTPL_CFTABLE_PARITY)
			printf(" [parity]");
		if (entry->flags & CISTPL_CFTABLE_WAIT)
			printf(" [wait]");
		if (entry->flags & CISTPL_CFTABLE_SERR)
			printf(" [serr]");
		if (entry->flags & CISTPL_CFTABLE_FAST_BACK)
			printf(" [fast back]");
		if (entry->flags & CISTPL_CFTABLE_BINARY_AUDIO)
			printf(" [binary audio]");
		if (entry->flags & CISTPL_CFTABLE_PWM_AUDIO)
			printf(" [pwm audio]");
		putchar('\n');
	}

	if (entry->vcc.present)
		print_power("Vcc", &entry->vcc);
	if (entry->vpp1.present)
		print_power("Vpp1", &entry->vpp1);
	if (entry->vpp2.present)
		print_power("Vpp2", &entry->vpp2);

	if (entry->io) {
		printf("  io_base");
		for (i = 0; i < 8; i++)
			if (entry->io & (1<<i)) printf(" %d", i);
		putchar('\n');
	}

	if (entry->irq.IRQInfo1) {
		printf("  irq ");
		if (entry->irq.IRQInfo1 & IRQ_INFO2_VALID)
			printf("mask 0x%4.4x", entry->irq.IRQInfo2);
		else
			printf("%u", entry->irq.IRQInfo1 & IRQ_MASK);
		if (entry->irq.IRQInfo1 & IRQ_LEVEL_ID)
			printf(" [level]");
		if (entry->irq.IRQInfo1 & IRQ_PULSE_ID)
			printf(" [pulse]");
		if (entry->irq.IRQInfo1 & IRQ_SHARE_ID)
			printf(" [shared]");
		putchar('\n');
	}

	if (entry->mem) {
		printf("  mem_base");
		for (i = 0; i < 8; i++)
			if (entry->mem & (1<<i))
				printf(" %d", i);
		putchar('\n');
	}

	if (verbose && entry->subtuples)
		printf("  %d bytes in subtuples\n", entry->subtuples);
}

/*====================================================================*/

static void print_jedec(cistpl_jedec_t *j)
{
	int i;
	for (i = 0; i < j->nid; i++) {
		if (i != 0)
			putchar(',');
		printf(" 0x%02x 0x%02x", j->id[i].mfr, j->id[i].info);
	}
	putchar('\n');
}

/*====================================================================*/

static void print_device_geo(cistpl_device_geo_t *geo)
{
	int i;
	for (i = 0; i < geo->ngeo; i++) {
		printf("  width %d erase 0x%x read 0x%x write 0x%x "
		       "partition 0x%x interleave 0x%x\n",
		       geo->geo[i].buswidth, geo->geo[i].erase_block,
		       geo->geo[i].read_block, geo->geo[i].write_block,
		       geo->geo[i].partition, geo->geo[i].interleave);
	}
}

/*====================================================================*/

static void print_org(cistpl_org_t *org)
{
	printf("data_org ");
	switch (org->data_org) {
	case CISTPL_ORG_FS:
		printf("[filesystem]");
		break;
	case CISTPL_ORG_APPSPEC:
		printf("[app_specific]");
		break;
	case CISTPL_ORG_XIP:
		printf("[code]"); break;
	default:
		if (org->data_org < 0x80)
			printf("[reserved]");
		else
			printf("[vendor_specific]");
	}
	printf(", \"%s\"\n", org->desc);
}


static char *data_mod[] = {
	"Bell103", "V.21", "V.23", "V.22", "Bell212A", "V.22bis",
	"V.26", "V.26bis", "V.27bis", "V.29", "V.32", "V.32bis",
	"V.34", "rfu", "rfu", "rfu"
};
static char *fax_mod[] = {
	"V.21-C2", "V.27ter", "V.29", "V.17", "V.33", "rfu", "rfu", "rfu"
};
static char *fax_features[] = {
	"T.3", "T.4", "T.6", "error", "voice", "poll", "file", "passwd"
};
static char *cmd_protocol[] = {
	"AT1", "AT2", "AT3", "MNP_AT", "V.25bis", "V.25A", "DMCL"
};
static char *uart[] = {
	"8250", "16450", "16550", "8251", "8530", "85230"
};
static char *parity[] = { "space", "mark", "odd", "even" };
static char *stop[] = { "1", "1.5", "2" };
static char *flow[] = {
	"XON/XOFF xmit", "XON/XOFF rcv", "hw xmit", "hw rcv", "transparent"
};
static void print_serial(cistpl_funce_t *funce)
{
	cistpl_serial_t *s;
	cistpl_data_serv_t *ds;
	cistpl_fax_serv_t *fs;
	cistpl_modem_cap_t *cp;
	int i, j;

	switch (funce->type & 0x0f) {
	case CISTPL_FUNCE_SERIAL_IF:
	case CISTPL_FUNCE_SERIAL_IF_DATA:
	case CISTPL_FUNCE_SERIAL_IF_FAX:
	case CISTPL_FUNCE_SERIAL_IF_VOICE:
		s = (cistpl_serial_t *)(funce->data);
		printf("serial_interface");
		if ((funce->type & 0x0f) == CISTPL_FUNCE_SERIAL_IF_DATA)
			printf("_data");
		else if ((funce->type & 0x0f) == CISTPL_FUNCE_SERIAL_IF_FAX)
			printf("_fax");
		else if ((funce->type & 0x0f) == CISTPL_FUNCE_SERIAL_IF_VOICE)
			printf("_voice");
		printf("\n  uart %s",
		       (s->uart_type < 6) ? uart[s->uart_type] : "reserved");
		if (s->uart_cap_0) {
			printf(" [");
			for (i = 0; i < 4; i++)
				if (s->uart_cap_0 & (1<<i))
					printf("%s%s", parity[i],
					       (s->uart_cap_0 >= (2<<i)) ? "/" : "]");
		}
		if (s->uart_cap_1) {
			int m = s->uart_cap_1 & 0x0f;
			int n = s->uart_cap_1 >> 4;
			printf(" [");
			for (i = 0; i < 4; i++)
				if (m & (1<<i))
					printf("%d%s", i+5, (m >= (2<<i)) ? "/" : "");
			printf("] [");
			for (i = 0; i < 3; i++)
				if (n & (1<<i))
					printf("%s%s", stop[i], (n >= (2<<i)) ? "/" : "]");
		}
		printf("\n");
		break;
	case CISTPL_FUNCE_SERIAL_CAP:
	case CISTPL_FUNCE_SERIAL_CAP_DATA:
	case CISTPL_FUNCE_SERIAL_CAP_FAX:
	case CISTPL_FUNCE_SERIAL_CAP_VOICE:
		cp = (cistpl_modem_cap_t *)(funce->data);
		printf("serial_modem_cap");
		if ((funce->type & 0x0f) == CISTPL_FUNCE_SERIAL_CAP_DATA)
			printf("_data");
		else if ((funce->type & 0x0f) == CISTPL_FUNCE_SERIAL_CAP_FAX)
			printf("_fax");
		else if ((funce->type & 0x0f) == CISTPL_FUNCE_SERIAL_CAP_VOICE)
			printf("_voice");
		if (cp->flow) {
			printf("\n  flow");
			for (i = 0; i < 5; i++)
				if (cp->flow & (1<<i))
					printf(" [%s]", flow[i]);
		}
		printf("\n  cmd_buf %d rcv_buf %d xmit_buf %d\n",
		       4*(cp->cmd_buf+1),
		       cp->rcv_buf_0+(cp->rcv_buf_1<<8)+(cp->rcv_buf_2<<16),
		       cp->xmit_buf_0+(cp->xmit_buf_1<<8)+(cp->xmit_buf_2<<16));
		break;
	case CISTPL_FUNCE_SERIAL_SERV_DATA:
		ds = (cistpl_data_serv_t *)(funce->data);
		printf("serial_data_services\n");
		printf("  data_rate %d\n",
		       75*((ds->max_data_0<<8) + ds->max_data_1));
		printf("  modulation");
		for (i = j = 0; i < 16; i++)
			if (((ds->modulation_1<<8) + ds->modulation_0) & (1<<i)) {
				if (++j % 6 == 0)
					printf("\n   ");
				printf(" [%s]", data_mod[i]);
			}
		printf("\n");
		if (ds->error_control) {
			printf("  error_control");
			if (ds->error_control & CISTPL_SERIAL_ERR_MNP2_4)
				printf(" [MNP2-4]");
			if (ds->error_control & CISTPL_SERIAL_ERR_V42_LAPM)
				printf(" [V.42/LAPM]");
			printf("\n");
	}
		if (ds->compression) {
			printf("  compression");
			if (ds->compression & CISTPL_SERIAL_CMPR_V42BIS)
				printf(" [V.42bis]");
			if (ds->compression & CISTPL_SERIAL_CMPR_MNP5)
				printf(" [MNP5]");
			printf("\n");
		}
		if (ds->cmd_protocol) {
			printf("  cmd_protocol");
			for (i = 0; i < 7; i++)
				if (ds->cmd_protocol & (1<<i))
					printf(" [%s]", cmd_protocol[i]);
			printf("\n");
		}
		break;

	case CISTPL_FUNCE_SERIAL_SERV_FAX:
		fs = (cistpl_fax_serv_t *)(funce->data);
		printf("serial_fax_services [class=%d]\n",
		       funce->type>>4);
		printf("  data_rate %d\n",
		       75*((fs->max_data_0<<8) + fs->max_data_1));
		printf("  modulation");
		for (i = 0; i < 8; i++)
			if (fs->modulation & (1<<i))
				printf(" [%s]", fax_mod[i]);
		printf("\n");
		if (fs->features_0) {
			printf("  features");
			for (i = 0; i < 8; i++)
				if (fs->features_0 & (1<<i))
					printf(" [%s]", fax_features[i]);
			printf("\n");
		}
		break;
	}
}

/*====================================================================*/

static void print_fixed(cistpl_funce_t *funce)
{
	cistpl_ide_interface_t *i;
	cistpl_ide_feature_t *f;

	switch (funce->type) {
	case CISTPL_FUNCE_IDE_IFACE:
		i = (cistpl_ide_interface_t *)(funce->data);
		printf("disk_interface ");
		if (i->interface == CISTPL_IDE_INTERFACE)
			printf("[ide]\n");
		else
			printf("[undefined]\n");
		break;
	case CISTPL_FUNCE_IDE_MASTER:
	case CISTPL_FUNCE_IDE_SLAVE:
		f = (cistpl_ide_feature_t *)(funce->data);
		printf("disk_features");
		if (f->feature1 & CISTPL_IDE_SILICON)
			printf(" [silicon]");
		else
			printf(" [rotating]");
		if (f->feature1 & CISTPL_IDE_UNIQUE)
			printf(" [unique]");
		if (f->feature1 & CISTPL_IDE_DUAL)
			printf(" [dual]");
		else
			printf(" [single]");
		if (f->feature1 && f->feature2)
			printf("\n ");
		if (f->feature2 & CISTPL_IDE_HAS_SLEEP)
			printf(" [sleep]");
		if (f->feature2 & CISTPL_IDE_HAS_STANDBY)
			printf(" [standby]");
		if (f->feature2 & CISTPL_IDE_HAS_IDLE)
			printf(" [idle]");
		if (f->feature2 & CISTPL_IDE_LOW_POWER)
			printf(" [low power]");
		if (f->feature2 & CISTPL_IDE_REG_INHIBIT)
			printf(" [reg inhibit]");
		if (f->feature2 & CISTPL_IDE_HAS_INDEX)
			printf(" [index]");
		if (f->feature2 & CISTPL_IDE_IOIS16)
			printf(" [iois16]");
		putchar('\n');
		break;
	}
}

static const char *tech[] = {
	"undefined", "ARCnet", "ethernet", "token_ring", "localtalk",
	"FDDI/CDDI", "ATM", "wireless"
};

static const char *media[] = {
	"undefined", "unshielded_twisted_pair", "shielded_twisted_pair",
	"thin_coax", "thick_coax", "fiber", "900_MHz", "2.4_GHz",
	"5.4_GHz", "diffuse_infrared", "point_to_point_infrared"
};

static void print_network(cistpl_funce_t *funce)
{
	cistpl_lan_tech_t *t;
	cistpl_lan_speed_t *s;
	cistpl_lan_media_t *m;
	cistpl_lan_node_id_t *n;
	cistpl_lan_connector_t *c;
	int i;

	switch (funce->type) {
	case CISTPL_FUNCE_LAN_TECH:
		t = (cistpl_lan_tech_t *)(funce->data);
		printf("lan_technology %s\n", tech[t->tech]);
		break;
	case CISTPL_FUNCE_LAN_SPEED:
		s = (cistpl_lan_speed_t *)(funce->data);
		printf("lan_speed ");
		print_speed(s->speed);
		putchar('\n');
		break;
	case CISTPL_FUNCE_LAN_MEDIA:
		m = (cistpl_lan_media_t *)(funce->data);
		printf("lan_media %s\n", media[m->media]);
		break;
	case CISTPL_FUNCE_LAN_NODE_ID:
		n = (cistpl_lan_node_id_t *)(funce->data);
		printf("lan_node_id");
		for (i = 0; i < n->nb; i++)
			printf(" %02x", n->id[i]);
		putchar('\n');
		break;
	case CISTPL_FUNCE_LAN_CONNECTOR:
		c = (cistpl_lan_connector_t *)(funce->data);
		printf("lan_connector ");
		if (c->code == 0)
			printf("Open connector standard\n");
		else
			printf("Closed connector standard\n");
		break;
	}
}


static void print_vers_1(cistpl_vers_1_t *v1)
{
	int i, n;
	char s[32];
	sprintf(s, "vers_1 %d.%d", v1->major, v1->minor);
	printf("%s", s);
	n = strlen(s);
	for (i = 0; i < v1->ns; i++) {
		if (n + strlen(v1->str + v1->ofs[i]) + 4 > 72) {
			n += 2;
			printf(",\n  ");
		} else {
			printf(", ");
			n += 2;
		}
		printf("\"%s\"", v1->str + v1->ofs[i]);
		n += strlen(v1->str + v1->ofs[i]) + 2;
	}
	putchar('\n');
}


static void print_vers_2(cistpl_vers_2_t *v2)
{
	printf("version 0x%2.2x, compliance 0x%2.2x, dindex 0x%4.4x\n",
	       v2->vers, v2->comply, v2->dindex);
	printf("  vspec8 0x%2.2x, vspec9 0x%2.2x, nhdr %d\n",
	       v2->vspec8, v2->vspec9, v2->nhdr);
	printf("  vendor \"%s\"\n", v2->str+v2->vendor);
	printf("  info \"%s\"\n", v2->str+v2->info);
}


static void print_format(cistpl_format_t *fmt)
{
	if (fmt->type == CISTPL_FORMAT_DISK)
		printf("  [disk]");
	else if (fmt->type == CISTPL_FORMAT_MEM)
		printf("  [memory]");
	else
		printf("  [type 0x%02x]\n", fmt->type);
	if (fmt->edc == CISTPL_EDC_NONE)
		printf(" [no edc]");
	else if (fmt->edc == CISTPL_EDC_CKSUM)
		printf(" [cksum]");
	else if (fmt->edc == CISTPL_EDC_CRC)
		printf(" [crc]");
	else if (fmt->edc == CISTPL_EDC_PCC)
		printf(" [pcc]");
	else
		printf(" [edc 0x%02x]", fmt->edc);
	printf(" offset 0x%04x length ", fmt->offset);
	print_size(fmt->length);
	putchar('\n');
}


static void print_config(int code, cistpl_config_t *cfg)
{
    printf("config%s base 0x%4.4x",
	   (code == CISTPL_CONFIG_CB) ? "_cb" : "",
	   cfg->base);
    if (code == CISTPL_CONFIG)
	    printf(" mask 0x%4.4x", cfg->rmask[0]);
    printf(" last_index 0x%2.2x\n", cfg->last_idx);
    if (verbose && cfg->subtuples)
	    printf("  %d bytes in subtuples\n", cfg->subtuples);
}


static int nfn = 0, cur = 0;

static void print_parse(tuple_t *tuple, cisparse_t *parse)
{
	static int func = 0;
	int i;

	switch (tuple->TupleCode) {
	case CISTPL_DEVICE:
	case CISTPL_DEVICE_A:
		if (tuple->TupleCode == CISTPL_DEVICE)
			printf("dev_info\n");
		else
			printf("attr_dev_info\n");
		print_device(&parse->device);
		break;
	case CISTPL_CHECKSUM:
		printf("checksum 0x%04x-0x%04x = 0x%02x\n",
		       parse->checksum.addr,
		       parse->checksum.addr+parse->checksum.len-1,
		       parse->checksum.sum);
		break;
	case CISTPL_LONGLINK_A:
		if (verbose)
			printf("long_link_attr 0x%04x\n",
			       parse->longlink.addr);
		break;
	case CISTPL_LONGLINK_C:
		if (verbose)
			printf("long_link 0x%04x\n",
			       parse->longlink.addr);
		break;
	case CISTPL_LONGLINK_MFC:
		if (verbose) {
			printf("mfc_long_link\n");
			for (i = 0; i < parse->longlink_mfc.nfn; i++)
				printf(" function %d: %s 0x%04x\n", i,
				       parse->longlink_mfc.fn[i].space ? "common" : "attr",
				       parse->longlink_mfc.fn[i].addr);
		} else {
			printf("mfc {\n");
			nfn = parse->longlink_mfc.nfn;
			cur = 0;
		}
		break;
	case CISTPL_NO_LINK:
		if (verbose)
			printf("no_long_link\n");
		break;
	case CISTPL_INDIRECT:
		if (verbose)
			printf("indirect_access\n");
		break;
	case CISTPL_LINKTARGET:
		if (verbose)
			printf("link_target\n");
		else {
			if (cur++)
				printf("}, {\n");
		}
		break;
	case CISTPL_VERS_1:
		print_vers_1(&parse->version_1);
		break;
	case CISTPL_ALTSTR:
		break;
	case CISTPL_JEDEC_A:
	case CISTPL_JEDEC_C:
		if (tuple->TupleCode == CISTPL_JEDEC_C)
			printf("common_jedec");
		else
			printf("attr_jedec");
		print_jedec(&parse->jedec);
		break;
	case CISTPL_DEVICE_GEO:
	case CISTPL_DEVICE_GEO_A:
		if (tuple->TupleCode == CISTPL_DEVICE_GEO)
			printf("common_geometry\n");
		else
			printf("attr_geometry\n");
		print_device_geo(&parse->device_geo);
		break;
	case CISTPL_MANFID:
		printf("manfid 0x%4.4x, 0x%4.4x\n",
		       parse->manfid.manf, parse->manfid.card);
		break;
	case CISTPL_FUNCID:
		print_funcid(&parse->funcid);
		func = parse->funcid.func;
		break;
	case CISTPL_FUNCE:
		switch (func) {
		case CISTPL_FUNCID_SERIAL:
			print_serial(&parse->funce);
			break;
		case CISTPL_FUNCID_FIXED:
			print_fixed(&parse->funce);
			break;
		case CISTPL_FUNCID_NETWORK:
			print_network(&parse->funce);
			break;
		}
		break;
	case CISTPL_BAR:
		printf("BAR %d size ",
		       parse->bar.attr & CISTPL_BAR_SPACE);
		print_size(parse->bar.size);
		if (parse->bar.attr & CISTPL_BAR_SPACE_IO)
			printf(" [io]");
		else
			printf(" [mem]");
		if (parse->bar.attr & CISTPL_BAR_PREFETCH)
			printf(" [prefetch]");
		if (parse->bar.attr & CISTPL_BAR_CACHEABLE)
			printf(" [cacheable]");
		if (parse->bar.attr & CISTPL_BAR_1MEG_MAP)
			printf(" [<1mb]");
		putchar('\n');
		break;
	case CISTPL_CONFIG:
	case CISTPL_CONFIG_CB:
		print_config(tuple->TupleCode, &parse->config);
		break;
	case CISTPL_CFTABLE_ENTRY:
		print_cftable_entry(&parse->cftable_entry);
		break;
	case CISTPL_CFTABLE_ENTRY_CB:
		print_cftable_entry_cb(&parse->cftable_entry_cb);
		break;
	case CISTPL_VERS_2:
		print_vers_2(&parse->vers_2);
		break;
	case CISTPL_ORG:
		print_org(&parse->org);
		break;
	case CISTPL_FORMAT:
	case CISTPL_FORMAT_A:
		if (tuple->TupleCode == CISTPL_FORMAT)
			printf("common_format\n");
		else
			printf("attr_format\n");
		print_format(&parse->format);
	}
}


static int parse_cis_one_socket(unsigned int socket_no, FILE *fd)
{
	int ret = 0;
	tuple_t tuple;
	unsigned char buf[256];
	cisparse_t parse;

	memset(&tuple, 0, sizeof(tuple_t));

        ret = read_out_cis(socket_no, fd);
        if (ret)
                return (ret);

	printf("Socket %u\n", socket_no);

	tuple.Attributes = TUPLE_RETURN_LINK | TUPLE_RETURN_COMMON;
        tuple.DesiredTuple = RETURN_FIRST_TUPLE;

	ret = pcmcia_get_first_tuple(BIND_FN_ALL, &tuple);
	if (ret)
		return (ret);

	while(tuple.TupleCode != CISTPL_END) {
		tuple.TupleData = buf;
		tuple.TupleOffset = 0;
		tuple.TupleDataMax = 255;

		pcmcia_get_tuple_data(&tuple);

		if (verbose)
			print_tuple(&tuple);

		ret = pccard_parse_tuple(&tuple, &parse);
		if (ret) {
			printf("invalid tuple\n");
			continue;
		}

		print_parse(&tuple, &parse);

		printf("\n");

		ret = pcmcia_get_next_tuple(BIND_FN_ALL, &tuple);
		if (ret)
			break;
	}

	return (ret);
}

int main(int argc, char** argv)
{
	unsigned int socket_no = MAX_SOCKETS;
	int ret = -ENODEV, i;
	FILE *fd = NULL;

	if (argc == 2) {
		ret = sscanf(argv[1], "%u", &socket_no);
		if (ret != 1)
			socket_no = MAX_SOCKETS;
	} else if (argc == 3) {
		if (!strncmp("-f", argv[1], 2)) {
			if (!strncmp("-", argv[2], 1))
				fd = stdin;
			else
				fd = fopen(argv[2], "r");
			if (!fd)
				return -EINVAL;
			return parse_cis_one_socket(MAX_SOCKETS + 1, fd);
		}
	}

	if ((socket_no != MAX_SOCKETS) || fd) {
		return parse_cis_one_socket(socket_no, fd);
	} else {
		for (i=0; i<MAX_SOCKETS; i++)
			if (!parse_cis_one_socket(i, fd))
				ret = 0;
	}

	return (ret);;
}