/* 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<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<sdiocard[bus].function_suspended_map) \ |= (0x01<sdiocard[bus].function_suspended_map) \ &= (~(0x01<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__ */