projects / pub / USBasp.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Oops - fix broken SPI driver due to missing bit inversion on a port mask.
[pub/USBasp.git] / LUFA / Drivers / USB / Class / Device / CDC.h
diff --git a/LUFA/Drivers/USB/Class/Device/CDC.h b/LUFA/Drivers/USB/Class/Device/CDC.h
index f0351f5..2e66e9f 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/CDC.h
+++ b/LUFA/Drivers/USB/Class/Device/CDC.h
@@ -1,7 +1,7 @@
 /*
              LUFA Library
      Copyright (C) Dean Camera, 2010.
 /*
              LUFA Library
      Copyright (C) Dean Camera, 2010.
-              
+
   dean [at] fourwalledcubicle [dot] com
       www.fourwalledcubicle.com
 */
   dean [at] fourwalledcubicle [dot] com
       www.fourwalledcubicle.com
 */
@@ -9,13 +9,13 @@
 /*
   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
 
 /*
   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
 
-  Permission to use, copy, modify, distribute, and sell this 
+  Permission to use, copy, modify, distribute, and sell this
   software and its documentation for any purpose is hereby granted
   software and its documentation for any purpose is hereby granted
-  without fee, provided that the above copyright notice appear in 
+  without fee, provided that the above copyright notice appear in
   all copies and that both that the copyright notice and this
   all copies and that both that the copyright notice and this
-  permission notice and warranty disclaimer appear in supporting 
-  documentation, and that the name of the author not be used in 
-  advertising or publicity pertaining to distribution of the 
+  permission notice and warranty disclaimer appear in supporting
+  documentation, and that the name of the author not be used in
+  advertising or publicity pertaining to distribution of the
   software without specific, written prior permission.
 
   The author disclaim all warranties with regard to this
   software without specific, written prior permission.
 
   The author disclaim all warranties with regard to this
@@ -42,7 +42,7 @@
  *
  *  \section Sec_Dependencies Module Source Dependencies
  *  The following files must be built with any user project that uses this module:
  *
  *  \section Sec_Dependencies Module Source Dependencies
  *  The following files must be built with any user project that uses this module:
- *    - LUFA/Drivers/USB/Class/Device/CDC.c
+ *    - LUFA/Drivers/USB/Class/Device/CDC.c <i>(Makefile source module name: LUFA_SRC_USBCLASS)</i>
  *
  *  \section Module Description
  *  Device Mode USB Class driver framework interface, for the CDC USB Class driver.
  *
  *  \section Module Description
  *  Device Mode USB Class driver framework interface, for the CDC USB Class driver.
@@ -50,11 +50,11 @@
  *  \note There are several major drawbacks to the CDC-ACM standard USB class, however
  *        it is very standardized and thus usually available as a built-in driver on
  *        most platforms, and so is a better choice than a proprietary serial class.
  *  \note There are several major drawbacks to the CDC-ACM standard USB class, however
  *        it is very standardized and thus usually available as a built-in driver on
  *        most platforms, and so is a better choice than a proprietary serial class.
- *        
+ *
  *        One major issue with CDC-ACM is that it requires two Interface descriptors,
  *        which will upset most hosts when part of a multi-function "Composite" USB
  *        device, as each interface will be loaded into a separate driver instance. To
  *        One major issue with CDC-ACM is that it requires two Interface descriptors,
  *        which will upset most hosts when part of a multi-function "Composite" USB
  *        device, as each interface will be loaded into a separate driver instance. To
- *        conbat this, you should use the "Interface Association Descriptor" addendum to
+ *        combat this, you should use the "Interface Association Descriptor" addendum to
  *        the USB standard which is available on most OSes when creating Composite devices.
  *
  *        Another major oversight is that there is no mechanism for the host to notify the
  *        the USB standard which is available on most OSes when creating Composite devices.
  *
  *        Another major oversight is that there is no mechanism for the host to notify the
@@ -66,7 +66,7 @@
  *
  *  @{
  */
  *
  *  @{
  */
- 
+
 #ifndef _CDC_CLASS_DEVICE_H_
 #define _CDC_CLASS_DEVICE_H_
 
 #ifndef _CDC_CLASS_DEVICE_H_
 #define _CDC_CLASS_DEVICE_H_
 
@@ -86,7 +86,7 @@
                #if !defined(__INCLUDE_FROM_CDC_DRIVER)
                        #error Do not include this file directly. Include LUFA/Drivers/Class/CDC.h instead.
                #endif
                #if !defined(__INCLUDE_FROM_CDC_DRIVER)
                        #error Do not include this file directly. Include LUFA/Drivers/Class/CDC.h instead.
                #endif
-               
+
        /* Public Interface - May be used in end-application: */
                /* Type Defines: */
                        /** \brief CDC Class Device Mode Configuration and State Structure.
        /* Public Interface - May be used in end-application: */
                /* Type Defines: */
                        /** \brief CDC Class Device Mode Configuration and State Structure.
@@ -99,19 +99,19 @@
                        {
                                const struct
                                {
                        {
                                const struct
                                {
-                                       uint8_t  ControlInterfaceNumber; /**< Interface number of the CDC control interface within the device */
+                                       uint8_t  ControlInterfaceNumber; /**< Interface number of the CDC control interface within the device. */
 
 
-                                       uint8_t  DataINEndpointNumber; /**< Endpoint number of the CDC interface's IN data endpoint */
-                                       uint16_t DataINEndpointSize; /**< Size in bytes of the CDC interface's IN data endpoint */
-                                       bool     DataINEndpointDoubleBank; /** Indicates if the CDC interface's IN data endpoint should use double banking */
+                                       uint8_t  DataINEndpointNumber; /**< Endpoint number of the CDC interface's IN data endpoint. */
+                                       uint16_t DataINEndpointSize; /**< Size in bytes of the CDC interface's IN data endpoint. */
+                                       bool     DataINEndpointDoubleBank; /**< Indicates if the CDC interface's IN data endpoint should use double banking. */
 
 
-                                       uint8_t  DataOUTEndpointNumber; /**< Endpoint number of the CDC interface's OUT data endpoint */
-                                       uint16_t DataOUTEndpointSize;  /**< Size in bytes of the CDC interface's OUT data endpoint */
-                                       bool     DataOUTEndpointDoubleBank; /** Indicates if the CDC interface's OUT data endpoint should use double banking */
+                                       uint8_t  DataOUTEndpointNumber; /**< Endpoint number of the CDC interface's OUT data endpoint. */
+                                       uint16_t DataOUTEndpointSize;  /**< Size in bytes of the CDC interface's OUT data endpoint. */
+                                       bool     DataOUTEndpointDoubleBank; /**< Indicates if the CDC interface's OUT data endpoint should use double banking. */
 
 
-                                       uint8_t  NotificationEndpointNumber; /**< Endpoint number of the CDC interface's IN notification endpoint, if used */
-                                       uint16_t NotificationEndpointSize;  /**< Size in bytes of the CDC interface's IN notification endpoint, if used */
-                                       bool     NotificationEndpointDoubleBank; /** Indicates if the CDC interface's notification endpoint should use double banking */
+                                       uint8_t  NotificationEndpointNumber; /**< Endpoint number of the CDC interface's IN notification endpoint, if used. */
+                                       uint16_t NotificationEndpointSize;  /**< Size in bytes of the CDC interface's IN notification endpoint, if used. */
+                                       bool     NotificationEndpointDoubleBank; /**< Indicates if the CDC interface's notification endpoint should use double banking. */
                                } Config; /**< Config data for the USB class interface within the device. All elements in this section
                                           *   <b>must</b> be set or the interface will fail to enumerate and operate correctly.
                                           */
                                } Config; /**< Config data for the USB class interface within the device. All elements in this section
                                           *   <b>must</b> be set or the interface will fail to enumerate and operate correctly.
                                           */
