EDMA_Status EDMA_mapBaseAddress(void **pvirtAddr)
{
    Int sharedMemId = -1;
    if (NULL == state) {
#ifdef xdc_target__os_Linux
        state = ( EDMA_State *)SHM_getObj(EXAMPLE_gate, sizeof(EDMA_State),
                EDMA_LOCKID, &setInternalState, &sharedMemId);
#else
        state = &myState;
        setInternalState(state);
        sharedMemId = 0;
#endif
        state->sharedMemId = sharedMemId;
    }
    *pvirtAddr = (void **)(state->edma).edmaAddressSpace;
    return (EDMA_OK);
}
static void getInternalState() 
{
    Int sharedMemId = -1;
 
    _resmanInternalState = (IRESMAN_MEMTCM_InternalState *)SHM_getObj(
            _MEMTCM_lock, sizeof(IRESMAN_MEMTCM_InternalState),
            _MEMTCM_LOCKID, &setInternalState, &sharedMemId);

    if ((NULL != _resmanInternalState) && (-1 != sharedMemId)) {

        _resmanInternalState->sharedMemId = sharedMemId;
    }
    else {
        _resmanInternalState = NULL;
        sharedMemId = -1;
    }
}
Пример #3
0
static void getInternalState()
{
#ifdef xdc_target__os_Linux
    Int sharedMemId = -1;

    _resmanInternalState = (IRESMAN_HDVICP_InternalState *)SHM_getObj(gate,
            sizeof(IRESMAN_HDVICP_InternalState), _HDVICP_LOCKID,
            &setInternalState, &sharedMemId);
    _resmanInternalState->sharedMemId = sharedMemId;
#else
    __FAR__ static IRESMAN_HDVICP_InternalState _HDVICP_internalState;

    _resmanInternalState = (IRESMAN_HDVICP_InternalState *)
            &_HDVICP_internalState;
    setInternalState(_resmanInternalState);
    _resmanInternalState->sharedMemId = 0;
#endif
}
int EDMA_init(void)
{
    Int sharedMemId;

#ifdef xdc_target__os_Linux
    state = ( EDMA_State *)SHM_getObj(EXAMPLE_gate, sizeof(EDMA_State),
            EDMA_LOCKID, &setInternalState, &sharedMemId);
#else
    state = &myState;
    setInternalState(state);
    sharedMemId = 0;
#endif

    state->refCount++;

    if (NULL != state) {
        state->sharedMemId = sharedMemId;
    }

    return (1);
}
Пример #5
0
static void getInternalState()
{
    Int sharedMemId = -1;
#ifdef xdc_target__os_Linux

    rmanInternalState = (RMAN_InternalState *)SHM_getObj(gate,
            sizeof(RMAN_InternalState) + (ti_sdo_fc_rman_RMAN_MAXALGS *
            sizeof(RMAN_VtableEntry)), (key_t)_RMAN_LOCKID,
            &setInternalState, &sharedMemId);

    algresVTable = (RMAN_VtableEntry *)((unsigned int)rmanInternalState +
            (unsigned int) (rmanInternalState->info.vTableOffset));
#else
    rmanInternalState = (RMAN_InternalState *)
            &_RMAN_internalState;
    algresVTable = (RMAN_VtableEntry *)(malloc(ti_sdo_fc_rman_RMAN_MAXALGS *
            sizeof(RMAN_VtableEntry)));
    setInternalState(rmanInternalState);
    sharedMemId = 0;
#endif
    rmanInternalState->info.sharedMemId = sharedMemId;
    rmanInternalState->info.refCount++;
}
Пример #6
0
/*
 *  ======== RMP_create ========
 */
