Statistics
| Branch: | Tag: | Revision:

root / LUFA / Drivers / USB / Core / XMEGA / Endpoint_XMEGA.h @ 978b99e5

History | View | Annotate | Download (31.2 KB)

1
/*
2
             LUFA Library
3
     Copyright (C) Dean Camera, 2011.
4

5
  dean [at] fourwalledcubicle [dot] com
6
           www.lufa-lib.org
7
*/
8

    
9
/*
10
  Copyright 2011  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
/** \file
32
 *  \brief USB Endpoint definitions for the AVR XMEGA microcontrollers.
33
 *  \copydetails Group_EndpointManagement_XMEGA
34
 *
35
 *  \note This file should not be included directly. It is automatically included as needed by the USB driver
36
 *        dispatch header located in LUFA/Drivers/USB/USB.h.
37
 */
38

    
39
/** \ingroup Group_EndpointRW
40
 *  \defgroup Group_EndpointRW_XMEGA Endpoint Data Reading and Writing (XMEGA)
41
 *  \brief Endpoint data read/write definitions for the Atmel AVR XMEGA architecture.
42
 *
43
 *  Functions, macros, variables, enums and types related to data reading and writing from and to endpoints.
44
 */
45

    
46
/** \ingroup Group_EndpointPrimitiveRW
47
 *  \defgroup Group_EndpointPrimitiveRW_XMEGA Read/Write of Primitive Data Types (XMEGA)
48
 *  \brief Endpoint primitive read/write definitions for the Atmel AVR XMEGA architecture.
49
 *
50
 *  Functions, macros, variables, enums and types related to data reading and writing of primitive data types
51
 *  from and to endpoints.
52
 */
53

    
54
/** \ingroup Group_EndpointPacketManagement
55
 *  \defgroup Group_EndpointPacketManagement_XMEGA Endpoint Packet Management (XMEGA)
56
 *  \brief Endpoint packet management definitions for the Atmel AVR XMEGA architecture.
57
 *
58
 *  Functions, macros, variables, enums and types related to packet management of endpoints.
59
 */
60

    
61
/** \ingroup Group_EndpointManagement
62
 *  \defgroup Group_EndpointManagement_XMEGA Endpoint Management (XMEGA)
63
 *  \brief Endpoint management definitions for the Atmel AVR XMEGA architecture.
64
 *
65
 *  Functions, macros and enums related to endpoint management when in USB Device mode. This
66
 *  module contains the endpoint management macros, as well as endpoint interrupt and data
67
 *  send/receive functions for various data types.
68
 *
69
 *  @{
70
 */
71

    
72
#ifndef __ENDPOINT_XMEGA_H__
73
#define __ENDPOINT_XMEGA_H__
74

    
75
        /* Includes: */
76
                #include "../../../../Common/Common.h"
77
                #include "../USBTask.h"
78
                #include "../USBInterrupt.h"
79
                #include "../USBController.h"
80

    
81
        /* Enable C linkage for C++ Compilers: */
82
                #if defined(__cplusplus)
83
                        extern "C" {
84
                #endif
85

    
86
        /* Preprocessor Checks: */
87
                #if !defined(__INCLUDE_FROM_USB_DRIVER)
88
                        #error Do not include this file directly. Include LUFA/Drivers/USB/USB.h instead.
89
                #endif
90

    
91
        /* Private Interface - For use in library only: */
92
        #if !defined(__DOXYGEN__)
93
                /* Macros: */
94
                        #define _ENDPOINT_GET_MAXSIZE(EPIndex)         1023
95
                        #define _ENDPOINT_GET_BANKS(EPIndex)           2
96

    
97
                        #define ENDPOINT_DETAILS_MAXEP                 16
98

    
99
                /* External Variables: */
100
                        extern volatile uint8_t   Endpoint_SelectedEndpoint;
101
                        extern volatile USB_EP_t* Endpoint_SelectedEndpointHandle;
102

    
103
                /* Inline Functions: */
104
                        static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST
105
                                                                                               ATTR_ALWAYS_INLINE;
106
                        static inline uint8_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes)
107
                        {
108
                                uint8_t  MaskVal    = 0;
109
                                uint16_t CheckBytes = 8;
110

    
111
                                while (CheckBytes < Bytes)
112
                                {
113
                                        MaskVal++;
114
                                        CheckBytes <<= 1;
115
                                }
116

    
117
                                return (MaskVal << USB_EP_BUFSIZE_gp);
118
                        }
