More work on the Mass Storage Host mode Class driver.

Added  ATTR_NON_NULL_PTR_ARG() attributes to the class drivers to improve user code reliability by disallowing explicit NULL pointers as pointer parameters in function calls where the parameter must not be NULL.

Disabled building of the Demos/Host/ClassDriver directory until Host Mode Class drivers are complete to prevent build errors in the meantime.

diff --git a/Demos/Host/ClassDriver/MassStorageHost/MassStorageHost.c b/Demos/Host/ClassDriver/MassStorageHost/MassStorageHost.c
index 19c77c3..0f9134f 100644 (file)
--- a/Demos/Host/ClassDriver/MassStorageHost/MassStorageHost.c
+++ b/Demos/Host/ClassDriver/MassStorageHost/MassStorageHost.c
@@ -132,8 +132,8 @@ int main(void)
 \r
                                printf("Vendor \"%.8s\", Product \"%.16s\"\r\n", InquiryData.VendorID, InquiryData.ProductID);\r
                                \r
 \r
                                printf("Vendor \"%.8s\", Product \"%.16s\"\r\n", InquiryData.VendorID, InquiryData.ProductID);\r
                                \r

+                               printf("Waiting until ready...\r\n");\r

                                bool DeviceReady;\r
                                bool DeviceReady;\r

