packages/ti/sdo/ipc/family/c6a8149/NotifyDriverMbx.c

   1 /*
   2  * Copyright (c) 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 /*
  34  *  ======== NotifyDriverMbx.c ========
  35  */
  36
  37 #include <xdc/std.h>
  38 #include <xdc/runtime/Assert.h>
  39 #include <xdc/runtime/Startup.h>
  40
  41 #include <ti/sysbios/BIOS.h>
  42 #include <ti/sysbios/hal/Hwi.h>
  43 #ifdef xdc_target__isaCompatible_v7M
  44 #include <ti/sysbios/family/arm/ducati/Core.h>
  45 #endif
  46
  47 #include <ti/sdo/ipc/interfaces/INotifyDriver.h>
  48 #include <ti/sdo/ipc/_Notify.h>
  49 #include <ti/sdo/utils/_MultiProc.h>
  50
  51 #include "package/internal/NotifyDriverMbx.xdc.h"
  52
  53 /* Bit mask operations */
  54 #define SET_BIT(num,pos)            ((num) |= (1u << (pos)))
  55 #define CLEAR_BIT(num,pos)          ((num) &= ~(1u << (pos)))
  56 #define TEST_BIT(num,pos)           ((num) & (1u << (pos)))
  57
  58 /* Assigned mailboxes */
  59 #define DSP_TO_HOST         0
  60 #define DSP_TO_VIDEO        1
  61 #define DSP_TO_VPSS         2
  62 #define HOST_TO_DSP         3
  63 #define HOST_TO_VIDEO       4
  64 #define HOST_TO_VPSS        5
  65 #define VIDEO_TO_HOST       6
  66 #define VIDEO_TO_DSP        7
  67 #define VPSS_TO_HOST        8
  68 #define VPSS_TO_DSP         9
  69 #define VIDEO_TO_VPSS       10
  70 #define VPSS_TO_VIDEO       11
  71
  72 #define MAILBOX_REG_VAL(M)            (0x1 << (2 * M))
  73
  74 /* Register access method. */
  75 #define REG16(A)                      (*(volatile UInt16 *) (A))
  76 #define REG32(A)                      (*(volatile UInt32 *) (A))
  77
  78 #define MAILBOX_FIFOLENGTH      4
  79
  80 #define MAILBOX_MESSAGE(M) \
  81         (NotifyDriverMbx_mailboxBaseAddr + 0x40 + (0x4 * M))
  82 #define MAILBOX_FIFOSTATUS(M) \
  83         (NotifyDriverMbx_mailboxBaseAddr + 0x80 + (0x4 * M))
  84 #define MAILBOX_STATUS(M) \
  85         (NotifyDriverMbx_mailboxBaseAddr + 0xC0 + (0x4 * M))
  86
  87 /* HOST registers */
  88 #define MAILBOX_IRQSTATUS_CLR_HOST    (NotifyDriverMbx_mailboxBaseAddr + 0x104)
  89 #define MAILBOX_IRQENABLE_SET_HOST    (NotifyDriverMbx_mailboxBaseAddr + 0x108)
  90 #define MAILBOX_IRQENABLE_CLR_HOST    (NotifyDriverMbx_mailboxBaseAddr + 0x10C)
  91
  92 /* DSP registers */
  93 #define MAILBOX_IRQSTATUS_CLR_DSP     (NotifyDriverMbx_mailboxBaseAddr + 0x114)
  94 #define MAILBOX_IRQENABLE_SET_DSP     (NotifyDriverMbx_mailboxBaseAddr + 0x118)
  95 #define MAILBOX_IRQENABLE_CLR_DSP     (NotifyDriverMbx_mailboxBaseAddr + 0x11C)
  96
  97 /* VIDEO registers */
  98 #define MAILBOX_IRQSTATUS_CLR_VIDEO   (NotifyDriverMbx_mailboxBaseAddr + 0x124)
  99 #define MAILBOX_IRQENABLE_SET_VIDEO   (NotifyDriverMbx_mailboxBaseAddr + 0x128)
 100 #define MAILBOX_IRQENABLE_CLR_VIDEO   (NotifyDriverMbx_mailboxBaseAddr + 0x12C)
 101
 102 /* VPSS registers */
 103 #define MAILBOX_IRQSTATUS_CLR_VPSS    (NotifyDriverMbx_mailboxBaseAddr + 0x134)
 104 #define MAILBOX_IRQENABLE_SET_VPSS    (NotifyDriverMbx_mailboxBaseAddr + 0x138)
 105 #define MAILBOX_IRQENABLE_CLR_VPSS    (NotifyDriverMbx_mailboxBaseAddr + 0x13C)
 106
 107 #define MAILBOX_EOI_REG               (NotifyDriverMbx_mailboxBaseAddr + 0x140)
 108
 109 #define MBX(src, dst)                 (src##_TO_##dst)
 110
 111 #define PROCID_HOST                   NotifyDriverMbx_hostProcId
 112 #define PROCID_VPSS                   NotifyDriverMbx_vpssProcId
 113 #define PROCID_VIDEO                  NotifyDriverMbx_videoProcId
 114 #define PROCID_DSP                    NotifyDriverMbx_dspProcId
 115
 116 /*
 117  *************************************************************************
 118  *                       Module functions
 119  *************************************************************************
 120  */
 121
 122 /*
 123  *  ======== NotifyDriverMbx_Module_startup ========
 124  */
 125
 126 /* The INIT macro empties the mailbox that corresponds to 'src'-to-'dst' */
 127 #define INIT(src, dst)                                                  \
 128     while (REG32(MAILBOX_STATUS(MBX(src, dst)))) {                      \
 129         REG32(MAILBOX_MESSAGE(MBX(src, dst)));                          \
 130     }                                                                   \
 131     REG32(MAILBOX_IRQSTATUS_CLR_##dst)                                  \
 132             = MAILBOX_REG_VAL(MBX(src, dst));
 133
 134 Int NotifyDriverMbx_Module_startup(Int phase)
 135 {
 136 #if defined(xdc_target__isaCompatible_64)
 137
 138     INIT(HOST, DSP)
 139     INIT(VIDEO, DSP)
 140     INIT(VPSS, DSP)
 141     REG32(MAILBOX_EOI_REG) = 0x1;
 142
 143 #elif defined(xdc_target__isaCompatible_v7M)
 144     if (!(BIOS_smpEnabled) && (Core_getId())) {
 145         INIT(DSP, VPSS)
 146         INIT(HOST, VPSS)
 147         INIT(VIDEO, VPSS)
 148     }
 149     else {
 150         INIT(DSP, VIDEO)
 151         INIT(HOST, VIDEO)
 152         INIT(VPSS, VIDEO)
 153     }
 154
 155 #else
 156     INIT(DSP, HOST)
 157     INIT(VIDEO, HOST)
 158     INIT(VPSS, HOST)
 159
 160 #endif
 161
 162     return (Startup_DONE);
 163 }
 164
 165
 166 /*
 167  **************************************************************
 168  *                       Instance functions
 169  **************************************************************
 170  */
 171
 172 /*
 173  *  ======== NotifyDriverMbx_Instance_init ========
 174  */
 175 Void NotifyDriverMbx_Instance_init(NotifyDriverMbx_Object *obj,
 176         const NotifyDriverMbx_Params *params)
 177 {
 178     UInt        key;
 179
 180
 181     /*
 182      * Check whether remote proc ID has been set and isn't the same as the
 183      * local proc ID
 184      */
 185     Assert_isTrue ((params->remoteProcId < MultiProc_getNumProcessors()) &&
 186                    (params->remoteProcId != MultiProc_INVALIDID) &&
 187                    (params->remoteProcId != MultiProc_self()),
 188                    ti_sdo_ipc_Notify_A_internal);
 189
 190     if (params->remoteProcId >= MultiProc_getNumProcessors() ||
 191         params->remoteProcId == MultiProc_INVALIDID) {
 192         return;    /* keep Coverity happy */
 193     }
 194
 195     obj->remoteProcId = params->remoteProcId;
 196     obj->evtRegMask = 0;
 197     obj->notifyHandle = NULL;
 198
 199     /* Disable global interrupts */
 200     key = Hwi_disable();
 201
 202     /* Store the driver handle so it can be retreived in the isr */
 203     NotifyDriverMbx_module->drvHandles[obj->remoteProcId] = obj;
 204
 205     /* Enable the mailbox interrupt from the remote core */
 206     NotifyDriverMbx_enable(obj);
 207
 208     /* Restore global interrupts */
 209     Hwi_restore(key);
 210 }
 211
 212 /*
 213  *  ======== NotifyDriverMbx_Instance_finalize ========
 214  */
 215 Void NotifyDriverMbx_Instance_finalize(NotifyDriverMbx_Object *obj)
 216 {
 217     /* Disable the mailbox interrupt source */
 218     NotifyDriverMbx_disable(obj);
 219
 220     NotifyDriverMbx_module->drvHandles[obj->remoteProcId] = NULL;
 221 }
 222
 223 /*
 224  *  ======== NotifyDriverMbx_registerEvent ========
 225  */
 226 Void NotifyDriverMbx_registerEvent(NotifyDriverMbx_Object *obj,
 227                                    UInt32 eventId)
 228 {
 229     UInt hwiKey;
 230
 231     /*
 232      *  Disable interrupt line to ensure that isr doesn't
 233      *  preempt registerEvent and encounter corrupt state
 234      */
 235     hwiKey = Hwi_disable();
 236
 237     /* Set the 'registered' bit */
 238     SET_BIT(obj->evtRegMask, eventId);
 239
 240     /* Restore the interrupt line */
 241     Hwi_restore(hwiKey);
 242 }
 243
 244 /*
 245  *  ======== NotifyDriverMbx_unregisterEvent ========
 246  */
 247 Void NotifyDriverMbx_unregisterEvent(NotifyDriverMbx_Object *obj,
 248                                      UInt32 eventId)
 249 {
 250     UInt hwiKey;
 251
 252     /*
 253      *  Disable interrupt line to ensure that isr doesn't
 254      *  preempt registerEvent and encounter corrupt state
 255      */
 256     hwiKey = Hwi_disable();
 257
 258     /* Clear the registered bit */
 259     CLEAR_BIT(obj->evtRegMask, eventId);
 260
 261     /* Restore the interrupt line */
 262     Hwi_restore(hwiKey);
 263 }
 264
 265 /*
 266  *  ======== NotifyDriverMbx_sendEvent ========
 267  */
 268 /*
 269  *  PUT_NOTIFICATION will spin waiting for enough room in the mailbox FIFO
 270  *  to store the number of messages needed for the notification ('numMsgs').
 271  *  If spinning is necesssary (i.e. if waitClear is TRUE and there isn't enough
 272  *  room in the FIFO) then PUT_NOTIFICATION will allow pre-emption while
 273  *  spinning.
 274  *
 275  *  PUT_NOTIFICATION needs to prevent another local thread from writing to the
 276  *  same mailbox after the current thread has
 277  *  1) determined that there is enough room to write the notification and
 278  *  2) written the first of two messages to the mailbox.
 279  *  This is needed to respectively prevent
 280  *  1) both threads from incorrectly assuming there is enough space in the FIFO
 281  *     for their own notifications
 282  *  2) the interrupting thread from writing a notification between two
 283  *     two messages that need to be successivly written by the preempted thread.
 284  *  Therefore, the check for enough FIFO room and one/both mailbox write(s)
 285  *  should all occur atomically (i.e. with interrupts disabled)
 286  */
 287 #define PUT_NOTIFICATION(m)                                                 \
 288         key = Hwi_disable();                                                \
 289         while(MAILBOX_FIFOLENGTH - REG32(MAILBOX_STATUS(m)) < numMsgs) {    \
 290             Hwi_restore(key);                                               \
 291             if (!waitClear) {                                               \
 292                 return (Notify_E_FAIL);                                     \
 293             }                                                               \
 294             key = Hwi_disable();                                            \
 295         };                                                                  \
 296         REG32(MAILBOX_MESSAGE(m)) = eventId + smallPayload;                 \
 297         if (smallPayload == 0xFFFFFFE0) {                                   \
 298             REG32(MAILBOX_MESSAGE(m)) = payload;                            \
 299         }                                                                   \
 300         Hwi_restore(key);
 301
 302 Int NotifyDriverMbx_sendEvent(NotifyDriverMbx_Object *obj,
 303                               UInt32                 eventId,
 304                               UInt32                 payload,
 305                               Bool                   waitClear)
 306 {
 307     UInt16 remoteProcId = obj->remoteProcId;
 308     UInt key, numMsgs;
 309     UInt32 smallPayload;
 310
 311     /* Decide if the payload is small enough to fit in the first mbx msg */
 312     if (payload < 0x7FFFFFF) {
 313         smallPayload = (payload << 5);
 314         numMsgs = 1;
 315     }
 316     else {
 317         smallPayload = 0xFFFFFFE0;
 318         numMsgs = 2;
 319     }
 320
 321 #if defined(xdc_target__isaCompatible_64)
 322     if (remoteProcId == NotifyDriverMbx_hostProcId) {
 323         PUT_NOTIFICATION(DSP_TO_HOST)
 324     }
 325     else if (remoteProcId == NotifyDriverMbx_videoProcId) {
 326         PUT_NOTIFICATION(DSP_TO_VIDEO)
 327     }
 328     else {
 329         PUT_NOTIFICATION(DSP_TO_VPSS)
 330     }
 331 #elif defined(xdc_target__isaCompatible_v7M)
 332     if (!(BIOS_smpEnabled) && (Core_getId())) {
 333         if (remoteProcId == NotifyDriverMbx_dspProcId) {
 334             PUT_NOTIFICATION(VPSS_TO_DSP)
 335         }
 336         else if (remoteProcId == NotifyDriverMbx_hostProcId) {
 337             PUT_NOTIFICATION(VPSS_TO_HOST)
 338         }
 339         else {
 340             PUT_NOTIFICATION(VPSS_TO_VIDEO)
 341         }
 342     }
 343     else {
 344         if (remoteProcId == NotifyDriverMbx_dspProcId) {
 345             PUT_NOTIFICATION(VIDEO_TO_DSP)
 346         }
 347         else if (remoteProcId == NotifyDriverMbx_hostProcId) {
 348             PUT_NOTIFICATION(VIDEO_TO_HOST)
 349         }
 350         else {
 351             PUT_NOTIFICATION(VIDEO_TO_VPSS)
 352         }
 353     }
 354 #else
 355     if (remoteProcId == NotifyDriverMbx_dspProcId) {
 356         PUT_NOTIFICATION(HOST_TO_DSP)
 357     }
 358     else if (remoteProcId == NotifyDriverMbx_videoProcId) {
 359         PUT_NOTIFICATION(HOST_TO_VIDEO)
 360     }
 361     else {
 362         PUT_NOTIFICATION(HOST_TO_VPSS)
 363     }
 364 #endif
 365
 366     return (Notify_S_SUCCESS);
 367 }
 368
 369 /*
 370  *  ======== NotifyDriverMbx_disable ========
 371  */
 372 Void NotifyDriverMbx_disable(NotifyDriverMbx_Object *obj)
 373 {
 374     UInt16 remoteProcId = obj->remoteProcId;
 375
 376 #if defined(xdc_target__isaCompatible_64)
 377     if (remoteProcId == NotifyDriverMbx_hostProcId) {
 378         REG32(MAILBOX_IRQENABLE_CLR_DSP) = MAILBOX_REG_VAL(HOST_TO_DSP);
 379     }
 380     else if (remoteProcId == NotifyDriverMbx_videoProcId) {
 381         REG32(MAILBOX_IRQENABLE_CLR_DSP) = MAILBOX_REG_VAL(VIDEO_TO_DSP);
 382     }
 383     else {
 384         REG32(MAILBOX_IRQENABLE_CLR_DSP) = MAILBOX_REG_VAL(VPSS_TO_DSP);
 385     }
 386 #elif defined(xdc_target__isaCompatible_v7M)
 387     if (!(BIOS_smpEnabled) && (Core_getId())) {
 388         if (remoteProcId == NotifyDriverMbx_hostProcId) {
 389             REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
 390         }
 391         else if (remoteProcId == NotifyDriverMbx_dspProcId) {
 392             REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
 393         }
 394         else {
 395             REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(VIDEO_TO_VPSS);
 396         }
 397     }
 398     else {
 399         if (remoteProcId == NotifyDriverMbx_hostProcId) {
 400             REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
 401         }
 402         else if (remoteProcId == NotifyDriverMbx_dspProcId) {
 403             REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
 404         }
 405         else {
 406             REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(VPSS_TO_VIDEO);
 407         }
 408     }
 409 #else
 410     if (remoteProcId == NotifyDriverMbx_dspProcId) {
 411         REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(DSP_TO_HOST);
 412     }
 413     else if (remoteProcId == NotifyDriverMbx_videoProcId) {
 414         REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(VIDEO_TO_HOST);
 415     }
 416     else {
 417         REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(VPSS_TO_HOST);
 418     }
 419 #endif
 420 }
 421
 422 /*
 423  *  ======== NotifyDriverMbx_enable ========
 424  */
 425 Void NotifyDriverMbx_enable(NotifyDriverMbx_Object *obj)
 426 {
 427     UInt16 remoteProcId = obj->remoteProcId;
 428
 429 #if defined(xdc_target__isaCompatible_64)
 430     if (remoteProcId == NotifyDriverMbx_hostProcId) {
 431         REG32(MAILBOX_IRQENABLE_SET_DSP) = MAILBOX_REG_VAL(HOST_TO_DSP);
 432     }
 433     else if (remoteProcId == NotifyDriverMbx_videoProcId) {
 434         REG32(MAILBOX_IRQENABLE_SET_DSP) = MAILBOX_REG_VAL(VIDEO_TO_DSP);
 435     }
 436     else {
 437         REG32(MAILBOX_IRQENABLE_SET_DSP) = MAILBOX_REG_VAL(VPSS_TO_DSP);
 438     }
 439 #elif defined(xdc_target__isaCompatible_v7M)
 440     if (!(BIOS_smpEnabled) && (Core_getId())) {
 441         if (remoteProcId == NotifyDriverMbx_hostProcId) {
 442             REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
 443         }
 444         else if (remoteProcId == NotifyDriverMbx_dspProcId) {
 445             REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
 446         }
 447         else {
 448             REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(VIDEO_TO_VPSS);
 449         }
 450     }
 451     else {
 452         if (remoteProcId == NotifyDriverMbx_hostProcId) {
 453             REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
 454         }
 455         else if (remoteProcId == NotifyDriverMbx_dspProcId) {
 456             REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
 457         }
 458         else {
 459             REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(VPSS_TO_VIDEO);
 460         }
 461     }
 462 #else
 463     if (remoteProcId == NotifyDriverMbx_dspProcId) {
 464         REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(DSP_TO_HOST);
 465     }
 466     else if (remoteProcId == NotifyDriverMbx_videoProcId) {
 467         REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(VIDEO_TO_HOST);
 468     }
 469     else {
 470         REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(VPSS_TO_HOST);
 471     }
 472 #endif
 473 }
 474
 475 /*
 476  *  ======== NotifyDriverMbx_disableEvent ========
 477  */
 478 Void NotifyDriverMbx_disableEvent(NotifyDriverMbx_Object *obj, UInt32 eventId)
 479 {
 480     /* NotifyDriverMbx_disableEvent not supported by this driver */
 481     Assert_isTrue(FALSE, NotifyDriverMbx_A_notSupported);
 482 }
 483
 484 /*
 485  *  ======== NotifyDriverMbx_enableEvent ========
 486  */
 487 Void NotifyDriverMbx_enableEvent(NotifyDriverMbx_Object *obj, UInt32 eventId)
 488 {
 489     /* NotifyDriverMbx_enableEvent not supported by this driver */
 490     Assert_isTrue(FALSE, NotifyDriverMbx_A_notSupported);
 491 }
 492
 493 /*
 494  *************************************************************************
 495  *                       Internal functions
 496  *************************************************************************
 497  */
 498
 499 /*
 500  *  ======== NotifyDriverMbx_isr ========
 501  */
 502
 503 /*
 504  *  Get a message from the mailbox.  The bottom 5 bits of the message
 505  *  contains the eventId.  The top 27 bits of the message contains either
 506  *  1) The payload if the payload is less than 0x7FFFFFF
 507  *  2) 0x7FFFFFF otherwise
 508  *  If the top 27 bits of the first message is 0x7FFFFFF, then the payload
 509  *  is in the next mailbox message.
 510  */
 511 #define GET_NOTIFICATION(dst, src)                                          \
 512     if (REG32(MAILBOX_STATUS(MBX(src, dst)))) {                             \
 513         numProcessed++;                                                     \
 514         msg = REG32(MAILBOX_MESSAGE(MBX(src, dst)));                        \
 515         eventId = (UInt16)(msg & 0x1F);                                     \
 516         payload = msg >> 5;                                                 \
 517         if (payload == 0x7FFFFFF) {                                         \
 518             while(REG32(MAILBOX_STATUS(MBX(src, dst))) == 0);               \
 519             payload = REG32(MAILBOX_MESSAGE(MBX(src, dst)));                \
 520         }                                                                   \
 521         REG32(MAILBOX_IRQSTATUS_CLR_##dst) =                                \
 522                 MAILBOX_REG_VAL(MBX(src, dst));                             \
 523         obj = NotifyDriverMbx_module->drvHandles[PROCID_##src];             \
 524         Assert_isTrue(obj != NULL, ti_sdo_ipc_Notify_A_internal);           \
 525         if (TEST_BIT(obj->evtRegMask, eventId)) {                           \
 526             ti_sdo_ipc_Notify_exec(obj->notifyHandle,                       \
 527                                    eventId,                                 \
 528                                    payload);                                \
 529         }                                                                   \
 530     }
 531
 532 Void NotifyDriverMbx_isr(UArg arg)
 533 {
 534     NotifyDriverMbx_Object *obj;
 535     UInt32 msg, payload;
 536     UInt16 eventId;
 537     Int numProcessed;
 538
 539 #if defined(xdc_target__isaCompatible_64)
 540     do {
 541         numProcessed = 0;
 542         GET_NOTIFICATION(DSP, HOST)
 543         GET_NOTIFICATION(DSP, VPSS)
 544         GET_NOTIFICATION(DSP, VIDEO)
 545     }
 546     while (numProcessed != 0);
 547
 548     /* Write to EOI (End Of Interrupt) register */
 549     REG32(MAILBOX_EOI_REG) = 0x1;
 550
 551 #elif defined(xdc_target__isaCompatible_v7M)
 552     do {
 553         numProcessed = 0;
 554         if (!(BIOS_smpEnabled) && (Core_getId())) {
 555             GET_NOTIFICATION(VPSS, HOST)
 556             GET_NOTIFICATION(VPSS, DSP)
 557             GET_NOTIFICATION(VPSS, VIDEO)
 558         }
 559         else {
 560             GET_NOTIFICATION(VIDEO, HOST)
 561             GET_NOTIFICATION(VIDEO, DSP)
 562             GET_NOTIFICATION(VIDEO, VPSS)
 563         }
 564     }
 565     while (numProcessed != 0);
 566
 567 #else
 568     do {
 569         numProcessed = 0;
 570         GET_NOTIFICATION(HOST, DSP)
 571         GET_NOTIFICATION(HOST, VPSS)
 572         GET_NOTIFICATION(HOST, VIDEO)
 573     }
 574     while (numProcessed != 0);
 575
 576 #endif
 577 }
 578
 579 /*
 580  *  ======== NotifyDriverMbx_setNotifyHandle ========
 581  */
 582 Void NotifyDriverMbx_setNotifyHandle(NotifyDriverMbx_Object *obj,
 583                                      Ptr notifyHandle)
 584 {
 585     /* Internally used, so no Assert needed */
 586     obj->notifyHandle = (ti_sdo_ipc_Notify_Handle)notifyHandle;
 587 }