Staging: epl: run Lindent on *.c files

It's a start, still a mess...

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

1 files changed, 573 insertions, 638 deletions

diff --git a/drivers/staging/epl/ShbIpc-LinuxKernel.c b/drivers/staging/epl/ShbIpc-LinuxKernel.c
index 50a2f2dd473c..1d3cb3f13de1 100644
--- a/drivers/staging/epl/ShbIpc-LinuxKernel.c
+++ b/drivers/staging/epl/ShbIpc-LinuxKernel.c
@@ -55,7 +55,6 @@
 
 ****************************************************************************/
 
-
 #include "global.h"
 #include "SharedBuff.h"
 #include "ShbIpc.h"
@@ -72,8 +71,6 @@
 #include <linux/wait.h>
 #include <linux/completion.h>
 
-
-
 /***************************************************************************/
 /*                                                                         */
 /*                                                                         */
@@ -88,26 +85,23 @@
 //  Configuration
 //---------------------------------------------------------------------------
 
-
-
 //---------------------------------------------------------------------------
 //  Constant definitions
 //---------------------------------------------------------------------------
 
 #define MAX_LEN_BUFFER_ID       256
 
-#define TIMEOUT_ENTER_ATOMIC    1000        // (ms) for debgging: INFINITE
+#define TIMEOUT_ENTER_ATOMIC    1000	// (ms) for debgging: INFINITE
 #define TIMEOUT_TERM_THREAD     1000
 #define INFINITE                3600
 
-#define SBI_MAGIC_ID            0x5342492B  // magic ID ("SBI+")
-#define SBH_MAGIC_ID            0x5342482A  // magic ID ("SBH*")
+#define SBI_MAGIC_ID            0x5342492B	// magic ID ("SBI+")
+#define SBH_MAGIC_ID            0x5342482A	// magic ID ("SBH*")
 
 #define INVALID_ID              -1
 
 #define TABLE_SIZE              10
 
-
 //---------------------------------------------------------------------------
 //  Local types
 //---------------------------------------------------------------------------
@@ -118,27 +112,24 @@
 // separated processes (e.g. the refernce counter). This structure is
 // located at the start of the shared memory region itself and exists
 // consequently only one times per shared memory instance.
