Supports SPD in VPD partition.

vpd.c

 /*
  * Copyright (C) 2010 Google Inc.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  *
  */
 #include <assert.h>
 #include <errno.h>
+#include <getopt.h>
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <getopt.h>
+#include <uuid/uuid.h>
 #include "lib/flashrom.h"
 #include "lib/fmap.h"
 #include "lib/lib_vpd.h"
 #include "lib/lib_smbios.h"
 #include "lib/vpd.h"
 #include "lib/vpd_tables.h"
 
 /* The buffer length. Right now the VPD partition size on flash is 128KB. */
 #define BUF_LEN (128 * 1024)
 
 static uint8_t flashrom_tmp_file[] = "/tmp/vpd.flashrom.XXXXXX";
 
 /* 2 containers:
  *   file:      stores decoded pairs from file.
  *   argument:  stores parsed pairs from command arguments.
  */
 struct PairContainer file;
 struct PairContainer argument;
 
 /* The current padding length value.
  * Default: VPD_AS_LONG_AS
  */
 int pad_value_len = VPD_AS_LONG_AS;
 
 /* The output buffer */
 unsigned char buf[BUF_LEN];
 int buf_len = 0;
 int max_buf_len = sizeof(buf);
 
-/* The EPS base address is used to fill the EPS table entry. */
-uint32_t eps_base = GOOGLE_VPD_2_0_EPS_BASE;
+/* The EPS base address used to fill the EPS table entry.
+ * If the VPD partition can be found in fmap, this points to the starting
+ * offset of VPD partition. If not found, this is used to be the base address
+ * to increase SPD and VPD 2.0 offset fields.
+ *
+ * User can overwrite this by -E argument.
+ */
+uint32_t eps_base = GOOGLE_EPS_BASE;
 
 /* the fmap name of VPD. */
 uint8_t fmap_vpd_area_name[FMAP_STRLEN] = "RO VPD";
+
 /* If found_vpd, replace the VPD partition when saveFile().
  * If not found, always create new file when saveFlie(). */
 int found_vpd = 0;
