[uboot] （番外篇）uboot串口&console&stdio设备工作流程 （转）

[uboot] uboot流程系列：
[project X] tiny210(s5pv210)上电启动流程（BL0-BL2）
[project X] tiny210(s5pv210)从存储设备加载代码到DDR
[uboot] （第一章）uboot流程——概述
[uboot] （第二章）uboot流程——uboot-spl编译流程
[uboot] （第三章）uboot流程——uboot-spl代码流程
[uboot] （第四章）uboot流程——uboot编译流程
[uboot] （第五章）uboot流程——uboot启动流程
[uboot] （番外篇）global_data介绍
[uboot] （番外篇）uboot relocation介绍
[uboot] （番外篇）uboot 驱动模型

建议先看《[uboot] （番外篇）uboot 驱动模型》

=============================================================================================================
一、uboot serial框架
1、serial模块驱动模型

在《[uboot] （番外篇）uboot 驱动模型》中我们已经介绍uboot的驱动模型，uboot DM。
在uboot中，serial模块也使用了对应的驱动模型。
其框架图如下：
这里写图片描述
我们在《[uboot] （番外篇）uboot 驱动模型》已经说明过了，这里再简单解释一下：

    serial core为serial模块向外提供接口，但是也是在serial-uclass中实现
    serial uclass是serial设备的集合抽象，为serial设备提供统一的操作接口，serial uclass driver则是其对应的驱动
    serial udevice是serial设备的具体抽象，代表了一个serial设备对象，serial driver则是其对应的驱动

2、serial DM实现

在《[uboot] （番外篇）uboot 驱动模型》中，我们已经知道了uclass和udevice由uboot动态生成，但是我们需要在dtsi中添加相应的设备信息，以及添加相应的uclass driver和udevice driver.
以tiny210为例，如下：

    dts中的设备信息

/{
    aliases {
        console = "/serial@e2900000";
    };

    serial@e2900000 {
        compatible = "samsung,exynos4210-uart";
        reg = <0xe2900000 0x100>;
        interrupts = <0 51 0>;
        id = <0>;
    };
};

这里，有些人或许会有疑问，在relocate之前就需要打印串口数据，就需要使用到这个节点了，为什么不需要加上“u-boot,dm-pre-reloc”属性？
确实是可以加，但是不加也没事，因为console中已经指定了串口节点的路径，在relocate之前的串口初始化过程中，在设备链表上找不到对应串口设备的话，会强制绑定console指定的串口节点的设备。

    uclass driver
    driver/serial/serial-uclass.c

UCLASS_DRIVER(serial) = {
    .id     = UCLASS_SERIAL,
    .name       = "serial",
    .flags      = DM_UC_FLAG_SEQ_ALIAS,
    .post_probe = serial_post_probe,
    .pre_remove = serial_pre_remove,
    .per_device_auto_alloc_size = sizeof(struct serial_dev_priv),
};

    udevice driver
    driver/serial/serial_s5p.c

static const struct udevice_id s5p_serial_ids[] = {
    { .compatible = "samsung,exynos4210-uart" },  // 必须和dts匹配
    { }
};

// s5p serial driver 提供了如下操作集
static const struct dm_serial_ops s5p_serial_ops = {
    .putc = s5p_serial_putc,
    .pending = s5p_serial_pending,
    .getc = s5p_serial_getc,
    .setbrg = s5p_serial_setbrg,
};

U_BOOT_DRIVER(serial_s5p) = {
    .name   = "serial_s5p",
    .id = UCLASS_SERIAL,
    .of_match = s5p_serial_ids,
    .ofdata_to_platdata = s5p_serial_ofdata_to_platdata,
    .platdata_auto_alloc_size = sizeof(struct s5p_serial_platdata),
    .probe = s5p_serial_probe,
    .ops    = &s5p_serial_ops,
    .flags = DM_FLAG_PRE_RELOC,
};


注意，serial uclass driver的id和serial driver的id是一致的，都是UCLASS_SERIAL。
具体也在《[uboot] （番外篇）uboot 驱动模型》分析过了，这里也不多说了。
关于tiny210的串口驱动的实现，在第四节中再学习。
3、serial core提供的接口

serial core会利用serial uclass找到对应的设备及其操作集，向上层提供接口。
如下：
driver/serial/serial-uclass.c

    void serial_putc(char ch)
    往gd->cur_serial_dev指定的串口设备输出一个字符。

