/*
   //*************************************************************************
   //
   //                  P H I L I P S   P R O P R I E T A R Y
   //
   //           COPYRIGHT (c)   1999 BY PHILIPS SINGAPORE.
   //                     --  ALL RIGHTS RESERVED  --
   //
   // File Name:	D13BUS.C
   // Created:		Oct 30, 2000
   // Modified:
   // Revision:		1.01
   //Bulk by DMA 
   //*************************************************************************
*/

#include <stdio.h>
#include <string.h>
#include <reg51.h>                /* special function register declarations   */
#include "BasicTyp.h"
#include "Hal4Sys.h"
#include "Hal4D13.h"
#include "mainloop.h"
#include "USB100.h"
#include "Chap_9.h"
#include "common.h"
#include "D13bus.h"


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

/*
   //*************************************************************************
   // Public Data
   //*************************************************************************
*/

extern CONTROL_XFER ControlData;
extern D13FLAGS bD13flags;
extern IO_REQUEST idata ioRequest;


/*
   //*************************************************************************
   // Subroutines
   //*************************************************************************
*/
/*
void D13Bus_Watchdog(void)
{
	
	// No support now, just stall it.
	
	D13Bus_StallEP0();
}


void D13Bus_ControlEntry(void)
{
	// No support now, just stall it.
	
	D13Bus_StallEP0();  //Unknown command 
}

void reserved(void)
{
	
	// Undefined commands, stall them
	
	D13Bus_StallEP0();  //Unknown command 
}
*/

//Jan10, WARNING 16: UNCALLED SEGMENT, IGNORED FOR OVERLAY PROCESS
void dma_start(PIO_REQUEST pio)
{
//feb22, enable DMA
//	DMA_RST = 1;
	program_cpld(pio->uSize, pio->bCommand);
}

void program_cpld(USHORT uSize, UCHAR bCommand)
{

	outportb(DMA_REG_BYTE0, --uSize);	// set CPLD counter
	outportb(DMA_REG_BYTE1, uSize>>8);


	if(bCommand & 0x1) 
	{
//dec13, program DMA direction and enable register of CPLD, d7 = dir, d6 = dma_en
		outportb(DMA_REG_DIR, 0xc0);			//outportb(port-addr, val)

	}
	else 
	{
//		DATA_BUS = 0x00;	//d7=0 for DMA write

		outportb(DMA_REG_DIR, 0x40);			//outportb(port-addr, val)
	}
}

void read_write_register(void)
{
	unsigned char i;


	if(ControlData.DeviceRequest.bmRequestType & (unsigned char)USB_ENDPOINT_DIRECTION_MASK) 
	{
/*
		if(bD13flags.bits.verbose)
			printf("Read Registers: Offset = 0x%x, Length = 0x%x, Index = 0x%x.\n",
				ControlData.DeviceRequest.wValue,
				ControlData.DeviceRequest.wLength,
				ControlData.DeviceRequest.wIndex);

		if(ControlData.DeviceRequest.wIndex == GET_FIRMWARE_VERSION &&
			ControlData.DeviceRequest.wValue == 0 &&
			ControlData.DeviceRequest.wLength == 1)
			{
				get_firmware_version();
			}
		else
		{
			Chap9_StallEP0();
//			printf("stall: get firmware version\n");
		}
*/
	}	// if read register
	else
	{
/*		if(bD13flags.bits.verbose) 
		{
			printf("Write Registers: Offset = 0x%x, Length = 0x%x, Index = 0x%x.\n",
			ControlData.DeviceRequest.wValue,
			ControlData.DeviceRequest.wLength,
			ControlData.DeviceRequest.wIndex);

			printf("Data: ");
			for(i = 0; i < ControlData.DeviceRequest.wLength; i ++)
				printf("0x%x, ", *((ControlData.dataBuffer)+i));
			printf("\n");
		}
*/
		if(ControlData.DeviceRequest.wIndex == SETUP_DMA_REQUEST &&
			ControlData.DeviceRequest.wValue == 0 &&
			ControlData.DeviceRequest.wLength == 6)
		{
//			RaiseIRQL();
			setup_dma_request();
//			LowerIRQL();
		}
		else
		{
			Chap9_StallEP0();
		}
	}	// if write register
}