-typedef struct
-{
+typedef struct {
 
-    unsigned long       m_ulShMemSize;
-    unsigned long       m_ulRefCount;
-    int                 m_iBufferId;
+	unsigned long m_ulShMemSize;
+	unsigned long m_ulRefCount;
+	int m_iBufferId;
 //    int                 m_iUserSpaceMem;           //0 for userspace mem   !=0 kernelspace mem
-    spinlock_t          m_SpinlockBuffAccess;
-    BOOL                m_fNewData;
-    BOOL                m_fJobReady;
-    wait_queue_head_t   m_WaitQueueNewData;
-    wait_queue_head_t   m_WaitQueueJobReady;
-
-    #ifndef NDEBUG
-        unsigned long   m_ulOwnerProcID;
-    #endif
+	spinlock_t m_SpinlockBuffAccess;
+	BOOL m_fNewData;
+	BOOL m_fJobReady;
+	wait_queue_head_t m_WaitQueueNewData;
+	wait_queue_head_t m_WaitQueueJobReady;
+
+#ifndef NDEBUG
+	unsigned long m_ulOwnerProcID;
+#endif
 
 } tShbMemHeader;
 
-
-
 // This structure is the "external entry point" from a separate process
 // to get access to a shared buffer. This structure includes all platform
 // resp. target specific information to administrate/manage the shared
@@ -148,34 +139,32 @@ typedef struct
 // owner process only). The structure member <m_pShbMemHeader> points
 // to the (process specific) start address of the shared memory region
 // itself.
-typedef struct
-{
-    unsigned long       m_SbiMagicID;           // magic ID ("SBI+")
+typedef struct {
+	unsigned long m_SbiMagicID;	// magic ID ("SBI+")
 //    void*               m_pSharedMem;
-    int                 m_tThreadNewDataId;
-    long                m_lThreadNewDataNice;   // nice value of the new data thread
-    int                 m_tThreadJobReadyId;
-    unsigned long       m_ulFlagsBuffAccess;    // d.k. moved from tShbMemHeader, because each
-                                                // process needs to store the interrupt flags separately
-    tSigHndlrNewData    m_pfnSigHndlrNewData;
-    unsigned long       m_ulTimeOutJobReady;
-    tSigHndlrJobReady   m_pfnSigHndlrJobReady;
-    tShbMemHeader*      m_pShbMemHeader;
-    int                 m_iThreadTermFlag;
-    struct completion   m_CompletionNewData;
+	int m_tThreadNewDataId;
+	long m_lThreadNewDataNice;	// nice value of the new data thread
+	int m_tThreadJobReadyId;
+	unsigned long m_ulFlagsBuffAccess;	// d.k. moved from tShbMemHeader, because each
+	// process needs to store the interrupt flags separately
+	tSigHndlrNewData m_pfnSigHndlrNewData;
+	unsigned long m_ulTimeOutJobReady;
+	tSigHndlrJobReady m_pfnSigHndlrJobReady;
+	tShbMemHeader *m_pShbMemHeader;
+	int m_iThreadTermFlag;
+	struct completion m_CompletionNewData;
 /*
     struct semaphore    *m_pSemBuffAccess;
     struct semaphore    *m_pSemNewData;
     struct semaphore    *m_pSemStopSignalingNewData;
     struct semaphore    *m_pSemJobReady;
 */
-    #ifndef NDEBUG
-        unsigned long   m_ulThreadIDNewData;
-        unsigned long   m_ulThreadIDJobReady;
-    #endif
+#ifndef NDEBUG
+	unsigned long m_ulThreadIDNewData;
+	unsigned long m_ulThreadIDJobReady;
+#endif
 } tShbMemInst;
 
-
 //---------------------------------------------------------------------------
 //  Prototypes of internal functions
 //---------------------------------------------------------------------------
@@ -187,36 +176,29 @@ typedef struct
 //  Get pointer to process local information structure
 //---------------------------------------------------------------------------
 
-static inline tShbMemInst*  ShbIpcGetShbMemInst (
-    tShbInstance pShbInstance_p)
+static inline tShbMemInst *ShbIpcGetShbMemInst(tShbInstance pShbInstance_p)
 {
 
-tShbMemInst*  pShbMemInst;
+	tShbMemInst *pShbMemInst;
 
+	pShbMemInst = (tShbMemInst *) pShbInstance_p;
 
-    pShbMemInst = (tShbMemInst*)pShbInstance_p;
-
-
-    return (pShbMemInst);
+	return (pShbMemInst);
 
 }
 
-
-
 //---------------------------------------------------------------------------
 //  Get pointer to shared memory header
 //---------------------------------------------------------------------------
 
-static inline tShbMemHeader*  ShbIpcGetShbMemHeader (
-    tShbMemInst* pShbMemInst_p)
+static inline tShbMemHeader *ShbIpcGetShbMemHeader(tShbMemInst * pShbMemInst_p)
 {
 
-tShbMemHeader*  pShbMemHeader;
-
+	tShbMemHeader *pShbMemHeader;
 
-    pShbMemHeader = pShbMemInst_p->m_pShbMemHeader;
+	pShbMemHeader = pShbMemInst_p->m_pShbMemHeader;
 
-    return (pShbMemHeader);
+	return (pShbMemHeader);
 
 }
 
@@ -227,8 +209,8 @@ tShbMemHeader*  pShbMemHeader;
 //#define ShbIpcGetShbMemHeader(pShbMemInst_p) (pShbMemInst_p->m_pShbMemHeader)
 
 // not inlined internal functions
-int                     ShbIpcThreadSignalNewData   (void* pvThreadParam_p);
-int                     ShbIpcThreadSignalJobReady  (void* pvThreadParam_p);
+int ShbIpcThreadSignalNewData(void *pvThreadParam_p);
+int ShbIpcThreadSignalJobReady(void *pvThreadParam_p);
 #endif
 
 //---------------------------------------------------------------------------
@@ -238,16 +220,18 @@ int                     ShbIpcThreadSignalJobReady  (void* pvThreadParam_p);
 #if !defined(SHBIPC_INLINE_ENABLED)
 struct sShbMemTable *psMemTableElementFirst_g;
 
-static void*            ShbIpcAllocPrivateMem       (unsigned long ulMemSize_p);
-static int              ShbIpcFindListElement       (int iBufferId, struct sShbMemTable **ppsReturnMemTableElement);
-static void             ShbIpcAppendListElement     (struct sShbMemTable *sNewMemTableElement);
-static void             ShbIpcDeleteListElement     (int iBufferId);
-static void             ShbIpcCrc32GenTable         (unsigned long aulCrcTable[256]);
-static unsigned long    ShbIpcCrc32GetCrc           (const char *pcString, unsigned long aulCrcTable[256]);
+static void *ShbIpcAllocPrivateMem(unsigned long ulMemSize_p);
+static int ShbIpcFindListElement(int iBufferId,
+				 struct sShbMemTable
+				 **ppsReturnMemTableElement);
+static void ShbIpcAppendListElement(struct sShbMemTable *sNewMemTableElement);
+static void ShbIpcDeleteListElement(int iBufferId);
+static void ShbIpcCrc32GenTable(unsigned long aulCrcTable[256]);
+static unsigned long ShbIpcCrc32GetCrc(const char *pcString,
+				       unsigned long aulCrcTable[256]);
 
 #endif
 
-
 //=========================================================================//
 //                                                                         //
 //          P U B L I C   F U N C T I O N S                                //
@@ -261,497 +245,466 @@ static unsigned long    ShbIpcCrc32GetCrc           (const char *pcString, unsig
 //  Initialize IPC for Shared Buffer Module
 //---------------------------------------------------------------------------
 
-tShbError  ShbIpcInit (void)
+tShbError ShbIpcInit(void)
 {
-    psMemTableElementFirst_g = NULL;
-    return (kShbOk);
+	psMemTableElementFirst_g = NULL;
+	return (kShbOk);
 
 }
 
-
-
 //---------------------------------------------------------------------------
 //  Deinitialize IPC for Shared Buffer Module
 //---------------------------------------------------------------------------
 
-tShbError  ShbIpcExit (void)
+tShbError ShbIpcExit(void)
 {
 
-    return (kShbOk);
+	return (kShbOk);
 
 }
 
-
-
 //---------------------------------------------------------------------------
 //  Allocate Shared Buffer
 //---------------------------------------------------------------------------
 
-tShbError  ShbIpcAllocBuffer (
-    unsigned long ulBufferSize_p,
-    const char* pszBufferID_p,
-    tShbInstance* ppShbInstance_p,
-    unsigned int* pfShbNewCreated_p)
+tShbError ShbIpcAllocBuffer(unsigned long ulBufferSize_p,
+			    const char *pszBufferID_p,
+			    tShbInstance * ppShbInstance_p,
+			    unsigned int *pfShbNewCreated_p)
 {
-tShbError               ShbError;
-int                     iBufferId=0;
-unsigned long           ulCrc32=0;
-unsigned int            uiFirstProcess=0;
-unsigned long           ulShMemSize;
-tShbMemHeader*          pShbMemHeader;
-tShbMemInst*            pShbMemInst=NULL;
-tShbInstance            pShbInstance;
-unsigned int            fShMemNewCreated=FALSE;
-void                    *pSharedMem=NULL;
-unsigned long           aulCrcTable[256];
-struct sShbMemTable     *psMemTableElement;
-
-
-    DEBUG_LVL_29_TRACE0("ShbIpcAllocBuffer \n");
-    ulShMemSize      = ulBufferSize_p + sizeof(tShbMemHeader);
-
-    //create Buffer ID
-    ShbIpcCrc32GenTable(aulCrcTable);
-    ulCrc32=ShbIpcCrc32GetCrc(pszBufferID_p,aulCrcTable);
-    iBufferId=ulCrc32;
-    DEBUG_LVL_29_TRACE2("ShbIpcAllocBuffer BufferSize:%d sizeof(tShb..):%d\n",ulBufferSize_p,sizeof(tShbMemHeader));
-    DEBUG_LVL_29_TRACE2("ShbIpcAllocBuffer BufferId:%d MemSize:%d\n",iBufferId,ulShMemSize);
-    //---------------------------------------------------------------
-    // (1) open an existing or create a new shared memory
-    //---------------------------------------------------------------
-    //test if buffer already exists
-    if (ShbIpcFindListElement(iBufferId, &psMemTableElement) == 0)
-    {
-        //Buffer already exists
-        fShMemNewCreated=FALSE;
-        pSharedMem = psMemTableElement->m_pBuffer;
-        DEBUG_LVL_29_TRACE1("ShbIpcAllocBuffer attach Buffer at:%p Id:%d\n",pSharedMem);
-        uiFirstProcess=1;
-    }
-    else
-    {
-        //create new Buffer
-        fShMemNewCreated = TRUE;
-        uiFirstProcess=0;
-        pSharedMem = kmalloc(ulShMemSize,GFP_KERNEL);
-        DEBUG_LVL_29_TRACE2("ShbIpcAllocBuffer Create New Buffer at:%p Id:%d\n",pSharedMem,iBufferId);
-        if (pSharedMem == NULL)
-        {
-            //unable to create mem
-            ShbError = kShbOutOfMem;
-            goto Exit;
-        }
-        DEBUG_LVL_29_TRACE0("ShbIpcAllocBuffer create semas\n");
-        // append Element to Mem Table
-        psMemTableElement = kmalloc(sizeof(struct sShbMemTable),GFP_KERNEL);
-        psMemTableElement->m_iBufferId = iBufferId;
-        psMemTableElement->m_pBuffer = pSharedMem;
-        psMemTableElement->m_psNextMemTableElement = NULL;
-        ShbIpcAppendListElement (psMemTableElement);
-    }
-
-    DEBUG_LVL_29_TRACE0("ShbIpcAllocBuffer update header\n");
-    //update header
-    pShbMemHeader = (tShbMemHeader*)pSharedMem;
-    DEBUG_LVL_29_TRACE1("ShbIpcAllocBuffer 0 pShbMemHeader->m_ulShMemSize: %d\n",pShbMemHeader->m_ulShMemSize);
-    // allocate a memory block from process specific mempool to save
-    // process local information to administrate/manage the shared buffer
-    DEBUG_LVL_29_TRACE0("ShbIpcAllocBuffer alloc private mem\n");
-    pShbMemInst = (tShbMemInst*) ShbIpcAllocPrivateMem (sizeof(tShbMemInst));
-    if (pShbMemInst == NULL)
-    {
-        ShbError = kShbOutOfMem;
-        goto Exit;
-    }
-
-    // reset complete header to default values
-    //pShbMemInst->m_SbiMagicID                             = SBI_MAGIC_ID;
+	tShbError ShbError;
+	int iBufferId = 0;
+	unsigned long ulCrc32 = 0;
+	unsigned int uiFirstProcess = 0;
+	unsigned long ulShMemSize;
+	tShbMemHeader *pShbMemHeader;
+	tShbMemInst *pShbMemInst = NULL;
+	tShbInstance pShbInstance;
+	unsigned int fShMemNewCreated = FALSE;
+	void *pSharedMem = NULL;
+	unsigned long aulCrcTable[256];
+	struct sShbMemTable *psMemTableElement;
+
+	DEBUG_LVL_29_TRACE0("ShbIpcAllocBuffer \n");
+	ulShMemSize = ulBufferSize_p + sizeof(tShbMemHeader);
+
+	//create Buffer ID
+	ShbIpcCrc32GenTable(aulCrcTable);
+	ulCrc32 = ShbIpcCrc32GetCrc(pszBufferID_p, aulCrcTable);
+	iBufferId = ulCrc32;
+	DEBUG_LVL_29_TRACE2
+	    ("ShbIpcAllocBuffer BufferSize:%d sizeof(tShb..):%d\n",
+	     ulBufferSize_p, sizeof(tShbMemHeader));
+	DEBUG_LVL_29_TRACE2("ShbIpcAllocBuffer BufferId:%d MemSize:%d\n",
+			    iBufferId, ulShMemSize);
+	//---------------------------------------------------------------
+	// (1) open an existing or create a new shared memory
+	//---------------------------------------------------------------
+	//test if buffer already exists
+	if (ShbIpcFindListElement(iBufferId, &psMemTableElement) == 0) {
+		//Buffer already exists
+		fShMemNewCreated = FALSE;
+		pSharedMem = psMemTableElement->m_pBuffer;
+		DEBUG_LVL_29_TRACE1
+		    ("ShbIpcAllocBuffer attach Buffer at:%p Id:%d\n",
+		     pSharedMem);
+		uiFirstProcess = 1;
+	} else {
+		//create new Buffer
+		fShMemNewCreated = TRUE;
+		uiFirstProcess = 0;
+		pSharedMem = kmalloc(ulShMemSize, GFP_KERNEL);
+		DEBUG_LVL_29_TRACE2
+		    ("ShbIpcAllocBuffer Create New Buffer at:%p Id:%d\n",
+		     pSharedMem, iBufferId);
+		if (pSharedMem == NULL) {
+			//unable to create mem
+			ShbError = kShbOutOfMem;
+			goto Exit;
+		}
+		DEBUG_LVL_29_TRACE0("ShbIpcAllocBuffer create semas\n");
+		// append Element to Mem Table
+		psMemTableElement =
+		    kmalloc(sizeof(struct sShbMemTable), GFP_KERNEL);
+		psMemTableElement->m_iBufferId = iBufferId;
+		psMemTableElement->m_pBuffer = pSharedMem;
+		psMemTableElement->m_psNextMemTableElement = NULL;
+		ShbIpcAppendListElement(psMemTableElement);
+	}
+
+	DEBUG_LVL_29_TRACE0("ShbIpcAllocBuffer update header\n");
+	//update header
+	pShbMemHeader = (tShbMemHeader *) pSharedMem;
+	DEBUG_LVL_29_TRACE1
+	    ("ShbIpcAllocBuffer 0 pShbMemHeader->m_ulShMemSize: %d\n",
+	     pShbMemHeader->m_ulShMemSize);
+	// allocate a memory block from process specific mempool to save
+	// process local information to administrate/manage the shared buffer
+	DEBUG_LVL_29_TRACE0("ShbIpcAllocBuffer alloc private mem\n");
+	pShbMemInst =
+	    (tShbMemInst *) ShbIpcAllocPrivateMem(sizeof(tShbMemInst));
+	if (pShbMemInst == NULL) {
+		ShbError = kShbOutOfMem;
+		goto Exit;
+	}
+	// reset complete header to default values
+	//pShbMemInst->m_SbiMagicID                             = SBI_MAGIC_ID;
 //    pShbMemInst->m_pSharedMem                               = pSharedMem;
-    pShbMemInst->m_tThreadNewDataId                         = INVALID_ID;
-    pShbMemInst->m_tThreadJobReadyId                        = INVALID_ID;
-    pShbMemInst->m_pfnSigHndlrNewData                       = NULL;
-    pShbMemInst->m_ulTimeOutJobReady                        = 0;
-    pShbMemInst->m_pfnSigHndlrJobReady                      = NULL;
-    pShbMemInst->m_pShbMemHeader                            = pShbMemHeader;
-    pShbMemInst->m_iThreadTermFlag                          = 0;
-
-    // initialize completion etc.
-    init_completion(&pShbMemInst->m_CompletionNewData);
-
-    ShbError         = kShbOk;
-    if ( fShMemNewCreated )
-    {
-        // this process was the first who wanted to use the shared memory,
-        // so a new shared memory was created
-        // -> setup new header information inside the shared memory region
-        //    itself
-        pShbMemHeader->m_ulShMemSize = ulShMemSize;
-        pShbMemHeader->m_ulRefCount  = 1;
-        pShbMemHeader->m_iBufferId=iBufferId;
-        // initialize spinlock
-        spin_lock_init(&pShbMemHeader->m_SpinlockBuffAccess);
-        // initialize wait queues
-        init_waitqueue_head(&pShbMemHeader->m_WaitQueueNewData);
-        init_waitqueue_head(&pShbMemHeader->m_WaitQueueJobReady);
-    }
-    else
-    {
-        // any other process has created the shared memory and this
-        // process only has to attach to it
-        // -> check and update existing header information inside the
-        //    shared memory region itself
-        if (pShbMemHeader->m_ulShMemSize != ulShMemSize)
-        {
-            ShbError = kShbOpenMismatch;
-            goto Exit;
-        }
-        pShbMemHeader->m_ulRefCount++;
-    }
-
-    Exit:
-    pShbInstance = (tShbInstance*)pShbMemInst;
-    *pfShbNewCreated_p = fShMemNewCreated;
-    *ppShbInstance_p   = pShbInstance;
-    return (ShbError);
+	pShbMemInst->m_tThreadNewDataId = INVALID_ID;
+	pShbMemInst->m_tThreadJobReadyId = INVALID_ID;
+	pShbMemInst->m_pfnSigHndlrNewData = NULL;
+	pShbMemInst->m_ulTimeOutJobReady = 0;
+	pShbMemInst->m_pfnSigHndlrJobReady = NULL;
+	pShbMemInst->m_pShbMemHeader = pShbMemHeader;
+	pShbMemInst->m_iThreadTermFlag = 0;
+
+	// initialize completion etc.
+	init_completion(&pShbMemInst->m_CompletionNewData);
+
+	ShbError = kShbOk;
+	if (fShMemNewCreated) {
+		// this process was the first who wanted to use the shared memory,
+		// so a new shared memory was created
+		// -> setup new header information inside the shared memory region
+		//    itself
+		pShbMemHeader->m_ulShMemSize = ulShMemSize;
+		pShbMemHeader->m_ulRefCount = 1;
+		pShbMemHeader->m_iBufferId = iBufferId;
+		// initialize spinlock
+		spin_lock_init(&pShbMemHeader->m_SpinlockBuffAccess);
+		// initialize wait queues
+		init_waitqueue_head(&pShbMemHeader->m_WaitQueueNewData);
+		init_waitqueue_head(&pShbMemHeader->m_WaitQueueJobReady);
+	} else {
+		// any other process has created the shared memory and this
+		// process only has to attach to it
+		// -> check and update existing header information inside the
+		//    shared memory region itself
+		if (pShbMemHeader->m_ulShMemSize != ulShMemSize) {
+			ShbError = kShbOpenMismatch;
+			goto Exit;
+		}
+		pShbMemHeader->m_ulRefCount++;
+	}
+
+      Exit:
+	pShbInstance = (tShbInstance *) pShbMemInst;
+	*pfShbNewCreated_p = fShMemNewCreated;
+	*ppShbInstance_p = pShbInstance;
+	return (ShbError);
 
 }
 
-
-
 //---------------------------------------------------------------------------
 //  Release Shared Buffer
 //---------------------------------------------------------------------------
 
-tShbError  ShbIpcReleaseBuffer (tShbInstance pShbInstance_p)
+tShbError ShbIpcReleaseBuffer(tShbInstance pShbInstance_p)
 {
-tShbMemInst*    pShbMemInst;
-tShbMemHeader*  pShbMemHeader;
-tShbError       ShbError;
-tShbError       ShbError2;
-
-    DEBUG_LVL_26_TRACE1("ShbIpcReleaseBuffer(%p)\n", pShbInstance_p);
-    if (pShbInstance_p == NULL)
-    {
-        return (kShbOk);
-    }
-    pShbMemInst   = ShbIpcGetShbMemInst   (pShbInstance_p);
-    pShbMemHeader = ShbIpcGetShbMemHeader (pShbMemInst);
-
-    // stop threads in any case, because they are bound to that specific instance
-    ShbError2 = ShbIpcStopSignalingNewData (pShbInstance_p);
-    // d.k.: Whats up with JobReady thread?
-    //       Just wake it up, but without setting the semaphore variable
-    wake_up_interruptible(&pShbMemHeader->m_WaitQueueJobReady);
-
-    if ( !--pShbMemHeader->m_ulRefCount )
-    {
-        ShbError = kShbOk;
-        // delete mem table element
-        ShbIpcDeleteListElement(pShbMemHeader->m_iBufferId);
-        // delete shared mem
-        kfree(pShbMemInst->m_pShbMemHeader);
-    }
-    else
-    {
-        ShbError = kShbMemUsedByOtherProcs;
-    }
-    //delete privat mem
-    kfree(pShbMemInst);
-    return (ShbError);
+	tShbMemInst *pShbMemInst;
+	tShbMemHeader *pShbMemHeader;
+	tShbError ShbError;
+	tShbError ShbError2;
+
+	DEBUG_LVL_26_TRACE1("ShbIpcReleaseBuffer(%p)\n", pShbInstance_p);
+	if (pShbInstance_p == NULL) {
+		return (kShbOk);
+	}
+	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);
+	pShbMemHeader = ShbIpcGetShbMemHeader(pShbMemInst);
+
+	// stop threads in any case, because they are bound to that specific instance
+	ShbError2 = ShbIpcStopSignalingNewData(pShbInstance_p);
+	// d.k.: Whats up with JobReady thread?
+	//       Just wake it up, but without setting the semaphore variable
+	wake_up_interruptible(&pShbMemHeader->m_WaitQueueJobReady);
+
+	if (!--pShbMemHeader->m_ulRefCount) {
+		ShbError = kShbOk;
+		// delete mem table element
+		ShbIpcDeleteListElement(pShbMemHeader->m_iBufferId);
+		// delete shared mem
+		kfree(pShbMemInst->m_pShbMemHeader);
+	} else {
+		ShbError = kShbMemUsedByOtherProcs;
+	}
+	//delete privat mem
+	kfree(pShbMemInst);
+	return (ShbError);
 }
 
-
-#endif  // !defined(SHBIPC_INLINE_ENABLED)
+#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)
+INLINE_FUNCTION tShbError ShbIpcEnterAtomicSection(tShbInstance pShbInstance_p)
 {
 
-tShbMemInst*    pShbMemInst;
-tShbMemHeader*  pShbMemHeader;
-tShbError       ShbError = kShbOk;
+	tShbMemInst *pShbMemInst;
+	tShbMemHeader *pShbMemHeader;
+	tShbError ShbError = kShbOk;
 
-    if (pShbInstance_p == NULL)
-    {
-        ShbError = kShbInvalidArg;
-        goto Exit;
-    }
-    DEBUG_LVL_29_TRACE0("enter atomic\n");
-    pShbMemInst   = ShbIpcGetShbMemInst   (pShbInstance_p);
-    pShbMemHeader = ShbIpcGetShbMemHeader (pShbMemInst);
+	if (pShbInstance_p == NULL) {
+		ShbError = kShbInvalidArg;
+		goto Exit;
+	}
+	DEBUG_LVL_29_TRACE0("enter atomic\n");
+	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);
+	pShbMemHeader = ShbIpcGetShbMemHeader(pShbMemInst);
 
-    // lock interrupts
-    spin_lock_irqsave(&pShbMemHeader->m_SpinlockBuffAccess, pShbMemInst->m_ulFlagsBuffAccess);
+	// lock interrupts
+	spin_lock_irqsave(&pShbMemHeader->m_SpinlockBuffAccess,
+			  pShbMemInst->m_ulFlagsBuffAccess);
 
-Exit:
-    return ShbError;
+      Exit:
+	return ShbError;
 
 }
 
-
-
 //---------------------------------------------------------------------------
 //  Leave atomic section for Shared Buffer access
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION tShbError  ShbIpcLeaveAtomicSection (
-    tShbInstance pShbInstance_p)
+INLINE_FUNCTION tShbError ShbIpcLeaveAtomicSection(tShbInstance pShbInstance_p)
 {
 
-tShbMemInst*    pShbMemInst;
-tShbMemHeader*  pShbMemHeader;
-tShbError       ShbError = kShbOk;
-
-    if (pShbInstance_p == NULL)
-    {
-        ShbError = kShbInvalidArg;
-        goto Exit;
-    }
-    pShbMemInst   = ShbIpcGetShbMemInst   (pShbInstance_p);
-    pShbMemHeader = ShbIpcGetShbMemHeader (pShbMemInst);
-    // unlock interrupts
-    spin_unlock_irqrestore(&pShbMemHeader->m_SpinlockBuffAccess, pShbMemInst->m_ulFlagsBuffAccess);
-
-Exit:
-    DEBUG_LVL_29_TRACE0("Leave Atomic \n");
-    return ShbError;
+	tShbMemInst *pShbMemInst;
+	tShbMemHeader *pShbMemHeader;
+	tShbError ShbError = kShbOk;
 
-}
+	if (pShbInstance_p == NULL) {
+		ShbError = kShbInvalidArg;
+		goto Exit;
+	}
+	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);
+	pShbMemHeader = ShbIpcGetShbMemHeader(pShbMemInst);
+	// unlock interrupts
+	spin_unlock_irqrestore(&pShbMemHeader->m_SpinlockBuffAccess,
+			       pShbMemInst->m_ulFlagsBuffAccess);
 
