小熊派开发板是否值得购买_树莓派是linux吗

版本记录

日期	版本	备注	作者
2024年2月18日	1.0.0	第二章起稿	蓝羽玄机
2024年2月21日	1.0.1	修复卡死在sp_min(bl32)部分	蓝羽玄机

前置任务

在前一篇文章已经搭建了VMware的虚拟机环境与SD卡的配置

未完成的小伙伴们可以点击连接跳转一. 小熊派bearpi-micro 移植 Linux 内核完全手册 (环境搭建篇)

下面记录移植TF-A的编译过程

获取 TF-A 源码

因为我的ubuntu repo 配置总是出问题所以我选择最笨的方法

直接根据https://gitee.com/weidongshan/manifests/blob/linux-sdk/stm32mp1/100ask_stm32mp157_pro_release-v2.0.xml的文件来git所需源代码例如 : -d 表示分支 Tfa-v2.2 就是重命名git目录

git clone https://gitee.com/weidongshan/stm32mp15xc-tf-a -d stm32mp-ya15xc Tfa-v2.2

目前所需的文件只有 Tfa-v2.2 ,ToolChain-buildroot2020 后续需要用什么我再git也可以

git clone https://e.coding.net/weidongshan/ToolChain-8.x/ToolChain-8.x -d master ToolChain

配置环境变量

这里可以查看一. 小熊派bearpi-micro 移植 Linux 内核完全手册 (环境搭建篇) 的环境搭建篇

sudo nano ~/.bashrc
在最后一行添加这三句代码
export ARCH=arm 
export CROSS_COMPILE=arm-buildroot-linux-gnueabihf- 
export PATH=$PATH:/home/book/100ask_stm32mp157_pro-sdk/ToolChain/arm-buildroot-linux-gnueabihf_sdk-buildroot/bin

输入命令使配置生效
source ~/.bashrc

测试环境变量是否配置成功

echo $CROSS_COMPILE arm-buildroot-linux-gnueabihf-

看到GCC版本表示配置成功

TF-A是什么

TF-A全称Arm Trusted Firmware(可信固件)它是一个开源的软件，最早是用在Armv8-A，ST也在MP1里面使用到了TF-A。它的作用就是隔离硬件，为硬件提供一个安全环境并且提供安全服务。TF-A只要学会使用就好了，不用过多探究，不是linux驱动开发的重点。

TF-A的官方源码还不能直接使用，需要对其打补丁。ST也是在TF-A官方的源码上将自己的MP1系列芯片添加进去的，因此必然涉及到对官方TF-A源码的修改，修改的部分就是“补丁”，补丁文件后缀为.patch，之前图片中的0001-st-update-v2.2-r2.0.0.patch就是ST为TF-A官方源码做的补丁文件，补丁文件里面描述了修改源码中的哪些文件，应该添加或删除哪些代码或文件，打完补丁后的TF-A才是真正需要的

但百问网100ask_stm32mp157所提供的开发包中提供的TF-A源码包是已经打过ST的补丁的所以这一步可以暂时跳过.有兴趣的可以查一查资料(虽然资料并不多,但操作确实不难只是在环境配置上比较繁琐)

这里推荐资料: 正点原子嵌入式linux驱动开发——TF-A使用

在开发包中提供的TF-A源码是这样的效果

samba 环境搭建(可选)

使Linux主机成为Windows网络的一份子，与Windows网络相互分享资源

这里为什么使用 samba 呢因为需要修改文件 linux 自己用不惯所以直接映射到windows 用vscode 打开进行修改了

先用apt工具进行 samba的安装

sudo apt install samba

对smb文件进行配置 (先备份在修改)

sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.bak

sudo nano /etc/samba/smb.conf

先取消[homes]、[printers]的项目，添加[temp]项目如下

将以下配置写入 smb.conf的最后一行

[temp]              #<==共享资源名称
        comment = Temporary file space #<==简单的解释，内容无关紧要
        path = /home/book     #<==实际的共享目录
        writable = yes    #<==设置为可写入
        browseable = yes   #<==可以被所有用户浏览到资源名称，
        guest ok = yes    #<==可以让用户随意登录

