/* Cypress West Bridge API header file (cyasdevice.h)

 ## ===========================

 ##

 ##  Copyright Cypress Semiconductor Corporation, 2006-2009,

 ##  All Rights Reserved

 ##  UNPUBLISHED, LICENSED SOFTWARE.

 ##

 ##  CONFIDENTIAL AND PROPRIETARY INFORMATION

 ##  WHICH IS THE PROPERTY OF CYPRESS.

 ##

 ##  Use of this file is governed

 ##  by the license agreement included in the file

 ##

 ##     <install>/license/license.txt

 ##

 ##  where <install> is the Cypress software

 ##  installation root directory path.

 ##

 ## ===========================

*/

#ifndef __INCLUDED_CYASDEVICE_H__

#define __INCLUDED_CYASDEVICE_H__

#include "cyashal.h"

#include "cyasprotocol.h"

#include "cyasusb.h"

#include "cyasstorage.h"

#include "cyasmtp.h"

#include "cyas_cplus_start.h"

/*****************************************************************************

 * West Bridge Constants

 ****************************************************************************/

/* The endpoints used by West Bridge for the P port to S port path */

#define CY_AS_P2S_WRITE_ENDPOINT                        (0x04)

#define CY_AS_P2S_READ_ENDPOINT                         (0x08)

/* The endpoint to use for firmware download */

#define CY_AS_FIRMWARE_ENDPOINT                         (0x02)

/* The maximum size of the firmware image West Bridge can accept */

#define CY_AS_MAXIMUM_FIRMWARE_SIZE                     (24 * 1024)

/* The maximum size of a write for EP0 and EP1 */

#define CY_AS_EP0_MAX_WRITE_SIZE                        (128)

#define CY_AS_EP1_MAX_WRITE_SIZE                        (64)

/* The bitfields for the device state value */

#define CY_AS_DEVICE_STATE_PIN_STANDBY                  (0x00000001)            /* The device is in StandBy mode */

#define CY_AS_DEVICE_STATE_CONFIGURED                   (0x00000002)            /* The device has been configured */

#define CY_AS_DEVICE_STATE_FIRMWARE_LOADED              (0x00000004)            /* The firmware has been loaded into the device */

#define CY_AS_DEVICE_STATE_LOWLEVEL_MODULE              (0x00000008)            /* The interrupt module has been initialized */

#define CY_AS_DEVICE_STATE_DMA_MODULE                   (0x00000010)            /* The DMA module has been initialized */

#define CY_AS_DEVICE_STATE_INTR_MODULE                  (0x00000020)            /* The interrupt module has been initialized */

#define CY_AS_DEVICE_STATE_STORAGE_MODULE               (0x00000040)            /* The storage module has been initialized */

#define CY_AS_DEVICE_STATE_USB_MODULE                   (0x00000080)            /* The USB module has been initialized */

#define CY_AS_DEVICE_STATE_STORAGE_SCSIMSG              (0x00000100)            /* If set, the API wants SCSI messages */

#define CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING        (0x00000200)            /* If set, an ASYNC storage operation is pending */

#define CY_AS_DEVICE_STATE_USB_CONNECTED                (0x00000400)            /* If set, the USB port is connected */

#define CY_AS_DEVICE_STATE_USB_HIGHSPEED                (0x00000800)            /* If set and USB is connected, it is high speed */

#define CY_AS_DEVICE_STATE_IN_CALLBACK                  (0x00001000)            /* If set, we are in a callback */

#define CY_AS_DEVICE_STATE_IN_SETUP_PACKET              (0x00004000)            /* If set, we are processing a setup packet */

#define CY_AS_DEVICE_STATE_REGISTER_STANDBY             (0x00008000)            /* The device was placed in standby via register */

#define CY_AS_DEVICE_STATE_CRYSTAL                      (0x00010000)            /* If set, the device is using a crystal */

#define CY_AS_DEVICE_STATE_WAKING                       (0x00020000)            /* If set, wakeup has been called */

