SDOCM00106428 Add notify mailbox driver support on DRA7xx (Part 1)
authorRamsey Harris <ramsey@ti.com>
Mon, 17 Feb 2014 22:14:54 +0000 (14:14 -0800)
committerChris Ring <cring@ti.com>
Wed, 19 Feb 2014 00:37:12 +0000 (16:37 -0800)
New NotifyDriverMbx module; initial implementation of notify mailbox
driver on dsp only. Added support for multiple notify driver configs
in NotifySetup; requires new dispatch isr for notify events.

13 files changed:
packages/ti/sdo/ipc/family/vayu/InterruptDsp.c
packages/ti/sdo/ipc/family/vayu/InterruptDsp.xdc
packages/ti/sdo/ipc/family/vayu/InterruptDsp.xs
packages/ti/sdo/ipc/family/vayu/NotifyDriverMbx.c [new file with mode: 0644]
packages/ti/sdo/ipc/family/vayu/NotifyDriverMbx.xdc [new file with mode: 0644]
packages/ti/sdo/ipc/family/vayu/NotifyDriverMbx.xs [new file with mode: 0644]
packages/ti/sdo/ipc/family/vayu/NotifySetup.c
packages/ti/sdo/ipc/family/vayu/NotifySetup.xdc
packages/ti/sdo/ipc/family/vayu/NotifySetup.xdt [new file with mode: 0644]
packages/ti/sdo/ipc/family/vayu/NotifySetup.xs
packages/ti/sdo/ipc/family/vayu/TableInit.xs
packages/ti/sdo/ipc/family/vayu/package.bld
packages/ti/sdo/ipc/family/vayu/package.xdc

index 406558e14da94b16fb9c64c652f50c9554f32424..560083b1bb566ff0654cbaf5ade67cc84d4c5f87 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2014, Texas Instruments Incorporated
+ * Copyright (c) 2012-2014 Texas Instruments Incorporated - http://www.ti.com
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  *  Mailbox based interrupt manager
  */
 #include <xdc/std.h>
+#include <xdc/runtime/Assert.h>
 #include <xdc/runtime/Startup.h>
 #include <xdc/runtime/System.h>
-#include <xdc/runtime/Assert.h>
-
-#include <ti/sysbios/family/shared/vayu/IntXbar.h>
 
 #include <ti/sysbios/family/c64p/Hwi.h>
 #include <ti/sysbios/family/c64p/EventCombiner.h>
+#include <ti/sysbios/family/shared/vayu/IntXbar.h>
 
-#include <ti/sdo/utils/_MultiProc.h>
 #include <ti/sdo/ipc/_Ipc.h>
-
+#include <ti/sdo/ipc/family/vayu/NotifySetup.h>
 #include <ti/sdo/ipc/notifyDrivers/IInterrupt.h>
+#include <ti/sdo/utils/_MultiProc.h>
 
 #include "package/internal/InterruptDsp.xdc.h"
 
@@ -198,17 +197,14 @@ Void InterruptDsp_intDisable(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo)
  *  ======== InterruptDsp_intRegister ========
  */
 Void InterruptDsp_intRegister(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo,
-                              Fxn func, UArg arg)
+        Fxn func, UArg arg)
 {
     UInt        key;
-    UInt        eventId;
-    UInt        combinedEventId;
     Int         index;
-    Hwi_Params  params;
     InterruptDsp_FxnTable *table;
 
     Assert_isTrue(((remoteProcId < MultiProc_getNumProcsInCluster()) &&
-                   (remoteProcId != MultiProc_self())), ti_sdo_ipc_Ipc_A_internal);
+            (remoteProcId != MultiProc_self())), ti_sdo_ipc_Ipc_A_internal);
 
     index = PROCID(remoteProcId);
 
@@ -221,28 +217,9 @@ Void InterruptDsp_intRegister(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo,
 
     InterruptDsp_intClear(remoteProcId, intInfo);
 
-    /* Make sure the interrupt only gets plugged once */
-    eventId = InterruptDsp_module->interruptTable[index];
-
-    InterruptDsp_module->numPlugged++;
-
-    if (InterruptDsp_module->numPlugged == 1) {
-        EventCombiner_dispatchPlug(eventId,
-            (Hwi_FuncPtr)InterruptDsp_intShmStub, eventId, TRUE);
-
-        Hwi_Params_init(&params);
-        combinedEventId = eventId / EVENT_GROUP_SIZE;
-        params.eventId = combinedEventId;
-        params.arg = combinedEventId;
-        params.enableInt = TRUE;
-        Hwi_create(intInfo->intVectorId, &ti_sysbios_family_c64p_EventCombiner_dispatch,
-                   &params, NULL);
-        Hwi_enableInterrupt(intInfo->intVectorId);
-    }
-    else {
-        EventCombiner_dispatchPlug(eventId,
-                (Hwi_FuncPtr)InterruptDsp_intShmStub, eventId, TRUE);
-    }
+    /* plug the cpu interrupt */
+    NotifySetup_plugHwi(remoteProcId, intInfo->intVectorId,
+            InterruptDsp_intShmStub);
 
     /* Enable the mailbox interrupt to the DSP */
     InterruptDsp_intEnable(remoteProcId, intInfo);
@@ -257,31 +234,19 @@ Void InterruptDsp_intRegister(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo,
 Void InterruptDsp_intUnregister(UInt16 remoteProcId,
                                 IInterrupt_IntInfo *intInfo)
 {
-    Hwi_Handle  hwiHandle;
-    Int         index;
-    UInt        eventId;
+    Int index;
     InterruptDsp_FxnTable *table;
 
     Assert_isTrue(((remoteProcId < MultiProc_getNumProcsInCluster()) &&
-                   (remoteProcId != MultiProc_self())), ti_sdo_ipc_Ipc_A_internal);
+            (remoteProcId != MultiProc_self())), ti_sdo_ipc_Ipc_A_internal);
 
     index = PROCID(remoteProcId);
 
     /* Disable the mailbox interrupt source */
     InterruptDsp_intDisable(remoteProcId, intInfo);
 
-    /* Make sure the interrupt only gets plugged once */
-    eventId = InterruptDsp_module->interruptTable[index];
-
-    InterruptDsp_module->numPlugged--;
-
-    EventCombiner_disableEvent(eventId);
-
-    if (InterruptDsp_module->numPlugged == 0) {
-        /* Delete the Hwi */
-        hwiHandle = Hwi_getHandle(intInfo->intVectorId);
-        Hwi_delete(&hwiHandle);
-    }
+    /* unplug isr and unprogram the event dispatcher */
+    NotifySetup_unplugHwi(remoteProcId, intInfo->intVectorId);
 
     table = &(InterruptDsp_module->fxnTable[index]);
     table->func = NULL;
@@ -363,32 +328,12 @@ UInt InterruptDsp_intClear(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo)
 /*
  *  ======== InterruptDsp_intShmStub ========
  */
-Void InterruptDsp_intShmStub(UArg arg)
+Void InterruptDsp_intShmStub(UInt16 idx)
 {
-    UInt16 index;
-    UInt16 selfIdx;
-    UInt16 loopIdx;
+    UInt16 srcVirtId;
     InterruptDsp_FxnTable *table;
 
-    selfIdx = MultiProc_self();
-
-    /*
-     * Loop through each Sub-mailbox to determine which one generated
-     * interrupt.
-     */
-    for (loopIdx = 0; loopIdx < MultiProc_getNumProcsInCluster(); loopIdx++) {
-
-        if (loopIdx == selfIdx) {
-            continue;
-        }
-
-        index = MBX_TABLE_IDX(loopIdx, selfIdx);
-
-        if ((REG32(MAILBOX_STATUS(index)) != 0) &&
-            (REG32(MAILBOX_IRQENABLE_SET_DSP(index)) &
-             MAILBOX_REG_VAL(SUBMBX_IDX(index)))) {
-            table = &(InterruptDsp_module->fxnTable[PROCID(loopIdx)]);
-            (table->func)(table->arg);
-        }
-    }
+    srcVirtId = idx / InterruptDsp_NUM_CORES;
+    table = &(InterruptDsp_module->fxnTable[srcVirtId]);
+    (table->func)(table->arg);
 }
index a52b4f59d44bb156b7e17b52b71281e97a4371c4..69a24796436144442021030a88c95174aeba702c 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2013, Texas Instruments Incorporated
+ * Copyright (c) 2012-2014 Texas Instruments Incorporated - http://www.ti.com
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 /*
  *  ======== InterruptDsp.xdc ========
  */
+package ti.sdo.ipc.family.vayu;
 
 import ti.sdo.utils.MultiProc;
+import xdc.rov.ViewInfo;
 
 /*!
  *  ======== InterruptDsp ========
  *  Vayu/DSP interrupt manager
  */
-
 @ModuleStartup
 
 module InterruptDsp inherits ti.sdo.ipc.notifyDrivers.IInterrupt
@@ -54,19 +56,19 @@ module InterruptDsp inherits ti.sdo.ipc.notifyDrivers.IInterrupt
     };
 
     /*! @_nodoc */
-    @Facet
-    metaonly config xdc.rov.ViewInfo.Instance rovViewInfo =
-        xdc.rov.ViewInfo.create({
-            viewMap: [
-                ['IncomingInterrupts',
-                    {
-                        type: xdc.rov.ViewInfo.MODULE_DATA,
-                        viewInitFxn: 'viewInitInterrupt',
-                        structName: 'InterruptDataView'
-                    }
-                ],
-            ]
-        });
+//  @Facet
+//  metaonly config xdc.rov.ViewInfo.Instance rovViewInfo =
+//      xdc.rov.ViewInfo.create({
+//          viewMap: [
+//              ['IncomingInterrupts',
+//                  {
+//                      type: xdc.rov.ViewInfo.MODULE_DATA,
+//                      viewInitFxn: 'viewInitInterrupt',
+//                      structName: 'InterruptDataView'
+//                  }
+//              ],
+//          ]
+//      });
 
     /* Total number of cores on Vayu SoC */
     const UInt8 NUM_CORES = 11;
@@ -119,7 +121,7 @@ internal:
      *  ======== intShmStub ========
      *  Stub to be plugged
      */
-    Void intShmStub(UArg arg);
+    Void intShmStub(UInt16 idx);
 
     struct Module_State {
         /*
@@ -129,12 +131,8 @@ internal:
         FxnTable   fxnTable[NUM_CORES];
 
         /*
-         * Number of numPlugged counters is equal to the number of combined
-         * events used by the mailbox interrupts.
-         */
-        UInt16 numPlugged;  /* # of times the interrupt was registered */
-
-        /* table of interrupt event ids use to communicate with this proc */
+         * Interrupt event IDs used to communicate with this processor.
+         * Table is indexed by virtual processor ID. */
         UInt16 interruptTable[NUM_CORES];
     };
 }
index 75897ed236a9396f8b9b74fee13346c95f81fe97..65a9b41b4f1236aa8152647a7352e06296c691c7 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2013, Texas Instruments Incorporated
+ * Copyright (c) 2012-2014 Texas Instruments Incorporated - http://www.ti.com
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 /*
  *  ======== InterruptDsp.xs ========
  */
 
-var Hwi             = null;
-var InterruptDsp    = null;
+var InterruptDsp = null;
 
 /*
  *  ======== module$use ========
  */
 function module$use()
 {
-    Hwi              = xdc.useModule("ti.sysbios.family.c64p.Hwi");
-    EventCombiner    = xdc.useModule("ti.sysbios.family.c64p.EventCombiner");
-    Ipc              = xdc.useModule("ti.sdo.ipc.Ipc");
-    InterruptDsp     = xdc.useModule("ti.sdo.ipc.family.vayu.InterruptDsp");
-    Xbar             = xdc.useModule("ti.sysbios.family.shared.vayu.IntXbar");
-    TableInit        = xdc.useModule("ti.sdo.ipc.family.vayu.TableInit");
+    var TableInit = xdc.useModule("ti.sdo.ipc.family.vayu.TableInit");
+    InterruptDsp = this;
+    xdc.useModule("ti.sysbios.family.c64p.EventCombiner");
+    xdc.useModule("ti.sysbios.family.c64p.Hwi");
+    xdc.useModule("ti.sysbios.family.shared.vayu.IntXbar");
+    xdc.useModule("ti.sdo.ipc.Ipc");
 
     /* Initialize procIdTable */
     TableInit.initProcId(InterruptDsp);
@@ -107,7 +107,4 @@ function module$static$init(mod, params)
     mod.interruptTable[7] = 0; /* IPU2 -> DSP1 or DSP2 */
     mod.interruptTable[9] = 0; /* IPU1-1 -> DSP1 or DSP2 */
     mod.interruptTable[10] = 0; /* IPU2-1 -> DSP1 or DSP2 */
-
-    /* Intialize numPlugged */
-    mod.numPlugged = 0;
 }