-                               printf("Waiting until ready...\r\n"));\r

 \r
                                do\r
                                {\r
 \r
                                do\r
                                {\r


@@ -150,7 +150,7 @@ int main(void)
                                puts_P(PSTR("Retrieving Capacity... "));\r
 \r
                                SCSI_Capacity_t DiskCapacity;\r
                                puts_P(PSTR("Retrieving Capacity... "));\r
 \r
                                SCSI_Capacity_t DiskCapacity;\r

-                               if (MS_Host_ReadDeviceCapacity(0, &DiskCapacity))\r
+                               if (MS_Host_ReadDeviceCapacity(&FlashDisk_MS_Interface, 0, &DiskCapacity))\r

                                {\r
                                        printf("Error retrieving device capacity.\r\n");\r
                                        LEDs_SetAllLEDs(LEDMASK_USB_ERROR);\r
                                {\r
                                        printf("Error retrieving device capacity.\r\n");\r
                                        LEDs_SetAllLEDs(LEDMASK_USB_ERROR);\r

diff --git a/LUFA/Drivers/USB/Class/Device/Audio.h b/LUFA/Drivers/USB/Class/Device/Audio.h
index b1c5046..12a8acd 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/Audio.h
+++ b/LUFA/Drivers/USB/Class/Device/Audio.h
@@ -104,21 +104,21 @@
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r

-                       bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);\r
+                       bool Audio_Device_ConfigureEndpoints(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Processes incomming control requests from the host, that are directed to the given Audio class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.\r
                         *\r
                         *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
                         */\r
 \r
                        /** Processes incomming control requests from the host, that are directed to the given Audio class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.\r
                         *\r
                         *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
                         */\r

-                       void Audio_Device_ProcessControlRequest(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);\r
+                       void Audio_Device_ProcessControlRequest(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** General management task for a given Audio class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                         *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
                         */\r
 \r
                        /** General management task for a given Audio class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                         *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
                         */\r

-                       void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);\r
+                       void Audio_Device_USBTask(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** Reads the next 8-bit audio sample from the current audio interface.\r
                         *\r
                        \r
                        /** Reads the next 8-bit audio sample from the current audio interface.\r
                         *\r


@@ -129,7 +129,7 @@
                         *\r
                         *  \return  Signed 8-bit audio sample from the audio interface\r
                         */\r
                         *\r
                         *  \return  Signed 8-bit audio sample from the audio interface\r
                         */\r

-                       int8_t Audio_Device_ReadSample8(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);\r
+                       int8_t Audio_Device_ReadSample8(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Reads the next 16-bit audio sample from the current audio interface.\r
                         *\r
 \r
                        /** Reads the next 16-bit audio sample from the current audio interface.\r
                         *\r


@@ -140,7 +140,7 @@
                         *\r
                         *  \return  Signed 16-bit audio sample from the audio interface\r
                         */\r
                         *\r
                         *  \return  Signed 16-bit audio sample from the audio interface\r
                         */\r

-                       int16_t Audio_Device_ReadSample16(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);\r
+                       int16_t Audio_Device_ReadSample16(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Reads the next 24-bit audio sample from the current audio interface.\r
                         *\r
 \r
                        /** Reads the next 24-bit audio sample from the current audio interface.\r
                         *\r


@@ -150,7 +150,7 @@
                         *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
                         *  \return  Signed 24-bit audio sample from the audio interface\r
                         */\r
                         *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
                         *  \return  Signed 24-bit audio sample from the audio interface\r
                         */\r

-                       int32_t Audio_Device_ReadSample24(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);\r
+                       int32_t Audio_Device_ReadSample24(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Writes the next 8-bit audio sample to the current audio interface.\r
                         *\r
 \r
                        /** Writes the next 8-bit audio sample to the current audio interface.\r
                         *\r


@@ -160,7 +160,7 @@
                         *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
                         *  \param[in] Sample  Signed 8-bit audio sample\r
                         */\r
                         *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
                         *  \param[in] Sample  Signed 8-bit audio sample\r
                         */\r

-                       void Audio_Device_WriteSample8(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo, const int8_t Sample);\r
+                       void Audio_Device_WriteSample8(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo, const int8_t Sample) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Writes the next 16-bit audio sample to the current audio interface.\r
                         *\r
 \r
                        /** Writes the next 16-bit audio sample to the current audio interface.\r
                         *\r


@@ -170,7 +170,7 @@
                         *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
                         *  \param[in] Sample  Signed 16-bit audio sample\r
                         */\r
                         *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
                         *  \param[in] Sample  Signed 16-bit audio sample\r
                         */\r

-                       void Audio_Device_WriteSample16(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo, const int16_t Sample);\r
+                       void Audio_Device_WriteSample16(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo, const int16_t Sample) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Writes the next 24-bit audio sample to the current audio interface.\r
                         *\r
 \r
                        /** Writes the next 24-bit audio sample to the current audio interface.\r
                         *\r


@@ -180,7 +180,7 @@
                         *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
                         *  \param[in] Sample  Signed 24-bit audio sample\r
                         */\r
                         *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.\r
                         *  \param[in] Sample  Signed 24-bit audio sample\r
                         */\r

-                       void Audio_Device_WriteSample24(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo, const int32_t Sample);\r
+                       void Audio_Device_WriteSample24(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo, const int32_t Sample) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Determines if the given audio interface is ready for a sample to be read from it.\r
                         *\r
 \r
                        /** Determines if the given audio interface is ready for a sample to be read from it.\r
                         *\r


@@ -188,7 +188,7 @@
                         *\r
                         *  \return Boolean true if the given Audio interface has a sample to be read, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the given Audio interface has a sample to be read, false otherwise\r
                         */\r

-                       bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);\r
+                       bool Audio_Device_IsSampleReceived(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Determines if the given audio interface is ready to accept the next sample to be written to it.\r
                         *\r
 \r
                        /** Determines if the given audio interface is ready to accept the next sample to be written to it.\r
                         *\r


@@ -196,7 +196,7 @@
                         *\r
                         *  \return Boolean true if the given Audio interface is ready to accept the next sample, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the given Audio interface is ready to accept the next sample, false otherwise\r
                         */\r

-                       bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo);\r
+                       bool Audio_Device_IsReadyForNextSample(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r
 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r

diff --git a/LUFA/Drivers/USB/Class/Device/CDC.h b/LUFA/Drivers/USB/Class/Device/CDC.h
index 99f8eb2..dcb1762 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/CDC.h
+++ b/LUFA/Drivers/USB/Class/Device/CDC.h
@@ -115,21 +115,21 @@
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r

-                       bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r
+                       bool CDC_Device_ConfigureEndpoints(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Processes incomming control requests from the host, that are directed to the given CDC class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.\r
                         *\r
                         *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
                         */\r
 \r
                        /** Processes incomming control requests from the host, that are directed to the given CDC class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.\r
                         *\r
                         *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
                         */\r

-                       void CDC_Device_ProcessControlRequest(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r
+                       void CDC_Device_ProcessControlRequest(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** General management task for a given CDC class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                         *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
                         */\r
 \r
                        /** General management task for a given CDC class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                         *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
                         */\r

-                       void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r
+                       void CDC_Device_USBTask(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** CDC class driver event for a line encoding change on a CDC interface. This event fires each time the host requests a\r
                         *  line encoding change (containing the serial parity, baud and other configuration information) and may be hooked in the\r
 \r
                        /** CDC class driver event for a line encoding change on a CDC interface. This event fires each time the host requests a\r
                         *  line encoding change (containing the serial parity, baud and other configuration information) and may be hooked in the\r


@@ -138,7 +138,7 @@
                         *\r
                         *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
                         */\r
                         *\r
                         *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
                         */\r

-                       void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r
+                       void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** CDC class driver event for a control line state change on a CDC interface. This event fires each time the host requests a\r
                         *  control line state change (containing the virtual serial control line states, such as DTR) and may be hooked in the\r
                        \r
                        /** CDC class driver event for a control line state change on a CDC interface. This event fires each time the host requests a\r
                         *  control line state change (containing the virtual serial control line states, such as DTR) and may be hooked in the\r


@@ -148,7 +148,7 @@
                         *\r
                         *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
                         */\r
                         *\r
                         *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
                         */\r

-                       void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r
+                       void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Sends a given string to the attached USB host, if connected. If a host is not connected when the function is called, the\r
                         *  string is discarded.\r
 \r
                        /** Sends a given string to the attached USB host, if connected. If a host is not connected when the function is called, the\r
                         *  string is discarded.\r


@@ -159,7 +159,7 @@
                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum\r
                         */\r
                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum\r
                         */\r

-                       uint8_t CDC_Device_SendString(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, char* const Data, const uint16_t Length);\r
+                       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, 2);\r

                        \r
                        /** Sends a given byte to the attached USB host, if connected. If a host is not connected when the function is called, the\r
                         *  byte is discarded.\r
                        \r
                        /** Sends a given byte to the attached USB host, if connected. If a host is not connected when the function is called, the\r
                         *  byte is discarded.\r


@@ -169,7 +169,7 @@
                         *\r
                         *  \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum\r
                         */\r
                         *\r
                         *  \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum\r
                         */\r

-                       uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data);\r
+                       uint8_t CDC_Device_SendByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t Data) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** Determines the number of bytes received by the CDC interface from the host, waiting to be read.\r
                         *\r
                        \r
                        /** Determines the number of bytes received by the CDC interface from the host, waiting to be read.\r
                         *\r


@@ -177,7 +177,7 @@
                         *\r
                         *  \return Total number of buffered bytes received from the host\r
                         */\r
                         *\r
                         *  \return Total number of buffered bytes received from the host\r
                         */\r

-                       uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r
+                       uint16_t CDC_Device_BytesReceived(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** 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\r
                         *  returns 0. The \ref CDC_Device_BytesReceived() function should be queried before data is recieved to ensure that no data\r
                        \r
                        /** 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\r
                         *  returns 0. The \ref CDC_Device_BytesReceived() function should be queried before data is recieved to ensure that no data\r


@@ -187,7 +187,7 @@
                         *\r
                         *  \return Next received byte from the host, or 0 if no data received\r
                         */\r
                         *\r
                         *  \return Next received byte from the host, or 0 if no data received\r
                         */\r

-                       uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r
+                       uint8_t CDC_Device_ReceiveByte(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** Flushes any data waiting to be sent, ensuring that the send buffer is cleared.\r
                         *\r
                        \r
                        /** Flushes any data waiting to be sent, ensuring that the send buffer is cleared.\r
                         *\r


@@ -195,7 +195,7 @@
                         *\r
                         *  \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum\r
                         */\r
                         *\r
                         *  \return A value from the \ref Endpoint_WaitUntilReady_ErrorCodes_t enum\r
                         */\r

-                       uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r
+                       uint8_t CDC_Device_Flush(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** Sends a Serial Control Line State Change notification to the host. This should be called when the virtual serial\r
                         *  control lines (DCD, DSR, etc.) have changed states, or to give BREAK notfications to the host. Line states persist\r
                        \r
                        /** Sends a Serial Control Line State Change notification to the host. This should be called when the virtual serial\r
                         *  control lines (DCD, DSR, etc.) have changed states, or to give BREAK notfications to the host. Line states persist\r


@@ -204,7 +204,7 @@
                         *\r
                         *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
                         */\r
                         *\r
                         *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class configuration and state.\r
                         */\r

-                       void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);\r
+                       void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
 \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r


@@ -212,9 +212,9 @@
                        #if defined(INCLUDE_FROM_CDC_CLASS_DEVICE_C)\r
                                void CDC_Device_Event_Stub(void);\r
                                void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)\r
                        #if defined(INCLUDE_FROM_CDC_CLASS_DEVICE_C)\r
                                void CDC_Device_Event_Stub(void);\r
                                void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)\r

-                                                                                                                 ATTR_WEAK ATTR_ALIAS(CDC_Device_Event_Stub);\r
+                                                                                                                 ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Device_Event_Stub);\r

                                void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)\r
                                void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)\r

-                                                                                                                        ATTR_WEAK ATTR_ALIAS(CDC_Device_Event_Stub);\r
+                                                                                                                        ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Device_Event_Stub);\r

                        #endif\r
 \r
        #endif\r
                        #endif\r
 \r
        #endif\r

diff --git a/LUFA/Drivers/USB/Class/Device/HID.h b/LUFA/Drivers/USB/Class/Device/HID.h
index d995c09..e3f091b 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/HID.h
+++ b/LUFA/Drivers/USB/Class/Device/HID.h
@@ -102,21 +102,21 @@
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r

-                       bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);\r
+                       bool HID_Device_ConfigureEndpoints(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** Processes incomming control requests from the host, that are directed to the given HID class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.\r
                         *\r
                         *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r
                         */             \r
                        \r
                        /** Processes incomming control requests from the host, that are directed to the given HID class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.\r
                         *\r
                         *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r
                         */             \r

-                       void HID_Device_ProcessControlRequest(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);\r
+                       void HID_Device_ProcessControlRequest(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** General management task for a given HID class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                         *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r
                         */\r
 \r
                        /** General management task for a given HID class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                         *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r
                         */\r

-                       void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);\r
+                       void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** Indicates that a millisecond of idle time has elapsed on the given HID interface, and the interface's idle count should be\r
                         *  decremented. This should be called once per millisecond so that hardware key-repeats function correctly. It is recommended\r
                        \r
                        /** Indicates that a millisecond of idle time has elapsed on the given HID interface, and the interface's idle count should be\r
                         *  decremented. This should be called once per millisecond so that hardware key-repeats function correctly. It is recommended\r


@@ -125,7 +125,7 @@
                         *\r
                         *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r
                         */\r
                         *\r
                         *  \param[in,out] HIDInterfaceInfo  Pointer to a structure containing a HID Class configuration and state.\r
                         */\r

-                       void HID_Device_MillisecondElapsed(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo);\r
+                       void HID_Device_MillisecondElapsed(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** HID class driver callback for the user creation of a HID input report. This callback may fire in response to either\r
                         *  HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback the\r
                        \r
                        /** HID class driver callback for the user creation of a HID input report. This callback may fire in response to either\r
                         *  HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback the\r


@@ -142,7 +142,7 @@
                         *          the idle period (useful for devices which report relative movement), false otherwise\r
                         */\r
                        bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,\r
                         *          the idle period (useful for devices which report relative movement), false otherwise\r
                         */\r
                        bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,\r

-                                                     void* ReportData, uint16_t* ReportSize);\r
+                                                     void* ReportData, uint16_t* ReportSize) ATTR_NON_NULL_PTR_ARG(1, 2, 3, 4);\r

                        \r
                        /** HID class driver callback for the user processing of a received HID input report. This callback may fire in response to\r
                         *  either HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback\r
                        \r
                        /** HID class driver callback for the user processing of a received HID input report. This callback may fire in response to\r
                         *  either HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback\r


@@ -155,7 +155,7 @@
                         *  \param[in] ReportSize  Size in bytes of the received report from the host.\r
                         */\r
                        void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,\r
                         *  \param[in] ReportSize  Size in bytes of the received report from the host.\r
                         */\r
                        void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,\r

-                                                                 const void* ReportData, const uint16_t ReportSize);\r
+                                                                 const void* ReportData, const uint16_t ReportSize) ATTR_NON_NULL_PTR_ARG(1, 3);\r

 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r
 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r

diff --git a/LUFA/Drivers/USB/Class/Device/MIDI.h b/LUFA/Drivers/USB/Class/Device/MIDI.h
index ce6778f..c7f7bd9 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/MIDI.h
+++ b/LUFA/Drivers/USB/Class/Device/MIDI.h
@@ -93,21 +93,21 @@
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r

-                       bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);\r
+                       bool MIDI_Device_ConfigureEndpoints(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** Processes incomming control requests from the host, that are directed to the given MIDI class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.\r
                         *\r
                         *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r
                         */             \r
                        \r
                        /** Processes incomming control requests from the host, that are directed to the given MIDI class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.\r
                         *\r
                         *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r
                         */             \r

-                       void MIDI_Device_ProcessControlRequest(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);\r
+                       void MIDI_Device_ProcessControlRequest(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** General management task for a given MIDI class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                         *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r
                         */\r
 \r
                        /** General management task for a given MIDI class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                         *  \param[in,out] MIDIInterfaceInfo  Pointer to a structure containing a MIDI Class configuration and state.\r
                         */\r

-                       void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo);\r
+                       void MIDI_Device_USBTask(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Sends a MIDI event packet to the host. If no host is connected, the event packet is discarded.\r
                         *\r
 \r
                        /** Sends a MIDI event packet to the host. If no host is connected, the event packet is discarded.\r
                         *\r


@@ -116,7 +116,8 @@
                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum                   \r
                         */\r
                         *\r
                         *  \return A value from the \ref Endpoint_Stream_RW_ErrorCodes_t enum                   \r
                         */\r

-                       uint8_t MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event);\r
+                       uint8_t MIDI_Device_SendEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo,\r
+                                                           MIDI_EventPacket_t* const Event) ATTR_NON_NULL_PTR_ARG(1, 2);\r

 \r
                        /** Receives a MIDI event packet from the host.\r
                         *\r
 \r
                        /** Receives a MIDI event packet from the host.\r
                         *\r


@@ -125,7 +126,8 @@
                         *\r
                         *  \return Boolean true if a MIDI event packet was received, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if a MIDI event packet was received, false otherwise\r
                         */\r

-                       bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo, MIDI_EventPacket_t* const Event);\r
+                       bool MIDI_Device_ReceiveEventPacket(USB_ClassInfo_MIDI_Device_t* const MIDIInterfaceInfo,\r
+                                                           MIDI_EventPacket_t* const Event) ATTR_NON_NULL_PTR_ARG(1, 2);\r

 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r
 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r

