/* Cypress West Bridge API header file (cyasdevice.h)
## ===========================
## Copyright (C) 2010  Cypress Semiconductor
##
## This program is free software; you can redistribute it and/or
## modify it under the terms of the GNU General Public License
## as published by the Free Software Foundation; either version 2
## of the License, or (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 51 Franklin Street, Fifth Floor
##Boston, MA  02110-1301, USA.
## ===========================
*/

#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 */

/* The device is in StandBy mode */
#define CY_AS_DEVICE_STATE_PIN_STANDBY (0x00000001)
/* The device has been configured */
#define CY_AS_DEVICE_STATE_CONFIGURED (0x00000002)
/* The firmware has been loaded into the device */
#define CY_AS_DEVICE_STATE_FIRMWARE_LOADED (0x00000004)
/* The interrupt module has been initialized */
#define CY_AS_DEVICE_STATE_LOWLEVEL_MODULE (0x00000008)
/* The DMA module has been initialized */
#define CY_AS_DEVICE_STATE_DMA_MODULE (0x00000010)
/* The interrupt module has been initialized */
#define CY_AS_DEVICE_STATE_INTR_MODULE (0x00000020)
/* The storage module has been initialized */
#define CY_AS_DEVICE_STATE_STORAGE_MODULE (0x00000040)
/* The USB module has been initialized */
#define CY_AS_DEVICE_STATE_USB_MODULE (0x00000080)
/* If set, the API wants SCSI messages */
#define CY_AS_DEVICE_STATE_STORAGE_SCSIMSG (0x00000100)
/* If set, an ASYNC storage operation is pending */
#define CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING (0x00000200)
/* If set, the USB port is connected */
#define CY_AS_DEVICE_STATE_USB_CONNECTED (0x00000400)
/* If set and USB is connected, it is high speed */
#define CY_AS_DEVICE_STATE_USB_HIGHSPEED (0x00000800)
/* If set, we are in a callback */
#define CY_AS_DEVICE_STATE_IN_CALLBACK (0x00001000)
/* If set, we are processing a setup packet */
#define CY_AS_DEVICE_STATE_IN_SETUP_PACKET (0x00004000)
/* The device was placed in standby via register */
#define CY_AS_DEVICE_STATE_REGISTER_STANDBY (0x00008000)
/* If set, the device is using a crystal */
#define CY_AS_DEVICE_STATE_CRYSTAL (0x00010000)
/* If set, wakeup has been called */
#define CY_AS_DEVICE_STATE_WAKING (0x00020000)
/* If set, EP0 has been stalled. */
#define CY_AS_DEVICE_STATE_EP0_STALLED (0x00040000)
/* If set, device is in suspend mode. */
#define CY_AS_DEVICE_STATE_SUSPEND (0x00080000)
/* If set, device is a reset is pending. */
#define CY_AS_DEVICE_STATE_RESETP (0x00100000)
/* If set, device is a standby is pending. */
#define CY_AS_DEVICE_STATE_STANDP (0x00200000)
/* If set, device has a storage start or stop pending. */
#define CY_AS_DEVICE_STATE_SSSP (0x00400000)
/* If set, device has a usb start or stop pending. */
#define CY_AS_DEVICE_STATE_USSP (0x00800000)
/* If set, device has a mtp start or stop pending. */
#define CY_AS_DEVICE_STATE_MSSP (0x01000000)
/* If set, P2S DMA transfer can be started. */
#define CY_AS_DEVICE_STATE_P2SDMA_START (0x02000000)

/* The bitfields for the endpoint state value */
/* DMA requests are accepted into the queue */
#define CY_AS_DMA_ENDPOINT_STATE_ENABLED (0x0001)
/* The endpoint has a sleeping client, waiting on a queue drain */
#define CY_AS_DMA_ENDPOINT_STATE_SLEEPING (0x0002)
/* The DMA backend to hardware is running */
#define CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING (0x0004)
/* There is an outstanding DMA entry deployed to the HAL */
#define CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT (0x0008)
/* 0 = OUT (West Bridge -> P Port), 1 = IN (P Port -> West Bridge) */
#define CY_AS_DMA_ENDPOINT_STATE_DIRECTION (0x0010)

/* The state values for the request list */
/* Mask for getting the state information */
#define CY_AS_REQUEST_LIST_STATE_MASK (0x0f)
/* The request is queued, nothing further */
#define CY_AS_REQUEST_LIST_STATE_QUEUED (0x00)
/* The request is sent, waiting for response */
#define CY_AS_REQUEST_LIST_STATE_WAITING (0x01)
/* The response has been received, processing reponse */
#define CY_AS_REQUEST_LIST_STATE_RECEIVED (0x02)
/* The request/response is being canceled */
#define CY_AS_REQUEST_LIST_STATE_CANCELING (0x03)
/* The request is synchronous */
#define CY_AS_REQUEST_LIST_STATE_SYNC (0x80)

