嵌入式Linux學習筆記(四) 設備樹和UART驅動開發

目錄

(1).參考資料

(2).Uart硬件配置

(3).設備樹的說明和修改

(4).測試代碼

 

　　通過完成LED的驅動，我們熟悉了驅動編寫的大致結構框架，然而在實際開發中，嵌入式Linux和普通單片機最大的不同就是提供大量的代碼，滿足大部分的應用需求，如本節中，我們使用的UART驅動已經被集成到內核。不過通過對底層驅動更高級的抽象，使用設備樹實現了底層驅動的復用，是目前主推的驅動的開發模式，還是必須重視和掌握（后面涉及到驅動的部分都會以設備樹開發），下面就開始本小節的修改和開發。

 

參考資料

1. 開發板原理圖 《IMX6UL_ALPHA_V2.0(底板原理圖)》 《IMX6ULL_CORE_V1.4(核心板原理圖)》 

2. 正點原子《Linux驅動開發指南說明V1.0》 第四十三章 Linux設備樹

3. 正點原子《Linux驅動開發指南說明V1.0》 第四十五章 pinctrl和gpio子程序

4. 正點原子《Linux驅動開發指南說明V1.0》 第六十三章 Linux RS232/RS485/GPS驅動程序

5. 宋寶華 《Linux設備驅動開發詳解：基於最新的Linux 4.0內核》 第18章ARM Linux設備樹

 

UART硬件配置

 RS232對應的位USART3串口。

 

設備樹的說明和修改

　　在早期不支持設備樹的Linux版本，描述板級信息的代碼被集成在內核中，這就讓內核充斥着大量的冗余代碼以應對不同的開發板和產品的外設需求，如在arch/arm/mach-xxx下的板級目錄，代碼量在數萬行，為了解決這種情況，采用設備樹(Flattned Device Tree)，將硬件信息從Linux系統中剝離出來，從而不用在內核中進行大量的冗余編碼。

　　設備樹由一系列被命名的節點(Node)和屬性(Property)組成，其中節點本身可包含子節點，而屬性就是成對出現的名與值，在設備樹中，可描述的信息包含:

　　1. CPU的數量和類型

　　2.內存基地址和大小

　　3.總線和橋

　　4.外設連接

　　5.中斷控制器和中斷使用情況

　　6.GPIO控制器和GPIO使用情況

　　7.時間控制器和時鍾使用情況

　　對於設備樹的開發，如果沒有原型(如新開發的一款芯片)，對於設備樹的設計流程如下：根據硬件設計的板級信息，結合DTS語法知識，完成.dts或.dtsi文件的編寫，在通過scripts/dtc目錄下的DTC工具進行編譯，生成.dtb文件。Linux啟動后，會加載編譯完成的dtb文件到內核中，從而滿足內核模塊對於硬件和外設的操作要求。不過大多數情況下(非IC設計原廠的軟件的工程師), 都會提供好支持官方開發板的相同芯片的DTS文件，而我們的主要工作就是根據硬件設計的變動，修改這個DTS的信息以適配目前應用的需求，那么工作就簡單多了，具體分為以下幾個步驟

　　1.結合現有設備樹的Node情況，修改成符合需求Node的dts文件，編譯完成后，生成dtb文件

　　2.結合上節內容，實現字符驅動設備的添加，硬件部分操作替換成基於設備樹操作的版本

　　3.下載，編寫測試模塊並進行測試

　　按照需求，目前使用的dts文件為arch/arm/boot/dts/imx6ull-14x14-nand-4.3-480*272-c.dts, 通過內部的include代碼，我們可以找到

　　imx6ull-14x14-evk-gpmi-weim.dts ->imx6ull-14x14-evk.dts->imx6ull.dtsi

　　在imx6ull.dtsi中搜索硬件用到的uart3，通過全局檢索如下:

uart3: serial@021ec000 {
    compatible = "fsl,imx6ul-uart",
                "fsl,imx6q-uart", "fsl,imx21-uart";
    reg = <0x021ec000 0x4000>;
    interrupts = <GIC_SPI 28 IRQ_TYPE_LEVEL_HIGH>;
    clocks = <&clks IMX6UL_CLK_UART3_IPG>,
            <&clks IMX6UL_CLK_UART3_SERIAL>;
    clock-names = "ipg", "per";
    dmas = <&sdma 29 4 0>, <&sdma 30 4 0>;
    dma-names = "rx", "tx";
    status = "disabled";
};