diff --git a/LUFA/Drivers/USB/Class/Device/MassStorage.h b/LUFA/Drivers/USB/Class/Device/MassStorage.h
index b207c23..4ab4398 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/MassStorage.h
+++ b/LUFA/Drivers/USB/Class/Device/MassStorage.h
@@ -102,21 +102,21 @@
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r

-                       bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);\r
+                       bool MS_Device_ConfigureEndpoints(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** Processes incomming control requests from the host, that are directed to the given Mass Storage class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.\r
                         *\r
                         *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.\r
                         */             \r
                        \r
                        /** Processes incomming control requests from the host, that are directed to the given Mass Storage class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.\r
                         *\r
                         *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state.\r
                         */             \r

-                       void MS_Device_ProcessControlRequest(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);\r
+                       void MS_Device_ProcessControlRequest(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** General management task for a given Mass Storage class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                         *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing a Mass Storage configuration and state.\r
                         */\r
 \r
                        /** General management task for a given Mass Storage class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                         *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing a Mass Storage configuration and state.\r
                         */\r

-                       void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);\r
+                       void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** Mass Storage class driver callback for the user processing of a received SCSI command. This callback will fire each time the\r
                         *  host sends a SCSI command which requires processing by the user application. Inside this callback the user is responsible\r
                        \r
                        /** Mass Storage class driver callback for the user processing of a received SCSI command. This callback will fire each time the\r
                         *  host sends a SCSI command which requires processing by the user application. Inside this callback the user is responsible\r


@@ -127,14 +127,14 @@
                         *\r
                         *  \return Boolean true if the SCSI command was successfully processed, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the SCSI command was successfully processed, false otherwise\r
                         */\r

-                       bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);\r
+                       bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Function Prototypes: */\r
                        #if defined(INCLUDE_FROM_MS_CLASS_DEVICE_C)\r
                \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Function Prototypes: */\r
                        #if defined(INCLUDE_FROM_MS_CLASS_DEVICE_C)\r

