Wiznet makers

/**
\brief  Create Mutex
The function creates a mutex.
\param[in]      mutexName_p         The name of the mutex to create.
\param[out]     pMutex_p            Pointer to store the created mutex.
\return The function returns a tOplkError error code.
\retval kErrorOk                    Mutex was successfully created.
\retval kErrorNoFreeInstance        An error occurred while creating the mutex.
\ingroup module_target
*/
//------------------------------------------------------------------------------
tOplkError target_createMutex(const char* mutexName_p,
                              OPLK_MUTEX_T* pMutex_p)
{
 
  UNUSED_PARAMETER(mutexName_p);
    pMutex_p =  osMutexNew(NULL);
    return kErrorOk;
}
 
//------------------------------------------------------------------------------
/**
\brief  Destroy Mutex
The function destroys a mutex.
\param[in]      mutexId_p           The ID of the mutex to destroy.
\ingroup module_target
*/
//------------------------------------------------------------------------------
void target_destroyMutex(OPLK_MUTEX_T mutexId_p)
{
//CloseHandle(mutexId_p);
    if(mutexId_p != NULL){
        osMutexDelete(mutexId_p);
    }
}
 
//------------------------------------------------------------------------------
/**
\brief  Lock Mutex
The function locks a mutex.
\param[in]      mutexId_p           The ID of the mutex to lock.
\return The function returns a tOplkError error code.
\retval kErrorOk                    Mutex was successfully locked.
\retval kErrorNoFreeInstance        An error occurred while locking the mutex.
\ingroup module_target
*/
//------------------------------------------------------------------------------
tOplkError target_lockMutex(OPLK_MUTEX_T mutexId_p)
{
  
    tOplkError  ret;
      osStatus_t status;
 
    ret = kErrorOk;
        if (mutexId_p != NULL) {
            status = osMutexAcquire(mutexId_p, osWaitForever);
            if (status != osOK)  {
                // handle failure code
            }
        }    
    return ret;
}
 
//------------------------------------------------------------------------------
/**
\brief  Unlock Mutex
The function unlocks a mutex.
\param[in]      mutexId_p           The ID of the mutex to unlock.
\ingroup module_target
*/
//------------------------------------------------------------------------------
void target_unlockMutex(OPLK_MUTEX_T mutexId_p)
{
    //ReleaseMutex(mutexId_p);
    osStatus_t status;
 
  if (mutexId_p != NULL)  {
    status = osMutexRelease(mutexId_p);
    if (status != osOK)  {
      // handle failure code
    }
  }
}
 
int target_lock(void)
{
    target_enableGlobalInterrupt(FALSE);
 
    return 0;
}
int target_unlock(void)
{
    target_enableGlobalInterrupt(TRUE);
 
    return 0;
}

//------------------------------------------------------------------------------
/**
\brief  Event handler thread function
This function contains the main function for the event handler thread.
\param[in]      arg                 Thread parameter. Used to get the instance structure.
\return The function returns the thread exit code.
*/
//------------------------------------------------------------------------------
static void eventThread(void* arg)
{
    const tEventkCalInstance*   pInstance = (const tEventkCalInstance*)arg;
    osStatus_t waitResult;
 
    DEBUG_LVL_EVENTK_TRACE("Kernel event thread %d waiting for events...\n", GetCurrentThreadId());
    while (!pInstance->fStopThread)
    {
      waitResult = osSemaphoreAcquire(pInstance->semKernelData, 100UL);       // wait for max. 10 ticks for semaphore token to get available
            switch (waitResult) {
                case osOK:
                    if (eventkcal_getEventCountCircbuf(kEventQueueKInt) > 0)
                    {
                            eventkcal_processEventCircbuf(kEventQueueKInt);
                    }
                    else
                    {
                            if (eventkcal_getEventCountCircbuf(kEventQueueU2K) > 0)
                            {
                                    eventkcal_processEventCircbuf(kEventQueueU2K);
                            }
                    }
                    break;
                case osErrorResource:
                    DEBUG_LVL_ERROR_TRACE("kernel event osErrorResource!\n");
                    break;
                case osErrorParameter:
                    DEBUG_LVL_ERROR_TRACE("kernel event osErrorParameter!\n");
                    break;
                case osErrorTimeout:
                    DEBUG_LVL_ERROR_TRACE("kernel event timeout!\n");
                    break;
                default:
                    DEBUG_LVL_ERROR_TRACE("%s() Semaphore wait unknown error! \n",
                                      __func__);
                    break;
            }
    }
 
    DEBUG_LVL_EVENTK_TRACE("Kernel event thread is exiting!\n");
 
}