　　其中compatible定義了整個系統(設備級別)的名稱，通過檢索Linux代碼，在drivers/tty/serial/imx.c中可以找到imx6q-uart的位置，定義在imx_uart_devtype中，仔細觀察該文件的實現，串口驅動本質上是platform驅動，包含

module_init(imx_serial_init);
module_exit(imx_serial_exit);
 
MODULE_AUTHOR("Sascha Hauer");
MODULE_DESCRIPTION("IMX generic serial port driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:imx-uart");

　　並通過platform_driver_register注冊到虛擬總線上，這部分對於內核都已經實現了，我們不要做造輪子了(在上一節為了解驅動開發，所以對驅動進行了比較深入的講解), 對於嵌入式Linux開發，分清楚何時使用官方提供的驅動，何時使用自己編寫，這是需要養成的習慣，也是與單片機開發中是重要不同點。

　　在imx6ull-14x14-evk.dts聲明了關於板級信息，在這里我們要添加GPIO對應的寄存器的信息以及在總線上添加UART3接口，因為默認配置的接口uart1和uart2，所以我們按照原本的格式添加(這部分的了解是可以隨着深入慢慢掌握的，先學會如何寫更重要)，首先我們確認位RS232接口，不需要RTS或CTS功能，搜索&uart1,檢索到數據如下:

&uart1 {
    pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_uart1>;
    status = "okay";
};

　　參考這個結構，在后面添加uart3的節點:

&uart3 {
    pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_uart3>;
    status = "okay";
};

　　從上面可以看出，我們還需要添加pinctrl_uart3對應的GPIO子系統的信息，那么很簡單，檢索全局，找到如下代碼:

pinctrl_uart1: uart1grp {
fsl,pins = <
        MX6UL_PAD_UART1_TX_DATA__UART1_DCE_TX 0x1b0b1
        MX6UL_PAD_UART1_RX_DATA__UART1_DCE_RX 0x1b0b1
        >;
};

　　參考上述結構，在后面添加UART3對應的接口：

pinctrl_uart3: uart3grp {
    fsl,pins = <
        MX6UL_PAD_UART3_TX_DATA__UART3_DCE_TX 0x1b0b1
        MX6UL_PAD_UART3_RX_DATA__UART3_DCE_RX 0x1b0b1
    >;
};

　　當然，此時還要檢索全局，判斷UART3的接口是否被用到其它模塊，如果被占用，將該模塊注釋掉。這十分重要，因為被其它模塊占用，會導致引腳的配置被覆蓋或者改變，從而驅動的注冊無效。完成上述上述流程后，將imx6ull-14x14-nand-4.3-480*272-c.dts添加到/arch/arm/boot/dts/Makefile中的dtb-$(CONFIG_SOC_IMX6ULL)下，添加后如下:

 

　　然后到linux文件夾下，使用

make dtbs

　　編譯生成需要的dtb文件如下：

 

　　將生成的dtb文件，參考之前Linux下載更新的流程，通過mgtool下載到芯片中，重新啟動，使用

ls /dev/ttymxc*

　　即可查看支持的串口，如Uart3對應的位ttymxc2，ttymxc可通過drivers/tty/serial/imx.c中的Device_Name確認，如下圖所示：

 

測試代碼

　　RS232的測試代碼和LED類似，有open/write/read/close接口實現，不過和LED不同，RS232作為通用串口，需要上層傳遞波特率，數據位，停止位，奇偶檢驗位，這是通關set_attr修改，測試代碼如下:

/*
 * File      : uart_proto.c
 * This file is uart protocolw work
 * COPYRIGHT (C) 2020, zc
 *
 * Change Logs:
 * Date           Author       Notes
 * 2020-5-4      zc           the first version
 */

/**
 * @addtogroup IMX6ULL
 */
/*@{*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>

/**************************************************************************
* Local Macro Definition
***************************************************************************/
/*協議數據格式*/
#define __DEBUG                         0

