openwrt/flashrom
1
0
Fork 0
mirror of https://review.coreboot.org/flashrom.git synced 2025-04-26 14:42:36 +02:00
Code Issues Releases Wiki Activity

flashchips: Splitting flashchips into separate files by vendor

Browse Source 
To make the flashchips "database" easier to manage, split it by vendor
into several smaller files. This commit transfers the bulk of the data
to separate files and includes them from `flashchips.c`. Although this
is ugly (.c includes are usually frowned upon), it is a necessary evil
to make this commit reproducible.

Tested in two ways:

1) Output of `flashrom -L` has no diffs with/without the patch
compared with diff and cmp tools

2) flashrom binary has no diffs with/without the patch
compared with diff and cmp tools
Note for binary comparison documentation and manpages need to be
disabled (documentation is actually modified in the patch), also
version in meson.build set to "none" (otherwise git version counts
every commit).

Change-Id: I3a9ebb0575e2700c5871d16875495d9c8943b30b
Co-developed-by: Angel Pons <th3fanbus@gmail.com>
Co-developed-by: Anastasia Klimchuk <aklm@flashrom.org>
Signed-off-by: Angel Pons <th3fanbus@gmail.com>
Signed-off-by: Anastasia Klimchuk <aklm@flashrom.org>
Reviewed-on: https://review.coreboot.org/c/flashrom/+/83307
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Peter Marheine <pmarheine@chromium.org>
This commit is contained in:
Angel Pons 2024-07-02 16:51:43 +02:00 committed by Anastasia Klimchuk
parent 3ba9d6140b
commit d07cd9f515
37 changed files with 24143 additions and 23458 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
MAINTAINERS
View File

@ -95,6 +95,7 @@ M: Nikolai Artemiev <nartemiev@google.com>
M: Stefan Reinauer <stefan.reinauer@coreboot.org>
S: Maintained
F: flashchips*
F: flashchips/
F: include/flashchips*
I2C HELPERS

8
doc/contrib_howtos/how_to_add_new_chip.rst
View File

@ -12,7 +12,7 @@ Typically, you would add all the models covered by the datasheet you have, but o
To begin with, make sure you have a link to the publicly available datasheet for the chip you want to add. Publicly
available datasheet is a requirement for adding a new chip.
Open the datasheet, ``flashchips.c`` and ``include/flashchips.h``, and then
Open the datasheet, ``flashchips/`` directory, ``include/flashchips.h``, and then
Model ID and vendor ID
======================
@ -23,7 +23,7 @@ These values come in combination with commands used for probing the chip (more o
probing SPI chips is ``0x9f`` which corresponds to ``PROBE_SPI_RDID``.
At this point you need to double-check if exact same chip is already defined. Search for the ``.name`` and ``.vendor`` of the chip
you have in ``flashchips.c`` and if found, compare values of ``.manufacture_id`` and ``.model_id``. If all 4 values match, it
you have in the files in ``flashchips/`` directory and if found, compare values of ``.manufacture_id`` and ``.model_id``. If all 4 values match, it
seems like the chip already defined. In this case you can try using it. Possibly, only the testing status of the chip needs to be
updated, in this case see :doc:`how_to_mark_chip_tested` for instructions.
@ -52,8 +52,8 @@ and continue with the next section "Properties".
Model ID already exists
^^^^^^^^^^^^^^^^^^^^^^^
It is possible that model ID already exists in the header. Then find the corresponding definition in ``flashchips.c`` and inspect
it carefully. Is it the same chip that you have or a different one?
It is possible that model ID already exists in the header. Then find the corresponding definition in file in ``flashchips/`` directory
and inspect it carefully. Is it the same chip that you have or a different one?
The question you need to figure out is: whether existing definition can work for your chip or not. You figure that out by
reading the rest of instructions and comparing the values from the datasheet with existing definition.

23492
flashchips.c
View File

File diff suppressed because it is too large Load Diff

580
flashchips/amd.c Normal file
View File

@ -0,0 +1,580 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "AMD",
.name = "Am29F002(N)BB",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29F002BB,
.total_size = 256,
.page_size = 256,
.feature_bits = FEATURE_SHORT_RESET | FEATURE_ADDR_2AA,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{32 * 1024, 1},
{64 * 1024, 3},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4750, 5250}, /* 4.75-5.25V for type -55, others 4.5-5.5V */
},
{
.vendor = "AMD",
.name = "Am29F002(N)BT",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29F002BT,
.total_size = 256,
.page_size = 256,
.feature_bits = FEATURE_EITHER_RESET | FEATURE_ADDR_2AA,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 3},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4750, 5250}, /* 4.75-5.25V for type -55, others 4.5-5.5V */
},
{
.vendor = "AMD",
.name = "Am29F010",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29F010,
.total_size = 128,
.page_size = 16 * 1024,
.feature_bits = FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {16 * 1024, 8} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "AMD",
.name = "Am29F010A/B",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29F010,
.total_size = 128,
.page_size = 16 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_OK_PRE,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {16 * 1024, 8} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "AMD",
.name = "Am29F016D",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29F016D,
.total_size = 2 * 1024,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 32} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {2048 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "AMD",
.name = "Am29F040",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29F040,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 8} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "AMD",
.name = "Am29F040B",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29F040,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 8} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "AMD",
.name = "Am29F080",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29F080,
.total_size = 1024,
.page_size = 64 * 1024,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 16} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "AMD",
.name = "Am29F080B",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29F080,
.total_size = 1024,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 16} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "AMD",
.name = "Am29LV001BB",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29LV001BB,
.total_size = 128,
.page_size = 64 * 1024, /* unused */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_OK_PREW,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{8 * 1024, 1},
{4 * 1024, 2},
{16 * 1024, 7},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* 3.0-3.6V for type -45R, others 2.7-3.6V */
},
{
.vendor = "AMD",
.name = "Am29LV001BT",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29LV001BT,
.total_size = 128,
.page_size = 64 * 1024, /* unused */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 7},
{4 * 1024, 2},
{8 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* 3.0-3.6V for type -45R, others 2.7-3.6V */
},
{
.vendor = "AMD",
.name = "Am29LV002BB",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29LV002BB,
.total_size = 256,
.page_size = 64 * 1024, /* unused */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{32 * 1024, 1},
{64 * 1024, 3},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* 3.0-3.6V for type -55, others 2.7-3.6V */
},
{
.vendor = "AMD",
.name = "Am29LV002BT",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29LV002BT,
.total_size = 256,
.page_size = 64 * 1024, /* unused */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 3},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* 3.0-3.6V for type -55, others 2.7-3.6V */
},
{
.vendor = "AMD",
.name = "Am29LV004BB",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29LV004BB,
.total_size = 512,
.page_size = 64 * 1024, /* unused */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{32 * 1024, 1},
{64 * 1024, 7},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},
{
.vendor = "AMD",
.name = "Am29LV004BT",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29LV004BT,
.total_size = 512,
.page_size = 64 * 1024, /* unused */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 7},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},
{
.vendor = "AMD",
.name = "Am29LV008BB",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29LV008BB,
.total_size = 1024,
.page_size = 64 * 1024, /* unused */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_OK_PREW,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{32 * 1024, 1},
{64 * 1024, 15},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* 3.0-3.6V for type -70R, others 2.7-3.6V */
},
{
.vendor = "AMD",
.name = "Am29LV008BT",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29LV008BT,
.total_size = 1024,
.page_size = 64 * 1024, /* unused */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 15},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* 3.0-3.6V for type -70R, others 2.7-3.6V */
},
{
.vendor = "AMD",
.name = "Am29LV040B",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29LV040B,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_OK_PREW,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 8} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* 3.0-3.6V for type -60R, others 2.7-3.6V*/
},
{
.vendor = "AMD",
.name = "Am29LV081B",
.bustype = BUS_PARALLEL,
.manufacture_id = AMD_ID,
.model_id = AMD_AM29LV080B,
.total_size = 1024,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET, /* datasheet specifies address as don't care */
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 16} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* 3.0-3.6V for type -70R, others 2.7-3.6V */
},

884
flashchips/amic.c Normal file
View File

@ -0,0 +1,884 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "AMIC",
.name = "A25L010",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A25L010,
.total_size = 128,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.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_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L016",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A25L016,
.total_size = 2048,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { { 4 * 1024, 512 } },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { { 64 * 1024, 32 } },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { { 2048 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L020",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A25L020,
.total_size = 256,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { { 4 * 1024, 64 } },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { { 64 * 1024, 4 } },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { { 256 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L032",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A25L032,
.total_size = 4096,
.page_size = 256,
/* OTP: 64B total; read 0x4B, 0x48; write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { { 4 * 1024, 1024 } },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { { 64 * 1024, 64 } },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { { 64 * 1024, 64 } },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { { 4096 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { { 4096 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_SRWD_SEC_TB_BP2_WELWIP,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD, /* TODO: 2nd status reg (read with 0x35) */
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L040",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A25L040,
.total_size = 512,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { { 4 * 1024, 128 } },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { { 64 * 1024, 8 } },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { { 512 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L05PT",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID,
.model_id = AMIC_A25L05PT,
.total_size = 64,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID4,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{32 * 1024, 1},
{16 * 1024, 1},
{8 * 1024, 1},
{4 * 1024, 2},
},
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {64 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L05PU",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID,
.model_id = AMIC_A25L05PU,
.total_size = 64,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID4,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{4 * 1024, 2},
{8 * 1024, 1},
{16 * 1024, 1},
{32 * 1024, 1},
},
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {64 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L080",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A25L080,
.total_size = 1024,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { { 4 * 1024, 256 } },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { { 64 * 1024, 16 } },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { { 1024 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L10PT",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID,
.model_id = AMIC_A25L10PT,
.total_size = 128,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID4,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 1},
{32 * 1024, 1},
{16 * 1024, 1},
{8 * 1024, 1},
{4 * 1024, 2},
},
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L10PU",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID,
.model_id = AMIC_A25L10PU,
.total_size = 128,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID4,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{4 * 1024, 2},
{8 * 1024, 1},
{16 * 1024, 1},
{32 * 1024, 1},
{64 * 1024, 1},
},
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L16PT",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID,
.model_id = AMIC_A25L16PT,
.total_size = 2048,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID4,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 31},
{32 * 1024, 1},
{16 * 1024, 1},
{8 * 1024, 1},
{4 * 1024, 2},
},
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {2048 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {2048 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L16PU",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID,
.model_id = AMIC_A25L16PU,
.total_size = 2048,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PR,
.probe = PROBE_SPI_RDID4,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{4 * 1024, 2},
{8 * 1024, 1},
{16 * 1024, 1},
{32 * 1024, 1},
{64 * 1024, 31},
},
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {2048 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {2048 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L20PT",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID,
.model_id = AMIC_A25L20PT,
.total_size = 256,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID4,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 3},
{32 * 1024, 1},
{16 * 1024, 1},
{8 * 1024, 1},
{4 * 1024, 2},
},
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L20PU",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID,
.model_id = AMIC_A25L20PU,
.total_size = 256,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID4,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{4 * 1024, 2},
{8 * 1024, 1},
{16 * 1024, 1},
{32 * 1024, 1},
{64 * 1024, 3},
},
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
/* The A25L40P{T,U} chips are distinguished by their
* erase block layouts, but without any distinction in RDID.
* This inexplicable quirk was verified by Rudolf Marek
* and discussed on the flashrom mailing list on 2010-07-12.
*/
{
.vendor = "AMIC",
.name = "A25L40PT",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID,
.model_id = AMIC_A25L40PT,
.total_size = 512,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PR,
.probe = PROBE_SPI_RDID4,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 7},
{32 * 1024, 1},
{16 * 1024, 1},
{8 * 1024, 1},
{4 * 1024, 2},
},
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L40PU",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID,
.model_id = AMIC_A25L40PU,
.total_size = 512,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID4,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{4 * 1024, 2},
{8 * 1024, 1},
{16 * 1024, 1},
{32 * 1024, 1},
{64 * 1024, 7},
},
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L512",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A25L512,
.total_size = 64,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { { 4 * 1024, 16 } },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { { 64 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { { 64 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25L80P",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID,
.model_id = AMIC_A25L80P,
.total_size = 1024,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PRE,
.probe = PROBE_SPI_RDID4,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{4 * 1024, 2},
{8 * 1024, 1},
{16 * 1024, 1},
{32 * 1024, 1},
{64 * 1024, 15},
},
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25LQ032/A25LQ32A",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A25LQ032,
.total_size = 4096,
.page_size = 256,
/* A25LQ32A supports SFDP */
/* OTP: 64B total; read 0x4B, 0x48; write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { { 4 * 1024, 1024 } },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { { 64 * 1024, 64 } },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { { 64 * 1024, 64 } },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { { 4096 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { { 4096 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_SRWD_SEC_TB_BP2_WELWIP,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD, /* TODO: 2nd status reg (read with 0x35) */
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25LQ16",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A25LQ16,
.total_size = 2048,
.page_size = 256,
/* supports SFDP */
/* OTP: 64B total; read 0x4B, 0x48; write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { { 4 * 1024, 512 } },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { { 64 * 1024, 32 } },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { { 64 * 1024, 32 } },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { { 2048 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { { 2048 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_SRWD_SEC_TB_BP2_WELWIP,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD, /* TODO: 2nd status reg (read with 0x35) */
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A25LQ64",
.bustype = BUS_SPI,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A25LQ64,
.total_size = 8192,
.page_size = 256,
/* supports SFDP */
/* OTP: 512B total; enter 0xB1, exit 0xC1 */
/* QPI enable 0x35, disable 0xF5 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { { 4 * 1024, 2048 } },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { { 32 * 1024, 256 } },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { { 64 * 1024, 128 } },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { { 8192 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { { 8192 * 1024, 1 } },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP3_SRWD, /* bit6 is quad enhance (sic!) */
.unlock = SPI_DISABLE_BLOCKPROTECT_BP3_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "AMIC",
.name = "A29002B",
.bustype = BUS_PARALLEL,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A29002B,
.total_size = 256,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{32 * 1024, 1},
{64 * 1024, 3},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "AMIC",
.name = "A29002T",
.bustype = BUS_PARALLEL,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A29002T,
.total_size = 256,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_OK_PREW,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 3},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "AMIC",
.name = "A29040B",
.bustype = BUS_PARALLEL,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A29040B,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_OK_PREW,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 8} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "AMIC",
.name = "A49LF040A",
.bustype = BUS_LPC,
.manufacture_id = AMIC_ID_NOPREFIX,
.model_id = AMIC_A49LF040A,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
.tested = TEST_OK_PR,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* routine is wrapper to probe_jedec (pm49fl00x.c) */
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 8} },
.block_erase = JEDEC_BLOCK_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.unlock = UNLOCK_REGSPACE2_UNIFORM_64K,
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600},
},