RMP_Handle RMP_create(RMP_Attrs *attrs)
{
    RMP_Obj         *handle = NULL;
    Int             shmId = -1;
    unsigned int    shmSize = 0;
    Void            * addr = NULL;
    RMM_Attrs       rmmAttrs;
    static Int shmCount = 0;

    /* Create a shared memory object RMP_Obj using the key and the lock
    Size of this will depend numResources and RMM_Obj etc  */

    Assert_isTrue(shmCount < RMMP_MAXINSTANCES, (Assert_Id)NULL);

    shmSize = sizeof(RMP_Obj) + sizeof(RMM_Obj) + sizeof(UInt32);
    shmSize = ALIGN32(shmSize);
    shmSize += (attrs->maxFreeListBlocks * sizeof(RMM_Header));
    shmSize = ALIGN32(shmSize);

#ifdef xdc_target__os_Linux
    addr = SHM_getObj((GateProcess_Handle_upCast)(attrs->gate), shmSize,
            (key_t)attrs->key, (SHM_InitFxn)&setInternalState, &shmId);
#else
    addr = (void *)malloc(shmSize);
    if (NULL != addr) {
        setInternalState(addr);
        shmId = 0;
    }
#endif

    if (shmId != -1) {
        handle = (RMP_Obj *)addr;

        if (0 == handle->refCount) {
            /* RMM_create has to happen */
            rmmAttrs.segid = shmCount;          /* Use shmCount as segId */
            rmmAttrs.base = attrs->base;
            rmmAttrs.length = attrs->length;
            rmmAttrs.maxFreeListBlocks = attrs->maxFreeListBlocks;
            /* My alloc fxn will use the sharedMem address to increment an
               offset pointer */

            rmmAttrs.allocFxn = shmAlloc;
            rmmAttrs.freeFxn = shmFree;

            /* Store the shmCount in the  SHM_Obj part of the handle */
            handle->shmCount = shmCount;
            shmCount++;
        }

        /* Successful acquisition of shared Mem object, so store in array
           for use by allocFxn */
        shmAddrs[handle->shmCount] = (unsigned int)addr;
        shmIndex[handle->shmCount] = sizeof(RMP_Obj); /* Change this to work for
                the allocFxn */

        if (handle->refCount == 0) {
            /* Whatever the RMM_create returns, store that as an offset from
               shmBase */
            handle->rmmOffset = OFFSET(handle, RMM_create(&rmmAttrs));
        }
        handle->refCount++;

        /* Store the sharedMemId in the RMP_Obj */
        handle->sharedMemId = shmId;
    }

    return (handle);
}
EDMA_Status EDMA_getResource(int devId, int *tcc, int *channel, int *param,
                             int nParams)
{
    EDMA_Status status = EDMA_ENOCHANNEL;
    Bool found = FALSE;
    Int j = 0;
    Int temp = -1;
    Int sharedMemId;
    if (NULL == state) {
#ifdef xdc_target__os_Linux
        state = ( EDMA_State *)SHM_getObj(EXAMPLE_gate, sizeof(EDMA_State),
                EDMA_LOCKID, &setInternalState, &sharedMemId);
#else
        state = (EDMA_State *)&myState;
        setInternalState(state);
        sharedMemId = 0;
#endif
        state->sharedMemId = sharedMemId;
    }

    switch (devId) {

        case EDMA_EDMAANY:

            while (state->symIndex < 64) {
                if ((state->edmaArr[state->symIndex] == 0) &&
                        (state->paramArr[state->symIndex] == 0) &&
                        (state->tccArr[state->symIndex] == 0)) {
                    *channel = state->symIndex;
                    *param   = state->symIndex;
                    *tcc     = state->symIndex;
                    state->edmaArr[state->symIndex] = 1;
                    state->paramArr[state->symIndex] = 1;
                    state->tccArr[state->symIndex] = 1;
                    status = EDMA_OK;
                    state->symIndex++;
                    break;
                }
                else {
                    state->symIndex++;
                }
           }
           break;

       case EDMA_QDMAANY:

        while (state->tccQdmaIndex != state->symIndex) {

            if (*tcc != EDMA_TCCANY) {
                temp = state->tccQdmaIndex;
                state->tccQdmaIndex = *tcc;
            }

            if (state->tccArr[state->tccQdmaIndex] == 0) {

                while ((state->qdmaIndex < 8) &&
                        (state->qdmaArr[state->qdmaIndex] == 1)) {
                    state->qdmaIndex++;
                }

                while ((state->paramAnyIndex < 512) && (state->paramArr[state->paramAnyIndex] == 1)){
                    state->paramAnyIndex++;
                }

                if ((1 == state->qdmaArr[state->qdmaIndex]) ||
                        (1 == state->paramArr[state->paramAnyIndex])) {
                    break;
                }

                *channel = EDMA_QDMA0 + state->qdmaIndex;
                *param   = state->paramAnyIndex;
                *tcc     = state->tccQdmaIndex;
                state->qdmaArr[state->qdmaIndex] = 1;
                state->paramArr[state->paramAnyIndex] = 1;
                state->tccArr[state->tccQdmaIndex] = 1;
                state->qdmaIndex++;
                state->tccQdmaIndex--;
                state->paramAnyIndex++;
                status = EDMA_OK;

                if (temp != -1) {
                    state->tccQdmaIndex = temp;
                }
                break;
            }
            else {
                if (*tcc != EDMA_TCCANY) {
                    break;
                }
                state->tccQdmaIndex--;
            }
       }
       if (temp != -1) {
           state->tccQdmaIndex = temp;
       }
       break;
       case EDMA_PARAMANY:
            while ((state->paramAnyIndex < 512) && (state->paramArr[state->paramAnyIndex] == 1)) {
                state->paramAnyIndex++;
            }
            if (state->paramAnyIndex + nParams < 512) {
                for (j = 0; j < nParams; j++) {
                    state->paramArr[state->paramAnyIndex+j] = 1;
                }
                *param = state->paramAnyIndex;
                state->paramAnyIndex += nParams;
                status = EDMA_OK;
                break;
            }
        break;
       default:
            if (devId < 64) {
                /* Requested and EDMA channel */
                if ((state->edmaArr[devId] == 0) &&
                        (state->paramArr[devId] == 0) &&
                        (state->tccArr[devId] == 0)) {
                    *channel = devId;
                    *param   = devId;
                    *tcc     = devId;
                    state->edmaArr[devId] = 1;
                    state->paramArr[devId] = 1;
                    state->tccArr[devId] = 1;
                    status = EDMA_OK;
                    break;
                }
            }
            else if (devId < 512) {
                /* Requested a PARAM channel */
                for (j = 0; j < nParams; j++) {
                    if (state->paramArr[devId+j] == 0) {
                        found = TRUE;
                        state->paramArr[devId + j] = 1;
                    }
                    else {
                        found = FALSE;
                        break;
                    }
                }
                if (found) {
                    *param = devId;
                    status = EDMA_OK;
                }
            }
            else if (devId <= EDMA_QDMA7) {
                if (state->qdmaArr[devId-EDMA_QDMA0] == 0) {
                    state->qdmaArr[devId-EDMA_QDMA0] = 1;
                    *channel = devId-EDMA_QDMA0;
                }

                while (state->tccQdmaIndex != state->symIndex) {

                    if (state->tccArr[state->tccQdmaIndex] == 0) {

                        while ((state->paramAnyIndex < 512) &&
                                    (state->paramArr[state->paramAnyIndex] == 1)) {
                                state->paramAnyIndex++;
                        }

                        if (1 == state->paramArr[state->paramAnyIndex]) {
                            break;
                        }

                        *param   = state->paramAnyIndex;
                        *tcc     = state->tccQdmaIndex;
                        state->paramArr[state->paramAnyIndex] = 1;
                        state->tccArr[state->tccQdmaIndex] = 1;
                        state->tccQdmaIndex--;
                        state->paramAnyIndex++;
                        status = EDMA_OK;
                        break;
                    }
                    else {
                        state->tccQdmaIndex--;
                    }
                }
            }
        }
        return (status);
}
/*
 *  ======== SMGRMP_create ========
 */
