testusbbin.c

uCOS上移植的USB。今天终于可以使用我的了

//	IT0 = 0;
//	MCUCR=0x80;
//	EX0 = 1;
// 	SREG|=0x80;
	sei();
 	EIMSK|=0x01;
//	PX0 = 0;
}

void init_port(void)
{
	DDRD &= 0x7F;
        PORTD|=0<<4;
	PORTD|=1<<5;
	PORTD|=1<<6;
//	DDRC = 0xFF;
        PORTC|=0xFF;			
//	D12SUSPD = 0;
}

/*Serial Port */
/*Mode            = 1  /8-bit UART
  Serial Port Interrupt    = Disabled         */
/*Receive         = Enabled   */
/*Auto Addressing    = Disabled   */
//void init_serial(void)
//{
//	SCON = 0X52;
//	PCON = 0X80 | PCON;
//	TMOD = 0X20;
//	TCON = 0x69;    /* TCON */
//	TH1 = 0xF3;
//}  

//void on_exit(void)
//{
//}

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

void disconnect_USB(void)
{
	// Initialize D12 configuration
	D12_SetMode(D12_NOLAZYCLOCK, D12_SETTOONE | D12_CLOCK_12M);
}

void connect_USB(void)
{
	// reset event flags
	DISABLE;
	bEPPflags.value = 0;
	ENABLE;

	// V2.1 enable normal+sof interrupt
	D12_SetDMA(D12_ENDP4INTENABLE | D12_ENDP5INTENABLE);

	// Initialize D12 configuration
	D12_SetMode(D12_NOLAZYCLOCK|D12_SOFTCONNECT, D12_SETTOONE | D12_CLOCK_12M);
}


void reconnect_USB(void)
{
	unsigned long clk_cnt,i;

//	MCU_LED0 = 0;
//	MCU_LED1 = 0;

	// Pull-down D12's SUSPEND pin
	// Disable 74HCT123 pulse generation before disconnect
	// Release D12's SUSPEND pin after receiving bus reset from host
//	D12SUSPD = 0;
	PORTD|=0<<4;
	disconnect_USB();

  VT102DispStr(1, 11, "Wait for 1 second ...", COLOR_WHITE, COLOR_BLACK);
//    OSTimeDlyHMSM(0, 0, 1, 0);  
// 	for(i=0;i<1000;i++) for(clk_cnt=0;clk_cnt<1800;clk_cnt++) ;
  VT102DispStr(1, 11, "                     ", COLOR_WHITE, COLOR_BLACK);

	connect_USB();

//	MCU_LED0 = 1;
//	MCU_LED1 = 1;
}

void init_unconfig(void)
{

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

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

void single_transmit(unsigned char * buf, unsigned char len)
{
	if( len <= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, len, buf);
	}
}

void code_transmit(unsigned char * pRomData, unsigned int len)
{
	ControlData.wCount = 0;
	if(ControlData.wLength > len)
		ControlData.wLength = len;

	ControlData.pData = pRomData;
	if( ControlData.wLength >= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, EP0_PACKET_SIZE, ControlData.pData);
		ControlData.wCount += EP0_PACKET_SIZE;

		DISABLE;
		bEPPflags.bits.control_state = USB_TRANSMIT;
		ENABLE;
	}
	else {
		D12_WriteEndpoint(1, ControlData.wLength, pRomData);
		ControlData.wCount += ControlData.wLength;
		DISABLE;
		bEPPflags.bits.control_state = USB_IDLE;
		ENABLE;
	}
}


void setup_dma(void)
{
	ioSize = ioRequest.uSize;
	ioCount = 0;

	DISABLE;
	bEPPflags.bits.dma_state = DMA_RUNNING;
	ENABLE;

	single_transmit(0, 0);

	if(ioRequest.bCommand & 0x1) {
		if(ioSize > 64 || ioSize == 0) {
			if(bNoRAM)
				D12_WriteEndpoint(5, 64, (unsigned char *)EpBuf);
			else
				D12_WriteEndpoint(5, 64, MainEpBuf);
			ioCount += 64;
		}
		else {
			if(bNoRAM)
				D12_WriteEndpoint(5, ioSize, (unsigned char *)EpBuf);
			else
				D12_WriteEndpoint(5, ioSize, MainEpBuf);
			ioCount += ioSize;
		}
	}
}


void control_handler(void)
{
	unsigned char type, req;

	type = ControlData.DeviceRequest.bmRequestType & USB_REQUEST_TYPE_MASK;
	req = ControlData.DeviceRequest.bRequest & USB_REQUEST_MASK;

	help_devreq(type, req); // print out device request

	if (type == USB_STANDARD_REQUEST)
		(*StandardDeviceRequest[req])();
	else if (type == USB_VENDOR_REQUEST)
		(*VendorDeviceRequest[req])();
	else
		stall_ep0();
}





