mrf::CFIFlash Class Reference

Handling for Common Flash Interfafce compliant chips. More...

#include <flash.h>

Classes
struct	ID

Public Member Functions
	CFIFlash (const SPIDevice &dev)
	~CFIFlash ()
void	readID (ID *id)
	execute command 0x9f JEDEC-ID read More...
bool	writable ()
epicsUInt32	alignement ()
epicsUInt32	blockSize ()
epicsUInt32	pageSize ()
epicsUInt32	sectorSize ()
void	read (epicsUInt32 start, epicsUInt32 count, epicsUInt8 *in)
void	read (epicsUInt32 start, std::vector< epicsUInt8 > &in)
void	write (epicsUInt32 start, epicsUInt32 count, const epicsUInt8 *out, bool strict=true)
void	write (epicsUInt32 start, const std::vector< epicsUInt8 > &out, bool strict=true)
void	erase (epicsUInt32 start, epicsUInt32 count, bool strict=true)

Detailed Description

Handling for Common Flash Interfafce compliant chips.

Definition at line 23 of file flash.h.

Constructor & Destructor Documentation

CFIFlash()

mrf::CFIFlash::CFIFlash ( const SPIDevice &  dev )

explicit

Definition at line 25 of file flash.cpp.

    :dev(dev)
    ,haveinfo(false)
{}

~CFIFlash()

mrf::CFIFlash::~CFIFlash

(

)

Definition at line 30 of file flash.cpp.

{}

Member Function Documentation

alignement()

epicsUInt32 mrf::CFIFlash::alignement ( )

inline

Definition at line 50 of file flash.h.

{ check(); return (info.pageSize-1)|(info.sectorSize-1); }

blockSize()

epicsUInt32 mrf::CFIFlash::blockSize ( )

inline

Definition at line 52 of file flash.h.

{ return alignement()+1u; }

erase()

void mrf::CFIFlash::erase	(	epicsUInt32	start,
		epicsUInt32	count,
		bool	strict = true
	)

Definition at line 274 of file flash.cpp.

{
    if((start&0xff000000) || (count&0xff000000) || ((start+count)&0xff000000))
        std::runtime_error("start/count exceeds 24-bit addressing");

    check();

    if(strict && info.capacity==0)
        throw std::runtime_error("Won't attempt to write when capacity isn't known");

    else if(start>=info.capacity || (start+count)>info.capacity)
        throw std::runtime_error("Can't write beyond capacity");

    if(info.pageSize==0 || info.sectorSize==0)
        throw std::runtime_error("Won't attempt to write to unsupported flash chip");

    {
        epicsUInt32 mask = (info.pageSize-1u) | (info.sectorSize-1u);
        if(start&mask)
            throw std::runtime_error("start address not aligned to page & sector sizes");

        if(strict && ((start+count)&mask))
            throw std::runtime_error("end address not aligned to page & sector sizes");
    }

    const epicsUInt32 end = start+count;

    const double timeout = dev.interface()->timeout();

    WriteEnabler WE(*this);

    // erase necessary sectors

    for(epicsUInt32 addr=start; addr<end; addr+=info.sectorSize)
    {
        busyWait(timeout);

        WE.enable();

        epicsUInt8 cmd[4];
        cmd[0] = 0xd8; // SECTOR ERASE
        cmd[1] = (addr>>16)&0xff;
        cmd[2] = (addr>> 8)&0xff;
        cmd[3] = (addr>> 0)&0xff;
        SPIInterface::Operation op = {4, cmd, NULL};

        {
            SPIDevice::Selector S(dev);
            dev.interface()->cycles(1, &op);
        }
    }
}

pageSize()

epicsUInt32 mrf::CFIFlash::pageSize ( )

inline

Definition at line 53 of file flash.h.

{ check(); return info.pageSize; }

read() [1/2]

void mrf::CFIFlash::read	(	epicsUInt32	start,
		epicsUInt32	count,
		epicsUInt8 *	in
	)

Definition at line 124 of file flash.cpp.