/*調試接口*/
#if __DEBUG     == 1
#define USR_DEBUG               printf
#else
void USR_DEBUG(char *format, ...){
}
#endif

#define FRAME_HEAD_SIZE         5

#define PROTO_REQ_HEAD          0x5A    /*協議數據頭*/
#define PROTO_ID                0x01    /*設備ID*/

/*設備操作指令*/
#define TYPE_CMD                0x01
#define TYPE_DATA                       0x02
#define TYPE_RST                0x03
//other reserved            0x04~0xff

#define UART_DEV_LED        0x00
#define UART_DEV_OTHERUART  0x01 //目前使用printf打印到系統遠程管理口
#define BUFFER_SIZE             1200

/*返回命令狀態*/
#define RT_OK               0
#define RT_FAIL             1
#define RT_EMPTY            2

/**************************************************************************
* Local Type Definition
***************************************************************************/
typedef signed char int8_t;
typedef signed short int16_t;
typedef signed int int32_t;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;

/*協議包結構*/
#pragma pack(push, 1)
struct req_frame
{
        uint8_t head;
        uint8_t id;
        uint8_t type;
        uint16_t length;
};
#pragma pack(pop)
struct extra_frame
{
        uint8_t *rx_ptr;
        uint8_t *tx_ptr;
        uint8_t *rx_data_ptr;
        uint16_t rx_size;
        uint16_t tx_size;
        uint16_t crc;
};

/**************************************************************************
* Local static Variable Declaration
***************************************************************************/
static uint8_t  rx_buffer[BUFFER_SIZE];
static uint8_t  tx_buffer[BUFFER_SIZE];
static const char DeviceList[][20] = {
        "/dev/ttymxc2",
};
struct req_frame *frame_ptr;
struct extra_frame proto_info = {
        .rx_ptr = rx_buffer,
        .tx_ptr = tx_buffer,
        .rx_data_ptr =  &rx_buffer[FRAME_HEAD_SIZE],
        .rx_size = 0,
        .tx_size = 0,
        .crc = 0,
};

/**************************************************************************
* Global Variable Declaration
***************************************************************************/

/**************************************************************************
* Function
***************************************************************************/
int ReceiveCheckData(int);
void protocol_process(int);
static int set_opt(int, int, int, char, int);
static uint16_t  CrcCalculate(char *, int);

/**
 * uart執行入口函數
 * 
 * @param argc
 * @param argv
 *  
 * @return the error code, 0 on initialization successfully.
 */
int main(int argc, char* argv[])
{
        const char *pDevice = DeviceList[0];
        int result = 0;
        int com_fd;

        result = daemon(1, 1);
        if(result < 0){
                perror("daemon");
                return result;
        }

        if(argc > 2){
                pDevice = argv[1];
        }

        if((com_fd = open(pDevice, O_RDWR|O_NOCTTY|O_NDELAY))<0){
                USR_DEBUG("open %s is failed\n", pDevice);
                return ;
        }
        else{
                set_opt(com_fd, 115200, 8, 'N', 1);
                USR_DEBUG("open %s success!\t\n", pDevice);
        }

        USR_DEBUG("Uart Main Task Start\n");
        write(com_fd, "Uart Start OK!\n", strlen("Uart Start OK!\n"));
        protocol_process(com_fd);

        return result;
}

/**
 * 協議執行主執行流程
 * 
 * @param fd
 *  
 * @return NULL
 */
void protocol_process(int fd)
{
        int flag;

        frame_ptr = (struct req_frame *)rx_buffer;

        for(;;){
                flag = ReceiveCheckData(fd);
                if(flag == RT_OK){
                        printf("data:%s, len:%d\n", proto_info.rx_ptr, proto_info.rx_size);
                        write(fd, proto_info.rx_ptr, proto_info.rx_size);
                        proto_info.rx_size = 0;
                }
        }
}

/**
 * 協議執行主執行流程
 * 
 * @param fd
 *  
 * @return NULL
 */