SMGRMP_Handle SMGRMP_create(SMGRMP_Attrs *attrs)
{
    SMGRMP_Obj         *handle;
    Int             shmId = -1;
    unsigned int    shmSize = 0;
    Void            * addr;
    SMGR_Attrs       smgrAttrs;

    /* Create a shared memory object SMGRMP_Obj using the key and the lock 
    Size of this will depend numResources and SMGR_Obj etc  */
   
    GT_assert(CURTRACE, shmCount < SMGRMP_MAXINSTANCES); 

    shmSize = sizeof(SMGRMP_Obj) + sizeof(SMGR_Obj) + sizeof(UInt32); 
    shmSize = ALIGN32(shmSize);
    shmSize += (sizeof(SMGR_Counter) * attrs->numResources);
    shmSize = ALIGN32(shmSize);

#ifdef xdc_target__os_Linux
    addr = SHM_getObj(attrs->lock, shmSize, (key_t)attrs->key, 
            (SHM_InitFxn)&setInternalState, &shmId);
#else
    addr = (void *)malloc(shmSize);
    setInternalState(addr);
    shmId = 0;
#endif

    if (shmId != -1) {

       handle = (SMGRMP_Obj *)addr;

        /* This will return a unique object for each key, and the same object
           for different processes */
        if (0 == handle->refCount) {

            /* SMGR_create has to happen */ 
            smgrAttrs.segid = shmCount;          /* Use shmCount as segId */ 
            smgrAttrs.numResources = attrs->numResources;
            smgrAttrs.numScratchGroups = attrs->numScratchGroups;
            smgrAttrs.allocFxn = shmAlloc;
            smgrAttrs.freeFxn = shmFree;

            /* Store the shmCount in the  SHM_Obj part of the handle */
            handle->shmCount = shmCount;
            shmCount++;
            shmTotal++;
        }
        /* Successful acquisition of shared Mem object, so store in array
           for use by alloc/free functions */ 
        shmAddrs[handle->shmCount] = (unsigned int)addr;
        shmIndex[handle->shmCount] = sizeof(SMGRMP_Obj); /* Change this to 
                                                            work for the alloFxn
                                                          */
        if (handle->refCount == 0) {

            /* Whatever the SMGR_create returns, store that as an offset from 
               shmBase */
            handle->smgrOffset = OFFSET(handle, SMGR_create(&smgrAttrs));
        }

        handle->refCount++;
        /* Store the sharedMemId in the SMGRMP_Obj */ 
        handle->sharedMemId = shmId;
        return (handle);
    }
    else {
        return (NULL);
    }
}