USB device stack HID CDC validated

Author: jcbuda

Diff for: cores/arduino/Arduino.h

@@ -81,11 +81,6 @@ void loop( void ) ;
 #include "WInterrupts.h"
 
 // USB Device
-#define USB_VID            0x2341 // arduino LLC vid
-#define USB_PID_LEONARDO   0x0034
-#define USB_PID_MICRO      0x0035
-#define USB_PID_DUE        0x003E
-#define USB_PID_ZERO       0x004D
 #include "USB/USBDesc.h"
 #include "USB/USBCore.h"
 #include "USB/USBAPI.h"

Diff for: cores/arduino/USB/CDC.cpp

@@ -19,20 +19,20 @@
 #include <stdint.h>
 
 // Include Atmel headers
+#include "arduino.h"
 #include "sam.h"
 #include "wiring_constants.h"
 #include "USBCore.h"
 #include "USB_device.h"
 #include "USBDesc.h"
 #include "USBAPI.h"
-//#include "samd21_device.h"
 
 #include "Reset.h"
 
 
 #ifdef CDC_ENABLED
 
-#define CDC_SERIAL_BUFFER_SIZE	512
+#define CDC_SERIAL_BUFFER_SIZE	64
 
 /* For information purpose only since RTS is not always handled by the terminal application */
 #define CDC_LINESTATE_DTR		0x01 // Data Terminal Ready
@@ -58,61 +58,44 @@ typedef struct
 	uint8_t		lineState;
 } LineInfo;
 
+_Pragma("pack(1)")
 static volatile LineInfo _usbLineInfo = { 
-    57600, // dWDTERate
+   115200, // dWDTERate
     0x00,  // bCharFormat
     0x00,  // bParityType
     0x08,  // bDataBits
     0x00   // lineState
 };
 
-_Pragma("pack(1)")
 static const CDCDescriptor _cdcInterface =
 {
-	D_IAD(0,2,CDC_COMMUNICATION_INTERFACE_CLASS,CDC_ABSTRACT_CONTROL_MODEL,1),
-
+#if (defined CDC_ENABLED) && defined(HID_ENABLED)
+	D_IAD(0, 2, CDC_COMMUNICATION_INTERFACE_CLASS, CDC_ABSTRACT_CONTROL_MODEL, 0),
+#endif
 	//	CDC communication interface
 	D_INTERFACE(CDC_ACM_INTERFACE,1,CDC_COMMUNICATION_INTERFACE_CLASS,CDC_ABSTRACT_CONTROL_MODEL,0),
-	D_CDCCS(CDC_HEADER,0x10,0x01),								// Header (1.10 bcd)
-	D_CDCCS(CDC_CALL_MANAGEMENT,1,1),							// Device handles call management (not)
+	D_CDCCS( CDC_HEADER, CDC_V1_10 & 0xFF, (CDC_V1_10>>8) & 0x0FF ),	// Header (1.10 bcd)
+	
 	D_CDCCS4(CDC_ABSTRACT_CONTROL_MANAGEMENT,6),				// SET_LINE_CODING, GET_LINE_CODING, SET_CONTROL_LINE_STATE supported
 	D_CDCCS(CDC_UNION,CDC_ACM_INTERFACE,CDC_DATA_INTERFACE),	// Communication interface is master, data interface is slave 0
-	D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_ACM),USB_ENDPOINT_TYPE_INTERRUPT,0x10, 0x10),
-
-	//	CDC data interface
-	D_INTERFACE(CDC_DATA_INTERFACE,2,CDC_DATA_INTERFACE_CLASS,0,0),
-	D_ENDPOINT(USB_ENDPOINT_OUT(CDC_ENDPOINT_OUT),USB_ENDPOINT_TYPE_BULK,512,0),
-	D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_IN ),USB_ENDPOINT_TYPE_BULK,512,0)
-};
-static const CDCDescriptor _cdcOtherInterface =
-{
-	D_IAD(0,2,CDC_COMMUNICATION_INTERFACE_CLASS,CDC_ABSTRACT_CONTROL_MODEL,1),
-
-	//	CDC communication interface
-	D_INTERFACE(CDC_ACM_INTERFACE,1,CDC_COMMUNICATION_INTERFACE_CLASS,CDC_ABSTRACT_CONTROL_MODEL,0),
-	D_CDCCS(CDC_HEADER,0x10,0x01),								// Header (1.10 bcd)
 	D_CDCCS(CDC_CALL_MANAGEMENT,1,1),							// Device handles call management (not)
-	D_CDCCS4(CDC_ABSTRACT_CONTROL_MANAGEMENT,6),				// SET_LINE_CODING, GET_LINE_CODING, SET_CONTROL_LINE_STATE supported
-	D_CDCCS(CDC_UNION,CDC_ACM_INTERFACE,CDC_DATA_INTERFACE),	// Communication interface is master, data interface is slave 0
 	D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_ACM),USB_ENDPOINT_TYPE_INTERRUPT,0x10, 0x10),
 
 	//	CDC data interface
 	D_INTERFACE(CDC_DATA_INTERFACE,2,CDC_DATA_INTERFACE_CLASS,0,0),
