mainloop.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:	MAINLOOOP.C
   // Author:		Qian Jiang
   // Created:		Sept. 1, 2000
   // Modified:
   // Revision:		0.0
   //
   //*************************************************************************
*/
/* 
//*************************************************************************
//		
13, Jan 2002 -- Jiang Qian
	move some of the variables to GLOBE_VARIABLE structure, make it easy to find.

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

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

#include <bios.h>
#include <dos.h>
#include <malloc.h>
#include <conio.h>

#include "BasicTyp.h"
#include "common.h"

#include "mainloop.h"

#include "usb200.h"
#include "Hal4sys.h"
#include "ISP1581.h"

#include "chap_9.h"
#include "verify.h"
#include "iso.h"

//************************************************************************
// Jiang Qian
unsigned long dmaBuffer;
extern unsigned long ioBuffer;
unsigned short far *privateBuffer;
unsigned long isoBuffer;
GLOBE_VARIABLE globe_variable;

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

/*
//*************************************************************************
// USB protocol function pointer arrays
//*************************************************************************
*/

IO_REQUEST idata ioRequest;

#define MAX_STANDARD_REQUEST    0x0D
code void (*StandardDeviceRequest[])(void) =
{
	Chap9_GetStatus,
	Chap9_ClearFeature,
	Chap9_StallEP0,
	Chap9_SetFeature,
	Chap9_StallEP0,
	Chap9_SetAddress,
	Chap9_GetDescriptor,
	Chap9_StallEP0,
	Chap9_GetConfiguration,
	Chap9_SetConfiguration,
	Chap9_GetInterface,
	Chap9_SetInterface,
	Chap9_StallEP0
};


code CHAR * _NAME_USB_REQUEST_DIRECTION[] =
{
"Host_to_device",
"Device_to_host"
};

code CHAR * _NAME_USB_REQUEST_RECIPIENT[] =
{
"Device",
"Interface",
"Endpoint(0)",
"Other"
};

code CHAR * _NAME_USB_REQUEST_TYPE[] =
{
"Standard",
"Class",
"Vendor",
"Reserved"
};

code CHAR * _NAME_USB_STANDARD_REQUEST[] =
{
"GET_STATUS",
"CLEAR_FEATURE",
"RESERVED",
"SET_FEATURE",
"RESERVED",
"SET_ADDRESS",
"GET_DESCRIPTOR",
"SET_DESCRIPTOR",
"GET_CONFIGURATION",
"SET_CONFIGURATION",
"GET_INTERFACE",
"SET_INTERFACE",
"SYNC_FRAME"
};
/*
   //*************************************************************************
   // Class device requests
   //*************************************************************************
*/
#define MAX_CLASS_REQUEST    0x00
code void (*ClassDeviceRequest[])(void) =
{
    ML_Reserved
};

code CHAR * _NAME_USB_CLASS_REQUEST[] =
{
   " ML_Reserved"
};

/*
//*************************************************************************
// Vendor Device Request
//*************************************************************************
*/
//#define MAX_VENDOR_REQUEST    0x02
#define MAX_VENDOR_REQUEST    0x0f

code void (*VendorDeviceRequest[])(void) =
{  
	EnableIsoMode,
//	reserved,
	ISP1581Bus_ControlEntry,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	read_write_register,
	reserved,
	reserved,
	reserved
};
/* 0x00 for Vendor request of PHILIPS ISP1581BUS.
//		bmRequestType = 0x41 or 0xC1
//		bRequest = 0x00		ISP1581Bus_Watchdog
//		wValue   =          // Low Word for encription
//		wIndex	 =          // High word for encription
//		wLength  = 0x10     // 16 bytes Secuity Number
//
*/

/* 0x01 for Vendor request of PHILIPS ISP1581BUS.
//		bmRequestType = 0x41 or 0xC1
//		bRequest = 0x01		ISP1581Bus_ControlEntry
//		wValue   =
//		wIndex	 =
//		wLength  =
//
*/

/* 0x0C for Vendor request of PHILIPS D12 PC kit DMA request.
//		bmRequestType = 0x40
//		bRequest = 0x0C		ISP1581Bus_ControlEntry
//		wValue   =	0x0
//		wIndex	 =	0x0471
//		wLength  =	0x6
//
*/

code CHAR * _NAME_USB_VENDOR_REQUEST[] =
{
"ISP1581 Iso Transfer",
"Philips ISP1581 Unsupport Command Testing",
"RESERVED",
"RESERVED",
"RESERVED",
"RESERVED",
"RESERVED",
"RESERVED",
"RESERVED",
"RESERVED",
"RESERVED",
"RESERVED",
"ISP1581 Data Transfer",
"RESERVED",
"RESERVED",
"RESERVED",
};


/*
//*************************************************************************
//  Public static data
//*************************************************************************
*/

ISP1581FLAGS bISP1581flags;

CONTROL_XFER ControlData;

extern ULONG Hal4Sys_ClockTicks;
extern ULONG Isr_Clock;
extern IO_REQUEST idata ioRequest;
extern GLOBE_VARIABLE globe_variable;

