/* 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 " "received, 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 " "received, 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; } EXPORT_SYMBOL(cy_as_misc_get_firmware_version); 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; } EXPORT_SYMBOL(cy_as_misc_read_m_c_u_register); 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; } EXPORT_SYMBOL(cy_as_misc_reset); 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; } EXPORT_SYMBOL(cy_as_misc_acquire_resource); 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; } EXPORT_SYMBOL(cy_as_misc_release_resource); 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; } EXPORT_SYMBOL(cy_as_misc_heart_beat_control); 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); } EXPORT_SYMBOL(cy_as_misc_set_low_speed_sd_freq); 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); } EXPORT_SYMBOL(cy_as_misc_set_high_speed_sd_freq); 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; } EXPORT_SYMBOL(cy_as_misc_get_gpio_value); 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; } EXPORT_SYMBOL(cy_as_misc_set_gpio_value); 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; } EXPORT_SYMBOL(cy_as_misc_enter_standby); 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 up to 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; } EXPORT_SYMBOL(cy_as_misc_leave_standby); 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; } EXPORT_SYMBOL(cy_as_misc_storage_changed); 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; } EXPORT_SYMBOL(cy_as_misc_enter_suspend); 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; } EXPORT_SYMBOL(cy_as_misc_leave_suspend); 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); } /*[]*/