sd_diskio.c

Go to the documentation of this file.

 
/* Includes ------------------------------------------------------------------*/
#include "sd_diskio.h"
 
#include "board.h"
#include "log.h"
#include "sdmmc.h"
 
#include <stdbool.h>
 
/* Private function prototypes -----------------------------------------------*/
static void SdReadCompleteCallback(void);
 
static void SdWriteCompleteCallback(void);
 
static DSTATUS SdDiskIoInit(BYTE pdrv);
 
static DSTATUS SdDiskIoStatus(BYTE pdrv);
 
static DRESULT SdDiskIoRead(BYTE pdrv, BYTE* buff, DWORD sector, UINT count);
 
static DRESULT SdDiskIoWrite(BYTE pdrv,
                             const BYTE* buff,
                             DWORD sector,
                             UINT count);
 
static DRESULT SdDiskIoIoctl(BYTE pdrv, BYTE cmd, void* buff);
 
/* Private variables ---------------------------------------------------------*/
static volatile bool isReadComplete = false;
 
static volatile bool isWriteComplete = false;
 
/* Functions -----------------------------------------------------------------*/
const Diskio_drvTypeDef* SdDiskIoGetDriver(void)
{
    static const Diskio_drvTypeDef SD_DISK_IO_DRIVER = {
        SdDiskIoInit,  SdDiskIoStatus, SdDiskIoRead,
        SdDiskIoWrite, SdDiskIoIoctl,
    };
 
    return &SD_DISK_IO_DRIVER;
}
 
static DSTATUS SdDiskIoInit(BYTE pdrv)
{
    SdmmcRegisterRxCompleteCallback(SdReadCompleteCallback);
    SdmmcRegisterTxCompleteCallback(SdWriteCompleteCallback);
 
    isReadComplete  = false;
    isWriteComplete = false;
 
    return SdDiskIoStatus(pdrv);
}
 
static DSTATUS SdDiskIoStatus(BYTE pdrv)
{
    UNUSED(pdrv);
    DSTATUS result = STA_NOINIT;
 
    if (SdmmcIsCardInTransferState())
    {
        result &= ~STA_NOINIT;
    }
 
    return result;
}
 
static DRESULT SdDiskIoRead(BYTE pdrv, BYTE* buff, DWORD sector, UINT count)
{
    UNUSED(pdrv);
    DRESULT result = RES_ERROR;
 
#if defined(USE_SDMMC_DMA)
    /* Use SD Driver in DMA mode */
    isReadComplete = false;
    if (SdmmcReadBlocksDma(buff, sector, count))
    {
        /* Wait for DMA Complete */
        uint32_t timeout = HAL_GetTick();
        while (!isReadComplete &&
               ((HAL_GetTick() - timeout) < SDMMC_TRANSFER_TIMEOUT))
        {
        }
 
        /* In case of a timeout return error */
        if (!isReadComplete)
        {
            result = RES_ERROR;
        }
        else
        {
            if (SdmmcIsCardInTransferState())
            {
                result = RES_OK;
            }
            else
            {
                LogPrint("ERROR: SD card is not in transfer state.\n");
            }
        }
    }
#else
    /* Use SD Driver in blocking mode */
    if (SdmmcReadBlocks(buff, sector, count, SDMMC_TRANSFER_TIMEOUT))
    {
        if (SdmmcIsCardInTransferState())
        {
            result = RES_OK;
        }
    }
#endif /* USE_SDMMC_DMA */
 
    return result;
}
 