之后使用来重启samba 服务使配置生效

sudo /etc/init.d/smbd restart

在Windows和Linux网络都畅通的情况下，在Windows下登录Samba服务器。使用命令查看Samba的IP地址：

ifconfig

在windows资源管理器输入刚才所查到的Ubuntu的ip地址

点击回车是否能跳出以下窗口如果未跳出请检查网络或配置

输入登录ubuntu的账户密码就可以了

这时进入temp映射目录就可以看到我们原本在ubuntu中的目录

也可以选择映射到网络驱动器直接在windows 资源管理器中创建快捷方式 (如果IP发生变化会失效需要重新使用ifconfig 查看ubuntu的IP 在进行映射)

注意事项

防火墙

如果防火墙不关闭，Windows和Samba之间的连通可能会被阻挡。

Windows上关闭防火墙：控制面板->系统和安全->Windows防火墙->打开或关闭Windows防火墙；

Linux上关闭防火墙：

setenforce 0
service iptables stop

权限问题

如果出现权限时说明你所登陆的账号没有权限访问你设定的目录

最简单粗暴的方法是直接将要修改的目录赋予777权限

sudo chmod 777 /home -R

当然你也可以创建一个分组然后将samba 登陆账户分配给那个分组然后将权限给到分组上 .

因为是本地搭建个虚拟机环境来编译不涉及到外网 , 所以我就简单粗暴一点直接修改全部权限了

修改TF-A设备树

此时windows资源管理器上找到Ubuntu上TF-A的源码路径右键空白处使用VScode打开目录

修改设备树

打开TF-A2.2源码下的fdts 目录此目录所包含的文件都是设备树文件

首先先创建小熊派开发板的设备树文件 stm32mp157a-bearpi.dts 、stm32mp15-pinctrl-bearpi.dtsi 和 stm32mp15xx-bearpi.dtsi 文件这三个文件分别是根据st官方的DK1开发板来仿写的因为设备树这东西如果有相似的开发板可以直接移植过来用

创建这三个文件按照下列给出的代码来修改设备树

stm32mp157a-bearpi.dts –> stm32mp157a-dk1.dts

stm32mp15xx-bearpi.dtsi –> stm32mp15xx-dkx.dtsi

stm32mp15-pinctrl-bearpi.dtsi –> stm32mp15-pinctrl.dtsi

如果你还没了解过设备树请先学习基础课程这方面过于繁琐我只记录怎么使开发板动起来了

stm32mp157a-bearpi.dts

/dts-v1/;

 #include "stm32mp157.dtsi"
 #include "stm32mp15xa.dtsi"
 #include "stm32mp15-pinctrl.dtsi"
 #include "stm32mp15xxac-pinctrl.dtsi"
 #include "stm32mp15xx-bearpi.dtsi"
 #include <dt-bindings/soc/st,stm32-etzpc.h>
 
 / { 
   
     model = "STMicroelectronics STM32MP157A-BearPi Board";
     compatible = "st,stm32mp157a-bearpi", "st,stm32mp157";
 
     aliases { 
   
         serial0 = &uart4;
  
     };
 
     chosen { 
   
         stdout-path = "serial0:115200n8";
     };
 };
 
/** 1.0.1修改记录 * 不要写以下一段 会导致无法载入 卡死在sp_min (bl32) 个人猜测原因应该是 * 默认情况下，此外围设备分配给 MPU 非安全环境 * 而写了板专用设备树文件中的ETZPC节点用于配置安全外设的状态 * 或者 是我配置有问题 但在测试环境中不考虑安不安全了 能跑就行 ***/

// &etzpc { 
   
