研究了下STM32H7的ThreadX FileX的SDIO底层驱动实现，为了解决DMA4字节对齐问，全部搞成了单扇区操作，读写性能起不来

eric2013 · 发表于 2020-12-29 17:03:58

为了解决SDIO自带的IDMA的4字节对齐问题，搞成了512字节（一个扇区）大小为单位进行操作，没有是multiblock操作，这样的话，读写性能上不去

/**************************************************************************/
/* */
/* Partial Copyright (c) Microsoft Corporation. All rights reserved.*/
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* Partial Copyright (c) STMicroelctronics 2020. All rights reserved */
/**************************************************************************/
/* Include necessary system files. */
#include "fx_stm32_sd_driver.h"
ALIGN_32BYTES (UCHAR scratch[DEFAULT_SECTOR_SIZE]);
UINT _fx_partition_offset_calculate(void *partition_sector, UINT partition, ULONG *partition_start, ULONG *partition_size);
static UINT sd_read_data(FX_MEDIA *media_ptr, ULONG sector, UINT num_sectors, UINT use_scratch_buffer);
static UINT sd_write_data(FX_MEDIA *media_ptr, ULONG sector, UINT num_sectors, UINT use_scratch_buffer);
static TX_SEMAPHORE transfer_semaphore;
static uint8_t is_initialized = 0;
static int32_t check_sd_status(uint32_t instance)
{
uint32_t start = tx_time_get();
while (tx_time_get() - start < DEFAULT_TIMEOUT)
{
if (BSP_SD_GetCardState(instance) == SD_TRANSFER_OK)
{
return BSP_ERROR_NONE;
}
}
return BSP_ERROR_BUSY;
}
/**
* @brief This function is the entry point to the STM32 SDIO disk driver. */
/* It relies on the STM32 peripheral library from ST.
* @param None
* @retval None
*/
VOID fx_stm32_sd_driver(FX_MEDIA *media_ptr)
{
int32_t status;
ULONG partition_start;
ULONG partition_size;
#if (FX_DRIVER_CALLS_BSP_SD_INIT == 0)
is_initialized = 1; /* the SD was initialized by the application*/
#endif
TX_INTERRUPT_SAVE_AREA
/* before performing any operation, check the status of the SDMMC */
if (is_initialized == 1)
{
if (check_sd_status(SD_INSTANCE) != BSP_ERROR_NONE)
{
media_ptr->fx_media_driver_status = FX_IO_ERROR;
return;
}
}
/* Process the driver request specified in the media control block. */
switch(media_ptr->fx_media_driver_request)
{
case FX_DRIVER_INIT:
{
#if (FX_DRIVER_CALLS_BSP_SD_INIT == 1)
/* Initialize the SD instance */
if (is_initialized == 0)
{
status = BSP_SD_Init(SD_INSTANCE);
if (status == BSP_ERROR_NONE)
{
is_initialized = 1;
#endif
/* create a binary semaphore to check the DMA transfer status */
if (tx_semaphore_create(&transfer_semaphore, "sdmmc dma transfer semaphore", 0) != TX_SUCCESS)
{
media_ptr->fx_media_driver_status = FX_IO_ERROR;
}
else
{
media_ptr->fx_media_driver_status = FX_SUCCESS;
}
#if (FX_DRIVER_CALLS_BSP_SD_INIT == 1)
}
else
{
media_ptr->fx_media_driver_status = FX_IO_ERROR;
}
}
#endif
break;
}
case FX_DRIVER_UNINIT:
{
tx_semaphore_delete(&transfer_semaphore);
#if (FX_DRIVER_CALLS_BSP_SD_INIT == 1)
BSP_SD_DeInit(SD_INSTANCE);
is_initialized = 0;
#endif
/* Successful driver request. */
media_ptr->fx_media_driver_status = FX_SUCCESS;
break;
}
case FX_DRIVER_READ:
{
media_ptr->fx_media_driver_status = FX_IO_ERROR;
TX_DISABLE /* disable interrupts */
if ((ULONG)(media_ptr->fx_media_driver_buffer) & 0x3)
{
if (sd_read_data(media_ptr, media_ptr->fx_media_driver_logical_sector + media_ptr->fx_media_hidden_sectors,
media_ptr->fx_media_driver_sectors, 1) == FX_SUCCESS)
{
media_ptr->fx_media_driver_status = FX_SUCCESS;
}
}
else
{
if (sd_read_data(media_ptr, media_ptr->fx_media_driver_logical_sector + media_ptr->fx_media_hidden_sectors,
media_ptr->fx_media_driver_sectors, 0) == FX_SUCCESS)
{
media_ptr->fx_media_driver_status = FX_SUCCESS;
}
}
TX_RESTORE /* restore interrupts */
break;
}
case FX_DRIVER_WRITE:
{
media_ptr->fx_media_driver_status = FX_IO_ERROR;
TX_DISABLE /* disable interrupts */
/* the buffer is unaligned use a scratch buffer for the write operation */
if ((ULONG)(media_ptr->fx_media_driver_buffer) & 0x3)
{
if (sd_write_data(media_ptr, media_ptr->fx_media_driver_logical_sector + media_ptr->fx_media_hidden_sectors,
media_ptr->fx_media_driver_sectors, 1) == FX_SUCCESS)
{
media_ptr->fx_media_driver_status = FX_SUCCESS;
}
}
else
{
if (sd_write_data(media_ptr, media_ptr->fx_media_driver_logical_sector + media_ptr->fx_media_hidden_sectors,
media_ptr->fx_media_driver_sectors, 0) == FX_SUCCESS)
{
media_ptr->fx_media_driver_status = FX_SUCCESS;
}
}
TX_RESTORE /* restore interrupts */
break;
}
case FX_DRIVER_FLUSH:
{
/* Return driver success. */
media_ptr->fx_media_driver_status = FX_SUCCESS;
break;
}
case FX_DRIVER_ABORT:
{
/* Return driver success. */
media_ptr->fx_media_driver_status = FX_SUCCESS;
break;
}
case FX_DRIVER_BOOT_READ:
{
#if (ENABLE_CACHE_MAINTENANCE == 1)
SCB_InvalidateDCache_by_Addr((uint32_t*)media_ptr->fx_media_driver_buffer, media_ptr->fx_media_driver_sectors * DEFAULT_SECTOR_SIZE);
#endif
/* the boot sector is the sector 0 */
status = BSP_SD_ReadBlocks_DMA(SD_INSTANCE,(uint32_t*)media_ptr->fx_media_driver_buffer, 0, 1);
if (status != BSP_ERROR_NONE)
{
media_ptr->fx_media_driver_status = FX_IO_ERROR;
break;
}
if(tx_semaphore_get(&transfer_semaphore, DEFAULT_TIMEOUT) != TX_SUCCESS)
{
media_ptr->fx_media_driver_status = FX_IO_ERROR;
break;
}
/* Check if the sector 0 is the actual boot sector, otherwise calculate the offset into it.
Please note that this should belong to higher level of MW to do this check and it is here
as a temporary work solution */
partition_start = 0;
status = _fx_partition_offset_calculate(media_ptr -> fx_media_driver_buffer, 0,
&partition_start, &partition_size);
/* Check partition read error. */
if (status)
{
/* Unsuccessful driver request. */
media_ptr -> fx_media_driver_status = FX_IO_ERROR;
return;
}
/* Now determine if there is a partition... */
if (partition_start)
{
if (check_sd_status(SD_INSTANCE) != BSP_ERROR_NONE)
{
media_ptr->fx_media_driver_status = FX_IO_ERROR;
return;
}
/*Invalidate cache before DMA read */
#if (ENABLE_CACHE_MAINTENANCE == 1)
SCB_InvalidateDCache_by_Addr((uint32_t*)media_ptr->fx_media_driver_buffer, media_ptr->fx_media_driver_sectors * DEFAULT_SECTOR_SIZE);
#endif
/* Yes, now lets read the actual boot record. */
status = BSP_SD_ReadBlocks_DMA(SD_INSTANCE, (uint32_t*)media_ptr -> fx_media_driver_buffer, partition_start , 1);
/* Check status of SDIO Read. */
if (status != BSP_ERROR_NONE)
{
/* Unsuccessful driver request. */
media_ptr -> fx_media_driver_status = FX_IO_ERROR;
return;
}
/* Wait for Rx Transfer completion */
if(tx_semaphore_get(&transfer_semaphore, DEFAULT_TIMEOUT) != TX_SUCCESS)
{
media_ptr->fx_media_driver_status = FX_IO_ERROR;
break;
}
}
/* Successful driver request. */
media_ptr -> fx_media_driver_status = FX_SUCCESS;
break;
}
case FX_DRIVER_BOOT_WRITE:
{
#if (ENABLE_CACHE_MAINTENANCE == 1)
SCB_CleanDCache_by_Addr((uint32_t*)media_ptr->fx_media_driver_buffer, media_ptr->fx_media_driver_sectors * DEFAULT_SECTOR_SIZE);
#endif
status = BSP_SD_WriteBlocks_DMA(SD_INSTANCE,(uint32_t*)media_ptr->fx_media_driver_buffer, 0, 1);
if (status == BSP_ERROR_NONE)
{
if(tx_semaphore_get(&transfer_semaphore, DEFAULT_TIMEOUT) == TX_SUCCESS)
{
media_ptr->fx_media_driver_status = FX_SUCCESS;
}
else
{
media_ptr->fx_media_driver_status = FX_IO_ERROR;
}
}
break;
}
default:
{
media_ptr->fx_media_driver_status = FX_IO_ERROR;
break;
}
}
}
/**
* @brief BSP Tx Transfer completed callbacks
* @param Instance the SD instance
* @retval None
*/
void BSP_SD_WriteCpltCallback(uint32_t Instance)
{
tx_semaphore_put(&transfer_semaphore);
}
/**
* @brief BSP Rx Transfer completed callbacks
* @param Instance the sd instance
* @retval None
*/
void BSP_SD_ReadCpltCallback(uint32_t Instance)
{
tx_semaphore_put(&transfer_semaphore);
}
/**
* @brief Read buffer using BSP SD API taking into account the scratch buffer
* @param FX_MEDIA *media_ptr a pointer the main FileX structure
* @param ULONG start_sector first sector to start reading from
* @param UINT num_sectors number of sectors to be read
* @param UINT use_scratch_buffer to enable scratch buffer usage or not.
* @retval FX_SUCCESS on success FX_BUFFER_ERROR otherwise
*/
static UINT sd_read_data(FX_MEDIA *media_ptr, ULONG start_sector, UINT num_sectors, UINT use_scratch_buffer)
{
INT i = 0;
UINT status;
if (use_scratch_buffer)
{
memset(scratch, '\0', DEFAULT_SECTOR_SIZE);
for (i = 0; i < num_sectors; i++)
{
status = BSP_SD_ReadBlocks_DMA(SD_INSTANCE, (uint32_t*)scratch, start_sector++, 1);
if (status != BSP_ERROR_NONE)
{
status = FX_IO_ERROR;
break;
}
if(tx_semaphore_get(&transfer_semaphore, DEFAULT_TIMEOUT) != TX_SUCCESS)
{
status = FX_BUFFER_ERROR;
break;
}
else
{
#if (ENABLE_CACHE_MAINTENANCE == 1)
SCB_InvalidateDCache_by_Addr((uint32_t*)scratch, DEFAULT_SECTOR_SIZE);
#endif
_fx_utility_memory_copy(scratch, media_ptr->fx_media_driver_buffer, DEFAULT_SECTOR_SIZE);
media_ptr->fx_media_driver_buffer += DEFAULT_SECTOR_SIZE;
}
}
if (i == num_sectors)
{
status = FX_SUCCESS;
}
}
else
{
status = BSP_SD_ReadBlocks_DMA(SD_INSTANCE, (uint32_t*)media_ptr->fx_media_driver_buffer, start_sector, num_sectors);
if (status == BSP_ERROR_NONE)
{
if(tx_semaphore_get(&transfer_semaphore, DEFAULT_TIMEOUT) == TX_SUCCESS)
{
#if (ENABLE_CACHE_MAINTENANCE == 1)
SCB_InvalidateDCache_by_Addr((uint32_t*)media_ptr->fx_media_driver_buffer, num_sectors * DEFAULT_SECTOR_SIZE);
#endif
status = FX_SUCCESS;
}
else
{
status = FX_BUFFER_ERROR;
}
}
}
return status;
}
/**
* @brief write buffer using BSP SD API taking into account the scratch buffer
* @param FX_MEDIA *media_ptr a pointer the main FileX structure
* @param ULONG start_sector first sector to start writing from
* @param UINT num_sectors number of sectors to be written
* @param UINT use_scratch_buffer to enable scratch buffer usage or not.
* @retval FX_SUCCESS on success FX_BUFFER_ERROR otherwise
*/
static UINT sd_write_data(FX_MEDIA *media_ptr, ULONG start_sector, UINT num_sectors, UINT use_scratch_buffer)
{
INT i = 0;
UINT status;
if (use_scratch_buffer)
{
for (i = 0; i < num_sectors; i++)
{
_fx_utility_memory_copy(media_ptr->fx_media_driver_buffer, scratch, DEFAULT_SECTOR_SIZE);
media_ptr->fx_media_driver_buffer += DEFAULT_SECTOR_SIZE;
#if (ENABLE_CACHE_MAINTENANCE == 1)
/* Clean the DCache to make the SD DMA see the actual content of the scratch buffer */
SCB_CleanDCache_by_Addr((uint32_t*)scratch, DEFAULT_SECTOR_SIZE);
#endif
status = BSP_SD_WriteBlocks_DMA(SD_INSTANCE, (uint32_t*)scratch, (uint32_t)start_sector++, 1);
if (status != BSP_ERROR_NONE)
{
status = FX_IO_ERROR;
break;
}
if(tx_semaphore_get(&transfer_semaphore, DEFAULT_TIMEOUT) != TX_SUCCESS)
{
status = FX_BUFFER_ERROR;
break;
}
}
if (i == num_sectors)
{
status = FX_SUCCESS;
}
}
else
{
SCB_CleanDCache_by_Addr((uint32_t*)media_ptr->fx_media_driver_buffer, num_sectors * DEFAULT_SECTOR_SIZE);
status = BSP_SD_WriteBlocks_DMA(SD_INSTANCE, (uint32_t*)media_ptr->fx_media_driver_buffer, start_sector, num_sectors);
if (status == BSP_ERROR_NONE)
{
if(tx_semaphore_get(&transfer_semaphore, DEFAULT_TIMEOUT) == TX_SUCCESS)
{
status = FX_SUCCESS;
}
else
{
status = FX_IO_ERROR;
}
}
}
return status;
}

