/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2012, Joyent, Inc. All rights reserved.
 * Copyright 2021 Oxide Computer Company
 */

/*
 * This library exists to understand and parse the pci.ids database that is
 * maintained at http://pci-ids.ucw.cz/ and in the gate at cmd/hwdata. This
 * database provides a way to map the PCI device, vendor, and subsystem ids to
 * a human understandable name.
 *
 * This library exports this data in a similar way to a tree. The handle that
 * is returned from pcidb_open is the root of the tree. The next level are the
 * vendors. Each vendor has a unique set of devices and each device has a unique
 * set of subvendor and subdevice pairs.
 *
 * Parsing information:
 *
 * The database is formatted in the following basic format:
 * vendor_id<two spaces>vendor_name
 * <tab>device_id<two spaces>device_name
 * <tab><tab>subvendor<space>subdevice<two spaces>subsystem_name
 *
 * For any given vendor, there can be multiple devices. And for any given device
 * there will be multiple subsystems. In addition, there can be comments that
 * start a line which use the '#' character.
 *
 * At the end of the file, there are a series of PCI classes. Those will start
 * with a single C<space>. Once we hit those, we stop all parsing. We currently
 * don't care about consuming or presenting those.
 */

#include <sys/types.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <stddef.h>
#include <sys/list.h>

#include "pcidb.h"

#define PCI_NAME_MAX    256
#define PCI_READLINE    1024

struct pcidb_progif {
        char            pp_name[PCI_NAME_MAX];
        list_node_t     pp_link;
        pcidb_subclass_t *pp_subclass;
        uint8_t         pp_code;
};

struct pcidb_subclass {
        char            psc_name[PCI_NAME_MAX];
        list_node_t     psc_link;
        list_t          psc_progifs;
        pcidb_class_t   *psc_class;
        uint8_t         psc_code;
};

struct pcidb_class {
        char            pc_name[PCI_NAME_MAX];
        list_node_t     pc_link;
        list_t          pc_subclass;
        pcidb_hdl_t     *pc_hdl;
        uint8_t         pc_code;
};

struct pcidb_subvd {
        uint16_t        ps_vid;
        uint16_t        ps_did;
        char            ps_name[PCI_NAME_MAX];
        list_node_t     ps_link;
        pcidb_device_t  *ps_dev;
        pcidb_vendor_t  *ps_vend;
};

struct pcidb_device {
        uint16_t        pd_id;
        char            pd_name[PCI_NAME_MAX];
        list_t          pd_subs;
        list_node_t     pd_link;
        pcidb_vendor_t  *pd_vend;
};

struct pcidb_vendor {
        uint16_t        pv_id;
        char            pv_name[PCI_NAME_MAX];
        list_t          pv_devs;
        list_node_t     pv_link;
        pcidb_hdl_t     *pv_hdl;
};

struct pcidb_hdl {
        list_t ph_vendors;
        list_t ph_classes;
};

typedef enum pcidb_parse {
        PDB_INIT,
        PDB_VENDOR,
        PDB_DEVICE,
        PDB_SUBDEV,
        PDB_CLASS,
        PDB_SUBCLASS,
        PDB_PROGIF
} pcidb_parse_t;

static const char *pci_db = "/usr/share/hwdata/pci.ids";

static pcidb_vendor_t *
parse_vendor(char *buf, pcidb_hdl_t *hdl)
{
        pcidb_vendor_t *vend;

        vend = malloc(sizeof (pcidb_vendor_t));
        if (vend == NULL)
                return (NULL);

        list_create(&vend->pv_devs, sizeof (pcidb_device_t),
            offsetof(pcidb_device_t, pd_link));
        vend->pv_hdl = hdl;
        list_insert_tail(&hdl->ph_vendors, vend);

        buf[4] = '\0';
        vend->pv_id = strtol(buf, NULL, 16);
        buf += 6;

        (void) strlcpy(vend->pv_name, buf, PCI_NAME_MAX);

        return (vend);
}

