您的位置: 首页  >  文章  >  u-boot串口和stdio、console初始化及相关操作详解<二>

u-boot串口和stdio、console初始化及相关操作详解<二>

分类: 文章 • 2025-05-12 18:17:10

二.board_r阶段串口操作和stdio初始化

该阶段包括3个函数：stdio_init_tables、 initr_serial、stdio_add_devices。下面逐一对其进行详细说明。

1. stdio_init_tables
[cpp] view plain copy
  1. int stdio_init_tables(void)  
  2. {  
  3.     /* Initialize the list */  
  4.     INIT_LIST_HEAD(&(devs.list));  
  5.     return 0;  
  6. }  
INIT_LIST_HEAD为include/linux/List.h中的内联函数:
[cpp] view plain copy
  1. static inline void INIT_LIST_HEAD(struct list_head *list)  
  2. {  
  3.     list->next = list;  
  4.     list->prev = list;  
  5. }  
devs在stdio.c中定义：
static struct stdio_dev devs；
其中结构体struct stdio_dev定义在include/Stdio_dev.h中：
[cpp] view plain copy
  1. struct stdio_dev {  
  2.     int flags;          /* Device flags: input/output/system    */  
  3.     int ext;            /* Supported extensions         */  
  4.     char    name[32];       /* Device name              */  
  5. /* GENERAL functions */  
  6.     int (*start)(struct stdio_dev *dev);   /* To start the device */  
  7.     int (*stop)(struct stdio_dev *dev);    /* To stop the device */  
  8. /* OUTPUT functions */  
  9.     /* To put a char */  
  10.     void (*putc)(struct stdio_dev *dev, const char c);  
  11.     /* To put a string (accelerator) */  
  12.     void (*puts)(struct stdio_dev *dev, const char *s);  
  13. /* INPUT functions */  
  14.     /* To test if a char is ready... */  
  15.     int (*tstc)(struct stdio_dev *dev);  
  16.     int (*getc)(struct stdio_dev *dev);    /* To get that char */  
  17. /* Other functions */  
  18.     void *priv;         /* Private extensions           */  
  19.     struct list_head list;  
  20. };  
include/linux/List.h中有：
[cpp] view plain copy
  1. struct list_head {  
  2.     struct list_head *next, *prev;  
  3. };  
struct stdio_dev代表对stdio设备的描述，当有多个stdio设备时，将使用其成员变量list将这些stdio设备链接起来。这里，函数stdio_init_tables对该链表进行了初始化。注意这里的链表机制是在struct stdio_dev结构体中嵌入一个楔子struct list_head list，list有两个成员*next和*prev，分别指向上一个和下一个struct list_head变量，而该变量则是struct stdio_dev的成员，*next和*prev并不指向struct stdio_dev结构体变量。

这和struct serial_device中的*next成员不同，后者指向下一个struct serial_device结构体变量，即下一个serial设备。

由struct list_head list组成的链表可称为stdio设备的维护链表。u-boot维持着devs这样一个全局变量，它始终指向stdio设备维护链表struct list_head的头部，u-boot通过这样一个链表维护着所有的stdio设备。

下面我们还会看到另一个全局变量serial_devices，它始终指向serial设备链表的头部。同样，所有注册的serial设备通过这样一个链表串接起来。

2. initr_serial
initr_serial为静态函数，它调用了drivers/serail/serail.c中的serial_initialize,该函数实现如下：

[cpp] view plain copy
  1. void serial_initialize(void)  
  2. {  
  3.     altera_jtag_serial_initialize();  
  4.     altera_serial_initialize();  
  5.     ...  
  6.     mxc_serial_initialize();  
  7.     ...  
  8.    
  9.    serial_assign(default_serial_console()->name);  
  10. }  
serial_initialize调用的函数列表中，末尾serial_assign除外，所有的函数都是weak类型，即其可能在它处实现，但如果没有实现，
会被函数serial_null替换。serial_null是serial.c中的静态函数，该函数中没有任何代码。
如altera_jtag_serial_initialize在它处没有实现，那么它将被alias("serial_null")，即被serial_null替换。
上面的函数列表是针对不同的SOC，有各自的实现。单独针对某一SOC时，只有一个函数得到具体的实现，此处针对I.MX6的CPU，
查看其目录下的Makefiel文件，根据配置可以看出最终使用的是文件drivers/serial/Serial_mxc.c中的mxc_serial_initialize：
[cpp] view plain copy
  1. void imx_serial_initialize(void)  
  2. {  
  3.     serial_register(&mxc_serial_drv);  
  4. }  
