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
  91 //only support spi1
  92 static esp_rom_spiflash_result_t esp_rom_spiflash_erase_chip_internal(esp_rom_spiflash_chip_t *spi)
  93 {
  94     esp_rom_spiflash_wait_idle(spi);
  95
  96     // Chip erase.
  97     WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_CE);
  98     while (READ_PERI_REG(PERIPHS_SPI_FLASH_CMD) != 0);
  99
 100     // check erase is finished.
 101     esp_rom_spiflash_wait_idle(spi);
 102
 103     return ESP_ROM_SPIFLASH_RESULT_OK;
 104 }
 105
 106 //only support spi1
 107 static esp_rom_spiflash_result_t esp_rom_spiflash_erase_sector_internal(esp_rom_spiflash_chip_t *spi, uint32_t addr)
 108 {
 109     //check if addr is 4k alignment
 110     if (0 != (addr & 0xfff)) {
 111         return ESP_ROM_SPIFLASH_RESULT_ERR;
 112     }
 113
 114     esp_rom_spiflash_wait_idle(spi);
 115
 116     // sector erase  4Kbytes erase is sector erase.
 117     WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, addr & 0xffffff);
 118     WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_SE);
 119     while (READ_PERI_REG(PERIPHS_SPI_FLASH_CMD) != 0);
 120
 121     esp_rom_spiflash_wait_idle(spi);
 122
 123     return ESP_ROM_SPIFLASH_RESULT_OK;
 124 }
 125
 126 //only support spi1
 127 static esp_rom_spiflash_result_t esp_rom_spiflash_erase_block_internal(esp_rom_spiflash_chip_t *spi, uint32_t addr)
 128 {
 129     esp_rom_spiflash_wait_idle(spi);
 130
 131     // sector erase  4Kbytes erase is sector erase.
 132     WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, addr & 0xffffff);
 133     WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_BE);
 134     while (READ_PERI_REG(PERIPHS_SPI_FLASH_CMD) != 0);
 135
 136     esp_rom_spiflash_wait_idle(spi);
 137
 138     return ESP_ROM_SPIFLASH_RESULT_OK;
 139 }
 140
 141 //only support spi1
 142 static esp_rom_spiflash_result_t esp_rom_spiflash_program_page_internal(esp_rom_spiflash_chip_t *spi, uint32_t spi_addr,
 143         uint32_t *addr_source, int32_t byte_length)
 144 {
 145     uint32_t  temp_addr;
 146     int32_t  temp_bl;
 147     uint8_t   i;
 148     uint8_t   remain_word_num;
 149
 150     //check 4byte alignment
 151     if (0 != (byte_length & 0x3)) {
 152         return ESP_ROM_SPIFLASH_RESULT_ERR;
 153     }
 154
 155     //check if write in one page
 156     if ((spi->page_size) < ((spi_addr % (spi->page_size)) + byte_length)) {
 157         return ESP_ROM_SPIFLASH_RESULT_ERR;
 158     }
 159
 160     esp_rom_spiflash_wait_idle(spi);
 161
 162     temp_addr = spi_addr;
 163     temp_bl = byte_length;
 164
 165     while (temp_bl > 0 ) {
 166         if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_enable_write(spi)) {
 167             return ESP_ROM_SPIFLASH_RESULT_ERR;
 168         }
 169         if ( temp_bl >= ESP_ROM_SPIFLASH_BUFF_BYTE_WRITE_NUM ) {
 170             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
 171
 172             for (i = 0; i < (ESP_ROM_SPIFLASH_BUFF_BYTE_WRITE_NUM >> 2); i++) {
 173                 WRITE_PERI_REG(PERIPHS_SPI_FLASH_C0 + i * 4, *addr_source++);
 174             }
 175             temp_bl = temp_bl - 32;
 176             temp_addr = temp_addr + 32;
 177         } else {
 178             WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, (temp_addr & 0xffffff) | (temp_bl << ESP_ROM_SPIFLASH_BYTES_LEN ));
 179
 180             remain_word_num = (0 == (temp_bl & 0x3)) ? (temp_bl >> 2) : (temp_bl >> 2) + 1;
 181             for (i = 0; i < remain_word_num; i++) {
 182                 WRITE_PERI_REG(PERIPHS_SPI_FLASH_C0 + i * 4, *addr_source++);
 183                 temp_bl = temp_bl - 4;
 184             }
 185             temp_bl = 0;
 186         }
 187
 188         WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_PP);
 189         while ( READ_PERI_REG(PERIPHS_SPI_FLASH_CMD ) != 0 );
 190
 191         esp_rom_spiflash_wait_idle(spi);
 192     }
 193
 194     return ESP_ROM_SPIFLASH_RESULT_OK;
 195 }
 196
 197 //only support spi1
 198 static esp_rom_spiflash_result_t esp_rom_spiflash_read_data(esp_rom_spiflash_chip_t *spi, uint32_t flash_addr,
 199         uint32_t *addr_dest, int32_t byte_length)
 200 {
 201     uint32_t  temp_addr;
 202     int32_t  temp_length;
 203     uint8_t   i;
 204     uint8_t   remain_word_num;
 205
 206     //address range check
 207     if ((flash_addr + byte_length) > (spi->chip_size)) {
 208         return ESP_ROM_SPIFLASH_RESULT_ERR;
 209     }
 210
 211     temp_addr = flash_addr;
 212     temp_length = byte_length;
 213
 214     esp_rom_spiflash_wait_idle(spi);
 215
 216     while (temp_length > 0) {
 217         if (temp_length >= ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM) {
 218             //WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, temp_addr |(ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM << ESP_ROM_SPIFLASH_BYTES_LEN));
 219             REG_WRITE(SPI_MISO_DLEN_REG(1),  ((ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM << 3) - 1) << SPI_USR_MISO_DBITLEN_S);
 220             WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, temp_addr << 8);
 221             REG_WRITE(PERIPHS_SPI_FLASH_CMD, SPI_USR);
 222             while (REG_READ(PERIPHS_SPI_FLASH_CMD) != 0);
 223
 224             for (i = 0; i < (ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM >> 2); i++) {
 225                 *addr_dest++ = READ_PERI_REG(PERIPHS_SPI_FLASH_C0 + i * 4);
 226             }
 227             temp_length = temp_length - ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM;
 228             temp_addr = temp_addr + ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM;
 229         } else {
 230             //WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, temp_addr |(temp_length << ESP_ROM_SPIFLASH_BYTES_LEN ));
 231             WRITE_PERI_REG(PERIPHS_SPI_FLASH_ADDR, temp_addr << 8);
 232             REG_WRITE(SPI_MISO_DLEN_REG(1),  ((ESP_ROM_SPIFLASH_BUFF_BYTE_READ_NUM << 3) - 1) << SPI_USR_MISO_DBITLEN_S);
 233             REG_WRITE(PERIPHS_SPI_FLASH_CMD, SPI_USR);
 234             while (REG_READ(PERIPHS_SPI_FLASH_CMD) != 0);
 235
 236             remain_word_num = (0 == (temp_length & 0x3)) ? (temp_length >> 2) : (temp_length >> 2) + 1;
 237             for (i = 0; i < remain_word_num; i++) {
 238                 *addr_dest++ = READ_PERI_REG(PERIPHS_SPI_FLASH_C0 + i * 4);
 239             }
 240             temp_length = 0;
 241         }
 242     }
 243
 244     return ESP_ROM_SPIFLASH_RESULT_OK;
 245 }
 246
 247 esp_rom_spiflash_result_t esp_rom_spiflash_read_status(esp_rom_spiflash_chip_t *spi, uint32_t *status)
 248 {
 249     uint32_t status_value = ESP_ROM_SPIFLASH_BUSY_FLAG;
 250
 251     if (g_rom_spiflash_dummy_len_plus[1] == 0) {
 252         while (ESP_ROM_SPIFLASH_BUSY_FLAG == (status_value & ESP_ROM_SPIFLASH_BUSY_FLAG)) {
 253             WRITE_PERI_REG(PERIPHS_SPI_FLASH_STATUS, 0);       // clear regisrter
 254             WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_RDSR);
 255             while (READ_PERI_REG(PERIPHS_SPI_FLASH_CMD) != 0);
 256
 257             status_value = READ_PERI_REG(PERIPHS_SPI_FLASH_STATUS) & (spi->status_mask);
 258         }
 259     } else {
 260         while (ESP_ROM_SPIFLASH_BUSY_FLAG == (status_value & ESP_ROM_SPIFLASH_BUSY_FLAG)) {
 261             esp_rom_spiflash_read_user_cmd(&status_value, 0x05);
 262         }
 263     }
 264     *status = status_value;
 265
 266     return ESP_ROM_SPIFLASH_RESULT_OK;
 267 }
 268
 269 esp_rom_spiflash_result_t esp_rom_spiflash_read_statushigh(esp_rom_spiflash_chip_t *spi, uint32_t *status)
 270 {
 271     esp_rom_spiflash_result_t ret;
 272     esp_rom_spiflash_wait_idle(&g_rom_spiflash_chip);
 273     ret = esp_rom_spiflash_read_user_cmd(status, 0x35);
 274     *status = *status << 8;
 275     return ret;
 276 }
 277
 278 esp_rom_spiflash_result_t esp_rom_spiflash_write_status(esp_rom_spiflash_chip_t *spi, uint32_t status_value)
 279 {
 280     esp_rom_spiflash_wait_idle(spi);
 281
 282     // update status value by status_value
 283     WRITE_PERI_REG(PERIPHS_SPI_FLASH_STATUS, status_value);    // write status regisrter
 284     WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_WRSR);
 285     while (READ_PERI_REG(PERIPHS_SPI_FLASH_CMD) != 0);
 286     esp_rom_spiflash_wait_idle(spi);
 287
 288     return ESP_ROM_SPIFLASH_RESULT_OK;
 289 }
 290
 291 static esp_rom_spiflash_result_t esp_rom_spiflash_enable_write(esp_rom_spiflash_chip_t *spi)
 292 {
 293     uint32_t flash_status = 0;
 294
 295     esp_rom_spiflash_wait_idle(spi);
 296
 297     //enable write
 298     WRITE_PERI_REG(PERIPHS_SPI_FLASH_CMD, SPI_FLASH_WREN);     // enable write operation
 299     while (READ_PERI_REG(PERIPHS_SPI_FLASH_CMD) != 0);
 300
 301     // make sure the flash is ready for writing
 302     while (ESP_ROM_SPIFLASH_WRENABLE_FLAG != (flash_status & ESP_ROM_SPIFLASH_WRENABLE_FLAG)) {
 303         esp_rom_spiflash_read_status(spi, &flash_status);
 304     }
 305
 306     return ESP_ROM_SPIFLASH_RESULT_OK;
 307 }
 308
 309 static void spi_cache_mode_switch(uint32_t  modebit)
 310 {
 311     if ((modebit & SPI_FREAD_QIO) && (modebit & SPI_FASTRD_MODE)) {
 312         REG_CLR_BIT(SPI_USER_REG(0), SPI_USR_MOSI);
 313         REG_SET_BIT(SPI_USER_REG(0), SPI_USR_MISO | SPI_USR_DUMMY | SPI_USR_ADDR);
 314         REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_ADDR_BITLEN, SPI0_R_QIO_ADDR_BITSLEN);
 315         REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_DUMMY_CYCLELEN, SPI0_R_QIO_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[0]);
 316         REG_SET_FIELD(SPI_USER2_REG(0), SPI_USR_COMMAND_VALUE, 0xEB);
 317     } else if (modebit & SPI_FASTRD_MODE) {
 318         REG_CLR_BIT(SPI_USER_REG(0), SPI_USR_MOSI);
 319         REG_SET_BIT(SPI_USER_REG(0), SPI_USR_MISO | SPI_USR_DUMMY | SPI_USR_ADDR);
 320         REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_ADDR_BITLEN, SPI0_R_FAST_ADDR_BITSLEN);
 321         if ((modebit & SPI_FREAD_QUAD)) {
 322             REG_SET_FIELD(SPI_USER2_REG(0), SPI_USR_COMMAND_VALUE, 0x6B);
 323             REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_DUMMY_CYCLELEN, SPI0_R_FAST_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[0]);
 324         } else if ((modebit & SPI_FREAD_DIO)) {
 325             REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_DUMMY_CYCLELEN, SPI0_R_DIO_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[0]);
 326             REG_SET_FIELD(SPI_USER2_REG(0), SPI_USR_COMMAND_VALUE, 0xBB);
 327         } else if ((modebit & SPI_FREAD_DUAL)) {
 328             REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_DUMMY_CYCLELEN, SPI0_R_FAST_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[0]);
 329             REG_SET_FIELD(SPI_USER2_REG(0), SPI_USR_COMMAND_VALUE, 0x3B);
 330         } else {
 331             REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_DUMMY_CYCLELEN, SPI0_R_FAST_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[0]);
 332             REG_SET_FIELD(SPI_USER2_REG(0), SPI_USR_COMMAND_VALUE, 0x0B);
 333         }
 334     } else {
 335         REG_CLR_BIT(SPI_USER_REG(0), SPI_USR_MOSI);
 336         if (g_rom_spiflash_dummy_len_plus[0] == 0) {
 337             REG_CLR_BIT(SPI_USER_REG(0), SPI_USR_DUMMY);
 338         } else {
 339             REG_SET_BIT(SPI_USER_REG(0), SPI_USR_DUMMY);
 340             REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_DUMMY_CYCLELEN, g_rom_spiflash_dummy_len_plus[0] - 1);
 341         }
 342         REG_SET_BIT(SPI_USER_REG(0), SPI_USR_MISO | SPI_USR_ADDR);
 343         REG_SET_FIELD(SPI_USER1_REG(0), SPI_USR_ADDR_BITLEN, SPI0_R_SIO_ADDR_BITSLEN);
 344         REG_SET_FIELD(SPI_USER2_REG(0), SPI_USR_COMMAND_VALUE, 0x03);
 345     }
 346
 347 }
 348
 349 esp_rom_spiflash_result_t esp_rom_spiflash_lock()
 350 {
 351     uint32_t status;
 352
 353     //read QE bit, not write if not QE
 354     if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_read_statushigh(&g_rom_spiflash_chip, &status)) {
 355         return ESP_ROM_SPIFLASH_RESULT_ERR;
 356     }
 357     //enable 2 byte status writing
 358     SET_PERI_REG_MASK(PERIPHS_SPI_FLASH_CTRL, ESP_ROM_SPIFLASH_TWO_BYTE_STATUS_EN);
 359
 360     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_enable_write(&g_rom_spiflash_chip)) {
 361         return ESP_ROM_SPIFLASH_RESULT_ERR;
 362     }
 363
 364     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_write_status(&g_rom_spiflash_chip, status | ESP_ROM_SPIFLASH_WR_PROTECT)) {
 365         return ESP_ROM_SPIFLASH_RESULT_ERR;
 366     }
 367
 368     return ESP_ROM_SPIFLASH_RESULT_OK;
 369 }
 370
 371
 372 esp_rom_spiflash_result_t esp_rom_spiflash_config_readmode(esp_rom_spiflash_read_mode_t mode)
 373 {
 374     uint32_t  modebit;
 375
 376     while ((REG_READ(SPI_EXT2_REG(1)) & SPI_ST)) {
 377     }
 378     while ((REG_READ(SPI_EXT2_REG(0)) & SPI_ST)) {
 379     }
 380     //clear old mode bit
 381     CLEAR_PERI_REG_MASK(PERIPHS_SPI_FLASH_CTRL, SPI_FREAD_QIO | SPI_FREAD_QUAD | SPI_FREAD_DIO | SPI_FREAD_DUAL | SPI_FASTRD_MODE);
 382     CLEAR_PERI_REG_MASK(SPI_CTRL_REG(0), SPI_FREAD_QIO | SPI_FREAD_QUAD | SPI_FREAD_DIO | SPI_FREAD_DUAL | SPI_FASTRD_MODE);
 383     //configure read mode
 384     switch (mode) {
 385     case ESP_ROM_SPIFLASH_QIO_MODE   :  modebit = SPI_FREAD_QIO  | SPI_FASTRD_MODE; break;
 386     case ESP_ROM_SPIFLASH_QOUT_MODE  :  modebit = SPI_FREAD_QUAD | SPI_FASTRD_MODE; break;
 387     case ESP_ROM_SPIFLASH_DIO_MODE   :  modebit = SPI_FREAD_DIO  | SPI_FASTRD_MODE; break;
 388     case ESP_ROM_SPIFLASH_DOUT_MODE  :  modebit = SPI_FREAD_DUAL | SPI_FASTRD_MODE; break;
 389     case ESP_ROM_SPIFLASH_FASTRD_MODE:  modebit = SPI_FASTRD_MODE; break;
 390     case ESP_ROM_SPIFLASH_SLOWRD_MODE:  modebit = 0; break;
 391     default : modebit = 0;
 392     }
 393
 394     SET_PERI_REG_MASK(PERIPHS_SPI_FLASH_CTRL, modebit);
 395     SET_PERI_REG_MASK(SPI_CTRL_REG(0), modebit);
 396     spi_cache_mode_switch(modebit);
 397
 398     return  ESP_ROM_SPIFLASH_RESULT_OK;
 399 }
 400
 401 esp_rom_spiflash_result_t esp_rom_spiflash_erase_chip()
 402 {
 403     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_enable_write(&g_rom_spiflash_chip)) {
 404         return ESP_ROM_SPIFLASH_RESULT_ERR;
 405     }
 406
 407     if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_erase_chip_internal(&g_rom_spiflash_chip)) {
 408         return ESP_ROM_SPIFLASH_RESULT_ERR;
 409     }
 410
 411     return ESP_ROM_SPIFLASH_RESULT_OK;
 412 }
 413
 414 esp_rom_spiflash_result_t esp_rom_spiflash_erase_block(uint32_t block_num)
 415 {
 416     // flash write is always 1 line currently
 417     REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 418     REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, ESP_ROM_SPIFLASH_W_SIO_ADDR_BITSLEN);
 419
 420     //check program size
 421     if (block_num >= ((g_rom_spiflash_chip.chip_size) / (g_rom_spiflash_chip.block_size))) {
 422         return ESP_ROM_SPIFLASH_RESULT_ERR;
 423     }
 424
 425     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_enable_write(&g_rom_spiflash_chip)) {
 426         return ESP_ROM_SPIFLASH_RESULT_ERR;
 427     }
 428
 429     if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_erase_block_internal(&g_rom_spiflash_chip, block_num * (g_rom_spiflash_chip.block_size))) {
 430         return ESP_ROM_SPIFLASH_RESULT_ERR;
 431     }
 432     return ESP_ROM_SPIFLASH_RESULT_OK;
 433 }
 434
 435 esp_rom_spiflash_result_t esp_rom_spiflash_erase_sector(uint32_t sector_num)
 436 {
 437     // flash write is always 1 line currently
 438     REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 439     REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, ESP_ROM_SPIFLASH_W_SIO_ADDR_BITSLEN);
 440
 441     //check program size
 442     if (sector_num >= ((g_rom_spiflash_chip.chip_size) / (g_rom_spiflash_chip.sector_size))) {
 443         return ESP_ROM_SPIFLASH_RESULT_ERR;
 444     }
 445
 446     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_enable_write(&g_rom_spiflash_chip)) {
 447         return ESP_ROM_SPIFLASH_RESULT_ERR;
 448     }
 449
 450     if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_erase_sector_internal(&g_rom_spiflash_chip, sector_num * (g_rom_spiflash_chip.sector_size))) {
 451         return ESP_ROM_SPIFLASH_RESULT_ERR;
 452     }
 453
 454     return ESP_ROM_SPIFLASH_RESULT_OK;
 455 }
 456
 457 esp_rom_spiflash_result_t esp_rom_spiflash_write(uint32_t target, const uint32_t *src_addr, int32_t len)
 458 {
 459     uint32_t  page_size;
 460     uint32_t  pgm_len, pgm_num;
 461     uint8_t    i;
 462
 463     // flash write is always 1 line currently
 464     REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 465     REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, ESP_ROM_SPIFLASH_W_SIO_ADDR_BITSLEN);
 466
 467     //check program size
 468     if ( (target + len) > (g_rom_spiflash_chip.chip_size)) {
 469         return ESP_ROM_SPIFLASH_RESULT_ERR;
 470     }
 471
 472     page_size = g_rom_spiflash_chip.page_size;
 473     pgm_len = page_size - (target % page_size);
 474     if (len < pgm_len) {
 475         if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_program_page_internal(&g_rom_spiflash_chip,
 476                 target, (uint32_t *)src_addr, len)) {
 477             return ESP_ROM_SPIFLASH_RESULT_ERR;
 478         }
 479     } else {
 480         if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_program_page_internal(&g_rom_spiflash_chip,
 481                 target, (uint32_t *)src_addr, pgm_len)) {
 482             return ESP_ROM_SPIFLASH_RESULT_ERR;
 483         }
 484
 485         //whole page program
 486         pgm_num = (len - pgm_len) / page_size;
 487         for (i = 0; i < pgm_num; i++) {
 488             if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_program_page_internal(&g_rom_spiflash_chip,
 489                     target + pgm_len, (uint32_t *)src_addr + (pgm_len >> 2), page_size)) {
 490                 return ESP_ROM_SPIFLASH_RESULT_ERR;
 491             }
 492             pgm_len += page_size;
 493         }
 494
 495         //remain parts to program
 496         if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_program_page_internal(&g_rom_spiflash_chip,
 497                 target + pgm_len, (uint32_t *)src_addr + (pgm_len >> 2), len - pgm_len)) {
 498             return ESP_ROM_SPIFLASH_RESULT_ERR;
 499         }
 500     }
 501     return  ESP_ROM_SPIFLASH_RESULT_OK;
 502 }
 503
 504 esp_rom_spiflash_result_t esp_rom_spiflash_write_encrypted(uint32_t flash_addr, uint32_t *data, uint32_t len)
 505 {
 506     esp_rom_spiflash_result_t ret = ESP_ROM_SPIFLASH_RESULT_OK;
 507     uint32_t i;
 508
 509     if ((flash_addr & 0x1f) || (len & 0x1f)) {  //check 32 byte alignment
 510         return ESP_ROM_SPIFLASH_RESULT_ERR;
 511     }
 512
 513     esp_rom_spiflash_write_encrypted_enable();
 514
 515     for (i = 0; i < (len >> 5); i++) {
 516         if ((ret = esp_rom_spiflash_prepare_encrypted_data(flash_addr + (i << 5), data + (i << 3))) != ESP_ROM_SPIFLASH_RESULT_OK) {
 517             break;
 518         }
 519
 520         if ((ret = esp_rom_spiflash_write(flash_addr + (i << 5), data, 32)) != ESP_ROM_SPIFLASH_RESULT_OK) {
 521             break;
 522         }
 523     }
 524
 525     esp_rom_spiflash_write_encrypted_disable();
 526
 527     return ret;
 528 }
 529
 530
 531 esp_rom_spiflash_result_t esp_rom_spiflash_read(uint32_t target, uint32_t *dest_addr, int32_t len)
 532 {
 533     // QIO or SIO, non-QIO regard as SIO
 534     uint32_t modebit;
 535     modebit = READ_PERI_REG(PERIPHS_SPI_FLASH_CTRL);
 536     if ((modebit & SPI_FREAD_QIO) && (modebit & SPI_FASTRD_MODE)) {
 537         REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_MOSI);
 538         REG_SET_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_MISO | SPI_USR_DUMMY | SPI_USR_ADDR);
 539         REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, SPI1_R_QIO_ADDR_BITSLEN);
 540         REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_DUMMY_CYCLELEN, SPI1_R_QIO_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[1]);
 541         //REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG2, SPI_USR_COMMAND_VALUE, 0xEB);
 542         REG_WRITE(PERIPHS_SPI_FLASH_USRREG2, (0x7 << SPI_USR_COMMAND_BITLEN_S) | 0xEB);
 543     } else if (modebit & SPI_FASTRD_MODE) {
 544         REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_MOSI);
 545         REG_SET_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_MISO | SPI_USR_ADDR);
 546         if (modebit & SPI_FREAD_DIO) {
 547             if (g_rom_spiflash_dummy_len_plus[1] == 0) {
 548                 REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 549                 REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, SPI1_R_DIO_ADDR_BITSLEN);
 550                 REG_WRITE(PERIPHS_SPI_FLASH_USRREG2, (0x7 << SPI_USR_COMMAND_BITLEN_S) | 0xBB);
 551             } else {
 552                 REG_SET_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 553                 REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, SPI1_R_DIO_ADDR_BITSLEN);
 554                 REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_DUMMY_CYCLELEN, g_rom_spiflash_dummy_len_plus[1] - 1);
 555                 REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG2, SPI_USR_COMMAND_VALUE, 0xBB);
 556             }
 557         } else {
 558             if ((modebit & SPI_FREAD_QUAD)) {
 559                 //REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG2, SPI_USR_COMMAND_VALUE, 0x6B);
 560                 REG_WRITE(PERIPHS_SPI_FLASH_USRREG2, (0x7 << SPI_USR_COMMAND_BITLEN_S) | 0x6B);
 561             } else if ((modebit & SPI_FREAD_DUAL)) {
 562                 //REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG2, SPI_USR_COMMAND_VALUE, 0x3B);
 563                 REG_WRITE(PERIPHS_SPI_FLASH_USRREG2, (0x7 << SPI_USR_COMMAND_BITLEN_S) | 0x3B);
 564             } else {
 565                 //REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG2, SPI_USR_COMMAND_VALUE, 0x0B);
 566                 REG_WRITE(PERIPHS_SPI_FLASH_USRREG2, (0x7 << SPI_USR_COMMAND_BITLEN_S) | 0x0B);
 567             }
 568             REG_SET_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 569             REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, SPI1_R_FAST_ADDR_BITSLEN);
 570             REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_DUMMY_CYCLELEN, SPI1_R_FAST_DUMMY_CYCLELEN + g_rom_spiflash_dummy_len_plus[1]);
 571         }
 572     } else {
 573         REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_MOSI);
 574         if (g_rom_spiflash_dummy_len_plus[1] == 0) {
 575             REG_CLR_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 576         } else {
 577             REG_SET_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_DUMMY);
 578             REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_DUMMY_CYCLELEN,  g_rom_spiflash_dummy_len_plus[1] - 1);
 579         }
 580         REG_SET_BIT(PERIPHS_SPI_FLASH_USRREG, SPI_USR_MISO | SPI_USR_ADDR);
 581         REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG1, SPI_USR_ADDR_BITLEN, SPI1_R_SIO_ADDR_BITSLEN);
 582         //REG_SET_FIELD(PERIPHS_SPI_FLASH_USRREG2, SPI_USR_COMMAND_VALUE, 0x03);
 583         REG_WRITE(PERIPHS_SPI_FLASH_USRREG2, (0x7 << SPI_USR_COMMAND_BITLEN_S) | 0x03);
 584     }
 585
 586     if ( ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_read_data(&g_rom_spiflash_chip, target, dest_addr, len)) {
 587         return ESP_ROM_SPIFLASH_RESULT_ERR;
 588     }
 589     return ESP_ROM_SPIFLASH_RESULT_OK;
 590 }
 591
 592 esp_rom_spiflash_result_t esp_rom_spiflash_erase_area(uint32_t start_addr, uint32_t area_len)
 593 {
 594     int32_t total_sector_num;
 595     int32_t head_sector_num;
 596     uint32_t sector_no;
 597     uint32_t sector_num_per_block;
 598
 599     //set read mode to Fastmode ,not QDIO mode for erase
 600     //
 601     // TODO: this is probably a bug as it doesn't re-enable QIO mode, not serious as this
 602     // function is not used in IDF.
 603     esp_rom_spiflash_config_readmode(ESP_ROM_SPIFLASH_SLOWRD_MODE);
 604
 605     //check if area is oversize of flash
 606     if ((start_addr + area_len) > g_rom_spiflash_chip.chip_size) {
 607         return ESP_ROM_SPIFLASH_RESULT_ERR;
 608     }
 609
 610     //start_addr is aligned as sector boundary
 611     if (0 != (start_addr % g_rom_spiflash_chip.sector_size)) {
 612         return ESP_ROM_SPIFLASH_RESULT_ERR;
 613     }
 614
 615     //Unlock flash to enable erase
 616     if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_unlock(/*&g_rom_spiflash_chip*/)) {
 617         return ESP_ROM_SPIFLASH_RESULT_ERR;
 618     }
 619
 620     sector_no = start_addr / g_rom_spiflash_chip.sector_size;
 621     sector_num_per_block = g_rom_spiflash_chip.block_size / g_rom_spiflash_chip.sector_size;
 622     total_sector_num = (0 == (area_len % g_rom_spiflash_chip.sector_size)) ? area_len / g_rom_spiflash_chip.sector_size :
 623                        1 + (area_len / g_rom_spiflash_chip.sector_size);
 624
 625     //check if erase area reach over block boundary
 626     head_sector_num = sector_num_per_block - (sector_no % sector_num_per_block);
 627
 628     head_sector_num = (head_sector_num >= total_sector_num) ? total_sector_num : head_sector_num;
 629
 630     //JJJ, BUG of 6.0 erase
 631     //middle part of area is aligned by blocks
 632     total_sector_num -= head_sector_num;
 633
 634     //head part of area is erased
 635     while (0 != head_sector_num) {
 636         if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_erase_sector(sector_no)) {
 637             return ESP_ROM_SPIFLASH_RESULT_ERR;
 638         }
 639         sector_no++;
 640         head_sector_num--;
 641     }
 642     while (total_sector_num > sector_num_per_block) {
 643         if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_erase_block(sector_no / sector_num_per_block)) {
 644             return ESP_ROM_SPIFLASH_RESULT_ERR;
 645         }
 646         sector_no += sector_num_per_block;
 647         total_sector_num -= sector_num_per_block;
 648     }
 649
 650     //tail part of area burn
 651     while (0 < total_sector_num) {
 652         if (ESP_ROM_SPIFLASH_RESULT_OK != esp_rom_spiflash_erase_sector(sector_no)) {
 653             return ESP_ROM_SPIFLASH_RESULT_ERR;
 654         }
 655         sector_no++;
 656         total_sector_num--;
 657     }
 658
 659     return ESP_ROM_SPIFLASH_RESULT_OK;
 660 }
 661
 662 #endif