mainloop.c

基于PDIUSBD12芯片的USB开发板固件程序

/*
   //*************************************************************************
   //
   //                  P H I L I P S   P R O P R I E T A R Y
   //
   //           COPYRIGHT (c)   1997 BY PHILIPS SINGAPORE.
   //                     --  ALL RIGHTS RESERVED  --
   //
   // File Name:	MainLoop.C
   // Author:		Wenkai Du
   // Created:		19 Dec 97
   // Modified:
   // Revision:		3.0
   //
   //*************************************************************************
   //
   // 98/11/25		Added I/O access support on Main endpoints. (WK)
   //*************************************************************************
   */



#include <reg51.h>                /* special function register declarations   */

#include "epphal.h"
#include "d12ci.h"
#include "mainloop.h"
#include "usb100.h"
#include "chap_9.h"
#include "ISP.h"
/*
//*************************************************************************
// USB protocol function pointer arrays
//*************************************************************************
*/
code void (*StandardDeviceRequest[])(void) =
{
	get_status,
	clear_feature,
	reserved,
	set_feature,
	reserved,
	set_address,
	get_descriptor,
	reserved,
	get_configuration,
	set_configuration,
	get_interface,
	set_interface,
	reserved,
	reserved,
	reserved,
	reserved
};

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

extern EPPFLAGS bEPPflags;
extern unsigned char idata GenEpBuf[];
extern unsigned char idata EpBuf[];
//extern IO_REQUEST idata ioRequest;


CONTROL_XFER ControlData;


void init_special_interrupts(void)
{
	EA=1;
	EX1=1;
}

void init_port()
{
	P0 = 0xFF;
	P1 = 0xFF;
	P2 = 0xFF;
	P3 = 0xFF;
	D12SUSPD = 0;
}

void init_flags()
{
//	bEPPflags.bits.bus_reset=0;           
//	bEPPflags.bits.suspend=0;             
	bEPPflags.bits.setup_packet=0;  	  
	bEPPflags.bits.remote_wakeup=0;		
	bEPPflags.bits.in_isr=0;		      
	bEPPflags.bits.control_state=0;		
	bEPPflags.bits.configuration=0;		
	bEPPflags.bits.ep1_rxdone=0;
	bEPPflags.bits.main_rxdone=0;	
}

void main(void)
{
	init_port();
	init_special_interrupts();
	init_flags();
	reconnect_USB();
	while( TRUE )
	{		
/*		if (bEPPflags.bits.bus_reset) 
		{
			DISABLE;
			bEPPflags.bits.bus_reset = 0;
			ENABLE;
			D12SUSPD = 1;
		} 
		if (bEPPflags.bits.suspend) 
		{
			DISABLE;
			bEPPflags.bits.suspend= 0;
			ENABLE;
			if(D12SUSPD == 1) 
			{
				D12SUSPD = 0;
				P0 = 0xFF;
				P1 = 0xFF;
				P2 = 0xFF;
				P3 = 0xFF;
				D12SUSPD = 1;
				PCON |= 0x02;
				while (1);
			}
		} // if suspend change*/

		if (bEPPflags.bits.setup_packet)
		{
			DISABLE;
			bEPPflags.bits.setup_packet = 0;
			ENABLE;
			control_handler();
			D12SUSPD = 1;
		} // if setup_packet
    	if(bEPPflags.bits.configuration)				
			IspControl();
	} // Main Loop

}

void stall_ep0(void)
{
	D12_SetEndpointStatus(0, 1);
	D12_SetEndpointStatus(1, 1);
}

void init_unconfig(void)
{
//	unsigned char i;

	D12_SetEndpointEnable(0);	/* Disable all endpoints but EPP0. */
}

void init_config(void)
{
	D12_SetEndpointEnable(1);	/* Enable  generic/iso endpoints. */
}

void single_transmit(unsigned char * buf, unsigned char len)
{
	if( len <= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, len, buf);
	}
}