119

    
120
                /* Function Prototypes: */
121
                        void Endpoint_ClearEndpoints(void);
122
        #endif
123

    
124
        /* Public Interface - May be used in end-application: */
125
                /* Macros: */                        
126
                        /** \name Endpoint Bank Mode Masks */
127
                        //@{
128
                        /** Mask for the bank mode selection for the \ref Endpoint_ConfigureEndpoint() macro. This indicates
129
                         *  that the endpoint should have one single bank, which requires less USB FIFO memory but results
130
                         *  in slower transfers as only one USB device (the AVR or the host) can access the endpoint's
131
                         *  bank at the one time.
132
                         */
133
                        #define ENDPOINT_BANK_SINGLE                    0
134

    
135
                        /** Mask for the bank mode selection for the \ref Endpoint_ConfigureEndpoint() macro. This indicates
136
                         *  that the endpoint should have two banks, which requires more USB FIFO memory but results
137
                         *  in faster transfers as one USB device (the AVR or the host) can access one bank while the other
138
                         *  accesses the second bank.
139
                         */
140
                        #define ENDPOINT_BANK_DOUBLE                    USB_EP_PINGPONG_bm
141
                        //@}
142

    
143
                        #if (!defined(FIXED_CONTROL_ENDPOINT_SIZE) || defined(__DOXYGEN__))
144
                                /** Default size of the default control endpoint's bank, until altered by the control endpoint bank size
145
                                 *  value in the device descriptor. Not available if the \c FIXED_CONTROL_ENDPOINT_SIZE token is defined.
146
                                 */
147
                                #define ENDPOINT_CONTROLEP_DEFAULT_SIZE     8
148
                        #endif
149

    
150
                        /** Retrieves the maximum bank size in bytes of a given endpoint.
151
                         *
152
                         *  \note This macro will only work correctly on endpoint indexes that are compile-time constants
153
                         *        defined by the preprocessor.
154
                         *
155
                         *  \param[in] EPIndex  Endpoint number, a value between 0 and (\ref ENDPOINT_TOTAL_ENDPOINTS - 1)
156
                         */
157
                        #define ENDPOINT_MAX_SIZE(EPIndex)              _ENDPOINT_GET_MAXSIZE(EPIndex)
158

    
159
                        /** Retrieves the total number of banks supported by the given endpoint.
160
                         *
161
                         *  \note This macro will only work correctly on endpoint indexes that are compile-time constants
162
                         *        defined by the preprocessor.
163
                         *
164
                         *  \param[in] EPIndex  Endpoint number, a value between 0 and (\ref ENDPOINT_TOTAL_ENDPOINTS - 1)
165
                         */
166
                        #define ENDPOINT_BANKS_SUPPORTED(EPIndex)       _ENDPOINT_GET_BANKS(EPIndex)
167

    
168
                        #if !defined(CONTROL_ONLY_DEVICE) || defined(__DOXYGEN__)
169
                                /** Total number of endpoints (including the default control endpoint at address 0) which may
170
                                 *  be used in the device. Different USB AVR models support different amounts of endpoints,
171
                                 *  this value reflects the maximum number of endpoints for the currently selected AVR model.
172
                                 */
173
                                #define ENDPOINT_TOTAL_ENDPOINTS            ENDPOINT_DETAILS_MAXEP
174
                        #else
175
                                #define ENDPOINT_TOTAL_ENDPOINTS            1
176
                        #endif
177

    
178
                /* Enums: */
179
                        /** Enum for the possible error return codes of the \ref Endpoint_WaitUntilReady() function.
180
                         *
181
                         *  \ingroup Group_EndpointRW_XMEGA
182
                         */
183
                        enum Endpoint_WaitUntilReady_ErrorCodes_t
184
                        {
185
                                ENDPOINT_READYWAIT_NoError                 = 0, /**< Endpoint is ready for next packet, no error. */
186
                                ENDPOINT_READYWAIT_EndpointStalled         = 1, /**< The endpoint was stalled during the stream
187
                                                                                 *   transfer by the host or device.
188
                                                                                 */
189
                                ENDPOINT_READYWAIT_DeviceDisconnected      = 2,        /**< Device was disconnected from the host while
190
                                                                                 *   waiting for the endpoint to become ready.
191
                                                                                 */
192
                                ENDPOINT_READYWAIT_BusSuspended            = 3, /**< The USB bus has been suspended by the host and
193
                                                                                 *   no USB endpoint traffic can occur until the bus
194
                                                                                 *   has resumed.
195
                                                                                 */
196
                                ENDPOINT_READYWAIT_Timeout                 = 4, /**< The host failed to accept or send the next packet
197
                                                                                 *   within the software timeout period set by the
198
                                                                                 *   \ref USB_STREAM_TIMEOUT_MS macro.
199
                                                                                 */
200
                        };
