flashiocsh.cpp File Reference

#include <stdexcept>
#include <vector>
#include <fstream>
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <iocsh.h>
#include <epicsThread.h>
#include <epicsStdio.h>
#include "mrfCommon.h"
#include "mrf/spi.h"
#include "mrf/flash.h"
#include <epicsExport.h>

Include dependency graph for flashiocsh.cpp:

Go to the source code of this file.

Functions
void	flashinfo (const char *name)
void	flashread (const char *name, int addrraw, int countraw, const char *outfile)
void	flashwrite (const char *name, int addrraw, const char *infile)
void	flasherase (const char *name, int addrraw, int countraw)
	epicsExportRegistrar (registrarFlashOps)
	epicsExportAddress (int, flashAcknowledgeMismatch)

Variables
int	flashAcknowledgeMismatch

Function Documentation

epicsExportAddress()

epicsExportAddress	(	int	,
		flashAcknowledgeMismatch
	)

epicsExportRegistrar()

epicsExportRegistrar

(

registrarFlashOps

)

flasherase()

void flasherase	(	const char *	name,
		int	addrraw,
		int	countraw
	)

Definition at line 229 of file flashiocsh.cpp.

{
    try {
        mrf::SPIDevice dev;
        if(!mrf::SPIDevice::lookupDev(name, &dev)) {
            printf("No such device");
            return;
        }
        epicsUInt32 addr = addrraw, count = countraw;

        mrf::CFIFlash mem(dev);

        mem.erase(addr, count);

        printf("\nDone\n");

    }catch(std::exception& e){
        printf("Error: %s\n", e.what());
    }
}

flashinfo()

void flashinfo

(

const char *

name

)

Definition at line 36 of file flashiocsh.cpp.

{
    try {
        mrf::SPIDevice dev;
        if(!mrf::SPIDevice::lookupDev(name, &dev)) {
            printf("No such device");
            return;
        }

        mrf::CFIFlash mem(dev);

        mrf::CFIFlash::ID info;

        mem.readID(&info);

        printf("Vendor: %02x (%s)\nDevice: %02x\nID: %02x\n",
               info.vendor, info.vendorName, info.dev_type, info.dev_id);
        if(info.capacity)
            printf("Capacity: 0x%x\n", (unsigned)info.capacity);
        if(info.sectorSize)
            printf("Sector: 0x%x\n", (unsigned)info.sectorSize);
        if(info.pageSize)
            printf("Page: 0x%x\n", (unsigned)info.pageSize);
        if(!info.SN.empty()) {
            printf("S/N: ");
            for(size_t i=0; i<info.SN.size(); i++)
                printf(" %02x", unsigned(info.SN[i]));
            printf("\n");
        }

        if(!info.capacity || !info.sectorSize || !info.pageSize) {
            printf("Warning: Some information about this flash chip is not known.\n"
                   "         Please open an issue and include this output of flashinfo()\n"
                   "         and if known the flash chip vendor and part number.\n"
                   "         https://github.com/epics-modules/mrfioc2/issues\n");
        }

        {
            mrf::CFIStreamBuf sbuf(mem);
            std::istream strm(&sbuf);
            mrf::XilinxBitInfo image;
            if(image.read(strm)) {
                printf("Bit Stream found\n  Project: %s\n  Part: %s\n  Build: %s\n",
                       image.project.c_str(), image.part.c_str(), image.date.c_str());
            }
        }

    }catch(std::exception& e){
        printf("Error: %s\n", e.what());
    }
}

flashread()

void flashread	(	const char *	name,
		int	addrraw,
		int	countraw,
		const char *	outfile
	)

Definition at line 90 of file flashiocsh.cpp.

{
    try {
        mrf::SPIDevice dev;
        if(!mrf::SPIDevice::lookupDev(name, &dev)) {
            printf("No such device");
            return;
        }
        epicsUInt32 addr = addrraw, count = countraw;

        mrf::CFIFlash mem(dev);

        std::ostream *strm = &std::cout;
        std::ofstream fstrm;
        if(outfile) {
            fstrm.open(outfile, std::ios_base::out|std::ios_base::binary);
            if(fstrm.fail())
                throw std::runtime_error("Unable to open output file");
            strm = &fstrm;
        }

        while(count) {
            const epicsUInt32 N = std::min(count, mem.blockSize());
            std::vector<epicsUInt8> buf(N);

            mem.read(addr, buf);

            if(outfile) {
                (*strm).write((const char*)&buf[0], buf.size());

            } else {
                for(size_t i=0; i<buf.size(); i++) {
                    printf("%02x", int(buf[i]));
                    if(i%16==15)
                        printf("\n");
                    else if(i%4==3)
                        printf(" ");
                }
            }

            addr += N;
            count -= N;
            if(outfile)
                printf("| %u\n", unsigned(count));
        }

        printf("\nDone\n");

    }catch(std::exception& e){
        printf("Error: %s\n", e.what());
    }
}

flashwrite()

void flashwrite	(	const char *	name,
		int	addrraw,
		const char *	infile
	)

Definition at line 145 of file flashiocsh.cpp.

{
    if(!infile || infile[0]=='\0') {
        printf("Usage: flashwrite <name> <start_address> <filename>\n");
        return;
    }

    try {
        mrf::SPIDevice dev;
        if(!mrf::SPIDevice::lookupDev(name, &dev)) {
            printf("No such device");
            return;
        }
        epicsUInt32 addr = addrraw;

        mrf::CFIFlash mem(dev);
        if(!mem.writable()) {
            printf("Device not writable\n");
            return;
        }

        std::ifstream strm(infile, std::ios_base::in|std::ios_base::binary);
        if(strm.fail())
            throw std::runtime_error("Unable to open output file");

        strm.seekg(0, std::ios_base::end);
        const long fsize = strm.tellg();
        strm.seekg(0);

        if(flashAcknowledgeMismatch!=2) {
            mrf::XilinxBitInfo infile, inmem;

            infile.read(strm);
            strm.seekg(0);

            mrf::CFIStreamBuf sbuf(mem);
            std::istream mstrm(&sbuf);
            mstrm.seekg(addr);
            inmem.read(mstrm);

            bool match = true;
            match &= infile.project.empty() || infile.project==inmem.project;
            match &= infile.part.empty() || infile.part==inmem.part;
            if(!match) {
                fprintf(stderr, "Bitstream header mis-match.\nFile: \"%s\", \"%s\"\nROM: \"%s\", \"%s\"\n",
                        infile.part.c_str(), infile.project.c_str(),
                        inmem.part.c_str(), inmem.project.c_str());

                if(!flashAcknowledgeMismatch) {
                    fprintf(stderr, "To override, re-run after setting: var(\"flashAcknowledgeMismatch\", 1)\n");
                    return;
                }
            }
        }
        // user must re-ack for each operation
        flashAcknowledgeMismatch = 0;

        std::vector<epicsUInt8> buf;

        long pos=0;
        while(strm.good()) {
            printf("| %u/%u\n", (unsigned)pos, (unsigned)fsize);

            buf.resize(mem.blockSize());
            buf.resize(strm.read((char*)&buf[0], buf.size()).gcount());
            if(strm.bad())
                throw std::runtime_error("I/O Error");
            if(buf.empty())
                break;
            pos += buf.size();

            mem.write(addr, buf, false);
            addr += buf.size();
        }

        printf("\nDone\n");

    }catch(std::exception& e){
        printf("Error: %s\n", e.what());
    }
}

Variable Documentation

flashAcknowledgeMismatch

int flashAcknowledgeMismatch

Definition at line 32 of file flashiocsh.cpp.