| /* ---------------------------------------------------------------------------- | |
| * ATMEL Microcontroller Software Support | |
| * ---------------------------------------------------------------------------- | |
| * Copyright (c) 2010, Atmel Corporation | |
| * | |
| * All rights reserved. | |
| * | |
| * Redistribution and use in source and binary forms, with or without | |
| * modification, are permitted provided that the following conditions are met: | |
| * | |
| * - Redistributions of source code must retain the above copyright notice, | |
| * this list of conditions and the disclaimer below. | |
| * | |
| * Atmel's name may not be used to endorse or promote products derived from | |
| * this software without specific prior written permission. | |
| * | |
| * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR | |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE | |
| * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT, | |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, | |
| * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | |
| * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, | |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| * ---------------------------------------------------------------------------- | |
| */ | |
| /** \file */ | |
| /** | |
| * \page sdmmc_lib_cmd SD/MMC Lib Commands | |
| * | |
| * Implementation for SD/MMC low level driver. Supply a set of SD/MMC mode's | |
| * interface. | |
| * | |
| * \section Usage | |
| * | |
| * - Uses following Library definitions in HAL or application: | |
| * -# \ref sdmmc_cardtype : SD/SDIO/MMC card type definitions. | |
| * -# \ref sdmmc_rc : Return codes for SD/MMC operation (functions). | |
| * -# \ref sSdCard : Struct that defined by application for SD/MMC management. | |
| * - Uses following Low Level Definitions in HAL: | |
| * -# \ref sdmmc_ioctrls : IO control code for HAL implement. | |
| * -# \ref sdmmc_cmd_op : Command operation code for HAL to implement. | |
| * -# \ref sSdHalFunctions : HAL functions to implement. | |
| */ | |
| #ifndef _SDMMC_CMD_H | |
| #define _SDMMC_CMD_H | |
| /** \addtogroup sdmmc_cmd | |
| * | |
| * \copydoc sdmmc_lib_cmd | |
| * | |
| * See \ref sdmmc_lib_cmd for more details. | |
| *@{ | |
| */ | |
| /*------------------------------------------------------------------------------ | |
| * Includes | |
| *----------------------------------------------------------------------------*/ | |
| #include <stdint.h> | |
| /*------------------------------------------------------------------------------ | |
| * Definitions | |
| *----------------------------------------------------------------------------*/ | |
| /** \addtogroup sdmmc_cmd_defines SD/MMC General defines | |
| @{*/ | |
| /** | |
| * \addtogroup sdmmc_cardtype SD/MMC Card Types | |
| * Here lists the SD/MMC card types. | |
| * - Card Type Category Bitmap | |
| * - \ref CARD_TYPE_bmHC | |
| * - \ref CARD_TYPE_bmSDMMC | |
| * - \ref CARD_TYPE_bmUNKNOWN | |
| * - \ref CARD_TYPE_bmSD | |
| * - \ref CARD_TYPE_bmMMC | |
| * - \ref CARD_TYPE_bmSDIO | |
| * - Card Types | |
| * - \ref CARD_UNKNOWN | |
| * - \ref CARD_SD | |
| * - \ref CARD_SDHC | |
| * - \ref CARD_MMC | |
| * - \ref CARD_MMCHD | |
| * - \ref CARD_SDIO | |
| * - \ref CARD_SDCOMBO | |
| * - \ref CARD_SDHCCOMBO | |
| * @{*/ | |
| #define CARD_TYPE_bmHC (1 << 0) /**< Bit for High-Capacity(Density) */ | |
| #define CARD_TYPE_bmSDMMC (0x3 << 1) /**< Bits mask for SD/MMC */ | |
| #define CARD_TYPE_bmUNKNOWN (0x0 << 1) /**< Bits for Unknown card */ | |
| #define CARD_TYPE_bmSD (0x1 << 1) /**< Bits for SD */ | |
| #define CARD_TYPE_bmMMC (0x2 << 1) /**< Bits for MMC */ | |
| #define CARD_TYPE_bmSDIO (1 << 3) /**< Bit for SDIO */ | |
| /** Card can not be identified */ | |
| #define CARD_UNKNOWN (0) | |
| /** SD Card (0x2) */ | |
| #define CARD_SD (CARD_TYPE_bmSD) | |
| /** SD High Capacity Card (0x3) */ | |
| #define CARD_SDHC (CARD_TYPE_bmSD|CARD_TYPE_bmHC) | |
| /** MMC Card (0x4) */ | |
| #define CARD_MMC (CARD_TYPE_bmMMC) | |
| /** MMC High-Density Card (0x5) */ | |
| #define CARD_MMCHD (CARD_TYPE_bmMMC|CARD_TYPE_bmHC) | |
| /** SDIO only card (0x8) */ | |
| #define CARD_SDIO (CARD_TYPE_bmSDIO) | |
| /** SDIO Combo, with SD embedded (0xA) */ | |
| #define CARD_SDCOMBO (CARD_TYPE_bmSDIO|CARD_SD) | |
| /** SDIO Combo, with SDHC embedded (0xB) */ | |
| #define CARD_SDHCCOMBO (CARD_TYPE_bmSDIO|CARD_SDHC) | |
| /** @}*/ | |
| /** | |
| * \addtogroup sdmmc_rc SD/MMC Return Codes | |
| * Here lists the SD/MMC driver return codes. | |
| * - \ref SDMMC_ERROR | |
| * - \ref SDMMC_ERROR_NORESPONSE | |
| * - \ref SDMMC_ERROR_NOT_INITIALIZED | |
| * - \ref SDMMC_ERROR_BUSY | |
| * - \ref SDMMC_ERROR_PARAM | |
| * - \ref SDMMC_ERROR_NOT_SUPPORT | |
| * - \ref SDMMC_OK | |
| * - \ref SDMMC_ERROR_LOCKED | |
| * @{*/ | |
| /** SD/MMC Return codes */ | |
| typedef enum { | |
| SDMMC_OK = 0, /**< Operation OK */ | |
| SDMMC_LOCKED = 1, /**< Failed because driver locked */ | |
| SDMMC_BUSY = 2, /**< Failed because driver busy */ | |
| SDMMC_NO_RESPONSE = 3, /**< Failed because card not respond */ | |
| SDMMC_CHANGED, /**< Setting param changed due to limitation */ | |
| SDMMC_ERR, /**< Failed with general error */ | |
| SDMMC_ERR_IO, /**< Failed because of IO error */ | |
| SDMMC_ERR_RESP, /**< Error reported in response code */ | |
| SDMMC_NOT_INITIALIZED, /**< Fail to initialize */ | |
| SDMMC_PARAM, /**< Parameter error */ | |
| SDMMC_STATE, /**< State error */ | |
| SDMMC_USER_CANCEL, /**< Canceled by user */ | |
| SDMMC_NOT_SUPPORTED /**< Command(Operation) not supported */ | |
| } eSDMMC_RC; | |
| /** No error */ | |
| #define SDMMC_SUCCESS SDMMC_OK | |
| /** The driver is locked. */ | |
| #define SDMMC_ERROR_LOCKED SDMMC_LOCKED | |
| /** There was an error with the SD driver. */ | |
| #define SDMMC_ERROR SDMMC_ERR | |
| /** The SD card did not answer the command. */ | |
| #define SDMMC_ERROR_NORESPONSE SDMMC_NO_RESPONSE | |
| /** The SD card is not initialized. */ | |
| #define SDMMC_ERROR_NOT_INITIALIZED SDMMC_NOT_INITIALIZED | |
| /** The SD card is busy. */ | |
| #define SDMMC_ERROR_BUSY SDMMC_BUSY | |
| /** The input parameter error */ | |
| #define SDMMC_ERROR_PARAM SDMMC_PARAM | |
| /** Invalid state */ | |
| #define SDMMC_ERROR_STATE SDMMC_STATE | |
| /** User canceled */ | |
| #define SDMMC_ERROR_USER_CANCEL SDMMC_USER_CANCEL | |
| /** The operation is not supported. */ | |
| #define SDMMC_ERROR_NOT_SUPPORT SDMMC_NOT_SUPPORTED | |
| /** @}*/ | |
| /** | |
| * \addtogroup sdmmc_states SD/MMC Card States | |
| * @{ | |
| */ | |
| #define SDMMC_STATE_OFF 0x0 /**< Power OFF */ | |
| #define SDMMC_STATE_ON 0x1 /**< Power ON */ | |
| #define SDMMC_STATE_IDENT 0x2 /**< Card Identification (IDLE,READY,IDENT) */ | |
| #define SDMMC_STATE_INACTIVE 0x3 /**< Inactive */ | |
| #define SDMMC_STATE_IRQ 0x4 /**< Wait-IRQ, interrupt mode */ | |
| #define SDMMC_STATE_STBY 0x5 /**< Addressed */ | |
| #define SDMMC_STATE_TRAN 0x6 /**< Ready for transfer */ | |
| #define SDMMC_STATE_DATA_WR 0x7 /**< Data TX in progress */ | |
| #define SDMMC_STATE_DATA_RD 0x8 /**< Data RX in progress */ | |
| /** @}*/ | |
| /** \ingroup sdmmc_hal_def | |
| * \addtogroup sdmmc_ioctrls SD/MMC IO Control Codes | |
| * Here lists the control codes for SD/MMC low level driver to support lib. | |
| * - \ref SDMMC_IOCTL_POWER: Power ON/OFF control. | |
| * - \ref SDMMC_IOCTL_SET_CLOCK: Set clock and return actual clock. | |
| * - \ref SDMMC_IOCTL_GET_BUSMODE: Return max supported bus mode. | |
| * - \ref SDMMC_IOCTL_GET_HSMODE: Return if HS mode is supported. | |
| * - \ref SDMMC_IOCTL_GET_BOOTMODE: Return if Boot mode is supported. | |
| * @{*/ | |
| /** SD/MMC Low Level IO Control: Check busy. | |
| Must implement for low level driver busy check. | |
| IOCtrl(pSd, SDMMC_IOCTL_BUSY_CHECK, (uint32_t)pBusyFlag) */ | |
| #define SDMMC_IOCTL_BUSY_CHECK 0x0 | |
| /** SD/MMC Low Level IO Control: Power control. | |
| Recomended for SD/MMC/SDIO power control. | |
| IOCtrl(pSd, SDMMC_IOCTL_POWER, (uint32_t)ON/OFF) */ | |
| #define SDMMC_IOCTL_POWER 0x1 | |
| /** SD/MMC Low Level IO Control: Cancel command. | |
| IOCtrl(pSd, SDMMC_IOCTL_CANCEL_CMD, NULL) */ | |
| #define SDMMC_IOCTL_CANCEL_CMD 0x2 | |
| /** SD/MMC Low Level IO Control: Reset & disable HW. | |
| IOCtrl(pSd, SDMMC_IOCTL_RESET, NULL) */ | |
| #define SDMMC_IOCTL_RESET 0x3 | |
| /** SD/MMC Low Level IO Control: Set clock frequency, return applied frequency | |
| Recomended for clock selection | |
| IOCtrl(pSd, SDMMC_IOCTL_SET_CLOCK, (uint32_t*)pIoFreq) */ | |
| #define SDMMC_IOCTL_SET_CLOCK 0x11 | |
| /** SD/MMC Low Level IO Control: Set bus mode, return applied mode | |
| Recomended for bus mode selection | |
| IOCtrl(pSd, SDMMC_IOCTL_SET_BUSMODE, (uint32_t*)pIoBusMode) */ | |
| #define SDMMC_IOCTL_SET_BUSMODE 0x12 | |
| /** SD/MMC Low Level IO Control: Set HS mode, return applied mode | |
| Recommended for HS mode enable | |
| IOCtrl(pSd, SDMMC_IOCTL_SET_BUSMODE, (uint32_t*)pIoHsMode) */ | |
| #define SDMMC_IOCTL_SET_HSMODE 0x13 | |
| /** SD/MMC Low Level IO Control: Set Boot mode */ | |
| #define SDMMC_IOCTL_SET_BOOTMODE 0x14 | |
| /** SD/MMC Low Level IO Control: Get clock frequency */ | |
| #define SDMMC_IOCTL_GET_CLOCK 0x21 | |
| /** SD/MMC Low Level IO Control: Bus mode */ | |
| #define SDMMC_IOCTL_GET_BUSMODE 0x22 | |
| /** SD/MMC Low Level IO Control: High-speed mode */ | |
| #define SDMMC_IOCTL_GET_HSMODE 0x23 | |
| /** SD/MMC Low Level IO Control: Boot mode */ | |
| #define SDMMC_IOCTL_GET_BOOTMODE 0x24 | |
| /** @}*/ | |
| /** \ingroup sdmmc_hal_def | |
| * \addtogroup sdmmc_cmd_op SD/MMC Command Operations | |
| * @{ | |
| */ | |
| #define SDMMC_CMD_bmPOWERON (0x1 ) /**< Do Power ON sequence */ | |
| #define SDMMC_CMD_bmCOMMAND (0x1 << 1) /**< Send command */ | |
| #define SDMMC_CMD_bmDATAMASK (0x3 << 2) /**< Data operation mask */ | |
| #define SDMMC_CMD_bmNODATA (0x0 << 2) /**< No data transfer */ | |
| #define SDMMC_CMD_RX 0x1 /**< data RX */ | |
| #define SDMMC_CMD_bmDATARX (0x1 << 2) /**< Bits for data RX */ | |
| #define SDMMC_CMD_TX 0x2 /**< data TX */ | |
| #define SDMMC_CMD_bmDATATX (0x2 << 2) /**< Bits for data TX */ | |
| #define SDMMC_CMD_STOPXFR 0x3 /**< data stop */ | |
| #define SDMMC_CMD_bmSTOPXFR (0x3 << 2) /**< Bits for transfer stop */ | |
| #define SDMMC_CMD_bmRESPMASK (0x7 << 4) /**< Bits masks response option */ | |
| #define SDMMC_CMD_bmRESP(R) (((R)&0x7) << 4) /**< Bits setup response */ | |
| #define SDMMC_CMD_bmCRC (0x1 << 7) /**< CRC is enabled (SPI only) */ | |
| #define SDMMC_CMD_bmOD (0x1 << 8) /**< Open-Drain is enabled (MMC) */ | |
| #define SDMMC_CMD_bmIO (0x1 << 9) /**< IO function */ | |
| #define SDMMC_CMD_bmBUSY (0x1 << 10) /**< Do busy check */ | |
| /** Cmd: Do power on initialize */ | |
| #define SDMMC_CMD_POWERONINIT (SDMMC_CMD_bmPOWERON) | |
| /** Cmd: Data only, read */ | |
| #define SDMMC_CMD_DATARX (SDMMC_CMD_bmDATARX) | |
| /** Cmd: Data only, write */ | |
| #define SDMMC_CMD_DATATX (SDMMC_CMD_bmDATATX) | |
| /** Cmd: Command without data */ | |
| #define SDMMC_CMD_CNODATA(R) ( SDMMC_CMD_bmCOMMAND \ | |
| | SDMMC_CMD_bmRESP(R) ) | |
| /** Cmd: Command with data, read */ | |
| #define SDMMC_CMD_CDATARX(R) ( SDMMC_CMD_bmCOMMAND \ | |
| | SDMMC_CMD_bmDATARX \ | |
| | SDMMC_CMD_bmRESP(R) ) | |
| /** Cmd: Command with data, write */ | |
| #define SDMMC_CMD_CDATATX(R) ( SDMMC_CMD_bmCOMMAND \ | |
| | SDMMC_CMD_bmDATATX \ | |
| | SDMMC_CMD_bmRESP(R) ) | |
| /** Cmd: Send Stop command */ | |
| #define SDMMC_CMD_CSTOP ( SDMMC_CMD_bmCOMMAND \ | |
| | SDMMC_CMD_bmSTOPXFR \ | |
| | SDMMC_CMD_bmRESP(1) ) | |
| /** Cmd: Send Stop token for SPI */ | |
| #define SDMMC_CMD_STOPTOKEN (SDMMC_CMD_bmSTOPXFR) | |
| /** @}*/ | |
| /** Default block size for SD/MMC access */ | |
| #define SDMMC_BLOCK_SIZE 512 | |
| /** @}*/ | |
| /*------------------------------------------------------------------------------ | |
| * Types | |
| *----------------------------------------------------------------------------*/ | |
| /** \addtogroup sdmmc_cmd_types SD/MMC General Types | |
| @{*/ | |
| /** SD/MMC end-of-command callback function. */ | |
| typedef void (*fSdmmcCallback)(uint32_t status, void *pArg); | |
| /** | |
| * Sdmmc command operation settings union. | |
| */ | |
| typedef union _SdmmcCmdOperation { | |
| uint16_t wVal; | |
| struct _SdmmcOpBm { | |
| uint16_t powerON:1, /**< Do power on initialize */ | |
| sendCmd:1, /**< Send SD/MMC command */ | |
| xfrData:2, /**< Send/Stop data transfer */ | |
| respType:3,/**< Response type (1~7) */ | |
| crcON:1, /**< CRC is used (SPI) */ | |
| odON:1, /**< Open-Drain is ON (MMC) */ | |
| ioCmd:1, /**< SDIO command */ | |
| checkBsy:1;/**< Busy check is ON */ | |
| } bmBits; | |
| } uSdmmcCmdOp; | |
| /** | |
| * Sdmmc command instance. | |
| */ | |
| typedef struct _SdmmcCommand { | |
| /** Optional user-provided callback function. */ | |
| fSdmmcCallback fCallback; | |
| /** Optional argument to the callback function. */ | |
| void *pArg; | |
| /** Data buffer, with MCI_DMA_ENABLE defined 1, the buffer can be | |
| * 1, 2 or 4 bytes aligned. It has to be 4 byte aligned if no DMA. | |
| */ | |
| uint8_t *pData; | |
| /** Size of data block in bytes. */ | |
| uint16_t wBlockSize; | |
| /** Number of blocks to be transfered */ | |
| uint16_t wNbBlocks; | |
| /** Response buffer. */ | |
| uint32_t *pResp; | |
| /** Command argument. */ | |
| uint32_t dwArg; | |
| /** Command operation settings */ | |
| uSdmmcCmdOp cmdOp; | |
| /** Command index */ | |
| uint8_t bCmd; | |
| /** Command return status */ | |
| uint8_t bStatus; | |
| } sSdmmcCommand; | |
| /** | |
| * \ingroup sdmmc_hal_def | |
| * SD/MMC Lock device function type */ | |
| typedef uint32_t (*fSdmmcLock)(void* pDrv, uint8_t bSlot); | |
| /** | |
| * \ingroup sdmmc_hal_def | |
| * SD/MMC Release device function type */ | |
| typedef uint32_t (*fSdmmcRelease)(void* pDrv); | |
| /** | |
| * \ingroup sdmmc_hal_def | |
| * SD/MMC Send Command function type */ | |
| typedef uint32_t (*fSdmmcSendCommand)(void* pDrv, sSdmmcCommand *pCmd); | |
| /** | |
| * \ingroup sdmmc_hal_def | |
| * SD/MMC IO Control function type */ | |
| typedef uint32_t (*fSdmmcIOCtrl)(void* pDrv, uint32_t dwCtrl, uint32_t param); | |
| /** | |
| * \ingroup sdmmc_hal_def | |
| * \brief SD/MMC card HAL functions. | |
| */ | |
| typedef struct _SdHalFunctions { | |
| fSdmmcLock fLock; /**< Pointer to lock funtion */ | |
| fSdmmcRelease fRelease; /**< Pointer to release function */ | |
| fSdmmcSendCommand fCommand; /**< Pointer to command function */ | |
| fSdmmcIOCtrl fIOCtrl; /**< Pointer to IO control function */ | |
| } sSdHalFunctions; | |
| /** | |
| * \brief SD/MMC card driver structure. | |
| * It holds the current command being processed and the SD/MMC card address. | |
| */ | |
| typedef struct _SdCard | |
| { | |
| void *pDrv; /**< Pointer to unnderlying driver */ | |
| sSdHalFunctions *pHalf; /**< Pointer to underlying functions */ | |
| void *pExt; /**< Pointer to extension data for SD/MMC/SDIO */ | |
| sSdmmcCommand sdCmd; /**< Command instance for underlying driver */ | |
| uint32_t CID[128/8/4]; /**< Card Identification (CID register) */ | |
| uint32_t CSD[128/8/4]; /**< Card-specific data (CSD register) */ | |
| uint32_t EXT[512/4]; /**< Extended information */ | |
| uint32_t dwTranSpeed; /**< Max supported transfer speed */ | |
| uint32_t dwTotalSize; /**< Card total size | |
| (0xffffffff to see number of blocks */ | |
| uint32_t dwNbBlocks; /**< Card total number of blocks */ | |
| uint16_t wBlockSize; /**< Card block size reported */ | |
| uint16_t wCurrBlockLen; /**< Block length used */ | |
| uint32_t dwCurrSpeed; /**< Transfer speed used */ | |
| uint32_t dwPrevBlk; /**< Previous accessed block for memory */ | |
| uint16_t wAddress; /**< Current card address */ | |
| uint8_t bCardType; /**< SD/MMC/SDIO card type \sa sdmmc_cardtype */ | |
| uint8_t bBusMode; /**< 1/4/8 bit bus mode */ | |
| uint8_t bSlot; /**< Card access slot */ | |
| uint8_t bState; /**< Card state */ | |
| uint8_t bStatus; /**< Card status */ | |
| uint8_t reserve; | |
| } sSdCard; | |
| /** \addtogroup sdmmc_struct_cmdarg SD/MMC command arguments | |
| * Here lists the command arguments for SD/MMC. | |
| * - CMD6 Argument | |
| * - \ref _MmcCmd6Arg "MMC CMD6" | |
| * - \ref _SdCmd6Arg "SD CMD6" | |
| * - \ref _SdioCmd52Arg CMD52 | |
| * - \ref _SdioCmd53Arg CMD53 | |
| * @{*/ | |
| /** | |
| * \typedef MmcCmd6Arg | |
| * Argument for MMC CMD6 | |
| */ | |
| typedef struct _MmcCmd6Arg | |
| { | |
| uint8_t access; | |
| uint8_t index; | |
| uint8_t value; | |
| uint8_t cmdSet; | |
| } MmcCmd6Arg, MmcSwitchArg; | |
| /** | |
| * \typedef SdCmd6Arg | |
| * Argument for SD CMD6 | |
| */ | |
| typedef struct _SdCmd6Arg | |
| { | |
| uint32_t accessMode:4, /**< [ 3: 0] function group 1, access mode */ | |
| command:4, /**< [ 7: 4] function group 2, command system */ | |
| reserveFG3:4, /**< [11: 8] function group 3, 0xF or 0x0 */ | |
| reserveFG4:4, /**< [15:12] function group 4, 0xF or 0x0 */ | |
| reserveFG5:4, /**< [19:16] function group 5, 0xF or 0x0 */ | |
| reserveFG6:4, /**< [23:20] function group 6, 0xF or 0x0 */ | |
| reserved:7, /**< [30:24] reserved 0 */ | |
| mode:1; /**< [31 ] Mode, 0: Check, 1: Switch */ | |
| } SdCmd6Arg, SdSwitchArg; | |
| /** | |
| * \typedef SdioCmd52Arg | |
| * Argument for SDIO CMD52 | |
| */ | |
| typedef struct _SdioCmd52Arg | |
| { | |
| uint32_t data:8, /**< [ 7: 0] data for writing */ | |
| stuff0:1, /**< [ 8] reserved */ | |
| regAddress:17, /**< [25: 9] register address */ | |
| stuff1:1, /**< [ 26] reserved */ | |
| rawFlag:1, /**< [ 27] Read after Write flag */ | |
| functionNum:3, /**< [30:28] Number of the function */ | |
| rwFlag:1; /**< [ 31] Direction, 1:write, 0:read. */ | |
| } SdioCmd52Arg, SdioRwDirectArg; | |
| /** | |
| * \typedef SdioCmd53Arg | |
| * Argument for SDIO CMD53 | |
| */ | |
| typedef struct _SdioCmd53Arg { | |
| uint32_t count:9, /**< [ 8: 0] Byte mode: number of bytes to transfer, | |
| 0 cause 512 bytes transfer. | |
| Block mode: number of blocks to transfer, | |
| 0 set count to infinite. */ | |
| regAddress:17, /**< [25: 9] Start Address I/O register */ | |
| opCode:1, /**< [ 26] 1:Incrementing address, 0: fixed */ | |
| blockMode:1, /**< [ 27] (Optional) 1:block mode */ | |
| functionNum:3, /**< [30:28] Number of the function */ | |
| rwFlag:1; /**< [ 31] Direction, 1:WR, 0:RD */ | |
| } SdioCmd53Arg, SdioRwExtArg; | |
| /** @}*/ | |
| /** \addtogroup sdmmc_resp_struct SD/MMC Responses Structs | |
| * Here lists the command responses for SD/MMC. | |
| * - \ref _SdmmcR1 "R1" | |
| * - \ref _SdmmcR3 "R3" | |
| * - \ref _MmcR4 "MMC R4", \ref _SdioR4 "SDIO R4" | |
| * - \ref _SdmmcR5 "R5" | |
| * - \ref _SdR6 "R6" | |
| * - \ref _SdR7 "R7" | |
| * @{*/ | |
| /** | |
| * Response R1 (normal response command) | |
| */ | |
| typedef struct _SdmmcR1 | |
| { | |
| uint32_t cardStatus; /**< [32: 0] Response card status flags */ | |
| } SdmmcR1, SdmmcR1b; | |
| /** | |
| * Response R3 (OCR) | |
| */ | |
| typedef struct _SdmmcR3 | |
| { | |
| uint32_t OCR; /**< [32: 0] OCR register */ | |
| } SdmmcR3; | |
| /** | |
| * Response R4 (MMC Fast I/O CMD39) | |
| */ | |
| typedef struct _MmcR4 | |
| { | |
| uint32_t regData:8, /**< [ 7: 0] Read register contents */ | |
| regAddr:7, /**< [14: 8] Register address */ | |
| status:1, /**< [ 15] Status */ | |
| RCA:16; /**< [31:16] RCA */ | |
| } MmcR4; | |
| /** | |
| * Response R4 (SDIO), no CRC. | |
| */ | |
| typedef struct _SdioR4 | |
| { | |
| uint32_t OCR:24, /**< [23: 0] Operation Conditions Register */ | |
| reserved:3, /**< [26:24] Reserved */ | |
| memoryPresent:1, /**< [ 27] MP Set to 1 if contains | |
| SD memory */ | |
| nbIoFunction:3, /**< [30:28] NF Total number of I/O functions | |
| supported */ | |
| C:1; /**< [ 31] IORDY Set to 1 if card is ready */ | |
| } SdioR4; | |
| /** | |
| * Response R5 (MMC Interrupt request CMD40 / SDIO CMD52) | |
| */ | |
| typedef struct _SdmmcR5 | |
| { | |
| uint32_t data:8, /**< [ 7: 0] Response data */ | |
| response:8, /**< [15: 8] Response status flags */ | |
| RCA:16; /**< [31:16] (MMC) Winning card RCA */ | |
| } SdmmcR5; | |
| /** | |
| * Response R6 (SD RCA) | |
| */ | |
| typedef struct _SdR6 | |
| { | |
| uint32_t status:16, /**< [15: 0] Response status */ | |
| RCA:16; /**< [31:16] New published RCA */ | |
| } SdR6; | |
| /** | |
| * Response R7 (Card interface condition) | |
| */ | |
| typedef struct _SdR7 { | |
| uint32_t checkPatten:8, /**< [ 7: 0] Echo-back of check pattern */ | |
| voltage:4, /**< [11: 8] Voltage accepted */ | |
| reserved:20; /**< [31:12] reserved bits */ | |
| } SdR7; | |
| /** @}*/ | |
| /** @}*/ | |
| /*---------------------------------------------------------------------------- | |
| * Exported functions | |
| *----------------------------------------------------------------------------*/ | |
| /**@}*/ | |
| #endif /* #define _SDMMC_CMD_H */ | |