host811hs.c

sl811hs的host源程序

////////////////////////////////////////////////////////////////////////////////
// Cypress Semiconductor - Customer Design Center 
////////////////////////////////////////////////////////////////////////////////
// File:		host_811.c
// Purpose:	    8051 firmware to master SL811 Embedded Host. 
//              Contains SL811-related control firmware. 
//              Based on SL811HST code written by cxn.
// H/W Target:  SL811HST(Rev 1.5) + EZUSB DEV KIT
// IMPORTANT :  Turn ON SW4 of S6-DIP-SWITCH 
//              to enable upper 32K memory on EZUSB Dev Kit
//
// $Header: /USB/ez811/firmware/Emb_Host/host_811.c 8     5/14/02 8:30p Tpm $
// Copyright (c) 2002 Cypress Semiconductor. May not be reproduced without permission.
// See the license agreement for more details.
////////////////////////////////////////////////////////////////////////////////

//#include "ezusb.h"
//#include "ezregs.h"
#include <reg51.h>
#include <absacc.h>
#include <sl811hs.h>
#define SL811HS XBYTE[0x23333L]
#include "host811hs.h"

void initial(void);
void serial(void);
unsigned char SL811MemTest(void);
void Send2pc(unsigned char xdata *,int);

////////////////////////////////////////////////////////////////////////////////
// Code and Xdata Memory Space
////////////////////////////////////////////////////////////////////////////////
//
// ** Upper 32K external memory **
// (PROGRAM'S CODE/XDATA MEMORY ALLOCATION)
// Program xdata Space	: 0x2000 ~ 0x23FF -> ALL XDATA (size:0x0400,1K)(ISO unused data mem)
// Program Code Space1	: 0x8000 ~ 0x9EFF -> ?FW, ?EZ811 (size:0x1F00,7K) (ext. code memory) 
// Program Code Space2	: 0xA000 ~ 0xDFFF -> ?SL811H (size:0x4000,16K)(ext. code memory) 
// (MONITOR'S CODE/XDATA MEMORY ALLOCATION) (SHOULD NEVER BE USED)
// Monitor xdata Space	: 0x9F00 ~ 0x9FFF (size:0x0100,256)(ext. code memory) 
// Monitor Code Space	: 0xE000 ~ 0xFFFF (size:0x2000,8K) (ext. code memory) 
//
// ** Lower 32K external memory **
// SL811H_ADDR address	: 0x4000
// SL811H_DATA address	: 0x4001
//
// ** Internal 8K EZUSB code/xdata memory **
// Both USBJmpTb.a51 and Dscr.a51 code are located to EZUSB internal 8K memory
//
// (See Project -> Options for Target 'Target 1' for detail settings)
//
//*****************************************************************************************
// 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
// 5) HubPortEnum()	: hub port device enum, incl. dynamic USB address
// 6) speed_detect(): SL811H slave device attach/speed detect
// 7) slave_detect(): Main loop control between SL811H & EZUSB & GUI
// 8) host_811.c	: Entire code size

//*****************************************************************************************
// SL811HST+EZUSB Hardware Resources :
//*****************************************************************************************
// SL811HST		<-->	AN2131QC	<-->	FUNCTIONS (looking from SL811H side)
// A0			<-->	A0			<-->	(I) Address entry for SL811H, '0'-addr, '1'-data
// D0 ~ D7		<-->	D0 ~ D7		<-->	(B) 8-bit Data Bus
// nCS			<-->	A15			<-->	(I) Enable lower 32K memory(where SL811H is mapped)
// nRD 			<-->	nRD (PC7)	<-->	(I) Read (active low)
// nWR			<-->	nWR (PC6)	<-->	(I) Write (active low)
// nRST			<-->	PB0			<-->	(I) SL811HST's reset (active low)
// MS_SEL		<-->	PB1			<-->	(I) SL811HST's master/slave select, '0'-host
// INTR			<-->	INT4 (PB4)	<-->	(O) SL811HST's interrupt (active high) not used
// ACTIVE_LED	<-->	PB6			<-->	Blink - waiting for enum, On - enumerated
//
// For Downstream Port LEDs on Hub (not present on Demo Board):
// DOWNSTREAM PORT1 LED			0x80	// PA bit 7
// DOWNSTREAM PORT2 LED			0x40	// PA bit 6
// DOWNSTREAM PORT3 LED			0x20	// PA bit 5
// DOWNSTREAM PORT4 LED			0x10	// PA bit 4
//
//*****************************************************************************************
// Monitor (Serial Port 1) Hardware Resources :
//*****************************************************************************************
// PB2 - (I) RxD1 (looking from EZUSB side)
// PB2 - (0) TxD1
// PC6 - (O) nWR
// PC7 - (O) nRD

//*****************************************************************************************
// xdata variables
//*****************************************************************************************
//xdata unsigned char SL811H_ADDR		_at_	0x4000;		// A0 = '0' to external memory
//xdata unsigned char SL811H_DATA  	_at_	0x4001;     // A0 = '1' (EZ-USB Dev Kit - SW4 ON)
sbit A0=P1^0;
sbit cpld=P1^1;

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