{
    if((start&0xff000000) || (count&0xff000000) || ((start+count)&0xff000000))
        std::runtime_error("start/count exceeds 24-bit addressing");

    check();

    epicsUInt8 cmd[5];

    // as we don't control clock speed, assume support for "fast" read
    // w/ dummy byte (wait state) after 24-bit address
    cmd[0] = 0x0b;
    cmd[1] = (start>>16)&0xff;
    cmd[2] = (start>> 8)&0xff;
    cmd[3] = (start>> 0)&0xff;
    cmd[4] = 0; // dummy

    SPIInterface::Operation ops[2];

    ops[0].ncycles = 5;
    ops[0].out = NULL;
    ops[0].in = cmd;

    ops[1].ncycles = count;
    ops[1].out = data;
    ops[1].in = NULL;

    {
        SPIDevice::Selector S(dev);
        dev.interface()->cycles(2, ops);
    }
}

read() [2/2]

void mrf::CFIFlash::read ( epicsUInt32  start, std::vector< epicsUInt8 > &  in  )

inline

Definition at line 57 of file flash.h.

    { read(start, in.size(), &in[0]); }

readID()

void mrf::CFIFlash::readID

(

ID *

id

)

execute command 0x9f JEDEC-ID read

Definition at line 33 of file flash.cpp.

{
    epicsUInt8 cmd[7] = {0x9f, 0u, 0u, 0u},
               response[7];
    SPIInterface::Operation ops[2] = {{4, cmd, response}};
    ops[0].ncycles = 4;
    ops[0].in = cmd;
    ops[0].out = response;

    {
        SPIDevice::Selector S(dev);
        dev.interface()->cycles(1, ops);
    }

    if(response[1]==0xff)
    {
        /* the first read after power up seems to fail.
         * Presumably some missing initializtion on my part.
         * A single re-try.
         */
        SPIDevice::Selector S(dev);
        dev.interface()->cycles(1, ops);
    }

    id->vendor = response[1];
    id->dev_type = response[2];
    id->dev_id = response[3];

    id->vendorName = "<Unknown>";
    id->capacity = id->sectorSize = id->pageSize = 0u;

    if(id->vendor==0x20) { // Micron
        /* Some Micron parts support the Serial Flash Discoverable Parameter (SFDP) spec.
         * using command 0x5a (see tech note TN-25-06).
         * However, so far there isn't anything so interesting.
         */
        id->vendorName = "Micron";

        switch(id->dev_type) {
        case 0x20: // m25p (Numonyx)
            id->capacity = 1u<<(id->dev_id);
            id->sectorSize = 256*1024u; // 2Mbit
            id->pageSize = 256;
            break;
        case 0xba: // mt25q
        case 0xbb:
            id->capacity = 1u<<(id->dev_id);
            id->sectorSize = 64*1024u;
            id->pageSize = 256;
            break;
        }

        /* Micron puts some extra info after the regular 0x9f payload,
         * including a serial number.
         * Byte 4 is the length of the additional payload
         */
        ops[0].ncycles = 5;

        {
            SPIDevice::Selector S(dev);
            dev.interface()->cycles(1, ops);
        }

        if(response[4]>2) {
            ops[0].ncycles = 7;

            id->SN.resize(response[4]-2);
            ops[1].ncycles = id->SN.size();
            ops[1].in = NULL;
            ops[1].out = &id->SN[0];

            SPIDevice::Selector S(dev);
            dev.interface()->cycles(2, ops);

            // if this byte isn't 0, then the spec isn't being followed
            if(response[6]!=0)
                id->SN.clear();

            if((response[5]&0x3)!=0) {
                // sector size not known
                id->sectorSize = 0;
            }
        }
    }

    // we only use 24-bit read/write/erase ops
    // so capacity beyond 16MB is not accessible.
    if(id->capacity>0x1000000)
        id->capacity = 0x1000000;
}

sectorSize()

epicsUInt32 mrf::CFIFlash::sectorSize ( )

inline

Definition at line 54 of file flash.h.