+      Exit:
+	DEBUG_LVL_29_TRACE0("Leave Atomic \n");
+	return ShbError;
 
+}
 
 //---------------------------------------------------------------------------
 //  Start signaling of new data (called from reading process)
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION tShbError  ShbIpcStartSignalingNewData (
-    tShbInstance pShbInstance_p,
-    tSigHndlrNewData pfnSignalHandlerNewData_p,
-    tShbPriority ShbPriority_p)
+INLINE_FUNCTION tShbError ShbIpcStartSignalingNewData(tShbInstance
+						      pShbInstance_p,
+						      tSigHndlrNewData
+						      pfnSignalHandlerNewData_p,
+						      tShbPriority
+						      ShbPriority_p)
 {
-tShbMemInst*    pShbMemInst;
-tShbMemHeader*  pShbMemHeader;
-tShbError       ShbError;
-
-    DEBUG_LVL_29_TRACE0("------->ShbIpcStartSignalingNewData\n");
-    if ((pShbInstance_p == NULL) || (pfnSignalHandlerNewData_p == NULL))
-    {
-        return (kShbInvalidArg);
-    }
-
-    pShbMemInst   = ShbIpcGetShbMemInst   (pShbInstance_p);
-    pShbMemHeader = ShbIpcGetShbMemHeader (pShbMemInst);
-    ShbError = kShbOk;
-
-    if ((pShbMemInst->m_tThreadNewDataId != INVALID_ID)
-        || (pShbMemInst->m_pfnSigHndlrNewData != NULL))
-    {
-        ShbError = kShbAlreadySignaling;
-        goto Exit;
-    }
-    DEBUG_LVL_26_TRACE2("ShbIpcStartSignalingNewData(%p) m_pfnSigHndlrNewData = %p\n", pShbInstance_p, pfnSignalHandlerNewData_p);
-    pShbMemInst->m_pfnSigHndlrNewData = pfnSignalHandlerNewData_p;
-    pShbMemHeader->m_fNewData = FALSE;
-    pShbMemInst->m_iThreadTermFlag = 0;
-
-    switch (ShbPriority_p)
-    {
-        case kShbPriorityLow:
-            pShbMemInst->m_lThreadNewDataNice = -2;
-            break;
-
-        case kShbPriorityNormal:
-            pShbMemInst->m_lThreadNewDataNice = -9;
-            break;
-
-        case kshbPriorityHigh:
-            pShbMemInst->m_lThreadNewDataNice = -20;
-            break;
-
-    }
-
-    //create thread for signalling new data
-    pShbMemInst->m_tThreadNewDataId = kernel_thread(ShbIpcThreadSignalNewData,pShbInstance_p,CLONE_KERNEL);
-
-Exit:
-    return ShbError;
+	tShbMemInst *pShbMemInst;
+	tShbMemHeader *pShbMemHeader;
+	tShbError ShbError;
+
+	DEBUG_LVL_29_TRACE0("------->ShbIpcStartSignalingNewData\n");
+	if ((pShbInstance_p == NULL) || (pfnSignalHandlerNewData_p == NULL)) {
+		return (kShbInvalidArg);
+	}
+
+	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);
+	pShbMemHeader = ShbIpcGetShbMemHeader(pShbMemInst);
+	ShbError = kShbOk;
+
+	if ((pShbMemInst->m_tThreadNewDataId != INVALID_ID)
+	    || (pShbMemInst->m_pfnSigHndlrNewData != NULL)) {
+		ShbError = kShbAlreadySignaling;
+		goto Exit;
+	}
+	DEBUG_LVL_26_TRACE2
+	    ("ShbIpcStartSignalingNewData(%p) m_pfnSigHndlrNewData = %p\n",
+	     pShbInstance_p, pfnSignalHandlerNewData_p);
+	pShbMemInst->m_pfnSigHndlrNewData = pfnSignalHandlerNewData_p;
+	pShbMemHeader->m_fNewData = FALSE;
+	pShbMemInst->m_iThreadTermFlag = 0;
+
+	switch (ShbPriority_p) {
+	case kShbPriorityLow:
+		pShbMemInst->m_lThreadNewDataNice = -2;
+		break;
+
+	case kShbPriorityNormal:
+		pShbMemInst->m_lThreadNewDataNice = -9;
+		break;
+
+	case kshbPriorityHigh:
+		pShbMemInst->m_lThreadNewDataNice = -20;
+		break;
+
+	}
+
+	//create thread for signalling new data
+	pShbMemInst->m_tThreadNewDataId =
+	    kernel_thread(ShbIpcThreadSignalNewData, pShbInstance_p,
+			  CLONE_KERNEL);
+
+      Exit:
+	return ShbError;
 
 }
 
