LUFA/Drivers/USB/LowLevel/Endpoint.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_DEVICE)
  35
  36 #define  __INCLUDE_FROM_ENDPOINT_C
  37 #include "Endpoint.h"
  38
  39 #if !defined(FIXED_CONTROL_ENDPOINT_SIZE)
  40 uint8_t USB_ControlEndpointSize = ENDPOINT_CONTROLEP_DEFAULT_SIZE;
  41 #endif
  42
  43 uintN_t Endpoint_BytesToEPSizeMaskDynamic(const uint16_t Size)
  44 {
  45         return Endpoint_BytesToEPSizeMask(Size);
  46 }
  47
  48 bool Endpoint_ConfigureEndpoint_Prv(const uintN_t Number, const uintN_t UECFG0XData, const uintN_t UECFG1XData)
  49 {
  50         Endpoint_SelectEndpoint(Number);
  51         Endpoint_EnableEndpoint();
  52
  53         UECFG1X = 0;
  54
  55         UECFG0X = UECFG0XData;
  56         UECFG1X = UECFG1XData;
  57
  58         return Endpoint_IsConfigured();
  59 }
  60
  61 void Endpoint_ClearEndpoints(void)
  62 {
  63         UEINT = 0;
  64
  65         for (uint8_t EPNum = 0; EPNum < ENDPOINT_TOTAL_ENDPOINTS; EPNum++)
  66         {
  67                 Endpoint_SelectEndpoint(EPNum);
  68                 UEIENX = 0;
  69                 UEINTX = 0;
  70                 Endpoint_DeallocateMemory();
  71                 Endpoint_DisableEndpoint();
  72         }
  73 }
  74
  75 void Endpoint_ClearStatusStage(void)
  76 {
  77         if (USB_ControlRequest.bmRequestType & REQDIR_DEVICETOHOST)
  78         {
  79                 while (!(Endpoint_IsOUTReceived()))
  80                 {
  81                         if (USB_DeviceState == DEVICE_STATE_Unattached)
  82                           return;
  83                 }
  84
  85                 Endpoint_ClearOUT();
  86         }
  87         else
  88         {
  89                 while (!(Endpoint_IsINReady()))
  90                 {
  91                         if (USB_DeviceState == DEVICE_STATE_Unattached)
  92                           return;
  93                 }
  94
  95                 Endpoint_ClearIN();
  96         }
  97 }
  98
  99 #if !defined(CONTROL_ONLY_DEVICE)
 100 uint8_t Endpoint_WaitUntilReady(void)
 101 {
 102         #if (USB_STREAM_TIMEOUT_MS < 0xFF)
 103         uint8_t  TimeoutMSRem = USB_STREAM_TIMEOUT_MS;
 104         #else
 105         uint16_t TimeoutMSRem = USB_STREAM_TIMEOUT_MS;
 106         #endif
 107
 108         for (;;)
 109         {
 110                 if (Endpoint_GetEndpointDirection() == ENDPOINT_DIR_IN)
 111                 {
 112                         if (Endpoint_IsINReady())
 113                           return ENDPOINT_READYWAIT_NoError;
 114                 }
 115                 else
 116                 {
 117                         if (Endpoint_IsOUTReceived())
 118                           return ENDPOINT_READYWAIT_NoError;
 119                 }
 120
 121                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 122                   return ENDPOINT_READYWAIT_DeviceDisconnected;
 123                 else if (Endpoint_IsStalled())
 124                   return ENDPOINT_READYWAIT_EndpointStalled;
 125
 126                 if (USB_INT_HasOccurred(USB_INT_SOFI))
 127                 {
 128                         USB_INT_Clear(USB_INT_SOFI);
 129
 130                         if (!(TimeoutMSRem--))
 131                           return ENDPOINT_READYWAIT_Timeout;
 132                 }
 133         }
 134 }
 135
 136 uint8_t Endpoint_Discard_Stream(uint16_t Length
 137 #if !defined(NO_STREAM_CALLBACKS)
 138                                 , StreamCallbackPtr_t Callback
 139 #endif
 140                                                                 )
 141 {
 142         uint8_t  ErrorCode;
 143
 144         if ((ErrorCode = Endpoint_WaitUntilReady()))
 145           return ErrorCode;
 146
 147         #if defined(FAST_STREAM_TRANSFERS)
 148         uint8_t BytesRemToAlignment = (Endpoint_BytesInEndpoint() & 0x07);
 149
 150         if (Length >= 8)
 151         {
 152                 Length -= BytesRemToAlignment;
 153
 154                 switch (BytesRemToAlignment)
 155                 {
 156                         default:
 157                                 do
 158                                 {
 159                                         if (!(Endpoint_IsReadWriteAllowed()))
 160                                         {
 161                                                 Endpoint_ClearOUT();
 162
 163                                                 #if !defined(NO_STREAM_CALLBACKS)
 164                                                 if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
 165                                                   return ENDPOINT_RWSTREAM_CallbackAborted;
 166                                                 #endif
 167
 168                                                 if ((ErrorCode = Endpoint_WaitUntilReady()))
 169                                                   return ErrorCode;
 170                                         }
 171
 172                                         Length -= 8;
 173
 174                                         Endpoint_Discard_Byte();
 175                         case 7: Endpoint_Discard_Byte();
 176                         case 6: Endpoint_Discard_Byte();
 177                         case 5: Endpoint_Discard_Byte();
 178                         case 4: Endpoint_Discard_Byte();
 179                         case 3: Endpoint_Discard_Byte();
 180                         case 2: Endpoint_Discard_Byte();
 181                         case 1: Endpoint_Discard_Byte();
 182                                 } while (Length >= 8);
 183                 }
 184         }
 185         #endif
 186
 187         while (Length)
 188         {
 189                 if (!(Endpoint_IsReadWriteAllowed()))
 190                 {
 191                         Endpoint_ClearOUT();
 192
 193                         #if !defined(NO_STREAM_CALLBACKS)
 194                         if ((Callback != NULL) && (Callback() == STREAMCALLBACK_Abort))
 195                           return ENDPOINT_RWSTREAM_CallbackAborted;
 196                         #endif
 197
 198                         if ((ErrorCode = Endpoint_WaitUntilReady()))
 199                           return ErrorCode;
 200                 }
 201                 else
 202                 {
 203                         Endpoint_Discard_Byte();
 204                         Length--;
 205                 }
 206         }
 207
 208         return ENDPOINT_RWSTREAM_NoError;
 209 }
 210
 211 /* The following abuses the C preprocessor in order to copy-past common code with slight alterations,
 212  * so that the code needs to be written once. It is a crude form of templating to reduce code maintenance. */
 213
 214 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Stream_LE
 215 #define  TEMPLATE_BUFFER_TYPE                      const void*
 216 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearIN()
 217 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 218 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(*((uint8_t*)BufferPtr++))
 219 #include "Template/Template_Endpoint_RW.c"
 220
 221 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_PStream_LE
 222 #define  TEMPLATE_BUFFER_TYPE                      const void*
 223 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearIN()
 224 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 225 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(pgm_read_byte((uint8_t*)BufferPtr++))
 226 #include "Template/Template_Endpoint_RW.c"
 227
 228 #if defined(__AVR__)
 229         #define  TEMPLATE_FUNC_NAME                    Endpoint_Write_EStream_LE
 230         #define  TEMPLATE_BUFFER_TYPE                  const void*
 231         #define  TEMPLATE_CLEAR_ENDPOINT()             Endpoint_ClearIN()
 232         #define  TEMPLATE_BUFFER_OFFSET(Length)        0
 233         #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)     Endpoint_Write_Byte(eeprom_read_byte((uint8_t*)BufferPtr++))
 234         #include "Template/Template_Endpoint_RW.c"
 235 #endif
 236
 237 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Stream_BE
 238 #define  TEMPLATE_BUFFER_TYPE                      const void*
 239 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearIN()
 240 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 241 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(*((uint8_t*)BufferPtr--))
 242 #include "Template/Template_Endpoint_RW.c"
 243
 244 #if defined(__AVR__)
 245         #define  TEMPLATE_FUNC_NAME                    Endpoint_Write_EStream_BE
 246         #define  TEMPLATE_BUFFER_TYPE                  const void*
 247         #define  TEMPLATE_CLEAR_ENDPOINT()             Endpoint_ClearIN()
 248         #define  TEMPLATE_BUFFER_OFFSET(Length)        (Length - 1)
 249         #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)     Endpoint_Write_Byte(eeprom_read_byte((uint8_t*)BufferPtr--))
 250         #include "Template/Template_Endpoint_RW.c"
 251 #endif
 252
 253 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_PStream_BE
 254 #define  TEMPLATE_BUFFER_TYPE                      const void*
 255 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearIN()
 256 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 257 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(pgm_read_byte((uint8_t*)BufferPtr--))
 258 #include "Template/Template_Endpoint_RW.c"
 259
 260 #define  TEMPLATE_FUNC_NAME                        Endpoint_Read_Stream_LE
 261 #define  TEMPLATE_BUFFER_TYPE                      void*
 262 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearOUT()
 263 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 264 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         *((uint8_t*)BufferPtr++) = Endpoint_Read_Byte()
 265 #include "Template/Template_Endpoint_RW.c"
 266
 267 #if defined(__AVR__)
 268         #define  TEMPLATE_FUNC_NAME                    Endpoint_Read_EStream_LE
 269         #define  TEMPLATE_BUFFER_TYPE                  void*
 270         #define  TEMPLATE_CLEAR_ENDPOINT()             Endpoint_ClearOUT()
 271         #define  TEMPLATE_BUFFER_OFFSET(Length)        0
 272         #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)     eeprom_write_byte((uint8_t*)BufferPtr++, Endpoint_Read_Byte())
 273         #include "Template/Template_Endpoint_RW.c"
 274 #endif
 275
 276 #define  TEMPLATE_FUNC_NAME                        Endpoint_Read_Stream_BE
 277 #define  TEMPLATE_BUFFER_TYPE                      void*
 278 #define  TEMPLATE_CLEAR_ENDPOINT()                 Endpoint_ClearOUT()
 279 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 280 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         *((uint8_t*)BufferPtr--) = Endpoint_Read_Byte()
 281 #include "Template/Template_Endpoint_RW.c"
 282
 283 #if defined(__AVR__)
 284         #define  TEMPLATE_FUNC_NAME                    Endpoint_Read_EStream_BE
 285         #define  TEMPLATE_BUFFER_TYPE                  void*
 286         #define  TEMPLATE_CLEAR_ENDPOINT()             Endpoint_ClearOUT()
 287         #define  TEMPLATE_BUFFER_OFFSET(Length)        (Length - 1)
 288         #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)     eeprom_write_byte((uint8_t*)BufferPtr--, Endpoint_Read_Byte())
 289         #include "Template/Template_Endpoint_RW.c"
 290 #endif
 291
 292 #endif
 293
 294 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Control_Stream_LE
 295 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 296 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(*((uint8_t*)BufferPtr++))
 297 #include "Template/Template_Endpoint_Control_W.c"
 298
 299 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Control_PStream_LE
 300 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 301 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(pgm_read_byte((uint8_t*)BufferPtr++))
 302 #include "Template/Template_Endpoint_Control_W.c"
 303
 304 #if defined(__AVR__)
 305         #define  TEMPLATE_FUNC_NAME                    Endpoint_Write_Control_EStream_LE
 306         #define  TEMPLATE_BUFFER_OFFSET(Length)        0
 307         #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)     Endpoint_Write_Byte(eeprom_read_byte((uint8_t*)BufferPtr++))
 308         #include "Template/Template_Endpoint_Control_W.c"
 309 #endif
 310
 311 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Control_Stream_BE
 312 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 313 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(*((uint8_t*)BufferPtr--))
 314 #include "Template/Template_Endpoint_Control_W.c"
 315
 316 #define  TEMPLATE_FUNC_NAME                        Endpoint_Write_Control_PStream_BE
 317 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 318 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         Endpoint_Write_Byte(pgm_read_byte((uint8_t*)BufferPtr--))
 319 #include "Template/Template_Endpoint_Control_W.c"
 320
 321 #if defined(__AVR__)
 322         #define  TEMPLATE_FUNC_NAME                    Endpoint_Write_Control_EStream_BE
 323         #define  TEMPLATE_BUFFER_OFFSET(Length)        (Length - 1)
 324         #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)     Endpoint_Write_Byte(eeprom_read_byte((uint8_t*)BufferPtr--))
 325         #include "Template/Template_Endpoint_Control_W.c"
 326 #endif
 327
 328 #define  TEMPLATE_FUNC_NAME                        Endpoint_Read_Control_Stream_LE
 329 #define  TEMPLATE_BUFFER_OFFSET(Length)            0
 330 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         *((uint8_t*)BufferPtr++) = Endpoint_Read_Byte()
 331 #include "Template/Template_Endpoint_Control_R.c"
 332
 333 #if defined(__AVR__)
 334         #define  TEMPLATE_FUNC_NAME                    Endpoint_Read_Control_EStream_LE
 335         #define  TEMPLATE_BUFFER_OFFSET(Length)        0
 336         #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)     eeprom_write_byte((uint8_t*)BufferPtr++, Endpoint_Read_Byte())
 337         #include "Template/Template_Endpoint_Control_R.c"
 338 #endif
 339
 340 #define  TEMPLATE_FUNC_NAME                        Endpoint_Read_Control_Stream_BE
 341 #define  TEMPLATE_BUFFER_OFFSET(Length)            (Length - 1)
 342 #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)         *((uint8_t*)BufferPtr--) = Endpoint_Read_Byte()
 343 #include "Template/Template_Endpoint_Control_R.c"
 344
 345 #if defined(__AVR__)
 346         #define  TEMPLATE_FUNC_NAME                    Endpoint_Read_Control_EStream_BE
 347         #define  TEMPLATE_BUFFER_OFFSET(Length)        (Length - 1)
 348         #define  TEMPLATE_TRANSFER_BYTE(BufferPtr)     eeprom_write_byte((uint8_t*)BufferPtr--, Endpoint_Read_Byte())
 349         #include "Template/Template_Endpoint_Control_R.c"
 350 #endif
 351
 352 #endif