Subversion Repositories funbase_ip_library

/*

 * Copyright (c) 2010, Mentor Graphics Corporation

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 * 3. Neither the name of the <ORGANIZATION> nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

#include <openmcapi.h>

extern mcapi_endpoint_t     MCAPI_CTRL_TX_Endp;

extern MCAPI_BUF_QUEUE      MCAPI_Buf_Wait_List;

extern mcapi_endpoint_t     MCAPI_CTRL_RX_Endp;

/*************************************************************************

*

*   FUNCTION

*

*       mcapi_check_resume

*

*   DESCRIPTION

*

*       Checks if any pending requests in the system should be resumed.

*

*   INPUTS

*

*       type                    The type of request to check.

*       endpoint                The endpoint for which the request is

*                               suspended on some action.

*       *endp_ptr               If data was received, a pointer to the

*                               endpoint for which data was received.

*       byte_count              If the type is MCAPI_REQ_TX_FIN or

*                               MCAPI_REQ_RX_FIN, the number of bytes

*                               pending on the endpoint.

*       status                  The status to set in the request structure.

*

*   OUTPUTS

*

*       None.

*

*************************************************************************/

void mcapi_check_resume(int type, mcapi_endpoint_t endpoint,

                        MCAPI_ENDPOINT *endp_ptr, size_t byte_count,

                        mcapi_status_t status)

{

    mcapi_request_t     *request, *next_ptr;

    MCAPI_GLOBAL_DATA   *node_data;

    MCAPI_BUFFER        *rx_buf;

    mcapi_boolean_t     data_copied = 0;

    /* Get a pointer to the global node list. */

    node_data = mcapi_get_node_data();

    /* Get a pointer to the first entry in the request queue. */

    request = node_data->mcapi_local_req_queue.flink;

    /* Check each request to see if the operation has been completed. */

    while (request)

    {

        /* Get a pointer to the next entry. */

        next_ptr = request->mcapi_next;

        switch (type)

        {

            /* An endpoint associated with a request structure has been

             * deleted.

             */

            case MCAPI_REQ_DELETED:

                /* If the operation is waiting for something to happen

                 * on the send side, and the endpoint matches the send

                 * endpoint.

                 */

                if ( ((request->mcapi_type == MCAPI_REQ_TX_FIN) ||

                      (request->mcapi_type == MCAPI_REQ_TX_OPEN) ||

                      (request->mcapi_type == MCAPI_REQ_CONNECTED)) &&

                      (request->mcapi_target_endp == endpoint) )

                {

                    mcapi_resume(node_data, request, status);

                }

                /* If the operation is waiting for something to happen

                 * on the receive side, and the endpoint matches the receive

                 * endpoint.

                 */

                else if ( ((request->mcapi_type == MCAPI_REQ_RX_FIN) ||

                           (request->mcapi_type == MCAPI_REQ_RX_OPEN) ||

                           (request->mcapi_type == MCAPI_REQ_CONNECTED)) &&

                          (request->mcapi_target_endp == endpoint) )

                {

                    mcapi_resume(node_data, request, status);

                }

                break;

            /* The connection has been closed. */

            case MCAPI_REQ_CLOSED:

                /* No matter what the reason the thread is suspended, if the

                 * connection has been closed, resume the thread.

                 */

                if (request->mcapi_target_endp == endpoint)

                {

                    /* Resume the task. */

                    mcapi_resume(node_data, request, status);

                }

                break;

            /* The send side of an endpoint has been opened. */

            case MCAPI_REQ_TX_OPEN:

                /* If the request structure is waiting for the send side

                 * of the connection to open.

                 */

                if (request->mcapi_target_endp == endpoint)

                {

                    /* Resume the task. */

                    mcapi_resume(node_data, request, status);

                }

                break;

            /* Data associated with a request structure has been transmitted

             * successfully, or the transmit has been canceled.

             */

            case MCAPI_REQ_TX_FIN:

                /* If the request structure is waiting for outgoing data to be

                 * successfully transmitted.

                 */

                if ( (request->mcapi_type == MCAPI_REQ_TX_FIN) &&

                     (request->mcapi_target_endp == endpoint) )

                {

                    /* Indicate the number of bytes transmitted. */

                    request->mcapi_byte_count = byte_count;

                    /* Resume the task. */

                    mcapi_resume(node_data, request, status);

                }

                break;

            /* The receive side of an endpoint has been opened. */

            case MCAPI_REQ_RX_OPEN:

                /* If the request structure is waiting for the receive side

                 * of the connection to open.

                 */

                if (request->mcapi_target_endp == endpoint)

                {

                    /* Resume the task. */

                    mcapi_resume(node_data, request, status);

                }

                break;

            /* Data associated with a request structure has been received

             * successfully, or the receive has been canceled.

             */

            case MCAPI_REQ_RX_FIN:

                /* If the request structure is waiting for data to be

                 * received on the endpoint.

                 */

                if ( (request->mcapi_type == MCAPI_REQ_RX_FIN) &&

                     (request->mcapi_target_endp == endpoint) )

                {

                    switch (request->mcapi_chan_type)

                    {

                        case MCAPI_MSG_TYPE:

                            /* Ensure the data will fit in the buffer. */

                            if (byte_count <= request->mcapi_buf_size)

                            {

                                /* Copy the data into the user buffer. */

                                request->mcapi_byte_count =

                                    msg_recv_copy_data(endp_ptr, request->mcapi_buffer);

                                /* Data has been successfully copied. */

                                data_copied = MCAPI_TRUE;

                            }

                            /* The data is too big for the user buffer.  Leave

                             * the data on the receive queue for a subsequent

                             * receive call.

                             */

                            else

                            {

                                status = MCAPI_ERR_MSG_TRUNCATED;

                            }

                            break;

                        case MCAPI_CHAN_PKT_TYPE:

                            /* Get a pointer to the head buffer. */

                            rx_buf = endp_ptr->mcapi_rx_queue.head;

                            /* Set the user buffer to the incoming buffer. */

                            *(request->mcapi_pkt) =

                                &rx_buf->buf_ptr[MCAPI_HEADER_LEN];

                            /* Set the size of the incoming buffer. */

                            request->mcapi_byte_count =

                                rx_buf->buf_size - MCAPI_HEADER_LEN;

                            /* Data has been successfully copied. */

                            data_copied = MCAPI_TRUE;

                            break;

                        default:

                            break;

                    }

                    /* Resume the task. */

                    mcapi_resume(node_data, request, status);

                }

                break;

            /* An endpoint associated with a pending request has been

             * created.

             */

            case MCAPI_REQ_CREATED:

                /* If the request structure is waiting for an endpoint to be

                 * created.

                 */

                if ( (request->mcapi_type == MCAPI_REQ_CREATED) &&

                     (mcapi_encode_endpoint(request->mcapi_target_node_id,

                                            request->mcapi_target_port_id) == endpoint) )

                {

                    /* If this is a local call, fill in the endpoint pointer. */

                    if (request->mcapi_endp_ptr)

                    {

                        *(request->mcapi_endp_ptr) = endpoint;

                    }

                    mcapi_resume(node_data, request, status);

                }

                break;

            /* A connection between two endpoints has been made. */

            case MCAPI_REQ_CONNECTED:

                /* If the request structure is waiting for a connection

                 * between two endpoints to be made.

                 */

                if ( (request->mcapi_type == MCAPI_REQ_CONNECTED) &&

                     (request->mcapi_target_endp == endpoint) )

                {

                    /* Resume the task. */

                    mcapi_resume(node_data, request, status);

                }

                break;

            default:

                break;

        }

        /* Get the next request entry in the list. */

        request = next_ptr;

    }

    /* Multiple request structures could have been suspended on the same

     * receive operation; therefore, the data must not be removed from

     * the queue until all request structures have been serviced.

     */

    if (data_copied)

    {

        /* Remove the buffer from the receive queue. */

        rx_buf = mcapi_dequeue(&endp_ptr->mcapi_rx_queue);

        if (endp_ptr->mcapi_chan_type == MCAPI_CHAN_PKT_TYPE)

        {

            /* Add the receive buffer structure to the list of

             * buffers waiting to be freed by the application.

             */

            mcapi_enqueue(&MCAPI_Buf_Wait_List, rx_buf);

        }

        else

        {

            /* Return the message buffer to the pool of available buffers. */

            ((MCAPI_INTERFACE*)(rx_buf->mcapi_dev_ptr))->

                mcapi_recover_buffer(rx_buf);

        }

    }

}

