Subversion Repositories HelenOS

Rev

Rev 1302 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  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 {
  21.   struct id_entry *next;
  22.   u32 id12, id34;
  23.   byte cat;
  24.   byte name[1];
  25. };
  26.  
  27. enum id_entry_type {
  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
  36. };
  37.  
  38. struct id_bucket {
  39.   struct id_bucket *next;
  40.   unsigned int full;
  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 {
  51.   struct id_bucket *next;
  52.   unsigned int full;
  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. {
  60.   struct id_bucket *buck = a->current_id_bucket;
  61.   unsigned int pos;
  62.   if (!buck || buck->full + size > BUCKET_SIZE)
  63.     {
  64.       buck = pci_malloc(a, BUCKET_SIZE);
  65.       buck->next = a->current_id_bucket;
  66.       a->current_id_bucket = buck;
  67.       buck->full = BUCKET_ALIGN(sizeof(struct id_bucket));
  68.     }
  69.   pos = buck->full;
  70.   buck->full = BUCKET_ALIGN(buck->full + size);
  71.   return (byte *)buck + pos;
  72. }
  73.  
  74. static inline u32 id_pair(unsigned int x, unsigned int y)
  75. {
  76.   return ((x << 16) | y);
  77. }
  78.  
  79. static inline unsigned int id_hash(int cat, u32 id12, u32 id34)
  80. {
  81.   unsigned int h;
  82.  
  83.   h = id12 ^ (id34 << 3) ^ (cat << 5);
  84.   return h % HASH_SIZE;
  85. }
  86.  
  87. static struct id_entry *id_lookup(struct pci_access *a, int cat, int id1, int id2, int id3, int id4)
  88. {
  89.   struct id_entry *n;
  90.   u32 id12 = id_pair(id1, id2);
  91.   u32 id34 = id_pair(id3, id4);
  92.  
  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;
  97. }
  98.  
  99. static int id_insert(struct pci_access *a, int cat, int id1, int id2, int id3, int id4, byte *text)
  100. {
  101.   u32 id12 = id_pair(id1, id2);
  102.   u32 id34 = id_pair(id3, id4);
  103.   unsigned int h = id_hash(cat, id12, id34);
  104.   struct id_entry *n = a->id_hash[h];
  105.   int len = strlen((char *) text);
  106.  
  107.   while (n && (n->id12 != id12 || n->id34 != id34 || n->cat != cat))
  108.     n = n->next;
  109.   if (n)
  110.     return 1;
  111.   n = id_alloc(a, sizeof(struct id_entry) + len);
  112.   n->id12 = id12;
  113.   n->id34 = id34;
  114.   n->cat = cat;
  115.   memcpy(n->name, text, len+1);
  116.   n->next = a->id_hash[h];
  117.   a->id_hash[h] = n;
  118.   return 0;
  119. }
  120.  
  121. static int id_hex(byte *p, int cnt)
  122. {
  123.   int x = 0;
  124.   while (cnt--)
  125.     {
  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;
  138. }
  139.  
  140. static inline int id_white_p(int c)
  141. {
  142.   return (c == ' ') || (c == '\t');
  143. }
  144.  
  145. static const char *id_parse_list(struct pci_access *a, int *lino)
  146. {
  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;
  154.  
  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;
  164.  
  165.       p = line;
  166.       while (id_white_p(*p))
  167.     p++;
  168.       if (!*p || *p == '#')
  169.     continue;
  170.  
  171.       p = line;
  172.       while (*p == '\t')
  173.     p++;
  174.       nest = p - line;
  175.  
  176.       if (!nest)                    /* Top-level entries */
  177.     {
  178.       if (p[0] == 'C' && p[1] == ' ')       /* Class block */
  179.         {
  180.           if ((id1 = id_hex(p+2, 2)) < 0 || !id_white_p(p[4]))
  181.         return parse_error;
  182.           cat = ID_CLASS;
  183.           p += 5;
  184.         }
  185.       else if (p[0] == 'S' && p[1] == ' ')
  186.         {                       /* Generic subsystem block */
  187.           if ((id1 = id_hex(p+2, 4)) < 0 || p[6])
  188.         return parse_error;
  189.           if (!id_lookup(a, ID_VENDOR, id1, 0, 0, 0))
  190.         return "Vendor does not exist";
  191.           cat = ID_GEN_SUBSYSTEM;
  192.           continue;
  193.         }
  194.       else if (p[0] >= 'A' && p[0] <= 'Z' && p[1] == ' ')
  195.         {                       /* Unrecognized block (RFU) */
  196.           cat = ID_UNKNOWN;
  197.           continue;
  198.         }
  199.       else                      /* Vendor ID */
  200.         {
  201.           if ((id1 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
  202.         return parse_error;
  203.           cat = ID_VENDOR;
  204.           p += 5;
  205.         }
  206.       id2 = id3 = id4 = 0;
  207.     }
  208.       else if (cat == ID_UNKNOWN)           /* Nested entries in RFU blocks are skipped */
  209.     continue;
  210.       else if (nest == 1)               /* Nesting level 1 */
  211.     switch (cat)
  212.       {
  213.       case ID_VENDOR:
  214.       case ID_DEVICE:
  215.       case ID_SUBSYSTEM:
  216.         if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
  217.           return parse_error;
  218.         p += 5;
  219.         cat = ID_DEVICE;
  220.         id3 = id4 = 0;
  221.         break;
  222.       case ID_GEN_SUBSYSTEM:
  223.         if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4]))
  224.           return parse_error;
  225.         p += 5;
  226.         id3 = id4 = 0;
  227.         break;
  228.       case ID_CLASS:
  229.       case ID_SUBCLASS:
  230.       case ID_PROGIF:
  231.         if ((id2 = id_hex(p, 2)) < 0 || !id_white_p(p[2]))
  232.           return parse_error;
  233.         p += 3;
  234.         cat = ID_SUBCLASS;
  235.         id3 = id4 = 0;
  236.         break;
  237.       default:
  238.         return parse_error;
  239.       }
  240.       else if (nest == 2)               /* Nesting level 2 */
  241.     switch (cat)
  242.       {
  243.       case ID_DEVICE:
  244.       case ID_SUBSYSTEM:
  245.         if ((id3 = id_hex(p, 4)) < 0 || !id_white_p(p[4]) || (id4 = id_hex(p+5, 4)) < 0 || !id_white_p(p[9]))
  246.           return parse_error;
  247.         p += 10;
  248.         cat = ID_SUBSYSTEM;
  249.         break;
  250.       case ID_CLASS:
  251.       case ID_SUBCLASS:
  252.       case ID_PROGIF:
  253.         if ((id3 = id_hex(p, 2)) < 0 || !id_white_p(p[2]))
  254.           return parse_error;
  255.         p += 3;
  256.         cat = ID_PROGIF;
  257.         id4 = 0;
  258.         break;
  259.       default:
  260.         return parse_error;
  261.       }
  262.       else                      /* Nesting level 3 or more */
  263.     return parse_error;
  264.       while (id_white_p(*p))
  265.     p++;
  266.       if (!*p)
  267.     return parse_error;
  268.       if (id_insert(a, cat, id1, id2, id3, id4, p))
  269.     return "Duplicate entry";
  270.     }
  271.   return NULL;
  272. }
  273.  
  274. int
  275. pci_load_name_list(struct pci_access *a)
  276. {
  277.   int lino;
  278.   const char *err;
  279.  
  280.   pci_free_name_list(a);
  281.   a->id_hash = pci_malloc(a, sizeof(struct id_entry *) * HASH_SIZE);
  282.   bzero(a->id_hash, sizeof(struct id_entry *) * HASH_SIZE);
  283.   err = id_parse_list(a, &lino);
  284.   if (err)
  285.     a->error("%s at %s, element %d\n", err, "pci_ids.h", lino);
  286.   return 1;
  287. }
  288.  
  289. void
  290. pci_free_name_list(struct pci_access *a)
  291. {
  292.   pci_mfree(a->id_hash);
  293.   a->id_hash = NULL;
  294.   while (a->current_id_bucket)
  295.     {
  296.       struct id_bucket *buck = a->current_id_bucket;
  297.       a->current_id_bucket = buck->next;
  298.       pci_mfree(buck);
  299.     }
  300. }
  301.  
  302. static struct id_entry *id_lookup_subsys(struct pci_access *a, int iv, int id, int isv, int isd)
  303. {
  304.   struct id_entry *d = NULL;
  305.   if (iv > 0 && id > 0)                     /* Per-device lookup */
  306.     d = id_lookup(a, ID_SUBSYSTEM, iv, id, isv, isd);
  307.   if (!d)                           /* Generic lookup */
  308.     d = id_lookup(a, ID_GEN_SUBSYSTEM, isv, isd, 0, 0);
  309.   if (!d && iv == isv && id == isd)             /* Check for subsystem == device */
  310.     d = id_lookup(a, ID_DEVICE, iv, id, 0, 0);
  311.   return d;
  312. }
  313.  
  314. char *
  315. pci_lookup_name(struct pci_access *a, char *buf, int size, int flags, ...)
  316. {
  317.   va_list args;
  318.   int num, res, synth;
  319.   struct id_entry *v, *d, *cls, *pif;
  320.   int iv, id, isv, isd, icls, ipif;
  321.  
  322.   va_start(args, flags);
  323.  
  324.   num = 0;
  325.   if ((flags & PCI_LOOKUP_NUMERIC) || a->numeric_ids)
  326.     {
  327.       flags &= ~PCI_LOOKUP_NUMERIC;
  328.       num = 1;
  329.     }
  330.   else if (!a->id_hash)
  331.     {
  332.       if (!pci_load_name_list(a))
  333.     num = a->numeric_ids = 1;
  334.     }
  335.  
  336.   if (flags & PCI_LOOKUP_NO_NUMBERS)
  337.     {
  338.       flags &= ~PCI_LOOKUP_NO_NUMBERS;
  339.       synth = 0;
  340.       if (num)
  341.     return NULL;
  342.     }
  343.   else
  344.     synth = 1;
  345.  
  346.   switch (flags)
  347.     {
  348.     case PCI_LOOKUP_VENDOR:
  349.       iv = va_arg(args, int);
  350.       if (num)
  351.     res = snprintf(buf, size, "%04x", iv);
  352.       else if (v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0))
  353.     return (char *) v->name;
  354.       else
  355.     res = snprintf(buf, size, "Unknown vendor %04x", iv);
  356.       break;
  357.     case PCI_LOOKUP_DEVICE:
  358.       iv = va_arg(args, int);
  359.       id = va_arg(args, int);
  360.       if (num)
  361.     res = snprintf(buf, size, "%04x", id);
  362.       else if (d = id_lookup(a, ID_DEVICE, iv, id, 0, 0))
  363.     return (char *) d->name;
  364.       else if (synth)
  365.     res = snprintf(buf, size, "Unknown device %04x", id);
  366.       else
  367.     return NULL;
  368.       break;
  369.     case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE:
  370.       iv = va_arg(args, int);
  371.       id = va_arg(args, int);
  372.       if (num)
  373.     res = snprintf(buf, size, "%04x:%04x", iv, id);
  374.       else
  375.     {
  376.       v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0);
  377.       d = id_lookup(a, ID_DEVICE, iv, id, 0, 0);
  378.       if (v && d)
  379.         res = snprintf(buf, size, "%s %s", v->name, d->name);
  380.       else if (!synth)
  381.         return NULL;
  382.       else if (!v)
  383.         res = snprintf(buf, size, "Unknown device %04x:%04x", iv, id);
  384.       else  /* !d */
  385.         res = snprintf(buf, size, "%s Unknown device %04x", v->name, id);
  386.     }
  387.       break;
  388.     case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR:
  389.       isv = va_arg(args, int);
  390.       if (num)
  391.     res = snprintf(buf, size, "%04x", isv);
  392.       else if (v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0))
  393.     return (char *) v->name;
  394.       else if (synth)
  395.     res = snprintf(buf, size, "Unknown vendor %04x", 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 = snprintf(buf, size, "Unknown device %04x", isd);
  410.       else
  411.     return NULL;
  412.       break;
  413.     case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE | PCI_LOOKUP_SUBSYSTEM:
  414.       iv = va_arg(args, int);
  415.       id = va_arg(args, int);
  416.       isv = va_arg(args, int);
  417.       isd = va_arg(args, int);
  418.       if (num)
  419.     res = snprintf(buf, size, "%04x:%04x", isv, isd);
  420.       else
  421.     {
  422.       v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0);
  423.       d = id_lookup_subsys(a, iv, id, isv, isd);
  424.       if (v && d)
  425.         res = snprintf(buf, size, "%s %s", v->name, d->name);
  426.       else if (!synth)
  427.         return NULL;
  428.       else if (!v)
  429.         res = snprintf(buf, size, "Unknown device %04x:%04x", isv, isd);
  430.       else /* !d */
  431.         res = snprintf(buf, size, "%s Unknown device %04x", v->name, isd);
  432.     }
  433.       break;
  434.     case PCI_LOOKUP_CLASS:
  435.       icls = va_arg(args, int);
  436.       if (num)
  437.     res = snprintf(buf, size, "%04x", icls);
  438.       else if (cls = id_lookup(a, ID_SUBCLASS, icls >> 8, icls & 0xff, 0, 0))
  439.     return (char *) cls->name;
  440.       else if (cls = id_lookup(a, ID_CLASS, icls, 0, 0, 0))
  441.     res = snprintf(buf, size, "%s [%04x]", cls->name, icls);
  442.       else if (synth)
  443.     res = snprintf(buf, size, "Class %04x", icls);
  444.       else
  445.     return NULL;
  446.       break;
  447.     case PCI_LOOKUP_PROGIF:
  448.       icls = va_arg(args, int);
  449.       ipif = va_arg(args, int);
  450.       if (num)
  451.     res = snprintf(buf, size, "%02x", ipif);
  452.       else if (pif = id_lookup(a, ID_PROGIF, icls >> 8, icls & 0xff, ipif, 0))
  453.     return (char *) pif->name;
  454.       else if (icls == 0x0101 && !(ipif & 0x70))
  455.     {
  456.       /* IDE controllers have complex prog-if semantics */
  457.       res = snprintf(buf, size, "%s%s%s%s%s",
  458.              (ipif & 0x80) ? "Master " : "",
  459.              (ipif & 0x08) ? "SecP " : "",
  460.              (ipif & 0x04) ? "SecO " : "",
  461.              (ipif & 0x02) ? "PriP " : "",
  462.              (ipif & 0x01) ? "PriO " : "");
  463.       if (res > 0 && res < size)
  464.         buf[--res] = 0;
  465.     }
  466.       else if (synth)
  467.     res = snprintf(buf, size, "ProgIf %02x", ipif);
  468.       else
  469.     return NULL;
  470.       break;
  471.     default:
  472.       return "<pci_lookup_name: invalid request>";
  473.     }
  474.   if (res < 0 || res >= size)
  475.     return "<pci_lookup_name: buffer too small>";
  476.   else
  477.     return buf;
  478. }
  479.