third_party/ti_simplelink_sdk/mcuboot/flash_map_backend.c - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  * Copyright (c) 2018 Nordic Semiconductor ASA
  * Copyright (c) 2020 Cypress Semiconductor Corporation
  * Copyright (c) 2021 Texas Instruments
  *
  * SPDX-License-Identifier: Apache-2.0
  */
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 /*******************************************************************************/

 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>

 #include "flash_map_backend.h"
 #include "mcuboot_config/mcuboot_config.h"
 #include <sysflash/sysflash.h>

 #include "bootutil/bootutil_log.h"

 // clang-format off
 #include <ti/devices/DeviceFamily.h>
 #include DeviceFamily_constructPath(driverlib/flash.h)

 #ifndef DeviceFamily_CC23X0R5
 #include DeviceFamily_constructPath(driverlib/vims.h)
 #endif
 // clang-format on

 #ifdef TI_BOOT_USE_EXTERNAL_FLASH
 #include <ext_flash.h>
 #endif /* TI_BOOT_USE_EXTERNAL_FLASH */

 #define FLASH_BASE_ADDRESS 0

 #ifdef DeviceFamily_CC23X0R5
 /* Remap driverlib API names that changed only for cc23x0
  */
 #define FlashSectorSizeGet FlashGetSectorSize
 #define FlashSectorErase FlashEraseSector
 #endif

 #define FLASH_ERASE_VALUE 0xFF

 /* XXX: Someone defined assert backwards in this file. We've changed it back to
  * not conflict with the GCC assert.

 #define assert(x) if(x) {BOOT_LOG_ERR("assert: %s line %d", __FILE__, __LINE__);}
 */
 #include <assert.h>

 #ifdef TI_FLASH_MAP_EXT_DESC
 /* Nothing to be there when external FlashMap Descriptors are used */
 #else
 static const struct flash_area bootloader = { .fa_id        = FLASH_AREA_BOOTLOADER,
                                               .fa_device_id = FLASH_DEVICE_INTERNAL_FLASH,
                                               .fa_off       = BOOTLOADER_BASE_ADDRESS,
                                               .fa_size      = BOOT_BOOTLOADER_SIZE };

 static const struct flash_area primary_1 = { .fa_id        = FLASH_AREA_IMAGE_PRIMARY(0),
                                              .fa_device_id = FLASH_DEVICE_INTERNAL_FLASH,
                                              .fa_off       = BOOT_PRIMARY_1_BASE_ADDRESS,
                                              .fa_size      = BOOT_PRIMARY_1_SIZE };

 #if (MCUBOOT_IMAGE_NUMBER == 2)
 static const struct flash_area primary_2 = { .fa_id        = FLASH_AREA_IMAGE_PRIMARY(1),
                                              .fa_device_id = FLASH_DEVICE_INTERNAL_FLASH,
                                              .fa_off       = BOOT_PRIMARY_2_BASE_ADDRESS,
                                              .fa_size      = BOOT_PRIMARY_2_SIZE };
 #endif

 static const struct flash_area secondary_1         = { .fa_id        = FLASH_AREA_IMAGE_SECONDARY(0),
 #ifndef TI_BOOT_USE_EXTERNAL_FLASH
                                                        .fa_device_id = FLASH_DEVICE_INTERNAL_FLASH,
 #else
                                                .fa_device_id = FLASH_DEVICE_EXTERNAL_FLASH(0),
 #endif
                                                        .fa_off       = BOOT_SECONDARY_1_BASE_ADDRESS,
                                                        .fa_size      = BOOT_SECONDARY_1_SIZE };

 #if (MCUBOOT_IMAGE_NUMBER == 2)
 static const struct flash_area secondary_2         = { .fa_id        = FLASH_AREA_IMAGE_SECONDARY(1),
 #ifndef TI_BOOT_USE_EXTERNAL_FLASH
                                                        .fa_device_id = FLASH_DEVICE_INTERNAL_FLASH,
 #else
                                                .fa_device_id = FLASH_DEVICE_EXTERNAL_FLASH(0),
 #endif
                                                        .fa_off       = BOOT_SECONDARY_2_BASE_ADDRESS,
                                                        .fa_size      = BOOT_SECONDARY_2_SIZE };
 #endif
 #endif

 #if (MCUBOOT_IMAGE_NUMBER == 2) && (DeviceFamily_PARENT != DeviceFamily_PARENT_CC13X4_CC26X3_CC26X4)
 #error "MCUBOOT_IMAGE_NUMBER == 2 for current device not supported"
 #endif

 #if (MCUBOOT_IMAGE_NUMBER > 2)
 #error "More than 2 images not supported"
 #endif

 #ifdef MCUBOOT_SWAP_USING_SCRATCH
 static struct flash_area scratch = {
 #error "MCUBOOT_SWAP_USING_SCRATCH not supported"
 };
 #endif

 #ifdef TI_FLASH_MAP_EXT_DESC
 /* Use external Flash Map Descriptors */
 extern struct flash_area * boot_area_descs[];
 #else
 static const struct flash_area * boot_area_descs[] = { &bootloader, &primary_1,   &secondary_1,
 #if (MCUBOOT_IMAGE_NUMBER == 2) /* if dual-image */
                                                        &primary_2,  &secondary_2,
 #endif
 #ifdef MCUBOOT_SWAP_USING_SCRATCH
                                                        &scratch,
 #endif
                                                        NULL };
 #endif

 #ifdef TI_BOOT_USE_EXTERNAL_FLASH
 static bool extFlashStatus = false;
 #endif

 #ifndef DeviceFamily_CC23X0R5
 /* Prepares system for a write to flash */
 static uint8_t disableCache(void)
 {
     uint8_t mode = VIMSModeGet(VIMS_BASE);

     VIMSLineBufDisable(VIMS_BASE);

     if (mode != VIMS_MODE_DISABLED)
     {
         VIMSModeSet(VIMS_BASE, VIMS_MODE_DISABLED);
         while (VIMSModeGet(VIMS_BASE) != VIMS_MODE_DISABLED)
             ;
     }

     return (mode);
 }

 /*
  *  ======== restoreFlashCache ========
  */
 static void enableCache(uint8_t mode)
 {
     if (mode != VIMS_MODE_DISABLED)
     {
         VIMSModeSet(VIMS_BASE, VIMS_MODE_ENABLED);
     }

     VIMSLineBufEnable(VIMS_BASE);
 }
 #endif

 /* Returns device flash start based on supported fa_id */
 int flash_device_base(uint8_t fd_id, uintptr_t * ret)
 {
     if ((fd_id != FLASH_DEVICE_INTERNAL_FLASH) || (fd_id != FLASH_DEVICE_EXTERNAL_FLASH(0)))
     {
         BOOT_LOG_ERR("invalid flash ID %d", fd_id);
         return -1;
     }
     *ret = FLASH_BASE_ADDRESS;
     return 0;
 }

 /* Opens the area for use. id is one of the `fa_id`s */
 int flash_area_open(uint8_t id, const struct flash_area ** fa)
 {
     int ret    = -1;
     uint32_t i = 0;

     while (NULL != boot_area_descs[i])
     {
         if (id == boot_area_descs[i]->fa_id)
         {
             *fa = boot_area_descs[i];

 #ifdef TI_BOOT_USE_EXTERNAL_FLASH
             if (boot_area_descs[i]->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
             {
                 if (!extFlashStatus)
                 {
                     ret = !extFlashOpen();
                     // if the external flash has been opened, update the status
                     if (ret == 0)
                     {
                         extFlashStatus = true;
                     }
                 }
                 else
                 {
                     ret = 0;
                 }
             }
             else
             {
                 ret = 0;
             }
 #else
             ret = 0;
 #endif /* TI_BOOT_USE_EXTERNAL_FLASH */
             break;
         }
         i++;
     }
     return ret;
 }

 void flash_area_close(const struct flash_area * fa)
 {
 #ifdef TI_BOOT_USE_EXTERNAL_FLASH
     if (fa->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
     {
         if (extFlashStatus)
         {
             extFlashClose();
             extFlashStatus = false;
         }
     }
 #endif /* TI_BOOT_USE_EXTERNAL_FLASH */

     (void) fa; /* Nothing to do there */
 }

 /*
  * Reads `len` bytes of flash memory at `off` to the buffer at `dst`
  */
 int flash_area_read(const struct flash_area * fa, uint32_t off, void * dst, uint32_t len)
 {
     int rc = 0;
     size_t addr;

     /* convert to absolute address inside a device*/
     addr = fa->fa_off + off;

     /* check if read is within bounds */
     assert((addr + len) <= (fa->fa_off + fa->fa_size));

     if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
     {
         /* flash read by simple memory copying */
         memcpy((void *) dst, (const void *) addr, (size_t) len);
     }
 #ifdef TI_BOOT_USE_EXTERNAL_FLASH
     else if (fa->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
     {
         /* verify that flash is open */
         if (!extFlashStatus)
         {
             rc = flash_area_open(fa->fa_id, &fa);
             if (rc != 0)
             {
                 return rc;
             }
         }
         else
         {
             extFlashClose();
             rc = !extFlashOpen();
             // if the external flash has been opened, update the status
             if (rc == 0)
             {
                 extFlashStatus = true;
             }
         }

         /* Read whole metadata header */
         rc = !extFlashRead(addr, (size_t) len, (void *) dst);
     }
 #endif /* TI_BOOT_USE_EXTERNAL_FLASH */
     else
     {
         /* incorrect/non-existing flash device id */
         rc = -1;
     }

     if (rc != 0)
     {
         BOOT_LOG_ERR("Flash area read error, rc = %d", (int) rc);
     }
     return rc;
 }

 /*
  * Writes `len` bytes of flash memory at `off` from the buffer at `src`
  */
 int flash_area_write(const struct flash_area * fa, uint32_t off, const void * src, uint32_t len)
 {
     int rc = -1;
     size_t write_start_addr;

     /* convert to absolute address inside a device*/
     write_start_addr = fa->fa_off + off;

     /* check if read is within bounds */
     assert((write_start_addr + len) <= (fa->fa_off + fa->fa_size));

     if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
     {
         uint32_t flashStat;
 #ifndef DeviceFamily_CC23X0R5
         uint8_t cacheState = disableCache();
 #endif

         flashStat = FlashProgram((uint8_t *) src, write_start_addr, len);
         if (flashStat == FAPI_STATUS_SUCCESS)
         {
             rc = 0;
         }

 #ifndef DeviceFamily_CC23X0R5
         enableCache(cacheState);
 #endif
     }
 #ifdef TI_BOOT_USE_EXTERNAL_FLASH
     else if (fa->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
     {
         /* verify that flash is open */
         if (!extFlashStatus)
         {
             rc = flash_area_open(fa->fa_id, &fa);
             if (rc != 0)
             {
                 return rc;
             }
         }

         rc = !extFlashWrite(write_start_addr, (size_t) len, (uint8_t *) src);
     }
 #endif /* TI_BOOT_USE_EXTERNAL_FLASH */
     else
     {
         /* incorrect/non-existing flash device id */
         rc = -1;
     }

     return rc;
 }

 /*< Erases `len` bytes of flash memory at `off` */
 int flash_area_erase(const struct flash_area * fa, uint32_t off, uint32_t len)
 {
     int rc = -1;
     size_t erase_start_addr;

     /* convert to absolute address inside a device*/
     erase_start_addr = fa->fa_off + off;

     /* check if read is within bounds */
     assert((erase_start_addr + len) <= (fa->fa_off + fa->fa_size));

     if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
     {
         uint8_t flashStat;
         uint32_t pageAddr;
         uint32_t sectorSize = FlashSectorSizeGet();

         assert(0 == erase_start_addr % sectorSize);

 #ifndef DeviceFamily_CC23X0R5
         uint8_t cacheState = disableCache();
 #endif

         for (pageAddr = erase_start_addr; pageAddr < erase_start_addr + len; pageAddr += sectorSize)
         {
             flashStat = FlashSectorErase(pageAddr);
             if (flashStat != FAPI_STATUS_SUCCESS)
             {
 #ifndef DeviceFamily_CC23X0R5
                 enableCache(cacheState);
 #endif
                 return rc;
             }
         }

 #ifndef DeviceFamily_CC23X0R5
         enableCache(cacheState);
 #endif
         rc = 0;
     }
 #ifdef TI_BOOT_USE_EXTERNAL_FLASH
     else if (fa->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
     {
         assert(0 == erase_start_addr % EXT_FLASH_PAGE_SIZE);

         /* verify that flash is open */
         if (!extFlashStatus)
         {
             rc = flash_area_open(fa->fa_id, &fa);
             if (rc != 0)
             {
                 return rc;
             }
         }
         rc = !extFlashErase(erase_start_addr, (size_t) len);
     }
 #endif /* TI_BOOT_USE_EXTERNAL_FLASH */
     else
     {
         /* incorrect/non-existing flash device id */
         rc = -1;
     }
     return (int) rc;
 }

 /*< Returns this `flash_area`s alignment */
 size_t flash_area_align(const struct flash_area * fa)
 {
     int ret = -1;
     if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
     {
         ret = FlashSectorSizeGet();
     }
 #ifdef TI_BOOT_USE_EXTERNAL_FLASH
     if (fa->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
     {
         ret = EXT_FLASH_PAGE_SIZE;
     }
 #endif /* TI_BOOT_USE_EXTERNAL_FLASH */
     else
     {
         /* incorrect/non-existing flash device id */
         ret = -1;
     }
     return ret;
 }

 #ifndef MCUBOOT_USE_FLASH_AREA_GET_SECTORS
 /*< Initializes an array of flash_area elements for the slot's sectors */
 int flash_area_to_sectors(int idx, int * cnt, struct flash_area * fa)
 {
     int rc = 0;

     if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
     {
         (void) idx;
         (void) cnt;
         rc = 0;
     }
     else
     {
         /* incorrect/non-existing flash device id */
         rc = -1;
     }
     return rc;
 }
 #endif

 /*
  * This depends on the mappings defined in sysflash.h.
  * MCUBoot uses continuous numbering for the primary slot, the secondary slot,
  * and the scratch while zephyr might number it differently.
  */
 int flash_area_id_from_multi_image_slot(int image_index, int slot)
 {
     switch (slot)
     {
     case 0:
         return FLASH_AREA_IMAGE_PRIMARY(image_index);
     case 1:
         return FLASH_AREA_IMAGE_SECONDARY(image_index);
     case 2:
         return FLASH_AREA_IMAGE_SCRATCH;
     }

     return -1; /* flash_area_open will fail on that */
 }

 int flash_area_id_from_image_slot(int slot)
 {
     return flash_area_id_from_multi_image_slot(0, slot);
 }

 int flash_area_id_to_multi_image_slot(int image_index, int area_id)
 {
     if (area_id == FLASH_AREA_IMAGE_PRIMARY(image_index))
     {
         return 0;
     }
     if (area_id == FLASH_AREA_IMAGE_SECONDARY(image_index))
     {
         return 1;
     }

     return -1;
 }

 int flash_area_id_to_image_slot(int area_id)
 {
     return flash_area_id_to_multi_image_slot(0, area_id);
 }

 uint8_t flash_area_erased_val(const struct flash_area * fap)
 {
     int ret = 0;

     if ((fap->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH) || (fap->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0)))
     {
         ret = FLASH_ERASE_VALUE;
     }
     else
     {
         assert(false);
     }

     return ret;
 }

 int flash_area_read_is_empty(const struct flash_area * fa, uint32_t off, void * dst, uint32_t len)
 {
     uint8_t * mem_dest;
     int rc;

     mem_dest = (uint8_t *) dst;
     rc       = flash_area_read(fa, off, dst, len);
     if (rc)
     {
         return -1;
     }

     for (uint8_t i = 0; i < len; i++)
     {
         if (mem_dest[i] != flash_area_erased_val(fa))
         {
             return 0;
         }
     }
     return 1;
 }

 #ifdef MCUBOOT_USE_FLASH_AREA_GET_SECTORS
 int flash_area_get_sectors(int idx, uint32_t * cnt, struct flash_sector * ret)
 {
     int rc                 = 0;
     uint32_t i             = 0;
     struct flash_area * fa = NULL;

     while (NULL != boot_area_descs[i])
     {
         if (idx == boot_area_descs[i]->fa_id)
         {
             fa = (struct flash_area *) boot_area_descs[i];
             break;
         }
         i++;
     }

     if (NULL != boot_area_descs[i])
     {
         size_t sector_size = 0;

         if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
         {
             sector_size = FlashSectorSizeGet();
         }
 #ifdef TI_BOOT_USE_EXTERNAL_FLASH
         else if (fa->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
         {
             sector_size = EXT_FLASH_PAGE_SIZE;
         }
 #endif
         else
         {
             rc = -1;
         }

         if (0 == rc)
         {
             uint32_t addr    = 0;
             size_t sectors_n = 0;

             sectors_n = (fa->fa_size + (sector_size - 1)) / sector_size;
             assert(sectors_n <= *cnt);

             addr = fa->fa_off;
             for (i = 0; i < sectors_n; i++)
             {
                 ret[i].fs_size = sector_size;
                 ret[i].fs_off  = addr;
                 addr += sector_size;
             }

             *cnt = sectors_n;
         }
     }
     else
     {
         rc = -1;
     }

     return rc;
 }
 #endif

 #ifdef MCUBOOT_HW_ROLLBACK_PROT

 #ifdef DeviceFamily_CC23X0R5

 #define FLASH_WRITE_PROTECT 0

 /*
  * There is no implementation of FlashProtectionSet() in cc23x0 driverlib.
  * For now it was decided to implement this feature directly in this module.
  *
  */

 static void FlashProtectionSet(uint32_t address, uint32_t mode)
 {
     uint32_t sector_number;
     uint32_t sector_size = FlashSectorSizeGet();
     uint32_t mask;

     /*
      * Check that address is within expected range, as in cc23x0r5
      * only the first 32 sectors can be individually locked.
      */
     if ((address >= (FLASH_MAIN_BASE + (32 * sector_size))) || (0 != (address & (sector_size - 1))))
     {
         return;
     }

     sector_number = (address - FLASH_MAIN_BASE) / sector_size;
     mask          = 1 << sector_number;

     HWREG(VIMS_BASE + VIMS_O_WEPRA) &= ~mask;
 }
 #endif

 void flash_area_lock(const struct flash_area * fa)
 {
     size_t addr;

     /* convert to absolute address inside a device*/
     addr = fa->fa_off;

     if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
     {
         FlashProtectionSet(addr, FLASH_WRITE_PROTECT);
     }
 }
 #endif
	/*
	* Copyright (c) 2018 Nordic Semiconductor ASA
	* Copyright (c) 2020 Cypress Semiconductor Corporation
	* Copyright (c) 2021 Texas Instruments
	*
	* SPDX-License-Identifier: Apache-2.0
	*/
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	/*******************************************************************************/

	#include <stdbool.h>
	#include <stdint.h>
	#include <stdio.h>
	#include <string.h>

	#include "flash_map_backend.h"
	#include "mcuboot_config/mcuboot_config.h"
	#include <sysflash/sysflash.h>

	#include "bootutil/bootutil_log.h"

	// clang-format off
	#include <ti/devices/DeviceFamily.h>
	#include DeviceFamily_constructPath(driverlib/flash.h)

	#ifndef DeviceFamily_CC23X0R5
	#include DeviceFamily_constructPath(driverlib/vims.h)
	#endif
	// clang-format on

	#ifdef TI_BOOT_USE_EXTERNAL_FLASH
	#include <ext_flash.h>
	#endif /* TI_BOOT_USE_EXTERNAL_FLASH */

	#define FLASH_BASE_ADDRESS 0

	#ifdef DeviceFamily_CC23X0R5
	/* Remap driverlib API names that changed only for cc23x0
	*/
	#define FlashSectorSizeGet FlashGetSectorSize
	#define FlashSectorErase FlashEraseSector
	#endif

	#define FLASH_ERASE_VALUE 0xFF

	/* XXX: Someone defined assert backwards in this file. We've changed it back to
	* not conflict with the GCC assert.

	#define assert(x) if(x) {BOOT_LOG_ERR("assert: %s line %d", __FILE__, __LINE__);}
	*/
	#include <assert.h>

	#ifdef TI_FLASH_MAP_EXT_DESC
	/* Nothing to be there when external FlashMap Descriptors are used */
	#else
	static const struct flash_area bootloader = { .fa_id = FLASH_AREA_BOOTLOADER,
	.fa_device_id = FLASH_DEVICE_INTERNAL_FLASH,
	.fa_off = BOOTLOADER_BASE_ADDRESS,
	.fa_size = BOOT_BOOTLOADER_SIZE };

	static const struct flash_area primary_1 = { .fa_id = FLASH_AREA_IMAGE_PRIMARY(0),
	.fa_device_id = FLASH_DEVICE_INTERNAL_FLASH,
	.fa_off = BOOT_PRIMARY_1_BASE_ADDRESS,
	.fa_size = BOOT_PRIMARY_1_SIZE };

	#if (MCUBOOT_IMAGE_NUMBER == 2)
	static const struct flash_area primary_2 = { .fa_id = FLASH_AREA_IMAGE_PRIMARY(1),
	.fa_device_id = FLASH_DEVICE_INTERNAL_FLASH,
	.fa_off = BOOT_PRIMARY_2_BASE_ADDRESS,
	.fa_size = BOOT_PRIMARY_2_SIZE };
	#endif

	static const struct flash_area secondary_1 = { .fa_id = FLASH_AREA_IMAGE_SECONDARY(0),
	#ifndef TI_BOOT_USE_EXTERNAL_FLASH
	.fa_device_id = FLASH_DEVICE_INTERNAL_FLASH,
	#else
	.fa_device_id = FLASH_DEVICE_EXTERNAL_FLASH(0),
	#endif
	.fa_off = BOOT_SECONDARY_1_BASE_ADDRESS,
	.fa_size = BOOT_SECONDARY_1_SIZE };

	#if (MCUBOOT_IMAGE_NUMBER == 2)
	static const struct flash_area secondary_2 = { .fa_id = FLASH_AREA_IMAGE_SECONDARY(1),
	#ifndef TI_BOOT_USE_EXTERNAL_FLASH
	.fa_device_id = FLASH_DEVICE_INTERNAL_FLASH,
	#else
	.fa_device_id = FLASH_DEVICE_EXTERNAL_FLASH(0),
	#endif
	.fa_off = BOOT_SECONDARY_2_BASE_ADDRESS,
	.fa_size = BOOT_SECONDARY_2_SIZE };
	#endif
	#endif

	#if (MCUBOOT_IMAGE_NUMBER == 2) && (DeviceFamily_PARENT != DeviceFamily_PARENT_CC13X4_CC26X3_CC26X4)
	#error "MCUBOOT_IMAGE_NUMBER == 2 for current device not supported"
	#endif

	#if (MCUBOOT_IMAGE_NUMBER > 2)
	#error "More than 2 images not supported"
	#endif

	#ifdef MCUBOOT_SWAP_USING_SCRATCH
	static struct flash_area scratch = {
	#error "MCUBOOT_SWAP_USING_SCRATCH not supported"
	};
	#endif

	#ifdef TI_FLASH_MAP_EXT_DESC
	/* Use external Flash Map Descriptors */
	extern struct flash_area * boot_area_descs[];
	#else
	static const struct flash_area * boot_area_descs[] = { &bootloader, &primary_1, &secondary_1,
	#if (MCUBOOT_IMAGE_NUMBER == 2) /* if dual-image */
	&primary_2, &secondary_2,
	#endif
	#ifdef MCUBOOT_SWAP_USING_SCRATCH
	&scratch,
	#endif
	NULL };
	#endif

	#ifdef TI_BOOT_USE_EXTERNAL_FLASH
	static bool extFlashStatus = false;
	#endif

	#ifndef DeviceFamily_CC23X0R5
	/* Prepares system for a write to flash */
	static uint8_t disableCache(void)
	{
	uint8_t mode = VIMSModeGet(VIMS_BASE);

	VIMSLineBufDisable(VIMS_BASE);

	if (mode != VIMS_MODE_DISABLED)
	{
	VIMSModeSet(VIMS_BASE, VIMS_MODE_DISABLED);
	while (VIMSModeGet(VIMS_BASE) != VIMS_MODE_DISABLED)
	;
	}

	return (mode);
	}

	/*
	* ======== restoreFlashCache ========
	*/
	static void enableCache(uint8_t mode)
	{
	if (mode != VIMS_MODE_DISABLED)
	{
	VIMSModeSet(VIMS_BASE, VIMS_MODE_ENABLED);
	}

	VIMSLineBufEnable(VIMS_BASE);
	}
	#endif

	/* Returns device flash start based on supported fa_id */
	int flash_device_base(uint8_t fd_id, uintptr_t * ret)
	{
	if ((fd_id != FLASH_DEVICE_INTERNAL_FLASH) \|\| (fd_id != FLASH_DEVICE_EXTERNAL_FLASH(0)))
	{
	BOOT_LOG_ERR("invalid flash ID %d", fd_id);
	return -1;
	}
	*ret = FLASH_BASE_ADDRESS;
	return 0;
	}

	/* Opens the area for use. id is one of the `fa_id`s */
	int flash_area_open(uint8_t id, const struct flash_area ** fa)
	{
	int ret = -1;
	uint32_t i = 0;

	while (NULL != boot_area_descs[i])
	{
	if (id == boot_area_descs[i]->fa_id)
	{
	*fa = boot_area_descs[i];

	#ifdef TI_BOOT_USE_EXTERNAL_FLASH
	if (boot_area_descs[i]->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
	{
	if (!extFlashStatus)
	{
	ret = !extFlashOpen();
	// if the external flash has been opened, update the status
	if (ret == 0)
	{
	extFlashStatus = true;
	}
	}
	else
	{
	ret = 0;
	}
	}
	else
	{
	ret = 0;
	}
	#else
	ret = 0;
	#endif /* TI_BOOT_USE_EXTERNAL_FLASH */
	break;
	}
	i++;
	}
	return ret;
	}

	void flash_area_close(const struct flash_area * fa)
	{
	#ifdef TI_BOOT_USE_EXTERNAL_FLASH
	if (fa->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
	{
	if (extFlashStatus)
	{
	extFlashClose();
	extFlashStatus = false;
	}
	}
	#endif /* TI_BOOT_USE_EXTERNAL_FLASH */

	(void) fa; /* Nothing to do there */
	}

	/*
	* Reads `len` bytes of flash memory at `off` to the buffer at `dst`
	*/
	int flash_area_read(const struct flash_area * fa, uint32_t off, void * dst, uint32_t len)
	{
	int rc = 0;
	size_t addr;

	/* convert to absolute address inside a device*/
	addr = fa->fa_off + off;

	/* check if read is within bounds */
	assert((addr + len) <= (fa->fa_off + fa->fa_size));

	if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
	{
	/* flash read by simple memory copying */
	memcpy((void ) dst, (const void ) addr, (size_t) len);
	}
	#ifdef TI_BOOT_USE_EXTERNAL_FLASH
	else if (fa->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
	{
	/* verify that flash is open */
	if (!extFlashStatus)
	{
	rc = flash_area_open(fa->fa_id, &fa);
	if (rc != 0)
	{
	return rc;
	}
	}
	else
	{
	extFlashClose();
	rc = !extFlashOpen();
	// if the external flash has been opened, update the status
	if (rc == 0)
	{
	extFlashStatus = true;
	}
	}

	/* Read whole metadata header */
	rc = !extFlashRead(addr, (size_t) len, (void *) dst);
	}
	#endif /* TI_BOOT_USE_EXTERNAL_FLASH */
	else
	{
	/* incorrect/non-existing flash device id */
	rc = -1;
	}

	if (rc != 0)
	{
	BOOT_LOG_ERR("Flash area read error, rc = %d", (int) rc);
	}
	return rc;
	}

	/*
	* Writes `len` bytes of flash memory at `off` from the buffer at `src`
	*/
	int flash_area_write(const struct flash_area * fa, uint32_t off, const void * src, uint32_t len)
	{
	int rc = -1;
	size_t write_start_addr;

	/* convert to absolute address inside a device*/
	write_start_addr = fa->fa_off + off;

	/* check if read is within bounds */
	assert((write_start_addr + len) <= (fa->fa_off + fa->fa_size));

	if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
	{
	uint32_t flashStat;
	#ifndef DeviceFamily_CC23X0R5
	uint8_t cacheState = disableCache();
	#endif

	flashStat = FlashProgram((uint8_t *) src, write_start_addr, len);
	if (flashStat == FAPI_STATUS_SUCCESS)
	{
	rc = 0;
	}

	#ifndef DeviceFamily_CC23X0R5
	enableCache(cacheState);
	#endif
	}
	#ifdef TI_BOOT_USE_EXTERNAL_FLASH
	else if (fa->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
	{
	/* verify that flash is open */
	if (!extFlashStatus)
	{
	rc = flash_area_open(fa->fa_id, &fa);
	if (rc != 0)
	{
	return rc;
	}
	}

	rc = !extFlashWrite(write_start_addr, (size_t) len, (uint8_t *) src);
	}
	#endif /* TI_BOOT_USE_EXTERNAL_FLASH */
	else
	{
	/* incorrect/non-existing flash device id */
	rc = -1;
	}

	return rc;
	}

	/< Erases `len` bytes of flash memory at `off` /
	int flash_area_erase(const struct flash_area * fa, uint32_t off, uint32_t len)
	{
	int rc = -1;
	size_t erase_start_addr;

	/* convert to absolute address inside a device*/
	erase_start_addr = fa->fa_off + off;

	/* check if read is within bounds */
	assert((erase_start_addr + len) <= (fa->fa_off + fa->fa_size));

	if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
	{
	uint8_t flashStat;
	uint32_t pageAddr;
	uint32_t sectorSize = FlashSectorSizeGet();

	assert(0 == erase_start_addr % sectorSize);

	#ifndef DeviceFamily_CC23X0R5
	uint8_t cacheState = disableCache();
	#endif

	for (pageAddr = erase_start_addr; pageAddr < erase_start_addr + len; pageAddr += sectorSize)
	{
	flashStat = FlashSectorErase(pageAddr);
	if (flashStat != FAPI_STATUS_SUCCESS)
	{
	#ifndef DeviceFamily_CC23X0R5
	enableCache(cacheState);
	#endif
	return rc;
	}
	}

	#ifndef DeviceFamily_CC23X0R5
	enableCache(cacheState);
	#endif
	rc = 0;
	}
	#ifdef TI_BOOT_USE_EXTERNAL_FLASH
	else if (fa->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
	{
	assert(0 == erase_start_addr % EXT_FLASH_PAGE_SIZE);

	/* verify that flash is open */
	if (!extFlashStatus)
	{
	rc = flash_area_open(fa->fa_id, &fa);
	if (rc != 0)
	{
	return rc;
	}
	}
	rc = !extFlashErase(erase_start_addr, (size_t) len);
	}
	#endif /* TI_BOOT_USE_EXTERNAL_FLASH */
	else
	{
	/* incorrect/non-existing flash device id */
	rc = -1;
	}
	return (int) rc;
	}

	/< Returns this `flash_area`s alignment /
	size_t flash_area_align(const struct flash_area * fa)
	{
	int ret = -1;
	if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
	{
	ret = FlashSectorSizeGet();
	}
	#ifdef TI_BOOT_USE_EXTERNAL_FLASH
	if (fa->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
	{
	ret = EXT_FLASH_PAGE_SIZE;
	}
	#endif /* TI_BOOT_USE_EXTERNAL_FLASH */
	else
	{
	/* incorrect/non-existing flash device id */
	ret = -1;
	}
	return ret;
	}

	#ifndef MCUBOOT_USE_FLASH_AREA_GET_SECTORS
	/< Initializes an array of flash_area elements for the slot's sectors /
	int flash_area_to_sectors(int idx, int * cnt, struct flash_area * fa)
	{
	int rc = 0;

	if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
	{
	(void) idx;
	(void) cnt;
	rc = 0;
	}
	else
	{
	/* incorrect/non-existing flash device id */
	rc = -1;
	}
	return rc;
	}
	#endif

	/*
	* This depends on the mappings defined in sysflash.h.
	* MCUBoot uses continuous numbering for the primary slot, the secondary slot,
	* and the scratch while zephyr might number it differently.
	*/
	int flash_area_id_from_multi_image_slot(int image_index, int slot)
	{
	switch (slot)
	{
	case 0:
	return FLASH_AREA_IMAGE_PRIMARY(image_index);
	case 1:
	return FLASH_AREA_IMAGE_SECONDARY(image_index);
	case 2:
	return FLASH_AREA_IMAGE_SCRATCH;
	}

	return -1; /* flash_area_open will fail on that */
	}

	int flash_area_id_from_image_slot(int slot)
	{
	return flash_area_id_from_multi_image_slot(0, slot);
	}

	int flash_area_id_to_multi_image_slot(int image_index, int area_id)
	{
	if (area_id == FLASH_AREA_IMAGE_PRIMARY(image_index))
	{
	return 0;
	}
	if (area_id == FLASH_AREA_IMAGE_SECONDARY(image_index))
	{
	return 1;
	}

	return -1;
	}

	int flash_area_id_to_image_slot(int area_id)
	{
	return flash_area_id_to_multi_image_slot(0, area_id);
	}

	uint8_t flash_area_erased_val(const struct flash_area * fap)
	{
	int ret = 0;

	if ((fap->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH) \|\| (fap->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0)))
	{
	ret = FLASH_ERASE_VALUE;
	}
	else
	{
	assert(false);
	}

	return ret;
	}

	int flash_area_read_is_empty(const struct flash_area * fa, uint32_t off, void * dst, uint32_t len)
	{
	uint8_t * mem_dest;
	int rc;

	mem_dest = (uint8_t *) dst;
	rc = flash_area_read(fa, off, dst, len);
	if (rc)
	{
	return -1;
	}

	for (uint8_t i = 0; i < len; i++)
	{
	if (mem_dest[i] != flash_area_erased_val(fa))
	{
	return 0;
	}
	}
	return 1;
	}

	#ifdef MCUBOOT_USE_FLASH_AREA_GET_SECTORS
	int flash_area_get_sectors(int idx, uint32_t * cnt, struct flash_sector * ret)
	{
	int rc = 0;
	uint32_t i = 0;
	struct flash_area * fa = NULL;

	while (NULL != boot_area_descs[i])
	{
	if (idx == boot_area_descs[i]->fa_id)
	{
	fa = (struct flash_area *) boot_area_descs[i];
	break;
	}
	i++;
	}

	if (NULL != boot_area_descs[i])
	{
	size_t sector_size = 0;

	if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
	{
	sector_size = FlashSectorSizeGet();
	}
	#ifdef TI_BOOT_USE_EXTERNAL_FLASH
	else if (fa->fa_device_id == FLASH_DEVICE_EXTERNAL_FLASH(0))
	{
	sector_size = EXT_FLASH_PAGE_SIZE;
	}
	#endif
	else
	{
	rc = -1;
	}

	if (0 == rc)
	{
	uint32_t addr = 0;
	size_t sectors_n = 0;

	sectors_n = (fa->fa_size + (sector_size - 1)) / sector_size;
	assert(sectors_n <= *cnt);

	addr = fa->fa_off;
	for (i = 0; i < sectors_n; i++)
	{
	ret[i].fs_size = sector_size;
	ret[i].fs_off = addr;
	addr += sector_size;
	}

	*cnt = sectors_n;
	}
	}
	else
	{
	rc = -1;
	}

	return rc;
	}
	#endif

	#ifdef MCUBOOT_HW_ROLLBACK_PROT

	#ifdef DeviceFamily_CC23X0R5

	#define FLASH_WRITE_PROTECT 0

	/*
	* There is no implementation of FlashProtectionSet() in cc23x0 driverlib.
	* For now it was decided to implement this feature directly in this module.
	*
	*/

	static void FlashProtectionSet(uint32_t address, uint32_t mode)
	{
	uint32_t sector_number;
	uint32_t sector_size = FlashSectorSizeGet();
	uint32_t mask;

	/*
	* Check that address is within expected range, as in cc23x0r5
	* only the first 32 sectors can be individually locked.
	*/
	if ((address >= (FLASH_MAIN_BASE + (32 * sector_size))) \|\| (0 != (address & (sector_size - 1))))
	{
	return;
	}

	sector_number = (address - FLASH_MAIN_BASE) / sector_size;
	mask = 1 << sector_number;

	HWREG(VIMS_BASE + VIMS_O_WEPRA) &= ~mask;
	}
	#endif

	void flash_area_lock(const struct flash_area * fa)
	{
	size_t addr;

	/* convert to absolute address inside a device*/
	addr = fa->fa_off;

	if (fa->fa_device_id == FLASH_DEVICE_INTERNAL_FLASH)
	{
	FlashProtectionSet(addr, FLASH_WRITE_PROTECT);
	}
	}
	#endif