2066
flashchips/atmel.c Normal file
View File

File diff suppressed because it is too large Load Diff

171
flashchips/boya_bohong.c Normal file
View File

@ -0,0 +1,171 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "Boya/BoHong Microelectronics",
.name = "B.25D16A",
.bustype = BUS_SPI,
.manufacture_id = BOYA_BOHONG_ID,
.model_id = BOYA_BOHONG_B_25D16A,
.total_size = 2048,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PR,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "Boya/BoHong Microelectronics",
.name = "B.25D80A",
.bustype = BUS_SPI,
.manufacture_id = BOYA_BOHONG_ID,
.model_id = BOYA_BOHONG_B__25D80A,
.total_size = 1024,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PR,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {1 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "Boya/BoHong Microelectronics",
.name = "B.25Q64AS",
.bustype = BUS_SPI,
.manufacture_id = BOYA_BOHONG_ID,
.model_id = BOYA_BOHONG_B_25Q64AS,
.total_size = 8192,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {16 * 512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {16 * 512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP4_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "Boya/BoHong Microelectronics",
.name = "B.25Q128AS",
.bustype = BUS_SPI,
.manufacture_id = BOYA_BOHONG_ID,
.model_id = BOYA_BOHONG_B_25Q128AS,
.total_size = 16384,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN,
.unlock = SPI_DISABLE_BLOCKPROTECT_AT25FS040,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},

46
flashchips/bright.c Normal file
View File

@ -0,0 +1,46 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "Bright",
.name = "BM29F040",
.bustype = BUS_PARALLEL,
.manufacture_id = BRIGHT_ID,
.model_id = BRIGHT_BM29F040,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_OK_PR,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 8} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},

43
flashchips/catalyst.c Normal file
View File

@ -0,0 +1,43 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "Catalyst",
.name = "CAT28F512",
.bustype = BUS_PARALLEL,
.manufacture_id = CATALYST_ID,
.model_id = CATALYST_CAT28F512,
.total_size = 64,
.page_size = 0, /* unused */
.feature_bits = 0,
.tested = {.probe = OK, .read = OK, .erase = BAD, .write = BAD, .wp = NA},
.probe = PROBE_JEDEC, /* FIXME! */
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 1} },
.block_erase = NO_BLOCK_ERASE_FUNC, /* TODO */
},
},
.write = 0, /* TODO */
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},

43
flashchips/ene.c Normal file
View File

@ -0,0 +1,43 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "ENE",
.name = "KB9012 (EDI)",
.bustype = BUS_SPI,
.total_size = 128,
.page_size = 128,
.feature_bits = FEATURE_ERASED_ZERO,
.tested = TEST_OK_PREW,
.spi_cmd_set = SPI_EDI,
.probe = PROBE_EDI_KB9012,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {128, 1024} },
.block_erase = EDI_CHIP_BLOCK_ERASE,
},
},
.write = EDI_CHIP_WRITE,
.read = EDI_CHIP_READ,
.voltage = {2700, 3600},
.gran = WRITE_GRAN_128BYTES,
},

2100
flashchips/eon.c Normal file
View File

File diff suppressed because it is too large Load Diff

112
flashchips/esi.c Normal file
View File

@ -0,0 +1,112 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "ESI",
.name = "ES25P16",
.bustype = BUS_SPI,
.manufacture_id = EXCEL_ID_NOPREFIX,
.model_id = EXCEL_ES25P16,
.total_size = 2 * 1024,
.page_size = 256,
/* 256-byte parameter page separate from memory array:
* supports read (0x53), fast read (0x5B), erase (0xD5) and program (0x52) instructions. */
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.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_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast Read (0x0B) supported */
.voltage = {2700, 3600},
},
{
.vendor = "ESI",
.name = "ES25P40",
.bustype = BUS_SPI,
.manufacture_id = EXCEL_ID_NOPREFIX,
.model_id = EXCEL_ES25P40,
.total_size = 512,
.page_size = 256,
/* 256-byte parameter page separate from memory array:
* supports read (0x53), fast read (0x5B), erase (0xD5) and program (0x52) instructions. */
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast Read (0x0B) supported */
.voltage = {2700, 3600},
},
{
.vendor = "ESI",
.name = "ES25P80",
.bustype = BUS_SPI,
.manufacture_id = EXCEL_ID_NOPREFIX,
.model_id = EXCEL_ES25P80,
.total_size = 1024,
.page_size = 256,
/* 256-byte parameter page separate from memory array:
* supports read (0x53), fast read (0x5B), erase (0xD5) and program (0x52) instructions. */
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast Read (0x0B) supported */
.voltage = {2700, 3600},
},

121
flashchips/esmt.c Normal file
View File

@ -0,0 +1,121 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "ESMT",
.name = "F25L008A",
.bustype = BUS_SPI,
.manufacture_id = ESMT_ID,
.model_id = ESMT_F25L008A,
.total_size = 1024,
.page_size = 256,
.feature_bits = FEATURE_WRSR_EITHER,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {64 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN, /* TODO: improve */
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE1,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "ESMT",
.name = "F25L32PA",
.bustype = BUS_SPI,
.manufacture_id = ESMT_ID,
.model_id = ESMT_F25L32PA,
.total_size = 4096,
.page_size = 256,
.feature_bits = FEATURE_WRSR_EITHER | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {64 * 1024, 64} },
.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,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_BPL,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "ESMT",
.name = "F49B002UA",
.bustype = BUS_PARALLEL,
.manufacture_id = ESMT_ID,
.model_id = ESMT_F49B002UA,
.total_size = 256,
.page_size = 4096,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{128 * 1024, 1},
{96 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},

423
flashchips/fudan.c Normal file
View File