diff --git a/packages/ti/sdo/ipc/family/vayu/NotifyDriverMbx.c b/packages/ti/sdo/ipc/family/vayu/NotifyDriverMbx.c
new file mode 100644 (file)
index 0000000..987500a
--- /dev/null
@@ -0,0 +1,633 @@
+/*
+ * Copyright (c) 2014 Texas Instruments Incorporated - http://www.ti.com
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ *  ======== NotifyDriverMbx.c ========
+ */
+
+#include <xdc/std.h>
+#include <xdc/runtime/Assert.h>
+#include <xdc/runtime/Startup.h>
+
+#include <ti/sysbios/BIOS.h>
+#include <ti/sysbios/family/c64p/EventCombiner.h>
+#include <ti/sysbios/family/c64p/Hwi.h>
+#include <ti/sysbios/family/shared/vayu/IntXbar.h>
+
+#include <ti/sdo/ipc/_Ipc.h>
+#include <ti/sdo/ipc/_Notify.h>
+#include <ti/sdo/ipc/family/vayu/NotifySetup.h>
+#include <ti/sdo/ipc/interfaces/INotifyDriver.h>
+#include <ti/sdo/utils/_MultiProc.h>
+
+#include "package/internal/NotifyDriverMbx.xdc.h"
+
+/* Bit mask operations */
+#define SET_BIT(num,pos)            ((num) |= (1u << (pos)))
+#define CLEAR_BIT(num,pos)          ((num) &= ~(1u << (pos)))
+#define TEST_BIT(num,pos)           ((num) & (1u << (pos)))
+
+/* register access methods */
+#define REG16(A)        (*(volatile UInt16 *)(A))
+#define REG32(A)        (*(volatile UInt32 *)(A))
+
+#define MAILBOX_FIFOLENGTH 4
+#define PROCID(idx) (NotifyDriverMbx_procIdTable[idx])
+
+#define MBX_BASEADDR_IDX(idx) \
+        ((NotifyDriverMbx_mailboxTable[idx] >> 16) & 0xFFFF)
+
+#define MAILBOX_ADDR(idx) \
+        (NotifyDriverMbx_mailboxBaseAddr[MBX_BASEADDR_IDX(idx)])
+
+#define MBX_TABLE_IDX(src, dst) \
+        ((PROCID(src) * NotifyDriverMbx_NUM_CORES) + PROCID(dst))
+
+#define SUBMBX_IDX(idx) (NotifyDriverMbx_mailboxTable[idx] & 0xFF)
+
+#define MBX_USER_IDX(idx) ((NotifyDriverMbx_mailboxTable[idx] >> 8) & 0xFF)
+
+#define MAILBOX_REG_VAL(m) (0x1 << (2 * m))
+
+#define MAILBOX_MESSAGE(idx) \
+        (MAILBOX_ADDR(idx) + 0x40 + (0x4 * SUBMBX_IDX(idx)))
+
+#define MAILBOX_STATUS(idx) \
+        (MAILBOX_ADDR(idx) + 0xC0 + (0x4 * SUBMBX_IDX(idx)))
+
+#define MAILBOX_IRQSTATUS_CLR(idx) \
+        (MAILBOX_ADDR(idx) + 0x104 + (0x10 * MBX_USER_IDX(idx)))
+
+#define MAILBOX_IRQENABLE_SET(idx) \
+        (MAILBOX_ADDR(idx) + 0x108 + (0x10 * MBX_USER_IDX(idx)))
+
+#define MAILBOX_IRQENABLE_CLR(idx) \
+        (MAILBOX_ADDR(idx) + 0x10C + (0x10 * MBX_USER_IDX(idx)))
+
+#define MAILBOX_EOI_REG(idx) (MAILBOX_ADDR(idx) + 0x140)
+
+#define EVENT_GROUP_SIZE 32
+
+/* empty the mailbox for the given index, clear its interrupt */
+#define MAILBOX_INIT(idx)                                                   \
+    while (REG32(MAILBOX_STATUS(idx)) != 0) {                               \
+        REG32(MAILBOX_MESSAGE(idx));                                        \
+    }                                                                       \
+    REG32(MAILBOX_IRQSTATUS_CLR(idx)) = MAILBOX_REG_VAL(SUBMBX_IDX(idx));
+
+/*
+ *************************************************************************
+ *                       Module functions
+ *************************************************************************
+ */
+
+/*
+ *  ======== NotifyDriverMbx_Module_startup ========
+ */
+Int NotifyDriverMbx_Module_startup(Int phase)
+{
+#if defined(xdc_target__isaCompatible_64)
+    extern cregister volatile UInt DNUM;
+
+    if (IntXbar_Module_startupDone()) {
+        /* connect mailbox interrupts at startup */
+        if (DNUM == 0) {               /* DSP1 */
+            IntXbar_connect(24, 284);  // eve1 mailbox 0 user 1
+            IntXbar_connect(25, 293);  // eve2 mailbox 0 user 1
+            IntXbar_connect(26, 249);  // system mailbox 5 user 0
+
+            NotifyDriverMbx_module->interruptTable[6] = 57; // IPU1-0
+            NotifyDriverMbx_module->interruptTable[9] = 57; // IPU1-1
+
+            /* plug eve3 and eve4 mbxs only if eve3 and eve4 exists */
+            if ((MultiProc_getId("EVE3") != MultiProc_INVALIDID) ||
+                (MultiProc_getId("EVE4") != MultiProc_INVALIDID)) {
+                IntXbar_connect(27, 302);  // eve3 mailbox 0 user 1
+                IntXbar_connect(28, 311);  // eve4 mailbox 0 user 1
+            }
+
+            /* plug mbx7 only if DSP2 or IPU2 exists */
+            if ((MultiProc_getId("DSP2") != MultiProc_INVALIDID) ||
+                (MultiProc_getId("IPU2") != MultiProc_INVALIDID) ||
+                (MultiProc_getId("IPU2-0") != MultiProc_INVALIDID)) {
+                IntXbar_connect(29, 257);  // system mailbox 7 user 0
+                NotifyDriverMbx_module->interruptTable[7] = 60; // IPU2-0
+            }
+
+            /* plug mbx8 only if IPU2-1 exists */
+            if (MultiProc_getId("IPU2-1") != MultiProc_INVALIDID) {
+                IntXbar_connect(30, 261);  // system mailbox 8 user 0
+                NotifyDriverMbx_module->interruptTable[10] = 61; // IPU2-1
+            }
+        }
+        else if (DNUM == 1) {          /* DSP2 */
+            IntXbar_connect(24, 287);  // eve1 mailbox 1 user 1
+            IntXbar_connect(25, 296);  // eve2 mailbox 1 user 1
+            IntXbar_connect(26, 253);  // system mailbox 6 user 0
+
+            NotifyDriverMbx_module->interruptTable[7] = 57; // IPU2-0
+            NotifyDriverMbx_module->interruptTable[10] = 57; // IPU2-1
+
+            /* plug eve3 and eve4 mbxs only if eve3 and eve4 exists */
+            if ((MultiProc_getId("EVE3") != MultiProc_INVALIDID) ||
+                (MultiProc_getId("EVE4") != MultiProc_INVALIDID)) {
+                IntXbar_connect(27, 305);  // eve3 mailbox 1 user 1
+                IntXbar_connect(28, 314);  // eve4 mailbox 1 user 1
+            }
+
+            /* plug mbx7 only if DSP1 or IPU1 exists */
+            if ((MultiProc_getId("DSP1") != MultiProc_INVALIDID) ||
+                (MultiProc_getId("IPU1") != MultiProc_INVALIDID) ||
+                (MultiProc_getId("IPU1-0") != MultiProc_INVALIDID)) {
+                IntXbar_connect(29, 258);  // system mailbox 7 user 1
+                NotifyDriverMbx_module->interruptTable[6] = 60; // IPU1-0
+            }
+
+            /* plug mbx8 only if IPU1-1 exists */
+            if (MultiProc_getId("IPU1-1") != MultiProc_INVALIDID) {
+                IntXbar_connect(30, 262);  // system mailbox 8 user 1
+                NotifyDriverMbx_module->interruptTable[9] = 61; // IPU1-1
+            }
+        }
+        return (Startup_DONE);
+    }
+#elif defined(xdc_target__isaCompatible_v7M)
+
+#else
+
+#endif
+    return (Startup_NOTDONE);
+}
+
+/*
+ **************************************************************
+ *                       Instance functions
+ **************************************************************
+ */
+
+/*
+ *  ======== NotifyDriverMbx_Instance_init ========
+ */
+Void NotifyDriverMbx_Instance_init(NotifyDriverMbx_Object *obj,
+        const NotifyDriverMbx_Params *params)
+{
+    UInt        key;
+    UInt16      selfVirtId;
+    UInt16      index;
+
+    /*
+     * Check whether remote proc ID has been set and isn't the same as the
+     * local proc ID
+     */
+    Assert_isTrue((params->remoteProcId != MultiProc_INVALIDID) &&
+            (params->remoteProcId != MultiProc_self()),
+            ti_sdo_ipc_Ipc_A_invParam);
+
+    if (params->remoteProcId >= MultiProc_getNumProcessors() ||
+        params->remoteProcId == MultiProc_INVALIDID) {
+        return;    /* keep Coverity happy */
+    }
+
+    obj->evtRegMask = 0;
+    obj->notifyHandle = NULL;
+    obj->remoteProcId = params->remoteProcId;
+    obj->remoteVirtId = PROCID(params->remoteProcId);
+    obj->cpuIntrNum = params->intVectorId;
+
+    /* disable global interrupts */
+    key = Hwi_disable();
+
+    /* clear mailbox of any old messages */
+    selfVirtId = PROCID(MultiProc_self());
+    index = (selfVirtId * NotifyDriverMbx_NUM_CORES) + obj->remoteVirtId;
+    MAILBOX_INIT(index)
+
+    /* must use processor virtual ID to store driver handle in table */
+    NotifyDriverMbx_module->drvHandles[obj->remoteVirtId] = obj;
+
+    /* plug the cpu interrupt */
+    NotifySetup_plugHwi(params->remoteProcId, params->intVectorId,
+            NotifyDriverMbx_isr);
+
+    /* enable the mailbox interrupt from the remote core */
+    NotifyDriverMbx_enable(obj);
+
+    /* Restore global interrupts */
+    Hwi_restore(key);
+}
+
+/*
+ *  ======== NotifyDriverMbx_Instance_finalize ========
+ */
+Void NotifyDriverMbx_Instance_finalize(NotifyDriverMbx_Object *obj)
+{
+
+    /* disable the mailbox interrupt source */
+    NotifyDriverMbx_disable(obj);
+
+    /* unplug isr and unprogram the event dispatcher */
+    NotifySetup_unplugHwi(obj->remoteProcId, obj->cpuIntrNum);
+
+    /* must use processor virtual ID to remove driver handle from table */
+    NotifyDriverMbx_module->drvHandles[obj->remoteVirtId] = NULL;
+}
+
+/*
+ *  ======== NotifyDriverMbx_registerEvent ========
+ */
+Void NotifyDriverMbx_registerEvent(NotifyDriverMbx_Object *obj,
+                                   UInt32 eventId)
+{
+    UInt hwiKey;
+
+    /*
+     *  Disable interrupt line to ensure that isr doesn't
+     *  preempt registerEvent and encounter corrupt state
+     */
+    hwiKey = Hwi_disable();
+
+    /* Set the 'registered' bit */
+    SET_BIT(obj->evtRegMask, eventId);
+
+    /* Restore the interrupt line */
+    Hwi_restore(hwiKey);
+}
+
+/*
+ *  ======== NotifyDriverMbx_unregisterEvent ========
+ */
+Void NotifyDriverMbx_unregisterEvent(NotifyDriverMbx_Object *obj,
+                                     UInt32 eventId)
+{
+    UInt hwiKey;
+
+    /*
+     *  Disable interrupt line to ensure that isr doesn't
+     *  preempt registerEvent and encounter corrupt state
+     */
+    hwiKey = Hwi_disable();
+
+    /* Clear the registered bit */
+    CLEAR_BIT(obj->evtRegMask, eventId);
+
+    /* Restore the interrupt line */
+    Hwi_restore(hwiKey);
+}
+
+/*
+ *  ======== NotifyDriverMbx_sendEvent ========
+ */
+/*
+ *  PUT_NOTIFICATION will spin waiting for enough room in the mailbox FIFO
+ *  to store the number of messages needed for the notification ('numMsgs').
+ *  If spinning is necesssary (i.e. if waitClear is TRUE and there isn't enough
+ *  room in the FIFO) then PUT_NOTIFICATION will allow pre-emption while
+ *  spinning.
+ *
+ *  PUT_NOTIFICATION needs to prevent another local thread from writing to the
+ *  same mailbox after the current thread has
+ *  1) determined that there is enough room to write the notification and
+ *  2) written the first of two messages to the mailbox.
+ *  This is needed to respectively prevent
+ *  1) both threads from incorrectly assuming there is enough space in the FIFO
+ *     for their own notifications
+ *  2) the interrupting thread from writing a notification between two
+ *     two messages that need to be successivly written by the preempted thread.
+ *  Therefore, the check for enough FIFO room and one/both mailbox write(s)
+ *  should all occur atomically (i.e. with interrupts disabled)
+ */
+#define PUT_NOTIFICATION(idx)                                               \
+        key = Hwi_disable();                                                \
+        while(MAILBOX_FIFOLENGTH - REG32(MAILBOX_STATUS(idx)) < numMsgs) {  \
+            Hwi_restore(key);                                               \
+            if (!waitClear) {                                               \
+                return (Notify_E_FAIL);                                     \
+            }                                                               \
+            key = Hwi_disable();                                            \
+        };                                                                  \
+        REG32(MAILBOX_MESSAGE(idx)) = eventId + smallPayload;               \
+        if (smallPayload == 0xFFFFFFE0) {                                   \
+            REG32(MAILBOX_MESSAGE(idx)) = payload;                          \
+        }                                                                   \
+        Hwi_restore(key);
+
+Int NotifyDriverMbx_sendEvent(NotifyDriverMbx_Object *obj, UInt32 eventId,
+        UInt32 payload, Bool waitClear)
+{
+    UInt16 selfVirtId = PROCID(MultiProc_self());
+    UInt key, numMsgs;
+    UInt32 smallPayload;
+    UInt16 index;
+
+    /* Decide if the payload is small enough to fit in the first mbx msg */
+    if (payload < 0x7FFFFFF) {
+        smallPayload = (payload << 5);
+        numMsgs = 1;
+    }
+    else {
+        smallPayload = 0xFFFFFFE0;
+        numMsgs = 2;
+    }
+
+#if defined(xdc_target__isaCompatible_64)
+    index = (selfVirtId * NotifyDriverMbx_NUM_CORES) + obj->remoteVirtId;
+    PUT_NOTIFICATION(index);
+
+#elif defined(xdc_target__isaCompatible_v7M)
+
+#if 0
+    if (!(BIOS_smpEnabled) && (Core_getId())) {
+        if (remoteProcId == NotifyDriverMbx_dspProcId) {
+            PUT_NOTIFICATION(VPSS_TO_DSP)
+        }
+        else if (remoteProcId == NotifyDriverMbx_hostProcId) {
+            PUT_NOTIFICATION(VPSS_TO_HOST)
+        }
+        else {
+            PUT_NOTIFICATION(VPSS_TO_VIDEO)
+        }
+    }
+    else {
+        if (remoteProcId == NotifyDriverMbx_dspProcId) {
+            PUT_NOTIFICATION(VIDEO_TO_DSP)
+        }
+        else if (remoteProcId == NotifyDriverMbx_hostProcId) {
+            PUT_NOTIFICATION(VIDEO_TO_HOST)
+        }
+        else {
+            PUT_NOTIFICATION(VIDEO_TO_VPSS)
+        }
+    }
+
+#endif
+
+#else
+
+#if 0
+    if (remoteProcId == NotifyDriverMbx_dspProcId) {
+        PUT_NOTIFICATION(HOST_TO_DSP)
+    }
+    else if (remoteProcId == NotifyDriverMbx_videoProcId) {
+        PUT_NOTIFICATION(HOST_TO_VIDEO)
+    }
+    else {
+        PUT_NOTIFICATION(HOST_TO_VPSS)
+    }
+
+#endif
+
+#endif
+
+    return (Notify_S_SUCCESS);
+}
+
+/*
+ *  ======== NotifyDriverMbx_disable ========
+ */
+Void NotifyDriverMbx_disable(NotifyDriverMbx_Object *obj)
+{
+    UInt16 selfVirtId = PROCID(MultiProc_self());
+    UInt16 index;
+
+#if defined(xdc_target__isaCompatible_64)
+    index = (obj->remoteVirtId * NotifyDriverMbx_NUM_CORES) + selfVirtId;
+    REG32(MAILBOX_IRQENABLE_CLR(index)) = MAILBOX_REG_VAL(SUBMBX_IDX(index));
+
+#elif defined(xdc_target__isaCompatible_v7M)
+
+#if 0
+    if (!(BIOS_smpEnabled) && (Core_getId())) {
+        if (remoteProcId == NotifyDriverMbx_hostProcId) {
+            REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
+        }
+        else if (remoteProcId == NotifyDriverMbx_dspProcId) {
+            REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
+        }
+        else {
+            REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(VIDEO_TO_VPSS);
+        }
+    }
+    else {
+        if (remoteProcId == NotifyDriverMbx_hostProcId) {
+            REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
+        }
+        else if (remoteProcId == NotifyDriverMbx_dspProcId) {
+            REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
+        }
+        else {
+            REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(VPSS_TO_VIDEO);
+        }
+    }
+#endif
+
+#else
+
+#if 0
+    if (remoteProcId == NotifyDriverMbx_dspProcId) {
+        REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(DSP_TO_HOST);
+    }
+    else if (remoteProcId == NotifyDriverMbx_videoProcId) {
+        REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(VIDEO_TO_HOST);
+    }
+    else {
+        REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(VPSS_TO_HOST);
+    }
+#endif
+
+#endif
+}
+
+/*
+ *  ======== NotifyDriverMbx_enable ========
+ */
+Void NotifyDriverMbx_enable(NotifyDriverMbx_Object *obj)
+{
+    UInt16 selfVirtId = PROCID(MultiProc_self());
+    UInt16 index;
+
+#if defined(xdc_target__isaCompatible_64)
+    index = (obj->remoteVirtId * NotifyDriverMbx_NUM_CORES) + selfVirtId;
+    REG32(MAILBOX_IRQENABLE_SET(index)) = MAILBOX_REG_VAL(SUBMBX_IDX(index));
+
+#elif defined(xdc_target__isaCompatible_v7M)
+
+#if 0
+    if (!(BIOS_smpEnabled) && (Core_getId())) {
+        if (remoteProcId == NotifyDriverMbx_hostProcId) {
+            REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
+        }
+        else if (remoteProcId == NotifyDriverMbx_dspProcId) {
+            REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
+        }
+        else {
+            REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(VIDEO_TO_VPSS);
+        }
+    }
+    else {
+        if (remoteProcId == NotifyDriverMbx_hostProcId) {
+            REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
+        }
+        else if (remoteProcId == NotifyDriverMbx_dspProcId) {
+            REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
+        }
+        else {
+            REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(VPSS_TO_VIDEO);
+        }
+    }
+#endif
+
+#else
+
+#if 0
+    if (remoteProcId == NotifyDriverMbx_dspProcId) {
+        REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(DSP_TO_HOST);
+    }
+    else if (remoteProcId == NotifyDriverMbx_videoProcId) {
+        REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(VIDEO_TO_HOST);
+    }
+    else {
+        REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(VPSS_TO_HOST);
+    }
+#endif
+
+#endif
+}
+
+/*
+ *  ======== NotifyDriverMbx_disableEvent ========
+ */
+Void NotifyDriverMbx_disableEvent(NotifyDriverMbx_Object *obj, UInt32 eventId)
+{
+    /* NotifyDriverMbx_disableEvent not supported by this driver */
+    Assert_isTrue(FALSE, NotifyDriverMbx_A_notSupported);
+}
+
+/*
+ *  ======== NotifyDriverMbx_enableEvent ========
+ */
+Void NotifyDriverMbx_enableEvent(NotifyDriverMbx_Object *obj, UInt32 eventId)
+{
+    /* NotifyDriverMbx_enableEvent not supported by this driver */
+    Assert_isTrue(FALSE, NotifyDriverMbx_A_notSupported);
+}
+
+/*
+ *************************************************************************
+ *                       Internal functions
+ *************************************************************************
+ */
+
+/*
+ *  ======== NotifyDriverMbx_isr ========
+ */
+
+/*  Read a message from the mailbox. The low 5 bits of the message
+ *  contains the eventId. The high 27 bits of the message contains
+ *  either:
+ *      1) The payload if the payload is less than 0x7FFFFFF
+ *      2) 0x7FFFFFF otherwise
+ *  If the high 27 bits of the first message is 0x7FFFFFF, then the
+ *  payload is in the next mailbox message.
+ *
+ *  idx = mailbox table index
+ */
+#define MESSAGE_DELIVERY(idx)                                               \
+    msg = REG32(MAILBOX_MESSAGE(idx));                                      \
+    eventId = (UInt16)(msg & 0x1F);                                         \
+    payload = msg >> 5;                                                     \
+    if (payload == 0x7FFFFFF) {                                             \
+        while(REG32(MAILBOX_STATUS(idx)) == 0);                             \
+        payload = REG32(MAILBOX_MESSAGE(idx));                              \
+    }                                                                       \
+    REG32(MAILBOX_IRQSTATUS_CLR(idx)) = MAILBOX_REG_VAL(SUBMBX_IDX(idx));   \
+    obj = NotifyDriverMbx_module->drvHandles[srcVirtId];                    \
+    Assert_isTrue(obj != NULL, ti_sdo_ipc_Notify_A_internal);               \
+    if (TEST_BIT(obj->evtRegMask, eventId)) {                               \
+        ti_sdo_ipc_Notify_exec(obj->notifyHandle, eventId, payload);        \
+    }                                                                       \
+    REG32(MAILBOX_EOI_REG(idx)) = 0x1;
+
+Void NotifyDriverMbx_isr(UInt16 idx)
+{
+    NotifyDriverMbx_Object *obj;
+    UInt32 msg, payload;
+    UInt16 eventId;
+
+#if defined(xdc_target__isaCompatible_64)
+    UInt16 srcVirtId;
+
+    srcVirtId = idx / NotifyDriverMbx_NUM_CORES;
+    MESSAGE_DELIVERY(idx)
+
+#elif defined(xdc_target__isaCompatible_v7M)
+
+#if 0
+    do {
+        numProcessed = 0;
+        if (!(BIOS_smpEnabled) && (Core_getId())) {
+            GET_NOTIFICATION(VPSS, HOST)
+            GET_NOTIFICATION(VPSS, DSP)
+            GET_NOTIFICATION(VPSS, VIDEO)
+        }
+        else {
+            GET_NOTIFICATION(VIDEO, HOST)
+            GET_NOTIFICATION(VIDEO, DSP)
+            GET_NOTIFICATION(VIDEO, VPSS)
+        }
+    }
+    while (numProcessed != 0);
+#endif
+
+#else
+
+#if 0
+    do {
+        numProcessed = 0;
+        GET_NOTIFICATION(HOST, DSP)
+        GET_NOTIFICATION(HOST, VPSS)
+        GET_NOTIFICATION(HOST, VIDEO)
+    }
+    while (numProcessed != 0);
+#endif
+
+#endif
+}
+
+/*
+ *  ======== NotifyDriverMbx_setNotifyHandle ========
+ */
+Void NotifyDriverMbx_setNotifyHandle(NotifyDriverMbx_Object *obj,
+        Ptr notifyHandle)
+{
+    /* internally used, so no assert needed */
+    obj->notifyHandle = (ti_sdo_ipc_Notify_Handle)notifyHandle;
+}
diff --git a/packages/ti/sdo/ipc/family/vayu/NotifyDriverMbx.xdc b/packages/ti/sdo/ipc/family/vayu/NotifyDriverMbx.xdc
new file mode 100644 (file)
index 0000000..f6b4d8e
--- /dev/null
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) 2014 Texas Instruments Incorporated - http://www.ti.com
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ *  ======== NotifyDriverMbx.xdc ================
+ */
+package ti.sdo.ipc.family.vayu;
+
+import ti.sdo.utils.MultiProc;
+import ti.sdo.ipc.interfaces.INotifyDriver;
+import ti.sdo.ipc.Notify;
+
+import ti.sysbios.hal.Hwi;
+
+import xdc.runtime.Assert;
+import xdc.rov.ViewInfo;
+
+/*!
+ *  ======== NotifyDriverMbx ========
+ *  A notify driver based on hardware mailbox.
+ *
+ *  This notify driver uses hardware mailboxes to transmit notifications
+ *  to remote processors. This driver implements the
+ *  {@link ti.sdo.ipc.interfaces.INotifyDriver} interface.
+ *
+ *  Unlike the Notify drivers available in the {@link ti.sdo.ipc.notifyDrivers}
+ *  package, this driver is not generic and will only work with the Vayu
+ *  family of devices.
+ *
+ *  The driver does not use shared memory. The event IDs and payloads are
+ *  transmitted via the hardware mailbox FIFO. The FIFO can hold up to 4
+ *  mailbox messages. The number of notification that can be stored in the
+ *  FIFO depends on the size of the payloads being sent via Notify_sendEvent.
+ *  If the payload is less than 0x7FFFFFF, then a single message will be
+ *  sent per notification. Otherwise, two mailbox messages are needed to
+ *  send the notification.
+ *
+ *  The behavior of Notify_sendEvent when the FIFO is full depends on the
+ *  value of the 'waitClear' argument to the function. If 'waitClear' is
+ *  TRUE, then Notify_sendEvent will spin waiting for enough room in the
+ *  FIFO. If 'waitClear' is FALSE, then Notify_sendEvent will return
+ *  Notify_E_FAIL.
+ *
+ *  The Notify_enableEvent and Notify_disableEvent APIs are not supported
+ *  by this driver.
+ */
+@InstanceFinalize
+@ModuleStartup
+
+module NotifyDriverMbx inherits ti.sdo.ipc.interfaces.INotifyDriver
+{
+    /*! @_nodoc */
+    metaonly struct BasicView {
+        String      remoteProc;
+        String      mailboxAddr;
+        Int         subMbxId;
+        Int         count;
+    }
+
+    /*!  @_nodoc */
+    metaonly struct ModuleView {
+        UInt16                  interruptTable[NUM_CORES];
+        NotifyDriverMbx.Handle  drvHandles[NUM_CORES];
+    }
+
+    /*!
+     *  ======== rovViewInfo ========
+     */
+    @Facet
+    metaonly config ViewInfo.Instance rovViewInfo =
+        ViewInfo.create({
+            viewMap: [
+                ['Basic',
+                    {
+                        type: ViewInfo.INSTANCE,
+                        viewInitFxn: 'viewInitBasic',
+                        structName: 'BasicView'
+                    }
+                ]
+//              ['Module',
+//                  {
+//                      type: ViewInfo.MODULE,
+//                      viewInitFxn: 'viewInitModule',
+//                      structName: 'ModuleView'
+//                  }
+//              ]
+            ]
+        });
+
+    /*!
+     *  Assert raised when trying to use Notify_[enable/disable]Event with
+     *  NotifyDriverMbx
+     */
+    config Assert.Id A_notSupported = {
+        msg: "A_notSupported: [enable/disable]Event not supported"
+    };
+
+instance:
+
+    /*!
+     *  ======== remoteProcId ========
+     *  The MultiProc ID corresponding to the remote processor
+     *
+     *  This is a required parameter, it is not optional.
+     */
+    config UInt16 remoteProcId = MultiProc.INVALIDID;
+
+    /*!
+     *  ======== intVectorId ========
+     *  Interrupt vector ID to be used by the driver.
+     *
+     *  This parameter is only used by C66 targets.
+     *  This is a required parameter, it is not optional.
+     */
+    config UInt intVectorId = ~1u;
+
+internal:
+    /* total number of cores on Vayu SoC */
+    const UInt8 NUM_CORES = 11;
+
+    /* number of cores in eve subsystem */
+    const UInt8 NUM_EVES = 4;
+
+    /* number of internal eve mailboxes */
+    const UInt8 NUM_EVE_MBX = 12;
+
+    /* number of system mailboxes (used by IPC) */
+    const UInt8 NUM_SYS_MBX = 4;
+
+    /*  Mailbox table for storing encoded base address, mailbox user ID,
+     *  and sub-mailbox index.
+     */
+    config UInt32 mailboxTable[NUM_CORES * NUM_CORES];
+
+    /* base address table for the mailbox subsystem */
+    config UInt32 mailboxBaseAddr[NUM_EVE_MBX + NUM_SYS_MBX];
+
+    /* map MultiProc ID to virtual ID, virtId = procIdTable[procId] */
+    config UInt32 procIdTable[NUM_CORES];
+
+    /*! define MultiProcID for each core to avoid doing this at runtime */
+    config UInt eve1ProcId     = MultiProc.INVALIDID;
+    config UInt eve2ProcId     = MultiProc.INVALIDID;
+    config UInt eve3ProcId     = MultiProc.INVALIDID;
+    config UInt eve4ProcId     = MultiProc.INVALIDID;
+    config UInt dsp1ProcId     = MultiProc.INVALIDID;
+    config UInt dsp2ProcId     = MultiProc.INVALIDID;
+    config UInt ipu1_0ProcId   = MultiProc.INVALIDID;
+    config UInt ipu2_0ProcId   = MultiProc.INVALIDID;
+    config UInt hostProcId     = MultiProc.INVALIDID;
+    config UInt ipu1_1ProcId   = MultiProc.INVALIDID;
+    config UInt ipu2_1ProcId   = MultiProc.INVALIDID;
+
+    /* plugs the interrupt and executes the callback functions */
+    Void isr(UInt16 idx);
+
+    /*! instance state structure */
+    struct Instance_State {
+        Bits32          evtRegMask;     /* local event register mask        */
+        Notify.Handle   notifyHandle;   /* handle to front-end object       */
+        UInt16          remoteProcId;   /* remote processor ID              */
+        UInt16          remoteVirtId;   /* remote processor virtual ID      */
+        Int             cpuIntrNum;     /* cpu interrupt number             */
+    }
+
+    struct Module_State {
+        /*  Interrupt event IDs used to communicate with this processor.
+         *  This table is indexed by virtual processor ID.
+         *  TODO: move this table to NotifySetup module
+         */
+        UInt16 interruptTable[NUM_CORES];
+
+        /*  Used by the isr to retrieve the driver handle. This table is
+         *  indexed by virtual processorID.
+         */
+        NotifyDriverMbx.Handle drvHandles[NUM_CORES];
+    };
+}
diff --git a/packages/ti/sdo/ipc/family/vayu/NotifyDriverMbx.xs b/packages/ti/sdo/ipc/family/vayu/NotifyDriverMbx.xs
new file mode 100644 (file)
index 0000000..be8251d
--- /dev/null
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2012-2014, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ *  ======== NotifyDriverMbx.xs ================
+ */
+
+var NotifyDriverMbx = null;
+var Core = null;
+
+/*
+ *  ======== module$use ========
+ */
+function module$use()
+{
+    var TableInit = xdc.useModule("ti.sdo.ipc.family.vayu.TableInit");
+
+    NotifyDriverMbx = this;
+
+    xdc.useModule("ti.sysbios.family.shared.vayu.IntXbar");
+    xdc.useModule("ti.sysbios.family.c64p.EventCombiner");
+    xdc.useModule("ti.sysbios.family.c64p.Hwi");
+    xdc.useModule("ti.sdo.ipc.Notify");
+    xdc.useModule("ti.sdo.utils.MultiProc");
+
+    if (Program.build.target.$name.match(/M3/)) {
+        Core = xdc.useModule("ti.sysbios.family.arm.ducati.Core");
+    }
+
+    /* initialize procIdTable */
+    TableInit.initProcId(NotifyDriverMbx);
+
+    /* Initialize mailboxTable */
+    TableInit.generateTable(NotifyDriverMbx);
+
+    /* Initialize mailbox base address table */
+    this.mailboxBaseAddr[0]  = 0x4208B000;  /* EVE1 Internal Mailbox 0 */
+    this.mailboxBaseAddr[1]  = 0x4208C000;  /* EVE1 Internal Mailbox 1 */
+    this.mailboxBaseAddr[2]  = 0x4208D000;  /* EVE1 Internal Mailbox 2 */
+    this.mailboxBaseAddr[3]  = 0x4218B000;  /* EVE2 Internal Mailbox 0 */
+    this.mailboxBaseAddr[4]  = 0x4218C000;  /* EVE2 Internal Mailbox 1 */
+    this.mailboxBaseAddr[5]  = 0x4218D000;  /* EVE2 Internal Mailbox 2 */
+    this.mailboxBaseAddr[6]  = 0x4228B000;  /* EVE3 Internal Mailbox 0 */
+    this.mailboxBaseAddr[7]  = 0x4228C000;  /* EVE3 Internal Mailbox 1 */
+    this.mailboxBaseAddr[8]  = 0x4228D000;  /* EVE3 Internal Mailbox 2 */
+    this.mailboxBaseAddr[9]  = 0x4238B000;  /* EVE4 Internal Mailbox 0 */
+    this.mailboxBaseAddr[10] = 0x4238C000;  /* EVE4 Internal Mailbox 1 */
+    this.mailboxBaseAddr[11] = 0x4238D000;  /* EVE4 Internal Mailbox 2 */
+    this.mailboxBaseAddr[12] = 0x48840000;  /* System Mailbox 5 */
+    this.mailboxBaseAddr[13] = 0x48842000;  /* System Mailbox 6 */
+    this.mailboxBaseAddr[14] = 0x48844000;  /* System Mailbox 7 */
+    this.mailboxBaseAddr[15] = 0x48846000;  /* System Mailbox 8 */
+}
+
+
+/*
+ *  ======== module$static$init ========
+ *  Initialize the target state object.
+ */
+function module$static$init(state, mod)
+{
+
+    for (var i = 0; i < state.drvHandles.length; i++) {
+        state.drvHandles[i] = null;
+    }
+
+    /* TODO this code is specific to the DSP, need to add other processors */
+
+
+    if (Program.build.target.$name.match(/M3/)) {
+/* TODO */
+if (0) {
+        if (Core.id == 0) {
+            Hwi.construct(state.hwi, 53, NotifyDriverMbx.isr);
+        }
+        else {
+            Hwi.construct(state.hwi, 54, NotifyDriverMbx.isr);
+        }
+}
+    }
+    else if (Program.build.target.isa == "66") {
+        /* interrupt event IDs used by this processor */
+        state.interruptTable[0] = 55; /* EVE1 -> DSP1 or DSP2 */
+        state.interruptTable[1] = 56; /* EVE2 -> DSP1 or DSP2 */
+        state.interruptTable[2] = 58; /* EVE3 -> DSP1 or DSP2 */
+        state.interruptTable[3] = 59; /* EVE4 -> DSP1 or DSP2 */
+        state.interruptTable[4] = 60; /* DSP1 -> DSP2 */
+        state.interruptTable[5] = 60; /* DSP2 -> DSP1 */
+        state.interruptTable[8] = 57; /* HOST -> DSP1 or DSP2 */
+
+        /* these are not known at config time, set at runtime */
+        state.interruptTable[6] = 0; /* IPU1 -> DSP1 or DSP2 */
+        state.interruptTable[7] = 0; /* IPU2 -> DSP1 or DSP2 */
+        state.interruptTable[9] = 0; /* IPU1-1 -> DSP1 or DSP2 */
+        state.interruptTable[10] = 0; /* IPU2-1 -> DSP1 or DSP2 */
+    }
+    else if (Program.build.target.$name.match(/A8/)) {
+/* TODO */
+if (0) {
+        Hwi.construct(state.hwi, 77, NotifyDriverMbx.isr);
+}
+    }
+    else {
+        throw("Invalid target: " + Program.build.target.$name);
+    }
+}
+
+/*
+ *************************************************************************
+ *                       ROV View functions
+ *************************************************************************
+ */
+
+/*
+ *  ======== viewInitBasic ========
+ */
+function viewInitBasic(view, obj)
+{
+    var Program = xdc.useModule('xdc.rov.Program');
+    var ScalarStructs = xdc.useModule('xdc.rov.support.ScalarStructs');
+    var MultiProc = xdc.useModule('ti.sdo.utils.MultiProc');
+    var modCfg = Program.getModuleConfig(
+            'ti.sdo.ipc.family.vayu.NotifyDriverMbx');
+
+    /* translate the virtual id to a processor id */
+    var remoteProcId = -1;
+
+    for (var i = 0; i < modCfg.procIdTable.length; i++) {
+        if (obj.remoteVirtId == modCfg.procIdTable[i]) {
+            remoteProcId = i;
+            break;
+        }
+    }
+
+    /* view.remoteProc */
+    try {
+        view.remoteProc = MultiProc.getName$view(remoteProcId);
+    }
+    catch (e) {
+        Program.displayError(view, 'remoteProc',
+                "Problem retrieving proc name: " + e);
+    }
+
+    /* view.mailboxAddr */
+    var selfVirtId = modCfg.procIdTable[MultiProc.self$view()];
+    var idx = (obj.remoteVirtId * modCfg.NUM_CORES) + selfVirtId;
+    var baseAddrIdx = (modCfg.mailboxTable[idx] >> 16) & 0xFFFF;
+    var mailboxAddr = modCfg.mailboxBaseAddr[baseAddrIdx];
+    view.mailboxAddr = "0x" + Number(mailboxAddr).toString(16);
+
+    /* view.subMbxId */
+    view.subMbxId = modCfg.mailboxTable[idx] & 0xFF;
+
+    /* view.count */
+    try {
+        var MAILBOX_STATUS_IN = Program.fetchStruct(
+                ScalarStructs.S_Bits32$fetchDesc,
+                mailboxAddr + 0xC0 + (0x4 * view.subMbxId), false);
+        view.count = MAILBOX_STATUS_IN.elem;
+    }
+    catch (e) {
+        throw(e);
+    }
+}
index 023a1c25a5bdece19e4b07ef463f56817ad23c34..2f7710af638c7d005166f7f504a2398c346b9d4e 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2013, Texas Instruments Incorporated
+ * Copyright (c) 2012-2014 Texas Instruments Incorporated - http://www.ti.com
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 /*
  *  ======== NotifySetup.c ========
  */
 #include <xdc/std.h>
