sl811hst.c

三星公司的ARM44B0的SL811测试程序

////////////////////////////////////////////////////////////////////////////////
// Cypress Semiconductor - Customer Design Center 
////////////////////////////////////////////////////////////////////////////////
// File:		sl811hst.c
// Purpose:	    Contains SL811-related control firmware. 
//              Based on SL811HST code written by cxn.
// Copyright (c) 2002 Cypress Semiconductor. May not be reproduced without permission.
// See the license agreement for more details.
////////////////////////////////////////////////////////////////////////////////

#include "..\sl811\host_811.h"
#include "..\target\def.h"
#include "..\target\44blib.h"

//*****************************************************************************************
// SL811H Modules (major routines only): 
//*****************************************************************************************
// 1) usbXfer()		: handles usd data transfer, SETUP,IN, OUT
// 2) ep0Xfer()		: handles endpoint zero control pipe
// 3) DataRW()		: handles data endpoint transfer pipe
// 4) EnumUsbDev() 	: device enum(HID/HUB), excl. multi-interface
// 6) speed_detect(): SL811H slave device attach/speed detect
// 7) slave_detect(): Main loop control between SL811H & EZUSB & GUI

#define	SL811H_ADDR	0x06000000		//USB board,A1=0;
#define	SL811H_DATA	0x06000002		//USB board,A1=1;
//--------------------------------------------------------------------
#define USBADDR (*(volatile unsigned char *)0x06000000) //USB board,A1=1;
#define USBDATA (*(volatile unsigned char *)0x06000002) //USB board,A1=0
//--------------------------------------------------------------------


BYTE 			DBUF[256];		// at 0x2000 for general descriptors data
BYTE 			STATUS[8];		// for status data buffer
BYTE			REGBUFF[16];    // Buffer for Register Data
BYTE 			HOSTCMD[8];		// EZUSB's OUT1 host command data
BYTE 			pHOSTCMD[8];	// previous data transfer info, during data transfer
BYTE 			HubChange[1];	// Hub port endpoint 1 data status
BYTE 			DataBufLen;		// EZUSB's IN #3 data transfer buffer length
BYTE 			pNumPort;		// Number of downstream ports on hub
BYTE			remainder;		// Remaining byte in a USB transfer
pUSBDEV  		uDev[MAX_DEV];	// Multiple USB devices attributes, Max 5 devices
pHUBDEV			uHub;			// Struct for downstream device on HUB
pDevDesc  		pDev;			// Device descriptor struct
pCfgDesc 		pCfg;			// Configuration descriptor struct
pIntfDesc 		pIfc;			// Interface descriptor struct
pEPDesc 		pEnp;			// Endpoint descriptor struct
pStrDesc 		pStr;			// String descriptor struct
pHidDesc 		pHid;			// HID class descriptor struct
pHubDesc 		pHub;			// HUD class descriptor struct
pPortStatus		pStat;			// HID ports status

//*****************************************************************************************
// Boolean Logic Defines
//*****************************************************************************************
BOOL  	SLAVE_FOUND;				// Slave USB device found
BOOL  	SLAVE_ENUMERATED;			// slave USB device enumeration done
BOOL  	FULL_SPEED;					// Full-Speed = TRUE, Low-Speed = FALSE
BOOL 	BULK_OUT_DONE;				// Set when EZUSB's OUT1 hostcmd xfer is done
BOOL 	CONFIG_DONE;				// Set when EZUSB completes its enumeration process.
BOOL 	TIMEOUT_ERR;				// timeout error during data endpoint transfer
BOOL	DATA_STOP;					// device unplugged during data transfer
BOOL	DATA_INPROCESS;				// set when we are in a data pipe transfer
BOOL	pLS_HUB;					// indicate previous command is a LS device on hub
BOOL	dsPoll;				        // poll downstream port conections
BOOL 	bData1;

//*****************************************************************************************
// Byte Read from SL811H
// adr = register address
// return = data in register
//*****************************************************************************************
BYTE SL811Read(BYTE adr)
{  
	/***BYTE i=0;
	USBADDR = adr;
	i= USBDATA;
	return (i);***/
	outportb(adr, SL811H_ADDR);
	return (inportb(SL811H_DATA));
}

