Subversion Repositories HelenOS-historic

Rev

Rev 1301 | Go to most recent revision | 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
 *
6
 *  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
 
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];
106
    int len = strlen((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";
153
    int 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 */
178
                if ((id1 = id_hex(p + 2, 2)) < 0
179
                    || !id_white_p(p[4]))
180
                    return parse_error;
181
                cat = ID_CLASS;
182
                p += 5;
183
            } else if (p[0] == 'S' && p[1] == ' ') {    /* Generic subsystem block */
184
                if ((id1 = id_hex(p + 2, 4)) < 0 || p[6])
185
                    return parse_error;
186
                if (!id_lookup(a, ID_VENDOR, id1, 0, 0, 0))
187
                    return "Vendor does not exist";
188
                cat = ID_GEN_SUBSYSTEM;
189
                continue;
190
            } else if (p[0] >= 'A' && p[0] <= 'Z' && p[1] == ' ') { /* Unrecognized block (RFU) */
191
                cat = ID_UNKNOWN;
192
                continue;
193
            } else {    /* Vendor ID */
194
 
195
                if ((id1 = id_hex(p, 4)) < 0
196
                    || !id_white_p(p[4]))
197
                    return parse_error;
198
                cat = ID_VENDOR;
199
                p += 5;
200
            }
201
            id2 = id3 = id4 = 0;
202
        } else if (cat == ID_UNKNOWN)   /* Nested entries in RFU blocks are skipped */
203
            continue;
204
        else if (nest == 1) /* Nesting level 1 */
205
            switch (cat) {
206
            case ID_VENDOR:
207
            case ID_DEVICE:
208
            case ID_SUBSYSTEM:
209
                if ((id2 = id_hex(p, 4)) < 0
210
                    || !id_white_p(p[4]))
211
                    return parse_error;
212
                p += 5;
213
                cat = ID_DEVICE;
214
                id3 = id4 = 0;
215
                break;
216
            case ID_GEN_SUBSYSTEM:
217
                if ((id2 = id_hex(p, 4)) < 0
218
                    || !id_white_p(p[4]))
219
                    return parse_error;
220
                p += 5;
221
                id3 = id4 = 0;
222
                break;
223
            case ID_CLASS:
224
            case ID_SUBCLASS:
225
            case ID_PROGIF:
226
                if ((id2 = id_hex(p, 2)) < 0
227
                    || !id_white_p(p[2]))
228
                    return parse_error;
229
                p += 3;
230
                cat = ID_SUBCLASS;
231
                id3 = id4 = 0;
232
                break;
233
            default:
234
                return parse_error;
235
        } else if (nest == 2)   /* Nesting level 2 */
236
            switch (cat) {
237
            case ID_DEVICE:
238
            case ID_SUBSYSTEM:
239
                if ((id3 = id_hex(p, 4)) < 0
240
                    || !id_white_p(p[4])
241
                    || (id4 = id_hex(p + 5, 4)) < 0
242
                    || !id_white_p(p[9]))
243
                    return parse_error;
244
                p += 10;
245
                cat = ID_SUBSYSTEM;
246
                break;
247
            case ID_CLASS:
248
            case ID_SUBCLASS:
249
            case ID_PROGIF:
250
                if ((id3 = id_hex(p, 2)) < 0
251
                    || !id_white_p(p[2]))
252
                    return parse_error;
253
                p += 3;
254
                cat = ID_PROGIF;
255
                id4 = 0;
256
                break;
257
            default:
258
                return parse_error;
259
        } else      /* Nesting level 3 or more */
260
            return parse_error;
261
        while (id_white_p(*p))
262
            p++;
263
        if (!*p)
264
            return parse_error;
265
        if (id_insert(a, cat, id1, id2, id3, id4, p))
266
            return "Duplicate entry";
1301 jermar 267
    }
1302 jermar 268
    return NULL;
1301 jermar 269
}
270
 
