Add compatibility mode
Add a compatibility mode to the em100 tool. Right now coreboot
and the Chrome OS build system carry a bunch of work-arounds to
produce two sets of images, one for "real SPI chips" and one for
use with the EM100Pro. Instead, we can (and should) just recognize
these images and have the em100 tool handle them correctly during
upload. em100 --compatibility ... does exactly that.
Signed-off-by: Stefan Reinauer <stefan.reinauer@coreboot.org>
Change-Id: Ie02264facb028841d18ed84680ffa40f45987510
Reviewed-on: https://review.coreboot.org/c/em100/+/37258
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Simon Glass <sjg@chromium.org>
diff --git a/Makefile b/Makefile
index 8d8be29..93a2474 100644
--- a/Makefile
+++ b/Makefile
@@ -36,7 +36,7 @@
XZ = xz/xz_crc32.c xz/xz_crc64.c xz/xz_dec_bcj.c xz/xz_dec_lzma2.c xz/xz_dec_stream.c
SOURCES = em100.c firmware.c fpga.c hexdump.c sdram.c spi.c system.c trace.c usb.c
-SOURCES += curl.c chips.c tar.c $(XZ)
+SOURCES += image.c curl.c chips.c tar.c $(XZ)
OBJECTS = $(SOURCES:.c=.o)
all: dep em100
diff --git a/em100.c b/em100.c
index 5fa95dd..7b1e068 100644
--- a/em100.c
+++ b/em100.c
@@ -764,7 +764,8 @@
{"device", 1, 0, 'x'},
{"list-devices", 0, 0, 'l'},
{"update-files", 0, 0, 'U'},
- {"terminal",0 ,0, 'T'},
+ {"terminal", 0, 0, 'T'},
+ {"compatible", 0, 0, 'C'},
{NULL, 0, 0, 0}
};
@@ -793,6 +794,7 @@
" -x|--device EMxxxxxx use EM100pro with serial no EMxxxxxx\n"
" -l|--list-devices list all connected EM100pro devices\n"
" -U|--update-files update device (chip) and firmware database\n"
+ " -C|--compatible enable compatibility mode (patch image for EM100Pro)\n"
" -D|--debug: print debug information.\n"
" -h|--help: this help text\n\n",
name);
@@ -808,7 +810,7 @@
const char *holdpin = NULL;
int do_start = 0, do_stop = 0;
int verify = 0, trace = 0, terminal=0;
- int debug = 0;
+ int debug = 0, compatibility = 0;
int bus = 0, device = 0;
int firmware_is_dpfw = 0;
unsigned int serial_number = 0;
@@ -816,7 +818,7 @@
unsigned int spi_start_address = 0;
const char *voltage = NULL;
- while ((opt = getopt_long(argc, argv, "c:d:a:u:rsvtO:F:f:g:S:V:p:Dx:lUhT",
+ while ((opt = getopt_long(argc, argv, "c:d:a:u:rsvtO:F:f:g:S:V:p:DCx:lUhT",
longopts, &idx)) != -1) {
switch (opt) {
case 'c':
@@ -887,6 +889,9 @@
case 'U':
update_all_files();
return 0;
+ case 'C':
+ compatibility = 1;
+ break;
default:
case 'h':
usage(argv[0]);
@@ -1081,6 +1086,9 @@
return 1;
}
+ if (compatibility)
+ autocorrect_image(&em100, data, length);
+
if (spi_start_address) {
readback = malloc(maxlen);
if (readback == NULL) {
diff --git a/em100.h b/em100.h
index 4e3d74c..d48e52b 100644
--- a/em100.h
+++ b/em100.h
@@ -193,9 +193,13 @@
#define MB * 1024 * 1024
#define FILENAME_BUFFER_SIZE 1024
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
char *get_em100_file(const char *name);
/* Chips */
int parse_dcfg(chipdesc *chip, TFILE *dcfg);
+/* Images */
+int autocorrect_image(struct em100 *em100, char *image, size_t size);
+
#endif
diff --git a/image.c b/image.c
new file mode 100644
index 0000000..9e0b8a7
--- /dev/null
+++ b/image.c
@@ -0,0 +1,228 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * 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; version 2 of the License.
+ *
+ * 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.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include "em100.h"
+
+enum ifd_version {
+ IFD_VERSION_1,
+ IFD_VERSION_2,
+};
+
+enum platform {
+ PLATFORM_APL,
+ PLATFORM_CNL,
+ PLATFORM_GLK,
+ PLATFORM_ICL,
+ PLATFORM_SKLKBL,
+ PLATFORM_TGL,
+};
+
+enum spi_frequency {
+ SPI_FREQUENCY_20MHZ = 0,
+ SPI_FREQUENCY_33MHZ = 1,
+ SPI_FREQUENCY_48MHZ = 2,
+ SPI_FREQUENCY_50MHZ_30MHZ = 4,
+ SPI_FREQUENCY_17MHZ = 6,
+};
+
+/* flash descriptor */
+typedef struct {
+ uint32_t flvalsig;
+ uint32_t flmap0;
+ uint32_t flmap1;
+ uint32_t flmap2;
+} __attribute__((packed)) fdbar_t;
+
+/* component section */
+typedef struct {
+ uint32_t flcomp;
+ uint32_t flill;
+ uint32_t flpb;
+} __attribute__((packed)) fcba_t;
+
+/**
+ * valid_pointer - examine whether a pointer falls in [base, base + limit)
+ * @param ptr: the non-void* pointer to a single arbitrary-sized object.
+ * @param base: base address represented with char* type.
+ * @param limit: upper limit of the legal address.
+ * @return: ptr if valid, otherwise NULL.
+ */
+static void *valid_pointer(char *ptr, char *base, size_t limit)
+{
+ return ((char *)(ptr) >= (base) &&
+ (char *)&(ptr)[1] <= (base) + (limit)) ? ptr : NULL;
+}
+
+/**
+ * find_fd - Find firmware flash descriptor
+ * @param image: pointer to image in ram
+ * @param size: size of image
+ * @return: pointer to flash descriptor or NULL
+ */
+static fdbar_t *find_fd(char *image, int size)
+{
+#define FD_SIGNATURE 0x0FF0A55A
+ int i, found = 0;
+
+ /* Scan for FD signature */
+ for (i = 0; i < (size - 4); i += 4) {
+ if (*(uint32_t *) (image + i) == FD_SIGNATURE) {
+ found = 1;
+ break; /* signature found. */
+ }
+ }
+
+ if (!found) {
+ printf("No Flash Descriptor found in this image\n");
+ return NULL;
+ }
+
+ return (fdbar_t *)valid_pointer(image + i, image, size);
+}
+
+
+/**
+ * find_fcba - Find FCBA block in image
+ * @param image: pointer to image in ram
+ * @param size: size of image
+ * @return: pointer to FCBA or NULL
+ */
+static fcba_t *find_fcba(fdbar_t *fdb, char *image, int size)
+{
+ return (fcba_t *)valid_pointer(image + ((fdb->flmap0 & 0xff) << 4), image, size);
+}
+
+/*
+ * There is no version field in the descriptor so to determine
+ * if this is a new descriptor format we check the hardcoded SPI
+ * read frequency to see if it is fixed at 20MHz or 17MHz.
+ */
+static int get_ifd_version(fcba_t *fcba, int platform)
+{
+ int read_freq;
+ unsigned int i;
+
+ /* Some newer platforms have re-defined the FCBA field that was
+ * used to distinguish IFD v1 v/s v2. Define a list of platforms
+ * that we know do not have the required FCBA field, but are IFD
+ * v2 and return true if current platform is one of them.
+ */
+ static const int ifd_2_platforms[] = {
+ PLATFORM_GLK,
+ PLATFORM_CNL,
+ PLATFORM_ICL,
+ PLATFORM_TGL,
+ };
+
+ /* Unfortunately we do not have a way to determine the
+ * platform of an image any more than we have to determine
+ * its IFD version, but leaving this code in to elaborate
+ * a possible fix.
+ */
+ for (i = 0; i < ARRAY_SIZE(ifd_2_platforms); i++) {
+ if (platform == ifd_2_platforms[i])
+ return IFD_VERSION_2;
+ }
+
+ read_freq = (fcba->flcomp >> 17) & 7;
+
+ switch (read_freq) {
+ case SPI_FREQUENCY_20MHZ:
+ return IFD_VERSION_1;
+ case SPI_FREQUENCY_17MHZ:
+ case SPI_FREQUENCY_50MHZ_30MHZ:
+ return IFD_VERSION_2;
+ default:
+ fprintf(stderr, "Unknown descriptor version: %d\n",
+ read_freq);
+ exit(EXIT_FAILURE);
+ }
+}
+
+static void ifd_set_spi_frequency(fcba_t *fcba, enum spi_frequency freq)
+{
+ /* clear bits 21-30 */
+ fcba->flcomp &= ~0x7fe00000;
+ /* Read ID and Read Status Clock Frequency */
+ fcba->flcomp |= freq << 27;
+ /* Write and Erase Clock Frequency */
+ fcba->flcomp |= freq << 24;
+ /* Fast Read Clock Frequency */
+ fcba->flcomp |= freq << 21;
+}
+
+static void ifd_set_em100_mode(fcba_t *fcba, struct em100 *em100)
+{
+ int freq;
+
+ if (em100->hwversion == HWVERSION_EM100PRO_G2) {
+ printf("Warning: EM100Pro-G2 can run at full speed.\n");
+ }
+
+ /* Auto-detect IFD version. Right now we don't support
+ * hard-coding the IFD version, hence passing -1 for platform.
+ */
+ int ifd_version = get_ifd_version(fcba, -1);
+ switch (ifd_version) {
+ case IFD_VERSION_1:
+ freq = SPI_FREQUENCY_20MHZ;
+ printf("Limit SPI frequency to 20MHz.\n");
+ break;
+ case IFD_VERSION_2:
+ freq = SPI_FREQUENCY_17MHZ;
+ printf("Limit SPI frequency to 17MHz.\n");
+ break;
+ default:
+ freq = SPI_FREQUENCY_17MHZ;
+ printf("Limit SPI frequency to 17MHz.\n");
+ break;
+ }
+
+ ifd_set_spi_frequency(fcba, freq);
+}
+
+/**
+ * autocorrect_image: Modify image to work with EM100
+ * @param em100: initialized em100 device structure
+ * @param image: pointer to emulated image in RAM
+ * @param size: size of emulated image
+ *
+ * @return: 0: image type known and image patched
+ * @return: 1: image type not detected (unpatched)
+ */
+
+int autocorrect_image(struct em100 *em100, char *image, size_t size)
+{
+ printf("Auto-detecting image type ... ");
+ fdbar_t *fdb = find_fd(image, size);
+ if (fdb) {
+ printf("IFD\n");
+
+ fcba_t *fcba = find_fcba(fdb, image, size);
+ if (!fcba) {
+ printf("Inconsistent image.\n");
+ return 1;
+ }
+
+ /* Set EM100 mode */
+ ifd_set_em100_mode(fcba, em100);
+ } else {
+ printf("<unknown>\n");
+ return 1; /* No support for other image types (yet). */
+ }
+
+ return 0;
+}
