blob: 47e118c94ab25c67ae56e54d16de9688ea968da5 [file] [log] [blame]
David Brown5153bd62017-01-06 11:16:53 -07001/*
2 * Copyright (c) 2012-2014 Wind River Systems, Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Marti Bolivareb940802017-05-01 23:15:29 -040017#include <assert.h>
David Brown5153bd62017-01-06 11:16:53 -070018#include <zephyr.h>
Peter Bigot54c1e3f2020-01-25 05:50:12 -060019#include <drivers/gpio.h>
Andrzej Puzdrowskif1d189c2019-12-12 09:34:11 +010020#include <sys/__assert.h>
Peter Bigot54c1e3f2020-01-25 05:50:12 -060021#include <drivers/flash.h>
Andrzej Puzdrowskif99a4c72019-06-28 15:16:35 +020022#include <drivers/timer/system_timer.h>
Emanuele Di Santoc4bf7802018-07-20 11:39:57 +020023#include <usb/usb_device.h>
Evan Gates4632d8d2018-06-28 13:27:40 -070024#include <soc.h>
David Brown5153bd62017-01-06 11:16:53 -070025
Marti Bolivar51181cf2017-03-20 11:03:41 -040026#include "target.h"
27
Marti Bolivar4a97b4c2017-01-31 18:20:02 -050028#include "bootutil/bootutil_log.h"
Ricardo Salveti3a2c1242017-01-19 10:22:35 -020029#include "bootutil/image.h"
30#include "bootutil/bootutil.h"
Andrzej Puzdrowskib788c712018-04-12 12:42:49 +020031#include "flash_map_backend/flash_map_backend.h"
Ricardo Salveti3a2c1242017-01-19 10:22:35 -020032
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +020033#ifdef CONFIG_MCUBOOT_SERIAL
Marko Kiiskila149b4572018-06-06 14:18:54 +030034#include "boot_serial/boot_serial.h"
35#include "serial_adapter/serial_adapter.h"
36
37const struct boot_uart_funcs boot_funcs = {
38 .read = console_read,
39 .write = console_write
40};
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +020041#endif
42
Rajavardhan Gundi51c9d702019-02-20 14:08:52 +053043#ifdef CONFIG_BOOT_WAIT_FOR_USB_DFU
44#include <usb/class/usb_dfu.h>
45#endif
46
Andrzej Puzdrowski3f092bd2020-02-17 13:25:32 +010047#if defined(CONFIG_LOG) && !defined(CONFIG_LOG_IMMEDIATE)
48#ifdef CONFIG_LOG_PROCESS_THREAD
49#warning "The log internal thread for log processing can't transfer the log"\
50 "well for MCUBoot."
51#else
52#include <logging/log_ctrl.h>
53
54#define BOOT_LOG_STACK_SIZE 768
55#define BOOT_LOG_PROCESSING_INTERVAL 30 /* [ms] */
56
57/* log are processing in custom routine */
58K_THREAD_STACK_DEFINE(boot_log_stack, BOOT_LOG_STACK_SIZE);
59struct k_thread boot_log_thread;
Andrzej Puzdrowski84591632020-02-24 11:50:19 +010060volatile bool boot_log_stop = false;
61K_SEM_DEFINE(boot_log_sem, 1, 1);
Andrzej Puzdrowski3f092bd2020-02-17 13:25:32 +010062
63/* log processing need to be initalized by the application */
64#define ZEPHYR_BOOT_LOG_START() zephyr_boot_log_start()
Andrzej Puzdrowski84591632020-02-24 11:50:19 +010065#define ZEPHYR_BOOT_LOG_STOP() zephyr_boot_log_stop()
Andrzej Puzdrowski3f092bd2020-02-17 13:25:32 +010066#endif /* CONFIG_LOG_PROCESS_THREAD */
67#else
68/* synchronous log mode doesn't need to be initalized by the application */
69#define ZEPHYR_BOOT_LOG_START() do { } while (false)
Andrzej Puzdrowski84591632020-02-24 11:50:19 +010070#define ZEPHYR_BOOT_LOG_STOP() do { } while (false)
Andrzej Puzdrowski3f092bd2020-02-17 13:25:32 +010071#endif /* defined(CONFIG_LOG) && !defined(CONFIG_LOG_IMMEDIATE) */
72
Jon Helge Nistade58f9bd2019-11-25 15:59:52 +010073#ifdef CONFIG_SOC_FAMILY_NRF
74#include <hal/nrf_power.h>
75
76static inline bool boot_skip_serial_recovery()
77{
Fabio Utzig63b4eac2019-12-17 09:59:47 -030078#if NRF_POWER_HAS_RESETREAS
Jon Helge Nistade58f9bd2019-11-25 15:59:52 +010079 u32_t rr = nrf_power_resetreas_get(NRF_POWER);
80
81 return !(rr == 0 || (rr & NRF_POWER_RESETREAS_RESETPIN_MASK));
82#else
83 return false;
84#endif
85}
86#else
87static inline bool boot_skip_serial_recovery()
88{
89 return false;
90}
91#endif
92
Emanuele Di Santo9f1933d2018-11-20 10:59:59 +010093MCUBOOT_LOG_MODULE_REGISTER(mcuboot);
94
Andrew Boie7238f512017-03-02 13:39:06 -080095void os_heap_init(void);
96
97#if defined(CONFIG_ARM)
98struct arm_vector_table {
David Brown0d0652a2017-04-11 17:33:30 -060099 uint32_t msp;
100 uint32_t reset;
David Brown5153bd62017-01-06 11:16:53 -0700101};
102
Emanuele Di Santofcfff582018-11-01 16:06:36 +0100103extern void sys_clock_disable(void);
104
Andrew Boie7238f512017-03-02 13:39:06 -0800105static void do_boot(struct boot_rsp *rsp)
106{
David Brown0d0652a2017-04-11 17:33:30 -0600107 struct arm_vector_table *vt;
Marti Bolivareb940802017-05-01 23:15:29 -0400108 uintptr_t flash_base;
109 int rc;
Andrew Boie7238f512017-03-02 13:39:06 -0800110
David Brown0d0652a2017-04-11 17:33:30 -0600111 /* The beginning of the image is the ARM vector table, containing
112 * the initial stack pointer address and the reset vector
113 * consecutively. Manually set the stack pointer and jump into the
114 * reset vector
115 */
Marti Bolivareb940802017-05-01 23:15:29 -0400116 rc = flash_device_base(rsp->br_flash_dev_id, &flash_base);
117 assert(rc == 0);
118
119 vt = (struct arm_vector_table *)(flash_base +
120 rsp->br_image_off +
David Brown0d0652a2017-04-11 17:33:30 -0600121 rsp->br_hdr->ih_hdr_size);
122 irq_lock();
Andrzej Puzdrowski960a2d62019-08-12 16:28:26 +0200123#ifdef CONFIG_SYS_CLOCK_EXISTS
David Brown0d0652a2017-04-11 17:33:30 -0600124 sys_clock_disable();
Andrzej Puzdrowski960a2d62019-08-12 16:28:26 +0200125#endif
Jun Li01bef712019-05-08 21:55:54 -0700126#ifdef CONFIG_USB
Emanuele Di Santoc4bf7802018-07-20 11:39:57 +0200127 /* Disable the USB to prevent it from firing interrupts */
128 usb_disable();
129#endif
David Brown57837b92018-03-13 15:56:38 -0600130 __set_MSP(vt->msp);
David Brown0d0652a2017-04-11 17:33:30 -0600131 ((void (*)(void))vt->reset)();
Andrew Boie7238f512017-03-02 13:39:06 -0800132}
Rajavardhan Gundi40c28e32018-12-09 13:32:01 +0530133
134#elif defined(CONFIG_XTENSA)
135#define SRAM_BASE_ADDRESS 0xBE030000
136
137static void copy_img_to_SRAM(int slot, unsigned int hdr_offset)
138{
139 const struct flash_area *fap;
140 int area_id;
141 int rc;
142 unsigned char *dst = (unsigned char *)(SRAM_BASE_ADDRESS + hdr_offset);
143
144 BOOT_LOG_INF("Copying image to SRAM");
145
146 area_id = flash_area_id_from_image_slot(slot);
147 rc = flash_area_open(area_id, &fap);
148 if (rc != 0) {
Fabio Utzigcac58f62019-09-06 08:52:35 -0300149 BOOT_LOG_ERR("flash_area_open failed with %d\n", rc);
Rajavardhan Gundi40c28e32018-12-09 13:32:01 +0530150 goto done;
151 }
152
153 rc = flash_area_read(fap, hdr_offset, dst, fap->fa_size - hdr_offset);
154 if (rc != 0) {
Fabio Utzigcac58f62019-09-06 08:52:35 -0300155 BOOT_LOG_ERR("flash_area_read failed with %d\n", rc);
Rajavardhan Gundi40c28e32018-12-09 13:32:01 +0530156 goto done;
157 }
158
159done:
160 flash_area_close(fap);
161}
162
163/* Entry point (.ResetVector) is at the very beginning of the image.
164 * Simply copy the image to a suitable location and jump there.
165 */
166static void do_boot(struct boot_rsp *rsp)
167{
168 void *start;
169
170 BOOT_LOG_INF("br_image_off = 0x%x\n", rsp->br_image_off);
171 BOOT_LOG_INF("ih_hdr_size = 0x%x\n", rsp->br_hdr->ih_hdr_size);
172
173 /* Copy from the flash to HP SRAM */
174 copy_img_to_SRAM(0, rsp->br_hdr->ih_hdr_size);
175
176 /* Jump to entry point */
177 start = (void *)(SRAM_BASE_ADDRESS + rsp->br_hdr->ih_hdr_size);
178 ((void (*)(void))start)();
179}
180
Andrew Boie7238f512017-03-02 13:39:06 -0800181#else
182/* Default: Assume entry point is at the very beginning of the image. Simply
183 * lock interrupts and jump there. This is the right thing to do for X86 and
184 * possibly other platforms.
185 */
186static void do_boot(struct boot_rsp *rsp)
187{
Marti Bolivareb940802017-05-01 23:15:29 -0400188 uintptr_t flash_base;
David Brown0d0652a2017-04-11 17:33:30 -0600189 void *start;
Marti Bolivareb940802017-05-01 23:15:29 -0400190 int rc;
Andrew Boie7238f512017-03-02 13:39:06 -0800191
Marti Bolivareb940802017-05-01 23:15:29 -0400192 rc = flash_device_base(rsp->br_flash_dev_id, &flash_base);
193 assert(rc == 0);
194
195 start = (void *)(flash_base + rsp->br_image_off +
196 rsp->br_hdr->ih_hdr_size);
Andrew Boie7238f512017-03-02 13:39:06 -0800197
David Brown0d0652a2017-04-11 17:33:30 -0600198 /* Lock interrupts and dive into the entry point */
199 irq_lock();
200 ((void (*)(void))start)();
Andrew Boie7238f512017-03-02 13:39:06 -0800201}
202#endif
David Brown5153bd62017-01-06 11:16:53 -0700203
Andrzej Puzdrowski3f092bd2020-02-17 13:25:32 +0100204#if defined(CONFIG_LOG) && !defined(CONFIG_LOG_IMMEDIATE) &&\
205 !defined(CONFIG_LOG_PROCESS_THREAD)
206/* The log internal thread for log processing can't transfer log well as has too
207 * low priority.
208 * Dedicated thread for log processing below uses highest application
209 * priority. This allows to transmit all logs without adding k_sleep/k_yield
210 * anywhere else int the code.
211 */
212
213/* most simple log processing theread */
214void boot_log_thread_func(void *dummy1, void *dummy2, void *dummy3)
215{
216 (void)dummy1;
217 (void)dummy2;
218 (void)dummy3;
219
220 log_init();
221
222 while (1) {
223 if (log_process(false) == false) {
Andrzej Puzdrowski84591632020-02-24 11:50:19 +0100224 if (boot_log_stop) {
225 break;
226 }
Andrzej Puzdrowski3f092bd2020-02-17 13:25:32 +0100227 k_sleep(BOOT_LOG_PROCESSING_INTERVAL);
228 }
229 }
Andrzej Puzdrowski84591632020-02-24 11:50:19 +0100230
231 k_sem_give(&boot_log_sem);
Andrzej Puzdrowski3f092bd2020-02-17 13:25:32 +0100232}
233
234void zephyr_boot_log_start(void)
235{
236 /* start logging thread */
237 k_thread_create(&boot_log_thread, boot_log_stack,
238 K_THREAD_STACK_SIZEOF(boot_log_stack),
239 boot_log_thread_func, NULL, NULL, NULL,
240 K_HIGHEST_APPLICATION_THREAD_PRIO, 0,
241 BOOT_LOG_PROCESSING_INTERVAL);
242
243 k_thread_name_set(&boot_log_thread, "logging");
244}
Andrzej Puzdrowski84591632020-02-24 11:50:19 +0100245
246void zephyr_boot_log_stop(void)
247{
248 boot_log_stop = true;
249
250 /* wait until log procesing thread expired
251 * This can be reworked using a thread_join() API once a such will be
252 * available in zephyr.
253 * see https://github.com/zephyrproject-rtos/zephyr/issues/21500
254 */
255 (void)k_sem_take(&boot_log_sem, K_FOREVER);
256}
Andrzej Puzdrowski3f092bd2020-02-17 13:25:32 +0100257#endif/* defined(CONFIG_LOG) && !defined(CONFIG_LOG_IMMEDIATE) &&\
258 !defined(CONFIG_LOG_PROCESS_THREAD) */
259
David Brown5153bd62017-01-06 11:16:53 -0700260void main(void)
261{
David Brown0d0652a2017-04-11 17:33:30 -0600262 struct boot_rsp rsp;
263 int rc;
David Brown5153bd62017-01-06 11:16:53 -0700264
David Brown0d0652a2017-04-11 17:33:30 -0600265 BOOT_LOG_INF("Starting bootloader");
Ricardo Salveti7cf3d9e2017-01-18 16:38:22 -0200266
David Brown0d0652a2017-04-11 17:33:30 -0600267 os_heap_init();
David Brown5153bd62017-01-06 11:16:53 -0700268
Andrzej Puzdrowski3f092bd2020-02-17 13:25:32 +0100269 ZEPHYR_BOOT_LOG_START();
270
Rajavardhan Gundi40c28e32018-12-09 13:32:01 +0530271#if (!defined(CONFIG_XTENSA) && defined(DT_FLASH_DEV_NAME))
Andrzej Puzdrowskif50054d2018-11-14 14:33:19 +0100272 if (!flash_device_get_binding(DT_FLASH_DEV_NAME)) {
273 BOOT_LOG_ERR("Flash device %s not found", DT_FLASH_DEV_NAME);
David Brown0d0652a2017-04-11 17:33:30 -0600274 while (1)
275 ;
276 }
Rajavardhan Gundi24321c32019-02-08 12:48:34 +0530277#elif (defined(CONFIG_XTENSA) && defined(DT_JEDEC_SPI_NOR_0_LABEL))
278 if (!flash_device_get_binding(DT_JEDEC_SPI_NOR_0_LABEL)) {
279 BOOT_LOG_ERR("Flash device %s not found", DT_JEDEC_SPI_NOR_0_LABEL);
Rajavardhan Gundi40c28e32018-12-09 13:32:01 +0530280 while (1)
281 ;
282 }
Rajavardhan Gundic3353b22018-12-06 17:24:10 +0530283#endif
David Brown5153bd62017-01-06 11:16:53 -0700284
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200285#ifdef CONFIG_MCUBOOT_SERIAL
286
287 struct device *detect_port;
Peter Bigot36e90292020-01-30 05:36:47 -0600288 u32_t detect_value = !CONFIG_BOOT_SERIAL_DETECT_PIN_VAL;
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200289
290 detect_port = device_get_binding(CONFIG_BOOT_SERIAL_DETECT_PORT);
291 __ASSERT(detect_port, "Error: Bad port for boot serial detection.\n");
292
Peter Bigot36e90292020-01-30 05:36:47 -0600293 /* The default presence value is 0 which would normally be
294 * active-low, but historically the raw value was checked so we'll
295 * use the raw interface.
296 */
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200297 rc = gpio_pin_configure(detect_port, CONFIG_BOOT_SERIAL_DETECT_PIN,
Peter Bigot36e90292020-01-30 05:36:47 -0600298#ifdef GPIO_INPUT
299 GPIO_INPUT | GPIO_PULL_UP
300#else
301 GPIO_DIR_IN | GPIO_PUD_PULL_UP
302#endif
Andrzej Puzdrowski5d96bd22020-02-20 10:35:33 +0100303 );
Andrzej Puzdrowski82d73952018-06-13 14:55:51 +0200304 __ASSERT(rc == 0, "Error of boot detect pin initialization.\n");
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200305
Peter Bigot36e90292020-01-30 05:36:47 -0600306#ifdef GPIO_INPUT
307 rc = gpio_pin_get_raw(detect_port, CONFIG_BOOT_SERIAL_DETECT_PIN);
308 detect_value = rc;
309#else
Emanuele Di Santofcfff582018-11-01 16:06:36 +0100310 rc = gpio_pin_read(detect_port, CONFIG_BOOT_SERIAL_DETECT_PIN,
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200311 &detect_value);
Peter Bigot36e90292020-01-30 05:36:47 -0600312#endif
313 __ASSERT(rc >= 0, "Error of the reading the detect pin.\n");
Jon Helge Nistade58f9bd2019-11-25 15:59:52 +0100314 if (detect_value == CONFIG_BOOT_SERIAL_DETECT_PIN_VAL &&
315 !boot_skip_serial_recovery()) {
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200316 BOOT_LOG_INF("Enter the serial recovery mode");
Marko Kiiskila149b4572018-06-06 14:18:54 +0300317 rc = boot_console_init();
Carles Cufie2a36122018-06-15 10:51:02 +0200318 __ASSERT(rc == 0, "Error initializing boot console.\n");
Marko Kiiskila149b4572018-06-06 14:18:54 +0300319 boot_serial_start(&boot_funcs);
Andrzej Puzdrowski8e96b832017-09-08 16:49:14 +0200320 __ASSERT(0, "Bootloader serial process was terminated unexpectedly.\n");
321 }
322#endif
323
Rajavardhan Gundi51c9d702019-02-20 14:08:52 +0530324#ifdef CONFIG_BOOT_WAIT_FOR_USB_DFU
Andrzej Puzdrowskiac1f1ff2020-02-05 08:40:12 +0100325 rc = usb_enable(NULL);
326 if (rc) {
327 BOOT_LOG_ERR("Cannot enable USB");
328 } else {
329 BOOT_LOG_INF("Waiting for USB DFU");
330 wait_for_usb_dfu();
331 BOOT_LOG_INF("USB DFU wait time elapsed");
332 }
Rajavardhan Gundi51c9d702019-02-20 14:08:52 +0530333#endif
334
David Brown0d0652a2017-04-11 17:33:30 -0600335 rc = boot_go(&rsp);
336 if (rc != 0) {
337 BOOT_LOG_ERR("Unable to find bootable image");
338 while (1)
339 ;
340 }
David Brown5153bd62017-01-06 11:16:53 -0700341
Marti Bolivar88f48d92017-05-01 22:30:02 -0400342 BOOT_LOG_INF("Bootloader chainload address offset: 0x%x",
343 rsp.br_image_off);
Andrzej Puzdrowskib788c712018-04-12 12:42:49 +0200344
David Brown0d0652a2017-04-11 17:33:30 -0600345 BOOT_LOG_INF("Jumping to the first image slot");
Andrzej Puzdrowski84591632020-02-24 11:50:19 +0100346 ZEPHYR_BOOT_LOG_STOP();
David Brown0d0652a2017-04-11 17:33:30 -0600347 do_boot(&rsp);
David Brown5153bd62017-01-06 11:16:53 -0700348
David Brown0d0652a2017-04-11 17:33:30 -0600349 BOOT_LOG_ERR("Never should get here");
350 while (1)
351 ;
David Brown5153bd62017-01-06 11:16:53 -0700352}