| /* Cypress West Bridge API header file (cyasstorage.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_CYASSTORAGE_H_ |
| #define _INCLUDED_CYASSTORAGE_H_ |
| |
| #include "cyasmedia.h" |
| #include "cyasmisc.h" |
| #include "cyas_cplus_start.h" |
| |
| |
| /*@@Storage APIs |
| Summary |
| This section documents the storage APIs supported by the |
| West Bridge API. |
| |
| Description |
| The storage API is based on some specific concepts which |
| are referenced here. |
| * <LINK Storage API Overview> |
| * Addressing |
| * Ownership |
| * <LINK Asynchronous Versus Synchronous Operation> |
| */ |
| |
| /*@@Storage API Overview |
| Summary |
| Storage devices are identified by media type. Each media |
| type is considered a single logical device. |
| |
| Description |
| Each media type has a consistent block size and consists |
| of a set of logical blocks numbered from 0 to N - 1 where |
| N is the size of the |
| media type in blocks. The mass storage APIs defined below |
| provide the |
| capability to query for devices that are present, and |
| read/write data to/from |
| these devices. |
| */ |
| |
| /*@@Addressing |
| Summary |
| Blocks within a storage device are address by a hierarchal |
| block address. This |
| address consists of the bus number, physical device, |
| logical unit, and finally |
| block address. |
| |
| Description |
| While currently only a single device of each media type |
| is supported, the address |
| space reserves space in the future for multiple devices |
| of each type. Therefore |
| the second element of the address is the specific device |
| being addressed within |
| a given device type. For this release of the software, |
| this value will always be |
| zero to address the first device. |
| |
| The third element of the address is the logical unit. |
| A device being managed |
| by West Bridge can be partitioned into multiple logical |
| units. This partition |
| information is stored on each device itself. Currently, |
| one of the storage devices |
| managed by West Bridge can be partitioned into two |
| logical units. |
| |
| Finally a logical block address is given within the |
| logical unit to address an |
| individual block. |
| */ |
| |
| /*@@Ownership |
| Summary |
| While West Bridge supports concurrent block level |
| operations from both the USB port and |
| the processor port, this is not desirable in most |
| situations as the file system |
| contained on the storage media cannot be accessed |
| concurrently. To insure access |
| by only one of USB and the processor, the West Bridge |
| API provides for ownership of storage |
| devices based on media type. |
| |
| Description |
| The processor requests ownership of a given media type |
| by calling CyAsStorageClaim(). |
| The firmware in West Bridge releases control of the |
| media and signals the processor through |
| the event callback registered with |
| CyAsStorageRegisterCallback(). The specific event is |
| the CyAsStorageProcessor. The processor can later |
| release the media via a call to |
| CyAsStorageRelease(). This call is immediate and |
| no callback is required. |
| |
| If the processor has claimed storage and the USB port |
| is connected, West Bridge will need to |
| claim the storage to manage the mass storage device. |
| West Bridge requests the storage through |
| the event callback registered with |
| CyAsStorageRegisterCallback(). The specific event is |
| CyAsStorageAntioch and is named as such to reflect |
| the USB view of storage. This callback |
| is a request for the processor to release storage. |
| The storage is not actually released |
| until the processor calls CyAsStorageRelease(). |
| |
| Note that the CyAsStorageAntioch is only sent when the |
| USB storage device is enumerated and |
| NOT at every USB operation. The ownership of a given |
| storage media type is assumed to belong |
| to the processor until the USB connection is established. |
| At that point, the storage ownership |
| is transferred to West Bridge. After the USB connection |
| is broken, ownership can be transferred |
| back to the processor. |
| */ |
| |
| /*@@Asynchronous Versus Synchronous Operation |
| Summary |
| When read or write operations are performed to the |
| storage devices, these operations may be |
| synchronous or asynchronous. A synchronous operation |
| is an operation where the read or write |
| operation is requested and the function does not return |
| until the operation is complete. This |
| type of function is the easiest to use but does not |
| provide for optimal usage of the P port processor time. |
| |
| Description |
| An asynchronous operation is one where the function returns |
| as soon as the request is started. |
| The specific read and write request will complete at some |
| time in the future and the P port |
| processor will be notified via a callback function. While |
| asynchronous functions provide for |
| much better usage of the CPU, these function have more |
| stringent requirements for use. First, |
| any buffer use for data transfer must be valid from the |
| function call to request the operation |
| through when the callback function is called. This basically |
| implies that stack based buffers |
| are not acceptable for asynchronous calls. Second, error |
| handling must be deferred until the |
| callback function is called indicating any kind of error |
| that may have occurred. |
| */ |
| |
| /*@@Partitioning |
| Summary |
| West Bridge API and firmware support the creation of up to |
| two logical partitions on one |
| of the storage devices that are managed by West Bridge. The |
| partitions are managed through |
| the CyAsStorageCreatePPartition and CyAsStorageRemovePPartition |
| APIs. |
| |
| Description |
| The CyAsStorageCreatePPartition API is used to divide the total |
| storage on a storage |
| device into two logical units or partitions. Since the partition |
| information is stored |
| on the storage device in a custom format, partitions should |
| only be created on fixed |
| storage devices (i.e., no removable SD/MMC cards). Any data |
| stored on the device |
| before the creation of the partition, is liable to be lost when |
| a partition is created. |
| |
| The CyAsStorageRemovePPartition API is used to remove the |
| stored partition information, |
| so that all of the device's capacity is treated as a single |
| partition again. |
| |
| When a storage device with two partitions (units) is being |
| enumerated as a mass storage |
| device through the West Bridge, it is possible to select the |
| partitions to be made |
| visible to the USB host. This is done through the |
| CyAsUsbSelectMSPartitions API. |
| */ |
| |
| /********************************* |
| * West Bridge Constants |
| **********************************/ |
| |
| /* Summary |
| This constants indicates a raw device access to the read/write |
| functions |
| |
| Description |
| When performing reading and writing operations on the |
| storage devices attached |
| to West Bridge, there are cases where writes need to |
| happen to raw devices, versus |
| the units contained within a device. This is |
| specifically required to manage |
| the partitions within physical devices. This constant |
| is used in calls to |
| CyAsStorageRead(), CyAsStorageReadAsync(), |
| CyAsStorageWrite() and |
| CyAsStorageWriteAsync(), to indicate that the raw |
| physical device is being |
| accessed and not any specific unit on the device. |
| |
| See Also |
| * CyAsStorageRead |
| * CyAsStorageReadAsync |
| * CyAsStorageWrite |
| * CyAsStorageWriteAsync |
| */ |
| #define CY_AS_LUN_PHYSICAL_DEVICE (0xffffffff) |
| |
| /* Summary |
| This constant represents the maximum DMA burst length |
| supported on a storage endpoint |
| |
| Description |
| West Bridge reserves separate endpoints for accessing |
| storage media through the |
| CyAsStorageRead() and CyAsStorageWrite() calls. The |
| maximum size of these |
| endpoints is always 512 bytes, regardless of status |
| and speed of the USB |
| connection. |
| */ |
| #define CY_AS_STORAGE_EP_SIZE (512) |
| |
| /******************************** |
| * West Bridge Types |
| *******************************/ |
| |
| /* Summary |
| This type indicates the type of event in an event |
| callback from West Bridge |
| |
| Description |
| At times West Bridge needs to inform the P port |
| processor of events that have |
| occurred. These events are asynchronous to the |
| thread of control on the P |
| port processor and as such are generally delivered |
| via a callback function that |
| is called as part of an interrupt handler. This |
| type indicates the resonse for |
| the call to the callback function. |
| |
| See Also |
| * CyAsStorageEventCallback |
| * CyAsStorageRegisterCallback |
| */ |
| typedef enum cy_as_storage_event { |
| /* This event occurs when the West Bridge device has |
| detected a USB connect and has enumerated the |
| storage controlled by west bridge to the USB port. |
| this event is the signal that the processor |
| needs to release the storage media. west bridge will |
| not have control of the storage media until the |
| processor calls cy_as_release_storage() to release |
| the specific media. */ |
| cy_as_storage_antioch, |
| |
| /* This event occurs when the processor has requested |
| ownership of a given media type and west bridge has |
| released the media. this event is an indicator |
| that the transfer of ownership is complete and the |
| processor now owns the given media type. */ |
| cy_as_storage_processor, |
| |
| /* This event occurs when a removable media type has |
| been removed. */ |
| cy_as_storage_removed, |
| |
| /* This event occurs when a removable media type has |
| been inserted. */ |
| cy_as_storage_inserted, |
| |
| /* This event occurs when the West Bridge device |
| * percieves an interrrupt from an SDIO card */ |
| cy_as_sdio_interrupt |
| |
| } cy_as_storage_event; |
| |
| /* Summary |
| This type gives the type of the operation in a storage |
| operation callback |
| |
| Description |
| This type is used in the callback function for asynchronous |
| operation. This type indicates whether it is a |
| CyAsStorageRead() or CyAsStorageWrite() operation that |
| has completed. |
| |
| See Also |
| * <LINK Asynchronous Versus Synchronous Operation> |
| * CyAsStorageRead |
| * CyAsStorageWrite |
| */ |
| typedef enum cy_as_oper_type { |
| /* A data read operation */ |
| cy_as_op_read, |
| /* A data write operation */ |
| cy_as_op_write |
| } cy_as_oper_type; |
| |
| /* Summary |
| This data structure describes a specific type of media |
| |
| Description |
| This data structure is the return value from the |
| CyAsStorageQueryDevice function. This structure provides |
| information about the specific storage device being queried. |
| |
| See Also |
| * CyAsStorageQueryDevice |
| */ |
| typedef struct cy_as_device_desc { |
| /* Type of device */ |
| cy_as_media_type type; |
| /* Is the device removable */ |
| cy_bool removable; |
| /* Is the device writeable */ |
| cy_bool writeable; |
| /* Basic block size for device */ |
| uint16_t block_size; |
| /* Number of LUNs on the device */ |
| uint32_t number_units; |
| /* Is the device password locked */ |
| cy_bool locked; |
| /* Size in bytes of an Erase Unit. Block erase operation |
| is only supported for SD storage, and the erase_unit_size |
| is invalid for all other kinds of storage. */ |
| uint32_t erase_unit_size; |
| } cy_as_device_desc; |
| |
| /* Summary |
| This data structure describes a specific unit on a |
| specific type of media |
| |
| Description |
| This data structure is the return value from the |
| CyAsStorageQueryUnit function. This structure provides |
| information about the specific unit. |
| |
| See Also |
| * CyAsStorageQueryUnit |
| */ |
| typedef struct cy_as_unit_desc { |
| /* Type of device */ |
| cy_as_media_type type; |
| /* Basic block size for device */ |
| uint16_t block_size; |
| /* Physical start block for LUN */ |
| uint32_t start_block; |
| /* Number of blocks in the LUN */ |
| uint32_t unit_size; |
| } cy_as_unit_desc; |
| |
| /* Summary |
| This function type defines a callback to be called after an |
| asynchronous operation |
| |
| Description |
| This function type defines a callback function that is called |
| at the completion of any asynchronous read or write operation. |
| |
| See Also |
| * CyAsStorageReadAsync() |
| * CyAsStorageWriteAsync() |
| */ |
| typedef void (*cy_as_storage_callback)( |
| /* Handle to the device completing the storage operation */ |
| cy_as_device_handle handle, |
| /* The bus completing the operation */ |
| cy_as_bus_number_t bus, |
| /* The device completing the operation */ |
| uint32_t device, |
| /* The unit completing the operation */ |
| uint32_t unit, |
| /* The block number of the completed operation */ |
| uint32_t block_number, |
| /* The type of operation */ |
| cy_as_oper_type op, |
| /* The error status */ |
| cy_as_return_status_t status |
| ); |
| |
| /* Summary |
| This function type defines a callback to be called in the |
| event of a storage related event |
| |
| Description |
| At times West Bridge needs to inform the P port processor |
| of events that have |
| occurred. These events are asynchronous to the thread of |
| control on the P |
| port processor and as such are generally delivered via a |
| callback function that |
| is called as part of an interrupt handler. This type |
| defines the type of function |
| that must be provided as a callback function. |
| |
| See Also |
| * CyAsStorageEvent |
| * CyAsStorageRegisterCallback |
| */ |
| typedef void (*cy_as_storage_event_callback)( |
| /* Handle to the device sending the event notification */ |
| cy_as_device_handle handle, |
| /* The bus where the event happened */ |
| cy_as_bus_number_t bus, |
| /* The device where the event happened */ |
| uint32_t device, |
| /* The event type */ |
| cy_as_storage_event evtype, |
| /* Event related data */ |
| void *evdata |
| ); |
| |
| /* Summary |
| This function type defines a callback to be called after |
| an asynchronous sdio operation |
| |
| Description |
| The Callback function is called at the completion of an |
| asynchronous sdio read or write operation. |
| |
| See Also |
| * CyAsSdioExtendedRead() |
| * CyAsSdioExtendedWrite() |
| */ |
| typedef void (*cy_as_sdio_callback)( |
| /* Handle to the device completing the storage operation */ |
| cy_as_device_handle handle, |
| /* The bus completing the operation */ |
| cy_as_bus_number_t bus, |
| /* The device completing the operation */ |
| uint32_t device, |
| /* The function number of the completing the operation. |
| if the status of the operation is either CY_AS_ERROR_IO_ABORTED |
| or CY_AS_IO_SUSPENDED then the most significant word parameter will |
| contain the number of blocks still pending. */ |
| uint32_t function, |
| /* The base address of the completed operation */ |
| uint32_t address, |
| /* The type of operation */ |
| cy_as_oper_type op, |
| /* The status of the operation */ |
| cy_as_return_status_t status |
| ); |
| |
| /* Summary |
| Enumeration of SD/MMC card registers that can be read |
| through the API. |
| |
| Description |
| Some of the registers on the SD/MMC card(s) attached to the |
| West Bridge can be read through the API layers. This type |
| enumerates the registers that can be read. |
| |
| See Also |
| * CyAsStorageSDRegisterRead |
| */ |
| typedef enum cy_as_sd_card_reg_type { |
| cy_as_sd_reg_OCR = 0, |
| cy_as_sd_reg_CID, |
| cy_as_sd_reg_CSD |
| } cy_as_sd_card_reg_type; |
| |
| /* Summary |
| Struct encapsulating parameters and return values for a |
| CyAsStorageQueryDevice call. |
| |
| Description |
| This struct holds the input parameters and the return values |
| for an asynchronous CyAsStorageQueryDevice call. |
| |
| See Also |
| * CyAsStorageQueryDevice |
| */ |
| typedef struct cy_as_storage_query_device_data { |
| /* The bus with the device to query */ |
| cy_as_bus_number_t bus; |
| /* The logical device number to query */ |
| uint32_t device; |
| /* The return value for the device descriptor */ |
| cy_as_device_desc desc_p; |
| } cy_as_storage_query_device_data; |
| |
| |
| /* Summary |
| Struct encapsulating parameters and return values |
| for a CyAsStorageQueryUnit call. |
| |
| Description |
| This struct holds the input parameters and the return |
| values for an asynchronous CyAsStorageQueryUnit call. |
| |
| See Also |
| * CyAsStorageQueryUnit |
| */ |
| typedef struct cy_as_storage_query_unit_data { |
| /* The bus with the device to query */ |
| cy_as_bus_number_t bus; |
| /* The logical device number to query */ |
| uint32_t device; |
| /* The unit to query on the device */ |
| uint32_t unit; |
| /* The return value for the unit descriptor */ |
| cy_as_unit_desc desc_p; |
| } cy_as_storage_query_unit_data; |
| |
| /* Summary |
| Struct encapsulating the input parameter and return |
| values for a CyAsStorageSDRegisterRead call. |
| |
| Description |
| This struct holds the input parameter and return |
| values for an asynchronous CyAsStorageSDRegisterRead |
| call. |
| |
| See Also |
| * CyAsStorageSDRegisterRead |
| */ |
| typedef struct cy_as_storage_sd_reg_read_data { |
| /* Pointer to the result buffer. */ |
| uint8_t *buf_p; |
| /* Length of data to be copied in bytes. */ |
| uint8_t length; |
| } cy_as_storage_sd_reg_read_data; |
| |
| /* Summary |
| Controls which pins are used for card detection |
| |
| Description |
| When a StorageDeviceControl call is made to enable or |
| disable card detection this enum is passed in to |
| control which pin is used for the detection. |
| |
| See Also |
| * CyAsStorageDeviceControl |
| */ |
| typedef enum cy_as_storage_card_detect { |
| cy_as_storage_detect_GPIO, |
| cy_as_storage_detect_SDAT_3 |
| } cy_as_storage_card_detect; |
| |
| #ifndef __doxygen__ |
| #define cy_as_storage_detect_GPIO_0 cy_as_storage_detect_GPIO |
| |
| /* Length of OCR value in bytes. */ |
| #define CY_AS_SD_REG_OCR_LENGTH (4) |
| /* Length of CID value in bytes. */ |
| #define CY_AS_SD_REG_CID_LENGTH (16) |
| /* Length of CSD value in bytes. */ |
| #define CY_AS_SD_REG_CSD_LENGTH (16) |
| /* Max. length of register response in words. */ |
| #define CY_AS_SD_REG_MAX_RESP_LENGTH (10) |
| |
| #endif |
| |
| /* Summary |
| This data structure is the data passed via the evdata |
| paramater on a usb event callback for the mass storage |
| device progress event. |
| |
| Description |
| This data structure reports the number of sectors that have |
| been written and read on the USB mass storage device since |
| the last event report. The corresponding event is only sent |
| when either the number of writes, or the number of reads has |
| crossed a pre-set threshold. |
| |
| See Also |
| * CyAsUsbEventCallback |
| * CyAsUsbRegisterCallback |
| */ |
| typedef struct cy_as_m_s_c_progress_data { |
| /* Number of sectors written since the last event. */ |
| uint32_t wr_count; |
| /* Number of sectors read since the last event. */ |
| uint32_t rd_count; |
| } cy_as_m_s_c_progress_data; |
| |
| /* Summary |
| Flag to set Direct Write operation to read back from the |
| address written to. |
| |
| |
| See Also |
| *CyAsSdioDirectWrite() |
| */ |
| #define CY_SDIO_RAW (0x01) |
| |
| |
| /* Summary |
| Flag to set Extended Read and Write to perform IO |
| using a FIFO i.e. read or write from the specified |
| address only. |
| |
| See Also |
| *CyAsSdioExtendedRead() |
| *CyAsSdioExtendedWrite() |
| */ |
| #define CY_SDIO_OP_FIFO (0x00) |
| |
| /* Summary |
| Flag to set Extended Read and Write to perform incremental |
| IO using the address provided as the base address. |
| |
| |
| See Also |
| *CyAsSdioExtendedRead() |
| *CyAsSdioExtendedWrite() |
| */ |
| #define CY_SDIO_OP_INCR (0x02) |
| |
| /* Summary |
| Flag to set Extended Read and Write to Block Mode operation |
| |
| See Also |
| *CyAsSdioExtendedRead() |
| *CyAsSdioExtendedWrite() |
| */ |
| #define CY_SDIO_BLOCKMODE (0x04) |
| |
| /* Summary |
| Flag to set Extended Read and Write to Byte Mode operation |
| |
| See Also |
| *CyAsSdioExtendedRead() |
| *CyAsSdioExtendedWrite() |
| */ |
| #define CY_SDIO_BYTEMODE (0x00) |
| |
| /* Summary |
| Flag to force re/initialization of a function. |
| |
| Description |
| If not set a call to CyAsSdioInitFunction() |
| will not initialize a function that has been previously |
| initialized. |
| See Also |
| *CyAsSdioInitFunction() |
| */ |
| #define CY_SDIO_FORCE_INIT (0x40) |
| |
| /* Summary |
| Flag to re-enable the SDIO interrupts. |
| |
| Description |
| Used with a direct read or direct write |
| after the Interrupt triggerred by SDIO has been serviced |
| and cleared to reset the West Bridge Sdio Interrupt. |
| See Also |
| *CyAsSdioDirectRead() |
| *CyAsSdioDirectWrite() |
| */ |
| |
| #define CY_SDIO_REARM_INT (0x80) |
| |
| |
| /* Summary |
| Flag to check if 4 bit support is enabled on a |
| low speed card |
| See Also |
| <link CyAsSDIOCard::card_capability>*/ |
| #define CY_SDIO_4BLS (0x80) |
| |
| /* Summary |
| Flag to check if card is a low speed card |
| See Also |
| <link CyAsSDIOCard::card_capability> */ |
| #define CY_SDIO_LSC (0x40) |
| |
| /* Summary |
| Flag to check if interrupt during multiblock data |
| transfer is enabled |
| See Also |
| <link CyAsSDIOCard::card_capability>*/ |
| #define CY_SDIO_E4MI (0x20) |
| |
| /* Summary |
| Flag to check if interrupt during multiblock data |
| transfer is supported |
| See Also |
| <link CyAsSDIOCard::card_capability> */ |
| #define CY_SDIO_S4MI (0x10) |
| |
| /* Summary |
| Flag to check if card supports function suspending. |
| See Also |
| <link CyAsSDIOCard::card_capability> */ |
| #define CY_SDIO_SBS (0x08) |
| |
| /* Summary |
| Flag to check if card supports SDIO Read-Wait |
| See Also |
| <link CyAsSDIOCard::card_capability> */ |
| #define CY_SDIO_SRW (0x04) |
| |
| /* Summary |
| Flag to check if card supports multi-block transfers |
| See Also |
| <link CyAsSDIOCard::card_capability> */ |
| #define CY_SDIO_SMB (0x02) |
| |
| /* Summary |
| Flag to check if card supports Direct IO commands |
| during execution of an Extended |
| IO function |
| See Also |
| <link CyAsSDIOCard::card_capability>*/ |
| #define CY_SDIO_SDC (0x01) |
| |
| /* Summary |
| Flag to check if function has a CSA area. |
| See Also |
| <link CyAsSDIOFunc::csa_bits> */ |
| #define CY_SDIO_CSA_SUP (0x40) |
| |
| /* Summary |
| Flag to check if CSA access is enabled. |
| See Also |
| <link CyAsSDIOFunc::csa_bits> */ |
| #define CY_SDIO_CSA_EN (0x80) |
| |
| /* Summary |
| Flag to check if CSA is Write protected. |
| See Also |
| <link CyAsSDIOFunc::csa_bits> */ |
| #define CY_SDIO_CSA_WP (0x01) |
| |
| /* Summary |
| Flag to check if CSA formatting is prohibited. |
| See Also |
| <link CyAsSDIOFunc::csa_bits>*/ |
| #define CY_SDIO_CSA_NF (0x02) |
| |
| /* Summary |
| Flag to check if the function allows wake-up from low |
| power mode using some vendor specific method. |
| See Also |
| <link CyAsSDIOFunc::wakeup_support>*/ |
| #define CY_SDIO_FN_WUS (0x01) |
| |
| |
| /* Summary |
| This data structure stores SDIO function 0 |
| parameters for a SDIO card |
| */ |
| typedef struct cy_as_sdio_card { |
| /* Number of functions present on the card. */ |
| uint8_t num_functions; |
| /* Memory present(Combo card) or not */ |
| uint8_t memory_present; |
| /* 16 bit manufacturer ID */ |
| uint16_t manufacturer__id; |
| /* Additional vendor specific info */ |
| uint16_t manufacturer_info; |
| /* Max Block size for function 0 */ |
| uint16_t maxblocksize; |
| /* Block size used for function 0 */ |
| uint16_t blocksize; |
| /* SDIO version supported by the card */ |
| uint8_t sdio_version; |
| /* Card capability flags */ |
| uint8_t card_capability; |
| } cy_as_sdio_card; |
| |
| /* Summary |
| This data structure stores SDIO function 1-7 parameters |
| for a SDIO card |
| */ |
| typedef struct cy_as_sdio_func { |
| /* SDIO function code. 0 if non standard function */ |
| uint8_t function_code; |
| /* Extended function type code for non-standard function */ |
| uint8_t extended_func_code; |
| /* Max IO Blocksize supported by the function */ |
| uint16_t maxblocksize; |
| /* IO Blocksize used by the function */ |
| uint16_t blocksize; |
| /* 32 bit product serial number for the function */ |
| uint32_t card_psn; |
| /* Code storage area variables */ |
| uint8_t csa_bits; |
| /* Function wake-up support */ |
| uint8_t wakeup_support; |
| } cy_as_sdio_func; |
| |
| /*********************************** |
| * West Bridge Functions |
| ************************************/ |
| |
| /* Summary |
| This function starts the West Bridge storage module. |
| |
| Description |
| This function initializes the West Bridge storage software |
| stack and readies this module to service storage related |
| requests. If the stack is already running, the reference |
| count for the stack is incremented. |
| |
| * Valid In Asynchronous Callback: YES (if cb supplied) |
| * Nestable: YES |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in |
| * CY_AS_ERROR_SUCCESS - the module started sucessfully |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_OUT_OF_MEMORY |
| * CY_AS_ERROR_INVALID_RESPONSE |
| |
| See Also |
| * CyAsStorageStop |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_start( |
| /* Handle to the device */ |
| cy_as_device_handle handle, |
| /* Callback to be called when the operation is complete */ |
| cy_as_function_callback cb, |
| /* Client data to be passed to the callback */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| This function stops the West Bridge storage module. |
| |
| Description |
| This function decrements the reference count for the |
| storage stack and if this count is zero, the storage |
| stack is shut down. The shutdown frees all resources |
| associated with the storage stack. |
| |
| * Valid In Asynchronous Callback: YES (if cb supplied) |
| * Nestable: YES |
| |
| Notes |
| While all resources associated with the storage stack |
| will be freed is a shutdown occurs, |
| resources associated with underlying layers of the |
| software will not be freed if they |
| are shared by the USB stack and the USB stack is |
| active. Specifically the DMA manager, |
| the interrupt manager, and the West Bridge |
| communications module are all shared by both the |
| USB stack and the storage stack. |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge |
| * device has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not |
| * been loaded into West Bridge |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_SUCCESS - this module was shut |
| * down sucessfully |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred |
| * communicating with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING |
| * CY_AS_ERROR_ASYNC_PENDING |
| * CY_AS_ERROR_OUT_OF_MEMORY |
| |
| See Also |
| * CyAsStorageStart |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_stop( |
| /* Handle to the device to configure */ |
| cy_as_device_handle handle, |
| /* Callback to be called when the operation is complete */ |
| cy_as_function_callback cb, |
| /* Client data to be passed to the callback */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| This function is used to register a callback function |
| for the storage API. |
| |
| Description |
| At times West Bridge needs to inform the P port processor |
| of events that have occurred. These events are asynchronous |
| to the thread of control on the P |
| port processor and as such are generally delivered via a |
| callback function that |
| is called as part of an interrupt handler. This function |
| registers the callback |
| function that is called when an event occurs. Each call |
| to this function |
| replaces any old callback function with a new callback |
| function supplied on |
| the most recent call. This function can also be called |
| with a callback function |
| of NULL in order to remove any existing callback function |
| |
| * Valid In Asynchronous Callback:YES |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device |
| * has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has |
| * not been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle |
| * was passed in |
| * CY_AS_ERROR_SUCCESS - the function was registered |
| * sucessfully |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| |
| See Also |
| * CyAsStorageEventCallback |
| * CyAsStorageEvent |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_register_callback( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* The callback function to call for async storage events */ |
| cy_as_storage_event_callback callback |
| ); |
| |
| /* Summary |
| This function claims a given media type. |
| |
| Description |
| This function communicates to West Bridge that the |
| processor wants control of the |
| given storage media type. Each media type can be |
| claimed or released by the |
| processor independently. As the processor is the |
| master for the storage, |
| West Bridge should release control of the requested |
| media as soon as possible and |
| signal the processor via the CyAsStorageProcessor event. |
| |
| * Valid In Asynchronous Callback: NO |
| |
| Notes |
| This function just notifies West Bridge that the storage |
| is desired. The storage |
| has not actually been released by West Bridge until the |
| registered callback function |
| is called with the CyAsStorageProcessor event |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device |
| * has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_SUCCESS - this request was sucessfully |
| * transmitted to the West Bridge device |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_MEDIA |
| * CY_AS_ERROR_OUT_OF_MEMORY |
| * CY_AS_ERROR_INVALID_RESPONSE |
| * CY_AS_ERROR_NOT_ACQUIRED |
| |
| See Also: |
| * CyAsStorageClaim |
| * CyAsStorageRelease |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_claim( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* The bus to claim */ |
| cy_as_bus_number_t bus, |
| /* The device to claim */ |
| uint32_t device, |
| /* Callback to be called when the operation is complete */ |
| cy_as_function_callback cb, |
| /* Client data to be passed to the callback */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| This function releases a given media type. |
| |
| Description |
| This function communicates to West Bridge that the |
| processor has released control of |
| the given storage media type. Each media type can |
| be claimed or released by the |
| processor independently. As the processor is the |
| master for the storage, West Bridge |
| can now assume ownership of the media type. No callback |
| or event is generated. |
| |
| * Valid In Asynchronous Callback: YES (if cb supplied) |
| * Nestable: YES |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device |
| * has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle |
| * was passed in |
| * CY_AS_ERROR_SUCCESS - the media was sucessfully |
| * released |
| * CY_AS_ERROR_MEDIA_NOT_CLAIMED - the media was not |
| * claimed by the P port |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred |
| * communicating with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_MEDIA |
| * CY_AS_ERROR_OUT_OF_MEMORY |
| * CY_AS_ERROR_INVALID_RESPONSE |
| |
| See Also |
| * CyAsStorageClaim |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_release( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* The bus to release */ |
| cy_as_bus_number_t bus, |
| /* The device to release */ |
| uint32_t device, |
| /* Callback to be called when the operation is complete */ |
| cy_as_function_callback cb, |
| /* Client data to be passed to the callback */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| This function information about the number of devices present |
| on a given bus |
| |
| Description |
| This function retrieves information about how many devices on |
| on the given |
| West Bridge bus. |
| |
| * Valid In Asynchronous Callback: NO |
| |
| Notes |
| While the current implementation of West Bridge only |
| supports one of logical device of |
| each media type, future versions WestBridge/Antioch may |
| support multiple devices. |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device |
| * has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_SUCCESS - the media information was |
| * returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred |
| * communicating with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_OUT_OF_MEMORY |
| * CY_AS_ERROR_INVALID_RESPONSE |
| |
| See Also |
| * CyAsStorageQueryDevice |
| * CyAsStorageQueryUnit |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_query_bus( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* The bus to query */ |
| cy_as_bus_number_t bus, |
| /* The return value containing the number of |
| devices present for this media type */ |
| uint32_t *count, |
| /* Callback to be called when the operation is complete */ |
| cy_as_function_callback cb, |
| /* Client data to be passed to the callback */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| This function information about the number of devices |
| present for a given media type |
| |
| Description |
| This function retrieves information about how many |
| devices of a given media type are attached to West Bridge. |
| |
| * Valid In Asynchronous Callback: YES (if cb supplied) |
| * Nestable: YES |
| |
| Notes |
| While the current implementation of West Bridge only |
| supports one of logical device of each media type, future |
| versions West Bridge may support multiple devices. |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device |
| * has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_SUCCESS - the media information was |
| * returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred |
| * communicating with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_OUT_OF_MEMORY |
| * CY_AS_ERROR_INVALID_RESPONSE |
| |
| See Also |
| * CyAsStorageQueryMedia |
| * CyAsMediaType |
| * CyAsStorageQueryDevice |
| * CyAsStorageQueryUnit |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_query_media( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* The type of media to query */ |
| cy_as_media_type type, |
| /* The return value containing the number of |
| devices present for this media type */ |
| uint32_t *count, |
| /* Callback to be called when the operation is complete */ |
| cy_as_function_callback cb, |
| /* Client data to be passed to the callback */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| This function returns information about a given device |
| of a specific media type |
| |
| Description |
| This function retrieves information about a device of a |
| given type of media. The function is called with a given |
| media type and device and a pointer to a media descriptor |
| (CyAsDeviceDesc). This function fills in the data in the |
| media descriptor to provide information about the |
| attributes of the device of the given device. |
| |
| * Valid In Asynchronous Callback: YES (if cb supplied) |
| * Nestable: YES |
| |
| Notes |
| Currently this API only supports a single logical device |
| of each media type. Therefore the only acceptable value |
| for the parameter device is zero (0). |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_SUCCESS - the media information was |
| * returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_OUT_OF_MEMORY |
| * CY_AS_ERROR_NO_SUCH_MEDIA |
| * CY_AS_ERROR_NO_SUCH_DEVICE |
| * CY_AS_ERROR_INVALID_RESPONSE |
| |
| See Also |
| * CyAsMediaType |
| * CyAsStorageQueryMedia |
| * CyAsStorageQueryUnit |
| * CyAsDeviceDesc |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_query_device( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* Parameters and return value for the query call */ |
| cy_as_storage_query_device_data *data, |
| /* Callback to be called when the operation is complete */ |
| cy_as_function_callback cb, |
| /* Client data to be passed to the callback */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| This function returns information about a given unit on a |
| specific device |
| |
| Description |
| This function retrieves information about a device of a |
| given logical unit. The function is called with a given |
| media type, device address, unit address, and a pointer |
| to a unit descriptor (CyAsUnitDesc). This function fills |
| in the data in the unit descriptor to provide information |
| about the attributes of the device of the given logical |
| unit. |
| |
| * Valid In Asynchronous Callback: YES (if cb supplied) |
| * Nestable: YES |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_SUCCESS - the media information was returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_OUT_OF_MEMORY |
| * CY_AS_ERROR_NO_SUCH_DEVICE |
| * CY_AS_ERROR_NO_SUCH_UNIT |
| * CY_AS_ERROR_INVALID_RESPONSE |
| |
| |
| See Also |
| * CyAsMediaType |
| * CyAsStorageQueryMedia |
| * CyAsStorageQueryDevice |
| * CyAsUnitDesc |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_query_unit( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* Parameters and return value for the query call */ |
| cy_as_storage_query_unit_data *data_p, |
| /* Callback to be called when the operation is complete */ |
| cy_as_function_callback cb, |
| /* Client data to be passed to the callback */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| This function enables/disables the handling of SD/MMC card |
| detection and SD/MMC write protection in West Bridge Firmware. |
| |
| Description |
| If the detection of SD/MMC card insertion or removal is being |
| done by the Processor directly, the West Bridge firmware needs |
| to be instructed to disable the card detect feature. Also, if |
| the hardware design does not use the SD_WP GPIO of the West |
| Bridge to handle SD card's write protect notch, the handling |
| of write protection if firmware should be disabled. This API |
| is used to enable/disable the card detect and write protect |
| support in West Bridge firmware. |
| |
| * Valid In Asynchronous Callback: YES (if cb supplied) |
| * Nestable: YES |
| |
| Returns |
| * CY_AS_ERROR_SUCCESS - the feature controls were |
| * set successfully |
| * CY_AS_ERROR_NO_SUCH_BUS - the specified bus is invalid |
| * CY_AS_ERROR_NOT_SUPPORTED - function not supported on |
| * the device in the specified bus |
| * CY_AS_ERROR_IN_SUSPEND - the West Brdige device is in |
| * suspended mode |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_INVALID_HANDLE |
| * CY_AS_ERROR_OUT_OF_MEMORY |
| * CY_AS_ERROR_INVALID_RESPONSE |
| |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_device_control( |
| /* Handle to the West Bridge device */ |
| cy_as_device_handle handle, |
| /* The bus to control */ |
| cy_as_bus_number_t bus, |
| /* The device to control */ |
| uint32_t device, |
| /* Enable/disable control for card detection */ |
| cy_bool card_detect_en, |
| /* Enable/disable control for write protect handling */ |
| cy_bool write_prot_en, |
| /* Control which pin is used for card detection */ |
| cy_as_storage_card_detect config_detect, |
| /* Callback to be called when the operation is complete */ |
| cy_as_function_callback cb, |
| /* Client data to be passed to the callback */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| This function reads one or more blocks of data from |
| the storage system. |
| |
| Description |
| This function synchronously reads one or more blocks |
| of data from the given media |
| type/device and places the data into the data buffer |
| given. This function does not |
| return until the data is read and placed into the buffer. |
| |
| * Valid In Asynchronous Callback: NO |
| |
| Notes |
| If the Samsung CEATA drive is the target for a |
| read/write operation, the maximum |
| number of sectors that can be accessed through a |
| single API call is limited to 2047. |
| Longer accesses addressed to a Samsung CEATA drive |
| can result in time-out errors. |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device |
| * has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle |
| * was passed in |
| * CY_AS_ERROR_SUCCESS - the media information was |
| * returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred |
| * communicating with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified |
| * does not exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified |
| * media/device pair does not exist |
| * CY_AS_ERROR_NO_SUCH_UNIT - the unit specified |
| * does not exist |
| * CY_AS_ERROR_ASYNC_PENDING - an async operation |
| * is pending |
| * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was |
| * error in reading from the media |
| * CY_AS_ERROR_MEDIA_WRITE_PROTECTED - the media is |
| * write protected |
| * CY_AS_ERROR_INVALID_PARAMETER - Reads/Writes greater |
| * than 4095 logic blocks are not allowed |
| |
| See Also |
| * CyAsStorageReadAsync |
| * CyAsStorageWrite |
| * CyAsStorageWriteAsync |
| * CyAsStorageCancelAsync |
| * <LINK Asynchronous Versus Synchronous Operation> |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_read( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* The bus to access */ |
| cy_as_bus_number_t bus, |
| /* The device to access */ |
| uint32_t device, |
| /* The unit to access */ |
| uint32_t unit, |
| /* The first block to access */ |
| uint32_t block, |
| /* The buffer where data will be placed */ |
| void *data_p, |
| /* The number of blocks to be read */ |
| uint16_t num_blocks |
| ); |
| |
| /* Summary |
| This function asynchronously reads one or more blocks of data |
| from the storage system. |
| |
| Description |
| This function asynchronously reads one or more blocks of |
| data from the given media |
| type/device and places the data into the data buffer given. |
| This function returns |
| as soon as the request is transmitted to the West Bridge |
| device but before the data is |
| available. When the read is complete, the callback function |
| is called to indicate the |
| data has been placed into the data buffer. Note that the |
| data buffer must remain |
| valid from when the read is requested until the callback |
| function is called. |
| |
| * Valid In Asynchronous Callback: YES |
| |
| Notes |
| If the Samsung CEATA drive is the target for a read/write |
| operation, the maximum |
| number of sectors that can be accessed through a single API |
| call is limited to 2047. |
| Longer accesses addressed to a Samsung CEATA drive can |
| result in time-out errors. |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device |
| * has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle |
| * was passed in |
| * CY_AS_ERROR_SUCCESS - the media information was |
| * returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred |
| * communicating with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_ASYNC_PENDING - an async operation |
| * is pending |
| * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error |
| * in reading from the media |
| * CY_AS_ERROR_MEDIA_WRITE_PROTECTED - the media is |
| * write protected |
| * CY_AS_ERROR_QUERY_DEVICE_NEEDED - Before an |
| * asynchronous read can be issue a call to |
| * CyAsStorageQueryDevice must be made |
| * CY_AS_ERROR_INVALID_PARAMETER - Reads/Writes greater |
| * than 4095 logic blocks are not allowed |
| |
| See Also |
| * CyAsStorageRead |
| * CyAsStorageWrite |
| * CyAsStorageWriteAsync |
| * CyAsStorageCancelAsync |
| * CyAsStorageQueryDevice |
| * <LINK Asynchronous Versus Synchronous Operation> |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_read_async( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* The bus to access */ |
| cy_as_bus_number_t bus, |
| /* The device to access */ |
| uint32_t device, |
| /* The unit to access */ |
| uint32_t unit, |
| /* The first block to access */ |
| uint32_t block, |
| /* The buffer where data will be placed */ |
| void *data_p, |
| /* The number of blocks to be read */ |
| uint16_t num_blocks, |
| /* The function to call when the read is complete |
| or an error occurs */ |
| cy_as_storage_callback callback |
| ); |
| |
| /* Summary |
| This function writes one or more blocks of data |
| to the storage system. |
| |
| Description |
| This function synchronously writes one or more blocks of |
| data to the given media/device. |
| This function does not return until the data is written |
| into the media. |
| |
| * Valid In Asynchronous Callback: NO |
| |
| Notes |
| If the Samsung CEATA drive is the target for a read/write |
| operation, the maximum |
| number of sectors that can be accessed through a single |
| API call is limited to 2047. |
| Longer accesses addressed to a Samsung CEATA drive can |
| result in time-out errors. |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device |
| * has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_SUCCESS - the media information was |
| * returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred |
| * communicating with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does |
| * not exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified |
| * media/device pair does not exist |
| * CY_AS_ERROR_NO_SUCH_UNIT - the unit specified |
| * does not exist |
| * CY_AS_ERROR_ASYNC_PENDING - an async operation |
| * is pending |
| * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error |
| * in reading from the media |
| * CY_AS_ERROR_MEDIA_WRITE_PROTECTED - the media is |
| * write protected |
| * CY_AS_ERROR_INVALID_PARAMETER - Reads/Writes greater |
| * than 4095 logic blocks are not allowed |
| |
| See Also |
| * CyAsStorageRead |
| * CyAsStorageReadAsync |
| * CyAsStorageWriteAsync |
| * CyAsStorageCancelAsync |
| * <LINK Asynchronous Versus Synchronous Operation> |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_write( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* The bus to access */ |
| cy_as_bus_number_t bus, |
| /* The device to access */ |
| uint32_t device, |
| /* The unit to access */ |
| uint32_t unit, |
| /* The first block to access */ |
| uint32_t block, |
| /* The buffer containing the data to be written */ |
| void *data_p, |
| /* The number of blocks to be written */ |
| uint16_t num_blocks |
| ); |
| |
| /* Summary |
| This function asynchronously writes one or more blocks |
| of data to the storage system |
| |
| Description |
| This function asynchronously writes one or more blocks of |
| data to the given media type/device. |
| This function returns as soon as the request is transmitted |
| to the West Bridge device |
| but before the data is actually written. When the write is |
| complete, the callback |
| function is called to indicate the data has been physically |
| written into the media. |
| |
| * Valid In Asynchronous Callback: YES |
| |
| Notes |
| If the Samsung CEATA drive is the target for a read/write |
| operation, the maximum |
| number of sectors that can be accessed through a single API |
| call is limited to 2047. |
| Longer accesses addressed to a Samsung CEATA drive can |
| result in time-out errors. |
| |
| Notes |
| The data buffer must remain valid from when the write is |
| requested until the callback function is called. |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device |
| * has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has |
| * not been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in |
| * CY_AS_ERROR_SUCCESS - the media information was returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_ASYNC_PENDING - an async operation is |
| * pending |
| * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in |
| * reading from the media |
| * CY_AS_ERROR_MEDIA_WRITE_PROTECTED - the media is write |
| * protected |
| * CY_AS_ERROR_QUERY_DEVICE_NEEDED - A query device call is |
| * required before async writes are allowed |
| * CY_AS_ERROR_INVALID_PARAMETER - Reads/Writes greater |
| * than 4095 logic blocks are not allowed |
| |
| See Also |
| * CyAsStorageRead |
| * CyAsStorageWrite |
| * CyAsStorageReadAsync |
| * CyAsStorageCancelAsync |
| * CyAsStorageQueryDevice |
| * <LINK Asynchronous Versus Synchronous Operation> |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_write_async( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* The bus to access */ |
| cy_as_bus_number_t bus, |
| /* The device to access */ |
| uint32_t device, |
| /* The unit to access */ |
| uint32_t unit, |
| /* The first block to access */ |
| uint32_t block, |
| /* The buffer where the data to be written is stored */ |
| void *data_p, |
| /* The number of blocks to be written */ |
| uint16_t num_blocks, |
| /* The function to call when the write is complete |
| or an error occurs */ |
| cy_as_storage_callback callback |
| ); |
| |
| /* Summary |
| This function aborts any outstanding asynchronous operation |
| |
| Description |
| This function aborts any asynchronous block read or block |
| write operation. As only a single asynchronous block read |
| or write operation is possible at one time, this aborts |
| the single operation in progress. |
| |
| * Valid In Asynchronous Callback: YES |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device |
| * has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in |
| * CY_AS_ERROR_SUCCESS - the media information was returned |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_OPERATION_PENDING - no asynchronous |
| * operation is pending |
| |
| See Also |
| * CyAsStorageRead |
| * CyAsStorageReadAsync |
| * CyAsStorageWrite |
| * CyAsStorageWriteAsync |
| * <LINK Asynchronous Versus Synchronous Operation> |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_cancel_async( |
| /* Handle to the device with outstanding async request */ |
| cy_as_device_handle handle |
| ); |
| |
| /* Summary |
| This function is used to read the content of SD registers |
| |
| Description |
| This function is used to read the contents of CSD, CID and |
| CSD registers of the SD Card. |
| |
| * Valid In Asynchronous Callback: YES (if cb supplied) |
| * Nestable: YES |
| |
| Returns |
| * CY_AS_ERROR_SUCCESS - the read operation was successful |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not |
| * been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded |
| * into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been |
| * started |
| * CY_AS_ERROR_IN_SUSPEND - The West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair |
| * does not exist |
| * CY_AS_ERROR_INVALID_PARAMETER - The register type is invalid |
| * or the media is not supported on the bus |
| * CY_AS_ERROR_OUT_OF_MEMORY - failed to get memory to process |
| * request |
| * CY_AS_ERROR_INVALID_RESPONSE - communication failure with |
| * West Bridge firmware |
| |
| See Also |
| * CyAsStorageSDRegReadData |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_sd_register_read( |
| /* Handle to the West Bridge device. */ |
| cy_as_device_handle handle, |
| /* The bus to query */ |
| cy_as_bus_number_t bus, |
| /* The device to query */ |
| uint8_t device, |
| /* The type of register to read. */ |
| cy_as_sd_card_reg_type reg_type, |
| /* Output data buffer and length. */ |
| cy_as_storage_sd_reg_read_data *data_p, |
| /* Callback function to call when done. */ |
| cy_as_function_callback cb, |
| /* Call context to send to the cb function. */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| Creates a partition starting at the given block and using the |
| remaining blocks on the card. |
| |
| Description |
| Storage devices attached to West Bridge can be partitioned |
| into two units. |
| The visibility of these units through the mass storage |
| interface can be |
| individually controlled. This API is used to partition |
| a device into two. |
| |
| * Valid in Asynchronous Callback: Yes (if cb supplied) |
| * Nestable: Yes |
| |
| Returns |
| * CY_AS_ERROR_SUCCESS - the partition was successfully created |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not |
| * been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded |
| * into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been |
| * started |
| * CY_AS_ERROR_IN_SUSPEND - The West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_USB_RUNNING - Partition cannot be created while |
| * USB stack is active |
| * CY_AS_ERROR_OUT_OF_MEMORY - failed to get memory to |
| * process request |
| * CY_AS_ERROR_INVALID_REQUEST - feature not supported by |
| * active device or firmware |
| * CY_AS_ERROR_INVALID_RESPONSE - communication failure with |
| * West Bridge firmware |
| * CY_AS_ERROR_ALREADY_PARTITIONED - the storage device already |
| * has been partitioned |
| * CY_AS_ERROR_INVALID_BLOCK - Size specified for the partition |
| * exceeds the actual device capacity |
| |
| See Also |
| * <LINK Partitioning> |
| * CyAsStorageRemovePPartition |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_create_p_partition( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* Bus on which the device to be partitioned is connected */ |
| cy_as_bus_number_t bus, |
| /* Device number to be partitioned */ |
| uint32_t device, |
| /* Size of partition number 0 in blocks */ |
| uint32_t size, |
| /* Callback in case of async call */ |
| cy_as_function_callback cb, |
| /* Client context to pass to the callback */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| Removes the partition table on a storage device connected |
| to the West Bridge. |
| |
| Description |
| Storage devices attached to West Bridge can be partitioned |
| into two units.This partition information is stored on the |
| device and is non-volatile. This API is used to remove the |
| stored partition information and make the entire device |
| visible as a single partition (unit). |
| |
| * Valid in Asynchronous Callback: Yes (if cb supplied) |
| * Nestable: Yes |
| |
| Returns |
| * CY_AS_ERROR_SUCCESS - the partition was successfully |
| * deleted |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_IN_SUSPEND - The West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_USB_RUNNING - Partition cannot be created |
| * while USB stack is active |
| * CY_AS_ERROR_OUT_OF_MEMORY - failed to get memory to |
| * process request |
| * CY_AS_ERROR_INVALID_REQUEST - operation not supported |
| * by active device/firmware |
| * CY_AS_ERROR_NO_SUCH_UNIT - the addressed device is |
| * not partitioned |
| |
| See Also |
| * <LINK Partitioning> |
| * CyAsStorageCreatePPartition |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_remove_p_partition( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* Bus on which device of interest is connected */ |
| cy_as_bus_number_t bus, |
| /* Device number of interest */ |
| uint32_t device, |
| /* Callback in case of async call */ |
| cy_as_function_callback cb, |
| /* Client context to pass to the callback */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| Returns the amount of data read/written to the given |
| device from the USB host. |
| |
| Description |
| |
| * Valid in Asynchronous Callback: Yes (if cb supplied) |
| * Nestable: Yes |
| |
| Returns |
| * CY_AS_ERROR_SUCCESS - API call completed successfully |
| * CY_AS_ERROR_INVALID_HANDLE - Invalid West Bridge device |
| * handle |
| * CY_AS_ERROR_NOT_CONFIGURED - West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - No firmware image has been |
| * loaded on West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - Storage stack has not been |
| * started |
| * CY_AS_ERROR_NOT_SUPPORTED - This function is not |
| * supported by active firmware version |
| * CY_AS_ERROR_OUT_OF_MEMORY - Failed to get memory to |
| * process the request |
| * CY_AS_ERROR_TIMEOUT - West Bridge firmware did not |
| * respond to request |
| * CY_AS_ERROR_INVALID_RESPONSE - Unexpected reply from |
| * West Bridge firmware |
| |
| See Also |
| * CyAsUsbSetMSReportThreshold |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_get_transfer_amount( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* Bus on which device of interest is connected */ |
| cy_as_bus_number_t bus, |
| /* Device number of interest */ |
| uint32_t device, |
| /* Return value containing read/write sector counts. */ |
| cy_as_m_s_c_progress_data *data_p, |
| /* Callback in case of async call */ |
| cy_as_function_callback cb, |
| /* Client context to pass to the callback */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| Performs a Sector Erase on an attached SD Card |
| |
| Description |
| This allows you to erase an attached SD card. The area to erase |
| is specified in terms of a starting Erase Unit and a number of |
| Erase Units. The size of each Erase Unit is defined in the |
| DeviceDesc returned from a StorageQueryDevice call and it can |
| differ between SD cards. |
| |
| A large erase can take a while to complete depending on the SD |
| card. In such a case it is reccomended that an async call is made. |
| |
| Returns |
| * CY_AS_ERROR_SUCCESS - API call completed successfully |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not |
| * been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded |
| * into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been |
| * started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with |
| * the West Bridge device |
| * CY_AS_ERROR_ASYNC_PENDING - an async operation is pending |
| * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in |
| * reading from the media |
| * CY_AS_ERROR_MEDIA_WRITE_PROTECTED - the media is write protected |
| * CY_AS_ERROR_QUERY_DEVICE_NEEDED - A query device call is |
| * required before erase is allowed |
| * CY_AS_ERROR_NO_SUCH_BUS |
| * CY_AS_ERROR_NO_SUCH_DEVICE |
| * CY_AS_ERROR_NOT_SUPPORTED - Erase is currenly only supported |
| * on SD and using SD only firmware |
| * CY_AS_ERROR_OUT_OF_MEMORY |
| |
| See Also |
| * CyAsStorageSDRegisterRead |
| */ |
| EXTERN cy_as_return_status_t |
| cy_as_storage_erase( |
| /* Handle to the device of interest */ |
| cy_as_device_handle handle, |
| /* Bus on which device of interest is connected */ |
| cy_as_bus_number_t bus, |
| /* Device number of interest */ |
| uint32_t device, |
| /* Erase Unit to start the erase */ |
| uint32_t erase_unit, |
| /* Number of Erase Units to erase */ |
| uint16_t num_erase_units, |
| /* Callback in case of async call */ |
| cy_as_function_callback cb, |
| /* Client context to pass to the callback */ |
| uint32_t client |
| ); |
| |
| /* Summary |
| This function is used to read a Tuple from the SDIO CIS area. |
| |
| Description |
| This function is used to read a Tuple from the SDIO CIS area. |
| This function is to be used only for IO to an SDIO card as |
| other media will not respond to the SDIO command set. |
| |
| * Valid in Asynchronous Callback: NO |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_SUCCESS - the media information was returned |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device |
| * is in suspend mode |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not |
| * exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device |
| * pair does not exist |
| * CY_AS_ERROR_ASYNC_PENDING - an async operation is pending |
| * CY_AS_ERROR_INVALID_REQUEST - an invalid IO request |
| * type was made |
| * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available |
| * CY_AS_ERROR_INVALID_RESPONSE - an error message was |
| * recieved from the firmware |
| * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in |
| * reading from the media |
| * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to |
| * an invalid function |
| * CY_AS_ERROR_INVALID_ENDPOINT - A DMA request was made to |
| * an invalid endpoint |
| * CY_AS_ERROR_ENDPOINT_DISABLED - A DMA request was made to |
| * a disabled endpoint |
| |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_get_c_i_s_info( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device, |
| /* IO function Number */ |
| uint8_t n_function_no, |
| /* Id of tuple to be fetched */ |
| uint16_t tuple_id, |
| /* Buffer to hold tuple read from card. |
| should be at least 256 bytes in size */ |
| uint8_t *data_p |
| ); |
| |
| |
| /* Summary |
| This function is used to read properties of the SDIO card. |
| |
| Description |
| This function is used to read properties of the SDIO card |
| into a CyAsSDIOCard structure. |
| This function is to be used only for IO to an SDIO card as |
| other media will not respond to the SDIO command set. |
| |
| * Valid in Asynchronous Callback: NO |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been |
| * started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_SUCCESS - the card information was returned |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not |
| * exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device |
| * pair does not exist |
| * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available |
| * CY_AS_ERROR_INVALID_RESPONSE - an error message was |
| * recieved from the firmware |
| |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_query_card( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device, |
| /* Buffer to store card properties */ |
| cy_as_sdio_card *data_p |
| ); |
| |
| /* Summary |
| This function is used to reset a SDIO card. |
| |
| Description |
| This function is used to reset a SDIO card by writing to |
| the reset bit in the CCCR and reinitializing the card. This |
| function is to be used only for IO to an SDIO card as |
| other media will not respond to the SDIO command set. |
| |
| * Valid in Asynchronous Callback: NO |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded |
| * into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_SUCCESS - the media information was returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not |
| * exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device |
| * pair does not exist |
| * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available |
| * CY_AS_ERROR_INVALID_RESPONSE - an error message was |
| * recieved from the firmware |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_reset_card( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device |
| ); |
| |
| /* Summary |
| This function performs a Synchronous 1 byte read from the sdio |
| device function. |
| |
| Description |
| This function is used to perform a synchronous 1 byte read |
| from an SDIO card function. This function is to be used only |
| for IO to an SDIO card as other media will not respond to the |
| SDIO command set. |
| |
| * Valid in Asynchronous Callback: NO |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not |
| * been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded |
| * into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed |
| * in |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_SUCCESS - the media information was returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with |
| * the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair |
| * does not exist |
| * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available |
| * CY_AS_ERROR_INVALID_RESPONSE - an error message was recieved |
| * from the firmware |
| * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading |
| * from the media |
| * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to an |
| * invalid function |
| * CY_AS_ERROR_FUNCTION_SUSPENDED - The function to which read |
| * was attempted is in suspend |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_direct_read( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device, |
| /* IO function Number */ |
| uint8_t n_function_no, |
| /* Address for IO */ |
| uint32_t address, |
| /* Set to CY_SDIO_REARM_INT to reinitialize SDIO interrupt */ |
| uint8_t misc_buf, |
| /* Buffer to hold byte read from card */ |
| uint8_t *data_p |
| ); |
| |
| /* Summary |
| This function performs a Synchronous 1 byte write to the |
| sdio device function. |
| |
| Description |
| This function is used to perform a synchronous 1 byte write |
| to an SDIO card function. |
| This function is to be used only for IO to an SDIO card as |
| other media will not respond to the SDIO command set. |
| |
| * Valid in Asynchronous Callback: NO |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been |
| * started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_SUCCESS - the media information was returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device |
| * pair does not exist |
| * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available |
| * CY_AS_ERROR_INVALID_RESPONSE - an error message was recieved |
| * from the firmware |
| * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in |
| * reading from the media |
| * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to |
| * an invalid function |
| * CY_AS_ERROR_FUNCTION_SUSPENDED - The function to which |
| * write was attempted is in suspend |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_direct_write( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device, |
| /* IO function Number */ |
| uint8_t n_function_no, |
| /* Address for IO */ |
| uint32_t address, |
| /* Set to CY_SDIO_REARM_INT to reinitialize SDIO interrupt, |
| set to CY_SDIO_RAW for read after write */ |
| uint8_t misc_buf, |
| /* Byte to write */ |
| uint16_t argument, |
| /* Buffer to hold byte read from card in Read after write mode */ |
| uint8_t *data_p |
| ); |
| |
| /* Summary |
| This function is used to set the blocksize of an SDIO function. |
| |
| Description |
| This function is used to set the blocksize of an SDIO function. |
| This function is to be used only for IO to an SDIO card as |
| other media will not respond to the SDIO command set. |
| |
| * Valid in Asynchronous Callback: NO |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_SUCCESS - the media information was |
| * returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not |
| * exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device |
| * pair does not exist |
| * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory |
| * available |
| * CY_AS_ERROR_INVALID_RESPONSE - an error message was |
| * recieved from the firmware |
| * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in |
| * reading from the media |
| * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made |
| * to an invalid function |
| * CY_AS_ERROR_INVALID_BLOCKSIZE - An incorrect blocksize |
| * was passed to the function. |
| * CY_AS_ERROR_FUNCTION_SUSPENDED - The function to which |
| * write was attempted is in suspend |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_set_blocksize( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device, |
| /* IO function Number */ |
| uint8_t n_function_no, |
| /* Block size to set. */ |
| uint16_t blocksize |
| ); |
| |
| /* Summary |
| This function is used to read Multibyte/Block data from a |
| IO function. |
| |
| Description |
| This function is used to read Multibyte/Block data from a |
| IO function. This function is to be used only for IO to an |
| SDIO card as other media will not respond to the SDIO |
| command set. |
| |
| * Valid in Asynchronous Callback: YES |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_SUCCESS - the media information was returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with |
| * the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device |
| * pair does not exist |
| * CY_AS_ERROR_ASYNC_PENDING - an async operation is pending |
| * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available |
| * CY_AS_ERROR_INVALID_RESPONSE - an error message was recieved |
| * from the firmware |
| * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in |
| * reading from the media |
| * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to |
| * an invalid function |
| * CY_AS_ERROR_INVALID_BLOCKSIZE - An incorrect blocksize or |
| * block count was passed to the function. |
| * CY_AS_ERROR_FUNCTION_SUSPENDED - The function to which |
| * write was attempted is in suspend |
| * CY_AS_ERROR_IO_ABORTED - The IO operation was aborted |
| * CY_AS_ERROR_IO_SUSPENDED - The IO operation was suspended |
| * CY_AS_ERROR_INVALID_REQUEST - An invalid request was |
| * passed to the card. |
| |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_extended_read( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device, |
| /* IO function Number */ |
| uint8_t n_function_no, |
| /* Base Address for IO */ |
| uint32_t address, |
| /* Set to CY_SDIO_BLOCKMODE for block IO, |
| CY_SDIO_BYTEMODE for multibyte IO, |
| CY_SDIO_OP_FIFO to read multiple bytes from the |
| same address, CY_SDIO_OP_INCR to read bytes from |
| the incrementing addresses */ |
| uint8_t misc_buf, |
| /* Block/Byte count to read */ |
| uint16_t argument, |
| /* Buffer to hold data read from card */ |
| uint8_t *data_p, |
| /* Callback in case of Asyncronous call. 0 if Synchronous */ |
| cy_as_sdio_callback callback |
| ); |
| |
| /* Summary |
| This function is used to write Multibyte/Block data |
| to a IO function. |
| |
| Description |
| This function is used to write Multibyte/Block data |
| to a IO function. This function is to be used only |
| for IO to an SDIO card as other media will not respond |
| to the SDIO command set. |
| |
| * Valid in Asynchronous Callback: YES |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_SUCCESS - the media information was returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not |
| * exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device |
| * pair does not exist |
| * CY_AS_ERROR_ASYNC_PENDING - an async operation is pending |
| * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available |
| * CY_AS_ERROR_INVALID_RESPONSE - an error message was |
| * recieved from the firmware |
| * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in |
| * reading from the media |
| * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made |
| * to an invalid function |
| * CY_AS_ERROR_INVALID_BLOCKSIZE - An incorrect blocksize or |
| * block count was passed to the function. |
| * CY_AS_ERROR_FUNCTION_SUSPENDED - The function to which |
| * write was attempted is in suspend |
| * CY_AS_ERROR_IO_ABORTED - The IO operation was aborted |
| * CY_AS_ERROR_IO_SUSPENDED - The IO operation was suspended |
| * CY_AS_ERROR_INVALID_REQUEST - An invalid request was |
| * passed to the card. |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_extended_write( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device, |
| /* IO function Number */ |
| uint8_t n_function_no, |
| /* Base Address for IO */ |
| uint32_t address, |
| /* Set to CY_SDIO_BLOCKMODE for block IO, |
| CY_SDIO_BYTEMODE for multibyte IO, |
| CY_SDIO_OP_FIFO to write multiple bytes to the same address, |
| CY_SDIO_OP_INCR to write multiple bytes to incrementing |
| addresses */ |
| uint8_t misc_buf, |
| /* Block/Byte count to write |
| in case of byte mode the count should not exceed the block size |
| or 512, whichever is smaller. |
| in case of block mode, maximum number of blocks is 511. */ |
| uint16_t argument, |
| /* Buffer to hold data to be written to card. */ |
| uint8_t *data_p, |
| /* Callback in case of Asyncronous call. 0 if Synchronous */ |
| cy_as_sdio_callback callback |
| ); |
| |
| /* Summary |
| This function is used to initialize a SDIO card function. |
| |
| Description |
| This function is used to initialize a SDIO card function |
| (1 - 7). This function is to be used only for IO to an |
| SDIO card as other media will not respond to the SDIO |
| command set. |
| |
| * Valid in Asynchronous Callback: NO |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded |
| * into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been |
| * started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed |
| * in |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_SUCCESS - the media information was returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device |
| * pair does not exist |
| * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available |
| * CY_AS_ERROR_INVALID_RESPONSE - an error message was |
| * recieved from the firmware |
| * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in |
| * reading from the media |
| * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made |
| * to an invalid function |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_init_function( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device, |
| /* IO function Number */ |
| uint8_t n_function_no, |
| /* Set to CY_SDIO_FORCE_INIT to reinitialize function */ |
| uint8_t misc_buf |
| ); |
| |
| /* Summary |
| This function is used to get properties of a SDIO card function. |
| |
| Description |
| This function is used to get properties of a SDIO card functio |
| (1 - 7) into a CyAsSDIOFunc structure. This function is to be |
| used only for IO to an SDIO card as other media will not respond |
| to the SDIO command set. |
| |
| * Valid in Asynchronous Callback: NO |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not |
| * been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded |
| * into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been |
| * started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed |
| * in |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_SUCCESS - the media information was returned |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the media specified does |
| * not exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair |
| * does not exist |
| * CY_AS_ERROR_INVALID_FUNCTION - An IO request was made to |
| * an invalid function |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_query_function( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device, |
| /* IO function Number */ |
| uint8_t n_function_no, |
| /* Buffer to store function properties */ |
| cy_as_sdio_func *data_p |
| ); |
| |
| /* Summary |
| This function is used to Abort the current IO function. |
| |
| Description |
| This function is used to Abort the current IO function. |
| This function is to be used only for IO to an SDIO card as |
| other media will not respond to the SDIO command set. |
| |
| * Valid in Asynchronous Callback: NO |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device |
| * has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_SUCCESS - the media information was |
| * returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not |
| * exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified |
| * media/device pair does not exist |
| * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory |
| * available |
| * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made |
| * to an invalid function |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_abort_function( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device, |
| /* IO function Number */ |
| uint8_t n_function_no |
| ); |
| |
| /* Summary |
| This function is used to Disable IO to an SDIO function. |
| |
| Description |
| This function is used to Disable IO to an SDIO function. |
| This function is to be used only for IO to an SDIO card as |
| other media will not respond to the SDIO command set. |
| |
| * Valid in Asynchronous Callback: NO |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device |
| * has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is |
| * in suspend mode |
| * CY_AS_ERROR_SUCCESS - the media information was |
| * returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not |
| * exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device |
| * pair does not exist |
| * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made |
| * to an invalid function |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_de_init_function( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device, |
| /* IO function Number */ |
| uint8_t n_function_no |
| ); |
| |
| /* Summary |
| This function is used to Suspend the current IO function. |
| |
| Description |
| This function is used to Suspend the current IO function. |
| This function is to be used only for IO to an SDIO card as |
| other media will not respond to the SDIO command set. |
| |
| * Valid in Asynchronous Callback: NO |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has |
| * not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in |
| * suspend mode |
| * CY_AS_ERROR_SUCCESS - the media information was returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating |
| * with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not |
| * exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified |
| * media/device pair does not exist |
| * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory |
| * available |
| * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made |
| * to an invalid function |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_suspend( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device, |
| /* IO function Number */ |
| uint8_t n_function_no |
| ); |
| |
| /* Summary |
| This function is used to resume a Suspended IO function. |
| |
| Description |
| This function is used to resume a Suspended IO function. |
| This function is to be used only for IO to an SDIO card as |
| other media will not respond to the SDIO command set. |
| |
| * Valid in Asynchronous Callback: NO |
| * Valid on Antioch device: NO |
| |
| Returns |
| * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device |
| * has not been configured |
| * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been |
| * loaded into West Bridge |
| * CY_AS_ERROR_NOT_RUNNING - the storage stack has not |
| * been started |
| * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was |
| * passed in |
| * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is |
| * in suspend mode |
| * CY_AS_ERROR_SUCCESS - the media information was |
| * returned |
| * CY_AS_ERROR_TIMEOUT - a timeout occurred |
| * communicating with the West Bridge device |
| * CY_AS_ERROR_NOT_RUNNING - the stack is not running |
| * CY_AS_ERROR_NO_SUCH_BUS - the bus specified |
| * does not exist |
| * CY_AS_ERROR_NO_SUCH_DEVICE - the specified |
| * media/device pair does not exist |
| * CY_AS_ERROR_ASYNC_PENDING - an async operation |
| * is pending |
| * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory |
| * available |
| * CY_AS_ERROR_INVALID_RESPONSE - an error message was |
| * recieved from the firmware |
| * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error |
| * in reading from the media |
| * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was |
| * made to an invalid function |
| * CY_AS_ERROR_IO_ABORTED - The IO operation was |
| * aborted |
| * CY_AS_ERROR_IO_SUSPENDED - The IO operation was |
| * suspended |
| * CY_AS_ERROR_INVALID_REQUEST - An invalid request was |
| * passed to the card. |
| |
| */ |
| cy_as_return_status_t |
| cy_as_sdio_resume( |
| /* Handle to the Westbridge device */ |
| cy_as_device_handle handle, |
| /* Bus to use */ |
| cy_as_bus_number_t bus, |
| /* Device number */ |
| uint32_t device, |
| /* IO function Number */ |
| uint8_t n_function_no, |
| /* Operation to resume (Read or Write) */ |
| cy_as_oper_type op, |
| /* Micellaneous buffer same as for Extended read and Write */ |
| uint8_t misc_buf, |
| /* Number of pending blocks for IO. Should be less |
| than or equal to the maximum defined for extended |
| read and write */ |
| uint16_t pendingblockcount, |
| /* Buffer to continue the Suspended IO operation */ |
| uint8_t *data_p |
| ); |
| |
| |
| |
| /* For supporting deprecated functions */ |
| #include "cyasstorage_dep.h" |
| |
| #include "cyas_cplus_end.h" |
| |
| #endif /* _INCLUDED_CYASSTORAGE_H_ */ |
