Revert "SDOCM00106428 Add notify mailbox driver support on DRA7xx (Part 3)"
[ipc/ipcdev.git] / packages / ti / sdo / ipc / family / vayu / NotifyDriverMbx.c
1 /*
2  * Copyright (c) 2014 Texas Instruments Incorporated - http://www.ti.com
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  */
33 /*
34  *  ======== NotifyDriverMbx.c ========
35  */
37 #include <xdc/std.h>
38 #include <xdc/runtime/Assert.h>
39 #include <xdc/runtime/Startup.h>
41 #include <ti/sysbios/BIOS.h>
42 #include <ti/sysbios/family/c64p/EventCombiner.h>
43 #include <ti/sysbios/family/c64p/Hwi.h>
44 #include <ti/sysbios/family/shared/vayu/IntXbar.h>
46 #include <ti/sdo/ipc/_Ipc.h>
47 #include <ti/sdo/ipc/_Notify.h>
48 #include <ti/sdo/ipc/family/vayu/NotifySetup.h>
49 #include <ti/sdo/ipc/interfaces/INotifyDriver.h>
50 #include <ti/sdo/utils/_MultiProc.h>
52 #include "package/internal/NotifyDriverMbx.xdc.h"
54 /* Bit mask operations */
55 #define SET_BIT(num,pos)            ((num) |= (1u << (pos)))
56 #define CLEAR_BIT(num,pos)          ((num) &= ~(1u << (pos)))
57 #define TEST_BIT(num,pos)           ((num) & (1u << (pos)))
59 /* register access methods */
60 #define REG16(A)        (*(volatile UInt16 *)(A))
61 #define REG32(A)        (*(volatile UInt32 *)(A))
63 #define MAILBOX_FIFOLENGTH 4
64 #define PROCID(idx) (NotifyDriverMbx_procIdTable[idx])
66 #define MBX_BASEADDR_IDX(idx) \
67         ((NotifyDriverMbx_mailboxTable[idx] >> 16) & 0xFFFF)
69 #define MAILBOX_ADDR(idx) \
70         (NotifyDriverMbx_mailboxBaseAddr[MBX_BASEADDR_IDX(idx)])
72 #define MBX_TABLE_IDX(src, dst) \
73         ((PROCID(src) * NotifyDriverMbx_NUM_CORES) + PROCID(dst))
75 #define SUBMBX_IDX(idx) (NotifyDriverMbx_mailboxTable[idx] & 0xFF)
77 #define MBX_USER_IDX(idx) ((NotifyDriverMbx_mailboxTable[idx] >> 8) & 0xFF)
79 #define MAILBOX_REG_VAL(m) (0x1 << (2 * m))
81 #define MAILBOX_MESSAGE(idx) \
82         (MAILBOX_ADDR(idx) + 0x40 + (0x4 * SUBMBX_IDX(idx)))
84 #define MAILBOX_STATUS(idx) \
85         (MAILBOX_ADDR(idx) + 0xC0 + (0x4 * SUBMBX_IDX(idx)))
87 #define MAILBOX_IRQSTATUS_CLR(idx) \
88         (MAILBOX_ADDR(idx) + 0x104 + (0x10 * MBX_USER_IDX(idx)))
90 #define MAILBOX_IRQENABLE_SET(idx) \
91         (MAILBOX_ADDR(idx) + 0x108 + (0x10 * MBX_USER_IDX(idx)))
93 #define MAILBOX_IRQENABLE_CLR(idx) \
94         (MAILBOX_ADDR(idx) + 0x10C + (0x10 * MBX_USER_IDX(idx)))
96 #define MAILBOX_EOI_REG(idx) (MAILBOX_ADDR(idx) + 0x140)
98 #define EVENT_GROUP_SIZE 32
100 /* empty the mailbox for the given index, clear its interrupt */
101 #define MAILBOX_INIT(idx)                                                   \
102     while (REG32(MAILBOX_STATUS(idx)) != 0) {                               \
103         REG32(MAILBOX_MESSAGE(idx));                                        \
104     }                                                                       \
105     REG32(MAILBOX_IRQSTATUS_CLR(idx)) = MAILBOX_REG_VAL(SUBMBX_IDX(idx));
107 /*
108  *************************************************************************
109  *                       Module functions
110  *************************************************************************
111  */
113 /*
114  *  ======== NotifyDriverMbx_Module_startup ========
115  */
116 Int NotifyDriverMbx_Module_startup(Int phase)
118 #if defined(xdc_target__isaCompatible_64)
119     extern cregister volatile UInt DNUM;
121     if (IntXbar_Module_startupDone()) {
122         /* connect mailbox interrupts at startup */
123         if (DNUM == 0) {               /* DSP1 */
124             IntXbar_connect(24, 284);  // eve1 mailbox 0 user 1
125             IntXbar_connect(25, 293);  // eve2 mailbox 0 user 1
126             IntXbar_connect(26, 249);  // system mailbox 5 user 0
128             NotifyDriverMbx_module->interruptTable[6] = 57; // IPU1-0
129             NotifyDriverMbx_module->interruptTable[9] = 57; // IPU1-1
131             /* plug eve3 and eve4 mbxs only if eve3 and eve4 exists */
132             if ((MultiProc_getId("EVE3") != MultiProc_INVALIDID) ||
133                 (MultiProc_getId("EVE4") != MultiProc_INVALIDID)) {
134                 IntXbar_connect(27, 302);  // eve3 mailbox 0 user 1
135                 IntXbar_connect(28, 311);  // eve4 mailbox 0 user 1
136             }
138             /* plug mbx7 only if DSP2 or IPU2 exists */
139             if ((MultiProc_getId("DSP2") != MultiProc_INVALIDID) ||
140                 (MultiProc_getId("IPU2") != MultiProc_INVALIDID) ||
141                 (MultiProc_getId("IPU2-0") != MultiProc_INVALIDID)) {
142                 IntXbar_connect(29, 257);  // system mailbox 7 user 0
143                 NotifyDriverMbx_module->interruptTable[7] = 60; // IPU2-0
144             }
146             /* plug mbx8 only if IPU2-1 exists */
147             if (MultiProc_getId("IPU2-1") != MultiProc_INVALIDID) {
148                 IntXbar_connect(30, 261);  // system mailbox 8 user 0
149                 NotifyDriverMbx_module->interruptTable[10] = 61; // IPU2-1
150             }
151         }
152         else if (DNUM == 1) {          /* DSP2 */
153             IntXbar_connect(24, 287);  // eve1 mailbox 1 user 1
154             IntXbar_connect(25, 296);  // eve2 mailbox 1 user 1
155             IntXbar_connect(26, 253);  // system mailbox 6 user 0
157             NotifyDriverMbx_module->interruptTable[7] = 57; // IPU2-0
158             NotifyDriverMbx_module->interruptTable[10] = 57; // IPU2-1
160             /* plug eve3 and eve4 mbxs only if eve3 and eve4 exists */
161             if ((MultiProc_getId("EVE3") != MultiProc_INVALIDID) ||
162                 (MultiProc_getId("EVE4") != MultiProc_INVALIDID)) {
163                 IntXbar_connect(27, 305);  // eve3 mailbox 1 user 1
164                 IntXbar_connect(28, 314);  // eve4 mailbox 1 user 1
165             }
167             /* plug mbx7 only if DSP1 or IPU1 exists */
168             if ((MultiProc_getId("DSP1") != MultiProc_INVALIDID) ||
169                 (MultiProc_getId("IPU1") != MultiProc_INVALIDID) ||
170                 (MultiProc_getId("IPU1-0") != MultiProc_INVALIDID)) {
171                 IntXbar_connect(29, 258);  // system mailbox 7 user 1
172                 NotifyDriverMbx_module->interruptTable[6] = 60; // IPU1-0
173             }
175             /* plug mbx8 only if IPU1-1 exists */
176             if (MultiProc_getId("IPU1-1") != MultiProc_INVALIDID) {
177                 IntXbar_connect(30, 262);  // system mailbox 8 user 1
178                 NotifyDriverMbx_module->interruptTable[9] = 61; // IPU1-1
179             }
180         }
181         return (Startup_DONE);
182     }
183 #elif defined(xdc_target__isaCompatible_v7M)
185 #else
187 #endif
188     return (Startup_NOTDONE);
191 /*
192  **************************************************************
193  *                       Instance functions
194  **************************************************************
195  */
197 /*
198  *  ======== NotifyDriverMbx_Instance_init ========
199  */
200 Void NotifyDriverMbx_Instance_init(NotifyDriverMbx_Object *obj,
201         const NotifyDriverMbx_Params *params)
203     UInt        key;
204     UInt16      selfVirtId;
205     UInt16      index;
207     /*
208      * Check whether remote proc ID has been set and isn't the same as the
209      * local proc ID
210      */
211     Assert_isTrue((params->remoteProcId != MultiProc_INVALIDID) &&
212             (params->remoteProcId != MultiProc_self()),
213             ti_sdo_ipc_Ipc_A_invParam);
215     if (params->remoteProcId >= MultiProc_getNumProcessors() ||
216         params->remoteProcId == MultiProc_INVALIDID) {
217         return;    /* keep Coverity happy */
218     }
220     obj->evtRegMask = 0;
221     obj->notifyHandle = NULL;
222     obj->remoteProcId = params->remoteProcId;
223     obj->remoteVirtId = PROCID(params->remoteProcId);
224     obj->cpuIntrNum = params->intVectorId;
226     /* disable global interrupts */
227     key = Hwi_disable();
229     /* clear mailbox of any old messages */
230     selfVirtId = PROCID(MultiProc_self());
231     index = (selfVirtId * NotifyDriverMbx_NUM_CORES) + obj->remoteVirtId;
232     MAILBOX_INIT(index)
234     /* must use processor virtual ID to store driver handle in table */
235     NotifyDriverMbx_module->drvHandles[obj->remoteVirtId] = obj;
237     /* plug the cpu interrupt */
238     NotifySetup_plugHwi(params->remoteProcId, params->intVectorId,
239             NotifyDriverMbx_isr);
241     /* enable the mailbox interrupt from the remote core */
242     NotifyDriverMbx_enable(obj);
244     /* Restore global interrupts */
245     Hwi_restore(key);
248 /*
249  *  ======== NotifyDriverMbx_Instance_finalize ========
250  */
251 Void NotifyDriverMbx_Instance_finalize(NotifyDriverMbx_Object *obj)
254     /* disable the mailbox interrupt source */
255     NotifyDriverMbx_disable(obj);
257     /* unplug isr and unprogram the event dispatcher */
258     NotifySetup_unplugHwi(obj->remoteProcId, obj->cpuIntrNum);
260     /* must use processor virtual ID to remove driver handle from table */
261     NotifyDriverMbx_module->drvHandles[obj->remoteVirtId] = NULL;
264 /*
265  *  ======== NotifyDriverMbx_registerEvent ========
266  */
267 Void NotifyDriverMbx_registerEvent(NotifyDriverMbx_Object *obj,
268                                    UInt32 eventId)
270     UInt hwiKey;
272     /*
273      *  Disable interrupt line to ensure that isr doesn't
274      *  preempt registerEvent and encounter corrupt state
275      */
276     hwiKey = Hwi_disable();
278     /* Set the 'registered' bit */
279     SET_BIT(obj->evtRegMask, eventId);
281     /* Restore the interrupt line */
282     Hwi_restore(hwiKey);
285 /*
286  *  ======== NotifyDriverMbx_unregisterEvent ========
287  */
288 Void NotifyDriverMbx_unregisterEvent(NotifyDriverMbx_Object *obj,
289                                      UInt32 eventId)
291     UInt hwiKey;
293     /*
294      *  Disable interrupt line to ensure that isr doesn't
295      *  preempt registerEvent and encounter corrupt state
296      */
297     hwiKey = Hwi_disable();
299     /* Clear the registered bit */
300     CLEAR_BIT(obj->evtRegMask, eventId);
302     /* Restore the interrupt line */
303     Hwi_restore(hwiKey);
306 /*
307  *  ======== NotifyDriverMbx_sendEvent ========
308  */
309 /*
310  *  PUT_NOTIFICATION will spin waiting for enough room in the mailbox FIFO
311  *  to store the number of messages needed for the notification ('numMsgs').
312  *  If spinning is necesssary (i.e. if waitClear is TRUE and there isn't enough
313  *  room in the FIFO) then PUT_NOTIFICATION will allow pre-emption while
314  *  spinning.
315  *
316  *  PUT_NOTIFICATION needs to prevent another local thread from writing to the
317  *  same mailbox after the current thread has
318  *  1) determined that there is enough room to write the notification and
319  *  2) written the first of two messages to the mailbox.
320  *  This is needed to respectively prevent
321  *  1) both threads from incorrectly assuming there is enough space in the FIFO
322  *     for their own notifications
323  *  2) the interrupting thread from writing a notification between two
324  *     two messages that need to be successivly written by the preempted thread.
325  *  Therefore, the check for enough FIFO room and one/both mailbox write(s)
326  *  should all occur atomically (i.e. with interrupts disabled)
327  */
328 #define PUT_NOTIFICATION(idx)                                               \
329         key = Hwi_disable();                                                \
330         while(MAILBOX_FIFOLENGTH - REG32(MAILBOX_STATUS(idx)) < numMsgs) {  \
331             Hwi_restore(key);                                               \
332             if (!waitClear) {                                               \
333                 return (Notify_E_FAIL);                                     \
334             }                                                               \
335             key = Hwi_disable();                                            \
336         };                                                                  \
337         REG32(MAILBOX_MESSAGE(idx)) = eventId + smallPayload;               \
338         if (smallPayload == 0xFFFFFFE0) {                                   \
339             REG32(MAILBOX_MESSAGE(idx)) = payload;                          \
340         }                                                                   \
341         Hwi_restore(key);
343 Int NotifyDriverMbx_sendEvent(NotifyDriverMbx_Object *obj, UInt32 eventId,
344         UInt32 payload, Bool waitClear)
346     UInt16 selfVirtId = PROCID(MultiProc_self());
347     UInt key, numMsgs;
348     UInt32 smallPayload;
349     UInt16 index;
351     /* Decide if the payload is small enough to fit in the first mbx msg */
352     if (payload < 0x7FFFFFF) {
353         smallPayload = (payload << 5);
354         numMsgs = 1;
355     }
356     else {
357         smallPayload = 0xFFFFFFE0;
358         numMsgs = 2;
359     }
361 #if defined(xdc_target__isaCompatible_64)
362     index = (selfVirtId * NotifyDriverMbx_NUM_CORES) + obj->remoteVirtId;
363     PUT_NOTIFICATION(index);
365 #elif defined(xdc_target__isaCompatible_v7M)
367 #if 0
368     if (!(BIOS_smpEnabled) && (Core_getId())) {
369         if (remoteProcId == NotifyDriverMbx_dspProcId) {
370             PUT_NOTIFICATION(VPSS_TO_DSP)
371         }
372         else if (remoteProcId == NotifyDriverMbx_hostProcId) {
373             PUT_NOTIFICATION(VPSS_TO_HOST)
374         }
375         else {
376             PUT_NOTIFICATION(VPSS_TO_VIDEO)
377         }
378     }
379     else {
380         if (remoteProcId == NotifyDriverMbx_dspProcId) {
381             PUT_NOTIFICATION(VIDEO_TO_DSP)
382         }
383         else if (remoteProcId == NotifyDriverMbx_hostProcId) {
384             PUT_NOTIFICATION(VIDEO_TO_HOST)
385         }
386         else {
387             PUT_NOTIFICATION(VIDEO_TO_VPSS)
388         }
389     }
391 #endif
393 #else
395 #if 0
396     if (remoteProcId == NotifyDriverMbx_dspProcId) {
397         PUT_NOTIFICATION(HOST_TO_DSP)
398     }
399     else if (remoteProcId == NotifyDriverMbx_videoProcId) {
400         PUT_NOTIFICATION(HOST_TO_VIDEO)
401     }
402     else {
403         PUT_NOTIFICATION(HOST_TO_VPSS)
404     }
406 #endif
408 #endif
410     return (Notify_S_SUCCESS);
413 /*
414  *  ======== NotifyDriverMbx_disable ========
415  */
416 Void NotifyDriverMbx_disable(NotifyDriverMbx_Object *obj)
418     UInt16 selfVirtId = PROCID(MultiProc_self());
419     UInt16 index;
421 #if defined(xdc_target__isaCompatible_64)
422     index = (obj->remoteVirtId * NotifyDriverMbx_NUM_CORES) + selfVirtId;
423     REG32(MAILBOX_IRQENABLE_CLR(index)) = MAILBOX_REG_VAL(SUBMBX_IDX(index));
425 #elif defined(xdc_target__isaCompatible_v7M)
427 #if 0
428     if (!(BIOS_smpEnabled) && (Core_getId())) {
429         if (remoteProcId == NotifyDriverMbx_hostProcId) {
430             REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
431         }
432         else if (remoteProcId == NotifyDriverMbx_dspProcId) {
433             REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
434         }
435         else {
436             REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(VIDEO_TO_VPSS);
437         }
438     }
439     else {
440         if (remoteProcId == NotifyDriverMbx_hostProcId) {
441             REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
442         }
443         else if (remoteProcId == NotifyDriverMbx_dspProcId) {
444             REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
445         }
446         else {
447             REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(VPSS_TO_VIDEO);
448         }
449     }
450 #endif
452 #else
454 #if 0
455     if (remoteProcId == NotifyDriverMbx_dspProcId) {
456         REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(DSP_TO_HOST);
457     }
458     else if (remoteProcId == NotifyDriverMbx_videoProcId) {
459         REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(VIDEO_TO_HOST);
460     }
461     else {
462         REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(VPSS_TO_HOST);
463     }
464 #endif
466 #endif
469 /*
470  *  ======== NotifyDriverMbx_enable ========
471  */
472 Void NotifyDriverMbx_enable(NotifyDriverMbx_Object *obj)
474     UInt16 selfVirtId = PROCID(MultiProc_self());
475     UInt16 index;
477 #if defined(xdc_target__isaCompatible_64)
478     index = (obj->remoteVirtId * NotifyDriverMbx_NUM_CORES) + selfVirtId;
479     REG32(MAILBOX_IRQENABLE_SET(index)) = MAILBOX_REG_VAL(SUBMBX_IDX(index));
481 #elif defined(xdc_target__isaCompatible_v7M)
483 #if 0
484     if (!(BIOS_smpEnabled) && (Core_getId())) {
485         if (remoteProcId == NotifyDriverMbx_hostProcId) {
486             REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
487         }
488         else if (remoteProcId == NotifyDriverMbx_dspProcId) {
489             REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
490         }
491         else {
492             REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(VIDEO_TO_VPSS);
493         }
494     }
495     else {
496         if (remoteProcId == NotifyDriverMbx_hostProcId) {
497             REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
498         }
499         else if (remoteProcId == NotifyDriverMbx_dspProcId) {
500             REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
501         }
502         else {
503             REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(VPSS_TO_VIDEO);
504         }
505     }
506 #endif
508 #else
510 #if 0
511     if (remoteProcId == NotifyDriverMbx_dspProcId) {
512         REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(DSP_TO_HOST);
513     }
514     else if (remoteProcId == NotifyDriverMbx_videoProcId) {
515         REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(VIDEO_TO_HOST);
516     }
517     else {
518         REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(VPSS_TO_HOST);
519     }
520 #endif
522 #endif
525 /*
526  *  ======== NotifyDriverMbx_disableEvent ========
527  */
528 Void NotifyDriverMbx_disableEvent(NotifyDriverMbx_Object *obj, UInt32 eventId)
530     /* NotifyDriverMbx_disableEvent not supported by this driver */
531     Assert_isTrue(FALSE, NotifyDriverMbx_A_notSupported);
534 /*
535  *  ======== NotifyDriverMbx_enableEvent ========
536  */
537 Void NotifyDriverMbx_enableEvent(NotifyDriverMbx_Object *obj, UInt32 eventId)
539     /* NotifyDriverMbx_enableEvent not supported by this driver */
540     Assert_isTrue(FALSE, NotifyDriverMbx_A_notSupported);
543 /*
544  *************************************************************************
545  *                       Internal functions
546  *************************************************************************
547  */
549 /*
550  *  ======== NotifyDriverMbx_isr ========
551  */
553 /*  Read a message from the mailbox. The low 5 bits of the message
554  *  contains the eventId. The high 27 bits of the message contains
555  *  either:
556  *      1) The payload if the payload is less than 0x7FFFFFF
557  *      2) 0x7FFFFFF otherwise
558  *  If the high 27 bits of the first message is 0x7FFFFFF, then the
559  *  payload is in the next mailbox message.
560  *
561  *  idx = mailbox table index
562  */
563 #define MESSAGE_DELIVERY(idx)                                               \
564     msg = REG32(MAILBOX_MESSAGE(idx));                                      \
565     eventId = (UInt16)(msg & 0x1F);                                         \
566     payload = msg >> 5;                                                     \
567     if (payload == 0x7FFFFFF) {                                             \
568         while(REG32(MAILBOX_STATUS(idx)) == 0);                             \
569         payload = REG32(MAILBOX_MESSAGE(idx));                              \
570     }                                                                       \
571     REG32(MAILBOX_IRQSTATUS_CLR(idx)) = MAILBOX_REG_VAL(SUBMBX_IDX(idx));   \
572     obj = NotifyDriverMbx_module->drvHandles[srcVirtId];                    \
573     Assert_isTrue(obj != NULL, ti_sdo_ipc_Notify_A_internal);               \
574     if (TEST_BIT(obj->evtRegMask, eventId)) {                               \
575         ti_sdo_ipc_Notify_exec(obj->notifyHandle, eventId, payload);        \
576     }                                                                       \
577     REG32(MAILBOX_EOI_REG(idx)) = 0x1;
579 Void NotifyDriverMbx_isr(UInt16 idx)
581     NotifyDriverMbx_Object *obj;
582     UInt32 msg, payload;
583     UInt16 eventId;
585 #if defined(xdc_target__isaCompatible_64)
586     UInt16 srcVirtId;
588     srcVirtId = idx / NotifyDriverMbx_NUM_CORES;
589     MESSAGE_DELIVERY(idx)
591 #elif defined(xdc_target__isaCompatible_v7M)
593 #if 0
594     do {
595         numProcessed = 0;
596         if (!(BIOS_smpEnabled) && (Core_getId())) {
597             GET_NOTIFICATION(VPSS, HOST)
598             GET_NOTIFICATION(VPSS, DSP)
599             GET_NOTIFICATION(VPSS, VIDEO)
600         }
601         else {
602             GET_NOTIFICATION(VIDEO, HOST)
603             GET_NOTIFICATION(VIDEO, DSP)
604             GET_NOTIFICATION(VIDEO, VPSS)
605         }
606     }
607     while (numProcessed != 0);
608 #endif
610 #else
612 #if 0
613     do {
614         numProcessed = 0;
615         GET_NOTIFICATION(HOST, DSP)
616         GET_NOTIFICATION(HOST, VPSS)
617         GET_NOTIFICATION(HOST, VIDEO)
618     }
619     while (numProcessed != 0);
620 #endif
622 #endif
625 /*
626  *  ======== NotifyDriverMbx_setNotifyHandle ========
627  */
628 Void NotifyDriverMbx_setNotifyHandle(NotifyDriverMbx_Object *obj,
629         Ptr notifyHandle)
631     /* internally used, so no assert needed */
632     obj->notifyHandle = (ti_sdo_ipc_Notify_Handle)notifyHandle;