@ -0,0 +1,423 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "Fudan",
.name = "FM25F005",
.bustype = BUS_SPI,
.manufacture_id = FUDAN_ID_NOPREFIX,
.model_id = FUDAN_FM25F005,
.total_size = 64,
.page_size = 256,
/* OTP: 256B total; enter 0x3A */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers = {
{
.eraseblocks = { {4 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 2} },
.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,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_TB_BPL,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O (0x3B) supported */
.voltage = {2700, 3600}, /* 2.3-2.7V acceptable results in lower performance */
},
{
.vendor = "Fudan",
.name = "FM25F01",
.bustype = BUS_SPI,
.manufacture_id = FUDAN_ID_NOPREFIX,
.model_id = FUDAN_FM25F01,
.total_size = 128,
.page_size = 256,
/* OTP: 256B total; enter 0x3A */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers = {
{
.eraseblocks = { {4 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.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,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_TB_BPL,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O (0x3B) supported */
.voltage = {2700, 3600}, /* 2.3-2.7V acceptable results in lower performance */
},
{
.vendor = "Fudan",
.name = "FM25F02(A)",
.bustype = BUS_SPI,
.manufacture_id = FUDAN_ID_NOPREFIX,
.model_id = FUDAN_FM25F02,
.total_size = 256,
.page_size = 256,
/* OTP: 256B total; enter 0x3A, (A version only:) read ID 0x4B */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers = {
{
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1024 * 256, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {1024 * 256, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
},
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_TB_BPL,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O (0x3B) supported */
.voltage = {2700, 3600}, /* 2.3-2.7V acceptable results in lower performance */
},
{
.vendor = "Fudan",
.name = "FM25F04(A)",
.bustype = BUS_SPI,
.manufacture_id = FUDAN_ID_NOPREFIX,
.model_id = FUDAN_FM25F04,
.total_size = 512,
.page_size = 256,
/* OTP: 256B total; enter 0x3A, (A version only:) read ID 0x4B */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers = {
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1024 * 512, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {1024 * 512, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
},
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_TB_BPL,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O (0x3B) supported */
.voltage = {2700, 3600},
},
{
.vendor = "Fudan",
.name = "FM25Q04",
.bustype = BUS_SPI,
.manufacture_id = FUDAN_ID_NOPREFIX,
.model_id = FUDAN_FM25Q04,
.total_size = 512,
.page_size = 256,
/* supports SFDP */
/* QPI enable 0x38, disable 0xFF */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers = {
{
/* 128 * 4KB sectors */
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
/* 16 * 32KB blocks */
.eraseblocks = { {32 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
/* 8 * 64KB blocks */
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
/* Full chip erase (0x60) */
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
/* Full chip erase (0xC7) */
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
},
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_TB_BPL,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2700, 3600},
},
{
.vendor = "Fudan",
.name = "FM25Q08",
.bustype = BUS_SPI,
.manufacture_id = FUDAN_ID_NOPREFIX,
.model_id = FUDAN_FM25Q08,
.total_size = 1024,
.page_size = 256,
/* supports SFDP */
/* OTP: 1024B total; read 0x48; write 0x42, erase 0x44, read ID 0x4B */
/* QPI enable 0x38, disable 0xFF */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers = {
{
.eraseblocks = { {4 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
},
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_TB_BPL, /* bit6 selects size of protected blocks; TODO: SR2 */
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2700, 3600},
},
{
.vendor = "Fudan",
.name = "FM25Q16",
.bustype = BUS_SPI,
.manufacture_id = FUDAN_ID_NOPREFIX,
.model_id = FUDAN_FM25Q16,
.total_size = 2048,
.page_size = 256,
/* supports SFDP */
/* OTP: 1024B total; read 0x48; write 0x42, erase 0x44, read ID 0x4B */
/* QPI enable 0x38, disable 0xFF */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PR,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers = {
{
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_TB_BPL, /* bit6 selects size of protected blocks; TODO: SR2 */
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2700, 3600},
},
{
.vendor = "Fudan",
.name = "FM25Q32",
.bustype = BUS_SPI,
.manufacture_id = FUDAN_ID_NOPREFIX,
.model_id = FUDAN_FM25Q32,
.total_size = 4096,
.page_size = 256,
/* supports SFDP */
/* OTP: 1024B total; read 0x48; write 0x42, erase 0x44, read ID 0x4B */
/* QPI enable 0x38, disable 0xFF */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers = {
{
.eraseblocks = { {4 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 64} },
.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,
},
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_TB_BPL, /* bit6 selects size of protected blocks; TODO: SR2 */
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2700, 3600},
},
{
.vendor = "Fudan",
.name = "FM25Q64",
.bustype = BUS_SPI,
.manufacture_id = FUDAN_ID_NOPREFIX,
.model_id = FUDAN_FM25Q64,
.total_size = 8192,
.page_size = 256,
/* supports SFDP */
/* QPI enable 0x38, disable 0xFF */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers = {
{
/* 2048 * 4KB sectors */
.eraseblocks = { {4 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
/* 256 * 32KB blocks */
.eraseblocks = { {32 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
/* 128 * 64KB blocks */
.eraseblocks = { {64 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
/* Full chip erase (0x60) */
.eraseblocks = { {8 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
/* Full chip erase (0xC7) */
.eraseblocks = { {8 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
},
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_TB_BPL, /* bit6 selects size of protected blocks; TODO: SR2 */
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2700, 3600},
},
{
.vendor = "Fudan",
.name = "FM25Q128",
.bustype = BUS_SPI,
.manufacture_id = FUDAN_ID_NOPREFIX,
.model_id = FUDAN_FM25Q128,
.total_size = 16384,
.page_size = 256,
/* supports SFDP */
/* QPI enable 0x38, disable 0xFF */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PR,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers = {
{
/* 4096 * 4KB sectors */
.eraseblocks = { {4 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
/* 512 * 32KB blocks */
.eraseblocks = { {32 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
/* 256 * 64KB blocks */
.eraseblocks = { {64 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
/* Full chip erase (0x60) */
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
/* Full chip erase (0xC7) */
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
},
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_TB_BPL, /* bit6 selects size of protected blocks; TODO: SR2 */
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2700, 3600},
},

212
flashchips/fujitsu.c Normal file
View File

@ -0,0 +1,212 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "Fujitsu",
.name = "MBM29F004BC",
.bustype = BUS_PARALLEL,
.manufacture_id = FUJITSU_ID,
.model_id = FUJITSU_MBM29F004BC,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{32 * 1024, 1},
{64 * 1024, 7},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = 0,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "Fujitsu",
.name = "MBM29F004TC",
.bustype = BUS_PARALLEL,
.manufacture_id = FUJITSU_ID,
.model_id = FUJITSU_MBM29F004TC,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 7},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = 0,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
/* FIXME: this has WORD/BYTE sequences; 2AA for word, 555 for byte */
.vendor = "Fujitsu",
.name = "MBM29F400BC",
.bustype = BUS_PARALLEL,
.manufacture_id = FUJITSU_ID,
.model_id = FUJITSU_MBM29F400BC,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_SHIFTED | FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = 10, // FIXME: check datasheet. Using the 10 us from probe_m29f400bt
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{32 * 1024, 1},
{64 * 1024, 7},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4750, 5250}, /* 4.75-5.25V for type -55, others 4.5-5.5V */
},
{
.vendor = "Fujitsu",
.name = "MBM29F400TC",
.bustype = BUS_PARALLEL,
.manufacture_id = FUJITSU_ID,
.model_id = FUJITSU_MBM29F400TC,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_SHIFTED | FEATURE_ADDR_AAA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = 10, // FIXME: check datasheet. Using the 10 us from probe_m29f400bt
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 7},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4750, 5250}, /* 4.75-5.25V for type -55, others 4.5-5.5V */
},
{
.vendor = "Fujitsu",
.name = "MBM29LV160BE",
.bustype = BUS_PARALLEL,
.manufacture_id = FUJITSU_ID,
.model_id = FUJITSU_MBM29LV160BE,
.total_size = 2 * 1024,
.page_size = 0,
.feature_bits = FEATURE_ADDR_SHIFTED | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = 10, // FIXME: check datasheet. Using the 10 us from probe_m29f400bt
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{32 * 1024, 1},
{64 * 1024, 31},
},
.block_erase = JEDEC_BLOCK_ERASE,
}, {
.eraseblocks = { {2048 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1, /* Supports a fast mode too */
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* 3.0-3.6V for type -70, others 2.7-3.6V */
},
{
.vendor = "Fujitsu",
.name = "MBM29LV160TE",
.bustype = BUS_PARALLEL,
.manufacture_id = FUJITSU_ID,
.model_id = FUJITSU_MBM29LV160TE,
.total_size = 2 * 1024,
.page_size = 0,
.feature_bits = FEATURE_ADDR_SHIFTED | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = 10, // FIXME: check datasheet. Using the 10 us from probe_m29f400bt
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 31},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_BLOCK_ERASE,
}, {
.eraseblocks = { {2048 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1, /* Supports a fast mode too */
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* 3.0-3.6V for type -70, others 2.7-3.6V */
},

1714
flashchips/gigadevice.c Normal file
View File

File diff suppressed because it is too large Load Diff

110
flashchips/hyundai.c Normal file
View File

@ -0,0 +1,110 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "Hyundai",
.name = "HY29F002B",
.bustype = BUS_PARALLEL,
.manufacture_id = HYUNDAI_ID,
.model_id = HYUNDAI_HY29F002B,
.total_size = 256,
.page_size = 256 * 1024,
.feature_bits = FEATURE_EITHER_RESET, /* Some revisions may need FEATURE_ADDR_2AA */
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{32 * 1024, 1},
{64 * 1024, 3},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4750, 5250}, /* 4.75-5.25V for type -45, others 4.5-5.5V */
},
{
.vendor = "Hyundai",
.name = "HY29F002T",
.bustype = BUS_PARALLEL,
.manufacture_id = HYUNDAI_ID,
.model_id = HYUNDAI_HY29F002T,
.total_size = 256,
.page_size = 256 * 1024,
.feature_bits = FEATURE_EITHER_RESET, /* Some revisions may need FEATURE_ADDR_2AA */
.tested = TEST_OK_PRE,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 3},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4750, 5250}, /* 4.75-5.25V for type -45, others 4.5-5.5V */
},
{
.vendor = "Hyundai",
.name = "HY29F040A",
.bustype = BUS_PARALLEL,
.manufacture_id = HYUNDAI_ID,
.model_id = HYUNDAI_HY29F040A,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 8} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},

517
flashchips/intel.c Normal file
View File

@ -0,0 +1,517 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.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_BP2_EP_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_EP_SRWD,
.write = SPI_CHIP_WRITE256,
.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_BP2_EP_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_EP_SRWD,
.write = SPI_CHIP_WRITE256,
.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_BP2_EP_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_EP_SRWD,
.write = SPI_CHIP_WRITE256,
.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_BP2_EP_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_EP_SRWD,
.write = SPI_CHIP_WRITE256,
.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_OK_PREW,
.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_BP2_EP_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_EP_SRWD,
.write = SPI_CHIP_WRITE256,
.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_BP2_EP_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_EP_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* also fast read 0x0B */
.voltage = {2700, 3600},
},
{
.vendor = "Intel",
.name = "28F001BN/BX-B",
.bustype = BUS_PARALLEL,
.manufacture_id = INTEL_ID,
.model_id = INTEL_28F001B,
.total_size = 128,
.page_size = 128 * 1024, /* 8k + 2x4k + 112k */
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{8 * 1024, 1},
{4 * 1024, 2},
{112 * 1024, 1},
},
.block_erase = ERASE_BLOCK_82802AB,
},
},
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "Intel",
.name = "28F001BN/BX-T",
.bustype = BUS_PARALLEL,
.manufacture_id = INTEL_ID,
.model_id = INTEL_28F001T,
.total_size = 128,
.page_size = 128 * 1024, /* 112k + 2x4k + 8k */
.tested = TEST_OK_PREW,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{112 * 1024, 1},
{4 * 1024, 2},
{8 * 1024, 1},
},
.block_erase = ERASE_BLOCK_82802AB,
},
},
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "Intel",
.name = "28F002BC/BL/BV/BX-T",
.bustype = BUS_PARALLEL,
.manufacture_id = INTEL_ID,
.model_id = INTEL_28F002T,
.total_size = 256,
.page_size = 256 * 1024,
.tested = TEST_OK_PRE,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{128 * 1024, 1},
{96 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = ERASE_BLOCK_82802AB,
},
},
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
},
{
.vendor = "Intel",
.name = "28F004B5/BE/BV/BX-B",
.bustype = BUS_PARALLEL,
.manufacture_id = INTEL_ID,
.model_id = INTEL_28F004B,
.total_size = 512,
.page_size = 128 * 1024, /* maximal block size */
.tested = TEST_UNTESTED,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{96 * 1024, 1},
{128 * 1024, 3},
},
.block_erase = ERASE_BLOCK_82802AB,
},
},
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
},
{
.vendor = "Intel",
.name = "28F004B5/BE/BV/BX-T",
.bustype = BUS_PARALLEL,
.manufacture_id = INTEL_ID,
.model_id = INTEL_28F004T,
.total_size = 512,
.page_size = 128 * 1024, /* maximal block size */
.tested = TEST_UNTESTED,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{128 * 1024, 3},
{96 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = ERASE_BLOCK_82802AB,
},
},
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
},
{
.vendor = "Intel",
.name = "28F008S3/S5/SC",
.bustype = BUS_PARALLEL,
.manufacture_id = INTEL_ID,
.model_id = INTEL_28F004S3,
.total_size = 512,
.page_size = 256,
.tested = TEST_UNTESTED,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 8} },
.block_erase = ERASE_BLOCK_82802AB,
},
},
.unlock = UNLOCK_28F004S5,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
},
{
.vendor = "Intel",
.name = "28F400BV/BX/CE/CV-B",
.bustype = BUS_PARALLEL,
.manufacture_id = INTEL_ID,
.model_id = INTEL_28F400B,
.total_size = 512,
.page_size = 128 * 1024, /* maximal block size */
.feature_bits = FEATURE_ADDR_SHIFTED,
.tested = TEST_UNTESTED,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{96 * 1024, 1},
{128 * 1024, 3},
},
.block_erase = ERASE_BLOCK_82802AB,
},
},
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
},
{
.vendor = "Intel",
.name = "28F400BV/BX/CE/CV-T",
.bustype = BUS_PARALLEL,
.manufacture_id = INTEL_ID,
.model_id = INTEL_28F400T,
.total_size = 512,
.page_size = 128 * 1024, /* maximal block size */
.feature_bits = FEATURE_ADDR_SHIFTED,
.tested = TEST_UNTESTED,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{128 * 1024, 3},
{96 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = ERASE_BLOCK_82802AB,
},
},
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
},
{
.vendor = "Intel",
.name = "AT82802AB",
.bustype = BUS_FWH,
.manufacture_id = INTEL_ID,
.model_id = INTEL_82802AB,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_REGISTERMAP,
.tested = TEST_OK_PREW,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_IGNORED, /* routine does not use probe_timing (82802ab.c) */
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 8} },
.block_erase = ERASE_BLOCK_82802AB,
},
},
.unlock = UNLOCK_REGSPACE2_UNIFORM_64K,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600},
},
{
.vendor = "Intel",
.name = "82802AC",
.bustype = BUS_FWH,
.manufacture_id = INTEL_ID,
.model_id = INTEL_82802AC,
.total_size = 1024,
.page_size = 64 * 1024,
.feature_bits = FEATURE_REGISTERMAP,
.tested = TEST_OK_PR,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_IGNORED, /* routine does not use probe_timing (82802ab.c) */
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 16} },
.block_erase = ERASE_BLOCK_82802AB,
},
},
.unlock = UNLOCK_REGSPACE2_UNIFORM_64K,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600},
},

730
flashchips/issi.c Normal file
View File

@ -0,0 +1,730 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "ISSI",
.name = "IS25LP016",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25LP016,
.total_size = 2048,
.page_size = 256,
/* OTP: 1024B total; read 0x48; write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.unlock = SPI_DISABLE_BLOCKPROTECT_BP3_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2300, 3600},
},
{
.vendor = "ISSI",
.name = "IS25LP064",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25LP064,
.total_size = 8192,
.page_size = 256,
/* OTP: 1024B total; read 0x48; write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 128} },
.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,
}
},
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2300, 3600},
},
{
.vendor = "ISSI",
.name = "IS25LP128",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25LP128,
.total_size = 16384,
.page_size = 256,
/* OTP: 1024B total; read 0x48; write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2300, 3600},
},
{
.vendor = "ISSI",
.name = "IS25LP256",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25LP256,
.total_size = 32768,
.page_size = 256,
/* supports SFDP */
/* OTP: 1024B total; read 0x68; write 0x62, erase 0x64, read ID 0x4B */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP |
FEATURE_4BA | FEATURE_4BA_ENTER_EAR7 | FEATURE_4BA_EAR_1716,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_21,
}, {
.eraseblocks = { {4 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_20,
/* could also use SPI_BLOCK_ERASE_D7 */
}, {
.eraseblocks = { {32 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_5C,
}, {
.eraseblocks = { {32 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_DC,
}, {
.eraseblocks = { {64 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {32 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {32 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2300, 3600},
},
{
.vendor = "ISSI",
.name = "IS25LQ016",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25LQ016,
.total_size = 2048,
.page_size = 256,
/* OTP: 256B total; read 0x4b; write 0xb1 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP3_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2300, 3600},
},
{
.vendor = "ISSI",
.name = "IS25WP016",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25WP016,
.total_size = 2048,
.page_size = 256,
/* OTP: 1024B total; read 0x48; write 0x42 */
/* QPI enable 0x35, disable 0xF5 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "ISSI",
.name = "IS25WP020",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25WP020,
.total_size = 256,
.page_size = 256,
/* OTP: 1024B total; read 0x48; write 0x42 */
/* QPI enable 0x35, disable 0xF5 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "ISSI",
.name = "IS25WP032",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25WP032,
.total_size = 4096,
.page_size = 256,
/* OTP: 1024B total; read 0x48; write 0x42 */
/* QPI enable 0x35, disable 0xF5 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 64} },
.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,
}
},
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "ISSI",
.name = "IS25WP040",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25WP040,
.total_size = 512,
.page_size = 256,
/* OTP: 1024B total; read 0x48; write 0x42 */
/* QPI enable 0x35, disable 0xF5 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "ISSI",
.name = "IS25WP064",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25WP064,
.total_size = 8192,
.page_size = 256,
/* OTP: 1024B total; read 0x48; write 0x42 */
/* QPI enable 0x35, disable 0xF5 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 128} },
.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,
}
},
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "ISSI",
.name = "IS25WP080",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25WP080,
.total_size = 1024,
.page_size = 256,
/* OTP: 1024B total; read 0x48; write 0x42 */
/* QPI enable 0x35, disable 0xF5 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "ISSI",
.name = "IS25WP128",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25WP128,
.total_size = 16384,
.page_size = 256,
/* OTP: 1024B total; read 0x48; write 0x42 */
/* QPI enable 0x35, disable 0xF5 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "ISSI",
.name = "IS25WP256",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25WP256,
.total_size = 32768,
.page_size = 256,
/* supports SFDP */
/* OTP: 1024B total; read 0x68; write 0x62, erase 0x64, read ID 0x4B */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP |
FEATURE_4BA | FEATURE_4BA_ENTER_EAR7 | FEATURE_4BA_EAR_1716,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_21,
}, {
.eraseblocks = { {4 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_20,
/* could also use SPI_BLOCK_ERASE_D7 */
}, {
.eraseblocks = { {32 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_5C,
}, {
.eraseblocks = { {32 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_DC,
}, {
.eraseblocks = { {64 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {32 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {32 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "ISSI",
.name = "IS25WQ040",
.bustype = BUS_SPI,
.manufacture_id = ISSI_ID_SPI,
.model_id = ISSI_IS25WQ040,
.total_size = 512,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "ISSI",
.name = "IS29GL064B",
.bustype = BUS_PARALLEL,
.manufacture_id = ISSI_ID,
.model_id = ISSI_PMC_IS29GL064B,
.total_size = 8192,
.page_size = 128 * 1024, /* actual page size is 16 */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC_29GL,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{8 * 1024, 8},
{64 * 1024, 127},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {8 * 1024 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},
{
.vendor = "ISSI",
.name = "IS29GL064H/L",
.bustype = BUS_PARALLEL,
.manufacture_id = ISSI_ID,
.model_id = ISSI_PMC_IS29GL064HL,
.total_size = 8192,
.page_size = 128 * 1024, /* actual page size is 16 */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC_29GL,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 128} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {8 * 1024 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},
{
.vendor = "ISSI",
.name = "IS29GL064T",
.bustype = BUS_PARALLEL,
.manufacture_id = ISSI_ID,
.model_id = ISSI_PMC_IS29GL064T,
.total_size = 8192,
.page_size = 128 * 1024, /* actual page size is 16 */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC_29GL,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 127},
{8 * 1024, 8},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {8 * 1024 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},
{
.vendor = "ISSI",
.name = "IS29GL128H/L",
.bustype = BUS_PARALLEL,
.manufacture_id = ISSI_ID,
.model_id = ISSI_PMC_IS29GL128HL,
.total_size = 16384,
.page_size = 128 * 1024, /* actual page size is 16 */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC_29GL,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {128 * 1024, 128} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},

2902
flashchips/macronix.c Normal file
View File

File diff suppressed because it is too large Load Diff

486
flashchips/micron.c Normal file
View File

@ -0,0 +1,486 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "Micron",
.name = "MT25QL01G", /* L = 3V, uniform 64KB/4KB blocks/sectors */
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = ST_N25Q00A__3G,
.total_size = 131072,
.page_size = 256,
/* supports SFDP */
/* OTP: 64B total; read 0x4B, write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 32768} },
.block_erase = SPI_BLOCK_ERASE_21,
}, {
.eraseblocks = { {4 * 1024, 32768} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_5C,
}, {
.eraseblocks = { {32 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_DC,
}, {
.eraseblocks = { {64 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {65536 * 1024, 2} },
.block_erase = SPI_BLOCK_ERASE_C4,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_N25Q, /* TODO: config, lock, flag regs */
.unlock = SPI_DISABLE_BLOCKPROTECT_N25Q, /* TODO: per 64kB sector lock registers */
.write = SPI_CHIP_WRITE256, /* Multi I/O supported */
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2700, 3600},
},
{
.vendor = "Micron",
.name = "MT25QU01G", /* U = 1.8V, uniform 64KB/4KB blocks/sectors */
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = ST_N25Q00A__1G,
.total_size = 131072,
.page_size = 256,
/* supports SFDP */
/* OTP: 64B total; read 0x4B, write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 32768} },
.block_erase = SPI_BLOCK_ERASE_21,
}, {
.eraseblocks = { {4 * 1024, 32768} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_5C,
}, {
.eraseblocks = { {32 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_DC,
}, {
.eraseblocks = { {64 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {65536 * 1024, 2} },
.block_erase = SPI_BLOCK_ERASE_C4,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_N25Q, /* TODO: config, lock, flag regs */
.unlock = SPI_DISABLE_BLOCKPROTECT_N25Q, /* TODO: per 64kB sector lock registers */
.write = SPI_CHIP_WRITE256, /* Multi I/O supported */
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {1700, 2000},
},
{
.vendor = "Micron",
.name = "MT25QL02G", /* L = 3V, uniform 64KB/4KB blocks/sectors */
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = ST_MT25QL02G,
.total_size = 262144,
.page_size = 256,
/* supports SFDP */
/* OTP: 64B total; read 0x4B, write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 65536} },
.block_erase = SPI_BLOCK_ERASE_21,
}, {
.eraseblocks = { {4 * 1024, 65536} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_5C,
}, {
.eraseblocks = { {32 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_DC,
}, {
.eraseblocks = { {64 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {65536 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_C4,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_N25Q, /* TODO: config, lock, flag regs */
.unlock = SPI_DISABLE_BLOCKPROTECT_N25Q, /* TODO: per 64kB sector lock registers */
.write = SPI_CHIP_WRITE256, /* Multi I/O supported */
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2700, 3600},
},
{
.vendor = "Micron",
.name = "MT25QU02G", /* U = 1.8V, uniform 64KB/4KB blocks/sectors */
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = ST_MT25QU02G,
.total_size = 262144,
.page_size = 256,
/* supports SFDP */
/* OTP: 64B total; read 0x4B, write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 65536} },
.block_erase = SPI_BLOCK_ERASE_21,
}, {
.eraseblocks = { {4 * 1024, 65536} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_5C,
}, {
.eraseblocks = { {32 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_DC,
}, {
.eraseblocks = { {64 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {65536 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_C4,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_N25Q, /* TODO: config, lock, flag regs */
.unlock = SPI_DISABLE_BLOCKPROTECT_N25Q, /* TODO: per 64kB sector lock registers */
.write = SPI_CHIP_WRITE256, /* Multi I/O supported */
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {1700, 2000},
},
{
.vendor = "Micron",
.name = "MT25QU128", /* U = 1.8V, uniform 64KB/4KB blocks/sectors */
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = ST_N25Q128__1E,
.total_size = 16384,
.page_size = 256,
/* supports SFDP */
/* OTP: 64B total; read 0x4B, write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {16384 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}, {
.eraseblocks = { {16384 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_N25Q, /* TODO: config, lock, flag regs */
.unlock = SPI_DISABLE_BLOCKPROTECT_N25Q, /* TODO: per 64kB sector lock registers */
.write = SPI_CHIP_WRITE256, /* Multi I/O supported */
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {1700, 2000},
},
{
.vendor = "Micron",
.name = "MT25QL128", /* L = 3V, uniform 64KB/4KB blocks/sectors */
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = ST_N25Q128__3E,
.total_size = 16384,
.page_size = 256,
/* supports SFDP */
/* OTP: 64B total; read 0x4B, write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {16384 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}, {
.eraseblocks = { {16384 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_N25Q, /* TODO: config, lock, flag regs */
.unlock = SPI_DISABLE_BLOCKPROTECT_N25Q, /* TODO: per 64kB sector lock registers */
.write = SPI_CHIP_WRITE256, /* Multi I/O supported */
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2700, 3600},
},
{
.vendor = "Micron",
.name = "MT25QL256", /* L = 3V, uniform 64KB/4KB blocks/sectors */
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = ST_N25Q256__3E,
.total_size = 32768,
.page_size = 256,
/* supports SFDP */
/* OTP: 64B total; read 0x4B, write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_21,
}, {
.eraseblocks = { {4 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_5C,
}, {
.eraseblocks = { {32 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_DC,
}, {
.eraseblocks = { {64 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {32768 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}, {
.eraseblocks = { {32768 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_N25Q, /* TODO: config, lock, flag regs */
.unlock = SPI_DISABLE_BLOCKPROTECT_N25Q, /* TODO: per 64kB sector lock registers */
.write = SPI_CHIP_WRITE256, /* Multi I/O supported */
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2700, 3600},
},
{
.vendor = "Micron",
.name = "MT25QU256", /* U = 1.8V, uniform 64KB/4KB blocks/sectors */
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = ST_N25Q256__1E,
.total_size = 32768,
.page_size = 256,
/* supports SFDP */
/* OTP: 64B total; read 0x4B, write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_21,
}, {
.eraseblocks = { {4 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_5C,
}, {
.eraseblocks = { {32 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_DC,
}, {
.eraseblocks = { {64 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {32768 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}, {
.eraseblocks = { {32768 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_N25Q, /* TODO: config, lock, flag regs */
.unlock = SPI_DISABLE_BLOCKPROTECT_N25Q, /* TODO: per 64kB sector lock registers */
.write = SPI_CHIP_WRITE256, /* Multi I/O supported */
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {1700, 2000},
},
{
.vendor = "Micron",
.name = "MT25QL512", /* L = 3V, uniform 64KB/4KB blocks/sectors */
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = ST_N25Q512__3G,
.total_size = 65536,
.page_size = 256,
/* supports SFDP */
/* OTP: 64B total; read 0x4B, write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 16384} },
.block_erase = SPI_BLOCK_ERASE_21,
}, {
.eraseblocks = { {4 * 1024, 16384} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_5C,
}, {
.eraseblocks = { {32 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_DC,
}, {
.eraseblocks = { {64 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {65536 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}, {
.eraseblocks = { {65536 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_N25Q, /* TODO: config, lock, flag regs */
.unlock = SPI_DISABLE_BLOCKPROTECT_N25Q, /* TODO: per 64kB sector lock registers */
.write = SPI_CHIP_WRITE256, /* Multi I/O supported */
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2700, 3600},
.reg_bits =
{
.srp = {STATUS1, 7, RW},
.bp = {{STATUS1, 2, RW}, {STATUS1, 3, RW}, {STATUS1, 4, RW}, {STATUS1, 6, RW}},
.tb = {STATUS1, 5, RW},
},
.decode_range = DECODE_RANGE_SPI25,
},
{
.vendor = "Micron",
.name = "MT25QU512", /* U = 1.8V, uniform 64KB/4KB blocks/sectors */
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = ST_N25Q512__1G,
.total_size = 65536,
.page_size = 256,
/* supports SFDP */
/* OTP: 64B total; read 0x4B, write 0x42 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 16384} },
.block_erase = SPI_BLOCK_ERASE_21,
}, {
.eraseblocks = { {4 * 1024, 16384} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_5C,
}, {
.eraseblocks = { {32 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_DC,
}, {
.eraseblocks = { {64 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {65536 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}, {
.eraseblocks = { {65536 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_N25Q, /* TODO: config, lock, flag regs */
.unlock = SPI_DISABLE_BLOCKPROTECT_N25Q, /* TODO: per 64kB sector lock registers */
.write = SPI_CHIP_WRITE256, /* Multi I/O supported */
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {1700, 2000},
},

1358
flashchips/micron_numonyx_st.c Normal file
View File

File diff suppressed because it is too large Load Diff

208
flashchips/mosel_vitelic.c Normal file
View File

@ -0,0 +1,208 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "MoselVitelic",
.name = "V29C51000B",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = MVC_V29C51000B,
.total_size = 64,
.page_size = 512,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {512, 128} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {64 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "MoselVitelic",
.name = "V29C51000T",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = MVC_V29C51000T,
.total_size = 64,
.page_size = 512,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {512, 128} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {64 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "MoselVitelic",
.name = "V29C51400B",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = MVC_V29C51400B,
.total_size = 512,
.page_size = 1024,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {1024, 512} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "MoselVitelic",
.name = "V29C51400T",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = MVC_V29C51400T,
.total_size = 512,
.page_size = 1024,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {1024, 512} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "MoselVitelic",
.name = "V29LC51000",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = MVC_V29LC51000,
.total_size = 64,
.page_size = 512,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {512, 128} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {64 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "MoselVitelic",
.name = "V29LC51001",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = MVC_V29LC51001,
.total_size = 128,
.page_size = 512,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {512, 256} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "MoselVitelic",
.name = "V29LC51002",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = MVC_V29LC51002,
.total_size = 256,
.page_size = 512,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {512, 512} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},

215
flashchips/nantronics.c Normal file
View File

@ -0,0 +1,215 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "Nantronics",
.name = "N25S10",
.bustype = BUS_SPI,
.manufacture_id = NANTRONICS_ID_NOPREFIX,
.model_id = NANTRONICS_N25S10,
.total_size = 128,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.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,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP3_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP3_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O read (0x3B) supported */
.voltage = {2700, 3600},
},
{
.vendor = "Nantronics",
.name = "N25S16",
.bustype = BUS_SPI,
.manufacture_id = NANTRONICS_ID_NOPREFIX,
.model_id = NANTRONICS_N25S16,
.total_size = 2048,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {64 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {2048 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {2048 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP3_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP3_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O read (0x3B) supported */
.voltage = {2700, 3600},
},
{
.vendor = "Nantronics",
.name = "N25S20",
.bustype = BUS_SPI,
.manufacture_id = NANTRONICS_ID_NOPREFIX,
.model_id = NANTRONICS_N25S20,
.total_size = 256,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP3_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP3_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O read (0x3B) supported */
.voltage = {2700, 3600},
},
{
.vendor = "Nantronics",
.name = "N25S40",
.bustype = BUS_SPI,
.manufacture_id = NANTRONICS_ID_NOPREFIX,
.model_id = NANTRONICS_N25S40,
.total_size = 512,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP3_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP3_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O read (0x3B) supported */
.voltage = {2700, 3600},
},
{
.vendor = "Nantronics",
.name = "N25S80",
.bustype = BUS_SPI,
.manufacture_id = NANTRONICS_ID_NOPREFIX,
.model_id = NANTRONICS_N25S80,
.total_size = 1024,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP3_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP3_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O read (0x3B) supported */
.voltage = {2700, 3600},
},

886
flashchips/pmc.c Normal file
View File

@ -0,0 +1,886 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "PMC",
.name = "Pm25LD010(C)",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LD010,
.total_size = 128,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 4} },
.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,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT, /* FIXME: C version supports "Safe Guard" */
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O supported */
.voltage = {2700, 3600}, /* 2.3-3.6V for Pm25LD010 */
},
{
.vendor = "PMC",
.name = "Pm25LD020(C)",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LD020,
.total_size = 256,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT, /* FIXME: C version supports "Safe Guard" */
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O supported */
.voltage = {2700, 3600}, /* 2.3-3.6V for Pm25LD020 */
},
{
.vendor = "PMC",
.name = "Pm25LD040(C)",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LV040,
.total_size = 512,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O supported */
.voltage = {2700, 3600}, /* 2.3-3.6V for Pm25LD040 */
},
{
.vendor = "PMC",
.name = "Pm25LD256C",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LD256C,
.total_size = 32,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {32 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {32 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O supported */
.voltage = {2700, 3600},
},
{
.vendor = "PMC",
.name = "Pm25LD512(C)",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LD512,
.total_size = 64,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 2} },
.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,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT, /* FIXME: C version supports "Safe Guard" */
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual I/O supported */
.voltage = {2300, 3600},
},
{
.vendor = "PMC",
.name = "Pm25LQ016",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LQ016,
.total_size = 2048,
.page_size = 256,
/* OTP: 256B total; read 0x4B, write 0xB1 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {2048 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {2048 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP3_SRWD, /* bit6 is quad enable */
.unlock = SPI_DISABLE_BLOCKPROTECT_BP3_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2300, 3600},
},
{
.vendor = "PMC",
.name = "Pm25LQ020",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LQ020,
.total_size = 256,
.page_size = 256,
/* OTP: 256B total; read 0x4B, write 0xB1 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP3_SRWD, /* bit6 is quad enable */
.unlock = SPI_DISABLE_BLOCKPROTECT_BP3_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2300, 3600},
},
{
.vendor = "PMC",
.name = "Pm25LQ032C",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LQ032C,
.total_size = 4096,
.page_size = 256,
/* OTP: 64B total; read 0x4B, write 0xB1 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {4096 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {4096 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP3_SRWD, /* bit6 is quad enable */
.unlock = SPI_DISABLE_BLOCKPROTECT_BP3_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2700, 3600},
},
{
.vendor = "PMC",
.name = "Pm25LQ040",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LQ040,
.total_size = 512,
.page_size = 256,
/* OTP: 256B total; read 0x4B, write 0xB1 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP3_SRWD, /* bit6 is quad enable */
.unlock = SPI_DISABLE_BLOCKPROTECT_BP3_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2300, 3600},
},
{
.vendor = "PMC",
.name = "Pm25LQ080",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LQ080,
.total_size = 1024,
.page_size = 256,
/* OTP: 64B total; read 0x4B, write 0xB1 */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP3_SRWD, /* bit6 is quad enable */
.unlock = SPI_DISABLE_BLOCKPROTECT_BP3_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) and multi I/O supported */
.voltage = {2300, 3600},
},
{
.vendor = "PMC",
.name = "Pm25LV010",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID_NOPREFIX,
.model_id = PMC_PM25LV010,
.total_size = 128,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RES2, /* The continuation code is transferred as the 3rd byte m( */
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) supported */
.voltage = {2700, 3600},
},
{
.vendor = "PMC",
.name = "Pm25LV010A",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LV010,
.total_size = 128,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) supported */
.voltage = {2700, 3600},
},
{
.vendor = "PMC",
.name = "Pm25LV016B",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LV016B,
.total_size = 2048,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {64 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) supported */
.voltage = {2700, 3600},
},
{
.vendor = "PMC",
.name = "Pm25LV020",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LV020,
.total_size = 256,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "PMC",
.name = "Pm25LV040",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LV040,
.total_size = 512,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) supported */
.voltage = {2700, 3600},
},
{
.vendor = "PMC",
.name = "Pm25LV080B",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID,
.model_id = PMC_PM25LV080B,
.total_size = 1024,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {4 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {64 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) supported */
.voltage = {2700, 3600},
},
{
.vendor = "PMC",
.name = "Pm25LV512(A)",
.bustype = BUS_SPI,
.manufacture_id = PMC_ID_NOPREFIX,
.model_id = PMC_PM25LV512,
.total_size = 64,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RES2, /* The continuation code is transferred as the 3rd byte m( */
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 2} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {64 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B) supported */
.voltage = {2700, 3600},
},
{
.vendor = "PMC",
.name = "Pm29F002B",
.bustype = BUS_PARALLEL,
.manufacture_id = PMC_ID_NOPREFIX,
.model_id = PMC_PM29F002B,
.total_size = 256,
.page_size = 8 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_FIXME,
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{96 * 1024, 1},
{128 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "PMC",
.name = "Pm29F002T",
.bustype = BUS_PARALLEL,
.manufacture_id = PMC_ID_NOPREFIX,
.model_id = PMC_PM29F002T,
.total_size = 256,
.page_size = 8 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_OK_PREW,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_FIXME,
.block_erasers =
{
{
.eraseblocks = {
{128 * 1024, 1},
{96 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "PMC",
.name = "Pm39LV010",
.bustype = BUS_PARALLEL,
.manufacture_id = PMC_ID_NOPREFIX,
.model_id = PMC_PM39F010, /* Pm39LV010 and Pm39F010 have identical IDs but different voltage */
.total_size = 128,
.page_size = 4096,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_OK_PREW,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 32} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {64 * 1024, 2} },
.block_erase = JEDEC_BLOCK_ERASE,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},
{
.vendor = "PMC",
.name = "Pm39LV020",
.bustype = BUS_PARALLEL,
.manufacture_id = PMC_ID_NOPREFIX,
.model_id = PMC_PM39LV020,
.total_size = 256,
.page_size = 4096,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 64} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {64 * 1024, 4} },
.block_erase = JEDEC_BLOCK_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},
{
.vendor = "PMC",
.name = "Pm39LV040",
.bustype = BUS_PARALLEL,
.manufacture_id = PMC_ID_NOPREFIX,
.model_id = PMC_PM39LV040,
.total_size = 512,
.page_size = 4096,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_OK_PR,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = JEDEC_BLOCK_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},
{
.vendor = "PMC",
.name = "Pm39LV512",
.bustype = BUS_PARALLEL,
.manufacture_id = PMC_ID_NOPREFIX,
.model_id = PMC_PM39LV512,
.total_size = 64,
.page_size = 4096,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_OK_PREW,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 16} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {64 * 1024, 1} },
.block_erase = JEDEC_BLOCK_ERASE,
}, {
.eraseblocks = { {64 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},
{
.vendor = "PMC",
.name = "Pm49FL002",
.bustype = BUS_LPC | BUS_FWH, /* A/A Mux */
.manufacture_id = PMC_ID_NOPREFIX,
.model_id = PMC_PM49FL002,
.total_size = 256,
.page_size = 16 * 1024,
.feature_bits = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
.tested = TEST_OK_PR,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* routine is wrapper to JEDEC (pm49fl00x.c) */
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 64} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {16 * 1024, 16} },
.block_erase = JEDEC_BLOCK_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.unlock = UNLOCK_REGSPACE2_UNIFORM_32K,
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600},
},
{
.vendor = "PMC",
.name = "Pm49FL004",
.bustype = BUS_LPC | BUS_FWH, /* A/A Mux */
.manufacture_id = PMC_ID_NOPREFIX,
.model_id = PMC_PM49FL004,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
.tested = TEST_OK_PREW,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = JEDEC_BLOCK_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.unlock = UNLOCK_REGSPACE2_UNIFORM_64K,
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600},
},

148
flashchips/puya.c Normal file
View File

@ -0,0 +1,148 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "PUYA",
.name = "P25Q06H",
.bustype = BUS_SPI,
.manufacture_id = PUYA_ID,
.model_id = PUYA_P25Q06H,
.total_size = 64,
.page_size = 256,
/* supports SFDP */
/* OTP: 3 x 512 bytes */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {256, 256} },
.block_erase = SPI_BLOCK_ERASE_81,
}, {
.eraseblocks = { {4 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 2} },
.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,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP4_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP4_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2300, 3600},
},
{
.vendor = "PUYA",
.name = "P25Q11H",
.bustype = BUS_SPI,
.manufacture_id = PUYA_ID,
.model_id = PUYA_P25Q11H,
.total_size = 128,
.page_size = 256,
/* supports SFDP */
/* OTP: 3 x 512 bytes */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {256, 512} },
.block_erase = SPI_BLOCK_ERASE_81,
}, {
.eraseblocks = { {4 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.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,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP4_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP4_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2300, 3600},
},
{
.vendor = "PUYA",
.name = "P25Q21H",
.bustype = BUS_SPI,
.manufacture_id = PUYA_ID,
.model_id = PUYA_P25Q21H,
.total_size = 256,
.page_size = 256,
/* supports SFDP */
/* OTP: 3 x 512 bytes */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {256, 1024} },
.block_erase = SPI_BLOCK_ERASE_81,
}, {
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP4_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP4_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2300, 3600},
},

417
flashchips/sanyo.c Normal file
View File

@ -0,0 +1,417 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "Sanyo",
.name = "LE25FU106B",
.bustype = BUS_SPI,
.manufacture_id = SANYO_ID,
.model_id = SANYO_LE25FU106B,
.total_size = 128,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RES2,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
/* FIXME: Is this correct?
{
.eraseblocks = { {2 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_D7,
},*/
{
.eraseblocks = { {32 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP1_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2300, 3600},
},
{
.vendor = "Sanyo",
.name = "LE25FU206",
.bustype = BUS_SPI,
.manufacture_id = SANYO_ID,
.model_id = SANYO_LE25FU206,
.total_size = 256,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RES2,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP1_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2300, 3600},
},
{
.vendor = "Sanyo",
.name = "LE25FU206A",
.bustype = BUS_SPI,
.manufacture_id = SANYO_ID,
.model_id = SANYO_LE25FU206A,
.total_size = 256,
.page_size = 256,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT, /* #WP pin write-protects SRWP bit. */
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2300, 3600},
},
{
.vendor = "Sanyo",
.name = "LE25FU406B",
.bustype = BUS_SPI,
.manufacture_id = SANYO_ID,
.model_id = SANYO_LE25FU406B,
.total_size = 512,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RES2,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT, /* #WP pin write-protects SRWP bit. */
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2300, 3600},
},
{
.vendor = "Sanyo",
.name = "LE25FU406C/LE25U40CMC",
.bustype = BUS_SPI,
.manufacture_id = SANYO_ID,
.model_id = SANYO_LE25FU406C,
.total_size = 512,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP2_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* Fast read (0x0B), dual read (0x3B) and dual I/O (0xBB) supported */
.voltage = {2300, 3600},
},
{
.vendor = "Sanyo",
.name = "LE25FW106",
.bustype = BUS_SPI,
.manufacture_id = SANYO_ID,
.model_id = SANYO_LE25FW106,
.total_size = 128,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RES2,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {2 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {32 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD, /* FIXME: Add ERSER error flag. */
.unlock = SPI_DISABLE_BLOCKPROTECT_BP1_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "Sanyo",
.name = "LE25FW203A",
.bustype = BUS_SPI,
.manufacture_id = SANYO_ID,
.model_id = SANYO_LE25FW203A,
.total_size = 256,
.page_size = 256,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {256, 1024} },
.block_erase = SPI_BLOCK_ERASE_DB,
}, {
.eraseblocks = { {64 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_DEFAULT_WELWIP,
.unlock = NO_BLOCKPROTECT_FUNC, /* #WP pin write-protects lower 64kB. */
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "Sanyo",
.name = "LE25FW403A",
.bustype = BUS_SPI,
.manufacture_id = SANYO_ID,
.model_id = SANYO_LE25FW403A,
.total_size = 512,
.page_size = 256,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {256, 2 * 1024} },
.block_erase = SPI_BLOCK_ERASE_DB,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_DEFAULT_WELWIP,
.unlock = NO_BLOCKPROTECT_FUNC, /* #WP pin write-protects lower 64kB. */
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "Sanyo",
.name = "LE25FW406A",
.bustype = BUS_SPI,
.manufacture_id = SANYO_ID,
.model_id = SANYO_LE25FW406A,
.total_size = 512,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RES2,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "Sanyo",
.name = "LE25FW418A",
.bustype = BUS_SPI,
.manufacture_id = SANYO_ID,
.model_id = SANYO_LE25FW418A,
.total_size = 512,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RES2,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT, /* #WP pin write-protects SRWP bit. */
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* some quad-read supported ("HD_READ mode") */
.voltage = {2700, 3600},
},
{
.vendor = "Sanyo",
.name = "LE25FW806",
.bustype = BUS_SPI,
.manufacture_id = SANYO_ID,
.model_id = SANYO_LE25FW806,
.total_size = 1024,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RES2,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {4 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT, /* #WP pin write-protects SRWP bit. */
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "Sanyo",
.name = "LE25FW808",
.bustype = BUS_SPI,
.manufacture_id = SANYO_ID,
.model_id = SANYO_LE25FW808,
.total_size = 1024,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RES2,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {8 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_D7,
}, {
.eraseblocks = { {64 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT, /* #WP pin write-protects SRWP bit. */
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ, /* some quad-read supported ("HD_READ mode") */
.voltage = {2700, 3600},
},

82
flashchips/sharp.c Normal file
View File

@ -0,0 +1,82 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "Sharp",
.name = "LH28F008BJT-BTLZ1",
.bustype = BUS_PARALLEL,
.manufacture_id = SHARP_ID,
.model_id = SHARP_LH28F008BJ__PB,
.total_size = 1024,
.page_size = 64 * 1024,
.tested = TEST_OK_PREW,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{8 * 1024, 8},
{64 * 1024, 15}
},
.block_erase = ERASE_BLOCK_82802AB,
}, {
.eraseblocks = { {1024 * 1024, 1} },
.block_erase = ERASE_SECTOR_49LFXXXC,
}
},
.unlock = UNLOCK_LH28F008BJT,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},
{
.vendor = "Sharp",
.name = "LHF00L04",
.bustype = BUS_FWH, /* A/A Mux */
.manufacture_id = SHARP_ID,
.model_id = SHARP_LHF00L04,
.total_size = 1024,
.page_size = 64 * 1024,
.feature_bits = FEATURE_EITHER_RESET | FEATURE_REGISTERMAP,
.tested = TEST_UNTESTED,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 15},
{8 * 1024, 8}
},
.block_erase = ERASE_BLOCK_82802AB,
}, {
.eraseblocks = {
{1024 * 1024, 1}
},
.block_erase = NO_BLOCK_ERASE_FUNC, /* 30 D0, only in A/A mux mode */
},
},
.unlock = UNLOCK_REGSPACE2_UNIFORM_64K,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600},
},