static pcidb_device_t *
parse_device(char *buf, pcidb_vendor_t *vend)
{
        pcidb_device_t *dev;

        dev = malloc(sizeof (pcidb_device_t));
        if (dev == NULL)
                return (dev);

        list_create(&dev->pd_subs, sizeof (pcidb_subvd_t),
            offsetof(pcidb_subvd_t, ps_link));
        dev->pd_vend = vend;
        list_insert_tail(&vend->pv_devs, dev);

        buf++;
        buf[4] = '\0';
        dev->pd_id = strtol(buf, NULL, 16);
        buf += 6;

        (void) strlcpy(dev->pd_name, buf, PCI_NAME_MAX);
        return (dev);
}

static pcidb_subvd_t *
parse_subdev(char *buf, pcidb_device_t *dev)
{
        pcidb_subvd_t *sub;

        sub = malloc(sizeof (pcidb_subvd_t));
        if (sub == NULL)
                return (NULL);

        sub->ps_dev = dev;
        sub->ps_vend = dev->pd_vend;
        list_insert_tail(&dev->pd_subs, sub);

        buf += 2;
        buf[4] = '\0';
        sub->ps_vid = strtol(buf, NULL, 16);
        buf += 5;
        buf[4] = '\0';
        sub->ps_did = strtol(buf, NULL, 16);
        buf += 6;

        (void) strlcpy(sub->ps_name, buf, PCI_NAME_MAX);

        return (sub);
}

static pcidb_class_t *
pcidb_parse_class(char *buf, pcidb_hdl_t *hdl)
{
        pcidb_class_t *class;

        class = malloc(sizeof (pcidb_class_t));
        if (class == NULL)
                return (NULL);

        list_create(&class->pc_subclass, sizeof (pcidb_subclass_t),
            offsetof(pcidb_subclass_t, psc_link));
        class->pc_hdl = hdl;
        list_insert_tail(&hdl->ph_classes, class);

        buf += 2;
        buf[3] = '\0';
        class->pc_code = strtol(buf, NULL, 16);
        buf += 4;
        (void) strlcpy(class->pc_name, buf, PCI_NAME_MAX);

        return (class);
}

static pcidb_subclass_t *
pcidb_parse_subclass(char *buf, pcidb_class_t *class)
{
        pcidb_subclass_t *sub;

        sub = malloc(sizeof (pcidb_subclass_t));
        if (sub == NULL)
                return (NULL);

        list_create(&sub->psc_progifs, sizeof (pcidb_progif_t),
            offsetof(pcidb_progif_t, pp_link));
        sub->psc_class = class;
        list_insert_tail(&class->pc_subclass, sub);

        buf++;
        buf[3] = '\0';
        sub->psc_code = strtol(buf, NULL, 16);
        buf += 4;
        (void) strlcpy(sub->psc_name, buf, PCI_NAME_MAX);

        return (sub);
}

static pcidb_progif_t *
pcidb_parse_progif(char *buf, pcidb_subclass_t *sub)
{
        pcidb_progif_t *prog;

        prog = malloc(sizeof (pcidb_progif_t));
        if (prog == NULL) {
                return (NULL);
        }

        prog->pp_subclass = sub;
        list_insert_tail(&sub->psc_progifs, prog);

        buf += 2;
        buf[3] = '\0';
        prog->pp_code = strtol(buf, NULL, 16);
        buf += 4;
        (void) strlcpy(prog->pp_name, buf, PCI_NAME_MAX);

        return (prog);
}

static int
readline(FILE *f, char *buf, size_t len)
{
        for (;;) {
                char *c;

                if (fgets(buf, len, f) == NULL)
                        return (-1);

                if ((c = strchr(buf, '\n')) != NULL)
                        *c = '\0';

                if (buf[0] != '#' && buf[0] != '\0')
                        return (0);
        }
}

