[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>;
};
};

1
2
3
4
5
6
7
8
9
10
11
12

这里，有些人或许会有疑问，在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),
};

1
2
3
4
5
6
7
8
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,
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

注意，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 == '\n')
_serial_putc(dev, '\r');

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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;
}
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

在串口初始化完成之后，如果指定了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;
}

1
2
3
4
5
6

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

#define CONFIG_BAUDRATE         115200

1

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,        // 串口初始化
}

1
2
3
4
5
6
7
8
在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;
}

1
2
3
4
5
6
7
8
9
10
11

二、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

1
2
3
4
debug()使用方法如下：

debug("U-Boot code: %08lX -> %08lX  BSS: -> %08lX\n",
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)

1
2
3
4
5
6
7
8

可以观察到最终也是调用到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);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

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

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之前是不会被使用的

1
2
3
存储流程 

在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++);
}

1
2
3
4
5
6
7
8
9
10
11
12
输出流程 

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;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

三、标准输入输出(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;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

可以看到包含了标准输入输出设备的一些操作集。

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链表

1
2
3
4
5
6
7

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

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

1
2

3、stdio模块初始化

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

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

1
2
3
4
5

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);
}
。。。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

经过上述步骤之后就注册了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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

后续就可以通过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从串口输出数据了
}

1
2
3
4
5
6
7
8
9
10
11
12
13

到这里，框架层的串口输出流程就分析完成了，也就是板级无关的部分。 

后面我们分析一下和板级相关的串口驱动的部分。

四、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号
};

1
2
3
4
5

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,
};

1
2
3
4
5
6
7
8
9
10

3、设置match_id：s5p_serial_ids

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

1
2
3
4

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;
}

1
2
3
4
5
6
7
8
9
10
11
12

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);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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,
};

1
2
3
4
5
6

具体实现这里不多说了。

7、在dtsi中添加设备信息

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

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