jtagup.cpp

TI MSP430 JTAG program for internal flash upgarde from PC printer port

    for(i=0; i<len; i++)
    {
        if (toupper(element[i]) >= 'A') //'A' 'B' 'C' 'D' 'E' 'F'
            ret = (ret << 4) + toupper(element[i]) - 'A' + 10;
        else
            ret = (ret << 4) + element[i] - '0';
    }
    return ret;
}

/*
 * DESCRIPTION:      Drives TCK, TDI, and TMS signals and reads TDO signal 
 *                   via _outp and _inp calls.
 *             -----   At Real Board: -----
 *                   Output pins (LPT driving)
 *                       LPT D0 Pin 2 and TCK J10 Pin 4
 *                       LPT D1 Pin 3 and TDI J10 Pin 11
 *                       LPT D2 Pin 4 and TMS J10 Pin 9
 *             -----   At Test Board: -----		   	
 *                       LPT D0 Pin 2 and TDI 
 *                       LPT D1 Pin 3 and TMS  
 *                       LPT D2 Pin 4 and TCK 
 *                   Input pin (uP drives)
 *             -----   At Real Board: -----	       	
 *                       LPT Busy Pin 11 and TDO J10 Pin 13
 *             -----   At Test Board: -----
 *                       LPT Paperend(S5) Pin 12 and TDO
 *
 * get 1 bit TDO data 
 * 
 * History:
 * 10-SEP-2003  Lucas Kuo
 */
int getp1(byte usX)
{
     int tdo = -1;
     if(!gBoardSelect)
     {
     	tdo = !((int)_inp(lpt_address + 1) >> 7);	// get Real Board TDO data
		//printf("in get tdo REl\n");
     }
     else
     {	
 
      tdo = (int)_inp(lpt_STAT);                        //get Experimentaion Board TDO data     
      tdo = (tdo & 0x20) >> 5;
	  //printf("in get tdo test\n");
     }
     return tdo;
}

/*
 * put TCK, TMS, TDO
 * 
 * History:
 * 10-SEP-2003  Lucas Kuo
 */
void putp1(byte tck, byte tms, byte tdi, byte usX)
{
    g_tck = tck;
    g_tms = tms;
    g_tdi = tdi;
 
    // TCK is D2, TMS is D1, and TDI is D0, so construct an output by creating a 
    // rising edge on TCK with TMS and TDI data set.
    
    if(!gBoardSelect){
		_outp(lpt_address, tms*4+tdi*2+tck+128);
		//printf("in put tdo REl\n");
	}
    else 
	{_outp(lpt_address, tck*4+tms*2+tdi+128);
	 //printf("in put tdo test\n");
	}// 128 is power on	
        
    //Delay(usDelay*usX);       // delay usDelay*usX microsecond
}

/*
*******************************************************************************
*
* FUNCTION:         error_out
*
* DESCRIPTION:      generic error printout and program exit.
*
* INPUT PARAMETERS: char * error_string to print before exit
*
* RETURNS:          void
*
* GLOBAL EFFECTS:   Exits the program
*******************************************************************************
*/

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

/*
*******************************************************************************
*
* FUNCTION:         test_port
*
* DESCRIPTION:      Searches for a valid parallel port
*
* INPUT PARAMETERS: void
*
* RETURNS:          int - Address of the port or zero if none available
*
*******************************************************************************
*/

int test_port(void)
{
	// search for valid parallel port
		_outp(LPT1, 0x55);
		if((int)_inp(LPT1) == 0x55)
        {
            if(Debug_Mode)
            	printf("Parallel Com port found at I/O address: %X\n", LPT1);

            return LPT1;
        }

		_outp(LPT2, 0x55);
		if((int)_inp(LPT2) == 0x55)
        {
            if(Debug_Mode)
            	printf("Parallel Com port found at I/O address: %X\n", LPT2);
           
            return LPT2;
		}
 
        _outp(LPT3, 0x55);
		if((int)_inp(LPT3) == 0x55)
        {
            if(Debug_Mode)
            	printf("Parallel Com port found at I/O address: %X\n", LPT3);
            
            return LPT3;
        }
        
	return(0);	// return zero if none found
}

