diff -r b7e488c49d0d -r 117faf51deac omap3530/beagle_drivers/wb/api/src/cyasdevice.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasdevice.h	Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,756 @@
+/* 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 */
+    CyAsMiscEventCallback       misc_event_cb ;             /* Misc callback */
+
+    /* Storage Related */
+    uint32_t                    storage_count ;             /* The reference count for the Storage API */
+    CyAsStorageEventCallback_dep    storage_event_cb ;      /* Callback for storage events */
+    CyAsStorageEventCallback  storage_event_cb_ms ;         /* V1.2+ callback for storage events */
+    CyAsReturnStatus_t          storage_error ;             /* The error for a sleeping storage operation */
+    CyBool                      storage_wait ;              /* Flag indicating that the storage stack is waiting for an operation */
+    CyAsLLRequestResponse *     storage_rw_req_p ;          /* Request used for storage read/writes. */
+    CyAsLLRequestResponse *     storage_rw_resp_p ;         /* Response used for storage read/writes. */
+    CyAsStorageCallback_dep     storage_cb ;                /* The storage callback */
+    CyAsStorageCallback         storage_cb_ms ;             /* The V1.2+ storage callback */
+    CyAsBusNumber_t             storage_bus_index ;         /* The bus index for the currently outstanding async storage request */
+    uint32_t                    storage_device_index ;      /* The device index for the currently outstanding async storage request */
+    uint32_t                    storage_unit ;              /* The unit index for the currently outstanding async storage request */
+    uint32_t                    storage_block_addr ;        /* The block address for the currently outstanding async storage request */
+    CyAsOperType                storage_oper ;              /* The operation for the currently outstanding async storage request */
+    CyAsEndPointNumber_t        storage_read_endpoint ;     /* The endpoint used to read Storage data */
+    CyAsEndPointNumber_t        storage_write_endpoint ;    /* The endpoint used to write endpoint data */
+    CyAsDeviceDesc              storage_device_info[CY_AS_MAX_BUSES][CY_AS_MAX_STORAGE_DEVICES] ;
+    /* The information on each device on each bus */
+
+    /* USB Related */
+    uint16_t                    epasync ;                   /* This conatins the endpoint async state */
+    uint32_t                    usb_count ;                 /* The reference count for the USB API */
+    uint8_t                     usb_phy_config ;            /* The physical endpoint configuration */
+    CyAsCBQueue *               usb_func_cbs ;              /* The callbacks for async func calls */
+    CyAsUsbEndPointConfig       usb_config[16] ;            /* Endpoint configuration information */
+    CyAsUsbEventCallback_dep    usb_event_cb ;              /* The USB callback */
+    CyAsUsbEventCallback        usb_event_cb_ms ;           /* The V1.2+ USB callback */
+    CyAsReturnStatus_t          usb_error ;                 /* The error for a sleeping usb operation */
+    CyAsUsbIoCallback           usb_cb[16] ;                /* The USB callback for a pending storage operation */
+    void *                      usb_pending_buffer ;        /* The buffer pending from a USB operation */
+    uint32_t                    usb_pending_size ;          /* The size of the buffer pending from a USB operation */
+    CyBool                      usb_spacket[16] ;           /* If true, send a short packet */
+    uint32_t                    usb_actual_cnt ;            /* The amount of data actually xferred */
+    uint8_t                     usb_ep1cfg[2] ;             /* EP1OUT and EP1IN config register contents */
+    uint16_t                    usb_lepcfg[10] ;            /* LEP config register contents */
+    uint16_t                    usb_pepcfg[4] ;             /* PEP config register contents */
+    uint8_t *                   usb_ep_data ;               /* Buffer for EP0 and EP1 data sent via mailboxes */
+    uint32_t                    usb_delay_ack_count ;       /* Used to track how many ack requests are pending */
+    uint32_t                    usb_max_tx_size ;           /* Maximum transfer size for USB endpoints. */
+
+    CyAsLLRequestResponse *     usb_ep0_dma_req ;           /* Request for sending EP0 data to West Bridge */
+    CyAsLLRequestResponse *     usb_ep0_dma_resp ;          /* Response for EP0 data sent to West Bridge */
+    CyAsLLRequestResponse *     usb_ep1_dma_req ;           /* Request for sending EP1 data to West Bridge */
+    CyAsLLRequestResponse *     usb_ep1_dma_resp ;          /* Response for EP1 data sent to West Bridge */
+
+    CyAsLLRequestResponse *     usb_ep0_dma_req_save ;
+    CyAsLLRequestResponse *     usb_ep0_dma_resp_save ;
+
+    /* MTP Related */
+    uint32_t                    mtp_count ;                 /* The reference count for the MTP API */
+    CyAsMTPEventCallback        mtp_event_cb ;              /* The MTP event callback supplied by the client */
+    CyAsMTPBlockTable*          mtp_blk_tbl ;               /* The current block table to be transfered */
+
+    CyAsCBQueue *               func_cbs_mtp ;
+    CyAsCBQueue *               func_cbs_usb ;
+    CyAsCBQueue *               func_cbs_stor ;
+    CyAsCBQueue *               func_cbs_misc ;
+    CyAsCBQueue *               func_cbs_res ;
+
+    CyAsUsbEvent                usb_last_event ;                     /* The last USB event that was received */
+    uint8_t                     media_supported[CY_AS_MAX_BUSES] ;   /* Types of storage media supported by the firmware */
+
+    CyAsSDIODevice   sdiocard[CY_AS_MAX_BUSES];                      /* SDIO card parameters*/
+    CyBool                      is_mtp_firmware ;                    /* if true, MTP enabled Firmware. */
+    CyBool                      is_mtp_data_pending ;                /* if true, mailbox message has come already */
+    CyBool                      mtp_turbo_active ;                   /* True between the time an Init was called and the complete event is generated */
+    uint16_t                    mtp_data_len ;                       /* mbox reported EP 2 data len */
+    CyAsReturnStatus_t          mtp_error ;                          /* The error for mtp EP4 write operation */
+    CyAsFunctionCallback        mtp_cb ;                             /* mtp send/get operation callback */
+    uint32_t                    mtp_client ;                         /* mtp send/get operation client id */
+    CyAsFunctCBType             mtp_op ;                             /* mtp operation type. To be used in callback */
+
+    CyBool                      is_storage_only_mode ;               /* Firmware is running in P2S only mode. */
+    uint32_t                    stby_int_mask ;                      /* Interrupt mask value during device standby. */
+} ;
+
+#define CyAsDeviceIsConfigured(dp) ((dp)->state & CY_AS_DEVICE_STATE_CONFIGURED)
+#define CyAsDeviceSetConfigured(dp) ((dp)->state |= CY_AS_DEVICE_STATE_CONFIGURED)
+#define CyAsDeviceSetUnconfigured(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_CONFIGURED)
+
+#define CyAsDeviceIsDmaRunning(dp)      ((dp)->state & CY_AS_DEVICE_STATE_DMA_MODULE)
+#define CyAsDeviceSetDmaRunning(dp)     ((dp)->state |= CY_AS_DEVICE_STATE_DMA_MODULE)
+#define CyAsDeviceSetDmaStopped(dp)     ((dp)->state &= ~CY_AS_DEVICE_STATE_DMA_MODULE)
+
+#define CyAsDeviceIsLowLevelRunning(dp) ((dp)->state & CY_AS_DEVICE_STATE_LOWLEVEL_MODULE)
+#define CyAsDeviceSetLowLevelRunning(dp) ((dp)->state |= CY_AS_DEVICE_STATE_LOWLEVEL_MODULE)
+#define CyAsDeviceSetLowLevelStopped(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_LOWLEVEL_MODULE)
+
+#define CyAsDeviceIsIntrRunning(dp) ((dp)->state & CY_AS_DEVICE_STATE_INTR_MODULE)
+#define CyAsDeviceSetIntrRunning(dp) ((dp)->state |= CY_AS_DEVICE_STATE_INTR_MODULE)
+#define CyAsDeviceSetIntrStopped(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_INTR_MODULE)
+
+#define CyAsDeviceIsFirmwareLoaded(dp) ((dp)->state & CY_AS_DEVICE_STATE_FIRMWARE_LOADED)
+#define CyAsDeviceSetFirmwareLoaded(dp) ((dp)->state |= CY_AS_DEVICE_STATE_FIRMWARE_LOADED)
+#define CyAsDeviceSetFirmwareNotLoaded(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_FIRMWARE_LOADED)
+
+#define CyAsDeviceIsStorageRunning(dp) ((dp)->state & CY_AS_DEVICE_STATE_STORAGE_MODULE)
+#define CyAsDeviceSetStorageRunning(dp) ((dp)->state |= CY_AS_DEVICE_STATE_STORAGE_MODULE)
+#define CyAsDeviceSetStorageStopped(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_STORAGE_MODULE)
+
+#define CyAsDeviceIsUsbRunning(dp) ((dp)->state & CY_AS_DEVICE_STATE_USB_MODULE)
+#define CyAsDeviceSetUsbRunning(dp) ((dp)->state |= CY_AS_DEVICE_STATE_USB_MODULE)
+#define CyAsDeviceSetUsbStopped(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_USB_MODULE)
+
+#define CyAsDeviceWantsScsiMessages(dp) (((dp)->state & CY_AS_DEVICE_STATE_STORAGE_SCSIMSG) ? CyTrue : CyFalse)
+#define CyAsDeviceSetScsiMessages(dp) ((dp)->state |= CY_AS_DEVICE_STATE_STORAGE_SCSIMSG)
+#define CyAsDeviceClearScsiMessages(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_STORAGE_SCSIMSG)
+
+#define CyAsDeviceIsStorageAsyncPending(dp) ((dp)->state & CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING)
+#define CyAsDeviceSetStorageAsyncPending(dp) ((dp)->state |= CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING)
+#define CyAsDeviceClearStorageAsyncPending(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING)
+
+#define CyAsDeviceIsUsbConnected(dp) ((dp)->state & CY_AS_DEVICE_STATE_USB_CONNECTED)
+#define CyAsDeviceSetUsbConnected(dp) ((dp)->state |= CY_AS_DEVICE_STATE_USB_CONNECTED)
+#define CyAsDeviceClearUsbConnected(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_USB_CONNECTED)
+
+#define CyAsDeviceIsUsbHighSpeed(dp) ((dp)->state & CY_AS_DEVICE_STATE_USB_HIGHSPEED)
+#define CyAsDeviceSetUsbHighSpeed(dp) ((dp)->state |= CY_AS_DEVICE_STATE_USB_HIGHSPEED)
+#define CyAsDeviceClearUsbHighSpeed(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_USB_HIGHSPEED)
+
+#define CyAsDeviceIsInCallback(dp) ((dp)->state & CY_AS_DEVICE_STATE_IN_CALLBACK)
+#define CyAsDeviceSetInCallback(dp) ((dp)->state |= CY_AS_DEVICE_STATE_IN_CALLBACK)
+#define CyAsDeviceClearInCallback(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_IN_CALLBACK)
+
+#define CyAsDeviceIsSetupIOPerformed(dp) ((dp)->state & CY_AS_DEVICE_STATE_SETUP_IO_PERFORMED)
+#define CyAsDeviceSetSetupIOPerformed(dp) ((dp)->state |= CY_AS_DEVICE_STATE_SETUP_IO_PERFORMED)
+#define CyAsDeviceClearSetupIOPerformed(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_SETUP_IO_PERFORMED)
+
+#define CyAsDeviceIsAckDelayed(dp) ((dp)->usb_delay_ack_count > 0)
+#define CyAsDeviceSetAckDelayed(dp) ((dp)->usb_delay_ack_count++)
+#define CyAsDeviceRemAckDelayed(dp) ((dp)->usb_delay_ack_count--)
+#define CyAsDeviceClearAckDelayed(dp) ((dp)->usb_delay_ack_count = 0)
+
+#define CyAsDeviceIsSetupPacket(dp) ((dp)->state & CY_AS_DEVICE_STATE_IN_SETUP_PACKET)
+#define CyAsDeviceSetSetupPacket(dp) ((dp)->state |= CY_AS_DEVICE_STATE_IN_SETUP_PACKET)
+#define CyAsDeviceClearSetupPacket(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_IN_SETUP_PACKET)
+
+#define CyAsDeviceIsEp0Stalled(dp) ((dp)->state & CY_AS_DEVICE_STATE_EP0_STALLED)
+#define CyAsDeviceSetEp0Stalled(dp) ((dp)->state |= CY_AS_DEVICE_STATE_EP0_STALLED)
+#define CyAsDeviceClearEp0Stalled(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_EP0_STALLED)
+
+#define CyAsDeviceIsRegisterStandby(dp) ((dp)->state & CY_AS_DEVICE_STATE_REGISTER_STANDBY)
+#define CyAsDeviceSetRegisterStandby(dp) ((dp)->state |= CY_AS_DEVICE_STATE_REGISTER_STANDBY)
+#define CyAsDeviceClearRegisterStandby(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_REGISTER_STANDBY)
+
+#define CyAsDeviceIsPinStandby(dp) ((dp)->state & CY_AS_DEVICE_STATE_PIN_STANDBY)
+#define CyAsDeviceSetPinStandby(dp) ((dp)->state |= CY_AS_DEVICE_STATE_PIN_STANDBY)
+#define CyAsDeviceClearPinStandby(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_PIN_STANDBY)
+
+#define CyAsDeviceIsCrystal(dp) ((dp)->state & CY_AS_DEVICE_STATE_CRYSTAL)
+#define CyAsDeviceIsExternalClock(dp) (!((dp)->state & CY_AS_DEVICE_STATE_CRYSTAL))
+#define CyAsDeviceSetCrystal(dp) ((dp)->state |= CY_AS_DEVICE_STATE_CRYSTAL)
+#define CyAsDeviceSetExternalClock(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_CRYSTAL)
+
+#define CyAsDeviceIsWaking(dp) ((dp)->state & CY_AS_DEVICE_STATE_WAKING)
+#define CyAsDeviceSetWaking(dp) ((dp)->state |= CY_AS_DEVICE_STATE_WAKING)
+#define CyAsDeviceClearWaking(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_WAKING)
+
+#define CyAsDeviceIsInSuspendMode(dp) ((dp)->state & CY_AS_DEVICE_STATE_SUSPEND)
+#define CyAsDeviceSetSuspendMode(dp) ((dp)->state |= CY_AS_DEVICE_STATE_SUSPEND)
+#define CyAsDeviceClearSuspendMode(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_SUSPEND)
+
+#define CyAsDeviceIsResetPending(dp) ((dp)->state & CY_AS_DEVICE_STATE_RESETP)
+#define CyAsDeviceSetResetPending(dp) ((dp)->state |= CY_AS_DEVICE_STATE_RESETP)
+#define CyAsDeviceClearResetPending(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_RESETP)
+
+#define CyAsDeviceIsStandbyPending(dp) ((dp)->state & CY_AS_DEVICE_STATE_STANDP)
+#define CyAsDeviceSetStandbyPending(dp) ((dp)->state |= CY_AS_DEVICE_STATE_STANDP)
+#define CyAsDeviceClearStandbyPending(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_STANDP)
+
+#define CyAsDeviceIsSSSPending(dp) ((dp)->state & CY_AS_DEVICE_STATE_SSSP)
+#define CyAsDeviceSetSSSPending(dp) ((dp)->state |= CY_AS_DEVICE_STATE_SSSP)
+#define CyAsDeviceClearSSSPending(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_SSSP)
+
+#define CyAsDeviceIsUSSPending(dp) ((dp)->state & CY_AS_DEVICE_STATE_USSP)
+#define CyAsDeviceSetUSSPending(dp) ((dp)->state |= CY_AS_DEVICE_STATE_USSP)
+#define CyAsDeviceClearUSSPending(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_USSP)
+
+#define CyAsDeviceIsMSSPending(dp) ((dp)->state & CY_AS_DEVICE_STATE_MSSP)
+#define CyAsDeviceSetMSSPending(dp) ((dp)->state |= CY_AS_DEVICE_STATE_MSSP)
+#define CyAsDeviceClearMSSPending(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_MSSP)
+
+#define CyAsDeviceIsUsbAsyncPending(dp, ep) ((dp)->epasync & (1 << ep))
+#define CyAsDeviceSetUsbAsyncPending(dp, ep) ((dp)->epasync |= (1 << ep))
+#define CyAsDeviceClearUsbAsyncPending(dp, ep) ((dp)->epasync &= ~(1 << ep))
+
+#define CyAsDeviceIsNandStorageSupported(dp) ((dp)->media_supported[0] & 1)
+
+/* Macros to check the type of West Bridge device. */
+#define CyAsDeviceIsAstoriaDev(dp) (((dp)->silicon_id == CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_VALUE) || \
+        ((dp)->silicon_id == CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_FPGA_VALUE))
+#define CyAsDeviceIsAntiochDev(dp) ((dp)->silicon_id == CY_AS_MEM_CM_WB_CFG_ID_HDID_ANTIOCH_VALUE)
+
+#ifdef CY_AS_LOG_SUPPORT
+extern void CyAsLogDebugMessage(int value, const char *msg) ;
+#else
+#define CyAsLogDebugMessage(value, msg)
+#endif
+
+/* Summary
+   This function finds the device object given the HAL tag
+
+   Description
+   The user associats a device TAG with each West Bridge device created.  This tag is passed from the
+   API functions to and HAL functions that need to ID a specific West Bridge device.  This tag is also
+   passed in from the user back into the API via interrupt functions.  This function allows the API
+   to find the device structure associated with a given tag.
+
+   Notes
+   This function does a simple linear search for the device based on the TAG.  This function is
+   called each time an West Bridge interrupt handler is called.  Therefore this works fine for a small
+   number of West Bridge devices (e.g. less than five).  Anything more than this and this methodology
+   will need to be updated.
+
+   Returns
+   Pointer to a CyAsDevice associated with the tag
+*/
+extern CyAsDevice *
+CyAsDeviceFindFromTag(
+        CyAsHalDeviceTag tag
+        ) ;
+
+#include "cyas_cplus_end.h"
+
+#endif          /* __INCLUDED_CYASDEVICE_H__ */