1
0
mirror of https://review.coreboot.org/flashrom.git synced 2025-07-02 14:33:18 +02:00

Add support for Intel S33 series flash chips

This includes:
Bottom boot block:
* 16Mb/2MB:
  QB25F160S33B8, QB25F016S33B8, QH25F160S33B8, QH25F016S33B8
* 32Mb/4MB:
  QB25F320S33B8, QH25F320S33B8
* 64Mb/8MB:
  QB25F640S33B8, QH25F640S33B8

Top boot block:
* 16Mb/2MB:
  QB25F160S33T8, QB25F016S33T8, QH25F160S33T8, QH25F016S33T8
* 32Mb/4MB:
  QB25F320S33T8, QH25F320S33T8
* 64Mb/8MB:
  QB25F640S33T8, QH25F640S33T8

At least some seem to be marketed by other vendors (too?) but also with
Intel's vendor ID.

Besides a 0xC7 chip erase and a 0xD8 uniform 64kB block erase they
support also erasing the top/bottom 8 8kB blocks with opcode 0x40.
But since this command fails for all addresses outside those ranges,
it is not easily implemented with flashrom's current code base and
hence left out.

Corresponding to flashrom svn r1636.

Signed-off-by: Stefan Tauner <stefan.tauner@alumni.tuwien.ac.at>
Acked-by: Stefan Tauner <stefan.tauner@alumni.tuwien.ac.at>
This commit is contained in:
Stefan Tauner
2012-12-29 15:04:12 +00:00
parent 9530a02212
commit 54aaa4ae2b
4 changed files with 265 additions and 0 deletions

View File