201

    
202
                /* Inline Functions: */
203
                        /** Selects the given endpoint number. If the address from the device descriptors is used, the
204
                         *  value should be masked with the \ref ENDPOINT_EPNUM_MASK constant to extract only the endpoint
205
                         *  number (and discarding the endpoint direction bit).
206
                         *
207
                         *  Any endpoint operations which do not require the endpoint number to be indicated will operate on
208
                         *  the currently selected endpoint.
209
                         *
210
                         *  \param[in] EndpointNumber Endpoint number to select.
211
                         */
212
                        static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE;
213
                        static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber)
214
                        {
215
                                uint8_t EPTableIndex = ((EndpointNumber & ENDPOINT_EPNUM_MASK) << 1) |
216
                                                        ((EndpointNumber & ENDPOINT_DIR_IN) ? 0x01 : 0);
217

    
218
                                Endpoint_SelectedEndpoint       = EndpointNumber;
219
                                Endpoint_SelectedEndpointHandle = &((USB_EP_t*)&USB_EndpointTable)[EPTableIndex];
220
                        }
221

    
222
                        /** Configures the specified endpoint number with the given endpoint type, direction, bank size
223
                         *  and banking mode. Once configured, the endpoint may be read from or written to, depending
224
                         *  on its direction.
225
                         *
226
                         *  \param[in] Number     Endpoint number to configure. This must be more than 0 and less than
227
                         *                        \ref ENDPOINT_TOTAL_ENDPOINTS.
228
                         *
229
                         *  \param[in] Type       Type of endpoint to configure, a \c EP_TYPE_* mask. Not all endpoint types
230
                         *                        are available on Low Speed USB devices - refer to the USB 2.0 specification.
231
                         *
232
                         *  \param[in] Direction  Endpoint data direction, either \ref ENDPOINT_DIR_OUT or \ref ENDPOINT_DIR_IN.
233
                         *                        All endpoints (except Control type) are unidirectional - data may only be read
234
                         *                        from or written to the endpoint bank based on its direction, not both.
235
                         *
236
                         *  \param[in] Size       Size of the endpoint's bank, where packets are stored before they are transmitted
237
                         *                        to the USB host, or after they have been received from the USB host (depending on
238
                         *                        the endpoint's data direction). The bank size must indicate the maximum packet size
239
                         *                        that the endpoint can handle.
240
                         *
241
                         *  \param[in] Banks      Number of banks to use for the endpoint being configured, an \c ENDPOINT_BANK_* mask.
242
                         *                        More banks uses more USB DPRAM, but offers better performance. Isochronous type
243
                         *                        endpoints <b>must</b> have at least two banks.
244
                         *
245
                         *  \note When the \c ORDERED_EP_CONFIG compile time option is used, Endpoints <b>must</b> be configured in
246
                         *        ascending order, or bank corruption will occur.
247
                         *        \n\n
248
                         *
249
                         *  \note Different endpoints may have different maximum packet sizes based on the endpoint's index - refer to
250
                         *        the chosen microcontroller model's datasheet to determine the maximum bank size for each endpoint.
251
                         *        \n\n
252
                         *
253
                         *  \note The default control endpoint should not be manually configured by the user application, as
254
                         *        it is automatically configured by the library internally.
255
                         *        \n\n
256
                         *
257
                         *  \note This routine will automatically select the specified endpoint upon success. Upon failure, the endpoint
258
                         *        which failed to reconfigure correctly will be selected.
259
                         *
260
                         *  \return Boolean \c true if the configuration succeeded, \c false otherwise.
261
                         */
262
                        static inline bool Endpoint_ConfigureEndpoint(const uint8_t Number,
263
                                                                      const uint8_t Type,
264
                                                                      const uint8_t Direction,
265
                                                                      const uint16_t Size,
266
                                                                      const uint8_t Banks) ATTR_ALWAYS_INLINE;
267
                        static inline bool Endpoint_ConfigureEndpoint(const uint8_t Number,
268
                                                                      const uint8_t Type,
269
                                                                      const uint8_t Direction,
270
                                                                      const uint16_t Size,
271
                                                                      const uint8_t Banks)
