| /* |
| * 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 <zephyr.h> |
| #include <flash.h> |
| |
| #include "target.h" |
| |
| #include <flash_map/flash_map.h> |
| #include <hal/hal_flash.h> |
| #include <sysflash/sysflash.h> |
| |
| #define BOOT_LOG_LEVEL BOOT_LOG_LEVEL_INFO |
| #include "bootutil/bootutil_log.h" |
| |
| extern struct device *boot_flash_device; |
| |
| /* |
| * For now, we only support one flash device. |
| * |
| * Pick a random device ID for it that's unlikely to collide with |
| * anything "real". |
| */ |
| #define FLASH_DEVICE_ID 100 |
| #define FLASH_DEVICE_BASE CONFIG_FLASH_BASE_ADDRESS |
| |
| #define FLASH_MAP_ENTRY_MAGIC 0xd00dbeef |
| |
| struct flash_map_entry { |
| const uint32_t magic; |
| const struct flash_area area; |
| unsigned int ref_count; |
| }; |
| |
| /* |
| * The flash area describes essentially the partition table of the |
| * flash. In this case, it starts with FLASH_AREA_IMAGE_0. |
| */ |
| static struct flash_map_entry part_map[] = { |
| { |
| .magic = FLASH_MAP_ENTRY_MAGIC, |
| .area = { |
| .fa_id = FLASH_AREA_IMAGE_0, |
| .fa_device_id = FLASH_DEVICE_ID, |
| .fa_off = FLASH_AREA_IMAGE_0_OFFSET, |
| .fa_size = FLASH_AREA_IMAGE_0_SIZE, |
| }, |
| }, |
| { |
| .magic = FLASH_MAP_ENTRY_MAGIC, |
| .area = { |
| .fa_id = FLASH_AREA_IMAGE_1, |
| .fa_device_id = FLASH_DEVICE_ID, |
| .fa_off = FLASH_AREA_IMAGE_1_OFFSET, |
| .fa_size = FLASH_AREA_IMAGE_1_SIZE, |
| }, |
| }, |
| { |
| .magic = FLASH_MAP_ENTRY_MAGIC, |
| .area = { |
| .fa_id = FLASH_AREA_IMAGE_SCRATCH, |
| .fa_device_id = FLASH_DEVICE_ID, |
| .fa_off = FLASH_AREA_IMAGE_SCRATCH_OFFSET, |
| .fa_size = FLASH_AREA_IMAGE_SCRATCH_SIZE, |
| }, |
| } |
| }; |
| |
| int flash_device_base(uint8_t fd_id, uintptr_t *ret) |
| { |
| if (fd_id != FLASH_DEVICE_ID) { |
| BOOT_LOG_ERR("invalid flash ID %d; expected %d", |
| fd_id, FLASH_DEVICE_ID); |
| return -EINVAL; |
| } |
| *ret = FLASH_DEVICE_BASE; |
| return 0; |
| } |
| |
| /* |
| * `open` a flash area. The `area` in this case is not the individual |
| * sectors, but describes the particular flash area in question. |
| */ |
| int flash_area_open(uint8_t id, const struct flash_area **area) |
| { |
| int i; |
| |
| BOOT_LOG_DBG("area %d", id); |
| |
| for (i = 0; i < ARRAY_SIZE(part_map); i++) { |
| if (id == part_map[i].area.fa_id) { |
| break; |
| } |
| } |
| if (i == ARRAY_SIZE(part_map)) { |
| return -1; |
| } |
| |
| *area = &part_map[i].area; |
| part_map[i].ref_count++; |
| return 0; |
| } |
| |
| /* |
| * Nothing to do on close. |
| */ |
| void flash_area_close(const struct flash_area *area) |
| { |
| struct flash_map_entry *entry; |
| |
| if (!area) { |
| return; |
| } |
| |
| entry = CONTAINER_OF(area, struct flash_map_entry, area); |
| if (entry->magic != FLASH_MAP_ENTRY_MAGIC) { |
| BOOT_LOG_ERR("invalid area %p (id %u)", area, area->fa_id); |
| return; |
| } |
| if (entry->ref_count == 0) { |
| BOOT_LOG_ERR("area %u use count underflow", area->fa_id); |
| return; |
| } |
| entry->ref_count--; |
| } |
| |
| void zephyr_flash_area_warn_on_open(void) |
| { |
| int i; |
| |
| for (i = 0; i < ARRAY_SIZE(part_map); i++) { |
| struct flash_map_entry *entry = &part_map[i]; |
| if (entry->ref_count) { |
| BOOT_LOG_WRN("area %u has %u users", |
| entry->area.fa_id, entry->ref_count); |
| } |
| } |
| } |
| |
| int flash_area_read(const struct flash_area *area, uint32_t off, void *dst, |
| uint32_t len) |
| { |
| BOOT_LOG_DBG("area=%d, off=%x, len=%x", area->fa_id, off, len); |
| return flash_read(boot_flash_device, area->fa_off + off, dst, len); |
| } |
| |
| int flash_area_write(const struct flash_area *area, uint32_t off, const void *src, |
| uint32_t len) |
| { |
| int rc = 0; |
| |
| BOOT_LOG_DBG("area=%d, off=%x, len=%x", area->fa_id, off, len); |
| flash_write_protection_set(boot_flash_device, false); |
| rc = flash_write(boot_flash_device, area->fa_off + off, src, len); |
| flash_write_protection_set(boot_flash_device, true); |
| return rc; |
| } |
| |
| int flash_area_erase(const struct flash_area *area, uint32_t off, uint32_t len) |
| { |
| int rc; |
| |
| BOOT_LOG_DBG("area=%d, off=%x, len=%x", area->fa_id, off, len); |
| flash_write_protection_set(boot_flash_device, false); |
| rc = flash_erase(boot_flash_device, area->fa_off + off, len); |
| flash_write_protection_set(boot_flash_device, true); |
| return rc; |
| } |
| |
| uint8_t flash_area_align(const struct flash_area *area) |
| { |
| return hal_flash_align(area->fa_id); |
| } |
| |
| /* |
| * This depends on the mappings defined in sysflash.h, and assumes |
| * that slot 0, slot 1, and the scratch area area contiguous. |
| */ |
| int flash_area_id_from_image_slot(int slot) |
| { |
| return slot + FLASH_AREA_IMAGE_0; |
| } |
| |
| /* |
| * This is used by the legacy file as well; don't mark it static until |
| * that file is removed. |
| */ |
| int flash_area_get_bounds(int idx, uint32_t *off, uint32_t *len) |
| { |
| /* |
| * This simple layout has uniform slots, so just fill in the |
| * right one. |
| */ |
| if (idx < FLASH_AREA_IMAGE_0 || idx > FLASH_AREA_IMAGE_SCRATCH) { |
| return -1; |
| } |
| |
| switch (idx) { |
| case FLASH_AREA_IMAGE_0: |
| *off = FLASH_AREA_IMAGE_0_OFFSET; |
| *len = FLASH_AREA_IMAGE_0_SIZE; |
| break; |
| case FLASH_AREA_IMAGE_1: |
| *off = FLASH_AREA_IMAGE_1_OFFSET; |
| *len = FLASH_AREA_IMAGE_1_SIZE; |
| break; |
| case FLASH_AREA_IMAGE_SCRATCH: |
| *off = FLASH_AREA_IMAGE_SCRATCH_OFFSET; |
| *len = FLASH_AREA_IMAGE_SCRATCH_SIZE; |
| break; |
| default: |
| BOOT_LOG_ERR("unknown flash area %d", idx); |
| return -1; |
| } |
| |
| BOOT_LOG_DBG("area %d: offset=0x%x, length=0x%x", idx, *off, *len); |
| return 0; |
| } |
| |
| /* |
| * The legacy fallbacks are used instead if the flash driver doesn't |
| * provide page layout support. |
| */ |
| #if defined(CONFIG_FLASH_PAGE_LAYOUT) |
| struct layout_data { |
| uint32_t area_idx; |
| uint32_t area_off; |
| uint32_t area_len; |
| void *ret; /* struct flash_area* or struct flash_sector* */ |
| uint32_t ret_idx; |
| uint32_t ret_len; |
| int status; |
| }; |
| |
| /* |
| * Generic page layout discovery routine. This is kept separate to |
| * support both the deprecated flash_area_to_sectors() and the current |
| * flash_area_get_sectors(). A lot of this can be inlined once |
| * flash_area_to_sectors() is removed. |
| */ |
| static int flash_area_layout(int idx, int *cnt, void *ret, |
| flash_page_cb cb, struct layout_data *cb_data) |
| { |
| cb_data->area_idx = idx; |
| if (flash_area_get_bounds(idx, &cb_data->area_off, &cb_data->area_len)) { |
| return -1; |
| } |
| cb_data->ret = ret; |
| cb_data->ret_idx = 0; |
| cb_data->ret_len = *cnt; |
| cb_data->status = 0; |
| |
| flash_page_foreach(boot_flash_device, cb, cb_data); |
| |
| if (cb_data->status == 0) { |
| *cnt = cb_data->ret_idx; |
| } |
| |
| return cb_data->status; |
| } |
| |
| /* |
| * Check if a flash_page_foreach() callback should exit early, due to |
| * one of the following conditions: |
| * |
| * - The flash page described by "info" is before the area of interest |
| * described in "data" |
| * - The flash page is after the end of the area |
| * - There are too many flash pages on the device to fit in the array |
| * held in data->ret. In this case, data->status is set to -ENOMEM. |
| * |
| * The value to return to flash_page_foreach() is stored in |
| * "bail_value" if the callback should exit early. |
| */ |
| static bool should_bail(const struct flash_pages_info *info, |
| struct layout_data *data, |
| bool *bail_value) |
| { |
| if (info->start_offset < data->area_off) { |
| *bail_value = true; |
| return true; |
| } else if (info->start_offset >= data->area_off + data->area_len) { |
| *bail_value = false; |
| return true; |
| } else if (data->ret_idx >= data->ret_len) { |
| data->status = -ENOMEM; |
| *bail_value = false; |
| return true; |
| } |
| |
| return false; |
| } |
| |
| static bool to_sectors_cb(const struct flash_pages_info *info, void *datav) |
| { |
| struct layout_data *data = datav; |
| struct flash_area *ret = data->ret; |
| bool bail; |
| |
| if (should_bail(info, data, &bail)) { |
| return bail; |
| } |
| |
| ret[data->ret_idx].fa_id = data->area_idx; |
| ret[data->ret_idx].fa_device_id = 0; |
| ret[data->ret_idx].pad16 = 0; |
| ret[data->ret_idx].fa_off = info->start_offset; |
| ret[data->ret_idx].fa_size = info->size; |
| data->ret_idx++; |
| |
| return true; |
| } |
| |
| int flash_area_to_sectors(int idx, int *cnt, struct flash_area *ret) |
| { |
| struct layout_data data; |
| |
| return flash_area_layout(idx, cnt, ret, to_sectors_cb, &data); |
| } |
| |
| static bool get_sectors_cb(const struct flash_pages_info *info, void *datav) |
| { |
| struct layout_data *data = datav; |
| struct flash_sector *ret = data->ret; |
| bool bail; |
| |
| if (should_bail(info, data, &bail)) { |
| return bail; |
| } |
| |
| ret[data->ret_idx].fs_off = info->start_offset - data->area_off; |
| ret[data->ret_idx].fs_size = info->size; |
| data->ret_idx++; |
| |
| return true; |
| } |
| |
| int flash_area_get_sectors(int idx, uint32_t *cnt, struct flash_sector *ret) |
| { |
| struct layout_data data; |
| |
| return flash_area_layout(idx, cnt, ret, get_sectors_cb, &data); |
| } |
| #endif /* defined(CONFIG_FLASH_PAGE_LAYOUT) */ |