esp-idf/components/spi_flash/spi_flash_chip_mxic_opi.c

421 lines
15 KiB
C
Raw Normal View History

// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <stdlib.h>
#include "spi_flash_chip_generic.h"
#include "spi_flash_defs.h"
#include "esp_log.h"
#include "string.h"
#include <sys/param.h> // For MIN/MAX
#include "hal/spi_flash_hal.h"
#define CMD_OPI_FLASH_MXIC(cmd) ((((~(cmd) & 0xff) << 8)) | ((cmd) & 0xff))
#define CMD_OPI_FLASH_MXIC_CHIP_ERASE 0x9F60
#define CMD_OPI_FLASH_MXIC_READ_STR 0x13EC
#define CMD_OPI_FLASH_MXIC_READ_DTR 0x11EE
#define CMD_OPI_FLASH_MXIC_RDCR2 0x8E71
#define CMD_OPI_FLASH_MXIC_WRCR2 0x8D72
/* Driver for MXIC OPI flash chip */
static const char chip_name[] = "mxic (opi)";
esp_err_t spi_flash_chip_mxic_opi_probe(esp_flash_t *chip, uint32_t flash_id)
{
/* Check manufacturer and product IDs match our desired masks */
const uint8_t MFG_ID = 0xC2;
if (flash_id >> 16 != MFG_ID) {
return ESP_ERR_NOT_FOUND;
}
if (chip->read_mode < SPI_FLASH_OPI_FLAG) {
// The code here serve for opi flash under opi mode only, for ordinary mxic chip, go `spi_flash_chip_mxic.c`
return ESP_ERR_NOT_FOUND;
}
return ESP_OK;
}
spi_flash_caps_t spi_flash_chip_mxic_opi_get_caps(esp_flash_t *chip)
{
spi_flash_caps_t caps_flags = 0;
caps_flags |= SPI_FLASH_CHIP_CAP_32MB_SUPPORT;
// flash-suspend is not supported yet. // IDF-3852
// reading unique id is not supported.
return caps_flags;
}
esp_err_t spi_flash_chip_mxic_opi_set_write_protect(esp_flash_t *chip, bool write_protect)
{
esp_err_t err = ESP_OK;
err = chip->chip_drv->wait_idle(chip, chip->chip_drv->timeout->idle_timeout);
spi_flash_trans_t t = {};
if (err == ESP_OK || err == ESP_ERR_NOT_SUPPORTED) {
if(write_protect) {
t.command = CMD_OPI_FLASH_MXIC(CMD_WRDI);
} else {
t.command = CMD_OPI_FLASH_MXIC(CMD_WREN);
}
err = chip->host->driver->common_command(chip->host, &t);
}
bool wp_read;
err = chip->chip_drv->get_chip_write_protect(chip, &wp_read);
if (err == ESP_OK && wp_read != write_protect) {
err = ESP_ERR_NOT_FOUND;
}
return err;
}
static void spi_flash_chip_mxic_opi_get_data_length_zoom(esp_flash_io_mode_t io_mode, uint32_t *length_zoom)
{
/* Under STR mode, one byte occupies one single clock. While under DTR mode, one byte occupies half clock.
For exmaple, if an operation needs 3 clock dummy, host send 3 dummy bytes under STR mode, while 6 dummy bytes under DTR mode.
Therefore, we need to adjust data zoom to fit the clock here. */
assert((io_mode == SPI_FLASH_OPI_STR) || (io_mode == SPI_FLASH_OPI_DTR));
*length_zoom = (io_mode == SPI_FLASH_OPI_STR) ? 1 : 2;
}
esp_err_t spi_flash_chip_mxic_opi_read_id(esp_flash_t *chip, uint32_t* out_chip_id)
{
uint64_t id_buf = 0;
uint32_t length_zoom;
spi_flash_chip_mxic_opi_get_data_length_zoom(chip->read_mode, &length_zoom);
spi_flash_trans_t t = {
.command = CMD_OPI_FLASH_MXIC(CMD_RDID),
.miso_len = 3 * length_zoom,
.dummy_bitlen = 4 * length_zoom,
.address_bitlen = 32,
.miso_data = ((uint8_t*) &id_buf),
};
chip->host->driver->common_command(chip->host, &t);
if(chip->read_mode == SPI_FLASH_OPI_DTR) {
// Adjust the id_buf in DTR mode, because in DTR mode, the data back in STR rule.
// So it looks like [MD, MD, MT, MT, MID, MID], adjust it to [MD, MT, MID] here.
ESP_EARLY_LOGV(chip_name, "raw_chip_id: %llx\n", id_buf);
id_buf = (id_buf & 0xff) | ((id_buf & 0xff0000) >> 8) | ((id_buf & 0xff00000000) >> 16);
} else {
ESP_EARLY_LOGV(chip_name, "raw_chip_id: %X\n", id_buf);
}
uint32_t raw_flash_id = __builtin_bswap32(id_buf);
if (raw_flash_id == 0xFFFFFF || raw_flash_id == 0) {
ESP_EARLY_LOGE(chip_name, "no response\n");
return ESP_ERR_FLASH_NO_RESPONSE;
}
*out_chip_id = (raw_flash_id >> 8);
ESP_EARLY_LOGV(chip_name, "chip_id: %X\n", *out_chip_id);
return ESP_OK;
}
esp_err_t spi_flash_chip_mxic_opi_read_reg(esp_flash_t *chip, spi_flash_register_t reg_id, uint32_t* out_reg)
{
uint32_t stat_buf = 0;
uint32_t length_zoom;
spi_flash_chip_mxic_opi_get_data_length_zoom(chip->read_mode, &length_zoom);
spi_flash_trans_t t = {
.command = CMD_OPI_FLASH_MXIC(CMD_RDSR),
.miso_data = ((uint8_t*) &stat_buf),
.miso_len = 1 * length_zoom,
.address_bitlen = 32,
.dummy_bitlen = 4 * length_zoom,
};
esp_err_t err = chip->host->driver->common_command(chip->host, &t);
if (err != ESP_OK) {
return err;
}
// For DTR mode, RDSR result like [SR1, SR1], just keeping one SR1.
*out_reg = (stat_buf & 0xff);
return ESP_OK;
}
esp_err_t spi_flash_chip_mxic_opi_get_write_protect(esp_flash_t *chip, bool *out_write_protected)
{
esp_err_t err = ESP_OK;
uint32_t status;
assert(out_write_protected!=NULL);
err = chip->chip_drv->read_reg(chip, SPI_FLASH_REG_STATUS, &status);
if (err != ESP_OK) {
return err;
}
*out_write_protected = ((status & SR_WREN) == 0);
return err;
}
esp_err_t spi_flash_chip_mxic_opi_erase_chip(esp_flash_t *chip)
{
esp_err_t err;
err = chip->chip_drv->set_chip_write_protect(chip, false);
if (err == ESP_OK) {
err = chip->chip_drv->wait_idle(chip, chip->chip_drv->timeout->idle_timeout);
}
if (err == ESP_OK || err == ESP_ERR_NOT_SUPPORTED) {
// Do erase chip here.
spi_flash_trans_t t = {
.command = CMD_OPI_FLASH_MXIC_CHIP_ERASE,
};
err = chip->host->driver->common_command(chip->host, &t);
chip->busy = 1;
#ifdef CONFIG_SPI_FLASH_CHECK_ERASE_TIMEOUT_DISABLED
err = chip->chip_drv->wait_idle(chip, ESP_FLASH_CHIP_GENERIC_NO_TIMEOUT);
#else
err = chip->chip_drv->wait_idle(chip, chip->chip_drv->timeout->chip_erase_timeout);
#endif
}
// Ensure WEL is 0, even if the erase failed.
if (err == ESP_ERR_NOT_SUPPORTED) {
chip->chip_drv->set_chip_write_protect(chip, true);
}
return err;
}
esp_err_t spi_flash_chip_mxic_opi_erase_sector(esp_flash_t *chip, uint32_t start_address)
{
esp_err_t err = chip->chip_drv->set_chip_write_protect(chip, false);
if (err == ESP_OK) {
err = chip->chip_drv->wait_idle(chip, chip->chip_drv->timeout->idle_timeout);
}
//The chip didn't accept the previous write command. Ignore this in preparationstage.
if (err == ESP_OK || err == ESP_ERR_NOT_SUPPORTED) {
spi_flash_trans_t t = {
.command = CMD_OPI_FLASH_MXIC(CMD_SECTOR_ERASE_4B),
.address_bitlen = 32,
.address = start_address,
};
err = chip->host->driver->common_command(chip->host, &t);
chip->busy = 1;
#ifdef CONFIG_SPI_FLASH_CHECK_ERASE_TIMEOUT_DISABLED
err = chip->chip_drv->wait_idle(chip, ESP_FLASH_CHIP_GENERIC_NO_TIMEOUT);
#else
err = chip->chip_drv->wait_idle(chip, chip->chip_drv->timeout->sector_erase_timeout);
#endif
}
// Ensure WEL is 0, even if the erase failed.
if (err == ESP_ERR_NOT_SUPPORTED) {
err = chip->chip_drv->set_chip_write_protect(chip, true);
}
return err;
}
esp_err_t spi_flash_chip_mxic_opi_erase_block(esp_flash_t *chip, uint32_t start_address)
{
esp_err_t err = chip->chip_drv->set_chip_write_protect(chip, false);
if (err == ESP_OK) {
err = chip->chip_drv->wait_idle(chip, chip->chip_drv->timeout->idle_timeout);
}
//The chip didn't accept the previous write command. Ignore this in preparationstage.
if (err == ESP_OK || err == ESP_ERR_NOT_SUPPORTED) {
spi_flash_trans_t t = {
.command = CMD_OPI_FLASH_MXIC(CMD_LARGE_BLOCK_ERASE_4B),
.address_bitlen = 32,
.address = start_address,
};
err = chip->host->driver->common_command(chip->host, &t);
chip->busy = 1;
#ifdef CONFIG_SPI_FLASH_CHECK_ERASE_TIMEOUT_DISABLED
err = chip->chip_drv->wait_idle(chip, ESP_FLASH_CHIP_GENERIC_NO_TIMEOUT);
#else
err = chip->chip_drv->wait_idle(chip, chip->chip_drv->timeout->block_erase_timeout);
#endif
}
// Ensure WEL is 0, even if the erase failed.
if (err == ESP_ERR_NOT_SUPPORTED) {
err = chip->chip_drv->set_chip_write_protect(chip, true);
}
return err;
}
esp_err_t spi_flash_chip_mxic_opi_page_program(esp_flash_t *chip, const void *buffer, uint32_t address, uint32_t length)
{
esp_err_t err;
err = chip->chip_drv->wait_idle(chip, chip->chip_drv->timeout->idle_timeout);
//The chip didn't accept the previous write command. Ignore this in preparationstage.
if (err == ESP_OK || err == ESP_ERR_NOT_SUPPORTED) {
// Perform the actual Page Program command
spi_flash_trans_t t = {
.command = CMD_OPI_FLASH_MXIC(CMD_PROGRAM_PAGE_4B),
.address_bitlen = 32,
.address = address,
.mosi_len = length,
.mosi_data = buffer,
};
chip->host->driver->common_command(chip->host, &t);
chip->busy = 1;
err = chip->chip_drv->wait_idle(chip, chip->chip_drv->timeout->page_program_timeout);
}
// Ensure WEL is 0, even if the page program failed.
if (err == ESP_ERR_NOT_SUPPORTED) {
err = chip->chip_drv->set_chip_write_protect(chip, true);
}
return err;
}
esp_err_t spi_flash_chip_mxic_opi_write(esp_flash_t *chip, const void *buffer, uint32_t address, uint32_t length)
{
esp_err_t err = ESP_OK;
const uint32_t page_size = chip->chip_drv->page_size;
uint32_t align_address;
uint8_t temp_buffer[64]; //spiflash hal max length of write no longer than 64byte
while (err == ESP_OK && length > 0) {
memset(temp_buffer, 0xFF, sizeof(temp_buffer));
uint32_t page_len = chip->host->driver->write_data_slicer(chip->host, address, length, &align_address, page_size);
uint32_t left_off = address - align_address;
uint32_t write_len = MIN(align_address + page_len, address + length) - address;
memcpy(temp_buffer + left_off, buffer, write_len);
err = chip->chip_drv->set_chip_write_protect(chip, false);
if (err == ESP_OK && length > 0) {
err = chip->chip_drv->program_page(chip, temp_buffer, align_address, page_len);
address += write_len;
buffer = (void *)((intptr_t)buffer + write_len);
length -= write_len;
}
}
// The caller is responsible to do host->driver->flush_cache, because this function may be
// called in small pieces. Frequency call of flush cache will do harm to the performance.
return err;
}
esp_err_t spi_flash_chip_mxic_opi_get_io_mode(esp_flash_t *chip, esp_flash_io_mode_t* out_io_mode)
{
uint32_t stat_buf = 0;
uint32_t length_zoom;
spi_flash_chip_mxic_opi_get_data_length_zoom(chip->read_mode, &length_zoom);
spi_flash_trans_t t = {
.command = CMD_OPI_FLASH_MXIC_RDCR2,
.dummy_bitlen = 4 * length_zoom,
.miso_data = ((uint8_t*) &stat_buf),
.miso_len = 1 * length_zoom,
.address_bitlen = 32,
};
esp_err_t err = chip->host->driver->common_command(chip->host, &t);
if (err != ESP_OK) {
return err;
}
// For DTR mode, RDSR result like [CR1, CR1], just keeping one CR1.
switch (stat_buf & 0xff)
{
case 0x1:
*out_io_mode = SPI_FLASH_OPI_STR;
break;
case 0x2:
*out_io_mode = SPI_FLASH_OPI_DTR;
break;
default:
// wrong mode.
*out_io_mode = 0;
break;
}
if (*out_io_mode != chip->read_mode) {
// Current chip mode is not the mode we configured.
*out_io_mode = 0;
}
return ESP_OK;
}
esp_err_t spi_flash_chip_xmic_opi_set_io_mode(esp_flash_t *chip)
{
// TODO: configure opi flash chip set io mode, only useful for external flash currently.
// For main flash, we already set io mode when chip starts up. But for external flash,
// We need to set mode when flash initialized, so keeping this for future usage.
return ESP_OK;
}
// This function should only be called after opi mode initialization. So, only configure for OPI-STR/OPI-DTR mode
// not support other mode in this file, return `ESP_ERR_FLASH_NOT_INITIALISED` directely.
esp_err_t spi_flash_chip_xmic_opi_config_host_io_mode(esp_flash_t *chip, uint32_t flags)
{
uint32_t dummy_cyclelen_base;
uint32_t addr_bitlen;
uint32_t read_command;
esp_flash_io_mode_t read_mode = chip->read_mode;
switch (read_mode & 0xFFFF) {
case SPI_FLASH_OPI_STR:
addr_bitlen = SPI_FLASH_OPISTR_ADDR_BITLEN;
dummy_cyclelen_base = SPI_FLASH_OPISTR_DUMMY_BITLEN;
read_command = CMD_OPI_FLASH_MXIC_READ_STR;
break;
case SPI_FLASH_OPI_DTR:
addr_bitlen = SPI_FLASH_OPIDTR_ADDR_BITLEN;
dummy_cyclelen_base = SPI_FLASH_OPIDTR_DUMMY_BITLEN;
read_command = CMD_OPI_FLASH_MXIC_READ_DTR;
break;
default:
return ESP_ERR_FLASH_NOT_INITIALISED;
}
return chip->host->driver->configure_host_io_mode(chip->host, read_command, addr_bitlen, dummy_cyclelen_base, read_mode);
}
// Most of mxic opi implementations are totally different from that is generic.
// Replace them to opi implementation.
const spi_flash_chip_t esp_flash_chip_mxic_opi = {
.name = chip_name,
.timeout = &spi_flash_chip_generic_timeout,
.probe = spi_flash_chip_mxic_opi_probe,
.reset = spi_flash_chip_generic_reset,
.detect_size = spi_flash_chip_generic_detect_size,
.erase_chip = spi_flash_chip_mxic_opi_erase_chip,
.erase_sector = spi_flash_chip_mxic_opi_erase_sector,
.erase_block = spi_flash_chip_mxic_opi_erase_block,
.sector_size = 4 * 1024,
.block_erase_size = 64 * 1024,
.get_chip_write_protect = spi_flash_chip_mxic_opi_get_write_protect,
.set_chip_write_protect = spi_flash_chip_mxic_opi_set_write_protect,
.num_protectable_regions = 0,
.protectable_regions = NULL,
.get_protected_regions = NULL,
.set_protected_regions = NULL,
.read = spi_flash_chip_generic_read,
.write = spi_flash_chip_mxic_opi_write,
.program_page = spi_flash_chip_mxic_opi_page_program,
.page_size = 256,
.write_encrypted = spi_flash_chip_generic_write_encrypted,
.wait_idle = spi_flash_chip_generic_wait_idle,
.set_io_mode = spi_flash_chip_xmic_opi_set_io_mode,
.get_io_mode = spi_flash_chip_mxic_opi_get_io_mode,
.read_id = spi_flash_chip_mxic_opi_read_id,
.read_reg = spi_flash_chip_mxic_opi_read_reg,
.yield = spi_flash_chip_generic_yield,
.sus_setup = spi_flash_chip_generic_suspend_cmd_conf,
.read_unique_id = spi_flash_chip_generic_read_unique_id_none,
.get_chip_caps = spi_flash_chip_mxic_opi_get_caps,
.config_host_io_mode = spi_flash_chip_xmic_opi_config_host_io_mode,
};