-
-
 //---------------------------------------------------------------------------
 //  Stop signaling of new data (called from reading process)
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION tShbError  ShbIpcStopSignalingNewData (
-    tShbInstance pShbInstance_p)
+INLINE_FUNCTION tShbError ShbIpcStopSignalingNewData(tShbInstance
+						     pShbInstance_p)
 {
-tShbMemInst*    pShbMemInst;
-tShbMemHeader*  pShbMemHeader;
-tShbError       ShbError;
-
-    DEBUG_LVL_29_TRACE0("------->ShbIpcStopSignalingNewData\n");
-    if (pShbInstance_p == NULL)
-    {
-        return (kShbInvalidArg);
-    }
-    ShbError = kShbOk;
-    pShbMemInst = ShbIpcGetShbMemInst (pShbInstance_p);
-    pShbMemHeader = ShbIpcGetShbMemHeader (pShbMemInst);
-
-    DEBUG_LVL_26_TRACE2("ShbIpcStopSignalingNewData(%p) pfnSignHndlrNewData=%p\n", pShbInstance_p, pShbMemInst->m_pfnSigHndlrNewData);
-    if (pShbMemInst->m_pfnSigHndlrNewData != NULL)
-    {   // signal handler was set before
-        int iErr;
-        //set termination flag in mem header
-        pShbMemInst->m_iThreadTermFlag = 1;
-
-        // check if thread is still running at all by sending the null-signal to this thread
-        /* iErr = kill_proc(pShbMemInst->m_tThreadNewDataId, 0, 1); */
-        iErr = send_sig(0, pShbMemInst->m_tThreadNewDataId, 1);
-        if (iErr == 0)
-        {
-            // wake up thread, because it is still running
-            wake_up_interruptible(&pShbMemHeader->m_WaitQueueNewData);
-
-            //wait for termination of thread
-            wait_for_completion(&pShbMemInst->m_CompletionNewData);
-        }
-
-        pShbMemInst->m_pfnSigHndlrNewData = NULL;
-        pShbMemInst->m_tThreadNewDataId = INVALID_ID;
-    }
-
-    return ShbError;
+	tShbMemInst *pShbMemInst;
+	tShbMemHeader *pShbMemHeader;
+	tShbError ShbError;
+
+	DEBUG_LVL_29_TRACE0("------->ShbIpcStopSignalingNewData\n");
+	if (pShbInstance_p == NULL) {
+		return (kShbInvalidArg);
+	}
+	ShbError = kShbOk;
+	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);
+	pShbMemHeader = ShbIpcGetShbMemHeader(pShbMemInst);
+
+	DEBUG_LVL_26_TRACE2
+	    ("ShbIpcStopSignalingNewData(%p) pfnSignHndlrNewData=%p\n",
+	     pShbInstance_p, pShbMemInst->m_pfnSigHndlrNewData);
+	if (pShbMemInst->m_pfnSigHndlrNewData != NULL) {	// signal handler was set before
+		int iErr;
+		//set termination flag in mem header
+		pShbMemInst->m_iThreadTermFlag = 1;
+
+		// check if thread is still running at all by sending the null-signal to this thread
+		/* iErr = kill_proc(pShbMemInst->m_tThreadNewDataId, 0, 1); */
+		iErr = send_sig(0, pShbMemInst->m_tThreadNewDataId, 1);
+		if (iErr == 0) {
+			// wake up thread, because it is still running
+			wake_up_interruptible(&pShbMemHeader->
+					      m_WaitQueueNewData);
+
+			//wait for termination of thread
+			wait_for_completion(&pShbMemInst->m_CompletionNewData);
+		}
+
+		pShbMemInst->m_pfnSigHndlrNewData = NULL;
+		pShbMemInst->m_tThreadNewDataId = INVALID_ID;
+	}
+
+	return ShbError;
 
 }
 