272
                        {
273
                                Endpoint_SelectEndpoint(Number | Direction);
274

    
275
                                uint8_t EPTypeMask = 0;
276
                                switch (Type)
277
                                {
278
                                        case EP_TYPE_CONTROL:
279
                                                EPTypeMask = USB_EP_TYPE_CONTROL_gc;
280
                                                break;
281
                                        case EP_TYPE_ISOCHRONOUS:
282
                                                EPTypeMask = USB_EP_TYPE_ISOCHRONOUS_gc;
283
                                                break;
284
                                        default:
285
                                                EPTypeMask = USB_EP_TYPE_BULK_gc;
286
                                                break;
287
                                }
288
        
289
                                Endpoint_SelectedEndpointHandle->CTRL   = 0;
290
                                Endpoint_SelectedEndpointHandle->STATUS = (USB_EP_BUSNACK0_bm | USB_EP_BUSNACK1_bm);
291
                                Endpoint_SelectedEndpointHandle->CTRL   = (EPTypeMask | Banks | Endpoint_BytesToEPSizeMask(Size));
292
                                return true;
293
                        }
294

    
295
                        /** Indicates the number of bytes currently stored in the current endpoint's selected bank.
296
                         *
297
                         *  \note The return width of this function may differ, depending on the maximum endpoint bank size
298
                         *        of the selected AVR model.
299
                         *
300
                         *  \ingroup Group_EndpointRW_XMEGA
301
                         *
302
                         *  \return Total number of bytes in the currently selected Endpoint's FIFO buffer.
303
                         */
