usb.c

自己动手做U盘

#include  "config.h" 
#include  "LPC2294.h"
#include  "sourceHead.h" 
#include  "other.h"
#include  "flash.h"
#include  "usb.h" 
#include  "uart.h"
#include  "menu.h"
#include  "LCD.h"
#include  "fat.h"

#define CFG_NUM  32

unsigned char *pDeviceDescr,*pConfigDescr;




extern unsigned char Data_buffer[0x200];

unsigned char inquirydata[36]=
{0,0x80,02,02,
 0x1f,0,0,0,
 0x6b,0x70,0x6d,0x20,
 0x20,0x20,0x20,0x20,
 0x6b,0x70,0x6d,0x20,
 0x20,0x20,0x20,0x20,
 0x20,0x20,0x20,0x20,
 0x20,0x20,0x20,0x20,
 0x20,0x20,0x20,0x20,
};
unsigned char csw[64],cbw[31];
const char cap[8]={0,0x01,0xff,0xff,0x00,0x00,0x02,0x00};
const char fcap[12]={0,0,0,8,0,2,0,0,2,0,2,0};
const char mode[12]={0x0b,0,0,8,0,2,0,0,0,0,2,0};     

extern  unsigned  char receive_buffer[0x4000];
extern char STATUS;

unsigned long int count=0,count1=0;
unsigned long int block_addr,block_addr_old;
unsigned long int trans_start_page,flash_page_start;
unsigned int trans_num;
unsigned char USBMode;
/////////////////////////
void analyse(void);	
unsigned char dataCount=0;

//*************  PDIUSBD12  ****************//
void Outport_command(unsigned char val)
{
	USBA0H=val;
	Delay100ns(5);
}
void Outport_data(unsigned char val)
{
	USBA0L=val;
	Delay100ns(5);
}
unsigned char Inport_data(void)
{
	unsigned char c;
	c=USBA0L;
	Delay100ns(5);
	return c;
}

void D12_SetAddressEnable(unsigned char bAddress, unsigned char bEnable)
{
	if(bEPPflags.bits.in_isr == 0)	DISABLE;
	Outport_command( 0xD0);
	if(bEnable)		bAddress |= 0x80;
	Outport_data( bAddress);
	if(bEPPflags.bits.in_isr == 0)	ENABLE;
}

void D12_SetEndpointEnable(unsigned char bEnable)
{
	if(bEPPflags.bits.in_isr == 0)	DISABLE;
	Outport_command( 0xD8);
	if(bEnable)		Outport_data( 1);
	else	Outport_data( 0);
	if(bEPPflags.bits.in_isr == 0)	ENABLE;
}

void D12_SetMode(unsigned char bConfig, unsigned char bClkDiv)
{
	if(bEPPflags.bits.in_isr == 0)	DISABLE;
	Outport_command( 0xF3);
	Outport_data( bConfig);
	Outport_data( bClkDiv);
	if(bEPPflags.bits.in_isr == 0)	ENABLE;
}
void D12_SetDMA(unsigned char bMode)
{
	if(bEPPflags.bits.in_isr == 0)	DISABLE;
	Outport_command( 0xFB);
	Outport_data( bMode);
	if(bEPPflags.bits.in_isr == 0)	ENABLE;
}
unsigned short D12_ReadInterruptRegister(void)
{
	unsigned char b1;
	unsigned int j;
	Outport_command( 0xF4);
	b1 = Inport_data();Delay100ns(1);
	j = Inport_data();
	j <<= 8;
	j += b1;
	return j;
}

unsigned char D12_SelectEndpoint(unsigned char bEndp)
{
	unsigned char c;
	if(bEPPflags.bits.in_isr == 0)	DISABLE;
	Outport_command( bEndp);
	c = Inport_data();
	if(bEPPflags.bits.in_isr == 0)	ENABLE;
	return c;
}

unsigned char D12_ReadLastTransactionStatus(unsigned char bEndp)
{
	Outport_command( 0x40 + bEndp);
	return Inport_data();
}

unsigned char D12_ReadEndpointStatus(unsigned char bEndp)
{
	unsigned char c;
	if(bEPPflags.bits.in_isr == 0)	DISABLE;
	Outport_command( 0x80 + bEndp);
	c = Inport_data();
	if(bEPPflags.bits.in_isr == 0)	ENABLE;
	return c;
}

