lowlevelfuncsbw.c

msp430的jtag程序下载的源代码

/*==========================================================================*\
|                                                                            |
| LowLevelFunc.c                                                             |
|                                                                            |
| Low Level Functions regarding user's Hardware                              |
|----------------------------------------------------------------------------|
| Project:              MSP430 Replicator                                    |
| Developed using:      IAR Embedded Workbench 3.30B                         |
|----------------------------------------------------------------------------|
| Author:               STO                                                  |
| Version:              1.5                                                  |
| Initial Version:      04-17-02                                             |
| Last Change:          12-16-05                                             |
|----------------------------------------------------------------------------|
| Version history:                                                           |
| 1.0 04/02 FRGR        Initial version.                                     |
| 1.1 04/02 FRGR        Included SPI mode to speed up shifting function by 2.|
| 1.2 06/02 ALB2        Formatting changes, added comments.                  |
| 1.3 08/02 ALB2        Initial code release with Lit# SLAA149.              |
| 1.4 09/05 SUN1        Software delays redesigned to use TimerA harware;    |
|                       see MsDelay() routine. Added TA setup                |
| 1.5 12/05 STO         Adapted for SpyBiWire JTAG mode                      |
|----------------------------------------------------------------------------|
| Designed 2002 by Texas Instruments Germany                                 |
\*==========================================================================*/

#include "LowLevelFuncSBW.h"

byte tdo_bit;               //holds the value of TDO-bit
byte TCLK_saved = SBWDATO;  // holds the last value of TCLK before entering a JTAG sequence

/****************************************************************************/
/* Function declarations which have to be programmed by the user for use    */
/* with hosts other than the MSP430F149.                                    */
/*                                                                          */
/* The following MSP430F149-specific code can be used as a reference as to  */
/* how to implement the required JTAG communication on additional hosts.    */
/****************************************************************************/


//-------------------------------
//  combinations of sbw-cycles (TMS, TDI, TDO)
void TMSL_TDIL(void)
{
    TMSL  TDIL  TDOsbw
}
//---------------------------------
void TMSH_TDIL(void)
{
    TMSH  TDIL  TDOsbw
}
//------------------------------------
void TMSL_TDIH(void)
{
    TMSL  TDIH  TDOsbw
}
//-------------------------------------
void TMSH_TDIH(void)
{
    TMSH  TDIH  TDOsbw
}
//------------------------------------
void TMSL_TDIH_TDOrd(void)
{
    TMSL  TDIH  TDO_RD
}
//------------------------------------
void TMSL_TDIL_TDOrd(void)
{
    TMSL  TDIL  TDO_RD
}
//------------------------------------
void TMSH_TDIH_TDOrd(void)
{
    TMSH  TDIH  TDO_RD
}
//------------------------------------
void TMSH_TDIL_TDOrd(void)
{
    TMSH  TDIL  TDO_RD
}

//----------------------------------------------
// enters with TCLK_saved and exits with TCLK = 0
void ClrTCLK_sbw(void)
{
    if (TCLK_saved & SBWDATO)
    {
        TMSLDH
    }
    else
    {
        TMSL
    }

    JTAGOUT &= ~SBWDATO;

    TDIL TDOsbw    //ExitTCLK
    TCLK_saved = ~SBWDATO;
}

//----------------------------------------------
// enters with TCLK_saved and exits with TCLK = 1
void SetTCLK_sbw(void)
{
   if (TCLK_saved & SBWDATO)
   {
        TMSLDH
   }
   else
   {
        TMSL
   }

   JTAGOUT |= SBWDATO;

   TDIH TDOsbw    //ExitTCLK
   TCLK_saved = SBWDATO;
}

/*----------------------------------------------------------------------------
   Initialization of the Controller Board (Master or Host)
*/
void InitController(void)
{
	volatile byte i;

	WDTCTL   = WDTPW + WDTHOLD;		// Stop watchdog timer

	// initialize MCLK = LFXT1 (external crystal)
	BCSCTL1 |= XTS;				    // ACLK = LFXT1 = HF XTAL
    do
    {
		IFG1 &= ~OFIFG;			    // Clear OSCFault flag
		for (i = 0xFF; i > 0; i--);	// Time for flag to set
	}
	while ((IFG1 & OFIFG) != 0);	// OSCFault flag still set?
	IFG1 &= ~OFIFG;				    // Clear OSCFault flag again
	BCSCTL2 |= SELM1+SELM0;			// MCLK = LFXT1 (safe)

    // Setup timer_A for hardware delay
	TACTL &= MC_0;				    // STOP Timer
    TACTL |= ID_3+TASSEL_1;  		// Timer_A source: ACLK/8 = 1MHz
	TACCR0 = ONEMS;				    // Load CCR0 with delay... (1ms delay)

	MsDelay(50);				    // debounce RST key

	// initialize the Status LEDs control port
	LEDSEL  &= ~(LEDGREEN | LEDRED);	// no special function, I/O
	LEDOUT  &= ~(LEDGREEN | LEDRED);	// LEDs are OFF
	LEDDIR  |=  (LEDGREEN | LEDRED);	// LED pins are outputs
}

/*----------------------------------------------------------------------------
   This function switches TDO to Input, used for fuse blowing
*/
/*void TDOisInput(void)
{
	JTAGOUT &= ~TDICTRL1;	    // Release TDI pin on target
	MsDelay(5);				    // Settle MOS relay
	JTAGOUT |=  TDICTRL2;		// Switch TDI --> TDO
	MsDelay(5);				    // Settle MOS relay
}*/

