Support variable-size SPI chip for dummy programmer.

dummyflasher.c

 /*
  * This file is part of the flashrom project.
  *
  * Copyright (C) 2009,2010 Carl-Daniel Hailfinger
  *
  * 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.
  *
  * 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 St, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
 #include <string.h>
 #include <stdlib.h>
 #include "flash.h"
 #include "chipdrivers.h"
 #include "programmer.h"
+#include "flashchips.h"
 
 /* Remove the #define below if you don't want SPI flash chip emulation. */
 #define EMULATE_SPI_CHIP 1
 
 #if EMULATE_SPI_CHIP
 #define EMULATE_CHIP 1
 #include "spi.h"
 #endif
 
 #if EMULATE_CHIP
 #include <sys/types.h>
 #include <sys/stat.h>
+
+#if EMULATE_SPI_CHIP
+/* The name of variable-size virtual chip. A 4MB flash example:
+ *   flashrom -p dummy:emulate=VARIABLE_SIZE,size=4194304
+ */
+#define VARIABLE_SIZE_CHIP_NAME "VARIABLE_SIZE"
+#endif
 #endif
 
 #if EMULATE_CHIP
 static uint8_t *flashchip_contents = NULL;
 enum emu_chip {
         EMULATE_NONE,
         EMULATE_ST_M25P10_RES,
         EMULATE_SST_SST25VF040_REMS,
         EMULATE_SST_SST25VF032B,
+        EMULATE_VARIABLE_SIZE,
 };
 static enum emu_chip emu_chip = EMULATE_NONE;
 static char *emu_persistent_image = NULL;
 static int emu_chip_size = 0;
 #if EMULATE_SPI_CHIP
 static int emu_max_byteprogram_size = 0;
 static int emu_max_aai_size = 0;
 static int emu_jedec_se_size = 0;
 static int emu_jedec_be_52_size = 0;
 static int emu_jedec_be_d8_size = 0;
 static int emu_jedec_ce_60_size = 0;
 static int emu_jedec_ce_c7_size = 0;
 #endif
 #endif
 
 static int spi_write_256_chunksize = 256;
 
 int dummy_init(void)
 {
         char *bustext = NULL;
         char *tmp = NULL;
 #if EMULATE_CHIP
         struct stat image_stat;
+#if EMULATE_SPI_CHIP
+        int size = -1;  /* size for generic chip */
+#endif
 #endif
 
         msg_pspew("%s\n", __func__);
 
         bustext = extract_programmer_param("bus");
         msg_pdbg("Requested buses are: %s\n", bustext ? bustext : "default");
         if (!bustext)
                 bustext = strdup("parallel+lpc+fwh+spi");
         /* Convert the parameters to lowercase. */
         tolower_string(bustext);
@@ skipping 24 matching lines @@
         if (tmp) {
                 spi_write_256_chunksize = atoi(tmp);
                 free(tmp);
                 if (spi_write_256_chunksize < 1) {
                         msg_perr("invalid spi_write_256_chunksize\n");
                         return 1;
                 }
         }
 
 #if EMULATE_CHIP
+#if EMULATE_SPI_CHIP
+        tmp = extract_programmer_param("size");
+        if (tmp) {
+                int multiplier = 1;
+                if (strlen(tmp)) {
+                        int remove_last_char = 1;
+                        switch (tmp[strlen(tmp) - 1]) {
+                        case 'k': case 'K':
+                                multiplier = 1024;
+                                break;
+                        case 'm': case 'M':
+                                multiplier = 1024 * 1024;
+                                break;
+                        default:
+                                remove_last_char = 0;
+                                break;
+                        }
+                        if (remove_last_char) tmp[strlen(tmp) - 1] = '\0';
+                }
+                size = atoi(tmp) * multiplier;
+        }
+#endif
+
         tmp = extract_programmer_param("emulate");
         if (!tmp) {
                 msg_pdbg("Not emulating any flash chip.\n");
                 /* Nothing else to do. */
                 return 0;
         }
 #if EMULATE_SPI_CHIP
         if (!strcmp(tmp, "M25P10.RES")) {
                 emu_chip = EMULATE_ST_M25P10_RES;
                 emu_chip_size = 128 * 1024;
@@ skipping 26 matching lines @@
                 emu_max_byteprogram_size = 1;
                 emu_max_aai_size = 2;
                 emu_jedec_se_size = 4 * 1024;
                 emu_jedec_be_52_size = 32 * 1024;
                 emu_jedec_be_d8_size = 64 * 1024;
                 emu_jedec_ce_60_size = emu_chip_size;
                 emu_jedec_ce_c7_size = emu_chip_size;
                 msg_pdbg("Emulating SST SST25VF032B SPI flash chip (RDID, AAI "
                          "write)\n");
         }
+        if (!strncmp(tmp, VARIABLE_SIZE_CHIP_NAME,
+                          strlen(VARIABLE_SIZE_CHIP_NAME))) {
+                if (size == -1) {
+                        msg_perr("%s: the size parameter is not given.\n",
+                                 __func__);
+                        free(tmp);
+                        return 1;
+                }
+                emu_chip = EMULATE_VARIABLE_SIZE;
+                emu_chip_size = size;
+                emu_max_byteprogram_size = 256;
+                emu_max_aai_size = 0;
+                emu_jedec_se_size = 4 * 1024;
+                emu_jedec_be_52_size = 32 * 1024;
+                emu_jedec_be_d8_size = 64 * 1024;
+                emu_jedec_ce_60_size = emu_chip_size;
+                emu_jedec_ce_c7_size = emu_chip_size;
+                msg_pdbg("Emulating generic SPI flash chip (size=%d bytes)\n",
+                         emu_chip_size);
+        }
 #endif
         if (emu_chip == EMULATE_NONE) {
                 msg_perr("Invalid chip specified for emulation: %s\n", tmp);
                 free(tmp);
                 return 1;
         }
         free(tmp);
         flashchip_contents = malloc(emu_chip_size);
         if (!flashchip_contents) {
                 msg_perr("Out of memory!\n");
@@ skipping 129 matching lines @@
         case JEDEC_REMS:
                 if (emu_chip != EMULATE_SST_SST25VF040_REMS)
                         break;
                 /* Respond with SST_SST25VF040_REMS. */
                 if (readcnt > 0)
                         readarr[0] = 0xbf;
                 if (readcnt > 1)
                         readarr[1] = 0x44;
                 break;
         case JEDEC_RDID:
-                if (emu_chip != EMULATE_SST_SST25VF032B)
-                        break;
-                /* Respond with SST_SST25VF032B. */
-                if (readcnt > 0)
-                        readarr[0] = 0xbf;
-                if (readcnt > 1)
-                        readarr[1] = 0x25;
-                if (readcnt > 2)
-                        readarr[2] = 0x4a;
+                if (emu_chip == EMULATE_SST_SST25VF032B) {
+                        /* Respond with SST_SST25VF032B. */
+                        if (readcnt > 0)
+                                readarr[0] = 0xbf;
+                        if (readcnt > 1)
+                                readarr[1] = 0x25;
+                        if (readcnt > 2)
+                                readarr[2] = 0x4a;
+                } else if (emu_chip == EMULATE_VARIABLE_SIZE) {
+                        const uint16_t man_id = VARIABLE_SIZE_MANUF_ID;
+                        const uint16_t dev_id = VARIABLE_SIZE_DEVICE_ID;
+                        if (readcnt > 0) readarr[0] = man_id >> 8;
+                        if (readcnt > 1) readarr[1] = man_id & 0xff;
+                        if (readcnt > 2) readarr[2] = dev_id >> 8;
+                        if (readcnt > 3) readarr[3] = dev_id & 0xff;
+                }
                 break;
         case JEDEC_RDSR:
                 memset(readarr, 0, readcnt);
                 if (aai_active)
                         memset(readarr, 1 << 6, readcnt);
                 break;
         case JEDEC_READ:
                 offs = writearr[1] << 16 | writearr[2] << 8 | writearr[3];
                 /* Truncate to emu_chip_size. */
                 offs %= emu_chip_size;
@@ skipping 161 matching lines @@
         for (i = 0; i < writecnt; i++)
                 msg_pspew(" 0x%02x", writearr[i]);
 
         /* Response for unknown commands and missing chip is 0xff. */
         memset(readarr, 0xff, readcnt);
 #if EMULATE_SPI_CHIP
         switch (emu_chip) {
         case EMULATE_ST_M25P10_RES:
         case EMULATE_SST_SST25VF040_REMS:
         case EMULATE_SST_SST25VF032B:
+        case EMULATE_VARIABLE_SIZE:
                 if (emulate_spi_chip_response(writecnt, readcnt, writearr,
                                               readarr)) {
                         msg_perr("Invalid command sent to flash chip!\n");
                         return 1;
                 }
                 break;
         default:
                 break;
         }
 #endif
         msg_pspew(" reading %u bytes:", readcnt);
         for (i = 0; i < readcnt; i++) {
                 msg_pspew(" 0x%02x", readarr[i]);
         }
         msg_pspew("\n");
         return 0;
 }
 
 int dummy_spi_read(struct flashchip *flash, uint8_t *buf, int start, int len)
 {
         /* Maximum read length is unlimited, use 64kB. */
         return spi_read_chunked(flash, buf, start, len, 64 * 1024);
 }
 
 int dummy_spi_write_256(struct flashchip *flash, uint8_t *buf, int start, int len)
 {
         return spi_write_chunked(flash, buf, start, len,
                                  spi_write_256_chunksize);
 }
+
+#if EMULATE_CHIP && EMULATE_SPI_CHIP
+int probe_variable_size(struct flashchip *flash)
+{
+        int i;
+
+        /* Skip the probing if we don't emulate this chip. */
+        if (emu_chip != EMULATE_VARIABLE_SIZE)
+                return 0;
+
+        /*
+         * This will break if one day flashchip becomes read-only.
+         * Once that happens, we need to have special hacks in functions:
+         *
+         *     erase_and_write_flash() in flashrom.c
+         *     read_flash_to_file()
+         *     handle_romentries()
+         *     ...
+         *
+         * Search "total_size * 1024" in code.
+         */
+        if (emu_chip_size % 1024)
+                msg_perr("%s: emu_chip_size is not multipler of 1024.\n",
+                         __func__);
+        flash->total_size = emu_chip_size / 1024;
+        msg_cdbg("%s: set flash->total_size to %dK bytes.\n", __func__,
+                 flash->total_size);
+
+        /* Update eraser count */
+        for (i = 0; i < NUM_ERASEFUNCTIONS; i++) {
+                struct block_eraser *eraser = &flash->block_erasers[i];
+                if (eraser->block_erase == NULL)
+                        break;
+
+                eraser->eraseblocks[0].count = emu_chip_size /
+                    eraser->eraseblocks[0].size;
+                msg_cdbg("%s: eraser.size=%d, .count=%d\n",
+                         __func__, eraser->eraseblocks[0].size,
+                         eraser->eraseblocks[0].count);
+        }
+
+        return 1;
+}
+#endif