void serial_putc(char ch)
{
    if (gd->cur_serial_dev)
        _serial_putc(gd->cur_serial_dev, ch); // 将gd->cur_serial_dev指定的udevice作为参数传入
}

static void _serial_putc(struct udevice *dev, char ch)
{
    struct dm_serial_ops *ops = serial_get_ops(dev); // 获取对应udevice的操作集（driver->ops）
    int err;

    if (ch == ' ')
        _serial_putc(dev, ' ');

    do {
        err = ops->putc(dev, ch); // 调用udevice的操作集（driver->ops）中的putc函数，这里真正向硬件串口设备进行输出。
    } while (err == -EAGAIN);
}

    void serial_puts(const char *str)
    往gd->cur_serial_dev指定的串口设备输出字符串。其方法与serial_putc类似，自己参考代码。

    int serial_getc(void)
    从gd->cur_serial_dev指定的串口设备获取一个字符。其方法与serial_putc类似，自己参考代码。

    int serial_tstc(void)
    判断gd->cur_serial_dev指定的串口设备是否有数据在等待。其方法与serial_putc类似，自己参考代码。

    void serial_setbrg(void)
    设置gd->cur_serial_dev指定的串口设备的波特率。其方法与serial_putc类似，自己参考代码。

    void serial_initialize(void) & int serial_init(void)
    串口初始化。这里重点说明

void serial_initialize(void)
{
    serial_init();
}
// 可以看出serial_initialize和serial_init是一样的。

int serial_init(void)
{
    serial_find_console_or_panic(); //调用serial_find_console_or_panic来查找console指定的设备
    gd->flags |= GD_FLG_SERIAL_READY;

    return 0;
}

static void serial_find_console_or_panic(void)
{
    const void *blob = gd->fdt_blob;
    struct udevice *dev;
    int node;

    if (CONFIG_IS_ENABLED(OF_CONTROL) && blob) {
        node = fdtdec_get_chosen_node(blob, "stdout-path"); // 尝试在chosen节点中获取"stdout-path"节点
        if (node < 0) {
            const char *str, *p, *name;

            str = fdtdec_get_chosen_prop(blob, "stdout-path"); // 尝试在chosen节点中获取"stdout-path"属性
            if (str) {
                p = strchr(str, ':');
                name = fdt_get_alias_namelen(blob, str,
                        p ? p - str : strlen(str));
                if (name)
                    node = fdt_path_offset(blob, name);
            }
        }
        if (node < 0)
            node = fdt_path_offset(blob, "console"); // 上述都找不到的话，最终去获取"console"指定的节点路径对应的偏移node
        if (!uclass_get_device_by_of_offset(UCLASS_SERIAL, node,
                            &dev)) {
                // 根据节点node从serial uclass的设备链表中获取对应的udevice设备，在获取之后，会进行probe。
                // 注意，tiny210的serial节点并没有设置“u-boot,dm-pre-reloc”属性，所以在relocate之前dm_init中并不会去解析这个节点，
                // 所以在relocate之前，这里会返回失败，也就是找不到对应的udevice
            gd->cur_serial_dev = dev;
            return;
        }

        /*
         * If the console is not marked to be bound before relocation,
         * bind it anyway.
         */
                // 如果console的串口设备节点在relocate之前没有被绑定，那么这里就会强制调用lists_bind_fdt和device_probe进行绑定和probe
                // 这里就是为什么可以不需要加“u-boot,dm-pre-reloc”属性的原因。
        if (node > 0 &&
            !lists_bind_fdt(gd->dm_root, blob, node, &dev)) {
            if (!device_probe(dev)) {
                gd->cur_serial_dev = dev;
                return;
            }
        }
    }
}

在串口初始化完成之后，如果指定了console并且对应serial节点正常，那么serial_putc等等API都可以正常使用了。
同时，gd->flags中的GD_FLG_SERIAL_READY的标志也被设置了
后续就可以通过serial_putc、serial_puts、serial_getc向串口输出数据或者获取数据了。
4、默认波特率的设置

有两个地方可以设置默认波特率，并且存储到gd->baudrate中

    环境变量”baudrate”
    如果环境变量”baudrate”不存在，则使用CONFIG_BAUDRATE宏

具体参考代码：
common/board_f.c

static int init_baud_rate(void)
{
    gd->baudrate = getenv_ulong("baudrate", 10, CONFIG_BAUDRATE);
// 从环境变量中获取"baudrate"的值，存储到gd->baudrate中，如果如果环境变量"baudrate"不存在，则使用CONFIG_BAUDRATE宏的值作为默认波特率
    return 0;
}


