Subversion Repositories wbscope

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

//

// Filename:    scopecls.cpp

//

// Project:     WBScope, a wishbone hosted scope

//

// Purpose:     After rebuilding the same code over and over again for every

//              "scope" I tried to interact with, I thought it would be simpler

//      to try to make a more generic interface, that other things could plug

//      into.  This is that more generic interface.

//

// 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 <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <strings.h>

#include <ctype.h>

#include <string.h>

#include <signal.h>

#include <assert.h>

#include <time.h>

#include "devbus.h"

#include "scopecls.h"

bool    SCOPE::ready() {

        unsigned v;

        v = m_fpga->readio(m_addr);

        if (m_scoplen == 0) {

                m_scoplen = (1<<((v>>20)&0x01f));

                m_holdoff = (v & ((1<<20)-1));

        } v = (v>>28)&6;

        return (v==6);

}

void    SCOPE::decode_control(void) {

        unsigned        v;

        v = m_fpga->readio(m_addr);

        printf("\tCNTRL-REG:\t0x%08x\n", v);

        printf("\t31. RESET:\t%s\n", (v&0x80000000)?"Ongoing":"Complete");

        printf("\t30. STOPPED:\t%s\n", (v&0x40000000)?"Yes":"No");

        printf("\t29. TRIGGERED:\t%s\n", (v&0x20000000)?"Yes":"No");

        printf("\t28. PRIMED:\t%s\n", (v&0x10000000)?"Yes":"No");

        printf("\t27. MANUAL:\t%s\n", (v&0x08000000)?"Yes":"No");

        printf("\t26. DISABLED:\t%s\n", (v&0x04000000)?"Yes":"No");

        printf("\t25. ZERO:\t%s\n", (v&0x02000000)?"Yes":"No");

        printf("\tSCOPLEN:\t%08x (%d)\n", m_scoplen, m_scoplen);

        printf("\tHOLDOFF:\t%08x\n", (v&0x0fffff));

        printf("\tTRIGLOC:\t%d\n", m_scoplen-(v&0x0fffff));

}

int     SCOPE::scoplen(void) {

        unsigned        v, lgln;

        // If the scope length is zero, then the scope isn't present.

        // We use a length of zero here to also represent whether or not we've

        // looked up the length by reading from the scope.

        if (m_scoplen == 0) {

                v = m_fpga->readio(m_addr);

                m_holdoff = (v & ((1<<20)-1));

                // Since the length of the scope memory is a configuration

                // parameter internal to the scope, we read it here to find

                // out how the scope was configured.

                lgln = (v>>20) & 0x1f;

                // If the length is still zero, then there is no scope installed

                if (lgln != 0) {

                        // Otherwise, the scope length contained in the device

                        // control register is the log base 2 of the actual

                        // length of what's in the FPGA.  Here, we just convert

                        // that to the actual length of the scope.

                        m_scoplen = (1<<lgln);

                }

        // else we already know the length of the scope, and don't need to

        // slow down to read that length from the device a second time.

        } return m_scoplen;

}

//

// rawread

//

// Read the scope data from the scope.

void    SCOPE::rawread(void) {

        // If we've already read the data from the scope, then we don't need

        // to read it a second time.

        if (m_data)

                return;

        // Let's get the length of the scope, and check that it is a valid

        // length

        if (scoplen() <= 4) {

                printf("ERR: Scope has less than a minimum length.  Is it truly a scope?\n");

                return;

        }

        // Now that we know the size of the scopes buffer, let's allocate a

        // buffer to hold all this data

        m_data = new DEVBUS::BUSW[m_scoplen];

        // There are two means of reading from a DEVBUS interface: The first

        // is a vector read, optimized so that the address and read command

        // only needs to be sent once.  This is the optimal means.  However,

        // if the bus isn't (yet) trustworthy, it may be more reliable to access

        // the port by reading one register at a time--hence the second method.

        // If the bus works, you'll want to use readz(): read scoplen values

        // into the buffer, from the address WBSCOPEDATA, without incrementing

        // the address each time (hence the 'z' in readz--for zero increment).

        if (m_vector_read) {

                m_fpga->readz(m_addr+4, m_scoplen, m_data);

        } else {

                for(unsigned int i=0; i<m_scoplen; i++)

                        m_data[i] = m_fpga->readio(m_addr+4);

        }

}

void    SCOPE::print(void) {

        unsigned long addrv = 0, alen;

        int     offset;

        rawread();

        // Count how many values are in our (possibly compressed) buffer.

        // If it weren't for the compression, this'd be m_scoplen

        alen = getaddresslen();

        // If the holdoff is zero, the triggered item is the very

        // last one.

        offset = alen - m_holdoff -1;

        if(m_compressed) {

                for(int i=0; i<(int)m_scoplen; i++) {

                        if ((m_data[i]>>31)&1) {

                                addrv += (m_data[i]&0x7fffffff) + 1;

                                printf(" ** (+0x%08x = %8d)\n",

                                        (m_data[i]&0x07fffffff),

                                        (m_data[i]&0x07fffffff));

                                continue;

                        }

                        printf("%10ld %08x: ", addrv++, m_data[i]);

                        decode(m_data[i]);

                        if ((int)addrv == offset)

                                printf(" <--- TRIGGER");

                        printf("\n");

                }

        } else {

                for(int i=0; i<(int)m_scoplen; i++) {

                        if ((i>0)&&(m_data[i] == m_data[i-1])&&(i<(int)(m_scoplen-1))) {

                                if ((i>2)&&(m_data[i] != m_data[i-2]))

                                        printf(" **** ****\n");

                                continue;

                        } printf("%9d %08x: ", i, m_data[i]);

                        decode(m_data[i]);

                        if (i == offset)

                                printf(" <--- TRIGGER");

                        printf("\n");

                }

        }

}

