Context Navigation

source: mainline/uspace/srv/hw/bus/pci/libpci/names.c@ 6ef2c11

Visit:

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export

Last change on this file since 6ef2c11 was b3d513f, checked in by Martin Decky <martin@…>, 15 years ago
restructure servers into a more well-arranged hierarchy
Property mode set to `100644`
File size: 11.0 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: