--- /dev/null
+/* Cypress West Bridge API source file (cyasmisc.c)
+## ===========================
+## 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.
+## ===========================
+*/
+
+#include "../../include/linux/westbridge/cyashal.h"
+#include "../../include/linux/westbridge/cyasmisc.h"
+#include "../../include/linux/westbridge/cyasdma.h"
+#include "../../include/linux/westbridge/cyasintr.h"
+#include "../../include/linux/westbridge/cyaserr.h"
+#include "../../include/linux/westbridge/cyasregs.h"
+#include "../../include/linux/westbridge/cyaslowlevel.h"
+#include "../../include/linux/westbridge/cyasprotocol.h"
+
+/*
+* The device list, the only global in the API
+*/
+static cy_as_device *g_device_list;
+
+/*
+ * The current debug level
+ */
+static uint8_t debug_level;
+
+/*
+ * This function sets the debug level for the API
+ *
+ */
+void
+cy_as_misc_set_log_level(uint8_t level)
+{
+ debug_level = level;
+}
+
+#ifdef CY_AS_LOG_SUPPORT
+
+/*
+ * This function is a low level logger for the API.
+ */
+void
+cy_as_log_debug_message(int level, const char *str)
+{
+ if (level <= debug_level)
+ cy_as_hal_print_message("log %d: %s\n", level, str);
+}
+
+#endif
+
+#define cy_as_check_device_ready(dev_p) \
+{\
+ if (!(dev_p) || ((dev_p)->sig != \
+ CY_AS_DEVICE_HANDLE_SIGNATURE)) \
+ return CY_AS_ERROR_INVALID_HANDLE; \
+\
+ if (!cy_as_device_is_configured(dev_p)) \
+ return CY_AS_ERROR_NOT_CONFIGURED; \
+\
+ if (!cy_as_device_is_firmware_loaded(dev_p))\
+ return CY_AS_ERROR_NO_FIRMWARE; \
+}
+
+/* Find an West Bridge device based on a TAG */
+cy_as_device *
+cy_as_device_find_from_tag(cy_as_hal_device_tag tag)
+{
+ cy_as_device *dev_p;
+
+ for (dev_p = g_device_list; dev_p != 0; dev_p = dev_p->next_p) {
+ if (dev_p->tag == tag)
+ return dev_p;
+ }
+
+ return 0;
+}
+
+/* Map a pre-V1.2 media type to the V1.2+ bus number */
+static void
+cy_as_bus_from_media_type(cy_as_media_type type,
+ cy_as_bus_number_t *bus)
+{
+ if (type == cy_as_media_nand)
+ *bus = 0;
+ else
+ *bus = 1;
+}
+
+static cy_as_return_status_t
+my_handle_response_no_data(cy_as_device *dev_p,
+ cy_as_ll_request_response *req_p,
+ cy_as_ll_request_response *reply_p)
+{
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_SUCCESS_FAILURE)
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ else
+ ret = cy_as_ll_request_response__get_word(reply_p, 0);
+
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+/*
+* Create a new West Bridge device
+*/
+cy_as_return_status_t
+cy_as_misc_create_device(cy_as_device_handle *handle_p,
+ cy_as_hal_device_tag tag)
+{
+ cy_as_device *dev_p;
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+
+ cy_as_log_debug_message(6, "cy_as_misc_create_device called");
+
+ dev_p = (cy_as_device *)cy_as_hal_alloc(sizeof(cy_as_device));
+ if (dev_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ cy_as_hal_mem_set(dev_p, 0, sizeof(cy_as_device));
+
+ /*
+ * dynamically allocating this buffer to ensure that it is
+ * word aligned.
+ */
+ dev_p->usb_ep_data = (uint8_t *)cy_as_hal_alloc(64 * sizeof(uint8_t));
+ if (dev_p->usb_ep_data == 0) {
+ cy_as_hal_free(dev_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ dev_p->sig = CY_AS_DEVICE_HANDLE_SIGNATURE;
+ dev_p->tag = tag;
+ dev_p->usb_max_tx_size = 0x40;
+
+ dev_p->storage_write_endpoint = CY_AS_P2S_WRITE_ENDPOINT;
+ dev_p->storage_read_endpoint = CY_AS_P2S_READ_ENDPOINT;
+
+ dev_p->func_cbs_misc = cy_as_create_c_b_queue(CYAS_FUNC_CB);
+ if (dev_p->func_cbs_misc == 0)
+ goto destroy;
+
+ dev_p->func_cbs_res = cy_as_create_c_b_queue(CYAS_FUNC_CB);
+ if (dev_p->func_cbs_res == 0)
+ goto destroy;
+
+ dev_p->func_cbs_stor = cy_as_create_c_b_queue(CYAS_FUNC_CB);
+ if (dev_p->func_cbs_stor == 0)
+ goto destroy;
+
+ dev_p->func_cbs_usb = cy_as_create_c_b_queue(CYAS_FUNC_CB);
+ if (dev_p->func_cbs_usb == 0)
+ goto destroy;
+
+ dev_p->func_cbs_mtp = cy_as_create_c_b_queue(CYAS_FUNC_CB);
+ if (dev_p->func_cbs_mtp == 0)
+ goto destroy;
+
+ /*
+ * allocate memory for the DMA module here. it is then marked idle, and
+ * will be activated when cy_as_misc_configure_device is called.
+ */
+ ret = cy_as_dma_start(dev_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ cy_as_device_set_dma_stopped(dev_p);
+
+ /*
+ * allocate memory for the low level module here. this module is also
+ * activated only when cy_as_misc_configure_device is called.
+ */
+ ret = cy_as_ll_start(dev_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ cy_as_device_set_low_level_stopped(dev_p);
+
+ dev_p->next_p = g_device_list;
+ g_device_list = dev_p;
+
+ *handle_p = dev_p;
+ cy_as_hal_init_dev_registers(tag, cy_false);
+ return CY_AS_ERROR_SUCCESS;
+
+destroy:
+ /* Free any queues that were successfully allocated. */
+ if (dev_p->func_cbs_misc)
+ cy_as_destroy_c_b_queue(dev_p->func_cbs_misc);
+
+ if (dev_p->func_cbs_res)
+ cy_as_destroy_c_b_queue(dev_p->func_cbs_res);
+
+ if (dev_p->func_cbs_stor)
+ cy_as_destroy_c_b_queue(dev_p->func_cbs_stor);
+
+ if (dev_p->func_cbs_usb)
+ cy_as_destroy_c_b_queue(dev_p->func_cbs_usb);
+
+ if (dev_p->func_cbs_mtp)
+ cy_as_destroy_c_b_queue(dev_p->func_cbs_mtp);
+
+ cy_as_hal_free(dev_p->usb_ep_data);
+ cy_as_hal_free(dev_p);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+ else
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+}
+
+/*
+* Destroy an existing West Bridge device
+*/
+cy_as_return_status_t
+cy_as_misc_destroy_device(cy_as_device_handle handle)
+{
+ cy_as_return_status_t ret;
+ cy_as_device *dev_p;
+
+ cy_as_log_debug_message(6, "cy_as_misc_destroy_device called");
+
+ dev_p = (cy_as_device *)handle;
+ if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE;
+
+ /*
+ * if the USB stack is still running,
+ * it must be stopped first
+ */
+ if (dev_p->usb_count > 0)
+ return CY_AS_ERROR_STILL_RUNNING;
+
+ /*
+ * if the STORAGE stack is still running,
+ * it must be stopped first
+ */
+ if (dev_p->storage_count > 0)
+ return CY_AS_ERROR_STILL_RUNNING;
+
+ if (cy_as_device_is_intr_running(dev_p))
+ ret = cy_as_intr_stop(dev_p);
+
+ ret = cy_as_ll_stop(dev_p);
+ if (ret != CY_AS_ERROR_SUCCESS) {
+ cy_as_intr_start(dev_p, dev_p->use_int_drq);
+ return ret;
+ }
+
+ ret = cy_as_dma_stop(dev_p);
+ if (ret != CY_AS_ERROR_SUCCESS) {
+ cy_as_intr_start(dev_p, dev_p->use_int_drq);
+ return ret;
+ }
+
+ /* Reset the West Bridge device. */
+ cy_as_hal_write_register(dev_p->tag, CY_AS_MEM_RST_CTRL_REG,
+ CY_AS_MEM_RST_CTRL_REG_HARD);
+
+ /*
+ * remove the device from the device list
+ */
+ if (g_device_list == dev_p) {
+ g_device_list = dev_p->next_p;
+ } else {
+ cy_as_device *tmp_p = g_device_list;
+ while (tmp_p && tmp_p->next_p != dev_p)
+ tmp_p = tmp_p->next_p;
+
+ cy_as_hal_assert(tmp_p != 0);
+ tmp_p->next_p = dev_p->next_p;
+ }
+
+ /*
+ * reset the signature so this will not be detected
+ * as a valid handle
+ */
+ dev_p->sig = 0;
+
+ cy_as_destroy_c_b_queue(dev_p->func_cbs_misc);
+ cy_as_destroy_c_b_queue(dev_p->func_cbs_res);
+ cy_as_destroy_c_b_queue(dev_p->func_cbs_stor);
+ cy_as_destroy_c_b_queue(dev_p->func_cbs_usb);
+ cy_as_destroy_c_b_queue(dev_p->func_cbs_mtp);
+
+ /*
+ * free the memory associated with the device
+ */
+ cy_as_hal_free(dev_p->usb_ep_data);
+ cy_as_hal_free(dev_p);
+
+ return CY_AS_ERROR_SUCCESS;
+}
+
+/*
+* Determine the endian mode for the processor we are
+* running on, then set the endian mode register
+*/
+static void
+cy_as_setup_endian_mode(cy_as_device *dev_p)
+{
+ /*
+ * In general, we always set west bridge intothe little
+ * endian mode. this causes the data on bit 0 internally
+ * to come out on data line 0 externally and it is generally
+ * what we want regardless of the endian mode of the
+ * processor. this capability in west bridge should be
+ * labeled as a "SWAP" capability and can be used to swap the
+ * bytes of data in and out of west bridge. this is
+ * useful if there is DMA hardware that requires this for some
+ * reason I cannot imagine at this time. basically if the
+ * wires are connected correctly, we should never need to
+ * change the endian-ness of west bridge.
+ */
+ cy_as_hal_write_register(dev_p->tag, CY_AS_MEM_P0_ENDIAN,
+ CY_AS_LITTLE_ENDIAN);
+}
+
+/*
+* Query the West Bridge device and determine if we are an standby mode
+*/
+cy_as_return_status_t
+cy_as_misc_in_standby(cy_as_device_handle handle, cy_bool *standby)
+{
+ cy_as_device *dev_p;
+
+ cy_as_log_debug_message(6, "cy_as_misc_in_standby called");
+
+ dev_p = (cy_as_device *)handle;
+ if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE;
+
+ if (cy_as_device_is_pin_standby(dev_p) ||
+ cy_as_device_is_register_standby(dev_p)) {
+ *standby = cy_true;
+ } else
+ *standby = cy_false;
+
+ return CY_AS_ERROR_SUCCESS;
+}
+
+static void
+cy_as_misc_func_callback(cy_as_device *dev_p,
+ uint8_t context,
+ cy_as_ll_request_response *rqt,
+ cy_as_ll_request_response *resp,
+ cy_as_return_status_t ret);
+
+
+static void
+my_misc_callback(cy_as_device *dev_p, uint8_t context,
+ cy_as_ll_request_response *req_p,
+ cy_as_ll_request_response *resp_p,
+ cy_as_return_status_t ret)
+{
+ (void)resp_p;
+ (void)context;
+ (void)ret;
+
+ switch (cy_as_ll_request_response__get_code(req_p)) {
+ case CY_RQT_INITIALIZATION_COMPLETE:
+ {
+ uint16_t v;
+
+ cy_as_ll_send_status_response(dev_p,
+ CY_RQT_GENERAL_RQT_CONTEXT,
+ CY_AS_ERROR_SUCCESS, 0);
+ cy_as_device_set_firmware_loaded(dev_p);
+
+ if (cy_as_device_is_waking(dev_p)) {
+ /*
+ * this is a callback from a
+ * cy_as_misc_leave_standby()
+ * request. in this case we call
+ * the standby callback and clear
+ * the waking state.
+ */
+ if (dev_p->misc_event_cb)
+ dev_p->misc_event_cb(
+ (cy_as_device_handle)dev_p,
+ cy_as_event_misc_awake, 0);
+ cy_as_device_clear_waking(dev_p);
+ } else {
+ v = cy_as_ll_request_response__get_word
+ (req_p, 3);
+
+ /*
+ * store the media supported on
+ * each of the device buses.
+ */
+ dev_p->media_supported[0] =
+ (uint8_t)(v & 0xFF);
+ dev_p->media_supported[1] =
+ (uint8_t)((v >> 8) & 0xFF);
+
+ v = cy_as_ll_request_response__get_word
+ (req_p, 4);
+
+ dev_p->is_mtp_firmware =
+ (cy_bool)((v >> 8) & 0xFF);
+
+ if (dev_p->misc_event_cb)
+ dev_p->misc_event_cb(
+ (cy_as_device_handle)dev_p,
+ cy_as_event_misc_initialized, 0);
+ }
+
+ v = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_P0_VM_SET);
+
+ if (v & CY_AS_MEM_P0_VM_SET_CFGMODE)
+ cy_as_hal_print_message(
+ "initialization message "
+ "recieved, but config bit "
+ "still set\n");
+
+ v = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_RST_CTRL_REG);
+ if ((v & CY_AS_MEM_RST_RSTCMPT) == 0)
+ cy_as_hal_print_message(
+ "initialization message "
+ "recieved, but reset complete "
+ "bit still not set\n");
+ }
+ break;
+
+ case CY_RQT_OUT_OF_SUSPEND:
+ cy_as_ll_send_status_response(dev_p, CY_RQT_GENERAL_RQT_CONTEXT,
+ CY_AS_ERROR_SUCCESS, 0);
+ cy_as_device_clear_suspend_mode(dev_p);
+
+ /*
+ * if the wakeup was caused by an async cy_as_misc_leave_suspend
+ * call, we have to call the corresponding callback.
+ */
+ if (dev_p->func_cbs_misc->count > 0) {
+ cy_as_func_c_b_node *node = (cy_as_func_c_b_node *)
+ dev_p->func_cbs_misc->head_p;
+ cy_as_hal_assert(node);
+
+ if (cy_as_funct_c_b_type_get_type(node->data_type) ==
+ CY_FUNCT_CB_MISC_LEAVESUSPEND) {
+ cy_as_hal_assert(node->cb_p != 0);
+
+ node->cb_p((cy_as_device_handle)dev_p,
+ CY_AS_ERROR_SUCCESS, node->client_data,
+ CY_FUNCT_CB_MISC_LEAVESUSPEND, 0);
+ cy_as_remove_c_b_node(dev_p->func_cbs_misc);
+ }
+ }
+
+ if (dev_p->misc_event_cb)
+ dev_p->misc_event_cb((cy_as_device_handle)dev_p,
+ cy_as_event_misc_wakeup, 0);
+ break;
+
+ case CY_RQT_DEBUG_MESSAGE:
+ if ((req_p->data[0] == 0) && (req_p->data[1] == 0) &&
+ (req_p->data[2] == 0)) {
+ if (dev_p->misc_event_cb)
+ dev_p->misc_event_cb((cy_as_device_handle)dev_p,
+ cy_as_event_misc_heart_beat, 0);
+ } else {
+ cy_as_hal_print_message(
+ "**** debug message: %02x "
+ "%02x %02x %02x %02x %02x\n",
+ req_p->data[0] & 0xff,
+ (req_p->data[0] >> 8) & 0xff,
+ req_p->data[1] & 0xff,
+ (req_p->data[1] >> 8) & 0xff,
+ req_p->data[2] & 0xff,
+ (req_p->data[2] >> 8) & 0xff);
+ }
+ break;
+
+ case CY_RQT_WB_DEVICE_MISMATCH:
+ {
+ if (dev_p->misc_event_cb)
+ dev_p->misc_event_cb((cy_as_device_handle)dev_p,
+ cy_as_event_misc_device_mismatch, 0);
+ }
+ break;
+
+ case CY_RQT_BOOTLOAD_NO_FIRMWARE:
+ {
+ /* TODO Handle case when firmware is
+ * not found during bootloading. */
+ cy_as_hal_print_message("no firmware image found "
+ "during bootload. device not started\n");
+ }
+ break;
+
+ default:
+ cy_as_hal_assert(0);
+ }
+}
+
+static cy_bool
+is_valid_silicon_id(uint16_t v)
+{
+ cy_bool idok = cy_false;
+
+ /*
+ * remove the revision number from the ID value
+ */
+ v = v & CY_AS_MEM_CM_WB_CFG_ID_HDID_MASK;
+
+ /*
+ * if this is west bridge, then we are OK.
+ */
+ if (v == CY_AS_MEM_CM_WB_CFG_ID_HDID_ANTIOCH_VALUE ||
+ v == CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_FPGA_VALUE ||
+ v == CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_VALUE)
+ idok = cy_true;
+
+ return idok;
+}
+
+/*
+* Configure the West Bridge device hardware
+*/
+cy_as_return_status_t
+cy_as_misc_configure_device(cy_as_device_handle handle,
+ cy_as_device_config *config_p)
+{
+ cy_as_return_status_t ret;
+ cy_bool standby;
+ cy_as_device *dev_p;
+ uint16_t v;
+ uint16_t fw_present;
+ cy_as_log_debug_message(6, "cy_as_misc_configure_device called");
+
+ dev_p = (cy_as_device *)handle;
+ if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE;
+
+ /* Setup big endian vs little endian */
+ cy_as_setup_endian_mode(dev_p);
+
+ /* Now, confirm that we can talk to the West Bridge device */
+ dev_p->silicon_id = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_CM_WB_CFG_ID);
+ fw_present = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_RST_CTRL_REG);
+ if (!(fw_present & CY_AS_MEM_RST_RSTCMPT)) {
+ if (!is_valid_silicon_id(dev_p->silicon_id))
+ return CY_AS_ERROR_NO_ANTIOCH;
+ }
+ /* Check for standby mode */
+ ret = cy_as_misc_in_standby(handle, &standby);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+ if (ret)
+ return CY_AS_ERROR_IN_STANDBY;
+
+ /* Setup P-port interface mode (CRAM / SRAM). */
+ if (cy_as_device_is_astoria_dev(dev_p)) {
+ if (config_p->srammode)
+ v = CY_AS_MEM_P0_VM_SET_VMTYPE_SRAM;
+ else
+ v = CY_AS_MEM_P0_VM_SET_VMTYPE_RAM;
+ } else
+ v = CY_AS_MEM_P0_VM_SET_VMTYPE_RAM;
+
+ /* Setup synchronous versus asynchronous mode */
+ if (config_p->sync)
+ v |= CY_AS_MEM_P0_VM_SET_IFMODE;
+ if (config_p->dackmode == cy_as_device_dack_ack)
+ v |= CY_AS_MEM_P0_VM_SET_DACKEOB;
+ if (config_p->drqpol)
+ v |= CY_AS_MEM_P0_VM_SET_DRQPOL;
+ if (config_p->dackpol)
+ v |= CY_AS_MEM_P0_VM_SET_DACKPOL;
+ cy_as_hal_write_register(dev_p->tag, CY_AS_MEM_P0_VM_SET, v);
+
+ if (config_p->crystal)
+ cy_as_device_set_crystal(dev_p);
+ else
+ cy_as_device_set_external_clock(dev_p);
+
+ /* Register a callback to handle MISC requests from the firmware */
+ cy_as_ll_register_request_callback(dev_p,
+ CY_RQT_GENERAL_RQT_CONTEXT, my_misc_callback);
+
+ /* Now mark the DMA and low level modules as active. */
+ cy_as_device_set_dma_running(dev_p);
+ cy_as_device_set_low_level_running(dev_p);
+
+ /* Now, initialize the interrupt module */
+ dev_p->use_int_drq = config_p->dmaintr;
+ ret = cy_as_intr_start(dev_p, config_p->dmaintr);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+
+ /* Mark the interface as initialized */
+ cy_as_device_set_configured(dev_p);
+
+ return CY_AS_ERROR_SUCCESS;
+}
+
+static void
+my_dma_callback(cy_as_device *dev_p,
+ cy_as_end_point_number_t ep,
+ void *mem_p,
+ uint32_t size,
+ cy_as_return_status_t ret
+ )
+{
+ cy_as_dma_end_point *ep_p;
+
+ (void)size;
+
+ /* Get the endpoint pointer based on the endpoint number */
+ ep_p = CY_AS_NUM_EP(dev_p, ep);
+
+ /* Check the queue to see if is drained */
+ if (ep_p->queue_p == 0) {
+ cy_as_func_c_b_node *node =
+ (cy_as_func_c_b_node *)dev_p->func_cbs_misc->head_p;
+
+ cy_as_hal_assert(node);
+
+ if (ret == CY_AS_ERROR_SUCCESS) {
+ /*
+ * disable endpoint 2. the storage module
+ * will enable this EP if necessary.
+ */
+ cy_as_dma_enable_end_point(dev_p,
+ CY_AS_FIRMWARE_ENDPOINT,
+ cy_false, cy_as_direction_in);
+
+ /*
+ * clear the reset register. this releases the
+ * antioch micro-controller from reset and begins
+ * running the code at address zero.
+ */
+ cy_as_hal_write_register(dev_p->tag,
+ CY_AS_MEM_RST_CTRL_REG, 0x00);
+ }
+
+ /* Call the user Callback */
+ node->cb_p((cy_as_device_handle)dev_p, ret, node->client_data,
+ node->data_type, node->data);
+ cy_as_remove_c_b_node(dev_p->func_cbs_misc);
+ } else {
+ /* This is the header data that was allocated in the
+ * download firmware function, and can be safely freed
+ * here. */
+ uint32_t state = cy_as_hal_disable_interrupts();
+ cy_as_hal_c_b_free(mem_p);
+ cy_as_hal_enable_interrupts(state);
+ }
+}
+
+cy_as_return_status_t
+cy_as_misc_download_firmware(cy_as_device_handle handle,
+ const void *mem_p,
+ uint16_t size,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ uint8_t *header;
+ cy_as_return_status_t ret;
+ cy_bool standby;
+ cy_as_device *dev_p;
+ cy_as_dma_callback dmacb = 0;
+ uint32_t state;
+
+ cy_as_log_debug_message(6, "cy_as_misc_download_firmware called");
+
+ /* Make sure we have a valid device */
+ dev_p = (cy_as_device *)handle;
+ if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE;
+
+ /*
+ * if the device has not been initialized, we cannot download firmware
+ * to the device.
+ */
+ if (!cy_as_device_is_configured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED;
+
+ /*
+ * make sure west bridge is not in standby
+ */
+ ret = cy_as_misc_in_standby(dev_p, &standby);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+
+ if (standby)
+ return CY_AS_ERROR_IN_STANDBY;
+
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ /*
+ * make sure we are in configuration mode
+ */
+ if ((cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_P0_VM_SET) &
+ CY_AS_MEM_P0_VM_SET_CFGMODE) == 0)
+ return CY_AS_ERROR_NOT_IN_CONFIG_MODE;
+
+ /* Maximum firmware size is 24k */
+ if (size > CY_AS_MAXIMUM_FIRMWARE_SIZE)
+ return CY_AS_ERROR_INVALID_SIZE;
+
+ /* Make sure the size is an even number of bytes as well */
+ if (size & 0x01)
+ return CY_AS_ERROR_ALIGNMENT_ERROR;
+
+ /*
+ * write the two word header that gives the base address and
+ * size of the firmware image to download
+ */
+ state = cy_as_hal_disable_interrupts();
+ header = (uint8_t *)cy_as_hal_c_b_alloc(4);
+ cy_as_hal_enable_interrupts(state);
+ if (header == NULL)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ header[0] = 0x00;
+ header[1] = 0x00;
+ header[2] = (uint8_t)(size & 0xff);
+ header[3] = (uint8_t)((size >> 8) & 0xff);
+
+ /* Enable the firmware endpoint */
+ ret = cy_as_dma_enable_end_point(dev_p, CY_AS_FIRMWARE_ENDPOINT,
+ cy_true, cy_as_direction_in);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+
+ /*
+ * setup DMA for 64 byte packets. this is the requirement for downloading
+ * firmware to west bridge.
+ */
+ cy_as_dma_set_max_dma_size(dev_p, CY_AS_FIRMWARE_ENDPOINT, 64);
+
+ if (cb)
+ dmacb = my_dma_callback;
+
+ ret = cy_as_dma_queue_request(dev_p, CY_AS_FIRMWARE_ENDPOINT, header,
+ 4, cy_false, cy_false, dmacb);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+
+ /*
+ * write the firmware image to the west bridge device
+ */
+ ret = cy_as_dma_queue_request(dev_p, CY_AS_FIRMWARE_ENDPOINT,
+ (void *)mem_p, size, cy_false, cy_false, dmacb);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+
+ if (cb) {
+ cy_as_func_c_b_node *cbnode = cy_as_create_func_c_b_node_data(
+ cb, client, CY_FUNCT_CB_MISC_DOWNLOADFIRMWARE, 0);
+
+ if (cbnode == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ else
+ cy_as_insert_c_b_node(dev_p->func_cbs_misc, cbnode);
+
+ ret = cy_as_dma_kick_start(dev_p, CY_AS_FIRMWARE_ENDPOINT);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+ } else {
+ ret = cy_as_dma_drain_queue(dev_p,
+ CY_AS_FIRMWARE_ENDPOINT, cy_true);
+
+ /* Free the header memory that was allocated earlier. */
+ cy_as_hal_c_b_free(header);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+
+ /*
+ * disable EP 2. the storage module will
+ * enable this EP if necessary.
+ */
+ cy_as_dma_enable_end_point(dev_p, CY_AS_FIRMWARE_ENDPOINT,
+ cy_false, cy_as_direction_in);
+
+ /*
+ * clear the reset register. this releases the west bridge
+ * micro-controller from reset and begins running the code at
+ * address zero.
+ */
+ cy_as_hal_write_register(dev_p->tag,
+ CY_AS_MEM_RST_CTRL_REG, 0x00);
+ }
+
+ /*
+ * the firmware is not marked as loaded until the firmware
+ * initializes west bridge and a request is sent from west bridge
+ * to the P port processor indicating that west bridge is ready.
+ */
+ return CY_AS_ERROR_SUCCESS;
+}
+
+
+static cy_as_return_status_t
+my_handle_response_get_firmware_version(cy_as_device *dev_p,
+ cy_as_ll_request_response *req_p,
+ cy_as_ll_request_response *reply_p,
+ cy_as_get_firmware_version_data *data_p)
+{
+
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ uint16_t val;
+
+ if (cy_as_ll_request_response__get_code(reply_p)
+ != CY_RESP_FIRMWARE_VERSION) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ goto destroy;
+ }
+
+ data_p->major = cy_as_ll_request_response__get_word(reply_p, 0);
+ data_p->minor = cy_as_ll_request_response__get_word(reply_p, 1);
+ data_p->build = cy_as_ll_request_response__get_word(reply_p, 2);
+ val = cy_as_ll_request_response__get_word(reply_p, 3);
+ data_p->media_type = (uint8_t)(((val >> 8) & 0xFF) | (val & 0xFF));
+ val = cy_as_ll_request_response__get_word(reply_p, 4);
+ data_p->is_debug_mode = (cy_bool)(val & 0xFF);
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+cy_as_return_status_t
+cy_as_misc_get_firmware_version(cy_as_device_handle handle,
+ cy_as_get_firmware_version_data *data,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ cy_bool standby;
+ cy_as_ll_request_response *req_p, *reply_p;
+
+ cy_as_device *dev_p;
+
+ (void)client;
+
+ cy_as_log_debug_message(6, "cy_as_misc_get_firmware_version called");
+
+ /* Make sure we have a valid device */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ /*
+ * make sure antioch is not in standby
+ */
+ ret = cy_as_misc_in_standby(dev_p, &standby);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+ if (standby)
+ return CY_AS_ERROR_IN_STANDBY;
+
+ /* Make sure the Antioch is not in suspend mode. */
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = cy_as_ll_create_request(dev_p, CY_RQT_GET_FIRMWARE_VERSION,
+ CY_RQT_GENERAL_RQT_CONTEXT, 0);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ /*
+ * Reserve space for the reply, the reply data
+ * will not exceed three words
+ */
+ reply_p = cy_as_ll_create_response(dev_p, 5);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (cb == 0) {
+ ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* Request and response are freed in
+ * MyHandleResponseGetFirmwareVersion. */
+ ret = my_handle_response_get_firmware_version(dev_p,
+ req_p, reply_p, data);
+ return ret;
+ } else {
+
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_GETFIRMWAREVERSION, data,
+ dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* The request and response are freed
+ * as part of the MiscFuncCallback */
+ return ret;
+ }
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+static cy_as_return_status_t
+my_handle_response_read_m_c_u_register(cy_as_device *dev_p,
+ cy_as_ll_request_response *req_p,
+ cy_as_ll_request_response *reply_p,
+ uint8_t *data_p)
+{
+
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+
+ if (cy_as_ll_request_response__get_code(reply_p)
+ != CY_RESP_MCU_REGISTER_DATA) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ goto destroy;
+ }
+
+ *data_p = (uint8_t)
+ (cy_as_ll_request_response__get_word(reply_p, 0));
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+static cy_as_return_status_t
+my_handle_response_get_gpio_value(cy_as_device *dev_p,
+ cy_as_ll_request_response *req_p,
+ cy_as_ll_request_response *reply_p,
+ uint8_t *data_p)
+{
+
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+
+ if (cy_as_ll_request_response__get_code(reply_p)
+ != CY_RESP_GPIO_STATE) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ } else
+ *data_p = (uint8_t)
+ (cy_as_ll_request_response__get_word(reply_p, 0));
+
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+
+cy_as_return_status_t cy_as_misc_set_sd_power_polarity(
+ cy_as_device_handle handle,
+ cy_as_misc_signal_polarity polarity,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_ll_request_response *req_p, *reply_p;
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ cy_as_device *dev_p = (cy_as_device *)handle;
+
+ if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE;
+
+ if (!cy_as_device_is_configured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED;
+
+ if (!cy_as_device_is_firmware_loaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE;
+
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ req_p = cy_as_ll_create_request(dev_p, CY_RQT_SDPOLARITY,
+ CY_RQT_GENERAL_RQT_CONTEXT, 1);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ cy_as_ll_request_response__set_word(req_p, 0,
+ (uint16_t)polarity);
+
+ /*
+ * Reserve space for the reply, the reply data will
+ * not exceed one word
+ */
+ reply_p = cy_as_ll_create_response(dev_p, 1);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (cb == 0) {
+ ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ return (my_handle_response_no_data(dev_p, req_p, reply_p));
+ } else {
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_SETSDPOLARITY, 0, dev_p->func_cbs_misc,
+ CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* The request and response are freed
+ * as part of the FuncCallback */
+ return ret;
+ }
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+ return ret;
+}
+
+
+cy_as_return_status_t
+cy_as_misc_read_m_c_u_register(cy_as_device_handle handle,
+ uint16_t address,
+ uint8_t *value,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ cy_as_ll_request_response *req_p, *reply_p;
+
+ cy_as_device *dev_p;
+
+ cy_as_log_debug_message(6, "cy_as_misc_read_m_c_u_register called");
+
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ /* Check whether the firmware supports this command. */
+ if (cy_as_device_is_nand_storage_supported(dev_p))
+ return CY_AS_ERROR_NOT_SUPPORTED;
+
+ /* Make sure the Antioch is not in suspend mode. */
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = cy_as_ll_create_request(dev_p, CY_RQT_READ_MCU_REGISTER,
+ CY_RQT_GENERAL_RQT_CONTEXT, 1);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ cy_as_ll_request_response__set_word(req_p, 0, (uint16_t)address);
+
+ /* Reserve space for the reply, the reply
+ * data will not exceed one word */
+ reply_p = cy_as_ll_create_response(dev_p, 1);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (cb == 0) {
+ ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_MCU_REGISTER_DATA) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ goto destroy;
+ }
+
+ *value = (uint8_t)(cy_as_ll_request_response__get_word
+ (reply_p, 0));
+ } else {
+
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_READMCUREGISTER, value,
+ dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* The request and response are freed
+ * as part of the MiscFuncCallback */
+ return ret;
+ }
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+
+cy_as_return_status_t
+cy_as_misc_write_m_c_u_register(cy_as_device_handle handle,
+ uint16_t address,
+ uint8_t mask,
+ uint8_t value,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ cy_as_ll_request_response *req_p, *reply_p;
+ cy_as_device *dev_p;
+
+ cy_as_log_debug_message(6, "cy_as_misc_write_m_c_u_register called");
+
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ /* Check whether the firmware supports this command. */
+ if (cy_as_device_is_nand_storage_supported(dev_p))
+ return CY_AS_ERROR_NOT_SUPPORTED;
+
+ /* Make sure the Antioch is not in suspend mode. */
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = cy_as_ll_create_request(dev_p, CY_RQT_WRITE_MCU_REGISTER,
+ CY_RQT_GENERAL_RQT_CONTEXT, 2);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ cy_as_ll_request_response__set_word(req_p, 0, (uint16_t)address);
+ cy_as_ll_request_response__set_word(req_p, 1,
+ (uint16_t)((mask << 8) | value));
+
+ /*
+ * Reserve space for the reply, the reply data
+ * will not exceed one word
+ */
+ reply_p = cy_as_ll_create_response(dev_p, 1);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (cb == 0) {
+ ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_SUCCESS_FAILURE) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ goto destroy;
+ }
+
+ ret = cy_as_ll_request_response__get_word(reply_p, 0);
+ } else {
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_WRITEMCUREGISTER, 0,
+ dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /*
+ * The request and response are freed as part of the
+ * MiscFuncCallback
+ */
+ return ret;
+ }
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+cy_as_return_status_t
+my_handle_response_reset(cy_as_device *dev_p,
+ cy_as_ll_request_response *req_p,
+ cy_as_ll_request_response *reply_p,
+ cy_as_reset_type type)
+{
+ uint16_t v;
+
+ (void)req_p;
+ (void)reply_p;
+
+ /*
+ * if the device is in suspend mode, it needs to be woken up
+ * so that the write to the reset control register succeeds.
+ * we need not however wait for the wake up procedure to be
+ * complete.
+ */
+ if (cy_as_device_is_in_suspend_mode(dev_p)) {
+ v = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_CM_WB_CFG_ID);
+ cy_as_hal_sleep(1);
+ }
+
+ if (type == cy_as_reset_hard) {
+ cy_as_misc_cancel_ex_requests(dev_p);
+ cy_as_hal_write_register(dev_p->tag, CY_AS_MEM_RST_CTRL_REG,
+ CY_AS_MEM_RST_CTRL_REG_HARD);
+ cy_as_device_set_unconfigured(dev_p);
+ cy_as_device_set_firmware_not_loaded(dev_p);
+ cy_as_device_set_dma_stopped(dev_p);
+ cy_as_device_set_low_level_stopped(dev_p);
+ cy_as_device_set_intr_stopped(dev_p);
+ cy_as_device_clear_suspend_mode(dev_p);
+ cy_as_usb_cleanup(dev_p);
+ cy_as_storage_cleanup(dev_p);
+
+ /*
+ * wait for a small amount of time to
+ * allow reset to be complete.
+ */
+ cy_as_hal_sleep(100);
+ }
+
+ cy_as_device_clear_reset_pending(dev_p);
+
+ return CY_AS_ERROR_SUCCESS;
+}
+
+cy_as_return_status_t
+cy_as_misc_reset(cy_as_device_handle handle,
+ cy_as_reset_type type,
+ cy_bool flush,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_device *dev_p;
+ cy_as_end_point_number_t i;
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ (void)client;
+ (void)cb;
+
+ cy_as_log_debug_message(6, "cy_as_misc_reset_e_x called");
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ /*
+ * soft reset is not supported until we close on the issues
+ * in the firmware with what needs to happen.
+ */
+ if (type == cy_as_reset_soft)
+ return CY_AS_ERROR_NOT_YET_SUPPORTED;
+
+ cy_as_device_set_reset_pending(dev_p);
+
+ if (flush) {
+ /* Unable to DrainQueues in polling mode */
+ if ((dev_p->storage_cb || dev_p->storage_cb_ms) &&
+ cy_as_hal_is_polling())
+ return CY_AS_ERROR_ASYNC_PENDING;
+
+ /*
+ * shutdown the endpoints so no more traffic can be queued
+ */
+ for (i = 0; i < 15; i++)
+ cy_as_dma_enable_end_point(dev_p, i, cy_false,
+ cy_as_direction_dont_change);
+
+ /*
+ * if we are in normal mode, drain all traffic across all
+ * endpoints to be sure all traffic is flushed. if the
+ * device is suspended, data will not be coming in on any
+ * endpoint and all outstanding DMA operations can be
+ * cancelled.
+ */
+ if (cy_as_device_is_in_suspend_mode(dev_p)) {
+ for (i = 0; i < 15; i++)
+ cy_as_dma_cancel(dev_p, i,
+ CY_AS_ERROR_CANCELED);
+ } else {
+ for (i = 0; i < 15; i++) {
+ if ((i == CY_AS_P2S_WRITE_ENDPOINT) ||
+ (i == CY_AS_P2S_READ_ENDPOINT))
+ cy_as_dma_drain_queue(dev_p, i,
+ cy_false);
+ else
+ cy_as_dma_drain_queue(dev_p, i,
+ cy_true);
+ }
+ }
+ } else {
+ /* No flush was requested, so cancel any outstanding DMAs
+ * so the user callbacks are called as needed
+ */
+ if (cy_as_device_is_storage_async_pending(dev_p)) {
+ for (i = 0; i < 15; i++)
+ cy_as_dma_cancel(dev_p, i,
+ CY_AS_ERROR_CANCELED);
+ }
+ }
+
+ ret = my_handle_response_reset(dev_p, 0, 0, type);
+
+ if (cb)
+ /* Even though no mailbox communication was needed,
+ * issue the callback so the user does not need to
+ * special case their code. */
+ cb((cy_as_device_handle)dev_p, ret, client,
+ CY_FUNCT_CB_MISC_RESET, 0);
+
+ /*
+ * initialize any registers that may have been
+ * changed when the device was reset.
+ */
+ cy_as_hal_init_dev_registers(dev_p->tag, cy_false);
+
+ return ret;
+}
+
+static cy_as_return_status_t
+get_unallocated_resource(cy_as_device *dev_p, cy_as_resource_type resource)
+{
+ uint8_t shift = 0;
+ uint16_t v;
+ cy_as_return_status_t ret = CY_AS_ERROR_NOT_ACQUIRED;
+
+ switch (resource) {
+ case cy_as_bus_u_s_b:
+ shift = 4;
+ break;
+ case cy_as_bus_1:
+ shift = 0;
+ break;
+ case cy_as_bus_0:
+ shift = 2;
+ break;
+ default:
+ cy_as_hal_assert(cy_false);
+ break;
+ }
+
+ /* Get the semaphore value for this resource */
+ v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_P0_RSE_ALLOCATE);
+ v = (v >> shift) & 0x03;
+
+ if (v == 0x03) {
+ ret = CY_AS_ERROR_RESOURCE_ALREADY_OWNED;
+ } else if ((v & 0x01) == 0) {
+ /* The resource is not owned by anyone, we can try to get it */
+ cy_as_hal_write_register(dev_p->tag,
+ CY_AS_MEM_P0_RSE_MASK, (0x03 << shift));
+ v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_P0_RSE_MASK);
+ cy_as_hal_write_register(dev_p->tag,
+ CY_AS_MEM_P0_RSE_ALLOCATE, (0x01 << shift));
+ v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_P0_RSE_MASK);
+
+ v = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_P0_RSE_ALLOCATE);
+ v = (v >> shift) & 0x03;
+ if (v == 0x03)
+ ret = CY_AS_ERROR_SUCCESS;
+ }
+
+ return ret;
+}
+
+static cy_as_return_status_t
+my_handle_response_acquire_resource(cy_as_device *dev_p,
+ cy_as_ll_request_response *req_p,
+ cy_as_ll_request_response *reply_p,
+ cy_as_resource_type *resource)
+{
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_SUCCESS_FAILURE) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ goto destroy;
+ }
+
+ if (ret == CY_AS_ERROR_SUCCESS) {
+ ret = get_unallocated_resource(dev_p, *resource);
+ if (ret != CY_AS_ERROR_NOT_ACQUIRED)
+ ret = CY_AS_ERROR_SUCCESS;
+ }
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+cy_as_return_status_t
+cy_as_misc_acquire_resource(cy_as_device_handle handle,
+ cy_as_resource_type *resource,
+ cy_bool force,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_ll_request_response *req_p, *reply_p;
+ cy_as_return_status_t ret;
+
+ cy_as_device *dev_p;
+
+ (void)client;
+
+ cy_as_log_debug_message(6, "cy_as_misc_acquire_resource called");
+
+ if (*resource != cy_as_bus_u_s_b && *resource !=
+ cy_as_bus_0 && *resource != cy_as_bus_1)
+ return CY_AS_ERROR_INVALID_RESOURCE;
+
+
+ /* Make sure the device is ready to accept the command. */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+
+ ret = get_unallocated_resource(dev_p, *resource);
+
+ /*
+ * make sure that the callback is called if the resource is
+ * successfully acquired at this point.
+ */
+ if ((ret == CY_AS_ERROR_SUCCESS) && (cb != 0))
+ cb(handle, ret, client,
+ CY_FUNCT_CB_MISC_ACQUIRERESOURCE, resource);
+
+ if (ret != CY_AS_ERROR_NOT_ACQUIRED)
+ return ret;
+
+ if (!force)
+ return CY_AS_ERROR_NOT_ACQUIRED;
+
+ /* Create the request to acquire the resource */
+ req_p = cy_as_ll_create_request(dev_p, CY_RQT_ACQUIRE_RESOURCE,
+ CY_RQT_RESOURCE_RQT_CONTEXT, 1);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ cy_as_ll_request_response__set_word(req_p, 0, (uint16_t)(*resource));
+
+ reply_p = cy_as_ll_create_response(dev_p, 1);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (cb == 0) {
+ ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_SUCCESS_FAILURE) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ goto destroy;
+ }
+
+ ret = cy_as_ll_request_response__get_word(reply_p, 0);
+ } else {
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_ACQUIRERESOURCE, resource,
+ dev_p->func_cbs_res, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* The request and response are freed
+ * as part of the MiscFuncCallback */
+ return ret;
+ }
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ if (ret == CY_AS_ERROR_SUCCESS) {
+ ret = get_unallocated_resource(dev_p, *resource);
+ if (ret != CY_AS_ERROR_NOT_ACQUIRED)
+ ret = CY_AS_ERROR_SUCCESS;
+ }
+
+ return ret;
+}
+cy_as_return_status_t
+cy_as_misc_release_resource(cy_as_device_handle handle,
+ cy_as_resource_type resource)
+{
+ uint8_t shift = 0;
+ uint16_t v;
+
+ cy_as_device *dev_p;
+
+ cy_as_log_debug_message(6, "cy_as_misc_release_resource called");
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ if (resource != cy_as_bus_u_s_b && resource !=
+ cy_as_bus_0 && resource != cy_as_bus_1)
+ return CY_AS_ERROR_INVALID_RESOURCE;
+
+ switch (resource) {
+ case cy_as_bus_u_s_b:
+ shift = 4;
+ break;
+ case cy_as_bus_1:
+ shift = 0;
+ break;
+ case cy_as_bus_0:
+ shift = 2;
+ break;
+ default:
+ cy_as_hal_assert(cy_false);
+ break;
+ }
+
+ /* Get the semaphore value for this resource */
+ v = (cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_P0_RSE_ALLOCATE) >> shift) & 0x03;
+ if (v == 0 || v == 1 || v == 2)
+ return CY_AS_ERROR_RESOURCE_NOT_OWNED;
+
+ cy_as_hal_write_register(dev_p->tag,
+ CY_AS_MEM_P0_RSE_MASK, (0x03 << shift));
+ cy_as_hal_write_register(dev_p->tag,
+ CY_AS_MEM_P0_RSE_ALLOCATE, (0x02 << shift));
+ cy_as_hal_write_register(dev_p->tag,
+ CY_AS_MEM_P0_RSE_MASK, 0);
+
+ return CY_AS_ERROR_SUCCESS;
+}
+
+cy_as_return_status_t
+cy_as_misc_set_trace_level(cy_as_device_handle handle,
+ uint8_t level,
+ cy_as_bus_number_t bus,
+ uint32_t device,
+ uint32_t unit,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_ll_request_response *req_p, *reply_p;
+ cy_as_return_status_t ret;
+ cy_as_device *dev_p;
+
+ cy_as_log_debug_message(6, "cy_as_misc_set_trace_level called");
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ if (bus < 0 || bus >= CY_AS_MAX_BUSES)
+ return CY_AS_ERROR_NO_SUCH_BUS;
+
+ if (device >= CY_AS_MAX_STORAGE_DEVICES)
+ return CY_AS_ERROR_NO_SUCH_DEVICE;
+
+ if (unit > 255)
+ return CY_AS_ERROR_NO_SUCH_UNIT;
+
+ if (level >= CYAS_FW_TRACE_MAX_LEVEL)
+ return CY_AS_ERROR_INVALID_TRACE_LEVEL;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = cy_as_ll_create_request(dev_p, CY_RQT_SET_TRACE_LEVEL,
+ CY_RQT_GENERAL_RQT_CONTEXT, 2);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ cy_as_ll_request_response__set_word(req_p, 0,
+ (uint16_t)level);
+ cy_as_ll_request_response__set_word(req_p, 1,
+ (uint16_t)((bus << 12) | (device << 8) | (unit)));
+
+ /*
+ * Reserve space for the reply, the reply data will not
+ * exceed three words
+ */
+ reply_p = cy_as_ll_create_response(dev_p, 2);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (cb == 0) {
+ ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_SUCCESS_FAILURE) {
+ ret = CY_AS_ERROR_NOT_SUPPORTED;
+ goto destroy;
+ }
+
+ ret = cy_as_ll_request_response__get_word(reply_p, 0);
+ } else {
+
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_SETTRACELEVEL, 0, dev_p->func_cbs_misc,
+ CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* The request and response are freed as part of the
+ * MiscFuncCallback */
+ return ret;
+ }
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+cy_as_return_status_t
+cy_as_misc_heart_beat_control(cy_as_device_handle handle,
+ cy_bool enable,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_ll_request_response *req_p, *reply_p;
+ cy_as_return_status_t ret;
+ cy_as_device *dev_p;
+
+ cy_as_log_debug_message(6, "cy_as_misc_heart_beat_control called");
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = cy_as_ll_create_request(dev_p, CY_RQT_CONTROL_ANTIOCH_HEARTBEAT,
+ CY_RQT_GENERAL_RQT_CONTEXT, 1);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ cy_as_ll_request_response__set_word(req_p, 0, (uint16_t)enable);
+
+ /* Reserve space for the reply, the reply
+ * data will not exceed one word */
+ reply_p = cy_as_ll_create_response(dev_p, 1);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (cb == 0) {
+ ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_SUCCESS_FAILURE) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ goto destroy;
+ }
+
+ ret = cy_as_ll_request_response__get_word(reply_p, 0);
+ } else {
+
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_HEARTBEATCONTROL, 0,
+ dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* The request and response are freed as part of the
+ * MiscFuncCallback */
+ return ret;
+ }
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+static cy_as_return_status_t
+my_set_sd_clock_freq(
+ cy_as_device *dev_p,
+ uint8_t card_type,
+ uint8_t setting,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ cy_as_ll_request_response *req_p, *reply_p;
+
+ if (cy_as_device_is_in_callback(dev_p) && (cb == 0))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK;
+
+ req_p = cy_as_ll_create_request(dev_p, CY_RQT_SET_SD_CLOCK_FREQ,
+ CY_RQT_GENERAL_RQT_CONTEXT, 1);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ cy_as_ll_request_response__set_word(req_p, 0,
+ (uint16_t)((card_type << 8) | setting));
+
+ /* Reserve space for the reply, which will not exceed one word. */
+ reply_p = cy_as_ll_create_response(dev_p, 1);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (cb == 0) {
+ ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_SUCCESS_FAILURE) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ goto destroy;
+ }
+
+ ret = cy_as_ll_request_response__get_word(reply_p, 0);
+ } else {
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_SETSDFREQ, 0, dev_p->func_cbs_misc,
+ CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* The request and response are freed as part of the
+ * MiscFuncCallback */
+ return ret;
+ }
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+cy_as_return_status_t
+cy_as_misc_set_low_speed_sd_freq(
+ cy_as_device_handle handle,
+ cy_as_low_speed_sd_freq setting,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_device *dev_p;
+
+ cy_as_log_debug_message(6, "cy_as_misc_set_low_speed_sd_freq called");
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ if ((setting != CY_AS_SD_DEFAULT_FREQ) &&
+ (setting != CY_AS_SD_RATED_FREQ))
+ return CY_AS_ERROR_INVALID_PARAMETER;
+
+ return my_set_sd_clock_freq(dev_p, 0, (uint8_t)setting, cb, client);
+}
+
+cy_as_return_status_t
+cy_as_misc_set_high_speed_sd_freq(
+ cy_as_device_handle handle,
+ cy_as_high_speed_sd_freq setting,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_device *dev_p;
+
+ cy_as_log_debug_message(6, "cy_as_misc_set_high_speed_sd_freq called");
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ if ((setting != CY_AS_HS_SD_FREQ_24) &&
+ (setting != CY_AS_HS_SD_FREQ_48))
+ return CY_AS_ERROR_INVALID_PARAMETER;
+
+ return my_set_sd_clock_freq(dev_p, 1, (uint8_t)setting, cb, client);
+}
+
+cy_as_return_status_t
+cy_as_misc_get_gpio_value(cy_as_device_handle handle,
+ cy_as_misc_gpio pin,
+ uint8_t *value,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ cy_as_ll_request_response *req_p, *reply_p;
+ cy_as_device *dev_p;
+ uint16_t v;
+
+ cy_as_log_debug_message(6, "cy_as_misc_get_gpio_value called");
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ /* If the pin specified is UVALID, there is no need
+ * for firmware to be loaded. */
+ if (pin == cy_as_misc_gpio_U_valid) {
+ v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_PMU_UPDATE);
+ *value = (uint8_t)(v & CY_AS_MEM_PMU_UPDATE_UVALID);
+
+ if (cb != 0)
+ cb(dev_p, ret, client,
+ CY_FUNCT_CB_MISC_GETGPIOVALUE, value);
+
+ return ret;
+ }
+
+ /* Check whether the firmware supports this command. */
+ if (cy_as_device_is_nand_storage_supported(dev_p))
+ return CY_AS_ERROR_NOT_SUPPORTED;
+
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ /* Make sure the pin selected is valid */
+ if ((pin != cy_as_misc_gpio_1) && (pin != cy_as_misc_gpio_0))
+ return CY_AS_ERROR_INVALID_PARAMETER;
+
+ req_p = cy_as_ll_create_request(dev_p, CY_RQT_GET_GPIO_STATE,
+ CY_RQT_GENERAL_RQT_CONTEXT, 1);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ cy_as_ll_request_response__set_word(req_p, 0, ((uint8_t)pin << 8));
+
+ /* Reserve space for the reply, which will not exceed one word. */
+ reply_p = cy_as_ll_create_response(dev_p, 1);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (cb == 0) {
+ ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_GPIO_STATE) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ goto destroy;
+ }
+
+ *value = (uint8_t)
+ cy_as_ll_request_response__get_word(reply_p, 0);
+ } else {
+
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_GETGPIOVALUE, value,
+ dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* The request and response are freed as part of the
+ * MiscFuncCallback */
+ return ret;
+ }
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+
+cy_as_return_status_t
+cy_as_misc_set_gpio_value(cy_as_device_handle handle,
+ cy_as_misc_gpio pin,
+ uint8_t value,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ cy_as_ll_request_response *req_p, *reply_p;
+ cy_as_device *dev_p;
+ uint16_t v;
+
+ cy_as_log_debug_message(6, "cy_as_misc_set_gpio_value called");
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ /* If the pin specified is UVALID, there is
+ * no need for firmware to be loaded. */
+ if (pin == cy_as_misc_gpio_U_valid) {
+ v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_PMU_UPDATE);
+ if (value)
+ cy_as_hal_write_register(dev_p->tag,
+ CY_AS_MEM_PMU_UPDATE,
+ (v | CY_AS_MEM_PMU_UPDATE_UVALID));
+ else
+ cy_as_hal_write_register(dev_p->tag,
+ CY_AS_MEM_PMU_UPDATE,
+ (v & ~CY_AS_MEM_PMU_UPDATE_UVALID));
+
+ if (cb != 0)
+ cb(dev_p, ret, client,
+ CY_FUNCT_CB_MISC_SETGPIOVALUE, 0);
+ return ret;
+ }
+
+ /* Check whether the firmware supports this command. */
+ if (cy_as_device_is_nand_storage_supported(dev_p))
+ return CY_AS_ERROR_NOT_SUPPORTED;
+
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ /* Make sure the pin selected is valid */
+ if ((pin < cy_as_misc_gpio_0) || (pin > cy_as_misc_gpio_U_valid))
+ return CY_AS_ERROR_INVALID_PARAMETER;
+
+ /* Create and initialize the low level request to the firmware. */
+ req_p = cy_as_ll_create_request(dev_p, CY_RQT_SET_GPIO_STATE,
+ CY_RQT_GENERAL_RQT_CONTEXT, 1);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ v = (uint16_t)(((uint8_t)pin << 8) | (value > 0));
+ cy_as_ll_request_response__set_word(req_p, 0, v);
+
+ /* Reserve space for the reply, which will not exceed one word. */
+ reply_p = cy_as_ll_create_response(dev_p, 1);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (cb == 0) {
+ ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_SUCCESS_FAILURE) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ goto destroy;
+ }
+
+ ret = cy_as_ll_request_response__get_word(reply_p, 0);
+ } else {
+
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_SETGPIOVALUE, 0,
+ dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* The request and response are freed as part of the
+ * MiscFuncCallback */
+ return ret;
+ }
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+static cy_as_return_status_t
+my_enter_standby(cy_as_device *dev_p, cy_bool pin)
+{
+ cy_as_misc_cancel_ex_requests(dev_p);
+
+ /* Save the current values in the critical P-port
+ * registers, where necessary. */
+ cy_as_hal_read_regs_before_standby(dev_p->tag);
+
+ if (pin) {
+ if (cy_as_hal_set_wakeup_pin(dev_p->tag, cy_false))
+ cy_as_device_set_pin_standby(dev_p);
+ else
+ return CY_AS_ERROR_SETTING_WAKEUP_PIN;
+ } else {
+ /*
+ * put antioch in the standby mode
+ */
+ cy_as_hal_write_register(dev_p->tag,
+ CY_AS_MEM_PWR_MAGT_STAT, 0x02);
+ cy_as_device_set_register_standby(dev_p);
+ }
+
+ /*
+ * when the antioch comes out of standby, we have to wait until
+ * the firmware initialization completes before sending other
+ * requests down.
+ */
+ cy_as_device_set_firmware_not_loaded(dev_p);
+
+ /*
+ * keep west bridge interrupt disabled until the device is being woken
+ * up from standby.
+ */
+ dev_p->stby_int_mask = cy_as_hal_disable_interrupts();
+
+ return CY_AS_ERROR_SUCCESS;
+}
+
+static cy_as_return_status_t
+my_handle_response_enter_standby(cy_as_device *dev_p,
+ cy_as_ll_request_response *req_p,
+ cy_as_ll_request_response *reply_p,
+ cy_bool pin)
+{
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_SUCCESS_FAILURE) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ goto destroy;
+ }
+
+ ret = cy_as_ll_request_response__get_word(reply_p, 0);
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+
+ ret = my_enter_standby(dev_p, pin);
+
+ return ret;
+}
+
+cy_as_return_status_t
+cy_as_misc_enter_standby(cy_as_device_handle handle,
+ cy_bool pin,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_device *dev_p;
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ cy_as_ll_request_response *req_p, *reply_p;
+ cy_bool standby;
+
+ cy_as_log_debug_message(6, "cy_as_misc_enter_standby called");
+
+ /* Make sure we have a valid device */
+ dev_p = (cy_as_device *)handle;
+ if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE;
+
+ /*
+ * if we already are in standby, do not do it again and let the
+ * user know via the error return.
+ */
+ ret = cy_as_misc_in_standby(handle, &standby);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+
+ if (standby == cy_true)
+ return CY_AS_ERROR_ALREADY_STANDBY;
+
+ /*
+ * if the user wants to transition from suspend mode to standby mode,
+ * the device needs to be woken up so that it can complete all pending
+ * operations.
+ */
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ cy_as_misc_leave_suspend(dev_p, 0, 0);
+
+ if (dev_p->usb_count) {
+ /*
+ * we do not allow west bridge to go into standby mode when the
+ * USB stack is initialized. you must stop the USB stack in
+ * order to enter standby mode.
+ */
+ return CY_AS_ERROR_USB_RUNNING;
+ }
+
+ /*
+ * if the storage stack is not running, the device can directly be
+ * put into sleep mode. otherwise, the firmware needs to be signaled
+ * to prepare for going into sleep mode.
+ */
+ if (dev_p->storage_count) {
+ /*
+ * if there are async storage operations pending,
+ * make one attempt to complete them.
+ */
+ if (cy_as_device_is_storage_async_pending(dev_p)) {
+ /* DrainQueue will not work in polling mode */
+ if (cy_as_hal_is_polling())
+ return CY_AS_ERROR_ASYNC_PENDING;
+
+ cy_as_dma_drain_queue(dev_p,
+ CY_AS_P2S_READ_ENDPOINT, cy_false);
+ cy_as_dma_drain_queue(dev_p,
+ CY_AS_P2S_WRITE_ENDPOINT, cy_false);
+
+ /*
+ * if more storage operations were queued
+ * at this stage, return an error.
+ */
+ if (cy_as_device_is_storage_async_pending(dev_p))
+ return CY_AS_ERROR_ASYNC_PENDING;
+ }
+
+ req_p = cy_as_ll_create_request(dev_p,
+ CY_RQT_PREPARE_FOR_STANDBY,
+ CY_RQT_GENERAL_RQT_CONTEXT, 1);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ reply_p = cy_as_ll_create_response(dev_p, 1);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (!cb) {
+ ret = cy_as_ll_send_request_wait_reply(dev_p,
+ req_p, reply_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* The request and response are freed
+ * in the HandleResponse */
+ return my_handle_response_enter_standby(dev_p,
+ req_p, reply_p, pin);
+
+ } else {
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_ENTERSTANDBY, (void *)pin,
+ dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* The request and response are freed
+ * as part of the MiscFuncCallback */
+ return ret;
+ }
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+ } else {
+ ret = my_enter_standby(dev_p, pin);
+ if (cb)
+ /* Even though no mailbox communication was
+ * needed, issue the callback so the user
+ * does not need to special case their code. */
+ cb((cy_as_device_handle)dev_p, ret, client,
+ CY_FUNCT_CB_MISC_ENTERSTANDBY, 0);
+ }
+
+ return ret;
+}
+
+cy_as_return_status_t
+cy_as_misc_enter_standby_e_x_u(cy_as_device_handle handle,
+ cy_bool pin,
+ cy_bool uvalid_special,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_device *dev_p;
+
+ dev_p = (cy_as_device *)handle;
+ if (uvalid_special)
+ cy_as_hal_write_register(dev_p->tag, 0xc5, 0x4);
+
+ return cy_as_misc_enter_standby(handle, pin, cb, client);
+}
+
+cy_as_return_status_t
+cy_as_misc_leave_standby(cy_as_device_handle handle,
+ cy_as_resource_type resource)
+{
+ cy_as_device *dev_p;
+ uint16_t v;
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ uint32_t count = 8;
+ uint8_t retry = 1;
+
+ cy_as_log_debug_message(6, "cy_as_misc_leave_standby called");
+ (void)resource;
+
+ /* Make sure we have a valid device */
+ dev_p = (cy_as_device *)handle;
+ if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE;
+
+ if (cy_as_device_is_register_standby(dev_p)) {
+ /*
+ * set a flag to indicate that the west bridge is waking
+ * up from standby.
+ */
+ cy_as_device_set_waking(dev_p);
+
+ /*
+ * the initial read will not succeed, but will just wake
+ * the west bridge device from standby. successive reads
+ * should succeed and in that way we know west bridge is awake.
+ */
+ v = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_CM_WB_CFG_ID);
+
+ do {
+ /*
+ * we have initiated the operation to leave standby, now
+ * we need to wait at least N ms before trying to access
+ * the west bridge device to insure the PLLs have locked
+ * and we can talk to the device.
+ */
+ if (cy_as_device_is_crystal(dev_p))
+ cy_as_hal_sleep(
+ CY_AS_LEAVE_STANDBY_DELAY_CRYSTAL);
+ else
+ cy_as_hal_sleep(
+ CY_AS_LEAVE_STANDBY_DELAY_CLOCK);
+ v = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_CM_WB_CFG_ID);
+
+ /*
+ * if the P-SPI interface mode is in use, there may be a
+ * need to re-synchronise the serial clock used for
+ * astoria access.
+ */
+ if (!is_valid_silicon_id(v)) {
+ if (cy_as_hal_sync_device_clocks(dev_p->tag) !=
+ cy_true) {
+ cy_as_hal_enable_interrupts(
+ dev_p->stby_int_mask);
+ return CY_AS_ERROR_TIMEOUT;
+ }
+ }
+ } while (!is_valid_silicon_id(v) && count-- > 0);
+
+ /*
+ * if we tried to read the register and could not,
+ * return a timeout
+ */
+ if (count == 0) {
+ cy_as_hal_enable_interrupts(
+ dev_p->stby_int_mask);
+ return CY_AS_ERROR_TIMEOUT;
+ }
+
+ /*
+ * the standby flag is cleared here, after the action to
+ * exit standby has been taken. the wait for firmware
+ * initialization, is ensured by marking the firmware as
+ * not loaded until the init event is received.
+ */
+ cy_as_device_clear_register_standby(dev_p);
+
+ /*
+ * initialize any registers that may have been changed
+ * while the device was in standby mode.
+ */
+ cy_as_hal_init_dev_registers(dev_p->tag, cy_true);
+ } else if (cy_as_device_is_pin_standby(dev_p)) {
+ /*
+ * set a flag to indicate that the west bridge is waking
+ * up from standby.
+ */
+ cy_as_device_set_waking(dev_p);
+
+try_wakeup_again:
+ /*
+ * try to set the wakeup pin, if this fails in the HAL
+ * layer, return this failure to the user.
+ */
+ if (!cy_as_hal_set_wakeup_pin(dev_p->tag, cy_true)) {
+ cy_as_hal_enable_interrupts(dev_p->stby_int_mask);
+ return CY_AS_ERROR_SETTING_WAKEUP_PIN;
+ }
+
+ /*
+ * we have initiated the operation to leave standby, now
+ * we need to wait at least N ms before trying to access
+ * the west bridge device to insure the PL_ls have locked
+ * and we can talk to the device.
+ */
+ if (cy_as_device_is_crystal(dev_p))
+ cy_as_hal_sleep(CY_AS_LEAVE_STANDBY_DELAY_CRYSTAL);
+ else
+ cy_as_hal_sleep(CY_AS_LEAVE_STANDBY_DELAY_CLOCK);
+
+ /*
+ * initialize any registers that may have been changed
+ * while the device was in standby mode.
+ */
+ cy_as_hal_init_dev_registers(dev_p->tag, cy_true);
+
+ /*
+ * the standby flag is cleared here, after the action to
+ * exit standby has been taken. the wait for firmware
+ * initialization, is ensured by marking the firmware as
+ * not loaded until the init event is received.
+ */
+ cy_as_device_clear_pin_standby(dev_p);
+ } else {
+ return CY_AS_ERROR_NOT_IN_STANDBY;
+ }
+
+ /*
+ * the west bridge interrupt can be enabled now.
+ */
+ cy_as_hal_enable_interrupts(dev_p->stby_int_mask);
+
+ /*
+ * release the west bridge micro-_controller from reset,
+ * so that firmware initialization can complete. the attempt
+ * to release antioch reset is made upto 8 times.
+ */
+ v = 0x03;
+ count = 0x08;
+ while ((v & 0x03) && (count)) {
+ cy_as_hal_write_register(dev_p->tag,
+ CY_AS_MEM_RST_CTRL_REG, 0x00);
+ v = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_RST_CTRL_REG);
+ count--;
+ }
+
+ if (v & 0x03) {
+ cy_as_hal_print_message("failed to clear antioch reset\n");
+ return CY_AS_ERROR_TIMEOUT;
+ }
+
+ /*
+ * if the wake-up pin is being used, wait here to make
+ * sure that the wake-up event is received within a
+ * reasonable delay. otherwise, toggle the wake-up pin
+ * again in an attempt to start the firmware properly.
+ */
+ if (retry) {
+ count = 10;
+ while (count) {
+ /* If the wake-up event has been received,
+ * we can return. */
+ if (cy_as_device_is_firmware_loaded(dev_p))
+ break;
+ /* If we are in polling mode, the interrupt may
+ * not have been serviced as yet. read the
+ * interrupt status register. if a pending mailbox
+ * interrupt is seen, we can assume that the
+ * wake-up event will be received soon. */
+ v = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_P0_INTR_REG);
+ if (v & CY_AS_MEM_P0_INTR_REG_MBINT)
+ break;
+
+ cy_as_hal_sleep(10);
+ count--;
+ }
+
+ if (!count) {
+ retry = 0;
+ dev_p->stby_int_mask = cy_as_hal_disable_interrupts();
+ cy_as_hal_set_wakeup_pin(dev_p->tag, cy_false);
+ cy_as_hal_sleep(10);
+ goto try_wakeup_again;
+ }
+ }
+
+ return ret;
+}
+
+cy_as_return_status_t
+cy_as_misc_register_callback(
+ /* Handle to the West Bridge device */
+ cy_as_device_handle handle,
+ /* The function to call */
+ cy_as_misc_event_callback callback
+ )
+{
+ cy_as_device *dev_p;
+
+ cy_as_log_debug_message(6, "cy_as_misc_register_callback called");
+
+ /* Make sure we have a valid device */
+ dev_p = (cy_as_device *)handle;
+ if (!dev_p || (dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE;
+
+ dev_p->misc_event_cb = callback;
+ return CY_AS_ERROR_SUCCESS;
+}
+
+cy_as_return_status_t
+cy_as_misc_storage_changed(cy_as_device_handle handle,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_device *dev_p;
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ cy_bool standby;
+ cy_as_ll_request_response *req_p, *reply_p;
+
+ cy_as_log_debug_message(6, "cy_as_misc_storage_changed called");
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ /*
+ * make sure antioch is not in standby
+ */
+ ret = cy_as_misc_in_standby(dev_p, &standby);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+
+ if (standby)
+ return CY_AS_ERROR_IN_STANDBY;
+
+ /*
+ * make sure westbridge is not in suspend mode.
+ */
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = cy_as_ll_create_request(dev_p, CY_RQT_STORAGE_MEDIA_CHANGED,
+ CY_RQT_GENERAL_RQT_CONTEXT, 0);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ /* Reserve space for the reply, the reply data will
+ * not exceed one word */
+ reply_p = cy_as_ll_create_response(dev_p, 1);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (cb == 0) {
+ ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_SUCCESS_FAILURE) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ goto destroy;
+ }
+
+ ret = cy_as_ll_request_response__get_word(reply_p, 0);
+ } else {
+
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_STORAGECHANGED, 0,
+ dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* The request and response are freed as part of the
+ * MiscFuncCallback */
+ return ret;
+ }
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+
+cy_as_return_status_t
+cy_as_misc_enter_suspend(
+ cy_as_device_handle handle,
+ cy_bool usb_wakeup_en,
+ cy_bool gpio_wakeup_en,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_device *dev_p;
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ cy_bool standby;
+ cy_as_ll_request_response *req_p, *reply_p;
+ uint16_t value;
+ uint32_t int_state;
+
+ cy_as_log_debug_message(6, "cy_as_misc_enter_suspend called");
+
+ /*
+ * basic sanity checks to ensure that the device is initialised.
+ */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ /*
+ * make sure west bridge is not already in standby
+ */
+ cy_as_misc_in_standby(dev_p, &standby);
+ if (standby)
+ return CY_AS_ERROR_IN_STANDBY;
+
+ /*
+ * make sure that the device is not already in suspend mode.
+ */
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ /*
+ * make sure there is no active USB connection.
+ */
+ if ((cy_as_device_is_usb_connected(dev_p)) && (dev_p->usb_last_event
+ != cy_as_event_usb_suspend))
+ return CY_AS_ERROR_USB_CONNECTED;
+
+ /*
+ * make sure that there are no async requests at this point in time.
+ */
+ int_state = cy_as_hal_disable_interrupts();
+ if ((dev_p->func_cbs_misc->count) || (dev_p->func_cbs_res->count) ||
+ (dev_p->func_cbs_stor->count) || (dev_p->func_cbs_usb->count)) {
+ cy_as_hal_enable_interrupts(int_state);
+ return CY_AS_ERROR_ASYNC_PENDING;
+ }
+ cy_as_hal_enable_interrupts(int_state);
+
+ /* Create the request to send to the Antioch device */
+ req_p = cy_as_ll_create_request(dev_p, CY_RQT_ENTER_SUSPEND_MODE,
+ CY_RQT_GENERAL_RQT_CONTEXT, 1);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ /* Reserve space for the reply, the reply data will not
+ * exceed one word */
+ reply_p = cy_as_ll_create_response(dev_p, 1);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ /* Wakeup control flags. */
+ value = 0x0001;
+ if (usb_wakeup_en)
+ value |= 0x04;
+ if (gpio_wakeup_en)
+ value |= 0x02;
+ cy_as_ll_request_response__set_word(req_p, 0, value);
+
+ if (cb != 0) {
+
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_ENTERSUSPEND,
+ 0, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p,
+ cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ return CY_AS_ERROR_SUCCESS;
+ } else {
+ ret = cy_as_ll_send_request_wait_reply(dev_p, req_p, reply_p);
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_SUCCESS_FAILURE)
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ else
+ ret = cy_as_ll_request_response__get_word(reply_p, 0);
+ }
+
+destroy:
+ if (ret == CY_AS_ERROR_SUCCESS)
+ cy_as_device_set_suspend_mode(dev_p);
+
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+cy_as_return_status_t
+cy_as_misc_leave_suspend(
+ cy_as_device_handle handle,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_device *dev_p;
+ uint16_t v, count;
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+
+ cy_as_log_debug_message(6, "cy_as_misc_leave_suspend called");
+
+ /* Make sure we have a valid device */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ /* Make sure we are in suspend mode. */
+ if (cy_as_device_is_in_suspend_mode(dev_p)) {
+ if (cb) {
+ cy_as_func_c_b_node *cbnode =
+ cy_as_create_func_c_b_node_data(cb, client,
+ CY_FUNCT_CB_MISC_LEAVESUSPEND, 0);
+ if (cbnode == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ cy_as_insert_c_b_node(dev_p->func_cbs_misc, cbnode);
+ }
+
+ /*
+ * do a read from the ID register so that the CE assertion
+ * will wake west bridge. the read is repeated until the
+ * read comes back with valid data.
+ */
+ count = 8;
+
+ v = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_CM_WB_CFG_ID);
+
+ while (!is_valid_silicon_id(v) && count-- > 0) {
+ cy_as_hal_sleep(CY_AS_LEAVE_STANDBY_DELAY_CLOCK);
+ v = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_CM_WB_CFG_ID);
+ }
+
+ /*
+ * if we tried to read the register and could not,
+ * return a timeout
+ */
+ if (count == 0)
+ return CY_AS_ERROR_TIMEOUT;
+ } else
+ return CY_AS_ERROR_NOT_IN_SUSPEND;
+
+ if (cb == 0) {
+ /*
+ * wait until the in suspend mode flag is cleared.
+ */
+ count = 20;
+ while ((cy_as_device_is_in_suspend_mode(dev_p))
+ && (count--)) {
+ cy_as_hal_sleep(CY_AS_LEAVE_STANDBY_DELAY_CLOCK);
+ }
+
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ ret = CY_AS_ERROR_TIMEOUT;
+ }
+
+ return ret;
+}
+
+cy_as_return_status_t
+cy_as_misc_reserve_l_n_a_boot_area(cy_as_device_handle handle,
+ uint8_t numzones,
+ cy_as_function_callback cb,
+ uint32_t client)
+{
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ cy_bool standby;
+ cy_as_ll_request_response *req_p, *reply_p;
+
+ cy_as_device *dev_p;
+
+ (void)client;
+
+ cy_as_log_debug_message(6, "cy_as_misc_switch_pnand_mode called");
+
+ /* Make sure we have a valid device */
+ dev_p = (cy_as_device *)handle;
+ cy_as_check_device_ready(dev_p);
+
+ /*
+ * make sure antioch is not in standby
+ */
+ ret = cy_as_misc_in_standby(dev_p, &standby);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+ if (standby)
+ return CY_AS_ERROR_IN_STANDBY;
+
+ /* Make sure the Antioch is not in suspend mode. */
+ if (cy_as_device_is_in_suspend_mode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = cy_as_ll_create_request(dev_p,
+ CY_RQT_RESERVE_LNA_BOOT_AREA,
+ CY_RQT_GENERAL_RQT_CONTEXT, 1);
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ cy_as_ll_request_response__set_word(req_p,
+ 0, (uint16_t)numzones);
+
+ /* Reserve space for the reply, the reply data will not
+ * exceed one word */
+ reply_p = cy_as_ll_create_response(dev_p, 1);
+ if (reply_p == 0) {
+ cy_as_ll_destroy_request(dev_p, req_p);
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (cb == 0) {
+ ret = cy_as_ll_send_request_wait_reply(dev_p,
+ req_p, reply_p);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ if (cy_as_ll_request_response__get_code(reply_p) !=
+ CY_RESP_SUCCESS_FAILURE) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ goto destroy;
+ }
+
+ ret = cy_as_ll_request_response__get_word(reply_p, 0);
+ } else {
+
+ ret = cy_as_misc_send_request(dev_p, cb, client,
+ CY_FUNCT_CB_MISC_RESERVELNABOOTAREA,
+ 0, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, cy_as_misc_func_callback);
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy;
+
+ /* The request and response are freed as part of the
+ * MiscFuncCallback */
+ return ret;
+ }
+
+destroy:
+ cy_as_ll_destroy_request(dev_p, req_p);
+ cy_as_ll_destroy_response(dev_p, reply_p);
+
+ return ret;
+}
+
+cy_as_func_c_b_node*
+cy_as_create_func_c_b_node_data(cy_as_function_callback cb,
+ uint32_t client,
+ cy_as_funct_c_b_type type,
+ void *data)
+{
+ uint32_t state = cy_as_hal_disable_interrupts();
+ cy_as_func_c_b_node *node = cy_as_hal_c_b_alloc(
+ sizeof(cy_as_func_c_b_node));
+ cy_as_hal_enable_interrupts(state);
+ if (node != 0) {
+ node->node_type = CYAS_FUNC_CB;
+ node->cb_p = cb;
+ node->client_data = client;
+ node->data_type = type;
+ if (data != 0)
+ node->data_type |= CY_FUNCT_CB_DATA;
+ else
+ node->data_type |= CY_FUNCT_CB_NODATA;
+ node->data = data;
+ node->next_p = 0;
+ }
+ return node;
+}
+
+cy_as_func_c_b_node*
+cy_as_create_func_c_b_node(cy_as_function_callback cb,
+ uint32_t client)
+{
+ return cy_as_create_func_c_b_node_data(cb, client,
+ CY_FUNCT_CB_NODATA, 0);
+}
+
+void
+cy_as_destroy_func_c_b_node(cy_as_func_c_b_node *node)
+{
+ uint32_t state;
+
+ node->node_type = CYAS_INVALID;
+ state = cy_as_hal_disable_interrupts();
+ cy_as_hal_c_b_free(node);
+ cy_as_hal_enable_interrupts(state);
+}
+
+cy_as_usb_func_c_b_node*
+cy_as_create_usb_func_c_b_node(
+ cy_as_usb_function_callback cb, uint32_t client)
+{
+ uint32_t state = cy_as_hal_disable_interrupts();
+ cy_as_usb_func_c_b_node *node = cy_as_hal_c_b_alloc(
+ sizeof(cy_as_usb_func_c_b_node));
+ cy_as_hal_enable_interrupts(state);
+ if (node != 0) {
+ node->type = CYAS_USB_FUNC_CB;
+ node->cb_p = cb;
+ node->client_data = client;
+ node->next_p = 0;
+ }
+ return node;
+}
+
+void
+cy_as_destroy_usb_func_c_b_node(cy_as_usb_func_c_b_node *node)
+{
+ uint32_t state;
+
+ node->type = CYAS_INVALID;
+ state = cy_as_hal_disable_interrupts();
+ cy_as_hal_c_b_free(node);
+ cy_as_hal_enable_interrupts(state);
+}
+
+cy_as_usb_io_c_b_node*
+cy_as_create_usb_io_c_b_node(cy_as_usb_io_callback cb)
+{
+ uint32_t state = cy_as_hal_disable_interrupts();
+ cy_as_usb_io_c_b_node *node = cy_as_hal_c_b_alloc(
+ sizeof(cy_as_usb_io_c_b_node));
+ cy_as_hal_enable_interrupts(state);
+ if (node != 0) {
+ node->type = CYAS_USB_IO_CB;
+ node->cb_p = cb;
+ node->next_p = 0;
+ }
+ return node;
+}
+
+void
+cy_as_destroy_usb_io_c_b_node(cy_as_usb_io_c_b_node *node)
+{
+ uint32_t state;
+
+ node->type = CYAS_INVALID;
+
+ state = cy_as_hal_disable_interrupts();
+ cy_as_hal_c_b_free(node);
+ cy_as_hal_enable_interrupts(state);
+}
+
+cy_as_storage_io_c_b_node*
+cy_as_create_storage_io_c_b_node(cy_as_storage_callback cb,
+ cy_as_media_type media, uint32_t device_index,
+ uint32_t unit, uint32_t block_addr, cy_as_oper_type oper,
+ cy_as_ll_request_response *req_p,
+ cy_as_ll_request_response *reply_p)
+{
+ uint32_t state = cy_as_hal_disable_interrupts();
+ cy_as_storage_io_c_b_node *node = cy_as_hal_c_b_alloc(
+ sizeof(cy_as_storage_io_c_b_node));
+ cy_as_hal_enable_interrupts(state);
+ if (node != 0) {
+ node->type = CYAS_STORAGE_IO_CB;
+ node->cb_p = cb;
+ node->media = media;
+ node->device_index = device_index;
+ node->unit = unit;
+ node->block_addr = block_addr;
+ node->oper = oper;
+ node->req_p = req_p;
+ node->reply_p = reply_p;
+ node->next_p = 0;
+ }
+ return node;
+}
+
+void
+cy_as_destroy_storage_io_c_b_node(cy_as_storage_io_c_b_node *node)
+{
+ uint32_t state;
+ node->type = CYAS_INVALID;
+ state = cy_as_hal_disable_interrupts();
+ cy_as_hal_c_b_free(node);
+ cy_as_hal_enable_interrupts(state);
+}
+
+cy_as_c_b_queue *
+cy_as_create_c_b_queue(cy_as_c_b_node_type type)
+{
+ uint32_t state = cy_as_hal_disable_interrupts();
+ cy_as_c_b_queue *queue = cy_as_hal_c_b_alloc(
+ sizeof(cy_as_c_b_queue));
+ cy_as_hal_enable_interrupts(state);
+ if (queue) {
+ queue->type = type;
+ queue->head_p = 0;
+ queue->tail_p = 0;
+ queue->count = 0;
+ }
+
+ return queue;
+}
+
+void
+cy_as_destroy_c_b_queue(cy_as_c_b_queue *queue)
+{
+ uint32_t state;
+ queue->type = CYAS_INVALID;
+ queue->head_p = 0;
+ queue->tail_p = 0;
+ queue->count = 0;
+ state = cy_as_hal_disable_interrupts();
+ cy_as_hal_c_b_free(queue);
+ cy_as_hal_enable_interrupts(state);
+}
+
+/* Inserts a CyAsCBNode into the queue, the
+ * node type must match the queue type*/
+void
+cy_as_insert_c_b_node(cy_as_c_b_queue *queue_p, void*cbnode)
+{
+ uint32_t int_state;
+
+ int_state = cy_as_hal_disable_interrupts();
+
+ cy_as_hal_assert(queue_p != 0);
+
+ switch (queue_p->type) {
+ case CYAS_USB_FUNC_CB:
+ {
+ cy_as_usb_func_c_b_node *node =
+ (cy_as_usb_func_c_b_node *)cbnode;
+ cy_as_usb_func_c_b_node *tail =
+ (cy_as_usb_func_c_b_node *)queue_p->tail_p;
+
+ cy_as_hal_assert(node->type == CYAS_USB_FUNC_CB);
+ cy_as_hal_assert(tail == 0 ||
+ tail->type == CYAS_USB_FUNC_CB);
+ if (queue_p->head_p == 0)
+ queue_p->head_p = node;
+ else
+ tail->next_p = node;
+
+ queue_p->tail_p = node;
+ }
+ break;
+
+ case CYAS_USB_IO_CB:
+ {
+ cy_as_usb_io_c_b_node *node =
+ (cy_as_usb_io_c_b_node *)cbnode;
+ cy_as_usb_io_c_b_node *tail =
+ (cy_as_usb_io_c_b_node *)queue_p->tail_p;
+
+ cy_as_hal_assert(node->type == CYAS_USB_IO_CB);
+ cy_as_hal_assert(tail == 0 ||
+ tail->type == CYAS_USB_IO_CB);
+ if (queue_p->head_p == 0)
+ queue_p->head_p = node;
+ else
+ tail->next_p = node;
+
+ queue_p->tail_p = node;
+ }
+ break;
+
+ case CYAS_STORAGE_IO_CB:
+ {
+ cy_as_storage_io_c_b_node *node =
+ (cy_as_storage_io_c_b_node *)cbnode;
+ cy_as_storage_io_c_b_node *tail =
+ (cy_as_storage_io_c_b_node *)queue_p->tail_p;
+
+ cy_as_hal_assert(node->type == CYAS_STORAGE_IO_CB);
+ cy_as_hal_assert(tail == 0 ||
+ tail->type == CYAS_STORAGE_IO_CB);
+ if (queue_p->head_p == 0)
+ queue_p->head_p = node;
+ else
+ tail->next_p = node;
+
+ queue_p->tail_p = node;
+ }
+ break;
+
+ case CYAS_FUNC_CB:
+ {
+ cy_as_func_c_b_node *node =
+ (cy_as_func_c_b_node *)cbnode;
+ cy_as_func_c_b_node *tail =
+ (cy_as_func_c_b_node *)queue_p->tail_p;
+
+ cy_as_hal_assert(node->node_type == CYAS_FUNC_CB);
+ cy_as_hal_assert(tail == 0 ||
+ tail->node_type == CYAS_FUNC_CB);
+ if (queue_p->head_p == 0)
+ queue_p->head_p = node;
+ else
+ tail->next_p = node;
+
+ queue_p->tail_p = node;
+ }
+ break;
+
+ default:
+ cy_as_hal_assert(cy_false);
+ break;
+ }
+
+ queue_p->count++;
+
+ cy_as_hal_enable_interrupts(int_state);
+}
+
+/* Removes the tail node from the queue and frees it */
+void
+cy_as_remove_c_b_tail_node(cy_as_c_b_queue *queue_p)
+{
+ uint32_t int_state;
+
+ int_state = cy_as_hal_disable_interrupts();
+
+ if (queue_p->count > 0) {
+ /*
+ * the worst case length of the queue should be
+ * under 10 elements, and the average case should
+ * be just 1 element. so, we just employ a linear
+ * search to find the node to be freed.
+ */
+ switch (queue_p->type) {
+ case CYAS_FUNC_CB:
+ {
+ cy_as_func_c_b_node *node =
+ (cy_as_func_c_b_node *)
+ queue_p->head_p;
+ cy_as_func_c_b_node *tail =
+ (cy_as_func_c_b_node *)
+ queue_p->tail_p;
+ if (node != tail) {
+ while (node->next_p != tail)
+ node = node->next_p;
+ node->next_p = 0;
+ queue_p->tail_p = node;
+ }
+ cy_as_destroy_func_c_b_node(tail);
+ }
+ break;
+
+ case CYAS_USB_FUNC_CB:
+ {
+ cy_as_usb_func_c_b_node *node =
+ (cy_as_usb_func_c_b_node *)
+ queue_p->head_p;
+ cy_as_usb_func_c_b_node *tail =
+ (cy_as_usb_func_c_b_node *)
+ queue_p->tail_p;
+ if (node != tail) {
+ while (node->next_p != tail)
+ node = node->next_p;
+ node->next_p = 0;
+ queue_p->tail_p = node;
+ }
+
+ cy_as_destroy_usb_func_c_b_node(tail);
+ }
+ break;
+
+ case CYAS_USB_IO_CB:
+ {
+ cy_as_usb_io_c_b_node *node =
+ (cy_as_usb_io_c_b_node *)
+ queue_p->head_p;
+ cy_as_usb_io_c_b_node *tail =
+ (cy_as_usb_io_c_b_node *)
+ queue_p->tail_p;
+ if (node != tail) {
+ while (node->next_p != tail)
+ node = node->next_p;
+ node->next_p = 0;
+ queue_p->tail_p = node;
+ }
+ cy_as_destroy_usb_io_c_b_node(tail);
+ }
+ break;
+
+ case CYAS_STORAGE_IO_CB:
+ {
+ cy_as_storage_io_c_b_node *node =
+ (cy_as_storage_io_c_b_node *)
+ queue_p->head_p;
+ cy_as_storage_io_c_b_node *tail =
+ (cy_as_storage_io_c_b_node *)
+ queue_p->tail_p;
+ if (node != tail) {
+ while (node->next_p != tail)
+ node = node->next_p;
+ node->next_p = 0;
+ queue_p->tail_p = node;
+ }
+ cy_as_destroy_storage_io_c_b_node(tail);
+ }
+ break;
+
+ default:
+ cy_as_hal_assert(cy_false);
+ }
+
+ queue_p->count--;
+ if (queue_p->count == 0) {
+ queue_p->head_p = 0;
+ queue_p->tail_p = 0;
+ }
+ }
+
+ cy_as_hal_enable_interrupts(int_state);
+}
+
+/* Removes the first CyAsCBNode from the queue and frees it */
+void
+cy_as_remove_c_b_node(cy_as_c_b_queue *queue_p)
+{
+ uint32_t int_state;
+
+ int_state = cy_as_hal_disable_interrupts();
+
+ cy_as_hal_assert(queue_p->count >= 0);
+ if (queue_p->count > 0) {
+ if (queue_p->type == CYAS_USB_FUNC_CB) {
+ cy_as_usb_func_c_b_node *node =
+ (cy_as_usb_func_c_b_node *)
+ queue_p->head_p;
+ queue_p->head_p = node->next_p;
+ cy_as_destroy_usb_func_c_b_node(node);
+ } else if (queue_p->type == CYAS_USB_IO_CB) {
+ cy_as_usb_io_c_b_node *node =
+ (cy_as_usb_io_c_b_node *)
+ queue_p->head_p;
+ queue_p->head_p = node->next_p;
+ cy_as_destroy_usb_io_c_b_node(node);
+ } else if (queue_p->type == CYAS_STORAGE_IO_CB) {
+ cy_as_storage_io_c_b_node *node =
+ (cy_as_storage_io_c_b_node *)
+ queue_p->head_p;
+ queue_p->head_p = node->next_p;
+ cy_as_destroy_storage_io_c_b_node(node);
+ } else if (queue_p->type == CYAS_FUNC_CB) {
+ cy_as_func_c_b_node *node =
+ (cy_as_func_c_b_node *)
+ queue_p->head_p;
+ queue_p->head_p = node->next_p;
+ cy_as_destroy_func_c_b_node(node);
+ } else {
+ cy_as_hal_assert(cy_false);
+ }
+
+ queue_p->count--;
+ if (queue_p->count == 0) {
+ queue_p->head_p = 0;
+ queue_p->tail_p = 0;
+ }
+ }
+
+ cy_as_hal_enable_interrupts(int_state);
+}
+
+void my_print_func_c_b_node(cy_as_func_c_b_node *node)
+{
+ cy_as_funct_c_b_type type =
+ cy_as_funct_c_b_type_get_type(node->data_type);
+ cy_as_hal_print_message("[cd:%2u dt:%2u cb:0x%08x "
+ "d:0x%08x nt:%1i]", node->client_data, type,
+ (uint32_t)node->cb_p, (uint32_t)node->data,
+ node->node_type);
+}
+
+void my_print_c_b_queue(cy_as_c_b_queue *queue_p)
+{
+ uint32_t i = 0;
+
+ cy_as_hal_print_message("| count: %u type: ", queue_p->count);
+
+ if (queue_p->type == CYAS_USB_FUNC_CB) {
+ cy_as_hal_print_message("USB_FUNC_CB\n");
+ } else if (queue_p->type == CYAS_USB_IO_CB) {
+ cy_as_hal_print_message("USB_IO_CB\n");
+ } else if (queue_p->type == CYAS_STORAGE_IO_CB) {
+ cy_as_hal_print_message("STORAGE_IO_CB\n");
+ } else if (queue_p->type == CYAS_FUNC_CB) {
+ cy_as_func_c_b_node *node = queue_p->head_p;
+ cy_as_hal_print_message("FUNC_CB\n");
+ if (queue_p->count > 0) {
+ cy_as_hal_print_message("| head->");
+
+ for (i = 0; i < queue_p->count; i++) {
+ if (node) {
+ cy_as_hal_print_message("->");
+ my_print_func_c_b_node(node);
+ node = node->next_p;
+ } else
+ cy_as_hal_print_message("->[NULL]\n");
+ }
+
+ cy_as_hal_print_message("\n| tail->");
+ my_print_func_c_b_node(queue_p->tail_p);
+ cy_as_hal_print_message("\n");
+ }
+ } else {
+ cy_as_hal_print_message("INVALID\n");
+ }
+
+ cy_as_hal_print_message("|----------\n");
+}
+
+
+/* Removes and frees all pending callbacks */
+void
+cy_as_clear_c_b_queue(cy_as_c_b_queue *queue_p)
+{
+ uint32_t int_state = cy_as_hal_disable_interrupts();
+
+ while (queue_p->count != 0)
+ cy_as_remove_c_b_node(queue_p);
+
+ cy_as_hal_enable_interrupts(int_state);
+}
+
+cy_as_return_status_t
+cy_as_misc_send_request(cy_as_device *dev_p,
+ cy_as_function_callback cb,
+ uint32_t client,
+ cy_as_funct_c_b_type type,
+ void *data,
+ cy_as_c_b_queue *queue,
+ uint16_t req_type,
+ cy_as_ll_request_response *req_p,
+ cy_as_ll_request_response *reply_p,
+ cy_as_response_callback rcb)
+{
+
+ cy_as_func_c_b_node *cbnode = cy_as_create_func_c_b_node_data(cb,
+ client, type, data);
+ cy_as_return_status_t ret;
+
+ if (cbnode == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+ else
+ cy_as_insert_c_b_node(queue, cbnode);
+
+ req_p->flags |= req_type;
+
+ ret = cy_as_ll_send_request(dev_p, req_p, reply_p, cy_false, rcb);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ cy_as_remove_c_b_tail_node(queue);
+
+ return ret;
+}
+
+void
+cy_as_misc_cancel_ex_requests(cy_as_device *dev_p)
+{
+ int i;
+ for (i = 0; i < CY_RQT_CONTEXT_COUNT; i++)
+ cy_as_ll_remove_all_requests(dev_p, dev_p->context[i]);
+}
+
+
+static void
+cy_as_misc_func_callback(cy_as_device *dev_p,
+ uint8_t context,
+ cy_as_ll_request_response *rqt,
+ cy_as_ll_request_response *resp,
+ cy_as_return_status_t stat)
+{
+ cy_as_func_c_b_node *node = NULL;
+ cy_as_return_status_t ret;
+
+ cy_bool ex_request = (rqt->flags & CY_AS_REQUEST_RESPONSE_EX)
+ == CY_AS_REQUEST_RESPONSE_EX;
+ cy_bool ms_request = (rqt->flags & CY_AS_REQUEST_RESPONSE_MS)
+ == CY_AS_REQUEST_RESPONSE_MS;
+ uint8_t code;
+ uint32_t type;
+ uint8_t cntxt;
+
+ cy_as_hal_assert(ex_request || ms_request);
+ (void) ex_request;
+ (void) ms_request;
+ (void)context;
+
+ cntxt = cy_as_ll_request_response__get_context(rqt);
+ code = cy_as_ll_request_response__get_code(rqt);
+
+ switch (cntxt) {
+ case CY_RQT_GENERAL_RQT_CONTEXT:
+ cy_as_hal_assert(dev_p->func_cbs_misc->count != 0);
+ cy_as_hal_assert(dev_p->func_cbs_misc->type == CYAS_FUNC_CB);
+ node = (cy_as_func_c_b_node *)dev_p->func_cbs_misc->head_p;
+ type = cy_as_funct_c_b_type_get_type(node->data_type);
+
+ switch (code) {
+ case CY_RQT_GET_FIRMWARE_VERSION:
+ cy_as_hal_assert(node->data != 0);
+ cy_as_hal_assert(type ==
+ CY_FUNCT_CB_MISC_GETFIRMWAREVERSION);
+ ret = my_handle_response_get_firmware_version(dev_p,
+ rqt, resp,
+ (cy_as_get_firmware_version_data *)node->data);
+ break;
+ case CY_RQT_READ_MCU_REGISTER:
+ cy_as_hal_assert(node->data != 0);
+ cy_as_hal_assert(type ==
+ CY_FUNCT_CB_MISC_READMCUREGISTER);
+ ret = my_handle_response_read_m_c_u_register(dev_p, rqt,
+ resp, (uint8_t *)node->data);
+ break;
+ case CY_RQT_GET_GPIO_STATE:
+ cy_as_hal_assert(node->data != 0);
+ cy_as_hal_assert(type ==
+ CY_FUNCT_CB_MISC_GETGPIOVALUE);
+ ret = my_handle_response_get_gpio_value(dev_p, rqt,
+ resp, (uint8_t *)node->data);
+ break;
+ case CY_RQT_SET_SD_CLOCK_FREQ:
+ cy_as_hal_assert(type == CY_FUNCT_CB_MISC_SETSDFREQ);
+ ret = my_handle_response_no_data(dev_p, rqt, resp);
+ break;
+ case CY_RQT_CONTROL_ANTIOCH_HEARTBEAT:
+ cy_as_hal_assert(type ==
+ CY_FUNCT_CB_MISC_HEARTBEATCONTROL);
+ ret = my_handle_response_no_data(dev_p, rqt, resp);
+ break;
+ case CY_RQT_WRITE_MCU_REGISTER:
+ cy_as_hal_assert(type ==
+ CY_FUNCT_CB_MISC_WRITEMCUREGISTER);
+ ret = my_handle_response_no_data(dev_p, rqt, resp);
+ break;
+ case CY_RQT_STORAGE_MEDIA_CHANGED:
+ cy_as_hal_assert(type ==
+ CY_FUNCT_CB_MISC_STORAGECHANGED);
+ ret = my_handle_response_no_data(dev_p, rqt, resp);
+ break;
+ case CY_RQT_SET_GPIO_STATE:
+ cy_as_hal_assert(type ==
+ CY_FUNCT_CB_MISC_SETGPIOVALUE);
+ ret = my_handle_response_no_data(dev_p, rqt, resp);
+ break;
+ case CY_RQT_SET_TRACE_LEVEL:
+ cy_as_hal_assert(type ==
+ CY_FUNCT_CB_MISC_SETTRACELEVEL);
+ ret = my_handle_response_no_data(dev_p, rqt, resp);
+ if (ret == CY_AS_ERROR_INVALID_RESPONSE)
+ ret = CY_AS_ERROR_NOT_SUPPORTED;
+ break;
+ case CY_RQT_PREPARE_FOR_STANDBY:
+ cy_as_hal_assert(type ==
+ CY_FUNCT_CB_MISC_ENTERSTANDBY);
+ ret = my_handle_response_enter_standby(dev_p, rqt, resp,
+ (cy_bool)node->data);
+ break;
+ case CY_RQT_ENTER_SUSPEND_MODE:
+ cy_as_hal_assert(type ==
+ CY_FUNCT_CB_MISC_ENTERSUSPEND);
+ ret = my_handle_response_no_data(dev_p, rqt, resp);
+ if (ret == CY_AS_ERROR_SUCCESS)
+ cy_as_device_set_suspend_mode(dev_p);
+
+ break;
+ case CY_RQT_RESERVE_LNA_BOOT_AREA:
+ cy_as_hal_assert(type ==
+ CY_FUNCT_CB_MISC_RESERVELNABOOTAREA);
+ ret = my_handle_response_no_data(dev_p, rqt, resp);
+ break;
+ case CY_RQT_SDPOLARITY:
+ cy_as_hal_assert(type ==
+ CY_FUNCT_CB_MISC_SETSDPOLARITY);
+ ret = my_handle_response_no_data(dev_p, rqt, resp);
+ break;
+ default:
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ cy_as_hal_assert(cy_false);
+ break;
+ }
+ break;
+
+ case CY_RQT_RESOURCE_RQT_CONTEXT:
+ cy_as_hal_assert(dev_p->func_cbs_res->count != 0);
+ cy_as_hal_assert(dev_p->func_cbs_res->type == CYAS_FUNC_CB);
+ node = (cy_as_func_c_b_node *)dev_p->func_cbs_res->head_p;
+ type = cy_as_funct_c_b_type_get_type(node->data_type);
+
+ switch (code) {
+ case CY_RQT_ACQUIRE_RESOURCE:
+ /* The node->data field is actually an enum value
+ * which could be 0, thus no assert is done */
+ cy_as_hal_assert(type ==
+ CY_FUNCT_CB_MISC_ACQUIRERESOURCE);
+ ret = my_handle_response_acquire_resource(dev_p, rqt,
+ resp, (cy_as_resource_type *)node->data);
+ break;
+ default:
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ cy_as_hal_assert(cy_false);
+ break;
+ }
+ break;
+
+ default:
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+ cy_as_hal_assert(cy_false);
+ break;
+ }
+
+ /*
+ * if the low level layer returns a direct error, use the
+ * corresponding error code. if not, use the error code
+ * based on the response from firmware.
+ */
+ if (stat == CY_AS_ERROR_SUCCESS)
+ stat = ret;
+
+ /* Call the user Callback */
+ node->cb_p((cy_as_device_handle)dev_p, stat, node->client_data,
+ node->data_type, node->data);
+ if (cntxt == CY_RQT_GENERAL_RQT_CONTEXT)
+ cy_as_remove_c_b_node(dev_p->func_cbs_misc);
+ else
+ cy_as_remove_c_b_node(dev_p->func_cbs_res);
+
+}
+
+
+
+/*[]*/
projects / mv-sheeva.git / blobdiff