pe_usb_intr.c

GM8120 linux driver.

///////////////////////////////////////////////////////////////////////////////
//
//	File name: usb_intr.c
//	Version: 1.0
//	Date: 2003/8/05
//
//	Author: Andrew
//	Email: [e-mail]
//	Phone: [phone]
//	Company: Faraday Tech. Corp.
//
//	Description: USB INTERRUPT Transfer test Rountine & relatived subroutine
//
///////////////////////////////////////////////////////////////////////////////
#define USB_INTR_GLOBALS
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "Pe_usb.h"
#include "Pe_usb_pre.h"
#include "FOTG200_peripheral.h"
#include "Pe_my_usbtable.h"

INT8U u8LineOTGCount;
INT8U u8OTGMessageLevel;
INT8U *u8InterruptOTGArray;

INT8U u8Test;

///////////////////////////////////////////////////////////////////////////////
//		vOTG_Interrupt_Initial() 
//		Description: Initial interrupt transfer test variable
//		input: none
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vOTG_Interrupt_Initial(void)
{
	INT8U u8i = 0;
	INT16U u16i;
	static INT8U u8IntTransInit = FALSE;

	if(u8IntTransInit == FALSE)
	{
		u8InterruptOTGArray =  (INT8U *)malloc(2048);
		for (u16i = 0; u16i < 2048; u16i ++)
		{
			u8InterruptOTGArray[u16i] = u8i ++;
		}
		u8IntTransInit = TRUE;
	}
}

///////////////////////////////////////////////////////////////////////////////
//		vOTG_Interrupt_In() 
//		Description: FIFO4 interrupt service process
//		input: none
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vOTG_Interrupt_In(void)
{
	INT32U u32i;
	INT32U u32PacketSize ;
	INT8U *u8Array;
	
#if((OTG_AP_Satus == Bulk_AP) && (Bulk_Satus == Bulk_FIFO_BiDir))
	if(bOTGHighSpeed)
		u32PacketSize = HS_C1_I0_A0_EP3_MAX_PACKET ;
	else
		u32PacketSize = FS_C1_I0_A0_EP3_MAX_PACKET ;
#elif (OTG_AP_Satus == Interrupt_AP)
	if(bOTGHighSpeed)
		u32PacketSize = HS_C1_I0_A0_EP1_MAX_PACKET ;
	else
		u32PacketSize = FS_C1_I0_A0_EP1_MAX_PACKET ;
#endif
	
#if IntTransSizeFix
	u32OTGInterrupt_TX_COUNT = u32PacketSize;
#endif

	u8Array = malloc(u32OTGInterrupt_TX_COUNT);

	for (u32i = 0; u32i < u32OTGInterrupt_TX_COUNT; u32i ++)
	{
		u8Array[u32i] = (u8OTGInterruptCount); 
		u8OTGInterruptCount ++;
	}

//	if(u8OTGMessageLevel & MESS_INFO)
//		printf("L%x: Interrupt_IN...\n", u8LineOTGCount ++);  

	printf("Interrupt count = %d\n", u32OTGInterrupt_TX_COUNT);

#if(OTG_AP_Satus	 == Bulk_AP)
	vOTGDxFWr(FIFO2, u8Array, u32OTGInterrupt_TX_COUNT);
	mUsbFIFODone(FIFO2);
#elif (OTG_AP_Satus == Interrupt_AP)
	vOTGDxFWr(FIFO0, u8Array, u32OTGInterrupt_TX_COUNT);
	mUsbFIFODone(FIFO0);
#endif

	u32OTGInterrupt_TX_COUNT++;
	if(u32OTGInterrupt_TX_COUNT > u32PacketSize)
		u32OTGInterrupt_TX_COUNT = 1;

	free(u8Array);

}

