////////////////////////////////////////////////////////////////////////////////
// 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 "host_811.h"

////////////////////////////////////////////////////////////////////////////////
// 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 BYTE SL811H_ADDR		_at_	0x4000;		// A0 = '0' to external memory
xdata BYTE SL811H_DATA  	_at_	0x4001;     // A0 = '1' (EZ-USB Dev Kit - SW4 ON)

xdata BYTE 			DBUF[256];		// at 0x2000 for general descriptors data
xdata BYTE 			STATUS[8];		// for status data buffer
xdata BYTE        	        REGBUFF[16];    // Buffer for Register Data
xdata BYTE 			HOSTCMD[8];		// EZUSB's OUT1 host command data
xdata BYTE 			pHOSTCMD[8];	// previous data transfer info, during data transfer
xdata BYTE 			HubChange[1];	// Hub port endpoint 1 data status
xdata BYTE 			DataBufLen;		// EZUSB's IN #3 data transfer buffer length
xdata BYTE 			pNumPort;		// Number of downstream ports on hub
xdata BYTE			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
//*****************************************************************************************
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	HUB_DEVICE;					// HUB device = TRUE
BOOL 	BULK_OUT_DONE;				// Set when EZUSB's OUT1 hostcmd xfer is done
BOOL 	DESC_XFER;					// Set when there is data for EZUSB's IN1 desc xfer
BOOL 	DATA_XFER;					// Set when there is data for EZUSB's IN3 data xfer
BOOL 	DATA_XFER_OUT;				// Set when there is data for EZUSB's OUT3 data xfer
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
// a = register address
// return = data in register
//*****************************************************************************************
BYTE SL811Read(BYTE a)
{  
	SL811H_ADDR = a;			
	return (SL811H_DATA);
}

//*****************************************************************************************
// Byte Write to SL811H
// a = register address
// d = data to be written to this register address
//*****************************************************************************************
void SL811Write(BYTE a, BYTE d)
{  
	SL811H_ADDR = a;	
	SL811H_DATA = d;
}

//*****************************************************************************************
// 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)
{	
	SL811H_ADDR = addr;	
   	while (c--) 
		*s++ = SL811H_DATA;
}

//*****************************************************************************************
// 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)
{	
	SL811H_ADDR = addr;	
   	while (c--) 
		SL811H_DATA = *s++;
}

//*****************************************************************************************
// 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()
{
	BYTE tmp;
        tmp =  SL811Read(CtrlReg);   
 	SL811Write(CtrlReg,tmp|0x08);
	EZUSB_Delay(25);			
    	SL811Write(CtrlReg,tmp);    
}

//*****************************************************************************************
// usbXfer:
// successful transfer = return TRUE
// fail transfer = return FALSE
//*****************************************************************************************
int usbXfer(BYTE usbaddr, BYTE endpoint, BYTE pid, B
YTE iso, WORD wPayload, WORD wLen, BYTE *buffer)
{  
	xdata BYTE 	cmd, result, timeout, intr;
	xdata BYTE	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;							//
		//-------------------------------------------- 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;
		}
	}

	//------------------------------------------------
	// 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

	//------------------------------------------------
	// 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 
			if((intr & USB_RESET) || (intr & INSERT_REMOVE))	// proceed to parse result from slave 
			{													// device.
				DATA_STOP = TRUE;								// if device is removed, set DATA_STOP
				return FALSE;									// flag true, so that main loop will 
			}													// know this condition and exit gracefully
			if(intr & USB_A_DONE)								
				break;											// interrupt done !!!