Misra C fixes:
authorSunil MS <x0190988@ti.com>
Mon, 15 Sep 2014 07:34:48 +0000 (13:04 +0530)
committerSunil MS <x0190988@ti.com>
Thu, 9 Oct 2014 14:11:31 +0000 (19:41 +0530)
MISRA.BUILTIN_NUMERIC
MISRA.CVALUE.IMPL.CAST
MISRA.DEFINE.BADEXP
MISRA.DEFINE.WRONGNAME.UNDERSCORE
MISRA.FUNC.PARAMS.IDENT
MISRA.IF.NO_COMPOUND
MISRA.LOGIC.OPERATOR.NOT_BOOL
MISRA.RETURN.NOT_LAST
Removed white space errors.

Change-Id: I978150b32825654507b7f0d645250b97106b7396
Signed-off-by: Sunil MS <x0190988@ti.com>
packages/ti/sdo/edma3/rm/edma3_common.h
packages/ti/sdo/edma3/rm/sample/bios6_edma3_rm_sample.h
packages/ti/sdo/edma3/rm/sample/src/sample_arm_cs.c
packages/ti/sdo/edma3/rm/sample/src/sample_arm_init.c
packages/ti/sdo/edma3/rm/sample/src/sample_cs.c
packages/ti/sdo/edma3/rm/sample/src/sample_init.c
packages/ti/sdo/edma3/rm/src/edma3resmgr.c

