We are in the kernel, so these checks are pointless.
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>
 
 #include "global.h"
 
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
-
-//    #include <linux/config.h>
 #include <linux/kernel.h>
 
 #ifdef CONFIG_COLDFIRE
 #define BENCHMARK_MODULES           0x00000000
 #endif
 
-#else
-    // disable Benchmarking
-#undef BENCHMARK_MODULES
-#define BENCHMARK_MODULES               0x00000000
-#endif
-
 /***************************************************************************/
 /*                                                                         */
 /*                                                                         */
 
 ****************************************************************************/
 
 #include "Epl.h"
-//#include "kernel/EplPdokCal.h"
 
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
-#include <asm/uaccess.h>
-#endif
+#include <linux/uaccess.h>
 
 /***************************************************************************/
 /*                                                                         */
        tEplKernel Ret = kEplSuccessful;
 
 #if EPL_API_PROCESS_IMAGE_SIZE_IN > 0
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
        copy_to_user(pPI_p->m_pImage,
                     EplApiProcessImageInstance_g.m_abProcessImageInput,
                     min(pPI_p->m_uiSize,
                         sizeof(EplApiProcessImageInstance_g.
                                m_abProcessImageInput)));
-#else
-       EPL_MEMCPY(pPI_p->m_pImage,
-                  EplApiProcessImageInstance_g.m_abProcessImageInput,
-                  min(pPI_p->m_uiSize,
-                      sizeof(EplApiProcessImageInstance_g.
-                             m_abProcessImageInput)));
-#endif
 #endif
 
        return Ret;
        tEplKernel Ret = kEplSuccessful;
 
 #if EPL_API_PROCESS_IMAGE_SIZE_OUT > 0
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
        copy_from_user(EplApiProcessImageInstance_g.m_abProcessImageOutput,
                       pPI_p->m_pImage,
                       min(pPI_p->m_uiSize,
                           sizeof(EplApiProcessImageInstance_g.
                                  m_abProcessImageOutput)));
-#else
-       EPL_MEMCPY(EplApiProcessImageInstance_g.m_abProcessImageOutput,
-                  pPI_p->m_pImage,
-                  min(pPI_p->m_uiSize,
-                      sizeof(EplApiProcessImageInstance_g.
-                             m_abProcessImageOutput)));
-#endif
 #endif
 
        return Ret;
 
 
 #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_UDP)) != 0)
 
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
 #include "SocketLinuxKernel.h"
 #include <linux/completion.h>
 #include <linux/sched.h>
-#endif
 
 /***************************************************************************/
 /*                                                                         */
        tEplSequLayerReceiveCb m_fpSdoAsySeqCb;
        SOCKET m_UdpSocket;
 
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
        struct completion m_CompletionUdpThread;
        int m_ThreadHandle;
        int m_iTerminateThread;
-#endif
-
 } tEplSdoUdpInstance;
 
 //---------------------------------------------------------------------------
 // local function prototypes
 //---------------------------------------------------------------------------
 
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
 static int EplSdoUdpThread(void *pArg_p);
-#endif
 
 /***************************************************************************/
 /*                                                                         */
                goto Exit;
        }
 
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
        init_completion(&SdoUdpInstance_g.m_CompletionUdpThread);
        SdoUdpInstance_g.m_iTerminateThread = 0;
