Diff: RenesasBSP/drv_src/dma/dma.c

Revision:

5:1390bfcb667c

Parent:

0:702bf7b2b7d8

diff -r 7318d8e553a4 -r 1390bfcb667c RenesasBSP/drv_src/dma/dma.c
--- a/RenesasBSP/drv_src/dma/dma.c	Tue Jul 21 01:48:39 2015 +0000
+++ b/RenesasBSP/drv_src/dma/dma.c	Tue Aug 18 04:00:49 2015 +0000
@@ -23,8 +23,8 @@
 
 /**************************************************************************//**
 * @file         dma.c
-* $Rev: 1133 $
-* $Date:: 2014-09-08 14:33:59 +0900#$
+* $Rev: 1674 $
+* $Date:: 2015-05-29 16:35:57 +0900#$
 * @brief        DMA Driver internal functions
 ******************************************************************************/
 
@@ -41,7 +41,6 @@
 #include "aioif.h"
 #include "iodefine.h"
 #include "gic.h"
-#include "bsp_util.h"
 
 /******************************************************************************
 Private global driver management information
@@ -51,31 +50,6 @@
 static dma_info_drv_t gb_info_drv;
 
 /******************************************************************************
-Private global channel semaphore information
-******************************************************************************/
-
-/* driver semaphore name define */
-/* ->MISRA 8.8, 8.10, IPA M2.2.2 There is no problem in the description of declaration of 
-OS resource itself */
-osSemaphoreDef(sem_dma_ch0);
-osSemaphoreDef(sem_dma_ch1);
-osSemaphoreDef(sem_dma_ch2);
-osSemaphoreDef(sem_dma_ch3);
-osSemaphoreDef(sem_dma_ch4);
-osSemaphoreDef(sem_dma_ch5);
-osSemaphoreDef(sem_dma_ch6);
-osSemaphoreDef(sem_dma_ch7);
-osSemaphoreDef(sem_dma_ch8);
-osSemaphoreDef(sem_dma_ch9);
-osSemaphoreDef(sem_dma_ch10);
-osSemaphoreDef(sem_dma_ch11);
-osSemaphoreDef(sem_dma_ch12);
-osSemaphoreDef(sem_dma_ch13);
-osSemaphoreDef(sem_dma_ch14);
-osSemaphoreDef(sem_dma_ch15);
-/* <-MISRA 8.8, 8.10, IPA M2.2.2 */
-      
-/******************************************************************************
 Private function define (interrupt handler)
 ******************************************************************************/
 
@@ -145,17 +119,13 @@
 * Description : Initialize DMA driver.
 * Arguments : *p_dma_init_param -
 *                  Pointer of init parameters.
-*             sem_drv -
-*                  Driver semaphore ID.
 * Return Value : ESUCCESS -
 *                  Operation successful.
 *                OS error num -
 *                  Registering handler failed.
-*                ENOMEM -
-*                  Making semaphore failed.
 ******************************************************************************/
 
-int_t DMA_Initialize(const dma_drv_init_t * const p_dma_init_param, const osSemaphoreId sem_drv)
+int_t DMA_Initialize(const dma_drv_init_t * const p_dma_init_param)
 {
     int_t    retval = ESUCCESS;
     int_t    ch_count;
@@ -268,33 +238,9 @@
           DMAINT15_IRQn
         };
         
-    /* driver semaphore table define */
-    static const osSemaphoreDef_t *p_gb_semdef_ch[DMA_CH_NUM] = 
-        { 
-          osSemaphore(sem_dma_ch0),
-          osSemaphore(sem_dma_ch1),
-          osSemaphore(sem_dma_ch2),
-          osSemaphore(sem_dma_ch3),
-          osSemaphore(sem_dma_ch4),
-          osSemaphore(sem_dma_ch5),
-          osSemaphore(sem_dma_ch6),
-          osSemaphore(sem_dma_ch7),
-          osSemaphore(sem_dma_ch8),
-          osSemaphore(sem_dma_ch9),
-          osSemaphore(sem_dma_ch10),
-          osSemaphore(sem_dma_ch11),
-          osSemaphore(sem_dma_ch12),
-          osSemaphore(sem_dma_ch13),
-          osSemaphore(sem_dma_ch14),
-          osSemaphore(sem_dma_ch15)
-        };
-    
     /* element of p_dma_init_param is copied to element of gb_info_drv */
     gb_info_drv.p_err_aio = p_dma_init_param->p_aio;
     
-    /* set driver semaphore ID */
-    gb_info_drv.sem_drv = sem_drv;
-    
     /* set DMA error interrupt number */
     gb_info_drv.err_irq_num = DMAERR_IRQn;
     
@@ -365,27 +311,6 @@
        set round robin mode */
     gb_info_drv.info_ch[HIGH_COMMON_REG_OFFSET].p_dma_common_reg->DCTRL_0_7 = DCTRL_INIT_VALUE;
     