int ReceiveCheckData(int fd)
{
    int nread;
    int nLen;
    int CrcRecv, CrcCacl;

    nread = read(fd, &rx_buffer[proto_info.rx_size], (BUFFER_SIZE-proto_info.rx_size));
    if(nread > 0)
    {
       proto_info.rx_size += nread;

           /*接收到頭不符合預期*/
       if(frame_ptr->head != PROTO_REQ_HEAD) {
            USR_DEBUG("No Valid Head\n");
            proto_info.rx_size = 0;
            return RT_FAIL;
       }
       else if(proto_info.rx_size > 3){
                    /*設備ID檢測*/
            if(frame_ptr->id != PROTO_ID && frame_ptr->id != 0xff)
            {
                proto_info.rx_size = 0;
                USR_DEBUG("Valid ID\n");
                return RT_FAIL;
            }
                        /*crc檢測*/
            nLen = frame_ptr->length+7;
            if(proto_info.rx_size >= nLen)
            {
                CrcRecv = (rx_buffer[nLen-2]<<8) + rx_buffer[nLen-1];
                CrcCacl = CrcCalculate(&rx_buffer[1], nLen-3);
                if(CrcRecv == CrcCacl){
                    USR_DEBUG("CRC Check OK!\n");
                    return RT_OK;
                }
                else{
                        proto_info.rx_size = 0;
                    USR_DEBUG("CRC Check ERROR!\n");
                    return RT_FAIL;
                }
            }
       }
    }
    return RT_EMPTY;
}

/**
 * CRC16計算實現
 * 
 * @param ptr
 * @param len
 *  
 * @return NULL
 */
static uint16_t CrcCalculate(char *ptr, int len)
{
    return 0xffff;
}

/**
 * 設置uart的信息
 * 
 * @param ptr
 * @param len
 *  
 * @return NULL
 */
static int set_opt(int fd, int nSpeed, int nBits, char nEvent, int nStop)
{
        struct termios newtio;
        struct termios oldtio;

        if  ( tcgetattr( fd,&oldtio)  !=  0) {
                perror("SetupSerial 1");
                return -1;
        }
        bzero( &newtio, sizeof( newtio ) );
        newtio.c_cflag  |=  CLOCAL | CREAD;
        newtio.c_cflag &= ~CSIZE;

        switch( nBits )
        {
                case 7:
                        newtio.c_cflag |= CS7;
                        break;
                case 8:
                        newtio.c_cflag |= CS8;
                        break;
                default:
                        break;
        }

        switch( nEvent )
        {
        case 'O':
                newtio.c_cflag |= PARENB;
                newtio.c_cflag |= PARODD;
                newtio.c_iflag |= (INPCK | ISTRIP);
                break;
        case 'E':
                newtio.c_iflag |= (INPCK | ISTRIP);
                newtio.c_cflag |= PARENB;
                newtio.c_cflag &= ~PARODD;
                break;
        case 'N':
                newtio.c_cflag &= ~PARENB;
                break;
        }

        switch( nSpeed )
        {
        case 2400:
                cfsetispeed(&newtio, B2400);
                cfsetospeed(&newtio, B2400);
                break;
        case 4800:
                cfsetispeed(&newtio, B4800);
                cfsetospeed(&newtio, B4800);
                break;
        case 9600:
                cfsetispeed(&newtio, B9600);
                cfsetospeed(&newtio, B9600);
                break;
        case 115200:
                cfsetispeed(&newtio, B115200);
                cfsetospeed(&newtio, B115200);
                break;
        case 460800:
                cfsetispeed(&newtio, B460800);
                cfsetospeed(&newtio, B460800);
                break;
        case 921600:
                printf("B921600\n");
                cfsetispeed(&newtio, B921600);
                cfsetospeed(&newtio, B921600);
                break;
        default:
                cfsetispeed(&newtio, B9600);
                cfsetospeed(&newtio, B9600);
                break;
        }
        if( nStop == 1 )
                newtio.c_cflag &=  ~CSTOPB;
        else if ( nStop == 2 )
        newtio.c_cflag |=  CSTOPB;
        newtio.c_cc[VTIME]  = 0;
        newtio.c_cc[VMIN] = 0;
        tcflush(fd,TCIFLUSH);
        if((tcsetattr(fd,TCSANOW,&newtio))!=0)
        {
                perror("com set error");
                return -1;
        }
//      printf("set done!\n\r");
        return 0;
}

　　將編譯好的代碼上傳到嵌入式Linux芯片中並執行，使用串口工具即可測試通訊，如下所示: