util/flashrom/spi.c

   1 /*
   2  * This file is part of the flashrom project.
   3  *
   4  * Copyright (C) 2007, 2008 Carl-Daniel Hailfinger
   5  * Copyright (C) 2008 coresystems GmbH
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; version 2 of the License.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19  */
  20
  21 /*
  22  * Contains the generic SPI framework
  23  */
  24
  25 #include <stdio.h>
  26 #include <pci/pci.h>
  27 #include <stdint.h>
  28 #include <string.h>
  29 #include "flash.h"
  30 #include "spi.h"
  31
  32 void spi_prettyprint_status_register(struct flashchip *flash);
  33
  34 int spi_command(unsigned int writecnt, unsigned int readcnt,
  35                 const unsigned char *writearr, unsigned char *readarr)
  36 {
  37         switch (flashbus) {
  38         case BUS_TYPE_IT87XX_SPI:
  39                 return it8716f_spi_command(writecnt, readcnt, writearr,
  40                                            readarr);
  41         case BUS_TYPE_ICH7_SPI:
  42         case BUS_TYPE_ICH9_SPI:
  43         case BUS_TYPE_VIA_SPI:
  44                 return ich_spi_command(writecnt, readcnt, writearr, readarr);
  45         case BUS_TYPE_SB600_SPI:
  46                 return sb600_spi_command(writecnt, readcnt, writearr, readarr);
  47         default:
  48                 printf_debug
  49                     ("%s called, but no SPI chipset/strapping detected\n",
  50                      __FUNCTION__);
  51         }
  52         return 1;
  53 }
  54
  55 static int spi_rdid(unsigned char *readarr, int bytes)
  56 {
  57         const unsigned char cmd[JEDEC_RDID_OUTSIZE] = { JEDEC_RDID };
  58
  59         if (spi_command(sizeof(cmd), bytes, cmd, readarr))
  60                 return 1;
  61         printf_debug("RDID returned %02x %02x %02x.\n", readarr[0], readarr[1],
  62                      readarr[2]);
  63         return 0;
  64 }
  65
  66 static int spi_rems(unsigned char *readarr)
  67 {
  68         const unsigned char cmd[JEDEC_REMS_OUTSIZE] = { JEDEC_REMS, 0, 0, 0 };
  69
  70         if (spi_command(sizeof(cmd), JEDEC_REMS_INSIZE, cmd, readarr))
  71                 return 1;
  72         printf_debug("REMS returned %02x %02x.\n", readarr[0], readarr[1]);
  73         return 0;
  74 }
  75
  76 static int spi_res(unsigned char *readarr)
  77 {
  78         const unsigned char cmd[JEDEC_RES_OUTSIZE] = { JEDEC_RES, 0, 0, 0 };
  79
  80         if (spi_command(sizeof(cmd), JEDEC_RES_INSIZE, cmd, readarr))
  81                 return 1;
  82         printf_debug("RES returned %02x.\n", readarr[0]);
  83         return 0;
  84 }
  85
  86 int spi_write_enable()
  87 {
  88         const unsigned char cmd[JEDEC_WREN_OUTSIZE] = { JEDEC_WREN };
  89
  90         /* Send WREN (Write Enable) */
  91         return spi_command(sizeof(cmd), 0, cmd, NULL);
  92 }
  93
  94 int spi_write_disable()
  95 {
  96         const unsigned char cmd[JEDEC_WRDI_OUTSIZE] = { JEDEC_WRDI };
  97
  98         /* Send WRDI (Write Disable) */
  99         return spi_command(sizeof(cmd), 0, cmd, NULL);
 100 }
 101
 102 static int probe_spi_rdid_generic(struct flashchip *flash, int bytes)
 103 {
 104         unsigned char readarr[4];
 105         uint32_t manuf_id;
 106         uint32_t model_id;
 107
 108         if (spi_rdid(readarr, bytes))
 109                 return 0;
 110
 111         if (!oddparity(readarr[0]))
 112                 printf_debug("RDID byte 0 parity violation.\n");
 113
 114         /* Check if this is a continuation vendor ID */
 115         if (readarr[0] == 0x7f) {
 116                 if (!oddparity(readarr[1]))
 117                         printf_debug("RDID byte 1 parity violation.\n");
 118                 manuf_id = (readarr[0] << 8) | readarr[1];
 119                 model_id = readarr[2];
 120                 if (bytes > 3) {
 121                         model_id <<= 8;
 122                         model_id |= readarr[3];
 123                 }
 124         } else {
 125                 manuf_id = readarr[0];
 126                 model_id = (readarr[1] << 8) | readarr[2];
 127         }
 128
 129         printf_debug("%s: id1 0x%x, id2 0x%x\n", __FUNCTION__, manuf_id,
 130                      model_id);
 131
 132         if (manuf_id == flash->manufacture_id && model_id == flash->model_id) {
 133                 /* Print the status register to tell the
 134                  * user about possible write protection.
 135                  */
 136                 spi_prettyprint_status_register(flash);
 137
 138                 return 1;
 139         }
 140
 141         /* Test if this is a pure vendor match. */
 142         if (manuf_id == flash->manufacture_id &&
 143             GENERIC_DEVICE_ID == flash->model_id)
 144                 return 1;
 145
 146         return 0;
 147 }
 148
 149 int probe_spi_rdid(struct flashchip *flash)
 150 {
 151         return probe_spi_rdid_generic(flash, 3);
 152 }
 153
 154 /* support 4 bytes flash ID */
 155 int probe_spi_rdid4(struct flashchip *flash)
 156 {
 157         /* only some SPI chipsets support 4 bytes commands */
 158         switch (flashbus) {
 159         case BUS_TYPE_ICH7_SPI:
 160         case BUS_TYPE_ICH9_SPI:
 161         case BUS_TYPE_VIA_SPI:
 162         case BUS_TYPE_SB600_SPI:
 163                 return probe_spi_rdid_generic(flash, 4);
 164         default:
 165                 printf_debug("4b ID not supported on this SPI controller\n");
 166         }
 167
 168         return 0;
 169 }
 170
 171 int probe_spi_rems(struct flashchip *flash)
 172 {
 173         unsigned char readarr[JEDEC_REMS_INSIZE];
 174         uint32_t manuf_id, model_id;
 175
 176         if (spi_rems(readarr))
 177                 return 0;
 178
 179         manuf_id = readarr[0];
 180         model_id = readarr[1];
 181
 182         printf_debug("%s: id1 0x%x, id2 0x%x\n", __FUNCTION__, manuf_id,
 183                      model_id);
 184
 185         if (manuf_id == flash->manufacture_id && model_id == flash->model_id) {
 186                 /* Print the status register to tell the
 187                  * user about possible write protection.
 188                  */
 189                 spi_prettyprint_status_register(flash);
 190
 191                 return 1;
 192         }
 193
 194         /* Test if this is a pure vendor match. */
 195         if (manuf_id == flash->manufacture_id &&
 196             GENERIC_DEVICE_ID == flash->model_id)
 197                 return 1;
 198
 199         return 0;
 200 }
 201
 202 int probe_spi_res(struct flashchip *flash)
 203 {
 204         unsigned char readarr[3];
 205         uint32_t model_id;
 206
 207         /* Check if RDID was successful and did not return 0xff 0xff 0xff.
 208          * In that case, RES is pointless.
 209          */
 210         if (!spi_rdid(readarr, 3) && ((readarr[0] != 0xff) ||
 211             (readarr[1] != 0xff) || (readarr[2] != 0xff)))
 212                 return 0;
 213
 214         if (spi_res(readarr))
 215                 return 0;
 216
 217         model_id = readarr[0];
 218         printf_debug("%s: id 0x%x\n", __FUNCTION__, model_id);
 219         if (model_id != flash->model_id)
 220                 return 0;
 221
 222         /* Print the status register to tell the
 223          * user about possible write protection.
 224          */
 225         spi_prettyprint_status_register(flash);
 226         return 1;
 227 }
 228
 229 uint8_t spi_read_status_register()
 230 {
 231         const unsigned char cmd[JEDEC_RDSR_OUTSIZE] = { JEDEC_RDSR };
 232         unsigned char readarr[JEDEC_RDSR_INSIZE];
 233
 234         /* Read Status Register */
 235         if (flashbus == BUS_TYPE_SB600_SPI) {
 236                 /* SB600 uses a different way to read status register. */
 237                 return sb600_read_status_register();
 238         } else {
 239                 spi_command(sizeof(cmd), sizeof(readarr), cmd, readarr);
 240         }
 241
 242         return readarr[0];
 243 }
 244
 245 /* Prettyprint the status register. Common definitions.
 246  */
 247 void spi_prettyprint_status_register_common(uint8_t status)
 248 {
 249         printf_debug("Chip status register: Bit 5 / Block Protect 3 (BP3) is "
 250                      "%sset\n", (status & (1 << 5)) ? "" : "not ");
 251         printf_debug("Chip status register: Bit 4 / Block Protect 2 (BP2) is "
 252                      "%sset\n", (status & (1 << 4)) ? "" : "not ");
 253         printf_debug("Chip status register: Bit 3 / Block Protect 1 (BP1) is "
 254                      "%sset\n", (status & (1 << 3)) ? "" : "not ");
 255         printf_debug("Chip status register: Bit 2 / Block Protect 0 (BP0) is "
 256                      "%sset\n", (status & (1 << 2)) ? "" : "not ");
 257         printf_debug("Chip status register: Write Enable Latch (WEL) is "
 258                      "%sset\n", (status & (1 << 1)) ? "" : "not ");
 259         printf_debug("Chip status register: Write In Progress (WIP/BUSY) is "
 260                      "%sset\n", (status & (1 << 0)) ? "" : "not ");
 261 }
 262
 263 /* Prettyprint the status register. Works for
 264  * ST M25P series
 265  * MX MX25L series
 266  */
 267 void spi_prettyprint_status_register_st_m25p(uint8_t status)
 268 {
 269         printf_debug("Chip status register: Status Register Write Disable "
 270                      "(SRWD) is %sset\n", (status & (1 << 7)) ? "" : "not ");
 271         printf_debug("Chip status register: Bit 6 is "
 272                      "%sset\n", (status & (1 << 6)) ? "" : "not ");
 273         spi_prettyprint_status_register_common(status);
 274 }
 275
 276 /* Prettyprint the status register. Works for
 277  * SST 25VF016
 278  */
 279 void spi_prettyprint_status_register_sst25vf016(uint8_t status)
 280 {
 281         const char *bpt[] = {
 282                 "none",
 283                 "1F0000H-1FFFFFH",
 284                 "1E0000H-1FFFFFH",
 285                 "1C0000H-1FFFFFH",
 286                 "180000H-1FFFFFH",
 287                 "100000H-1FFFFFH",
 288                 "all", "all"
 289         };
 290         printf_debug("Chip status register: Block Protect Write Disable "
 291                      "(BPL) is %sset\n", (status & (1 << 7)) ? "" : "not ");
 292         printf_debug("Chip status register: Auto Address Increment Programming "
 293                      "(AAI) is %sset\n", (status & (1 << 6)) ? "" : "not ");
 294         spi_prettyprint_status_register_common(status);
 295         printf_debug("Resulting block protection : %s\n",
 296                      bpt[(status & 0x1c) >> 2]);
 297 }
 298
 299 void spi_prettyprint_status_register(struct flashchip *flash)
 300 {
 301         uint8_t status;
 302
 303         status = spi_read_status_register();
 304         printf_debug("Chip status register is %02x\n", status);
 305         switch (flash->manufacture_id) {
 306         case ST_ID:
 307                 if (((flash->model_id & 0xff00) == 0x2000) ||
 308                     ((flash->model_id & 0xff00) == 0x2500))
 309                         spi_prettyprint_status_register_st_m25p(status);
 310                 break;
 311         case MX_ID:
 312                 if ((flash->model_id & 0xff00) == 0x2000)
 313                         spi_prettyprint_status_register_st_m25p(status);
 314                 break;
 315         case SST_ID:
 316                 if (flash->model_id == SST_25VF016B)
 317                         spi_prettyprint_status_register_sst25vf016(status);
 318                 break;
 319         }
 320 }
 321
 322 int spi_chip_erase_60(struct flashchip *flash)
 323 {
 324         const unsigned char cmd[JEDEC_CE_60_OUTSIZE] = {JEDEC_CE_60};
 325         int result;
 326
 327         result = spi_disable_blockprotect();
 328         if (result) {
 329                 printf_debug("spi_disable_blockprotect failed\n");
 330                 return result;
 331         }
 332         result = spi_write_enable();
 333         if (result) {
 334                 printf_debug("spi_write_enable failed\n");
 335                 return result;
 336         }
 337         /* Send CE (Chip Erase) */
 338         result = spi_command(sizeof(cmd), 0, cmd, NULL);
 339         if (result) {
 340                 printf_debug("spi_chip_erase_60 failed sending erase\n");
 341                 return result;
 342         }
 343         /* Wait until the Write-In-Progress bit is cleared.
 344          * This usually takes 1-85 s, so wait in 1 s steps.
 345          */
 346         /* FIXME: We assume spi_read_status_register will never fail. */
 347         while (spi_read_status_register() & JEDEC_RDSR_BIT_WIP)
 348                 sleep(1);
 349         return 0;
 350 }
 351
 352 int spi_chip_erase_c7(struct flashchip *flash)
 353 {
 354         const unsigned char cmd[JEDEC_CE_C7_OUTSIZE] = { JEDEC_CE_C7 };
 355         int result;
 356
 357         result = spi_disable_blockprotect();
 358         if (result) {
 359                 printf_debug("spi_disable_blockprotect failed\n");
 360                 return result;
 361         }
 362         result = spi_write_enable();
 363         if (result) {
 364                 printf_debug("spi_write_enable failed\n");
 365                 return result;
 366         }
 367         /* Send CE (Chip Erase) */
 368         result = spi_command(sizeof(cmd), 0, cmd, NULL);
 369         if (result) {
 370                 printf_debug("spi_chip_erase_60 failed sending erase\n");
 371                 return result;
 372         }
 373         /* Wait until the Write-In-Progress bit is cleared.
 374          * This usually takes 1-85 s, so wait in 1 s steps.
 375          */
 376         /* FIXME: We assume spi_read_status_register will never fail. */
 377         while (spi_read_status_register() & JEDEC_RDSR_BIT_WIP)
 378                 sleep(1);
 379         return 0;
 380 }
 381
 382 int spi_chip_erase_60_c7(struct flashchip *flash)
 383 {
 384         int result;
 385         result = spi_chip_erase_60(flash);
 386         if (result) {
 387                 printf_debug("spi_chip_erase_60 failed, trying c7\n");
 388                 result = spi_chip_erase_c7(flash);
 389         }
 390         return result;
 391 }
 392
 393 int spi_block_erase_52(const struct flashchip *flash, unsigned long addr)
 394 {
 395         unsigned char cmd[JEDEC_BE_52_OUTSIZE] = {JEDEC_BE_52};
 396
 397         cmd[1] = (addr & 0x00ff0000) >> 16;
 398         cmd[2] = (addr & 0x0000ff00) >> 8;
 399         cmd[3] = (addr & 0x000000ff);
 400         spi_write_enable();
 401         /* Send BE (Block Erase) */
 402         spi_command(sizeof(cmd), 0, cmd, NULL);
 403         /* Wait until the Write-In-Progress bit is cleared.
 404          * This usually takes 100-4000 ms, so wait in 100 ms steps.
 405          */
 406         while (spi_read_status_register() & JEDEC_RDSR_BIT_WIP)
 407                 usleep(100 * 1000);
 408         return 0;
 409 }
 410
 411 /* Block size is usually
 412  * 64k for Macronix
 413  * 32k for SST
 414  * 4-32k non-uniform for EON
 415  */
 416 int spi_block_erase_d8(const struct flashchip *flash, unsigned long addr)
 417 {
 418         unsigned char cmd[JEDEC_BE_D8_OUTSIZE] = { JEDEC_BE_D8 };
 419
 420         cmd[1] = (addr & 0x00ff0000) >> 16;
 421         cmd[2] = (addr & 0x0000ff00) >> 8;
 422         cmd[3] = (addr & 0x000000ff);
 423         spi_write_enable();
 424         /* Send BE (Block Erase) */
 425         spi_command(sizeof(cmd), 0, cmd, NULL);
 426         /* Wait until the Write-In-Progress bit is cleared.
 427          * This usually takes 100-4000 ms, so wait in 100 ms steps.
 428          */
 429         while (spi_read_status_register() & JEDEC_RDSR_BIT_WIP)
 430                 usleep(100 * 1000);
 431         return 0;
 432 }
 433
 434 int spi_chip_erase_d8(struct flashchip *flash)
 435 {
 436         int i, rc = 0;
 437         int total_size = flash->total_size * 1024;
 438         int erase_size = 64 * 1024;
 439
 440         spi_disable_blockprotect();
 441
 442         printf("Erasing chip: \n");
 443
 444         for (i = 0; i < total_size / erase_size; i++) {
 445                 rc = spi_block_erase_d8(flash, i * erase_size);
 446                 if (rc) {
 447                         printf("Error erasing block at 0x%x\n", i);
 448                         break;
 449                 }
 450         }
 451
 452         printf("\n");
 453
 454         return rc;
 455 }
 456
 457 /* Sector size is usually 4k, though Macronix eliteflash has 64k */
 458 int spi_sector_erase(const struct flashchip *flash, unsigned long addr)
 459 {
 460         unsigned char cmd[JEDEC_SE_OUTSIZE] = { JEDEC_SE };
 461         cmd[1] = (addr & 0x00ff0000) >> 16;
 462         cmd[2] = (addr & 0x0000ff00) >> 8;
 463         cmd[3] = (addr & 0x000000ff);
 464
 465         spi_write_enable();
 466         /* Send SE (Sector Erase) */
 467         spi_command(sizeof(cmd), 0, cmd, NULL);
 468         /* Wait until the Write-In-Progress bit is cleared.
 469          * This usually takes 15-800 ms, so wait in 10 ms steps.
 470          */
 471         while (spi_read_status_register() & JEDEC_RDSR_BIT_WIP)
 472                 usleep(10 * 1000);
 473         return 0;
 474 }
 475
 476 int spi_write_status_enable()
 477 {
 478         const unsigned char cmd[JEDEC_EWSR_OUTSIZE] = { JEDEC_EWSR };
 479
 480         /* Send EWSR (Enable Write Status Register). */
 481         return spi_command(JEDEC_EWSR_OUTSIZE, JEDEC_EWSR_INSIZE, cmd, NULL);
 482 }
 483
 484 /*
 485  * This is according the SST25VF016 datasheet, who knows it is more
 486  * generic that this...
 487  */
 488 int spi_write_status_register(int status)
 489 {
 490         const unsigned char cmd[JEDEC_WRSR_OUTSIZE] =
 491             { JEDEC_WRSR, (unsigned char)status };
 492
 493         /* Send WRSR (Write Status Register) */
 494         return spi_command(sizeof(cmd), 0, cmd, NULL);
 495 }
 496
 497 void spi_byte_program(int address, uint8_t byte)
 498 {
 499         const unsigned char cmd[JEDEC_BYTE_PROGRAM_OUTSIZE] = {
 500                 JEDEC_BYTE_PROGRAM,
 501                 (address >> 16) & 0xff,
 502                 (address >> 8) & 0xff,
 503                 (address >> 0) & 0xff,
 504                 byte
 505         };
 506
 507         /* Send Byte-Program */
 508         spi_command(sizeof(cmd), 0, cmd, NULL);
 509 }
 510
 511 int spi_disable_blockprotect(void)
 512 {
 513         uint8_t status;
 514         int result;
 515
 516         status = spi_read_status_register();
 517         /* If there is block protection in effect, unprotect it first. */
 518         if ((status & 0x3c) != 0) {
 519                 printf_debug("Some block protection in effect, disabling\n");
 520                 result = spi_write_status_enable();
 521                 if (result) {
 522                         printf_debug("spi_write_status_enable failed\n");
 523                         return result;
 524                 }
 525                 result = spi_write_status_register(status & ~0x3c);
 526                 if (result) {
 527                         printf_debug("spi_write_status_register failed\n");
 528                         return result;
 529                 }
 530         }
 531         return 0;
 532 }
 533
 534 int spi_nbyte_read(int address, uint8_t *bytes, int len)
 535 {
 536         const unsigned char cmd[JEDEC_READ_OUTSIZE] = {
 537                 JEDEC_READ,
 538                 (address >> 16) & 0xff,
 539                 (address >> 8) & 0xff,
 540                 (address >> 0) & 0xff,
 541         };
 542
 543         /* Send Read */
 544         return spi_command(sizeof(cmd), len, cmd, bytes);
 545 }
 546
 547 int spi_chip_read(struct flashchip *flash, uint8_t *buf)
 548 {
 549         switch (flashbus) {
 550         case BUS_TYPE_IT87XX_SPI:
 551                 return it8716f_spi_chip_read(flash, buf);
 552         case BUS_TYPE_SB600_SPI:
 553                 return sb600_spi_read(flash, buf);
 554         case BUS_TYPE_ICH7_SPI:
 555         case BUS_TYPE_ICH9_SPI:
 556         case BUS_TYPE_VIA_SPI:
 557                 return ich_spi_read(flash, buf);
 558         default:
 559                 printf_debug
 560                     ("%s called, but no SPI chipset/strapping detected\n",
 561                      __FUNCTION__);
 562         }
 563
 564         return 1;
 565 }
 566
 567 int spi_chip_write(struct flashchip *flash, uint8_t *buf)
 568 {
 569         switch (flashbus) {
 570         case BUS_TYPE_IT87XX_SPI:
 571                 return it8716f_spi_chip_write(flash, buf);
 572         case BUS_TYPE_SB600_SPI:
 573                 return sb600_spi_write(flash, buf);
 574         case BUS_TYPE_ICH7_SPI:
 575         case BUS_TYPE_ICH9_SPI:
 576         case BUS_TYPE_VIA_SPI:
 577                 return ich_spi_write(flash, buf);
 578         default:
 579                 printf_debug
 580                     ("%s called, but no SPI chipset/strapping detected\n",
 581                      __FUNCTION__);
 582         }
 583
 584         return 1;
 585 }