@@ -130,44 +130,48 @@
 
                                        struct
                                        {
 
                                        struct
                                        {
-                                               uint32_t BaudRateBPS; /**< Baud rate of the virtual serial port, in bits per second */
+                                               uint32_t BaudRateBPS; /**< Baud rate of the virtual serial port, in bits per second. */
                                                uint8_t  CharFormat; /**< Character format of the virtual serial port, a value from the
                                                uint8_t  CharFormat; /**< Character format of the virtual serial port, a value from the
-                                                                                         *   CDCDevice_CDC_LineCodingFormats_t enum
+                                                                                         *   \ref CDC_LineEncodingFormats_t enum.
                                                                                          */
                                                uint8_t  ParityType; /**< Parity setting of the virtual serial port, a value from the
                                                                                          */
                                                uint8_t  ParityType; /**< Parity setting of the virtual serial port, a value from the
-                                                                                         *   CDCDevice_LineCodingParity_t enum
+                                                                                         *   \ref CDC_LineEncodingParity_t enum.
                                                                                          */
                                                                                          */
-                                               uint8_t  DataBits; /**< Bits of data per character of the virtual serial port */
+                                               uint8_t  DataBits; /**< Bits of data per character of the virtual serial port. */
                                        } LineEncoding; /** Line encoding used in the virtual serial port, for the device's information. This is generally
                                                         *  only used if the virtual serial port data is to be reconstructed on a physical UART.
                                        } LineEncoding; /** Line encoding used in the virtual serial port, for the device's information. This is generally
                                                         *  only used if the virtual serial port data is to be reconstructed on a physical UART.
-                                                        */             
+                                                        */
                                } State; /**< State data for the USB class interface within the device. All elements in this section
                                          *   are reset to their defaults when the interface is enumerated.
                                          */
                        } USB_ClassInfo_CDC_Device_t;
                                } State; /**< State data for the USB class interface within the device. All elements in this section
                                          *   are reset to their defaults when the interface is enumerated.
                                          */
                        } USB_ClassInfo_CDC_Device_t;
