pin6400.c

s3c6400（ARM11）的JTAG烧写软件

/* - 16/05/2002 [Jaewook Cheong] : first writing for S3C6400 */

#include <stdio.h>
#include "..\include\def.h"
#include "..\include\pin6400.h"
#include "..\include\Jtag.h"

// Boundary Scan Cell In/Out Interface    
char outCellValue[S6400_MAX_CELL_INDEX+2]; //818+2 => 820(#BSC of 6400) + 1(End of String)
char inCellValue[S6400_MAX_CELL_INDEX+2]; //818+2 => 820(#BSC of 6400) + 1(End of String)

// Index Array for RData In/Out and RAddr BSC      
int  rdataOutCellIndex[16];
int  rdataInCellIndex[16];
//int  raddrCellIndex[26];
int  raddrCellIndex[16];

// Index Array for SData In/Out and SAddr BSC      
int  sdataOutCellIndex[32];
int  sdataInCellIndex[32];
int  saddrCellIndex[16];


void S6400_InitCell(void)
{
    int i;
	
	// ROM bus addr & data cell index
	rdataOutCellIndex[0] = Xm0DATA0_OUT;  //refer to S3C6400_070430.bsdl
    rdataOutCellIndex[1] = Xm0DATA1_OUT; 
    rdataOutCellIndex[2] = Xm0DATA2_OUT;
    rdataOutCellIndex[3] = Xm0DATA3_OUT;
    rdataOutCellIndex[4] = Xm0DATA4_OUT;
    rdataOutCellIndex[5] = Xm0DATA5_OUT;
    rdataOutCellIndex[6] = Xm0DATA6_OUT;
    rdataOutCellIndex[7] = Xm0DATA7_OUT;	
    rdataOutCellIndex[8] = Xm0DATA8_OUT;
    rdataOutCellIndex[9] = Xm0DATA9_OUT;
    rdataOutCellIndex[10] = Xm0DATA10_OUT;
    rdataOutCellIndex[11] = Xm0DATA11_OUT;
    rdataOutCellIndex[12] = Xm0DATA12_OUT;
    rdataOutCellIndex[13] = Xm0DATA13_OUT;
    rdataOutCellIndex[14] = Xm0DATA14_OUT;
    rdataOutCellIndex[15] = Xm0DATA15_OUT;	

    rdataInCellIndex[0] = Xm0DATA0_IN;	//refer to S3C6400_070430.bsdl 
    rdataInCellIndex[1] = Xm0DATA1_IN;
    rdataInCellIndex[2] = Xm0DATA2_IN;
    rdataInCellIndex[3] = Xm0DATA3_IN;
    rdataInCellIndex[4] = Xm0DATA4_IN;
    rdataInCellIndex[5] = Xm0DATA5_IN;
    rdataInCellIndex[6] = Xm0DATA6_IN;
    rdataInCellIndex[7] = Xm0DATA7_IN;
    rdataInCellIndex[8] = Xm0DATA8_IN;  
    rdataInCellIndex[9] = Xm0DATA9_IN;
    rdataInCellIndex[10] = Xm0DATA10_IN;
    rdataInCellIndex[11] = Xm0DATA11_IN;
    rdataInCellIndex[12] = Xm0DATA12_IN;
    rdataInCellIndex[13] = Xm0DATA13_IN;
    rdataInCellIndex[14] = Xm0DATA14_IN;
    rdataInCellIndex[15] = Xm0DATA15_IN;

    raddrCellIndex[0]=Xm0ADDR0_OUT;  //refer to S3C6400_070430.bsdl
    raddrCellIndex[1]=Xm0ADDR1_OUT;
    raddrCellIndex[2]=Xm0ADDR2_OUT;
    raddrCellIndex[3]=Xm0ADDR3_OUT;
    raddrCellIndex[4]=Xm0ADDR4_OUT;
    raddrCellIndex[5]=Xm0ADDR5_OUT;
    raddrCellIndex[6]=Xm0ADDR6_OUT;
    raddrCellIndex[7]=Xm0ADDR7_OUT;
    raddrCellIndex[8]=Xm0ADDR8_OUT;
    raddrCellIndex[9]=Xm0ADDR9_OUT;
    raddrCellIndex[10]=Xm0ADDR10_OUT;
    raddrCellIndex[11]=Xm0ADDR11_OUT;
    raddrCellIndex[12]=Xm0ADDR12_OUT;
    raddrCellIndex[13]=Xm0ADDR13_OUT;
    raddrCellIndex[14]=Xm0ADDR14_OUT;
    raddrCellIndex[15]=Xm0ADDR15_OUT;

/*
	// SDRAM bus addr & data cell index
    sdataOutCellIndex[0] = SDATA0_OUT;  //refer to S3C6400_070430.bsdl
    sdataOutCellIndex[1] = SDATA1_OUT; 
    sdataOutCellIndex[2] = SDATA2_OUT;
    sdataOutCellIndex[3] = SDATA3_OUT;
    sdataOutCellIndex[4] = SDATA4_OUT;
    sdataOutCellIndex[5] = SDATA5_OUT;
    sdataOutCellIndex[6] = SDATA6_OUT;
    sdataOutCellIndex[7] = SDATA7_OUT;	
    sdataOutCellIndex[8] = SDATA8_OUT;
    sdataOutCellIndex[9] = SDATA9_OUT;
    sdataOutCellIndex[10] = SDATA10_OUT;
    sdataOutCellIndex[11] = SDATA11_OUT;
    sdataOutCellIndex[12] = SDATA12_OUT;
    sdataOutCellIndex[13] = SDATA13_OUT;
    sdataOutCellIndex[14] = SDATA14_OUT;
    sdataOutCellIndex[15] = SDATA15_OUT;	
    sdataOutCellIndex[16] = SDATA16_OUT;
    sdataOutCellIndex[17] = SDATA17_OUT;
    sdataOutCellIndex[18] = SDATA18_OUT;
    sdataOutCellIndex[19] = SDATA19_OUT;
    sdataOutCellIndex[20] = SDATA20_OUT;
    sdataOutCellIndex[21] = SDATA21_OUT;
    sdataOutCellIndex[22] = SDATA22_OUT;
    sdataOutCellIndex[23] = SDATA23_OUT;	
    sdataOutCellIndex[24] = SDATA24_OUT;
    sdataOutCellIndex[25] = SDATA25_OUT;
    sdataOutCellIndex[26] = SDATA26_OUT;
    sdataOutCellIndex[27] = SDATA27_OUT;
    sdataOutCellIndex[28] = SDATA28_OUT;
    sdataOutCellIndex[29] = SDATA29_OUT;
    sdataOutCellIndex[30] = SDATA30_OUT;
    sdataOutCellIndex[31] = SDATA31_OUT;	

    sdataInCellIndex[0] = SDATA0_IN;	//refer to S3C6400_070430.bsdl 
    sdataInCellIndex[1] = SDATA1_IN;
    sdataInCellIndex[2] = SDATA2_IN;
    sdataInCellIndex[3] = SDATA3_IN;
    sdataInCellIndex[4] = SDATA4_IN;
    sdataInCellIndex[5] = SDATA5_IN;
    sdataInCellIndex[6] = SDATA6_IN;
    sdataInCellIndex[7] = SDATA7_IN;
    sdataInCellIndex[8] = SDATA8_IN;  
    sdataInCellIndex[9] = SDATA9_IN;
    sdataInCellIndex[10] = SDATA10_IN;
    sdataInCellIndex[11] = SDATA11_IN;
    sdataInCellIndex[12] = SDATA12_IN;
    sdataInCellIndex[13] = SDATA13_IN;
    sdataInCellIndex[14] = SDATA14_IN;
    sdataInCellIndex[15] = SDATA15_IN;
    sdataInCellIndex[16] = SDATA16_IN;  
    sdataInCellIndex[17] = SDATA17_IN;
    sdataInCellIndex[18] = SDATA18_IN;
    sdataInCellIndex[19] = SDATA19_IN;
    sdataInCellIndex[20] = SDATA20_IN;
    sdataInCellIndex[21] = SDATA21_IN;
    sdataInCellIndex[22] = SDATA22_IN;
    sdataInCellIndex[23] = SDATA23_IN;
    sdataInCellIndex[24] = SDATA24_IN;  
    sdataInCellIndex[25] = SDATA25_IN;
    sdataInCellIndex[26] = SDATA26_IN;
    sdataInCellIndex[27] = SDATA27_IN;
    sdataInCellIndex[28] = SDATA28_IN;
    sdataInCellIndex[29] = SDATA29_IN;
    sdataInCellIndex[30] = SDATA30_IN;
    sdataInCellIndex[31] = SDATA31_IN;
  
    saddrCellIndex[0]=SADDR0;  //refer to S3C6400_070430.bsdl
    saddrCellIndex[1]=SADDR1;
    saddrCellIndex[2]=SADDR2;
    saddrCellIndex[3]=SADDR3;
    saddrCellIndex[4]=SADDR4;
    saddrCellIndex[5]=SADDR5;
    saddrCellIndex[6]=SADDR6;
    saddrCellIndex[7]=SADDR7;
    saddrCellIndex[8]=SADDR8;
    saddrCellIndex[9]=SADDR9;
    saddrCellIndex[10]=SADDR10;
    saddrCellIndex[11]=SADDR11;
    saddrCellIndex[12]=SADDR12;
    saddrCellIndex[13]=SADDR13;
    saddrCellIndex[14]=SADDR14;
    saddrCellIndex[15]=SADDR15;
*/
    //outCellValue[] must be initialized by dummy values for JTAG_ShiftDRState();
    for(i=0;i<=S6400_MAX_CELL_INDEX;i++) //From i=0 to i=818
    {
		outCellValue[i]=HIGH; //'1'
		inCellValue[i]='u';
    }

    outCellValue[S6400_MAX_CELL_INDEX+1]='\0';
    inCellValue[S6400_MAX_CELL_INDEX+1]='\0';

    JTAG_RunTestldleState();
    
	JTAG_ShiftIRState(SAMPLE_PRELOAD);

	//for(i=0;i<=S6400_MAX_CELL_INDEX;i++)
	//	printf("\nBefor: inCellValue[%d]=%c", i, inCellValue[i]);

    JTAG_ShiftDRState(outCellValue,inCellValue); //inCellValue[] is initialized.

    //for(i=0;i<=S6400_MAX_CELL_INDEX;i++)
		//printf("\nAfter: inCellValue[%d]=%c", i, inCellValue[i]);

    for(i=0;i<=S6400_MAX_CELL_INDEX;i++)
    {
		outCellValue[i]=inCellValue[i];	//outCellValue[] is initialized.
    }

    //Memory control signal initialization.
	S6400_ContRDataBus(HIGH); // RData input
//	S6400_ContSDataBus(HIGH); // SData input
	S6400_ContRAddrBus(LOW); // RAddr output

    S6400_SetPin(Xm0CSn5_CON,LOW); 
    S6400_SetPin(Xm0CSn5_OUT,HIGH); 
    S6400_SetPin(Xm0CSn4_CON,LOW); 
    S6400_SetPin(Xm0CSn4_OUT,HIGH); 
    S6400_SetPin(Xm0CSn3_CON,LOW); 
    S6400_SetPin(Xm0CSn3_OUT,HIGH); 
    S6400_SetPin(Xm0CSn2_CON,LOW); 
    S6400_SetPin(Xm0CSn2_OUT,HIGH); 
    S6400_SetPin(Xm0CSn1_CON,LOW); 
    S6400_SetPin(Xm0CSn1_OUT,HIGH); 
    S6400_SetPin(Xm0CSn0_CON,LOW);
    S6400_SetPin(Xm0CSn0_OUT,HIGH); 
    
	S6400_SetPin(Xm0WEn,HIGH); 
    S6400_SetPin(Xm0OEn,HIGH); 
    
	S6400_SetPin(Xm0DQM0_nBE0,HIGH); 
    S6400_SetPin(Xm0DQM1_nBE1,HIGH); 

    S6400_SetPin(Xm0INTsm1_FREn_OUT,HIGH); 
    S6400_SetPin(Xm0INTsm0_FWEn_OUT,HIGH); 

//	S6400_SetPin(nSCS1_CON,LOW); 
//   S6400_SetPin(nSCS1,HIGH); 
//	S6400_SetPin(nSCS0_CON,LOW); 
//    S6400_SetPin(nSCS0,HIGH); 

}

