[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