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