void S6400_ContRAddrBus(U8 cmd) // Xm0ADDR[15:0] LOW=output
{
    S6400_SetPin(Xm0ADDR0_CON,cmd);
    S6400_SetPin(Xm0ADDR1_CON,cmd);
    S6400_SetPin(Xm0ADDR2_CON,cmd);
    S6400_SetPin(Xm0ADDR3_CON,cmd);
    S6400_SetPin(Xm0ADDR4_CON,cmd);
    S6400_SetPin(Xm0ADDR5_CON,cmd);
    S6400_SetPin(Xm0ADDR6_CON,cmd);
    S6400_SetPin(Xm0ADDR7_CON,cmd);
    S6400_SetPin(Xm0ADDR8_CON,cmd);
    S6400_SetPin(Xm0ADDR9_CON,cmd);
    S6400_SetPin(Xm0ADDR10_CON,cmd);
    S6400_SetPin(Xm0ADDR11_CON,cmd);
    S6400_SetPin(Xm0ADDR12_CON,cmd);
    S6400_SetPin(Xm0ADDR13_CON,cmd);
    S6400_SetPin(Xm0ADDR14_CON,cmd);
    S6400_SetPin(Xm0ADDR15_CON,cmd);
}


void S6400_ContRDataBus(U8 cmd) // Xm0DATA[15:0] HIGH=input, LOW=output
{
	S6400_SetPin(Xm0DATA0_CON ,cmd); 
    S6400_SetPin(Xm0DATA1_CON ,cmd); 
    S6400_SetPin(Xm0DATA2_CON ,cmd); 
    S6400_SetPin(Xm0DATA3_CON ,cmd); 
    S6400_SetPin(Xm0DATA4_CON ,cmd); 
    S6400_SetPin(Xm0DATA5_CON ,cmd); 
    S6400_SetPin(Xm0DATA6_CON ,cmd); 
    S6400_SetPin(Xm0DATA7_CON ,cmd); 
	S6400_SetPin(Xm0DATA8_CON ,cmd);
    S6400_SetPin(Xm0DATA9_CON ,cmd); 
    S6400_SetPin(Xm0DATA10_CON ,cmd); 
    S6400_SetPin(Xm0DATA11_CON ,cmd); 
    S6400_SetPin(Xm0DATA12_CON ,cmd); 
    S6400_SetPin(Xm0DATA13_CON ,cmd); 
    S6400_SetPin(Xm0DATA14_CON ,cmd); 
    S6400_SetPin(Xm0DATA15_CON ,cmd); 
}

