Subversion Repositories HelenOS

Rev

Rev 4264 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1301 jermar 1
/*
2
 *	The PCI Library -- ID to Name Translation
3
 *
4
 *	Copyright (c) 1997--2005 Martin Mares <mj@ucw.cz>
5
 *
1324 jermar 6
 *	May 8, 2006 - Modified and ported to HelenOS by Jakub Jermar.
1301 jermar 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 {
1302 jermar 21
	struct id_entry *next;
22
	u32 id12, id34;
23
	byte cat;
24
	byte name[1];
1301 jermar 25
};
26
 
27
enum id_entry_type {
1302 jermar 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
1301 jermar 36
};
37
 
38
struct id_bucket {
1302 jermar 39
	struct id_bucket *next;
40
	unsigned int full;
1301 jermar 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 {
1302 jermar 51
	struct id_bucket *next;
52
	unsigned int full;
1301 jermar 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
{
1302 jermar 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;
1301 jermar 71
}
72
 
73
static inline u32 id_pair(unsigned int x, unsigned int y)
74
{
1302 jermar 75
	return ((x << 16) | y);
1301 jermar 76
}
77
 
78
static inline unsigned int id_hash(int cat, u32 id12, u32 id34)
79
{
1302 jermar 80
	unsigned int h;
1301 jermar 81
 
1302 jermar 82
	h = id12 ^ (id34 << 3) ^ (cat << 5);
83
	return h % HASH_SIZE;
1301 jermar 84
}
85
 
1302 jermar 86
static struct id_entry *id_lookup(struct pci_access *a, int cat, int id1,
87
				  int id2, int id3, int id4)
1301 jermar 88
{
1302 jermar 89
	struct id_entry *n;
90
	u32 id12 = id_pair(id1, id2);
91
	u32 id34 = id_pair(id3, id4);
1301 jermar 92
 
1302 jermar 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;
1301 jermar 97
}
98
 
1302 jermar 99
static int id_insert(struct pci_access *a, int cat, int id1, int id2,
100
		     int id3, int id4, byte * text)
1301 jermar 101
{
1302 jermar 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];
4264 svoboda 106
	int len = str_size((char *) text);
1301 jermar 107
 
1302 jermar 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;
1301 jermar 120
}
121
 
1302 jermar 122
static int id_hex(byte * p, int cnt)
1301 jermar 123
{
1302 jermar 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;
1301 jermar 138
}
139
 
140
static inline int id_white_p(int c)
141
{
1302 jermar 142
	return (c == ' ') || (c == '\t');
1301 jermar 143
}
144
 
145
static const char *id_parse_list(struct pci_access *a, int *lino)
146
{
1302 jermar 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";
4682 svoboda 153
	size_t i;
1301 jermar 154
 
1302 jermar 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;
1301 jermar 164
 
1302 jermar 165
		p = line;
166
		while (id_white_p(*p))
167
			p++;
168
		if (!*p || *p == '#')
169
			continue;
1301 jermar 170
 
1302 jermar 171
		p = line;
172
		while (*p == '\t')
173
			p++;
174
		nest = p - line;
1301 jermar 175
 
1302 jermar 176
		if (!nest) {	/* Top-level entries */
177
			if (p[0] == 'C' && p[1] == ' ') {	/* Class block */
1324 jermar 178
				if ((id1 = id_hex(p + 2, 2)) < 0 || !id_white_p(p[4]))
1302 jermar 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
 
1324 jermar 194
				if ((id1 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
1302 jermar 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:
1324 jermar 207
				if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
1302 jermar 208
					return parse_error;
209
				p += 5;
210
				cat = ID_DEVICE;
211
				id3 = id4 = 0;
212
				break;
213
			case ID_GEN_SUBSYSTEM:
1324 jermar 214
				if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
1302 jermar 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:
1324 jermar 222
				if ((id2 = id_hex(p, 2)) < 0 || !id_white_p(p[2]))
1302 jermar 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:
1324 jermar 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]))
1302 jermar 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:
1324 jermar 243
				if ((id3 = id_hex(p, 2)) < 0 || !id_white_p(p[2]))
1302 jermar 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";
1301 jermar 259
	}
1302 jermar 260
	return NULL;
1301 jermar 261
}
262
 
