USBController.h

Go to the documentation of this file.

/*
 * @brief Common USB Controller definitions for all architectures
 *
 * @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 __USBCONTROLLER_H__
#define __USBCONTROLLER_H__

 /* Includes: */
  #include "../../../Common/Common.h"
  #include "USBMode.h"  

 /* Enable C linkage for C++ Compilers: */
  #if defined(__cplusplus)
   extern "C" {
  #endif

 /* Preprocessor Checks and Defines: */
  #if !defined(__INCLUDE_FROM_USB_DRIVER)
   #error Do not include this file directly. Include lpcroot/libraries/LPCUSBlib/Drivers/USB/USB.h instead.
  #endif

 /* Defines: */
  #define ENDPOINT_DIR_MASK                       0x80

  #define ENDPOINT_DIR_OUT                        0x00

  #define ENDPOINT_DIR_IN                         0x80


  #define EP_TYPE_MASK                       0x03

  #define EP_TYPE_CONTROL                    0x00

  #define EP_TYPE_ISOCHRONOUS                0x01

  #define EP_TYPE_BULK                       0x02

  #define EP_TYPE_INTERRUPT                  0x03


  #include "Events.h"
  #include "USBTask.h"
  #include "USBInterrupt.h"
  
  #if defined(USB_CAN_BE_HOST) || defined(__DOXYGEN__)
   #include "Host.h"
   #include "OTG.h"
   #include "Pipe.h"
   #include "HostStandardReq.h"
   #include "PipeStream.h"
  #endif

  #if defined(USB_CAN_BE_DEVICE) || defined(__DOXYGEN__)
   #include "Device.h"
   #include "Endpoint.h"
   #include "DeviceStandardReq.h"
   #include "EndpointStream.h"
  #endif
  
  /* Public Interface - May be used in end-application: */
  /* Macros: */
     #define USB_OPT_REG_DISABLED               (1 << 1)

     #define USB_OPT_REG_ENABLED                (0 << 1)

     #define USB_OPT_MANUAL_PLL                 (1 << 2)

     #define USB_OPT_AUTO_PLL                   (0 << 2)

     
     #if !defined(USB_STREAM_TIMEOUT_MS) || defined(__DOXYGEN__)

      #define USB_STREAM_TIMEOUT_MS       100
     #endif

  /* Inline Functions: */
     #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) || \
   defined(__DOXYGEN__)

  PRAGMA_ALWAYS_INLINE
  static inline bool USB_VBUS_GetStatus(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline bool USB_VBUS_GetStatus(void)
  {
   return (USBSTA & (1 << VBUS)) ? true : false;
  }

     #endif

  PRAGMA_ALWAYS_INLINE
  static inline void USB_Detach(void) ATTR_ALWAYS_INLINE;

  static inline void USB_Detach(void)
  {}

  PRAGMA_ALWAYS_INLINE
  static inline void USB_Attach(void) ATTR_ALWAYS_INLINE;

  static inline void USB_Attach(void)
  {}

  /* Function Prototypes: */
  void USB_Init(uint8_t corenum, uint8_t mode);

  void USB_Disable(uint8_t corenum, uint8_t mode);

  void USB_ResetInterface(uint8_t corenum, uint8_t mode);

  /* Global Variables: */
  extern volatile uint8_t USB_CurrentMode[];
  //    #if (!defined(USB_HOST_ONLY) && !defined(USB_DEVICE_ONLY)) || defined(__DOXYGEN__)
  // extern volatile uint8_t USB_CurrentMode[];
  //    #elif defined(USB_HOST_ONLY)
  //     #define USB_CurrentMode[0] USB_MODE_Host
  //    #elif defined(USB_DEVICE_ONLY)
  //     #define USB_CurrentMode[0] USB_MODE_Device
  //    #endif

     #if !defined(USE_STATIC_OPTIONS) || defined(__DOXYGEN__)

  extern volatile uint8_t USB_Options;
     #elif defined(USE_STATIC_OPTIONS)
      #define USB_Options USE_STATIC_OPTIONS
     #endif

  /* Enums: */
  enum USB_Modes_t {
   USB_MODE_None   = 0,   
   USB_MODE_Device = 1,   
   USB_MODE_Host   = 2,   
   USB_MODE_UID    = 3,   
  };

  /* Private Interface - For use in library only: */
   #if !defined(__DOXYGEN__)
  /* Function Prototypes: */
     #if defined(__INCLUDE_FROM_USB_CONTROLLER_C)
      #if defined(USB_CAN_BE_DEVICE)
  static void USB_Init_Device(uint8_t corenum);

      #endif

      #if defined(USB_CAN_BE_HOST)
  static void USB_Init_Host(uint8_t corenum);

      #endif
     #endif

  /* Inline Functions: */
  PRAGMA_ALWAYS_INLINE
  static inline void USB_PLL_On(void) ATTR_ALWAYS_INLINE;

  static inline void USB_PLL_On(void)
  {}

  PRAGMA_ALWAYS_INLINE
  static inline void USB_PLL_Off(void) ATTR_ALWAYS_INLINE;

  static inline void USB_PLL_Off(void)
  {}

  PRAGMA_ALWAYS_INLINE
  static inline bool USB_PLL_IsReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline bool USB_PLL_IsReady(void)
  {
   return true;   // implement later if needed
  }

  PRAGMA_ALWAYS_INLINE
  static inline void USB_REG_On(void) ATTR_ALWAYS_INLINE;

  static inline void USB_REG_On(void)
  {}

  PRAGMA_ALWAYS_INLINE
  static inline void USB_REG_Off(void) ATTR_ALWAYS_INLINE;

  static inline void USB_REG_Off(void)
  {}

  PRAGMA_ALWAYS_INLINE
  static inline void USB_OTGPAD_On(void) ATTR_ALWAYS_INLINE;

  static inline void USB_OTGPAD_On(void)
  {}

  PRAGMA_ALWAYS_INLINE
  static inline void USB_OTGPAD_Off(void) ATTR_ALWAYS_INLINE;

  static inline void USB_OTGPAD_Off(void)
  {}

  PRAGMA_ALWAYS_INLINE
  static inline void USB_CLK_Freeze(void) ATTR_ALWAYS_INLINE;

  static inline void USB_CLK_Freeze(void)
  {}

  PRAGMA_ALWAYS_INLINE
  static inline void USB_CLK_Unfreeze(void) ATTR_ALWAYS_INLINE;

  static inline void USB_CLK_Unfreeze(void)
  {}

  PRAGMA_ALWAYS_INLINE
  static inline void USB_Controller_Enable(void) ATTR_ALWAYS_INLINE;

  static inline void USB_Controller_Enable(void)
  {}

  PRAGMA_ALWAYS_INLINE
  static inline void USB_Controller_Disable(void) ATTR_ALWAYS_INLINE;

  static inline void USB_Controller_Disable(void)
  {}

  PRAGMA_ALWAYS_INLINE
  static inline void USB_Controller_Reset(void) ATTR_ALWAYS_INLINE;

  static inline void USB_Controller_Reset(void)
  {}

     #if defined(USB_CAN_BE_BOTH)
  PRAGMA_ALWAYS_INLINE
  static inline uint8_t USB_GetUSBModeFromUID(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline uint8_t USB_GetUSBModeFromUID(void)
  {
   // if (USBSTA & (1 << ID))
   //  return USB_MODE_Device;
   // else
   //  return USB_MODE_Host;
   return 0;
  }

     #endif

   #endif


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

#endif