/*
void S6400_ContSDataBus(U8 cmd) // SData[31:0] HIGH=input, LOW=output
{
    S6400_SetPin(SDATA0_CON ,cmd); 
    S6400_SetPin(SDATA1_CON ,cmd); 
    S6400_SetPin(SDATA2_CON ,cmd); 
    S6400_SetPin(SDATA3_CON ,cmd); 
    S6400_SetPin(SDATA4_CON ,cmd); 
    S6400_SetPin(SDATA5_CON ,cmd); 
    S6400_SetPin(SDATA6_CON ,cmd); 
    S6400_SetPin(SDATA7_CON ,cmd); 
    S6400_SetPin(SDATA8_CON ,cmd);
    S6400_SetPin(SDATA9_CON ,cmd); 
    S6400_SetPin(SDATA10_CON ,cmd); 
    S6400_SetPin(SDATA11_CON ,cmd); 
    S6400_SetPin(SDATA12_CON ,cmd); 
    S6400_SetPin(SDATA13_CON ,cmd); 
    S6400_SetPin(SDATA14_CON ,cmd); 
    S6400_SetPin(SDATA15_CON ,cmd); 
    S6400_SetPin(SDATA16_CON ,cmd); 
    S6400_SetPin(SDATA17_CON ,cmd); 
    S6400_SetPin(SDATA18_CON ,cmd); 
    S6400_SetPin(SDATA19_CON ,cmd); 
    S6400_SetPin(SDATA20_CON ,cmd); 
    S6400_SetPin(SDATA21_CON ,cmd); 
    S6400_SetPin(SDATA22_CON ,cmd); 
    S6400_SetPin(SDATA23_CON ,cmd); 
    S6400_SetPin(SDATA24_CON ,cmd); 
    S6400_SetPin(SDATA25_CON ,cmd); 
    S6400_SetPin(SDATA26_CON ,cmd); 
    S6400_SetPin(SDATA27_CON ,cmd); 
    S6400_SetPin(SDATA28_CON ,cmd); 
    S6400_SetPin(SDATA29_CON ,cmd); 
    S6400_SetPin(SDATA30_CON ,cmd); 
    S6400_SetPin(SDATA31_CON ,cmd); 
}
*/

