LUFA/Drivers/USB/LowLevel/Pipe.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 #define  __INCLUDE_FROM_USB_DRIVER
  32 #include "../HighLevel/USBMode.h"
  33
  34 #if defined(USB_CAN_BE_HOST)
  35
  36 #define  __INCLUDE_FROM_PIPE_C
  37 #include "Pipe.h"
  38
  39 uint8_t USB_ControlPipeSize = PIPE_CONTROLPIPE_DEFAULT_SIZE;
  40
  41 bool Pipe_ConfigurePipe(const uint8_t Number, const uint8_t Type, const uint8_t Token, const uint8_t EndpointNumber,
  42                                                 const uint16_t Size, const uint8_t Banks)
  43 {
  44         Pipe_SelectPipe(Number);
  45         Pipe_EnablePipe();
  46
  47         UPCFG1X = 0;
  48
  49         UPCFG0X = ((Type << EPTYPE0) | Token | ((EndpointNumber & PIPE_EPNUM_MASK) << PEPNUM0));
  50         UPCFG1X = ((1 << ALLOC) | Banks | Pipe_BytesToEPSizeMask(Size));
  51
  52         Pipe_SetInfiniteINRequests();
  53
  54         return Pipe_IsConfigured();
  55 }
  56
  57 void Pipe_ClearPipes(void)
  58 {
  59         UPINT = 0;
  60
  61         for (uint8_t PNum = 0; PNum < PIPE_TOTAL_PIPES; PNum++)
  62         {
  63                 Pipe_ResetPipe(PNum);
  64                 Pipe_SelectPipe(PNum);
  65                 UPIENX = 0;
  66                 UPINTX = 0;
  67                 Pipe_ClearError();
  68                 Pipe_ClearErrorFlags();
  69                 Pipe_DeallocateMemory();
  70                 Pipe_DisablePipe();
  71         }
  72 }
  73
  74 bool Pipe_IsEndpointBound(const uint8_t EndpointAddress)
  75 {
  76         uint8_t PrevPipeNumber = Pipe_GetCurrentPipe();
  77
  78         for (uint8_t PNum = 0; PNum < PIPE_TOTAL_PIPES; PNum++)
  79         {
  80                 Pipe_SelectPipe(PNum);
  81
  82                 uint8_t PipeToken = Pipe_GetPipeToken();
  83
  84                 if (PipeToken != PIPE_TOKEN_SETUP)
  85                   PipeToken = (PipeToken == ((EndpointAddress & PIPE_EPDIR_MASK) ? PIPE_TOKEN_IN : PIPE_TOKEN_OUT));
  86
  87                 if (Pipe_IsConfigured() && (Pipe_BoundEndpointNumber() == (EndpointAddress & PIPE_EPNUM_MASK)) && PipeToken)
  88                 {
  89                         return true;
  90                 }
  91         }
  92
  93         Pipe_SelectPipe(PrevPipeNumber);
  94         return false;
  95 }
  96
  97 uint8_t Pipe_WaitUntilReady(void)
  98 {
  99         #if (USB_STREAM_TIMEOUT_MS < 0xFF)
 100         uint8_t  TimeoutMSRem = USB_STREAM_TIMEOUT_MS;
 101         #else
 102         uint16_t TimeoutMSRem = USB_STREAM_TIMEOUT_MS;
 103         #endif
 104
 105         for (;;)
 106         {
 107                 if (Pipe_GetPipeToken() == PIPE_TOKEN_IN)
 108                 {
 109                         if (Pipe_IsINReceived())
 110                           return PIPE_READYWAIT_NoError;
 111                 }
 112                 else
 113                 {
 114                         if (Pipe_IsOUTReady())
 115                           return PIPE_READYWAIT_NoError;
 116                 }
 117
 118                 if (Pipe_IsStalled())
 119                   return PIPE_READYWAIT_PipeStalled;
 120                 else if (USB_HostState == HOST_STATE_Unattached)
 121                   return PIPE_READYWAIT_DeviceDisconnected;
 122
 123                 if (USB_INT_HasOccurred(USB_INT_HSOFI))
 124                 {
 125                         USB_INT_Clear(USB_INT_HSOFI);
 126
 127                         if (!(TimeoutMSRem--))
 128                           return PIPE_READYWAIT_Timeout;
 129                 }
 130         }
 131 }
 132
 133 uint8_t Pipe_Discard_Stream(uint16_t Length
 134 #if !defined(NO_STREAM_CALLBACKS)
 135                                  , StreamCallbackPtr_t Callback
 136 #endif
 137                                                                  )
 138 {
 139         uint8_t  ErrorCode;
 140
 141         Pipe_SetPipeToken(PIPE_TOKEN_IN);
 142
 143         if ((ErrorCode = Pipe_WaitUntilReady()))
 144           return ErrorCode;
 145
 146         #if defined(FAST_STREAM_TRANSFERS)
 147         uint8_t BytesRemToAlignment = (Pipe_BytesInPipe() & 0x07);
 148
 149         if (Length >= 8)
 150         {
 151                 Length -= BytesRemToAlignment;
 152
 153                 switch (BytesRemToAlignment)
 154                 {
 155                         default:
 156                                 do
 157                                 {
 158                                         if (!(Pipe_IsReadWriteAllowed()))
 159                                         {
 160                                                 Pipe_ClearIN();
 161
 162                                                 #if !defined(NO_STREAM_CALLBACKS)
 163                                                 if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
 164                                                   return PIPE_RWSTREAM_CallbackAborted;
 165                                                 #endif
 166
 167                                                 if ((ErrorCode = Pipe_WaitUntilReady()))
 168                                                   return ErrorCode;
 169                                         }
 170
 171                                         Length -= 8;
 172
 173                                         Pipe_Discard_Byte();
 174                         case 7: Pipe_Discard_Byte();
 175                         case 6: Pipe_Discard_Byte();
 176                         case 5: Pipe_Discard_Byte();
 177                         case 4: Pipe_Discard_Byte();
 178                         case 3: Pipe_Discard_Byte();
 179                         case 2: Pipe_Discard_Byte();
 180                         case 1: Pipe_Discard_Byte();
 181                                 } while (Length >= 8);
 182                 }
 183         }
 184         #endif
 185
 186         while (Length)
 187         {
 188                 if (!(Pipe_IsReadWriteAllowed()))
 189                 {
 190                         Pipe_ClearIN();
 191
 192                         #if !defined(NO_STREAM_CALLBACKS)
 193                         if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
 194                           return PIPE_RWSTREAM_CallbackAborted;
 195                         #endif
 196
 197                         if ((ErrorCode = Pipe_WaitUntilReady()))
 198                           return ErrorCode;
 199                 }
 200                 else
 201                 {
 202                         Pipe_Discard_Byte();
 203                         Length--;
 204                 }
 205         }
 206
 207         return PIPE_RWSTREAM_NoError;
 208 }
 209
 210 /* The following abuses the C preprocessor in order to copy-past common code with slight alterations,
 211  * so that the code needs to be written once. It is a crude form of templating to reduce code maintenance. */
 212
 213 #define  TEMPLATE_FUNC_NAME                        Pipe_Write_Stream_LE
 214 #define  TEMPLATE_BUFFER_TYPE                      const void*
 215 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_OUT
 216 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearOUT()
 217 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 218 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Pipe_Write_Byte(*((uint8_t*)BufferPtr++))
 219 #include "Template/Template_Pipe_RW.c"
 220
 221 #define  TEMPLATE_FUNC_NAME                        Pipe_Write_PStream_LE
 222 #define  TEMPLATE_BUFFER_TYPE                      const void*
 223 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_OUT
 224 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearOUT()
 225 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 226 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Pipe_Write_Byte(pgm_read_byte((uint8_t*)BufferPtr++))
 227 #include "Template/Template_Pipe_RW.c"
 228
 229 #define  TEMPLATE_FUNC_NAME                        Pipe_Write_EStream_LE
 230 #define  TEMPLATE_BUFFER_TYPE                      const void*
 231 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_OUT
 232 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearOUT()
 233 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 234 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Pipe_Write_Byte(eeprom_read_byte((uint8_t*)BufferPtr++))
 235 #include "Template/Template_Pipe_RW.c"
 236
 237 #define  TEMPLATE_FUNC_NAME                        Pipe_Write_Stream_BE
 238 #define  TEMPLATE_BUFFER_TYPE                      const void*
 239 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_OUT
 240 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearOUT()
 241 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 242 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Pipe_Write_Byte(*((uint8_t*)BufferPtr--))
 243 #include "Template/Template_Pipe_RW.c"
 244
 245 #define  TEMPLATE_FUNC_NAME                        Pipe_Write_PStream_BE
 246 #define  TEMPLATE_BUFFER_TYPE                      const void*
 247 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_OUT
 248 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearOUT()
 249 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 250 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Pipe_Write_Byte(pgm_read_byte((uint8_t*)BufferPtr--))
 251 #include "Template/Template_Pipe_RW.c"
 252
 253 #define  TEMPLATE_FUNC_NAME                        Pipe_Write_EStream_BE
 254 #define  TEMPLATE_BUFFER_TYPE                      const void*
 255 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_OUT
 256 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearOUT()
 257 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 258 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Pipe_Write_Byte(eeprom_read_byte((uint8_t*)BufferPtr--))
 259 #include "Template/Template_Pipe_RW.c"
 260
 261 #define  TEMPLATE_FUNC_NAME                        Pipe_Read_Stream_LE
 262 #define  TEMPLATE_BUFFER_TYPE                      void*
 263 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_IN
 264 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearIN()
 265 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 266 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         *((uint8_t*)BufferPtr++) = Pipe_Read_Byte()
 267 #include "Template/Template_Pipe_RW.c"
 268
 269 #define  TEMPLATE_FUNC_NAME                        Pipe_Read_EStream_LE
 270 #define  TEMPLATE_BUFFER_TYPE                      void*
 271 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_IN
 272 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearIN()
 273 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 274 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         eeprom_write_byte((uint8_t*)BufferPtr++, Pipe_Read_Byte())
 275 #include "Template/Template_Pipe_RW.c"
 276
 277 #define  TEMPLATE_FUNC_NAME                        Pipe_Read_Stream_BE
 278 #define  TEMPLATE_BUFFER_TYPE                      void*
 279 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_IN
 280 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearIN()
 281 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 282 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         *((uint8_t*)BufferPtr--) = Pipe_Read_Byte()
 283 #include "Template/Template_Pipe_RW.c"
 284
 285 #define  TEMPLATE_FUNC_NAME                        Pipe_Read_EStream_BE
 286 #define  TEMPLATE_BUFFER_TYPE                      void*
 287 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_IN
 288 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearIN()
 289 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 290 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         eeprom_write_byte((uint8_t*)BufferPtr--, Pipe_Read_Byte())
 291 #include "Template/Template_Pipe_RW.c"
 292
 293 #endif