static int
parse_db(FILE *f, pcidb_hdl_t *hdl)
{
        pcidb_vendor_t *vend = NULL;
        pcidb_device_t *dev = NULL;
        pcidb_class_t *class = NULL;
        pcidb_subclass_t *sub = NULL;
        pcidb_parse_t state = PDB_INIT;

        for (;;) {
                char buf[1024];

                errno = 0;
                if (readline(f, buf, sizeof (buf)) != 0) {
                        if (errno != 0)
                                return (-1);
                        else
                                return (0);
                }

newstate:
                switch (state) {
                case PDB_INIT:
                        vend = NULL;
                        dev = NULL;
                        class = NULL;
                        sub = NULL;
                        if (buf[0] == 'C') {
                                state = PDB_CLASS;
                        } else {
                                state = PDB_VENDOR;
                        }
                        goto newstate;
                case PDB_VENDOR:
                        vend = parse_vendor(buf, hdl);
                        if (vend == NULL)
                                return (-1);
                        state = PDB_DEVICE;
                        break;
                case PDB_DEVICE:
                        if (buf[0] != '\t') {
                                state = PDB_INIT;
                                goto newstate;
                        }

                        if (buf[1] == '\t') {
                                state = PDB_SUBDEV;
                                goto newstate;
                        }

                        assert(vend != NULL);
                        dev = parse_device(buf, vend);
                        if (dev == NULL)
                                return (0);
                        break;
                case PDB_SUBDEV:
                        if (buf[0] != '\t') {
                                state = PDB_INIT;
                                goto newstate;
                        }

                        if (buf[0] == '\t' && buf[1] != '\t') {
                                state = PDB_DEVICE;
                                goto newstate;
                        }

                        assert(buf[0] == '\t' && buf[1] == '\t');
                        assert(dev != NULL);
                        if (parse_subdev(buf, dev) == NULL) {
                                return (-1);
                        }
                        break;
                case PDB_CLASS:
                        class = pcidb_parse_class(buf, hdl);
                        state = PDB_SUBCLASS;
                        break;
                case PDB_SUBCLASS:
                        if (buf[0] != '\t') {
                                state = PDB_INIT;
                                goto newstate;
                        }

                        if (buf[1] == '\t') {
                                state = PDB_PROGIF;
                                goto newstate;
                        }

                        assert(class != NULL);
                        sub = pcidb_parse_subclass(buf, class);
                        if (sub == NULL) {
                                return (-1);
                        }
                        break;
                case PDB_PROGIF:
                        if (buf[0] != '\t') {
                                state = PDB_INIT;
                                goto newstate;
                        }

                        if (buf[0] == '\t' && buf[1] != '\t') {
                                state = PDB_SUBCLASS;
                                goto newstate;
                        }

                        assert(sub != NULL);
                        if (pcidb_parse_progif(buf, sub) == NULL) {
                                return (-1);
                        }
                        break;
                }
        }
}

pcidb_hdl_t *
pcidb_open(int version)
{
        pcidb_hdl_t *h;
        FILE *f;

        if (version != PCIDB_VERSION) {
                errno = EINVAL;
                return (NULL);
        }

        h = malloc(sizeof (pcidb_hdl_t));
        if (h == NULL)
                return (NULL);

        list_create(&h->ph_vendors, sizeof (pcidb_vendor_t),
            offsetof(pcidb_vendor_t, pv_link));
        list_create(&h->ph_classes, sizeof (pcidb_class_t),
            offsetof(pcidb_class_t, pc_link));

        f = fopen(pci_db, "rF");
        if (f == NULL) {
                free(h);
                return (NULL);
        }

        if (parse_db(f, h) < 0) {
                (void) fclose(f);
                pcidb_close(h);
                return (NULL);
        }

        (void) fclose(f);

        return (h);
}

void
pcidb_close(pcidb_hdl_t *hdl)
{
        pcidb_vendor_t *vend;
        pcidb_class_t *class;

        if (hdl == NULL)
                return;

        while ((vend = list_remove_head(&hdl->ph_vendors)) != NULL) {
                pcidb_device_t *dev;

                while ((dev = list_remove_head(&vend->pv_devs)) != NULL) {
                        pcidb_subvd_t *sub;

                        while ((sub = list_remove_head(&dev->pd_subs)) !=
                            NULL) {
                                free(sub);
                        }
                        list_destroy(&dev->pd_subs);
                        free(dev);
                }
                list_destroy(&vend->pv_devs);
                free(vend);
        }
        list_destroy(&hdl->ph_vendors);

        while ((class = list_remove_head(&hdl->ph_classes)) != NULL) {
                pcidb_subclass_t *sub;

                while ((sub = list_remove_head(&class->pc_subclass)) != NULL) {
                        pcidb_progif_t *prog;

                        while ((prog = list_remove_head(&sub->psc_progifs)) !=
                            NULL) {
                                free(prog);
                        }
                        list_destroy(&sub->psc_progifs);
                        free(sub);
                }
                list_destroy(&class->pc_subclass);
                free(class);
        }
        list_destroy(&hdl->ph_classes);

        free(hdl);
}