// st,decprot = <
// DECPROT(STM32MP1_ETZPC_USART1_ID, DECPROT_NS_RW, DECPROT_UNLOCK)
// DECPROT(STM32MP1_ETZPC_SPI6_ID, DECPROT_NS_RW, DECPROT_UNLOCK)
// DECPROT(STM32MP1_ETZPC_I2C4_ID, DECPROT_NS_RW, DECPROT_UNLOCK)
// DECPROT(STM32MP1_ETZPC_I2C6_ID, DECPROT_NS_RW, DECPROT_UNLOCK)
// DECPROT(STM32MP1_ETZPC_RNG1_ID, DECPROT_NS_RW, DECPROT_UNLOCK)
// DECPROT(STM32MP1_ETZPC_HASH1_ID, DECPROT_NS_RW, DECPROT_UNLOCK)
// DECPROT(STM32MP1_ETZPC_DDRCTRL_ID, DECPROT_NS_R_S_W, DECPROT_LOCK)
// DECPROT(STM32MP1_ETZPC_DDRPHYC_ID, DECPROT_NS_R_S_W, DECPROT_LOCK)
// DECPROT(STM32MP1_ETZPC_STGENC_ID, DECPROT_S_RW, DECPROT_LOCK)
// DECPROT(STM32MP1_ETZPC_BKPSRAM_ID, DECPROT_S_RW, DECPROT_LOCK)
// DECPROT(STM32MP1_ETZPC_IWDG1_ID, DECPROT_S_RW, DECPROT_LOCK)
// >;
// };