/* The flag values for a LL RequestResponse */
/* This request requires an ACK to be sent after it is completed */
#define CY_AS_REQUEST_RESPONSE_DELAY_ACK (0x01)
/* This request originated from a version V1.1 function call */
#define CY_AS_REQUEST_RESPONSE_EX (0x02)
/* This request originated from a version V1.2 function call */
#define CY_AS_REQUEST_RESPONSE_MS (0x04)


#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 cy_as_device cy_as_device;

/* 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 (*cy_as_dma_callback)(
        /* The device that completed DMA */
        cy_as_device *dev_p,
        /* The endpoint that completed DMA */
        cy_as_end_point_number_t ep,
        /* The pointer to the buffer that completed DMA */
        void *mem_p,
        /* The amount of data transferred */
        uint32_t size,
        /* The error code for this DMA xfer */
        cy_as_return_status_t error
        );

/* 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 cy_as_dma_queue_entry {
        /* Pointer to memory buffer for this request */
        void *buf_p;
        /* Size of the memory buffer for DMA operation */
        uint32_t size;
        /* Offset into memory buffer for next DMA operation */
        uint32_t offset;
        /* If TRUE and IN request */
        cy_bool packet;
        /* If TRUE, this is a read request */
        cy_bool readreq;
        /* Callback function for when DMA is complete */
        cy_as_dma_callback      cb;
        /* Pointer to next entry in queue */
        struct cy_as_dma_queue_entry *next_p;
} cy_as_dma_queue_entry;

/* 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 cy_as_dma_end_point {
        /* The endpoint number */
        cy_as_end_point_number_t ep;
        /* The state of this endpoint */
        uint8_t state;
        /* The maximum amount of data accepted in a packet by the hw */
        uint16_t maxhwdata;
        /* The maximum amount of data accepted by the HAL layer */
        uint32_t maxhaldata;
        /* The queue for DMA operations */
        cy_as_dma_queue_entry *queue_p;
        /* The last entry in the DMA queue */
        cy_as_dma_queue_entry *last_p;
        /* This sleep channel is used to wait while the DMA queue
         * drains for a given endpoint */
        cy_as_hal_sleep_channel                  channel;
} cy_as_dma_end_point;

#define cy_as_end_point_number_is_usb(n) \
        ((n) != 2 && (n) != 4 && (n) != 6 && (n) != 8)
#define cy_as_end_point_number_is_storage(n) \
        ((n) == 2 || (n) == 4 || (n) == 6 || (n) == 8)

#define cy_as_dma_end_point_is_enabled(ep) \
        ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_ENABLED)
#define cy_as_dma_end_point_enable(ep) \
        ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_ENABLED)
#define cy_as_dma_end_point_disable(ep) \
        ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_ENABLED)

#define cy_as_dma_end_point_is_sleeping(ep) \
        ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_SLEEPING)
#define cy_as_dma_end_point_set_sleep_state(ep) \
        ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_SLEEPING)
#define cy_as_dma_end_point_set_wake_state(ep) \
        ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_SLEEPING)

#define cy_as_dma_end_point_is_running(ep) \
        ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING)
#define cy_as_dma_end_point_set_running(ep) \
        ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING)
#define cy_as_dma_end_point_set_stopped(ep) \
        ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING)

#define cy_as_dma_end_point_in_transit(ep) \
        ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT)
#define cy_as_dma_end_point_set_in_transit(ep) \
        ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT)
#define cy_as_dma_end_point_clear_in_transit(ep) \
        ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT)

#define cy_as_dma_end_point_is_direction_in(ep) \
        (((ep)->state & CY_AS_DMA_ENDPOINT_STATE_DIRECTION) == \
                CY_AS_DMA_ENDPOINT_STATE_DIRECTION)
#define cy_as_dma_end_point_is_direction_out(ep) \
        (((ep)->state & CY_AS_DMA_ENDPOINT_STATE_DIRECTION) == 0)
#define cy_as_dma_end_point_set_direction_in(ep) \
        ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_DIRECTION)
#define cy_as_dma_end_point_set_direction_out(ep) \
        ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_DIRECTION)

#define cy_as_dma_end_point_is_usb(p) \
        cy_as_end_point_number_is_usb((p)->ep)
#define cy_as_dma_end_point_is_storage(p) \
        cy_as_end_point_number_is_storage((p)->ep)