-                               static void    MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);\r
-                               static bool    MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo);\r
+                               static void    MS_Device_ReturnCommandStatus(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r
+                               static bool    MS_Device_ReadInCommandBlock(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                                static uint8_t StreamCallback_MS_Device_AbortOnMassStoreReset(void);\r
                        #endif\r
                \r
                                static uint8_t StreamCallback_MS_Device_AbortOnMassStoreReset(void);\r
                        #endif\r
                \r

diff --git a/LUFA/Drivers/USB/Class/Device/RNDIS.h b/LUFA/Drivers/USB/Class/Device/RNDIS.h
index d9a5d7f..4b024d9 100644 (file)
--- a/LUFA/Drivers/USB/Class/Device/RNDIS.h
+++ b/LUFA/Drivers/USB/Class/Device/RNDIS.h
@@ -110,32 +110,32 @@
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r
                         *\r
                         *  \return Boolean true if the endpoints were sucessfully configured, false otherwise\r
                         */\r

-                       bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);\r
+                       bool RNDIS_Device_ConfigureEndpoints(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Processes incomming control requests from the host, that are directed to the given RNDIS class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.\r
                         *\r
                         *  \param[in,out] RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.\r
                         */             \r
 \r
                        /** Processes incomming control requests from the host, that are directed to the given RNDIS class interface. This should be\r
                         *  linked to the library \ref EVENT_USB_Device_UnhandledControlRequest() event.\r
                         *\r
                         *  \param[in,out] RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.\r
                         */             \r

-                       void RNDIS_Device_ProcessControlRequest(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);\r
+                       void RNDIS_Device_ProcessControlRequest(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** General management task for a given HID class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                         *  \param[in,out] RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.\r
                         */\r
                        \r
                        /** General management task for a given HID class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                         *  \param[in,out] RNDISInterfaceInfo  Pointer to a structure containing a RNDIS Class configuration and state.\r
                         */\r

-                       void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);\r
+                       void RNDIS_Device_USBTask(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Function Prototypes: */\r
                #if defined(INCLUDE_FROM_RNDIS_CLASS_DEVICE_C)\r
                \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                /* Function Prototypes: */\r
                #if defined(INCLUDE_FROM_RNDIS_CLASS_DEVICE_C)\r

-                       static void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo);\r
+                       static void RNDIS_Device_ProcessRNDISControlMessage(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, \r
                                                                  const uint32_t OId, void* const QueryData, const uint16_t QuerySize,\r
                        static bool RNDIS_Device_ProcessNDISQuery(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, \r
                                                                  const uint32_t OId, void* const QueryData, const uint16_t QuerySize,\r

-                                                                                             void* ResponseData, uint16_t* const ResponseSize);\r
+                                                                                             void* ResponseData, uint16_t* const ResponseSize) ATTR_NON_NULL_PTR_ARG(1, 5, 6);\r

                        static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, const uint32_t OId,\r
                        static bool RNDIS_Device_ProcessNDISSet(USB_ClassInfo_RNDIS_Device_t* const RNDISInterfaceInfo, const uint32_t OId,\r

-                                                               void* SetData, const uint16_t SetSize); \r
+                                                               void* SetData, const uint16_t SetSize) ATTR_NON_NULL_PTR_ARG(1, 3);\r

                #endif\r
                \r
        #endif\r
                #endif\r
                \r
        #endif\r

diff --git a/LUFA/Drivers/USB/Class/Host/CDC.h b/LUFA/Drivers/USB/Class/Host/CDC.h
index 5baafaf..f3abb29 100644 (file)
--- a/LUFA/Drivers/USB/Class/Host/CDC.h
+++ b/LUFA/Drivers/USB/Class/Host/CDC.h
@@ -122,9 +122,9 @@
                        /** General management task for a given CDC host class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r
                        /** General management task for a given CDC host class interface, required for the correct operation of the interface. This should\r
                         *  be called frequently in the main program loop, before the master USB management task \ref USB_USBTask().\r
                         *\r

-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing an CDC Class host configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing an CDC Class host configuration and state\r

                         */\r
                         */\r

-                       void CDC_Host_USBTask(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo);\r
+                       void CDC_Host_USBTask(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** Host interface configuration routine, to configure a given CDC host interface instance using the Configuration\r
                         *  Descriptor read from an attached USB device. This function automatically updates the given CDC Host instance's\r
                        \r
                        /** Host interface configuration routine, to configure a given CDC host interface instance using the Configuration\r
                         *  Descriptor read from an attached USB device. This function automatically updates the given CDC Host instance's\r


@@ -132,63 +132,63 @@
                         *  This should be called once after the stack has enumerated the attached device, while the host state machine is in\r
                         *  the Addressed state.\r
                         *\r
                         *  This should be called once after the stack has enumerated the attached device, while the host state machine is in\r
                         *  the Addressed state.\r
                         *\r

-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing an CDC Class host configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing an CDC Class host configuration and state\r

                         *  \param[in] ConfigDescriptorLength  Length of the attached device's Configuration Descriptor\r
                         *  \param[in] DeviceConfigDescriptor  Pointer to a buffer containing the attached device's Configuration Descriptor\r
                         */\r
                        uint8_t CDC_Host_ConfigurePipes(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo, uint16_t ConfigDescriptorLength,\r
                         *  \param[in] ConfigDescriptorLength  Length of the attached device's Configuration Descriptor\r
                         *  \param[in] DeviceConfigDescriptor  Pointer to a buffer containing the attached device's Configuration Descriptor\r
                         */\r
                        uint8_t CDC_Host_ConfigurePipes(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo, uint16_t ConfigDescriptorLength,\r

-                                                       uint8_t* DeviceConfigDescriptor);\r
+                                                       uint8_t* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1, 3);\r

                        \r
                        /** Sets the line encoding for the attached device's virtual serial port. This should be called when the LineEncoding\r
                         *  values of the interface have been changed to push the new settings to the USB device.\r
                         *\r
                        \r
                        /** Sets the line encoding for the attached device's virtual serial port. This should be called when the LineEncoding\r
                         *  values of the interface have been changed to push the new settings to the USB device.\r
                         *\r

-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state\r

                         */\r
                         */\r

-                       uint8_t CDC_Host_SetLineEncoding(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo);\r
+                       uint8_t CDC_Host_SetLineEncoding(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Sends a Serial Control Line State Change notification to the device. This should be called when the virtual serial\r
                         *  control lines (DTR, RTS, etc.) have changed states. Line states persist until they are cleared via a second\r
                         *  notification. This should be called each time the CDC class driver's ControlLineStates.HostToDevice value is updated\r
                         *  to push the new states to the USB device.\r
                         *\r
 \r
                        /** Sends a Serial Control Line State Change notification to the device. This should be called when the virtual serial\r
                         *  control lines (DTR, RTS, etc.) have changed states. Line states persist until they are cleared via a second\r
                         *  notification. This should be called each time the CDC class driver's ControlLineStates.HostToDevice value is updated\r
                         *  to push the new states to the USB device.\r
                         *\r

-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state\r

                         */\r
                         */\r

-                       uint8_t CDC_Host_SendControlLineStateChange(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo);\r
+                       uint8_t CDC_Host_SendControlLineStateChange(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** Sends a given string to the attached USB device, if connected. If a device is not connected when the function is called, the\r
                         *  string is discarded.\r
                         *\r
                        \r
                        /** Sends a given string to the attached USB device, if connected. If a device is not connected when the function is called, the\r
                         *  string is discarded.\r
                         *\r

-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state\r

                         *  \param[in] Data  Pointer to the string to send to the device\r
                         *  \param[in] Length  Size in bytes of the string to send to the device\r
                         */\r
                         *  \param[in] Data  Pointer to the string to send to the device\r
                         *  \param[in] Length  Size in bytes of the string to send to the device\r
                         */\r

-                       void CDC_Host_SendString(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo, char* Data, uint16_t Length);\r
+                       void CDC_Host_SendString(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo, char* Data, uint16_t Length) ATTR_NON_NULL_PTR_ARG(1, 2);\r

                        \r
                        /** Sends a given byte to the attached USB device, if connected. If a host is not connected when the function is called, the\r
                         *  byte is discarded.\r
                         *\r
                        \r
                        /** Sends a given byte to the attached USB device, if connected. If a host is not connected when the function is called, the\r
                         *  byte is discarded.\r
                         *\r

-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state\r

                         *  \param[in] Data  Byte of data to send to the device\r
                         */\r
                         *  \param[in] Data  Byte of data to send to the device\r
                         */\r

-                       void CDC_Host_SendByte(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo, uint8_t Data);\r
+                       void CDC_Host_SendByte(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo, uint8_t Data) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Determines the number of bytes received by the CDC interface from the device, waiting to be read.\r
                         *\r
 \r
                        /** Determines the number of bytes received by the CDC interface from the device, waiting to be read.\r
                         *\r

-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state\r

                         *\r
                         *  \return Total number of buffered bytes received from the device\r
                         */\r
                         *\r
                         *  \return Total number of buffered bytes received from the device\r
                         */\r

-                       uint16_t CDC_Host_BytesReceived(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo);\r
+                       uint16_t CDC_Host_BytesReceived(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
                        /** Reads a byte of data from the device. If no data is waiting to be read of if a USB device is not connected, the function\r
                         *  returns 0. The \ref CDC_Host_BytesReceived() function should be queried before data is recieved to ensure that no data\r
                         *  underflow occurs.\r
                         *\r
 \r
                        /** Reads a byte of data from the device. If no data is waiting to be read of if a USB device is not connected, the function\r
                         *  returns 0. The \ref CDC_Host_BytesReceived() function should be queried before data is recieved to ensure that no data\r
                         *  underflow occurs.\r
                         *\r

-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state\r

                         *\r
                         *  \return Next received byte from the device, or 0 if no data received\r
                         */\r
                         *\r
                         *  \return Next received byte from the device, or 0 if no data received\r
                         */\r

-                       uint8_t CDC_Host_ReceiveByte(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo);\r
+                       uint8_t CDC_Host_ReceiveByte(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        \r
                        /** CDC class driver event for a control line state change on a CDC host interface. This event fires each time the device notifies\r
                         *  the host of a control line state change (containing the virtual serial control line states, such as DCD) and may be hooked in the\r
                        \r
                        /** CDC class driver event for a control line state change on a CDC host interface. This event fires each time the device notifies\r
                         *  the host of a control line state change (containing the virtual serial control line states, such as DCD) and may be hooked in the\r


@@ -196,9 +196,9 @@
                         *  are available in the ControlLineStates.DeviceToHost value inside the CDC host interface structure passed as a parameter, set as\r
                         *  a mask of CDC_CONTROL_LINE_IN_* masks.\r
                         *\r
                         *  are available in the ControlLineStates.DeviceToHost value inside the CDC host interface structure passed as a parameter, set as\r
                         *  a mask of CDC_CONTROL_LINE_IN_* masks.\r
                         *\r

-                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state.\r
+                        *  \param[in,out] CDCInterfaceInfo  Pointer to a structure containing a CDC Class host configuration and state\r

                         */\r
                         */\r

-                       void EVENT_CDC_Host_ControLineStateChanged(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo);\r
+                       void EVENT_CDC_Host_ControLineStateChanged(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

 \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
 \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r


@@ -218,9 +218,9 @@
                        #if defined(INCLUDE_FROM_CDC_CLASS_HOST_C)\r
                                void CDC_Host_Event_Stub(void);\r
                                void EVENT_CDC_Host_ControLineStateChanged(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo)\r
                        #if defined(INCLUDE_FROM_CDC_CLASS_HOST_C)\r
                                void CDC_Host_Event_Stub(void);\r
                                void EVENT_CDC_Host_ControLineStateChanged(USB_ClassInfo_CDC_Host_t* CDCInterfaceInfo)\r

-                                                                          ATTR_WEAK ATTR_ALIAS(CDC_Host_Event_Stub);\r
-                               static uint8_t DComp_CDC_Host_NextCDCControlInterface(void* CurrentDescriptor);\r
-                               static uint8_t DComp_CDC_Host_NextCDCDataInterface(void* CurrentDescriptor);\r
+                                                                          ATTR_WEAK ATTR_NON_NULL_PTR_ARG(1) ATTR_ALIAS(CDC_Host_Event_Stub);\r
+                               static uint8_t DComp_CDC_Host_NextCDCControlInterface(void* CurrentDescriptor) ATTR_NON_NULL_PTR_ARG(1);\r
+                               static uint8_t DComp_CDC_Host_NextCDCDataInterface(void* CurrentDescriptor) ATTR_NON_NULL_PTR_ARG(1);\r

                                static uint8_t DComp_CDC_Host_NextInterfaceCDCDataEndpoint(void* CurrentDescriptor);\r
                        #endif  \r
        #endif\r
                                static uint8_t DComp_CDC_Host_NextInterfaceCDCDataEndpoint(void* CurrentDescriptor);\r
                        #endif  \r
        #endif\r

diff --git a/LUFA/Drivers/USB/Class/Host/HID.h b/LUFA/Drivers/USB/Class/Host/HID.h
index 3d7a539..6e1a522 100644 (file)
--- a/LUFA/Drivers/USB/Class/Host/HID.h
+++ b/LUFA/Drivers/USB/Class/Host/HID.h
@@ -104,12 +104,12 @@
                        } HIDHost_EnumerationFailure_ErrorCodes_t;\r
        \r
                /* Function Prototypes: */\r
                        } HIDHost_EnumerationFailure_ErrorCodes_t;\r
        \r
                /* Function Prototypes: */\r

-                       void HID_Host_USBTask(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo);\r
+                       void HID_Host_USBTask(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r

                        uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo, uint16_t ConfigDescriptorLength,\r
                        uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo, uint16_t ConfigDescriptorLength,\r

-                                                       uint8_t* DeviceConfigDescriptor);\r
+                                                       uint8_t* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1, 3);\r

 \r
 \r

-                       bool    HID_Host_IsReportReceived(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo);\r
-                       uint8_t USB_HID_Host_SetProtocol(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo, bool UseReportProtocol);\r
+                       bool    HID_Host_IsReportReceived(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r
+                       uint8_t USB_HID_Host_SetProtocol(USB_ClassInfo_HID_Host_t* HIDInterfaceInfo, bool UseReportProtocol) ATTR_NON_NULL_PTR_ARG(1);\r

                \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r


@@ -121,8 +121,8 @@
 \r
                /* Function Prototypes: */\r
                        #if defined(INCLUDE_FROM_HID_CLASS_HOST_C)\r
 \r
                /* Function Prototypes: */\r
                        #if defined(INCLUDE_FROM_HID_CLASS_HOST_C)\r

-                               static uint8_t DComp_HID_Host_NextHIDInterface(void* CurrentDescriptor);\r
-                               static uint8_t DComp_HID_Host_NextInterfaceHIDDataEndpoint(void* CurrentDescriptor);\r
+                               static uint8_t DComp_HID_Host_NextHIDInterface(void* CurrentDescriptor) ATTR_NON_NULL_PTR_ARG(1);\r
+                               static uint8_t DComp_HID_Host_NextInterfaceHIDDataEndpoint(void* CurrentDescriptor) ATTR_NON_NULL_PTR_ARG(1);\r

                        #endif  \r
        #endif  \r
        \r
                        #endif  \r
        #endif  \r
        \r

diff --git a/LUFA/Drivers/USB/Class/Host/MassStorage.c b/LUFA/Drivers/USB/Class/Host/MassStorage.c
index 6332d3a..ea7ed3d 100644 (file)
--- a/LUFA/Drivers/USB/Class/Host/MassStorage.c
+++ b/LUFA/Drivers/USB/Class/Host/MassStorage.c
@@ -131,4 +131,192 @@ void MS_Host_USBTask(USB_ClassInfo_MS_Host_t* MSInterfaceInfo)
        \r
 }\r
 \r
        \r
 }\r
 \r

+static uint8_t MassStore_SendCommand(USB_ClassInfo_MS_Host_t* MSInterfaceInfo, MS_CommandBlockWrapper_t* SCSICommandBlock)\r
+{\r
+       uint8_t ErrorCode = PIPE_RWSTREAM_NoError;\r
+\r
+       if (++MSInterfaceInfo->State.TransactionTag == 0xFFFFFFFF)\r
+         MSInterfaceInfo->State.TransactionTag = 1;\r
+\r
+       Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);\r
+       Pipe_Unfreeze();\r
+\r
+       if ((ErrorCode = Pipe_Write_Stream_LE(SCSICommandBlock, sizeof(MS_CommandBlockWrapper_t))) != PIPE_RWSTREAM_NoError)\r
+         return ErrorCode;\r
+\r
+       Pipe_ClearOUT();\r
+       while(!(Pipe_IsOUTReady()));\r
+\r
+       Pipe_Freeze();\r
+       \r
+       return PIPE_RWSTREAM_NoError;\r
+}\r
+\r
+static uint8_t MassStore_WaitForDataReceived(USB_ClassInfo_MS_Host_t* MSInterfaceInfo)\r
+{\r
+       uint16_t TimeoutMSRem = COMMAND_DATA_TIMEOUT_MS;\r
+\r
+       Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);\r
+       Pipe_Unfreeze();\r
+\r
+       while (!(Pipe_IsINReceived()))\r
+       {\r
+               if (USB_INT_HasOccurred(USB_INT_HSOFI))\r
+               {\r
+                       USB_INT_Clear(USB_INT_HSOFI);\r
+                       TimeoutMSRem--;\r
+\r
+                       if (!(TimeoutMSRem))\r
+                         return PIPE_RWSTREAM_Timeout;\r
+               }\r
+       \r
+               Pipe_Freeze();\r
+               Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);\r
+               Pipe_Unfreeze();\r
+\r
+               if (Pipe_IsStalled())\r
+               {\r
+                       USB_Host_ClearPipeStall(MSInterfaceInfo->Config.DataOUTPipeNumber);\r
+\r
+                       return PIPE_RWSTREAM_PipeStalled;\r
+               }\r
+               \r
+               Pipe_Freeze();\r
+               Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);\r
+               Pipe_Unfreeze();\r
+\r
+               if (Pipe_IsStalled())\r
+               {\r
+                       USB_Host_ClearPipeStall(MSInterfaceInfo->Config.DataINPipeNumber);\r
+\r
+                       return PIPE_RWSTREAM_PipeStalled;\r
+               }\r
+                 \r
+               if (USB_HostState == HOST_STATE_Unattached)\r
+                 return PIPE_RWSTREAM_DeviceDisconnected;\r
+       };\r
+       \r
+       Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);\r
+       Pipe_Freeze();\r
+               \r
+       Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);\r
+       Pipe_Freeze();\r
+\r
+       return PIPE_RWSTREAM_NoError;\r
+}\r
+\r
+static uint8_t MassStore_SendReceiveData(USB_ClassInfo_MS_Host_t* MSInterfaceInfo,\r
+                                         MS_CommandBlockWrapper_t* SCSICommandBlock, void* BufferPtr)\r
+{\r
+       uint8_t  ErrorCode = PIPE_RWSTREAM_NoError;\r
+       uint16_t BytesRem  = SCSICommandBlock->DataTransferLength;\r
+\r
+       if (SCSICommandBlock->Flags & COMMAND_DIRECTION_DATA_IN)\r
+       {\r
+               Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);\r
+               Pipe_Unfreeze();\r
+               \r
+               if ((ErrorCode = Pipe_Read_Stream_LE(BufferPtr, BytesRem)) != PIPE_RWSTREAM_NoError)\r
+                 return ErrorCode;\r
+\r
+               Pipe_ClearIN();\r
+       }\r
+       else\r
+       {\r
+               Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);\r
+               Pipe_Unfreeze();\r
+\r
+               if ((ErrorCode = Pipe_Write_Stream_LE(BufferPtr, BytesRem)) != PIPE_RWSTREAM_NoError)\r
+                 return ErrorCode;\r
+\r
+               Pipe_ClearOUT();\r
+               \r
+               while (!(Pipe_IsOUTReady()))\r
+               {\r
+                       if (USB_HostState == HOST_STATE_Unattached)\r
+                         return PIPE_RWSTREAM_DeviceDisconnected;\r
+               }\r
+       }\r
+\r
+       Pipe_Freeze();\r
+\r
+       return PIPE_RWSTREAM_NoError;\r
+}\r
+\r
+static uint8_t MassStore_GetReturnedStatus(USB_ClassInfo_MS_Host_t* MSInterfaceInfo,\r
+                                           MS_CommandStatusWrapper_t* SCSICommandStatus)\r
+{\r
+       uint8_t ErrorCode = PIPE_RWSTREAM_NoError;\r
+\r
+       if ((ErrorCode = MassStore_WaitForDataReceived(MSInterfaceInfo)) != PIPE_RWSTREAM_NoError)\r
+         return ErrorCode;\r
+\r
+       Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);\r
+       Pipe_Unfreeze();\r
+       \r
+       if ((ErrorCode = Pipe_Read_Stream_LE(&SCSICommandStatus, sizeof(MS_CommandStatusWrapper_t))) != PIPE_RWSTREAM_NoError)\r
+         return ErrorCode;\r
+         \r
+       Pipe_ClearIN();\r
+       Pipe_Freeze();\r
+       \r
+       return PIPE_RWSTREAM_NoError;\r
+}\r
+\r
+uint8_t MS_Host_ResetMSInterface(USB_ClassInfo_MS_Host_t* MSInterfaceInfo)\r
+{\r
+       if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.Active))\r
+         return HOST_SENDCONTROL_DeviceDisconnect;\r
+\r
+       USB_ControlRequest = (USB_Request_Header_t)\r
+               {\r
+                       .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),\r
+                       .bRequest      = REQ_MassStorageReset,\r
+                       .wValue        = 0,\r
+                       .wIndex        = MSInterfaceInfo->State.InterfaceNumber,\r
+                       .wLength       = 0,\r
+               };\r
+       \r
+       Pipe_SelectPipe(PIPE_CONTROLPIPE);\r
+\r
+       return USB_Host_SendControlRequest(NULL);\r
+}\r
+\r
+uint8_t MS_Host_GetMaxLUN(USB_ClassInfo_MS_Host_t* MSInterfaceInfo, uint8_t* MaxLUNIndex)\r
+{\r
+       if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.Active))\r
+         return HOST_SENDCONTROL_DeviceDisconnect;\r
+\r
+       uint8_t ErrorCode;\r
+\r
+       USB_ControlRequest = (USB_Request_Header_t)\r
+               {\r
+                       .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),\r
+                       .bRequest      = REQ_GetMaxLUN,\r
+                       .wValue        = 0,\r
+                       .wIndex        = MSInterfaceInfo->State.InterfaceNumber,\r
+                       .wLength       = 1,\r
+               };\r
+               \r
+       Pipe_SelectPipe(PIPE_CONTROLPIPE);\r
+\r
+       if ((ErrorCode = USB_Host_SendControlRequest(MaxLUNIndex)) == HOST_SENDCONTROL_SetupStalled)\r
+       {\r
+               Pipe_ClearStall();\r
+\r
+               *MaxLUNIndex = 0;\r
+       }\r
+       \r
+       return ErrorCode;\r
+}\r
+\r
+uint8_t MS_Host_GetInquiryData(USB_ClassInfo_MS_Host_t* MSInterfaceInfo, SCSI_Inquiry_Response_t* InquiryData)\r
+{\r
+\r
+}\r
+\r
+uint8_t MS_Host_TestUnitReady(USB_ClassInfo_MS_Host_t* MSInterfaceInfo, uint8_t LUNIndex, bool* DeviceReady);\r
+uint8_t MS_Host_ReadDeviceCapacity(USB_ClassInfo_MS_Host_t* MSInterfaceInfo, uint8_t LUNIndex,\r
+                                   SCSI_Capacity_t* DeviceCapacity);\r
+\r

 #endif\r
 #endif\r