void code_transmit(unsigned char code * pRomData, unsigned short len)
{
	ControlData.wCount = 0;
	if(ControlData.wLength > len)
		ControlData.wLength = len;

	ControlData.pData = pRomData;
	if( ControlData.wLength >= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, EP0_PACKET_SIZE, ControlData.pData);
		ControlData.wCount += EP0_PACKET_SIZE;

		DISABLE;
		bEPPflags.bits.control_state = USB_TRANSMIT;
		ENABLE;
	}
	else {
		D12_WriteEndpoint(1, ControlData.wLength, pRomData);
		ControlData.wCount += ControlData.wLength;
		DISABLE;
		bEPPflags.bits.control_state = USB_IDLE;
		ENABLE;
	}
}

void IspControl(void)
{
	unsigned char a;
	unsigned char time;
	int Addr;
	unsigned char i;
	unsigned char j;
	unsigned char nBit;
	while(!bEPPflags.bits.ep1_rxdone) 
		{}
	DISABLE;
	bEPPflags.bits.ep1_rxdone = 0;
	ENABLE;
	a=GenEpBuf[0];
	PreparePro();	
	switch(a)
	{
	case 0:
		Erase();
		GenEpBuf[0]=1;
		D12_WriteEndpoint(3,4, GenEpBuf);
		GenEpBuf[0]=0;
		break;
	case 1:		
		time=GenEpBuf[1];
		for(i=0;i<time;i++)
		{
			while(!bEPPflags.bits.main_rxdone)
				{}
			DISABLE;
			bEPPflags.bits.main_rxdone = 0;
			ENABLE;
			D12SUSPD=1;
			for(j=0;j<64;j++)
			{
				Addr=j+i*64;
				Write(EpBuf[j],Addr);
				if(Read(Addr)!=EpBuf[j])
				{
					GenEpBuf[0]=2;
					D12_WriteEndpoint(3,4, GenEpBuf);
					GenEpBuf[0]=0;
					return;
				}	
			}
			D12SUSPD=0;
			GenEpBuf[0]=1;
			D12_WriteEndpoint(3,4, GenEpBuf);
			GenEpBuf[0]=0;
		}
		break;
	case 2:
		time=GenEpBuf[1];
		for(i=0;i<time;i++)
		{
			for(j=0;j<64;j++)
			{
				Addr=j+i*64;
				EpBuf[j]=Read(Addr);
			}
			D12_WriteEndpoint(5,64,EpBuf);
			GenEpBuf[0]=1;
			D12_WriteEndpoint(3,4, GenEpBuf);
		}
		GenEpBuf[0]=0;
		break;
	case 3:
		ReadSign(GenEpBuf);
		if(GenEpBuf[0]==0)
			GenEpBuf[0]=2;
		D12_WriteEndpoint(3,4, GenEpBuf);
		GenEpBuf[0]=0;
		break;
	case 4:
		nBit=GenEpBuf[1];
		LockBit(nBit);
		GenEpBuf[0]=1;
		D12_WriteEndpoint(3,4, GenEpBuf);
		GenEpBuf[0]=0;
		break;
	}
	ProOver();
}

void control_handler()
{
	unsigned char type, req;

	type = ControlData.DeviceRequest.bmRequestType & USB_REQUEST_TYPE_MASK;
	req = ControlData.DeviceRequest.bRequest & USB_REQUEST_MASK;
	if (type == USB_STANDARD_REQUEST)
		(*StandardDeviceRequest[req])();
	else
		stall_ep0();
}

void reconnect_USB(void)
{
	D12SUSPD = 0;
	disconnect_USB();
	connect_USB();
}

void disconnect_USB(void)
{
	// Initialize D12 configuration
	D12_SetMode(D12_NOLAZYCLOCK, D12_SETTOONE | D12_CLOCK_12M);
}

void connect_USB(void)
{
	D12_SetDMA(D12_ENDP4INTENABLE | D12_ENDP5INTENABLE);
	D12_SetMode(D12_NOLAZYCLOCK|D12_SOFTCONNECT, D12_SETTOONE | D12_CLOCK_12M);
}