-	D_ENDPOINT(USB_ENDPOINT_OUT(CDC_ENDPOINT_OUT),USB_ENDPOINT_TYPE_BULK,64,0),
-	D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_IN ),USB_ENDPOINT_TYPE_BULK,64,0)
+	D_ENDPOINT(USB_ENDPOINT_OUT(CDC_ENDPOINT_OUT),USB_ENDPOINT_TYPE_BULK,EPX_SIZE,0),
+	D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_IN ),USB_ENDPOINT_TYPE_BULK,EPX_SIZE,0)
 };
 _Pragma("pack()")
 
-int WEAK CDC_GetInterface(uint8_t* interfaceNum)
+const void* WEAK CDC_GetInterface(void)
 {
-	interfaceNum[0] += 2;	// uses 2
-	return USBD_SendControl(0,&_cdcInterface,sizeof(_cdcInterface));
+	return  &_cdcInterface;
 }
 
-int WEAK CDC_GetOtherInterface(uint8_t* interfaceNum)
+uint32_t WEAK CDC_GetInterfaceLength(void)
 {
-	interfaceNum[0] += 2;	// uses 2
-	return USBD_SendControl(0,&_cdcOtherInterface,sizeof(_cdcOtherInterface));
+    return sizeof( _cdcInterface );
 }
 
 bool WEAK CDC_Setup(Setup& setup)
@@ -134,7 +117,7 @@ bool WEAK CDC_Setup(Setup& setup)
 		if (CDC_SET_LINE_CODING == r)
 		{
 			USBD_RecvControl((void*)&_usbLineInfo,7);
-			return true;
+			return false;
 		}
 
 		if (CDC_SET_CONTROL_LINE_STATE == r)
@@ -150,13 +133,13 @@ bool WEAK CDC_Setup(Setup& setup)
 				else
 					cancelReset();
 			}
-			return true;
+			return false;
 		}
 	}
 	return false;
 }
 
-int _serialPeek = -1;
+uint32_t _serialPeek = -1;
 void Serial_::begin(uint32_t baud_count)
 {
 }
