SysFlashOpMessage.h

Go to the documentation of this file.

#ifndef LibMultiSense_SysFlashOpMessage
#define LibMultiSense_SysFlashOpMessage

#include <typeinfo>

#include "details/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)
    {
        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