jflash.cpp

pxa255用的并口烧写jtag口的源代码。可以修改为其他的cpu等下载工具

* RETURNS:          void
*
* GLOBAL EFFECTS:   Exits the program
*******************************************************************************
*/

void error_out(char *error_string)
{
	printf("%s\n",error_string);
	exit(0);
}

/*
*******************************************************************************
*
* FUNCTION:         program_flash
*
* DESCRIPTION:      program the flash using buffered writes
*
* INPUT PARAMETERS: DWORD max_write_buffer derived from the flash query
*                   DWORD base_address
*                   DWORD fsize (flash size)
*
* RETURNS:          void
*
*******************************************************************************
*/

void program_flash(DWORD max_write_buffer, DWORD base_address, DWORD fsize)
{
	time_t start = 0;
	time_t now = 0;
	WORD li_WORD;
	DWORD li_DWORD;
	DWORD write_word_count;
	int bus_width;
//	DWORD Status;
	printf("Starting programming\n");

	if(!strcmp("WORD", &WORDARRAY[P_progmode][0] ))
	{
		printf("Using WORD programming mode...\n");

		for(DWORD lj = base_address; lj < fsize + base_address; lj = lj +1)
		{
			
			time(&now);
			if(difftime(now,start) > STATUS_UPDATE)	// Update status every 2 seconds
				{
			   	printf("Writing flash at hex address %8lx, %5.2f%% done    \r"
					,lj * ADDR_MULT ,(float)(lj - base_address)/(float)fsize*100.0);
				time(&start);
				}

			if(!PlatformIs16bit)
			{
				fread((DWORD *)&li_DWORD, sizeof(DWORD) , 1, in_file);
				access_rom(WRITE, lj, F_WORDBYTE_PROG, IGNORE_PORT); 
				access_rom(HOLD, lj, F_WORDBYTE_PROG, IGNORE_PORT);
				access_rom(WRITE, lj, li_DWORD, IGNORE_PORT); 
				access_rom(HOLD, lj, li_DWORD, IGNORE_PORT);
			}
			else
			{
				fread((WORD *)&li_WORD, sizeof(WORD) , 1, in_file);
				access_rom(WRITE, lj, F_WORDBYTE_PROG, IGNORE_PORT); 
				access_rom(HOLD, lj, F_WORDBYTE_PROG, IGNORE_PORT);
				access_rom(WRITE, lj, li_WORD, IGNORE_PORT); 
				access_rom(HOLD, lj, li_WORD, IGNORE_PORT);
			}
		}
			 	Write_Rom(lj, F_READ_ARRAY);
	}

	else if(!strcmp("BUFFER", &WORDARRAY[P_progmode][0] ))
	{
		printf("Using BUFFER programming mode...\n");

		// "Write Buffer" flow.
		// This uses almost half the cycles required by "word programming" flow
		// Status register is not read to save time.  There is also no checking to see
		// if maximum "Write Buffer Program Time" is violated.  However even with the
		// fastest parallel port bus speed this should not be a problem
		// (i.e. 16 words * 300 JTAG chain length * 4 parallel port cycles * 1uS fast
		// parallel port cycle = 19mS, typical write buffer program times are in the 200uS range).

	if(!PlatformIs16bit)
		write_word_count = (max_write_buffer - 1) + ((max_write_buffer - 1) << 16);
	else
		write_word_count = max_write_buffer - 1;


		time(&start);

		for(DWORD lj = base_address; lj < fsize + base_address; lj = lj + max_write_buffer)
		{

			access_rom(WRITE, lj, F_WRITE_BUFFER, IGNORE_PORT); // write buffer command
			access_rom(HOLD, lj, F_WRITE_BUFFER, IGNORE_PORT);

			access_rom(WRITE, lj, write_word_count, IGNORE_PORT); // write word count (max write buffer size)
			access_rom(HOLD, lj, write_word_count, IGNORE_PORT);

			time(&now);
			if(difftime(now,start) > STATUS_UPDATE)	// Update status every 2 seconds
				{
			   	printf("Writing flash at hex address %8lx, %5.2f%% done    \r"
					,lj * ADDR_MULT ,(float)(lj - base_address)/(float)fsize*100.0);
				time(&start);
				}

			if(!PlatformIs16bit)
			{
				for(DWORD lk = 0; lk < max_write_buffer; lk++)
				{
					fread((DWORD *)&li_DWORD, sizeof(DWORD) , 1, in_file);
					access_rom(WRITE, lj+lk, li_DWORD, IGNORE_PORT);  // Write buffer data
					access_rom(HOLD, lj+lk, li_DWORD, IGNORE_PORT);  // New
				 //	printf("writing %x at address %x\n", li_DWORD, lj+lk);
				}
			}
			else
			{
				for(DWORD lk = 0; lk < max_write_buffer; lk++)
				{
					fread((WORD *)&li_WORD, sizeof(WORD) , 1, in_file);
					access_rom(WRITE, lj+lk, li_WORD, IGNORE_PORT);  // Write buffer data
					access_rom(HOLD, lj+lk, li_WORD, IGNORE_PORT);  // New
				}
			}

				// No need to diferentiate between 16 and 32 bit access_rom functions anymore!
				access_rom(WRITE, 0, F_BLOCK_ERASE_2ND, IGNORE_PORT); // Program Buffer to Flash Confirm
				access_rom(HOLD, 0, F_BLOCK_ERASE_2ND, IGNORE_PORT);  //New
		}
			 	Write_Rom(lj, F_READ_ARRAY);
	}
	else if(!strcmp("XSCALE", &WORDARRAY[P_progmode][0] ))
	{
		printf("Using XSCALE programming mode...\n");
		
		xscale_init_handler();
		if(!PlatformIs16bit) 
		{
			bus_width = 32;
		}
		else
		{
			bus_width = 16;
		}
		
		xscale_program_flash(in_file, base_address, fsize, bus_width);	

	}


	printf("\nProgramming done\n");

	rewind(in_file);
}
/*
*******************************************************************************
*
* FUNCTION:         verify_flash
*
* DESCRIPTION:      compares data programmed in flash with the original binary file.
*
* INPUT PARAMETERS: DWORD base_address
*                   DWORD flash_size
*
* RETURNS:          void
*
*******************************************************************************
*/

