lspnp.c

pcmcia source code

	if (r->dma.info & PNP_RES_DMA_COUNT_BYTE)
	    printf(" [count byte]");
	if (r->dma.info & PNP_RES_DMA_COUNT_WORD)
	    printf(" [count word]");
	switch (r->dma.info & PNP_RES_DMA_SPEED_MASK) {
	case PNP_RES_DMA_SPEED_COMPAT: printf(" [compat]"); break;
	case PNP_RES_DMA_SPEED_TYPEA: printf(" [type A]"); break;
	case PNP_RES_DMA_SPEED_TYPEB: printf(" [type B]"); break;
	case PNP_RES_DMA_SPEED_TYPEF: printf(" [type F]"); break;
	}
    }
    printf("\n");
}

static void dump_dep_start(union pnp_small_resource *r, int sz)
{
    printf("\t[start dep fn");
    if (sz) {
	printf(": priority: ");
	switch (r->dep_start.priority) {
	case PNP_RES_CONFIG_GOOD:
	    printf("good"); break;
	case PNP_RES_CONFIG_ACCEPTABLE:
	    printf("acceptable"); break;
	case PNP_RES_CONFIG_SUBOPTIMAL:
	    printf("suboptimal"); break;
	default:
	    printf("reserved"); break;
	}
    }
    printf("]\n");
}

static void dump_dep_end(union pnp_small_resource *r)
{
    printf("\t[end dep fn]\n");
}

static void dump_io(union pnp_small_resource *r)
{
    int min = flip16(r->io.min), max = flip16(r->io.max);
    printf("\tio ");
    if (r->io.len == 0)
	printf("disabled");
    else if (min == max)
	printf("0x%04x-0x%04x", min, min+r->io.len-1);
    else
	printf("base 0x%04x-0x%04x align 0x%02x len 0x%02x",
	       min, max, r->io.align, r->io.len);
    if (verbose > 1) {
	if (r->io.info & PNP_RES_IO_DECODE_16)
	    printf(" [16-bit decode]");
    }
    printf("\n");
}

static void dump_io_fixed(union pnp_small_resource *r)
{
    int base = flip16(r->io_fixed.base);
    printf("\tio ");
    if (r->io_fixed.len == 0)
	printf("disabled\n");
    else
	printf("0x%04x-0x%04x\n", base, base+r->io_fixed.len-1);
}

/*
  Large resource tags
*/

static void dump_mem_info(__u8 info)
{
    switch (info & PNP_RES_MEM_WIDTH_MASK) {
    case PNP_RES_MEM_WIDTH_8:
	printf(" [8 bit]"); break;
    case PNP_RES_MEM_WIDTH_16:
	printf(" [16 bit]"); break;
    case PNP_RES_MEM_WIDTH_8_16:
	printf(" [8/16 bit]"); break;
    case PNP_RES_MEM_WIDTH_32:
	printf(" [32 bit]"); break;
    }
    printf((info & PNP_RES_MEM_WRITEABLE) ? " [r/w]" : " [r/o]");
    if (info & PNP_RES_MEM_CACHEABLE)
	printf(" [cacheable]");
    if (info & PNP_RES_MEM_HIGH_ADDRESS)
	printf(" [high]");
    if (info & PNP_RES_MEM_SHADOWABLE)
	printf(" [shadow]");
    if (info & PNP_RES_MEM_EXPANSION_ROM)
	printf(" [rom]");
}

static void dump_ansi(union pnp_large_resource *r, int sz)
{
    printf("\tidentifier '%.*s'\n", sz, r->ansi.str);
}

static void dump_mem(union pnp_large_resource *r)
{
    int min = flip16(r->mem.min) << 8;
    int max = flip16(r->mem.max) << 8;
    int align = flip16(r->mem.align), len = flip16(r->mem.len);
    printf("\tmem ");
    if (len == 0)
	printf("disabled");
    else if (min == max)
	printf("0x%06x-0x%06x", min, min+len-1);
    else
	printf("base 0x%06x-%06x, align 0x%04x, len 0x%06x",
	       min, max, align ? align : 0x10000, len<<8);
    if (verbose > 1)
	dump_mem_info(r->mem.info);
    printf("\n");
}

static void dump_mem32(union pnp_large_resource *r)
{
    u_int min = flip32(r->mem32.min), max = flip32(r->mem32.max);
    u_int align = flip32(r->mem32.align), len = flip32(r->mem32.len);
    printf("\tmem ");
    if (len == 0)
	printf("disabled");
    else if (min == max)
	printf("0x%08x-0x%08x", min, min+len-1);
    else
	printf("\tmem base 0x%08x-0x%08x align 0x%06x len 0x%06x",
	   min, max, align, len);
    if (verbose > 1)
	dump_mem_info(r->mem32.info);
    printf("\n");
}

static void dump_mem32_fixed(union pnp_large_resource *r)
{
    u_int base = flip32(r->mem32_fixed.base);
    u_int len = flip32(r->mem32_fixed.len);
    printf("\tmem ");
    if (len == 0)
	printf("disabled");
    else
	printf("0x%08x-0x%08x", base, base+len-1);
    if (verbose > 1)
	dump_mem_info(r->mem32_fixed.info);
    printf("\n");
}

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