在include/configs/tiny210.h中配置默认波特率如下：

#define CONFIG_BAUDRATE         115200


5、serial初始化时机

在relocate之前的board_f中和relocate之后的board_r各会执行一次串口初始操作

    在relocate之前的serial初始化
    common/board_f.c

static init_fnc_t init_sequence_f[] = {
#ifdef CONFIG_OF_CONTROL
    fdtdec_setup,
#endif
    initf_dm,                    // DM的初始化，解析带有“u-boot,dm-pre-reloc”属性的节点
    init_baud_rate,     // 设置默认波特率
    serial_init,        // 串口初始化
}

    在relocate之后的serial初始化
    common/board_r.c

init_fnc_t init_sequence_r[] = {
    initr_dm,            // DM的初始化，解析所有设备节点
    initr_serial,        // 又一次进行串口初始化
}

/* initr_serial实现如下 */
static int initr_serial(void)
{
    serial_initialize();
    return 0;
}


二、debug、printf的输出流程

我们知道，在uboot中，可以通过debug和printf两个函数来进行串口log输出。
1、简单流程图

这里写图片描述

简单说明如下

    debug会转化为printf
    printf会调用到console的puts接口进行输出
    console的puts的输出主要分成如下三个阶段
        在serial初始化之前，会存储到pre console buffer中
        在serial初始化之后，console完全初始化（console_init_r）之前，会直接调用serial的serial_puts接口进行输出
        在serial初始化之后，console完全初始化（console_init_r）之后，会使用标准输入输出设备进行输出，但最终也是会调用到串口设备进行输出

2、debug()流程

    要使能debug()的输出功能，需要先打开DEBUG宏
    include/common.h

++#define DEBUG
#ifdef DEBUG
#define _DEBUG 1
#else

    debug()使用方法如下：

    debug("U-Boot code: %08lX -> %08lX  BSS: -> %08lX ",
        text_base, bss_start, bss_end);

    1
    2

    debug()定义如下：
    include/common.h

#define debug_cond(cond, fmt, args...)         
    do {                       
        if (cond)                  // 会根据_DEBUG的值来判断是否要进行输出
            printf(pr_fmt(fmt), ##args);      //调用printf进行输出    
    } while (0)

#define debug(fmt, args...)        
    debug_cond(_DEBUG, fmt, ##args)


可以观察到最终也是调用到printf进行输出。
3、printf()流程

printf代码流程如下：
lib/vsprintf.c

int printf(const char *fmt, ...)
{
    va_list args;
    uint i;
    char printbuffer[CONFIG_SYS_PBSIZE];

    va_start(args, fmt);

    /*
     * For this to work, printbuffer must be larger than
     * anything we ever want to print.
     */
    i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args); // 对参数进行格式化
    va_end(args);

    /* Print the string */
    puts(printbuffer); // 调用puts进行输出
    return i;
}

// common/console.c
void puts(const char *s)
{
 // 在serial初始化之前，会调用pre_console_puts将字符串存储到pre console buffer中
 // 具体参考下面第4小节
    if (!gd->have_console)    
        return pre_console_puts(s);

    if (gd->flags & GD_FLG_DEVINIT) {
// 在serial初始化之后，console完全初始化（console_init_r）之后，
// 会使用标准输入输出设备进行输出，也就是调用fputs(stdout, s)进行输出，但最终也是会调用到串口设备进行输出
// 具体参考下面第5小节
        /* Send to the standard output */
        fputs(stdout, s);
    } else {
        /* Send directly to the handler */
//在serial初始化之后，console完全初始化（console_init_r）之前，会直接调用serial的serial_puts接口进行输出
// serial_puts我们已经在前面说过了
        pre_console_puts(s);
        serial_puts(s);
    }
}

几个重点标志位说明一下：

    gd->have_console
    用于判断是否有console，在relocate之前、serial串口初始化之后的console_init_f进行设置，
    这里可以简单的理解为作为console的串口初始化的标识

    gd->flags & GD_FLG_DEVINIT
    标准输入输出设备初始化完成的标识。
    在console_init_r中设置，当这个标识被设置，就表示console已经完全初始化了。

4、pre console buffer的使用

根据上面第2小节说明，在serial初始化之前，发到串口的数据会通过pre_console_puts存储到pre console buffer中。
当串口初始化之后，在console_init_f中会对pre console buffer里面的内容进行输出

    需要打开的宏
    以tiny210为例
    include/configs/tiny210.h

#define CONFIG_PRE_CONSOLE_BUFFER // 用于使能pre console buffer的功能
#define CONFIG_PRE_CON_BUF_SZ           4096 // buffer的size
#define CONFIG_PRE_CON_BUF_ADDR         0x30000000 // 需要从内存中指定一块区域给buffer用，必须小心的判断哪部分区域在relocate之前是不会被使用的

    存储流程
    在puts中通过调用pre_console_puts将字符串存储到pre console buffer中，代码流程如下：
    common/console.c

#define CIRC_BUF_IDX(idx) ((idx) % (unsigned long)CONFIG_PRE_CON_BUF_SZ)
static void pre_console_putc(const char c)
{
    char *buffer = (char *)CONFIG_PRE_CON_BUF_ADDR; // 设置buffer地址为CONFIG_PRE_CON_BUF_ADDR
    buffer[CIRC_BUF_IDX(gd->precon_buf_idx++)] = c; // 以gd->precon_buf_idx为当前buffer的指针，写入对应位置上
}

static void pre_console_puts(const char *s)
{
    while (*s)
        pre_console_putc(*s++);
}

    输出流程
    uboot会在relocate之前的串口初始化之后，通过调用console_init_f对pre console buffer的内容进行输出。代码如下：
    common/console.c

int console_init_f(void)
{
    gd->have_console = 1; // 打开这个标志之后，printf的输出信息就不会在存储到pre console buffer中了。
    print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT1_SERIAL); //  调用print_pre_console_buffer对pre console buffer的数据进行输出。
    return 0;
}

