apps/KinetisFlashTool/KinetisFlashTool/Bootloader.h

/*
* Copyright (c) 2013-15, 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.
*/

#pragma once
#include "afxwin.h"
#include <vector>
#include <array>
#include "../../common/blfwkdll/blfwkdll.h"

using namespace std;

class Bootloader : public CWinThread
{
public:
    struct TargetInformation
    {
        UINT32 targetVersion;    
        UINT32 procotolVersion;  
        UINT32 securityState;    
        UINT32 flashSize;        
        UINT32 flashSectorSize;  
        UINT32 ramSize;          
        UINT32 rsvRgnFlashStart; 
        UINT32 rsvRgnFlashEnd;   
        UINT32 rsvRgnRamStart;   
        UINT32 rsvRgnRamEnd;     
        UINT32 supportedCmd;     
    };

    struct FlashFirmwareOption
    {
        BOOL autoConnect;          
        BOOL doErasetoUnlock;      
        BOOL useKeytoUnlock;       
        std::string backdoorkey;   
        std::string imageFilePath; 
        uint32_t baseAddress;      
    };

    struct EraseOption
    {
        enum ERASE_OPERATION
        {
            erase_region = 0,          
            erase_all = 1,             
            erase_all_and_unsecure = 2 
        };

        ERASE_OPERATION option; 
        uint32_t memoryID;      
        uint32_t startAddress;  
        uint32_t length;        
    };

    struct ProgramOnceOption
    {
        uint32_t index;     
        uint32_t byteCount; 
        std::string data;   
    };

public:
    Bootloader() { this->Open(); };
    virtual ~Bootloader() { this->Close(); };
    virtual BOOL InitInstance() { return CWinThread::InitInstance(); };
    virtual int ExitInstance() { return CWinThread::ExitInstance(); };
    enum KibbleStatusCode
    {
        KBL_Status_Success = 0x0,           
        KBL_Status_AbortDataPhase = 0x2712, 
    };

    bool CanRun();

    DWORD Open();

    void Close();

    static void progressCallback(int percentage, int segmentIndex, int segmentCount);

    DWORD WaitForEvents(DWORD time);

    void ResetEvents(DWORD events);

    void Ping();

    void Reset();

    void Connect(blfwkdll::Updater::PeripheralConfig *config);

    void UpdateStatus();

    void UpdateImage(blfwkdll::Updater::PeripheralConfig *config, FlashFirmwareOption *option);

    void Erase(EraseOption *option);

    void ProgramOnce(ProgramOnceOption *option);

    HANDLE m_pingEvent;        
    HANDLE m_statusEvent;      
    HANDLE m_resetEvent;       
    HANDLE m_connectEvent;     
    HANDLE m_updateEvent;      
    HANDLE m_eraseEvent;       
    HANDLE m_programOnceEvent; 
    HANDLE m_exitEvent;        
    CWinThread *m_pThread;     

    bool m_abort;                                 
    bool m_isRunning;                             
    bool m_isExiting;                             
    bool m_isConneted;                            
    TargetInformation m_targetInfo;               
    FlashFirmwareOption m_firmwareConfig;         
    EraseOption m_eraseOption;                    
    ProgramOnceOption m_programOnceOption;        
    blfwkdll::Updater::PeripheralConfig m_config; 
    blfwkdll::Updater *m_updater;                 
};

extern Bootloader *g_pBootloader;