-
-
 //---------------------------------------------------------------------------
 //  Signal new data (called from writing process)
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION tShbError  ShbIpcSignalNewData (
-    tShbInstance pShbInstance_p)
+INLINE_FUNCTION tShbError ShbIpcSignalNewData(tShbInstance pShbInstance_p)
 {
-tShbMemHeader*  pShbMemHeader;
-
-    if (pShbInstance_p == NULL)
-    {
-        return (kShbInvalidArg);
-    }
-    pShbMemHeader = ShbIpcGetShbMemHeader (ShbIpcGetShbMemInst (pShbInstance_p));
-    //set semaphore
-    pShbMemHeader->m_fNewData = TRUE;
-    DEBUG_LVL_29_TRACE0("ShbIpcSignalNewData set Sem -> New Data\n");
-
-    wake_up_interruptible(&pShbMemHeader->m_WaitQueueNewData);
-    return (kShbOk);
+	tShbMemHeader *pShbMemHeader;
+
+	if (pShbInstance_p == NULL) {
+		return (kShbInvalidArg);
+	}
+	pShbMemHeader =
+	    ShbIpcGetShbMemHeader(ShbIpcGetShbMemInst(pShbInstance_p));
+	//set semaphore
+	pShbMemHeader->m_fNewData = TRUE;
+	DEBUG_LVL_29_TRACE0("ShbIpcSignalNewData set Sem -> New Data\n");
+
+	wake_up_interruptible(&pShbMemHeader->m_WaitQueueNewData);
+	return (kShbOk);
 }
 
