Endpoint_LPC17xx.h

Go to the documentation of this file.

/*
 * @brief USB Endpoint definitions for the LPC17xx microcontrollers
 *
 * @note
 * Copyright(C) NXP Semiconductors, 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 __ENDPOINT_LPC17XX_H__
#define __ENDPOINT_LPC17XX_H__

  #include "../EndpointCommon.h"

  #if defined(__cplusplus)
extern "C" {
  #endif

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

 #if !defined(__DOXYGEN__)

   #define ENDPOINT_DETAILS_MAXEP      6       /* Maximum of supported endpoint */
   #define USED_PHYSICAL_ENDPOINTS     (ENDPOINT_DETAILS_MAXEP * 2) /* This macro effect memory size of the DCD */
   #define ENDPOINT_DETAILS_MAXEP0  ENDPOINT_DETAILS_MAXEP
   #define ENDPOINT_DETAILS_MAXEP1  ENDPOINT_DETAILS_MAXEP

extern volatile bool SETUPReceived;
extern DMADescriptor dmaDescriptor[USED_PHYSICAL_ENDPOINTS];

void SIE_WriteCommandData (uint32_t cmd, uint32_t val);

void SIE_WriteCommand (uint32_t cmd);

extern volatile bool isOutReceived;
extern volatile bool isInReady;

void WriteControlEndpoint(uint8_t *pData, uint32_t cnt);

void ReadControlEndpoint(uint8_t *pData);

void DcdDataTransfer(uint8_t PhyEP, uint8_t *pData, uint32_t cnt);

void Endpoint_Streaming(uint8_t corenum, uint8_t *buffer, uint16_t packetsize,
      uint16_t totalpackets, uint16_t dummypackets);

void Endpoint_ClearEndpoints(uint8_t corenum);

bool Endpoint_ConfigureEndpoint_Prv(uint8_t corenum,
         const uint8_t Number,
         const uint8_t UECFG0XData,
         const uint8_t UECFG1XData);

 #endif

/*static inline */ bool Endpoint_ConfigureEndpoint(uint8_t corenum,
               const uint8_t Number,
               const uint8_t Type,
               const uint8_t Direction,
               const uint16_t Size,
               const uint8_t Banks) /*ATTR_ALWAYS_INLINE*/;