void D12_SetEndpointStatus(unsigned char bEndp, unsigned char bStalled)
{
	if(bEPPflags.bits.in_isr == 0)	DISABLE;
	Outport_command( 0x40 + bEndp);
	Outport_data( bStalled);
	if(bEPPflags.bits.in_isr == 0)	ENABLE;
}
void D12_SendResume(void)
{
	Outport_command( 0xF6);
}
unsigned short D12_ReadCurrentFrameNumber(void)
{
	unsigned short i,j;
	if(bEPPflags.bits.in_isr == 0)	DISABLE;
	Outport_command( 0xF5);
	i= Inport_data();
	j = Inport_data();
	i += (j<<8);
	if(bEPPflags.bits.in_isr == 0)	ENABLE;
	return i;
}

unsigned short D12_ReadChipID(void)
{
	unsigned short i,j;
	if(bEPPflags.bits.in_isr == 0)	DISABLE;
	Outport_command( 0xFD);
	i=Inport_data();
	j=Inport_data();
	i += (j<<8);
	if(bEPPflags.bits.in_isr == 0)ENABLE;
	return i;
}

unsigned char D12_ReadEndpoint(unsigned char endp, unsigned char * buf, unsigned char len)
{
	unsigned char i, j;
	if(bEPPflags.bits.in_isr == 0)	DISABLE;
	Outport_command( endp);
	if((Inport_data() & D12_FULLEMPTY) == 0) 
	{
		if(bEPPflags.bits.in_isr == 0)	ENABLE;
		return 0;
	}
	Outport_command( 0xF0);
	j = Inport_data();
	j = Inport_data();
	if(j > len)	j = len;
	for(i=0; i<j; i++)
	*(buf+i) = Inport_data();
	Outport_command( 0xF2);
	if(bEPPflags.bits.in_isr == 0)	ENABLE;
	return j;
}

// D12_ReadMainEndpoint() added by V2_2 to support double-buffering_
// Caller should assume maxium 128 bytes of returned data_
unsigned char D12_ReadMainEndpoint(unsigned char * buf)
{
	unsigned char i, j, k = 0, bDblBuf = 1;
	if(bEPPflags.bits.in_isr == 0)	DISABLE;
	Outport_command( 0x84);
	if( (Inport_data() & 0x60) == 0x60)	bDblBuf = 2;
	while(bDblBuf) 
	{
		Outport_command( 4);
		if((Inport_data() & D12_FULLEMPTY) == 0)	break;
		Outport_command( 0xF0);
		j = Inport_data();
		j = Inport_data();
		for(i=0; i<j; i++)
		*(buf+i+k) = Inport_data();
		k += j;
		Outport_command( 0xF2);
		bDblBuf --;
	}
	if(bEPPflags.bits.in_isr == 0)	ENABLE;
	return k;
}

unsigned char D12_WriteEndpoint(unsigned char endp, unsigned char * buf, unsigned char len)
{
	unsigned char i;
	if(bEPPflags.bits.in_isr == 0)	DISABLE;
	Outport_command(endp);
	Inport_data();
	Outport_command( 0xF0);
	Outport_data( 0);
	Outport_data( len);
	for(i=0; i<len; i++)
	Outport_data( *(buf+i));
	Outport_command( 0xFA);
	if(bEPPflags.bits.in_isr == 0)
	ENABLE;
	return len;
}

void D12_AcknowledgeEndpoint(unsigned char endp)
{
	Outport_command( endp);
	Outport_command( 0xF1);
	if(endp == 0)	Outport_command( 0xF2);
}

unsigned char  uDisk_DeviceDescr[] =//USB_DEVICE_DESCRIPTOR
{
	0x12,
	0x01,
	0x10,0x01,
	0x00 ,
	0, 0,
	0x10,
	0x71,0x04,//SWAP(0x0471),
	0x28,0x02,//SWAP(0x0222),
	0x00,0x01,//SWAP(0x0100),
	0, 0, 0,
	1
};


unsigned char uDisk_ConfigDescr[] =//USB_CONFIGURATION_DESCRIPTOR
{
//Configuration Description
	9,					
	02,
	CFG_NUM,0,
	1,
	1,
	0,
	0x80,
	0x32,
	
 //Bulk-only Data Interface Descriptor	
	9,                    
	0x04,
	0,
	0,
	2,
	8,
	0x06,
	0x50,
	0,
//Bulk-In Endpoit 2 Descriptor
	7,					   
	0x05,
	0x82,
	2,
	64,0,
	01,
//Bulk-Out Endpoit 2 Descriptor
	7,					
	0x05,
	0x02,
	2,
	64,0,
	1,
	
};

