/* * ======== NotifyDriverShm_sharedMemReq ======== */ SizeT NotifyDriverShm_sharedMemReq(const NotifyDriverShm_Params *params) { UInt16 regionId; SizeT regionCacheSize; SizeT minAlign, memReq; /* Ensure that params is non-NULL */ Assert_isTrue(params != NULL, ti_sdo_ipc_Ipc_A_internal); /* * Determine obj->cacheEnabled using params->cacheEnabled and SharedRegion * cache flag setting, if applicable. */ minAlign = params->cacheLineSize; if (minAlign == 0) { /* Fix alignment of zero */ minAlign = sizeof(Ptr); } regionId = SharedRegion_getId(params->sharedAddr); if (regionId != SharedRegion_INVALIDREGIONID) { regionCacheSize = SharedRegion_getCacheLineSize(regionId); /* Override minAlign if the region cache line size is smaller */ if (regionCacheSize < minAlign) { minAlign = regionCacheSize; } } /* Determine obj->align which will be used to _Ipc_roundup addresses */ memReq = ((_Ipc_roundup(sizeof(NotifyDriverShm_ProcCtrl), minAlign)) * 2) + ((_Ipc_roundup(sizeof(NotifyDriverShm_EventEntry), minAlign) * 2 * ti_sdo_ipc_Notify_numEvents)); return (memReq); }
/* * ======== TransportShm_sharedMemReq ======== */ SizeT TransportShm_sharedMemReq(const TransportShm_Params *params) { SizeT memReq, minAlign; UInt16 regionId; ListMP_Params listMPParams; regionId = SharedRegion_getId(params->sharedAddr); minAlign = Memory_getMaxDefaultTypeAlign(); if (SharedRegion_getCacheLineSize(regionId) > minAlign) { minAlign = SharedRegion_getCacheLineSize(regionId); } /* for the Attrs structure */ memReq = _Ipc_roundup(sizeof(TransportShm_Attrs), minAlign); /* for the second Attrs structure */ memReq += _Ipc_roundup(sizeof(TransportShm_Attrs), minAlign); ListMP_Params_init(&listMPParams); listMPParams.regionId = regionId; /* for localListMP */ memReq += ListMP_sharedMemReq(&listMPParams); /* for remoteListMP */ memReq += ListMP_sharedMemReq(&listMPParams); return(memReq); }
/* * ======== GateAAMonitor_Instance_init ======== */ Int GateAAMonitor_Instance_init(GateAAMonitor_Object *obj, IGateProvider_Handle localGate, const GateAAMonitor_Params *params, Error_Block *eb) { /* Assert that params->sharedAddr is valid */ Assert_isTrue( (UInt32)params->sharedAddr >= GateAAMonitor_SL2_RANGE_BASE && (UInt32)params->sharedAddr < GateAAMonitor_SL2_RANGE_MAX, GateAAMonitor_A_invSharedAddr); obj->localGate = localGate; obj->sharedAddr = (Ptr)_Ipc_roundup(params->sharedAddr, GateAAMonitor_CACHELINE_SIZE); obj->nested = 0; if (!params->openFlag) { /* * The processor that inits the AAM initializes the value * to zero (e.g. no one is using it). The other processors * must invalidate the memory in case it is in cache. */ *(obj->sharedAddr) = 0; Cache_wbInv((Ptr)obj->sharedAddr, GateAAMonitor_CACHELINE_SIZE, Cache_Type_ALL, TRUE); } else { /* Opening. */ Cache_inv((Ptr)obj->sharedAddr, GateAAMonitor_CACHELINE_SIZE, Cache_Type_ALL, TRUE); } return (0); }
/* * ======== ListMP_sharedMemReq ======== */ SizeT ListMP_sharedMemReq(const ListMP_Params *params) { SizeT memReq, minAlign; UInt16 regionId; if (params->sharedAddr == NULL) { regionId = params->regionId; } else { regionId = SharedRegion_getId(params->sharedAddr); } /* Assert that the region is valid */ Assert_isTrue(regionId != SharedRegion_INVALIDREGIONID, ti_sdo_ipc_Ipc_A_addrNotInSharedRegion); minAlign = Memory_getMaxDefaultTypeAlign(); if (SharedRegion_getCacheLineSize(regionId) > minAlign) { minAlign = SharedRegion_getCacheLineSize(regionId); } memReq = _Ipc_roundup(sizeof(ti_sdo_ipc_ListMP_Attrs), minAlign); return (memReq); }
/* * ======== SemaphoreMP_sharedMemReq ======== */ SizeT SemaphoreMP_sharedMemReq(const SemaphoreMP_Params *params) { SizeT memReq, minAlign; ListMP_Params listMPParams; UInt16 regionId; if (params->sharedAddr == NULL) { regionId = params->regionId; } else { regionId = SharedRegion_getId(params->sharedAddr); } Assert_isTrue(regionId != SharedRegion_INVALIDREGIONID, ti_sdo_ipc_Ipc_A_internal); minAlign = SharedRegion_getCacheLineSize(regionId); memReq = _Ipc_roundup(sizeof(SemaphoreMP_Attrs), minAlign); /* * Add size of ListMP Attrs. No need to init params since it's not used * to create. */ ListMP_Params_init(&listMPParams); listMPParams.regionId = regionId; memReq += ListMP_sharedMemReq(&listMPParams); return (memReq); }
/* * ======== ti_sdo_ipc_Ipc_reservedSizePerProc ======== */ SizeT ti_sdo_ipc_Ipc_reservedSizePerProc(Void) { SizeT reservedSize = sizeof(ti_sdo_ipc_Ipc_Reserved) * ti_sdo_utils_MultiProc_numProcsInCluster; SizeT cacheLineSize = SharedRegion_getCacheLineSize(0); /* Calculate amount to reserve per processor */ if (cacheLineSize > reservedSize) { /* Use cacheLineSize if larger than reservedSize */ reservedSize = cacheLineSize; } else { /* Round reservedSize to cacheLineSize */ reservedSize = _Ipc_roundup(reservedSize, cacheLineSize); } return (reservedSize); }
/* * ======== NotifyDriverShm_Instance_init ======== */ Int NotifyDriverShm_Instance_init(NotifyDriverShm_Object *obj, const NotifyDriverShm_Params *params, Error_Block *eb) { UInt16 regionId; SizeT regionCacheSize, minAlign, procCtrlSize; /* * 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); /* * Determine obj->cacheEnabled using params->cacheEnabled and SharedRegion * cache flag setting, if applicable. */ obj->cacheEnabled = params->cacheEnabled; minAlign = params->cacheLineSize; if (minAlign == 0) { /* Fix alignment of zero */ minAlign = sizeof(Ptr); } regionId = SharedRegion_getId(params->sharedAddr); if (regionId != SharedRegion_INVALIDREGIONID) { /* * Override the user cacheEnabled setting if the region * cacheEnabled is FALSE. */ if (!SharedRegion_isCacheEnabled(regionId)) { obj->cacheEnabled = FALSE; } regionCacheSize = SharedRegion_getCacheLineSize(regionId); /* * Override the user cache line size setting if the region * cache line size is smaller. */ if (regionCacheSize < minAlign) { minAlign = regionCacheSize; } } /* Check if shared memory base addr is aligned to cache line boundary.*/ Assert_isTrue ((UInt32)params->sharedAddr % minAlign == 0, ti_sdo_ipc_Ipc_A_addrNotCacheAligned); obj->remoteProcId = params->remoteProcId; /* * Store all interrupt information so it may be used (if neccessary) by * the IInterrupt delegates */ obj->intInfo.remoteIntId = params->remoteIntId; obj->intInfo.localIntId = params->localIntId; obj->intInfo.intVectorId = params->intVectorId; obj->nesting = 0; if (params->remoteProcId > MultiProc_self()) { obj->selfId = 0; obj->otherId = 1; } else { obj->selfId = 1; obj->otherId = 0; } /* Initialize pointers to shared memory regions */ procCtrlSize = _Ipc_roundup(sizeof(NotifyDriverShm_ProcCtrl), minAlign); /* * Save the eventEntrySize in obj since we will need it at runtime to * index the event charts */ obj->eventEntrySize = _Ipc_roundup(sizeof(NotifyDriverShm_EventEntry), minAlign); obj->selfProcCtrl = (NotifyDriverShm_ProcCtrl *) ((UInt32)params->sharedAddr + (obj->selfId * procCtrlSize)); obj->otherProcCtrl = (NotifyDriverShm_ProcCtrl *) ((UInt32)params->sharedAddr + (obj->otherId * procCtrlSize)); obj->selfEventChart = (NotifyDriverShm_EventEntry *) ((UInt32)params->sharedAddr + (2 * procCtrlSize) + (obj->eventEntrySize * ti_sdo_ipc_Notify_numEvents * obj->selfId)); obj->otherEventChart = (NotifyDriverShm_EventEntry *) ((UInt32)params->sharedAddr + (2 * procCtrlSize) + (obj->eventEntrySize * ti_sdo_ipc_Notify_numEvents * obj->otherId)); /* Allocate memory for regChart and init to (UInt32)-1 (unregistered) */ obj->regChart = Memory_valloc( NotifyDriverShm_Object_heap(), (sizeof(UInt32) * ti_sdo_ipc_Notify_numEvents), NULL, ~0, eb); if (obj->regChart == NULL) { return (1); } /* Enable all events initially.*/ obj->selfProcCtrl->eventEnableMask = 0xFFFFFFFF; /* Write back our own ProcCtrl */ if (obj->cacheEnabled) { Cache_wbInv(obj->selfProcCtrl, sizeof(NotifyDriverShm_ProcCtrl), Cache_Type_ALL, TRUE); } /* Register the incoming interrupt */ NotifyDriverShm_InterruptProxy_intRegister(obj->remoteProcId, &(obj->intInfo), (Fxn)NotifyDriverShm_isr, (UArg)obj); return (0); }
/* * ======== SemaphoreMP_Instance_init ======== */ Int SemaphoreMP_Instance_init(SemaphoreMP_Object *obj, Int count, const SemaphoreMP_Params *params, Error_Block *eb) { Ptr localAddr; Int status; IHeap_Handle regionHeap; ListMP_Params listMPParams; SharedRegion_SRPtr sharedShmBase; if (params->openFlag) { /* Open by sharedAddr */ obj->objType = ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC; obj->attrs = (SemaphoreMP_Attrs *)params->sharedAddr; obj->regionId = SharedRegion_getId(obj->attrs); obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId); obj->mode = (SemaphoreMP_Mode)obj->attrs->mode; regionHeap = SharedRegion_getHeap(obj->regionId); Assert_isTrue(regionHeap != NULL, ti_sdo_ipc_SharedRegion_A_noHeap); /* get the local address of the SRPtr */ localAddr = SharedRegion_getPtr(obj->attrs->gateMPAddr); status = GateMP_openByAddr(localAddr, (GateMP_Handle *)&(obj->gate)); if (status < 0) { return (1); } /* Open the ListMP */ localAddr = (Ptr)_Ipc_roundup( (UInt32)obj->attrs + sizeof(SemaphoreMP_Attrs), SharedRegion_getCacheLineSize(obj->regionId)); status = ListMP_openByAddr(localAddr, (ListMP_Handle *)&(obj->pendQ)); if (status < 0) { /* obj->freeList set to NULL */ return (4); } return (0); } /* init the gate */ if (params->gate != NULL) { obj->gate = params->gate; } else { obj->gate = (ti_sdo_ipc_GateMP_Handle)GateMP_getDefaultRemote(); } obj->mode = params->mode; if (params->sharedAddr == NULL) { /* Creating using a shared region ID */ obj->objType = ti_sdo_ipc_Ipc_ObjType_CREATEDYNAMIC_REGION; obj->regionId = params->regionId; obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId); /* Need to allocate from the heap */ obj->allocSize = SemaphoreMP_sharedMemReq(params); regionHeap = SharedRegion_getHeap(obj->regionId); Assert_isTrue(regionHeap != NULL, ti_sdo_ipc_SharedRegion_A_noHeap); /* The region heap will take care of the alignment */ obj->attrs = Memory_alloc(regionHeap, obj->allocSize, 0, eb); if (obj->attrs == NULL) { return (2); } } else { /* Creating using sharedAddr */ obj->regionId = SharedRegion_getId(params->sharedAddr); /* Assert that the buffer is in a valid shared region */ Assert_isTrue(obj->regionId != SharedRegion_INVALIDREGIONID, ti_sdo_ipc_Ipc_A_addrNotInSharedRegion); /* Assert that sharedAddr is cache aligned */ Assert_isTrue(((UInt32)params->sharedAddr % SharedRegion_getCacheLineSize(obj->regionId) == 0), ti_sdo_ipc_Ipc_A_addrNotCacheAligned); /* set object's cacheEnabled, objType, and attrs */ obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId); obj->objType = ti_sdo_ipc_Ipc_ObjType_CREATEDYNAMIC; obj->attrs = (SemaphoreMP_Attrs *)params->sharedAddr; } /* Store the GateMP sharedAddr in the SemaphoreMP Attrs */ obj->attrs->gateMPAddr = ti_sdo_ipc_GateMP_getSharedAddr(obj->gate); obj->attrs->mode = (Bits16)obj->mode; obj->attrs->count = count; /* Create the freeList */ ListMP_Params_init(&listMPParams); listMPParams.sharedAddr = (Ptr)_Ipc_roundup((UInt32)obj->attrs + sizeof(SemaphoreMP_Attrs), SharedRegion_getCacheLineSize(obj->regionId)); listMPParams.gate = (GateMP_Handle)obj->gate; obj->pendQ = (ti_sdo_ipc_ListMP_Handle)ListMP_create(&listMPParams); if (obj->pendQ == NULL) { return (3); } /* Last thing, set the status */ obj->attrs->status = SemaphoreMP_CREATED; if (obj->cacheEnabled) { Cache_wbInv(obj->attrs, sizeof(SemaphoreMP_Attrs), Cache_Type_ALL, TRUE); } /* Add entry to NameServer */ if (params->name != NULL) { /* We will store a shared pointer in the NameServer */ sharedShmBase = SharedRegion_getSRPtr(obj->attrs, obj->regionId); obj->nsKey = NameServer_addUInt32((NameServer_Handle) SemaphoreMP_module->nameServer, params->name, (UInt32)sharedShmBase); if (obj->nsKey == NULL) { /* NameServer_addUInt32 failed */ return (4); } } return (0); }
/* * ======== TransportShm_Instance_init ======== */ Int TransportShm_Instance_init(TransportShm_Object *obj, UInt16 procId, const TransportShm_Params *params, Error_Block *eb) { Int localIndex; Int remoteIndex; Int status; Bool flag; UInt32 minAlign; ListMP_Params listMPParams[2]; Swi_Handle swiHandle; Swi_Params swiParams; Ptr localAddr; swiHandle = TransportShm_Instance_State_swiObj(obj); /* * Determine who gets the '0' slot in shared memory and who gets * the '1' slot. The '0' slot is given to the lower MultiProc id. */ if (MultiProc_self() < procId) { localIndex = 0; remoteIndex = 1; } else { localIndex = 1; remoteIndex = 0; } if (params->openFlag) { /* Open by sharedAddr */ obj->objType = ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC; obj->self = (TransportShm_Attrs *)params->sharedAddr; obj->regionId = SharedRegion_getId(params->sharedAddr); obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId); localAddr = SharedRegion_getPtr(obj->self->gateMPAddr); status = GateMP_openByAddr(localAddr, (GateMP_Handle *)&obj->gate); if (status < 0) { Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0); return(1); } } else { /* init the gate for ListMP create below */ if (params->gate != NULL) { obj->gate = params->gate; } else { obj->gate = (ti_sdo_ipc_GateMP_Handle)GateMP_getDefaultRemote(); } /* Creating using sharedAddr */ obj->regionId = SharedRegion_getId(params->sharedAddr); /* Assert that the buffer is in a valid shared region */ Assert_isTrue(obj->regionId != SharedRegion_INVALIDREGIONID, ti_sdo_ipc_Ipc_A_addrNotInSharedRegion); /* Assert that sharedAddr is cache aligned */ Assert_isTrue(((UInt32)params->sharedAddr % SharedRegion_getCacheLineSize(obj->regionId) == 0), ti_sdo_ipc_Ipc_A_addrNotCacheAligned); /* set object's cacheEnabled, type, self */ obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId); obj->objType = ti_sdo_ipc_Ipc_ObjType_CREATEDYNAMIC; obj->self = (TransportShm_Attrs *)params->sharedAddr; } /* determine the minimum alignment to align to */ minAlign = Memory_getMaxDefaultTypeAlign(); if (SharedRegion_getCacheLineSize(obj->regionId) > minAlign) { minAlign = SharedRegion_getCacheLineSize(obj->regionId); } /* * Carve up the shared memory. * If cache is enabled, these need to be on separate cache lines. * This is done with minAlign and _Ipc_roundup function. */ obj->other = (TransportShm_Attrs *)((UInt32)(obj->self) + (_Ipc_roundup(sizeof(TransportShm_Attrs), minAlign))); ListMP_Params_init(&(listMPParams[0])); listMPParams[0].gate = (GateMP_Handle)obj->gate; listMPParams[0].sharedAddr = (UInt32 *)((UInt32)(obj->other) + (_Ipc_roundup(sizeof(TransportShm_Attrs), minAlign))); ListMP_Params_init(&listMPParams[1]); listMPParams[1].gate = (GateMP_Handle)obj->gate; listMPParams[1].sharedAddr = (UInt32 *)((UInt32)(listMPParams[0].sharedAddr) + ListMP_sharedMemReq(&listMPParams[0])); obj->priority = params->priority; obj->remoteProcId = procId; Swi_Params_init(&swiParams); swiParams.arg0 = (UArg)obj; Swi_construct(Swi_struct(swiHandle), (Swi_FuncPtr)TransportShm_swiFxn, &swiParams, eb); if (params->openFlag == FALSE) { obj->localList = (ti_sdo_ipc_ListMP_Handle) ListMP_create(&(listMPParams[localIndex])); if (obj->localList == NULL) { Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0); return (2); } obj->remoteList = (ti_sdo_ipc_ListMP_Handle) ListMP_create(&(listMPParams[remoteIndex])); if (obj->localList == NULL) { Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0); return (2); } } else { /* Open the local ListMP instance */ status = ListMP_openByAddr(listMPParams[localIndex].sharedAddr, (ListMP_Handle *)&(obj->localList)); if (status < 0) { Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0); return (2); } /* Open the remote ListMP instance */ status = ListMP_openByAddr(listMPParams[remoteIndex].sharedAddr, (ListMP_Handle *)&(obj->remoteList)); if (status < 0) { Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0); return (2); } } /* register the event with Notify */ status = Notify_registerEventSingle( procId, /* remoteProcId */ 0, /* lineId */ TransportShm_notifyEventId, (Notify_FnNotifyCbck)TransportShm_notifyFxn, (UArg)swiHandle); if (status < 0) { Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0); return (3); } /* Register the transport with MessageQ */ flag = ti_sdo_ipc_MessageQ_registerTransport( TransportShm_Handle_upCast(obj), procId, params->priority); if (flag == FALSE) { Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0); return (4); } if (params->openFlag == FALSE) { obj->self->creatorProcId = MultiProc_self(); obj->self->notifyEventId = TransportShm_notifyEventId; obj->self->priority = obj->priority; /* Store the GateMP sharedAddr in the Attrs */ obj->self->gateMPAddr = ti_sdo_ipc_GateMP_getSharedAddr(obj->gate); obj->self->flag = TransportShm_UP; if (obj->cacheEnabled) { Cache_wbInv(obj->self, sizeof(TransportShm_Attrs), Cache_Type_ALL, TRUE); } } else { obj->other->flag = TransportShm_UP; if (obj->cacheEnabled) { Cache_wbInv(&(obj->other->flag), minAlign, Cache_Type_ALL, TRUE); } } obj->status = TransportShm_UP; return (0); }