{ check(); return info.sectorSize; }

writable()

bool mrf::CFIFlash::writable ( )

inline

Definition at line 48 of file flash.h.

{ check(); return info.pageSize>0 && info.sectorSize>0; }

write() [1/2]

void mrf::CFIFlash::write	(	epicsUInt32	start,
		epicsUInt32	count,
		const epicsUInt8 *	out,
		bool	strict = true
	)

Definition at line 157 of file flash.cpp.

{
    if((start&0xff000000) || (count&0xff000000) || ((start+count)&0xff000000))
        std::runtime_error("start/count exceeds 24-bit addressing");

    check();

    if(strict && info.capacity==0)
        throw std::runtime_error("Won't attempt to write when capacity isn't known");

    else if(start>=info.capacity || (start+count)>info.capacity)
        throw std::runtime_error("Can't write beyond capacity");

    if(info.pageSize==0 || info.sectorSize==0)
        throw std::runtime_error("Won't attempt to write to unsupported flash chip");

    {
        epicsUInt32 mask = (info.pageSize-1u) | (info.sectorSize-1u);
        if(start&mask)
            throw std::runtime_error("start address not aligned to page & sector sizes");

        if(strict && ((start+count)&mask))
            throw std::runtime_error("end address not aligned to page & sector sizes");
    }

    const epicsUInt32 end = start+count;

    const double timeout = dev.interface()->timeout();

    {
        WriteEnabler WE(*this);

        // erase necessary sectors

        for(epicsUInt32 addr=start; addr<end; addr+=info.sectorSize)
        {
            busyWait(timeout);

            WE.enable();

            epicsUInt8 cmd[4];
            cmd[0] = 0xd8; // SECTOR ERASE
            cmd[1] = (addr>>16)&0xff;
            cmd[2] = (addr>> 8)&0xff;
            cmd[3] = (addr>> 0)&0xff;
            SPIInterface::Operation op = {4, cmd, NULL};

            {
                SPIDevice::Selector S(dev);
                dev.interface()->cycles(1, &op);
            }
        }

        // program all pages

        const epicsUInt8 *cur = data;
        for(epicsUInt32 addr=start; addr<end; addr+=info.pageSize, cur+=info.pageSize)
        {
            busyWait(timeout);

            WE.enable();

            const epicsUInt32 N = std::min(info.pageSize, end-addr);

            epicsUInt8 cmd[4];
            cmd[0] = 0x02; // PAGE PROGRAM
            cmd[1] = (addr>>16)&0xff;
            cmd[2] = (addr>> 8)&0xff;
            cmd[3] = (addr>> 0)&0xff;

            SPIInterface::Operation ops[2];
            ops[0].ncycles = 4;
            ops[0].in = cmd;
            ops[0].out = NULL;

            ops[1].ncycles = N;
            ops[1].in = cur;
            ops[1].out = NULL;

            {
                SPIDevice::Selector S(dev);
                dev.interface()->cycles(2, ops);
            }
        }

        busyWait(timeout);

        // end of write phase
    }

    // readback to verify by sector

    std::vector<epicsUInt8> scratch;

    const epicsUInt8 *cur = data;
    bool ok = true;
    for(epicsUInt32 addr=start; addr<end; addr+=info.sectorSize, cur+=info.sectorSize)
    {
        const epicsUInt32 N = std::min(info.sectorSize, end-addr);

        scratch.resize(N);

        read(addr, scratch);

        if(memcmp(cur, &scratch[0], N)!=0) {
            printf("FLASH readback mis-match in sector 0x%06x\n", (unsigned)addr);
            ok = false;
        }
    }

    if(!ok)
        throw std::runtime_error("FLASH readback error");
}

write() [2/2]

void mrf::CFIFlash::write ( epicsUInt32  start, const std::vector< epicsUInt8 > &  out, bool  strict = true  )

inline

Definition at line 61 of file flash.h.

    { write(start, out.size(), &out[0], strict); }

---

The documentation for this class was generated from the following files:

• flash.h
• flash.cpp