serial_register在drivers/serial/serial .c中实现：
[cpp] view plain copy
  1. void serial_register(struct serial_device *dev)  
  2. {  
  3.     dev->next = serial_devices;  
  4.     serial_devices = dev;  
  5. }  
serial_devices在serial.c中被定义为静态变量:
static struct serial_device *serial_devices;
static struct serial_device *serial_current;
结构体struct serial_device的最后一个成员是struct serial_device    *next。
执行完serial_register后，dev->next被赋值为serial_devices的初始值，即变量定义时默认的初始值0，
serial_devices后被赋值为dev，即传入的参数&mxc_serial_drv。该结构体在上面board_init_f阶段的分析中讨论过，
这里，为了便于分析，再次列出它的定义和初始化：
[cpp] view plain copy
  1. static struct serial_device mxc_serial_drv = {  
  2.     .name   = "mxc_serial",  
  3.     .start  = mxc_serial_init,  
  4.     .stop   = NULL,  
  5.     .setbrg = mxc_serial_setbrg,  
  6.     .putc   = mxc_serial_putc,  
  7.     .puts   = default_serial_puts,  
  8.     .getc   = mxc_serial_getc,  
  9.     .tstc   = mxc_serial_tstc,  
  10. };  
新加入serial的设备总是插入到serial_devices指向的serial设备链表的头部，而后serial_devices指向该新serial设备。
这样，所有注册过的serial设备通过设备结构成员next链接成一个设备链表。最后，全局变量serial_devices指向该链表的表头。
在函数serial_initialize中，执行完所有有效的serial设备的注册后，最后执行serial_assign：
[cpp] view plain copy
  1. int serial_assign(const char *name)  
  2. {  
  3.     struct serial_device *s;  
  4.     for (s = serial_devices; s; s = s->next) {  
  5.         if (strcmp(s->name, name))  
  6.             continue;  
  7.         serial_current = s;  
  8.         return 0;  
  9.     }  
  10.     return -EINVAL;  
  11. }  
当某一SOC包含有多个可被u-boot使用的串口时，只要创建一个针对某串口的initialize函数，并包含对该串口如上类似的注册操作，把它加入到serial_initialize的执行函数列表中，就可被使用。所谓的串口链表也是针对多个串口的上述情况。但只有一个是被当前使用的，serial_assign函数就是指定以其入参为名字的串口为当前设备，该函数中的全局变量serial_current最后指向一个有效的当前串口设备。
3. stdio_add_devices
函数stdio_add_devices执行stdio设备的注册。stdio设备层工作在serail层之上，但stdio设备并不限于serial设备，比如标准输出设备可能包括显示器。但我们这里只讨论stdio中的serail设备。
stdio_add_devices在common/stdio.c中实现：
[cpp] view plain copy
  1. int stdio_add_devices(void)  
  2. {  
  3.     i2c_init_all();  
  4.   
  5.     drv_video_init ();  
  6.     drv_system_init ();  
  7.     serial_stdio_init ();  
  8.     drv_nc_init ();  
  9.   
  10.     return 0;  
  11. }  
上述函数中注册为stdio的设备包括I2c，video，system，serial，以及netcommand设备。
其中serial设备到stdio的注册通过函数serial_stdio_ini来实现，其在drivres/serial/serial.c中定义为：
[cpp] view plain copy
  1. void serial_stdio_init(void)  
  2. {  
  3.     struct stdio_dev dev;  
  4.     struct serial_device *s = serial_devices;  
  5.     while (s) {  
  6.         memset(&dev, 0, sizeof(dev));  
  7.         strcpy(dev.name, s->name);  
  8.         dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;  
  9.         dev.start = serial_stub_start;  
  10.         dev.stop = serial_stub_stop;  
  11.         dev.putc = serial_stub_putc;  
  12.         dev.puts = serial_stub_puts;  
  13.         dev.getc = serial_stub_getc;  
  14.         dev.tstc = serial_stub_tstc;  
  15.         dev.priv = s;  
  16.         stdio_register(&dev);  
  17.         s = s->next;  
  18.     }  
  19. }  
