Adding TCI6498 support in RM sample init lib
[keystone-rtos/edma3_lld.git] / packages / ti / sdo / edma3 / rm / sample / src / sample_cs.c
old mode 100644 (file)
new mode 100755 (executable)
similarity index 71%
rename from packages/ti/sdo/edma3/rm/sample/src/bios6_edma3_rm_sample_cs.c
rename to packages/ti/sdo/edma3/rm/sample/src/sample_cs.c
index ed83e91..d9eb756
-/*******************************************************************************
-**+--------------------------------------------------------------------------+**
-**|                            ****                                          |**
-**|                            ****                                          |**
-**|                            ******o***                                    |**
-**|                      ********_///_****                                   |**
-**|                      ***** /_//_/ ****                                   |**
-**|                       ** ** (__/ ****                                    |**
-**|                           *********                                      |**
-**|                            ****                                          |**
-**|                            ***                                           |**
-**|                                                                          |**
-**|         Copyright (c) 1998-2006 Texas Instruments Incorporated           |**
-**|                        ALL RIGHTS RESERVED                               |**
-**|                                                                          |**
-**| Permission is hereby granted to licensees of Texas Instruments           |**
-**| Incorporated (TI) products to use this computer program for the sole     |**
-**| purpose of implementing a licensee product based on TI products.         |**
-**| No other rights to reproduce, use, or disseminate this computer          |**
-**| program, whether in part or in whole, are granted.                       |**
-**|                                                                          |**
-**| TI makes no representation or warranties with respect to the             |**
-**| performance of this computer program, and specifically disclaims         |**
-**| any responsibility for any damages, special or consequential,            |**
-**| connected with the use of this program.                                  |**
-**|                                                                          |**
-**+--------------------------------------------------------------------------+**
-*******************************************************************************/
-
-/** \file   bios6_edma3_rm_sample_cs.c
-
-    \brief  Sample functions showing the implementation of Critical section
-            entry/exit routines and various semaphore related routines (all OS
-            depenedent). These implementations MUST be provided by the user /
-            application, using the EDMA3 Resource Manager, for its
-            correct functioning.
-
-    (C) Copyright 2006, Texas Instruments, Inc
-
-    \version    1.0   Anuj Aggarwal         - Created
-
- */
-
-#include <ti/sysbios/family/c64p/EventCombiner.h>
-#include <ti/sysbios/hal/Hwi.h>
-#include <ti/sysbios/knl/Task.h>
-#include <ti/sysbios/ipc/Semaphore.h>
-
-#include <ti/sdo/edma3/rm/sample/bios6_edma3_rm_sample.h>
-
-
-
-/**
- * \brief   EDMA3 OS Protect Entry
- *
- *      This function saves the current state of protection in 'intState'
- *      variable passed by caller, if the protection level is
- *      EDMA3_OS_PROTECT_INTERRUPT. It then applies the requested level of
- *      protection.
- *      For EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION and
- *      EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR, variable 'intState' is ignored,
- *      and the requested interrupt is disabled.
- *      For EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR, '*intState' specifies the
- *      Transfer Controller number whose interrupt needs to be disabled.
- *
- * \param   level is numeric identifier of the desired degree of protection.
- * \param   intState is memory location where current state of protection is
- *      saved for future use while restoring it via edma3OsProtectExit() (Only
- *      for EDMA3_OS_PROTECT_INTERRUPT protection level).
- * \return  None
- */
-void edma3OsProtectEntry (int level, unsigned int *intState)
-    {
-    if (((level == EDMA3_OS_PROTECT_INTERRUPT)
-        || (level == EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR))
-        && (intState == NULL))
-        {
-        return;
-        }
-    else
-        {
-        switch (level)
-            {
-            /* Disable all (global) interrupts */
-            case EDMA3_OS_PROTECT_INTERRUPT :
-                *intState = Hwi_disable();
-                break;
-
-            /* Disable scheduler */
-            case EDMA3_OS_PROTECT_SCHEDULER :
-                               Task_disable();
-                break;
-
-            /* Disable EDMA3 transfer completion interrupt only */
-            case EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION :
-                EventCombiner_disableEvent(ccXferCompInt);
-                break;
-
-            /* Disable EDMA3 CC error interrupt only */
-            case EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR :
-                EventCombiner_disableEvent(ccErrorInt);
-                break;
-
-            /* Disable EDMA3 TC error interrupt only */
-            case EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR :
-                switch (*intState)
-                    {
-                    case 0:
-                    case 1:
-                    case 2:
-                    case 3:
-                    case 4:
-                    case 5:
-                    case 6:
-                    case 7:
-                        /* Fall through... */
-                        /* Disable the corresponding interrupt */
-                        EventCombiner_disableEvent(tcErrorInt[*intState]);
-                        break;
-
-                     default:
-                        break;
-                    }
-
-                break;
-
-            default:
-                break;
-            }
-        }
-    }
-
-
-/**
- * \brief   EDMA3 OS Protect Exit
- *
- *      This function undoes the protection enforced to original state
- *      as is specified by the variable 'intState' passed, if the protection
- *      level is EDMA3_OS_PROTECT_INTERRUPT.
- *      For EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION and
- *      EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR, variable 'intState' is ignored,
- *      and the requested interrupt is enabled.
- *      For EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR, 'intState' specifies the
- *      Transfer Controller number whose interrupt needs to be enabled.
- * \param   level is numeric identifier of the desired degree of protection.
- * \param   intState is original state of protection at time when the
- *      corresponding edma3OsProtectEntry() was called (Only
- *      for EDMA3_OS_PROTECT_INTERRUPT protection level).
- * \return  None
- */
-void edma3OsProtectExit (int level, unsigned int intState)
-    {
-    switch (level)
-        {
-        /* Enable all (global) interrupts */
-        case EDMA3_OS_PROTECT_INTERRUPT :
-            Hwi_restore(intState);
-            break;
-
-        /* Enable scheduler */
-        case EDMA3_OS_PROTECT_SCHEDULER :
-            Task_enable();
-            break;
-
-        /* Enable EDMA3 transfer completion interrupt only */
-        case EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION :
-            EventCombiner_enableEvent(ccXferCompInt);
-            break;
-
-        /* Enable EDMA3 CC error interrupt only */
-        case EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR :
-            EventCombiner_enableEvent(ccErrorInt);
-            break;
-
-        /* Enable EDMA3 TC error interrupt only */
-        case EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR :
-            switch (intState)
-                {
-                case 0:
-                case 1:
-                case 2:
-                case 3:
-                case 4:
-                case 5:
-                case 6:
-                case 7:
-                    /* Fall through... */
-                    /* Enable the corresponding interrupt */
-                    EventCombiner_enableEvent(tcErrorInt[intState]);
-                    break;
-
-                 default:
-                    break;
-                }
-
-            break;
-
-        default:
-            break;
-        }
-    }
-
-
-/**
-  * Counting Semaphore related functions (OS dependent) should be
-  * called/implemented by the application. A handle to the semaphore
-  * is required while opening the resource manager instance.
-  */
-
-/**
- * \brief   EDMA3 OS Semaphore Create
- *
- *      This function creates a counting semaphore with specified
- *      attributes and initial value. It should be used to create a semaphore
- *      with initial value as '1'. The semaphore is then passed by the user
- *      to the EDMA3 RM for proper sharing of resources.
- * \param   initVal [IN] is initial value for semaphore
- * \param   semParams [IN] is the semaphore attributes.
- * \param   hSem [OUT] is location to recieve the handle to just created
- *      semaphore
- * \return  EDMA3_RM_SOK if succesful, else a suitable error code.
- */
-EDMA3_RM_Result edma3OsSemCreate(int initVal,
-                                                       const Semaphore_Params *semParams,
-                               EDMA3_OS_Sem_Handle *hSem)
-    {
-    EDMA3_RM_Result semCreateResult = EDMA3_RM_SOK;
-
-    if(NULL == hSem)
-        {
-        semCreateResult = EDMA3_RM_E_INVALID_PARAM;
-        }
-    else
-        {
-        *hSem = (EDMA3_OS_Sem_Handle)Semaphore_create(initVal, semParams, NULL);
-        if ( (*hSem) == NULL )
-            {
-            semCreateResult = EDMA3_RM_E_SEMAPHORE;
-            }
-        }
-
-    return semCreateResult;
-    }
-
-
-/**
- * \brief   EDMA3 OS Semaphore Delete
- *
- *      This function deletes or removes the specified semaphore
- *      from the system. Associated dynamically allocated memory
- *      if any is also freed up.
- * \param   hSem [IN] handle to the semaphore to be deleted
- * \return  EDMA3_RM_SOK if succesful else a suitable error code
- */
-EDMA3_RM_Result edma3OsSemDelete(EDMA3_OS_Sem_Handle hSem)
-    {
-    EDMA3_RM_Result semDeleteResult = EDMA3_RM_SOK;
-
-    if(NULL == hSem)
-        {
-        semDeleteResult = EDMA3_RM_E_INVALID_PARAM;
-        }
-    else
-        {
-               Semaphore_delete(hSem);
-        }
-
-    return semDeleteResult;
-    }
-
-
-/**
- * \brief   EDMA3 OS Semaphore Take
- *
- *      This function takes a semaphore token if available.
- *      If a semaphore is unavailable, it blocks currently
- *      running thread in wait (for specified duration) for
- *      a free semaphore.
- * \param   hSem [IN] is the handle of the specified semaphore
- * \param   mSecTimeout [IN] is wait time in milliseconds
- * \return  EDMA3_RM_Result if successful else a suitable error code
- */
-EDMA3_RM_Result edma3OsSemTake(EDMA3_OS_Sem_Handle hSem, int mSecTimeout)
-    {
-    EDMA3_RM_Result semTakeResult = EDMA3_RM_SOK;
-    unsigned short semPendResult;
-
-    if(NULL == hSem)
-        {
-        semTakeResult = EDMA3_RM_E_INVALID_PARAM;
-        }
-    else
-        {
-        semPendResult = Semaphore_pend(hSem, mSecTimeout);
-        if (semPendResult == FALSE)
-            {
-            semTakeResult = EDMA3_RM_E_SEMAPHORE;
-            }
-        }
-
-    return semTakeResult;
-    }
-
-
-/**
- * \brief   EDMA3 OS Semaphore Give
- *
- *      This function gives or relinquishes an already
- *      acquired semaphore token
- * \param   hSem [IN] is the handle of the specified semaphore
- * \return  EDMA3_RM_Result if successful else a suitable error code
- */
-EDMA3_RM_Result edma3OsSemGive(EDMA3_OS_Sem_Handle hSem)
-    {
-    EDMA3_RM_Result semGiveResult = EDMA3_RM_SOK;
-
-    if(NULL == hSem)
-        {
-        semGiveResult = EDMA3_RM_E_INVALID_PARAM;
-        }
-    else
-        {
-               Semaphore_post(hSem);
-        }
-
-    return semGiveResult;
-    }
-
-
-
-
-
+/*\r
+ * sample_cs.c\r
+ *\r
+ * Sample functions showing the implementation of critical section entry/exit\r
+ * routines and various semaphore related routines (all OS depenedent). These\r
+ * implementations MUST be provided by the user / application, using the EDMA3\r
+ * Resource Manager, for its correct functioning.\r
+ *\r
+ * Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/\r
+ *\r
+ *\r
+ *  Redistribution and use in source and binary forms, with or without\r
+ *  modification, are permitted provided that the following conditions\r
+ *  are met:\r
+ *\r
+ *    Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ *\r
+ *    Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the\r
+ *    distribution.\r
+ *\r
+ *    Neither the name of Texas Instruments Incorporated nor the names of\r
+ *    its contributors may be used to endorse or promote products derived\r
+ *    from this software without specific prior written permission.\r
+ *\r
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\r
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\r
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\r
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ *\r
+*/\r
+\r
+#include <ti/sysbios/family/c64p/EventCombiner.h>\r
+#include <ti/sysbios/hal/Hwi.h>\r
+#include <ti/sysbios/knl/Task.h>\r
+#include <ti/sysbios/ipc/Semaphore.h>\r
+\r
+#include <ti/sdo/edma3/rm/sample/bios6_edma3_rm_sample.h>\r
+\r
+extern unsigned int ccXferCompInt[][EDMA3_MAX_REGIONS];\r
+extern unsigned int ccErrorInt[];\r
+extern unsigned int tcErrorInt[][EDMA3_MAX_TC];\r
+\r
+/**\r
+ * DSP instance number on which the executable is running. Its value is\r
+ * determined by reading the processor specific register DNUM.\r
+ */\r
+extern unsigned int dsp_num;\r
+\r
+/**\r
+ * \brief   EDMA3 OS Protect Entry\r
+ *\r
+ *      This function saves the current state of protection in 'intState'\r
+ *      variable passed by caller, if the protection level is\r
+ *      EDMA3_OS_PROTECT_INTERRUPT. It then applies the requested level of\r
+ *      protection.\r
+ *      For EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION and\r
+ *      EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR, variable 'intState' is ignored,\r
+ *      and the requested interrupt is disabled.\r
+ *      For EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR, '*intState' specifies the\r
+ *      Transfer Controller number whose interrupt needs to be disabled.\r
+ *\r
+ * \param   level is numeric identifier of the desired degree of protection.\r
+ * \param   intState is memory location where current state of protection is\r
+ *      saved for future use while restoring it via edma3OsProtectExit() (Only\r
+ *      for EDMA3_OS_PROTECT_INTERRUPT protection level).\r
+ * \return  None\r
+ */\r
+void edma3OsProtectEntry (unsigned int edma3InstanceId, \r
+                                                       int level, unsigned int *intState)\r
+    {\r
+    if (((level == EDMA3_OS_PROTECT_INTERRUPT)\r
+        || (level == EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR))\r
+        && (intState == NULL))\r
+        {\r
+        return;\r
+        }\r
+    else\r
+        {\r
+        switch (level)\r
+            {\r
+            /* Disable all (global) interrupts */\r
+            case EDMA3_OS_PROTECT_INTERRUPT :\r
+                *intState = Hwi_disable();\r
+                break;\r
+\r
+            /* Disable scheduler */\r
+            case EDMA3_OS_PROTECT_SCHEDULER :\r
+                               Task_disable();\r
+                break;\r
+\r
+            /* Disable EDMA3 transfer completion interrupt only */\r
+            case EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION :\r
+                EventCombiner_disableEvent(ccXferCompInt[edma3InstanceId][dsp_num]);\r
+                break;\r
+\r
+            /* Disable EDMA3 CC error interrupt only */\r
+            case EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR :\r
+                EventCombiner_disableEvent(ccErrorInt[edma3InstanceId]);\r
+                break;\r
+\r
+            /* Disable EDMA3 TC error interrupt only */\r
+            case EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR :\r
+                switch (*intState)\r
+                    {\r
+                    case 0:\r
+                    case 1:\r
+                    case 2:\r
+                    case 3:\r
+                    case 4:\r
+                    case 5:\r
+                    case 6:\r
+                    case 7:\r
+                        /* Fall through... */\r
+                        /* Disable the corresponding interrupt */\r
+                        EventCombiner_disableEvent(tcErrorInt[edma3InstanceId][*intState]);\r
+                        break;\r
+\r
+                     default:\r
+                        break;\r
+                    }\r
+\r
+                break;\r
+\r
+            default:\r
+                break;\r
+            }\r
+        }\r
+    }\r
+\r
+\r
+/**\r
+ * \brief   EDMA3 OS Protect Exit\r
+ *\r
+ *      This function undoes the protection enforced to original state\r
+ *      as is specified by the variable 'intState' passed, if the protection\r
+ *      level is EDMA3_OS_PROTECT_INTERRUPT.\r
+ *      For EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION and\r
+ *      EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR, variable 'intState' is ignored,\r
+ *      and the requested interrupt is enabled.\r
+ *      For EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR, 'intState' specifies the\r
+ *      Transfer Controller number whose interrupt needs to be enabled.\r
+ * \param   level is numeric identifier of the desired degree of protection.\r
+ * \param   intState is original state of protection at time when the\r
+ *      corresponding edma3OsProtectEntry() was called (Only\r
+ *      for EDMA3_OS_PROTECT_INTERRUPT protection level).\r
+ * \return  None\r
+ */\r
+void edma3OsProtectExit (unsigned int edma3InstanceId,\r
+                        int level, unsigned int intState)\r
+    {\r
+    switch (level)\r
+        {\r
+        /* Enable all (global) interrupts */\r
+        case EDMA3_OS_PROTECT_INTERRUPT :\r
+            Hwi_restore(intState);\r
+            break;\r
+\r
+        /* Enable scheduler */\r
+        case EDMA3_OS_PROTECT_SCHEDULER :\r
+            Task_enable();\r
+            break;\r
+\r
+        /* Enable EDMA3 transfer completion interrupt only */\r
+        case EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION :\r
+            EventCombiner_enableEvent(ccXferCompInt[edma3InstanceId][dsp_num]);\r
+            break;\r
+\r
+        /* Enable EDMA3 CC error interrupt only */\r
+        case EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR :\r
+            EventCombiner_enableEvent(ccErrorInt[edma3InstanceId]);\r
+            break;\r
+\r
+        /* Enable EDMA3 TC error interrupt only */\r
+        case EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR :\r
+            switch (intState)\r
+                {\r
+                case 0:\r
+                case 1:\r
+                case 2:\r
+                case 3:\r
+                case 4:\r
+                case 5:\r
+                case 6:\r
+                case 7:\r
+                    /* Fall through... */\r
+                    /* Enable the corresponding interrupt */\r
+                    EventCombiner_enableEvent(tcErrorInt[edma3InstanceId][intState]);\r
+                    break;\r
+\r
+                 default:\r
+                    break;\r
+                }\r
+\r
+            break;\r
+\r
+        default:\r
+            break;\r
+        }\r
+    }\r
+\r
+\r
+/**\r
+  * Counting Semaphore related functions (OS dependent) should be\r
+  * called/implemented by the application. A handle to the semaphore\r
+  * is required while opening the resource manager instance.\r
+  */\r
+\r
+/**\r
+ * \brief   EDMA3 OS Semaphore Create\r
+ *\r
+ *      This function creates a counting semaphore with specified\r
+ *      attributes and initial value. It should be used to create a semaphore\r
+ *      with initial value as '1'. The semaphore is then passed by the user\r
+ *      to the EDMA3 RM for proper sharing of resources.\r
+ * \param   initVal [IN] is initial value for semaphore\r
+ * \param   semParams [IN] is the semaphore attributes.\r
+ * \param   hSem [OUT] is location to recieve the handle to just created\r
+ *      semaphore\r
+ * \return  EDMA3_RM_SOK if succesful, else a suitable error code.\r
+ */\r
+EDMA3_RM_Result edma3OsSemCreate(int initVal,\r
+                                                       const Semaphore_Params *semParams,\r
+                               EDMA3_OS_Sem_Handle *hSem)\r
+    {\r
+    EDMA3_RM_Result semCreateResult = EDMA3_RM_SOK;\r
+\r
+    if(NULL == hSem)\r
+        {\r
+        semCreateResult = EDMA3_RM_E_INVALID_PARAM;\r
+        }\r
+    else\r
+        {\r
+        *hSem = (EDMA3_OS_Sem_Handle)Semaphore_create(initVal, semParams, NULL);\r
+        if ( (*hSem) == NULL )\r
+            {\r
+            semCreateResult = EDMA3_RM_E_SEMAPHORE;\r
+            }\r
+        }\r
+\r
+    return semCreateResult;\r
+    }\r
+\r
+\r
+/**\r
+ * \brief   EDMA3 OS Semaphore Delete\r
+ *\r
+ *      This function deletes or removes the specified semaphore\r
+ *      from the system. Associated dynamically allocated memory\r
+ *      if any is also freed up.\r
+ * \param   hSem [IN] handle to the semaphore to be deleted\r
+ * \return  EDMA3_RM_SOK if succesful else a suitable error code\r
+ */\r
+EDMA3_RM_Result edma3OsSemDelete(EDMA3_OS_Sem_Handle hSem)\r
+    {\r
+    EDMA3_RM_Result semDeleteResult = EDMA3_RM_SOK;\r
+\r
+    if(NULL == hSem)\r
+        {\r
+        semDeleteResult = EDMA3_RM_E_INVALID_PARAM;\r
+        }\r
+    else\r
+        {\r
+               Semaphore_delete(hSem);\r
+        }\r
+\r
+    return semDeleteResult;\r
+    }\r
+\r
+\r
+/**\r
+ * \brief   EDMA3 OS Semaphore Take\r
+ *\r
+ *      This function takes a semaphore token if available.\r
+ *      If a semaphore is unavailable, it blocks currently\r
+ *      running thread in wait (for specified duration) for\r
+ *      a free semaphore.\r
+ * \param   hSem [IN] is the handle of the specified semaphore\r
+ * \param   mSecTimeout [IN] is wait time in milliseconds\r
+ * \return  EDMA3_RM_Result if successful else a suitable error code\r
+ */\r
+EDMA3_RM_Result edma3OsSemTake(EDMA3_OS_Sem_Handle hSem, int mSecTimeout)\r
+    {\r
+    EDMA3_RM_Result semTakeResult = EDMA3_RM_SOK;\r
+    unsigned short semPendResult;\r
+\r
+    if(NULL == hSem)\r
+        {\r
+        semTakeResult = EDMA3_RM_E_INVALID_PARAM;\r
+        }\r
+    else\r
+        {\r
+        semPendResult = Semaphore_pend(hSem, mSecTimeout);\r
+        if (semPendResult == FALSE)\r
+            {\r
+            semTakeResult = EDMA3_RM_E_SEMAPHORE;\r
+            }\r
+        }\r
+\r
+    return semTakeResult;\r
+    }\r
+\r
+\r
+/**\r
+ * \brief   EDMA3 OS Semaphore Give\r
+ *\r
+ *      This function gives or relinquishes an already\r
+ *      acquired semaphore token\r
+ * \param   hSem [IN] is the handle of the specified semaphore\r
+ * \return  EDMA3_RM_Result if successful else a suitable error code\r
+ */\r
+EDMA3_RM_Result edma3OsSemGive(EDMA3_OS_Sem_Handle hSem)\r
+    {\r
+    EDMA3_RM_Result semGiveResult = EDMA3_RM_SOK;\r
+\r
+    if(NULL == hSem)\r
+        {\r
+        semGiveResult = EDMA3_RM_E_INVALID_PARAM;\r
+        }\r
+    else\r
+        {\r
+               Semaphore_post(hSem);\r
+        }\r
+\r
+    return semGiveResult;\r
+    }\r
+\r
+/* End of File */\r
+\r