ahoneybun/qmk_firmware
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rewritten event system to remove all macros, to make user code clearer.

Browse source 
Fixed incorrect ENDPOINT_EPNUM_MASK mask preventing endpoints above EP3 from being selected (thanks to Jonathan Oakley).

Removed STREAM_CALLBACK() macro - callbacks now use regular function definitions to clarify user code.

Removed DESCRIPTOR_COMPARATOR() macro - comparators should now use regular function definitions to clarify user code.
This commit is contained in:
Dean Camera 2009-05-18 10:05:21 +00:00
parent 72c2922e38
commit 2ee9fc7077
116 changed files with 596 additions and 1124 deletions
Download patch file Download diff file Expand all files Collapse all files

220
LUFA/Drivers/USB/HighLevel/Events.h
View file

@ -36,9 +36,9 @@
* multiple places in the user or library code, which may or may not be inside an ISR, thus each handler
* should be written to be as small and fast as possible to prevent possible problems.
*
* Events can be hooked by the user application using the \ref EVENT_HANDLER() and \ref HANDLES_EVENT() macros. If an
* event with no associated handler is fired within the library, it by default fires an internal empty stub
* function. This is achieved through the use of the GCC compiler's "alias" attribute.
* Events can be hooked by the user application by declaring a handler function with the same name and parameters
* listed here. If an event with no user-associated handler is fired within the library, it by default maps to an
* internal empty stub function. This is achieved through the use of the GCC compiler's "alias" attribute.
*
* Each event must only have one associated event handler, but can be raised by multiple sources.
*
@ -59,96 +59,15 @@
extern "C" {
#endif
/* Public Interface - May be used in end-application: */
/* Macros: */
/** Raises a given event name, with the specified parameters. For events with no parameters the
* only argument to the macro is the event name, events with parameters list the parameter values
* after the name as a comma separated list.
*
* When a given event is fired, its corresponding event handler code is executed.
*
* Usage Examples:
* \code
* // Raise the USB_VBUSChange event, which takes no parameters
* RAISE_EVENT(USB_VBUSChange);
*
* // Raise the USB_UnhandledControlPacket event which takes two parameters
* RAISE_EVENT(USB_UnhandledControlPacket, 0, 1);
* \endcode
*
* \see RAISES_EVENT()
*/
#define RAISE_EVENT(e, ...) Event_ ## e (__VA_ARGS__)
/** Indicates that a given module can raise a given event. This is the equivalent of putting the
* event function's prototype into the module, but in a cleaner way. Each event which may be
* fired via the \ref RAISE_EVENT macro in the module should have an accompanying \ref RAISES_EVENT
* prototype in the module's header file.
*
* Usage Examples:
* \code
* // Module can raise the USB_VBUSChange event
* RAISES_EVENT(USB_VBUSChange);
*
* // ...
* // Inside a block of code in a function of the module, raise the USB_VBUSChange event
* RAISE_EVENT(USB_VBUSChange);
* \endcode
*
* \see RAISE_EVENT()
*/
#define RAISES_EVENT(e) HANDLES_EVENT(e)
/** Defines an event handler for the given event. Event handlers should be short in length, as they
* may be raised from inside an ISR. The user application can react to each event as it sees fit,
* such as logging the event, indicating the change to the user or performing some other action.
*
* Only one event handler may be defined in any user project for each individual event. Events may
* or may not have parameters - for each event, refer to its documentation elsewhere in this module
* to determine the presence and purpose of any event parameters.
*
* Usage Example:
* \code
* // Create an event handler for the USB_VBUSChange event
* EVENT_HANDLER(USB_VBUSChange)
* {
* // Code to execute when the VBUS level changes
* }
* \endcode
*
* \see HANDLES_EVENT()
*/
#define EVENT_HANDLER(e) void Event_ ## e e ## _P
/** Indicates that a given module handles an event. This is the equivalent of putting the
* event function's prototype into the module, but in a cleaner way. Each event which may be
* handled via the \ref EVENT_HANDLER macro in the module should have an accompanying \ref HANDLES_EVENT
* prototype in the module's header file.
*
* Usage Examples:
* \code
* // Module handles the USB_VBUSChange event
* HANDLES_EVENT(USB_VBUSChange);
*
* // Create the USB_VBUSChange event handler
* EVENT_HANDLER(USB_VBUSChange)
* {
* // Event handler code here
* }
* \endcode
*
* \see EVENT_HANDLER()
*/
#define HANDLES_EVENT(e) EVENT_HANDLER(e)
/* Public Interface - May be used in end-application: */
/* Pseudo-Functions for Doxygen: */
#if defined(__DOXYGEN__)
#if !defined(INCLUDE_FROM_EVENTS_C) || defined(__DOXYGEN__)
/** Event for VBUS level change. This event fires when the VBUS line of the USB AVR changes from
* high to low or vice-versa.
*
* \note This event is only available on USB AVR models which support VBUS notification interrupts.
*/
void USB_VBUSChange(void);
void EVENT_USB_VBUSChange(void);
/** Event for VBUS attachment. This event fires when the VBUS line of the USB AVR changes from
* low to high, signalling the attachment of the USB device to a host, before the enumeration
@ -156,7 +75,7 @@
*
* \note This event is only available on USB AVR models which support VBUS notification interrupts.
*/
void USB_VBUSConnect(void);
void EVENT_USB_VBUSConnect(void);
/** Event for VBUS detachment. This event fires when the VBUS line of the USB AVR changes from
* high to low, signalling the USB device has been removed from a host whether it has been enumerated
@ -164,7 +83,7 @@
*
* \note This event is only available on USB AVR models which support VBUS notification interrupts.
*/
void USB_VBUSDisconnect(void);
void EVENT_USB_VBUSDisconnect(void);
/** Event for USB device connection. This event fires when the AVR is in USB host mode and a device
* has been attached (but not yet fully enumerated), or when in device mode and the device is connected
@ -178,11 +97,11 @@
* which is not always accurate (host may suspend the bus while still connected). If the actual connection state
* needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by
* passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection
* and disconnection events may be manually fired by \ref RAISE_EVENT(), and the \ref USB_IsConnected global changed manually.
* and disconnection events may be manually fired, and the \ref USB_IsConnected global changed manually.
*
* \see USBTask.h for more information on the USB management task and reducing CPU usage.
*/
void USB_Connect(void);
void EVENT_USB_Connect(void);
/** Event for USB device disconnection. This event fires when the AVR is in USB host mode and an
* attached and enumerated device has been disconnected, or when in device mode and the device is
@ -196,11 +115,11 @@
* which is not always accurate (host may suspend the bus while still connected). If the actual connection state
* needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by
* passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection
* and disconnection events may be manually fired by \ref RAISE_EVENT(), and the \ref USB_IsConnected global changed manually.
* and disconnection events may be manually fired, and the \ref USB_IsConnected global changed manually.
*
* \see USBTask.h for more information on the USB management task and reducing CPU usage.
*/
void USB_Disconnect(void);
void EVENT_USB_Disconnect(void);
/** Event for USB initialization failure. This event fires when the USB interface fails to
* initialize correctly due to a hardware or software fault.
@ -208,9 +127,8 @@
* \note This event only exists on USB AVR models which support dual role modes.
*
* \param ErrorCode Error code indicating the failure reason, a value in \ref USB_InitErrorCodes_t
* located in LowLevel.h.
*/
void USB_InitFailure(const uint8_t ErrorCode);
void EVENT_USB_InitFailure(const uint8_t ErrorCode);
/** Event for USB mode pin level change. This event fires when the USB interface is set to dual role
* mode, and the UID pin level has changed to indicate a new mode (device or host). This event fires
@ -221,24 +139,23 @@
* \note This event does not exist if the USB_DEVICE_ONLY or USB_HOST_ONLY tokens have been supplied
* to the compiler (see \ref Group_USBManagement documentation).
*/
void USB_UIDChange(void);
void EVENT_USB_UIDChange(void);
/** Event for USB host error. This event fires when a hardware fault has occurred whilst the USB
* interface is in host mode.
*
* \param ErrorCode Error code indicating the failure reason, a value in \ref USB_Host_ErrorCodes_t
* located in Host.h.
*
* \note This event only exists on USB AVR models which supports host mode.
*
* \note This event does not exist if the USB_DEVICE_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*/
void USB_HostError(const uint8_t ErrorCode);
void EVENT_USB_HostError(const uint8_t ErrorCode);
/** Event for USB device attachment. This event fires when a the USB interface is in host mode, and
* a USB device has been connected to the USB interface. This is interrupt driven, thus fires before
* the standard \ref USB_Connect event and so can be used to programmatically start the USB management
* the standard \ref EVENT_USB_Connect event and so can be used to programmatically start the USB management
* task to reduce CPU consumption.
*
* \note This event only exists on USB AVR models which supports host mode.
@ -248,7 +165,7 @@
*
* \see \ref TASK(USB_USBTask) for more information on the USB management task and reducing CPU usage.
*/
void USB_DeviceAttached(void);
void EVENT_USB_DeviceAttached(void);
/** Event for USB device removal. This event fires when a the USB interface is in host mode, and
* a USB device has been removed the USB interface whether or not it has been enumerated. This
@ -261,13 +178,13 @@
*
* \see \ref TASK(USB_USBTask) for more information on the USB management task and reducing CPU usage.
*/
void USB_DeviceUnattached(void);
void EVENT_USB_DeviceUnattached(void);
/** Event for USB device enumeration failure. This event fires when a the USB interface is
* in host mode, and an attached USB device has failed to enumerate completely.
*
* \param ErrorCode Error code indicating the failure reason, a value in
* \ref USB_Host_EnumerationErrorCodes_t located in Host.h.
* \ref USB_Host_EnumerationErrorCodes_t
*
* \param SubErrorCode Sub error code indicating the reason for failure - for example, if the
* ErrorCode parameter indicates a control error, this will give the error
@ -278,14 +195,14 @@
* \note This event does not exist if the USB_DEVICE_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*/
void USB_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode);
void EVENT_USB_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode);
/** Event for USB device enumeration completion. This event fires when a the USB interface is
* in host mode and an attached USB device has been completely enumerated and is ready to be
* controlled by the user application, or when the library is in device mode, and the Host
* has finished enumerating the device.
*/
void USB_DeviceEnumerationComplete(void);
void EVENT_USB_DeviceEnumerationComplete(void);
/** Event for unhandled control requests. This event fires when a the USB host issues a control
* request to the control endpoint (address 0) that the library does not handle. This may either
@ -301,7 +218,7 @@
* request SETUP parameters into the \ref USB_ControlRequest structure which should then be used
* by the application to determine how to handle the issued request.
*/
void USB_UnhandledControlPacket(void);
void EVENT_USB_UnhandledControlPacket(void);
/** Event for USB configuration number changed. This event fires when a the USB host changes the
* selected configuration number while in device mode. This event should be hooked in device
@ -312,7 +229,7 @@
* \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*/
void USB_ConfigurationChanged(void);
void EVENT_USB_ConfigurationChanged(void);
/** Event for USB suspend. This event fires when a the USB host suspends the device by halting its
* transmission of Start Of Frame pulses to the device. This is generally hooked in order to move
@ -321,9 +238,9 @@
* \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*
* \see \ref USB_WakeUp() event for accompanying Wake Up event.
* \see \ref EVENT_USB_WakeUp() event for accompanying Wake Up event.
*/
void USB_Suspend(void);
void EVENT_USB_Suspend(void);
/** Event for USB wake up. This event fires when a the USB interface is suspended while in device
* mode, and the host wakes up the device by supplying Start Of Frame pulses. This is generally
@ -333,9 +250,9 @@
* \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*
* \see \ref USB_Suspend() event for accompanying Suspend event.
* \see \ref EVENT_USB_Suspend() event for accompanying Suspend event.
*/
void USB_WakeUp(void);
void EVENT_USB_WakeUp(void);
/** Event for USB interface reset. This event fires when a the USB interface is in device mode, and
* a the USB host requests that the device reset its interface. This is generally hooked so that
@ -346,90 +263,55 @@
* \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*/
void USB_Reset(void);
void EVENT_USB_Reset(void);
/** Event for USB device mode error. This event fires when the USB interface is in device mode,
* and an error occurs which prevents it from operating normally.
*
* \param ErrorCode Error code indicating the source of the error. One of the values in the
* \ref USB_Device_ErrorCodes_t enum located in Device.h.
* \param ErrorCode Error code indicating the source of the error, a value in
* \ref USB_Device_ErrorCodes_t
*
* \note This event does not exist if the USB_HOST_ONLY token is supplied to the compiler (see
* \ref Group_USBManagement documentation).
*/
void USB_DeviceError(const uint8_t ErrorCode);
void EVENT_USB_DeviceError(const uint8_t ErrorCode);
#endif
/* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__)
/* Macros: */
#define ALIAS_STUB(e) EVENT_HANDLER(e) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub)
#if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER)
#define USB_VBUSChange_P (void)
#define USB_VBUSConnect_P (void)
#define USB_VBUSDisconnect_P (void)
#endif
#define USB_Connect_P (void)
#define USB_Disconnect_P (void)
#define USB_DeviceEnumerationComplete_P (void)
#if defined(USB_CAN_BE_BOTH)
#define USB_InitFailure_P (const uint8_t ErrorCode)
#define USB_UIDChange_P (void)
#endif
#if defined(USB_CAN_BE_HOST)
#define USB_HostError_P (const uint8_t ErrorCode)
#define USB_DeviceAttached_P (void)
#define USB_DeviceUnattached_P (void)
#define USB_DeviceEnumerationFailed_P (const uint8_t ErrorCode, const uint8_t SubErrorCode)
#endif
#if defined(USB_CAN_BE_DEVICE)
#define USB_UnhandledControlPacket_P (void)
#define USB_ConfigurationChanged_P (void)
#define USB_Suspend_P (void)
#define USB_WakeUp_P (void)
#define USB_Reset_P (void)
#define USB_DeviceError_P (const uint8_t ErrorCode)
#endif
/* Function Prototypes: */
#if defined(INCLUDE_FROM_EVENTS_C)
void USB_Event_Stub(void) ATTR_CONST;
#if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER)
ALIAS_STUB(USB_VBUSChange);
ALIAS_STUB(USB_VBUSConnect);
ALIAS_STUB(USB_VBUSDisconnect);
void EVENT_USB_VBUSChange(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_VBUSConnect(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_VBUSDisconnect(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
#endif
ALIAS_STUB(USB_Connect);
ALIAS_STUB(USB_Disconnect);
ALIAS_STUB(USB_DeviceEnumerationComplete);
void EVENT_USB_Connect(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_Disconnect(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_DeviceEnumerationComplete(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
#if defined(USB_CAN_BE_BOTH)
ALIAS_STUB(USB_InitFailure);
ALIAS_STUB(USB_UIDChange);
void EVENT_USB_InitFailure(const uint8_t ErrorCode) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_UIDChange(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
#endif
#if defined(USB_CAN_BE_HOST)
ALIAS_STUB(USB_HostError);
ALIAS_STUB(USB_DeviceAttached);
ALIAS_STUB(USB_DeviceUnattached);
ALIAS_STUB(USB_DeviceEnumerationFailed);
void EVENT_USB_HostError(const uint8_t ErrorCode) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_DeviceAttached(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_DeviceUnattached(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_DeviceEnumerationFailed(const uint8_t ErrorCode, const uint8_t SubErrorCode)
ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
#endif
#if defined(USB_CAN_BE_DEVICE)
ALIAS_STUB(USB_UnhandledControlPacket);
ALIAS_STUB(USB_ConfigurationChanged);
ALIAS_STUB(USB_Suspend);
ALIAS_STUB(USB_WakeUp);
ALIAS_STUB(USB_Reset);
ALIAS_STUB(USB_DeviceError);
#endif
void EVENT_USB_UnhandledControlPacket(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_ConfigurationChanged(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_Suspend(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_WakeUp(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_Reset(void) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
void EVENT_USB_DeviceError(const uint8_t ErrorCode) ATTR_WEAK ATTR_ALIAS(USB_Event_Stub);
#endif
#endif

2
LUFA/Drivers/USB/HighLevel/StdDescriptors.c
View file

@ -36,7 +36,7 @@
uint16_t USB_GetDescriptor(const uint16_t wValue, const uint8_t wIndex, void** const DescriptorAddress)
{
RAISE_EVENT(USB_DeviceError, DEVICE_ERROR_GetDescriptorNotHooked);
EVENT_USB_DeviceError(DEVICE_ERROR_GetDescriptorNotHooked);
return 0;
};

10
LUFA/Drivers/USB/HighLevel/StdDescriptors.h
View file

@ -175,16 +175,6 @@
*/
#define ENDPOINT_USAGE_IMPLICIT_FEEDBACK (2 << 4)
/* Events: */
#if defined(USB_CAN_BE_DEVICE) || defined(__DOXYGEN__)
/** This module raises the Device Error event while in device mode, if the \ref USB_GetDescriptor()
* routine is not hooked in the user application to properly return descriptors to the library.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_DeviceError);
#endif
/* Enums: */
/** Enum for the possible standard descriptor types, as given in each descriptor's header. */
enum USB_DescriptorTypes_t

20
LUFA/Drivers/USB/HighLevel/StdRequestType.h
View file

@ -160,41 +160,41 @@
{
REQ_GetStatus = 0, /**< Implemented in the library for device, endpoint and interface
* recipients. Passed to the user application for other recipients
* via the \ref USB_UnhandledControlPacket() event when received in
* via the \ref EVENT_USB_UnhandledControlPacket() event when received in
* device mode. */
REQ_ClearFeature = 1, /**< Implemented in the library for device, endpoint and interface
* recipients. Passed to the user application for other recipients
* via the \ref USB_UnhandledControlPacket() event when received in
* via the \ref EVENT_USB_UnhandledControlPacket() event when received in
* device mode. */
REQ_SetFeature = 3, /**< Implemented in the library for device, endpoint and interface
* recipients. Passed to the user application for other recipients
* via the \ref USB_UnhandledControlPacket() event when received in
* via the \ref EVENT_USB_UnhandledControlPacket() event when received in
* device mode. */
REQ_SetAddress = 5, /**< Implemented in the library for the device recipient. Passed
* to the user application for other recipients via the
* \ref USB_UnhandledControlPacket() event when received in
* \ref EVENT_USB_UnhandledControlPacket() event when received in
* device mode. */
REQ_GetDescriptor = 6, /**< Implemented in the library for all recipients and all request
* types. */
REQ_SetDescriptor = 7, /**< Not implemented in the library, passed to the user application
* via the \ref USB_UnhandledControlPacket() event when received in
* via the \ref EVENT_USB_UnhandledControlPacket() event when received in
* device mode. */
REQ_GetConfiguration = 8, /**< Implemented in the library for the device recipient. Passed
* to the user application for other recipients via the
* \ref USB_UnhandledControlPacket() event when received in
* \ref EVENT_USB_UnhandledControlPacket() event when received in
* device mode. */
REQ_SetConfiguration = 9, /**< Implemented in the library for the device recipient. Passed
* to the user application for other recipients via the
* \ref USB_UnhandledControlPacket() event when received in
* \ref EVENT_USB_UnhandledControlPacket() event when received in
* device mode. */
REQ_GetInterface = 10, /**< Not implemented in the library, passed to the user application
* via the \ref USB_UnhandledControlPacket() event when received in
* via the \ref EVENT_USB_UnhandledControlPacket() event when received in
* device mode. */
REQ_SetInterface = 11, /**< Not implemented in the library, passed to the user application
* via the \ref USB_UnhandledControlPacket() event when received in
* via the \ref EVENT_USB_UnhandledControlPacket() event when received in
* device mode. */
REQ_SynchFrame = 12, /**< Not implemented in the library, passed to the user application
* via the \ref USB_UnhandledControlPacket() event when received in
* via the \ref EVENT_USB_UnhandledControlPacket() event when received in
* device mode. */
};

34
LUFA/Drivers/USB/HighLevel/StreamCallbacks.h
View file

@ -32,7 +32,8 @@
* @defgroup Group_StreamCallbacks Endpoint and Pipe Stream Callbacks
*
* Macros and enums for the stream callback routines. This module contains the code required to easily set up
* stream callback functions which can be used to force early abort of a stream read/write process.
* stream callback functions which can be used to force early abort of a stream read/write process. Each callback
* should take no arguments, and return a value from the \ref StreamCallback_Return_ErrorCodes_t enum.
*
* @{
*/
@ -42,37 +43,6 @@
/* Public Interface - May be used in end-application: */
/* Macros: */
/** Creates a prototype for or begins a stream callback routine. Stream callback routines are small
* routines which are executed during stream read or writes (if the callback-enabled versions of
* these functions are used) which allow the user application to abort the transfer when certain
* arbitrary conditions are met.
*
* Stream callback functions should return a value from the \ref StreamCallback_Return_ErrorCodes_t
* enum.
*
* Usage Example (Device Endpoint, but applicable for Host Pipes also):
* \code
* STREAM_CALLBACK(GlobalNotSet); // Callback Prototype
*
* STREAM_CALLBACK(GlobalNotSet)
* {
* if (MyGlobal == false)
* return ENDPOINT_STREAMCALLBACK_Continue;
* else
* return ENDPOINT_STREAMCALLBACK_Abort;
* }
*
* //...
* // Inside some routine:
* if (Endpoint_Write_Stream_LE(DataBuffer, sizeof(DataBuffer), GlobalNotSet) ==
* ENDPOINT_RWSTREAM_ERROR_CallbackAborted)
* {
* // Do something when the callback aborted the transfer early
* }
* \endcode
*/
#define STREAM_CALLBACK(name) uint8_t name (void)
/** Used with the Endpoint and Pipe stream functions as the callback function parameter, indicating that the stream
* call has no callback function to be called between USB packets.
*/

44
LUFA/Drivers/USB/HighLevel/USBInterrupt.c
View file

@ -72,24 +72,24 @@ ISR(USB_GEN_vect, ISR_BLOCK)
{
USB_INT_Clear(USB_INT_VBUS);
RAISE_EVENT(USB_VBUSChange);
EVENT_USB_VBUSChange();
if (USB_VBUS_GetStatus())
{
RAISE_EVENT(USB_VBUSConnect);
EVENT_USB_VBUSConnect();
if (USB_IsConnected)
RAISE_EVENT(USB_Disconnect);
EVENT_USB_Disconnect();
USB_ResetInterface();
USB_IsConnected = true;
RAISE_EVENT(USB_Connect);
EVENT_USB_Connect();
}
else
{
RAISE_EVENT(USB_Disconnect);
EVENT_USB_Disconnect();
USB_Detach();
USB_CLK_Freeze();
@ -98,7 +98,7 @@ ISR(USB_GEN_vect, ISR_BLOCK)
USB_IsConnected = false;
RAISE_EVENT(USB_VBUSDisconnect);
EVENT_USB_VBUSDisconnect();
USB_INT_Clear(USB_INT_VBUS);
}
@ -119,13 +119,13 @@ ISR(USB_GEN_vect, ISR_BLOCK)
USB_IsSuspended = true;
RAISE_EVENT(USB_Suspend);
EVENT_USB_Suspend();
#if defined(USB_LIMITED_CONTROLLER) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
if (USB_IsConnected)
{
USB_IsConnected = false;
RAISE_EVENT(USB_Disconnect);
EVENT_USB_Disconnect();
}
#endif
}
@ -149,13 +149,13 @@ ISR(USB_GEN_vect, ISR_BLOCK)
if (!(USB_IsConnected))
{
USB_IsConnected = true;
RAISE_EVENT(USB_Connect);
EVENT_USB_Connect();
}
#endif
USB_IsSuspended = false;
RAISE_EVENT(USB_WakeUp);
EVENT_USB_WakeUp();
}
if (USB_INT_HasOccurred(USB_INT_EORSTI) && USB_INT_IsEnabled(USB_INT_EORSTI))
@ -178,7 +178,7 @@ ISR(USB_GEN_vect, ISR_BLOCK)
USB_INT_Enable(USB_INT_ENDPOINT_SETUP);
#endif
RAISE_EVENT(USB_Reset);
EVENT_USB_Reset();
}
#endif
@ -189,8 +189,8 @@ ISR(USB_GEN_vect, ISR_BLOCK)
USB_INT_Clear(USB_INT_DCONNI);
USB_INT_Disable(USB_INT_DDISCI);
RAISE_EVENT(USB_DeviceUnattached);
RAISE_EVENT(USB_Disconnect);
EVENT_USB_DeviceUnattached();
EVENT_USB_Disconnect();
USB_ResetInterface();
}
@ -202,8 +202,8 @@ ISR(USB_GEN_vect, ISR_BLOCK)
USB_Host_VBUS_Manual_Off();
USB_Host_VBUS_Auto_Off();
RAISE_EVENT(USB_HostError, HOST_ERROR_VBusVoltageDip);
RAISE_EVENT(USB_DeviceUnattached);
EVENT_USB_HostError(HOST_ERROR_VBusVoltageDip);
EVENT_USB_DeviceUnattached();
USB_HostState = HOST_STATE_Unattached;
}
@ -213,7 +213,7 @@ ISR(USB_GEN_vect, ISR_BLOCK)
USB_INT_Clear(USB_INT_SRPI);
USB_INT_Disable(USB_INT_SRPI);
RAISE_EVENT(USB_DeviceAttached);
EVENT_USB_DeviceAttached();
USB_INT_Enable(USB_INT_DDISCI);
@ -224,11 +224,11 @@ ISR(USB_GEN_vect, ISR_BLOCK)
{
USB_INT_Clear(USB_INT_BCERRI);
RAISE_EVENT(USB_DeviceEnumerationFailed, HOST_ENUMERROR_NoDeviceDetected, 0);
RAISE_EVENT(USB_DeviceUnattached);
EVENT_USB_DeviceEnumerationFailed(HOST_ENUMERROR_NoDeviceDetected, 0);
EVENT_USB_DeviceUnattached();
if (USB_IsConnected)
RAISE_EVENT(USB_Disconnect);
EVENT_USB_Disconnect();
USB_ResetInterface();
}
@ -242,12 +242,12 @@ ISR(USB_GEN_vect, ISR_BLOCK)
if (USB_IsConnected)
{
if (USB_CurrentMode == USB_MODE_HOST)
RAISE_EVENT(USB_DeviceUnattached);
EVENT_USB_DeviceUnattached();
else
RAISE_EVENT(USB_Disconnect);
EVENT_USB_Disconnect();
}
RAISE_EVENT(USB_UIDChange);
EVENT_USB_UIDChange();
USB_ResetInterface();
}

107
LUFA/Drivers/USB/HighLevel/USBInterrupt.h
View file

@ -45,113 +45,6 @@
extern "C" {
#endif
/* Public Interface - May be used in end-application: */
/* Throwable Events: */
/** This module raises the USB Connected interrupt when the AVR is attached to a host while in device
* USB mode.
*
* \note For the smaller USB AVRs (AT90USBXX2) with limited USB controllers, VBUS is not available to the USB controller.
* this means that the current connection state is derived from the bus suspension and wake up events by default,
* which is not always accurate (host may suspend the bus while still connected). If the actual connection state
* needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by
* passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection
* and disconnection events may be manually fired by \ref RAISE_EVENT(), and the USB_IsConnected global changed manually.
*/
RAISES_EVENT(USB_Connect);
/** This module raises the USB Disconnected interrupt when the AVR is removed from a host while in
* device USB mode.
*
* \note For the smaller USB AVRs (AT90USBXX2) with limited USB controllers, VBUS is not available to the USB controller.
* this means that the current connection state is derived from the bus suspension and wake up events by default,
* which is not always accurate (host may suspend the bus while still connected). If the actual connection state
* needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by
* passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection
* and disconnection events may be manually fired by \ref RAISE_EVENT(), and the USB_IsConnected global changed manually.
*/
RAISES_EVENT(USB_Disconnect);
#if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER) || defined(__DOXYGEN__)
/** This module raises the VBUS Change event when the current VBUS status (present or not present) has
* changed.
*
* \note Not all USB AVR models support VBUS interrupts; this event only exists on supported AVRs.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_VBUSChange);
/** This module raises the VBUS Connect event when the VBUS line is powered.
*
* \note Not all USB AVR models support VBUS interrupts; this event only exists on supported AVRs.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_VBUSConnect);
/** This module raises the VBUS Disconnect event when power is removed from the VBUS line.
*
* \note Not all USB AVR models support VBUS interrupts; this event only exists on supported AVRs.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_VBUSDisconnect);
#endif
#if defined(USB_CAN_BE_DEVICE) || defined(__DOXYGEN__)
/** This module raises the Suspended event when the host suspends the USB interface of the AVR
* whilst running in device mode.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_Suspend);
/** This module raises the Wake Up event when the host resumes the USB interface of the AVR
* whilst running in device mode.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_WakeUp);
/** This module raises the USB Reset event when the host resets the USB interface of the AVR
* whilst running in device mode.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_Reset);
#endif
#if defined(USB_CAN_BE_HOST) || defined(__DOXYGEN__)
/** This module raises the Host Error event when the VBUS line voltage dips below the minimum threshold
* while running in host mode.
*
* \note Not all USB AVR models support host mode; this event only exists on supported AVRs.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_HostError);
/** This module raises the Device Unattached event when an attached device is removed from the AVR whilst
* running in host mode.
*
* \note Not all USB AVR models support host mode; this event only exists on supported AVRs.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_DeviceUnattached);
#endif
#if defined(USB_CAN_BE_BOTH) || defined(__DOXYGEN__)
/** This module raises the UID Change event when the UID line changes in value on dual-role devices.
*
* \note Not all USB AVR models support host mode and thus the UID pin; this event only exists on
* supported AVRs.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_UIDChange);
#endif
/* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__)
/* Macros: */

58
LUFA/Drivers/USB/HighLevel/USBTask.h
View file

@ -67,7 +67,7 @@
* which is not always accurate (host may suspend the bus while still connected). If the actual connection state
* needs to be determined, VBUS should be routed to an external pin, and the auto-detect behaviour turned off by
* passing the NO_LIMITED_CONTROLLER_CONNECT token to the compiler via the -D switch at compile time. The connection
* and disconnection events may be manually fired by \ref RAISE_EVENT(), and the \ref USB_IsConnected global changed manually.
* and disconnection events may be manually fired, and the \ref USB_IsConnected global changed manually.
*
* \ingroup Group_USBManagement
*/
@ -84,7 +84,7 @@
extern volatile bool USB_IsInitialized;
/** Structure containing the last received Control request when in Device mode (for use in user-applications
* inside of the \ref USB_UnhandledControlPacket() event, or for filling up with a control request to issue when
* inside of the \ref EVENT_USB_UnhandledControlPacket() event, or for filling up with a control request to issue when
* in Host mode before calling \ref USB_Host_SendControlRequest().
*
* \ingroup Group_USBManagement
@ -122,52 +122,6 @@
extern volatile uint8_t USB_HostState;
#endif
/* Throwable Events: */
#if defined(USB_CAN_BE_HOST) || defined(__DOXYGEN__)
/** This module raises the \ref USB_Connect event when a USB device has been connected whilst in host
* mode, but not yet enumerated.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_Connect);
/** This module raises the \ref USB_DeviceAttached event when in host mode, and a device is attached
* to the AVR's USB interface.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_DeviceAttached);
/** This module raises the \ref USB_DeviceUnattached event when in host mode, and a device is removed
* from the AVR's USB interface.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_DeviceUnattached);
/** This module raises the \ref USB_DeviceEnumerationFailed event when in host mode, and an
* attached USB device has failed to successfully enumerated.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_DeviceEnumerationFailed);
/** This module raises the \ref USB_DeviceEnumerationComplete event when in host mode, and an
* attached USB device has been successfully enumerated and ready to be used by the user
* application.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_DeviceEnumerationComplete);
/** This module raises the \ref USB_Disconnect event when an attached USB device is removed from the USB
* bus.
*
* \see \ref Group_Events for more information on this event.
*/
RAISES_EVENT(USB_Disconnect);
#endif
/* Tasks: */
/** This is the main USB management task. The USB driver requires that this task be executed
* continuously when the USB system is active (device attached in host mode, or attached to a host
@ -177,11 +131,11 @@
* The USB task must be serviced within 50mS in all modes, when needed. The task may be serviced
* at all times, or (for minimum CPU consumption):
*
* - In device mode, it may be disabled at start-up, enabled on the firing of the \ref USB_Connect event
* and disabled again on the firing of the \ref USB_Disconnect event.
* - In device mode, it may be disabled at start-up, enabled on the firing of the \ref EVENT_USB_Connect() event
* and disabled again on the firing of the \ref EVENT_USB_Disconnect() event.
*
* - In host mode, it may be disabled at start-up, enabled on the firing of the \ref USB_DeviceAttached
* event and disabled again on the firing of the \ref USB_DeviceUnattached event.
* - In host mode, it may be disabled at start-up, enabled on the firing of the \ref EVENT_USB_DeviceAttached()
* event and disabled again on the firing of the \ref EVENT_USB_DeviceUnattached() event.
*
* If in device mode (only), the control endpoint can instead be managed via interrupts entirely by the library
* by defining the INTERRUPT_CONTROL_ENDPOINT token and passing it to the compiler via the -D switch.