-
-
 //---------------------------------------------------------------------------
 //  Start signaling for job ready (called from waiting process)
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION tShbError  ShbIpcStartSignalingJobReady (
-    tShbInstance pShbInstance_p,
-    unsigned long ulTimeOut_p,
-    tSigHndlrJobReady pfnSignalHandlerJobReady_p)
+INLINE_FUNCTION tShbError ShbIpcStartSignalingJobReady(tShbInstance
+						       pShbInstance_p,
+						       unsigned long
+						       ulTimeOut_p,
+						       tSigHndlrJobReady
+						       pfnSignalHandlerJobReady_p)
 {
-tShbMemInst*    pShbMemInst;
-tShbMemHeader*  pShbMemHeader;
-tShbError       ShbError;
-
-    if ((pShbInstance_p == NULL) || (pfnSignalHandlerJobReady_p == NULL))
-    {
-        return (kShbInvalidArg);
-    }
-    pShbMemInst   = ShbIpcGetShbMemInst   (pShbInstance_p);
-    pShbMemHeader = ShbIpcGetShbMemHeader (pShbMemInst);
-
-    ShbError = kShbOk;
-    if ((pShbMemInst->m_tThreadJobReadyId != INVALID_ID)||(pShbMemInst->m_pfnSigHndlrJobReady!= NULL))
-    {
-        ShbError = kShbAlreadySignaling;
-        goto Exit;
-    }
-    pShbMemInst->m_ulTimeOutJobReady = ulTimeOut_p;
-    pShbMemInst->m_pfnSigHndlrJobReady = pfnSignalHandlerJobReady_p;
-    pShbMemHeader->m_fJobReady = FALSE;
-    //create thread for signalling new data
-    pShbMemInst->m_tThreadJobReadyId=kernel_thread(ShbIpcThreadSignalJobReady,pShbInstance_p,CLONE_KERNEL);
-    Exit:
-    return ShbError;
+	tShbMemInst *pShbMemInst;
+	tShbMemHeader *pShbMemHeader;
+	tShbError ShbError;
+
+	if ((pShbInstance_p == NULL) || (pfnSignalHandlerJobReady_p == NULL)) {
+		return (kShbInvalidArg);
+	}
+	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);
+	pShbMemHeader = ShbIpcGetShbMemHeader(pShbMemInst);
+
+	ShbError = kShbOk;
+	if ((pShbMemInst->m_tThreadJobReadyId != INVALID_ID)
+	    || (pShbMemInst->m_pfnSigHndlrJobReady != NULL)) {
+		ShbError = kShbAlreadySignaling;
+		goto Exit;
+	}
+	pShbMemInst->m_ulTimeOutJobReady = ulTimeOut_p;
+	pShbMemInst->m_pfnSigHndlrJobReady = pfnSignalHandlerJobReady_p;
+	pShbMemHeader->m_fJobReady = FALSE;
+	//create thread for signalling new data
+	pShbMemInst->m_tThreadJobReadyId =
+	    kernel_thread(ShbIpcThreadSignalJobReady, pShbInstance_p,
+			  CLONE_KERNEL);
+      Exit:
+	return ShbError;
 }
 
-
-
 //---------------------------------------------------------------------------
 //  Signal job ready (called from executing process)
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION tShbError  ShbIpcSignalJobReady (
-    tShbInstance pShbInstance_p)
+INLINE_FUNCTION tShbError ShbIpcSignalJobReady(tShbInstance pShbInstance_p)
 {
-tShbMemHeader*  pShbMemHeader;
-
-
-    DEBUG_LVL_29_TRACE0("ShbIpcSignalJobReady\n");
-    if (pShbInstance_p == NULL)
-    {
-        return (kShbInvalidArg);
-    }
-    pShbMemHeader = ShbIpcGetShbMemHeader (ShbIpcGetShbMemInst (pShbInstance_p));
-    //set semaphore
-    pShbMemHeader->m_fJobReady = TRUE;
-    DEBUG_LVL_29_TRACE0("ShbIpcSignalJobReady set Sem -> Job Ready \n");
-
-    wake_up_interruptible(&pShbMemHeader->m_WaitQueueJobReady);
-    return (kShbOk);
+	tShbMemHeader *pShbMemHeader;
+
+	DEBUG_LVL_29_TRACE0("ShbIpcSignalJobReady\n");
+	if (pShbInstance_p == NULL) {
+		return (kShbInvalidArg);
+	}
+	pShbMemHeader =
+	    ShbIpcGetShbMemHeader(ShbIpcGetShbMemInst(pShbInstance_p));
+	//set semaphore
+	pShbMemHeader->m_fJobReady = TRUE;
+	DEBUG_LVL_29_TRACE0("ShbIpcSignalJobReady set Sem -> Job Ready \n");
+
+	wake_up_interruptible(&pShbMemHeader->m_WaitQueueJobReady);
+	return (kShbOk);
 }
 
-
-
 //---------------------------------------------------------------------------
 //  Get pointer to common used share memory area
 //---------------------------------------------------------------------------
 
-INLINE_FUNCTION void*  ShbIpcGetShMemPtr (tShbInstance pShbInstance_p)
+INLINE_FUNCTION void *ShbIpcGetShMemPtr(tShbInstance pShbInstance_p)
 {
 
-tShbMemHeader*  pShbMemHeader;
-void*  pShbShMemPtr;
-
+	tShbMemHeader *pShbMemHeader;
+	void *pShbShMemPtr;
 
-    pShbMemHeader = ShbIpcGetShbMemHeader (ShbIpcGetShbMemInst (pShbInstance_p));
-    if (pShbMemHeader != NULL)
-    {
-        pShbShMemPtr = (BYTE*)pShbMemHeader + sizeof(tShbMemHeader);
-    }
-    else
-    {
-        pShbShMemPtr = NULL;
-    }
+	pShbMemHeader =
+	    ShbIpcGetShbMemHeader(ShbIpcGetShbMemInst(pShbInstance_p));
+	if (pShbMemHeader != NULL) {
+		pShbShMemPtr = (BYTE *) pShbMemHeader + sizeof(tShbMemHeader);
+	} else {
+		pShbShMemPtr = NULL;
+	}
 
-    return (pShbShMemPtr);
+	return (pShbShMemPtr);
 
 }
 
 #endif
 
-
-
 //=========================================================================//
 //                                                                         //
 //          P R I V A T E   F U N C T I O N S                              //
@@ -770,16 +723,13 @@ void*  pShbShMemPtr;
 
 tShbMemInst*  pShbMemInst;
 
-
     pShbMemInst = (tShbMemInst*)pShbInstance_p;
 
-
     return (pShbMemInst);
 
 }
 */
 
-
 //---------------------------------------------------------------------------
 //  Get pointer to shared memory header
 //---------------------------------------------------------------------------
@@ -790,7 +740,6 @@ tShbMemInst*  pShbMemInst;
 
 tShbMemHeader*  pShbMemHeader;
 
-
     pShbMemHeader = pShbMemInst_p->m_pShbMemHeader;
 
     return (pShbMemHeader);
@@ -798,233 +747,219 @@ tShbMemHeader*  pShbMemHeader;
 }
 */
 
-
 //---------------------------------------------------------------------------
 //  Allocate a memory block from process specific mempool
 //---------------------------------------------------------------------------
 
-static void*  ShbIpcAllocPrivateMem (unsigned long ulMemSize_p)
+static void *ShbIpcAllocPrivateMem(unsigned long ulMemSize_p)
 {
-tShbError       ShbError;
-void*           pMem;
-
-    DEBUG_LVL_29_TRACE0("ShbIpcAllocPrivateMem \n");
-    //get private mem
-    pMem = kmalloc(ulMemSize_p, GFP_KERNEL);
-    if (pMem == NULL)
-    {
-        //unable to create mem
-        ShbError = kShbOutOfMem;
-        goto Exit;
-    }
-Exit:
-    return (pMem);
+	tShbError ShbError;
+	void *pMem;
+
+	DEBUG_LVL_29_TRACE0("ShbIpcAllocPrivateMem \n");
+	//get private mem
+	pMem = kmalloc(ulMemSize_p, GFP_KERNEL);
+	if (pMem == NULL) {
+		//unable to create mem
+		ShbError = kShbOutOfMem;
+		goto Exit;
+	}
+      Exit:
+	return (pMem);
 
 }
 
