Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 563b125d authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

Staging: epl: remove INLINE mess 



extern inline isn't the nicest and it doesn't really make sense.
So unwind all the INLINE defines and includes, if speed is _really_ an
issue later stuff can be put back in a sane manner.

Cc: Daniel Krueger <daniel.krueger@systec-electronic.com>
Cc: Ronald Sieber <Ronald.Sieber@systec-electronic.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 54e49ddd

drivers/staging/epl/EplAmi.h

+0 −21
Original line number Diff line number Diff line
@@ -104,18 +104,6 @@ 
extern "C" {

#endif



#if (TARGET_SYSTEM == _LINUX_)

#if defined(__m68k__)		// it is an big endian machine

#if defined(INLINE_FUNCTION_DEF)

#undef  INLINE_FUNCTION

#define INLINE_FUNCTION     INLINE_FUNCTION_DEF

#define INLINE_ENABLED      TRUE

#define EPL_AMI_INLINED

#include "../EplStack/amibe.c"

#endif

#endif

#endif



//---------------------------------------------------------------------------

//

// write functions
@@ -127,12 +115,10 @@ extern "C" { 
#define AmiSetByteToBe(pAddr_p, bByteVal_p)  {*(BYTE FAR*)(pAddr_p) = (bByteVal_p);}

#define AmiSetByteToLe(pAddr_p, bByteVal_p)  {*(BYTE FAR*)(pAddr_p) = (bByteVal_p);}



#if !defined(INLINE_ENABLED)

void AmiSetWordToBe(void FAR *pAddr_p, WORD wWordVal_p);

void AmiSetDwordToBe(void FAR *pAddr_p, DWORD dwDwordVal_p);

void AmiSetWordToLe(void FAR *pAddr_p, WORD wWordVal_p);

void AmiSetDwordToLe(void FAR *pAddr_p, DWORD dwDwordVal_p);

#endif



//---------------------------------------------------------------------------

//
@@ -145,8 +131,6 @@ void AmiSetDwordToLe(void FAR *pAddr_p, DWORD dwDwordVal_p); 
#define AmiGetByteFromBe(pAddr_p)  (*(BYTE FAR*)(pAddr_p))

#define AmiGetByteFromLe(pAddr_p)  (*(BYTE FAR*)(pAddr_p))



#if !defined(INLINE_ENABLED)



WORD AmiGetWordFromBe(void FAR *pAddr_p);

DWORD AmiGetDwordFromBe(void FAR *pAddr_p);

WORD AmiGetWordFromLe(void FAR *pAddr_p);
@@ -337,11 +321,6 @@ void AmiSetTimeOfDay(void FAR *pAddr_p, tTimeOfDay FAR *pTimeOfDay_p); 
//---------------------------------------------------------------------------

void AmiGetTimeOfDay(void FAR *pAddr_p, tTimeOfDay FAR *pTimeOfDay_p);



#endif



#undef  INLINE_ENABLED		// disable actual inlining of functions

#define EPL_AMI_INCLUDED



#ifdef __cplusplus

}

#endif

drivers/staging/epl/SharedBuff.c

+36 −66
Original line number Diff line number Diff line
@@ -88,6 +88,7 @@ 
// d.k. Linux kernel modules needs other header files for memcpy()

#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)

#include <linux/string.h>

#include <linux/kernel.h>

#else

#include <stdio.h>

#include <stdlib.h>
@@ -102,8 +103,6 @@ 
/*                                                                         */

/***************************************************************************/



#if (!defined(SHAREDBUFF_INLINED)) || defined(INLINE_ENABLED)



//---------------------------------------------------------------------------

//  Configuration

//---------------------------------------------------------------------------
@@ -177,7 +176,7 @@ typedef struct { 
//  Get pointer to Circular Shared Buffer

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbCirBuff *ShbCirGetBuffer(tShbInstance pShbInstance_p)

tShbCirBuff *ShbCirGetBuffer(tShbInstance pShbInstance_p)

{



	tShbCirBuff *pShbCirBuff;
@@ -193,7 +192,7 @@ INLINE_FUNCTION tShbCirBuff *ShbCirGetBuffer(tShbInstance pShbInstance_p) 
//  Get pointer to Linear Shared Buffer

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbLinBuff *ShbLinGetBuffer(tShbInstance pShbInstance_p)

tShbLinBuff *ShbLinGetBuffer(tShbInstance pShbInstance_p)

{



	tShbLinBuff *pShbLinBuff;
@@ -210,7 +209,6 @@ int ShbCirSignalHandlerNewData(tShbInstance pShbInstance_p); 
void ShbCirSignalHandlerReset(tShbInstance pShbInstance_p,

			      unsigned int fTimeOut_p);



#endif



//=========================================================================//

//                                                                         //
@@ -218,7 +216,6 @@ void ShbCirSignalHandlerReset(tShbInstance pShbInstance_p, 
//                                                                         //

//=========================================================================//



#if !defined(INLINE_ENABLED)

// not inlined external functions



//---------------------------------------------------------------------------
@@ -363,18 +360,13 @@ tShbError ShbCirReleaseBuffer(tShbInstance pShbInstance_p) 


}



#endif // !defined(INLINE_ENABLED)



#if (!defined(SHAREDBUFF_INLINED)) || defined(INLINE_ENABLED)



//---------------------------------------------------------------------------

//  Reset Circular Shared Buffer

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbCirResetBuffer(tShbInstance pShbInstance_p,

tShbError ShbCirResetBuffer(tShbInstance pShbInstance_p,

			    unsigned long ulTimeOut_p,

					    tShbCirSigHndlrReset

					    pfnSignalHandlerReset_p)

			    tShbCirSigHndlrReset pfnSignalHandlerReset_p)

{



	tShbCirBuff *pShbCirBuff;
@@ -440,7 +432,7 @@ INLINE_FUNCTION tShbError ShbCirResetBuffer(tShbInstance pShbInstance_p, 
//  Write data block to Circular Shared Buffer

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbCirWriteDataBlock(tShbInstance pShbInstance_p,

tShbError ShbCirWriteDataBlock(tShbInstance pShbInstance_p,

			       const void *pSrcDataBlock_p,

			       unsigned long ulDataBlockSize_p)

{
@@ -608,7 +600,7 @@ INLINE_FUNCTION tShbError ShbCirWriteDataBlock(tShbInstance pShbInstance_p, 
//  Allocate block within the Circular Shared Buffer for chunk writing

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbCirAllocDataBlock(tShbInstance pShbInstance_p,

tShbError ShbCirAllocDataBlock(tShbInstance pShbInstance_p,

			       tShbCirChunk * pShbCirChunk_p,

			       unsigned long ulDataBufferSize_p)

{
@@ -717,12 +709,11 @@ INLINE_FUNCTION tShbError ShbCirAllocDataBlock(tShbInstance pShbInstance_p, 
//  Write data chunk into an allocated buffer of the Circular Shared Buffer

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbCirWriteDataChunk(tShbInstance pShbInstance_p,

tShbError ShbCirWriteDataChunk(tShbInstance pShbInstance_p,

			       tShbCirChunk *pShbCirChunk_p,

			       const void *pSrcDataChunk_p,

			       unsigned long ulDataChunkSize_p,

					       unsigned int

					       *pfBufferCompleted_p)

			       unsigned int *pfBufferCompleted_p)

{



	tShbCirBuff *pShbCirBuff;
@@ -857,7 +848,7 @@ INLINE_FUNCTION tShbError ShbCirWriteDataChunk(tShbInstance pShbInstance_p, 
//  Read data block from Circular Shared Buffer

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbCirReadDataBlock(tShbInstance pShbInstance_p,

tShbError ShbCirReadDataBlock(tShbInstance pShbInstance_p,

			      void *pDstDataBlock_p,

			      unsigned long ulRdBuffSize_p,

			      unsigned long *pulDataBlockSize_p)
@@ -1009,9 +1000,8 @@ INLINE_FUNCTION tShbError ShbCirReadDataBlock(tShbInstance pShbInstance_p, 
//  Get data size of next readable block from Circular Shared Buffer

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbCirGetReadDataSize(tShbInstance pShbInstance_p,

						unsigned long

						*pulDataBlockSize_p)

tShbError ShbCirGetReadDataSize(tShbInstance pShbInstance_p,

				unsigned long *pulDataBlockSize_p)

{



	tShbCirBuff *pShbCirBuff;
@@ -1070,9 +1060,8 @@ INLINE_FUNCTION tShbError ShbCirGetReadDataSize(tShbInstance pShbInstance_p, 
//  Get number of readable blocks from Circular Shared Buffer

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbCirGetReadBlockCount(tShbInstance pShbInstance_p,

						  unsigned long

						  *pulDataBlockCount_p)

tShbError ShbCirGetReadBlockCount(tShbInstance pShbInstance_p,

				  unsigned long *pulDataBlockCount_p)

{



	tShbCirBuff *pShbCirBuff;
@@ -1113,12 +1102,9 @@ INLINE_FUNCTION tShbError ShbCirGetReadBlockCount(tShbInstance pShbInstance_p, 
//  d.k.: new parameter priority as enum

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbCirSetSignalHandlerNewData(tShbInstance

							pShbInstance_p,

							tShbCirSigHndlrNewData

							pfnSignalHandlerNewData_p,

							tShbPriority

							ShbPriority_p)

tShbError ShbCirSetSignalHandlerNewData(tShbInstance pShbInstance_p,

					tShbCirSigHndlrNewData pfnSignalHandlerNewData_p,

					tShbPriority ShbPriority_p)

{



	tShbCirBuff *pShbCirBuff;
@@ -1165,10 +1151,6 @@ INLINE_FUNCTION tShbError ShbCirSetSignalHandlerNewData(tShbInstance 


}



#endif



#if !defined(INLINE_ENABLED)



//---------------------------------------------------------------------------

//  DEBUG: Trace Circular Shared Buffer

//---------------------------------------------------------------------------
@@ -1413,15 +1395,10 @@ tShbError ShbLinReleaseBuffer(tShbInstance pShbInstance_p) 


}



#endif // !defined(INLINE_ENABLED)



#if (!defined(SHAREDBUFF_INLINED)) || defined(INLINE_ENABLED)



//---------------------------------------------------------------------------

//  Write data block to Linear Shared Buffer

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbLinWriteDataBlock(tShbInstance pShbInstance_p,

tShbError ShbLinWriteDataBlock(tShbInstance pShbInstance_p,

			       unsigned long ulDstBufferOffs_p,

			       const void *pSrcDataBlock_p,

			       unsigned long ulDataBlockSize_p)
@@ -1489,8 +1466,7 @@ INLINE_FUNCTION tShbError ShbLinWriteDataBlock(tShbInstance pShbInstance_p, 
//---------------------------------------------------------------------------

//  Read data block from Linear Shared Buffer

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbLinReadDataBlock(tShbInstance pShbInstance_p,

tShbError ShbLinReadDataBlock(tShbInstance pShbInstance_p,

			      void *pDstDataBlock_p,

			      unsigned long ulSrcBufferOffs_p,

			      unsigned long ulDataBlockSize_p)
@@ -1555,10 +1531,6 @@ INLINE_FUNCTION tShbError ShbLinReadDataBlock(tShbInstance pShbInstance_p, 


}



#endif



#if !defined(INLINE_ENABLED)



//---------------------------------------------------------------------------

//  DEBUG: Trace Linear Shared Buffer

//---------------------------------------------------------------------------
@@ -1794,6 +1766,4 @@ void ShbCirSignalHandlerReset(tShbInstance pShbInstance_p, 


}



#endif



// EOF

drivers/staging/epl/SharedBuff.h

+0 −17
Original line number Diff line number Diff line
@@ -110,15 +110,6 @@ typedef void (*tShbCirSigHndlrReset) (tShbInstance pShbInstance_p, 
extern "C" {

#endif



/*#if defined(INLINE_FUNCTION_DEF)

    #undef  INLINE_FUNCTION

    #define INLINE_FUNCTION     INLINE_FUNCTION_DEF

    #define INLINE_ENABLED      TRUE

    #define SHAREDBUFF_INLINED

    #include "SharedBuff.c"

#endif

*/



	tShbError ShbInit(void);

	tShbError ShbExit(void);
@@ -129,7 +120,6 @@ extern "C" { 
				    unsigned int *pfShbNewCreated_p);

	tShbError ShbCirReleaseBuffer(tShbInstance pShbInstance_p);



#if !defined(INLINE_ENABLED)



	tShbError ShbCirResetBuffer(tShbInstance pShbInstance_p,

				    unsigned long ulTimeOut_p,
@@ -159,7 +149,6 @@ extern "C" { 
						pfnShbSignalHandlerNewData_p,

						tShbPriority ShbPriority_p);



#endif



// Linear Shared Buffer

	tShbError ShbLinAllocBuffer(unsigned long ulBufferSize_p,
@@ -168,7 +157,6 @@ extern "C" { 
				    unsigned int *pfShbNewCreated_p);

	tShbError ShbLinReleaseBuffer(tShbInstance pShbInstance_p);



#if !defined(INLINE_ENABLED)



	tShbError ShbLinWriteDataBlock(tShbInstance pShbInstance_p,

				       unsigned long ulDstBufferOffs_p,
@@ -179,7 +167,6 @@ extern "C" { 
				      unsigned long ulSrcBufferOffs_p,

				      unsigned long ulDataBlockSize_p);



#endif



#ifndef NDEBUG

	tShbError ShbCirTraceBuffer(tShbInstance pShbInstance_p);
@@ -194,10 +181,6 @@ extern "C" { 
#define ShbTraceDump(p0, p1, p2, p3)

#endif



#undef  INLINE_ENABLED		// disable actual inlining of functions

#undef  INLINE_FUNCTION

#define INLINE_FUNCTION		// define INLINE_FUNCTION to nothing



#ifdef __cplusplus

}

#endif

drivers/staging/epl/ShbIpc-LinuxKernel.c

+12 −34
Original line number Diff line number Diff line
@@ -79,8 +79,6 @@ 
/*                                                                         */

/***************************************************************************/



#if (!defined(SHBIPC_INLINED)) || defined(SHBIPC_INLINE_ENABLED)



//---------------------------------------------------------------------------

//  Configuration

//---------------------------------------------------------------------------
@@ -211,13 +209,11 @@ static inline tShbMemHeader *ShbIpcGetShbMemHeader(tShbMemInst * pShbMemInst_p) 
// not inlined internal functions

int ShbIpcThreadSignalNewData(void *pvThreadParam_p);

int ShbIpcThreadSignalJobReady(void *pvThreadParam_p);

#endif



//---------------------------------------------------------------------------

// modul globale vars

//---------------------------------------------------------------------------



#if !defined(SHBIPC_INLINE_ENABLED)

struct sShbMemTable *psMemTableElementFirst_g;



static void *ShbIpcAllocPrivateMem(unsigned long ulMemSize_p);
@@ -230,7 +226,6 @@ static void ShbIpcCrc32GenTable(unsigned long aulCrcTable[256]); 
static unsigned long ShbIpcCrc32GetCrc(const char *pcString,

				       unsigned long aulCrcTable[256]);



#endif



//=========================================================================//

//                                                                         //
@@ -238,7 +233,6 @@ static unsigned long ShbIpcCrc32GetCrc(const char *pcString, 
//                                                                         //

//=========================================================================//



#if !defined(SHBIPC_INLINE_ENABLED)

// not inlined external functions



//---------------------------------------------------------------------------
@@ -433,15 +427,11 @@ tShbError ShbIpcReleaseBuffer(tShbInstance pShbInstance_p) 
	return (ShbError);

}



#endif // !defined(SHBIPC_INLINE_ENABLED)



#if (!defined(SHBIPC_INLINED)) || defined(SHBIPC_INLINE_ENABLED)



//---------------------------------------------------------------------------

//  Enter atomic section for Shared Buffer access

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbIpcEnterAtomicSection(tShbInstance pShbInstance_p)

tShbError ShbIpcEnterAtomicSection(tShbInstance pShbInstance_p)

{



	tShbMemInst *pShbMemInst;
@@ -469,7 +459,7 @@ INLINE_FUNCTION tShbError ShbIpcEnterAtomicSection(tShbInstance pShbInstance_p) 
//  Leave atomic section for Shared Buffer access

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbIpcLeaveAtomicSection(tShbInstance pShbInstance_p)

tShbError ShbIpcLeaveAtomicSection(tShbInstance pShbInstance_p)

{



	tShbMemInst *pShbMemInst;
@@ -496,12 +486,9 @@ INLINE_FUNCTION tShbError ShbIpcLeaveAtomicSection(tShbInstance pShbInstance_p) 
//  Start signaling of new data (called from reading process)

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbIpcStartSignalingNewData(tShbInstance

						      pShbInstance_p,

						      tSigHndlrNewData

						      pfnSignalHandlerNewData_p,

						      tShbPriority

						      ShbPriority_p)

tShbError ShbIpcStartSignalingNewData(tShbInstance pShbInstance_p,

				      tSigHndlrNewData pfnSignalHandlerNewData_p,

				      tShbPriority ShbPriority_p)

{

	tShbMemInst *pShbMemInst;

	tShbMemHeader *pShbMemHeader;
@@ -557,8 +544,7 @@ INLINE_FUNCTION tShbError ShbIpcStartSignalingNewData(tShbInstance 
//  Stop signaling of new data (called from reading process)

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbIpcStopSignalingNewData(tShbInstance

						     pShbInstance_p)

tShbError ShbIpcStopSignalingNewData(tShbInstance pShbInstance_p)

{

	tShbMemInst *pShbMemInst;

	tShbMemHeader *pShbMemHeader;
@@ -604,7 +590,7 @@ INLINE_FUNCTION tShbError ShbIpcStopSignalingNewData(tShbInstance 
//  Signal new data (called from writing process)

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbIpcSignalNewData(tShbInstance pShbInstance_p)

tShbError ShbIpcSignalNewData(tShbInstance pShbInstance_p)

{

	tShbMemHeader *pShbMemHeader;
@@ -625,12 +611,9 @@ INLINE_FUNCTION tShbError ShbIpcSignalNewData(tShbInstance pShbInstance_p) 
//  Start signaling for job ready (called from waiting process)

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbIpcStartSignalingJobReady(tShbInstance

						       pShbInstance_p,

						       unsigned long

						       ulTimeOut_p,

						       tSigHndlrJobReady

						       pfnSignalHandlerJobReady_p)

tShbError ShbIpcStartSignalingJobReady(tShbInstance pShbInstance_p,

				       unsigned long ulTimeOut_p,

				       tSigHndlrJobReady pfnSignalHandlerJobReady_p)

{

	tShbMemInst *pShbMemInst;

	tShbMemHeader *pShbMemHeader;
@@ -663,7 +646,7 @@ INLINE_FUNCTION tShbError ShbIpcStartSignalingJobReady(tShbInstance 
//  Signal job ready (called from executing process)

//---------------------------------------------------------------------------



INLINE_FUNCTION tShbError ShbIpcSignalJobReady(tShbInstance pShbInstance_p)

tShbError ShbIpcSignalJobReady(tShbInstance pShbInstance_p)

{

	tShbMemHeader *pShbMemHeader;
@@ -685,7 +668,7 @@ INLINE_FUNCTION tShbError ShbIpcSignalJobReady(tShbInstance pShbInstance_p) 
//  Get pointer to common used share memory area

//---------------------------------------------------------------------------



INLINE_FUNCTION void *ShbIpcGetShMemPtr(tShbInstance pShbInstance_p)

void *ShbIpcGetShMemPtr(tShbInstance pShbInstance_p)

{



	tShbMemHeader *pShbMemHeader;
@@ -703,16 +686,12 @@ INLINE_FUNCTION void *ShbIpcGetShMemPtr(tShbInstance pShbInstance_p) 


}



#endif



//=========================================================================//

//                                                                         //

//          P R I V A T E   F U N C T I O N S                              //

//                                                                         //

//=========================================================================//



#if !defined(SHBIPC_INLINE_ENABLED)



//---------------------------------------------------------------------------

//  Get pointer to process local information structure

//---------------------------------------------------------------------------
@@ -963,4 +942,3 @@ static void ShbIpcDeleteListElement(int iBufferId) 


}

#endif

drivers/staging/epl/ShbIpc.h

+0 −17
Original line number Diff line number Diff line
@@ -65,16 +65,6 @@ typedef int (*tSigHndlrNewData) (tShbInstance pShbInstance_p); 
typedef void (*tSigHndlrJobReady) (tShbInstance pShbInstance_p,

				   unsigned int fTimeOut_p);



#if (TARGET_SYSTEM == _LINUX_)

#if defined(INLINE_FUNCTION_DEF)

#undef  INLINE_FUNCTION

#define INLINE_FUNCTION     INLINE_FUNCTION_DEF

#define SHBIPC_INLINE_ENABLED      TRUE

#define SHBIPC_INLINED

#include "ShbIpc-LinuxKernel.c"

#endif

#endif



//---------------------------------------------------------------------------

//  Prototypes

//---------------------------------------------------------------------------
@@ -88,8 +78,6 @@ tShbError ShbIpcAllocBuffer(unsigned long ulBufferSize_p, 
			    unsigned int *pfShbNewCreated_p);

tShbError ShbIpcReleaseBuffer(tShbInstance pShbInstance_p);



#if !defined(SHBIPC_INLINE_ENABLED)



tShbError ShbIpcEnterAtomicSection(tShbInstance pShbInstance_p);

tShbError ShbIpcLeaveAtomicSection(tShbInstance pShbInstance_p);
@@ -107,10 +95,5 @@ tShbError ShbIpcStartSignalingJobReady(tShbInstance pShbInstance_p, 
tShbError ShbIpcSignalJobReady(tShbInstance pShbInstance_p);



void *ShbIpcGetShMemPtr(tShbInstance pShbInstance_p);

#endif



#undef  SHBIPC_INLINE_ENABLED	// disable actual inlining of functions

#undef  INLINE_FUNCTION

#define INLINE_FUNCTION		// define INLINE_FUNCTION to nothing



#endif // #ifndef _SHBIPC_H_