1302 jermar 271
int pci_load_name_list(struct pci_access *a)
1301 jermar 272
{
1302 jermar 273
    int lino;
274
    const char *err;
1301 jermar 275
 
1302 jermar 276
    pci_free_name_list(a);
277
    a->id_hash = pci_malloc(a, sizeof(struct id_entry *) * HASH_SIZE);
278
    bzero(a->id_hash, sizeof(struct id_entry *) * HASH_SIZE);
279
    err = id_parse_list(a, &lino);
280
    if (err)
281
        a->error("%s at %s, element %d\n", err, "pci_ids.h", lino);
282
    return 1;
1301 jermar 283
}
284
 
1302 jermar 285
void pci_free_name_list(struct pci_access *a)
1301 jermar 286
{
1302 jermar 287
    pci_mfree(a->id_hash);
288
    a->id_hash = NULL;
289
    while (a->current_id_bucket) {
290
        struct id_bucket *buck = a->current_id_bucket;
291
        a->current_id_bucket = buck->next;
292
        pci_mfree(buck);
293
    }
1301 jermar 294
}
295
 
1302 jermar 296
static struct id_entry *id_lookup_subsys(struct pci_access *a, int iv,
297
                     int id, int isv, int isd)
1301 jermar 298
{
1302 jermar 299
    struct id_entry *d = NULL;
300
    if (iv > 0 && id > 0)   /* Per-device lookup */
301
        d = id_lookup(a, ID_SUBSYSTEM, iv, id, isv, isd);
302
    if (!d)         /* Generic lookup */
303
        d = id_lookup(a, ID_GEN_SUBSYSTEM, isv, isd, 0, 0);
304
    if (!d && iv == isv && id == isd)   /* Check for subsystem == device */
305
        d = id_lookup(a, ID_DEVICE, iv, id, 0, 0);
306
    return d;
1301 jermar 307
}
308
 
1302 jermar 309
char *pci_lookup_name(struct pci_access *a, char *buf, int size, int flags,
310
              ...)
1301 jermar 311
{
1302 jermar 312
    va_list args;
313
    int num, res, synth;
314
    struct id_entry *v, *d, *cls, *pif;
315
    int iv, id, isv, isd, icls, ipif;
1301 jermar 316
 
1302 jermar 317
    va_start(args, flags);
1301 jermar 318
 
1302 jermar 319
    num = 0;
320
    if ((flags & PCI_LOOKUP_NUMERIC) || a->numeric_ids) {
321
        flags &= ~PCI_LOOKUP_NUMERIC;
322
        num = 1;
323
    } else if (!a->id_hash) {
324
        if (!pci_load_name_list(a))
325
            num = a->numeric_ids = 1;
326
    }
1301 jermar 327
 
1302 jermar 328
    if (flags & PCI_LOOKUP_NO_NUMBERS) {
329
        flags &= ~PCI_LOOKUP_NO_NUMBERS;
330
        synth = 0;
331
        if (num)
332
            return NULL;
333
    } else
334
        synth = 1;
1301 jermar 335
 
1302 jermar 336
    switch (flags) {
337
    case PCI_LOOKUP_VENDOR:
338
        iv = va_arg(args, int);
339
        if (num)
340
            res = snprintf(buf, size, "%04x", iv);
341
        else if (v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0))
342
            return (char *) v->name;
343
        else
344
            res =
345
                snprintf(buf, size, "Unknown vendor %04x", iv);
346
        break;
347
    case PCI_LOOKUP_DEVICE:
348
        iv = va_arg(args, int);
349
        id = va_arg(args, int);
350
        if (num)
351
            res = snprintf(buf, size, "%04x", id);
352
        else if (d = id_lookup(a, ID_DEVICE, iv, id, 0, 0))
353
            return (char *) d->name;
354
        else if (synth)
355
            res =
356
                snprintf(buf, size, "Unknown device %04x", id);
357
        else
358
            return NULL;
359
        break;
360
    case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE:
361
        iv = va_arg(args, int);
362
        id = va_arg(args, int);
363
        if (num)
364
            res = snprintf(buf, size, "%04x:%04x", iv, id);
365
        else {
366
            v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0);
367
            d = id_lookup(a, ID_DEVICE, iv, id, 0, 0);
368
            if (v && d)
369
                res =
370
                    snprintf(buf, size, "%s %s", v->name,
371
                         d->name);
372
            else if (!synth)
373
                return NULL;
374
            else if (!v)
375
                res =
376
                    snprintf(buf, size,
377
                         "Unknown device %04x:%04x",
378
                         iv, id);
379
            else    /* !d */
380
                res =
381
                    snprintf(buf, size,
382
                         "%s Unknown device %04x",
383
                         v->name, id);
384
        }
