a3d90b3176280a0b38aaffe48d89e38f6183c0a0
[ipc/ipcdev.git] / packages / ti / sdo / ipc / GateMP.c
1 /*
2  * Copyright (c) 2012-2015 Texas Instruments Incorporated - http://www.ti.com
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * *  Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  * *  Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * *  Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32 /*
33  *  ======== GateMP.c ========
34  */
36 #include <xdc/std.h>
37 #include <string.h>
38 #include <xdc/runtime/Error.h>
39 #include <xdc/runtime/Assert.h>
40 #include <xdc/runtime/System.h>
41 #include <xdc/runtime/IGateProvider.h>
42 #include <xdc/runtime/IHeap.h>
43 #include <xdc/runtime/Memory.h>
44 #include <xdc/runtime/Log.h>
46 #include <ti/sdo/ipc/interfaces/IGateMPSupport.h>
48 #include <ti/sysbios/gates/GateMutexPri.h>
49 #include <ti/sysbios/gates/GateSwi.h>
50 #include <ti/sysbios/gates/GateAll.h>
51 #include <ti/sysbios/hal/Cache.h>
52 #include <ti/sysbios/hal/Hwi.h>
54 #include <ti/sdo/ipc/_Ipc.h>
55 #include <ti/sdo/utils/_MultiProc.h>
56 #include <ti/sdo/ipc/_GateMP.h>
57 #include <ti/sdo/utils/_NameServer.h>
58 #include <ti/sdo/ipc/_SharedRegion.h>
60 #include "package/internal/GateMP.xdc.h"
62 /* Helper macros */
63 #define GETREMOTE(mask) ((ti_sdo_ipc_GateMP_RemoteProtect)((mask) >> 8))
64 #define GETLOCAL(mask)  ((ti_sdo_ipc_GateMP_LocalProtect)((mask) & 0xFF))
65 #define SETMASK(remoteProtect, localProtect) \
66                         ((Bits32)((remoteProtect) << 8 | (localProtect)))
68 /* Values used to populate the resource 'inUse' arrays */
69 #define UNUSED          ((UInt8)0)
70 #define USED            ((UInt8)1)
71 #define RESERVED        ((UInt8)-1)
73 #ifdef __ti__
74     #pragma FUNC_EXT_CALLED(GateMP_Params_init);
75     #pragma FUNC_EXT_CALLED(GateMP_create);
76     #pragma FUNC_EXT_CALLED(GateMP_close);
77     #pragma FUNC_EXT_CALLED(GateMP_delete);
78     #pragma FUNC_EXT_CALLED(GateMP_enter);
79     #pragma FUNC_EXT_CALLED(GateMP_getDefaultRemote);
80     #pragma FUNC_EXT_CALLED(GateMP_getLocalProtect);
81     #pragma FUNC_EXT_CALLED(GateMP_getRemoteProtect);
82     #pragma FUNC_EXT_CALLED(GateMP_leave);
83     #pragma FUNC_EXT_CALLED(GateMP_open);
84     #pragma FUNC_EXT_CALLED(GateMP_openByAddr);
85     #pragma FUNC_EXT_CALLED(GateMP_sharedMemReq);
86 #endif
88 /*
89  *  ======== GateMP_getSharedParams ========
90  */
91 static Void GateMP_getSharedParams(GateMP_Params *sparams,
92         const ti_sdo_ipc_GateMP_Params *params)
93 {
94     sparams->name             = params->name;
95     sparams->regionId         = params->regionId;
96     sparams->sharedAddr       = params->sharedAddr;
97     sparams->localProtect     = (GateMP_LocalProtect)
98         params->localProtect;
99     sparams->remoteProtect    = (GateMP_RemoteProtect)
100         params->remoteProtect;
103 /*
104  *  ======== GateMP_getRTSCParams ========
105  */
106 static Void GateMP_getRTSCParams(ti_sdo_ipc_GateMP_Params *params,
107         const GateMP_Params *sparams)
110     ti_sdo_ipc_GateMP_Params_init(params);
112     params->name             = sparams->name;
113     params->regionId         = sparams->regionId;
114     params->sharedAddr       = sparams->sharedAddr;
115     params->localProtect     = (ti_sdo_ipc_GateMP_LocalProtect)
116         sparams->localProtect;
117     params->remoteProtect    = (ti_sdo_ipc_GateMP_RemoteProtect)
118         sparams->remoteProtect;
121 /*
122  *************************************************************************
123  *                       Common Header Functions
124  *************************************************************************
125  */
127 /*
128  *  ======== GateMP_Params_init ========
129  */
130 Void GateMP_Params_init(GateMP_Params *sparams)
132     ti_sdo_ipc_GateMP_Params params;
134     ti_sdo_ipc_GateMP_Params_init(&params);
135     GateMP_getSharedParams(sparams, &params);
138 /*
139  *  ======== GateMP_create ========
140  */
141 GateMP_Handle GateMP_create(const GateMP_Params *sparams)
143     ti_sdo_ipc_GateMP_Params params;
144     ti_sdo_ipc_GateMP_Object *obj;
145     Error_Block eb;
147     GateMP_getRTSCParams(&params, (Ptr)sparams);
149     Error_init(&eb);
151     /* call the module create */
152     obj = ti_sdo_ipc_GateMP_create(&params, &eb);
154     return ((GateMP_Handle)obj);
157 /*
158  *  ======== GateMP_close ========
159  */
160 Int GateMP_close(GateMP_Handle *handlePtr)
162     ti_sdo_ipc_GateMP_Object *obj = (ti_sdo_ipc_GateMP_Object *)*handlePtr;
163     UInt key;
164     Int count;
166     /*
167      *  Cannot call with the numOpens equal to zero.  This is either
168      *  a created handle or been closed already.
169      */
170     Assert_isTrue((obj->numOpens != 0), ti_sdo_ipc_GateMP_A_invalidClose);
172     key = Hwi_disable();
173     count = --obj->numOpens;
174     Hwi_restore(key);
176     /*
177      *  if the count is zero and the gate is opened, then this
178      *  object was created in the open (i.e. the create happened
179      *  on a remote processor.
180      */
181     if ((count == 0) && (obj->objType == ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC)) {
182         GateMP_delete(handlePtr);
183     }
185     *handlePtr = NULL;
187     return (GateMP_S_SUCCESS);
190 /*
191  *  ======== GateMP_delete ========
192  */
193 Int GateMP_delete(GateMP_Handle *handlePtr)
195     ti_sdo_ipc_GateMP_delete((ti_sdo_ipc_GateMP_Handle *)handlePtr);
197     return (GateMP_S_SUCCESS);
200 /*
201  *  ======== GateMP_enter ========
202  */
203 IArg GateMP_enter(GateMP_Handle handle)
205     IArg key;
206     ti_sdo_ipc_GateMP_Object *obj = (ti_sdo_ipc_GateMP_Object *)handle;
208     Assert_isTrue(obj != NULL, ti_sdo_ipc_Ipc_A_nullArgument);
210     key = IGateProvider_enter(obj->gateHandle);
212     Log_write3(ti_sdo_ipc_GateMP_LM_enter,(UArg)obj->remoteProtect,
213             (UArg)obj->resourceId, key);
215     return (key);
218 /*
219  *  ======== GateMP_leave ========
220  */
221 Void GateMP_leave(GateMP_Handle handle, IArg key)
223     ti_sdo_ipc_GateMP_Object *obj = (ti_sdo_ipc_GateMP_Object *)handle;
225     Assert_isTrue(obj != NULL, ti_sdo_ipc_Ipc_A_nullArgument);
227     IGateProvider_leave(obj->gateHandle, key);
229     Log_write3(ti_sdo_ipc_GateMP_LM_leave, (UArg)obj->remoteProtect,
230         (UArg)obj->resourceId, key);
233 /*
234  *  ======== GateMP_open ========
235  */
236 Int GateMP_open(String name, GateMP_Handle *handlePtr)
238     SharedRegion_SRPtr sharedShmBase;
239     Int status;
240     ti_sdo_ipc_GateMP_Object *obj;
241     ti_sdo_ipc_GateMP_Params params;
242     Error_Block eb;
243     UInt key;
244     UInt32 len;
245     UInt32 mask;
246     UInt32 resourceId;
247     Ptr sharedAddr;
248     UInt32 nsValue[4];
250     Error_init(&eb);
252     /* Assert that a pointer has been supplied */
253     Assert_isTrue(handlePtr != NULL, ti_sdo_ipc_Ipc_A_nullArgument);
255     len = sizeof(nsValue);
257     /*
258      *  Get the Attrs out of the NameServer instance.
259      *  Search all processors.
260      */
261     status = NameServer_get((NameServer_Handle)GateMP_module->nameServer, name,
262             &nsValue, &len, MultiProc_getClusterProcList());
264     if (status < 0) {
265         *handlePtr = NULL;
266         return (GateMP_E_NOTFOUND);
267     }
269     /*
270      * The least significant bit of nsValue[1] == 0 means its a
271      * local GateMP, otherwise its a remote GateMP.
272      */
273     if (((nsValue[1] & 0x1) == 0) &&
274         ((nsValue[1] >> 16) != MultiProc_self())) {
275         /* Trying to open a local GateMP remotely */
276         *handlePtr = NULL;
277         return (GateMP_E_FAIL);
278     }
280     if ((nsValue[1] & 0x1) == 0) {
281         /*
282          * Opening a local GateMP locally. The GateMP is created
283          * from a local heap so don't do SharedRegion Ptr conversion.
284          */
285         sharedAddr = (Ptr)nsValue[0];
286         status = GateMP_openByAddr(sharedAddr, handlePtr);
287     }
288     else if (GateMP_module->hostSupport == FALSE) {
289         /* Opening a remote GateMP. Need to do SharedRegion Ptr conversion. */
290         sharedShmBase = (SharedRegion_SRPtr)nsValue[0];
291         sharedAddr = SharedRegion_getPtr(sharedShmBase);
292         status = GateMP_openByAddr(sharedAddr, handlePtr);
293     }
294     else {
295         /*  need to track number of opens atomically */
296         key = Hwi_disable();
297         resourceId = nsValue[2];
298         mask = nsValue[3];
300         /* Remote case */
301         switch (GETREMOTE(mask)) {
302             case GateMP_RemoteProtect_SYSTEM:
303                 obj = GateMP_module->remoteSystemGates[resourceId];
304                 break;
306             case GateMP_RemoteProtect_CUSTOM1:
307                 obj = GateMP_module->remoteCustom1Gates[resourceId];
308                 break;
310             case GateMP_RemoteProtect_CUSTOM2:
311                 obj = GateMP_module->remoteCustom2Gates[resourceId];
312                 break;
314             default:
315                 obj = NULL;
316                 status = GateMP_E_FAIL;
317                 break;
318         }
320         if (status == GateMP_S_SUCCESS) {
321             /*
322              *  If the object is NULL, then it must have been created on a
323              *  remote processor. Need to create a local object. This is
324              *  accomplished by setting the openFlag to TRUE.
325              */
326             if (obj == NULL) {
327                 /* Create a GateMP object with the openFlag set to true */
328                 ti_sdo_ipc_GateMP_Params_init(&params);
329                 params.openFlag = TRUE;
330                 params.sharedAddr = NULL;
331                 params.resourceId = resourceId;
332                 params.localProtect = GETLOCAL(mask);
333                 params.remoteProtect = GETREMOTE(mask);
335                 obj = ti_sdo_ipc_GateMP_create(&params, &eb);
336                 if (obj == NULL) {
337                     status = GateMP_E_FAIL;
338                 }
339             }
340             else {
341                 obj->numOpens++;
342             }
343         }
345         /* Return the GateMP instance  */
346         *handlePtr = (GateMP_Handle)obj;
348         /* restore hwi mask */
349         Hwi_restore(key);
350     }
352     return (status);
355 /*
356  *  ======== GateMP_openByAddr ========
357  */
358 Int GateMP_openByAddr(Ptr sharedAddr, GateMP_Handle *handlePtr)
360     Int status = GateMP_S_SUCCESS;
361     UInt key;
362     ti_sdo_ipc_GateMP_Object *obj;
363     ti_sdo_ipc_GateMP_Params params;
364     ti_sdo_ipc_GateMP_Attrs *attrs;
365     UInt16 regionId;
366     Error_Block eb;
368     Error_init(&eb);
370     attrs = (ti_sdo_ipc_GateMP_Attrs *)sharedAddr;
372     /* get the region id and invalidate attrs is needed */
373     regionId = SharedRegion_getId(sharedAddr);
374     if (regionId != SharedRegion_INVALIDREGIONID) {
375         if (SharedRegion_isCacheEnabled(regionId)) {
376             Cache_inv(attrs, sizeof(ti_sdo_ipc_GateMP_Attrs), Cache_Type_ALL,
377                     TRUE);
378         }
379     }
381     if (attrs->status != ti_sdo_ipc_GateMP_CREATED) {
382         *handlePtr = NULL;
383         status = GateMP_E_NOTFOUND;
384     }
385     else {
386         /* Local gate */
387         if (GETREMOTE(attrs->mask) == GateMP_RemoteProtect_NONE) {
388             if (attrs->creatorProcId != MultiProc_self()) {
389                 Error_raise(&eb, ti_sdo_ipc_GateMP_E_localGate, 0, 0);
390                 return (GateMP_E_FAIL);
391             }
393             /* need to atomically increment number of opens */
394             key = Hwi_disable();
396             obj = (ti_sdo_ipc_GateMP_Object *)attrs->arg;
397             *handlePtr = (GateMP_Handle)obj;
398             obj->numOpens++;
400             /* restore hwi mask */
401             Hwi_restore(key);
403             return (GateMP_S_SUCCESS);
404         }
406         /*  need to track number of opens atomically */
407         key = Hwi_disable();
409         /* Remote case */
410         switch (GETREMOTE(attrs->mask)) {
411             case GateMP_RemoteProtect_SYSTEM:
412                 obj = GateMP_module->remoteSystemGates[attrs->arg];
413                 break;
415             case GateMP_RemoteProtect_CUSTOM1:
416                 obj = GateMP_module->remoteCustom1Gates[attrs->arg];
417                 break;
419             case GateMP_RemoteProtect_CUSTOM2:
420                 obj = GateMP_module->remoteCustom2Gates[attrs->arg];
421                 break;
423             default:
424                 obj = NULL;
425                 status = GateMP_E_FAIL;
426                 break;
427         }
429         if (status == GateMP_S_SUCCESS) {
430             /*
431              *  If the object is NULL, then it must have been created on a
432              *  remote processor. Need to create a local object. This is
433              *  accomplished by setting the openFlag to TRUE.
434              */
435             if (obj == NULL) {
436                 /* Create a GateMP object with the openFlag set to true */
437                 ti_sdo_ipc_GateMP_Params_init(&params);
438                 params.openFlag = TRUE;
439                 params.sharedAddr = sharedAddr;
440                 params.resourceId = attrs->arg;
441                 params.localProtect = GETLOCAL(attrs->mask);
442                 params.remoteProtect = GETREMOTE(attrs->mask);
444                 obj = ti_sdo_ipc_GateMP_create(&params, &eb);
445                 if (obj == NULL) {
446                     status = GateMP_E_FAIL;
447                 }
448             }
449             else {
450                 obj->numOpens++;
451             }
452         }
454         /* Return the GateMP instance  */
455         *handlePtr = (GateMP_Handle)obj;
457         /* restore hwi mask */
458         Hwi_restore(key);
459     }
461     return (status);
464 /*
465  *  ======== GateMP_sharedMemReq ========
466  */
467 SizeT GateMP_sharedMemReq(const GateMP_Params *params)
469     SizeT memReq, minAlign;
470     UInt16 regionId;
471     ti_sdo_ipc_GateMP_RemoteSystemProxy_Params systemParams;
472     ti_sdo_ipc_GateMP_RemoteCustom1Proxy_Params custom1Params;
473     ti_sdo_ipc_GateMP_RemoteCustom2Proxy_Params custom2Params;
475     if (params->sharedAddr) {
476         regionId = SharedRegion_getId(params->sharedAddr);
477     }
478     else {
479         regionId = params->regionId;
480     }
482     Assert_isTrue(regionId != SharedRegion_INVALIDREGIONID,
483             ti_sdo_ipc_Ipc_A_internal);
485     minAlign = Memory_getMaxDefaultTypeAlign();
486     if (SharedRegion_getCacheLineSize(regionId) > minAlign) {
487         minAlign = SharedRegion_getCacheLineSize(regionId);
488     }
490     memReq = _Ipc_roundup(sizeof(ti_sdo_ipc_GateMP_Attrs), minAlign);
492     /* add the amount of shared memory required by proxy */
493     if (params->remoteProtect == GateMP_RemoteProtect_SYSTEM) {
494         ti_sdo_ipc_GateMP_RemoteSystemProxy_Params_init(&systemParams);
495         systemParams.regionId = regionId;
496         memReq += ti_sdo_ipc_GateMP_RemoteSystemProxy_sharedMemReq(
497                 (IGateMPSupport_Params *)&systemParams);
498     }
499     else if (params->remoteProtect == GateMP_RemoteProtect_CUSTOM1) {
500         ti_sdo_ipc_GateMP_RemoteCustom1Proxy_Params_init(&custom1Params);
501         custom1Params.regionId = regionId;
502         memReq += ti_sdo_ipc_GateMP_RemoteCustom1Proxy_sharedMemReq(
503                 (IGateMPSupport_Params *)&custom1Params);
504     }
505     else if (params->remoteProtect == GateMP_RemoteProtect_CUSTOM2) {
506         ti_sdo_ipc_GateMP_RemoteCustom2Proxy_Params_init(&custom2Params);
507         custom2Params.regionId = regionId;
508         memReq += ti_sdo_ipc_GateMP_RemoteCustom2Proxy_sharedMemReq(
509                 (IGateMPSupport_Params *)&custom2Params);
510     }
512     return (memReq);
515 /*
516  *************************************************************************
517  *                       Module functions
518  *************************************************************************
519  */
521 /*
522  *  ======== ti_sdo_ipc_GateMP_createLocal ========
523  */
524 IGateProvider_Handle ti_sdo_ipc_GateMP_createLocal(
525     ti_sdo_ipc_GateMP_LocalProtect localProtect)
527     IGateProvider_Handle gateHandle;
529     /* Create the local gate. */
530     switch (localProtect) {
531         case GateMP_LocalProtect_NONE:
532             /* Plug with the GateNull singleton */
533             gateHandle = GateMP_module->gateNull;
534             break;
536         case GateMP_LocalProtect_INTERRUPT:
537             /* Plug with the GateAll singleton */
538             gateHandle = GateMP_module->gateAll;
539             break;
541         case GateMP_LocalProtect_TASKLET:
542             /* Plug with the GateSwi singleton */
543             gateHandle = GateMP_module->gateSwi;
544             break;
546         case GateMP_LocalProtect_THREAD:
547         case GateMP_LocalProtect_PROCESS:
548             /* Plug with the GateMutexPri singleton */
549             gateHandle = GateMP_module->gateMutexPri;
550             break;
552         default:
553             /* Invalid local protection level encountered */
554             Assert_isTrue(FALSE, ti_sdo_ipc_Ipc_A_internal);
555             break;
556     }
558     return (gateHandle);
561 /*
562  *  ======== GateMP_getDefaultRemote ========
563  */
564 GateMP_Handle GateMP_getDefaultRemote()
566     return ((GateMP_Handle)GateMP_module->defaultGate);
569 /*
570  *  ======== GateMP_getLocalProtect ========
571  */
572 GateMP_LocalProtect GateMP_getLocalProtect(GateMP_Handle handle)
574     ti_sdo_ipc_GateMP_Object *obj = (ti_sdo_ipc_GateMP_Object *)handle;
576     Assert_isTrue(obj != NULL, ti_sdo_ipc_Ipc_A_nullArgument);
578     return ((GateMP_LocalProtect)obj->localProtect);
581 /*
582  *  ======== GateMP_getRemoteProtect ========
583  */
584 GateMP_RemoteProtect GateMP_getRemoteProtect(GateMP_Handle handle)
586     ti_sdo_ipc_GateMP_Object *obj = (ti_sdo_ipc_GateMP_Object *)handle;
588     Assert_isTrue(obj != NULL, ti_sdo_ipc_Ipc_A_nullArgument);
590     return ((GateMP_RemoteProtect)obj->remoteProtect);
593 /*
594  *  ======== ti_sdo_ipc_GateMP_getRegion0ReservedSize ========
595  */
596 SizeT ti_sdo_ipc_GateMP_getRegion0ReservedSize(Void)
598     SizeT reserved, minAlign;
600     minAlign = Memory_getMaxDefaultTypeAlign();
602     if (SharedRegion_getCacheLineSize(0) > minAlign) {
603         minAlign = SharedRegion_getCacheLineSize(0);
604     }
606     reserved = _Ipc_roundup(sizeof(ti_sdo_ipc_GateMP_Reserved), minAlign);
608     reserved += _Ipc_roundup(GateMP_module->numRemoteSystem, minAlign);
610     if (GateMP_module->proxyMap[ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM1] ==
611         ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM1) {
612             reserved += _Ipc_roundup(GateMP_module->numRemoteCustom1, minAlign);
613     }
615     if (GateMP_module->proxyMap[ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM2] ==
616         ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM2) {
617             reserved += _Ipc_roundup(GateMP_module->numRemoteCustom2, minAlign);
618     }
620     return (reserved);
623 /*
624  *  ======== ti_sdo_ipc_GateMP_setRegion0Reserved ========
625  */
626 Void ti_sdo_ipc_GateMP_setRegion0Reserved(Ptr sharedAddr)
628     ti_sdo_ipc_GateMP_Reserved *reserve;
629     SizeT minAlign, offset;
630     UInt i;
631     Bits32 *delegateReservedMask;
632     UInt32 nsValue[6];
633     Int ret;
635     minAlign = Memory_getMaxDefaultTypeAlign();
636     if (SharedRegion_getCacheLineSize(0) > minAlign) {
637         minAlign = SharedRegion_getCacheLineSize(0);
638     }
640     /* setup ti_sdo_ipc_GateMP_Reserved fields */
641     reserve = (ti_sdo_ipc_GateMP_Reserved *)sharedAddr;
642     reserve->version = ti_sdo_ipc_GateMP_VERSION;
644     if (SharedRegion_isCacheEnabled(0)) {
645         Cache_wbInv(sharedAddr, sizeof(ti_sdo_ipc_GateMP_Reserved),
646             Cache_Type_ALL, TRUE);
647     }
649     /*
650      *  initialize the in-use array in shared memory for the system gates.
651      */
652     offset = _Ipc_roundup(sizeof(ti_sdo_ipc_GateMP_Reserved), minAlign);
653     GateMP_module->remoteSystemInUse =
654         (Ptr)((UInt32)sharedAddr + offset);
656     memset(GateMP_module->remoteSystemInUse, 0,
657         GateMP_module->numRemoteSystem * sizeof(UInt8));
658     delegateReservedMask =
659             ti_sdo_ipc_GateMP_RemoteSystemProxy_getReservedMask();
660     if (delegateReservedMask != NULL) {
661         for (i = 0; i < GateMP_module->numRemoteSystem; i++) {
662             if (delegateReservedMask[i >> 5] & (1 << (i % 32))) {
663                 GateMP_module->remoteSystemInUse[i] = RESERVED;
664             }
665         }
666     }
668     if (SharedRegion_isCacheEnabled(0)) {
669         Cache_wbInv(GateMP_module->remoteSystemInUse,
670             GateMP_module->numRemoteSystem * sizeof(UInt8),
671             Cache_Type_ALL,
672             TRUE);
673     }
675     /*
676      *  initialize the in-use array in shared memory for the custom1 gates.
677      *  Need to check if this proxy is the same as system
678      */
679     offset = _Ipc_roundup(GateMP_module->numRemoteSystem, minAlign);
680     if (GateMP_module->proxyMap[ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM1] ==
681         ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM1) {
682         if (GateMP_module->numRemoteCustom1 != 0) {
683             GateMP_module->remoteCustom1InUse =
684                 GateMP_module->remoteSystemInUse + offset;
685         }
687         memset(GateMP_module->remoteCustom1InUse, 0,
688             GateMP_module->numRemoteCustom1 * sizeof(UInt8));
689         delegateReservedMask =
690                 ti_sdo_ipc_GateMP_RemoteCustom1Proxy_getReservedMask();
691         if (delegateReservedMask != NULL) {
692             for (i = 0; i < GateMP_module->numRemoteCustom1; i++) {
693                 if (delegateReservedMask[i >> 5] & (1 << (i % 32))) {
694                     GateMP_module->remoteCustom1InUse[i] = RESERVED;
695                 }
696             }
697         }
698         if (SharedRegion_isCacheEnabled(0)) {
699             Cache_wbInv(GateMP_module->remoteCustom1InUse,
700                  GateMP_module->numRemoteCustom1 * sizeof(UInt8),
701                  Cache_Type_ALL,
702                  TRUE);
703         }
704     }
705     else {
706         GateMP_module->remoteCustom1InUse = GateMP_module->remoteSystemInUse;
707         GateMP_module->remoteCustom1Gates = GateMP_module->remoteSystemGates;
708     }
710     /*
711      *  initialize the in-use array in shared memory for the custom2 gates.
712      *  Need to check if this proxy is the same as system or custom1
713      */
714     offset = _Ipc_roundup(GateMP_module->numRemoteCustom1, minAlign);
715     if (GateMP_module->proxyMap[ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM2] ==
716         ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM2) {
717         if (GateMP_module->numRemoteCustom2 != 0) {
718                 GateMP_module->remoteCustom2InUse =
719                     GateMP_module->remoteCustom1InUse + offset;
720         }
722         memset(GateMP_module->remoteCustom2InUse, 0,
723             GateMP_module->numRemoteCustom2 * sizeof(UInt8));
724         delegateReservedMask =
725                 ti_sdo_ipc_GateMP_RemoteCustom2Proxy_getReservedMask();
726         if (delegateReservedMask != NULL) {
727             for (i = 0; i < GateMP_module->numRemoteCustom2; i++) {
728                 if (delegateReservedMask[i >> 5] & (1 << (i % 32))) {
729                     GateMP_module->remoteCustom2InUse[i] = RESERVED;
730                 }
731             }
732         }
734         if (SharedRegion_isCacheEnabled(0)) {
735             Cache_wbInv(GateMP_module->remoteCustom2InUse,
736                  GateMP_module->numRemoteCustom2 * sizeof(UInt8),
737                  Cache_Type_ALL,
738                  TRUE);
739         }
740     }
741     else if (GateMP_module->proxyMap[ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM2] ==
742              ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM1) {
743         GateMP_module->remoteCustom2InUse =
744             GateMP_module->remoteCustom1InUse;
745         GateMP_module->remoteCustom2Gates =
746             GateMP_module->remoteCustom1Gates;
747     }
748     else {
749         GateMP_module->remoteCustom2InUse = GateMP_module->remoteSystemInUse;
750         GateMP_module->remoteCustom2Gates = GateMP_module->remoteSystemGates;
751     }
753     if (GateMP_module->hostSupport == TRUE) {
754         /* Add special entry to store inuse arrays' location and size */
755         ret = _GateMP_virtToPhys(
756             (UInt32)GateMP_module->remoteSystemInUse, &nsValue[0]);
757         Assert_isTrue(ret == GateMP_S_SUCCESS, (Assert_Id)NULL);
758         ret = _GateMP_virtToPhys(
759             (UInt32)GateMP_module->remoteCustom1InUse, &nsValue[1]);
760         Assert_isTrue(ret == GateMP_S_SUCCESS, (Assert_Id)NULL);
761         ret = _GateMP_virtToPhys(
762             (UInt32)GateMP_module->remoteCustom2InUse, &nsValue[2]);
763         Assert_isTrue(ret == GateMP_S_SUCCESS, (Assert_Id)NULL);
764         nsValue[3] = GateMP_module->numRemoteSystem;
765         nsValue[4] = GateMP_module->numRemoteCustom1;
766         nsValue[5] = GateMP_module->numRemoteCustom2;
767         GateMP_module->nsKey = NameServer_add((NameServer_Handle)
768             GateMP_module->nameServer, "_GateMP_TI_info", &nsValue,
769             sizeof(nsValue));
770     }
773 /*
774  *  ======== ti_sdo_ipc_GateMP_openRegion0Reserved ========
775  */
776 Void ti_sdo_ipc_GateMP_openRegion0Reserved(Ptr sharedAddr)
778     ti_sdo_ipc_GateMP_Reserved *reserve;
779     SizeT minAlign, offset;
781     minAlign = Memory_getMaxDefaultTypeAlign();
782     if (SharedRegion_getCacheLineSize(0) > minAlign) {
783         minAlign = SharedRegion_getCacheLineSize(0);
784     }
787     /* setup ti_sdo_ipc_GateMP_Reserved fields */
788     reserve = (ti_sdo_ipc_GateMP_Reserved *)sharedAddr;
790     if (reserve->version != ti_sdo_ipc_GateMP_VERSION) {
791         /* Version mismatch: return an error */
792         Error_raise(NULL, ti_sdo_ipc_Ipc_E_versionMismatch, reserve->version,
793                     ti_sdo_ipc_GateMP_VERSION);
794         return;
795     }
797     offset = _Ipc_roundup(sizeof(ti_sdo_ipc_GateMP_Reserved), minAlign);
798     GateMP_module->remoteSystemInUse =
799         (Ptr)((UInt32)sharedAddr + offset);
801     /*
802      *  initialize the in-use array in shared memory for the custom1 gates.
803      *  Need to check if this proxy is the same as system
804      */
805     offset = _Ipc_roundup(GateMP_module->numRemoteSystem, minAlign);
806     if (GateMP_module->proxyMap[ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM1] ==
807         ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM1) {
808         if (GateMP_module->numRemoteCustom1 != 0) {
809             GateMP_module->remoteCustom1InUse =
810                 GateMP_module->remoteSystemInUse + offset;
811         }
812     }
813     else {
814         GateMP_module->remoteCustom1InUse = GateMP_module->remoteSystemInUse;
815         GateMP_module->remoteCustom1Gates = GateMP_module->remoteSystemGates;
816     }
818     offset = _Ipc_roundup(GateMP_module->numRemoteCustom1, minAlign);
819     if (GateMP_module->proxyMap[ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM2] ==
820         ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM2) {
821         if (GateMP_module->numRemoteCustom2 != 0) {
822             GateMP_module->remoteCustom2InUse =
823                 GateMP_module->remoteCustom1InUse + offset;
824         }
825     }
826     else if (GateMP_module->proxyMap[ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM2] ==
827              ti_sdo_ipc_GateMP_ProxyOrder_CUSTOM1) {
828         GateMP_module->remoteCustom2InUse =
829             GateMP_module->remoteCustom1InUse;
830         GateMP_module->remoteCustom2Gates =
831             GateMP_module->remoteCustom1Gates;
832     }
833     else {
834         GateMP_module->remoteCustom2InUse = GateMP_module->remoteSystemInUse;
835         GateMP_module->remoteCustom2Gates = GateMP_module->remoteSystemGates;
836     }
839 /*
840  *  ======== ti_sdo_ipc_GateMP_attach ========
841  */
842 Int ti_sdo_ipc_GateMP_attach(UInt16 remoteProcId, Ptr sharedAddr)
844     Ptr gateMPsharedAddr;
845     SharedRegion_Entry entry;
846     ti_sdo_ipc_GateMP_Handle defaultGate;
847     Int status = GateMP_S_SUCCESS;
849     /* If default gate is not NULL return since its already set */
850     if (GateMP_getDefaultRemote() != NULL) {
851         return(GateMP_S_ALREADYSETUP);
852     }
854     /* get region 0 information */
855     SharedRegion_getEntry(0, &entry);
857     gateMPsharedAddr = (Ptr)((UInt32)sharedAddr +
858                        ti_sdo_ipc_GateMP_getRegion0ReservedSize());
860     if ((entry.ownerProcId != MultiProc_self()) &&
861         (entry.ownerProcId != MultiProc_INVALIDID)) {
862         /* if not the owner of the SharedRegion */
863         ti_sdo_ipc_GateMP_openRegion0Reserved(sharedAddr);
865         /* open the gate by address */
866         status = GateMP_openByAddr(gateMPsharedAddr,
867                 (GateMP_Handle *)&defaultGate);
869         /* openByAddr should always succeed */
870         Assert_isTrue(status >= 0, ti_sdo_ipc_Ipc_A_internal);
872         /* set the default GateMP for opener */
873         ti_sdo_ipc_GateMP_setDefaultRemote(defaultGate);
874     }
876     return (status);
879 /*
880  *  ======== ti_sdo_ipc_GateMP_detach ========
881  */
882 Int ti_sdo_ipc_GateMP_detach(UInt16 remoteProcId)
884     SharedRegion_Entry entry;
885     GateMP_Handle gate;
886     Int status = GateMP_S_SUCCESS;
888     /* get region 0 information */
889     SharedRegion_getEntry(0, &entry);
891     if ((entry.isValid) &&
892         (entry.ownerProcId == remoteProcId)) {
893         /* get the default gate */
894         gate = GateMP_getDefaultRemote();
896         if (gate != NULL) {
897             /* close the gate */
898             status = GateMP_close(&gate);
900             /* set the default remote gate to NULL */
901             ti_sdo_ipc_GateMP_setDefaultRemote(NULL);
902         }
903     }
905     return (status);
908 /*
909  *  ======== ti_sdo_ipc_GateMP_start ========
910  */
911 Int ti_sdo_ipc_GateMP_start(Ptr sharedAddr)
913     SharedRegion_Entry       entry;
914     ti_sdo_ipc_GateMP_Params gateMPParams;
915     ti_sdo_ipc_GateMP_Handle defaultGate;
916     Int status = GateMP_S_SUCCESS;
917     Error_Block eb;
919     /* get region 0 information */
920     SharedRegion_getEntry(0, &entry);
922     /* if entry owner proc is not specified return */
923     if (entry.ownerProcId == MultiProc_INVALIDID) {
924         return (status);
925     }
927     if (entry.ownerProcId == MultiProc_self()) {
928         /* if owner of the SharedRegion */
929         ti_sdo_ipc_GateMP_setRegion0Reserved(sharedAddr);
931         /* create default GateMP */
932         ti_sdo_ipc_GateMP_Params_init(&gateMPParams);
933         gateMPParams.sharedAddr = (Ptr)((UInt32)sharedAddr +
934                 ti_sdo_ipc_GateMP_getRegion0ReservedSize());
935         gateMPParams.localProtect  = ti_sdo_ipc_GateMP_LocalProtect_TASKLET;
936         gateMPParams.name = "_GateMP_TI_dGate";
938         if (ti_sdo_utils_MultiProc_numProcessors > 1) {
939             gateMPParams.remoteProtect = ti_sdo_ipc_GateMP_RemoteProtect_SYSTEM;
940         }
941         else {
942             gateMPParams.remoteProtect = ti_sdo_ipc_GateMP_RemoteProtect_NONE;
943         }
945         Error_init(&eb);
946         defaultGate = ti_sdo_ipc_GateMP_create(&gateMPParams, &eb);
947         if (defaultGate != NULL) {
948             /* set the default GateMP for creator */
949             ti_sdo_ipc_GateMP_setDefaultRemote(defaultGate);
950         }
951         else {
952             status = GateMP_E_FAIL;
953         }
954     }
956     return (status);
959 /*
960  *  ======== ti_sdo_ipc_GateMP_stop ========
961  */
962 Int ti_sdo_ipc_GateMP_stop()
964     SharedRegion_Entry entry;
965     GateMP_Handle gate;
966     Int status = GateMP_S_SUCCESS;
968     /* get region 0 information */
969     SharedRegion_getEntry(0, &entry);
971     if ((entry.isValid) &&
972         (entry.createHeap) &&
973         (entry.ownerProcId == MultiProc_self())) {
974         /* get the default GateMP */
975         gate = GateMP_getDefaultRemote();
977         if (gate != NULL) {
978             /* set the default GateMP to NULL */
979             ti_sdo_ipc_GateMP_setDefaultRemote(NULL);
981             /* delete the default GateMP */
982             status = GateMP_delete(&gate);
983         }
985         /* Remove global info entry from NameServer */
986         if ((GateMP_module->hostSupport == TRUE) &&
987             (GateMP_module->nsKey != 0)) {
988             NameServer_removeEntry((NameServer_Handle)GateMP_module->nameServer,
989                 GateMP_module->nsKey);
990         }
991     }
993     return (status);
996 /*
997  *************************************************************************
998  *                       Instance functions
999  *************************************************************************
1000  */
1002 /*
1003  *  ======== ti_sdo_ipc_GateMP_Instance_init ========
1004  */
1005 Int ti_sdo_ipc_GateMP_Instance_init(ti_sdo_ipc_GateMP_Object *obj,
1006         const ti_sdo_ipc_GateMP_Params *params,
1007         Error_Block *eb)
1009     UInt key;
1010     IGateMPSupport_Handle remoteHandle;
1011     IGateProvider_Handle localHandle;
1012     ti_sdo_ipc_GateMP_RemoteSystemProxy_Params systemParams;
1013     ti_sdo_ipc_GateMP_RemoteCustom1Proxy_Params custom1Params;
1014     ti_sdo_ipc_GateMP_RemoteCustom2Proxy_Params custom2Params;
1015     SizeT minAlign, offset;
1016     SharedRegion_SRPtr sharedShmBase;
1017     GateMP_Params sparams;
1018     UInt32 nsValue[4];
1019     UInt32 sizeNsValue;
1020     IHeap_Handle regionHeap;
1022     /* Initialize resourceId to an invalid value */
1023     obj->resourceId = (UInt)-1;
1025     localHandle = ti_sdo_ipc_GateMP_createLocal(params->localProtect);
1027     /* Open GateMP instance */
1028     if (params->openFlag == TRUE) {
1029         /* all open work done here except for remote gateHandle */
1030         obj->localProtect   = params->localProtect;
1031         obj->remoteProtect  = params->remoteProtect;
1032         obj->nsKey          = 0;
1033         obj->numOpens       = 0; /* Will be set to 1 after init() complete */
1034         obj->attrs          = (ti_sdo_ipc_GateMP_Attrs *)params->sharedAddr;
1035         if (obj->attrs != NULL) {
1036             obj->regionId       = SharedRegion_getId((Ptr)obj->attrs);
1037             obj->cacheEnabled   = SharedRegion_isCacheEnabled(obj->regionId);
1038             /* Assert that the buffer is in a valid shared region */
1039             Assert_isTrue(obj->regionId != SharedRegion_INVALIDREGIONID,
1040                       ti_sdo_ipc_Ipc_A_addrNotInSharedRegion);
1041         }
1043         obj->allocSize      = 0;
1044         obj->objType        = ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC;
1046         minAlign = Memory_getMaxDefaultTypeAlign();
1048         if ((obj->attrs != NULL) &&
1049             (SharedRegion_getCacheLineSize(obj->regionId) > minAlign)) {
1050             minAlign = SharedRegion_getCacheLineSize(obj->regionId);
1051         }
1053         offset = _Ipc_roundup(sizeof(ti_sdo_ipc_GateMP_Attrs), minAlign);
1055         /* TODO: host side created gates cannot have proxy memory */
1056         if (obj->attrs != NULL) {
1057             obj->proxyAttrs = (Ptr)((UInt32)obj->attrs + offset);
1058         }
1059         else {
1060             obj->proxyAttrs = NULL;
1061         }
1062     }
1063     /* Create GateMP instance */
1064     else {
1065         obj->localProtect  = params->localProtect;
1066         obj->remoteProtect = params->remoteProtect;
1067         obj->nsKey         = 0;
1068         obj->numOpens      = 0;
1070         if (obj->remoteProtect == GateMP_RemoteProtect_NONE) {
1071             obj->gateHandle = ti_sdo_ipc_GateMP_createLocal(obj->localProtect);
1072             if (params->sharedAddr != NULL) {
1073                 /* Create a local gate using shared memory */
1074                 obj->objType = ti_sdo_ipc_Ipc_ObjType_CREATEDYNAMIC;
1075                 obj->attrs = params->sharedAddr;
1076                 obj->regionId = SharedRegion_getId((Ptr)obj->attrs);
1077                 obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId);
1078             }
1079             else {
1080                 /* Create a local gate allocating from the local heap */
1081                 obj->objType = ti_sdo_ipc_Ipc_ObjType_LOCAL;
1082                 obj->regionId = ti_sdo_ipc_SharedRegion_INVALIDREGIONID;
1083                 obj->cacheEnabled  = FALSE; /* local */
1084                 obj->attrs = Memory_alloc(NULL,
1085                         sizeof(ti_sdo_ipc_GateMP_Attrs), 0, eb);
1086                 if (obj->attrs == NULL) {
1087                     return (2);
1088                 }
1090             }
1092             obj->attrs->arg = (Bits32)obj;
1093             obj->attrs->mask = SETMASK(obj->remoteProtect, obj->localProtect);
1094             obj->attrs->creatorProcId = MultiProc_self();
1095             obj->attrs->status = ti_sdo_ipc_GateMP_CREATED;
1096             if (obj->cacheEnabled) {
1097                 /*
1098                  *  Need to write back memory if cache is enabled because cache
1099                  *  will be invalidated during openByAddr
1100                  */
1101                 Cache_wbInv(obj->attrs, sizeof(ti_sdo_ipc_GateMP_Attrs),
1102                         Cache_Type_ALL, TRUE);
1103             }
1105             if (params->name) {
1106                 nsValue[0] = (UInt32)obj->attrs;
1107                 /*
1108                  *  Top 16 bits = procId of creator
1109                  *  Bottom 16 bits = '0' if local, '1' otherwise
1110                  */
1111                 nsValue[1] = ((UInt32)MultiProc_self()) << 16;
1113                 if (GateMP_module->hostSupport == TRUE) {
1114                     nsValue[2] = obj->attrs->arg;
1115                     nsValue[3] = obj->attrs->mask;
1116                     sizeNsValue = sizeof(nsValue);
1117                 }
1118                 else {
1119                     sizeNsValue = 2 * sizeof(UInt32);
1120                 }
1122                 obj->nsKey = NameServer_add((NameServer_Handle)
1123                         GateMP_module->nameServer, params->name, &nsValue,
1124                         sizeNsValue);
1126                 if (obj->nsKey == NULL) {
1127                     Error_raise(eb, ti_sdo_ipc_Ipc_E_nameFailed, params->name,
1128                         0);
1129                     return (3);
1130                 }
1131             }
1133             /* Nothing else to do for local gates */
1134             return (0);
1135         }
1137         if (params->sharedAddr == NULL) {
1138             /* Need to allocate from heap */
1139             obj->objType        = ti_sdo_ipc_Ipc_ObjType_CREATEDYNAMIC_REGION;
1140             obj->regionId       = params->regionId;
1141             GateMP_getSharedParams(&sparams, params);
1142             obj->allocSize      = GateMP_sharedMemReq(&sparams);
1143             obj->cacheEnabled   = SharedRegion_isCacheEnabled(obj->regionId);
1145             /* The region heap will do the alignment */
1146             regionHeap = SharedRegion_getHeap(obj->regionId);
1147             Assert_isTrue(regionHeap != NULL, ti_sdo_ipc_SharedRegion_A_noHeap);
1148             obj->attrs = Memory_alloc(regionHeap, obj->allocSize, 0, eb);
1149             if (obj->attrs == NULL) {
1150                 return (3);
1151             }
1153             minAlign = Memory_getMaxDefaultTypeAlign();
1155             if (SharedRegion_getCacheLineSize(obj->regionId) > minAlign) {
1156                 minAlign = SharedRegion_getCacheLineSize(obj->regionId);
1157             }
1159             offset = _Ipc_roundup(sizeof(ti_sdo_ipc_GateMP_Attrs), minAlign);
1161             obj->proxyAttrs = (Ptr)((UInt32)obj->attrs + offset);
1162         }
1163         else {
1164             /* creating using sharedAddr */
1165             obj->regionId = SharedRegion_getId(params->sharedAddr);
1166             /* Assert that the buffer is in a valid shared region */
1167             Assert_isTrue(obj->regionId != SharedRegion_INVALIDREGIONID,
1168                           ti_sdo_ipc_Ipc_A_addrNotInSharedRegion);
1170             obj->attrs = (ti_sdo_ipc_GateMP_Attrs *)params->sharedAddr;
1171             obj->cacheEnabled  = SharedRegion_isCacheEnabled(obj->regionId);
1172             obj->objType = ti_sdo_ipc_Ipc_ObjType_CREATEDYNAMIC;
1174             minAlign = Memory_getMaxDefaultTypeAlign();
1176             if (SharedRegion_getCacheLineSize(obj->regionId) > minAlign) {
1177                 minAlign = SharedRegion_getCacheLineSize(obj->regionId);
1178             }
1180             /* Assert that sharedAddr has correct alignment */
1181             Assert_isTrue(minAlign == 0 ||
1182                           ((UInt32)params->sharedAddr % minAlign) == 0,
1183                           ti_sdo_ipc_Ipc_A_addrNotCacheAligned);
1185             offset = _Ipc_roundup(sizeof(ti_sdo_ipc_GateMP_Attrs), minAlign);
1187             obj->proxyAttrs = (Ptr)((UInt32)obj->attrs + offset);
1188         }
1189     }
1191     /* Proxy work for open and create done here */
1192     switch (obj->remoteProtect) {
1193         case GateMP_RemoteProtect_SYSTEM:
1194             if (obj->objType != ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC) {
1195                 /* Created Instance */
1196                 obj->resourceId = GateMP_getFreeResource(
1197                     GateMP_module->remoteSystemInUse,
1198                              GateMP_module->numRemoteSystem, eb);
1199                 if (Error_check(eb) == TRUE) {
1200                     return (4);
1201                 }
1202             }
1203             else {
1204                 /* resourceId set by open call */
1205                 obj->resourceId = params->resourceId;
1206             }
1208             /* Create the proxy object */
1209             ti_sdo_ipc_GateMP_RemoteSystemProxy_Params_init(&systemParams);
1210             systemParams.resourceId = obj->resourceId;
1211             systemParams.openFlag =
1212                     (obj->objType == ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC);
1213             systemParams.sharedAddr = obj->proxyAttrs;
1214             systemParams.regionId = obj->regionId;
1215             remoteHandle = ti_sdo_ipc_GateMP_RemoteSystemProxy_create(
1216                     localHandle, &systemParams, eb);
1218             if (remoteHandle == NULL) {
1219                 return (5);
1220             }
1222             /* Fill in the local array because it is cooked */
1223             key = Hwi_disable();
1224             GateMP_module->remoteSystemGates[obj->resourceId] = obj;
1225             Hwi_restore(key);
1226             break;
1228         case GateMP_RemoteProtect_CUSTOM1:
1229             if (obj->objType != ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC) {
1230                 obj->resourceId = GateMP_getFreeResource(
1231                              GateMP_module->remoteCustom1InUse,
1232                              GateMP_module->numRemoteCustom1, eb);
1233                 if (Error_check(eb) == TRUE) {
1234                     return (4);
1235                 }
1236             }
1237             else {
1238                 /* resourceId set by open call */
1239                 obj->resourceId = params->resourceId;
1240             }
1242             /* Create the proxy object */
1243             ti_sdo_ipc_GateMP_RemoteCustom1Proxy_Params_init(&custom1Params);
1244             custom1Params.resourceId = obj->resourceId;
1245             custom1Params.openFlag =
1246                     (obj->objType == ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC);
1247             custom1Params.sharedAddr = obj->proxyAttrs;
1248             custom1Params.regionId = obj->regionId;
1249             remoteHandle = ti_sdo_ipc_GateMP_RemoteCustom1Proxy_create(
1250                     localHandle, &custom1Params, eb);
1251             if (remoteHandle == NULL) {
1252                 return (5);
1253             }
1255             /* Fill in the local array because it is cooked */
1256             key = Hwi_disable();
1257             GateMP_module->remoteCustom1Gates[obj->resourceId] = obj;
1258             Hwi_restore(key);
1259             break;
1261         case GateMP_RemoteProtect_CUSTOM2:
1262             if (obj->objType != ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC) {
1263                 obj->resourceId = GateMP_getFreeResource(
1264                              GateMP_module->remoteCustom2InUse,
1265                              GateMP_module->numRemoteCustom2, eb);
1266                 if (Error_check(eb) == TRUE) {
1267                     return (4);
1268                 }
1269             }
1270             else {
1271                 /* resourceId set by open call */
1272                 obj->resourceId = params->resourceId;
1273             }
1275             /* Create the proxy object */
1276             ti_sdo_ipc_GateMP_RemoteCustom2Proxy_Params_init(&custom2Params);
1277             custom2Params.resourceId = obj->resourceId;
1278             custom2Params.openFlag =
1279                     (obj->objType == ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC);
1280             custom2Params.sharedAddr = obj->proxyAttrs;
1281             custom2Params.regionId = obj->regionId;
1282             remoteHandle = ti_sdo_ipc_GateMP_RemoteCustom2Proxy_create(
1283                     localHandle, &custom2Params, eb);
1284             if (remoteHandle == NULL) {
1285                 return (5);
1286             }
1288             /* Fill in the local array because it is cooked */
1289             key = Hwi_disable();
1290             GateMP_module->remoteCustom2Gates[obj->resourceId] = obj;
1291             Hwi_restore(key);
1292             break;
1294         default:
1295             /* Should never be here */
1296             Assert_isTrue(FALSE, ti_sdo_ipc_Ipc_A_internal);
1297             return (5);  /* keep Coverity happy */
1298     }
1300     obj->gateHandle = IGateMPSupport_Handle_upCast(remoteHandle);
1302     /* Place Name/Attrs into NameServer table */
1303     if (obj->objType != ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC) {
1304         /* Fill in the attrs */
1305         obj->attrs->arg = obj->resourceId;
1306         obj->attrs->mask = SETMASK(obj->remoteProtect, obj->localProtect);
1307         obj->attrs->creatorProcId = MultiProc_self();
1308         obj->attrs->status = ti_sdo_ipc_GateMP_CREATED;
1310         if (obj->cacheEnabled) {
1311             Cache_wbInv(obj->attrs, sizeof(ti_sdo_ipc_GateMP_Attrs),
1312                     Cache_Type_ALL, TRUE);
1313         }
1315         if (params->name != NULL) {
1316             sharedShmBase = SharedRegion_getSRPtr(obj->attrs, obj->regionId);
1317             nsValue[0] = (UInt32)sharedShmBase;
1318             /*
1319              *  Top 16 bits = procId of creator
1320              *  Bottom 16 bits = '0' if local, '1' otherwise
1321              */
1322             nsValue[1] = ((UInt32)MultiProc_self() << 16) | 1;
1324             if (GateMP_module->hostSupport == TRUE) {
1325                 /* Making a copy of these for host processor */
1326                 nsValue[2] = obj->attrs->arg;
1327                 nsValue[3] = obj->attrs->mask;
1328                 sizeNsValue = sizeof(nsValue);
1329             }
1330             else {
1331                 sizeNsValue = 2 * sizeof(UInt32);
1332             }
1334             obj->nsKey = NameServer_add((NameServer_Handle)
1335                     GateMP_module->nameServer, params->name, &nsValue,
1336                     sizeNsValue);
1338             if (obj->nsKey == NULL) {
1339                 Error_raise(eb, ti_sdo_ipc_Ipc_E_nameFailed, params->name, 0);
1340                 return (6);
1341             }
1342         }
1344         Log_write2(ti_sdo_ipc_GateMP_LM_create,
1345                 (UArg)obj->remoteProtect, (UArg)obj->resourceId);
1346     }
1347     else {
1348         obj->numOpens = 1;
1350         Log_write2(ti_sdo_ipc_GateMP_LM_open,
1351             (UArg)obj->remoteProtect, (UArg)obj->resourceId);
1352     }
1354     return (0);
1357 /*
1358  *  ======== ti_sdo_ipc_GateMP_Instance_finalize ========
1359  */
1360 Void ti_sdo_ipc_GateMP_Instance_finalize(
1361         ti_sdo_ipc_GateMP_Object *obj, Int status)
1363     UInt systemKey;
1364     ti_sdo_ipc_GateMP_RemoteSystemProxy_Handle systemHandle;
1365     ti_sdo_ipc_GateMP_RemoteCustom1Proxy_Handle custom1Handle;
1366     ti_sdo_ipc_GateMP_RemoteCustom2Proxy_Handle custom2Handle;
1368     ti_sdo_ipc_GateMP_Handle *remoteHandles;
1369     UInt8 *inUseArray;
1370     UInt numResources;
1372     /* Cannot call when numOpen is non-zero. */
1373     Assert_isTrue(obj->numOpens == 0, ti_sdo_ipc_GateMP_A_invalidDelete);
1375     /* Removed from NameServer */
1376     if (obj->nsKey != 0) {
1377         NameServer_removeEntry((NameServer_Handle)GateMP_module->nameServer,
1378                 obj->nsKey);
1379     }
1381     /* Set the status to 0 */
1382     if (obj->objType != ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC) {
1383         obj->attrs->status = 0;
1384         if (obj->cacheEnabled) {
1385             Cache_wbInv(obj->attrs, sizeof(ti_sdo_ipc_GateMP_Attrs),
1386                     Cache_Type_ALL, TRUE);
1387         }
1388     }
1390     /*
1391      *  If ObjType_LOCAL, memory was allocated from the local system heap.
1392      *  obj->attrs might be NULL if the Memory_alloc failed in Instance_init
1393      */
1394     if (obj->objType == ti_sdo_ipc_Ipc_ObjType_LOCAL && obj->attrs != NULL) {
1395         Memory_free(NULL, obj->attrs, sizeof(ti_sdo_ipc_GateMP_Attrs));
1396     }
1398     switch (obj->remoteProtect) {
1399         case GateMP_RemoteProtect_SYSTEM:
1400             if (obj->gateHandle) {
1401                 systemHandle =
1402                 ti_sdo_ipc_GateMP_RemoteSystemProxy_Handle_downCast2(
1403                         obj->gateHandle);
1404                 ti_sdo_ipc_GateMP_RemoteSystemProxy_delete(&systemHandle);
1405             }
1407             inUseArray = GateMP_module->remoteSystemInUse;
1408             remoteHandles = GateMP_module->remoteSystemGates;
1409             numResources = GateMP_module->numRemoteSystem;
1410             break;
1412         case GateMP_RemoteProtect_CUSTOM1:
1413             if (obj->gateHandle) {
1414                 custom1Handle =
1415                         ti_sdo_ipc_GateMP_RemoteCustom1Proxy_Handle_downCast2(
1416                             obj->gateHandle);
1417                 ti_sdo_ipc_GateMP_RemoteCustom1Proxy_delete(&custom1Handle);
1418             }
1420             inUseArray = GateMP_module->remoteCustom1InUse;
1421             remoteHandles = GateMP_module->remoteCustom1Gates;
1422             numResources = GateMP_module->numRemoteCustom1;
1423             break;
1425         case GateMP_RemoteProtect_CUSTOM2:
1426             if (obj->gateHandle) {
1427                 custom2Handle =
1428                         ti_sdo_ipc_GateMP_RemoteCustom2Proxy_Handle_downCast2(
1429                             obj->gateHandle);
1430                 ti_sdo_ipc_GateMP_RemoteCustom2Proxy_delete(&custom2Handle);
1431             }
1433             inUseArray = GateMP_module->remoteCustom2InUse;
1434             remoteHandles = GateMP_module->remoteCustom2Gates;
1435             numResources = GateMP_module->numRemoteCustom2;
1436             break;
1437         case GateMP_RemoteProtect_NONE:
1438             /*
1439              *  Nothing else to finalize. Any alloc'ed memory has already been
1440              *  freed
1441              */
1442             Log_write2(ti_sdo_ipc_GateMP_LM_delete, (UArg)obj->remoteProtect,
1443                 (UArg)obj->resourceId);
1444             return;
1445         default:
1446             /* Should never be here */
1447             Assert_isTrue(FALSE, ti_sdo_ipc_Ipc_A_internal);
1448             break;
1449     }
1451     /* Clear the handle array entry in local memory */
1452     if (obj->resourceId != (UInt)-1) {
1453         remoteHandles[obj->resourceId] = NULL;
1454     }
1456     if ((obj->objType != ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC) &&
1457         (obj->resourceId != (UInt)-1)) {
1458         /* Clear the resource used flag in shared memory */
1459         if (GateMP_module->defaultGate != NULL) {
1460             systemKey = GateMP_enter((GateMP_Handle)GateMP_module->defaultGate);
1461         }
1462         else {
1463             /* this should only be done when deleting the very last GateMP */
1464             systemKey = Hwi_disable();
1465         }
1467         /* update the GateMP resource tracker */
1468         inUseArray[obj->resourceId] = UNUSED;
1469         if (obj->cacheEnabled) {
1470             Cache_wbInv(inUseArray,
1471                         numResources * sizeof(UInt8),
1472                         Cache_Type_ALL,
1473                         TRUE);
1474         }
1476         if (GateMP_module->defaultGate != NULL) {
1477             GateMP_leave((GateMP_Handle)GateMP_module->defaultGate, systemKey);
1478         }
1479         else {
1480             Hwi_restore(systemKey);
1481         }
1482     }
1484     if (obj->objType == ti_sdo_ipc_Ipc_ObjType_CREATEDYNAMIC_REGION) {
1485         /* Free memory allocated from the region heap */
1486         if (obj->attrs) {
1487             Memory_free(SharedRegion_getHeap(obj->regionId), obj->attrs,
1488                 obj->allocSize);
1489         }
1490     }
1492     Log_write2(ti_sdo_ipc_GateMP_LM_delete, (UArg)obj->remoteProtect,
1493             (UArg)obj->resourceId);
1496 /*
1497  *  ======== ti_sdo_ipc_GateMP_getSharedAddr ========
1498  */
1499 SharedRegion_SRPtr ti_sdo_ipc_GateMP_getSharedAddr(
1500         ti_sdo_ipc_GateMP_Object *obj)
1502     SharedRegion_SRPtr srPtr;
1504     srPtr = SharedRegion_getSRPtr(obj->attrs, obj->regionId);
1506     return (srPtr);
1509 /*
1510  *  ======== ti_sdo_ipc_GateMP_setDefaultRemote ========
1511  */
1512 Void ti_sdo_ipc_GateMP_setDefaultRemote(ti_sdo_ipc_GateMP_Object *obj)
1514     GateMP_module->defaultGate = obj;
1517 /*
1518  *************************************************************************
1519  *                       Internal functions
1520  *************************************************************************
1521  */
1523 /*
1524  *  ======== ti_sdo_ipc_GateMP_getFreeResource ========
1525  */
1526 UInt ti_sdo_ipc_GateMP_getFreeResource(UInt8 *inUse, Int num, Error_Block *eb)
1528     UInt key;
1529     Bool flag = FALSE;
1530     UInt resourceId;
1531     GateMP_Handle defaultGate;
1533     /* Need to look at shared memory. Enter default gate */
1534     defaultGate = GateMP_getDefaultRemote();
1536     if (defaultGate){
1537         key = GateMP_enter(defaultGate);
1538     }
1540     /* Invalidate cache before looking at the in-use flags */
1541     if (SharedRegion_isCacheEnabled(0)) {
1542         Cache_inv(inUse, num * sizeof(UInt8), Cache_Type_ALL, TRUE);
1543     }
1545     /*
1546      *  Find a free resource id. Note: zero is reserved on the
1547      *  system proxy for the default gate.
1548      */
1549     for (resourceId = 0; resourceId < num; resourceId++) {
1550         /*
1551          *  If not in-use, set the inUse to TRUE to prevent other
1552          *  creates from getting this one.
1553          */
1554         if (inUse[resourceId] == UNUSED) {
1555            flag = TRUE;
1557            /* Denote in shared memory that the resource is used */
1558            inUse[resourceId] = USED;
1559            break;
1560        }
1561     }
1563     /* Write-back if a in-use flag was changed */
1564     if (flag == TRUE && SharedRegion_isCacheEnabled(0)) {
1565         Cache_wbInv(inUse, num * sizeof(UInt8), Cache_Type_ALL, TRUE);
1566     }
1568     /* Done with the critical section */
1569     if (defaultGate) {
1570         GateMP_leave(defaultGate, key);
1571     }
1573     if (flag == FALSE) {
1574         resourceId = (UInt)-1;
1575         Error_raise(eb, ti_sdo_ipc_GateMP_E_gateUnavailable, 0, 0);
1576     }
1578     return (resourceId);