/*************************************************************************/
/*                                                                       */
/* FILE NAME                                      VERSION                */
/*                                                                       */
/*      iic.c                      		 KS32C50100   : version 1.0 */
/*                                                                       */
/* COMPONENT                                                             */
/*                                                                       */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/* FUNCTIONS                                                             */
/*                                                                       */
/*                                                                       */
/* DEPENDENCIES                                                          */
/*                                                                       */
/*                                                                       */
/* HISTORY                                                               */
/*                                                                       */
/*************************************************************************/
#include <stdarg.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include "std.h"
#include "apdialog.h"
#include "snds.h"
#include "uart.h"
#include "isr.h"
#include "pollio.h"
#include "iic.h"
#include "memory.h"
#include "sysconf.h"

#define   MAX_LINE_BUF     250

/******************************************************************
 *                                                                *
 *           IIC Test using IIC 64Kbit Serial EEPROM              *
 *                                                                *
 ******************************************************************/
void IICTest(void) 
{
	char TestItemSel ;

	IicSetup() ;// Initialize IIC control block
	Enable_Int(nGLOBAL_INT); //enable global interrupt mask

	do {
	     Print("\n\n") ;
	     Print("        IIC Test Items \n") ;
	     Print("+-----------------------------------+\r") ;
	     Print("1. IIC Page Write Test(INT)      - [W]\r") ;
	     Print("2. IIC Sequential Read Test(INT) - [R]\r") ;
	     Print("3. IIC Read/Write Test(INT.)     - [L]\r") ;
	     Print("4. IIC Loopback test(INT)        - [B]\r") ;
	     Print("5. IIC configuration view        - [C]\r") ;
	     Print("6. Quit IIC Test                 - [Q]\r") ;
	     Print("+-----------------------------------+\r") ;


	     Print("\rSelect Test Item : ") ;
	     TestItemSel = get_byte() ;

	     switch(TestItemSel)
	     {
		case 'W' : case 'w' : IICWriteTest() ; break ;
		case 'R' : case 'r' : IICReadTest() ; break ;
		case 'L' : case 'l' : IICAutoTest() ; break ;
		case 'B' : case 'b' : IICLoopBackTest() ; break ;
		case 'C' : case 'c' : config_iic() ; break ;
		case 'Q' : case 'q' : break ;
		default : return ;
	     }
	     Print("\n Press Any Key to Continue IIC Test") ; 
	     get_byte() ;

	} while  ( (TestItemSel != 'Q') && (TestItemSel != 'q') ) ;
}



/******************************************************************
 *                                                                *
 *              IIC EEPROM READ & WRITE TEST MODULE               *
 *                                                                *
 ******************************************************************/

/* IIC Write Test Program */
void IICWriteTest(void)
{
	U8 TestData[StorageSize] ;
	U32 i, GetDataSize=0 ;
	U32 ByteAddr;

        Print("\rEnter Byte write address of IIC EEPROM.");
        Print("\r=>[0x%x]: ",(int)StorageSize);
        ByteAddr = gethex2dec(4); get_byte();

	Print("\rInput Write Character.");
	Print("\r=>(upto %dbytes): ",(int)StorageSize) ;
	while ((TestData[GetDataSize] = get_byte()) != CR ) GetDataSize++ ;

	Print("%d bytes received : ",GetDataSize);
	for (i=0;i<GetDataSize;i++) put_byte(TestData[i]) ;

	IICWriteInt((U8)IIC_DEV_0,(U32)ByteAddr,TestData,GetDataSize);
	Print("\rIIC Serial EEPROM write done.\r");
}


/* IIC Read Test Program */
void IICReadTest(void)
{
	U8 *DataBuff;
	U32 ReadDataSize ;
	int i,p;
	U32 ByteAddr;

        Print("\rEnter Byte write address of IIC EEPROM.");
        Print("\r=>[0x%x]: ",(int)StorageSize);
        ByteAddr = gethex2dec(4); get_byte();

	Print("\r >>> Input Read Data Size : ") ;
	ReadDataSize = get_digit() ;

	Print("\r\r  <<< READ DATA FROM IIC SERIAL EEPROM >>>\r\r") ;
        DataBuff=(U8 *)IICReadInt((U8)IIC_DEV_0,(U32)ByteAddr,ReadDataSize);

	for (i=0,p=0;i<ReadDataSize;i++) 
	{
	        if(!(i%SizeOfPage)) Print("\r[%d]0x%x: ",p++,ByteAddr);
	        put_byte(*DataBuff++); 
	        ByteAddr++;
    } 
}



