chap9.c

基于MCU的U盘源码

/*
   //************************************************************************* 
   //
   //                  P H I L I P S   P R O P R I E T A R Y
   //
   //           COPYRIGHT (c)   1997 BY PHILIPS SINGAPORE.
   //                     --  ALL RIGHTS RESERVED  --
   //
   // File Name:	CHAP_9.C
   // Author:		Wenkai Du
   // Created:		19 Dec 97
   // Modified:
   // Revision:		3.0
   //
   //*************************************************************************
*/

#include <stdio.h>
#include <string.h>


#include "d12ci.h"
#include "main.h"
#include "usb100.h"
#include "chap9.h"
//#include "44b.h"
#define NUM_ENDPOINTS	2

#define CONFIG_DESCRIPTOR_LENGTH    sizeof(USB_CONFIGURATION_DESCRIPTOR) \
									+ sizeof(USB_INTERFACE_DESCRIPTOR) \
									+ (NUM_ENDPOINTS * sizeof(USB_ENDPOINT_DESCRIPTOR))


extern CONTROL_XFER ControlData;
extern IO_REQUEST ioRequest;
extern EPPFLAGS bEPPflags;

TOTAL_CONFIGURATION_DESCRIPTOR Total_Configuration_Descriptor=
{
    9,
    2,
    CONFIG_DESCRIPTOR_LENGTH,
	1,
	1,
    0,
	0x80,
	0x32,

    sizeof(USB_INTERFACE_DESCRIPTOR),
    USB_INTERFACE_DESCRIPTOR_TYPE,
    0,
    0,
	NUM_ENDPOINTS,
	8,
	6,	//interface subclass1=RBC,2=SFF,3=QIC,4=UFI,5=SFF,6=SCSI
	0x50,//bulk 0nly
	0,

			 //Bulk-in Endpoint
			 0x07,              //length of this desc.   
			 0x05,              //ENDPOINT descriptor
			 0x82,              //address (IN) Endpoint 4 84
			 0x02,              //attributes  (BULK)    
			 0x0040,         //max packet size (64)
			 0x0,              //Does not apply to Bulk endpoints

			 //Bulk-out Endpoint
			 0x07,              //length of this desc.   
			 0x05,              //ENDPOINT descriptor 
			 0x02,              //address (OUT) Endpoint 5 05
			 0x02,              //attributes  (BULK)
			 0x0040,         //max packet size (64)
			 0x0             //Does not apply to Bulk endpoints

};

 USB_DEVICE_DESCRIPTOR DeviceDescr =
{
    	0x12,			//0x12
			 0x01,              //DEVICE descriptor
			 0x0100,         //spec rev level (BCD) 1.0
			 0x00,              //device class
			 0x00,              //device subclass
			 0x00,              //device protocol
			 0x10,              //max packet size
			 0x0584,         //National's vendor ID
			 0x0001,         //National's product ID  
			 0x0100,         //National's revision ID  
			 0,                 //index of manuf. string   
			 0,                 //index of prod.  string  
			 0,                 //index of ser. # string   
			 0x01               //number of configs. 	
};

USB_CONFIGURATION_DESCRIPTOR ConfigDescr =
{
    9,
    2,
    CONFIG_DESCRIPTOR_LENGTH,
	1,
	1,
    0,
	0x80,
	0x32
};


USB_INTERFACE_DESCRIPTOR InterfaceDescr =
{
    sizeof(USB_INTERFACE_DESCRIPTOR),
    USB_INTERFACE_DESCRIPTOR_TYPE,
    0,
    0,
	NUM_ENDPOINTS,
	8,
	6,	//interface subclass6=SCSI
	0x50,//bulk 0nly
	0
};

USB_ENDPOINT_DESCRIPTOR EP1_TXDescr =
{
	sizeof(USB_ENDPOINT_DESCRIPTOR),
	USB_ENDPOINT_DESCRIPTOR_TYPE,
	0x82,
	USB_ENDPOINT_TYPE_INTERRUPT,
	EP1_PACKET_SIZE,
	10
};

