//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//

#include <windows.h>
#include <bsp.h>

#define	DBG_ON	1
#define	U8	UINT8
#define	U32	UINT32

#define pISR		(*(unsigned *)(0x30000000+0x18))		// Virtual Address 0x0 is mapped to 0x30000000, ISR Address is VA 0x18

void	IsrKeyboardHandler(void);
void	IsrKeyboard(unsigned int val);

int	putcToKBCTL(U8 c)
{
	volatile S3C2443_IOPORT_REG *s2443IOP = (S3C2443_IOPORT_REG *)OALPAtoVA(S3C2443_BASE_REG_PA_IOPORT, FALSE);	
	volatile S3C2443_HSSPI_REG *s2443SPI = (S3C2443_HSSPI_REG *)OALPAtoVA(S3C2443_BASE_REG_PA_SPI0, FALSE);		
	U32	i;

	s2443SPI->SLAVE_SELECTION_REG &= ~(1<<0);
  	//s2443IOP->GPLDAT &= ~(1 << 13);       //Set _SS signal to low (Slave Select)
  	

	while((s2443SPI->SPI_STATUS & (1<<21))==0);	// wait while busy

	s2443SPI->SPI_TX_DATA = c;	                // write left justified data

	while((s2443SPI->SPI_STATUS & (1<<21))==0);	// wait while busy
   	
   	//s2443IOP->GPLDAT |= (1 << 13);        //Set _SS signal to high (Slave Select)
   	s2443SPI->SLAVE_SELECTION_REG |= (1<<0);

	i = s2443SPI->SPI_RX_DATA;

	return(i);
}

void getsFromKBCTL(U8 *m, int cnt)
{
	int	i, j;
	volatile tmp = 1;

	for(j = 0; j < 3; j++)
		tmp += tmp;
	for(j = 0; j < 250 * 30; j++)
		tmp += tmp;

	for(i = 0; i < cnt; i++) 
	{
		m[i] = putcToKBCTL(0xFF);

		for(j = 0; j < 400; j++)
			tmp+= tmp;
	}
}

void putsToKBCTL(U8 *m,  int cnt)
{
	int	i, j, x;
	volatile tmp = 1;
	
	for(j = 0; j < 3; j++)
		x = j;
	for(j = 0; j < 3; j++)
		tmp += tmp;
	for(j = 0; j < 250 * 30; j++)
		tmp += tmp;

	for(i = 0; i < cnt; i++) {

		j = putcToKBCTL(m[i]);

		for(j = 0; j < 400; j++)
			tmp+= tmp;
		for(j = 0; j < 400; j++)
			x = j;
    }
}