static char *dump_chain(u_char *buf, int nr)
{
    union pnp_resource *p = (union pnp_resource *)buf;
    int tag = 0, sz;
    
    while (((u_char *)p < buf+nr) && (tag != PNP_RES_SMTAG_END)) {
	if (p->lg.tag & PNP_RES_LARGE_ITEM) {
	    union pnp_large_resource *r = &p->lg.d;
	    tag = p->lg.tag & ~PNP_RES_LARGE_ITEM;
	    sz = flip16(p->lg.sz) + 2;
	    switch (tag) {
	    case PNP_RES_LGTAG_MEM:
		dump_mem(r); break;
	    case PNP_RES_LGTAG_ID_ANSI:
		dump_ansi(r, sz-2); break;
	    case PNP_RES_LGTAG_ID_UNICODE:
		/* dump_unicode(r); */ break;
	    case PNP_RES_LGTAG_MEM32:
		dump_mem32(r); break;
	    case PNP_RES_LGTAG_MEM32_FIXED:
		dump_mem32_fixed(r); break;
	    }
	} else {
	    union pnp_small_resource *r = &p->sm.d;
	    tag = (p->sm.tag >> 3); sz = (p->sm.tag & 7);
	    switch (tag) {
	    case PNP_RES_SMTAG_VERSION:
		dump_version(r); break;
	    case PNP_RES_SMTAG_LDID:
		dump_ldid(r, sz); break;
	    case PNP_RES_SMTAG_CDID:
		dump_gdid(r); break;
	    case PNP_RES_SMTAG_IRQ:
		dump_irq(r, sz); break;
	    case PNP_RES_SMTAG_DMA:
		dump_dma(r); break;
	    case PNP_RES_SMTAG_DEP_START:
		dump_dep_start(r, sz); break;
	    case PNP_RES_SMTAG_DEP_END:
		dump_dep_end(r); break;
	    case PNP_RES_SMTAG_IO:
		dump_io(r); break;
	    case PNP_RES_SMTAG_IO_FIXED:
		dump_io_fixed(r); break;
	    }
	}
	(u_char *)p += sz + 1;
    }
    return (u_char *)p;
}

static void dump_resources(int num)
{
    char fn[40];
    u_char buf[4096], *p;
    int fd, nr;
    
    sprintf(fn, "/proc/bus/pnp/%s%02x", (boot ? "boot/" : ""), num);
    fd = open(fn, O_RDONLY);
    nr = read(fd, buf, sizeof(buf));
    close(fd);
    if (nr > 0) {
	if (verbose > 1)
	    printf("    allocated resources:\n");
	p = dump_chain(buf, nr);
	if (verbose > 1) {
	    if (p+4 < buf+nr) {
		printf("    possible resources:\n");
	    }
	    p = dump_chain(p, nr);
	    if (p+2 < buf+nr) {
		printf("    compatible devices:\n");
		p = dump_chain(p, nr);
	    }
	}
    }
}

static int dump_basic(int match)
{
    int id, num, t1, t2, t3, flags;
    struct eisa_id *eid;
    char *eis, buf[64];
    FILE *f;

    f = fopen("/proc/bus/pnp/devices", "r");
    if (f == NULL) {
	fprintf(stderr, "lspnp: /proc/bus/pnp not available\n");
	return -1;
    }
    while (fgets(buf, 63, f) != NULL) {
	sscanf(buf, "%x %x %x:%x:%x %x", &num, &id, &t1, &t2, &t3, &flags);
	if ((match >= 0) && (match != num))
	    continue;
	eis = eisa_str(id);
	printf("%02x %7s ", num, eis);
	for (eid = eisa_id; eid; eid = eid->next)
	    if (strcmp(eis, eid->id) == 0) break;
	if (eid)
	    printf("%s", eid->name);
	else
	    dump_class(t1, t2);
	printf("\n");
	if (verbose > 1)
	    dump_flags(flags);
	if (verbose) {
	    dump_resources(num);
	    if (match < 0) printf("\n");
	}
    }
    fclose(f);
    return 0;
}

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

void usage(char *name)
{
    fprintf(stderr, "usage: %s [-b] [-v[v]] [device #]\n", name);
    exit(EXIT_FAILURE);
}
    
int main(int argc, char *argv[])
{
    int optch, errflg = 0;
    char *s;
    
    while ((optch = getopt(argc, argv, "bv")) != -1) {
	switch (optch) {
	case 'b':
	    boot++; break;
	case 'v':
	    verbose++; break;
	default:
	    errflg = 1; break;
	}
    }
    if (errflg)
	usage(argv[0]);
    load_ids();
    if (optind < argc) {
	while (optind < argc) {
	    int i = strtoul(argv[optind], &s, 16);
	    if ((argv[optind] == '\0') || (*s != '\0'))
		usage(argv[0]);
	    if (dump_basic(i) != 0)
		return EXIT_FAILURE;
	    optind++;
	}
	return EXIT_SUCCESS;
    }
    return dump_basic(-1);
}