blob: c5cdc51d712e6dcbbd15d9b6bd2ba33c46e2e005 [file] [log] [blame]
/*
* 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);;
}