compati.h

SAMSUNG 5009的源代码

/* compati.h - SAMSUNG S5L5005 Compatibility header */

/* Copyright 2005 TAEBAEK Soft Corp. */

/*
modification history
--------------------
02e,28nov05,jmLee   add LODSW, STOSW.
01a,21sep05,jmLee   created.
*/


#ifndef __INCcompatih
#define __INCcompatih

#include <string.h>


#ifdef  __cplusplus
extern "C" {
#endif

/*
 *	To print out USB devide access state
 *
 *	TJ
 */
#define UART_DISPLAY	0

/*
 * This option is for mass production test
 *
 * TJ
 */
#define DIAG_TEST                       0

/*
	for usb read sector count.
	060919 by CKLee.
*/
#define USB_READ_SECTOR_COUNT		32
//#define USB_READ_SECTOR_COUNT	64
//#define USB_READ_SECTOR_COUNT	128

/* Type defines */

#ifndef UCHAR
typedef unsigned char UCHAR;
#endif
#ifndef USHORT
typedef unsigned short USHORT;
#endif
#ifndef UINT
typedef unsigned int UINT;
#endif
#ifndef ULONG
typedef unsigned long ULONG;
#endif
#ifndef PUCHAR
typedef UCHAR *PUCHAR;
#endif  /* PUUCHAR */
#ifndef PUSHORT
typedef USHORT *PUSHORT;
#endif  /* PUSHORT */
#ifndef PUINT
typedef UINT *PUINT;
#endif  /* PUINT */
#ifndef PULONG
typedef ULONG *PULONG;
#endif  /* PULONG */
#ifndef PVOID
typedef VOID *PVOID;
#endif  /* PVOID */

/* Byte order defines */

#ifndef _LITTLE_ENDIAN
#define _LITTLE_ENDIAN                  1234
#define _BIG_ENDIAN                     4321
#endif  /* _LITTLE_ENDIAN */

#ifndef _BYTE_ORDER
#define _BYTE_ORDER                     _BIG_ENDIAN
#endif  /* _BYTE_ORDER */

#define SIZE_OF_INT                     4

#ifndef MSB
#define MSB(w)                          ((UCHAR)(((w) >> 8) & 0xff))
#define LSB(w)                          ((UCHAR)(((w) >> 0) & 0xff))
#endif  /* MSB */
#ifndef MSW
#define MSW(dw)                         ((USHORT)(((dw) >> 16) & 0xffff))
#define LSW(dw)                         ((USHORT)(((dw) >>  0) & 0xffff))
#endif  /* MSW */
#ifndef MSWMSB
#define MSWMSB(dw)                      ((UCHAR)(((dw) >> 24) & 0xff))
#define MSWLSB(dw)                      ((UCHAR)(((dw) >> 16) & 0xff))
#define LSWMSB(dw)                      ((UCHAR)(((dw) >>  8) & 0xff))
#define LSWLSB(dw)                      ((UCHAR)(((dw) >>  0) & 0xff))
#endif  /* MSWMSB */

#ifndef MKWORD
#define MKWORD(lb, hb)                  ((((USHORT)(hb)) << 8) | ((USHORT)(lb)))
#endif  /* MKWORD */
#ifndef MKLONG
#define MKLONG(lw, hw)                  ((((ULONG)(hw)) << 16) | ((ULONG)(lw)))
#endif  /* MKLONG */
#ifndef MKDWORD
#define MKDWORD(lwlb, lwhb, hwlb, hwhb) ((((ULONG)(hwhb)) << 24) | \
                                         (((ULONG)(hwlb)) << 16) | \
                                         (((ULONG)(lwhb)) <<  8) | \
                                         (((ULONG)(lwlb)) <<  0))
#endif  /* MKDWORD */

/* Some MCU has problems with memory alignment */
#define WORD_ALIGNED_MCU

#if     (_BYTE_ORDER == _BIG_ENDIAN)

#define LSB_FROM_LITTLE(w)              (((PUCHAR)(&(w)))[0])
#define MSB_FROM_LITTLE(w)              (((PUCHAR)(&(w)))[1])

#define WORD_FROM_LITTLE(w)             MKWORD((((PUCHAR)(&(w)))[0]), (((PUCHAR)(&(w)))[1]))
#define WORD_TO_LITTLE(w)               WORD_FROM_LITTLE(w)

#define WRAPPED_WORD_FROM_LITTLE(w)     WORD_FROM_LITTLE(w)

#define CONST_WORD_TO_LITTLE(w)         (((((USHORT)(w)) & 0x00ff) << 8) | ((((USHORT)(w)) >> 8) & 0x00ff))