unsigned char ctl_DeviceDescr[] =//USB_DEVICE_DESCRIPTOR
{
	0x12,
	0x01,
	0x10,0x01,
	0xdc ,
	0, 0,
	0x10,
	0x71,0x04,//SWAP(0x0471),
	0x66,0x06,//SWAP(0x0666),
	0x00,0x01,//SWAP(0x0100),
	0, 0, 0,
	1
};


unsigned char ctl_ConfigDescr[] =//USB_CONFIGURATION_DESCRIPTOR
{
//Configuration Description
	9,					
	02,
	CFG_NUM,0,
	1,
	1,
	0,
	0x80,
	0x32,
	
 //Bulk-only Data Interface Descriptor	
	9,                    
	0x04,
	0,
	0,
	2,
	0xdc,
	0xa0,
	0xb0,
	0,
//Bulk-In Endpoit 1 Descriptor
	7,					   
	0x05,
	0x81,
	2,
	0x10,0,
	10,
//Bulk-Out Endpoit 1 Descriptor
	7,					
	0x05,
	0x01,
	2,
	0x10,0,
	10,
		
};

void suspend_change(void)
{
}
void stall_ep0(void)
{
	D12_SetEndpointStatus(0, 1);
	D12_SetEndpointStatus(1, 1);
}

void single_transmit(unsigned char * buf, unsigned char len)
{
	if( len <= EP0_PACKET_SIZE) {
	D12_WriteEndpoint(1, buf, len);}
}
void init_unconfig(void)
{
	
	D12_SetEndpointEnable(0); /* Disable all endpoints but EPP0. */
}
void init_config(void)
{
	D12_SetEndpointEnable(1); /* Enable generic/iso endpoints. */
}

void setup_dma()
{
	
}

void code_transmit(unsigned char  * pRomData, unsigned short len)
{
	ControlData.wCount = 0;
	if(ControlData.wLength > len)	ControlData.wLength = len;
	ControlData.pData = pRomData;
	if( ControlData.wLength >= EP0_PACKET_SIZE)
	{
		D12_WriteEndpoint(1, ControlData.pData, EP0_PACKET_SIZE);
		ControlData.wCount += EP0_PACKET_SIZE;
		DISABLE;
		bEPPflags.bits.control_state = USB_TRANSMIT;
		ENABLE;
	}
	else 
	{
		D12_WriteEndpoint(1, pRomData, ControlData.wLength);
		ControlData.wCount += ControlData.wLength;
		DISABLE;
		bEPPflags.bits.control_state = USB_IDLE;
		ENABLE;
	}
	
}

void CSW_transmit(unsigned char  * pRomData, unsigned short len)
{
	unsigned int index=0,L;
	unsigned char i;
	ControlData.pData = pRomData;
	L=len;
	while(L>64)
	{	
		
		D12_WriteEndpoint(5, (ControlData.pData+index*64), 64);
		index++;
		L-=64;
		rr:	Outport_command(5);
	 	i=Inport_data();	
  		if(i!=0){goto rr;}
	}
	if(L!=0)
	D12_WriteEndpoint(5, (ControlData.pData+index*64), L);
	
}
void reserved(void)
{
	stall_ep0();
}

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)	D12_SetEndpointStatus(endp*2 + 1, 0);/* clear TX stall for IN on EPn_ */
		else	D12_SetEndpointStatus(endp*2, 0);	/* clear RX stall for OUT on EPn_ */
		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)	D12_SetEndpointStatus(endp*2 + 1, 1);/* clear TX stall for IN on EPn_ */
		else	D12_SetEndpointStatus(endp*2, 1);/* clear RX stall for OUT on EPn_ */
		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 =(ControlData.DeviceRequest.wValue>>8);
	if (bDescriptor == USB_DEVICE_DESCRIPTOR_TYPE) 
	{
		code_transmit(pDeviceDescr, 18);
	} 
	else if (bDescriptor == USB_CONFIGURATION_DESCRIPTOR_TYPE) 
	{
		code_transmit(pConfigDescr, CFG_NUM);
	} 

}

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 */ 
	{
		single_transmit(0, 0);
		DISABLE;
		bEPPflags.bits.configuration = 0;
		ENABLE;
		init_unconfig();
	} 
	else if (ControlData.DeviceRequest.wValue == 1) /* Configure device */
	{
		single_transmit(0, 0);
		init_unconfig();
		init_config();
		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();
}