复制代码

LR215 · 发表于 2020-12-29 21:28:18

读写速度和FATFS相比呢？

eric2013 · 发表于 2020-12-30 08:57:59

LR215 发表于 2020-12-29 21:28
读写速度和FATFS相比呢？

底层驱动不同，没法做比较。

morning_enr6U · 发表于 2020-12-30 10:50:17

硬汉大哥这里有想法？毕竟对方的代码是安全认证过的，也许考虑的功能安全的层面比较多。

eric2013 · 发表于 2020-12-30 11:44:40

morning_enr6U 发表于 2020-12-30 10:50
硬汉大哥这里有想法？毕竟对方的代码是安全认证过的，也许考虑的功能安全的层面比较多。

当前提供的这个是最简单的实现方式，性能也是最低的。

稳定性好点

hpdell · 发表于 2021-1-3 14:12:45

传说稳定压倒一切，估计就是这个道理吧

eric2013 · 发表于 2021-1-4 10:28:26

hpdell 发表于 2021-1-3 14:12
传说稳定压倒一切，估计就是这个道理吧

他们先发布一个稳定易用的版本也是合理的。

		自动登录	找回密码
密码			立即注册

[SD/SDIO] 研究了下STM32H7的ThreadX FileX的SDIO底层驱动实现，为了解决DMA4字节对齐问，全部搞成了单扇区操作，读写性能起不来