---

jtag_pp_commander.cpp

/*--------------------------------------------------------------------
 * jtag_pp_commander.cpp -- JTAG Parallel Port Commander Class 
 *--------------------------------------------------------------------
 * $Id: jtag_pp_commander.cpp,v 1.1 2003/04/08 08:59:53 cgaudin Exp $
 *--------------------------------------------------------------------
 * This file is part of JTAG Framework
 * (c) 2002 Julien Pilet <julien.pilet@epfl.ch> and
 *          Stephane Magnenat <stephane.magnenat@epfl.ch>
 *--------------------------------------------------------------------
 * JTAG Framework is free software; you can redistribute it
 * and/or modify it under the terms of the GNU General Public License 
 * as published by the Free Software Foundation; either version 2 of 
 * the License, or (at your option) any later version.
 *
 * JTAG Framework is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Foobar; if not, write to: 
 * Free Software Foundation, Inc., 
 * 59 Temple Place, 
 * Suite 330, Boston, MA  02111-1307  USA
 *--------------------------------------------------------------------
 *! \file
 *
 * \brief JTAG Commander for Parallel Port 
 *
 * \author Julien Pilet <julien.pilet@epfl.ch>
 * \author Stephane Magnenat <stephane.magnenat@epfl.ch>
 * \author Cedric Gaudin <cedric.gaudin@epfl.ch> 
 */

#include "jtag_pp_commander.h"

/* JTAG state machine */
const int JSM[16][2] = {
  { JS_IDLE       , JS_RESET } ,
  { JS_IDLE       , JS_SELECT_DR_SCAN } ,
  { JS_CAPTURE_DR , JS_SELECT_IR_SCAN } ,
  { JS_SHIFT_DR   , JS_EXIT1_DR } ,
  { JS_SHIFT_DR   , JS_EXIT1_DR } ,
  { JS_PAUSE_DR   , JS_UPDATE_DR } , 
  { JS_PAUSE_DR   , JS_EXIT2_DR } ,
  { JS_SHIFT_DR   , JS_UPDATE_DR } ,
  { JS_IDLE       , JS_SELECT_DR_SCAN } ,
  { JS_CAPTURE_IR , JS_RESET } ,
  { JS_SHIFT_IR   , JS_EXIT1_IR } ,
  { JS_SHIFT_IR   , JS_EXIT1_IR } ,
  { JS_PAUSE_IR   , JS_UPDATE_IR } ,
  { JS_PAUSE_IR   , JS_EXIT2_IR } ,
  { JS_SHIFT_IR   , JS_UPDATE_IR } ,
  { JS_IDLE       , JS_SELECT_DR_SCAN }
};


JTAG_ParallelPort_Commander::JTAG_ParallelPort_Commander( JTAG_Driver * driver )
{
  this->driver = driver; 
  state = JS_RESET;
}

JTAG_ParallelPort_Commander::~JTAG_ParallelPort_Commander()
{
  delete driver;
}

bool JTAG_ParallelPort_Commander::init( int argc , 
                                        char **argv )
{
  if (!driver->init( argc , argv ))
    return false;

  // we need a method for checking 
  // instruction register length
  // this->ir_reg_length = ir_reg_length;
  this->ir_reg_length = 5;
  
  return true;
}

void JTAG_ParallelPort_Commander::ireg( unsigned char * data )
{
  unsigned long value;

  value = data[0];

  if ( ir_reg_length > 8 )
    value |= ((data[1] << 8)&0xff00);

  if ( ir_reg_length > 16 )
    value |= ((data[2] << 16)&0xff0000);

  if ( ir_reg_length > 24 )
    value |= ((data[3] << 24)&0xff000000);

  jtag_ireg(value);
}

void JTAG_ParallelPort_Commander::dreg( unsigned char * data , unsigned char length , bool writeOnly )
{
  unsigned long value;
  unsigned int  count;

  count = 0;
  while ( count < length ) {
    value = data[8*count];
    
    if (( count + 8 ) <= length ) 
      value |= ((data[count/8+1]<<8)&0xff00);
    
    if (( count + 16 )  <= length )
      value |= ((data[count/8+2]<<8)&0xff0000);
    
    if (( count + 24 ) <= length )
      value |= ((data[count/8+3]<<8)&0xff000000);
    
    value  = jtag_dreg( ((count + 32 <= length)?32:(length-count)) , value );
    
    count += 32;
  }
}

void JTAG_ParallelPort_Commander::jtagReset( void )
{
  jtag_reset( false );
}

void JTAG_ParallelPort_Commander::cpuReset( bool state )
{
  cpu_reset( state );
}

void JTAG_ParallelPort_Commander::trst( bool state )
{
  // really do nothing !
  jtag_reset( true );
}

void JTAG_ParallelPort_Commander::idle( unsigned int nbTCK )
{
  // nbTCK are ignored !

  jtag_idle();
}

void JTAG_ParallelPort_Commander::flushQueue()
{
  flush();
}

const char *JTAG_ParallelPort_Commander::getName( void ) const
{
  return "ppdriver";
}

bool JTAG_ParallelPort_Commander::jtag_reset( bool cold )
{
  if ( cold )
    return false;

  for (int i=0; i<5; i++)
    advance(1);

  return true;
}

void JTAG_ParallelPort_Commander::jtag_idle( )
{
  if ( state != JS_UPDATE_IR &&
       state != JS_UPDATE_DR )
    jtag_reset(false);
  
  advance(0);

}

bool JTAG_ParallelPort_Commander::cpu_reset( bool state )
{
  return driver->drive_signal( SIGNAL_CPU_RESET ,
                               state ,
                               false ,
                               true );
}

void JTAG_ParallelPort_Commander::jtag_ireg( unsigned long value )
{
  if ( state != JS_IDLE && 
       state != JS_RESET )
    jtag_idle();
    
  advance(1);
  advance(1);
  advance(0);
  advance(0);
  // SHIFT_IR
  
  driver->transfer_data( ir_reg_length , 
                         value ,
                         true );

  advance(1);
  advance(1);
  // UPDATE_IR
}

unsigned long JTAG_ParallelPort_Commander::jtag_dreg( int bit_count ,
                                                      unsigned long data )
{
  return driver->transfer_data( bit_count , 
                                data ,
                                false );
}

bool JTAG_ParallelPort_Commander::jtag_shiftdr()
{
  if ( state != JS_UPDATE_DR &&
       state != JS_UPDATE_IR ) {
    if ( state != JS_RESET &&
         state != JS_IDLE ) 
      return false;
    else {
      // JS_RESET or JS_IDLE

      advance(0);
      // RUN_TEST/IDLE state

      advance(1); 
      advance(0);
      advance(0);
      // SHIFT_DR
      
      return true;
    }
  }
  
  advance(1);
  advance(0);
  advance(0);
  // SHIFT_DR

  return true;
     
}

bool JTAG_ParallelPort_Commander::jtag_updatedr()
{
  if ( state != JS_SHIFT_DR )
    return false;

  advance(1);
  advance(1);
  // UPDATE_DR

  return true;
}

void JTAG_ParallelPort_Commander::flush()
{ 
  driver->flush();
}

void JTAG_ParallelPort_Commander::advance( bool mode_select )
{
  driver->drive_signal( SIGNAL_TMS , 
                        mode_select ,
                        true , 
                        true );

  state = JSM[state][(mode_select?1:0)];
}

---