stm32mp15xx-bearpi.dtsi

 #include <dt-bindings/clock/stm32mp1-clksrc.h>
 #include <dt-bindings/power/stm32mp1-power.h>
 #include "stm32mp15-ddr3-1x4Gb-1066-binG.dtsi"
 
 / { 
   
     memory@c0000000 { 
   
         device_type = "memory";
         reg = <0xc0000000 0x20000000>;
     };
 
     vddcore: regulator-vddcore { 
   
         compatible = "regulator-fixed";
         regulator-name = "vddcore";
         regulator-min-microvolt = <1200000>;
         regulator-max-microvolt = <1350000>;
         regulator-always-on;
     };
 
     v3v3: regulator-3p3v { 
   
         compatible = "regulator-fixed";
         regulator-name = "v3v3";
         regulator-min-microvolt = <3300000>;
         regulator-max-microvolt = <3300000>;
         regulator-always-on;
     };
 
     vdd: regulator-vdd { 
   
         compatible = "regulator-fixed";
         regulator-name = "vdd";
         regulator-min-microvolt = <3300000>;
         regulator-max-microvolt = <3300000>;
         regulator-always-on;
     };
 
     vdd_usb: regulator-vdd-usb { 
   
         compatible = "regulator-fixed";
         regulator-name = "vdd_usb";
         regulator-min-microvolt = <3300000>;
         regulator-max-microvolt = <3300000>;
         regulator-always-on;
     };
 };
 
 &bsec { 
   
     board_id: board_id@ec { 
   
         reg = <0xec 0x4>;
         st,non-secure-otp;
     };
 };
 
 &clk_hse { 
   
     st,digbypass;
 };
 
 &hash1 { 
   
     status = "okay";
 };
 
 &i2c4 { 
   
     pinctrl-names = "default";
     pinctrl-0 = <&i2c4_pins_a>;
     i2c-scl-rising-time-ns = <185>;
     i2c-scl-falling-time-ns = <20>;
     clock-frequency = <400000>;
     status = "okay";
     secure-status = "okay";
 };
 
 &iwdg2 { 
   
     timeout-sec = <32>;
     secure-timeout-sec = <5>;
     status = "okay";
     secure-status = "okay";
 };
 
 &nvmem_layout { 
   
     nvmem-cells = <&cfg0_otp>,
               <&part_number_otp>,
               <&monotonic_otp>,
               <&nand_otp>,
               <&uid_otp>,
               <&package_otp>,
               <&hw2_otp>,
               <&pkh_otp>,
               <&board_id>;
 
     nvmem-cell-names = "cfg0_otp",
                "part_number_otp",
                "monotonic_otp",
                "nand_otp",
                "uid_otp",
                "package_otp",
                "hw2_otp",
                "pkh_otp",
                "board_id";
 };
 
 &pwr_regulators { 
   
     system_suspend_supported_soc_modes = <
         STM32_PM_CSLEEP_RUN
         STM32_PM_CSTOP_ALLOW_LP_STOP
         STM32_PM_CSTOP_ALLOW_STANDBY_DDR_SR
     >;
     system_off_soc_mode = <STM32_PM_CSTOP_ALLOW_STANDBY_DDR_OFF>;
     vdd-supply = <&vdd>;
     vdd_3v3_usbfs-supply = <&vdd_usb>;
 };
 
 &rcc { 
   
     st,hsi-cal;
     st,csi-cal;
     st,cal-sec = <60>;
     st,clksrc = <
         CLK_MPU_PLL1P
         CLK_AXI_PLL2P
         CLK_MCU_PLL3P
         CLK_PLL12_HSE
         CLK_PLL3_HSE
         CLK_PLL4_HSE
         CLK_RTC_LSE
         CLK_MCO1_DISABLED
         CLK_MCO2_DISABLED
     >;
 
     st,clkdiv = <
         1 /*MPU*/
         0 /*AXI*/
         0 /*MCU*/
         1 /*APB1*/
         1 /*APB2*/
         1 /*APB3*/
         1 /*APB4*/
         2 /*APB5*/
         23 /*RTC*/
         0 /*MCO1*/
         0 /*MCO2*/
     >;
 
     st,pkcs = <
         CLK_CKPER_HSE
         CLK_FMC_ACLK
         CLK_QSPI_ACLK
         CLK_ETH_PLL4P
         CLK_SDMMC12_PLL4P
         CLK_DSI_DSIPLL
         CLK_STGEN_HSE
         CLK_USBPHY_HSE
         CLK_SPI2S1_PLL3Q
         CLK_SPI2S23_PLL3Q
         CLK_SPI45_HSI
         CLK_SPI6_HSI
         CLK_I2C46_HSI
         CLK_SDMMC3_PLL4P
         CLK_USBO_USBPHY
         CLK_ADC_CKPER
         CLK_CEC_LSE
         CLK_I2C12_HSI
         CLK_I2C35_HSI
         CLK_UART1_HSI
         CLK_UART24_HSI
         CLK_UART35_HSI
         CLK_UART6_HSI
         CLK_UART78_HSI
         CLK_SPDIF_PLL4P
         CLK_FDCAN_PLL4R
         CLK_SAI1_PLL3Q
         CLK_SAI2_PLL3Q
         CLK_SAI3_PLL3Q
         CLK_SAI4_PLL3Q
         CLK_RNG1_LSI
         CLK_RNG2_LSI
         CLK_LPTIM1_PCLK1
         CLK_LPTIM23_PCLK3
         CLK_LPTIM45_LSE
     >;
 
     /* VCO = 1066.0 MHz => P = 266 (AXI), Q = 533 (GPU), R = 533 (DDR) */
     pll2: st,pll@1 { 
   
         compatible = "st,stm32mp1-pll";
         reg = <1>;
         cfg = <2 65 1 0 0 PQR(1,1,1)>;
         frac = <0x1400>;
     };
 
     /* VCO = 417.8 MHz => P = 209, Q = 24, R = 11 */
     pll3: st,pll@2 { 
   
         compatible = "st,stm32mp1-pll";
         reg = <2>;
         cfg = <1 33 1 16 36 PQR(1,1,1)>;
         frac = <0x1a04>;
     };
 
     /* VCO = 594.0 MHz => P = 99, Q = 74, R = 74 */
     pll4: st,pll@3 { 
   
         compatible = "st,stm32mp1-pll";
         reg = <3>;
         cfg = <3 98 5 7 7 PQR(1,1,1)>;
     };
 };
 
 &rng1 { 
   
     status = "okay";
     secure-status = "okay";
 };
 
 &rtc { 
   
     status = "okay";
     secure-status = "okay";
 };
 
 &sdmmc1 { 
   
     pinctrl-names = "default";
     pinctrl-0 = <&sdmmc1_b4_pins_a>;
     disable-wp;
     st,neg-edge;
     bus-width = <4>;
     vmmc-supply = <&v3v3>;
     status = "okay";
 };
 
 &timers15 { 
   
     secure-status = "okay";
     st,hsi-cal-input = <7>;
     st,csi-cal-input = <8>;
 };
 
 &uart4 { 
   
     pinctrl-names = "default";
     pinctrl-0 = <&uart4_pins_a>;
     status = "okay";
 };
 
 &usbotg_hs { 
   
     phys = <&usbphyc_port1 0>;
     phy-names = "usb2-phy";
     usb-role-switch;
     status = "okay";
 };
 
 &usbphyc { 
   
     status = "okay";
 };
 
 &usbphyc_port0 { 
   
     phy-supply = <&vdd_usb>;
 };
 
 &usbphyc_port1 { 
   
     phy-supply = <&vdd_usb>;
 };
 
 &vddcore { 
   
     lp-stop { 
   
         regulator-on-in-suspend;
         regulator-suspend-microvolt = <1200000>;
     };
     standby-ddr-sr { 
   
         regulator-off-in-suspend;
     };
     standby-ddr-off { 
   
         regulator-off-in-suspend;
     };
 };
 
 &v3v3 { 
   
     lp-stop { 
   
         regulator-suspend-microvolt = <3300000>;
         regulator-on-in-suspend;
     };
     standby-ddr-sr { 
   
         regulator-off-in-suspend;
     };
     standby-ddr-off { 
   
         regulator-off-in-suspend;
     };
 };
 
 &vdd { 
   
     lp-stop { 
   
         regulator-suspend-microvolt = <3300000>;
         regulator-on-in-suspend;
     };
     standby-ddr-sr { 
   
         regulator-suspend-microvolt = <3300000>;
         regulator-on-in-suspend;
     };
     standby-ddr-off { 
   
         regulator-suspend-microvolt = <3300000>;
         regulator-on-in-suspend;
     };
 };
 
 &vdd_usb { 
   
     standby-ddr-sr { 
   
         regulator-off-in-suspend;
     };
     standby-ddr-off { 
   
         regulator-off-in-suspend;
     };
 };

