[flashrom] [commit] r719 - trunk
svn at flashrom.org
svn at flashrom.org
Sat Sep 5 04:30:58 CEST 2009
Author: hailfinger
Date: 2009-09-05 04:30:58 +0200 (Sat, 05 Sep 2009)
New Revision: 719
Modified:
trunk/flash.h
trunk/flashchips.c
trunk/flashrom.c
trunk/ft2232_spi.c
trunk/it87spi.c
trunk/sb600spi.c
trunk/spi.c
trunk/w39v040c.c
Log:
This is a patch which stores eraseblock sizes and corresponding block
erase functions in struct flashchip. I decided to fill in the info for a
few chips to illustrate how this works both for uniform and non-uniform
sector sizes.
struct eraseblock{
int size; /* Eraseblock size */
int count; /* Number of contiguous blocks with that size */
};
struct eraseblock doesn't correspond with a single erase block, but with
a group of contiguous erase blocks having the same size.
Given a (top boot block) flash chip with the following weird, but
real-life structure:
top
16384
8192
8192
32768
65536
65536
65536
65536
65536
65536
65536
bottom
we get the following encoding:
{65536,7},{32768,1},{8192,2},{16384,1}
Although the number of blocks is bigger than 4, the number of block
groups is only 4. If you ever add some flash chips with more than 4
contiguous block groups, the definition will not fit into the 4-member
array anymore and gcc will recognize that and error out. No undetected
overflow possible. In that case, you simply increase array size a bit.
For modern flash chips with uniform erase block size, you only need one
array member anyway.
Of course data types will need to be changed if you ever get flash chips
with more than 2^30 erase blocks, but even with the lowest known erase
granularity of 256 bytes, these flash chips will have to have a size of
a quarter Terabyte. I'm pretty confident we won't see such big EEPROMs
in the near future (or at least not attached in a way that makes
flashrom usable). For SPI chips, we even have a guaranteed safety factor
of 4096 over the maximum SPI chip size (which is 2^24). And if such a
big flash chip has uniform erase block size, you could even split it
among the 4 array members. If you change int count to unsigned int
count, the storable size doubles. So with a split and a slight change of
data type, the maximum ROM chip size is 2 Terabytes.
Since many chips have multiple block erase functions where the
eraseblock layout depends on the block erase function, this patch
couples the block erase functions with their eraseblock layouts.
struct block_eraser {
struct eraseblock{
unsigned int size; /* Eraseblock size */
unsigned int count; /* Number of contiguous blocks with that size */
} eraseblocks[NUM_ERASEREGIONS];
int (*block_erase) (struct flashchip *flash, unsigned int blockaddr, unsigned int blocklen);
} block_erasers[NUM_ERASEFUNCTIONS];
Signed-off-by: Carl-Daniel Hailfinger <c-d.hailfinger.devel.2006 at gmx.net>
Acked-by: Stefan Reinauer <stepan at coresystems.de>
Modified: trunk/flash.h
===================================================================
--- trunk/flash.h 2009-09-05 01:31:32 UTC (rev 718)
+++ trunk/flash.h 2009-09-05 02:30:58 UTC (rev 719)
@@ -149,6 +149,17 @@
CHIP_BUSTYPE_UNKNOWN = CHIP_BUSTYPE_PARALLEL | CHIP_BUSTYPE_LPC | CHIP_BUSTYPE_FWH | CHIP_BUSTYPE_SPI,
};
+/*
+ * How many different contiguous runs of erase blocks with one size each do
+ * we have for a given erase function?
+ */
+#define NUM_ERASEREGIONS 5
+
+/*
+ * How many different erase functions do we have per chip?
+ */
+#define NUM_ERASEFUNCTIONS 5
+
struct flashchip {
const char *vendor;
const char *name;
@@ -177,6 +188,19 @@
/* Delay after "enter/exit ID mode" commands in microseconds. */
int probe_timing;
int (*erase) (struct flashchip *flash);
+
+ /*
+ * Erase blocks and associated erase function. The default entry is a
+ * chip-sized virtual block together with the chip erase function.
+ */
+ struct block_eraser {
+ struct eraseblock{
+ unsigned int size; /* Eraseblock size */
+ unsigned int count; /* Number of contiguous blocks with that size */
+ } eraseblocks[NUM_ERASEREGIONS];
+ int (*block_erase) (struct flashchip *flash, unsigned int blockaddr, unsigned int blocklen);
+ } block_erasers[NUM_ERASEFUNCTIONS];
+
int (*write) (struct flashchip *flash, uint8_t *buf);
int (*read) (struct flashchip *flash, uint8_t *buf, int start, int len);
@@ -417,6 +441,7 @@
#define printf_debug(x...) { if (verbose) printf(x); }
void map_flash_registers(struct flashchip *flash);
int read_memmapped(struct flashchip *flash, uint8_t *buf, int start, int len);
+int erase_flash(struct flashchip *flash);
int min(int a, int b);
int max(int a, int b);
int check_erased_range(struct flashchip *flash, int start, int len);
Modified: trunk/flashchips.c
===================================================================
--- trunk/flashchips.c 2009-09-05 01:31:32 UTC (rev 718)
+++ trunk/flashchips.c 2009-09-05 02:30:58 UTC (rev 719)
@@ -1229,7 +1229,30 @@
.tested = TEST_UNTESTED,
.probe = probe_spi_rdid,
.probe_timing = TIMING_ZERO,
- .erase = spi_chip_erase_60_c7,
+ .erase = NULL,
+ .block_erasers =
+ {
+ {
+ .eraseblocks = { {4 * 1024, 16} },
+ .block_erase = spi_block_erase_20,
+ },
+ {
+ .eraseblocks = { {64 * 1024, 1} },
+ .block_erase = spi_block_erase_52,
+ },
+ {
+ .eraseblocks = { {64 * 1024, 1} },
+ .block_erase = spi_block_erase_d8,
+ },
+ {
+ .eraseblocks = { {64 * 1024, 1} },
+ .block_erase = spi_block_erase_60,
+ },
+ {
+ .eraseblocks = { {64 * 1024, 1} },
+ .block_erase = spi_block_erase_c7,
+ },
+ },
.write = spi_chip_write_256,
.read = spi_chip_read,
},
@@ -1245,7 +1268,26 @@
.tested = TEST_UNTESTED,
.probe = probe_spi_rdid,
.probe_timing = TIMING_ZERO,
- .erase = spi_chip_erase_60_c7,
+ .erase = NULL,
+ .block_erasers =
+ {
+ {
+ .eraseblocks = { {4 * 1024, 32} },
+ .block_erase = spi_block_erase_20,
+ },
+ {
+ .eraseblocks = { {64 * 1024, 2} },
+ .block_erase = spi_block_erase_d8,
+ },
+ {
+ .eraseblocks = { {128 * 1024, 1} },
+ .block_erase = spi_block_erase_60,
+ },
+ {
+ .eraseblocks = { {128 * 1024, 1} },
+ .block_erase = spi_block_erase_c7,
+ },
+ },
.write = spi_chip_write_256,
.read = spi_chip_read,
},
Modified: trunk/flashrom.c
===================================================================
--- trunk/flashrom.c 2009-09-05 01:31:32 UTC (rev 718)
+++ trunk/flashrom.c 2009-09-05 02:30:58 UTC (rev 719)
@@ -474,36 +474,66 @@
int erase_flash(struct flashchip *flash)
{
- uint32_t erasedbytes;
- unsigned long size = flash->total_size * 1024;
- unsigned char *buf = calloc(size, sizeof(char));
+ int i, j, k, ret = 0, found = 0;
+
printf("Erasing flash chip... ");
- if (NULL == flash->erase) {
- printf("FAILED!\n");
+ for (k = 0; k < NUM_ERASEFUNCTIONS; k++) {
+ unsigned long done = 0;
+ struct block_eraser eraser = flash->block_erasers[k];
+
+ printf_debug("Looking at blockwise erase function %i... ", k);
+ if (!eraser.block_erase && !eraser.eraseblocks[0].count) {
+ printf_debug("not defined. "
+ "Looking for another erase function.\n");
+ continue;
+ }
+ if (!eraser.block_erase && eraser.eraseblocks[0].count) {
+ printf_debug("eraseblock layout is known, but no "
+ "matching block erase function found. "
+ "Looking for another erase function.\n");
+ continue;
+ }
+ if (eraser.block_erase && !eraser.eraseblocks[0].count) {
+ printf_debug("block erase function found, but "
+ "eraseblock layout is unknown. "
+ "Looking for another erase function.\n");
+ continue;
+ }
+ found = 1;
+ printf_debug("trying... ");
+ for (i = 0; i < NUM_ERASEREGIONS; i++) {
+ /* count==0 for all automatically initialized array
+ * members so the loop below won't be executed for them.
+ */
+ for (j = 0; j < eraser.eraseblocks[i].count; j++) {
+ ret = eraser.block_erase(flash, done + eraser.eraseblocks[i].size * j, eraser.eraseblocks[i].size);
+ if (ret)
+ break;
+ }
+ if (ret)
+ break;
+ }
+ /* If everything is OK, don't try another erase function. */
+ if (!ret)
+ break;
+ }
+ /* If no block erase function was found or block erase failed, retry. */
+ if ((!found || ret) && (flash->erase)) {
+ found = 1;
+ printf_debug("Trying whole-chip erase function... ");
+ ret = flash->erase(flash);
+ }
+ if (!found) {
fprintf(stderr, "ERROR: flashrom has no erase function for this flash chip.\n");
return 1;
}
- flash->erase(flash);
- /* FIXME: The lines below are superfluous. We should check the result
- * of flash->erase(flash) instead.
- */
- if (!flash->read) {
- printf("FAILED!\n");
- fprintf(stderr, "ERROR: flashrom has no read function for this flash chip.\n");
- return 1;
- } else
- flash->read(flash, buf, 0, size);
-
- for (erasedbytes = 0; erasedbytes < size; erasedbytes++)
- if (0xff != buf[erasedbytes]) {
- printf("FAILED!\n");
- fprintf(stderr, "ERROR at 0x%08x: Expected=0xff, Read=0x%02x\n",
- erasedbytes, buf[erasedbytes]);
- return 1;
- }
- printf("SUCCESS.\n");
- return 0;
+ if (ret) {
+ fprintf(stderr, "FAILED!\n");
+ } else {
+ printf("SUCCESS.\n");
+ }
+ return ret;
}
void emergency_help_message()
Modified: trunk/ft2232_spi.c
===================================================================
--- trunk/ft2232_spi.c 2009-09-05 01:31:32 UTC (rev 718)
+++ trunk/ft2232_spi.c 2009-09-05 02:30:58 UTC (rev 719)
@@ -271,7 +271,7 @@
spi_disable_blockprotect();
/* Erase first */
printf("Erasing flash before programming... ");
- if (flash->erase(flash)) {
+ if (erase_flash(flash)) {
fprintf(stderr, "ERASE FAILED!\n");
return -1;
}
Modified: trunk/it87spi.c
===================================================================
--- trunk/it87spi.c 2009-09-05 01:31:32 UTC (rev 718)
+++ trunk/it87spi.c 2009-09-05 02:30:58 UTC (rev 719)
@@ -279,7 +279,7 @@
spi_disable_blockprotect();
/* Erase first */
printf("Erasing flash before programming... ");
- if (flash->erase(flash)) {
+ if (erase_flash(flash)) {
fprintf(stderr, "ERASE FAILED!\n");
return -1;
}
Modified: trunk/sb600spi.c
===================================================================
--- trunk/sb600spi.c 2009-09-05 01:31:32 UTC (rev 718)
+++ trunk/sb600spi.c 2009-09-05 02:30:58 UTC (rev 719)
@@ -55,7 +55,7 @@
spi_disable_blockprotect();
/* Erase first */
printf("Erasing flash before programming... ");
- if (flash->erase(flash)) {
+ if (erase_flash(flash)) {
fprintf(stderr, "ERASE FAILED!\n");
return -1;
}
Modified: trunk/spi.c
===================================================================
--- trunk/spi.c 2009-09-05 01:31:32 UTC (rev 718)
+++ trunk/spi.c 2009-09-05 02:30:58 UTC (rev 719)
@@ -972,7 +972,7 @@
spi_disable_blockprotect();
/* Erase first */
printf("Erasing flash before programming... ");
- if (flash->erase(flash)) {
+ if (erase_flash(flash)) {
fprintf(stderr, "ERASE FAILED!\n");
return -1;
}
@@ -1021,7 +1021,7 @@
default:
break;
}
- if (flash->erase(flash)) {
+ if (erase_flash(flash)) {
fprintf(stderr, "ERASE FAILED!\n");
return -1;
}
Modified: trunk/w39v040c.c
===================================================================
--- trunk/w39v040c.c 2009-09-05 01:31:32 UTC (rev 718)
+++ trunk/w39v040c.c 2009-09-05 02:30:58 UTC (rev 719)
@@ -72,7 +72,7 @@
int page_size = flash->page_size;
chipaddr bios = flash->virtual_memory;
- if (flash->erase(flash)) {
+ if (erase_flash(flash)) {
fprintf(stderr, "ERASE FAILED!\n");
return -1;
}
More information about the flashrom
mailing list