static DRESULT SdDiskIoWrite(BYTE pdrv,
                             const BYTE* buff,
                             DWORD sector,
                             UINT count)
{
    UNUSED(pdrv);
    DRESULT result = RES_ERROR;
 
#if defined(USE_SDMMC_DMA)
    /* Use SD Driver in DMA mode */
    isWriteComplete = false;
    if (SdmmcWriteBlocksDma(buff, sector, count))
    {
        /* Wait for DMA complete */
        uint32_t timeout = HAL_GetTick();
        while (!isWriteComplete &&
               ((HAL_GetTick() - timeout) < SDMMC_TRANSFER_TIMEOUT))
        {
        }
 
        /* In case of a timeout return error */
        if (!isWriteComplete)
        {
            result = RES_ERROR;
        }
        else
        {
            if (SdmmcIsCardInTransferState())
            {
                result = RES_OK;
            }
            else
            {
                LogPrint("ERROR: SD card is not in transfer state.\n");
            }
        }
    }
#else
    /* Use SD Driver in blocking mode */
    result = RES_ERROR;
    if (SdmmcWriteBlocks(buff, sector, count, SDMMC_TRANSFER_TIMEOUT))
    {
        if (SdmmcIsCardInTransferState())
        {
            result = RES_OK;
        }
    }
#endif /* USE_SDMMC_DMA */
 
    return result;
}
 
static DRESULT SdDiskIoIoctl(BYTE pdrv, BYTE cmd, void* buff)
{
    UNUSED(pdrv);
    DRESULT result = RES_NOTRDY;
 
    if (SdmmcIsCardInTransferState())
    {
        SdCardInfo sdCardInfo = {0};
        switch (cmd)
        {
            /* Make sure that no pending write process */
            case CTRL_SYNC:
                result = RES_OK;
                break;
 
            /* Get number of sectors on the disk (DWORD) */
            case GET_SECTOR_COUNT:
                if (SdmmcGetCardInfo(&sdCardInfo))
                {
                    // Message:     A conversion should not be performed from
                    //              pointer to void into pointer to object
                    //              [misra-c2012-11.5]
                    // Reason:      The pointer to the buffer needs to be
                    //              converted to a pointer to DWORD in order to
                    //              fill the buffer with the requested value.
                    // Risk:        Conversion of a pointer to void into a
                    //              pointer to object may result in a pointer
                    //              that is not correctly aligned, resulting in
                    //              undefined behavior.
                    // Prevention:  Code reviews.
                    // cppcheck-suppress [misra-c2012-11.5]
                    *(DWORD*)buff = sdCardInfo.LogBlockNbr;
                    result        = RES_OK;
                }
                break;
 
            /* Get R/W sector size (WORD) */
            case GET_SECTOR_SIZE:
                if (SdmmcGetCardInfo(&sdCardInfo))
                {
                    // Message:     A conversion should not be performed from
                    //              pointer to void into pointer to object
                    //              [misra-c2012-11.5]
                    // Reason:      The pointer to the buffer needs to be
                    //              converted to a pointer to WORD in order to
                    //              fill the buffer with the requested value.
                    // Risk:        Conversion of a pointer to void into a
                    //              pointer to object may result in a pointer
                    //              that is not correctly aligned, resulting in
                    //              undefined behavior.
                    // Prevention:  Code reviews.
                    // cppcheck-suppress [misra-c2012-11.5]
                    *(WORD*)buff = (WORD)sdCardInfo.LogBlockSize;
                    result       = RES_OK;
                }
                break;
 
            /* Get erase block size in unit of sector (DWORD) */
            case GET_BLOCK_SIZE:
                if (SdmmcGetCardInfo(&sdCardInfo))
                {
                    // Message:     A conversion should not be performed from
                    //              pointer to void into pointer to object
                    //              [misra-c2012-11.5]
                    // Reason:      The pointer to the buffer needs to be
                    //              converted to a pointer to DWORD in order to
                    //              fill the buffer with the requested value.
                    // Risk:        Conversion of a pointer to void into a
                    //              pointer to object may result in a pointer
                    //              that is not correctly aligned, resulting in
                    //              undefined behavior.
                    // Prevention:  Code reviews.
                    // cppcheck-suppress [misra-c2012-11.5]
                    *(DWORD*)buff = sdCardInfo.LogBlockSize;
                    result        = RES_OK;
                }
                break;
 
            default:
                result = RES_PARERR;
                break;
        }
    }
 
    return result;
}
 
static void SdReadCompleteCallback(void)
{
    isReadComplete = true;
}
 
static void SdWriteCompleteCallback(void)
{
    isWriteComplete = true;
}