static void print_pre_console_buffer(int flushpoint)
{
    unsigned long in = 0, out = 0;
    char *buf_in = (char *)CONFIG_PRE_CON_BUF_ADDR;
    char buf_out[CONFIG_PRE_CON_BUF_SZ + 1];

    if (gd->precon_buf_idx > CONFIG_PRE_CON_BUF_SZ)
        in = gd->precon_buf_idx - CONFIG_PRE_CON_BUF_SZ;

    while (in < gd->precon_buf_idx)
        buf_out[out++] = buf_in[CIRC_BUF_IDX(in++)];

    buf_out[out] = 0; // 将pre console buffer数据复制到buf_out中

    switch (flushpoint) {
    case PRE_CONSOLE_FLUSHPOINT1_SERIAL:
        puts(buf_out); // 重新调用puts，此时的puts不会再存储到pre console buffer，而是会走serial_puts进行输出。
        break;
    case PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL:
        console_puts_noserial(stdout, buf_out);
        break;
    }
}


三、标准输入输出(stdio)

前面也说了，当console完全初始化之后，会生成标准输入输出设备。
后续会在puts中调用fputs(stdout, s)对串口数据进行输出。
1、标准输入输出设备的结构体

include/stdio_dev.h

/* Device information */
struct stdio_dev {
    int flags;          /* Device flags: input/output/system    */
    int ext;            /* Supported extensions         */
    char    name[32];       /* Device name              */ //设备名称

/* GENERAL functions */
    int (*start)(struct stdio_dev *dev);    /* To start the device */ // 启动这个设备的方法
    int (*stop)(struct stdio_dev *dev); /* To stop the device */ // 停止这个设备的方法

/* OUTPUT functions */
    void (*putc)(struct stdio_dev *dev, const char c);  /* To put a char */ // 输出一个字符
    void (*puts)(struct stdio_dev *dev, const char *s);  /* To put a string (accelerator) */ // 输出字符串

/* INPUT functions */
    int (*tstc)(struct stdio_dev *dev);/* To test if a char is ready... */ // 测试是否有数据可以获取
    int (*getc)(struct stdio_dev *dev); /* To get that char */ // 获取一个字符

/* Other functions */
    void *priv;         /* Private extensions           */
    struct list_head list;
};

可以看到包含了标准输入输出设备的一些操作集。
2、标准输入输出设备的存储位置

uboot创建了一个虚拟stdio设备devs作为所有stdio设备的链表头，所有其他stdio设备都会挂载到devs.list链表上。
并且提供了如下操作链表的方法：
common/stdio.c

