Paul Beesley | f3653a6 | 2019-05-22 11:22:44 +0100 | [diff] [blame^] | 1 | Raspberry Pi 3 |
| 2 | ============== |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 3 | |
| 4 | .. contents:: |
| 5 | |
| 6 | The `Raspberry Pi 3`_ is an inexpensive single-board computer that contains four |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 7 | Arm Cortex-A53 cores. |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 8 | |
Dan Handley | 610e7e1 | 2018-03-01 18:44:00 +0000 | [diff] [blame] | 9 | The following instructions explain how to use this port of the TF-A with the |
| 10 | default distribution of `Raspbian`_ because that's the distribution officially |
| 11 | supported by the Raspberry Pi Foundation. At the moment of writing this, the |
| 12 | officially supported kernel is a AArch32 kernel. This doesn't mean that this |
| 13 | port of TF-A can't boot a AArch64 kernel. The `Linux tree fork`_ maintained by |
| 14 | the Foundation can be compiled for AArch64 by following the steps in |
| 15 | `AArch64 kernel build instructions`_. |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 16 | |
| 17 | **IMPORTANT NOTE**: This port isn't secure. All of the memory used is DRAM, |
| 18 | which is available from both the Non-secure and Secure worlds. This port |
| 19 | shouldn't be considered more than a prototype to play with and implement |
| 20 | elements like PSCI to support the Linux kernel. |
| 21 | |
| 22 | Design |
| 23 | ------ |
| 24 | |
| 25 | The SoC used by the Raspberry Pi 3 is the Broadcom BCM2837. It is a SoC with a |
| 26 | VideoCore IV that acts as primary processor (and loads everything from the SD |
| 27 | card) and is located between all Arm cores and the DRAM. Check the `Raspberry Pi |
| 28 | 3 documentation`_ for more information. |
| 29 | |
| 30 | This explains why it is possible to change the execution state (AArch64/AArch32) |
| 31 | depending on a few files on the SD card. We only care about the cases in which |
| 32 | the cores boot in AArch64 mode. |
| 33 | |
| 34 | The rules are simple: |
| 35 | |
| 36 | - If a file called ``kernel8.img`` is located on the ``boot`` partition of the |
| 37 | SD card, it will load it and execute in EL2 in AArch64. Basically, it executes |
| 38 | a `default AArch64 stub`_ at address **0x0** that jumps to the kernel. |
| 39 | |
| 40 | - If there is also a file called ``armstub8.bin``, it will load it at address |
| 41 | **0x0** (instead of the default stub) and execute it in EL3 in AArch64. All |
| 42 | the cores are powered on at the same time and start at address **0x0**. |
| 43 | |
| 44 | This means that we can use the default AArch32 kernel provided in the official |
Dan Handley | 610e7e1 | 2018-03-01 18:44:00 +0000 | [diff] [blame] | 45 | `Raspbian`_ distribution by renaming it to ``kernel8.img``, while TF-A and |
| 46 | anything else we need is in ``armstub8.bin``. This way we can forget about the |
| 47 | default bootstrap code. When using a AArch64 kernel, it is only needed to make |
| 48 | sure that the name on the SD card is ``kernel8.img``. |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 49 | |
| 50 | Ideally, we want to load the kernel and have all cores available, which means |
| 51 | that we need to make the secondary cores work in the way the kernel expects, as |
| 52 | explained in `Secondary cores`_. In practice, a small bootstrap is needed |
Dan Handley | 610e7e1 | 2018-03-01 18:44:00 +0000 | [diff] [blame] | 53 | between TF-A and the kernel. |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 54 | |
| 55 | To get the most out of a AArch32 kernel, we want to boot it in Hypervisor mode |
| 56 | in AArch32. This means that BL33 can't be in EL2 in AArch64 mode. The |
| 57 | architecture specifies that AArch32 Hypervisor mode isn't present when AArch64 |
| 58 | is used for EL2. When using a AArch64 kernel, it should simply start in EL2. |
| 59 | |
| 60 | Placement of images |
| 61 | ~~~~~~~~~~~~~~~~~~~ |
| 62 | |
| 63 | The file ``armstub8.bin`` contains BL1 and the FIP. It is needed to add padding |
| 64 | between them so that the addresses they are loaded to match the ones specified |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 65 | when compiling TF-A. This is done automatically by the build system. |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 66 | |
| 67 | The device tree block is loaded by the VideoCore loader from an appropriate |
| 68 | file, but we can specify the address it is loaded to in ``config.txt``. |
| 69 | |
| 70 | The file ``kernel8.img`` contains a kernel image that is loaded to the address |
| 71 | specified in ``config.txt``. The `Linux kernel tree`_ has information about how |
| 72 | a AArch32 Linux kernel image is loaded in ``Documentation/arm/Booting``: |
| 73 | |
| 74 | :: |
| 75 | |
| 76 | The zImage may also be placed in system RAM and called there. The |
| 77 | kernel should be placed in the first 128MiB of RAM. It is recommended |
| 78 | that it is loaded above 32MiB in order to avoid the need to relocate |
| 79 | prior to decompression, which will make the boot process slightly |
| 80 | faster. |
| 81 | |
| 82 | There are no similar restrictions for AArch64 kernels, as specified in the file |
| 83 | ``Documentation/arm64/booting.txt``. |
| 84 | |
| 85 | This means that we need to avoid the first 128 MiB of RAM when placing the |
Dan Handley | 610e7e1 | 2018-03-01 18:44:00 +0000 | [diff] [blame] | 86 | TF-A images (and specially the first 32 MiB, as they are directly used to |
| 87 | place the uncompressed AArch32 kernel image. This way, both AArch32 and |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 88 | AArch64 kernels can be placed at the same address. |
| 89 | |
| 90 | In the end, the images look like the following diagram when placed in memory. |
| 91 | All addresses are Physical Addresses from the point of view of the Arm cores. |
| 92 | Again, note that this is all just part of the same DRAM that goes from |
| 93 | **0x00000000** to **0x3F000000**, it just has different names to simulate a real |
| 94 | secure platform! |
| 95 | |
| 96 | :: |
| 97 | |
| 98 | 0x00000000 +-----------------+ |
| 99 | | ROM | BL1 |
Ying-Chun Liu (PaulLiu) | 51b146f | 2018-07-04 02:32:27 +0800 | [diff] [blame] | 100 | 0x00020000 +-----------------+ |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 101 | | FIP | |
| 102 | 0x00200000 +-----------------+ |
| 103 | | | |
| 104 | | ... | |
| 105 | | | |
| 106 | 0x01000000 +-----------------+ |
Antonio Nino Diaz | 8513596 | 2018-07-15 11:54:42 +0100 | [diff] [blame] | 107 | | DTB | (Loaded by the VideoCore) |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 108 | +-----------------+ |
| 109 | | | |
| 110 | | ... | |
| 111 | | | |
| 112 | 0x02000000 +-----------------+ |
Antonio Nino Diaz | 8513596 | 2018-07-15 11:54:42 +0100 | [diff] [blame] | 113 | | Kernel | (Loaded by the VideoCore) |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 114 | +-----------------+ |
| 115 | | | |
| 116 | | ... | |
| 117 | | | |
| 118 | 0x10000000 +-----------------+ |
| 119 | | Secure SRAM | BL2, BL31 |
| 120 | 0x10100000 +-----------------+ |
Ying-Chun Liu (PaulLiu) | 64c6ff1 | 2018-06-13 20:53:08 +0800 | [diff] [blame] | 121 | | Secure DRAM | BL32 (Secure payload) |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 122 | 0x11000000 +-----------------+ |
Antonio Nino Diaz | 50c5a9e | 2018-07-15 11:56:33 +0100 | [diff] [blame] | 123 | | Non-secure DRAM | BL33 |
| 124 | +-----------------+ |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 125 | | | |
| 126 | | ... | |
| 127 | | | |
| 128 | 0x3F000000 +-----------------+ |
| 129 | | I/O | |
| 130 | 0x40000000 +-----------------+ |
| 131 | |
Antonio Nino Diaz | 8513596 | 2018-07-15 11:54:42 +0100 | [diff] [blame] | 132 | The area between **0x10000000** and **0x11000000** has to be manually protected |
Antonio Nino Diaz | f96582a | 2018-10-19 00:57:16 +0100 | [diff] [blame] | 133 | so that the kernel doesn't use it. The current port tries to modify the live DTB |
| 134 | to add a memreserve region that reserves the previously mentioned area. |
| 135 | |
| 136 | If this is not possible, the user may manually add ``memmap=16M$256M`` to the |
| 137 | command line passed to the kernel in ``cmdline.txt``. See the `Setup SD card`_ |
| 138 | instructions to see how to do it. This system is strongly discouraged. |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 139 | |
| 140 | The last 16 MiB of DRAM can only be accessed by the VideoCore, that has |
| 141 | different mappings than the Arm cores in which the I/O addresses don't overlap |
| 142 | the DRAM. The memory reserved to be used by the VideoCore is always placed at |
| 143 | the end of the DRAM, so this space isn't wasted. |
| 144 | |
Dan Handley | 610e7e1 | 2018-03-01 18:44:00 +0000 | [diff] [blame] | 145 | Considering the 128 MiB allocated to the GPU and the 16 MiB allocated for |
| 146 | TF-A, there are 880 MiB available for Linux. |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 147 | |
| 148 | Boot sequence |
| 149 | ~~~~~~~~~~~~~ |
| 150 | |
Dan Handley | 610e7e1 | 2018-03-01 18:44:00 +0000 | [diff] [blame] | 151 | The boot sequence of TF-A is the usual one except when booting an AArch32 |
| 152 | kernel. In that case, BL33 is booted in AArch32 Hypervisor mode so that it |
| 153 | can jump to the kernel in the same mode and let it take over that privilege |
| 154 | level. If BL33 was running in EL2 in AArch64 (as in the default bootflow of |
| 155 | TF-A) it could only jump to the kernel in AArch32 in Supervisor mode. |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 156 | |
| 157 | The `Linux kernel tree`_ has instructions on how to jump to the Linux kernel |
| 158 | in ``Documentation/arm/Booting`` and ``Documentation/arm64/booting.txt``. The |
| 159 | bootstrap should take care of this. |
| 160 | |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 161 | This port support a direct boot of the Linux kernel from the firmware (as a BL33 |
| 162 | image). Alternatively, U-Boot or other bootloaders may be used. |
| 163 | |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 164 | Secondary cores |
| 165 | ~~~~~~~~~~~~~~~ |
| 166 | |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 167 | This port of the Trusted Firmware-A supports ``PSCI_CPU_ON``, |
Paul Beesley | f3653a6 | 2019-05-22 11:22:44 +0100 | [diff] [blame^] | 168 | ``PSCI_SYSTEM_RESET`` and ``PSCI_SYSTEM_OFF``. The last one doesn't really turn |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 169 | the system off, it simply reboots it and asks the VideoCore firmware to keep it |
| 170 | in a low power mode permanently. |
| 171 | |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 172 | The kernel used by `Raspbian`_ doesn't have support for PSCI, so it is needed to |
| 173 | use mailboxes to trap the secondary cores until they are ready to jump to the |
| 174 | kernel. This mailbox is located at a different address in the AArch32 default |
| 175 | kernel than in the AArch64 kernel. |
| 176 | |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 177 | Kernels with PSCI support can use the PSCI calls instead for a cleaner boot. |
| 178 | |
Dan Handley | 610e7e1 | 2018-03-01 18:44:00 +0000 | [diff] [blame] | 179 | Also, this port of TF-A has another Trusted Mailbox in Shared BL RAM. During |
| 180 | cold boot, all secondary cores wait in a loop until they are given given an |
| 181 | address to jump to in this Mailbox (``bl31_warm_entrypoint``). |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 182 | |
| 183 | Once BL31 has finished and the primary core has jumped to the BL33 payload, it |
| 184 | has to call ``PSCI_CPU_ON`` to release the secondary CPUs from the wait loop. |
| 185 | The payload then makes them wait in another waitloop listening from messages |
| 186 | from the kernel. When the primary CPU jumps into the kernel, it will send an |
| 187 | address to the mailbox so that the secondary CPUs jump to it and are recognised |
| 188 | by the kernel. |
| 189 | |
| 190 | Build Instructions |
| 191 | ------------------ |
| 192 | |
| 193 | To boot a AArch64 kernel, only the AArch64 toolchain is required. |
| 194 | |
| 195 | To boot a AArch32 kernel, both AArch64 and AArch32 toolchains are required. The |
| 196 | AArch32 toolchain is needed for the AArch32 bootstrap needed to load a 32-bit |
| 197 | kernel. |
| 198 | |
Antonio Nino Diaz | dfe895d | 2018-07-12 08:58:38 +0100 | [diff] [blame] | 199 | The build system concatenates BL1 and the FIP so that the addresses match the |
| 200 | ones in the memory map. The resulting file is ``armstub8.bin``, located in the |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 201 | build folder (e.g. ``build/rpi3/debug/armstub8.bin``). To know how to use this |
| 202 | file, follow the instructions in `Setup SD card`_. |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 203 | |
| 204 | The following build options are supported: |
| 205 | |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 206 | - ``RPI3_BL33_IN_AARCH32``: This port can load a AArch64 or AArch32 BL33 image. |
Dan Handley | 610e7e1 | 2018-03-01 18:44:00 +0000 | [diff] [blame] | 207 | 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 Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 210 | |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 211 | - ``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 | |
Pete Batard | c9acd6c | 2018-11-13 13:14:26 +0000 | [diff] [blame] | 231 | - ``RPI3_RUNTIME_UART``: Indicates whether the UART should be used at runtime |
| 232 | or disabled. ``-1`` (default) disables the runtime UART. Any other value |
| 233 | enables the default UART (currently UART1) for runtime messages. |
| 234 | |
Pete Batard | f820cad | 2018-11-15 22:29:59 +0000 | [diff] [blame] | 235 | - ``RPI3_USE_UEFI_MAP``: Set to 1 to build ATF with the altername memory |
Pete Batard | 3fabc88 | 2018-11-20 16:25:15 +0000 | [diff] [blame] | 236 | mapping required for an UEFI firmware payload. These changes are needed |
| 237 | to be able to run Windows on ARM64. This option, which is disabled by |
| 238 | default, results in the following memory mappings: |
Pete Batard | f820cad | 2018-11-15 22:29:59 +0000 | [diff] [blame] | 239 | |
| 240 | :: |
| 241 | |
| 242 | 0x00000000 +-----------------+ |
| 243 | | ROM | BL1 |
| 244 | 0x00010000 +-----------------+ |
| 245 | | DTB | (Loaded by the VideoCore) |
| 246 | 0x00020000 +-----------------+ |
| 247 | | FIP | |
| 248 | 0x00030000 +-----------------+ |
| 249 | | | |
| 250 | | UEFI PAYLOAD | |
| 251 | | | |
| 252 | 0x00200000 +-----------------+ |
| 253 | | Secure SRAM | BL2, BL31 |
| 254 | 0x00300000 +-----------------+ |
| 255 | | Secure DRAM | BL32 (Secure payload) |
| 256 | 0x00400000 +-----------------+ |
| 257 | | | |
| 258 | | | |
| 259 | | Non-secure DRAM | BL33 |
| 260 | | | |
| 261 | | | |
| 262 | 0x01000000 +-----------------+ |
| 263 | | | |
| 264 | | ... | |
| 265 | | | |
| 266 | 0x3F000000 +-----------------+ |
| 267 | | I/O | |
| 268 | |
Ying-Chun Liu (PaulLiu) | 64c6ff1 | 2018-06-13 20:53:08 +0800 | [diff] [blame] | 269 | - ``BL32``: This port can load and run OP-TEE. The OP-TEE image is optional. |
| 270 | Please use the code from `here <https://github.com/OP-TEE/optee_os>`__. |
| 271 | Build the Trusted Firmware with option ``BL32=tee-header_v2.bin |
| 272 | BL32_EXTRA1=tee-pager_v2.bin BL32_EXTRA2=tee-pageable_v2.bin`` |
| 273 | to put the binaries into the FIP. |
| 274 | |
Antonio Nino Diaz | 9abd78d | 2018-07-11 21:00:32 +0100 | [diff] [blame] | 275 | Note: If OP-TEE is used it may be needed to add the following options to the |
| 276 | Linux command line so that the USB driver doesn't use FIQs: |
| 277 | ``dwc_otg.fiq_enable=0 dwc_otg.fiq_fsm_enable=0 dwc_otg.nak_holdoff=0``. |
| 278 | This will unfortunately reduce the performance of the USB driver. It is needed |
| 279 | when using Raspbian, for example. |
| 280 | |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 281 | - ``TRUSTED_BOARD_BOOT``: This port supports TBB. Set this option to 1 to enable |
| 282 | it. In order to use TBB, you might want to set ``GENERATE_COT=1`` to let the |
| 283 | contents of the FIP automatically signed by the build process. The ROT key |
| 284 | will be generated and output to ``rot_key.pem`` in the build directory. It is |
| 285 | able to set ROT_KEY to your own key in PEM format. Also in order to build, |
| 286 | you need to clone mbed TLS from `here <https://github.com/ARMmbed/mbedtls>`__. |
| 287 | ``MBEDTLS_DIR`` must point at the mbed TLS source directory. |
| 288 | |
| 289 | - ``ENABLE_STACK_PROTECTOR``: Disabled by default. It uses the hardware RNG of |
| 290 | the board. |
Ying-Chun Liu (PaulLiu) | 4176e0f | 2018-07-05 14:55:21 +0800 | [diff] [blame] | 291 | |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 292 | The following is not currently supported: |
| 293 | |
Dan Handley | 610e7e1 | 2018-03-01 18:44:00 +0000 | [diff] [blame] | 294 | - AArch32 for TF-A itself. |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 295 | |
| 296 | - ``EL3_PAYLOAD_BASE``: The reason is that you can already load anything to any |
| 297 | address by changing the file ``armstub8.bin``, so there's no point in using |
Dan Handley | 610e7e1 | 2018-03-01 18:44:00 +0000 | [diff] [blame] | 298 | TF-A in this case. |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 299 | |
Antonio Nino Diaz | 1f47002 | 2018-03-27 09:39:47 +0100 | [diff] [blame] | 300 | - ``MULTI_CONSOLE_API=0``: The multi console API must be enabled. Note that the |
| 301 | crash console uses the internal 16550 driver functions directly in order to be |
| 302 | able to print error messages during early crashes before setting up the |
| 303 | multi console API. |
| 304 | |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 305 | Building the firmware for kernels that don't support PSCI |
| 306 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 307 | |
| 308 | This is the case for the 32-bit image of Raspbian, for example. 64-bit kernels |
| 309 | always support PSCI, but they may not know that the system understands PSCI due |
| 310 | to an incorrect DTB file. |
| 311 | |
| 312 | First, clone and compile the 32-bit version of the `Raspberry Pi 3 TF-A |
| 313 | bootstrap`_. Choose the one needed for the architecture of your kernel. |
| 314 | |
| 315 | Then compile TF-A. For a 32-bit kernel, use the following command line: |
| 316 | |
| 317 | .. code:: shell |
| 318 | |
| 319 | CROSS_COMPILE=aarch64-linux-gnu- make PLAT=rpi3 \ |
| 320 | RPI3_BL33_IN_AARCH32=1 \ |
| 321 | BL33=../rpi3-arm-tf-bootstrap/aarch32/el2-bootstrap.bin |
| 322 | |
| 323 | For a 64-bit kernel, use this other command line: |
| 324 | |
| 325 | .. code:: shell |
| 326 | |
| 327 | CROSS_COMPILE=aarch64-linux-gnu- make PLAT=rpi3 \ |
| 328 | BL33=../rpi3-arm-tf-bootstrap/aarch64/el2-bootstrap.bin |
| 329 | |
| 330 | However, enabling PSCI support in a 64-bit kernel is really easy. In the |
| 331 | repository `Raspberry Pi 3 TF-A bootstrap`_ there is a patch that can be applied |
| 332 | to the Linux kernel tree maintained by the Raspberry Pi foundation. It modifes |
| 333 | the DTS to tell the kernel to use PSCI. Once this patch is applied, follow the |
| 334 | instructions in `AArch64 kernel build instructions`_ to get a working 64-bit |
| 335 | kernel image and supporting files. |
| 336 | |
| 337 | Building the firmware for kernels that support PSCI |
| 338 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| 339 | |
| 340 | For a 64-bit kernel: |
| 341 | |
| 342 | .. code:: shell |
| 343 | |
| 344 | CROSS_COMPILE=aarch64-linux-gnu- make PLAT=rpi3 \ |
Antonio Nino Diaz | 8513596 | 2018-07-15 11:54:42 +0100 | [diff] [blame] | 345 | PRELOADED_BL33_BASE=0x02000000 \ |
| 346 | RPI3_PRELOADED_DTB_BASE=0x01000000 \ |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 347 | RPI3_DIRECT_LINUX_BOOT=1 |
| 348 | |
| 349 | For a 32-bit kernel: |
| 350 | |
| 351 | .. code:: shell |
| 352 | |
| 353 | CROSS_COMPILE=aarch64-linux-gnu- make PLAT=rpi3 \ |
Antonio Nino Diaz | 8513596 | 2018-07-15 11:54:42 +0100 | [diff] [blame] | 354 | PRELOADED_BL33_BASE=0x02000000 \ |
| 355 | RPI3_PRELOADED_DTB_BASE=0x01000000 \ |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 356 | RPI3_DIRECT_LINUX_BOOT=1 \ |
| 357 | RPI3_BL33_IN_AARCH32=1 |
| 358 | |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 359 | AArch64 kernel build instructions |
| 360 | --------------------------------- |
| 361 | |
| 362 | The following instructions show how to install and run a AArch64 kernel by |
| 363 | using a SD card with the default `Raspbian`_ install as base. Skip them if you |
| 364 | want to use the default 32-bit kernel. |
| 365 | |
| 366 | Note that this system won't be fully 64-bit because all the tools in the |
| 367 | filesystem are 32-bit binaries, but it's a quick way to get it working, and it |
| 368 | allows the user to run 64-bit binaries in addition to 32-bit binaries. |
| 369 | |
| 370 | 1. Clone the `Linux tree fork`_ maintained by the Raspberry Pi Foundation. To |
| 371 | speed things up, do a shallow clone of the desired branch. |
| 372 | |
| 373 | .. code:: shell |
| 374 | |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 375 | git clone --depth=1 -b rpi-4.18.y https://github.com/raspberrypi/linux |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 376 | cd linux |
| 377 | |
| 378 | 2. Configure and compile the kernel. Adapt the number after ``-j`` so that it is |
| 379 | 1.5 times the number of CPUs in your computer. This may take some time to |
| 380 | finish. |
| 381 | |
| 382 | .. code:: shell |
| 383 | |
| 384 | make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- bcmrpi3_defconfig |
| 385 | make -j 6 ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- |
| 386 | |
| 387 | 3. Copy the kernel image and the device tree to the SD card. Replace the path |
| 388 | by the corresponding path in your computers to the ``boot`` partition of the |
| 389 | SD card. |
| 390 | |
| 391 | .. code:: shell |
| 392 | |
| 393 | cp arch/arm64/boot/Image /path/to/boot/kernel8.img |
| 394 | cp arch/arm64/boot/dts/broadcom/bcm2710-rpi-3-b.dtb /path/to/boot/ |
Antonio Nino Diaz | 7c4ab21 | 2018-07-14 02:03:38 +0100 | [diff] [blame] | 395 | cp arch/arm64/boot/dts/broadcom/bcm2710-rpi-3-b-plus.dtb /path/to/boot/ |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 396 | |
| 397 | 4. Install the kernel modules. Replace the path by the corresponding path to the |
| 398 | filesystem partition of the SD card on your computer. |
| 399 | |
| 400 | .. code:: shell |
| 401 | |
| 402 | make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- \ |
| 403 | INSTALL_MOD_PATH=/path/to/filesystem modules_install |
| 404 | |
| 405 | 5. Follow the instructions in `Setup SD card`_ except for the step of renaming |
| 406 | the existing ``kernel7.img`` (we have already copied a AArch64 kernel). |
| 407 | |
| 408 | Setup SD card |
| 409 | ------------- |
| 410 | |
| 411 | The instructions assume that you have an SD card with a fresh install of |
| 412 | `Raspbian`_ (or that, at least, the ``boot`` partition is untouched, or nearly |
Antonio Nino Diaz | 1f47002 | 2018-03-27 09:39:47 +0100 | [diff] [blame] | 413 | untouched). They have been tested with the image available in 2018-03-13. |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 414 | |
| 415 | 1. Insert the SD card and open the ``boot`` partition. |
| 416 | |
| 417 | 2. Rename ``kernel7.img`` to ``kernel8.img``. This tricks the VideoCore |
Dan Handley | 610e7e1 | 2018-03-01 18:44:00 +0000 | [diff] [blame] | 418 | bootloader into booting the Arm cores in AArch64 mode, like TF-A needs, |
| 419 | even though the kernel is not compiled for AArch64. |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 420 | |
| 421 | 3. Copy ``armstub8.bin`` here. When ``kernel8.img`` is available, The VideoCore |
| 422 | bootloader will look for a file called ``armstub8.bin`` and load it at |
| 423 | address **0x0** instead of a predefined one. |
| 424 | |
Antonio Nino Diaz | f96582a | 2018-10-19 00:57:16 +0100 | [diff] [blame] | 425 | 4. To enable the serial port "Mini UART" in Linux, open ``cmdline.txt`` and add |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 426 | ``console=serial0,115200 console=tty1``. |
| 427 | |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 428 | 5. Open ``config.txt`` and add the following lines at the end (``enable_uart=1`` |
| 429 | is only needed to enable debugging through the Mini UART): |
| 430 | |
| 431 | :: |
| 432 | |
| 433 | enable_uart=1 |
Antonio Nino Diaz | 8513596 | 2018-07-15 11:54:42 +0100 | [diff] [blame] | 434 | kernel_address=0x02000000 |
| 435 | device_tree_address=0x01000000 |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 436 | |
| 437 | If you connect a serial cable to the Mini UART and your computer, and connect |
| 438 | to it (for example, with ``screen /dev/ttyUSB0 115200``) you should see some |
| 439 | text. In the case of an AArch32 kernel, you should see something like this: |
| 440 | |
| 441 | :: |
| 442 | |
| 443 | NOTICE: Booting Trusted Firmware |
| 444 | NOTICE: BL1: v1.4(release):v1.4-329-g61e94684-dirty |
| 445 | NOTICE: BL1: Built : 00:09:25, Nov 6 2017 |
| 446 | NOTICE: BL1: Booting BL2 |
| 447 | NOTICE: BL2: v1.4(release):v1.4-329-g61e94684-dirty |
| 448 | NOTICE: BL2: Built : 00:09:25, Nov 6 2017 |
| 449 | NOTICE: BL1: Booting BL31 |
| 450 | NOTICE: BL31: v1.4(release):v1.4-329-g61e94684-dirty |
| 451 | NOTICE: BL31: Built : 00:09:25, Nov 6 2017 |
| 452 | [ 0.266484] bcm2835-aux-uart 3f215040.serial: could not get clk: -517 |
| 453 | |
| 454 | Raspbian GNU/Linux 9 raspberrypi ttyS0 |
| 455 | raspberrypi login: |
| 456 | |
| 457 | Just enter your credentials, everything should work as expected. Note that the |
| 458 | HDMI output won't show any text during boot. |
| 459 | |
| 460 | .. _default Arm stub: https://github.com/raspberrypi/tools/blob/master/armstubs/armstub7.S |
| 461 | .. _default AArch64 stub: https://github.com/raspberrypi/tools/blob/master/armstubs/armstub8.S |
| 462 | .. _Linux kernel tree: https://github.com/torvalds/linux |
| 463 | .. _Linux tree fork: https://github.com/raspberrypi/linux |
| 464 | .. _Raspberry Pi 3: https://www.raspberrypi.org/products/raspberry-pi-3-model-b/ |
Dan Handley | 610e7e1 | 2018-03-01 18:44:00 +0000 | [diff] [blame] | 465 | .. _Raspberry Pi 3 TF-A bootstrap: https://github.com/AntonioND/rpi3-arm-tf-bootstrap |
Antonio Nino Diaz | 8869b48 | 2017-12-01 11:11:26 +0000 | [diff] [blame] | 466 | .. _Raspberry Pi 3 documentation: https://www.raspberrypi.org/documentation/ |
| 467 | .. _Raspbian: https://www.raspberrypi.org/downloads/raspbian/ |