Add config to allow VPSS-M3 to EVE communication
[ipc/ipcdev.git] / packages / ti / sdo / ipc / family / c6a8149 / InterruptDucati.c
1 /*
2  * Copyright (c) 2012-2013, Texas Instruments Incorporated
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * *  Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  * *  Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * *  Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32 /*
33  *  ======== InterruptDucati.c ========
34  *  Ducati/TI81xx based interupt manager
35  */
37 #include <xdc/std.h>
38 #include <xdc/runtime/Assert.h>
39 #include <xdc/runtime/Error.h>
41 #include <ti/sysbios/BIOS.h>
42 #include <ti/sysbios/family/arm/m3/Hwi.h>
43 #include <ti/sysbios/family/arm/ducati/Core.h>
44 #include <ti/sdo/ipc/notifyDrivers/IInterrupt.h>
45 #include <ti/sdo/ipc/_Ipc.h>
46 #include <ti/sdo/utils/_MultiProc.h>
48 #include "package/internal/InterruptDucati.xdc.h"
50 /* Register access method. */
51 #define REG16(A)   (*(volatile UInt16 *) (A))
52 #define REG32(A)   (*(volatile UInt32 *) (A))
54 /*
55  *  Ducati control register that maintains inter-core interrupt bits.
56  *
57  *  Using separate VIDEO and VPSS values to do 16-bit reads/writes
58  *  because we do not want to overwrite the other cores value.
59  */
60 #define INTERRUPT_VIDEO           (InterruptDucati_ducatiCtrlBaseAddr)
61 #define INTERRUPT_VPSS            (InterruptDucati_ducatiCtrlBaseAddr + 2)
63 /* Assigned mailboxes */
64 #define DSP_TO_HOST      0
65 #define DSP_TO_VIDEO     1
66 #define DSP_TO_VPSS      2
67 #define HOST_TO_DSP      3
68 #define HOST_TO_VIDEO    4
69 #define HOST_TO_VPSS     5
70 #define VIDEO_TO_HOST    6
71 #define VIDEO_TO_DSP     7
72 #define VPSS_TO_HOST     8
73 #define VPSS_TO_DSP      9
75 #define MAILBOX_REG_VAL(M)   (0x1 << (2 * M))
77 #define MAILBOX_MESSAGE(M) (InterruptDucati_mailboxBaseAddr + 0x040 + (0x4 * M))
78 #define MAILBOX_STATUS(M)  (InterruptDucati_mailboxBaseAddr + 0x0C0 + (0x4 * M))
80 /* VIDEO registers */
81 #define MAILBOX_IRQSTATUS_CLR_VIDEO    (InterruptDucati_mailboxBaseAddr + 0x124)
82 #define MAILBOX_IRQENABLE_SET_VIDEO    (InterruptDucati_mailboxBaseAddr + 0x128)
83 #define MAILBOX_IRQENABLE_CLR_VIDEO    (InterruptDucati_mailboxBaseAddr + 0x12C)
85 /* VPSS registers */
86 #define MAILBOX_IRQSTATUS_CLR_VPSS     (InterruptDucati_mailboxBaseAddr + 0x134)
87 #define MAILBOX_IRQENABLE_SET_VPSS     (InterruptDucati_mailboxBaseAddr + 0x138)
88 #define MAILBOX_IRQENABLE_CLR_VPSS     (InterruptDucati_mailboxBaseAddr + 0x13C)
90 #define MAILBOX_M3VIDEOINT     53
91 #define MAILBOX_M3DSSINT       54
93 /* Assigned eve mailbox users */
94 #define EVE_TO_HOST     0
95 #define EVE_TO_DSP      1
96 #define EVE_TO_VIDEO    2
97 #define HOST_TO_EVE     3
98 #define DSP_TO_EVE      4
99 #define VIDEO_TO_EVE    5
101 #define EVE_MAILBOX_MESSAGE(M)      (InterruptDucati_mailboxEveBaseAddr + 0x40 + (0x4 * M))
102 #define EVE_MAILBOX_STATUS(M)       (InterruptDucati_mailboxEveBaseAddr + 0xC0 + (0x4 * M))
104 #define EVE_MAILBOX_IRQSTATUS_CLR_VIDEO   (InterruptDucati_mailboxEveBaseAddr + 0x134)
105 #define EVE_MAILBOX_IRQENABLE_SET_VIDEO   (InterruptDucati_mailboxEveBaseAddr + 0x138)
106 #define EVE_MAILBOX_IRQENABLE_CLR_VIDEO   (InterruptDucati_mailboxEveBaseAddr + 0x13C)
107 #define EVE_MAILBOX_EOI_REG               (InterruptDucati_mailboxEveBaseAddr + 0x140)
109 #define EVE_MAILBOX_M3VIDEOINT  38
111 #define M3INTERCOREINT          19
113 /*
114  *************************************************************************
115  *                      Module functions
116  *************************************************************************
117  */
119 /*
120  *  ======== InterruptDucati_intEnable ========
121  *  Enable remote processor interrupt
122  */
123 Void InterruptDucati_intEnable(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo)
125     /*
126      *  If the remote processor communicates via mailboxes, we should enable
127      *  the Mailbox IRQ instead of enabling the Hwi because multiple mailboxes
128      *  share the same Hwi
129      */
130     if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
131         if (remoteProcId == InterruptDucati_hostProcId) {
132             REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
133         }
134         else if (remoteProcId == InterruptDucati_dspProcId) {
135             REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
136         }
137         else if (remoteProcId == InterruptDucati_eveProcId) {
138             REG32(EVE_MAILBOX_IRQENABLE_SET_VIDEO) =
139                 MAILBOX_REG_VAL(EVE_TO_VIDEO);
140         }
141         else {
142             Hwi_enableInterrupt(M3INTERCOREINT);
143         }
144     }
145     else {
146         if (remoteProcId == InterruptDucati_hostProcId) {
147             REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
148         }
149         else if (remoteProcId == InterruptDucati_dspProcId) {
150             REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
151         }
152         else if (remoteProcId == InterruptDucati_eveProcId) {
153             REG32(EVE_MAILBOX_IRQENABLE_SET_VIDEO) =
154                 MAILBOX_REG_VAL(EVE_TO_VIDEO);
155         }
156         else {
157             Hwi_enableInterrupt(M3INTERCOREINT);
158         }
159     }
162 /*
163  *  ======== InterruptDucati_intDisable ========
164  *  Disables remote processor interrupt
165  */
166 Void InterruptDucati_intDisable(UInt16 remoteProcId,
167                                 IInterrupt_IntInfo *intInfo)
169     /*
170      *  If the remote processor communicates via mailboxes, we should disable
171      *  the Mailbox IRQ instead of disabling the Hwi because multiple mailboxes
172      *  share the same Hwi
173      */
174     if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
175         if (remoteProcId == InterruptDucati_hostProcId) {
176             REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
177         }
178         else if (remoteProcId == InterruptDucati_dspProcId) {
179             REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
180         }
181         else if (remoteProcId == InterruptDucati_eveProcId) {
182             REG32(EVE_MAILBOX_IRQENABLE_CLR_VIDEO) =
183                 MAILBOX_REG_VAL(EVE_TO_VIDEO);
184         }
185         else {
186             Hwi_disableInterrupt(M3INTERCOREINT);
187         }
188     }
189     else {
190         if (remoteProcId == InterruptDucati_hostProcId) {
191             REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
192         }
193         else if (remoteProcId == InterruptDucati_dspProcId) {
194             REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
195         }
196         else if (remoteProcId == InterruptDucati_eveProcId) {
197             REG32(EVE_MAILBOX_IRQENABLE_CLR_VIDEO) =
198                 MAILBOX_REG_VAL(EVE_TO_VIDEO);
199         }
200         else {
201             Hwi_disableInterrupt(M3INTERCOREINT);
202         }
203     }
206 /*
207  *  ======== InterruptDucati_intRegister ========
208  */
209 Void InterruptDucati_intRegister(UInt16 remoteProcId,
210                                  IInterrupt_IntInfo *intInfo,
211                                  Fxn func, UArg arg)
213     Hwi_Params  hwiAttrs;
214     UInt        key;
215     Int         index;
216     Error_Block eb;
217     InterruptDucati_FxnTable *table;
219     Assert_isTrue(remoteProcId < ti_sdo_utils_MultiProc_numProcessors,
220             ti_sdo_ipc_Ipc_A_internal);
222     /* Assert that our MultiProc id is set correctly */
223     Assert_isTrue((InterruptDucati_videoProcId == MultiProc_self()) ||
224                   (InterruptDucati_vpssProcId == MultiProc_self()),
225                   ti_sdo_ipc_Ipc_A_internal);
227     /* init error block */
228     Error_init(&eb);
230     /*
231      *  VPSS-M3 & VIDEO-M3 each have a unique interrupt ID for receiving
232      *  interrupts external to the Ducati subsystem.
233      *  (M3DSSINT & MAILBOX_M3VIDEOINT).
234      *  However, they have a separate interrupt ID for receving interrupt from
235      *  each other(M3INTERCOREINT).
236      *
237      *  Store the interrupt id in the intInfo so it can be used during
238      *  intUnregiseter.
239      */
240     if (remoteProcId == InterruptDucati_dspProcId) {
241         index = 0;
242         if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
243             intInfo->localIntId = MAILBOX_M3VIDEOINT;
244         }
245         else {
246             intInfo->localIntId = MAILBOX_M3DSSINT ;
247         }
248     }
249     else if (remoteProcId == InterruptDucati_hostProcId) {
250         index = 1;
251         if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
252             intInfo->localIntId = MAILBOX_M3VIDEOINT;
253         }
254         else {
255             intInfo->localIntId = MAILBOX_M3DSSINT ;
256         }
257     }
258     else if (remoteProcId == InterruptDucati_eveProcId) {
259         index = 3;
260         if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
261             if (InterruptDucati_enableVpssToEve) {
262                 /* Core0 communication to EVE is not supported */
263                 Assert_isTrue(FALSE, ti_sdo_ipc_Ipc_A_internal);
264             }
265             else {
266                 intInfo->localIntId = EVE_MAILBOX_M3VIDEOINT;
267             }
268         }
269         else {
270             if (InterruptDucati_enableVpssToEve) {
271                 /*
272                  *  Core1 communication to EVE use same mbox
273                  *  so only 1 can communicate to EVE.
274                  */
275                 intInfo->localIntId = EVE_MAILBOX_M3VIDEOINT;
276             }
277             else {
278                 /* Core1 communication to EVE is not supported */
279                 Assert_isTrue(FALSE, ti_sdo_ipc_Ipc_A_internal);
280             }
281         }
282     }
283     else {
284         /* Going to the other M3 */
285         index = 2;
286         intInfo->localIntId = M3INTERCOREINT;
287     }
289     /* Disable global interrupts */
290     key = Hwi_disable();
292     table = &(InterruptDucati_module->fxnTable[index]);
293     table->func = func;
294     table->arg  = arg;
296     InterruptDucati_intClear(remoteProcId, intInfo);
298     Hwi_Params_init(&hwiAttrs);
299     hwiAttrs.maskSetting = Hwi_MaskingOption_LOWER;
301     /* Make sure the interrupt only gets plugged once */
302     if (index == 0 || index == 1) {
303         InterruptDucati_module->numPlugged++;
304         if (InterruptDucati_module->numPlugged == 1) {
305             Hwi_create(intInfo->localIntId,
306                       (Hwi_FuncPtr)InterruptDucati_intShmMbxStub,
307                       &hwiAttrs,
308                       &eb);
310             /* Interrupt_intEnable won't enable the Hwi */
311             Hwi_enableInterrupt(intInfo->localIntId);
312         }
313     }
314     else if (index == 2) {
315         Hwi_create(intInfo->localIntId,
316                   (Hwi_FuncPtr)InterruptDucati_intShmDucatiStub,
317                   &hwiAttrs,
318                   &eb);
319     }
320     else {
321         if ((BIOS_smpEnabled) || (Core_getId() == 0) ||
322             (InterruptDucati_enableVpssToEve)) {
323             Hwi_create(intInfo->localIntId,
324                       (Hwi_FuncPtr)InterruptDucati_intShmEveMbxStub,
325                       &hwiAttrs,
326                       &eb);
328             /* Interrupt_intEnable won't enable the Hwi */
329             Hwi_enableInterrupt(intInfo->localIntId);
330         }
331     }
333     InterruptDucati_intEnable(remoteProcId, intInfo);
335     /* Restore global interrupts */
336     Hwi_restore(key);
339 /*
340  *  ======== InterruptDucati_intUnregister ========
341  */
342 Void InterruptDucati_intUnregister(UInt16 remoteProcId,
343                                    IInterrupt_IntInfo *intInfo)
345     Int         index;
346     InterruptDucati_FxnTable *table;
347     Hwi_Handle  hwiHandle;
349     if (remoteProcId == InterruptDucati_dspProcId) {
350         index = 0;
351     }
352     else if (remoteProcId == InterruptDucati_hostProcId) {
353         index = 1;
354     }
355     else if (remoteProcId == InterruptDucati_eveProcId) {
356         index = 3;
357         if (!(BIOS_smpEnabled) && (Core_getId() == 1) &&
358             !(InterruptDucati_enableVpssToEve)) {
359             /* Core1 communication to EVE is not supported */
360             return;
361         }
362     }
363     else {
364         /* Going to the other M3 */
365         index = 2;
366     }
368     /* Disable the mailbox interrupt source */
369     InterruptDucati_intDisable(remoteProcId, intInfo);
371     /* Disable the interrupt itself */
372     if (index == 0 || index == 1) {
373         /* case for DSP or HOST */
374         InterruptDucati_module->numPlugged--;
375         if (InterruptDucati_module->numPlugged == 0) {
376             hwiHandle = Hwi_getHandle(intInfo->localIntId);
377             Hwi_delete(&hwiHandle);
378         }
379     }
380     else if (index == 2) {
381         /* case for other M3 */
382         hwiHandle = Hwi_getHandle(M3INTERCOREINT);
383         Hwi_delete(&hwiHandle);
384     }
385     else {
386         /* case for EVE */
387         hwiHandle = Hwi_getHandle(intInfo->localIntId);
388         Hwi_delete(&hwiHandle);
389     }
391     /* Clear the FxnTable entry for the remote processor */
392     table = &(InterruptDucati_module->fxnTable[index]);
393     table->func = NULL;
394     table->arg  = 0;
398 /*
399  *  ======== InterruptDucati_intSend ========
400  *  Send interrupt to the remote processor
401  */
402 Void InterruptDucati_intSend(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo,
403                              UArg arg)
405     UInt key;
407     if (remoteProcId == InterruptDucati_videoProcId ||
408         remoteProcId == InterruptDucati_vpssProcId) {
409         if (!(BIOS_smpEnabled) && (Core_getId() == 1)) {
410             /* VPSS-M3 to VIDEO-M3 */
411             REG16(INTERRUPT_VIDEO) |= 0x1;
412         }
413         else {
414             /* VIDEO-M3 to VPSS-M3 */
415             REG16(INTERRUPT_VPSS) |= 0x1;
416         }
417     }
418     else if (remoteProcId == InterruptDucati_dspProcId) {
419         if (!(BIOS_smpEnabled) && (Core_getId() == 1)) {
420             /* VPSS-M3 to DSP */
421             key = Hwi_disable();
422             if (REG32(MAILBOX_STATUS(VPSS_TO_DSP)) == 0) {
423                 REG32(MAILBOX_MESSAGE(VPSS_TO_DSP)) = arg;
424             }
425             Hwi_restore(key);
426         }
427         else {
428             /* VIDEO-M3 to DSP */
429             key = Hwi_disable();
430             if (REG32(MAILBOX_STATUS(VIDEO_TO_DSP)) == 0) {
431                 REG32(MAILBOX_MESSAGE(VIDEO_TO_DSP)) = arg;
432             }
433             Hwi_restore(key);
434         }
435     }
436     else if (remoteProcId == InterruptDucati_hostProcId) {
437         if (!(BIOS_smpEnabled) && (Core_getId() == 1)) {
438             /* VPSS-M3 to HOST */
439             key = Hwi_disable();
440             if (REG32(MAILBOX_STATUS(VPSS_TO_HOST)) == 0) {
441                 REG32(MAILBOX_MESSAGE(VPSS_TO_HOST)) = arg;
442             }
443             Hwi_restore(key);
444         }
445         else {
446             /* VIDEO-M3 to HOST */
447             key = Hwi_disable();
448             if (REG32(MAILBOX_STATUS(VIDEO_TO_HOST)) == 0) {
449                 REG32(MAILBOX_MESSAGE(VIDEO_TO_HOST)) = arg;
450             }
451             Hwi_restore(key);
452         }
453     }
454     else {
455         if ((BIOS_smpEnabled) || (Core_getId() == 0) ||
456             (InterruptDucati_enableVpssToEve)) {
457             /* VIDEO-M3/VPSS-M3 to EVE */
458             key = Hwi_disable();
459             if (REG32(EVE_MAILBOX_STATUS(VIDEO_TO_EVE)) == 0) {
460                 REG32(EVE_MAILBOX_MESSAGE(VIDEO_TO_EVE)) = arg;
461             }
462             Hwi_restore(key);
463         }
464     }
468 /*
469  *  ======== InterruptDucati_intPost ========
470  *  Simulate an interrupt from a remote processor
471  */
472 Void InterruptDucati_intPost(UInt16 srcProcId, IInterrupt_IntInfo *intInfo,
473                              UArg arg)
475     UInt key;
477     if (srcProcId == InterruptDucati_videoProcId ||
478         srcProcId == InterruptDucati_vpssProcId) {
479         if (!(BIOS_smpEnabled) && (Core_getId() == 1)) {
480             /* VIDEO-M3 to VPSS-M3 */
481             REG16(INTERRUPT_VPSS) |= 0x1;
482         }
483         else {
484             /* VPSS-M3 to VIDEO-M3 */
485             REG16(INTERRUPT_VIDEO) |= 0x1;
486         }
487     }
488     else if (srcProcId == InterruptDucati_dspProcId) {
489         if (!(BIOS_smpEnabled) && (Core_getId() == 1)) {
490             /* DSP to VPSS-M3 */
491             key = Hwi_disable();
492             if (REG32(MAILBOX_STATUS(DSP_TO_VPSS)) == 0) {
493                 REG32(MAILBOX_MESSAGE(DSP_TO_VPSS)) = arg;
494             }
495             Hwi_restore(key);
496         }
497         else {
498             /* DSP to VIDEO-M3 */
499             key = Hwi_disable();
500             if (REG32(MAILBOX_STATUS(DSP_TO_VIDEO)) == 0) {
501                 REG32(MAILBOX_MESSAGE(DSP_TO_VIDEO)) = arg;
502             }
503             Hwi_restore(key);
504         }
505     }
506     else if (srcProcId == InterruptDucati_hostProcId) {
507         if (!(BIOS_smpEnabled) && (Core_getId() == 1)) {
508             /* HOST to VPSS-M3 */
509             key = Hwi_disable();
510             if (REG32(MAILBOX_STATUS(HOST_TO_VPSS)) == 0) {
511                 REG32(MAILBOX_MESSAGE(HOST_TO_VPSS)) = arg;
512             }
513             Hwi_restore(key);
514         }
515         else {
516             /* HOST to VIDEO-M3 */
517             key = Hwi_disable();
518             if (REG32(MAILBOX_STATUS(HOST_TO_VIDEO)) == 0) {
519                 REG32(MAILBOX_MESSAGE(HOST_TO_VIDEO)) = arg;
520             }
521             Hwi_restore(key);
522         }
523     }
524     else {
525         if ((BIOS_smpEnabled) || (Core_getId() == 0) ||
526             (InterruptDucati_enableVpssToEve)) {
527             /* EVE to VIDEO-M3/VPSS-M3 */
528             key = Hwi_disable();
529             if (REG32(EVE_MAILBOX_STATUS(EVE_TO_VIDEO)) == 0) {
530                 REG32(EVE_MAILBOX_MESSAGE(EVE_TO_VIDEO)) = arg;
531             }
532             Hwi_restore(key);
533         }
534     }
538 /*
539  *  ======== InterruptDucati_intClear ========
540  *  Clear interrupt
541  */
542 UInt InterruptDucati_intClear(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo)
544     UInt arg;
546     if (remoteProcId == InterruptDucati_videoProcId ||
547         remoteProcId == InterruptDucati_vpssProcId) {
548         arg = REG32(InterruptDucati_ducatiCtrlBaseAddr);
550         /* Look at BIOS's ducati Core id */
551         if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
552             if ((REG16(INTERRUPT_VIDEO) & 0x1) == 0x1) {
553                 /* VPSS-M3 to VIDEO-M3 */
554                 REG16(INTERRUPT_VIDEO) &= ~(0x1);
555             }
556         }
557         else {
558             if ((REG16(INTERRUPT_VPSS) & 0x1) == 0x1) {
559                 /* VIDEO-M3 to VPSS-M3 */
560                 REG16(INTERRUPT_VPSS) &= ~(0x1);
561             }
562         }
563     }
564     else if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
565         if (remoteProcId == InterruptDucati_hostProcId) {
566             /* HOST to VIDEO-M3 */
567             arg = REG32(MAILBOX_MESSAGE(HOST_TO_VIDEO));
568             REG32(MAILBOX_IRQSTATUS_CLR_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
569         }
570         else if (remoteProcId == InterruptDucati_dspProcId) {
571             /* DSP to VIDEO-M3 */
572             arg = REG32(MAILBOX_MESSAGE(DSP_TO_VIDEO));
573             REG32(MAILBOX_IRQSTATUS_CLR_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
574         }
575         else {
576             if (InterruptDucati_enableVpssToEve) {
577                 /* EVE cannot send an interrupt to VIDEO-M3 in this case */
578                 Assert_isTrue(FALSE, ti_sdo_ipc_Ipc_A_internal);
579                 arg = 0;    /* keep Coverity happy */
580             }
581             else {
582                 /* EVE to VIDEO-M3 */
583                 arg = REG32(EVE_MAILBOX_MESSAGE(EVE_TO_VIDEO));
584                 REG32(EVE_MAILBOX_IRQSTATUS_CLR_VIDEO) = MAILBOX_REG_VAL(EVE_TO_VIDEO);
585             }
586         }
587     }
588     else { /* M3DSSINT */
589         if (remoteProcId == InterruptDucati_hostProcId) {
590             /* HOST to VPSS-M3 */
591             arg = REG32(MAILBOX_MESSAGE(HOST_TO_VPSS));
592             REG32(MAILBOX_IRQSTATUS_CLR_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
593         }
594         else if (remoteProcId == InterruptDucati_dspProcId) {
595             /* DSP to VPSS-M3 */
596             arg = REG32(MAILBOX_MESSAGE(DSP_TO_VPSS));
597             REG32(MAILBOX_IRQSTATUS_CLR_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
598         }
599         else {
600             if (InterruptDucati_enableVpssToEve) {
601                 /* EVE to VPSS-M3 */
602                 arg = REG32(EVE_MAILBOX_MESSAGE(EVE_TO_VIDEO));
603                 REG32(EVE_MAILBOX_IRQSTATUS_CLR_VIDEO) = MAILBOX_REG_VAL(EVE_TO_VIDEO);
604             }
605             else {
606                 /* EVE cannot send an interrupt to VPSS-M3 */
607                 Assert_isTrue(FALSE, ti_sdo_ipc_Ipc_A_internal);
608                 arg = 0;    /* keep Coverity happy */
609             }
610         }
611     }
613     return (arg);
616 /*
617  *************************************************************************
618  *                      Internals functions
619  *************************************************************************
620  */
622 /*
623  *  ======== InterruptDucati_intShmDucatiStub ========
624  */
625 Void InterruptDucati_intShmDucatiStub(UArg arg)
627     InterruptDucati_FxnTable *table;
629     table = &(InterruptDucati_module->fxnTable[2]);
630     (table->func)(table->arg);
633 /*
634  *  ======== InterruptDucati_intShmMbxStub ========
635  */
636 Void InterruptDucati_intShmMbxStub(UArg arg)
638     InterruptDucati_FxnTable *table;
640     if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
641         if ((REG32(MAILBOX_IRQENABLE_SET_VIDEO) &
642                 MAILBOX_REG_VAL(DSP_TO_VIDEO)) &&
643             REG32(MAILBOX_STATUS(DSP_TO_VIDEO)) != 0) { /* DSP to VIDEO-M3 */
644             table = &(InterruptDucati_module->fxnTable[0]);
645             (table->func)(table->arg);
646         }
647         if ((REG32(MAILBOX_IRQENABLE_SET_VIDEO) &
648                 MAILBOX_REG_VAL(HOST_TO_VIDEO)) &&
649             REG32(MAILBOX_STATUS(HOST_TO_VIDEO)) != 0) { /* HOST to VIDEO-M3 */
650             table = &(InterruptDucati_module->fxnTable[1]);
651             (table->func)(table->arg);
652         }
653     }
654     else {
655         if ((REG32(MAILBOX_IRQENABLE_SET_VPSS) &
656                 MAILBOX_REG_VAL(DSP_TO_VPSS)) &&
657              REG32(MAILBOX_STATUS(DSP_TO_VPSS)) != 0) { /* DSP to VPSS-M3 */
658             table = &(InterruptDucati_module->fxnTable[0]);
659             (table->func)(table->arg);
660         }
661         if ((REG32(MAILBOX_IRQENABLE_SET_VPSS) &
662                 MAILBOX_REG_VAL(HOST_TO_VPSS)) &&
663             REG32(MAILBOX_STATUS(HOST_TO_VPSS)) != 0) { /* HOST to VPSS-M3 */
664             table = &(InterruptDucati_module->fxnTable[1]);
665             (table->func)(table->arg);
666         }
667     }
670 /*
671  *  ======== InterruptDucati_intShmEveMbxStub ========
672  */
673 Void InterruptDucati_intShmEveMbxStub(UArg arg)
675     InterruptDucati_FxnTable *table;
677     if ((BIOS_smpEnabled) || (Core_getId() == 0) ||
678         (InterruptDucati_enableVpssToEve)) {
679         if ((REG32(EVE_MAILBOX_IRQENABLE_SET_VIDEO) &
680             MAILBOX_REG_VAL(EVE_TO_VIDEO)) &&
681             REG32(EVE_MAILBOX_STATUS(EVE_TO_VIDEO)) != 0) {
682              /* EVE to VIDEO-M3/VPSS-M3 */
683             table = &(InterruptDucati_module->fxnTable[3]);
684             (table->func)(table->arg);
685         }
686     }