void    SCOPE::write_trace_timescale(FILE *fp) {

        fprintf(fp, "$timescale 1ns $end\n\n");

}

void    SCOPE::write_trace_timezero(FILE *fp, int offset) {

        double          dwhen;

        long            when_ns;

        dwhen = 1.0/((double)m_clkfreq_hz) * (offset);

        when_ns = (unsigned long)(dwhen * 1e9);

        fprintf(fp, "$timezero %ld $end\n\n", -when_ns);

}

// $dumpoff and $dumpon

void    SCOPE::write_trace_header(FILE *fp, int offset) {

        time_t  now;

        time(&now);

        fprintf(fp, "$version Generated by WBScope $end\n");

        fprintf(fp, "$date %s\n $end\n", ctime(&now));

        write_trace_timescale(fp);

        if (offset != 0)

                write_trace_timezero(fp, offset);

        fprintf(fp, " $scope module WBSCOPE $end\n");

        // Print out all of the various values

        if (m_compressed) {

                fprintf(fp, "  $var wire %2d \'R _raw_data [%d:0] $end\n", 31,

                        30);

        } else {

                fprintf(fp, "  $var wire %2d \'C clk $end\n", 1);

                fprintf(fp, "  $var wire %2d \'R _raw_data [%d:0] $end\n", 32,

                        31);

        }

        // Add in a fake _trigger variable to the VCD file we are producing,

        // so we can see when our trigger took place (assuming the holdoff is

        // such that it is within the collect)

        fprintf(fp, "  $var wire %2d \'T _trigger $end\n", 1);

        for(unsigned i=0; i<m_traces.size(); i++) {

                TRACEINFO *info = m_traces[i];

                fprintf(fp, "  $var wire %2d %s %s",

                        info->m_nbits, info->m_key, info->m_name);

                if ((info->m_nbits > 0)&&(NULL == strchr(info->m_name, '[')))

                        fprintf(fp, "[%d:0] $end\n", info->m_nbits-1);

                else

                        fprintf(fp, " $end\n");

        }

        fprintf(fp, " $upscope $end\n");

        fprintf(fp, "$enddefinitions $end\n");

}

void    SCOPE::write_binary_trace(FILE *fp, const int nbits, unsigned val,

                const char *str) {

        if (nbits <= 1) {

                fprintf(fp, "%d%s\n", val&1, str);

                return;

        }

        if ((unsigned)nbits < sizeof(val)*8)

                val &= ~(-1<<nbits);

        fputs("b", fp);

        for(int i=0; i<nbits; i++)

                fprintf(fp, "%d", (val>>(nbits-1-i))&1);

        fprintf(fp, " %s\n", str);

}

void    SCOPE::write_binary_trace(FILE *fp, TRACEINFO *info, unsigned value) {

        write_binary_trace(fp, info->m_nbits, (value>>info->m_nshift),

                info->m_key);

}

void    SCOPE::register_trace(const char *name,

                unsigned nbits, unsigned shift) {

        TRACEINFO       *info = new TRACEINFO;

        int     nkey = m_traces.size();

        info->m_name   = name;

        info->m_nbits  = nbits;

        info->m_nshift = shift;

        info->m_key[0] = 'v';

        if (nkey < 26)

                info->m_key[1] = 'a'+nkey;

        else if (nkey < 26+26)

                info->m_key[1] = 'A'+nkey-26;

        else // if (nkey < 26+26+10)    // Should never happen

                info->m_key[1] = '0'+nkey-26-26;

        info->m_key[2] = '\0';

        info->m_key[3] = '\0';

        m_traces.push_back(info);

}

/*

 * getaddresslen(void)

 *

 * Returns the number of items in the scope's buffer.  For the uncompressed

 * scope, this is just the size of hte scope.  For the compressed scope ... this

 * is a touch longer.

 */

unsigned        SCOPE::getaddresslen(void) {

        // Find the offset to the trigger

        if (m_compressed) {

                // First, find the overall length

                //

                // If we are compressed, then *every* item increments

                // the address length

                unsigned alen = m_scoplen;

                //

                // Some items increment it more.

                for(int i=0; i<(int)m_scoplen; i++) {

                        if ((m_data[i]&0x80000000)&&(i!=0))

                                alen += m_data[i] & 0x7fffffff;

                }

                return alen;

        } return m_scoplen;

}