#define CY_AS_DEVICE_STATE_EP0_STALLED                  (0x00040000)            /* If set, EP0 has been stalled. */

#define CY_AS_DEVICE_STATE_SUSPEND                      (0x00080000)            /* If set, device is in suspend mode. */

#define CY_AS_DEVICE_STATE_RESETP                       (0x00100000)            /* If set, device is a reset is pending. */

#define CY_AS_DEVICE_STATE_STANDP                       (0x00200000)            /* If set, device is a standby is pending. */

#define CY_AS_DEVICE_STATE_SSSP                         (0x00400000)            /* If set, device has a storage start or stop pending. */

#define CY_AS_DEVICE_STATE_USSP                         (0x00800000)            /* If set, device has a usb start or stop pending. */

#define CY_AS_DEVICE_STATE_MSSP                         (0x01000000)            /* If set, device has a mtp start or stop pending. */

/* The bitfields for the endpoint state value */

#define CY_AS_DMA_ENDPOINT_STATE_ENABLED                (0x0001)                /* DMA requests are accepted into the queue */

#define CY_AS_DMA_ENDPOINT_STATE_SLEEPING               (0x0002)                /* The endpoint has a sleeping client, waiting on a queue drain */

#define CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING            (0x0004)                /* The DMA backend to hardware is running */

#define CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT             (0x0008)                /* There is an outstanding DMA entry deployed to the HAL */

#define CY_AS_DMA_ENDPOINT_STATE_DIRECTION              (0x0010)                /* 0 = OUT (West Bridge -> P Port), 1 = IN (P Port -> West Bridge) */

/* The state values for the request list */

#define CY_AS_REQUEST_LIST_STATE_MASK                   (0x0f)                  /* Mask for getting the state information */

#define CY_AS_REQUEST_LIST_STATE_QUEUED                 (0x00)                  /* The request is queued, nothing further */

#define CY_AS_REQUEST_LIST_STATE_WAITING                (0x01)                  /* The request is sent, waiting for response */

#define CY_AS_REQUEST_LIST_STATE_RECEIVED               (0x02)                  /* The response has been received, processing reponse */

#define CY_AS_REQUEST_LIST_STATE_CANCELING              (0x03)                  /* The request/response is being canceled */

#define CY_AS_REQUEST_LIST_STATE_SYNC                   (0x80)                  /* The request is synchronous */

/* The flag values for a LL RequestResponse */

#define CY_AS_REQUEST_RESPONSE_DELAY_ACK                (0x01)                  /* This request requires an ACK to be sent after it is completed */

#define CY_AS_REQUEST_RESPONSE_EX                       (0x02)                  /* This request originated from a version V1.1 function call */

#define CY_AS_REQUEST_RESPONSE_MS                       (0x04)                  /* This request originated from a version V1.2 function call */

#define CY_AS_DEVICE_HANDLE_SIGNATURE                   (0x01211219)

/*

 * This macro returns the endpoint pointer given the device pointer and an endpoint number

 */

#define CY_AS_NUM_EP(dev_p, num) ((dev_p)->endp[(num)])

/*****************************************************************************

 * West Bridge Data Structures

 ****************************************************************************/

typedef struct CyAsDevice CyAsDevice ;

/* Summary

   This type defines a callback function that will be called on completion of a DMA operation.

   Description

   This function definition is for a function that is called when the DMA operation is complete.  This

   function is called with the endpoint number, operation type, buffer pointer and size.

   See Also

   * CyAsDmaOper

   * CyAsDmaQueueWrite

 */

typedef void (*CyAsDmaCallback)(

        CyAsDevice *                dev_p,                  /* The device that completed DMA */

        CyAsEndPointNumber_t        ep,                     /* The endpoint that completed DMA */

        void *                      mem_p,                  /* The pointer to the buffer that completed DMA */

        uint32_t                    size,                   /* The amount of data transferred */

        CyAsReturnStatus_t          error                   /* The error code for this DMA xfer */

        ) ;