#define	D_LOOPBODY		8		// MSP430: 8 cycles for "for" body
#define D_LOOPCOUNT1MS	(word)((FREQUENCY / D_LOOPBODY))

void Delay(int microsec)			// Inner loop generates 1 ms
{
	int i, j;
	for (i = microsec; i > 0; i--)
		for (j = D_LOOPCOUNT1MS; j > 0; j--) ;
}

/*
 * uP initial
 * 
 * History:
 * 10-SEP-2003  Lucas Kuo
 */
void uPreset()
{
    //Power off, TCK=0, TMS=0, TDI=0
    _outp(lpt_address, 0);
    Sleep(10);
    //Power on, TCK=1, TMS=1, TDI=1
    putp1(1,1,1,1);     //Power on;
    
    //Reset pin on-off-on
    _outp(lpt_CTL, 0);
    Sleep(10);
    _outp(lpt_CTL, 1);
    Sleep(10);
    _outp(lpt_CTL, 0);
    Sleep(10);
}

void FlashTest()
{
    int addr;
    word buf[1];
    byte pattern;
    byte antipattern;
    
    //RAM memory test (0x200 - 0x2FF) 256 bytes
    //Fill memory with a known pattern.
    printf("RAM memory testing!\n");
    for (pattern = 1, addr = 0x200; addr < 0x2FF; pattern++, addr++)
    {
        WriteMem(F_BYTE,addr,pattern);
    }
    
    //Check each location and invert it for the second pass.
    for (pattern = 1, addr = 0x200; addr < 0x2FF; pattern++, addr++)
    {
        if (ReadMem(F_BYTE,addr) != pattern)
        {
            printf("Address = 0x%x error",addr);
            exit(0);
        }

        antipattern = ~pattern;
        WriteMem(F_BYTE,addr,antipattern);
    }
    
    //Check each location for the inverted pattern and zero it.
    for (pattern = 1, addr = 0x200; addr < 0x2FF; pattern++, addr++)
    {
        antipattern = ~pattern;
        if (ReadMem(F_BYTE,addr) != antipattern)
        {
            printf("Address = 0x%x error",addr);
            exit(0);
        }
    }
    printf("Done!\n");
    
    //FLASH memory test (0xE000 - 0xFFFF) 8k bytes
    printf("Erase FLASH memory!\n");
    EraseFLASH(ERASE_MASS, 0x1000);       // Mass-Erase Flash (all types)
    
    printf("FLASH memory testing!\n");
    for (pattern = 1, addr = 0xE000; addr < 0xFFFF; pattern++, addr+=2)
    {
        buf[0] = pattern + (pattern << 8);
        WriteFLASH(addr,1,&buf[0]);
    }
    
    for (pattern = 1, addr = 0xE000; addr < 0xFFFF; pattern++, addr+=2)
    {
        if (ReadMem(F_BYTE,addr) != pattern)
        {
            printf("Address = 0x%x error",addr);
            exit(0);
        }
        if (ReadMem(F_BYTE,addr+1) != pattern)
        {
            printf("Address = 0x%x error",addr+1);
            exit(0);
        }
    }
    
    EraseFLASH(ERASE_MASS, 0x1000);       // Mass-Erase Flash (all types)
    for (pattern = 1, addr = 0xE000; addr < 0xFFFF; pattern++, addr+=2)
    {
        antipattern = ~pattern;
        buf[0] = antipattern + (antipattern << 8);
        WriteFLASH(addr,1,&buf[0]);
    }
    
    for (pattern = 1, addr = 0xE000; addr < 0xFFFF; pattern++, addr+=2)
    {
        antipattern = ~pattern;
        if (ReadMem(F_BYTE,addr) != antipattern)
        {
            printf("Address = 0x%x error",addr);
            exit(0);
        }
        if (ReadMem(F_BYTE,addr+1) != antipattern)
        {
            printf("Address = 0x%x error",addr+1);
            exit(0);
        }
    }
    printf("Done!\n");
}