/************************************************************************************//** * \file openblt.c * \brief OpenBLT host library source file. * \ingroup Library * \internal *---------------------------------------------------------------------------------------- * C O P Y R I G H T *---------------------------------------------------------------------------------------- * Copyright (c) 2017 by Feaser http://www.feaser.com All rights reserved * *---------------------------------------------------------------------------------------- * L I C E N S E *---------------------------------------------------------------------------------------- * This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or * modify it under the terms of the GNU General Public License as published by the Free * Software Foundation, either version 3 of the License, or (at your option) any later * version. * * OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * * You have received a copy of the GNU General Public License along with OpenBLT. It * should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy. * * \endinternal ****************************************************************************************/ /**************************************************************************************** * Include files ****************************************************************************************/ #include /* for assertions */ #include /* for NULL declaration */ #include /* for boolean type */ #include "openblt.h" /* OpenBLT host library */ #include "util.h" /* Utility module */ #include "firmware.h" /* Firmware data module */ #include "srecparser.h" /* S-record parser */ #include "session.h" /* Communication session module */ #include "xcploader.h" /* XCP loader module */ #include "xcptpuart.h" /* XCP UART transport layer */ #include "xcptpcan.h" /* XCP CAN transport layer */ #include "xcptpusb.h" /* XCP USB transport layer */ #include "xcptpnet.h" /* XCP TCP/IP transport layer */ /**************************************************************************************** * Macro definitions ****************************************************************************************/ /** \brief The version number of the library as an integer. The number has two digits * for major-, minor-, and patch-version. Version 1.05.12 would for example be * 10512. */ #define BLT_VERSION_NUMBER (10305u) /** \brief The version number of the library as a null-terminated string. */ #define BLT_VERSION_STRING "1.03.05" /**************************************************************************************** * Local constant declarations ****************************************************************************************/ /** \brief Constant null-terminated string with the version number of the library. */ char const bltVersionString[] = BLT_VERSION_STRING; /**************************************************************************************** * V E R S I O N I N F O R M A T I O N ****************************************************************************************/ /************************************************************************************//** ** \brief Obtains the version number of the library as an integer. The number has two ** digits for major-, minor-, and patch-version. Version 1.05.12 would for ** example return 10512. ** \return Library version number as an integer. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltVersionGetNumber(void) { return BLT_VERSION_NUMBER; } /*** end of BltVersionGetNumber ***/ /************************************************************************************//** ** \brief Obtains the version number of the library as a null-terminated string. ** Version 1.05.12 would for example return "1.05.12". ** \return Library version number as a null-terminated string. ** ****************************************************************************************/ LIBOPENBLT_EXPORT char const * BltVersionGetString(void) { return BLT_VERSION_STRING; } /*** end of BltVersionGetString ***/ /**************************************************************************************** * S E S S I O N / T R A N S P O R T L A Y E R S ****************************************************************************************/ /************************************************************************************//** ** \brief Initializes the firmware update session for a specific communication ** protocol and transport layer. This function is typically called once at ** the start of the firmware update. ** \param sessionType The communication protocol to use for this session. It should ** be a BLT_SESSION_xxx value. ** \param sessionSettings Pointer to a structure with communication protocol specific ** settings. ** \param transportType The transport layer to use for the specified communication ** protocol. It should be a BLT_TRANSPORT_xxx value. ** \param transportSettings Pointer to a structure with transport layer specific ** settings. ** ****************************************************************************************/ LIBOPENBLT_EXPORT void BltSessionInit(uint32_t sessionType, void const * sessionSettings, uint32_t transportType, void const * transportSettings) { /* Check parameters. Note that the settings-pointers are allowed to be NULL in case * no additional settings are needed for the specified session or transport type. */ assert(sessionType == BLT_SESSION_XCP_V10); assert( (transportType == BLT_TRANSPORT_XCP_V10_RS232) || \ (transportType == BLT_TRANSPORT_XCP_V10_CAN) || \ (transportType == BLT_TRANSPORT_XCP_V10_USB) || \ (transportType == BLT_TRANSPORT_XCP_V10_NET) ); /* Initialize the correct session. */ if (sessionType == BLT_SESSION_XCP_V10) /*lint !e774 */ { /* Verify settingsSettings parameter because the XCP loader requires them. */ assert(sessionSettings != NULL); /* Only continue if the settingsSettings parameter is valid. */ if (sessionSettings != NULL) /*lint !e774 */ { /* Cast session settings to the correct type. */ tBltSessionSettingsXcpV10 * bltSessionSettingsXcpV10Ptr; bltSessionSettingsXcpV10Ptr = ((tBltSessionSettingsXcpV10 *)sessionSettings); /* Convert session settings to the format supported by the XCP loader module. */ tXcpLoaderSettings xcpLoaderSettings; xcpLoaderSettings.timeoutT1 = bltSessionSettingsXcpV10Ptr->timeoutT1; xcpLoaderSettings.timeoutT3 = bltSessionSettingsXcpV10Ptr->timeoutT3; xcpLoaderSettings.timeoutT4 = bltSessionSettingsXcpV10Ptr->timeoutT4; xcpLoaderSettings.timeoutT5 = bltSessionSettingsXcpV10Ptr->timeoutT5; xcpLoaderSettings.timeoutT6 = bltSessionSettingsXcpV10Ptr->timeoutT6; xcpLoaderSettings.timeoutT7 = bltSessionSettingsXcpV10Ptr->timeoutT7; xcpLoaderSettings.seedKeyFile = bltSessionSettingsXcpV10Ptr->seedKeyFile; xcpLoaderSettings.connectMode = bltSessionSettingsXcpV10Ptr->connectMode; xcpLoaderSettings.transport = NULL; xcpLoaderSettings.transportSettings = NULL; /* Link the correct transport layer. */ if (transportType == BLT_TRANSPORT_XCP_V10_RS232) { /* Verify transportSettings parameters because the XCP UART transport layer * requires them. */ assert(transportSettings != NULL); /* Only continue if the transportSettings parameter is valid. */ if (transportSettings != NULL) /*lint !e774 */ { /* Cast transport settings to the correct type. */ tBltTransportSettingsXcpV10Rs232 * bltTransportSettingsXcpV10Rs232Ptr; bltTransportSettingsXcpV10Rs232Ptr = (tBltTransportSettingsXcpV10Rs232 * )transportSettings; /* Convert transport settings to the format supported by the XCP UART transport * layer. It was made static to make sure it doesn't get out of scope when * used in xcpLoaderSettings. */ static tXcpTpUartSettings xcpTpUartSettings; xcpTpUartSettings.baudrate = bltTransportSettingsXcpV10Rs232Ptr->baudrate; xcpTpUartSettings.portname = bltTransportSettingsXcpV10Rs232Ptr->portName; /* Store transport layer settings in the XCP loader settings. */ xcpLoaderSettings.transportSettings = &xcpTpUartSettings; /* Link the transport layer to the XCP loader settings. */ xcpLoaderSettings.transport = XcpTpUartGetTransport(); } } else if (transportType == BLT_TRANSPORT_XCP_V10_CAN) { /* Verify transportSettings parameters because the XCP CAN transport layer * requires them. */ assert(transportSettings != NULL); /* Only continue if the transportSettings parameter is valid. */ if (transportSettings != NULL) /*lint !e774 */ { /* Cast transport settings to the correct type. */ tBltTransportSettingsXcpV10Can * bltTransportSettingsXcpV10CanPtr; bltTransportSettingsXcpV10CanPtr = (tBltTransportSettingsXcpV10Can *)transportSettings; /* Convert transport settings to the format supported by the XCP CAN transport * layer. It was made static to make sure it doesn't get out of scope when * used in xcpLoaderSettings. */ static tXcpTpCanSettings xcpTpCanSettings; xcpTpCanSettings.device = bltTransportSettingsXcpV10CanPtr->deviceName; xcpTpCanSettings.channel = bltTransportSettingsXcpV10CanPtr->deviceChannel; xcpTpCanSettings.baudrate = bltTransportSettingsXcpV10CanPtr->baudrate; xcpTpCanSettings.transmitId = bltTransportSettingsXcpV10CanPtr->transmitId; xcpTpCanSettings.receiveId = bltTransportSettingsXcpV10CanPtr->receiveId; xcpTpCanSettings.useExtended = (bltTransportSettingsXcpV10CanPtr->useExtended != 0); /* Store transport layer settings in the XCP loader settings. */ xcpLoaderSettings.transportSettings = &xcpTpCanSettings; /* Link the transport layer to the XCP loader settings. */ xcpLoaderSettings.transport = XcpTpCanGetTransport(); } } else if (transportType == BLT_TRANSPORT_XCP_V10_USB) { /* Store transport layer settings in the XCP loader settings. */ xcpLoaderSettings.transportSettings = NULL; /* Link the transport layer to the XCP loader settings. */ xcpLoaderSettings.transport = XcpTpUsbGetTransport(); } else if (transportType == BLT_TRANSPORT_XCP_V10_NET) { /* Verify transportSettings parameters because the XCP NET transport layer * requires them. */ assert(transportSettings != NULL); /* Only continue if the transportSettings parameter is valid. */ if (transportSettings != NULL) /*lint !e774 */ { /* Cast transport settings to the correct type. */ tBltTransportSettingsXcpV10Net * bltTransportSettingsXcpV10NetPtr; bltTransportSettingsXcpV10NetPtr = (tBltTransportSettingsXcpV10Net * )transportSettings; /* Convert transport settings to the format supported by the XCP NET transport * layer. It was made static to make sure it doesn't get out of scope when * used in xcpLoaderSettings. */ static tXcpTpNetSettings xcpTpNetSettings; xcpTpNetSettings.address = bltTransportSettingsXcpV10NetPtr->address; xcpTpNetSettings.port = bltTransportSettingsXcpV10NetPtr->port; /* Store transport layer settings in the XCP loader settings. */ xcpLoaderSettings.transportSettings = &xcpTpNetSettings; /* Link the transport layer to the XCP loader settings. */ xcpLoaderSettings.transport = XcpTpNetGetTransport(); } } /* Perform actual session initialization. */ SessionInit(XcpLoaderGetProtocol(), &xcpLoaderSettings); } } } /*** end of BltSessionInit ***/ /************************************************************************************//** ** \brief Terminates the firmware update session. This function is typically called ** once at the end of the firmware update. ** ****************************************************************************************/ LIBOPENBLT_EXPORT void BltSessionTerminate(void) { /* Terminate the session. */ SessionTerminate(); } /*** end of BltSessionTerminate ***/ /************************************************************************************//** ** \brief Starts the firmware update session. This is were the library attempts to ** activate and connect with the bootloader running on the target, through ** the transport layer that was specified during the session's initialization. ** \return BLT_RESULT_OK if successful, BLT_RESULT_ERROR_xxx otherwise. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltSessionStart(void) { uint32_t result = BLT_RESULT_ERROR_GENERIC; /* Start the session. */ if (SessionStart()) { result = BLT_RESULT_OK; } /* Give the result back to the caller. */ return result; } /*** end of BltSessionStart ***/ /************************************************************************************//** ** \brief Stops the firmware update session. This is there the library disconnects ** the transport layer as well. ** ****************************************************************************************/ LIBOPENBLT_EXPORT void BltSessionStop(void) { /* Stop the session. */ SessionStop(); } /*** end of BltSessionStop ***/ /************************************************************************************//** ** \brief Requests the target to erase the specified range of memory on the target. ** Note that the target automatically aligns this to the erasable memory ** block sizes. This typically results in more memory being erased than the ** range that was specified here. Refer to the target implementation for ** details. ** \param address The starting memory address for the erase operation. ** \param len The total number of bytes to erase from memory. ** \return BLT_RESULT_OK if successful, BLT_RESULT_ERROR_xxx otherwise. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltSessionClearMemory(uint32_t address, uint32_t len) { uint32_t result = BLT_RESULT_ERROR_GENERIC; /* Check parameters. */ assert(len > 0); /* Only continue if the parameters are valid. */ if (len > 0) { /* Pass the request on to the session module. */ if (SessionClearMemory(address, len)) { result = BLT_RESULT_OK; } } /* Give the result back to the caller. */ return result; } /*** end of BltSessionClearMemory ***/ /************************************************************************************//** ** \brief Requests the target to program the specified data to memory. Note that it ** is the responsibility of the application to make sure the memory range was ** erased beforehand. ** \param address The starting memory address for the write operation. ** \param len The number of bytes in the data buffer that should be written. ** \param data Pointer to the byte array with data to write. ** \return BLT_RESULT_OK if successful, BLT_RESULT_ERROR_xxx otherwise. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltSessionWriteData(uint32_t address, uint32_t len, uint8_t const * data) { uint32_t result = BLT_RESULT_ERROR_GENERIC; /* Check parameters. */ assert(data != NULL); assert(len > 0); /* Only continue if the parameters are valid. */ if ( (data != NULL) && (len > 0) ) /*lint !e774 */ { /* Pass the request on to the session module. */ if (SessionWriteData(address, len, data)) { result = BLT_RESULT_OK; } } /* Give the result back to the caller. */ return result; } /*** end of BltSessionWriteData ***/ /************************************************************************************//** ** \brief Requests the target to upload the specified range from memory and store its ** contents in the specified data buffer. ** \param address The starting memory address for the read operation. ** \param len The number of bytes to upload from the target and store in the data ** buffer. ** \param data Pointer to the byte array where the uploaded data should be stored. ** \return BLT_RESULT_OK if successful, BLT_RESULT_ERROR_xxx otherwise. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltSessionReadData(uint32_t address, uint32_t len, uint8_t * data) { uint32_t result = BLT_RESULT_ERROR_GENERIC; /* Check parameters. */ assert(data != NULL); assert(len > 0); /* Only continue if the parameters are valid. */ if ( (data != NULL) && (len > 0) ) /*lint !e774 */ { /* Pass the request on to the session module. */ if (SessionReadData(address, len, data)) { result = BLT_RESULT_OK; } } /* Give the result back to the caller. */ return result; } /*** end of BltSessionReadData ***/ /**************************************************************************************** * F I R M W A R E D A T A ****************************************************************************************/ /************************************************************************************//** ** \brief Initializes the firmware data module for a specified firmware file parser. ** \param parserType The firmware file parser to use in this module. It should be a ** BLT_FIRMWARE_PARSER_xxx value. ** ****************************************************************************************/ LIBOPENBLT_EXPORT void BltFirmwareInit(uint32_t parserType) { tFirmwareParser const * firmwareParser = NULL; /* Verify parameters. */ assert(parserType == BLT_FIRMWARE_PARSER_SRECORD); /* Set the parser pointer. */ if (parserType == BLT_FIRMWARE_PARSER_SRECORD) /*lint !e774 */ { firmwareParser = SRecParserGetParser(); } /* Initialize the firmware data module by linking the firmware file parser. */ FirmwareInit(firmwareParser); } /*** end of BltFirmwareInit ***/ /************************************************************************************//** ** \brief Terminates the firmware data module. Typically called at the end of the ** program when the firmware data module is no longer needed. ** ****************************************************************************************/ LIBOPENBLT_EXPORT void BltFirmwareTerminate(void) { /* Terminate the firmware data module. */ FirmwareTerminate(); } /*** end of BltFirmwareTerminate ***/ /************************************************************************************//** ** \brief Loads firmware data from the specified file using the firmware file parser ** that was specified during the initialization of this module. ** \param firmwareFile Filename of the firmware file to load. ** \param addressOffset Optional memory address offset to add when loading the ** firmware data from the file. This is typically only useful when loading ** firmware data from a binary formatted firmware file. ** \return BLT_RESULT_OK if successful, BLT_RESULT_ERROR_xxx otherwise. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltFirmwareLoadFromFile(char const * firmwareFile, uint32_t addressOffset) { uint32_t result = BLT_RESULT_ERROR_GENERIC; /* Verify parameters. */ assert(firmwareFile != NULL); /* Only continue if parameters are valid. */ if (firmwareFile != NULL) /*lint !e774 */ { /* Pass the request on to the firmware data module. */ if (FirmwareLoadFromFile(firmwareFile, addressOffset)) { result = BLT_RESULT_OK; } } /* Give the result back to the caller. */ return result; } /*** end of BltFirmwareLoadFromFile ***/ /************************************************************************************//** ** \brief Writes firmware data to the specified file using the firmware file parser ** that was specified during the initialization of this module. ** \param firmwareFile Filename of the firmware file to write to. ** \return BLT_RESULT_OK if successful, BLT_RESULT_ERROR_xxx otherwise. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltFirmwareSaveToFile(char const * firmwareFile) { uint32_t result = BLT_RESULT_ERROR_GENERIC; /* Verify parameters. */ assert(firmwareFile != NULL); /* Only continue if parameters are valid. */ if (firmwareFile != NULL) /*lint !e774 */ { /* Pass the request on to the firmware data module. */ if (FirmwareSaveToFile(firmwareFile)) { result = BLT_RESULT_OK; } } /* Give the result back to the caller. */ return result; } /*** end of BltFirmwareSaveToFile ***/ /************************************************************************************//** ** \brief Obtains the number of firmware data segments that are currently present ** in the firmware data module. ** \return The total number of segments. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltFirmwareGetSegmentCount(void) { /* Pass the request on to the firmware data module. */ return FirmwareGetSegmentCount(); } /*** end of BltFirmwareGetSegmentCount ***/ /************************************************************************************//** ** \brief Obtains the contents of the firmware data segment that was specified by the ** index parameter. ** \param idx The segment index. It should be a value greater or equal to zero and ** smaller than the value returned by \ref BltFirmwareGetSegmentCount. ** \param address Pointer to where the segment's base address will be written to. ** \param len Pointer to where the segment's length will be written to. ** \return Pointer to the segment data if successful, NULL otherwise. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint8_t * BltFirmwareGetSegment(uint32_t idx, uint32_t * address, uint32_t * len) { uint8_t * result = NULL; tFirmwareSegment *segmentPtr; /* Verify parameters. Note that it is okay for the data parameter to be NULL. */ assert(idx < FirmwareGetSegmentCount()); assert(address != NULL); assert(len != NULL); /* Only continue if parameters are valid. */ if ((address != NULL) && (len != NULL) && (idx < FirmwareGetSegmentCount()) ) /*lint !e774 */ { /* Pass the request on to the firmware data module. */ segmentPtr = FirmwareGetSegment(idx); /* Process the result. */ if (segmentPtr != NULL) { *address = segmentPtr->base; *len = segmentPtr->length; result = segmentPtr->data; } } /* Give the result back to the caller. */ return result; } /*** end of BltFirmwareGetSegment ***/ /************************************************************************************//** ** \brief Adds data to the segments that are currently present in the firmware data ** module. If the data overlaps with already existing data, the existing data ** gets overwritten. The size of a segment is automatically adjusted or a new ** segment gets created, if necessary. ** \param address Base address of the firmware data. ** \param len Number of bytes to add. ** \param data Pointer to array with data bytes that should be added. ** \return BLT_RESULT_OK if successful, BLT_RESULT_ERROR_xxx otherwise. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltFirmwareAddData(uint32_t address, uint32_t len, uint8_t const * data) { uint32_t result = BLT_RESULT_ERROR_GENERIC; /* Verify parameters. */ assert(len > 0); assert(data != NULL); /* Only continue if parameters are valid. */ if ( (len > 0) && (data != NULL) ) /*lint !e774 */ { /* Pass the request on to the firmware data module. */ if (FirmwareAddData(address, len, data)) { result = BLT_RESULT_OK; } } /* Give the result back to the caller. */ return result; } /*** end of BltFirmwareAddData ***/ /************************************************************************************//** ** \brief Removes data from the segments that are currently present in the firmware ** data module. The size of a segment is automatically adjusted or removed, if ** necessary. ** \param address Base address of the firmware data. ** \param len Number of bytes to remove. ** \return BLT_RESULT_OK if successful, BLT_RESULT_ERROR_xxx otherwise. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltFirmwareRemoveData(uint32_t address, uint32_t len) { uint32_t result = BLT_RESULT_ERROR_GENERIC; /* Verify parameters. */ assert(len > 0); /* Only continue if parameters are valid. */ if (len > 0) { /* Pass the request on to the firmware data module. */ if (FirmwareRemoveData(address, len)) { result = BLT_RESULT_OK; } } /* Give the result back to the caller. */ return result; } /*** end of BltFirmwareRemoveData ***/ /************************************************************************************//** ** \brief Clears all data and segments that are currently present in the firmware ** data module. ** ****************************************************************************************/ LIBOPENBLT_EXPORT void BltFirmwareClearData(void) { /* Pass the request on to the firmware data module. */ FirmwareClearData(); } /*** end of BltFirmwareClearData ***/ /**************************************************************************************** * G E N E R I C U T I L I T I E S ****************************************************************************************/ /************************************************************************************//** ** \brief Calculates a 16-bit CRC value over the specified data. ** \param data Array with bytes over which the CRC16 should be calculated. ** \param len Number of bytes in the data array. ** \return The 16-bit CRC value. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint16_t BltUtilCrc16Calculate(uint8_t const * data, uint32_t len) { uint16_t result = 0; /* Check parameters. */ assert(data != NULL); assert(len > 0); /* Only continue if parameters are valid. */ if ( (data != NULL) && (len > 0) ) /*lint !e774 */ { /* Perform checksum calculation. */ result = UtilChecksumCrc16Calculate(data, len); } /* Give the result back to the caller. */ return result; } /*** end of BltUtilCrc16Calculate ***/ /************************************************************************************//** ** \brief Calculates a 32-bit CRC value over the specified data. ** \param data Array with bytes over which the CRC32 should be calculated. ** \param len Number of bytes in the data array. ** \return The 32-bit CRC value. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltUtilCrc32Calculate(uint8_t const * data, uint32_t len) { uint32_t result = 0; /* Check parameters. */ assert(data != NULL); assert(len > 0); /* Only continue if parameters are valid. */ if ( (data != NULL) && (len > 0) ) /*lint !e774 */ { /* Perform checksum calculation. */ result = UtilChecksumCrc32Calculate(data, len); } /* Give the result back to the caller. */ return result; } /*** end of BltUtilCrc32Calculate ***/ /************************************************************************************//** ** \brief Get the system time in milliseconds. ** \return Time in milliseconds. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltUtilTimeGetSystemTime(void) { uint32_t result; /* Pass the request on to the utility module. */ result = UtilTimeGetSystemTimeMs(); /* Give the result back to the caller. */ return result; } /*** end of BltUtilTimeGetSystemTime ***/ /************************************************************************************//** ** \brief Performs a delay of the specified amount of milliseconds. ** \param delay Delay time in milliseconds. ** ****************************************************************************************/ LIBOPENBLT_EXPORT void BltUtilTimeDelayMs(uint16_t delay) { /* Pass the request on to the utility module. */ UtilTimeDelayMs(delay); } /*** end of BltUtilTimeDelayMs ***/ /************************************************************************************//** ** \brief Encrypts the len-bytes in the specified data-array, using the specified ** 256-bit (32 bytes) key. The results are written back into the same array. ** \param data Pointer to the byte array with data to encrypt. The encrypted bytes ** are stored in the same array. ** \param len The number of bytes in the data-array to encrypt. It must be a multiple ** of 16, as this is the AES256 minimal block size. ** \param key The 256-bit encryption key as a array of 32 bytes. ** \return BLT_RESULT_OK if successful, BLT_RESULT_ERROR_xxx otherwise. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltUtilCryptoAes256Encrypt(uint8_t * data, uint32_t len, uint8_t const * key) { uint32_t result = BLT_RESULT_ERROR_GENERIC; /* Check parameters */ assert(data != NULL); assert(key != NULL); /* Only continue with valid parameters. Also add a block size check for 'len'. */ if ( (data != NULL) && (key != NULL) && ((len % 16u) == 0) ) /*lint !e774 */ { /* Pass the request on to the utility module. */ if (UtilCryptoAes256Encrypt(data, len, key)) { result = BLT_RESULT_OK; } } /* Give the result back to the caller. */ return result; } /*** end of BltUtilCryptoAes256Encrypt ***/ /************************************************************************************//** ** \brief Decrypts the len-bytes in the specified data-array, using the specified 256- ** bit (32 bytes) key. The results are written back into the same array. ** \param data Pointer to the byte array with data to decrypt. The decrypted bytes ** are stored in the same array. ** \param len The number of bytes in the data-array to decrypt. It must be a multiple ** of 16, as this is the AES256 minimal block size. ** \param key The 256-bit decryption key as a array of 32 bytes. ** \return BLT_RESULT_OK if successful, BLT_RESULT_ERROR_xxx otherwise. ** ****************************************************************************************/ LIBOPENBLT_EXPORT uint32_t BltUtilCryptoAes256Decrypt(uint8_t * data, uint32_t len, uint8_t const * key) { uint32_t result = BLT_RESULT_ERROR_GENERIC; /* Check parameters */ assert(data != NULL); assert(key != NULL); /* Only continue with valid parameters. Also add a block size check for 'len'. */ if ( (data != NULL) && (key != NULL) && ((len % 16u) == 0) ) /*lint !e774 */ { /* Pass the request on to the utility module. */ if (UtilCryptoAes256Decrypt(data, len, key)) { result = BLT_RESULT_OK; } } /* Give the result back to the caller. */ return result; } /*** end of BltUtilCryptoAes256Decrypt ***/ /*********************************** end of openblt.c **********************************/