feedc0de/esp-idf
1
0
Fork 0
forked from espressif/esp-idf
Code Pull Requests Activity

bootloader: move useful structures to esp32 component

Browse Source
This commit is contained in:
Ivan Grokhotkov
2016-10-19 17:05:37 +08:00
parent f6f23141b3
commit 628bde2080
4 changed files with 162 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
components/bootloader/src/main/bootloader_config.h
View File

@@ -20,12 +20,13 @@
extern "C" extern "C"
{ {
#endif #endif
#include "esp_flash_data_types.h"
#define BOOT_VERSION "V0.1" #define BOOT_VERSION "V0.1"
#define SPI_SEC_SIZE 0x1000 #define SPI_SEC_SIZE 0x1000
#define MEM_CACHE(offset) (uint8_t *)(0x3f400000 + (offset)) #define MEM_CACHE(offset) (uint8_t *)(0x3f400000 + (offset))
#define CACHE_READ_32(offset) ((uint32_t *)(0x3f400000 + (offset))) #define CACHE_READ_32(offset) ((uint32_t *)(0x3f400000 + (offset)))
#define PARTITION_ADD 0x4000
#define PARTITION_MAGIC 0x50AA
#define IROM_LOW 0x400D0000 #define IROM_LOW 0x400D0000
#define IROM_HIGH 0x40400000 #define IROM_HIGH 0x40400000
#define DROM_LOW 0x3F400000 #define DROM_LOW 0x3F400000
@@ -35,73 +36,6 @@ extern "C"
#define RTC_DATA_LOW 0x50000000 #define RTC_DATA_LOW 0x50000000
#define RTC_DATA_HIGH 0x50002000 #define RTC_DATA_HIGH 0x50002000
/*spi mode,saved in third byte in flash */
enum {
SPI_MODE_QIO,
SPI_MODE_QOUT,
SPI_MODE_DIO,
SPI_MODE_DOUT,
SPI_MODE_FAST_READ,
SPI_MODE_SLOW_READ
};
/* spi speed*/
enum {
SPI_SPEED_40M,
SPI_SPEED_26M,
SPI_SPEED_20M,
SPI_SPEED_80M = 0xF
};
/*supported flash sizes*/
enum {
SPI_SIZE_1MB = 0,
SPI_SIZE_2MB,
SPI_SIZE_4MB,
SPI_SIZE_8MB,
SPI_SIZE_16MB,
SPI_SIZE_MAX
};
struct flash_hdr {
char magic;
char blocks;
char spi_mode; /* flag of flash read mode in unpackage and usage in future */
char spi_speed: 4; /* low bit */
char spi_size: 4;
unsigned int entry_addr;
uint8_t encrypt_flag; /* encrypt flag */
uint8_t secury_boot_flag; /* secury boot flag */
char extra_header[14]; /* ESP32 additional header, unused by second bootloader */
};
/* each header of flash bin block */
struct block_hdr {
unsigned int load_addr;
unsigned int data_len;
};
/* OTA selection structure (two copies in the OTA data partition.)
Size of 32 bytes is friendly to flash encryption */
typedef struct {
uint32_t ota_seq;
uint8_t seq_label[24];
uint32_t crc; /* CRC32 of ota_seq field only */
} ota_select;
typedef struct {
uint32_t offset;
uint32_t size;
} partition_pos_t;
typedef struct {
uint16_t magic;
uint8_t type; /* partition Type */
uint8_t subtype; /* part_subtype */
partition_pos_t pos;
uint8_t label[16]; /* label for the partition */
uint8_t reserved[4]; /* reserved */
} partition_info_t;
#define PART_TYPE_APP 0x00 #define PART_TYPE_APP 0x00
#define PART_SUBTYPE_FACTORY 0x00 #define PART_SUBTYPE_FACTORY 0x00
@@ -120,10 +54,10 @@ typedef struct {
#define SPI_ERROR_LOG "spi flash error" #define SPI_ERROR_LOG "spi flash error"
typedef struct { typedef struct {
partition_pos_t ota_info; esp_partition_pos_t ota_info;
partition_pos_t factory; esp_partition_pos_t factory;
partition_pos_t test; esp_partition_pos_t test;
partition_pos_t ota[16]; esp_partition_pos_t ota[16];
uint32_t app_count; uint32_t app_count;
uint32_t selected_subtype; uint32_t selected_subtype;
} bootloader_state_t; } bootloader_state_t;

120
components/bootloader/src/main/bootloader_start.c
View File

@@ -3,7 +3,7 @@
// Licensed under the Apache License, Version 2.0 (the "License"); // Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License. // you may not use this file except in compliance with the License.
// You may obtain a copy of the License at // You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0 // http://www.apache.org/licenses/LICENSE-2.0
// //
// Unless required by applicable law or agreed to in writing, software // Unless required by applicable law or agreed to in writing, software
@@ -49,8 +49,8 @@ flash cache is down and the app CPU is in reset. We do have a stack, so we can d
extern void Cache_Flush(int); extern void Cache_Flush(int);
void bootloader_main(); void bootloader_main();
void unpack_load_app(const partition_pos_t *app_node); void unpack_load_app(const esp_partition_pos_t *app_node);
void print_flash_info(struct flash_hdr* pfhdr); void print_flash_info(const esp_image_header_t* pfhdr);
void IRAM_ATTR set_cache_and_start_app(uint32_t drom_addr, void IRAM_ATTR set_cache_and_start_app(uint32_t drom_addr,
uint32_t drom_load_addr, uint32_t drom_load_addr,
uint32_t drom_size, uint32_t drom_size,
@@ -58,7 +58,7 @@ void IRAM_ATTR set_cache_and_start_app(uint32_t drom_addr,
uint32_t irom_load_addr, uint32_t irom_load_addr,
uint32_t irom_size, uint32_t irom_size,
uint32_t entry_addr); uint32_t entry_addr);
static void update_flash_config(struct flash_hdr* pfhdr); static void update_flash_config(const esp_image_header_t* pfhdr);
void IRAM_ATTR call_start_cpu0() void IRAM_ATTR call_start_cpu0()
@@ -154,7 +154,7 @@ void boot_cache_redirect( uint32_t pos, size_t size )
*/ */
bool load_partition_table(bootloader_state_t* bs, uint32_t addr) bool load_partition_table(bootloader_state_t* bs, uint32_t addr)
{ {
partition_info_t partition; esp_partition_info_t partition;
uint32_t end = addr + 0x1000; uint32_t end = addr + 0x1000;
int index = 0; int index = 0;
char *partition_usage; char *partition_usage;
@@ -168,7 +168,7 @@ bool load_partition_table(bootloader_state_t* bs, uint32_t addr)
ESP_LOGD(TAG, "type=%x subtype=%x", partition.type, partition.subtype); ESP_LOGD(TAG, "type=%x subtype=%x", partition.type, partition.subtype);
partition_usage = "unknown"; partition_usage = "unknown";
if (partition.magic == PARTITION_MAGIC) { /* valid partition definition */ if (partition.magic == ESP_PARTITION_MAGIC) { /* valid partition definition */
switch(partition.type) { switch(partition.type) {
case PART_TYPE_APP: /* app partition */ case PART_TYPE_APP: /* app partition */
switch(partition.subtype) { switch(partition.subtype) {
@@ -231,12 +231,12 @@ bool load_partition_table(bootloader_state_t* bs, uint32_t addr)
return true; return true;
} }
static uint32_t ota_select_crc(const ota_select *s) static uint32_t ota_select_crc(const esp_ota_select_entry_t *s)
{ {
return crc32_le(UINT32_MAX, (uint8_t*)&s->ota_seq, 4); return crc32_le(UINT32_MAX, (uint8_t*)&s->ota_seq, 4);
} }
static bool ota_select_valid(const ota_select *s) static bool ota_select_valid(const esp_ota_select_entry_t *s)
{ {
return s->ota_seq != UINT32_MAX && s->crc == ota_select_crc(s); return s->ota_seq != UINT32_MAX && s->crc == ota_select_crc(s);
} }
@@ -252,10 +252,10 @@ void bootloader_main()
{ {
ESP_LOGI(TAG, "Espressif ESP32 2nd stage bootloader v. %s", BOOT_VERSION); ESP_LOGI(TAG, "Espressif ESP32 2nd stage bootloader v. %s", BOOT_VERSION);
struct flash_hdr fhdr; esp_image_header_t fhdr;
bootloader_state_t bs; bootloader_state_t bs;
SpiFlashOpResult spiRet1,spiRet2; SpiFlashOpResult spiRet1,spiRet2;
ota_select sa,sb; esp_ota_select_entry_t sa,sb;
memset(&bs, 0, sizeof(bs)); memset(&bs, 0, sizeof(bs));
ESP_LOGI(TAG, "compile time " __TIME__ ); ESP_LOGI(TAG, "compile time " __TIME__ );
@@ -266,18 +266,18 @@ void bootloader_main()
/*register first sector in drom0 page 0 */ /*register first sector in drom0 page 0 */
boot_cache_redirect( 0, 0x5000 ); boot_cache_redirect( 0, 0x5000 );
memcpy((unsigned int *) &fhdr, MEM_CACHE(0x1000), sizeof(struct flash_hdr) ); memcpy((unsigned int *) &fhdr, MEM_CACHE(0x1000), sizeof(esp_image_header_t) );
print_flash_info(&fhdr); print_flash_info(&fhdr);
update_flash_config(&fhdr); update_flash_config(&fhdr);
if (!load_partition_table(&bs, PARTITION_ADD)) { if (!load_partition_table(&bs, ESP_PARTITION_TABLE_ADDR)) {
ESP_LOGE(TAG, "load partition table error!"); ESP_LOGE(TAG, "load partition table error!");
return; return;
} }
partition_pos_t load_part_pos; esp_partition_pos_t load_part_pos;
if (bs.ota_info.offset != 0) { // check if partition table has OTA info partition if (bs.ota_info.offset != 0) { // check if partition table has OTA info partition
//ESP_LOGE("OTA info sector handling is not implemented"); //ESP_LOGE("OTA info sector handling is not implemented");
@@ -299,8 +299,8 @@ void bootloader_main()
ESP_LOGE(TAG, SPI_ERROR_LOG); ESP_LOGE(TAG, SPI_ERROR_LOG);
return; return;
} }
spiRet1 = SPIWrite(bs.ota_info.offset,(uint32_t *)&sa,sizeof(ota_select)); spiRet1 = SPIWrite(bs.ota_info.offset,(uint32_t *)&sa,sizeof(esp_ota_select_entry_t));
spiRet2 = SPIWrite(bs.ota_info.offset + 0x1000,(uint32_t *)&sb,sizeof(ota_select)); spiRet2 = SPIWrite(bs.ota_info.offset + 0x1000,(uint32_t *)&sb,sizeof(esp_ota_select_entry_t));
if (spiRet1 != SPI_FLASH_RESULT_OK || spiRet2 != SPI_FLASH_RESULT_OK ) { if (spiRet1 != SPI_FLASH_RESULT_OK || spiRet2 != SPI_FLASH_RESULT_OK ) {
ESP_LOGE(TAG, SPI_ERROR_LOG); ESP_LOGE(TAG, SPI_ERROR_LOG);
return; return;
@@ -329,7 +329,7 @@ void bootloader_main()
} }
ESP_LOGI(TAG, "Loading app partition at offset %08x", load_part_pos); ESP_LOGI(TAG, "Loading app partition at offset %08x", load_part_pos);
if(fhdr.secury_boot_flag == 0x01) { if(fhdr.secure_boot_flag == 0x01) {
/* protect the 2nd_boot */ /* protect the 2nd_boot */
if(false == secure_boot()){ if(false == secure_boot()){
ESP_LOGE(TAG, "secure boot failed"); ESP_LOGE(TAG, "secure boot failed");
@@ -350,12 +350,12 @@ void bootloader_main()
} }
void unpack_load_app(const partition_pos_t* partition) void unpack_load_app(const esp_partition_pos_t* partition)
{ {
boot_cache_redirect(partition->offset, partition->size); boot_cache_redirect(partition->offset, partition->size);
uint32_t pos = 0; uint32_t pos = 0;
struct flash_hdr image_header; esp_image_header_t image_header;
memcpy(&image_header, MEM_CACHE(pos), sizeof(image_header)); memcpy(&image_header, MEM_CACHE(pos), sizeof(image_header));
pos += sizeof(image_header); pos += sizeof(image_header);
@@ -379,7 +379,7 @@ void unpack_load_app(const partition_pos_t* partition)
for (uint32_t section_index = 0; for (uint32_t section_index = 0;
section_index < image_header.blocks; section_index < image_header.blocks;
++section_index) { ++section_index) {
struct block_hdr section_header = {0}; esp_image_section_header_t section_header = {0};
memcpy(&section_header, MEM_CACHE(pos), sizeof(section_header)); memcpy(&section_header, MEM_CACHE(pos), sizeof(section_header));
pos += sizeof(section_header); pos += sizeof(section_header);
@@ -485,23 +485,23 @@ void IRAM_ATTR set_cache_and_start_app(
(*entry)(); (*entry)();
} }
static void update_flash_config(struct flash_hdr* pfhdr) static void update_flash_config(const esp_image_header_t* pfhdr)
{ {
uint32_t size; uint32_t size;
switch(pfhdr->spi_size) { switch(pfhdr->spi_size) {
case SPI_SIZE_1MB: case ESP_IMAGE_FLASH_SIZE_1MB:
size = 1; size = 1;
break; break;
case SPI_SIZE_2MB: case ESP_IMAGE_FLASH_SIZE_2MB:
size = 2; size = 2;
break; break;
case SPI_SIZE_4MB: case ESP_IMAGE_FLASH_SIZE_4MB:
size = 4; size = 4;
break; break;
case SPI_SIZE_8MB: case ESP_IMAGE_FLASH_SIZE_8MB:
size = 8; size = 8;
break; break;
case SPI_SIZE_16MB: case ESP_IMAGE_FLASH_SIZE_16MB:
size = 16; size = 16;
break; break;
default: default:
@@ -516,66 +516,53 @@ static void update_flash_config(struct flash_hdr* pfhdr)
Cache_Read_Enable( 0 ); Cache_Read_Enable( 0 );
} }
void print_flash_info(struct flash_hdr* pfhdr) void print_flash_info(const esp_image_header_t* phdr)
{ {
#if (BOOT_LOG_LEVEL >= BOOT_LOG_LEVEL_NOTICE) #if (BOOT_LOG_LEVEL >= BOOT_LOG_LEVEL_NOTICE)
struct flash_hdr fhdr = *pfhdr; ESP_LOGD(TAG, "magic %02x", phdr->magic );
ESP_LOGD(TAG, "blocks %02x", phdr->blocks );
ESP_LOGD(TAG, "magic %02x", fhdr.magic ); ESP_LOGD(TAG, "spi_mode %02x", phdr->spi_mode );
ESP_LOGD(TAG, "blocks %02x", fhdr.blocks ); ESP_LOGD(TAG, "spi_speed %02x", phdr->spi_speed );
ESP_LOGD(TAG, "spi_mode %02x", fhdr.spi_mode ); ESP_LOGD(TAG, "spi_size %02x", phdr->spi_size );
ESP_LOGD(TAG, "spi_speed %02x", fhdr.spi_speed );
ESP_LOGD(TAG, "spi_size %02x", fhdr.spi_size );
const char* str; const char* str;
switch ( fhdr.spi_speed ) { switch ( phdr->spi_speed ) {
case SPI_SPEED_40M: case ESP_IMAGE_SPI_SPEED_40M:
str = "40MHz"; str = "40MHz";
break; break;
case ESP_IMAGE_SPI_SPEED_26M:
case SPI_SPEED_26M:
str = "26.7MHz"; str = "26.7MHz";
break; break;
case ESP_IMAGE_SPI_SPEED_20M:
case SPI_SPEED_20M:
str = "20MHz"; str = "20MHz";
break; break;
case ESP_IMAGE_SPI_SPEED_80M:
case SPI_SPEED_80M:
str = "80MHz"; str = "80MHz";
break; break;
default: default:
str = "20MHz"; str = "20MHz";
break; break;
} }
ESP_LOGI(TAG, "SPI Speed : %s", str ); ESP_LOGI(TAG, "SPI Speed : %s", str );
switch ( phdr->spi_mode ) {
case ESP_IMAGE_SPI_MODE_QIO:
switch ( fhdr.spi_mode ) {
case SPI_MODE_QIO:
str = "QIO"; str = "QIO";
break; break;
case ESP_IMAGE_SPI_MODE_QOUT:
case SPI_MODE_QOUT:
str = "QOUT"; str = "QOUT";
break; break;
case ESP_IMAGE_SPI_MODE_DIO:
case SPI_MODE_DIO:
str = "DIO"; str = "DIO";
break; break;
case ESP_IMAGE_SPI_MODE_DOUT:
case SPI_MODE_DOUT:
str = "DOUT"; str = "DOUT";
break; break;
case ESP_IMAGE_SPI_MODE_FAST_READ:
case SPI_MODE_FAST_READ:
str = "FAST READ"; str = "FAST READ";
break; break;
case ESP_IMAGE_SPI_MODE_SLOW_READ:
case SPI_MODE_SLOW_READ:
str = "SLOW READ"; str = "SLOW READ";
break; break;
default: default:
@@ -584,31 +571,24 @@ void print_flash_info(struct flash_hdr* pfhdr)
} }
ESP_LOGI(TAG, "SPI Mode : %s", str ); ESP_LOGI(TAG, "SPI Mode : %s", str );
switch ( phdr->spi_size ) {
case ESP_IMAGE_FLASH_SIZE_1MB:
switch ( fhdr.spi_size ) {
case SPI_SIZE_1MB:
str = "1MB"; str = "1MB";
break; break;
case ESP_IMAGE_FLASH_SIZE_2MB:
case SPI_SIZE_2MB:
str = "2MB"; str = "2MB";
break; break;
case ESP_IMAGE_FLASH_SIZE_4MB:
case SPI_SIZE_4MB:
str = "4MB"; str = "4MB";
break; break;
case ESP_IMAGE_FLASH_SIZE_8MB:
case SPI_SIZE_8MB:
str = "8MB"; str = "8MB";
break; break;
case ESP_IMAGE_FLASH_SIZE_16MB:
case SPI_SIZE_16MB:
str = "16MB"; str = "16MB";
break; break;
default: default:
str = "1MB"; str = "2MB";
break; break;
} }
ESP_LOGI(TAG, "SPI Flash Size : %s", str ); ESP_LOGI(TAG, "SPI Flash Size : %s", str );

2
components/bootloader/src/main/flash_encrypt.c
View File

@@ -128,7 +128,7 @@ bool flash_encrypt(bootloader_state_t *bs)
return false; return false;
} }
/* encrypt partition table */ /* encrypt partition table */
if (false == flash_encrypt_write(PARTITION_ADD, SPI_SEC_SIZE)) { if (false == flash_encrypt_write(ESP_PARTITION_TABLE_ADDR, SPI_SEC_SIZE)) {
ESP_LOGE(TAG, "encrypt partition table error"); ESP_LOGE(TAG, "encrypt partition table error");
return false; return false;
} }

102
components/esp32/include/esp_flash_data_types.h Normal file
View File

@@ -0,0 +1,102 @@
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
//
// Licensed 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.
#ifndef __ESP_BIN_TYPES_H__
#define __ESP_BIN_TYPES_H__
#include <stdint.h>
#ifdef __cplusplus
extern "C"
{
#endif
#define ESP_PARTITION_TABLE_ADDR 0x4000
#define ESP_PARTITION_MAGIC 0x50AA
/*spi mode,saved in third byte in flash */
typedef enum {
ESP_IMAGE_SPI_MODE_QIO,
ESP_IMAGE_SPI_MODE_QOUT,
ESP_IMAGE_SPI_MODE_DIO,
ESP_IMAGE_SPI_MODE_DOUT,
ESP_IMAGE_SPI_MODE_FAST_READ,
ESP_IMAGE_SPI_MODE_SLOW_READ
} esp_image_spi_mode_t;
/* spi speed*/
enum {
ESP_IMAGE_SPI_SPEED_40M,
ESP_IMAGE_SPI_SPEED_26M,
ESP_IMAGE_SPI_SPEED_20M,
ESP_IMAGE_SPI_SPEED_80M = 0xF
} esp_image_spi_freq_t;
/*supported flash sizes*/
typedef enum {
ESP_IMAGE_FLASH_SIZE_1MB = 0,
ESP_IMAGE_FLASH_SIZE_2MB,
ESP_IMAGE_FLASH_SIZE_4MB,
ESP_IMAGE_FLASH_SIZE_8MB,
ESP_IMAGE_FLASH_SIZE_16MB,
ESP_IMAGE_FLASH_SIZE_MAX
} esp_image_flash_size_t;
typedef struct {
char magic;
char blocks;
char spi_mode; /* flag of flash read mode in unpackage and usage in future */
char spi_speed: 4; /* low bit */
char spi_size: 4;
unsigned int entry_addr;
uint8_t encrypt_flag; /* encrypt flag */
uint8_t secure_boot_flag; /* secure boot flag */
char extra_header[14]; /* ESP32 additional header, unused by second bootloader */
} esp_image_header_t;
/* each header of flash bin block */
typedef struct {
unsigned int load_addr;
unsigned int data_len;
} esp_image_section_header_t;
/* OTA selection structure (two copies in the OTA data partition.)
Size of 32 bytes is friendly to flash encryption */
typedef struct {
uint32_t ota_seq;
uint8_t seq_label[24];
uint32_t crc; /* CRC32 of ota_seq field only */
} esp_ota_select_entry_t;
typedef struct {
uint32_t offset;
uint32_t size;
} esp_partition_pos_t;
typedef struct {
uint16_t magic;
uint8_t type; /* partition Type */
uint8_t subtype; /* part_subtype */
esp_partition_pos_t pos;
uint8_t label[16]; /* label for the partition */
uint8_t reserved[4]; /* reserved */
} esp_partition_info_t;
#ifdef __cplusplus
}
#endif
#endif //__ESP_BIN_TYPES_H__