uboot 驱动模型框架分析(DM)

﹏ヽ暗。殇╰゛Y 2023-01-13 01:33 294阅读 0赞

本文只是简单记录自己对uboot 驱动模型框架的梳理，这些东西比较琐碎，由于时间原因，没有整理成为一个系统的东西，可以理解为一个笔记

在uboot驱动模型中，有uclass，uclass driver，udevice， udevice driver结构体，每一个具体的设备，使用udevice结构体描述，udevice设备对应的驱动为driver。
    uclass描述一种设备类型的集合，udevice挂载uclass上，uclass driver为uclass对应的驱动。
    
    代码上，uclass，uclass driver，udevice， udevice driver之间的联系：
    
    设备的硬件信息描述在设备树中，或者struct driver_info数据结构定义硬件信息，然后会去一个特殊的段中，去匹配driver结构体，设备树的话，使用compatible去匹配。
    struct driver_info的话，使用name去匹配。如果匹配成功的话，那么使用driver中的id去特殊的段中匹配uclass driver，如果找到的话，为该uclass driver分配uclass。
    然后为driver分配udevice结构体，driver和udevice进行绑定，uclass 和uclass driver进行绑定。udevice和uclass进行绑定。然后调用driver的bind和probe函数。
    由上面的描述可知，不管是udevice还是uclass都是自动分配的，而driver和uclass driver都是通过宏定义在特殊段中。
    
    
    
    uboot中的设备驱动模型中初始化
    initr_dm
    	dm_init_and_scan(false);
    		dm_init
    			//初始化uclass的根节点
    			INIT_LIST_HEAD(&DM_UCLASS_ROOT_NON_CONST);
    			/* 这里传递的参数是root_info，里面仅仅有一个name，用来匹配 */
    			device_bind_by_name(NULL, false, &root_info, &DM_ROOT_NON_CONST);
    				//通过名字，找到udevice dirver
    				drv = lists_driver_lookup_name(info->name);
    				/*
    					设备绑定操作的通用函数：
    					1.通过driver中的id找到uclass，因此uclass也是需要提前注册到系统中
    					2.分配一个udevice结构体，初始化该结构体，然后绑定uclass和driver
    					3.分别调用该udevice driver和udevice 父节点的driver中的pre probe，probe，post probe函数
    				*/
    
    				device_bind_common
    					/* 
    						1.先在gd->uclass_root根节点上根据id查找匹配的uclass
    						2.如果在gd->uclass_root根节点上没有找到uclass，那么会在特殊的段中根据id查找uclass driver。
    						3.分配uclass，将uclass driver和uclass绑定，同时将uclass添加到gd->uclass_root链表中
    					*/					
    					ret = uclass_get(drv->id, &uc);
    					
    					//分配一个udevice，从这里可以看出，必须先有uclass才能有udevice。
    					dev = calloc(1, sizeof(struct udevice));
    					INIT_LIST_HEAD(&dev->sibling_node);
    					INIT_LIST_HEAD(&dev->child_head);
    					INIT_LIST_HEAD(&dev->uclass_node);
    					dev->platdata = platdata;
    					dev->driver_data = driver_data;
    					dev->name = name;
    					dev->node = node;
    					dev->parent = parent;
    					//绑定driver，先有udevice driver，然后才绑定udevice
    					dev->driver = drv;
    					//udevice和uclass绑定
    					dev->uclass = uc;
    					//分配driver中要分配的内存
    					dev->platdata = calloc(1,drv->platdata_auto_alloc_size);
    					//如果有父节点，将udevice加入到父节点中的链表中
    					if (parent)
    						list_add_tail(&dev->sibling_node, &parent->child_head);
    					//将udevice设备挂在uclass的链表中
    					ret = uclass_bind_device(dev);	
    					ret = drv->bind(dev);
    					//调用父设备驱动中的child_post_bind函数
    					if (parent && parent->driver->child_post_bind) {
    						ret = parent->driver->child_post_bind(dev);
    			//递归的调用udevice和其父设备的probe函数
    			device_probe
    				//udevice对应的driver
    				drv = dev->driver;			
    		//这里是绑定预先定义在特定的段中的struct driver_info结构体
    		dm_scan_platdata(pre_reloc_only);
    			//这里是从预先定义保存的struct driver_info的段中，依次遍历段中的成员进行绑定
    			int lists_bind_drivers(struct udevice *parent, bool pre_reloc_only)
    		//这里是绑定设备树中的设备
    		dm_extended_scan_fdt(gd->fdt_blob, pre_reloc_only);
    			//遍历设备树，用设备树中的compatible属性与系统中的driver进行匹配，并分配udevice结构体，然后与driver绑定，并调用probe函数
    			dm_scan_fdt(blob, pre_reloc_only);			
    				 dm_scan_fdt_node(gd->dm_root, blob, 0, pre_reloc_only);
    				 /* 
    					1.获取设备节点中compatible属性列表
    					2.从特殊段中取出每个driver，依次与该node节点进行匹配，如果匹配成功，调用device_bind_common进行绑定
    				*/
    					lists_bind_fdt
    			
    			
    struct driver *lists_driver_lookup_name(const char *name)
    {
    	struct driver *drv =
    		ll_entry_start(struct driver, driver);
    	const int n_ents = ll_entry_count(struct driver, driver);
    	struct driver *entry;
    
    	for (entry = drv; entry != drv + n_ents; entry++) {
    		if (!strcmp(name, entry->name))
    			return entry;
    	}
    
    	/* Not found */
    	return NULL;
    }
    
    			
    			
    //该结构体仅仅用来查找u-boot driver
    static const struct driver_info root_info = {
    	.name		= "root_driver",
    };
    
    
    U_BOOT_DRIVER(root_driver) = {
    	.name	= "root_driver",
    	.id	= UCLASS_ROOT,
    };
    
    
    上面所说的特殊段具体指的是什么段呢？
    U_BOOT_DRIVER宏会在特殊的段中定义一个struct driver结构体，遍历的时候，会从这个段中的起始位置遍历整个段中的内容
    
    #define U_BOOT_DRIVER(__name)						\
    	ll_entry_declare(struct driver, __name, driver)
    
     //该宏其实就是在.u_boot_list_2_uclass_2_serial段中分配一个指定类型_type的结构体
    #define ll_entry_declare(_type, _name, _list)				\
    	_type _u_boot_list_2_##_list##_2_##_name __aligned(4)		\
    			__attribute__((unused,				\
    			section(".u_boot_list_2_"#_list"_2_"#_name)))
    
    同理：UCLASS_DRIVER宏也是在一个特殊段中定义一个结构体：		
    #define UCLASS_DRIVER(__name)						\
    	ll_entry_declare(struct uclass_driver, __name, uclass)
    			
     //该宏其实就是在.u_boot_list_2_uclass_2_serial段中分配一个指定类型_type的结构体
    #define ll_entry_declare(_type, _name, _list)				\
    	_type _u_boot_list_2_##_list##_2_##_name __aligned(4)		\
    			__attribute__((unused,				\
    			section(".u_boot_list_2_"#_list"_2_"#_name)))
    			
    
    
    uclass是供上层接口使用的，而udevice是底层一个具体的设备。那么如何定义一个设备呢？如下以一个串口驱动为例：
    
    serial-uclass.c中定义一个uclass_driver
    
    UCLASS_DRIVER(serial) = {
        .id        = UCLASS_SERIAL, //注意这里的uclass id
        .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),
    };
    
    < 2 > 定义s5pv210的serial的dts节点
    
    serial@e2900000 {
    		compatible = "samsung,exynos4210-uart"; //注意这里的compatible 
    		reg = <0xe2900000 0x100>;
    		interrupts = <0 51 0>; 
    		id = <0>;
    };  
    
    < 3 > 定义设备驱动
    
    U_BOOT_DRIVER(serial_s5p) = {
        .name    = "serial_s5p",
        .id    = UCLASS_SERIAL, //注意这里的uclass id
        .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,
    };
    
    static const struct udevice_id s5p_serial_ids[] = {
        { .compatible = "samsung,exynos4210-uart" }, //注意这里的compatible 
        { }
    };