Subversion Repositories s6soc

///////////////////////////////////////////////////////////////////////////
//
// Filename: 	wbscopc.v
//
// Project:	FPGA Library of Routines
//
// Purpose:	This scope is identical in function to the wishbone scope
//	found in wbscope, save that the output is compressed and that (as a
//	result) it can only handle recording 31 bits at a time.  This allows
//	the top bit to indicate an 'address difference'.   Okay, there's 
//	another difference as well: this version only works in a synchronous
//	fashion with the clock from the WB bus.  You cannot have a separate
//	bus and data clock.
//
//	Reading/decompressing the output of this scope works in this fashion:
//	Once the scope has stopped, read from the port.  Any time the high
//	order bit is set, the other 31 bits tell you how many times to repeat
//	the last value.  If the high order bit is not set, then the value
//	is a new data value.
//
//	I've provided this version of a compressed scope to OpenCores for
//	discussion purposes.  While wbscope.v works and works well by itself,
//	this compressed scope has a couple of fundamental flaw that I have
//	yet to fix.  One of them is that it is impossible to know when the
//	trigger took place.  The second problem is that it may be impossible
//	to know the state of the scope at the beginning of the buffer--should
//	the buffer begin with an address difference value instead of a data
//	value.
//
//	Ideally, the first item read out of the scope should be a data value,
//	even if the scope was skipping values to a new address at the time.
//	If it was in the middle of a skip, the next item out of the scope
//	should be the skip length.  This, though, violates the rule that there
//	are (1<<LGMEMLEN) items in the memory, and that the trigger took place
//	on the last item of memory ... so that portion of this compressed
//	scope is still to be defined.
//
//	Like I said, this version is placed here for discussion purposes,
//	not because it runs well nor because I have recognized that it has any
//	particular value (yet).
//
//	Well, I take that back.  When dealing with an interface such as the
//	PS/2 interface, or even the 16x2 LCD interface, it is often true
//	that things change _very_ slowly.  They could change so slowly that
//	the other approach to the scope doesn't work.  This then gives you
//	a working scope, by only capturing the changes.  You'll still need
//	to figure out (after the fact) when the trigge took place.  Perhaps
//	you'll wish to add the trigger as another data line, so you can find
//	when it took place in your own data?
//
//	Okay, I take that back twice: I'm finding this compressed scope very
//	valuable for evaluating the timing associated with a GPS PPS and
//	associated NMEA stream.  I need to collect over a seconds worth of
//	data, and I don't have enough memory to handle one memory value per
//	clock, yet I still want to know exactly when the GPS PPS goes high,
//	when it goes low, when I'm adjusting my clock, and when the clock's
//	PPS output goes high.  Did I synchronize them well?  Oh, and when does
//	the NMEA time string show up when compared with the PPS?  All of those
//	are valuable, but could never be done if the scope wasn't compressed.
//
// Creator:	Dan Gisselquist, Ph.D.
//		Gisselquist Technology, LLC
//
///////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015, Gisselquist Technology, LLC
//
// This program is free software (firmware): 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 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY 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 this program.  (It's in the $(ROOT)/doc directory, run make with no
// target there if the PDF file isn't present.)  If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
// License:	GPL, v3, as defined and found on www.gnu.org,
//		http://www.gnu.org/licenses/gpl.html
//
//
/////////////////////////////////////////////////////////////////////////////
//
//
module wbscopc(i_clk, i_ce, i_trigger, i_data,
	i_wb_clk, i_wb_cyc, i_wb_stb, i_wb_we, i_wb_addr, i_wb_data,
	o_wb_ack, o_wb_stall, o_wb_data,
	o_interrupt);
	parameter	LGMEM = 5'd10, NELM=31, BUSW = 32, SYNCHRONOUS=1;
	// The input signals that we wish to record
	input				i_clk, i_ce, i_trigger;
	input		[(NELM-1):0]	i_data;
	// The WISHBONE bus for reading and configuring this scope
	input				i_wb_clk, i_wb_cyc, i_wb_stb, i_wb_we;
	input				i_wb_addr; // One address line only
	input		[(BUSW-1):0]	i_wb_data;
	output	wire			o_wb_ack, o_wb_stall;
	output	wire	[(BUSW-1):0]	o_wb_data;
	// And, finally, for a final flair --- offer to interrupt the CPU after
	// our trigger has gone off.  This line is equivalent to the scope 
	// being stopped.  It is not maskable here.
	output	wire			o_interrupt;
 
 
	// Let's first see how far we can get by cheating.  We'll use the
	// wbscope program, and suffer a lack of several features
 
	// When is the full scope reset?  Capture that reset bit from any
	// write.
	wire	lcl_reset;
	assign	lcl_reset = (i_wb_cyc)&&(i_wb_stb)&&(~i_wb_addr)&&(i_wb_we)
				&&(~i_wb_data[31]);
 
	// A big part of this scope is the 'address' of any particular
	// data value.  As of this current version, the 'address' changed
	// in definition from an absolute time (which had all kinds of
	// problems) to a difference in time.  Hence, when the address line
	// is high on decompression, the 'address' field will record an
	// address difference.
	//
	// To implement this, we set our 'address' to zero any time the
	// data changes, but increment it on all other clocks.  Should the
	// address difference get to our maximum value, we let it saturate
	// rather than overflow.
	reg	[(BUSW-2):0]	ck_addr;
	reg	[(NELM-1):0]	lst_dat;
	initial	ck_addr = 0;
	always @(posedge i_clk)
		if ((lcl_reset)||((i_ce)&&(i_data != lst_dat)))
			ck_addr <= 0;
		else if (&ck_addr)
			;	// Saturated (non-overflowing) address diff
		else
			ck_addr <= ck_addr + 1;
 
	wire	[(BUSW-2):0]	w_data;
	generate
	if (NELM == BUSW-1)
		assign w_data = i_data;
	else
		assign w_data = { {(BUSW-NELM-1){1'b0}}, i_data };
	endgenerate
 
	//
	// To do our compression, we keep track of two registers: the most
	// recent data to the device (imm_ prefix) and the data from one
	// clock ago.  This allows us to suppress writes to the scope which
	// would otherwise be two address writes in a row.
	reg	imm_adr, lst_adr; // Is this an address (1'b1) or data value?
	reg	[(BUSW-2):0]	lst_val, // Data for the scope, delayed by one
				imm_val; // Data to write to the scope
	initial	lst_dat = 0;
	initial	lst_adr = 1'b1;
	initial	imm_adr = 1'b1;
	always @(posedge i_clk)
		if (lcl_reset)
		begin
			imm_val <= 31'h0;
			imm_adr <= 1'b1;
			lst_val <= 31'h0;
			lst_adr <= 1'b1;
			lst_dat <= 0;
		end else if ((i_ce)&&(i_data != lst_dat))
		begin
			imm_val <= w_data;
			imm_adr <= 1'b0;
			lst_val <= imm_val;
			lst_adr <= imm_adr;
			lst_dat <= i_data;
		end else begin
			imm_val <= ck_addr; // Minimum value here is '1'
			imm_adr <= 1'b1;
			lst_val <= imm_val;
			lst_adr <= imm_adr;
		end
 
	//
	// Here's where we suppress writing pairs of address words to the
	// scope at once.
	//
	reg			r_ce;
	reg	[(BUSW-1):0]	r_data;
	initial			r_ce = 1'b0;
	always @(posedge i_clk)
		r_ce <= (~lst_adr)||(~imm_adr);
	always @(posedge i_clk)
		r_data <= ((~lst_adr)||(~imm_adr))
			? { lst_adr, lst_val }
			: { {(32 - NELM){1'b0}}, i_data };
 
 
	//
	// The trigger needs some extra attention, in order to keep triggers
	// that happen between events from being ignored.  
	//
	wire	w_trigger;
	assign	w_trigger = (r_trigger)||(i_trigger);
 
	reg	r_trigger;
	initial	r_trigger = 1'b0;
	always @(posedge i_clk)
		if (lcl_reset)
			r_trigger <= 1'b0;
		else
			r_trigger <= w_trigger;
 
	//
	// Call the regular wishbone scope to do all of our real work, now
	// that we've compressed the input.
	//
	wbscope	#(.SYNCHRONOUS(1), .LGMEM(LGMEM),
		.BUSW(BUSW))	cheatersscope(i_clk, r_ce, w_trigger, r_data,
		i_wb_clk, i_wb_cyc, i_wb_stb, i_wb_we, i_wb_addr, i_wb_data,
		o_wb_ack, o_wb_stall, o_wb_data, o_interrupt);
endmodule