void verify_flash(DWORD base_address, DWORD fsize)
{
	time_t start, now;
	DWORD li_DWORD, li1_DWORD;
	WORD li_WORD, li1_WORD;
	int dumpcount = 0;
	bool verified = false;
	bool retry = false;

	printf("Starting Verify\n");
	

	
	time(&start);

	if(PlatformIs16bit)
	{
		for(DWORD lj = base_address + 1; lj <= fsize + base_address; lj++)
			{
			fread((WORD *)&li_WORD, sizeof(WORD) , 1, in_file);
			retry = false;
			verified = false;
			do
			{
			    // toggle the chip select for K3 flash
			    access_rom(RS, lj, 0x0L, READ_PORT);
				
				li1_WORD = (WORD) Read_Rom(lj);
				
				#ifdef K3_BUGFIX
			    Read_Rom(lj);  //hack to fix K3 flash bug?
				#endif //K3_BUGFIX

				time(&now);
				if(difftime(now,start) > STATUS_UPDATE)	// Update status every 2 seconds
					{
					printf("Verifying flash at hex address %8lx, %5.2f%% done    \r"
						,lj*ADDR_MULT ,(float)(lj - base_address)/(float)fsize*100.0);
					time(&start);
					}
				if(li_WORD != li1_WORD)
					{
						printf("verify error at address = %lx exp_dat = %lx act_dat = %lx\n",(lj - 1)*ADDR_MULT, li_WORD,li1_WORD);
						dumpcount++;
						if(dumpcount > 10) exit(1);
						verified = false;
						printf("Retrying....\n");
						
						retry = true;
					}
					else
					{
						verified = true;
						if (retry) dumpcount--;
					}

			
			    }while(!verified);
			}
	}
	else 
	{
		for(DWORD lj = base_address + 1; lj <= fsize + base_address; lj++)
		{
			fread((DWORD *)&li_DWORD, sizeof(DWORD) , 1, in_file);
			retry = false;
			verified = false;
		 do
		 {
		    // toggle the chip select for K3 flash
		    access_rom(RS, lj, 0x0L, READ_PORT);
			li1_DWORD = Read_Rom(lj);
		    //	li1_DWORD = Read_Rom(lj);
			
			
			time(&now);
			if(difftime(now,start) > STATUS_UPDATE)	// Update status every 2 seconds
				{
				printf("Verifying flash at hex address %8lx, %5.2f%% done    \r"
					,lj*ADDR_MULT ,(float)(lj - base_address)/(float)fsize*100.0);
				time(&start);
				}
			if(li_DWORD != li1_DWORD)
				{
					printf("verify error at address = %lx exp_dat = %lx act_dat = %lx\n",(lj - 1) *ADDR_MULT,li_DWORD,li1_DWORD);
					dumpcount++;
					if(dumpcount > 10) exit(1);
					verified = false;
					printf("Retrying....\n");
					
					retry = true;
				}
				else
				{
					verified = true;
					if(retry) dumpcount--;
				}
			}while(!verified);
		}
	}


	printf("\nVerification successful!                                                    \n");
}
/*
*******************************************************************************
*
* FUNCTION:         test_logic_reset
*
* DESCRIPTION:      initializes the JTAG state machine to a known state
*
* INPUT PARAMETERS: void
*
* RETURNS:          void
*
*******************************************************************************
*/
 