-    /* making channel semaphore */
-    init_check_flag = false;
-    ch_count = 0;
-    while (false == init_check_flag)
-    {
-        /* make semaphore */
-        gb_info_drv.info_ch[ch_count].sem_ch = osSemaphoreCreate(p_gb_semdef_ch[ch_count], 1);
-        if (NULL == gb_info_drv.info_ch[ch_count].sem_ch)
-        {
-            /* set error return value */
-            retval = ENOMEM;
-            init_check_flag = true;
-        }
-        
-        if ((DMA_CH_NUM - 1) == ch_count)
-        {
-            init_check_flag = true;
-        }
-        ch_count++;
-    }
-    
     if (ESUCCESS == retval)
     {
         /* DMA end interrupt handler register */
@@ -469,8 +394,7 @@
 * Return Value : ESUCCESS -
 *                  Operation successful.
 *                OS error num -
-*                  Unregistering handler failed,
-*                  or Semaphore release failed.
+*                  Unregistering handler failed
 ******************************************************************************/
 
 int_t DMA_UnInitialize(void)
@@ -478,7 +402,6 @@
     int_t            retval = ESUCCESS;
     int_t            ch_count;
     uint32_t         error_code;
-    osStatus         sem_status;
     bool_t           uninit_check_flag;
 
     /* init DMA registers */
@@ -540,29 +463,6 @@
 
     if (ESUCCESS == retval)
     {
-        /* delete channel semaphore */
-        ch_count = 0;
-        uninit_check_flag = false;
-        while (false == uninit_check_flag)
-        {
-            /* semaphore delete */
-            sem_status = osSemaphoreDelete(gb_info_drv.info_ch[ch_count].sem_ch);
-            if (osOK != sem_status)
-            {
-                /* set error return value */
-                retval = (int_t)sem_status;
-                uninit_check_flag = true;
-            }
-            if ((DMA_CH_NUM - 1) == ch_count)
-            {
-                uninit_check_flag = true;
-            }
-            ch_count++;
-        }
-    }
-    
-    if (ESUCCESS == retval)
-    {
         /* set channel status to DMA_CH_UNINIT */
         for (ch_count = 0; ch_count < DMA_CH_NUM; ch_count++)
         {
@@ -607,10 +507,8 @@
 * Return Value :   channel -
 *                     Open channel number.
 *                  error code -
-*                     OS error num : Semaphore release failed.
-*                     EMFILE : When looking for a free channel, but a free channel
-*                              didn't exist.
-*                     EFAULT:  Wait semaphore failed.
+*                     EMFILE : When looking for a free channel, but a free
+*                              channel didn't exist.
 ******************************************************************************/
 
 int_t DMA_GetFreeChannel(void)
@@ -618,8 +516,6 @@
     int_t           retval = EFAULT;
     dma_info_ch_t   *dma_info_ch;
     int_t           ch_alloc;
-    int_t           sem_wait_status;
-    osStatus        sem_release_status;
     bool_t          ch_stat_check_flag;
     
     /* looking for free channel */
@@ -628,21 +524,6 @@
     while (false == ch_stat_check_flag)
     {
         dma_info_ch = DMA_GetDrvChInfo(ch_alloc);
-        /* start semaphore wait forever */
-        /* check carrying out on the task (0) */
-        if (0 == R_ExceptionalMode())
-        {
-            /* ->MISRA 10.6, osWaitForever is defined by the header got from related section*/ 
-            sem_wait_status = osSemaphoreWait(dma_info_ch->sem_ch, osWaitForever);
-            /* <-MISRA 10.6 */
-            /* semaphore error check */
-            if ((-1) == sem_wait_status)
-            {
-                /* set error return value */
-                retval = EFAULT;
-                ch_stat_check_flag = true;
-            }
-        }
                         
         if (false == ch_stat_check_flag)
         {
@@ -650,36 +531,8 @@
             {
                 DMA_OpenChannel(ch_alloc);
                 retval = ch_alloc;
-                /* semaphore release */
-                /* check carrying out on the task (0) */
-                if (0 == R_ExceptionalMode())
-                {
-                    sem_release_status = osSemaphoreRelease(dma_info_ch->sem_ch);
-                    /* semaphore error check */
-                    if (osOK != sem_release_status)
-                    {
-                        /* set error return value */
-                        retval = (int_t)sem_release_status;
-                    }
-                }   
                 ch_stat_check_flag = true;
             }
-            else
-            {
-                /* semaphore release */
-                /* check carrying out on the task (0) */
-                if (0 == R_ExceptionalMode())
-                {
-                    sem_release_status = osSemaphoreRelease(dma_info_ch->sem_ch);
-                    /* semaphore error check */
-                    if (osOK != sem_release_status)
-                    {
-                        /* set error return value */
-                        retval = (int_t)sem_release_status;
-                        ch_stat_check_flag = true;
-                    }
-                }
-            }
             if (false ==  ch_stat_check_flag)
             {
                 ch_alloc++;
@@ -709,37 +562,19 @@
 * Return Value :   channel -
 *                     Open channel number.
 *                  error code -
-*                     OS error num : Semaphore release failed.
 *                     EBUSY : It has been allocated already in channel.
 *                     ENOTSUP : Channel status is DMA_CH_UNINIT.
 *                     EFAULT: Channel status is besides the status definded in 
 *                             dma_stat_ch_t.
-*                             Wait semaphore failed.
 ******************************************************************************/
 
 int_t DMA_GetFixedChannel(const int_t channel)
 {
     int_t           retval = ESUCCESS;
     dma_info_ch_t   *dma_info_ch;
-    int_t           sem_wait_status;
-    osStatus        sem_release_status;
     
     /* allocate the specified number */
     dma_info_ch = DMA_GetDrvChInfo(channel);
-    /* start semaphore wait forever */
-    /* check carrying out on the task (0) */
-    if (0 == R_ExceptionalMode())
-    {
-        /* ->MISRA 10.6, osWaitForever is defined by the header got from related section*/ 
-        sem_wait_status = osSemaphoreWait(dma_info_ch->sem_ch, osWaitForever);
-        /* <-MISRA 10.6 */
-        /* semaphore error check */
-        if ((-1) == sem_wait_status)
-        {
-            /* set error return value */
-            retval = EFAULT;
-        }
-    }
             
     if (ESUCCESS == retval)
     {
@@ -769,18 +604,6 @@
                                     
             }
         }
-        /* semaphore release */
-        /* check carrying out on the task (0) */
-        if (0 == R_ExceptionalMode())
-        {
-            sem_release_status = osSemaphoreRelease(dma_info_ch->sem_ch);
-            /* semaphore error check */
-            if (osOK != sem_release_status)
-            {
-                /* set error return value */
-                retval = (int_t)sem_release_status;
-            }
-        }
     }
     
     return retval;
@@ -801,18 +624,9 @@
 
 void DMA_CloseChannel(const int_t channel)
 {
-    int_t  was_masked;
-    
-    /* disable all irq */
-    was_masked = __disable_irq();
     /* clear DMARS register */
     *(gb_info_drv.info_ch[channel].p_dma_dmars_reg) &= gb_info_drv.info_ch[channel].mask_dmars;
-    if (0 == was_masked)
-    {
-        /* enable all irq */
-        __enable_irq();
-        
-    }
+
     /* set channel status to DMA_CH_INIT */
     gb_info_drv.info_ch[channel].ch_stat = DMA_CH_INIT;
     
@@ -842,7 +656,6 @@
 {
     uint32_t  chcfg_sel;
     uint32_t  value_dmars;
-    int_t     was_masked;
     
     /* set DMA transfer parameter to DMA channel infomation */
     gb_info_drv.info_ch[channel].resource =  p_ch_setup->resource;
@@ -853,19 +666,12 @@
     gb_info_drv.info_ch[channel].dst_cnt =   p_ch_setup->dst_cnt;
     gb_info_drv.info_ch[channel].p_end_aio = p_ch_setup->p_aio;
     
-    /* disable all irq */
-    was_masked = __disable_irq();
     /* set DMARS value and protect non change bit */
     value_dmars = *(gb_info_drv.info_ch[channel].p_dma_dmars_reg);
     value_dmars = ((value_dmars & gb_info_drv.info_ch[channel].mask_dmars) |
                    (uint32_t)(p_ch_cfg->dmars << gb_info_drv.info_ch[channel].shift_dmars)); 
     /* set DMARS register value */
     *(gb_info_drv.info_ch[channel].p_dma_dmars_reg) = value_dmars;
-    if (0 == was_masked)
-    {
-        /* enable all irq */
-        __enable_irq();
-    }
         
     /* set CHCFG regsiter */
     if (channel < HIGH_COMMON_REG_OFFSET)
@@ -1642,10 +1448,17 @@
 __inline static void R_DMA_EndHandlerProcess(const int_t channel)
 {
     bool_t   store_next_dma_flag;
+    int_t    was_masked;
     
     if (NULL != gb_info_drv.info_ch[channel].p_end_aio)
     {
-    
+        /* disable all irq */
+#if defined (__ICCARM__)
+        was_masked = __disable_irq_iar();
+#else
+        was_masked = __disable_irq();
+#endif
+
         /* store next_dma_flag */
         store_next_dma_flag = gb_info_drv.info_ch[channel].next_dma_flag;
     
@@ -1689,16 +1502,21 @@
         /* clear TC, END bit */
         gb_info_drv.info_ch[channel].p_dma_ch_reg->CHCTRL_n = (CHCTRL_SET_CLRTC | CHCTRL_SET_CLREND);
 
+        if (0 == was_masked)
+        {
+            __enable_irq();
+        }
+
         /* call back to the module function which called DMA driver */
         ahf_complete(NULL, gb_info_drv.info_ch[channel].p_end_aio);
-        
     }
     else
     {
         ;
         /* NON_NOTICE_ASSERT:<callback pointer is NULL> */
     }
-    
+
+    return;
 }
 
 /******************************************************************************