/*
//*************************************************************************
//  Main Function
//*************************************************************************
*/
void main(void)
{
	BOOL in_loop = TRUE;
	UCHAR key, i;
	ULONG ClockSec, last_clk;
	UCHAR EP0Status;
	unsigned int c;

#ifdef dma_on_local
#ifdef debug
//			cprintf(" dma_on_local main ");
#endif
	Local_dma_cfg(dma_ctl_rst); // initialize cpld dma to reset.
#ifdef debug
	textattr(0x07);
#endif
#endif
	// clear firmware state machine;
	Device_Initiate();
	Sample_INT();

#ifdef debug
//	if(ISP1581_ReadInterruptRegisterLow() && int_susp)
//	{
//		cprintf("Issue suspend command after configuration");
//		ISP1581_GoSuspend();
//	}
//	else
//		cprintf("no suspend find after configuration");
#endif

	/* Main program loop */
//		Sample_INT();
	while( in_loop ){

//		ISP1581_SetDMACounterLow(0);  //0x40
//		ISP1581_SetDMACounterHigh(0x00);		// no longer than 64k bytes each transfer;
		if (bISP1581flags.bits.timer)
		{
			RaiseIRQL();
			bISP1581flags.bits.timer = 0;
			LowerIRQL();

/*			ClockSec = Hal4Sys_ClockTicks*10/182;
			if(ClockSec != last_clk)
			{
					cprintf("\rIdle time = %ld sec.", (Hal4Sys_ClockTicks - Isr_Clock)*10/182);
					cprintf("\r");
					last_clk = ClockSec;
			}

*/		}

		Sample_INT();

#ifdef debug
// TESTING: Read DMA counter......
/*
		if(bISP1581flags.bits.dma_state == DMA_RUNNING)
		{
			textattr(0x04);
			cprintf("%x,%x",ISP1581_GetDMACounterLow(),ISP1581_GetDMACounterHigh());
			textattr(0x07);
		}

*/
#endif
		if( bioskey(1) ) {
			key = bioskey(0);
			key &= 0xff;
			switch(key) {
				case 0x1b: /* ESC */
					in_loop = FALSE;
					break;
				case 'a':
					cprintf("\r\nConnect D+ pull up");
					ISP1581_SetMode( mode_glintena|mode_wkupcs|mode_softct);
					break;
				case 'c':
					cprintf("\r\nReConnect D+ pull up, get out disconnect status with soft reset");
					ISP1581_ResetDevice();
					Reconnect();
					break;
				case 'd':
					cprintf("\r\nDisconnect D+ pull up");
					ISP1581_SetMode(mode_glintena|mode_wkupcs);
					break;
				case 'e': // reset dma for and validate a short pktff
						ioRequest.uSize = 1530;
						ioRequest.bCommand = 0x81;
						ioRequest.bAddressH = 0;
						ioRequest.uAddressL = 0;
						dma_start(&ioRequest);
						ISP1581_SetDMAHDCfg(dmahd_dreqpolh|dmahd_eotpolh);
						ISP1581_SetDMAConfig(dmacfg_burst1|dmacfg_modediorw|dmacfg_width16);
						ISP1581_SetDMAIntMask(dmaint_oddint|dmaint_extereot|dmaint_intereot|dmaint_xferok);

						ISP1581_SetDMACounterLow(ioRequest.uSize+1024);
						ISP1581_SetDMACounterHigh(0x00);		// no longer than 64k bytes each transfer;
						ISP1581_SetDMAEP(bulkinendpointindex);
						bISP1581flags.bits.dma_endpoint = bulkinendpointindex;
						c = ISP1581_GetIntEnableLow();
						ISP1581_SetIntEnableLow(c&(~bulkinendpointinterrupt));
						ISP1581_SetDMACMD(dmacmd_gdmaread);
//						ISP1581_SetDMACMD(dmacmd_reset);
					break;
				case 'f':
						ISP1581_SetDMAEP(bulkoutendpointindex);
						dma_start(&ioRequest);

						ISP1581_SetDMAHDCfg(dmahd_dreqpolh|dmahd_eotpolh);
						ISP1581_SetDMAConfig(dmacfg_burst32|dmacfg_modediorw|dmacfg_width16);
						ISP1581_SetDMAIntMask(dmaint_oddint|dmaint_extereot|dmaint_intereot|dmaint_xferok);

						ISP1581_SetDMACounterLow(ioRequest.uSize);
						ISP1581_SetDMACounterHigh(0x00);		// no longer than 64k bytes each transfer;
						ISP1581_SetDMAEP(EPINDEX4EP01IN);
						bISP1581flags.bits.dma_endpoint = EPINDEX4EP01IN;
						c = ISP1581_GetIntEnableLow();
						ISP1581_SetIntEnableLow(c&(~bulkinendpointinterrupt));
						ISP1581_SetDMACMD(dmacmd_gdmaread);
					break;
				case 'h':
//					ISP1581_SetDMAHDCfg(dmahd_dreqpolh|dmahd_ackpolh);
//					ISP1581_SetDMACMD(dmacmd_gdmaread);
					ISP1581_SetDMACMD(dmacmd_validatebuffer);
					break;
				case 'm':
					Config_DMA();  // dma control configuration;
					break;
				case 'n':
					cprintf("\r\nReset DMA");
					ISP1581_SetDMAHDCfg(dmahd_dreqpolh|dmahd_dackpolh);
//					ISP1581_SetDMACMD(dmacmd_gdmaread);
					ISP1581_SetDMACMD(dmacmd_reset);
// ******************
//for test purpose only, clear all dma state for a new transfer to start;
					bISP1581flags.bits.dma_state = DMA_IDLE;
//*******************
					Chap9_StallEP0InControlWrite();
					break;
				case 'r':
					cprintf("\r\nReset DMA");
					ISP1581_SetDMAHDCfg(dmahd_dreqpolh|dmahd_dackpolh);
//					ISP1581_SetDMACMD(dmacmd_gdmaread);
					ISP1581_SetDMACMD(dmacmd_reset);
					break;
				case 's':
					bISP1581flags.bits.dma_state = DMA_IDLE;
					break;
				case 'w':
					ISP1581_SendResume();
					cprintf("\rRemote wake, Resume signal sent..\r\n");
					break;
				case 'v':
					cprintf("bISP1581flags.bits.dma_state %x ", bISP1581flags.bits.dma_state);
					break;
				case 'u':
					bISP1581flags.bits.dma_state = 0;
					break;
/*				case 'R':
					reconnect_USB();
					break;

				case 'v':
					if(bISP1581flags.bits.verbose == 0) {
						cprintf("Verbose Mode = ON.\r\n\n");
						bISP1581flags.bits.verbose = 1;
					}
					else {
						cprintf("Verbose Mode = OFF.\r\n\n");
						bISP1581flags.bits.verbose = 0;
					}
					break;
				case 'T':
					if(bISP1581flags.bits.dbg == 0) {
						cprintf("Debug Mode = ON.\r\n");
						bISP1581flags.bits.dbg = 1;
						cprintf("Verbose Mode = ON.\r\n");
						bISP1581flags.bits.verbose = 1;
					}
					else {
						cprintf("Debug Mode = OFF.\r\n");
						bISP1581flags.bits.dbg = 0;
					}
					break;
*/				default:
					break;
			}
		}

		if (bISP1581flags.bits.suspend)
		{
			textattr(0x06);
			cprintf("USB_SUSPEND ");
			textattr(0x07);
#ifdef debug
			debug_out(debug_code_gosuspend);
#endif
			RaiseIRQL();
			suspend_change();
			bISP1581flags.bits.suspend= 0;
			LowerIRQL();
		} /* if suspend change*/

		Sample_INT();

		if (bISP1581flags.bits.DCP_state == USBFSM4DCP_REQUESTPROC && bISP1581flags.bits.CONTROL_HANDLE_DONE == 1 && !ControlData.Abort)
		{
			//cprintf("get into request process");
			RaiseIRQL();
//			cprintf("\r\nDevice request handler");
			bISP1581flags.bits.CONTROL_HANDLE_DONE = 0;
			DeviceRequest_Handler();
			LowerIRQL();
			//cprintf("get out of request process");
		} /* if setup_packet for DeviceRequest*/


		Sample_INT();

#ifdef debug
		if (bISP1581flags.bits.setup_dma == 1 && bISP1581flags.bits.dma_state !=DMA_RUNNING)
#else
		if (bISP1581flags.bits.setup_dma == 1 && (bISP1581flags.bits.dma_state == DMA_IDLE||bISP1581flags.bits.FREE_DMA_CHANNEL == 1))
#endif
		{
			RaiseIRQL();
			bISP1581flags.bits.setup_dma = 0;
			bISP1581flags.bits.FREE_DMA_CHANNEL = 0;
//			setup_dma_request();
			setup_dma();
			LowerIRQL();
		} // if setup_dma

		Sample_INT();

		if (bISP1581flags.bits.DCP_state == USBFSM4DCP_CONTROLOUTDONE)
		{
//			cprintf("\r\nControl Write");
			Chap9_ControlWriteHandshake();
		}

		Sample_INT();
		if (bISP1581flags.bits.ISO_CONFIG)
		{
			bISP1581flags.bits.ISO_CONFIG = 0;
			ISO_CONFIG();
		}

		Sample_INT();

	} // Main Loop

	on_exit();
}

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

void SetupToken_Handler(void)
{
	/*
	// Normal path
	// Setup Transaction starts after a completed Control Transfer.
	*/
	RaiseIRQL();
	bISP1581flags.bits.At_IRQL1 = 1;
	ControlData.Abort = FALSE;

	ControlData.wLength = 0;
	ControlData.wCount = 0;

	if(ISP1581_ReadControlEndpointSetup((UCHAR *)(&(ControlData.DeviceRequest))) == sizeof(DEVICE_REQUEST))