Subversion Repositories xulalx25soc

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

//

// Filename:    dumpsdram.cpp

//

// Project:     XuLA2 board

//

// Purpose:     Read local memory, dump into a file.

//

//

// Creator:     Dan Gisselquist, Ph.D.

//              Gisselquist Technology, LLC

//

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

//

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

//

// 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 "llcomms.h"

#include "usbi.h"

#include "port.h"

#include "regdefs.h"

FPGA    *m_fpga;

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

        FILE            *fp, *fpin;

        unsigned        pos=0;

        int             port = FPGAPORT, skp;

        const int       BUFLN = 127;

        FPGA::BUSW      *buf = new FPGA::BUSW[BUFLN],

                        *cmp = new FPGA::BUSW[BUFLN];

        bool            use_usb = true;

        skp = 1;

        for(int argn=0; argn<argc-skp; argn++) {

                if (argv[argn+skp][0] == '-') {

                        if (argv[argn+skp][1] == 'u')

                                use_usb = true;

                        else if (argv[argn+skp][1] == 'p') {

                                use_usb = false;

                                if (isdigit(argv[argn+skp][2]))

                                        port = atoi(&argv[argn+skp][2]);

                        } skp++; argn--;

                } else

                        argv[argn] = argv[argn+skp];

        } argc -= skp;

        if (argc!=2) {

                printf("Usage: dumpsdram [-p [port]] srcfile outfile\n");

                exit(-1);

        }

        /*

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

                printf("ARG[%d] = %s\n", i, argv[i]);

        } */

        fpin = fopen(argv[0], "rb");

        if (fpin == NULL) {

                fprintf(stderr, "Could not open %s\n", argv[1]);

                exit(-1);

        }

        if (use_usb)

                m_fpga = new FPGA(new USBI());

        else

                m_fpga = new FPGA(new NETCOMMS(FPGAHOST, port));

        // Read our file and copy it into memory

        try {

                int     nr;

                pos = SDRAMBASE;

                do {

                        nr = BUFLN;

                        if (nr + pos > SDRAMBASE*2)

                                nr = SDRAMBASE*2 - pos;

                        nr = fread(buf, sizeof(FPGA::BUSW), nr, fpin);

                        if (nr <= 0)

                                break;

                        if (false) {

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

                                        m_fpga->writeio(pos+i, buf[i]);

                        } else

                                m_fpga->writei(pos, nr, buf);

                        pos += nr;

                } while((nr > 0)&&(pos < 2*SDRAMBASE));

                printf("SUCCESS::fully wrote full file to memory (pos = %08x)\n", pos);

        } catch(BUSERR a) {

                fprintf(stderr, "BUS Err while writing at address 0x%08x\n", a.addr);

                fprintf(stderr, "... is your program too long for this memory?\n");

                exit(-2);

        } catch(...) {

                fprintf(stderr, "Other error\n");

                exit(-3);

        }

        rewind(fpin);

        fp = fopen(argv[1], "wb");

        if (fp == NULL) {

                fprintf(stderr, "Could not open: %s\n", argv[2]);

                exit(-1);

        }

        unsigned        mmaddr[65536], mmval[65536], mmidx = 0;

        // Read it back from memory

        try {

                pos = SDRAMBASE;

                const unsigned int MAXRAM = SDRAMBASE*2;

                bool    mismatch = false;

                unsigned        total_reread = 0;

                do {

                        int nw, nr;

                        if (MAXRAM-pos > BUFLN)

                                nr = BUFLN;

                        else

                                nr = MAXRAM-pos;

                        if (false) {

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

                                        buf[i] = m_fpga->readio(pos+i);

                        } else

                                m_fpga->readi(pos, nr, buf);

                        pos += nr;

                        nw = fwrite(buf, sizeof(FPGA::BUSW), nr, fp);

                        if (nw < nr) {

                                printf("Only wrote %d of %d words!\n", nw, nr);

                                exit(-2);

                        } // printf("nr = %d, pos = %08x (%08x / %08x)\n", nr,

                        //      pos, SDRAMBASE, MAXRAM);

                        {int cr;

                        cr = fread(cmp, sizeof(FPGA::BUSW), nr, fpin);

                        total_reread += cr;

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

                                if (cmp[i] != buf[i]) {

                                        printf("MISMATCH: MEM[%08x] = %08x(read) != %08x(expected)\n",

                                                pos-nr+i, buf[i], cmp[i]);

                                        mmaddr[mmidx] = pos-nr+i;

                                        mmval[mmidx] = cmp[i];

                                        if (mmidx < 65536)

                                                mmidx++;

                                        mismatch = true;

                                }

                        if (cr != nr) {

                                printf("Only read %d words from our input file\n", total_reread);

                                break;

                        }

                        }

                } while(pos < MAXRAM);

                if (mismatch)

                        printf("Read %04x (%6d) words from memory.  These did not match the source file.  (Failed test)\n",

                                pos-SDRAMBASE, pos-SDRAMBASE);

                else

                        printf("Successfully  read&copied %04x (%6d) words from memory\n",

                                pos-SDRAMBASE, pos-SDRAMBASE);

        } catch(BUSERR a) {

                fprintf(stderr, "BUS Err at address 0x%08x\n", a.addr);

                fprintf(stderr, "... is your program too long for this memory?\n");

                exit(-2);

        } catch(...) {

                fprintf(stderr, "Other error\n");

                exit(-3);

        }

        for(unsigned i=0; i<mmidx; i++) {

                unsigned bv = m_fpga->readio(mmaddr[i]);

                if (bv == mmval[i])

                        printf("Re-match, MEM[%08x]\n", mmaddr[i]);

                else

                        printf("2ndary Fail: MEM[%08x] = %08x(read) != %08x(expected)\n",

                                mmaddr[i], bv, mmval[i]);

        }

        delete  m_fpga;

}