| /**************************************************************************** |
| |
| (c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29 |
| www.systec-electronic.com |
| |
| Project: openPOWERLINK |
| |
| Description: source file for kernel DLL Communication Abstraction Layer module |
| |
| License: |
| |
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the following conditions |
| are met: |
| |
| 1. Redistributions of source code must retain the above copyright |
| notice, this list of conditions and the following disclaimer. |
| |
| 2. Redistributions in binary form must reproduce the above copyright |
| notice, this list of conditions and the following disclaimer in the |
| documentation and/or other materials provided with the distribution. |
| |
| 3. Neither the name of SYSTEC electronic GmbH nor the names of its |
| contributors may be used to endorse or promote products derived |
| from this software without prior written permission. For written |
| permission, please contact info@systec-electronic.com. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN |
| ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| POSSIBILITY OF SUCH DAMAGE. |
| |
| Severability Clause: |
| |
| If a provision of this License is or becomes illegal, invalid or |
| unenforceable in any jurisdiction, that shall not affect: |
| 1. the validity or enforceability in that jurisdiction of any other |
| provision of this License; or |
| 2. the validity or enforceability in other jurisdictions of that or |
| any other provision of this License. |
| |
| ------------------------------------------------------------------------- |
| |
| $RCSfile: EplDllkCal.c,v $ |
| |
| $Author: D.Krueger $ |
| |
| $Revision: 1.7 $ $Date: 2008/11/13 17:13:09 $ |
| |
| $State: Exp $ |
| |
| Build Environment: |
| GCC V3.4 |
| |
| ------------------------------------------------------------------------- |
| |
| Revision History: |
| |
| 2006/06/15 d.k.: start of the implementation, version 1.00 |
| |
| ****************************************************************************/ |
| |
| #include "kernel/EplDllkCal.h" |
| #include "kernel/EplDllk.h" |
| #include "kernel/EplEventk.h" |
| |
| #include "EplDllCal.h" |
| #ifndef EPL_NO_FIFO |
| #include "SharedBuff.h" |
| #endif |
| |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0) |
| /***************************************************************************/ |
| /* */ |
| /* */ |
| /* G L O B A L D E F I N I T I O N S */ |
| /* */ |
| /* */ |
| /***************************************************************************/ |
| |
| //--------------------------------------------------------------------------- |
| // const defines |
| //--------------------------------------------------------------------------- |
| |
| #ifndef min |
| #define min(a,b) (((a) < (b)) ? (a) : (b)) |
| #endif |
| |
| //--------------------------------------------------------------------------- |
| // local types |
| //--------------------------------------------------------------------------- |
| |
| //--------------------------------------------------------------------------- |
| // modul globale vars |
| //--------------------------------------------------------------------------- |
| |
| //--------------------------------------------------------------------------- |
| // local function prototypes |
| //--------------------------------------------------------------------------- |
| |
| /***************************************************************************/ |
| /* */ |
| /* */ |
| /* C L A S S EplDllkCal */ |
| /* */ |
| /* */ |
| /***************************************************************************/ |
| // |
| // Description: |
| // |
| // |
| /***************************************************************************/ |
| |
| //=========================================================================// |
| // // |
| // P R I V A T E D E F I N I T I O N S // |
| // // |
| //=========================================================================// |
| |
| //--------------------------------------------------------------------------- |
| // const defines |
| //--------------------------------------------------------------------------- |
| |
| #define EPL_DLLKCAL_MAX_QUEUES 5 // CnGenReq, CnNmtReq, {MnGenReq, MnNmtReq}, MnIdentReq, MnStatusReq |
| |
| //--------------------------------------------------------------------------- |
| // local types |
| //--------------------------------------------------------------------------- |
| |
| typedef struct { |
| #ifndef EPL_NO_FIFO |
| // tShbInstance m_ShbInstanceRx; // FIFO for Rx ASnd frames |
| tShbInstance m_ShbInstanceTxNmt; // FIFO for Tx frames with NMT request priority |
| tShbInstance m_ShbInstanceTxGen; // FIFO for Tx frames with generic priority |
| #else |
| unsigned int m_uiFrameSizeNmt; |
| u8 m_abFrameNmt[1500]; |
| unsigned int m_uiFrameSizeGen; |
| u8 m_abFrameGen[1500]; |
| #endif |
| |
| tEplDllkCalStatistics m_Statistics; |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| // IdentRequest queue with CN node IDs |
| unsigned int m_auiQueueIdentReq[EPL_D_NMT_MaxCNNumber_U8 + 1]; // 1 entry is reserved to distinguish between full and empty |
| unsigned int m_uiWriteIdentReq; |
| unsigned int m_uiReadIdentReq; |
| |
| // StatusRequest queue with CN node IDs |
| unsigned int m_auiQueueStatusReq[EPL_D_NMT_MaxCNNumber_U8 + 1]; // 1 entry is reserved to distinguish between full and empty |
| unsigned int m_uiWriteStatusReq; |
| unsigned int m_uiReadStatusReq; |
| |
| unsigned int m_auiQueueCnRequests[254 * 2]; |
| // first 254 entries represent the generic requests of the corresponding node |
| // second 254 entries represent the NMT requests of the corresponding node |
| unsigned int m_uiNextQueueCnRequest; |
| unsigned int m_uiNextRequestQueue; |
| #endif |
| |
| } tEplDllkCalInstance; |
| |
| //--------------------------------------------------------------------------- |
| // local vars |
| //--------------------------------------------------------------------------- |
| |
| // if no dynamic memory allocation shall be used |
| // define structures statically |
| static tEplDllkCalInstance EplDllkCalInstance_g; |
| |
| //--------------------------------------------------------------------------- |
| // local function prototypes |
| //--------------------------------------------------------------------------- |
| |
| //=========================================================================// |
| // // |
| // P U B L I C F U N C T I O N S // |
| // // |
| //=========================================================================// |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplDllkCalAddInstance() |
| // |
| // Description: add and initialize new instance of DLL CAL module |
| // |
| // Parameters: none |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel EplDllkCalAddInstance(void) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| #ifndef EPL_NO_FIFO |
| tShbError ShbError; |
| unsigned int fShbNewCreated; |
| |
| /* ShbError = ShbCirAllocBuffer (EPL_DLLCAL_BUFFER_SIZE_RX, EPL_DLLCAL_BUFFER_ID_RX, |
| &EplDllkCalInstance_g.m_ShbInstanceRx, &fShbNewCreated); |
| // returns kShbOk, kShbOpenMismatch, kShbOutOfMem or kShbInvalidArg |
| |
| if (ShbError != kShbOk) |
| { |
| Ret = kEplNoResource; |
| } |
| */ |
| ShbError = |
| ShbCirAllocBuffer(EPL_DLLCAL_BUFFER_SIZE_TX_NMT, |
| EPL_DLLCAL_BUFFER_ID_TX_NMT, |
| &EplDllkCalInstance_g.m_ShbInstanceTxNmt, |
| &fShbNewCreated); |
| // returns kShbOk, kShbOpenMismatch, kShbOutOfMem or kShbInvalidArg |
| |
| if (ShbError != kShbOk) { |
| Ret = kEplNoResource; |
| } |
| |
| /* ShbError = ShbCirSetSignalHandlerNewData (EplDllkCalInstance_g.m_ShbInstanceTxNmt, EplDllkCalTxNmtSignalHandler, kShbPriorityNormal); |
| // returns kShbOk, kShbAlreadySignaling or kShbInvalidArg |
| |
| if (ShbError != kShbOk) |
| { |
| Ret = kEplNoResource; |
| } |
| */ |
| ShbError = |
| ShbCirAllocBuffer(EPL_DLLCAL_BUFFER_SIZE_TX_GEN, |
| EPL_DLLCAL_BUFFER_ID_TX_GEN, |
| &EplDllkCalInstance_g.m_ShbInstanceTxGen, |
| &fShbNewCreated); |
| // returns kShbOk, kShbOpenMismatch, kShbOutOfMem or kShbInvalidArg |
| |
| if (ShbError != kShbOk) { |
| Ret = kEplNoResource; |
| } |
| |
| /* ShbError = ShbCirSetSignalHandlerNewData (EplDllkCalInstance_g.m_ShbInstanceTxGen, EplDllkCalTxGenSignalHandler, kShbPriorityNormal); |
| // returns kShbOk, kShbAlreadySignaling or kShbInvalidArg |
| |
| if (ShbError != kShbOk) |
| { |
| Ret = kEplNoResource; |
| } |
| */ |
| #else |
| EplDllkCalInstance_g.m_uiFrameSizeNmt = 0; |
| EplDllkCalInstance_g.m_uiFrameSizeGen = 0; |
| #endif |
| |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplDllkCalDelInstance() |
| // |
| // Description: deletes instance of DLL CAL module |
| // |
| // Parameters: none |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel EplDllkCalDelInstance(void) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| #ifndef EPL_NO_FIFO |
| tShbError ShbError; |
| |
| /* ShbError = ShbCirReleaseBuffer (EplDllkCalInstance_g.m_ShbInstanceRx); |
| if (ShbError != kShbOk) |
| { |
| Ret = kEplNoResource; |
| } |
| EplDllkCalInstance_g.m_ShbInstanceRx = NULL; |
| */ |
| ShbError = ShbCirReleaseBuffer(EplDllkCalInstance_g.m_ShbInstanceTxNmt); |
| if (ShbError != kShbOk) { |
| Ret = kEplNoResource; |
| } |
| EplDllkCalInstance_g.m_ShbInstanceTxNmt = NULL; |
| |
| ShbError = ShbCirReleaseBuffer(EplDllkCalInstance_g.m_ShbInstanceTxGen); |
| if (ShbError != kShbOk) { |
| Ret = kEplNoResource; |
| } |
| EplDllkCalInstance_g.m_ShbInstanceTxGen = NULL; |
| |
| #else |
| EplDllkCalInstance_g.m_uiFrameSizeNmt = 0; |
| EplDllkCalInstance_g.m_uiFrameSizeGen = 0; |
| #endif |
| |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplDllkCalProcess |
| // |
| // Description: process the passed configuration |
| // |
| // Parameters: pEvent_p = event containing configuration options |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel EplDllkCalProcess(tEplEvent * pEvent_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| |
| switch (pEvent_p->m_EventType) { |
| case kEplEventTypeDllkServFilter: |
| { |
| tEplDllCalAsndServiceIdFilter *pServFilter; |
| |
| pServFilter = |
| (tEplDllCalAsndServiceIdFilter *) pEvent_p->m_pArg; |
| Ret = |
| EplDllkSetAsndServiceIdFilter(pServFilter-> |
| m_ServiceId, |
| pServFilter-> |
| m_Filter); |
| break; |
| } |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| case kEplEventTypeDllkIssueReq: |
| { |
| tEplDllCalIssueRequest *pIssueReq; |
| |
| pIssueReq = (tEplDllCalIssueRequest *) pEvent_p->m_pArg; |
| Ret = |
| EplDllkCalIssueRequest(pIssueReq->m_Service, |
| pIssueReq->m_uiNodeId, |
| pIssueReq->m_bSoaFlag1); |
| break; |
| } |
| |
| case kEplEventTypeDllkAddNode: |
| { |
| tEplDllNodeInfo *pNodeInfo; |
| |
| pNodeInfo = (tEplDllNodeInfo *) pEvent_p->m_pArg; |
| Ret = EplDllkAddNode(pNodeInfo); |
| break; |
| } |
| |
| case kEplEventTypeDllkDelNode: |
| { |
| unsigned int *puiNodeId; |
| |
| puiNodeId = (unsigned int *)pEvent_p->m_pArg; |
| Ret = EplDllkDeleteNode(*puiNodeId); |
| break; |
| } |
| |
| case kEplEventTypeDllkSoftDelNode: |
| { |
| unsigned int *puiNodeId; |
| |
| puiNodeId = (unsigned int *)pEvent_p->m_pArg; |
| Ret = EplDllkSoftDeleteNode(*puiNodeId); |
| break; |
| } |
| #endif |
| |
| case kEplEventTypeDllkIdentity: |
| { |
| tEplDllIdentParam *pIdentParam; |
| |
| pIdentParam = (tEplDllIdentParam *) pEvent_p->m_pArg; |
| if (pIdentParam->m_uiSizeOfStruct > pEvent_p->m_uiSize) { |
| pIdentParam->m_uiSizeOfStruct = |
| pEvent_p->m_uiSize; |
| } |
| Ret = EplDllkSetIdentity(pIdentParam); |
| break; |
| } |
| |
| case kEplEventTypeDllkConfig: |
| { |
| tEplDllConfigParam *pConfigParam; |
| |
| pConfigParam = (tEplDllConfigParam *) pEvent_p->m_pArg; |
| if (pConfigParam->m_uiSizeOfStruct > pEvent_p->m_uiSize) { |
| pConfigParam->m_uiSizeOfStruct = |
| pEvent_p->m_uiSize; |
| } |
| Ret = EplDllkConfig(pConfigParam); |
| break; |
| } |
| |
| default: |
| break; |
| } |
| |
| //Exit: |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplDllkCalAsyncGetTxCount() |
| // |
| // Description: returns count of Tx frames of FIFO with highest priority |
| // |
| // Parameters: none |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel EplDllkCalAsyncGetTxCount(tEplDllAsyncReqPriority * pPriority_p, |
| unsigned int *puiCount_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| #ifndef EPL_NO_FIFO |
| tShbError ShbError; |
| unsigned long ulFrameCount; |
| |
| // get frame count of Tx FIFO with NMT request priority |
| ShbError = |
| ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxNmt, |
| &ulFrameCount); |
| // returns kShbOk, kShbInvalidArg |
| |
| // error handling |
| if (ShbError != kShbOk) { |
| Ret = kEplNoResource; |
| goto Exit; |
| } |
| |
| if (ulFrameCount > |
| EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt) { |
| EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt = |
| ulFrameCount; |
| } |
| |
| if (ulFrameCount != 0) { // NMT requests are in queue |
| *pPriority_p = kEplDllAsyncReqPrioNmt; |
| *puiCount_p = (unsigned int)ulFrameCount; |
| goto Exit; |
| } |
| // get frame count of Tx FIFO with generic priority |
| ShbError = |
| ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxGen, |
| &ulFrameCount); |
| // returns kShbOk, kShbInvalidArg |
| |
| // error handling |
| if (ShbError != kShbOk) { |
| Ret = kEplNoResource; |
| goto Exit; |
| } |
| |
| if (ulFrameCount > |
| EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen) { |
| EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen = |
| ulFrameCount; |
| } |
| |
| *pPriority_p = kEplDllAsyncReqPrioGeneric; |
| *puiCount_p = (unsigned int)ulFrameCount; |
| |
| Exit: |
| #else |
| if (EplDllkCalInstance_g.m_uiFrameSizeNmt > 0) { |
| *pPriority_p = kEplDllAsyncReqPrioNmt; |
| *puiCount_p = 1; |
| } else if (EplDllkCalInstance_g.m_uiFrameSizeGen > 0) { |
| *pPriority_p = kEplDllAsyncReqPrioGeneric; |
| *puiCount_p = 1; |
| } else { |
| *pPriority_p = kEplDllAsyncReqPrioGeneric; |
| *puiCount_p = 0; |
| } |
| #endif |
| |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplDllkCalAsyncGetTxFrame() |
| // |
| // Description: returns Tx frames from FIFO with specified priority |
| // |
| // Parameters: pFrame_p = IN: pointer to buffer |
| // puiFrameSize_p = IN: max size of buffer |
| // OUT: actual size of frame |
| // Priority_p = IN: priority |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel EplDllkCalAsyncGetTxFrame(void *pFrame_p, |
| unsigned int *puiFrameSize_p, |
| tEplDllAsyncReqPriority Priority_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| #ifndef EPL_NO_FIFO |
| tShbError ShbError; |
| unsigned long ulFrameSize; |
| |
| switch (Priority_p) { |
| case kEplDllAsyncReqPrioNmt: // NMT request priority |
| ShbError = |
| ShbCirReadDataBlock(EplDllkCalInstance_g.m_ShbInstanceTxNmt, |
| (u8 *) pFrame_p, *puiFrameSize_p, |
| &ulFrameSize); |
| // returns kShbOk, kShbDataTruncated, kShbInvalidArg, kShbNoReadableData |
| break; |
| |
| default: // generic priority |
| ShbError = |
| ShbCirReadDataBlock(EplDllkCalInstance_g.m_ShbInstanceTxGen, |
| (u8 *) pFrame_p, *puiFrameSize_p, |
| &ulFrameSize); |
| // returns kShbOk, kShbDataTruncated, kShbInvalidArg, kShbNoReadableData |
| break; |
| |
| } |
| |
| // error handling |
| if (ShbError != kShbOk) { |
| if (ShbError == kShbNoReadableData) { |
| Ret = kEplDllAsyncTxBufferEmpty; |
| } else { // other error |
| Ret = kEplNoResource; |
| } |
| goto Exit; |
| } |
| |
| *puiFrameSize_p = (unsigned int)ulFrameSize; |
| |
| Exit: |
| #else |
| switch (Priority_p) { |
| case kEplDllAsyncReqPrioNmt: // NMT request priority |
| *puiFrameSize_p = |
| min(*puiFrameSize_p, EplDllkCalInstance_g.m_uiFrameSizeNmt); |
| EPL_MEMCPY(pFrame_p, EplDllkCalInstance_g.m_abFrameNmt, |
| *puiFrameSize_p); |
| EplDllkCalInstance_g.m_uiFrameSizeNmt = 0; |
| break; |
| |
| default: // generic priority |
| *puiFrameSize_p = |
| min(*puiFrameSize_p, EplDllkCalInstance_g.m_uiFrameSizeGen); |
| EPL_MEMCPY(pFrame_p, EplDllkCalInstance_g.m_abFrameGen, |
| *puiFrameSize_p); |
| EplDllkCalInstance_g.m_uiFrameSizeGen = 0; |
| break; |
| } |
| |
| #endif |
| |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplDllkCalAsyncFrameReceived() |
| // |
| // Description: passes ASnd frame to receive FIFO. |
| // It will be called only for frames with registered AsndServiceIds. |
| // |
| // Parameters: none |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel EplDllkCalAsyncFrameReceived(tEplFrameInfo * pFrameInfo_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| tEplEvent Event; |
| |
| Event.m_EventSink = kEplEventSinkDlluCal; |
| Event.m_EventType = kEplEventTypeAsndRx; |
| Event.m_pArg = pFrameInfo_p->m_pFrame; |
| Event.m_uiSize = pFrameInfo_p->m_uiFrameSize; |
| // pass NetTime of frame to userspace |
| Event.m_NetTime = pFrameInfo_p->m_NetTime; |
| |
| Ret = EplEventkPost(&Event); |
| if (Ret != kEplSuccessful) { |
| EplDllkCalInstance_g.m_Statistics.m_ulCurRxFrameCount++; |
| } else { |
| EplDllkCalInstance_g.m_Statistics.m_ulMaxRxFrameCount++; |
| } |
| |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplDllkCalAsyncSend() |
| // |
| // Description: puts the given frame into the transmit FIFO with the specified |
| // priority. |
| // |
| // Parameters: pFrameInfo_p = frame info structure |
| // Priority_p = priority |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel EplDllkCalAsyncSend(tEplFrameInfo * pFrameInfo_p, |
| tEplDllAsyncReqPriority Priority_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| tEplEvent Event; |
| #ifndef EPL_NO_FIFO |
| tShbError ShbError; |
| |
| switch (Priority_p) { |
| case kEplDllAsyncReqPrioNmt: // NMT request priority |
| ShbError = |
| ShbCirWriteDataBlock(EplDllkCalInstance_g. |
| m_ShbInstanceTxNmt, |
| pFrameInfo_p->m_pFrame, |
| pFrameInfo_p->m_uiFrameSize); |
| // returns kShbOk, kShbExceedDataSizeLimit, kShbBufferFull, kShbInvalidArg |
| break; |
| |
| default: // generic priority |
| ShbError = |
| ShbCirWriteDataBlock(EplDllkCalInstance_g. |
| m_ShbInstanceTxGen, |
| pFrameInfo_p->m_pFrame, |
| pFrameInfo_p->m_uiFrameSize); |
| // returns kShbOk, kShbExceedDataSizeLimit, kShbBufferFull, kShbInvalidArg |
| break; |
| |
| } |
| |
| // error handling |
| switch (ShbError) { |
| case kShbOk: |
| break; |
| |
| case kShbExceedDataSizeLimit: |
| Ret = kEplDllAsyncTxBufferFull; |
| break; |
| |
| case kShbBufferFull: |
| Ret = kEplDllAsyncTxBufferFull; |
| break; |
| |
| case kShbInvalidArg: |
| default: |
| Ret = kEplNoResource; |
| break; |
| } |
| |
| #else |
| |
| switch (Priority_p) { |
| case kEplDllAsyncReqPrioNmt: // NMT request priority |
| if (EplDllkCalInstance_g.m_uiFrameSizeNmt == 0) { |
| EPL_MEMCPY(EplDllkCalInstance_g.m_abFrameNmt, |
| pFrameInfo_p->m_pFrame, |
| pFrameInfo_p->m_uiFrameSize); |
| EplDllkCalInstance_g.m_uiFrameSizeNmt = |
| pFrameInfo_p->m_uiFrameSize; |
| } else { |
| Ret = kEplDllAsyncTxBufferFull; |
| goto Exit; |
| } |
| break; |
| |
| default: // generic priority |
| if (EplDllkCalInstance_g.m_uiFrameSizeGen == 0) { |
| EPL_MEMCPY(EplDllkCalInstance_g.m_abFrameGen, |
| pFrameInfo_p->m_pFrame, |
| pFrameInfo_p->m_uiFrameSize); |
| EplDllkCalInstance_g.m_uiFrameSizeGen = |
| pFrameInfo_p->m_uiFrameSize; |
| } else { |
| Ret = kEplDllAsyncTxBufferFull; |
| goto Exit; |
| } |
| break; |
| } |
| |
| #endif |
| |
| // post event to DLL |
| Event.m_EventSink = kEplEventSinkDllk; |
| Event.m_EventType = kEplEventTypeDllkFillTx; |
| EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime)); |
| Event.m_pArg = &Priority_p; |
| Event.m_uiSize = sizeof(Priority_p); |
| Ret = EplEventkPost(&Event); |
| |
| #ifdef EPL_NO_FIFO |
| Exit: |
| #endif |
| |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplDllkCalAsyncClearBuffer() |
| // |
| // Description: clears the transmit buffer |
| // |
| // Parameters: (none) |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel EplDllkCalAsyncClearBuffer(void) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| #ifndef EPL_NO_FIFO |
| tShbError ShbError; |
| |
| ShbError = |
| ShbCirResetBuffer(EplDllkCalInstance_g.m_ShbInstanceTxNmt, 1000, |
| NULL); |
| ShbError = |
| ShbCirResetBuffer(EplDllkCalInstance_g.m_ShbInstanceTxGen, 1000, |
| NULL); |
| |
| #else |
| EplDllkCalInstance_g.m_uiFrameSizeNmt = 0; |
| EplDllkCalInstance_g.m_uiFrameSizeGen = 0; |
| #endif |
| |
| // EPL_MEMSET(&EplDllkCalInstance_g.m_Statistics, 0, sizeof (tEplDllkCalStatistics)); |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplDllkCalAsyncClearQueues() |
| // |
| // Description: clears the transmit buffer |
| // |
| // Parameters: (none) |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| tEplKernel EplDllkCalAsyncClearQueues(void) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| |
| // clear MN asynchronous queues |
| EplDllkCalInstance_g.m_uiNextQueueCnRequest = 0; |
| EplDllkCalInstance_g.m_uiNextRequestQueue = 0; |
| EplDllkCalInstance_g.m_uiReadIdentReq = 0; |
| EplDllkCalInstance_g.m_uiWriteIdentReq = 0; |
| EplDllkCalInstance_g.m_uiReadStatusReq = 0; |
| EplDllkCalInstance_g.m_uiWriteStatusReq = 0; |
| |
| return Ret; |
| } |
| #endif |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplDllkCalGetStatistics() |
| // |
| // Description: returns statistics of the asynchronous queues. |
| // |
| // Parameters: ppStatistics = statistics structure |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel EplDllkCalGetStatistics(tEplDllkCalStatistics ** ppStatistics) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| #ifndef EPL_NO_FIFO |
| tShbError ShbError; |
| |
| ShbError = |
| ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxNmt, |
| &EplDllkCalInstance_g.m_Statistics. |
| m_ulCurTxFrameCountNmt); |
| ShbError = |
| ShbCirGetReadBlockCount(EplDllkCalInstance_g.m_ShbInstanceTxGen, |
| &EplDllkCalInstance_g.m_Statistics. |
| m_ulCurTxFrameCountGen); |
| // ShbError = ShbCirGetReadBlockCount (EplDllkCalInstance_g.m_ShbInstanceRx, &EplDllkCalInstance_g.m_Statistics.m_ulCurRxFrameCount); |
| |
| #else |
| if (EplDllkCalInstance_g.m_uiFrameSizeNmt > 0) { |
| EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountNmt = 1; |
| } else { |
| EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountNmt = 0; |
| } |
| if (EplDllkCalInstance_g.m_uiFrameSizeGen > 0) { |
| EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountGen = 1; |
| } else { |
| EplDllkCalInstance_g.m_Statistics.m_ulCurTxFrameCountGen = 0; |
| } |
| #endif |
| |
| *ppStatistics = &EplDllkCalInstance_g.m_Statistics; |
| return Ret; |
| } |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplDllkCalIssueRequest() |
| // |
| // Description: issues a StatusRequest or a IdentRequest to the specified node. |
| // |
| // Parameters: Service_p = request service ID |
| // uiNodeId_p = node ID |
| // bSoaFlag1_p = flag1 for this node (transmit in SoA and PReq) |
| // If 0xFF this flag is ignored. |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel EplDllkCalIssueRequest(tEplDllReqServiceId Service_p, |
| unsigned int uiNodeId_p, u8 bSoaFlag1_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| |
| if (bSoaFlag1_p != 0xFF) { |
| Ret = EplDllkSetFlag1OfNode(uiNodeId_p, bSoaFlag1_p); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| } |
| // add node to appropriate request queue |
| switch (Service_p) { |
| case kEplDllReqServiceIdent: |
| { |
| if (((EplDllkCalInstance_g.m_uiWriteIdentReq + |
| 1) % |
| tabentries(EplDllkCalInstance_g. |
| m_auiQueueIdentReq)) |
| == EplDllkCalInstance_g.m_uiReadIdentReq) { // queue is full |
| Ret = kEplDllAsyncTxBufferFull; |
| goto Exit; |
| } |
| EplDllkCalInstance_g. |
| m_auiQueueIdentReq[EplDllkCalInstance_g. |
| m_uiWriteIdentReq] = uiNodeId_p; |
| EplDllkCalInstance_g.m_uiWriteIdentReq = |
| (EplDllkCalInstance_g.m_uiWriteIdentReq + |
| 1) % |
| tabentries(EplDllkCalInstance_g.m_auiQueueIdentReq); |
| break; |
| } |
| |
| case kEplDllReqServiceStatus: |
| { |
| if (((EplDllkCalInstance_g.m_uiWriteStatusReq + |
| 1) % |
| tabentries(EplDllkCalInstance_g. |
| m_auiQueueStatusReq)) |
| == EplDllkCalInstance_g.m_uiReadStatusReq) { // queue is full |
| Ret = kEplDllAsyncTxBufferFull; |
| goto Exit; |
| } |
| EplDllkCalInstance_g. |
| m_auiQueueStatusReq[EplDllkCalInstance_g. |
| m_uiWriteStatusReq] = |
| uiNodeId_p; |
| EplDllkCalInstance_g.m_uiWriteStatusReq = |
| (EplDllkCalInstance_g.m_uiWriteStatusReq + |
| 1) % |
| tabentries(EplDllkCalInstance_g. |
| m_auiQueueStatusReq); |
| break; |
| } |
| |
| default: |
| { |
| Ret = kEplDllInvalidParam; |
| goto Exit; |
| } |
| } |
| |
| Exit: |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplDllkCalAsyncGetSoaRequest() |
| // |
| // Description: returns next request for SoA. This function is called by DLLk module. |
| // |
| // Parameters: pReqServiceId_p = pointer to request service ID |
| // IN: available request for MN NMT or generic request queue (Flag2.PR) |
| // or kEplDllReqServiceNo if queues are empty |
| // OUT: next request |
| // puiNodeId_p = OUT: pointer to node ID of next request |
| // = EPL_C_ADR_INVALID, if request is self addressed |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel EplDllkCalAsyncGetSoaRequest(tEplDllReqServiceId * pReqServiceId_p, |
| unsigned int *puiNodeId_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| unsigned int uiCount; |
| |
| // *pReqServiceId_p = kEplDllReqServiceNo; |
| |
| for (uiCount = EPL_DLLKCAL_MAX_QUEUES; uiCount > 0; uiCount--) { |
| switch (EplDllkCalInstance_g.m_uiNextRequestQueue) { |
| case 0: |
| { // CnGenReq |
| for (; |
| EplDllkCalInstance_g. |
| m_uiNextQueueCnRequest < |
| (tabentries |
| (EplDllkCalInstance_g. |
| m_auiQueueCnRequests) / 2); |
| EplDllkCalInstance_g. |
| m_uiNextQueueCnRequest++) { |
| if (EplDllkCalInstance_g.m_auiQueueCnRequests[EplDllkCalInstance_g.m_uiNextQueueCnRequest] > 0) { // non empty queue found |
| // remove one request from queue |
| EplDllkCalInstance_g. |
| m_auiQueueCnRequests |
| [EplDllkCalInstance_g. |
| m_uiNextQueueCnRequest]--; |
| *puiNodeId_p = |
| EplDllkCalInstance_g. |
| m_uiNextQueueCnRequest + 1; |
| *pReqServiceId_p = |
| kEplDllReqServiceUnspecified; |
| EplDllkCalInstance_g. |
| m_uiNextQueueCnRequest++; |
| if (EplDllkCalInstance_g.m_uiNextQueueCnRequest >= (tabentries(EplDllkCalInstance_g.m_auiQueueCnRequests) / 2)) { // last node reached |
| // continue with CnNmtReq queue at next SoA |
| EplDllkCalInstance_g. |
| m_uiNextRequestQueue |
| = 1; |
| } |
| goto Exit; |
| } |
| } |
| // all CnGenReq queues are empty -> continue with CnNmtReq queue |
| EplDllkCalInstance_g.m_uiNextRequestQueue = 1; |
| break; |
| } |
| |
| case 1: |
| { // CnNmtReq |
| for (; |
| EplDllkCalInstance_g. |
| m_uiNextQueueCnRequest < |
| tabentries(EplDllkCalInstance_g. |
| m_auiQueueCnRequests); |
| EplDllkCalInstance_g. |
| m_uiNextQueueCnRequest++) { |
| if (EplDllkCalInstance_g.m_auiQueueCnRequests[EplDllkCalInstance_g.m_uiNextQueueCnRequest] > 0) { // non empty queue found |
| // remove one request from queue |
| EplDllkCalInstance_g. |
| m_auiQueueCnRequests |
| [EplDllkCalInstance_g. |
| m_uiNextQueueCnRequest]--; |
| *puiNodeId_p = |
| EplDllkCalInstance_g. |
| m_uiNextQueueCnRequest + 1 - |
| (tabentries |
| (EplDllkCalInstance_g. |
| m_auiQueueCnRequests) / |
| 2); |
| *pReqServiceId_p = |
| kEplDllReqServiceNmtRequest; |
| EplDllkCalInstance_g. |
| m_uiNextQueueCnRequest++; |
| if (EplDllkCalInstance_g.m_uiNextQueueCnRequest > tabentries(EplDllkCalInstance_g.m_auiQueueCnRequests)) { // last node reached |
| // restart CnGenReq queue |
| EplDllkCalInstance_g. |
| m_uiNextQueueCnRequest |
| = 0; |
| // continue with MnGenReq queue at next SoA |
| EplDllkCalInstance_g. |
| m_uiNextRequestQueue |
| = 2; |
| } |
| goto Exit; |
| } |
| } |
| // restart CnGenReq queue |
| EplDllkCalInstance_g.m_uiNextQueueCnRequest = 0; |
| // all CnNmtReq queues are empty -> continue with MnGenReq queue |
| EplDllkCalInstance_g.m_uiNextRequestQueue = 2; |
| break; |
| } |
| |
| case 2: |
| { // MnNmtReq and MnGenReq |
| // next queue will be MnIdentReq queue |
| EplDllkCalInstance_g.m_uiNextRequestQueue = 3; |
| if (*pReqServiceId_p != kEplDllReqServiceNo) { |
| *puiNodeId_p = EPL_C_ADR_INVALID; // DLLk must exchange this with the actual node ID |
| goto Exit; |
| } |
| break; |
| } |
| |
| case 3: |
| { // MnIdentReq |
| // next queue will be MnStatusReq queue |
| EplDllkCalInstance_g.m_uiNextRequestQueue = 4; |
| if (EplDllkCalInstance_g.m_uiReadIdentReq != EplDllkCalInstance_g.m_uiWriteIdentReq) { // queue is not empty |
| *puiNodeId_p = |
| EplDllkCalInstance_g. |
| m_auiQueueIdentReq |
| [EplDllkCalInstance_g. |
| m_uiReadIdentReq]; |
| EplDllkCalInstance_g.m_uiReadIdentReq = |
| (EplDllkCalInstance_g. |
| m_uiReadIdentReq + |
| 1) % |
| tabentries(EplDllkCalInstance_g. |
| m_auiQueueIdentReq); |
| *pReqServiceId_p = |
| kEplDllReqServiceIdent; |
| goto Exit; |
| } |
| break; |
| } |
| |
| case 4: |
| { // MnStatusReq |
| // next queue will be CnGenReq queue |
| EplDllkCalInstance_g.m_uiNextRequestQueue = 0; |
| if (EplDllkCalInstance_g.m_uiReadStatusReq != EplDllkCalInstance_g.m_uiWriteStatusReq) { // queue is not empty |
| *puiNodeId_p = |
| EplDllkCalInstance_g. |
| m_auiQueueStatusReq |
| [EplDllkCalInstance_g. |
| m_uiReadStatusReq]; |
| EplDllkCalInstance_g.m_uiReadStatusReq = |
| (EplDllkCalInstance_g. |
| m_uiReadStatusReq + |
| 1) % |
| tabentries(EplDllkCalInstance_g. |
| m_auiQueueStatusReq); |
| *pReqServiceId_p = |
| kEplDllReqServiceStatus; |
| goto Exit; |
| } |
| break; |
| } |
| |
| } |
| } |
| |
| Exit: |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplDllkCalAsyncSetPendingRequests() |
| // |
| // Description: sets the pending asynchronous frame requests of the specified node. |
| // This will add the node to the asynchronous request scheduler. |
| // |
| // Parameters: uiNodeId_p = node ID |
| // AsyncReqPrio_p = asynchronous request priority |
| // uiCount_p = count of asynchronous frames |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel EplDllkCalAsyncSetPendingRequests(unsigned int uiNodeId_p, |
| tEplDllAsyncReqPriority |
| AsyncReqPrio_p, |
| unsigned int uiCount_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| |
| // add node to appropriate request queue |
| switch (AsyncReqPrio_p) { |
| case kEplDllAsyncReqPrioNmt: |
| { |
| uiNodeId_p--; |
| if (uiNodeId_p >= |
| (tabentries |
| (EplDllkCalInstance_g.m_auiQueueCnRequests) / 2)) { |
| Ret = kEplDllInvalidParam; |
| goto Exit; |
| } |
| uiNodeId_p += |
| tabentries(EplDllkCalInstance_g. |
| m_auiQueueCnRequests) / 2; |
| EplDllkCalInstance_g.m_auiQueueCnRequests[uiNodeId_p] = |
| uiCount_p; |
| break; |
| } |
| |
| default: |
| { |
| uiNodeId_p--; |
| if (uiNodeId_p >= |
| (tabentries |
| (EplDllkCalInstance_g.m_auiQueueCnRequests) / 2)) { |
| Ret = kEplDllInvalidParam; |
| goto Exit; |
| } |
| EplDllkCalInstance_g.m_auiQueueCnRequests[uiNodeId_p] = |
| uiCount_p; |
| break; |
| } |
| } |
| |
| Exit: |
| return Ret; |
| } |
| #endif //(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| |
| //=========================================================================// |
| // // |
| // P R I V A T E F U N C T I O N S // |
| // // |
| //=========================================================================// |
| |
| //--------------------------------------------------------------------------- |
| // Callback handler for new data signaling |
| //--------------------------------------------------------------------------- |
| |
| #ifndef EPL_NO_FIFO |
| /*static void EplDllkCalTxNmtSignalHandler ( |
| tShbInstance pShbRxInstance_p, |
| unsigned long ulDataSize_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| tEplEvent Event; |
| tEplDllAsyncReqPriority Priority; |
| #ifndef EPL_NO_FIFO |
| tShbError ShbError; |
| unsigned long ulBlockCount; |
| |
| ShbError = ShbCirGetReadBlockCount (EplDllkCalInstance_g.m_ShbInstanceTxNmt, &ulBlockCount); |
| if (ulBlockCount > EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt) |
| { |
| EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountNmt = ulBlockCount; |
| } |
| |
| #endif |
| |
| // post event to DLL |
| Priority = kEplDllAsyncReqPrioNmt; |
| Event.m_EventSink = kEplEventSinkDllk; |
| Event.m_EventType = kEplEventTypeDllkFillTx; |
| EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime)); |
| Event.m_pArg = &Priority; |
| Event.m_uiSize = sizeof(Priority); |
| Ret = EplEventkPost(&Event); |
| |
| } |
| |
| static void EplDllkCalTxGenSignalHandler ( |
| tShbInstance pShbRxInstance_p, |
| unsigned long ulDataSize_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| tEplEvent Event; |
| tEplDllAsyncReqPriority Priority; |
| #ifndef EPL_NO_FIFO |
| tShbError ShbError; |
| unsigned long ulBlockCount; |
| |
| ShbError = ShbCirGetReadBlockCount (EplDllkCalInstance_g.m_ShbInstanceTxGen, &ulBlockCount); |
| if (ulBlockCount > EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen) |
| { |
| EplDllkCalInstance_g.m_Statistics.m_ulMaxTxFrameCountGen = ulBlockCount; |
| } |
| |
| #endif |
| |
| // post event to DLL |
| Priority = kEplDllAsyncReqPrioGeneric; |
| Event.m_EventSink = kEplEventSinkDllk; |
| Event.m_EventType = kEplEventTypeDllkFillTx; |
| EPL_MEMSET(&Event.m_NetTime, 0x00, sizeof(Event.m_NetTime)); |
| Event.m_pArg = &Priority; |
| Event.m_uiSize = sizeof(Priority); |
| Ret = EplEventkPost(&Event); |
| |
| } |
| */ |
| #endif |
| |
| #endif // #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0) |
| |
| // EOF |
