Minor fixes in default configuration files in RM
[keystone-rtos/edma3_lld.git] / packages / ti / sdo / edma3 / rm / sample / src / bios6_edma3_rm_sample_cs.c
1 /*******************************************************************************
2 **+--------------------------------------------------------------------------+**
3 **|                            ****                                          |**
4 **|                            ****                                          |**
5 **|                            ******o***                                    |**
6 **|                      ********_///_****                                   |**
7 **|                      ***** /_//_/ ****                                   |**
8 **|                       ** ** (__/ ****                                    |**
9 **|                           *********                                      |**
10 **|                            ****                                          |**
11 **|                            ***                                           |**
12 **|                                                                          |**
13 **|         Copyright (c) 1998-2006 Texas Instruments Incorporated           |**
14 **|                        ALL RIGHTS RESERVED                               |**
15 **|                                                                          |**
16 **| Permission is hereby granted to licensees of Texas Instruments           |**
17 **| Incorporated (TI) products to use this computer program for the sole     |**
18 **| purpose of implementing a licensee product based on TI products.         |**
19 **| No other rights to reproduce, use, or disseminate this computer          |**
20 **| program, whether in part or in whole, are granted.                       |**
21 **|                                                                          |**
22 **| TI makes no representation or warranties with respect to the             |**
23 **| performance of this computer program, and specifically disclaims         |**
24 **| any responsibility for any damages, special or consequential,            |**
25 **| connected with the use of this program.                                  |**
26 **|                                                                          |**
27 **+--------------------------------------------------------------------------+**
28 *******************************************************************************/
30 /** \file   bios6_edma3_rm_sample_cs.c
32     \brief  Sample functions showing the implementation of Critical section
33             entry/exit routines and various semaphore related routines (all OS
34             depenedent). These implementations MUST be provided by the user /
35             application, using the EDMA3 Resource Manager, for its
36             correct functioning.
38     (C) Copyright 2006, Texas Instruments, Inc
40     \version    1.0   Anuj Aggarwal         - Created
42  */
44 #include <ti/sysbios/family/c64p/EventCombiner.h>
45 #include <ti/sysbios/hal/Hwi.h>
46 #include <ti/sysbios/knl/Task.h>
47 #include <ti/sysbios/ipc/Semaphore.h>
49 #include <ti/sdo/edma3/rm/sample/bios6_edma3_rm_sample.h>
53 /**
54  * \brief   EDMA3 OS Protect Entry
55  *
56  *      This function saves the current state of protection in 'intState'
57  *      variable passed by caller, if the protection level is
58  *      EDMA3_OS_PROTECT_INTERRUPT. It then applies the requested level of
59  *      protection.
60  *      For EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION and
61  *      EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR, variable 'intState' is ignored,
62  *      and the requested interrupt is disabled.
63  *      For EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR, '*intState' specifies the
64  *      Transfer Controller number whose interrupt needs to be disabled.
65  *
66  * \param   level is numeric identifier of the desired degree of protection.
67  * \param   intState is memory location where current state of protection is
68  *      saved for future use while restoring it via edma3OsProtectExit() (Only
69  *      for EDMA3_OS_PROTECT_INTERRUPT protection level).
70  * \return  None
71  */
72 void edma3OsProtectEntry (int level, unsigned int *intState)
73     {
74     if (((level == EDMA3_OS_PROTECT_INTERRUPT)
75         || (level == EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR))
76         && (intState == NULL))
77         {
78         return;
79         }
80     else
81         {
82         switch (level)
83             {
84             /* Disable all (global) interrupts */
85             case EDMA3_OS_PROTECT_INTERRUPT :
86                 *intState = Hwi_disable();
87                 break;
89             /* Disable scheduler */
90             case EDMA3_OS_PROTECT_SCHEDULER :
91                                 Task_disable();
92                 break;
94             /* Disable EDMA3 transfer completion interrupt only */
95             case EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION :
96                 EventCombiner_disableEvent(ccXferCompInt);
97                 break;
99             /* Disable EDMA3 CC error interrupt only */
100             case EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR :
101                 EventCombiner_disableEvent(ccErrorInt);
102                 break;
104             /* Disable EDMA3 TC error interrupt only */
105             case EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR :
106                 switch (*intState)
107                     {
108                     case 0:
109                     case 1:
110                     case 2:
111                     case 3:
112                     case 4:
113                     case 5:
114                     case 6:
115                     case 7:
116                         /* Fall through... */
117                         /* Disable the corresponding interrupt */
118                         EventCombiner_disableEvent(tcErrorInt[*intState]);
119                         break;
121                      default:
122                         break;
123                     }
125                 break;
127             default:
128                 break;
129             }
130         }
131     }
134 /**
135  * \brief   EDMA3 OS Protect Exit
136  *
137  *      This function undoes the protection enforced to original state
138  *      as is specified by the variable 'intState' passed, if the protection
139  *      level is EDMA3_OS_PROTECT_INTERRUPT.
140  *      For EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION and
141  *      EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR, variable 'intState' is ignored,
142  *      and the requested interrupt is enabled.
143  *      For EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR, 'intState' specifies the
144  *      Transfer Controller number whose interrupt needs to be enabled.
145  * \param   level is numeric identifier of the desired degree of protection.
146  * \param   intState is original state of protection at time when the
147  *      corresponding edma3OsProtectEntry() was called (Only
148  *      for EDMA3_OS_PROTECT_INTERRUPT protection level).
149  * \return  None
150  */
151 void edma3OsProtectExit (int level, unsigned int intState)
152     {
153     switch (level)
154         {
155         /* Enable all (global) interrupts */
156         case EDMA3_OS_PROTECT_INTERRUPT :
157             Hwi_restore(intState);
158             break;
160         /* Enable scheduler */
161         case EDMA3_OS_PROTECT_SCHEDULER :
162             Task_enable();
163             break;
165         /* Enable EDMA3 transfer completion interrupt only */
166         case EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION :
167             EventCombiner_enableEvent(ccXferCompInt);
168             break;
170         /* Enable EDMA3 CC error interrupt only */
171         case EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR :
172             EventCombiner_enableEvent(ccErrorInt);
173             break;
175         /* Enable EDMA3 TC error interrupt only */
176         case EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR :
177             switch (intState)
178                 {
179                 case 0:
180                 case 1:
181                 case 2:
182                 case 3:
183                 case 4:
184                 case 5:
185                 case 6:
186                 case 7:
187                     /* Fall through... */
188                     /* Enable the corresponding interrupt */
189                     EventCombiner_enableEvent(tcErrorInt[intState]);
190                     break;
192                  default:
193                     break;
194                 }
196             break;
198         default:
199             break;
200         }
201     }
204 /**
205   * Counting Semaphore related functions (OS dependent) should be
206   * called/implemented by the application. A handle to the semaphore
207   * is required while opening the resource manager instance.
208   */
210 /**
211  * \brief   EDMA3 OS Semaphore Create
212  *
213  *      This function creates a counting semaphore with specified
214  *      attributes and initial value. It should be used to create a semaphore
215  *      with initial value as '1'. The semaphore is then passed by the user
216  *      to the EDMA3 RM for proper sharing of resources.
217  * \param   initVal [IN] is initial value for semaphore
218  * \param   semParams [IN] is the semaphore attributes.
219  * \param   hSem [OUT] is location to recieve the handle to just created
220  *      semaphore
221  * \return  EDMA3_RM_SOK if succesful, else a suitable error code.
222  */
223 EDMA3_RM_Result edma3OsSemCreate(int initVal,
224                                                         const Semaphore_Params *semParams,
225                                 EDMA3_OS_Sem_Handle *hSem)
226     {
227     EDMA3_RM_Result semCreateResult = EDMA3_RM_SOK;
229     if(NULL == hSem)
230         {
231         semCreateResult = EDMA3_RM_E_INVALID_PARAM;
232         }
233     else
234         {
235         *hSem = (EDMA3_OS_Sem_Handle)Semaphore_create(initVal, semParams, NULL);
236         if ( (*hSem) == NULL )
237             {
238             semCreateResult = EDMA3_RM_E_SEMAPHORE;
239             }
240         }
242     return semCreateResult;
243     }
246 /**
247  * \brief   EDMA3 OS Semaphore Delete
248  *
249  *      This function deletes or removes the specified semaphore
250  *      from the system. Associated dynamically allocated memory
251  *      if any is also freed up.
252  * \param   hSem [IN] handle to the semaphore to be deleted
253  * \return  EDMA3_RM_SOK if succesful else a suitable error code
254  */
255 EDMA3_RM_Result edma3OsSemDelete(EDMA3_OS_Sem_Handle hSem)
256     {
257     EDMA3_RM_Result semDeleteResult = EDMA3_RM_SOK;
259     if(NULL == hSem)
260         {
261         semDeleteResult = EDMA3_RM_E_INVALID_PARAM;
262         }
263     else
264         {
265                 Semaphore_delete(hSem);
266         }
268     return semDeleteResult;
269     }
272 /**
273  * \brief   EDMA3 OS Semaphore Take
274  *
275  *      This function takes a semaphore token if available.
276  *      If a semaphore is unavailable, it blocks currently
277  *      running thread in wait (for specified duration) for
278  *      a free semaphore.
279  * \param   hSem [IN] is the handle of the specified semaphore
280  * \param   mSecTimeout [IN] is wait time in milliseconds
281  * \return  EDMA3_RM_Result if successful else a suitable error code
282  */
283 EDMA3_RM_Result edma3OsSemTake(EDMA3_OS_Sem_Handle hSem, int mSecTimeout)
284     {
285     EDMA3_RM_Result semTakeResult = EDMA3_RM_SOK;
286     unsigned short semPendResult;
288     if(NULL == hSem)
289         {
290         semTakeResult = EDMA3_RM_E_INVALID_PARAM;
291         }
292     else
293         {
294         semPendResult = Semaphore_pend(hSem, mSecTimeout);
295         if (semPendResult == FALSE)
296             {
297             semTakeResult = EDMA3_RM_E_SEMAPHORE;
298             }
299         }
301     return semTakeResult;
302     }
305 /**
306  * \brief   EDMA3 OS Semaphore Give
307  *
308  *      This function gives or relinquishes an already
309  *      acquired semaphore token
310  * \param   hSem [IN] is the handle of the specified semaphore
311  * \return  EDMA3_RM_Result if successful else a suitable error code
312  */
313 EDMA3_RM_Result edma3OsSemGive(EDMA3_OS_Sem_Handle hSem)
314     {
315     EDMA3_RM_Result semGiveResult = EDMA3_RM_SOK;
317     if(NULL == hSem)
318         {
319         semGiveResult = EDMA3_RM_E_INVALID_PARAM;
320         }
321     else
322         {
323                 Semaphore_post(hSem);
324         }
326     return semGiveResult;
327     }