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>
 #endif
 
 #if EMULATE_CHIP
+/* The name of variable-size virtual chip. A 4MB flash example:
+ *   flashrom -p dummy:emulate=VIRTUAL-4194304
+ */
+#define VIRTUAL_CHIP_NAME "VIRTUAL"
+#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_VIRTUAL,

[Stefan Reinauer, 2011/04/01 17:47:06]

Since this emulates a Winbond, should it be called EMULATE_WINBOND_GENERIC?

[Louis, 2011/04/02 01:48:52]

My initial attempt is to emulate any size of flash chip. But the flashrom
doesn't allow this because it needs at least an entry in flashchips[].

However, I just think another way to approach for this: add a virtual_spi in
flashchips[] and a probe_virtual(). Then, change 
total_size in probe_virtual().

On 2011/04/01 17:47:06, Stefan Reinauer wrote:

[dhendrix, 2011/04/02 23:43:32]

SGTM.

[Louis, 2011/04/07 02:28:14]

Done.

 };
 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;
@@ skipping 93 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, VIRTUAL_CHIP_NAME, strlen(VIRTUAL_CHIP_NAME))) {
+                char *size_str;
+                emu_chip = EMULATE_VIRTUAL;
+                strtok(tmp, "-");  // prefix is discarded.
+                if (NULL == (size_str = strtok(NULL, "-")) || !*size_str) {
+                        msg_perr("Please specify flash size, "
+                                 "example: %s-65536\n", VIRTUAL_CHIP_NAME);

[Stefan Reinauer, 2011/04/01 17:47:06]

Can we use KB instead of bytes here? 64, 128, 256, 512 is much nicer to type
than 65536, 131072, 262144, 524288.

[Louis, 2011/04/02 01:48:52]

This is intentional for

  -p dummy:VIRTUAL-`stat %s H2C`

On 2011/04/01 17:47:06, Stefan Reinauer wrote:

[dhendrix, 2011/04/02 23:43:32]

Good point... if desired, maybe we can add something that processes suffixes in
the future, ie "128K" or "1M"

[dhendrix, 2011/04/02 23:43:32]

I think it would be better to treat size (and potentially other chip info) as
programmer parameters. e.g. dummy:emulate=VIRTUAL:size=65536

I think that is more consistent with flashrom syntax in general, and also you
will be able to use extract_programmer_param() and related functions for string
parsing.

[Louis, 2011/04/07 02:28:14]

Done.

[Louis, 2011/04/07 02:28:14]

Done.

+                        free(tmp);
+                        return 1;
+                }
+                emu_chip_size = atoi(size_str);
+                if (emu_chip_size & (emu_chip_size - 1)) {
+                        msg_perr("Specified flash size is not power of 2.\n");
+                        free(tmp);
+                        return 1;
+                }
+                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 virtual 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_VIRTUAL) {
+                        /* Winbond W25X series flashes are easy to map.
+                         *   128KB -- ID: 0x3011
+                         *   256KB -- ID: 0x3012
+                         *     :             :
+                         *  8192KB -- ID: 0x3017
+                         * TODO: map more chips in future for other sizes.

[Stefan Reinauer, 2011/04/01 17:47:06]

Should we make sure we only pass sizes supported by this RDID?

[Louis, 2011/04/02 01:48:52]

Will refine this to support any size.

On 2011/04/01 17:47:06, Stefan Reinauer wrote:

+                         */
+                        uint16_t dev_id = WINBOND_NEX_W25X10;
+                        int size = emu_chip_size >> 17;
+                        for (; size >>= 1; dev_id++);
+                        if (readcnt > 0) readarr[0] = WINBOND_NEX_ID;
+                        if (readcnt > 1) readarr[1] = dev_id >> 8;
+                        if (readcnt > 2) readarr[2] = 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_VIRTUAL:
                 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);
 }