diskio.c

Go to the documentation of this file.

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/*----- Header-Files -------------------------------------------------------*/
#include <string.h>
#include "diskio.h"                 /* FatFs lower layer API                */
#include "stm32f4xx.h"
#include "stm32f4_sdio_sd.h"

/*----- Macros -------------------------------------------------------------*/
#define BLOCK_SIZE          512     
/*----- Data types ---------------------------------------------------------*/

/*----- Function prototypes ------------------------------------------------*/

/*----- Data ---------------------------------------------------------------*/

/*----- Implementation -----------------------------------------------------*/
DSTATUS disk_initialize(BYTE drv) {

    DSTATUS stat = 0;

#ifdef DBGIO
    printf("disk_initialize %d\n", drv);
#endif

    /* Supports only single drive */
    if (drv) {
        stat |= STA_NOINIT;
    }

    /* SD Init */
    if (SD_Init() != SD_OK) {
#ifdef DBGIO
        puts("Initialization Fail");
#endif
        stat |= STA_NOINIT;
    }

    return (stat);
}

DSTATUS disk_status(BYTE drv) {

    DSTATUS stat = 0;

    if (SD_Detect() != SD_PRESENT )
        stat |= STA_NODISK;

    /* STA_NOTINIT - Subsystem not initialized                              */
    /* STA_PROTECTED - Write protected, MMC/SD switch if available          */

    return (stat);
}

DRESULT disk_read(BYTE drv, BYTE *buff, DWORD sector, UINT count) {

    SD_Error Status;

#ifdef DBGIO
    printf("disk_read %d %p %10d %d\n",drv,buff,sector,count);
#endif

    if (SD_Detect() != SD_PRESENT )
        return (RES_NOTRDY);

    /* DMA Alignment failure, do single up to aligned buffer */
    if ((DWORD) buff & 3) {
        DRESULT res = RES_OK;
        DWORD scratch[BLOCK_SIZE / 4]; /* Alignment assured, you'll need a sufficiently big stack */

        while (count--) {
            res = disk_read(drv, (void *) scratch, sector++, 1);

            if (res != RES_OK)
                break;

            memcpy(buff, scratch, BLOCK_SIZE);

            buff += BLOCK_SIZE;
        }

        return (res);
    }

    /* 4GB Compliant */
    Status = SD_ReadMultiBlocksFIXED(buff, sector, BLOCK_SIZE, count);

    if (Status == SD_OK) {
        SDTransferState State;

        /* Check if the Transfer is finished */
        Status = SD_WaitReadOperation();

        /* BUSY, OK (DONE), ERROR (FAIL) */
        while ((State = SD_GetStatus()) == SD_TRANSFER_BUSY)
            ;

        if ((State == SD_TRANSFER_ERROR) || (Status != SD_OK))
            return (RES_ERROR);
        else
            return (RES_OK);
    }
    else
        return (RES_ERROR);
}

#if _USE_WRITE

DRESULT disk_write(BYTE drv, const BYTE *buff, DWORD sector, BYTE count) {

    SD_Error Status;

#ifdef DBGIO
    printf("disk_write %d %p %10d %d\n",drv,buff,sector,count);
#endif

    if (SD_Detect() != SD_PRESENT )
        return (RES_NOTRDY);

    /* DMA Alignment failure, do single up to aligned buffer */
    if ((DWORD) buff & 3) {
        DRESULT res = RES_OK;
        DWORD scratch[BLOCK_SIZE / 4]; /* Alignment assured, you'll need a sufficiently big stack */

        while (count--) {
            memcpy(scratch, buff, BLOCK_SIZE);

            res = disk_write(drv, (void *) scratch, sector++, 1);

            if (res != RES_OK)
                break;

            buff += BLOCK_SIZE;
        }

        return (res);
    }

    /* 4GB Compliant */
    Status = SD_WriteMultiBlocksFIXED((uint8_t *) buff, sector, BLOCK_SIZE,
                                      count);

    if (Status == SD_OK) {
        SDTransferState State;

        /* Check if the Transfer is finished */
        Status = SD_WaitWriteOperation();

        /* BUSY, OK (DONE), ERROR (FAIL) */
        while ((State = SD_GetStatus()) == SD_TRANSFER_BUSY)
            ;

        if ((State == SD_TRANSFER_ERROR) || (Status != SD_OK))
            return (RES_ERROR);
        else
            return (RES_OK);
    }
    else
        return (RES_ERROR);
}
#endif /* _USE_WRITE */

#if _USE_IOCTL

DRESULT disk_ioctl(BYTE pdrv, BYTE cmd, void *buff) {
    return RES_OK;
}
#endif /* _USE_IOCTL */

#ifdef __cplusplus
}
#endif /* __cplusplus */