//ISR
//timer_isr() interrupt 1
//{
//	DISABLE;
//	ClockTicks++;
//	bEPPflags.bits.timer = 1;
//	ENABLE;
//}

UCOSISR(SIG_INTERRUPT0)
{
  PushRS();
  OSIntEnter();
  VT102DispStr(1, 11, "response to interrupte 0......", COLOR_WHITE, COLOR_BLACK);  
	fn_usb_isr();
  sei();
  OSIntExit();
  PopRS();
}
/*usb_isr() interrupt 0
{
	DISABLE;
	fn_usb_isr();
	ENABLE;
}  */

void fn_usb_isr(void)
{
	unsigned int i_st;

  VT102DispStr(1, 11, "response to interrupte 0......", COLOR_WHITE, COLOR_BLACK);
	bEPPflags.bits.in_isr = 1;

	i_st = D12_ReadInterruptRegister();

	if(i_st != 0) {
		if(i_st & D12_INT_BUSRESET) {
			bus_reset();
			bEPPflags.bits.bus_reset = 1;
		}

		if(i_st & D12_INT_EOT)
			dma_eot();

		if(i_st & D12_INT_SUSPENDCHANGE)
			bEPPflags.bits.suspend = 1;

		if(i_st & D12_INT_ENDP0IN)
			ep0_txdone();
		if(i_st & D12_INT_ENDP0OUT)
			ep0_rxdone();
		if(i_st & D12_INT_ENDP1IN)
			ep1_txdone();
		if(i_st & D12_INT_ENDP1OUT)
			ep1_rxdone();
		if(i_st & D12_INT_ENDP2IN)
			main_txdone();
		if(i_st & D12_INT_ENDP2OUT)
			main_rxdone();
	}

	bEPPflags.bits.in_isr = 0;
}

void bus_reset(void)
{
}

void ep0_rxdone(void)
{
	unsigned char ep_last, i;

	ep_last = D12_ReadLastTransactionStatus(0); // Clear interrupt flag

	if (ep_last & D12_SETUPPACKET) {

		ControlData.wLength = 0;
		ControlData.wCount = 0;

		if( D12_ReadEndpoint(0, sizeof(ControlData.DeviceRequest),
			(unsigned char *)(&(ControlData.DeviceRequest))) != sizeof(DEVICE_REQUEST) ) {

			D12_SetEndpointStatus(0, 1);
			D12_SetEndpointStatus(1, 1);
			bEPPflags.bits.control_state = USB_IDLE;
			
			return;
		}

		ControlData.DeviceRequest.wValue = SWAP(ControlData.DeviceRequest.wValue);
		ControlData.DeviceRequest.wIndex = SWAP(ControlData.DeviceRequest.wIndex);
		ControlData.DeviceRequest.wLength = SWAP(ControlData.DeviceRequest.wLength);

		// Acknowledge setup here to unlock in/out endp
		D12_AcknowledgeEndpoint(0);
		D12_AcknowledgeEndpoint(1);

		ControlData.wLength = ControlData.DeviceRequest.wLength;
		ControlData.wCount = 0;

		if (ControlData.DeviceRequest.bmRequestType & (unsigned char)USB_ENDPOINT_DIRECTION_MASK) {
			bEPPflags.bits.setup_packet = 1;
			bEPPflags.bits.control_state = USB_IDLE;		/* get command */
		}
		else {
			if (ControlData.DeviceRequest.wLength == 0) {
				bEPPflags.bits.setup_packet = 1;
				bEPPflags.bits.control_state = USB_IDLE;		/* set command */
			}
			else {
				if(ControlData.DeviceRequest.wLength > MAX_CONTROLDATA_SIZE) {
					bEPPflags.bits.control_state = USB_IDLE;
					D12_SetEndpointStatus(0, 1);
					D12_SetEndpointStatus(1, 1);
				}
				else {
					bEPPflags.bits.control_state = USB_RECEIVE;	/* set command with OUT token */
				}
			} // set command with data
		} // else set command
	} // if setup packet

	else if (bEPPflags.bits.control_state == USB_RECEIVE) {
		i =	D12_ReadEndpoint(0, EP0_PACKET_SIZE,
			ControlData.dataBuffer + ControlData.wCount);

		ControlData.wCount += i;
		if( i != EP0_PACKET_SIZE || ControlData.wCount >= ControlData.wLength) {
			bEPPflags.bits.setup_packet = 1;
			bEPPflags.bits.control_state = USB_IDLE;
		}
	}

	else {
		bEPPflags.bits.control_state = USB_IDLE;
	}
}