index 07f8c74a47163b14211aee7b5565e5529d90e69a..abddc147a7e6ac727b4d6b9c6deda179f796a8bd 100755 (executable)
@@ -78,6 +78,8 @@ extern "C" {
 typedef int32_t             EDMA3_RM_Result;
 /** EDMA3_DRV Result - return value of a function  */
 typedef int32_t             EDMA3_DRV_Result;
+/** EDMA3_Result - return value of a function for common functions of DRV and RM */
+typedef int32_t             EDMA3_Result;
 
 /** EDMA3 Resource Manager Result OK */
 #define EDMA3_RM_SOK             (0)
@@ -306,7 +308,7 @@ extern void edma3OsProtectExit (uint32_t edma3InstanceId,
  *
  * \return  EDMA3_DRV_Result if successful else a suitable error code
  */
-extern EDMA3_DRV_Result edma3OsSemTake (EDMA3_OS_Sem_Handle hSem,
+extern EDMA3_Result edma3OsSemTake (EDMA3_OS_Sem_Handle hSem,
                                         int32_t mSecTimeout);
 
 /**
@@ -319,7 +321,7 @@ extern EDMA3_DRV_Result edma3OsSemTake (EDMA3_OS_Sem_Handle hSem,
  *
  * \return  EDMA3_DRV_Result if successful else a suitable error code
  */
-extern EDMA3_DRV_Result edma3OsSemGive(EDMA3_OS_Sem_Handle hSem);
+extern EDMA3_Result edma3OsSemGive(EDMA3_OS_Sem_Handle hSem);
 
 #ifdef __cplusplus
 }
index 86b724ec389c7164f5b2359f9d48d5e041f0584b..816a108e5cc73c31d646669c706902f2db2c4ae9 100755 (executable)
@@ -36,8 +36,8 @@
  *
 */
 
-#ifndef _BIOS6_EDMA3_RM_SAMPLE_H_
-#define _BIOS6_EDMA3_RM_SAMPLE_H_
+#ifndef BIOS6_EDMA3_RM_SAMPLE_H_
+#define BIOS6_EDMA3_RM_SAMPLE_H_
 
 #include <ti/sysbios/knl/Semaphore.h>
 
@@ -48,11 +48,13 @@ extern "C" {
 #endif
 
 /* To enable debug traces in the EDMA3 sample app */
-#define EDMA3_DEBUG_PRINT
+/* Nowhere this macro is used, undefined to remove Misra C warning */
+
+/* #define EDMA3_DEBUG_PRINT  */
 
 #ifdef EDMA3_DEBUG_PRINT
 #include <stdio.h>
-#define EDMA3_DEBUG_PRINTF           printf
+#define EDMA3_DEBUG_PRINTF printf
 #endif /* EDMA3_DEBUG_PRINT */
 
 /**
@@ -83,7 +85,7 @@ extern "C" {
  *  \return EDMA3_RM_Handle: If successfully opened, the API will return the
  *                            associated RM's instance handle.
  */
-EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode);
+EDMA3_RM_Handle edma3init (uint32_t edma3Id, EDMA3_RM_Result *errorCode);
 
 /**
  * \brief   EDMA3 De-initialization
@@ -101,7 +103,7 @@ EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode);
  *                                                                     edma3init().
  *  \return  EDMA3_RM_SOK if success, else error code
  */
-EDMA3_RM_Result edma3deinit (unsigned int edma3Id, EDMA3_RM_Handle hEdma);
+EDMA3_RM_Result edma3deinit (uint32_t edma3Id, EDMA3_RM_Handle hEdma);
 
 /**
  * Counting Semaphore related functions (OS dependent) should be
@@ -122,7 +124,7 @@ EDMA3_RM_Result edma3deinit (unsigned int edma3Id, EDMA3_RM_Handle hEdma);
  *      semaphore
  * \return  EDMA3_RM_SOK if succesful, else a suitable error code.
  */
-EDMA3_RM_Result edma3OsSemCreate(int initVal,
+EDMA3_RM_Result edma3OsSemCreate(int32_t initVal,
                                                        const Semaphore_Params *semParams,
                                EDMA3_OS_Sem_Handle *hSem);
 
index be5d2b753fefa6a535a7fac02c6a50fe5df977f6..5a350dedaa6092d1e21e943b673ead2f9087035d 100644 (file)
 
 #include <ti/sdo/edma3/rm/sample/bios6_edma3_rm_sample.h>
 
-extern unsigned int ccXferCompInt[][EDMA3_MAX_REGIONS];
-extern unsigned int ccErrorInt[];
-extern unsigned int tcErrorInt[][EDMA3_MAX_TC];
+extern uint32_t ccXferCompInt[EDMA3_MAX_EDMA3_INSTANCES][EDMA3_MAX_REGIONS];
+extern uint32_t ccErrorInt[EDMA3_MAX_EDMA3_INSTANCES];
+extern uint32_t tcErrorInt[EDMA3_MAX_EDMA3_INSTANCES][EDMA3_MAX_TC];
 
 /**
  * Shadow Region on which the executable is running. Its value is
  * populated with the DSP Instance Number here in this case.
  */
-extern unsigned int region_id;
+extern uint32_t region_id;
 
 /**
  * \brief   EDMA3 OS Protect Entry
@@ -81,9 +81,9 @@ void edma3OsProtectEntry (uint32_t edma3InstanceId,
         || (level == EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR))
         && (intState == NULL))
         {
-        return;
+            /* Nothing to be done here */
         }
-    else
+        else
         {
         switch (level)
             {
@@ -134,6 +134,7 @@ void edma3OsProtectEntry (uint32_t edma3InstanceId,
                 break;
             }
         }
+    return;
     }
 
 
@@ -227,7 +228,7 @@ void edma3OsProtectExit (uint32_t edma3InstanceId,
  *      semaphore
  * \return  EDMA3_RM_SOK if succesful, else a suitable error code.
  */
-EDMA3_RM_Result edma3OsSemCreate(int initVal,
+EDMA3_RM_Result edma3OsSemCreate(int32_t initVal,
                                                        const Semaphore_Params *semParams,
                                EDMA3_OS_Sem_Handle *hSem)
     {
@@ -287,10 +288,9 @@ EDMA3_RM_Result edma3OsSemDelete(EDMA3_OS_Sem_Handle hSem)
  * \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, int32_t mSecTimeout)
+EDMA3_Result edma3OsSemTake(EDMA3_OS_Sem_Handle hSem, int32_t mSecTimeout)
     {
-    EDMA3_RM_Result semTakeResult = EDMA3_RM_SOK;
-    unsigned short semPendResult;
+    EDMA3_Result semTakeResult = EDMA3_RM_SOK;
 
     if(NULL == hSem)
         {
@@ -298,8 +298,7 @@ EDMA3_RM_Result edma3OsSemTake(EDMA3_OS_Sem_Handle hSem, int32_t mSecTimeout)
         }
     else
         {
-        semPendResult = Semaphore_pend((Semaphore_Handle)hSem, mSecTimeout);
-        if (semPendResult == FALSE)
+        if ((Semaphore_pend((Semaphore_Handle)hSem, (uint32_t)mSecTimeout)) == FALSE)
             {
             semTakeResult = EDMA3_RM_E_SEMAPHORE;
             }
@@ -315,11 +314,11 @@ EDMA3_RM_Result edma3OsSemTake(EDMA3_OS_Sem_Handle hSem, int32_t mSecTimeout)
  *      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
+ * \return  EDMA3_Result if successful else a suitable error code
  */
-EDMA3_RM_Result edma3OsSemGive(EDMA3_OS_Sem_Handle hSem)
+EDMA3_Result edma3OsSemGive(EDMA3_OS_Sem_Handle hSem)
     {
-    EDMA3_RM_Result semGiveResult = EDMA3_RM_SOK;
+    EDMA3_Result semGiveResult = EDMA3_RM_SOK;
 
     if(NULL == hSem)
         {
index e89cb0e9487abdcc04fe65f2bd736625d6683bf2..e25564bebea9a819ca5dae49875c5c023c237c02 100644 (file)
 #include <ti/sdo/edma3/rm/sample/bios6_edma3_rm_sample.h>
 
 /** @brief EDMA3 Driver Instance specific Semaphore handle */
-extern EDMA3_OS_Sem_Handle rmSemHandle[];
+extern EDMA3_OS_Sem_Handle rmSemHandle[EDMA3_MAX_EDMA3_INSTANCES];
 
 /**  To Register the ISRs with the underlying OS, if required. */
-extern void registerEdma3Interrupts (unsigned int edma3Id);
+extern void registerEdma3Interrupts (uint32_t edma3Id);
 /**  To Unregister the ISRs with the underlying OS, if previously registered. */
-extern void unregisterEdma3Interrupts (unsigned int edma3Id);
+extern void unregisterEdma3Interrupts (uint32_t edma3Id);
 
 /* To find out the DSP# */
-extern unsigned short determineProcId();
+extern uint16_t determineProcId(void);
 
 /**
  * To check whether the global EDMA3 configuration is required or not.
@@ -61,31 +61,31 @@ extern unsigned short determineProcId();
  * by one of the masters. Hence this function will return TRUE only once
  * and FALSE for all other masters. 
  */
-extern unsigned short isGblConfigRequired(unsigned int dspNum);
+extern uint16_t isGblConfigRequired(uint32_t dspNum);
 
 /**
  * DSP instance number on which the executable is running. Its value is
  * determined by reading the processor specific register DNUM.
  */
-unsigned int dsp_num;
+uint32_t dsp_num;
 
 /**
  * Shadow Region on which the executable is runnig. Its value is populated
  * with the dsp_num here in this case.
  */
-unsigned int region_id;
+uint32_t region_id;
 
 /* Number of EDMA3 controllers present in the system */
-extern const unsigned int numEdma3Instances;
+extern const uint32_t numEdma3Instances;
 
 /* External Global Configuration Structure */
-extern EDMA3_RM_GblConfigParams sampleEdma3GblCfgParams[];
+extern EDMA3_RM_GblConfigParams sampleEdma3GblCfgParams[EDMA3_MAX_EDMA3_INSTANCES];
 
 /* External Instance Specific Configuration Structure */
-extern EDMA3_RM_InstanceInitConfig sampleInstInitConfig[][EDMA3_MAX_REGIONS];
+extern EDMA3_RM_InstanceInitConfig sampleInstInitConfig[EDMA3_MAX_EDMA3_INSTANCES][EDMA3_MAX_REGIONS];
 
 #ifdef DMA_XBAR_AVAILABLE
-extern EDMA3_DRV_Result sampleInitXbarEvt(EDMA3_DRV_Handle hEdma, unsigned int edma3Id);
+extern EDMA3_DRV_Result sampleInitXbarEvt(EDMA3_DRV_Handle hEdma, uint32_t edma3Id);
 #endif
 
 /**
@@ -96,7 +96,7 @@ extern EDMA3_DRV_Result sampleInitXbarEvt(EDMA3_DRV_Handle hEdma, unsigned int e
  *
   * \return  EDMA3_RM_SOK if success, else error code
  */
-EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode)
+EDMA3_RM_Handle edma3init (uint32_t edma3Id, EDMA3_RM_Result *errorCode)
     {
     EDMA3_RM_Param initParam;
     EDMA3_RM_Result edma3Result = EDMA3_RM_SOK;
@@ -107,8 +107,11 @@ EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode)
        EDMA3_RM_Handle hEdmaResMgr = NULL;
 
        if ((edma3Id >= numEdma3Instances) || (errorCode == NULL))
-               return hEdmaResMgr;
-
+    {
+               hEdmaResMgr = NULL;
+    }
+    else
+    {
     /* DSP instance number */
     dsp_num = determineProcId();
 
@@ -129,7 +132,7 @@ EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode)
                Semaphore_Params_init(&semParams);
 
                initParam.rmSemHandle = NULL;
-               edma3Result = edma3OsSemCreate(1, &semParams, &initParam.rmSemHandle);
+               edma3Result = edma3OsSemCreate((int32_t)1, &semParams, &initParam.rmSemHandle);
                }
 
        if (edma3Result == EDMA3_DRV_SOK)
@@ -159,13 +162,13 @@ EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode)
 
 #ifdef DMA_XBAR_AVAILABLE
        {
-       if(hEdmaResMgr && (edma3Result == EDMA3_RM_SOK))
+       if((hEdmaResMgr != NULL) && (edma3Result == EDMA3_RM_SOK))
                {
                edma3Result = sampleInitXbarEvt(hEdmaResMgr, edma3Id);
                }
        }
 #endif
-       if(hEdmaResMgr && (edma3Result == EDMA3_DRV_SOK))
+       if((hEdmaResMgr != NULL) && (edma3Result == EDMA3_DRV_SOK))
                {
                /**
                * Register Interrupt Handlers for various interrupts
@@ -175,7 +178,8 @@ EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode)
                registerEdma3Interrupts(edma3Id);
                }
 
-       *errorCode = edma3Result;       
+       *errorCode = edma3Result;
+    }
        return hEdmaResMgr;
     }
 
@@ -187,7 +191,7 @@ EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode)
  *
   * \return  EDMA3_RM_SOK if success, else error code
  */
-EDMA3_RM_Result edma3deinit (unsigned int edma3Id, EDMA3_RM_Handle hEdmaResMgr)
+EDMA3_RM_Result edma3deinit (uint32_t edma3Id, EDMA3_RM_Handle hEdma)
     {
     EDMA3_RM_Result edma3Result = EDMA3_RM_SOK;
 
@@ -203,7 +207,7 @@ EDMA3_RM_Result edma3deinit (unsigned int edma3Id, EDMA3_RM_Handle hEdmaResMgr)
         rmSemHandle[edma3Id] = NULL;
 
         /* Now, close the EDMA3 RM Instance */
-        edma3Result = EDMA3_RM_close (hEdmaResMgr, NULL);
+        edma3Result = EDMA3_RM_close (hEdma, NULL);
        }
        
     if (EDMA3_RM_SOK == edma3Result)
index 802421f6f55a0ba72801d2ffc0697e88ef7dcfa3..1ef9d2b3a15ba5062192aa911879ed1cda7c5136 100755 (executable)
 \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
+extern uint32_t ccXferCompInt[EDMA3_MAX_EDMA3_INSTANCES][EDMA3_MAX_REGIONS];\r
+extern uint32_t ccErrorInt[EDMA3_MAX_EDMA3_INSTANCES];\r
+extern uint32_t tcErrorInt[EDMA3_MAX_EDMA3_INSTANCES][EDMA3_MAX_TC];\r
 \r
 /**\r
  * Shadow Region on which the executable is running. Its value is\r
  * populated with the DSP Instance Number here in this case.\r
  */\r
-extern unsigned int region_id;\r
+extern uint32_t region_id;\r
 \r
 /**\r
  * \brief   EDMA3 OS Protect Entry\r
@@ -75,16 +75,16 @@ extern unsigned int region_id;
  *      for EDMA3_OS_PROTECT_INTERRUPT protection level).\r
  * \return  None\r
  */\r
-void edma3OsProtectEntry (unsigned int edma3InstanceId, \r
-                                                       int level, unsigned int *intState)\r
+void edma3OsProtectEntry (uint32_t edma3InstanceId,\r
+                                                       int32_t level, uint32_t *intState)\r
     {\r
     if (((level == EDMA3_OS_PROTECT_INTERRUPT)\r
         || (level == EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR))\r
         && (intState == NULL))\r
         {\r
-        return;\r
+            /* Nothing to be done here */\r
         }\r
-    else\r
+        else\r
         {\r
         switch (level)\r
             {\r
@@ -135,6 +135,7 @@ void edma3OsProtectEntry (unsigned int edma3InstanceId,
                 break;\r
             }\r
         }\r
+        return;\r
     }\r
 \r
 \r
@@ -155,8 +156,8 @@ void edma3OsProtectEntry (unsigned int edma3InstanceId,
  *      for EDMA3_OS_PROTECT_INTERRUPT protection level).\r
  * \return  None\r
  */\r
-void edma3OsProtectExit (unsigned int edma3InstanceId,\r
-                        int level, unsigned int intState)\r
+void edma3OsProtectExit (uint32_t edma3InstanceId,\r
+                        int32_t level, uint32_t intState)\r
     {\r
     switch (level)\r
         {\r
@@ -228,7 +229,7 @@ void edma3OsProtectExit (unsigned int edma3InstanceId,
  *      semaphore\r
  * \return  EDMA3_RM_SOK if succesful, else a suitable error code.\r
  */\r
-EDMA3_RM_Result edma3OsSemCreate(int initVal,\r
+EDMA3_RM_Result edma3OsSemCreate(int32_t initVal,\r
                                                        const Semaphore_Params *semParams,\r
                                EDMA3_OS_Sem_Handle *hSem)\r
     {\r
@@ -286,12 +287,11 @@ EDMA3_RM_Result edma3OsSemDelete(EDMA3_OS_Sem_Handle hSem)
  *      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
+ * \return  EDMA3_Result if successful else a suitable error code\r
  */\r
-EDMA3_RM_Result edma3OsSemTake(EDMA3_OS_Sem_Handle hSem, int mSecTimeout)\r
+EDMA3_Result edma3OsSemTake(EDMA3_OS_Sem_Handle hSem, int32_t mSecTimeout)\r
     {\r
-    EDMA3_RM_Result semTakeResult = EDMA3_RM_SOK;\r
-    unsigned short semPendResult;\r
+    EDMA3_Result semTakeResult = EDMA3_RM_SOK;\r
 \r
     if(NULL == hSem)\r
         {\r
@@ -299,10 +299,9 @@ EDMA3_RM_Result edma3OsSemTake(EDMA3_OS_Sem_Handle hSem, int mSecTimeout)
         }\r
     else\r
         {\r
-        semPendResult = Semaphore_pend(hSem, mSecTimeout);\r
-        if (semPendResult == FALSE)\r
+        if((Semaphore_pend(hSem, (uint32_t)mSecTimeout)) == FALSE)\r
             {\r
-            semTakeResult = EDMA3_RM_E_SEMAPHORE;\r
+                semTakeResult = EDMA3_RM_E_SEMAPHORE;\r
             }\r
         }\r
 \r
@@ -316,11 +315,11 @@ EDMA3_RM_Result edma3OsSemTake(EDMA3_OS_Sem_Handle hSem, int mSecTimeout)
  *      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
+ * \return  EDMA3_Result if successful else a suitable error code\r
  */\r
-EDMA3_RM_Result edma3OsSemGive(EDMA3_OS_Sem_Handle hSem)\r
+EDMA3_Result edma3OsSemGive(EDMA3_OS_Sem_Handle hSem)\r
     {\r
-    EDMA3_RM_Result semGiveResult = EDMA3_RM_SOK;\r
+    EDMA3_Result semGiveResult = EDMA3_RM_SOK;\r
 \r
     if(NULL == hSem)\r
         {\r
index 329fc7d5949b975e38a4bf816b3a1969cdca476d..2b7f0695c4dc15eee3428f71221ebde0e9e74ce1 100755 (executable)
 #include <ti/sdo/edma3/rm/sample/bios6_edma3_rm_sample.h>\r
 \r
 /** @brief EDMA3 Driver Instance specific Semaphore handle */\r
-extern EDMA3_OS_Sem_Handle rmSemHandle[];\r
+extern EDMA3_OS_Sem_Handle rmSemHandle[EDMA3_MAX_EDMA3_INSTANCES];\r
 \r
 /**  To Register the ISRs with the underlying OS, if required. */\r
-extern void registerEdma3Interrupts (unsigned int edma3Id);\r
+extern void registerEdma3Interrupts (uint32_t edma3Id);\r
 /**  To Unregister the ISRs with the underlying OS, if previously registered. */\r
-extern void unregisterEdma3Interrupts (unsigned int edma3Id);\r
+extern void unregisterEdma3Interrupts (uint32_t edma3Id);\r
 \r
 /* To find out the DSP# */\r
-extern unsigned short determineProcId();\r
+extern uint16_t determineProcId(void);\r
 \r
 /**\r
  * To check whether the global EDMA3 configuration is required or not.\r
@@ -62,31 +62,31 @@ extern unsigned short determineProcId();
  * by one of the masters. Hence this function will return TRUE only once\r
  * and FALSE for all other masters. \r
  */\r
-extern unsigned short isGblConfigRequired(unsigned int dspNum);\r
+extern uint16_t isGblConfigRequired(uint32_t dspNum);\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
-unsigned int dsp_num;\r
+uint32_t dsp_num;\r
 \r
 /**\r
  * Shadow Region on which the executable is runnig. Its value is populated\r
  * with the dsp_num here in this case.\r
  */\r
-unsigned int region_id;\r
+uint32_t region_id;\r
 \r
 /* Number of EDMA3 controllers present in the system */\r
-extern const unsigned int numEdma3Instances;\r
+extern const uint32_t numEdma3Instances;\r
 \r
 /* External Global Configuration Structure */\r
-extern EDMA3_RM_GblConfigParams sampleEdma3GblCfgParams[];\r
+extern EDMA3_RM_GblConfigParams sampleEdma3GblCfgParams[EDMA3_MAX_EDMA3_INSTANCES];\r
 \r
 /* External Instance Specific Configuration Structure */\r
-extern EDMA3_RM_InstanceInitConfig sampleInstInitConfig[][EDMA3_MAX_REGIONS];\r
+extern EDMA3_RM_InstanceInitConfig sampleInstInitConfig[EDMA3_MAX_EDMA3_INSTANCES][EDMA3_MAX_REGIONS];\r
 \r
 #ifdef DMA_XBAR_AVAILABLE
-extern EDMA3_RM_Result sampleInitXbarEvt(EDMA3_RM_Handle hEdma, unsigned int edma3Id);
+extern EDMA3_RM_Result sampleInitXbarEvt(EDMA3_RM_Handle hEdma, uint32_t edma3Id);
 #endif
 
 /**\r
@@ -97,7 +97,7 @@ extern EDMA3_RM_Result sampleInitXbarEvt(EDMA3_RM_Handle hEdma, unsigned int edm
  *\r
   * \return  EDMA3_RM_SOK if success, else error code\r
  */\r
-EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode)\r
+EDMA3_RM_Handle edma3init (uint32_t edma3Id, EDMA3_RM_Result *errorCode)\r
     {\r
     EDMA3_RM_Param initParam;\r
     EDMA3_RM_Result edma3Result = EDMA3_RM_SOK;\r
@@ -108,8 +108,11 @@ EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode)
        EDMA3_RM_Handle hEdmaResMgr = NULL;\r
 \r
        if ((edma3Id >= numEdma3Instances) || (errorCode == NULL))\r
-               return hEdmaResMgr;\r
-\r
+    {\r
+               hEdmaResMgr = NULL;\r
+    }\r
+    else\r
+    {\r
     /* DSP instance number */\r
     dsp_num = determineProcId();\r
 \r
@@ -130,7 +133,7 @@ EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode)
                Semaphore_Params_init(&semParams);\r
 \r
                initParam.rmSemHandle = NULL;\r
-               edma3Result = edma3OsSemCreate(1, &semParams, &initParam.rmSemHandle);\r
+               edma3Result = edma3OsSemCreate((int32_t)1, &semParams, &initParam.rmSemHandle);\r
                }\r
 \r
        if (edma3Result == EDMA3_DRV_SOK)\r
@@ -160,13 +163,13 @@ EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode)
 \r
 #ifdef DMA_XBAR_AVAILABLE
        {\r
-       if(hEdmaResMgr && (edma3Result == EDMA3_RM_SOK))\r
+       if((hEdmaResMgr != NULL) && (edma3Result == EDMA3_RM_SOK))\r
                {\r
                edma3Result = sampleInitXbarEvt(hEdmaResMgr, edma3Id);\r
                }\r
        }\r
 #endif \r
-       if(hEdmaResMgr && (edma3Result == EDMA3_DRV_SOK))\r
+       if((hEdmaResMgr != NULL) && (edma3Result == EDMA3_DRV_SOK))\r
                {\r
                /**\r
                * Register Interrupt Handlers for various interrupts\r
@@ -177,6 +180,7 @@ EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode)
                }\r
 \r
        *errorCode = edma3Result;       \r
+    }\r
        return hEdmaResMgr;\r
     }\r
 \r
@@ -188,7 +192,7 @@ EDMA3_RM_Handle edma3init (unsigned int edma3Id, EDMA3_RM_Result *errorCode)
  *\r
   * \return  EDMA3_RM_SOK if success, else error code\r
  */\r
-EDMA3_RM_Result edma3deinit (unsigned int edma3Id, EDMA3_RM_Handle hEdmaResMgr)\r
+EDMA3_RM_Result edma3deinit (uint32_t edma3Id, EDMA3_RM_Handle hEdma)\r
     {\r
     EDMA3_RM_Result edma3Result = EDMA3_RM_SOK;\r
 \r
@@ -204,7 +208,7 @@ EDMA3_RM_Result edma3deinit (unsigned int edma3Id, EDMA3_RM_Handle hEdmaResMgr)
         rmSemHandle[edma3Id] = NULL;\r
 \r
         /* Now, close the EDMA3 RM Instance */\r
-        edma3Result = EDMA3_RM_close (hEdmaResMgr, NULL);\r
+        edma3Result = EDMA3_RM_close (hEdma, NULL);\r
        }\r
        \r
     if (EDMA3_RM_SOK == edma3Result)\r
index e3f67e1f528235eaea0c15d61b5d949ab67669e3..186d7e48499ef4a6bb5751a802f7730ba19fc4ec 100755 (executable)
@@ -5479,12 +5479,18 @@ static void edma3CCErrHandler(const EDMA3_RM_Obj *rmObj)
                             + (edma3Id*EDMA3_MAX_RM_INSTANCES)
                             + edma3RegionId);
 
-        pendingIrqs = ((ptrEdmaccRegs->EMR != 0 )
-                        || (ptrEdmaccRegs->QEMR != 0)
-                        || (ptrEdmaccRegs->CCERR != 0));
+        if((ptrEdmaccRegs->EMR != 0 )
+                || (ptrEdmaccRegs->QEMR != 0)
+                || (ptrEdmaccRegs->CCERR != 0))
+            {
+                pendingIrqs = 1U;
+            }
         if (numTCCs > 32U)
             {
-            pendingIrqs = pendingIrqs || (ptrEdmaccRegs->EMRH != 0 );
+            if((pendingIrqs != 0) || (ptrEdmaccRegs->EMRH != 0))
+               {
+                   pendingIrqs = 1U;
+               }
             }
         index = 1U;