On 12/22/09 3:49 PM, Carl-Daniel Hailfinger wrote:
Hi,

I have the following list of erase block structures still lying around:

  AMIC_A29002B,  { {16 * 1024, 1}, {8 * 1024, 2}, {32 * 1024, 1}, {64 * 1024, 
3} }
  AMIC_A29002T,  { {64 * 1024, 3}, {32 * 1024, 1}, {8 * 1024, 2}, {16 * 1024, 
1} }
  EN_29F002B,  { {16 * 1024, 1}, {8 * 1024, 2}, {32 * 1024, 1}, {64 * 1024, 3} }
  EN_29F002T,  { {64 * 1024, 3}, {32 * 1024, 1}, {8 * 1024, 2}, {16 * 1024, 1} }
  MBM29F004BC,  { {16 * 1024, 1}, {8 * 1024, 2}, {32 * 1024, 1}, {64 * 1024, 7} 
}
  MBM29F004TC,  { {64 * 1024, 7}, {32 * 1024, 1}, {8 * 1024, 2}, {16 * 1024, 1} 
}
  MBM29F400BC,  { {16 * 1024, 1}, {8 * 1024, 2}, {32 * 1024, 1}, {64 * 1024, 7} 
}
  MBM29F400TC,  { {64 * 1024, 7}, {32 * 1024, 1}, {8 * 1024, 2}, {16 * 1024, 1} 
}
  MX_25L3205,  { {4 * 1024, 1024} }
  MX_25L6405,  { {4 * 1024, 2048} }
  MX_29F002B,  { {16 * 1024, 1}, {8 * 1024, 2}, {32 * 1024, 1}, {64 * 1024, 3} }
  MX_29F002T,  { {64 * 1024, 3}, {32 * 1024, 1}, {8 * 1024, 2}, {16 * 1024, 1} }


No guarantees about completeness (and note that the corresponding erase
functions are not part of that list), but it might be useful in case
someone wants to cross-check his/her work.

Regards,
Carl-Daniel

Patch attached.


commit d9ec35fc2ba691794103a94d09bf0c7080fd6e52
Author: Sean Nelson <[email protected]>
Date:   Tue Dec 22 22:59:12 2009 -0800

    Convert the following chips to use struct eraseblock:
    AMIC_A29002B
    AMIC_A29002T
    EN_29F002B
    EN_29F002T
    MBM29F004BC
    MBM29F004TC
    MBM29F400BC
    MBM29F400TC
    MX_25L3205
    MX_25L6405
    MX_29F002B
    MX_29F002T

    Add block erasers for m29f400bt and mx29f002.

    Signed-off-by: Sean Nelson <[email protected]>

