property.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 _property_h
#define _property_h

#include <stdint.h>
#include "bootloader_common.h"
#include "packet/command_packet.h"
#if !defined(BOOTLOADER_HOST)
#include "fsl_device_registers.h"
#include "utilities/vector_table_info.h"
#endif


// Declarations



#define HAS_CMD(tag) (1 << ((tag)-kFirstCommandTag))

#define IS_CMD_AVAILABLE(mask, tag) (((mask)&HAS_CMD(tag)) != 0)

enum _available_commands
{
    kAvailableCommands = (
#if !BL_FEATURE_MIN_PROFILE
        HAS_CMD(kCommandTag_FlashEraseAll) | HAS_CMD(kCommandTag_FlashEraseRegion) | HAS_CMD(kCommandTag_WriteMemory)
#if BL_FEATURE_FLASH_SECURITY
        |
        HAS_CMD(kCommandTag_FlashSecurityDisable)
#endif // BL_FEATURE_ERASEALL_UNSECURE
        |
        HAS_CMD(kCommandTag_GetProperty) | HAS_CMD(kCommandTag_Execute) | HAS_CMD(kCommandTag_Reset) |
        HAS_CMD(kCommandTag_SetProperty) | HAS_CMD(kCommandTag_ReadMemory) | HAS_CMD(kCommandTag_FillMemory) |
        HAS_CMD(kCommandTag_ReceiveSbFile) | HAS_CMD(kCommandTag_Call)
#if BL_FEATURE_ERASEALL_UNSECURE
        |
        HAS_CMD(kCommandTag_FlashEraseAllUnsecure)
#endif // BL_FEATURE_ERASEALL_UNSECURE
        |
        HAS_CMD(kCommandTag_FlashReadOnce) | HAS_CMD(kCommandTag_FlashProgramOnce) |
        HAS_CMD(kCommandTag_FlashReadResource)
#if BL_FEATURE_QSPI_MODULE
        |
        HAS_CMD(kCommandTag_ConfigureQuadSpi)
#endif // BL_FEATURE_QSPI_MODULE

#else // BL_FEATURE_MIN_PROFILE
        HAS_CMD(kCommandTag_FlashEraseAll) | HAS_CMD(kCommandTag_FlashEraseRegion) | HAS_CMD(kCommandTag_WriteMemory)
#if BL_FEATURE_FLASH_SECURITY
        |
        HAS_CMD(kCommandTag_FlashSecurityDisable)
#endif // BL_FEATURE_FLASH_SECURITY
        |
        HAS_CMD(kCommandTag_GetProperty) | HAS_CMD(kCommandTag_Execute) | HAS_CMD(kCommandTag_Reset) |
        HAS_CMD(kCommandTag_SetProperty)
#if BL_FEATURE_READ_MEMORY
        |
        HAS_CMD(kCommandTag_ReadMemory)
#endif // BL_FEATURE_READ_MEMORY
#if BL_FEATURE_FILL_MEMORY
        |
        HAS_CMD(kCommandTag_FillMemory)
#endif // BL_FEATURE_FILL_MEMORY
#if BL_FEATURE_ERASEALL_UNSECURE
        |
        HAS_CMD(kCommandTag_FlashEraseAllUnsecure)
#endif // BL_FEATURE_ERASEALL_UNSECURE
#if BL_FEATURE_QSPI_MODULE
        |
        HAS_CMD(kCommandTag_ConfigureQuadSpi)
#endif // BL_FEATURE_QSPI_MODULE

#endif // BL_FEATURE_MIN_PROFILE
            )
};


enum _property_errors
{
    kStatus_UnknownProperty = MAKE_STATUS(kStatusGroup_PropertyStore, 0),
    kStatus_ReadOnlyProperty = MAKE_STATUS(kStatusGroup_PropertyStore, 1),    
    kStatus_InvalidPropertyValue = MAKE_STATUS(kStatusGroup_PropertyStore, 2) 
};

enum _property_tag
{
    kPropertyTag_ListProperties = 0x00,
    kPropertyTag_BootloaderVersion = 0x01,
    kPropertyTag_AvailablePeripherals = 0x02,
    kPropertyTag_FlashStartAddress = 0x03,
    kPropertyTag_FlashSizeInBytes = 0x04,
    kPropertyTag_FlashSectorSize = 0x05,
    kPropertyTag_FlashBlockCount = 0x06,
    kPropertyTag_AvailableCommands = 0x07,
    kPropertyTag_CrcCheckStatus = 0x08,
    kPropertyTag_Reserved9 = 0x09,
    kPropertyTag_VerifyWrites = 0x0a,
    kPropertyTag_MaxPacketSize = 0x0b,
    kPropertyTag_ReservedRegions = 0x0c,
    kPropertyTag_Reserved13 = 0x0d,
    kPropertyTag_RAMStartAddress = 0x0e,
    kPropertyTag_RAMSizeInBytes = 0x0f,
    kPropertyTag_SystemDeviceId = 0x10,
    kPropertyTag_FlashSecurityState = 0x11,
    kPropertyTag_UniqueDeviceId = 0x12,
    kPropertyTag_FacSupport = 0x13,
    kPropertyTag_FlashAccessSegmentSize = 0x14,
    kPropertyTag_FlashAccessSegmentCount = 0x15,
    kPropertyTag_FlashReadMargin = 0x16,
    kPropertyTag_QspiInitStatus = 0x17,
    kPropertyTag_TargetVersion = 0x18,
    kPropertyTag_ExternalMemoryAttributes = 0x19,
    kPropertyTag_ReliableUpdateStatus = 0x1a,
    kPropertyTag_InvalidProperty = 0xFF,
};

