1 /* Cypress West Bridge API header file (cyasdevice.h)
2 ## ===========================
3 ## Copyright (C) 2010 Cypress Semiconductor
5 ## This program is free software; you can redistribute it and/or
6 ## modify it under the terms of the GNU General Public License
7 ## as published by the Free Software Foundation; either version 2
8 ## of the License, or (at your option) any later version.
10 ## This program is distributed in the hope that it will be useful,
11 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 ## GNU General Public License for more details.
15 ## You should have received a copy of the GNU General Public License
16 ## along with this program; if not, write to the Free Software
17 ## Foundation, Inc., 51 Franklin Street, Fifth Floor
18 ##Boston, MA 02110-1301, USA.
19 ## ===========================
22 #ifndef __INCLUDED_CYASDEVICE_H__
23 #define __INCLUDED_CYASDEVICE_H__
26 #include "cyasprotocol.h"
28 #include "cyasstorage.h"
30 #include "cyas_cplus_start.h"
32 /***********************************
33 * West Bridge Constants
34 ***********************************/
36 /* The endpoints used by West Bridge for the P port to S port path */
37 #define CY_AS_P2S_WRITE_ENDPOINT (0x04)
38 #define CY_AS_P2S_READ_ENDPOINT (0x08)
40 /* The endpoint to use for firmware download */
41 #define CY_AS_FIRMWARE_ENDPOINT (0x02)
43 /* The maximum size of the firmware image West Bridge can accept */
44 #define CY_AS_MAXIMUM_FIRMWARE_SIZE (24 * 1024)
46 /* The maximum size of a write for EP0 and EP1 */
47 #define CY_AS_EP0_MAX_WRITE_SIZE (128)
48 #define CY_AS_EP1_MAX_WRITE_SIZE (64)
50 /* The bitfields for the device state value */
52 /* The device is in StandBy mode */
53 #define CY_AS_DEVICE_STATE_PIN_STANDBY (0x00000001)
54 /* The device has been configured */
55 #define CY_AS_DEVICE_STATE_CONFIGURED (0x00000002)
56 /* The firmware has been loaded into the device */
57 #define CY_AS_DEVICE_STATE_FIRMWARE_LOADED (0x00000004)
58 /* The interrupt module has been initialized */
59 #define CY_AS_DEVICE_STATE_LOWLEVEL_MODULE (0x00000008)
60 /* The DMA module has been initialized */
61 #define CY_AS_DEVICE_STATE_DMA_MODULE (0x00000010)
62 /* The interrupt module has been initialized */
63 #define CY_AS_DEVICE_STATE_INTR_MODULE (0x00000020)
64 /* The storage module has been initialized */
65 #define CY_AS_DEVICE_STATE_STORAGE_MODULE (0x00000040)
66 /* The USB module has been initialized */
67 #define CY_AS_DEVICE_STATE_USB_MODULE (0x00000080)
68 /* If set, the API wants SCSI messages */
69 #define CY_AS_DEVICE_STATE_STORAGE_SCSIMSG (0x00000100)
70 /* If set, an ASYNC storage operation is pending */
71 #define CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING (0x00000200)
72 /* If set, the USB port is connected */
73 #define CY_AS_DEVICE_STATE_USB_CONNECTED (0x00000400)
74 /* If set and USB is connected, it is high speed */
75 #define CY_AS_DEVICE_STATE_USB_HIGHSPEED (0x00000800)
76 /* If set, we are in a callback */
77 #define CY_AS_DEVICE_STATE_IN_CALLBACK (0x00001000)
78 /* If set, we are processing a setup packet */
79 #define CY_AS_DEVICE_STATE_IN_SETUP_PACKET (0x00004000)
80 /* The device was placed in standby via register */
81 #define CY_AS_DEVICE_STATE_REGISTER_STANDBY (0x00008000)
82 /* If set, the device is using a crystal */
83 #define CY_AS_DEVICE_STATE_CRYSTAL (0x00010000)
84 /* If set, wakeup has been called */
85 #define CY_AS_DEVICE_STATE_WAKING (0x00020000)
86 /* If set, EP0 has been stalled. */
87 #define CY_AS_DEVICE_STATE_EP0_STALLED (0x00040000)
88 /* If set, device is in suspend mode. */
89 #define CY_AS_DEVICE_STATE_SUSPEND (0x00080000)
90 /* If set, device is a reset is pending. */
91 #define CY_AS_DEVICE_STATE_RESETP (0x00100000)
92 /* If set, device is a standby is pending. */
93 #define CY_AS_DEVICE_STATE_STANDP (0x00200000)
94 /* If set, device has a storage start or stop pending. */
95 #define CY_AS_DEVICE_STATE_SSSP (0x00400000)
96 /* If set, device has a usb start or stop pending. */
97 #define CY_AS_DEVICE_STATE_USSP (0x00800000)
98 /* If set, device has a mtp start or stop pending. */
99 #define CY_AS_DEVICE_STATE_MSSP (0x01000000)
100 /* If set, P2S DMA transfer can be started. */
101 #define CY_AS_DEVICE_STATE_P2SDMA_START (0x02000000)
103 /* The bitfields for the endpoint state value */
104 /* DMA requests are accepted into the queue */
105 #define CY_AS_DMA_ENDPOINT_STATE_ENABLED (0x0001)
106 /* The endpoint has a sleeping client, waiting on a queue drain */
107 #define CY_AS_DMA_ENDPOINT_STATE_SLEEPING (0x0002)
108 /* The DMA backend to hardware is running */
109 #define CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING (0x0004)
110 /* There is an outstanding DMA entry deployed to the HAL */
111 #define CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT (0x0008)
112 /* 0 = OUT (West Bridge -> P Port), 1 = IN (P Port -> West Bridge) */
113 #define CY_AS_DMA_ENDPOINT_STATE_DIRECTION (0x0010)
115 /* The state values for the request list */
116 /* Mask for getting the state information */
117 #define CY_AS_REQUEST_LIST_STATE_MASK (0x0f)
118 /* The request is queued, nothing further */
119 #define CY_AS_REQUEST_LIST_STATE_QUEUED (0x00)
120 /* The request is sent, waiting for response */
121 #define CY_AS_REQUEST_LIST_STATE_WAITING (0x01)
122 /* The response has been received, processing reponse */
123 #define CY_AS_REQUEST_LIST_STATE_RECEIVED (0x02)
124 /* The request/response is being canceled */
125 #define CY_AS_REQUEST_LIST_STATE_CANCELING (0x03)
126 /* The request is synchronous */
127 #define CY_AS_REQUEST_LIST_STATE_SYNC (0x80)
129 /* The flag values for a LL RequestResponse */
130 /* This request requires an ACK to be sent after it is completed */
131 #define CY_AS_REQUEST_RESPONSE_DELAY_ACK (0x01)
132 /* This request originated from a version V1.1 function call */
133 #define CY_AS_REQUEST_RESPONSE_EX (0x02)
134 /* This request originated from a version V1.2 function call */
135 #define CY_AS_REQUEST_RESPONSE_MS (0x04)
138 #define CY_AS_DEVICE_HANDLE_SIGNATURE (0x01211219)
141 * This macro returns the endpoint pointer given the
142 * device pointer and an endpoint number
144 #define CY_AS_NUM_EP(dev_p, num) ((dev_p)->endp[(num)])
146 /****************************************
147 * West Bridge Data Structures
148 ****************************************/
150 typedef struct cy_as_device cy_as_device;
153 This type defines a callback function that will be called
154 on completion of a DMA operation.
157 This function definition is for a function that is called when
158 the DMA operation is complete. This function is called with the
159 endpoint number, operation type, buffer pointer and size.
165 typedef void (*cy_as_dma_callback)(
166 /* The device that completed DMA */
168 /* The endpoint that completed DMA */
169 cy_as_end_point_number_t ep,
170 /* The pointer to the buffer that completed DMA */
172 /* The amount of data transferred */
174 /* The error code for this DMA xfer */
175 cy_as_return_status_t error
179 This structure defines a DMA request that is queued
182 This structure contains the information about a DMA
183 request that is queued and is to be sent when possible.
185 typedef struct cy_as_dma_queue_entry {
186 /* Pointer to memory buffer for this request */
188 /* Size of the memory buffer for DMA operation */
190 /* Offset into memory buffer for next DMA operation */
192 /* If TRUE and IN request */
194 /* If TRUE, this is a read request */
196 /* Callback function for when DMA is complete */
197 cy_as_dma_callback cb;
198 /* Pointer to next entry in queue */
199 struct cy_as_dma_queue_entry *next_p;
200 } cy_as_dma_queue_entry;
203 This structure defines the endpoint data for a given
206 This structure defines all of the information required
207 to manage DMA for a given endpoint.
209 typedef struct cy_as_dma_end_point {
210 /* The endpoint number */
211 cy_as_end_point_number_t ep;
212 /* The state of this endpoint */
214 /* The maximum amount of data accepted in a packet by the hw */
216 /* The maximum amount of data accepted by the HAL layer */
218 /* The queue for DMA operations */
219 cy_as_dma_queue_entry *queue_p;
220 /* The last entry in the DMA queue */
221 cy_as_dma_queue_entry *last_p;
222 /* This sleep channel is used to wait while the DMA queue
223 * drains for a given endpoint */
224 cy_as_hal_sleep_channel channel;
225 } cy_as_dma_end_point;
227 #define cy_as_end_point_number_is_usb(n) \
228 ((n) != 2 && (n) != 4 && (n) != 6 && (n) != 8)
229 #define cy_as_end_point_number_is_storage(n) \
230 ((n) == 2 || (n) == 4 || (n) == 6 || (n) == 8)
232 #define cy_as_dma_end_point_is_enabled(ep) \
233 ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_ENABLED)
234 #define cy_as_dma_end_point_enable(ep) \
235 ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_ENABLED)
236 #define cy_as_dma_end_point_disable(ep) \
237 ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_ENABLED)
239 #define cy_as_dma_end_point_is_sleeping(ep) \
240 ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_SLEEPING)
241 #define cy_as_dma_end_point_set_sleep_state(ep) \
242 ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_SLEEPING)
243 #define cy_as_dma_end_point_set_wake_state(ep) \
244 ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_SLEEPING)
246 #define cy_as_dma_end_point_is_running(ep) \
247 ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING)
248 #define cy_as_dma_end_point_set_running(ep) \
249 ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING)
250 #define cy_as_dma_end_point_set_stopped(ep) \
251 ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING)
253 #define cy_as_dma_end_point_in_transit(ep) \
254 ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT)
255 #define cy_as_dma_end_point_set_in_transit(ep) \
256 ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT)
257 #define cy_as_dma_end_point_clear_in_transit(ep) \
258 ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT)
260 #define cy_as_dma_end_point_is_direction_in(ep) \
261 (((ep)->state & CY_AS_DMA_ENDPOINT_STATE_DIRECTION) == \
262 CY_AS_DMA_ENDPOINT_STATE_DIRECTION)
263 #define cy_as_dma_end_point_is_direction_out(ep) \
264 (((ep)->state & CY_AS_DMA_ENDPOINT_STATE_DIRECTION) == 0)
265 #define cy_as_dma_end_point_set_direction_in(ep) \
266 ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_DIRECTION)
267 #define cy_as_dma_end_point_set_direction_out(ep) \
268 ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_DIRECTION)
270 #define cy_as_dma_end_point_is_usb(p) \
271 cy_as_end_point_number_is_usb((p)->ep)
272 #define cy_as_dma_end_point_is_storage(p) \
273 cy_as_end_point_number_is_storage((p)->ep)
275 typedef struct cy_as_ll_request_response {
276 /* The mbox[0] contents - see low level comm section of API doc */
278 /* The amount of data stored in this request/response in bytes */
280 /* Length of this request in words */
282 /* Additional status information about the request */
284 /* Note: This is over indexed and contains the request/response data */
286 } cy_as_ll_request_response;
289 * The callback function for responses
291 typedef void (*cy_as_response_callback)(
292 /* The device that had the response */
294 /* The context receiving a response */
296 /* The request data */
297 cy_as_ll_request_response *rqt,
298 /* The response data */
299 cy_as_ll_request_response *resp,
300 /* The status of the request */
301 cy_as_return_status_t status
304 typedef struct cy_as_ll_request_list_node {
305 /* The request to send */
306 cy_as_ll_request_response *rqt;
307 /* The associated response for the request */
308 cy_as_ll_request_response *resp;
309 /* Length of the response */
311 /* The callback to call when done */
312 cy_as_response_callback callback;
313 /* The state of the request */
315 /* The next request in the list */
316 struct cy_as_ll_request_list_node *next;
317 } cy_as_ll_request_list_node;
319 #define cy_as_request_get_node_state(node_p) \
320 ((node_p)->state & CY_AS_REQUEST_LIST_STATE_MASK)
321 #define cy_as_request_set_node_state(node_p, st) \
323 ((node_p)->state & ~CY_AS_REQUEST_LIST_STATE_MASK) | (st))
325 #define cy_as_request_node_is_sync(node_p) \
326 ((node_p)->state & CY_AS_REQUEST_LIST_STATE_SYNC)
327 #define cy_as_request_node_set_sync(node_p) \
328 ((node_p)->state |= CY_AS_REQUEST_LIST_STATE_SYNC)
329 #define cy_as_request_node_clear_sync(node_p) \
330 ((node_p)->state &= ~CY_AS_REQUEST_LIST_STATE_SYNC)
333 typedef enum cy_as_c_b_node_type {
339 } cy_as_c_b_node_type;
341 typedef struct cy_as_func_c_b_node {
342 cy_as_c_b_node_type node_type;
343 cy_as_function_callback cb_p;
344 uint32_t client_data;
345 cy_as_funct_c_b_type data_type;
347 struct cy_as_func_c_b_node *next_p;
348 } cy_as_func_c_b_node;
350 extern cy_as_func_c_b_node*
351 cy_as_create_func_c_b_node_data(cy_as_function_callback
352 cb, uint32_t client, cy_as_funct_c_b_type type, void *data);
354 extern cy_as_func_c_b_node*
355 cy_as_create_func_c_b_node(cy_as_function_callback cb,
359 cy_as_destroy_func_c_b_node(cy_as_func_c_b_node *node);
361 typedef struct cy_as_mtp_func_c_b_node {
362 cy_as_c_b_node_type type;
363 cy_as_mtp_function_callback cb_p;
364 uint32_t client_data;
365 struct cy_as_mtp_func_c_b_node *next_p;
366 } cy_as_mtp_func_c_b_node;
368 extern cy_as_mtp_func_c_b_node*
369 cy_as_create_mtp_func_c_b_node(cy_as_mtp_function_callback cb,
373 cy_as_destroy_mtp_func_c_b_node(cy_as_mtp_func_c_b_node *node);
375 typedef struct cy_as_usb_func_c_b_node {
376 cy_as_c_b_node_type type;
377 cy_as_usb_function_callback cb_p;
378 uint32_t client_data;
379 struct cy_as_usb_func_c_b_node *next_p;
380 } cy_as_usb_func_c_b_node;
382 extern cy_as_usb_func_c_b_node*
383 cy_as_create_usb_func_c_b_node(cy_as_usb_function_callback cb,
387 cy_as_destroy_usb_func_c_b_node(cy_as_usb_func_c_b_node *node);
389 typedef struct cy_as_usb_io_c_b_node {
390 cy_as_c_b_node_type type;
391 cy_as_usb_io_callback cb_p;
392 struct cy_as_usb_io_c_b_node *next_p;
393 } cy_as_usb_io_c_b_node;
395 extern cy_as_usb_io_c_b_node*
396 cy_as_create_usb_io_c_b_node(cy_as_usb_io_callback cb);
399 cy_as_destroy_usb_io_c_b_node(cy_as_usb_io_c_b_node *node);
401 typedef struct cy_as_storage_io_c_b_node {
402 cy_as_c_b_node_type type;
403 cy_as_storage_callback cb_p;
404 /* The media for the currently outstanding async storage request */
405 cy_as_media_type media;
406 /* The device index for the currently outstanding async storage
408 uint32_t device_index;
409 /* The unit index for the currently outstanding async storage
412 /* The block address for the currently outstanding async storage
415 /* The operation for the currently outstanding async storage
417 cy_as_oper_type oper;
418 cy_as_ll_request_response *req_p;
419 cy_as_ll_request_response *reply_p;
420 struct cy_as_storage_io_c_b_node *next_p;
421 } cy_as_storage_io_c_b_node;
423 extern cy_as_storage_io_c_b_node*
424 cy_as_create_storage_io_c_b_node(cy_as_storage_callback cb,
425 cy_as_media_type media, uint32_t device_index,
426 uint32_t unit, uint32_t block_addr, cy_as_oper_type oper,
427 cy_as_ll_request_response *req_p,
428 cy_as_ll_request_response *reply_p);
431 cy_as_destroy_storage_io_c_b_node(cy_as_storage_io_c_b_node *node);
433 typedef struct cy_as_c_b_queue {
437 cy_as_c_b_node_type type;
440 extern cy_as_c_b_queue *
441 cy_as_create_c_b_queue(cy_as_c_b_node_type type);
444 cy_as_destroy_c_b_queue(cy_as_c_b_queue *queue);
446 /* Allocates a new CyAsCBNode */
448 cy_as_insert_c_b_node(cy_as_c_b_queue *queue_p, void *cbnode);
450 /* Removes the first CyAsCBNode from the queue and frees it */
452 cy_as_remove_c_b_node(cy_as_c_b_queue *queue_p);
454 /* Remove the last CyAsCBNode from the queue and frees it */
456 cy_as_remove_c_b_tail_node(cy_as_c_b_queue *queue_p);
458 /* Removes and frees all pending callbacks */
460 cy_as_clear_c_b_queue(cy_as_c_b_queue *queue_p);
462 extern cy_as_return_status_t
463 cy_as_misc_send_request(cy_as_device *dev_p,
464 cy_as_function_callback cb,
466 cy_as_funct_c_b_type type,
468 cy_as_c_b_queue *queue,
470 cy_as_ll_request_response *req_p,
471 cy_as_ll_request_response *reply_p,
472 cy_as_response_callback rcb);
475 cy_as_misc_cancel_ex_requests(cy_as_device *dev_p);
478 Free all memory allocated by and zero all
479 structures initialized by CyAsUsbStart.
483 cy_as_device *dev_p);
486 Free all memory allocated and zero all structures initialized
490 cy_as_storage_cleanup(
491 cy_as_device *dev_p);
495 This structure defines the data structure to support a
496 given command context
499 All commands send to the West Bridge device via the mailbox
500 registers are sent via a context.Each context is independent
501 and there can be a parallel stream of requests and responses on
502 each context. This structure is used to manage a single context.
504 typedef struct cy_as_context {
505 /* The context number for this context */
507 /* This sleep channel is used to sleep while waiting on a
508 * response from the west bridge device for a request. */
509 cy_as_hal_sleep_channel channel;
510 /* The buffer for received requests */
511 cy_as_ll_request_response *req_p;
512 /* The length of the request being received */
513 uint16_t request_length;
514 /* The callback for the next request received */
515 cy_as_response_callback request_callback;
516 /* A list of low level requests to go to the firmware */
517 cy_as_ll_request_list_node *request_queue_p;
518 /* The list node in the request queue */
519 cy_as_ll_request_list_node *last_node_p;
520 /* Index upto which data is stored. */
521 uint16_t queue_index;
522 /* Index to the next request in the queue. */
524 /* Queue of data stored */
525 uint16_t data_queue[128];
529 #define cy_as_context_is_waiting(ctxt) \
530 ((ctxt)->state & CY_AS_CTXT_STATE_WAITING_RESPONSE)
531 #define cy_as_context_set_waiting(ctxt) \
532 ((ctxt)->state |= CY_AS_CTXT_STATE_WAITING_RESPONSE)
533 #define cy_as_context_clear_waiting(ctxt) \
534 ((ctxt)->state &= ~CY_AS_CTXT_STATE_WAITING_RESPONSE)
539 This data structure stores SDIO function
540 parameters for a SDIO card
544 typedef struct cy_as_sdio_device {
545 /* Keeps track of IO functions initialized*/
546 uint8_t function_init_map;
547 uint8_t function_suspended_map;
548 /* Function 0 (Card Common) properties*/
549 cy_as_sdio_card card;
550 /* Function 1-7 (Mapped to array element 0-6) properties.*/
551 cy_as_sdio_func function[7];
556 Macros to access the SDIO card properties
559 #define cy_as_sdio_get_function_code(handle, bus, i) \
560 (((cy_as_device *)handle)->sdiocard[bus].function[i-1].function_code)
562 #define cy_as_sdio_get_function_ext_code(handle, bus, i) \
563 (((cy_as_device *)handle)->sdiocard[bus].\
564 function[i-1].extended_func_code)
566 #define cy_as_sdio_get_function_p_s_n(handle, bus, i) \
567 (((cy_as_device *)handle)->sdiocard[bus].function[i-1].card_psn)
569 #define cy_as_sdio_get_function_blocksize(handle, bus, i) \
570 (((cy_as_device *)handle)->sdiocard[bus].function[i-1].blocksize)
572 #define cy_as_sdio_get_function_max_blocksize(handle, bus, i) \
573 (((cy_as_device *)handle)->sdiocard[bus].function[i-1].maxblocksize)
575 #define cy_as_sdio_get_function_csa_support(handle, bus, i) \
576 (((cy_as_device *)handle)->sdiocard[bus].function[i-1].csa_bits)
578 #define cy_as_sdio_get_function_wakeup_support(handle, bus, i) \
579 (((cy_as_device *)handle)->sdiocard[bus].function[i-1]. wakeup_support)
581 #define cy_as_sdio_set_function_block_size(handle, bus, i, blocksize) \
582 (((cy_as_device *)handle)->sdiocard[bus].function[i-1].blocksize = \
585 #define cy_as_sdio_get_card_num_functions(handle, bus) \
586 (((cy_as_device *)handle)->sdiocard[bus].card.num_functions)
588 #define cy_as_sdio_get_card_mem_present(handle, bus) \
589 (((cy_as_device *)handle)->sdiocard[bus].card.memory_present)
591 #define cy_as_sdio_get_card_manf_id(handle, bus) \
592 (((cy_as_device *)handle)->sdiocard[bus].card.manufacturer__id)
594 #define cy_as_sdio_get_card_manf_info(handle, bus) \
595 (((cy_as_device *)handle)->sdiocard[bus].card.manufacturer_info)
597 #define cy_as_sdio_get_card_blocksize(handle, bus) \
598 (((cy_as_device *)handle)->sdiocard[bus].card.blocksize)
600 #define cy_as_sdio_get_card_max_blocksize(handle, bus) \
601 (((cy_as_device *)handle)->sdiocard[bus].card.maxblocksize)
603 #define cy_as_sdio_get_card_sdio_version(handle, bus) \
604 (((cy_as_device *)handle)->sdiocard[bus].card.sdio_version)
606 #define cy_as_sdio_get_card_capability(handle, bus) \
607 (((cy_as_device *)handle)->sdiocard[bus].card.card_capability)
609 #define cy_as_sdio_get_function_init_map(handle, bus) \
610 (((cy_as_device *)handle)->sdiocard[bus].function_init_map)
612 #define cy_as_sdio_check_function_initialized(handle, bus, i) \
613 (((cy_as_sdio_get_function_init_map(handle, bus)) & (0x01<<i)) ? 1 : 0)
615 #define cy_as_sdio_set_card_block_size(handle, bus, blocksize) \
616 (((cy_as_device *)handle)->sdiocard[bus].card.blocksize = blocksize)
618 #define cy_as_sdio_check_support_bus_suspend(handle, bus) \
619 ((cy_as_sdio_get_card_capability(handle, bus) & CY_SDIO_SBS) ? 1 : 0)
621 #define cy_as_sdio_check_function_suspended(handle, bus, i) \
622 ((((cy_as_device *)handle)->sdiocard[bus].function_suspended_map & \
625 #define cy_as_sdio_set_function_suspended(handle, bus, i) \
626 ((((cy_as_device *)handle)->sdiocard[bus].function_suspended_map) \
629 #define cy_as_sdio_clear_function_suspended(handle, bus, i) \
630 ((((cy_as_device *)handle)->sdiocard[bus].function_suspended_map) \
634 This data structure represents a single device.
638 struct cy_as_device {
640 /* A signature to insure we have a valid handle */
642 /* The ID of the silicon */
644 /* Pointer to the next device */
645 struct cy_as_device *next_p;
646 /* This is the client specific tag for this device */
647 cy_as_hal_device_tag tag;
648 /* This contains various state information about the device */
650 /* Flag indicating whether INT# pin is used for DRQ */
654 /* The endpoint pointers associated with this device */
655 cy_as_dma_end_point *endp[16];
656 /* List of queue entries that can be used for xfers */
657 cy_as_dma_queue_entry *dma_freelist_p;
659 /* Low level comm related */
660 /* The contexts available in this device */
661 cy_as_context *context[CY_RQT_CONTEXT_COUNT];
662 /* The low level error returned from sending an async request */
663 cy_as_return_status_t ll_error;
664 /* A request is currently being sent to West Bridge. */
665 cy_bool ll_sending_rqt;
666 /* The current mailbox request should be aborted. */
667 cy_bool ll_abort_curr_rqt;
668 /* Indicates that the LL layer has queued mailbox data. */
669 cy_bool ll_queued_data;
671 /* MISC API related */
673 cy_as_misc_event_callback misc_event_cb;
675 /* Storage Related */
676 /* The reference count for the Storage API */
677 uint32_t storage_count;
678 /* Callback for storage events */
679 cy_as_storage_event_callback_dep storage_event_cb;
680 /* V1.2+ callback for storage events */
681 cy_as_storage_event_callback storage_event_cb_ms;
682 /* The error for a sleeping storage operation */
683 cy_as_return_status_t storage_error;
684 /* Flag indicating that the storage stack is waiting for an operation */
685 cy_bool storage_wait;
686 /* Request used for storage read/writes. */
687 cy_as_ll_request_response *storage_rw_req_p;
688 /* Response used for storage read/writes. */
689 cy_as_ll_request_response *storage_rw_resp_p;
690 /* The storage callback */
691 cy_as_storage_callback_dep storage_cb;
692 /* The V1.2+ storage callback */
693 cy_as_storage_callback storage_cb_ms;
694 /* The bus index for the currently outstanding async storage request */
695 cy_as_bus_number_t storage_bus_index;
696 /* The device index for the currently outstanding async storage
698 uint32_t storage_device_index;
699 /* The unit index for the currently outstanding async storage request */
700 uint32_t storage_unit;
701 /* The block address for the currently outstanding async storage
703 uint32_t storage_block_addr;
704 /* The operation for the currently outstanding async storage request */
705 cy_as_oper_type storage_oper;
706 /* The endpoint used to read Storage data */
707 cy_as_end_point_number_t storage_read_endpoint;
708 /* The endpoint used to write endpoint data */
709 cy_as_end_point_number_t storage_write_endpoint;
710 cy_as_device_desc storage_device_info
711 [CY_AS_MAX_BUSES][CY_AS_MAX_STORAGE_DEVICES];
712 /* The information on each device on each bus */
715 /* This conatins the endpoint async state */
717 /* The reference count for the USB API */
719 /* The physical endpoint configuration */
720 uint8_t usb_phy_config;
721 /* The callbacks for async func calls */
722 cy_as_c_b_queue *usb_func_cbs;
723 /* Endpoint configuration information */
724 cy_as_usb_end_point_config usb_config[16];
725 /* The USB callback */
726 cy_as_usb_event_callback_dep usb_event_cb;
727 /* The V1.2+ USB callback */
728 cy_as_usb_event_callback usb_event_cb_ms;
729 /* The error for a sleeping usb operation */
730 cy_as_return_status_t usb_error;
731 /* The USB callback for a pending storage operation */
732 cy_as_usb_io_callback usb_cb[16];
733 /* The buffer pending from a USB operation */
734 void *usb_pending_buffer;
735 /* The size of the buffer pending from a USB operation */
736 uint32_t usb_pending_size;
737 /* If true, send a short packet */
738 cy_bool usb_spacket[16];
739 /* The amount of data actually xferred */
740 uint32_t usb_actual_cnt;
741 /* EP1OUT and EP1IN config register contents */
742 uint8_t usb_ep1cfg[2];
743 /* LEP config register contents */
744 uint16_t usb_lepcfg[10];
745 /* PEP config register contents */
746 uint16_t usb_pepcfg[4];
747 /* Buffer for EP0 and EP1 data sent via mailboxes */
748 uint8_t *usb_ep_data;
749 /* Used to track how many ack requests are pending */
750 uint32_t usb_delay_ack_count;
751 /* Maximum transfer size for USB endpoints. */
752 uint32_t usb_max_tx_size;
754 /* Request for sending EP0 data to West Bridge */
755 cy_as_ll_request_response *usb_ep0_dma_req;
756 /* Response for EP0 data sent to West Bridge */
757 cy_as_ll_request_response *usb_ep0_dma_resp;
758 /* Request for sending EP1 data to West Bridge */
759 cy_as_ll_request_response *usb_ep1_dma_req;
760 /* Response for EP1 data sent to West Bridge */
761 cy_as_ll_request_response *usb_ep1_dma_resp;
763 cy_as_ll_request_response *usb_ep0_dma_req_save;
764 cy_as_ll_request_response *usb_ep0_dma_resp_save;
767 /* The reference count for the MTP API */
769 /* The MTP event callback supplied by the client */
770 cy_as_mtp_event_callback mtp_event_cb;
771 /* The current block table to be transfered */
772 cy_as_mtp_block_table *tp_blk_tbl;
774 cy_as_c_b_queue *func_cbs_mtp;
775 cy_as_c_b_queue *func_cbs_usb;
776 cy_as_c_b_queue *func_cbs_stor;
777 cy_as_c_b_queue *func_cbs_misc;
778 cy_as_c_b_queue *func_cbs_res;
780 /* The last USB event that was received */
781 cy_as_usb_event usb_last_event;
782 /* Types of storage media supported by the firmware */
783 uint8_t media_supported[CY_AS_MAX_BUSES];
785 /* SDIO card parameters*/
786 cy_as_sdio_device sdiocard[CY_AS_MAX_BUSES];
787 /* if true, MTP enabled Firmware. */
788 cy_bool is_mtp_firmware;
789 /* if true, mailbox message has come already */
790 cy_bool is_mtp_data_pending;
791 /* True between the time an Init was called and
792 * the complete event is generated */
793 cy_bool mtp_turbo_active;
794 /* mbox reported EP 2 data len */
795 uint16_t mtp_data_len;
796 /* The error for mtp EP4 write operation */
797 cy_as_return_status_t mtp_error;
798 /* mtp send/get operation callback */
799 cy_as_function_callback mtp_cb;
800 /* mtp send/get operation client id */
802 /* mtp operation type. To be used in callback */
803 cy_as_funct_c_b_type mtp_op;
805 /* Firmware is running in P2S only mode. */
806 cy_bool is_storage_only_mode;
807 /* Interrupt mask value during device standby. */
808 uint32_t stby_int_mask;
811 #define cy_as_device_is_configured(dp) \
812 ((dp)->state & CY_AS_DEVICE_STATE_CONFIGURED)
813 #define cy_as_device_set_configured(dp) \
814 ((dp)->state |= CY_AS_DEVICE_STATE_CONFIGURED)
815 #define cy_as_device_set_unconfigured(dp) \
816 ((dp)->state &= ~CY_AS_DEVICE_STATE_CONFIGURED)
818 #define cy_as_device_is_dma_running(dp) \
819 ((dp)->state & CY_AS_DEVICE_STATE_DMA_MODULE)
820 #define cy_as_device_set_dma_running(dp) \
821 ((dp)->state |= CY_AS_DEVICE_STATE_DMA_MODULE)
822 #define cy_as_device_set_dma_stopped(dp) \
823 ((dp)->state &= ~CY_AS_DEVICE_STATE_DMA_MODULE)
825 #define cy_as_device_is_low_level_running(dp) \
826 ((dp)->state & CY_AS_DEVICE_STATE_LOWLEVEL_MODULE)
827 #define cy_as_device_set_low_level_running(dp) \
828 ((dp)->state |= CY_AS_DEVICE_STATE_LOWLEVEL_MODULE)
829 #define cy_as_device_set_low_level_stopped(dp) \
830 ((dp)->state &= ~CY_AS_DEVICE_STATE_LOWLEVEL_MODULE)
832 #define cy_as_device_is_intr_running(dp) \
833 ((dp)->state & CY_AS_DEVICE_STATE_INTR_MODULE)
834 #define cy_as_device_set_intr_running(dp) \
835 ((dp)->state |= CY_AS_DEVICE_STATE_INTR_MODULE)
836 #define cy_as_device_set_intr_stopped(dp) \
837 ((dp)->state &= ~CY_AS_DEVICE_STATE_INTR_MODULE)
839 #define cy_as_device_is_firmware_loaded(dp) \
840 ((dp)->state & CY_AS_DEVICE_STATE_FIRMWARE_LOADED)
841 #define cy_as_device_set_firmware_loaded(dp) \
842 ((dp)->state |= CY_AS_DEVICE_STATE_FIRMWARE_LOADED)
843 #define cy_as_device_set_firmware_not_loaded(dp) \
844 ((dp)->state &= ~CY_AS_DEVICE_STATE_FIRMWARE_LOADED)
846 #define cy_as_device_is_storage_running(dp) \
847 ((dp)->state & CY_AS_DEVICE_STATE_STORAGE_MODULE)
848 #define cy_as_device_set_storage_running(dp) \
849 ((dp)->state |= CY_AS_DEVICE_STATE_STORAGE_MODULE)
850 #define cy_as_device_set_storage_stopped(dp) \
851 ((dp)->state &= ~CY_AS_DEVICE_STATE_STORAGE_MODULE)
853 #define cy_as_device_is_usb_running(dp) \
854 ((dp)->state & CY_AS_DEVICE_STATE_USB_MODULE)
855 #define cy_as_device_set_usb_running(dp) \
856 ((dp)->state |= CY_AS_DEVICE_STATE_USB_MODULE)
857 #define cy_as_device_set_usb_stopped(dp) \
858 ((dp)->state &= ~CY_AS_DEVICE_STATE_USB_MODULE)
860 #define cy_as_device_wants_scsi_messages(dp) \
861 (((dp)->state & CY_AS_DEVICE_STATE_STORAGE_SCSIMSG) \
862 ? cy_true : cy_false)
863 #define cy_as_device_set_scsi_messages(dp) \
864 ((dp)->state |= CY_AS_DEVICE_STATE_STORAGE_SCSIMSG)
865 #define cy_as_device_clear_scsi_messages(dp) \
866 ((dp)->state &= ~CY_AS_DEVICE_STATE_STORAGE_SCSIMSG)
868 #define cy_as_device_is_storage_async_pending(dp) \
869 ((dp)->state & CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING)
870 #define cy_as_device_set_storage_async_pending(dp) \
871 ((dp)->state |= CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING)
872 #define cy_as_device_clear_storage_async_pending(dp) \
873 ((dp)->state &= ~CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING)
875 #define cy_as_device_is_usb_connected(dp) \
876 ((dp)->state & CY_AS_DEVICE_STATE_USB_CONNECTED)
877 #define cy_as_device_set_usb_connected(dp) \
878 ((dp)->state |= CY_AS_DEVICE_STATE_USB_CONNECTED)
879 #define cy_as_device_clear_usb_connected(dp) \
880 ((dp)->state &= ~CY_AS_DEVICE_STATE_USB_CONNECTED)
882 #define cy_as_device_is_usb_high_speed(dp) \
883 ((dp)->state & CY_AS_DEVICE_STATE_USB_HIGHSPEED)
884 #define cy_as_device_set_usb_high_speed(dp) \
885 ((dp)->state |= CY_AS_DEVICE_STATE_USB_HIGHSPEED)
886 #define cy_as_device_clear_usb_high_speed(dp) \
887 ((dp)->state &= ~CY_AS_DEVICE_STATE_USB_HIGHSPEED)
889 #define cy_as_device_is_in_callback(dp) \
890 ((dp)->state & CY_AS_DEVICE_STATE_IN_CALLBACK)
891 #define cy_as_device_set_in_callback(dp) \
892 ((dp)->state |= CY_AS_DEVICE_STATE_IN_CALLBACK)
893 #define cy_as_device_clear_in_callback(dp) \
894 ((dp)->state &= ~CY_AS_DEVICE_STATE_IN_CALLBACK)
896 #define cy_as_device_is_setup_i_o_performed(dp) \
897 ((dp)->state & CY_AS_DEVICE_STATE_SETUP_IO_PERFORMED)
898 #define cy_as_device_set_setup_i_o_performed(dp) \
899 ((dp)->state |= CY_AS_DEVICE_STATE_SETUP_IO_PERFORMED)
900 #define cy_as_device_clear_setup_i_o_performed(dp) \
901 ((dp)->state &= ~CY_AS_DEVICE_STATE_SETUP_IO_PERFORMED)
903 #define cy_as_device_is_ack_delayed(dp) \
904 ((dp)->usb_delay_ack_count > 0)
905 #define cy_as_device_set_ack_delayed(dp) \
906 ((dp)->usb_delay_ack_count++)
907 #define cy_as_device_rem_ack_delayed(dp) \
908 ((dp)->usb_delay_ack_count--)
909 #define cy_as_device_clear_ack_delayed(dp) \
910 ((dp)->usb_delay_ack_count = 0)
912 #define cy_as_device_is_setup_packet(dp) \
913 ((dp)->state & CY_AS_DEVICE_STATE_IN_SETUP_PACKET)
914 #define cy_as_device_set_setup_packet(dp) \
915 ((dp)->state |= CY_AS_DEVICE_STATE_IN_SETUP_PACKET)
916 #define cy_as_device_clear_setup_packet(dp) \
917 ((dp)->state &= ~CY_AS_DEVICE_STATE_IN_SETUP_PACKET)
919 #define cy_as_device_is_ep0_stalled(dp) \
920 ((dp)->state & CY_AS_DEVICE_STATE_EP0_STALLED)
921 #define cy_as_device_set_ep0_stalled(dp) \
922 ((dp)->state |= CY_AS_DEVICE_STATE_EP0_STALLED)
923 #define cy_as_device_clear_ep0_stalled(dp) \
924 ((dp)->state &= ~CY_AS_DEVICE_STATE_EP0_STALLED)
926 #define cy_as_device_is_register_standby(dp) \
927 ((dp)->state & CY_AS_DEVICE_STATE_REGISTER_STANDBY)
928 #define cy_as_device_set_register_standby(dp) \
929 ((dp)->state |= CY_AS_DEVICE_STATE_REGISTER_STANDBY)
930 #define cy_as_device_clear_register_standby(dp) \
931 ((dp)->state &= ~CY_AS_DEVICE_STATE_REGISTER_STANDBY)
933 #define cy_as_device_is_pin_standby(dp) \
934 ((dp)->state & CY_AS_DEVICE_STATE_PIN_STANDBY)
935 #define cy_as_device_set_pin_standby(dp) \
936 ((dp)->state |= CY_AS_DEVICE_STATE_PIN_STANDBY)
937 #define cy_as_device_clear_pin_standby(dp) \
938 ((dp)->state &= ~CY_AS_DEVICE_STATE_PIN_STANDBY)
940 #define cy_as_device_is_crystal(dp) \
941 ((dp)->state & CY_AS_DEVICE_STATE_CRYSTAL)
942 #define cy_as_device_is_external_clock(dp) \
943 (!((dp)->state & CY_AS_DEVICE_STATE_CRYSTAL))
944 #define cy_as_device_set_crystal(dp) \
945 ((dp)->state |= CY_AS_DEVICE_STATE_CRYSTAL)
946 #define cy_as_device_set_external_clock(dp) \
947 ((dp)->state &= ~CY_AS_DEVICE_STATE_CRYSTAL)
949 #define cy_as_device_is_waking(dp) \
950 ((dp)->state & CY_AS_DEVICE_STATE_WAKING)
951 #define cy_as_device_set_waking(dp) \
952 ((dp)->state |= CY_AS_DEVICE_STATE_WAKING)
953 #define cy_as_device_clear_waking(dp) \
954 ((dp)->state &= ~CY_AS_DEVICE_STATE_WAKING)
956 #define cy_as_device_is_in_suspend_mode(dp) \
957 ((dp)->state & CY_AS_DEVICE_STATE_SUSPEND)
958 #define cy_as_device_set_suspend_mode(dp) \
959 ((dp)->state |= CY_AS_DEVICE_STATE_SUSPEND)
960 #define cy_as_device_clear_suspend_mode(dp) \
961 ((dp)->state &= ~CY_AS_DEVICE_STATE_SUSPEND)
963 #define cy_as_device_is_reset_pending(dp) \
964 ((dp)->state & CY_AS_DEVICE_STATE_RESETP)
965 #define cy_as_device_set_reset_pending(dp) \
966 ((dp)->state |= CY_AS_DEVICE_STATE_RESETP)
967 #define cy_as_device_clear_reset_pending(dp) \
968 ((dp)->state &= ~CY_AS_DEVICE_STATE_RESETP)
970 #define cy_as_device_is_standby_pending(dp) \
971 ((dp)->state & CY_AS_DEVICE_STATE_STANDP)
972 #define cy_as_device_set_standby_pending(dp) \
973 ((dp)->state |= CY_AS_DEVICE_STATE_STANDP)
974 #define cy_as_device_clear_standby_pending(dp) \
975 ((dp)->state &= ~CY_AS_DEVICE_STATE_STANDP)
977 #define cy_as_device_is_s_s_s_pending(dp) \
978 ((dp)->state & CY_AS_DEVICE_STATE_SSSP)
979 #define cy_as_device_set_s_s_s_pending(dp) \
980 ((dp)->state |= CY_AS_DEVICE_STATE_SSSP)
981 #define cy_as_device_clear_s_s_s_pending(dp) \
982 ((dp)->state &= ~CY_AS_DEVICE_STATE_SSSP)
984 #define cy_as_device_is_u_s_s_pending(dp) \
985 ((dp)->state & CY_AS_DEVICE_STATE_USSP)
986 #define cy_as_device_set_u_s_s_pending(dp) \
987 ((dp)->state |= CY_AS_DEVICE_STATE_USSP)
988 #define cy_as_device_clear_u_s_s_pending(dp) \
989 ((dp)->state &= ~CY_AS_DEVICE_STATE_USSP)
991 #define cy_as_device_is_m_s_s_pending(dp) \
992 ((dp)->state & CY_AS_DEVICE_STATE_MSSP)
993 #define cy_as_device_set_m_s_s_pending(dp) \
994 ((dp)->state |= CY_AS_DEVICE_STATE_MSSP)
995 #define cy_as_device_clear_m_s_s_pending(dp) \
996 ((dp)->state &= ~CY_AS_DEVICE_STATE_MSSP)
998 #define cy_as_device_is_p2s_dma_start_recvd(dp) \
999 ((dp)->state & CY_AS_DEVICE_STATE_P2SDMA_START)
1000 #define cy_as_device_set_p2s_dma_start_recvd(dp) \
1001 ((dp)->state |= CY_AS_DEVICE_STATE_P2SDMA_START)
1002 #define cy_as_device_clear_p2s_dma_start_recvd(dp) \
1003 ((dp)->state &= ~CY_AS_DEVICE_STATE_P2SDMA_START)
1005 #define cy_as_device_is_usb_async_pending(dp, ep) \
1006 ((dp)->epasync & (1 << ep))
1007 #define cy_as_device_set_usb_async_pending(dp, ep) \
1008 ((dp)->epasync |= (1 << ep))
1009 #define cy_as_device_clear_usb_async_pending(dp, ep) \
1010 ((dp)->epasync &= ~(1 << ep))
1012 #define cy_as_device_is_nand_storage_supported(dp) \
1013 ((dp)->media_supported[0] & 1)
1015 /* Macros to check the type of West Bridge device. */
1016 #define cy_as_device_is_astoria_dev(dp) \
1017 (((dp)->silicon_id == CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_VALUE) || \
1018 ((dp)->silicon_id == CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_FPGA_VALUE))
1019 #define cy_as_device_is_antioch_dev(dp) \
1020 ((dp)->silicon_id == CY_AS_MEM_CM_WB_CFG_ID_HDID_ANTIOCH_VALUE)
1022 #ifdef CY_AS_LOG_SUPPORT
1023 extern void cy_as_log_debug_message(int value, const char *msg);
1025 #define cy_as_log_debug_message(value, msg)
1029 This function finds the device object given the HAL tag
1032 The user associats a device TAG with each West Bridge device
1033 created. This tag is passed from the API functions to and HAL
1034 functions that need to ID a specific West Bridge device. This
1035 tag is also passed in from the user back into the API via
1036 interrupt functions. This function allows the API to find the
1037 device structure associated with a given tag.
1040 This function does a simple linear search for the device based
1041 on the TAG. This function is called each time an West Bridge
1042 interrupt handler is called. Therefore this works fine for a
1043 small number of West Bridge devices (e.g. less than five).
1044 Anything more than this and this methodology will need to be
1048 Pointer to a CyAsDevice associated with the tag
1050 extern cy_as_device *
1051 cy_as_device_find_from_tag(
1052 cy_as_hal_device_tag tag
1055 #include "cyas_cplus_end.h"
1057 #endif /* __INCLUDED_CYASDEVICE_H__ */