8ba3cd378a01efac8b73476b3ec816b92edd266e
[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 {
153             Hwi_enableInterrupt(M3INTERCOREINT);
154         }
155     }
158 /*
159  *  ======== InterruptDucati_intDisable ========
160  *  Disables remote processor interrupt
161  */
162 Void InterruptDucati_intDisable(UInt16 remoteProcId,
163                                 IInterrupt_IntInfo *intInfo)
165     /*
166      *  If the remote processor communicates via mailboxes, we should disable
167      *  the Mailbox IRQ instead of disabling the Hwi because multiple mailboxes
168      *  share the same Hwi
169      */
170     if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
171         if (remoteProcId == InterruptDucati_hostProcId) {
172             REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
173         }
174         else if (remoteProcId == InterruptDucati_dspProcId) {
175             REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
176         }
177         else if (remoteProcId == InterruptDucati_eveProcId) {
178             REG32(EVE_MAILBOX_IRQENABLE_CLR_VIDEO) =
179                 MAILBOX_REG_VAL(EVE_TO_VIDEO);
180         }
181         else {
182             Hwi_disableInterrupt(M3INTERCOREINT);
183         }
184     }
185     else {
186         if (remoteProcId == InterruptDucati_hostProcId) {
187             REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
188         }
189         else if (remoteProcId == InterruptDucati_dspProcId) {
190             REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
191         }
192         else {
193             Hwi_disableInterrupt(M3INTERCOREINT);
194         }
195     }
198 /*
199  *  ======== InterruptDucati_intRegister ========
200  */
201 Void InterruptDucati_intRegister(UInt16 remoteProcId,
202                                  IInterrupt_IntInfo *intInfo,
203                                  Fxn func, UArg arg)
205     Hwi_Params  hwiAttrs;
206     UInt        key;
207     Int         index;
208     Error_Block eb;
209     InterruptDucati_FxnTable *table;
211     Assert_isTrue(remoteProcId < ti_sdo_utils_MultiProc_numProcessors,
212             ti_sdo_ipc_Ipc_A_internal);
214     /* Assert that our MultiProc id is set correctly */
215     Assert_isTrue((InterruptDucati_videoProcId == MultiProc_self()) ||
216                   (InterruptDucati_vpssProcId == MultiProc_self()),
217                   ti_sdo_ipc_Ipc_A_internal);
219     /* init error block */
220     Error_init(&eb);
222     /*
223      *  VPSS-M3 & VIDEO-M3 each have a unique interrupt ID for receiving
224      *  interrupts external to the Ducati subsystem.
225      *  (M3DSSINT & MAILBOX_M3VIDEOINT).
226      *  However, they have a separate interrupt ID for receving interrupt from
227      *  each other(M3INTERCOREINT).
228      *
229      *  Store the interrupt id in the intInfo so it can be used during
230      *  intUnregiseter.
231      */
232     if (remoteProcId == InterruptDucati_dspProcId) {
233         index = 0;
234         if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
235             intInfo->localIntId = MAILBOX_M3VIDEOINT;
236         }
237         else {
238             intInfo->localIntId = MAILBOX_M3DSSINT ;
239         }
240     }
241     else if (remoteProcId == InterruptDucati_hostProcId) {
242         index = 1;
243         if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
244             intInfo->localIntId = MAILBOX_M3VIDEOINT;
245         }
246         else {
247             intInfo->localIntId = MAILBOX_M3DSSINT ;
248         }
249     }
250     else if (remoteProcId == InterruptDucati_eveProcId) {
251         index = 3;
252         if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
253             intInfo->localIntId = EVE_MAILBOX_M3VIDEOINT;
254         }
255         else {
256             /* Core1 communication to EVE is not supported */
257             Assert_isTrue(FALSE, ti_sdo_ipc_Ipc_A_internal);
258         }
259     }
260     else {
261         /* Going to the other M3 */
262         index = 2;
263         intInfo->localIntId = M3INTERCOREINT;
264     }
266     /* Disable global interrupts */
267     key = Hwi_disable();
269     table = &(InterruptDucati_module->fxnTable[index]);
270     table->func = func;
271     table->arg  = arg;
273     InterruptDucati_intClear(remoteProcId, intInfo);
275     Hwi_Params_init(&hwiAttrs);
276     hwiAttrs.maskSetting = Hwi_MaskingOption_LOWER;
278     /* Make sure the interrupt only gets plugged once */
279     if (index == 0 || index == 1) {
280         InterruptDucati_module->numPlugged++;
281         if (InterruptDucati_module->numPlugged == 1) {
282             Hwi_create(intInfo->localIntId,
283                       (Hwi_FuncPtr)InterruptDucati_intShmMbxStub,
284                       &hwiAttrs,
285                       &eb);
287             /* Interrupt_intEnable won't enable the Hwi */
288             Hwi_enableInterrupt(intInfo->localIntId);
289         }
290     }
291     else if (index == 2) {
292         Hwi_create(intInfo->localIntId,
293                   (Hwi_FuncPtr)InterruptDucati_intShmDucatiStub,
294                   &hwiAttrs,
295                   &eb);
296     }
297     else {
298         if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
299             Hwi_create(intInfo->localIntId,
300                       (Hwi_FuncPtr)InterruptDucati_intShmEveMbxStub,
301                       &hwiAttrs,
302                       &eb);
304             /* Interrupt_intEnable won't enable the Hwi */
305             Hwi_enableInterrupt(intInfo->localIntId);
306         }
307     }
309     InterruptDucati_intEnable(remoteProcId, intInfo);
311     /* Restore global interrupts */
312     Hwi_restore(key);
315 /*
316  *  ======== InterruptDucati_intUnregister ========
317  */
318 Void InterruptDucati_intUnregister(UInt16 remoteProcId,
319                                    IInterrupt_IntInfo *intInfo)
321     Int         index;
322     InterruptDucati_FxnTable *table;
323     Hwi_Handle  hwiHandle;
325     if (remoteProcId == InterruptDucati_dspProcId) {
326         index = 0;
327     }
328     else if (remoteProcId == InterruptDucati_hostProcId) {
329         index = 1;
330     }
331     else if (remoteProcId == InterruptDucati_eveProcId) {
332         index = 3;
333         if (!(BIOS_smpEnabled) && (Core_getId() == 1)) {
334             /* Core1 communication to EVE is not supported */
335             return;
336         }
337     }
338     else {
339         /* Going to the other M3 */
340         index = 2;
341     }
343     /* Disable the mailbox interrupt source */
344     InterruptDucati_intDisable(remoteProcId, intInfo);
346     /* Disable the interrupt itself */
347     if (index == 0 || index == 1) {
348         /* case for DSP or HOST */
349         InterruptDucati_module->numPlugged--;
350         if (InterruptDucati_module->numPlugged == 0) {
351             hwiHandle = Hwi_getHandle(intInfo->localIntId);
352             Hwi_delete(&hwiHandle);
353         }
354     }
355     else if (index == 2) {
356         /* case for other M3 */
357         hwiHandle = Hwi_getHandle(M3INTERCOREINT);
358         Hwi_delete(&hwiHandle);
359     }
360     else {
361         /* case for EVE */
362         hwiHandle = Hwi_getHandle(intInfo->localIntId);
363         Hwi_delete(&hwiHandle);
364     }
366     /* Clear the FxnTable entry for the remote processor */
367     table = &(InterruptDucati_module->fxnTable[index]);
368     table->func = NULL;
369     table->arg  = 0;
373 /*
374  *  ======== InterruptDucati_intSend ========
375  *  Send interrupt to the remote processor
376  */
377 Void InterruptDucati_intSend(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo,
378                              UArg arg)
380     UInt key;
382     if (remoteProcId == InterruptDucati_videoProcId ||
383         remoteProcId == InterruptDucati_vpssProcId) {
384         if (!(BIOS_smpEnabled) && (Core_getId() == 1)) {
385             /* VPSS-M3 to VIDEO-M3 */
386             REG16(INTERRUPT_VIDEO) |= 0x1;
387         }
388         else {
389             /* VIDEO-M3 to VPSS-M3 */
390             REG16(INTERRUPT_VPSS) |= 0x1;
391         }
392     }
393     else if (remoteProcId == InterruptDucati_dspProcId) {
394         if (!(BIOS_smpEnabled) && (Core_getId() == 1)) {
395             /* VPSS-M3 to DSP */
396             key = Hwi_disable();
397             if (REG32(MAILBOX_STATUS(VPSS_TO_DSP)) == 0) {
398                 REG32(MAILBOX_MESSAGE(VPSS_TO_DSP)) = arg;
399             }
400             Hwi_restore(key);
401         }
402         else {
403             /* VIDEO-M3 to DSP */
404             key = Hwi_disable();
405             if (REG32(MAILBOX_STATUS(VIDEO_TO_DSP)) == 0) {
406                 REG32(MAILBOX_MESSAGE(VIDEO_TO_DSP)) = arg;
407             }
408             Hwi_restore(key);
409         }
410     }
411     else if (remoteProcId == InterruptDucati_hostProcId) {
412         if (!(BIOS_smpEnabled) && (Core_getId() == 1)) {
413             /* VPSS-M3 to HOST */
414             key = Hwi_disable();
415             if (REG32(MAILBOX_STATUS(VPSS_TO_HOST)) == 0) {
416                 REG32(MAILBOX_MESSAGE(VPSS_TO_HOST)) = arg;
417             }
418             Hwi_restore(key);
419         }
420         else {
421             /* VIDEO-M3 to HOST */
422             key = Hwi_disable();
423             if (REG32(MAILBOX_STATUS(VIDEO_TO_HOST)) == 0) {
424                 REG32(MAILBOX_MESSAGE(VIDEO_TO_HOST)) = arg;
425             }
426             Hwi_restore(key);
427         }
428     }
429     else {
430         if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
431             /* VIDEO-M3 to EVE */
432             key = Hwi_disable();
433             if (REG32(EVE_MAILBOX_STATUS(VIDEO_TO_EVE)) == 0) {
434                 REG32(EVE_MAILBOX_MESSAGE(VIDEO_TO_EVE)) = arg;
435             }
436             Hwi_restore(key);
437         }
438     }
442 /*
443  *  ======== InterruptDucati_intPost ========
444  *  Simulate an interrupt from a remote processor
445  */
446 Void InterruptDucati_intPost(UInt16 srcProcId, IInterrupt_IntInfo *intInfo,
447                              UArg arg)
449     UInt key;
451     if (srcProcId == InterruptDucati_videoProcId ||
452         srcProcId == InterruptDucati_vpssProcId) {
453         if (!(BIOS_smpEnabled) && (Core_getId() == 1)) {
454             /* VIDEO-M3 to VPSS-M3 */
455             REG16(INTERRUPT_VPSS) |= 0x1;
456         }
457         else {
458             /* VPSS-M3 to VIDEO-M3 */
459             REG16(INTERRUPT_VIDEO) |= 0x1;
460         }
461     }
462     else if (srcProcId == InterruptDucati_dspProcId) {
463         if (!(BIOS_smpEnabled) && (Core_getId() == 1)) {
464             /* DSP to VPSS-M3 */
465             key = Hwi_disable();
466             if (REG32(MAILBOX_STATUS(DSP_TO_VPSS)) == 0) {
467                 REG32(MAILBOX_MESSAGE(DSP_TO_VPSS)) = arg;
468             }
469             Hwi_restore(key);
470         }
471         else {
472             /* DSP to VIDEO-M3 */
473             key = Hwi_disable();
474             if (REG32(MAILBOX_STATUS(DSP_TO_VIDEO)) == 0) {
475                 REG32(MAILBOX_MESSAGE(DSP_TO_VIDEO)) = arg;
476             }
477             Hwi_restore(key);
478         }
479     }
480     else if (srcProcId == InterruptDucati_hostProcId) {
481         if (!(BIOS_smpEnabled) && (Core_getId() == 1)) {
482             /* HOST to VPSS-M3 */
483             key = Hwi_disable();
484             if (REG32(MAILBOX_STATUS(HOST_TO_VPSS)) == 0) {
485                 REG32(MAILBOX_MESSAGE(HOST_TO_VPSS)) = arg;
486             }
487             Hwi_restore(key);
488         }
489         else {
490             /* HOST to VIDEO-M3 */
491             key = Hwi_disable();
492             if (REG32(MAILBOX_STATUS(HOST_TO_VIDEO)) == 0) {
493                 REG32(MAILBOX_MESSAGE(HOST_TO_VIDEO)) = arg;
494             }
495             Hwi_restore(key);
496         }
497     }
498     else {
499         if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
500             /* EVE to VIDEO-M3 */
501             key = Hwi_disable();
502             if (REG32(EVE_MAILBOX_STATUS(EVE_TO_VIDEO)) == 0) {
503                 REG32(EVE_MAILBOX_MESSAGE(EVE_TO_VIDEO)) = arg;
504             }
505             Hwi_restore(key);
506         }
507     }
511 /*
512  *  ======== InterruptDucati_intClear ========
513  *  Clear interrupt
514  */
515 UInt InterruptDucati_intClear(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo)
517     UInt arg;
519     if (remoteProcId == InterruptDucati_videoProcId ||
520         remoteProcId == InterruptDucati_vpssProcId) {
521         arg = REG32(InterruptDucati_ducatiCtrlBaseAddr);
523         /* Look at BIOS's ducati Core id */
524         if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
525             if ((REG16(INTERRUPT_VIDEO) & 0x1) == 0x1) {
526                 /* VPSS-M3 to VIDEO-M3 */
527                 REG16(INTERRUPT_VIDEO) &= ~(0x1);
528             }
529         }
530         else {
531             if ((REG16(INTERRUPT_VPSS) & 0x1) == 0x1) {
532                 /* VIDEO-M3 to VPSS-M3 */
533                 REG16(INTERRUPT_VPSS) &= ~(0x1);
534             }
535         }
536     }
537     else if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
538         if (remoteProcId == InterruptDucati_hostProcId) {
539             /* HOST to VIDEO-M3 */
540             arg = REG32(MAILBOX_MESSAGE(HOST_TO_VIDEO));
541             REG32(MAILBOX_IRQSTATUS_CLR_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
542         }
543         else if (remoteProcId == InterruptDucati_dspProcId) {
544             /* DSP to VIDEO-M3 */
545             arg = REG32(MAILBOX_MESSAGE(DSP_TO_VIDEO));
546             REG32(MAILBOX_IRQSTATUS_CLR_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
547         }
548         else {
549             /* EVE to VIDEO-M3 */
550             arg = REG32(EVE_MAILBOX_MESSAGE(EVE_TO_VIDEO));
551             REG32(EVE_MAILBOX_IRQSTATUS_CLR_VIDEO) = MAILBOX_REG_VAL(EVE_TO_VIDEO);
552         }
553     }
554     else { /* M3DSSINT */
555         if (remoteProcId == InterruptDucati_hostProcId) {
556             /* HOST to VPSS-M3 */
557             arg = REG32(MAILBOX_MESSAGE(HOST_TO_VPSS));
558             REG32(MAILBOX_IRQSTATUS_CLR_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
559         }
560         else if (remoteProcId == InterruptDucati_dspProcId) {
561             /* DSP to VPSS-M3 */
562             arg = REG32(MAILBOX_MESSAGE(DSP_TO_VPSS));
563             REG32(MAILBOX_IRQSTATUS_CLR_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
564         }
565         else {
566             /* EVE cannot send an interrupt to VPSS-M3! */
567             Assert_isTrue(FALSE, ti_sdo_ipc_Ipc_A_internal);
568             arg = 0;    /* keep Coverity happy */
569         }
570     }
572     return (arg);
575 /*
576  *************************************************************************
577  *                      Internals functions
578  *************************************************************************
579  */
581 /*
582  *  ======== InterruptDucati_intShmDucatiStub ========
583  */
584 Void InterruptDucati_intShmDucatiStub(UArg arg)
586     InterruptDucati_FxnTable *table;
588     table = &(InterruptDucati_module->fxnTable[2]);
589     (table->func)(table->arg);
592 /*
593  *  ======== InterruptDucati_intShmMbxStub ========
594  */
595 Void InterruptDucati_intShmMbxStub(UArg arg)
597     InterruptDucati_FxnTable *table;
599     if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
600         if ((REG32(MAILBOX_IRQENABLE_SET_VIDEO) &
601                 MAILBOX_REG_VAL(DSP_TO_VIDEO)) &&
602             REG32(MAILBOX_STATUS(DSP_TO_VIDEO)) != 0) { /* DSP to VIDEO-M3 */
603             table = &(InterruptDucati_module->fxnTable[0]);
604             (table->func)(table->arg);
605         }
606         if ((REG32(MAILBOX_IRQENABLE_SET_VIDEO) &
607                 MAILBOX_REG_VAL(HOST_TO_VIDEO)) &&
608             REG32(MAILBOX_STATUS(HOST_TO_VIDEO)) != 0) { /* HOST to VIDEO-M3 */
609             table = &(InterruptDucati_module->fxnTable[1]);
610             (table->func)(table->arg);
611         }
612     }
613     else {
614         if ((REG32(MAILBOX_IRQENABLE_SET_VPSS) &
615                 MAILBOX_REG_VAL(DSP_TO_VPSS)) &&
616              REG32(MAILBOX_STATUS(DSP_TO_VPSS)) != 0) { /* DSP to VPSS-M3 */
617             table = &(InterruptDucati_module->fxnTable[0]);
618             (table->func)(table->arg);
619         }
620         if ((REG32(MAILBOX_IRQENABLE_SET_VPSS) &
621                 MAILBOX_REG_VAL(HOST_TO_VPSS)) &&
622             REG32(MAILBOX_STATUS(HOST_TO_VPSS)) != 0) { /* HOST to VPSS-M3 */
623             table = &(InterruptDucati_module->fxnTable[1]);
624             (table->func)(table->arg);
625         }
626     }
629 /*
630  *  ======== InterruptDucati_intShmEveMbxStub ========
631  */
632 Void InterruptDucati_intShmEveMbxStub(UArg arg)
634     InterruptDucati_FxnTable *table;
636     if ((BIOS_smpEnabled) || (Core_getId() == 0)) {
637         if ((REG32(EVE_MAILBOX_IRQENABLE_SET_VIDEO) &
638             MAILBOX_REG_VAL(EVE_TO_VIDEO)) &&
639             REG32(EVE_MAILBOX_STATUS(EVE_TO_VIDEO)) != 0) { /* EVE to VIDEO-M3 */
640             table = &(InterruptDucati_module->fxnTable[3]);
641             (table->func)(table->arg);
642         }
643     }