granicus.if.org Git - esp-idf/blob - components/esp32/cpu_start.c

   1 // Copyright 2015-2017 Espressif Systems (Shanghai) PTE LTD
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include <stdint.h>
  16 #include <string.h>
  17
  18 #include "esp_attr.h"
  19 #include "esp_err.h"
  20
  21 #include "rom/ets_sys.h"
  22 #include "rom/uart.h"
  23 #include "rom/rtc.h"
  24 #include "rom/cache.h"
  25
  26 #include "soc/cpu.h"
  27 #include "soc/rtc.h"
  28 #include "soc/dport_reg.h"
  29 #include "soc/io_mux_reg.h"
  30 #include "soc/rtc_cntl_reg.h"
  31 #include "soc/timer_group_reg.h"
  32
  33 #include "driver/rtc_io.h"
  34
  35 #include "freertos/FreeRTOS.h"
  36 #include "freertos/task.h"
  37 #include "freertos/semphr.h"
  38 #include "freertos/queue.h"
  39 #include "freertos/portmacro.h"
  40
  41 #include "tcpip_adapter.h"
  42
  43 #include "esp_heap_caps_init.h"
  44 #include "sdkconfig.h"
  45 #include "esp_system.h"
  46 #include "esp_spi_flash.h"
  47 #include "nvs_flash.h"
  48 #include "esp_event.h"
  49 #include "esp_spi_flash.h"
  50 #include "esp_ipc.h"
  51 #include "esp_crosscore_int.h"
  52 #include "esp_dport_access.h"
  53 #include "esp_log.h"
  54 #include "esp_vfs_dev.h"
  55 #include "esp_newlib.h"
  56 #include "esp_brownout.h"
  57 #include "esp_int_wdt.h"
  58 #include "esp_task_wdt.h"
  59 #include "esp_phy_init.h"
  60 #include "esp_cache_err_int.h"
  61 #include "esp_coexist.h"
  62 #include "esp_panic.h"
  63 #include "esp_core_dump.h"
  64 #include "esp_app_trace.h"
  65 #include "esp_efuse.h"
  66 #include "esp_spiram.h"
  67 #include "esp_clk.h"
  68 #include "esp_timer.h"
  69 #include "trax.h"
  70
  71 #define STRINGIFY(s) STRINGIFY2(s)
  72 #define STRINGIFY2(s) #s
  73
  74 void start_cpu0(void) __attribute__((weak, alias("start_cpu0_default"))) __attribute__((noreturn));
  75 void start_cpu0_default(void) IRAM_ATTR __attribute__((noreturn));
  76 #if !CONFIG_FREERTOS_UNICORE
  77 static void IRAM_ATTR call_start_cpu1() __attribute__((noreturn));
  78 void start_cpu1(void) __attribute__((weak, alias("start_cpu1_default"))) __attribute__((noreturn));
  79 void start_cpu1_default(void) IRAM_ATTR __attribute__((noreturn));
  80 static bool app_cpu_started = false;
  81 #endif //!CONFIG_FREERTOS_UNICORE
  82
  83 static void do_global_ctors(void);
  84 static void main_task(void* args);
  85 extern void app_main(void);
  86
  87 extern int _bss_start;
  88 extern int _bss_end;
  89 extern int _rtc_bss_start;
  90 extern int _rtc_bss_end;
  91 extern int _init_start;
  92 extern void (*__init_array_start)(void);
  93 extern void (*__init_array_end)(void);
  94 extern volatile int port_xSchedulerRunning[2];
  95
  96 static const char* TAG = "cpu_start";
  97
  98 struct object { long placeholder[ 10 ]; };
  99 void __register_frame_info (const void *begin, struct object *ob);
 100 extern char __eh_frame[];
 101
 102 /*
 103  * We arrive here after the bootloader finished loading the program from flash. The hardware is mostly uninitialized,
 104  * and the app CPU is in reset. We do have a stack, so we can do the initialization in C.
 105  */
 106
 107 void IRAM_ATTR call_start_cpu0()
 108 {
 109 #if CONFIG_FREERTOS_UNICORE
 110     RESET_REASON rst_reas[1];
 111 #else
 112     RESET_REASON rst_reas[2];
 113 #endif
 114     cpu_configure_region_protection();
 115
 116     //Move exception vectors to IRAM
 117     asm volatile (\
 118                   "wsr    %0, vecbase\n" \
 119                   ::"r"(&_init_start));
 120
 121     rst_reas[0] = rtc_get_reset_reason(0);
 122
 123 #if !CONFIG_FREERTOS_UNICORE
 124     rst_reas[1] = rtc_get_reset_reason(1);
 125 #endif
 126
 127     // from panic handler we can be reset by RWDT or TG0WDT
 128     if (rst_reas[0] == RTCWDT_SYS_RESET || rst_reas[0] == TG0WDT_SYS_RESET
 129 #if !CONFIG_FREERTOS_UNICORE
 130         || rst_reas[1] == RTCWDT_SYS_RESET || rst_reas[1] == TG0WDT_SYS_RESET
 131 #endif
 132     ) {
 133         esp_panic_wdt_stop();
 134     }
 135
 136     // Temporary workaround for an ugly crash, until we allow > 192KB of static DRAM
 137     if ((intptr_t)&_bss_end > 0x3FFE0000) {
 138         // Can't use assert() or logging here because there's no .bss
 139         ets_printf("ERROR: Static .bss section extends past 0x3FFE0000. IDF cannot boot.\n");
 140         abort();
 141     }
 142
 143     //Clear BSS. Please do not attempt to do any complex stuff (like early logging) before this.
 144     memset(&_bss_start, 0, (&_bss_end - &_bss_start) * sizeof(_bss_start));
 145
 146     /* Unless waking from deep sleep (implying RTC memory is intact), clear RTC bss */
 147     if (rst_reas[0] != DEEPSLEEP_RESET) {
 148         memset(&_rtc_bss_start, 0, (&_rtc_bss_end - &_rtc_bss_start) * sizeof(_rtc_bss_start));
 149     }
 150
 151 #if CONFIG_SPIRAM_BOOT_INIT
 152     if (esp_spiram_init() != ESP_OK) {
 153         ESP_EARLY_LOGE(TAG, "Failed to init external RAM!");
 154         abort();
 155     }
 156 #endif
 157
 158     ESP_EARLY_LOGI(TAG, "Pro cpu up.");
 159
 160 #if !CONFIG_FREERTOS_UNICORE
 161     ESP_EARLY_LOGI(TAG, "Starting app cpu, entry point is %p", call_start_cpu1);
 162     //Flush and enable icache for APP CPU
 163     Cache_Flush(1);
 164     Cache_Read_Enable(1);
 165     esp_cpu_unstall(1);
 166     // Enable clock and reset APP CPU. Note that OpenOCD may have already
 167     // enabled clock and taken APP CPU out of reset. In this case don't reset
 168     // APP CPU again, as that will clear the breakpoints which may have already
 169     // been set.
 170     if (!DPORT_GET_PERI_REG_MASK(DPORT_APPCPU_CTRL_B_REG, DPORT_APPCPU_CLKGATE_EN)) {
 171         DPORT_SET_PERI_REG_MASK(DPORT_APPCPU_CTRL_B_REG, DPORT_APPCPU_CLKGATE_EN);
 172         DPORT_CLEAR_PERI_REG_MASK(DPORT_APPCPU_CTRL_C_REG, DPORT_APPCPU_RUNSTALL);
 173         DPORT_SET_PERI_REG_MASK(DPORT_APPCPU_CTRL_A_REG, DPORT_APPCPU_RESETTING);
 174         DPORT_CLEAR_PERI_REG_MASK(DPORT_APPCPU_CTRL_A_REG, DPORT_APPCPU_RESETTING);
 175     }
 176     ets_set_appcpu_boot_addr((uint32_t)call_start_cpu1);
 177
 178     while (!app_cpu_started) {
 179         ets_delay_us(100);
 180     }
 181 #else
 182     ESP_EARLY_LOGI(TAG, "Single core mode");
 183     DPORT_CLEAR_PERI_REG_MASK(DPORT_APPCPU_CTRL_B_REG, DPORT_APPCPU_CLKGATE_EN);
 184 #endif
 185
 186
 187 #if CONFIG_SPIRAM_MEMTEST
 188     bool ext_ram_ok=esp_spiram_test();
 189     if (!ext_ram_ok) {
 190         ESP_EARLY_LOGE(TAG, "External RAM failed memory test!");
 191         abort();
 192     }
 193 #endif
 194
 195     /* Initialize heap allocator. WARNING: This *needs* to happen *after* the app cpu has booted.
 196        If the heap allocator is initialized first, it will put free memory linked list items into
 197        memory also used by the ROM. Starting the app cpu will let its ROM initialize that memory,
 198        corrupting those linked lists. Initializing the allocator *after* the app cpu has booted
 199        works around this problem.
 200        With SPI RAM enabled, there's a second reason: half of the SPI RAM will be managed by the
 201        app CPU, and when that is not up yet, the memory will be inaccessible and heap_caps_init may
 202        fail initializing it properly. */
 203     heap_caps_init();
 204
 205     ESP_EARLY_LOGI(TAG, "Pro cpu start user code");
 206     start_cpu0();
 207 }
 208
 209 #if !CONFIG_FREERTOS_UNICORE
 210
 211 static void wdt_reset_cpu1_info_enable(void)
 212 {
 213     DPORT_REG_SET_BIT(DPORT_APP_CPU_RECORD_CTRL_REG, DPORT_APP_CPU_PDEBUG_ENABLE | DPORT_APP_CPU_RECORD_ENABLE);
 214     DPORT_REG_CLR_BIT(DPORT_APP_CPU_RECORD_CTRL_REG, DPORT_APP_CPU_RECORD_ENABLE);
 215 }
 216
 217 void IRAM_ATTR call_start_cpu1()
 218 {
 219     asm volatile (\
 220                   "wsr    %0, vecbase\n" \
 221                   ::"r"(&_init_start));
 222
 223     ets_set_appcpu_boot_addr(0);
 224     cpu_configure_region_protection();
 225
 226 #if CONFIG_CONSOLE_UART_NONE
 227     ets_install_putc1(NULL);
 228     ets_install_putc2(NULL);
 229 #else // CONFIG_CONSOLE_UART_NONE
 230     uartAttach();
 231     ets_install_uart_printf();
 232     uart_tx_switch(CONFIG_CONSOLE_UART_NUM);
 233 #endif
 234
 235     wdt_reset_cpu1_info_enable();
 236     ESP_EARLY_LOGI(TAG, "App cpu up.");
 237     app_cpu_started = 1;
 238     start_cpu1();
 239 }
 240 #endif //!CONFIG_FREERTOS_UNICORE
 241
 242 static void intr_matrix_clear(void)
 243 {
 244     //Clear all the interrupt matrix register
 245     for (int i = ETS_WIFI_MAC_INTR_SOURCE; i <= ETS_CACHE_IA_INTR_SOURCE; i++) {
 246         intr_matrix_set(0, i, ETS_INVALID_INUM);
 247 #if !CONFIG_FREERTOS_UNICORE
 248         intr_matrix_set(1, i, ETS_INVALID_INUM);
 249 #endif
 250     }
 251 }
 252
 253 void start_cpu0_default(void)
 254 {
 255     esp_setup_syscall_table();
 256 //Enable trace memory and immediately start trace.
 257 #if CONFIG_ESP32_TRAX
 258 #if CONFIG_ESP32_TRAX_TWOBANKS
 259     trax_enable(TRAX_ENA_PRO_APP);
 260 #else
 261     trax_enable(TRAX_ENA_PRO);
 262 #endif
 263     trax_start_trace(TRAX_DOWNCOUNT_WORDS);
 264 #endif
 265     esp_clk_init();
 266     esp_perip_clk_init();
 267     intr_matrix_clear();
 268 #ifndef CONFIG_CONSOLE_UART_NONE
 269     uart_div_modify(CONFIG_CONSOLE_UART_NUM, (rtc_clk_apb_freq_get() << 4) / CONFIG_CONSOLE_UART_BAUDRATE);
 270 #endif
 271 #if CONFIG_BROWNOUT_DET
 272     esp_brownout_init();
 273 #endif
 274 #if CONFIG_DISABLE_BASIC_ROM_CONSOLE
 275     esp_efuse_disable_basic_rom_console();
 276 #endif
 277     rtc_gpio_force_hold_dis_all();
 278     esp_vfs_dev_uart_register();
 279     esp_reent_init(_GLOBAL_REENT);
 280 #ifndef CONFIG_CONSOLE_UART_NONE
 281     const char* default_uart_dev = "/dev/uart/" STRINGIFY(CONFIG_CONSOLE_UART_NUM);
 282     _GLOBAL_REENT->_stdin  = fopen(default_uart_dev, "r");
 283     _GLOBAL_REENT->_stdout = fopen(default_uart_dev, "w");
 284     _GLOBAL_REENT->_stderr = fopen(default_uart_dev, "w");
 285 #else
 286     _GLOBAL_REENT->_stdin  = (FILE*) &__sf_fake_stdin;
 287     _GLOBAL_REENT->_stdout = (FILE*) &__sf_fake_stdout;
 288     _GLOBAL_REENT->_stderr = (FILE*) &__sf_fake_stderr;
 289 #endif
 290     esp_timer_init();
 291     esp_set_time_from_rtc();
 292 #if CONFIG_ESP32_APPTRACE_ENABLE
 293     esp_err_t err = esp_apptrace_init();
 294     if (err != ESP_OK) {
 295         ESP_EARLY_LOGE(TAG, "Failed to init apptrace module on CPU0 (%d)!", err);
 296     }
 297 #endif
 298 #if CONFIG_SYSVIEW_ENABLE
 299     SEGGER_SYSVIEW_Conf();
 300 #endif
 301     do_global_ctors();
 302 #if CONFIG_INT_WDT
 303     esp_int_wdt_init();
 304 #endif
 305 #if CONFIG_TASK_WDT
 306     esp_task_wdt_init();
 307 #endif
 308     esp_cache_err_int_init();
 309     esp_crosscore_int_init();
 310     esp_ipc_init();
 311 #ifndef CONFIG_FREERTOS_UNICORE
 312     esp_dport_access_int_init();
 313 #endif
 314     spi_flash_init();
 315     /* init default OS-aware flash access critical section */
 316     spi_flash_guard_set(&g_flash_guard_default_ops);
 317
 318 #if CONFIG_ESP32_ENABLE_COREDUMP
 319     esp_core_dump_init();
 320 #endif
 321
 322     portBASE_TYPE res = xTaskCreatePinnedToCore(&main_task, "main",
 323                                                 ESP_TASK_MAIN_STACK, NULL,
 324                                                 ESP_TASK_MAIN_PRIO, NULL, 0);
 325     assert(res == pdTRUE);
 326     ESP_LOGI(TAG, "Starting scheduler on PRO CPU.");
 327     vTaskStartScheduler();
 328     abort(); /* Only get to here if not enough free heap to start scheduler */
 329 }
 330
 331 #if !CONFIG_FREERTOS_UNICORE
 332 void start_cpu1_default(void)
 333 {
 334 #if CONFIG_ESP32_TRAX_TWOBANKS
 335     trax_start_trace(TRAX_DOWNCOUNT_WORDS);
 336 #endif
 337 #if CONFIG_ESP32_APPTRACE_ENABLE
 338     esp_err_t err = esp_apptrace_init();
 339     if (err != ESP_OK) {
 340         ESP_EARLY_LOGE(TAG, "Failed to init apptrace module on CPU1 (%d)!", err);
 341     }
 342 #endif
 343     // Wait for FreeRTOS initialization to finish on PRO CPU
 344     while (port_xSchedulerRunning[0] == 0) {
 345         ;
 346     }
 347     //Take care putting stuff here: if asked, FreeRTOS will happily tell you the scheduler
 348     //has started, but it isn't active *on this CPU* yet.
 349     esp_cache_err_int_init();
 350     esp_crosscore_int_init();
 351     esp_dport_access_int_init();
 352
 353     ESP_EARLY_LOGI(TAG, "Starting scheduler on APP CPU.");
 354     xPortStartScheduler();
 355     abort(); /* Only get to here if FreeRTOS somehow very broken */
 356 }
 357 #endif //!CONFIG_FREERTOS_UNICORE
 358
 359 static void do_global_ctors(void)
 360 {
 361     static struct object ob;
 362     __register_frame_info( __eh_frame, &ob );
 363
 364     void (**p)(void);
 365     for (p = &__init_array_end - 1; p >= &__init_array_start; --p) {
 366         (*p)();
 367     }
 368 }
 369
 370 static void main_task(void* args)
 371 {
 372     // Now that the application is about to start, disable boot watchdogs
 373     REG_CLR_BIT(TIMG_WDTCONFIG0_REG(0), TIMG_WDT_FLASHBOOT_MOD_EN_S);
 374     REG_CLR_BIT(RTC_CNTL_WDTCONFIG0_REG, RTC_CNTL_WDT_FLASHBOOT_MOD_EN);
 375 #if !CONFIG_FREERTOS_UNICORE
 376     // Wait for FreeRTOS initialization to finish on APP CPU, before replacing its startup stack
 377     while (port_xSchedulerRunning[1] == 0) {
 378         ;
 379     }
 380 #endif
 381     //Enable allocation in region where the startup stacks were located.
 382     heap_caps_enable_nonos_stack_heaps();
 383     app_main();
 384     vTaskDelete(NULL);
 385 }
 386