projects / pub / USBasp.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Conditionally add available address spaces to the address space enum, for multiple...
[pub/USBasp.git] / LUFA / Drivers / USB / Core / UC3 / Endpoint_UC3.h
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 AVR32 UC3 microcontrollers.
33 * \copydetails Group_EndpointManagement_UC3
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_UC3 Endpoint Data Reading and Writing (UC3)
41 * \brief Endpoint data read/write definitions for the Atmel AVR32 UC3 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_UC3 Read/Write of Primitive Data Types (UC3)
48 * \brief Endpoint primative read/write definitions for the Atmel AVR32 UC3 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_UC3 Endpoint Packet Management (UC3)
56 * \brief Endpoint packet management definitions for the Atmel AVR32 UC3 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_UC3 Endpoint Management (UC3)
63 * \brief Endpoint management definitions for the Atmel AVR32 UC3 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_UC3_H__
73 #define __ENDPOINT_UC3_H__
74
75 /* Includes: */
76 #include "../../../../Common/Common.h"
77 #include "../USBTask.h"
78 #include "../USBInterrupt.h"
79
80 /* Enable C linkage for C++ Compilers: */
81 #if defined(__cplusplus)
82 extern "C" {
83 #endif
84
85 /* Preprocessor Checks: */
86 #if !defined(__INCLUDE_FROM_USB_DRIVER)
87 #error Do not include this file directly. Include LUFA/Drivers/USB/USB.h instead.
88 #endif
89
90 /* Private Interface - For use in library only: */
91 #if !defined(__DOXYGEN__)
92 /* Macros: */
93 #define _ENDPOINT_GET_MAXSIZE(EPIndex) _ENDPOINT_GET_MAXSIZE2(ENDPOINT_DETAILS_EP ## EPIndex)
94 #define _ENDPOINT_GET_MAXSIZE2(EPDetails) _ENDPOINT_GET_MAXSIZE3(EPDetails)
95 #define _ENDPOINT_GET_MAXSIZE3(MaxSize, Banks) (MaxSize)
96
97 #define _ENDPOINT_GET_BANKS(EPIndex) _ENDPOINT_GET_BANKS2(ENDPOINT_DETAILS_EP ## EPIndex)
98 #define _ENDPOINT_GET_BANKS2(EPDetails) _ENDPOINT_GET_BANKS3(EPDetails)
99 #define _ENDPOINT_GET_BANKS3(MaxSize, Banks) (Banks)
100
101 #if defined(USB_SERIES_UC3A0_AVR) || defined(USB_SERIES_UC3A1_AVR)
102 #define ENDPOINT_DETAILS_MAXEP 7
103
104 #define ENDPOINT_DETAILS_EP0 64, 1
105 #define ENDPOINT_DETAILS_EP1 256, 2
106 #define ENDPOINT_DETAILS_EP2 256, 2
107 #define ENDPOINT_DETAILS_EP3 64, 2
108 #define ENDPOINT_DETAILS_EP4 64, 2
109 #define ENDPOINT_DETAILS_EP5 256, 2
110 #define ENDPOINT_DETAILS_EP6 256, 2
111 #elif defined(USB_SERIES_UC3A3_AVR) || defined(USB_SERIES_UC3A4_AVR)
112 #define ENDPOINT_DETAILS_MAXEP 8
113
114 #define ENDPOINT_DETAILS_EP0 64, 1
115 #define ENDPOINT_DETAILS_EP1 512, 2
116 #define ENDPOINT_DETAILS_EP2 512, 2
117 #define ENDPOINT_DETAILS_EP3 512, 2
118 #define ENDPOINT_DETAILS_EP4 512, 2
119 #define ENDPOINT_DETAILS_EP5 512, 2
120 #define ENDPOINT_DETAILS_EP6 512, 2
121 #elif defined(USB_SERIES_UC3B0_AVR) || defined(USB_SERIES_UC3B1_AVR)
122 #define ENDPOINT_DETAILS_MAXEP 7
123
124 #define ENDPOINT_DETAILS_EP0 64, 1
125 #define ENDPOINT_DETAILS_EP1 64, 2
126 #define ENDPOINT_DETAILS_EP2 64, 2
127 #define ENDPOINT_DETAILS_EP3 64, 2
128 #define ENDPOINT_DETAILS_EP4 64, 2
129 #define ENDPOINT_DETAILS_EP5 256, 2
130 #define ENDPOINT_DETAILS_EP6 256, 2
131 #endif
132
133 /* Inline Functions: */
134 static inline uint32_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes) ATTR_WARN_UNUSED_RESULT ATTR_CONST
135 ATTR_ALWAYS_INLINE;
136 static inline uint32_t Endpoint_BytesToEPSizeMask(const uint16_t Bytes)
137 {
138 uint8_t MaskVal = 0;
139 uint16_t CheckBytes = 8;
140
141 while (CheckBytes < Bytes)
142 {
143 MaskVal++;
144 CheckBytes <<= 1;
145 }
146
147 return (MaskVal << AVR32_USBB_EPSIZE_OFFSET);
148 }
149
150 /* Function Prototypes: */
151 void Endpoint_ClearEndpoints(void);
152 bool Endpoint_ConfigureEndpoint_Prv(const uint8_t Number,
153 const uint32_t UECFGXData);
154
155 /* External Variables: */
156 extern volatile uint8_t USB_SelectedEndpoint;
157 extern volatile uint8_t* USB_EndpointFIFOPos[];
158 #endif
159
160 /* Public Interface - May be used in end-application: */
161 /* Macros: */
162 /** \name Endpoint Direction Masks */
163 //@{
164 /** Endpoint data direction mask for \ref Endpoint_ConfigureEndpoint(). This indicates that the endpoint
165 * should be initialized in the OUT direction - i.e. data flows from host to device.
166 */
167 #define ENDPOINT_DIR_OUT AVR32_USBB_UECFG0_EPDIR_OUT
168
169 /** Endpoint data direction mask for \ref Endpoint_ConfigureEndpoint(). This indicates that the endpoint
170 * should be initialized in the IN direction - i.e. data flows from device to host.
171 */
172 #define ENDPOINT_DIR_IN AVR32_USBB_UECFG0_EPDIR_IN
173 //@}
174
175 /** \name Endpoint Bank Mode Masks */
176 //@{
177 /** Mask for the bank mode selection for the \ref Endpoint_ConfigureEndpoint() macro. This indicates
178 * that the endpoint should have one single bank, which requires less USB FIFO memory but results
179 * in slower transfers as only one USB device (the AVR or the host) can access the endpoint's
180 * bank at the one time.
181 */
182 #define ENDPOINT_BANK_SINGLE AVR32_USBB_UECFG0_EPBK_SINGLE
183
184 /** Mask for the bank mode selection for the \ref Endpoint_ConfigureEndpoint() macro. This indicates
185 * that the endpoint should have two banks, which requires more USB FIFO memory but results
186 * in faster transfers as one USB device (the AVR or the host) can access one bank while the other
187 * accesses the second bank.
188 */
189 #define ENDPOINT_BANK_DOUBLE AVR32_USBB_UECFG0_EPBK_DOUBLE
190 //@}
191
192 #if (!defined(FIXED_CONTROL_ENDPOINT_SIZE) || defined(__DOXYGEN__))
193 /** Default size of the default control endpoint's bank, until altered by the control endpoint bank size
194 * value in the device descriptor. Not available if the \c FIXED_CONTROL_ENDPOINT_SIZE token is defined.
195 */
196 #define ENDPOINT_CONTROLEP_DEFAULT_SIZE 8
197 #endif
198
199 /** Retrives the maximum bank size in bytes of a given endpoint.
200 *
201 * \note This macro will only work correctly on endpoint indexes that are compile-time constants
202 * defined by the preprocessor.
203 *
204 * \param[in] EPIndex Endpoint number, a value between 0 and (\ref ENDPOINT_TOTAL_ENDPOINTS - 1)
205 */
206 #define ENDPOINT_MAX_SIZE(EPIndex) _ENDPOINT_GET_MAXSIZE(EPIndex)
207
208 /** Retrieves the total number of banks supported by the given endpoint.
209 *
210 * \note This macro will only work correctly on endpoint indexes that are compile-time constants
211 * defined by the preprocessor.
212 *
213 * \param[in] EPIndex Endpoint number, a value between 0 and (\ref ENDPOINT_TOTAL_ENDPOINTS - 1)
214 */
215 #define ENDPOINT_BANKS_SUPPORTED(EPIndex) _ENDPOINT_GET_BANKS(EPIndex)
216
217 #if !defined(CONTROL_ONLY_DEVICE) || defined(__DOXYGEN__)
218 /** Total number of endpoints (including the default control endpoint at address 0) which may
219 * be used in the device. Different AVR models support different amounts of endpoints,
220 * this value reflects the maximum number of endpoints for the currently selected AVR model.
221 */
222 #define ENDPOINT_TOTAL_ENDPOINTS ENDPOINT_DETAILS_MAXEP
223 #else
224 #define ENDPOINT_TOTAL_ENDPOINTS 1
225 #endif
226
227 /* Enums: */
228 /** Enum for the possible error return codes of the \ref Endpoint_WaitUntilReady() function.
229 *
230 * \ingroup Group_EndpointRW_UC3
231 */
232 enum Endpoint_WaitUntilReady_ErrorCodes_t
233 {
234 ENDPOINT_READYWAIT_NoError = 0, /**< Endpoint is ready for next packet, no error. */
235 ENDPOINT_READYWAIT_EndpointStalled = 1, /**< The endpoint was stalled during the stream
236 * transfer by the host or device.
237 */
238 ENDPOINT_READYWAIT_DeviceDisconnected = 2, /**< Device was disconnected from the host while
239 * waiting for the endpoint to become ready.
240 */
241 ENDPOINT_READYWAIT_BusSuspended = 3, /**< The USB bus has been suspended by the host and
242 * no USB endpoint traffic can occur until the bus
243 * has resumed.
244 */
245 ENDPOINT_READYWAIT_Timeout = 4, /**< The host failed to accept or send the next packet
246 * within the software timeout period set by the
247 * \ref USB_STREAM_TIMEOUT_MS macro.
248 */
249 };
250
251 /* Inline Functions: */
252 /** Configures the specified endpoint number with the given endpoint type, direction, bank size
253 * and banking mode. Once configured, the endpoint may be read from or written to, depending
254 * on its direction.
255 *
256 * \param[in] Number Endpoint number to configure. This must be more than 0 and less than
257 * \ref ENDPOINT_TOTAL_ENDPOINTS.
258 *
259 * \param[in] Type Type of endpoint to configure, a \c EP_TYPE_* mask. Not all endpoint types
260 * are available on Low Speed USB devices - refer to the USB 2.0 specification.
261 *
262 * \param[in] Direction Endpoint data direction, either \ref ENDPOINT_DIR_OUT or \ref ENDPOINT_DIR_IN.
263 * All endpoints (except Control type) are unidirectional - data may only be read
264 * from or written to the endpoint bank based on its direction, not both.
265 *
266 * \param[in] Size Size of the endpoint's bank, where packets are stored before they are transmitted
267 * to the USB host, or after they have been received from the USB host (depending on
268 * the endpoint's data direction). The bank size must indicate the maximum packet size
269 * that the endpoint can handle.
270 *
271 * \param[in] Banks Number of banks to use for the endpoint being configured, an \c ENDPOINT_BANK_* mask.
272 * More banks uses more USB DPRAM, but offers better performance. Isochronous type
273 * endpoints <b>must</b> have at least two banks.
274 *
275 * \note When the \c ORDERED_EP_CONFIG compile time option is used, Endpoints <b>must</b> be configured in
276 * ascending order, or bank corruption will occur.
277 * \n\n
278 *
279 * \note Different endpoints may have different maximum packet sizes based on the endpoint's index - refer to
280 * the chosen microcontroller model's datasheet to determine the maximum bank size for each endpoint.
281 * \n\n
282 *
283 * \note The default control endpoint should not be manually configured by the user application, as
284 * it is automatically configured by the library internally.
285 * \n\n
286 *
287 * \note This routine will automatically select the specified endpoint upon success. Upon failure, the endpoint
288 * which failed to reconfigure correctly will be selected.
289 *
290 * \return Boolean \c true if the configuration succeeded, \c false otherwise.
291 */
292 static inline bool Endpoint_ConfigureEndpoint(const uint8_t Number,
293 const uint8_t Type,
294 const uint8_t Direction,
295 const uint16_t Size,
296 const uint8_t Banks) ATTR_ALWAYS_INLINE;
297 static inline bool Endpoint_ConfigureEndpoint(const uint8_t Number,
298 const uint8_t Type,
299 const uint8_t Direction,
300 const uint16_t Size,
301 const uint8_t Banks)
302 {
303 return Endpoint_ConfigureEndpoint_Prv(Number, (AVR32_USBB_ALLOC_MASK |
304 ((uint32_t)Type << AVR32_USBB_EPTYPE_OFFSET) |
305 ((uint32_t)Direction << AVR32_USBB_EPDIR_OFFSET) |
306 ((uint32_t)Banks << AVR32_USBB_EPBK_OFFSET) |
307 Endpoint_BytesToEPSizeMask(Size)));
308 }
309
310 /** Indicates the number of bytes currently stored in the current endpoint's selected bank.
311 *
312 * \note The return width of this function may differ, depending on the maximum endpoint bank size
313 * of the selected AVR model.
314 *
315 * \ingroup Group_EndpointRW_UC3
316 *
317 * \return Total number of bytes in the currently selected Endpoint's FIFO buffer.
318 */
319 static inline uint16_t Endpoint_BytesInEndpoint(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
320 static inline uint16_t Endpoint_BytesInEndpoint(void)
321 {
322 return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].byct;
323 }
324
325 /** Get the endpoint address of the currently selected endpoint. This is typically used to save
326 * the currently selected endpoint number so that it can be restored after another endpoint has
327 * been manipulated.
328 *
329 * \return Index of the currently selected endpoint.
330 */
331 static inline uint8_t Endpoint_GetCurrentEndpoint(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
332 static inline uint8_t Endpoint_GetCurrentEndpoint(void)
333 {
334 return USB_SelectedEndpoint;
335 }
336
337 /** Selects the given endpoint number. If the address from the device descriptors is used, the
338 * value should be masked with the \ref ENDPOINT_EPNUM_MASK constant to extract only the endpoint
339 * number (and discarding the endpoint direction bit).
340 *
341 * Any endpoint operations which do not require the endpoint number to be indicated will operate on
342 * the currently selected endpoint.
343 *
344 * \param[in] EndpointNumber Endpoint number to select.
345 */
346 static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE;
347 static inline void Endpoint_SelectEndpoint(const uint8_t EndpointNumber)
348 {
349 USB_SelectedEndpoint = EndpointNumber;
350 }
351
352 /** Resets the endpoint bank FIFO. This clears all the endpoint banks and resets the USB controller's
353 * data In and Out pointers to the bank's contents.
354 *
355 * \param[in] EndpointNumber Endpoint number whose FIFO buffers are to be reset.
356 */
357 static inline void Endpoint_ResetEndpoint(const uint8_t EndpointNumber) ATTR_ALWAYS_INLINE;
358 static inline void Endpoint_ResetEndpoint(const uint8_t EndpointNumber)
359 {
360 AVR32_USBB.uerst |= (AVR32_USBB_EPRST0_MASK << EndpointNumber);
361 AVR32_USBB.uerst &= ~(AVR32_USBB_EPRST0_MASK << EndpointNumber);
362 USB_EndpointFIFOPos[EndpointNumber] = &AVR32_USBB_SLAVE[EndpointNumber * 0x10000];
363 }
364
365 /** Enables the currently selected endpoint so that data can be sent and received through it to
366 * and from a host.
367 *
368 * \note Endpoints must first be configured properly via \ref Endpoint_ConfigureEndpoint().
369 */
370 static inline void Endpoint_EnableEndpoint(void) ATTR_ALWAYS_INLINE;
371 static inline void Endpoint_EnableEndpoint(void)
372 {
373 AVR32_USBB.uerst |= (AVR32_USBB_EPEN0_MASK << USB_SelectedEndpoint);
374 }
375
376 /** Disables the currently selected endpoint so that data cannot be sent and received through it
377 * to and from a host.
378 */
379 static inline void Endpoint_DisableEndpoint(void) ATTR_ALWAYS_INLINE;
380 static inline void Endpoint_DisableEndpoint(void)
381 {
382 AVR32_USBB.uerst &= ~(AVR32_USBB_EPEN0_MASK << USB_SelectedEndpoint);
383 }
384
385 /** Determines if the currently selected endpoint is enabled, but not necessarily configured.
386 *
387 * \return Boolean \c true if the currently selected endpoint is enabled, \c false otherwise.
388 */
389 static inline bool Endpoint_IsEnabled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
390 static inline bool Endpoint_IsEnabled(void)
391 {
392 return ((AVR32_USBB.uerst & (AVR32_USBB_EPEN0_MASK << USB_SelectedEndpoint)) ? true : false);
393 }
394
395 /** Retrieves the number of busy banks in the currently selected endpoint, which have been queued for
396 * transmission via the \ref Endpoint_ClearIN() command, or are awaiting acknowledgement via the
397 * \ref Endpoint_ClearOUT() command.
398 *
399 * \ingroup Group_EndpointPacketManagement_UC3
400 *
401 * \return Total number of busy banks in the selected endpoint.
402 */
403 static inline uint8_t Endpoint_GetBusyBanks(void)
404 {
405 return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].nbusybk;
406 }
407
408 /** Aborts all pending IN transactions on the currently selected endpoint, once the bank
409 * has been queued for transmission to the host via \ref Endpoint_ClearIN(). This function
410 * will terminate all queued transactions, resetting the endpoint banks ready for a new
411 * packet.
412 *
413 * \ingroup Group_EndpointPacketManagement_UC3
414 */
415 static inline void Endpoint_AbortPendingIN(void)
416 {
417 while (Endpoint_GetBusyBanks() != 0)
418 {
419 (&AVR32_USBB.UECON0SET)[USB_SelectedEndpoint].killbks = true;
420 while ((&AVR32_USBB.UECON0)[USB_SelectedEndpoint].killbk);
421 }
422 }
423
424 /** Determines if the currently selected endpoint may be read from (if data is waiting in the endpoint
425 * bank and the endpoint is an OUT direction, or if the bank is not yet full if the endpoint is an IN
426 * direction). This function will return false if an error has occurred in the endpoint, if the endpoint
427 * is an OUT direction and no packet (or an empty packet) has been received, or if the endpoint is an IN
428 * direction and the endpoint bank is full.
429 *
430 * \ingroup Group_EndpointPacketManagement_UC3
431 *
432 * \return Boolean \c true if the currently selected endpoint may be read from or written to, depending
433 * on its direction.
434 */
435 static inline bool Endpoint_IsReadWriteAllowed(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
436 static inline bool Endpoint_IsReadWriteAllowed(void)
437 {
438 return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].rwall;
439 }
440
441 /** Determines if the currently selected endpoint is configured.
442 *
443 * \return Boolean \c true if the currently selected endpoint has been configured, \c false otherwise.
444 */
445 static inline bool Endpoint_IsConfigured(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
446 static inline bool Endpoint_IsConfigured(void)
447 {
448 return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].cfgok;
449 }
450
451 /** Returns a mask indicating which INTERRUPT type endpoints have interrupted - i.e. their
452 * interrupt duration has elapsed. Which endpoints have interrupted can be determined by
453 * masking the return value against <tt>(1 << <i>{Endpoint Number}</i>)</tt>.
454 *
455 * \return Mask whose bits indicate which endpoints have interrupted.
456 */
457 static inline uint8_t Endpoint_GetEndpointInterrupts(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
458 static inline uint8_t Endpoint_GetEndpointInterrupts(void)
459 {
460 return ((AVR32_USBB.udint & (AVR32_USBB_EP6INT_MASK | AVR32_USBB_EP5INT_MASK |
461 AVR32_USBB_EP4INT_MASK | AVR32_USBB_EP3INT_MASK |
462 AVR32_USBB_EP2INT_MASK | AVR32_USBB_EP1INT_MASK |
463 AVR32_USBB_EP0INT_MASK)) >> AVR32_USBB_EP0INT_OFFSET);
464 }
465
466 /** Determines if the specified endpoint number has interrupted (valid only for INTERRUPT type
467 * endpoints).
468 *
469 * \param[in] EndpointNumber Index of the endpoint whose interrupt flag should be tested.
470 *
471 * \return Boolean \c true if the specified endpoint has interrupted, \c false otherwise.
472 */
473 static inline bool Endpoint_HasEndpointInterrupted(const uint8_t EndpointNumber) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
474 static inline bool Endpoint_HasEndpointInterrupted(const uint8_t EndpointNumber)
475 {
476 return ((Endpoint_GetEndpointInterrupts() & (AVR32_USBB_EP0INT_MASK << EndpointNumber)) ? true : false);
477 }
478
479 /** Determines if the selected IN endpoint is ready for a new packet to be sent to the host.
480 *
481 * \ingroup Group_EndpointPacketManagement_UC3
482 *
483 * \return Boolean \c true if the current endpoint is ready for an IN packet, \c false otherwise.
484 */
485 static inline bool Endpoint_IsINReady(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
486 static inline bool Endpoint_IsINReady(void)
487 {
488 return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].txini;
489 }
490
491 /** Determines if the selected OUT endpoint has received new packet from the host.
492 *
493 * \ingroup Group_EndpointPacketManagement_UC3
494 *
495 * \return Boolean \c true if current endpoint is has received an OUT packet, \c false otherwise.
496 */
497 static inline bool Endpoint_IsOUTReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
498 static inline bool Endpoint_IsOUTReceived(void)
499 {
500 return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].rxouti;
501 }
502
503 /** Determines if the current CONTROL type endpoint has received a SETUP packet.
504 *
505 * \ingroup Group_EndpointPacketManagement_UC3
506 *
507 * \return Boolean \c true if the selected endpoint has received a SETUP packet, \c false otherwise.
508 */
509 static inline bool Endpoint_IsSETUPReceived(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
510 static inline bool Endpoint_IsSETUPReceived(void)
511 {
512 return (&AVR32_USBB.UESTA0)[USB_SelectedEndpoint].rxstpi;
513 }
514
515 /** Clears a received SETUP packet on the currently selected CONTROL type endpoint, freeing up the
516 * endpoint for the next packet.
517 *
518 * \ingroup Group_EndpointPacketManagement_UC3
519 *
520 * \note This is not applicable for non CONTROL type endpoints.
521 */
522 static inline void Endpoint_ClearSETUP(void) ATTR_ALWAYS_INLINE;
523 static inline void Endpoint_ClearSETUP(void)
524 {
525 (&AVR32_USBB.UESTA0CLR)[USB_SelectedEndpoint].rxstpic = true;
526 USB_EndpointFIFOPos[USB_SelectedEndpoint] = &AVR32_USBB_SLAVE[USB_SelectedEndpoint * 0x10000];
527 }
528
529 /** Sends an IN packet to the host on the currently selected endpoint, freeing up the endpoint for the
530 * next packet and switching to the alternative endpoint bank if double banked.
531 *
532 * \ingroup Group_EndpointPacketManagement_UC3
533 */
534 static inline void Endpoint_ClearIN(void) ATTR_ALWAYS_INLINE;
535 static inline void Endpoint_ClearIN(void)
536 {
537 (&AVR32_USBB.UESTA0CLR)[USB_SelectedEndpoint].txinic = true;
538 (&AVR32_USBB.UECON0CLR)[USB_SelectedEndpoint].fifoconc = true;
539 USB_EndpointFIFOPos[USB_SelectedEndpoint] = &AVR32_USBB_SLAVE[USB_SelectedEndpoint * 0x10000];
540 }
541
542 /** Acknowledges an OUT packet to the host on the currently selected endpoint, freeing up the endpoint
543 * for the next packet and switching to the alternative endpoint bank if double banked.
544 *
545 * \ingroup Group_EndpointPacketManagement_UC3
546 */
547 static inline void Endpoint_ClearOUT(void) ATTR_ALWAYS_INLINE;
548 static inline void Endpoint_ClearOUT(void)
549 {
550 (&AVR32_USBB.UESTA0CLR)[USB_SelectedEndpoint].rxoutic = true;
551 (&AVR32_USBB.UECON0CLR)[USB_SelectedEndpoint].fifoconc = true;
552 USB_EndpointFIFOPos[USB_SelectedEndpoint] = &AVR32_USBB_SLAVE[USB_SelectedEndpoint * 0x10000];
553 }
554
555 /** Stalls the current endpoint, indicating to the host that a logical problem occurred with the
556 * indicated endpoint and that the current transfer sequence should be aborted. This provides a
557 * way for devices to indicate invalid commands to the host so that the current transfer can be
558 * aborted and the host can begin its own recovery sequence.
559 *
560 * The currently selected endpoint remains stalled until either the \ref Endpoint_ClearStall() macro
561 * is called, or the host issues a CLEAR FEATURE request to the device for the currently selected
562 * endpoint.
563 *
564 * \ingroup Group_EndpointPacketManagement_UC3
565 */
566 static inline void Endpoint_StallTransaction(void) ATTR_ALWAYS_INLINE;
567 static inline void Endpoint_StallTransaction(void)
568 {
569 (&AVR32_USBB.UECON0SET)[USB_SelectedEndpoint].stallrqs = true;
570 }
571
572 /** Clears the STALL condition on the currently selected endpoint.
573 *
574 * \ingroup Group_EndpointPacketManagement_UC3
575 */
576 static inline void Endpoint_ClearStall(void) ATTR_ALWAYS_INLINE;
577 static inline void Endpoint_ClearStall(void)
578 {
579 (&AVR32_USBB.UECON0CLR)[USB_SelectedEndpoint].stallrqc = true;
580 }
581
582 /** Determines if the currently selected endpoint is stalled, false otherwise.
583 *
584 * \ingroup Group_EndpointPacketManagement_UC3
585 *
586 * \return Boolean \c true if the currently selected endpoint is stalled, \c false otherwise.
587 */
588 static inline bool Endpoint_IsStalled(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
589 static inline bool Endpoint_IsStalled(void)
590 {
591 return (&AVR32_USBB.UECON0)[USB_SelectedEndpoint].stallrq;
592 }
593
594 /** Resets the data toggle of the currently selected endpoint. */
595 static inline void Endpoint_ResetDataToggle(void) ATTR_ALWAYS_INLINE;
596 static inline void Endpoint_ResetDataToggle(void)
597 {
598 (&AVR32_USBB.UECON0SET)[USB_SelectedEndpoint].rstdts = true;
599 }
600
601 /** Determines the currently selected endpoint's direction.
602 *
603 * \return The currently selected endpoint's direction, as a \c ENDPOINT_DIR_* mask.
604 */
605 static inline uint32_t Endpoint_GetEndpointDirection(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
606 static inline uint32_t Endpoint_GetEndpointDirection(void)
607 {
608 return ((&AVR32_USBB.UECFG0)[USB_SelectedEndpoint].epdir ? ENDPOINT_DIR_IN : ENDPOINT_DIR_OUT);
609 }
610
611 /** Sets the direction of the currently selected endpoint.
612 *
613 * \param[in] DirectionMask New endpoint direction, as a \c ENDPOINT_DIR_* mask.
614 */
615 static inline void Endpoint_SetEndpointDirection(const uint32_t DirectionMask) ATTR_ALWAYS_INLINE;
616 static inline void Endpoint_SetEndpointDirection(const uint32_t DirectionMask)
617 {
618 (&AVR32_USBB.UECFG0)[USB_SelectedEndpoint].epdir = (DirectionMask == ENDPOINT_DIR_IN);
619 }
620
621 /** Reads one byte from the currently selected endpoint's bank, for OUT direction endpoints.
622 *
623 * \ingroup Group_EndpointPrimitiveRW_AVR32
624 *
625 * \return Next byte in the currently selected endpoint's FIFO buffer.
626 */
627 static inline uint8_t Endpoint_Read_Byte(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
628 static inline uint8_t Endpoint_Read_Byte(void)
629 {
630 return *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
631 }
632
633 /** Writes one byte from the currently selected endpoint's bank, for IN direction endpoints.
634 *
635 * \ingroup Group_EndpointPrimitiveRW_AVR32
636 *
637 * \param[in] Byte Next byte to write into the the currently selected endpoint's FIFO buffer.
638 */
639 static inline void Endpoint_Write_Byte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
640 static inline void Endpoint_Write_Byte(const uint8_t Byte)
641 {
642 *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++) = Byte;
643 }
644
645 /** Discards one byte from the currently selected endpoint's bank, for OUT direction endpoints.
646 *
647 * \ingroup Group_EndpointPrimitiveRW_UC3
648 */
649 static inline void Endpoint_Discard_Byte(void) ATTR_ALWAYS_INLINE;
650 static inline void Endpoint_Discard_Byte(void)
651 {
652 uint8_t Dummy;
653
654 Dummy = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
655 }
656
657 /** Reads two bytes from the currently selected endpoint's bank in little endian format, for OUT
658 * direction endpoints.
659 *
660 * \ingroup Group_EndpointPrimitiveRW_UC3
661 *
662 * \return Next word in the currently selected endpoint's FIFO buffer.
663 */
664 static inline uint16_t Endpoint_Read_Word_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
665 static inline uint16_t Endpoint_Read_Word_LE(void)
666 {
667 uint16_t Byte1 = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
668 uint16_t Byte0 = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
669
670 return ((Byte0 << 8) | Byte1);
671 }
672
673 /** Reads two bytes from the currently selected endpoint's bank in big endian format, for OUT
674 * direction endpoints.
675 *
676 * \ingroup Group_EndpointPrimitiveRW_UC3
677 *
678 * \return Next word in the currently selected endpoint's FIFO buffer.
679 */
680 static inline uint16_t Endpoint_Read_Word_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
681 static inline uint16_t Endpoint_Read_Word_BE(void)
682 {
683 uint16_t Byte0 = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
684 uint16_t Byte1 = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
685
686 return ((Byte0 << 8) | Byte1);
687 }
688
689 /** Writes two bytes to the currently selected endpoint's bank in little endian format, for IN
690 * direction endpoints.
691 *
692 * \ingroup Group_EndpointPrimitiveRW_UC3
693 *
694 * \param[in] Word Next word to write to the currently selected endpoint's FIFO buffer.
695 */
696 static inline void Endpoint_Write_Word_LE(const uint16_t Word) ATTR_ALWAYS_INLINE;
697 static inline void Endpoint_Write_Word_LE(const uint16_t Word)
698 {
699 *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++) = (Word >> 8);
700 *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++) = (Word & 0xFF);
701 }
702
703 /** Writes two bytes to the currently selected endpoint's bank in big endian format, for IN
704 * direction endpoints.
705 *
706 * \ingroup Group_EndpointPrimitiveRW_UC3
707 *
708 * \param[in] Word Next word to write to the currently selected endpoint's FIFO buffer.
709 */
710 static inline void Endpoint_Write_Word_BE(const uint16_t Word) ATTR_ALWAYS_INLINE;
711 static inline void Endpoint_Write_Word_BE(const uint16_t Word)
712 {
713 *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++) = (Word & 0xFF);
714 *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++) = (Word >> 8);
715 }
716
717 /** Discards two bytes from the currently selected endpoint's bank, for OUT direction endpoints.
718 *
719 * \ingroup Group_EndpointPrimitiveRW_UC3
720 */
721 static inline void Endpoint_Discard_Word(void) ATTR_ALWAYS_INLINE;
722 static inline void Endpoint_Discard_Word(void)
723 {
724 uint8_t Dummy;
725
726 Dummy = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
727 Dummy = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
728 }
729
730 /** Reads four bytes from the currently selected endpoint's bank in little endian format, for OUT
731 * direction endpoints.
732 *
733 * \ingroup Group_EndpointPrimitiveRW_UC3
734 *
735 * \return Next double word in the currently selected endpoint's FIFO buffer.
736 */
737 static inline uint32_t Endpoint_Read_DWord_LE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
738 static inline uint32_t Endpoint_Read_DWord_LE(void)
739 {
740 uint32_t Byte3 = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
741 uint32_t Byte2 = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
742 uint32_t Byte1 = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
743 uint32_t Byte0 = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
744
745 return ((Byte0 << 24) | (Byte1 << 16) | (Byte2 << 8) | Byte3);
746 }
747
748 /** Reads four bytes from the currently selected endpoint's bank in big endian format, for OUT
749 * direction endpoints.
750 *
751 * \ingroup Group_EndpointPrimitiveRW_UC3
752 *
753 * \return Next double word in the currently selected endpoint's FIFO buffer.
754 */
755 static inline uint32_t Endpoint_Read_DWord_BE(void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE;
756 static inline uint32_t Endpoint_Read_DWord_BE(void)
757 {
758 uint32_t Byte0 = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
759 uint32_t Byte1 = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
760 uint32_t Byte2 = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
761 uint32_t Byte3 = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
762
763 return ((Byte0 << 24) | (Byte1 << 16) | (Byte2 << 8) | Byte3);
764 }
765
766 /** Writes four bytes to the currently selected endpoint's bank in little endian format, for IN
767 * direction endpoints.
768 *
769 * \ingroup Group_EndpointPrimitiveRW_UC3
770 *
771 * \param[in] DWord Next double word to write to the currently selected endpoint's FIFO buffer.
772 */
773 static inline void Endpoint_Write_DWord_LE(const uint32_t DWord) ATTR_ALWAYS_INLINE;
774 static inline void Endpoint_Write_DWord_LE(const uint32_t DWord)
775 {
776 *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++) = (DWord >> 24);
777 *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++) = (DWord >> 16);
778 *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++) = (DWord >> 8);
779 *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++) = (DWord & 0xFF);
780 }
781
782 /** Writes four bytes to the currently selected endpoint's bank in big endian format, for IN
783 * direction endpoints.
784 *
785 * \ingroup Group_EndpointPrimitiveRW_UC3
786 *
787 * \param[in] DWord Next double word to write to the currently selected endpoint's FIFO buffer.
788 */
789 static inline void Endpoint_Write_DWord_BE(const uint32_t DWord) ATTR_ALWAYS_INLINE;
790 static inline void Endpoint_Write_DWord_BE(const uint32_t DWord)
791 {
792 *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++) = (DWord & 0xFF);
793 *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++) = (DWord >> 8);
794 *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++) = (DWord >> 16);
795 *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++) = (DWord >> 24);
796 }
797
798 /** Discards four bytes from the currently selected endpoint's bank, for OUT direction endpoints.
799 *
800 * \ingroup Group_EndpointPrimitiveRW_UC3
801 */
802 static inline void Endpoint_Discard_DWord(void) ATTR_ALWAYS_INLINE;
803 static inline void Endpoint_Discard_DWord(void)
804 {
805 uint8_t Dummy;
806
807 Dummy = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
808 Dummy = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
809 Dummy = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
810 Dummy = *(USB_EndpointFIFOPos[USB_SelectedEndpoint]++);
811 }
812
813 /* External Variables: */
814 /** Global indicating the maximum packet size of the default control endpoint located at address
815 * 0 in the device. This value is set to the value indicated in the device descriptor in the user
816 * project once the USB interface is initialized into device mode.
817 *
818 * If space is an issue, it is possible to fix this to a static value by defining the control
819 * endpoint size in the \c FIXED_CONTROL_ENDPOINT_SIZE token passed to the compiler in the makefile
820 * via the -D switch. When a fixed control endpoint size is used, the size is no longer dynamically
821 * read from the descriptors at runtime and instead fixed to the given value. When used, it is
822 * important that the descriptor control endpoint size value matches the size given as the
823 * \c FIXED_CONTROL_ENDPOINT_SIZE token - it is recommended that the \c FIXED_CONTROL_ENDPOINT_SIZE token
824 * be used in the device descriptors to ensure this.
825 *
826 * \note This variable should be treated as read-only in the user application, and never manually
827 * changed in value.
828 */
829 #if (!defined(FIXED_CONTROL_ENDPOINT_SIZE) || defined(__DOXYGEN__))
830 extern uint8_t USB_ControlEndpointSize;
831 #else
832 #define USB_ControlEndpointSize FIXED_CONTROL_ENDPOINT_SIZE
833 #endif
834
835 /* Function Prototypes: */
836 /** Completes the status stage of a control transfer on a CONTROL type endpoint automatically,
837 * with respect to the data direction. This is a convenience function which can be used to
838 * simplify user control request handling.
839 */
840 void Endpoint_ClearStatusStage(void);
841
842 /** Spin-loops until the currently selected non-control endpoint is ready for the next packet of data
843 * to be read or written to it.
844 *
845 * \note This routine should not be called on CONTROL type endpoints.
846 *
847 * \ingroup Group_EndpointRW_UC3
848 *
849 * \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum.
850 */
851 uint8_t Endpoint_WaitUntilReady(void);
852
853 /* Disable C linkage for C++ Compilers: */
854 #if defined(__cplusplus)
855 }
856 #endif
857
858 #endif
859
860 /** @} */
861
USB isp AVR programmer