typedef struct cy_as_ll_request_response {
        /* The mbox[0] contents - see low level comm section of API doc */
        uint16_t        box0;
        /* The amount of data stored in this request/response in bytes */
        uint16_t        stored;
        /* Length of this request in words */
        uint16_t        length;
        /* Additional status information about the request */
        uint16_t        flags;
        /* Note: This is over indexed and contains the request/response data */
        uint16_t        data[1];
} cy_as_ll_request_response;

/*
 * The callback function for responses
 */
typedef void (*cy_as_response_callback)(
        /* The device that had the response */
        cy_as_device *dev_p,
        /* The context receiving a response */
        uint8_t                                          context,
        /* The request data */
        cy_as_ll_request_response *rqt,
        /* The response data */
        cy_as_ll_request_response *resp,
        /* The status of the request */
        cy_as_return_status_t status
        );

typedef struct cy_as_ll_request_list_node {
        /* The request to send */
        cy_as_ll_request_response *rqt;
        /* The associated response for the request */
        cy_as_ll_request_response *resp;
        /* Length of the response */
        uint16_t                                                length;
        /* The callback to call when done */
        cy_as_response_callback                 callback;
        /* The state of the request */
        uint8_t                                          state;
        /* The next request in the list */
        struct cy_as_ll_request_list_node *next;
} cy_as_ll_request_list_node;

#define cy_as_request_get_node_state(node_p) \
        ((node_p)->state & CY_AS_REQUEST_LIST_STATE_MASK)
#define cy_as_request_set_node_state(node_p, st) \
        ((node_p)->state = \
        ((node_p)->state & ~CY_AS_REQUEST_LIST_STATE_MASK) | (st))

#define cy_as_request_node_is_sync(node_p) \
        ((node_p)->state & CY_AS_REQUEST_LIST_STATE_SYNC)
#define cy_as_request_node_set_sync(node_p) \
        ((node_p)->state |= CY_AS_REQUEST_LIST_STATE_SYNC)
#define cy_as_request_node_clear_sync(node_p) \
        ((node_p)->state &= ~CY_AS_REQUEST_LIST_STATE_SYNC)

#ifndef __doxygen__
typedef enum cy_as_c_b_node_type {
        CYAS_INVALID,
        CYAS_USB_FUNC_CB,
        CYAS_USB_IO_CB,
        CYAS_STORAGE_IO_CB,
        CYAS_FUNC_CB
} cy_as_c_b_node_type;

typedef struct cy_as_func_c_b_node {
        cy_as_c_b_node_type                       node_type;
        cy_as_function_callback         cb_p;
        uint32_t                                        client_data;
        cy_as_funct_c_b_type                     data_type;
        void    *data;
        struct cy_as_func_c_b_node *next_p;
} cy_as_func_c_b_node;

extern cy_as_func_c_b_node*
cy_as_create_func_c_b_node_data(cy_as_function_callback
        cb, uint32_t client, cy_as_funct_c_b_type type, void *data);

extern cy_as_func_c_b_node*
cy_as_create_func_c_b_node(cy_as_function_callback cb,
        uint32_t client);

extern void
cy_as_destroy_func_c_b_node(cy_as_func_c_b_node *node);

typedef struct cy_as_mtp_func_c_b_node {
        cy_as_c_b_node_type                       type;
        cy_as_mtp_function_callback      cb_p;
        uint32_t                                        client_data;
        struct cy_as_mtp_func_c_b_node *next_p;
} cy_as_mtp_func_c_b_node;

extern cy_as_mtp_func_c_b_node*
cy_as_create_mtp_func_c_b_node(cy_as_mtp_function_callback cb,
        uint32_t client);

extern void
cy_as_destroy_mtp_func_c_b_node(cy_as_mtp_func_c_b_node *node);

typedef struct cy_as_usb_func_c_b_node {
        cy_as_c_b_node_type     type;
        cy_as_usb_function_callback      cb_p;
        uint32_t client_data;
        struct cy_as_usb_func_c_b_node *next_p;
} cy_as_usb_func_c_b_node;

extern cy_as_usb_func_c_b_node*
cy_as_create_usb_func_c_b_node(cy_as_usb_function_callback cb,
        uint32_t client);

extern void
cy_as_destroy_usb_func_c_b_node(cy_as_usb_func_c_b_node *node);

typedef struct cy_as_usb_io_c_b_node {
        cy_as_c_b_node_type                       type;
        cy_as_usb_io_callback              cb_p;
        struct cy_as_usb_io_c_b_node *next_p;
} cy_as_usb_io_c_b_node;

extern cy_as_usb_io_c_b_node*
cy_as_create_usb_io_c_b_node(cy_as_usb_io_callback cb);

extern void
cy_as_destroy_usb_io_c_b_node(cy_as_usb_io_c_b_node *node);

