Subversion Repositories HelenOS

/*

 *  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;

}