304
                        static inline uint16_t Endpoint_BytesInEndpoint(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
305
                        static inline uint16_t Endpoint_BytesInEndpoint(void)
306
                        {
307
                                return (((uint16_t)(Endpoint_SelectedEndpointHandle->CNTH & ~USB_EP_ZLP_bm) << 8) | Endpoint_SelectedEndpointHandle->CNTL);
308
                        }
309

    
310
                        /** Get the endpoint address of the currently selected endpoint. This is typically used to save
311
                         *  the currently selected endpoint number so that it can be restored after another endpoint has
312
                         *  been manipulated.
313
                         *
314
                         *  \return Index of the currently selected endpoint.
315
                         */
316
                        static inline uint8_t Endpoint_GetCurrentEndpoint(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
317
                        static inline uint8_t Endpoint_GetCurrentEndpoint(void)
318
                        {
319
                                return Endpoint_SelectedEndpoint;
320
                        }
321

    
322
                        /** Resets the endpoint bank FIFO. This clears all the endpoint banks and resets the USB controller's
323
                         *  data In and Out pointers to the bank's contents.
324
                         *
325
                         *  \param[in] EndpointNumber Endpoint number whose FIFO buffers are to be reset.
326
                         */
327
                        static inline void Endpoint_ResetEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE;
328
                        static inline void Endpoint_ResetEndpoint(const uint8_t EndpointNumber)
329
                        {
330
                                // TODO
331
                        }
332

    
333
                        /** Determines if the currently selected endpoint is enabled, but not necessarily configured.
334
                         *
335
                         * \return Boolean \c true if the currently selected endpoint is enabled, \c false otherwise.
336
                         */
337
                        static inline bool Endpoint_IsEnabled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
338
                        static inline bool Endpoint_IsEnabled(void)
339
                        {
340
                                return true;
341
                        }
342

    
343
                        /** Aborts all pending IN transactions on the currently selected endpoint, once the bank
344
                         *  has been queued for transmission to the host via \ref Endpoint_ClearIN(). This function
345
                         *  will terminate all queued transactions, resetting the endpoint banks ready for a new
346
                         *  packet.
347
                         *
348
                         *  \ingroup Group_EndpointPacketManagement_XMEGA
349
                         */
350
                        static inline void Endpoint_AbortPendingIN(void)
351
                        {
352
                                // TODO
353
                        }
354

    
355
                        /** Determines if the currently selected endpoint may be read from (if data is waiting in the endpoint
356
                         *  bank and the endpoint is an OUT direction, or if the bank is not yet full if the endpoint is an IN
357
                         *  direction). This function will return false if an error has occurred in the endpoint, if the endpoint
358
                         *  is an OUT direction and no packet (or an empty packet) has been received, or if the endpoint is an IN
359
                         *  direction and the endpoint bank is full.
360
                         *
361
                         *  \ingroup Group_EndpointPacketManagement_XMEGA
362
                         *
363
                         *  \return Boolean \c true if the currently selected endpoint may be read from or written to, depending
364
                         *          on its direction.
365
                         */
366
                        static inline bool Endpoint_IsReadWriteAllowed(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
367
                        static inline bool Endpoint_IsReadWriteAllowed(void)
368
                        {
369
                                return 0; // TODO
370
                        }
371

    
372
                        /** Determines if the currently selected endpoint is configured.
373
                         *
374
                         *  \return Boolean \c true if the currently selected endpoint has been configured, \c false otherwise.
375
                         */
376
                        static inline bool Endpoint_IsConfigured(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
377
                        static inline bool Endpoint_IsConfigured(void)
378
                        {
379
                                return ((Endpoint_SelectedEndpointHandle->CTRL & USB_EP_TYPE_gm) ? true : false);
380
                        }
381

    
382
                        /** Returns a mask indicating which INTERRUPT type endpoints have interrupted - i.e. their
383
                         *  interrupt duration has elapsed. Which endpoints have interrupted can be determined by
384
                         *  masking the return value against <tt>(1 << <i>{Endpoint Number}</i>)</tt>.
385
                         *
386
                         *  \return Mask whose bits indicate which endpoints have interrupted.
387
                         */
388
                        static inline uint8_t Endpoint_GetEndpointInterrupts(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
389
                        static inline uint8_t Endpoint_GetEndpointInterrupts(void)
390
                        {
391
                                return 0; // TODO
392
                        }
393

    
394
                        /** Determines if the specified endpoint number has interrupted (valid only for INTERRUPT type
395
                         *  endpoints).
396
                         *
397
                         *  \param[in] EndpointNumber  Index of the endpoint whose interrupt flag should be tested.
398
                         *
399
                         *  \return Boolean \c true if the specified endpoint has interrupted, \c false otherwise.
400
                         */
401
                        static inline bool Endpoint_HasEndpointInterrupted(const uint8_t EndpointNumber) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
402
                        static inline bool Endpoint_HasEndpointInterrupted(const uint8_t EndpointNumber)
403
                        {
404
                                return 0; // TODO
405
                        }
406

    
407
                        /** Determines if the selected IN endpoint is ready for a new packet to be sent to the host.
408
                         *
409
                         *  \ingroup Group_EndpointPacketManagement_XMEGA
410
                         *
411
                         *  \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
412
                         */
413
                        static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
414
                        static inline bool Endpoint_IsINReady(void)
415
                        {
416
                                return (Endpoint_SelectedEndpointHandle->STATUS & USB_EP_TRNCOMPL0_bm);
417
                        }
418

    
419
                        /** Determines if the selected OUT endpoint has received new packet from the host.
420
                         *
421
                         *  \ingroup Group_EndpointPacketManagement_XMEGA
422
                         *
423
                         *  \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
424
                         */
425
                        static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
426
                        static inline bool Endpoint_IsOUTReceived(void)
427
                        {
428
                                return (Endpoint_SelectedEndpointHandle->STATUS & USB_EP_TRNCOMPL0_bm);
429
                        }
430

    
431
                        /** Determines if the current CONTROL type endpoint has received a SETUP packet.
432
                         *
433
                         *  \ingroup Group_EndpointPacketManagement_XMEGA
434
                         *
435
                         *  \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
436
                         */
437
                        static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
438
                        static inline bool Endpoint_IsSETUPReceived(void)
439
                        {
440
                                return (Endpoint_SelectedEndpointHandle->STATUS & USB_EP_SETUP_bm);
441
                        }
442

    
443
                        /** Clears a received SETUP packet on the currently selected CONTROL type endpoint, freeing up the
444
                         *  endpoint for the next packet.
445
                         *
446
                         *  \ingroup Group_EndpointPacketManagement_XMEGA
447
                         *
448
                         *  \note This is not applicable for non CONTROL type endpoints.
449
                         */
450
                        static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
451
                        static inline void Endpoint_ClearSETUP(void)
452
                        {
453
                                // TODO
454
                        }
455

    
456
                        /** Sends an IN packet to the host on the currently selected endpoint, freeing up the endpoint for the
457
                         *  next packet and switching to the alternative endpoint bank if double banked.
458
                         *
459
                         *  \ingroup Group_EndpointPacketManagement_XMEGA
460
                         */
461
                        static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
462
                        static inline void Endpoint_ClearIN(void)
463
                        {
464
                                // TODO
465
                        }
466

    
467
                        /** Acknowledges an OUT packet to the host on the currently selected endpoint, freeing up the endpoint
468
                         *  for the next packet and switching to the alternative endpoint bank if double banked.
469
                         *
470
                         *  \ingroup Group_EndpointPacketManagement_XMEGA
471
                         */
472
                        static inline void Endpoint_ClearOUT(void) ATTR_ALWAYS_INLINE;
473
                        static inline void Endpoint_ClearOUT(void)
474
                        {
475
                                // TODO
476
                        }
477

    
478
                        /** Stalls the current endpoint, indicating to the host that a logical problem occurred with the
479
                         *  indicated endpoint and that the current transfer sequence should be aborted. This provides a
480
                         *  way for devices to indicate invalid commands to the host so that the current transfer can be
481
                         *  aborted and the host can begin its own recovery sequence.
482
                         *
483
                         *  The currently selected endpoint remains stalled until either the \ref Endpoint_ClearStall() macro
484
                         *  is called, or the host issues a CLEAR FEATURE request to the device for the currently selected
485
                         *  endpoint.
486
                         *
487
                         *  \ingroup Group_EndpointPacketManagement_XMEGA
488
                         */
489
                        static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE;
490
                        static inline void Endpoint_StallTransaction(void)
491
                        {
492
                                Endpoint_SelectedEndpointHandle->CTRL |=  USB_EP_STALL_bm;
493
                        }
494

    
495
                        /** Clears the STALL condition on the currently selected endpoint.
496
                         *
497
                         *  \ingroup Group_EndpointPacketManagement_XMEGA
498
                         */
499
                        static inline void Endpoint_ClearStall(void) ATTR_ALWAYS_INLINE;
500
                        static inline void Endpoint_ClearStall(void)
501
                        {
502
                                Endpoint_SelectedEndpointHandle->CTRL &= ~USB_EP_STALL_bm;
503
                        }
504

    
505
                        /** Determines if the currently selected endpoint is stalled, false otherwise.
506
                         *
507
                         *  \ingroup Group_EndpointPacketManagement_XMEGA
508
                         *
509
                         *  \return Boolean \c true if the currently selected endpoint is stalled, \c false otherwise.
510
                         */
511
                        static inline bool Endpoint_IsStalled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
512
                        static inline bool Endpoint_IsStalled(void)
513
                        {
514
                                return (Endpoint_SelectedEndpointHandle->CTRL & USB_EP_STALL_bm);
515
                        }
516

    
517
                        /** Resets the data toggle of the currently selected endpoint. */
518
                        static inline void Endpoint_ResetDataToggle(void) ATTR_ALWAYS_INLINE;
519
                        static inline void Endpoint_ResetDataToggle(void)
520
                        {
521
                                Endpoint_SelectedEndpointHandle->STATUS &= ~USB_EP_TOGGLE_bm;
522
                        }
523

    
524
                        /** Determines the currently selected endpoint's direction.
525
                         *
526
                         *  \return The currently selected endpoint's direction, as a \c ENDPOINT_DIR_* mask.
527
                         */
528
                        static inline uint8_t Endpoint_GetEndpointDirection(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
529
                        static inline uint8_t Endpoint_GetEndpointDirection(void)
530
                        {
531
                                return 0; // TODO
532
                        }
533

    
534
                        /** Sets the direction of the currently selected endpoint.
535
                         *
536
                         *  \param[in] DirectionMask  New endpoint direction, as a \c ENDPOINT_DIR_* mask.
537
                         */
538
                        static inline void Endpoint_SetEndpointDirection(const uint8_t DirectionMask) ATTR_ALWAYS_INLINE;
539
                        static inline void Endpoint_SetEndpointDirection(const uint8_t DirectionMask)
540
                        {
541
                                // TODO
542
                        }
543

    
544
                        /** Reads one byte from the currently selected endpoint's bank, for OUT direction endpoints.
545
                         *
546
                         *  \ingroup Group_EndpointPrimitiveRW_XMEGA
547
                         *
548
                         *  \return Next byte in the currently selected endpoint's FIFO buffer.
549
                         */
550
                        static inline uint8_t Endpoint_Read_8(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
551
                        static inline uint8_t Endpoint_Read_8(void)
552
                        {
553
                                return 0; // TODO
554
                        }
555

    
556
                        /** Writes one byte to the currently selected endpoint's bank, for IN direction endpoints.
557
                         *
558
                         *  \ingroup Group_EndpointPrimitiveRW_XMEGA
559
                         *
560
                         *  \param[in] Data  Data to write into the the currently selected endpoint's FIFO buffer.
561
                         */
562
                        static inline void Endpoint_Write_8(const uint8_t Data) ATTR_ALWAYS_INLINE;
563
                        static inline void Endpoint_Write_8(const uint8_t Data)
564
                        {
565
                                // TODO
566
                        }
567

    
568
                        /** Discards one byte from the currently selected endpoint's bank, for OUT direction endpoints.
569
                         *
570
                         *  \ingroup Group_EndpointPrimitiveRW_XMEGA
571
                         */
572
                        static inline void Endpoint_Discard_8(void) ATTR_ALWAYS_INLINE;
573
                        static inline void Endpoint_Discard_8(void)
574
                        {
575
                                // TODO
576
                        }
577

    
578
                        /** Reads two bytes from the currently selected endpoint's bank in little endian format, for OUT
579
                         *  direction endpoints.
580
                         *
581
                         *  \ingroup Group_EndpointPrimitiveRW_XMEGA
582
                         *
583
                         *  \return Next two bytes in the currently selected endpoint's FIFO buffer.
584
                         */
585
                        static inline uint16_t Endpoint_Read_16_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
586
                        static inline uint16_t Endpoint_Read_16_LE(void)
587
                        {
588
                                return 0; // TODO
589
                        }
590

    
591
                        /** Reads two bytes from the currently selected endpoint's bank in big endian format, for OUT
592
                         *  direction endpoints.
593
                         *
594
                         *  \ingroup Group_EndpointPrimitiveRW_XMEGA
595
                         *
596
                         *  \return Next two bytes in the currently selected endpoint's FIFO buffer.
597
                         */
598
                        static inline uint16_t Endpoint_Read_16_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
599
                        static inline uint16_t Endpoint_Read_16_BE(void)
600
                        {
601
                                return 0; // TODO
602
                        }
603

    
604
                        /** Writes two bytes to the currently selected endpoint's bank in little endian format, for IN
605
                         *  direction endpoints.
606
                         *
607
                         *  \ingroup Group_EndpointPrimitiveRW_XMEGA
608
                         *
609
                         *  \param[in] Data  Data to write to the currently selected endpoint's FIFO buffer.
610
                         */
611
                        static inline void Endpoint_Write_16_LE(const uint16_t Data) ATTR_ALWAYS_INLINE;
612
                        static inline void Endpoint_Write_16_LE(const uint16_t Data)
613
                        {
614
                                // TODO
615
                        }
616

    
617
                        /** Writes two bytes to the currently selected endpoint's bank in big endian format, for IN
618
                         *  direction endpoints.
619
                         *
620
                         *  \ingroup Group_EndpointPrimitiveRW_XMEGA
621
                         *
622
                         *  \param[in] Data  Data to write to the currently selected endpoint's FIFO buffer.
623
                         */
624
                        static inline void Endpoint_Write_16_BE(const uint16_t Data) ATTR_ALWAYS_INLINE;
625
                        static inline void Endpoint_Write_16_BE(const uint16_t Data)
626
                        {
627
                                // TODO
628
                        }
629

    
630
                        /** Discards two bytes from the currently selected endpoint's bank, for OUT direction endpoints.
631
                         *
632
                         *  \ingroup Group_EndpointPrimitiveRW_XMEGA
633
                         */
634
                        static inline void Endpoint_Discard_16(void) ATTR_ALWAYS_INLINE;
635
                        static inline void Endpoint_Discard_16(void)
636
                        {
637
                                // TODO
638
                        }
639

    
640
                        /** Reads four bytes from the currently selected endpoint's bank in little endian format, for OUT
641
                         *  direction endpoints.
642
                         *
643
                         *  \ingroup Group_EndpointPrimitiveRW_XMEGA
644
                         *
645
                         *  \return Next four bytes in the currently selected endpoint's FIFO buffer.
646
                         */
647
                        static inline uint32_t Endpoint_Read_32_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
648
                        static inline uint32_t Endpoint_Read_32_LE(void)
649
                        {
650
                                return 0; // TODO
651
                        }
652

    
653
                        /** Reads four bytes from the currently selected endpoint's bank in big endian format, for OUT
654
                         *  direction endpoints.
655
                         *
656
                         *  \ingroup Group_EndpointPrimitiveRW_XMEGA
657
                         *
658
                         *  \return Next four bytes in the currently selected endpoint's FIFO buffer.
659
                         */
660
                        static inline uint32_t Endpoint_Read_32_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
661
                        static inline uint32_t Endpoint_Read_32_BE(void)
662
                        {
663
                                return 0; // TODO
664
                        }
665

    
666
                        /** Writes four bytes to the currently selected endpoint's bank in little endian format, for IN
667
                         *  direction endpoints.
668
                         *
669
                         *  \ingroup Group_EndpointPrimitiveRW_XMEGA
670
                         *
671
                         *  \param[in] Data  Data to write to the currently selected endpoint's FIFO buffer.
672
                         */
673
                        static inline void Endpoint_Write_32_LE(const uint32_t Data) ATTR_ALWAYS_INLINE;
674
                        static inline void Endpoint_Write_32_LE(const uint32_t Data)
675
                        {
676
                                // TODO
677
                        }
678

    
679
                        /** Writes four bytes to the currently selected endpoint's bank in big endian format, for IN
680
                         *  direction endpoints.
681
                         *
682
                         *  \ingroup Group_EndpointPrimitiveRW_XMEGA
683
                         *
684
                         *  \param[in] Data  Data to write to the currently selected endpoint's FIFO buffer.
685
                         */
686
                        static inline void Endpoint_Write_32_BE(const uint32_t Data) ATTR_ALWAYS_INLINE;
687
                        static inline void Endpoint_Write_32_BE(const uint32_t Data)
688
                        {
689
                                // TODO
690
                        }
691

    
692
                        /** Discards four bytes from the currently selected endpoint's bank, for OUT direction endpoints.
693
                         *
694
                         *  \ingroup Group_EndpointPrimitiveRW_XMEGA
695
                         */
696
                        static inline void Endpoint_Discard_32(void) ATTR_ALWAYS_INLINE;
697
                        static inline void Endpoint_Discard_32(void)
698
                        {
699
                                // TODO
700
                        }
701

    
702
                /* External Variables: */
703
                        /** Global indicating the maximum packet size of the default control endpoint located at address
704
                         *  0 in the device. This value is set to the value indicated in the device descriptor in the user
705
                         *  project once the USB interface is initialized into device mode.
706
                         *
707
                         *  If space is an issue, it is possible to fix this to a static value by defining the control
708
                         *  endpoint size in the \c FIXED_CONTROL_ENDPOINT_SIZE token passed to the compiler in the makefile
709
                         *  via the -D switch. When a fixed control endpoint size is used, the size is no longer dynamically
710
                         *  read from the descriptors at runtime and instead fixed to the given value. When used, it is
711
                         *  important that the descriptor control endpoint size value matches the size given as the
712
                         *  \c FIXED_CONTROL_ENDPOINT_SIZE token - it is recommended that the \c FIXED_CONTROL_ENDPOINT_SIZE token
713
                         *  be used in the device descriptors to ensure this.
714
                         *
715
                         *  \note This variable should be treated as read-only in the user application, and never manually
716
                         *        changed in value.
717
                         */
718
                        #if (!defined(FIXED_CONTROL_ENDPOINT_SIZE) || defined(__DOXYGEN__))
719
                                extern uint8_t USB_Device_ControlEndpointSize;
720
                        #else
721
                                #define USB_Device_ControlEndpointSize FIXED_CONTROL_ENDPOINT_SIZE
722
                        #endif
723

    
724
                /* Function Prototypes: */
725
                        /** Completes the status stage of a control transfer on a CONTROL type endpoint automatically,
726
                         *  with respect to the data direction. This is a convenience function which can be used to
727
                         *  simplify user control request handling.
728
                         */
729
                        void Endpoint_ClearStatusStage(void);
730

    
731
                        /** Spin-loops until the currently selected non-control endpoint is ready for the next packet of data
732
                         *  to be read or written to it.
733
                         *
734
                         *  \note This routine should not be called on CONTROL type endpoints.
735
                         *
736
                         *  \ingroup Group_EndpointRW_XMEGA
737
                         *
738
                         *  \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum.
739
                         */
740
                        uint8_t Endpoint_WaitUntilReady(void);
741

    
742
        /* Disable C linkage for C++ Compilers: */
743
                #if defined(__cplusplus)
744
                        }
745
                #endif
746

    
747
#endif
748

    
749
/** @} */
750