typedef struct cy_as_storage_io_c_b_node {
        cy_as_c_b_node_type                       type;
        cy_as_storage_callback           cb_p;
        /* The media for the currently outstanding async storage request */
        cy_as_media_type                           media;
        /* The device index for the currently outstanding async storage
         * request */
        uint32_t                                        device_index;
        /* The unit index for the currently outstanding async storage
         * request */
        uint32_t                                        unit;
        /* The block address for the currently outstanding async storage
         * request */
        uint32_t                                        block_addr;
        /* The operation for the currently outstanding async storage
         * request */
        cy_as_oper_type                         oper;
        cy_as_ll_request_response *req_p;
        cy_as_ll_request_response *reply_p;
        struct cy_as_storage_io_c_b_node *next_p;
} cy_as_storage_io_c_b_node;

extern cy_as_storage_io_c_b_node*
cy_as_create_storage_io_c_b_node(cy_as_storage_callback cb,
        cy_as_media_type media, uint32_t device_index,
        uint32_t unit, uint32_t block_addr, cy_as_oper_type oper,
        cy_as_ll_request_response *req_p,
        cy_as_ll_request_response *reply_p);

extern void
cy_as_destroy_storage_io_c_b_node(cy_as_storage_io_c_b_node *node);

typedef struct cy_as_c_b_queue {
        void *head_p;
        void *tail_p;
        uint32_t count;
        cy_as_c_b_node_type type;
} cy_as_c_b_queue;

extern cy_as_c_b_queue *
cy_as_create_c_b_queue(cy_as_c_b_node_type type);

extern void
cy_as_destroy_c_b_queue(cy_as_c_b_queue *queue);

/* Allocates a new CyAsCBNode */
extern void
cy_as_insert_c_b_node(cy_as_c_b_queue *queue_p, void *cbnode);

/* Removes the first CyAsCBNode from the queue and frees it */
extern void
cy_as_remove_c_b_node(cy_as_c_b_queue *queue_p);

/* Remove the last CyAsCBNode from the queue and frees it */
extern void
cy_as_remove_c_b_tail_node(cy_as_c_b_queue *queue_p);

/* Removes and frees all pending callbacks */
extern void
cy_as_clear_c_b_queue(cy_as_c_b_queue *queue_p);

extern cy_as_return_status_t
cy_as_misc_send_request(cy_as_device *dev_p,
                                          cy_as_function_callback cb,
                                          uint32_t client,
                                          cy_as_funct_c_b_type type,
                                          void *data,
                                          cy_as_c_b_queue *queue,
                                          uint16_t req_type,
                                          cy_as_ll_request_response *req_p,
                                          cy_as_ll_request_response *reply_p,
                                          cy_as_response_callback rcb);

extern void
cy_as_misc_cancel_ex_requests(cy_as_device *dev_p);

/* Summary
   Free all memory allocated by and zero all
   structures initialized by CyAsUsbStart.
 */
extern void
cy_as_usb_cleanup(
                cy_as_device *dev_p);

/* Summary
   Free all memory allocated and zero all structures initialized
   by CyAsStorageStart.
 */