//*****************************************************************************************
// Byte Write to SL811H
// adr = register address
// dat = data to be written to this register address
//*****************************************************************************************
void SL811Write(BYTE adr, BYTE dat)
{  
	//USBADDR = adr;
	//USBDATA = dat;	
	outportb(adr, SL811H_ADDR);
	outportb(dat, SL811H_DATA);
}

//*****************************************************************************************
// Buffer Read from SL811H
// addr = buffer start address
// s    = return buffer address where data are to be save/read
// c	= buffer data length
//*****************************************************************************************
void SL811BufRead(BYTE addr, BYTE *s, BYTE c)
{	
	if(c<=0) return;
	Uart_Printf("BR(");
	USBADDR = addr;		
	//outportb(addr, SL811H_ADDR);	
   	while (c--) 
   	{   		
		*s = USBDATA;	
		//*s = (BYTE)inportb(SL811H_DATA);		
		Uart_Printf("%x,", *s);
		s++;
	}
		Uart_Printf(")\n");
}

//*****************************************************************************************
// Buffer Write  to SL811H
// addr = buffer start address
// s    = buffer address where data are to be written
// c	= buffer data length
//*****************************************************************************************
void SL811BufWrite(BYTE addr, BYTE *s, BYTE c)
{
	if(c<=0)
		return;
	Uart_Printf("BW[");		
	USBADDR = addr;
	//outportb(addr, SL811H_ADDR);
   	while (c--) 
   	{
   		Uart_Printf("%x,", *s);
   		USBDATA = *s++;	
		//outportb(*s, SL811H_DATA);		
	}
		Uart_Printf("]\n");
}
//*****************************************************************************************
// Swap high and low byte 
//*****************************************************************************************
WORD WordSwap(WORD input)
{
	return(((input&0x00FF)<<8)|((input&0xFF00)>>8));
}

//*****************************************************************************************
// UsbReset during enumeration of device attached directly to SL811HS
//*****************************************************************************************
void USBReset(void)
{
  BYTE tmp;
    tmp =  SL811Read(CtrlReg);   
 	SL811Write(CtrlReg,tmp|0x08);
	Delay(25);			
    SL811Write(CtrlReg,tmp);
}

//*****************************************************************************************
// SL811H variables initialization
//*****************************************************************************************
void sl811h_init(void)
{	
	int i;
	
	USBADDR = 0;
	USBDATA = 0;
	//outportb(0, SL811H_ADDR);
	//outportb(0, SL811H_ADDR);
	
	SL811Write(cSOFcnt,0xae);
	pNumPort = 0x00;	
	
	FULL_SPEED = FALSE;	
	SLAVE_FOUND = FALSE;
	SLAVE_ENUMERATED = FALSE;
	BULK_OUT_DONE = FALSE;
	DATA_INPROCESS = FALSE;
    dsPoll = 1;				    // poll downstream port conections
	SL811MemTest();	
	
	SL811Write(cSOFcnt,0xae);
	SL811Write(CtrlReg,0x08);      		// Reset USB engine, full-speed setup, suspend disable
	Delay(100);					// Delay for HW stablize
	SL811Write(CtrlReg,0x00);      		// Set to normal operation
	SL811Write(IntEna,0x61);      		// USB-A, Insert/Remove, USB_Resume.
	SL811Write(IntStatus,INT_CLEAR);	// Clear Interrupt enable status
	Delay(100);					// Delay for HW stablize
	
}

