evbme_messages.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2020, Cascoda Ltd.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. 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.
 *  3. Neither the name of the copyright holder 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 EVBME_MESSAGES_H
#define EVBME_MESSAGES_H
 
#include <stdint.h>
 
#include "ca821x_config.h"
#include "ca821x_error.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum evbme_command_ids
{
    EVBME_GET_CONFIRM = 0x5C, 
    EVBME_GET_REQUEST = 0x5D, 
    EVBME_SET_CONFIRM = 0x5E, 
    EVBME_SET_REQUEST = 0x5F, 
 
    EVBME_HOST_CONNECTED     = 0x81, 
    EVBME_HOST_DISCONNECTED  = 0x82, 
    EVBME_MESSAGE_INDICATION = 0xA0, 
    EVBME_COMM_CHECK         = 0xA1, 
    EVBME_COMM_INDICATION    = 0xA2, 
    EVBME_DFU_CMD            = 0xA3, 
 
    EVBME_RXRDY  = 0xAA, 
    EVBME_RXFAIL = 0xAB, 
};
 
enum evbme_attribute
{
    EVBME_RESETRF  = 0x00, 
    EVBME_CFGPINS  = 0x01, 
    EVBME_WAKEUPRF = 0x02, 
 
    EVBME_VERSTRING                = 0x80, 
    EVBME_PLATSTRING               = 0x81, 
    EVBME_APPSTRING                = 0x82, 
    EVBME_SERIALNO                 = 0x83, 
    EVBME_OT_EUI64                 = 0x84, 
    EVBME_OT_JOINCRED              = 0x85, 
    EVBME_EXTERNAL_FLASH_AVAILABLE = 0x86, 
    EVBME_ONBOARD_FLASH_INFO       = 0x87, 
};
 
enum evbme_dfu_const
{
    DFU_WRITE_MAX_LEN = 244, 
};
 
enum evbme_dfu_cmdid
{
    DFU_REBOOT   = 0, 
    DFU_ERASE    = 1, 
    DFU_WRITE    = 2, 
    DFU_CHECK    = 3, 
    DFU_STATUS   = 4, 
    DFU_BOOTMODE = 5, 
};
 
enum evbme_dfu_rebootmode
{
    EVBME_DFU_REBOOT_APROM = 0, 
    EVBME_DFU_REBOOT_DFU   = 1, 
};
 
struct evbme_dfu_reboot_cmd
{
    uint8_t rebootMode; 
};
 
struct evbme_dfu_erase_cmd
{
    uint8_t startAddr[4]; 
    uint8_t eraseLen[4];  
};
 
struct evbme_dfu_write_cmd
{
    uint8_t startAddr[4]; 
    uint8_t data[];       
};
 
struct evbme_dfu_check_cmd
{
    uint8_t startAddr[4]; 
    uint8_t checkLen[4];  
    uint8_t checksum[4];  
};
 
struct evbme_dfu_status_cmd
{
    uint8_t status; 
};
 
struct evbme_dfu_bootmode_cmd
{
    uint8_t bootMode; 
};
 
union evbme_dfu_sub_cmd
{
    struct evbme_dfu_reboot_cmd   reboot_cmd;
    struct evbme_dfu_erase_cmd    erase_cmd;
    struct evbme_dfu_write_cmd    write_cmd;
    struct evbme_dfu_check_cmd    check_cmd;
    struct evbme_dfu_status_cmd   status_cmd;
    struct evbme_dfu_bootmode_cmd bootmode_cmd;
};
 
struct EVBME_GET_confirm
{
    uint8_t mStatus;
    uint8_t mAttributeId;
    uint8_t mAttributeLen;
    uint8_t mAttribute[];
};
 
struct EVBME_GET_request
{
    uint8_t mAttributeId;
};
 
struct EVBME_SET_confirm
{
    uint8_t mStatus;
};
 
struct EVBME_SET_request
{
    uint8_t mAttributeId;
    uint8_t mAttributeLen;
    uint8_t mAttribute[];
};
 
struct EVBME_MESSAGE_indication
{
    char mMessage[1]; //Flexible length, but need at least one member
};
 
struct EVBME_COMM_CHECK_request
{
    uint8_t mHandle;    
    uint8_t mDelay;     
    uint8_t mIndCount;  
    uint8_t mIndSize;   
    uint8_t mPayload[]; 
};
 
struct EVBME_COMM_indication
{
    uint8_t mHandle;    
    uint8_t mPayload[]; 
};
 
struct EVBME_DFU_cmd
{
    uint8_t                 mDfuSubCmdId; 
    union evbme_dfu_sub_cmd mSubCmd;      
};
 
struct EVBME_Message
{
    uint8_t mCmdId; 
    uint8_t mLen;   
    union
    {
        struct EVBME_GET_confirm        GET_confirm;
        struct EVBME_GET_request        GET_request;
        struct EVBME_SET_confirm        SET_confirm;
        struct EVBME_SET_request        SET_request;
        struct EVBME_MESSAGE_indication MESSAGE_indication;
        struct EVBME_COMM_CHECK_request COMM_CHECK_request;
        struct EVBME_COMM_indication    COMM_indication;
        struct EVBME_DFU_cmd            DFU_cmd;
        uint8_t                         data[254]; 
    } EVBME;
};
 
#ifdef __cplusplus
}
#endif
 
#endif // EVBME_MESSAGES_H