verify.c

飞利浦公司usb2.0芯片isp1581的通用驱动代码

/*
   //*************************************************************************
   //
   //                  P H I L I P S   P R O P R I E T A R Y
   //
   //           COPYRIGHT (c)   2000 BY PHILIPS SINGAPORE.
   //                     --  ALL RIGHTS RESERVED  --
   //
   // Project:		ISP1581 EVA board
   // File Name:	VERIFY.C
   // Author:		Qian Jiang
   // Created:		Sept. 1, 2000
   // Modified:
   // Revision:		0.0
   //
   //*************************************************************************
*/
/* 
//*************************************************************************
//		
13, Jan 2002 -- Jiang Qian
		This program is configurable for fast cycle time DMA -- 95144 CPLD has to be reprogrammed
		High speed DMA configurate register 0x36e;
		Configure the cpld dma controller via Local_dma_cfg();
		Test different buffer size of bulk possible - reassigne maxepsize_HS, maxepsize_FS value;
		Debug port is not used address of ISP1581 - 0xff;
		debug output code assgined - easy for LA capturing;

//*************************************************************************
*/

#include <stdio.h>
#include <string.h>
#include <dos.h>

#include "BasicTyp.h"

#include "USB200.h"
#include "Hal4Sys.h"
#include "ISP1581.h"
#include "Chap_9.h"

#include "VERIFY.h"
#include "mainloop.h"
#include "rwreg.h"


// ***************************************************************************
#define SETUP_DMA_REQUEST 		0x0471
#define GET_FIRMWARE_VERSION    0x0472
//#define DMA_BUFFER_SIZE		64000
//#define idata
extern IO_REQUEST idata ioRequest;
TWIN_CONFIG idata twin_config;

extern unsigned long dmaBuffer;
unsigned long ioBuffer;
extern GLOBE_VARIABLE globe_variable;
extern CONTROL_XFER ControlData;
extern ISP1581FLAGS bISP1581flags;

/*
   //*************************************************************************
   // Subroutines
   //*************************************************************************
*/

void ISP1581Bus_Watchdog(void)
{
	/*
	// No support now, just stall it.
	*/
	ISP1581Bus_StallEP0();
}


void ISP1581Bus_ControlEntry(void)
{
	/*
	// No support now, just stall it.
	*/
	ISP1581Bus_StallEP0(); /* Unknown command */
}

void reserved(void)
{
	/*
	// Undefined commands, stall them
	*/
	ISP1581Bus_StallEP0(); /* Unknown command */
}


void read_write_register(void)
{
	unsigned char i;

	if(ControlData.DeviceRequest.bmRequestType & (unsigned char)USB_ENDPOINT_DIRECTION_MASK) {

#ifdef debug
		if(bISP1581flags.bits.verbose)
			cprintf("Read Registers: Offset = 0x%x, Length = 0x%x, Index = 0x%x.\r\n",
				ControlData.DeviceRequest.wValue,
				ControlData.DeviceRequest.wLength,
				ControlData.DeviceRequest.wIndex);

#endif
		if(ControlData.DeviceRequest.wIndex == GET_FIRMWARE_VERSION &&
			ControlData.DeviceRequest.wValue == 0 &&
			ControlData.DeviceRequest.wLength == 1)
			{
				get_firmware_version();
			}
		else if(ControlData.DeviceRequest.wIndex == TWIN_CONFIGURATION)
		{
			RaiseIRQL();
			get_twin_configuration();
			LowerIRQL();
		}
		else
		{
//			Chap9_ControlWriteHandshake(); // debug, while stall comes for no reason.
			Chap9_StallEP0();
#ifdef debug
			key2go();
			cprintf("stall: get firmware version\r\n");
#endif
		}
	}	// if read register
	else{
#ifdef debug
		if(bISP1581flags.bits.verbose) {

			cprintf("Write Registers: Offset = 0x%x, Length = 0x%x, Index = 0x%x.\r\n",
				ControlData.DeviceRequest.wValue,
				ControlData.DeviceRequest.wLength,
				ControlData.DeviceRequest.wIndex);

			cprintf("Data: ");
			for(i = 0; i < ControlData.DeviceRequest.wLength; i ++)
				cprintf("0x%x, ", *((ControlData.dataBuffer)+i));
			cprintf("\r\n");
		}
#endif
		if(ControlData.DeviceRequest.wIndex == SETUP_DMA_REQUEST &&
			ControlData.DeviceRequest.wValue == 0 &&
			ControlData.DeviceRequest.wLength == 6)
		{
			RaiseIRQL();
			setup_dma_request();
			LowerIRQL();
		}
		else if(ControlData.DeviceRequest.wIndex == TWIN_CONFIGURATION)
		{
			RaiseIRQL();
			set_twin_configuration();
			LowerIRQL();
		}
//Work around in case data transfer is abort due at host side.
		else if(ControlData.DeviceRequest.wIndex == GET_FIRMWARE_VERSION)
		{
			RaiseIRQL();
			transfer_error_handler();
			bISP1581flags.bits.FREE_DMA_CHANNEL = 1;
			LowerIRQL();
		}
		else
		{
			Chap9_StallEP0();
#ifdef debug
			key2go();
			cprintf("Stall: setup dma get, but wrong data content.\r\n");
#endif
		}
	}	// if write register
}