/*----------------------------------------------------------------------------
   Initialization of the Target Board (switch voltages on, preset JTAG pins)
*/
void InitTarget(void)
{
	JTAGSEL  = 0x00;			// Pins all I/Os
	JTAGOUT  = SBWDATO | TMS | TCK |  VCCTGT;
	JTAGDIR  = TEST | SBWDATO | TMS | TCK |  VCCTGT;
	VPPSEL  &= ~(VPPONTDI | VPPONTEST);	// No special function, I/Os
	VPPOUT  &= ~(VPPONTDI | VPPONTEST);	// VPPs are OFF
	VPPDIR  |=  (VPPONTDI | VPPONTEST);	// VPP pins are outputs
	MsDelay(50);				        // Settle MOS relays, target capacitor
}

/*----------------------------------------------------------------------------
   Release Target Board (switch voltages off, JTAG pins are HI-Z)
*/
void ReleaseTarget(void)
{
	VPPoff();				// VPPs are off (safety)
	MsDelay(5);				// Settle MOS relays
	JTAGDIR  =  0x00;	    // VCC is off, all I/Os are HI-Z
	MsDelay(5);				// Settle MOS relays
}

//----------------------------------------------------------------------------
/*  Shift a value into TDI (MSB first) and simultaneously shift out a value
    from TDO (MSB first).
    Arguments: word Format (number of bits shifted, 8 (F_BYTE) or 16 (F_WORD))
               word Data (data to be shifted into TDI)
    Result:    word (scanned TDO value)
*/
word Shift_sbw(word Format, word Data)
{
   word TDOword = 0x0000;
   word MSB = 0x0000;
   word i;

   (Format == F_WORD) ? (MSB = 0x8000) : (MSB = 0x80);
   for (i = Format; i > 0; i--)
   {
        if (i == 1)                     // last bit requires TMS=1; TDO one bit before TDI
        {
          ((Data & MSB) == 0) ? TMSH_TDIL_TDOrd() : TMSH_TDIH_TDOrd();
        }
        else
        {
          ((Data & MSB) == 0) ? TMSL_TDIL_TDOrd() : TMSL_TDIH_TDOrd();
        }
        Data <<= 1;
        if (tdo_bit & SBWDATI)
            TDOword++;
        if (i > 1)
            TDOword <<= 1;               // TDO could be any port pin
   }
   TMSH_TDIH();                         // update IR
   if (TCLK_saved & SBWDATO)
   {
        TMSL_TDIH();
   }
   else
   {
        TMSL_TDIL();
   }
   return(TDOword);
}


/*---------------------------------------------------------------------------
   Delay function (resolution is 1 ms)
   Arguments: word millisec (number of ms, max number is 0xFFFF)
*/
void MsDelay(word milliseconds)
{
    volatile word i;
    for(i = milliseconds; i > 0; i--)
    {
        TACCTL0 &= ~CCIFG;		        // Clear the interrupt flag
        TACTL |= TACLR+MC_1;	        // Clear & start timer
        while ((TACCTL0 & CCIFG)==0);	// Wait until the Timer elapses
        TACTL &= ~MC_1;			        // Stop Timer
    }
}

/*---------------------------------------------------------------------------
   This function generates Amount strobes with the Flash Timing Generator
   Frequency fFTG = 257..476kHz (t = 3.9..2.1us).
   User knows target frequency, instruction cycles, C implementation.
   Arguments: word Amount (number of strobes to be generated)
*/
void TCLKstrobes_sbw(word Amount)       // enters with TCLK_saved and exits with TCLK = 1
{
   word i;

   if (TCLK_saved & SBWDATO)
   {
        TMSLDH
   }                         // TDI = 1 with rising sbwclk
   else
   {
        TMSL
   }
   for (i = Amount; i > 0; i--)
   {
        JTAGOUT &= ~SBWDATO;
        _NOP(); _NOP(); _NOP(); _NOP();
        JTAGOUT |= SBWDATO;
        _NOP();
   }
   TDIH TDOsbw    //ExitTCLK
   TCLK_saved = SBWDATO;
}

/*----------------------------------------------------------------------------
   This function controls the status LEDs depending on the status
   argument. It stops program in error case.
   Arguments: word status (4 stati possible for 2 LEDs)
              word index (additional number for detailed diagnostics or
                          watch variable during debugging phase)
*/
void ShowStatus(word status, word index)
{
	LEDOUT  &= ~(LEDGREEN | LEDRED);	// Both LEDs are off
	switch (status)
	{
		case STATUS_ERROR:
			LEDOUT  |= LEDRED;	// Switch red LED on
			ReleaseTarget();	// Voltages off, JTAG HI-Z
			while(index);		// Stop program, index must be > 0
		case STATUS_ACTIVE:;	// Switch both LEDs on
			LEDOUT  |= LEDRED;
		case STATUS_OK:			// Switch green LED on
			LEDOUT  |= LEDGREEN;
		case STATUS_IDLE:;		// Switch both LEDs off
	}
}						        // return if active, idle, ok

/*----------------------------------------------------------------------------
   This function performs a Trigger Pulse for test/development
*/
#ifdef DEBUG
void TriggerPulse(word mode)
{
	switch (mode)
	{
		case 1:	LEDOUT  |=  TRIGGER;	// mode = 1: set trigger
				break;
		case 2:	LEDOUT  |=  TRIGGER;	// mode = 2: set/reset trigger
		case 0:	LEDOUT  &= ~TRIGGER;	// mode = 0: reset trigger
	}
}
#endif

/****************************************************************************/
/*                         END OF SOURCE FILE                               */
/****************************************************************************/