385
        break;
386
    case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR:
387
        isv = va_arg(args, int);
388
        if (num)
389
            res = snprintf(buf, size, "%04x", isv);
390
        else if (v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0))
391
            return (char *) v->name;
392
        else if (synth)
393
            res =
394
                snprintf(buf, size, "Unknown vendor %04x",
395
                     isv);
396
        else
397
            return NULL;
398
        break;
399
    case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_DEVICE:
400
        iv = va_arg(args, int);
401
        id = va_arg(args, int);
402
        isv = va_arg(args, int);
403
        isd = va_arg(args, int);
404
        if (num)
405
            res = snprintf(buf, size, "%04x", isd);
406
        else if (d = id_lookup_subsys(a, iv, id, isv, isd))
407
            return (char *) d->name;
408
        else if (synth)
409
            res =
410
                snprintf(buf, size, "Unknown device %04x",
411
                     isd);
412
        else
413
            return NULL;
414
        break;
415
    case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE | PCI_LOOKUP_SUBSYSTEM:
416
        iv = va_arg(args, int);
417
        id = va_arg(args, int);
418
        isv = va_arg(args, int);
419
        isd = va_arg(args, int);
420
        if (num)
421
            res = snprintf(buf, size, "%04x:%04x", isv, isd);
422
        else {
423
            v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0);
424
            d = id_lookup_subsys(a, iv, id, isv, isd);
425
            if (v && d)
426
                res =
427
                    snprintf(buf, size, "%s %s", v->name,
428
                         d->name);
429
            else if (!synth)
430
                return NULL;
431
            else if (!v)
432
                res =
433
                    snprintf(buf, size,
434
                         "Unknown device %04x:%04x",
435
                         isv, isd);
436
            else    /* !d */
437
                res =
438
                    snprintf(buf, size,
439
                         "%s Unknown device %04x",
440
                         v->name, isd);
441
        }
442
        break;
443
    case PCI_LOOKUP_CLASS:
444
        icls = va_arg(args, int);
445
        if (num)
446
            res = snprintf(buf, size, "%04x", icls);
447
        else if (cls =
448
             id_lookup(a, ID_SUBCLASS, icls >> 8, icls & 0xff,
449
                   0, 0))
450
            return (char *) cls->name;
451
        else if (cls = id_lookup(a, ID_CLASS, icls, 0, 0, 0))
452
            res =
453
                snprintf(buf, size, "%s [%04x]", cls->name,
454
                     icls);
455
        else if (synth)
456
            res = snprintf(buf, size, "Class %04x", icls);
457
        else
458
            return NULL;
459
        break;
460
    case PCI_LOOKUP_PROGIF:
461
        icls = va_arg(args, int);
462
        ipif = va_arg(args, int);
463
        if (num)
464
            res = snprintf(buf, size, "%02x", ipif);
465
        else if (pif =
466
             id_lookup(a, ID_PROGIF, icls >> 8, icls & 0xff,
467
                   ipif, 0))
468
            return (char *) pif->name;
469
        else if (icls == 0x0101 && !(ipif & 0x70)) {
470
            /* IDE controllers have complex prog-if semantics */
471
            res = snprintf(buf, size, "%s%s%s%s%s",
472
                       (ipif & 0x80) ? "Master " : "",
473
                       (ipif & 0x08) ? "SecP " : "",
474
                       (ipif & 0x04) ? "SecO " : "",
475
                       (ipif & 0x02) ? "PriP " : "",
476
                       (ipif & 0x01) ? "PriO " : "");
477
            if (res > 0 && res < size)
478
                buf[--res] = 0;
479
        } else if (synth)
480
            res = snprintf(buf, size, "ProgIf %02x", ipif);
481
        else
482
            return NULL;
483
        break;
484
    default:
485
        return "<pci_lookup_name: invalid request>";
1301 jermar 486
    }
1302 jermar 487
    if (res < 0 || res >= size)
488
        return "<pci_lookup_name: buffer too small>";
489
    else
490
        return buf;
1301 jermar 491
}