-               
-               /* Function Prototypes: */              
+
+               /* Function Prototypes: */
                        /** Configures the endpoints of a given CDC interface, ready for use. This should be linked to the library
                         *  \ref EVENT_USB_Device_ConfigurationChanged() event so that the endpoints are configured when the configuration containing
                         *  the given CDC interface is selected.
                         *
                        /** Configures the endpoints of a given CDC interface, ready for use. This should be linked to the library
                         *  \ref EVENT_USB_Device_ConfigurationChanged() event so that the endpoints are configured when the configuration containing
                         *  the given CDC interface is selected.
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
+                        *  \note The endpoint index numbers as given in the interface's configuration structure must not overlap with any other
+                        *        interface, or endpoint bank corruption will occur. Gaps in the allocated endpoint numbers or non-sequential indexes
+                        *        within a single interface is allowed, but no two interfaces of any type have have interleaved endpoint indexes.
+                        *
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
                         *
                         *
-                        *  \return Boolean true if the endpoints were successfully configured, false otherwise
+                        *  \return Boolean true if the endpoints were successfully configured, false otherwise.
                         */
                        bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
 
                        /** Processes incoming control requests from the host, that are directed to the given CDC class interface. This should be
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.
                         *
                         */
                        bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
 
                        /** Processes incoming control requests from the host, that are directed to the given CDC class interface. This should be
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
                         */
                        void CDC_Device_ProcessControlRequest(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
 
                        /** General management task for a given CDC class interface, required for the correct operation of the interface. This should
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
                         *
                         */
                        void CDC_Device_ProcessControlRequest(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
 
                        /** General management task for a given CDC class interface, required for the correct operation of the interface. This should
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
                         */
                        void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
 
                         */
                        void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
 
@@ -176,108 +180,115 @@
                         *  user program by declaring a handler function with the same name and parameters listed here. The new line encoding
                         *  settings are available in the LineEncoding structure inside the CDC interface structure passed as a parameter.
                         *
                         *  user program by declaring a handler function with the same name and parameters listed here. The new line encoding
                         *  settings are available in the LineEncoding structure inside the CDC interface structure passed as a parameter.
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
                         */
                        void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
                         */
                        void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
-                       
+
                        /** CDC class driver event for a control line state change on a CDC interface. This event fires each time the host requests a
                         *  control line state change (containing the virtual serial control line states, such as DTR) and may be hooked in the
                         *  user program by declaring a handler function with the same name and parameters listed here. The new control line states
                         *  are available in the ControlLineStates.HostToDevice value inside the CDC interface structure passed as a parameter, set as
                         *  a mask of CDC_CONTROL_LINE_OUT_* masks.
                         *
                        /** CDC class driver event for a control line state change on a CDC interface. This event fires each time the host requests a
                         *  control line state change (containing the virtual serial control line states, such as DTR) and may be hooked in the
                         *  user program by declaring a handler function with the same name and parameters listed here. The new control line states
                         *  are available in the ControlLineStates.HostToDevice value inside the CDC interface structure passed as a parameter, set as
                         *  a mask of CDC_CONTROL_LINE_OUT_* masks.
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
                         */
                        void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
 
                         */
                        void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
 
-                       /** CDC class driver event for a send break request sent to the device from the host. This is generally used to seperate
+                       /** CDC class driver event for a send break request sent to the device from the host. This is generally used to separate
                         *  data or to indicate a special condition to the receiving device.
                         *
                         *  data or to indicate a special condition to the receiving device.
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
-                        *  \param[in]     Duration          Duration of the break that has been sent by the host, in milliseconds
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
+                        *  \param[in]     Duration          Duration of the break that has been sent by the host, in milliseconds.
                         */
                         */
-                       void EVENT_CDC_Device_BreakSent(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, uint8_t Duration) ATTR_NON_NULL_PTR_ARG(1);
+                       void EVENT_CDC_Device_BreakSent(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
+                                                       const uint8_t Duration) ATTR_NON_NULL_PTR_ARG(1);
 
                        /** Sends a given string to the attached USB host, if connected. If a host is not connected when the function is called, the
                         *  string is discarded. Bytes will be queued for transmission to the host until either the endpoint bank becomes full, or the
 
                        /** Sends a given string to the attached USB host, if connected. If a host is not connected when the function is called, the
                         *  string is discarded. Bytes will be queued for transmission to the host until either the endpoint bank becomes full, or the
-                        *  \ref CDC_Device_Flush() function is called to flush the pending data to the host. This allows for multiple bytes to be 
+                        *  \ref CDC_Device_Flush() function is called to flush the pending data to the host. This allows for multiple bytes to be
                         *  packed into a single endpoint packet, increasing data throughput.
                         *
                         *  packed into a single endpoint packet, increasing data throughput.
                         *
-                        *  \note This function must only be called when the Device state machine is in the DEVICE_STATE_Configured state or
-                        *        the call will fail.
+                        *  \pre This function must only be called when the Device state machine is in the \ref DEVICE_STATE_Configured state or
+                        *       the call will fail.
                         *
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
-                        *  \param[in] Data  Pointer to the string to send to the host
-                        *  \param[in] Length  Size in bytes of the string to send to the host
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
+                        *  \param[in]     Data              Pointer to the string to send to the host.
+                        *  \param[in]     Length            Size in bytes of the string to send to the host.
                         *
                         *
-                        *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum
+                        *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum.
                         */
                         */
-                       uint8_t CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length)
-                                                     ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
-                       
+                       uint8_t CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
+                                                     const char* const Data,
+                                                     const uint16_t Length) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
+
                        /** Sends a given byte to the attached USB host, if connected. If a host is not connected when the function is called, the
                         *  byte is discarded. Bytes will be queued for transmission to the host until either the endpoint bank becomes full, or the
                        /** Sends a given byte to the attached USB host, if connected. If a host is not connected when the function is called, the
                         *  byte is discarded. Bytes will be queued for transmission to the host until either the endpoint bank becomes full, or the
-                        *  \ref CDC_Device_Flush() function is called to flush the pending data to the host. This allows for multiple bytes to be 
+                        *  \ref CDC_Device_Flush() function is called to flush the pending data to the host. This allows for multiple bytes to be
                         *  packed into a single endpoint packet, increasing data throughput.
                         *
                         *  packed into a single endpoint packet, increasing data throughput.
                         *
-                        *  \note This function must only be called when the Device state machine is in the DEVICE_STATE_Configured state or
-                        *        the call will fail.
+                        *  \pre This function must only be called when the Device state machine is in the \ref DEVICE_STATE_Configured state or
+                        *       the call will fail.
                         *
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
-                        *  \param[in] Data  Byte of data to send to the host
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
+                        *  \param[in]     Data              Byte of data to send to the host.
                         *
                         *
-                        *  \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum
+                        *  \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum.
                         */
                         */
