/*  ===========================================================================
 *   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_ */