static struct stdio_dev devs;
struct list_head* stdio_get_list(void); // 获取stdio链表
struct stdio_dev* stdio_get_by_name(const char *name); // 通过name获取stdio链表中的stdio设备
struct stdio_dev* stdio_clone(struct stdio_dev *dev); // 复制一个stdio设备
int stdio_register_dev(struct stdio_dev *dev, struct stdio_dev **devp); // 注册一个stdio设备，会连接到stdio链表中
int stdio_register(struct stdio_dev *dev); // 调用stdio_register_dev
int stdio_init_tables(void); // 初始化stdio链表


并且默认提供了stdin、stdout、stderr三个标准输入输出设备

struct stdio_dev *stdio_devices[] = { NULL, NULL, NULL };
char *stdio_names[MAX_FILES] = { "stdin", "stdout", "stderr" };

3、stdio模块初始化

stdio模块的初始化是在relocate之后的board_r中实现的

init_fnc_t init_sequence_r[] = {
    stdio_init_tables,
    stdio_add_devices,
    console_init_r,
}


stdio_init_tables用于stdio链表的初始化
stdio_add_devices用于创建一些标准输入输出设备。
console_init_r用于将console和标准输入输出设备关联
4、stdio_add_devices

int stdio_add_devices(void)
{
    drv_system_init ();  // 在drv_system_init 中创建一些必须的标准输入输出设备，比如串口的标准输入输出设备。
    return 0;
}

static void drv_system_init (void)
{
    struct stdio_dev dev;

    memset (&dev, 0, sizeof (dev));
 /* 以下创建串口的标准输入输出设备，设置其方法，并注册到stdio链表中 */
    strcpy (dev.name, "serial");
    dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
    dev.putc = stdio_serial_putc; //可以观察到这几个方法都是直接调用serial的接口进行输出
    dev.puts = stdio_serial_puts;
    dev.getc = stdio_serial_getc;
    dev.tstc = stdio_serial_tstc;
    stdio_register (&dev);
}
static void stdio_serial_putc(struct stdio_dev *dev, const char c)
{
    serial_putc(c);
}
。。。

经过上述步骤之后就注册了serial的标准输入输出设备了。
5、console_init_r

console_init_r主要用将console和标准输入输出设备关联。
其会获取stdio链表中的第一个满足条件的标准输入输出设备，进行关联。
代码如下

int console_init_r(void)
{
    struct stdio_dev *inputdev = NULL, *outputdev = NULL;
    int i;
    struct list_head *list = stdio_get_list(); // 获取stdio链表
    struct list_head *pos;
    struct stdio_dev *dev;

    /* Scan devices looking for input and output devices */
    list_for_each(pos, list) { //遍历stdio链表
        dev = list_entry(pos, struct stdio_dev, list);

        if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
            inputdev = dev; // 设置输入设备为第一个搜索到的支持DEV_FLAGS_INPUT的stdio设备
        }
        if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
            outputdev = dev;// 设置输出设备为第一个搜索到的支持DEV_FLAGS_OUTPUT的stdio设备
        }
        if(inputdev && outputdev)
            break;
    }

// 此时，我们的stdio链表上只有serial一个设备，并且既支持DEV_FLAGS_INPUT又支持DEV_FLAGS_OUTPUT，
// 所以inputdev = serail_stdio_dev, output = serail_stdio_dev

    /* Initializes output console first */
    if (outputdev != NULL) {
        console_setfile(stdout, outputdev); //设置系统的标准输出设备stdio_devices[0]为outputdev，对于tiny210来说就是serail_stdio_dev
        console_setfile(stderr, outputdev); //设置系统的标准错误设备stdio_devices[2]为outputdev，对于tiny210来说就是serail_stdio_dev
    }

    /* Initializes input console */
    if (inputdev != NULL) {
        console_setfile(stdin, inputdev);//设置系统的标准输入设备stdio_devices[1]为inputdev，对于tiny210来说就是serail_stdio_dev
    }

#ifndef CONFIG_SYS_CONSOLE_INFO_QUIET
    stdio_print_current_devices();
#endif /* CONFIG_SYS_CONSOLE_INFO_QUIET */
        // 打印出三个系统标准输入输出设备的名称，在log中可以看到如下：
        // In:    serial@e2900000                        Out:   serial@e2900000                     Err:   serial@e2900000

    /* Setting environment variables */
    for (i = 0; i < 3; i++) {
        setenv(stdio_names[i], stdio_devices[i]->name);
    }
        // 设置环境变量stdio_names

    gd->flags |= GD_FLG_DEVINIT;    /* device initialization completed */
        // 设置GD_FLG_DEVINIT标识，表示当前系统标准输入输出设备已经初始化完成了，

    print_pre_console_buffer(PRE_CONSOLE_FLUSHPOINT2_EVERYTHING_BUT_SERIAL);
    return 0;
}

