WebSVN – HelenOS – Diff – /uspace/trunk/pci/libpci/names.c


/*
 *  The PCI Library -- ID to Name Translation
 *
 *  Copyright (c) 1997--2005 Martin Mares <mj@ucw.cz>
 *
 *  May 8, 2006 - Modified and ported to HelenOS by Jakub Jermar.
 *
 *  Can be freely distributed and used under the terms of the GNU GPL.
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
 
#include "internal.h"
#include "pci_ids.h"
 
struct id_entry {
    struct id_entry *next;
    u32 id12, id34;
    byte cat;
    byte name[1];
};
 
enum id_entry_type {
    ID_UNKNOWN,
    ID_VENDOR,
    ID_DEVICE,
    ID_SUBSYSTEM,
    ID_GEN_SUBSYSTEM,
    ID_CLASS,
    ID_SUBCLASS,
    ID_PROGIF
};
 
struct id_bucket {
    struct id_bucket *next;
    unsigned int full;
};
 
#define MAX_LINE 1024
#define BUCKET_SIZE 8192
#define HASH_SIZE 4099
 
#ifdef __GNUC__
#define BUCKET_ALIGNMENT __alignof__(struct id_bucket)
#else
union id_align {
    struct id_bucket *next;
    unsigned int full;
};
#define BUCKET_ALIGNMENT sizeof(union id_align)
#endif
#define BUCKET_ALIGN(n) ((n)+BUCKET_ALIGNMENT-(n)%BUCKET_ALIGNMENT)
 
static void *id_alloc(struct pci_access *a, unsigned int size)
{
    struct id_bucket *buck = a->current_id_bucket;
    unsigned int pos;
    if (!buck || buck->full + size > BUCKET_SIZE) {
        buck = pci_malloc(a, BUCKET_SIZE);
        buck->next = a->current_id_bucket;
        a->current_id_bucket = buck;
        buck->full = BUCKET_ALIGN(sizeof(struct id_bucket));
    }
    pos = buck->full;
    buck->full = BUCKET_ALIGN(buck->full + size);
    return (byte *) buck + pos;
}
 
static inline u32 id_pair(unsigned int x, unsigned int y)
{
    return ((x << 16) | y);
}
 
static inline unsigned int id_hash(int cat, u32 id12, u32 id34)
{
    unsigned int h;
 
    h = id12 ^ (id34 << 3) ^ (cat << 5);
    return h % HASH_SIZE;
}
 
static struct id_entry *id_lookup(struct pci_access *a, int cat, int id1,
                  int id2, int id3, int id4)
{
    struct id_entry *n;
    u32 id12 = id_pair(id1, id2);
    u32 id34 = id_pair(id3, id4);
 
    n = a->id_hash[id_hash(cat, id12, id34)];
    while (n && (n->id12 != id12 || n->id34 != id34 || n->cat != cat))
        n = n->next;
    return n;
}
 
static int id_insert(struct pci_access *a, int cat, int id1, int id2,
             int id3, int id4, byte * text)
{
    u32 id12 = id_pair(id1, id2);
    u32 id34 = id_pair(id3, id4);
    unsigned int h = id_hash(cat, id12, id34);
    struct id_entry *n = a->id_hash[h];
    int len = strlen((char *) text);
 
    while (n && (n->id12 != id12 || n->id34 != id34 || n->cat != cat))
        n = n->next;
    if (n)
        return 1;
    n = id_alloc(a, sizeof(struct id_entry) + len);
    n->id12 = id12;
    n->id34 = id34;
    n->cat = cat;
    memcpy(n->name, text, len + 1);
    n->next = a->id_hash[h];
    a->id_hash[h] = n;
    return 0;
}
 
static int id_hex(byte * p, int cnt)
{
    int x = 0;
    while (cnt--) {
        x <<= 4;
        if (*p >= '0' && *p <= '9')
            x += (*p - '0');
        else if (*p >= 'a' && *p <= 'f')
            x += (*p - 'a' + 10);
        else if (*p >= 'A' && *p <= 'F')
            x += (*p - 'A' + 10);
        else
            return -1;
        p++;
    }
    return x;
}
 
static inline int id_white_p(int c)
{
    return (c == ' ') || (c == '\t');
}
 
static const char *id_parse_list(struct pci_access *a, int *lino)
{
    byte *line;
    byte *p;
    int id1 = 0, id2 = 0, id3 = 0, id4 = 0;
    int cat = -1;
    int nest;
    static const char parse_error[] = "Parse error";
    int i;
 
    *lino = 0;
    for (i = 0; i < sizeof(pci_ids) / sizeof(char *); i++) {
        line = (byte *) pci_ids[i];
        (*lino)++;
        p = line;
        while (*p)
            p++;
        if (p > line && (p[-1] == ' ' || p[-1] == '\t'))
            *--p = 0;
 
        p = line;
        while (id_white_p(*p))
            p++;
        if (!*p || *p == '#')
            continue;
 
        p = line;
        while (*p == '\t')
            p++;
        nest = p - line;
 
        if (!nest) {    /* Top-level entries */
            if (p[0] == 'C' && p[1] == ' ') {   /* Class block */
                if ((id1 = id_hex(p + 2, 2)) < 0 || !id_white_p(p[4]))
 
                    return parse_error;
                cat = ID_CLASS;
                p += 5;
            } else if (p[0] == 'S' && p[1] == ' ') {    /* Generic subsystem block */
                if ((id1 = id_hex(p + 2, 4)) < 0 || p[6])
                    return parse_error;
                if (!id_lookup(a, ID_VENDOR, id1, 0, 0, 0))
                    return "Vendor does not exist";
                cat = ID_GEN_SUBSYSTEM;
                continue;
            } else if (p[0] >= 'A' && p[0] <= 'Z' && p[1] == ' ') { /* Unrecognized block (RFU) */
                cat = ID_UNKNOWN;
                continue;
            } else {    /* Vendor ID */
 
                if ((id1 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
 
                    return parse_error;
                cat = ID_VENDOR;
                p += 5;
            }
            id2 = id3 = id4 = 0;
        } else if (cat == ID_UNKNOWN)   /* Nested entries in RFU blocks are skipped */
            continue;
        else if (nest == 1) /* Nesting level 1 */
            switch (cat) {
            case ID_VENDOR:
            case ID_DEVICE:
            case ID_SUBSYSTEM:
                if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
 
                    return parse_error;
                p += 5;
                cat = ID_DEVICE;
                id3 = id4 = 0;
                break;
            case ID_GEN_SUBSYSTEM:
                if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
 
                    return parse_error;
                p += 5;
                id3 = id4 = 0;
                break;
            case ID_CLASS:
            case ID_SUBCLASS:
            case ID_PROGIF:
                if ((id2 = id_hex(p, 2)) < 0 || !id_white_p(p[2]))
 
                    return parse_error;
                p += 3;
                cat = ID_SUBCLASS;
                id3 = id4 = 0;
                break;
            default:
                return parse_error;
        } else if (nest == 2)   /* Nesting level 2 */
            switch (cat) {
            case ID_DEVICE:
            case ID_SUBSYSTEM:
                if ((id3 = id_hex(p, 4)) < 0 || !id_white_p(p[4])
 
                    || (id4 = id_hex(p + 5, 4)) < 0 || !id_white_p(p[9]))
 
                    return parse_error;
                p += 10;
                cat = ID_SUBSYSTEM;
                break;
            case ID_CLASS:
            case ID_SUBCLASS:
            case ID_PROGIF:
                if ((id3 = id_hex(p, 2)) < 0 || !id_white_p(p[2]))
 
                    return parse_error;
                p += 3;
                cat = ID_PROGIF;
                id4 = 0;
                break;
            default:
                return parse_error;
        } else      /* Nesting level 3 or more */
            return parse_error;
        while (id_white_p(*p))
            p++;
        if (!*p)
            return parse_error;
        if (id_insert(a, cat, id1, id2, id3, id4, p))
            return "Duplicate entry";
    }
    return NULL;
}
 