-/* The VPD offset and size in buf[] */
-off_t vpd_offset = 0, vpd_size = 0;
+
+/* The VPD partition offset and size in buf[]. The whole partition includes:
+ *
+ *   SMBIOS EPS
+ *   SMBIOS tables[]
+ *   SPD
+ *   VPD 2.0 data
+ *
+ * For those offset values below, ABSENT means not presented in buffer.
+ */
+off_t vpd_offset = 0, vpd_size;  /* The whole partition */
+/* Below offset are related to vpd_offset and assume positive.
+ * Those are used in saveFile() to write back data. */
+off_t eps_offset = 0;  /* EPS's starting address. Tables[] is following. */
+off_t spd_offset = GOOGLE_SPD_OFFSET;  /* SPD address .*/
+off_t vpd_2_0_offset = GOOGLE_VPD_2_0_OFFSET; /* VPD 2.0 data address. */
+
+/* This points to the SPD data if it is availiable when loadFile().
+ * The memory is allocated in loadFile(), will be used in saveFile(),
+ * and freed at end of main(). */
+uint8_t *spd_data = NULL;
+int32_t spd_len = 256;  /* max value for DDR3 */
 
 /* for debug purpose */
 void dumpBuf() {
   int i;
   for(i = 0; i < buf_len; ++i) {
     printf("%02x ", buf[i]);
     if ((i % 16) == 15) printf("\n");
   }
 }
 
 
 /*  Given the offset of blob block (related to the first byte of EPS) and
  *  the size of blob, the is function generates an SMBIOS ESP.
  */
 int buildEpsAndTables(
-    const int offset_blob,
     const int size_blob,
     const int max_buf_len,
     unsigned char *buf,
     int *generated) {
   struct vpd_entry *eps;
   unsigned char *table = NULL;          /* the structure table */
   int table_len = 0;
   int num_structures = 0;
   int retval = VPD_OK;
 
   assert(buf);
   assert(generated);
 
   buf += *generated;
 
-  /* Generate type 241 */
+  /* Generate type 241 - SPD data */
   table_len = vpd_append_type241(0, &table, table_len,
+                                 GOOGLE_SPD_UUID,
+                                 eps_base + GOOGLE_SPD_OFFSET,
+                                 spd_len,  /* Max length for DDR3 */
+                                 GOOGLE_SPD_VENDOR,
+                                 GOOGLE_SPD_DESCRIPTION,
+                                 GOOGLE_SPD_VARIANT);
+  if (table_len < 0) {
+    retval = VPD_FAIL;
+    goto error_1;
+  }
+  num_structures++;
+
+  /* Generate type 241 - VPD 2.0 */
+  table_len = vpd_append_type241(1, &table, table_len,
                                  GOOGLE_VPD_2_0_UUID,
-                                 eps_base + offset_blob,
+                                 eps_base + GOOGLE_VPD_2_0_OFFSET,
                                  size_blob,
                                  GOOGLE_VPD_2_0_VENDOR,
                                  GOOGLE_VPD_2_0_DESCRIPTION,
                                  GOOGLE_VPD_2_0_VARIANT);
   if (table_len < 0) {
     retval = VPD_FAIL;
     goto error_1;
   }
   num_structures++;
 
   /* Generate type 127 */
-  table_len = vpd_append_type127(1, &table, table_len);
+  table_len = vpd_append_type127(2, &table, table_len);
   if (table_len < 0) {
     retval = VPD_FAIL;
     goto error_1;
   }
   num_structures++;
 
   /* Generate EPS */
   eps = vpd_create_eps(table_len, num_structures, eps_base);
   if ((*generated + eps->entry_length) > max_buf_len) {
     retval = VPD_FAIL;
@@ skipping 49 matching lines @@
              int overwrite_it) {
   FILE *fp;
   int file_size;
   uint8_t *read_buf;
   off_t sig_offset;
   struct fmap *fmap;
   uint8_t *vpd_buf;
   struct vpd_entry *eps;
   struct vpd_header *header;
   struct vpd_table_binary_blob_pointer *data;
+  uint8_t spd_uuid[16], vpd_2_0_uuid[16];
+  int expected_handle = 0;
+  int table_len;
   int index;
   int retval = 0;
 
   if (!(fp = fopen(filename, "r"))) {
-    fprintf(stderr, "* File [%s] cannot be opened for read. Ignored.\n",
+    fprintf(stderr, "[WARN] File [%s] cannot be opened for read. Ignored.\n",
             filename);
     return 0;
   }
   /* get file size */
   fseek(fp, 0, SEEK_END);
   file_size = ftell(fp);
 
   /* read file content */
   fseek(fp, 0, SEEK_SET);
   read_buf = malloc(file_size);
   assert(read_buf);
   if (file_size != fread(read_buf, 1, file_size, fp)) {
     fprintf(stderr, "Reading file [%s] failed.\n", filename);
     retval = 1;
     goto teardown;
   }
   fclose(fp);
 
   /* scan the file and find out the VPD partition. */
   sig_offset = fmapFind(read_buf, file_size);
   if (-1 == sig_offset) {
-    /* FMAP signature is not found, assume it is pure VPD content. */
+    /* FMAP signature is not found, assume it is pure VPD partition. */
     vpd_buf = read_buf;
     eps = (struct vpd_entry *)vpd_buf;
 
     /* In overwrite mode, ignore all existing data. */
     if (overwrite_it) {
       retval = 0;
       goto teardown;
     }
   } else {
     int i;
 
     fmap = (struct fmap *)&read_buf[sig_offset];
     for(i = 0; i < fmap->nareas; i++) {
       fmapNormalizeAreaName(fmap->areas[i].name);
     }
 
     if (FMAP_OK == fmapGetArea(fmap_vpd_area_name, fmap,
                                &vpd_offset, &vpd_size)) {
-      fprintf(stderr,
-              "FMAP and area are found, eps_base changed from 0x%x to 0x%lx\n",
-              eps_base, vpd_offset);
+      found_vpd = 1;  /* Mark found here then saveFile() knows where to
+                       * write back (vpd_offset, vpd_size). */
       eps_base = vpd_offset;
       vpd_buf = &read_buf[vpd_offset];
       eps = (struct vpd_entry *)vpd_buf;
 
       /* In overwrite mode, the VPD content is erased before reading. */
       if (overwrite_it) {
-        memset(vpd_buf, 0xff, vpd_size);
+        retval = 0;
+        goto teardown;
       }
     } else {
       fprintf(stderr, "The VPD partition [%s] is not found.\n",
               fmap_vpd_area_name);
       retval = 1;
       goto teardown;
     }
+  }
+  /* Now, vpd_buf points to the VPD partition in buffer.
+   * eps points to the EPS structure, which is usually equal to vpd_buf. */
+  eps_offset = (uint8_t*)eps - vpd_buf;
 
-    /* jump if the VPD partition is not recognized. */
-    if (memcmp(VPD_ENTRY_MAGIC, eps, sizeof(VPD_ENTRY_MAGIC) - 1)) {
-      /* But OKAY if the VPD partition is all-FF, which is un-used. */
-      if (memcmp("\xff\xff\xff\xff", eps, sizeof(VPD_ENTRY_MAGIC) - 1)) {
-        fprintf(stderr, "FMAP found, but SMBIOS signature is not matched.\n");
-        fprintf(stderr, "You may use -O to overwrite the data.\n");
+  /* jump if the VPD partition is not recognized. */
+  if (memcmp(VPD_ENTRY_MAGIC, eps, sizeof(VPD_ENTRY_MAGIC) - 1)) {
+    /* But OKAY if the VPD partition is all-FF, which is un-used. */
+    if (memcmp("\xff\xff\xff\xff", eps, sizeof(VPD_ENTRY_MAGIC) - 1)) {
+      fprintf(stderr, "SMBIOS signature is not matched.\n");
+      fprintf(stderr, "You may use -O to overwrite the data.\n");
+      retval = 1;
+      goto teardown;
+    }
+    /* TODO(yjlou): need more EPS sanity checks here. */
+  }
+  /* EPS is done above. Parse structure tables below. */
+  /* Get the first type 241 blob, at the tail of EPS. */
+  header = (struct vpd_header*)(((uint8_t*)eps) + eps->entry_length);
+  data = (struct vpd_table_binary_blob_pointer *)
+         ((uint8_t *)header + sizeof(*header));
+
+  /* TODO(yjlou): Re-factor the parsing code to support more SMBIOS entries.
+   *              The current code only supports 2 combinations:
+   *                1. Type 241 (SPD) + Type 241 (VPD 2.0) + Type 127
+   *                2. Type 241 (VPD 2.0) + Type 127
+   */
+
+  /* Now header points to the first SMBIOS entry, and data points to the
+   * first BBP entry. The first entry could be SPD data. We don't care. */
+  if (header->handle != expected_handle) {
+    fprintf(stderr, "The first handle value must be 0, but is %d.\n",
+                    header->handle);
+    retval = 1;
+    goto teardown;
+  }
+  if (header->type != VPD_TYPE_BINARY_BLOB_POINTER) {
+    fprintf(stderr, "Expect first entry is type Binary Blob Pointer (241),"
+                    " but actually is %d\n", header->type);
+    fprintf(stderr, "You may use -O to overwrite the data.\n");
+    retval = 1;
+    goto teardown;
+  }
+  uuid_parse(GOOGLE_SPD_UUID, spd_uuid);
+  if (!memcmp(data->uuid, spd_uuid, sizeof(data->uuid))) {
+    ++expected_handle;
+    spd_offset = data->offset - eps_base;
+    spd_len = data->size;
+    if (vpd_offset + spd_offset + spd_len >= file_size) {
+      fprintf(stderr, "[ERROR] SPD offset in BBP is not correct.\n"
+                      "        vpd=0x%x spd=0x%x len=0x%x file_size=0x%x\n"
+                      "        If this file is VPD partition only, try to\n"
+                      "        use -E to adjust offset values.\n",
+                      (uint32_t)vpd_offset, (uint32_t)spd_offset,
+                      spd_len, file_size);
+      retval = 1;
+      goto teardown;
+    }
+    if (!(spd_data = malloc(spd_len))) {
+      fprintf(stderr, "spd_data: malloc(%d bytes) failed.\n", spd_len);
+      retval = 1;
+      goto teardown;
+    }
+    memcpy(spd_data, &read_buf[vpd_offset + spd_offset], spd_len);
+
+    /* move to next table */
+    if ((table_len = vpd_type241_size(header)) < 0) {
+      fprintf(stderr, "[ERROR] Cannot get type 241 structure table length.\n");
+      retval = 1;
+      goto teardown;
+    }
+    header = (struct vpd_header*)((uint8_t*)header + table_len);
+    data = (struct vpd_table_binary_blob_pointer *)
+           ((uint8_t *)header + sizeof(*header));
+  }
+
+  /* The 2nd could be VPD 2.0 data or End Of Table. */
+  if (header->handle != expected_handle) {
+    fprintf(stderr, "The second handle value must be 1, but is %d.\n",
+                    header->handle);
+    retval = 1;
+    goto teardown;
+  }
+  uuid_parse(GOOGLE_VPD_2_0_UUID, vpd_2_0_uuid);
+  if (header->type == VPD_TYPE_BINARY_BLOB_POINTER &&
+      !memcmp(data->uuid, vpd_2_0_uuid, sizeof(data->uuid))) {
+    ++expected_handle;
+
+    /* iterate all pairs */
+    for (index = data->offset - eps_base;  /* skip the EPS */
+         vpd_buf[index] != VPD_TYPE_TERMINATOR &&
+         vpd_buf[index] != VPD_TYPE_IMPLICIT_TERMINATOR;) {
+      if (VPD_OK != decodeVpdString(file_size, vpd_buf, container, &index)) {
+        fprintf(stderr, "decodeVpdString() error.\n");
         retval = 1;
         goto teardown;
       }
     }
 
-    /* mark the VPD is found, so that saveFile() knows where to overwrite
-     *  (vpd_offset, vpd_size). */
-    found_vpd = 1;
-  }
-
-  /* Get type 241 blob */
-  header = (struct vpd_header*)(((uint8_t*)eps) + eps->entry_length);
-  data = (struct vpd_table_binary_blob_pointer *)
-         ((uint8_t *)header + sizeof(*header));
-
-  /* iterate all pairs */
-  for (index = data->offset - eps_base;  /* skip the EPS */
-       vpd_buf[index] != VPD_TYPE_TERMINATOR &&
-       vpd_buf[index] != VPD_TYPE_IMPLICIT_TERMINATOR;) {
-    if (VPD_OK != decodeVpdString(file_size, vpd_buf, container, &index)) {
-      fprintf(stderr, "decodeVpdString() error.\n");
+    /* move to next table */
+    if ((table_len = vpd_type241_size(header)) < 0) {
+      fprintf(stderr, "[ERROR] Cannot get type 241 structure table length.\n");
       retval = 1;
       goto teardown;
     }
+    header = (struct vpd_header*)((uint8_t*)header + table_len);
+    data = (struct vpd_table_binary_blob_pointer *)
+           ((uint8_t *)header + sizeof(*header));
+  } else {
+    fprintf(stderr, "[WARN] no VPD 2.0 BBP is found, ignored.\n");
+    retval = 0;
+    goto teardown;
+  }
+
+  if (header->type != VPD_TYPE_END) {
+    fprintf(stderr, "[WARN] we expect the last one is type 127. Ignored.\n");
   }
 
 teardown:
   free(read_buf);
 
   return retval;
 }
 
 
 int saveFile(const struct PairContainer *container, const char *filename) {
   FILE *fp;
   unsigned char eps[1024];
   int eps_len = 0;
   int retval = 0;
 
+  memset(eps, 0, sizeof(eps));
+
   /* encode into buffer */
   if (VPD_OK != encodeContainer(&file, max_buf_len, buf, &buf_len)) {
     fprintf(stderr, "encodeContainer() error.\n");
     retval = 1;
     goto teardown;
   }
   if (VPD_OK != encodeVpdTerminator(max_buf_len, buf, &buf_len)) {
     fprintf(stderr, "Out of space for terminator.\n");
     retval = 1;
     goto teardown;
   }
 
-  if (VPD_OK != buildEpsAndTables(GOOGLE_VPD_2_0_OFFSET, buf_len,
-                                  sizeof(eps), eps, &eps_len)) {
+  if (VPD_OK != buildEpsAndTables(buf_len, sizeof(eps), eps, &eps_len)) {
     fprintf(stderr, "Cannot build EPS.\n");
     retval = 1;
     goto teardown;
   }
-  assert(eps_len <= GOOGLE_VPD_2_0_OFFSET);
-  eps_len = GOOGLE_VPD_2_0_OFFSET;
+  assert(eps_len <= GOOGLE_SPD_OFFSET);
 
+  /* Write data in the following order:
+   *   1. EPS
+   *   2. SPD
+   *   3. VPD 2.0
+  */
   if (found_vpd) {
-    /* We found VPD in file, which means file is existed.
+    /* We found VPD partition in -f file, which means file is existed.
      * Instead of truncating the whole file, open to write partial. */
     if (!(fp = fopen(filename, "r+"))) {
       fprintf(stderr, "File [%s] cannot be opened for write.\n", filename);
       retval = 1;
       goto teardown;
     }
-    /* Move file cursor to VPD section */
-    if (fseek(fp, vpd_offset, SEEK_SET)) {
-      fprintf(stderr,"fseek(0x%lx) error: %s\n", vpd_offset, strerror(errno));
-      retval = 1;
-      goto teardown;
-    }
   } else {
     /* VPD is not found, which means the file is pure VPD data.
      * Always creates the new file and overwrites the original content. */
     if (!(fp = fopen(filename, "w+"))) {
       fprintf(stderr, "File [%s] cannot be opened for write.\n", filename);
       retval = 1;
       goto teardown;
     }
   }
+
+  /* write EPS */
+  fseek(fp, vpd_offset + eps_offset, SEEK_SET);
   if (fwrite(eps, eps_len, 1, fp) != 1) {
     fprintf(stderr, "fwrite(EPS) error (%s)\n", strerror(errno));
     retval = 1;
     goto teardown;
   }
+
+  /* write SPD */
+  if (spd_data) {
+    fseek(fp, vpd_offset + spd_offset, SEEK_SET);
+    if (fwrite(spd_data, spd_len, 1, fp) != 1) {
+      fprintf(stderr, "fwrite(SPD) error (%s)\n", strerror(errno));
+      retval = 1;
+      goto teardown;
+    }
+  }
+
+  /* write VPD 2.0 */
+  fseek(fp, vpd_offset + vpd_2_0_offset, SEEK_SET);
   if (fwrite(buf, buf_len, 1, fp) != 1) {
-    fprintf(stderr, "fwrite(VPD) error (%s)\n", strerror(errno));
+    fprintf(stderr, "fwrite(VPD 2.0) error (%s)\n", strerror(errno));
     retval = 1;
     goto teardown;
   }
   fclose(fp);
 
 teardown:
   return retval;
 }
 
 
 static void usage(const char *progname) {
   printf("Chrome OS VPD 2.0 utility --\n");
 #ifdef VPD_VERSION
   printf("%s\n", VPD_VERSION);
 #endif
   printf("\n");
   printf("Usage: %s [OPTION] ...\n", progname);
   printf("   OPTIONs include:\n");
   printf("      -h               This help page and version.\n");
   printf("      -f <filename>    The output file name.\n");
   printf("      -E <address>     EPS base address (default:0x240000).\n");
   printf("      -s <key=value>   To add/change a string value.\n");
   printf("      -p <pad length>  Pad if length is shorter.\n");
   printf("      -i <partition>   Specify VPD partition name in fmap.\n");
   printf("      -l               List content in the file.\n");
-  printf("      -O               Overwrite current VPD partition.\n");
+  printf("      -O               Overwrite and re-format VPD partition.\n");
   printf("\n");
 }
 
 int main(int argc, char *argv[]) {
   int opt;
   int option_index = 0;
   int retval = 0;
   const char *optstring = "hf:E:s:p:i:lO";
   static struct option long_options[] = {
     {"help", 0, 0, 'h'},
@@ skipping 137 matching lines @@
     if (write_back_to_flash) {
       if (FLASHROM_OK != flashromPartialWrite(filename, vpd_offset, vpd_size)) {
         fprintf(stderr, "flashromPartialWrite() error.\n");
         retval = 1;
         goto teardown;
       }
     }
   }
 
 teardown:
+  if (spd_data) free(spd_data);
   if (filename) free(filename);
   destroyContainer(&file);
   destroyContainer(&argument);
 
   return retval;
 }