diff --git a/LUFA/Drivers/USB/Class/Host/MassStorage.h b/LUFA/Drivers/USB/Class/Host/MassStorage.h
index 18b2cf4..a8a957b 100644 (file)
--- a/LUFA/Drivers/USB/Class/Host/MassStorage.h
+++ b/LUFA/Drivers/USB/Class/Host/MassStorage.h
@@ -78,25 +78,137 @@
 \r
                                        uint16_t DataINPipeSize; /**< Size in bytes of the MS interface's IN data pipe */\r
                                        uint16_t DataOUTPipeSize;  /**< Size in bytes of the MS interface's OUT data pipe */\r
 \r
                                        uint16_t DataINPipeSize; /**< Size in bytes of the MS interface's IN data pipe */\r
                                        uint16_t DataOUTPipeSize;  /**< Size in bytes of the MS interface's OUT data pipe */\r

+                                       \r
+                                       uint32_t TransactionTag; /**< Current transaction tag for data synchronising of packets */\r

                                } State; /**< State data for the USB class interface within the device. All elements in this section\r
                                                  *   <b>may</b> be set to initial values, but may also be ignored to default to sane values when\r
                                                  *   the interface is enumerated.\r
                                                  */\r
                        } USB_ClassInfo_MS_Host_t;\r
 \r
                                } State; /**< State data for the USB class interface within the device. All elements in this section\r
                                                  *   <b>may</b> be set to initial values, but may also be ignored to default to sane values when\r
                                                  *   the interface is enumerated.\r
                                                  */\r
                        } USB_ClassInfo_MS_Host_t;\r
 \r