在上面的initr_serial函数一节中，我们已经讨论过serail设备链表，它是已被注册的SOC层serial设备的集合。
这里的全局变量serial_devices指向serial设备链表的表头， 而后使用while循环用来遍历该设备链表并执行如下操作：
a).将serial设备的设备名拷贝到stdio设备的设备名中
b).我们知道stdio设备包含stdin,stdout,stderr三种设备，dev.flags即为这种设备属性区分标志。
c).添加stdio设备的ops函数。
d). 语句dev.priv = s将serial设备指针赋值给stdio设备结构体的成员变量priv。
e). 注册stdio 设备。
struct stdio_dev成员变量priv(私有的)是访问下层设备---这里是serial层----的媒介。通过priv变量，就可以访问stdio包含
的下层设备。由于stdio设备并不只包含serial设备，所以该变量定义为void *类型。
我们在board_init_f阶段阶段的讨论中曾经提到过，在serial层，提供了诸如serial_puts，serial_getc的外部访问接口。
而针对上层的stdio设备，serial层提供的外部接口则是名为serial_stub_xx的桩函数。
如serial_stub_putc在drivres/serial/serial.c中实现为：
[cpp] view plain copy
  1. static void serial_stub_putc(struct stdio_dev *sdev, const char ch)  
  2. {  
  3.     struct serial_device *dev = sdev->priv;  
  4.     dev->putc(ch);  
  5. }  
如前所述，sdev->priv为serial设备指针，后者在serail初始化(注册)时被赋值为SOC层的设备指针，这样，最终的dev->putc将指向了
SOC层中的相关输出函数。
最后使用stdio_register函数，完成serial设备到stdio的注册：
[cpp] view plain copy
  1. int stdio_register(struct stdio_dev *dev)  
  2. {  
  3.     return stdio_register_dev(dev, NULL);  
  4. }  
该函数然后调用stdio_register_dev(在common/stdio.c中实现)
[cpp] view plain copy
  1. int stdio_register_dev(struct stdio_dev *dev, struct stdio_dev **devp)  
  2. {  
  3.     struct stdio_dev *_dev;  
  4.     _dev = stdio_clone(dev);  //分配struct stdio_dev并将参数dev的内容拷贝到分配的结构体中  
  5.     if(!_dev)  
  6.         return -ENODEV;  
  7.     list_add_tail(&(_dev->list), &(devs.list));  
  8.     if (devp)  
  9.         *devp = _dev;  
  10.     return 0;  
  11. }  
最后一个涵参devp是保留给udev驱动模式使用，此处为空。
函数stdio_clone首先分配一个struct stdio_dev实例内存空间，然后将输入参数dev指向的结构体内容拷贝到新分配的struct stdio_dev实例空间，其返回值是新分配的struct stdio_dev实例的首址。
list_add_tail(&(_dev->list), &(devs.list))
将新建_dev成员变量中的list链表加入到stdio设备总链表的末尾。注意这里是单纯的list链表，_dev结构体自身并未加入链表中。
在上面"stdio_init_tables"函数分析一节中曾经提到过，全局变量devs指向该链表的表头。
综上所述，serial_stdio_init函数实现了如下功能：
1.为串口设备分配相应的struct stdio_dev实例
2.将struct stdio_dev的ops函数和串口的ops相关联
3.利用struct stdio_dev的成员priv将串口设备和代表stdio实例的struct stdio_dev关联起来。
4.将struct stdio_dev的成员list加入全局变量devs的list链表，完成最终的serial设备到stdio的注册。这样，后续的stdio设备的访问就可以使用全局变量devs来进行。使用的也是一种和linux驱动中类似的机制，使用宏container_of根据结构体成员倒查结构体。这里devs中的list是结构体成员，其被结构体struct stdio_dev所包含。查找到相应的stdio设备后，就可利用该stdi设备的ops函数进行相关的输入输出操作。
总结：
就分层机制来说，stdio的实现包含3层，即stdio层，serail层和SOC serail层。
stdio层和SOC serail层都是有实体存在的，比如上述讨论中为stdio设备层分配了实体内存空间，
而serail层并无相应的内存实体存在，它使用的还是SOC serail分配的内存空间，只不过对该SOC serail
设备实例进一步执行了serail层特有的操作。所以serail层可称为抽象层。它是对相应的具体SOC层serail设备
的抽象。serail层和SOC serail是一种映射关系。
下图总揽了stdio层，serail层和SOC serail层之间的关系：
u-boot串口和stdio、console初始化及相关操作详解<二>

相关推荐