///////////////////////////////////////////////////////////////////////////////
//		vOTG_Interrupt_Out() 
//		Description: FIFO5 interrupt service process
//		input: none
//		output: none
///////////////////////////////////////////////////////////////////////////////
void vOTG_Interrupt_Out(void)
{
#if(OTG_AP_Satus == Bulk_AP)
	// for Bulk Bir-direction test
	INT32U u32IntOutFifoUse = FIFO3;
#else
	// for Interrupt test
	INT32U u32IntOutFifoUse = (bOTGHighSpeed)? FIFO2 : FIFO1;
#endif
	INT16U i,u16Interrupt_RX_Count = mUsbFIFOOutByteCount(u32IntOutFifoUse);
	INT32U u32PacketSize ;
	INT8U *u8Array;

#if((OTG_AP_Satus == Bulk_AP) && (Bulk_Satus == Bulk_FIFO_BiDir))
	if(bOTGHighSpeed)
		u32PacketSize = HS_C1_I0_A0_EP4_MAX_PACKET ;
	else
		u32PacketSize = FS_C1_I0_A0_EP4_MAX_PACKET ;

#elif (OTG_AP_Satus == Interrupt_AP)
	if(bOTGHighSpeed)
		u32PacketSize = HS_C1_I0_A0_EP2_MAX_PACKET ;
	else
		u32PacketSize = FS_C1_I0_A0_EP2_MAX_PACKET ;
#endif

#if IntTransSizeFix
	u32OTGInterrupt_RX_COUNT = u32PacketSize;
#endif
	u8Array = malloc(u32OTGInterrupt_RX_COUNT);

	if(u16Interrupt_RX_Count == u32OTGInterrupt_RX_COUNT)
	{
//		if(u8OTGMessageLevel & MESS_INFO)
//			printf("L%x: Interrupt_Out...\n", u8LineOTGCount ++);
	}
	else
	{
		if(u8OTGMessageLevel & MESS_ERROR)
			printf("L%x: Interrupt_Out Byte Count Error = %x...(Correct = %x)\n", 
				u8LineOTGCount ++, u16Interrupt_RX_Count, u32OTGInterrupt_RX_COUNT);
	}
	
	// Read Interrupt Data from FIFO..
	vOTGDxFRd((INT8U)u32IntOutFifoUse, u8Array, u16Interrupt_RX_Count );
	u8Test = bFOTGPeri_Port(0x1c);
	
	if(memcmp(u8InterruptOTGArray + u8OTGInterruptOutCount, 
			   u8Array, 
			   u32OTGInterrupt_RX_COUNT) != 0)
	{
		#if(OTG_AP_Satus == Bulk_AP)
		// for Bulk Bir-direction test
		mUsbEPinStallSet(EP4);
		#else
		// for Interrupt test
		mUsbEPinStallSet(EP2);
		#endif
	
		if(u8OTGMessageLevel & MESS_ERROR)
		{
			printf("L%x: Interrupt_Out Data error...\n", u8LineOTGCount ++);
#if 0
			printf("Device Get Data...");		
			for(i = 0; i< u16Interrupt_RX_Count; i++)
			{
				if(i % 8 == 0)
					printf("\n");
				printf("%02x  ",u8Array[i]);
			}
			printf("\n");
			
			printf("Correct Data...");		
			for(i = 0; i< u32OTGInterrupt_RX_COUNT; i++)
			{
				if(i % 8 == 0)
					printf("\n");
				printf("%02x  ", *(u8InterruptOTGArray + u8OTGInterruptOutCount + i));
			}			
			printf("\n");
#else
			for(i = 0;i<u32OTGInterrupt_RX_COUNT;i++)
			{
				if(u8InterruptOTGArray[u8OTGInterruptOutCount+i] != u8Array[i])
					printf("L%x: Index(%d/%d) Error = 0x%x, correct = 0x%x\n",u8LineOTGCount ++,
								i+1,u32OTGInterrupt_RX_COUNT,u8Array[i],
								u8InterruptOTGArray[u8OTGInterruptOutCount+i]);
			}
#endif
		}
	}
	u8OTGInterruptOutCount = u8OTGInterruptOutCount + u32OTGInterrupt_RX_COUNT;

	u32OTGInterrupt_RX_COUNT++;
	if(u32OTGInterrupt_RX_COUNT > u32PacketSize)
		u32OTGInterrupt_RX_COUNT = 1;	
	
	free(u8Array);
}