后续就可以通过fputs(stdout, s)从串口输出字符，或者通过fgets(string, sizeof(string), stdin);从串口中获取字符。
6、fputs流程

fputs也是有console实现，较为简单，简单地看一下代码
fputs(stdout, s)从串口输出的流程如下：

void fputs(int file, const char *s)
{
    if (file < MAX_FILES)
        console_puts(file, s);
}

static inline void console_puts(int file, const char *s)
{
    stdio_devices[file]->puts(stdio_devices[file], s);
       // 在console_init_r中stdio_devices已经和serial的标准输入输出绑定了
        // 所以这里会调用到stdio_serial_puts函数
        // 最终就调用到serial_puts从串口输出数据了
}


到这里，框架层的串口输出流程就分析完成了，也就是板级无关的部分。
后面我们分析一下和板级相关的串口驱动的部分。
四、s5pv210 seriial driver分析

和tiny210(s5pv210)相关性较强，这里仅仅说明一下思路。
代码具体参考driver/serial/serial_s5p.c
1、先定义驱动中需要使用到的私有数据

/* Information about a serial port */
struct s5p_serial_platdata {
    struct s5p_uart *reg;  /* address of registers in physical memory */ // 和uart相关的寄存器的物理基地址
    u8 port_id;     /* uart port number */ // 串口id号
};

2、定义DM模型中的driver结构体

U_BOOT_DRIVER(serial_s5p) = {
    .name   = "serial_s5p",
    .id = UCLASS_SERIAL,  // 这个是固定的！！！
    .of_match = s5p_serial_ids,
    .ofdata_to_platdata = s5p_serial_ofdata_to_platdata,
    .platdata_auto_alloc_size = sizeof(struct s5p_serial_platdata), // 私有数据的大小
    .probe = s5p_serial_probe,
    .ops    = &s5p_serial_ops,
    .flags = DM_FLAG_PRE_RELOC,
};

3、设置match_id：s5p_serial_ids

static const struct udevice_id s5p_serial_ids[] = {
    { .compatible = "samsung,exynos4210-uart" },
    { }
};


4、设置dts节点的解析函数：s5p_serial_ofdata_to_platdata

static int s5p_serial_ofdata_to_platdata(struct udevice *dev)
{
    struct s5p_serial_platdata *plat = dev->platdata;
    fdt_addr_t addr;

    addr = dev_get_addr(dev); // 获取dts节点中的寄存器地址

    plat->reg = (struct s5p_uart *)addr; // 将地址存储在plat->reg中
    plat->port_id = fdtdec_get_int(gd->fdt_blob, dev->of_offset, "id", -1); // 获取dtsi中的id属性，并且存放到plat->port_id中

    return 0;
}

5、实现probe函数：s5p_serial_probe

probe就相当于是激活这个串口，就需要在probe中对这个串口进行初始话

static int s5p_serial_probe(struct udevice *dev)
{
    struct s5p_serial_platdata *plat = dev->platdata;
    struct s5p_uart *const uart = plat->reg;
    s5p_serial_init(uart);
    return 0;
}

static void __maybe_unused s5p_serial_init(struct s5p_uart *uart)
{
    /* enable FIFOs, auto clear Rx FIFO */
    writel(0x3, &uart->ufcon);
    writel(0, &uart->umcon);
    /* 8N1 */
    writel(0x3, &uart->ulcon);
    /* No interrupts, no DMA, pure polling */
    writel(0x245, &uart->ucon);
}


6、实现操作集：s5p_serial_ops

注意，因为这个driver对应的udevice所属的serial uclass类型，因此其操作集的类型必须定义为dm_serial_ops类型。

static const struct dm_serial_ops s5p_serial_ops = {
    .putc = s5p_serial_putc,
    .pending = s5p_serial_pending,
    .getc = s5p_serial_getc,
    .setbrg = s5p_serial_setbrg,
};


具体实现这里不多说了。
7、在dtsi中添加设备信息

/{
    aliases {
        console = "/serial@e2900000";
    };

    serial@e2900000 {
        compatible = "samsung,exynos4210-uart";
        reg = <0xe2900000 0x100>;
        interrupts = <0 51 0>;
        id = <0>;
    };
};
————————————————
版权声明：本文为CSDN博主「ooonebook」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ooonebook/article/details/53313112