ls-vpd.c

   1 /*
   2  *      The PCI Utilities -- Show Vital Product Data
   3  *
   4  *      Copyright (c) 2008 Solarflare Communications
   5  *
   6  *      Written by Ben Hutchings <bhutchings@solarflare.com>
   7  *      Improved by Martin Mares <mj@ucw.cz>
   8  *
   9  *      Can be freely distributed and used under the terms of the GNU GPL.
  10  */
  11
  12 #include <stdio.h>
  13
  14 #include "lspci.h"
  15
  16 /*
  17  *  The list of all known VPD items and their formats.
  18  *  Technically, this belongs to the pci.ids file, but the VPD does not seem
  19  *  to be developed any longer, so we have chosen the easier way.
  20  */
  21
  22 enum vpd_format {
  23   F_BINARY,
  24   F_TEXT,
  25   F_RESVD,
  26   F_RDWR,
  27 };
  28
  29 static const struct vpd_item {
  30   byte id1, id2;
  31   byte format;
  32   const char *name;
  33 } vpd_items[] = {
  34   { 'C','P', F_BINARY,  "Extended capability" },
  35   { 'E','C', F_TEXT,    "Engineering changes" },
  36   { 'M','N', F_BINARY,  "Manufacture ID" },
  37   { 'P','N', F_TEXT,    "Part number" },
  38   { 'R','V', F_RESVD,   "Reserved" },
  39   { 'R','W', F_RDWR,    "Read-write area" },
  40   { 'S','N', F_TEXT,    "Serial number" },
  41   { 'Y','A', F_TEXT,    "Asset tag" },
  42   { 'V', 0 , F_TEXT,    "Vendor specific" },
  43   { 'Y', 0 , F_TEXT,    "System specific" },
  44   {  0,  0 , F_BINARY,  NULL }
  45 };
  46
  47 static void
  48 print_vpd_string(const byte *buf, word len)
  49 {
  50   while (len--)
  51     {
  52       byte ch = *buf++;
  53       if (ch == '\\')
  54         printf("\\\\");
  55       else if (ch < 32 || ch == 127)
  56         printf("\\x%02x", ch);
  57       else
  58         putchar(ch);
  59     }
  60 }
  61
  62 static void
  63 print_vpd_binary(const byte *buf, word len)
  64 {
  65   int i;
  66   for (i = 0; i < len; i++)
  67     {
  68       if (i)
  69         putchar(' ');
  70       printf("%02x", buf[i]);
  71     }
  72 }
  73
  74 static int
  75 read_vpd(struct device *d, int pos, byte *buf, int len, byte *csum)
  76 {
  77   if (!pci_read_vpd(d->dev, pos, buf, len))
  78     return 0;
  79   while (len--)
  80     *csum += *buf++;
  81   return 1;
  82 }
  83
  84 void
  85 cap_vpd(struct device *d)
  86 {
  87   word res_addr = 0, res_len, part_pos, part_len;
  88   byte buf[256];
  89   byte tag;
  90   byte csum = 0;
  91
  92   printf("Vital Product Data\n");
  93   if (verbose < 2)
  94     return;
  95
  96   while (res_addr <= PCI_VPD_ADDR_MASK)
  97     {
  98       if (!read_vpd(d, res_addr, &tag, 1, &csum))
  99         break;
 100       if (tag & 0x80)
 101         {
 102           if (res_addr > PCI_VPD_ADDR_MASK + 1 - 3)
 103             break;
 104           if (!read_vpd(d, res_addr + 1, buf, 2, &csum))
 105             break;
 106           res_len = buf[0] + (buf[1] << 8);
 107           res_addr += 3;
 108         }
 109       else
 110         {
 111           res_len = tag & 7;
 112           tag >>= 3;
 113           res_addr += 1;
 114         }
 115       if (res_len > PCI_VPD_ADDR_MASK + 1 - res_addr)
 116         break;
 117
 118       part_pos = 0;
 119
 120       switch (tag)
 121         {
 122         case 0x0f:
 123           printf("\t\tEnd\n");
 124           return;
 125
 126         case 0x82:
 127           printf("\t\tProduct Name: ");
 128           while (part_pos < res_len)
 129             {
 130               part_len = res_len - part_pos;
 131               if (part_len > sizeof(buf))
 132                 part_len = sizeof(buf);
 133               if (!read_vpd(d, res_addr + part_pos, buf, part_len, &csum))
 134                 break;
 135               print_vpd_string(buf, part_len);
 136               part_pos += part_len;
 137             }
 138           printf("\n");
 139           break;
 140
 141         case 0x90:
 142         case 0x91:
 143           printf("\t\t%s fields:\n",
 144                  (tag == 0x90) ? "Read-only" : "Read/write");
 145
 146           while (part_pos + 3 <= res_len)
 147             {
 148               word read_len;
 149               const struct vpd_item *item;
 150               struct vpd_item unknown_item;
 151
 152               if (!read_vpd(d, res_addr + part_pos, buf, 3, &csum))
 153                 break;
 154               part_pos += 3;
 155               part_len = buf[2];
 156               if (part_len > res_len - part_pos)
 157                 break;
 158
 159               /* Is this item known? */
 160               for (item=vpd_items; item->id1 && item->id1 != buf[0] ||
 161                                    item->id2 && item->id2 != buf[1]; item++)
 162                 ;
 163               if (!item->id1 && !item->id2)
 164                 {
 165                   unknown_item.id1 = buf[0];
 166                   unknown_item.id2 = buf[1];
 167                   unknown_item.format = F_BINARY;
 168                   unknown_item.name = "Unknown";
 169                   item = &unknown_item;
 170                 }
 171
 172               /* Only read the first byte of the RV field because the
 173                * remaining bytes are not included in the checksum. */
 174               read_len = (item->format == F_RESVD) ? 1 : part_len;
 175               if (!read_vpd(d, res_addr + part_pos, buf, read_len, &csum))
 176                 break;
 177
 178               printf("\t\t\t[%c%c] %s: ", item->id1, item->id2, item->name);
 179
 180               switch (item->format)
 181                 {
 182                 case F_TEXT:
 183                   print_vpd_string(buf, part_len);
 184                   printf("\n");
 185                   break;
 186                 case F_BINARY:
 187                   print_vpd_binary(buf, part_len);
 188                   printf("\n");
 189                   break;
 190                 case F_RESVD:
 191                   printf("checksum %s, %d byte(s) reserved\n", csum ? "bad" : "good", part_len - 1);
 192                   break;
 193                 case F_RDWR:
 194                   printf("%d byte(s) free\n", part_len);
 195                   break;
 196                 }
 197
 198               part_pos += part_len;
 199             }
 200           break;
 201
 202         default:
 203           printf("\t\tUnknown %s resource type %02x\n",
 204                  (tag & 0x80) ? "large" : "small", tag & ~0x80);
 205           break;
 206         }
 207
 208       res_addr += res_len;
 209     }
 210
 211   if (res_addr == 0)
 212     printf("\t\tNot readable\n");
 213   else
 214     printf("\t\tNo end tag found\n");
 215 }