pcidb_vendor_t *
pcidb_lookup_vendor(pcidb_hdl_t *hdl, uint16_t id)
{
        pcidb_vendor_t *v;

        for (v = list_head(&hdl->ph_vendors); v != NULL;
            v = list_next(&hdl->ph_vendors, v)) {
                if (v->pv_id == id)
                        return (v);
        }

        return (NULL);
}

const char *
pcidb_vendor_name(pcidb_vendor_t *vend)
{
        return (vend->pv_name);
}

uint16_t
pcidb_vendor_id(pcidb_vendor_t *vend)
{
        return (vend->pv_id);
}

pcidb_vendor_t *
pcidb_vendor_iter(pcidb_hdl_t *hdl)
{
        return (list_head(&hdl->ph_vendors));
}

pcidb_vendor_t *
pcidb_vendor_iter_next(pcidb_vendor_t *vend)
{
        assert(vend != NULL);
        return (list_next(&vend->pv_hdl->ph_vendors, vend));
}

pcidb_device_t *
pcidb_lookup_device_by_vendor(pcidb_vendor_t *vend, uint16_t id)
{
        assert(vend != NULL);

        for (pcidb_device_t *dev = list_head(&vend->pv_devs); dev != NULL;
            dev = list_next(&vend->pv_devs, dev)) {
                if (dev->pd_id == id)
                        return (dev);
        }

        return (NULL);
}

pcidb_device_t *
pcidb_lookup_device(pcidb_hdl_t *hdl, uint16_t vid, uint16_t did)
{
        pcidb_vendor_t *vend;

        vend = pcidb_lookup_vendor(hdl, vid);
        if (vend == NULL)
                return (NULL);

        return (pcidb_lookup_device_by_vendor(vend, did));
}

pcidb_device_t *
pcidb_device_iter(pcidb_vendor_t *vend)
{
        return (list_head(&vend->pv_devs));
}

pcidb_device_t *
pcidb_device_iter_next(pcidb_device_t *dev)
{
        return (list_next(&dev->pd_vend->pv_devs, dev));
}

const char *
pcidb_device_name(pcidb_device_t *dev)
{
        return (dev->pd_name);
}

uint16_t
pcidb_device_id(pcidb_device_t *dev)
{
        return (dev->pd_id);
}

pcidb_vendor_t *
pcidb_device_vendor(pcidb_device_t *dev)
{
        return (dev->pd_vend);
}

pcidb_subvd_t *
pcidb_lookup_subvd_by_device(pcidb_device_t *dev, uint16_t svid, uint16_t sdid)
{
        pcidb_subvd_t *sub;

        assert(dev != NULL);

        for (sub = list_head(&dev->pd_subs); sub != NULL;
            sub = list_next(&dev->pd_subs, sub)) {
                if (sub->ps_vid == svid && sub->ps_did == sdid)
                        return (sub);
        }

        return (NULL);
}

pcidb_subvd_t *
pcidb_lookup_subvd_by_vendor(pcidb_vendor_t *vend, uint16_t devid,
    uint16_t svid, uint16_t sdid)
{
        pcidb_device_t *dev;

        assert(vend != NULL);
        dev = pcidb_lookup_device_by_vendor(vend, devid);
        if (dev == NULL)
                return (NULL);

        return (pcidb_lookup_subvd_by_device(dev, svid, sdid));
}

pcidb_subvd_t *
pcidb_lookup_subvd(pcidb_hdl_t *hdl, uint16_t vid, uint16_t did, uint16_t svid,
    uint16_t sdid)
{
        pcidb_device_t *dev;

        assert(hdl != NULL);
        dev = pcidb_lookup_device(hdl, vid, did);
        if (dev == NULL)
                return (NULL);

        return (pcidb_lookup_subvd_by_device(dev, svid, sdid));
}

pcidb_subvd_t *
pcidb_subvd_iter(pcidb_device_t *dev)
{
        return (list_head(&dev->pd_subs));
}

pcidb_subvd_t *
pcidb_subvd_iter_next(pcidb_subvd_t *sub)
{
        return (list_next(&sub->ps_dev->pd_subs, sub));
}

