/****************************************************************************
(c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
www.systec-electronic.com
Project: Project independend shared buffer (linear + circular)
Description: Implementation of platform independend part for the
shared buffer
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.
-------------------------------------------------------------------------
2006/06/27 -rs: V 1.00 (initial version)
****************************************************************************/
#if defined(WIN32) || defined(_WIN32)
#ifdef UNDER_RTSS
// RTX header
#include <windows.h>
#include <process.h>
#include <rtapi.h>
#elif __BORLANDC__
// borland C header
#include <windows.h>
#include <process.h>
#elif WINCE
#include <windows.h>
#else
// MSVC needs to include windows.h at first
// the following defines ar necessary for function prototypes for waitable timers
#define _WIN32_WINDOWS 0x0401
#define _WIN32_WINNT 0x0400
#include <windows.h>
#include <process.h>
#endif
#endif
#include "global.h"
#include "SharedBuff.h"
#include "ShbIpc.h"
#include <linux/string.h>
#include <linux/kernel.h>
/***************************************************************************/
/* */
/* */
/* G L O B A L D E F I N I T I O N S */
/* */
/* */
/***************************************************************************/
//---------------------------------------------------------------------------
// Configuration
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Constant definitions
//---------------------------------------------------------------------------
#define SBC_MAGIC_ID 0x53424323 // magic ID ("SBC#")
#define SBL_MAGIC_ID 0x53424C23 // magic ID ("SBL#")
//---------------------------------------------------------------------------
// Local types
//---------------------------------------------------------------------------
// structure to administrate circular shared buffer head
typedef struct {
unsigned long m_ShbCirMagicID; // magic ID ("SBC#")
unsigned long m_ulBufferTotalSize; // over-all size of complete buffer
unsigned long m_ulBufferDataSize; // size of complete data area
unsigned long m_ulWrIndex; // current write index (set bevore write)
unsigned long m_ulRdIndex; // current read index (set after read)
unsigned long m_ulNumOfWriteJobs; // number of currently (parallel running) write operations
unsigned long m_ulDataInUse; // currently used buffer size (incl. uncompleted write operations)
unsigned long m_ulDataApended; // buffer size of complete new written but not yet readable data (in case of m_ulNumOfWriteJobs>1)
unsigned long m_ulBlocksApended; // number of complete new written but not yet readable data blocks (in case of m_ulNumOfWriteJobs>1)
unsigned long m_ulDataReadable; // buffer size with readable (complete written) data
unsigned long m_ulBlocksReadable; // number of readable (complete written) data blocks
tShbCirSigHndlrNewData m_pfnSigHndlrNewData; // application handler to signal new data
unsigned int m_fBufferLocked; // TRUE if buffer is locked (because of pending reset request)
tShbCirSigHndlrReset m_pfnSigHndlrReset; // application handler to signal buffer reset is done
unsigned char m_Data; // start of data area (the real data size is unknown at this time)
} tShbCirBuff;
// structure to administrate linear shared buffer head
typedef struct {
unsigned int m_ShbLinMagicID; // magic ID ("SBL#")
unsigned long m_ulBufferTotalSize; // over-all size of complete buffer
unsigned long m_ulBufferDataSize; // size of complete data area
unsigned char m_Data; // start of data area (the real data size is unknown at this time)
} tShbLinBuff;
// type to save size of a single data block inside the circular shared buffer
typedef struct {
unsigned int m_uiFullBlockSize:28; // a single block must not exceed a length of 256MByte :-)
unsigned int m_uiAlignFillBytes:4;
} tShbCirBlockSize;
#define SBC_BLOCK_ALIGNMENT 4 // alignment must *not* be lower than sizeof(tShbCirBlockSize)!
#define SBC_MAX_BLOCK_SIZE ((1<<28)-1) // = (2^28 - 1) = (256MByte - 1) -> should be enought for real life :-)
#define SBL_BLOCK_ALIGNMENT 4
#define SBL_MAX_BLOCK_SIZE ((1<<28)-1) // = (2^28 - 1) = (256MByte - 1) -> should be enought for real life :-)
//---------------------------------------------------------------------------
// Global variables
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Local variables
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Prototypes of internal functions
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Get pointer to Circular Shared Buffer
//---------------------------------------------------------------------------
tShbCirBuff *ShbCirGetBuffer(tShbInstance pShbInstance_p)
{
tShbCirBuff *pShbCirBuff;
pShbCirBuff = (tShbCirBuff *) ShbIpcGetShMemPtr(pShbInstance_p);
ASSERT(pShbCirBuff->m_ShbCirMagicID == SBC_MAGIC_ID);
return (pShbCirBuff);
}
//---------------------------------------------------------------------------
// Get pointer to Linear Shared Buffer
//---------------------------------------------------------------------------
tShbLinBuff *ShbLinGetBuffer(tShbInstance pShbInstance_p)
{
tShbLinBuff *pShbLinBuff;
pShbLinBuff = (tShbLinBuff *) ShbIpcGetShMemPtr(pShbInstance_p);
ASSERT(pShbLinBuff->m_ShbLinMagicID == SBL_MAGIC_ID);
return (pShbLinBuff);
}
// not inlined internal functions
int ShbCirSignalHandlerNewData(tShbInstance pShbInstance_p);
void ShbCirSignalHandlerReset(tShbInstance pShbInstance_p,
unsigned int fTimeOut_p);
//=========================================================================//
// //
// P U B L I C F U N C T I O N S //
// //
//=========================================================================//
// not inlined external functions
//---------------------------------------------------------------------------
// Initialize Shared Buffer Module
//---------------------------------------------------------------------------
tShbError ShbInit(void)
{
tShbError ShbError;
ShbError = ShbIpcInit();
return (ShbError);
}
//---------------------------------------------------------------------------
// Deinitialize Shared Buffer Module
//---------------------------------------------------------------------------
tShbError ShbExit(void)
{
tShbError ShbError;
ShbError = ShbIpcExit();
return (ShbError);
}
//-------------------------------------------------------------------------//
// //
// C i r c u l a r S h a r e d B u f f e r //
// //
//-------------------------------------------------------------------------//
//---------------------------------------------------------------------------
// Allocate Circular Shared Buffer
//---------------------------------------------------------------------------
tShbError ShbCirAllocBuffer(unsigned long ulBufferSize_p,
const char *pszBufferID_p,
tShbInstance * ppShbInstance_p,
unsigned int *pfShbNewCreated_p)
{
tShbInstance pShbInstance;
tShbCirBuff *pShbCirBuff;
unsigned int fShbNewCreated;
unsigned long ulBufferDataSize;
unsigned long ulBufferTotalSize;
tShbError ShbError;
// check arguments
if ((ulBufferSize_p == 0) || (ppShbInstance_p == NULL)) {
return (kShbInvalidArg);
}
// calculate length of memory to allocate
ulBufferDataSize =
(ulBufferSize_p +
(SBC_BLOCK_ALIGNMENT - 1)) & ~(SBC_BLOCK_ALIGNMENT - 1);
ulBufferTotalSize = ulBufferDataSize + sizeof(tShbCirBuff);
// allocate a new or open an existing shared buffer
ShbError = ShbIpcAllocBuffer(ulBufferTotalSize, pszBufferID_p,
&pShbInstance, &fShbNewCreated);
if (ShbError != kShbOk) {
goto Exit;
}
if (pShbInstance == NULL) {
ShbError = kShbOutOfMem;
goto Exit;
}
// get pointer to shared buffer
pShbCirBuff = (tShbCirBuff *) ShbIpcGetShMemPtr(pShbInstance);
// if the shared buffer was new created, than this process has
// to initialize it, otherwise the buffer is already in use
// and *must not* be reseted
if (fShbNewCreated) {
#ifndef NDEBUG
{
memset(pShbCirBuff, 0xCC, ulBufferTotalSize);
}
#endif
pShbCirBuff->m_ShbCirMagicID = SBC_MAGIC_ID;
pShbCirBuff->m_ulBufferTotalSize = ulBufferTotalSize;
pShbCirBuff->m_ulBufferDataSize = ulBufferDataSize;
pShbCirBuff->m_ulWrIndex = 0;
pShbCirBuff->m_ulRdIndex = 0;
pShbCirBuff->m_ulNumOfWriteJobs = 0;
pShbCirBuff->m_ulDataInUse = 0;
pShbCirBuff->m_ulDataApended = 0;
pShbCirBuff->m_ulBlocksApended = 0;
pShbCirBuff->m_ulDataReadable = 0;
pShbCirBuff->m_ulBlocksReadable = 0;
pShbCirBuff->m_pfnSigHndlrNewData = NULL;
pShbCirBuff->m_fBufferLocked = FALSE;
pShbCirBuff->m_pfnSigHndlrReset = NULL;
} else {
if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
}
Exit:
*ppShbInstance_p = pShbInstance;
*pfShbNewCreated_p = fShbNewCreated;
return (ShbError);
}
//---------------------------------------------------------------------------
// Release Circular Shared Buffer
//---------------------------------------------------------------------------
tShbError ShbCirReleaseBuffer(tShbInstance pShbInstance_p)
{
tShbError ShbError;
// check arguments
if (pShbInstance_p == NULL) {
ShbError = kShbOk;
goto Exit;
}
ShbError = ShbIpcReleaseBuffer(pShbInstance_p);
Exit:
return (ShbError);
}
//---------------------------------------------------------------------------
// Reset Circular Shared Buffer
//---------------------------------------------------------------------------
tShbError ShbCirResetBuffer(tShbInstance pShbInstance_p,
unsigned long ulTimeOut_p,
tShbCirSigHndlrReset pfnSignalHandlerReset_p)
{
tShbCirBuff *pShbCirBuff;
unsigned long ulNumOfWriteJobs = 0; // d.k. GCC complains about uninitialized variable otherwise
tShbError ShbError;
// check arguments
if (pShbInstance_p == NULL) {
ShbError = kShbInvalidArg;
goto Exit;
}
pShbCirBuff = ShbCirGetBuffer(pShbInstance_p);
ShbError = kShbOk;
if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
// start reset job by setting request request in buffer header
ShbIpcEnterAtomicSection(pShbInstance_p);
{
if (!pShbCirBuff->m_fBufferLocked) {
ulNumOfWriteJobs = pShbCirBuff->m_ulNumOfWriteJobs;
pShbCirBuff->m_fBufferLocked = TRUE;
pShbCirBuff->m_pfnSigHndlrReset =
pfnSignalHandlerReset_p;
} else {
ShbError = kShbAlreadyReseting;
}
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
if (ShbError != kShbOk) {
goto Exit;
}
// if there is currently no running write operation then reset buffer
// immediately, otherwise wait until the last write job is ready by
// starting a signal process
if (ulNumOfWriteJobs == 0) {
// there is currently no running write operation
// -> reset buffer immediately
ShbCirSignalHandlerReset(pShbInstance_p, FALSE);
ShbError = kShbOk;
} else {
// there is currently at least one running write operation
// -> starting signal process to wait until the last write job is ready
ShbError =
ShbIpcStartSignalingJobReady(pShbInstance_p, ulTimeOut_p,
ShbCirSignalHandlerReset);
}
Exit:
return (ShbError);
}
//---------------------------------------------------------------------------
// Write data block to Circular Shared Buffer
//---------------------------------------------------------------------------
tShbError ShbCirWriteDataBlock(tShbInstance pShbInstance_p,
const void *pSrcDataBlock_p,
unsigned long ulDataBlockSize_p)
{
tShbCirBuff *pShbCirBuff;
tShbCirBlockSize ShbCirBlockSize;
unsigned int uiFullBlockSize;
unsigned int uiAlignFillBytes;
unsigned char *pShbCirDataPtr;
unsigned char *pScrDataPtr;
unsigned long ulDataSize;
unsigned long ulChunkSize;
unsigned long ulWrIndex = 0; // d.k. GCC complains about uninitialized variable otherwise
unsigned int fSignalNewData;
unsigned int fSignalReset;
tShbError ShbError;
tShbError ShbError2;
int fRes;
// check arguments
if (pShbInstance_p == NULL) {
ShbError = kShbInvalidArg;
goto Exit;
}
if ((pSrcDataBlock_p == NULL) || (ulDataBlockSize_p == 0)) {
// nothing to do here
ShbError = kShbOk;
goto Exit;
}
if (ulDataBlockSize_p > SBC_MAX_BLOCK_SIZE) {
ShbError = kShbExceedDataSizeLimit;
goto Exit;
}
pShbCirBuff = ShbCirGetBuffer(pShbInstance_p);
pScrDataPtr = (unsigned char *)pSrcDataBlock_p;
fSignalNewData = FALSE;
fSignalReset = FALSE;
ShbError = kShbOk;
if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
// calculate data block size in circular buffer
ulDataSize =
(ulDataBlockSize_p +
(SBC_BLOCK_ALIGNMENT - 1)) & ~(SBC_BLOCK_ALIGNMENT - 1);
uiFullBlockSize = ulDataSize + sizeof(tShbCirBlockSize); // data size + header
uiAlignFillBytes = ulDataSize - ulDataBlockSize_p;
ShbCirBlockSize.m_uiFullBlockSize = uiFullBlockSize;
ShbCirBlockSize.m_uiAlignFillBytes = uiAlignFillBytes;
// reserve the needed memory for the write operation to do now
// and make necessary adjustments in the circular buffer header
ShbIpcEnterAtomicSection(pShbInstance_p);
{
// check if there is sufficient memory available to store
// the new data
fRes =
uiFullBlockSize <=
(pShbCirBuff->m_ulBufferDataSize -
pShbCirBuff->m_ulDataInUse);
if (fRes) {
// set write pointer for the write operation to do now
// to the current write pointer of the circular buffer
ulWrIndex = pShbCirBuff->m_ulWrIndex;
// reserve the needed memory for the write operation to do now
pShbCirBuff->m_ulDataInUse += uiFullBlockSize;
// set new write pointer behind the reserved memory
// for the write operation to do now
pShbCirBuff->m_ulWrIndex += uiFullBlockSize;
pShbCirBuff->m_ulWrIndex %=
pShbCirBuff->m_ulBufferDataSize;
// increment number of currently (parallel running)
// write operations
pShbCirBuff->m_ulNumOfWriteJobs++;
}
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
if (!fRes) {
ShbError = kShbBufferFull;
goto Exit;
}
// copy the data to the circular buffer
// (the copy process itself will be done outside of any
// critical/locked section)
pShbCirDataPtr = &pShbCirBuff->m_Data; // ptr to start of data area
// write real size of current block (incl. alignment fill bytes)
*(tShbCirBlockSize *) (pShbCirDataPtr + ulWrIndex) = ShbCirBlockSize;
ulWrIndex += sizeof(tShbCirBlockSize);
ulWrIndex %= pShbCirBuff->m_ulBufferDataSize;
if (ulWrIndex + ulDataBlockSize_p <= pShbCirBuff->m_ulBufferDataSize) {
// linear write operation
memcpy(pShbCirDataPtr + ulWrIndex, pScrDataPtr,
ulDataBlockSize_p);
} else {
// wrap-around write operation
ulChunkSize = pShbCirBuff->m_ulBufferDataSize - ulWrIndex;
memcpy(pShbCirDataPtr + ulWrIndex, pScrDataPtr, ulChunkSize);
memcpy(pShbCirDataPtr, pScrDataPtr + ulChunkSize,
ulDataBlockSize_p - ulChunkSize);
}
// adjust header information for circular buffer with properties
// of the wiritten data block
ShbIpcEnterAtomicSection(pShbInstance_p);
{
pShbCirBuff->m_ulDataApended += uiFullBlockSize;
pShbCirBuff->m_ulBlocksApended++;
// decrement number of currently (parallel running) write operations
if (!--pShbCirBuff->m_ulNumOfWriteJobs) {
// if there is no other write process running then
// set new size of readable (complete written) data and
// adjust number of readable blocks
pShbCirBuff->m_ulDataReadable +=
pShbCirBuff->m_ulDataApended;
pShbCirBuff->m_ulBlocksReadable +=
pShbCirBuff->m_ulBlocksApended;
pShbCirBuff->m_ulDataApended = 0;
pShbCirBuff->m_ulBlocksApended = 0;
fSignalNewData = TRUE;
fSignalReset = pShbCirBuff->m_fBufferLocked;
}
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
// signal new data event to a potentially reading application
if (fSignalNewData) {
ShbError2 = ShbIpcSignalNewData(pShbInstance_p);
if (ShbError == kShbOk) {
ShbError = ShbError2;
}
}
// signal that the last write job has been finished to allow
// a waiting application to reset the buffer now
if (fSignalReset) {
ShbError2 = ShbIpcSignalJobReady(pShbInstance_p);
if (ShbError == kShbOk) {
ShbError = ShbError2;
}
}
Exit:
return (ShbError);
}
//---------------------------------------------------------------------------
// Allocate block within the Circular Shared Buffer for chunk writing
//---------------------------------------------------------------------------
tShbError ShbCirAllocDataBlock(tShbInstance pShbInstance_p,
tShbCirChunk * pShbCirChunk_p,
unsigned long ulDataBufferSize_p)
{
tShbCirBuff *pShbCirBuff;
tShbCirBlockSize ShbCirBlockSize;
unsigned int uiFullBlockSize;
unsigned int uiAlignFillBytes;
unsigned char *pShbCirDataPtr;
unsigned long ulDataSize;
unsigned long ulWrIndex = 0; // d.k. GCC complains about uninitialized variable otherwise
tShbError ShbError;
int fRes;
// check arguments
if ((pShbInstance_p == NULL) || (pShbCirChunk_p == NULL)) {
ShbError = kShbInvalidArg;
goto Exit;
}
if (ulDataBufferSize_p == 0) {
ShbError = kShbInvalidArg;
goto Exit;
}
if (ulDataBufferSize_p > SBC_MAX_BLOCK_SIZE) {
ShbError = kShbExceedDataSizeLimit;
goto Exit;
}
pShbCirBuff = ShbCirGetBuffer(pShbInstance_p);
ShbError = kShbOk;
if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
// calculate data block size in circular buffer
ulDataSize =
(ulDataBufferSize_p +
(SBC_BLOCK_ALIGNMENT - 1)) & ~(SBC_BLOCK_ALIGNMENT - 1);
uiFullBlockSize = ulDataSize + sizeof(tShbCirBlockSize); // data size + header
uiAlignFillBytes = ulDataSize - ulDataBufferSize_p;
ShbCirBlockSize.m_uiFullBlockSize = uiFullBlockSize;
ShbCirBlockSize.m_uiAlignFillBytes = uiAlignFillBytes;
// reserve the needed memory for the write operation to do now
// and make necessary adjustments in the circular buffer header
ShbIpcEnterAtomicSection(pShbInstance_p);
{
// check if there is sufficient memory available to store
// the new data
fRes =
(uiFullBlockSize <=
(pShbCirBuff->m_ulBufferDataSize -
pShbCirBuff->m_ulDataInUse));
if (fRes) {
// set write pointer for the write operation to do now
// to the current write pointer of the circular buffer
ulWrIndex = pShbCirBuff->m_ulWrIndex;
// reserve the needed memory for the write operation to do now
pShbCirBuff->m_ulDataInUse += uiFullBlockSize;
// set new write pointer behind the reserved memory
// for the write operation to do now
pShbCirBuff->m_ulWrIndex += uiFullBlockSize;
pShbCirBuff->m_ulWrIndex %=
pShbCirBuff->m_ulBufferDataSize;
// increment number of currently (parallel running)
// write operations
pShbCirBuff->m_ulNumOfWriteJobs++;
}
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
if (!fRes) {
ShbError = kShbBufferFull;
goto Exit;
}
// setup header information for allocated buffer
pShbCirDataPtr = &pShbCirBuff->m_Data; // ptr to start of data area
// write real size of current block (incl. alignment fill bytes)
*(tShbCirBlockSize *) (pShbCirDataPtr + ulWrIndex) = ShbCirBlockSize;
ulWrIndex += sizeof(tShbCirBlockSize);
ulWrIndex %= pShbCirBuff->m_ulBufferDataSize;
// setup chunk descriptor
pShbCirChunk_p->m_uiFullBlockSize = uiFullBlockSize;
pShbCirChunk_p->m_ulAvailableSize = ulDataBufferSize_p;
pShbCirChunk_p->m_ulWrIndex = ulWrIndex;
pShbCirChunk_p->m_fBufferCompleted = FALSE;
Exit:
return (ShbError);
}
//---------------------------------------------------------------------------
// Write data chunk into an allocated buffer of the Circular Shared Buffer
//---------------------------------------------------------------------------
tShbError ShbCirWriteDataChunk(tShbInstance pShbInstance_p,
tShbCirChunk *pShbCirChunk_p,
const void *pSrcDataChunk_p,
unsigned long ulDataChunkSize_p,
unsigned int *pfBufferCompleted_p)
{
tShbCirBuff *pShbCirBuff;
unsigned char *pShbCirDataPtr;
unsigned char *pScrDataPtr;
unsigned long ulSubChunkSize;
unsigned long ulWrIndex;
unsigned int fBufferCompleted;
unsigned int fSignalNewData;
unsigned int fSignalReset;
tShbError ShbError;
tShbError ShbError2;
// check arguments
if ((pShbInstance_p == NULL) || (pShbCirChunk_p == NULL)
|| (pfBufferCompleted_p == NULL)) {
ShbError = kShbInvalidArg;
goto Exit;
}
if ((pSrcDataChunk_p == NULL) || (ulDataChunkSize_p == 0)) {
// nothing to do here
ShbError = kShbOk;
goto Exit;
}
if (pShbCirChunk_p->m_fBufferCompleted) {
ShbError = kShbBufferAlreadyCompleted;
goto Exit;
}
if (ulDataChunkSize_p > pShbCirChunk_p->m_ulAvailableSize) {
ShbError = kShbExceedDataSizeLimit;
goto Exit;
}
pShbCirBuff = ShbCirGetBuffer(pShbInstance_p);
pScrDataPtr = (unsigned char *)pSrcDataChunk_p;
fSignalNewData = FALSE;
fSignalReset = FALSE;
ShbError = kShbOk;
if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
ulWrIndex = pShbCirChunk_p->m_ulWrIndex;
// copy the data to the circular buffer
// (the copy process itself will be done outside of any
// critical/locked section)
pShbCirDataPtr = &pShbCirBuff->m_Data; // ptr to start of data area
if (ulWrIndex + ulDataChunkSize_p <= pShbCirBuff->m_ulBufferDataSize) {
// linear write operation
memcpy(pShbCirDataPtr + ulWrIndex, pScrDataPtr,
ulDataChunkSize_p);
} else {
// wrap-around write operation
ulSubChunkSize = pShbCirBuff->m_ulBufferDataSize - ulWrIndex;
memcpy(pShbCirDataPtr + ulWrIndex, pScrDataPtr, ulSubChunkSize);
memcpy(pShbCirDataPtr, pScrDataPtr + ulSubChunkSize,
ulDataChunkSize_p - ulSubChunkSize);
}
// adjust chunk descriptor
ulWrIndex += ulDataChunkSize_p;
ulWrIndex %= pShbCirBuff->m_ulBufferDataSize;
pShbCirChunk_p->m_ulAvailableSize -= ulDataChunkSize_p;
pShbCirChunk_p->m_ulWrIndex = ulWrIndex;
fBufferCompleted = (pShbCirChunk_p->m_ulAvailableSize == 0);
pShbCirChunk_p->m_fBufferCompleted = fBufferCompleted;
// if the complete allocated buffer is filled with data then
// adjust header information for circular buffer with properties
// of the wiritten data block
if (fBufferCompleted) {
ShbIpcEnterAtomicSection(pShbInstance_p);
{
pShbCirBuff->m_ulDataApended +=
pShbCirChunk_p->m_uiFullBlockSize;
pShbCirBuff->m_ulBlocksApended++;
// decrement number of currently (parallel running) write operations
if (!--pShbCirBuff->m_ulNumOfWriteJobs) {
// if there is no other write process running then
// set new size of readable (complete written) data and
// adjust number of readable blocks
pShbCirBuff->m_ulDataReadable +=
pShbCirBuff->m_ulDataApended;
pShbCirBuff->m_ulBlocksReadable +=
pShbCirBuff->m_ulBlocksApended;
pShbCirBuff->m_ulDataApended = 0;
pShbCirBuff->m_ulBlocksApended = 0;
fSignalNewData = TRUE;
fSignalReset = pShbCirBuff->m_fBufferLocked;
}
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
}
// signal new data event to a potentially reading application
if (fSignalNewData) {
ShbError2 = ShbIpcSignalNewData(pShbInstance_p);
if (ShbError == kShbOk) {
ShbError = ShbError2;
}
}
// signal that the last write job has been finished to allow
// a waiting application to reset the buffer now
if (fSignalReset) {
ShbError2 = ShbIpcSignalJobReady(pShbInstance_p);
if (ShbError == kShbOk) {
ShbError = ShbError2;
}
}
*pfBufferCompleted_p = fBufferCompleted;
Exit:
return (ShbError);
}
//---------------------------------------------------------------------------
// Read data block from Circular Shared Buffer
//---------------------------------------------------------------------------
tShbError ShbCirReadDataBlock(tShbInstance pShbInstance_p,
void *pDstDataBlock_p,
unsigned long ulRdBuffSize_p,
unsigned long *pulDataBlockSize_p)
{
tShbCirBuff *pShbCirBuff;
tShbCirBlockSize ShbCirBlockSize;
unsigned long ulDataReadable;
unsigned char *pShbCirDataPtr;
unsigned char *pDstDataPtr;
unsigned long ulDataSize = 0; // d.k. GCC complains about uninitialized variable otherwise
unsigned long ulChunkSize;
unsigned long ulRdIndex;
tShbError ShbError;
// check arguments
if ((pShbInstance_p == NULL) || (pulDataBlockSize_p == NULL)) {
return (kShbInvalidArg);
}
if ((pDstDataBlock_p == NULL) || (ulRdBuffSize_p == 0)) {
// nothing to do here
ShbError = kShbOk;
goto Exit;
}
ShbError = kShbOk;
pShbCirBuff = ShbCirGetBuffer(pShbInstance_p);
pDstDataPtr = (unsigned char *)pDstDataBlock_p;
ulDataSize = 0;
if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
// get total number of readable bytes for the whole circular buffer
ShbIpcEnterAtomicSection(pShbInstance_p);
{
ulDataReadable = pShbCirBuff->m_ulDataReadable;
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
// if there are readable data available, then there must be at least
// one complete readable data block
if (ulDataReadable > 0) {
// get pointer to start of data area and current read index
pShbCirDataPtr = &pShbCirBuff->m_Data; // ptr to start of data area
ulRdIndex = pShbCirBuff->m_ulRdIndex;
// get real size of current block (incl. alignment fill bytes)
ShbCirBlockSize =
*(tShbCirBlockSize *) (pShbCirDataPtr + ulRdIndex);
ulRdIndex += sizeof(tShbCirBlockSize);
ulRdIndex %= pShbCirBuff->m_ulBufferDataSize;
// get size of user data inside the current block
ulDataSize =
ShbCirBlockSize.m_uiFullBlockSize -
ShbCirBlockSize.m_uiAlignFillBytes;
ulDataSize -= sizeof(tShbCirBlockSize);
}
// ulDataSize = MIN(ulDataSize, ulRdBuffSize_p);
if (ulDataSize > ulRdBuffSize_p) {
ulDataSize = ulRdBuffSize_p;
ShbError = kShbDataTruncated;
}
if (ulDataSize == 0) {
// nothing to do here
ShbError = kShbNoReadableData;
goto Exit;
}
// copy the data from the circular buffer
// (the copy process itself will be done outside of any
// critical/locked section)
if (ulRdIndex + ulDataSize <= pShbCirBuff->m_ulBufferDataSize) {
// linear read operation
memcpy(pDstDataPtr, pShbCirDataPtr + ulRdIndex, ulDataSize);
} else {
// wrap-around read operation
ulChunkSize = pShbCirBuff->m_ulBufferDataSize - ulRdIndex;
memcpy(pDstDataPtr, pShbCirDataPtr + ulRdIndex, ulChunkSize);
memcpy(pDstDataPtr + ulChunkSize, pShbCirDataPtr,
ulDataSize - ulChunkSize);
}
#ifndef NDEBUG
{
tShbCirBlockSize ClrShbCirBlockSize;
if (ulRdIndex + ulDataSize <= pShbCirBuff->m_ulBufferDataSize) {
// linear buffer
memset(pShbCirDataPtr + ulRdIndex, 0xDD, ulDataSize);
} else {
// wrap-around read operation
ulChunkSize =
pShbCirBuff->m_ulBufferDataSize - ulRdIndex;
memset(pShbCirDataPtr + ulRdIndex, 0xDD, ulChunkSize);
memset(pShbCirDataPtr, 0xDD, ulDataSize - ulChunkSize);
}
ClrShbCirBlockSize.m_uiFullBlockSize = /*(unsigned int) */ -1; // -1 = xFFFFFFF
ClrShbCirBlockSize.m_uiAlignFillBytes = /*(unsigned int) */ -1; // -1 = Fxxxxxxx
*(tShbCirBlockSize *) (pShbCirDataPtr +
pShbCirBuff->m_ulRdIndex) =
ClrShbCirBlockSize;
}
#endif // #ifndef NDEBUG
// set new size of readable data, data in use, new read index
// and adjust number of readable blocks
ShbIpcEnterAtomicSection(pShbInstance_p);
{
pShbCirBuff->m_ulDataInUse -= ShbCirBlockSize.m_uiFullBlockSize;
pShbCirBuff->m_ulDataReadable -=
ShbCirBlockSize.m_uiFullBlockSize;
pShbCirBuff->m_ulBlocksReadable--;
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
if ((pShbCirBuff->m_ulDataInUse == 0)
&& (pShbCirBuff->m_ulDataReadable == 0)) {
ASSERT(pShbCirBuff->m_ulBlocksReadable == 0);
pShbCirBuff->m_ulWrIndex = 0;
pShbCirBuff->m_ulRdIndex = 0;
} else
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
{
pShbCirBuff->m_ulRdIndex +=
ShbCirBlockSize.m_uiFullBlockSize;
pShbCirBuff->m_ulRdIndex %=
pShbCirBuff->m_ulBufferDataSize;
}
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
Exit:
*pulDataBlockSize_p = ulDataSize;
return (ShbError);
}
//---------------------------------------------------------------------------
// Get data size of next readable block from Circular Shared Buffer
//---------------------------------------------------------------------------
tShbError ShbCirGetReadDataSize(tShbInstance pShbInstance_p,
unsigned long *pulDataBlockSize_p)
{
tShbCirBuff *pShbCirBuff;
unsigned long ulDataReadable;
unsigned char *pShbCirDataPtr;
tShbCirBlockSize ShbCirBlockSize;
unsigned long ulDataSize;
tShbError ShbError;
// check arguments
if ((pShbInstance_p == NULL) || (pulDataBlockSize_p == NULL)) {
return (kShbInvalidArg);
}
pShbCirBuff = ShbCirGetBuffer(pShbInstance_p);
ulDataSize = 0;
ShbError = kShbOk;
if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
// get total number of readable bytes for the whole circular buffer
ShbIpcEnterAtomicSection(pShbInstance_p);
{
ulDataReadable = pShbCirBuff->m_ulDataReadable;
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
// if there are readable data available, then there must be at least
// one complete readable data block
if (ulDataReadable > 0) {
pShbCirDataPtr =
&pShbCirBuff->m_Data + pShbCirBuff->m_ulRdIndex;
// get real size of current block (incl. alignment fill bytes)
ShbCirBlockSize = *(tShbCirBlockSize *) pShbCirDataPtr;
// get size of user data inside the current block
ulDataSize =
ShbCirBlockSize.m_uiFullBlockSize -
ShbCirBlockSize.m_uiAlignFillBytes;
ulDataSize -= sizeof(tShbCirBlockSize);
}
Exit:
*pulDataBlockSize_p = ulDataSize;
return (ShbError);
}
//---------------------------------------------------------------------------
// Get number of readable blocks from Circular Shared Buffer
//---------------------------------------------------------------------------
tShbError ShbCirGetReadBlockCount(tShbInstance pShbInstance_p,
unsigned long *pulDataBlockCount_p)
{
tShbCirBuff *pShbCirBuff;
unsigned long ulBlockCount;
tShbError ShbError;
// check arguments
if ((pShbInstance_p == NULL) || (pulDataBlockCount_p == NULL)) {
ShbError = kShbInvalidArg;
goto Exit;
}
pShbCirBuff = ShbCirGetBuffer(pShbInstance_p);
ulBlockCount = 0;
ShbError = kShbOk;
if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
ShbIpcEnterAtomicSection(pShbInstance_p);
{
ulBlockCount = pShbCirBuff->m_ulBlocksReadable;
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
*pulDataBlockCount_p = ulBlockCount;
Exit:
return (ShbError);
}
//---------------------------------------------------------------------------
// Set application handler to signal new data for Circular Shared Buffer
// d.k.: new parameter priority as enum
//---------------------------------------------------------------------------
tShbError ShbCirSetSignalHandlerNewData(tShbInstance pShbInstance_p,
tShbCirSigHndlrNewData pfnSignalHandlerNewData_p,
tShbPriority ShbPriority_p)
{
tShbCirBuff *pShbCirBuff;
tShbError ShbError;
// check arguments
if (pShbInstance_p == NULL) {
ShbError = kShbInvalidArg;
goto Exit;
}
pShbCirBuff = ShbCirGetBuffer(pShbInstance_p);
ShbError = kShbOk;
if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
if (pfnSignalHandlerNewData_p != NULL) {
// set a new signal handler
if (pShbCirBuff->m_pfnSigHndlrNewData != NULL) {
ShbError = kShbAlreadySignaling;
goto Exit;
}
pShbCirBuff->m_pfnSigHndlrNewData = pfnSignalHandlerNewData_p;
ShbError =
ShbIpcStartSignalingNewData(pShbInstance_p,
ShbCirSignalHandlerNewData,
ShbPriority_p);
} else {
// remove existing signal handler
ShbError = ShbIpcStopSignalingNewData(pShbInstance_p);
if (pShbCirBuff->m_pfnSigHndlrNewData != NULL) {
pShbCirBuff->m_pfnSigHndlrNewData(pShbInstance_p, 0);
}
pShbCirBuff->m_pfnSigHndlrNewData = NULL;
}
Exit:
return (ShbError);
}
//---------------------------------------------------------------------------
// DEBUG: Trace Circular Shared Buffer
//---------------------------------------------------------------------------
#ifndef NDEBUG
tShbError ShbCirTraceBuffer(tShbInstance pShbInstance_p)
{
tShbCirBuff *pShbCirBuff;
char szMagigID[sizeof(SBC_MAGIC_ID) + 1];
tShbCirBlockSize ShbCirBlockSize;
unsigned long ulDataReadable;
unsigned char *pShbCirDataPtr;
unsigned long ulBlockIndex;
unsigned int nBlockCount;
unsigned long ulDataSize;
unsigned long ulChunkSize;
unsigned long ulRdIndex;
tShbError ShbError;
TRACE0("\n\n##### Circular Shared Buffer #####\n");
// check arguments
if (pShbInstance_p == NULL) {
TRACE1("\nERROR: invalid buffer address (0x%08lX)\n",
(unsigned long)pShbInstance_p);
ShbError = kShbInvalidArg;
goto Exit;
}
pShbCirBuff = ShbCirGetBuffer(pShbInstance_p);
ShbError = kShbOk;
if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
*(unsigned long *)&szMagigID[0] = pShbCirBuff->m_ShbCirMagicID;
szMagigID[sizeof(SBC_MAGIC_ID)] = '\0';
ShbIpcEnterAtomicSection(pShbInstance_p);
{
TRACE1("\nBuffer Address: 0x%08lX\n",
(unsigned long)pShbCirBuff);
TRACE0("\nHeader Info:");
TRACE2("\nMagigID: '%s' (%08lX)", szMagigID,
pShbCirBuff->m_ShbCirMagicID);
TRACE1("\nBufferTotalSize: %4lu [Bytes]",
pShbCirBuff->m_ulBufferTotalSize);
TRACE1("\nBufferDataSize: %4lu [Bytes]",
pShbCirBuff->m_ulBufferDataSize);
TRACE1("\nWrIndex: %4lu", pShbCirBuff->m_ulWrIndex);
TRACE1("\nRdIndex: %4lu", pShbCirBuff->m_ulRdIndex);
TRACE1("\nNumOfWriteJobs: %4lu",
pShbCirBuff->m_ulNumOfWriteJobs);
TRACE1("\nDataInUse: %4lu [Bytes]",
pShbCirBuff->m_ulDataInUse);
TRACE1("\nDataApended: %4lu [Bytes]",
pShbCirBuff->m_ulDataApended);
TRACE1("\nBlocksApended: %4lu",
pShbCirBuff->m_ulBlocksApended);
TRACE1("\nDataReadable: %4lu [Bytes]",
pShbCirBuff->m_ulDataReadable);
TRACE1("\nBlocksReadable: %4lu",
pShbCirBuff->m_ulBlocksReadable);
TRACE1("\nSigHndlrNewData: %08lX",
(unsigned long)pShbCirBuff->m_pfnSigHndlrNewData);
TRACE1("\nBufferLocked: %d", pShbCirBuff->m_fBufferLocked);
TRACE1("\nSigHndlrReset: %08lX",
(unsigned long)pShbCirBuff->m_pfnSigHndlrReset);
ShbTraceDump(&pShbCirBuff->m_Data,
pShbCirBuff->m_ulBufferDataSize, 0x00000000L,
"\nData Area:");
ulDataReadable = pShbCirBuff->m_ulDataReadable;
nBlockCount = 1;
ulBlockIndex = pShbCirBuff->m_ulRdIndex;
while (ulDataReadable > 0) {
TRACE1("\n\n--- Block #%u ---", nBlockCount);
// get pointer to start of data area and current read index
pShbCirDataPtr = &pShbCirBuff->m_Data; // ptr to start of data area
ulRdIndex = ulBlockIndex;
// get real size of current block (incl. alignment fill bytes)
ShbCirBlockSize =
*(tShbCirBlockSize *) (pShbCirDataPtr + ulRdIndex);
ulRdIndex += sizeof(tShbCirBlockSize);
ulRdIndex %= pShbCirBuff->m_ulBufferDataSize;
// get size of user data inside the current block
ulDataSize =
ShbCirBlockSize.m_uiFullBlockSize -
ShbCirBlockSize.m_uiAlignFillBytes;
ulDataSize -= sizeof(tShbCirBlockSize);
TRACE1
("\nFull Data Size: %4u [Bytes] (incl. header and alignment fill bytes)",
ShbCirBlockSize.m_uiFullBlockSize);
TRACE1("\nUser Data Size: %4lu [Bytes]",
ulDataSize);
TRACE1("\nAlignment Fill Bytes: %4u [Bytes]",
ShbCirBlockSize.m_uiAlignFillBytes);
if (ulRdIndex + ulDataSize <=
pShbCirBuff->m_ulBufferDataSize) {
// linear data buffer
ShbTraceDump(pShbCirDataPtr + ulRdIndex,
ulDataSize, 0x00000000L, NULL);
} else {
// wrap-around data buffer
ulChunkSize =
pShbCirBuff->m_ulBufferDataSize - ulRdIndex;
ShbTraceDump(pShbCirDataPtr + ulRdIndex,
ulChunkSize, 0x00000000L, NULL);
ShbTraceDump(pShbCirDataPtr,
ulDataSize - ulChunkSize,
ulChunkSize, NULL);
}
nBlockCount++;
ulBlockIndex += ShbCirBlockSize.m_uiFullBlockSize;
ulBlockIndex %= pShbCirBuff->m_ulBufferDataSize;
ulDataReadable -= ShbCirBlockSize.m_uiFullBlockSize;
}
ASSERT(pShbCirBuff->m_ulBlocksReadable == nBlockCount - 1);
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
Exit:
return (ShbError);
}
#endif
//-------------------------------------------------------------------------//
// //
// L i n e a r S h a r e d B u f f e r //
// //
//-------------------------------------------------------------------------//
//---------------------------------------------------------------------------
// Allocate Linear Shared Buffer
//---------------------------------------------------------------------------
tShbError ShbLinAllocBuffer(unsigned long ulBufferSize_p,
const char *pszBufferID_p,
tShbInstance * ppShbInstance_p,
unsigned int *pfShbNewCreated_p)
{
tShbInstance pShbInstance;
tShbLinBuff *pShbLinBuff;
unsigned int fShbNewCreated;
unsigned long ulBufferDataSize;
unsigned long ulBufferTotalSize;
tShbError ShbError;
// check arguments
if ((ulBufferSize_p == 0) || (ppShbInstance_p == NULL)) {
return (kShbInvalidArg);
}
// calculate length of memory to allocate
ulBufferDataSize =
(ulBufferSize_p +
(SBL_BLOCK_ALIGNMENT - 1)) & ~(SBL_BLOCK_ALIGNMENT - 1);
ulBufferTotalSize = ulBufferDataSize + sizeof(tShbLinBuff);
// allocate a new or open an existing shared buffer
ShbError = ShbIpcAllocBuffer(ulBufferTotalSize, pszBufferID_p,
&pShbInstance, &fShbNewCreated);
if (ShbError != kShbOk) {
goto Exit;
}
if (pShbInstance == NULL) {
ShbError = kShbOutOfMem;
goto Exit;
}
// get pointer to shared buffer
pShbLinBuff = (tShbLinBuff *) ShbIpcGetShMemPtr(pShbInstance);
// if the shared buffer was new created, than this process has
// to initialize it, otherwise the buffer is already in use
// and *must not* be reseted
if (fShbNewCreated) {
#ifndef NDEBUG
{
memset(pShbLinBuff, 0xCC, ulBufferTotalSize);
}
#endif
pShbLinBuff->m_ShbLinMagicID = SBL_MAGIC_ID;
pShbLinBuff->m_ulBufferTotalSize = ulBufferTotalSize;
pShbLinBuff->m_ulBufferDataSize = ulBufferDataSize;
} else {
if (pShbLinBuff->m_ShbLinMagicID != SBL_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
}
Exit:
*ppShbInstance_p = pShbInstance;
*pfShbNewCreated_p = fShbNewCreated;
return (ShbError);
}
//---------------------------------------------------------------------------
// Release Linear Shared Buffer
//---------------------------------------------------------------------------
tShbError ShbLinReleaseBuffer(tShbInstance pShbInstance_p)
{
tShbError ShbError;
// check arguments
if (pShbInstance_p == NULL) {
ShbError = kShbOk;
goto Exit;
}
ShbError = ShbIpcReleaseBuffer(pShbInstance_p);
Exit:
return (ShbError);
}
//---------------------------------------------------------------------------
// Write data block to Linear Shared Buffer
//---------------------------------------------------------------------------
tShbError ShbLinWriteDataBlock(tShbInstance pShbInstance_p,
unsigned long ulDstBufferOffs_p,
const void *pSrcDataBlock_p,
unsigned long ulDataBlockSize_p)
{
tShbLinBuff *pShbLinBuff;
unsigned char *pShbLinDataPtr;
unsigned char *pScrDataPtr;
unsigned long ulBufferDataSize;
tShbError ShbError;
// check arguments
if (pShbInstance_p == NULL) {
ShbError = kShbInvalidArg;
goto Exit;
}
if ((pSrcDataBlock_p == NULL) || (ulDataBlockSize_p == 0)) {
// nothing to do here
ShbError = kShbOk;
goto Exit;
}
if (ulDataBlockSize_p > SBL_MAX_BLOCK_SIZE) {
ShbError = kShbExceedDataSizeLimit;
goto Exit;
}
pShbLinBuff = ShbLinGetBuffer(pShbInstance_p);
pScrDataPtr = (unsigned char *)pSrcDataBlock_p;
ShbError = kShbOk;
if (pShbLinBuff->m_ShbLinMagicID != SBL_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
// check if offeset and size for the write operation matches with
// the size of the shared buffer
ulBufferDataSize = pShbLinBuff->m_ulBufferDataSize;
if ((ulDstBufferOffs_p > ulBufferDataSize) ||
(ulDataBlockSize_p > ulBufferDataSize) ||
((ulDstBufferOffs_p + ulDataBlockSize_p) > ulBufferDataSize)) {
ShbError = kShbDataOutsideBufferArea;
goto Exit;
}
// copy the data to the linear buffer
// (the copy process will be done inside of any critical/locked section)
pShbLinDataPtr = &pShbLinBuff->m_Data; // ptr to start of data area
pShbLinDataPtr += ulDstBufferOffs_p;
ShbIpcEnterAtomicSection(pShbInstance_p);
{
memcpy(pShbLinDataPtr, pScrDataPtr, ulDataBlockSize_p);
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
Exit:
return (ShbError);
}
//---------------------------------------------------------------------------
// Read data block from Linear Shared Buffer
//---------------------------------------------------------------------------
tShbError ShbLinReadDataBlock(tShbInstance pShbInstance_p,
void *pDstDataBlock_p,
unsigned long ulSrcBufferOffs_p,
unsigned long ulDataBlockSize_p)
{
tShbLinBuff *pShbLinBuff;
unsigned char *pShbLinDataPtr;
unsigned char *pDstDataPtr;
unsigned long ulBufferDataSize;
tShbError ShbError;
// check arguments
if (pShbInstance_p == NULL) {
ShbError = kShbInvalidArg;
goto Exit;
}
if ((pDstDataBlock_p == NULL) || (ulDataBlockSize_p == 0)) {
// nothing to do here
ShbError = kShbOk;
goto Exit;
}
if (ulDataBlockSize_p > SBL_MAX_BLOCK_SIZE) {
ShbError = kShbExceedDataSizeLimit;
goto Exit;
}
pShbLinBuff = ShbLinGetBuffer(pShbInstance_p);
pDstDataPtr = (unsigned char *)pDstDataBlock_p;
ShbError = kShbOk;
if (pShbLinBuff->m_ShbLinMagicID != SBL_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
// check if offeset and size for the read operation matches with
// the size of the shared buffer
ulBufferDataSize = pShbLinBuff->m_ulBufferDataSize;
if ((ulSrcBufferOffs_p > ulBufferDataSize) ||
(ulDataBlockSize_p > ulBufferDataSize) ||
((ulSrcBufferOffs_p + ulDataBlockSize_p) > ulBufferDataSize)) {
ShbError = kShbDataOutsideBufferArea;
goto Exit;
}
// copy the data to the linear buffer
// (the copy process will be done inside of any critical/locked section)
pShbLinDataPtr = &pShbLinBuff->m_Data; // ptr to start of data area
pShbLinDataPtr += ulSrcBufferOffs_p;
ShbIpcEnterAtomicSection(pShbInstance_p);
{
memcpy(pDstDataPtr, pShbLinDataPtr, ulDataBlockSize_p);
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
Exit:
return (ShbError);
}
//---------------------------------------------------------------------------
// DEBUG: Trace Linear Shared Buffer
//---------------------------------------------------------------------------
#ifndef NDEBUG
tShbError ShbLinTraceBuffer(tShbInstance pShbInstance_p)
{
tShbLinBuff *pShbLinBuff;
char szMagigID[sizeof(SBL_MAGIC_ID) + 1];
tShbError ShbError;
TRACE0("\n\n##### Linear Shared Buffer #####\n");
// check arguments
if (pShbInstance_p == NULL) {
TRACE1("\nERROR: invalid buffer address (0x%08lX)\n",
(unsigned long)pShbInstance_p);
ShbError = kShbInvalidArg;
goto Exit;
}
pShbLinBuff = ShbLinGetBuffer(pShbInstance_p);
ShbError = kShbOk;
if (pShbLinBuff->m_ShbLinMagicID != SBL_MAGIC_ID) {
ShbError = kShbInvalidBufferType;
goto Exit;
}
*(unsigned int *)&szMagigID[0] = pShbLinBuff->m_ShbLinMagicID;
szMagigID[sizeof(SBL_MAGIC_ID)] = '\0';
ShbIpcEnterAtomicSection(pShbInstance_p);
{
TRACE1("\nBuffer Address: 0x%08lX\n",
(unsigned long)pShbLinBuff);
TRACE0("\nHeader Info:");
TRACE2("\nMagigID: '%s' (%08X)", szMagigID,
pShbLinBuff->m_ShbLinMagicID);
TRACE1("\nBufferTotalSize: %4lu [Bytes]",
pShbLinBuff->m_ulBufferTotalSize);
TRACE1("\nBufferDataSize: %4lu [Bytes]",
pShbLinBuff->m_ulBufferDataSize);
ShbTraceDump(&pShbLinBuff->m_Data,
pShbLinBuff->m_ulBufferDataSize, 0x00000000L,
"\nData Area:");
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
Exit:
return (ShbError);
}
#endif
//---------------------------------------------------------------------------
// Dump buffer contents
//---------------------------------------------------------------------------
#ifndef NDEBUG
tShbError ShbTraceDump(const unsigned char *pabStartAddr_p,
unsigned long ulDataSize_p,
unsigned long ulAddrOffset_p, const char *pszInfoText_p)
{
const unsigned char *pabBuffData;
unsigned long ulBuffSize;
unsigned char bData;
int nRow;
int nCol;
// get pointer to buffer and length of buffer
pabBuffData = pabStartAddr_p;
ulBuffSize = ulDataSize_p;
if (pszInfoText_p != NULL) {
TRACE1("%s", pszInfoText_p);
}
// dump buffer contents
for (nRow = 0;; nRow++) {
TRACE1("\n%08lX: ",
(unsigned long)(nRow * 0x10) + ulAddrOffset_p);
for (nCol = 0; nCol < 16; nCol++) {
if ((unsigned long)nCol < ulBuffSize) {
TRACE1("%02X ",
(unsigned int)*(pabBuffData + nCol));
} else {
TRACE0(" ");
}
}
TRACE0(" ");
for (nCol = 0; nCol < 16; nCol++) {
bData = *pabBuffData++;
if ((unsigned long)nCol < ulBuffSize) {
if ((bData >= 0x20) && (bData < 0x7F)) {
TRACE1("%c", bData);
} else {
TRACE0(".");
}
} else {
TRACE0(" ");
}
}
if (ulBuffSize > 16) {
ulBuffSize -= 16;
} else {
break;
}
}
return (kShbOk);
}
#endif // #ifndef NDEBUG
//=========================================================================//
// //
// P R I V A T E F U N C T I O N S //
// //
//=========================================================================//
//---------------------------------------------------------------------------
// Handler to signal new data event for Circular Shared Buffer
//---------------------------------------------------------------------------
int ShbCirSignalHandlerNewData(tShbInstance pShbInstance_p)
{
tShbCirBuff *pShbCirBuff;
unsigned long ulDataSize;
unsigned long ulBlockCount;
tShbError ShbError;
// check arguments
if (pShbInstance_p == NULL) {
return FALSE;
}
pShbCirBuff = ShbCirGetBuffer(pShbInstance_p);
ShbError = kShbOk;
if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) {
return FALSE;
}
// call application handler
if (pShbCirBuff->m_pfnSigHndlrNewData != NULL) {
/* do
{*/
ShbError = ShbCirGetReadDataSize(pShbInstance_p, &ulDataSize);
if ((ulDataSize > 0) && (ShbError == kShbOk)) {
pShbCirBuff->m_pfnSigHndlrNewData(pShbInstance_p,
ulDataSize);
}
ShbError =
ShbCirGetReadBlockCount(pShbInstance_p, &ulBlockCount);
/* }
while ((ulBlockCount > 0) && (ShbError == kShbOk));*/
}
// Return TRUE if there are pending blocks.
// In that case ShbIpc tries to call this function again immediately if there
// is no other filled shared buffer with higher priority.
return ((ulBlockCount > 0) && (ShbError == kShbOk));
}
//---------------------------------------------------------------------------
// Handler to reset Circular Shared Buffer
//---------------------------------------------------------------------------
void ShbCirSignalHandlerReset(tShbInstance pShbInstance_p,
unsigned int fTimeOut_p)
{
tShbCirBuff *pShbCirBuff;
// check arguments
if (pShbInstance_p == NULL) {
return;
}
pShbCirBuff = ShbCirGetBuffer(pShbInstance_p);
if (pShbCirBuff->m_ShbCirMagicID != SBC_MAGIC_ID) {
return;
}
// reset buffer header
if (!fTimeOut_p) {
ShbIpcEnterAtomicSection(pShbInstance_p);
{
pShbCirBuff->m_ulWrIndex = 0;
pShbCirBuff->m_ulRdIndex = 0;
pShbCirBuff->m_ulNumOfWriteJobs = 0;
pShbCirBuff->m_ulDataInUse = 0;
pShbCirBuff->m_ulDataApended = 0;
pShbCirBuff->m_ulBlocksApended = 0;
pShbCirBuff->m_ulDataReadable = 0;
pShbCirBuff->m_ulBlocksReadable = 0;
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
#ifndef NDEBUG
{
memset(&pShbCirBuff->m_Data, 0xCC,
pShbCirBuff->m_ulBufferDataSize);
}
#endif
}
// call application handler
if (pShbCirBuff->m_pfnSigHndlrReset != NULL) {
pShbCirBuff->m_pfnSigHndlrReset(pShbInstance_p, fTimeOut_p);
}
// unlock buffer
ShbIpcEnterAtomicSection(pShbInstance_p);
{
pShbCirBuff->m_fBufferLocked = FALSE;
pShbCirBuff->m_pfnSigHndlrReset = NULL;
}
ShbIpcLeaveAtomicSection(pShbInstance_p);
return;
}
// EOF