enum _property_constants
{
    kProperty_ReservedRegionsCount = 2,
    kProperty_FlashReservedRegionIndex = 0,
    kProperty_RamReservedRegionIndex = 1,

    kProperty_FlashVersionIdSizeInBytes = 8,
};

enum _clock_flags
{
    kClockFlag_HighSpeed = (1 << 0)
};

enum _boot_flags
{
    kBootFlag_DirectBoot = (1 << 0)
};

#if !defined(BOOTLOADER_HOST)
enum _flash_constants
{
    kBootloaderConfigAreaAddress = (uint32_t)(APP_VECTOR_TABLE) + 0x3c0
};
#endif // BOOTLOADER_HOST

typedef struct BootloaderConfigurationData
{
    uint32_t tag; 
    uint32_t crcStartAddress;              
    uint32_t crcByteCount;                 
    uint32_t crcExpectedValue;             
    uint8_t enabledPeripherals;            
    uint8_t i2cSlaveAddress;               
    uint16_t peripheralDetectionTimeoutMs; 
    uint16_t usbVid;                    
    uint16_t usbPid;                    
    uint32_t usbStringsPointer;         
    uint8_t clockFlags;                 
    uint8_t clockDivider;               
    uint8_t bootFlags;                  
    uint8_t pad0;                       
    uint32_t mmcauConfigPointer;        
    uint32_t keyBlobPointer;            
    uint8_t pad1;                       
    uint8_t canConfig1;                 
    uint16_t canConfig2;                
    uint16_t canTxId;                   
    uint16_t canRxId;                   
    uint32_t qspi_config_block_pointer; 
} bootloader_configuration_data_t;

typedef struct ReservedRegion
{
    uint32_t startAddress;
    uint32_t endAddress;
} reserved_region_t;

typedef struct UniqueDeviceId
{
    uint32_t uidl;
    uint32_t uidml;
    uint32_t uidmh;
#if defined(BOOTLOADER_HOST) | defined(SIM_UIDH)
    uint32_t uidh;
#endif
} unique_device_id_t;

enum _external_memory_property_tags
{
    kExternalMemoryPropertyTag_InitStatus = 0,         
    kExternalMemoryPropertyTag_StartAddress = 1,       
    kExternalMemoryPropertyTag_MemorySizeInKbytes = 2, 
    kExternalMemoryPropertyTag_PageSize = 3,           
    kExternalMemoryPropertyTag_SectorSize = 4,         
    kExternalMemoryPropertyTag_BlockSize = 5,          

    kExternalMemoryPropertyTag_Start = kExternalMemoryPropertyTag_StartAddress,
    kExternalMemoryPropertyTag_End = kExternalMemoryPropertyTag_BlockSize,
};

typedef struct
{
    uint32_t availableAttributesFlag; 
    uint32_t startAddress;            
    uint32_t flashSizeInKB;           
    uint32_t pageSize;                
    uint32_t sectorSize;              
    uint32_t blockSize;               
} external_memory_property_store_t;

enum _ram_constants
{
#if CPU_IS_ARM_CORTEX_M7
    kRAMCount = 3,
#else
    kRAMCount = 1,
#endif
};

typedef struct PropertyStore
{
    standard_version_t bootloaderVersion;     
    standard_version_t serialProtocolVersion; 
    standard_version_t targetVersion;         
    uint32_t availablePeripherals;            
    uint32_t flashStartAddress;               
    uint32_t flashSizeInBytes;                
    uint32_t flashSectorSize; 
    uint32_t flashBlockSize;  
    uint32_t flashBlockCount; 
    uint32_t ramStartAddress[kRAMCount]; 
    uint32_t ramSizeInBytes[kRAMCount];  
    uint32_t crcCheckStatus;             
    uint32_t verifyWrites; 
    uint32_t availableCommands;        
    unique_device_id_t UniqueDeviceId; 
    uint32_t flashFacSupport;          
    uint32_t flashAccessSegmentSize;   
    uint32_t flashAccessSegmentCount;  
    uint32_t flashReadMargin;          
    uint32_t qspiInitStatus;           
    reserved_region_t reservedRegions[kProperty_ReservedRegionsCount]; 
    bootloader_configuration_data_t
        configurationData; 
    external_memory_property_store_t externalMemoryPropertyStore; 
    uint32_t reliableUpdateStatus;                                
} property_store_t;

enum _property_store_tags
{
    kPropertyStoreTag = FOUR_CHAR_CODE('k', 'c', 'f', 'g')
};

typedef struct ExternalMemoryPropertyInterface
{
    uint32_t memoryId;
    status_t (*get)(uint32_t tag, uint32_t *value);
} external_memory_property_interface_t;

typedef struct PropertyInterface
{
    status_t (*load_user_config)(void); 
    status_t (*init)(void);             
    status_t (*get)(uint8_t tag, uint8_t id, const void **value, uint32_t *valueSize); 
    status_t (*set_uint32)(uint8_t tag, uint32_t value);                               
    property_store_t *store;                                                           
} property_interface_t;

// Externs

extern const property_interface_t g_propertyInterface;

// Prototypes

#if __cplusplus
extern "C" {
#endif



status_t bootloader_property_load_user_config(void);

status_t bootloader_property_init(void);

status_t bootloader_property_get(uint8_t tag, uint8_t memoryId, const void **value, uint32_t *valueSize);

status_t bootloader_property_set_uint32(uint8_t tag, uint32_t value);


#if __cplusplus
}
#endif


#endif // _property_h
// EOF