void test_logic_reset(void)
{
    if(Debug_Mode)
    printf("begin test logic reset\n");
    

	// keep TMS set to 1 force a test logic reset
	// no matter where you are in the TAP controller
	for(int i=0; i < 6; ++i)
		putp(1,1,IGNORE_PORT);

    if(Debug_Mode)
    printf("finish test logic reset\n");
    
}

/*
*******************************************************************************
*
* FUNCTION:         set_lock_flash
*
* DESCRIPTION:      sets locks bits in specified block
*
* INPUT PARAMETERS: DWORD base_address of flash
*                   DWORD fsize - size of flash
*                   DWORD block_size - block size of flash
*                   DWORD max_erase_time - used for a timeout 
*                   int block_number - block number of interest
*
* RETURNS:          void
*
*******************************************************************************
*/


void set_lock_flash(DWORD base_address, DWORD fsize, DWORD block_size, DWORD max_erase_time, int block_number)
{
	time_t start, now;

	printf("Starting set block lock bit\n");

	for(DWORD lj = base_address; lj < fsize + base_address; lj = lj + block_size)  // locks only blocks to be programmed
		{

		// Rami: Should this be lj instead of 0 ???
		Write_Rom(0, F_SET_BLOCK_LOCK);			//  block lock bit command
		Write_Rom(lj, F_SET_BLOCK_LOCK_2ND);	// Confirm

		time(&start);
		printf("Erasing block %3d   \r",block_number++);
		while(access_rom(RS, 0, 0, READ_PORT) != F_STATUS_READY)	// Loop until successful status return
			{
			Read_Rom(0);
			time(&now);
			if(difftime(now,start) > max_erase_time + 1)	// Check for status timeout
				error_out("Error, Clear lock timed out");
			}
		}
	printf("Set lock bit done                                           \n");
}

/*
*******************************************************************************
*
* FUNCTION:         set_address
*
* DESCRIPTION:      Loads the address into the address bits
*
* INPUT PARAMETERS: address
*
* RETURNS:          void
*
* GLOBAL EFFECTS:   None
*
* ASSUMPTIONS:      None
*
* CALLS:            None
*
* CALLED BY:        Anyone
*
* PROTOTYPE:        void set_address(unsigned int address);
*
*******************************************************************************
*/
void set_address (DWORD address)
{
    DWORD i;
    
    for (i = 0; i < 26; i++)
    {
        pin[addr_order[i]] = ((address >> i) & 1);
    }
}

/*
*******************************************************************************
*
* FUNCTION:         set_data
*
* DESCRIPTION:      Fills the chain with the data bits
*
* INPUT PARAMETERS: DWORD data
*
* RETURNS:          void
*
*******************************************************************************
*/
void set_data(DWORD data)
{
    DWORD i;
    
    for(i = 0; i < 32; i++)
    {
        pin[dat_order[i]] = ((data >> i) & 1);	// set data pins
    }
}

/*
*******************************************************************************
*
* FUNCTION:         set_pin_chip_select
*
* DESCRIPTION:      Sets chip selects depending on the address and the platform
*
* INPUT PARAMETERS: DWORD address
*
* RETURNS:          void
*
*******************************************************************************
*/

void set_pin_chip_select(DWORD address)
{
	    
	    	 if((address >= CSR_LADDR[0]) && (address < CSR_HADDR[0]))  pin[CSR1] = 0;
		else if((address >= CSR_LADDR[1]) && (address < CSR_HADDR[1]))  pin[CSR2] = 0;
		else if((address >= CSR_LADDR[2]) && (address < CSR_HADDR[2]))  pin[CSR3] = 0;
		else if((address >= CSR_LADDR[3]) && (address < CSR_HADDR[3]))  pin[CSR4] = 0;
		else if((address >= CSR_LADDR[4]) && (address < CSR_HADDR[4]))  pin[CSR5] = 0;
		else if((address >= CSR_LADDR[5]) && (address < CSR_HADDR[5]))  pin[CSR6] = 0;

		pin[p_nsdcas] = 0;
		
}

/*
*******************************************************************************
*
* FUNCTION:         clear_chip_selects
*
* DESCRIPTION:      reset all chip selects
*
* INPUT PARAMETERS: None
*
* RETURNS:          none
*
*******************************************************************************
*/

void clear_chip_selects()
{
    // Preset to default values 
	
		pin[ChipSelect0] = 1;
		pin[ChipSelect1] = 1;
		pin[ChipSelect2] = 1;
		pin[ChipSelect3] = 1;
		pin[ChipSelect4] = 1;
		pin[ChipSelect5] = 1;
		pin[p_nsdcas] = 1;
}
/*