/* Summary

   This structure defines a DMA request that is queued

   Description

   This structure contains the information about a DMA request that is queued and is to

   be sent when possible.

*/

typedef struct CyAsDmaQueueEntry

{

    void *                          buf_p ;                 /* Pointer to memory buffer for this request */

    uint32_t                        size ;                  /* Size of the memory buffer for DMA operation */

    uint32_t                        offset ;                /* Offset into memory buffer for next DMA operation */

    CyBool                          packet ;                /* If TRUE and IN request */

    CyBool                          readreq ;               /* If TRUE, this is a read request */

    CyAsDmaCallback                 cb ;                    /* Callback function for when DMA is complete */

    struct CyAsDmaQueueEntry *      next_p ;                /* Pointer to next entry in queue */

} CyAsDmaQueueEntry ;

/* Summary

   This structure defines the endpoint data for a given

   Description

   This structure defines all of the information required to manage DMA for a given

   endpoint.

*/

typedef struct CyAsDmaEndPoint

{

    CyAsEndPointNumber_t            ep ;                    /* The endpoint number */

    uint8_t                         state ;                 /* The state of this endpoint */

    uint16_t                        maxhwdata ;             /* The maximum amount of data accepted in a packet by the hw */

    uint32_t                        maxhaldata ;            /* The maximum amount of data accepted by the HAL layer */

    CyAsDmaQueueEntry *             queue_p ;               /* The queue for DMA operations */

    CyAsDmaQueueEntry *             last_p ;                /* The last entry in the DMA queue */

    CyAsHalSleepChannel             channel ;               /* This sleep channel is used to wait while the DMA queue drains for a given endpoint */

} CyAsDmaEndPoint ;

#define CyAsEndPointNumberIsUsb(n) ((n) != 2 && (n) != 4 && (n) != 6 && (n) != 8)

#define CyAsEndPointNumberIsStorage(n) ((n) == 2 || (n) == 4 || (n) == 6 || (n) == 8)

#define CyAsDmaEndPointIsEnabled(ep) ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_ENABLED)

#define CyAsDmaEndPointEnable(ep) ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_ENABLED)

#define CyAsDmaEndPointDisable(ep) ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_ENABLED)

#define CyAsDmaEndPointIsSleeping(ep) ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_SLEEPING)

#define CyAsDmaEndPointSetSleepState(ep) ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_SLEEPING)

#define CyAsDmaEndPointSetWakeState(ep) ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_SLEEPING)

#define CyAsDmaEndPointIsRunning(ep) ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING)

#define CyAsDmaEndPointSetRunning(ep) ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING)

#define CyAsDmaEndPointSetStopped(ep) ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING)

#define CyAsDmaEndPointInTransit(ep) ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT)

#define CyAsDmaEndPointSetInTransit(ep) ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT)

#define CyAsDmaEndPointClearInTransit(ep) ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT)

#define CyAsDmaEndPointIsDirectionIn(ep) (((ep)->state & CY_AS_DMA_ENDPOINT_STATE_DIRECTION) == CY_AS_DMA_ENDPOINT_STATE_DIRECTION)

#define CyAsDmaEndPointIsDirectionOut(ep) (((ep)->state & CY_AS_DMA_ENDPOINT_STATE_DIRECTION) == 0)

#define CyAsDmaEndPointSetDirectionIn(ep) ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_DIRECTION)

#define CyAsDmaEndPointSetDirectionOut(ep) ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_DIRECTION)

#define CyAsDmaEndPointIsUsb(p) CyAsEndPointNumberIsUsb((p)->ep)

#define CyAsDmaEndPointIsStorage(p) CyAsEndPointNumberIsStorage((p)->ep)

typedef struct CyAsLLRequestResponse