int pci_load_name_list(struct pci_access *a)
{
    int lino;
    const char *err;
 
    pci_free_name_list(a);
    a->id_hash = pci_malloc(a, sizeof(struct id_entry *) * HASH_SIZE);
    bzero(a->id_hash, sizeof(struct id_entry *) * HASH_SIZE);
    err = id_parse_list(a, &lino);
    if (err)
        a->error("%s at %s, element %d\n", err, "pci_ids.h", lino);
    return 1;
}
 
void pci_free_name_list(struct pci_access *a)
{
    pci_mfree(a->id_hash);
    a->id_hash = NULL;
    while (a->current_id_bucket) {
        struct id_bucket *buck = a->current_id_bucket;
        a->current_id_bucket = buck->next;
        pci_mfree(buck);
    }
}
 
static struct id_entry *id_lookup_subsys(struct pci_access *a, int iv,
                     int id, int isv, int isd)
{
    struct id_entry *d = NULL;
    if (iv > 0 && id > 0)   /* Per-device lookup */
        d = id_lookup(a, ID_SUBSYSTEM, iv, id, isv, isd);
    if (!d)         /* Generic lookup */
        d = id_lookup(a, ID_GEN_SUBSYSTEM, isv, isd, 0, 0);
    if (!d && iv == isv && id == isd)   /* Check for subsystem == device */
        d = id_lookup(a, ID_DEVICE, iv, id, 0, 0);
    return d;
}
 