-                       uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data) ATTR_NON_NULL_PTR_ARG(1);
-                       
-                       /** Determines the number of bytes received by the CDC interface from the host, waiting to be read.
+                       uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
+                                                   const uint8_t Data) ATTR_NON_NULL_PTR_ARG(1);
+
+                       /** Determines the number of bytes received by the CDC interface from the host, waiting to be read. This indicates the number
+                        *  of bytes in the OUT endpoint bank only, and thus the number of calls to \ref CDC_Device_ReceiveByte() which are guaranteed to
+                        *  succeed immediately. If multiple bytes are to be received, they should be buffered by the user application, as the endpoint
+                        *  bank will not be released back to the USB controller until all bytes are read.
                         *
                         *
-                        *  \note This function must only be called when the Device state machine is in the DEVICE_STATE_Configured state or
-                        *        the call will fail.
+                        *  \pre This function must only be called when the Device state machine is in the \ref DEVICE_STATE_Configured state or
+                        *       the call will fail.
                         *
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
                         *
                         *
-                        *  \return Total number of buffered bytes received from the host
+                        *  \return Total number of buffered bytes received from the host.
                         */
                        uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
                         */
                        uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
-                       
+
                        /** Reads a byte of data from the host. If no data is waiting to be read of if a USB host is not connected, the function
                        /** Reads a byte of data from the host. If no data is waiting to be read of if a USB host is not connected, the function
-                        *  returns 0. The \ref CDC_Device_BytesReceived() function should be queried before data is received to ensure that no data
-                        *  underflow occurs.
+                        *  returns a negative value. The \ref CDC_Device_BytesReceived() function may be queried in advance to determine how many
+                        *  bytes are currently buffered in the CDC interface's data receive endpoint bank, and thus how many repeated calls to this
+                        *  function which are guaranteed to succeed.
                         *
                         *
-                        *  \note This function must only be called when the Device state machine is in the DEVICE_STATE_Configured state or
-                        *        the call will fail.
+                        *  \pre This function must only be called when the Device state machine is in the \ref DEVICE_STATE_Configured state or
+                        *       the call will fail.
                         *
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
                         *
                         *
-                        *  \return Next received byte from the host, or 0 if no data received
+                        *  \return Next received byte from the host, or a negative value if no data received.
                         */
                         */