{

    uint16_t                        box0 ;                  /* The mbox[0] contents - see low level comm section of API doc */

    uint16_t                        stored ;                /* The amount of data stored in this request/response in bytes */

    uint16_t                        length ;                /* Length of this request in words */

    uint16_t                        flags ;                 /* Additional status information about the request */

    uint16_t                        data[1] ;               /* Note: This is over indexed and contains the request/response data */

} CyAsLLRequestResponse ;

/*

 * The callback function for responses

 */

typedef void (*CyAsResponseCallback)(

    CyAsDevice *                    dev_p,                  /* The device that had the response */

    uint8_t                         context,                /* The context receiving a response */

    CyAsLLRequestResponse *         rqt,                    /* The request data */

    CyAsLLRequestResponse *         resp,                   /* The response data */

    CyAsReturnStatus_t              status                  /* The status of the request */

    ) ;

typedef struct CyAsLLRequestListNode

{

    CyAsLLRequestResponse *         rqt ;                   /* The request to send */

    CyAsLLRequestResponse *         resp ;                  /* The associated response for the request */

    uint16_t                        length ;                /* Length of the response */

    CyAsResponseCallback            callback ;              /* The callback to call when done */

    uint8_t                         state ;                 /* The state of the request */

    struct CyAsLLRequestListNode *  next ;                  /* The next request in the list */

} CyAsLLRequestListNode ;

#define CyAsRequestGetNodeState(node_p) ((node_p)->state & CY_AS_REQUEST_LIST_STATE_MASK)

#define CyAsRequestSetNodeState(node_p, st) ((node_p)->state = ((node_p)->state & ~CY_AS_REQUEST_LIST_STATE_MASK) | (st))

#define CyAsRequestNodeIsSync(node_p) ((node_p)->state & CY_AS_REQUEST_LIST_STATE_SYNC)

#define CyAsRequestNodeSetSync(node_p) ((node_p)->state |= CY_AS_REQUEST_LIST_STATE_SYNC)

#define CyAsRequestNodeClearSync(node_p) ((node_p)->state &= ~CY_AS_REQUEST_LIST_STATE_SYNC)

#ifndef __doxygen__

typedef enum CyAsCBNodeType

{

    CYAS_INVALID,

    CYAS_USB_FUNC_CB,

    CYAS_USB_IO_CB,

    CYAS_STORAGE_IO_CB,

    CYAS_FUNC_CB

} CyAsCBNodeType ;

typedef struct CyAsFuncCBNode

{

    CyAsCBNodeType              nodeType ;

    CyAsFunctionCallback        cb_p ;

    uint32_t                    client_data ;

    /*CyAsFunctCBType             dataType ; nxz */

    uint32_t					dataType ;

    void*                       data ;

    struct CyAsFuncCBNode *     next_p ;

} CyAsFuncCBNode;

extern CyAsFuncCBNode*

CyAsCreateFuncCBNodeData(CyAsFunctionCallback cb, uint32_t client, CyAsFunctCBType type, void* data) ;

extern CyAsFuncCBNode*

CyAsCreateFuncCBNode(CyAsFunctionCallback cb, uint32_t client) ;

extern void

CyAsDestroyFuncCBNode(CyAsFuncCBNode* node) ;

typedef struct CyAsMTPFuncCBNode

{

    CyAsCBNodeType              type ;

    CyAsMTPFunctionCallback     cb_p ;

    uint32_t                    client_data;

    struct CyAsMTPFuncCBNode *  next_p ;

} CyAsMTPFuncCBNode;

extern CyAsMTPFuncCBNode*

CyAsCreateMTPFuncCBNode(CyAsMTPFunctionCallback cb, uint32_t client) ;

extern void

CyAsDestroyMTPFuncCBNode(CyAsMTPFuncCBNode* node) ;

typedef struct CyAsUsbFuncCBNode

{

    CyAsCBNodeType              type ;

    CyAsUsbFunctionCallback     cb_p ;

    uint32_t                    client_data;

    struct CyAsUsbFuncCBNode *  next_p ;

} CyAsUsbFuncCBNode;

