LUFA/Drivers/USB/LowLevel/Endpoint.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2009.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, and distribute this software
  13   and its documentation for any purpose and without fee is hereby
  14   granted, provided that the above copyright notice appear in all
  15   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 #include "../HighLevel/USBMode.h"
  32
  33 #if defined(USB_CAN_BE_DEVICE)
  34
  35 #define  INCLUDE_FROM_ENDPOINT_C
  36 #include "Endpoint.h"
  37
  38 #if !defined(FIXED_CONTROL_ENDPOINT_SIZE)
  39 uint8_t USB_ControlEndpointSize = ENDPOINT_CONTROLEP_DEFAULT_SIZE;
  40 #endif
  41
  42 uint8_t Endpoint_BytesToEPSizeMaskDynamic(const uint16_t Size)
  43 {
  44         return Endpoint_BytesToEPSizeMask(Size);
  45 }
  46
  47 bool Endpoint_ConfigureEndpoint_Prv(const uint8_t Number, const uint8_t UECFG0XData, const uint8_t UECFG1XData)
  48 {
  49         Endpoint_SelectEndpoint(Number);
  50         Endpoint_EnableEndpoint();
  51
  52         UECFG1X = 0;
  53
  54         UECFG0X = UECFG0XData;
  55         UECFG1X = UECFG1XData;
  56
  57         return Endpoint_IsConfigured();
  58 }
  59
  60 void Endpoint_ClearEndpoints(void)
  61 {
  62         UEINT = 0;
  63
  64         for (uint8_t EPNum = 0; EPNum < ENDPOINT_TOTAL_ENDPOINTS; EPNum++)
  65         {
  66                 Endpoint_SelectEndpoint(EPNum);
  67                 UEIENX = 0;
  68                 UEINTX = 0;
  69                 Endpoint_DeallocateMemory();
  70                 Endpoint_DisableEndpoint();
  71         }
  72 }
  73
  74 #if !defined(CONTROL_ONLY_DEVICE)
  75 uint8_t Endpoint_WaitUntilReady(void)
  76 {
  77         #if (USB_STREAM_TIMEOUT_MS < 0xFF)
  78         uint8_t  TimeoutMSRem = USB_STREAM_TIMEOUT_MS;
  79         #else
  80         uint16_t TimeoutMSRem = USB_STREAM_TIMEOUT_MS;
  81         #endif
  82
  83         for (;;)
  84         {
  85                 if (Endpoint_GetEndpointDirection() == ENDPOINT_DIR_IN)
  86                 {
  87                         if (Endpoint_IsINReady())
  88                           return ENDPOINT_READYWAIT_NoError;
  89                 }
  90                 else
  91                 {
  92                         if (Endpoint_IsOUTReceived())
  93                           return ENDPOINT_READYWAIT_NoError;
  94                 }
  95
  96                 if (!(USB_IsConnected))
  97                   return ENDPOINT_READYWAIT_DeviceDisconnected;
  98                 else if (Endpoint_IsStalled())
  99                   return ENDPOINT_READYWAIT_EndpointStalled;
 100
 101                 if (USB_INT_HasOccurred(USB_INT_SOFI))
 102                 {
 103                         USB_INT_Clear(USB_INT_SOFI);
 104
 105                         if (!(TimeoutMSRem--))
 106                           return ENDPOINT_READYWAIT_Timeout;
 107                 }
 108         }
 109 }
 110
 111 uint8_t Endpoint_Discard_Stream(uint16_t Length
 112 #if !defined(NO_STREAM_CALLBACKS)
 113                                 , StreamCallbackPtr_t Callback
 114 #endif
 115                                                                 )
 116 {
 117         uint8_t  ErrorCode;
 118
 119         if ((ErrorCode = Endpoint_WaitUntilReady()))
 120           return ErrorCode;
 121
 122         #if defined(FAST_STREAM_TRANSFERS)
 123         uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);
 124
 125         if (Length >= 8)
 126         {
 127                 Length -= BytesRemToAlignment;
 128
 129                 switch (BytesRemToAlignment)
 130                 {
 131                         default:
 132                                 do
 133                                 {
 134                                         if (!(Endpoint_IsReadWriteAllowed()))
 135                                         {
 136                                                 Endpoint_ClearOUT();
 137
 138                                                 #if !defined(NO_STREAM_CALLBACKS)
 139                                                 if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
 140                                                   return ENDPOINT_RWSTREAM_CallbackAborted;
 141                                                 #endif
 142
 143                                                 if ((ErrorCode = Endpoint_WaitUntilReady()))
 144                                                   return ErrorCode;
 145                                         }
 146
 147                                         Length -= 8;
 148
 149                                         Endpoint_Discard_Byte();
 150                         case 7: Endpoint_Discard_Byte();
 151                         case 6: Endpoint_Discard_Byte();
 152                         case 5: Endpoint_Discard_Byte();
 153                         case 4: Endpoint_Discard_Byte();
 154                         case 3: Endpoint_Discard_Byte();
 155                         case 2: Endpoint_Discard_Byte();
 156                         case 1: Endpoint_Discard_Byte();
 157                                 } while (Length >= 8);
 158                 }
 159         }
 160         #endif
 161
 162         while (Length)
 163         {
 164                 if (!(Endpoint_IsReadWriteAllowed()))
 165                 {
 166                         Endpoint_ClearOUT();
 167
 168                         #if !defined(NO_STREAM_CALLBACKS)
 169                         if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
 170                           return ENDPOINT_RWSTREAM_CallbackAborted;
 171                         #endif
 172
 173                         if ((ErrorCode = Endpoint_WaitUntilReady()))
 174                           return ErrorCode;
 175                 }
 176                 else
 177                 {
 178                         Endpoint_Discard_Byte();
 179                         Length--;
 180                 }
 181         }
 182
 183         return ENDPOINT_RWSTREAM_NoError;
 184 }
 185
 186 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Stream_LE
 187 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearIN()
 188 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 189 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(*(BufferPtr++))
 190 #include "Template/Template_Endpoint_RW.c"
 191
 192 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_PStream_LE
 193 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearIN()
 194 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 195 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(pgm_read_byte(BufferPtr++))
 196 #include "Template/Template_Endpoint_RW.c"
 197
 198 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_EStream_LE
 199 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearIN()
 200 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 201 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(eeprom_read_byte(BufferPtr++))
 202 #include "Template/Template_Endpoint_RW.c"
 203
 204 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Stream_BE
 205 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearIN()
 206 #define  TEMPLATE_BUFFER_OFFSET(Length)            Length - 1
 207 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(*(BufferPtr--))
 208 #include "Template/Template_Endpoint_RW.c"
 209
 210 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_EStream_BE
 211 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearIN()
 212 #define  TEMPLATE_BUFFER_OFFSET(Length)            Length - 1
 213 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(eeprom_read_byte(BufferPtr--))
 214 #include "Template/Template_Endpoint_RW.c"
 215
 216 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_PStream_BE
 217 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearIN()
 218 #define  TEMPLATE_BUFFER_OFFSET(Length)            Length - 1
 219 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(pgm_read_byte(BufferPtr--))
 220 #include "Template/Template_Endpoint_RW.c"
 221
 222 #define  TEMPLATE_FUNC_NAME                        Endpoint_Read_Stream_LE
 223 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearOUT()
 224 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 225 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         *(BufferPtr++) = Endpoint_Read_Byte()
 226 #include "Template/Template_Endpoint_RW.c"
 227
 228 #define  TEMPLATE_FUNC_NAME                        Endpoint_Read_EStream_LE
 229 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearOUT()
 230 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 231 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         eeprom_write_byte(BufferPtr++, Endpoint_Read_Byte())
 232 #include "Template/Template_Endpoint_RW.c"
 233
 234 #define  TEMPLATE_FUNC_NAME                        Endpoint_Read_Stream_BE
 235 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearOUT()
 236 #define  TEMPLATE_BUFFER_OFFSET(Length)            Length - 1
 237 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         *(BufferPtr--) = Endpoint_Read_Byte()
 238 #include "Template/Template_Endpoint_RW.c"
 239
 240 #define  TEMPLATE_FUNC_NAME                        Endpoint_Read_EStream_BE
 241 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearOUT()
 242 #define  TEMPLATE_BUFFER_OFFSET(Length)            Length - 1
 243 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         eeprom_write_byte(BufferPtr--, Endpoint_Read_Byte())
 244 #include "Template/Template_Endpoint_RW.c"
 245
 246 #endif
 247
 248 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Control_Stream_LE
 249 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 250 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(*(BufferPtr++))
 251 #include "Template/Template_Endpoint_Control_W.c"
 252
 253 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Control_PStream_LE
 254 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 255 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(pgm_read_byte(BufferPtr++))
 256 #include "Template/Template_Endpoint_Control_W.c"
 257
 258 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Control_EStream_LE
 259 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 260 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(eeprom_read_byte(BufferPtr++))
 261 #include "Template/Template_Endpoint_Control_W.c"
 262
 263 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Control_Stream_BE
 264 #define  TEMPLATE_BUFFER_OFFSET(Length)            Length - 1
 265 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(*(BufferPtr--))
 266 #include "Template/Template_Endpoint_Control_W.c"
 267
 268 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Control_PStream_BE
 269 #define  TEMPLATE_BUFFER_OFFSET(Length)            Length - 1
 270 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(pgm_read_byte(BufferPtr--))
 271 #include "Template/Template_Endpoint_Control_W.c"
 272
 273 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Control_EStream_BE
 274 #define  TEMPLATE_BUFFER_OFFSET(Length)            Length - 1
 275 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(eeprom_read_byte(BufferPtr--))
 276 #include "Template/Template_Endpoint_Control_W.c"
 277
 278 #define  TEMPLATE_FUNC_NAME                        Endpoint_Read_Control_Stream_LE
 279 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 280 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         *(BufferPtr++) = Endpoint_Read_Byte()
 281 #include "Template/Template_Endpoint_Control_R.c"
 282
 283 #define  TEMPLATE_FUNC_NAME                        Endpoint_Read_Control_EStream_LE
 284 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 285 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         eeprom_write_byte(BufferPtr++, Endpoint_Read_Byte())
 286 #include "Template/Template_Endpoint_Control_R.c"
 287
 288 #define  TEMPLATE_FUNC_NAME                        Endpoint_Read_Control_Stream_BE
 289 #define  TEMPLATE_BUFFER_OFFSET(Length)            Length - 1
 290 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         *(BufferPtr--) = Endpoint_Read_Byte()
 291 #include "Template/Template_Endpoint_Control_R.c"
 292
 293 #define  TEMPLATE_FUNC_NAME                        Endpoint_Read_Control_EStream_BE
 294 #define  TEMPLATE_BUFFER_OFFSET(Length)            Length - 1
 295 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         eeprom_write_byte(BufferPtr--, Endpoint_Read_Byte())
 296 #include "Template/Template_Endpoint_Control_R.c"
 297
 298 #endif