-
 //---------------------------------------------------------------------------
 //  Thread for new data signaling
 //---------------------------------------------------------------------------
 
-int ShbIpcThreadSignalNewData (void *pvThreadParam_p)
+int ShbIpcThreadSignalNewData(void *pvThreadParam_p)
 {
-tShbInstance    pShbInstance;
-tShbMemInst*    pShbMemInst;
-tShbMemHeader*  pShbMemHeader;
-int             iRetVal=-1;
-int             fCallAgain;
+	tShbInstance pShbInstance;
+	tShbMemInst *pShbMemInst;
+	tShbMemHeader *pShbMemHeader;
+	int iRetVal = -1;
+	int fCallAgain;
 
-    daemonize("ShbND%p", pvThreadParam_p);
-    allow_signal(SIGTERM);
-    pShbInstance = (tShbMemInst*)pvThreadParam_p;
-    pShbMemInst  = ShbIpcGetShbMemInst (pShbInstance);
-    pShbMemHeader = ShbIpcGetShbMemHeader (pShbMemInst);
+	daemonize("ShbND%p", pvThreadParam_p);
+	allow_signal(SIGTERM);
+	pShbInstance = (tShbMemInst *) pvThreadParam_p;
+	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance);
+	pShbMemHeader = ShbIpcGetShbMemHeader(pShbMemInst);
 
-    DEBUG_LVL_26_TRACE1("ShbIpcThreadSignalNewData(%p)\n",pvThreadParam_p);
+	DEBUG_LVL_26_TRACE1("ShbIpcThreadSignalNewData(%p)\n", pvThreadParam_p);
 
-    set_user_nice(current, pShbMemInst->m_lThreadNewDataNice);
+	set_user_nice(current, pShbMemInst->m_lThreadNewDataNice);
 
 //            DEBUG_LVL_29_TRACE1("ShbIpcThreadSignalNewData wait for New Data Sem %p\n",pShbMemInst->m_pSemNewData);
-    do
-    {
-        iRetVal = wait_event_interruptible(pShbMemHeader->m_WaitQueueNewData,
-            (pShbMemInst->m_iThreadTermFlag != 0) || (pShbMemHeader->m_fNewData != FALSE));
-
-        if (iRetVal != 0)
-        {   // signal pending
-            break;
-        }
-
-        if (pShbMemHeader->m_fNewData != FALSE)
-        {
-            pShbMemHeader->m_fNewData = FALSE;
-            do
-            {
-                fCallAgain = pShbMemInst->m_pfnSigHndlrNewData(pShbInstance);
-                // call scheduler, which will execute any task with higher priority
-                schedule();
-            } while (fCallAgain != FALSE);
-        }
-    } while (pShbMemInst->m_iThreadTermFlag==0);
-    DEBUG_LVL_29_TRACE0("ShbIpcThreadSignalNewData terminated \n");
-    //set thread completed
-    complete_and_exit(&pShbMemInst->m_CompletionNewData, 0);
-    return 0;
+	do {
+		iRetVal =
+		    wait_event_interruptible(pShbMemHeader->m_WaitQueueNewData,
+					     (pShbMemInst->m_iThreadTermFlag !=
+					      0)
+					     || (pShbMemHeader->m_fNewData !=
+						 FALSE));
+
+		if (iRetVal != 0) {	// signal pending
+			break;
+		}
+
+		if (pShbMemHeader->m_fNewData != FALSE) {
+			pShbMemHeader->m_fNewData = FALSE;
+			do {
+				fCallAgain =
+				    pShbMemInst->
+				    m_pfnSigHndlrNewData(pShbInstance);
+				// call scheduler, which will execute any task with higher priority
+				schedule();
+			} while (fCallAgain != FALSE);
+		}
+	} while (pShbMemInst->m_iThreadTermFlag == 0);
+	DEBUG_LVL_29_TRACE0("ShbIpcThreadSignalNewData terminated \n");
+	//set thread completed
+	complete_and_exit(&pShbMemInst->m_CompletionNewData, 0);
+	return 0;
 }
 
-
-
 //---------------------------------------------------------------------------
 //  Thread for new data Job Ready signaling
 //---------------------------------------------------------------------------
 
-int ShbIpcThreadSignalJobReady (void *pvThreadParam_p)
+int ShbIpcThreadSignalJobReady(void *pvThreadParam_p)
 {
-tShbInstance    pShbInstance;
-tShbMemInst*    pShbMemInst;
-tShbMemHeader*  pShbMemHeader;
-long            lTimeOut;
-int             iRetVal=-1;
-
-    daemonize("ShbJR%p", pvThreadParam_p);
-    allow_signal(SIGTERM);
-    pShbInstance = (tShbMemInst*)pvThreadParam_p;
-    pShbMemInst  = ShbIpcGetShbMemInst (pShbInstance);
-    pShbMemHeader = ShbIpcGetShbMemHeader (pShbMemInst);
-
-    DEBUG_LVL_29_TRACE0("ShbIpcThreadSignalJobReady wait for job ready Sem\n");
-    if (pShbMemInst->m_ulTimeOutJobReady != 0)
-    {
-        lTimeOut = (long) pShbMemInst->m_ulTimeOutJobReady;
-        //wait for job ready semaphore
-        iRetVal = wait_event_interruptible_timeout(pShbMemHeader->m_WaitQueueJobReady,
-            (pShbMemHeader->m_fJobReady != FALSE), lTimeOut);
-    }
-    else
-    {
-        //wait for job ready semaphore
-        iRetVal = wait_event_interruptible(pShbMemHeader->m_WaitQueueJobReady,
-            (pShbMemHeader->m_fJobReady != FALSE));
-    }
-
-    if (pShbMemInst->m_pfnSigHndlrJobReady != NULL)
-    {
-        //call Handler
-        pShbMemInst->m_pfnSigHndlrJobReady(pShbInstance, !pShbMemHeader->m_fJobReady);
-    }
-
-    pShbMemInst->m_pfnSigHndlrJobReady=NULL;
-    return 0;
+	tShbInstance pShbInstance;
+	tShbMemInst *pShbMemInst;
+	tShbMemHeader *pShbMemHeader;
+	long lTimeOut;
+	int iRetVal = -1;
+
+	daemonize("ShbJR%p", pvThreadParam_p);
+	allow_signal(SIGTERM);
+	pShbInstance = (tShbMemInst *) pvThreadParam_p;
+	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance);
+	pShbMemHeader = ShbIpcGetShbMemHeader(pShbMemInst);
+
+	DEBUG_LVL_29_TRACE0
+	    ("ShbIpcThreadSignalJobReady wait for job ready Sem\n");
+	if (pShbMemInst->m_ulTimeOutJobReady != 0) {
+		lTimeOut = (long)pShbMemInst->m_ulTimeOutJobReady;
+		//wait for job ready semaphore
+		iRetVal =
+		    wait_event_interruptible_timeout(pShbMemHeader->
+						     m_WaitQueueJobReady,
+						     (pShbMemHeader->
+						      m_fJobReady != FALSE),
+						     lTimeOut);
+	} else {
+		//wait for job ready semaphore
+		iRetVal =
+		    wait_event_interruptible(pShbMemHeader->m_WaitQueueJobReady,
+					     (pShbMemHeader->m_fJobReady !=
+					      FALSE));
+	}
+
+	if (pShbMemInst->m_pfnSigHndlrJobReady != NULL) {
+		//call Handler
+		pShbMemInst->m_pfnSigHndlrJobReady(pShbInstance,
+						   !pShbMemHeader->m_fJobReady);
+	}
+
+	pShbMemInst->m_pfnSigHndlrJobReady = NULL;
+	return 0;
 }
 
