testopposing.c

epson usb2.0 控制芯片 S1R72V05 固件程序。

/*
 * description: Test Proc Opposing
 * Maker	  : Mie.Ono
 * Copyright  : (C)2003,SEIKO EPSON Corp. All Rights Reserved.
 */


//=============================================================================
//include files
//=============================================================================
#include <string.h>
#include <SPRDEF.h>
#include <SPRSTS.h>
#include <OSCall.h>

#include <DebugTask.h>
#include <Reg72V05.h>
#include <TestOpposing.h>
#include <TestAnalog.h>

//=============================================================================
//Constants declaration
//=============================================================================
#define FLOW_LV					3
#define TEST_OPPOSING			"懳岦帋尡拞偵揮憲僄儔乕敪惗"

//=============================================================================
//Macros declaration
//=============================================================================

//=============================================================================
//Structures declaration
//=============================================================================

//=============================================================================
// Variables declaration
//=============================================================================

//=============================================================================
// Static functions
//=============================================================================
static void TestOpposingErr( CHAR* chapter, int fileLine );

/*
//=============================================================================
// Function_Name: TestOpposingRequest
// description	: Issue Opposing examination Request
// argument		: TEST_REQUEST reqParam
//				  unsigned short *pReqData
// return		: long execute result
//=============================================================================
*/
long TestOpposingRequest( TEST_REQUEST reqParam, unsigned short *pReqData )
{

	unsigned int i;
	unsigned short swapData;
	unsigned short savedCH0StartAdrs, savedCH0EndAdrs;
	unsigned char bFraction, *pbDataBuf;
	unsigned short *pwDataBuf;
	unsigned short fifoCount;

	//initialize the variables

	savedCH0StartAdrs = RegRead(REG16_H_CH0StartAdrs);
	savedCH0EndAdrs = RegRead(REG16_H_CH0EndAdrs);
	RegWrite(REG16_H_CH0StartAdrs, 0x00);
	RegWrite(REG16_H_CH0EndAdrs, 0x20);
	RegSet(REG08_H_CHnControl, BIT_CH0FIFO_Clr);
	RegWrite(REG08_H_CH0IntStat, INT_ALL_CLEAR);	//Clear the interrupts


	// Set up the test request
	RegWrite(REG08_H_CH0SETUP_0, reqParam.bmRequestType);
	RegWrite(REG08_H_CH0SETUP_1, reqParam.bRequest);
	RegWrite(REG08_H_CH0SETUP_2, reqParam.wValue_L);
	RegWrite(REG08_H_CH0SETUP_3, reqParam.wValue_H);
	RegWrite(REG08_H_CH0SETUP_4, reqParam.wIndex_L);
	RegWrite(REG08_H_CH0SETUP_5, reqParam.wIndex_H);
	RegWrite(REG08_H_CH0SETUP_6, reqParam.wLength_L);
	RegWrite(REG08_H_CH0SETUP_7, reqParam.wLength_H);

	bFraction = (reqParam.wLength_L & 0x01);
	if( (reqParam.bmRequestType & 0x80) == DATA_OUT ) {
		//Set up the request data.

		pwDataBuf = pReqData;
		RegSet(REG08_H_CH0Join, BIT_JoinCPU_Wr);
		for( i = (reqParam.wLength_L / 2) ; i > 0; i-- ) {
			swapData = *pwDataBuf;
			RegWrite(REG16_FIFO_Wr, swapData);
			pwDataBuf++;
		}
		if( bFraction ){
			pbDataBuf = (unsigned char *)pwDataBuf;
			RegWrite(REG08_FIFO_Wr_H, *pbDataBuf);
		}
		RegClear(REG08_H_CH0Join, BIT_JoinCPU_Wr);
		RegModify(REG08_H_CH0Config_1, MASK_TID, TID_OUT_DATA);
	} else {
		memset( pReqData, 0, TEST_TYPE_RESULT_REQ_LEN );
		RegModify(REG08_H_CH0Config_1, MASK_TID, TID_IN_DATA);
	}

	RegModify(REG08_H_CH0Config_0, MASK_ACK_Cnt, 1<<SHIFT_ACK_Cnt);
	RegModify(REG08_H_CH0Config_0, MASK_SpeedMode, (RegRead(REG08_H_NegoControl_1) & MASK_PortSpeed)>>SHIFT_SpeedMode);

	RegWrite(REG08_H_CH0MaxPktSize, 0x10);
	RegWrite(REG16_H_CH0TotalSize, reqParam.wLength_L);

	/* Start transfer */
	RegSet(REG08_H_CTL_SupportControl, BIT_CTL_SupportGo);

	//CTL_SupportCmp interrupt check
	while(1) {
		if( (RegRead(REG08_H_CH0IntStat) & MASK_CTL_SupportCmp) == BIT_CTL_SupportCmp ) {
			DBG_FlowStrPrint("\r\n[CTL_SupportCmp interrupt reception.]\r\n\r\n", FLOW_LV);
			 if( (reqParam.bmRequestType & 0x80) == DATA_IN ) {

				RegSet(REG08_H_CH0Join, BIT_JoinCPU_Rd);
				do{
					fifoCount = RegRead(REG16_FIFO_RdRemain);
				}while((fifoCount & 0x8000) == 0 );
				fifoCount &= 0x7FFF;

				if( fifoCount != 0 ){
					//Get the request data
					pwDataBuf = pReqData;
					for( i = (reqParam.wLength_L / 2) ; i > 0; i-- ) {
						swapData = RegRead(REG16_FIFO_Rd);
						*pwDataBuf = swapData;
						pwDataBuf++;
					}
					if( bFraction ){
						pbDataBuf = (unsigned char *)pwDataBuf;
						*pbDataBuf = RegRead(REG08_FIFO_ByteRd);
					}
				}
				RegClear(REG08_H_CH0Join, BIT_JoinCPU_Rd);
			}
			break;
		} else if( (RegRead(REG08_H_CH0IntStat) & MASK_CTL_SupportStop) == BIT_CTL_SupportStop ){
			DBG_FlowStrPrint("\r\n[CTL_SupportStop interrupt reception.]\r\n\r\n", FLOW_LV);

			return STATUS_UNSUCCESSFUL;
		} else if( (reqParam.bmRequestType & 0x80) == DATA_IN ) {

			RegSet(REG08_H_CH0Join, BIT_JoinCPU_Rd);
			do{
				fifoCount = RegRead(REG16_FIFO_RdRemain);
			}while((fifoCount & 0x8000) == 0 );
			fifoCount &= 0x7FFF;

			if( fifoCount != 0 ){
				// Get the request data
				pwDataBuf = pReqData;
				for( i = (reqParam.wLength_L / 2) ; i > 0; i-- ) {
					swapData = RegRead(REG16_FIFO_Rd);
					*pwDataBuf = swapData;
					pwDataBuf++;
				}
				if( bFraction ){
					pbDataBuf = (unsigned char *)pwDataBuf;
					*pbDataBuf = RegRead(REG08_FIFO_ByteRd);
				}
			}
			RegClear(REG08_H_CH0Join, BIT_JoinCPU_Rd);
		}
	}


	// TotalSizeCmp interrupt check
	if( (RegRead(REG08_H_CH0IntStat) & MASK_TotalSizeCmp) != BIT_TotalSizeCmp ) {
		TestOpposingErr( TEST_OPPOSING, __LINE__ );
	}

	// TranGo check
	if( (RegRead(REG08_H_CH0Config_0) & MASK_TranGo) == BIT_TranGo ) {
		TestOpposingErr( TEST_OPPOSING, __LINE__ );
	}

	// ChangeCondition interrupt check
	if( (RegRead(REG08_H_CH0IntStat) & MASK_ChangeCondition) == BIT_ChangeCondition ) {
		TestOpposingErr( TEST_OPPOSING, __LINE__ );
	}

	//ConditionCode check
	if( RegRead(REG08_H_CH0ConditionCode) != NO_ERROR ) {
		TestOpposingErr( TEST_OPPOSING, __LINE__ );
	}

	RegWrite(REG16_H_CH0StartAdrs, savedCH0StartAdrs);
	RegWrite(REG16_H_CH0EndAdrs, savedCH0EndAdrs);

	return STATUS_SUCCESS;
}