char *pci_lookup_name(struct pci_access *a, char *buf, int size, int flags,
              ...)
{
    va_list args;
    int num, res, synth;
    struct id_entry *v, *d, *cls, *pif;
    int iv, id, isv, isd, icls, ipif;
 
    va_start(args, flags);
 
    num = 0;
    if ((flags & PCI_LOOKUP_NUMERIC) || a->numeric_ids) {
        flags &= ~PCI_LOOKUP_NUMERIC;
        num = 1;
    } else if (!a->id_hash) {
        if (!pci_load_name_list(a))
            num = a->numeric_ids = 1;
    }
 
    if (flags & PCI_LOOKUP_NO_NUMBERS) {
        flags &= ~PCI_LOOKUP_NO_NUMBERS;
        synth = 0;
        if (num)
            return NULL;
    } else
        synth = 1;
 
    switch (flags) {
    case PCI_LOOKUP_VENDOR:
        iv = va_arg(args, int);
        if (num)
            res = snprintf(buf, size, "%04x", iv);
        else if (v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0))
            return (char *) v->name;
        else
 
            res = snprintf(buf, size, "Unknown vendor %04x", iv);
        break;
    case PCI_LOOKUP_DEVICE:
        iv = va_arg(args, int);
        id = va_arg(args, int);
        if (num)
            res = snprintf(buf, size, "%04x", id);
        else if (d = id_lookup(a, ID_DEVICE, iv, id, 0, 0))
            return (char *) d->name;
        else if (synth)
 
            res = snprintf(buf, size, "Unknown device %04x", id);
        else
            return NULL;
        break;
    case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE:
        iv = va_arg(args, int);
        id = va_arg(args, int);
        if (num)
            res = snprintf(buf, size, "%04x:%04x", iv, id);
        else {
            v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0);
            d = id_lookup(a, ID_DEVICE, iv, id, 0, 0);
            if (v && d)
 
                res = snprintf(buf, size, "%s %s", v->name,
                         d->name);
            else if (!synth)
                return NULL;
            else if (!v)
 
 
                res = snprintf(buf, size, "Unknown device %04x:%04x", iv, id);
 
            else    /* !d */
 
 
                res = snprintf(buf, size, "%s Unknown device %04x", v->name, id);
 
        }
        break;
    case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR:
        isv = va_arg(args, int);
        if (num)
            res = snprintf(buf, size, "%04x", isv);
        else if (v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0))
            return (char *) v->name;
        else if (synth)
 
            res = snprintf(buf, size, "Unknown vendor %04x", isv);
 
        else
            return NULL;
        break;
    case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_DEVICE:
        iv = va_arg(args, int);
        id = va_arg(args, int);
        isv = va_arg(args, int);
        isd = va_arg(args, int);
        if (num)
            res = snprintf(buf, size, "%04x", isd);
        else if (d = id_lookup_subsys(a, iv, id, isv, isd))
            return (char *) d->name;
        else if (synth)
 
            res = snprintf(buf, size, "Unknown device %04x", isd);
 
        else
            return NULL;
        break;
    case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE | PCI_LOOKUP_SUBSYSTEM:
        iv = va_arg(args, int);
        id = va_arg(args, int);
        isv = va_arg(args, int);
        isd = va_arg(args, int);
        if (num)
            res = snprintf(buf, size, "%04x:%04x", isv, isd);
        else {
            v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0);
            d = id_lookup_subsys(a, iv, id, isv, isd);
            if (v && d)
 
                res = snprintf(buf, size, "%s %s", v->name, d->name);
 
            else if (!synth)
                return NULL;
            else if (!v)
 
 
                res = snprintf(buf, size, "Unknown device %04x:%04x", isv, isd);
 
            else    /* !d */
 
 
                res = snprintf(buf, size, "%s Unknown device %04x", v->name, isd);
 
        }
        break;
    case PCI_LOOKUP_CLASS:
        icls = va_arg(args, int);
        if (num)
            res = snprintf(buf, size, "%04x", icls);
 
        else if (cls = id_lookup(a, ID_SUBCLASS, icls >> 8, icls & 0xff, 0, 0))
 
            return (char *) cls->name;
        else if (cls = id_lookup(a, ID_CLASS, icls, 0, 0, 0))
 
            res = snprintf(buf, size, "%s [%04x]", cls->name, icls);
 
        else if (synth)
            res = snprintf(buf, size, "Class %04x", icls);
        else
            return NULL;
        break;
    case PCI_LOOKUP_PROGIF:
        icls = va_arg(args, int);
        ipif = va_arg(args, int);
        if (num)
            res = snprintf(buf, size, "%02x", ipif);
 
        else if (pif = id_lookup(a, ID_PROGIF, icls >> 8, icls & 0xff, ipif, 0))
 
            return (char *) pif->name;
        else if (icls == 0x0101 && !(ipif & 0x70)) {
            /* IDE controllers have complex prog-if semantics */
            res = snprintf(buf, size, "%s%s%s%s%s",
                       (ipif & 0x80) ? "Master " : "",
                       (ipif & 0x08) ? "SecP " : "",
                       (ipif & 0x04) ? "SecO " : "",
                       (ipif & 0x02) ? "PriP " : "",
                       (ipif & 0x01) ? "PriO " : "");
            if (res > 0 && res < size)
                buf[--res] = 0;
        } else if (synth)
            res = snprintf(buf, size, "ProgIf %02x", ipif);
        else
            return NULL;
        break;
    default:
        return "<pci_lookup_name: invalid request>";
    }
    if (res < 0 || res >= size)
        return "<pci_lookup_name: buffer too small>";
    else
        return buf;
}
 