int usbXfer(BYTE usbaddr, BYTE endpoint, BYTE pid, BYTE iso, WORD wPayload, WORD wLen, BYTE *buffer)
{  
	U8 	cmd, result, timeout, intr=0x0,intr1=0xff;
	U8	xferLen, bufLen, data0, data1, dataX, addr;

	//------------------------------------------------
	// Default setting for usb trasnfer
	//------------------------------------------------
	bufLen = dataX = timeout = 0;					//reset all
	data0 = EP0_Buf;								// DATA0 buffer address
	data1 = data0 + (BYTE)wPayload;					// DATA1 buffer address
	DATA_STOP =	TIMEOUT_ERR = FALSE;				// set default conditions

	//------------------------------------------------
	// Define data transfer payload
	//------------------------------------------------
	if (wLen >= wPayload)  							// select proper data payload
		xferLen = wPayload;							// limit to wPayload size 
	else											// else take < payload len
		xferLen = wLen;								//	

	//------------------------------------------------
	// For IN token
	//------------------------------------------------
	if (pid==PID_IN)								// for current IN tokens
	{												//
		if(FULL_SPEED)								//
			cmd = sDATA0_RD;						// FS/FS on Hub, sync to sof
		else										// LS, no sync to sof for IN
			cmd = DATA0_RD;							//
	}
	//------------------------------------------------
	// For OUT token
	//------------------------------------------------
	else if(pid==PID_OUT)							// for OUT tokens
	{  	
		if(xferLen)									// only when there are	
			SL811BufWrite(data0,buffer,xferLen); 	// data to transfer on USB

		if(FULL_SPEED)								
			cmd = sDATA0_WR;						// FS/FS on Hub, sync to sof
		else										// LS, no sync to sof for OUT
			cmd = DATA0_WR;							

		// implement data toggle
		bData1 = uDev[usbaddr].bData1[endpoint];
        uDev[usbaddr].bData1[endpoint] = (uDev[usbaddr].bData1[endpoint] ? 0 : 1); // DataToggle
		if(bData1)
          cmd |= 0x40;                              // Set Data1 bit in command
	}
	//------------------------------------------------
	// For SETUP/OUT token
	//------------------------------------------------
	else											// for current SETUP/OUT tokens
	{  	
		if(xferLen)									// only when there are	
			SL811BufWrite(data0,buffer,xferLen); 	// data to transfer on USB

		if(FULL_SPEED)								
			cmd = sDATA0_WR;						// FS/FS on Hub, sync to sof
		else										// LS, no sync to sof for OUT
			cmd = DATA0_WR;							
	}

	//------------------------------------------------
	// Isochronous data transfer setting
	//------------------------------------------------
	if (iso) 
		cmd |= ISO_BIT;                     		// if iso setup ISO mode

	//------------------------------------------------
	// For EP0's IN/OUT token data, start with DATA1
	// Control Endpoint0's status stage.
	// For data endpoint, IN/OUT data, start ????
	//------------------------------------------------
	if (endpoint == 0 && pid != PID_SETUP) 			// for Ep0's IN/OUT token
		cmd |= 0x40; 								// always set DATA1

	//------------------------------------------------
	// Arming of USB data transfer for the first pkt
	//------------------------------------------------
	SL811Write(EP0Status,((endpoint&0x0F)|pid));	// PID + EP address
	SL811Write(EP0Counter,usbaddr);			// USB address
	SL811Write(EP0Address,data0);			// buffer address, start with "data0"
	SL811Write(EP0XferLen,xferLen);			// data transfer length
	SL811Write(IntStatus,INT_CLEAR); 		// clear interrupt status
	SL811Write(EP0Control,cmd);						// Enable ARM and USB transfer start here
	//	printf("[%x,%x,%x,%x,%x]\n", ((endpoint&0x0F)|pid), usbaddr, data0, xferLen, cmd);
		
	//------------------------------------------------
	// Main loop for completing a wLen data trasnfer
	//------------------------------------------------
	
	while(TRUE)
	{   
		//---------------Wait for done interrupt------------------
		while(TRUE)												// always ensure requested device is
		{														// inserted at all time, then you will
			intr = SL811Read(IntStatus);						// wait for interrupt to be done, and 
			//Uart_Printf("IntStatus Status %x\n", intr);
			// proceed to parse result from slave 
			if((intr & USB_RESET) || (intr & INSERT_REMOVE))
			{													// device.					
				DATA_STOP = TRUE;								// if device is removed, set DATA_STOP
				return FALSE;									// flag true, so that main loop will