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 #if defined(__AVR__)
 230         #define  TEMPLATE_FUNC_NAME                    Pipe_Write_EStream_LE
 231         #define  TEMPLATE_BUFFER_TYPE                  const void*
 232         #define  TEMPLATE_TOKEN                        PIPE_TOKEN_OUT
 233         #define  TEMPLATE_CLEAR_PIPE()                 Pipe_ClearOUT()
 234         #define  TEMPLATE_BUFFER_OFFSET(Length)        0
 235         #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)     Pipe_Write_Byte(eeprom_read_byte((uint8_t*)BufferPtr++))
 236         #include "Template/Template_Pipe_RW.c"
 237 #endif
 238
 239 #define  TEMPLATE_FUNC_NAME                        Pipe_Write_Stream_BE
 240 #define  TEMPLATE_BUFFER_TYPE                      const void*
 241 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_OUT
 242 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearOUT()
 243 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 244 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Pipe_Write_Byte(*((uint8_t*)BufferPtr--))
 245 #include "Template/Template_Pipe_RW.c"
 246
 247 #define  TEMPLATE_FUNC_NAME                        Pipe_Write_PStream_BE
 248 #define  TEMPLATE_BUFFER_TYPE                      const void*
 249 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_OUT
 250 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearOUT()
 251 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 252 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Pipe_Write_Byte(pgm_read_byte((uint8_t*)BufferPtr--))
 253 #include "Template/Template_Pipe_RW.c"
 254
 255 #if defined(__AVR__)
 256         #define  TEMPLATE_FUNC_NAME                    Pipe_Write_EStream_BE
 257         #define  TEMPLATE_BUFFER_TYPE                  const void*
 258         #define  TEMPLATE_TOKEN                        PIPE_TOKEN_OUT
 259         #define  TEMPLATE_CLEAR_PIPE()                 Pipe_ClearOUT()
 260         #define  TEMPLATE_BUFFER_OFFSET(Length)        (Length - 1)
 261         #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)     Pipe_Write_Byte(eeprom_read_byte((uint8_t*)BufferPtr--))
 262         #include "Template/Template_Pipe_RW.c"
 263 #endif
 264
 265 #define  TEMPLATE_FUNC_NAME                        Pipe_Read_Stream_LE
 266 #define  TEMPLATE_BUFFER_TYPE                      void*
 267 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_IN
 268 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearIN()
 269 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 270 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         *((uint8_t*)BufferPtr++) = Pipe_Read_Byte()
 271 #include "Template/Template_Pipe_RW.c"
 272
 273 #if defined(__AVR__)
 274         #define  TEMPLATE_FUNC_NAME                    Pipe_Read_EStream_LE
 275         #define  TEMPLATE_BUFFER_TYPE                  void*
 276         #define  TEMPLATE_TOKEN                        PIPE_TOKEN_IN
 277         #define  TEMPLATE_CLEAR_PIPE()                 Pipe_ClearIN()
 278         #define  TEMPLATE_BUFFER_OFFSET(Length)        0
 279         #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)     eeprom_write_byte((uint8_t*)BufferPtr++, Pipe_Read_Byte())
 280         #include "Template/Template_Pipe_RW.c"
 281 #endif
 282
 283 #define  TEMPLATE_FUNC_NAME                        Pipe_Read_Stream_BE
 284 #define  TEMPLATE_BUFFER_TYPE                      void*
 285 #define  TEMPLATE_TOKEN                            PIPE_TOKEN_IN
 286 #define  TEMPLATE_CLEAR_PIPE()                     Pipe_ClearIN()
 287 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 288 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         *((uint8_t*)BufferPtr--) = Pipe_Read_Byte()
 289 #include "Template/Template_Pipe_RW.c"
 290
 291 #if defined(__AVR__)
 292         #define  TEMPLATE_FUNC_NAME                    Pipe_Read_EStream_BE
 293         #define  TEMPLATE_BUFFER_TYPE                  void*
 294         #define  TEMPLATE_TOKEN                        PIPE_TOKEN_IN
 295         #define  TEMPLATE_CLEAR_PIPE()                 Pipe_ClearIN()
 296         #define  TEMPLATE_BUFFER_OFFSET(Length)        (Length - 1)
 297         #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)     eeprom_write_byte((uint8_t*)BufferPtr--, Pipe_Read_Byte())
 298         #include "Template/Template_Pipe_RW.c"
 299 #endif
 300
 301 #endif