//------------------------------------------------------------------------------
/**
\brief  Send Tx buffer
This function sends the Tx buffer.
\param[in,out]  pBuffer_p           Tx buffer descriptor
\return The function returns a tOplkError error code.
\ingroup module_edrv
*/
//------------------------------------------------------------------------------
tOplkError edrv_sendTxBuffer(tEdrvTxBuffer* pBuffer_p)
{
    int    sockRet;
 
    // Check parameter validity
    ASSERT(pBuffer_p != NULL);
 
    FTRACE_MARKER("%s", __func__);
 
    if (pBuffer_p->txBufferNumber.pArg != NULL)
        return kErrorInvalidOperation;
 
    if (getLinkStatus(edrvInstance_l.initParam.pDevName) == FALSE)
    {
        /* If there is no link, we pretend that the packet is sent and immediately call
         * tx handler. Otherwise the stack would hang! */
        if (pBuffer_p->pfnTxHandler != NULL)
        {
            pBuffer_p->pfnTxHandler(pBuffer_p);
        }
    }
    else
    {
        //pthread_mutex_lock(&edrvInstance_l.mutex);
              osMutexAcquire(edrvInstance_l.mutex,osWaitForever);
        if (edrvInstance_l.pTransmittedTxBufferLastEntry == NULL)
        {
            edrvInstance_l.pTransmittedTxBufferLastEntry = pBuffer_p;
            edrvInstance_l.pTransmittedTxBufferFirstEntry = pBuffer_p;
        }
        else
        {
            edrvInstance_l.pTransmittedTxBufferLastEntry->txBufferNumber.pArg = pBuffer_p;
            edrvInstance_l.pTransmittedTxBufferLastEntry = pBuffer_p;
        }
        //pthread_mutex_unlock(&edrvInstance_l.mutex);
                osMutexRelease(edrvInstance_l.mutex);
 
        sockRet = send(edrvInstance_l.sock, (u_char*)pBuffer_p->pBuffer, (int)pBuffer_p->txFrameSize);
        if (sockRet < 0)
        {
            DEBUG_LVL_EDRV_TRACE("%s() send() returned %d\n", __func__, sockRet);
            return kErrorInvalidOperation;
        }
        else
        {
            packetHandler((u_char*)&edrvInstance_l, sockRet, pBuffer_p->pBuffer);
        }
    }
 
    return kErrorOk;
}

//------------------------------------------------------------------------------
/**
\brief  Edrv worker thread
This function implements the edrv worker thread. It is responsible to receive frames
\param[in,out]  pArgument_p         User specific pointer pointing to the instance structure
\return The function returns a thread error code.
*/
//------------------------------------------------------------------------------
static void workerThread(void* pArgument_p)
{
    tEdrvInstance*  pInstance = (tEdrvInstance*)pArgument_p;
    int             rawSockRet;
    u_char          aBuffer[EDRV_MAX_FRAME_SIZE];
 
    DEBUG_LVL_EDRV_TRACE("%s(): ThreadId:%ld\n", __func__, syscall(SYS_gettid));
 
    // signal that thread is successfully started
    //sem_post(&pInstance->syncSem);
     osSemaphoreRelease(pInstance->syncSem);
 
    while (edrvInstance_l.fStartCommunication)
    {
        rawSockRet = recvfrom(edrvInstance_l.sock, aBuffer, EDRV_MAX_FRAME_SIZE, 0, 0);
        if (rawSockRet > 0)
        {
            packetHandler(pInstance, rawSockRet, aBuffer);
        }
    }
    edrvInstance_l.fThreadIsExited = TRUE;
 
}