stm32mp15-pinctrl-bearpi.dtsi

 #include <dt-bindings/pinctrl/stm32-pinfunc.h>

 &pinctrl { 
   
     fmc_pins_a: fmc-0 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('D', 4, AF12)>, /* FMC_NOE */
                  <STM32_PINMUX('D', 5, AF12)>, /* FMC_NWE */
                  <STM32_PINMUX('D', 11, AF12)>, /* FMC_A16_FMC_CLE */
                  <STM32_PINMUX('D', 12, AF12)>, /* FMC_A17_FMC_ALE */
                  <STM32_PINMUX('D', 14, AF12)>, /* FMC_D0 */
                  <STM32_PINMUX('D', 15, AF12)>, /* FMC_D1 */
                  <STM32_PINMUX('D', 0, AF12)>, /* FMC_D2 */
                  <STM32_PINMUX('D', 1, AF12)>, /* FMC_D3 */
                  <STM32_PINMUX('E', 7, AF12)>, /* FMC_D4 */
                  <STM32_PINMUX('E', 8, AF12)>, /* FMC_D5 */
                  <STM32_PINMUX('E', 9, AF12)>, /* FMC_D6 */
                  <STM32_PINMUX('E', 10, AF12)>, /* FMC_D7 */
                  <STM32_PINMUX('G', 9, AF12)>; /* FMC_NE2_FMC_NCE */
             bias-disable;
             drive-push-pull;
             slew-rate = <1>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('D', 6, AF12)>; /* FMC_NWAIT */
             bias-pull-up;
         };
     };
 
     qspi_clk_pins_a: qspi-clk-0 { 
   
         pins { 
   
             pinmux = <STM32_PINMUX('F', 10, AF9)>; /* QSPI_CLK */
             bias-disable;
             drive-push-pull;
             slew-rate = <3>;
         };
     };
 
     qspi_bk1_pins_a: qspi-bk1-0 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('F', 8, AF10)>, /* QSPI_BK1_IO0 */
                  <STM32_PINMUX('F', 9, AF10)>, /* QSPI_BK1_IO1 */
                  <STM32_PINMUX('F', 7, AF9)>, /* QSPI_BK1_IO2 */
                  <STM32_PINMUX('F', 6, AF9)>; /* QSPI_BK1_IO3 */
             bias-disable;
             drive-push-pull;
             slew-rate = <1>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('B', 6, AF10)>; /* QSPI_BK1_NCS */
             bias-pull-up;
             drive-push-pull;
             slew-rate = <1>;
         };
     };
 
     qspi_bk2_pins_a: qspi-bk2-0 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('H', 2, AF9)>, /* QSPI_BK2_IO0 */
                  <STM32_PINMUX('H', 3, AF9)>, /* QSPI_BK2_IO1 */
                  <STM32_PINMUX('G', 10, AF11)>, /* QSPI_BK2_IO2 */
                  <STM32_PINMUX('G', 7, AF11)>; /* QSPI_BK2_IO3 */
             bias-disable;
             drive-push-pull;
             slew-rate = <1>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('C', 0, AF10)>; /* QSPI_BK2_NCS */
             bias-pull-up;
             drive-push-pull;
             slew-rate = <1>;
         };
     };
 
     rtc_out2_rmp_pins_a: rtc-out2-rmp-pins-0 { 
   
         pins { 
   
             pinmux = <STM32_PINMUX('I', 8, ANALOG)>; /* RTC_OUT2_RMP */
         };
     };
 
     sdmmc1_b4_pins_a: sdmmc1-b4-0 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('C', 8, AF12)>, /* SDMMC1_D0 */
                  <STM32_PINMUX('C', 9, AF12)>, /* SDMMC1_D1 */
                  <STM32_PINMUX('C', 10, AF12)>, /* SDMMC1_D2 */
                  <STM32_PINMUX('C', 11, AF12)>, /* SDMMC1_D3 */
                  <STM32_PINMUX('D', 2, AF12)>; /* SDMMC1_CMD */
             slew-rate = <1>;
             drive-push-pull;
             bias-disable;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('C', 12, AF12)>; /* SDMMC1_CK */
             slew-rate = <2>;
             drive-push-pull;
             bias-disable;
         };
     };
 
     sdmmc1_dir_pins_a: sdmmc1-dir-0 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('F', 2, AF11)>, /* SDMMC1_D0DIR */
                  <STM32_PINMUX('C', 7, AF8)>, /* SDMMC1_D123DIR */
                  <STM32_PINMUX('B', 9, AF11)>; /* SDMMC1_CDIR */
             slew-rate = <1>;
             drive-push-pull;
             bias-pull-up;
         };
         pins2{ 
   
             pinmux = <STM32_PINMUX('E', 4, AF8)>; /* SDMMC1_CKIN */
             bias-pull-up;
         };
     };
 
     sdmmc2_b4_pins_a: sdmmc2-b4-0 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('B', 14, AF9)>, /* SDMMC2_D0 */
                  <STM32_PINMUX('B', 15, AF9)>, /* SDMMC2_D1 */
                  <STM32_PINMUX('B', 3, AF9)>, /* SDMMC2_D2 */
                  <STM32_PINMUX('B', 4, AF9)>, /* SDMMC2_D3 */
                  <STM32_PINMUX('G', 6, AF10)>; /* SDMMC2_CMD */
             slew-rate = <1>;
             drive-push-pull;
             bias-pull-up;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('E', 3, AF9)>; /* SDMMC2_CK */
             slew-rate = <2>;
             drive-push-pull;
             bias-pull-up;
         };
     };
 
     sdmmc2_b4_pins_b: sdmmc2-b4-1 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('B', 14, AF9)>, /* SDMMC2_D0 */
                  <STM32_PINMUX('B', 15, AF9)>, /* SDMMC2_D1 */
                  <STM32_PINMUX('B', 3, AF9)>, /* SDMMC2_D2 */
                  <STM32_PINMUX('B', 4, AF9)>, /* SDMMC2_D3 */
                  <STM32_PINMUX('G', 6, AF10)>; /* SDMMC2_CMD */
             slew-rate = <1>;
             drive-push-pull;
             bias-disable;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('E', 3, AF9)>; /* SDMMC2_CK */
             slew-rate = <2>;
             drive-push-pull;
             bias-disable;
         };
     };
 
     sdmmc2_d47_pins_a: sdmmc2-d47-0 { 
   
         pins { 
   
             pinmux = <STM32_PINMUX('A', 8, AF9)>, /* SDMMC2_D4 */
                  <STM32_PINMUX('A', 9, AF10)>, /* SDMMC2_D5 */
                  <STM32_PINMUX('E', 5, AF9)>, /* SDMMC2_D6 */
                  <STM32_PINMUX('D', 3, AF9)>; /* SDMMC2_D7 */
             slew-rate = <1>;
             drive-push-pull;
             bias-pull-up;
         };
     };
 
     uart4_pins_a: uart4-0 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('G', 11, AF6)>; /* UART4_TX */
             bias-disable;
             drive-push-pull;
             slew-rate = <0>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('B', 2, AF8)>; /* UART4_RX */
             bias-disable;
         };
     };
 
     uart4_pins_b: uart4-1 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('D', 1, AF8)>; /* UART4_TX */
             bias-disable;
             drive-push-pull;
             slew-rate = <0>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('B', 2, AF8)>; /* UART4_RX */
             bias-disable;
         };
     };
 
     uart7_pins_a: uart7-0 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('E', 8, AF7)>; /* UART7_TX */
             bias-disable;
             drive-push-pull;
             slew-rate = <0>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('E', 7, AF7)>, /* UART7_RX */
                  <STM32_PINMUX('E', 10, AF7)>, /* UART7_CTS */
                  <STM32_PINMUX('E', 9, AF7)>; /* UART7_RTS */
             bias-disable;
         };
     };
 
     uart7_pins_b: uart7-1 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('F', 7, AF7)>; /* UART7_TX */
             bias-disable;
             drive-push-pull;
             slew-rate = <0>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('F', 6, AF7)>; /* UART7_RX */
             bias-disable;
         };
     };
 
     uart7_pins_c: uart7-2 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('E', 8, AF7)>; /* UART7_TX */
             bias-disable;
             drive-push-pull;
             slew-rate = <0>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('E', 7, AF7)>; /* UART7_RX */
             bias-pull-up;
         };
     };
 
     uart8_pins_a: uart8-0 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('E', 1, AF8)>; /* UART8_TX */
             bias-disable;
             drive-push-pull;
             slew-rate = <0>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('E', 0, AF8)>; /* UART8_RX */
             bias-disable;
         };
     };
 
     usart2_pins_a: usart2-0 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('F', 5, AF7)>, /* USART2_TX */
                  <STM32_PINMUX('D', 4, AF7)>; /* USART2_RTS */
             bias-disable;
             drive-push-pull;
             slew-rate = <0>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('D', 6, AF7)>, /* USART2_RX */
                  <STM32_PINMUX('D', 3, AF7)>; /* USART2_CTS_NSS */
             bias-disable;
         };
     };
 
     usart2_pins_b: usart2-1 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('F', 5, AF7)>, /* USART2_TX */
                  <STM32_PINMUX('A', 1, AF7)>; /* USART2_RTS */
             bias-disable;
             drive-push-pull;
             slew-rate = <0>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('F', 4, AF7)>, /* USART2_RX */
                  <STM32_PINMUX('E', 15, AF7)>; /* USART2_CTS_NSS */
             bias-disable;
         };
     };
 
     usart2_pins_c: usart2-2 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('D', 5, AF7)>, /* USART2_TX */
                  <STM32_PINMUX('D', 4, AF7)>; /* USART2_RTS */
             bias-disable;
             drive-push-pull;
             slew-rate = <3>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('D', 6, AF7)>, /* USART2_RX */
                  <STM32_PINMUX('D', 3, AF7)>; /* USART2_CTS_NSS */
             bias-disable;
         };
     };
 
     usart3_pins_a: usart3-0 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('B', 10, AF7)>; /* USART3_TX */
             bias-disable;
             drive-push-pull;
             slew-rate = <0>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('B', 12, AF8)>; /* USART3_RX */
             bias-disable;
         };
     };
 
     usart3_pins_b: usart3-1 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('B', 10, AF7)>, /* USART3_TX */
                  <STM32_PINMUX('G', 8, AF8)>; /* USART3_RTS */
             bias-disable;
             drive-push-pull;
             slew-rate = <0>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('B', 12, AF8)>, /* USART3_RX */
                  <STM32_PINMUX('I', 10, AF8)>; /* USART3_CTS_NSS */
             bias-disable;
         };
     };
 
     usart3_pins_c: usart3-2 { 
   
         pins1 { 
   
             pinmux = <STM32_PINMUX('B', 10, AF7)>, /* USART3_TX */
                  <STM32_PINMUX('G', 8, AF8)>; /* USART3_RTS */
             bias-disable;
             drive-push-pull;
             slew-rate = <0>;
         };
         pins2 { 
   
             pinmux = <STM32_PINMUX('B', 12, AF8)>, /* USART3_RX */
                  <STM32_PINMUX('B', 13, AF7)>; /* USART3_CTS_NSS */
             bias-pull-up;
         };
     };
 
     usbotg_hs_pins_a: usbotg-hs-0 { 
   
         pins { 
   
             pinmux = <STM32_PINMUX('A', 10, ANALOG)>; /* OTG_ID */
         };
     };
 
     usbotg_fs_dp_dm_pins_a: usbotg-fs-dp-dm-0 { 
   
         pins { 
   
             pinmux = <STM32_PINMUX('A', 11, ANALOG)>, /* OTG_FS_DM */
                  <STM32_PINMUX('A', 12, ANALOG)>; /* OTG_FS_DP */
         };
     };
 };
 
 &pinctrl_z { 
   
     i2c4_pins_a: i2c4-0 { 
   
         pins { 
   
             pinmux = <STM32_PINMUX('Z', 4, AF6)>, /* I2C4_SCL */
                  <STM32_PINMUX('Z', 5, AF6)>; /* I2C4_SDA */
             bias-disable;
             drive-open-drain;
             slew-rate = <0>;
         };
     };
 };