-
-
 //Build the crc table
 static void ShbIpcCrc32GenTable(unsigned long aulCrcTable[256])
 {
-    unsigned long       ulCrc,ulPoly;
-    int                 iIndexI,iIndexJ;
-
-    ulPoly = 0xEDB88320L;
-    for (iIndexI = 0; iIndexI < 256; iIndexI++)
-    {
-        ulCrc = iIndexI;
-        for (iIndexJ = 8; iIndexJ > 0; iIndexJ--)
-        {
-            if (ulCrc & 1)
-            {
-                ulCrc = (ulCrc >> 1) ^ ulPoly;
-            }
-            else
-            {
-                ulCrc >>= 1;
-            }
-        }
-        aulCrcTable[iIndexI] = ulCrc;
-    }
+	unsigned long ulCrc, ulPoly;
+	int iIndexI, iIndexJ;
+
+	ulPoly = 0xEDB88320L;
+	for (iIndexI = 0; iIndexI < 256; iIndexI++) {
+		ulCrc = iIndexI;
+		for (iIndexJ = 8; iIndexJ > 0; iIndexJ--) {
+			if (ulCrc & 1) {
+				ulCrc = (ulCrc >> 1) ^ ulPoly;
+			} else {
+				ulCrc >>= 1;
+			}
+		}
+		aulCrcTable[iIndexI] = ulCrc;
+	}
 }
 
 //Calculate the crc value
-static unsigned long ShbIpcCrc32GetCrc(const char *pcString,unsigned long aulCrcTable[256])
+static unsigned long ShbIpcCrc32GetCrc(const char *pcString,
+				       unsigned long aulCrcTable[256])
 {
-    unsigned long   ulCrc;
-    int             iIndex;
+	unsigned long ulCrc;
+	int iIndex;
 
-    ulCrc = 0xFFFFFFFF;
-    for (iIndex=0;iIndex<strlen(pcString);iIndex++)
-    {
-        ulCrc = ((ulCrc>>8) & 0x00FFFFFF) ^ aulCrcTable[ (ulCrc^pcString[iIndex]) & 0xFF ];
-    }
-    return( ulCrc^0xFFFFFFFF );
+	ulCrc = 0xFFFFFFFF;
+	for (iIndex = 0; iIndex < strlen(pcString); iIndex++) {
+		ulCrc =
+		    ((ulCrc >> 8) & 0x00FFFFFF) ^
+		    aulCrcTable[(ulCrc ^ pcString[iIndex]) & 0xFF];
+	}
+	return (ulCrc ^ 0xFFFFFFFF);
 
 }
 
-static void ShbIpcAppendListElement (struct sShbMemTable *psNewMemTableElement)
+static void ShbIpcAppendListElement(struct sShbMemTable *psNewMemTableElement)
 {
-    struct sShbMemTable *psMemTableElement=psMemTableElementFirst_g;
-    psNewMemTableElement->m_psNextMemTableElement=NULL;
-
-    if (psMemTableElementFirst_g!= NULL )
-    {      /* sind Elemente vorhanden */
-       while (psMemTableElement->m_psNextMemTableElement != NULL )
-       {    /* suche das letzte Element */
-           psMemTableElement=psMemTableElement->m_psNextMemTableElement;
-       }
-       psMemTableElement->m_psNextMemTableElement=psNewMemTableElement;              /*  Haenge das Element hinten an */
-    }
-    else
-    {                           /* wenn die liste leer ist, bin ich das erste Element */
-        psMemTableElementFirst_g=psNewMemTableElement;
-    }
+	struct sShbMemTable *psMemTableElement = psMemTableElementFirst_g;
+	psNewMemTableElement->m_psNextMemTableElement = NULL;
+
+	if (psMemTableElementFirst_g != NULL) {	/* sind Elemente vorhanden */
+		while (psMemTableElement->m_psNextMemTableElement != NULL) {	/* suche das letzte Element */
+			psMemTableElement =
+			    psMemTableElement->m_psNextMemTableElement;
+		}
+		psMemTableElement->m_psNextMemTableElement = psNewMemTableElement;	/*  Haenge das Element hinten an */
+	} else {		/* wenn die liste leer ist, bin ich das erste Element */
+		psMemTableElementFirst_g = psNewMemTableElement;
+	}
 }
 
-
-
-
-static int ShbIpcFindListElement (int iBufferId, struct sShbMemTable **ppsReturnMemTableElement)
+static int ShbIpcFindListElement(int iBufferId,
+				 struct sShbMemTable **ppsReturnMemTableElement)
 {
-    struct sShbMemTable *psMemTableElement=psMemTableElementFirst_g;
-    while (psMemTableElement!=NULL)
-    {
-        if(psMemTableElement->m_iBufferId==iBufferId)
-        {
+	struct sShbMemTable *psMemTableElement = psMemTableElementFirst_g;
+	while (psMemTableElement != NULL) {
+		if (psMemTableElement->m_iBufferId == iBufferId) {
 //printk("ShbIpcFindListElement Buffer at:%p Id:%d\n",psMemTableElement->m_pBuffer,psMemTableElement->m_iBufferId);
-             *ppsReturnMemTableElement=psMemTableElement;
+			*ppsReturnMemTableElement = psMemTableElement;
 //printk("ShbIpcFindListElement Buffer at:%p Id:%d\n",(*ppsReturnMemTableElement)->m_pBuffer,(*ppsReturnMemTableElement)->m_iBufferId);
-             return 0;
-        }
-        psMemTableElement=psMemTableElement->m_psNextMemTableElement;
-    }
-    return -1;
+			return 0;
+		}
+		psMemTableElement = psMemTableElement->m_psNextMemTableElement;
+	}
+	return -1;
 }
 
 static void ShbIpcDeleteListElement(int iBufferId)
 {
-   struct sShbMemTable *psMemTableElement=psMemTableElementFirst_g;
-   struct sShbMemTable *psMemTableElementOld=psMemTableElementFirst_g;
-   if (psMemTableElement!=NULL)
-   {
-        while((psMemTableElement!=NULL)&&(psMemTableElement->m_iBufferId!=iBufferId))
-        {
-            psMemTableElementOld=psMemTableElement;
-            psMemTableElement=psMemTableElement->m_psNextMemTableElement;
-        }
-        if (psMemTableElement!=NULL)
-        {
-            if (psMemTableElement!=psMemTableElementFirst_g)
-            {
-                psMemTableElementOld->m_psNextMemTableElement=psMemTableElement->m_psNextMemTableElement;
-                kfree(psMemTableElement);
-            }
-            else
-            {
-                kfree(psMemTableElement);
-                psMemTableElementFirst_g=NULL;
-            }
-
-        }
-   }
+	struct sShbMemTable *psMemTableElement = psMemTableElementFirst_g;
+	struct sShbMemTable *psMemTableElementOld = psMemTableElementFirst_g;
+	if (psMemTableElement != NULL) {
+		while ((psMemTableElement != NULL)
+		       && (psMemTableElement->m_iBufferId != iBufferId)) {
+			psMemTableElementOld = psMemTableElement;
+			psMemTableElement =
+			    psMemTableElement->m_psNextMemTableElement;
+		}
+		if (psMemTableElement != NULL) {
+			if (psMemTableElement != psMemTableElementFirst_g) {
+				psMemTableElementOld->m_psNextMemTableElement =
+				    psMemTableElement->m_psNextMemTableElement;
+				kfree(psMemTableElement);
+			} else {
+				kfree(psMemTableElement);
+				psMemTableElementFirst_g = NULL;
+			}
+
+		}
+	}
 
 }