Common.h

Go to the documentation of this file.

/*
 * @brief LPCUSB library's common macros, definitions
 *
 * @note
 * Copyright(C) NXP Semiconductors, 2012
 * Copyright(C) Dean Camera, 2011, 2012
 * All rights reserved.
 *
 * @par
 * Software that is described herein is for illustrative purposes only
 * which provides customers with programming information regarding the
 * LPC products.  This software is supplied "AS IS" without any warranties of
 * any kind, and NXP Semiconductors and its licensor disclaim any and
 * all warranties, express or implied, including all implied warranties of
 * merchantability, fitness for a particular purpose and non-infringement of
 * intellectual property rights.  NXP Semiconductors assumes no responsibility
 * or liability for the use of the software, conveys no license or rights under any
 * patent, copyright, mask work right, or any other intellectual property rights in
 * or to any products. NXP Semiconductors reserves the right to make changes
 * in the software without notification. NXP Semiconductors also makes no
 * representation or warranty that such application will be suitable for the
 * specified use without further testing or modification.
 *
 * @par
 * Permission to use, copy, modify, and distribute this software and its
 * documentation is hereby granted, under NXP Semiconductors' and its
 * licensor's relevant copyrights in the software, without fee, provided that it
 * is used in conjunction with NXP Semiconductors microcontrollers.  This
 * copyright, permission, and disclaimer notice must appear in all copies of
 * this code.
*/


#ifndef __LPCUSBlib_COMMON_H__
#define __LPCUSBlib_COMMON_H__

 /* Macros: */
  #define __INCLUDE_FROM_COMMON_H
  
 /* Includes: */
  #include <stdint.h>
  #include <stdbool.h>
  #include <string.h>
  #include <stddef.h>
  
  #if defined(USE_LUFA_CONFIG_HEADER)
   #include "LUFAConfig.h"
  #endif

  #if 1 // TODO add control macros later
   #include "../LPCUSBlibConfig.h"
  #endif

  #include "CompilerSpecific.h"
  #include "Attributes.h"
  
 /* Enable C linkage for C++ Compilers: */
  #if defined(__cplusplus)
   extern "C" {
  #endif

 /* Architecture specific utility includes: */
  #if defined(__DOXYGEN__)

   typedef MACHINE_REG_t uint_reg_t; 
  #else
   typedef uint32_t uint_reg_t;
   #define ARCH_LITTLE_ENDIAN
   #define PROGMEM                  const
   #define pgm_read_byte(x)         (*x)
   #define memcmp_P(...)            memcmp(__VA_ARGS__)
   #define memcpy_P(...)            memcpy(__VA_ARGS__)
   #include "Endianness.h"
  #endif

 /* Public Interface - May be used in end-application: */
  /* Macros: */
   #define MACROS                  do

   #define MACROE                  while (0)

   #if !defined(MAX) || defined(__DOXYGEN__)
    #define MAX(x, y)               (((x) > (y)) ? (x) : (y))
   #endif

   #if !defined(MIN) || defined(__DOXYGEN__)
    #define MIN(x, y)               (((x) < (y)) ? (x) : (y))
   #endif
   
   #if !defined(STRINGIFY) || defined(__DOXYGEN__)

    #define STRINGIFY(x)            #x

    #define STRINGIFY_EXPANDED(x)   STRINGIFY(x)
   #endif

  /* Inline Functions: */
   static inline uint8_t BitReverse(uint8_t Byte) ATTR_WARN_UNUSED_RESULT ATTR_CONST;
   static inline uint8_t BitReverse(uint8_t Byte)
   {
    Byte = (((Byte & 0xF0) >> 4) | ((Byte & 0x0F) << 4));
    Byte = (((Byte & 0xCC) >> 2) | ((Byte & 0x33) << 2));
    Byte = (((Byte & 0xAA) >> 1) | ((Byte & 0x55) << 1));

    return Byte;
   }

PRAGMA_ALWAYS_INLINE
            static inline void Delay_MS(uint16_t Milliseconds) ATTR_ALWAYS_INLINE;
   static inline void Delay_MS(uint16_t Milliseconds)
   {
    while (Milliseconds--)
    {
     volatile  uint32_t  i;

     for (i = 0; i < (4 * 1000); i++) {    /* This logic was tested. It gives app. 1 micro sec delay        */
      ;
     }
    }
   }

PRAGMA_ALWAYS_INLINE
   static inline uint_reg_t GetGlobalInterruptMask(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
   static inline uint_reg_t GetGlobalInterruptMask(void)
   {
    GCC_MEMORY_BARRIER();
    // TODO #warning GetGlobalInterruptMask() is not implemented under ARCH_LPC.
    return 0;
    //GCC_MEMORY_BARRIER();
   }

PRAGMA_ALWAYS_INLINE
   static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState) ATTR_ALWAYS_INLINE;
   static inline void SetGlobalInterruptMask(const uint_reg_t GlobalIntState)
   {
    GCC_MEMORY_BARRIER();
    // TODO #warning SetGlobalInterruptMask() is not implemented under ARCH_LPC.   
    GCC_MEMORY_BARRIER();
   }
  
PRAGMA_ALWAYS_INLINE
   static inline void GlobalInterruptEnable(void) ATTR_ALWAYS_INLINE;
   static inline void GlobalInterruptEnable(void)
   {
    GCC_MEMORY_BARRIER();
    // TODO #warning GlobalInterruptEnable() is not implemented under ARCH_LPC.
    GCC_MEMORY_BARRIER();
   }  

PRAGMA_ALWAYS_INLINE
   static inline void GlobalInterruptDisable(void) ATTR_ALWAYS_INLINE;
   static inline void GlobalInterruptDisable(void)
   {
    GCC_MEMORY_BARRIER();
    // TODO #warning GlobalInterruptDisable() is not implemented under ARCH_LPC.
    GCC_MEMORY_BARRIER();
   }

 /* Disable C linkage for C++ Compilers: */
  #if defined(__cplusplus)
   }
  #endif

#endif