Subversion Repositories wbscope

////////////////////////////////////////////////////////////////////////////////

//

// Filename:    cfgscope.cpp

//

// Project:     WBScope, a wishbone hosted scope

//

// Purpose:     To read out, and decompose, the results of the wishbone scope

//              as applied to the ICAPE2 interaction.

//

//      This is provided together with the wbscope project as an example of

//      what might be done with the wishbone scope.  The intermediate details,

//      though, between this and the wishbone scope are not part of the

//      wishbone scope project.

//

//      Using this particular scope made it a *lot* easier to get the ICAPE2

//      interface up and running, since I was able to see what was going right

//      (or wrong) with the interface as I was developing it.  Sure, it

//      would've been better to get it to work under a simulator instead of

//      with the scope, but not being certain of how the interface was

//      supposed to work made building a simulator difficult.

//

// Creator:     Dan Gisselquist, Ph.D.

//              Gisselquist Technology, LLC

//

////////////////////////////////////////////////////////////////////////////////

//

// Copyright (C) 2015-2017, 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

//

//

////////////////////////////////////////////////////////////////////////////////

//

//

#include "devbus.h"

#include "scopecls.h"

//

// CFGSCOPE

//

// When you wish to build your own scope, you'll need to build a version of this

// class to do so.  This class has two particular functions to it: one

// (optional) one to define the traces used incase we wish to split these apart

// for output to a VCD file.  The other function is for use with debug-by-printf

// approaches.  As a result, it provides for a more flexible (textual) output.

//

class   CFGSCOPE : public SCOPE {

        virtual void    define_traces(void) {

                // Heres the interface for VCD files: We need to tell the VCD

                // writer the names of all of our traces, how many bits each

                // trace uses, and where the location of the value exists within

                // the 32-bit trace word.

                register_trace("cs_n",   1, 31);

                register_trace("we_n",   1, 30);

                register_trace("code",   6, 24);

                register_trace("value", 24,  0);

        }

        //

        // decode

        //

        // Decode the value to the standard-output stream.  How you decode this

        // value is up to you.  Prior to the value being printed, a prefix

        // identifying the clock number (as counted by the scope, with the

        // internal clock enable on), and the raw value will be printed out.

        // Further, after doing whatever printing you wish to do here, a newline

        // will be printed before going to the next value.

        //

        virtual void    decode(DEVBUS::BUSW v) const {

                // Now, let's decompose our 32-bit wires into something ...

                // meaningful and dump it to stdout.  This section will change

                // from project to project, scope to scope, depending on what

                // wires are placed into the scope.

                printf("%s %s ", (v&0x80000000)?"  ":"CS",

                                (v&0x40000000)?"RD":"WR");

                unsigned cw = (v>>24)&0x03f;

                switch(cw) {

                        case    0x20: printf("DUMMY"); break;

                        case    0x10: printf("NOOP "); break;

                        case    0x08: printf("SYNC "); break;

                        case    0x04: printf("CMD  "); break;

                        case    0x02: printf("IPROG"); break;

                        case    0x01: printf("DSYNC"); break;

                        default:      printf("OTHER"); break;

                }

                printf(" -> %02x", v & 0x0ffffff);

        }

};

int main(int argc, char **argv) {

        // The DEVBUS structure encapsulates wishbone accesses, so that this

        // code can access the wishbone bus on the FPGA.

        DEVBUS  *m_fpga;

        // Open up a port to talk to the FPGA ...

        //

        // This may be unique to your FPGA, so feel free to adjust these lines

        // for your setup.  The result, though, must be a DEVBUS structure

        // giving you access to the FPGA.

#ifndef FORCE_UART

        m_fpga = new FPGA(new NETCOMMS("lazarus",PORT));

#else

        m_fpga = new FPGA(new TTYCOMMS("/dev/ttyUSB2"));

#endif

        // 

        CFGSCOPE *scope = new CFGSCOPE(m_fpga, WBSCOPE);

        // Check to see whether or not the scope has captured the data we need

        // yet or not.

        if (scope->ready()) {

                // If the data has been captured, we call print().  This

                // function will print all our values to the standard output,

                // and it will call the decode() function above to do it.

                scope->print();

                // You can also write the results to a VCD trace file.  To do

                // this, just call writevcd and pass it the name you wish your

                // VCD file to have.

                scope->writevcd("cfgtrace.vcd");

        } else {

                // If the scope isnt yet ready, print a message, decode its

                // current state, and exit kindly.

                printf("Scope is not (yet) ready:\n");

                scope->decode_control();

        }

        // Clean up our interface, now, and we're done.

        delete  m_fpga;

}