+#include <xdc/runtime/Assert.h>
 #include <xdc/runtime/Error.h>
+#include <xdc/runtime/Startup.h>
 
-#include <ti/sdo/ipc/notifyDrivers/NotifyDriverShm.h>
 #include <ti/sdo/ipc/_Notify.h>
 #include <ti/sdo/ipc/Ipc.h>
-
+#include <ti/sdo/ipc/family/vayu/NotifyDriverMbx.h>
+#include <ti/sdo/ipc/notifyDrivers/NotifyDriverShm.h>
 #include <ti/sdo/utils/_MultiProc.h>
 
+#include <ti/sysbios/family/c64p/EventCombiner.h>
+#include <ti/sysbios/family/c64p/Hwi.h>
+#include <ti/sysbios/family/shared/vayu/IntXbar.h>
+
 #include "package/internal/NotifySetup.xdc.h"
 
-#define PROCID(IDX)               (NotifySetup_procIdTable[(IDX)])
+
+#define EVENT_GROUP_SIZE 32
+
+/* register access methods */
+#define REG16(A)        (*(volatile UInt16 *)(A))
+#define REG32(A)        (*(volatile UInt32 *)(A))
+
+/* ipc helper macros */
+#define MAILBOX_REG_VAL(m) (0x1 << (2 * (m)))
+
+#define VIRTID(procId) (NotifySetup_procIdTable[(procId)])
+
+#define MBX_BASEADDR_IDX(idx) ((NotifySetup_mailboxTable[(idx)] >> 16) & 0xFFFF)
+
+#define MBX_USER_IDX(idx) ((NotifySetup_mailboxTable[(idx)] >> 8) & 0xFF)
+
+#define SUBMBX_IDX(idx) (NotifySetup_mailboxTable[(idx)] & 0xFF)
+
+#define MAILBOX_ADDR(idx) \
+        (NotifySetup_mailboxBaseAddr[MBX_BASEADDR_IDX(idx)])
+
+#define MAILBOX_STATUS(idx) \
+        (MAILBOX_ADDR((idx)) + 0xC0 + (0x4 * SUBMBX_IDX((idx))))
+
+#define MAILBOX_IRQENABLE_SET(idx) \
+        (MAILBOX_ADDR((idx)) + 0x108 + (0x10 * MBX_USER_IDX((idx))))
+
+#define MBOX_IRQ_ENABLE(idx) \
+    ((REG32(MAILBOX_IRQENABLE_SET((idx))) & \
+    MAILBOX_REG_VAL(SUBMBX_IDX((idx)))) != 0)
+
+#define MBOX_MSG_COUNT(idx) (REG32(MAILBOX_STATUS((idx))))
+
 
 /*
  *************************************************************************
  *************************************************************************
  */
 