保存文件我们此时创建的设备树文件叫做stm32mp157a-bearpi.dts 那么这个开发板就叫做 stm32mp157a-bearpi

修改Makefile.sdk

刚才已经创建了一个交叫做stm32mp157a-bearpi的开发板我们需要修改该makefile.sdk 让其指定编译此开发版

打开根目录的Makefile.sdk 注意是 Makefile.sdk 不是Makefile文件

可以看到第24 行指定的开发板名称为

TFA_DEVICETREE ?=  stm32mp157c-100ask-512d-v1

将其修改成 (不需要加.dts)

tf-a-stm32mp157a-bearpi-trusted.stm32TFA_DEVICETREE ?=  stm32mp157a-bearpi

保存文件

编译TF-A

进入Tfa源代码路径

cd /home/book/100ask_stm32mp157_pro-sdk/Tf-A2.2/

输入下述命令进行编译

make -f Makefile.sdk all

编译后正确的结果如下所示

此时进入…/build/trusted/目录下可以看到编译后的文件

我们需要用到的文件名为 tf-a-stm32mp157a-bearpi-trusted.stm32

这里cd 到build/trusted/ 是为了查看此目录文件夹正常编译可以不用

烧录TF-A 到 SD卡

将我们上一篇文章所配置好的SD卡插入电脑并连接至ubuntu

使用此命令将编译好的TF-A烧录到SD卡的sdb1分区与sdb2分区中

sudo dd if=../build/trusted/tf-a-stm32mp157a-bearpi-trusted.stm32 of=/dev/sdb1 conv=fdatasync
sudo dd if=../build/trusted/tf-a-stm32mp157a-bearpi-trusted.stm32 of=/dev/sdb2 conv=fdatasync