Rev 1302	Rev 1324
1	/*	1	/*
2	* The PCI Library -- ID to Name Translation	2	* The PCI Library -- ID to Name Translation
3	*	3	*
4	* Copyright (c) 1997--2005 Martin Mares <mj@ucw.cz>	4	* Copyright (c) 1997--2005 Martin Mares <mj@ucw.cz>
5	*	5	*
6	* Modified and ported to HelenOS by Jakub Jermar.	6	* May 8, 2006 - Modified and ported to HelenOS by Jakub Jermar.
7	*	7	*
8	* Can be freely distributed and used under the terms of the GNU GPL.	8	* Can be freely distributed and used under the terms of the GNU GPL.
9	*/	9	*/
10		10
11	#include <stdio.h>	11	#include <stdio.h>
12	#include <stdlib.h>	12	#include <stdlib.h>
13	#include <stdarg.h>	13	#include <stdarg.h>
14	#include <string.h>	14	#include <string.h>
15	#include <errno.h>	15	#include <errno.h>
16		16
17	#include "internal.h"	17	#include "internal.h"
18	#include "pci_ids.h"	18	#include "pci_ids.h"
19		19
20	struct id_entry {	20	struct id_entry {
21	struct id_entry *next;	21	struct id_entry *next;
22	u32 id12, id34;	22	u32 id12, id34;
23	byte cat;	23	byte cat;
24	byte name[1];	24	byte name[1];
25	};	25	};
26		26
27	enum id_entry_type {	27	enum id_entry_type {
28	ID_UNKNOWN,	28	ID_UNKNOWN,
29	ID_VENDOR,	29	ID_VENDOR,
30	ID_DEVICE,	30	ID_DEVICE,
31	ID_SUBSYSTEM,	31	ID_SUBSYSTEM,
32	ID_GEN_SUBSYSTEM,	32	ID_GEN_SUBSYSTEM,
33	ID_CLASS,	33	ID_CLASS,
34	ID_SUBCLASS,	34	ID_SUBCLASS,
35	ID_PROGIF	35	ID_PROGIF
36	};	36	};
37		37
38	struct id_bucket {	38	struct id_bucket {
39	struct id_bucket *next;	39	struct id_bucket *next;
40	unsigned int full;	40	unsigned int full;
41	};	41	};
42		42
43	#define MAX_LINE 1024	43	#define MAX_LINE 1024
44	#define BUCKET_SIZE 8192	44	#define BUCKET_SIZE 8192
45	#define HASH_SIZE 4099	45	#define HASH_SIZE 4099
46		46
47	#ifdef __GNUC__	47	#ifdef __GNUC__
48	#define BUCKET_ALIGNMENT __alignof__(struct id_bucket)	48	#define BUCKET_ALIGNMENT __alignof__(struct id_bucket)
49	#else	49	#else
50	union id_align {	50	union id_align {
51	struct id_bucket *next;	51	struct id_bucket *next;
52	unsigned int full;	52	unsigned int full;
53	};	53	};
54	#define BUCKET_ALIGNMENT sizeof(union id_align)	54	#define BUCKET_ALIGNMENT sizeof(union id_align)
55	#endif	55	#endif
56	#define BUCKET_ALIGN(n) ((n)+BUCKET_ALIGNMENT-(n)%BUCKET_ALIGNMENT)	56	#define BUCKET_ALIGN(n) ((n)+BUCKET_ALIGNMENT-(n)%BUCKET_ALIGNMENT)
57		57
58	static void id_alloc(struct pci_access a, unsigned int size)	58	static void id_alloc(struct pci_access a, unsigned int size)
59	{	59	{
60	struct id_bucket *buck = a->current_id_bucket;	60	struct id_bucket *buck = a->current_id_bucket;
61	unsigned int pos;	61	unsigned int pos;
62	if (!buck \|\| buck->full + size > BUCKET_SIZE) {	62	if (!buck \|\| buck->full + size > BUCKET_SIZE) {
63	buck = pci_malloc(a, BUCKET_SIZE);	63	buck = pci_malloc(a, BUCKET_SIZE);
64	buck->next = a->current_id_bucket;	64	buck->next = a->current_id_bucket;
65	a->current_id_bucket = buck;	65	a->current_id_bucket = buck;
66	buck->full = BUCKET_ALIGN(sizeof(struct id_bucket));	66	buck->full = BUCKET_ALIGN(sizeof(struct id_bucket));
67	}	67	}
68	pos = buck->full;	68	pos = buck->full;
69	buck->full = BUCKET_ALIGN(buck->full + size);	69	buck->full = BUCKET_ALIGN(buck->full + size);
70	return (byte *) buck + pos;	70	return (byte *) buck + pos;
71	}	71	}
72		72
73	static inline u32 id_pair(unsigned int x, unsigned int y)	73	static inline u32 id_pair(unsigned int x, unsigned int y)
74	{	74	{
75	return ((x << 16) \| y);	75	return ((x << 16) \| y);
76	}	76	}
77		77
78	static inline unsigned int id_hash(int cat, u32 id12, u32 id34)	78	static inline unsigned int id_hash(int cat, u32 id12, u32 id34)
79	{	79	{
80	unsigned int h;	80	unsigned int h;
81		81
82	h = id12 ^ (id34 << 3) ^ (cat << 5);	82	h = id12 ^ (id34 << 3) ^ (cat << 5);
83	return h % HASH_SIZE;	83	return h % HASH_SIZE;
84	}	84	}
85		85
86	static struct id_entry id_lookup(struct pci_access a, int cat, int id1,	86	static struct id_entry id_lookup(struct pci_access a, int cat, int id1,
87	int id2, int id3, int id4)	87	int id2, int id3, int id4)
88	{	88	{
89	struct id_entry *n;	89	struct id_entry *n;
90	u32 id12 = id_pair(id1, id2);	90	u32 id12 = id_pair(id1, id2);
91	u32 id34 = id_pair(id3, id4);	91	u32 id34 = id_pair(id3, id4);
92		92
93	n = a->id_hash[id_hash(cat, id12, id34)];	93	n = a->id_hash[id_hash(cat, id12, id34)];
94	while (n && (n->id12 != id12 \|\| n->id34 != id34 \|\| n->cat != cat))	94	while (n && (n->id12 != id12 \|\| n->id34 != id34 \|\| n->cat != cat))
95	n = n->next;	95	n = n->next;
96	return n;	96	return n;
97	}	97	}
98		98
99	static int id_insert(struct pci_access *a, int cat, int id1, int id2,	99	static int id_insert(struct pci_access *a, int cat, int id1, int id2,
100	int id3, int id4, byte * text)	100	int id3, int id4, byte * text)
101	{	101	{
102	u32 id12 = id_pair(id1, id2);	102	u32 id12 = id_pair(id1, id2);
103	u32 id34 = id_pair(id3, id4);	103	u32 id34 = id_pair(id3, id4);
104	unsigned int h = id_hash(cat, id12, id34);	104	unsigned int h = id_hash(cat, id12, id34);
105	struct id_entry *n = a->id_hash[h];	105	struct id_entry *n = a->id_hash[h];
106	int len = strlen((char *) text);	106	int len = strlen((char *) text);
107		107
108	while (n && (n->id12 != id12 \|\| n->id34 != id34 \|\| n->cat != cat))	108	while (n && (n->id12 != id12 \|\| n->id34 != id34 \|\| n->cat != cat))
109	n = n->next;	109	n = n->next;
110	if (n)	110	if (n)
111	return 1;	111	return 1;
112	n = id_alloc(a, sizeof(struct id_entry) + len);	112	n = id_alloc(a, sizeof(struct id_entry) + len);
113	n->id12 = id12;	113	n->id12 = id12;
114	n->id34 = id34;	114	n->id34 = id34;
115	n->cat = cat;	115	n->cat = cat;
116	memcpy(n->name, text, len + 1);	116	memcpy(n->name, text, len + 1);
117	n->next = a->id_hash[h];	117	n->next = a->id_hash[h];
118	a->id_hash[h] = n;	118	a->id_hash[h] = n;
119	return 0;	119	return 0;
120	}	120	}
121		121
122	static int id_hex(byte * p, int cnt)	122	static int id_hex(byte * p, int cnt)
123	{	123	{
124	int x = 0;	124	int x = 0;
125	while (cnt--) {	125	while (cnt--) {
126	x <<= 4;	126	x <<= 4;
127	if (p >= '0' && p <= '9')	127	if (p >= '0' && p <= '9')
128	x += (*p - '0');	128	x += (*p - '0');
129	else if (p >= 'a' && p <= 'f')	129	else if (p >= 'a' && p <= 'f')
130	x += (*p - 'a' + 10);	130	x += (*p - 'a' + 10);
131	else if (p >= 'A' && p <= 'F')	131	else if (p >= 'A' && p <= 'F')
132	x += (*p - 'A' + 10);	132	x += (*p - 'A' + 10);
133	else	133	else
134	return -1;	134	return -1;
135	p++;	135	p++;
136	}	136	}
137	return x;	137	return x;
138	}	138	}
139		139
140	static inline int id_white_p(int c)	140	static inline int id_white_p(int c)
141	{	141	{
142	return (c == ' ') \|\| (c == '\t');	142	return (c == ' ') \|\| (c == '\t');
143	}	143	}
144		144
145	static const char id_parse_list(struct pci_access a, int *lino)	145	static const char id_parse_list(struct pci_access a, int *lino)
146	{	146	{
147	byte *line;	147	byte *line;
148	byte *p;	148	byte *p;
149	int id1 = 0, id2 = 0, id3 = 0, id4 = 0;	149	int id1 = 0, id2 = 0, id3 = 0, id4 = 0;
150	int cat = -1;	150	int cat = -1;
151	int nest;	151	int nest;
152	static const char parse_error[] = "Parse error";	152	static const char parse_error[] = "Parse error";
153	int i;	153	int i;
154		154
155	*lino = 0;	155	*lino = 0;
156	for (i = 0; i < sizeof(pci_ids) / sizeof(char *); i++) {	156	for (i = 0; i < sizeof(pci_ids) / sizeof(char *); i++) {
157	line = (byte *) pci_ids[i];	157	line = (byte *) pci_ids[i];
158	(*lino)++;	158	(*lino)++;
159	p = line;	159	p = line;
160	while (*p)	160	while (*p)
161	p++;	161	p++;
162	if (p > line && (p[-1] == ' ' \|\| p[-1] == '\t'))	162	if (p > line && (p[-1] == ' ' \|\| p[-1] == '\t'))
163	*--p = 0;	163	*--p = 0;
164		164
165	p = line;	165	p = line;
166	while (id_white_p(*p))	166	while (id_white_p(*p))
167	p++;	167	p++;
168	if (!p \|\| p == '#')	168	if (!p \|\| p == '#')
169	continue;	169	continue;
170		170
171	p = line;	171	p = line;
172	while (*p == '\t')	172	while (*p == '\t')
173	p++;	173	p++;
174	nest = p - line;	174	nest = p - line;
175		175
176	if (!nest) { /* Top-level entries */	176	if (!nest) { /* Top-level entries */
177	if (p[0] == 'C' && p[1] == ' ') { /* Class block */	177	if (p[0] == 'C' && p[1] == ' ') { /* Class block */
178	if ((id1 = id_hex(p + 2, 2)) < 0	178	if ((id1 = id_hex(p + 2, 2)) < 0 \|\| !id_white_p(p[4]))
179	\|\| !id_white_p(p[4]))	-
180	return parse_error;	179	return parse_error;
181	cat = ID_CLASS;	180	cat = ID_CLASS;
182	p += 5;	181	p += 5;
183	} else if (p[0] == 'S' && p[1] == ' ') { /* Generic subsystem block */	182	} else if (p[0] == 'S' && p[1] == ' ') { /* Generic subsystem block */
184	if ((id1 = id_hex(p + 2, 4)) < 0 \|\| p[6])	183	if ((id1 = id_hex(p + 2, 4)) < 0 \|\| p[6])
185	return parse_error;	184	return parse_error;
186	if (!id_lookup(a, ID_VENDOR, id1, 0, 0, 0))	185	if (!id_lookup(a, ID_VENDOR, id1, 0, 0, 0))
187	return "Vendor does not exist";	186	return "Vendor does not exist";
188	cat = ID_GEN_SUBSYSTEM;	187	cat = ID_GEN_SUBSYSTEM;
189	continue;	188	continue;
190	} else if (p[0] >= 'A' && p[0] <= 'Z' && p[1] == ' ') { /* Unrecognized block (RFU) */	189	} else if (p[0] >= 'A' && p[0] <= 'Z' && p[1] == ' ') { /* Unrecognized block (RFU) */
191	cat = ID_UNKNOWN;	190	cat = ID_UNKNOWN;
192	continue;	191	continue;
193	} else { /* Vendor ID */	192	} else { /* Vendor ID */
194		193
195	if ((id1 = id_hex(p, 4)) < 0	194	if ((id1 = id_hex(p, 4)) < 0 \|\| !id_white_p(p[4]))
196	\|\| !id_white_p(p[4]))	-
197	return parse_error;	195	return parse_error;
198	cat = ID_VENDOR;	196	cat = ID_VENDOR;
199	p += 5;	197	p += 5;
200	}	198	}
201	id2 = id3 = id4 = 0;	199	id2 = id3 = id4 = 0;
202	} else if (cat == ID_UNKNOWN) /* Nested entries in RFU blocks are skipped */	200	} else if (cat == ID_UNKNOWN) /* Nested entries in RFU blocks are skipped */
203	continue;	201	continue;
204	else if (nest == 1) /* Nesting level 1 */	202	else if (nest == 1) /* Nesting level 1 */
205	switch (cat) {	203	switch (cat) {
206	case ID_VENDOR:	204	case ID_VENDOR:
207	case ID_DEVICE:	205	case ID_DEVICE:
208	case ID_SUBSYSTEM:	206	case ID_SUBSYSTEM:
209	if ((id2 = id_hex(p, 4)) < 0	207	if ((id2 = id_hex(p, 4)) < 0 \|\| !id_white_p(p[4]))
210	\|\| !id_white_p(p[4]))	-
211	return parse_error;	208	return parse_error;
212	p += 5;	209	p += 5;
213	cat = ID_DEVICE;	210	cat = ID_DEVICE;
214	id3 = id4 = 0;	211	id3 = id4 = 0;
215	break;	212	break;
216	case ID_GEN_SUBSYSTEM:	213	case ID_GEN_SUBSYSTEM:
217	if ((id2 = id_hex(p, 4)) < 0	214	if ((id2 = id_hex(p, 4)) < 0 \|\| !id_white_p(p[4]))
218	\|\| !id_white_p(p[4]))	-
219	return parse_error;	215	return parse_error;
220	p += 5;	216	p += 5;
221	id3 = id4 = 0;	217	id3 = id4 = 0;
222	break;	218	break;
223	case ID_CLASS:	219	case ID_CLASS:
224	case ID_SUBCLASS:	220	case ID_SUBCLASS:
225	case ID_PROGIF:	221	case ID_PROGIF:
226	if ((id2 = id_hex(p, 2)) < 0	222	if ((id2 = id_hex(p, 2)) < 0 \|\| !id_white_p(p[2]))
227	\|\| !id_white_p(p[2]))	-
228	return parse_error;	223	return parse_error;
229	p += 3;	224	p += 3;
230	cat = ID_SUBCLASS;	225	cat = ID_SUBCLASS;
231	id3 = id4 = 0;	226	id3 = id4 = 0;
232	break;	227	break;
233	default:	228	default:
234	return parse_error;	229	return parse_error;
235	} else if (nest == 2) /* Nesting level 2 */	230	} else if (nest == 2) /* Nesting level 2 */
236	switch (cat) {	231	switch (cat) {
237	case ID_DEVICE:	232	case ID_DEVICE:
238	case ID_SUBSYSTEM:	233	case ID_SUBSYSTEM:
239	if ((id3 = id_hex(p, 4)) < 0	234	if ((id3 = id_hex(p, 4)) < 0 \|\| !id_white_p(p[4])
240	\|\| !id_white_p(p[4])	-
241	\|\| (id4 = id_hex(p + 5, 4)) < 0	235	\|\| (id4 = id_hex(p + 5, 4)) < 0 \|\| !id_white_p(p[9]))
242	\|\| !id_white_p(p[9]))	-
243	return parse_error;	236	return parse_error;
244	p += 10;	237	p += 10;
245	cat = ID_SUBSYSTEM;	238	cat = ID_SUBSYSTEM;
246	break;	239	break;
247	case ID_CLASS:	240	case ID_CLASS:
248	case ID_SUBCLASS:	241	case ID_SUBCLASS:
249	case ID_PROGIF:	242	case ID_PROGIF:
250	if ((id3 = id_hex(p, 2)) < 0	243	if ((id3 = id_hex(p, 2)) < 0 \|\| !id_white_p(p[2]))
251	\|\| !id_white_p(p[2]))	-
252	return parse_error;	244	return parse_error;
253	p += 3;	245	p += 3;
254	cat = ID_PROGIF;	246	cat = ID_PROGIF;
255	id4 = 0;	247	id4 = 0;
256	break;	248	break;
257	default:	249	default:
258	return parse_error;	250	return parse_error;
259	} else /* Nesting level 3 or more */	251	} else /* Nesting level 3 or more */
260	return parse_error;	252	return parse_error;
261	while (id_white_p(*p))	253	while (id_white_p(*p))
262	p++;	254	p++;
263	if (!*p)	255	if (!*p)
264	return parse_error;	256	return parse_error;
265	if (id_insert(a, cat, id1, id2, id3, id4, p))	257	if (id_insert(a, cat, id1, id2, id3, id4, p))
266	return "Duplicate entry";	258	return "Duplicate entry";
267	}	259	}
268	return NULL;	260	return NULL;
269	}	261	}
270		262
271	int pci_load_name_list(struct pci_access *a)	263	int pci_load_name_list(struct pci_access *a)
272	{	264	{
273	int lino;	265	int lino;
274	const char *err;	266	const char *err;
275		267
276	pci_free_name_list(a);	268	pci_free_name_list(a);
277	a->id_hash = pci_malloc(a, sizeof(struct id_entry ) HASH_SIZE);	269	a->id_hash = pci_malloc(a, sizeof(struct id_entry ) HASH_SIZE);
278	bzero(a->id_hash, sizeof(struct id_entry ) HASH_SIZE);	270	bzero(a->id_hash, sizeof(struct id_entry ) HASH_SIZE);
279	err = id_parse_list(a, &lino);	271	err = id_parse_list(a, &lino);
280	if (err)	272	if (err)
281	a->error("%s at %s, element %d\n", err, "pci_ids.h", lino);	273	a->error("%s at %s, element %d\n", err, "pci_ids.h", lino);
282	return 1;	274	return 1;
283	}	275	}
284		276
285	void pci_free_name_list(struct pci_access *a)	277	void pci_free_name_list(struct pci_access *a)
286	{	278	{
287	pci_mfree(a->id_hash);	279	pci_mfree(a->id_hash);
288	a->id_hash = NULL;	280	a->id_hash = NULL;
289	while (a->current_id_bucket) {	281	while (a->current_id_bucket) {
290	struct id_bucket *buck = a->current_id_bucket;	282	struct id_bucket *buck = a->current_id_bucket;
291	a->current_id_bucket = buck->next;	283	a->current_id_bucket = buck->next;
292	pci_mfree(buck);	284	pci_mfree(buck);
293	}	285	}
294	}	286	}
295		287
296	static struct id_entry id_lookup_subsys(struct pci_access a, int iv,	288	static struct id_entry id_lookup_subsys(struct pci_access a, int iv,
297	int id, int isv, int isd)	289	int id, int isv, int isd)
298	{	290	{
299	struct id_entry *d = NULL;	291	struct id_entry *d = NULL;
300	if (iv > 0 && id > 0) /* Per-device lookup */	292	if (iv > 0 && id > 0) /* Per-device lookup */
301	d = id_lookup(a, ID_SUBSYSTEM, iv, id, isv, isd);	293	d = id_lookup(a, ID_SUBSYSTEM, iv, id, isv, isd);
302	if (!d) /* Generic lookup */	294	if (!d) /* Generic lookup */
303	d = id_lookup(a, ID_GEN_SUBSYSTEM, isv, isd, 0, 0);	295	d = id_lookup(a, ID_GEN_SUBSYSTEM, isv, isd, 0, 0);
304	if (!d && iv == isv && id == isd) /* Check for subsystem == device */	296	if (!d && iv == isv && id == isd) /* Check for subsystem == device */
305	d = id_lookup(a, ID_DEVICE, iv, id, 0, 0);	297	d = id_lookup(a, ID_DEVICE, iv, id, 0, 0);
306	return d;	298	return d;
307	}	299	}
308		300
309	char pci_lookup_name(struct pci_access a, char *buf, int size, int flags,	301	char pci_lookup_name(struct pci_access a, char *buf, int size, int flags,
310	...)	302	...)
311	{	303	{
312	va_list args;	304	va_list args;
313	int num, res, synth;	305	int num, res, synth;
314	struct id_entry v, d, cls, pif;	306	struct id_entry v, d, cls, pif;
315	int iv, id, isv, isd, icls, ipif;	307	int iv, id, isv, isd, icls, ipif;
316		308
317	va_start(args, flags);	309	va_start(args, flags);
318		310
319	num = 0;	311	num = 0;
320	if ((flags & PCI_LOOKUP_NUMERIC) \|\| a->numeric_ids) {	312	if ((flags & PCI_LOOKUP_NUMERIC) \|\| a->numeric_ids) {
321	flags &= ~PCI_LOOKUP_NUMERIC;	313	flags &= ~PCI_LOOKUP_NUMERIC;
322	num = 1;	314	num = 1;
323	} else if (!a->id_hash) {	315	} else if (!a->id_hash) {
324	if (!pci_load_name_list(a))	316	if (!pci_load_name_list(a))
325	num = a->numeric_ids = 1;	317	num = a->numeric_ids = 1;
326	}	318	}
327		319
328	if (flags & PCI_LOOKUP_NO_NUMBERS) {	320	if (flags & PCI_LOOKUP_NO_NUMBERS) {
329	flags &= ~PCI_LOOKUP_NO_NUMBERS;	321	flags &= ~PCI_LOOKUP_NO_NUMBERS;
330	synth = 0;	322	synth = 0;
331	if (num)	323	if (num)
332	return NULL;	324	return NULL;
333	} else	325	} else
334	synth = 1;	326	synth = 1;
335		327
336	switch (flags) {	328	switch (flags) {
337	case PCI_LOOKUP_VENDOR:	329	case PCI_LOOKUP_VENDOR:
338	iv = va_arg(args, int);	330	iv = va_arg(args, int);
339	if (num)	331	if (num)
340	res = snprintf(buf, size, "%04x", iv);	332	res = snprintf(buf, size, "%04x", iv);
341	else if (v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0))	333	else if (v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0))
342	return (char *) v->name;	334	return (char *) v->name;
343	else	335	else
344	res =	-
345	snprintf(buf, size, "Unknown vendor %04x", iv);	336	res = snprintf(buf, size, "Unknown vendor %04x", iv);
346	break;	337	break;
347	case PCI_LOOKUP_DEVICE:	338	case PCI_LOOKUP_DEVICE:
348	iv = va_arg(args, int);	339	iv = va_arg(args, int);
349	id = va_arg(args, int);	340	id = va_arg(args, int);
350	if (num)	341	if (num)
351	res = snprintf(buf, size, "%04x", id);	342	res = snprintf(buf, size, "%04x", id);
352	else if (d = id_lookup(a, ID_DEVICE, iv, id, 0, 0))	343	else if (d = id_lookup(a, ID_DEVICE, iv, id, 0, 0))
353	return (char *) d->name;	344	return (char *) d->name;
354	else if (synth)	345	else if (synth)
355	res =	-
356	snprintf(buf, size, "Unknown device %04x", id);	346	res = snprintf(buf, size, "Unknown device %04x", id);
357	else	347	else
358	return NULL;	348	return NULL;
359	break;	349	break;
360	case PCI_LOOKUP_VENDOR \| PCI_LOOKUP_DEVICE:	350	case PCI_LOOKUP_VENDOR \| PCI_LOOKUP_DEVICE:
361	iv = va_arg(args, int);	351	iv = va_arg(args, int);
362	id = va_arg(args, int);	352	id = va_arg(args, int);
363	if (num)	353	if (num)
364	res = snprintf(buf, size, "%04x:%04x", iv, id);	354	res = snprintf(buf, size, "%04x:%04x", iv, id);
365	else {	355	else {
366	v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0);	356	v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0);
367	d = id_lookup(a, ID_DEVICE, iv, id, 0, 0);	357	d = id_lookup(a, ID_DEVICE, iv, id, 0, 0);
368	if (v && d)	358	if (v && d)
369	res =	-
370	snprintf(buf, size, "%s %s", v->name,	359	res = snprintf(buf, size, "%s %s", v->name,
371	d->name);	360	d->name);
372	else if (!synth)	361	else if (!synth)
373	return NULL;	362	return NULL;
374	else if (!v)	363	else if (!v)
375	res =	-
376	snprintf(buf, size,	-
377	"Unknown device %04x:%04x",	364	res = snprintf(buf, size, "Unknown device %04x:%04x", iv, id);
378	iv, id);	-
379	else /* !d */	365	else /* !d */
380	res =	-
381	snprintf(buf, size,	-
382	"%s Unknown device %04x",	366	res = snprintf(buf, size, "%s Unknown device %04x", v->name, id);
383	v->name, id);	-
384	}	367	}
385	break;	368	break;
386	case PCI_LOOKUP_SUBSYSTEM \| PCI_LOOKUP_VENDOR:	369	case PCI_LOOKUP_SUBSYSTEM \| PCI_LOOKUP_VENDOR:
387	isv = va_arg(args, int);	370	isv = va_arg(args, int);
388	if (num)	371	if (num)
389	res = snprintf(buf, size, "%04x", isv);	372	res = snprintf(buf, size, "%04x", isv);
390	else if (v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0))	373	else if (v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0))
391	return (char *) v->name;	374	return (char *) v->name;
392	else if (synth)	375	else if (synth)
393	res =	-
394	snprintf(buf, size, "Unknown vendor %04x",	376	res = snprintf(buf, size, "Unknown vendor %04x", isv);
395	isv);	-
396	else	377	else
397	return NULL;	378	return NULL;
398	break;	379	break;
399	case PCI_LOOKUP_SUBSYSTEM \| PCI_LOOKUP_DEVICE:	380	case PCI_LOOKUP_SUBSYSTEM \| PCI_LOOKUP_DEVICE:
400	iv = va_arg(args, int);	381	iv = va_arg(args, int);
401	id = va_arg(args, int);	382	id = va_arg(args, int);
402	isv = va_arg(args, int);	383	isv = va_arg(args, int);
403	isd = va_arg(args, int);	384	isd = va_arg(args, int);
404	if (num)	385	if (num)
405	res = snprintf(buf, size, "%04x", isd);	386	res = snprintf(buf, size, "%04x", isd);
406	else if (d = id_lookup_subsys(a, iv, id, isv, isd))	387	else if (d = id_lookup_subsys(a, iv, id, isv, isd))
407	return (char *) d->name;	388	return (char *) d->name;
408	else if (synth)	389	else if (synth)
409	res =	-
410	snprintf(buf, size, "Unknown device %04x",	390	res = snprintf(buf, size, "Unknown device %04x", isd);
411	isd);	-
412	else	391	else
413	return NULL;	392	return NULL;
414	break;	393	break;
415	case PCI_LOOKUP_VENDOR \| PCI_LOOKUP_DEVICE \| PCI_LOOKUP_SUBSYSTEM:	394	case PCI_LOOKUP_VENDOR \| PCI_LOOKUP_DEVICE \| PCI_LOOKUP_SUBSYSTEM:
416	iv = va_arg(args, int);	395	iv = va_arg(args, int);
417	id = va_arg(args, int);	396	id = va_arg(args, int);
418	isv = va_arg(args, int);	397	isv = va_arg(args, int);
419	isd = va_arg(args, int);	398	isd = va_arg(args, int);
420	if (num)	399	if (num)
421	res = snprintf(buf, size, "%04x:%04x", isv, isd);	400	res = snprintf(buf, size, "%04x:%04x", isv, isd);
422	else {	401	else {
423	v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0);	402	v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0);
424	d = id_lookup_subsys(a, iv, id, isv, isd);	403	d = id_lookup_subsys(a, iv, id, isv, isd);
425	if (v && d)	404	if (v && d)
426	res =	-
427	snprintf(buf, size, "%s %s", v->name,	405	res = snprintf(buf, size, "%s %s", v->name, d->name);
428	d->name);	-
429	else if (!synth)	406	else if (!synth)
430	return NULL;	407	return NULL;
431	else if (!v)	408	else if (!v)
432	res =	-
433	snprintf(buf, size,	-
434	"Unknown device %04x:%04x",	409	res = snprintf(buf, size, "Unknown device %04x:%04x", isv, isd);
435	isv, isd);	-
436	else /* !d */	410	else /* !d */
437	res =	-
438	snprintf(buf, size,	-
439	"%s Unknown device %04x",	411	res = snprintf(buf, size, "%s Unknown device %04x", v->name, isd);
440	v->name, isd);	-
441	}	412	}
442	break;	413	break;
443	case PCI_LOOKUP_CLASS:	414	case PCI_LOOKUP_CLASS:
444	icls = va_arg(args, int);	415	icls = va_arg(args, int);
445	if (num)	416	if (num)
446	res = snprintf(buf, size, "%04x", icls);	417	res = snprintf(buf, size, "%04x", icls);
447	else if (cls =	-
448	id_lookup(a, ID_SUBCLASS, icls >> 8, icls & 0xff,	418	else if (cls = id_lookup(a, ID_SUBCLASS, icls >> 8, icls & 0xff, 0, 0))
449	0, 0))	-
450	return (char *) cls->name;	419	return (char *) cls->name;
451	else if (cls = id_lookup(a, ID_CLASS, icls, 0, 0, 0))	420	else if (cls = id_lookup(a, ID_CLASS, icls, 0, 0, 0))
452	res =	-
453	snprintf(buf, size, "%s [%04x]", cls->name,	421	res = snprintf(buf, size, "%s [%04x]", cls->name, icls);
454	icls);	-
455	else if (synth)	422	else if (synth)
456	res = snprintf(buf, size, "Class %04x", icls);	423	res = snprintf(buf, size, "Class %04x", icls);
457	else	424	else
458	return NULL;	425	return NULL;
459	break;	426	break;
460	case PCI_LOOKUP_PROGIF:	427	case PCI_LOOKUP_PROGIF:
461	icls = va_arg(args, int);	428	icls = va_arg(args, int);
462	ipif = va_arg(args, int);	429	ipif = va_arg(args, int);
463	if (num)	430	if (num)
464	res = snprintf(buf, size, "%02x", ipif);	431	res = snprintf(buf, size, "%02x", ipif);
465	else if (pif =	-
466	id_lookup(a, ID_PROGIF, icls >> 8, icls & 0xff,	432	else if (pif = id_lookup(a, ID_PROGIF, icls >> 8, icls & 0xff, ipif, 0))
467	ipif, 0))	-
468	return (char *) pif->name;	433	return (char *) pif->name;
469	else if (icls == 0x0101 && !(ipif & 0x70)) {	434	else if (icls == 0x0101 && !(ipif & 0x70)) {
470	/* IDE controllers have complex prog-if semantics */	435	/* IDE controllers have complex prog-if semantics */
471	res = snprintf(buf, size, "%s%s%s%s%s",	436	res = snprintf(buf, size, "%s%s%s%s%s",
472	(ipif & 0x80) ? "Master " : "",	437	(ipif & 0x80) ? "Master " : "",
473	(ipif & 0x08) ? "SecP " : "",	438	(ipif & 0x08) ? "SecP " : "",
474	(ipif & 0x04) ? "SecO " : "",	439	(ipif & 0x04) ? "SecO " : "",
475	(ipif & 0x02) ? "PriP " : "",	440	(ipif & 0x02) ? "PriP " : "",
476	(ipif & 0x01) ? "PriO " : "");	441	(ipif & 0x01) ? "PriO " : "");
477	if (res > 0 && res < size)	442	if (res > 0 && res < size)
478	buf[--res] = 0;	443	buf[--res] = 0;
479	} else if (synth)	444	} else if (synth)
480	res = snprintf(buf, size, "ProgIf %02x", ipif);	445	res = snprintf(buf, size, "ProgIf %02x", ipif);
481	else	446	else
482	return NULL;	447	return NULL;
483	break;	448	break;
484	default:	449	default:
485	return "<pci_lookup_name: invalid request>";	450	return "<pci_lookup_name: invalid request>";
486	}	451	}
487	if (res < 0 \|\| res >= size)	452	if (res < 0 \|\| res >= size)
488	return "<pci_lookup_name: buffer too small>";	453	return "<pci_lookup_name: buffer too small>";
489	else	454	else
490	return buf;	455	return buf;
491	}	456	}
492		457

Subversion Repositories HelenOS

(root)/uspace/trunk/pci/libpci/names.c – Rev 1302 → 1324