void SPIKBD_Port_Init()
{
	volatile S3C2443_IOPORT_REG *s2443IOP = (S3C2443_IOPORT_REG *)OALPAtoVA(S3C2443_BASE_REG_PA_IOPORT, FALSE);	

	// Setup IO port for SPI interface & Keyboard
	
	// Setup KBDINT as output
    s2443IOP->GPFCON &= ~(0x3 << 4); 	// Clear GPF2
    s2443IOP->GPFCON |= (0x2 << 4);  	// Set GPF2 to EINT2 for Keyboard interrupt
    s2443IOP->GPFUDP &= ~(0x3 << 4);
    s2443IOP->GPFUDP |= (0x1 << 4);

    s2443IOP->EXTINT0 &= ~(0x7 << 8);    // Clear EINT2
    s2443IOP->EXTINT0 |= (0x2 << 8);     // fallig edge triggered for EINT2

	// setup SPI interface
	// GPE11 : SPIMISO (KBDSPIMISO)
	// GPE12 : SPIMOSI (KBDSPIMOSI)
	// GPE13 : SPICLK  (KBDSPICLK)
    s2443IOP->GPECON &= ~((0x3 << 26) | (0x3 << 24) | (0x3 << 22));   // Clear GPE11,12,13
    s2443IOP->GPECON |= ((0x2 << 26) | (0x2 << 24) | (0x2 << 22));    
    s2443IOP->GPEUDP &= ~((0x3 << 26) | (0x3 << 24) | (0x3 << 22));
    s2443IOP->GPEUDP |= ((0x1 << 26) | (0x1 << 24) | (0x1 << 22));       
     
	// setup _SS signal(nSS_KBD)
    s2443IOP->GPLCON &= ~(0x3 << 26);         // Clear GPL14
    s2443IOP->GPLCON |= (0x2 << 26);        // Set Port GPL14 to output for nSS signal
    s2443IOP->GPLUDP &= ~((0x3 << 26));
    s2443IOP->GPLUDP |= ((0x1 << 26));    
    
	// setup _PWR_OK signal (KEYBOARD)
    s2443IOP->GPFCON &= ~(0x3 << 6);         // Clear GPF3 
    s2443IOP->GPFCON |= (0x1 << 6);       // Set Port GPF3 to output for _PWR_OK signal
    s2443IOP->GPFUDP &= ~((0x3 << 6));
    s2443IOP->GPFUDP |= ((0x1 << 6));    

    s2443IOP->GPFDAT &= ~(1 << 3);        // set _PWR_OK to 0
}

void Kbd_PowerOn(void)
{
	volatile S3C2443_IOPORT_REG *s2443IOP = (S3C2443_IOPORT_REG *)OALPAtoVA(S3C2443_BASE_REG_PA_IOPORT, FALSE);	
	volatile S3C2443_HSSPI_REG *s2443SPI = (S3C2443_HSSPI_REG *)OALPAtoVA(S3C2443_BASE_REG_PA_SPI0, FALSE);	
	volatile S3C2443_CLKPWR_REG *s2443PWR = (S3C2443_CLKPWR_REG *)OALPAtoVA(S3C2443_BASE_REG_PA_CLOCK_POWER, FALSE);	
	
	U8 msg[5];
	int t;
	char dummy = (char)0xff;	

	SPIKBD_Port_Init();

	// Setup SPI registers
    // Interrupt mode, prescaler enable, master mode, active high clock, format B, normal mode
    s2443PWR->PCLKCON |= (1<<6);
    s2443IOP->MISCCR |= (1<<31);
    s2443SPI->CH_CFG &= ~(1<<5);
    s2443SPI->CH_CFG |= (1<<5);
    s2443SPI->CH_CFG &= ~(1<<5);
    
    s2443SPI->CH_CFG = (0<<4)|(0x0<<3)|(1<<2)|(1<<1)|(1<<0);
    
    s2443SPI->CLK_CFG = (00<<9)|(1<<8)|(255<<0);
    //s2443SPI->SPPIN |= (1<<0);//Feedback Clock Disable, Master Out Keep
    
	// Developer MUST change the value of prescaler properly whenever value of PCLK is changed.
    //s2443SPI->SPPRE = 255;// 99.121K = 203M/4/2/(255+1) PCLK=50.75Mhz FCLK=203Mhz SPICLK=99.121Khz
         
    for(t=0;t<20000; t++); // delay
	    msg[0] = (char)0x1b; msg[1] = (char)0xa0; msg[2] = (char)0x7b; msg[3] = (char)0; // Initialize USAR
    	for(t=0; t < 10; t++) {
    	dummy = putcToKBCTL(0xff);
    }
    
    for(t=0; t<10; t++) { // wait for a while
        putsToKBCTL(msg,3);
        for(t=0;t<20000; t++);
    }
    t = 100;

#if 1
   	s2443IOP->GPFCON &= ~(3<<4);
    while(t--) {
        if((s2443IOP->GPFDAT & (1<<2))==0) { // Read _ATN (KBDINT) GPF2
            break;
        }
    }	//check _ATN
   	s2443IOP->GPFCON |= (2<<4);
#endif
   	
    if(t != 0) {
        getsFromKBCTL(msg,3);
    }    
    t=100000;
    while(t--); // delay
	msg[0] = (char)0x1b; msg[1] = (char)0xa1; msg[2] = (char)0x7a; msg[3] = (char)0; //Initialization complete
	putsToKBCTL(msg,3);

	RETAILMSG(DBG_ON,(TEXT("KeybdPowerOn\n")));
}