extern CyAsUsbFuncCBNode*

CyAsCreateUsbFuncCBNode(CyAsUsbFunctionCallback cb, uint32_t client) ;

extern void

CyAsDestroyUsbFuncCBNode(CyAsUsbFuncCBNode* node) ;

typedef struct CyAsUsbIoCBNode

{

    CyAsCBNodeType              type ;

    CyAsUsbIoCallback           cb_p ;

    struct CyAsUsbIoCBNode *    next_p ;

} CyAsUsbIoCBNode;

extern CyAsUsbIoCBNode*

CyAsCreateUsbIoCBNode(CyAsUsbIoCallback cb) ;

extern void

CyAsDestroyUsbIoCBNode(CyAsUsbIoCBNode* node) ;

typedef struct CyAsStorageIoCBNode

{

    CyAsCBNodeType              type ;

    CyAsStorageCallback         cb_p ;

    CyAsMediaType               media ;             /* The media for the currently outstanding async storage request */

    uint32_t                    device_index ;      /* The device index for the currently outstanding async storage request */

    uint32_t                    unit ;              /* The unit index for the currently outstanding async storage request */

    uint32_t                    block_addr ;        /* The block address for the currently outstanding async storage request */

    CyAsOperType                oper ;              /* The operation for the currently outstanding async storage request */

    CyAsLLRequestResponse*      req_p ;

    CyAsLLRequestResponse*      reply_p ;

    struct CyAsStorageIoCBNode* next_p ;

} CyAsStorageIoCBNode;

extern CyAsStorageIoCBNode*

CyAsCreateStorageIoCBNode(CyAsStorageCallback cb, CyAsMediaType media, uint32_t device_index,

                          uint32_t unit, uint32_t block_addr, CyAsOperType oper,

                          CyAsLLRequestResponse* req_p, CyAsLLRequestResponse* reply_p) ;

extern void

CyAsDestroyStorageIoCBNode(CyAsStorageIoCBNode* node) ;

typedef struct CyAsCBQueue

{

    void *              head_p;

    void *              tail_p;

    uint32_t            count ;

    CyAsCBNodeType      type ;

} CyAsCBQueue ;

extern CyAsCBQueue *

CyAsCreateCBQueue(CyAsCBNodeType type) ;

extern void

CyAsDestroyCBQueue(CyAsCBQueue* queue) ;

/* Allocates a new CyAsCBNode */

extern void

CyAsInsertCBNode(CyAsCBQueue * queue_p, void* cbnode) ;

/* Removes the first CyAsCBNode from the queue and frees it */

extern void

CyAsRemoveCBNode(CyAsCBQueue * queue_p) ;

/* Remove the last CyAsCBNode from the queue and frees it */

extern void

CyAsRemoveCBTailNode(CyAsCBQueue *queue_p) ;

/* Removes and frees all pending callbacks */

extern void

CyAsClearCBQueue(CyAsCBQueue * queue_p) ;

extern CyAsReturnStatus_t

CyAsMiscSendRequest(CyAsDevice* dev_p,

                      CyAsFunctionCallback cb,

                      uint32_t client,

                      CyAsFunctCBType type,

                      void* data,

                      CyAsCBQueue* queue,

                      uint16_t req_type,

                      CyAsLLRequestResponse *req_p,

                      CyAsLLRequestResponse *reply_p,

                      CyAsResponseCallback rcb) ;

extern void

CyAsMiscCancelExRequests(CyAsDevice* dev_p) ;

/* Summary

   Free all memory allocated by and zero all structures initialized

   by CyAsUsbStart.

 */

extern void

CyAsUsbCleanup (

        CyAsDevice *dev_p) ;

/* Summary

   Free all memory allocated and zero all structures initialized

   by CyAsStorageStart.

 */

extern void

CyAsStorageCleanup (

        CyAsDevice *dev_p) ;

#endif

