usbisr.c

Philips PIDUSBP11 驱动代码

/************************************************************************
 *File	: Usbisr.c															*
 *By 	: hugang, [e-mail]								*
 ************************************************************************/ 

#include "armusb.h"
#include <stdio.h>
#include <string.h>
/**************************************************************************
 *Public static data
 **************************************************************************/
extern ARMUSBFLAGS bUSBFlags;
/* Control endpoint TX/RX buffers */
extern CONTROL_XFER ControlData;
/* ISR static vars */
extern unsigned char Ep1Buf[EP1_PACKET_SIZE];
extern unsigned char Ep2BufTx[EP2_PACKET_SIZE];
extern unsigned char Ep2BufRx[EP2_PACKET_SIZE];
extern unsigned char Ep1Len, Ep2LenTx, Ep2LenRx;

extern unsigned char wf;
extern unsigned char SBufFlag;

/************************************************************************************************
 *USB中断服务程序																				*
 *区分中断源,并执行相应的程序																	*
 ************************************************************************************************/
void EInt0Isr()
{
	unsigned int i_st;
	
	USB_DISABLE_INTERRUPT;
	bUSBFlags.bits.bIn_ISR = 1;
	
	i_st = UsbReadInterruptRegister();
	if(i_st != 0) 
	{
		#ifdef USB_ISR
		printf("\r\nisr = %x", i_st);
		#endif
		
		if(i_st & USB_D12_INT_BUSRESET) 
		{
			bus_reset();
			bUSBFlags.bits.bBus_Reset = 1;
		}
		else 
		{
			if(i_st & USB_D12_INT_EOT) 				dma_eot();
			if(i_st & USB_D12_INT_SUSPENDCHANGE) 	bUSBFlags.bits.bSuspend = 1;
			if(i_st & USB_D12_INT_ENDP0IN) 			ep0_txdone();
			if(i_st & USB_D12_INT_ENDP0OUT) 		ep0_rxdone();
			if(i_st & USB_D12_INT_ENDP1IN) 			ep1_txdone();
			if(i_st & USB_D12_INT_ENDP1OUT) 		ep1_rxdone();
			if(i_st & USB_D12_INT_ENDP2IN) 			main_txdone();
			if(i_st & USB_D12_INT_ENDP2OUT) 		main_rxdone();
		}
	}
	
	bUSBFlags.bits.bIn_ISR = 0;
	USB_ENABLE_INTERRUPT;
	
	rI_ISPC = BIT_EINT0;
}

void bus_reset(void)
{
	
}

/************************************************************************************************
 *端点0接收中断处理程序																			*
 *提取setup包																					*
 *接收主机发往设备的数据																		*
 *程序首先判断是否为setup包,如果是则读取设备请求,并进一步判断设备请求的方向,					*
 *和设备请求是否带有数据,及数据的长度															*
 ************************************************************************************************/
void ep0_rxdone(void)
{
	unsigned char ep_last;
	unsigned char i;

	ep_last = UsbReadLastTransactionStatus(0); 					// 清端点0中断标志
	printf("\r\nEP0RxStatus = %x",ep_last);
	
	if (ep_last & USB_D12_SETUPPACKET) 
	{																// 判断是否为setup包
		ControlData.wLength = 0;
		ControlData.wCount = 0;
		if( UsbReadEndpoint(0, (unsigned char *)(&(ControlData.DeviceRequest)),
			sizeof(ControlData.DeviceRequest)) != sizeof(DEVICE_REQUEST) ) 
		{															// setup包出错,返回
			UsbSetEndpointStatus(0, 1);							
			UsbSetEndpointStatus(1, 1);
			bUSBFlags.bits.bControl_State = USB_IDLE;
			return;
		}
																
		UsbAcknowledgeEndpoint(0);								// 端点应答,释放端点
		UsbAcknowledgeEndpoint(1);
		
		ControlData.wLength = ControlData.DeviceRequest.wLength;	// 设备请求的数据长度
		ControlData.wCount = 0;
	
		if (ControlData.DeviceRequest.bmRequestType & (unsigned char)USB_ENDPOINT_DIRECTION_MASK) 
		{															// 设备->主机
			bUSBFlags.bits.bSetup_Packet = 1;
			bUSBFlags.bits.bControl_State = USB_TRANSMIT; 			// 设置为发送状态		
		} 
		else 
		{															// 主机->设备
			if (ControlData.DeviceRequest.wLength == 0) 
			{														// 无数据的设备请求
				bUSBFlags.bits.bSetup_Packet = 1;
				bUSBFlags.bits.bControl_State = USB_IDLE; 			
			} 
			else 
			{														// 有数据的设备请求
				if(ControlData.DeviceRequest.wLength > MAX_CONTROLDATA_SIZE) 
				{													// 设备请求出错
					bUSBFlags.bits.bControl_State = USB_IDLE;
					UsbSetEndpointStatus(0, 1);
					UsbSetEndpointStatus(1, 1);
				} 
				else 
				{
					bUSBFlags.bits.bControl_State = USB_RECEIVE; 	// 设置为接收状态
				}
			}
		}
	}
	else if (bUSBFlags.bits.bControl_State == USB_RECEIVE) 
	{																// 处于接收状态
		i = UsbReadEndpoint(0, ControlData.dataBuffer + ControlData.wCount,EP0_PACKET_SIZE);
		ControlData.wCount += i;									// 数据计数指针增加
		if( i != EP0_PACKET_SIZE || ControlData.wCount >= ControlData.wLength) 
		{															// 设备请求的数据接收完毕
			bUSBFlags.bits.bSetup_Packet = 1;
			bUSBFlags.bits.bControl_State = USB_IDLE;
		}
	}
	else 
	{
		bUSBFlags.bits.bControl_State = USB_IDLE;
	}
}