/* IIC Read/Write Test Program by interrupt method */
void IICAutoTest(void)
{

	U8 *DataBuff;
	U8 TestData[] = "IIC Read/Write Test Pattern. ";
	U8 TempData ;
	U32 i, TestSize, TestLoop ;

	TestLoop = TestSize = sizeof(TestData) ;
	l2Print("IIC Test","=>IICAutoTest");

	while(TestLoop--) {

	     Print("\r $$ ") ;

	     /* Write IIC test pattern to Serial EEPROM */
	     IICWriteInt((U8)IIC_DEV_0,(U32)IICTestAddr,TestData,TestSize);
	     for (i=0;i<(int)Write_Cycle_ms(5);i++); /* 5ms write cycle */
        
	     /* Read IIC test pattern to Serial EEPROM */
             DataBuff=(U8 *)IICReadInt((U8)IIC_DEV_0,(U32)IICTestAddr,TestSize);
	     for (i=0;i<(int)Write_Cycle_ms(5);i++); /* 5ms write cycle */
	     for (i=0;i<TestSize;i++) put_byte(*DataBuff++) ;

	     /* Next Test Pattern Generation */
	     TempData = TestData[TestSize] ;
	     TestData[TestSize] = TestData[0] ;
	     for (i=0;i<TestSize;i++) TestData[i] = TestData[i+1] ;

	} // End of while loop
}


/* IIC Loopback Test  */
int IICLoopBackTest(void)
{
	U8 *DataBuff;
	U8 *TestData, *TempData;
	int i;
	int TestFlag = 1;


	//Print("\r\r$IIC R&W Test with IIC EEPROM(%dKByte).\r",IICTestSize/1024);
	Print("\r\r$IIC R&W Test with IIC EEPROM(%dKByte).\r",IICTestSize);

        /* Memory allocation for IIC test pattern */
        if((TestData = (U8 *)malloc((unsigned)IICTestSize)) == (U8 *)(NULL))
             Print("\rMemory allocation error occurred!!!\r");

        /* To generate IIC test pattern */
	//Print("\r=> Generating R,W pattern data(%dBytes).",IICTestSize);
        TempData = TestData; /* copy test pattern data memory */
        for(i=0; i < IICTestSize; i++) *TempData++ = (U8)PatternGen(i);

	/* Write IIC test pattern to Serial EEPROM */
	Print("\r=> Writing data.....");
	IICWriteInt((U8)IIC_DEV_0,(U32)IICTestAddr,TestData,IICTestSize);
	for (i=0;i<(int)Write_Cycle_ms(5);i++); /* 5ms write cycle */

	/* Read IIC test pattern from Serial EEPROM */
	Print("\r=> Reading data....");
        DataBuff=(U8 *)IICReadInt((U8)IIC_DEV_0,(U32)IICTestAddr,IICTestSize);
	for (i=0;i<(int)Write_Cycle_ms(5);i++); /* 5ms write cycle */

	/* Compare the read/write test pattern */ 

        TempData = TestData; /* copy test pattern data memory */
	Print("\r=> Comparing data....");
	for (i=0;i<IICTestSize-1;i++) 
	{
             if (*TempData++ != *DataBuff++) {
		 Print("\r[ERROR] 0x%x : W=%d:R=%d\r",i,*TempData-1,*DataBuff-1); 
		 TestFlag = 0; /* Indicate error occurred */
             }
             PrtIICStatus(i);
             
	} // End of while loop
        Print("Ok\r");
        free(TestData);     /* Return allocated memory to user memory */
	return(TestFlag);
}


void PrtIICStatus(int byte)
{
     char buff[MAX_LINE_BUF];
     int  i;
    
     //sprintf(buff,"=> R&W pattern compare : %dbyte",byte); 
     //put_string(buff); /* to console */
     //for(i=0;i < sizeof(buff);i++)  put_byte('\b'); 
     IOPDATA = ~(1<<(byte%4));  /* to LED */
}



void config_iic(void)
{
       Print("\r<< IIC BUS Special Registers. >>\r\r");
       Print("IICCON   = 0x%x \r", IICCON);
       Print("IICBUF   = 0x%x \r", IICBUF);
       Print("IICPS    = 0x%x \r", IICPS);
       Print("IICCOUNT = 0x%x \r", IICCOUNT);
}