void IsrKeyboard(unsigned int val)
{
    U8           ui8ScanCode;	
	volatile S3C2443_INTR_REG *s2443INTR = (S3C2443_INTR_REG *)OALPAtoVA(S3C2443_BASE_REG_PA_INTR, FALSE);	
	RETAILMSG(DBG_ON,(TEXT("IsrKeyboard\n")));
	if(s2443INTR->INTPND & (1<<2))
	{
		s2443INTR->INTMSK |= (1<<2); // clear EINT2
		RETAILMSG(DBG_ON,(TEXT("Keyboard Interrupt occured!\n")));	
		
		s2443INTR->SRCPND = (1<<2);	// clear EINT2
		s2443INTR->INTPND = (1<<2);	// clear EINT2	


		getsFromKBCTL(&ui8ScanCode, 1);

		RETAILMSG(1,(TEXT("keybd interrupt asserted -> scancode = 0x%x\n"), ui8ScanCode));
			
	
		s2443INTR->INTMSK &= ~(1<<2); // clear EINT2		
	}			
}

void	Isr_SpiInit()
{
	RETAILMSG(DBG_ON,(TEXT("Isr_SpiInit\n")));	
	pISR =(unsigned)(0xEA000000)+(((unsigned)IsrKeyboardHandler - (0x80000000 + 0x18 + 0x8) )>>2);		
}

void	SpiKeyboardTest()
{
	volatile S3C2443_IOPORT_REG *s2443IOP = (S3C2443_IOPORT_REG *)OALPAtoVA(S3C2443_BASE_REG_PA_IOPORT, FALSE);		
	volatile S3C2443_SPI_REG *s2443SPI = (S3C2443_SPI_REG *)OALPAtoVA(S3C2443_BASE_REG_PA_SPI0, FALSE);		
	volatile S3C2443_INTR_REG *s2443INTR = (S3C2443_INTR_REG *)OALPAtoVA(S3C2443_BASE_REG_PA_INTR, FALSE);	
	volatile S3C2443_CLKPWR_REG *s2443PWR = (S3C2443_CLKPWR_REG *)OALPAtoVA(S3C2443_BASE_REG_PA_CLOCK_POWER, FALSE);
	int i=0;
	RETAILMSG(DBG_ON,(TEXT("SpiKeyboardTest\n")));

	pISR =(unsigned)(0xEA000000)+(((unsigned)IsrKeyboardHandler - (0x80000000 + 0x18 + 0x8) )>>2);	
	Kbd_PowerOn();
	RETAILMSG(1,(TEXT("PCLKCON = 0x%X\n"),s2443PWR->PCLKCON));
	
	
	if(s2443INTR->SRCPND & (1<<2))
		s2443INTR->SRCPND = (1<<2);	// clear EINT2
	if(s2443INTR->INTPND & (1<<2))
		s2443INTR->INTPND = (1<<2);	// clear EINT2
	s2443INTR->INTMSK &= ~(1<<2); // clear EINT2
	
	
	/*
	while(1)
	{
		if(s2443INTR->INTPND & (1<<0))
		{
			s2443INTR->SRCPND = (1<<0);	// clear EINT2
			s2443INTR->INTPND = (1<<0);	// clear EINT2
			RETAILMSG(DBG_ON,(TEXT("Keyboard Interrupt occured!\n")));			
		}
	}*/
	//getsFromKBCTL(&ui8ScanCode, 1);	
	
	
}