Subversion Repositories adv_debug_sys

////////////////////////////////////////////////////////////////
//
// rspCoder.java
//
// Copyright (C) 2010 Nathan Yawn 
//                    (nyawn@opencores.org)
//
// This class handles formatting, escaping, and checksumming
// for packets sent to and received from the network layer.
//
////////////////////////////////////////////////////////////////
//
// This source file may be used and distributed without
// restriction provided that this copyright statement is not
// removed from the file and that any derivative work contains
// the original copyright notice and the associated disclaimer.
// 
// This source file 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 3.0 of the License, or (at your option) any
// later version.
//
// This source 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 Lesser General Public License for more
// details.
// 
// You should have received a copy of the GNU General
// Public License along with this source; if not, download it 
// from http://www.gnu.org/licenses/gpl.html
//
////////////////////////////////////////////////////////////////
package advancedWatchpointControl;
 
import java.io.IOException;
 
 
public class rspCoder {
 
 
 
	public enum rcvStateType { WAITING_FOR_START, RECEIVING_DATA, RECEIVING_CSUM1, 
		RECEIVING_CSUM2, FINISHED }
 
	private networkSystem netSys = null;
	private rcvStateType rcvState = rcvStateType.WAITING_FOR_START;
	private StringBuilder rcvPacketStringBuilder = null;
 
	public rspCoder(networkSystem ns) {
		rcvPacketStringBuilder = new StringBuilder();
		netSys = ns;
	}
 
	public void Transact(TargetTransaction t) throws IOException {
		int retries_remaining = 3;
		int rcvchar;
		boolean ret = false;
 
		// Send the packet and look for an RSP ack ("+")
		do {
			escapePacketAndSend(t.getDataToSend());
			rcvchar = netSys.getChar(); // Get +/-
			// If -, retry up to 3 times
		} while((rcvchar != '+') && ((retries_remaining--) >= 0));
 
		if(retries_remaining < 0) {
			throw new IOException("Retries exceeded sending data");
		}
 
		retries_remaining = 3;
 
		do {
			ret = false;
			// Get one complete packet
			String dataPacket = getDataPacket();
			// Unescape, un-RLE, and test the checksum.  Returns null if bad checksum
			String decodedPacket = decodeRSPPacket(dataPacket);
			if(decodedPacket != null) {
				// Let the transaction object parse the specific packet type
				ret = t.receivePacket(decodedPacket);
			}
			if(!ret) {
				sendNak();
			}
 
		} while ((!ret)&& ((retries_remaining--) >= 0));
 
		if(retries_remaining < 0) {
			throw new IOException("Retries exceeded parsing data");
		}
 
		sendAck();
 
	}  // Transact()
 
 
	private boolean escapePacketAndSend(String packetString) {
		//System.out.println("Sending packet: \"" + packetString + "\"");
		String protocolString = new String("$");
 
		// Escape the packet data.  '}' is 0x7d, the escape char.
		// Escaped char must be XOR'd with 0x20.
		packetString.replace("}", "}"+('}'^0x20));  // This must be escaped first!
		packetString.replace("#", "}"+('#'^0x20));  // '#' is 0x23
		packetString.replace("$", "}"+('$'^0x20));  // '$' is 0x24
 
		// Add the packet data
		protocolString += packetString;
 
		// Add the separator
		protocolString += "#";
 
		// Create the checksum (from packetString, not protocolString)
		int checksum = getChecksum(packetString);
 
		// Add the checksum
		if(checksum < 0x10)
			protocolString += "0";
		protocolString += Integer.toHexString(checksum);
 
		// Send it.
		return netSys.sendData(protocolString);
	}
 
 
	// This reads one complete data packet from the network, including checksum
	public String getDataPacket() throws IOException {
		int rcvChar;
		rcvState = rcvStateType.WAITING_FOR_START;
 
		do {
			rcvChar = netSys.getChar();
			//System.out.println("parseData: " + rcvChar);
			switch(rcvState) {
				case WAITING_FOR_START:
					if(rcvChar == '$') {
						// discard the '$' character
						rcvState = rcvStateType.RECEIVING_DATA;
						rcvPacketStringBuilder = new StringBuilder();
					}
					break;
				case RECEIVING_DATA:
					if(rcvChar == '#') {
						rcvState = rcvStateType.RECEIVING_CSUM1;
					}
					rcvPacketStringBuilder.append((char)rcvChar);
					break;
				case RECEIVING_CSUM1:
					rcvPacketStringBuilder.append((char)rcvChar);
					rcvState = rcvStateType.RECEIVING_CSUM2;
					break;
				case RECEIVING_CSUM2:
					rcvPacketStringBuilder.append((char)rcvChar);
					rcvState = rcvStateType.FINISHED;
					break;
			}		
		} while(rcvState != rcvStateType.FINISHED);
 
		return rcvPacketStringBuilder.toString();
	}  // parseData()
 
 
	// This looks like it modifies the input String.  But since a String
	// is actually constant, a new String object should be created each
	// time we "modify" the String, so the original input parameter
	// should remain intact.
	private String decodeRSPPacket(String packet) {
 
		//System.out.println("Parsing packet: \"" + packet + "\"\n");
 
		// Test the checksum
		int checksum = 0;
		try {
			//System.out.println("Checksum substring: " + packet.substring(packet.length()-2));
			checksum = Integer.parseInt(packet.substring(packet.length()-2), 16);
		} catch (NumberFormatException e) {
			// TODO Log the error
			sendNak();
			System.out.println("Got bad checksum: calculated " + getChecksum(packet) + ", read " + checksum);
			return null;			
		}
		// Cut off the '#' and checksum
		packet = packet.substring(0, packet.length()-3);
 
		if(checksum != getChecksum(packet)) {
			// TODO Log the error
			sendNak();
			System.out.println("Got bad checksum: calculated " + getChecksum(packet) + ", read " + checksum);
			return null;
		}
 
		// Un-escape
		packet.replace("}"+('#'^0x20), "#");
		packet.replace("}"+('$'^0x20), "$");
		packet.replace("}"+('}'^0x20), "}");
 
		// Undo any run-length encoding.  This code is so ugly.
		if(packet.indexOf("*") != -1) {
			StringBuffer sb = new StringBuffer(packet);
			int thisIndex = 0;
			int lastIndex = 0;
 
			while(-1 != (thisIndex = sb.indexOf("*", lastIndex))) {
				int runlength = sb.charAt(thisIndex+1) - 28;
				sb.deleteCharAt(thisIndex+1);
				sb.deleteCharAt(thisIndex);
				char c = sb.charAt(thisIndex-1);
				for(int i = 0; i < runlength; i++) {
					sb.insert(thisIndex, c);
				}
				lastIndex = thisIndex;
			}
 
			packet = sb.toString();
		}
 
		return packet;
	}  // handleRSPPacket()
 
 
	public void sendAck() {
		netSys.sendData("+");
	}
 
	public void sendNak() {
		netSys.sendData("-");
	}
 
 
	private int getChecksum(String packet) {
		int csum = 0;
		for(int i = 0; i < packet.length(); i++) {
			csum += packet.charAt(i);
			//System.out.println("checksum adding char: " + packet.charAt(i) + ", checksum " + csum);
		}
		csum = csum & 0xFF;
		//System.out.println("Final checksum: " + csum);
		return csum;
	}
}