Subversion Repositories HelenOS-historic

Rev

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