const char *
pcidb_subvd_name(pcidb_subvd_t *sub)
{
        return (sub->ps_name);
}

uint16_t
pcidb_subvd_svid(pcidb_subvd_t *sub)
{
        return (sub->ps_vid);
}

uint16_t
pcidb_subvd_sdid(pcidb_subvd_t *sub)
{
        return (sub->ps_did);
}

pcidb_device_t *
pcidb_subvd_device(pcidb_subvd_t *sub)
{
        return (sub->ps_dev);
}

pcidb_vendor_t *
pcidb_subvd_vendor(pcidb_subvd_t *sub)
{
        return (sub->ps_vend);
}


pcidb_class_t *
pcidb_lookup_class(pcidb_hdl_t *hdl, uint8_t code)
{
        for (pcidb_class_t *class = list_head(&hdl->ph_classes); class != NULL;
            class = list_next(&hdl->ph_classes, class)) {
                if (class->pc_code == code) {
                        return (class);
                }
        }

        return (NULL);
}

pcidb_class_t *
pcidb_class_iter(pcidb_hdl_t *hdl)
{
        return (list_head(&hdl->ph_classes));
}

pcidb_class_t *
pcidb_class_iter_next(pcidb_class_t *class)
{
        return (list_next(&class->pc_hdl->ph_classes, class));
}

const char *
pcidb_class_name(pcidb_class_t *class)
{
        return (class->pc_name);
}

uint8_t
pcidb_class_code(pcidb_class_t *class)
{
        return (class->pc_code);
}

pcidb_subclass_t *
pcidb_lookup_subclass(pcidb_hdl_t *hdl, uint8_t ccode, uint8_t subcode)
{
        pcidb_class_t *class;

        class = pcidb_lookup_class(hdl, ccode);
        if (class == NULL) {
                return (NULL);
        }

        return (pcidb_lookup_subclass_by_class(class, subcode));
}

pcidb_subclass_t *
pcidb_lookup_subclass_by_class(pcidb_class_t *class, uint8_t code)
{
        for (pcidb_subclass_t *sub = list_head(&class->pc_subclass);
            sub != NULL; sub = list_next(&class->pc_subclass, sub)) {
                if (sub->psc_code == code) {
                        return (sub);
                }
        }

        return (NULL);
}

pcidb_subclass_t *
pcidb_subclass_iter(pcidb_class_t *class)
{
        return (list_head(&class->pc_subclass));
}

pcidb_subclass_t *
pcidb_subclass_iter_next(pcidb_subclass_t *sub)
{
        return (list_next(&sub->psc_class->pc_subclass, sub));
}

const char *
pcidb_subclass_name(pcidb_subclass_t *sub)
{
        return (sub->psc_name);
}

uint8_t
pcidb_subclass_code(pcidb_subclass_t *sub)
{
        return (sub->psc_code);
}

pcidb_progif_t *
pcidb_lookup_progif(pcidb_hdl_t *hdl, uint8_t ccode, uint8_t scode,
    uint8_t pcode)
{
        pcidb_subclass_t *sub;

        sub = pcidb_lookup_subclass(hdl, ccode, scode);
        if (sub == NULL) {
                return (NULL);
        }

        return (pcidb_lookup_progif_by_subclass(sub, pcode));
}

pcidb_progif_t *
pcidb_lookup_progif_by_subclass(pcidb_subclass_t *sub, uint8_t code)
{
        for (pcidb_progif_t *prog = list_head(&sub->psc_progifs); prog != NULL;
            prog = list_next(&sub->psc_progifs, prog)) {
                if (prog->pp_code == code) {
                        return (prog);
                }
        }

        return (NULL);
}

pcidb_progif_t *
pcidb_progif_iter(pcidb_subclass_t *sub)
{
        return (list_head(&sub->psc_progifs));
}

pcidb_progif_t *
pcidb_progif_iter_next(pcidb_progif_t *prog)
{
        return (list_next(&prog->pp_subclass->psc_progifs, prog));
}

const char *
pcidb_progif_name(pcidb_progif_t *prog)
{
        return (prog->pp_name);
}

uint8_t
pcidb_progif_code(pcidb_progif_t *prog)
{
        return (prog->pp_code);
}