//*****************************************************************************************
// Boolean Logic Defines
//*****************************************************************************************
bit  	SLAVE_FOUND;				// Slave USB device found
bit  	SLAVE_ENUMERATED;			// slave USB device enumeration done
bit  	FULL_SPEED;					// Full-Speed = TRUE, Low-Speed = FALSE
bit	HUB_DEVICE;					// HUB device = TRUE
bit 	BULK_OUT_DONE;				// Set when EZUSB's OUT1 hostcmd xfer is done
bit 	DESC_XFER;					// Set when there is data for EZUSB's IN1 desc xfer
bit 	DATA_XFER;					// Set when there is data for EZUSB's IN3 data xfer
bit 	DATA_XFER_OUT;				// Set when there is data for EZUSB's OUT3 data xfer
bit 	CONFIG_DONE;				// Set when EZUSB completes its enumeration process.
bit 	TIMEOUT_ERR;				// timeout error during data endpoint transfer
bit	DATA_STOP;					// device unplugged during data transfer
bit	DATA_INPROCESS;				// set when we are in a data pipe transfer
bit	pLS_HUB;					// indicate previous command is a LS device on hub

bit	dsPoll;				        // poll downstream port conections

bit bData1;
unsigned char IN2BUF[10];
unsigned char IN2BC;
unsigned char IN2CS;
unsigned char bmEPBUSY;
//***************************************************************************************

void main(void)
{
	unsigned char err[10],pll;
	initial();
	sl811h_init();
	pll=0;
	err[pll++]=SL811MemTest();
	err[pll++]=SL811Read(EP0Control);
	err[pll++]=SL811Read(EP0Address);
	err[pll++]=SL811Read(EP0XferLen);
	err[pll++]=SL811Read(EP0Status);	
	err[pll++]=SL811Read(EP0Counter);
	err[pll++]=SL811Read(CtrlReg);
	err[pll++]=SL811Read(IntEna);
	err[pll++]=SL811Read(IntStatus);
	err[pll++]=SL811Read(DATASet);
	err[pll++]=SL811Read(CSOFcnt);

	while(1)
	{
		if (SL811Read(IntStatus) & 0x60) 
		break;
	}
	if (SL811Read(IntStatus) & 0x80)
		FULL_SPEED=1;
	else 
		FULL_SPEED=0;
EnumUsbDev(0);
}

void initial(void)
{
	TMOD=0x20;    /*定时器1方式2*/
	TH1=0xfd;
	TL1=0xfd;     /*BAUD=9600*/
	SCON=0x50;    /*串口工作在方式1*/
	PCON=0x00;    /*SMOD=0*/    
	ES=1;         /*允许串口中断*/
	EA=0;         /*CPU中断允许*/
	TR1=1;        /*启动计时器1*/
}

//*****************************************************************************************
// Byte Read from SL811H
// a = register address
// return = data in register
//*****************************************************************************************
unsigned char SL811Read(unsigned char Addr811R)
{  
	A0=0;                 /*数据线上传送地址*/
	SL811HS=Addr811R;
	A0=1;                 /*数据线上传送数据*/
	return(SL811HS);       
}

//*****************************************************************************************
// Byte Write to SL811H
// a = register address
// d = data to be written to this register address
//*****************************************************************************************
void SL811Write(unsigned char Addr811W,unsigned char WData)
{  
	A0=0;                 /*数据线上传送地址*/
	SL811HS=Addr811W;
	A0=1;                 /*数据线上传送数据*/
	SL811HS=WData;
}

//*****************************************************************************************
// Buffer Read from SL811H
// Addr811R = buffer start address
// s    = return buffer address where data are to be save/read
// c	= buffer data length
//*****************************************************************************************
void SL811BufRead(unsigned char Addr811R, unsigned char *s, unsigned char c)
{	
	A0=0;
	SL811HS=Addr811R;
	A0=1;
	while (c--) 
		*s++ = SL811HS;
}

//*****************************************************************************************
// Buffer Write  to SL811H
// Addr811W = buffer start address
// s    = buffer address where data are to be written
// c	= buffer data length
//*****************************************************************************************
void SL811BufWrite(unsigned char Addr811W, unsigned char *s, unsigned char c)
{	
	A0=0;
	SL811HS=Addr811W;
	A0=1;
	while (c--) 
		SL811HS = *s++;
}

//*****************************************************************************************
// Swap high and low byte 
//*****************************************************************************************
unsigned int WordSwap(unsigned int input)
{
	return(((input&0x00FF)<<8)|((input&0xFF00)>>8));
}

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

//*****************************************************************************************
// usbXfer:
// successful transfer = return TRUE
// fail transfer = return FALSE
//*****************************************************************************************
int usbXfer(unsigned char usbaddr, unsigned char endpoint, unsigned char pid, BYTE iso, unsigned int wPayload, unsigned int wLen, unsigned char *buffer)
{  
	xdata unsigned char 	cmd, result, timeout, intr;
	xdata unsigned char	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 + (unsigned char)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;							//DATA0_RD    0x03
		//-------------------------------------------- response to OUT can propagate to SL811HS
		// handling LS device on HUB
		//--------------------------------------------
		if(HUB_DEVICE && usbaddr!=HUB_ADDR)			// Transfer on Hub, USB addr #0, #2..#5 only
		{
			if(uHub.bPortSpeed[usbaddr])			// If transfer of LS on Hub & previous is			
				cmd = psDATA0_RD;					// SETUP & current is IN, no sync to sof,
		}
	}
	//------------------------------------------------
	// 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;							
		//--------------------------------------------
		// handling LS device on HUB
		//--------------------------------------------
		if(HUB_DEVICE && usbaddr!=HUB_ADDR)			// Transfer on Hub, USB addr #0, #2..#5 only
		{
			if(uHub.bPortSpeed[usbaddr])			// If transfer of LS on Hub, previous
				cmd = psDATA0_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;							
		//--------------------------------------------
		// handling LS device on HUB
		//--------------------------------------------
		if(HUB_DEVICE && usbaddr!=HUB_ADDR)			// Transfer on Hub, USB addr #0, #2..#5 only
		{
			if(uHub.bPortSpeed[usbaddr])			// If transfer of LS on Hub, previous
				cmd = psDATA0_WR;