//------------------------------------------------------------------------------ tOplkError pdoucal_getRxPdo(BYTE** ppPdo_p, UINT channelId_p, WORD pdoSize_p) { OPLK_ATOMIC_T readBuf; UNUSED_PARAMETER(pdoSize_p); // Used to avoid compiler warning if OPLK_DCACHE_INVALIDATE is not set // Invalidate data cache for addressed txChannelInfo OPLK_DCACHE_INVALIDATE(&(pPdoMem_l->rxChannelInfo[channelId_p]), sizeof(tPdoBufferInfo)); if (pPdoMem_l->rxChannelInfo[channelId_p].newData) { readBuf = pPdoMem_l->rxChannelInfo[channelId_p].readBuf; OPLK_ATOMIC_EXCHANGE(&pPdoMem_l->rxChannelInfo[channelId_p].cleanBuf, readBuf, pPdoMem_l->rxChannelInfo[channelId_p].readBuf); pPdoMem_l->rxChannelInfo[channelId_p].newData = 0; // Flush data cache for variables changed in this function OPLK_DCACHE_FLUSH(&(pPdoMem_l->rxChannelInfo[channelId_p].readBuf), sizeof(OPLK_ATOMIC_T)); OPLK_DCACHE_FLUSH(&(pPdoMem_l->rxChannelInfo[channelId_p].newData), sizeof(UINT8)); } readBuf = pPdoMem_l->rxChannelInfo[channelId_p].readBuf; *ppPdo_p = pTripleBuf_l[readBuf] + pPdoMem_l->rxChannelInfo[channelId_p].channelOffset; OPLK_DCACHE_INVALIDATE(*ppPdo_p, pdoSize_p); return kErrorOk; }
//------------------------------------------------------------------------------ static tTimesyncSocTime* getSocTime(void) { tTimesyncSocTimeTripleBuf* pTripleBuf; OPLK_ATOMIC_T readBuf; pTripleBuf = &pSharedMemory_l->socTime; OPLK_DCACHE_INVALIDATE(pTripleBuf, sizeof(*pTripleBuf)); if (pTripleBuf->newData) { // Switch triple buffer because there is new data available! readBuf = pTripleBuf->read; OPLK_ATOMIC_EXCHANGE(&pTripleBuf->clean, readBuf, pTripleBuf->read); pTripleBuf->newData = 0; OPLK_DCACHE_FLUSH(&pTripleBuf->clean, sizeof(pTripleBuf->clean)); OPLK_DCACHE_FLUSH(&pTripleBuf->read, sizeof(pTripleBuf->read)); OPLK_DCACHE_FLUSH(&pTripleBuf->newData, sizeof(pTripleBuf->newData)); } readBuf = pTripleBuf->read; // Return reference to read buffer return &pTripleBuf->aTripleBuf[readBuf]; }
//------------------------------------------------------------------------------ tOplkError pdoucal_setTxPdo(UINT channelId_p, BYTE* pPdo_p, WORD pdoSize_p) { OPLK_ATOMIC_T temp; UNUSED_PARAMETER(pPdo_p); // Used to avoid compiler warning if OPLK_DCACHE_FLUSH is not set UNUSED_PARAMETER(pdoSize_p); // Used to avoid compiler warning if OPLK_DCACHE_FLUSH is not set OPLK_DCACHE_FLUSH(pPdo_p, pdoSize_p); //TRACE("%s() chan:%d wi:%d\n", __func__, channelId_p, pPdoMem_l->txChannelInfo[channelId_p].writeBuf); // Invalidate data cache already done in pdoucal_getTxPdoAdrs() temp = pPdoMem_l->txChannelInfo[channelId_p].writeBuf; OPLK_ATOMIC_EXCHANGE(&pPdoMem_l->txChannelInfo[channelId_p].cleanBuf, temp, pPdoMem_l->txChannelInfo[channelId_p].writeBuf); pPdoMem_l->txChannelInfo[channelId_p].newData = 1; // Flush data cache for variables changed in this function OPLK_DCACHE_FLUSH(&(pPdoMem_l->txChannelInfo[channelId_p].writeBuf), sizeof(OPLK_ATOMIC_T)); OPLK_DCACHE_FLUSH(&(pPdoMem_l->txChannelInfo[channelId_p].newData), sizeof(UINT8)); //TRACE("%s() chan:%d new wi:%d\n", __func__, channelId_p, pPdoMem_l->txChannelInfo[channelId_p].writeBuf); return kErrorOk; }
//------------------------------------------------------------------------------ static tOplkError setNetTime(void) { OPLK_ATOMIC_T writeBuf; tOplkError ret = kErrorOk; BOOL fValidSystemTime = FALSE; writeBuf = instance_l.pSharedMemory->userToKernelSocTime.write; // Get system clock time ret = target_getSystemTime(&instance_l.pSharedMemory->userToKernelSocTime.aTripleBuf[writeBuf].netTime, &fValidSystemTime); if (ret != kErrorOk) { DEBUG_LVL_ERROR_TRACE("%s Failed to get current system time!\n", __func__); return ret; } if (fValidSystemTime) { OPLK_ATOMIC_EXCHANGE(&instance_l.pSharedMemory->userToKernelSocTime.clean, writeBuf, instance_l.pSharedMemory->userToKernelSocTime.write); // Set the newData flag to indicate that a new data is available in the shared buffer instance_l.pSharedMemory->userToKernelSocTime.newData = 1; // Flush data cache for variables changed in this function OPLK_DCACHE_FLUSH(&instance_l.pSharedMemory->userToKernelSocTime.write, sizeof(OPLK_ATOMIC_T)); OPLK_DCACHE_FLUSH(&instance_l.pSharedMemory->userToKernelSocTime.newData, sizeof(UINT8)); } return ret; }
//------------------------------------------------------------------------------ void errhndkcal_setMnCnLossPresThresholdCnt(UINT nodeIdx_p, UINT32 thresholdCnt_p) { pErrHndObjects_l->aMnCnLossPres[nodeIdx_p].thresholdCnt = thresholdCnt_p; OPLK_DCACHE_FLUSH(&pErrHndObjects_l->aMnCnLossPres[nodeIdx_p], sizeof(tErrorObject)); }
//------------------------------------------------------------------------------ tOplkError timesynck_init(void) { tOplkError ret; OPLK_MEMSET(×ynckInstance_l, 0, sizeof(timesynckInstance_l)); timesynckInstance_l.syncEventCycle = 1; // Default every cycle ret = timesynckcal_init(); if (ret != kErrorOk) return ret; #if defined(CONFIG_INCLUDE_SOC_TIME_FORWARD) timesynckInstance_l.pSharedMemory = timesynckcal_getSharedMemory(); if (timesynckInstance_l.pSharedMemory == NULL) return kErrorNoResource; // Initialize shared memory OPLK_MEMSET(timesynckInstance_l.pSharedMemory, 0, sizeof(*timesynckInstance_l.pSharedMemory)); // Initialize triple buffer timesynckInstance_l.pSharedMemory->kernelToUserSocTime.clean = 0; timesynckInstance_l.pSharedMemory->kernelToUserSocTime.read = 1; timesynckInstance_l.pSharedMemory->kernelToUserSocTime.write = 2; OPLK_DCACHE_FLUSH(timesynckInstance_l.pSharedMemory, sizeof(*timesynckInstance_l.pSharedMemory)); #endif return ret; }
//------------------------------------------------------------------------------ void errhndkcal_setMnCycTimeExceedCounters(UINT32 cumulativeCnt_p, UINT32 thresholdCnt_p) { pErrHndObjects_l->mnCycTimeExceed.cumulativeCnt = cumulativeCnt_p; pErrHndObjects_l->mnCycTimeExceed.thresholdCnt = thresholdCnt_p; OPLK_DCACHE_FLUSH(&pErrHndObjects_l->mnCycTimeExceed, sizeof(tErrorObject)); }
//------------------------------------------------------------------------------ void errhndkcal_setCnCrcCounters(UINT32 cumulativeCnt_p, UINT32 thresholdCnt_p) { pErrHndObjects_l->cnCrcErr.cumulativeCnt = cumulativeCnt_p; pErrHndObjects_l->cnCrcErr.thresholdCnt = thresholdCnt_p; OPLK_DCACHE_FLUSH(&pErrHndObjects_l->cnCrcErr, sizeof(tErrorObject)); }
//------------------------------------------------------------------------------ tOplkError timesynck_getNetTime(tNetTime* pNetTime_p, BOOL* pNewData_p) { OPLK_ATOMIC_T readBuf; if ((timesynckInstance_l.pSharedMemory == NULL) || (pNetTime_p == NULL) || (pNewData_p == NULL)) { DEBUG_LVL_ERROR_TRACE("%s Pointer to memory is invalid!\n", __func__); return kErrorNoResource; } if (timesynckInstance_l.pSharedMemory->userToKernelSocTime.newData) { *pNewData_p = TRUE; readBuf = timesynckInstance_l.pSharedMemory->userToKernelSocTime.read; OPLK_ATOMIC_EXCHANGE(×ynckInstance_l.pSharedMemory->userToKernelSocTime.clean, readBuf, timesynckInstance_l.pSharedMemory->userToKernelSocTime.read); // Once the read from buffer is done, reset the newData timesynckInstance_l.pSharedMemory->userToKernelSocTime.newData = 0; // Flush data cache for variables changed in this function OPLK_DCACHE_FLUSH(×ynckInstance_l.pSharedMemory->userToKernelSocTime.read, sizeof(OPLK_ATOMIC_T)); OPLK_DCACHE_FLUSH(×ynckInstance_l.pSharedMemory->userToKernelSocTime.newData, sizeof(UINT8)); pNetTime_p->nsec = timesynckInstance_l.pSharedMemory->userToKernelSocTime.aTripleBuf[0].netTime.nsec; pNetTime_p->sec = timesynckInstance_l.pSharedMemory->userToKernelSocTime.aTripleBuf[0].netTime.sec; } else *pNewData_p = FALSE; return kErrorOk; }
//------------------------------------------------------------------------------ tOplkError timesynck_setSocTime(const tTimesyncSocTime* pSocTime_p) { tTimesyncSocTimeTripleBuf* pTripleBuf; OPLK_ATOMIC_T writeBuf; tTimesyncSocTime* pBuffer; // Check parameter validity ASSERT(pSocTime_p != NULL); if (timesynckInstance_l.pSharedMemory == NULL) { // Looks like the CAL has no SoC time forward support, but feature is // enabled! DEBUG_LVL_ERROR_TRACE("%s Pointer to shared memory is invalid!\n", __func__); return kErrorNoResource; } pTripleBuf = ×ynckInstance_l.pSharedMemory->kernelToUserSocTime; OPLK_DCACHE_INVALIDATE(pTripleBuf, sizeof(*pTripleBuf)); writeBuf = pTripleBuf->write; pBuffer = &pTripleBuf->aTripleBuf[writeBuf]; OPLK_MEMCPY(pBuffer, pSocTime_p, sizeof(*pBuffer)); OPLK_ATOMIC_EXCHANGE(&pTripleBuf->clean, writeBuf, pTripleBuf->write); pTripleBuf->newData = 1; OPLK_DCACHE_FLUSH(&pTripleBuf->clean, sizeof(pTripleBuf->clean)); OPLK_DCACHE_FLUSH(&pTripleBuf->write, sizeof(pTripleBuf->write)); OPLK_DCACHE_FLUSH(&pTripleBuf->newData, sizeof(pTripleBuf->newData)); return kErrorOk; }
//------------------------------------------------------------------------------ void errhndkcal_setMnCycTimeExceedThresholdCnt(UINT32 thresholdCnt_p) { pErrHndObjects_l->mnCycTimeExceed.thresholdCnt = thresholdCnt_p; OPLK_DCACHE_FLUSH(&pErrHndObjects_l->mnCycTimeExceed, sizeof(tErrorObject)); }
//------------------------------------------------------------------------------ void errhndkcal_setMnCrcThresholdCnt(UINT32 thresholdCnt_p) { pErrHndObjects_l->mnCrcErr.thresholdCnt = thresholdCnt_p; OPLK_DCACHE_FLUSH(&pErrHndObjects_l->mnCrcErr, sizeof(tErrorObject)); }
//------------------------------------------------------------------------------ void errhndkcal_setLossPreqThresholdCnt(UINT32 thresholdCnt_p) { pErrHndObjects_l->cnLossPreq.thresholdCnt = thresholdCnt_p; OPLK_DCACHE_FLUSH(&pErrHndObjects_l->cnLossPreq, sizeof(tErrorObject)); }