Skip to content

L
linux-davinci
Commit b4a4d568 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files
Options

Staging: epl: remove complier macros from global.h 

As we are only building within the Linux kernel, remove all of the
different system types from global.h, they are not needed at all.

First step of many to clean up the code to match the kernel coding
style rules.

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 06c86229
Show whitespace changes
Inline Side-by-side
Showing with 23 additions and 1075 deletions
drivers/staging/epl/global.h
View file @ b4a4d568
......@@ -121,827 +121,40 @@
//---------------------------------------------------------------------------
// defines for target system (TARGET_SYSTEM)
//---------------------------------------------------------------------------
#define _DOS_ (16 + 0x10000)
#define _WIN16_ 16
#define _WIN32_ 32
#define _WINCE_ (32 + 0x20000)
#define _NO_OS_ 0
#define _LINUX_ 1
#define _PXROS_ 2
#define _ECOSPRO_ 3
//---------------------------------------------------------------------------
// definitions for function inlining
//---------------------------------------------------------------------------
#define INLINE_FUNCTION // empty define
#undef INLINE_ENABLED // disable actual inlining of functions
#undef INLINE_FUNCTION_DEF // disable inlining for all compilers per default
//---------------------------------------------------------------------------
// definitions for Keil C51
//---------------------------------------------------------------------------
#ifdef __C51__
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_KEIL_C51X_
#pragma DEBUG OBJECTEXTEND
#pragma WARNINGLEVEL(2) // maximum warning level
#define NEAR idata // variables mapped to internal data storage location
#define FAR xdata // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM code // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC xdata // hardware access through external memory (i.e. CAN)
#define LARGE large // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM xdata // Memory attribute to optimize speed and code of pointer access.
#define REENTRANT reentrant
#define PUBLIC
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#endif
//---------------------------------------------------------------------------
// definitions for GNU Compiler for Infineon C16x
// - it have to be befor Keil (it has __C166__ too)
//---------------------------------------------------------------------------
#elif defined (__GNUC__) && defined (__C166__)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_GNU_C16X_
// #define NEAR idata // variables mapped to internal data storage location
#define NEAR near // variables mapped to internal data storage location
// #define FAR xhuge // variables mapped to external data storage location
#define FAR huge // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
// #define HWACC sdata // hardware access through external memory (i.e. CAN)
#define HWACC huge // hardware access through external memory (i.e. CAN)
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
// #define GENERIC xhuge // generic pointer to point to application data
#define GENERIC huge // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define REENTRANT
#define PUBLIC
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#define ASSERT(p) \
if (p) \
{ \
; \
} \
else \
{ \
PRINTF0("Assert failed: " #p " (file %s line %d)\n", __FILE__, (int) __LINE__ ); \
while (1); \
}
#else
#define ASSERT(p)
#endif
//---------------------------------------------------------------------------
// definitions for Keil C166
//---------------------------------------------------------------------------
#elif defined (__C166__) // 24.01.2005 r.d.: Keil ARM7 needs directive 'defined'
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_KEIL_C16X_
#pragma CODE
#pragma MOD167
#pragma NOINIT
#pragma DEBUG
#pragma WARNINGLEVEL(3) // maximum warning level
#pragma WARNING DISABLE = 47 // warning <unreferenced parameter> = OFF
#pragma WARNING DISABLE = 38 // warning <empty translation unit> = OFF
// #pragma WARNING DISABLE = 102 // warning <different const/volatile qualifiers> = OFF
#pragma WARNING DISABLE = 174 // warning <unreferenced 'static' function> = OFF
#pragma WARNING DISABLE = 183 // warning <dead assignement eliminated> = OFF
#define NEAR idata // variables mapped to internal data storage location
#define FAR xhuge // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
// #define HWACC sdata // hardware access through external memory (i.e. CAN)
#define HWACC huge // hardware access through external memory (i.e. CAN)
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC xhuge // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define REENTRANT
#define PUBLIC
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#endif
//---------------------------------------------------------------------------
// definitions for MPLAB C30 for dsPIC33F series
//---------------------------------------------------------------------------
#elif defined (__C30__)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_MPLAB_DSPIC33F_
#define NEAR // variables mapped to internal data storage location
#define FAR // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC // hardware access through external memory (i.e. CAN)
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define REENTRANT
#define PUBLIC
// #ifndef QWORD
// #define QWORD long long
// #endif
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#endif
//---------------------------------------------------------------------------
// definitions for Keil ARM
//---------------------------------------------------------------------------
#elif defined (__CA__)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_KEIL_CARM_
#define NEAR // variables mapped to internal data storage location
#define FAR // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC // hardware access through external memory (i.e. CAN)
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define REENTRANT
#define PUBLIC
#ifndef QWORD
#define QWORD long long
#endif
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#endif
//---------------------------------------------------------------------------
// definitions for RealView ARM compilation tools (provided by recent Keil Microcontroller Development Kits)
//---------------------------------------------------------------------------
#elif defined (__ARMCC_VERSION)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_RVCT_CARM_
#define NEAR // variables mapped to internal data storage location
#define FAR // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC // hardware access through external memory (i.e. CAN)
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define REENTRANT
#define PUBLIC
#ifndef QWORD
#define QWORD long long
#endif
#ifndef NDEBUG
#define ASSERT(expr) if (!(expr)) {\
TRACE0 ("Assertion failed: " #expr );\
while (1);}
#else
#define ASSERT(expr)
#endif
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#endif
//---------------------------------------------------------------------------
// definitions for ARM IAR C Compiler
//---------------------------------------------------------------------------
#elif defined (__ICCARM__)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_IAR_CARM_
#define NEAR // variables mapped to internal data storage location
#define FAR // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC // hardware access through external memory (i.e. CAN)
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define REENTRANT
#define PUBLIC
#ifndef QWORD
#define QWORD long long
#endif
// Workaround:
// If we use IAR and want to debug but don't want to use C-Spy Debugger
// assert() doesn't work in debug mode because it needs support for FILE descriptors
// (_DLIB_FILE_DESCRIPTOR == 1).
#ifndef NDEBUG
#define ASSERT(expr) if (!(expr)) {\
TRACE0 ("Assertion failed: " #expr );\
while (1);}
#else
#define ASSERT(expr)
#endif
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
// #define TRACE PRINTF4
#endif
//---------------------------------------------------------------------------
// definitions for Tasking 8051
//---------------------------------------------------------------------------
#elif defined (_CC51)
#include <cc51.h>
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_TASKING_C51X_
#define NEAR _data // variables mapped to internal data storage location
#define FAR _xdat // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC _xdat // hardware access through external memory (i.e. CAN)
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM _xdat // Memory attribute to optimize speed and code of pointer access.
#define REENTRANT _reentrant
#define PUBLIC
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#endif
//---------------------------------------------------------------------------
// definitions for Tasking C167CR and C164CI
//---------------------------------------------------------------------------
#elif defined (_C166)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_TASKING_C16X_
#define NEAR near // variables mapped to internal data storage location
#define FAR far // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC /* to be defined */ // hardware access through external memory (i.e. CAN)
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define REENTRANT
#define PUBLIC
// Stdio.h has to be alway included here. If printf() is used stdio.h defines NULL
// without checking if it is already included. So an error occurs while compiling.
// (r.d.)
#include <stdio.h> // prototype printf() (for TRACE)
#ifndef NDEBUG
#define TRACE printf
#endif
//---------------------------------------------------------------------------
// definitions for FUJITSU FFMC-16LX MB90590
//---------------------------------------------------------------------------
//#elif (defined (F590) || defined (F543) || defined (F598) || defined (F495) || defined (F350))
#elif defined(__COMPILER_FCC907__)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_FUJITSU_F590_
#define NEAR /* to be defined */ // variables mapped to internal data storage location
#define FAR /* to be defined */ // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM /* to be defined */ // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC /* to be defined */ // hardware access through external memory (i.e. CAN)
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
// softune is not able to support 64 bit variables QWORD !!!
#define REENTRANT
#define PUBLIC
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#endif
//---------------------------------------------------------------------------
// definitions for Mitsubishi M16C family for TASKING Compiler CM16
//---------------------------------------------------------------------------
#elif defined (_CM16C)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_TASKING_M16C_
#define NEAR _near // variables mapped to internal data storage location
#define FAR _far // variables mapped to external data storage location
#define CONST _farrom // variables mapped to ROM (i.e. flash)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC _near // hardware access through external memory (i.e. CAN)
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC _far // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
// do you use memory model SMALL, than you have to set _far
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define REENTRANT
#define PUBLIC
// Stdio.h has to be alway included here. If printf() is used stdio.h defines NULL
// without checking if it is already included. So an error occurs while compiling.
// (r.d.)
#include <stdio.h> // prototype printf() (for TRACE)
#ifndef NDEBUG
#define TRACE printf
#endif
//---------------------------------------------------------------------------
// definitions for Mitsubishi M16C family for Mitsubishi Compiler NC30
//---------------------------------------------------------------------------
// name NC30, andere Form will der Compiler nicht !!
#elif defined (NC30)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_MITSUBISHI_M16C_
#define NEAR near // variables mapped to internal data storage location
#define FAR far // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC near // hardware access through external memory (i.e. CAN)
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC far // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define REENTRANT
#define PUBLIC
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#endif
//---------------------------------------------------------------------------
// definitions for Renesas M32C family for Renesas Compiler
//---------------------------------------------------------------------------
#elif defined (NC308)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_RENESAS_M32C_
#define NEAR near // variables mapped to internal data storage location
#define FAR far // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM // code or variables mapped to ROM (i.e. flash)
#define HWACC // hardware access through external memory (i.e. CAN)
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM far // Memory attribute to optimize speed and code of pointer access.
#define REENTRANT
#define PUBLIC
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#endif
// #error ("RENESAS o.k.")
//---------------------------------------------------------------------------
// definitions for ARM7 family with GNU compiler
//---------------------------------------------------------------------------
#elif defined(__GNUC__) && defined(__arm__) && !defined(__LINUX_ARM_ARCH__)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_GNU_ARM7_
#define NEAR // variables mapped to internal data storage location
#define FAR // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC // hardware access through external memory (i.e. CAN)
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define HWACC // hardware access through external memory (i.e. CAN)
#define REENTRANT
#define PUBLIC
#ifndef QWORD
#define QWORD long long // i.A. durch Herr Kuschel
#endif
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#endif
//---------------------------------------------------------------------------
// definitions for Motorola PowerPC family 5x5 (555/565)
// definitions Linux-PC
//---------------------------------------------------------------------------
#elif defined (__GNUC__)
#if defined (LINUX) || defined (linux) || defined (__linux__)
#define LINUX_SYSTEM // define 'LINUX_SYSTEM' uniform for all Linux based systems
// r.d.: We will need an other solution here! There are two sections here which do check the preproc-definitions:
// LINUX and __linux__ . The first one was Linux for PC, the second one is this section for embedded Linux (MCF5xxx).
// But Linux for PC does not need the definitions for embedded Linux.
#endif
// GNU C compiler supports function inlining
#define INLINE_FUNCTION_DEF extern inline
// to actually enable inlining just include the following three lines
// #undef INLINE_FUNCTION
// #define INLINE_FUNCTION INLINE_FUNCTION_DEF
// #define INLINE_ENABLED TRUE
#ifdef PXROS
#define TARGET_SYSTEM _PXROS_
#ifdef __i386__
#undef LINUX // this define seems to be set from compiler
#define DEV_SYSTEM _DEV_HIGHTEC_X86_
#elif defined (__tricore__)
#define DEV_SYSTEM _DEV_GNU_TRICORE_
#else // MPC5x5
#define DEV_SYSTEM _DEV_GNU_MPC5X5_
#endif
#elif defined (LINUX) || defined (__linux__)
#define TARGET_SYSTEM _LINUX_ // Linux definition
#define DEV_SYSTEM _DEV_LINUX_
#elif defined (GNU_CF5282)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_GNU_CF5282_
#elif defined (ECOSPRO_I386_PEAK_PCI)
#define TARGET_SYSTEM _ECOSPRO_
#define DEV_SYSTEM _DEV_GNU_I386_
#elif defined (GNU_CF548X)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_GNU_CF548X_
#else
#error 'ERROR: DEV_SYSTEM not found!'
#endif
#ifndef QWORD
#define QWORD long long int
#endif
#if (TARGET_SYSTEM == _PXROS_)
#ifndef __KERNEL__
#include <string.h>
#endif
#define NEAR // variables mapped to internal data storage location
#define FAR // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM /* to be defined */ // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define HWACC // hardware access through external memory (i.e. CAN)
#define REENTRANT
#define PUBLIC
#ifndef QWORD
#define QWORD long long int
#endif
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#endif
#endif
// ------------------ GNUC for I386 ---------------------------------------------
#if (TARGET_SYSTEM == _LINUX_) || (TARGET_SYSTEM == _ECOSPRO_)
#ifndef __KERNEL__
#include <string.h>
#endif
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC // hardware access through external memory (i.e. CAN)
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#ifndef NEAR
#define NEAR // variables mapped to internal data storage location
#endif
#ifndef FAR
#define FAR // variables mapped to external data storage location
#endif
#ifndef CONST
#define CONST const // variables mapped to ROM (i.e. flash)
#endif
#define LARGE
#define REENTRANT
#define PUBLIC
#ifndef NDEBUG
#ifndef __KERNEL__
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#else
#define TRACE printk
#endif
#endif
#endif
// ------------------ GNU without OS ---------------------------------------------
#if (TARGET_SYSTEM == _NO_OS_)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC // hardware access through external memory (i.e. CAN)
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#ifndef NEAR
#define NEAR // variables mapped to internal data storage location
#endif
#ifndef FAR
#define FAR // variables mapped to external data storage location
#endif
#ifndef CONST
#define CONST const // variables mapped to ROM (i.e. flash)
#endif
#define LARGE
#define REENTRANT
#define PUBLIC
#ifndef NDEBUG
// #include "xuartdrv.h"
// #include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
// #define TRACE mprintf
// #ifndef TRACE
// #define TRACE trace
// void trace (char *fmt, ...);
// #endif
#endif
#endif
//---------------------------------------------------------------------------
// definitions for MPC565
//---------------------------------------------------------------------------
#elif __MWERKS__
#ifdef __MC68K__
#define TARGET_SYSTEM = _MCF548X_
#define DEV_SYSTEM _DEV_MCW_MCF5XXX_
#else
#define TARGET_SYSTEM = _MPC565_
#define DEV_SYSTEM _DEV_MCW_MPC5X5_
#endif
#define NEAR // variables mapped to internal data storage location
#define FAR // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define LARGE // functions set parameters to external data storage location
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define HWACC // hardware access through external memory (i.e. CAN)
#define REENTRANT
#define PUBLIC
#ifndef NDEBUG
#include <stdio.h> // prototype printf() (for TRACE)
#define TRACE printf
#endif
#define _WIN32_ 32
#define _NO_OS_ 0
#define _LINUX_ 1
//---------------------------------------------------------------------------
// definitions for BECK 1x3
// definitions for function inlining
//---------------------------------------------------------------------------
#elif defined (__BORLANDC__) && defined (__PARADIGM__)
#define TARGET_SYSTEM _NO_OS_
#define DEV_SYSTEM _DEV_PAR_BECK1X3_
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC // hardware access through external memory (i.e. CAN)
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define NEAR __near // variables mapped to internal data storage location
#define FAR __far // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define LARGE
#define INLINE_FUNCTION // empty define
#undef INLINE_ENABLED // disable actual inlining of functions
#undef INLINE_FUNCTION_DEF // disable inlining for all compilers per default
#define REENTRANT
#define PUBLIC
#ifndef NDEBUG
#ifndef TRACE
#include <stdio.h>
#define TRACE printf
#endif
#endif
#define LINUX_SYSTEM // define 'LINUX_SYSTEM' uniform for all Linux based systems
// r.d.: We will need an other solution here! There are two sections here which do check the preproc-definitions:
// LINUX and __linux__ . The first one was Linux for PC, the second one is this section for embedded Linux (MCF5xxx).
// But Linux for PC does not need the definitions for embedded Linux.
//---------------------------------------------------------------------------
// definitions for PC
//---------------------------------------------------------------------------
// GNU C compiler supports function inlining
#define INLINE_FUNCTION_DEF extern inline
#elif defined (__BORLANDC__)
// to actually enable inlining just include the following three lines
// #undef INLINE_FUNCTION
// #define INLINE_FUNCTION INLINE_FUNCTION_DEF
// #define INLINE_ENABLED TRUE
// ------------------ definition target system --------------------------
#define TARGET_SYSTEM _LINUX_ // Linux definition
#define DEV_SYSTEM _DEV_LINUX_
#ifdef _WIN32
#define TARGET_SYSTEM _WIN32_ // WIN32 definition
#define DEV_SYSTEM _DEV_WIN32_
#else
#define TARGET_SYSTEM _DOS_
#define DEV_SYSTEM _DEV_BORLAND_DOS_
#ifndef QWORD
#define QWORD long long int
#endif
// ------------------ WIN32 ---------------------------------------------
#if (TARGET_SYSTEM == _WIN32_)
// ------------------ GNUC for I386 ---------------------------------------------
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
......@@ -966,275 +179,11 @@
#define CONST const // variables mapped to ROM (i.e. flash)
#endif
#define LARGE
#define REENTRANT
#define PUBLIC __stdcall
#ifndef NDEBUG
#ifndef TRACE
#include <stdio.h>
#define TRACE printf
#endif
#endif
#elif (TARGET_SYSTEM == _DOS_)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC // hardware access through external memory (i.e. CAN)
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define NEAR near // variables mapped to internal data storage location
#define FAR far // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define LARGE
#define REENTRANT
#define PUBLIC
#ifndef NDEBUG
#ifndef TRACE
#include <stdio.h>
#define TRACE printf
#endif
#endif
#endif
#elif (_MSC_VER == 800) // PC MS Visual C/C++ for DOS applications
#define TARGET_SYSTEM _DOS_
#define DEV_SYSTEM _DEV_MSVC_DOS_
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC near // hardware access through external memory (i.e. CAN)
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#define NEAR near // variables mapped to internal data storage location
#define FAR far // variables mapped to external data storage location
#define CONST const // variables mapped to ROM (i.e. flash)
#define LARGE
#define REENTRANT
#define PUBLIC
#ifndef NDEBUG
#ifndef TRACE
#include <stdio.h>
#define TRACE printf
#endif
#endif
//---------------------------------------------------------------------------
// definitions for RTX under WIN32
//---------------------------------------------------------------------------
#elif (defined (UNDER_RTSS) && defined (WIN32))
// ------------------ definition target system --------------------------
#define TARGET_SYSTEM _WIN32_RTX_
#define DEV_SYSTEM _DEV_WIN32_RTX_
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC // hardware access through external memory (i.e. CAN)
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#ifndef NEAR
#define NEAR // variables mapped to internal data storage location
#endif
#ifndef FAR
#define FAR // variables mapped to external data storage location
#endif
#ifndef CONST
#define CONST const // variables mapped to ROM (i.e. flash)
#endif
#define LARGE
#define REENTRANT
#define PUBLIC __stdcall
#ifndef NDEBUG
#ifndef TRACE
#define TRACE RtPrintf
#endif
#endif
//---------------------------------------------------------------------------
// definitions for WinCE
//---------------------------------------------------------------------------
#elif defined (_WIN32_WCE)
// ------------------ definition target system --------------------------
#define TARGET_SYSTEM _WINCE_
#define DEV_SYSTEM _DEV_WIN_CE_
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC // hardware access through external memory (i.e. CAN)
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#ifndef NEAR
#define NEAR // variables mapped to internal data storage location
#endif
#ifndef FAR
#define FAR // variables mapped to external data storage location
#endif
#ifndef CONST
#define CONST const // variables mapped to ROM (i.e. flash)
#endif
#define LARGE
#ifndef QWORD
//#define QWORD long long int // MSVC .NET can use "long long int" too (like GNU)
#define QWORD __int64
#endif
#define REENTRANT
#define PUBLIC __cdecl
#ifdef ASSERTMSG
#undef ASSERTMSG
#endif
#ifndef NDEBUG
#ifndef TRACE
#define TRACE printf
// void trace (char *fmt, ...);
#endif
#endif
#else // ===> PC MS Visual C/C++
// ------------------ definition target system --------------------------
#ifdef _WIN32
#define TARGET_SYSTEM _WIN32_ // WIN32 definition
#define DEV_SYSTEM _DEV_WIN32_
#else
#define TARGET_SYSTEM _WIN16_ // WIN16 definition
#define DEV_SYSTEM _DEV_WIN16_
#endif
// ------------------ WIN16 ---------------------------------------------
#if (TARGET_SYSTEM == _WIN16_)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC // hardware access through external memory (i.e. CAN)
// These types can be adjusted by users to match application requirements. The goal is to
// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external
// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#ifndef NEAR
#define NEAR // variables mapped to internal data storage location
#endif
#ifndef FAR
#define FAR far // variables mapped to external data storage location
#endif
#ifndef CONST
#define CONST const // variables mapped to ROM (i.e. flash)
#endif
#define LARGE
#define REENTRANT
#define PUBLIC _far _pascal _export
#define TRACE printk
#ifndef NDEBUG
#ifndef TRACE
#define TRACE trace
#ifdef __cplusplus
extern "C" {
#endif
void trace(const char *fmt, ...);
#ifdef __cplusplus
}
#endif
#endif
#endif
#endif
// ------------------ WIN32 ---------------------------------------------
#if (TARGET_SYSTEM == _WIN32_)
#define ROM // code or variables mapped to ROM (i.e. flash)
// usage: CONST BYTE ROM foo = 0x00;
#define HWACC // hardware access through external memory (i.e. CAN)
// These types can be adjusted by users to match application requirements. The goal is to// minimize code memory and maximize speed.
#define GENERIC // generic pointer to point to application data
// Variables with this attribute can be located in external// or internal data memory.
#define MEM // Memory attribute to optimize speed and code of pointer access.
#ifndef NEAR
#define NEAR // variables mapped to internal data storage location
#endif
#ifndef FAR
#define FAR // variables mapped to external data storage location
#endif
#ifndef CONST
#define CONST const // variables mapped to ROM (i.e. flash)
#endif
#define LARGE
#define REENTRANT
#define PUBLIC __stdcall
#ifndef QWORD
//#define QWORD long long int // MSVC .NET can use "long long int" too (like GNU)
#define QWORD __int64
#endif
#ifndef NDEBUG
#ifndef TRACE
#define TRACE trace
#ifdef __cplusplus
extern "C" {
#endif
void trace(const char *fmt, ...);
#ifdef __cplusplus
}
#endif
#endif
#endif
// MS Visual C++ compiler supports function inlining
#define INLINE_FUNCTION_DEF __forceinline
// to actually enable inlining just include the following two lines// #define INLINE_FUNCTION INLINE_FUNCTION_DEF// #define INLINE_ENABLED TRUE
#endif
#endif // ===> PC
//---------------------------------------------------------------------------// definitions of basic types//---------------------------------------------------------------------------
#ifndef _WINDEF_ // defined in WINDEF.H, included by <windows.h>
// --- arithmetic types ---
#ifndef SHORT
#define SHORT short int
#endif
......@@ -1276,7 +225,6 @@ extern "C" {
#ifndef NULL
#define NULL ((void *) 0)
#endif
#endif
#ifndef _TIME_OF_DAY_DEFINED_
typedef struct {
unsigned long int m_dwMs;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment