usb_enumerate.c

基于atmel公司的at91rm9200的简单usb协议驱动

	AT91PS_UDP   pUdp = pUSBCTL->pUdp; // Pointer to UDP registers

	// Send the current configuration
	AT91F_UDP_EpWrite(pUdp, 0, currentConfiguration);
	AT91F_UDP_EpEndOfWr(pUdp, 0);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_USB_GetStatusZero
//* \brief Answer to a standard GET STATUS ZERO request
//*----------------------------------------------------------------------------
__inline void AT91F_USB_GetStatusZero(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	AT91PS_UDP   pUdp = pUSBCTL->pUdp; // Pointer to UDP registers

	// Return no Remote wakeup, not self powered (Cf. Fig 9.4 in USB Spec Rev 1.1)
	AT91F_UDP_EpWrite(pUdp, 0, 0);
	AT91F_UDP_EpWrite(pUdp, 0, 0);
	AT91F_UDP_EpEndOfWr(pUdp, 0);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_USB_GetStatusInterface
//* \brief Answer to a standard GET STATUS INTERFACE request
//*----------------------------------------------------------------------------
__inline void AT91F_USB_GetStatusInterface(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	AT91PS_UDP   pUdp = pUSBCTL->pUdp; // Pointer to UDP registers

	// Return 0 (Cf. Fig 9.5 in USB Spec Rev 1.1)
	AT91F_UDP_EpWrite(pUdp, 0, 0);
	AT91F_UDP_EpWrite(pUdp, 0, 0);
	AT91F_UDP_EpEndOfWr(pUdp, 0);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_USB_GetStatusEndpoint
//* \brief Answer to a standard GET STATUS ENDPOINT request
//*----------------------------------------------------------------------------
__inline void AT91F_USB_GetStatusEndpoint(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	AT91PS_UDP   pUdp = pUSBCTL->pUdp; // Pointer to UDP registers
	unsigned char endpoint = (pUSBCTL->pSetup[4] & 0x7F);

	// Return halt or not (Cf. Fig 9.6 in USB Spec Rev 1.1)
	if ((AT91F_UDP_GetState(pUdp) != AT91C_UDP_CONFG) ||  (endpoint > 3))
		AT91F_UDP_EpStall(pUdp, 0);
	else {
		if (AT91F_UDP_EpStatus(pUdp, endpoint) & AT91C_UDP_EPEDS)
			AT91F_UDP_EpWrite(pUdp, 0, 1);
		else
			AT91F_UDP_EpWrite(pUdp, 0, 0);
		AT91F_UDP_EpWrite(pUdp, 0, 0);
		AT91F_UDP_EpEndOfWr(pUdp, 0);
	}
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_USB_SetFeatureZero
//* \brief Answer to a standard SET FEATURE ZERO request
//*----------------------------------------------------------------------------
__inline void AT91F_USB_SetFeatureZero(
	AT91PS_SVC_USBCTL pUSBCTL)
{
    // Device feature RWUp is not supported STALL it
	AT91F_UDP_EpStall(pUSBCTL->pUdp, 0);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_USB_SetFeatureInterface
//* \brief Answer to a standard SET FEATURE INTERFACE request
//*----------------------------------------------------------------------------
__inline void AT91F_USB_SetFeatureInterface(
	AT91PS_SVC_USBCTL pUSBCTL)
{
    // Assumed RFU...
    // Send a zero length packet
	AT91F_UDP_EpEndOfWr(pUSBCTL->pUdp, 0);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_USB_SetFeatureEndpoint
//* \brief Answer to a standard SET FEATURE ENDPOINT request
//*----------------------------------------------------------------------------
__inline void AT91F_USB_SetFeatureEndpoint(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	AT91PS_UDP   pUdp = pUSBCTL->pUdp; // Pointer to UDP registers
	unsigned char endpoint = (pUSBCTL->pSetup[4] & 0x7F);

    // If Feature different from ENDPOINT_HALT, Stall the request !!! (Cf table 9.6 in USB Spec. )
	if (pUSBCTL->pSetup[2])
		AT91F_UDP_EpStall(pUdp, 0);

	if ((AT91F_UDP_GetState(pUdp) != AT91C_UDP_CONFG) ||  (endpoint < 1) || (endpoint > 3))
		AT91F_UDP_EpStall(pUdp, 0);
	else {
		// Disable the endpoint
		AT91F_UDP_DisableEp(pUdp, endpoint);
    	// Send a zero length packet
		AT91F_UDP_EpEndOfWr(pUdp, 0);
	}
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_USB_ClrFeatureZero
//* \brief Answer to a standard CLEAR FEATURE ZERO request
//*----------------------------------------------------------------------------
__inline void AT91F_USB_ClrFeatureZero(
	AT91PS_SVC_USBCTL pUSBCTL)
{
    // Device feature RWUp is not supported STALL it
	AT91F_UDP_EpStall(pUSBCTL->pUdp, 0);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_USB_ClrFeatureInterface
//* \brief Answer to a standard CLEAR FEATURE INTERFACE request
//*----------------------------------------------------------------------------
__inline void AT91F_USB_ClrFeatureInterface(
	AT91PS_SVC_USBCTL pUSBCTL)
{
    // Assumed RFU...
    // Send a zero length packet
	AT91F_UDP_EpEndOfWr(pUSBCTL->pUdp, 0);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_USB_ClrFeatureEndpoint
//* \brief Answer to a standard CLEAR FEATURE ENDPOINT request
//*----------------------------------------------------------------------------
__inline void AT91F_USB_ClrFeatureEndpoint(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	AT91PS_UDP   pUdp = pUSBCTL->pUdp; // Pointer to UDP registers
	unsigned char endpoint = (pUSBCTL->pSetup[4] & 0x7F);

    // If Feature different from ENDPOINT_HALT, Stall the request !!! (Cf table 9.6 in USB Spec. )
	if (pUSBCTL->pSetup[2])
		AT91F_UDP_EpStall(pUdp, 0);

	if ((AT91F_UDP_GetState(pUdp) != AT91C_UDP_CONFG) ||  (endpoint < 1) || (endpoint > 3))
		AT91F_UDP_EpStall(pUdp, 0);
	else {
		// Disable the endpoint
		AT91F_UDP_EnableEp(pUdp, endpoint);
    	// Send a zero length packet
		AT91F_UDP_EpEndOfWr(pUdp, 0);
	}
}

__align(32) char serialState[] = {
	0xA1, 0x20, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,
	0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	};

__align(32) char networkConnection[] = {
	0xA1, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00
	};

typedef struct {
	unsigned int dwDTERRate;
	char bCharFormat;
	char bParityType;
	char bDataBits;
} AT91S_CDC_LINE_CODING, *AT91PS_CDC_LINE_CODING;


__align(32) AT91S_CDC_LINE_CODING lineCoding = {
	115200, // baudrate
	0,      // 1 Stop Bit
	0,      // None Parity
	8};     // 8 Data bits


//*----------------------------------------------------------------------------
//* \fn    AT91F_CDC_GetLineCoding
//* \brief This request allows the host to find out the currently configured line coding
//*----------------------------------------------------------------------------
__inline void AT91F_CDC_GetLineCoding(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	unsigned short wLength = *((unsigned short *) &(pUSBCTL->pSetup[6]));
	pUSBCTL->Write(pUSBCTL,
		(const char *) &lineCoding,
		MIN(sizeof(lineCoding), wLength),
		(AT91PF_SVC_USBCTL_RWComplete) 0);    // No callback
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_CDC_SetLineCodingComplete
//* \brief AT91F_CDC_SetLineCodingComplete once AT91F_CDC_SetLineCoding is achieved
//*----------------------------------------------------------------------------
__inline void AT91F_CDC_SetLineCodingComplete(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	// Send a STATUS IN
	pUSBCTL->Write(pUSBCTL, (const char *) 0, 0, (AT91PF_SVC_USBCTL_RWComplete)0);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_CDC_SetLineCoding
//* \brief This request allows the host to specify typical asynchronous line-characterformatting properties
//*----------------------------------------------------------------------------
__inline void AT91F_CDC_SetLineCoding(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	unsigned short wLength = *((unsigned short *) &(pUSBCTL->pSetup[6]));
	pUSBCTL->Read(pUSBCTL,
		(char *) &lineCoding,
		MIN(sizeof(lineCoding), wLength),
		(AT91PF_SVC_USBCTL_RWComplete) AT91F_CDC_SetLineCodingComplete);    // No callback
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_CDC_NotificationComplete
//* \brief 
//*----------------------------------------------------------------------------
void AT91F_CDC_NotificationComplete(
	AT91PS_SVC_USBIN pUSBIN)
{
	//usbEpInt.Write(&usbEpInt, networkConnection, sizeof(networkConnection), (AT91PF_SVC_SVCUSBIN_TxComplete) 0);

}

void AT91F_CDC_SetControlLineStateComplete(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	currentConnection = pUSBCTL->pSetup[2];
	//if (currentConnection == 3)
	//	usbEpInt.Write(&usbEpInt, serialState, sizeof(serialState), (AT91PF_SVC_SVCUSBIN_TxComplete) 0);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_CDC_SetControlLineState
//* \brief This request allows the host to specify typical asynchronous line-characterformatting properties
//*----------------------------------------------------------------------------
__inline void AT91F_CDC_SetControlLineState(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	//AT91PS_UDP   pUdp = pUSBCTL->pUdp; // Pointer to UDP registers
	// Send a STATUS IN
	pUSBCTL->Write(pUSBCTL,	(char *) 0,	0, AT91F_CDC_SetControlLineStateComplete);
	//AT91F_UDP_EpEndOfWr(pUdp, 0);
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_USB_DispatchRequest
//* \brief This function is a callback invoked when a SETUP packet is received
//*----------------------------------------------------------------------------
void AT91F_USB_DispatchRequest(
	AT91PS_SVC_USBCTL pUSBCTL)
{
	unsigned short request = *((unsigned short *) pUSBCTL->pSetup);

	// Handle supported standard device request Cf Table 9-3 in USB specification Rev 1.1
	if ((request == STD_GET_DESCRIPTOR) && (pUSBCTL->pSetup[3] == 1))
		AT91F_USB_GetDescriptorDevice(pUSBCTL);
	else if ((request == STD_GET_DESCRIPTOR) && (pUSBCTL->pSetup[3] == 2))
		AT91F_USB_GetDescriptorConfiguration(pUSBCTL);
	else if (request == STD_SET_ADDRESS)             AT91F_USB_SetAddress(pUSBCTL);
	else if (request == STD_SET_CONFIGURATION)       AT91F_USB_SetConfiguration(pUSBCTL);
	else if (request == STD_GET_CONFIGURATION)       AT91F_USB_GetConfiguration(pUSBCTL);
	else if (request == STD_GET_STATUS_ZERO)         AT91F_USB_GetStatusZero(pUSBCTL);
	else if (request == STD_GET_STATUS_INTERFACE)    AT91F_USB_GetStatusInterface(pUSBCTL);
	else if (request == STD_GET_STATUS_ENDPOINT)     AT91F_USB_GetStatusEndpoint(pUSBCTL);
	else if (request == STD_SET_FEATURE_ZERO)        AT91F_USB_SetFeatureZero(pUSBCTL);
	else if (request == STD_SET_FEATURE_INTERFACE)   AT91F_USB_SetFeatureInterface(pUSBCTL);
	else if (request == STD_SET_FEATURE_ENDPOINT)    AT91F_USB_SetFeatureEndpoint(pUSBCTL);
	else if (request == STD_CLEAR_FEATURE_ZERO)      AT91F_USB_ClrFeatureZero(pUSBCTL);
	else if (request == STD_CLEAR_FEATURE_INTERFACE) AT91F_USB_ClrFeatureInterface(pUSBCTL);
	else if (request == STD_CLEAR_FEATURE_ENDPOINT)  AT91F_USB_ClrFeatureEndpoint(pUSBCTL);

	// handle CDC class requests
	else if (request == SET_LINE_CODING) AT91F_CDC_SetLineCoding(pUSBCTL);
	else if (request == GET_LINE_CODING) AT91F_CDC_GetLineCoding(pUSBCTL);
	else if (request == SET_CONTROL_LINE_STATE) AT91F_CDC_SetControlLineState(pUSBCTL);
	// Unsupported requests
	else
		AT91F_UDP_EpStall(pUSBCTL->pUdp, 0);
}