ls-vpd.c

   1 /*
   2  *      The PCI Utilities -- Show Vital Product Data
   3  *
   4  *      Copyright (c) 2008 Ben Hutchings <bhutchings@solarflare.com>
   5  *
   6  *      Can be freely distributed and used under the terms of the GNU GPL.
   7  */
   8
   9 #include <stdio.h>
  10
  11 #include "lspci.h"
  12
  13 static void
  14 print_vpd_string(const byte *buf, word len)
  15 {
  16   while (len--)
  17     {
  18       byte ch = *buf++;
  19       if (ch == '\\')
  20         printf("\\\\");
  21       else if (ch < 32 || ch == 127)
  22         printf("\\x%02x", ch);
  23       else
  24         putchar(ch);
  25     }
  26 }
  27
  28 static int
  29 read_vpd(struct device *d, int pos, byte *buf, int len, byte *csum)
  30 {
  31   if (!pci_read_vpd(d->dev, pos, buf, len))
  32     return 0;
  33   while (len--)
  34     *csum += *buf++;
  35   return 1;
  36 }
  37
  38 void
  39 cap_vpd(struct device *d)
  40 {
  41   word res_addr = 0, res_len, part_pos, part_len;
  42   byte key[2], buf[256];
  43   byte tag;
  44   byte csum = 0;
  45
  46   printf("Vital Product Data\n");
  47
  48   while (res_addr <= PCI_VPD_ADDR_MASK)
  49     {
  50       if (!read_vpd(d, res_addr, &tag, 1, &csum))
  51         break;
  52       if (tag & 0x80)
  53         {
  54           if (res_addr > PCI_VPD_ADDR_MASK + 1 - 3)
  55             break;
  56           if (!read_vpd(d, res_addr + 1, buf, 2, &csum))
  57             break;
  58           res_len = buf[0] + (buf[1] << 8);
  59           res_addr += 3;
  60         }
  61       else
  62         {
  63           res_len = tag & 7;
  64           tag >>= 3;
  65           res_addr += 1;
  66         }
  67       if (res_len > PCI_VPD_ADDR_MASK + 1 - res_addr)
  68         break;
  69
  70       part_pos = 0;
  71
  72       switch (tag)
  73         {
  74         case 0x0f:
  75           printf("\t\tEnd\n");
  76           return;
  77
  78         case 0x82:
  79           printf("\t\tProduct Name: ");
  80           while (part_pos < res_len)
  81             {
  82               part_len = res_len - part_pos;
  83               if (part_len > sizeof(buf))
  84                 part_len = sizeof(buf);
  85               if (!read_vpd(d, res_addr + part_pos, buf, part_len, &csum))
  86                 break;
  87               print_vpd_string(buf, part_len);
  88               part_pos += part_len;
  89             }
  90           printf("\n");
  91           break;
  92
  93         case 0x90:
  94         case 0x91:
  95           printf("\t\t%s fields:\n",
  96                  (tag == 0x90) ? "Read-only" : "Read/write");
  97
  98           while (part_pos + 3 <= res_len)
  99             {
 100               word read_len;
 101
 102               if (!read_vpd(d, res_addr + part_pos, buf, 3, &csum))
 103                 break;
 104               part_pos += 3;
 105               key[0] = buf[0];
 106               key[1] = buf[1];
 107               part_len = buf[2];
 108               if (part_len > res_len - part_pos)
 109                 break;
 110
 111               /* Only read the first byte of the RV field because the
 112                * remaining bytes are not included in the checksum. */
 113               read_len = (key[0] == 'R' && key[1] == 'V') ? 1 : part_len;
 114               if (!read_vpd(d, res_addr + part_pos, buf, read_len, &csum))
 115                 break;
 116
 117               if ((key[0] == 'E' && key[1] == 'C') ||
 118                   (key[0] == 'P' && key[1] == 'N') ||
 119                   (key[0] == 'S' && key[1] == 'N') ||
 120                   key[0] == 'V' ||
 121                   key[0] == 'Y')
 122                 {
 123                   /* Alphanumeric content */
 124                   printf("\t\t\t%c%c: ", key[0], key[1]);
 125                   print_vpd_string(buf, part_len);
 126                   printf("\n");
 127                 }
 128               else if (key[0] == 'R' && key[1] == 'V')
 129                 {
 130                   /* Reserved and checksum */
 131                   printf("\t\t\tRV: checksum %s, %d byte(s) reserved\n",
 132                          csum ? "bad" : "good", part_len - 1);
 133                 }
 134               else if (key[0] == 'R' && key[1] == 'W')
 135                 {
 136                   /* Read-write area */
 137                   printf("\t\t\tRW: %d byte(s) free\n", part_len);
 138                 }
 139               else
 140                 {
 141                   /* Binary or unknown content */
 142                   int i;
 143                   printf("\t\t\t%c%c:", key[0], key[1]);
 144                   for (i = 0; i < part_len; i++)
 145                     printf(" %02x", buf[i]);
 146                   printf("\n");
 147                 }
 148
 149               part_pos += part_len;
 150             }
 151           break;
 152
 153         default:
 154           printf("\t\tUnknown %s resource type %02x\n",
 155                  (tag & 0x80) ? "large" : "small", tag & ~0x80);
 156           break;
 157         }
 158
 159       res_addr += res_len;
 160     }
 161
 162   if (res_addr == 0)
 163     printf("\t\tNot readable\n");
 164   else
 165     printf("\t\tNo end tag found\n");
 166 }