global_types_l3.h

有关于USB的一些主机端驱动

// ===============================================================================
//            TEXAS INSTRUMENTS INCORPORATED PROPRIETARY INFORMATION
//
//   Property of Texas Instruments -- For  Unrestricted  Internal  Use Only
//   Unauthorized reproduction and/or distribution is strictly prohibited.  This
//   product  is  protected  under  copyright  law  and  trade  secret law as an
//   unpublished work.  Created 2000, (C) Copyright 2000 Texas Instruments.  All
//   rights reserved.
//
//   Description     : Header file for the DSP Interrupt Interface
//
//   Project         : omap
// ===============================================================================

#ifndef _GLOBAL_TYPES_H
#define _GLOBAL_TYPES_H

typedef unsigned char  UWORD8;
typedef signed   char  WORD8;


typedef unsigned short UWORD16;
typedef          short WORD16;
typedef unsigned int   BIT;

// int and long both fit to 32 bits
typedef unsigned long  UWORD32;
typedef          long  WORD32;

//--------------------------------------------------
// Memory types
//----------------------------------------------------
typedef volatile unsigned char  MEMORY_UWORD8;
typedef volatile signed   char  MEMORY_WORD8;

typedef volatile unsigned short MEMORY_UWORD16;
typedef volatile          short MEMORY_WORD16;

typedef volatile unsigned long  MEMORY_UWORD32;
typedef volatile          long  MEMORY_WORD32;

#define MEM8(A)     (*(MEMORY_UWORD8*)(A))
#define MEM16(A)    (*(MEMORY_UWORD16*)(A))
#define MEM32(A)    (*(MEMORY_UWORD32*)(A))

//--------------------------------------------------
// Register types (I/O Space)
//----------------------------------------------------
typedef volatile ioport unsigned char  REGISTER_UWORD8;
typedef volatile ioport signed   char  REGISTER_WORD8;

typedef volatile ioport unsigned short REGISTER_UWORD16;
typedef volatile ioport          short REGISTER_WORD16;

#define REG8(A)     (*(REGISTER_UWORD8*)(A))
#define REG16(A)    (*(REGISTER_UWORD16*)(A))

//--------------------------------------------------
// Boolean type
//--------------------------------------------------
typedef enum  {False= 0, True=1 } boolean_t;
#define BOOL           boolean_t

#define FALSE                                     0
#define TRUE                                      1

#define NO                                        FALSE
#define YES                                       TRUE

#define DISABLE                                   FALSE
#define ENABLE                                    TRUE

#define NOT_OK                                    FALSE
#define IS_OK                                     TRUE

//--------------------------------------------------
// pointer to a function
//--------------------------------------------------
typedef void (*FUNC)(void);

//--------------------------------------------------
// Bit functions definitions
//--------------------------------------------------
#define SetBit(registre,mask)                 (registre|=mask)
#define ClearBit(registre,mask)               (registre&=~mask)
#define TestBit(registre,mask)                (registre&mask)
#define TestBitValue(registre,mask,value)     ((registre&mask)==value)

#define GetGroupBits8(registre,position,number)        (((registre) & ((0xFF>>(8-(number)))<<(position)))>>(position))

#define GetGroupBits16(registre,position,number)       (((registre) & ((0xFFFF>>(16-(number)))<<(position)))>>(position))

#define GetGroupBits32(registre,position,number)       (((registre) & ((0xFFFFFFFF>>(32-(number)))<<(position)))>>(position))

#define SetGroupBits8(registre,position,width,value)\
                      registre&=~( (0xFF>> (8-(width)) ) <<(position) );\
                      registre|=( (value&(0xFF>> (8-(width)) )) <<(position) )

#define SetGroupBits16(registre,position,width,value)\
                       registre&=~((0xFFFF>>(16-(width)))<<(position));\
                       registre|=((value&(0xFFFF>>(16-(width))))<<(position))

#define SetGroupBits32(registre,position,width,value)\
                       registre&=~((0xFFFFFFFF>>(32-(width)))<<(position));\
                       registre|=((value&(0xFFFFFFFF>>(32-(width))))<<(position))

    
#define SetBitIndex(registre,index)     (registre|=(1<<(index)))
#define ClearBitIndex(registre,index)   (registre&=~(1<<(index)))
#define TestBitIndex(registre,index)    (registre&(1<<(index)))
       
#define AND                            &&
#define OR                             ||
#define NOT                             !
#define EQU                            ==

#endif