• Banana Pi BPI-W3（Armsom W3）RK3588开当板之调试UART

    前言

    • 本文主要讲解如何关于RK3588开发板UART的使用和调试方法，包括UART作为普通串口和控制台两种不同使用场景

    一. 功能特点

    Rockchip UART (Universal Asynchronous Receiver/Transmitter) 基于16550A串口标准，完整模块支持以下功能：

    • 支持5、6、7、8 bits数据位。
    • 支持1、1.5、2 bits停止位。
    • 支持奇校验和偶校验，不支持mark校验和space校验。
    • 支持接收FIFO和发送FIFO，一般为32字节或者64字节。
    • 支持最高4M波特率，实际支持波特率需要芯片时钟分频策略配合。
    • 支持中断传输模式和DMA传输模式。 支持硬件自动流控，RTS+CTS。

    二、代码位置

    在Linux kernel 中，使用8250串口通用驱动，以下为主要驱动文件：

    drivers/tty/serial/8250/8250_core.c # 8250串口驱动核心 drivers/tty/serial/8250/8250_dw.c # Synopsis DesignWare 8250串口驱动 drivers/tty/serial/8250/8250_dma.c # 8250串口DMA驱动 drivers/tty/serial/8250/8250_port.c # 8250串口端口操作 drivers/tty/serial/8250/8250_early.c # 8250串口early console驱动

    SDK中提供的UART默认配置已经使用了8250驱动我们就不需要修改

    三、硬件原理图

    串口功能的硬件上比较简单，这是只附上调试串口的原理图

    四、设备树配置

    rk平台的设备树修改路径都是在kernel\arch\arm64\boot\dts\rockchip下面，具体哪个文件根据对应开发板来决定，通常描述设备硬件配置在rkxxxx.dtsi中，比如在rk3588s.dtsi中：

    1. uart2: serial@feb50000 {
    2. 		compatible = "rockchip,rk3588-uart", "snps,dw-apb-uart";
    3. 		reg = <0x0 0xfeb50000 0x0 0x100>;
    4. 		interrupts = <GIC_SPI 333 IRQ_TYPE_LEVEL_HIGH>;
    5. 		clocks = <&cru SCLK_UART2>, <&cru PCLK_UART2>;
    6. 		clock-names = "baudclk", "apb_pclk";
    7. 		reg-shift = <2>;
    8. 		reg-io-width = <4>;
    9. 		dmas = <&dmac0 10>, <&dmac0 11>;
    10. 		pinctrl-names = "default";
    11. 		pinctrl-0 = <&uart2m1_xfer>;
    12. 		status = "disabled";
    13. 	};

    4.1作为普通串口

    假入我们想使用w3开发板上40PIN上的uart7 我们在dts可以使用如下配置打开

    1. &uart7 {
    2.  
    3. status = "okay";
    4.  
    5. pinctrl-names = "default";
    6.  
    7. pinctrl-0 = <&uart7m1_xfer>;
    8.  
    9. };

    4.2作为调试串口

    Rockchip UART作为控制台，使用fiq_debugger流程。 在dts中fiq_debugger节点配置如下。由于fiq_debugger和普通串口互斥，在使能fiq_debugger节点后必须禁用对应的普通串口uart节点。

    1. chosen: chosen {
    2. 	bootargs = "earlycon=uart8250,mmio32,0xfe660000 console=ttyFIQ0";
    3. };
    4. fiq-debugger {
    5. 	compatible = "rockchip,fiq-debugger";
    6. 	rockchip,serial-id = <2>;
    7. 	rockchip,wake-irq = <0>;
    8. 	/* If enable uart uses irq instead of fiq */
    9. 	rockchip,irq-mode-enable = <1>;
    10. 	rockchip,baudrate = <1500000>; /* Only 115200 and 1500000 */
    11. 	interrupts = <GIC_SPI 252 IRQ_TYPE_LEVEL_LOW>;
    12. 	pinctrl-names = "default";
    13. 	pinctrl-0 = <&uart2m0_xfer>;
    14. 	status = "okay";
    15. };
    16. &uart2 {
    17. 	status = "disabled";
    18. };
    • rockchip,serial-id：使用的UART编号。修改serial-id到不同UART，fiq_debugger设备也会注册成
    • ttyFIQ0设备。 rockchip,irq-mode-enable：配置为1使用irq中断，配置为0使用fiq中断。
    • interrupts：配置的辅助中断，保持默认即可。
    • pinctrl-0：使用的串口引脚
    • rockchip,baudrate：波特率配置

    五、串口相关问题

    5.1设备注册

    普通串口设备将会根据dts中的aliase来对串口进行编号，对应注册成ttySx设备。注册的节点为/dev/ttyS4，命名规则是通过dts中的aliases来的。

    1. aliases {
    2. serial0 = &uart0;
    3. serial1 = &uart1;
    4. serial2 = &uart2;
    5. serial3 = &uart3;
    6. }

    对应uart0注册为ttyS0，uart0注册为ttyS1，如果需要把uart3注册成ttyS1，可以进行以下修改

    1. serial1 = &uart3;  
    2. serial3 = &uart1;

    5.2控制台打印相关

    Rockchip UART打印通常包括DDR阶段、Miniloader阶段、TF-A (Trusted Firmware-A)阶段、OP-TEE阶段、Uboot阶段和Kernel阶段，我们平时主要关注的是uboot阶段和kernel阶段的打印，在这两个阶段我们可以尝试关闭所有打印或切换所有打印到其他UART，RK平台默认的调试串口是uart2_m0这一组引脚，假如现在我将打印换成其他串口，可以尝试以下做法。

    5.2.1DDR Loader修改方法

    DDR Loader中关闭或切换打印，需要修改DDR Loader中的UART打印配置，修改文件rkbin/tools/ddrbin_param.txt中的以下参数：

    uart id= # UART控制器id，配置为0xf为关闭打印 uart iomux= # 复用的IOMUX引脚 uart baudrate= # 115200 or 1500000

    修改完成后，使用以下命令重新生成ddr.bin固件。

    ./ddrbin_tool ddrbin_param.txt rk3588_ddr_lp4_2112MHz_lp5_2736MHz_v1.09.bin

    5.2.2Uboot修改方法

    Uboot中关闭打印，需要在menuconfig中，打开配CONFIG_DISABLE_CONSOLE，保存到.config文件 Uboot中切换打印，由传参机制决定，不需要进行额外修改。uboot解析传参机制相关代码在arch/arm/mach-rockchip/board.c的board_init_f_init_serial()函数中。

    5.2.3kernel修改方法

    去掉打印需要在menuconfig中，关闭配置CONFIG_SERIAL_8250_CONSOLE。

    Device Drivers ---> Character devices ---> Serial drivers ---> [ ]Console on 8250/16550 and compatible serial port

    在dts配置中找到类似以下内容，并去掉UART基地址和console相关配置参数

    1. chosen: chosen {
    2. 		bootargs = "earlycon=uart8250,mmio32,0xfeb50000 console=ttyFIQ0 irqchip.gicv3_pseudo_nmi=0 root=PARTUUID=614e0000-0000 rw rootwait";
    3. 	};

    将0xfeb50000 console=ttyFIQ0 去掉，然后找到fiq-debugger节点，修改serial-id为0xffffffff，去掉UART引脚复用相关配置。注意，需要保持fiq�debugger节点使能，保持fiq-debugger流程系统才能正常启动

    1. fiq_debugger: fiq-debugger {
    2. 		compatible = "rockchip,fiq-debugger";
    3. 		rockchip,serial-id = <0xffffffff>;
    4. 		rockchip,wake-irq = <0>;
    5. 		/* If enable uart uses irq instead of fiq */
    6. 		rockchip,irq-mode-enable = <1>;
    7. 		rockchip,baudrate = <1500000>;  /* Only 115200 and 1500000 */
    8. 		interrupts = <GIC_SPI 423 IRQ_TYPE_LEVEL_LOW>;
    9. 		status = "okay";
    10. 	};

    切换打印串口例如将Kernel打印从UART2切换到UART3，在dts配置中找到类似以下内容，将UART基地址由UART2改为UART3.

    bootargs = "earlycon=uart8250,mmio32,0xfe670000 console=ttyFIQ0";

    0xfe670000是UART3基地址，然后找到fiq-debugger节点，修改serial-id为3，修改UART3引脚复用配置pinctrl-0 = <&uart3m0_xfer>。注意，同时需要将切换为打印串口的UART3作为普通串口的节点禁用。

    六、串口测试

    在开发板上跑一套应用程序，可以发送数据，可以接收数据，测试方法可以短接TX_RX

    1. #include <stdio.h>
    2. #include <stdlib.h>
    3. #include <errno.h>
    4. #include <unistd.h>
    5. #include <fcntl.h>
    6. #include <string.h>
    7. #include <termio.h>
    8. #include <time.h>
    9. #include <pthread.h>
    10.  
    11. int read_data(int fd, void *buf, int len);
    12. int write_data(int fd, void *buf, int len);
    13. int setup_port(int fd, int baud, int databits, int parity, int stopbits);
    14. void print_usage(char *program_name);
    15.  
    16. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    17. pthread_cond_t data_ready = PTHREAD_COND_INITIALIZER;
    18. int data_available = 0;
    19.  
    20. void *read_thread(void *arg) {
    21.     int fd = *(int *)arg;
    22.     char buffer[1024]; // 存储读取的数据
    23.  
    24.     while (1) {
    25.         int bytes_read = read_data(fd, buffer, sizeof(buffer));
    26.         if (bytes_read > 0) {
    27.             printf("Read Thread: Read %d bytes: %s\n", bytes_read, buffer);
    28.         } else {
    29.             // 处理读取错误或设备关闭的情况
    30.             break;
    31.         }
    32.     }
    33.     
    34.     pthread_exit(NULL);
    35. }
    36.  
    37. void *write_thread(void *arg) {
    38.     int fd = *(int *)arg;
    39. 	char input[1024]; // 存储用户输入的数据
    40.  
    41.     while (1) {
    42.         printf("Enter data to write (or 'q' to quit): ");
    43.         fgets(input, sizeof(input), stdin);
    44.  
    45.         if (strcmp(input, "q\n") == 0 || strcmp(input, "Q\n") == 0) {
    46.             // 用户输入 'q' 或 'Q'，退出循环
    47.             break;
    48.         }
    49.  
    50.         int len = strlen(input);
    51.         int bytes_written = write_data(fd, input, len);
    52.         if (bytes_written > 0) {
    53.             printf("Write Thread: Wrote %d bytes: %s\n", bytes_written, input);
    54.         }
    55.     }
    56.     
    57.     pthread_exit(NULL);
    58. }
    59.  
    60. int main(int argc, char *argv[]) //./a.out /dev/ttyS4 115200 8 0 1
    61. {
    62.     int fd;
    63.     int baud;
    64.     int len;
    65.     int count;
    66.     int i;
    67.     int databits;
    68.     int stopbits;
    69.     int parity;
    70.  
    71.     if (argc != 6) {
    72.         print_usage(argv[0]);
    73.         return 1;
    74.     }
    75.  
    76.     baud = atoi(argv[2]);
    77.     if ((baud < 0) || (baud > 921600)) {
    78.         fprintf(stderr, "Invalid baudrate!\n");
    79.         return 1;
    80.     }
    81.  
    82.     databits = atoi(argv[3]);
    83.     if ((databits < 5) || (databits > 8)) {
    84.         fprintf(stderr, "Invalid databits!\n");
    85.         return 1;
    86.     }
    87.  
    88.     parity = atoi(argv[4]);
    89.     if ((parity < 0) || (parity > 2)) {
    90.         fprintf(stderr, "Invalid parity!\n");
    91.         return 1;
    92.     }
    93.  
    94.     stopbits = atoi(argv[5]);
    95.     if ((stopbits < 1) || (stopbits > 2)) {
    96.         fprintf(stderr, "Invalid stopbits!\n");
    97.         return 1;
    98.     }
    99.  
    100.  
    101.     fd = open(argv[1], O_RDWR, 0);
    102.     if (fd < 0) {
    103.         fprintf(stderr, "open <%s> error %s\n", argv[1], strerror(errno));
    104.         return 1;
    105.     }
    106.  
    107.     if (setup_port(fd, baud, databits, parity, stopbits)) {
    108.         fprintf(stderr, "setup_port error %s\n", strerror(errno));
    109.         close(fd);
    110.         return 1;
    111.     }
    112. 	pthread_t read_tid, write_tid;
    113.     int ret;
    114.  
    115.     // 创建读取线程
    116.     ret = pthread_create(&read_tid, NULL, read_thread, &fd);
    117.     if (ret != 0) {
    118.         fprintf(stderr, "Failed to create read thread\n");
    119.         return 1;
    120.     }
    121.  
    122.     // 创建写入线程
    123.     ret = pthread_create(&write_tid, NULL, write_thread, &fd);
    124.     if (ret != 0) {
    125.         fprintf(stderr, "Failed to create write thread\n");
    126.         return 1;
    127.     }
    128.  
    129.     // 等待读取线程和写入线程结束
    130.     pthread_join(read_tid, NULL);
    131.     pthread_join(write_tid, NULL);
    132. 	
    133.     close(fd);
    134.  
    135.     return 0;
    136. }
    137.  
    138. static int baudflag_arr[] = {
    139.     B921600, B460800, B230400, B115200, B57600, B38400,
    140.     B19200,  B9600,   B4800,   B2400,   B1800,  B1200,
    141.     B600,    B300,    B150,    B110,    B75,    B50
    142. };
    143. static int speed_arr[] = {
    144.     921600,  460800,  230400,  115200,  57600,  38400,
    145.     19200,   9600,    4800,    2400,    1800,   1200,
    146.     600,     300,     150,     110,     75,     50
    147. };
    148.  
    149. int speed_to_flag(int speed)
    150. {
    151.     int i;
    152.  
    153.     for (i = 0;  i < sizeof(speed_arr)/sizeof(int);  i++) {
    154.         if (speed == speed_arr[i]) {
    155.             return baudflag_arr[i];
    156.         }
    157.     }
    158.  
    159.     fprintf(stderr, "Unsupported baudrate, use 9600 instead!\n");
    160.     return B9600;
    161. }
    162.  
    163. static struct termio oterm_attr;
    164.  
    165. int setup_port(int fd, int baud, int databits, int parity, int stopbits)
    166. {
    167.     struct termio term_attr;
    168.  
    169.     
    170.     if (ioctl(fd, TCGETA, &term_attr) < 0) {
    171.         return -1;
    172.     }
    173.  
    174.     
    175.     memcpy(&oterm_attr, &term_attr, sizeof(struct termio));
    176.  
    177.     term_attr.c_iflag &= ~(INLCR | IGNCR | ICRNL | ISTRIP);
    178.     term_attr.c_oflag &= ~(OPOST | ONLCR | OCRNL);
    179.     term_attr.c_lflag &= ~(ISIG | ECHO | ICANON | NOFLSH);
    180.     term_attr.c_cflag &= ~CBAUD;
    181.     term_attr.c_cflag |= CREAD | speed_to_flag(baud);
    182.  
    183.     
    184.     term_attr.c_cflag &= ~(CSIZE);
    185.     switch (databits) {
    186.         case 5:
    187.             term_attr.c_cflag |= CS5;
    188.             break;
    189.  
    190.         case 6:
    191.             term_attr.c_cflag |= CS6;
    192.             break;
    193.  
    194.         case 7:
    195.             term_attr.c_cflag |= CS7;
    196.             break;
    197.  
    198.         case 8:
    199.         default:
    200.             term_attr.c_cflag |= CS8;
    201.             break;
    202.     }
    203.  
    204.     
    205.     switch (parity) {
    206.         case 1:  
    207.             term_attr.c_cflag |= (PARENB | PARODD);
    208.             break;
    209.  
    210.         case 2:  
    211.             term_attr.c_cflag |= PARENB;
    212.             term_attr.c_cflag &= ~(PARODD);
    213.             break;
    214.  
    215.         case 0:  
    216.         default:
    217.             term_attr.c_cflag &= ~(PARENB);
    218.             break;
    219.     }
    220.  
    221.  
    222.     
    223.     switch (stopbits) {
    224.         case 2:  
    225.             term_attr.c_cflag |= CSTOPB;
    226.             break;
    227.  
    228.         case 1:  
    229.         default:
    230.             term_attr.c_cflag &= ~CSTOPB;
    231.             break;
    232.     }
    233.  
    234.     term_attr.c_cc[VMIN] = 1;
    235.     term_attr.c_cc[VTIME] = 0;
    236.  
    237.     if (ioctl(fd, TCSETAW, &term_attr) < 0) {
    238.         return -1;
    239.     }
    240.  
    241.     if (ioctl(fd, TCFLSH, 2) < 0) {
    242.         return -1;
    243.     }
    244.  
    245.     return 0;
    246. }
    247.  
    248.  
    249. int read_data(int fd, void *buf, int len)
    250. {
    251.     int count;
    252.     int ret;
    253.  
    254.     ret = 0;
    255.     count = 0;
    256.  
    257.     //while (len > 0) {
    258.  
    259.     ret = read(fd, (char*)buf + count, len);
    260.     if (ret < 1) {
    261.         fprintf(stderr, "Read error %s\n", strerror(errno));
    262.         //break;
    263.     }
    264.  
    265.     count += ret;
    266.     len = len - ret;
    267.  
    268.     //}
    269.  
    270.     *((char*)buf + count) = 0;
    271.     return count;
    272. }
    273.  
    274.  
    275. int write_data(int fd, void *buf, int len)
    276. {
    277.     int count;
    278.     int ret;
    279.  
    280.     ret = 0;
    281.     count = 0;
    282.  
    283.     while (len > 0) {
    284.  
    285.         ret = write(fd, (char*)buf + count, len);
    286.         if (ret < 1) {
    287.             fprintf(stderr, "Write error %s\n", strerror(errno));
    288.             break;
    289.         }
    290.  
    291.         count += ret;
    292.         len = len - ret;
    293.     }
    294.  
    295.     return count;
    296. }
    297.  
    298. void print_usage(char *program_name)
    299. {
    300.     fprintf(stderr,
    301.             "*************************************\n"
    302.             "  A Simple Serial Port Test Utility\n"
    303.             "*************************************\n\n"
    304.             "Usage:\n  %s      \n"
    305.             "       databits: 5, 6, 7, 8\n"
    306.             "       parity: 0(None), 1(Odd), 2(Even)\n"
    307.             "       stopbits: 1, 2\n"
    308.             "Example:\n  %s /dev/ttyS4 115200 8 0 1\n\n",
    309.             program_name, program_name
    310.            );
    311. }

    运行效果如下：

  • 相关阅读:
    【2023 · CANN训练营第一季】应用开发（初级）——第一章 AscendCL概述
    抖音小店无货源，正处于红利期内的电商项目，新手能操作吗？
    G1D5-Intriguing properties of neural networks
    精密空调里面kfb和kfd、kfc 三块pcb板子都负责什么功能？
    Node.js初体验
    Fluent Facede Pattern(外观模式）
    第四节：Vben Admin登录对接后端getUserInfo接口
    Rust学习02：推荐一本入门书，免费的
    力扣第1005题 K 次取反后最大化的数组和 c++ 贪心 双思维
    Monaco Editor教程（八）： 实现添加自定义命令，添加自定义菜单action功能
  • 原文地址：https://blog.csdn.net/sinovoip/article/details/134008668