1030
flashchips/spansion.c Normal file
View File

File diff suppressed because it is too large Load Diff

1712
flashchips/sst.c Normal file
View File

File diff suppressed because it is too large Load Diff

581
flashchips/st.c Normal file
View File

@ -0,0 +1,581 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "ST",
.name = "M29F002B",
.bustype = BUS_PARALLEL,
.manufacture_id = ST_ID,
.model_id = ST_M29F002B,
.total_size = 256,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_AAA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{32 * 1024, 1},
{64 * 1024, 3},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4750, 5250}, /* 4.75-5.25V for type -X, others 4.5-5.5V */
},
{
.vendor = "ST",
.name = "M29F002T/NT",
.bustype = BUS_PARALLEL,
.manufacture_id = ST_ID,
.model_id = ST_M29F002T,
.total_size = 256,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_AAA | FEATURE_EITHER_RESET,
.tested = TEST_OK_PREW,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 3},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4750, 5250}, /* 4.75-5.25V for type -X, others 4.5-5.5V */
},
{
.vendor = "ST",
.name = "M29F040B",
.bustype = BUS_PARALLEL,
.manufacture_id = ST_ID,
.model_id = ST_M29F040B,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* datasheet specifies no timing */
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 8} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
/* FIXME: this has WORD/BYTE sequences; 2AA for word, 555 for byte */
.vendor = "ST",
.name = "M29F400BB",
.bustype = BUS_PARALLEL,
.manufacture_id = ST_ID,
.model_id = ST_M29F400BB,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_SHIFTED | FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = 10, // FIXME: check datasheet. Using the 10 us from probe_m29f400bt
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{32 * 1024, 1},
{64 * 1024, 7},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
/* FIXME: this has WORD/BYTE sequences; 2AA for word, 555 for byte */
.vendor = "ST",
.name = "M29F400BT",
.bustype = BUS_PARALLEL,
.manufacture_id = ST_ID,
.model_id = ST_M29F400BT,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_SHIFTED | FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = 10, // FIXME: check datasheet. Using the 10 us from probe_m29f400bt
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 7},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "ST",
.name = "M29W010B",
.bustype = BUS_PARALLEL,
.manufacture_id = ST_ID,
.model_id = ST_M29W010B,
.total_size = 128,
.page_size = 16 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {16 * 1024, 8} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},
{
.vendor = "ST",
.name = "M29W040B",
.bustype = BUS_PARALLEL,
.manufacture_id = ST_ID,
.model_id = ST_M29W040B,
.total_size = 512,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 8} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},
{
.vendor = "ST",
.name = "M29W512B",
.bustype = BUS_PARALLEL,
.manufacture_id = ST_ID,
.model_id = ST_M29W512B,
.total_size = 64,
.page_size = 64 * 1024,
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_OK_PREW,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
}
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {2700, 3600},
},
{
.vendor = "ST",
.name = "M50FLW040A",
.bustype = BUS_FWH | BUS_LPC, /* A/A Mux */
.manufacture_id = ST_ID,
.model_id = ST_M50FLW040A,
.total_size = 512,
.page_size = 0,
.feature_bits = FEATURE_REGISTERMAP,
.tested = TEST_UNTESTED,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_FIXME,
.block_erasers =
{
{
.eraseblocks = {
{4 * 1024, 16}, /* sector */
{64 * 1024, 5}, /* block */
{4 * 1024, 16}, /* sector */
{4 * 1024, 16}, /* sector */
},
.block_erase = STM50_SECTOR_ERASE,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = ERASE_BLOCK_82802AB,
}
},
.unlock = UNLOCK_REGSPACE2_UNIFORM_64K,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* Also has 12V fast program & erase */
},
{
.vendor = "ST",
.name = "M50FLW040B",
.bustype = BUS_FWH | BUS_LPC, /* A/A Mux */
.manufacture_id = ST_ID,
.model_id = ST_M50FLW040B,
.total_size = 512,
.page_size = 0,
.feature_bits = FEATURE_REGISTERMAP,
.tested = TEST_UNTESTED,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_FIXME,
.block_erasers =
{
{
.eraseblocks = {
{4 * 1024, 16}, /* sector */
{4 * 1024, 16}, /* sector */
{64 * 1024, 5}, /* block */
{4 * 1024, 16}, /* sector */
},
.block_erase = STM50_SECTOR_ERASE,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = ERASE_BLOCK_82802AB,
}
},
.unlock = UNLOCK_REGSPACE2_UNIFORM_64K,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* Also has 12V fast program & erase */
},
{
.vendor = "ST",
.name = "M50FLW080A",
.bustype = BUS_FWH | BUS_LPC, /* A/A Mux */
.manufacture_id = ST_ID,
.model_id = ST_M50FLW080A,
.total_size = 1024,
.page_size = 0,
.feature_bits = FEATURE_REGISTERMAP,
.tested = TEST_OK_PR,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_FIXME,
.block_erasers =
{
{
.eraseblocks = {
{4 * 1024, 16}, /* sector */
{64 * 1024, 13}, /* block */
{4 * 1024, 16}, /* sector */
{4 * 1024, 16}, /* sector */
},
.block_erase = STM50_SECTOR_ERASE,
}, {
.eraseblocks = { {64 * 1024, 16} },
.block_erase = ERASE_BLOCK_82802AB,
}
},
.printlock = PRINTLOCK_REGSPACE2_BLOCK_ERASER_0,
.unlock = UNLOCK_REGSPACE2_BLOCK_ERASER_0,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* Also has 12V fast program & erase */
},
{
.vendor = "ST",
.name = "M50FLW080B",
.bustype = BUS_FWH | BUS_LPC, /* A/A Mux */
.manufacture_id = ST_ID,
.model_id = ST_M50FLW080B,
.total_size = 1024,
.page_size = 0,
.feature_bits = FEATURE_REGISTERMAP,
.tested = TEST_UNTESTED,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_FIXME,
.block_erasers =
{
{
.eraseblocks = {
{4 * 1024, 16}, /* sector */
{4 * 1024, 16}, /* sector */
{64 * 1024, 13}, /* block */
{4 * 1024, 16}, /* sector */
},
.block_erase = STM50_SECTOR_ERASE,
}, {
.eraseblocks = { {64 * 1024, 16} },
.block_erase = ERASE_BLOCK_82802AB,
}
},
.printlock = PRINTLOCK_REGSPACE2_BLOCK_ERASER_0,
.unlock = UNLOCK_REGSPACE2_BLOCK_ERASER_0,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* Also has 12V fast program & erase */
},
{
.vendor = "ST",
.name = "M50FW002",
.bustype = BUS_FWH, /* A/A Mux */
.manufacture_id = ST_ID,
.model_id = ST_M50FW002,
.total_size = 256,
.page_size = 0,
.feature_bits = FEATURE_REGISTERMAP,
.tested = TEST_OK_PR,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_IGNORED, /* routine doesn't use probe_timing (82802ab.c) */
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 3},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = ERASE_BLOCK_82802AB,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = NO_BLOCK_ERASE_FUNC, /* Only in A/A mux mode */
}
},
.printlock = PRINTLOCK_REGSPACE2_BLOCK_ERASER_0,
.unlock = UNLOCK_REGSPACE2_BLOCK_ERASER_0,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* Also has 12V fast program & erase */
},
{
.vendor = "ST",
.name = "M50FW016",
.bustype = BUS_FWH, /* A/A Mux */
.manufacture_id = ST_ID,
.model_id = ST_M50FW016,
.total_size = 2048,
.page_size = 0,
.feature_bits = FEATURE_REGISTERMAP,
.tested = TEST_UNTESTED,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_IGNORED, /* routine doesn't use probe_timing (82802ab.c) */
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 32} },
.block_erase = ERASE_BLOCK_82802AB,
}
},
.unlock = UNLOCK_REGSPACE2_UNIFORM_64K,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* Also has 12V fast program & erase */
},
{
.vendor = "ST",
.name = "M50FW040",
.bustype = BUS_FWH, /* A/A Mux */
.manufacture_id = ST_ID,
.model_id = ST_M50FW040,
.total_size = 512,
.page_size = 0,
.feature_bits = FEATURE_REGISTERMAP,
.tested = TEST_OK_PR,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_IGNORED, /* routine doesn't use probe_timing (82802ab.c) */
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 8} },
.block_erase = ERASE_BLOCK_82802AB,
}
},
.unlock = UNLOCK_REGSPACE2_UNIFORM_64K,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* Also has 12V fast program & erase */
},
{
.vendor = "ST",
.name = "M50FW080",
.bustype = BUS_FWH, /* A/A Mux */
.manufacture_id = ST_ID,
.model_id = ST_M50FW080,
.total_size = 1024,
.page_size = 0,
.feature_bits = FEATURE_REGISTERMAP,
.tested = TEST_OK_PR,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_IGNORED, /* routine doesn't use probe_timing (82802ab.c) */
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 16} },
.block_erase = ERASE_BLOCK_82802AB,
}
},
.unlock = UNLOCK_REGSPACE2_UNIFORM_64K,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* Also has 12V fast program & erase */
},
{
.vendor = "ST",
.name = "M50LPW080",
.bustype = BUS_LPC, /* A/A Mux */
.manufacture_id = ST_ID,
.model_id = ST_M50LPW080,
.total_size = 1024,
.page_size = 0,
.feature_bits = FEATURE_REGISTERMAP,
.tested = TEST_UNTESTED,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {64 * 1024, 16} },
.block_erase = ERASE_BLOCK_82802AB,
}
},
.unlock = UNLOCK_REGSPACE2_UNIFORM_64K,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* Also has 12V fast program & erase */
},
{
.vendor = "ST",
.name = "M50LPW116",
.bustype = BUS_LPC, /* A/A Mux */
.manufacture_id = ST_ID,
.model_id = ST_M50LPW116,
.total_size = 2048,
.page_size = 0,
.feature_bits = FEATURE_REGISTERMAP,
.tested = TEST_UNTESTED,
.probe = PROBE_AT82802AB,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{4 * 1024, 16},
{64 * 1024, 30},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = ERASE_BLOCK_82802AB,
}
},
.printlock = PRINTLOCK_REGSPACE2_BLOCK_ERASER_0,
.unlock = UNLOCK_REGSPACE2_BLOCK_ERASER_0,
.write = WRITE_82802AB,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600}, /* Also has 12V fast program & erase */
},
{
.vendor = "ST",
.name = "M95M02",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = ST_M95M02,
.total_size = 256,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN | FEATURE_NO_ERASE | FEATURE_ERASED_ZERO,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_ST95,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_EMULATION,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP1_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2500, 5500},
},