/************************************************************************************************
 *端点0发送中断处理程序																			*
 *将设备请求所需数据发给主机																	*
 ************************************************************************************************/
void ep0_txdone(void)
{
	unsigned char ep_last;
	short i = ControlData.wLength - ControlData.wCount;				// 计算剩下的数据的长度

	ep_last = UsbReadLastTransactionStatus(1); 							// 清端点0中断标志
	printf("\r\nLastEP0TxStatus = %x",ep_last);
	
	if (bUSBFlags.bits.bControl_State != USB_TRANSMIT) return;		// 非发送状态,返回
	
	if( i >= EP0_PACKET_SIZE) 
	{																// 剩下数据大于16B,先发送前16B				
		UsbWriteEndpoint(1, ControlData.pData + ControlData.wCount, EP0_PACKET_SIZE);
		ControlData.wCount += EP0_PACKET_SIZE;
		bUSBFlags.bits.bControl_State = USB_TRANSMIT;
	}
	else if( i != 0) 
	{																// 发送剩下的数据
		UsbWriteEndpoint(1, ControlData.pData + ControlData.wCount, i);
		ControlData.wCount += i;
		bUSBFlags.bits.bControl_State = USB_IDLE;
	}
	else if (i == 0){
		UsbWriteEndpoint(1, 0, 0); 							// 发送零数据包
		bUSBFlags.bits.bControl_State = USB_IDLE;					// 发送结束
	}
}


void dma_eot(void)
{
	if(bUSBFlags.bits.bDMA_State == DMA_PENDING)
		bUSBFlags.bits.bSetup_DMA = 1;
	else
		bUSBFlags.bits.bDMA_State = DMA_IDLE;
}

/************************************************************************************************
 *端点1接收中断处理程序																			*
 *																								*
 ************************************************************************************************/
void ep1_rxdone(void)
{
	unsigned char ep_last;
	static unsigned char i;
	printf("\r\nep1_rxdone %d",i);
	i++;

	ep_last = UsbReadLastTransactionStatus(2); 						// 清端点1中断标志
	printf("\r\nLastEP1RxStation = %x",ep_last);

	if (ep_last & USB_D12_SUCCESS) 
	{
		memset(Ep1Buf, 0, sizeof(Ep1Buf));	
		Ep1Len = UsbReadEndpoint(2, Ep1Buf, sizeof(Ep1Buf));		// 读取数据
	}
	
	bUSBFlags.bits.bEP1_RxDone = 1;									// 标志接收到数据
}

/************************************************************************************************
 *端点1发送中断处理程序																			*
 *																								*
 ************************************************************************************************/
void ep1_txdone(void)
{
	unsigned char ep_last;

	printf("\r\nep1_txdone");

	ep_last = UsbReadLastTransactionStatus(3); 								// 请端点1中断标志
	printf("\r\nLastEP1TxStation = %x",ep_last);
}

/************************************************************************************************
 *主端点(端点2)接收中断处理程序																	*
 *																								*
 ************************************************************************************************/
void main_rxdone(void)
{
	unsigned char ep_last;

	USB_DISABLE_INTERRUPT;
	
	ep_last = UsbReadLastTransactionStatus(4); /* Clear interrupt flag */

	if(bUSBFlags.bits.bEP2_RxDone) return;
	
	if (ep_last & USB_D12_SUCCESS) 
	{		
		if(ep_last & 0x80)
        {
            Ep2LenRx = UsbReadEndpoint(4, Ep2BufRx, sizeof(Ep2BufRx)); // 读取数据
            wf = 2;
        }
        else
        {
            Ep2LenRx = 0; 
            wf = 1;
        }
		Ep2LenRx += UsbReadEndpoint(4, Ep2BufRx + Ep2LenRx, sizeof(Ep2BufRx)); // 读取数据

	    bUSBFlags.bits.bEP2_RxDone = 1;
	}
	
}

/************************************************************************************************
 *主端点(端点2)发送中断处理程序																	*
 *																								*
 ************************************************************************************************/
void main_txdone(void)
{
	unsigned char ep_last;
	
	ep_last = UsbReadLastTransactionStatus(5); /* Clear interrupt flag */
	
	//ToDo Usb mass storage work
	switch(gbBulkPipeStage)			
	{
		case S_DATA_TX_PHASE:
			
			gbBulkPipeStage = S_DATA_TX_DONE_PHASE;
		
		case S_DATA_PHASE:
			
			gbCSWStatus = PASS;
			gbBulkPipeStage = S_CSW_PHASE;
			break;
						
		case S_CSW_PHASE:
		
			gbBulkPipeStage = S_CSW_DONE_PHASE;			
			break;
					
		default:
			break;
	}
	//End of Usb mass storage work

}