怀揣着十几个疑问整理了rk3288 uboot 阶段display相关代码：
1、代码流程
由rk3288 uboot 启动流程分析可知，dispaly 驱动在board_fbt_preboot;中被调用，如下所示：
#ifdef CONFIG_LCD
/* logo state defautl init = 0 */
g_logo_on_state = 0;
if (gd->fdt_blob) {
int node = fdt_path_offset(gd->fdt_blob, "/fb");
g_logo_on_state = fdtdec_get_int(gd->fdt_blob, node, "rockchip,uboot-logo-on", 0);
}
printf("read logo on state from dts [%d]\n", g_logo_on_state);
if (g_logo_on_state != 0) {
lcd_enable_logo(true);
drv_lcd_init();
}
#endif
当定义了CONFIG_LCD后，这段代码被调用通过对g_logo_on_state的判断来确定是否在uboot阶段显示logo。
/* /common/lcd.c */
static void *lcd_base; /* Start of framebuffer memory */
lcd_enable_logo(true);
lcd_show_logo = 1;
drv_lcd_init();
/* 第一步：获取framebuffer memory的起始位置 */
lcd_base = map_sysmem(gd->fb_base, 0);/* framebuffer addr = 0x7dc00000 ,位于ddr地址的最后 */
/* 第二步： 初始化LCD */
/* 2.1 ： 定义一个rockchip_fb的结构体指针 */
/* 2.2 ： 解析屏幕相关的参数填充到panel_info结构体 */
/* 2.3 ： 解析gpio相关的参数填充到pwr_ctr 结构体 */
/* 2.4 ： 根据pwr_ctr结构体 控制gpio 输出 */
/* 2.5 ： lcd 控制器的初始化 */
lcd_init(lcd_base); /* LCD initialization */
/* drivers/video/rockchip_fb.c */
struct rockchip_fb rockchip_fb; /* 定义了一个全局结构体 rockchip_fb */
lcd_ctrl_init(lcdbase);
/* 定义一个 rockchip_fb 结构体指针 */
struct rockchip_fb *fb = &rockchip_fb; /* rockchip_fb 是一个全局结构体 */
/* 从设备树解析屏幕参数 */
int ret = rk_fb_parse_dt(fb, gd->fdt_blob); /* gd->fdt_blob 决定了是否从dts中解析数据 */
/* 获得dtb下display-timings 节点的偏移 ，这个偏移可以代表这个节点 */
int node = fdt_path_offset(blob（gd->fdt_blob）, "/display-timings");
phandle = fdt_getprop_u32_default_node(blob, node, 0, "native-mode", -1);
/* 填充panel_info结构体 */
/* panel_info 也是一个全局结构体 */
panel_info.vl_bpix = 5;
panel_info.lvds_ttl_en = 0;
panel_info.screen_type = fdtdec_get_int(blob, node, "screen-type", -1);
panel_info.color_mode = fdtdec_get_int(blob, node, "color-mode", 0);
panel_info.lcd_face = fdtdec_get_int(blob, node, "out-face", -1);
panel_info.vl_col = fdtdec_get_int(blob, node, "hactive", 0);
panel_info.vl_row = fdtdec_get_int(blob, node, "vactive", 0);
panel_info.vl_width = fdtdec_get_int(blob, node, "hactive", 0);
panel_info.vl_height = fdtdec_get_int(blob, node, "vactive", 0);
panel_info.vl_freq = fdtdec_get_int(blob, node, "clock-frequency", 0);
panel_info.vl_oep = fdtdec_get_int(blob, node, "de-active", -1);
panel_info.vl_hsp = fdtdec_get_int(blob, node, "hsync-active", -1);
panel_info.vl_vsp = fdtdec_get_int(blob, node, "vsync-active", -1);
panel_info.lvds_format = fdtdec_get_int(blob, node, "lvds-format", -1);
panel_info.vl_swap_rb = fdtdec_get_int(blob, node, "swap-rb", -1);
panel_info.vl_hspw = fdtdec_get_int(blob, node, "hsync-len", 0);
panel_info.vl_hfpd = fdtdec_get_int(blob, node, "hfront-porch", 0);
panel_info.vl_hbpd = fdtdec_get_int(blob, node, "hback-porch", 0);
panel_info.vl_vspw = fdtdec_get_int(blob, node, "vsync-len", 0);
panel_info.vl_vfpd = fdtdec_get_int(blob, node, "vfront-porch", 0);
panel_info.vl_vbpd = fdtdec_get_int(blob, node, "vback-porch", 0);
/* 解析lcdc0 节点 */
node = rk_fb_find_lcdc_node_dt(rk_fb（fb）, blob);
node = fdt_path_offset(blob, "lcdc0");
/* 解析gpio 节点 */
rk_fb_pwr_ctr_parse_dt(rk_fb, blob);
panel_info.logo_rgb_mode = RGB565;
/* 使能对应的gpio口 */
rk_fb_pwr_enable(fb);
gpio_direction_output(pwr_ctr->gpio.gpio,pwr_ctr->atv_val);
mdelay(pwr_ctr->delay);
/* LCDC 控制器 初始化 */
/* drivers/video/rk32_lcdc.c */
rk_lcdc_init(panel_info.lcdc_id);
struct lcdc_device *lcdc_dev = &rk32_lcdc; /* rk32_lcdc 是一个全局结构体 */
lcdc_dev->soc_type = gd->arch.chiptype; /* 应该没什么用这个参数 */
lcdc_dev->id = lcdc_id; /* lcdc_id = panel_info.lcdc_id */
rk32_lcdc_parse_dt(lcdc_dev, gd->fdt_blob);
/* 解析得到lcdc0 节点 */
lcdc_dev->node = fdt_path_offset(blob, "lcdc0");
/* 获取lcdc 节点的regs 资源 */
lcdc_dev->regs = fdtdec_get_addr(blob, lcdc_dev->node, "reg");
/* 寄存器控制 */
/* 写 SYS_CTRL */
/* 写 DSP_CTRL1 */
/* cfg_done */
/*第三步 ： 配置mipi dsi */
/*3.1 ：解析display-timing
/*3.2 ：解析dsi
/*3.3 ：配置dsi host（初始化 phy等）
/*3.4 ：发送屏幕初始化序列
/* 配置mipi dsi */
/* drivers/video/rk32_lcdc.c */
rk_lcdc_load_screen(&panel_info);
/* 使用在lcdc_init中初始化的lcdc_dev */
struct lcdc_device *lcdc_dev = &rk32_lcdc;
struct rk_screen *screen = lcdc_dev->screen;
/* 将panel_info 过渡给rk_screen */
/* drivers/video/rockchip_fb.c */
rk_fb_vidinfo_to_screen(vid, screen);
screen->type = vid->screen_type;
...
/* mipi dsi 初始化 */
/* drivers/video/transmitter/rk32_mipi_dsi.c */
rk32_mipi_enable(vid);
struct dsi *dsi;
struct mipi_dsi_ops *ops;
struct rk_screen *screen;
struct mipi_dsi_screen *dsi_screen;
/* drivers/video/screen/lcd_mipi.c */
rk_mipi_screen_probe();
gmipi_screen = calloc(1, sizeof(struct mipi_screen)); /* 全局变量 */
/* 解析dts */
ret = rk_mipi_screen_init_dt(gmipi_screen);
struct device_node *childnode, *grandchildnode, *root;
struct mipi_dcs_cmd_ctr_list *dcs_cmd;
struct list_head *pos;
struct property *prop;
/* 将mipi_screen 清 0 ， mipi_screen 是一个全局变量 */
memset(screen, 0, sizeof(*screen));
/* 链表头初始化 */
INIT_LIST_HEAD(&screen->cmdlist_head);
/* 获取mipi_dsi_init 节点 */
childnode = of_find_node_by_name(NULL, "mipi_dsi_init");
/* 获取screen_init 属性的值赋予value */
ret = of_property_read_u32(childnode, "rockchip,screen_init", &value);
/* 赋值screen_init */
screen->screen_init = value ;
/* 获取 dsi_lane 属性的值 */
ret = of_property_read_u32(childnode, "rockchip,dsi_lane", &value);
screen->dsi_lane = value;
/* 获取dsi_hs_clk 属性的值 */
ret = of_property_read_u32(childnode, "rockchip,dsi_hs_clk", &value);
screen->hs_tx_clk = value*MHz;
/* 获取mipi_dsi_num 属性的值 */
ret = of_property_read_u32(childnode, "rockchip,mipi_dsi_num", &value);
screen->mipi_dsi_num = value ;
/* 获取 mipi_power_ctr 节点 */
childnode = of_find_node_by_name(NULL, "mipi_power_ctr");
/* 获取mipi_lcd_rst 节点 */
grandchildnode = of_get_child_by_name(childnode, "mipi_lcd_rst");
/* 获取 mipi reset delay 属性的值 */
ret = of_property_read_u32(grandchildnode, "rockchip,delay", &value);
screen->lcd_rst_delay = value;
/* 获取mipi reset gpio 属性 */
gpio = of_get_named_gpio_flags(grandchildnode, "rockchip,gpios", 0, &flags);
/* 获取对应的gpio */
ret = gpio_request(gpio,"mipi_lcd_rst");
screen->lcd_rst_gpio = gpio;
screen->lcd_rst_atv_val = (flags == GPIO_ACTIVE_HIGH)? 1:0;
/* 获取mipi_lcd_en 节点 */
grandchildnode = of_get_child_by_name(childnode, "mipi_lcd_en");
/* 获取 mipi en delay 属性的值 */
ret = of_property_read_u32(grandchildnode, "rockchip,delay", &value);
screen->lcd_en_delay = value;
/* 获取mipi en gpio */
gpio = of_get_named_gpio_flags(grandchildnode, "rockchip,gpios", 0, &flags);
ret = gpio_request(gpio,"mipi_lcd_en");
screen->lcd_en_gpio = gpio;
screen->lcd_en_atv_val= (flags == GPIO_ACTIVE_HIGH)? 1:0;
/* 获取screen-on-cmds 节点 */
root= of_find_node_by_name(NULL,"screen-on-cmds");
/* cmd 节点的东西很多 需要循环依次来获取存放 */
for_each_child_of_node(root, childnode)
/* 存放cmd的结构体 */
dcs_cmd = kmalloc(sizeof(struct mipi_dcs_cmd_ctr_list), GFP_KERNEL);
/* 区分不同的cmd */
strcpy(dcs_cmd->dcs_cmd.name, childnode->name);
/* 获取一个cmd的长度 */
prop = of_find_property(childnode, "rockchip,cmd", &length);
dcs_cmd->dcs_cmd.cmd_len = length / sizeof(u32) ;
/* 根据长度依次 将cmd保存到dcs_cmd->dcs_cmd.cmds */
for(i = 0; i < (length / sizeof(u32)); i++)
dcs_cmd->dcs_cmd.cmds[i] = cmds[i];
/* 获取dsi_id */
ret = of_property_read_u32(childnode, "rockchip,dsi_id", &value);
dcs_cmd->dcs_cmd.dsi_id = value;
/* 获取cmd_type */
ret = of_property_read_u32(childnode, "rockchip,cmd_type", &value);
dcs_cmd->dcs_cmd.type = value;
/* 获取cmd_delay */
ret = of_property_read_u32(childnode, "rockchip,cmd_delay", &value);
dcs_cmd->dcs_cmd.delay = value;
/* 解析完了一个cmd 后将包含这个cmd的信息链接到cmdlist_head链表中 */
list_add_tail(&dcs_cmd->list, &screen->cmdlist_head);
/* rk32_mipi_enable */
/* 获取之前解析出来的dsi 数量 */
dsi_number = rk_mipi_get_dsi_num();
/* 有几个dsi就搞几个dsi */
for(id = 0; id < dsi_number;)
/* 为每一个dsi分配空间 */
dsi = calloc(1, sizeof(struct dsi));
/* 通过id区分不同的dsi */
dsi->dsi_id = id++;
/* 解析dsi_host 就是为了dsi的基地址 */
rk_dsi_host_parse_dt(gd->fdt_blob,dsi);
/* 找到rk32_dsi 节点 */
node = fdt_node_offset_by_compatible(blob, 0, "rockchip,rk32-dsi");
/* 确定host 的基地址 */
dsi->host.membase = (void __iomem *)(unsigned long)fdtdec_get_int(blob, node, "reg", -1);
/* 分 配 rk_screen */
screen = calloc(1, sizeof(struct rk_screen));
/* 准备填充ops */
ops = &dsi->ops;
ops->dsi = dsi;
ops->get_id = rk32_mipi_dsi_get_id,
/* 关键操作函数 发送数据 */
ops->dsi_send_packet = rk32_mipi_dsi_send_packet;
ops->dsi_read_dcs_packet = rk32_mipi_dsi_read_dcs_packet,
ops->dsi_enable_video_mode = rk32_mipi_dsi_enable_video_mode,
ops->dsi_enable_command_mode = rk32_mipi_dsi_enable_command_mode,
ops->dsi_enable_hs_clk = rk32_mipi_dsi_enable_hs_clk,
ops->dsi_is_active = rk32_mipi_dsi_is_active,
ops->dsi_is_enable= rk32_mipi_dsi_is_enable,
ops->power_up = rk32_mipi_dsi_power_up,
ops->power_down = rk32_mipi_dsi_power_down,
ops->dsi_init = rk_mipi_dsi_init,
/* 填充mipi_dsi_screen */
dsi_screen = &dsi->screen;
dsi_screen->type = screen->type = vid->screen_type;
dsi_screen->face = screen->face = vid->lcd_face;
dsi_screen->pixclock = screen->mode.pixclock = vid->real_freq;
dsi_screen->pin_den = screen->pin_den = vid->vl_oep;
。。。
dsi_screen->lcdc_id = 1;
/* 注册dsi ops */
ret = rk_mipi_dsi_probe(dsi);
/* 就是将ops放入一个全局数组中通过dsi_id管理起来 */
register_dsi_ops(dsi->dsi_id, &dsi->ops);
dsi_ops[id] = ops; /*static struct mipi_dsi_ops *dsi_ops[MAX_DSI_CHIPS] = {NULL}; 全局变量 */
/* 探测当前的dsi chip是否存在 */
ret = dsi_probe_current_chip(dsi->dsi_id);
/* 不在dis_num 的for中 */
rk32_dsi_enable();
/* 判断dsi0 的时钟是否打开 dsi0 是一个全局变量*/
if (!dsi0->clk_on) {
/* 调用之前注册到dsi 的dsi_init ops函数 ，这里将dsi0 和前面的dsi关联起来了 */
dsi_init(0, 0);
/* 这里的dsi 对应的就是id = 0 的dsi */
ops->dsi_init(ops->dsi, n);
static int rk_mipi_dsi_init(void *arg, u32 n)
struct dsi *dsi = arg;
struct mipi_dsi_screen *screen = &dsi->screen;
/* 设置各种时钟 */
dsi->phy.Tpclk = div_u64(1000000000000llu, screen->pixclock);
dsi->phy.ref_clk = 24*MHZ;
dsi->phy.sys_clk = dsi->phy.ref_clk;
dsi->phy.ddr_clk = 1500 * MHz; /* default is 1.5HGz */
decimals = dsi->phy.ref_clk;
dsi->phy.ddr_clk = dsi->phy.ref_clk / dsi->phy.prediv * dsi->phy.fbdiv;
。。。
dsi->host.video_mode = VM_BM;
mdelay(10);
/* 计算完phy的时钟后开始进行操作了 */
rk_phy_power_up(dsi);
rk32_phy_power_up(dsi);
/* 开时钟 */
rk32_mipi_dsi_clk_enable(dsi);
val = 0x80000000;//bit31~bit16
writel(val, RK3288_CRU_PHYS + 0x174); /*24M*/
writel(val, RK3288_CRU_PHYS + 0x1a0); /*pclk*/
/* 设置dsi lane */
switch(dsi->host.lane)
/* 以4根lane为例 */
rk32_dsi_set_bits(dsi, 3, n_lanes);
/* 写寄存器了 */
rk32_dsi_set_bits(dsi, 1, phy_shutdownz);
rk32_dsi_set_bits(dsi, 1, phy_rstz);
rk32_dsi_set_bits(dsi, 1, phy_enableclk);
rk32_dsi_set_bits(dsi, 1, phy_forcepll);
/* dsi 上电？ */
rk32_mipi_dsi_host_power_up(dsi);
/* 禁用所有中断 */
rk32_dsi_set_bits(dsi, 0x1fffff, INT_MKS0);
rk32_dsi_set_bits(dsi, 0x3ffff, INT_MKS1);
rk32_mipi_dsi_is_enable(dsi, 1);
rk32_dsi_set_bits(dsi, enable, shutdownz);
/* 检测phy clk 是否起来了 等待了一段时间 */
while(!rk32_dsi_get_bits(dsi, phylock) && val--)
/* phy 的初始化 */
rk_phy_init(dsi);
/* phy 的初始化 */
rk32_phy_init(dsi);
/* test data 那一套东西 */
/* dsi host 的初始化 */
rk32_mipi_dsi_host_init(dsi);
struct mipi_dsi_screen *screen = &dsi->screen;
rk32_dsi_set_bits(dsi, dsi->host.lane - 1, n_lanes);
rk32_dsi_set_bits(dsi, dsi->vid, dpi_vcid);
rk32_dsi_set_bits(dsi, 1, hsync_active_low);
。。。
rk32_dsi_set_bits(dsi, dsi->host.video_mode, vid_mode_type); //burst mode
。。。
/* 根据video mode screen type 等配置寄存器 */
/* 配置一些时序 寄存器 */
rk32_dsi_set_bits(dsi, dsi->phy.Tpclk * (screen->left_margin) / dsi->phy.Ttxbyte_clk, vid_hbp_time);
rk32_dsi_set_bits(dsi, screen->y_res , vid_active_lines);
rk32_dsi_set_bits(dsi, screen->lower_margin, vid_vfp_lines);
rk32_dsi_set_bits(dsi, screen->upper_margin, vid_vbp_lines);
。。。
/* driver/video/transmitter/rk32_mipi_dsi.c rk32_dsi_enable */
rk_mipi_screen_standby(0);
/* driver/video/screen/lcd_mipi.c */
int rk_mipi_screen_standby(u8 enable)
rk_dsi_num = gmipi_screen->mipi_dsi_num;
rk_mipi_screen(); /* enable = 0 时 */
rk_dsi_num = gmipi_screen->mipi_dsi_num;
/* 这个不需要也可以前面做过了 */
rk_mipi_screen_pwr_enable(gmipi_screen);
dsi_enable_hs_clk(0,1);
dsi_enable_video_mode(0,0);
/* 通过ops调用之前注册的ops函数中的dsi enable video mode函数 enable = 0 */
ops->dsi_enable_video_mode(ops->dsi, enable);
rk32_mipi_dsi_enable_video_mode(ops->dsi,0)
/* 设置相应的寄存器 */
rk32_dsi_set_bits(dsi, !enable, cmd_video_mode);
/* 打开command mode */
dsi_enable_command_mode(0, 1);
/* 通过command mode 发送屏幕初始化序列 */
rk_mipi_screen_cmd_init(gmipi_screen);
struct list_head *screen_pos;
struct mipi_dcs_cmd_ctr_list *dcs_cmd;
/* 通过screen 中的comlist_head链表去访问各个cmd */
list_for_each(screen_pos, &screen->cmdlist_head){
/* 发送函数 */
dsi_send_packet(1, cmds, len);
ops->dsi_send_packet(ops->dsi, packet, n);
static int rk32_mipi_dsi_send_packet(void *arg, unsigned char cmds[], u32 length)
/* 发送完初始化序列后，关闭command模式 */
dsi_enable_command_mode(0,0);
/* 打开video 模式 */
dsi_enable_video_mode(0,1);
dsi_is_enable(0, 0);
rk32_mipi_dsi_is_enable(dsi,0)
rk32_dsi_set_bits(dsi, enable, shutdownz);
dsi_enable_video_mode(0, 1);
dsi_is_enable(0, 1);
/* rk32_lcdc.c rk_lcdc_load_screen */
rk32_dsi_sync();
dsi_is_enable(0, 0);
dsi_enable_video_mode(0, 1);
dsi_is_enable(0, 1);
/* 第四步： 显示logo */
/*4.1 ： 获取bmp问题的位置 */
/*4.2 ： 获取framebuffer的位置 */
/*4.3 ： 将bmp写到framebuffer中 */
/*4.4 ： 设置图层显示framebuffer的内容 */
/* /common/lcd.c lcd_init */
/* lcd_ctrl_init 完成后，准备显示logo */
lcd_clear();
/* 画logo */
static void *lcd_logo(void)
/* 绘制位图并显示*/
bitmap_plot(0, 0);
/* 获取一个bmp_logo_palette 的数据 */
uint *cmap = (uint *)bmp_logo_palette;
ushort i, j;
uchar *bmap;
uchar *fb;
ushort *fb16;
unsigned bpix = NBITS(panel_info.vl_bpix);
/* 获取一个bmp_logo_bitmap 的数据 */
bmap = &bmp_logo_bitmap[0];
/* 设置fb 指针 */
fb = (uchar *)(lcd_base);
/* */
if(!rk_bitmap_from_resource((unsigned short*)fb))
show_resource_image(file_path)
/*把位图搬运到bmp->addr处 */
load_content_data(&image, 0, image.load_addr, blocks)
/* 把bmp->addr得东西按照格式搞到fb->add */
lcd_display_bitmap_center((uint32_t)(unsigned long)image.load_addr);
lcd_display_bitmap(bmp_image, (panel_info.vl_col - width)/2,(panel_info.vl_row - height)/2);
/* 写buffer */
/* 显示 drivers/video/rockchip_fb.c */
lcd_pandispaly(&fb_info);
/* drivers/video/rk32_lcdc.c */
rk_lcdc_set_par(info, &panel_info);
/* 有多个图层 选择一个作为默认的图层去显示 */
fb_info->layer_id = lcdc_dev->dft_win;
/* 通过win0 显示 */
win0_set_par(lcdc_dev, fb_info, vid);
/* 使用这个来表示一个图层 */
struct rk_lcdc_win win;
memset(&win, 0, sizeof(struct rk_lcdc_win));
/* 计算显示时x坐标 */
win.area[0].dsp_stx = dsp_x_pos(win.mirror_en, screen, win.area);
/* 计算显示时y坐标 */
win.area[0].dsp_sty = dsp_y_pos(win.mirror_en, screen, win.area);
/* 显示效果相关计算获取对应的参数 */
rk3288_lcdc_calc_scl_fac(&win, screen);
/* 显示格式 */
win.area[0].y_vir_stride = v_RGB565_VIRWIDTH(fb_info->xvir);
/* 写寄存器，将刚计算获得的值写到相应的寄存器中去 */
rk3288_win_0_1_reg_update(lcdc_dev, &win, fb_info->layer_id);
/* 设置将win0 的数据获取入口设置为framebuffer 的位置 */
lcdc_writel(lcdc_dev, WIN0_YRGB_MST, fb_info->yaddr);
lcdc_writel(lcdc_dev, BCSH_BCS, 0xd0010000);
。。。
lcdc_cfg_done(lcdc_dev);
/* bitmap_plot(0, 0); */
/* 刷新caches */
lcd_sync();
/* 第五步： 开背光 */
/* board/rockchip/common/rkboot/fastboot.c */
rk_pwm_bl_config(-1);
/* drives/video/backlight/pwm_bl.c */
int rk_pwm_bl_config(int brightness)
/* 设置pwm */
2、十二问
问题1、GD这个全局变量是什么？
/* include/asm-arm/global_data.h */
typedef struct global_data {
bd_t *bd;
unsigned long flags;
unsigned long baudrate;
unsigned long have_console; /* serial_init() was called */
unsigned long reloc_off; /* Relocation Offset */
unsigned long env_addr; /* Address of Environment struct */
unsigned long env_valid; /* Checksum of Environment valid? */
unsigned long fb_base; /* base address of frame buffer */
#ifdef CONFIG_VFD
unsigned char vfd_type; /* display type */
#endif
#if 0
unsigned long cpu_clk; /* CPU clock in Hz! */
unsigned long bus_clk;
unsigned long ram_size; /* RAM size */
unsigned long reset_status; /* reset status register at boot */
#endif
void **jt; /* jump table */
}gd_t;
GD全局变量是uboot启动的最开始就在ram中申请创建的一个结构体，它的生命周期贯穿uboot启动的整个阶段，所以可以用来传递大量信息。
uboot使用gd来传递信息是因为，有些时候uboot可能是在一些只读类存储器上运行的，在uboot被重定位到ram之前，是无法写入数据的，把gd放在ram中，就可以对齐进行读写保存需要的信息。
在gd初始化的时候，会将gd的地址放在r9寄存器中，后面需要使用到gd时直接访问r9即可。
问题2、gd->fb_base 是何时赋值为何？
在board_init_f 的list中有一个reserve_lcd。这个函数中对gd->fb_base进行了赋值 。
static int setup_fdt(void)
{
#ifdef CONFIG_OF_CONTROL
# ifdef CONFIG_OF_EMBED
/* 使用CONFIG_OF_EMBED 的方式，dtb集成到了uboot的bin文件中，通过_dtb_dt_begin 来获取dtb的地址 */
/* Get a pointer to the FDT */
gd->fdt_blob = __dtb_dt_begin;
# elif defined CONFIG_OF_SEPARATE
/* FDT is at end of image */
/* 使用CONFIG_OF_SEPARATE 的方式，此时dtb 是追加在uboot的bin文件后面的，所以通过_end符号来获取dtb的地址 */
gd->fdt_blob = (ulong *)&_end;
# elif defined(CONFIG_OF_HOSTFILE)
if (read_fdt_from_file()) {
puts("Failed to read control FDT\n");
return -1;
}
# endif
/* Allow the early environment to override the fdt address */
/* 也可以通过环境变量“fdtcontroladdr 来指定fdt的地址 */
gd->fdt_blob = (void *)getenv_ulong("fdtcontroladdr", 16,
(uintptr_t)gd->fdt_blob);
#endif
return 0;
}
问题3、gd->fdt_blob 是做什么的，何时初始化的？
gd->fdt_blob 保存的是fdt的地址，是由board_init_f 的list中的setup_fdt最先获取，注意：设备树编译生成的dtb文件并不包含在uboot.bin当中。
static int setup_fdt(void)
{
#ifdef CONFIG_OF_CONTROL
# ifdef CONFIG_OF_EMBED
/* 使用CONFIG_OF_EMBED 的方式，dtb集成到了uboot的bin文件中，通过_dtb_dt_begin 来获取dtb的地址 */
/* Get a pointer to the FDT */
gd->fdt_blob = __dtb_dt_begin;
# elif defined CONFIG_OF_SEPARATE
/* FDT is at end of image */
/* 使用CONFIG_OF_SEPARATE 的方式，此时dtb 是追加在uboot的bin文件后面的，所以通过_end符号来获取dtb的地址 */
gd->fdt_blob = (ulong *)&_end;
# elif defined(CONFIG_OF_HOSTFILE)
if (read_fdt_from_file()) {
puts("Failed to read control FDT\n");
return -1;
}
# endif
/* Allow the early environment to override the fdt address */
/* 也可以通过环境变量“fdtcontroladdr 来指定fdt的地址 */
gd->fdt_blob = (void *)getenv_ulong("fdtcontroladdr", 16,
(uintptr_t)gd->fdt_blob);
#endif
return 0;
}
由setup_fdt 获取fdt 最开始的地址后，我们还需要调用reserve_fdt来为其保留空间：
static int reserve_fdt(void)
{
/*
* If the device tree is sitting immediate above our image then we
* must relocate it. If it is embedded in the data section, then it
* will be relocated with other data.
*/
if (gd->fdt_blob) {
gd->fdt_size = ALIGN(fdt_totalsize(gd->fdt_blob) + 0x1000, 32);
gd->start_addr_sp -= gd->fdt_size;
gd->new_fdt = map_sysmem(gd->start_addr_sp, gd->fdt_size);
debug("Reserving %lu Bytes for FDT at: %08lx\n",
gd->fdt_size, gd->start_addr_sp);
}
return 0;
}
最后通过reloc_fdt来完成fdt的重定位并更新fdt的地址：
static int reloc_fdt(void)
{
if (gd->new_fdt) {
memcpy(gd->new_fdt, gd->fdt_blob, gd->fdt_size);
gd->fdt_blob = gd->new_fdt;
}
return 0;
}
问题4、 struct mipi_screen 中的cmdlist_head 链表的作用是什么？
struct list_head cmdlist_head; 在rk_mipi_screen_init_dt(gmipi_screen); 中调用 INIT_LIST_HEAD(&screen->cmdlist_head);完成了初始化，然后在后面解析cmd命令时，每解析完一条cmd（完成struct mipi_dcs_cmd_ctr_list 结构体的填充后）调用 list_add_tail(&dcs_cmd->list, &screen->cmdlist_head); 将struct mipi_dcs_cmd_ctr_list 中的dcs_cmd ->链接到cmdlist_head 中，就这样每解析了一条cmd就链接进去一条。最终实现了通过struct mipi_screen 结构体可以访问到所有cmd的功能。方便通过mipi 发送cmd去初始化屏幕。
问题5、rk32_mipi_enable 中的struct rk_screen *screen 与rk_mipi_screen_probe()中的struct mipi_screen gmipi_screen 及struct mipi_dsi_screen *dsi_screen;的关系是什么？
struct rk_screen *screen 是rk对支持的屏幕的一个集合，这些屏幕包括rgb屏幕、mipi屏幕、lvds屏幕等。当使用其中一种屏幕时有些成员时没有用的。其主要用于lcdc控制器中图层相关的寄存器配置上。而struct mipi_screen 是针对mipi屏幕的特点构成的一个集合，主要包含了mipi 屏幕使用dsi 通道数目、使能和复位的gpio口控制、需要发送的屏幕初始化序列。主要用来初始化屏幕。struct mipi_dsi_screen 是 struct dsi 中成员，在mipi dis host 初始化时会使用struct mipi_dsi_screen 成员的的值去配置相应的寄存器。如：vid_hline_time、vid_hbp_time、vid_hsa_time、vid_active_lines、vid_vfp_lines、vid_vbp_lines、vid_vsa_lines等。
总结：struct rk_screen *screen 用于lcdc控制器的寄存器配置、struct mipi_screen gmipi_screen 用于mipi 屏幕的初始化、struct mipi_dsi_screen *dsi_screen 用于MIPI DSI相关寄存器的配置。
问题6、 在rk32_mipi_enable(vid); 中会根据dsi_num去配置所有的dsi，dsi_num是什么含义？
查看rk3288 Block Diagram 可知，rk3288中集成了两个MIPI DSi PHY ：dsihost0: mipi@ff960000 \dsihost1: mipi@ff964000。在初始化的时候需要将这两个dsi phy都初始化了，所以出现了dsi_num的参数。方便对一个或两个dsi phy进行访问控制。
问题7、rk32_dsi_enable 中出现的dsi0 和 rk32_mipi_enable 中初始化填充的dsi有什么关联?
没什么用，可以用自己建立的dsi去代替它
问题8、解析设备树获取节点属性信息时，有很多define值，他们定义在什么地方？
解析设备树时所有的信息都是从设备树文件中得到，打开查看设备树文件可以看到它也是有#include 头文件的。其中大部分头文件都是在kernel/arch/arm/boot/dts/include/dt-bindings/。。。 中，这些头文件就定义了绝大部分使用到的值，如：
./rkfb/rk_fb.h:#define SCREEN_MIPI 7
问题9、Uboot启动阶段一定会使能mipi dsi 的command mode去发送屏幕初始化序列么？
根据不同的lcd屏幕的spec 决定是否需要初始化，对于需要初始化的lcd屏幕就调用相应的接口发送初始化cmd进行初始化。
问题10、代码中的standby的含义是什么？
待机模式，当需要进入待机模式时调用rk_mipi_screen_standby（1）,会通过dcs发送display_off命令给lcd。并进入sleep 模式。
最后关掉power。
退出standby模式时会首先打开dsi power。使能时钟，使能command模式，发送退出sleep mode 命令。发送display on命令，再关闭command模式。打开video mode。
问题11、bmp_logo_palette[] 是什么？
bmp_logo_palette 放在bmp_logo_data.h中，是一个数组。而我们在编译uboot的过程中可以看到以下打印信息：
tools/bmp_logo --gen-info /home/kai/work/rk3288/x3288_lollipop/u-boot/tools/logos/rockchip.bmp > /home/kai/work/rk3288/x3288_lollipop/u-boot/include/bmp_logo.h
tools/bmp_logo --gen-data /home/kai/work/rk3288/x3288_lollipop/u-boot/tools/logos/rockchip.bmp > /home/kai/work/rk3288/x3288_lollipop/u-boot/include/bmp_logo_data.h
可以看出bmp_logo_data.h 是由/home/kai/work/rk3288/x3288_lollipop/u-boot/tools/logos/rockchip.bmp 这个位图文件经由tools/bmp_logo 处理产生的
起始就是把一个.bmp位图转换成数组数据放在了.h文件中，方便程序去调用显示。
问题12、如何获取bmp？
bmp 可以通过上面bmp_logo_palette数组中的数据获得，也可以在一开始就在ram中保留一个区域，然后将img中的位图拷贝过去获得