233
flashchips/syncmos_mosel_vitelic.c Normal file
View File

@ -0,0 +1,233 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "SyncMOS/MoselVitelic",
.name = "{F,S,V}29C51001B",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = SM_MVC_29C51001B,
.total_size = 128,
.page_size = 512,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {512, 256} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "SyncMOS/MoselVitelic",
.name = "{F,S,V}29C51001T",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = SM_MVC_29C51001T,
.total_size = 128,
.page_size = 512,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {512, 256} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {128 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "SyncMOS/MoselVitelic",
.name = "{F,S,V}29C51002B",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = SM_MVC_29C51002B,
.total_size = 256,
.page_size = 512,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {512, 512} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
},
{
.vendor = "SyncMOS/MoselVitelic",
.name = "{F,S,V}29C51002T",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = SM_MVC_29C51002T,
.total_size = 256,
.page_size = 512,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_OK_PREW,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {512, 512} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
},
{
.vendor = "SyncMOS/MoselVitelic",
.name = "{F,S,V}29C51004B",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = SM_MVC_29C51004B,
.total_size = 512,
.page_size = 1024,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {1024, 512} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "SyncMOS/MoselVitelic",
.name = "{F,S,V}29C51004T",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = SM_MVC_29C51004T,
.total_size = 512,
.page_size = 1024,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {1024, 512} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "SyncMOS/MoselVitelic",
.name = "{S,V}29C31004B",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = SM_MVC_29C31004B,
.total_size = 512,
.page_size = 1024,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {1024, 512} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600},
},
{
.vendor = "SyncMOS/MoselVitelic",
.name = "{S,V}29C31004T",
.bustype = BUS_PARALLEL,
.manufacture_id = SYNCMOS_MVC_ID,
.model_id = SM_MVC_29C31004T,
.total_size = 512,
.page_size = 1024,
.feature_bits = FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = { {1024, 512} },
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {3000, 3600},
},

