usr/src/lib/libpcidb/common/pcidb.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2012, Joyent, Inc. All rights reserved.
  23  */
  24
  25 /*
  26  * This library exists to understand and parse the pci.ids database that is
  27  * maintained at http://pci-ids.ucw.cz/ and in the gate at cmd/hwdata. This
  28  * database provides a way to map the PCI device, vendor, and subsystem ids to
  29  * a human understandable name.
  30  *
  31  * This library exports this data in a similar way to a tree. The handle that
  32  * is returned from pcidb_open is the root of the tree. The next level are the
  33  * vendors. Each vendor has a unique set of devices and each device has a unique
  34  * set of subvendor and subdevice pairs.
  35  *
  36  * Parsing information:
  37  *
  38  * The database is formatted in the following basic format:
  39  * vendor_id<two spaces>vendor_name
  40  * <tab>device_id<two spaces>device_name
  41  * <tab><tab>subvendor<space>subdevice<two spaces>subsystem_name
  42  *
  43  * For any given vendor, there can be multiple devices. And for any given device
  44  * there will be multiple subsystems. In addition, there can be comments that
  45  * start a line which use the '#' character.
  46  *
  47  * At the end of the file, there are a series of PCI classes. Those will start
  48  * with a single C<space>. Once we hit those, we stop all parsing. We currently
  49  * don't care about consuming or presenting those.
  50  */
  51
  52 #include <sys/types.h>
  53 #include <stdint.h>
  54 #include <stdio.h>
  55 #include <stdlib.h>
  56 #include <errno.h>
  57 #include <string.h>
  58 #include <assert.h>
  59 #include <unistd.h>
  60
  61 #include "pcidb.h"
  62
  63 #define PCI_NAME_MAX    256
  64 #define PCI_READLINE    1024
  65
  66 /* Forward declarations */
  67 struct pcidb_vendor;
  68 struct pcidb_device;
  69 struct pcidb_subvd;
  70
  71 struct pcidb_subvd {
  72         uint16_t                ps_vid;
  73         uint16_t                ps_did;
  74         char                    ps_name[PCI_NAME_MAX];
  75         struct pcidb_subvd      *ps_prev;
  76         struct pcidb_subvd      *ps_next;
  77         struct pcidb_device     *ps_dev;
  78         struct pcidb_vendor     *ps_vend;
  79 };
  80
  81 struct pcidb_device {
  82         uint16_t                pd_id;
  83         char                    pd_name[PCI_NAME_MAX];
  84         struct pcidb_subvd      *pd_sstart;
  85         struct pcidb_subvd      *pd_send;
  86         struct pcidb_device     *pd_next;
  87         struct pcidb_device     *pd_prev;
  88         struct pcidb_vendor     *pd_vend;
  89 };
  90
  91 struct pcidb_vendor {
  92         uint16_t                pv_id;
  93         char                    pv_name[PCI_NAME_MAX];
  94         struct pcidb_device     *pv_dstart;
  95         struct pcidb_device     *pv_dend;
  96         struct pcidb_vendor     *pv_prev;
  97         struct pcidb_vendor     *pv_next;
  98 };
  99
 100 struct pcidb_hdl {
 101         pcidb_vendor_t  *ph_vstart;
 102         pcidb_vendor_t  *ph_vend;
 103 };
 104
 105 typedef enum pcidb_parse {
 106         PDB_VENDOR,
 107         PDB_DEVICE,
 108         PDB_SUBDEV
 109 } pcidb_parse_t;
 110
 111 static const char *pci_db = "/usr/share/hwdata/pci.ids";
 112
 113 static void
 114 pcihdl_add_vendor(pcidb_hdl_t *hdl, pcidb_vendor_t *v)
 115 {
 116         if (hdl->ph_vstart == NULL && hdl->ph_vend == NULL) {
 117                 hdl->ph_vstart = v;
 118                 hdl->ph_vend = v;
 119                 v->pv_prev = NULL;
 120                 v->pv_next = NULL;
 121         } else {
 122                 v->pv_prev = hdl->ph_vend;
 123                 v->pv_next = NULL;
 124                 hdl->ph_vend->pv_next = v;
 125                 hdl->ph_vend = v;
 126         }
 127 }
 128
 129 static pcidb_vendor_t *
 130 parse_vendor(char *buf, pcidb_hdl_t *hdl)
 131 {
 132         pcidb_vendor_t *v;
 133         size_t len;
 134
 135         v = malloc(sizeof (pcidb_vendor_t));
 136         if (v == NULL)
 137                 return (NULL);
 138
 139         pcihdl_add_vendor(hdl, v);
 140         v->pv_dstart = NULL;
 141         v->pv_dend = NULL;
 142
 143         buf[4] = '\0';
 144         v->pv_id = strtol(buf, NULL, 16);
 145         buf += 6;
 146         len = strlen(buf);
 147         if (buf[len-1] == '\n')
 148                 buf[len-1] = '\0';
 149
 150         (void) strlcpy(v->pv_name, buf, PCI_NAME_MAX);
 151
 152         return (v);
 153 }
 154
 155 static void
 156 insert_device(pcidb_vendor_t *v, pcidb_device_t *d)
 157 {
 158         d->pd_vend = v;
 159         if (v->pv_dstart == NULL && v->pv_dend == NULL) {
 160                 v->pv_dstart = d;
 161                 v->pv_dend = d;
 162                 d->pd_next = NULL;
 163                 d->pd_prev = NULL;
 164         } else {
 165                 d->pd_prev = v->pv_dend;
 166                 d->pd_next = NULL;
 167                 v->pv_dend->pd_next = d;
 168                 v->pv_dend = d;
 169         }
 170 }
 171
 172 static pcidb_device_t *
 173 parse_device(char *buf, pcidb_vendor_t *v)
 174 {
 175         pcidb_device_t *d;
 176         size_t len;
 177
 178         d = malloc(sizeof (pcidb_device_t));
 179         if (d == NULL)
 180                 return (d);
 181
 182         d->pd_sstart = NULL;
 183         d->pd_send = NULL;
 184         insert_device(v, d);
 185
 186         buf++;
 187         buf[4] = '\0';
 188         d->pd_id = strtol(buf, NULL, 16);
 189         buf += 6;
 190         len = strlen(buf);
 191         if (buf[len-1] == '\n')
 192                 buf[len-1] = '\0';
 193
 194         (void) strlcpy(d->pd_name, buf, PCI_NAME_MAX);
 195         return (d);
 196 }
 197
 198 static void
 199 insert_subdev(pcidb_device_t *d, pcidb_subvd_t *s)
 200 {
 201         s->ps_dev = d;
 202         s->ps_vend = d->pd_vend;
 203         if (d->pd_sstart == NULL) {
 204                 d->pd_sstart = s;
 205                 d->pd_send = s;
 206                 s->ps_prev = NULL;
 207                 s->ps_next = NULL;
 208         } else {
 209                 s->ps_prev = d->pd_send;
 210                 s->ps_next = NULL;
 211                 d->pd_send->ps_next = s;
 212                 d->pd_send = s;
 213         }
 214 }
 215
 216 static pcidb_subvd_t *
 217 parse_subdev(char *buf, pcidb_device_t *d)
 218 {
 219         pcidb_subvd_t *s;
 220         size_t len;
 221
 222         s = malloc(sizeof (pcidb_subvd_t));
 223         if (s == NULL)
 224                 return (NULL);
 225         insert_subdev(d, s);
 226
 227         buf += 2;
 228         buf[4] = '\0';
 229         s->ps_vid = strtol(buf, NULL, 16);
 230         buf += 5;
 231         buf[4] = '\0';
 232         s->ps_did = strtol(buf, NULL, 16);
 233         buf += 6;
 234
 235         len = strlen(buf);
 236         if (buf[len-1] == '\n')
 237                 buf[len-1] = '\0';
 238
 239         (void) strlcpy(s->ps_name, buf, PCI_NAME_MAX);
 240
 241         return (s);
 242 }
 243
 244 static int
 245 readline(FILE *f, char *buf, size_t len)
 246 {
 247         for (;;) {
 248                 if (fgets(buf, len, f) == NULL)
 249                         return (-1);
 250
 251                 if (buf[0] == 'C')
 252                         return (-1);
 253
 254                 if (buf[0] != '#' && buf[0] != '\n')
 255                         return (0);
 256         }
 257 }
 258
 259 static int
 260 parse_db(FILE *f, pcidb_hdl_t *hdl)
 261 {
 262         char buf[1024];
 263         pcidb_vendor_t *v = NULL;
 264         pcidb_device_t *d = NULL;
 265         pcidb_parse_t state = PDB_VENDOR;
 266
 267         for (;;) {
 268                 errno = 0;
 269                 if (readline(f, buf, sizeof (buf)) != 0) {
 270                         if (errno != 0)
 271                                 return (-1);
 272                         else
 273                                 return (0);
 274                 }
 275
 276 newstate:
 277                 switch (state) {
 278                 case PDB_VENDOR:
 279                         v = parse_vendor(buf, hdl);
 280                         if (v == NULL)
 281                                 return (0);
 282                         state = PDB_DEVICE;
 283                         continue;
 284                 case PDB_DEVICE:
 285                         if (buf[0] != '\t') {
 286                                 state = PDB_VENDOR;
 287                                 goto newstate;
 288                         }
 289
 290                         if (buf[1] == '\t') {
 291                                 state = PDB_SUBDEV;
 292                                 goto newstate;
 293                         }
 294
 295                         assert(v != NULL);
 296                         d = parse_device(buf, v);
 297                         if (d == NULL)
 298                                 return (0);
 299                         continue;
 300                 case PDB_SUBDEV:
 301                         if (buf[0] != '\t') {
 302                                 state = PDB_VENDOR;
 303                                 goto newstate;
 304                         }
 305
 306                         if (buf[0] == '\t' && buf[1] != '\t') {
 307                                 state = PDB_DEVICE;
 308                                 goto newstate;
 309                         }
 310
 311                         assert(buf[0] == '\t' && buf[1] == '\t');
 312                         assert(d != NULL);
 313                         (void) parse_subdev(buf, d);
 314                 }
 315         }
 316 }
 317
 318 pcidb_hdl_t *
 319 pcidb_open(int version)
 320 {
 321         pcidb_hdl_t *h;
 322         FILE *f;
 323
 324         if (version != PCIDB_VERSION) {
 325                 errno = EINVAL;
 326                 return (NULL);
 327         }
 328
 329         h = malloc(sizeof (pcidb_hdl_t));
 330         if (h == NULL)
 331                 return (NULL);
 332
 333         h->ph_vstart = NULL;
 334         h->ph_vend = NULL;
 335
 336         f = fopen(pci_db, "rF");
 337         if (f == NULL) {
 338                 free(h);
 339                 return (NULL);
 340         }
 341
 342         if (parse_db(f, h) < 0) {
 343                 pcidb_close(h);
 344                 free(h);
 345                 return (NULL);
 346         }
 347
 348         return (h);
 349 }
 350
 351 void
 352 pcidb_close(pcidb_hdl_t *h)
 353 {
 354         pcidb_vendor_t *v, *tv;
 355
 356         pcidb_device_t *d, *td;
 357         pcidb_subvd_t *s, *ts;
 358
 359         if (h == NULL)
 360                 return;
 361
 362         v = h->ph_vstart;
 363         while (v != NULL) {
 364                 d = v->pv_dstart;
 365                 while (d != NULL) {
 366                         s = d->pd_sstart;
 367                         while (s != NULL) {
 368                                 ts = s;
 369                                 s = s->ps_next;
 370                                 free(ts);
 371                         }
 372                         td = d;
 373                         d = d->pd_next;
 374                         free(td);
 375                 }
 376                 tv = v;
 377                 v = v->pv_next;
 378                 free(tv);
 379         }
 380
 381         free(h);
 382 }
 383
 384 pcidb_vendor_t *
 385 pcidb_lookup_vendor(pcidb_hdl_t *hdl, uint16_t id)
 386 {
 387         pcidb_vendor_t *v;
 388
 389         for (v = hdl->ph_vstart; v != NULL; v = v->pv_next) {
 390                 if (v->pv_id == id)
 391                         return (v);
 392         }
 393
 394         return (NULL);
 395 }
 396
 397 const char *
 398 pcidb_vendor_name(pcidb_vendor_t *v)
 399 {
 400         return (v->pv_name);
 401 }
 402
 403 uint16_t
 404 pcidb_vendor_id(pcidb_vendor_t *v)
 405 {
 406         return (v->pv_id);
 407 }
 408
 409 pcidb_vendor_t *
 410 pcidb_vendor_iter(pcidb_hdl_t *h)
 411 {
 412         return (h->ph_vstart);
 413 }
 414
 415 pcidb_vendor_t *
 416 pcidb_vendor_iter_next(pcidb_vendor_t *v)
 417 {
 418         assert(v != NULL);
 419         return (v->pv_next);
 420 }
 421
 422 pcidb_device_t *
 423 pcidb_lookup_device_by_vendor(pcidb_vendor_t *v, uint16_t id)
 424 {
 425         pcidb_device_t *d;
 426         assert(v != NULL);
 427
 428         for (d = v->pv_dstart; d != NULL; d = d->pd_next)
 429                 if (d->pd_id == id)
 430                         return (d);
 431
 432         return (NULL);
 433 }
 434
 435 pcidb_device_t *
 436 pcidb_lookup_device(pcidb_hdl_t *h, uint16_t vid, uint16_t did)
 437 {
 438         pcidb_vendor_t *v;
 439
 440         v = pcidb_lookup_vendor(h, vid);
 441         if (v == NULL)
 442                 return (NULL);
 443
 444         return (pcidb_lookup_device_by_vendor(v, did));
 445 }
 446
 447 pcidb_device_t *
 448 pcidb_device_iter(pcidb_vendor_t *v)
 449 {
 450         return (v->pv_dstart);
 451 }
 452
 453 pcidb_device_t *
 454 pcidb_device_iter_next(pcidb_device_t *d)
 455 {
 456         return (d->pd_next);
 457 }
 458
 459 const char *
 460 pcidb_device_name(pcidb_device_t *d)
 461 {
 462         return (d->pd_name);
 463 }
 464
 465 uint16_t
 466 pcidb_device_id(pcidb_device_t *d)
 467 {
 468         return (d->pd_id);
 469 }
 470
 471 pcidb_vendor_t *
 472 pcidb_device_vendor(pcidb_device_t *d)
 473 {
 474         return (d->pd_vend);
 475 }
 476
 477 pcidb_subvd_t *
 478 pcidb_lookup_subvd_by_device(pcidb_device_t *d, uint16_t svid, uint16_t sdid)
 479 {
 480         pcidb_subvd_t *s;
 481
 482         assert(d != NULL);
 483
 484         for (s = d->pd_sstart; s != NULL; s = s->ps_next)
 485                 if (s->ps_vid == svid && s->ps_did == sdid)
 486                         return (s);
 487
 488         return (NULL);
 489 }
 490
 491 pcidb_subvd_t *
 492 pcidb_lookup_subvd_by_vendor(pcidb_vendor_t *v, uint16_t devid, uint16_t svid,
 493     uint16_t sdid)
 494 {
 495         pcidb_device_t *d;
 496
 497         assert(v != NULL);
 498         d = pcidb_lookup_device_by_vendor(v, devid);
 499         if (d == NULL)
 500                 return (NULL);
 501
 502         return (pcidb_lookup_subvd_by_device(d, svid, sdid));
 503 }
 504
 505 pcidb_subvd_t *
 506 pcidb_lookup_subvd(pcidb_hdl_t *h, uint16_t vid, uint16_t did, uint16_t svid,
 507     uint16_t sdid)
 508 {
 509         pcidb_device_t *d;
 510
 511         assert(h != NULL);
 512         d = pcidb_lookup_device(h, vid, did);
 513         if (d == NULL)
 514                 return (NULL);
 515
 516         return (pcidb_lookup_subvd_by_device(d, svid, sdid));
 517 }
 518
 519 pcidb_subvd_t *
 520 pcidb_subvd_iter(pcidb_device_t *d)
 521 {
 522         return (d->pd_sstart);
 523 }
 524
 525 pcidb_subvd_t *
 526 pcidb_subvd_iter_next(pcidb_subvd_t *s)
 527 {
 528         return (s->ps_next);
 529 }
 530
 531 const char *
 532 pcidb_subvd_name(pcidb_subvd_t *s)
 533 {
 534         return (s->ps_name);
 535 }
 536
 537 uint16_t
 538 pcidb_subvd_svid(pcidb_subvd_t *s)
 539 {
 540         return (s->ps_vid);
 541 }
 542
 543 uint16_t
 544 pcidb_subvd_sdid(pcidb_subvd_t *s)
 545 {
 546         return (s->ps_did);
 547 }
 548
 549 pcidb_device_t *
 550 pcidb_subvd_device(pcidb_subvd_t *s)
 551 {
 552         return (s->ps_dev);
 553 }
 554
 555 pcidb_vendor_t *
 556 pcidb_subvd_vendor(pcidb_subvd_t *s)
 557 {
 558         return (s->ps_vend);
 559 }