void ep0_txdone(void)
{
	short i = ControlData.wLength - ControlData.wCount;

	D12_ReadLastTransactionStatus(1); // Clear interrupt flag

	if (bEPPflags.bits.control_state != USB_TRANSMIT) 
		return;

	if( i >= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, EP0_PACKET_SIZE, ControlData.pData + ControlData.wCount);
		ControlData.wCount += EP0_PACKET_SIZE;

		bEPPflags.bits.control_state = USB_TRANSMIT;
	}
	else if( i != 0) {
		D12_WriteEndpoint(1, i, ControlData.pData + ControlData.wCount);
		ControlData.wCount += i;

		bEPPflags.bits.control_state = USB_IDLE;
	}
	else if (i == 0){
		D12_WriteEndpoint(1, 0, 0); // Send zero packet at the end ???

		bEPPflags.bits.control_state = USB_IDLE;
	}
}

void dma_eot(void)
{
}

void ep1_txdone(void)
{
	D12_ReadLastTransactionStatus(3); /* Clear interrupt flag */
}

void ep1_rxdone(void)
{
	unsigned char len;

	D12_ReadLastTransactionStatus(2); /* Clear interrupt flag */

	len = D12_ReadEndpoint(2, sizeof(GenEpBuf), GenEpBuf);

	if(len != 0)
		bEPPflags.bits.ep1_rxdone = 1;
}

void main_txdone(void)
{
	unsigned char len;

	D12_ReadLastTransactionStatus(5); /* Clear interrupt flag */

	len = ioSize - ioCount;
	if(len == 0) {
		if(bEPPflags.bits.dma_state == DMA_PENDING)
			bEPPflags.bits.setup_dma ++;
		else
			bEPPflags.bits.dma_state = DMA_IDLE;
	}
	else {
		if(len > 64)
			len = 64;
		if(bNoRAM)
			len = D12_WriteEndpoint(5, len, EpBuf + ioCount);
		else
			len = D12_WriteEndpoint(5, len, MainEpBuf + ioCount);
		ioCount += len;
	}
}

void main_rxdone(void)
{
	unsigned char len;

	D12_ReadLastTransactionStatus(4); /* Clear interrupt flag */

	if(bNoRAM)
		len = D12_ReadEndpoint(4, 64, EpBuf + ioCount);
	else
		len = D12_ReadEndpoint(4, 64, MainEpBuf + ioCount);
	ioCount += len;
	if(bNoRAM)
		len = D12_ReadEndpoint(4, 64, EpBuf + ioCount);
	else
		len = D12_ReadEndpoint(4, 64, MainEpBuf + ioCount);
	ioCount += len;
	if(ioCount >= ioSize) {
		if(bEPPflags.bits.dma_state == DMA_PENDING)
			bEPPflags.bits.setup_dma ++;
		else
			bEPPflags.bits.dma_state = DMA_IDLE;
	}
}




//D12CI
void D12_SetAddressEnable(unsigned char bAddress,unsigned char bEnable)
{
	outportb(D12_COMMAND,0xD0);
	if(bEnable)
	   bAddress |=0x80;
	outportb(D12_DATA,bAddress);   
}

void D12_SetEndpointEnable(unsigned char bEnable)
{
  	outportb(D12_COMMAND,0xD8);
  	if(bEnable)
  	outportb(D12_DATA,1);
  	else
  	outportb(D12_DATA,0);
}

void D12_SetMode(unsigned char bConfig,unsigned char bClkDiv)
{
  	outportb(D12_COMMAND,0xF3);
  	outportb(D12_DATA,bConfig);
  	outportb(D12_DATA,bClkDiv);
}

void D12_SetDMA(unsigned char bMode)
{
  	outportb(D12_COMMAND,0xFB);
  	outportb(D12_DATA,bMode);
}


unsigned short D12_ReadInterruptRegister(void)
{
  	unsigned char b1;
  	unsigned int j;
  	outportb(D12_COMMAND,0xF4);
  	b1=inportb(D12_DATA);
  	j=inportb(D12_DATA);
  	j<<=8;
  	j+=b1;
  	return j;
}

unsigned char D12_SelectEndpoint(unsigned char bEndp)
{
  	unsigned char c;
  	outportb(D12_COMMAND,bEndp);
  	c=inportb(D12_DATA);
  	return c;
}

unsigned char D12_ReadLastTransactionStatus(unsigned char bEndp)
{