SFUD
V1.1.0 release
O SFUD é uma biblioteca de driver universal SPI Flash de código aberto. Como existem muitos tipos de flash em série no mercado, as especificações e comandos de cada flash são diferentes. O SFUD foi projetado para resolver as diferenças atuais nesses flashes, permitindo que nossos produtos suportem flash de diferentes marcas e especificações, melhore a reutilização e a escalabilidade do software envolvendo funções flash e, ao mesmo tempo, também pode evitar os riscos trazidos para o produto por meio de estoque ou descontinuação do flash.
/sfud/inc/sfud_flash_def.h ). Se não for suportado, você poderá adicionar as informações do parâmetro desse flash no arquivo de configuração (consulte o flash que atualmente não é suportado na biblioteca de 2.5 para obter detalhes). Após obter as especificações do Flash, todas as operações no Flash podem ser alcançadas. A tabela a seguir mostra todos os flashes que foram testados em tempo real na plataforma de demonstração. O flash que não suporta o padrão SFDP foi definido na tabela de informações do parâmetro flash. Mais flash que não suporta o padrão SFDP precisa ser melhorado e mantido no futuro (Github | Oschina | codificação) .
Se você acha que este projeto de código aberto é ótimo, clique em Star no canto superior direito da página inicial do projeto e recomendá -lo a mais amigos necessitados.
| modelo | Fabricante | capacidade | Velocidade máxima | Padrão SFDP | Modo Qspi | Observação |
|---|---|---|---|---|---|---|
| W25Q40BV | Winbond | 4 MB | 50MHz | Não suportado | Linha dupla | A produção foi descontinuada |
| W25Q80DV | Winbond | 8 MB | 104MHz | apoiar | Linha dupla | |
| W25Q16BV | Winbond | 16 MB | 104MHz | Não suportado | Linha dupla | por SlipperStree |
| W25Q16CV | Winbond | 16 MB | 104MHz | apoiar | Não testado | |
| W25Q16DV | Winbond | 16 MB | 104MHz | apoiar | Não testado | por SlipperStree |
| W25Q32BV | Winbond | 32 MB | 104MHz | apoiar | Linha dupla | |
| W25Q64CV | Winbond | 64 MB | 80MHz | apoiar | Quatro linhas | |
| W25Q128BV | Winbond | 128 MB | 104MHz | apoiar | Quatro linhas | |
| W25Q256FV | Winbond | 256 MB | 104MHz | apoiar | Quatro linhas | |
| MX25L3206E | Macronix | 32 MB | 86MHz | apoiar | Linha dupla | |
| MX25L3233F | Macronix | 32 MB | 133MHz | apoiar | Não testado | por Jiapengli |
| KH25L4006E | Macronix | 4 MB | 86MHz | apoiar | Não testado | por Jiapengli |
| KH25L3206E | Macronix | 32 MB | 86MHz | apoiar | Linha dupla | |
| SST25VF016B | Microchip | 16 MB | 50MHz | Não suportado | Não suportado | SST foi adquirido por microchip |
| M25P40 | Micron | 4 MB | 75MHz | Não suportado | Não testado | por Redoccheng |
| M25P80 | Micron | 8 MB | 75MHz | Não suportado | Não testado | por Redoccheng |
| M25p32 | Micron | 32 MB | 75MHz | Não suportado | Não suportado | |
| En25q32b | Eon | 32 MB | 104MHz | Não suportado | Não testado | |
| GD25Q16B | Gigadevice | 16 MB | 120MHz | Não suportado | Não testado | Por Tanekliang |
| GD25Q32C | Gigadevice | 32 MB | 120MHz | Não suportado | Não testado | por Gaupen1186 |
| GD25Q64B | Gigadevice | 64 MB | 120MHz | Não suportado | Linha dupla | |
| S25FL216K | Cipreste | 16 MB | 65MHz | Não suportado | Linha dupla | |
| S25FL032P | Cipreste | 32 MB | 104MHz | Não suportado | Não testado | por yc_911 |
| S25FL164K | Cipreste | 64 MB | 108MHz | apoiar | Não testado | |
| A25L080 | Amic | 8 MB | 100MHz | Não suportado | Linha dupla | |
| A25LQ64 | Amic | 64 MB | 104MHz | apoiar | apoiar | |
| F25L004 | Esmt | 4 MB | 100MHz | Não suportado | Não suportado | |
| PCT25VF016B | PCT | 16 MB | 80MHz | Não suportado | Não suportado | A licença SST será identificada como SST25VF016B |
| AT45DB161E | ADESTO | 16 MB | 85MHz | Não suportado | Não suportado | Adesto adquire a linha de produtos flash serial atmel |
| NM25Q128EV | Nor_mem | 128 MB | Não testado | Não suportado | Não testado | O SFDP pode ler as informações e identificá -las como mais de 32 GB. |
| P25D40H | Puya | 4 MB | Não testado | apoiar | Não testado | por Shan |
| P25Q80H | Puya | 8 MB | Não testado | apoiar | Não testado | por Shan |
NOTA: No modo QSPI, o fio duplo significa suportar leitura rápida de fios duplos e quatro fios significa suportar leitura rápida de quatro fios.
De um modo geral, o Flash, que suporta leitura rápida de quatro linhas, também suporta leitura rápida de duas linhas.
Vamos primeiro explicar uma estrutura usada principalmente nesta biblioteca sfud_flash . Sua definição está localizada em /sfud/inc/sfud_def.h . Cada flash SPI corresponderá a uma estrutura e o ponteiro da estrutura é referido coletivamente como o objeto do dispositivo flash. Depois que a inicialização for bem-sucedida, os parâmetros comuns do flash SPI serão armazenados na estrutura sfud_flash->chip . Se o SPI Flash também suportar SFDP, você também poderá ver informações mais abrangentes dos parâmetros através sfud_flash->sfdp . Muitas das funções a seguir usarão o objeto do dispositivo flash como o primeiro parâmetro de entrada para implementar operações no flash SPI especificado.
sfud_device_init serão chamados para inicializar todos os dispositivos na tabela de dispositivos flash. Se houver apenas um flash, você poderá usar sfud_device_init apenas para inicialização única.
NOTA : O flash SPI inicializado foi protegido por não padrão. Se você precisar habilitar o Protect Write, use a função SFUD_WRITE_STATUS para modificar o status SPI Flash.
sfud_err sfud_init ( void ) sfud_err sfud_device_init ( sfud_flash * flash )| parâmetro | descrever |
|---|---|
| clarão | Dispositivo flash a ser inicializado |
Quando o SFUD liga o modo Qspi, o driver flash no SFUD suporta comunicação usando o barramento QSPI. Comparado com o modo SPI tradicional, o uso do QSPI pode acelerar a leitura dos dados flash. No entanto, quando os dados precisam ser gravados, a velocidade de escrita de dados do flash é mais lenta que a velocidade de transmissão SPI, portanto a velocidade de escrita de dados no modo QSPI não é significativamente melhorada.
Portanto, o suporte do SFUD ao modo QSPI é limitado a comandos de leitura rápida. Esta função permite configurar a largura máxima de linha de dados real real do barramento QSPI usado pelo Flash, como: 1 linha (padrão, ou seja, modo SPI tradicional), 2 e 4 linhas.
Após a configuração, o SFUD combinará a largura da linha de dados do barramento QSPI atualmente definida para corresponder ao comando de leitura rápido mais adequado e mais rápido na tabela de informações de extensão do QSPI Flash. Depois disso, quando o usuário chama sfud_read (), ele usará a função de transmissão do modo QSPI para enviar o comando.
sfud_err sfud_qspi_fast_read_enable ( sfud_flash * flash , uint8_t data_line_width )| parâmetro | descrever |
|---|---|
| clarão | Dispositivos flash |
| data_line_width | A largura máxima da linha de dados suportada pelo barramento Qspi, como: 1, 2, 4 |
A tabela de dispositivos flash é definida no arquivo de configuração do SFUD, responsável pelo armazenamento de todos os objetos do dispositivo flash a serem usados; portanto, o SFUD suporta vários dispositivos flash a serem acionados simultaneamente. A configuração da tabela de dispositivos é definida na macro SFUD_FLASH_DEVICE_TABLE em /sfud/inc/sfud_cfg.h . Para obter métodos de configuração detalhados, consulte o flash 2.3 do método de configuração). Este método retorna o objeto do dispositivo flash, indexando o dispositivo flash na tabela de dispositivos e retorna NULL além do intervalo da tabela de dispositivos.
sfud_flash * sfud_get_device ( size_t index )| parâmetro | descrever |
|---|---|
| índice | O valor do índice do dispositivo flash localizado na tabela de dispositivos flash |
sfud_err sfud_read ( const sfud_flash * flash , uint32_t addr , size_t size , uint8_t * data )| parâmetro | descrever |
|---|---|
| clarão | Objeto de dispositivo flash |
| addr | Endereço inicial |
| tamanho | O tamanho total dos dados lidos no endereço inicial |
| dados | Leia os dados |
NOTA: A operação de apagamento será alinhada de acordo com a granularidade apagada do chip flash (consulte a folha de dados flash para obter detalhes, geralmente o tamanho do bloco. Após a conclusão da inicialização, você pode visualizá-lo através de
sfud_flash->chip.erase_gran). Cuidado para garantir que o endereço inicial e o tamanho dos dados apagados sejam alinhados de acordo com a granularidade apagada do chip flash. Caso contrário, depois de executar a operação de apagamento, outros dados serão perdidos.
sfud_err sfud_erase ( const sfud_flash * flash , uint32_t addr , size_t size )| parâmetro | descrever |
|---|---|
| clarão | Objeto de dispositivo flash |
| addr | Endereço inicial |
| tamanho | O tamanho total da apagamento dos dados do endereço inicial |
sfud_err sfud_chip_erase ( const sfud_flash * flash )| parâmetro | descrever |
|---|---|
| clarão | Objeto de dispositivo flash |
sfud_err sfud_write ( const sfud_flash * flash , uint32_t addr , size_t size , const uint8_t * data )| parâmetro | descrever |
|---|---|
| clarão | Objeto de dispositivo flash |
| addr | Endereço inicial |
| tamanho | Tamanho total dos dados escritos no endereço inicial |
| dados | Dados a serem escritos |
NOTA: A operação de apagamento será alinhada de acordo com a granularidade apagada do chip flash (consulte a folha de dados flash para obter detalhes, geralmente o tamanho do bloco. Após a conclusão da inicialização, você pode visualizá-lo através de
sfud_flash->chip.erase_gran). Cuidado para garantir que o endereço inicial e o tamanho dos dados apagados sejam alinhados de acordo com a granularidade apagada do chip flash. Caso contrário, depois de executar a operação de apagamento, outros dados serão perdidos.
sfud_err sfud_erase_write ( const sfud_flash * flash , uint32_t addr , size_t size , const uint8_t * data )| parâmetro | descrever |
|---|---|
| clarão | Objeto de dispositivo flash |
| addr | Endereço inicial |
| tamanho | Tamanho total dos dados escritos no endereço inicial |
| dados | Dados a serem escritos |
sfud_err sfud_read_status ( const sfud_flash * flash , uint8_t * status )| parâmetro | descrever |
|---|---|
| clarão | Objeto de dispositivo flash |
| status | Valor do registro de status atual |
sfud_err sfud_write_status ( const sfud_flash * flash , bool is_volatile , uint8_t status )| parâmetro | descrever |
|---|---|
| clarão | Objeto de dispositivo flash |
| IS_VOLATILE | É fácil perder? verdadeiro: fácil de perder e será perdido após a queda de energia |
| status | Valor do registro de status atual |
Todas as configurações estão localizadas em /sfud/inc/sfud_cfg.h . Consulte a configuração Introdução abaixo para selecionar a configuração adequada ao seu projeto.
LIGUE ON/OFF SFUD_DEBUG_MODE Definição de macro
LIGUE ON/OFF SFUD_USING_SFDP Definição de macro
Nota: Após o fechamento, apenas a tabela de informações flash fornecida pela biblioteca em
/sfud/inc/sfud_flash_def.hserá consultada. Embora isso reduza a adaptabilidade do software, ele reduzirá a quantidade de código.
LIGUE/OFF SFUD_USING_FAST_READ . Muitos modos de leitura flash podem não atender à frequência SPI mais alta (para obter detalhes, consulte as características de troca de folhas de dados de cada flash) e o modo de leitura rápido precisa ser ativado.
Nota: Como o modo de leitura rápida insere um byte nulo padrão ao ler, ele pode ser mais lento que o modo de leitura quando a taxa de SPI é mais lenta.
LIGUE ON/OFF SFUD_USING_FLASH_INFO_TABLE Definição
NOTA: Após o fechamento, esta biblioteca direcionará apenas o flash que suporta especificações do SFDP, o que também reduzirá adequadamente a quantidade de código. Além disso, as duas definições macro de 2.3.2 e 2.3.3 definem pelo menos uma delas e também podem ser selecionadas em ambos os lados.
Para reduzir ainda mais a quantidade de código, SFUD_USING_SFDP e SFUD_USING_FLASH_INFO_TABLE também podem ser definidos .
No momento, basta especificar os parâmetros do flash ao definir o dispositivo flash e ligar para sfud_device_init para inicializar o dispositivo. Consulte o seguinte código:
sfud_flash sfud_norflash0 = {
. name = "norflash0" ,
. spi . name = "SPI1" ,
. chip = { "W25Q64FV" , SFUD_MF_ID_WINBOND , 0x40 , 0x17 , 8L * 1024L * 1024L , SFUD_WM_PAGE_256B , 4096 , 0x20 } };
......
sfud_device_init ( & sfud_norflash0 );
...... Se houver vários flashes no produto, você poderá adicionar a tabela de dispositivos flash. Modificar a definição macro de SFUD_FLASH_DEVICE_TABLE , o exemplo é o seguinte:
enum {
SFUD_W25Q64CV_DEVICE_INDEX = 0 ,
SFUD_GD25Q64B_DEVICE_INDEX = 1 ,
};
#define SFUD_FLASH_DEVICE_TABLE
{
[SFUD_W25Q64CV_DEVICE_INDEX] = {.name = "W25Q64CV", .spi.name = "SPI1"},
[SFUD_GD25Q64B_DEVICE_INDEX] = {.name = "GD25Q64B", .spi.name = "SPI3"},
} O acima define dois dispositivos flash (um dos produtos é suficiente). Os nomes dos dois dispositivos são "W25Q64CV" e "GD25Q64B" , correspondendo aos dois nomes de dispositivos SPI "SPI1" e "SPI3" , respectivamente (será usado ao migrar a interface SPI, localizada em /sfud/port/sfud_port.c ). As duas enumerações de SFUD_W25Q16CV_DEVICE_INDEX e SFUD_GD25Q64B_DEVICE_INDEX definem o índice dos dois dispositivos na tabela de dispositivos. Você pode obter a tabela de dispositivos através sfud_get_device_table() e acessar o dispositivo especificado com esse valor de índice.
LIGUE ON/OFF SFUD_USING_QSPI Definição de macro
Quando ativado, o SFUD também suportará o flash conectado usando o barramento QSPI.
O arquivo de porta está localizado em /sfud/port/sfud_port.c . sfud_err sfud_spi_port_init(sfud_flash *flash) no arquivo é um método de porta fornecido pela biblioteca. Ele completa a configuração dos drivers de leitura e gravação SPI (necessários), retratar os tempos (necessários), a interface de nova tentativa (opcional) e bloqueios SPI (opcional). Para um conteúdo mais detalhado de portas, você pode consultar os arquivos de portamento de cada plataforma na demonstração.
Aqui você precisa modificar /sfud/inc/sfdu_flash_def.h . Consulte a definição de macro SFUD_FLASH_CHIP_TABLE para todos os flashes suportados. Os parâmetros flash que precisam ser preparados com antecedência são: | Nome | ID do fabricante | Tipo id | ID da capacidade | Capacidade | Modo de gravação | Apagar granularidade (a unidade mínima de apagamento) | Apagar comando granularidade correspondente | . Aqui, pegamos GD25Q64B com Gigadevice como exemplo.
Esse flash é um modelo de inovação de Gioyi produzido precoce, por isso não suporta o padrão SFDP. Primeiro, você precisa baixar sua folha de dados e encontrar os três IDs retornados pelo comando 0x9f. Aqui você precisa dos dois últimos byte ID, nomeadamente type id e capacity id . GD25Q64B corresponde a esses dois IDs: 0x40 e 0x17 , respectivamente. Os outros parâmetros flash exigidos acima podem ser encontrados na folha de dados. Aqui vamos nos concentrar no modo de escrita . Este parâmetro é fornecido pela própria biblioteca. Existem 4 tipos de modos de gravação. Para detalhes, consulte o tipo de enumeração sfud_write_mode na parte superior do arquivo. O mesmo flash pode suportar vários modos de gravação ao mesmo tempo, dependendo da situação. Para GD25Q64B , o modo de gravação suportado deve ser SFUD_WM_PAGE_256B , ou seja, escreva 1-256 bytes por página. Combinado com os parâmetros flash acima GD25Q64B , devem ser os seguintes:
{"GD25Q64B", SFUD_MF_ID_GIGADEVICE, 0x40, 0x17, 8*1024*1024, SFUD_WM_PAGE_256B, 4096, 0x20},
Adicione -o ao final da definição de macro SFUD_FLASH_CHIP_TABLE para preencher o suporte da biblioteca para GD25Q64B .
Atualmente, ele apoiou demos nas seguintes plataformas
| caminho | Descrição da plataforma |
|---|---|
| /Demo/STM32F10X_NON_OS | STM32F10X Plataforma bare metal |
| /DEMO/STM32F2XX_RTT | STM32F2XX + RT-THREAD SISTEMA PLATAFOR |
| /Demo/STM32L475_NON_OS_QSPI | STM32L475 + Modo Qspi Plataforma bare metal |
| /Demo/esp32_ext_spi_flash | ESP32C3 + SPI FLASH FLASH ESP-IDF Framework |
Use o protocolo de código aberto do MIT. Leia o conteúdo do arquivo de licença no projeto para obter detalhes.