@@ -171,16 +154,6 @@ void Serial_::end(void)
 
 void Serial_::accept(void)
 {
-//	static uint32_t guard = 0;
-
-	// synchronized access to guard
-//JCB	do {
-//		if (__LDREXW(&guard) != 0) {
-//			__CLREX();
-//			return;  // busy
-//		}
-//	} while (__STREXW(1, &guard) != 0); // retry until write succeed
-
 	ring_buffer *buffer = &cdc_rx_buffer;
 	uint32_t i = (uint32_t)(buffer->head+1) % CDC_SERIAL_BUFFER_SIZE;
 
@@ -190,27 +163,22 @@ void Serial_::accept(void)
 	// and so we don't write the character or advance the head.
 	while (i != buffer->tail) {
 		uint32_t c;
-		if (!USBD_Available(CDC_RX)) {
-            UDD_ReleaseRX(CDC_RX);
-			//JCB udd_ack_fifocon(CDC_RX);
+		if (!USBD_Available(CDC_ENDPOINT_OUT)) {
+            UDD_ReleaseRX(CDC_ENDPOINT_OUT);
 			break;
 		}
-		c = USBD_Recv(CDC_RX);
-		// c = UDD_Recv8(CDC_RX & 0xF);
+		c = USBD_Recv(CDC_ENDPOINT_OUT);
 		buffer->buffer[buffer->head] = c;
 		buffer->head = i;
 
 		i = (i + 1) % CDC_SERIAL_BUFFER_SIZE;
 	}
-
-	// release the guard
-//	guard = 0;
 }
 
 int Serial_::available(void)
 {
 	ring_buffer *buffer = &cdc_rx_buffer;
-	return (unsigned int)(CDC_SERIAL_BUFFER_SIZE + buffer->head - buffer->tail) % CDC_SERIAL_BUFFER_SIZE;
+	return (uint32_t)(CDC_SERIAL_BUFFER_SIZE + buffer->head - buffer->tail) % CDC_SERIAL_BUFFER_SIZE;
 }
 
 int Serial_::peek(void)
@@ -239,16 +207,16 @@ int Serial_::read(void)
 	else
 	{
 		unsigned char c = buffer->buffer[buffer->tail];
-		buffer->tail = (unsigned int)(buffer->tail + 1) % CDC_SERIAL_BUFFER_SIZE;
-		if (USBD_Available(CDC_RX))
+		buffer->tail = (uint32_t)(buffer->tail + 1) % CDC_SERIAL_BUFFER_SIZE;
+		if (USBD_Available(CDC_ENDPOINT_OUT))
 			accept();
 		return c;
 	}
 }
 
 void Serial_::flush(void)
 {
-	USBD_Flush(CDC_TX);
+	USBD_Flush(CDC_ENDPOINT_IN);
 }
 
 size_t Serial_::write(const uint8_t *buffer, size_t size)
@@ -262,9 +230,9 @@ size_t Serial_::write(const uint8_t *buffer, size_t size)
 	// TODO - ZE - check behavior on different OSes and test what happens if an
 	// open connection isn't broken cleanly (cable is yanked out, host dies
 	// or locks up, or host virtual serial port hangs)
