PRSDK-3391 Wrapper function for handling Interrupt
[keystone-rtos/edma3_lld.git] / packages / ti / sdo / edma3 / rm / sample / src / sample_cs.c
1 /*\r
2  * sample_cs.c\r
3  *\r
4  * Sample functions showing the implementation of critical section entry/exit\r
5  * routines and various semaphore related routines (all OS depenedent). These\r
6  * implementations MUST be provided by the user / application, using the EDMA3\r
7  * Resource Manager, for its correct functioning.\r
8  *\r
9  * Copyright (C) 2009-2017 Texas Instruments Incorporated - http://www.ti.com/\r
10  *\r
11  *\r
12  *  Redistribution and use in source and binary forms, with or without\r
13  *  modification, are permitted provided that the following conditions\r
14  *  are met:\r
15  *\r
16  *    Redistributions of source code must retain the above copyright\r
17  *    notice, this list of conditions and the following disclaimer.\r
18  *\r
19  *    Redistributions in binary form must reproduce the above copyright\r
20  *    notice, this list of conditions and the following disclaimer in the\r
21  *    documentation and/or other materials provided with the\r
22  *    distribution.\r
23  *\r
24  *    Neither the name of Texas Instruments Incorporated nor the names of\r
25  *    its contributors may be used to endorse or promote products derived\r
26  *    from this software without specific prior written permission.\r
27  *\r
28  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
29  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\r
30  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
31  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\r
32  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
33  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\r
34  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
35  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
36  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
37  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
38  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
39  *\r
40 */\r
41 \r
42 #include <ti/sysbios/family/c64p/EventCombiner.h>\r
43 #include <ti/sysbios/hal/Hwi.h>\r
44 #include <ti/sysbios/knl/Task.h>\r
45 #include <ti/sysbios/knl/Semaphore.h>\r
46 \r
47 #include <ti/sdo/edma3/rm/sample/bios6_edma3_rm_sample.h>\r
48 \r
49 extern uint32_t tcErrorInt[EDMA3_MAX_EDMA3_INSTANCES][EDMA3_MAX_TC];\r
50 extern void enableXferCompInterrupt(uint32_t edma3Id);\r
51 extern void disableXferCompInterrupt(uint32_t edma3Id);\r
52 extern void enableErrorInterrupt(uint32_t edma3Id);\r
53 extern void disableErrorInterrupt(uint32_t edma3Id);\r
54 \r
55 /**\r
56  * Shadow Region on which the executable is running. Its value is\r
57  * populated with the DSP Instance Number here in this case.\r
58  */\r
59 extern uint32_t region_id;\r
60 \r
61 /**\r
62  * \brief   EDMA3 OS Protect Entry\r
63  *\r
64  *      This function saves the current state of protection in 'intState'\r
65  *      variable passed by caller, if the protection level is\r
66  *      EDMA3_OS_PROTECT_INTERRUPT. It then applies the requested level of\r
67  *      protection.\r
68  *      For EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION and\r
69  *      EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR, variable 'intState' is ignored,\r
70  *      and the requested interrupt is disabled.\r
71  *      For EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR, '*intState' specifies the\r
72  *      Transfer Controller number whose interrupt needs to be disabled.\r
73  *\r
74  * \param   level is numeric identifier of the desired degree of protection.\r
75  * \param   intState is memory location where current state of protection is\r
76  *      saved for future use while restoring it via edma3OsProtectExit() (Only\r
77  *      for EDMA3_OS_PROTECT_INTERRUPT protection level).\r
78  * \return  None\r
79  */\r
80 void edma3OsProtectEntry (uint32_t edma3InstanceId,\r
81                                                         int32_t level, uint32_t *intState)\r
82     {\r
83     if (((level == EDMA3_OS_PROTECT_INTERRUPT)\r
84         || (level == EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR))\r
85         && (intState == NULL))\r
86         {\r
87             /* Nothing to be done here */\r
88         }\r
89         else\r
90         {\r
91         switch (level)\r
92             {\r
93             /* Disable all (global) interrupts */\r
94             case EDMA3_OS_PROTECT_INTERRUPT :\r
95                 *intState = Hwi_disable();\r
96                 break;\r
97 \r
98             /* Disable scheduler */\r
99             case EDMA3_OS_PROTECT_SCHEDULER :\r
100                                 Task_disable();\r
101                 break;\r
102 \r
103             /* Disable EDMA3 transfer completion interrupt only */\r
104             case EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION :\r
105                 disableXferCompInterrupt(edma3InstanceId);\r
106                 //EventCombiner_disableEvent(ccXferCompInt[edma3InstanceId][region_id]);\r
107                 break;\r
108 \r
109             /* Disable EDMA3 CC error interrupt only */\r
110             case EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR :\r
111                 disableErrorInterrupt(edma3InstanceId);\r
112                 //EventCombiner_disableEvent(ccErrorInt[edma3InstanceId]);\r
113                 break;\r
114 \r
115             /* Disable EDMA3 TC error interrupt only */\r
116             case EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR :\r
117                 switch (*intState)\r
118                     {\r
119                     case 0:\r
120                     case 1:\r
121                     case 2:\r
122                     case 3:\r
123                     case 4:\r
124                     case 5:\r
125                     case 6:\r
126                     case 7:\r
127                         /* Fall through... */\r
128                         /* Disable the corresponding interrupt */\r
129                         EventCombiner_disableEvent(tcErrorInt[edma3InstanceId][*intState]);\r
130                         break;\r
131 \r
132                      default:\r
133                         break;\r
134                     }\r
135 \r
136                 break;\r
137 \r
138             default:\r
139                 break;\r
140             }\r
141         }\r
142         return;\r
143     }\r
144 \r
145 \r
146 /**\r
147  * \brief   EDMA3 OS Protect Exit\r
148  *\r
149  *      This function undoes the protection enforced to original state\r
150  *      as is specified by the variable 'intState' passed, if the protection\r
151  *      level is EDMA3_OS_PROTECT_INTERRUPT.\r
152  *      For EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION and\r
153  *      EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR, variable 'intState' is ignored,\r
154  *      and the requested interrupt is enabled.\r
155  *      For EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR, 'intState' specifies the\r
156  *      Transfer Controller number whose interrupt needs to be enabled.\r
157  * \param   level is numeric identifier of the desired degree of protection.\r
158  * \param   intState is original state of protection at time when the\r
159  *      corresponding edma3OsProtectEntry() was called (Only\r
160  *      for EDMA3_OS_PROTECT_INTERRUPT protection level).\r
161  * \return  None\r
162  */\r
163 void edma3OsProtectExit (uint32_t edma3InstanceId,\r
164                         int32_t level, uint32_t intState)\r
165     {\r
166     switch (level)\r
167         {\r
168         /* Enable all (global) interrupts */\r
169         case EDMA3_OS_PROTECT_INTERRUPT :\r
170             Hwi_restore(intState);\r
171             break;\r
172 \r
173         /* Enable scheduler */\r
174         case EDMA3_OS_PROTECT_SCHEDULER :\r
175             Task_enable();\r
176             break;\r
177 \r
178         /* Enable EDMA3 transfer completion interrupt only */\r
179         case EDMA3_OS_PROTECT_INTERRUPT_XFER_COMPLETION :\r
180             enableXferCompInterrupt(edma3InstanceId);\r
181             //EventCombiner_enableEvent(ccXferCompInt[edma3InstanceId][region_id]);\r
182             break;\r
183 \r
184         /* Enable EDMA3 CC error interrupt only */\r
185         case EDMA3_OS_PROTECT_INTERRUPT_CC_ERROR :\r
186             enableErrorInterrupt(edma3InstanceId);\r
187             //EventCombiner_enableEvent(ccErrorInt[edma3InstanceId]);\r
188             break;\r
189 \r
190         /* Enable EDMA3 TC error interrupt only */\r
191         case EDMA3_OS_PROTECT_INTERRUPT_TC_ERROR :\r
192             switch ((int32_t)intState)\r
193                 {\r
194                 case 0:\r
195                 case 1:\r
196                 case 2:\r
197                 case 3:\r
198                 case 4:\r
199                 case 5:\r
200                 case 6:\r
201                 case 7:\r
202                     /* Fall through... */\r
203                     /* Enable the corresponding interrupt */\r
204                                         //enableTCErrorInterrupt(edma3InstanceId);\r
205                     EventCombiner_enableEvent(tcErrorInt[edma3InstanceId][intState]);\r
206                     break;\r
207 \r
208                  default:\r
209                     break;\r
210                 }\r
211 \r
212             break;\r
213 \r
214         default:\r
215             break;\r
216         }\r
217     }\r
218 \r
219 \r
220 /**\r
221   * Counting Semaphore related functions (OS dependent) should be\r
222   * called/implemented by the application. A handle to the semaphore\r
223   * is required while opening the resource manager instance.\r
224   */\r
225 \r
226 /**\r
227  * \brief   EDMA3 OS Semaphore Create\r
228  *\r
229  *      This function creates a counting semaphore with specified\r
230  *      attributes and initial value. It should be used to create a semaphore\r
231  *      with initial value as '1'. The semaphore is then passed by the user\r
232  *      to the EDMA3 RM for proper sharing of resources.\r
233  * \param   initVal [IN] is initial value for semaphore\r
234  * \param   semParams [IN] is the semaphore attributes.\r
235  * \param   hSem [OUT] is location to recieve the handle to just created\r
236  *      semaphore\r
237  * \return  EDMA3_RM_SOK if succesful, else a suitable error code.\r
238  */\r
239 EDMA3_RM_Result edma3OsSemCreate(int32_t initVal,\r
240                                                         const Semaphore_Params *semParams,\r
241                                 EDMA3_OS_Sem_Handle *hSem)\r
242     {\r
243     EDMA3_RM_Result semCreateResult = EDMA3_RM_SOK;\r
244 \r
245     if(NULL == hSem)\r
246         {\r
247         semCreateResult = EDMA3_RM_E_INVALID_PARAM;\r
248         }\r
249     else\r
250         {\r
251         *hSem = (EDMA3_OS_Sem_Handle)Semaphore_create(initVal, semParams, NULL);\r
252         if ( (*hSem) == NULL )\r
253             {\r
254             semCreateResult = EDMA3_RM_E_SEMAPHORE;\r
255             }\r
256         }\r
257 \r
258     return semCreateResult;\r
259     }\r
260 \r
261 \r
262 /**\r
263  * \brief   EDMA3 OS Semaphore Delete\r
264  *\r
265  *      This function deletes or removes the specified semaphore\r
266  *      from the system. Associated dynamically allocated memory\r
267  *      if any is also freed up.\r
268  * \param   hSem [IN] handle to the semaphore to be deleted\r
269  * \return  EDMA3_RM_SOK if succesful else a suitable error code\r
270  */\r
271 EDMA3_RM_Result edma3OsSemDelete(EDMA3_OS_Sem_Handle hSem)\r
272     {\r
273     EDMA3_RM_Result semDeleteResult = EDMA3_RM_SOK;\r
274 \r
275     if(NULL == hSem)\r
276         {\r
277         semDeleteResult = EDMA3_RM_E_INVALID_PARAM;\r
278         }\r
279     else\r
280         {\r
281                 Semaphore_delete(hSem);\r
282         }\r
283 \r
284     return semDeleteResult;\r
285     }\r
286 \r
287 \r
288 /**\r
289  * \brief   EDMA3 OS Semaphore Take\r
290  *\r
291  *      This function takes a semaphore token if available.\r
292  *      If a semaphore is unavailable, it blocks currently\r
293  *      running thread in wait (for specified duration) for\r
294  *      a free semaphore.\r
295  * \param   hSem [IN] is the handle of the specified semaphore\r
296  * \param   mSecTimeout [IN] is wait time in milliseconds\r
297  * \return  EDMA3_Result if successful else a suitable error code\r
298  */\r
299 EDMA3_Result edma3OsSemTake(EDMA3_OS_Sem_Handle hSem, int32_t mSecTimeout)\r
300     {\r
301     EDMA3_Result semTakeResult = EDMA3_RM_SOK;\r
302 \r
303     if(NULL == hSem)\r
304         {\r
305         semTakeResult = EDMA3_RM_E_INVALID_PARAM;\r
306         }\r
307     else\r
308         {\r
309         if((Semaphore_pend(hSem, (uint32_t)mSecTimeout)) == FALSE)\r
310             {\r
311                 semTakeResult = EDMA3_RM_E_SEMAPHORE;\r
312             }\r
313         }\r
314 \r
315     return semTakeResult;\r
316     }\r
317 \r
318 \r
319 /**\r
320  * \brief   EDMA3 OS Semaphore Give\r
321  *\r
322  *      This function gives or relinquishes an already\r
323  *      acquired semaphore token\r
324  * \param   hSem [IN] is the handle of the specified semaphore\r
325  * \return  EDMA3_Result if successful else a suitable error code\r
326  */\r
327 EDMA3_Result edma3OsSemGive(EDMA3_OS_Sem_Handle hSem)\r
328     {\r
329     EDMA3_Result semGiveResult = EDMA3_RM_SOK;\r
330 \r
331     if(NULL == hSem)\r
332         {\r
333         semGiveResult = EDMA3_RM_E_INVALID_PARAM;\r
334         }\r
335     else\r
336         {\r
337                 Semaphore_post(hSem);\r
338         }\r
339 \r
340     return semGiveResult;\r
341     }\r
342 \r
343 /* End of File */\r
344 \r