/*************************************************************************

*

*   FUNCTION

*

*       mcapi_resume

*

*   DESCRIPTION

*

*       Resume a specific task.

*

*   INPUTS

*

*       *node_data              A pointer to the global MCAPI node data

*                               structure.

*       *request                The request structure associated with the

*                               task to resume.

*       status                  The status to set in the request structure.

*

*   OUTPUTS

*

*       None.

*

*************************************************************************/

void mcapi_resume(MCAPI_GLOBAL_DATA *node_data, mcapi_request_t *request,

                  mcapi_status_t status)

{

    /* Set the status so the blocking operation knows if the operation

     * completed successfully.

     */

    request->mcapi_status = status;

    /* Remove this request from the list. */

    mcapi_remove(&node_data->mcapi_local_req_queue, request);

    /* Resume the task. */

    MCAPI_Resume_Task(request);

}

/*************************************************************************

*

*   FUNCTION

*

*       mcapi_find_request

*

*   DESCRIPTION

*

*       Find a matching request structure on the global list.

*

*   INPUTS

*

*       *target_request         The target request to find.

*       *node_data              A pointer to the global node structure

*                               for the system.

*

*   OUTPUTS

*

*       A pointer to the request structure or MCAPI_NULL if the structure

*       could not be found.

*

*************************************************************************/

mcapi_request_t *mcapi_find_request(mcapi_request_t *target_request,

                                    MCAPI_REQ_QUEUE *req_queue)

{

    mcapi_request_t     *req_ptr;

    /* Get a pointer to the first entry in the request queue. */

    req_ptr = req_queue->flink;

    /* Search the list looking for the target entry. */

    while (req_ptr)

    {

        if ( (req_ptr->mcapi_requesting_node_id == target_request->mcapi_requesting_node_id) &&

             (req_ptr->mcapi_type == target_request->mcapi_type) &&

             (req_ptr->mcapi_target_endp == target_request->mcapi_target_endp) &&

             (req_ptr->mcapi_target_node_id == target_request->mcapi_target_node_id) &&

             (req_ptr->mcapi_target_port_id == target_request->mcapi_target_port_id) )

        {

            break;

        }

        /* Get a pointer to the next request structure. */

        req_ptr = req_ptr->mcapi_next;

    }

    return (req_ptr);

}