-                       uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
-                       
+                       int16_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
+
                        /** Flushes any data waiting to be sent, ensuring that the send buffer is cleared.
                         *
                        /** Flushes any data waiting to be sent, ensuring that the send buffer is cleared.
                         *
-                        *  \note This function must only be called when the Device state machine is in the DEVICE_STATE_Configured state or
-                        *        the call will fail.
+                        *  \pre This function must only be called when the Device state machine is in the \ref DEVICE_STATE_Configured state or
+                        *       the call will fail.
                         *
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
                         *
                         *
-                        *  \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum
+                        *  \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum.
                         */
                        uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
                         */
                        uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
-                       
+
                        /** Sends a Serial Control Line State Change notification to the host. This should be called when the virtual serial
                         *  control lines (DCD, DSR, etc.) have changed states, or to give BREAK notifications to the host. Line states persist
                        /** Sends a Serial Control Line State Change notification to the host. This should be called when the virtual serial
                         *  control lines (DCD, DSR, etc.) have changed states, or to give BREAK notifications to the host. Line states persist
-                        *  until they are cleared via a second notification. This should be called each time the CDC class driver's 
+                        *  until they are cleared via a second notification. This should be called each time the CDC class driver's
                         *  ControlLineStates.DeviceToHost value is updated to push the new states to the USB host.
                         *
                         *  ControlLineStates.DeviceToHost value is updated to push the new states to the USB host.
                         *
-                        *  \note This function must only be called when the Device state machine is in the DEVICE_STATE_Configured state or
-                        *        the call will fail.
+                        *  \pre This function must only be called when the Device state machine is in the \ref DEVICE_STATE_Configured state or
+                        *       the call will fail.
                         *
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
                         */
                        void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
 
                         */
                        void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);
 