/*
//=============================================================================
// Function_Name: TestOpposingCompare
// description	: Opposing examination compare
// argument		: unsigned char *pReceiveData
//				  unsigned long receiveSize
//				  unsigned char testDataType
//				  unsigned char startData (only when Test data increment)
// return		: unsigned long error
//=============================================================================
*/
unsigned long TestOpposingCompare( unsigned char *pReceiveData, unsigned long receiveSize, unsigned char testDataType, unsigned char startData )
{
	unsigned long i, error;
	unsigned char checkData;

	//Data type check
	if( testDataType == TEST_DATA_INC ) {
		/* 0 = Increment */
		for( i = error = 0, checkData = startData ; i < receiveSize ; i++ ) {
			if( *( pReceiveData + i ) != checkData ) {
				error++;
			}
			if( checkData == 0xFF ) {
				checkData = 0;
			} else {
				checkData++;
			}
		}

	} else {

		//Parameter check
		if( startData != 0 ) {
			TestOpposingErr( TEST_OPPOSING, __LINE__ );
			return 0;
		}

		//Data type check
		switch( testDataType ) {
			/* 1 = All 0x00 */
			case TEST_DATA_ALL_00 :
				checkData = 0x00;
				break;

			/* 2 = All 0xFF */
			case TEST_DATA_ALL_FF :
				checkData = 0xFF;
				break;

			/* 3 = All 0x7C */
			case TEST_DATA_ALL_7C :
				checkData = 0x7C;
				break;

			/* 4 = All 0x7E */
			case TEST_DATA_ALL_7E :
				checkData = 0x7E;
				break;

			/* Had not run into here  */
			default :
				TestOpposingErr( TEST_OPPOSING, __LINE__ );
				return 0;
				//break;
		}

		for( i = error = 0 ; i < receiveSize ; i++ ) {
			if( *( pReceiveData + i ) != checkData ) {
				error++;
			}
		}
	}

	return error;
}

/*
//=============================================================================
// Function_Name: TestOpposingErr
// description	: Test Opposing Proc Error
// argument		: UCHAR* chapter Item
//				: int fileLine	 The line number of the error
// return		: none
//=============================================================================
*/
static void TestOpposingErr( CHAR* chapter, int fileLine )
{
	DBG_FlowStrPrint( "\r\n", FLOW_LV);
	OS_DlyTsk(1);
	DBG_FlowValPrint( PRINT_DECIMAL_MODE, DBG_STORE_DWORD, fileLine, FLOW_LV);
	OS_DlyTsk(1);
	DBG_FlowStrPrint( "峴栚偱僄儔乕敪惗!\r\n", FLOW_LV);
	OS_DlyTsk(1);
}