testusb.c

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

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

	// Initialize D12 configuration
	D12_SetMode(D12_NOLAZYCLOCK|D12_SOFTCONNECT, D12_SETTOONE | D12_CLOCK_12M|D12_SOFONLY);
}  */
//连接USB总线
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);
}

//重新连接到USB总线
void reconnect_USB(void)
{
//	unsigned long clk_cnt,i;

//	D12SUSPD = 0;
	DDRD = 0x7F;
        PORTD&=~(1<<4);
        DDRD&=~(1<<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++) ;

	connect_USB();
  	VT102DispStr(23, 11, "connecting", COLOR_WHITE, COLOR_BLACK);  
}
//恢复到未配置状态
void init_unconfig(void)
{

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

//设置配置状态
void init_config(void)
{
	D12_SetEndpointEnable(1);	/* Enable  generic/iso endpoints. */
}

//从端点号1发送数据
void single_transmit(unsigned char * buf, unsigned char len)
{
	if( len <= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, len, buf);
	}
}

//发送端点号1建立代码
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;
	}

}

//DMA建立子程序
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) {
			//传输大于64字节数据
//			if(bNoRAM)
//				D12_WriteEndpoint(5, 64, (unsigned char *)EpBuf);
//			else
				D12_WriteEndpoint(5, 64, mainep.MainEpBuf);
			ioCount += 64;
		}
		else {
			//传输64字节数据			
//			if(bNoRAM)
//				D12_WriteEndpoint(5, ioSize, (unsigned char *)EpBuf);
//			else
				D12_WriteEndpoint(5, ioSize, mainep.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
//INTERRUPT(SIG_INTERRUPT0)
UCOSISR(SIG_INTERRUPT0)
{
  	DISABLE;
  PushRS();
  OSIntEnter();
  if (OSIntNesting == 1)
    OSTCBCur->OSTCBStkPtr = (OS_STK *)SP;


	fn_usb_isr();


//  if(OSIntNesting <= 2)  	ENABLE;
  ENABLE;	
  OSIntExit();
  PopRS();
}

/*UCOSISR(SIG_INTERRUPT0)
{
	DISABLE;
	fn_usb_isr();
	ENABLE;
}*/ 

void fn_usb_isr(void)
{
	unsigned int i_st;
 	//printf(1,12,"response to interrupte 0......\n",0);
	bEPPflags.bits.in_isr = 1;

	i_st = D12_ReadInterruptRegister();
	//printf(1,13,"Interrupt Register :%h",i_st);
	
	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();
			}
	}
/*	else {
                                cli();  
				EIFR=0x00;		
		}*/


	bEPPflags.bits.in_isr = 0;
}

//总线复位处理子程序
void bus_reset(void)
{
}

//端点0OUT中断
void ep0_rxdone(void)
{
	unsigned char ep_last, i;

	ep_last = D12_ReadLastTransactionStatus(0); //清中断标志

	if (ep_last & D12_SETUPPACKET) {
		//接收到SETUP包
		ControlData.wLength = 0;
		ControlData.wCount = 0;

		if( D12_ReadEndpoint(0, sizeof(ControlData.DeviceRequest),
			(unsigned char *)(&(ControlData.DeviceRequest))) != sizeof(DEVICE_REQUEST) ) {
			//SETUP包出错,返回
			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);

		//对控制端点的输入/输出进行应答
		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_TRANSMIT;		/* 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) {
					//接收数据长度为0
					bEPPflags.bits.control_state = USB_IDLE;
					D12_SetEndpointStatus(0, 1);
					D12_SetEndpointStatus(1, 1);
				}
				else {
					bEPPflags.bits.control_state = USB_RECEIVE;	//设置接收状态
				}
			} // 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;//进入等待状态
	}
}

//端点0IN处理
void ep0_txdone(void)
{
	short i = ControlData.wLength - ControlData.wCount;
	D12_ReadLastTransactionStatus(1); //清中断标志位
	if (bEPPflags.bits.control_state != USB_TRANSMIT) 
		return;//非发送状态,返回

	if( i >= EP0_PACKET_SIZE) {
		//剩下数据大于16字节,发送16字节
		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); //发送完毕,发送0字节
		bEPPflags.bits.control_state = USB_IDLE;
	}
}

//DMA结束处理
void dma_eot(void)
{
}

//端点1IN处理
void ep1_txdone(void)
{
	unsigned char i;
	D12_ReadLastTransactionStatus(3); //清中断标志位
		for(i=0;i<16;i++) EpBuf[i]=i;
	D12_WriteEndpoint(3,16,EpBuf);
}

//端点1OUT处理
void ep1_rxdone(void)
{
	unsigned char len;

	D12_ReadLastTransactionStatus(2); //清中断标志位
	len = D12_ReadEndpoint(2, sizeof(GenEpBuf), GenEpBuf);//读取数据
	if(len != 0)
		bEPPflags.bits.ep1_rxdone = 1;//标志接收到数据
}

//主端点IN控制
void main_txdone(void)
{
//	unsigned char len,epstatus;
	unsigned char i;
	D12_ReadLastTransactionStatus(5); //清中断标志位
	
/*	if(mainep.datacount>0)  {
		if(mainep.datacount<64)   {
			D12_WriteEndpoint(5,mainep.datacount,EpBuf);
			mainep.datacount=0;
		}
		else   {
			mainep.datacount-=64;
			D12_WriteEndpoint(5,64,EpBuf);
			}
	}
	for(i=0;i<64;i++) EpBuf[i]=i;
	D12_WriteEndpoint(5,64,EpBuf);*/
	bEPPflags.bits.ep2_txdone = 1;
}

//主端点OUT控制
void main_rxdone(void)
{
	unsigned char len,epstatus,ep_last;

	ep_last=D12_ReadLastTransactionStatus(4); //清中断标志位

	//接收数据
	len = D12_ReadEndpoint(4, 64, EpBuf);
	epstatus=D12_ReadEndpointStatus(4);
	epstatus &= 0x60;
	if (epstatus == 0x60)
		len = D12_ReadEndpoint(4, 64, EpBuf);//读取双缓冲区数据
	if(len != 0)
		bEPPflags.bits.ep2_rxdone = 1;//标志接收到数据		
}






//D12CI

//设置地址使能
void D12_SetAddressEnable(unsigned char bAddress, unsigned char bEnable)
{
	if(bEPPflags.bits.in_isr == 0)
		DISABLE;

	outportb(D12_COMMAND, 0xD0);//输出指令
	if(bEnable)
		bAddress |= 0x80;
	outportb(D12_DATA, bAddress);//设置地址

	if(bEPPflags.bits.in_isr == 0)
		ENABLE;
}

//设置端点使能
void D12_SetEndpointEnable(unsigned char bEnable)
{
	if(bEPPflags.bits.in_isr == 0)
		DISABLE;

	outportb(D12_COMMAND, 0xD8);//输出指令
	if(bEnable)
		outportb(D12_DATA, 1);//设置端点允许
	else
		outportb(D12_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;

	outportb(D12_COMMAND, 0xF3);//设置模式
	outportb(D12_DATA, bConfig);
	outportb(D12_DATA, bClkDiv);

	if(bEPPflags.bits.in_isr == 0)