+                       /** Type define for a SCSI Sense structure. Structures of this type are filled out by the\r
+                        *  device via the MassStore_RequestSense() function, indicating the current sense data of the\r
+                        *  device (giving explicit error codes for the last issued command). For details of the\r
+                        *  structure contents, refer to the SCSI specifications.\r
+                        */\r
+                       typedef struct\r
+                       {\r
+                               uint8_t       ReponseCode;\r
+\r
+                               uint8_t       SegmentNumber;\r
+                               \r
+                               unsigned char SenseKey            : 4;\r
+                               unsigned char _RESERVED1          : 1;\r
+                               unsigned char ILI                 : 1;\r
+                               unsigned char EOM                 : 1;\r
+                               unsigned char FileMark            : 1;\r
+                               \r
+                               uint8_t      Information[4];\r
+                               uint8_t      AdditionalLength;\r
+                               uint8_t      CmdSpecificInformation[4];\r
+                               uint8_t      AdditionalSenseCode;\r
+                               uint8_t      AdditionalSenseQualifier;\r
+                               uint8_t      FieldReplaceableUnitCode;\r
+                               uint8_t      SenseKeySpecific[3];\r
+                       } SCSI_Request_Sense_Response_t;\r
+\r
+                       /** Type define for a SCSI Inquiry structure. Structures of this type are filled out by the\r
+                        *  device via the MassStore_Inquiry() function, retrieving the attached device's information.\r
+                        *  For details of the structure contents, refer to the SCSI specifications.\r
+                        */\r
+                       typedef struct\r
+                       {\r
+                               unsigned char DeviceType          : 5;\r
+                               unsigned char PeripheralQualifier : 3;\r
+                               \r
+                               unsigned char _RESERVED1          : 7;\r
+                               unsigned char Removable           : 1;\r
+                               \r
+                               uint8_t      Version;\r
+                               \r
+                               unsigned char ResponseDataFormat  : 4;\r
+                               unsigned char _RESERVED2          : 1;\r
+                               unsigned char NormACA             : 1;\r
+                               unsigned char TrmTsk              : 1;\r
+                               unsigned char AERC                : 1;\r
+\r
+                               uint8_t      AdditionalLength;\r
+                               uint8_t      _RESERVED3[2];\r
+\r
+                               unsigned char SoftReset           : 1;\r
+                               unsigned char CmdQue              : 1;\r
+                               unsigned char _RESERVED4          : 1;\r
+                               unsigned char Linked              : 1;\r
+                               unsigned char Sync                : 1;\r
+                               unsigned char WideBus16Bit        : 1;\r
+                               unsigned char WideBus32Bit        : 1;\r
+                               unsigned char RelAddr             : 1;\r
+                               \r
+                               uint8_t      VendorID[8];\r
+                               uint8_t      ProductID[16];\r
+                               uint8_t      RevisionID[4];\r
+                       } SCSI_Inquiry_Response_t;\r
+                       \r
+                       /** SCSI capacity structure, to hold the total capacity of the device in both the number\r
+                        *  of blocks in the current LUN, and the size of each block. This structure is filled by\r
+                        *  the device when the MassStore_ReadCapacity() function is called.\r
+                        */\r
+                       typedef struct\r
+                       {\r
+                               uint32_t Blocks; /**< Number of blocks in the addressed LUN of the device */\r
+                               uint32_t BlockSize; /**< Number of bytes in each block in the addressed LUN */\r
+                       } SCSI_Capacity_t;\r
+\r

                /* Enums: */\r
                        enum\r
                        {\r
                                MS_ENUMERROR_NoError                    = 0, /**< Configuration Descriptor was processed successfully */\r
                                MS_ENUMERROR_InvalidConfigDescriptor    = 1, /**< The device returned an invalid Configuration Descriptor */\r
                /* Enums: */\r
                        enum\r
                        {\r
                                MS_ENUMERROR_NoError                    = 0, /**< Configuration Descriptor was processed successfully */\r
                                MS_ENUMERROR_InvalidConfigDescriptor    = 1, /**< The device returned an invalid Configuration Descriptor */\r

-                               MS_ENUMERROR_NoMSInterfaceFound        = 2, /**< A compatible Mass Storage interface was not found in the device's Configuration Descriptor */\r
+                               MS_ENUMERROR_NoMSInterfaceFound         = 2, /**< A compatible Mass Storage interface was not found in the device's Configuration Descriptor */\r

                                MS_ENUMERROR_EndpointsNotFound          = 3, /**< Compatible Mass Storage endpoints were not found in the device's interfaces */\r
                        } MSHost_EnumerationFailure_ErrorCodes_t;\r
        \r
                /* Function Prototypes: */\r
                                MS_ENUMERROR_EndpointsNotFound          = 3, /**< Compatible Mass Storage endpoints were not found in the device's interfaces */\r
                        } MSHost_EnumerationFailure_ErrorCodes_t;\r
        \r
                /* Function Prototypes: */\r