/*

 * define_traces

 *

 * This is a user stub.  User programs should define this function.

 */

void    SCOPE::define_traces(void) {}

void    SCOPE::writevcd(FILE *fp) {

        unsigned        alen;

        int     offset = 0;

        if (!m_data)

                rawread();

        // If the traces haven't yet been defined, then define them now.

        if (m_traces.size()==0)

                define_traces();

        // Count how many values are in our (possibly compressed) buffer.

        // If it weren't for the compression, this'd be m_scoplen

        alen = getaddresslen();

        // If the holdoff is zero, the triggered item is the very

        // last one.

        offset = alen - m_holdoff -1;

        // Write the file header.

        write_trace_header(fp, offset);

        // And split into two paths--one for compressed scopes (wbscopc), and

        // the other for the more normal scopes (wbscope).

        if(m_compressed) {

                // With compressed scopes, you need to track the address

                // relative to the beginning.

                unsigned long   addrv = 0;

                unsigned long   now_ns;

                double          dnow;

                bool            last_trigger = true;

                // Loop over each data word read from the scope

                for(int i=0; i<(int)m_scoplen; i++) {

                        // If the high bit is set, the address jumps by more

                        // than an increment

                        if ((m_data[i]>>31)&1) {

                                if (i!=0) {

                                        if (last_trigger) {

                                                // If the trigger was valid

                                                // on the last clock, then we

                                                // need to include the change

                                                // to drop it.

                                                //

                                                dnow   = 1.0/((double)m_clkfreq_hz) * (addrv+1);

                                                now_ns = (unsigned long)(dnow * 1e9);

                                                fprintf(fp, "#%ld\n", now_ns);

                                                fprintf(fp, "0\'T\n");

                                        }

                                        // But ... with nothing to write out.

                                        addrv += (m_data[i]&0x7fffffff) + 1;

                                } continue;

                        }

                        // Produce a line identifying the time associated with

                        // this piece of data.

                        //

                        // dnow is the current time represented as a double

                        dnow = 1.0/((double)m_clkfreq_hz) * addrv;

                        // Convert to nanoseconds, and to integers.

                        now_ns = (unsigned long)(dnow * 1e9);

                        fprintf(fp, "#%ld\n", now_ns);

                        if ((int)(addrv-alen) == offset) {

                                fprintf(fp, "1\'T\n");

                                last_trigger = true;

                        } else if (last_trigger)

                                fprintf(fp, "0\'T\n");

                        // For compressed data, only the lower 31 bits are

                        // valid.  Write those bits to the VCD file as a raw

                        // value.

                        write_binary_trace(fp, 31, m_data[i], "\'R\n");

                        // Finally, walk through all of the user defined traces,

                        // writing each to the VCD file.

                        for(unsigned k=0; k<m_traces.size(); k++) {

                                TRACEINFO *info = m_traces[k];

                                write_binary_trace(fp, info, m_data[i]);

                        }

                        addrv++;

                }

        } else {

                //

                // Uncompressed scope.

                //

                unsigned now_ns;

                double  dnow;

                // We assume a clock signal, and set it to one and zero.

                // We also assume everything changes on the positive edge of

                // that clock within here.

                // Loop over all data words

                for(int i=0; i<(int)m_scoplen; i++) {

                        // Positive edge of the clock (everything is assumed to

                        // be on the positive edge)

                        //

                        // Clock goes high

                        //

                        // Write the current (relative) time of this data word

                        dnow = 1.0/((double)m_clkfreq_hz) * i;

                        now_ns = (unsigned)(dnow * 1e9 + 0.5);

                        fprintf(fp, "#%d\n", now_ns);

                        fprintf(fp, "1\'C\n");

                        write_binary_trace(fp, (m_compressed)?31:32,

                                m_data[i], "\'R\n");

                        if (i == offset)

                                fprintf(fp, "1\'T\n");

                        else // if (addrv == offset+1)

                                fprintf(fp, "0\'T\n");

                        for(unsigned k=0; k<m_traces.size(); k++) {

                                TRACEINFO *info = m_traces[k];

                                write_binary_trace(fp, info, m_data[i]);

                        }

                        //

                        // Clock goes to zero

                        //

                        // Add half a clock period to our time

                        dnow += 1.0/((double)m_clkfreq_hz)/2.;

                        now_ns = (unsigned)(dnow * 1e9 + 0.5);

                        fprintf(fp, "#%d\n", now_ns);

                        // Now finally write the clock as zero.

                        fprintf(fp, "0\'C\n");

                }

        }

}

/*

 * writevcd

 *

 * Main user entry point for VCD file creation.  This just opens a file of the

 * given name, and writes the VCD info to it.  If the file cannot be opened,

 * an error is written to the standard error stream, and the routine returns.

 */

void    SCOPE::writevcd(const char *trace_file_name) {

        FILE    *fp = fopen(trace_file_name, "w");

        if (fp == NULL) {

                fprintf(stderr, "ERR: Cannot open %s for writing!\n", trace_file_name);

                fprintf(stderr, "ERR: Trace file not written\n");

                return;

        }

        writevcd(fp);

        fclose(fp);

}