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>

MCAPI_MUTEX MCAPI_Mutex;

pthread_t   MCAPI_Control_Task_TCB;

static inline long ms_to_s(long ms)

{

    return ms / 1000;

}

static inline long ns_to_s(long ns)

{

    return ns / 1000000000;

}

static inline long ms_to_ns(long ms)

{

    return ms * 1000000;

}

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

*

*   FUNCTION

*

*       MCAPI_Init_OS

*

*   DESCRIPTION

*

*       Initializes OS specific data structures.

*

*   INPUTS

*

*       None.

*

*   OUTPUTS

*

*       MCAPI_SUCCESS

*       MCAPI_ERR_GENERAL

*

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

mcapi_status_t MCAPI_Init_OS(void)

{

    int status;

    /* Create the task that will be used for receiving status

     * messages.

     */

    status = pthread_create(&MCAPI_Control_Task_TCB, NULL,

                            mcapi_process_ctrl_msg, NULL);

    if (status)

        return MCAPI_ERR_GENERAL;

    return MCAPI_SUCCESS;

}

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

*

*   FUNCTION

*

*       MCAPI_Exit_OS

*

*   DESCRIPTION

*

*       Release OS specific data structures.

*

*   INPUTS

*

*       None.

*

*   OUTPUTS

*

*       None.

*

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

void MCAPI_Exit_OS(void)

{

}

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

*

*   FUNCTION

*

*       MCAPI_Resume_Task

*

*   DESCRIPTION

*

*       Resumes a suspended system task.

*

*   INPUTS

*

*       *request                The request structure on which the

*                               suspended task is suspended.

*

*   OUTPUTS

*

*       MCAPI_SUCCESS

*       MCAPI_ERR_GENERAL

*

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

mcapi_status_t MCAPI_Resume_Task(mcapi_request_t *request)

{

    int status;

    /* If multiple requests are suspending on the same condition, we use

     * mcapi_cond_ptr. */

    if (request->mcapi_cond.mcapi_cond_ptr)

        status = pthread_cond_signal(request->mcapi_cond.mcapi_cond_ptr);

    else

        status = pthread_cond_signal(&request->mcapi_cond.mcapi_cond);

    if (status)

        return MCAPI_ERR_GENERAL;

    return MCAPI_SUCCESS;

}

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

*

*   FUNCTION

*

*       MCAPI_Suspend_Task

*

*   DESCRIPTION

*

*       Suspends a system task.

*

*   INPUTS

*

*       *node_data              A pointer to the global node data

*                               structure.

*       *request                A pointer to the request associated

*                               with the thread being suspended.

*       *mcapi_os               A pointer to the OS specific structure

*                               containing suspend/resume data.

*       timeout                 The number of milliseconds to suspend

*                               pending completion of the request.

*

*   OUTPUTS

*

*       MCAPI_SUCCESS

*       MCAPI_ERR_GENERAL

*

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

mcapi_status_t MCAPI_Suspend_Task(MCAPI_GLOBAL_DATA *node_data,

                                  mcapi_request_t *request,

                                  MCAPI_COND_STRUCT *condition,

                                  mcapi_timeout_t timeout)

{

    struct timespec ts;

    int status = 0;

    /* If a request structure was passed into the routine. */

    if (request)

    {

        /* Initialize the condition variable with default parameters. */

        status = pthread_cond_init(&request->mcapi_cond.mcapi_cond, NULL);

        if (status == 0)

        {

            /* Add the request to the queue of pending requests. */

            mcapi_enqueue(&node_data->mcapi_local_req_queue, request);

        }

    }

    if (status == 0)

    {

        /* If no timeout value was specified. */

        if (timeout == MCAPI_TIMEOUT_INFINITE)

        {

            status = pthread_cond_wait(&condition->mcapi_cond, &MCAPI_Mutex);

        }

        else

        {

            long subsecond_ms;

            long total_ns;

            clock_gettime(CLOCK_REALTIME, &ts);

            /* Add timeout to ts, accounting for nsec overflow. */

            subsecond_ms = timeout % 1000;

            total_ns = ts.tv_nsec + ms_to_ns(subsecond_ms);

            ts.tv_sec += ms_to_s(timeout) + ns_to_s(total_ns);

            ts.tv_nsec = total_ns % 1000000000;

            status = pthread_cond_timedwait(&condition->mcapi_cond,

                                            &MCAPI_Mutex, &ts);

        }

        /* Uninitialize the condition variable. */

        status = pthread_cond_destroy(&condition->mcapi_cond);

    }

    if (status)

        return MCAPI_ERR_GENERAL;

    return MCAPI_SUCCESS;

}

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

*

*   FUNCTION

*

*       MCAPI_Cleanup_Task

*

*   DESCRIPTION

*

*       Terminates the current thread.

*

*   INPUTS

*

*       None.

*

*   OUTPUTS

*

*       None.

*

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

void MCAPI_Cleanup_Task(void)

{

    pthread_exit(NULL);

}

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

*

*   FUNCTION

*

*       MCAPI_Init_Condition

*

*   DESCRIPTION

*

*       Sets an OS specific condition for resuming a task in the future.

*

*   INPUTS

*

*       *os_cond                A pointer to the OS specific structure

*                               containing suspend/resume data.

*

*   OUTPUTS

*

*       None.

*

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