/* Summary

   This structure defines the data structure to support a given command context

   Description

   All commands send to the West Bridge device via the mailbox registers are sent via a context.

   Each context is independent and there can be a parallel stream of requests and responses on

   each context.  This structure is used to manage a single context.

*/

typedef struct CyAsContext

{

    uint8_t                         number ;                /* The context number for this context */

    CyAsHalSleepChannel             channel ;               /* This sleep channel is used to sleep while waiting on a response from the

                                                               West Bridge device for a request. */

    CyAsLLRequestResponse *         req_p ;                 /* The buffer for received requests */

    uint16_t                        request_length ;        /* The length of the request being received */

    CyAsResponseCallback            request_callback ;      /* The callback for the next request received */

    CyAsLLRequestListNode *         request_queue_p ;       /* A list of low level requests to go to the firmware */

    CyAsLLRequestListNode *         last_node_p ;           /* The list node in the request queue */

    uint16_t                        queue_index ;           /* Index upto which data is stored. */

    uint16_t                        rqt_index ;             /* Index to the next request in the queue. */

    uint16_t                        data_queue[128] ;       /* Queue of data stored */

} CyAsContext ;

#define CyAsContextIsWaiting(ctxt) ((ctxt)->state & CY_AS_CTXT_STATE_WAITING_RESPONSE)

#define CyAsContextSetWaiting(ctxt) ((ctxt)->state |= CY_AS_CTXT_STATE_WAITING_RESPONSE)

#define CyAsContextClearWaiting(ctxt) ((ctxt)->state &= ~CY_AS_CTXT_STATE_WAITING_RESPONSE)

/* Summary

   This data structure stores SDIO function parameters for a SDIO card

   Description

*/

typedef struct CyAsSDIODevice

{

    uint8_t     function_init_map; /* Keeps track of IO functions initialized*/

    uint8_t     function_suspended_map;

    CyAsSDIOCard card;            /* Function 0 (Card Common) properties*/

    CyAsSDIOFunc function[7];   /* Function 1-7 (Mapped to array element 0-6) properties.*/

}CyAsSDIODevice;

/* Summary

Macros to access the SDIO card properties

*/

//GetFunction Code

#define CyAsSdioGetFunctionCode(handle,bus,i)       ((CyAsDevice *)handle)->sdiocard[bus].function[i-1].function_code

//Get Function Extended Code

#define CyAsSdioGetFunctionExtCode(handle,bus,i)    ((CyAsDevice *)handle)->sdiocard[bus].function[i-1].extended_func_code

//Get Function Product Serial number

#define CyAsSdioGetFunctionPSN(handle,bus,i)        ((CyAsDevice *)handle)->sdiocard[bus].function[i-1].card_psn

//Get Function Block Size

#define CyAsSdioGetFunctionBlocksize(handle,bus,i)  ((CyAsDevice *)handle)->sdiocard[bus].function[i-1].blocksize

//Get Function Max Block Size

#define CyAsSdioGetFunctionMaxBlocksize(handle,bus,i)  ((CyAsDevice *)handle)->sdiocard[bus].function[i-1].maxblocksize

//Get Function CSA support

#define CyAsSdioGetFunctionCsaSupport(handle,bus,i) ((CyAsDevice *)handle)->sdiocard[bus].function[i-1].csa_bits

//Get Function Wakeup Support

#define CyAsSdioGetFunctionWakeupSupport(handle,bus,i) ((CyAsDevice *)handle)->sdiocard[bus].function[i-1]. wakeup_support

#define CyAsSdioSetFunctionBlockSize(handle,bus,i,blocksize) (((CyAsDevice *)handle)->sdiocard[bus].function[i-1].blocksize = blocksize)

//Get Number of funtions on card

#define CyAsSdioGetCardNumFunctions(handle,bus)     ((CyAsDevice *)handle)->sdiocard[bus].card.num_functions

//Check if memory is present on the card

#define CyAsSdioGetCardMemPresent(handle,bus)       ((CyAsDevice *)handle)->sdiocard[bus].card.memory_present