extern void
cy_as_storage_cleanup(
                cy_as_device *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 cy_as_context {
        /* The context number for this context */
        uint8_t                                          number;
        /* This sleep channel is used to sleep while waiting on a
         * response from the west bridge device for a request. */
        cy_as_hal_sleep_channel                  channel;
        /* The buffer for received requests */
        cy_as_ll_request_response *req_p;
        /* The length of the request being received */
        uint16_t request_length;
        /* The callback for the next request received */
        cy_as_response_callback request_callback;
        /* A list of low level requests to go to the firmware */
        cy_as_ll_request_list_node *request_queue_p;
        /* The list node in the request queue */
        cy_as_ll_request_list_node *last_node_p;
        /* Index upto which data is stored. */
        uint16_t queue_index;
        /* Index to the next request in the queue. */
        uint16_t rqt_index;
        /* Queue of data stored */
        uint16_t data_queue[128];

} cy_as_context;

#define cy_as_context_is_waiting(ctxt) \
        ((ctxt)->state & CY_AS_CTXT_STATE_WAITING_RESPONSE)
#define cy_as_context_set_waiting(ctxt) \
        ((ctxt)->state |= CY_AS_CTXT_STATE_WAITING_RESPONSE)
#define cy_as_context_clear_waiting(ctxt) \
        ((ctxt)->state &= ~CY_AS_CTXT_STATE_WAITING_RESPONSE)



/* Summary
   This data structure stores SDIO function
   parameters for a SDIO card

   Description
*/
typedef struct cy_as_sdio_device {
        /* Keeps track of IO functions initialized*/
        uint8_t  function_init_map;
        uint8_t  function_suspended_map;
        /* Function 0 (Card Common) properties*/
        cy_as_sdio_card card;
        /* Function 1-7 (Mapped to array element 0-6) properties.*/
        cy_as_sdio_func function[7];

} cy_as_sdio_device;

/* Summary
Macros to access the SDIO card properties
*/

#define cy_as_sdio_get_function_code(handle, bus, i) \
        (((cy_as_device *)handle)->sdiocard[bus].function[i-1].function_code)

#define cy_as_sdio_get_function_ext_code(handle, bus, i)        \
        (((cy_as_device *)handle)->sdiocard[bus].\
                function[i-1].extended_func_code)

#define cy_as_sdio_get_function_p_s_n(handle, bus, i) \
        (((cy_as_device *)handle)->sdiocard[bus].function[i-1].card_psn)

#define cy_as_sdio_get_function_blocksize(handle, bus, i)  \
        (((cy_as_device *)handle)->sdiocard[bus].function[i-1].blocksize)

#define cy_as_sdio_get_function_max_blocksize(handle, bus, i) \
        (((cy_as_device *)handle)->sdiocard[bus].function[i-1].maxblocksize)

#define cy_as_sdio_get_function_csa_support(handle, bus, i) \
        (((cy_as_device *)handle)->sdiocard[bus].function[i-1].csa_bits)

#define cy_as_sdio_get_function_wakeup_support(handle, bus, i) \
        (((cy_as_device *)handle)->sdiocard[bus].function[i-1]. wakeup_support)

#define cy_as_sdio_set_function_block_size(handle, bus, i, blocksize) \
        (((cy_as_device *)handle)->sdiocard[bus].function[i-1].blocksize = \
        blocksize)

#define cy_as_sdio_get_card_num_functions(handle, bus) \
        (((cy_as_device *)handle)->sdiocard[bus].card.num_functions)

#define cy_as_sdio_get_card_mem_present(handle, bus) \
        (((cy_as_device *)handle)->sdiocard[bus].card.memory_present)

#define cy_as_sdio_get_card_manf_id(handle, bus)        \
        (((cy_as_device *)handle)->sdiocard[bus].card.manufacturer__id)

#define cy_as_sdio_get_card_manf_info(handle, bus) \
        (((cy_as_device *)handle)->sdiocard[bus].card.manufacturer_info)

#define cy_as_sdio_get_card_blocksize(handle, bus) \
        (((cy_as_device *)handle)->sdiocard[bus].card.blocksize)

#define cy_as_sdio_get_card_max_blocksize(handle, bus) \
        (((cy_as_device *)handle)->sdiocard[bus].card.maxblocksize)

#define cy_as_sdio_get_card_sdio_version(handle, bus) \
        (((cy_as_device *)handle)->sdiocard[bus].card.sdio_version)

#define cy_as_sdio_get_card_capability(handle, bus) \
        (((cy_as_device *)handle)->sdiocard[bus].card.card_capability)

#define cy_as_sdio_get_function_init_map(handle, bus) \
        (((cy_as_device *)handle)->sdiocard[bus].function_init_map)

#define cy_as_sdio_check_function_initialized(handle, bus, i) \
        (((cy_as_sdio_get_function_init_map(handle, bus)) & (0x01<<i)) ? 1 : 0)

#define cy_as_sdio_set_card_block_size(handle, bus, blocksize) \
        (((cy_as_device *)handle)->sdiocard[bus].card.blocksize = blocksize)

#define cy_as_sdio_check_support_bus_suspend(handle, bus) \
        ((cy_as_sdio_get_card_capability(handle, bus) & CY_SDIO_SBS) ? 1 : 0)

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

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

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

/* Summary
   This data structure represents a single device.

   Description
*/
struct cy_as_device {
        /* General stuff */
        /* A signature to insure we have a valid handle */
        uint32_t sig;
        /* The ID of the silicon */
        uint16_t silicon_id;
        /* Pointer to the next device */
        struct cy_as_device *next_p;
        /* This is the client specific tag for this device */
        cy_as_hal_device_tag tag;
        /* This contains various state information about the device */
        uint32_t state;
        /* Flag indicating whether INT# pin is used for DRQ */
        cy_bool use_int_drq;

        /* DMA related */
        /* The endpoint pointers associated with this device */
        cy_as_dma_end_point      *endp[16];
        /* List of queue entries that can be used for xfers */
        cy_as_dma_queue_entry *dma_freelist_p;

        /* Low level comm related */
        /* The contexts available in this device */
        cy_as_context *context[CY_RQT_CONTEXT_COUNT];
        /* The low level error returned from sending an async request */
        cy_as_return_status_t ll_error;
        /* A request is currently being sent to West Bridge. */
        cy_bool ll_sending_rqt;
        /* The current mailbox request should be aborted. */
        cy_bool ll_abort_curr_rqt;
        /* Indicates that the LL layer has queued mailbox data. */
        cy_bool ll_queued_data;

        /* MISC API related */
        /* Misc callback */
        cy_as_misc_event_callback misc_event_cb;

        /* Storage Related */
        /* The reference count for the Storage API */
        uint32_t storage_count;
        /* Callback for storage events */
        cy_as_storage_event_callback_dep        storage_event_cb;
        /* V1.2+ callback for storage events */
        cy_as_storage_event_callback  storage_event_cb_ms;
        /* The error for a sleeping storage operation */
        cy_as_return_status_t             storage_error;
        /* Flag indicating that the storage stack is waiting for an operation */
        cy_bool                                   storage_wait;
        /* Request used for storage read/writes. */
        cy_as_ll_request_response *storage_rw_req_p;
        /* Response used for storage read/writes. */
        cy_as_ll_request_response *storage_rw_resp_p;
        /* The storage callback */
        cy_as_storage_callback_dep storage_cb;
        /* The V1.2+ storage callback */
        cy_as_storage_callback storage_cb_ms;
        /* The bus index for the currently outstanding async storage request */
        cy_as_bus_number_t storage_bus_index;
        /* The device index for the currently outstanding async storage
         * request */
        uint32_t storage_device_index;
        /* The unit index for the currently outstanding async storage request */
        uint32_t storage_unit;
        /* The block address for the currently outstanding async storage
         * request */
        uint32_t storage_block_addr;
        /* The operation for the currently outstanding async storage request */
        cy_as_oper_type storage_oper;
        /* The endpoint used to read Storage data */
        cy_as_end_point_number_t storage_read_endpoint;
        /* The endpoint used to write endpoint data */
        cy_as_end_point_number_t storage_write_endpoint;
        cy_as_device_desc storage_device_info
                [CY_AS_MAX_BUSES][CY_AS_MAX_STORAGE_DEVICES];
        /* The information on each device on each bus */

        /* USB Related */
        /* This conatins the endpoint async state */
        uint16_t epasync;
        /* The reference count for the USB API */
        uint32_t usb_count;
        /* The physical endpoint configuration */
        uint8_t usb_phy_config;
        /* The callbacks for async func calls */
        cy_as_c_b_queue *usb_func_cbs;
        /* Endpoint configuration information */
        cy_as_usb_end_point_config usb_config[16];
        /* The USB callback */
        cy_as_usb_event_callback_dep usb_event_cb;
        /* The V1.2+ USB callback */
        cy_as_usb_event_callback usb_event_cb_ms;
        /* The error for a sleeping usb operation */
        cy_as_return_status_t usb_error;
        /* The USB callback for a pending storage operation */
        cy_as_usb_io_callback usb_cb[16];
        /* The buffer pending from a USB operation */
        void *usb_pending_buffer;
        /* The size of the buffer pending from a USB operation */
        uint32_t usb_pending_size;
        /* If true, send a short packet */
        cy_bool usb_spacket[16];
        /* The amount of data actually xferred */
        uint32_t usb_actual_cnt;
        /* EP1OUT and EP1IN config register contents */
        uint8_t usb_ep1cfg[2];
        /* LEP config register contents */
        uint16_t usb_lepcfg[10];
        /* PEP config register contents */
        uint16_t usb_pepcfg[4];
        /* Buffer for EP0 and EP1 data sent via mailboxes */
        uint8_t *usb_ep_data;
        /* Used to track how many ack requests are pending */
        uint32_t usb_delay_ack_count;
        /* Maximum transfer size for USB endpoints. */
        uint32_t usb_max_tx_size;

        /* Request for sending EP0 data to West Bridge */
        cy_as_ll_request_response *usb_ep0_dma_req;
        /* Response for EP0 data sent to West Bridge */
        cy_as_ll_request_response *usb_ep0_dma_resp;
        /* Request for sending EP1 data to West Bridge */
        cy_as_ll_request_response *usb_ep1_dma_req;
        /* Response for EP1 data sent to West Bridge */
        cy_as_ll_request_response *usb_ep1_dma_resp;

        cy_as_ll_request_response *usb_ep0_dma_req_save;
        cy_as_ll_request_response *usb_ep0_dma_resp_save;

        /* MTP Related */
        /* The reference count for the MTP API */
        uint32_t mtp_count;
        /* The MTP event callback supplied by the client */
        cy_as_mtp_event_callback mtp_event_cb;
        /* The current block table to be transfered */
        cy_as_mtp_block_table *tp_blk_tbl;

        cy_as_c_b_queue *func_cbs_mtp;
        cy_as_c_b_queue *func_cbs_usb;
        cy_as_c_b_queue *func_cbs_stor;
        cy_as_c_b_queue *func_cbs_misc;
        cy_as_c_b_queue *func_cbs_res;

        /* The last USB event that was received */
        cy_as_usb_event usb_last_event;
        /* Types of storage media supported by the firmware */
        uint8_t media_supported[CY_AS_MAX_BUSES];

        /* SDIO card parameters*/
        cy_as_sdio_device   sdiocard[CY_AS_MAX_BUSES];
        /* if true, MTP enabled Firmware. */
        cy_bool is_mtp_firmware;
        /* if true, mailbox message has come already */
        cy_bool is_mtp_data_pending;
        /* True between the time an Init was called and
         * the complete event is generated */
        cy_bool mtp_turbo_active;
        /* mbox reported EP 2 data len */
        uint16_t mtp_data_len;
        /* The error for mtp EP4 write operation */
        cy_as_return_status_t mtp_error;
        /* mtp send/get operation callback */
        cy_as_function_callback mtp_cb;
        /* mtp send/get operation client id */
        uint32_t mtp_client;
        /* mtp operation type. To be used in callback */
        cy_as_funct_c_b_type mtp_op;

        /* Firmware is running in P2S only mode. */
        cy_bool is_storage_only_mode;
        /* Interrupt mask value during device standby. */
        uint32_t stby_int_mask;
};

#define cy_as_device_is_configured(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_CONFIGURED)
#define cy_as_device_set_configured(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_CONFIGURED)
#define cy_as_device_set_unconfigured(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_CONFIGURED)

#define cy_as_device_is_dma_running(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_DMA_MODULE)
#define cy_as_device_set_dma_running(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_DMA_MODULE)
#define cy_as_device_set_dma_stopped(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_DMA_MODULE)

#define cy_as_device_is_low_level_running(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_LOWLEVEL_MODULE)
#define cy_as_device_set_low_level_running(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_LOWLEVEL_MODULE)
#define cy_as_device_set_low_level_stopped(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_LOWLEVEL_MODULE)

#define cy_as_device_is_intr_running(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_INTR_MODULE)
#define cy_as_device_set_intr_running(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_INTR_MODULE)
#define cy_as_device_set_intr_stopped(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_INTR_MODULE)

#define cy_as_device_is_firmware_loaded(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_FIRMWARE_LOADED)
#define cy_as_device_set_firmware_loaded(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_FIRMWARE_LOADED)
#define cy_as_device_set_firmware_not_loaded(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_FIRMWARE_LOADED)

#define cy_as_device_is_storage_running(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_STORAGE_MODULE)
#define cy_as_device_set_storage_running(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_STORAGE_MODULE)
#define cy_as_device_set_storage_stopped(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_STORAGE_MODULE)

#define cy_as_device_is_usb_running(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_USB_MODULE)
#define cy_as_device_set_usb_running(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_USB_MODULE)
#define cy_as_device_set_usb_stopped(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_USB_MODULE)

#define cy_as_device_wants_scsi_messages(dp) \
        (((dp)->state & CY_AS_DEVICE_STATE_STORAGE_SCSIMSG) \
        ? cy_true : cy_false)
#define cy_as_device_set_scsi_messages(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_STORAGE_SCSIMSG)
#define cy_as_device_clear_scsi_messages(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_STORAGE_SCSIMSG)

#define cy_as_device_is_storage_async_pending(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING)
#define cy_as_device_set_storage_async_pending(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING)
#define cy_as_device_clear_storage_async_pending(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING)

#define cy_as_device_is_usb_connected(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_USB_CONNECTED)
#define cy_as_device_set_usb_connected(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_USB_CONNECTED)
#define cy_as_device_clear_usb_connected(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_USB_CONNECTED)

#define cy_as_device_is_usb_high_speed(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_USB_HIGHSPEED)
#define cy_as_device_set_usb_high_speed(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_USB_HIGHSPEED)
#define cy_as_device_clear_usb_high_speed(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_USB_HIGHSPEED)

#define cy_as_device_is_in_callback(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_IN_CALLBACK)
#define cy_as_device_set_in_callback(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_IN_CALLBACK)
#define cy_as_device_clear_in_callback(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_IN_CALLBACK)

#define cy_as_device_is_setup_i_o_performed(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_SETUP_IO_PERFORMED)
#define cy_as_device_set_setup_i_o_performed(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_SETUP_IO_PERFORMED)
#define cy_as_device_clear_setup_i_o_performed(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_SETUP_IO_PERFORMED)

#define cy_as_device_is_ack_delayed(dp) \
        ((dp)->usb_delay_ack_count > 0)
#define cy_as_device_set_ack_delayed(dp) \
        ((dp)->usb_delay_ack_count++)
#define cy_as_device_rem_ack_delayed(dp) \
        ((dp)->usb_delay_ack_count--)
#define cy_as_device_clear_ack_delayed(dp) \
        ((dp)->usb_delay_ack_count = 0)

#define cy_as_device_is_setup_packet(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_IN_SETUP_PACKET)
#define cy_as_device_set_setup_packet(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_IN_SETUP_PACKET)
#define cy_as_device_clear_setup_packet(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_IN_SETUP_PACKET)

#define cy_as_device_is_ep0_stalled(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_EP0_STALLED)
#define cy_as_device_set_ep0_stalled(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_EP0_STALLED)
#define cy_as_device_clear_ep0_stalled(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_EP0_STALLED)

#define cy_as_device_is_register_standby(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_REGISTER_STANDBY)
#define cy_as_device_set_register_standby(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_REGISTER_STANDBY)
#define cy_as_device_clear_register_standby(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_REGISTER_STANDBY)

#define cy_as_device_is_pin_standby(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_PIN_STANDBY)
#define cy_as_device_set_pin_standby(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_PIN_STANDBY)
#define cy_as_device_clear_pin_standby(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_PIN_STANDBY)

#define cy_as_device_is_crystal(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_CRYSTAL)
#define cy_as_device_is_external_clock(dp) \
        (!((dp)->state & CY_AS_DEVICE_STATE_CRYSTAL))
#define cy_as_device_set_crystal(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_CRYSTAL)
#define cy_as_device_set_external_clock(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_CRYSTAL)

#define cy_as_device_is_waking(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_WAKING)
#define cy_as_device_set_waking(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_WAKING)
#define cy_as_device_clear_waking(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_WAKING)

#define cy_as_device_is_in_suspend_mode(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_SUSPEND)
#define cy_as_device_set_suspend_mode(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_SUSPEND)
#define cy_as_device_clear_suspend_mode(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_SUSPEND)

#define cy_as_device_is_reset_pending(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_RESETP)
#define cy_as_device_set_reset_pending(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_RESETP)
#define cy_as_device_clear_reset_pending(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_RESETP)

#define cy_as_device_is_standby_pending(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_STANDP)
#define cy_as_device_set_standby_pending(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_STANDP)
#define cy_as_device_clear_standby_pending(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_STANDP)

#define cy_as_device_is_s_s_s_pending(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_SSSP)
#define cy_as_device_set_s_s_s_pending(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_SSSP)
#define cy_as_device_clear_s_s_s_pending(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_SSSP)

#define cy_as_device_is_u_s_s_pending(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_USSP)
#define cy_as_device_set_u_s_s_pending(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_USSP)
#define cy_as_device_clear_u_s_s_pending(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_USSP)

#define cy_as_device_is_m_s_s_pending(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_MSSP)
#define cy_as_device_set_m_s_s_pending(dp) \
        ((dp)->state |= CY_AS_DEVICE_STATE_MSSP)
#define cy_as_device_clear_m_s_s_pending(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_MSSP)

#define cy_as_device_is_p2s_dma_start_recvd(dp) \
        ((dp)->state & CY_AS_DEVICE_STATE_P2SDMA_START)
#define cy_as_device_set_p2s_dma_start_recvd(dp) \

        ((dp)->state |= CY_AS_DEVICE_STATE_P2SDMA_START)
#define cy_as_device_clear_p2s_dma_start_recvd(dp) \
        ((dp)->state &= ~CY_AS_DEVICE_STATE_P2SDMA_START)

#define cy_as_device_is_usb_async_pending(dp, ep) \
        ((dp)->epasync & (1 << ep))
#define cy_as_device_set_usb_async_pending(dp, ep) \
        ((dp)->epasync |= (1 << ep))
#define cy_as_device_clear_usb_async_pending(dp, ep) \
        ((dp)->epasync &= ~(1 << ep))

#define cy_as_device_is_nand_storage_supported(dp) \
        ((dp)->media_supported[0] & 1)

/* Macros to check the type of West Bridge device. */
#define cy_as_device_is_astoria_dev(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 cy_as_device_is_antioch_dev(dp) \
        ((dp)->silicon_id == CY_AS_MEM_CM_WB_CFG_ID_HDID_ANTIOCH_VALUE)

#ifdef CY_AS_LOG_SUPPORT
extern void cy_as_log_debug_message(int value, const char *msg);
#else
#define cy_as_log_debug_message(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 cy_as_device *
cy_as_device_find_from_tag(
                cy_as_hal_device_tag tag
                );

#include "cyas_cplus_end.h"

#endif            /* __INCLUDED_CYASDEVICE_H__ */