USB_ENDPOINT_DESCRIPTOR EP1_RXDescr =
{
	sizeof(USB_ENDPOINT_DESCRIPTOR),
	USB_ENDPOINT_DESCRIPTOR_TYPE,
	0x2,
	USB_ENDPOINT_TYPE_INTERRUPT,
	EP1_PACKET_SIZE,
	10
};

USB_ENDPOINT_DESCRIPTOR EP2_TXDescr =
{
	sizeof(USB_ENDPOINT_DESCRIPTOR),
	USB_ENDPOINT_DESCRIPTOR_TYPE,
	0x82,
	USB_ENDPOINT_TYPE_BULK,
	EP2_PACKET_SIZE,
	10
};

USB_ENDPOINT_DESCRIPTOR EP2_RXDescr =
{
	sizeof(USB_ENDPOINT_DESCRIPTOR),
	USB_ENDPOINT_DESCRIPTOR_TYPE,
	0x2,
	USB_ENDPOINT_TYPE_BULK,
	EP2_PACKET_SIZE,
	10
};

/*
   //*************************************************************************
   // USB Protocol Layer
   //*************************************************************************
*/

void reserved(void)
{
	stall_ep0();
}

/*
   //*************************************************************************
   // USB standard device requests
   //*************************************************************************
*/

void get_status(void)
{
	unsigned char endp, txdat[2];
	unsigned char bRecipient = ControlData.DeviceRequest.bmRequestType & USB_RECIPIENT;
	unsigned char c;

	if (bRecipient == USB_RECIPIENT_DEVICE) {
		if(bEPPflags.bits.remote_wakeup == 1)
			txdat[0] = 3;
		else
			txdat[0] = 1;
		txdat[1]=0;
		single_transmit(txdat, 2);
	} else if (bRecipient == USB_RECIPIENT_INTERFACE) {
		txdat[0]=0;
		txdat[1]=0;
		single_transmit(txdat, 2);
	} else if (bRecipient == USB_RECIPIENT_ENDPOINT) {
		endp = (unsigned char)(ControlData.DeviceRequest.wIndex & MAX_ENDPOINTS);
		if (ControlData.DeviceRequest.wIndex & (unsigned char)USB_ENDPOINT_DIRECTION_MASK)
			c = D12_SelectEndpoint(endp*2 + 1);	/* Control-in */
		else
			c = D12_SelectEndpoint(endp*2);	/* Control-out */
		if(c & D12_STALL)
			txdat[0] = 1;
		else
			txdat[0] = 0;
		txdat[1] = 0;
		single_transmit(txdat, 2);
	} else
		stall_ep0();
}

void clear_feature(void)
{
	unsigned char endp;
	unsigned char bRecipient = ControlData.DeviceRequest.bmRequestType & USB_RECIPIENT;

	if (bRecipient == USB_RECIPIENT_DEVICE
		&& ControlData.DeviceRequest.wValue == USB_FEATURE_REMOTE_WAKEUP) {
		DISABLE;
		bEPPflags.bits.remote_wakeup = 0;
		ENABLE;
		single_transmit(0, 0);
	}
	else if (bRecipient == USB_RECIPIENT_ENDPOINT
		&& ControlData.DeviceRequest.wValue == USB_FEATURE_ENDPOINT_STALL) {
		endp = (unsigned char)(ControlData.DeviceRequest.wIndex & MAX_ENDPOINTS);
		if (ControlData.DeviceRequest.wIndex & (unsigned char)USB_ENDPOINT_DIRECTION_MASK)
			/* clear TX stall for IN on EPn. */
			D12_SetEndpointStatus(endp*2 + 1, 0);
		else
			/* clear RX stall for OUT on EPn. */
			D12_SetEndpointStatus(endp*2, 0);
		single_transmit(0, 0);
	} else
		stall_ep0();
}

void set_feature(void)
{
	unsigned char endp;
	unsigned char bRecipient = ControlData.DeviceRequest.bmRequestType & USB_RECIPIENT;

	if (bRecipient == USB_RECIPIENT_DEVICE
		&& ControlData.DeviceRequest.wValue == USB_FEATURE_REMOTE_WAKEUP) {
		DISABLE;
		bEPPflags.bits.remote_wakeup = 1;
		ENABLE;
		single_transmit(0, 0);
	}
	else if (bRecipient == USB_RECIPIENT_ENDPOINT
		&& ControlData.DeviceRequest.wValue == USB_FEATURE_ENDPOINT_STALL) {
		endp = (unsigned char)(ControlData.DeviceRequest.wIndex & MAX_ENDPOINTS);
		if (ControlData.DeviceRequest.wIndex & (unsigned char)USB_ENDPOINT_DIRECTION_MASK)
			/* clear TX stall for IN on EPn. */
			D12_SetEndpointStatus(endp*2 + 1, 1);
		else
			/* clear RX stall for OUT on EPn. */
			D12_SetEndpointStatus(endp*2, 1);
		single_transmit(0, 0);
	} else
		stall_ep0();
}

void set_address(void)
{
	D12_SetAddressEnable((unsigned char)(ControlData.DeviceRequest.wValue &
		DEVICE_ADDRESS_MASK), 1);
	single_transmit(0, 0);
}

void get_descriptor(void)
{
	unsigned char bDescriptor = MSB(ControlData.DeviceRequest.wValue);
	unsigned char bLength = MSB(ControlData.DeviceRequest.wLength);
	char *temp;
	if (bDescriptor == USB_DEVICE_DESCRIPTOR_TYPE) {
		temp=(char *)&DeviceDescr;
		Uart_Printf("%x %x %x %x %x %x %x %x %x",temp[0],temp[1],temp[2],temp[3],temp[4],temp[5],temp[6],temp[7],temp[8]);
		code_transmit((unsigned char *)&DeviceDescr, sizeof(USB_DEVICE_DESCRIPTOR));
	} else if (bDescriptor == USB_CONFIGURATION_DESCRIPTOR_TYPE) {
		temp=(char *)&ConfigDescr;
		Uart_Printf("%x %x %x %x %x %x %x %x %x",temp[0],temp[1],temp[2],temp[3],temp[4],temp[5],temp[6],temp[7],temp[8]);
		code_transmit((unsigned char *)&Total_Configuration_Descriptor, CONFIG_DESCRIPTOR_LENGTH);
	} else
		stall_ep0();
}
//CONFIG_DESCRIPTOR_LENGTH
void get_configuration(void)
{
	unsigned char c = bEPPflags.bits.configuration;

	single_transmit(&c, 1);
}

void set_configuration(void)
{
	if (ControlData.DeviceRequest.wValue == 0) {
		/* put device in unconfigured state */
		DISABLE;
		bEPPflags.bits.configuration = 0;
		ENABLE;
		D12_SetEndpointEnable(0); /* Disable all endpoints but EPP0. *///init_unconfig
		single_transmit(0, 0);
		
	} else if (ControlData.DeviceRequest.wValue == 1) {
		/* Configure device */

		D12_SetEndpointEnable(0); /* Disable all endpoints but EPP0. //init_unconfig*/

		D12_SetEndpointEnable(1); /* Enable generic/iso endpoints. init_config*/

		single_transmit(0, 0);
	
		DISABLE;
		bEPPflags.bits.configuration = 1;
		ENABLE;
	} else
		stall_ep0();
}

void get_interface(void)
{
	unsigned char txdat = 0;        /* Only/Current interface = 0 */
	single_transmit(&txdat, 1);
}

void set_interface(void)
{
	if (ControlData.DeviceRequest.wValue == 0 && ControlData.DeviceRequest.wIndex == 0)
		single_transmit(0, 0);
	else
		stall_ep0();
}