1302 jermar 263
int pci_load_name_list(struct pci_access *a)
1301 jermar 264
{
1302 jermar 265
	int lino;
266
	const char *err;
1301 jermar 267
 
1302 jermar 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;
1301 jermar 275
}
276
 
1302 jermar 277
void pci_free_name_list(struct pci_access *a)
1301 jermar 278
{
1302 jermar 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
	}
1301 jermar 286
}
287
 
1302 jermar 288
static struct id_entry *id_lookup_subsys(struct pci_access *a, int iv,
289
					 int id, int isv, int isd)
1301 jermar 290
{
1302 jermar 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;
1301 jermar 299
}
300
 
1302 jermar 301
char *pci_lookup_name(struct pci_access *a, char *buf, int size, int flags,
302
		      ...)
1301 jermar 303
{
1302 jermar 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;
1301 jermar 308
 
1302 jermar 309
	va_start(args, flags);
1301 jermar 310
 
1302 jermar 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;
318
	}
1301 jermar 319
 
1302 jermar 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;
1301 jermar 327
 
1302 jermar 328
	switch (flags) {
329
	case PCI_LOOKUP_VENDOR:
330
		iv = va_arg(args, int);
331
		if (num)
332
			res = snprintf(buf, size, "%04x", iv);
4682 svoboda 333
		else if ((v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0)) != 0)
1302 jermar 334
			return (char *) v->name;
335
		else
1324 jermar 336
			res = snprintf(buf, size, "Unknown vendor %04x", iv);
1302 jermar 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);
4682 svoboda 343
		else if ((d = id_lookup(a, ID_DEVICE, iv, id, 0, 0)) != 0)
1302 jermar 344
			return (char *) d->name;
345
		else if (synth)
1324 jermar 346
			res = snprintf(buf, size, "Unknown device %04x", id);
1302 jermar 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)
1324 jermar 359
				res = snprintf(buf, size, "%s %s", v->name,
1302 jermar 360
					     d->name);
361
			else if (!synth)
362
				return NULL;
363
			else if (!v)
1324 jermar 364
				res = snprintf(buf, size, "Unknown device %04x:%04x", iv, id);
1302 jermar 365
			else	/* !d */
1324 jermar 366
				res = snprintf(buf, size, "%s Unknown device %04x", v->name, id);
1302 jermar 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);
4682 svoboda 373
		else if ((v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0)) != 0)
1302 jermar 374
			return (char *) v->name;
375
		else if (synth)
1324 jermar 376
			res = snprintf(buf, size, "Unknown vendor %04x", isv);
1302 jermar 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);
4682 svoboda 387
		else if ((d = id_lookup_subsys(a, iv, id, isv, isd)) != 0)
1302 jermar 388
			return (char *) d->name;
389
		else if (synth)
1324 jermar 390
			res = snprintf(buf, size, "Unknown device %04x", isd);
1302 jermar 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)
1324 jermar 405
				res = snprintf(buf, size, "%s %s", v->name, d->name);
1302 jermar 406
			else if (!synth)
407
				return NULL;
408
			else if (!v)
1324 jermar 409
				res = snprintf(buf, size, "Unknown device %04x:%04x", isv, isd);
1302 jermar 410
			else	/* !d */
1324 jermar 411
				res = snprintf(buf, size, "%s Unknown device %04x", v->name, isd);
1302 jermar 412
		}
413
		break;
414
	case PCI_LOOKUP_CLASS:
415
		icls = va_arg(args, int);
416
		if (num)
417
			res = snprintf(buf, size, "%04x", icls);
4682 svoboda 418
		else if ((cls = id_lookup(a, ID_SUBCLASS, icls >> 8, icls & 0xff, 0, 0)) != 0)
1302 jermar 419
			return (char *) cls->name;
4682 svoboda 420
		else if ((cls = id_lookup(a, ID_CLASS, icls, 0, 0, 0)) != 0)
1324 jermar 421
			res = snprintf(buf, size, "%s [%04x]", cls->name, icls);
1302 jermar 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);
4682 svoboda 432
		else if ((pif = id_lookup(a, ID_PROGIF, icls >> 8, icls & 0xff, ipif, 0)) != 0)
1302 jermar 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>";
1301 jermar 451
	}
1302 jermar 452
	if (res < 0 || res >= size)
453
		return "<pci_lookup_name: buffer too small>";
454
	else
455
		return buf;
1301 jermar 456
}