+/*
+ *  ======== NotifySetup_Module_startup ========
+ */
+Int NotifySetup_Module_startup(Int phase)
+{
+#if defined(xdc_target__isa_66)
+
+    extern cregister volatile UInt DNUM;
+
+    if (IntXbar_Module_startupDone()) {
+        if (DNUM == 0) {               /* DSP1 */
+            NotifySetup_module->interruptTable[6] = 57; // IPU1-0
+            NotifySetup_module->interruptTable[9] = 57; // IPU1-1
+
+            /* plug eve3 and eve4 mbxs only if eve3 and eve4 exists */
+            if ((MultiProc_getId("EVE3") != MultiProc_INVALIDID) ||
+                (MultiProc_getId("EVE4") != MultiProc_INVALIDID)) {
+            }
+
+            /* plug mbx7 only if DSP2 or IPU2 exists */
+            if ((MultiProc_getId("DSP2") != MultiProc_INVALIDID) ||
+                (MultiProc_getId("IPU2") != MultiProc_INVALIDID) ||
+                (MultiProc_getId("IPU2-0") != MultiProc_INVALIDID)) {
+                NotifySetup_module->interruptTable[7] = 60; // IPU2-0
+            }
+
+            /* plug mbx8 only if IPU2-1 exists */
+            if (MultiProc_getId("IPU2-1") != MultiProc_INVALIDID) {
+                NotifySetup_module->interruptTable[10] = 61; // IPU2-1
+            }
+        }
+        else if (DNUM == 1) {          /* DSP2 */
+            NotifySetup_module->interruptTable[7] = 57; // IPU2-0
+            NotifySetup_module->interruptTable[10] = 57; // IPU2-1
+
+            /* plug eve3 and eve4 mbxs only if eve3 and eve4 exists */
+            if ((MultiProc_getId("EVE3") != MultiProc_INVALIDID) ||
+                (MultiProc_getId("EVE4") != MultiProc_INVALIDID)) {
+            }
+
+            /* plug mbx7 only if DSP1 or IPU1 exists */
+            if ((MultiProc_getId("DSP1") != MultiProc_INVALIDID) ||
+                (MultiProc_getId("IPU1") != MultiProc_INVALIDID) ||
+                (MultiProc_getId("IPU1-0") != MultiProc_INVALIDID)) {
+                NotifySetup_module->interruptTable[6] = 60; // IPU1-0
+            }
+
+            /* plug mbx8 only if IPU1-1 exists */
+            if (MultiProc_getId("IPU1-1") != MultiProc_INVALIDID) {
+                NotifySetup_module->interruptTable[9] = 61; // IPU1-1
+            }
+        }
+        return (Startup_DONE);
+    }
+
+    return (Startup_NOTDONE);
+
+#elif defined(xdc_target__isa_arp32)
+
+    /* TODO */
+    return (Startup_DONE);
+
+#elif defined(xdc_target__isa_v7M4)
+
+    /* TODO */
+    return (Startup_DONE);
+
+#elif defined(xdc_target__isa_v7A15)
+
+    /* TODO */
+    return (Startup_DONE);
+
+#else
+#error Invalid target
+#endif
+}
+
 /*!
  *  ======== NotifySetup_attach ========
- *  Initialize interrupt
+ *  Create driver instance specified at config time.
+ *
+ *  This functions is generated by the NotifySetup.xdt template.
+ */
+
+/*!
+ *  ======== NotifySetup_sharedMemReq ========
+ *  Compute how much shared memory is required by the driver.
+ *
+ *  This functions is generated by the NotifySetup.xdt template.
+ */
+
+/*!
+ * ======== NotifySetup_numIntLines ========
+ * Return number of available interrupt lines to the current processor.
+ */
+UInt16 NotifySetup_numIntLines(UInt16 remoteProcId)
+{
+    return (1);
+}
+
+/*
+ *  ======== NotifySetup_driverType ========
+ *  Find driver type for given connection.
+ *
+ *  Search the connection array for the given remote processor. If
+ *  found, return the requested notify driver type.
  */
