flashchips.c

   1 /*
   2  * This file is part of the flashrom project.
   3  *
   4  * Copyright (C) 2000 Silicon Integrated System Corporation
   5  * Copyright (C) 2004 Tyan Corp
   6  * Copyright (C) 2005-2008 coresystems GmbH <stepan@openbios.org>
   7  * Copyright (C) 2006-2009 Carl-Daniel Hailfinger
   8  * Copyright (C) 2009 Sean Nelson <audiohacked@gmail.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  23  */
  24
  25 #include "flash.h"
  26 #include "flashchips.h"
  27 #include "chipdrivers.h"
  28
  29 /**
  30  * List of supported flash chips.
  31  *
  32  * Please keep the list sorted by vendor name and chip name, so that
  33  * the output of 'flashrom -L' is alphabetically sorted.
  34  */
  35 const struct flashchip flashchips[] = {
  36
  37         /*
  38          * .vendor              = Vendor name
  39          * .name                = Chip name
  40          * .bustype             = Supported flash bus types (Parallel, LPC...)
  41          * .manufacture_id      = Manufacturer chip ID
  42          * .model_id            = Model chip ID
  43          * .total_size          = Total size in (binary) kbytes
  44          * .page_size           = Page or eraseblock(?) size in bytes
  45          * .tested              = Test status
  46          * .probe               = Probe function
  47          * .probe_timing        = Probe function delay
  48          * .block_erasers[]     = Array of erase layouts and erase functions
  49          * {
  50          *      .eraseblocks[]  = Array of { blocksize, blockcount }
  51          *      .block_erase    = Block erase function
  52          * }
  53          * .printlock           = Chip lock status function
  54          * .unlock              = Chip unlock function
  55          * .write               = Chip write function
  56          * .read                = Chip read function
  57          * .voltage             = Voltage range in millivolt
  58          */
  59
  60         {
  61                 .vendor         = "AMD",
  62                 .name           = "Am29F010A/B",
  63                 .bustype        = BUS_PARALLEL,
  64                 .manufacture_id = AMD_ID,
  65                 .model_id       = AMD_AM29F010B,        /* Same as Am29F010A */
  66                 .total_size     = 128,
  67                 .page_size      = 16 * 1024,
  68                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
  69                 .tested         = TEST_OK_PRE,
  70                 .probe          = probe_jedec,
  71                 .probe_timing   = TIMING_ZERO,
  72                 .block_erasers  =
  73                 {
  74                         {
  75                                 .eraseblocks = { {16 * 1024, 8} },
  76                                 .block_erase = erase_sector_jedec,
  77                         }, {
  78                                 .eraseblocks = { {128 * 1024, 1} },
  79                                 .block_erase = erase_chip_block_jedec,
  80                         },
  81                 },
  82                 .write          = write_jedec_1,
  83                 .read           = read_memmapped,
  84                 .voltage        = {4500, 5500},
  85         },
  86
  87         {
  88                 .vendor         = "AMD",
  89                 .name           = "Am29F002(N)BB",
  90                 .bustype        = BUS_PARALLEL,
  91                 .manufacture_id = AMD_ID,
  92                 .model_id       = AMD_AM29F002BB,
  93                 .total_size     = 256,
  94                 .page_size      = 256,
  95                 .feature_bits   = FEATURE_SHORT_RESET | FEATURE_ADDR_2AA,
  96                 .tested         = TEST_UNTESTED,
  97                 .probe          = probe_jedec,
  98                 .probe_timing   = TIMING_ZERO,
  99                 .block_erasers  =
 100                 {
 101                         {
 102                                 .eraseblocks = {
 103                                         {16 * 1024, 1},
 104                                         {8 * 1024, 2},
 105                                         {32 * 1024, 1},
 106                                         {64 * 1024, 3},
 107                                 },
 108                                 .block_erase = erase_sector_jedec,
 109                         }, {
 110                                 .eraseblocks = { {256 * 1024, 1} },
 111                                 .block_erase = erase_chip_block_jedec,
 112                         },
 113                 },
 114                 .write          = write_jedec_1,
 115                 .read           = read_memmapped,
 116                 .voltage        = {4750, 5250}, /* 4.75-5.25V for type -55, others 4.5-5.5V */
 117         },
 118
 119         {
 120                 .vendor         = "AMD",
 121                 .name           = "Am29F002(N)BT",
 122                 .bustype        = BUS_PARALLEL,
 123                 .manufacture_id = AMD_ID,
 124                 .model_id       = AMD_AM29F002BT,
 125                 .total_size     = 256,
 126                 .page_size      = 256,
 127                 .feature_bits   = FEATURE_EITHER_RESET | FEATURE_ADDR_2AA,
 128                 .tested         = TEST_UNTESTED,
 129                 .probe          = probe_jedec,
 130                 .probe_timing   = TIMING_ZERO,
 131                 .block_erasers  =
 132                 {
 133                         {
 134                                 .eraseblocks = {
 135                                         {64 * 1024, 3},
 136                                         {32 * 1024, 1},
 137                                         {8 * 1024, 2},
 138                                         {16 * 1024, 1},
 139                                 },
 140                                 .block_erase = erase_sector_jedec,
 141                         }, {
 142                                 .eraseblocks = { {256 * 1024, 1} },
 143                                 .block_erase = erase_chip_block_jedec,
 144                         },
 145                 },
 146                 .write          = write_jedec_1,
 147                 .read           = read_memmapped,
 148                 .voltage        = {4750, 5250}, /* 4.75-5.25V for type -55, others 4.5-5.5V */
 149         },
 150
 151         {
 152                 .vendor         = "AMD",
 153                 .name           = "Am29F016D",
 154                 .bustype        = BUS_PARALLEL,
 155                 .manufacture_id = AMD_ID,
 156                 .model_id       = AMD_AM29F016D,
 157                 .total_size     = 2 * 1024,
 158                 .page_size      = 64 * 1024,
 159                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
 160                 .tested         = TEST_UNTESTED,
 161                 .probe          = probe_jedec,
 162                 .probe_timing   = TIMING_ZERO,
 163                 .block_erasers  =
 164                 {
 165                         {
 166                                 .eraseblocks = { {64 * 1024, 32} },
 167                                 .block_erase = erase_sector_jedec,
 168                         }, {
 169                                 .eraseblocks = { {2048 * 1024, 1} },
 170                                 .block_erase = erase_chip_block_jedec,
 171                         },
 172                 },
 173                 .write          = write_jedec_1,
 174                 .read           = read_memmapped,
 175                 .voltage        = {4500, 5500},
 176         },
 177
 178         {
 179                 .vendor         = "AMD",
 180                 .name           = "Am29F040B",
 181                 .bustype        = BUS_PARALLEL,
 182                 .manufacture_id = AMD_ID,
 183                 .model_id       = AMD_AM29F040B,
 184                 .total_size     = 512,
 185                 .page_size      = 64 * 1024,
 186                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
 187                 .tested         = TEST_UNTESTED,
 188                 .probe          = probe_jedec,
 189                 .probe_timing   = TIMING_ZERO,
 190                 .block_erasers  =
 191                 {
 192                         {
 193                                 .eraseblocks = { {64 * 1024, 8} },
 194                                 .block_erase = erase_sector_jedec,
 195                         }, {
 196                                 .eraseblocks = { {512 * 1024, 1} },
 197                                 .block_erase = erase_chip_block_jedec,
 198                         },
 199                 },
 200                 .write          = write_jedec_1,
 201                 .read           = read_memmapped,
 202                 .voltage        = {4500, 5500},
 203         },
 204
 205         {
 206                 .vendor         = "AMD",
 207                 .name           = "Am29F080B",
 208                 .bustype        = BUS_PARALLEL,
 209                 .manufacture_id = AMD_ID,
 210                 .model_id       = AMD_AM29F080B,
 211                 .total_size     = 1024,
 212                 .page_size      = 64 * 1024,
 213                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
 214                 .tested         = TEST_UNTESTED,
 215                 .probe          = probe_jedec,
 216                 .probe_timing   = TIMING_ZERO,
 217                 .block_erasers  =
 218                 {
 219                         {
 220                                 .eraseblocks = { {64 * 1024, 16} },
 221                                 .block_erase = erase_sector_jedec,
 222                         }, {
 223                                 .eraseblocks = { {1024 * 1024, 1} },
 224                                 .block_erase = erase_chip_block_jedec,
 225                         },
 226                 },
 227                 .write          = write_jedec_1,
 228                 .read           = read_memmapped,
 229                 .voltage        = {4500, 5500},
 230         },
 231
 232         {
 233                 .vendor         = "AMD",
 234                 .name           = "Am29LV001BB",
 235                 .bustype        = BUS_PARALLEL,
 236                 .manufacture_id = AMD_ID,
 237                 .model_id       = AMD_AM29LV001BB,
 238                 .total_size     = 128,
 239                 .page_size      = 64 * 1024, /* unused */
 240                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
 241                 .tested         = TEST_OK_PREW,
 242                 .probe          = probe_jedec,
 243                 .probe_timing   = TIMING_ZERO,
 244                 .block_erasers  =
 245                 {
 246                         {
 247                                 .eraseblocks = {
 248                                         {8 * 1024, 1},
 249                                         {4 * 1024, 2},
 250                                         {16 * 1024, 7},
 251                                 },
 252                                 .block_erase = erase_sector_jedec,
 253                         }, {
 254                                 .eraseblocks = { {128 * 1024, 1} },
 255                                 .block_erase = erase_chip_block_jedec,
 256                         },
 257                 },
 258                 .write          = write_jedec_1,
 259                 .read           = read_memmapped,
 260                 .voltage        = {3000, 3600}, /* 3.0-3.6V for type -45R, others 2.7-3.6V */
 261         },
 262
 263         {
 264                 .vendor         = "AMD",
 265                 .name           = "Am29LV001BT",
 266                 .bustype        = BUS_PARALLEL,
 267                 .manufacture_id = AMD_ID,
 268                 .model_id       = AMD_AM29LV001BT,
 269                 .total_size     = 128,
 270                 .page_size      = 64 * 1024, /* unused */
 271                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
 272                 .tested         = TEST_UNTESTED,
 273                 .probe          = probe_jedec,
 274                 .probe_timing   = TIMING_ZERO,
 275                 .block_erasers  =
 276                 {
 277                         {
 278                                 .eraseblocks = {
 279                                         {16 * 1024, 7},
 280                                         {4 * 1024, 2},
 281                                         {8 * 1024, 1},
 282                                 },
 283                                 .block_erase = erase_sector_jedec,
 284                         }, {
 285                                 .eraseblocks = { {128 * 1024, 1} },
 286                                 .block_erase = erase_chip_block_jedec,
 287                         },
 288                 },
 289                 .write          = write_jedec_1,
 290                 .read           = read_memmapped,
 291                 .voltage        = {3000, 3600}, /* 3.0-3.6V for type -45R, others 2.7-3.6V */
 292         },
 293
 294         {
 295                 .vendor         = "AMD",
 296                 .name           = "Am29LV002BB",
 297                 .bustype        = BUS_PARALLEL,
 298                 .manufacture_id = AMD_ID,
 299                 .model_id       = AMD_AM29LV002BB,
 300                 .total_size     = 256,
 301                 .page_size      = 64 * 1024, /* unused */
 302                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
 303                 .tested         = TEST_UNTESTED,
 304                 .probe          = probe_jedec,
 305                 .probe_timing   = TIMING_ZERO,
 306                 .block_erasers  =
 307                 {
 308                         {
 309                                 .eraseblocks = {
 310                                         {16 * 1024, 1},
 311                                         {8 * 1024, 2},
 312                                         {32 * 1024, 1},
 313                                         {64 * 1024, 3},
 314                                 },
 315                                 .block_erase = erase_sector_jedec,
 316                         }, {
 317                                 .eraseblocks = { {256 * 1024, 1} },
 318                                 .block_erase = erase_chip_block_jedec,
 319                         },
 320                 },
 321                 .write          = write_jedec_1,
 322                 .read           = read_memmapped,
 323                 .voltage        = {3000, 3600}, /* 3.0-3.6V for type -55, others 2.7-3.6V */
 324         },
 325
 326         {
 327                 .vendor         = "AMD",
 328                 .name           = "Am29LV002BT",
 329                 .bustype        = BUS_PARALLEL,
 330                 .manufacture_id = AMD_ID,
 331                 .model_id       = AMD_AM29LV002BT,
 332                 .total_size     = 256,
 333                 .page_size      = 64 * 1024, /* unused */
 334                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
 335                 .tested         = TEST_UNTESTED,
 336                 .probe          = probe_jedec,
 337                 .probe_timing   = TIMING_ZERO,
 338                 .block_erasers  =
 339                 {
 340                         {
 341                                 .eraseblocks = {
 342                                         {64 * 1024, 3},
 343                                         {32 * 1024, 1},
 344                                         {8 * 1024, 2},
 345                                         {16 * 1024, 1},
 346                                 },
 347                                 .block_erase = erase_sector_jedec,
 348                         }, {
 349                                 .eraseblocks = { {256 * 1024, 1} },
 350                                 .block_erase = erase_chip_block_jedec,
 351                         },
 352                 },
 353                 .write          = write_jedec_1,
 354                 .read           = read_memmapped,
 355                 .voltage        = {3000, 3600}, /* 3.0-3.6V for type -55, others 2.7-3.6V */
 356         },
 357
 358         {
 359                 .vendor         = "AMD",
 360                 .name           = "Am29LV004BB",
 361                 .bustype        = BUS_PARALLEL,
 362                 .manufacture_id = AMD_ID,
 363                 .model_id       = AMD_AM29LV004BB,
 364                 .total_size     = 512,
 365                 .page_size      = 64 * 1024, /* unused */
 366                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
 367                 .tested         = TEST_UNTESTED,
 368                 .probe          = probe_jedec,
 369                 .probe_timing   = TIMING_ZERO,
 370                 .block_erasers  =
 371                 {
 372                         {
 373                                 .eraseblocks = {
 374                                         {16 * 1024, 1},
 375                                         {8 * 1024, 2},
 376                                         {32 * 1024, 1},
 377                                         {64 * 1024, 7},
 378                                 },
 379                                 .block_erase = erase_sector_jedec,
 380                         }, {
 381                                 .eraseblocks = { {512 * 1024, 1} },
 382                                 .block_erase = erase_chip_block_jedec,
 383                         },
 384                 },
 385                 .write          = write_jedec_1,
 386                 .read           = read_memmapped,
 387                 .voltage        = {2700, 3600},
 388         },
 389
 390         {
 391                 .vendor         = "AMD",
 392                 .name           = "Am29LV004BT",
 393                 .bustype        = BUS_PARALLEL,
 394                 .manufacture_id = AMD_ID,
 395                 .model_id       = AMD_AM29LV004BT,
 396                 .total_size     = 512,
 397                 .page_size      = 64 * 1024, /* unused */
 398                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
 399                 .tested         = TEST_UNTESTED,
 400                 .probe          = probe_jedec,
 401                 .probe_timing   = TIMING_ZERO,
 402                 .block_erasers  =
 403                 {
 404                         {
 405                                 .eraseblocks = {
 406                                         {64 * 1024, 7},
 407                                         {32 * 1024, 1},
 408                                         {8 * 1024, 2},
 409                                         {16 * 1024, 1},
 410                                 },
 411                                 .block_erase = erase_sector_jedec,
 412                         }, {
 413                                 .eraseblocks = { {512 * 1024, 1} },
 414                                 .block_erase = erase_chip_block_jedec,
 415                         },
 416                 },
 417                 .write          = write_jedec_1,
 418                 .read           = read_memmapped,
 419                 .voltage        = {2700, 3600},
 420         },
 421
 422         {
 423                 .vendor         = "AMD",
 424                 .name           = "Am29LV008BB",
 425                 .bustype        = BUS_PARALLEL,
 426                 .manufacture_id = AMD_ID,
 427                 .model_id       = AMD_AM29LV008BB,
 428                 .total_size     = 1024,
 429                 .page_size      = 64 * 1024, /* unused */
 430                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
 431                 .tested         = TEST_OK_PREW,
 432                 .probe          = probe_jedec,
 433                 .probe_timing   = TIMING_ZERO,
 434                 .block_erasers  =
 435                 {
 436                         {
 437                                 .eraseblocks = {
 438                                         {16 * 1024, 1},
 439                                         {8 * 1024, 2},
 440                                         {32 * 1024, 1},
 441                                         {64 * 1024, 15},
 442                                 },
 443                                 .block_erase = erase_sector_jedec,
 444                         }, {
 445                                 .eraseblocks = { {1024 * 1024, 1} },
 446                                 .block_erase = erase_chip_block_jedec,
 447                         },
 448                 },
 449                 .write          = write_jedec_1,
 450                 .read           = read_memmapped,
 451                 .voltage        = {3000, 3600} /* 3.0-3.6V for type -70R, others 2.7-3.6V */
 452         },
 453
 454         {
 455                 .vendor         = "AMD",
 456                 .name           = "Am29LV008BT",
 457                 .bustype        = BUS_PARALLEL,
 458                 .manufacture_id = AMD_ID,
 459                 .model_id       = AMD_AM29LV008BT,
 460                 .total_size     = 1024,
 461                 .page_size      = 64 * 1024, /* unused */
 462                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
 463                 .tested         = TEST_UNTESTED,
 464                 .probe          = probe_jedec,
 465                 .probe_timing   = TIMING_ZERO,
 466                 .block_erasers  =
 467                 {
 468                         {
 469                                 .eraseblocks = {
 470                                         {64 * 1024, 15},
 471                                         {32 * 1024, 1},
 472                                         {8 * 1024, 2},
 473                                         {16 * 1024, 1},
 474                                 },
 475                                 .block_erase = erase_sector_jedec,
 476                         }, {
 477                                 .eraseblocks = { {1024 * 1024, 1} },
 478                                 .block_erase = erase_chip_block_jedec,
 479                         },
 480                 },
 481                 .write          = write_jedec_1,
 482                 .read           = read_memmapped,
 483                 .voltage        = {3000, 3600} /* 3.0-3.6V for type -70R, others 2.7-3.6V */
 484         },
 485
 486         {
 487                 .vendor         = "AMD",
 488                 .name           = "Am29LV040B",
 489                 .bustype        = BUS_PARALLEL,
 490                 .manufacture_id = AMD_ID,
 491                 .model_id       = AMD_AM29LV040B,
 492                 .total_size     = 512,
 493                 .page_size      = 64 * 1024,
 494                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
 495                 .tested         = TEST_OK_PRE,
 496                 .probe          = probe_jedec,
 497                 .probe_timing   = TIMING_ZERO,
 498                 .block_erasers  =
 499                 {
 500                         {
 501                                 .eraseblocks = { {64 * 1024, 8} },
 502                                 .block_erase = erase_sector_jedec,
 503                         }, {
 504                                 .eraseblocks = { {512 * 1024, 1} },
 505                                 .block_erase = erase_chip_block_jedec,
 506                         },
 507                 },
 508                 .write          = write_jedec_1,
 509                 .read           = read_memmapped,
 510                 .voltage        = {3000, 3600}, /* 3.0-3.6V for type -60R, others 2.7-3.6V*/
 511         },
 512
 513         {
 514                 .vendor         = "AMD",
 515                 .name           = "Am29LV081B",
 516                 .bustype        = BUS_PARALLEL,
 517                 .manufacture_id = AMD_ID,
 518                 .model_id       = AMD_AM29LV080B,
 519                 .total_size     = 1024,
 520                 .page_size      = 64 * 1024,
 521                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET, /* datasheet specifies address as don't care */
 522                 .tested         = TEST_UNTESTED,
 523                 .probe          = probe_jedec,
 524                 .probe_timing   = TIMING_ZERO,
 525                 .block_erasers  =
 526                 {
 527                         {
 528                                 .eraseblocks = { {64 * 1024, 16} },
 529                                 .block_erase = erase_sector_jedec,
 530                         }, {
 531                                 .eraseblocks = { {1024 * 1024, 1} },
 532                                 .block_erase = erase_chip_block_jedec,
 533                         },
 534                 },
 535                 .write          = write_jedec_1,
 536                 .read           = read_memmapped,
 537                 .voltage        = {3000, 3600}, /* 3.0-3.6V for type -70R, others 2.7-3.6V */
 538         },
 539
 540         {
 541                 .vendor         = "AMIC",
 542                 .name           = "A25L05PT",
 543                 .bustype        = BUS_SPI,
 544                 .manufacture_id = AMIC_ID,
 545                 .model_id       = AMIC_A25L05PT,
 546                 .total_size     = 64,
 547                 .page_size      = 256,
 548                 .feature_bits   = FEATURE_WRSR_WREN,
 549                 .tested         = TEST_UNTESTED,
 550                 .probe          = probe_spi_rdid4,
 551                 .probe_timing   = TIMING_ZERO,
 552                 .block_erasers  =
 553                 {
 554                         {
 555                                 .eraseblocks = {
 556                                         {32 * 1024, 1},
 557                                         {16 * 1024, 1},
 558                                         {8 * 1024, 1},
 559                                         {4 * 1024, 2},
 560                                 },
 561                                 .block_erase = spi_block_erase_d8,
 562                         }, {
 563                                 .eraseblocks = { {64 * 1024, 1} },
 564                                 .block_erase = spi_block_erase_c7,
 565                         }
 566                 },
 567                 .printlock      = spi_prettyprint_status_register_amic_a25l05p,
 568                 .unlock         = spi_disable_blockprotect,
 569                 .write          = spi_chip_write_256,
 570                 .read           = spi_chip_read,
 571                 .voltage        = {2700, 3600},
 572         },
 573
 574         {
 575                 .vendor         = "AMIC",
 576                 .name           = "A25L05PU",
 577                 .bustype        = BUS_SPI,
 578                 .manufacture_id = AMIC_ID,
 579                 .model_id       = AMIC_A25L05PU,
 580                 .total_size     = 64,
 581                 .page_size      = 256,
 582                 .feature_bits   = FEATURE_WRSR_WREN,
 583                 .tested         = TEST_UNTESTED,
 584                 .probe          = probe_spi_rdid4,
 585                 .probe_timing   = TIMING_ZERO,
 586                 .block_erasers  =
 587                 {
 588                         {
 589                                 .eraseblocks = {
 590                                         {4 * 1024, 2},
 591                                         {8 * 1024, 1},
 592                                         {16 * 1024, 1},
 593                                         {32 * 1024, 1},
 594                                 },
 595                                 .block_erase = spi_block_erase_d8,
 596                         }, {
 597                                 .eraseblocks = { {64 * 1024, 1} },
 598                                 .block_erase = spi_block_erase_c7,
 599                         }
 600                 },
 601                 .printlock      = spi_prettyprint_status_register_amic_a25l05p,
 602                 .unlock         = spi_disable_blockprotect,
 603                 .write          = spi_chip_write_256,
 604                 .read           = spi_chip_read,
 605                 .voltage        = {2700, 3600},
 606         },
 607
 608         {
 609                 .vendor         = "AMIC",
 610                 .name           = "A25L10PT",
 611                 .bustype        = BUS_SPI,
 612                 .manufacture_id = AMIC_ID,
 613                 .model_id       = AMIC_A25L10PT,
 614                 .total_size     = 128,
 615                 .page_size      = 256,
 616                 .feature_bits   = FEATURE_WRSR_WREN,
 617                 .tested         = TEST_UNTESTED,
 618                 .probe          = probe_spi_rdid4,
 619                 .probe_timing   = TIMING_ZERO,
 620                 .block_erasers  =
 621                 {
 622                         {
 623                                 .eraseblocks = {
 624                                         {64 * 1024, 1},
 625                                         {32 * 1024, 1},
 626                                         {16 * 1024, 1},
 627                                         {8 * 1024, 1},
 628                                         {4 * 1024, 2},
 629                                 },
 630                                 .block_erase = spi_block_erase_d8,
 631                         }, {
 632                                 .eraseblocks = { {128 * 1024, 1} },
 633                                 .block_erase = spi_block_erase_c7,
 634                         }
 635                 },
 636                 .printlock      = spi_prettyprint_status_register_amic_a25l05p,
 637                 .unlock         = spi_disable_blockprotect,
 638                 .write          = spi_chip_write_256,
 639                 .read           = spi_chip_read,
 640                 .voltage        = {2700, 3600},
 641         },
 642
 643         {
 644                 .vendor         = "AMIC",
 645                 .name           = "A25L10PU",
 646                 .bustype        = BUS_SPI,
 647                 .manufacture_id = AMIC_ID,
 648                 .model_id       = AMIC_A25L10PU,
 649                 .total_size     = 128,
 650                 .page_size      = 256,
 651                 .feature_bits   = FEATURE_WRSR_WREN,
 652                 .tested         = TEST_UNTESTED,
 653                 .probe          = probe_spi_rdid4,
 654                 .probe_timing   = TIMING_ZERO,
 655                 .block_erasers  =
 656                 {
 657                         {
 658                                 .eraseblocks = {
 659                                         {4 * 1024, 2},
 660                                         {8 * 1024, 1},
 661                                         {16 * 1024, 1},
 662                                         {32 * 1024, 1},
 663                                         {64 * 1024, 1},
 664                                 },
 665                                 .block_erase = spi_block_erase_d8,
 666                         }, {
 667                                 .eraseblocks = { {128 * 1024, 1} },
 668                                 .block_erase = spi_block_erase_c7,
 669                         }
 670                 },
 671                 .printlock      = spi_prettyprint_status_register_amic_a25l05p,
 672                 .unlock         = spi_disable_blockprotect,
 673                 .write          = spi_chip_write_256,
 674                 .read           = spi_chip_read,
 675                 .voltage        = {2700, 3600},
 676         },
 677
 678         {
 679                 .vendor         = "AMIC",
 680                 .name           = "A25L20PT",
 681                 .bustype        = BUS_SPI,
 682                 .manufacture_id = AMIC_ID,
 683                 .model_id       = AMIC_A25L20PT,
 684                 .total_size     = 256,
 685                 .page_size      = 256,
 686                 .feature_bits   = FEATURE_WRSR_WREN,
 687                 .tested         = TEST_UNTESTED,
 688                 .probe          = probe_spi_rdid4,
 689                 .probe_timing   = TIMING_ZERO,
 690                 .block_erasers  =
 691                 {
 692                         {
 693                                 .eraseblocks = {
 694                                         {64 * 1024, 3},
 695                                         {32 * 1024, 1},
 696                                         {16 * 1024, 1},
 697                                         {8 * 1024, 1},
 698                                         {4 * 1024, 2},
 699                                 },
 700                                 .block_erase = spi_block_erase_d8,
 701                         }, {
 702                                 .eraseblocks = { {256 * 1024, 1} },
 703                                 .block_erase = spi_block_erase_c7,
 704                         }
 705                 },
 706                 .printlock      = spi_prettyprint_status_register_amic_a25l05p,
 707                 .unlock         = spi_disable_blockprotect,
 708                 .write          = spi_chip_write_256,
 709                 .read           = spi_chip_read,
 710                 .voltage        = {2700, 3600},
 711         },
 712
 713         {
 714                 .vendor         = "AMIC",
 715                 .name           = "A25L20PU",
 716                 .bustype        = BUS_SPI,
 717                 .manufacture_id = AMIC_ID,
 718                 .model_id       = AMIC_A25L20PU,
 719                 .total_size     = 256,
 720                 .page_size      = 256,
 721                 .feature_bits   = FEATURE_WRSR_WREN,
 722                 .tested         = TEST_UNTESTED,
 723                 .probe          = probe_spi_rdid4,
 724                 .probe_timing   = TIMING_ZERO,
 725                 .block_erasers  =
 726                 {
 727                         {
 728                                 .eraseblocks = {
 729                                         {4 * 1024, 2},
 730                                         {8 * 1024, 1},
 731                                         {16 * 1024, 1},
 732                                         {32 * 1024, 1},
 733                                         {64 * 1024, 3},
 734                                 },
 735                                 .block_erase = spi_block_erase_d8,
 736                         }, {
 737                                 .eraseblocks = { {256 * 1024, 1} },
 738                                 .block_erase = spi_block_erase_c7,
 739                         }
 740                 },
 741                 .printlock      = spi_prettyprint_status_register_amic_a25l05p,
 742                 .unlock         = spi_disable_blockprotect,
 743                 .write          = spi_chip_write_256,
 744                 .read           = spi_chip_read,
 745                 .voltage        = {2700, 3600},
 746         },
 747
 748         /* The A25L40P{T,U} chips are distinguished by their
 749          * erase block layouts, but without any distinction in RDID.
 750          * This inexplicable quirk was verified by Rudolf Marek
 751          * and discussed on the flashrom mailing list on 2010-07-12.
 752          */
 753         {
 754                 .vendor         = "AMIC",
 755                 .name           = "A25L40PT",
 756                 .bustype        = BUS_SPI,
 757                 .manufacture_id = AMIC_ID,
 758                 .model_id       = AMIC_A25L40PT,
 759                 .total_size     = 512,
 760                 .page_size      = 256,
 761                 .feature_bits   = FEATURE_WRSR_WREN,
 762                 .tested         = TEST_OK_PR,
 763                 .probe          = probe_spi_rdid4,
 764                 .probe_timing   = TIMING_ZERO,
 765                 .block_erasers  =
 766                 {
 767                         {
 768                                 .eraseblocks = {
 769                                         {64 * 1024, 7},
 770                                         {32 * 1024, 1},
 771                                         {16 * 1024, 1},
 772                                         {8 * 1024, 1},
 773                                         {4 * 1024, 2},
 774                                 },
 775                                 .block_erase = spi_block_erase_d8,
 776                         }, {
 777                                 .eraseblocks = { {512 * 1024, 1} },
 778                                 .block_erase = spi_block_erase_c7,
 779                         }
 780                 },
 781                 .printlock      = spi_prettyprint_status_register_amic_a25l40p,
 782                 .unlock         = spi_disable_blockprotect,
 783                 .write          = spi_chip_write_256,
 784                 .read           = spi_chip_read,
 785                 .voltage        = {2700, 3600},
 786         },
 787
 788         {
 789                 .vendor         = "AMIC",
 790                 .name           = "A25L40PU",
 791                 .bustype        = BUS_SPI,
 792                 .manufacture_id = AMIC_ID,
 793                 .model_id       = AMIC_A25L40PU,
 794                 .total_size     = 512,
 795                 .page_size      = 256,
 796                 .feature_bits   = FEATURE_WRSR_WREN,
 797                 .tested         = TEST_OK_PR,
 798                 .probe          = probe_spi_rdid4,
 799                 .probe_timing   = TIMING_ZERO,
 800                 .block_erasers  =
 801                 {
 802                         {
 803                                 .eraseblocks = {
 804                                         {4 * 1024, 2},
 805                                         {8 * 1024, 1},
 806                                         {16 * 1024, 1},
 807                                         {32 * 1024, 1},
 808                                         {64 * 1024, 7},
 809                                 },
 810                                 .block_erase = spi_block_erase_d8,
 811                         }, {
 812                                 .eraseblocks = { {512 * 1024, 1} },
 813                                 .block_erase = spi_block_erase_c7,
 814                         }
 815                 },
 816                 .printlock      = spi_prettyprint_status_register_amic_a25l40p,
 817                 .unlock         = spi_disable_blockprotect,
 818                 .write          = spi_chip_write_256,
 819                 .read           = spi_chip_read,
 820                 .voltage        = {2700, 3600},
 821         },
 822
 823         {
 824                 .vendor         = "AMIC",
 825                 .name           = "A25L80P",
 826                 .bustype        = BUS_SPI,
 827                 .manufacture_id = AMIC_ID,
 828                 .model_id       = AMIC_A25L80P,
 829                 .total_size     = 1024,
 830                 .page_size      = 256,
 831                 .feature_bits   = FEATURE_WRSR_WREN,
 832                 .tested         = TEST_OK_PRE,
 833                 .probe          = probe_spi_rdid4,
 834                 .probe_timing   = TIMING_ZERO,
 835                 .block_erasers  =
 836                 {
 837                         {
 838                                 .eraseblocks = {
 839                                         {4 * 1024, 2},
 840                                         {8 * 1024, 1},
 841                                         {16 * 1024, 1},
 842                                         {32 * 1024, 1},
 843                                         {64 * 1024, 15},
 844                                 },
 845                                 .block_erase = spi_block_erase_d8,
 846                         }, {
 847                                 .eraseblocks = { {1024 * 1024, 1} },
 848                                 .block_erase = spi_block_erase_c7,
 849                         }
 850                 },
 851                 .printlock      = spi_prettyprint_status_register_amic_a25l40p,
 852                 .unlock         = spi_disable_blockprotect,
 853                 .write          = spi_chip_write_256,
 854                 .read           = spi_chip_read,
 855                 .voltage        = {2700, 3600},
 856         },
 857
 858         {
 859                 .vendor         = "AMIC",
 860                 .name           = "A25L16PT",
 861                 .bustype        = BUS_SPI,
 862                 .manufacture_id = AMIC_ID,
 863                 .model_id       = AMIC_A25L16PT,
 864                 .total_size     = 2048,
 865                 .page_size      = 256,
 866                 .feature_bits   = FEATURE_WRSR_WREN,
 867                 .tested         = TEST_UNTESTED,
 868                 .probe          = probe_spi_rdid4,
 869                 .probe_timing   = TIMING_ZERO,
 870                 .block_erasers  =
 871                 {
 872                         {
 873                                 .eraseblocks = {
 874                                         {64 * 1024, 31},
 875                                         {32 * 1024, 1},
 876                                         {16 * 1024, 1},
 877                                         {8 * 1024, 1},
 878                                         {4 * 1024, 2},
 879                                 },
 880                                 .block_erase = spi_block_erase_d8,
 881                         }, {
 882                                 .eraseblocks = { {2048 * 1024, 1} },
 883                                 .block_erase = spi_block_erase_60,
 884                         }, {
 885                                 .eraseblocks = { {2048 * 1024, 1} },
 886                                 .block_erase = spi_block_erase_c7,
 887                         }
 888                 },
 889                 .printlock      = spi_prettyprint_status_register_amic_a25l40p,
 890                 .unlock         = spi_disable_blockprotect,
 891                 .write          = spi_chip_write_256,
 892                 .read           = spi_chip_read,
 893                 .voltage        = {2700, 3600},
 894         },
 895
 896         {
 897                 .vendor         = "AMIC",
 898                 .name           = "A25L16PU",
 899                 .bustype        = BUS_SPI,
 900                 .manufacture_id = AMIC_ID,
 901                 .model_id       = AMIC_A25L16PU,
 902                 .total_size     = 2048,
 903                 .page_size      = 256,
 904                 .feature_bits   = FEATURE_WRSR_WREN,
 905                 .tested         = TEST_OK_PR,
 906                 .probe          = probe_spi_rdid4,
 907                 .probe_timing   = TIMING_ZERO,
 908                 .block_erasers  =
 909                 {
 910                         {
 911                                 .eraseblocks = {
 912                                         {4 * 1024, 2},
 913                                         {8 * 1024, 1},
 914                                         {16 * 1024, 1},
 915                                         {32 * 1024, 1},
 916                                         {64 * 1024, 31},
 917                                 },
 918                                 .block_erase = spi_block_erase_d8,
 919                         }, {
 920                                 .eraseblocks = { {2048 * 1024, 1} },
 921                                 .block_erase = spi_block_erase_60,
 922                         }, {
 923                                 .eraseblocks = { {2048 * 1024, 1} },
 924                                 .block_erase = spi_block_erase_c7,
 925                         }
 926                 },
 927                 .printlock      = spi_prettyprint_status_register_amic_a25l40p,
 928                 .unlock         = spi_disable_blockprotect,
 929                 .write          = spi_chip_write_256,
 930                 .read           = spi_chip_read,
 931                 .voltage        = {2700, 3600},
 932         },
 933
 934         {
 935                 .vendor         = "AMIC",
 936                 .name           = "A25L512",
 937                 .bustype        = BUS_SPI,
 938                 .manufacture_id = AMIC_ID_NOPREFIX,
 939                 .model_id       = AMIC_A25L512,
 940                 .total_size     = 64,
 941                 .page_size      = 256,
 942                 .feature_bits   = FEATURE_WRSR_WREN,
 943                 .tested         = TEST_UNTESTED,
 944                 .probe          = probe_spi_rdid,
 945                 .probe_timing   = TIMING_ZERO,
 946                 .block_erasers  =
 947                 {
 948                         {
 949                                 .eraseblocks = { { 4 * 1024, 16 } },
 950                                 .block_erase = spi_block_erase_20,
 951                         }, {
 952                                 .eraseblocks = { { 64 * 1024, 1 } },
 953                                 .block_erase = spi_block_erase_d8,
 954                         }, {
 955                                 .eraseblocks = { { 64 * 1024, 1 } },
 956                                 .block_erase = spi_block_erase_c7,
 957                         }
 958                 },
 959                 .printlock      = spi_prettyprint_status_register_amic_a25l40p,
 960                 .unlock         = spi_disable_blockprotect,
 961                 .write          = spi_chip_write_256,
 962                 .read           = spi_chip_read,
 963                 .voltage        = {2700, 3600},
 964         },
 965
 966         {
 967                 .vendor         = "AMIC",
 968                 .name           = "A25L010",
 969                 .bustype        = BUS_SPI,
 970                 .manufacture_id = AMIC_ID_NOPREFIX,
 971                 .model_id       = AMIC_A25L010,
 972                 .total_size     = 128,
 973                 .page_size      = 256,
 974                 .feature_bits   = FEATURE_WRSR_WREN,
 975                 .tested         = TEST_UNTESTED,
 976                 .probe          = probe_spi_rdid,
 977                 .probe_timing   = TIMING_ZERO,
 978                 .block_erasers  =
 979                 {
 980                         {
 981                                 .eraseblocks = { { 4 * 1024, 32 } },
 982                                 .block_erase = spi_block_erase_20,
 983                         }, {
 984                                 .eraseblocks = { { 64 * 1024, 2 } },
 985                                 .block_erase = spi_block_erase_d8,
 986                         }, {
 987                                 .eraseblocks = { { 128 * 1024, 1 } },
 988                                 .block_erase = spi_block_erase_c7,
 989                         }
 990                 },
 991                 .printlock      = spi_prettyprint_status_register_amic_a25l40p,
 992                 .unlock         = spi_disable_blockprotect,
 993                 .write          = spi_chip_write_256,
 994                 .read           = spi_chip_read,
 995                 .voltage        = {2700, 3600},
 996         },
 997
 998         {
 999                 .vendor         = "AMIC",
1000                 .name           = "A25L020",
1001                 .bustype        = BUS_SPI,
1002                 .manufacture_id = AMIC_ID_NOPREFIX,
1003                 .model_id       = AMIC_A25L020,
1004                 .total_size     = 256,
1005                 .page_size      = 256,
1006                 .feature_bits   = FEATURE_WRSR_WREN,
1007                 .tested         = TEST_UNTESTED,
1008                 .probe          = probe_spi_rdid,
1009                 .probe_timing   = TIMING_ZERO,
1010                 .block_erasers  =
1011                 {
1012                         {
1013                                 .eraseblocks = { { 4 * 1024, 64 } },
1014                                 .block_erase = spi_block_erase_20,
1015                         }, {
1016                                 .eraseblocks = { { 64 * 1024, 4 } },
1017                                 .block_erase = spi_block_erase_d8,
1018                         }, {
1019                                 .eraseblocks = { { 256 * 1024, 1 } },
1020                                 .block_erase = spi_block_erase_c7,
1021                         }
1022                 },
1023                 .printlock      = spi_prettyprint_status_register_amic_a25l40p,
1024                 .unlock         = spi_disable_blockprotect,
1025                 .write          = spi_chip_write_256,
1026                 .read           = spi_chip_read,
1027                 .voltage        = {2700, 3600},
1028         },
1029
1030         {
1031                 .vendor         = "AMIC",
1032                 .name           = "A25L040",
1033                 .bustype        = BUS_SPI,
1034                 .manufacture_id = AMIC_ID_NOPREFIX,
1035                 .model_id       = AMIC_A25L040,
1036                 .total_size     = 512,
1037                 .page_size      = 256,
1038                 .feature_bits   = FEATURE_WRSR_WREN,
1039                 .tested         = TEST_UNTESTED,
1040                 .probe          = probe_spi_rdid,
1041                 .probe_timing   = TIMING_ZERO,
1042                 .block_erasers  =
1043                 {
1044                         {
1045                                 .eraseblocks = { { 4 * 1024, 128 } },
1046                                 .block_erase = spi_block_erase_20,
1047                         }, {
1048                                 .eraseblocks = { { 64 * 1024, 8 } },
1049                                 .block_erase = spi_block_erase_d8,
1050                         }, {
1051                                 .eraseblocks = { { 512 * 1024, 1 } },
1052                                 .block_erase = spi_block_erase_c7,
1053                         }
1054                 },
1055                 .printlock      = spi_prettyprint_status_register_amic_a25l40p,
1056                 .unlock         = spi_disable_blockprotect,
1057                 .write          = spi_chip_write_256,
1058                 .read           = spi_chip_read,
1059                 .voltage        = {2700, 3600},
1060         },
1061
1062         {
1063                 .vendor         = "AMIC",
1064                 .name           = "A25L080",
1065                 .bustype        = BUS_SPI,
1066                 .manufacture_id = AMIC_ID_NOPREFIX,
1067                 .model_id       = AMIC_A25L080,
1068                 .total_size     = 1024,
1069                 .page_size      = 256,
1070                 .feature_bits   = FEATURE_WRSR_WREN,
1071                 .tested         = TEST_UNTESTED,
1072                 .probe          = probe_spi_rdid,
1073                 .probe_timing   = TIMING_ZERO,
1074                 .block_erasers  =
1075                 {
1076                         {
1077                                 .eraseblocks = { { 4 * 1024, 256 } },
1078                                 .block_erase = spi_block_erase_20,
1079                         }, {
1080                                 .eraseblocks = { { 64 * 1024, 16 } },
1081                                 .block_erase = spi_block_erase_d8,
1082                         }, {
1083                                 .eraseblocks = { { 1024 * 1024, 1 } },
1084                                 .block_erase = spi_block_erase_c7,
1085                         }
1086                 },
1087                 .printlock      = spi_prettyprint_status_register_amic_a25l40p,
1088                 .unlock         = spi_disable_blockprotect,
1089                 .write          = spi_chip_write_256,
1090                 .read           = spi_chip_read,
1091                 .voltage        = {2700, 3600},
1092         },
1093
1094         {
1095                 .vendor         = "AMIC",
1096                 .name           = "A25L016",
1097                 .bustype        = BUS_SPI,
1098                 .manufacture_id = AMIC_ID_NOPREFIX,
1099                 .model_id       = AMIC_A25L016,
1100                 .total_size     = 2048,
1101                 .page_size      = 256,
1102                 .feature_bits   = FEATURE_WRSR_WREN,
1103                 .tested         = TEST_UNTESTED,
1104                 .probe          = probe_spi_rdid,
1105                 .probe_timing   = TIMING_ZERO,
1106                 .block_erasers  =
1107                 {
1108                         {
1109                                 .eraseblocks = { { 4 * 1024, 512 } },
1110                                 .block_erase = spi_block_erase_20,
1111                         }, {
1112                                 .eraseblocks = { { 64 * 1024, 32 } },
1113                                 .block_erase = spi_block_erase_d8,
1114                         }, {
1115                                 .eraseblocks = { { 2048 * 1024, 1 } },
1116                                 .block_erase = spi_block_erase_c7,
1117                         }
1118                 },
1119                 .printlock      = spi_prettyprint_status_register_amic_a25l40p,
1120                 .unlock         = spi_disable_blockprotect,
1121                 .write          = spi_chip_write_256,
1122                 .read           = spi_chip_read,
1123                 .voltage        = {2700, 3600},
1124         },
1125
1126         {
1127                 .vendor         = "AMIC",
1128                 .name           = "A25L032",
1129                 .bustype        = BUS_SPI,
1130                 .manufacture_id = AMIC_ID_NOPREFIX,
1131                 .model_id       = AMIC_A25L032,
1132                 .total_size     = 4096,
1133                 .page_size      = 256,
1134                 /* OTP: 64B total; read 0x4B, 0x48; write 0x42 */
1135                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
1136                 .tested         = TEST_OK_PREW,
1137                 .probe          = probe_spi_rdid,
1138                 .probe_timing   = TIMING_ZERO,
1139                 .block_erasers  =
1140                 {
1141                         {
1142                                 .eraseblocks = { { 4 * 1024, 1024 } },
1143                                 .block_erase = spi_block_erase_20,
1144                         }, {
1145                                 .eraseblocks = { { 64 * 1024, 64 } },
1146                                 .block_erase = spi_block_erase_52,
1147                         }, {
1148                                 .eraseblocks = { { 64 * 1024, 64 } },
1149                                 .block_erase = spi_block_erase_d8,
1150                         }, {
1151                                 .eraseblocks = { { 4096 * 1024, 1 } },
1152                                 .block_erase = spi_block_erase_60,
1153                         }, {
1154                                 .eraseblocks = { { 4096 * 1024, 1 } },
1155                                 .block_erase = spi_block_erase_c7,
1156                         }
1157                 },
1158                 .printlock      = spi_prettyprint_status_register_amic_a25l032,
1159                 .unlock         = NULL, /* Two status reg bytes (read with 0x35 and 0x05) */
1160                 .write          = spi_chip_write_256,
1161                 .read           = spi_chip_read,
1162                 .voltage        = {2700, 3600},
1163         },
1164
1165         {
1166                 .vendor         = "AMIC",
1167                 .name           = "A25LQ032",
1168                 .bustype        = BUS_SPI,
1169                 .manufacture_id = AMIC_ID_NOPREFIX,
1170                 .model_id       = AMIC_A25LQ032,
1171                 .total_size     = 4096,
1172                 .page_size      = 256,
1173                 /* OTP: 64B total; read 0x4B, 0x48; write 0x42 */
1174                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
1175                 .tested         = TEST_UNTESTED,
1176                 .probe          = probe_spi_rdid,
1177                 .probe_timing   = TIMING_ZERO,
1178                 .block_erasers  =
1179                 {
1180                         {
1181                                 .eraseblocks = { { 4 * 1024, 1024 } },
1182                                 .block_erase = spi_block_erase_20,
1183                         }, {
1184                                 .eraseblocks = { { 64 * 1024, 64 } },
1185                                 .block_erase = spi_block_erase_52,
1186                         }, {
1187                                 .eraseblocks = { { 64 * 1024, 64 } },
1188                                 .block_erase = spi_block_erase_d8,
1189                         }, {
1190                                 .eraseblocks = { { 4096 * 1024, 1 } },
1191                                 .block_erase = spi_block_erase_60,
1192                         }, {
1193                                 .eraseblocks = { { 4096 * 1024, 1 } },
1194                                 .block_erase = spi_block_erase_c7,
1195                         }
1196                 },
1197                 .printlock      = spi_prettyprint_status_register_amic_a25lq032,
1198                 .unlock         = NULL, /* Two status reg bytes (read with 0x35 and 0x05) */
1199                 .write          = spi_chip_write_256,
1200                 .read           = spi_chip_read,
1201                 .voltage        = {2700, 3600},
1202         },
1203
1204         {
1205                 .vendor         = "AMIC",
1206                 .name           = "A29002B",
1207                 .bustype        = BUS_PARALLEL,
1208                 .manufacture_id = AMIC_ID_NOPREFIX,
1209                 .model_id       = AMIC_A29002B,
1210                 .total_size     = 256,
1211                 .page_size      = 64 * 1024,
1212                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
1213                 .tested         = TEST_UNTESTED,
1214                 .probe          = probe_jedec,
1215                 .probe_timing   = TIMING_ZERO,
1216                 .block_erasers  =
1217                 {
1218                         {
1219                                 .eraseblocks = {
1220                                         {16 * 1024, 1},
1221                                         {8 * 1024, 2},
1222                                         {32 * 1024, 1},
1223                                         {64 * 1024, 3},
1224                                 },
1225                                 .block_erase = erase_sector_jedec,
1226                         }, {
1227                                 .eraseblocks = { {256 * 1024, 1} },
1228                                 .block_erase = erase_chip_block_jedec,
1229                         },
1230                 },
1231                 .write          = write_jedec_1,
1232                 .read           = read_memmapped,
1233                 .voltage        = {4500, 5500},
1234         },
1235
1236         {
1237                 .vendor         = "AMIC",
1238                 .name           = "A29002T",
1239                 .bustype        = BUS_PARALLEL,
1240                 .manufacture_id = AMIC_ID_NOPREFIX,
1241                 .model_id       = AMIC_A29002T,
1242                 .total_size     = 256,
1243                 .page_size      = 64 * 1024,
1244                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
1245                 .tested         = TEST_OK_PREW,
1246                 .probe          = probe_jedec,
1247                 .probe_timing   = TIMING_ZERO,
1248                 .block_erasers  =
1249                 {
1250                         {
1251                                 .eraseblocks = {
1252                                         {64 * 1024, 3},
1253                                         {32 * 1024, 1},
1254                                         {8 * 1024, 2},
1255                                         {16 * 1024, 1},
1256                                 },
1257                                 .block_erase = erase_sector_jedec,
1258                         }, {
1259                                 .eraseblocks = { {256 * 1024, 1} },
1260                                 .block_erase = erase_chip_block_jedec,
1261                         },
1262                 },
1263                 .write          = write_jedec_1,
1264                 .read           = read_memmapped,
1265                 .voltage        = {4500, 5500},
1266         },
1267
1268         {
1269                 .vendor         = "AMIC",
1270                 .name           = "A29040B",
1271                 .bustype        = BUS_PARALLEL,
1272                 .manufacture_id = AMIC_ID_NOPREFIX,
1273                 .model_id       = AMIC_A29040B,
1274                 .total_size     = 512,
1275                 .page_size      = 64 * 1024,
1276                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
1277                 .tested         = TEST_UNTESTED,
1278                 .probe          = probe_jedec,
1279                 .probe_timing   = TIMING_ZERO,
1280                 .block_erasers  =
1281                 {
1282                         {
1283                                 .eraseblocks = { {64 * 1024, 8} },
1284                                 .block_erase = erase_sector_jedec,
1285                         }, {
1286                                 .eraseblocks = { {512 * 1024, 1} },
1287                                 .block_erase = erase_chip_block_jedec,
1288                         },
1289                 },
1290                 .write          = write_jedec_1,
1291                 .read           = read_memmapped,
1292                 .voltage        = {4500, 5500},
1293         },
1294
1295         {
1296                 .vendor         = "AMIC",
1297                 .name           = "A49LF040A",
1298                 .bustype        = BUS_LPC,
1299                 .manufacture_id = AMIC_ID_NOPREFIX,
1300                 .model_id       = AMIC_A49LF040A,
1301                 .total_size     = 512,
1302                 .page_size      = 64 * 1024,
1303                 .feature_bits   = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
1304                 .tested         = TEST_OK_PREW,
1305                 .probe          = probe_jedec,
1306                 .probe_timing   = TIMING_ZERO,  /* routine is wrapper to probe_jedec (pm49fl00x.c) */
1307                 .block_erasers  =
1308                 {
1309                         {
1310                                 .eraseblocks = { {64 * 1024, 8} },
1311                                 .block_erase = erase_block_jedec,
1312                         }, {
1313                                 .eraseblocks = { {512 * 1024, 1} },
1314                                 .block_erase = erase_chip_block_jedec,
1315                         }
1316                 },
1317                 .unlock         = unlock_49fl00x,
1318                 .write          = write_jedec_1,
1319                 .read           = read_memmapped,
1320                 .voltage        = {3000, 3600},
1321         },
1322
1323         {
1324                 .vendor         = "Atmel",
1325                 .name           = "AT25DF021",
1326                 .bustype        = BUS_SPI,
1327                 .manufacture_id = ATMEL_ID,
1328                 .model_id       = ATMEL_AT25DF021,
1329                 .total_size     = 256,
1330                 .page_size      = 256,
1331                 /* OTP: 128B total, 64B pre-programmed; read 0x77; write 0x9B */
1332                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
1333                 .tested         = TEST_UNTESTED,
1334                 .probe          = probe_spi_rdid,
1335                 .probe_timing   = TIMING_ZERO,
1336                 .block_erasers  =
1337                 {
1338                         {
1339                                 .eraseblocks = { {4 * 1024, 64} },
1340                                 .block_erase = spi_block_erase_20,
1341                         }, {
1342                                 .eraseblocks = { {32 * 1024, 8} },
1343                                 .block_erase = spi_block_erase_52,
1344                         }, {
1345                                 .eraseblocks = { {64 * 1024, 4} },
1346                                 .block_erase = spi_block_erase_d8,
1347                         }, {
1348                                 .eraseblocks = { {256 * 1024, 1} },
1349                                 .block_erase = spi_block_erase_60,
1350                         }, {
1351                                 .eraseblocks = { {256 * 1024, 1} },
1352                                 .block_erase = spi_block_erase_c7,
1353                         }
1354                 },
1355                 .printlock      = spi_prettyprint_status_register_at25df,
1356                 .unlock         = spi_disable_blockprotect_at25df,
1357                 .write          = spi_chip_write_256,
1358                 .read           = spi_chip_read,
1359                 .voltage        = {2700, 3600}, /* 2.3-3.6V & 2.7-3.6V models available */
1360         },
1361
1362         {
1363                 .vendor         = "Atmel",
1364                 .name           = "AT25DF041A",
1365                 .bustype        = BUS_SPI,
1366                 .manufacture_id = ATMEL_ID,
1367                 .model_id       = ATMEL_AT25DF041A,
1368                 .total_size     = 512,
1369                 .page_size      = 256,
1370                 .feature_bits   = FEATURE_WRSR_WREN,
1371                 .tested         = TEST_UNTESTED,
1372                 .probe          = probe_spi_rdid,
1373                 .probe_timing   = TIMING_ZERO,
1374                 .block_erasers  =
1375                 {
1376                         {
1377                                 .eraseblocks = { {4 * 1024, 128} },
1378                                 .block_erase = spi_block_erase_20,
1379                         }, {
1380                                 .eraseblocks = { {32 * 1024, 16} },
1381                                 .block_erase = spi_block_erase_52,
1382                         }, {
1383                                 .eraseblocks = { {64 * 1024, 8} },
1384                                 .block_erase = spi_block_erase_d8,
1385                         }, {
1386                                 .eraseblocks = { {512 * 1024, 1} },
1387                                 .block_erase = spi_block_erase_60,
1388                         }, {
1389                                 .eraseblocks = { {512 * 1024, 1} },
1390                                 .block_erase = spi_block_erase_c7,
1391                         }
1392                 },
1393                 .printlock      = spi_prettyprint_status_register_at25df,
1394                 .unlock         = spi_disable_blockprotect_at25df,
1395                 .write          = spi_chip_write_256,
1396                 .read           = spi_chip_read,
1397                 .voltage        = {2700, 3600}, /* 2.3-3.6V & 2.7-3.6V models available */
1398         },
1399
1400         {
1401                 .vendor         = "Atmel",
1402                 .name           = "AT25DF081",
1403                 .bustype        = BUS_SPI,
1404                 .manufacture_id = ATMEL_ID,
1405                 .model_id       = ATMEL_AT25DF081,
1406                 .total_size     = 1024,
1407                 .page_size      = 256,
1408                 .feature_bits   = FEATURE_WRSR_WREN,
1409                 .tested         = TEST_UNTESTED,
1410                 .probe          = probe_spi_rdid,
1411                 .probe_timing   = TIMING_ZERO,
1412                 .block_erasers  =
1413                 {
1414                         {
1415                                 .eraseblocks = { {4 * 1024, 256} },
1416                                 .block_erase = spi_block_erase_20,
1417                         }, {
1418                                 .eraseblocks = { {32 * 1024, 32} },
1419                                 .block_erase = spi_block_erase_52,
1420                         }, {
1421                                 .eraseblocks = { {64 * 1024, 16} },
1422                                 .block_erase = spi_block_erase_d8,
1423                         }, {
1424                                 .eraseblocks = { {1024 * 1024, 1} },
1425                                 .block_erase = spi_block_erase_60,
1426                         }, {
1427                                 .eraseblocks = { {1024 * 1024, 1} },
1428                                 .block_erase = spi_block_erase_c7,
1429                         }
1430                 },
1431                 .printlock      = spi_prettyprint_status_register_at25df,
1432                 .unlock         = spi_disable_blockprotect_at25df,
1433                 .write          = spi_chip_write_256,
1434                 .read           = spi_chip_read,
1435                 .voltage        = {1600, 2000}, /* Datasheet says range is 1.65-1.95 V */
1436         },
1437
1438         {
1439                 .vendor         = "Atmel",
1440                 .name           = "AT25DF081A",
1441                 .bustype        = BUS_SPI,
1442                 .manufacture_id = ATMEL_ID,
1443                 .model_id       = ATMEL_AT25DF081A,
1444                 .total_size     = 1024,
1445                 .page_size      = 256,
1446                 .feature_bits   = FEATURE_WRSR_WREN,
1447                 .tested         = TEST_UNTESTED,
1448                 .probe          = probe_spi_rdid,
1449                 .probe_timing   = TIMING_ZERO,
1450                 .block_erasers  =
1451                 {
1452                         {
1453                                 .eraseblocks = { {4 * 1024, 256} },
1454                                 .block_erase = spi_block_erase_20,
1455                         }, {
1456                                 .eraseblocks = { {32 * 1024, 32} },
1457                                 .block_erase = spi_block_erase_52,
1458                         }, {
1459                                 .eraseblocks = { {64 * 1024, 16} },
1460                                 .block_erase = spi_block_erase_d8,
1461                         }, {
1462                                 .eraseblocks = { {1024 * 1024, 1} },
1463                                 .block_erase = spi_block_erase_60,
1464                         }, {
1465                                 .eraseblocks = { {1024 * 1024, 1} },
1466                                 .block_erase = spi_block_erase_c7,
1467                         }
1468                 },
1469                 .printlock      = spi_prettyprint_status_register_at25df_sec,
1470                 .unlock         = spi_disable_blockprotect_at25df_sec,
1471                 .write          = spi_chip_write_256,
1472                 .read           = spi_chip_read,
1473                 .voltage        = {2700, 3600},
1474         },
1475
1476         {
1477                 .vendor         = "Atmel",
1478                 .name           = "AT25DF161",
1479                 .bustype        = BUS_SPI,
1480                 .manufacture_id = ATMEL_ID,
1481                 .model_id       = ATMEL_AT25DF161,
1482                 .total_size     = 2048,
1483                 .page_size      = 256,
1484                 .feature_bits   = FEATURE_WRSR_WREN,
1485                 .tested         = TEST_OK_PROBE,
1486                 .probe          = probe_spi_rdid,
1487                 .probe_timing   = TIMING_ZERO,
1488                 .block_erasers  =
1489                 {
1490                         {
1491                                 .eraseblocks = { {4 * 1024, 512} },
1492                                 .block_erase = spi_block_erase_20,
1493                         }, {
1494                                 .eraseblocks = { {32 * 1024, 64} },
1495                                 .block_erase = spi_block_erase_52,
1496                         }, {
1497                                 .eraseblocks = { {64 * 1024, 32} },
1498                                 .block_erase = spi_block_erase_d8,
1499                         }, {
1500                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
1501                                 .block_erase = spi_block_erase_60,
1502                         }, {
1503                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
1504                                 .block_erase = spi_block_erase_c7,
1505                         }
1506                 },
1507                 .printlock      = spi_prettyprint_status_register_at25df_sec,
1508                 .unlock         = spi_disable_blockprotect_at25df_sec,
1509                 .write          = spi_chip_write_256,
1510                 .read           = spi_chip_read,
1511                 .voltage        = {2700, 3600},
1512         },
1513
1514         {
1515                 .vendor         = "Atmel",
1516                 .name           = "AT25DF321",
1517                 .bustype        = BUS_SPI,
1518                 .manufacture_id = ATMEL_ID,
1519                 .model_id       = ATMEL_AT25DF321,
1520                 .total_size     = 4096,
1521                 .page_size      = 256,
1522                 .feature_bits   = FEATURE_WRSR_WREN,
1523                 .tested         = TEST_OK_PREW,
1524                 .probe          = probe_spi_rdid,
1525                 .probe_timing   = TIMING_ZERO,
1526                 .block_erasers  =
1527                 {
1528                         {
1529                                 .eraseblocks = { {4 * 1024, 1024} },
1530                                 .block_erase = spi_block_erase_20,
1531                         }, {
1532                                 .eraseblocks = { {32 * 1024, 128} },
1533                                 .block_erase = spi_block_erase_52,
1534                         }, {
1535                                 .eraseblocks = { {64 * 1024, 64} },
1536                                 .block_erase = spi_block_erase_d8,
1537                         }, {
1538                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
1539                                 .block_erase = spi_block_erase_60,
1540                         }, {
1541                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
1542                                 .block_erase = spi_block_erase_c7,
1543                         }
1544                 },
1545                 .printlock      = spi_prettyprint_status_register_at25df,
1546                 .unlock         = spi_disable_blockprotect_at25df,
1547                 .write          = spi_chip_write_256,
1548                 .read           = spi_chip_read,
1549                 .voltage        = {2700, 3600},
1550         },
1551
1552         {
1553                 .vendor         = "Atmel",
1554                 .name           = "AT25DF321A",
1555                 .bustype        = BUS_SPI,
1556                 .manufacture_id = ATMEL_ID,
1557                 .model_id       = ATMEL_AT25DF321A,
1558                 .total_size     = 4096,
1559                 .page_size      = 256,
1560                 /* OTP: 128B total, 64B pre-programmed; read 0x77; write 0x9B */
1561                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
1562                 .tested         = TEST_OK_PREW,
1563                 .probe          = probe_spi_rdid,
1564                 .probe_timing   = TIMING_ZERO,
1565                 .block_erasers  =
1566                 {
1567                         {
1568                                 .eraseblocks = { {4 * 1024, 1024} },
1569                                 .block_erase = spi_block_erase_20,
1570                         }, {
1571                                 .eraseblocks = { {32 * 1024, 128} },
1572                                 .block_erase = spi_block_erase_52,
1573                         }, {
1574                                 .eraseblocks = { {64 * 1024, 64} },
1575                                 .block_erase = spi_block_erase_d8,
1576                         }, {
1577                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
1578                                 .block_erase = spi_block_erase_60,
1579                         }, {
1580                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
1581                                 .block_erase = spi_block_erase_c7,
1582                         }
1583                 },
1584                 .printlock      = spi_prettyprint_status_register_at25df_sec,
1585                 .unlock         = spi_disable_blockprotect_at25df_sec,
1586                 .write          = spi_chip_write_256,
1587                 .read           = spi_chip_read,
1588                 .voltage        = {2700, 3600},
1589         },
1590
1591         {
1592                 .vendor         = "Atmel",
1593                 .name           = "AT25DF641(A)",
1594                 .bustype        = BUS_SPI,
1595                 .manufacture_id = ATMEL_ID,
1596                 .model_id       = ATMEL_AT25DF641,
1597                 .total_size     = 8192,
1598                 .page_size      = 256,
1599                 .feature_bits   = FEATURE_WRSR_WREN,
1600                 .tested         = TEST_UNTESTED,
1601                 .probe          = probe_spi_rdid,
1602                 .probe_timing   = TIMING_ZERO,
1603                 .block_erasers  =
1604                 {
1605                         {
1606                                 .eraseblocks = { {4 * 1024, 2048} },
1607                                 .block_erase = spi_block_erase_20,
1608                         }, {
1609                                 .eraseblocks = { {32 * 1024, 256} },
1610                                 .block_erase = spi_block_erase_52,
1611                         }, {
1612                                 .eraseblocks = { {64 * 1024, 128} },
1613                                 .block_erase = spi_block_erase_d8,
1614                         }, {
1615                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
1616                                 .block_erase = spi_block_erase_60,
1617                         }, {
1618                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
1619                                 .block_erase = spi_block_erase_c7,
1620                         }
1621                 },
1622                 .printlock      = spi_prettyprint_status_register_at25df_sec,
1623                 .unlock         = spi_disable_blockprotect_at25df_sec,
1624                 .write          = spi_chip_write_256,
1625                 .read           = spi_chip_read,
1626                 .voltage        = {2700, 3600},
1627         },
1628
1629         {
1630                 .vendor         = "Atmel",
1631                 .name           = "AT25DQ161",
1632                 .bustype        = BUS_SPI,
1633                 .manufacture_id = ATMEL_ID,
1634                 .model_id       = ATMEL_AT25DQ161,
1635                 .total_size     = 2048,
1636                 .page_size      = 256,
1637                 /* OTP: 128B total, 64B pre-programmed; read 0x77; write 0x9B */
1638                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
1639                 .tested         = TEST_UNTESTED,
1640                 .probe          = probe_spi_rdid,
1641                 .probe_timing   = TIMING_ZERO,
1642                 .block_erasers  =
1643                 {
1644                         {
1645                                 .eraseblocks = { {4 * 1024, 512} },
1646                                 .block_erase = spi_block_erase_20,
1647                         }, {
1648                                 .eraseblocks = { {32 * 1024, 64} },
1649                                 .block_erase = spi_block_erase_52,
1650                         }, {
1651                                 .eraseblocks = { {64 * 1024, 32} },
1652                                 .block_erase = spi_block_erase_d8,
1653                         }, {
1654                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
1655                                 .block_erase = spi_block_erase_60,
1656                         }, {
1657                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
1658                                 .block_erase = spi_block_erase_c7,
1659                         }
1660                 },
1661                 .printlock      = spi_prettyprint_status_register_at25df_sec,
1662                 .unlock         = spi_disable_blockprotect_at25df_sec,
1663                 .write          = spi_chip_write_256,
1664                 .read           = spi_chip_read,
1665                 .voltage        = {2700, 3600},
1666         },
1667
1668         {
1669                 .vendor         = "Atmel",
1670                 .name           = "AT25F512B",
1671                 .bustype        = BUS_SPI,
1672                 .manufacture_id = ATMEL_ID,
1673                 .model_id       = ATMEL_AT25F512B,
1674                 .total_size     = 64,
1675                 .page_size      = 256,
1676                 /* OTP: 128B total, 64B pre-programmed; read 0x77; write 0x9B */
1677                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
1678                 .tested         = TEST_UNTESTED,
1679                 .probe          = probe_spi_rdid,
1680                 .probe_timing   = TIMING_ZERO,
1681                 .block_erasers  =
1682                 {
1683                         {
1684                                 .eraseblocks = { {4 * 1024, 16} },
1685                                 .block_erase = spi_block_erase_20,
1686                         }, {
1687                                 .eraseblocks = { {32 * 1024, 2} },
1688                                 .block_erase = spi_block_erase_52,
1689                         }, {
1690                                 .eraseblocks = { {32 * 1024, 2} },
1691                                 .block_erase = spi_block_erase_d8,
1692                         }, {
1693                                 .eraseblocks = { {64 * 1024, 1} },
1694                                 .block_erase = spi_block_erase_60,
1695                         }, {
1696                                 .eraseblocks = { {64 * 1024, 1} },
1697                                 .block_erase = spi_block_erase_c7,
1698                         }
1699                 },
1700                 .printlock      = spi_prettyprint_status_register_at25f,
1701                 .unlock         = spi_disable_blockprotect_at25f,
1702                 .write          = spi_chip_write_256,
1703                 .read           = spi_chip_read,
1704                 .voltage        = {2700, 3600},
1705         },
1706
1707         {
1708                 .vendor         = "Atmel",
1709                 .name           = "AT25FS010",
1710                 .bustype        = BUS_SPI,
1711                 .manufacture_id = ATMEL_ID,
1712                 .model_id       = ATMEL_AT25FS010,
1713                 .total_size     = 128,
1714                 .page_size      = 256,
1715                 .feature_bits   = FEATURE_WRSR_WREN,
1716                 .tested         = TEST_UNTESTED,
1717                 .probe          = probe_spi_rdid,
1718                 .probe_timing   = TIMING_ZERO,
1719                 .block_erasers  =
1720                 {
1721                         {
1722                                 .eraseblocks = { {4 * 1024, 32} },
1723                                 .block_erase = spi_block_erase_20,
1724                         }, {
1725                                 .eraseblocks = { {4 * 1024, 32} },
1726                                 .block_erase = spi_block_erase_d7,
1727                         }, {
1728                                 .eraseblocks = { {32 * 1024, 4} },
1729                                 .block_erase = spi_block_erase_52,
1730                         }, {
1731                                 .eraseblocks = { {32 * 1024, 4} },
1732                                 .block_erase = spi_block_erase_d8,
1733                         }, {
1734                                 .eraseblocks = { {128 * 1024, 1} },
1735                                 .block_erase = spi_block_erase_60,
1736                         }, {
1737                                 .eraseblocks = { {128 * 1024, 1} },
1738                                 .block_erase = spi_block_erase_c7,
1739                         }
1740                 },
1741                 .printlock      = spi_prettyprint_status_register_at25fs010,
1742                 .unlock         = spi_disable_blockprotect_at25fs010,
1743                 .write          = spi_chip_write_256,
1744                 .read           = spi_chip_read,
1745                 .voltage        = {2700, 3600},
1746         },
1747
1748         {
1749                 .vendor         = "Atmel",
1750                 .name           = "AT25FS040",
1751                 .bustype        = BUS_SPI,
1752                 .manufacture_id = ATMEL_ID,
1753                 .model_id       = ATMEL_AT25FS040,
1754                 .total_size     = 512,
1755                 .page_size      = 256,
1756                 .feature_bits   = FEATURE_WRSR_WREN,
1757                 .tested         = TEST_UNTESTED,
1758                 .probe          = probe_spi_rdid,
1759                 .probe_timing   = TIMING_ZERO,
1760                 .block_erasers  =
1761                 {
1762                         {
1763                                 .eraseblocks = { {4 * 1024, 128} },
1764                                 .block_erase = spi_block_erase_20,
1765                         }, {
1766                                 .eraseblocks = { {64 * 1024, 8} },
1767                                 .block_erase = spi_block_erase_52,
1768                         }, {
1769                                 .eraseblocks = { {64 * 1024, 8} },
1770                                 .block_erase = spi_block_erase_d8,
1771                         }, {
1772                                 .eraseblocks = { {512 * 1024, 1} },
1773                                 .block_erase = spi_block_erase_60,
1774                         }, {
1775                                 .eraseblocks = { {512 * 1024, 1} },
1776                                 .block_erase = spi_block_erase_c7,
1777                         }
1778                 },
1779                 .printlock      = spi_prettyprint_status_register_at25fs040,
1780                 .unlock         = spi_disable_blockprotect_at25fs040,
1781                 .write          = spi_chip_write_256,
1782                 .read           = spi_chip_read,
1783                 .voltage        = {2700, 3600},
1784         },
1785
1786         {
1787                 .vendor         = "Atmel",
1788                 .name           = "AT26DF041",
1789                 .bustype        = BUS_SPI,
1790                 .manufacture_id = ATMEL_ID,
1791                 .model_id       = ATMEL_AT26DF041,
1792                 .total_size     = 512,
1793                 .page_size      = 256,
1794                 /* does not support EWSR nor WREN and has no writable status register bits whatsoever */
1795                 .tested         = TEST_UNTESTED,
1796                 .probe          = probe_spi_rdid,
1797                 .probe_timing   = TIMING_ZERO,
1798                 .block_erasers  =
1799                 {
1800                         {
1801                                 .eraseblocks = { {4 * 1024, 128} },
1802                                 .block_erase = spi_block_erase_20,
1803                         }
1804                 },
1805                 .write          = NULL /* Incompatible Page write */,
1806                 .read           = spi_chip_read,
1807                 .voltage        = {2700, 3600}, /* 3.0-3.6V for higher speed, 2.7-3.6V normal */
1808         },
1809
1810         {
1811                 .vendor         = "Atmel",
1812                 .name           = "AT26DF081A",
1813                 .bustype        = BUS_SPI,
1814                 .manufacture_id = ATMEL_ID,
1815                 .model_id       = ATMEL_AT26DF081A,
1816                 .total_size     = 1024,
1817                 .page_size      = 256,
1818                 .feature_bits   = FEATURE_WRSR_WREN,
1819                 .tested         = TEST_OK_PREW,
1820                 .probe          = probe_spi_rdid,
1821                 .probe_timing   = TIMING_ZERO,
1822                 .block_erasers  =
1823                 {
1824                         {
1825                                 .eraseblocks = { {4 * 1024, 256} },
1826                                 .block_erase = spi_block_erase_20,
1827                         }, {
1828                                 .eraseblocks = { {32 * 1024, 32} },
1829                                 .block_erase = spi_block_erase_52,
1830                         }, {
1831                                 .eraseblocks = { {64 * 1024, 16} },
1832                                 .block_erase = spi_block_erase_d8,
1833                         }, {
1834                                 .eraseblocks = { {1024 * 1024, 1} },
1835                                 .block_erase = spi_block_erase_60,
1836                         }, {
1837                                 .eraseblocks = { {1024 * 1024, 1} },
1838                                 .block_erase = spi_block_erase_c7,
1839                         }
1840                 },
1841                 .printlock      = spi_prettyprint_status_register_atmel_at26df081a,
1842                 .unlock         = spi_disable_blockprotect_at25df,
1843                 .write          = spi_chip_write_256,
1844                 .read           = spi_chip_read,
1845                 .voltage        = {2700, 3600},
1846         },
1847
1848         {
1849                 .vendor         = "Atmel",
1850                 .name           = "AT26DF161",
1851                 .bustype        = BUS_SPI,
1852                 .manufacture_id = ATMEL_ID,
1853                 .model_id       = ATMEL_AT26DF161,
1854                 .total_size     = 2048,
1855                 .page_size      = 256,
1856                 .feature_bits   = FEATURE_WRSR_WREN,
1857                 .tested         = TEST_OK_PR,
1858                 .probe          = probe_spi_rdid,
1859                 .probe_timing   = TIMING_ZERO,
1860                 .block_erasers  =
1861                 {
1862                         {
1863                                 .eraseblocks = { {4 * 1024, 512} },
1864                                 .block_erase = spi_block_erase_20,
1865                         }, {
1866                                 .eraseblocks = { {32 * 1024, 64} },
1867                                 .block_erase = spi_block_erase_52,
1868                         }, {
1869                                 .eraseblocks = { {64 * 1024, 32} },
1870                                 .block_erase = spi_block_erase_d8,
1871                         }, {
1872                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
1873                                 .block_erase = spi_block_erase_60,
1874                         }, {
1875                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
1876                                 .block_erase = spi_block_erase_c7,
1877                         }
1878                 },
1879                 .printlock      = spi_prettyprint_status_register_at25df,
1880                 .unlock         = spi_disable_blockprotect,
1881                 .write          = spi_chip_write_256,
1882                 .read           = spi_chip_read,
1883                 .voltage        = {2700, 3600},
1884         },
1885
1886         {
1887                 .vendor         = "Atmel",
1888                 .name           = "AT26DF161A",
1889                 .bustype        = BUS_SPI,
1890                 .manufacture_id = ATMEL_ID,
1891                 .model_id       = ATMEL_AT26DF161A,
1892                 .total_size     = 2048,
1893                 .page_size      = 256,
1894                 .feature_bits   = FEATURE_WRSR_WREN,
1895                 .tested         = TEST_UNTESTED,
1896                 .probe          = probe_spi_rdid,
1897                 .probe_timing   = TIMING_ZERO,
1898                 .block_erasers  =
1899                 {
1900                         {
1901                                 .eraseblocks = { {4 * 1024, 512} },
1902                                 .block_erase = spi_block_erase_20,
1903                         }, {
1904                                 .eraseblocks = { {32 * 1024, 64} },
1905                                 .block_erase = spi_block_erase_52,
1906                         }, {
1907                                 .eraseblocks = { {64 * 1024, 32} },
1908                                 .block_erase = spi_block_erase_d8,
1909                         }, {
1910                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
1911                                 .block_erase = spi_block_erase_60,
1912                         }, {
1913                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
1914                                 .block_erase = spi_block_erase_c7,
1915                         }
1916                 },
1917                 .printlock      = spi_prettyprint_status_register_atmel_at26df081a,
1918                 .unlock         = spi_disable_blockprotect,
1919                 .write          = spi_chip_write_256,
1920                 .read           = spi_chip_read,
1921                 .voltage        = {2700, 3600},
1922         },
1923
1924         /*The AT26DF321 has the same ID as the AT25DF321. */
1925         /*{
1926                 .vendor         = "Atmel",
1927                 .name           = "AT26DF321",
1928                 .bustype        = BUS_SPI,
1929                 .manufacture_id = ATMEL_ID,
1930                 .model_id       = ATMEL_AT26DF321,
1931                 .total_size     = 4096,
1932                 .page_size      = 256,
1933                 .feature_bits   = FEATURE_WRSR_WREN,
1934                 .tested         = TEST_UNTESTED,
1935                 .probe          = probe_spi_rdid,
1936                 .probe_timing   = TIMING_ZERO,
1937                 .printlock      = spi_prettyprint_status_register_atmel_at26df081a,
1938                 .unlock         = spi_disable_blockprotect,
1939                 .write          = spi_chip_write_256,
1940                 .read           = spi_chip_read,
1941           },*/
1942
1943         {
1944                 .vendor         = "Atmel",
1945                 .name           = "AT26F004",
1946                 .bustype        = BUS_SPI,
1947                 .manufacture_id = ATMEL_ID,
1948                 .model_id       = ATMEL_AT26F004,
1949                 .total_size     = 512,
1950                 .page_size      = 256,
1951                 .tested         = TEST_UNTESTED,
1952                 .feature_bits   = FEATURE_WRSR_WREN,
1953                 .probe          = probe_spi_rdid,
1954                 .probe_timing   = TIMING_ZERO,
1955                 .block_erasers  =
1956                 {
1957                         {
1958                                 .eraseblocks = { {4 * 1024, 128} },
1959                                 .block_erase = spi_block_erase_20,
1960                         }, {
1961                                 .eraseblocks = { {32 * 1024, 16} },
1962                                 .block_erase = spi_block_erase_52,
1963                         }, {
1964                                 .eraseblocks = { {64 * 1024, 8} },
1965                                 .block_erase = spi_block_erase_d8,
1966                         }, {
1967                                 .eraseblocks = { {512 * 1024, 1} },
1968                                 .block_erase = spi_block_erase_60,
1969                         }, {
1970                                 .eraseblocks = { {512 * 1024, 1} },
1971                                 .block_erase = spi_block_erase_c7,
1972                         }
1973                 },
1974                 .write          = NULL /* Incompatible Page write */,
1975                 .read           = spi_chip_read,
1976                 .voltage        = {2700, 3600},
1977         },
1978
1979         {
1980                 .vendor         = "Atmel",
1981                 .name           = "AT29C512",
1982                 .bustype        = BUS_PARALLEL,
1983                 .manufacture_id = ATMEL_ID,
1984                 .model_id       = ATMEL_AT29C512,
1985                 .total_size     = 64,
1986                 .page_size      = 128,
1987                 .feature_bits   = FEATURE_LONG_RESET,
1988                 .tested         = TEST_OK_PREW,
1989                 .probe          = probe_jedec,
1990                 .probe_timing   = 10000, /* 10mS, Enter=Exec */
1991                 .block_erasers  =
1992                 {
1993                         {
1994                                 .eraseblocks = { {64 * 1024, 1} },
1995                                 .block_erase = erase_chip_block_jedec,
1996                         }
1997                 },
1998                 .write          = write_jedec,
1999                 .read           = read_memmapped,
2000                 .voltage        = {4500, 5500},
2001         },
2002
2003         {
2004                 .vendor         = "Atmel",
2005                 .name           = "AT29C010A",
2006                 .bustype        = BUS_PARALLEL,
2007                 .manufacture_id = ATMEL_ID,
2008                 .model_id       = ATMEL_AT29C010A,
2009                 .total_size     = 128,
2010                 .page_size      = 128,
2011                 .feature_bits   = FEATURE_LONG_RESET,
2012                 .tested         = TEST_OK_PRE,
2013                 .probe          = probe_jedec,
2014                 .probe_timing   = 10000, /* 10mS, Enter=Exec */
2015                 .block_erasers  =
2016                 {
2017                         {
2018                                 .eraseblocks = { {128 * 1024, 1} },
2019                                 .block_erase = erase_chip_block_jedec,
2020                         }
2021                 },
2022                 .write          = write_jedec,  /* FIXME */
2023                 .read           = read_memmapped,
2024                 .voltage        = {4500, 5500},
2025         },
2026
2027         {
2028                 .vendor         = "Atmel",
2029                 .name           = "AT29C020",
2030                 .bustype        = BUS_PARALLEL,
2031                 .manufacture_id = ATMEL_ID,
2032                 .model_id       = ATMEL_AT29C020,
2033                 .total_size     = 256,
2034                 .page_size      = 256,
2035                 .feature_bits   = FEATURE_LONG_RESET,
2036                 .tested         = TEST_UNTESTED,
2037                 .probe          = probe_jedec,
2038                 .probe_timing   = 10000,                        /* 10ms */
2039                 .block_erasers  =
2040                 {
2041                         {
2042                                 .eraseblocks = { {256 * 1024, 1} },
2043                                 .block_erase = erase_chip_block_jedec,
2044                         }
2045                 },
2046                 .write          = write_jedec,
2047                 .read           = read_memmapped,
2048                 .voltage        = {4500, 5500},
2049         },
2050
2051         {
2052                 .vendor         = "Atmel",
2053                 .name           = "AT29C040A",
2054                 .bustype        = BUS_PARALLEL,
2055                 .manufacture_id = ATMEL_ID,
2056                 .model_id       = ATMEL_AT29C040A,
2057                 .total_size     = 512,
2058                 .page_size      = 256,
2059                 .feature_bits   = FEATURE_LONG_RESET,
2060                 .tested         = TEST_UNTESTED,
2061                 .probe          = probe_jedec,
2062                 .probe_timing   = 10000,                        /* 10 ms */
2063                 .block_erasers  =
2064                 {
2065                         {
2066                                 .eraseblocks = { {512 * 1024, 1} },
2067                                 .block_erase = erase_chip_block_jedec,
2068                         }
2069                 },
2070                 .write          = write_jedec,
2071                 .read           = read_memmapped,
2072                 .voltage        = {4500, 5500},
2073         },
2074
2075         {
2076                 .vendor         = "Atmel",
2077                 .name           = "AT45CS1282",
2078                 .bustype        = BUS_SPI,
2079                 .manufacture_id = ATMEL_ID,
2080                 .model_id       = ATMEL_AT45CS1282,
2081                 .total_size     = 16896 /* No power of two sizes */,
2082                 .page_size      = 1056 /* No power of two sizes */,
2083                 /* does not support EWSR nor WREN and has no writable status register bits whatsoever */
2084                 .tested         = TEST_BAD_READ,
2085                 .probe          = probe_spi_rdid,
2086                 .probe_timing   = TIMING_ZERO,
2087                 .write          = NULL /* Incompatible Page write */,
2088                 .read           = NULL /* Incompatible read */,
2089                 .voltage        = {2700, 3600},
2090         },
2091
2092         {
2093                 .vendor         = "Atmel",
2094                 .name           = "AT45DB011D",
2095                 .bustype        = BUS_SPI,
2096                 .manufacture_id = ATMEL_ID,
2097                 .model_id       = ATMEL_AT45DB011D,
2098                 .total_size     = 128 /* Size can only be determined from status register */,
2099                 .page_size      = 256 /* Size can only be determined from status register */,
2100                 /* does not support EWSR nor WREN and has no writable status register bits whatsoever */
2101                 .tested         = TEST_BAD_READ,
2102                 .probe          = probe_spi_rdid,
2103                 .probe_timing   = TIMING_ZERO,
2104                 .write          = NULL,
2105                 .read           = NULL,
2106                 .voltage        = {2700, 3600},
2107         },
2108
2109         {
2110                 .vendor         = "Atmel",
2111                 .name           = "AT45DB021D",
2112                 .bustype        = BUS_SPI,
2113                 .manufacture_id = ATMEL_ID,
2114                 .model_id       = ATMEL_AT45DB021D,
2115                 .total_size     = 256 /* Size can only be determined from status register */,
2116                 .page_size      = 256 /* Size can only be determined from status register */,
2117                 /* does not support EWSR nor WREN and has no writable status register bits whatsoever */
2118                 .tested         = TEST_BAD_READ,
2119                 .probe          = probe_spi_rdid,
2120                 .probe_timing   = TIMING_ZERO,
2121                 .write          = NULL,
2122                 .read           = NULL,
2123                 .voltage        = {2700, 3600},
2124         },
2125
2126         {
2127                 .vendor         = "Atmel",
2128                 .name           = "AT45DB041D",
2129                 .bustype        = BUS_SPI,
2130                 .manufacture_id = ATMEL_ID,
2131                 .model_id       = ATMEL_AT45DB041D,
2132                 .total_size     = 512 /* Size can only be determined from status register */,
2133                 .page_size      = 256 /* Size can only be determined from status register */,
2134                 /* does not support EWSR nor WREN and has no writable status register bits whatsoever */
2135                 .tested         = TEST_BAD_READ,
2136                 .probe          = probe_spi_rdid,
2137                 .probe_timing   = TIMING_ZERO,
2138                 .write          = NULL,
2139                 .read           = NULL,
2140                 .voltage        = {2500, 3600}, /* 2.5-3.6V & 2.7-3.6V models available */
2141         },
2142
2143         {
2144                 .vendor         = "Atmel",
2145                 .name           = "AT45DB081D",
2146                 .bustype        = BUS_SPI,
2147                 .manufacture_id = ATMEL_ID,
2148                 .model_id       = ATMEL_AT45DB081D,
2149                 .total_size     = 1024 /* Size can only be determined from status register */,
2150                 .page_size      = 256 /* Size can only be determined from status register */,
2151                 /* does not support EWSR nor WREN and has no writable status register bits whatsoever */
2152                 .tested         = TEST_BAD_READ,
2153                 .probe          = probe_spi_rdid,
2154                 .probe_timing   = TIMING_ZERO,
2155                 .write          = NULL,
2156                 .read           = NULL,
2157                 .voltage        = {2700, 3600}, /* 2.5-3.6V & 2.7-3.6V models available */
2158         },
2159
2160         {
2161                 .vendor         = "Atmel",
2162                 .name           = "AT45DB161D",
2163                 .bustype        = BUS_SPI,
2164                 .manufacture_id = ATMEL_ID,
2165                 .model_id       = ATMEL_AT45DB161D,
2166                 .total_size     = 2048 /* Size can only be determined from status register */,
2167                 .page_size      = 512 /* Size can only be determined from status register */,
2168                 /* does not support EWSR nor WREN and has no writable status register bits whatsoever */
2169                 .tested         = TEST_BAD_READ,
2170                 .probe          = probe_spi_rdid,
2171                 .probe_timing   = TIMING_ZERO,
2172                 .write          = NULL,
2173                 .read           = NULL,
2174                 .voltage        = {2700, 3600}, /* 2.5-3.6V & 2.7-3.6V models available */
2175         },
2176
2177         {
2178                 .vendor         = "Atmel",
2179                 .name           = "AT45DB321C",
2180                 .bustype        = BUS_SPI,
2181                 .manufacture_id = ATMEL_ID,
2182                 .model_id       = ATMEL_AT45DB321C,
2183                 .total_size     = 4224 /* No power of two sizes */,
2184                 .page_size      = 528 /* No power of two sizes */,
2185                 /* does not support EWSR nor WREN and has no writable status register bits whatsoever */
2186                 .tested         = TEST_BAD_READ,
2187                 .probe          = probe_spi_rdid,
2188                 .probe_timing   = TIMING_ZERO,
2189                 .write          = NULL,
2190                 .read           = NULL /* Incompatible read */,
2191                 .voltage        = {2700, 3600},
2192         },
2193
2194         {
2195                 .vendor         = "Atmel",
2196                 .name           = "AT45DB321D",
2197                 .bustype        = BUS_SPI,
2198                 .manufacture_id = ATMEL_ID,
2199                 .model_id       = ATMEL_AT45DB321D,
2200                 .total_size     = 4096 /* Size can only be determined from status register */,
2201                 .page_size      = 512 /* Size can only be determined from status register */,
2202                 /* OTP: 128B total, 64B pre-programmed; read 0x77; write 0x9B */
2203                 /* does not support EWSR nor WREN and has no writable status register bits whatsoever */
2204                 .feature_bits   = FEATURE_OTP,
2205                 .tested         = TEST_BAD_READ,
2206                 .probe          = probe_spi_rdid,
2207                 .probe_timing   = TIMING_ZERO,
2208                 .write          = NULL,
2209                 .read           = NULL,
2210                 .voltage        = {2700, 3600},
2211         },
2212
2213         {
2214                 .vendor         = "Atmel",
2215                 .name           = "AT45DB642D",
2216                 .bustype        = BUS_SPI,
2217                 .manufacture_id = ATMEL_ID,
2218                 .model_id       = ATMEL_AT45DB642D,
2219                 .total_size     = 8192 /* Size can only be determined from status register */,
2220                 .page_size      = 1024 /* Size can only be determined from status register */,
2221                 /* does not support EWSR nor WREN and has no writable status register bits whatsoever */
2222                 .tested         = TEST_BAD_READ,
2223                 .probe          = probe_spi_rdid,
2224                 .probe_timing   = TIMING_ZERO,
2225                 .write          = NULL,
2226                 .read           = NULL,
2227                 .voltage        = {2700, 3600},
2228         },
2229
2230         {
2231                 .vendor         = "Atmel",
2232                 .name           = "AT49BV512",
2233                 .bustype        = BUS_PARALLEL,
2234                 .manufacture_id = ATMEL_ID,
2235                 .model_id       = ATMEL_AT49BV512,
2236                 .total_size     = 64,
2237                 .page_size      = 64,
2238                 .feature_bits   = FEATURE_EITHER_RESET,
2239                 .tested         = TEST_OK_PREW,
2240                 .probe          = probe_jedec,
2241                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
2242                 .block_erasers  =
2243                 {
2244                         {
2245                                 .eraseblocks = { {64 * 1024, 1} },
2246                                 .block_erase = erase_chip_block_jedec,
2247                         }
2248                 },
2249                 .write          = write_jedec_1,
2250                 .read           = read_memmapped,
2251                 .voltage        = {2700, 3600},
2252         },
2253
2254         {
2255                 .vendor         = "Atmel",
2256                 .name           = "AT49F002(N)",
2257                 .bustype        = BUS_PARALLEL,
2258                 .manufacture_id = ATMEL_ID,
2259                 .model_id       = ATMEL_AT49F002N,
2260                 .total_size     = 256,
2261                 .page_size      = 256,
2262                 .feature_bits   = FEATURE_EITHER_RESET,
2263                 .tested         = TEST_UNTESTED,
2264                 .probe          = probe_jedec,
2265                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
2266                 .block_erasers  =
2267                 {
2268                         {
2269                                 .eraseblocks = {
2270                                         {16 * 1024, 1},
2271                                         {8 * 1024, 2},
2272                                         {96 * 1024, 1},
2273                                         {128 * 1024, 1},
2274                                 },
2275                                 .block_erase = erase_sector_jedec,
2276                         }, {
2277                                 .eraseblocks = { {256 * 1024, 1} },
2278                                 .block_erase = erase_chip_block_jedec,
2279                         }
2280                 },
2281                 .write          = write_jedec_1,
2282                 .read           = read_memmapped,
2283                 .voltage        = {4500, 5500},
2284         },
2285
2286         {
2287                 .vendor         = "Atmel",
2288                 .name           = "AT49F002(N)T",
2289                 .bustype        = BUS_PARALLEL,
2290                 .manufacture_id = ATMEL_ID,
2291                 .model_id       = ATMEL_AT49F002NT,
2292                 .total_size     = 256,
2293                 .page_size      = 256,
2294                 .feature_bits   = FEATURE_EITHER_RESET,
2295                 .tested         = TEST_OK_PR,
2296                 .probe          = probe_jedec,
2297                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
2298                 .block_erasers  =
2299                 {
2300                         {
2301                                 .eraseblocks = {
2302                                         {128 * 1024, 1},
2303                                         {96 * 1024, 1},
2304                                         {8 * 1024, 2},
2305                                         {16 * 1024, 1},
2306                                 },
2307                                 .block_erase = erase_sector_jedec,
2308                         }, {
2309                                 .eraseblocks = { {256 * 1024, 1} },
2310                                 .block_erase = erase_chip_block_jedec,
2311                         }
2312                 },
2313                 .write          = write_jedec_1,
2314                 .read           = read_memmapped,
2315                 .voltage        = {4500, 5500},
2316         },
2317
2318         {
2319                 .vendor         = "Atmel",
2320                 .name           = "AT49F020",
2321                 .bustype        = BUS_PARALLEL,
2322                 .manufacture_id = ATMEL_ID,
2323                 .model_id       = ATMEL_AT49F020,
2324                 .total_size     = 256,
2325                 .page_size      = 256,
2326                 .feature_bits   = FEATURE_EITHER_RESET,
2327                 .tested         = TEST_OK_PRE,
2328                 .probe          = probe_jedec,
2329                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
2330                 .block_erasers  =
2331                 {
2332                         {
2333                                 .eraseblocks = { {256 * 1024, 1} },
2334                                 .block_erase = erase_chip_block_jedec,
2335                         }
2336                         /* Chip features an optional permanent write protection
2337                          * of the first 8 kB. The erase function is the same as
2338                          * above, but 00000H to 01FFFH will not be erased.
2339                          * FIXME: add another eraser when partial erasers are
2340                          * supported.
2341                          */
2342                 },
2343                 .printlock      = printlock_at49f,
2344                 .write          = write_jedec_1,
2345                 .read           = read_memmapped,
2346                 .voltage        = {4500, 5500},
2347         },
2348
2349         {
2350                 .vendor         = "Atmel",
2351                 .name           = "AT49F040",
2352                 .bustype        = BUS_PARALLEL,
2353                 .manufacture_id = ATMEL_ID,
2354                 .model_id       = ATMEL_AT49F040,
2355                 .total_size     = 512,
2356                 .page_size      = 512,
2357                 .feature_bits   = FEATURE_EITHER_RESET,
2358                 .tested         = TEST_UNTESTED,
2359                 .probe          = probe_jedec,
2360                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
2361                 .block_erasers  =
2362                 {
2363                         {
2364                                 .eraseblocks = { {512 * 1024, 1} },
2365                                 .block_erase = erase_chip_block_jedec,
2366                         }
2367                         /* Chip features an optional permanent write protection
2368                          * of the first 16 kB. The erase function is the same as
2369                          * above, but 00000H to 03FFFH will not be erased.
2370                          * FIXME: add another eraser when partial erasers are
2371                          * supported.
2372                          */
2373                 },
2374                 .printlock      = printlock_at49f,
2375                 .write          = write_jedec_1,
2376                 .read           = read_memmapped,
2377                 .voltage        = {4500, 5500},
2378         },
2379
2380         {
2381                 .vendor         = "Atmel",
2382                 .name           = "AT49LH002",
2383                 .bustype        = BUS_LPC | BUS_FWH, /* A/A Mux */
2384                 .manufacture_id = ATMEL_ID,
2385                 .model_id       = ATMEL_AT49LH002,
2386                 .total_size     = 256,
2387                 .page_size      = 0, /* unused */
2388                 .feature_bits   = FEATURE_REGISTERMAP, /* TODO: LPC OK too? */
2389                 .tested         = TEST_UNTESTED,
2390                 .probe          = probe_82802ab, /* TODO: 0xff cmd not documented? */
2391                 .probe_timing   = TIMING_FIXME,
2392                 .block_erasers  =
2393                 {
2394                         {
2395                                 .eraseblocks = {
2396                                         {64 * 1024, 3},
2397                                         {32 * 1024, 1},
2398                                         {8 * 1024, 2},
2399                                         {16 * 1024, 1},
2400                                 },
2401                                 .block_erase = erase_block_82802ab,
2402                         }, {
2403                                 .eraseblocks = {
2404                                         {64 * 1024, 4},
2405                                 },
2406                                 .block_erase = NULL, /* TODO: Implement. */
2407                         },
2408                 },
2409                 .printlock      = NULL, /* TODO */
2410                 .unlock         = NULL, /* unlock_82802ab() not correct(?) */
2411                 .write          = write_82802ab,
2412                 .read           = read_memmapped,
2413                 .voltage        = {3000, 3600},
2414         },
2415
2416         {
2417                 .vendor         = "Catalyst",
2418                 .name           = "CAT28F512",
2419                 .bustype        = BUS_PARALLEL,
2420                 .manufacture_id = CATALYST_ID,
2421                 .model_id       = CATALYST_CAT28F512,
2422                 .total_size     = 64,
2423                 .page_size      = 0, /* unused */
2424                 .feature_bits   = 0,
2425                 .tested         = TEST_OK_PR,
2426                 .probe          = probe_jedec, /* FIXME! */
2427                 .probe_timing   = TIMING_ZERO,
2428                 .block_erasers  =
2429                 {
2430                         {
2431                                 .eraseblocks = { {64 * 1024, 1} },
2432                                 .block_erase = NULL, /* TODO */
2433                         },
2434                 },
2435                 .write          = NULL, /* TODO */
2436                 .read           = read_memmapped,
2437                 .voltage        = {4500, 5500},
2438         },
2439
2440         {
2441                 .vendor         = "Bright",
2442                 .name           = "BM29F040",
2443                 .bustype        = BUS_PARALLEL,
2444                 .manufacture_id = BRIGHT_ID,
2445                 .model_id       = BRIGHT_BM29F040,
2446                 .total_size     = 512,
2447                 .page_size      = 64 * 1024,
2448                 .feature_bits   = FEATURE_EITHER_RESET,
2449                 .tested         = TEST_OK_PR,
2450                 .probe          = probe_jedec,
2451                 .probe_timing   = TIMING_ZERO,
2452                 .block_erasers  =
2453                 {
2454                         {
2455                                 .eraseblocks = { {64 * 1024, 8} },
2456                                 .block_erase = erase_sector_jedec,
2457                         }, {
2458                                 .eraseblocks = { {512 * 1024, 1} },
2459                                 .block_erase = erase_chip_block_jedec,
2460                         },
2461                 },
2462                 .write          = write_jedec_1,
2463                 .read           = read_memmapped,
2464                 .voltage        = {4500, 5500},
2465         },
2466
2467         {
2468                 .vendor         = "EMST",
2469                 .name           = "F49B002UA",
2470                 .bustype        = BUS_PARALLEL,
2471                 .manufacture_id = EMST_ID,
2472                 .model_id       = EMST_F49B002UA,
2473                 .total_size     = 256,
2474                 .page_size      = 4096,
2475                 .feature_bits   = FEATURE_EITHER_RESET,
2476                 .tested         = TEST_UNTESTED,
2477                 .probe          = probe_jedec,
2478                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
2479                 .block_erasers  =
2480                 {
2481                         {
2482                                 .eraseblocks = {
2483                                         {128 * 1024, 1},
2484                                         {96 * 1024, 1},
2485                                         {8 * 1024, 2},
2486                                         {16 * 1024, 1},
2487                                 },
2488                                 .block_erase = erase_sector_jedec,
2489                         }, {
2490                                 .eraseblocks = { {256 * 1024, 1} },
2491                                 .block_erase = erase_chip_block_jedec,
2492                         }
2493                 },
2494                 .write          = write_jedec_1,
2495                 .read           = read_memmapped,
2496                 .voltage        = {4500, 5500},
2497         },
2498
2499         {
2500                 .vendor         = "EMST",
2501                 .name           = "F25L008A",
2502                 .bustype        = BUS_SPI,
2503                 .manufacture_id = EMST_ID,
2504                 .model_id       = EMST_F25L008A,
2505                 .total_size     = 1024,
2506                 .page_size      = 256,
2507                 .feature_bits   = FEATURE_WRSR_EITHER,
2508                 .tested         = TEST_UNTESTED,
2509                 .probe          = probe_spi_rdid,
2510                 .probe_timing   = TIMING_ZERO,
2511                 .block_erasers  =
2512                 {
2513                         {
2514                                 .eraseblocks = { {4 * 1024, 256} },
2515                                 .block_erase = spi_block_erase_20,
2516                         }, {
2517                                 .eraseblocks = { {64 * 1024, 16} },
2518                                 .block_erase = spi_block_erase_d8,
2519                         }, {
2520                                 .eraseblocks = { {1024 * 1024, 1} },
2521                                 .block_erase = spi_block_erase_60,
2522                         }, {
2523                                 .eraseblocks = { {1024 * 1024, 1} },
2524                                 .block_erase = spi_block_erase_c7,
2525                         }
2526                 },
2527                 .unlock         = spi_disable_blockprotect,
2528                 .write          = spi_chip_write_1,
2529                 .read           = spi_chip_read,
2530                 .voltage        = {2700, 3600},
2531         },
2532
2533         {
2534                 .vendor         = "Eon",
2535                 .name           = "EN25B05",
2536                 .bustype        = BUS_SPI,
2537                 .manufacture_id = EON_ID_NOPREFIX,
2538                 .model_id       = EON_EN25B05,
2539                 .total_size     = 64,
2540                 .page_size      = 256,
2541                 .feature_bits   = FEATURE_WRSR_WREN,
2542                 .tested         = TEST_UNTESTED,
2543                 .probe          = probe_spi_rdid,
2544                 .probe_timing   = TIMING_ZERO,
2545                 .block_erasers  =
2546                 {
2547                         {
2548                                 .eraseblocks = {
2549                                         {4 * 1024, 2},
2550                                         {8 * 1024, 1},
2551                                         {16 * 1024, 1},
2552                                         {32 * 1024, 1},
2553                                 },
2554                                 .block_erase = spi_block_erase_d8,
2555                         }, {
2556                                 .eraseblocks = { {64 * 1024, 1} },
2557                                 .block_erase = spi_block_erase_c7,
2558                         }
2559                 },
2560                 .unlock         = spi_disable_blockprotect,
2561                 .write          = spi_chip_write_256,
2562                 .read           = spi_chip_read,
2563                 .voltage        = {2700, 3600},
2564         },
2565
2566         {
2567                 .vendor         = "Eon",
2568                 .name           = "EN25B05T",
2569                 .bustype        = BUS_SPI,
2570                 .manufacture_id = EON_ID_NOPREFIX,
2571                 .model_id       = EON_EN25B05,
2572                 .total_size     = 64,
2573                 .page_size      = 256,
2574                 .feature_bits   = FEATURE_WRSR_WREN,
2575                 .tested         = TEST_UNTESTED,
2576                 .probe          = probe_spi_rdid,
2577                 .probe_timing   = TIMING_ZERO,
2578                 .block_erasers  =
2579                 {
2580                         {
2581                                 .eraseblocks = {
2582                                         {32 * 1024, 1},
2583                                         {16 * 1024, 1},
2584                                         {8 * 1024, 1},
2585                                         {4 * 1024, 2},
2586                                 },
2587                                 .block_erase = spi_block_erase_d8,
2588                         }, {
2589                                 .eraseblocks = { {64 * 1024, 1} },
2590                                 .block_erase = spi_block_erase_c7,
2591                         }
2592                 },
2593                 .unlock         = spi_disable_blockprotect,
2594                 .write          = spi_chip_write_256,
2595                 .read           = spi_chip_read,
2596                 .voltage        = {2700, 3600},
2597         },
2598
2599         {
2600                 .vendor         = "Eon",
2601                 .name           = "EN25B10",
2602                 .bustype        = BUS_SPI,
2603                 .manufacture_id = EON_ID_NOPREFIX,
2604                 .model_id       = EON_EN25B10,
2605                 .total_size     = 128,
2606                 .page_size      = 256,
2607                 .feature_bits   = FEATURE_WRSR_WREN,
2608                 .tested         = TEST_UNTESTED,
2609                 .probe          = probe_spi_rdid,
2610                 .probe_timing   = TIMING_ZERO,
2611                 .block_erasers  =
2612                 {
2613                         {
2614                                 .eraseblocks = {
2615                                         {4 * 1024, 2},
2616                                         {8 * 1024, 1},
2617                                         {16 * 1024, 1},
2618                                         {32 * 1024, 3},
2619                                 },
2620                                 .block_erase = spi_block_erase_d8,
2621                         }, {
2622                                 .eraseblocks = { {128 * 1024, 1} },
2623                                 .block_erase = spi_block_erase_c7,
2624                         }
2625                 },
2626                 .unlock         = spi_disable_blockprotect,
2627                 .write          = spi_chip_write_256,
2628                 .read           = spi_chip_read,
2629                 .voltage        = {2700, 3600},
2630         },
2631
2632         {
2633                 .vendor         = "Eon",
2634                 .name           = "EN25B10T",
2635                 .bustype        = BUS_SPI,
2636                 .manufacture_id = EON_ID_NOPREFIX,
2637                 .model_id       = EON_EN25B10,
2638                 .total_size     = 128,
2639                 .page_size      = 256,
2640                 .feature_bits   = FEATURE_WRSR_WREN,
2641                 .tested         = TEST_UNTESTED,
2642                 .probe          = probe_spi_rdid,
2643                 .probe_timing   = TIMING_ZERO,
2644                 .block_erasers  =
2645                 {
2646                         {
2647                                 .eraseblocks = {
2648                                         {32 * 1024, 3},
2649                                         {16 * 1024, 1},
2650                                         {8 * 1024, 1},
2651                                         {4 * 1024, 2},
2652                                 },
2653                                 .block_erase = spi_block_erase_d8,
2654                         }, {
2655                                 .eraseblocks = { {128 * 1024, 1} },
2656                                 .block_erase = spi_block_erase_c7,
2657                         }
2658                 },
2659                 .unlock         = spi_disable_blockprotect,
2660                 .write          = spi_chip_write_256,
2661                 .read           = spi_chip_read,
2662                 .voltage        = {2700, 3600},
2663         },
2664
2665         {
2666                 .vendor         = "Eon",
2667                 .name           = "EN25B20",
2668                 .bustype        = BUS_SPI,
2669                 .manufacture_id = EON_ID_NOPREFIX,
2670                 .model_id       = EON_EN25B20,
2671                 .total_size     = 256,
2672                 .page_size      = 256,
2673                 .feature_bits   = FEATURE_WRSR_WREN,
2674                 .tested         = TEST_UNTESTED,
2675                 .probe          = probe_spi_rdid,
2676                 .probe_timing   = TIMING_ZERO,
2677                 .block_erasers  =
2678                 {
2679                         {
2680                                 .eraseblocks = {
2681                                         {4 * 1024, 2},
2682                                         {8 * 1024, 1},
2683                                         {16 * 1024, 1},
2684                                         {32 * 1024, 1},
2685                                         {64 * 1024, 3}
2686                                 },
2687                                 .block_erase = spi_block_erase_d8,
2688                         }, {
2689                                 .eraseblocks = { {256 * 1024, 1} },
2690                                 .block_erase = spi_block_erase_c7,
2691                         }
2692                 },
2693                 .unlock         = spi_disable_blockprotect,
2694                 .write          = spi_chip_write_256,
2695                 .read           = spi_chip_read,
2696                 .voltage        = {2700, 3600},
2697         },
2698
2699         {
2700                 .vendor         = "Eon",
2701                 .name           = "EN25B20T",
2702                 .bustype        = BUS_SPI,
2703                 .manufacture_id = EON_ID_NOPREFIX,
2704                 .model_id       = EON_EN25B20,
2705                 .total_size     = 256,
2706                 .page_size      = 256,
2707                 .feature_bits   = FEATURE_WRSR_WREN,
2708                 .tested         = TEST_UNTESTED,
2709                 .probe          = probe_spi_rdid,
2710                 .probe_timing   = TIMING_ZERO,
2711                 .block_erasers  =
2712                 {
2713                         {
2714                                 .eraseblocks = {
2715                                         {64 * 1024, 3},
2716                                         {32 * 1024, 1},
2717                                         {16 * 1024, 1},
2718                                         {8 * 1024, 1},
2719                                         {4 * 1024, 2},
2720                                 },
2721                                 .block_erase = spi_block_erase_d8,
2722                         }, {
2723                                 .eraseblocks = { {256 * 1024, 1} },
2724                                 .block_erase = spi_block_erase_c7,
2725                         }
2726                 },
2727                 .unlock         = spi_disable_blockprotect,
2728                 .write          = spi_chip_write_256,
2729                 .read           = spi_chip_read,
2730                 .voltage        = {2700, 3600},
2731         },
2732
2733         {
2734                 .vendor         = "Eon",
2735                 .name           = "EN25B40",
2736                 .bustype        = BUS_SPI,
2737                 .manufacture_id = EON_ID_NOPREFIX,
2738                 .model_id       = EON_EN25B40,
2739                 .total_size     = 512,
2740                 .page_size      = 256,
2741                 .feature_bits   = FEATURE_WRSR_WREN,
2742                 .tested         = TEST_UNTESTED,
2743                 .probe          = probe_spi_rdid,
2744                 .probe_timing   = TIMING_ZERO,
2745                 .block_erasers  =
2746                 {
2747                         {
2748                                 .eraseblocks = {
2749                                         {4 * 1024, 2},
2750                                         {8 * 1024, 1},
2751                                         {16 * 1024, 1},
2752                                         {32 * 1024, 1},
2753                                         {64 * 1024, 7}
2754                                 },
2755                                 .block_erase = spi_block_erase_d8,
2756                         }, {
2757                                 .eraseblocks = { {512 * 1024, 1} },
2758                                 .block_erase = spi_block_erase_c7,
2759                         }
2760                 },
2761                 .unlock         = spi_disable_blockprotect,
2762                 .write          = spi_chip_write_256,
2763                 .read           = spi_chip_read,
2764                 .voltage        = {2700, 3600},
2765         },
2766
2767         {
2768                 .vendor         = "Eon",
2769                 .name           = "EN25B40T",
2770                 .bustype        = BUS_SPI,
2771                 .manufacture_id = EON_ID_NOPREFIX,
2772                 .model_id       = EON_EN25B40,
2773                 .total_size     = 512,
2774                 .page_size      = 256,
2775                 .feature_bits   = FEATURE_WRSR_WREN,
2776                 .tested         = TEST_UNTESTED,
2777                 .probe          = probe_spi_rdid,
2778                 .probe_timing   = TIMING_ZERO,
2779                 .block_erasers  =
2780                 {
2781                         {
2782                                 .eraseblocks = {
2783                                         {64 * 1024, 7},
2784                                         {32 * 1024, 1},
2785                                         {16 * 1024, 1},
2786                                         {8 * 1024, 1},
2787                                         {4 * 1024, 2},
2788                                 },
2789                                 .block_erase = spi_block_erase_d8,
2790                         }, {
2791                                 .eraseblocks = { {512 * 1024, 1} },
2792                                 .block_erase = spi_block_erase_c7,
2793                         }
2794                 },
2795                 .unlock         = spi_disable_blockprotect,
2796                 .write          = spi_chip_write_256,
2797                 .read           = spi_chip_read,
2798                 .voltage        = {2700, 3600},
2799         },
2800
2801         {
2802                 .vendor         = "Eon",
2803                 .name           = "EN25B80",
2804                 .bustype        = BUS_SPI,
2805                 .manufacture_id = EON_ID_NOPREFIX,
2806                 .model_id       = EON_EN25B80,
2807                 .total_size     = 1024,
2808                 .page_size      = 256,
2809                 .feature_bits   = FEATURE_WRSR_WREN,
2810                 .tested         = TEST_UNTESTED,
2811                 .probe          = probe_spi_rdid,
2812                 .probe_timing   = TIMING_ZERO,
2813                 .block_erasers  =
2814                 {
2815                         {
2816                                 .eraseblocks = {
2817                                         {4 * 1024, 2},
2818                                         {8 * 1024, 1},
2819                                         {16 * 1024, 1},
2820                                         {32 * 1024, 1},
2821                                         {64 * 1024, 15}
2822                                 },
2823                                 .block_erase = spi_block_erase_d8,
2824                         }, {
2825                                 .eraseblocks = { {1024 * 1024, 1} },
2826                                 .block_erase = spi_block_erase_c7,
2827                         }
2828                 },
2829                 .unlock         = spi_disable_blockprotect,
2830                 .write          = spi_chip_write_256,
2831                 .read           = spi_chip_read,
2832                 .voltage        = {2700, 3600},
2833         },
2834
2835         {
2836                 .vendor         = "Eon",
2837                 .name           = "EN25B80T",
2838                 .bustype        = BUS_SPI,
2839                 .manufacture_id = EON_ID_NOPREFIX,
2840                 .model_id       = EON_EN25B80,
2841                 .total_size     = 1024,
2842                 .page_size      = 256,
2843                 .feature_bits   = FEATURE_WRSR_WREN,
2844                 .tested         = TEST_UNTESTED,
2845                 .probe          = probe_spi_rdid,
2846                 .probe_timing   = TIMING_ZERO,
2847                 .block_erasers  =
2848                 {
2849                         {
2850                                 .eraseblocks = {
2851                                         {64 * 1024, 15},
2852                                         {32 * 1024, 1},
2853                                         {16 * 1024, 1},
2854                                         {8 * 1024, 1},
2855                                         {4 * 1024, 2},
2856                                 },
2857                                 .block_erase = spi_block_erase_d8,
2858                         }, {
2859                                 .eraseblocks = { {1024 * 1024, 1} },
2860                                 .block_erase = spi_block_erase_c7,
2861                         }
2862                 },
2863                 .unlock         = spi_disable_blockprotect,
2864                 .write          = spi_chip_write_256,
2865                 .read           = spi_chip_read,
2866                 .voltage        = {2700, 3600},
2867         },
2868
2869         {
2870                 .vendor         = "Eon",
2871                 .name           = "EN25B16",
2872                 .bustype        = BUS_SPI,
2873                 .manufacture_id = EON_ID_NOPREFIX,
2874                 .model_id       = EON_EN25B16,
2875                 .total_size     = 2048,
2876                 .page_size      = 256,
2877                 .feature_bits   = FEATURE_WRSR_WREN,
2878                 .tested         = TEST_UNTESTED,
2879                 .probe          = probe_spi_rdid,
2880                 .probe_timing   = TIMING_ZERO,
2881                 .block_erasers  =
2882                 {
2883                         {
2884                                 .eraseblocks = {
2885                                         {4 * 1024, 2},
2886                                         {8 * 1024, 1},
2887                                         {16 * 1024, 1},
2888                                         {32 * 1024, 1},
2889                                         {64 * 1024, 31},
2890                                 },
2891                                 .block_erase = spi_block_erase_d8,
2892                         }, {
2893                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
2894                                 .block_erase = spi_block_erase_c7,
2895                         }
2896                 },
2897                 .unlock         = spi_disable_blockprotect,
2898                 .write          = spi_chip_write_256,
2899                 .read           = spi_chip_read,
2900                 .voltage        = {2700, 3600},
2901         },
2902
2903         {
2904                 .vendor         = "Eon",
2905                 .name           = "EN25B16T",
2906                 .bustype        = BUS_SPI,
2907                 .manufacture_id = EON_ID_NOPREFIX,
2908                 .model_id       = EON_EN25B16,
2909                 .total_size     = 2048,
2910                 .page_size      = 256,
2911                 .feature_bits   = FEATURE_WRSR_WREN,
2912                 .tested         = TEST_UNTESTED,
2913                 .probe          = probe_spi_rdid,
2914                 .probe_timing   = TIMING_ZERO,
2915                 .block_erasers  =
2916                 {
2917                         {
2918                                 .eraseblocks = {
2919                                         {64 * 1024, 31},
2920                                         {32 * 1024, 1},
2921                                         {16 * 1024, 1},
2922                                         {8 * 1024, 1},
2923                                         {4 * 1024, 2},
2924                                 },
2925                                 .block_erase = spi_block_erase_d8,
2926                         }, {
2927                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
2928                                 .block_erase = spi_block_erase_c7,
2929                         }
2930                 },
2931                 .unlock         = spi_disable_blockprotect,
2932                 .write          = spi_chip_write_256,
2933                 .read           = spi_chip_read,
2934                 .voltage        = {2700, 3600},
2935         },
2936
2937         {
2938                 .vendor         = "Eon",
2939                 .name           = "EN25B32",
2940                 .bustype        = BUS_SPI,
2941                 .manufacture_id = EON_ID_NOPREFIX,
2942                 .model_id       = EON_EN25B32,
2943                 .total_size     = 4096,
2944                 .page_size      = 256,
2945                 .feature_bits   = FEATURE_WRSR_WREN,
2946                 .tested         = TEST_UNTESTED,
2947                 .probe          = probe_spi_rdid,
2948                 .probe_timing   = TIMING_ZERO,
2949                 .block_erasers  =
2950                 {
2951                         {
2952                                 .eraseblocks = {
2953                                         {4 * 1024, 2},
2954                                         {8 * 1024, 1},
2955                                         {16 * 1024, 1},
2956                                         {32 * 1024, 1},
2957                                         {64 * 1024, 63},
2958                                 },
2959                                 .block_erase = spi_block_erase_d8,
2960                         }, {
2961                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
2962                                 .block_erase = spi_block_erase_c7,
2963                         }
2964                 },
2965                 .unlock         = spi_disable_blockprotect,
2966                 .write          = spi_chip_write_256,
2967                 .read           = spi_chip_read,
2968                 .voltage        = {2700, 3600},
2969         },
2970
2971         {
2972                 .vendor         = "Eon",
2973                 .name           = "EN25B32T",
2974                 .bustype        = BUS_SPI,
2975                 .manufacture_id = EON_ID_NOPREFIX,
2976                 .model_id       = EON_EN25B32,
2977                 .total_size     = 4096,
2978                 .page_size      = 256,
2979                 .feature_bits   = FEATURE_WRSR_WREN,
2980                 .tested         = TEST_UNTESTED,
2981                 .probe          = probe_spi_rdid,
2982                 .probe_timing   = TIMING_ZERO,
2983                 .block_erasers  =
2984                 {
2985                         {
2986                                 .eraseblocks = {
2987                                         {64 * 1024, 63},
2988                                         {32 * 1024, 1},
2989                                         {16 * 1024, 1},
2990                                         {8 * 1024, 1},
2991                                         {4 * 1024, 2},
2992                                 },
2993                                 .block_erase = spi_block_erase_d8,
2994                         }, {
2995                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
2996                                 .block_erase = spi_block_erase_c7,
2997                         }
2998                 },
2999                 .unlock         = spi_disable_blockprotect,
3000                 .write          = spi_chip_write_256,
3001                 .read           = spi_chip_read,
3002                 .voltage        = {2700, 3600},
3003         },
3004
3005         {
3006                 .vendor         = "Eon",
3007                 .name           = "EN25B64",
3008                 .bustype        = BUS_SPI,
3009                 .manufacture_id = EON_ID_NOPREFIX,
3010                 .model_id       = EON_EN25B64,
3011                 .total_size     = 8192,
3012                 .page_size      = 256,
3013                 .feature_bits   = FEATURE_WRSR_WREN,
3014                 .tested         = TEST_UNTESTED,
3015                 .probe          = probe_spi_rdid,
3016                 .probe_timing   = TIMING_ZERO,
3017                 .block_erasers  =
3018                 {
3019                         {
3020                                 .eraseblocks = {
3021                                         {4 * 1024, 2},
3022                                         {8 * 1024, 1},
3023                                         {16 * 1024, 1},
3024                                         {32 * 1024, 1},
3025                                         {64 * 1024, 127},
3026                                 },
3027                                 .block_erase = spi_block_erase_d8,
3028                         }, {
3029                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
3030                                 .block_erase = spi_block_erase_c7,
3031                         }
3032                 },
3033                 .unlock         = spi_disable_blockprotect,
3034                 .write          = spi_chip_write_256,
3035                 .read           = spi_chip_read,
3036                 .voltage        = {2700, 3600},
3037         },
3038
3039         {
3040                 .vendor         = "Eon",
3041                 .name           = "EN25B64T",
3042                 .bustype        = BUS_SPI,
3043                 .manufacture_id = EON_ID_NOPREFIX,
3044                 .model_id       = EON_EN25B64,
3045                 .total_size     = 8192,
3046                 .page_size      = 256,
3047                 .feature_bits   = FEATURE_WRSR_WREN,
3048                 .tested         = TEST_UNTESTED,
3049                 .probe          = probe_spi_rdid,
3050                 .probe_timing   = TIMING_ZERO,
3051                 .block_erasers  =
3052                 {
3053                         {
3054                                 .eraseblocks = {
3055                                         {64 * 1024, 127},
3056                                         {32 * 1024, 1},
3057                                         {16 * 1024, 1},
3058                                         {8 * 1024, 1},
3059                                         {4 * 1024, 2},
3060                                 },
3061                                 .block_erase = spi_block_erase_d8,
3062                         }, {
3063                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
3064                                 .block_erase = spi_block_erase_c7,
3065                         }
3066                 },
3067                 .unlock         = spi_disable_blockprotect,
3068                 .write          = spi_chip_write_256,
3069                 .read           = spi_chip_read,
3070                 .voltage        = {2700, 3600},
3071         },
3072
3073         {
3074                 .vendor         = "Eon",
3075                 .name           = "EN25F05",
3076                 .bustype        = BUS_SPI,
3077                 .manufacture_id = EON_ID_NOPREFIX,
3078                 .model_id       = EON_EN25F05,
3079                 .total_size     = 64,
3080                 .page_size      = 256,
3081                 .feature_bits   = FEATURE_WRSR_WREN,
3082                 .tested         = TEST_UNTESTED,
3083                 .probe          = probe_spi_rdid,
3084                 .probe_timing   = TIMING_ZERO,
3085                 .block_erasers  =
3086                 {
3087                         {
3088                                 .eraseblocks = { {4 * 1024, 16} },
3089                                 .block_erase = spi_block_erase_20,
3090                         }, {
3091                                 .eraseblocks = { {32 * 1024, 2} },
3092                                 .block_erase = spi_block_erase_d8,
3093                         }, {
3094                                 .eraseblocks = { {32 * 1024, 2} },
3095                                 .block_erase = spi_block_erase_52,
3096                         }, {
3097                                 .eraseblocks = { {64 * 1024, 1} },
3098                                 .block_erase = spi_block_erase_60,
3099                         }, {
3100                                 .eraseblocks = { {64 * 1024, 1} },
3101                                 .block_erase = spi_block_erase_c7,
3102                         }
3103                 },
3104                 .unlock         = spi_disable_blockprotect,
3105                 .write          = spi_chip_write_256,
3106                 .read           = spi_chip_read,
3107                 .voltage        = {2700, 3600},
3108         },
3109
3110         {
3111                 .vendor         = "Eon",
3112                 .name           = "EN25F10",
3113                 .bustype        = BUS_SPI,
3114                 .manufacture_id = EON_ID_NOPREFIX,
3115                 .model_id       = EON_EN25F10,
3116                 .total_size     = 128,
3117                 .page_size      = 256,
3118                 .feature_bits   = FEATURE_WRSR_WREN,
3119                 .tested         = TEST_UNTESTED,
3120                 .probe          = probe_spi_rdid,
3121                 .probe_timing   = TIMING_ZERO,
3122                 .block_erasers  =
3123                 {
3124                         {
3125                                 .eraseblocks = { {4 * 1024, 32} },
3126                                 .block_erase = spi_block_erase_20,
3127                         }, {
3128                                 .eraseblocks = { {32 * 1024, 4} },
3129                                 .block_erase = spi_block_erase_d8,
3130                         }, {
3131                                 .eraseblocks = { {32 * 1024, 4} },
3132                                 .block_erase = spi_block_erase_52,
3133                         }, {
3134                                 .eraseblocks = { {128 * 1024, 1} },
3135                                 .block_erase = spi_block_erase_60,
3136                         }, {
3137                                 .eraseblocks = { {128 * 1024, 1} },
3138                                 .block_erase = spi_block_erase_c7,
3139                         }
3140                 },
3141                 .unlock         = spi_disable_blockprotect,
3142                 .write          = spi_chip_write_256,
3143                 .read           = spi_chip_read,
3144                 .voltage        = {2700, 3600},
3145         },
3146
3147         {
3148                 .vendor         = "Eon",
3149                 .name           = "EN25F20",
3150                 .bustype        = BUS_SPI,
3151                 .manufacture_id = EON_ID_NOPREFIX,
3152                 .model_id       = EON_EN25F20,
3153                 .total_size     = 256,
3154                 .page_size      = 256,
3155                 .feature_bits   = FEATURE_WRSR_WREN,
3156                 .tested         = TEST_UNTESTED,
3157                 .probe          = probe_spi_rdid,
3158                 .probe_timing   = TIMING_ZERO,
3159                 .block_erasers  =
3160                 {
3161                         {
3162                                 .eraseblocks = { {4 * 1024, 64} },
3163                                 .block_erase = spi_block_erase_20,
3164                         }, {
3165                                 .eraseblocks = { {64 * 1024, 4} },
3166                                 .block_erase = spi_block_erase_d8,
3167                         }, {
3168                                 .eraseblocks = { {64 * 1024, 4} },
3169                                 .block_erase = spi_block_erase_52,
3170                         }, {
3171                                 .eraseblocks = { {256 * 1024, 1} },
3172                                 .block_erase = spi_block_erase_60,
3173                         }, {
3174                                 .eraseblocks = { {256 * 1024, 1} },
3175                                 .block_erase = spi_block_erase_c7,
3176                         }
3177                 },
3178                 .unlock         = spi_disable_blockprotect,
3179                 .write          = spi_chip_write_256,
3180                 .read           = spi_chip_read,
3181                 .voltage        = {2700, 3600},
3182         },
3183
3184         {
3185                 .vendor         = "Eon",
3186                 .name           = "EN25F40",
3187                 .bustype        = BUS_SPI,
3188                 .manufacture_id = EON_ID_NOPREFIX,
3189                 .model_id       = EON_EN25F40,
3190                 .total_size     = 512,
3191                 .page_size      = 256,
3192                 .feature_bits   = FEATURE_WRSR_WREN,
3193                 .tested         = TEST_OK_PROBE,
3194                 .probe          = probe_spi_rdid,
3195                 .probe_timing   = TIMING_ZERO,
3196                 .block_erasers  =
3197                 {
3198                         {
3199                                 .eraseblocks = { {4 * 1024, 128} },
3200                                 .block_erase = spi_block_erase_20,
3201                         }, {
3202                                 .eraseblocks = { {64 * 1024, 8} },
3203                                 .block_erase = spi_block_erase_d8,
3204                         }, {
3205                                 .eraseblocks = { {512 * 1024, 1} },
3206                                 .block_erase = spi_block_erase_60,
3207                         }, {
3208                                 .eraseblocks = { {512 * 1024, 1} },
3209                                 .block_erase = spi_block_erase_c7,
3210                         },
3211                 },
3212                 .unlock         = spi_disable_blockprotect,
3213                 .write          = spi_chip_write_256,
3214                 .read           = spi_chip_read,
3215                 .voltage        = {2700, 3600},
3216         },
3217
3218         {
3219                 .vendor         = "Eon",
3220                 .name           = "EN25F80",
3221                 .bustype        = BUS_SPI,
3222                 .manufacture_id = EON_ID_NOPREFIX,
3223                 .model_id       = EON_EN25F80,
3224                 .total_size     = 1024,
3225                 .page_size      = 256,
3226                 .feature_bits   = FEATURE_WRSR_WREN,
3227                 .tested         = TEST_OK_PREW,
3228                 .probe          = probe_spi_rdid,
3229                 .probe_timing   = TIMING_ZERO,
3230                 .block_erasers  =
3231                 {
3232                         {
3233                                 .eraseblocks = { {4 * 1024, 256} },
3234                                 .block_erase = spi_block_erase_20,
3235                         }, {
3236                                 .eraseblocks = { {64 * 1024, 16} },
3237                                 .block_erase = spi_block_erase_d8,
3238                         }, {
3239                                 .eraseblocks = { {1024 * 1024, 1} },
3240                                 .block_erase = spi_block_erase_60,
3241                         }, {
3242                                 .eraseblocks = { {1024 * 1024, 1} },
3243                                 .block_erase = spi_block_erase_c7,
3244                         }
3245                 },
3246                 .unlock         = spi_disable_blockprotect,
3247                 .write          = spi_chip_write_256,
3248                 .read           = spi_chip_read,
3249                 .voltage        = {2700, 3600},
3250         },
3251
3252         {
3253                 .vendor         = "Eon",
3254                 .name           = "EN25F16",
3255                 .bustype        = BUS_SPI,
3256                 .manufacture_id = EON_ID_NOPREFIX,
3257                 .model_id       = EON_EN25F16,
3258                 .total_size     = 2048,
3259                 .page_size      = 256,
3260                 .feature_bits   = FEATURE_WRSR_WREN,
3261                 .tested         = TEST_OK_PREW,
3262                 .probe          = probe_spi_rdid,
3263                 .probe_timing   = TIMING_ZERO,
3264                 .block_erasers  =
3265                 {
3266                         {
3267                                 .eraseblocks = { {4 * 1024, 512} },
3268                                 .block_erase = spi_block_erase_20,
3269                         }, {
3270                                 .eraseblocks = { {64 * 1024, 32} },
3271                                 .block_erase = spi_block_erase_d8,
3272                         }, {
3273                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
3274                                 .block_erase = spi_block_erase_60,
3275                         }, {
3276                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
3277                                 .block_erase = spi_block_erase_c7,
3278                         }
3279                 },
3280                 .unlock         = spi_disable_blockprotect,
3281                 .write          = spi_chip_write_256,
3282                 .read           = spi_chip_read,
3283                 .voltage        = {2700, 3600},
3284         },
3285
3286         {
3287                 .vendor         = "Eon",
3288                 .name           = "EN25F32",
3289                 .bustype        = BUS_SPI,
3290                 .manufacture_id = EON_ID_NOPREFIX,
3291                 .model_id       = EON_EN25F32,
3292                 .total_size     = 4096,
3293                 .page_size      = 256,
3294                 .feature_bits   = FEATURE_WRSR_WREN,
3295                 .tested         = TEST_UNTESTED,
3296                 .probe          = probe_spi_rdid,
3297                 .probe_timing   = TIMING_ZERO,
3298                 .block_erasers  =
3299                 {
3300                         {
3301                                 .eraseblocks = { {4 * 1024, 1024} },
3302                                 .block_erase = spi_block_erase_20,
3303                         }, {
3304                                 .eraseblocks = { {64 * 1024, 64} },
3305                                 .block_erase = spi_block_erase_d8,
3306                         }, {
3307                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
3308                                 .block_erase = spi_block_erase_60,
3309                         }, {
3310                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
3311                                 .block_erase = spi_block_erase_c7,
3312                         }
3313                 },
3314                 .unlock         = spi_disable_blockprotect,
3315                 .write          = spi_chip_write_256,
3316                 .read           = spi_chip_read,
3317                 .voltage        = {2700, 3600},
3318         },
3319
3320         {
3321                 .vendor         = "Eon",
3322                 .name           = "EN25Q40",
3323                 .bustype        = BUS_SPI,
3324                 .manufacture_id = EON_ID_NOPREFIX,
3325                 .model_id       = EON_EN25Q40,
3326                 .total_size     = 512,
3327                 .page_size      = 256,
3328                 /* OTP: 256B total; enter 0x3A */
3329                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
3330                 .tested         = TEST_UNTESTED,
3331                 .probe          = probe_spi_rdid,
3332                 .probe_timing   = TIMING_ZERO,
3333                 .block_erasers  =
3334                 {
3335                         {
3336                                 .eraseblocks = { {4 * 1024, 128} },
3337                                 .block_erase = spi_block_erase_20,
3338                         }, {
3339                                 .eraseblocks = { {64 * 1024, 8} },
3340                                 .block_erase = spi_block_erase_d8,
3341                         }, {
3342                                 .eraseblocks = { {512 * 1024, 1} },
3343                                 .block_erase = spi_block_erase_60,
3344                         }, {
3345                                 .eraseblocks = { {512 * 1024, 1} },
3346                                 .block_erase = spi_block_erase_c7,
3347                         }
3348                 },
3349                 .unlock         = spi_disable_blockprotect,
3350                 .write          = spi_chip_write_256,
3351                 .read           = spi_chip_read,
3352                 .voltage        = {2700, 3600},
3353         },
3354
3355         {
3356                 .vendor         = "Eon",
3357                 .name           = "EN25Q80(A)",
3358                 .bustype        = BUS_SPI,
3359                 .manufacture_id = EON_ID_NOPREFIX,
3360                 .model_id       = EON_EN25Q80,
3361                 .total_size     = 1024,
3362                 .page_size      = 256,
3363                 /* OTP: 256B total; enter 0x3A */
3364                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
3365                 .tested         = TEST_UNTESTED,
3366                 .probe          = probe_spi_rdid,
3367                 .probe_timing   = TIMING_ZERO,
3368                 .block_erasers  =
3369                 {
3370                         {
3371                                 .eraseblocks = { {4 * 1024, 256} },
3372                                 .block_erase = spi_block_erase_20,
3373                         }, {
3374                                 .eraseblocks = { {64 * 1024, 16} },
3375                                 .block_erase = spi_block_erase_d8,
3376                         }, {
3377                                 .eraseblocks = { {1024 * 1024, 1} },
3378                                 .block_erase = spi_block_erase_60,
3379                         }, {
3380                                 .eraseblocks = { {1024 * 1024, 1} },
3381                                 .block_erase = spi_block_erase_c7,
3382                         }
3383                 },
3384                 .unlock         = spi_disable_blockprotect,
3385                 .write          = spi_chip_write_256,
3386                 .read           = spi_chip_read,
3387                 .voltage        = {2700, 3600},
3388         },
3389
3390         {
3391                 /* Note: EN25D16 is an evil twin which shares the model ID
3392                    but has different write protection capabilities */
3393                 .vendor         = "Eon",
3394                 .name           = "EN25Q16",
3395                 .bustype        = BUS_SPI,
3396                 .manufacture_id = EON_ID_NOPREFIX,
3397                 .model_id       = EON_EN25Q16,
3398                 .total_size     = 2048,
3399                 .page_size      = 256,
3400                 /* OTP: D16 512B/Q16 128B total; enter 0x3A */
3401                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
3402                 .tested         = TEST_UNTESTED,
3403                 .probe          = probe_spi_rdid,
3404                 .probe_timing   = TIMING_ZERO,
3405                 .block_erasers  =
3406                 {
3407                         {
3408                                 .eraseblocks = { {4 * 1024, 512} },
3409                                 .block_erase = spi_block_erase_20,
3410                         }, {
3411                                 .eraseblocks = { {64 * 1024, 32} },
3412                                 .block_erase = spi_block_erase_d8,
3413                         }, {
3414                                 /* not supported by Q16 version */
3415                                 .eraseblocks = { {64 * 1024, 32} },
3416                                 .block_erase = spi_block_erase_52,
3417                         }, {
3418                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
3419                                 .block_erase = spi_block_erase_60,
3420                         }, {
3421                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
3422                                 .block_erase = spi_block_erase_c7,
3423                         }
3424                 },
3425                 .unlock         = spi_disable_blockprotect,
3426                 .write          = spi_chip_write_256,
3427                 .read           = spi_chip_read,
3428                 .voltage        = {2700, 3600},
3429         },
3430
3431         {
3432                 .vendor         = "Eon",
3433                 .name           = "EN25Q32(A/B)",
3434                 .bustype        = BUS_SPI,
3435                 .manufacture_id = EON_ID_NOPREFIX,
3436                 .model_id       = EON_EN25Q32,
3437                 .total_size     = 4096,
3438                 .page_size      = 256,
3439                 /* OTP: 512B total; enter 0x3A */
3440                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
3441                 .tested         = TEST_OK_PROBE,
3442                 .probe          = probe_spi_rdid,
3443                 .probe_timing   = TIMING_ZERO,
3444                 .block_erasers  =
3445                 {
3446                         {
3447                                 .eraseblocks = { {4 * 1024, 1024} },
3448                                 .block_erase = spi_block_erase_20,
3449                         }, {
3450                                 .eraseblocks = { {64 * 1024, 64} },
3451                                 .block_erase = spi_block_erase_d8,
3452                         }, {
3453                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
3454                                 .block_erase = spi_block_erase_60,
3455                         }, {
3456                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
3457                                 .block_erase = spi_block_erase_c7,
3458                         }
3459                 },
3460                 .unlock         = spi_disable_blockprotect,
3461                 .write          = spi_chip_write_256,
3462                 .read           = spi_chip_read,
3463                 .voltage        = {2700, 3600},
3464         },
3465
3466         {
3467                 .vendor         = "Eon",
3468                 .name           = "EN25Q64",
3469                 .bustype        = BUS_SPI,
3470                 .manufacture_id = EON_ID_NOPREFIX,
3471                 .model_id       = EON_EN25Q64,
3472                 .total_size     = 8192,
3473                 .page_size      = 256,
3474                 /* OTP: 512B total; enter 0x3A */
3475                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
3476                 .tested         = TEST_UNTESTED,
3477                 .probe          = probe_spi_rdid,
3478                 .probe_timing   = TIMING_ZERO,
3479                 .block_erasers  =
3480                 {
3481                         {
3482                                 .eraseblocks = { {4 * 1024, 2048} },
3483                                 .block_erase = spi_block_erase_20,
3484                         }, {
3485                                 .eraseblocks = { {64 * 1024, 128} },
3486                                 .block_erase = spi_block_erase_d8,
3487                         }, {
3488                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
3489                                 .block_erase = spi_block_erase_60,
3490                         }, {
3491                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
3492                                 .block_erase = spi_block_erase_c7,
3493                         }
3494                 },
3495                 .unlock         = spi_disable_blockprotect,
3496                 .write          = spi_chip_write_256,
3497                 .read           = spi_chip_read,
3498                 .voltage        = {2700, 3600},
3499         },
3500
3501         {
3502                 .vendor         = "Eon",
3503                 .name           = "EN25Q128",
3504                 .bustype        = BUS_SPI,
3505                 .manufacture_id = EON_ID_NOPREFIX,
3506                 .model_id       = EON_EN25Q128,
3507                 .total_size     = 16384,
3508                 .page_size      = 256,
3509                 /* OTP: 512B total; enter 0x3A */
3510                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
3511                 .tested         = TEST_UNTESTED,
3512                 .probe          = probe_spi_rdid,
3513                 .probe_timing   = TIMING_ZERO,
3514                 .block_erasers  =
3515                 {
3516                         {
3517                                 .eraseblocks = { {4 * 1024, 4096} },
3518                                 .block_erase = spi_block_erase_20,
3519                         }, {
3520                                 .eraseblocks = { {64 * 1024, 256} },
3521                                 .block_erase = spi_block_erase_d8,
3522                         }, {
3523                                 .eraseblocks = { {16 * 1024 * 1024, 1} },
3524                                 .block_erase = spi_block_erase_60,
3525                         }, {
3526                                 .eraseblocks = { {16 * 1024 * 1024, 1} },
3527                                 .block_erase = spi_block_erase_c7,
3528                         }
3529                 },
3530                 .unlock         = spi_disable_blockprotect,
3531                 .write          = spi_chip_write_256,
3532                 .read           = spi_chip_read,
3533         },
3534
3535         {
3536                 .vendor         = "Eon",
3537                 .name           = "EN25QH16",
3538                 .bustype        = BUS_SPI,
3539                 .manufacture_id = EON_ID_NOPREFIX,
3540                 .model_id       = EON_EN25QH16,
3541                 .total_size     = 2048,
3542                 .page_size      = 256,
3543                 /* supports SFDP */
3544                 /* OTP: 512B total; enter 0x3A */
3545                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
3546                 .tested         = TEST_OK_PR,
3547                 .probe          = probe_spi_rdid,
3548                 .probe_timing   = TIMING_ZERO,
3549                 .block_erasers  =
3550                 {
3551                         {
3552                                 .eraseblocks = { {4 * 1024, 512} },
3553                                 .block_erase = spi_block_erase_20,
3554                         }, {
3555                                 .eraseblocks = { {64 * 1024, 32} },
3556                                 .block_erase = spi_block_erase_d8,
3557                         }, {
3558                                 .eraseblocks = { {1024 * 2048, 1} },
3559                                 .block_erase = spi_block_erase_60,
3560                         }, {
3561                                 .eraseblocks = { {1024 * 2048, 1} },
3562                                 .block_erase = spi_block_erase_c7,
3563                         }
3564                 },
3565                 .unlock         = spi_disable_blockprotect,
3566                 .write          = spi_chip_write_256,
3567                 .read           = spi_chip_read,
3568                 .voltage        = {2700, 3600},
3569         },
3570
3571         {
3572                 .vendor         = "Eon",
3573                 .name           = "EN25QH32",
3574                 .bustype        = BUS_SPI,
3575                 .manufacture_id = EON_ID_NOPREFIX,
3576                 .model_id       = EON_EN25QH32,
3577                 .total_size     = 4096,
3578                 .page_size      = 256,
3579                 /* supports SFDP */
3580                 /* OTP: 512B total; enter 0x3A */
3581                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
3582                 .tested         = TEST_UNTESTED,
3583                 .probe          = probe_spi_rdid,
3584                 .probe_timing   = TIMING_ZERO,
3585                 .block_erasers  =
3586                 {
3587                         {
3588                                 .eraseblocks = { {4 * 1024, 1024} },
3589                                 .block_erase = spi_block_erase_20,
3590                         }, {
3591                                 .eraseblocks = { {64 * 1024, 64} },
3592                                 .block_erase = spi_block_erase_d8,
3593                         }, {
3594                                 .eraseblocks = { {1024 * 4096, 1} },
3595                                 .block_erase = spi_block_erase_60,
3596                         }, {
3597                                 .eraseblocks = { {1024 * 4096, 1} },
3598                                 .block_erase = spi_block_erase_c7,
3599                         }
3600                 },
3601                 .unlock         = spi_disable_blockprotect,
3602                 .write          = spi_chip_write_256,
3603                 .read           = spi_chip_read,
3604                 .voltage        = {2700, 3600},
3605         },
3606
3607         {
3608                 .vendor         = "Eon",
3609                 .name           = "EN29F010",
3610                 .bustype        = BUS_PARALLEL,
3611                 .manufacture_id = EON_ID,
3612                 .model_id       = EON_EN29F010,
3613                 .total_size     = 128,
3614                 .page_size      = 128,
3615                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
3616                 .tested         = TEST_OK_PRE,
3617                 .probe          = probe_jedec,
3618                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
3619                 .block_erasers  =
3620                 {
3621                         {
3622                                 .eraseblocks = { {16 * 1024, 8} },
3623                                 .block_erase = erase_sector_jedec,
3624                         },
3625                         {
3626                                 .eraseblocks = { {128 * 1024, 1} },
3627                                 .block_erase = erase_chip_block_jedec,
3628                         },
3629                 },
3630                 .write          = write_jedec_1,
3631                 .read           = read_memmapped,
3632                 .voltage        = {4500, 5500},
3633         },
3634
3635         {
3636                 .vendor         = "Eon",
3637                 .name           = "EN29F002(A)(N)B",
3638                 .bustype        = BUS_PARALLEL,
3639                 .manufacture_id = EON_ID,
3640                 .model_id       = EON_EN29F002B,
3641                 .total_size     = 256,
3642                 .page_size      = 256,
3643                 .feature_bits   = FEATURE_ADDR_AAA | FEATURE_EITHER_RESET,
3644                 .tested         = TEST_OK_PR,
3645                 .probe          = probe_jedec,
3646                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
3647                 .block_erasers  =
3648                 {
3649                         {
3650                                 .eraseblocks = {
3651                                         {16 * 1024, 1},
3652                                         {8 * 1024, 2},
3653                                         {32 * 1024, 1},
3654                                         {64 * 1024, 3},
3655                                 },
3656                                 .block_erase = erase_sector_jedec,
3657                         }, {
3658                                 .eraseblocks = { {256 * 1024, 1} },
3659                                 .block_erase = erase_chip_block_jedec,
3660                         },
3661                 },
3662                 .write          = write_jedec_1,
3663                 .read           = read_memmapped,
3664                 .voltage        = {4500, 5500},
3665         },
3666
3667         {
3668                 .vendor         = "Eon",
3669                 .name           = "EN29F002(A)(N)T",
3670                 .bustype        = BUS_PARALLEL,
3671                 .manufacture_id = EON_ID,
3672                 .model_id       = EON_EN29F002T,
3673                 .total_size     = 256,
3674                 .page_size      = 256,
3675                 .feature_bits   = FEATURE_ADDR_AAA | FEATURE_EITHER_RESET,
3676                 .tested         = TEST_OK_PREW,
3677                 .probe          = probe_jedec,
3678                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
3679                 .block_erasers  =
3680                 {
3681                         {
3682                                 .eraseblocks = {
3683                                         {64 * 1024, 3},
3684                                         {32 * 1024, 1},
3685                                         {8 * 1024, 2},
3686                                         {16 * 1024, 1},
3687                                 },
3688                                 .block_erase = erase_sector_jedec,
3689                         }, {
3690                                 .eraseblocks = { {256 * 1024, 1} },
3691                                 .block_erase = erase_chip_block_jedec,
3692                         },
3693                 },
3694                 .write          = write_jedec_1,
3695                 .read           = read_memmapped,
3696                 .voltage        = {4500, 5500},
3697         },
3698
3699         {
3700                 .vendor         = "Eon",
3701                 .name           = "EN29LV640B",
3702                 .bustype        = BUS_PARALLEL,
3703                 .manufacture_id = EON_ID,
3704                 .model_id       = EON_EN29LV640B,
3705                 .total_size     = 8192,
3706                 .page_size      = 8192,
3707                 .feature_bits   = 0,
3708                 .tested         = TEST_OK_PREW,
3709                 .probe          = probe_en29lv640b,
3710                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
3711                 .block_erasers  =
3712                 {
3713                         {
3714                                 .eraseblocks = {
3715                                         {8 * 1024, 8},
3716                                         {64 * 1024, 127},
3717                                 },
3718                                 .block_erase = block_erase_en29lv640b,
3719                         }, {
3720                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
3721                                 .block_erase = block_erase_chip_en29lv640b,
3722                         },
3723                 },
3724                 .write          = write_en29lv640b,
3725                 .read           = read_memmapped,
3726                 .voltage        = {2700, 3600},
3727         },
3728
3729         {
3730                 .vendor         = "Fujitsu",
3731                 .name           = "MBM29F004BC",
3732                 .bustype        = BUS_PARALLEL,
3733                 .manufacture_id = FUJITSU_ID,
3734                 .model_id       = FUJITSU_MBM29F004BC,
3735                 .total_size     = 512,
3736                 .page_size      = 64 * 1024,
3737                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
3738                 .tested         = TEST_UNTESTED,
3739                 .probe          = probe_jedec,
3740                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
3741                 .block_erasers  =
3742                 {
3743                         {
3744                                 .eraseblocks = {
3745                                         {16 * 1024, 1},
3746                                         {8 * 1024, 2},
3747                                         {32 * 1024, 1},
3748                                         {64 * 1024, 7},
3749                                 },
3750                                 .block_erase = erase_sector_jedec,
3751                         }, {
3752                                 .eraseblocks = { {512 * 1024, 1} },
3753                                 .block_erase = erase_chip_block_jedec,
3754                         },
3755                 },
3756                 .write          = NULL,
3757                 .read           = read_memmapped,
3758                 .voltage        = {4500, 5500},
3759         },
3760
3761         {
3762                 .vendor         = "Fujitsu",
3763                 .name           = "MBM29F004TC",
3764                 .bustype        = BUS_PARALLEL,
3765                 .manufacture_id = FUJITSU_ID,
3766                 .model_id       = FUJITSU_MBM29F004TC,
3767                 .total_size     = 512,
3768                 .page_size      = 64 * 1024,
3769                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
3770                 .tested         = TEST_UNTESTED,
3771                 .probe          = probe_jedec,
3772                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
3773                 .block_erasers  =
3774                 {
3775                         {
3776                                 .eraseblocks = {
3777                                         {64 * 1024, 7},
3778                                         {32 * 1024, 1},
3779                                         {8 * 1024, 2},
3780                                         {16 * 1024, 1},
3781                                 },
3782                                 .block_erase = erase_sector_jedec,
3783                         }, {
3784                                 .eraseblocks = { {512 * 1024, 1} },
3785                                 .block_erase = erase_chip_block_jedec,
3786                         },
3787                 },
3788                 .write          = NULL,
3789                 .read           = read_memmapped,
3790                 .voltage        = {4500, 5500},
3791         },
3792
3793         {
3794                 /* FIXME: this has WORD/BYTE sequences; 2AA for word, 555 for byte */
3795                 .vendor         = "Fujitsu",
3796                 .name           = "MBM29F400BC",
3797                 .bustype        = BUS_PARALLEL,
3798                 .manufacture_id = FUJITSU_ID,
3799                 .model_id       = FUJITSU_MBM29F400BC,
3800                 .total_size     = 512,
3801                 .page_size      = 64 * 1024,
3802                 .feature_bits   = FEATURE_ADDR_SHIFTED | FEATURE_EITHER_RESET,
3803                 .tested         = TEST_UNTESTED,
3804                 .probe          = probe_m29f400bt,
3805                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (m29f400bt.c) */
3806                 .block_erasers  =
3807                 {
3808                         {
3809                                 .eraseblocks = {
3810                                         {16 * 1024, 1},
3811                                         {8 * 1024, 2},
3812                                         {32 * 1024, 1},
3813                                         {64 * 1024, 7},
3814                                 },
3815                                 .block_erase = block_erase_m29f400bt,
3816                         }, {
3817                                 .eraseblocks = { {512 * 1024, 1} },
3818                                 .block_erase = block_erase_chip_m29f400bt,
3819                         },
3820                 },
3821                 .write          = write_m29f400bt,
3822                 .read           = read_memmapped,
3823                 .voltage        = {4750, 5250}, /* 4.75-5.25V for type -55, others 4.5-5.5V */
3824         },
3825
3826         {
3827                 .vendor         = "Fujitsu",
3828                 .name           = "MBM29F400TC",
3829                 .bustype        = BUS_PARALLEL,
3830                 .manufacture_id = FUJITSU_ID,
3831                 .model_id       = FUJITSU_MBM29F400TC,
3832                 .total_size     = 512,
3833                 .page_size      = 64 * 1024,
3834                 .feature_bits   = FEATURE_ADDR_SHIFTED | FEATURE_EITHER_RESET,
3835                 .tested         = TEST_UNTESTED,
3836                 .probe          = probe_m29f400bt,
3837                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (m29f400bt.c) */
3838                 .block_erasers  =
3839                 {
3840                         {
3841                                 .eraseblocks = {
3842                                         {64 * 1024, 7},
3843                                         {32 * 1024, 1},
3844                                         {8 * 1024, 2},
3845                                         {16 * 1024, 1},
3846                                 },
3847                                 .block_erase = block_erase_m29f400bt,
3848                         }, {
3849                                 .eraseblocks = { {512 * 1024, 1} },
3850                                 .block_erase = block_erase_chip_m29f400bt,
3851                         },
3852                 },
3853                 .write          = write_m29f400bt,
3854                 .read           = read_memmapped,
3855                 .voltage        = {4750, 5250}, /* 4.75-5.25V for type -55, others 4.5-5.5V */
3856         },
3857
3858         {
3859                 .vendor         = "GigaDevice",
3860                 .name           = "GD25Q20",
3861                 .bustype        = BUS_SPI,
3862                 .manufacture_id = GIGADEVICE_ID,
3863                 .model_id       = GIGADEVICE_GD25Q20,
3864                 .total_size     = 256,
3865                 .page_size      = 256,
3866                 .feature_bits   = FEATURE_WRSR_WREN,
3867                 .tested         = TEST_UNTESTED,
3868                 .probe          = probe_spi_rdid,
3869                 .probe_timing   = TIMING_ZERO,
3870                 .block_erasers  =
3871                 {
3872                         {
3873                                 .eraseblocks = { {4 * 1024, 64} },
3874                                 .block_erase = spi_block_erase_20,
3875                         }, {
3876                                 .eraseblocks = { {32 * 1024, 8} },
3877                                 .block_erase = spi_block_erase_52,
3878                         }, {
3879                                 .eraseblocks = { {64 * 1024, 4} },
3880                                 .block_erase = spi_block_erase_d8,
3881                         }, {
3882                                 .eraseblocks = { {256 * 1024, 1} },
3883                                 .block_erase = spi_block_erase_60,
3884                         }, {
3885                                 .eraseblocks = { {256 * 1024, 1} },
3886                                 .block_erase = spi_block_erase_c7,
3887                         }
3888                 },
3889                 .unlock         = spi_disable_blockprotect,
3890                 .write          = spi_chip_write_256,
3891                 .read           = spi_chip_read,
3892                 .voltage        = {2700, 3600},
3893         },
3894
3895         {
3896                 .vendor         = "GigaDevice",
3897                 .name           = "GD25Q40",
3898                 .bustype        = BUS_SPI,
3899                 .manufacture_id = GIGADEVICE_ID,
3900                 .model_id       = GIGADEVICE_GD25Q40,
3901                 .total_size     = 512,
3902                 .page_size      = 256,
3903                 .feature_bits   = FEATURE_WRSR_WREN,
3904                 .tested         = TEST_UNTESTED,
3905                 .probe          = probe_spi_rdid,
3906                 .probe_timing   = TIMING_ZERO,
3907                 .block_erasers  =
3908                 {
3909                         {
3910                                 .eraseblocks = { {4 * 1024, 128} },
3911                                 .block_erase = spi_block_erase_20,
3912                         }, {
3913                                 .eraseblocks = { {32 * 1024, 16} },
3914                                 .block_erase = spi_block_erase_52,
3915                         }, {
3916                                 .eraseblocks = { {64 * 1024, 8} },
3917                                 .block_erase = spi_block_erase_d8,
3918                         }, {
3919                                 .eraseblocks = { {512 * 1024, 1} },
3920                                 .block_erase = spi_block_erase_60,
3921                         }, {
3922                                 .eraseblocks = { {512 * 1024, 1} },
3923                                 .block_erase = spi_block_erase_c7,
3924                         }
3925                 },
3926                 .unlock         = spi_disable_blockprotect,
3927                 .write          = spi_chip_write_256,
3928                 .read           = spi_chip_read,
3929                 .voltage        = {2700, 3600},
3930         },
3931
3932         {
3933                 .vendor         = "GigaDevice",
3934                 .name           = "GD25Q80",
3935                 .bustype        = BUS_SPI,
3936                 .manufacture_id = GIGADEVICE_ID,
3937                 .model_id       = GIGADEVICE_GD25Q80,
3938                 .total_size     = 1024,
3939                 .page_size      = 256,
3940                 /* OTP: 1024B total, 256B reserved; read 0x48; write 0x42 */
3941                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
3942                 .tested         = TEST_OK_PREW,
3943                 .probe          = probe_spi_rdid,
3944                 .probe_timing   = TIMING_ZERO,
3945                 .block_erasers  =
3946                 {
3947                         {
3948                                 .eraseblocks = { {4 * 1024, 256} },
3949                                 .block_erase = spi_block_erase_20,
3950                         }, {
3951                                 .eraseblocks = { {32 * 1024, 32} },
3952                                 .block_erase = spi_block_erase_52,
3953                         }, {
3954                                 .eraseblocks = { {64 * 1024, 16} },
3955                                 .block_erase = spi_block_erase_d8,
3956                         }, {
3957                                 .eraseblocks = { {1024 * 1024, 1} },
3958                                 .block_erase = spi_block_erase_60,
3959                         }, {
3960                                 .eraseblocks = { {1024 * 1024, 1} },
3961                                 .block_erase = spi_block_erase_c7,
3962                         }
3963                 },
3964                 .unlock         = spi_disable_blockprotect,
3965                 .write          = spi_chip_write_256,
3966                 .read           = spi_chip_read,
3967                 .voltage        = {2700, 3600},
3968         },
3969
3970         {
3971                 .vendor         = "GigaDevice",
3972                 .name           = "GD25Q16",
3973                 .bustype        = BUS_SPI,
3974                 .manufacture_id = GIGADEVICE_ID,
3975                 .model_id       = GIGADEVICE_GD25Q16,
3976                 .total_size     = 2048,
3977                 .page_size      = 256,
3978                 /* OTP: 1024B total, 256B reserved; read 0x48; write 0x42 */
3979                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
3980                 .tested         = TEST_UNTESTED,
3981                 .probe          = probe_spi_rdid,
3982                 .probe_timing   = TIMING_ZERO,
3983                 .block_erasers  =
3984                 {
3985                         {
3986                                 .eraseblocks = { {4 * 1024, 512} },
3987                                 .block_erase = spi_block_erase_20,
3988                         }, {
3989                                 .eraseblocks = { {32 * 1024, 64} },
3990                                 .block_erase = spi_block_erase_52,
3991                         }, {
3992                                 .eraseblocks = { {64 * 1024, 32} },
3993                                 .block_erase = spi_block_erase_d8,
3994                         }, {
3995                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
3996                                 .block_erase = spi_block_erase_60,
3997                         }, {
3998                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
3999                                 .block_erase = spi_block_erase_c7,
4000                         }
4001                 },
4002                 .unlock         = spi_disable_blockprotect,
4003                 .write          = spi_chip_write_256,
4004                 .read           = spi_chip_read,
4005                 .voltage        = {2700, 3600},
4006         },
4007
4008         {
4009                 .vendor         = "GigaDevice",
4010                 .name           = "GD25Q32",
4011                 .bustype        = BUS_SPI,
4012                 .manufacture_id = GIGADEVICE_ID,
4013                 .model_id       = GIGADEVICE_GD25Q32,
4014                 .total_size     = 4096,
4015                 .page_size      = 256,
4016                 /* OTP: 1024B total, 256B reserved; read 0x48; write 0x42 */
4017                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
4018                 .tested         = TEST_UNTESTED,
4019                 .probe          = probe_spi_rdid,
4020                 .probe_timing   = TIMING_ZERO,
4021                 .block_erasers  =
4022                 {
4023                         {
4024                                 .eraseblocks = { {4 * 1024, 1024} },
4025                                 .block_erase = spi_block_erase_20,
4026                         }, {
4027                                 .eraseblocks = { {32 * 1024, 128} },
4028                                 .block_erase = spi_block_erase_52,
4029                         }, {
4030                                 .eraseblocks = { {64 * 1024, 64} },
4031                                 .block_erase = spi_block_erase_d8,
4032                         }, {
4033                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
4034                                 .block_erase = spi_block_erase_60,
4035                         }, {
4036                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
4037                                 .block_erase = spi_block_erase_c7,
4038                         }
4039                 },
4040                 .unlock         = spi_disable_blockprotect,
4041                 .write          = spi_chip_write_256,
4042                 .read           = spi_chip_read,
4043                 .voltage        = {2700, 3600},
4044         },
4045
4046         {
4047                 .vendor         = "GigaDevice",
4048                 .name           = "GD25Q64",
4049                 .bustype        = BUS_SPI,
4050                 .manufacture_id = GIGADEVICE_ID,
4051                 .model_id       = GIGADEVICE_GD25Q64,
4052                 .total_size     = 8192,
4053                 .page_size      = 256,
4054                 /* OTP: 1024B total, 256B reserved; read 0x48; write 0x42 */
4055                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
4056                 .tested         = TEST_UNTESTED,
4057                 .probe          = probe_spi_rdid,
4058                 .probe_timing   = TIMING_ZERO,
4059                 .block_erasers  =
4060                 {
4061                         {
4062                                 .eraseblocks = { {4 * 1024, 2048} },
4063                                 .block_erase = spi_block_erase_20,
4064                         }, {
4065                                 .eraseblocks = { {32 * 1024, 256} },
4066                                 .block_erase = spi_block_erase_52,
4067                         }, {
4068                                 .eraseblocks = { {64 * 1024, 128} },
4069                                 .block_erase = spi_block_erase_d8,
4070                         }, {
4071                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
4072                                 .block_erase = spi_block_erase_60,
4073                         }, {
4074                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
4075                                 .block_erase = spi_block_erase_c7,
4076                         }
4077                 },
4078                 .unlock         = spi_disable_blockprotect,
4079                 .write          = spi_chip_write_256,
4080                 .read           = spi_chip_read,
4081         },
4082
4083         {
4084                 .vendor         = "GigaDevice",
4085                 .name           = "GD25Q128",
4086                 .bustype        = BUS_SPI,
4087                 .manufacture_id = GIGADEVICE_ID,
4088                 .model_id       = GIGADEVICE_GD25Q128,
4089                 .total_size     = 16384,
4090                 .page_size      = 256,
4091                 /* OTP: 1024B total, 256B reserved; read 0x48; write 0x42 */
4092                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
4093                 .tested         = TEST_UNTESTED,
4094                 .probe          = probe_spi_rdid,
4095                 .probe_timing   = TIMING_ZERO,
4096                 .block_erasers  =
4097                 {
4098                         {
4099                                 .eraseblocks = { {4 * 1024, 4096} },
4100                                 .block_erase = spi_block_erase_20,
4101                         }, {
4102                                 .eraseblocks = { {32 * 1024, 512} },
4103                                 .block_erase = spi_block_erase_52,
4104                         }, {
4105                                 .eraseblocks = { {64 * 1024, 256} },
4106                                 .block_erase = spi_block_erase_d8,
4107                         }, {
4108                                 .eraseblocks = { {16 * 1024 * 1024, 1} },
4109                                 .block_erase = spi_block_erase_60,
4110                         }, {
4111                                 .eraseblocks = { {16 * 1024 * 1024, 1} },
4112                                 .block_erase = spi_block_erase_c7,
4113                         }
4114                 },
4115                 .unlock         = spi_disable_blockprotect,
4116                 .write          = spi_chip_write_256,
4117                 .read           = spi_chip_read,
4118         },
4119
4120         {
4121                 .vendor         = "Hyundai",
4122                 .name           = "HY29F002T",
4123                 .bustype        = BUS_PARALLEL,
4124                 .manufacture_id = HYUNDAI_ID,
4125                 .model_id       = HYUNDAI_HY29F002T,
4126                 .total_size     = 256,
4127                 .page_size      = 256 * 1024,
4128                 .feature_bits   = FEATURE_EITHER_RESET, /* Some revisions may need FEATURE_ADDR_2AA */
4129                 .tested         = TEST_OK_PRE,
4130                 .probe          = probe_jedec,
4131                 .probe_timing   = TIMING_ZERO, /* Datasheet has no timing info specified */
4132                 .block_erasers  =
4133                 {
4134                         {
4135                                 .eraseblocks = {
4136                                         {64 * 1024, 3},
4137                                         {32 * 1024, 1},
4138                                         {8 * 1024, 2},
4139                                         {16 * 1024, 1},
4140                                 },
4141                                 .block_erase = erase_sector_jedec,
4142                         }, {
4143                                 .eraseblocks = { {256 * 1024, 1} },
4144                                 .block_erase = erase_chip_block_jedec,
4145                         },
4146                 },
4147                 .write          = write_jedec_1,
4148                 .read           = read_memmapped,
4149                 .voltage        = {4750, 5250}, /* 4.75-5.25V for type -45, others 4.5-5.5V */
4150         },
4151
4152         {
4153                 .vendor         = "Hyundai",
4154                 .name           = "HY29F002B",
4155                 .bustype        = BUS_PARALLEL,
4156                 .manufacture_id = HYUNDAI_ID,
4157                 .model_id       = HYUNDAI_HY29F002B,
4158                 .total_size     = 256,
4159                 .page_size      = 256 * 1024,
4160                 .feature_bits   = FEATURE_EITHER_RESET, /* Some revisions may need FEATURE_ADDR_2AA */
4161                 .tested         = TEST_UNTESTED,
4162                 .probe          = probe_jedec,
4163                 .probe_timing   = TIMING_ZERO, /* Datasheet has no timing info specified */
4164                 .block_erasers  =
4165                 {
4166                         {
4167                                 .eraseblocks = {
4168                                         {16 * 1024, 1},
4169                                         {8 * 1024, 2},
4170                                         {32 * 1024, 1},
4171                                         {64 * 1024, 3},
4172                                 },
4173                                 .block_erase = erase_sector_jedec,
4174                         }, {
4175                                 .eraseblocks = { {256 * 1024, 1} },
4176                                 .block_erase = erase_chip_block_jedec,
4177                         },
4178                 },
4179                 .write          = write_jedec_1,
4180                 .read           = read_memmapped,
4181                 .voltage        = {4750, 5250}, /* 4.75-5.25V for type -45, others 4.5-5.5V */
4182         },
4183
4184         {
4185                 .vendor         = "Hyundai",
4186                 .name           = "HY29F040A",
4187                 .bustype        = BUS_PARALLEL,
4188                 .manufacture_id = HYUNDAI_ID,
4189                 .model_id       = HYUNDAI_HY29F040A,
4190                 .total_size     = 512,
4191                 .page_size      = 64 * 1024,
4192                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
4193                 .tested         = TEST_UNTESTED,
4194                 .probe          = probe_jedec,
4195                 .probe_timing   = TIMING_ZERO,
4196                 .block_erasers  =
4197                 {
4198                         {
4199                                 .eraseblocks = { {64 * 1024, 8} },
4200                                 .block_erase = erase_sector_jedec,
4201                         }, {
4202                                 .eraseblocks = { {512 * 1024, 1} },
4203                                 .block_erase = erase_chip_block_jedec,
4204                         },
4205                 },
4206                 .write          = write_jedec_1,
4207                 .read           = read_memmapped,
4208                 .voltage        = {4500, 5500},
4209         },
4210
4211         {
4212                 .vendor         = "Intel",
4213                 .name           = "28F001BN/BX-B",
4214                 .bustype        = BUS_PARALLEL,
4215                 .manufacture_id = INTEL_ID,
4216                 .model_id       = INTEL_28F001B,
4217                 .total_size     = 128,
4218                 .page_size      = 128 * 1024, /* 8k + 2x4k + 112k */
4219                 .tested         = TEST_UNTESTED,
4220                 .probe          = probe_jedec,
4221                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
4222                 .block_erasers  =
4223                 {
4224                         {
4225                                 .eraseblocks = {
4226                                         {8 * 1024, 1},
4227                                         {4 * 1024, 2},
4228                                         {112 * 1024, 1},
4229                                 },
4230                                 .block_erase = erase_block_82802ab,
4231                         },
4232                 },
4233                 .write          = write_82802ab,
4234                 .read           = read_memmapped,
4235                 .voltage        = {4500, 5500},
4236         },
4237
4238         {
4239                 .vendor         = "Intel",
4240                 .name           = "28F001BN/BX-T",
4241                 .bustype        = BUS_PARALLEL,
4242                 .manufacture_id = INTEL_ID,
4243                 .model_id       = INTEL_28F001T,
4244                 .total_size     = 128,
4245                 .page_size      = 128 * 1024, /* 112k + 2x4k + 8k */
4246                 .tested         = TEST_OK_PR,
4247                 .probe          = probe_jedec,
4248                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
4249                 .block_erasers  =
4250                 {
4251                         {
4252                                 .eraseblocks = {
4253                                         {112 * 1024, 1},
4254                                         {4 * 1024, 2},
4255                                         {8 * 1024, 1},
4256                                 },
4257                                 .block_erase = erase_block_82802ab,
4258                         },
4259                 },
4260                 .write          = write_82802ab,
4261                 .read           = read_memmapped,
4262                 .voltage        = {4500, 5500},
4263         },
4264
4265         {
4266                 .vendor         = "Intel",
4267                 .name           = "28F002BC/BL/BV/BX-T",
4268                 .bustype        = BUS_PARALLEL,
4269                 .manufacture_id = INTEL_ID,
4270                 .model_id       = INTEL_28F002T,
4271                 .total_size     = 256,
4272                 .page_size      = 256 * 1024,
4273                 .tested         = TEST_OK_PRE,
4274                 .probe          = probe_82802ab,
4275                 .probe_timing   = TIMING_ZERO, /* Datasheet has no timing info specified */
4276                 .block_erasers  =
4277                 {
4278                         {
4279                                 .eraseblocks = {
4280                                         {128 * 1024, 1},
4281                                         {96 * 1024, 1},
4282                                         {8 * 1024, 2},
4283                                         {16 * 1024, 1},
4284                                 },
4285                                 .block_erase = erase_block_82802ab,
4286                         },
4287                 },
4288                 .write          = write_82802ab,
4289                 .read           = read_memmapped,
4290         },
4291
4292         {
4293                 .vendor         = "Intel",
4294                 .name           = "28F008S3/S5/SC",
4295                 .bustype        = BUS_PARALLEL,
4296                 .manufacture_id = INTEL_ID,
4297                 .model_id       = INTEL_28F004S3,
4298                 .total_size     = 512,
4299                 .page_size      = 256,
4300                 .tested         = TEST_UNTESTED,
4301                 .probe          = probe_82802ab,
4302                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
4303                 .block_erasers  =
4304                 {
4305                         {
4306                                 .eraseblocks = { {64 * 1024, 8} },
4307                                 .block_erase = erase_block_82802ab,
4308                         },
4309                 },
4310                 .unlock         = unlock_28f004s5,
4311                 .write          = write_82802ab,
4312                 .read           = read_memmapped,
4313         },
4314
4315         {
4316                 .vendor         = "Intel",
4317                 .name           = "28F004B5/BE/BV/BX-B",
4318                 .bustype        = BUS_PARALLEL,
4319                 .manufacture_id = INTEL_ID,
4320                 .model_id       = INTEL_28F004B,
4321                 .total_size     = 512,
4322                 .page_size      = 128 * 1024, /* maximal block size */
4323                 .tested         = TEST_UNTESTED,
4324                 .probe          = probe_82802ab,
4325                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
4326                 .block_erasers  =
4327                 {
4328                         {
4329                                 .eraseblocks = {
4330                                         {16 * 1024, 1},
4331                                         {8 * 1024, 2},
4332                                         {96 * 1024, 1},
4333                                         {128 * 1024, 3},
4334                                 },
4335                                 .block_erase = erase_block_82802ab,
4336                         },
4337                 },
4338                 .write          = write_82802ab,
4339                 .read           = read_memmapped,
4340         },
4341
4342         {
4343                 .vendor         = "Intel",
4344                 .name           = "28F004B5/BE/BV/BX-T",
4345                 .bustype        = BUS_PARALLEL,
4346                 .manufacture_id = INTEL_ID,
4347                 .model_id       = INTEL_28F004T,
4348                 .total_size     = 512,
4349                 .page_size      = 128 * 1024, /* maximal block size */
4350                 .tested         = TEST_UNTESTED,
4351                 .probe          = probe_82802ab,
4352                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
4353                 .block_erasers  =
4354                 {
4355                         {
4356                                 .eraseblocks = {
4357                                         {128 * 1024, 3},
4358                                         {96 * 1024, 1},
4359                                         {8 * 1024, 2},
4360                                         {16 * 1024, 1},
4361                                 },
4362                                 .block_erase = erase_block_82802ab,
4363                         },
4364                 },
4365                 .write          = write_82802ab,
4366                 .read           = read_memmapped,
4367         },
4368
4369         {
4370                 .vendor         = "Intel",
4371                 .name           = "28F400BV/BX/CE/CV-B",
4372                 .bustype        = BUS_PARALLEL,
4373                 .manufacture_id = INTEL_ID,
4374                 .model_id       = INTEL_28F400B,
4375                 .total_size     = 512,
4376                 .page_size      = 128 * 1024, /* maximal block size */
4377                 .feature_bits   = FEATURE_ADDR_SHIFTED,
4378                 .tested         = TEST_UNTESTED,
4379                 .probe          = probe_82802ab,
4380                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
4381                 .block_erasers  =
4382                 {
4383                         {
4384                                 .eraseblocks = {
4385                                         {16 * 1024, 1},
4386                                         {8 * 1024, 2},
4387                                         {96 * 1024, 1},
4388                                         {128 * 1024, 3},
4389                                 },
4390                                 .block_erase = erase_block_82802ab,
4391                         },
4392                 },
4393                 .write          = write_82802ab,
4394                 .read           = read_memmapped,
4395         },
4396
4397         {
4398                 .vendor         = "Intel",
4399                 .name           = "28F400BV/BX/CE/CV-T",
4400                 .bustype        = BUS_PARALLEL,
4401                 .manufacture_id = INTEL_ID,
4402                 .model_id       = INTEL_28F400T,
4403                 .total_size     = 512,
4404                 .page_size      = 128 * 1024, /* maximal block size */
4405                 .feature_bits   = FEATURE_ADDR_SHIFTED,
4406                 .tested         = TEST_UNTESTED,
4407                 .probe          = probe_82802ab,
4408                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
4409                 .block_erasers  =
4410                 {
4411                         {
4412                                 .eraseblocks = {
4413                                         {128 * 1024, 3},
4414                                         {96 * 1024, 1},
4415                                         {8 * 1024, 2},
4416                                         {16 * 1024, 1},
4417                                 },
4418                                 .block_erase = erase_block_82802ab,
4419                         },
4420                 },
4421                 .write          = write_82802ab,
4422                 .read           = read_memmapped,
4423         },
4424
4425         {
4426                 .vendor         = "Intel",
4427                 .name           = "82802AB",
4428                 .bustype        = BUS_FWH,
4429                 .manufacture_id = INTEL_ID,
4430                 .model_id       = INTEL_82802AB,
4431                 .total_size     = 512,
4432                 .page_size      = 64 * 1024,
4433                 .feature_bits   = FEATURE_REGISTERMAP,
4434                 .tested         = TEST_OK_PREW,
4435                 .probe          = probe_82802ab,
4436                 .probe_timing   = TIMING_IGNORED, /* routine does not use probe_timing (82802ab.c) */
4437                 .block_erasers  =
4438                 {
4439                         {
4440                                 .eraseblocks = { {64 * 1024, 8} },
4441                                 .block_erase = erase_block_82802ab,
4442                         },
4443                 },
4444                 .unlock         = unlock_82802ab,
4445                 .write          = write_82802ab,
4446                 .read           = read_memmapped,
4447                 .voltage        = {3000, 3600},
4448         },
4449
4450         {
4451                 .vendor         = "Intel",
4452                 .name           = "82802AC",
4453                 .bustype        = BUS_FWH,
4454                 .manufacture_id = INTEL_ID,
4455                 .model_id       = INTEL_82802AC,
4456                 .total_size     = 1024,
4457                 .page_size      = 64 * 1024,
4458                 .feature_bits   = FEATURE_REGISTERMAP,
4459                 .tested         = TEST_OK_PR,
4460                 .probe          = probe_82802ab,
4461                 .probe_timing   = TIMING_IGNORED, /* routine does not use probe_timing (82802ab.c) */
4462                 .block_erasers  =
4463                 {
4464                         {
4465                                 .eraseblocks = { {64 * 1024, 16} },
4466                                 .block_erase = erase_block_82802ab,
4467                         },
4468                 },
4469                 .unlock         = unlock_82802ab,
4470                 .write          = write_82802ab,
4471                 .read           = read_memmapped,
4472                 .voltage        = {3000, 3600},
4473         },
4474
4475         {
4476                 .vendor         = "Macronix",
4477                 .name           = "MX25L512",
4478                 .bustype        = BUS_SPI,
4479                 .manufacture_id = MACRONIX_ID,
4480                 .model_id       = MACRONIX_MX25L512,
4481                 .total_size     = 64,
4482                 .page_size      = 256,
4483                 .feature_bits   = FEATURE_WRSR_WREN,
4484                 .tested         = TEST_UNTESTED,
4485                 .probe          = probe_spi_rdid,
4486                 .probe_timing   = TIMING_ZERO,
4487                 .block_erasers  =
4488                 {
4489                         {
4490                                 .eraseblocks = { {4 * 1024, 16} },
4491                                 .block_erase = spi_block_erase_20,
4492                         }, {
4493                                 .eraseblocks = { {64 * 1024, 1} },
4494                                 .block_erase = spi_block_erase_52,
4495                         }, {
4496                                 .eraseblocks = { {64 * 1024, 1} },
4497                                 .block_erase = spi_block_erase_d8,
4498                         }, {
4499                                 .eraseblocks = { {64 * 1024, 1} },
4500                                 .block_erase = spi_block_erase_60,
4501                         }, {
4502                                 .eraseblocks = { {64 * 1024, 1} },
4503                                 .block_erase = spi_block_erase_c7,
4504                         },
4505                 },
4506                 .unlock         = spi_disable_blockprotect,
4507                 .write          = spi_chip_write_256,
4508                 .read           = spi_chip_read,
4509                 .voltage        = {2700, 3600},
4510         },
4511
4512         {
4513                 .vendor         = "Macronix",
4514                 .name           = "MX25L1005",
4515                 .bustype        = BUS_SPI,
4516                 .manufacture_id = MACRONIX_ID,
4517                 .model_id       = MACRONIX_MX25L1005,
4518                 .total_size     = 128,
4519                 .page_size      = 256,
4520                 .feature_bits   = FEATURE_WRSR_WREN,
4521                 .tested         = TEST_UNTESTED,
4522                 .probe          = probe_spi_rdid,
4523                 .probe_timing   = TIMING_ZERO,
4524                 .block_erasers  =
4525                 {
4526                         {
4527                                 .eraseblocks = { {4 * 1024, 32} },
4528                                 .block_erase = spi_block_erase_20,
4529                         }, {
4530                                 .eraseblocks = { {64 * 1024, 2} },
4531                                 .block_erase = spi_block_erase_d8,
4532                         }, {
4533                                 .eraseblocks = { {128 * 1024, 1} },
4534                                 .block_erase = spi_block_erase_60,
4535                         }, {
4536                                 .eraseblocks = { {128 * 1024, 1} },
4537                                 .block_erase = spi_block_erase_c7,
4538                         },
4539                 },
4540                 .unlock         = spi_disable_blockprotect,
4541                 .write          = spi_chip_write_256,
4542                 .read           = spi_chip_read,
4543                 .voltage        = {2700, 3600},
4544         },
4545
4546         {
4547                 .vendor         = "Macronix",
4548                 .name           = "MX25L2005",
4549                 .bustype        = BUS_SPI,
4550                 .manufacture_id = MACRONIX_ID,
4551                 .model_id       = MACRONIX_MX25L2005,
4552                 .total_size     = 256,
4553                 .page_size      = 256,
4554                 .feature_bits   = FEATURE_WRSR_WREN,
4555                 .tested         = TEST_UNTESTED,
4556                 .probe          = probe_spi_rdid,
4557                 .probe_timing   = TIMING_ZERO,
4558                 .block_erasers  =
4559                 {
4560                         {
4561                                 .eraseblocks = { {4 * 1024, 64} },
4562                                 .block_erase = spi_block_erase_20,
4563                         }, {
4564                                 .eraseblocks = { {64 * 1024, 4} },
4565                                 .block_erase = spi_block_erase_52,
4566                         }, {
4567                                 .eraseblocks = { {64 * 1024, 4} },
4568                                 .block_erase = spi_block_erase_d8,
4569                         }, {
4570                                 .eraseblocks = { {256 * 1024, 1} },
4571                                 .block_erase = spi_block_erase_60,
4572                         }, {
4573                                 .eraseblocks = { {256 * 1024, 1} },
4574                                 .block_erase = spi_block_erase_c7,
4575                         },
4576                 },
4577                 .unlock         = spi_disable_blockprotect,
4578                 .write          = spi_chip_write_256,
4579                 .read           = spi_chip_read,
4580                 .voltage        = {2700, 3600},
4581         },
4582
4583         {
4584                 .vendor         = "Macronix",
4585                 .name           = "MX25L4005",
4586                 .bustype        = BUS_SPI,
4587                 .manufacture_id = MACRONIX_ID,
4588                 .model_id       = MACRONIX_MX25L4005,
4589                 .total_size     = 512,
4590                 .page_size      = 256,
4591                 .feature_bits   = FEATURE_WRSR_WREN,
4592                 .tested         = TEST_OK_PREW,
4593                 .probe          = probe_spi_rdid,
4594                 .probe_timing   = TIMING_ZERO,
4595                 .block_erasers  =
4596                 {
4597                         {
4598                                 .eraseblocks = { {4 * 1024, 128} },
4599                                 .block_erase = spi_block_erase_20,
4600                         }, {
4601                                 .eraseblocks = { {64 * 1024, 8} },
4602                                 .block_erase = spi_block_erase_52,
4603                         }, {
4604                                 .eraseblocks = { {64 * 1024, 8} },
4605                                 .block_erase = spi_block_erase_d8,
4606                         }, {
4607                                 .eraseblocks = { {512 * 1024, 1} },
4608                                 .block_erase = spi_block_erase_60,
4609                         }, {
4610                                 .eraseblocks = { {512 * 1024, 1} },
4611                                 .block_erase = spi_block_erase_c7,
4612                         },
4613                 },
4614                 .unlock         = spi_disable_blockprotect,
4615                 .write          = spi_chip_write_256,
4616                 .read           = spi_chip_read,
4617                 .voltage        = {2700, 3600},
4618         },
4619
4620         {
4621                 .vendor         = "Macronix",
4622                 .name           = "MX25L8005",
4623                 .bustype        = BUS_SPI,
4624                 .manufacture_id = MACRONIX_ID,
4625                 .model_id       = MACRONIX_MX25L8005,
4626                 .total_size     = 1024,
4627                 .page_size      = 256,
4628                 .feature_bits   = FEATURE_WRSR_WREN,
4629                 .tested         = TEST_OK_PREW,
4630                 .probe          = probe_spi_rdid,
4631                 .probe_timing   = TIMING_ZERO,
4632                 .block_erasers  =
4633                 {
4634                         {
4635                                 .eraseblocks = { {4 * 1024, 256} },
4636                                 .block_erase = spi_block_erase_20,
4637                         }, {
4638                                 .eraseblocks = { {64 * 1024, 16} },
4639                                 .block_erase = spi_block_erase_52,
4640                         }, {
4641                                 .eraseblocks = { {64 * 1024, 16} },
4642                                 .block_erase = spi_block_erase_d8,
4643                         }, {
4644                                 .eraseblocks = { {1024 * 1024, 1} },
4645                                 .block_erase = spi_block_erase_60,
4646                         }, {
4647                                 .eraseblocks = { {1024 * 1024, 1} },
4648                                 .block_erase = spi_block_erase_c7,
4649                         },
4650                 },
4651                 .unlock         = spi_disable_blockprotect,
4652                 .write          = spi_chip_write_256,
4653                 .read           = spi_chip_read,
4654                 .voltage        = {2700, 3600},
4655         },
4656
4657         {
4658                 .vendor         = "Macronix",
4659                 .name           = "MX25L1605",
4660                 .bustype        = BUS_SPI,
4661                 .manufacture_id = MACRONIX_ID,
4662                 .model_id       = MACRONIX_MX25L1605,
4663                 .total_size     = 2048,
4664                 .page_size      = 256,
4665                 .feature_bits   = FEATURE_WRSR_WREN,
4666                 .tested         = TEST_OK_PREW,
4667                 .probe          = probe_spi_rdid,
4668                 .probe_timing   = TIMING_ZERO,
4669                 .block_erasers  =
4670                 {
4671                         {
4672                                 .eraseblocks = { {4 * 1024, 512} },
4673                                 .block_erase = spi_block_erase_20,      /* This erase function has 64k blocksize for eLiteFlash */
4674                         }, {
4675                                 .eraseblocks = { {64 * 1024, 32} },     /* Not supported in MX25L1605 (eLiteFlash) and MX25L1605D */
4676                                 .block_erase = spi_block_erase_52,
4677                         }, {
4678                                 .eraseblocks = { {64 * 1024, 32} },
4679                                 .block_erase = spi_block_erase_d8,
4680                         }, {
4681                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
4682                                 .block_erase = spi_block_erase_60,
4683                         }, {
4684                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
4685                                 .block_erase = spi_block_erase_c7,
4686                         },
4687                 },
4688                 .unlock         = spi_disable_blockprotect,
4689                 .write          = spi_chip_write_256,
4690                 .read           = spi_chip_read,
4691                 .voltage        = {2700, 3600},
4692         },
4693
4694         {
4695                 .vendor         = "Macronix",
4696                 .name           = "MX25L1635D",
4697                 .bustype        = BUS_SPI,
4698                 .manufacture_id = MACRONIX_ID,
4699                 .model_id       = MACRONIX_MX25L1635D,
4700                 .total_size     = 2048,
4701                 .page_size      = 256,
4702                 .feature_bits   = FEATURE_WRSR_WREN,
4703                 .tested         = TEST_UNTESTED,
4704                 .probe          = probe_spi_rdid,
4705                 .probe_timing   = TIMING_ZERO,
4706                 .block_erasers  =
4707                 {
4708                         {
4709                                 .eraseblocks = { {4 * 1024, 512} },
4710                                 .block_erase = spi_block_erase_20,
4711                         }, {
4712                                 .eraseblocks = { {64 * 1024, 32} },
4713                                 .block_erase = spi_block_erase_d8,
4714                         }, {
4715                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
4716                                 .block_erase = spi_block_erase_60,
4717                         }, {
4718                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
4719                                 .block_erase = spi_block_erase_c7,
4720                         }
4721                 },
4722                 .unlock         = spi_disable_blockprotect,
4723                 .write          = spi_chip_write_256,
4724                 .read           = spi_chip_read,
4725                 .voltage        = {2700, 3600},
4726         },
4727
4728         {
4729                 .vendor         = "Macronix",
4730                 .name           = "MX25L1635E",
4731                 .bustype        = BUS_SPI,
4732                 .manufacture_id = MACRONIX_ID,
4733                 .model_id       = MACRONIX_MX25L1635E,
4734                 .total_size     = 2048,
4735                 .page_size      = 256,
4736                 .feature_bits   = FEATURE_WRSR_WREN,
4737                 .tested         = TEST_UNTESTED,
4738                 .probe          = probe_spi_rdid,
4739                 .probe_timing   = TIMING_ZERO,
4740                 .block_erasers  =
4741                 {
4742                         {
4743                                 .eraseblocks = { {4 * 1024, 512} },
4744                                 .block_erase = spi_block_erase_20,
4745                         }, {
4746                                 .eraseblocks = { {64 * 1024, 32} },
4747                                 .block_erase = spi_block_erase_d8,
4748                         }, {
4749                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
4750                                 .block_erase = spi_block_erase_60,
4751                         }, {
4752                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
4753                                 .block_erase = spi_block_erase_c7,
4754                         }
4755                 },
4756                 .unlock         = spi_disable_blockprotect,
4757                 .write          = spi_chip_write_256,
4758                 .read           = spi_chip_read,
4759                 .voltage        = {2700, 3600},
4760         },
4761
4762         {
4763                 .vendor         = "Macronix",
4764                 .name           = "MX25L3205",
4765                 .bustype        = BUS_SPI,
4766                 .manufacture_id = MACRONIX_ID,
4767                 .model_id       = MACRONIX_MX25L3205,
4768                 .total_size     = 4096,
4769                 .page_size      = 256,
4770                 .feature_bits   = FEATURE_WRSR_WREN,
4771                 .tested         = TEST_OK_PREW,
4772                 .probe          = probe_spi_rdid,
4773                 .probe_timing   = TIMING_ZERO,
4774                 .block_erasers  =
4775                 {
4776                         {
4777                                 .eraseblocks = { {4 * 1024, 1024} },
4778                                 .block_erase = spi_block_erase_20,
4779                         }, {
4780                                 .eraseblocks = { {4 * 1024, 1024} },
4781                                 .block_erase = spi_block_erase_d8,
4782                         }, {
4783                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
4784                                 .block_erase = spi_block_erase_60,
4785                         }, {
4786                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
4787                                 .block_erase = spi_block_erase_c7,
4788                         },
4789                 },
4790                 .unlock         = spi_disable_blockprotect,
4791                 .write          = spi_chip_write_256,
4792                 .read           = spi_chip_read,
4793                 .voltage        = {2700, 3600},
4794         },
4795
4796         {
4797                 .vendor         = "Macronix",
4798                 .name           = "MX25L3235D",
4799                 .bustype        = BUS_SPI,
4800                 .manufacture_id = MACRONIX_ID,
4801                 .model_id       = MACRONIX_MX25L3235D,
4802                 .total_size     = 4096,
4803                 .page_size      = 256,
4804                 .feature_bits   = FEATURE_WRSR_WREN,
4805                 .tested         = TEST_UNTESTED,
4806                 .probe          = probe_spi_rdid,
4807                 .probe_timing   = TIMING_ZERO,
4808                 .block_erasers  =
4809                 {
4810                         {
4811                                 .eraseblocks = { {4 * 1024, 1024} },
4812                                 .block_erase = spi_block_erase_20,
4813                         }, {
4814                                 .eraseblocks = { {64 * 1024, 64} },
4815                                 .block_erase = spi_block_erase_d8,
4816                         }, {
4817                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
4818                                 .block_erase = spi_block_erase_60,
4819                         }, {
4820                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
4821                                 .block_erase = spi_block_erase_c7,
4822                         }
4823                 },
4824                 .unlock         = spi_disable_blockprotect,
4825                 .write          = spi_chip_write_256,
4826                 .read           = spi_chip_read,
4827                 .voltage        = {2700, 3600},
4828         },
4829
4830         {
4831                 .vendor         = "Macronix",
4832                 .name           = "MX25L6405",
4833                 .bustype        = BUS_SPI,
4834                 .manufacture_id = MACRONIX_ID,
4835                 .model_id       = MACRONIX_MX25L6405,
4836                 .total_size     = 8192,
4837                 .page_size      = 256,
4838                 .feature_bits   = FEATURE_WRSR_WREN,
4839                 .tested         = TEST_OK_PREW,
4840                 .probe          = probe_spi_rdid,
4841                 .probe_timing   = TIMING_ZERO,
4842                 .block_erasers  =
4843                 {
4844                         {
4845                                 .eraseblocks = { {64 * 1024, 128} },
4846                                 .block_erase = spi_block_erase_20,
4847                         }, {
4848                                 .eraseblocks = { {64 * 1024, 128} },
4849                                 .block_erase = spi_block_erase_d8,
4850                         }, {
4851                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
4852                                 .block_erase = spi_block_erase_60,
4853                         }, {
4854                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
4855                                 .block_erase = spi_block_erase_c7,
4856                         }
4857                 },
4858                 .unlock         = spi_disable_blockprotect,
4859                 .write          = spi_chip_write_256,
4860                 .read           = spi_chip_read,
4861                 .voltage        = {2700, 3600},
4862         },
4863
4864         {
4865                 .vendor         = "Macronix",
4866                 .name           = "MX25L12805",
4867                 .bustype        = BUS_SPI,
4868                 .manufacture_id = MACRONIX_ID,
4869                 .model_id       = MACRONIX_MX25L12805,
4870                 .total_size     = 16384,
4871                 .page_size      = 256,
4872                 .feature_bits   = FEATURE_WRSR_WREN,
4873                 .tested         = TEST_UNTESTED,
4874                 .probe          = probe_spi_rdid,
4875                 .probe_timing   = TIMING_ZERO,
4876                 .block_erasers  =
4877                 {
4878                         {
4879                                 .eraseblocks = { {4 * 1024, 4096} },
4880                                 .block_erase = spi_block_erase_20,
4881                         }, {
4882                                 .eraseblocks = { {64 * 1024, 256} },
4883                                 .block_erase = spi_block_erase_d8,
4884                         }, {
4885                                 .eraseblocks = { {16 * 1024 * 1024, 1} },
4886                                 .block_erase = spi_block_erase_60,
4887                         }, {
4888                                 .eraseblocks = { {16 * 1024 * 1024, 1} },
4889                                 .block_erase = spi_block_erase_c7,
4890                         }
4891                 },
4892                 .unlock         = spi_disable_blockprotect,
4893                 .write          = spi_chip_write_256,
4894                 .read           = spi_chip_read,
4895                 .voltage        = {2700, 3600},
4896         },
4897
4898         {
4899                 .vendor         = "Macronix",
4900                 .name           = "MX29F001B",
4901                 .bustype        = BUS_PARALLEL,
4902                 .manufacture_id = MACRONIX_ID,
4903                 .model_id       = MACRONIX_MX29F001B,
4904                 .total_size     = 128,
4905                 .page_size      = 32 * 1024,
4906                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
4907                 .tested         = TEST_UNTESTED,
4908                 .probe          = probe_jedec,
4909                 .probe_timing   = TIMING_ZERO,
4910                 .block_erasers  =
4911                 {
4912                         {
4913                                 .eraseblocks = {
4914                                         {8 * 1024, 1},
4915                                         {4 * 1024, 2},
4916                                         {8 * 1024, 2},
4917                                         {32 * 1024, 1},
4918                                         {64 * 1024, 1},
4919                                 },
4920                                 .block_erase = erase_sector_jedec,
4921                         }, {
4922                                 .eraseblocks = { {128 * 1024, 1} },
4923                                 .block_erase = erase_chip_block_jedec,
4924                         }
4925                 },
4926                 .write          = write_jedec_1,
4927                 .read           = read_memmapped,
4928                 .voltage        = {4500, 5500},
4929         },
4930
4931         {
4932                 .vendor         = "Macronix",
4933                 .name           = "MX29F001T",
4934                 .bustype        = BUS_PARALLEL,
4935                 .manufacture_id = MACRONIX_ID,
4936                 .model_id       = MACRONIX_MX29F001T,
4937                 .total_size     = 128,
4938                 .page_size      = 32 * 1024,
4939                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
4940                 .tested         = TEST_OK_PREW,
4941                 .probe          = probe_jedec,
4942                 .probe_timing   = TIMING_ZERO,
4943                 .block_erasers  =
4944                 {
4945                         {
4946                                 .eraseblocks = {
4947                                         {64 * 1024, 1},
4948                                         {32 * 1024, 1},
4949                                         {8 * 1024, 2},
4950                                         {4 * 1024, 2},
4951                                         {8 * 1024, 1},
4952                                 },
4953                                 .block_erase = erase_sector_jedec,
4954                         }, {
4955                                 .eraseblocks = { {128 * 1024, 1} },
4956                                 .block_erase = erase_chip_block_jedec,
4957                         }
4958                 },
4959                 .write          = write_jedec_1,
4960                 .read           = read_memmapped,
4961                 .voltage        = {4500, 5500},
4962         },
4963
4964         {
4965                 .vendor         = "Macronix",
4966                 .name           = "MX29F002(N)B",
4967                 .bustype        = BUS_PARALLEL,
4968                 .manufacture_id = MACRONIX_ID,
4969                 .model_id       = MACRONIX_MX29F002B,
4970                 .total_size     = 256,
4971                 .page_size      = 64 * 1024,
4972                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
4973                 .tested         = TEST_UNTESTED,
4974                 .probe          = probe_jedec,
4975                 .probe_timing   = TIMING_ZERO,
4976                 .block_erasers  =
4977                 {
4978                         {
4979                                 .eraseblocks = {
4980                                         {16 * 1024, 1},
4981                                         {8 * 1024, 2},
4982                                         {32 * 1024, 1},
4983                                         {64 * 1024, 3},
4984                                 },
4985                                 .block_erase = erase_sector_jedec,
4986                         }, {
4987                                 .eraseblocks = { {256 * 1024, 1} },
4988                                 .block_erase = erase_chip_block_jedec,
4989                         },
4990                 },
4991                 .write          = write_jedec_1,
4992                 .read           = read_memmapped,
4993                 .voltage        = {4500, 5500},
4994         },
4995
4996         {
4997                 .vendor         = "Macronix",
4998                 .name           = "MX29F002(N)T",
4999                 .bustype        = BUS_PARALLEL,
5000                 .manufacture_id = MACRONIX_ID,
5001                 .model_id       = MACRONIX_MX29F002T,
5002                 .total_size     = 256,
5003                 .page_size      = 64 * 1024,
5004                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
5005                 .tested         = TEST_OK_PREW,
5006                 .probe          = probe_jedec,
5007                 .probe_timing   = TIMING_ZERO,
5008                 .block_erasers  =
5009                 {
5010                         {
5011                                 .eraseblocks = {
5012                                         {64 * 1024, 3},
5013                                         {32 * 1024, 1},
5014                                         {8 * 1024, 2},
5015                                         {16 * 1024, 1},
5016                                 },
5017                                 .block_erase = erase_sector_jedec,
5018                         }, {
5019                                 .eraseblocks = { {256 * 1024, 1} },
5020                                 .block_erase = erase_chip_block_jedec,
5021                         },
5022                 },
5023                 .write          = write_jedec_1,
5024                 .read           = read_memmapped,
5025                 .voltage        = {4500, 5500},
5026         },
5027
5028         {
5029                 .vendor         = "Macronix",
5030                 .name           = "MX29F040",
5031                 .bustype        = BUS_PARALLEL,
5032                 .manufacture_id = MACRONIX_ID,
5033                 .model_id       = MACRONIX_MX29F040,
5034                 .total_size     = 512,
5035                 .page_size      = 64 * 1024,
5036                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
5037                 .tested         = TEST_UNTESTED,
5038                 .probe          = probe_jedec,
5039                 .probe_timing   = TIMING_ZERO,
5040                 .block_erasers  =
5041                 {
5042                         {
5043                                 .eraseblocks = { {64 * 1024, 8} },
5044                                 .block_erase = erase_sector_jedec,
5045                         }, {
5046                                 .eraseblocks = { {512 * 1024, 1} },
5047                                 .block_erase = erase_chip_block_jedec,
5048                         },
5049                 },
5050                 .write          = write_jedec_1,
5051                 .read           = read_memmapped,
5052                 .voltage        = {4500, 5500},
5053         },
5054
5055         {
5056                 .vendor         = "Macronix",
5057                 .name           = "MX29LV040",
5058                 .bustype        = BUS_PARALLEL,
5059                 .manufacture_id = MACRONIX_ID,
5060                 .model_id       = MACRONIX_MX29LV040,
5061                 .total_size     = 512,
5062                 .page_size      = 64 * 1024,
5063                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_SHORT_RESET,
5064                 .tested         = TEST_UNTESTED,
5065                 .probe          = probe_jedec,
5066                 .probe_timing   = TIMING_ZERO,
5067                 .block_erasers  =
5068                 {
5069                         {
5070                                 .eraseblocks = { {64 * 1024, 8}, },
5071                                 .block_erase = erase_sector_jedec,
5072                         }, {
5073                                 .eraseblocks = { {512 * 1024, 1} },
5074                                 .block_erase = erase_chip_block_jedec,
5075                         },
5076                 },
5077                 .write          = write_jedec_1,
5078                 .read           = read_memmapped,
5079                 .voltage        = {2700, 3600},
5080         },
5081
5082         {
5083                 .vendor         = "MoselVitelic",
5084                 .name           = "V29C51000B",
5085                 .bustype        = BUS_PARALLEL,
5086                 .manufacture_id = SYNCMOS_MVC_ID,
5087                 .model_id       = MVC_V29C51000B,
5088                 .total_size     = 64,
5089                 .page_size      = 512,
5090                 .feature_bits   = FEATURE_EITHER_RESET,
5091                 .tested         = TEST_UNTESTED,
5092                 .probe          = probe_jedec,
5093                 .probe_timing   = TIMING_ZERO,
5094                 .block_erasers  =
5095                 {
5096                         {
5097                                 .eraseblocks = { {512, 128} },
5098                                 .block_erase = erase_sector_jedec,
5099                         }, {
5100                                 .eraseblocks = { {64 * 1024, 1} },
5101                                 .block_erase = erase_chip_block_jedec,
5102                         },
5103                 },
5104                 .write          = write_jedec_1,
5105                 .read           = read_memmapped,
5106                 .voltage        = {4500, 5500},
5107         },
5108
5109         {
5110                 .vendor         = "MoselVitelic",
5111                 .name           = "V29C51000T",
5112                 .bustype        = BUS_PARALLEL,
5113                 .manufacture_id = SYNCMOS_MVC_ID,
5114                 .model_id       = MVC_V29C51000T,
5115                 .total_size     = 64,
5116                 .page_size      = 512,
5117                 .feature_bits   = FEATURE_EITHER_RESET,
5118                 .tested         = TEST_UNTESTED,
5119                 .probe          = probe_jedec,
5120                 .probe_timing   = TIMING_ZERO,
5121                 .block_erasers  =
5122                 {
5123                         {
5124                                 .eraseblocks = { {512, 128} },
5125                                 .block_erase = erase_sector_jedec,
5126                         }, {
5127                                 .eraseblocks = { {64 * 1024, 1} },
5128                                 .block_erase = erase_chip_block_jedec,
5129                         },
5130                 },
5131                 .write          = write_jedec_1,
5132                 .read           = read_memmapped,
5133                 .voltage        = {4500, 5500},
5134         },
5135
5136         {
5137                 .vendor         = "MoselVitelic",
5138                 .name           = "V29C51400B",
5139                 .bustype        = BUS_PARALLEL,
5140                 .manufacture_id = SYNCMOS_MVC_ID,
5141                 .model_id       = MVC_V29C51400B,
5142                 .total_size     = 512,
5143                 .page_size      = 1024,
5144                 .feature_bits   = FEATURE_EITHER_RESET,
5145                 .tested         = TEST_UNTESTED,
5146                 .probe          = probe_jedec,
5147                 .probe_timing   = TIMING_ZERO,
5148                 .block_erasers  =
5149                 {
5150                         {
5151                                 .eraseblocks = { {1024, 512} },
5152                                 .block_erase = erase_sector_jedec,
5153                         }, {
5154                                 .eraseblocks = { {512 * 1024, 1} },
5155                                 .block_erase = erase_chip_block_jedec,
5156                         },
5157                 },
5158                 .write          = write_jedec_1,
5159                 .read           = read_memmapped,
5160                 .voltage        = {4500, 5500},
5161         },
5162
5163         {
5164                 .vendor         = "MoselVitelic",
5165                 .name           = "V29C51400T",
5166                 .bustype        = BUS_PARALLEL,
5167                 .manufacture_id = SYNCMOS_MVC_ID,
5168                 .model_id       = MVC_V29C51400T,
5169                 .total_size     = 512,
5170                 .page_size      = 1024,
5171                 .feature_bits   = FEATURE_EITHER_RESET,
5172                 .tested         = TEST_UNTESTED,
5173                 .probe          = probe_jedec,
5174                 .probe_timing   = TIMING_ZERO,
5175                 .block_erasers  =
5176                 {
5177                         {
5178                                 .eraseblocks = { {1024, 512} },
5179                                 .block_erase = erase_sector_jedec,
5180                         }, {
5181                                 .eraseblocks = { {512 * 1024, 1} },
5182                                 .block_erase = erase_chip_block_jedec,
5183                         },
5184                 },
5185                 .write          = write_jedec_1,
5186                 .read           = read_memmapped,
5187                 .voltage        = {4500, 5500},
5188         },
5189
5190         {
5191                 .vendor         = "MoselVitelic",
5192                 .name           = "V29LC51000",
5193                 .bustype        = BUS_PARALLEL,
5194                 .manufacture_id = SYNCMOS_MVC_ID,
5195                 .model_id       = MVC_V29LC51000,
5196                 .total_size     = 64,
5197                 .page_size      = 512,
5198                 .feature_bits   = FEATURE_EITHER_RESET,
5199                 .tested         = TEST_UNTESTED,
5200                 .probe          = probe_jedec,
5201                 .probe_timing   = TIMING_ZERO,
5202                 .block_erasers  =
5203                 {
5204                         {
5205                                 .eraseblocks = { {512, 128} },
5206                                 .block_erase = erase_sector_jedec,
5207                         }, {
5208                                 .eraseblocks = { {64 * 1024, 1} },
5209                                 .block_erase = erase_chip_block_jedec,
5210                         },
5211                 },
5212                 .write          = write_jedec_1,
5213                 .read           = read_memmapped,
5214                 .voltage        = {4500, 5500},
5215         },
5216
5217         {
5218                 .vendor         = "MoselVitelic",
5219                 .name           = "V29LC51001",
5220                 .bustype        = BUS_PARALLEL,
5221                 .manufacture_id = SYNCMOS_MVC_ID,
5222                 .model_id       = MVC_V29LC51001,
5223                 .total_size     = 128,
5224                 .page_size      = 512,
5225                 .feature_bits   = FEATURE_EITHER_RESET,
5226                 .tested         = TEST_UNTESTED,
5227                 .probe          = probe_jedec,
5228                 .probe_timing   = TIMING_ZERO,
5229                 .block_erasers  =
5230                 {
5231                         {
5232                                 .eraseblocks = { {512, 256} },
5233                                 .block_erase = erase_sector_jedec,
5234                         }, {
5235                                 .eraseblocks = { {128 * 1024, 1} },
5236                                 .block_erase = erase_chip_block_jedec,
5237                         },
5238                 },
5239                 .write          = write_jedec_1,
5240                 .read           = read_memmapped,
5241                 .voltage        = {4500, 5500},
5242         },
5243
5244         {
5245                 .vendor         = "MoselVitelic",
5246                 .name           = "V29LC51002",
5247                 .bustype        = BUS_PARALLEL,
5248                 .manufacture_id = SYNCMOS_MVC_ID,
5249                 .model_id       = MVC_V29LC51002,
5250                 .total_size     = 256,
5251                 .page_size      = 512,
5252                 .feature_bits   = FEATURE_EITHER_RESET,
5253                 .tested         = TEST_UNTESTED,
5254                 .probe          = probe_jedec,
5255                 .probe_timing   = TIMING_ZERO,
5256                 .block_erasers  =
5257                 {
5258                         {
5259                                 .eraseblocks = { {512, 512} },
5260                                 .block_erase = erase_sector_jedec,
5261                         }, {
5262                                 .eraseblocks = { {256 * 1024, 1} },
5263                                 .block_erase = erase_chip_block_jedec,
5264                         },
5265                 },
5266                 .write          = write_jedec_1,
5267                 .read           = read_memmapped,
5268                 .voltage        = {4500, 5500},
5269         },
5270
5271         {
5272                 .vendor         = "Numonyx",
5273                 .name           = "M25PE10",
5274                 .bustype        = BUS_SPI,
5275                 .manufacture_id = ST_ID,
5276                 .model_id       = ST_M25PE10,
5277                 .total_size     = 128,
5278                 .page_size      = 256,
5279                 .feature_bits   = FEATURE_WRSR_WREN,
5280                 .tested         = TEST_UNTESTED,
5281                 .probe          = probe_spi_rdid,
5282                 .probe_timing   = TIMING_ZERO,
5283                 .block_erasers  =
5284                 {
5285                         {
5286                                 .eraseblocks = { {4 * 1024, 32} },
5287                                 .block_erase = spi_block_erase_20,
5288                         }, {
5289                                 .eraseblocks = { {64 * 1024, 2} },
5290                                 .block_erase = spi_block_erase_d8,
5291                         }, {
5292                                 .eraseblocks = { {128 * 1024, 1} },
5293                                 .block_erase = spi_block_erase_c7,
5294                         }
5295                 },
5296                 .unlock         = spi_disable_blockprotect,
5297                 .write          = spi_chip_write_256,
5298                 .read           = spi_chip_read,
5299                 .voltage        = {2700, 3600},
5300         },
5301
5302         {
5303                 .vendor         = "Numonyx",
5304                 .name           = "M25PE20",
5305                 .bustype        = BUS_SPI,
5306                 .manufacture_id = ST_ID,
5307                 .model_id       = ST_M25PE20,
5308                 .total_size     = 256,
5309                 .page_size      = 256,
5310                 .feature_bits   = FEATURE_WRSR_WREN,
5311                 .tested         = TEST_UNTESTED,
5312                 .probe          = probe_spi_rdid,
5313                 .probe_timing   = TIMING_ZERO,
5314                 .block_erasers  =
5315                 {
5316                         {
5317                                 .eraseblocks = { {4 * 1024, 64} },
5318                                 .block_erase = spi_block_erase_20,
5319                         }, {
5320                                 .eraseblocks = { {64 * 1024, 4} },
5321                                 .block_erase = spi_block_erase_d8,
5322                         }, {
5323                                 .eraseblocks = { {256 * 1024, 1} },
5324                                 .block_erase = spi_block_erase_c7,
5325                         }
5326                 },
5327                 .unlock         = spi_disable_blockprotect,
5328                 .write          = spi_chip_write_256,
5329                 .read           = spi_chip_read,
5330                 .voltage        = {2700, 3600},
5331         },
5332
5333         {
5334                 .vendor         = "Numonyx",
5335                 .name           = "M25PE40",
5336                 .bustype        = BUS_SPI,
5337                 .manufacture_id = ST_ID,
5338                 .model_id       = ST_M25PE40,
5339                 .total_size     = 512,
5340                 .page_size      = 256,
5341                 .feature_bits   = FEATURE_WRSR_WREN,
5342                 .tested         = TEST_UNTESTED,
5343                 .probe          = probe_spi_rdid,
5344                 .probe_timing   = TIMING_ZERO,
5345                 .block_erasers  =
5346                 {
5347                         {
5348                                 .eraseblocks = { {4 * 1024, 128} },
5349                                 .block_erase = spi_block_erase_20,
5350                         }, {
5351                                 .eraseblocks = { {64 * 1024, 8} },
5352                                 .block_erase = spi_block_erase_d8,
5353                         }, {
5354                                 .eraseblocks = { {512 * 1024, 1} },
5355                                 .block_erase = spi_block_erase_c7,
5356                         }
5357                 },
5358                 .unlock         = spi_disable_blockprotect,
5359                 .write          = spi_chip_write_256,
5360                 .read           = spi_chip_read,
5361                 .voltage        = {2700, 3600},
5362         },
5363
5364         {
5365                 .vendor         = "Numonyx",
5366                 .name           = "M25PE80",
5367                 .bustype        = BUS_SPI,
5368                 .manufacture_id = ST_ID,
5369                 .model_id       = ST_M25PE80,
5370                 .total_size     = 1024,
5371                 .page_size      = 256,
5372                 .feature_bits   = FEATURE_WRSR_WREN,
5373                 .tested         = TEST_OK_PREW,
5374                 .probe          = probe_spi_rdid,
5375                 .probe_timing   = TIMING_ZERO,
5376                 .block_erasers  =
5377                 {
5378                         {
5379                                 .eraseblocks = { {4 * 1024, 256} },
5380                                 .block_erase = spi_block_erase_20,
5381                         }, {
5382                                 .eraseblocks = { {64 * 1024, 16} },
5383                                 .block_erase = spi_block_erase_d8,
5384                         }, {
5385                                 .eraseblocks = { {1024 * 1024, 1} },
5386                                 .block_erase = spi_block_erase_c7,
5387                         }
5388                 },
5389                 .unlock         = spi_disable_blockprotect,
5390                 .write          = spi_chip_write_256,
5391                 .read           = spi_chip_read,
5392                 .voltage        = {2700, 3600},
5393         },
5394
5395         {
5396                 .vendor         = "Numonyx",
5397                 .name           = "M25PE16",
5398                 .bustype        = BUS_SPI,
5399                 .manufacture_id = ST_ID,
5400                 .model_id       = ST_M25PE16,
5401                 .total_size     = 2048,
5402                 .page_size      = 256,
5403                 .feature_bits   = FEATURE_WRSR_WREN,
5404                 .tested         = TEST_UNTESTED,
5405                 .probe          = probe_spi_rdid,
5406                 .probe_timing   = TIMING_ZERO,
5407                 .block_erasers  =
5408                 {
5409                         {
5410                                 .eraseblocks = { {4 * 1024, 512} },
5411                                 .block_erase = spi_block_erase_20,
5412                         }, {
5413                                 .eraseblocks = { {64 * 1024, 32} },
5414                                 .block_erase = spi_block_erase_d8,
5415                         }, {
5416                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
5417                                 .block_erase = spi_block_erase_c7,
5418                         }
5419                 },
5420                 .unlock         = spi_disable_blockprotect,
5421                 .write          = spi_chip_write_256,
5422                 .read           = spi_chip_read,
5423                 .voltage        = {2700, 3600},
5424         },
5425
5426         {
5427                 .vendor         = "Numonyx",
5428                 .name           = "N25Q064",
5429                 .bustype        = BUS_SPI,
5430                 .manufacture_id = ST_ID,
5431                 .model_id       = ST_N25Q064,
5432                 .total_size     = 8192,
5433                 .page_size      = 256,
5434                 .tested         = TEST_OK_PREW,
5435                 .probe          = probe_spi_rdid,
5436                 .probe_timing   = TIMING_ZERO,
5437                 .block_erasers  =
5438                 {
5439                         {
5440                                 .eraseblocks = { {4 * 1024, 2048 } },
5441                                 .block_erase = spi_block_erase_20,
5442                         }, {
5443                                 .eraseblocks = { {64 * 1024, 128} },
5444                                 .block_erase = spi_block_erase_d8,
5445                         }, {
5446                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
5447                                 .block_erase = spi_block_erase_c7,
5448                         }
5449                 },
5450                 .unlock         = spi_disable_blockprotect,
5451                 .write          = spi_chip_write_256,
5452                 .read           = spi_chip_read,
5453         },
5454
5455         {
5456                 .vendor         = "PMC",
5457                 .name           = "Pm25LV010",
5458                 .bustype        = BUS_SPI,
5459                 .manufacture_id = PMC_ID,
5460                 .model_id       = PMC_PM25LV010,
5461                 .total_size     = 128,
5462                 .page_size      = 256,
5463                 .feature_bits   = FEATURE_WRSR_WREN,
5464                 .tested         = TEST_UNTESTED,
5465                 .probe          = probe_spi_rdid,
5466                 .probe_timing   = TIMING_ZERO,
5467                 .block_erasers  =
5468                 {
5469                         {
5470                                 .eraseblocks = { {4 * 1024, 32} },
5471                                 .block_erase = spi_block_erase_d7,
5472                         }, {
5473                                 .eraseblocks = { {32 * 1024, 4} },
5474                                 .block_erase = spi_block_erase_d8,
5475                         }, {
5476                                 .eraseblocks = { {128 * 1024, 1} },
5477                                 .block_erase = spi_block_erase_c7,
5478                         }
5479                 },
5480                 .unlock         = spi_disable_blockprotect,
5481                 .write          = spi_chip_write_256,
5482                 .read           = spi_chip_read,
5483                 .voltage        = {2700, 3600},
5484         },
5485
5486         {
5487                 .vendor         = "PMC",
5488                 .name           = "Pm25LV016B",
5489                 .bustype        = BUS_SPI,
5490                 .manufacture_id = PMC_ID,
5491                 .model_id       = PMC_PM25LV016B,
5492                 .total_size     = 2048,
5493                 .page_size      = 256,
5494                 .feature_bits   = FEATURE_WRSR_WREN,
5495                 .tested         = TEST_UNTESTED,
5496                 .probe          = probe_spi_rdid,
5497                 .probe_timing   = TIMING_ZERO,
5498                 .block_erasers  =
5499                 {
5500                         {
5501                                 .eraseblocks = { {4 * 1024, 512} },
5502                                 .block_erase = spi_block_erase_d7,
5503                         }, {
5504                                 .eraseblocks = { {4 * 1024, 512} },
5505                                 .block_erase = spi_block_erase_20,
5506                         }, {
5507                                 .eraseblocks = { {64 * 1024, 32} },
5508                                 .block_erase = spi_block_erase_d8,
5509                         }, {
5510                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
5511                                 .block_erase = spi_block_erase_60,
5512                         }, {
5513                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
5514                                 .block_erase = spi_block_erase_c7,
5515                         }
5516                 },
5517                 .unlock         = spi_disable_blockprotect,
5518                 .write          = spi_chip_write_256,
5519                 .read           = spi_chip_read,
5520                 .voltage        = {2700, 3600},
5521         },
5522
5523         {
5524                 .vendor         = "PMC",
5525                 .name           = "Pm25LV020",
5526                 .bustype        = BUS_SPI,
5527                 .manufacture_id = PMC_ID,
5528                 .model_id       = PMC_PM25LV020,
5529                 .total_size     = 256,
5530                 .page_size      = 256,
5531                 .feature_bits   = FEATURE_WRSR_WREN,
5532                 .tested         = TEST_UNTESTED,
5533                 .probe          = probe_spi_rdid,
5534                 .probe_timing   = TIMING_ZERO,
5535                 .block_erasers  =
5536                 {
5537                         {
5538                                 .eraseblocks = { {4 * 1024, 64} },
5539                                 .block_erase = spi_block_erase_d7,
5540                         }, {
5541                                 .eraseblocks = { {64 * 1024, 4} },
5542                                 .block_erase = spi_block_erase_d8,
5543                         }, {
5544                                 .eraseblocks = { {256 * 1024, 1} },
5545                                 .block_erase = spi_block_erase_c7,
5546                         }
5547                 },
5548                 .unlock         = spi_disable_blockprotect,
5549                 .write          = spi_chip_write_256,
5550                 .read           = spi_chip_read,
5551                 .voltage        = {2700, 3600},
5552         },
5553
5554         {
5555                 .vendor         = "PMC",
5556                 .name           = "Pm25LV040",
5557                 .bustype        = BUS_SPI,
5558                 .manufacture_id = PMC_ID,
5559                 .model_id       = PMC_PM25LV040,
5560                 .total_size     = 512,
5561                 .page_size      = 256,
5562                 .feature_bits   = FEATURE_WRSR_WREN,
5563                 .tested         = TEST_OK_PREW,
5564                 .probe          = probe_spi_rdid,
5565                 .probe_timing   = TIMING_ZERO,
5566                 .block_erasers  =
5567                 {
5568                         {
5569                                 .eraseblocks = { {4 * 1024, 128} },
5570                                 .block_erase = spi_block_erase_d7,
5571                         }, {
5572                                 .eraseblocks = { {64 * 1024, 8} },
5573                                 .block_erase = spi_block_erase_d8,
5574                         }, {
5575                                 .eraseblocks = { {512 * 1024, 1} },
5576                                 .block_erase = spi_block_erase_c7,
5577                         }
5578                 },
5579                 .unlock         = spi_disable_blockprotect,
5580                 .write          = spi_chip_write_256,
5581                 .read           = spi_chip_read,
5582                 .voltage        = {2700, 3600},
5583         },
5584
5585         {
5586                 .vendor         = "PMC",
5587                 .name           = "Pm25LV080B",
5588                 .bustype        = BUS_SPI,
5589                 .manufacture_id = PMC_ID,
5590                 .model_id       = PMC_PM25LV080B,
5591                 .total_size     = 1024,
5592                 .page_size      = 256,
5593                 .feature_bits   = FEATURE_WRSR_WREN,
5594                 .tested         = TEST_UNTESTED,
5595                 .probe          = probe_spi_rdid,
5596                 .probe_timing   = TIMING_ZERO,
5597                 .block_erasers  =
5598                 {
5599                         {
5600                                 .eraseblocks = { {4 * 1024, 256} },
5601                                 .block_erase = spi_block_erase_d7,
5602                         }, {
5603                                 .eraseblocks = { {4 * 1024, 256} },
5604                                 .block_erase = spi_block_erase_20,
5605                         }, {
5606                                 .eraseblocks = { {64 * 1024, 16} },
5607                                 .block_erase = spi_block_erase_d8,
5608                         }, {
5609                                 .eraseblocks = { {1024 * 1024, 1} },
5610                                 .block_erase = spi_block_erase_60,
5611                         }, {
5612                                 .eraseblocks = { {1024 * 1024, 1} },
5613                                 .block_erase = spi_block_erase_c7,
5614                         }
5615                 },
5616                 .unlock         = spi_disable_blockprotect,
5617                 .write          = spi_chip_write_256,
5618                 .read           = spi_chip_read,
5619                 .voltage        = {2700, 3600},
5620         },
5621
5622         {
5623                 .vendor         = "PMC",
5624                 .name           = "Pm25LV512",
5625                 .bustype        = BUS_SPI,
5626                 .manufacture_id = PMC_ID,
5627                 .model_id       = PMC_PM25LV512,
5628                 .total_size     = 64,
5629                 .page_size      = 256,
5630                 .feature_bits   = FEATURE_WRSR_WREN,
5631                 .tested         = TEST_UNTESTED,
5632                 .probe          = probe_spi_rdid,
5633                 .probe_timing   = TIMING_ZERO,
5634                 .block_erasers  =
5635                 {
5636                         {
5637                                 .eraseblocks = { {4 * 1024, 16} },
5638                                 .block_erase = spi_block_erase_d7,
5639                         }, {
5640                                 .eraseblocks = { {32 * 1024, 2} },
5641                                 .block_erase = spi_block_erase_d8,
5642                         }, {
5643                                 .eraseblocks = { {64 * 1024, 1} },
5644                                 .block_erase = spi_block_erase_c7,
5645                         }
5646                 },
5647                 .unlock         = spi_disable_blockprotect,
5648                 .write          = spi_chip_write_256,
5649                 .read           = spi_chip_read,
5650                 .voltage        = {2700, 3600},
5651         },
5652
5653         {
5654                 .vendor         = "PMC",
5655                 .name           = "Pm29F002T",
5656                 .bustype        = BUS_PARALLEL,
5657                 .manufacture_id = PMC_ID_NOPREFIX,
5658                 .model_id       = PMC_PM29F002T,
5659                 .total_size     = 256,
5660                 .page_size      = 8 * 1024,
5661                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
5662                 .tested         = TEST_OK_PREW,
5663                 .probe          = probe_jedec,
5664                 .probe_timing   = TIMING_FIXME,
5665                 .block_erasers  =
5666                 {
5667                         {
5668                                 .eraseblocks = {
5669                                         {128 * 1024, 1},
5670                                         {96 * 1024, 1},
5671                                         {8 * 1024, 2},
5672                                         {16 * 1024, 1},
5673                                 },
5674                                 .block_erase = erase_sector_jedec,
5675                         }, {
5676                                 .eraseblocks = { {256 * 1024, 1} },
5677                                 .block_erase = erase_chip_block_jedec,
5678                         },
5679                 },
5680                 .write          = write_jedec_1,
5681                 .read           = read_memmapped,
5682                 .voltage        = {4500, 5500},
5683         },
5684
5685         {
5686                 .vendor         = "PMC",
5687                 .name           = "Pm29F002B",
5688                 .bustype        = BUS_PARALLEL,
5689                 .manufacture_id = PMC_ID_NOPREFIX,
5690                 .model_id       = PMC_PM29F002B,
5691                 .total_size     = 256,
5692                 .page_size      = 8 * 1024,
5693                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
5694                 .tested         = TEST_UNTESTED,
5695                 .probe          = probe_jedec,
5696                 .probe_timing   = TIMING_FIXME,
5697                 .block_erasers  =
5698                 {
5699                         {
5700                                 .eraseblocks = {
5701                                         {16 * 1024, 1},
5702                                         {8 * 1024, 2},
5703                                         {96 * 1024, 1},
5704                                         {128 * 1024, 1},
5705                                 },
5706                                 .block_erase = erase_sector_jedec,
5707                         }, {
5708                                 .eraseblocks = { {256 * 1024, 1} },
5709                                 .block_erase = erase_chip_block_jedec,
5710                         },
5711                 },
5712                 .write          = write_jedec_1,
5713                 .read           = read_memmapped,
5714                 .voltage        = {4500, 5500},
5715         },
5716
5717         {
5718                 .vendor         = "PMC",
5719                 .name           = "Pm39LV010",
5720                 .bustype        = BUS_PARALLEL,
5721                 .manufacture_id = PMC_ID_NOPREFIX,
5722                 .model_id       = PMC_PM39F010, /* Pm39LV010 and Pm39F010 have identical IDs but different voltage */
5723                 .total_size     = 128,
5724                 .page_size      = 4096,
5725                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
5726                 .tested         = TEST_OK_PREW,
5727                 .probe          = probe_jedec,
5728                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
5729                 .block_erasers  =
5730                 {
5731                         {
5732                                 .eraseblocks = { {4 * 1024, 32} },
5733                                 .block_erase = erase_sector_jedec,
5734                         }, {
5735                                 .eraseblocks = { {64 * 1024, 2} },
5736                                 .block_erase = erase_block_jedec,
5737                         }, {
5738                                 .eraseblocks = { {128 * 1024, 1} },
5739                                 .block_erase = erase_chip_block_jedec,
5740                         }
5741                 },
5742                 .write          = write_jedec_1,
5743                 .read           = read_memmapped,
5744                 .voltage        = {2700, 3600},
5745         },
5746
5747         {
5748                 .vendor         = "PMC",
5749                 .name           = "Pm39LV020",
5750                 .bustype        = BUS_PARALLEL,
5751                 .manufacture_id = PMC_ID_NOPREFIX,
5752                 .model_id       = PMC_PM39LV020,
5753                 .total_size     = 256,
5754                 .page_size      = 4096,
5755                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
5756                 .tested         = TEST_UNTESTED,
5757                 .probe          = probe_jedec,
5758                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
5759                 .block_erasers =
5760                 {
5761                         {
5762                                 .eraseblocks = { {4 * 1024, 64} },
5763                                 .block_erase = erase_sector_jedec,
5764                         }, {
5765                                 .eraseblocks = { {64 * 1024, 4} },
5766                                 .block_erase = erase_block_jedec,
5767                         }, {
5768                                 .eraseblocks = { {256 * 1024, 1} },
5769                                 .block_erase = erase_chip_block_jedec,
5770                         }
5771                 },
5772                 .write          = write_jedec_1,
5773                 .read           = read_memmapped,
5774                 .voltage        = {2700, 3600},
5775         },
5776
5777         {
5778                 .vendor         = "PMC",
5779                 .name           = "Pm39LV040",
5780                 .bustype        = BUS_PARALLEL,
5781                 .manufacture_id = PMC_ID_NOPREFIX,
5782                 .model_id       = PMC_PM39LV040,
5783                 .total_size     = 512,
5784                 .page_size      = 4096,
5785                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
5786                 .tested         = TEST_OK_PR,
5787                 .probe          = probe_jedec,
5788                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
5789                 .block_erasers =
5790                 {
5791                         {
5792                                 .eraseblocks = { {4 * 1024, 128} },
5793                                 .block_erase = erase_sector_jedec,
5794                         }, {
5795                                 .eraseblocks = { {64 * 1024, 8} },
5796                                 .block_erase = erase_block_jedec,
5797                         }, {
5798                                 .eraseblocks = { {512 * 1024, 1} },
5799                                 .block_erase = erase_chip_block_jedec,
5800                         }
5801                 },
5802                 .write          = write_jedec_1,
5803                 .read           = read_memmapped,
5804                 .voltage        = {2700, 3600},
5805         },
5806
5807         {
5808                 .vendor         = "PMC",
5809                 .name           = "Pm39LV512",
5810                 .bustype        = BUS_PARALLEL,
5811                 .manufacture_id = PMC_ID_NOPREFIX,
5812                 .model_id       = PMC_PM39LV512,
5813                 .total_size     = 64,
5814                 .page_size      = 4096,
5815                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
5816                 .tested         = TEST_OK_PREW,
5817                 .probe          = probe_jedec,
5818                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
5819                 .block_erasers  =
5820                 {
5821                         {
5822                                 .eraseblocks = { {4 * 1024, 16} },
5823                                 .block_erase = erase_sector_jedec,
5824                         }, {
5825                                 .eraseblocks = { {64 * 1024, 1} },
5826                                 .block_erase = erase_block_jedec,
5827                         }, {
5828                                 .eraseblocks = { {64 * 1024, 1} },
5829                                 .block_erase = erase_chip_block_jedec,
5830                         }
5831                 },
5832                 .write          = write_jedec_1,
5833                 .read           = read_memmapped,
5834                 .voltage        = {2700, 3600},
5835         },
5836
5837         {
5838                 .vendor         = "PMC",
5839                 .name           = "Pm49FL002",
5840                 .bustype        = BUS_LPC | BUS_FWH, /* A/A Mux */
5841                 .manufacture_id = PMC_ID_NOPREFIX,
5842                 .model_id       = PMC_PM49FL002,
5843                 .total_size     = 256,
5844                 .page_size      = 16 * 1024,
5845                 .feature_bits   = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
5846                 .tested         = TEST_OK_PREW,
5847                 .probe          = probe_jedec,
5848                 .probe_timing   = TIMING_ZERO,  /* routine is wrapper to probe_jedec (pm49fl00x.c) */
5849                 .block_erasers  =
5850                 {
5851                         {
5852                                 .eraseblocks = { {4 * 1024, 64} },
5853                                 .block_erase = erase_sector_jedec,
5854                         }, {
5855                                 .eraseblocks = { {16 * 1024, 16} },
5856                                 .block_erase = erase_block_jedec,
5857                         }, {
5858                                 .eraseblocks = { {256 * 1024, 1} },
5859                                 .block_erase = erase_chip_block_jedec,
5860                         }
5861                 },
5862                 .unlock         = unlock_49fl00x,
5863                 .write          = write_jedec_1,
5864                 .read           = read_memmapped,
5865                 .voltage        = {3000, 3600},
5866         },
5867
5868         {
5869                 .vendor         = "PMC",
5870                 .name           = "Pm49FL004",
5871                 .bustype        = BUS_LPC | BUS_FWH, /* A/A Mux */
5872                 .manufacture_id = PMC_ID_NOPREFIX,
5873                 .model_id       = PMC_PM49FL004,
5874                 .total_size     = 512,
5875                 .page_size      = 64 * 1024,
5876                 .feature_bits   = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
5877                 .tested         = TEST_OK_PREW,
5878                 .probe          = probe_jedec,
5879                 .probe_timing   = TIMING_ZERO,  /* routine is wrapper to probe_jedec (pm49fl00x.c) */
5880                 .block_erasers  =
5881                 {
5882                         {
5883                                 .eraseblocks = { {4 * 1024, 128} },
5884                                 .block_erase = erase_sector_jedec,
5885                         }, {
5886                                 .eraseblocks = { {64 * 1024, 8} },
5887                                 .block_erase = erase_block_jedec,
5888                         }, {
5889                                 .eraseblocks = { {512 * 1024, 1} },
5890                                 .block_erase = erase_chip_block_jedec,
5891                         }
5892                 },
5893                 .unlock         = unlock_49fl00x,
5894                 .write          = write_jedec_1,
5895                 .read           = read_memmapped,
5896                 .voltage        = {3000, 3600},
5897         },
5898
5899         {
5900                 .vendor         = "Sanyo",
5901                 .name           = "LF25FW203A",
5902                 .bustype        = BUS_SPI,
5903                 .manufacture_id = SANYO_ID,
5904                 .model_id       = SANYO_LE25FW203A,
5905                 .total_size     = 2048,
5906                 .page_size      = 256,
5907                 .tested         = TEST_UNTESTED,
5908                 .probe          = probe_spi_rdid,
5909                 .probe_timing   = TIMING_ZERO,
5910                 .block_erasers  =
5911                 {
5912                         {
5913                                 .eraseblocks = { {64 * 1024, 32} },
5914                                 .block_erase = spi_block_erase_d8,
5915                         },      {
5916                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
5917                                 .block_erase = spi_block_erase_c7,
5918                         }
5919                 },
5920                 .unlock         = spi_disable_blockprotect,
5921                 .write          = spi_chip_write_256,
5922                 .read           = spi_chip_read,
5923         },
5924
5925         {
5926                 .vendor         = "Sharp",
5927                 .name           = "LH28F008BJT-BTLZ1",
5928                 .bustype        = BUS_PARALLEL,
5929                 .manufacture_id = SHARP_ID,
5930                 .model_id       = SHARP_LH28F008BJxxPB,
5931                 .total_size     = 1024,
5932                 .page_size      = 64 * 1024,
5933                 .tested         = TEST_OK_PREW,
5934                 .probe          = probe_82802ab,
5935                 .probe_timing   = TIMING_ZERO,
5936                 .block_erasers  =
5937                 {
5938                         {
5939                                 .eraseblocks = {
5940                                         {8 * 1024, 8},
5941                                         {64 * 1024, 15}
5942                                  },
5943                                 .block_erase = erase_block_82802ab,
5944                         }, {
5945                                 .eraseblocks = { {1024 * 1024, 1} },
5946                                 .block_erase = erase_sector_49lfxxxc,
5947                         }
5948                 },
5949                 .unlock         = unlock_lh28f008bjt,
5950                 .write          = write_82802ab,
5951                 .read           = read_memmapped,
5952                 .voltage        = {2700, 3600},
5953         },
5954
5955         {
5956                 .vendor         = "Sharp",
5957                 .name           = "LHF00L04",
5958                 .bustype        = BUS_FWH, /* A/A Mux */
5959                 .manufacture_id = SHARP_ID,
5960                 .model_id       = SHARP_LHF00L04,
5961                 .total_size     = 1024,
5962                 .page_size      = 64 * 1024,
5963                 .feature_bits   = FEATURE_EITHER_RESET | FEATURE_REGISTERMAP,
5964                 .tested         = TEST_UNTESTED,
5965                 .probe          = probe_82802ab,
5966                 .probe_timing   = TIMING_ZERO,
5967                 .block_erasers  =
5968                 {
5969                         {
5970                                 .eraseblocks = {
5971                                         {64 * 1024, 15},
5972                                         {8 * 1024, 8}
5973                                  },
5974                                 .block_erase = erase_block_82802ab,
5975                         }, {
5976                                 .eraseblocks = {
5977                                         {1024 * 1024, 1}
5978                                 },
5979                                 .block_erase = NULL, /* 30 D0, only in A/A mux mode */
5980                         },
5981                 },
5982                 .unlock         = unlock_82802ab,
5983                 .write          = write_82802ab,
5984                 .read           = read_memmapped,
5985                 .voltage        = {3000, 3600},
5986         },
5987
5988         {
5989                 .vendor         = "Spansion",
5990                 .name           = "S25FL004A",
5991                 .bustype        = BUS_SPI,
5992                 .manufacture_id = SPANSION_ID,
5993                 .model_id       = SPANSION_S25FL004A,
5994                 .total_size     = 512,
5995                 .page_size      = 256,
5996                 .feature_bits   = FEATURE_WRSR_WREN,
5997                 .tested         = TEST_UNTESTED,
5998                 .probe          = probe_spi_rdid,
5999                 .probe_timing   = TIMING_ZERO,
6000                 .block_erasers  =
6001                 {
6002                         {
6003                                 .eraseblocks = { {64 * 1024, 8} },
6004                                 .block_erase = spi_block_erase_d8,
6005                         }, {
6006                                 .eraseblocks = { {512 * 1024, 1} },
6007                                 .block_erase = spi_block_erase_c7,
6008                         }
6009                 },
6010                 .unlock         = spi_disable_blockprotect,
6011                 .write          = spi_chip_write_256,
6012                 .read           = spi_chip_read,
6013                 .voltage        = {2700, 3600},
6014         },
6015
6016         {
6017                 .vendor         = "Spansion",
6018                 .name           = "S25FL008A",
6019                 .bustype        = BUS_SPI,
6020                 .manufacture_id = SPANSION_ID,
6021                 .model_id       = SPANSION_S25FL008A,
6022                 .total_size     = 1024,
6023                 .page_size      = 256,
6024                 .feature_bits   = FEATURE_WRSR_WREN,
6025                 .tested         = TEST_OK_PRE,
6026                 .probe          = probe_spi_rdid,
6027                 .probe_timing   = TIMING_ZERO,
6028                 .block_erasers  =
6029                 {
6030                         {
6031                                 .eraseblocks = { {64 * 1024, 16} },
6032                                 .block_erase = spi_block_erase_d8,
6033                         }, {
6034                                 .eraseblocks = { {1024 * 1024, 1} },
6035                                 .block_erase = spi_block_erase_c7,
6036                         }
6037                 },
6038                 .unlock         = spi_disable_blockprotect,
6039                 .write          = spi_chip_write_256,
6040                 .read           = spi_chip_read,
6041                 .voltage        = {2700, 3600},
6042         },
6043
6044         {
6045                 .vendor         = "Spansion",
6046                 .name           = "S25FL016A",
6047                 .bustype        = BUS_SPI,
6048                 .manufacture_id = SPANSION_ID,
6049                 .model_id       = SPANSION_S25FL016A,
6050                 .total_size     = 2048,
6051                 .page_size      = 256,
6052                 .feature_bits   = FEATURE_WRSR_WREN,
6053                 .tested         = TEST_OK_PR,
6054                 .probe          = probe_spi_rdid,
6055                 .probe_timing   = TIMING_ZERO,
6056                 .block_erasers  =
6057                 {
6058                         {
6059                                 .eraseblocks = { {64 * 1024, 32} },
6060                                 .block_erase = spi_block_erase_d8,
6061                         }, {
6062                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
6063                                 .block_erase = spi_block_erase_c7,
6064                         }
6065                 },
6066                 .unlock         = spi_disable_blockprotect,
6067                 .write          = spi_chip_write_256,
6068                 .read           = spi_chip_read,
6069                 .voltage        = {2700, 3600},
6070         },
6071
6072         {
6073                 .vendor         = "Spansion",
6074                 .name           = "S25FL032A",
6075                 .bustype        = BUS_SPI,
6076                 .manufacture_id = SPANSION_ID,
6077                 .model_id       = SPANSION_S25FL032A,
6078                 .total_size     = 4096,
6079                 .page_size      = 256,
6080                 .feature_bits   = FEATURE_WRSR_WREN,
6081                 .tested         = TEST_OK_PR,
6082                 .probe          = probe_spi_rdid,
6083                 .probe_timing   = TIMING_ZERO,
6084                 .block_erasers  =
6085                 {
6086                         {
6087                                 .eraseblocks = { {64 * 1024, 64} },
6088                                 .block_erase = spi_block_erase_d8,
6089                         }, {
6090                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
6091                                 .block_erase = spi_block_erase_c7,
6092                         }
6093                 },
6094                 .unlock         = spi_disable_blockprotect,
6095                 .write          = spi_chip_write_256,
6096                 .read           = spi_chip_read,
6097                 .voltage        = {2700, 3600},
6098         },
6099
6100         {
6101                 .vendor         = "Spansion",
6102                 .name           = "S25FL064A",
6103                 .bustype        = BUS_SPI,
6104                 .manufacture_id = SPANSION_ID,
6105                 .model_id       = SPANSION_S25FL064A,
6106                 .total_size     = 8192,
6107                 .page_size      = 256,
6108                 .feature_bits   = FEATURE_WRSR_WREN,
6109                 .tested         = TEST_OK_PREW,
6110                 .probe          = probe_spi_rdid,
6111                 .probe_timing   = TIMING_ZERO,
6112                 .block_erasers  =
6113                 {
6114                         {
6115                                 .eraseblocks = { {64 * 1024, 128} },
6116                                 .block_erase = spi_block_erase_d8,
6117                         }, {
6118                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
6119                                 .block_erase = spi_block_erase_c7,
6120                         }
6121                 },
6122                 .unlock         = spi_disable_blockprotect,
6123                 .write          = spi_chip_write_256,
6124                 .read           = spi_chip_read,
6125                 .voltage        = {2700, 3600},
6126         },
6127
6128         {
6129                 .vendor         = "SST",
6130                 .name           = "SST25LF040A",
6131                 .bustype        = BUS_SPI,
6132                 .manufacture_id = SST_ID,
6133                 .model_id       = SST_SST25VF040_REMS,
6134                 .total_size     = 512,
6135                 .page_size      = 256,
6136                 .feature_bits   = FEATURE_WRSR_EWSR,
6137                 .tested         = TEST_OK_PREW,
6138                 .probe          = probe_spi_res2,
6139                 .probe_timing   = TIMING_ZERO,
6140                 .block_erasers  =
6141                 {
6142                         {
6143                                 .eraseblocks = { {4 * 1024, 128} },
6144                                 .block_erase = spi_block_erase_20,
6145                         }, {
6146                                 .eraseblocks = { {32 * 1024, 16} },
6147                                 .block_erase = spi_block_erase_52,
6148                         }, {
6149                                 .eraseblocks = { {512 * 1024, 1} },
6150                                 .block_erase = spi_block_erase_60,
6151                         },
6152                 },
6153                 .unlock         = spi_disable_blockprotect,
6154                 .write          = spi_chip_write_1, /* AAI supported, but opcode is 0xAF */
6155                 .read           = spi_chip_read,
6156                 .voltage        = {3000, 3600},
6157         },
6158
6159         {
6160                 .vendor         = "SST",
6161                 .name           = "SST25LF080A",
6162                 .bustype        = BUS_SPI,
6163                 .manufacture_id = SST_ID,
6164                 .model_id       = SST_SST25VF080_REMS,
6165                 .total_size     = 1024,
6166                 .page_size      = 256,
6167                 .feature_bits   = FEATURE_WRSR_EWSR,
6168                 .tested         = TEST_UNTESTED,
6169                 .probe          = probe_spi_res2,
6170                 .probe_timing   = TIMING_ZERO,
6171                 .block_erasers  =
6172                 {
6173                         {
6174                                 .eraseblocks = { {4 * 1024, 256} },
6175                                 .block_erase = spi_block_erase_20,
6176                         }, {
6177                                 .eraseblocks = { {32 * 1024, 32} },
6178                                 .block_erase = spi_block_erase_52,
6179                         }, {
6180                                 .eraseblocks = { {1024 * 1024, 1} },
6181                                 .block_erase = spi_block_erase_60,
6182                         },
6183                 },
6184                 .unlock         = spi_disable_blockprotect,
6185                 .write          = spi_chip_write_1, /* AAI supported, but opcode is 0xAF */
6186                 .read           = spi_chip_read,
6187                 .voltage        = {3000, 3600},
6188         },
6189
6190         {
6191                 .vendor         = "SST",
6192                 .name           = "SST25VF010",
6193                 .bustype        = BUS_SPI,
6194                 .manufacture_id = SST_ID,
6195                 .model_id       = SST_SST25VF010_REMS,
6196                 .total_size     = 128,
6197                 .page_size      = 256,
6198                 .feature_bits   = FEATURE_WRSR_EWSR,
6199                 .tested         = TEST_OK_PREW,
6200                 .probe          = probe_spi_rems,
6201                 .probe_timing   = TIMING_ZERO,
6202                 .block_erasers  =
6203                 {
6204                         {
6205                                 .eraseblocks = { {4 * 1024, 32} },
6206                                 .block_erase = spi_block_erase_20,
6207                         }, {
6208                                 .eraseblocks = { {32 * 1024, 4} },
6209                                 .block_erase = spi_block_erase_52,
6210                         }, {
6211                                 .eraseblocks = { {128 * 1024, 1} },
6212                                 .block_erase = spi_block_erase_60,
6213                         },
6214                 },
6215                 .unlock         = spi_disable_blockprotect,
6216                 .write          = spi_chip_write_1,
6217                 .read           = spi_chip_read,
6218                 .voltage        = {2700, 3600},
6219         },
6220
6221         {
6222                 .vendor         = "SST",
6223                 .name           = "SST25VF016B",
6224                 .bustype        = BUS_SPI,
6225                 .manufacture_id = SST_ID,
6226                 .model_id       = SST_SST25VF016B,
6227                 .total_size     = 2048,
6228                 .page_size      = 256,
6229                 .feature_bits   = FEATURE_WRSR_EWSR,
6230                 .tested         = TEST_OK_PREW,
6231                 .probe          = probe_spi_rdid,
6232                 .probe_timing   = TIMING_ZERO,
6233                 .block_erasers  =
6234                 {
6235                         {
6236                                 .eraseblocks = { {4 * 1024, 512} },
6237                                 .block_erase = spi_block_erase_20,
6238                         }, {
6239                                 .eraseblocks = { {32 * 1024, 64} },
6240                                 .block_erase = spi_block_erase_52,
6241                         }, {
6242                                 .eraseblocks = { {64 * 1024, 32} },
6243                                 .block_erase = spi_block_erase_d8,
6244                         }, {
6245                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
6246                                 .block_erase = spi_block_erase_60,
6247                         }, {
6248                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
6249                                 .block_erase = spi_block_erase_c7,
6250                         },
6251                 },
6252                 .unlock         = spi_disable_blockprotect,
6253                 .write          = spi_aai_write,
6254                 .read           = spi_chip_read,
6255                 .voltage        = {2700, 3600},
6256         },
6257
6258         {
6259                 .vendor         = "SST",
6260                 .name           = "SST25VF032B",
6261                 .bustype        = BUS_SPI,
6262                 .manufacture_id = SST_ID,
6263                 .model_id       = SST_SST25VF032B,
6264                 .total_size     = 4096,
6265                 .page_size      = 256,
6266                 .feature_bits   = FEATURE_WRSR_EWSR,
6267                 .tested         = TEST_OK_PREW,
6268                 .probe          = probe_spi_rdid,
6269                 .probe_timing   = TIMING_ZERO,
6270                 .block_erasers  =
6271                 {
6272                         {
6273                                 .eraseblocks = { {4 * 1024, 1024} },
6274                                 .block_erase = spi_block_erase_20,
6275                         }, {
6276                                 .eraseblocks = { {32 * 1024, 128} },
6277                                 .block_erase = spi_block_erase_52,
6278                         }, {
6279                                 .eraseblocks = { {64 * 1024, 64} },
6280                                 .block_erase = spi_block_erase_d8,
6281                         }, {
6282                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
6283                                 .block_erase = spi_block_erase_60,
6284                         }, {
6285                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
6286                                 .block_erase = spi_block_erase_c7,
6287                         },
6288                 },
6289                 .unlock         = spi_disable_blockprotect,
6290                 .write          = spi_aai_write,
6291                 .read           = spi_chip_read,
6292                 .voltage        = {2700, 3600},
6293         },
6294
6295         {
6296                 .vendor         = "SST",
6297                 .name           = "SST25VF064C",
6298                 .bustype        = BUS_SPI,
6299                 .manufacture_id = SST_ID,
6300                 .model_id       = SST_SST25VF064C,
6301                 .total_size     = 8192,
6302                 .page_size      = 256,
6303                 .feature_bits   = FEATURE_WRSR_EWSR,
6304                 .tested         = TEST_OK_PREW,
6305                 .probe          = probe_spi_rdid,
6306                 .probe_timing   = TIMING_ZERO,
6307                 .block_erasers  =
6308                 {
6309                         {
6310                                 .eraseblocks = { {4 * 1024, 2048} },
6311                                 .block_erase = spi_block_erase_20,
6312                         }, {
6313                                 .eraseblocks = { {32 * 1024, 256} },
6314                                 .block_erase = spi_block_erase_52,
6315                         }, {
6316                                 .eraseblocks = { {64 * 1024, 128} },
6317                                 .block_erase = spi_block_erase_d8,
6318                         }, {
6319                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
6320                                 .block_erase = spi_block_erase_60,
6321                         }, {
6322                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
6323                                 .block_erase = spi_block_erase_c7,
6324                         },
6325                 },
6326                 .unlock         = spi_disable_blockprotect,
6327                 .write          = spi_chip_write_256,
6328                 .read           = spi_chip_read,
6329                 .voltage        = {2700, 3600},
6330         },
6331
6332         {
6333                 .vendor         = "SST",
6334                 .name           = "SST25VF040",
6335                 .bustype        = BUS_SPI,
6336                 .manufacture_id = SST_ID,
6337                 .model_id       = SST_SST25VF040_REMS,
6338                 .total_size     = 512,
6339                 .page_size      = 256,
6340                 .feature_bits   = FEATURE_WRSR_EWSR,
6341                 .tested         = TEST_OK_PR,
6342                 .probe          = probe_spi_rems,
6343                 .probe_timing   = TIMING_ZERO,
6344                 .block_erasers  =
6345                 {
6346                         {
6347                                 .eraseblocks = { {4 * 1024, 128} },
6348                                 .block_erase = spi_block_erase_20,
6349                         }, {
6350                                 .eraseblocks = { {32 * 1024, 16} },
6351                                 .block_erase = spi_block_erase_52,
6352                         }, {
6353                                 .eraseblocks = { {512 * 1024, 1} },
6354                                 .block_erase = spi_block_erase_60,
6355                         },
6356                 },
6357                 .unlock         = spi_disable_blockprotect,
6358                 .write          = spi_chip_write_1, /* AAI supported, but opcode is 0xAF */
6359                 .read           = spi_chip_read,
6360                 .voltage        = {2700, 3600},
6361         },
6362
6363         {
6364                 .vendor         = "SST",
6365                 .name           = "SST25VF040B",
6366                 .bustype        = BUS_SPI,
6367                 .manufacture_id = SST_ID,
6368                 .model_id       = SST_SST25VF040B,
6369                 .total_size     = 512,
6370                 .page_size      = 256,
6371                 .feature_bits   = FEATURE_WRSR_EWSR,
6372                 .tested         = TEST_UNTESTED,
6373                 .probe          = probe_spi_rdid,
6374                 .probe_timing   = TIMING_ZERO,
6375                 .block_erasers  =
6376                 {
6377                         {
6378                                 .eraseblocks = { {4 * 1024, 128} },
6379                                 .block_erase = spi_block_erase_20,
6380                         }, {
6381                                 .eraseblocks = { {32 * 1024, 16} },
6382                                 .block_erase = spi_block_erase_52,
6383                         }, {
6384                                 .eraseblocks = { {64 * 1024, 8} },
6385                                 .block_erase = spi_block_erase_d8,
6386                         }, {
6387                                 .eraseblocks = { {512 * 1024, 1} },
6388                                 .block_erase = spi_block_erase_60,
6389                         }, {
6390                                 .eraseblocks = { {512 * 1024, 1} },
6391                                 .block_erase = spi_block_erase_c7,
6392                         },
6393                 },
6394                 .unlock         = spi_disable_blockprotect,
6395                 .write          = spi_aai_write,
6396                 .read           = spi_chip_read,
6397                 .voltage        = {2700, 3600},
6398         },
6399
6400         {
6401                 .vendor         = "SST",
6402                 .name           = "SST25VF040B.REMS",
6403                 .bustype        = BUS_SPI,
6404                 .manufacture_id = SST_ID,
6405                 .model_id       = SST_SST25VF040B_REMS,
6406                 .total_size     = 512,
6407                 .page_size      = 256,
6408                 .feature_bits   = FEATURE_WRSR_EWSR,
6409                 .tested         = TEST_OK_PR,
6410                 .probe          = probe_spi_rems,
6411                 .probe_timing   = TIMING_ZERO,
6412                 .block_erasers  =
6413                 {
6414                         {
6415                                 .eraseblocks = { {4 * 1024, 128} },
6416                                 .block_erase = spi_block_erase_20,
6417                         }, {
6418                                 .eraseblocks = { {32 * 1024, 16} },
6419                                 .block_erase = spi_block_erase_52,
6420                         }, {
6421                                 .eraseblocks = { {64 * 1024, 8} },
6422                                 .block_erase = spi_block_erase_d8,
6423                         }, {
6424                                 .eraseblocks = { {512 * 1024, 1} },
6425                                 .block_erase = spi_block_erase_60,
6426                         }, {
6427                                 .eraseblocks = { {512 * 1024, 1} },
6428                                 .block_erase = spi_block_erase_c7,
6429                         },
6430                 },
6431                 .unlock         = spi_disable_blockprotect,
6432                 .write          = spi_aai_write,
6433                 .read           = spi_chip_read,
6434                 .voltage        = {2700, 3600},
6435         },
6436
6437         {
6438                 .vendor         = "SST",
6439                 .name           = "SST25VF080B",
6440                 .bustype        = BUS_SPI,
6441                 .manufacture_id = SST_ID,
6442                 .model_id       = SST_SST25VF080B,
6443                 .total_size     = 1024,
6444                 .page_size      = 256,
6445                 .feature_bits   = FEATURE_WRSR_EWSR,
6446                 .tested         = TEST_OK_PREW,
6447                 .probe          = probe_spi_rdid,
6448                 .probe_timing   = TIMING_ZERO,
6449                 .block_erasers  =
6450                 {
6451                         {
6452                                 .eraseblocks = { {4 * 1024, 256} },
6453                                 .block_erase = spi_block_erase_20,
6454                         }, {
6455                                 .eraseblocks = { {32 * 1024, 32} },
6456                                 .block_erase = spi_block_erase_52,
6457                         }, {
6458                                 .eraseblocks = { {64 * 1024, 16} },
6459                                 .block_erase = spi_block_erase_d8,
6460                         }, {
6461                                 .eraseblocks = { {1024 * 1024, 1} },
6462                                 .block_erase = spi_block_erase_60,
6463                         }, {
6464                                 .eraseblocks = { {1024 * 1024, 1} },
6465                                 .block_erase = spi_block_erase_c7,
6466                         },
6467                 },
6468                 .unlock         = spi_disable_blockprotect,
6469                 .write          = spi_aai_write,
6470                 .read           = spi_chip_read,
6471                 .voltage        = {2700, 3600},
6472         },
6473
6474         {
6475                 .vendor         = "SST",
6476                 .name           = "SST28SF040A",
6477                 .bustype        = BUS_PARALLEL,
6478                 .manufacture_id = SST_ID,
6479                 .model_id       = SST_SST28SF040,
6480                 .total_size     = 512,
6481                 .page_size      = 256,
6482                 .feature_bits   = 0,
6483                 .tested         = TEST_UNTESTED,
6484                 .probe          = probe_82802ab,
6485                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (sst28sf040.c) */
6486                 .block_erasers  =
6487                 {
6488                         {
6489                                 .eraseblocks = { {128, 4096} },
6490                                 .block_erase = erase_sector_28sf040,
6491                         }, {
6492                                 .eraseblocks = { {512 * 1024, 1} },
6493                                 .block_erase = erase_chip_28sf040,
6494                         }
6495                 },
6496                 .unlock         = unprotect_28sf040,
6497                 .write          = write_28sf040,
6498                 .read           = read_memmapped,
6499                 .voltage        = {4500, 5500},
6500         },
6501
6502         {
6503                 .vendor         = "SST",
6504                 .name           = "SST29EE010",
6505                 .bustype        = BUS_PARALLEL,
6506                 .manufacture_id = SST_ID,
6507                 .model_id       = SST_SST29EE010,
6508                 .total_size     = 128,
6509                 .page_size      = 128,
6510                 .feature_bits   = FEATURE_LONG_RESET,
6511                 .tested         = TEST_OK_PR,
6512                 .probe          = probe_jedec,
6513                 .probe_timing   = 10,
6514                 .block_erasers  =
6515                 {
6516                         {
6517                                 .eraseblocks = { {128 * 1024, 1} },
6518                                 .block_erase = erase_chip_block_jedec,
6519                         }
6520                 },
6521                 .write          = write_jedec,
6522                 .read           = read_memmapped,
6523                 .voltage        = {4500, 5500},
6524         },
6525
6526         {
6527                 .vendor         = "SST",
6528                 .name           = "SST29LE010",
6529                 .bustype        = BUS_PARALLEL,
6530                 .manufacture_id = SST_ID,
6531                 .model_id       = SST_SST29LE010,
6532                 .total_size     = 128,
6533                 .page_size      = 128,
6534                 .feature_bits   = FEATURE_LONG_RESET,
6535                 .tested         = TEST_UNTESTED,
6536                 .probe          = probe_jedec,
6537                 .probe_timing   = 10,
6538                 .block_erasers  =
6539                 {
6540                         {
6541                                 .eraseblocks = { {128 * 1024, 1} },
6542                                 .block_erase = erase_chip_block_jedec,
6543                         }
6544                 },
6545                 .write          = write_jedec,
6546                 .read           = read_memmapped,
6547                 .voltage        = {3000, 3600},
6548         },
6549
6550         {
6551                 .vendor         = "SST",
6552                 .name           = "SST29EE020A",
6553                 .bustype        = BUS_PARALLEL,
6554                 .manufacture_id = SST_ID,
6555                 .model_id       = SST_SST29EE020A,
6556                 .total_size     = 256,
6557                 .page_size      = 128,
6558                 .feature_bits   = FEATURE_LONG_RESET,
6559                 .tested         = TEST_OK_PRE,
6560                 .probe          = probe_jedec,
6561                 .probe_timing   = 10,
6562                 .block_erasers  =
6563                 {
6564                         {
6565                                 .eraseblocks = { {256 * 1024, 1} },
6566                                 .block_erase = erase_chip_block_jedec,
6567                         }
6568                 },
6569                 .write          = write_jedec,
6570                 .read           = read_memmapped,
6571                 .voltage        = {4500, 5500},
6572         },
6573
6574         {
6575                 .vendor         = "SST",
6576                 .name           = "SST29LE020",
6577                 .bustype        = BUS_PARALLEL,
6578                 .manufacture_id = SST_ID,
6579                 .model_id       = SST_SST29LE020,
6580                 .total_size     = 256,
6581                 .page_size      = 128,
6582                 .feature_bits   = FEATURE_LONG_RESET,
6583                 .tested         = TEST_OK_PRE,
6584                 .probe          = probe_jedec,
6585                 .probe_timing   = 10,
6586                 .block_erasers  =
6587                 {
6588                         {
6589                                 .eraseblocks = { {256 * 1024, 1} },
6590                                 .block_erase = erase_chip_block_jedec,
6591                         }
6592                 },
6593                 .write          = write_jedec,
6594                 .read           = read_memmapped,
6595                 .voltage        = {3000, 3600},
6596         },
6597
6598         {
6599                 .vendor         = "SST",
6600                 .name           = "SST39SF512",
6601                 .bustype        = BUS_PARALLEL,
6602                 .manufacture_id = SST_ID,
6603                 .model_id       = SST_SST39SF512,
6604                 .total_size     = 64,
6605                 .page_size      = 4096,
6606                 .feature_bits   = FEATURE_EITHER_RESET,
6607                 .tested         = TEST_OK_PREW,
6608                 .probe          = probe_jedec,
6609                 .probe_timing   = 1,                    /* 150 ns */
6610                 .block_erasers  =
6611                 {
6612                         {
6613                                 .eraseblocks = { {4 * 1024, 16} },
6614                                 .block_erase = erase_sector_jedec,
6615                         }, {
6616                                 .eraseblocks = { {64 * 1024, 1} },
6617                                 .block_erase = erase_chip_block_jedec,
6618                         }
6619                 },
6620                 .write          = write_jedec_1,
6621                 .read           = read_memmapped,
6622                 .voltage        = {4500, 5500},
6623         },
6624
6625         {
6626                 .vendor         = "SST",
6627                 .name           = "SST39SF010A",
6628                 .bustype        = BUS_PARALLEL,
6629                 .manufacture_id = SST_ID,
6630                 .model_id       = SST_SST39SF010,
6631                 .total_size     = 128,
6632                 .page_size      = 4096,
6633                 .feature_bits   = FEATURE_EITHER_RESET,
6634                 .tested         = TEST_OK_PREW,
6635                 .probe          = probe_jedec,
6636                 .probe_timing   = 1,                    /* 150 ns */
6637                 .block_erasers  =
6638                 {
6639                         {
6640                                 .eraseblocks = { {4 * 1024, 32} },
6641                                 .block_erase = erase_sector_jedec,
6642                         }, {
6643                                 .eraseblocks = { {128 * 1024, 1} },
6644                                 .block_erase = erase_chip_block_jedec,
6645                         }
6646                 },
6647                 .write          = write_jedec_1,
6648                 .read           = read_memmapped,
6649                 .voltage        = {4500, 5500},
6650         },
6651
6652         {
6653                 .vendor         = "SST",
6654                 .name           = "SST39SF020A",
6655                 .bustype        = BUS_PARALLEL,
6656                 .manufacture_id = SST_ID,
6657                 .model_id       = SST_SST39SF020,
6658                 .total_size     = 256,
6659                 .page_size      = 4096,
6660                 .feature_bits   = FEATURE_EITHER_RESET,
6661                 .tested         = TEST_OK_PREW,
6662                 .probe          = probe_jedec,
6663                 .probe_timing   = 1,                    /* 150 ns */
6664                 .block_erasers  =
6665                 {
6666                         {
6667                                 .eraseblocks = { {4 * 1024, 64} },
6668                                 .block_erase = erase_sector_jedec,
6669                         }, {
6670                                 .eraseblocks = { {256 * 1024, 1} },
6671                                 .block_erase = erase_chip_block_jedec,
6672                         }
6673                 },
6674                 .write          = write_jedec_1,
6675                 .read           = read_memmapped,
6676                 .voltage        = {4500, 5500},
6677         },
6678
6679         {
6680                 .vendor         = "SST",
6681                 .name           = "SST39SF040",
6682                 .bustype        = BUS_PARALLEL,
6683                 .manufacture_id = SST_ID,
6684                 .model_id       = SST_SST39SF040,
6685                 .total_size     = 512,
6686                 .page_size      = 4096,
6687                 .feature_bits   = FEATURE_EITHER_RESET,
6688                 .tested         = TEST_OK_PREW,
6689                 .probe          = probe_jedec,
6690                 .probe_timing   = 1,                    /* 150 ns */
6691                 .block_erasers  =
6692                 {
6693                         {
6694                                 .eraseblocks = { {4 * 1024, 128} },
6695                                 .block_erase = erase_sector_jedec,
6696                         }, {
6697                                 .eraseblocks = { {512 * 1024, 1} },
6698                                 .block_erase = erase_chip_block_jedec,
6699                         }
6700                 },
6701                 .write          = write_jedec_1,
6702                 .read           = read_memmapped,
6703                 .voltage        = {4500, 5500},
6704         },
6705
6706         {
6707                 .vendor         = "SST",
6708                 .name           = "SST39VF512",
6709                 .bustype        = BUS_PARALLEL,
6710                 .manufacture_id = SST_ID,
6711                 .model_id       = SST_SST39VF512,
6712                 .total_size     = 64,
6713                 .page_size      = 4096,
6714                 .feature_bits   = FEATURE_EITHER_RESET,
6715                 .tested         = TEST_OK_PRE,
6716                 .probe          = probe_jedec,
6717                 .probe_timing   = 1,                    /* 150 ns */
6718                 .block_erasers  =
6719                 {
6720                         {
6721                                 .eraseblocks = { {4 * 1024, 16} },
6722                                 .block_erase = erase_sector_jedec,
6723                         }, {
6724                                 .eraseblocks = { {64 * 1024, 1} },
6725                                 .block_erase = erase_chip_block_jedec,
6726                         }
6727                 },
6728                 .write          = write_jedec_1,
6729                 .read           = read_memmapped,
6730                 .voltage        = {2700, 3600},
6731         },
6732
6733         {
6734                 .vendor         = "SST",
6735                 .name           = "SST39VF010",
6736                 .bustype        = BUS_PARALLEL,
6737                 .manufacture_id = SST_ID,
6738                 .model_id       = SST_SST39VF010,
6739                 .total_size     = 128,
6740                 .page_size      = 4096,
6741                 .feature_bits   = FEATURE_EITHER_RESET,
6742                 .tested         = TEST_OK_PREW,
6743                 .probe          = probe_jedec,
6744                 .probe_timing   = 1,                    /* 150 ns */
6745                 .block_erasers  =
6746                 {
6747                         {
6748                                 .eraseblocks = { {4 * 1024, 32} },
6749                                 .block_erase = erase_sector_jedec,
6750                         }, {
6751                                 .eraseblocks = { {128 * 1024, 1} },
6752                                 .block_erase = erase_chip_block_jedec,
6753                         }
6754                 },
6755                 .write          = write_jedec_1,
6756                 .read           = read_memmapped,
6757                 .voltage        = {2700, 3600},
6758         },
6759
6760         {
6761                 .vendor         = "SST",
6762                 .name           = "SST39VF020",
6763                 .bustype        = BUS_PARALLEL,
6764                 .manufacture_id = SST_ID,
6765                 .model_id       = SST_SST39VF020,
6766                 .total_size     = 256,
6767                 .page_size      = 4096,
6768                 .feature_bits   = FEATURE_EITHER_RESET,
6769                 .tested         = TEST_UNTESTED,
6770                 .probe          = probe_jedec,
6771                 .probe_timing   = 1,                    /* 150 ns */
6772                 .block_erasers  =
6773                 {
6774                         {
6775                                 .eraseblocks = { {4 * 1024, 64} },
6776                                 .block_erase = erase_sector_jedec,
6777                         }, {
6778                                 .eraseblocks = { {256 * 1024, 1} },
6779                                 .block_erase = erase_chip_block_jedec,
6780                         }
6781                 },
6782                 .write          = write_jedec_1,
6783                 .read           = read_memmapped,
6784                 .voltage        = {2700, 3600},
6785         },
6786
6787         {
6788                 .vendor         = "SST",
6789                 .name           = "SST39VF040",
6790                 .bustype        = BUS_PARALLEL,
6791                 .manufacture_id = SST_ID,
6792                 .model_id       = SST_SST39VF040,
6793                 .total_size     = 512,
6794                 .page_size      = 4096,
6795                 .feature_bits   = FEATURE_EITHER_RESET,
6796                 .tested         = TEST_UNTESTED,
6797                 .probe          = probe_jedec,
6798                 .probe_timing   = 1,                    /* 150 ns */
6799                 .block_erasers  =
6800                 {
6801                         {
6802                                 .eraseblocks = { {4 * 1024, 128} },
6803                                 .block_erase = erase_sector_jedec,
6804                         }, {
6805                                 .eraseblocks = { {512 * 1024, 1} },
6806                                 .block_erase = erase_chip_block_jedec,
6807                         }
6808                 },
6809                 .write          = write_jedec_1,
6810                 .read           = read_memmapped,
6811                 .voltage        = {2700, 3600},
6812         },
6813
6814         {
6815                 .vendor         = "SST",
6816                 .name           = "SST39VF080",
6817                 .bustype        = BUS_PARALLEL,
6818                 .manufacture_id = SST_ID,
6819                 .model_id       = SST_SST39VF080,
6820                 .total_size     = 1024,
6821                 .page_size      = 4096,
6822                 .feature_bits   = FEATURE_EITHER_RESET,
6823                 .tested         = TEST_UNTESTED,
6824                 .probe          = probe_jedec,
6825                 .probe_timing   = 1,                    /* 150 ns */
6826                 .block_erasers  =
6827                 {
6828                         {
6829                                 .eraseblocks = { {4 * 1024, 256} },
6830                                 .block_erase = erase_sector_jedec,
6831                         }, {
6832                                 .eraseblocks = { {64 * 1024, 16} },
6833                                 .block_erase = erase_block_jedec,
6834                         }, {
6835                                 .eraseblocks = { {1024 * 1024, 1} },
6836                                 .block_erase = erase_chip_block_jedec,
6837                         }
6838                 },
6839                 .write          = write_jedec_1,
6840                 .read           = read_memmapped,
6841                 .voltage        = {2700, 3600},
6842         },
6843
6844         {
6845                 .vendor         = "SST",
6846                 .name           = "SST49LF002A/B",
6847                 .bustype        = BUS_FWH, /* A/A Mux */
6848                 .manufacture_id = SST_ID,
6849                 .model_id       = SST_SST49LF002A,
6850                 .total_size     = 256,
6851                 .page_size      = 16 * 1024,
6852                 .feature_bits   = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
6853                 .tested         = TEST_OK_PREW,
6854                 .probe          = probe_jedec,
6855                 .probe_timing   = 1,            /* 150 ns */
6856                 .block_erasers  =
6857                 {
6858                         {
6859                                 .eraseblocks = { {4 * 1024, 64} },
6860                                 .block_erase = erase_sector_jedec,
6861                         }, {
6862                                 .eraseblocks = { {16 * 1024, 16} },
6863                                 .block_erase = erase_block_jedec,
6864                         }, {
6865                                 .eraseblocks = { {256 * 1024, 1} },
6866                                 .block_erase = NULL, /* AA 55 80 AA 55 10, only in A/A mux mode */
6867                         }
6868                 },
6869                 .printlock      = printlock_sst_fwhub,
6870                 .unlock         = unlock_sst_fwhub,
6871                 .write          = write_jedec_1,
6872                 .read           = read_memmapped,
6873                 .voltage        = {3000, 3600},
6874         },
6875
6876         {
6877                 .vendor         = "SST",
6878                 .name           = "SST49LF003A/B",
6879                 .bustype        = BUS_FWH, /* A/A Mux */
6880                 .manufacture_id = SST_ID,
6881                 .model_id       = SST_SST49LF003A,
6882                 .total_size     = 384,
6883                 .page_size      = 64 * 1024,
6884                 .feature_bits   = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
6885                 .tested         = TEST_OK_PR,
6886                 .probe          = probe_jedec,
6887                 .probe_timing   = 1,            /* 150 ns */
6888                 .block_erasers  =
6889                 {
6890                         {
6891                                 .eraseblocks = { {4 * 1024, 96} },
6892                                 .block_erase = erase_sector_jedec,
6893                         }, {
6894                                 .eraseblocks = { {64 * 1024, 6} },
6895                                 .block_erase = erase_block_jedec,
6896                         }, {
6897                                 .eraseblocks = { {384 * 1024, 1} },
6898                                 .block_erase = NULL, /* AA 55 80 AA 55 10, only in A/A mux mode */
6899                         }
6900                 },
6901                 .printlock      = printlock_sst_fwhub,
6902                 .unlock         = unlock_sst_fwhub,
6903                 .write          = write_jedec_1,
6904                 .read           = read_memmapped,
6905                 .voltage        = {3000, 3600},
6906         },
6907
6908         {
6909                 /* Contrary to the data sheet, TBL# on the SST49LF004B affects the top 128kB (instead of 64kB)
6910                  * and is only honored for 64k block erase, but not 4k sector erase.
6911                  */
6912                 .vendor         = "SST",
6913                 .name           = "SST49LF004A/B",
6914                 .bustype        = BUS_FWH, /* A/A Mux */
6915                 .manufacture_id = SST_ID,
6916                 .model_id       = SST_SST49LF004A,
6917                 .total_size     = 512,
6918                 .page_size      = 64 * 1024,
6919                 .feature_bits   = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
6920                 .tested         = TEST_OK_PREW,
6921                 .probe          = probe_jedec,
6922                 .probe_timing   = 1,            /* 150 ns */
6923                 .block_erasers  =
6924                 {
6925                         {
6926                                 .eraseblocks = { {4 * 1024, 128} },
6927                                 .block_erase = erase_sector_jedec,
6928                         }, {
6929                                 .eraseblocks = { {64 * 1024, 8} },
6930                                 .block_erase = erase_block_jedec,
6931                         }, {
6932                                 .eraseblocks = { {512 * 1024, 1} },
6933                                 .block_erase = NULL, /* AA 55 80 AA 55 10, only in A/A mux mode */
6934                         },
6935                 },
6936                 .printlock      = printlock_sst_fwhub,
6937                 .unlock         = unlock_sst_fwhub,
6938                 .write          = write_jedec_1,
6939                 .read           = read_memmapped,
6940                 .voltage        = {3000, 3600},
6941         },
6942
6943         {
6944                 .vendor         = "SST",
6945                 .name           = "SST49LF004C",
6946                 .bustype        = BUS_FWH,
6947                 .manufacture_id = SST_ID,
6948                 .model_id       = SST_SST49LF004C,
6949                 .total_size     = 512,
6950                 .page_size      = 4 * 1024,
6951                 .feature_bits   = FEATURE_REGISTERMAP,
6952                 .tested         = TEST_UNTESTED,
6953                 .probe          = probe_82802ab,
6954                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (sst49lfxxxc.c) */
6955                 .block_erasers  =
6956                 {
6957                         {
6958                                 .eraseblocks = { {4 * 1024, 128} },
6959                                 .block_erase = erase_sector_49lfxxxc,
6960                         }, {
6961                                 .eraseblocks = {
6962                                         {64 * 1024, 7},
6963                                         {32 * 1024, 1},
6964                                         {8 * 1024, 2},
6965                                         {16 * 1024, 1},
6966                                 },
6967                                 .block_erase = erase_block_82802ab,
6968                         }
6969                 },
6970                 .unlock         = unlock_49lfxxxc,
6971                 .write          = write_82802ab,
6972                 .read           = read_memmapped,
6973                 .voltage        = {3000, 3600},
6974         },
6975
6976         {
6977                 .vendor         = "SST",
6978                 .name           = "SST49LF008A",
6979                 .bustype        = BUS_FWH, /* A/A Mux */
6980                 .manufacture_id = SST_ID,
6981                 .model_id       = SST_SST49LF008A,
6982                 .total_size     = 1024,
6983                 .page_size      = 64 * 1024,
6984                 .feature_bits   = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
6985                 .tested         = TEST_OK_PREW,
6986                 .probe          = probe_jedec,
6987                 .probe_timing   = 1,            /* 150 ns */
6988                 .block_erasers  =
6989                 {
6990                         {
6991                                 .eraseblocks = { {4 * 1024, 256} },
6992                                 .block_erase = erase_sector_jedec,
6993                         }, {
6994                                 .eraseblocks = { {64 * 1024, 16} },
6995                                 .block_erase = erase_block_jedec,
6996                         }, {
6997                                 .eraseblocks = { {1024 * 1024, 1} },
6998                                 .block_erase = NULL, /* AA 55 80 AA 55 10, only in A/A mux mode */
6999                         }
7000                 },
7001                 .printlock      = printlock_sst_fwhub,
7002                 .unlock         = unlock_sst_fwhub,
7003                 .write          = write_jedec_1,
7004                 .read           = read_memmapped,
7005                 .voltage        = {3000, 3600},
7006         },
7007
7008         {
7009                 .vendor         = "SST",
7010                 .name           = "SST49LF008C",
7011                 .bustype        = BUS_FWH,
7012                 .manufacture_id = SST_ID,
7013                 .model_id       = SST_SST49LF008C,
7014                 .total_size     = 1024,
7015                 .page_size      = 4 * 1024,
7016                 .feature_bits   = FEATURE_REGISTERMAP,
7017                 .tested         = TEST_UNTESTED,
7018                 .probe          = probe_82802ab,
7019                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (sst49lfxxxc.c) */
7020                 .block_erasers  =
7021                 {
7022                         {
7023                                 .eraseblocks = { {4 * 1024, 256} },
7024                                 .block_erase = erase_sector_49lfxxxc,
7025                         }, {
7026                                 .eraseblocks = {
7027                                         {64 * 1024, 15},
7028                                         {32 * 1024, 1},
7029                                         {8 * 1024, 2},
7030                                         {16 * 1024, 1},
7031                                 },
7032                                 .block_erase = erase_block_82802ab,
7033                         }
7034                 },
7035                 .unlock         = unlock_49lfxxxc,
7036                 .write          = write_82802ab,
7037                 .read           = read_memmapped,
7038                 .voltage        = {3000, 3600},
7039         },
7040
7041         {
7042                 .vendor         = "SST",
7043                 .name           = "SST49LF016C",
7044                 .bustype        = BUS_FWH,
7045                 .manufacture_id = SST_ID,
7046                 .model_id       = SST_SST49LF016C,
7047                 .total_size     = 2048,
7048                 .page_size      = 4 * 1024,
7049                 .feature_bits   = FEATURE_REGISTERMAP,
7050                 .tested         = TEST_OK_PREW,
7051                 .probe          = probe_82802ab,
7052                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (sst49lfxxxc.c) */
7053                 .block_erasers  =
7054                 {
7055                         {
7056                                 .eraseblocks = { {4 * 1024, 512} },
7057                                 .block_erase = erase_sector_49lfxxxc,
7058                         }, {
7059                                 .eraseblocks = {
7060                                         {64 * 1024, 31},
7061                                         {32 * 1024, 1},
7062                                         {8 * 1024, 2},
7063                                         {16 * 1024, 1},
7064                                 },
7065                                 .block_erase = erase_block_82802ab,
7066                         }
7067                 },
7068                 .unlock         = unlock_49lfxxxc,
7069                 .write          = write_82802ab,
7070                 .read           = read_memmapped,
7071                 .voltage        = {3000, 3600},
7072         },
7073
7074         {
7075                 .vendor         = "SST",
7076                 .name           = "SST49LF020",
7077                 .bustype        = BUS_LPC,
7078                 .manufacture_id = SST_ID,
7079                 .model_id       = SST_SST49LF020,
7080                 .total_size     = 256,
7081                 .page_size      = 16 * 1024,
7082                 .feature_bits   = FEATURE_EITHER_RESET,
7083                 .tested         = TEST_OK_PREW,
7084                 .probe          = probe_jedec,
7085                 .probe_timing   = 1,                    /* 150 ns */
7086                 .block_erasers  =
7087                 {
7088                         {
7089                                 .eraseblocks = { {4 * 1024, 64} },
7090                                 .block_erase = erase_sector_jedec,
7091                         }, {
7092                                 .eraseblocks = { {16 * 1024, 16} },
7093                                 .block_erase = erase_block_jedec,
7094                         }, {
7095                                 .eraseblocks = { {256 * 1024, 1} },
7096                                 .block_erase = NULL,
7097                         }
7098                 },
7099                 .write          = write_jedec_1,
7100                 .read           = read_memmapped,
7101                 .voltage        = {3000, 3600},
7102         },
7103
7104         {
7105                 .vendor         = "SST",
7106                 .name           = "SST49LF020A",
7107                 .bustype        = BUS_LPC,
7108                 .manufacture_id = SST_ID,
7109                 .model_id       = SST_SST49LF020A,
7110                 .total_size     = 256,
7111                 .page_size      = 4 * 1024,
7112                 .feature_bits   = FEATURE_EITHER_RESET,
7113                 .tested         = TEST_OK_PRE,
7114                 .probe          = probe_jedec,
7115                 .probe_timing   = 1,                    /* 150 ns */
7116                 .block_erasers  =
7117                 {
7118                         {
7119                                 .eraseblocks = { {4 * 1024, 64} },
7120                                 .block_erase = erase_sector_jedec,
7121                         }, {
7122                                 .eraseblocks = { {16 * 1024, 16} },
7123                                 .block_erase = erase_block_jedec,
7124                         }, {
7125                                 .eraseblocks = { {256 * 1024, 1} },
7126                                 .block_erase = NULL,
7127                         }
7128                 },
7129                 .write          = write_jedec_1,
7130                 .read           = read_memmapped,
7131                 .voltage        = {3000, 3600},
7132         },
7133
7134         {
7135                 .vendor         = "SST",
7136                 .name           = "SST49LF040",
7137                 .bustype        = BUS_LPC,
7138                 .manufacture_id = SST_ID,
7139                 .model_id       = SST_SST49LF040,
7140                 .total_size     = 512,
7141                 .page_size      = 4096,
7142                 .feature_bits   = FEATURE_EITHER_RESET,
7143                 .tested         = TEST_OK_PRE,
7144                 .probe          = probe_jedec,
7145                 .probe_timing   = 1,                    /* 150 ns */
7146                 .block_erasers  =
7147                 {
7148                         {
7149                                 .eraseblocks = { {4 * 1024, 128} },
7150                                 .block_erase = erase_sector_jedec,
7151                         }, {
7152                                 .eraseblocks = { {64 * 1024, 8} },
7153                                 .block_erase = erase_block_jedec,
7154                         }, {
7155                                 .eraseblocks = { {512 * 1024, 1} },
7156                                 .block_erase = NULL,
7157                         }
7158                 },
7159                 .write          = write_jedec_1,
7160                 .read           = read_memmapped,
7161                 .voltage        = {3000, 3600},
7162         },
7163
7164         {
7165                 .vendor         = "SST",
7166                 .name           = "SST49LF040B",
7167                 .bustype        = BUS_LPC, /* A/A Mux */
7168                 .manufacture_id = SST_ID,
7169                 .model_id       = SST_SST49LF040B,
7170                 .total_size     = 512,
7171                 .page_size      = 64 * 1024,
7172                 .feature_bits   = FEATURE_EITHER_RESET | FEATURE_REGISTERMAP,
7173                 .tested         = TEST_OK_PREW,
7174                 .probe          = probe_jedec,
7175                 .probe_timing   = 1,            /* 150ns */
7176                 .block_erasers  =
7177                 {
7178                         {
7179                                 .eraseblocks = { {4 * 1024, 128} },
7180                                 .block_erase = erase_sector_jedec,
7181                         }, {
7182                                 .eraseblocks = { {64 * 1024, 8} },
7183                                 .block_erase = erase_block_jedec,
7184                         }, {
7185                                 .eraseblocks = { {512 * 1024, 1} },
7186                                 .block_erase = NULL,
7187                         }
7188                 },
7189                 .unlock         = unlock_82802ab,
7190                 .write          = write_jedec_1,
7191                 .read           = read_memmapped,
7192                 .voltage        = {3000, 3600},
7193         },
7194
7195         {
7196                 .vendor         = "SST",
7197                 .name           = "SST49LF080A",
7198                 .bustype        = BUS_LPC, /* A/A Mux */
7199                 .manufacture_id = SST_ID,
7200                 .model_id       = SST_SST49LF080A,
7201                 .total_size     = 1024,
7202                 .page_size      = 4096,
7203                 .feature_bits   = FEATURE_EITHER_RESET,
7204                 .tested         = TEST_OK_PREW,
7205                 .probe          = probe_jedec,
7206                 .probe_timing   = TIMING_FIXME,
7207                 .block_erasers  =
7208                 {
7209                         {
7210                                 .eraseblocks = { {4 * 1024, 256} },
7211                                 .block_erase = erase_sector_jedec,
7212                         }, {
7213                                 .eraseblocks = { {64 * 1024, 16} },
7214                                 .block_erase = erase_block_jedec,
7215                         }, {
7216                                 .eraseblocks = { {1024 * 1024, 1} },
7217                                 .block_erase = NULL,
7218                         }
7219                 },
7220                 .write          = write_jedec_1,
7221                 .read           = read_memmapped,
7222                 .voltage        = {3000, 3600},
7223         },
7224
7225         {
7226                 .vendor         = "SST",
7227                 .name           = "SST49LF160C",
7228                 .bustype        = BUS_LPC,
7229                 .manufacture_id = SST_ID,
7230                 .model_id       = SST_SST49LF160C,
7231                 .total_size     = 2048,
7232                 .page_size      = 4 * 1024,
7233                 .feature_bits   = FEATURE_REGISTERMAP,
7234                 .tested         = TEST_OK_PRE,
7235                 .probe          = probe_82802ab,
7236                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (sst49lfxxxc.c) */
7237                 .block_erasers  =
7238                 {
7239                         {
7240                                 .eraseblocks = { {4 * 1024, 512} },
7241                                 .block_erase = erase_sector_49lfxxxc,
7242                         }, {
7243                                 .eraseblocks = {
7244                                         {64 * 1024, 31},
7245                                         {32 * 1024, 1},
7246                                         {8 * 1024, 2},
7247                                         {16 * 1024, 1},
7248                                 },
7249                                 .block_erase = erase_block_82802ab,
7250                         }
7251                 },
7252                 .unlock         = unlock_49lfxxxc,
7253                 .write          = write_82802ab,
7254                 .read           = read_memmapped,
7255                 .voltage        = {3000, 3600},
7256         },
7257
7258         {
7259                 .vendor         = "ST",
7260                 .name           = "M25P05-A",
7261                 .bustype        = BUS_SPI,
7262                 .manufacture_id = ST_ID,
7263                 .model_id       = ST_M25P05A,
7264                 .total_size     = 64,
7265                 .page_size      = 256,
7266                 .feature_bits   = FEATURE_WRSR_WREN,
7267                 .tested         = TEST_UNTESTED,
7268                 .probe          = probe_spi_rdid,
7269                 .probe_timing   = TIMING_ZERO,
7270                 .block_erasers  =
7271                 {
7272                         {
7273                                 .eraseblocks = { {32 * 1024, 2} },
7274                                 .block_erase = spi_block_erase_d8,
7275                         }, {
7276                                 .eraseblocks = { {64 * 1024, 1} },
7277                                 .block_erase = spi_block_erase_c7,
7278                         }
7279                 },
7280                 .unlock         = spi_disable_blockprotect,
7281                 .write          = spi_chip_write_256,
7282                 .read           = spi_chip_read,
7283                 .voltage        = {2700, 3600},
7284         },
7285
7286         /* The ST M25P05 is a bit of a problem. It has the same ID as the
7287          * ST M25P05-A in RES mode, but supports only 128 byte writes instead
7288          * of 256 byte writes. We rely heavily on the fact that probe_spi_res1
7289          * only is successful if RDID does not work.
7290          */
7291         {
7292                 .vendor         = "ST",
7293                 .name           = "M25P05",
7294                 .bustype        = BUS_SPI,
7295                 .manufacture_id = 0, /* Not used. */
7296                 .model_id       = ST_M25P05_RES,
7297                 .total_size     = 64,
7298                 .page_size      = 256,
7299                 .feature_bits   = FEATURE_WRSR_WREN,
7300                 .tested         = TEST_UNTESTED,
7301                 .probe          = probe_spi_res1,
7302                 .probe_timing   = TIMING_ZERO,
7303                 .block_erasers  =
7304                 {
7305                         {
7306                                 .eraseblocks = { {32 * 1024, 2} },
7307                                 .block_erase = spi_block_erase_d8,
7308                         }, {
7309                                 .eraseblocks = { {64 * 1024, 1} },
7310                                 .block_erase = spi_block_erase_c7,
7311                         }
7312                 },
7313                 .unlock         = spi_disable_blockprotect,
7314                 .write          = spi_chip_write_1, /* 128 */
7315                 .read           = spi_chip_read,
7316                 .voltage        = {2700, 3600},
7317         },
7318
7319         {
7320                 .vendor         = "ST",
7321                 .name           = "M25P10-A",
7322                 .bustype        = BUS_SPI,
7323                 .manufacture_id = ST_ID,
7324                 .model_id       = ST_M25P10A,
7325                 .total_size     = 128,
7326                 .page_size      = 256,
7327                 .feature_bits   = FEATURE_WRSR_WREN,
7328                 .tested         = TEST_OK_PRE,
7329                 .probe          = probe_spi_rdid,
7330                 .probe_timing   = TIMING_ZERO,
7331                 .block_erasers  =
7332                 {
7333                         {
7334                                 .eraseblocks = { {32 * 1024, 4} },
7335                                 .block_erase = spi_block_erase_d8,
7336                         }, {
7337                                 .eraseblocks = { {128 * 1024, 1} },
7338                                 .block_erase = spi_block_erase_c7,
7339                         }
7340                 },
7341                 .unlock         = spi_disable_blockprotect,
7342                 .write          = spi_chip_write_256,
7343                 .read           = spi_chip_read,
7344                 .voltage        = {2700, 3600},
7345         },
7346
7347         /* The ST M25P10 has the same problem as the M25P05. */
7348         {
7349                 .vendor         = "ST",
7350                 .name           = "M25P10",
7351                 .bustype        = BUS_SPI,
7352                 .manufacture_id = 0, /* Not used. */
7353                 .model_id       = ST_M25P10_RES,
7354                 .total_size     = 128,
7355                 .page_size      = 256,
7356                 .feature_bits   = FEATURE_WRSR_WREN,
7357                 .tested         = TEST_UNTESTED,
7358                 .probe          = probe_spi_res1,
7359                 .probe_timing   = TIMING_ZERO,
7360                 .block_erasers  =
7361                 {
7362                         {
7363                                 .eraseblocks = { {32 * 1024, 4} },
7364                                 .block_erase = spi_block_erase_d8,
7365                         }, {
7366                                 .eraseblocks = { {128 * 1024, 1} },
7367                                 .block_erase = spi_block_erase_c7,
7368                         }
7369                 },
7370                 .unlock         = spi_disable_blockprotect,
7371                 .write          = spi_chip_write_1, /* 128 */
7372                 .read           = spi_chip_read,
7373                 .voltage        = {2700, 3600},
7374         },
7375
7376         {
7377                 .vendor         = "ST",
7378                 .name           = "M25P20",
7379                 .bustype        = BUS_SPI,
7380                 .manufacture_id = ST_ID,
7381                 .model_id       = ST_M25P20,
7382                 .total_size     = 256,
7383                 .page_size      = 256,
7384                 .feature_bits   = FEATURE_WRSR_WREN,
7385                 .tested         = TEST_UNTESTED,
7386                 .probe          = probe_spi_rdid,
7387                 .probe_timing   = TIMING_ZERO,
7388                 .block_erasers  =
7389                 {
7390                         {
7391                                 .eraseblocks = { {64 * 1024, 4} },
7392                                 .block_erase = spi_block_erase_d8,
7393                         }, {
7394                                 .eraseblocks = { {256 * 1024, 1} },
7395                                 .block_erase = spi_block_erase_c7,
7396                         }
7397                 },
7398                 .unlock         = spi_disable_blockprotect,
7399                 .write          = spi_chip_write_256,
7400                 .read           = spi_chip_read,
7401                 .voltage        = {2700, 3600},
7402         },
7403
7404         {
7405                 .vendor         = "ST", /* Numonyx */
7406                 .name           = "M25P40",
7407                 .bustype        = BUS_SPI,
7408                 .manufacture_id = ST_ID,
7409                 .model_id       = ST_M25P40,
7410                 .total_size     = 512,
7411                 .page_size      = 256,
7412                 .feature_bits   = FEATURE_WRSR_WREN,
7413                 .tested         = TEST_OK_PREW,
7414                 .probe          = probe_spi_rdid,
7415                 .probe_timing   = TIMING_ZERO,
7416                 .block_erasers  =
7417                 {
7418                         {
7419                                 .eraseblocks = { {64 * 1024, 8} },
7420                                 .block_erase = spi_block_erase_d8,
7421                         }, {
7422                                 .eraseblocks = { {512 * 1024, 1} },
7423                                 .block_erase = spi_block_erase_c7,
7424                         }
7425                 },
7426                 .unlock         = spi_disable_blockprotect,
7427                 .write          = spi_chip_write_256,
7428                 .read           = spi_chip_read,
7429                 .voltage        = {2700, 3600},
7430         },
7431
7432         {
7433                 .vendor         = "ST",
7434                 .name           = "M25P40-old",
7435                 .bustype        = BUS_SPI,
7436                 .manufacture_id = 0, /* Not used. */
7437                 .model_id       = ST_M25P40_RES,
7438                 .total_size     = 512,
7439                 .page_size      = 256,
7440                 .feature_bits   = FEATURE_WRSR_WREN,
7441                 .tested         = TEST_UNTESTED,
7442                 .probe          = probe_spi_res1,
7443                 .probe_timing   = TIMING_ZERO,
7444                 .block_erasers  =
7445                 {
7446                         {
7447                                 .eraseblocks = { {64 * 1024, 8} },
7448                                 .block_erase = spi_block_erase_d8,
7449                         }, {
7450                                 .eraseblocks = { {512 * 1024, 1} },
7451                                 .block_erase = spi_block_erase_c7,
7452                         }
7453                 },
7454                 .unlock         = spi_disable_blockprotect,
7455                 .write          = spi_chip_write_256,
7456                 .read           = spi_chip_read,
7457         },
7458
7459         {
7460                 .vendor         = "ST",
7461                 .name           = "M25P80",
7462                 .bustype        = BUS_SPI,
7463                 .manufacture_id = ST_ID,
7464                 .model_id       = ST_M25P80,
7465                 .total_size     = 1024,
7466                 .page_size      = 256,
7467                 .feature_bits   = FEATURE_WRSR_WREN,
7468                 .tested         = TEST_OK_PREW,
7469                 .probe          = probe_spi_rdid,
7470                 .probe_timing   = TIMING_ZERO,
7471                 .block_erasers  =
7472                 {
7473                         {
7474                                 .eraseblocks = { {64 * 1024, 16} },
7475                                 .block_erase = spi_block_erase_d8,
7476                         }, {
7477                                 .eraseblocks = { {1024 * 1024, 1} },
7478                                 .block_erase = spi_block_erase_c7,
7479                         }
7480                 },
7481                 .unlock         = spi_disable_blockprotect,
7482                 .write          = spi_chip_write_256,
7483                 .read           = spi_chip_read,
7484                 .voltage        = {2700, 3600},
7485         },
7486
7487         {
7488                 .vendor         = "ST",
7489                 .name           = "M25P16",
7490                 .bustype        = BUS_SPI,
7491                 .manufacture_id = ST_ID,
7492                 .model_id       = ST_M25P16,
7493                 .total_size     = 2048,
7494                 .page_size      = 256,
7495                 .feature_bits   = FEATURE_WRSR_WREN,
7496                 .tested         = TEST_OK_PR,
7497                 .probe          = probe_spi_rdid,
7498                 .probe_timing   = TIMING_ZERO,
7499                 .block_erasers  =
7500                 {
7501                         {
7502                                 .eraseblocks = { {64 * 1024, 32} },
7503                                 .block_erase = spi_block_erase_d8,
7504                         }, {
7505                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
7506                                 .block_erase = spi_block_erase_c7,
7507                         }
7508                 },
7509                 .unlock         = spi_disable_blockprotect,
7510                 .write          = spi_chip_write_256,
7511                 .read           = spi_chip_read,
7512                 .voltage        = {2700, 3600},
7513         },
7514
7515         {
7516                 .vendor         = "ST",
7517                 .name           = "M25P32",
7518                 .bustype        = BUS_SPI,
7519                 .manufacture_id = ST_ID,
7520                 .model_id       = ST_M25P32,
7521                 .total_size     = 4096,
7522                 .page_size      = 256,
7523                 .feature_bits   = FEATURE_WRSR_WREN,
7524                 .tested         = TEST_OK_PREW,
7525                 .probe          = probe_spi_rdid,
7526                 .probe_timing   = TIMING_ZERO,
7527                 .block_erasers  =
7528                 {
7529                         {
7530                                 .eraseblocks = { {64 * 1024, 64} },
7531                                 .block_erase = spi_block_erase_d8,
7532                         }, {
7533                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
7534                                 .block_erase = spi_block_erase_c7,
7535                         }
7536                 },
7537                 .unlock         = spi_disable_blockprotect,
7538                 .write          = spi_chip_write_256,
7539                 .read           = spi_chip_read,
7540                 .voltage        = {2700, 3600},
7541         },
7542
7543         {
7544                 .vendor         = "ST",
7545                 .name           = "M25P64",
7546                 .bustype        = BUS_SPI,
7547                 .manufacture_id = ST_ID,
7548                 .model_id       = ST_M25P64,
7549                 .total_size     = 8192,
7550                 .page_size      = 256,
7551                 .feature_bits   = FEATURE_WRSR_WREN,
7552                 .tested         = TEST_OK_PREW,
7553                 .probe          = probe_spi_rdid,
7554                 .probe_timing   = TIMING_ZERO,
7555                 .block_erasers  =
7556                 {
7557                         {
7558                                 .eraseblocks = { {64 * 1024, 128} },
7559                                 .block_erase = spi_block_erase_d8,
7560                         }, {
7561                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
7562                                 .block_erase = spi_block_erase_c7,
7563                         }
7564                 },
7565                 .unlock         = spi_disable_blockprotect,
7566                 .write          = spi_chip_write_256,
7567                 .read           = spi_chip_read,
7568                 .voltage        = {2700, 3600},
7569         },
7570
7571         {
7572                 .vendor         = "ST",
7573                 .name           = "M25P128",
7574                 .bustype        = BUS_SPI,
7575                 .manufacture_id = ST_ID,
7576                 .model_id       = ST_M25P128,
7577                 .total_size     = 16384,
7578                 .page_size      = 256,
7579                 .feature_bits   = FEATURE_WRSR_WREN,
7580                 .tested         = TEST_OK_PREW,
7581                 .probe          = probe_spi_rdid,
7582                 .probe_timing   = TIMING_ZERO,
7583                 .block_erasers  =
7584                 {
7585                         {
7586                                 .eraseblocks = { {256 * 1024, 64} },
7587                                 .block_erase = spi_block_erase_d8,
7588                         }, {
7589                                 .eraseblocks = { {16 * 1024 * 1024, 1} },
7590                                 .block_erase = spi_block_erase_c7,
7591                         }
7592                 },
7593                 .unlock         = spi_disable_blockprotect,
7594                 .write          = spi_chip_write_256,
7595                 .read           = spi_chip_read,
7596                 .voltage        = {2700, 3600},
7597         },
7598
7599         {
7600                 .vendor         = "ST",
7601                 .name           = "M25PX16",
7602                 .bustype        = BUS_SPI,
7603                 .manufacture_id = ST_ID,
7604                 .model_id       = ST_M25PX16,
7605                 .total_size     = 2048,
7606                 .page_size      = 256,
7607                 /* OTP: 64B total; read 0x4B; write 0x42 */
7608                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
7609                 .tested         = TEST_OK_PREW,
7610                 .probe          = probe_spi_rdid,
7611                 .probe_timing   = TIMING_ZERO,
7612                 .block_erasers  =
7613                 {
7614                         {
7615                                 .eraseblocks = { { 4 * 1024, 512 } },
7616                                 .block_erase = spi_block_erase_20,
7617                         }, {
7618                                 .eraseblocks = { {64 * 1024, 32} },
7619                                 .block_erase = spi_block_erase_d8,
7620                         }, {
7621                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
7622                                 .block_erase = spi_block_erase_c7,
7623                         }
7624                 },
7625                 .unlock         = spi_disable_blockprotect,
7626                 .write          = spi_chip_write_256,
7627                 .read           = spi_chip_read,
7628         },
7629
7630         {
7631                 .vendor         = "ST",
7632                 .name           = "M25PX32",
7633                 .bustype        = BUS_SPI,
7634                 .manufacture_id = ST_ID,
7635                 .model_id       = ST_M25PX32,
7636                 .total_size     = 4096,
7637                 .page_size      = 256,
7638                 .feature_bits   = FEATURE_WRSR_WREN,
7639                 .tested         = TEST_OK_PRE,
7640                 .probe          = probe_spi_rdid,
7641                 .probe_timing   = TIMING_ZERO,
7642                 .block_erasers  =
7643                 {
7644                         {
7645                                 .eraseblocks = { { 4 * 1024, 1024 } },
7646                                 .block_erase = spi_block_erase_20,
7647                         }, {
7648                                 .eraseblocks = { {64 * 1024, 64} },
7649                                 .block_erase = spi_block_erase_d8,
7650                         }, {
7651                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
7652                                 .block_erase = spi_block_erase_c7,
7653                         }
7654                 },
7655                 .unlock         = spi_disable_blockprotect,
7656                 .write          = spi_chip_write_256,
7657                 .read           = spi_chip_read,
7658                 .voltage        = {2700, 3600},
7659         },
7660
7661         {
7662                 .vendor         = "ST",
7663                 .name           = "M25PX64",
7664                 .bustype        = BUS_SPI,
7665                 .manufacture_id = ST_ID,
7666                 .model_id       = ST_M25PX64,
7667                 .total_size     = 8192,
7668                 .page_size      = 256,
7669                 .feature_bits   = FEATURE_WRSR_WREN,
7670                 .tested         = TEST_OK_PRE,
7671                 .probe          = probe_spi_rdid,
7672                 .probe_timing   = TIMING_ZERO,
7673                 .block_erasers  =
7674                 {
7675                         {
7676                                 .eraseblocks = { { 4 * 1024, 2048 } },
7677                                 .block_erase = spi_block_erase_20,
7678                         }, {
7679                                 .eraseblocks = { {64 * 1024, 128} },
7680                                 .block_erase = spi_block_erase_d8,
7681                         }, {
7682                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
7683                                 .block_erase = spi_block_erase_c7,
7684                         }
7685                 },
7686                 .unlock         = spi_disable_blockprotect,
7687                 .write          = spi_chip_write_256,
7688                 .read           = spi_chip_read,
7689         },
7690
7691         {
7692                 .vendor         = "ST",
7693                 .name           = "M29F002B",
7694                 .bustype        = BUS_PARALLEL,
7695                 .manufacture_id = ST_ID,
7696                 .model_id       = ST_M29F002B,
7697                 .total_size     = 256,
7698                 .page_size      = 64 * 1024,
7699                 .feature_bits   = FEATURE_ADDR_AAA | FEATURE_EITHER_RESET,
7700                 .tested         = TEST_UNTESTED,
7701                 .probe          = probe_jedec,
7702                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
7703                 .block_erasers  =
7704                 {
7705                         {
7706                                 .eraseblocks = {
7707                                         {16 * 1024, 1},
7708                                         {8 * 1024, 2},
7709                                         {32 * 1024, 1},
7710                                         {64 * 1024, 3},
7711                                 },
7712                                 .block_erase = erase_sector_jedec,
7713                         }, {
7714                                 .eraseblocks = { {256 * 1024, 1} },
7715                                 .block_erase = erase_chip_block_jedec,
7716                         }
7717                 },
7718                 .write          = write_jedec_1,
7719                 .read           = read_memmapped,
7720                 .voltage        = {4750, 5250}, /* 4.75-5.25V for type -X, others 4.5-5.5V */
7721         },
7722
7723         {
7724                 .vendor         = "ST",
7725                 .name           = "M29F002T/NT",
7726                 .bustype        = BUS_PARALLEL,
7727                 .manufacture_id = ST_ID,
7728                 .model_id       = ST_M29F002T,
7729                 .total_size     = 256,
7730                 .page_size      = 64 * 1024,
7731                 .feature_bits   = FEATURE_ADDR_AAA | FEATURE_EITHER_RESET,
7732                 .tested         = TEST_UNTESTED,
7733                 .probe          = probe_jedec,
7734                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
7735                 .block_erasers  =
7736                 {
7737                         {
7738                                 .eraseblocks = {
7739                                         {64 * 1024, 3},
7740                                         {32 * 1024, 1},
7741                                         {8 * 1024, 2},
7742                                         {16 * 1024, 1},
7743                                 },
7744                                 .block_erase = erase_sector_jedec,
7745                         }, {
7746                                 .eraseblocks = { {256 * 1024, 1} },
7747                                 .block_erase = erase_chip_block_jedec,
7748                         }
7749                 },
7750                 .write          = write_jedec_1,
7751                 .read           = read_memmapped,
7752                 .voltage        = {4750, 5250}, /* 4.75-5.25V for type -X, others 4.5-5.5V */
7753         },
7754
7755         {
7756                 .vendor         = "ST",
7757                 .name           = "M29F040B",
7758                 .bustype        = BUS_PARALLEL,
7759                 .manufacture_id = ST_ID,
7760                 .model_id       = ST_M29F040B,
7761                 .total_size     = 512,
7762                 .page_size      = 64 * 1024,
7763                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
7764                 .tested         = TEST_UNTESTED,
7765                 .probe          = probe_jedec,
7766                 .probe_timing   = TIMING_ZERO, /* datasheet specifies no timing */
7767                 .block_erasers  =
7768                 {
7769                         {
7770                                 .eraseblocks = { {64 * 1024, 8}, },
7771                                 .block_erase = erase_sector_jedec,
7772                         }, {
7773                                 .eraseblocks = { {512 * 1024, 1} },
7774                                 .block_erase = erase_chip_block_jedec,
7775                         }
7776                 },
7777                 .write          = write_jedec_1,
7778                 .read           = read_memmapped,
7779                 .voltage        = {4500, 5500},
7780         },
7781
7782         {
7783                 /* FIXME: this has WORD/BYTE sequences; 2AA for word, 555 for byte */
7784                 .vendor         = "ST",
7785                 .name           = "M29F400BB",
7786                 .bustype        = BUS_PARALLEL,
7787                 .manufacture_id = ST_ID,
7788                 .model_id       = ST_M29F400BB,
7789                 .total_size     = 512,
7790                 .page_size      = 64 * 1024,
7791                 .feature_bits   = FEATURE_ADDR_SHIFTED | FEATURE_EITHER_RESET,
7792                 .tested         = TEST_UNTESTED,
7793                 .probe          = probe_m29f400bt,
7794                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (m29f400bt.c) */
7795                 .block_erasers  =
7796                 {
7797                         {
7798                                 .eraseblocks = {
7799                                         {16 * 1024, 1},
7800                                         {8 * 1024, 2},
7801                                         {32 * 1024, 1},
7802                                         {64 * 1024, 7},
7803                                 },
7804                                 .block_erase = block_erase_m29f400bt,
7805                         }, {
7806                                 .eraseblocks = { {512 * 1024, 1} },
7807                                 .block_erase = block_erase_chip_m29f400bt,
7808                         }
7809                 },
7810                 .write          = write_m29f400bt,
7811                 .read           = read_memmapped,
7812                 .voltage        = {4500, 5500},
7813         },
7814         {
7815                 /* FIXME: this has WORD/BYTE sequences; 2AA for word, 555 for byte */
7816                 .vendor         = "ST",
7817                 .name           = "M29F400BT",
7818                 .bustype        = BUS_PARALLEL,
7819                 .manufacture_id = ST_ID,
7820                 .model_id       = ST_M29F400BT,
7821                 .total_size     = 512,
7822                 .page_size      = 64 * 1024,
7823                 .feature_bits   = FEATURE_ADDR_SHIFTED | FEATURE_EITHER_RESET,
7824                 .tested         = TEST_UNTESTED,
7825                 .probe          = probe_m29f400bt,
7826                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (m29f400bt.c) */
7827                 .block_erasers  =
7828                 {
7829                         {
7830                                 .eraseblocks = {
7831                                         {64 * 1024, 7},
7832                                         {32 * 1024, 1},
7833                                         {8 * 1024, 2},
7834                                         {16 * 1024, 1},
7835                                 },
7836                                 .block_erase = block_erase_m29f400bt,
7837                         }, {
7838                                 .eraseblocks = { {512 * 1024, 1} },
7839                                 .block_erase = block_erase_chip_m29f400bt,
7840                         }
7841                 },
7842                 .write          = write_m29f400bt,
7843                 .read           = read_memmapped,
7844                 .voltage        = {4500, 5500},
7845         },
7846
7847         {
7848                 .vendor         = "ST",
7849                 .name           = "M29W010B",
7850                 .bustype        = BUS_PARALLEL,
7851                 .manufacture_id = ST_ID,
7852                 .model_id       = ST_M29W010B,
7853                 .total_size     = 128,
7854                 .page_size      = 16 * 1024,
7855                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
7856                 .tested         = TEST_UNTESTED,
7857                 .probe          = probe_jedec,
7858                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
7859                 .block_erasers  =
7860                 {
7861                         {
7862                                 .eraseblocks = { {16 * 1024, 8}, },
7863                                 .block_erase = erase_sector_jedec,
7864                         }, {
7865                                 .eraseblocks = { {128 * 1024, 1} },
7866                                 .block_erase = erase_chip_block_jedec,
7867                         }
7868                 },
7869                 .write          = write_jedec_1,
7870                 .read           = read_memmapped,
7871                 .voltage        = {2700, 3600},
7872         },
7873
7874         {
7875                 .vendor         = "ST",
7876                 .name           = "M29W040B",
7877                 .bustype        = BUS_PARALLEL,
7878                 .manufacture_id = ST_ID,
7879                 .model_id       = ST_M29W040B,
7880                 .total_size     = 512,
7881                 .page_size      = 64 * 1024,
7882                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
7883                 .tested         = TEST_UNTESTED,
7884                 .probe          = probe_jedec,
7885                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
7886                 .block_erasers  =
7887                 {
7888                         {
7889                                 .eraseblocks = { {64 * 1024, 8}, },
7890                                 .block_erase = erase_sector_jedec,
7891                         }, {
7892                                 .eraseblocks = { {512 * 1024, 1} },
7893                                 .block_erase = erase_chip_block_jedec,
7894                         }
7895                 },
7896                 .write          = write_jedec_1,
7897                 .read           = read_memmapped,
7898                 .voltage        = {2700, 3600},
7899         },
7900
7901         {
7902                 .vendor         = "ST",
7903                 .name           = "M29W512B",
7904                 .bustype        = BUS_PARALLEL,
7905                 .manufacture_id = ST_ID,
7906                 .model_id       = ST_M29W512B,
7907                 .total_size     = 64,
7908                 .page_size      = 64 * 1024,
7909                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
7910                 .tested         = TEST_OK_PRE,
7911                 .probe          = probe_jedec,
7912                 .probe_timing   = TIMING_ZERO,
7913                 .block_erasers  =
7914                 {
7915                         {
7916                                 .eraseblocks = { {64 * 1024, 1} },
7917                                 .block_erase = erase_chip_block_jedec,
7918                         }
7919                 },
7920                 .write          = write_jedec_1,
7921                 .read           = read_memmapped,
7922                 .voltage        = {2700, 3600},
7923         },
7924
7925         {
7926                 .vendor         = "ST",
7927                 .name           = "M50FLW040A",
7928                 .bustype        = BUS_FWH | BUS_LPC, /* A/A Mux */
7929                 .manufacture_id = ST_ID,
7930                 .model_id       = ST_M50FLW040A,
7931                 .total_size     = 512,
7932                 .page_size      = 64 * 1024,
7933                 .feature_bits   = FEATURE_REGISTERMAP,
7934                 .tested         = TEST_UNTESTED,
7935                 .probe          = probe_82802ab,
7936                 .probe_timing   = TIMING_FIXME,
7937                 .block_erasers  =
7938                 {
7939                         {
7940                                 .eraseblocks = {
7941                                         {4 * 1024, 16}, /* sector */
7942                                         {64 * 1024, 5}, /* block */
7943                                         {4 * 1024, 16}, /* sector */
7944                                         {4 * 1024, 16}, /* sector */
7945                                 },
7946                                 .block_erase = NULL,
7947                         }, {
7948                                 .eraseblocks = { {64 * 1024, 8}, },
7949                                 .block_erase = erase_block_82802ab,
7950                         }
7951                 },
7952                 .unlock         = unlock_stm50flw0x0x,
7953                 .write          = write_82802ab,
7954                 .read           = read_memmapped,
7955                 .voltage        = {3000, 3600}, /* Also has 12V fast program & erase */
7956         },
7957
7958         {
7959                 .vendor         = "ST",
7960                 .name           = "M50FLW040B",
7961                 .bustype        = BUS_FWH | BUS_LPC, /* A/A Mux */
7962                 .manufacture_id = ST_ID,
7963                 .model_id       = ST_M50FLW040B,
7964                 .total_size     = 512,
7965                 .page_size      = 64 * 1024,
7966                 .feature_bits   = FEATURE_REGISTERMAP,
7967                 .tested         = TEST_UNTESTED,
7968                 .probe          = probe_82802ab,
7969                 .probe_timing   = TIMING_FIXME,
7970                 .block_erasers  =
7971                 {
7972                         {
7973                                 .eraseblocks = {
7974                                         {4 * 1024, 16}, /* sector */
7975                                         {4 * 1024, 16}, /* sector */
7976                                         {64 * 1024, 5}, /* block */
7977                                         {4 * 1024, 16}, /* sector */
7978                                 },
7979                                 .block_erase = NULL,
7980                         }, {
7981                                 .eraseblocks = { {64 * 1024, 8}, },
7982                                 .block_erase = erase_block_82802ab,
7983                         }
7984                 },
7985                 .unlock         = unlock_stm50flw0x0x,
7986                 .write          = write_82802ab,
7987                 .read           = read_memmapped,
7988                 .voltage        = {3000, 3600}, /* Also has 12V fast program & erase */
7989         },
7990
7991         {
7992                 .vendor         = "ST",
7993                 .name           = "M50FLW080A",
7994                 .bustype        = BUS_FWH | BUS_LPC, /* A/A Mux */
7995                 .manufacture_id = ST_ID,
7996                 .model_id       = ST_M50FLW080A,
7997                 .total_size     = 1024,
7998                 .page_size      = 64 * 1024,
7999                 .feature_bits   = FEATURE_REGISTERMAP,
8000                 .tested         = TEST_OK_PRE,
8001                 .probe          = probe_82802ab,
8002                 .probe_timing   = TIMING_FIXME,
8003                 .block_erasers  =
8004                 {
8005                         {
8006                                 .eraseblocks = {
8007                                         {4 * 1024, 16}, /* sector */
8008                                         {64 * 1024, 13}, /* block */
8009                                         {4 * 1024, 16}, /* sector */
8010                                         {4 * 1024, 16}, /* sector */
8011                                 },
8012                                 .block_erase = NULL,
8013                         }, {
8014                                 .eraseblocks = { {64 * 1024, 16}, },
8015                                 .block_erase = erase_block_82802ab,
8016                         }
8017                 },
8018                 .unlock         = unlock_stm50flw0x0x,
8019                 .write          = write_82802ab,
8020                 .read           = read_memmapped,
8021                 .voltage        = {3000, 3600}, /* Also has 12V fast program & erase */
8022         },
8023
8024         {
8025                 .vendor         = "ST",
8026                 .name           = "M50FLW080B",
8027                 .bustype        = BUS_FWH | BUS_LPC, /* A/A Mux */
8028                 .manufacture_id = ST_ID,
8029                 .model_id       = ST_M50FLW080B,
8030                 .total_size     = 1024,
8031                 .page_size      = 64 * 1024,
8032                 .feature_bits   = FEATURE_REGISTERMAP,
8033                 .tested         = TEST_UNTESTED,
8034                 .probe          = probe_82802ab,
8035                 .probe_timing   = TIMING_FIXME,
8036                 .block_erasers  =
8037                 {
8038                         {
8039                                 .eraseblocks = {
8040                                         {4 * 1024, 16}, /* sector */
8041                                         {4 * 1024, 16}, /* sector */
8042                                         {64 * 1024, 13}, /* block */
8043                                         {4 * 1024, 16}, /* sector */
8044                                 },
8045                                 .block_erase = NULL,
8046                         }, {
8047                                 .eraseblocks = { {64 * 1024, 16}, },
8048                                 .block_erase = erase_block_82802ab,
8049                         }
8050                 },
8051                 .unlock         = unlock_stm50flw0x0x,
8052                 .write          = write_82802ab,
8053                 .read           = read_memmapped,
8054                 .voltage        = {3000, 3600}, /* Also has 12V fast program & erase */
8055         },
8056
8057         {
8058                 .vendor         = "ST",
8059                 .name           = "M50FW002",
8060                 .bustype        = BUS_FWH, /* A/A Mux */
8061                 .manufacture_id = ST_ID,
8062                 .model_id       = ST_M50FW002,
8063                 .total_size     = 256,
8064                 .page_size      = 64 * 1024,
8065                 .feature_bits   = FEATURE_REGISTERMAP,
8066                 .tested         = TEST_UNTESTED,
8067                 .probe          = probe_82802ab,
8068                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (sst49lfxxxc.c) */
8069                 .block_erasers  =
8070                 {
8071                         {
8072                                 .eraseblocks = {
8073                                         {64 * 1024, 3},
8074                                         {32 * 1024, 1},
8075                                         {8 * 1024, 2},
8076                                         {16 * 1024, 1},
8077                                 },
8078                                 .block_erase = erase_block_82802ab,
8079                         }
8080                 },
8081                 .unlock         = unlock_stm50flw0x0x,
8082                 .write          = write_82802ab,
8083                 .read           = read_memmapped,
8084                 .voltage        = {3000, 3600}, /* Also has 12V fast program & erase */
8085         },
8086
8087         {
8088                 .vendor         = "ST",
8089                 .name           = "M50FW016",
8090                 .bustype        = BUS_FWH, /* A/A Mux */
8091                 .manufacture_id = ST_ID,
8092                 .model_id       = ST_M50FW016,
8093                 .total_size     = 2048,
8094                 .page_size      = 64 * 1024,
8095                 .feature_bits   = FEATURE_REGISTERMAP,
8096                 .tested         = TEST_UNTESTED,
8097                 .probe          = probe_82802ab,
8098                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (82802ab.c) */
8099                 .block_erasers  =
8100                 {
8101                         {
8102                                 .eraseblocks = { {64 * 1024, 32}, },
8103                                 .block_erase = erase_block_82802ab,
8104                         }
8105                 },
8106                 .unlock         = unlock_stm50flw0x0x,
8107                 .write          = write_82802ab,
8108                 .read           = read_memmapped,
8109                 .voltage        = {3000, 3600}, /* Also has 12V fast program & erase */
8110         },
8111
8112         {
8113                 .vendor         = "ST",
8114                 .name           = "M50FW040",
8115                 .bustype        = BUS_FWH, /* A/A Mux */
8116                 .manufacture_id = ST_ID,
8117                 .model_id       = ST_M50FW040,
8118                 .total_size     = 512,
8119                 .page_size      = 64 * 1024,
8120                 .feature_bits   = FEATURE_REGISTERMAP,
8121                 .tested         = TEST_OK_PR,
8122                 .probe          = probe_82802ab,
8123                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (82802ab.c) */
8124                 .block_erasers  =
8125                 {
8126                         {
8127                                 .eraseblocks = { {64 * 1024, 8}, },
8128                                 .block_erase = erase_block_82802ab,
8129                         }
8130                 },
8131                 .unlock         = unlock_stm50flw0x0x,
8132                 .write          = write_82802ab,
8133                 .read           = read_memmapped,
8134                 .voltage        = {3000, 3600}, /* Also has 12V fast program & erase */
8135         },
8136
8137         {
8138                 .vendor         = "ST",
8139                 .name           = "M50FW080",
8140                 .bustype        = BUS_FWH, /* A/A Mux */
8141                 .manufacture_id = ST_ID,
8142                 .model_id       = ST_M50FW080,
8143                 .total_size     = 1024,
8144                 .page_size      = 64 * 1024,
8145                 .feature_bits   = FEATURE_REGISTERMAP,
8146                 .tested         = TEST_OK_PREW,
8147                 .probe          = probe_82802ab,
8148                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (82802ab.c) */
8149                 .block_erasers  =
8150                 {
8151                         {
8152                                 .eraseblocks = { {64 * 1024, 16}, },
8153                                 .block_erase = erase_block_82802ab,
8154                         }
8155                 },
8156                 .unlock         = unlock_stm50flw0x0x,
8157                 .write          = write_82802ab,
8158                 .read           = read_memmapped,
8159                 .voltage        = {3000, 3600}, /* Also has 12V fast program & erase */
8160         },
8161
8162         {
8163                 .vendor         = "ST",
8164                 .name           = "M50LPW116",
8165                 .bustype        = BUS_LPC, /* A/A Mux */
8166                 .manufacture_id = ST_ID,
8167                 .model_id       = ST_M50LPW116,
8168                 .total_size     = 2048,
8169                 .page_size      = 64 * 1024,
8170                 .feature_bits   = FEATURE_REGISTERMAP,
8171                 .tested         = TEST_UNTESTED,
8172                 .probe          = probe_82802ab,
8173                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
8174                 .block_erasers  =
8175                 {
8176                         {
8177                                 .eraseblocks = {
8178                                         {4 * 1024, 16},
8179                                         {64 * 1024, 30},
8180                                         {32 * 1024, 1},
8181                                         {8 * 1024, 2},
8182                                         {16 * 1024, 1},
8183                                 },
8184                                 .block_erase = erase_block_82802ab,
8185                         }
8186                 },
8187                 .unlock         = unlock_stm50flw0x0x,
8188                 .write          = write_82802ab,
8189                 .read           = read_memmapped,
8190                 .voltage        = {3000, 3600}, /* Also has 12V fast program & erase */
8191         },
8192
8193         {
8194                 .vendor         = "SyncMOS/MoselVitelic",
8195                 .name           = "{F,S,V}29C51001B",
8196                 .bustype        = BUS_PARALLEL,
8197                 .manufacture_id = SYNCMOS_MVC_ID,
8198                 .model_id       = SM_MVC_29C51001B,
8199                 .total_size     = 128,
8200                 .page_size      = 512,
8201                 .feature_bits   = FEATURE_EITHER_RESET,
8202                 .tested         = TEST_UNTESTED,
8203                 .probe          = probe_jedec,
8204                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
8205                 .block_erasers  =
8206                 {
8207                         {
8208                                 .eraseblocks = { {512, 256} },
8209                                 .block_erase = erase_sector_jedec,
8210                         }, {
8211                                 .eraseblocks = { {128 * 1024, 1} },
8212                                 .block_erase = erase_chip_block_jedec,
8213                         },
8214                 },
8215                 .write          = write_jedec_1,
8216                 .read           = read_memmapped,
8217                 .voltage        = {4500, 5500},
8218         },
8219
8220         {
8221                 .vendor         = "SyncMOS/MoselVitelic",
8222                 .name           = "{F,S,V}29C51001T",
8223                 .bustype        = BUS_PARALLEL,
8224                 .manufacture_id = SYNCMOS_MVC_ID,
8225                 .model_id       = SM_MVC_29C51001T,
8226                 .total_size     = 128,
8227                 .page_size      = 512,
8228                 .feature_bits   = FEATURE_EITHER_RESET,
8229                 .tested         = TEST_UNTESTED,
8230                 .probe          = probe_jedec,
8231                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
8232                 .block_erasers  =
8233                 {
8234                         {
8235                                 .eraseblocks = { {512, 256} },
8236                                 .block_erase = erase_sector_jedec,
8237                         }, {
8238                                 .eraseblocks = { {128 * 1024, 1} },
8239                                 .block_erase = erase_chip_block_jedec,
8240                         },
8241                 },
8242                 .write          = write_jedec_1,
8243                 .read           = read_memmapped,
8244                 .voltage        = {4500, 5500},
8245         },
8246
8247         {
8248                 .vendor         = "SyncMOS/MoselVitelic",
8249                 .name           = "{F,S,V}29C51002B",
8250                 .bustype        = BUS_PARALLEL,
8251                 .manufacture_id = SYNCMOS_MVC_ID,
8252                 .model_id       = SM_MVC_29C51002B,
8253                 .total_size     = 256,
8254                 .page_size      = 512,
8255                 .feature_bits   = FEATURE_EITHER_RESET,
8256                 .tested         = TEST_UNTESTED,
8257                 .probe          = probe_jedec,
8258                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
8259                 .block_erasers  =
8260                 {
8261                         {
8262                                 .eraseblocks = { {512, 512} },
8263                                 .block_erase = erase_sector_jedec,
8264                         }, {
8265                                 .eraseblocks = { {256 * 1024, 1} },
8266                                 .block_erase = erase_chip_block_jedec,
8267                         },
8268                 },
8269                 .write          = write_jedec_1,
8270                 .read           = read_memmapped,
8271         },
8272
8273         {
8274                 .vendor         = "SyncMOS/MoselVitelic",
8275                 .name           = "{F,S,V}29C51002T",
8276                 .bustype        = BUS_PARALLEL,
8277                 .manufacture_id = SYNCMOS_MVC_ID,
8278                 .model_id       = SM_MVC_29C51002T,
8279                 .total_size     = 256,
8280                 .page_size      = 512,
8281                 .feature_bits   = FEATURE_EITHER_RESET,
8282                 .tested         = TEST_OK_PREW,
8283                 .probe          = probe_jedec,
8284                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
8285                 .block_erasers  =
8286                 {
8287                         {
8288                                 .eraseblocks = { {512, 512} },
8289                                 .block_erase = erase_sector_jedec,
8290                         }, {
8291                                 .eraseblocks = { {256 * 1024, 1} },
8292                                 .block_erase = erase_chip_block_jedec,
8293                         },
8294                 },
8295                 .write          = write_jedec_1,
8296                 .read           = read_memmapped,
8297         },
8298
8299         {
8300                 .vendor         = "SyncMOS/MoselVitelic",
8301                 .name           = "{F,S,V}29C51004B",
8302                 .bustype        = BUS_PARALLEL,
8303                 .manufacture_id = SYNCMOS_MVC_ID,
8304                 .model_id       = SM_MVC_29C51004B,
8305                 .total_size     = 512,
8306                 .page_size      = 1024,
8307                 .feature_bits   = FEATURE_EITHER_RESET,
8308                 .tested         = TEST_UNTESTED,
8309                 .probe          = probe_jedec,
8310                 .probe_timing   = TIMING_ZERO,
8311                 .block_erasers  =
8312                 {
8313                         {
8314                                 .eraseblocks = { {1024, 512} },
8315                                 .block_erase = erase_sector_jedec,
8316                         }, {
8317                                 .eraseblocks = { {512 * 1024, 1} },
8318                                 .block_erase = erase_chip_block_jedec,
8319                         },
8320                 },
8321                 .write          = write_jedec_1,
8322                 .read           = read_memmapped,
8323                 .voltage        = {4500, 5500},
8324         },
8325
8326         {
8327                 .vendor         = "SyncMOS/MoselVitelic",
8328                 .name           = "{F,S,V}29C51004T",
8329                 .bustype        = BUS_PARALLEL,
8330                 .manufacture_id = SYNCMOS_MVC_ID,
8331                 .model_id       = SM_MVC_29C51004T,
8332                 .total_size     = 512,
8333                 .page_size      = 1024,
8334                 .feature_bits   = FEATURE_EITHER_RESET,
8335                 .tested         = TEST_UNTESTED,
8336                 .probe          = probe_jedec,
8337                 .probe_timing   = TIMING_ZERO,
8338                 .block_erasers  =
8339                 {
8340                         {
8341                                 .eraseblocks = { {1024, 512} },
8342                                 .block_erase = erase_sector_jedec,
8343                         }, {
8344                                 .eraseblocks = { {512 * 1024, 1} },
8345                                 .block_erase = erase_chip_block_jedec,
8346                         },
8347                 },
8348                 .write          = write_jedec_1,
8349                 .read           = read_memmapped,
8350                 .voltage        = {4500, 5500},
8351         },
8352
8353         {
8354                 .vendor         = "SyncMOS/MoselVitelic",
8355                 .name           = "{S,V}29C31004B",
8356                 .bustype        = BUS_PARALLEL,
8357                 .manufacture_id = SYNCMOS_MVC_ID,
8358                 .model_id       = SM_MVC_29C31004B,
8359                 .total_size     = 512,
8360                 .page_size      = 1024,
8361                 .feature_bits   = FEATURE_EITHER_RESET,
8362                 .tested         = TEST_UNTESTED,
8363                 .probe          = probe_jedec,
8364                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
8365                 .block_erasers  =
8366                 {
8367                         {
8368                                 .eraseblocks = { {1024, 512} },
8369                                 .block_erase = erase_sector_jedec,
8370                         }, {
8371                                 .eraseblocks = { {512 * 1024, 1} },
8372                                 .block_erase = erase_chip_block_jedec,
8373                         },
8374                 },
8375                 .write          = write_jedec_1,
8376                 .read           = read_memmapped,
8377                 .voltage        = {3000, 3600},
8378         },
8379
8380         {
8381                 .vendor         = "SyncMOS/MoselVitelic",
8382                 .name           = "{S,V}29C31004T",
8383                 .bustype        = BUS_PARALLEL,
8384                 .manufacture_id = SYNCMOS_MVC_ID,
8385                 .model_id       = SM_MVC_29C31004T,
8386                 .total_size     = 512,
8387                 .page_size      = 1024,
8388                 .feature_bits   = FEATURE_EITHER_RESET,
8389                 .tested         = TEST_UNTESTED,
8390                 .probe          = probe_jedec,
8391                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
8392                 .block_erasers  =
8393                 {
8394                         {
8395                                 .eraseblocks = { {1024, 512} },
8396                                 .block_erase = erase_sector_jedec,
8397                         }, {
8398                                 .eraseblocks = { {512 * 1024, 1} },
8399                                 .block_erase = erase_chip_block_jedec,
8400                         },
8401                 },
8402                 .write          = write_jedec_1,
8403                 .read           = read_memmapped,
8404                 .voltage        = {3000, 3600},
8405         },
8406
8407         {
8408                 .vendor         = "TI",
8409                 .name           = "TMS29F002RB",
8410                 .bustype        = BUS_PARALLEL,
8411                 .manufacture_id = TI_OLD_ID,
8412                 .model_id       = TI_TMS29F002RB,
8413                 .total_size     = 256,
8414                 .page_size      = 16384, /* Non-uniform sectors */
8415                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
8416                 .tested         = TEST_UNTESTED,
8417                 .probe          = probe_jedec,
8418                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
8419                 .block_erasers  =
8420                 {
8421                         {
8422                                 .eraseblocks = {
8423                                         {16 * 1024, 1},
8424                                         {8 * 1024, 2},
8425                                         {32 * 1024, 1},
8426                                         {64 * 1024, 3},
8427                                 },
8428                                 .block_erase = erase_sector_jedec,
8429                         }, {
8430                                 .eraseblocks = { {256 * 1024, 1} },
8431                                 .block_erase = erase_chip_block_jedec,
8432                         },
8433                 },
8434                 .write          = write_jedec_1,
8435                 .read           = read_memmapped,
8436                 .voltage        = {4500, 5500},
8437         },
8438
8439         {
8440                 .vendor         = "TI",
8441                 .name           = "TMS29F002RT",
8442                 .bustype        = BUS_PARALLEL,
8443                 .manufacture_id = TI_OLD_ID,
8444                 .model_id       = TI_TMS29F002RT,
8445                 .total_size     = 256,
8446                 .page_size      = 16384, /* Non-uniform sectors */
8447                 .feature_bits   = FEATURE_ADDR_2AA | FEATURE_EITHER_RESET,
8448                 .tested         = TEST_UNTESTED,
8449                 .probe          = probe_jedec,
8450                 .probe_timing   = TIMING_ZERO,  /* Datasheet has no timing info specified */
8451                 .block_erasers  =
8452                 {
8453                         {
8454                                 .eraseblocks = {
8455                                         {64 * 1024, 3},
8456                                         {32 * 1024, 1},
8457                                         {8 * 1024, 2},
8458                                         {16 * 1024, 1},
8459                                 },
8460                                 .block_erase = erase_sector_jedec,
8461                         }, {
8462                                 .eraseblocks = { {256 * 1024, 1} },
8463                                 .block_erase = erase_chip_block_jedec,
8464                         },
8465                 },
8466                 .write          = write_jedec_1,
8467                 .read           = read_memmapped,
8468                 .voltage        = {4500, 5500},
8469         },
8470
8471         {
8472                 .vendor         = "Winbond",
8473                 .name           = "W25Q80",
8474                 .bustype        = BUS_SPI,
8475                 .manufacture_id = WINBOND_NEX_ID,
8476                 .model_id       = WINBOND_NEX_W25Q80,
8477                 .total_size     = 1024,
8478                 .page_size      = 256,
8479                 /* OTP: 1024B total, 256B reserved; read 0x48; write 0x42 */
8480                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
8481                 .tested         = TEST_OK_PREW,
8482                 .probe          = probe_spi_rdid,
8483                 .probe_timing   = TIMING_ZERO,
8484                 .block_erasers  =
8485                 {
8486                         {
8487                                 .eraseblocks = { {4 * 1024, 256} },
8488                                 .block_erase = spi_block_erase_20,
8489                         }, {
8490                                 .eraseblocks = { {32 * 1024, 32} },
8491                                 .block_erase = spi_block_erase_52,
8492                         }, {
8493                                 .eraseblocks = { {64 * 1024, 16} },
8494                                 .block_erase = spi_block_erase_d8,
8495                         }, {
8496                                 .eraseblocks = { {1024 * 1024, 1} },
8497                                 .block_erase = spi_block_erase_60,
8498                         }, {
8499                                 .eraseblocks = { {1024 * 1024, 1} },
8500                                 .block_erase = spi_block_erase_c7,
8501                         }
8502                 },
8503                 .unlock         = spi_disable_blockprotect,
8504                 .write          = spi_chip_write_256,
8505                 .read           = spi_chip_read,
8506                 .voltage        = {2700, 3600},
8507         },
8508
8509         {
8510                 .vendor         = "Winbond",
8511                 .name           = "W25Q16",
8512                 .bustype        = BUS_SPI,
8513                 .manufacture_id = WINBOND_NEX_ID,
8514                 .model_id       = WINBOND_NEX_W25Q16,
8515                 .total_size     = 2048,
8516                 .page_size      = 256,
8517                 /* OTP: 1024B total, 256B reserved; read 0x48; write 0x42 */
8518                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
8519                 .tested         = TEST_OK_PREW,
8520                 .probe          = probe_spi_rdid,
8521                 .probe_timing   = TIMING_ZERO,
8522                 .block_erasers  =
8523                 {
8524                         {
8525                                 .eraseblocks = { {4 * 1024, 512} },
8526                                 .block_erase = spi_block_erase_20,
8527                         }, {
8528                                 .eraseblocks = { {32 * 1024, 64} },
8529                                 .block_erase = spi_block_erase_52,
8530                         }, {
8531                                 .eraseblocks = { {64 * 1024, 32} },
8532                                 .block_erase = spi_block_erase_d8,
8533                         }, {
8534                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
8535                                 .block_erase = spi_block_erase_60,
8536                         }, {
8537                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
8538                                 .block_erase = spi_block_erase_c7,
8539                         }
8540                 },
8541                 .unlock         = spi_disable_blockprotect,
8542                 .write          = spi_chip_write_256,
8543                 .read           = spi_chip_read,
8544                 .voltage        = {2700, 3600},
8545         },
8546
8547         {
8548                 .vendor         = "Winbond",
8549                 .name           = "W25Q32",
8550                 .bustype        = BUS_SPI,
8551                 .manufacture_id = WINBOND_NEX_ID,
8552                 .model_id       = WINBOND_NEX_W25Q32,
8553                 .total_size     = 4096,
8554                 .page_size      = 256,
8555                 /* OTP: 1024B total, 256B reserved; read 0x48; write 0x42 */
8556                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
8557                 .tested         = TEST_OK_PREW,
8558                 .probe          = probe_spi_rdid,
8559                 .probe_timing   = TIMING_ZERO,
8560                 .block_erasers  =
8561                 {
8562                         {
8563                                 .eraseblocks = { {4 * 1024, 1024} },
8564                                 .block_erase = spi_block_erase_20,
8565                         }, {
8566                                 .eraseblocks = { {32 * 1024, 128} },
8567                                 .block_erase = spi_block_erase_52,
8568                         }, {
8569                                 .eraseblocks = { {64 * 1024, 64} },
8570                                 .block_erase = spi_block_erase_d8,
8571                         }, {
8572                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
8573                                 .block_erase = spi_block_erase_60,
8574                         }, {
8575                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
8576                                 .block_erase = spi_block_erase_c7,
8577                         }
8578                 },
8579                 .unlock         = spi_disable_blockprotect,
8580                 .write          = spi_chip_write_256,
8581                 .read           = spi_chip_read,
8582                 .voltage        = {2700, 3600},
8583         },
8584
8585         {
8586                 .vendor         = "Winbond",
8587                 .name           = "W25Q64",
8588                 .bustype        = BUS_SPI,
8589                 .manufacture_id = WINBOND_NEX_ID,
8590                 .model_id       = WINBOND_NEX_W25Q64,
8591                 .total_size     = 8192,
8592                 .page_size      = 256,
8593                 /* OTP: 1024B total, 256B reserved; read 0x48; write 0x42 */
8594                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
8595                 .tested         = TEST_OK_PREW,
8596                 .probe          = probe_spi_rdid,
8597                 .probe_timing   = TIMING_ZERO,
8598                 .block_erasers  =
8599                 {
8600                         {
8601                                 .eraseblocks = { {4 * 1024, 2048} },
8602                                 .block_erase = spi_block_erase_20,
8603                         }, {
8604                                 .eraseblocks = { {32 * 1024, 256} },
8605                                 .block_erase = spi_block_erase_52,
8606                         }, {
8607                                 .eraseblocks = { {64 * 1024, 128} },
8608                                 .block_erase = spi_block_erase_d8,
8609                         }, {
8610                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
8611                                 .block_erase = spi_block_erase_60,
8612                         }, {
8613                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
8614                                 .block_erase = spi_block_erase_c7,
8615                         }
8616                 },
8617                 .unlock         = spi_disable_blockprotect,
8618                 .write          = spi_chip_write_256,
8619                 .read           = spi_chip_read,
8620         },
8621
8622         {
8623                 .vendor         = "Winbond",
8624                 .name           = "W25Q128",
8625                 .bustype        = BUS_SPI,
8626                 .manufacture_id = WINBOND_NEX_ID,
8627                 .model_id       = WINBOND_NEX_W25Q128,
8628                 .total_size     = 16384,
8629                 .page_size      = 256,
8630                 /* OTP: 1024B total, 256B reserved; read 0x48; write 0x42 */
8631                 .feature_bits   = FEATURE_WRSR_WREN | FEATURE_OTP,
8632                 .tested         = TEST_OK_PROBE,
8633                 .probe          = probe_spi_rdid,
8634                 .probe_timing   = TIMING_ZERO,
8635                 .block_erasers  =
8636                 {
8637                         {
8638                                 .eraseblocks = { {4 * 1024, 4096} },
8639                                 .block_erase = spi_block_erase_20,
8640                         }, {
8641                                 .eraseblocks = { {32 * 1024, 512} },
8642                                 .block_erase = spi_block_erase_52,
8643                         }, {
8644                                 .eraseblocks = { {64 * 1024, 256} },
8645                                 .block_erase = spi_block_erase_d8,
8646                         }, {
8647                                 .eraseblocks = { {16 * 1024 * 1024, 1} },
8648                                 .block_erase = spi_block_erase_60,
8649                         }, {
8650                                 .eraseblocks = { {16 * 1024 * 1024, 1} },
8651                                 .block_erase = spi_block_erase_c7,
8652                         }
8653                 },
8654                 .unlock         = spi_disable_blockprotect,
8655                 .write          = spi_chip_write_256,
8656                 .read           = spi_chip_read,
8657         },
8658
8659         {
8660                 .vendor         = "Winbond",
8661                 .name           = "W25X10",
8662                 .bustype        = BUS_SPI,
8663                 .manufacture_id = WINBOND_NEX_ID,
8664                 .model_id       = WINBOND_NEX_W25X10,
8665                 .total_size     = 128,
8666                 .page_size      = 256,
8667                 .feature_bits   = FEATURE_WRSR_WREN,
8668                 .tested         = TEST_UNTESTED,
8669                 .probe          = probe_spi_rdid,
8670                 .probe_timing   = TIMING_ZERO,
8671                 .block_erasers  =
8672                 {
8673                         {
8674                                 .eraseblocks = { {4 * 1024, 32} },
8675                                 .block_erase = spi_block_erase_20,
8676                         }, {
8677                                 .eraseblocks = { {64 * 1024, 2} },
8678                                 .block_erase = spi_block_erase_d8,
8679                         }, {
8680                                 .eraseblocks = { {128 * 1024, 1} },
8681                                 .block_erase = spi_block_erase_c7,
8682                         }
8683                 },
8684                 .unlock         = spi_disable_blockprotect,
8685                 .write          = spi_chip_write_256,
8686                 .read           = spi_chip_read,
8687                 .voltage        = {2700, 3600},
8688         },
8689
8690         {
8691                 .vendor         = "Winbond",
8692                 .name           = "W25X20",
8693                 .bustype        = BUS_SPI,
8694                 .manufacture_id = WINBOND_NEX_ID,
8695                 .model_id       = WINBOND_NEX_W25X20,
8696                 .total_size     = 256,
8697                 .page_size      = 256,
8698                 .feature_bits   = FEATURE_WRSR_WREN,
8699                 .tested         = TEST_UNTESTED,
8700                 .probe          = probe_spi_rdid,
8701                 .probe_timing   = TIMING_ZERO,
8702                 .block_erasers  =
8703                 {
8704                         {
8705                                 .eraseblocks = { {4 * 1024, 64} },
8706                                 .block_erase = spi_block_erase_20,
8707                         }, {
8708                                 .eraseblocks = { {64 * 1024, 4} },
8709                                 .block_erase = spi_block_erase_d8,
8710                         }, {
8711                                 .eraseblocks = { {256 * 1024, 1} },
8712                                 .block_erase = spi_block_erase_c7,
8713                         }
8714                 },
8715                 .unlock         = spi_disable_blockprotect,
8716                 .write          = spi_chip_write_256,
8717                 .read           = spi_chip_read,
8718                 .voltage        = {2700, 3600},
8719         },
8720
8721         {
8722                 .vendor         = "Winbond",
8723                 .name           = "W25X40",
8724                 .bustype        = BUS_SPI,
8725                 .manufacture_id = WINBOND_NEX_ID,
8726                 .model_id       = WINBOND_NEX_W25X40,
8727                 .total_size     = 512,
8728                 .page_size      = 256,
8729                 .feature_bits   = FEATURE_WRSR_WREN,
8730                 .tested         = TEST_OK_PREW,
8731                 .probe          = probe_spi_rdid,
8732                 .probe_timing   = TIMING_ZERO,
8733                 .block_erasers  =
8734                 {
8735                         {
8736                                 .eraseblocks = { {4 * 1024, 128} },
8737                                 .block_erase = spi_block_erase_20,
8738                         }, {
8739                                 .eraseblocks = { {64 * 1024, 8} },
8740                                 .block_erase = spi_block_erase_d8,
8741                         }, {
8742                                 .eraseblocks = { {512 * 1024, 1} },
8743                                 .block_erase = spi_block_erase_c7,
8744                         }
8745                 },
8746                 .unlock         = spi_disable_blockprotect,
8747                 .write          = spi_chip_write_256,
8748                 .read           = spi_chip_read,
8749                 .voltage        = {2700, 3600},
8750         },
8751
8752         {
8753                 .vendor         = "Winbond",
8754                 .name           = "W25X80",
8755                 .bustype        = BUS_SPI,
8756                 .manufacture_id = WINBOND_NEX_ID,
8757                 .model_id       = WINBOND_NEX_W25X80,
8758                 .total_size     = 1024,
8759                 .page_size      = 256,
8760                 .feature_bits   = FEATURE_WRSR_WREN,
8761                 .tested         = TEST_OK_PREW,
8762                 .probe          = probe_spi_rdid,
8763                 .probe_timing   = TIMING_ZERO,
8764                 .block_erasers  =
8765                 {
8766                         {
8767                                 .eraseblocks = { {4 * 1024, 256} },
8768                                 .block_erase = spi_block_erase_20,
8769                         }, {
8770                                 .eraseblocks = { {64 * 1024, 16} },
8771                                 .block_erase = spi_block_erase_d8,
8772                         }, {
8773                                 .eraseblocks = { {1024 * 1024, 1} },
8774                                 .block_erase = spi_block_erase_c7,
8775                         }
8776                 },
8777                 .unlock         = spi_disable_blockprotect,
8778                 .write          = spi_chip_write_256,
8779                 .read           = spi_chip_read,
8780                 .voltage        = {2700, 3600},
8781         },
8782
8783         {
8784                 .vendor         = "Winbond",
8785                 .name           = "W25X16",
8786                 .bustype        = BUS_SPI,
8787                 .manufacture_id = WINBOND_NEX_ID,
8788                 .model_id       = WINBOND_NEX_W25X16,
8789                 .total_size     = 2048,
8790                 .page_size      = 256,
8791                 .feature_bits   = FEATURE_WRSR_WREN,
8792                 .tested         = TEST_OK_PREW,
8793                 .probe          = probe_spi_rdid,
8794                 .probe_timing   = TIMING_ZERO,
8795                 .block_erasers  =
8796                 {
8797                         {
8798                                 .eraseblocks = { {4 * 1024, 512} },
8799                                 .block_erase = spi_block_erase_20,
8800                         }, {
8801                                 .eraseblocks = { {32 * 1024, 64} },
8802                                 .block_erase = spi_block_erase_52,
8803                         }, {
8804                                 .eraseblocks = { {64 * 1024, 32} },
8805                                 .block_erase = spi_block_erase_d8,
8806                         }, {
8807                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
8808                                 .block_erase = spi_block_erase_60,
8809                         }, {
8810                                 .eraseblocks = { {2 * 1024 * 1024, 1} },
8811                                 .block_erase = spi_block_erase_c7,
8812                         }
8813                 },
8814                 .unlock         = spi_disable_blockprotect,
8815                 .write          = spi_chip_write_256,
8816                 .read           = spi_chip_read,
8817                 .voltage        = {2700, 3600},
8818         },
8819
8820         {
8821                 .vendor         = "Winbond",
8822                 .name           = "W25X32",
8823                 .bustype        = BUS_SPI,
8824                 .manufacture_id = WINBOND_NEX_ID,
8825                 .model_id       = WINBOND_NEX_W25X32,
8826                 .total_size     = 4096,
8827                 .page_size      = 256,
8828                 .feature_bits   = FEATURE_WRSR_WREN,
8829                 .tested         = TEST_OK_PROBE,
8830                 .probe          = probe_spi_rdid,
8831                 .probe_timing   = TIMING_ZERO,
8832                 .block_erasers  =
8833                 {
8834                         {
8835                                 .eraseblocks = { {4 * 1024, 1024} },
8836                                 .block_erase = spi_block_erase_20,
8837                         }, {
8838                                 .eraseblocks = { {32 * 1024, 128} },
8839                                 .block_erase = spi_block_erase_52,
8840                         }, {
8841                                 .eraseblocks = { {64 * 1024, 64} },
8842                                 .block_erase = spi_block_erase_d8,
8843                         }, {
8844                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
8845                                 .block_erase = spi_block_erase_60,
8846                         }, {
8847                                 .eraseblocks = { {4 * 1024 * 1024, 1} },
8848                                 .block_erase = spi_block_erase_c7,
8849                         }
8850                 },
8851                 .unlock         = spi_disable_blockprotect,
8852                 .write          = spi_chip_write_256,
8853                 .read           = spi_chip_read,
8854                 .voltage        = {2700, 3600},
8855         },
8856
8857         {
8858                 .vendor         = "Winbond",
8859                 .name           = "W25X64",
8860                 .bustype        = BUS_SPI,
8861                 .manufacture_id = WINBOND_NEX_ID,
8862                 .model_id       = WINBOND_NEX_W25X64,
8863                 .total_size     = 8192,
8864                 .page_size      = 256,
8865                 .feature_bits   = FEATURE_WRSR_WREN,
8866                 .tested         = TEST_OK_PROBE,
8867                 .probe          = probe_spi_rdid,
8868                 .probe_timing   = TIMING_ZERO,
8869                 .block_erasers  =
8870                 {
8871                         {
8872                                 .eraseblocks = { {4 * 1024, 2048} },
8873                                 .block_erase = spi_block_erase_20,
8874                         }, {
8875                                 .eraseblocks = { {32 * 1024, 256} },
8876                                 .block_erase = spi_block_erase_52,
8877                         }, {
8878                                 .eraseblocks = { {64 * 1024, 128} },
8879                                 .block_erase = spi_block_erase_d8,
8880                         }, {
8881                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
8882                                 .block_erase = spi_block_erase_60,
8883                         }, {
8884                                 .eraseblocks = { {8 * 1024 * 1024, 1} },
8885                                 .block_erase = spi_block_erase_c7,
8886                         }
8887                 },
8888                 .unlock         = spi_disable_blockprotect,
8889                 .write          = spi_chip_write_256,
8890                 .read           = spi_chip_read,
8891                 .voltage        = {2700, 3600},
8892         },
8893
8894         {
8895                 .vendor         = "Winbond",
8896                 .name           = "W29C010(M)/W29C011A/W29EE011/W29EE012-old",
8897                 .bustype        = BUS_PARALLEL,
8898                 .manufacture_id = WINBOND_ID,
8899                 .model_id       = WINBOND_W29C010,
8900                 .total_size     = 128,
8901                 .page_size      = 128,
8902                 .feature_bits   = FEATURE_LONG_RESET,
8903                 .tested         = TEST_OK_PRE,
8904                 .probe          = probe_w29ee011,
8905                 .probe_timing   = TIMING_IGNORED, /* routine doesn't use probe_timing (w29ee011.c) */
8906                 .block_erasers  =
8907                 {
8908                         {
8909                                 .eraseblocks = { {128 * 1024, 1} },
8910                                 .block_erase = erase_chip_block_jedec,
8911                         }
8912                 },
8913                 .write          = write_jedec,
8914                 .read           = read_memmapped,
8915         },
8916
8917         {/* W29EE011, W29EE012, W29C010M, W29C011A do not support probe_jedec according to the datasheet, but it works for newer(?) steppings. */
8918                 .vendor         = "Winbond",
8919                 .name           = "W29C010(M)/W29C011A/W29EE011/W29EE012",
8920                 .bustype        = BUS_PARALLEL,
8921                 .manufacture_id = WINBOND_ID,
8922                 .model_id       = WINBOND_W29C010,
8923                 .total_size     = 128,
8924                 .page_size      = 128,
8925                 .feature_bits   = FEATURE_LONG_RESET,
8926                 .tested         = TEST_OK_PREW,
8927                 .probe          = probe_jedec,
8928                 .probe_timing   = 10,           /* used datasheet for the W29C011A */
8929                 .block_erasers  =
8930                 {
8931                         {
8932                                 .eraseblocks = { {128 * 1024, 1} },
8933                                 .block_erase = erase_chip_block_jedec,
8934                         }
8935                 },
8936                 .write          = write_jedec,
8937                 .read           = read_memmapped,
8938         },
8939
8940         {
8941                 .vendor         = "Winbond",
8942                 .name           = "W29C020(C)/W29C022",
8943                 .bustype        = BUS_PARALLEL,
8944                 .manufacture_id = WINBOND_ID,
8945                 .model_id       = WINBOND_W29C020,
8946                 .total_size     = 256,
8947                 .page_size      = 128,
8948                 .feature_bits   = FEATURE_LONG_RESET,
8949                 .tested         = TEST_OK_PREW,
8950                 .probe          = probe_jedec,
8951                 .probe_timing   = 10,
8952                 .block_erasers  =
8953                 {
8954                         {
8955                                 .eraseblocks = { {256 * 1024, 1} },
8956                                 .block_erase = erase_chip_block_jedec,
8957                         }
8958                 },
8959                 .write          = write_jedec,
8960                 .read           = read_memmapped,
8961                 .voltage        = {4500, 5500},
8962         },
8963
8964         {
8965                 .vendor         = "Winbond",
8966                 .name           = "W29C040/P",
8967                 .bustype        = BUS_PARALLEL,
8968                 .manufacture_id = WINBOND_ID,
8969                 .model_id       = WINBOND_W29C040,
8970                 .total_size     = 512,
8971                 .page_size      = 256,
8972                 .feature_bits   = FEATURE_LONG_RESET,
8973                 .tested         = TEST_UNTESTED,
8974                 .probe          = probe_jedec,
8975                 .probe_timing   = 10,
8976                 .block_erasers  =
8977                 {
8978                         {
8979                                 .eraseblocks = { {512 * 1024, 1} },
8980                                 .block_erase = erase_chip_block_jedec,
8981                         }
8982                 },
8983                 .write          = write_jedec,
8984                 .read           = read_memmapped,
8985                 .voltage        = {4500, 5500},
8986         },
8987
8988         {
8989                 .vendor         = "Winbond",
8990                 .name           = "W39L040",
8991                 .bustype        = BUS_PARALLEL,
8992                 .manufacture_id = WINBOND_ID,
8993                 .model_id       = WINBOND_W39L040,
8994                 .total_size     = 512,
8995                 .page_size      = 64 * 1024,
8996                 .feature_bits   = FEATURE_EITHER_RESET,
8997                 .tested         = TEST_OK_PR,
8998                 .probe          = probe_jedec,
8999                 .probe_timing   = 10,
9000                 .block_erasers  =
9001                 {
9002                         {
9003                                 .eraseblocks = { {4 * 1024, 128} },
9004                                 .block_erase = erase_block_jedec,
9005                         }, {
9006                                 .eraseblocks = { {64 * 1024, 8} },
9007                                 .block_erase = erase_sector_jedec,
9008                         }, {
9009                                 .eraseblocks = { {512 * 1024, 1} },
9010                                 .block_erase = erase_chip_block_jedec,
9011                         }
9012                 },
9013                 .printlock      = printlock_w39l040,
9014                 .write          = write_jedec_1,
9015                 .read           = read_memmapped,
9016                 .voltage        = {3000, 3600},
9017         },
9018
9019         {
9020                 .vendor         = "Winbond",
9021                 .name           = "W39V040A",
9022                 .bustype        = BUS_LPC,
9023                 .manufacture_id = WINBOND_ID,
9024                 .model_id       = WINBOND_W39V040A,
9025                 .total_size     = 512,
9026                 .page_size      = 64 * 1024,
9027                 .feature_bits   = FEATURE_EITHER_RESET,
9028                 .tested         = TEST_OK_PREW,
9029                 .probe          = probe_jedec,
9030                 .probe_timing   = 10,
9031                 .block_erasers  =
9032                 {
9033                         {
9034                                 .eraseblocks = { {64 * 1024, 8} },
9035                                 .block_erase = erase_sector_jedec,
9036                         }, {
9037                                 .eraseblocks = { {512 * 1024, 1} },
9038                                 .block_erase = erase_chip_block_jedec,
9039                         }
9040                 },
9041                 .printlock      = printlock_w39v040a,
9042                 .write          = write_jedec_1,
9043                 .read           = read_memmapped,
9044                 .voltage        = {3000, 3600},
9045         },
9046
9047         {
9048                 .vendor         = "Winbond",
9049                 .name           = "W39V040B",
9050                 .bustype        = BUS_LPC,
9051                 .manufacture_id = WINBOND_ID,
9052                 .model_id       = WINBOND_W39V040B,
9053                 .total_size     = 512,
9054                 .page_size      = 64 * 1024,
9055                 .feature_bits   = FEATURE_EITHER_RESET,
9056                 .tested         = TEST_OK_PREW,
9057                 .probe          = probe_jedec,
9058                 .probe_timing   = 10,
9059                 .block_erasers  =
9060                 {
9061                         {
9062                                 .eraseblocks = { {64 * 1024, 8} },
9063                                 .block_erase = erase_sector_jedec,
9064                         }, {
9065                                 .eraseblocks = { {512 * 1024, 1} },
9066                                 .block_erase = erase_chip_block_jedec,
9067                         }
9068                 },
9069                 .printlock      = printlock_w39v040b,
9070                 .write          = write_jedec_1,
9071                 .read           = read_memmapped,
9072                 .voltage        = {3000, 3600},
9073         },
9074
9075         {
9076                 .vendor         = "Winbond",
9077                 .name           = "W39V040C",
9078                 .bustype        = BUS_LPC,
9079                 .manufacture_id = WINBOND_ID,
9080                 .model_id       = WINBOND_W39V040C,
9081                 .total_size     = 512,
9082                 .page_size      = 64 * 1024,
9083                 .feature_bits   = FEATURE_EITHER_RESET,
9084                 .tested         = TEST_OK_PREW,
9085                 .probe          = probe_jedec,
9086                 .probe_timing   = 10,
9087                 .block_erasers  =
9088                 {
9089                         {
9090                                 .eraseblocks = { {64 * 1024, 8} },
9091                                 .block_erase = erase_sector_jedec,
9092                         }, {
9093                                 .eraseblocks = { {512 * 1024, 1} },
9094                                 .block_erase = erase_chip_block_jedec,
9095                         }
9096                 },
9097                 .printlock      = printlock_w39v040c,
9098                 .write          = write_jedec_1,
9099                 .read           = read_memmapped,
9100                 .voltage        = {3000, 3600},
9101         },
9102
9103         {
9104                 .vendor         = "Winbond",
9105                 .name           = "W39V040FA",
9106                 .bustype        = BUS_FWH,
9107                 .manufacture_id = WINBOND_ID,
9108                 .model_id       = WINBOND_W39V040FA,
9109                 .total_size     = 512,
9110                 .page_size      = 64 * 1024,
9111                 .feature_bits   = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
9112                 .tested         = TEST_OK_PREW,
9113                 .probe          = probe_jedec,
9114                 .probe_timing   = 10,
9115                 .block_erasers  =
9116                 {
9117                         {
9118                                 .eraseblocks = { {4 * 1024, 128} },
9119                                 .block_erase = erase_block_jedec,
9120                         }, {
9121                                 .eraseblocks = { {64 * 1024, 8} },
9122                                 .block_erase = erase_sector_jedec,
9123                         }, {
9124                                 .eraseblocks = { {512 * 1024, 1} },
9125                                 .block_erase = erase_chip_block_jedec,
9126                         }
9127                 },
9128                 .printlock      = printlock_w39v040fa,
9129                 .unlock         = unlock_sst_fwhub,
9130                 .write          = write_jedec_1,
9131                 .read           = read_memmapped,
9132                 .voltage        = {3000, 3600},
9133         },
9134
9135         {
9136                 .vendor         = "Winbond",
9137                 .name           = "W39V040FB",
9138                 .bustype        = BUS_FWH,
9139                 .manufacture_id = WINBOND_ID,
9140                 .model_id       = WINBOND_W39V040B,
9141                 .total_size     = 512,
9142                 .page_size      = 64 * 1024,
9143                 .feature_bits   = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
9144                 .tested         = TEST_OK_PREW,
9145                 .probe          = probe_jedec,
9146                 .probe_timing   = 10,
9147                 .block_erasers  =
9148                 {
9149                         {
9150                                 .eraseblocks = { {64 * 1024, 8} },
9151                                 .block_erase = erase_sector_jedec,
9152                         }, {
9153                                 .eraseblocks = { {512 * 1024, 1} },
9154                                 .block_erase = erase_chip_block_jedec,
9155                         }
9156                 },
9157                 .printlock      = printlock_w39v040fb,
9158                 .unlock         = unlock_w39v040fb,
9159                 .write          = write_jedec_1,
9160                 .read           = read_memmapped,
9161                 .voltage        = {3000, 3600}, /* Also has 12V fast program */
9162         },
9163
9164         {
9165                 .vendor         = "Winbond",
9166                 .name           = "W39V040FC",
9167                 .bustype        = BUS_FWH,
9168                 .manufacture_id = WINBOND_ID,
9169                 .model_id       = WINBOND_W39V040C,
9170                 .total_size     = 512,
9171                 .page_size      = 64 * 1024,
9172                 .feature_bits   = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
9173                 .tested         = TEST_OK_PREW,
9174                 .probe          = probe_jedec,
9175                 .probe_timing   = 10,
9176                 .block_erasers  =
9177                 {
9178                         {
9179                                 .eraseblocks = { {64 * 1024, 8} },
9180                                 .block_erase = erase_sector_jedec,
9181                         }, {
9182                                 .eraseblocks = { {512 * 1024, 1} },
9183                                 .block_erase = erase_chip_block_jedec,
9184                         }
9185                 },
9186                 .printlock      = printlock_w39v040fc,
9187                 .write          = write_jedec_1,
9188                 .read           = read_memmapped,
9189                 .voltage        = {3000, 3600}, /* Also has 12V fast program */
9190         },
9191
9192         {
9193                 .vendor         = "Winbond",
9194                 .name           = "W39V080A",
9195                 .bustype        = BUS_LPC,
9196                 .manufacture_id = WINBOND_ID,
9197                 .model_id       = WINBOND_W39V080A,
9198                 .total_size     = 1024,
9199                 .page_size      = 64 * 1024,
9200                 .feature_bits   = FEATURE_EITHER_RESET,
9201                 .tested         = TEST_OK_PREW,
9202                 .probe          = probe_jedec,
9203                 .probe_timing   = 10,
9204                 .block_erasers  =
9205                 {
9206                         {
9207                                 .eraseblocks = { {64 * 1024, 16} },
9208                                 .block_erase = erase_sector_jedec,
9209                         }, {
9210                                 .eraseblocks = { {1024 * 1024, 1} },
9211                                 .block_erase = erase_chip_block_jedec,
9212                         }
9213                 },
9214                 .printlock      = printlock_w39v080a,
9215                 .write          = write_jedec_1,
9216                 .read           = read_memmapped,
9217                 .voltage        = {3000, 3600},
9218         },
9219
9220         {
9221                 .vendor         = "Winbond",
9222                 .name           = "W49F002U/N",
9223                 .bustype        = BUS_PARALLEL,
9224                 .manufacture_id = WINBOND_ID,
9225                 .model_id       = WINBOND_W49F002U,
9226                 .total_size     = 256,
9227                 .page_size      = 128,
9228                 .feature_bits   = FEATURE_EITHER_RESET,
9229                 .tested         = TEST_OK_PREW,
9230                 .probe          = probe_jedec,
9231                 .probe_timing   = 10,
9232                 .block_erasers  =
9233                 {
9234                         {
9235                                 .eraseblocks = {
9236                                         {128 * 1024, 1},
9237                                         {96 * 1024, 1},
9238                                         {8 * 1024, 2},
9239                                         {16 * 1024, 1},
9240                                 },
9241                                 .block_erase = erase_sector_jedec,
9242                         }, {
9243                                 .eraseblocks = { {256 * 1024, 1} },
9244                                 .block_erase = erase_chip_block_jedec,
9245                         }
9246                 },
9247                 .write          = write_jedec_1,
9248                 .read           = read_memmapped,
9249                 .voltage        = {4500, 5500},
9250         },
9251
9252         {
9253                 .vendor         = "Winbond",
9254                 .name           = "W49F020",
9255                 .bustype        = BUS_PARALLEL,
9256                 .manufacture_id = WINBOND_ID,
9257                 .model_id       = WINBOND_W49F020,
9258                 .total_size     = 256,
9259                 .page_size      = 128,
9260                 .feature_bits   = FEATURE_EITHER_RESET,
9261                 .tested         = TEST_OK_PROBE,
9262                 .probe          = probe_jedec,
9263                 .probe_timing   = 10,
9264                 .block_erasers  =
9265                 {
9266                         {
9267                                 .eraseblocks = { {256 * 1024, 1} },
9268                                 .block_erase = erase_chip_block_jedec,
9269                         }
9270                 },
9271                 .write          = write_jedec_1,
9272                 .read           = read_memmapped,
9273                 .voltage        = {4500, 5500},
9274         },
9275
9276         {
9277                 .vendor         = "Winbond",
9278                 .name           = "W49V002A",
9279                 .bustype        = BUS_LPC,
9280                 .manufacture_id = WINBOND_ID,
9281                 .model_id       = WINBOND_W49V002A,
9282                 .total_size     = 256,
9283                 .page_size      = 128,
9284                 .feature_bits   = FEATURE_EITHER_RESET,
9285                 .tested         = TEST_OK_PREW,
9286                 .probe          = probe_jedec,
9287                 .probe_timing   = 10,
9288                 .block_erasers  =
9289                 {
9290                         {
9291                                 .eraseblocks = {
9292                                         {64 * 1024, 3},
9293                                         {32 * 1024, 1},
9294                                         {8 * 1024, 2},
9295                                         {16 * 1024, 1},
9296                                 },
9297                                 .block_erase = erase_sector_jedec,
9298                         }, {
9299                                 .eraseblocks = { {256 * 1024, 1} },
9300                                 .block_erase = erase_chip_block_jedec,
9301                         }
9302                 },
9303                 .write          = write_jedec_1,
9304                 .read           = read_memmapped,
9305                 .voltage        = {3000, 3600},
9306         },
9307
9308         {
9309                 .vendor         = "Winbond",
9310                 .name           = "W49V002FA",
9311                 .bustype        = BUS_FWH,
9312                 .manufacture_id = WINBOND_ID,
9313                 .model_id       = WINBOND_W49V002FA,
9314                 .total_size     = 256,
9315                 .page_size      = 128,
9316                 .feature_bits   = FEATURE_EITHER_RESET,
9317                 .tested         = TEST_OK_PR,
9318                 .probe          = probe_jedec,
9319                 .probe_timing   = 10,
9320                 .block_erasers  =
9321                 {
9322                         {
9323                                 .eraseblocks = {
9324                                         {64 * 1024, 3},
9325                                         {32 * 1024, 1},
9326                                         {8 * 1024, 2},
9327                                         {16 * 1024, 1},
9328                                 },
9329                                 .block_erase = erase_sector_jedec,
9330                         }, {
9331                                 .eraseblocks = { {256 * 1024, 1} },
9332                                 .block_erase = erase_chip_block_jedec,
9333                         }
9334                 },
9335                 .write          = write_jedec_1,
9336                 .read           = read_memmapped,
9337                 .voltage        = {3000, 3600},
9338         },
9339
9340         {
9341                 .vendor         = "Winbond",
9342                 .name           = "W39V080FA",
9343                 .bustype        = BUS_FWH,
9344                 .manufacture_id = WINBOND_ID,
9345                 .model_id       = WINBOND_W39V080FA,
9346                 .total_size     = 1024,
9347                 .page_size      = 64 * 1024,
9348                 .feature_bits   = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
9349                 .tested         = TEST_OK_PREW,
9350                 .probe          = probe_jedec,
9351                 .probe_timing   = 10,
9352                 .block_erasers  =
9353                 {
9354                         {
9355                                 .eraseblocks = { {64 * 1024, 16}, },
9356                                 .block_erase = erase_sector_jedec,
9357                         }, {
9358                                 .eraseblocks = { {1024 * 1024, 1} },
9359                                 .block_erase = erase_chip_block_jedec,
9360                         }
9361                 },
9362                 .printlock      = printlock_w39v080fa,
9363                 .unlock         = unlock_w39v080fa,
9364                 .write          = write_jedec_1,
9365                 .read           = read_memmapped,
9366                 .voltage        = {3000, 3600}, /* Also has 12V fast program */
9367         },
9368
9369         {
9370                 .vendor         = "Winbond",
9371                 .name           = "W39V080FA (dual mode)",
9372                 .bustype        = BUS_FWH,
9373                 .manufacture_id = WINBOND_ID,
9374                 .model_id       = WINBOND_W39V080FA_DM,
9375                 .total_size     = 512,
9376                 .page_size      = 64 * 1024,
9377                 .feature_bits   = FEATURE_REGISTERMAP | FEATURE_EITHER_RESET,
9378                 .tested         = TEST_UNTESTED,
9379                 .probe          = probe_jedec,
9380                 .probe_timing   = 10,
9381                 .block_erasers  =
9382                 {
9383                         {
9384                                 .eraseblocks = { {64 * 1024, 8}, },
9385                                 .block_erase = erase_sector_jedec,
9386                         }, {
9387                                 .eraseblocks = { {512 * 1024, 1} },
9388                                 .block_erase = erase_chip_block_jedec,
9389                         }
9390                 },
9391                 .printlock      = printlock_w39v080fa_dual,
9392                 .write          = write_jedec_1,
9393                 .read           = read_memmapped,
9394                 .voltage        = {3000, 3600}, /* Also has 12V fast program */
9395         },
9396
9397         {
9398                 .vendor         = "Unknown",
9399                 .name           = "SFDP-capable chip",
9400                 .bustype        = BUS_SPI,
9401                 .manufacture_id = GENERIC_MANUF_ID,
9402                 .model_id       = SFDP_DEVICE_ID,
9403                 /* We present our own "report this" text hence we do not
9404                  * want the default "This flash part has status UNTESTED..."
9405                  * text to be printed. */
9406                 .tested         = TEST_OK_PREW,
9407                 .probe          = probe_spi_sfdp,
9408                 .unlock         = spi_disable_blockprotect, /* is this safe? */
9409                 .read           = spi_chip_read,
9410                 /* FIXME: some vendor extensions define this */
9411                 .voltage        = {},
9412                  /* Everything below will be set by the probing function. */
9413                 .write          = NULL,
9414                 .total_size     = 0,
9415                 .page_size      = 0,
9416                 .feature_bits   = 0,
9417                 .block_erasers  = {},
9418         },
9419
9420         {
9421                 .vendor         = "Programmer",
9422                 .name           = "Opaque flash chip",
9423                 .bustype        = BUS_PROG,
9424                 .manufacture_id = PROGMANUF_ID,
9425                 .model_id       = PROGDEV_ID,
9426                 .total_size     = 0,
9427                 .page_size      = 256,
9428                 /* probe is assumed to work, rest will be filled in by probe */
9429                 .tested         = TEST_OK_PROBE,
9430                 .probe          = probe_opaque,
9431                 /* eraseblock sizes will be set by the probing function */
9432                 .block_erasers  =
9433                 {
9434                         {
9435                                 .block_erase = erase_opaque,
9436                         }
9437                 },
9438                 .write          = write_opaque,
9439                 .read           = read_opaque,
9440         },
9441
9442         {
9443                 .vendor         = "AMIC",
9444                 .name           = "unknown AMIC SPI chip",
9445                 .bustype        = BUS_SPI,
9446                 .manufacture_id = AMIC_ID,
9447                 .model_id       = GENERIC_DEVICE_ID,
9448                 .total_size     = 0,
9449                 .page_size      = 256,
9450                 .tested         = TEST_BAD_PREW,
9451                 .probe          = probe_spi_rdid4,
9452                 .probe_timing   = TIMING_ZERO,
9453                 .write          = NULL,
9454                 .read           = NULL,
9455         },
9456
9457         {
9458                 .vendor         = "Atmel",
9459                 .name           = "unknown Atmel SPI chip",
9460                 .bustype        = BUS_SPI,
9461                 .manufacture_id = ATMEL_ID,
9462                 .model_id       = GENERIC_DEVICE_ID,
9463                 .total_size     = 0,
9464                 .page_size      = 256,
9465                 .tested         = TEST_BAD_PREW,
9466                 .probe          = probe_spi_rdid,
9467                 .probe_timing   = TIMING_ZERO,
9468                 .write          = NULL,
9469                 .read           = NULL,
9470         },
9471
9472         {
9473                 .vendor         = "Eon",
9474                 .name           = "unknown Eon SPI chip",
9475                 .bustype        = BUS_SPI,
9476                 .manufacture_id = EON_ID_NOPREFIX,
9477                 .model_id       = GENERIC_DEVICE_ID,
9478                 .total_size     = 0,
9479                 .page_size      = 256,
9480                 .tested         = TEST_BAD_PREW,
9481                 .probe          = probe_spi_rdid,
9482                 .probe_timing   = TIMING_ZERO,
9483                 .write          = NULL,
9484                 .read           = NULL,
9485         },
9486
9487         {
9488                 .vendor         = "Macronix",
9489                 .name           = "unknown Macronix SPI chip",
9490                 .bustype        = BUS_SPI,
9491                 .manufacture_id = MACRONIX_ID,
9492                 .model_id       = GENERIC_DEVICE_ID,
9493                 .total_size     = 0,
9494                 .page_size      = 256,
9495                 .tested         = TEST_BAD_PREW,
9496                 .probe          = probe_spi_rdid,
9497                 .probe_timing   = TIMING_ZERO,
9498                 .write          = NULL,
9499                 .read           = NULL,
9500         },
9501
9502         {
9503                 .vendor         = "PMC",
9504                 .name           = "unknown PMC SPI chip",
9505                 .bustype        = BUS_SPI,
9506                 .manufacture_id = PMC_ID,
9507                 .model_id       = GENERIC_DEVICE_ID,
9508                 .total_size     = 0,
9509                 .page_size      = 256,
9510                 .tested         = TEST_BAD_PREW,
9511                 .probe          = probe_spi_rdid,
9512                 .probe_timing   = TIMING_ZERO,
9513                 .write          = NULL,
9514                 .read           = NULL,
9515         },
9516
9517         {
9518                 .vendor         = "SST",
9519                 .name           = "unknown SST SPI chip",
9520                 .bustype        = BUS_SPI,
9521                 .manufacture_id = SST_ID,
9522                 .model_id       = GENERIC_DEVICE_ID,
9523                 .total_size     = 0,
9524                 .page_size      = 256,
9525                 .tested         = TEST_BAD_PREW,
9526                 .probe          = probe_spi_rdid,
9527                 .probe_timing   = TIMING_ZERO,
9528                 .write          = NULL,
9529                 .read           = NULL,
9530         },
9531
9532         {
9533                 .vendor         = "ST",
9534                 .name           = "unknown ST SPI chip",
9535                 .bustype        = BUS_SPI,
9536                 .manufacture_id = ST_ID,
9537                 .model_id       = GENERIC_DEVICE_ID,
9538                 .total_size     = 0,
9539                 .page_size      = 256,
9540                 .tested         = TEST_BAD_PREW,
9541                 .probe          = probe_spi_rdid,
9542                 .probe_timing   = TIMING_ZERO,
9543                 .write          = NULL,
9544                 .read           = NULL,
9545         },
9546
9547         {
9548                 .vendor         = "Sanyo",
9549                 .name           = "unknown Sanyo SPI chip",
9550                 .bustype        = BUS_SPI,
9551                 .manufacture_id = SANYO_ID,
9552                 .model_id       = GENERIC_DEVICE_ID,
9553                 .total_size     = 0,
9554                 .page_size      = 256,
9555                 .tested         = TEST_BAD_PREW,
9556                 .probe          = probe_spi_rdid,
9557                 .probe_timing   = TIMING_ZERO,
9558                 .write          = NULL,
9559                 .read           = NULL,
9560         },
9561
9562         {
9563                 .vendor         = "Generic",
9564                 .name           = "unknown SPI chip (RDID)",
9565                 .bustype        = BUS_SPI,
9566                 .manufacture_id = GENERIC_MANUF_ID,
9567                 .model_id       = GENERIC_DEVICE_ID,
9568                 .total_size     = 0,
9569                 .page_size      = 256,
9570                 .tested         = TEST_BAD_PREW,
9571                 .probe          = probe_spi_rdid,
9572                 .write          = NULL,
9573         },
9574
9575         {
9576                 .vendor         = "Generic",
9577                 .name           = "unknown SPI chip (REMS)",
9578                 .bustype        = BUS_SPI,
9579                 .manufacture_id = GENERIC_MANUF_ID,
9580                 .model_id       = GENERIC_DEVICE_ID,
9581                 .total_size     = 0,
9582                 .page_size      = 256,
9583                 .tested         = TEST_BAD_PREW,
9584                 .probe          = probe_spi_rems,
9585                 .write          = NULL,
9586         },
9587
9588         { NULL  }
9589 };