diff --git a/chipdrivers.h b/chipdrivers.h
index a4e1273..adcb46d 100644
--- a/chipdrivers.h
+++ b/chipdrivers.h
@@ -93,24 +93,27 @@ int write_sector_jedec(chipaddr bios, uint8_t *src,
 int erase_m29f002(struct flashchip *flash);
 int write_m29f002t(struct flashchip *flash, uint8_t *buf);
 int write_m29f002b(struct flashchip *flash, uint8_t *buf);
 
 /* m29f400bt.c */
 int probe_m29f400bt(struct flashchip *flash);
 int erase_m29f400bt(struct flashchip *flash);
-int block_erase_m29f400bt(struct flashchip *flash, int start, int len);
+int block_erase_m29f400bt(struct flashchip *flash, unsigned int start, 
unsigned int len);
+int block_erase_chip_m29f400bt(struct flashchip *flash, unsigned int start, 
unsigned int len);
 int write_m29f400bt(struct flashchip *flash, uint8_t *buf);
 int write_coreboot_m29f400bt(struct flashchip *flash, uint8_t *buf);
 void protect_m29f400bt(chipaddr bios);
 void write_page_m29f400bt(chipaddr bios, uint8_t *src,
                          chipaddr dst, int page_size);
 
 /* mx29f002.c */
 int probe_29f002(struct flashchip *flash);
 int erase_29f002(struct flashchip *flash);
+int erase_chip_29f002(struct flashchip *flash, unsigned int addr, unsigned int 
blocklen);
+int erase_sector_29f002(struct flashchip *flash, unsigned int address, 
unsigned int blocklen);
 int write_29f002(struct flashchip *flash, uint8_t *buf);
 
 /* pm49fl00x.c */
 int probe_49fl00x(struct flashchip *flash);
 int erase_49fl00x(struct flashchip *flash);
 int write_49fl00x(struct flashchip *flash, uint8_t *buf);
 
diff --git a/flashchips.c b/flashchips.c
index 786d53a..d9006b9 100644
--- a/flashchips.c
+++ b/flashchips.c
@@ -824,31 +824,61 @@ struct flashchip flashchips[] = {
                .manufacture_id = AMIC_ID_NOPREFIX,
                .model_id       = AMIC_A29002B,
                .total_size     = 256,
                .page_size      = 64 * 1024,
                .tested         = TEST_UNTESTED,
                .probe          = probe_29f002,
                .probe_timing   = TIMING_IGNORED, /* routine don't use 
probe_timing (mx29f002.c) */
-               .erase          = erase_29f002,
+               .erase          = NULL,
+               .block_erasers  =
+               {
+                       {
+                               .eraseblocks = { 
+                                       {16 * 1024, 1},
+                                       {8 * 1024, 2},
+                                       {32 * 1024, 1},
+                                       {64 * 1024, 3},
+                               },
+                               .block_erase = erase_sector_29f002,
+                       }, {
+                               .eraseblocks = { {256 * 1024, 1} },
+                               .block_erase = erase_chip_29f002,
+                       },
+               },
                .write          = write_jedec_1,
                .read           = read_memmapped,
        },
 
        {
                .vendor         = "AMIC",
                .name           = "A29002T",
                .bustype        = CHIP_BUSTYPE_PARALLEL,
                .manufacture_id = AMIC_ID_NOPREFIX,
                .model_id       = AMIC_A29002T,
                .total_size     = 256,
                .page_size      = 64 * 1024,
-               .tested         = TEST_OK_PRE,
+               .tested         = TEST_OK_PR,
                .probe          = probe_29f002,
                .probe_timing   = TIMING_IGNORED, /* routine don't use 
probe_timing (mx29f002.c) */
-               .erase          = erase_29f002,
+               .erase          = NULL,
+               .block_erasers  =
+               {
+                       {
+                               .eraseblocks = { 
+                                       {64 * 1024, 3},
+                                       {32 * 1024, 1},
+                                       {8 * 1024, 2},
+                                       {16 * 1024, 1},
+                               },
+                               .block_erase = erase_sector_29f002,
+                       }, {
+                               .eraseblocks = { {256 * 1024, 1} },
+                               .block_erase = erase_chip_29f002,
+                       },
+               },
                .write          = write_jedec_1,
                .read           = read_memmapped,
        },
 
        {
                .vendor         = "AMIC",
                .name           = "A29040B",
@@ -1170,31 +1200,61 @@ struct flashchip flashchips[] = {
                .manufacture_id = EON_ID,
                .model_id       = EN_29F002B,
                .total_size     = 256,
                .page_size      = 256,
                .tested         = TEST_UNTESTED,
                .probe          = probe_jedec,
                .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info 
specified */
-               .erase          = erase_chip_jedec,
+               .erase          = NULL,
+               .block_erasers  =
+               {
+                       {
+                               .eraseblocks = { 
+                                       {64 * 1024, 3},
+                                       {32 * 1024, 1},
+                                       {8 * 1024, 2},
+                                       {16 * 1024, 1},
+                               },
+                               .block_erase = erase_sector_jedec,
+                       }, {
+                               .eraseblocks = { {256 * 1024, 1} },
+                               .block_erase = erase_chip_block_jedec,
+                       },
+               },
                .write          = write_jedec_1,
                .read           = read_memmapped,
        },
 
        {
                .vendor         = "EON",
                .name           = "EN29F002(A)(N)T",
                .bustype        = CHIP_BUSTYPE_PARALLEL,
                .manufacture_id = EON_ID,
                .model_id       = EN_29F002T,
                .total_size     = 256,
                .page_size      = 256,
-               .tested         = TEST_OK_PRE,
+               .tested         = TEST_OK_PR,
                .probe          = probe_jedec,
                .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info 
specified */
-               .erase          = erase_chip_jedec,
+               .erase          = NULL,
+               .block_erasers  =
+               {
+                       {
+                               .eraseblocks = { 
+                                       {16 * 1024, 1},
+                                       {8 * 1024, 2},
+                                       {32 * 1024, 1},
+                                       {64 * 1024, 3},
+                               },
+                               .block_erase = erase_sector_jedec,
+                       }, {
+                               .eraseblocks = { {256 * 1024, 1} },
+                               .block_erase = erase_chip_block_jedec,
+                       },
+               },
                .write          = write_jedec_1,
                .read           = read_memmapped,
        },
 
        {
                .vendor         = "Fujitsu",
                .name           = "MBM29F004BC",
@@ -1203,14 +1263,29 @@ struct flashchip flashchips[] = {
                .model_id       = MBM29F004BC,
                .total_size     = 512,
                .page_size      = 64 * 1024,
                .tested         = TEST_UNTESTED,
                .probe          = probe_jedec,
                .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info 
specified */
                .erase          = NULL,
+               .block_erasers  =
+               {
+                       {
+                               .eraseblocks = { 
+                                       {16 * 1024, 1},
+                                       {8 * 1024, 2},
+                                       {32 * 1024, 1},
+                                       {64 * 1024, 7},
+                               },
+                               .block_erase = erase_sector_29f040b,
+                       }, {
+                               .eraseblocks = { {512 * 1024, 1} },
+                               .block_erase = erase_chip_29f040b,
+                       },
+               },
                .write          = NULL,
                .read           = read_memmapped,
        },
 
        {
                .vendor         = "Fujitsu",
                .name           = "MBM29F004TC",
@@ -1219,14 +1294,29 @@ struct flashchip flashchips[] = {
                .model_id       = MBM29F004TC,
                .total_size     = 512,
                .page_size      = 64 * 1024,
                .tested         = TEST_UNTESTED,
                .probe          = probe_jedec,
                .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info 
specified */
                .erase          = NULL,
+               .block_erasers  =
+               {
+                       {
+                               .eraseblocks = { 
+                                       {64 * 1024, 7},
+                                       {32 * 1024, 1},
+                                       {8 * 1024, 2},
+                                       {16 * 1024, 1},
+                               },
+                               .block_erase = erase_sector_29f040b,
+                       }, {
+                               .eraseblocks = { {512 * 1024, 1} },
+                               .block_erase = erase_chip_29f040b,
+                       },
+               },
                .write          = NULL,
                .read           = read_memmapped,
        },
 
        {
                .vendor         = "Fujitsu",
                .name           = "MBM29F400BC",
@@ -1234,15 +1324,30 @@ struct flashchip flashchips[] = {
                .manufacture_id = FUJITSU_ID,
                .model_id       = MBM29F400BC,
                .total_size     = 512,
                .page_size      = 64 * 1024,
                .tested         = TEST_UNTESTED,
                .probe          = probe_m29f400bt,
                .probe_timing   = TIMING_IGNORED, /* routine don't use 
probe_timing (m29f400bt.c) */
-               .erase          = erase_m29f400bt,
+               .erase          = NULL,
+               .block_erasers  =
+               {
+                       {
+                               .eraseblocks = { 
+                                       {16 * 1024, 1},
+                                       {8 * 1024, 2},
+                                       {32 * 1024, 1},
+                                       {64 * 1024, 7},
+                               },
+                               .block_erase = block_erase_m29f400bt,
+                       }, {
+                               .eraseblocks = { {512 * 1024, 1} },
+                               .block_erase = block_erase_chip_m29f400bt,
+                       },
+               },
                .write          = write_coreboot_m29f400bt,
                .read           = read_memmapped,
        },
 
        {
                .vendor         = "Fujitsu",
                .name           = "MBM29F400TC",
@@ -1250,15 +1355,30 @@ struct flashchip flashchips[] = {
                .manufacture_id = FUJITSU_ID,
                .model_id       = MBM29F400TC,
                .total_size     = 512,
                .page_size      = 64 * 1024,
                .tested         = TEST_UNTESTED,
                .probe          = probe_m29f400bt,
                .probe_timing   = TIMING_IGNORED, /* routine don't use 
probe_timing (m29f400bt.c) */
-               .erase          = erase_m29f400bt,
+               .erase          = NULL,
+               .block_erasers  =
+               {
+                       {
+                               .eraseblocks = { 
+                                       {64 * 1024, 7},
+                                       {32 * 1024, 1},
+                                       {8 * 1024, 2},
+                                       {16 * 1024, 1},
+                               },
+                               .block_erase = block_erase_m29f400bt,
+                       }, {
+                               .eraseblocks = { {512 * 1024, 1} },
+                               .block_erase = block_erase_chip_m29f400bt,
+                       },
+               },
                .write          = write_coreboot_m29f400bt,
                .read           = read_memmapped,
        },
 
        {
                .vendor         = "Intel",
                .name           = "28F001BX-B",
@@ -1550,18 +1670,34 @@ struct flashchip flashchips[] = {
                .vendor         = "Macronix",
                .name           = "MX25L3205",
                .bustype        = CHIP_BUSTYPE_SPI,
                .manufacture_id = MX_ID,
                .model_id       = MX_25L3205,
                .total_size     = 4096,
                .page_size      = 256,
-               .tested         = TEST_OK_PREW,
+               .tested         = TEST_OK_PRW,
                .probe          = probe_spi_rdid,
                .probe_timing   = TIMING_ZERO,
-               .erase          = spi_chip_erase_60_c7,
+               .erase          = NULL,
+               .block_erasers  =
+               {
+                       {
+                               .eraseblocks = { {4 * 1024, 1024} },
+                               .block_erase = spi_block_erase_20,
+                       }, {
+                               .eraseblocks = { {4 * 1024, 1024} },
+                               .block_erase = spi_block_erase_d8,
+                       }, {
+                               .eraseblocks = { {4 * 1024 * 1024, 1} },
+                               .block_erase = spi_block_erase_60,
+                       }, {
+                               .eraseblocks = { {4 * 1024 * 1024, 1} },
+                               .block_erase = spi_block_erase_c7,
+                       },
+               },
                .write          = spi_chip_write_256,
                .read           = spi_chip_read,
        },
 
        {
                .vendor         = "Macronix",
                .name           = "MX25L3235D",
@@ -1585,15 +1721,31 @@ struct flashchip flashchips[] = {
                .manufacture_id = MX_ID,
                .model_id       = MX_25L6405,
                .total_size     = 8192,
                .page_size      = 256,
                .tested         = TEST_OK_PROBE,
                .probe          = probe_spi_rdid,
                .probe_timing   = TIMING_ZERO,
-               .erase          = spi_chip_erase_60_c7,
+               .erase          = NULL,
+               .block_erasers  =
+               {
+                       {
+                               .eraseblocks = { {4 * 1024, 2048} },
+                               .block_erase = spi_block_erase_20,
+                       }, {
+                               .eraseblocks = { {4 * 1024, 2048} },
+                               .block_erase = spi_block_erase_d8,
+                       }, {
+                               .eraseblocks = { {8 * 1024 * 1024, 1} },
+                               .block_erase = spi_block_erase_60,
+                       }, {
+                               .eraseblocks = { {8 * 1024 * 1024, 1} },
+                               .block_erase = spi_block_erase_c7,
+                       },
+               },
                .write          = spi_chip_write_256,
                .read           = spi_chip_read,
        },
 
        {
                .vendor         = "Macronix",
                .name           = "MX25L12805",
@@ -1649,31 +1801,61 @@ struct flashchip flashchips[] = {
                .manufacture_id = MX_ID,
                .model_id       = MX_29F002B,
                .total_size     = 256,
                .page_size      = 64 * 1024,
                .tested         = TEST_UNTESTED,
                .probe          = probe_29f002,
                .probe_timing   = TIMING_IGNORED, /* routine don't use 
probe_timing (mx29f002.c) */
-               .erase          = erase_29f002,
+               .erase          = NULL,
+               .block_erasers  =
+               {
+                       {
+                               .eraseblocks = {
+                                       {16 * 1024, 1},
+                                       {8 * 1024, 2},
+                                       {32 * 1024, 1},
+                                       {64 * 1024, 3},
+                               },
+                               .block_erase = erase_sector_29f002,     /* This 
erase function has 64k blocksize for eLiteFlash */
+                       }, {
+                               .eraseblocks = { {256 * 1024, 1} },
+                               .block_erase = erase_chip_29f002,
+                       },
+               },
                .write          = write_jedec_1,
                .read           = read_memmapped,
        },
 
        {
                .vendor         = "Macronix",
                .name           = "MX29F002T",
                .bustype        = CHIP_BUSTYPE_PARALLEL,
                .manufacture_id = MX_ID,
                .model_id       = MX_29F002T,
                .total_size     = 256,
                .page_size      = 64 * 1024,
-               .tested         = TEST_OK_PRE,
+               .tested         = TEST_OK_PR,
                .probe          = probe_29f002,
                .probe_timing   = TIMING_IGNORED, /* routine don't use 
probe_timing (mx29f002.c) */
-               .erase          = erase_29f002,
+               .erase          = NULL,
+               .block_erasers  =
+               {
+                       {
+                               .eraseblocks = {
+                                       {64 * 1024, 3},
+                                       {32 * 1024, 1},
+                                       {8 * 1024, 2},
+                                       {16 * 1024, 1},
+                               },
+                               .block_erase = erase_sector_29f002,     /* This 
erase function has 64k blocksize for eLiteFlash */
+                       }, {
+                               .eraseblocks = { {256 * 1024, 1} },
+                               .block_erase = erase_chip_29f002,
+                       },
+               },
                .write          = write_jedec_1,
                .read           = read_memmapped,
        },
 
        {
                .vendor         = "Macronix",
                .name           = "MX29LV040",
diff --git a/m29f400bt.c b/m29f400bt.c
index c327f44..e77572a 100644
--- a/m29f400bt.c
+++ b/m29f400bt.c
@@ -98,15 +98,15 @@ int erase_m29f400bt(struct flashchip *flash)
        if (check_erased_range(flash, 0, flash->total_size * 1024)) {
                fprintf(stderr, "ERASE FAILED!\n");
                return -1;
        }
        return 0;
 }
 
-int block_erase_m29f400bt(struct flashchip *flash, int start, int len)
+int block_erase_m29f400bt(struct flashchip *flash, unsigned int start, 
unsigned int len)
 {
        chipaddr bios = flash->virtual_memory;
        chipaddr dst = bios + start;
 
        chip_writeb(0xAA, bios + 0xAAA);
        chip_writeb(0x55, bios + 0x555);
        chip_writeb(0x80, bios + 0xAAA);
@@ -122,14 +122,24 @@ int block_erase_m29f400bt(struct flashchip *flash, int 
start, int len)
        if (check_erased_range(flash, start, len)) {
                fprintf(stderr, "ERASE FAILED!\n");
                return -1;
        }
        return 0;
 }
 
+int block_erase_chip_m29f400bt(struct flashchip *flash, unsigned int address, 
unsigned int blocklen)
+{
+       if ((address != 0) || (blocklen != flash->total_size * 1024)) {
+               fprintf(stderr, "%s called with incorrect arguments\n",
+                       __func__);
+               return -1;
+       }
+       return erase_m29f400bt(flash);
+}
+
 int write_m29f400bt(struct flashchip *flash, uint8_t *buf)
 {
        int i;
        int total_size = flash->total_size * 1024;
        int page_size = flash->page_size;
        chipaddr bios = flash->virtual_memory;
 
diff --git a/mx29f002.c b/mx29f002.c
index 7838c3d..4a2ab97 100644
--- a/mx29f002.c
+++ b/mx29f002.c
@@ -39,14 +39,47 @@ int probe_29f002(struct flashchip *flash)
        printf_debug("%s: id1 0x%02x, id2 0x%02x\n", __func__, id1, id2);
        if (id1 == flash->manufacture_id && id2 == flash->model_id)
                return 1;
 
        return 0;
 }
 
+int erase_sector_29f002(struct flashchip *flash, unsigned int address, 
unsigned int blocklen)
+{
+       chipaddr bios = flash->virtual_memory;
+
+       chip_writeb(0xAA, bios + 0x555);
+       chip_writeb(0x55, bios + 0x2AA);
+       chip_writeb(0x80, bios + 0x555);
+       chip_writeb(0xAA, bios + 0x555);
+       chip_writeb(0x55, bios + 0x2AA);
+       chip_writeb(0x30, bios + address);
+
+       programmer_delay(2 * 1000 * 1000);
+
+       /* wait for Toggle bit ready         */
+       toggle_ready_jedec(bios + address);
+
+       if (check_erased_range(flash, address, blocklen)) {
+               fprintf(stderr, "ERASE FAILED!\n");
+               return -1;
+       }
+       return 0;
+}
+
+int erase_chip_29f002(struct flashchip *flash, unsigned int addr, unsigned int 
blocklen)
+{
+       if ((addr != 0) || (blocklen != flash->total_size * 1024)) {
+               fprintf(stderr, "%s called with incorrect arguments\n",
+                       __func__);
+               return -1;
+       }
+       return erase_29f002(flash);
+}
+
 /* FIXME: Use erase_chip_jedec?
  * erase_29f002 uses shorter addresses, sends F0 (exit ID mode) and
  * and has a bigger delay before polling the toggle bit */
 int erase_29f002(struct flashchip *flash)
 {
        chipaddr bios = flash->virtual_memory;
 
_______________________________________________
flashrom mailing list
[email protected]
http://www.flashrom.org/mailman/listinfo/flashrom

Reply via email to