Google Git
Sign in
nest-open-source / nest-guard / 1.0 / linux / 6754b876e4c89285b30ff59800d23e21ce2dbe3f / . / linux / drivers / staging / westbridge / astoria / api / src / cyasmisc.c
blob: 10a52a1ac6fb793e42b2730eb54791977ad24254 [file] [log] [blame]
/* 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);
}
/*[]*/