-                       void MS_Host_USBTask(USB_ClassInfo_MS_Host_t* MSInterfaceInfo);\r
+                       /** General management task for a given Mass Storage host class interface, required for the correct operation of\r
+                        *  the interface. This should be called frequently in the main program loop, before the master USB management task\r
+                        *  \ref USB_USBTask().\r
+                        *\r
+                        *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing an MS Class host configuration and state\r
+                        */\r
+                       void MS_Host_USBTask(USB_ClassInfo_MS_Host_t* MSInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r
+                       \r
+                       /** Host interface configuration routine, to configure a given Mass Storage host interface instance using the\r
+                        *  Configuration Descriptor read from an attached USB device. This function automatically updates the given Mass\r
+                        *  Storage Host instance's state values and configures the pipes required to communicate with the interface if it\r
+                        *  is found within the device. This should be called once after the stack has enumerated the attached device, while\r
+                        *  the host state machine is in the Addressed state.\r
+                        *\r
+                        *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing an MS Class host configuration and state\r
+                        *  \param[in] ConfigDescriptorLength  Length of the attached device's Configuration Descriptor\r
+                        *  \param[in] DeviceConfigDescriptor  Pointer to a buffer containing the attached device's Configuration Descriptor\r
+                        */\r

                        uint8_t MS_Host_ConfigurePipes(USB_ClassInfo_MS_Host_t* MSInterfaceInfo, uint16_t ConfigDescriptorLength,\r
                        uint8_t MS_Host_ConfigurePipes(USB_ClassInfo_MS_Host_t* MSInterfaceInfo, uint16_t ConfigDescriptorLength,\r

-                                                      uint8_t* DeviceConfigDescriptor);\r
+                                                      uint8_t* DeviceConfigDescriptor) ATTR_NON_NULL_PTR_ARG(1, 3);\r
+\r
+                       /** Sends a MASS STORAGE RESET control request to the attached device, resetting the Mass Storage Interface\r
+                        *  and readying it for the next Mass Storage command.\r
+                        *\r
+                        *  \param[in,out] MSInterfaceInfo  Pointer to a structure containing a MS Class host configuration and state\r
+                        *\r
+                        *  \return A value from the \ref USB_Host_SendControlErrorCodes_t enum\r
+                        */\r
+                       uint8_t MS_Host_ResetMSInterface(USB_ClassInfo_MS_Host_t* MSInterfaceInfo) ATTR_NON_NULL_PTR_ARG(1);\r
+\r
+                       uint8_t MS_Host_GetMaxLUN(USB_ClassInfo_MS_Host_t* MSInterfaceInfo, uint8_t* MaxLUNIndex) ATTR_NON_NULL_PTR_ARG(1, 2);\r
+\r
+                       uint8_t MS_Host_GetInquiryData(USB_ClassInfo_MS_Host_t* MSInterfaceInfo,\r
+                                                      SCSI_Inquiry_Response_t* InquiryData) ATTR_NON_NULL_PTR_ARG(1, 2);\r
+\r
+                       uint8_t MS_Host_TestUnitReady(USB_ClassInfo_MS_Host_t* MSInterfaceInfo, uint8_t LUNIndex,\r
+                                                     bool* DeviceReady) ATTR_NON_NULL_PTR_ARG(1, 3);\r
+\r
+                       uint8_t MS_Host_ReadDeviceCapacity(USB_ClassInfo_MS_Host_t* MSInterfaceInfo, uint8_t LUNIndex,\r
+                                                          SCSI_Capacity_t* DeviceCapacity) ATTR_NON_NULL_PTR_ARG(1, 3);\r

                \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r
                \r
        /* Private Interface - For use in library only: */\r
        #if !defined(__DOXYGEN__)\r


@@ -105,6 +217,17 @@
                        #define MASS_STORE_SUBCLASS            0x06\r
                        #define MASS_STORE_PROTOCOL            0x50\r
 \r
                        #define MASS_STORE_SUBCLASS            0x06\r
                        #define MASS_STORE_PROTOCOL            0x50\r
 \r

+                       #define REQ_MassStorageReset           0xFF\r
+                       #define REQ_GetMaxLUN                  0xFE\r
+\r
+                       #define CBW_SIGNATURE                  0x43425355UL\r
+                       #define CSW_SIGNATURE                  0x53425355UL\r
+                       \r
+                       #define COMMAND_DIRECTION_DATA_OUT     (0 << 7)\r
+                       #define COMMAND_DIRECTION_DATA_IN      (1 << 7)\r
+                       \r
+                       #define COMMAND_DATA_TIMEOUT_MS        2000\r
+\r

                        #define MS_FOUND_DATAPIPE_IN           (1 << 0)\r
                        #define MS_FOUND_DATAPIPE_OUT          (1 << 1)\r
                        \r
                        #define MS_FOUND_DATAPIPE_IN           (1 << 0)\r
                        #define MS_FOUND_DATAPIPE_OUT          (1 << 1)\r
                        \r


@@ -112,6 +235,14 @@
                        #if defined(INCLUDE_FROM_MS_CLASS_HOST_C)               \r
                                static uint8_t DComp_NextMassStorageInterface(void* CurrentDescriptor);\r
                                static uint8_t DComp_NextInterfaceBulkDataEndpoint(void* CurrentDescriptor);\r
                        #if defined(INCLUDE_FROM_MS_CLASS_HOST_C)               \r
                                static uint8_t DComp_NextMassStorageInterface(void* CurrentDescriptor);\r
                                static uint8_t DComp_NextInterfaceBulkDataEndpoint(void* CurrentDescriptor);\r

+                               \r
+                               static uint8_t MassStore_SendCommand(USB_ClassInfo_MS_Host_t* MSInterfaceInfo,\r
+                                                                    MS_CommandBlockWrapper_t* SCSICommandBlock);\r
+                               static uint8_t MassStore_WaitForDataReceived(USB_ClassInfo_MS_Host_t* MSInterfaceInfo);\r
+                               static uint8_t MassStore_SendReceiveData(USB_ClassInfo_MS_Host_t* MSInterfaceInfo, \r
+                                                         MS_CommandBlockWrapper_t* SCSICommandBlock, void* BufferPtr);\r
+                               static uint8_t MassStore_GetReturnedStatus(USB_ClassInfo_MS_Host_t* MSInterfaceInfo,\r
+                                                                          MS_CommandStatusWrapper_t* SCSICommandStatus);\r

                        #endif\r
        #endif\r
        \r
                        #endif\r
        #endif\r
        \r

diff --git a/LUFA/ManPages/FutureChanges.txt b/LUFA/ManPages/FutureChanges.txt
index 2f77e39..37b0796 100644 (file)
--- a/LUFA/ManPages/FutureChanges.txt
+++ b/LUFA/ManPages/FutureChanges.txt
@@ -13,11 +13,16 @@
   *\r
   *  <b>Targeted for This Release:</b>\r
   *  - Finish Host Mode Class Drivers\r
   *\r
   *  <b>Targeted for This Release:</b>\r
   *  - Finish Host Mode Class Drivers\r

+  *      ( ) Audio\r
+  *      (C) CDC\r
+  *      (S) HID\r
+  *      ( ) MIDI\r
+  *      (S) Mass Storage\r
+  *      ( ) Still Image\r

   *  - Add overviews of each of the officially supported boards to the manual\r
   *  - Add overviews of each of the officially supported boards to the manual\r

-  *  - Add hub support to match Atmel's stack\r
-  *  - Finish AVRISP Project\r

   *\r
   *  <b>Targeted for Future Releases:</b>\r
   *\r
   *  <b>Targeted for Future Releases:</b>\r

+  *  - Add hub support to match Atmel's stack\r

   *  - Add standardized descriptor names to device and host class driver structures\r
   *  - Remake AVRStudio project files\r
   *  - Add detailed overviews of how each demo works\r
   *  - Add standardized descriptor names to device and host class driver structures\r
   *  - Remake AVRStudio project files\r
   *  - Add detailed overviews of how each demo works\r