#define LSW_FROM_LITTLE(dw)             MKWORD((((PUCHAR)(&(dw)))[0]), (((PUCHAR)(&(dw)))[1]))
#define MSW_FROM_LITTLE(dw)             MKWORD((((PUCHAR)(&(dw)))[2]), (((PUCHAR)(&(dw)))[3]))

#define DWORD_FROM_LITTLE(dw)           MKDWORD((((PUCHAR)(&(dw)))[0]), (((PUCHAR)(&(dw)))[1]), (((PUCHAR)(&(dw)))[2]), (((PUCHAR)(&(dw)))[3]))
#define DWORD_TO_LITTLE(dw)             DWORD_FROM_LITTLE(dw)

#define WRAPPED_DWORD_FROM_LITTLE(dw)   DWORD_FROM_LITTLE(dw)

#define CONST_DWORD_TO_LITTLE(dw)       (((((ULONG)(dw)) & 0x000000ff) << 24) | \
                                         ((((ULONG)(dw)) & 0x0000ff00) <<  8) | \
                                         ((((ULONG)(dw)) >>  8) & 0x0000ff00) | \
                                         ((((ULONG)(dw)) >> 24) & 0x000000ff))

#else   /* (_BYTE_ORDER == _BIG_ENDIAN) */

#define LSB_FROM_LITTLE(w)              (((PUCHAR)(&(w)))[0])
#define MSB_FROM_LITTLE(w)              (((PUCHAR)(&(w)))[1])

#define WORD_FROM_LITTLE(w)             (w)
#define WORD_TO_LITTLE(w)               (w)

#define WRAPPED_WORD_FROM_LITTLE(w)     MKWORD((((PUCHAR)(&(w)))[0]), (((PUCHAR)(&(w)))[1]))

#define CONST_WORD_TO_LITTLE(w)         (w)

#define LSW_FROM_LITTLE(dw)             (((PUSHORT)(&(dw)))[0])
#define MSW_FROM_LITTLE(dw)             (((PUSHORT)(&(dw)))[1])

#define DWORD_FROM_LITTLE(dw)           (dw)
#define DWORD_TO_LITTLE(dw)             DWORD_FROM_LITTLE(dw)

#define WRAPPED_DWORD_FROM_LITTLE(dw)   MKDWORD((((PUCHAR)(&(dw)))[0]), (((PUCHAR)(&(dw)))[1]), (((PUCHAR)(&(dw)))[2]), (((PUCHAR)(&(dw)))[3]))

#define CONST_DWORD_TO_LITTLE(dw)       (dw)

#endif  /* (_BYTE_ORDER == _BIG_ENDIAN) */

/* Common Macros */

#ifndef max
#define max(a, b)                       (((a) > (b)) ? (a) : (b))
#endif  /* max */

#ifndef min
#define min(a, b)                       (((a) < (b)) ? (a) : (b))
#endif  /* min */

#ifndef IMPORT
#define IMPORT                          extern
#endif  /* IMPORT */

#ifndef LOCAL
#define LOCAL                           static
#endif  /* LOCAL */

#ifndef CONST
#define CONST                           const
#endif  /* CONST */

#ifndef OK
#define OK                              0
#endif  /* OK */

#ifndef ERROR
#define ERROR                           -1
#endif  /* ERROR */

#ifndef NULL
#define NULL (0)
#endif  /* NULL */

#ifndef bcopy
#define bcopy(_s, _d, _l)               {\
                                            PUCHAR src = (PUCHAR)(_s);\
                                            PUCHAR dst = (PUCHAR)(_d);\
                                            int length = (int)(_l);\
                                            int i;\
                                            for (i=0; i<length; i++)\
                                            {\
                                                *dst++ = *src++;\
                                            }\
                                        }
#endif  /* bcopy */

#ifndef LODSW
#define LODSW(_d, _s, _l)              {\
                                            volatile PULONG src = (volatile PULONG)(_s);\
                                            PUSHORT dst = (PUSHORT)(_d);\
                                            int length = (int)(_l);\
                                            int i;\
                                            for (i=0; i<length; i++)\
                                            {\
                                                *dst++ = (USHORT)(*src);\
                                                *dst++ = (USHORT)(*src);\
                                            }\
                                        }
#endif  /* LODSW */

#ifndef STOSW
#define STOSW(_d, _s, _l)              {\
                                            PUSHORT src = (PUSHORT)(_s);\
                                            volatile PULONG dst = (volatile PULONG)(_d);\
                                            int length = (int)(_l);\
                                            int i;\
                                            for (i=0; i<length; i++)\
                                            {\
                                                *dst = (UINT)(*src++);\
                                                *dst = (UINT)(*src++);\
                                            }\
                                        }
#endif  /* STOSW */

#ifndef TRACE_OUT
#define TRACE_OUT                       SysPrintf
#endif  /* TRACE_OUT */


#ifdef __cplusplus
}
#endif


#endif  /* __INCcompatih */