-                       /** Creates a standard characer stream for the given CDC Device instance so that it can be used with all the regular
+                       /** Creates a standard character stream for the given CDC Device instance so that it can be used with all the regular
                         *  functions in the avr-libc <stdio.h> library that accept a FILE stream as a destination (e.g. fprintf). The created
                         *  stream is bidirectional and can be used for both input and output functions.
                         *
                         *  functions in the avr-libc <stdio.h> library that accept a FILE stream as a destination (e.g. fprintf). The created
                         *  stream is bidirectional and can be used for both input and output functions.
                         *
@@ -289,43 +300,48 @@
                         *  \note The created stream can be given as stdout if desired to direct the standard output from all <stdio.h> functions
                         *        to the given CDC interface.
                         *
                         *  \note The created stream can be given as stdout if desired to direct the standard output from all <stdio.h> functions
                         *        to the given CDC interface.
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
-                        *  \param[in,out] Stream  Pointer to a FILE structure where the created stream should be placed
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
+                        *  \param[in,out] Stream            Pointer to a FILE structure where the created stream should be placed.
                         */
                         */
-                       void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, FILE* Stream);
+                       void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
+                                                    FILE* const Stream) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
 
                        /** Identical to CDC_Device_CreateStream(), except that reads are blocking until the calling stream function terminates
                         *  the transfer. While blocking, the USB and CDC service tasks are called repeatedly to maintain USB communications.
                         *
 
                        /** Identical to CDC_Device_CreateStream(), except that reads are blocking until the calling stream function terminates
                         *  the transfer. While blocking, the USB and CDC service tasks are called repeatedly to maintain USB communications.
                         *
-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state
-                        *  \param[in,out] Stream  Pointer to a FILE structure where the created stream should be placed
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.
+                        *  \param[in,out] Stream            Pointer to a FILE structure where the created stream should be placed.
                         */
                         */
-                       void CDC_Device_CreateBlockingStream(USB_ClassInfo_CDC_Device_t* CDCInterfaceInfo, FILE* Stream);
+                       void CDC_Device_CreateBlockingStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
+                                                            FILE* const Stream) ATTR_NON_NULL_PTR_ARG(1) ATTR_NON_NULL_PTR_ARG(2);
 
        /* Private Interface - For use in library only: */
        #if !defined(__DOXYGEN__)
                /* Function Prototypes: */
                        #if defined(__INCLUDE_FROM_CDC_CLASS_DEVICE_C)
 
        /* Private Interface - For use in library only: */
        #if !defined(__DOXYGEN__)
                /* Function Prototypes: */
                        #if defined(__INCLUDE_FROM_CDC_CLASS_DEVICE_C)
-                               static int CDC_Device_putchar(char c, FILE* Stream);
-                               static int CDC_Device_getchar(FILE* Stream);
-                               static int CDC_Device_getchar_Blocking(FILE* Stream);
-                               
+                               static int CDC_Device_putchar(char c,
+                                                             FILE* Stream) ATTR_NON_NULL_PTR_ARG(2);
+                               static int CDC_Device_getchar(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1);
+                               static int CDC_Device_getchar_Blocking(FILE* Stream) ATTR_NON_NULL_PTR_ARG(1);
+
                                void CDC_Device_Event_Stub(void);
                                void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
                                void CDC_Device_Event_Stub(void);
                                void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
-                                                                                                                 ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Device_Event_Stub);
+                                                                         ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Device_Event_Stub);
                                void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
                                void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
-                                                                                                                        ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Device_Event_Stub);
-                               void EVENT_CDC_Device_BreakSent(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, uint8_t Duration)
-                                                               ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Device_Event_Stub);
+                                                                            ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Device_Event_Stub);
+                               void EVENT_CDC_Device_BreakSent(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
+                                                               const uint8_t Duration) ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1)
+                                                               ATTR_ALIAS(CDC_Device_Event_Stub);
                        #endif
 
        #endif
                        #endif
 
        #endif
-       
+
        /* Disable C linkage for C++ Compilers: */
                #if defined(__cplusplus)
                        }
                #endif
        /* Disable C linkage for C++ Compilers: */
                #if defined(__cplusplus)
                        }
                #endif
-               
+
 #endif
 
 /** @} */
 #endif
 
 /** @} */
+
USB isp AVR programmer