Pipe.h

Go to the documentation of this file.

/*
 * @brief Common USB Pipe 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 __PIPE_H__
#define __PIPE_H__

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

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

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

 /* Public Interface - May be used in end-application: */
  /* Macros: */
   #define PIPE_CONTROLPIPE                0

   #define PIPE_PIPENUM_MASK               0x0F

   #define PIPE_EPNUM_MASK                 0x0F

   #define PIPE_EPDIR_MASK                 0x80

  #include "USBTask.h"
  #include "HCD/HCD.h"
  #include "USBMemory.h" // FIXME move later
  #include <stdbool.h>
  
  /* Macros: */
  // @{
     #define PIPE_ERRORFLAG_OVERFLOW         (1 << 6)

     #define PIPE_ERRORFLAG_UNDERFLOW        (1 << 5)

     #define PIPE_ERRORFLAG_CRC16            (1 << 4)

     #define PIPE_ERRORFLAG_TIMEOUT          (1 << 3)

     #define PIPE_ERRORFLAG_PID              (1 << 2)

     #define PIPE_ERRORFLAG_DATAPID          (1 << 1)

     #define PIPE_ERRORFLAG_DATATGL          (1 << 0)


     #define PIPE_TOKEN_SETUP                (0)

     #define PIPE_TOKEN_IN                   (1)

     #define PIPE_TOKEN_OUT                  (2)

     
     #define PIPE_BANK_SINGLE                (0 << 1)

     #define PIPE_BANK_DOUBLE                (1 << 1)


     #define PIPE_CONTROLPIPE_DEFAULT_SIZE   8

     #define PIPE_TOTAL_PIPES                HCD_MAX_ENDPOINT

     #define PIPE_MAX_SIZE                   512

  /* Enums: */
  enum Pipe_WaitUntilReady_ErrorCodes_t {
   PIPE_READYWAIT_NoError                 = 0,    
   PIPE_READYWAIT_PipeStalled             = 1,    
   PIPE_READYWAIT_DeviceDisconnected      = 2,    
   PIPE_READYWAIT_Timeout                 = 3,    
  };

  typedef struct {
   uint32_t PipeHandle;     
   uint8_t *Buffer;      
   uint16_t BufferSize;     
   uint16_t StartIdx;      
   uint16_t ByteTransfered;    
   uint8_t  EndponitAddress;    
  } USB_Pipe_Data_t;

  extern uint8_t hostselected;

  extern HCD_USB_SPEED hostportspeed[];

  extern uint8_t pipeselected[MAX_USB_CORE];

  extern USB_Pipe_Data_t PipeInfo[MAX_USB_CORE][PIPE_TOTAL_PIPES];

  /* Inline Functions: */
  static inline uint16_t Pipe_BytesInPipe(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline uint16_t Pipe_BytesInPipe(const uint8_t corenum)
  {
   return PipeInfo[corenum][pipeselected[corenum]].ByteTransfered - PipeInfo[corenum][pipeselected[corenum]].StartIdx;
  }

  static inline uint8_t Pipe_GetCurrentPipe(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline uint8_t Pipe_GetCurrentPipe(const uint8_t corenum)
  {
   return pipeselected[corenum];
  }

  static inline void Pipe_SelectPipe(const uint8_t corenum, const uint8_t PipeNumber) ATTR_ALWAYS_INLINE;

  static inline void Pipe_SelectPipe(const uint8_t corenum, const uint8_t PipeNumber)
  {
   pipeselected[corenum] = PipeNumber;
  }

  static inline void Pipe_ResetPipe(const uint8_t corenum, const uint8_t PipeNumber) ATTR_ALWAYS_INLINE;

  static inline void Pipe_ResetPipe(const uint8_t corenum, const uint8_t PipeNumber)
  {
   PipeInfo[corenum][pipeselected[corenum]].StartIdx = PipeInfo[corenum][pipeselected[corenum]].ByteTransfered = 0;
  }

  static inline void Pipe_EnablePipe(void) ATTR_ALWAYS_INLINE;

  static inline void Pipe_EnablePipe(void)
  {
   // TODO implement later
  }

  static inline void Pipe_DisablePipe(void) ATTR_ALWAYS_INLINE;

  static inline void Pipe_DisablePipe(void)
  {
   // TODO implement later
  }

  static inline bool Pipe_IsEnabled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline bool Pipe_IsEnabled(void)
  {
   // TODO implement later
   return true;
  }

  static inline uint8_t Pipe_GetPipeToken(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline uint8_t Pipe_GetPipeToken(const uint8_t corenum)
  {
   return (PipeInfo[corenum][pipeselected[corenum]].EndponitAddress &
     PIPE_EPDIR_MASK) ? PIPE_TOKEN_IN : PIPE_TOKEN_OUT;
  }

  static inline void Pipe_SetPipeToken(const uint8_t Token) ATTR_DEPRECATED ATTR_ALWAYS_INLINE;

  static inline void Pipe_SetPipeToken(const uint8_t Token)
  {}

  static inline void Pipe_SetInfiniteINRequests(void) ATTR_DEPRECATED ATTR_ALWAYS_INLINE;

  static inline void Pipe_SetInfiniteINRequests(void)
  {}

  static inline void Pipe_SetFiniteINRequests(const uint8_t TotalINRequests) ATTR_DEPRECATED ATTR_ALWAYS_INLINE;

  static inline void Pipe_SetFiniteINRequests(const uint8_t TotalINRequests)
  {}

  static inline bool Pipe_IsConfigured(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline bool Pipe_IsConfigured(const uint8_t corenum)
  {
   return PipeInfo[corenum][pipeselected[corenum]].Buffer != NULL;    // TODO implement using status later
  }

  static inline uint8_t Pipe_GetBoundEndpointAddress(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline uint8_t Pipe_GetBoundEndpointAddress(const uint8_t corenum)
  {
   return PipeInfo[corenum][pipeselected[corenum]].EndponitAddress;
  }

  static inline void Pipe_SetInterruptPeriod(const uint8_t Milliseconds) ATTR_ALWAYS_INLINE;

  static inline void Pipe_SetInterruptPeriod(const uint8_t Milliseconds)
  {
   // TODO implement later
  }

  static inline uint8_t Pipe_GetPipeInterrupts(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline uint8_t Pipe_GetPipeInterrupts(void)
  {
   return 0;    // TODO implement later
  }

  static inline bool Pipe_HasPipeInterrupted(const uint8_t PipeNumber) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline bool Pipe_HasPipeInterrupted(const uint8_t PipeNumber)
  {
   return false;    // TODO implement later
  }

  static inline void Pipe_Unfreeze(void) ATTR_ALWAYS_INLINE;

  static inline void Pipe_Unfreeze(void)
  {
   // TODO implement later
  }

  static inline void Pipe_Freeze(void) ATTR_ALWAYS_INLINE;

  static inline void Pipe_Freeze(void)
  {
   // TODO implement later
  }

  static inline bool Pipe_IsFrozen(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline bool Pipe_IsFrozen(void)
  {
   return false;    // TODO implement later
  }

  static inline void Pipe_ClearError(void) ATTR_ALWAYS_INLINE;

  static inline void Pipe_ClearError(void)
  {
   // TODO implement later
  }

  static inline bool Pipe_IsError(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline bool Pipe_IsError(void)
  {
   return false;    // TODO implement later
  }

  static inline uint8_t Pipe_GetErrorFlags(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline uint8_t Pipe_GetErrorFlags(void)
  {
   return 0;    // TODO implement later
  }

  static inline uint8_t Pipe_GetBusyBanks(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline uint8_t Pipe_GetBusyBanks(void)
  {
   return 0;    // TODO implement later
  }

  //   static inline bool Pipe_IsINReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
  bool Pipe_IsINReceived(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT;

  static inline bool Pipe_IsOUTReady(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline bool Pipe_IsOUTReady(const uint8_t corenum)
  {
   return (HcdGetPipeStatus(PipeInfo[corenum][pipeselected[corenum]].PipeHandle) == HCD_STATUS_OK)
       && (PipeInfo[corenum][pipeselected[corenum]].ByteTransfered <
        PipeInfo[corenum][pipeselected[corenum]].BufferSize);
  }

  static inline bool Pipe_IsReadWriteAllowed(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline bool Pipe_IsReadWriteAllowed(const uint8_t corenum)
  {
   if (Pipe_GetPipeToken(corenum) == PIPE_TOKEN_IN) {
    return (HCD_STATUS_OK == HcdGetPipeStatus(PipeInfo[corenum][pipeselected[corenum]].PipeHandle)) &&
        Pipe_BytesInPipe(corenum);
   }
   else {
    return Pipe_IsOUTReady(corenum);
   }
  }

  static inline bool Pipe_IsStatusOK(uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
  static inline bool Pipe_IsStatusOK(uint8_t corenum)
  {
   return (HCD_STATUS_OK == HcdGetPipeStatus(PipeInfo[corenum][pipeselected[corenum]].PipeHandle));
  }
     
  static inline bool Pipe_IsSETUPSent(void) ATTR_DEPRECATED ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

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

  static inline void Pipe_ClearSETUP(void) ATTR_DEPRECATED ATTR_ALWAYS_INLINE;

  static inline void Pipe_ClearSETUP(void)
  {}

  static inline void Pipe_ClearIN(const uint8_t corenum) ATTR_ALWAYS_INLINE;

  static inline void Pipe_ClearIN(const uint8_t corenum)
  {
   PipeInfo[corenum][pipeselected[corenum]].StartIdx = PipeInfo[corenum][pipeselected[corenum]].ByteTransfered = 0;
  }

  static inline void Pipe_ClearOUT(const uint8_t corenum) ATTR_ALWAYS_INLINE;

  static inline void Pipe_ClearOUT(const uint8_t corenum)
  {
   HcdDataTransfer(PipeInfo[corenum][pipeselected[corenum]].PipeHandle,
       PipeInfo[corenum][pipeselected[corenum]].Buffer,
       PipeInfo[corenum][pipeselected[corenum]].ByteTransfered,
       NULL /* FIXME &PipeInfo[pipeselected].ByteTransfered*/);
   PipeInfo[corenum][pipeselected[corenum]].StartIdx = PipeInfo[corenum][pipeselected[corenum]].ByteTransfered = 0;
  }

  static inline bool Pipe_IsNAKReceived(void) ATTR_DEPRECATED ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline bool Pipe_IsNAKReceived(void)
  {
   return false;
  }

  static inline void Pipe_ClearNAKReceived(void) ATTR_DEPRECATED ATTR_ALWAYS_INLINE;

  static inline void Pipe_ClearNAKReceived(void)
  {}

  static inline bool Pipe_IsStalled(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline bool Pipe_IsStalled(const uint8_t corenum)
  {
   return HcdGetPipeStatus(PipeInfo[corenum][pipeselected[corenum]].PipeHandle) == HCD_STATUS_TRANSFER_Stall;
  }

  static inline void Pipe_ClearStall(const uint8_t corenum) ATTR_ALWAYS_INLINE;

  static inline void Pipe_ClearStall(const uint8_t corenum)
  {
   HcdClearEndpointHalt(PipeInfo[corenum][pipeselected[corenum]].PipeHandle);
  }

  static inline uint8_t Pipe_Read_8(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline uint8_t Pipe_Read_8(const uint8_t corenum)
  {
   if (PipeInfo[corenum][pipeselected[corenum]].StartIdx < PipeInfo[corenum][pipeselected[corenum]].ByteTransfered ) {
    uint8_t temp =
     PipeInfo[corenum][pipeselected[corenum]].Buffer[PipeInfo[corenum][pipeselected[corenum]].StartIdx];
    PipeInfo[corenum][pipeselected[corenum]].StartIdx++;
    return temp;
   }
   else {
    return 0;
   }
  }

  static inline void Pipe_Write_8(const uint8_t corenum, const uint8_t Data) ATTR_ALWAYS_INLINE;

  static inline void Pipe_Write_8(const uint8_t corenum, const uint8_t Data)
  {
   if (PipeInfo[corenum][pipeselected[corenum]].ByteTransfered <
    PipeInfo[corenum][pipeselected[corenum]].BufferSize) {
    PipeInfo[corenum][pipeselected[corenum]].Buffer[PipeInfo[corenum][pipeselected[corenum]].ByteTransfered] = Data;
    PipeInfo[corenum][pipeselected[corenum]].ByteTransfered++;
   }
  }

  static inline void Pipe_Discard_8(void) ATTR_ALWAYS_INLINE;

  static inline void Pipe_Discard_8(void)
  {}

  static inline uint16_t Pipe_Read_16_LE(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline uint16_t Pipe_Read_16_LE(const uint8_t corenum)
  {
   uint16_t tem = 0;
   uint8_t tem1, tem2;

   tem1 = Pipe_Read_8(corenum);
   tem2 = Pipe_Read_8(corenum);
   tem = (tem2 << 8) | tem1;
   return tem;
  }

  static inline uint16_t Pipe_Read_16_BE(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline uint16_t Pipe_Read_16_BE(const uint8_t corenum)
  {
   uint16_t tem = 0;
   uint8_t tem1, tem2;

   tem1 = Pipe_Read_8(corenum);
   tem2 = Pipe_Read_8(corenum);
   tem = (tem1 << 8) | tem2;
   return tem;
  }

  static inline void Pipe_Write_16_LE(const uint8_t corenum, const uint16_t Data) ATTR_ALWAYS_INLINE;

  static inline void Pipe_Write_16_LE(const uint8_t corenum, const uint16_t Data)
  {
   Pipe_Write_8(corenum, Data & 0xFF);
   Pipe_Write_8(corenum, (Data >> 8) & 0xFF);
  }

  static inline void Pipe_Write_16_BE(const uint8_t corenum, const uint16_t Data) ATTR_ALWAYS_INLINE;

  static inline void Pipe_Write_16_BE(const uint8_t corenum, const uint16_t Data)
  {
   Pipe_Write_8(corenum, (Data >> 8) & 0xFF);
   Pipe_Write_8(corenum, Data & 0xFF);
  }

  static inline void Pipe_Discard_16(void) ATTR_ALWAYS_INLINE;

  static inline void Pipe_Discard_16(void)
  {}

  static inline uint32_t Pipe_Read_32_LE(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline uint32_t Pipe_Read_32_LE(const uint8_t corenum)
  {
   uint32_t tem = 0;
   uint8_t tem1, tem2, tem3, tem4;

   tem1 = Pipe_Read_8(corenum);
   tem2 = Pipe_Read_8(corenum);
   tem3 = Pipe_Read_8(corenum);
   tem4 = Pipe_Read_8(corenum);
   tem = (tem4 << 24) | (tem3 << 16) | (tem2 << 8) | tem1;
   return tem;
  }

  static inline uint32_t Pipe_Read_32_BE(const uint8_t corenum) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;

  static inline uint32_t Pipe_Read_32_BE(const uint8_t corenum)
  {
   uint32_t tem = 0;
   uint8_t tem1, tem2, tem3, tem4;

   tem1 = Pipe_Read_8(corenum);
   tem2 = Pipe_Read_8(corenum);
   tem3 = Pipe_Read_8(corenum);
   tem4 = Pipe_Read_8(corenum);
   tem = (tem1 << 24) | (tem2 << 16) | (tem3 << 8) | tem4;
   return tem;
  }

  static inline void Pipe_Write_32_LE(const uint8_t corenum, const uint32_t Data) ATTR_ALWAYS_INLINE;

  static inline void Pipe_Write_32_LE(const uint8_t corenum, const uint32_t Data)
  {
   Pipe_Write_8(corenum, Data & 0xFF);
   Pipe_Write_8(corenum, (Data >> 8) & 0xFF);
   Pipe_Write_8(corenum, (Data >> 16) & 0xFF);
   Pipe_Write_8(corenum, (Data >> 24) & 0xFF);
  }

  static inline void Pipe_Write_32_BE(const uint8_t corenum, const uint32_t Data) ATTR_ALWAYS_INLINE;

  static inline void Pipe_Write_32_BE(const uint8_t corenum, const uint32_t Data)
  {
   Pipe_Write_8(corenum, (Data >> 24) & 0xFF);
   Pipe_Write_8(corenum, (Data >> 16) & 0xFF);
   Pipe_Write_8(corenum, (Data >> 8) & 0xFF);
   Pipe_Write_8(corenum, Data & 0xFF);
  }

  static inline void Pipe_Discard_32(void) ATTR_ALWAYS_INLINE;

  static inline void Pipe_Discard_32(void)
  {}

  /* External Variables: */
  /* Function Prototypes: */
  bool Pipe_ConfigurePipe(const uint8_t corenum,
        const uint8_t Number,
        const uint8_t Type,
        const uint8_t Token,
        const uint8_t EndpointNumber,
        const uint16_t Size,
        const uint8_t Banks);

  void Pipe_ClosePipe(const uint8_t corenum, uint8_t pipenum);

  uint8_t Pipe_WaitUntilReady(const uint8_t corenum);

  bool Pipe_IsEndpointBound(const uint8_t EndpointAddress) ATTR_WARN_UNUSED_RESULT;

  /* Private Interface - For use in library only: */
   #if !defined(__DOXYGEN__)
  /* Macros: */
     #if !defined(ENDPOINT_CONTROLEP)
      #define ENDPOINT_CONTROLEP          0
     #endif

  /* Inline Functions: */
  static inline uint8_t Pipe_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST
  ATTR_ALWAYS_INLINE;

  static inline uint8_t Pipe_BytesToEPSizeMask(const uint16_t Bytes)
  {
   return 0;    // implement later
  }

  /* Function Prototypes: */
  void Pipe_ClearPipes(void);

   #endif

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

#endif