//Get Card manufaturer ID

#define CyAsSdioGetCardManfId(handle,bus)           ((CyAsDevice *)handle)->sdiocard[bus].card.manufacturer_Id

//Get Card manufacturer Information

#define CyAsSdioGetCardManfInfo(handle,bus)         ((CyAsDevice *)handle)->sdiocard[bus].card.manufacturer_info

//Get Card Block Size

#define CyAsSdioGetCardBlocksize(handle,bus)        ((CyAsDevice *)handle)->sdiocard[bus].card.blocksize

//Get Card max Block Size

#define CyAsSdioGetCardMaxBlocksize(handle,bus)        ((CyAsDevice *)handle)->sdiocard[bus].card.maxblocksize

//Get SDIO version supported by card

#define CyAsSdioGetCardSDIOVersion(handle,bus)      ((CyAsDevice *)handle)->sdiocard[bus].card.sdio_version

//Get Card capabillity register

#define CyAsSdioGetCardCapability(handle,bus)       ((CyAsDevice *)handle)->sdiocard[bus].card.card_capability

//Get function initialization map

#define CyAsSdioGetFunctionInitMap(handle,bus)      ((CyAsDevice *)handle)->sdiocard[bus].function_init_map

//Check if function i has been initialized

#define CyAsSdioCheckFunctionInitialized(handle,bus,i) (((CyAsSdioGetFunctionInitMap(handle,bus))& (0x01<<i))?1:0)

//Set the Card functio 0 block size

#define CyAsSdioSetCardBlockSize(handle,bus,blocksize) (((CyAsDevice *)handle)->sdiocard[bus].card.blocksize = blocksize)

//Check if the Card supports Bus suspend.

#define CyAsSdioCheckSupportBusSuspend(handle,bus)      ((CyAsSdioGetCardCapability(handle,bus) & CY_SDIO_SBS)?1:0)

//Check if a fuction is in suspended state

#define CyAsSdioCheckFunctionSuspended(handle,bus,i)    ((((CyAsDevice *)handle)->sdiocard[bus].function_suspended_map & (0x01<<i))?1:0)

//Set a function state to suspended

#define CyAsSdioSetFunctionSuspended(handle,bus,i)      ((((CyAsDevice *)handle)->sdiocard[bus].function_suspended_map) |= (0x01<<i))

//Clear a function suspended state

#define CyAsSdioClearFunctionSuspended(handle,bus,i)      ((((CyAsDevice *)handle)->sdiocard[bus].function_suspended_map) &= (~(0x01<<i)))

/* Summary

   This data structure represents a single device.

   Description

*/

struct CyAsDevice

{

    /* General stuff */

    uint32_t                    sig ;                       /* A signature to insure we have a valid handle */

    uint16_t                    silicon_id ;                /* The ID of the silicon */

    struct CyAsDevice *         next_p ;                    /* Pointer to the next device */

    CyAsHalDeviceTag            tag ;                       /* This is the client specific tag for this device */

    uint32_t                    state ;                     /* This contains various state information about the device */

    CyBool                      use_int_drq ;               /* Flag indicating whether INT# pin is used for DRQ */

    /* DMA related */

    CyAsDmaEndPoint     *       endp[16] ;                  /* The endpoint pointers associated with this device */

    CyAsDmaQueueEntry *         dma_freelist_p ;            /* List of queue entries that can be used for xfers */

    /* Low level comm related */

    CyAsContext *               context[CY_RQT_CONTEXT_COUNT] ; /* The contexts available in this device */

    CyAsReturnStatus_t          ll_error ;                  /* The low level error returned from sending an async request */

    CyBool                      ll_sending_rqt ;            /* A request is currently being sent to West Bridge. */

    CyBool                      ll_abort_curr_rqt ;         /* The current mailbox request should be aborted. */

    CyBool                      ll_queued_data ;            /* Indicates that the LL layer has queued mailbox data. */

    /* MISC API related */