SysFlashOpMessage.hh

Go to the documentation of this file.

 
#ifndef LibMultiSense_SysFlashOpMessage
#define LibMultiSense_SysFlashOpMessage
 
#include <typeinfo>
 
#include "utility/Portability.hh"
 
namespace crl {
namespace multisense {
namespace details {
namespace wire {
 
class SysFlashOp {
public:
    static CRL_CONSTEXPR IdType      ID      = ID_CMD_SYS_FLASH_OP;
    static CRL_CONSTEXPR VersionType VERSION = 1;
 
    //
    // Maximum payload length per operation
 
    static CRL_CONSTEXPR uint32_t MAX_LENGTH = 1024;
 
    //
    // Parameters representing the desired flash operation
 
    static CRL_CONSTEXPR uint32_t OP_STATUS  = 0; // just check status
    static CRL_CONSTEXPR uint32_t OP_ERASE   = 1; // erase entire region
    static CRL_CONSTEXPR uint32_t OP_PROGRAM = 2; // program/verify chunk within region
    static CRL_CONSTEXPR uint32_t OP_VERIFY  = 3; // just verify chunk within region
 
    uint32_t operation;
 
    //
    // Parameters representing the desired flash region
 
    static CRL_CONSTEXPR uint32_t RGN_BITSTREAM   = 0; // FPGA configuration bitstream
    static CRL_CONSTEXPR uint32_t RGN_FIRMWARE    = 1; // Microblaze firmware
 
    uint32_t region;
 
    //
    // Remaining fields are only used for OP_PROGRAM and OP_VERIFY:
 
    uint32_t start_address;  // start address of chunk to program or verify
    uint32_t length;         // size of chunk to program or verify (power-of-2)
 
    uint8_t data[MAX_LENGTH];
 
    //
    // Constructors
 
    SysFlashOp(utility::BufferStreamReader&r, VersionType v) {serialize(r,v);};
    SysFlashOp(uint32_t op=OP_STATUS,
               uint32_t r=RGN_BITSTREAM,
               uint32_t s=0,
               uint32_t l=0) : operation(op),
                               region(r),
                               start_address(s),
                               length(l) {};
    //
    // Serialization routine
 
    template<class Archive>
        void serialize(Archive&          message,
                       const VersionType version)
    {
        (void) version;
        message & operation;
        message & region;
 
        switch(operation) {
            case OP_PROGRAM:
            case OP_VERIFY:
 
                message & start_address;
                message & length;
 
                if(length > MAX_LENGTH)
                    CRL_EXCEPTION("length (%u) exceeds MAX_LENGTH (%u)",
                                  length, MAX_LENGTH);
 
                if (typeid(Archive) == typeid(utility::BufferStreamWriter))
                    message.write(data, length);
                else
                    message.read(data, length);
 
                break;
            case OP_STATUS:
            case OP_ERASE:
                // start/length/data not required
                break;
            default:
                CRL_EXCEPTION("unknown operation (%d)", (int)operation);
        }
 
        switch(region) {
            case RGN_BITSTREAM:
            case RGN_FIRMWARE:
                break;
            default:
                CRL_EXCEPTION("unknown region (%d)", (int)region);
        }
    }
};
 
}}}} // namespaces
 
#endif