Command.h

/*
 * Copyright (c) 2013-2015, Freescale Semiconductor, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * o Redistributions of source code must retain the above copyright notice, this list
 *   of conditions and the following disclaimer.
 *
 * o Redistributions in binary form must reproduce the above copyright notice, this
 *   list of conditions and the following disclaimer in the documentation and/or
 *   other materials provided with the distribution.
 *
 * o Neither the name of Freescale Semiconductor, Inc. nor the names of its
 *   contributors may be used to endorse or promote products derived from this
 *   software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _Command_h_
#define _Command_h_

#include <array>
#include <assert.h>
#include "DataSource.h"
#include "Packetizer.h"
#include "host_types.h"
#include "format_string.h"
#include "property/property.h"
#include "SourceFile.h"
#include "BusPal.h"


using namespace std;

namespace blfwk
{

struct cmd_t
{
    uint8_t tag;
    uint32_t mask;
    const char *const name;

    cmd_t(uint8_t tag, uint32_t mask, const char *name)
        : tag(tag)
        , mask(mask)
        , name(name)
    {
    }
};

const cmd_t kCommand_FlashEraseAll(kCommandTag_FlashEraseAll, 0x00000001, "flash-erase-all");
const cmd_t kCommand_FlashEraseRegion(kCommandTag_FlashEraseRegion, 0x00000002, "flash-erase-region");
const cmd_t kCommand_ReadMemory(kCommandTag_ReadMemory, 0x00000004, "read-memory");
const cmd_t kCommand_WriteMemory(kCommandTag_WriteMemory, 0x00000008, "write-memory");
const cmd_t kCommand_FillMemory(kCommandTag_FillMemory, 0x00000010, "fill-memory");
const cmd_t kCommand_FlashSecurityDisable(kCommandTag_FlashSecurityDisable, 0x00000020, "flash-security-disable");
const cmd_t kCommand_GetProperty(kCommandTag_GetProperty, 0x00000040, "get-property");
const cmd_t kCommand_ReceiveSbFile(kCommandTag_ReceiveSbFile, 0x00000080, "receive-sb-file");
const cmd_t kCommand_Execute(kCommandTag_Execute, 0x00000100, "execute");
const cmd_t kCommand_Call(kCommandTag_Call, 0x00000200, "call");
const cmd_t kCommand_Reset(kCommandTag_Reset, 0x00000400, "reset");
const cmd_t kCommand_SetProperty(kCommandTag_SetProperty, 0x00000800, "set-property");
const cmd_t kCommand_FlashEraseAllUnsecure(kCommandTag_FlashEraseAllUnsecure, 0x00001000, "flash-erase-all-unsecure");
const cmd_t kCommand_FlashProgramOnce(kCommandTag_FlashProgramOnce, 0x00002000, "flash-program-once");
const cmd_t kCommand_FlashReadOnce(kCommandTag_FlashReadOnce, 0x00004000, "flash-read-once");
const cmd_t kCommand_FlashReadResource(kCommandTag_FlashReadResource, 0x00008000, "flash-read-resource");
const cmd_t kCommand_ConfigureQuadSpi(kCommandTag_ConfigureQuadSpi, 0x00010000, "configure-quadspi");
const cmd_t kCommand_ReliableUpdate(kCommandTag_ReliableUpdate, 0x00100000, "reliable-update");
// flash-image is not a ROM basic command, but a combination of several basic commands.
const cmd_t kCommand_FlashImage(0x00, 0x00000000, "flash-image");
const cmd_t kCommand_ConfigureI2c(kCommandTag_ConfigureI2c, 0x00020000, "i2c");
const cmd_t kCommand_ConfigureSpi(kCommandTag_ConfigureSpi, 0x00040000, "spi");
const cmd_t kCommand_ConfigureCan(kCommandTag_ConfigureCan, 0x00080000, "can");

const array<const cmd_t, 22> kCommands = { kCommand_FlashEraseAll,
                                           kCommand_FlashEraseRegion,
                                           kCommand_ReadMemory,
                                           kCommand_WriteMemory,
                                           kCommand_FillMemory,
                                           kCommand_FlashSecurityDisable,
                                           kCommand_GetProperty,
                                           kCommand_ReceiveSbFile,
                                           kCommand_Execute,
                                           kCommand_Call,
                                           kCommand_Reset,
                                           kCommand_SetProperty,
                                           kCommand_FlashEraseAllUnsecure,
                                           kCommand_FlashProgramOnce,
                                           kCommand_FlashReadOnce,
                                           kCommand_FlashReadResource,
                                           kCommand_ConfigureQuadSpi,
                                           kCommand_ReliableUpdate,
                                           kCommand_FlashImage,
                                           kCommand_ConfigureI2c,
                                           kCommand_ConfigureSpi,
                                           kCommand_ConfigureCan };


struct property_t
{
    uint32_t value;
    const char *description;

    property_t(uint8_t value, const char *description)
        : value(value)
        , description(description)
    {
    }

    string str() const { return format_string("0x%02x", value); }
};
const property_t kProperty_ListProperties(kPropertyTag_ListProperties, "list-properties");
const property_t kProperty_CurrentVersion(kPropertyTag_BootloaderVersion, "current-version");
const property_t kProperty_AvailablePeripherals(kPropertyTag_AvailablePeripherals, "available-peripherals");
const property_t kProperty_FlashStartAddress(kPropertyTag_FlashStartAddress, "flash-start-address");
const property_t kProperty_FlashSizeInBytes(kPropertyTag_FlashSizeInBytes, "flash-size-in-bytes");
const property_t kProperty_FlashSectorSize(kPropertyTag_FlashSectorSize, "flash-sector-size");
const property_t kProperty_FlashBlockCount(kPropertyTag_FlashBlockCount, "flash-block-count");
const property_t kProperty_AvailableCommands(kPropertyTag_AvailableCommands, "available-commands");
const property_t kProperty_CrcCheckStatus(kPropertyTag_CrcCheckStatus, "crc-check-status");
const property_t kProperty_Reserved9(kPropertyTag_Reserved9, "reserved");
const property_t kProperty_VerifyWrites(kPropertyTag_VerifyWrites, "verify-writes");
const property_t kProperty_MaxPacketSize(kPropertyTag_MaxPacketSize, "max-packet-size");
const property_t kProperty_ReservedRegions(kPropertyTag_ReservedRegions, "reserved-regions");
const property_t kProperty_Reserved13(kPropertyTag_Reserved13, "reserved");
const property_t kProperty_RAMStartAddress(kPropertyTag_RAMStartAddress, "ram-start-address");
const property_t kProperty_RAMSizeInBytes(kPropertyTag_RAMSizeInBytes, "ram-size-in-bytes");
const property_t kProperty_SystemDeviceId(kPropertyTag_SystemDeviceId, "system-device-id");
const property_t kProperty_FlashSecurityState(kPropertyTag_FlashSecurityState, "flash-security-state");
const property_t kProperty_UniqueDeviceId(kPropertyTag_UniqueDeviceId, "unique-device-id");
const property_t kProperty_FacSupport(kPropertyTag_FacSupport, "flash-fac-support");
const property_t kProperty_FlashAccessSegmentSize(kPropertyTag_FlashAccessSegmentSize, "flash-access-segment-size");
const property_t kProperty_FlashAccessSegmentCount(kPropertyTag_FlashAccessSegmentCount, "flash-access-segment-count");
const property_t kProperty_FlashReadMargin(kPropertyTag_FlashReadMargin, "flash-read-margin");
const property_t kProperty_QspiInitStatus(kPropertyTag_QspiInitStatus, "qspi/otfad-init-status");
const property_t kProperty_TargetVersion(kPropertyTag_TargetVersion, "target-version");
const property_t kProperty_ExernalMemoryAttributes(kPropertyTag_ExternalMemoryAttributes, "external-memory-attributes");
const property_t kProperty_ReliableUpdateStatus(kPropertyTag_ReliableUpdateStatus, "reliable-update-status");
const property_t kProperty_Invalid(kPropertyTag_InvalidProperty, "invalid-property");

typedef array<const property_t, 27> PropertyArray;

const PropertyArray kProperties = {
    kProperty_ListProperties,         kProperty_CurrentVersion,
    kProperty_AvailablePeripherals,   kProperty_FlashStartAddress,
    kProperty_FlashSizeInBytes,       kProperty_FlashSectorSize,
    kProperty_FlashBlockCount,        kProperty_AvailableCommands,
    kProperty_CrcCheckStatus,         kProperty_Reserved9,
    kProperty_VerifyWrites,           kProperty_MaxPacketSize,
    kProperty_ReservedRegions,        kProperty_Reserved13,
    kProperty_RAMStartAddress,        kProperty_RAMSizeInBytes,
    kProperty_SystemDeviceId,         kProperty_FlashSecurityState,
    kProperty_UniqueDeviceId,         kProperty_FacSupport,
    kProperty_FlashAccessSegmentSize, kProperty_FlashAccessSegmentCount,
    kProperty_FlashReadMargin,        kProperty_QspiInitStatus,
    kProperty_TargetVersion,          kProperty_ExernalMemoryAttributes,
    kProperty_ReliableUpdateStatus,
};


struct peripheral_t
{
    uint32_t mask;
    const char *description;

    peripheral_t(uint32_t mask, const char *description)
        : mask(mask)
        , description(description)
    {
    }
};

const peripheral_t kPeripheral_Uart(0x00000001, "UART");
const peripheral_t kPeripheral_I2C(0x00000002, "I2C Slave");
const peripheral_t kPeripheral_Spi(0x00000004, "SPI Slave");
const peripheral_t kPeripheral_Can(0x00000008, "CAN");
const peripheral_t kPeripheral_UsbHid(0x00000010, "USB HID");
const peripheral_t kPeripheral_UsbCdc(0x00000020, "USB CDC");
const peripheral_t kPeripheral_UsbDfu(0x00000040, "USB DFU");

const array<const peripheral_t, 7> kPeripherals = { kPeripheral_Uart,  kPeripheral_I2C,    kPeripheral_Spi,
                                                    kPeripheral_Can,   kPeripheral_UsbHid, kPeripheral_UsbCdc,
                                                    kPeripheral_UsbDfu };

struct StatusMessageTableEntry
{
    int32_t status;            
    const std::string message; 
};

extern StatusMessageTableEntry g_statusCodes[];

class Progress
{
public:
    Progress()
        : m_segmentIndex(1)
        , m_segmentCount(1)
        , m_progressCallback(NULL)
        , m_abortPhase(NULL)
    {
    }

    Progress(void (*callback)(int, int, int), bool *abortPhase)
        : m_segmentIndex(1)
        , m_segmentCount(1)
        , m_progressCallback(callback)
        , m_abortPhase(abortPhase)
    {
    }

    ~Progress() {}
    void progressCallback(int percentage)
    {
        if (m_progressCallback != NULL)
        {
            m_progressCallback(percentage, m_segmentIndex, m_segmentCount);
        }
    }

    bool abortPhase(void)
    {
        if ((m_abortPhase) && (*m_abortPhase == true))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    void registerCallback(void (*callback)(int, int, int), bool *abortPhase)
    {
        m_progressCallback = callback;
        m_abortPhase = abortPhase;
    }

public:
    int m_segmentIndex; 
    int m_segmentCount; 

private:
    void (*m_progressCallback)(int percentage, int segmentIndex, int segmentCount); 
    bool *m_abortPhase; 
};



class Command
{
public:
    static Command *create(const string_vector_t *argv);

public:
    static std::string getStatusMessage(status_t code);

protected:
    Command(const string_vector_t *argv)
        : m_argv(*argv)
        , m_responseValues()
        , m_responseDetails()
        , m_progress()
    {
    }

    Command(const char *const name)
        : m_argv(1, name)
        , m_responseValues()
        , m_responseDetails()
        , m_progress()
    {
    }

public:
    virtual ~Command() {}
    virtual bool init() { return true; }


    virtual std::string getArg(int arg) const { return m_argv.at(arg); }
    virtual std::string getName() const { return getArg(0); }
    virtual size_t getArgCount() const { return m_argv.size(); }

    virtual void sendTo(Packetizer &packetizer) {}
    virtual const uint32_vector_t *getResponseValues() const
    {
        return const_cast<uint32_vector_t *>(&m_responseValues);
    }

    virtual std::string getResponse() const;

    void logResponses() const;

    void registerProgress(Progress *progress) { m_progress = progress; }
protected:
    virtual bool processResponse(const generic_response_packet_t *packet, uint8_t commandTag);

public:
    Progress *m_progress; 

protected:
    string_vector_t m_argv;           
    uint32_vector_t m_responseValues; 
    string m_responseDetails;         
};

class CommandPacket
{
protected:
    enum _command_packet_constants
    {
        kMaxCommandArguments = (kDefaultMaxPacketSize - sizeof(command_packet_t)) /
                               sizeof(uint32_t) 
    };

    struct PacketWithArgs
    {
        void init(uint8_t tag, uint8_t flags, uint8_t numArguments)
        {
            m_header.commandTag = tag;
            m_header.flags = flags;
            m_header.reserved = 0;
            m_header.parameterCount = numArguments;
        }
        command_packet_t m_header;                  
        uint32_t m_arguments[kMaxCommandArguments]; 
    };

public:
    CommandPacket(uint8_t tag, uint8_t flags = 0)
    {
        m_numArguments = 0;
        m_packet.init(tag, flags, m_numArguments);
    }

    CommandPacket(uint8_t tag, uint8_t flags, uint32_t arg)
    {
        m_numArguments = 1;
        m_packet.init(tag, flags, m_numArguments);
        m_packet.m_arguments[0] = arg;
    }

    CommandPacket(uint8_t tag, uint8_t flags, uint32_t arg1, uint32_t arg2)
    {
        m_numArguments = 2;
        m_packet.init(tag, flags, m_numArguments);
        m_packet.m_arguments[0] = arg1;
        m_packet.m_arguments[1] = arg2;
    }

    CommandPacket(uint8_t tag, uint8_t flags, uint32_t arg1, uint32_t arg2, uint32_t arg3)
    {
        m_numArguments = 3;
        m_packet.init(tag, flags, m_numArguments);
        m_packet.m_arguments[0] = arg1;
        m_packet.m_arguments[1] = arg2;
        m_packet.m_arguments[2] = arg3;
    }

    CommandPacket(uint8_t tag, uint8_t flags, uint32_t arg1, uint32_t arg2, uint32_t arg3, uint32_t arg4)
    {
        m_numArguments = 4;
        m_packet.init(tag, flags, m_numArguments);
        m_packet.m_arguments[0] = arg1;
        m_packet.m_arguments[1] = arg2;
        m_packet.m_arguments[2] = arg3;
        m_packet.m_arguments[3] = arg4;
    }

    uint32_t getSize() const { return sizeof(command_packet_t) + (m_numArguments * sizeof(uint32_t)); }
    const uint8_t *getData() { return reinterpret_cast<uint8_t *>(&m_packet.m_header); }
    const uint8_t *sendCommandGetResponse(Packetizer &device);

protected:
    int m_numArguments;      
    PacketWithArgs m_packet; 
};

class DataPacket
{
public:
    class DataProducer
    {
    public:
        virtual bool hasMoreData() const = 0;

        virtual uint32_t getDataSize() const = 0;

        virtual uint32_t getData(uint8_t *data, uint32_t size) = 0;
    };

    class FileDataProducer : public DataProducer
    {
    public:
        FileDataProducer()
            : m_filePath()
            , m_filePointer(NULL)
            , m_fileSize(0)
        {
        }

        virtual ~FileDataProducer()
        {
            if (m_filePointer)
                fclose(m_filePointer);
        }

        bool init(std::string filePath, uint32_t count);


        virtual bool hasMoreData() const
        {
            assert(m_filePointer);
            return (m_fileSize && !feof(m_filePointer));
        }

        virtual uint32_t getDataSize() const { return (uint32_t)m_fileSize; }
        virtual uint32_t getData(uint8_t *data, uint32_t size);

    protected:
        std::string m_filePath; 
        FILE *m_filePointer;    
        long m_fileSize;        
    };

    class HexDataProducer : public DataProducer
    {
    public:
        HexDataProducer()
            : m_byteIndex(0)
            , m_data()
        {
        }

        HexDataProducer(const uchar_vector_t &data)
            : m_byteIndex(0)
            , m_data(data)
        {
        }

        uint32_t initFromString(const std::string hexData);

        virtual ~HexDataProducer() {}

        virtual bool hasMoreData() const { return (m_byteIndex < m_data.size()); }
        virtual uint32_t getDataSize() const { return m_data.size(); }
        virtual uint32_t getData(uint8_t *data, uint32_t size);

    protected:
        uint32_t m_byteIndex;  
        uchar_vector_t m_data; 
    };

    class SegmentDataProducer : public DataProducer
    {
    public:
        SegmentDataProducer(blfwk::DataSource::Segment *segment)
            : m_segment(segment)
            , m_byteIndex(0)
        {
        }

        virtual ~SegmentDataProducer() {}
        bool init(std::string filePath);


        virtual bool hasMoreData() const { return (m_byteIndex < m_segment->getLength()); }
        virtual uint32_t getDataSize() const { return m_segment->getLength(); }
        virtual uint32_t getData(uint8_t *data, uint32_t size);

    protected:
        blfwk::DataSource::Segment *m_segment; 
        uint32_t m_byteIndex;                  
    };

    class DataConsumer
    {
    public:
        virtual void processData(const uint8_t *data, uint32_t size) = 0;

        virtual void finalize() = 0;
    };

    class FileDataConsumer : public DataConsumer
    {
    public:
        FileDataConsumer()
            : m_filePath()
            , m_filePointer(NULL)
        {
        }

        virtual ~FileDataConsumer()
        {
            if (m_filePointer)
                fclose(m_filePointer);
        }

        bool init(std::string filePath);

        virtual void processData(const uint8_t *data, uint32_t size);

        virtual void finalize() {}
    protected:
        std::string m_filePath; 
        FILE *m_filePointer;    
    };

    class StdOutDataConsumer : public DataConsumer
    {
    public:
        enum _constants
        {
            kBytesPerLine = 16 
        };

    public:
        StdOutDataConsumer()
            : m_currentCount(1)
        {
        }

        virtual void finalize()
        {
            if (((m_currentCount - 1) % kBytesPerLine) != 0)
            {
                // Fill space to clean the progress text.
                for (int i = ((m_currentCount - 1) % kBytesPerLine) * 3; i < 9; i++)
                {
                    printf(" ");
                }
                printf("\n");
            }
        }

        virtual void processData(const uint8_t *data, uint32_t size);

    protected:
        uint32_t m_currentCount; 
    };

public:
    DataPacket(DataProducer *dataProducer)
    {
        assert(dataProducer);
        m_dataProducer = dataProducer;
    }

    DataPacket(DataConsumer *dataConsumer)
    {
        assert(dataConsumer);
        m_dataConsumer = dataConsumer;
    }

    uint8_t *sendTo(Packetizer &device, uint32_t *bytesWritten, Progress *progress);

    uint8_t *receiveFrom(Packetizer &device, uint32_t *byteCount, Progress *progress);

protected:
    DataProducer *m_dataProducer;           
    DataConsumer *m_dataConsumer;           
    uint8_t m_packet[kMinPacketBufferSize]; 
};

class Reset : public Command
{
public:
    Reset(const string_vector_t *argv)
        : Command(argv)
    {
    }

    Reset()
        : Command(kCommand_Reset.name)
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet), kCommandTag_Reset);
    }
};

class GetProperty : public Command
{
public:
    GetProperty(const string_vector_t *argv)
        : Command(argv)
        , m_property(kProperty_Invalid.value, kProperty_Invalid.description)
    {
    }

    GetProperty(property_t property)
        : Command(kCommand_GetProperty.name)
        , m_property(property)
    {
        m_argv.push_back(format_string("0x%08x", property.value));
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const get_property_response_packet_t *packet);

    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_GetProperty);
    }

protected:
    property_t m_property; 
    uint32_t m_memoryId;   
};

class SetProperty : public Command
{
public:
    SetProperty(const string_vector_t *argv)
        : Command(argv)
    {
    }

    SetProperty(property_t property, uint32_t value)
        : Command(kCommand_SetProperty.name)
        , m_propertyTag(property.value)
        , m_propertyValue(value)
    {
        m_argv.push_back(format_string("0x%08x", property.value));
        m_argv.push_back(format_string("0x%08x", value));
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_SetProperty);
    }

protected:
    uint32_t m_propertyTag;   
    uint32_t m_propertyValue; 
};

class FlashEraseRegion : public Command
{
public:
    FlashEraseRegion(const string_vector_t *argv)
        : Command(argv)
    {
    }

    FlashEraseRegion(uint32_t start, uint32_t length)
        : Command(kCommand_FlashEraseRegion.name)
        , m_startAddress(start)
        , m_byteCount(length)
    {
        m_argv.push_back(format_string("0x%08x", start));
        m_argv.push_back(format_string("0x%08x", length));
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_FlashEraseRegion);
    }

protected:
    uint32_t m_startAddress; 
    uint32_t m_byteCount;    
};

class FlashEraseAll : public Command
{
public:
    FlashEraseAll(const string_vector_t *argv)
        : Command(argv)
    {
    }

    FlashEraseAll(uint32_t memoryId)
        : Command(kCommand_FlashEraseAll.name)
        , m_memoryId(memoryId)
    {
        m_argv.push_back(format_string("%d", memoryId));
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_FlashEraseAll);
    }

protected:
    uint32_t m_memoryId; 
};

class FlashEraseAllUnsecure : public Command
{
public:
    FlashEraseAllUnsecure(const string_vector_t *argv)
        : Command(argv)
    {
    }

    FlashEraseAllUnsecure()
        : Command(kCommand_GetProperty.name)
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_FlashEraseAllUnsecure);
    }
};

class ReadMemory : public Command
{
public:
    ReadMemory(const string_vector_t *argv)
        : Command(argv)
        , m_dataFile()
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const read_memory_response_packet_t *packet);

    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_ReadMemory);
    }

protected:
    std::string m_dataFile;  
    uint32_t m_startAddress; 
    uint32_t m_byteCount;    
};

class WriteMemory : public Command
{
public:
    WriteMemory(const string_vector_t *argv)
        : Command(argv)
        , m_fileOrData()
        , m_segment(NULL)
        , m_startAddress(0)
        , m_count(0)
        , m_data()
    {
    }

    WriteMemory(blfwk::DataSource::Segment *segment)
        : Command(kCommand_WriteMemory.name)
        , m_fileOrData()
        , m_segment(segment)
        , m_count(0)
        , m_data()
    {
        m_startAddress = segment->getBaseAddress();
        m_argv.push_back(format_string("0x%08x", m_startAddress));
        m_argv.push_back(m_fileOrData);
    }

    WriteMemory(uint32_t address, const uchar_vector_t &data)
        : Command(kCommand_WriteMemory.name)
        , m_fileOrData()
        , m_segment(NULL)
        , m_startAddress(address)
        , m_count(0)
        , m_data(data)
    {
        m_argv.push_back(format_string("0x%08x", m_startAddress));
        m_argv.push_back(m_fileOrData);
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_WriteMemory);
    }

protected:
    std::string m_fileOrData;              
    blfwk::DataSource::Segment *m_segment; 
    uint32_t m_startAddress;               
    uint32_t m_count;                      
    uchar_vector_t m_data;                 
};

class FillMemory : public Command
{
public:
    FillMemory(const string_vector_t *argv)
        : Command(argv)
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_FillMemory);
    }

protected:
    uint32_t m_startAddress; 
    uint32_t m_byteCount;    
    uint32_t m_patternWord;  
};

class ReceiveSbFile : public Command
{
public:
    ReceiveSbFile(const string_vector_t *argv)
        : Command(argv)
        , m_dataFile()
    {
    }

    ReceiveSbFile(const char *const filename)
        : Command(kCommand_ReceiveSbFile.name)
        , m_dataFile(filename)
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_ReceiveSbFile);
    }

protected:
    std::string m_dataFile; 
};

class Execute : public Command
{
public:
    Execute(const string_vector_t *argv)
        : Command(argv)
    {
    }

    Execute(uint32_t entry_point, uint32_t param, uint32_t stack_pointer)
        : Command(kCommand_Execute.name)
        , m_jumpAddress(entry_point)
        , m_wordArgument(param)
        , m_stackpointer(stack_pointer)
    {
        m_argv.push_back(format_string("0x%08x", entry_point));
        m_argv.push_back(format_string("0x%08x", param));
        m_argv.push_back(format_string("0x%08x", stack_pointer));
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_Execute);
    }

protected:
    uint32_t m_jumpAddress;  
    uint32_t m_wordArgument; 
    uint32_t m_stackpointer; 
};

class Call : public Command
{
public:
    Call(const string_vector_t *argv)
        : Command(argv)
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet), kCommandTag_Call);
    }

protected:
    uint32_t m_callAddress;  
    uint32_t m_wordArgument; 
};

class FlashSecurityDisable : public Command
{
public:
    FlashSecurityDisable(const string_vector_t *argv)
        : Command(argv)
    {
    }

    FlashSecurityDisable(uint32_t keyHigh, uint32_t keyLow)
        : Command(kCommand_FlashSecurityDisable.name)
        , m_keyHigh(keyHigh)
        , m_keyLow(keyLow)
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_FlashSecurityDisable);
    }

protected:
    uint32_t m_keyLow;  
    uint32_t m_keyHigh; 
};

class FlashProgramOnce : public Command
{
public:
    FlashProgramOnce(const string_vector_t *argv)
        : Command(argv)
    {
    }

    FlashProgramOnce(uint32_t index, uint32_t byteCount, uint32_t dataLow, uint32_t dataHigh)
        : Command(kCommand_FlashProgramOnce.name)
        , m_index(index)
        , m_byteCount(byteCount)
        , m_dataLow(dataLow)
        , m_dataHigh(dataHigh)
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_FlashProgramOnce);
    }

protected:
    uint32_t m_index;     
    uint32_t m_byteCount; 
    uint32_t m_dataLow;   
    uint32_t m_dataHigh;  
};

class FlashReadOnce : public Command
{
public:
    FlashReadOnce(const string_vector_t *argv)
        : Command(argv)
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const flash_read_once_response_packet_t *packet);

    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_FlashReadOnce);
    }

protected:
    uint32_t m_index;     
    uint32_t m_byteCount; 
};

class FlashReadResource : public Command
{
public:
    FlashReadResource(const string_vector_t *argv)
        : Command(argv)
        , m_dataFile()
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const flash_read_resource_response_packet_t *packet);

    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_FlashReadResource);
    }

protected:
    std::string m_dataFile;  
    uint32_t m_startAddress; 
    uint32_t m_byteCount;    
    uint32_t m_option;       
};

class ConfigureQuadSpi : public Command
{
public:
    ConfigureQuadSpi(const string_vector_t *argv)
        : Command(argv)
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_ConfigureQuadSpi);
    }

protected:
    uint32_t m_flashMemId;         
    uint32_t m_configBlockAddress; 
};

class ReliableUpdate : public Command
{
public:
    ReliableUpdate(const string_vector_t *argv)
        : Command(argv)
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_ReliableUpdate);
    }

protected:
    uint32_t m_address; 
};

class FlashImage : public Command
{
public:
    FlashImage(const string_vector_t *argv)
        : Command(argv)
        , m_fileName()
        , m_sourceFile(NULL)
        , m_doEraseOpt(false)
        , m_sectorSize()
    {
    }

    FlashImage(SourceFile *sourceFile, bool doEraseOpt)
        : Command(kCommand_FlashImage.name)
        , m_fileName()
        , m_sourceFile(sourceFile)
        , m_doEraseOpt(doEraseOpt)
        , m_sectorSize()
    {
        m_argv.push_back(m_sourceFile->getPath());
        m_argv.push_back(doEraseOpt ? "erase" : "none");
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    uint32_t m_sectorSize;    
    std::string m_fileName;   
    SourceFile *m_sourceFile; 
    bool m_doEraseOpt;        
};

class ConfigureI2c : public Command
{
public:
    ConfigureI2c(const string_vector_t *argv)
        : Command(argv)
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_ConfigureI2c);
    }

protected:
    uint8_t i2cAddress = 0x10;
    uint32_t i2cSpeedKHz = 100;
};

class ConfigureSpi : public Command
{
public:
    ConfigureSpi(const string_vector_t *argv)
        : Command(argv)
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_ConfigureSpi);
    }

protected:
    uint32_t spiSpeedKHz = 100;
    BusPal::spi_clock_polarity_t spiPolarity = BusPal::kSpiClockPolarity_ActiveLow;
    BusPal::spi_clock_phase_t spiPhase = BusPal::kSpiClockPhase_SecondEdge;
    BusPal::spi_shift_direction_t spiDirection = BusPal::kSpiMsbFirst;
};

class ConfigureCan : public Command
{
public:
    ConfigureCan(const string_vector_t *argv)
        : Command(argv)
    {
    }

    virtual bool init();

    virtual void sendTo(Packetizer &packetizer);

protected:
    virtual bool processResponse(const uint8_t *packet)
    {
        return Command::processResponse(reinterpret_cast<const generic_response_packet_t *>(packet),
                                        kCommandTag_ConfigureCan);
    }

protected:
    uint32_t canSpeed = 4;
    uint32_t canTxid = 0x321;
    uint32_t canRxid = 0x123;
};


} // namespace blfwk


#endif // _Command_h_

// EOF