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_sst25vf040b(uint8_t status)
 303 {
 304         const char *bpt[] = {
 305                 "none",
 306                 "0x70000-0x7ffff",
 307                 "0x60000-0x7ffff",
 308                 "0x40000-0x7ffff",
 309                 "all blocks", "all blocks", "all blocks", "all blocks"
 310         };
 311         printf_debug("Chip status register: Block Protect Write Disable "
 312                 "(BPL) is %sset\n", (status & (1 << 7)) ? "" : "not ");
 313         printf_debug("Chip status register: Auto Address Increment Programming "
 314                 "(AAI) is %sset\n", (status & (1 << 6)) ? "" : "not ");
 315         spi_prettyprint_status_register_common(status);
 316         printf_debug("Resulting block protection : %s\n",
 317                 bpt[(status & 0x3c) >> 2]);
 318 }
 319
 320 void spi_prettyprint_status_register(struct flashchip *flash)
 321 {
 322         uint8_t status;
 323
 324         status = spi_read_status_register();
 325         printf_debug("Chip status register is %02x\n", status);
 326         switch (flash->manufacture_id) {
 327         case ST_ID:
 328                 if (((flash->model_id & 0xff00) == 0x2000) ||
 329                     ((flash->model_id & 0xff00) == 0x2500))
 330                         spi_prettyprint_status_register_st_m25p(status);
 331                 break;
 332         case MX_ID:
 333                 if ((flash->model_id & 0xff00) == 0x2000)
 334                         spi_prettyprint_status_register_st_m25p(status);
 335                 break;
 336         case SST_ID:
 337                 switch (flash->model_id) {
 338                 case 0x2541:
 339                         spi_prettyprint_status_register_sst25vf016(status);
 340                         break;
 341                 case 0x8d:
 342                 case 0x258d:
 343                         spi_prettyprint_status_register_sst25vf040b(status);
 344                         break;
 345                 }
 346                 break;
 347         }
 348 }
 349
 350 int spi_chip_erase_60(struct flashchip *flash)
 351 {
 352         const unsigned char cmd[JEDEC_CE_60_OUTSIZE] = {JEDEC_CE_60};
 353         int result;
 354
 355         result = spi_disable_blockprotect();
 356         if (result) {
 357                 printf_debug("spi_disable_blockprotect failed\n");
 358                 return result;
 359         }
 360         result = spi_write_enable();
 361         if (result) {
 362                 printf_debug("spi_write_enable failed\n");
 363                 return result;
 364         }
 365         /* Send CE (Chip Erase) */
 366         result = spi_command(sizeof(cmd), 0, cmd, NULL);
 367         if (result) {
 368                 printf_debug("spi_chip_erase_60 failed sending erase\n");
 369                 return result;
 370         }
 371         /* Wait until the Write-In-Progress bit is cleared.
 372          * This usually takes 1-85 s, so wait in 1 s steps.
 373          */
 374         /* FIXME: We assume spi_read_status_register will never fail. */
 375         while (spi_read_status_register() & JEDEC_RDSR_BIT_WIP)
 376                 sleep(1);
 377         return 0;
 378 }
 379
 380 int spi_chip_erase_c7(struct flashchip *flash)
 381 {
 382         const unsigned char cmd[JEDEC_CE_C7_OUTSIZE] = { JEDEC_CE_C7 };
 383         int result;
 384
 385         result = spi_disable_blockprotect();
 386         if (result) {
 387                 printf_debug("spi_disable_blockprotect failed\n");
 388                 return result;
 389         }
 390         result = spi_write_enable();
 391         if (result) {
 392                 printf_debug("spi_write_enable failed\n");
 393                 return result;
 394         }
 395         /* Send CE (Chip Erase) */
 396         result = spi_command(sizeof(cmd), 0, cmd, NULL);
 397         if (result) {
 398                 printf_debug("spi_chip_erase_60 failed sending erase\n");
 399                 return result;
 400         }
 401         /* Wait until the Write-In-Progress bit is cleared.
 402          * This usually takes 1-85 s, so wait in 1 s steps.
 403          */
 404         /* FIXME: We assume spi_read_status_register will never fail. */
 405         while (spi_read_status_register() & JEDEC_RDSR_BIT_WIP)
 406                 sleep(1);
 407         return 0;
 408 }
 409
 410 int spi_chip_erase_60_c7(struct flashchip *flash)
 411 {
 412         int result;
 413         result = spi_chip_erase_60(flash);
 414         if (result) {
 415                 printf_debug("spi_chip_erase_60 failed, trying c7\n");
 416                 result = spi_chip_erase_c7(flash);
 417         }
 418         return result;
 419 }
 420
 421 int spi_block_erase_52(const struct flashchip *flash, unsigned long addr)
 422 {
 423         unsigned char cmd[JEDEC_BE_52_OUTSIZE] = {JEDEC_BE_52};
 424
 425         cmd[1] = (addr & 0x00ff0000) >> 16;
 426         cmd[2] = (addr & 0x0000ff00) >> 8;
 427         cmd[3] = (addr & 0x000000ff);
 428         spi_write_enable();
 429         /* Send BE (Block Erase) */
 430         spi_command(sizeof(cmd), 0, cmd, NULL);
 431         /* Wait until the Write-In-Progress bit is cleared.
 432          * This usually takes 100-4000 ms, so wait in 100 ms steps.
 433          */
 434         while (spi_read_status_register() & JEDEC_RDSR_BIT_WIP)
 435                 usleep(100 * 1000);
 436         return 0;
 437 }
 438
 439 /* Block size is usually
 440  * 64k for Macronix
 441  * 32k for SST
 442  * 4-32k non-uniform for EON
 443  */
 444 int spi_block_erase_d8(const struct flashchip *flash, unsigned long addr)
 445 {
 446         unsigned char cmd[JEDEC_BE_D8_OUTSIZE] = { JEDEC_BE_D8 };
 447
 448         cmd[1] = (addr & 0x00ff0000) >> 16;
 449         cmd[2] = (addr & 0x0000ff00) >> 8;
 450         cmd[3] = (addr & 0x000000ff);
 451         spi_write_enable();
 452         /* Send BE (Block Erase) */
 453         spi_command(sizeof(cmd), 0, cmd, NULL);
 454         /* Wait until the Write-In-Progress bit is cleared.
 455          * This usually takes 100-4000 ms, so wait in 100 ms steps.
 456          */
 457         while (spi_read_status_register() & JEDEC_RDSR_BIT_WIP)
 458                 usleep(100 * 1000);
 459         return 0;
 460 }
 461
 462 int spi_chip_erase_d8(struct flashchip *flash)
 463 {
 464         int i, rc = 0;
 465         int total_size = flash->total_size * 1024;
 466         int erase_size = 64 * 1024;
 467
 468         spi_disable_blockprotect();
 469
 470         printf("Erasing chip: \n");
 471
 472         for (i = 0; i < total_size / erase_size; i++) {
 473                 rc = spi_block_erase_d8(flash, i * erase_size);
 474                 if (rc) {
 475                         printf("Error erasing block at 0x%x\n", i);
 476                         break;
 477                 }
 478         }
 479
 480         printf("\n");
 481
 482         return rc;
 483 }
 484
 485 /* Sector size is usually 4k, though Macronix eliteflash has 64k */
 486 int spi_sector_erase(const struct flashchip *flash, unsigned long addr)
 487 {
 488         unsigned char cmd[JEDEC_SE_OUTSIZE] = { JEDEC_SE };
 489         cmd[1] = (addr & 0x00ff0000) >> 16;
 490         cmd[2] = (addr & 0x0000ff00) >> 8;
 491         cmd[3] = (addr & 0x000000ff);
 492
 493         spi_write_enable();
 494         /* Send SE (Sector Erase) */
 495         spi_command(sizeof(cmd), 0, cmd, NULL);
 496         /* Wait until the Write-In-Progress bit is cleared.
 497          * This usually takes 15-800 ms, so wait in 10 ms steps.
 498          */
 499         while (spi_read_status_register() & JEDEC_RDSR_BIT_WIP)
 500                 usleep(10 * 1000);
 501         return 0;
 502 }
 503
 504 int spi_write_status_enable()
 505 {
 506         const unsigned char cmd[JEDEC_EWSR_OUTSIZE] = { JEDEC_EWSR };
 507
 508         /* Send EWSR (Enable Write Status Register). */
 509         return spi_command(JEDEC_EWSR_OUTSIZE, JEDEC_EWSR_INSIZE, cmd, NULL);
 510 }
 511
 512 /*
 513  * This is according the SST25VF016 datasheet, who knows it is more
 514  * generic that this...
 515  */
 516 int spi_write_status_register(int status)
 517 {
 518         const unsigned char cmd[JEDEC_WRSR_OUTSIZE] =
 519             { JEDEC_WRSR, (unsigned char)status };
 520
 521         /* Send WRSR (Write Status Register) */
 522         return spi_command(sizeof(cmd), 0, cmd, NULL);
 523 }
 524
 525 void spi_byte_program(int address, uint8_t byte)
 526 {
 527         const unsigned char cmd[JEDEC_BYTE_PROGRAM_OUTSIZE] = {
 528                 JEDEC_BYTE_PROGRAM,
 529                 (address >> 16) & 0xff,
 530                 (address >> 8) & 0xff,
 531                 (address >> 0) & 0xff,
 532                 byte
 533         };
 534
 535         /* Send Byte-Program */
 536         spi_command(sizeof(cmd), 0, cmd, NULL);
 537 }
 538
 539 int spi_disable_blockprotect(void)
 540 {
 541         uint8_t status;
 542         int result;
 543
 544         status = spi_read_status_register();
 545         /* If there is block protection in effect, unprotect it first. */
 546         if ((status & 0x3c) != 0) {
 547                 printf_debug("Some block protection in effect, disabling\n");
 548                 result = spi_write_status_enable();
 549                 if (result) {
 550                         printf_debug("spi_write_status_enable failed\n");
 551                         return result;
 552                 }
 553                 result = spi_write_status_register(status & ~0x3c);
 554                 if (result) {
 555                         printf_debug("spi_write_status_register failed\n");
 556                         return result;
 557                 }
 558         }
 559         return 0;
 560 }
 561
 562 int spi_nbyte_read(int address, uint8_t *bytes, int len)
 563 {
 564         const unsigned char cmd[JEDEC_READ_OUTSIZE] = {
 565                 JEDEC_READ,
 566                 (address >> 16) & 0xff,
 567                 (address >> 8) & 0xff,
 568                 (address >> 0) & 0xff,
 569         };
 570
 571         /* Send Read */
 572         return spi_command(sizeof(cmd), len, cmd, bytes);
 573 }
 574
 575 int spi_chip_read(struct flashchip *flash, uint8_t *buf)
 576 {
 577         switch (flashbus) {
 578         case BUS_TYPE_IT87XX_SPI:
 579                 return it8716f_spi_chip_read(flash, buf);
 580         case BUS_TYPE_SB600_SPI:
 581                 return sb600_spi_read(flash, buf);
 582         case BUS_TYPE_ICH7_SPI:
 583         case BUS_TYPE_ICH9_SPI:
 584         case BUS_TYPE_VIA_SPI:
 585                 return ich_spi_read(flash, buf);
 586         case BUS_TYPE_WBSIO_SPI:
 587                 return wbsio_spi_read(flash, buf);
 588         default:
 589                 printf_debug
 590                     ("%s called, but no SPI chipset/strapping detected\n",
 591                      __FUNCTION__);
 592         }
 593
 594         return 1;
 595 }
 596
 597 int spi_chip_write(struct flashchip *flash, uint8_t *buf)
 598 {
 599         switch (flashbus) {
 600         case BUS_TYPE_IT87XX_SPI:
 601                 return it8716f_spi_chip_write(flash, buf);
 602         case BUS_TYPE_SB600_SPI:
 603                 return sb600_spi_write(flash, buf);
 604         case BUS_TYPE_ICH7_SPI:
 605         case BUS_TYPE_ICH9_SPI:
 606         case BUS_TYPE_VIA_SPI:
 607                 return ich_spi_write(flash, buf);
 608         case BUS_TYPE_WBSIO_SPI:
 609                 return wbsio_spi_write(flash, buf);
 610         default:
 611                 printf_debug
 612                     ("%s called, but no SPI chipset/strapping detected\n",
 613                      __FUNCTION__);
 614         }
 615
 616         return 1;
 617 }
 618
 619 int spi_aai_write(struct flashchip *flash, uint8_t *buf) {
 620         uint32_t pos = 2, size = flash->total_size * 1024;
 621         unsigned char w[6] = {0xad, 0, 0, 0, buf[0], buf[1]};
 622         switch (flashbus) {
 623                 case BUS_TYPE_WBSIO_SPI:
 624                         fprintf(stderr, "%s: impossible with Winbond SPI masters, degrading to byte program\n", __func__);
 625                         return spi_chip_write(flash, buf);
 626                 default:
 627                         break;
 628         }
 629         flash->erase(flash);
 630         spi_write_enable();
 631         spi_command(6, 0, w, NULL);
 632         while (spi_read_status_register() & JEDEC_RDSR_BIT_WIP)
 633                 myusec_delay(5); /* SST25VF040B Tbp is max 10us */
 634         while (pos < size) {
 635                 w[1] = buf[pos++];
 636                 w[2] = buf[pos++];
 637                 spi_command(3, 0, w, NULL);
 638                 while (spi_read_status_register() & JEDEC_RDSR_BIT_WIP)
 639                         myusec_delay(5); /* SST25VF040B Tbp is max 10us */
 640         }
 641         spi_write_disable();
 642         return 0;
 643 }