rt-thread/bsp/efm32/dev_sflash.c

414 lines
9.8 KiB
C

/******************************************************************//**
* @file dev_sflash.c
* @brief SPI Flash driver of RT-Thread RTOS for using EFM32 USART module.
* This driver is tested by using the M25PX16 device on the EFM32 development
* kit.
* COPYRIGHT (C) 2011, RT-Thread Development Team
* @author onelife
* @version 0.4 beta
**********************************************************************
* @section License
* The license and distribution terms for this file may be found in the file LICENSE in this
* distribution or at http://www.rt-thread.org/license/LICENSE
**********************************************************************
* @section Change Logs
* Date Author Notes
* 2011-05-06 onelife Initial creation for using EFM32 USART module
*********************************************************************/
/******************************************************************//**
* @addtogroup efm32_dk
* @{
*********************************************************************/
/* Includes -------------------------------------------------------------------*/
#include "board.h"
#include "drv_usart.h"
#include "dev_sflash.h"
#if defined(EFM32_USING_SFLASH)
/* Private typedef -------------------------------------------------------------*/
typedef struct
{
rt_uint8_t code;
rt_uint32_t address:24;
rt_uint32_t dummy:8;
} sflash_instruction;
/* Private define --------------------------------------------------------------*/
/* Private macro --------------------------------------------------------------*/
#ifdef EFM32_SFLASH_DEBUG
#define sflash_debug(format,args...) rt_kprintf(format, ##args)
#else
#define sflash_debug(format,args...)
#endif
/* Private constants -----------------------------------------------------------*/
static rt_uint8_t sflash_inst_code_tbl[] =
{
/* Instruction only */
SFLASH_INST_CODE_WREN,
SFLASH_INST_CODE_WRDI,
SFLASH_INST_CODE_RDID_L,
SFLASH_INST_CODE_RDID_S,
SFLASH_INST_CODE_RDSR,
SFLASH_INST_CODE_WRSR,
SFLASH_INST_CODE_BE,
SFLASH_INST_CODE_DP,
SFLASH_INST_CODE_RDP,
/* Instruction and address */
SFLASH_INST_CODE_WRLR,
SFLASH_INST_CODE_RDLR,
SFLASH_INST_CODE_READ,
SFLASH_INST_CODE_POTP,
SFLASH_INST_CODE_PP,
SFLASH_INST_CODE_DIFP,
SFLASH_INST_CODE_SSE,
SFLASH_INST_CODE_SE,
/* Instruction, address and dummy read */
SFLASH_INST_CODE_READ_F,
SFLASH_INST_CODE_DOFR,
SFLASH_INST_CODE_ROTP
};
static rt_uint16_t sflash_data_len_tbl[] =
{
/* Instruction only */
SFLASH_REPLY_LEN_WREN,
SFLASH_REPLY_LEN_WRDI,
SFLASH_REPLY_LEN_RDID_L,
SFLASH_REPLY_LEN_RDID_S,
SFLASH_REPLY_LEN_RDSR,
SFLASH_REPLY_LEN_WRSR,
SFLASH_REPLY_LEN_BE,
SFLASH_REPLY_LEN_DP,
SFLASH_REPLY_LEN_RDP,
/* Instruction and address */
SFLASH_REPLY_LEN_WRLR,
SFLASH_REPLY_LEN_RDLR,
SFLASH_REPLY_LEN_READ,
SFLASH_REPLY_LEN_POTP,
SFLASH_REPLY_LEN_PP,
SFLASH_REPLY_LEN_DIFP,
SFLASH_REPLY_LEN_SSE,
SFLASH_REPLY_LEN_SE,
/* Instruction, address and dummy read */
SFLASH_REPLY_LEN_READ_F,
SFLASH_REPLY_LEN_DOFR,
SFLASH_REPLY_LEN_ROTP
};
static rt_bool_t sflash_read_inst_tbl[] =
{
/* Instruction only */
false,
false,
true,
true,
true,
false,
false,
false,
false,
/* Instruction and address */
false,
true,
true,
false,
false,
false,
false,
false,
/* Instruction, address and dummy read */
true,
true,
true
};
/* Private variables ------------------------------------------------------------*/
static rt_device_t sFlash = RT_NULL;
static rt_bool_t sFlashAutoCs = true;
/* Private function prototypes ---------------------------------------------------*/
/* Private functions ------------------------------------------------------------*/
/******************************************************************//**
* @brief
* Initialize the SPI Flash
*
* @details
*
* @note
*
* @return
* Error code
*********************************************************************/
rt_err_t efm_spiFlash_init(void)
{
struct efm32_usart_device_t *usart;
usart = (struct efm32_usart_device_t *)(sFlash->user_data);
#if defined(EFM32_G290_DK)
/* Enable SPI access to Flash */
DVK_writeRegister(BC_SPI_CFG, 0);
#endif
do
{
/* Find SPI device */
sFlash = rt_device_find(SFLASH_USING_DEVICE_NAME);
if (sFlash == RT_NULL)
{
sflash_debug("SFLASH: Can't find device %s!\n",
SFLASH_USING_DEVICE_NAME);
break;
}
sflash_debug("SFLASH: Find device %s\n", SFLASH_USING_DEVICE_NAME);
/* Config chip slect pin */
if (!(usart->state & USART_STATE_AUTOCS))
{
GPIO_PinModeSet(SFLASH_CS_PORT, SFLASH_CS_PIN, gpioModePushPull, 1);
sFlashAutoCs = false;
}
/* Open SPI device */
if (sFlash->open(sFlash, RT_DEVICE_OFLAG_RDWR) != RT_EOK)
{
break;
}
return RT_EOK;
} while(0);
sflash_debug("SFLASH: Init failed!\n");
return -RT_ERROR;
}
/******************************************************************//**
* @brief
* De-initialize the SPI Flash
*
* @details
*
* @note
*
* @return
* Error code
*********************************************************************/
rt_err_t efm_spiFlash_deinit(void)
{
do
{
if (sFlash == RT_NULL)
{
sflash_debug("SFLASH: Already deinit!\n");
break;
}
/* Close SPI device */
if (sFlash->close(sFlash) != RT_EOK)
{
break;
}
sFlash = RT_NULL;
sflash_debug("SFLASH: Close device %s\n", SFLASH_USING_DEVICE_NAME);
return RT_EOK;
} while(0);
sflash_debug("SFLASH: Deinit failed!\n");
return -RT_ERROR;
}
/******************************************************************//**
* @brief
* Set/Clear chip select
*
* @details
*
* @note
*
* @param[in] enable
* Chip select pin setting
*********************************************************************/
static void efm_spiFlash_cs(rt_uint8_t enable)
{
if (!sFlashAutoCs)
{
if (enable)
{
GPIO_PinOutClear(SFLASH_CS_PORT, SFLASH_CS_PIN);
}
else
{
GPIO_PinOutSet(SFLASH_CS_PORT, SFLASH_CS_PIN);
}
}
}
/******************************************************************//**
* @brief
* Execute a command
*
* @details
*
* @note
*
* @param[in] command
* SPI Flash instruction
*
* @param[in] address
* Memory address
*
* @param[in] buffer
* Poniter to the read/write buffer
*
* @param[in] size
* Buffer size in byte
*
* @return
* Number of read/written bytes
*********************************************************************/
rt_uint32_t efm_spiFlash_cmd(
enum sflash_inst_type_t command,
rt_uint32_t address,
rt_uint8_t *buffer,
rt_uint32_t size)
{
RT_ASSERT(sFlash != RT_NULL);
sflash_instruction *inst;
rt_uint8_t *inst_buf;
rt_uint8_t inst_len, head_len;
rt_uint32_t data_len;
sflash_debug("SFLASH: Inst %x\n", sflash_inst_code_tbl[command]);
if (sflash_data_len_tbl[command] && !size)
{
sflash_debug("SFLASH: No data!\n");
return 0x00;
}
data_len = (sflash_data_len_tbl[command] < size)? \
sflash_data_len_tbl[command] : size;
if (data_len && (buffer == RT_NULL))
{
sflash_debug("SFLASH: No buffer specified!\n");
return 0x00;
}
/* Allocate memory for write buffer */
if (sflash_read_inst_tbl[command])
{
inst_buf = rt_malloc(6 + 4);
inst = (sflash_instruction *)(inst_buf + 1);
head_len = 1;
}
else
{
inst_buf = rt_malloc(5 + data_len);
inst = (sflash_instruction *)inst_buf;
head_len = 0;
}
/* Fill in instruction */
inst->code = sflash_inst_code_tbl[command];
if (command >= sflash_inst_wrlr)
{
/* MSB first */
inst->address = ((address & 0x000000FF) << 16) | \
(address & 0x0000FF00) | \
((address & 0x00FF0000) >> 16);
if (command >= sflash_inst_read_f)
{
inst->dummy = 0x00;
inst_len = 5;
}
else
{
inst_len = 4;
}
}
else
{
inst_len = 1;
}
head_len += inst_len;
/* Fill in data and send the buffer */
if (sflash_read_inst_tbl[command])
{
rt_off_t skip;
inst_buf[0] = inst_len;
*(rt_uint8_t **)(inst_buf + head_len) = buffer;
if (command == sflash_inst_read)
{
skip = SFLASH_SPI_READ_SKIP;
}
else
{
skip = SFLASH_SPI_COMMAND_SKIP;
}
efm_spiFlash_cs(1);
if (sFlash->read(sFlash, skip, inst_buf, \
(data_len == size)? data_len - 1 : data_len) == 0)
{
sflash_debug("SFLASH: Read failed!\n");
return 0x00;
}
efm_spiFlash_cs(0);
buffer[data_len] = 0x00;
sflash_debug("SFLASH: Read %d bytes data to 0x%x\n", data_len, buffer);
}
else
{
if (data_len)
{
rt_memcpy((inst_buf + head_len), buffer, data_len);
}
efm_spiFlash_cs(1);
if (sFlash->write(sFlash, EFM32_NO_DATA, inst_buf, \
head_len + data_len) == 0)
{
sflash_debug("SFLASH: Write failed!\n");
return 0x00;
}
efm_spiFlash_cs(0);
sflash_debug("SFLASH: Write %d/%d bytes data\n", data_len, \
head_len + data_len);
}
/* Free the buffer */
rt_free(inst_buf);
return data_len;
}
/*********************************************************************
* Export to FINSH
*********************************************************************/
#ifdef RT_USING_FINSH
#include <finsh.h>
void list_sflash(void)
{
rt_uint8_t buf[4];
efm_spiFlash_cmd(sflash_inst_rdid_s, EFM32_NO_DATA, buf, sizeof(buf));
rt_kprintf(" spi flash on %s\n", SFLASH_USING_DEVICE_NAME);
rt_kprintf(" ------------------------------\n");
rt_kprintf(" Manufacturer ID:\t%x\n", buf[0]);
rt_kprintf(" Memory type:\t\t%x\n", buf[1]);
rt_kprintf(" Memory capacity:\t%x\n", buf[2]);
}
FINSH_FUNCTION_EXPORT(list_sflash, list the SPI Flash.)
#endif
#endif /* defined(EFM32_USING_SFLASH) */
/******************************************************************//**
* @}
*********************************************************************/