void setup_dma_request()
{
	memcpy((unsigned char *)&ioRequest + ControlData.DeviceRequest.wValue,
		ControlData.dataBuffer,
		ControlData.DeviceRequest.wLength);

	ioRequest.uSize = SWAP(ioRequest.uSize);
	ioRequest.uAddressL = SWAP(ioRequest.uAddressL);

	if(ioRequest.uSize > DMA_BUFFER_SIZE) // Unaccepted request
	{
		Chap9_StallEP0();
		cprintf("stall: ioRequest.uSize > DMA_BUFFER_SIZE.\n");
	}
	else
	{
		RaiseIRQL();
		bISP1581flags.bits.setup_dma = 1;
#ifdef debug
//		cprintf("SETUP DMA = 1: ");
#endif
		LowerIRQL();
	} // else if accepted request
}

void get_firmware_version()
{
	unsigned char i;

	i = 0x01; // firmware version number, return 0x01 for PC kit version 1
	ISP1581Bus_SingleTransmitEP0(&i, 1);
}

/*
   //*************************************************************************
   // ISP1581Bus support functions
   //*************************************************************************
*/

void ISP1581Bus_StallEP0(void)
{
	Chap9_StallEP0();

}

void ISP1581Bus_SingleTransmitEP0(UCHAR * buf, UCHAR len)
{
	ISP1581_WriteControlEndpoint(buf, len);

	RaiseIRQL();
	if(!ControlData.Abort)
    {
		ControlData.wLength = ControlData.wCount = len;
        bISP1581flags.bits.DCP_state = USBFSM4DCP_CONTROLREADHANDSHAKE;
#ifdef debug
		cprintf("^_^%hx", bISP1581flags.bits.DCP_state);
#endif
    }
	LowerIRQL();

}

void ISP1581Bus_BurstTransmitEP0(UCHAR * pData, USHORT len)
{
	ControlData.wCount = 0;
	if(ControlData.wLength > len)
		ControlData.wLength = len;

	ControlData.Addr.pData = pData;
	if( ControlData.wLength >= EP0_PACKET_SIZE)
	{
		ISP1581_WriteControlEndpoint(ControlData.Addr.pData, EP0_PACKET_SIZE);
		/*
		// Minimize the MISSING Window for SETUP Packet
		// Here give a chance to ISR whose interrupt is caused by Setup Packet
		*/
		RaiseIRQL();
		if(!ControlData.Abort)
		{
			ControlData.wCount += EP0_PACKET_SIZE;
			bISP1581flags.bits.DCP_state = USBFSM4DCP_DATAIN;
#ifdef debug
			cprintf("^_^%hx", bISP1581flags.bits.DCP_state);
#endif
		}

		LowerIRQL();

	}
	else
	{
		ISP1581_WriteControlEndpoint(pData, ControlData.wLength);
		/*
		// Minimize the MISSING Window for SETUP Packet
		// Here give a chance to ISR whose interrupt is caused by Setup Packet
		*/
		RaiseIRQL();
		if(!ControlData.Abort)
		{
			ControlData.wCount += ControlData.wLength;
			bISP1581flags.bits.DCP_state = USBFSM4DCP_DATAIN;
#ifdef debug
			cprintf("^_^%hx", bISP1581flags.bits.DCP_state);
#endif
		}
		LowerIRQL();
	}
}

void setup_dma(void)
{
#ifdef debug
//	cprintf("\r\nvendor request for bulk, x%xh, x%xh, x%xh, x%xh",
//			ioRequest.bAddressH,ioRequest.uAddressL,ioRequest.bCommand,
//			ioRequest.uSize);
#endif
	if(ioRequest.bCommand & 0x80)
	{
		Config_DMA();
	}
	else
	{
		setup_io();
#ifdef debug
		cprintf("SETUP IO: ");
#endif
	}

	bISP1581flags.bits.DCP_state = USBFSM4DCP_CONTROLOUTDONE;
#ifdef debug
	cprintf("^_^%hx", bISP1581flags.bits.DCP_state);
#endif
	return;
}

// it only works on PC evaluation kit.
void setup_io(void)
{
	unsigned long offset;
//	unsigned short far *fp;
	unsigned short seg, off;

	bISP1581flags.bits.dma_endpoint = 0; // clear dma flag.
	seg = ISP1581_GetIntEnableLow();
	ISP1581_SetIntEnableLow(seg|bulkinendpointinterrupt|bulkoutendpointinterrupt);

	offset = (((unsigned long)ioRequest.bAddressH)<<16)
		+ ioRequest.uAddressL;

	ioBuffer = dmaBuffer + offset;

	bISP1581flags.bits.dma_state = DMA_PIO;
#ifdef debug1
	cprintf("dma_state PIO %x ",bISP1581flags.bits.dma_state);
#endif

	if(ioRequest.bCommand & 0x1)
	{
		globe_variable.ioINSize = ioRequest.uSize;
		globe_variable.ioINCount = 0;
/*		seg = (ioBuffer + globe_variable.ioINCount)>>4;
		off = (ioBuffer + globe_variable.ioINCount)&0xf;
		fp = MK_FP(seg, off);
*/		cprintf("bulk in  ");
		transmit_bulkendpoint(bulkinendpointindex);
/*		if(globe_variable.ioINSize > globe_variable.maxepsize_bulk)
		{
			ISP1581_WriteBulkEndpoint(bulkinendpointindex, fp, globe_variable.maxepsize_bulk);
			globe_variable.ioINCount += globe_variable.maxepsize_bulk;
		}
		else