-	if (_usbLineInfo.lineState > 0)
+//	if (_usbLineInfo.lineState > 0)  // Problem with Windows(R)
 	{
-		int r = USBD_Send(CDC_TX, buffer, size);
+		uint32_t r = USBD_Send(CDC_ENDPOINT_IN, buffer, size);
 
 		if (r > 0)
 		{
@@ -293,8 +261,8 @@ size_t Serial_::write(uint8_t c) {
 Serial_::operator bool()
 {
 	// this is here to avoid spurious opening after upload
-//	if (millis() < 500)
-//		return false;
+	if (millis() < 500)
+		return false;
 
 	bool result = false;
 
@@ -303,7 +271,7 @@ Serial_::operator bool()
 		result = true;
 	}
 
-//	delay(10);
+	delay(10);
 	return result;
 }
 

Diff for: cores/arduino/USB/HID.cpp

@@ -14,7 +14,6 @@
 ** SOFTWARE.
 */
 
-#ifdef HID_ENABLED
 
 #include "USBAPI.h"
 #include "Reset.h"
@@ -23,21 +22,18 @@
 #include "sam.h"
 #include "USB_device.h"
 
-//#define RAWHID_ENABLED
-#ifdef __cplusplus
-extern "C"{
-#endif // __cplusplus
 
-//	Singletons for mouse and keyboard
+#ifdef HID_ENABLED
+
+//#define RAWHID_ENABLED
 
+// Singletons for mouse and keyboard
 Mouse_ Mouse;
 Keyboard_ Keyboard;
 
 //================================================================================
 //================================================================================
 
-//	HID report descriptor
-
 #define LSB(_x) ((_x) & 0xFF)
 #define MSB(_x) ((_x) >> 8)
 
@@ -46,6 +42,8 @@ Keyboard_ Keyboard;
 #define RAWHID_TX_SIZE 64
 #define RAWHID_RX_SIZE 64
 
+//	HID report descriptor
+_Pragma("pack(1)")
 extern const uint8_t _hidReportDescriptor[] = {
 	//	Mouse
     0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)	// 54
@@ -129,7 +127,6 @@ extern const uint8_t _hidReportDescriptor[] = {
 #endif
 };
 
-_Pragma("pack(1)")
 extern const HIDDescriptor _hidInterface =
 {
 	D_INTERFACE(HID_INTERFACE,1,3,0,0),
@@ -147,26 +144,37 @@ uint8_t _hid_idle = 1;
 
 #define WEAK __attribute__ ((weak))
 
-int WEAK HID_GetInterface(uint8_t* interfaceNum)
+const void* WEAK HID_GetInterface(void)
+{
+	return  &_hidInterface;
+}
+
+uint32_t WEAK HID_GetInterfaceLength(void)
+{
+    return sizeof( _hidInterface );
+}
+
+uint32_t HID_SizeReportDescriptor(void)
 {
-	interfaceNum[0] += 1;	// uses 1
-	return USBD_SendControl(0,&_hidInterface,sizeof(_hidInterface));
+	return sizeof(_hidReportDescriptor);
 }
 
-int WEAK HID_GetDescriptor(int i)
+uint32_t WEAK HID_GetDescriptor(void)
 {
 	return USBD_SendControl(0,_hidReportDescriptor,sizeof(_hidReportDescriptor));
 }
 
 void WEAK HID_SendReport(uint8_t id, const void* data, uint32_t len)
 {
-	uint8_t p[64];
+	uint8_t p[8];
 	const uint8_t *d = reinterpret_cast<const uint8_t *>(data);
 
 	p[0] = id;
 	for (uint32_t i=0; i<len; i++)
+	{
 		p[i+1] = d[i];
-	USBD_Send(HID_TX, p, len+1);
+	}
+	USBD_Send(HID_ENDPOINT_INT, p, len+1);
 }
 
 bool WEAK HID_Setup(Setup& setup)
@@ -186,6 +194,12 @@ bool WEAK HID_Setup(Setup& setup)
 			//Send8(_hid_protocol);	// TODO
 			return true;
 		}
+		if (HID_GET_IDLE == r)
+		{
+			UDD_Send(0, &_hid_idle, 1);
+			UDD_ClearIN();
+			return true;
+		}
 	}
 
 	if (REQUEST_HOSTTODEVICE_CLASS_INTERFACE == requestType)
@@ -198,15 +212,12 @@ bool WEAK HID_Setup(Setup& setup)
 
 		if (HID_SET_IDLE == r)
 		{
-			_hid_idle = setup.wValueL;
+			_hid_idle = setup.wValueH;
 			return true;
 		}
 	}
 	return false;
 }
-#ifdef __cplusplus
-}
-#endif
 
 //================================================================================
 //================================================================================
@@ -423,8 +434,6 @@ extern const uint8_t _asciimap[128] =
 	0				// DEL
 };
 
-uint8_t USBPutChar(uint8_t c);
-
 // press() adds the specified key (printing, non-printing, or modifier)
 // to the persistent key report and sends the report.  Because of the way
 // USB HID works, the host acts like the key remains pressed until we