source: mainline/uspace/srv/pci/libpci/names.c@ ce7311fc

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since ce7311fc was 00acd66, checked in by Jakub Jermar <jakub@…>, 18 years ago

New, better-structured, directory layout for uspace.
  • Property mode set to 100644
File size: 11.0 KB
Line 
1/*
2 * The PCI Library -- ID to Name Translation
3 *
4 * Copyright (c) 1997--2005 Martin Mares <mj@ucw.cz>
5 *
6 * May 8, 2006 - Modified and ported to HelenOS by Jakub 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
20struct id_entry {
21 struct id_entry *next;
22 u32 id12, id34;
23 byte cat;
24 byte name[1];
25};
26
27enum id_entry_type {
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
36};
37
38struct id_bucket {
39 struct id_bucket *next;
40 unsigned int full;
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
50union id_align {
51 struct id_bucket *next;
52 unsigned int full;
53};
54#define BUCKET_ALIGNMENT sizeof(union id_align)
55#endif
56#define BUCKET_ALIGN(n) ((n)+BUCKET_ALIGNMENT-(n)%BUCKET_ALIGNMENT)
57
58static void *id_alloc(struct pci_access *a, unsigned int size)
59{
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;
71}
72
73static inline u32 id_pair(unsigned int x, unsigned int y)
74{
75 return ((x << 16) | y);
76}
77
78static inline unsigned int id_hash(int cat, u32 id12, u32 id34)
79{
80 unsigned int h;
81
82 h = id12 ^ (id34 << 3) ^ (cat << 5);
83 return h % HASH_SIZE;
84}
85
86static struct id_entry *id_lookup(struct pci_access *a, int cat, int id1,
87 int id2, int id3, int id4)
88{
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;
97}
98
99static int id_insert(struct pci_access *a, int cat, int id1, int id2,
100 int id3, int id4, byte * text)
101{
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];
106 int len = strlen((char *) text);
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;
120}
121
122static int id_hex(byte * p, int cnt)
123{
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;
138}
139
140static inline int id_white_p(int c)
141{
142 return (c == ' ') || (c == '\t');
143}
144
145static const char *id_parse_list(struct pci_access *a, int *lino)
146{
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";
153 int i;
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 */
178 if ((id1 = id_hex(p + 2, 2)) < 0 || !id_white_p(p[4]))
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
194 if ((id1 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
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:
207 if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
208 return parse_error;
209 p += 5;
210 cat = ID_DEVICE;
211 id3 = id4 = 0;
212 break;
213 case ID_GEN_SUBSYSTEM:
214 if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
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:
222 if ((id2 = id_hex(p, 2)) < 0 || !id_white_p(p[2]))
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:
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]))
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:
243 if ((id3 = id_hex(p, 2)) < 0 || !id_white_p(p[2]))
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";
259 }
260 return NULL;
261}
262
263int pci_load_name_list(struct pci_access *a)
264{
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;
275}
276
277void pci_free_name_list(struct pci_access *a)
278{
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 }
286}
287
288static struct id_entry *id_lookup_subsys(struct pci_access *a, int iv,
289 int id, int isv, int isd)
290{
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;
299}
300
301char *pci_lookup_name(struct pci_access *a, char *buf, int size, int flags,
302 ...)
303{
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;
318 }
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);
333 else if (v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0))
334 return (char *) v->name;
335 else
336 res = snprintf(buf, size, "Unknown vendor %04x", iv);
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);
343 else if (d = id_lookup(a, ID_DEVICE, iv, id, 0, 0))
344 return (char *) d->name;
345 else if (synth)
346 res = snprintf(buf, size, "Unknown device %04x", id);
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)
359 res = snprintf(buf, size, "%s %s", v->name,
360 d->name);
361 else if (!synth)
362 return NULL;
363 else if (!v)
364 res = snprintf(buf, size, "Unknown device %04x:%04x", iv, id);
365 else /* !d */
366 res = snprintf(buf, size, "%s Unknown device %04x", v->name, id);
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);
373 else if (v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0))
374 return (char *) v->name;
375 else if (synth)
376 res = snprintf(buf, size, "Unknown vendor %04x", isv);
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);
387 else if (d = id_lookup_subsys(a, iv, id, isv, isd))
388 return (char *) d->name;
389 else if (synth)
390 res = snprintf(buf, size, "Unknown device %04x", isd);
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)
405 res = snprintf(buf, size, "%s %s", v->name, d->name);
406 else if (!synth)
407 return NULL;
408 else if (!v)
409 res = snprintf(buf, size, "Unknown device %04x:%04x", isv, isd);
410 else /* !d */
411 res = snprintf(buf, size, "%s Unknown device %04x", v->name, isd);
412 }
413 break;
414 case PCI_LOOKUP_CLASS:
415 icls = va_arg(args, int);
416 if (num)
417 res = snprintf(buf, size, "%04x", icls);
418 else if (cls = id_lookup(a, ID_SUBCLASS, icls >> 8, icls & 0xff, 0, 0))
419 return (char *) cls->name;
420 else if (cls = id_lookup(a, ID_CLASS, icls, 0, 0, 0))
421 res = snprintf(buf, size, "%s [%04x]", cls->name, icls);
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);
432 else if (pif = id_lookup(a, ID_PROGIF, icls >> 8, icls & 0xff, ipif, 0))
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>";
451 }
452 if (res < 0 || res >= size)
453 return "<pci_lookup_name: buffer too small>";
454 else
455 return buf;
456}
Note: See TracBrowser for help on using the repository browser.