void MCAPI_Init_Condition(MCAPI_COND_STRUCT *condition)

{

    /* Initialize the condition variable with default parameters. */

    pthread_cond_init(&condition->mcapi_cond, NULL);

}

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

*

*   FUNCTION

*

*       MCAPI_Set_Condition

*

*   DESCRIPTION

*

*       Sets an OS specific condition for resuming a task in the future.

*

*   INPUTS

*

*       *request                A request structure that will trigger

*                               a future task resume.

*       *os_cond                The condition to use for resuming the

*                               task.

*

*   OUTPUTS

*

*       None.

*

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

void MCAPI_Set_Condition(mcapi_request_t *request, MCAPI_COND_STRUCT *condition)

{

    request->mcapi_cond.mcapi_cond_ptr = &condition->mcapi_cond;

}

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

*

*   FUNCTION

*

*       MCAPI_Clear_Condition

*

*   DESCRIPTION

*

*       Clears a previously set OS condition.

*

*   INPUTS

*

*       *request                A request structure that will trigger

*                               a future task resume.

*

*   OUTPUTS

*

*       None.

*

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

void MCAPI_Clear_Condition(mcapi_request_t *request)

{

    request->mcapi_cond.mcapi_cond_ptr = MCAPI_NULL;

}

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

*

*   FUNCTION

*

*       MCAPI_Create_Mutex

*

*   DESCRIPTION

*

*       Creates a system mutex.

*

*   INPUTS

*

*       *mutex                  Pointer to the mutex control block.

*       *name                   Name of the mutex.

*

*   OUTPUTS

*

*       MCAPI_SUCCESS

*

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

mcapi_status_t MCAPI_Create_Mutex(MCAPI_MUTEX *mutex, char *name)

{

    int status;

    status = pthread_mutex_init(mutex, NULL);

    if (status)

        return MCAPI_ERR_GENERAL;

    return MCAPI_SUCCESS;

}

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

*

*   FUNCTION

*

*       MCAPI_Delete_Mutex

*

*   DESCRIPTION

*

*       Destroyes a system mutex.

*

*   INPUTS

*

*       *mutex                  Pointer to the mutex control block.

*

*   OUTPUTS

*

*       MCAPI_SUCCESS

*       MCAPI_ERR_GENERAL

*

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

mcapi_status_t MCAPI_Delete_Mutex(MCAPI_MUTEX *mutex)

{

    int status;

    status = pthread_mutex_destroy(mutex);

    if (status)

        return MCAPI_ERR_GENERAL;

    return MCAPI_SUCCESS;

}

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

*

*   FUNCTION

*

*       MCAPI_Obtain_Mutex

*

*   DESCRIPTION

*

*       Obtains a system mutex.

*

*   INPUTS

*

*       *mutex              Pointer to the mutex control block.

*

*   OUTPUTS

*

*       MCAPI_SUCCESS

*       MCAPI_ERR_GENERAL

*

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

mcapi_status_t MCAPI_Obtain_Mutex(MCAPI_MUTEX *mutex)

{

    int status;

    status = pthread_mutex_lock(mutex);

    if (status)

        return MCAPI_ERR_GENERAL;

    return MCAPI_SUCCESS;

}

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

*

*   FUNCTION

*

*       MCAPI_Release_Mutex

*

*   DESCRIPTION

*

*       Releases a system mutex.

*

*   INPUTS

*

*       *mutex              Pointer to the mutex control block.

*

*   OUTPUTS

*

*       MCAPI_SUCCESS

*       MCAPI_ERR_GENERAL

*

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

mcapi_status_t MCAPI_Release_Mutex(MCAPI_MUTEX *mutex)

{

    int status;

    status = pthread_mutex_unlock(mutex);

    if (status)

        return MCAPI_ERR_GENERAL;

    return MCAPI_SUCCESS;

}

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

*

*   FUNCTION

*

*       MCAPI_Set_RX_Event

*

*   DESCRIPTION

*

*       Sets an event indicating that data is ready to be received.

*

*   INPUTS

*

*       None.

*

*   OUTPUTS

*

*       MCAPI_SUCCESS

*

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

mcapi_status_t MCAPI_Set_RX_Event(void)

{

    mcapi_rx_data();

    return MCAPI_SUCCESS;

}

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

*

*   FUNCTION

*

*       MCAPI_Lock_RX_Queue

*

*   DESCRIPTION

*

*       Protect RX queue from concurrent accesses.  No work is required

*       in this routine since Linux receives data from the context of

*       the driver RX thread.

*

*   INPUTS

*

*       None.

*

*   OUTPUTS

*

*       Unused.

*

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

mcapi_int_t MCAPI_Lock_RX_Queue(void)

{

    return 0;

}

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

*

*   FUNCTION

*

*       MCAPI_Unlock_RX_Queue

*

*   DESCRIPTION

*

*       Protect RX queue from concurrent accesses.  No work is required

*       in this routine since Linux receives data from the context of

*       the driver RX thread.

*

*   INPUTS

*

*       cookie                  Unused.

*

*   OUTPUTS

*

*       None.

*

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

void MCAPI_Unlock_RX_Queue(mcapi_int_t cookie)

{

}

void MCAPI_Sleep(unsigned int secs)

{

        /* XXX We can use select() to implement sub-second sleeps in the future. */

    sleep(secs);

}