void S6400_SetPin(int index, char value)
{
    outCellValue[index] = value;
}


char S6400_GetPin(int index)
{
    return inCellValue[index];
}


void S6400_SetRAddr(U32 raddr)
{
    int i;

    //for(i=0;i<=25;i++)
    for(i=0;i<=15;i++)
    {
    	if(raddr & (1<<i))
	    	outCellValue[raddrCellIndex[i]]=HIGH;
		else
	    	outCellValue[raddrCellIndex[i]]=LOW;
    }
}


void S6400_SetSAddr(U32 saddr)
{
    int i;

    for(i=0;i<=15;i++)
    {
    	if(saddr & (1<<i))
	    	outCellValue[saddrCellIndex[i]]=HIGH;
		else
	    	outCellValue[saddrCellIndex[i]]=LOW;
    }
}


void S6400_SetRDataByte(U8 rdata)
{
    int i;

    for(i=0;i<8;i++)
    {
		if(rdata & (1<<i))
	    	outCellValue[rdataOutCellIndex[i]]=HIGH;
		else
	    	outCellValue[rdataOutCellIndex[i]]=LOW;
    }
}


void S6400_SetRDataHW(U16 rdata)
{
    int i;

    for(i=0;i<16;i++)
    {
		if(rdata & (1<<i))
	    	outCellValue[rdataOutCellIndex[i]]=HIGH;
		else
	    	outCellValue[rdataOutCellIndex[i]]=LOW;
    }
}


void S6400_SetRDataWord(U32 rdata)
{
    int i;

    for(i=0;i<32;i++)
    {
		if(rdata & (1<<i))
	    	outCellValue[rdataOutCellIndex[i]]=HIGH;
		else
	    	outCellValue[rdataOutCellIndex[i]]=LOW;
    }
}


U8 S6400_GetRDataByte(void)
{
    int	i;
    U8 rdata=0;

    for(i=0;i<8;i++)
    {
		if(inCellValue[rdataInCellIndex[i]]==HIGH)
		{
		    rdata = (rdata | (1<<i));
		}
    }
    return rdata;
}


U16 S6400_GetRDataHW(void)
{
    int	i;
    U16 rdata=0;

    for(i=0;i<16;i++)
    {
		if(inCellValue[rdataInCellIndex[i]]==HIGH)
		{
		    rdata = (rdata | (1<<i));
		}
    }
    return rdata;
}


U32 S6400_GetRDataWord(void)
{
    int	i;
    U32 rdata=0;

    for(i=0;i<32;i++)
    {
	if(inCellValue[rdataInCellIndex[i]]==HIGH)
	{
	    rdata = (rdata | (1<<i));
	}
    }
    return rdata;
}