void setup_dma_request()
{
	memcpy((unsigned char *)&ioRequest + ControlData.DeviceRequest.wValue,
		ControlData.dataBuffer,
		ControlData.DeviceRequest.wLength);

	ioRequest.uSize = SWAP(ioRequest.uSize);
	ioRequest.uAddressL = SWAP(ioRequest.uAddressL);

	if(ioRequest.uSize > DMA_BUFFER_SIZE) // Unaccepted request
	{
		Chap9_StallEP0();
//		printf("stall: ioRequest.uSize > DMA_BUFFER_SIZE.\n");
	}
	else 
	{
//feb22, for bulk by PIO&DMA 0-pkt to host here
		Chap9_SingleTransmitEP0(0,0);

//dec13

		if(bD13flags.bits.dma_state == DMA_IDLE) 
		{
//			RaiseIRQL();
			bD13flags.bits.setup_dma = 1;
//			LowerIRQL();
		}
		else 
		{
//dec11, release bus to d13, not work!!!, with SETUP BUT no OUT int
//			if(!(DMAINTRANSFER))
//			{
//				DMASTART = 0;
//			}

//			RaiseIRQL();
			bD13flags.bits.dma_state = DMA_PENDING;
//			LowerIRQL();
		}
	} // else if accepted request
}

/*
////dec11, don't check dma_state, always set setup_dma=1
////		if(bD13flags.bits.dma_state == DMA_IDLE) {
			RaiseIRQL();
			bD13flags.bits.setup_dma = 1;
			LowerIRQL();
	}
////		else {
//dec11, release bus to d13, not work!!!, with SETUP BUT no OUT int
//			if(!(DMAINTRANSFER))
//			{
//				DMASTART = 0;
//			}

////			RaiseIRQL();
////			bD13flags.bits.dma_state = DMA_PENDING;
////			LowerIRQL();
////		}
////	} // else if accepted request
}
*/
/*
void get_firmware_version()
{
	unsigned char i;

	i = 0x01; // firmware version number, return 0x01 for PC kit version 1
	D13Bus_SingleTransmitEP0(&i, 1);
}
*/

// end of added functions that are to reuse D12 vendor specified command.

/*
   //*************************************************************************
   // D13Bus support functions
   //*************************************************************************
*/
/*
void D13Bus_StallEP0(void)
{
	Chap9_StallEP0();

}

void D13Bus_SingleTransmitEP0(UCHAR * buf, UCHAR len)
{
	Hal4D13_SingleTransmitEP0(buf, len);

    RaiseIRQL();
	if(!ControlData.Abort)
    {
		ControlData.wLength = ControlData.wCount = len;
        bD13flags.bits.DCP_state = USBFSM4DCP_HANDSHAKE;
//		printf("bD13flags.bits.DCP_state = x%hx\n", bD13flags.bits.DCP_state);
    }
	LowerIRQL();

}

void D13Bus_BurstTransmitEP0(UCHAR * pData, USHORT len)
{
	ControlData.wCount = 0;
	if(ControlData.wLength > len)
		ControlData.wLength = len;

	ControlData.Addr.pData = pData;
	if( ControlData.wLength >= EP0_PACKET_SIZE)
	{
		Hal4D13_WriteEndpoint(EPINDEX4EP0_CONTROL_IN, ControlData.Addr.pData, EP0_PACKET_SIZE);
		
		// Minimize the MISSING Window for SETUP Packet
		// Here give a chance to ISR whose interrupt is caused by Setup Packet
		
		RaiseIRQL();
		if(!ControlData.Abort)
		{
			ControlData.wCount += EP0_PACKET_SIZE;
			bD13flags.bits.DCP_state = USBFSM4DCP_DATAIN;
//		printf("bD13flags.bits.DCP_state = x%hx\n", bD13flags.bits.DCP_state);
		}

		LowerIRQL();

	}
	else
	{
		Hal4D13_WriteEndpoint(EPINDEX4EP0_CONTROL_IN, pData, ControlData.wLength);
		
		// Minimize the MISSING Window for SETUP Packet
		// Here give a chance to ISR whose interrupt is caused by Setup Packet
		
		RaiseIRQL();
		if(!ControlData.Abort)
		{
			ControlData.wCount += ControlData.wLength;
			bD13flags.bits.DCP_state = USBFSM4DCP_DATAIN;
//		printf("bD13flags.bits.DCP_state = x%hx\n", bD13flags.bits.DCP_state);
		}
		LowerIRQL();
	}
}
*/
//March1
void dma_start4iso(PIO_REQUEST pio)
{
	program_cpld4iso(pio->uSize, pio->bCommand);
}

void program_cpld4iso(USHORT uSize, UCHAR bCommand)
{
//March1
	outportb(DMA_REG_BYTE0, --uSize);	// set CPLD counter
	outportb(DMA_REG_BYTE1, uSize>>8);


	if(bCommand & 0x1) 
	{
		outportb(DMA_REG_DIR, 0xc0);			//outportb(port-addr, val)

	}
	else 
	{
		outportb(DMA_REG_DIR, 0x40);			//outportb(port-addr, val)

	}

}