jtagSystemC.cpp

/*
 * Copyright (c) 2014, Franck Jullien <franck.jullien@gmail.com>
 * All rights reserved.
 *
 * Redistribution and use in source and non-source forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in non-source form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *
 * THIS WORK IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * WORK, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdlib.h>
#include <stdio.h>
#include <iomanip>
#include <stdint.h>
#include <string.h>
#include <argp.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include "jtagSystemC.h"

#include "jtag_common.h"

int SystemCJtagServer::gen_clk(int nb_period, uint8_t *captured_tdo,
        int restart, int get_tdo)
{
	static bool gen_clk_begin = 1;
	static bool tck_low = 1;
	static uint64_t time;
	static int cur_period = 0;
	static int capture_done = 0;
    uint64_t t = sc_time_stamp().value(); 

	if (restart) {
		cur_period = 0;
		gen_clk_begin = 1;
		tck_low = 1;
		return DONE;
	}

	if (gen_clk_begin) {
		gen_clk_begin = 0;
		time = t;
	}

	if (cur_period < (nb_period * tck_period)) {
		if (tck_low) {
			capture_done = 0;
			tck = 0;
			if ((t - time) > tck_period) {
				time = t;
				tck_low = 0;
			}
			return IN_PROGRESS;
		} else {
			tck = 1;
			if (get_tdo && !capture_done) {
				capture_done = 1;
				*captured_tdo = tdo;
			}
			if ((t - time) > tck_period) {
				time = t;
				tck_low = 1;
			}
			cur_period++;
			return IN_PROGRESS;
		}
	}

	capture_done = 0;
	gen_clk_begin = 1;
	return DONE;
}

void SystemCJtagServer::gen_clk_restart()
{
	gen_clk(0, NULL, 1, 0);
}

int SystemCJtagServer::reset_tap()
{
	tms = 1;
	if (gen_clk(5, NULL, 0, 0) == DONE) {
		gen_clk_restart();
		tms = 0;
		return DONE;
	}

	return IN_PROGRESS;
}

int SystemCJtagServer::goto_run_test_idle()
{
	tms = 0;
	if (gen_clk(1, NULL, 0, 0) == DONE) {
		gen_clk_restart();
		return DONE;
	}

	return IN_PROGRESS;
}

int SystemCJtagServer::do_tms_seq(int length, int nb_bits, uint8_t *buffer)
{
	static int i = 0;
	static int j = 0;
	static unsigned char data;
	static int start = 1;
	int nb_bits_rem;
	int nb_bits_in_this_byte;

	// Number of bits to send in the last byte
	nb_bits_rem = nb_bits % 8;

	while (i < length) {
		// If we are in the last byte, we have to send only
		// nb_bits_rem bits. If not, we send the whole byte.
		nb_bits_in_this_byte = (i == (length - 1)) ? nb_bits_rem : 8;

		if (start) {
			data = buffer[i];
			start = 0;
		}

		while (j < nb_bits_in_this_byte) {
			tms = 0;
			if ((data & 1) == 1)
				tms = 1;
			if (gen_clk(1, NULL, 0, 0) == DONE) {
				j++;
				data = data >> 1;
				gen_clk_restart();
			}
			return IN_PROGRESS;
		}

		j = 0;
		i++;
		start = 1;
		return IN_PROGRESS;
	}

	tms = 0;
	i = 0;
	j = 0;
	start = 1;

	return DONE;
}

int SystemCJtagServer::do_scan_chain(int length, int nb_bits,
	unsigned char *buffer_out, unsigned char *buffer_in, int flip_tms)
{
	static int i = 0;
	static int j = 0;
	static int index = 0;
	static int start = 1;
	static unsigned char data;
	static uint8_t captured_tdo;
	int nb_bits_rem;
	int nb_bits_in_this_byte;

	// Number of bits to send in the last byte
	nb_bits_rem = nb_bits % 8;

	while (i < length) {
		// If we are in the last byte, we have to send only
		// nb_bits_rem bits if it's not zero.
		// If not, we send the whole byte.
		nb_bits_in_this_byte = (i == (length - 1)) ? ((nb_bits_rem == 0) ? 8 : nb_bits_rem) : 8;

		if (start) {
			buffer_in[i] = 0;
			if (buffer_out)
				data = buffer_out[i];
			else
				data = 0;
			start = 0;
		}

		while (j < nb_bits_in_this_byte) {
			tdi = 0;
			if ((data & 1) == 1)
				tdi = 1;

			// On the last bit, set TMS to '1'
			if (((j == (nb_bits_in_this_byte - 1)) && (i == (length - 1))) && (flip_tms == 1))
				tms = 1;

			if (gen_clk(1, &captured_tdo, 0, 1) == DONE) {
				if (captured_tdo)
					buffer_in[i] |= (1 << j);
				else
					buffer_in[i] &= ~(1 << j);
				j++;
				data = data >> 1;
				gen_clk_restart();
			}
			return IN_PROGRESS;
		}

		j = 0;
		i++;
		start = 1;
		return IN_PROGRESS;
	}

	tdi = 0;
	tms = 0;
	i = 0;
	j = 0;
	start = 1;

	return DONE;
}

int SystemCJtagServer::init_jtag_server(int port)
{
  return ::init_jtag_server(port);
}


void SystemCJtagServer::doJTAG()
{
	if (!cmd_in_progress) {
		if (check_for_command(&packet) != 0) {
			packet.cmd = 99;
		} else if (packet.cmd == CMD_SCAN_CHAIN || packet.cmd == CMD_SCAN_CHAIN_FLIP_TMS) {
            //std::cout << "length: " << packet.length << " num bits: " << packet.nb_bits << " scan in:";
            //std::ios_base::fmtflags f( std::cout.flags() );
            //std::cout << std::hex;
            //for (int i = packet.length - 1; i >= 0; i--) {
            //    std::cout << std::setfill('0') << std::setw(2) << (int) packet.buffer_out[i];
            //}
            //std::cout.flags(f);
            //std::cout << std::endl;
        }
   	}

	switch (jtag_state) {

	case CHECK_CMD:
		switch (packet.cmd) {
		case CMD_RESET:
			cmd_in_progress = 1;
			jtag_state = TAP_RESET;
			break;
		case CMD_TMS_SEQ:
			cmd_in_progress = 1;
			jtag_state = DO_TMS_SEQ;
			break;
		case CMD_SCAN_CHAIN:
			cmd_in_progress = 1;
			tms_flip = 0;
			jtag_state = SCAN_CHAIN;
			break;
		case CMD_SCAN_CHAIN_FLIP_TMS:
			cmd_in_progress = 1;
			tms_flip = 1;
			jtag_state = SCAN_CHAIN;
			break;
		default:
			break;
		}
		break;

	case TAP_RESET:
		if (reset_tap() == DONE) {
			jtag_state = GOTO_IDLE;
		}
		break;

	case GOTO_IDLE:
		if (goto_run_test_idle() == DONE) {
			cmd_in_progress = 0;
			jtag_state = CHECK_CMD;
		}
		break;

	case DO_TMS_SEQ:
		if (do_tms_seq(packet.length, packet.nb_bits, packet.buffer_out) == DONE) {
			cmd_in_progress = 0;
			jtag_state = CHECK_CMD;
		}
		break;

	case SCAN_CHAIN:
		tms = 0;
		if (do_scan_chain(packet.length, packet.nb_bits, packet.buffer_out,
				  packet.buffer_in, tms_flip) == DONE) {
			cmd_in_progress = 0;
			send_result_to_server(&packet);
            //std::cout << "scan out:";
            //std::ios_base::fmtflags f( std::cout.flags() );
            //std::cout << std::hex;
            //for (int i = packet.length - 1; i >= 0; i--) {
            //    std::cout << std::setfill('0') << std::setw(2) << (int) packet.buffer_in[i];
            //}
            //std::cout.flags(f);
            //std::cout << std::endl;
			jtag_state = CHECK_CMD;
		}
		break;

	case FINISHED:
		break;
	}
}

SystemCJtagServer::SystemCJtagServer(sc_core::sc_module_name name) :
        sc_module(name) {
	tck_period = 1; //TODO make period parameterized
	jtag_state = CHECK_CMD;
	cmd_in_progress = 0;
    SC_METHOD(doJTAG);
    sensitive << clk.pos();
}

SystemCJtagServer::~SystemCJtagServer() {
}