@ -4420,6 +4420,240 @@ const struct flashchip flashchips[] = {
.voltage = {4500, 5500},
},
{
.vendor = "Intel",
.name = "25F160S33B8",
.bustype = BUS_SPI,
.manufacture_id = INTEL_ID,
.model_id = INTEL_25F160S33B8,
.total_size = 2048,
.page_size = 256,
/* OTP: 506B total (2x 8B, 30x 16B, 1x 10B); read 0x4B; write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = probe_spi_rdid,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
/* This chip supports erasing of the 8 so-called "parameter blocks" with
* opcode 0x40. Trying to access an address outside these 8 8kB blocks does
* have no effect on the memory contents, but sets a flag in the SR.
.eraseblocks = {
{8 * 1024, 8},
{64 * 1024, 31} // inaccessible
},
.block_erase = spi_block_erase_40,
}, { */
.eraseblocks = { {64 * 1024, 32} },
.block_erase = spi_block_erase_d8,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = spi_block_erase_c7,
}
},
.printlock = spi_prettyprint_status_register_s33,
.unlock = spi_disable_blockprotect_s33,
.write = spi_chip_write_256,
.read = spi_chip_read, /* also fast read 0x0B */
.voltage = {2700, 3600},
},
{
.vendor = "Intel",
.name = "25F160S33T8",
.bustype = BUS_SPI,
.manufacture_id = INTEL_ID,
.model_id = INTEL_25F160S33T8,
.total_size = 2048,
.page_size = 256,
/* OTP: 506B total (2x 8B, 30x 16B, 1x 10B); read 0x4B; write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = probe_spi_rdid,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
/* This chip supports erasing of the 8 so-called "parameter blocks" with
* opcode 0x40. Trying to access an address outside these 8 8kB blocks does
* have no effect on the memory contents, but sets a flag in the SR.
.eraseblocks = {
{64 * 1024, 31}, // inaccessible
{8 * 1024, 8}
},
.block_erase = spi_block_erase_40,
}, { */
.eraseblocks = { {64 * 1024, 32} },
.block_erase = spi_block_erase_d8,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = spi_block_erase_c7,
}
},
.printlock = spi_prettyprint_status_register_s33,
.unlock = spi_disable_blockprotect_s33,
.write = spi_chip_write_256,
.read = spi_chip_read, /* also fast read 0x0B */
.voltage = {2700, 3600},
},
{
.vendor = "Intel",
.name = "25F320S33B8",
.bustype = BUS_SPI,
.manufacture_id = INTEL_ID,
.model_id = INTEL_25F320S33B8,
.total_size = 4096,
.page_size = 256,
/* OTP: 506B total (2x 8B, 30x 16B, 1x 10B); read 0x4B; write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = probe_spi_rdid,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
/* This chip supports erasing of the 8 so-called "parameter blocks" with
* opcode 0x40. Trying to access an address outside these 8 8kB blocks does
* have no effect on the memory contents, but sets a flag in the SR.
.eraseblocks = {
{8 * 1024, 8},
{64 * 1024, 63} // inaccessible
},
.block_erase = spi_block_erase_40,
}, { */
.eraseblocks = { {64 * 1024, 64} },
.block_erase = spi_block_erase_d8,
}, {
.eraseblocks = { {4 * 1024 * 1024, 1} },
.block_erase = spi_block_erase_c7,
}
},
.printlock = spi_prettyprint_status_register_s33,
.unlock = spi_disable_blockprotect_s33,
.write = spi_chip_write_256,
.read = spi_chip_read, /* also fast read 0x0B */
.voltage = {2700, 3600},
},
{
.vendor = "Intel",
.name = "25F320S33T8",
.bustype = BUS_SPI,
.manufacture_id = INTEL_ID,
.model_id = INTEL_25F320S33T8,
.total_size = 4096,
.page_size = 256,
/* OTP: 506B total (2x 8B, 30x 16B, 1x 10B); read 0x4B; write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = probe_spi_rdid,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
/* This chip supports erasing of the 8 so-called "parameter blocks" with
* opcode 0x40. Trying to access an address outside these 8 8kB blocks does
* have no effect on the memory contents, but sets a flag in the SR.
.eraseblocks = {
{64 * 1024, 63}, // inaccessible
{8 * 1024, 8}
},
.block_erase = spi_block_erase_40,
}, { */
.eraseblocks = { {64 * 1024, 64} },
.block_erase = spi_block_erase_d8,
}, {
.eraseblocks = { {4 * 1024 * 1024, 1} },
.block_erase = spi_block_erase_c7,
}
},
.printlock = spi_prettyprint_status_register_s33,
.unlock = spi_disable_blockprotect_s33,
.write = spi_chip_write_256,
.read = spi_chip_read, /* also fast read 0x0B */
.voltage = {2700, 3600},
},
{
.vendor = "Intel",
.name = "25F640S33B8",
.bustype = BUS_SPI,
.manufacture_id = INTEL_ID,
.model_id = INTEL_25F640S33B8,
.total_size = 8192,
.page_size = 256,
/* OTP: 506B total (2x 8B, 30x 16B, 1x 10B); read 0x4B; write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = probe_spi_rdid,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
/* This chip supports erasing of the 8 so-called "parameter blocks" with
* opcode 0x40. Trying to access an address outside these 8 8kB blocks does
* have no effect on the memory contents, but sets a flag in the SR.
.eraseblocks = {
{8 * 1024, 8},
{64 * 1024, 127} // inaccessible
},
.block_erase = spi_block_erase_40,
}, { */
.eraseblocks = { {64 * 1024, 128} },
.block_erase = spi_block_erase_d8,
}, {
.eraseblocks = { {8 * 1024 * 1024, 1} },
.block_erase = spi_block_erase_c7,
}
},
.printlock = spi_prettyprint_status_register_s33,
.unlock = spi_disable_blockprotect_s33,
.write = spi_chip_write_256,
.read = spi_chip_read, /* also fast read 0x0B */
.voltage = {2700, 3600},
},
{
.vendor = "Intel",
.name = "25F640S33T8",
.bustype = BUS_SPI,
.manufacture_id = INTEL_ID,
.model_id = INTEL_25F640S33T8,
.total_size = 8192,
.page_size = 256,
/* OTP: 506B total (2x 8B, 30x 16B, 1x 10B); read 0x4B; write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = probe_spi_rdid,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
/* This chip supports erasing of the 8 so-called "parameter blocks" with
* opcode 0x40. Trying to access an address outside these 8 8kB blocks does
* have no effect on the memory contents, but sets a flag in the SR.
.eraseblocks = {
{64 * 1024, 127}, // inaccessible
{8 * 1024, 8}
},
.block_erase = spi_block_erase_40,
}, { */
.eraseblocks = { {64 * 1024, 128} },
.block_erase = spi_block_erase_d8,
}, {
.eraseblocks = { {8 * 1024 * 1024, 1} },
.block_erase = spi_block_erase_c7,
}
},
.printlock = spi_prettyprint_status_register_s33,
.unlock = spi_disable_blockprotect_s33,
.write = spi_chip_write_256,
.read = spi_chip_read, /* also fast read 0x0B */
.voltage = {2700, 3600},
},
{
.vendor = "Intel",
.name = "28F001BN/BX-B",