granicus.if.org Git - esp-idf/blob - components/spi_flash/spi_flash_rom_patch.c

   1 // Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include "rom/ets_sys.h"
  16 #include "rom/gpio.h"
  17 #include "rom/spi_flash.h"
  18 #include "sdkconfig.h"
  19
  20 #define SPI_IDX   1
  21 #define OTH_IDX   0
  22
  23 extern esp_rom_spiflash_chip_t g_rom_spiflash_chip;
  24
  25 esp_rom_spiflash_result_t esp_rom_spiflash_wait_idle(esp_rom_spiflash_chip_t *spi)
  26 {
  27     uint32_t status;
  28
  29     //wait for spi control ready
  30     while ((REG_READ(SPI_EXT2_REG(1)) & SPI_ST)) {
  31     }
  32     while ((REG_READ(SPI_EXT2_REG(0)) & SPI_ST)) {
  33     }
  34     //wait for flash status ready
  35     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_read_status(spi, &status)) {
  36         return ESP_ROM_SPIFLASH_RESULT_ERR;
  37     }
  38     return  ESP_ROM_SPIFLASH_RESULT_OK;
  39 }
  40
  41
  42 /* Modified version of esp_rom_spiflash_unlock() that replaces version in ROM.
  43
  44    This works around a bug where esp_rom_spiflash_unlock sometimes reads the wrong
  45    high status byte (RDSR2 result) and then copies it back to the
  46    flash status, which can cause the CMP bit or Status Register
  47    Protect bit to become set.
  48
  49    Like other ROM SPI functions, this function is not designed to be
  50    called directly from an RTOS environment without taking precautions
  51    about interrupts, CPU coordination, flash mapping. However some of
  52    the functions in esp_spi_flash.c call it.
  53  */
  54 esp_rom_spiflash_result_t esp_rom_spiflash_unlock()
  55 {
  56     uint32_t status;
  57
  58     esp_rom_spiflash_wait_idle(&g_rom_spiflash_chip);
  59
  60     if (esp_rom_spiflash_read_statushigh(&g_rom_spiflash_chip, &status) != ESP_ROM_SPIFLASH_RESULT_OK) {
  61         return ESP_ROM_SPIFLASH_RESULT_ERR;
  62     }
  63
  64     /* Clear all bits except QIE, if it is set.
  65      (This is different from ROM esp_rom_spiflash_unlock, which keeps all bits as-is.)
  66     */
  67     status &= ESP_ROM_SPIFLASH_QE;
  68
  69     esp_rom_spiflash_wait_idle(&g_rom_spiflash_chip);
  70     REG_WRITE(SPI_CMD_REG(SPI_IDX), SPI_FLASH_WREN);
  71     while (REG_READ(SPI_CMD_REG(SPI_IDX)) != 0) {
  72     }
  73     esp_rom_spiflash_wait_idle(&g_rom_spiflash_chip);
  74
  75     SET_PERI_REG_MASK(SPI_CTRL_REG(SPI_IDX), SPI_WRSR_2B);
  76     if (esp_rom_spiflash_write_status(&g_rom_spiflash_chip, status) != ESP_ROM_SPIFLASH_RESULT_OK) {
  77         return ESP_ROM_SPIFLASH_RESULT_ERR;
  78     }
  79
  80     return ESP_ROM_SPIFLASH_RESULT_OK;
  81 }
  82
  83
  84 #if CONFIG_SPI_FLASH_ROM_DRIVER_PATCH
  85
  86 extern uint8_t g_rom_spiflash_dummy_len_plus[];
  87
  88
  89 static esp_rom_spiflash_result_t esp_rom_spiflash_enable_write(esp_rom_spiflash_chip_t *spi);
  90 static esp_rom_spiflash_result_t esp_rom_spiflash_enable_qmode(esp_rom_spiflash_chip_t *spi);
  91 static esp_rom_spiflash_result_t esp_rom_spiflash_disable_qmode(esp_rom_spiflash_chip_t *spi);
  92
  93
  94 //only support spi1
  95 static esp_rom_spiflash_result_t esp_rom_spiflash_erase_chip_internal(esp_rom_spiflash_chip_t *spi)
  96 {
  97     esp_rom_spiflash_wait_idle(spi);
  98
  99     // Chip erase.
 100     WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_CE);
 101     while (READ_PERI_REG(PERIPHS_SPI_FLASH_CMD) != 0);
 102
 103     // check erase is finished.
 104     esp_rom_spiflash_wait_idle(spi);
 105
 106     return ESP_ROM_SPIFLASH_RESULT_OK;
 107 }
 108
 109 //only support spi1
 110 static esp_rom_spiflash_result_t esp_rom_spiflash_erase_sector_internal(esp_rom_spiflash_chip_t *spi, uint32_t addr)
 111 {
 112     //check if addr is 4k alignment
 113     if (0 != (addr & 0xfff)) {
 114         return ESP_ROM_SPIFLASH_RESULT_ERR;
 115     }
 116
 117     esp_rom_spiflash_wait_idle(spi);
 118
 119     // sector erase  4Kbytes erase is sector erase.
 120     WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, addr & 0xffffff);
 121     WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_SE);
 122     while (READ_PERI_REG(PERIPHS_SPI_FLASH_CMD) != 0);
 123
 124     esp_rom_spiflash_wait_idle(spi);
 125
 126     return ESP_ROM_SPIFLASH_RESULT_OK;
 127 }
 128
 129 //only support spi1
 130 static esp_rom_spiflash_result_t esp_rom_spiflash_erase_block_internal(esp_rom_spiflash_chip_t *spi, uint32_t addr)
 131 {
 132     esp_rom_spiflash_wait_idle(spi);
 133
 134     // sector erase  4Kbytes erase is sector erase.
 135     WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, addr & 0xffffff);
 136     WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_BE);
 137     while (READ_PERI_REG(PERIPHS_SPI_FLASH_CMD) != 0);
 138
 139     esp_rom_spiflash_wait_idle(spi);
 140
 141     return ESP_ROM_SPIFLASH_RESULT_OK;
 142 }
 143
 144 //only support spi1
 145 static esp_rom_spiflash_result_t esp_rom_spiflash_program_page_internal(esp_rom_spiflash_chip_t *spi, uint32_t spi_addr,
 146         uint32_t *addr_source, int32_t byte_length)
 147 {
 148     uint32_t  temp_addr;
 149     int32_t  temp_bl;
 150     uint8_t   i;
 151     uint8_t   remain_word_num;
 152
 153     //check 4byte alignment
 154     if (0 != (byte_length & 0x3)) {
 155         return ESP_ROM_SPIFLASH_RESULT_ERR;
 156     }
 157
 158     //check if write in one page
 159     if ((spi->page_size) < ((spi_addr % (spi->page_size)) + byte_length)) {
 160         return ESP_ROM_SPIFLASH_RESULT_ERR;
 161     }
 162
 163     esp_rom_spiflash_wait_idle(spi);
 164
 165     temp_addr = spi_addr;
 166     temp_bl = byte_length;
 167
 168     while (temp_bl > 0 ) {
 169         if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_enable_write(spi)) {
 170             return ESP_ROM_SPIFLASH_RESULT_ERR;
 171         }
 172         if ( temp_bl >= ESP_ROM_SPIFLASH_BUFF_BYTE_WRITE_NUM ) {
 173             WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, (temp_addr & 0xffffff) | ( ESP_ROM_SPIFLASH_BUFF_BYTE_WRITE_NUM << ESP_ROM_SPIFLASH_BYTES_LEN )); // 32 byte a block
 174
 175             for (i = 0; i < (ESP_ROM_SPIFLASH_BUFF_BYTE_WRITE_NUM >> 2); i++) {
 176                 WRITE_PERI_REG(PERIPHS_SPI_FLASH_C0 + i * 4, *addr_source++);
 177             }
 178             temp_bl = temp_bl - 32;
 179             temp_addr = temp_addr + 32;
 180         } else {
 181             WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, (temp_addr & 0xffffff) | (temp_bl << ESP_ROM_SPIFLASH_BYTES_LEN ));
 182
 183             remain_word_num = (0 == (temp_bl & 0x3)) ? (temp_bl >> 2) : (temp_bl >> 2) + 1;
 184             for (i = 0; i < remain_word_num; i++) {
 185                 WRITE_PERI_REG(PERIPHS_SPI_FLASH_C0 + i * 4, *addr_source++);
 186                 temp_bl = temp_bl - 4;
 187             }
 188             temp_bl = 0;
 189         }
 190
 191         WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_PP);
 192         while ( READ_PERI_REG(PERIPHS_SPI_FLASH_CMD ) != 0 );
 193
 194         esp_rom_spiflash_wait_idle(spi);
 195     }
 196
 197     return ESP_ROM_SPIFLASH_RESULT_OK;
 198 }
 199
 200 //only support spi1
 201 static esp_rom_spiflash_result_t esp_rom_spiflash_read_data(esp_rom_spiflash_chip_t *spi, uint32_t flash_addr,
 202         uint32_t *addr_dest, int32_t byte_length)
 203 {
 204     uint32_t  temp_addr;
 205     int32_t  temp_length;
 206     uint8_t   i;
 207     uint8_t   remain_word_num;
 208
 209     //address range check
 210     if ((flash_addr + byte_length) > (spi->chip_size)) {
 211         return ESP_ROM_SPIFLASH_RESULT_ERR;
 212     }
 213
 214     temp_addr = flash_addr;
 215     temp_length = byte_length;
 216
 217     esp_rom_spiflash_wait_idle(spi);
 218
 219     while (temp_length > 0) {
 220         if (temp_length >= ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM) {
 221             //WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, temp_addr |(ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM << ESP_ROM_SPIFLASH_BYTES_LEN));
 222             REG_WRITE(SPI_MISO_DLEN_REG(1),  ((ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM << 3) - 1) << SPI_USR_MISO_DBITLEN_S);
 223             WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, temp_addr << 8);
 224             REG_WRITE(PERIPHS_SPI_FLASH_CMD, SPI_USR);
 225             while (REG_READ(PERIPHS_SPI_FLASH_CMD) != 0);
 226
 227             for (i = 0; i < (ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM >> 2); i++) {
 228                 *addr_dest++ = READ_PERI_REG(PERIPHS_SPI_FLASH_C0 + i * 4);
 229             }
 230             temp_length = temp_length - ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM;
 231             temp_addr = temp_addr + ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM;
 232         } else {
 233             //WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, temp_addr |(temp_length << ESP_ROM_SPIFLASH_BYTES_LEN ));
 234             WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, temp_addr << 8);
 235             REG_WRITE(SPI_MISO_DLEN_REG(1),  ((ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM << 3) - 1) << SPI_USR_MISO_DBITLEN_S);
 236             REG_WRITE(PERIPHS_SPI_FLASH_CMD, SPI_USR);
 237             while (REG_READ(PERIPHS_SPI_FLASH_CMD) != 0);
 238
 239             remain_word_num = (0 == (temp_length & 0x3)) ? (temp_length >> 2) : (temp_length >> 2) + 1;
 240             for (i = 0; i < remain_word_num; i++) {
 241                 *addr_dest++ = READ_PERI_REG(PERIPHS_SPI_FLASH_C0 + i * 4);
 242             }
 243             temp_length = 0;
 244         }
 245     }
 246
 247     return ESP_ROM_SPIFLASH_RESULT_OK;
 248 }
 249
 250 esp_rom_spiflash_result_t esp_rom_spiflash_read_status(esp_rom_spiflash_chip_t *spi, uint32_t *status)
 251 {
 252     uint32_t status_value = ESP_ROM_SPIFLASH_BUSY_FLAG;
 253
 254     if (g_rom_spiflash_dummy_len_plus[1] == 0) {
 255         while (ESP_ROM_SPIFLASH_BUSY_FLAG == (status_value & ESP_ROM_SPIFLASH_BUSY_FLAG)) {
 256             WRITE_PERI_REG(PERIPHS_SPI_FLASH_STATUS, 0);       // clear regisrter
 257             WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_RDSR);
 258             while (READ_PERI_REG(PERIPHS_SPI_FLASH_CMD) != 0);
 259
 260             status_value = READ_PERI_REG(PERIPHS_SPI_FLASH_STATUS) & (spi->status_mask);
 261         }
 262     } else {
 263         while (ESP_ROM_SPIFLASH_BUSY_FLAG == (status_value & ESP_ROM_SPIFLASH_BUSY_FLAG)) {
 264             esp_rom_spiflash_read_user_cmd(&status_value, 0x05);
 265         }
 266     }
 267     *status = status_value;
 268
 269     return ESP_ROM_SPIFLASH_RESULT_OK;
 270 }
 271
 272 esp_rom_spiflash_result_t esp_rom_spiflash_read_statushigh(esp_rom_spiflash_chip_t *spi, uint32_t *status)
 273 {
 274     esp_rom_spiflash_result_t ret;
 275     esp_rom_spiflash_wait_idle(&g_rom_spiflash_chip);
 276     ret = esp_rom_spiflash_read_user_cmd(status, 0x35);
 277     *status = *status << 8;
 278     return ret;
 279 }
 280
 281 esp_rom_spiflash_result_t esp_rom_spiflash_write_status(esp_rom_spiflash_chip_t *spi, uint32_t status_value)
 282 {
 283     esp_rom_spiflash_wait_idle(spi);
 284
 285     // update status value by status_value
 286     WRITE_PERI_REG(PERIPHS_SPI_FLASH_STATUS, status_value);    // write status regisrter
 287     WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_WRSR);
 288     while (READ_PERI_REG(PERIPHS_SPI_FLASH_CMD) != 0);
 289     esp_rom_spiflash_wait_idle(spi);
 290
 291     return ESP_ROM_SPIFLASH_RESULT_OK;
 292 }
 293
 294 static esp_rom_spiflash_result_t esp_rom_spiflash_enable_write(esp_rom_spiflash_chip_t *spi)
 295 {
 296     uint32_t flash_status = 0;
 297
 298     esp_rom_spiflash_wait_idle(spi);
 299
 300     //enable write
 301     WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_WREN);     // enable write operation
 302     while (READ_PERI_REG(PERIPHS_SPI_FLASH_CMD) != 0);
 303
 304     // make sure the flash is ready for writing
 305     while (ESP_ROM_SPIFLASH_WRENABLE_FLAG != (flash_status & ESP_ROM_SPIFLASH_WRENABLE_FLAG)) {
 306         esp_rom_spiflash_read_status(spi, &flash_status);
 307     }
 308
 309     return ESP_ROM_SPIFLASH_RESULT_OK;
 310 }
 311
 312 static esp_rom_spiflash_result_t esp_rom_spiflash_enable_qmode(esp_rom_spiflash_chip_t *spi)
 313 {
 314     uint32_t flash_status;
 315     uint32_t status;
 316     //read QE bit, not write if QE
 317     if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_read_statushigh(spi, &status)) {
 318         return ESP_ROM_SPIFLASH_RESULT_ERR;
 319     }
 320     if (status & ESP_ROM_SPIFLASH_QE) {
 321         return ESP_ROM_SPIFLASH_RESULT_OK;
 322     }
 323
 324     //enable 2 byte status writing
 325     SET_PERI_REG_MASK(PERIPHS_SPI_FLASH_CTRL, ESP_ROM_SPIFLASH_TWO_BYTE_STATUS_EN);
 326
 327     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_enable_write(spi)) {
 328         return ESP_ROM_SPIFLASH_RESULT_ERR;
 329     }
 330
 331     esp_rom_spiflash_read_status(spi, &flash_status);
 332
 333     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_write_status(spi, flash_status | ESP_ROM_SPIFLASH_QE)) {
 334         return ESP_ROM_SPIFLASH_RESULT_ERR;
 335     }
 336
 337     return ESP_ROM_SPIFLASH_RESULT_OK;
 338 }
 339
 340 static esp_rom_spiflash_result_t esp_rom_spiflash_disable_qmode(esp_rom_spiflash_chip_t *spi)
 341 {
 342     uint32_t flash_status;
 343     uint32_t status;
 344
 345     //read QE bit, not write if not QE
 346     if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_read_statushigh(spi, &status)) {
 347         return ESP_ROM_SPIFLASH_RESULT_ERR;
 348     }
 349     //ets_printf("status %08x, line:%u\n", status, __LINE__);
 350
 351     if (!(status & ESP_ROM_SPIFLASH_QE)) {
 352         return ESP_ROM_SPIFLASH_RESULT_OK;
 353     }
 354
 355     //enable 2 byte status writing
 356     SET_PERI_REG_MASK(PERIPHS_SPI_FLASH_CTRL, ESP_ROM_SPIFLASH_TWO_BYTE_STATUS_EN);
 357
 358     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_enable_write(spi)) {
 359         return ESP_ROM_SPIFLASH_RESULT_ERR;
 360     }
 361
 362     esp_rom_spiflash_read_status(spi, &flash_status);
 363     //keep low 8 bit
 364     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_write_status(spi, flash_status & 0xff)) {
 365         return ESP_ROM_SPIFLASH_RESULT_ERR;
 366     }
 367
 368     return ESP_ROM_SPIFLASH_RESULT_OK;
 369 }
 370
 371 static void spi_cache_mode_switch(uint32_t  modebit)
 372 {
 373     if ((modebit & SPI_FREAD_QIO) && (modebit & SPI_FASTRD_MODE)) {
 374         REG_CLR_BIT(SPI_USER_REG(0), SPI_USR_MOSI);
 375         REG_SET_BIT(SPI_USER_REG(0), SPI_USR_MISO | SPI_USR_DUMMY | SPI_USR_ADDR);
 376         REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_ADDR_BITLEN, SPI0_R_QIO_ADDR_BITSLEN);
 377         REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_DUMMY_CYCLELEN, SPI0_R_QIO_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[0]);
 378         REG_SET_FIELD(SPI_USER2_REG(0), SPI_USR_COMMAND_VALUE, 0xEB);
 379     } else if (modebit & SPI_FASTRD_MODE) {
 380         REG_CLR_BIT(SPI_USER_REG(0), SPI_USR_MOSI);
 381         REG_SET_BIT(SPI_USER_REG(0), SPI_USR_MISO | SPI_USR_DUMMY | SPI_USR_ADDR);
 382         REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_ADDR_BITLEN, SPI0_R_FAST_ADDR_BITSLEN);
 383         if ((modebit & SPI_FREAD_QUAD)) {
 384             REG_SET_FIELD(SPI_USER2_REG(0), SPI_USR_COMMAND_VALUE, 0x6B);
 385             REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_DUMMY_CYCLELEN, SPI0_R_FAST_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[0]);
 386         } else if ((modebit & SPI_FREAD_DIO)) {
 387             REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_DUMMY_CYCLELEN, SPI0_R_DIO_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[0]);
 388             REG_SET_FIELD(SPI_USER2_REG(0), SPI_USR_COMMAND_VALUE, 0xBB);
 389         } else if ((modebit & SPI_FREAD_DUAL)) {
 390             REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_DUMMY_CYCLELEN, SPI0_R_FAST_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[0]);
 391             REG_SET_FIELD(SPI_USER2_REG(0), SPI_USR_COMMAND_VALUE, 0x3B);
 392         } else {
 393             REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_DUMMY_CYCLELEN, SPI0_R_FAST_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[0]);
 394             REG_SET_FIELD(SPI_USER2_REG(0), SPI_USR_COMMAND_VALUE, 0x0B);
 395         }
 396     } else {
 397         REG_CLR_BIT(SPI_USER_REG(0), SPI_USR_MOSI);
 398         if (g_rom_spiflash_dummy_len_plus[0] == 0) {
 399             REG_CLR_BIT(SPI_USER_REG(0), SPI_USR_DUMMY);
 400         } else {
 401             REG_SET_BIT(SPI_USER_REG(0), SPI_USR_DUMMY);
 402             REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_DUMMY_CYCLELEN, g_rom_spiflash_dummy_len_plus[0] - 1);
 403         }
 404         REG_SET_BIT(SPI_USER_REG(0), SPI_USR_MISO | SPI_USR_ADDR);
 405         REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_ADDR_BITLEN, SPI0_R_SIO_ADDR_BITSLEN);
 406         REG_SET_FIELD(SPI_USER2_REG(0), SPI_USR_COMMAND_VALUE, 0x03);
 407     }
 408
 409 }
 410
 411 esp_rom_spiflash_result_t esp_rom_spiflash_lock()
 412 {
 413     uint32_t status;
 414
 415     //read QE bit, not write if not QE
 416     if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_read_statushigh(&g_rom_spiflash_chip, &status)) {
 417         return ESP_ROM_SPIFLASH_RESULT_ERR;
 418     }
 419     //enable 2 byte status writing
 420     SET_PERI_REG_MASK(PERIPHS_SPI_FLASH_CTRL, ESP_ROM_SPIFLASH_TWO_BYTE_STATUS_EN);
 421
 422     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_enable_write(&g_rom_spiflash_chip)) {
 423         return ESP_ROM_SPIFLASH_RESULT_ERR;
 424     }
 425
 426     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_write_status(&g_rom_spiflash_chip, status | ESP_ROM_SPIFLASH_WR_PROTECT)) {
 427         return ESP_ROM_SPIFLASH_RESULT_ERR;
 428     }
 429
 430     return ESP_ROM_SPIFLASH_RESULT_OK;
 431 }
 432
 433
 434 esp_rom_spiflash_result_t esp_rom_spiflash_config_readmode(esp_rom_spiflash_read_mode_t mode, bool legacy)
 435 {
 436     uint32_t  modebit;
 437
 438     while ((REG_READ(SPI_EXT2_REG(1)) & SPI_ST)) {
 439     }
 440     while ((REG_READ(SPI_EXT2_REG(0)) & SPI_ST)) {
 441     }
 442     //clear old mode bit
 443     CLEAR_PERI_REG_MASK(PERIPHS_SPI_FLASH_CTRL, SPI_FREAD_QIO | SPI_FREAD_QUAD | SPI_FREAD_DIO | SPI_FREAD_DUAL | SPI_FASTRD_MODE);
 444     CLEAR_PERI_REG_MASK(SPI_CTRL_REG(0), SPI_FREAD_QIO | SPI_FREAD_QUAD | SPI_FREAD_DIO | SPI_FREAD_DUAL | SPI_FASTRD_MODE);
 445     //configure read mode
 446     switch (mode) {
 447     case ESP_ROM_SPIFLASH_QIO_MODE   :  modebit = SPI_FREAD_QIO  | SPI_FASTRD_MODE; break;
 448     case ESP_ROM_SPIFLASH_QOUT_MODE  :  modebit = SPI_FREAD_QUAD | SPI_FASTRD_MODE; break;
 449     case ESP_ROM_SPIFLASH_DIO_MODE   :  modebit = SPI_FREAD_DIO  | SPI_FASTRD_MODE; break;
 450     case ESP_ROM_SPIFLASH_DOUT_MODE  :  modebit = SPI_FREAD_DUAL | SPI_FASTRD_MODE; break;
 451     case ESP_ROM_SPIFLASH_FASTRD_MODE:  modebit = SPI_FASTRD_MODE; break;
 452     case ESP_ROM_SPIFLASH_SLOWRD_MODE:  modebit = 0; break;
 453     default : modebit = 0;
 454     }
 455
 456     if ((ESP_ROM_SPIFLASH_QIO_MODE == mode) || (ESP_ROM_SPIFLASH_QOUT_MODE == mode)) {
 457         esp_rom_spiflash_enable_qmode(&g_rom_spiflash_chip);
 458     } else {
 459         //do not need disable QMode in faster boot
 460         if (legacy) {
 461             esp_rom_spiflash_disable_qmode(&g_rom_spiflash_chip);
 462         }
 463     }
 464
 465     SET_PERI_REG_MASK(PERIPHS_SPI_FLASH_CTRL, modebit);
 466     SET_PERI_REG_MASK(SPI_CTRL_REG(0), modebit);
 467     spi_cache_mode_switch(modebit);
 468
 469     return  ESP_ROM_SPIFLASH_RESULT_OK;
 470 }
 471
 472 esp_rom_spiflash_result_t esp_rom_spiflash_erase_chip()
 473 {
 474     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_enable_write(&g_rom_spiflash_chip)) {
 475         return ESP_ROM_SPIFLASH_RESULT_ERR;
 476     }
 477
 478     if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_erase_chip_internal(&g_rom_spiflash_chip)) {
 479         return ESP_ROM_SPIFLASH_RESULT_ERR;
 480     }
 481
 482     return ESP_ROM_SPIFLASH_RESULT_OK;
 483 }
 484
 485 esp_rom_spiflash_result_t esp_rom_spiflash_erase_block(uint32_t block_num)
 486 {
 487     // flash write is always 1 line currently
 488     REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 489     REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, ESP_ROM_SPIFLASH_W_SIO_ADDR_BITSLEN);
 490
 491     //check program size
 492     if (block_num >= ((g_rom_spiflash_chip.chip_size) / (g_rom_spiflash_chip.block_size))) {
 493         return ESP_ROM_SPIFLASH_RESULT_ERR;
 494     }
 495
 496     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_enable_write(&g_rom_spiflash_chip)) {
 497         return ESP_ROM_SPIFLASH_RESULT_ERR;
 498     }
 499
 500     if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_erase_block_internal(&g_rom_spiflash_chip, block_num * (g_rom_spiflash_chip.block_size))) {
 501         return ESP_ROM_SPIFLASH_RESULT_ERR;
 502     }
 503     return ESP_ROM_SPIFLASH_RESULT_OK;
 504 }
 505
 506 esp_rom_spiflash_result_t esp_rom_spiflash_erase_sector(uint32_t sector_num)
 507 {
 508     // flash write is always 1 line currently
 509     REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 510     REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, ESP_ROM_SPIFLASH_W_SIO_ADDR_BITSLEN);
 511
 512     //check program size
 513     if (sector_num >= ((g_rom_spiflash_chip.chip_size) / (g_rom_spiflash_chip.sector_size))) {
 514         return ESP_ROM_SPIFLASH_RESULT_ERR;
 515     }
 516
 517     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_enable_write(&g_rom_spiflash_chip)) {
 518         return ESP_ROM_SPIFLASH_RESULT_ERR;
 519     }
 520
 521     if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_erase_sector_internal(&g_rom_spiflash_chip, sector_num * (g_rom_spiflash_chip.sector_size))) {
 522         return ESP_ROM_SPIFLASH_RESULT_ERR;
 523     }
 524
 525     return ESP_ROM_SPIFLASH_RESULT_OK;
 526 }
 527
 528 esp_rom_spiflash_result_t esp_rom_spiflash_write(uint32_t target, const uint32_t *src_addr, int32_t len)
 529 {
 530     uint32_t  page_size;
 531     uint32_t  pgm_len, pgm_num;
 532     uint8_t    i;
 533
 534     // flash write is always 1 line currently
 535     REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 536     REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, ESP_ROM_SPIFLASH_W_SIO_ADDR_BITSLEN);
 537
 538     //check program size
 539     if ( (target + len) > (g_rom_spiflash_chip.chip_size)) {
 540         return ESP_ROM_SPIFLASH_RESULT_ERR;
 541     }
 542
 543     page_size = g_rom_spiflash_chip.page_size;
 544     pgm_len = page_size - (target % page_size);
 545     if (len < pgm_len) {
 546         if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_program_page_internal(&g_rom_spiflash_chip,
 547                 target, (uint32_t *)src_addr, len)) {
 548             return ESP_ROM_SPIFLASH_RESULT_ERR;
 549         }
 550     } else {
 551         if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_program_page_internal(&g_rom_spiflash_chip,
 552                 target, (uint32_t *)src_addr, pgm_len)) {
 553             return ESP_ROM_SPIFLASH_RESULT_ERR;
 554         }
 555
 556         //whole page program
 557         pgm_num = (len - pgm_len) / page_size;
 558         for (i = 0; i < pgm_num; i++) {
 559             if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_program_page_internal(&g_rom_spiflash_chip,
 560                     target + pgm_len, (uint32_t *)src_addr + (pgm_len >> 2), page_size)) {
 561                 return ESP_ROM_SPIFLASH_RESULT_ERR;
 562             }
 563             pgm_len += page_size;
 564         }
 565
 566         //remain parts to program
 567         if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_program_page_internal(&g_rom_spiflash_chip,
 568                 target + pgm_len, (uint32_t *)src_addr + (pgm_len >> 2), len - pgm_len)) {
 569             return ESP_ROM_SPIFLASH_RESULT_ERR;
 570         }
 571     }
 572     return  ESP_ROM_SPIFLASH_RESULT_OK;
 573 }
 574
 575 esp_rom_spiflash_result_t esp_rom_spiflash_write_encrypted(uint32_t flash_addr, uint32_t *data, uint32_t len)
 576 {
 577     esp_rom_spiflash_result_t ret = ESP_ROM_SPIFLASH_RESULT_OK;
 578     uint32_t i;
 579
 580     if ((flash_addr & 0x1f) || (len & 0x1f)) {  //check 32 byte alignment
 581         return ESP_ROM_SPIFLASH_RESULT_ERR;
 582     }
 583
 584     esp_rom_spiflash_write_encrypted_enable();
 585
 586     for (i = 0; i < (len >> 5); i++) {
 587         if ((ret = esp_rom_spiflash_prepare_encrypted_data(flash_addr + (i << 5), data + (i << 3))) != ESP_ROM_SPIFLASH_RESULT_OK) {
 588             break;
 589         }
 590
 591         if ((ret = esp_rom_spiflash_write(flash_addr + (i << 5), data, 32)) != ESP_ROM_SPIFLASH_RESULT_OK) {
 592             break;
 593         }
 594     }
 595
 596     esp_rom_spiflash_write_encrypted_disable();
 597
 598     return ret;
 599 }
 600
 601
 602 esp_rom_spiflash_result_t esp_rom_spiflash_read(uint32_t target, uint32_t *dest_addr, int32_t len)
 603 {
 604     // QIO or SIO, non-QIO regard as SIO
 605     uint32_t modebit;
 606     modebit = READ_PERI_REG(PERIPHS_SPI_FLASH_CTRL);
 607     if ((modebit & SPI_FREAD_QIO) && (modebit & SPI_FASTRD_MODE)) {
 608         REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_MOSI);
 609         REG_SET_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_MISO | SPI_USR_DUMMY | SPI_USR_ADDR);
 610         REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, SPI1_R_QIO_ADDR_BITSLEN);
 611         REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_DUMMY_CYCLELEN, SPI1_R_QIO_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[1]);
 612         //REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG2, SPI_USR_COMMAND_VALUE, 0xEB);
 613         REG_WRITE(PERIPHS_SPI_FLASH_USRREG2, (0x7 << SPI_USR_COMMAND_BITLEN_S) | 0xEB);
 614     } else if (modebit & SPI_FASTRD_MODE) {
 615         REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_MOSI);
 616         REG_SET_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_MISO | SPI_USR_ADDR);
 617         if (modebit & SPI_FREAD_DIO) {
 618             if (g_rom_spiflash_dummy_len_plus[1] == 0) {
 619                 REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 620                 REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, SPI1_R_DIO_ADDR_BITSLEN);
 621                 REG_WRITE(PERIPHS_SPI_FLASH_USRREG2, (0x7 << SPI_USR_COMMAND_BITLEN_S) | 0xBB);
 622             } else {
 623                 REG_SET_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 624                 REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, SPI1_R_DIO_ADDR_BITSLEN);
 625                 REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_DUMMY_CYCLELEN, g_rom_spiflash_dummy_len_plus[1] - 1);
 626                 REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG2, SPI_USR_COMMAND_VALUE, 0xBB);
 627             }
 628         } else {
 629             if ((modebit & SPI_FREAD_QUAD)) {
 630                 //REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG2, SPI_USR_COMMAND_VALUE, 0x6B);
 631                 REG_WRITE(PERIPHS_SPI_FLASH_USRREG2, (0x7 << SPI_USR_COMMAND_BITLEN_S) | 0x6B);
 632             } else if ((modebit & SPI_FREAD_DUAL)) {
 633                 //REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG2, SPI_USR_COMMAND_VALUE, 0x3B);
 634                 REG_WRITE(PERIPHS_SPI_FLASH_USRREG2, (0x7 << SPI_USR_COMMAND_BITLEN_S) | 0x3B);
 635             } else {
 636                 //REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG2, SPI_USR_COMMAND_VALUE, 0x0B);
 637                 REG_WRITE(PERIPHS_SPI_FLASH_USRREG2, (0x7 << SPI_USR_COMMAND_BITLEN_S) | 0x0B);
 638             }
 639             REG_SET_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 640             REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, SPI1_R_FAST_ADDR_BITSLEN);
 641             REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_DUMMY_CYCLELEN, SPI1_R_FAST_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[1]);
 642         }
 643     } else {
 644         REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_MOSI);
 645         if (g_rom_spiflash_dummy_len_plus[1] == 0) {
 646             REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 647         } else {
 648             REG_SET_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 649             REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_DUMMY_CYCLELEN,  g_rom_spiflash_dummy_len_plus[1] - 1);
 650         }
 651         REG_SET_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_MISO | SPI_USR_ADDR);
 652         REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, SPI1_R_SIO_ADDR_BITSLEN);
 653         //REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG2, SPI_USR_COMMAND_VALUE, 0x03);
 654         REG_WRITE(PERIPHS_SPI_FLASH_USRREG2, (0x7 << SPI_USR_COMMAND_BITLEN_S) | 0x03);
 655     }
 656
 657     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_read_data(&g_rom_spiflash_chip, target, dest_addr, len)) {
 658         return ESP_ROM_SPIFLASH_RESULT_ERR;
 659     }
 660     return ESP_ROM_SPIFLASH_RESULT_OK;
 661 }
 662
 663 esp_rom_spiflash_result_t esp_rom_spiflash_erase_area(uint32_t start_addr, uint32_t area_len)
 664 {
 665     int32_t total_sector_num;
 666     int32_t head_sector_num;
 667     uint32_t sector_no;
 668     uint32_t sector_num_per_block;
 669
 670     //set read mode to Fastmode ,not QDIO mode for erase
 671     esp_rom_spiflash_config_readmode(ESP_ROM_SPIFLASH_SLOWRD_MODE, true);
 672
 673     //check if area is oversize of flash
 674     if ((start_addr + area_len) > g_rom_spiflash_chip.chip_size) {
 675         return ESP_ROM_SPIFLASH_RESULT_ERR;
 676     }
 677
 678     //start_addr is aligned as sector boundary
 679     if (0 != (start_addr % g_rom_spiflash_chip.sector_size)) {
 680         return ESP_ROM_SPIFLASH_RESULT_ERR;
 681     }
 682
 683     //Unlock flash to enable erase
 684     if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_unlock(/*&g_rom_spiflash_chip*/)) {
 685         return ESP_ROM_SPIFLASH_RESULT_ERR;
 686     }
 687
 688     sector_no = start_addr / g_rom_spiflash_chip.sector_size;
 689     sector_num_per_block = g_rom_spiflash_chip.block_size / g_rom_spiflash_chip.sector_size;
 690     total_sector_num = (0 == (area_len % g_rom_spiflash_chip.sector_size)) ? area_len / g_rom_spiflash_chip.sector_size :
 691                        1 + (area_len / g_rom_spiflash_chip.sector_size);
 692
 693     //check if erase area reach over block boundary
 694     head_sector_num = sector_num_per_block - (sector_no % sector_num_per_block);
 695
 696     head_sector_num = (head_sector_num >= total_sector_num) ? total_sector_num : head_sector_num;
 697
 698     //JJJ, BUG of 6.0 erase
 699     //middle part of area is aligned by blocks
 700     total_sector_num -= head_sector_num;
 701
 702     //head part of area is erased
 703     while (0 != head_sector_num) {
 704         if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_erase_sector(sector_no)) {
 705             return ESP_ROM_SPIFLASH_RESULT_ERR;
 706         }
 707         sector_no++;
 708         head_sector_num--;
 709     }
 710     while (total_sector_num > sector_num_per_block) {
 711         if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_erase_block(sector_no / sector_num_per_block)) {
 712             return ESP_ROM_SPIFLASH_RESULT_ERR;
 713         }
 714         sector_no += sector_num_per_block;
 715         total_sector_num -= sector_num_per_block;
 716     }
 717
 718     //tail part of area burn
 719     while (0 < total_sector_num) {
 720         if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_erase_sector(sector_no)) {
 721             return ESP_ROM_SPIFLASH_RESULT_ERR;
 722         }
 723         sector_no++;
 724         total_sector_num--;
 725     }
 726
 727     return ESP_ROM_SPIFLASH_RESULT_OK;
 728 }
 729
 730 #endif