83
flashchips/ti.c Normal file
View File

@ -0,0 +1,83 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "TI",
.name = "TMS29F002RB",
.bustype = BUS_PARALLEL,
.manufacture_id = TI_OLD_ID,
.model_id = TI_TMS29F002RB,
.total_size = 256,
.page_size = 16384, /* Non-uniform sectors */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{16 * 1024, 1},
{8 * 1024, 2},
{32 * 1024, 1},
{64 * 1024, 3},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},
{
.vendor = "TI",
.name = "TMS29F002RT",
.bustype = BUS_PARALLEL,
.manufacture_id = TI_OLD_ID,
.model_id = TI_TMS29F002RT,
.total_size = 256,
.page_size = 16384, /* Non-uniform sectors */
.feature_bits = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
.tested = TEST_UNTESTED,
.probe = PROBE_JEDEC,
.probe_timing = TIMING_ZERO, /* Datasheet has no timing info specified */
.block_erasers =
{
{
.eraseblocks = {
{64 * 1024, 3},
{32 * 1024, 1},
{8 * 1024, 2},
{16 * 1024, 1},
},
.block_erase = JEDEC_SECTOR_ERASE,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = JEDEC_CHIP_BLOCK_ERASE,
},
},
.write = WRITE_JEDEC1,
.read = READ_MEMMAPPED,
.voltage = {4500, 5500},
},

2931
flashchips/winbond.c Normal file
View File

File diff suppressed because it is too large Load Diff

689
flashchips/xmc.c Normal file
View File

@ -0,0 +1,689 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "XMC",
.name = "XM25QH80B",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = ST_M45PE80,
.total_size = 1024,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {1 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP2_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "XMC",
.name = "XM25QU80B",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QU80B,
.total_size = 1024,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 256 } },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {1 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {1 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "XMC",
.name = "XM25QH16C/XM25QH16D",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QH16C,
.total_size = 2048,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "XMC",
.name = "XM25QU16C",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QU16C,
.total_size = 2048,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 32} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {2 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "XMC",
.name = "XM25QH32C/XM25QH32D",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QH32C,
.total_size = 4096,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 64} },
.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,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "XMC",
.name = "XM25QU32C",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QU32C,
.total_size = 4096,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 64} },
.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,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "XMC",
.name = "XM25QH64C/XM25QH64D",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QH64C,
.total_size = 8192,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 128} },
.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,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "XMC",
.name = "XM25QU64C/XM25LU64C",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QU64C,
.total_size = 8192,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 128} },
.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,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "XMC",
.name = "XM25QH128A",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QH128A,
.total_size = 16384,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI | FEATURE_WRSR2,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
.reg_bits =
{
.srp = {STATUS1, 7, RW},
.srl = {STATUS2, 0, RW},
.bp = {{STATUS1, 2, RW}, {STATUS1, 3, RW}, {STATUS1, 4, RW}},
.tb = {STATUS1, 5, RW},
.sec = {STATUS1, 6, RW},
.cmp = {STATUS2, 6, RW},
},
.decode_range = DECODE_RANGE_SPI25,
},
{
.vendor = "XMC",
.name = "XM25QH128C/XM25QH128D",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QH128C,
.total_size = 16384,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI | FEATURE_WRSR2,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_SRWD_SEC_TB_BP2_WELWIP,
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
.reg_bits =
{
.srp = {STATUS1, 7, RW},
.srl = {STATUS2, 0, RW},
.bp = {{STATUS1, 2, RW}, {STATUS1, 3, RW}, {STATUS1, 4, RW}},
.tb = {STATUS1, 5, RW},
.sec = {STATUS1, 6, RW},
.cmp = {STATUS2, 6, RW},
},
.decode_range = DECODE_RANGE_SPI25,
},
{
.vendor = "XMC",
.name = "XM25QU128C/XM25QU128D",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QU128C,
.total_size = 16384,
.page_size = 256,
/* supports SFDP */
/* OTP: 1024B total, 256B reserved; read 0x48; write 0x42, erase 0x44, read ID 0x4B */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN, /* TODO: improve */
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "XMC",
.name = "XM25QH256C/XM25QH256D",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QH256C,
.total_size = 32768,
.page_size = 256,
/* supports SFDP */
/* OTP: 1024B total, 256B reserved; read 0x48; write 0x42, erase 0x44, read ID 0x4B */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_ENTER_WREN |
FEATURE_4BA_EAR_C5C8 | FEATURE_4BA_READ | FEATURE_4BA_FAST_READ |
FEATURE_4BA_WRITE | FEATURE_WRSR2,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {32 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {32 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN, /* TODO: improve */
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
.reg_bits =
{
.srp = {STATUS1, 7, RW},
.srl = {STATUS2, 0, RW},
.bp = {{STATUS1, 2, RW}, {STATUS1, 3, RW}, {STATUS1, 4, RW}, {STATUS1, 5, RW}},
.tb = {STATUS1, 6, RW},
},
.decode_range = DECODE_RANGE_SPI25,
},
{
.vendor = "XMC",
.name = "XM25QU256C/XM25QU256D",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QU256C,
.total_size = 32768,
.page_size = 256,
/* supports SFDP */
/* OTP: 1024B total, 256B reserved; read 0x48; write 0x42, erase 0x44, read ID 0x4B */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_ENTER_WREN
| FEATURE_4BA_EAR_C5C8 | FEATURE_4BA_READ | FEATURE_4BA_FAST_READ
| FEATURE_4BA_WRITE,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {32 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {32 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN, /* TODO: improve */
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "XMC",
.name = "XM25RU256C",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25RU256C,
.total_size = 32768,
.page_size = 256,
/* supports SFDP */
/* OTP: 1024B total, 256B reserved; read 0x48; write 0x42, erase 0x44, read ID 0x4B */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_ENTER_WREN |
FEATURE_4BA_EAR_C5C8 | FEATURE_4BA_READ | FEATURE_4BA_FAST_READ |
FEATURE_4BA_WRITE,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 8192} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {32 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {32 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN, /* TODO: improve */
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},
{
.vendor = "XMC",
.name = "XM25QH512C/XM25QH512D",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QH512C,
.total_size = 64 * 1024,
.page_size = 256,
/* supports SFDP */
/* OTP: 1024B total, 256B reserved; read 0x48; write 0x42, erase 0x44, read ID 0x4B */
/* FOUR_BYTE_ADDR: supports 4-bytes addressing mode */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_ENTER_WREN
| FEATURE_4BA_EAR_C5C8 | FEATURE_4BA_READ | FEATURE_4BA_FAST_READ,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 16384} },
.block_erase = SPI_BLOCK_ERASE_21,
}, {
.eraseblocks = { {4 * 1024, 16384} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_DC,
}, {
.eraseblocks = { {64 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {64 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {64 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN, /* TODO: improve */
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "XMC",
.name = "XM25QU512C/XM25QU512D",
.bustype = BUS_SPI,
.manufacture_id = ST_ID,
.model_id = XMC_XM25QU512C,
.total_size = 64 * 1024,
.page_size = 256,
/* supports SFDP */
/* OTP: 1024B total, 256B reserved; read 0x48; write 0x42, erase 0x44, read ID 0x4B */
/* FOUR_BYTE_ADDR: supports 4-bytes addressing mode */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_4BA_ENTER_WREN
| FEATURE_4BA_EAR_C5C8 | FEATURE_4BA_READ | FEATURE_4BA_FAST_READ,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 16384} },
.block_erase = SPI_BLOCK_ERASE_21,
}, {
.eraseblocks = { {4 * 1024, 16384} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_DC,
}, {
.eraseblocks = { {64 * 1024, 1024} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {64 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {64 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN, /* TODO: improve */
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},

134
flashchips/xtx.c Normal file
View File

@ -0,0 +1,134 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "XTX Technology Limited",
.name = "XT25F02E",
.bustype = BUS_SPI,
.manufacture_id = XTX_ID,
.model_id = XTX_XT25F02E,
.total_size = 256,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {64 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP1_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP1_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "XTX Technology Limited",
.name = "XT25F64B",
.bustype = BUS_SPI,
.manufacture_id = XTX_ID,
.model_id = XTX_XT25F64B,
.total_size = 8 * 1024,
.page_size = 256,
/* Supports SFDP */
/* OTP: 4 x 256 bytes */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 2048} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 128} },
.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,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP4_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP4_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "XTX Technology Limited",
.name = "XT25F128B",
.bustype = BUS_SPI,
.manufacture_id = XTX_ID,
.model_id = XTX_XT25F128B,
.total_size = 16 * 1024,
.page_size = 256,
/* Supports SFDP */
/* OTP: 4 x 256 bytes */
.feature_bits = FEATURE_WRSR_WREN | FEATURE_OTP | FEATURE_QPI,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_BP4_SRWD,
.unlock = SPI_DISABLE_BLOCKPROTECT_BP4_SRWD,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},

133
flashchips/zetta.c Normal file
View File

@ -0,0 +1,133 @@
/*
* This file is part of the flashrom project.
*
* Copyright (C) 2000 Silicon Integrated System Corporation
* Copyright (C) 2004 Tyan Corp
* Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
* Copyright (C) 2006-2009 Carl-Daniel Hailfinger
* Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
*
* 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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.
*/
{
.vendor = "Zetta Device",
.name = "ZD25D20",
.bustype = BUS_SPI,
.manufacture_id = ZETTA_ID,
.model_id = ZETTA_ZD25D20,
.total_size = 256,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 64} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 4} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {256 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN, /* TODO: improve */
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "Zetta Device",
.name = "ZD25D40",
.bustype = BUS_SPI,
.manufacture_id = ZETTA_ID,
.model_id = ZETTA_ZD25D40,
.total_size = 512,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_UNTESTED,
.probe = PROBE_SPI_RDID,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 128} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 16} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 8} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {512 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN, /* TODO: improve */
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {2700, 3600},
},
{
.vendor = "Zetta Device",
.name = "ZD25LQ128",
.bustype = BUS_SPI,
.manufacture_id = ZETTA_ID,
.model_id = ZETTA_ZD25LQ128_REMS,
.total_size = 16384,
.page_size = 256,
.feature_bits = FEATURE_WRSR_WREN,
.tested = TEST_OK_PREW,
.probe = PROBE_SPI_REMS,
.probe_timing = TIMING_ZERO,
.block_erasers =
{
{
.eraseblocks = { {4 * 1024, 4096} },
.block_erase = SPI_BLOCK_ERASE_20,
}, {
.eraseblocks = { {32 * 1024, 512} },
.block_erase = SPI_BLOCK_ERASE_52,
}, {
.eraseblocks = { {64 * 1024, 256} },
.block_erase = SPI_BLOCK_ERASE_D8,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_60,
}, {
.eraseblocks = { {16 * 1024 * 1024, 1} },
.block_erase = SPI_BLOCK_ERASE_C7,
}
},
.printlock = SPI_PRETTYPRINT_STATUS_REGISTER_PLAIN, /* TODO: improve */
.unlock = SPI_DISABLE_BLOCKPROTECT,
.write = SPI_CHIP_WRITE256,
.read = SPI_CHIP_READ,
.voltage = {1650, 1950},
},