GitHub/qpcpp
1
0
Fork 0
mirror of https://github.com/QuantumLeaps/qpcpp.git synced 2025-02-04 06:13:00 +08:00
Code Issues Projects Releases Wiki Activity
qpcpp/examples/tms320c55x/c55xx_csl/inc/csl_sdio.h

2128 lines
77 KiB
C
Raw Normal View History

4.5.01
2012-08-14 18:00:48 -04:00
/* ===========================================================================
* Copyright (c) Texas Instruments Inc 2002, 2003, 2004, 2005, 2008
*
* Use of this software is controlled by the terms and conditions found in
* the license agreement under which this software has been supplied.
* ===========================================================================
*/
/** @defgroup CSL_SDIO_API SDIO
*
* @section Introduction
*
* @subsection xxx Purpose and Scope
* SDIO CSL provides a set of APIs to utilize the SDIO functionality provided
* C5515/C5505 DSP Hw controller. Hw devices that uses SDIO CSL should be
* compliant to SDIO specification. SDIO specification is the extension for
* the SD card specification.
*
* @subsection References
*
* TMS320VC5505 MMCSD DRAFT USERS GUIDE.pdf
*/
/** @file csl_sdio.h
*
* @brief Functional layer API header file for SDIO CSL
*
* Path: \(CSLPATH)\ inc
*/
/* ============================================================================
* Revision History
* ================
* 21-Dec-2009 Created
* 25-Jan-2009 Formatted the code
* ============================================================================
*/
#ifndef _CSL_SDIO_H_
#define _CSL_SDIO_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <soc.h>
#include <csl_types.h>
#include <csl_error.h>
#include <tistdtypes.h>
/**
\defgroup CSL_SDIO_API SDIO
*/
/**
@defgroup CSL_SDIO_SYMBOL SDIO Symbols Defined
@ingroup CSL_SDIO_API
*/
/**
@defgroup CSL_SDIO_DATASTRUCT SDIO Data Structures
@ingroup CSL_SDIO_API
*/
/**
@defgroup CSL_SDIO_ENUM SDIO Enumerated Data Types
@ingroup CSL_SDIO_API
*/
/**
@defgroup CSL_SDIO_FUNCTION SDIO Functions
@ingroup CSL_SDIO_API
*/
/**
@defgroup CSL_SDIOC_INLINE_FUNCTION SDIO Inline Functions
@ingroup CSL_SDIO_API
*/
/*****************************************************************************\
SDIO global macro declarations
\*****************************************************************************/
/** \addtogroup CSL_SDIO_SYMBOL
* @{ */
/** Stuff bits used to fill the command argument */
#define CSL_SDIO_STUFF_BITS (0x0000)
/** Reset SDIO bit field */
#define CSL_SDIO_RESET (0x1u)
/** Reset count for SDIO */
#define CSL_SDIO_RESET_COUNT (0x20u)
/** Time delay */
#define CSL_SDIO_DELAY_TIME (100u)
/** Time out duration for response */
#define CSL_SDIO_RESPONSE_TIMEOUT (0xFFFFu)
/** Time out duration for command retries during card initialization */
#define CSL_SDIO_INIT_TIMEOUT (0xFFFFu)
/** Time out duration for data read/write */
#define CSL_SDIO_DATA_RW_TIMEOUT (0xFFFFu)
/** SDIO command retry count during card detection and initialization */
#define CSL_SDIO_CMD_RETRY_COUNT (500u)
/** Minimum clock division for which both card can respond */
#define CSL_SDIO_CLK_DIV_INIT (70u)
/** This bit is used to check whether the card is in busy state */
#define CSL_SDIO_BUSY_STATE (0x01u)
/** This bit is used to check whether the FIFO is empty */
#define CSL_SDIO_FIFO_EMPTY (0x20u)
/** This bit is used to check whether the card has responded to a command */
#define CSL_SDIO_RESP_DONE (0x04u)
/** Bits that are used to check whether data can be read from the card */
#define CSL_SDIO_READ_READY (0x0400u)
/** Bits that are used to check whether data can be written to the card */
#define CSL_SDIO_WRITE_READY (0x0200u)
/** RCA value to deselect the SDIO card */
#define CSL_SDIO_CARD_DESELECT_RCA (0)
/** Macro to compare the NULL values */
#define CSL_SDIO_NULL (0)
/** Recommended value for command 0 */
#define CSL_SDIO_CMD_0 (0x0000u)
/** Recommended value for command 2 */
#define CSL_SDIO_CMD_2 (0x0402u)
/** Recommended value for command 3 */
#define CSL_SDIO_CMD_3 (0x0203u)
/** Recommended value for command 5 */
#define CSL_SDIO_CMD_5 (0x0605u)
/** Recommended value for command 7 */
#define CSL_SDIO_CMD_7 (0x0307u)
/** Recommended value for command 8 */
#define CSL_SDIO_CMD_8 (0x0208u)
/** Recommended value for command 41 */
#define CSL_SDIO_CMD_41 (0x0629u)
/** Recommended value for command 55 */
#define CSL_SDIO_CMD_55 (0x0237u)
/** Recommended value for command 53 for read operation */
#define CSL_SDIO_CMD_53_READ (0x2235u)
/** Recommended value for command 53 for write operation */
#define CSL_SDIO_CMD_53_WRITE (0x2A35u)
/** Recommended value for command 52 */
#define CSL_SDIO_CMD_52 (0x0234u)
/** Argument value for SDIO command 8 */
#define CSL_SDIO_CMD_8_ARG (0x1AAu)
/** Argument value for SDIO command 41 for standard capacity cards */
#define CSL_SDIO_CMD_41_ARG (0x00ff8000)
/** Argument value for SDIO command 41 for high capacity cards */
#define CSL_SDIO_CMD_41_HCS_ARG (0x40ff8000)
/** SDIO response for ACMD41 */
#define CSL_SDIO_CMD41_RESP (0x80FF8000u)
/** SDIO response for SDHC card */
#define CSL_SDIO_SDHC_RESP (0x40000000u)
/** Error code to indicate IO portion of the SDIO card is not ready */
#define CSL_ESDIO_IO_NOTREADY (0x101u)
/** Error code to indicate Memory portion of the SDIO card is not ready */
#define CSL_ESDIO_MEM_NOTREADY (0x102u)
/** SDIO read FIFO level in bytes */
#define CSL_SDIO_READ_FIFO_LEVEL (32u)
/** SDIO write FIFO level in bytes */
#define CSL_SDIO_WRITE_FIFO_LEVEL (32u)
/** Macro to shift 16 bit word */
#define CSL_SDIO_SHIFT_WORD (16u)
/** Macro to mask 16 bit word */
#define CSL_SDIO_MASK_WORD (0xFFFFu)
/** Macro to shift a byte */
#define CSL_SDIO_SHIFT_BYTE (8u)
/** Macro to mask a byte */
#define CSL_SDIO_MASK_BYTE (0xFFu)
/** Mask value for mmc interrupt enable register */
#define CSL_SDIO_MMCIM_REG_MASK (0x1FFFu)
/** Maximum number of bytes that can be read using CMD53 in byte mode */
#define CSL_SDIO_MAX_BYTE_COUNT (512u)
/** Maximum number of IO functions that are supported by SDIO specification */
#define CSL_SDIO_MAX_FUNCTION_COUNT (7u)
/** Maximum size of an data transfer block supported by SDIO specification */
#define CSL_SDIO_MAX_BLOCK_SIZE (2048u)
/** Maximum number of an data blocks supported by SDIO specification */
#define CSL_SDIO_MAX_BLOCK_COUNT (511u)
/** SDIO maximum clock rate value */
#define CSL_SDIO_MAX_CLKRATE (0xFFu)
/** Macro to perform a left shift operation on a value */
#define CSL_SDIO_LSHIFT(val, shift) ((Uint32)val << shift)
/** Macro to perform a right shift operation on a value */
#define CSL_SDIO_RSHIFT(val, shift) (val >> shift)
/** Macro to set bit position for register address field in CMD52 and CMD53 */
#define CSL_SDIO_REGADDR(regAddr) CSL_SDIO_LSHIFT(regAddr, 9)
/** Macro to set bit position for read after write flag in CMD52 */
#define CSL_SDIO_RAWFLAG(rawFlag) CSL_SDIO_LSHIFT(rawFlag, 27)
/** Macro to set bit position for function number field in CMD52 and CMD53 */
#define CSL_SDIO_FUNNUM(funNum) CSL_SDIO_LSHIFT(funNum, 28)
/** Macro to set bit position for read/write flag in CMD52 and CMD53 */
#define CSL_SDIO_RWFLAG(rwFlag) CSL_SDIO_LSHIFT(rwFlag, 31)
/** Macro to set bit position for opcode field in CMD53 */
#define CSL_SDIO_OPCODE(opCode) CSL_SDIO_LSHIFT(opCode, 26)
/** Macro to set bit position for block mode field in CMD53 */
#define CSL_SDIO_BLKMODE(blkMode) CSL_SDIO_LSHIFT(blkMode, 27)
/** Macro to make 32 bit argument for CMD52 for write operation */
#define CSL_SDIO_MAKE_CMD52_WRITE_ARG(wrData, regAddr, rawFlag, funNum, rwFlag)\
(wrData | \
CSL_SDIO_REGADDR(regAddr) | \
CSL_SDIO_RAWFLAG(rawFlag) | \
CSL_SDIO_FUNNUM(funNum) | \
CSL_SDIO_RWFLAG(rwFlag))
/** Macro to make 32 bit argument for CMD52 for read operation */
#define CSL_SDIO_MAKE_CMD52_READ_ARG(regAddr, rawFlag, funNum, rwFlag) \
(CSL_SDIO_REGADDR(regAddr) | \
CSL_SDIO_RAWFLAG(rawFlag) | \
CSL_SDIO_FUNNUM(funNum) | \
CSL_SDIO_RWFLAG(rwFlag))
/** Macro to make 32 bit argument for CMD53 */
#define CSL_SDIO_MAKE_CMD53_ARG(count, regAddr, opCode, blkMode, funNum, rwFlag)\
(count | \
CSL_SDIO_REGADDR(regAddr) | \
CSL_SDIO_OPCODE(opCode) | \
CSL_SDIO_BLKMODE(blkMode) | \
CSL_SDIO_FUNNUM(funNum) | \
CSL_SDIO_RWFLAG(rwFlag))
/** Macro to read ocr value from CMD5 response */
#define CSL_SDIO_GET_OCR(resp) (resp & 0xFFFFFF)
/** Macro to read mem field value from CMD5 response */
#define CSL_SDIO_GET_MEM(resp) (CSL_SDIO_RSHIFT(resp, 27) & 0x01)
/** Macro to read function count field value from CMD5 response */
#define CSL_SDIO_GET_FUNCNT(resp) (CSL_SDIO_RSHIFT(resp, 28) & 0x07)
/** Macro to read c field value from CMD5 response */
#define CSL_SDIO_GET_C(resp) (CSL_SDIO_RSHIFT(resp, 31) & 0x01)
/**
@} */
/*****************************************************************************\
SDIO global typedef declarations
\*****************************************************************************/
/**\addtogroup CSL_SDIO_ENUM
@{*/
/**
* \brief Hardware Instance Id to select SDIO controller registers
*/
typedef enum {
CSL_SDIO_INST0, /**< SDIO instance number 0 */
CSL_SDIO_INST1, /**< SDIO instance number 1 */
CSL_SDIO_INST_INV
} CSL_SdioInstId;
/**
* \brief Response type from SDIO card
*
* Depending on the command value sent to the card, the card responds with
* different response values.The type of response is defined in the structure.
*/
typedef enum {
CSL_SDIO_RESPTYPE_NO, /**< Command response is None */
CSL_SDIO_RESPTYPE_R1, /**< Command response is R1 */
CSL_SDIO_RESPTYPE_R2, /**< Command response is R2 */
CSL_SDIO_RESPTYPE_R3, /**< Command response is R3 */
CSL_SDIO_RESPTYPE_R4, /**< Command response is R4 */
CSL_SDIO_RESPTYPE_R5, /**< Command response is R5 */
CSL_SDIO_RESPTYPE_R6 /**< Command response is R6 */
} CSL_SdioRespType;
/**
* \brief Response busy signal from the card.
*/
typedef enum {
CSL_SDIO_RESPBUSY_NO, /**< No busy signal during the response */
CSL_SDIO_RESPBUSY_YES /**< Busy signal during the response */
} CSL_SdioRespBusy;
/**
* \brief Type of card that is inserted
*
*/
typedef enum
{
CSL_SDIO_CARD_NONE = 0,
/**< No card detected */
CSL_SDIO_IO_CARD,
/**< SD IO only card is detected - No memory */
CSL_SDIO_COMBO_CARD,
/**< SDIO combo card is detected - both IO and memory */
CSL_SDIO_INVALID_CARD
/**< SDIO card inserted is as invalid/unusable card */
} CSL_SdioCardType;
/**
* \brief SDIO event responses
*
*/
typedef enum {
CSL_SDIO_EVENT_EOFCMD = (1U << 2U),
/**< for commands with response, an end of
* Command + Response; for commands without response,
* an end of Command */
CSL_SDIO_EVENT_READ = (1U << 10U),
/**< data available with controller for reading */
CSL_SDIO_EVENT_WRITE = (1U << 9U),
/**< data required by controller for writing */
CSL_SDIO_EVENT_ERROR_CMDCRC = (1U << 7U),
/**< Error detected in the CRC during command
response phase */
CSL_SDIO_EVENT_ERROR_DATACRC = ((1U << 6U)|(1 << 5U)),
/**< Error detected in the CRC during data transfer */
CSL_SDIO_EVENT_ERROR_CMDTIMEOUT = ((1U) << (4U)),
/**< Timeout detected during command - response phase */
CSL_SDIO_EVENT_ERROR_DATATIMEOUT = ((1U) << (3U)),
/**< Timeout detected during data transfer */
CSL_SDIO_EVENT_CARD_EXITBUSY = ((1U) << (1U)),
/**< Card has exited busy state */
CSL_SDIO_EVENT_BLOCK_XFERRED = 1U
/**< block transfer done */
} CSL_SdioCardRespEvent;
/**
*\brief
* Enum variable for the selection of SDIO events.
*/
typedef enum
{
CSL_SDIO_EDATDNE_INTERRUPT,
/**< Data done (DATDNE) interrupt enable. */
CSL_SDIO_EBSYDNE_INTERRUPT,
/**< Busy done (BSYDNE) interrupt enable. */
CSL_SDIO_ERSPDNE_INTERRUPT,
/**< Command/response done (RSPDNE) interrupt enable. */
CSL_SDIO_ETOUTRD_INTERRUPT,
/**< Read-data time-out event (TOUTRD) interrupt enable. */
CSL_SDIO_ETOUTRS_INTERRUPT,
/**< Response time-out event (TOUTRS) interrupt enable. */
CSL_SDIO_ECRCWR_INTERRUPT,
/**< Write-data CRC error (CRCWR) interrupt enable. */
CSL_SDIO_ECRCRD_INTERRUPT,
/**< Read-data CRC error (CRCRD) interrupt enable. */
CSL_SDIO_ECRCRS_INTERRUPT,
/**< Response CRC error (CRCRS) interrupt enable. */
CSL_SDIO_RSV_BIT,
/**< this bit is reserved. */
CSL_SDIO_EDXRDY_INTERRUPT,
/**< Data transmit register (MMCDXR) ready interrupt enable. */
CSL_SDIO_EDRRDY_INTERRUPT,
/**< Data receive register ready (DRRDY) interrupt enable. */
CSL_SDIO_EDATED_INTERRUPT,
/**< DAT3 edge detect (DATED) interrupt enable. */
CSL_SDIO_ETRNDNE_INTERRUPT,
/**< Transfer done (TRNDNE) interrupt enable. */
CSL_SDIO_MMCIM_ALL_INTERRUPT,
/**< All interrupts in MMCIM register */
CSL_SDIO_READWAIT_INTERRUPT,
/**< SDIO read wait interrupt */
CSL_SDIO_CARD_INTERRUPT,
/**< SDIO card interrupt */
CSL_SDIO_SDIOIEN_ALL_INTERRUPT
/**< All interrupts in SDIOIEN register */
} CSL_SdioEventType;
/**
* \brief
* Enum variable for the selection of SDIO interrupt status.
*/
typedef enum
{
CSL_SDIO_READWAIT_INTR_ENABLE,
/**< Enable SDIO read wait interrupt */
CSL_SDIO_READWAIT_INTR_DISABLE,
/**< Disable SDIO read wait interrupt */
CSL_SDIO_CARD_INTR_ENABLE,
/**< Enable SDIO card interrupt */
CSL_SDIO_CARD_INTR_DISABLE,
/**< Disable SDIO card interrupt */
CSL_SDIO_ALL_INTR_ENABLE,
/**< Enable both read wit and SDIO card interrupts */
CSL_SDIO_ALL_INTR_DISABLE
/**< Disable both read wit and SDIO card interrupts */
} CSL_SdioIntrStatus;
/**
* \brief SDIO endianness
*
* This enum holds the values to set endianness of the SDIO controller
*/
typedef enum {
CSL_SDIO_ENDIAN_LITTLE = 0U, /**< Little endian mode configuration */
CSL_SDIO_ENDIAN_BIG = 1U /**< Big endian mode configuration */
} CSL_SdioEndianMode;
/**
* \brief Error type as received by the SDIO controller on response for a command
*/
#define CSL_SDIO_EVENT_ERROR (CSL_SDIO_EVENT_ERROR_CMDCRC | \
CSL_SDIO_EVENT_ERROR_DATACRC | \
CSL_SDIO_EVENT_ERROR_CMDTIMEOUT | \
CSL_SDIO_EVENT_ERROR_DATATIMEOUT)
/**
* \brief Error type for command response timeout and CRC error
*/
#define CSL_SDIO_CMD_TOUT_CRC_ERROR (CSL_SDIO_EVENT_ERROR_CMDCRC | \
CSL_SDIO_EVENT_ERROR_CMDTIMEOUT)
/**
* \brief Error type for data timeout and CRC error
*/
#define CSL_SDIO_DATA_TOUT_CRC_ERROR (CSL_SDIO_EVENT_ERROR_DATACRC | \
CSL_SDIO_EVENT_ERROR_DATATIMEOUT)
/**
@} */
/**
\addtogroup CSL_SDIO_DATASTRUCT
@{*/
/**
* \brief Response array received from the controller
*
* This object holds the information the response that is received for a command
* sent to the card.
*/
typedef struct {
Uint16 respBuf[8];
/**< The response will interpreted as:
* respBuf[0] - R2[15:0]
* respBuf[1] - R2[31:16]
* respBuf[2] - R2[47:32]
* respBuf[3] - R2[63:48]
* respBuf[4] - R2[79:64]
* respBuf[5] - R2[95:80]
* respBuf[6] - R2[111:96] or R1/R1B/R3/R4/R5/R6[23:8]
* respBuf[7] - R2[127:112] or R1/R1B/R3/R4/R5/R6[39:24]
* */
} CSL_SdioResponse;
/**
* \brief SDIo config structure for setting SDIO Control register.
*
*/
typedef struct {
Uint16 mmcctl; /**< MMCSD control register value */
Uint16 mmcclk; /**< MMCSD clock control register value */
Uint16 mmcim; /**< Required interrupt field for MMCSD */
Uint16 mmctor; /**< mmc response time out register */
Uint16 mmctod; /**< mmc data read time out register */
Uint16 mmcblen; /**< Number of bytes in a block of mmc or sd card */
Uint16 mmcnblk; /**< Total no of blocks for read or write */
Uint16 mmcfifoctl; /**< FIFO control register */
Uint16 sdioctl; /**< SDIO control register */
Uint16 sdioien; /**< SDIO interrupt enable register */
} CSL_SdioConfig;
/**
* \brief structure for card specific information.
*
*/
typedef struct {
Uint16 rca; /**< User assigned relative card address */
Uint32 ocr; /**< OCR value read from the card */
Uint8 funCount; /**< Number of IO functions on the card */
Bool cardReady; /**< Flag to indicate card is ready or not */
Bool cardActive; /**< Flag to indicate card is active or not*/
Bool sdHcDetected;/**< Flag to indicate high capacity card */
CSL_SdioCardType sdioCardType;/**< SDIO card type */
} CSL_SdioCardObj;
/**
* \brief structure for card specific information.
*
*/
typedef struct {
CSL_MmcsdRegsOvly sdioRegs; /**< Pointer to Hw regs structure */
CSL_SdioCardObj *pSdioCardObj; /**< Card Object structure pointer */
CSL_SdioEndianMode readEndianMode; /**< Endian mode for read operation */
CSL_SdioEndianMode writeEndianMode;/**< Endian mode for write operation */
Bool cmd8Resp; /**< Response status for CMD8 */
} CSL_SdioControllerObj;
/**
* \brief SDIO Handle
*
*/
typedef CSL_SdioControllerObj *CSL_SdioHandle;
/**
@} */
/*****************************************************************************\
* CSL SDIO function declarations *
\*****************************************************************************/
/** @addtogroup CSL_SDIO_FUNCTION
@{ */
/** ===========================================================================
* @n@b SDIO_init
*
* @b Description
* @n This is the initialization function for the SDIO CSL. The function
* must be called before calling any other API from this CSL. This
* function is for enabling the clock to the SDIO Controller.
* This function should be called only once during system initialization
* time. This function gates the clock for the two MMCSD modules.
* Application programs may disable the clocks for MMCSD module which is
* not in use.
*
* NOTE: Calling this function is not required if MMC_init is called since
* both functions use the same MMCSD controller
*
* @b Arguments
* @verbatim
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Always returns
*
* <b> Pre Condition </b>
* @n This should be called before calling any other SDIO Function.
*
* <b> Post Condition </b>
* @n Enables clock for MMCSD controller
*
* @b Modifies
* @n None
*
* @b Example
* @verbatim
CSL_status status;
status = SDIO_init();
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_init (void);
/** ===========================================================================
* @n@b SDIO_open
*
* @b Description
* @n This function opens the CSL SDIO module and returns handle to the
* SDIO object structure.
*
* NOTE: THIS API SETS THE ENDIAN MODE OF SDIO READ AND WRITE OPERATIONS
* TO LITTLE ENDIAN. USE SDIO_setEndianMode() TO CHANGE ENDIAN MODE.
*
* @b Arguments
* @verbatim
pSdioContObj SDIO Controller object structure
instId Instance number for SDIO
status Status of the function
@endverbatim
*
* <b> Return Value </b> CSL_SdioHandle
* @n Valid SDIO handle will be returned if
* status value is equal to CSL_SOK.
*
* <b> Pre Condition </b>
* @n SDIO_init() API should be called before SDIO_open().
*
* <b> Post Condition </b>
* @n 1. The status is returned in the status variable. If status
* returned is
* @li CSL_SOK - Valid SDIO handle is returned
* @li CSL_ESYS_INVPARAMS - Resource is already in use
* @n 2. CSL_SdioObj object structure is populated
*
* @b Modifies
* @n 1. Status variable
* @n 2. CSL_SdioObj object structure
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
...
@endverbatim
* ===========================================================================
*/
CSL_SdioHandle SDIO_open (CSL_SdioControllerObj *pSdioContObj,
CSL_SdioInstId instId,
CSL_Status *status);
/** ===========================================================================
* @n@b SDIO_close
*
* @b Description
* @n This function closes the specified handle to SDIO.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Close successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
*
* <b> Pre Condition </b>
* @n SDIO_open() API should be called successfully before this function.
*
* <b> Post Condition </b>
* @n None
*
* @b Modifies
* @n SDIO handle
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_close(hSdio);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_close(CSL_SdioHandle hSdio);
/** ===========================================================================
* @n@b SDIO_config
*
* @b Description
* @n This function configures the SDIO controller hardware registers.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
pSdioConfig Pointer to the SDIO config Parameter.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESYS_INVPARAMS - Invalid Parameter
*
* <b> Pre Condition </b>
* @n SDIO_open() API should be called before this function.
*
* <b> Post Condition </b>
* @n None
*
* @b Modifies
* @n SDIO Registers.
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
CSL_SdioConfig sdioConfig;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
// Initialize SDIO configuration structure
sdioConfig.mmcctl = .... ;
...
...
sdioConfig.sdioien = .... ;
// Configure SDIO
status = SDIO_config(hSdio, &sdioConfig);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_config(CSL_SdioHandle hSdio,
CSL_SdioConfig *pSdioConfig);
/** ===========================================================================
* @n@b SDIO_detectCard
*
* @b Description
* @n This function is used to detect type of the SDIO card inserted. This
* function sends SDIO specification defined command sequence to detect
* type of the card. Type of the card shall be populated in pSdioCardObj.
* This function also populates other fields of card object structure.
* Address pointed by 'pSdioCardObj' should be global structure variable
* which persists till end of the program since it is stored by SDIO CSL
* for reference in other APIs. This API returns success only incase of
* SDIO card inserted into the MMC/SD slot of the EVM. For the SDIO cards
* which returns OCR value as 0, card type will be set to
* 'CSL_SDIO_INVALID_CARD'. Application/Driver programs should validate
* card type and ocr value updated in the card object structure to
* proceed further.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
pSdioCardObj Pointer to SDIO card object structure
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESYS_INVPARAMS - Invalid Parameter
* @li CSL_ESYS_FAIL - Card detection failed
* @li CSL_ESDIO_TIMEOUT - Card Response time out
* @li CSL_ESDIO_CRCERR - Response/Data CRC Error
*
* <b> Pre Condition </b>
* @n SDIO_open() API should be called before this function.
*
* <b> Post Condition </b>
* @n None
*
* @b Modifies
* @n pSdioCardObj
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
CSL_SdioCardObj sdioCardObj;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_detectCard(hSdio, &sdioCardObj);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_detectCard(CSL_SdioHandle hSdio,
CSL_SdioCardObj *pSdioCardObj);
/** ===========================================================================
* @n@b SDIO_initCard
*
* @b Description
* @n This function is used to initialize the SDIO card inserted. This
* function sends SDIO specification defined command sequence to initialize
* the SDIO card. Proper OCR value should be sent to this function based
* on the OCR value received from the card during card detection.
* SDIO card shall be ready to use after successful execution of this
* function. This function also supports initializing memory portion of
* the COMBO SDIO card. Parameter 'initMem' is useful to select(initMem = 1)
* or skip(initMem = 0) the initialization of COMBO SDIO cards.
* This function returns with error incase of IO portion or memory(COMBO)
* portion of the card is not ready.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
OpCondReg Operation Conditions Regsiter(OCR) value
initMem Flag to select/skip memory initialization
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESDIO_TIMEOUT - Card Response time out
* @li CSL_ESDIO_CRCERR - Response/Data CRC Error
* @li CSL_ESDIO_IO_NOTREADY - Card IO is not ready
* @li CSL_ESDIO_MEM_NOTREADY - Card memory is not ready
*
* <b> Pre Condition </b>
* @n SDIO_detectCard() API should be called before this function.
*
* <b> Post Condition </b>
* @n Initializes SDIO card
*
* @b Modifies
* @n SDIO card registers
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
CSL_SdioCardObj sdioCardObj;
Uint32 ocr;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_detectCard(hSdio, &sdioCardObj);
status = SDIO_initCard(hSdio, ocr, TRUE);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_initCard(CSL_SdioHandle hSdio,
Uint32 OpCondReg,
Bool initMem);
/** ===========================================================================
* @n@b SDIO_resetCard
*
* @b Description
* @n This function is used to reset the SDIO card. This function uses CMD52
* to reset SDIO card. After execution of this function SDIO card will
* not receive any commands except CMD5.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESDIO_TIMEOUT - Card Response time out
* @li CSL_ESDIO_CRCERR - Response/Data CRC Error
*
* <b> Pre Condition </b>
* @n SDIO_open() API should be called before this function.
*
* <b> Post Condition </b>
* @n Resets SDIO card
*
* @b Modifies
* @n SDIO card registers
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_resetCard(hSdio);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_resetCard(CSL_SdioHandle hSdio);
/** ===========================================================================
* @n@b SDIO_getRca
*
* @b Description
* @n This function is used to read new relative card address from the card.
* This function sends CMD3 and reads relative card address. RCA read from
* the card will be populated to the pRCardAddr and card object structure
* in SDIO handle.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
pRCardAddr Relative card address.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESYS_INVPARAMS - Invalid Parameter
* @li CSL_ESDIO_TIMEOUT - Card Response time out
* @li CSL_ESDIO_CRCERR - Response/Data CRC Error
*
* <b> Pre Condition </b>
* @n 1:SDIO_open() API should be called successfully.
* @n 2:SDIO_initCard() API should be called.
*
* <b> Post Condition </b>
* @n None
*
* @b Modifies
* @n pRCardAddr variable will be populated.
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
Uint16 rca;
Uint32 ocr;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_initCard(hSdio, ocr, TRUE);
status = SDIO_getRca(hSdio, &rca);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_getRca(CSL_SdioHandle hSdio,
Uint16 *pRCardAddr);
/** ===========================================================================
* @n@b SDIO_deselectCard
*
* @b Description
* @n This function is used to deselect SDIO which has been selected earlier.
* CMD7 shall be sent to the SDIO card with the relative card address set
* to 0x0000.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESDIO_TIMEOUT - Card Response time out
* @li CSL_ESDIO_CRCERR - Response/Data CRC Error
*
* <b> Pre Condition </b>
* @n 1:SDIO_open() API should be called successfully.
* @n 2:SDIO_initCard() API should be called.
* @n 3:Card should be active
*
* <b> Post Condition </b>
* @n Deselects the SDIO card
*
* @b Modifies
* @n None
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
CSL_SdioCardObj sdioCardObj;
Uint32 ocr;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_detectCard(hSdio, &sdioCardObj);
status = SDIO_initCard(hSdio, ocr, TRUE);
status = SDIO_deselectCard(hSdio);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_deselectCard(CSL_SdioHandle hSdio);
/** ===========================================================================
* @n@b SDIO_selectCard
*
* @b Description
* @n This function is used to select SDIO card. CMD7 shall be sent to the
* SDIO card along with the relative card address to select the card.
* RCA value should be the one published by the card. Sending CMD7
* with invalid RCA will put the card into standby/disabled state.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
rca Relative card address.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESYS_INVPARAMS - Invalid Parameter
* @li CSL_ESDIO_TIMEOUT - Card Response time out
* @li CSL_ESDIO_CRCERR - Response/Data CRC Error
*
* <b> Pre Condition </b>
* @n 1:SDIO_open() API should be called successfully.
* @n 2:SDIO_initCard() API should be called.
*
* <b> Post Condition </b>
* @n Selects the SDIO card
*
* @b Modifies
* @n rca
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
Uint16 rca;
Uint32 ocr;
CSL_SdioCardObj sdioCardObj;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_detectCard(hSdio, &sdioCardObj);
rca = sdioCardObj.rca;
status = SDIO_initCard(hSdio, ocr, TRUE);
status = SDIO_selectCard(hSdio, rca);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_selectCard(CSL_SdioHandle hSdio,
Uint16 rca);
/** ===========================================================================
* @n@b SDIO_sendCommand
*
* @b Description
* @n This function is used to send commands to the SDIO card. This function
* sends given command to the card and waits for the response.
* Lower 16 bits of the parameter 'cmd' should contain the command that
* needs to be written to MMCCMD1 register. Upper 16 bits of the 'cmd'
* should contain the data that needs to be written to MMCCMD2 register.
*
* NOTE:SETTING THE MMCCMD2 VALUE TO '1' IS ALLOWED ONLY FOR DATA WRITE
* COMMANDS THAT USES DMA FOR DATA TRANSFER. FOR OTHER COMMANDS UPPER
* 16 BITS OF 'CMD' SHOULD ALWAYS BE ZERO.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
cmd MMCCMD1 and MMCCMD2 register value.
arg Command argument.
respTimeout Timeout value for the response.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESDIO_TIMEOUT - Card Response time out
* @li CSL_ESDIO_CRCERR - Response/Data CRC Error
*
* <b> Pre Condition </b>
* @n SDIO_open() API should be called successfully.
*
* <b> Post Condition </b>
* @n Sends command to the card
*
* @b Modifies
* @n Card Command registers
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
Uint32 cmd;
Uint32 arg;
Uint16 respTimeout;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
//Send Command 5
cmd = 0x205;
arg = 0;
respTimeout = 0xFFFF;
status = SDIO_sendCommand(hSdio, cmd, arg, respTimeout);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_sendCommand(CSL_SdioHandle hSdio,
Uint32 cmd,
Uint32 arg,
Uint16 respTimeout);
/** ===========================================================================
* @n@b SDIO_getResponse
*
* @b Description
* @n This function is used to read the response registers. This function
* reads response registers based on the response type and populates the
* response structure. Response registers are not cleared by this function.
*
*\n Response type Response bits Resp buf Fields populated
*\n ============== ============ =========================
*\n R1,R3,R4,R5,R6 [23:8] pResponse->respBuf[6]
*\n [39:24] pResponse->respBuf[7]
*\n
*\n R2 [15:0] pResponse->respBuf[0]
*\n [31:16] pResponse->respBuf[1]
*\n [47:32] pResponse->respBuf[2]
*\n [63:48] pResponse->respBuf[3]
*\n [79:64] pResponse->respBuf[4]
*\n [95:80] pResponse->respBuf[5]
*\n [111:96] pResponse->respBuf[6]
*\n [127:112] pResponse->respBuf[7]
*
*
* NOTE: IF RESPONSE TYPE SENT IS NOT RECOGNIZED BY THIS API ALL THE RESPONSE
* REGISTERS ARE POPULATED IN THE SAME FORMAT MENTIONED ABOVE FOR R2 RESPONSE.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
respType Type of the response
pResponse Pointer to response structure
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESYS_INVPARAMS - Invalid Parameter
*
* <b> Pre Condition </b>
* @n SDIO_sendCommand() API should be called successfully.
*
* <b> Post Condition </b>
* @n None
*
* @b Modifies
* @n Response structure
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
Uint32 cmd;
Uint32 arg;
Uint16 respTimeout;
CSL_SdioResponse response;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
//Send Command 5
cmd = 0x205;
arg = 0;
respTimeout = 0xFFFF;
status = SDIO_sendCommand(hSdio, cmd, arg, respTimeout);
status = SDIO_getResponse(hSdio, CSL_SDIO_RESPTYPE_R4, &response);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_getResponse(CSL_SdioHandle hSdio,
CSL_SdioRespType respType,
CSL_SdioResponse *pResponse);
/** ===========================================================================
* @n@b SDIO_clearResponse
*
* @b Description
* @n This function is used to clear all the response registers.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
*
* <b> Pre Condition </b>
* @n SDIO_open() API should be called successfully.
*
* <b> Post Condition </b>
* @n None
*
* @b Modifies
* @n Response structure
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
CSL_SdioResponse response;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_clearResponse(hSdio);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_clearResponse(CSL_SdioHandle hSdio);
/** ===========================================================================
* @n@b SDIO_getStatus
*
* @b Description
* @n This function reads MMCST0 and MMCST1 registers and returns the value.
* When mask value is set to 0xFFFFFFFF, value of MMCST0 will be stored
* in lower 16 bits and value of MMCST1 will be store in upper 16 bits.
* Value of a particular bit in the passed mask should be set to '1' to
* read the corresponding bit in the MMC status register.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
maskValue Mask value to specify the field.
pStatus Status of API Success or Failed.
@endverbatim
*
* <b> Return Value </b> Uint32
* Status - MMCST0 and MMCST1 register value.
*
* <b> Pre Condition </b>
* @n SDIO_open() API should be called successfully.
*
* <b> Post Condition </b>
* @n None
*
* @b Modifies
* @n None
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
Uint32 mmcstatus;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
mmcstatus = SDIO_getStatus(hSdio, 0xFFFF, &status);
@endverbatim
* ===========================================================================
*/
Uint32 SDIO_getStatus(CSL_SdioHandle hSdio,
Uint32 maskValue,
CSL_Status *pStatus);
/** ===========================================================================
* @n@b SDIO_getSdioStatus
*
* @b Description
* @n This function reads SDIOST0 and SDIOIST registers and returns the value.
* When mask value is set to 0xFFFFFFFF, value of SDIOST0 will be stored
* in lower 16 bits and value of SDIOIST will be store in upper 16 bits.
* Value of a particular bit in the passed mask should be set to '1' to
* read the corresponding bit in the SDIO status register.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
maskValue Mask value to specify the field.
pStatus status of API Success of Failed.
@endverbatim
*
* <b> Return Value </b> Uint32
* Status - SDIOST0 and SDIOIST register value.
*
* <b> Pre Condition </b>
* @n SDIO_open() API should be called successfully.
*
* <b> Post Condition </b>
* @n None
*
* @b Modifies
* @n None
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
Uint32 sdiostatus;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
sdiostatus = SDIO_getSdioStatus(hSdio, 0xFFFF, &status);
@endverbatim
* ===========================================================================
*/
Uint32 SDIO_getSdioStatus(CSL_SdioHandle hSdio,
Uint32 maskValue,
CSL_Status *pStatus);
/** ===========================================================================
* @n@b SDIO_eventEnable
*
* @b Description
* @n This function will enable the events in the MMC interrupt mask register
* and SDIO interrupt enable register.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
sdioEvent Event type.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESYS_INVPARAMS - Invalid Parameter
*
* <b> Pre Condition </b>
* @n SDIO_open() API should be called successfully.
*
* <b> Post Condition </b>
* @n Enables the given event
*
* @b Modifies
* @n MMC/SDIO Interrupt Mask Registers
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_eventEnable(hSdio, CSL_SDIO_EDRRDY_INTERRUPT);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_eventEnable(CSL_SdioHandle hSdio,
CSL_SdioEventType sdioEvent);
/** ===========================================================================
* @n@b SDIO_eventDisable
*
* @b Description
* @n This function will disable the events in the MMC interrupt mask
* register and SDIO interrupt enable register.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
sdioEvent Event type.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESYS_INVPARAMS - Invalid Parameter
*
* <b> Pre Condition </b>
* @n SDIO_open() API should be called successfully.
*
* <b> Post Condition </b>
* @n Disables the given event
*
* @b Modifies
* @n MMC/SDIO Interrupt Mask Register
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_eventDisable(hSdio, CSL_SDIO_EDRRDY_INTERRUPT);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_eventDisable(CSL_SdioHandle hSdio,
CSL_SdioEventType sdioEvent);
/** ===========================================================================
* @n@b SDIO_readWaitEnable
*
* @b Description
* @n This function is used to enable SDIO read-wait bit in SDIO control
* register.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
*
* <b> Pre Condition </b>
* @n SDIO_open() API should be called successfully.
*
* <b> Post Condition </b>
* @n Enables the sdio read-wait
*
* @b Modifies
* @n SDIO control Register
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_readWaitEnable(hSdio);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_readWaitEnable(CSL_SdioHandle hSdio);
/** ===========================================================================
* @n@b SDIO_readWaitDisable
*
* @b Description
* @n This function is used to disable SDIO read-wait bit in SDIO control
* register.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
*
* <b> Pre Condition </b>
* @n SDIO_open() API should be called successfully.
*
* <b> Post Condition </b>
* @n Disables the sdio read-wait
*
* @b Modifies
* @n SDIO control Register
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_readWaitDisable(hSdio);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_readWaitDisable(CSL_SdioHandle hSdio);
/** ===========================================================================
* @n@b SDIO_readSingleByte
*
* @b Description
* @n This function reads a single byte of data from the SDIO card.
* 'readAddr' is address on the SDIO card from where data byte will be
* read. Command 52 (IO_RW_DIRECT Command) is used to read the data.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
readAddr Location to read from.
funNum IO function number to read data
pReadData Pointer to populate data read
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Close successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESYS_INVPARAMS - Invalid Parameter
* @li CSL_ESDIO_TIMEOUT - Card Response time out
* @li CSL_ESDIO_CRCERR - Response/Data CRC Error
*
* <b> Pre Condition </b>
* @n 1:SDIO_open() API should be called successfully.
* @n 2:SDIO_initCard() API should be called successfully.
*
* <b> Post Condition </b>
* @n Reads a byte of data from the SDIO card
*
* @b Modifies
* @n Read data pointer will be populated.
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
Uint16 rca;
Uint32 ocr;
Uint8 readData;
Uint32 readAddr;
Uint8 funNum;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_detectCard(hSdio, &sdioCardObj);
status = SDIO_initCard(hSdio, ocr, TRUE);
readAddr = 0x0;
funNum = 0;
status = SDIO_readSingleByte(hSdio, readAddr, funNum, &readData);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_readSingleByte(CSL_SdioHandle hSdio,
Uint32 readAddr,
Uint8 funNum,
Uint8 *pReadData);
/** ===========================================================================
* @n@b SDIO_writeSingleByte
*
* @b Description
* @n This function writes a single byte of data to the SDIO card.
* 'writeAddr' is address on the SDIO card to where data byte will be
* written. Command 52 (IO_RW_DIRECT Command) is used to write the data.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
writeAddr Location to write data byte.
funNum IO function number to read data
writeData Data to be written
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Close successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESYS_INVPARAMS - Invalid Parameter
* @li CSL_ESDIO_TIMEOUT - Card Response time out
* @li CSL_ESDIO_CRCERR - Response/Data CRC Error
*
* <b> Pre Condition </b>
* @n 1:SDIO_open() API should be called successfully.
* @n 2:SDIO_initCard() API should be called successfully.
*
* <b> Post Condition </b>
* @n Writes a byte of data to the SDIO card
*
* @b Modifies
* @n SDIO card registers
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
Uint16 rca;
Uint32 ocr;
Uint8 writeData;
Uint32 writeAddr;
Uint8 funNum;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_detectCard(hSdio, &sdioCardObj);
status = SDIO_initCard(hSdio, ocr, TRUE);
writeAddr = 0x02;
writeData = 0x02;
funNum = 0;
status = SDIO_writeSingleByte(hSdio, writeAddr, funNum, writeData);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_writeSingleByte(CSL_SdioHandle hSdio,
Uint32 writeAddr,
Uint8 funNum,
Uint8 writeData);
/** ===========================================================================
* @n@b SDIO_readBytes
*
* @b Description
* @n This function reads requested number of bytes from the SDIO card.
* 'readAddr' is address on the SDIO card from where the reading
* starts. This function reads multiple bytes of data from the given
* address and populates into read buffer. Maximum number of bytes
* that can be read using this function are 512.
*
* Reading of data can be done from a fixed address(opCode = 0) or
* incrementing address(opCode = 1). Fixed mode data read is useful
* when I/O data is transferred using a FIFO inside SDIO card. Opcode
* should be 1 for the SDIO cards which doesn't have support for FIFO.
*
* NOTE: Endian mode of the data transfer depends on the parameter
* 'readEndianMode' in the SDIO handle. Default value for the endian mode
* is 'LITTLE ENDIAN' which will be set during SDIO open. Endian mode can
* be configured using SDIO_setEndianMode(). DO NOT CHANGE THE ENDIAN MODE
* WITH OUT USING THIS API.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
readAddr Location to read from.
funNum IO function number to read data
opCode Bit to decide source address mode
- Fixed/Incrementing
noOfBytes no of bytes to read.
pReadBuf pointer to a buffer.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Close successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESYS_INVPARAMS - Invalid Parameter
* @li CSL_ESDIO_TIMEOUT - Card Response time out
* @li CSL_ESDIO_CRCERR - Response/Data CRC Error
*
* <b> Pre Condition </b>
* @n 1:SDIO_open() API should be called successfully.
* @n 2:SDIO_initCard() API should be called successfully.
*
* <b> Post Condition </b>
* @n Reads data from the SDIO card
*
* @b Modifies
* @n readBuffer will be populated.
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
Uint16 rca;
Uint32 ocr;
Uint16 readBuf[512];
Uint32 readAddr;
Uint16 noOfBytes;
Bool opCode;
Uint8 funNum;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_detectCard(hSdio, &sdioCardObj);
status = SDIO_initCard(hSdio, ocr, TRUE);
readAddr = 0x0;
noOfBytes = 16;
opCode = 1;
funNum = 0;
status = SDIO_readBytes(hSdio, readAddr, funNum, opCode,
noOfBytes, readBuf);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_readBytes(CSL_SdioHandle hSdio,
Uint32 readAddr,
Uint8 funNum,
Bool opCode,
Uint16 noOfBytes,
Uint16 *pReadBuf);
/** ===========================================================================
* @n@b SDIO_writeBytes
*
* @b Description
* @n This function writes requested number of bytes to the SDIO card.
* 'writeAddr' is address on the SDIO card from where the writing
* starts. Maximum length of the data that can be written using
* this function is 512 bytes.
*
* Writing of data can be done to a fixed address(opCode = 0) or
* incrementing address(opCode = 1). Fixed mode data write is useful
* when I/O data is transferred using a FIFO inside SDIO card. Opcode
* should be 1 for the SDIO cards which doesn't have support for FIFO.
*
* NOTE: Endian mode of the data transfer depends on the parameter
* 'writeEndianMode' in the SDIO handle. Default value for the endian mode
* is 'LITTLE ENDIAN' which will be set during SDIO open. Endian mode can
* be configured using SDIO_setEndianMode(). DO NOT CHANGE THE ENDIAN MODE
* WITH OUT USING THIS API.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
writeAddr Location to write to.
funNum IO function number to write data
opCode Bit to decide destination address mode
- Fixed/Incrementing
noOfBytes Number of bytes to write.
pWriteBuf Pointer to write buffer.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Close successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESYS_INVPARAMS - Invalid Parameter
* @li CSL_ESDIO_TIMEOUT - Card Response time out
* @li CSL_ESDIO_CRCERR - Response/Data CRC Error
*
* <b> Pre Condition </b>
* @n 1:SDIO_open() API should be called successfully.
* @n 2:SDIO_initCard() API should be called successfully.
*
* <b> Post Condition </b>
* @n Writes data to the SDIO card
*
* @b Modifies
* @n Data registers
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
Uint32 ocr;
Uint16 writeBuf[512];
Uint32 writeAddr;
Uint16 noOfBytes;
Bool opCode;
Uint8 funNum;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_detectCard(hSdio, &sdioCardObj);
status = SDIO_initCard(hSdio, ocr, TRUE);
writeAddr = 0x07;
noOfBytes = 1;
opCode = 1;
funNum = 0;
status = SDIO_writeBytes(hSdio, writeAddr, funNum, opCode,
noOfBytes, writeBuf);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_writeBytes(CSL_SdioHandle hSdio,
Uint32 writeAddr,
Uint8 funNum,
Bool opCode,
Uint16 noOfBytes,
Uint16 *pWriteBuf);
/** ===========================================================================
* @n@b SDIO_readBlocks
*
* @b Description
* @n This function reads requested number of blocks of data from SDIO card.
* 'readAddr' is address on the SDIO card from where the reading
* starts. Block size of IO function to read data should be configured
* before calling this function.
*
* Reading of data can be done from a fixed address(opCode = 0) or
* incrementing address(opCode = 1). Fixed mode data read is useful
* when I/O data is transferred using a FIFO inside SDIO card. Opcode
* should be 1 for the SDIO cards which doesn't have support for FIFO.
*
* NOTE: Endian mode of the data transfer depends on the parameter
* 'readEndianMode' in the SDIO handle. Default value for the endian mode
* is 'LITTLE ENDIAN' which will be set during SDIO open. Endian mode can
* be configured using SDIO_setEndianMode(). DO NOT CHANGE THE ENDIAN MODE
* WITH OUT USING THIS API.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
readAddr Location to read from.
funNum IO function number to read data
opCode Bit to decide source address mode
- Fixed/Incrementing
noOfBlocks Number of blocks to read.
blockSize Size of each block
pReadBuf pointer to a buffer.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Close successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESYS_INVPARAMS - Invalid Parameter
* @li CSL_ESDIO_TIMEOUT - Card Response time out
* @li CSL_ESDIO_CRCERR - Response/Data CRC Error
*
* <b> Pre Condition </b>
* @n 1:SDIO_open() API should be called successfully.
* @n 2:SDIO_initCard() API should be called successfully.
*
* <b> Post Condition </b>
* @n Reads data from the SDIO card
*
* @b Modifies
* @n readBuffer will be populated.
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
Uint32 ocr;
Uint16 readBuf[512];
Uint32 readAddr;
Uint16 noOfBlocks;
Bool opCode;
Uint8 funNum;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_detectCard(hSdio, &sdioCardObj);
status = SDIO_initCard(hSdio, ocr, TRUE);
readAddr = 0x0;
noOfBlocks = 2;
opCode = 1;
funNum = 0;
status = SDIO_readBlocks(hSdio, readAddr, funNum, opCode,
noOfBlocks, 256, readBuf);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_readBlocks(CSL_SdioHandle hSdio,
Uint32 readAddr,
Uint8 funNum,
Bool opCode,
Uint16 noOfBlocks,
Uint16 blockSize,
Uint16 *pReadBuf);
/** ===========================================================================
* @n@b SDIO_writeBlocks
*
* @b Description
* @n This function writes requested number of blocks of data to SDIO card.
* 'writeAddr' is address on the SDIO card from where the writing
* starts. Block size of IO function to write data should be configured
* before calling this function.
*
* Writing of data can be done to a fixed address(opCode = 0) or
* incrementing address(opCode = 1). Fixed mode data write is useful
* when I/O data is transferred using a FIFO inside SDIO card. Opcode
* should be 1 for the SDIO cards which doesn't have support for FIFO.
*
* NOTE: Endian mode of the data transfer depends on the parameter
* 'writeEndianMode' in the SDIO handle. Default value for the endian mode
* is 'LITTLE ENDIAN' which will be set during SDIO open. Endian mode can
* be configured using SDIO_setEndianMode(). DO NOT CHANGE THE ENDIAN MODE
* WITH OUT USING THIS API.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
writeAddr Location to write to.
funNum IO function number to write data
opCode Bit to decide destination address mode
- Fixed/Incrementing
noOfBlocks Number of blocks to write.
blockSize Size of each block
pWriteBuf Pointer to write buffer.
@endverbatim
*
* <b> Return Value </b> CSL_Status
* @li CSL_SOK - Close successful
* @li CSL_ESYS_BADHANDLE - Invalid handle
* @li CSL_ESYS_INVPARAMS - Invalid Parameter
* @li CSL_ESDIO_TIMEOUT - Card Response time out
* @li CSL_ESDIO_CRCERR - Response/Data CRC Error
*
* <b> Pre Condition </b>
* @n 1:SDIO_open() API should be called successfully.
* @n 2:SDIO_initCard() API should be called successfully.
*
* <b> Post Condition </b>
* @n Writes data to the SDIO card
*
* @b Modifies
* @n Data registers
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
Uint32 ocr;
Uint16 writeBuf[512];
Uint32 writeAddr;
Uint16 noOfBlocks;
Bool opCode;
Uint8 funNum;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_detectCard(hSdio, &sdioCardObj);
status = SDIO_initCard(hSdio, ocr, TRUE);
writeAddr = 0x110;
noOfBlocks = 2;
opCode = 1;
funNum = 0;
status = SDIO_writeBlocks(hSdio, writeAddr, funNum, opCode,
noOfBlocks, 256, writeBuf);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_writeBlocks(CSL_SdioHandle hSdio,
Uint32 writeAddr,
Uint8 funNum,
Bool opCode,
Uint16 noOfBlocks,
Uint16 blockSize,
Uint16 *pWriteBuf);
/** ===========================================================================
* @n@b SDIO_setEndianMode
*
* @b Description
* @n This function is used to set endian mode of the SDIO controller.
* Endian mode set using this API decides the way in which data is
* transferred from FIFO to storage device.
*
* Default endianness of SDIO controller:
* Chip C5504 and C5505: LITTLE ENDIAN.
* Chip C5514 and C5515: BIG ENDIAN.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
writeEndianMode Endian mode for SDIO write operation
readEndianMode Endian mode for SDIO read operation
@endverbatim
*
* <b> Return Value </b>
* @li CSL_SOK - Returned for Success
* @li CSL_ESYS_BADHANDLE - Invalid MMSDC handle
* @li CSL_ESYS_INVPARAMS - Invalid input parameters
*
* <b> Pre Condition </b>
* @n SDIO_open() function should be called successfully
*
* <b> Post Condition </b>
* @n Sets SDIO endian mode for write and read operations
*
* @b Modifies
* @n SDIO control register
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_setEndianMode(hSdio, CSL_SDIO_ENDIAN_LITTLE,
CSL_SDIO_ENDIAN_LITTLE);
...
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_setEndianMode (CSL_SdioHandle hSdio,
CSL_SdioEndianMode writeEndianMode,
CSL_SdioEndianMode readEndianMode);
/** ===========================================================================
* @n@b SDIO_setClock
*
* @b Description
* @n This function is used to set SDIO controller clock divider value. Clock
* controller register bits are configured by this function. Clock rate or
* clock divider value can range from 0 to 0xFF.
*
* @b Arguments
* @verbatim
hSdio Handle to the SDIO.
clockRate Value of clock rate
@endverbatim
*
* <b> Return Value </b>
* @li CSL_SOK - Returned for Success
* @li CSL_ESYS_BADHANDLE - Invalid MMSDC handle
* @li CSL_ESYS_INVPARAMS - Invalid input parameters
*
* <b> Pre Condition </b>
* @n SDIO_open() function should be called successfully
*
* <b> Post Condition </b>
* @n Sets SDIO clock
*
* @b Modifies
* @n SDIO clock control register
*
* @b Example
* @verbatim
CSL_SdioControllerObj sdioContObj;
CSL_SdioHandle hSdio;
CSL_SdioInstId instId;
CSL_status status;
instId = CSL_SDIO_INST0;
status = SDIO_init();
hSdio = SDIO_open(&sdioContObj, instId, &status);
status = SDIO_setClock(hSdio, 5);
@endverbatim
* ===========================================================================
*/
CSL_Status SDIO_setClock (CSL_SdioHandle hSdio,
Uint16 clockRate);
/**
@} */
#ifdef __cplusplus
}
#endif
#endif /* _CSL_SDIO_H_ */
Reference in New Issue Copy Permalink