-#endif
-
        SdoUdpInstance_g.m_ThreadHandle = 0;
        SdoUdpInstance_g.m_UdpSocket = INVALID_SOCKET;
 
 
        if (SdoUdpInstance_g.m_ThreadHandle != 0) {     // listen thread was started
                // close thread
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
                SdoUdpInstance_g.m_iTerminateThread = 1;
                /* kill_proc(SdoUdpInstance_g.m_ThreadHandle, SIGTERM, 1 ); */
                send_sig(SIGTERM, SdoUdpInstance_g.m_ThreadHandle, 1);
                wait_for_completion(&SdoUdpInstance_g.m_CompletionUdpThread);
-#endif
-
                SdoUdpInstance_g.m_ThreadHandle = 0;
        }
 
        if (SdoUdpInstance_g.m_ThreadHandle != 0) {     // listen thread was started
 
                // close old thread
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
                SdoUdpInstance_g.m_iTerminateThread = 1;
                /* kill_proc(SdoUdpInstance_g.m_ThreadHandle, SIGTERM, 1 ); */
                send_sig(SIGTERM, SdoUdpInstance_g.m_ThreadHandle, 1);
                wait_for_completion(&SdoUdpInstance_g.m_CompletionUdpThread);
                SdoUdpInstance_g.m_iTerminateThread = 0;
-#endif
-
                SdoUdpInstance_g.m_ThreadHandle = 0;
        }
 
                goto Exit;
        }
        // create Listen-Thread
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
-
        SdoUdpInstance_g.m_ThreadHandle =
            kernel_thread(EplSdoUdpThread, &SdoUdpInstance_g, CLONE_KERNEL);
        if (SdoUdpInstance_g.m_ThreadHandle == 0) {
                Ret = kEplSdoUdpThreadError;
                goto Exit;
        }
-#endif
 
       Exit:
        return Ret;
        unsigned int uiSize;
        tEplSdoConHdl SdoConHdl;
 
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
        pInstance = (tEplSdoUdpInstance *) pArg_p;
        daemonize("EplSdoUdpThread");
        allow_signal(SIGTERM);
 
        for (; pInstance->m_iTerminateThread == 0;)
-#endif
 
        {
                // wait for data
                                  0,    // flags
                                  (struct sockaddr *)&RemoteAddr,
                                  (int *)&uiSize);
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
                if (iError == -ERESTARTSYS) {
                        break;
                }
-#endif
                if (iError > 0) {
                        // get handle for higher layer
                        iCount = 0;
                }               // end of  if(iError!=SOCKET_ERROR)
        }                       // end of for(;;)
 
-#if (TARGET_SYSTEM == _LINUX_) && defined(__KERNEL__)
        complete_and_exit(&SdoUdpInstance_g.m_CompletionUdpThread, 0);
-#endif
-
        return 0;
 }
 
 
 // applications needs to use one common library function (e.g. memcpy()). So
 // you can set (or change) it here.
 
-#ifndef __KERNEL__
-#include <stdlib.h>
-#include <stdio.h>
-#else
-//        #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/major.h>
 #include <linux/version.h>
-#endif
 
     //29.11.2004 f.j. sonst ist memcpy und memset unbekannt
 //    #include <string.h>
 #define EPL_MEMCPY(dst,src,siz)     memcpy((void*)(dst),(const void*)(src),(size_t)(siz));
 #define EPL_MEMSET(dst,val,siz)     memset((void*)(dst),(int)(val),(size_t)(siz));
 
-#ifndef __KERNEL__
-#define EPL_MALLOC(siz)             malloc((size_t)(siz))
-#define EPL_FREE(ptr)               free((void *)ptr)
-#else
 #define EPL_MALLOC(siz)             kmalloc((size_t)(siz), GFP_KERNEL)
 #define EPL_FREE(ptr)               kfree((void *)ptr)
-#endif
 
 #ifndef PRINTF0
 #define PRINTF                      TRACE
 
 #include "SharedBuff.h"
 #include "ShbIpc.h"
 
-// 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>
-#include <string.h>
-#endif
 
 /***************************************************************************/
 /*                                                                         */
 
 //---------------------------------------------------------------------------
 
 #ifndef ASSERT
-#if !defined (__linux__) && !defined (__KERNEL__)
-#include <assert.h>
-#ifndef ASSERT
-#define ASSERT(p)    assert(p)
-#endif
-#else
 #define ASSERT(p)
 #endif
-#endif
 
 //---------------------------------------------------------------------------
 //  SYS TEC extensions