-Int NotifySetup_attach(UInt16 remoteProcId, Ptr sharedAddr)
+NotifySetup_Driver NotifySetup_driverType(UInt16 remoteProcId)
+{
+    Int i;
+    NotifySetup_Driver driver = NotifySetup_Driver_SHAREDMEMORY;
+
+    /* look for remote processor in connection array */
+    for (i = 0; i < NotifySetup_module->connAry.length; i++) {
+        if (remoteProcId == NotifySetup_module->connAry.elem[i].procId) {
+            driver = NotifySetup_module->connAry.elem[i].driver;
+            break;
+        }
+    }
+
+    return(driver);
+}
+
+/*
+ *  ======== NotifySetup_plugHwi ========
+ */
+Void NotifySetup_plugHwi(UInt16 remoteProcId, Int cpuIntrNum,
+        NotifySetup_DriverIsr isr)
+{
+    UInt        key;
+    Hwi_Params  hwiParams;
+    UInt16      virtId;
+    Int         eventId;
+    UInt        combinedEventId;
+
+    /* disable global interrupts (TODO: should be a gated module) */
+    key = Hwi_disable();
+
+    /* map processor id to virtual id */
+    virtId = VIRTID(remoteProcId);
+
+    /* save driver isr in dispatch table */
+    NotifySetup_module->isrDispatchTable[virtId] = isr;
+
+    /* program the event dispatcher */
+    eventId = NotifySetup_module->interruptTable[virtId];
+    EventCombiner_dispatchPlug(eventId, NotifySetup_dispatchIsr, eventId, TRUE);
+
+    /* make sure the interrupt is plugged only once */
+    NotifySetup_module->numPlugged++;
+
+    if (NotifySetup_module->numPlugged == 1) {
+        combinedEventId = eventId / EVENT_GROUP_SIZE;
+
+        Hwi_Params_init(&hwiParams);
+        hwiParams.eventId = combinedEventId;
+        hwiParams.arg = combinedEventId;
+        hwiParams.enableInt = TRUE;
+
+        Hwi_create(cpuIntrNum,
+                &ti_sysbios_family_c64p_EventCombiner_dispatch,
+                &hwiParams, NULL);
+
+        Hwi_enableInterrupt(cpuIntrNum);
+    }
+
+    /* restore global interrupts */
+    Hwi_restore(key);
+}
+
+/*
+ *  ======== NotifySetup_unplugHwi ========
+ */
+Void NotifySetup_unplugHwi(UInt16 remoteProcId, Int cpuIntrNum)
+{
+    UInt        key;
+    Hwi_Handle  hwi;
+    UInt16      virtId;
+    Int         eventId;
+
+    /* disable global interrupts (TODO: should be a gated module) */
+    key = Hwi_disable();
+
+    /* unplug interrupt if last user */
+    NotifySetup_module->numPlugged--;
+
+    if (NotifySetup_module->numPlugged == 0) {
+        hwi= Hwi_getHandle(cpuIntrNum);
+        Hwi_delete(&hwi);
+    }
+
+    /* unprogram the event dispatcher */
+    virtId = VIRTID(remoteProcId);
+    eventId = NotifySetup_module->interruptTable[virtId];
+    EventCombiner_disableEvent(eventId);
+
+    /* restore global interrupts */
+    Hwi_restore(key);
+}
+
+/*
+ *  ======== NotifySetup_Shm_attach ========
+ */
+Int NotifySetup_Shm_attach(UInt16 remoteProcId, Ptr sharedAddr)
 {
     NotifyDriverShm_Params notifyShmParams;
     NotifyDriverShm_Handle shmDrvHandle;
@@ -80,7 +318,8 @@ Int NotifySetup_attach(UInt16 remoteProcId, Ptr sharedAddr)
         (MultiProc_self() == NotifySetup_eve2ProcId) ||
         (MultiProc_self() == NotifySetup_eve3ProcId) ||
         (MultiProc_self() == NotifySetup_eve4ProcId)) {
-        if (PROCID(remoteProcId) < 4) {
+
+        if (VIRTID(remoteProcId) < 4) {
             notifyShmParams.intVectorId = NotifySetup_eveIntVectId_INTC1;
         }
         else {
@@ -88,14 +327,18 @@ Int NotifySetup_attach(UInt16 remoteProcId, Ptr sharedAddr)
         }
     }
 
+    /* create the notify driver instance */
     shmDrvHandle = NotifyDriverShm_create(&notifyShmParams, &eb);
+
     if (shmDrvHandle == NULL) {
         return (Notify_E_FAIL);
     }
 
+    /* create the front-end notify instance */
     notifyHandle = ti_sdo_ipc_Notify_create(
             NotifyDriverShm_Handle_upCast(shmDrvHandle), remoteProcId, 0,
             NULL, &eb);
+
     if (notifyHandle == NULL) {
         NotifyDriverShm_delete(&shmDrvHandle);
         status = Notify_E_FAIL;
@@ -104,11 +347,10 @@ Int NotifySetup_attach(UInt16 remoteProcId, Ptr sharedAddr)
     return (status);
 }
 
-
 /*!
- *  ======== NotifySetup_sharedMemReq ========
+ *  ======== NotifySetup_Shm_sharedMemReq ========
  */
-SizeT NotifySetup_sharedMemReq(UInt16 remoteProcId, Ptr sharedAddr)
+SizeT NotifySetup_Shm_sharedMemReq(UInt16 remoteProcId, Ptr sharedAddr)
 {
     SizeT memReq;
     NotifyDriverShm_Params notifyShmParams;
@@ -121,10 +363,116 @@ SizeT NotifySetup_sharedMemReq(UInt16 remoteProcId, Ptr sharedAddr)
     return (memReq);
 }
 
+/*
+ *  ======== NotifySetup_Mbx_attach ========
+ */
+Int NotifySetup_Mbx_attach(UInt16 remoteProcId, Ptr sharedAddr)
+{
+    Int status = Notify_S_SUCCESS;
+    NotifyDriverMbx_Params params;
+    NotifyDriverMbx_Handle driver;
+    ti_sdo_ipc_Notify_Handle notify;
+    Error_Block eb;
+
+    Error_init(&eb);
+
+    NotifyDriverMbx_Params_init(&params);
+    params.remoteProcId = remoteProcId;
+
+    /* set the intVectorId if on the DSP */
+    if ((MultiProc_self() == NotifySetup_dsp1ProcId) ||
+        (MultiProc_self() == NotifySetup_dsp2ProcId)) {
+        params.intVectorId = NotifySetup_dspIntVectId;
+    }
+
+    /* set the intVectorId if on the EVE */
+    if ((MultiProc_self() == NotifySetup_eve1ProcId) ||
+        (MultiProc_self() == NotifySetup_eve2ProcId) ||
+        (MultiProc_self() == NotifySetup_eve3ProcId) ||
+        (MultiProc_self() == NotifySetup_eve4ProcId)) {
+
+        if (VIRTID(remoteProcId) < 4) {
+            params.intVectorId = NotifySetup_eveIntVectId_INTC1;
+        }
+        else {
+            params.intVectorId = NotifySetup_eveIntVectId_INTC0;
+        }
+    }
+
+    /* create the notify driver instance */
+    driver = NotifyDriverMbx_create(&params, &eb);
+
+    if (driver == NULL) {
+        return(Notify_E_FAIL);
+    }
+
+    /* create the front-end notify instance */
+    notify = ti_sdo_ipc_Notify_create(NotifyDriverMbx_Handle_upCast(driver),
+            remoteProcId, 0, NULL, &eb);
+
+    if (notify == NULL) {
+        NotifyDriverMbx_delete(&driver);
+        status = Notify_E_FAIL;
+    }
+
+    return(status);
+}
+
 /*!
- * ======== NotifySetup_numIntLines ========
+ *  ======== NotifySetup_Mbx_sharedMemReq ========
  */
-UInt16 NotifySetup_numIntLines(UInt16 remoteProcId)
+SizeT NotifySetup_Mbx_sharedMemReq(UInt16 remoteProcId, Ptr sharedAddr)
+{
+    SizeT memReq = 0;
+
+    return (memReq);
+}
+
+/*
+ *************************************************************************
+ *                       Internal functions
+ *************************************************************************
+ */
+
+/*
+ *  ======== NotifySetup_dispatchIsr ========
+ *  arg = eventId
+ */
+Void NotifySetup_dispatchIsr(UArg arg)
 {
-    return 1;
+    Int numProcessed;
+    UInt16 idx;
+    UInt16 srcVirtId;
+    UInt16 dstVirtId = VIRTID(MultiProc_self());
+    NotifySetup_DriverIsr driver;
+
+    do {
+        numProcessed = 0;
+
+        for (srcVirtId = 0; srcVirtId < NotifySetup_NUM_CORES; srcVirtId++) {
+
+            /* should not receive interrupts from myself */
+            if (srcVirtId == dstVirtId) {
+                continue;
+            }
+
+            /* check if processor would raise the given hardware eventId */
+            if (arg == NotifySetup_module->interruptTable[srcVirtId]) {
+
+                /* compute table index for given source and destination */
+                idx = (srcVirtId * NotifySetup_NUM_CORES) + dstVirtId;
+
+                /* check if submailbox has a message and irq is enabled */
+                if ((MBOX_MSG_COUNT(idx) != 0) && MBOX_IRQ_ENABLE(idx)) {
+
+                    /* invoke driver isr to deliver the event */
+                    driver = NotifySetup_module->isrDispatchTable[srcVirtId];
+                    (*driver)(idx);
+
+                    /* event has been delivered */
+                    numProcessed++;
+                }
+            }
+        }
+    } while (numProcessed != 0);
 }
index f63369db1381151c24b41fd4ca019f7a357c70e7..4b5091143826df8e9eac2c1ac98df81e80755c6f 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2013, Texas Instruments Incorporated
+ * Copyright (c) 2012-2014 Texas Instruments Incorporated - http://www.ti.com
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 /*
  *  ======== NotifySetup.xdc ========
- *
  */
+package ti.sdo.ipc.family.vayu;
 
+import xdc.runtime.Assert;
 import ti.sdo.utils.MultiProc;
 
 /*!
  *  ======== NotifySetup ========
  *  Notify setup proxy for Vayu
  *
- *  This module creates and registers all drivers necessary for inter-processor
- *  notification on Vayu.
+ *  This module creates and registers all drivers necessary for
+ *  inter-processor notification on Vayu.
  */
+@ModuleStartup
+@Template("./NotifySetup.xdt")
 
 module NotifySetup inherits ti.sdo.ipc.interfaces.INotifySetup
 {
-    /* Total number of cores on Vayu SoC */
-    const UInt8 NUM_CORES = 11;
+    /*
+     *  ======== DriverIsr ========
+     *  Notify driver isr function type definition
+     *  param1 = mailbox table index
+     */
+    typedef Void (*DriverIsr)(UInt16);
+
+    /*!
+     *  ======== A_internal ========
+     *  Internal implementation error.
+     */
+    config Assert.Id A_internal = {
+        msg: "A_internal: internal implementation error"
+    };
 
     /*!
      *  Interrupt vector id for Vayu/DSP.
@@ -60,16 +76,133 @@ module NotifySetup inherits ti.sdo.ipc.interfaces.INotifySetup
     config UInt eveIntVectId_INTC0 = -1;
     config UInt eveIntVectId_INTC1 = -1;
 
-    config UInt32 procIdTable[NUM_CORES];
+    /*!
+     *  Available notify drivers.
+     */
+    enum Driver {
+        Driver_SHAREDMEMORY = 0x01,     /*! shared memory */
+        Driver_MAILBOX = 0x02           /*! hardware mailbox */
+    };
+
+    /*!
+     *  Notify driver connection specification.
+     */
+    struct Connection {
+        Driver driver;                  /*! notify driver */
+        String procName;                /*! remote processor name */
+    };
+
+    /*!
+     *  Specify notify driver for given processor connections.
+     */
+    metaonly config Connection connections[length];
+
+    /*!
+     *  ======== plugHwi ========
+     *  Register an isr for the given interrupt and event.
+     *
+     *  The given interrupt number must be the same for all calls
+     *  because all IPC events should be taken by the same interrupt.
+     */
+    Void plugHwi(UInt16 remoteProcId, Int cpuIntrNum, DriverIsr isr);
+
+    /*!
+     *  ======== unplugHwi ========
+     *  Unregister the isr for the given interrupt.
+     */
+    Void unplugHwi(UInt16 remoteProcId, Int cpuIntrNum);
 
 internal:
+    /* total number of cores on Vayu SoC */
+    const UInt8 NUM_CORES = 11;
+
+    /* number of cores in eve subsystem */
+    const UInt8 NUM_EVES = 4;
+
+    /* number of internal eve mailboxes */
+    const UInt8 NUM_EVE_MBX = 12;
+
+    /* number of system mailboxes (used by IPC) */
+    const UInt8 NUM_SYS_MBX = 4;
+
+    /*  Mailbox table for storing encoded base address, mailbox user ID,
+     *  and sub-mailbox index.
+     */
+    config UInt32 mailboxTable[NUM_CORES * NUM_CORES];
+
+    /* base address table for the mailbox subsystem */
+    config UInt32 mailboxBaseAddr[NUM_EVE_MBX + NUM_SYS_MBX];
+
+    /* map procId to discrete processor/core */
+    config UInt eve1ProcId = MultiProc.INVALIDID;
+    config UInt eve2ProcId = MultiProc.INVALIDID;
+    config UInt eve3ProcId = MultiProc.INVALIDID;
+    config UInt eve4ProcId = MultiProc.INVALIDID;
+    config UInt dsp1ProcId = MultiProc.INVALIDID;
+    config UInt dsp2ProcId = MultiProc.INVALIDID;
+    config UInt ipu1_0ProcId = MultiProc.INVALIDID;
+    config UInt ipu1_1ProcId = MultiProc.INVALIDID;
+    config UInt ipu2_0ProcId = MultiProc.INVALIDID;
+    config UInt ipu2_1ProcId = MultiProc.INVALIDID;
+    config UInt hostProcId = MultiProc.INVALIDID;
+
+    /* map MultiProc ID to virtual ID, virtId = procIdTable[procId] */
+    config UInt32 procIdTable[NUM_CORES];
+
+    /*
+     *  ======== driverType ========
+     */
+    Driver driverType(UInt16 remoteProcId);
+
+    /*
+     *  ======== Shm_attach ========
+     */
+    Int Shm_attach(UInt16 remoteProcId, Ptr sharedAddr);
+
+    /*
+     *  ======== Shm_sharedMemReq ========
+     */
+    SizeT Shm_sharedMemReq(UInt16 remoteProcId, Ptr sharedAddr);
+
+    /*
+     *  ======== Mbx_attach ========
+     */
+    Int Mbx_attach(UInt16 remoteProcId, Ptr sharedAddr);
+
+    /*
+     *  ======== Mbx_sharedMemReq ========
+     */
+    SizeT Mbx_sharedMemReq(UInt16 remoteProcId, Ptr sharedAddr);
+
+    /*
+     *  ======== dispatchIsr ========
+     *  Dispatch interrupt to notify driver instance.
+     */
+    Void dispatchIsr(UArg arg);
+
+    /*
+     *  ======== DrvBind ========
+     */
+    struct DrvBind {
+        Driver driver;                  /*! notify driver */
+        UInt16 procId;                  /*! remote processor ID */
+    };
+
+    /*
+     *  ======== Module_State ========
+     */
+    struct Module_State {
+        UInt16      numPlugged;         /*! interrupt plug counter */
+        DrvBind     connAry[length];
+
+        /*  Interrupt event IDs used to communicate with this processor.
+         *  This table is indexed by virtual processor ID.
+         */
+        UInt16 interruptTable[NUM_CORES];
 
-    /* note: IPU intentionally omitted, nothing to setup */
-    config UInt eve1ProcId      = MultiProc.INVALIDID;
-    config UInt eve2ProcId      = MultiProc.INVALIDID;
-    config UInt eve3ProcId      = MultiProc.INVALIDID;
-    config UInt eve4ProcId      = MultiProc.INVALIDID;
-    config UInt dsp1ProcId      = MultiProc.INVALIDID;
-    config UInt dsp2ProcId      = MultiProc.INVALIDID;
-    config UInt hostProcId      = MultiProc.INVALIDID;
+        /*  Notify driver isr dispatch table. This table is indexed
+         *  by virtual processor ID.
+         */
+        DriverIsr isrDispatchTable[NUM_CORES];
+    };
 }
diff --git a/packages/ti/sdo/ipc/family/vayu/NotifySetup.xdt b/packages/ti/sdo/ipc/family/vayu/NotifySetup.xdt
new file mode 100644 (file)
index 0000000..880d213
--- /dev/null
@@ -0,0 +1,97 @@
+%%{
+/*
+ * Copyright (c) 2014 Texas Instruments Incorporated - http://www.ti.com
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+var pkg = this.$package.$name.replace(/\./g, "_");
+
+%%}
+#include <ti/ipc/Notify.h>
+
+/*
+ *  ======== `pkg`_NotifySetup_attach ========
+ */
+Int `pkg`_NotifySetup_attach(UInt16 remoteProcId, Ptr sharedAddr)
+{
+    Int status = Notify_E_FAIL;
+    `pkg`_NotifySetup_Driver driver;
+
+    driver = `pkg`_NotifySetup_driverType(remoteProcId);
+
+    switch (driver) {
+% if (this.$private.driverMask & this.Driver_SHAREDMEMORY) {
+        case `pkg`_NotifySetup_Driver_SHAREDMEMORY:
+            status = `pkg`_NotifySetup_Shm_attach(remoteProcId, sharedAddr);
+            break;
+% }
+% if (this.$private.driverMask & this.Driver_MAILBOX) {
+        case `pkg`_NotifySetup_Driver_MAILBOX:
+            status = `pkg`_NotifySetup_Mbx_attach(remoteProcId, sharedAddr);
+            break;
+% }
+        default:
+            xdc_runtime_Assert_isTrue(FALSE, `pkg`_NotifySetup_A_internal);
+            break;
+    }
+
+    return (status);
+}
+
+/*!
+ *  ======== `pkg`_NotifySetup_sharedMemReq ========
+ */
+SizeT `pkg`_NotifySetup_sharedMemReq(UInt16 remoteProcId, Ptr sharedAddr)
+{
+    `pkg`_NotifySetup_Driver driver;
+    SizeT memReq;
+
+    driver = `pkg`_NotifySetup_driverType(remoteProcId);
+
+    switch (driver) {
+% if (this.$private.driverMask & this.Driver_SHAREDMEMORY) {
+        case `pkg`_NotifySetup_Driver_SHAREDMEMORY:
+            memReq = `pkg`_NotifySetup_Shm_sharedMemReq(remoteProcId,
+                    sharedAddr);
+            break;
+% }
+% if (this.$private.driverMask & this.Driver_MAILBOX) {
+        case `pkg`_NotifySetup_Driver_MAILBOX:
+            memReq = `pkg`_NotifySetup_Mbx_sharedMemReq(remoteProcId,
+                    sharedAddr);
+            break;
+% }
+        default:
+            xdc_runtime_Assert_isTrue(FALSE, `pkg`_NotifySetup_A_internal);
+            break;
+    }
+
+    return (memReq);
+}
index 3a2d36db24faf7caed06d3e4c346c972b994a837..a7dd9f8dba0fc99ea7b0399f5441d4f1f47d57ff 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2013, Texas Instruments Incorporated
+ * Copyright (c) 2012-2014 Texas Instruments Incorporated - http://www.ti.com
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 /*
  *  ======== NotifySetup.xs ========
  *
  */
-
-var NotifyDriverShm = null;
-var Notify          = null;
-var MultiProc       = null;
-var NotifySetup     = null;
+var MultiProc = null;
 
 /*
  *  ======== module$use ========
  */
 function module$use()
 {
-    NotifyDriverShm = xdc.useModule('ti.sdo.ipc.notifyDrivers.NotifyDriverShm');
-    Notify          = xdc.useModule('ti.sdo.ipc.Notify');
-    MultiProc       = xdc.useModule('ti.sdo.utils.MultiProc');
-    NotifySetup     = this;
+    var TableInit = xdc.useModule("ti.sdo.ipc.family.vayu.TableInit");
+
+    /* load modules needed in meta domain and in target domain */
+    MultiProc = xdc.useModule('ti.sdo.utils.MultiProc');
+
+    xdc.useModule('xdc.runtime.Assert');
+
+    /* initialize procIdTable */
+    TableInit.initProcId(this);
+
+    /* initialize mailboxTable */
+    TableInit.generateTable(this);
 
-    var loopIdx;
+    /* Initialize mailbox base address table */
+    this.mailboxBaseAddr[0]  = 0x4208B000;  /* EVE1 Internal Mailbox 0 */
+    this.mailboxBaseAddr[1]  = 0x4208C000;  /* EVE1 Internal Mailbox 1 */
+    this.mailboxBaseAddr[2]  = 0x4208D000;  /* EVE1 Internal Mailbox 2 */
+    this.mailboxBaseAddr[3]  = 0x4218B000;  /* EVE2 Internal Mailbox 0 */
+    this.mailboxBaseAddr[4]  = 0x4218C000;  /* EVE2 Internal Mailbox 1 */
+    this.mailboxBaseAddr[5]  = 0x4218D000;  /* EVE2 Internal Mailbox 2 */
+    this.mailboxBaseAddr[6]  = 0x4228B000;  /* EVE3 Internal Mailbox 0 */
+    this.mailboxBaseAddr[7]  = 0x4228C000;  /* EVE3 Internal Mailbox 1 */
+    this.mailboxBaseAddr[8]  = 0x4228D000;  /* EVE3 Internal Mailbox 2 */
+    this.mailboxBaseAddr[9]  = 0x4238B000;  /* EVE4 Internal Mailbox 0 */
+    this.mailboxBaseAddr[10] = 0x4238C000;  /* EVE4 Internal Mailbox 1 */
+    this.mailboxBaseAddr[11] = 0x4238D000;  /* EVE4 Internal Mailbox 2 */
+    this.mailboxBaseAddr[12] = 0x48840000;  /* System Mailbox 5 */
+    this.mailboxBaseAddr[13] = 0x48842000;  /* System Mailbox 6 */
+    this.mailboxBaseAddr[14] = 0x48844000;  /* System Mailbox 7 */
+    this.mailboxBaseAddr[15] = 0x48846000;  /* System Mailbox 8 */
 
-    for (loopIdx = 0; loopIdx < this.NUM_CORES; loopIdx++) {
-        this.procIdTable[loopIdx] = -1;
+    /* determine which notify drivers to include */
+    this.$private.driverMask = 0;
+
+    /* for unspecfied connections, the default is shared memory */
+    if (this.connections.length < (MultiProc.numProcessors - 1)) {
+        this.$private.driverMask |= this.Driver_SHAREDMEMORY;
     }
 
-    /* note: IPU intentionally omitted, nothing to setup */
-    this.eve1ProcId     = MultiProc.getIdMeta("EVE1");
-    this.eve2ProcId     = MultiProc.getIdMeta("EVE2");
-    this.eve3ProcId     = MultiProc.getIdMeta("EVE3");
-    this.eve4ProcId     = MultiProc.getIdMeta("EVE4");
-    this.dsp1ProcId     = MultiProc.getIdMeta("DSP1");
-    this.dsp2ProcId     = MultiProc.getIdMeta("DSP2");
-    this.hostProcId     = MultiProc.getIdMeta("HOST");
-
-    if (this.eve1ProcId != MultiProc.INVALIDID) {
-        this.procIdTable[this.eve1ProcId] = 0;
+    /* remember which notify drivers have been specified */
+    for (var i = 0; i < this.connections.length; i++) {
+        if (this.connections[i].driver == this.Driver_SHAREDMEMORY) {
+            this.$private.driverMask |= this.Driver_SHAREDMEMORY;
+        }
+        if (this.connections[i].driver == this.Driver_MAILBOX) {
+            this.$private.driverMask |= this.Driver_MAILBOX;
+        }
     }
-    if (this.eve2ProcId != MultiProc.INVALIDID) {
-        this.procIdTable[this.eve2ProcId] = 1;
+
+    /* load notify drivers into configuration model */
+    if (this.$private.driverMask & this.Driver_SHAREDMEMORY) {
+        xdc.useModule('ti.sdo.ipc.notifyDrivers.NotifyDriverShm');
     }
-    if (this.eve3ProcId != MultiProc.INVALIDID) {
-        this.procIdTable[this.eve3ProcId] = 2;
+    if (this.$private.driverMask & this.Driver_MAILBOX) {
+        xdc.useModule('ti.sdo.ipc.family.vayu.NotifyDriverMbx');
     }
-    if (this.eve4ProcId != MultiProc.INVALIDID) {
-        this.procIdTable[this.eve4ProcId] = 3;
+}
+
+/*
+ *  ======== module$static$init ========
+ *  Initialize the target state object.
+ */
+function module$static$init(state, mod)
+{
+    var procId;
+
+    state.numPlugged = 0;
+
+    /* Initialize the state connAry from the config params. Translate
+     * processor names into IDs for better runtime performance.
+     */
+    state.connAry.length = mod.connections.length;
+
+    for (var i = 0; i < mod.connections.length; i++) {
+        procId = MultiProc.getIdMeta(mod.connections[i].procName);
+        state.connAry[i].procId = procId;
+        state.connAry[i].driver = mod.connections[i].driver;
     }
-    if (this.dsp1ProcId != MultiProc.INVALIDID) {
-        this.procIdTable[this.dsp1ProcId] = 4;
+
+    /* finish initializing the interrupt table */
+    if (Program.build.target.isa == "v7M4") {
+//      TODO
+//      if (Core.id == 0) {
+//          Hwi.construct(state.hwi, 53, NotifyDriverMbx.isr);
+//      }
+//      else {
+//          Hwi.construct(state.hwi, 54, NotifyDriverMbx.isr);
+//      }
+        /* interrupt event IDs used by this processor */
+        for (var i = 0; i < state.interruptTable.length; i++) {
+            state.interruptTable[i] = 0xFFFF; /* TODO */
+        }
     }
-    if (this.dsp2ProcId != MultiProc.INVALIDID) {
-        this.procIdTable[this.dsp2ProcId] = 5;
+    else if (Program.build.target.isa == "arp32") {
+        /* interrupt event IDs used by this processor */
+        for (var i = 0; i < state.interruptTable.length; i++) {
+            state.interruptTable[i] = 0xFFFF; /* TODO */
+        }
     }
-    if (this.hostProcId != MultiProc.INVALIDID) {
-        this.procIdTable[this.hostProcId] = 8;
+    else if (Program.build.target.isa == "66") {
+        /* interrupt event IDs used by this processor */
+        state.interruptTable[0] = 55; /* EVE1 -> DSP1 or DSP2 */
+        state.interruptTable[1] = 56; /* EVE2 -> DSP1 or DSP2 */
+        state.interruptTable[2] = 58; /* EVE3 -> DSP1 or DSP2 */
+        state.interruptTable[3] = 59; /* EVE4 -> DSP1 or DSP2 */
+        state.interruptTable[4] = 60; /* DSP1 -> DSP2 */
+        state.interruptTable[5] = 60; /* DSP2 -> DSP1 */
+        state.interruptTable[8] = 57; /* HOST -> DSP1 or DSP2 */
+
+        /* these are not known at config time, set at runtime */
+        state.interruptTable[6] = 0; /* IPU1 -> DSP1 or DSP2 */
+        state.interruptTable[7] = 0; /* IPU2 -> DSP1 or DSP2 */
+        state.interruptTable[9] = 0; /* IPU1-1 -> DSP1 or DSP2 */
+        state.interruptTable[10] = 0; /* IPU2-1 -> DSP1 or DSP2 */
+    }
+    else if (Program.build.target.isa == "v7A15") {
+        /* interrupt event IDs used by this processor */
+        for (var i = 0; i < state.interruptTable.length; i++) {
+            state.interruptTable[i] = 0xFFFF; /* TODO */
+        }
+
+        /* TODO */
+        // Hwi.construct(state.hwi, 77, NotifyDriverMbx.isr);
+    }
+    else {
+        throw("Invalid target: " + Program.build.target.$name);
+    }
+
+    /* initialize the driver table */
+    for (var i = 0; i < state.isrDispatchTable.length; i++) {
+        state.isrDispatchTable[i] = null;
     }
 }
index 17f8b74a9e55ff4daf2a68b3400bdbfa485f80f6..2021fcf4aaac2882e8c30b8600c1582d04143475 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2013, Texas Instruments Incorporated
+ * Copyright (c) 2012-2014 Texas Instruments Incorporated - http://www.ti.com
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -63,73 +63,84 @@ var hostVirtId    = 8;
 var ipu1_1VirtId  = 9;
 var ipu2_1VirtId  = 10;
 
+
 /*
- * Function to initialize coreIds.
+ *  ======== initProcId ========
+ *  Assign MultiProc ids and virtual processor ids.
  */
-function initProcId(InterruptCore)
+function initProcId(mod)
 {
-    var MultiProc        = xdc.useModule("ti.sdo.utils.MultiProc");
+    var MultiProc = xdc.useModule("ti.sdo.utils.MultiProc");
 
-    for (var loopIdx=0; loopIdx<InterruptCore.procIdTable.length; loopIdx++) {
-        InterruptCore.procIdTable[loopIdx] = -1;
+    for (var i = 0; i < mod.procIdTable.length; i++) {
+        mod.procIdTable[i] = -1;
     }
 
-    InterruptCore.eve1ProcId     = MultiProc.getIdMeta("EVE1");
-    InterruptCore.eve2ProcId     = MultiProc.getIdMeta("EVE2");
-    InterruptCore.eve3ProcId     = MultiProc.getIdMeta("EVE3");
-    InterruptCore.eve4ProcId     = MultiProc.getIdMeta("EVE4");
-    InterruptCore.dsp1ProcId     = MultiProc.getIdMeta("DSP1");
-    InterruptCore.dsp2ProcId     = MultiProc.getIdMeta("DSP2");
-    InterruptCore.ipu1_0ProcId   = MultiProc.getIdMeta("IPU1");
-    InterruptCore.ipu2_0ProcId   = MultiProc.getIdMeta("IPU2");
-    InterruptCore.hostProcId     = MultiProc.getIdMeta("HOST");
-    InterruptCore.ipu1_1ProcId   = MultiProc.getIdMeta("IPU1-1");
-    InterruptCore.ipu2_1ProcId   = MultiProc.getIdMeta("IPU2-1");
-
-    if (InterruptCore.eve1ProcId != MultiProc.INVALIDID) {
-        InterruptCore.procIdTable[InterruptCore.eve1ProcId] = eve1VirtId;
+    mod.eve1ProcId   = MultiProc.getIdMeta("EVE1");
+    mod.eve2ProcId   = MultiProc.getIdMeta("EVE2");
+    mod.eve3ProcId   = MultiProc.getIdMeta("EVE3");
+    mod.eve4ProcId   = MultiProc.getIdMeta("EVE4");
+    mod.dsp1ProcId   = MultiProc.getIdMeta("DSP1");
+    mod.dsp2ProcId   = MultiProc.getIdMeta("DSP2");
+    mod.ipu1_0ProcId = MultiProc.getIdMeta("IPU1");  /* assume smp */
+    mod.ipu1_1ProcId = MultiProc.getIdMeta("IPU1-1");
+    mod.ipu2_0ProcId = MultiProc.getIdMeta("IPU2");  /* assume smp */
+    mod.ipu2_1ProcId = MultiProc.getIdMeta("IPU2-1");
+    mod.hostProcId   = MultiProc.getIdMeta("HOST");
+
+    if (mod.eve1ProcId != MultiProc.INVALIDID) {
+        mod.procIdTable[mod.eve1ProcId] = eve1VirtId;
     }
-    if (InterruptCore.eve2ProcId != MultiProc.INVALIDID) {
-        InterruptCore.procIdTable[InterruptCore.eve2ProcId] = eve2VirtId;
+    if (mod.eve2ProcId != MultiProc.INVALIDID) {
+        mod.procIdTable[mod.eve2ProcId] = eve2VirtId;
     }
-    if (InterruptCore.eve3ProcId != MultiProc.INVALIDID) {
-        InterruptCore.procIdTable[InterruptCore.eve3ProcId] = eve3VirtId;
+    if (mod.eve3ProcId != MultiProc.INVALIDID) {
+        mod.procIdTable[mod.eve3ProcId] = eve3VirtId;
     }
-    if (InterruptCore.eve4ProcId != MultiProc.INVALIDID) {
-        InterruptCore.procIdTable[InterruptCore.eve4ProcId] = eve4VirtId;
+    if (mod.eve4ProcId != MultiProc.INVALIDID) {
+        mod.procIdTable[mod.eve4ProcId] = eve4VirtId;
     }
-    if (InterruptCore.dsp1ProcId != MultiProc.INVALIDID) {
-        InterruptCore.procIdTable[InterruptCore.dsp1ProcId] = dsp1VirtId;
+    if (mod.dsp1ProcId != MultiProc.INVALIDID) {
+        mod.procIdTable[mod.dsp1ProcId] = dsp1VirtId;
     }
-    if (InterruptCore.dsp2ProcId != MultiProc.INVALIDID) {
-        InterruptCore.procIdTable[InterruptCore.dsp2ProcId] = dsp2VirtId;
+    if (mod.dsp2ProcId != MultiProc.INVALIDID) {
+        mod.procIdTable[mod.dsp2ProcId] = dsp2VirtId;
     }
-    if (InterruptCore.ipu1_0ProcId != MultiProc.INVALIDID) {
-        InterruptCore.procIdTable[InterruptCore.ipu1_0ProcId] = ipu1_0VirtId;
+
+    if (mod.ipu1_0ProcId != MultiProc.INVALIDID) {
+        mod.procIdTable[mod.ipu1_0ProcId] = ipu1_0VirtId;
     }
     else {
-        InterruptCore.ipu1_0ProcId = MultiProc.getIdMeta("IPU1-0");
-        if (InterruptCore.ipu1_0ProcId != MultiProc.INVALIDID) {
-            InterruptCore.procIdTable[InterruptCore.ipu1_0ProcId] = ipu1_0VirtId;
+        /* IPU1 not smp */
+        mod.ipu1_0ProcId = MultiProc.getIdMeta("IPU1-0");
+
+        if (mod.ipu1_0ProcId != MultiProc.INVALIDID) {
+            mod.procIdTable[mod.ipu1_0ProcId] = ipu1_0VirtId;
         }
     }
-    if (InterruptCore.ipu2_0ProcId != MultiProc.INVALIDID) {
-        InterruptCore.procIdTable[InterruptCore.ipu2_0ProcId] = ipu2_0VirtId;
+
+    if (mod.ipu1_1ProcId != MultiProc.INVALIDID) {
+        mod.procIdTable[mod.ipu1_1ProcId] = ipu1_1VirtId;
+    }
+
+    if (mod.ipu2_0ProcId != MultiProc.INVALIDID) {
+        mod.procIdTable[mod.ipu2_0ProcId] = ipu2_0VirtId;
     }
     else {
-        InterruptCore.ipu2_0ProcId = MultiProc.getIdMeta("IPU2-0");
-        if (InterruptCore.ipu2_0ProcId != MultiProc.INVALIDID) {
-            InterruptCore.procIdTable[InterruptCore.ipu2_0ProcId] = ipu2_0VirtId;
+        /* IPU2 not smp */
+        mod.ipu2_0ProcId = MultiProc.getIdMeta("IPU2-0");
+
+        if (mod.ipu2_0ProcId != MultiProc.INVALIDID) {
+            mod.procIdTable[mod.ipu2_0ProcId] = ipu2_0VirtId;
         }
     }
-    if (InterruptCore.hostProcId != MultiProc.INVALIDID) {
-        InterruptCore.procIdTable[InterruptCore.hostProcId] = hostVirtId;
-    }
-    if (InterruptCore.ipu1_1ProcId != MultiProc.INVALIDID) {
-        InterruptCore.procIdTable[InterruptCore.ipu1_1ProcId] = ipu1_1VirtId;
+
+    if (mod.ipu2_1ProcId != MultiProc.INVALIDID) {
+        mod.procIdTable[mod.ipu2_1ProcId] = ipu2_1VirtId;
     }
-    if (InterruptCore.ipu2_1ProcId != MultiProc.INVALIDID) {
-        InterruptCore.procIdTable[InterruptCore.ipu2_1ProcId] = ipu2_1VirtId;
+
+    if (mod.hostProcId != MultiProc.INVALIDID) {
+        mod.procIdTable[mod.hostProcId] = hostVirtId;
     }
 }
 
index 728f176b123ea347ac4c486c8d10a2a883bf55fc..7754466e9b71508e9efe81209f93d511e7b8ff3d 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2013, Texas Instruments Incorporated
+ * Copyright (c) 2012-2014 Texas Instruments Incorporated - http://www.ti.com
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -38,7 +38,8 @@ var Pkg = xdc.useModule('xdc.bld.PackageContents');
 var IpcBuild = xdc.loadCapsule("ti/sdo/ipc/Build.xs");
 
 var objList_common = [
-    "NotifySetup.c"
+    "NotifySetup.c",
+    "NotifyDriverMbx.c"
 ];
 
 var objList_66 = [
index 6c6adbb7750577aa930628e17e32a73e6b047c85..6e9ef788a6c969428b9cb1de96c2f5049b2dd030 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2013, Texas Instruments Incorporated
+ * Copyright (c) 2012-2014 Texas Instruments Incorporated - http://www.ti.com
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -38,9 +38,10 @@ requires ti.sdo.ipc;
 /*!
  *  ======== ti.sdo.ipc.family.vayu ========
  */
-package ti.sdo.ipc.family.vayu [1,0,0,0] {
+package ti.sdo.ipc.family.vayu [1,0,1] {
     module    TableInit;
     module    NotifySetup;
+    module    NotifyDriverMbx;
     module    InterruptArp32;
     module    InterruptDsp;
     module    InterruptIpu;