--- /dev/null
+/* Cypress West Bridge API source file (cyaslowlevel.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/cyascast.h"
+#include "../../include/linux/westbridge/cyasdevice.h"
+#include "../../include/linux/westbridge/cyaslowlevel.h"
+#include "../../include/linux/westbridge/cyasintr.h"
+#include "../../include/linux/westbridge/cyaserr.h"
+#include "../../include/linux/westbridge/cyasregs.h"
+
+static const uint32_t cy_as_low_level_timeout_count = 65536 * 4;
+
+/* Forward declaration */
+static cy_as_return_status_t cy_as_send_one(cy_as_device *dev_p,
+ cy_as_ll_request_response *req_p);
+
+/*
+* This array holds the size of the largest request we will ever recevie from
+* the West Bridge device per context. The size is in 16 bit words. Note a
+* size of 0xffff indicates that there will be no requests on this context
+* from West Bridge.
+*/
+static uint16_t max_request_length[CY_RQT_CONTEXT_COUNT] = {
+ 8, /* CY_RQT_GENERAL_RQT_CONTEXT - CY_RQT_INITIALIZATION_COMPLETE */
+ 8, /* CY_RQT_RESOURCE_RQT_CONTEXT - none */
+ 8, /* CY_RQT_STORAGE_RQT_CONTEXT - CY_RQT_MEDIA_CHANGED */
+ 128, /* CY_RQT_USB_RQT_CONTEXT - CY_RQT_USB_EVENT */
+ 8 /* CY_RQT_TUR_RQT_CONTEXT - CY_RQT_TURBO_CMD_FROM_HOST */
+};
+
+/*
+* For the given context, this function removes the request node at the head
+* of the queue from the context. This is called after all processing has
+* occurred on the given request and response and we are ready to remove this
+* entry from the queue.
+*/
+static void
+cy_as_ll_remove_request_queue_head(cy_as_device *dev_p, cy_as_context *ctxt_p)
+{
+ uint32_t mask, state;
+ cy_as_ll_request_list_node *node_p;
+
+ (void)dev_p;
+ cy_as_hal_assert(ctxt_p->request_queue_p != 0);
+
+ mask = cy_as_hal_disable_interrupts();
+ node_p = ctxt_p->request_queue_p;
+ ctxt_p->request_queue_p = node_p->next;
+ cy_as_hal_enable_interrupts(mask);
+
+ node_p->callback = 0;
+ node_p->rqt = 0;
+ node_p->resp = 0;
+
+ /*
+ * note that the caller allocates and destroys the request and
+ * response. generally the destroy happens in the callback for
+ * async requests and after the wait returns for sync. the
+ * request and response may not actually be destroyed but may be
+ * managed in other ways as well. it is the responsibilty of
+ * the caller to deal with these in any case. the caller can do
+ * this in the request/response callback function.
+ */
+ state = cy_as_hal_disable_interrupts();
+ cy_as_hal_c_b_free(node_p);
+ cy_as_hal_enable_interrupts(state);
+}
+
+/*
+* For the context given, this function sends the next request to
+* West Bridge via the mailbox register, if the next request is
+* ready to be sent and has not already been sent.
+*/
+static void
+cy_as_ll_send_next_request(cy_as_device *dev_p, cy_as_context *ctxt_p)
+{
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+
+ /*
+ * ret == ret is equivalent to while (1) but eliminates compiler
+ * warnings for some compilers.
+ */
+ while (ret == ret) {
+ cy_as_ll_request_list_node *node_p = ctxt_p->request_queue_p;
+ if (node_p == 0)
+ break;
+
+ if (cy_as_request_get_node_state(node_p) !=
+ CY_AS_REQUEST_LIST_STATE_QUEUED)
+ break;
+
+ cy_as_request_set_node_state(node_p,
+ CY_AS_REQUEST_LIST_STATE_WAITING);
+ ret = cy_as_send_one(dev_p, node_p->rqt);
+ if (ret == CY_AS_ERROR_SUCCESS)
+ break;
+
+ /*
+ * if an error occurs in sending the request, tell the requester
+ * about the error and remove the request from the queue.
+ */
+ cy_as_request_set_node_state(node_p,
+ CY_AS_REQUEST_LIST_STATE_RECEIVED);
+ node_p->callback(dev_p, ctxt_p->number,
+ node_p->rqt, node_p->resp, ret);
+ cy_as_ll_remove_request_queue_head(dev_p, ctxt_p);
+
+ /*
+ * this falls through to the while loop to send the next request
+ * since the previous request did not get sent.
+ */
+ }
+}
+
+/*
+* This method removes an entry from the request queue of a given context.
+* The entry is removed only if it is not in transit.
+*/
+cy_as_remove_request_result_t
+cy_as_ll_remove_request(cy_as_device *dev_p, cy_as_context *ctxt_p,
+ cy_as_ll_request_response *req_p, cy_bool force)
+{
+ uint32_t imask;
+ cy_as_ll_request_list_node *node_p;
+ cy_as_ll_request_list_node *tmp_p;
+ uint32_t state;
+
+ imask = cy_as_hal_disable_interrupts();
+ if (ctxt_p->request_queue_p != 0 &&
+ ctxt_p->request_queue_p->rqt == req_p) {
+ node_p = ctxt_p->request_queue_p;
+ if ((cy_as_request_get_node_state(node_p) ==
+ CY_AS_REQUEST_LIST_STATE_WAITING) && (!force)) {
+ cy_as_hal_enable_interrupts(imask);
+ return cy_as_remove_request_in_transit;
+ }
+
+ ctxt_p->request_queue_p = node_p->next;
+ } else {
+ tmp_p = ctxt_p->request_queue_p;
+ while (tmp_p != 0 && tmp_p->next != 0 &&
+ tmp_p->next->rqt != req_p)
+ tmp_p = tmp_p->next;
+
+ if (tmp_p == 0 || tmp_p->next == 0) {
+ cy_as_hal_enable_interrupts(imask);
+ return cy_as_remove_request_not_found;
+ }
+
+ node_p = tmp_p->next;
+ tmp_p->next = node_p->next;
+ }
+
+ if (node_p->callback)
+ node_p->callback(dev_p, ctxt_p->number, node_p->rqt,
+ node_p->resp, CY_AS_ERROR_CANCELED);
+
+ state = cy_as_hal_disable_interrupts();
+ cy_as_hal_c_b_free(node_p);
+ cy_as_hal_enable_interrupts(state);
+
+ cy_as_hal_enable_interrupts(imask);
+ return cy_as_remove_request_sucessful;
+}
+
+void
+cy_as_ll_remove_all_requests(cy_as_device *dev_p, cy_as_context *ctxt_p)
+{
+ cy_as_ll_request_list_node *node = ctxt_p->request_queue_p;
+
+ while (node) {
+ if (cy_as_request_get_node_state(ctxt_p->request_queue_p) !=
+ CY_AS_REQUEST_LIST_STATE_RECEIVED)
+ cy_as_ll_remove_request(dev_p, ctxt_p,
+ node->rqt, cy_true);
+ node = node->next;
+ }
+}
+
+static cy_bool
+cy_as_ll_is_in_queue(cy_as_context *ctxt_p, cy_as_ll_request_response *req_p)
+{
+ uint32_t mask;
+ cy_as_ll_request_list_node *node_p;
+
+ mask = cy_as_hal_disable_interrupts();
+ node_p = ctxt_p->request_queue_p;
+ while (node_p) {
+ if (node_p->rqt == req_p) {
+ cy_as_hal_enable_interrupts(mask);
+ return cy_true;
+ }
+ node_p = node_p->next;
+ }
+ cy_as_hal_enable_interrupts(mask);
+ return cy_false;
+}
+
+/*
+* This is the handler for mailbox data when we are trying to send data
+* to the West Bridge firmware. The firmware may be trying to send us
+* data and we need to queue this data to allow the firmware to move
+* forward and be in a state to receive our request. Here we just queue
+* the data and it is processed at a later time by the mailbox interrupt
+* handler.
+*/
+void
+cy_as_ll_queue_mailbox_data(cy_as_device *dev_p)
+{
+ cy_as_context *ctxt_p;
+ uint8_t context;
+ uint16_t data[4];
+ int32_t i;
+
+ /* Read the data from mailbox 0 to determine what to do with the data */
+ for (i = 3; i >= 0; i--)
+ data[i] = cy_as_hal_read_register(dev_p->tag,
+ cy_cast_int2U_int16(CY_AS_MEM_P0_MAILBOX0 + i));
+
+ context = cy_as_mbox_get_context(data[0]);
+ if (context >= CY_RQT_CONTEXT_COUNT) {
+ cy_as_hal_print_message("mailbox request/response received "
+ "with invalid context value (%d)\n", context);
+ return;
+ }
+
+ ctxt_p = dev_p->context[context];
+
+ /*
+ * if we have queued too much data, drop future data.
+ */
+ cy_as_hal_assert(ctxt_p->queue_index * sizeof(uint16_t) +
+ sizeof(data) <= sizeof(ctxt_p->data_queue));
+
+ for (i = 0; i < 4; i++)
+ ctxt_p->data_queue[ctxt_p->queue_index++] = data[i];
+
+ cy_as_hal_assert((ctxt_p->queue_index % 4) == 0);
+ dev_p->ll_queued_data = cy_true;
+}
+
+void
+cy_as_mail_box_process_data(cy_as_device *dev_p, uint16_t *data)
+{
+ cy_as_context *ctxt_p;
+ uint8_t context;
+ uint16_t *len_p;
+ cy_as_ll_request_response *rec_p;
+ uint8_t st;
+ uint16_t src, dest;
+
+ context = cy_as_mbox_get_context(data[0]);
+ if (context >= CY_RQT_CONTEXT_COUNT) {
+ cy_as_hal_print_message("mailbox request/response received "
+ "with invalid context value (%d)\n", context);
+ return;
+ }
+
+ ctxt_p = dev_p->context[context];
+
+ if (cy_as_mbox_is_request(data[0])) {
+ cy_as_hal_assert(ctxt_p->req_p != 0);
+ rec_p = ctxt_p->req_p;
+ len_p = &ctxt_p->request_length;
+
+ } else {
+ if (ctxt_p->request_queue_p == 0 ||
+ cy_as_request_get_node_state(ctxt_p->request_queue_p)
+ != CY_AS_REQUEST_LIST_STATE_WAITING) {
+ cy_as_hal_print_message("mailbox response received on "
+ "context that was not expecting a response\n");
+ cy_as_hal_print_message(" context: %d\n", context);
+ cy_as_hal_print_message(" contents: 0x%04x 0x%04x "
+ "0x%04x 0x%04x\n",
+ data[0], data[1], data[2], data[3]);
+ if (ctxt_p->request_queue_p != 0)
+ cy_as_hal_print_message(" state: 0x%02x\n",
+ ctxt_p->request_queue_p->state);
+ return;
+ }
+
+ /* Make sure the request has an associated response */
+ cy_as_hal_assert(ctxt_p->request_queue_p->resp != 0);
+
+ rec_p = ctxt_p->request_queue_p->resp;
+ len_p = &ctxt_p->request_queue_p->length;
+ }
+
+ if (rec_p->stored == 0) {
+ /*
+ * this is the first cycle of the response
+ */
+ cy_as_ll_request_response__set_code(rec_p,
+ cy_as_mbox_get_code(data[0]));
+ cy_as_ll_request_response__set_context(rec_p, context);
+
+ if (cy_as_mbox_is_last(data[0])) {
+ /* This is a single cycle response */
+ *len_p = rec_p->length;
+ st = 1;
+ } else {
+ /* Ensure that enough memory has been
+ * reserved for the response. */
+ cy_as_hal_assert(rec_p->length >= data[1]);
+ *len_p = (data[1] < rec_p->length) ?
+ data[1] : rec_p->length;
+ st = 2;
+ }
+ } else
+ st = 1;
+
+ /* Trasnfer the data from the mailboxes to the response */
+ while (rec_p->stored < *len_p && st < 4)
+ rec_p->data[rec_p->stored++] = data[st++];
+
+ if (cy_as_mbox_is_last(data[0])) {
+ /* NB: The call-back that is made below can cause the
+ * addition of more data in this queue, thus causing
+ * a recursive overflow of the queue. this is prevented
+ * by removing the request entry that is currently
+ * being passed up from the data queue. if this is done,
+ * the queue only needs to be as long as two request
+ * entries from west bridge.
+ */
+ if ((ctxt_p->rqt_index > 0) &&
+ (ctxt_p->rqt_index <= ctxt_p->queue_index)) {
+ dest = 0;
+ src = ctxt_p->rqt_index;
+
+ while (src < ctxt_p->queue_index)
+ ctxt_p->data_queue[dest++] =
+ ctxt_p->data_queue[src++];
+
+ ctxt_p->rqt_index = 0;
+ ctxt_p->queue_index = dest;
+ cy_as_hal_assert((ctxt_p->queue_index % 4) == 0);
+ }
+
+ if (ctxt_p->request_queue_p != 0 && rec_p ==
+ ctxt_p->request_queue_p->resp) {
+ /*
+ * if this is the last cycle of the response, call the
+ * callback and reset for the next response.
+ */
+ cy_as_ll_request_response *resp_p =
+ ctxt_p->request_queue_p->resp;
+ resp_p->length = ctxt_p->request_queue_p->length;
+ cy_as_request_set_node_state(ctxt_p->request_queue_p,
+ CY_AS_REQUEST_LIST_STATE_RECEIVED);
+
+ cy_as_device_set_in_callback(dev_p);
+ ctxt_p->request_queue_p->callback(dev_p, context,
+ ctxt_p->request_queue_p->rqt,
+ resp_p, CY_AS_ERROR_SUCCESS);
+
+ cy_as_device_clear_in_callback(dev_p);
+
+ cy_as_ll_remove_request_queue_head(dev_p, ctxt_p);
+ cy_as_ll_send_next_request(dev_p, ctxt_p);
+ } else {
+ /* Send the request to the appropriate
+ * module to handle */
+ cy_as_ll_request_response *request_p = ctxt_p->req_p;
+ ctxt_p->req_p = 0;
+ if (ctxt_p->request_callback) {
+ cy_as_device_set_in_callback(dev_p);
+ ctxt_p->request_callback(dev_p, context,
+ request_p, 0, CY_AS_ERROR_SUCCESS);
+ cy_as_device_clear_in_callback(dev_p);
+ }
+ cy_as_ll_init_request(request_p, 0,
+ context, request_p->length);
+ ctxt_p->req_p = request_p;
+ }
+ }
+}
+
+/*
+* This is the handler for processing queued mailbox data
+*/
+void
+cy_as_mail_box_queued_data_handler(cy_as_device *dev_p)
+{
+ uint16_t i;
+
+ /*
+ * if more data gets queued in between our entering this call
+ * and the end of the iteration on all contexts; we should
+ * continue processing the queued data.
+ */
+ while (dev_p->ll_queued_data) {
+ dev_p->ll_queued_data = cy_false;
+ for (i = 0; i < CY_RQT_CONTEXT_COUNT; i++) {
+ uint16_t offset;
+ cy_as_context *ctxt_p = dev_p->context[i];
+ cy_as_hal_assert((ctxt_p->queue_index % 4) == 0);
+
+ offset = 0;
+ while (offset < ctxt_p->queue_index) {
+ ctxt_p->rqt_index = offset + 4;
+ cy_as_mail_box_process_data(dev_p,
+ ctxt_p->data_queue + offset);
+ offset = ctxt_p->rqt_index;
+ }
+ ctxt_p->queue_index = 0;
+ }
+ }
+}
+
+/*
+* This is the handler for the mailbox interrupt. This function reads
+* data from the mailbox registers until a complete request or response
+* is received. When a complete request is received, the callback
+* associated with requests on that context is called. When a complete
+* response is recevied, the callback associated with the request that
+* generated the reponse is called.
+*/
+void
+cy_as_mail_box_interrupt_handler(cy_as_device *dev_p)
+{
+ cy_as_hal_assert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE);
+
+ /*
+ * queue the mailbox data to preserve
+ * order for later processing.
+ */
+ cy_as_ll_queue_mailbox_data(dev_p);
+
+ /*
+ * process what was queued and anything that may be pending
+ */
+ cy_as_mail_box_queued_data_handler(dev_p);
+}
+
+cy_as_return_status_t
+cy_as_ll_start(cy_as_device *dev_p)
+{
+ uint16_t i;
+
+ if (cy_as_device_is_low_level_running(dev_p))
+ return CY_AS_ERROR_ALREADY_RUNNING;
+
+ dev_p->ll_sending_rqt = cy_false;
+ dev_p->ll_abort_curr_rqt = cy_false;
+
+ for (i = 0; i < CY_RQT_CONTEXT_COUNT; i++) {
+ dev_p->context[i] = (cy_as_context *)
+ cy_as_hal_alloc(sizeof(cy_as_context));
+ if (dev_p->context[i] == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ dev_p->context[i]->number = (uint8_t)i;
+ dev_p->context[i]->request_callback = 0;
+ dev_p->context[i]->request_queue_p = 0;
+ dev_p->context[i]->last_node_p = 0;
+ dev_p->context[i]->req_p = cy_as_ll_create_request(dev_p,
+ 0, (uint8_t)i, max_request_length[i]);
+ dev_p->context[i]->queue_index = 0;
+
+ if (!cy_as_hal_create_sleep_channel
+ (&dev_p->context[i]->channel))
+ return CY_AS_ERROR_CREATE_SLEEP_CHANNEL_FAILED;
+ }
+
+ cy_as_device_set_low_level_running(dev_p);
+ return CY_AS_ERROR_SUCCESS;
+}
+
+/*
+* Shutdown the low level communications module. This operation will
+* also cancel any queued low level requests.
+*/
+cy_as_return_status_t
+cy_as_ll_stop(cy_as_device *dev_p)
+{
+ uint8_t i;
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ cy_as_context *ctxt_p;
+ uint32_t mask;
+
+ for (i = 0; i < CY_RQT_CONTEXT_COUNT; i++) {
+ ctxt_p = dev_p->context[i];
+ if (!cy_as_hal_destroy_sleep_channel(&ctxt_p->channel))
+ return CY_AS_ERROR_DESTROY_SLEEP_CHANNEL_FAILED;
+
+ /*
+ * now, free any queued requests and assocaited responses
+ */
+ while (ctxt_p->request_queue_p) {
+ uint32_t state;
+ cy_as_ll_request_list_node *node_p =
+ ctxt_p->request_queue_p;
+
+ /* Mark this pair as in a cancel operation */
+ cy_as_request_set_node_state(node_p,
+ CY_AS_REQUEST_LIST_STATE_CANCELING);
+
+ /* Tell the caller that we are canceling this request */
+ /* NB: The callback is responsible for destroying the
+ * request and the response. we cannot count on the
+ * contents of these two after calling the callback.
+ */
+ node_p->callback(dev_p, i, node_p->rqt,
+ node_p->resp, CY_AS_ERROR_CANCELED);
+
+ /* Remove the pair from the queue */
+ mask = cy_as_hal_disable_interrupts();
+ ctxt_p->request_queue_p = node_p->next;
+ cy_as_hal_enable_interrupts(mask);
+
+ /* Free the list node */
+ state = cy_as_hal_disable_interrupts();
+ cy_as_hal_c_b_free(node_p);
+ cy_as_hal_enable_interrupts(state);
+ }
+
+ cy_as_ll_destroy_request(dev_p, dev_p->context[i]->req_p);
+ cy_as_hal_free(dev_p->context[i]);
+ dev_p->context[i] = 0;
+
+ }
+ cy_as_device_set_low_level_stopped(dev_p);
+
+ return ret;
+}
+
+void
+cy_as_ll_init_request(cy_as_ll_request_response *req_p,
+ uint16_t code, uint16_t context, uint16_t length)
+{
+ uint16_t totallen = sizeof(cy_as_ll_request_response) +
+ (length - 1) * sizeof(uint16_t);
+
+ cy_as_hal_mem_set(req_p, 0, totallen);
+ req_p->length = length;
+ cy_as_ll_request_response__set_code(req_p, code);
+ cy_as_ll_request_response__set_context(req_p, context);
+ cy_as_ll_request_response__set_request(req_p);
+}
+
+/*
+* Create a new request.
+*/
+cy_as_ll_request_response *
+cy_as_ll_create_request(cy_as_device *dev_p, uint16_t code,
+ uint8_t context, uint16_t length)
+{
+ cy_as_ll_request_response *req_p;
+ uint32_t state;
+ uint16_t totallen = sizeof(cy_as_ll_request_response) +
+ (length - 1) * sizeof(uint16_t);
+
+ (void)dev_p;
+
+ state = cy_as_hal_disable_interrupts();
+ req_p = cy_as_hal_c_b_alloc(totallen);
+ cy_as_hal_enable_interrupts(state);
+ if (req_p)
+ cy_as_ll_init_request(req_p, code, context, length);
+
+ return req_p;
+}
+
+/*
+* Destroy a request.
+*/
+void
+cy_as_ll_destroy_request(cy_as_device *dev_p, cy_as_ll_request_response *req_p)
+{
+ uint32_t state;
+ (void)dev_p;
+ (void)req_p;
+
+ state = cy_as_hal_disable_interrupts();
+ cy_as_hal_c_b_free(req_p);
+ cy_as_hal_enable_interrupts(state);
+
+}
+
+void
+cy_as_ll_init_response(cy_as_ll_request_response *req_p, uint16_t length)
+{
+ uint16_t totallen = sizeof(cy_as_ll_request_response) +
+ (length - 1) * sizeof(uint16_t);
+
+ cy_as_hal_mem_set(req_p, 0, totallen);
+ req_p->length = length;
+ cy_as_ll_request_response__set_response(req_p);
+}
+
+/*
+* Create a new response
+*/
+cy_as_ll_request_response *
+cy_as_ll_create_response(cy_as_device *dev_p, uint16_t length)
+{
+ cy_as_ll_request_response *req_p;
+ uint32_t state;
+ uint16_t totallen = sizeof(cy_as_ll_request_response) +
+ (length - 1) * sizeof(uint16_t);
+
+ (void)dev_p;
+
+ state = cy_as_hal_disable_interrupts();
+ req_p = cy_as_hal_c_b_alloc(totallen);
+ cy_as_hal_enable_interrupts(state);
+ if (req_p)
+ cy_as_ll_init_response(req_p, length);
+
+ return req_p;
+}
+
+/*
+* Destroy the new response
+*/
+void
+cy_as_ll_destroy_response(cy_as_device *dev_p, cy_as_ll_request_response *req_p)
+{
+ uint32_t state;
+ (void)dev_p;
+ (void)req_p;
+
+ state = cy_as_hal_disable_interrupts();
+ cy_as_hal_c_b_free(req_p);
+ cy_as_hal_enable_interrupts(state);
+}
+
+static uint16_t
+cy_as_read_intr_status(
+ cy_as_device *dev_p)
+{
+ uint32_t mask;
+ cy_bool bloop = cy_true;
+ uint16_t v = 0, last = 0xffff;
+
+ /*
+ * before determining if the mailboxes are ready for more data,
+ * we first check the mailbox interrupt to see if we need to
+ * receive data. this prevents a dead-lock condition that can
+ * occur when both sides are trying to receive data.
+ */
+ while (last == last) {
+ /*
+ * disable interrupts to be sure we don't process the mailbox
+ * here and have the interrupt routine try to read this data
+ * as well.
+ */
+ mask = cy_as_hal_disable_interrupts();
+
+ /*
+ * see if there is data to be read.
+ */
+ v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_P0_INTR_REG);
+ if ((v & CY_AS_MEM_P0_INTR_REG_MBINT) == 0) {
+ cy_as_hal_enable_interrupts(mask);
+ break;
+ }
+
+ /*
+ * queue the mailbox data for later processing.
+ * this allows the firmware to move forward and
+ * service the requst from the P port.
+ */
+ cy_as_ll_queue_mailbox_data(dev_p);
+
+ /*
+ * enable interrupts again to service mailbox
+ * interrupts appropriately
+ */
+ cy_as_hal_enable_interrupts(mask);
+ }
+
+ /*
+ * now, all data is received
+ */
+ last = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_MCU_MB_STAT) & CY_AS_MEM_P0_MCU_MBNOTRD;
+ while (bloop) {
+ v = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_MCU_MB_STAT) & CY_AS_MEM_P0_MCU_MBNOTRD;
+ if (v == last)
+ break;
+
+ last = v;
+ }
+
+ return v;
+}
+
+/*
+* Send a single request or response using the mail box register.
+* This function does not deal with the internal queues at all,
+* but only sends the request or response across to the firmware
+*/
+static cy_as_return_status_t
+cy_as_send_one(
+ cy_as_device *dev_p,
+ cy_as_ll_request_response *req_p)
+{
+ int i;
+ uint16_t mb0, v;
+ int32_t loopcount;
+ uint32_t int_stat;
+
+#ifdef _DEBUG
+ if (cy_as_ll_request_response__is_request(req_p)) {
+ switch (cy_as_ll_request_response__get_context(req_p)) {
+ case CY_RQT_GENERAL_RQT_CONTEXT:
+ cy_as_hal_assert(req_p->length * 2 + 2 <
+ CY_CTX_GEN_MAX_DATA_SIZE);
+ break;
+
+ case CY_RQT_RESOURCE_RQT_CONTEXT:
+ cy_as_hal_assert(req_p->length * 2 + 2 <
+ CY_CTX_RES_MAX_DATA_SIZE);
+ break;
+
+ case CY_RQT_STORAGE_RQT_CONTEXT:
+ cy_as_hal_assert(req_p->length * 2 + 2 <
+ CY_CTX_STR_MAX_DATA_SIZE);
+ break;
+
+ case CY_RQT_USB_RQT_CONTEXT:
+ cy_as_hal_assert(req_p->length * 2 + 2 <
+ CY_CTX_USB_MAX_DATA_SIZE);
+ break;
+ }
+ }
+#endif
+
+ /* Write the request to the mail box registers */
+ if (req_p->length > 3) {
+ uint16_t length = req_p->length;
+ int which = 0;
+ int st = 1;
+
+ dev_p->ll_sending_rqt = cy_true;
+ while (which < length) {
+ loopcount = cy_as_low_level_timeout_count;
+ do {
+ v = cy_as_read_intr_status(dev_p);
+
+ } while (v && loopcount-- > 0);
+
+ if (v) {
+ cy_as_hal_print_message(
+ ">>>>>> LOW LEVEL TIMEOUT "
+ "%x %x %x %x\n",
+ cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_MCU_MAILBOX0),
+ cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_MCU_MAILBOX1),
+ cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_MCU_MAILBOX2),
+ cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_MCU_MAILBOX3));
+ return CY_AS_ERROR_TIMEOUT;
+ }
+
+ if (dev_p->ll_abort_curr_rqt) {
+ dev_p->ll_sending_rqt = cy_false;
+ dev_p->ll_abort_curr_rqt = cy_false;
+ return CY_AS_ERROR_CANCELED;
+ }
+
+ int_stat = cy_as_hal_disable_interrupts();
+
+ /*
+ * check again whether the mailbox is free.
+ * it is possible that an ISR came in and
+ * wrote into the mailboxes since we last
+ * checked the status.
+ */
+ v = cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_MCU_MB_STAT) &
+ CY_AS_MEM_P0_MCU_MBNOTRD;
+ if (v) {
+ /* Go back to the original check since
+ * the mailbox is not free. */
+ cy_as_hal_enable_interrupts(int_stat);
+ continue;
+ }
+
+ if (which == 0) {
+ cy_as_hal_write_register(dev_p->tag,
+ CY_AS_MEM_MCU_MAILBOX1, length);
+ st = 2;
+ } else {
+ st = 1;
+ }
+
+ while ((which < length) && (st < 4)) {
+ cy_as_hal_write_register(dev_p->tag,
+ cy_cast_int2U_int16
+ (CY_AS_MEM_MCU_MAILBOX0 + st),
+ req_p->data[which++]);
+ st++;
+ }
+
+ mb0 = req_p->box0;
+ if (which == length) {
+ dev_p->ll_sending_rqt = cy_false;
+ mb0 |= CY_AS_REQUEST_RESPONSE_LAST_MASK;
+ }
+
+ if (dev_p->ll_abort_curr_rqt) {
+ dev_p->ll_sending_rqt = cy_false;
+ dev_p->ll_abort_curr_rqt = cy_false;
+ cy_as_hal_enable_interrupts(int_stat);
+ return CY_AS_ERROR_CANCELED;
+ }
+
+ cy_as_hal_write_register(dev_p->tag,
+ CY_AS_MEM_MCU_MAILBOX0, mb0);
+
+ /* Wait for the MBOX interrupt to be high */
+ cy_as_hal_sleep150();
+ cy_as_hal_enable_interrupts(int_stat);
+ }
+ } else {
+check_mailbox_availability:
+ /*
+ * wait for the mailbox registers to become available. this
+ * should be a very quick wait as the firmware is designed
+ * to accept requests at interrupt time and queue them for
+ * future processing.
+ */
+ loopcount = cy_as_low_level_timeout_count;
+ do {
+ v = cy_as_read_intr_status(dev_p);
+
+ } while (v && loopcount-- > 0);
+
+ if (v) {
+ cy_as_hal_print_message(
+ ">>>>>> LOW LEVEL TIMEOUT %x %x %x %x\n",
+ cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_MCU_MAILBOX0),
+ cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_MCU_MAILBOX1),
+ cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_MCU_MAILBOX2),
+ cy_as_hal_read_register(dev_p->tag,
+ CY_AS_MEM_MCU_MAILBOX3));
+ return CY_AS_ERROR_TIMEOUT;
+ }
+
+ int_stat = cy_as_hal_disable_interrupts();
+
+ /*
+ * check again whether the mailbox is free. it is
+ * possible that an ISR came in and wrote into the
+ * mailboxes since we last checked the status.
+ */
+ v = cy_as_hal_read_register(dev_p->tag, CY_AS_MEM_MCU_MB_STAT) &
+ CY_AS_MEM_P0_MCU_MBNOTRD;
+ if (v) {
+ /* Go back to the original check
+ * since the mailbox is not free. */
+ cy_as_hal_enable_interrupts(int_stat);
+ goto check_mailbox_availability;
+ }
+
+ /* Write the data associated with the request
+ * into the mbox registers 1 - 3 */
+ v = 0;
+ for (i = req_p->length - 1; i >= 0; i--)
+ cy_as_hal_write_register(dev_p->tag,
+ cy_cast_int2U_int16(CY_AS_MEM_MCU_MAILBOX1 + i),
+ req_p->data[i]);
+
+ /* Write the mbox register 0 to trigger the interrupt */
+ cy_as_hal_write_register(dev_p->tag, CY_AS_MEM_MCU_MAILBOX0,
+ req_p->box0 | CY_AS_REQUEST_RESPONSE_LAST_MASK);
+
+ cy_as_hal_sleep150();
+ cy_as_hal_enable_interrupts(int_stat);
+ }
+
+ return CY_AS_ERROR_SUCCESS;
+}
+
+/*
+* This function queues a single request to be sent to the firmware.
+*/
+extern cy_as_return_status_t
+cy_as_ll_send_request(
+ cy_as_device *dev_p,
+ /* The request to send */
+ cy_as_ll_request_response *req,
+ /* Storage for a reply, must be sure
+ * it is of sufficient size */
+ cy_as_ll_request_response *resp,
+ /* If true, this is a synchronous request */
+ cy_bool sync,
+ /* Callback to call when reply is received */
+ cy_as_response_callback cb
+)
+{
+ cy_as_context *ctxt_p;
+ uint16_t box0 = req->box0;
+ uint8_t context;
+ cy_as_return_status_t ret = CY_AS_ERROR_SUCCESS;
+ cy_as_ll_request_list_node *node_p;
+ uint32_t mask, state;
+
+ cy_as_hal_assert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE);
+
+ context = cy_as_mbox_get_context(box0);
+ cy_as_hal_assert(context < CY_RQT_CONTEXT_COUNT);
+ ctxt_p = dev_p->context[context];
+
+ /* Allocate the list node */
+ state = cy_as_hal_disable_interrupts();
+ node_p = cy_as_hal_c_b_alloc(sizeof(cy_as_ll_request_list_node));
+ cy_as_hal_enable_interrupts(state);
+
+ if (node_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY;
+
+ /* Initialize the list node */
+ node_p->callback = cb;
+ node_p->length = 0;
+ node_p->next = 0;
+ node_p->resp = resp;
+ node_p->rqt = req;
+ node_p->state = CY_AS_REQUEST_LIST_STATE_QUEUED;
+ if (sync)
+ cy_as_request_node_set_sync(node_p);
+
+ /* Put the request into the queue */
+ mask = cy_as_hal_disable_interrupts();
+ if (ctxt_p->request_queue_p == 0) {
+ /* Empty queue */
+ ctxt_p->request_queue_p = node_p;
+ ctxt_p->last_node_p = node_p;
+ } else {
+ ctxt_p->last_node_p->next = node_p;
+ ctxt_p->last_node_p = node_p;
+ }
+ cy_as_hal_enable_interrupts(mask);
+ cy_as_ll_send_next_request(dev_p, ctxt_p);
+
+ if (!cy_as_device_is_in_callback(dev_p)) {
+ mask = cy_as_hal_disable_interrupts();
+ cy_as_mail_box_queued_data_handler(dev_p);
+ cy_as_hal_enable_interrupts(mask);
+ }
+
+ return ret;
+}
+
+static void
+cy_as_ll_send_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)
+{
+ (void)rqt;
+ (void)resp;
+ (void)ret;
+
+
+ cy_as_hal_assert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE);
+
+ /*
+ * storage the state to return to the caller
+ */
+ dev_p->ll_error = ret;
+
+ /*
+ * now wake the caller
+ */
+ cy_as_hal_wake(&dev_p->context[context]->channel);
+}
+
+cy_as_return_status_t
+cy_as_ll_send_request_wait_reply(
+ cy_as_device *dev_p,
+ /* The request to send */
+ cy_as_ll_request_response *req,
+ /* Storage for a reply, must be
+ * sure it is of sufficient size */
+ cy_as_ll_request_response *resp
+ )
+{
+ cy_as_return_status_t ret;
+ uint8_t context;
+ /* Larger 8 sec time-out to handle the init
+ * delay for slower storage devices in USB FS. */
+ uint32_t loopcount = 800;
+ cy_as_context *ctxt_p;
+
+ /* Get the context for the request */
+ context = cy_as_ll_request_response__get_context(req);
+ cy_as_hal_assert(context < CY_RQT_CONTEXT_COUNT);
+ ctxt_p = dev_p->context[context];
+
+ ret = cy_as_ll_send_request(dev_p, req, resp,
+ cy_true, cy_as_ll_send_callback);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret;
+
+ while (loopcount-- > 0) {
+ /*
+ * sleep while we wait on the response. receiving the reply will
+ * wake this thread. we will wait, at most 2 seconds (10 ms*200
+ * tries) before we timeout. note if the reply arrives, we will
+ * not sleep the entire 10 ms, just til the reply arrives.
+ */
+ cy_as_hal_sleep_on(&ctxt_p->channel, 10);
+
+ /*
+ * if the request has left the queue, it means the request has
+ * been sent and the reply has been received. this means we can
+ * return to the caller and be sure the reply has been received.
+ */
+ if (!cy_as_ll_is_in_queue(ctxt_p, req))
+ return dev_p->ll_error;
+ }
+
+ /* Remove the QueueListNode for this request. */
+ cy_as_ll_remove_request(dev_p, ctxt_p, req, cy_true);
+
+ return CY_AS_ERROR_TIMEOUT;
+}
+
+cy_as_return_status_t
+cy_as_ll_register_request_callback(
+ cy_as_device *dev_p,
+ uint8_t context,
+ cy_as_response_callback cb)
+{
+ cy_as_context *ctxt_p;
+ cy_as_hal_assert(context < CY_RQT_CONTEXT_COUNT);
+ ctxt_p = dev_p->context[context];
+
+ ctxt_p->request_callback = cb;
+ return CY_AS_ERROR_SUCCESS;
+}
+
+void
+cy_as_ll_request_response__pack(
+ cy_as_ll_request_response *req_p,
+ uint32_t offset,
+ uint32_t length,
+ void *data_p)
+{
+ uint16_t dt;
+ uint8_t *dp = (uint8_t *)data_p;
+
+ while (length > 1) {
+ dt = ((*dp++) << 8);
+ dt |= (*dp++);
+ cy_as_ll_request_response__set_word(req_p, offset, dt);
+ offset++;
+ length -= 2;
+ }
+
+ if (length == 1) {
+ dt = (*dp << 8);
+ cy_as_ll_request_response__set_word(req_p, offset, dt);
+ }
+}
+
+void
+cy_as_ll_request_response__unpack(
+ cy_as_ll_request_response *req_p,
+ uint32_t offset,
+ uint32_t length,
+ void *data_p)
+{
+ uint8_t *dp = (uint8_t *)data_p;
+
+ while (length-- > 0) {
+ uint16_t val = cy_as_ll_request_response__get_word
+ (req_p, offset++);
+ *dp++ = (uint8_t)((val >> 8) & 0xff);
+
+ if (length) {
+ length--;
+ *dp++ = (uint8_t)(val & 0xff);
+ }
+ }
+}
+
+extern cy_as_return_status_t
+cy_as_ll_send_status_response(
+ cy_as_device *dev_p,
+ uint8_t context,
+ uint16_t code,
+ uint8_t clear_storage)
+{
+ cy_as_return_status_t ret;
+ cy_as_ll_request_response resp;
+ cy_as_ll_request_response *resp_p = &resp;
+
+ cy_as_hal_mem_set(resp_p, 0, sizeof(resp));
+ resp_p->length = 1;
+ cy_as_ll_request_response__set_response(resp_p);
+ cy_as_ll_request_response__set_context(resp_p, context);
+
+ if (clear_storage)
+ cy_as_ll_request_response__set_clear_storage_flag(resp_p);
+
+ cy_as_ll_request_response__set_code(resp_p, CY_RESP_SUCCESS_FAILURE);
+ cy_as_ll_request_response__set_word(resp_p, 0, code);
+
+ ret = cy_as_send_one(dev_p, resp_p);
+
+ return ret;
+}
+
+extern cy_as_return_status_t
+cy_as_ll_send_data_response(
+ cy_as_device *dev_p,
+ uint8_t context,
+ uint16_t code,
+ uint16_t length,
+ void *data)
+{
+ cy_as_ll_request_response *resp_p;
+ uint16_t wlen;
+ uint8_t respbuf[256];
+
+ if (length > 192)
+ return CY_AS_ERROR_INVALID_SIZE;
+
+ /* Word length for bytes */
+ wlen = length / 2;
+
+ /* If byte length odd, add one more */
+ if (length % 2)
+ wlen++;
+
+ /* One for the length of field */
+ wlen++;
+
+ resp_p = (cy_as_ll_request_response *)respbuf;
+ cy_as_hal_mem_set(resp_p, 0, sizeof(respbuf));
+ resp_p->length = wlen;
+ cy_as_ll_request_response__set_context(resp_p, context);
+ cy_as_ll_request_response__set_code(resp_p, code);
+
+ cy_as_ll_request_response__set_word(resp_p, 0, length);
+ cy_as_ll_request_response__pack(resp_p, 1, length, data);
+
+ return cy_as_send_one(dev_p, resp_p);
+}
+
+static cy_bool
+cy_as_ll_is_e_p_transfer_related_request(cy_as_ll_request_response *rqt_p,
+ cy_as_end_point_number_t ep)
+{
+ uint16_t v;
+ uint8_t type = cy_as_ll_request_response__get_code(rqt_p);
+
+ if (cy_as_ll_request_response__get_context(rqt_p) !=
+ CY_RQT_USB_RQT_CONTEXT)
+ return cy_false;
+
+ /*
+ * when cancelling outstanding EP0 data transfers, any pending
+ * setup ACK requests also need to be cancelled.
+ */
+ if ((ep == 0) && (type == CY_RQT_ACK_SETUP_PACKET))
+ return cy_true;
+
+ if (type != CY_RQT_USB_EP_DATA)
+ return cy_false;
+
+ v = cy_as_ll_request_response__get_word(rqt_p, 0);
+ if ((cy_as_end_point_number_t)((v >> 13) & 1) != ep)
+ return cy_false;
+
+ return cy_true;
+}
+
+cy_as_return_status_t
+cy_as_ll_remove_ep_data_requests(cy_as_device *dev_p,
+ cy_as_end_point_number_t ep)
+{
+ cy_as_context *ctxt_p;
+ cy_as_ll_request_list_node *node_p;
+ uint32_t imask;
+
+ /*
+ * first, remove any queued requests
+ */
+ ctxt_p = dev_p->context[CY_RQT_USB_RQT_CONTEXT];
+ if (ctxt_p) {
+ for (node_p = ctxt_p->request_queue_p; node_p;
+ node_p = node_p->next) {
+ if (cy_as_ll_is_e_p_transfer_related_request
+ (node_p->rqt, ep)) {
+ cy_as_ll_remove_request(dev_p, ctxt_p,
+ node_p->rqt, cy_false);
+ break;
+ }
+ }
+
+ /*
+ * now, deal with any request that may be in transit
+ */
+ imask = cy_as_hal_disable_interrupts();
+
+ if (ctxt_p->request_queue_p != 0 &&
+ cy_as_ll_is_e_p_transfer_related_request
+ (ctxt_p->request_queue_p->rqt, ep) &&
+ cy_as_request_get_node_state(ctxt_p->request_queue_p) ==
+ CY_AS_REQUEST_LIST_STATE_WAITING) {
+ cy_as_hal_print_message("need to remove an in-transit "
+ "request to antioch\n");
+
+ /*
+ * if the request has not been fully sent to west bridge
+ * yet, abort sending. otherwise, terminate the request
+ * with a CANCELED status. firmware will already have
+ * terminated this transfer.
+ */
+ if (dev_p->ll_sending_rqt)
+ dev_p->ll_abort_curr_rqt = cy_true;
+ else {
+ uint32_t state;
+
+ node_p = ctxt_p->request_queue_p;
+ if (node_p->callback)
+ node_p->callback(dev_p, ctxt_p->number,
+ node_p->rqt, node_p->resp,
+ CY_AS_ERROR_CANCELED);
+
+ ctxt_p->request_queue_p = node_p->next;
+ state = cy_as_hal_disable_interrupts();
+ cy_as_hal_c_b_free(node_p);
+ cy_as_hal_enable_interrupts(state);
+ }
+ }
+
+ cy_as_hal_enable_interrupts(imask);
+ }
+
+ return CY_AS_ERROR_SUCCESS;
+}
projects / mv-sheeva.git / blobdiff