static inline uint16_t USB_Device_GetFrameNumber(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;

static inline uint16_t USB_Device_GetFrameNumber(void)
{
 uint32_t val;

 SIE_WriteCommand(CMD_RD_FRAME);
 val = SIE_ReadCommandData(DAT_RD_FRAME);
 val = val | (SIE_ReadCommandData(DAT_RD_FRAME) << 8);

 return val;
}

static inline void USB_Device_SetDeviceAddress(uint8_t corenum, const uint8_t Address) ATTR_ALWAYS_INLINE;

static inline void USB_Device_SetDeviceAddress(uint8_t corenum, const uint8_t Address)
{
 SIE_WriteCommandData(CMD_SET_ADDR, DAT_WR_BYTE(DEV_EN | Address));
 SIE_WriteCommandData(CMD_SET_ADDR, DAT_WR_BYTE(DEV_EN | Address));
}

static inline void Endpoint_ResetEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE;

static inline void Endpoint_ResetEndpoint(const uint8_t EndpointNumber)
{}

static inline void Endpoint_EnableEndpoint(void) ATTR_ALWAYS_INLINE;

static inline void Endpoint_EnableEndpoint(void)
{}

static inline void Endpoint_DisableEndpoint(void) ATTR_ALWAYS_INLINE;

static inline void Endpoint_DisableEndpoint(void)
{}

static inline bool Endpoint_IsEnabled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

static inline bool Endpoint_IsEnabled(void)
{
 return true;
}

static inline uint8_t Endpoint_GetBusyBanks(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;

static inline uint8_t Endpoint_GetBusyBanks(void)
{
 return 0;
}

static inline void Endpoint_AbortPendingIN(void)
{}

static inline bool Endpoint_IsConfigured(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

static inline bool Endpoint_IsConfigured(void)
{
 return true;
}

static inline uint8_t Endpoint_GetEndpointInterrupts(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

static inline uint8_t Endpoint_GetEndpointInterrupts(void)
{
 return 0;
}

static inline bool Endpoint_HasEndpointInterrupted(const uint8_t EndpointNumber) ATTR_WARN_UNUSED_RESULT
ATTR_ALWAYS_INLINE;

static inline bool Endpoint_HasEndpointInterrupted(const uint8_t EndpointNumber)
{
 return (Endpoint_GetEndpointInterrupts() & (1 << EndpointNumber)) ? true : false;
}

static inline uint16_t Endpoint_BytesInEndpoint(uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

static inline uint16_t Endpoint_BytesInEndpoint(uint8_t corenum)
{
 if (endpointselected == ENDPOINT_CONTROLEP) {
  return usb_data_buffer_size[corenum];
 }
 else {
  // return (dmaDescriptor[ endpointhandle[endpointselected] ].PresentCount);
  return usb_data_buffer_OUT_size[corenum];
 }
}

static inline bool Endpoint_IsINReady(uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

static inline bool Endpoint_IsINReady(uint8_t corenum)
{
 if (endpointselected[corenum] == ENDPOINT_CONTROLEP) {

  return isInReady;
 }
 else {
  uint8_t SelEP_Data;
  if (dmaDescriptor[endpointhandle(corenum)[endpointselected[corenum]]].Retired == true) {
    SIE_WriteCommand(CMD_SEL_EP(endpointhandle(corenum)[endpointselected[corenum]]) );
    SelEP_Data = SIE_ReadCommandData(DAT_SEL_EP(endpointhandle(corenum)[endpointselected[corenum]]) );
    if ((SelEP_Data & 1) == 0) {
     return true;
    }
  }
  return false;
 }

}

static inline bool Endpoint_IsOUTReceived(uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

static inline bool Endpoint_IsOUTReceived(uint8_t corenum)
{
 if (endpointselected[corenum] == ENDPOINT_CONTROLEP) {

  return isOutReceived;
 }
 else {
  return (dmaDescriptor[endpointhandle(corenum)[endpointselected[corenum]]].Retired &&
    (dmaDescriptor[endpointhandle(corenum)[endpointselected[corenum]]].Status == 2 ||
     dmaDescriptor[endpointhandle(corenum)[endpointselected[corenum]]].Status == 3)
    ) ? true : false;
 }
}

static inline bool Endpoint_IsSETUPReceived(uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

static inline bool Endpoint_IsSETUPReceived(uint8_t corenum)
{
 return SETUPReceived;
}

static inline void Endpoint_ClearSETUP(uint8_t corenum) ATTR_ALWAYS_INLINE;

static inline void Endpoint_ClearSETUP(uint8_t corenum)
{
 SETUPReceived = FALSE;
 usb_data_buffer_index[corenum] = 0;
 usb_data_buffer_size[corenum] = 0;
 SIE_WriteCommand(CMD_SEL_EP(ENDPOINT_CONTROLEP));
 SIE_WriteCommand(CMD_CLR_BUF);
}

static inline void Endpoint_ClearIN(uint8_t corenum) ATTR_ALWAYS_INLINE;

static inline void Endpoint_ClearIN(uint8_t corenum)
{
 uint8_t PhyEP = (endpointselected[corenum] == ENDPOINT_CONTROLEP ? 1 : endpointhandle(corenum)[endpointselected[corenum]]);

 if (endpointselected[corenum] == ENDPOINT_CONTROLEP) {
  WriteControlEndpoint(usb_data_buffer[corenum], usb_data_buffer_index[corenum]);
  usb_data_buffer_index[corenum] = 0;
  usb_data_buffer_size[corenum] = 0;
 }
 else {
  DcdDataTransfer(PhyEP, usb_data_buffer_IN[corenum], usb_data_buffer_IN_index[corenum]);
  LPC_USB->DMARSet = _BIT(PhyEP);
  usb_data_buffer_IN_index[corenum] = 0;
 }
}

static inline void Endpoint_ClearOUT(uint8_t corenum) ATTR_ALWAYS_INLINE;

static inline void Endpoint_ClearOUT(uint8_t corenum)
{
 usb_data_buffer_index[corenum] = 0;
 if (endpointselected[corenum] == ENDPOINT_CONTROLEP) {    /* Control only */
  SIE_WriteCommand(CMD_SEL_EP(ENDPOINT_CONTROLEP));
  SIE_WriteCommand(CMD_CLR_BUF);
  isOutReceived = false;
 }
 else {
  usb_data_buffer_OUT_index[corenum] = 0;
  usb_data_buffer_OUT_size[corenum] = 0;
  dmaDescriptor[endpointhandle(corenum)[endpointselected[corenum]]].Status = 0;
  LPC_USB->DMAIntEn |= (1 << 1);
 }
}

// static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE;
void Endpoint_StallTransaction(uint8_t corenum);

static inline void Endpoint_ClearStall(uint8_t corenum) ATTR_ALWAYS_INLINE;

static inline void Endpoint_ClearStall(uint8_t corenum)
{
 uint8_t PhysicalEp = endpointhandle(corenum)[endpointselected[corenum]] + (endpointselected[corenum] == ENDPOINT_CONTROLEP ? 1 : 0);

 HAL_DisableUSBInterrupt(corenum);
 SIE_WriteCommandData(CMD_SET_EP_STAT(PhysicalEp), DAT_WR_BYTE(0));
 HAL_EnableUSBInterrupt(corenum);
}

static inline bool Endpoint_IsStalled(uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

static inline bool Endpoint_IsStalled(uint8_t corenum)
{
 bool isStalled;

 HAL_DisableUSBInterrupt(corenum);
 SIE_WriteCommand(CMD_SEL_EP(endpointhandle(corenum)[endpointselected[corenum]]) );
 isStalled = SIE_ReadCommandData(DAT_SEL_EP(endpointhandle(corenum)[endpointselected[corenum]]) ) & EP_SEL_ST ? true : false;
 HAL_EnableUSBInterrupt(corenum);

 return isStalled;     /* Device Status */
}

static inline void Endpoint_ResetDataToggle(uint8_t corenum) ATTR_ALWAYS_INLINE;

static inline void Endpoint_ResetDataToggle(uint8_t corenum)
{}

   #if (!defined(FIXED_CONTROL_ENDPOINT_SIZE) || defined(__DOXYGEN__))
extern uint8_t USB_Device_ControlEndpointSize;
   #else
    #define USB_Device_ControlEndpointSize FIXED_CONTROL_ENDPOINT_SIZE
   #endif

void Endpoint_ClearStatusStage(uint8_t corenum);

uint8_t Endpoint_WaitUntilReady(void);

  #if defined(__cplusplus)
}
  #endif

#endif