blob: fbf753b09dd06275d49a14cf90a784b378cb5ca7 [file] [log] [blame]
Dan Handley610e7e12018-03-01 18:44:00 +00001Trusted Firmware-A for Raspberry Pi 3
2=====================================
Antonio Nino Diaz8869b482017-12-01 11:11:26 +00003
4.. section-numbering::
5 :suffix: .
6
7.. contents::
8
9The `Raspberry Pi 3`_ is an inexpensive single-board computer that contains four
Antonio Nino Diaz7c4ab212018-07-14 02:03:38 +010010Arm Cortex-A53 cores.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +000011
Dan Handley610e7e12018-03-01 18:44:00 +000012The following instructions explain how to use this port of the TF-A with the
13default distribution of `Raspbian`_ because that's the distribution officially
14supported by the Raspberry Pi Foundation. At the moment of writing this, the
15officially supported kernel is a AArch32 kernel. This doesn't mean that this
16port of TF-A can't boot a AArch64 kernel. The `Linux tree fork`_ maintained by
17the Foundation can be compiled for AArch64 by following the steps in
18`AArch64 kernel build instructions`_.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +000019
20**IMPORTANT NOTE**: This port isn't secure. All of the memory used is DRAM,
21which is available from both the Non-secure and Secure worlds. This port
22shouldn't be considered more than a prototype to play with and implement
23elements like PSCI to support the Linux kernel.
24
25Design
26------
27
28The SoC used by the Raspberry Pi 3 is the Broadcom BCM2837. It is a SoC with a
29VideoCore IV that acts as primary processor (and loads everything from the SD
30card) and is located between all Arm cores and the DRAM. Check the `Raspberry Pi
313 documentation`_ for more information.
32
33This explains why it is possible to change the execution state (AArch64/AArch32)
34depending on a few files on the SD card. We only care about the cases in which
35the cores boot in AArch64 mode.
36
37The rules are simple:
38
39- If a file called ``kernel8.img`` is located on the ``boot`` partition of the
40 SD card, it will load it and execute in EL2 in AArch64. Basically, it executes
41 a `default AArch64 stub`_ at address **0x0** that jumps to the kernel.
42
43- If there is also a file called ``armstub8.bin``, it will load it at address
44 **0x0** (instead of the default stub) and execute it in EL3 in AArch64. All
45 the cores are powered on at the same time and start at address **0x0**.
46
47This means that we can use the default AArch32 kernel provided in the official
Dan Handley610e7e12018-03-01 18:44:00 +000048`Raspbian`_ distribution by renaming it to ``kernel8.img``, while TF-A and
49anything else we need is in ``armstub8.bin``. This way we can forget about the
50default bootstrap code. When using a AArch64 kernel, it is only needed to make
51sure that the name on the SD card is ``kernel8.img``.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +000052
53Ideally, we want to load the kernel and have all cores available, which means
54that we need to make the secondary cores work in the way the kernel expects, as
55explained in `Secondary cores`_. In practice, a small bootstrap is needed
Dan Handley610e7e12018-03-01 18:44:00 +000056between TF-A and the kernel.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +000057
58To get the most out of a AArch32 kernel, we want to boot it in Hypervisor mode
59in AArch32. This means that BL33 can't be in EL2 in AArch64 mode. The
60architecture specifies that AArch32 Hypervisor mode isn't present when AArch64
61is used for EL2. When using a AArch64 kernel, it should simply start in EL2.
62
63Placement of images
64~~~~~~~~~~~~~~~~~~~
65
66The file ``armstub8.bin`` contains BL1 and the FIP. It is needed to add padding
67between them so that the addresses they are loaded to match the ones specified
Antonio Nino Diaz7c4ab212018-07-14 02:03:38 +010068when compiling TF-A. This is done automatically by the build system.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +000069
70The device tree block is loaded by the VideoCore loader from an appropriate
71file, but we can specify the address it is loaded to in ``config.txt``.
72
73The file ``kernel8.img`` contains a kernel image that is loaded to the address
74specified in ``config.txt``. The `Linux kernel tree`_ has information about how
75a AArch32 Linux kernel image is loaded in ``Documentation/arm/Booting``:
76
77::
78
79 The zImage may also be placed in system RAM and called there. The
80 kernel should be placed in the first 128MiB of RAM. It is recommended
81 that it is loaded above 32MiB in order to avoid the need to relocate
82 prior to decompression, which will make the boot process slightly
83 faster.
84
85There are no similar restrictions for AArch64 kernels, as specified in the file
86``Documentation/arm64/booting.txt``.
87
88This means that we need to avoid the first 128 MiB of RAM when placing the
Dan Handley610e7e12018-03-01 18:44:00 +000089TF-A images (and specially the first 32 MiB, as they are directly used to
90place the uncompressed AArch32 kernel image. This way, both AArch32 and
Antonio Nino Diaz8869b482017-12-01 11:11:26 +000091AArch64 kernels can be placed at the same address.
92
93In the end, the images look like the following diagram when placed in memory.
94All addresses are Physical Addresses from the point of view of the Arm cores.
95Again, note that this is all just part of the same DRAM that goes from
96**0x00000000** to **0x3F000000**, it just has different names to simulate a real
97secure platform!
98
99::
100
101 0x00000000 +-----------------+
102 | ROM | BL1
Ying-Chun Liu (PaulLiu)51b146f2018-07-04 02:32:27 +0800103 0x00020000 +-----------------+
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000104 | FIP |
105 0x00200000 +-----------------+
106 | |
107 | ... |
108 | |
109 0x01000000 +-----------------+
Antonio Nino Diaz85135962018-07-15 11:54:42 +0100110 | DTB | (Loaded by the VideoCore)
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000111 +-----------------+
112 | |
113 | ... |
114 | |
115 0x02000000 +-----------------+
Antonio Nino Diaz85135962018-07-15 11:54:42 +0100116 | Kernel | (Loaded by the VideoCore)
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000117 +-----------------+
118 | |
119 | ... |
120 | |
121 0x10000000 +-----------------+
122 | Secure SRAM | BL2, BL31
123 0x10100000 +-----------------+
Ying-Chun Liu (PaulLiu)64c6ff12018-06-13 20:53:08 +0800124 | Secure DRAM | BL32 (Secure payload)
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000125 0x11000000 +-----------------+
Antonio Nino Diaz50c5a9e2018-07-15 11:56:33 +0100126 | Non-secure DRAM | BL33
127 +-----------------+
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000128 | |
129 | ... |
130 | |
131 0x3F000000 +-----------------+
132 | I/O |
133 0x40000000 +-----------------+
134
Antonio Nino Diaz85135962018-07-15 11:54:42 +0100135The area between **0x10000000** and **0x11000000** has to be manually protected
136so that the kernel doesn't use it. That is done by adding ``memmap=16M$256M`` to
137the command line passed to the kernel. See the `Setup SD card`_ instructions to
138see how to do it.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000139
140The last 16 MiB of DRAM can only be accessed by the VideoCore, that has
141different mappings than the Arm cores in which the I/O addresses don't overlap
142the DRAM. The memory reserved to be used by the VideoCore is always placed at
143the end of the DRAM, so this space isn't wasted.
144
Dan Handley610e7e12018-03-01 18:44:00 +0000145Considering the 128 MiB allocated to the GPU and the 16 MiB allocated for
146TF-A, there are 880 MiB available for Linux.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000147
148Boot sequence
149~~~~~~~~~~~~~
150
Dan Handley610e7e12018-03-01 18:44:00 +0000151The boot sequence of TF-A is the usual one except when booting an AArch32
152kernel. In that case, BL33 is booted in AArch32 Hypervisor mode so that it
153can jump to the kernel in the same mode and let it take over that privilege
154level. If BL33 was running in EL2 in AArch64 (as in the default bootflow of
155TF-A) it could only jump to the kernel in AArch32 in Supervisor mode.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000156
157The `Linux kernel tree`_ has instructions on how to jump to the Linux kernel
158in ``Documentation/arm/Booting`` and ``Documentation/arm64/booting.txt``. The
159bootstrap should take care of this.
160
Antonio Nino Diaz7c4ab212018-07-14 02:03:38 +0100161This port support a direct boot of the Linux kernel from the firmware (as a BL33
162image). Alternatively, U-Boot or other bootloaders may be used.
163
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000164Secondary cores
165~~~~~~~~~~~~~~~
166
Antonio Nino Diaz7c4ab212018-07-14 02:03:38 +0100167This port of the Trusted Firmware-A supports ``PSCI_CPU_ON``,
168`PSCI_SYSTEM_RESET`` and ``PSCI_SYSTEM_OFF``. The last one doesn't really turn
169the system off, it simply reboots it and asks the VideoCore firmware to keep it
170in a low power mode permanently.
171
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000172The kernel used by `Raspbian`_ doesn't have support for PSCI, so it is needed to
173use mailboxes to trap the secondary cores until they are ready to jump to the
174kernel. This mailbox is located at a different address in the AArch32 default
175kernel than in the AArch64 kernel.
176
Antonio Nino Diaz7c4ab212018-07-14 02:03:38 +0100177Kernels with PSCI support can use the PSCI calls instead for a cleaner boot.
178
Dan Handley610e7e12018-03-01 18:44:00 +0000179Also, this port of TF-A has another Trusted Mailbox in Shared BL RAM. During
180cold boot, all secondary cores wait in a loop until they are given given an
181address to jump to in this Mailbox (``bl31_warm_entrypoint``).
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000182
183Once BL31 has finished and the primary core has jumped to the BL33 payload, it
184has to call ``PSCI_CPU_ON`` to release the secondary CPUs from the wait loop.
185The payload then makes them wait in another waitloop listening from messages
186from the kernel. When the primary CPU jumps into the kernel, it will send an
187address to the mailbox so that the secondary CPUs jump to it and are recognised
188by the kernel.
189
190Build Instructions
191------------------
192
193To boot a AArch64 kernel, only the AArch64 toolchain is required.
194
195To boot a AArch32 kernel, both AArch64 and AArch32 toolchains are required. The
196AArch32 toolchain is needed for the AArch32 bootstrap needed to load a 32-bit
197kernel.
198
Antonio Nino Diazdfe895d2018-07-12 08:58:38 +0100199The build system concatenates BL1 and the FIP so that the addresses match the
200ones in the memory map. The resulting file is ``armstub8.bin``, located in the
Antonio Nino Diaz7c4ab212018-07-14 02:03:38 +0100201build folder (e.g. ``build/rpi3/debug/armstub8.bin``). To know how to use this
202file, follow the instructions in `Setup SD card`_.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000203
204The following build options are supported:
205
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000206- ``RPI3_BL33_IN_AARCH32``: This port can load a AArch64 or AArch32 BL33 image.
Dan Handley610e7e12018-03-01 18:44:00 +0000207 By default this option is 0, which means that TF-A will jump to BL33 in EL2
208 in AArch64 mode. If set to 1, it will jump to BL33 in Hypervisor in AArch32
209 mode.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000210
Antonio Nino Diaz7c4ab212018-07-14 02:03:38 +0100211- ``PRELOADED_BL33_BASE``: Used to specify the address of a BL33 binary that has
212 been preloaded by any other system than using the firmware. ``BL33`` isn't
213 needed in the build command line if this option is used. Specially useful
214 because the file ``kernel8.img`` can be loaded anywhere by modifying the file
215 ``config.txt``. It doesn't have to contain a kernel, it could have any
216 arbitrary payload.
217
218- ``RPI3_DIRECT_LINUX_BOOT``: Disabled by default. Set to 1 to enable the direct
219 boot of the Linux kernel from the firmware. Option ``RPI3_PRELOADED_DTB_BASE``
220 is mandatory when the direct Linux kernel boot is used. Options
221 ``PRELOADED_BL33_BASE`` will most likely be needed as well because it is
222 unlikely that the kernel image will fit in the space reserved for BL33 images.
223 This option can be combined with ``RPI3_BL33_IN_AARCH32`` in order to boot a
224 32-bit kernel. The only thing this option does is to set the arguments in
225 registers x0-x3 or r0-r2 as expected by the kernel.
226
227- ``RPI3_PRELOADED_DTB_BASE``: Auxiliary build option needed when using
228 ``RPI3_DIRECT_LINUX_BOOT=1``. This option allows to specify the location of a
229 DTB in memory.
230
Ying-Chun Liu (PaulLiu)64c6ff12018-06-13 20:53:08 +0800231- ``BL32``: This port can load and run OP-TEE. The OP-TEE image is optional.
232 Please use the code from `here <https://github.com/OP-TEE/optee_os>`__.
233 Build the Trusted Firmware with option ``BL32=tee-header_v2.bin
234 BL32_EXTRA1=tee-pager_v2.bin BL32_EXTRA2=tee-pageable_v2.bin``
235 to put the binaries into the FIP.
236
Antonio Nino Diaz9abd78d2018-07-11 21:00:32 +0100237 Note: If OP-TEE is used it may be needed to add the following options to the
238 Linux command line so that the USB driver doesn't use FIQs:
239 ``dwc_otg.fiq_enable=0 dwc_otg.fiq_fsm_enable=0 dwc_otg.nak_holdoff=0``.
240 This will unfortunately reduce the performance of the USB driver. It is needed
241 when using Raspbian, for example.
242
Antonio Nino Diaz7c4ab212018-07-14 02:03:38 +0100243- ``TRUSTED_BOARD_BOOT``: This port supports TBB. Set this option to 1 to enable
244 it. In order to use TBB, you might want to set ``GENERATE_COT=1`` to let the
245 contents of the FIP automatically signed by the build process. The ROT key
246 will be generated and output to ``rot_key.pem`` in the build directory. It is
247 able to set ROT_KEY to your own key in PEM format. Also in order to build,
248 you need to clone mbed TLS from `here <https://github.com/ARMmbed/mbedtls>`__.
249 ``MBEDTLS_DIR`` must point at the mbed TLS source directory.
250
251- ``ENABLE_STACK_PROTECTOR``: Disabled by default. It uses the hardware RNG of
252 the board.
Ying-Chun Liu (PaulLiu)4176e0f2018-07-05 14:55:21 +0800253
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000254The following is not currently supported:
255
Dan Handley610e7e12018-03-01 18:44:00 +0000256- AArch32 for TF-A itself.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000257
258- ``EL3_PAYLOAD_BASE``: The reason is that you can already load anything to any
259 address by changing the file ``armstub8.bin``, so there's no point in using
Dan Handley610e7e12018-03-01 18:44:00 +0000260 TF-A in this case.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000261
Antonio Nino Diaz1f470022018-03-27 09:39:47 +0100262- ``MULTI_CONSOLE_API=0``: The multi console API must be enabled. Note that the
263 crash console uses the internal 16550 driver functions directly in order to be
264 able to print error messages during early crashes before setting up the
265 multi console API.
266
Antonio Nino Diaz7c4ab212018-07-14 02:03:38 +0100267Building the firmware for kernels that don't support PSCI
268~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
269
270This is the case for the 32-bit image of Raspbian, for example. 64-bit kernels
271always support PSCI, but they may not know that the system understands PSCI due
272to an incorrect DTB file.
273
274First, clone and compile the 32-bit version of the `Raspberry Pi 3 TF-A
275bootstrap`_. Choose the one needed for the architecture of your kernel.
276
277Then compile TF-A. For a 32-bit kernel, use the following command line:
278
279.. code:: shell
280
281 CROSS_COMPILE=aarch64-linux-gnu- make PLAT=rpi3 \
282 RPI3_BL33_IN_AARCH32=1 \
283 BL33=../rpi3-arm-tf-bootstrap/aarch32/el2-bootstrap.bin
284
285For a 64-bit kernel, use this other command line:
286
287.. code:: shell
288
289 CROSS_COMPILE=aarch64-linux-gnu- make PLAT=rpi3 \
290 BL33=../rpi3-arm-tf-bootstrap/aarch64/el2-bootstrap.bin
291
292However, enabling PSCI support in a 64-bit kernel is really easy. In the
293repository `Raspberry Pi 3 TF-A bootstrap`_ there is a patch that can be applied
294to the Linux kernel tree maintained by the Raspberry Pi foundation. It modifes
295the DTS to tell the kernel to use PSCI. Once this patch is applied, follow the
296instructions in `AArch64 kernel build instructions`_ to get a working 64-bit
297kernel image and supporting files.
298
299Building the firmware for kernels that support PSCI
300~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
301
302For a 64-bit kernel:
303
304.. code:: shell
305
306 CROSS_COMPILE=aarch64-linux-gnu- make PLAT=rpi3 \
Antonio Nino Diaz85135962018-07-15 11:54:42 +0100307 PRELOADED_BL33_BASE=0x02000000 \
308 RPI3_PRELOADED_DTB_BASE=0x01000000 \
Antonio Nino Diaz7c4ab212018-07-14 02:03:38 +0100309 RPI3_DIRECT_LINUX_BOOT=1
310
311For a 32-bit kernel:
312
313.. code:: shell
314
315 CROSS_COMPILE=aarch64-linux-gnu- make PLAT=rpi3 \
Antonio Nino Diaz85135962018-07-15 11:54:42 +0100316 PRELOADED_BL33_BASE=0x02000000 \
317 RPI3_PRELOADED_DTB_BASE=0x01000000 \
Antonio Nino Diaz7c4ab212018-07-14 02:03:38 +0100318 RPI3_DIRECT_LINUX_BOOT=1 \
319 RPI3_BL33_IN_AARCH32=1
320
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000321AArch64 kernel build instructions
322---------------------------------
323
324The following instructions show how to install and run a AArch64 kernel by
325using a SD card with the default `Raspbian`_ install as base. Skip them if you
326want to use the default 32-bit kernel.
327
328Note that this system won't be fully 64-bit because all the tools in the
329filesystem are 32-bit binaries, but it's a quick way to get it working, and it
330allows the user to run 64-bit binaries in addition to 32-bit binaries.
331
3321. Clone the `Linux tree fork`_ maintained by the Raspberry Pi Foundation. To
333 speed things up, do a shallow clone of the desired branch.
334
335.. code:: shell
336
Antonio Nino Diaz7c4ab212018-07-14 02:03:38 +0100337 git clone --depth=1 -b rpi-4.18.y https://github.com/raspberrypi/linux
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000338 cd linux
339
3402. Configure and compile the kernel. Adapt the number after ``-j`` so that it is
341 1.5 times the number of CPUs in your computer. This may take some time to
342 finish.
343
344.. code:: shell
345
346 make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- bcmrpi3_defconfig
347 make -j 6 ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu-
348
3493. Copy the kernel image and the device tree to the SD card. Replace the path
350 by the corresponding path in your computers to the ``boot`` partition of the
351 SD card.
352
353.. code:: shell
354
355 cp arch/arm64/boot/Image /path/to/boot/kernel8.img
356 cp arch/arm64/boot/dts/broadcom/bcm2710-rpi-3-b.dtb /path/to/boot/
Antonio Nino Diaz7c4ab212018-07-14 02:03:38 +0100357 cp arch/arm64/boot/dts/broadcom/bcm2710-rpi-3-b-plus.dtb /path/to/boot/
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000358
3594. Install the kernel modules. Replace the path by the corresponding path to the
360 filesystem partition of the SD card on your computer.
361
362.. code:: shell
363
364 make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- \
365 INSTALL_MOD_PATH=/path/to/filesystem modules_install
366
3675. Follow the instructions in `Setup SD card`_ except for the step of renaming
368 the existing ``kernel7.img`` (we have already copied a AArch64 kernel).
369
370Setup SD card
371-------------
372
373The instructions assume that you have an SD card with a fresh install of
374`Raspbian`_ (or that, at least, the ``boot`` partition is untouched, or nearly
Antonio Nino Diaz1f470022018-03-27 09:39:47 +0100375untouched). They have been tested with the image available in 2018-03-13.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000376
3771. Insert the SD card and open the ``boot`` partition.
378
3792. Rename ``kernel7.img`` to ``kernel8.img``. This tricks the VideoCore
Dan Handley610e7e12018-03-01 18:44:00 +0000380 bootloader into booting the Arm cores in AArch64 mode, like TF-A needs,
381 even though the kernel is not compiled for AArch64.
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000382
3833. Copy ``armstub8.bin`` here. When ``kernel8.img`` is available, The VideoCore
384 bootloader will look for a file called ``armstub8.bin`` and load it at
385 address **0x0** instead of a predefined one.
386
Antonio Nino Diaz73ecb9f2018-06-13 13:34:46 +01003874. Open ``cmdline.txt`` and add ``memmap=16M$256M`` to prevent the kernel from
Dan Handley610e7e12018-03-01 18:44:00 +0000388 using the memory needed by TF-A. If you want to enable the serial port
389 "Mini UART", make sure that this file also contains
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000390 ``console=serial0,115200 console=tty1``.
391
392 Note that the 16 MiB reserved this way won't be available for Linux, the same
393 way as the memory reserved in DRAM for the GPU isn't available.
394
3955. Open ``config.txt`` and add the following lines at the end (``enable_uart=1``
396 is only needed to enable debugging through the Mini UART):
397
398::
399
400 enable_uart=1
Antonio Nino Diaz85135962018-07-15 11:54:42 +0100401 kernel_address=0x02000000
402 device_tree_address=0x01000000
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000403
404If you connect a serial cable to the Mini UART and your computer, and connect
405to it (for example, with ``screen /dev/ttyUSB0 115200``) you should see some
406text. In the case of an AArch32 kernel, you should see something like this:
407
408::
409
410 NOTICE: Booting Trusted Firmware
411 NOTICE: BL1: v1.4(release):v1.4-329-g61e94684-dirty
412 NOTICE: BL1: Built : 00:09:25, Nov 6 2017
413 NOTICE: BL1: Booting BL2
414 NOTICE: BL2: v1.4(release):v1.4-329-g61e94684-dirty
415 NOTICE: BL2: Built : 00:09:25, Nov 6 2017
416 NOTICE: BL1: Booting BL31
417 NOTICE: BL31: v1.4(release):v1.4-329-g61e94684-dirty
418 NOTICE: BL31: Built : 00:09:25, Nov 6 2017
419 [ 0.266484] bcm2835-aux-uart 3f215040.serial: could not get clk: -517
420
421 Raspbian GNU/Linux 9 raspberrypi ttyS0
422 raspberrypi login:
423
424Just enter your credentials, everything should work as expected. Note that the
425HDMI output won't show any text during boot.
426
427.. _default Arm stub: https://github.com/raspberrypi/tools/blob/master/armstubs/armstub7.S
428.. _default AArch64 stub: https://github.com/raspberrypi/tools/blob/master/armstubs/armstub8.S
429.. _Linux kernel tree: https://github.com/torvalds/linux
430.. _Linux tree fork: https://github.com/raspberrypi/linux
431.. _Raspberry Pi 3: https://www.raspberrypi.org/products/raspberry-pi-3-model-b/
Dan Handley610e7e12018-03-01 18:44:00 +0000432.. _Raspberry Pi 3 TF-A bootstrap: https://github.com/AntonioND/rpi3-arm-tf-bootstrap
Antonio Nino Diaz8869b482017-12-01 11:11:26 +0000433.. _Raspberry Pi 3 documentation: https://www.raspberrypi.org/documentation/
434.. _Raspbian: https://www.raspberrypi.org/downloads/raspbian/