lib/names.c

   1 /*
   2  *      The PCI Library -- ID to Name Translation
   3  *
   4  *      Copyright (c) 1997--2014 Martin Mares <mj@ucw.cz>
   5  *
   6  *      Can be freely distributed and used under the terms of the GNU GPL.
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdarg.h>
  11 #include <string.h>
  12
  13 #include "internal.h"
  14 #include "names.h"
  15
  16 static char *id_lookup(struct pci_access *a, int flags, int cat, int id1, int id2, int id3, int id4)
  17 {
  18   char *name;
  19   int tried_hwdb = 0;
  20
  21   while (!(name = pci_id_lookup(a, flags, cat, id1, id2, id3, id4)))
  22     {
  23       if ((flags & PCI_LOOKUP_CACHE) && !a->id_cache_status)
  24         {
  25           if (pci_id_cache_load(a, flags))
  26             continue;
  27         }
  28       if (!tried_hwdb && !(flags & (PCI_LOOKUP_SKIP_LOCAL | PCI_LOOKUP_NO_HWDB)))
  29         {
  30           tried_hwdb = 1;
  31           if (name = pci_id_hwdb_lookup(a, cat, id1, id2, id3, id4))
  32             {
  33               pci_id_insert(a, cat, id1, id2, id3, id4, name, SRC_HWDB);
  34               continue;
  35             }
  36         }
  37       if (flags & PCI_LOOKUP_NETWORK)
  38         {
  39           if (name = pci_id_net_lookup(a, cat, id1, id2, id3, id4))
  40             {
  41               pci_id_insert(a, cat, id1, id2, id3, id4, name, SRC_NET);
  42               pci_mfree(name);
  43               pci_id_cache_dirty(a);
  44             }
  45           else
  46             pci_id_insert(a, cat, id1, id2, id3, id4, "", SRC_NET);
  47           /* We want to iterate the lookup to get the allocated ID entry from the hash */
  48           continue;
  49         }
  50       return NULL;
  51     }
  52   return (name[0] ? name : NULL);
  53 }
  54
  55 static char *
  56 id_lookup_subsys(struct pci_access *a, int flags, int iv, int id, int isv, int isd)
  57 {
  58   char *d = NULL;
  59   if (iv > 0 && id > 0)                                         /* Per-device lookup */
  60     d = id_lookup(a, flags, ID_SUBSYSTEM, iv, id, isv, isd);
  61   if (!d)                                                       /* Generic lookup */
  62     d = id_lookup(a, flags, ID_GEN_SUBSYSTEM, isv, isd, 0, 0);
  63   if (!d && iv == isv && id == isd)                             /* Check for subsystem == device */
  64     d = id_lookup(a, flags, ID_DEVICE, iv, id, 0, 0);
  65   return d;
  66 }
  67
  68 static char *
  69 format_name(char *buf, int size, int flags, char *name, char *num, char *unknown)
  70 {
  71   int res;
  72   if ((flags & PCI_LOOKUP_NO_NUMBERS) && !name)
  73     return NULL;
  74   else if (flags & PCI_LOOKUP_NUMERIC)
  75     res = snprintf(buf, size, "%s", num);
  76   else if (!name)
  77     res = snprintf(buf, size, ((flags & PCI_LOOKUP_MIXED) ? "%s [%s]" : "%s %s"), unknown, num);
  78   else if (!(flags & PCI_LOOKUP_MIXED))
  79     res = snprintf(buf, size, "%s", name);
  80   else
  81     res = snprintf(buf, size, "%s [%s]", name, num);
  82   if (res >= size && size >= 4)
  83     buf[size-2] = buf[size-3] = buf[size-4] = '.';
  84   else if (res < 0 || res >= size)
  85     return "<pci_lookup_name: buffer too small>";
  86   return buf;
  87 }
  88
  89 static char *
  90 format_name_pair(char *buf, int size, int flags, char *v, char *d, char *num)
  91 {
  92   int res;
  93   if ((flags & PCI_LOOKUP_NO_NUMBERS) && (!v || !d))
  94     return NULL;
  95   if (flags & PCI_LOOKUP_NUMERIC)
  96     res = snprintf(buf, size, "%s", num);
  97   else if (flags & PCI_LOOKUP_MIXED)
  98     {
  99       if (v && d)
 100         res = snprintf(buf, size, "%s %s [%s]", v, d, num);
 101       else if (!v)
 102         res = snprintf(buf, size, "Device [%s]", num);
 103       else /* v && !d */
 104         res = snprintf(buf, size, "%s Device [%s]", v, num);
 105     }
 106   else
 107     {
 108       if (v && d)
 109         res = snprintf(buf, size, "%s %s", v, d);
 110       else if (!v)
 111         res = snprintf(buf, size, "Device %s", num);
 112       else /* v && !d */
 113         res = snprintf(buf, size, "%s Device %s", v, num+5);
 114     }
 115   if (res >= size && size >= 4)
 116     buf[size-2] = buf[size-3] = buf[size-4] = '.';
 117   else if (res < 0 || res >= size)
 118     return "<pci_lookup_name: buffer too small>";
 119   return buf;
 120 }
 121
 122 char *
 123 pci_lookup_name(struct pci_access *a, char *buf, int size, int flags, ...)
 124 {
 125   va_list args;
 126   char *v, *d, *cls, *pif;
 127   int iv, id, isv, isd, icls, ipif;
 128   char numbuf[16], pifbuf[32];
 129
 130   va_start(args, flags);
 131
 132   flags |= a->id_lookup_mode;
 133   if (!(flags & PCI_LOOKUP_NO_NUMBERS))
 134     {
 135       if (a->numeric_ids > 1)
 136         flags |= PCI_LOOKUP_MIXED;
 137       else if (a->numeric_ids)
 138         flags |= PCI_LOOKUP_NUMERIC;
 139     }
 140   if (flags & PCI_LOOKUP_MIXED)
 141     flags &= ~PCI_LOOKUP_NUMERIC;
 142
 143   if (!a->id_hash && !(flags & (PCI_LOOKUP_NUMERIC | PCI_LOOKUP_SKIP_LOCAL)) && !a->id_load_failed)
 144     pci_load_name_list(a);
 145
 146   switch (flags & 0xffff)
 147     {
 148     case PCI_LOOKUP_VENDOR:
 149       iv = va_arg(args, int);
 150       sprintf(numbuf, "%04x", iv);
 151       va_end(args);
 152       return format_name(buf, size, flags, id_lookup(a, flags, ID_VENDOR, iv, 0, 0, 0), numbuf, "Vendor");
 153     case PCI_LOOKUP_DEVICE:
 154       iv = va_arg(args, int);
 155       id = va_arg(args, int);
 156       sprintf(numbuf, "%04x", id);
 157       va_end(args);
 158       return format_name(buf, size, flags, id_lookup(a, flags, ID_DEVICE, iv, id, 0, 0), numbuf, "Device");
 159     case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE:
 160       iv = va_arg(args, int);
 161       id = va_arg(args, int);
 162       sprintf(numbuf, "%04x:%04x", iv, id);
 163       v = id_lookup(a, flags, ID_VENDOR, iv, 0, 0, 0);
 164       d = id_lookup(a, flags, ID_DEVICE, iv, id, 0, 0);
 165       va_end(args);
 166       return format_name_pair(buf, size, flags, v, d, numbuf);
 167     case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR:
 168       isv = va_arg(args, int);
 169       sprintf(numbuf, "%04x", isv);
 170       v = id_lookup(a, flags, ID_VENDOR, isv, 0, 0, 0);
 171       va_end(args);
 172       return format_name(buf, size, flags, v, numbuf, "Unknown vendor");
 173     case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_DEVICE:
 174       iv = va_arg(args, int);
 175       id = va_arg(args, int);
 176       isv = va_arg(args, int);
 177       isd = va_arg(args, int);
 178       sprintf(numbuf, "%04x", isd);
 179       va_end(args);
 180       return format_name(buf, size, flags, id_lookup_subsys(a, flags, iv, id, isv, isd), numbuf, "Device");
 181     case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE | PCI_LOOKUP_SUBSYSTEM:
 182       iv = va_arg(args, int);
 183       id = va_arg(args, int);
 184       isv = va_arg(args, int);
 185       isd = va_arg(args, int);
 186       v = id_lookup(a, flags, ID_VENDOR, isv, 0, 0, 0);
 187       d = id_lookup_subsys(a, flags, iv, id, isv, isd);
 188       sprintf(numbuf, "%04x:%04x", isv, isd);
 189       va_end(args);
 190       return format_name_pair(buf, size, flags, v, d, numbuf);
 191     case PCI_LOOKUP_CLASS:
 192       icls = va_arg(args, int);
 193       sprintf(numbuf, "%04x", icls);
 194       cls = id_lookup(a, flags, ID_SUBCLASS, icls >> 8, icls & 0xff, 0, 0);
 195       if (!cls && (cls = id_lookup(a, flags, ID_CLASS, icls >> 8, 0, 0, 0)))
 196         {
 197           if (!(flags & PCI_LOOKUP_NUMERIC)) /* Include full class number */
 198             flags |= PCI_LOOKUP_MIXED;
 199         }
 200       va_end(args);
 201       return format_name(buf, size, flags, cls, numbuf, "Class");
 202     case PCI_LOOKUP_PROGIF:
 203       icls = va_arg(args, int);
 204       ipif = va_arg(args, int);
 205       sprintf(numbuf, "%02x", ipif);
 206       pif = id_lookup(a, flags, ID_PROGIF, icls >> 8, icls & 0xff, ipif, 0);
 207       if (!pif && icls == 0x0101 && !(ipif & 0x70))
 208         {
 209           /* IDE controllers have complex prog-if semantics */
 210           sprintf(pifbuf, "%s%s%s%s%s",
 211                   (ipif & 0x80) ? " Master" : "",
 212                   (ipif & 0x08) ? " SecP" : "",
 213                   (ipif & 0x04) ? " SecO" : "",
 214                   (ipif & 0x02) ? " PriP" : "",
 215                   (ipif & 0x01) ? " PriO" : "");
 216           pif = pifbuf;
 217           if (*pif)
 218             pif++;
 219         }
 220       va_end(args);
 221       return format_name(buf, size, flags, pif, numbuf, "ProgIf");
 222     default:
 223       va_end(args);
 224       return "<pci_lookup_name: invalid request>";
 225     }
 226 }