uboot drm框架

最新推荐文章于 2024-08-16 21:04:58 发布
最新推荐文章于 2024-08-16 21:04:58 发布
阅读量1.6k 收藏 15
点赞数 1
分类专栏： rockchip uboot 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39678541/article/details/118695002
版权

uboot drm框架

drm概念

drm显示通路

在这里插入图片描述

CRTC： 显示控制器， 在 rockchip 平台是 SOC 内部 VOP(部分文档也称为 LCDC)模块的抽象；
Plane： 图层， 在 rockchip 平台是 SOC 内部 VOP(LCDC)模块 win 图层的抽象；
Encoder： 输出转换器， 指 RGB、 LVDS、 DSI、 eDP、 HDMI、 CVBS、 VGA 等显示接口；
Connector： 连接器， 指 encoder 和 panel 之间交互的接口部分；
Bridge： 桥接设备， 一般用于注册 encoder 后面另外再接的转换芯片， 如 DSI2HDMI 转换芯片。
Panel： 泛指屏， 各种 LCD、 HDMI 等显示设备的抽象；
GEM： buffer 管理和分配,类似 android 下的 ion。

其中bridge部分，当平台无对应 显示接口使用转换芯片

crtc控制器

Z:\RV1109\u-boot\drivers\video\drm\rockchip_crtc.c

//注册vop驱动
U_BOOT_DRIVER(rockchip_vop) = {
	.name	= "rockchip-vop",
	.id	= UCLASS_VIDEO_CRTC,
	.of_match = rockchip_vop_ids,
	.bind	= rockchip_vop_bind,
	.probe	= rockchip_vop_probe,
};
//通过of_match 匹配设备rockchip_vop_ids，1109和1126是一样通用的
    .compatible = "rockchip,rv1126-vop",
    .data = (ulong)&rv1126_vop_data,
//rv1126_vop 这个是1126平台的vop驱动设置了vop的一些参数寄存器等等，rockchip_vop_funcs是crtc vop的初始化之类的func
static const struct rockchip_crtc rv1126_vop_data = {
	.funcs = &rockchip_vop_funcs,
	.data = &rv1126_vop,
};

const struct rockchip_crtc_funcs rockchip_vop_funcs = {
	.preinit = rockchip_vop_preinit,
	.init = rockchip_vop_init,
	.set_plane = rockchip_vop_set_plane,
	.prepare = rockchip_vop_prepare,
	.enable = rockchip_vop_enable,
	.disable = rockchip_vop_disable,
	.fixup_dts = rockchip_vop_fixup_dts,
	.send_mcu_cmd = rockchip_vop_send_mcu_cmd,
};

panel

panel部分的控制流程

Z:\RV1109\u-boot\drivers\video\drm\rockchip_panel.c

panel的控制结构体如电源脚
 struct rockchip_panel_priv {
	bool prepared;
	bool enabled;
	struct udevice *power_supply;
	struct udevice *backlight;
	struct gpio_desc enable_gpio;
	struct gpio_desc reset_gpio;

	int cmd_type;
	struct gpio_desc spi_sdi_gpio;
	struct gpio_desc spi_scl_gpio;
	struct gpio_desc spi_cs_gpio;
};  
panel的参数结构体
 struct rockchip_panel_plat {
	bool power_invert;
	u32 bus_format;
	unsigned int bpc;

	struct {
		unsigned int prepare;
		unsigned int unprepare;
		unsigned int enable;
		unsigned int disable;
		unsigned int reset;
		unsigned int init;
	} delay;

	struct rockchip_panel_cmds *on_cmds;
	struct rockchip_panel_cmds *off_cmds;
};
panel的配置及连接状态
struct rockchip_panel {
	struct udevice *dev;
	u32 bus_format;
	unsigned int bpc;
	const struct rockchip_panel_funcs *funcs;
	const void *data;

	struct display_state *state;
};
//display 的结构体包含连接信息及状态 log信息
struct display_state {
	struct list_head head;

	const void *blob;
	ofnode node;

	struct crtc_state crtc_state;
	struct connector_state conn_state;
	struct panel_state panel_state;

	char ulogo_name[30];
	char klogo_name[30];

	struct logo_info logo;
	int logo_mode;
	int charge_logo_mode;
	void *mem_base;
	int mem_size;

	int enable;
	int is_init;
	int is_enable;
}

probe流程
    reset、电源脚申明
    gpio_request_by_name(dev, "enable-gpios", 0,
				   &priv->enable_gpio, GPIOD_IS_OUT);
	gpio_request_by_name(dev, "reset-gpios", 0,
				   &priv->reset_gpio, GPIOD_IS_OUT);
	uclass_get_device_by_phandle(UCLASS_PANEL_BACKLIGHT, dev,
					   "backlight", &priv->backlight);
	uclass_get_device_by_phandle(UCLASS_REGULATOR, dev,
					   "power-supply", &priv->power_supply);
	//读取配置发送屏参的方式，有spi、mcu和默认的屏
	dev_read_string_index(dev, "rockchip,cmd-type", 0, &cmd_type);
	//注册panel_function，用于屏的初始化 enable之类
    panel->funcs = &rockchip_panel_funcs;

static const struct rockchip_panel_funcs rockchip_panel_funcs = {
	.init = panel_simple_init,
	.prepare = panel_simple_prepare,
	.unprepare = panel_simple_unprepare,
	.enable = panel_simple_enable,
	.disable = panel_simple_disable,
	.getid = panel_simple_getid,
};
//把panel的总线格式赋值到连接接口的值
static void panel_simple_init(struct rockchip_panel *panel)
{
	struct display_state *state = panel->state;
	struct connector_state *conn_state = &state->conn_state;

	conn_state->bus_format = panel->bus_format;
}
//panel上电准备
panel_simple_prepare
 //panel下电准备
 panel_simple_unprepare
 //enable  panel
 panel_simple_enable
 //disable panel
 panel_simple_disable
 //get  panel screen id,兼容多个屏，在mipi_dsi_get_screen_id做屏的兼容
 panel_simple_getid
    return  mipi_dsi_get_screen_id

connect

这部分是encoder 连接到panel,这里讲解平台用到mipi

//mipi 
U_BOOT_DRIVER(dw_mipi_dsi) = {
	.name = "dw_mipi_dsi",
	.id = UCLASS_DISPLAY,
	.of_match = dw_mipi_dsi_ids,
	.probe = dw_mipi_dsi_probe,
	.bind = dw_mipi_dsi_bind,
	.priv_auto_alloc_size = sizeof(struct dw_mipi_dsi),
	.per_child_platdata_auto_alloc_size = sizeof(struct mipi_dsi_device),
	.platdata_auto_alloc_size = sizeof(struct mipi_dsi_host),
	.child_post_bind = dw_mipi_dsi_child_post_bind,
	.child_pre_probe = dw_mipi_dsi_child_pre_probe,
};
//通过of_match 匹配平台的dw_mipi_dsi_ids，获取到rockchip_connector的data和func，fun是connect模块的功能函数，通过fun与对应的pannel连接
    .compatible = "rockchip,rv1126-mipi-dsi",
    .data = (ulong)&rv1126_mipi_dsi_driver_data,

static const struct rockchip_connector rv1126_mipi_dsi_driver_data = {
	 .funcs = &dw_mipi_dsi_connector_funcs,
	 .data = &rv1126_mipi_dsi_plat_data,
};

static const struct rockchip_connector_funcs dw_mipi_dsi_connector_funcs = {
	.init = dw_mipi_dsi_connector_init,
	.prepare = dw_mipi_dsi_connector_prepare,
	.unprepare = dw_mipi_dsi_connector_unprepare,
	.enable = dw_mipi_dsi_connector_enable,
	.disable = dw_mipi_dsi_connector_disable,
};

display子系统

display子系统流程

//Device information used by the video uclass
struct video_priv {
	/* Things set up by the driver: */
	ushort xsize;
	ushort ysize;
	ushort rot;
	enum video_log2_bpp bpix;
	const char *vidconsole_drv_name;
	int font_size;

	/*
	 * Things that are private to the uclass: don't use these in the
	 * driver
	 */
	void *fb;
	int fb_size;
	int line_length;
	int colour_fg;
	int colour_bg;
	bool flush_dcache;
	ushort *cmap;
};
//
struct video_uc_platdata {
	uint align;
	uint size;
	ulong base;
};
//display crtc控制器
struct rockchip_crtc {
	const struct rockchip_crtc_funcs *funcs;
	const void *data;
	struct drm_display_mode active_mode;
	bool hdmi_hpd : 1;
	bool active : 1;
};
//display的连接器
struct rockchip_connector {
	const struct rockchip_connector_funcs *funcs;

	const void *data;
};
//display 桥接状态
struct rockchip_bridge {
	struct udevice *dev;
	const struct rockchip_bridge_funcs *funcs;

	struct display_state *state;
};
//display  phy接口
struct rockchip_phy {
	struct udevice *dev;
	const struct rockchip_phy_funcs *funcs;
	const void *data;
	int soc_type;
};
//display  phy数据
struct public_phy_data {
	const struct rockchip_phy *phy_drv;
	int phy_node;
	int public_phy_type;
	bool phy_init;
};
//uboot的display driver
U_BOOT_DRIVER(rockchip_display) = {
	.name	= "rockchip_display",
	.id	= UCLASS_VIDEO,
	.of_match = rockchip_display_ids,
	.bind	= rockchip_display_bind,
	.probe	= rockchip_display_probe,
};
rockchip_display_probe
    //寻找dts的route节点，route节点下有很多子节点，子节点的接口有dsi、rgb、
   route_node = dev_read_subnode(dev, "route");
	//然后读取子节点的配置参数

ofnode_for_each_subnode(node, route_node) {
		if (!ofnode_is_available(node))
			continue;
    	//通过connct参数中寻找该节点，再找到port父节点接口
		phandle = ofnode_read_u32_default(node, "connect", -1);
		if (phandle < 0) {
			printf("Warn: can't find connect node's handle\n");
			continue;
		}
    	//ep_node 是connect参数 实际申明的节点
		ep_node = of_find_node_by_phandle(phandle);
		if (!ofnode_valid(np_to_ofnode(ep_node))) {
			printf("Warn: can't find endpoint node from phandle\n");
			continue;
		}
		port_node = of_get_parent(ep_node);
		if (!ofnode_valid(np_to_ofnode(port_node))) {
			printf("Warn: can't find port node from phandle\n");
			continue;
		}

		port_parent_node = of_get_parent(port_node);
		if (!ofnode_valid(np_to_ofnode(port_parent_node))) {
			printf("Warn: can't find port parent node from phandle\n");
			continue;
		}

		is_ports_node = strstr(port_parent_node->full_name, "ports") ? 1 : 0;
		if (is_ports_node) {
			vop_node = of_get_parent(port_parent_node);
			if (!ofnode_valid(np_to_ofnode(vop_node))) {
				printf("Warn: can't find crtc node from phandle\n");
				continue;
			}
		} else {
			vop_node = port_parent_node;
		}
		//找到display crtc控制器
		ret = uclass_get_device_by_ofnode(UCLASS_VIDEO_CRTC,
						  np_to_ofnode(vop_node),
						  &crtc_dev);
		if (ret) {
			printf("Warn: can't find crtc driver %d\n", ret);
			continue;
		}
		crtc = (struct rockchip_crtc *)dev_get_driver_data(crtc_dev);
		//从ep_node的remote_point参数中得到申明节点的位置，在得到生成该节点的displayport 例如dsi 加入到display port链表中
		conn_dev = rockchip_of_find_connector(np_to_ofnode(ep_node));
		if (!conn_dev) {
			printf("Warn: can't find connect driver\n");
			continue;
		}

		conn = (const struct rockchip_connector *)dev_get_driver_data(conn_dev);
		//得到dsi port控制器的phy接口，dsi用的是mipi_dphy
		phy = rockchip_of_find_phy(conn_dev);
		//通过dsi节点来得到 bridge 节点  vop  vop-dsi
		bridge = rockchip_of_find_bridge(conn_dev);
		if (bridge)
			panel = rockchip_of_find_panel(bridge->dev);
		else
			panel = rockchip_of_find_panel(conn_dev);

		s = malloc(sizeof(*s));
		if (!s)
			continue;

		memset(s, 0, sizeof(*s));
		//从dts 文件中读取logo,mode的参数
		INIT_LIST_HEAD(&s->head);
		ret = ofnode_read_string_index(node, "logo,mode", 0, &name);
		if (!strcmp(name, "fullscreen"))
			s->logo_mode = ROCKCHIP_DISPLAY_FULLSCREEN;
		else
			s->logo_mode = ROCKCHIP_DISPLAY_CENTER;
		ret = ofnode_read_string_index(node, "charge_logo,mode", 0, &name);
		if (!strcmp(name, "fullscreen"))
			s->charge_logo_mode = ROCKCHIP_DISPLAY_FULLSCREEN;
		else
			s->charge_logo_mode = ROCKCHIP_DISPLAY_CENTER;
		//填充rockchip_state的参数 
		s->blob = blob;
		s->panel_state.panel = panel;
		s->conn_state.node = conn_dev->node;
		s->conn_state.dev = conn_dev;
		s->conn_state.connector = conn;
		s->conn_state.phy = phy;
		s->conn_state.bridge = bridge;
		s->conn_state.overscan.left_margin = 100;
		s->conn_state.overscan.right_margin = 100;
		s->conn_state.overscan.top_margin = 100;
		s->conn_state.overscan.bottom_margin = 100;
		s->crtc_state.node = np_to_ofnode(vop_node);
		s->crtc_state.dev = crtc_dev;
		s->crtc_state.crtc = crtc;
		s->crtc_state.crtc_id = get_crtc_id(np_to_ofnode(ep_node));
		s->node = node;

		if (bridge)
			bridge->state = s;

		if (panel)
			panel->state = s;

		get_crtc_mcu_mode(&s->crtc_state);

		ret = ofnode_read_u32_default(s->crtc_state.node,
					      "rockchip,dual-channel-swap", 0);
		s->crtc_state.dual_channel_swap = ret;
		if (connector_panel_init(s)) {
			printf("Warn: Failed to init panel drivers\n");
			free(s);
			continue;
		}

		if (connector_phy_init(s, data)) {
			printf("Warn: Failed to init phy drivers\n");
			free(s);
			continue;
		}
		list_add_tail(&s->head, &rockchip_display_list);
	}

//驱动程序中会遍历route节点下的子节点的connect参数，然后再通过of_find_node_by_phandle函数得到ep_node（vop_out_dsi）的定义点 通过两次调用of_get_parent函数得到该节点的父节点vop,再把vop的节点加入到crtc控制节点的链表中，通过rockchip_of_find_connector函数获取ep_node（vop_out_dsi）的节点下的remote-endpoint的参数，然后通过ofnode_get_by_phandle函数得到remote-endpoint参数（dsi_in_vop）的定义节点，然后通过三次调用ofnode_get_parent函数得到（dsi_in_vop）的父节点dsi display_port节点，加入到display_port链表中。通过调用rockchip_of_find_phy函数得到 dsi display_port节点中的phy节点的参数并加入到链表中调用rockchip_of_find_bridge函数遍历 dsi节点下的 ports节点的reg和port节点参数，再遍历port节点下的remote-endpoint的参数，调用of_get_parent三次是否可以得到父节点如果可以加入bridge链表，然后通过bridge得到panel.
//总结来说有bridge  crtc  --  encoder -- bridge --connect -- panel
//没有bridge  crtc  --  encoder --connect -- panel
	display_subsystem: display-subsystem {
		compatible = "rockchip,display-subsystem";
		ports = <&vop_out>;
		status = "disabled";
		logo-memory-region = <&drm_logo>;

		route {
			route_dsi: route-dsi {
				status = "disabled";
				logo,uboot_1024X600 = "logo_1024X600.bmp";
				logo,kernel_1024X600 = "logo_kernel_1024X600.bmp";
				logo,uboot_480X854 = "logo_480X854.bmp";
				logo,kernel_480X854 = "logo_kernel_480X854.bmp";
				logo,uboot_480X800 = "logo_480X800.bmp";
				logo,kernel_480X800 = "logo_kernel_480X800.bmp";
				logo,uboot_800X1280 = "logo_800X1280.bmp";
				logo,kernel_800X1280 = "logo_kernel_800X1280.bmp";
				logo,mode = "center";
				charge_logo,mode = "center";
				connect = <&vop_out_dsi>;
			};

			route_rgb: route-rgb {
				status = "disabled";
				logo,uboot = "logo.bmp";
				logo,kernel = "logo_kernel.bmp";
				logo,mode = "center";
				charge_logo,mode = "center";
				connect = <&vop_out_rgb>;
			};
		};
	};

	vop: vop@ffb00000 {
		compatible = "rockchip,rv1126-vop";
		reg = <0xffb00000 0x200>, <0xffb00a00 0x400>;
		reg-names = "regs", "gamma_lut";
		rockchip,grf = <&grf>;
		interrupts = <GIC_SPI 59 IRQ_TYPE_LEVEL_HIGH>;
		clocks = <&cru ACLK_VOP>, <&cru DCLK_VOP>, <&cru HCLK_VOP>;
		clock-names = "aclk_vop", "dclk_vop", "hclk_vop";
		iommus = <&vop_mmu>;
		power-domains = <&power RV1126_PD_VO>;
		status = "disabled";

		vop_out: port {
			#address-cells = <1>;
			#size-cells = <0>;

			vop_out_rgb: endpoint@0 {
				reg = <0>;
				remote-endpoint = <&rgb_in_vop>;
			};

			vop_out_dsi: endpoint@1 {
				reg = <1>;
				remote-endpoint = <&dsi_in_vop>;
			};
		};
	};

	dsi: dsi@ffb30000 {
		compatible = "rockchip,rv1126-mipi-dsi";
		reg = <0xffb30000 0x500>;
		interrupts = <GIC_SPI 61 IRQ_TYPE_LEVEL_HIGH>;
		clocks = <&cru PCLK_DSIHOST>, <&mipi_dphy>;
		clock-names = "pclk", "hs_clk";
		resets = <&cru SRST_DSIHOST_P>;
		reset-names = "apb";
		phys = <&mipi_dphy>;
		phy-names = "mipi_dphy";
		rockchip,grf = <&grf>;
		#address-cells = <1>;
		#size-cells = <0>;
		power-domains = <&power RV1126_PD_VO>;
		status = "disabled";

		ports {
			port {
				dsi_in_vop: endpoint {
					remote-endpoint = <&vop_out_dsi>;
				};
			};
		};
	};

display_init

分别获取connect、panel、crtc的结构体信息，然后初始化

//判断通路以及控制器是否初始化过
	if (state->is_init)
		return 0;

	if (!conn_funcs || !crtc_funcs) {
		printf("failed to find connector or crtc functions\n");
		return -ENXIO;
	}

	if (crtc_state->crtc->active &&
	    memcmp(&crtc_state->crtc->active_mode, &conn_state->screen[lcd_index].mode,
		   sizeof(struct drm_display_mode))) {
		printf("%s has been used for output type: %d, mode: %dx%dp%d\n",
			crtc_state->dev->name,
			crtc_state->crtc->active_mode.type,
			crtc_state->crtc->active_mode.hdisplay,
			crtc_state->crtc->active_mode.vdisplay,
			crtc_state->crtc->active_mode.vrefresh);
		return -ENODEV;
	}
//设置crtc控制器最大分辨率 	
if (crtc_funcs->preinit) {
		ret = crtc_funcs->preinit(state);
		if (ret)
			return ret;
	}
//panel初始化，设置bus_format -> 100e
if (panel_state->panel)
    rockchip_panel_init(panel_state->panel);
//connect初始化
if (conn_funcs->init) {
    ret = conn_funcs->init(state);
    if (ret)
        goto deinit;
}
//crtc和conect的prepare
if (crtc_funcs->prepare)
    crtc_funcs->prepare(state);

if (conn_funcs->prepare)
    conn_funcs->prepare(state, -1);
//panel的类型获取比如使用什么屏
if (panel_state->panel)
    display_get_lcd_index(panel_state->panel);
//panel的timing 和其他参数
if (panel_state->panel) {
    ret = display_get_timing(state);
    mode = &conn_state->screen[lcd_index].mode;
    if (!ret)
        conn_state->bpc = panel_state->panel->bpc;
    #if defined(CONFIG_I2C_EDID)
    if (ret < 0 && conn_funcs->get_edid) {
        rockchip_panel_prepare(panel_state->panel);

        ret = conn_funcs->get_edid(state);
        if (!ret) {
            ret = edid_get_drm_mode((void *)&conn_state->edid,
                                    sizeof(conn_state->edid),
                                    mode, &bpc);
            if (!ret) {
                conn_state->bpc = bpc;
                edid_print_info((void *)&conn_state->edid);
            }
        }
    }
    #endif
} else if (conn_state->bridge) {
    ret = video_bridge_read_edid(conn_state->bridge->dev,
                                 conn_state->edid, EDID_SIZE);
    if (ret > 0) {
        #if defined(CONFIG_I2C_EDID)
        ret = edid_get_drm_mode(conn_state->edid, ret, mode,
                                &bpc);
        if (!ret) {
            conn_state->bpc = bpc;
            edid_print_info((void *)&conn_state->edid);
        }
        #endif
    } else {
        ret = video_bridge_get_timing(conn_state->bridge->dev);
    }
} else if (conn_funcs->get_timing) {
    ret = conn_funcs->get_timing(state);
} else if (conn_funcs->get_edid) {
    ret = conn_funcs->get_edid(state);
    #if defined(CONFIG_I2C_EDID)
    if (!ret) {
			ret = edid_get_drm_mode((void *)&conn_state->edid,
						sizeof(conn_state->edid), mode,
						&bpc);
			if (!ret) {
				conn_state->bpc = bpc;
				edid_print_info((void *)&conn_state->edid);
			}
		}
#endif
	}


//获取display的时序和前后栏参数
static int display_get_timing(struct display_state *state)
{
	struct connector_state *conn_state = &state->conn_state;
	//struct drm_display_mode *mode = &conn_state->mode;
	//struct mipi_screen *mscreen = conn_state->screen;
	const struct drm_display_mode *m;
	struct panel_state *panel_state = &state->panel_state;
	const struct rockchip_panel *panel = panel_state->panel;

	if (dev_of_valid(panel->dev) &&
	    !display_get_timing_from_dts(panel_state, conn_state)) {
		printf("Using display timing dts %d\n", conn_state->screen[lcd_index].mode.hdisplay);
		return 0;
	}

	if (panel->data) {
		m = (const struct drm_display_mode *)panel->data;
		memcpy(&conn_state->screen[lcd_index].mode, m, sizeof(*m));
		printf("Using display timing from compatible panel driver\n");
		return 0;
	}

	return -ENODEV;
}
//具体参数从dts中获取，首先获取到mipilcd参数节点，再得到lcd的子节点有几个，然后遍历子节点把dts的参数赋值到具体的panel上
static int display_get_timing_from_dts(struct panel_state *panel_state,
				       struct connector_state *conn_state)
{
	struct rockchip_panel *panel = panel_state->panel;
	int phandle;
	int hactive, vactive, pixelclock;
	int hfront_porch, hback_porch, hsync_len;
	int vfront_porch, vback_porch, vsync_len;
	int val, flags = 0;
	ofnode timing, native_mode;
	const char *lcd_name;

	int len = 0;
	int index = -1;
	int lcd_phandle;
	ofnode lcd_list;
	ofnode lcd_node;

	struct mipi_screen *mscreen;
	int i = 0, j = 0;

	lcd_phandle = dev_read_u32_default(panel->dev, "mipilcd", -1);
	lcd_list = np_to_ofnode(of_find_node_by_phandle(lcd_phandle));
	if (!ofnode_valid(lcd_list)) {
		printf("failed to get display timings from DT\n");
		return -ENXIO;
	}

	ofnode_for_each_subnode(lcd_node, lcd_list) {
		lcd_name = ofnode_get_property(lcd_node, "name", &len);
		if(0 == strncmp(lcd_name, "lcd", 3)) {
			index = atoi((lcd_name+3));
			if(index == 0) {
				continue;
			}
			i++;
		}
	}

	mscreen = calloc(i+1, sizeof(struct mipi_screen));
	if (mscreen == NULL) {
		printf("failed to alloc mipi_screen memory\n");
		return -EFAULT;
	}

	ofnode_for_each_subnode(lcd_node, lcd_list) {
		lcd_name = ofnode_get_property(lcd_node, "name", &len);
		if(0 == strncmp(lcd_name, "lcd", 3)) {
			index = atoi((lcd_name+3));
			if(index == 0 || index > i) {
				continue;
			}
			j = index;
			timing = ofnode_find_subnode(lcd_node, "display-timings");
			if (!ofnode_valid(timing))
				return -ENODEV;

			native_mode = ofnode_find_subnode(timing, "timing");
			if (!ofnode_valid(native_mode)) {
				phandle = ofnode_read_u32_default(timing, "native-mode", -1);
				native_mode = np_to_ofnode(of_find_node_by_phandle(phandle));
				if (!ofnode_valid(native_mode)) {
					printf("failed to get display timings from DT\n");
					return -ENXIO;
				}
			}
			FDT_GET_INT(hactive, "hactive");
			FDT_GET_INT(vactive, "vactive");
			FDT_GET_INT(pixelclock, "clock-frequency");
			FDT_GET_INT(hsync_len, "hsync-len");
			FDT_GET_INT(hfront_porch, "hfront-porch");
			FDT_GET_INT(hback_porch, "hback-porch");
			FDT_GET_INT(vsync_len, "vsync-len");
			FDT_GET_INT(vfront_porch, "vfront-porch");
			FDT_GET_INT(vback_porch, "vback-porch");
			FDT_GET_INT(val, "hsync-active");
			flags |= val ? DRM_MODE_FLAG_PHSYNC : DRM_MODE_FLAG_NHSYNC;
			FDT_GET_INT(val, "vsync-active");
			flags |= val ? DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC;
			FDT_GET_INT(val, "pixelclk-active");
			flags |= val ? DRM_MODE_FLAG_PPIXDATA : 0;

			FDT_GET_INT_DEFAULT(val, "screen-rotate", 0);
			if (val == DRM_MODE_FLAG_XMIRROR) {
				flags |= DRM_MODE_FLAG_XMIRROR;
			} else if (val == DRM_MODE_FLAG_YMIRROR) {
				flags |= DRM_MODE_FLAG_YMIRROR;
			} else if (val == DRM_MODE_FLAG_XYMIRROR) {
				flags |= DRM_MODE_FLAG_XMIRROR;
				flags |= DRM_MODE_FLAG_YMIRROR;
			}
			mscreen[j].mode.hdisplay = hactive;
			mscreen[j].mode.hsync_start = mscreen[j].mode.hdisplay + hfront_porch;
			mscreen[j].mode.hsync_end = mscreen[j].mode.hsync_start + hsync_len;
			mscreen[j].mode.htotal = mscreen[j].mode.hsync_end + hback_porch;

			mscreen[j].mode.vdisplay = vactive;
			mscreen[j].mode.vsync_start = mscreen[j].mode.vdisplay + vfront_porch;
			mscreen[j].mode.vsync_end = mscreen[j].mode.vsync_start + vsync_len;
			mscreen[j].mode.vtotal = mscreen[j].mode.vsync_end + vback_porch;

			mscreen[j].mode.clock = pixelclock / 1000;
			mscreen[j].mode.flags = flags;
		}
	}
	conn_state->screen = mscreen;
	return 0;
}

display logo

//首先调用display_init 初始化display的crtc connect 和pannel
ret = display_init(state);
if (!state->is_init || ret)
return -ENODEV;
//加载logo
if (load_bmp_logo(&state->logo, state->ulogo_name))
    printf("failed to display uboot logo\n");
//设定logo 显示模式 全屏或者居中
	if (logo->mode == ROCKCHIP_DISPLAY_FULLSCREEN) {
		crtc_state->crtc_x = 0;
		crtc_state->crtc_y = 0;
		crtc_state->crtc_w = hdisplay;
		crtc_state->crtc_h = vdisplay;
	} else {
		if (crtc_state->src_w >= hdisplay) {
			crtc_state->crtc_x = 0;
			crtc_state->crtc_w = hdisplay;
		} else {
			crtc_state->crtc_x = (hdisplay - crtc_state->src_w) / 2;
			crtc_state->crtc_w = crtc_state->src_w;
		}

		if (crtc_state->src_h >= vdisplay) {
			crtc_state->crtc_y = 0;
			crtc_state->crtc_h = vdisplay;
		} else {
			crtc_state->crtc_y = (vdisplay - crtc_state->src_h) / 2;
			crtc_state->crtc_h = crtc_state->src_h;
		}
	}
//调用ctrc的plane 设定
	display_set_plane(state);
	display_enable(state);
//conn_funcs->prepare 下发panel 参数
static int display_enable(struct display_state *state)
{
	struct connector_state *conn_state = &state->conn_state;
	const struct rockchip_connector *conn = conn_state->connector;
	const struct rockchip_connector_funcs *conn_funcs = conn->funcs;
	struct crtc_state *crtc_state = &state->crtc_state;
	const struct rockchip_crtc *crtc = crtc_state->crtc;
	const struct rockchip_crtc_funcs *crtc_funcs = crtc->funcs;
	struct panel_state *panel_state = &state->panel_state;

	if (!state->is_init)
		return -EINVAL;

	if (state->is_enable)
		return 0;

	if (crtc_funcs->prepare)
		crtc_funcs->prepare(state);

	if (conn_funcs->prepare)
		conn_funcs->prepare(state, 0);

	if (conn_state->bridge)
		rockchip_bridge_pre_enable(conn_state->bridge);

	if (panel_state->panel)
		rockchip_panel_prepare(panel_state->panel);

	if (crtc_funcs->enable)
		crtc_funcs->enable(state);

	if (conn_funcs->enable)
		conn_funcs->enable(state);

	if (conn_state->bridge)
		rockchip_bridge_enable(conn_state->bridge);

	if (panel_state->panel)
		rockchip_panel_enable(panel_state->panel);

	state->is_enable = true;

	return 0;
}
不吃辣的同学
关注
专栏目录
RK356x U-Boot研究所（驱动篇）4.2.1 DRM分析之LOGO显示
Systemcall名屋
01-22 494
RK356x U-Boot研究所（驱动篇）4.2.1 DRM分析之LOGO显示
RK356x U-Boot研究所（驱动篇）4.2.2 DRM代码结构分析
Systemcall名屋
02-19 255
RK356x U-Boot研究所（驱动篇）4.2.2 DRM代码结构分析
20240816使用SDDiskTool_v1.69写32GB的TF卡后给飞凌OK3588-C核心板刷机异常了
最新发布
南岭笑笑生之家
08-16 372
由于 E:\20240506的OK3588-C开发板\OK3588-C_Linux5.10.66+Qt5.15.2_用户资料_R4(更新日期_20240321)\Linux\工具\SDDiskTool_v1.72.zip。参考资料：《OK3588-C_Linux5.10.66+Qt5.15.2_用户使用手册_V1.2_20240321.pdf》的 《4.2 TF 卡烧写系统》据飞凌：由于通过TF卡刷机也就是先要通过TF卡启动，那就是把TF卡的默认/主显示屏也要配置为HDMI0。等了十分钟+，串口没有提示。
【DRM】DRM bridge驱动调用流程简单分析
Muggle的博客
06-10 3296
Linux中DRM bridge驱动调用流程简单分析。
【U-Boot驱动模型DM】
heshuangzong的博客
04-04 2262
DM即drivermodule，也就是驱动模型。后续以数据结构、如何定义、存放位置、如何获取四个部分进行说明。这种方式除了根设备外基本上不使用。（1）通过U_BOOT_DRVINFO宏来进行定义或者直接定义struct driver_info结构体（2）U_BOOT_DRVINFO宏以ns16550_serial为例U_BOOT_DRVINFO实现如下：和上述的U_BOOT_DRIVER类似注：在老版本的uboot中，没有U_BOOT_DRVINFO，而是用U_BOOT_DEVICE替代。
Linux驱动开发之DRM驱动
黑客三遍猪
08-05 9198
参考 DRM 驱动程序开发（开篇） drm 驱动是如何创建 fb device 的 Linux中的DRM 介绍 Linux Graphic DRI 显示子系统 介绍1 Xilinx DRM KMS driver
Linux驱动学习--DRM框架介绍及基于DRM框架的HDMI开发
文艺小少年的博客
06-11 5355
目录 一、引言 二、DRM框架介绍 三、DRM框架的使用 四、源码分析 一、引言 Android4开始，hdmi等视频输出框架开始由framebuffer想DRM迁移，今天我们就来简单分析下DRM框架 二、DRM框架介绍 DRM是一个内核级的设备驱动，具体的说是显卡驱动的一种架构 源码位置 因为Linux kernel内部接口和数据结构可能随时发生变化，所以DRI模块要针对特定的内核版本进行编译。kernel 2.6.26之后的版本，DRM(DRI kernel模块)源码存放在kernel/drivers/
RK3568-drm框架
Paper_Love的博客
09-17 1268
DRM 全称是 Direct Rendering Manager，进行显示输出管理、buffer 分配、帧缓冲。对应 userspace 库为 libdrm,，libdrm 库提供了一系列友好的控制封装，使用户可以方便的进行显示的控制和 buffer 申请。DRM的设备节点为 "/dev/dri/cardX"， X 为 0-15 的数值，默认使用的是/dev/dri/card0。从 linux 4.4 内核开始，Rockchip 显示驱动全部切到 DRM 显示框架。
RK3568平台（显示篇） DRM显示框架
weixin_49303682的博客
10-14 4955
显示子系统是 Rockchip 平台显示输出相关软硬件系统的统称，它包括 VOP（比较老的平台叫 LCDC，比如 RK3188、RK3066）和 RGB、BT1120、BT656、I8080（MCU 显示接口），LVDS、MIPI DSI、EDP、DP、HDMI 等显示信号输 出模块以及与之对应的软件驱动。
drm设备不工作
greedyhao的博客
07-26 1194
在设备升级新版内核后，发现没有 fb0 设备，开机没有打印 drm 相关的信息 首先是检查设备树，确认加入 panel 节点 panel: panel { compatible = "lg,lb070wv8”, “simple-panel"; #address-cells = <1>; #size-cells = <0>; enable-gpios = &l...
Linux内核4.14版本——drm框架分析(1)——drm简介
yangguoyu8023的博客
03-03 7111
drm框架分析
Linux内核bridge浅析
weixin_30613343的博客
11-17 583
Linux网桥模型：　　Linux内核通过一个虚拟的网桥设备来实现桥接的，这个设备可以绑定若干个以太网接口设备，从而将它们桥接起来。如下图所示： 网桥设备br0绑定了eth0和eth1。对于网络协议栈的上层来说，只看得到br0，因为桥接是在数据链路层实现的，上层不需要关心桥接的细节。于是协议栈上层需要发送的报文被送到br0，网桥设备的处理代码再来判断报文该被转发到eth0或是et...
kms框架
Muggle的博客
02-10 2293
KMS(Kernel Mode Setting)的框架如下，用户空间使用双framebuffer机制，分别对应两个plane对象。plane从drm_framebuffer获取显示数据。然后plane传送给crtc（lcdif控制器），经过编码后再送给显示屏（connector）进行显示。一般来说现在的soc都在lcdif外围设计了bridge ip来实现诸如mipi、lvds和hdmi的功能。这里芯片已经实现的bridge就是我们这里的drm encoder（显示编码器）。而在encoder下面外接转换芯
DRM驱动
ask_true的博客
04-20 1416
DRM驱动
基于DRM框架的HDMI热插拔流程分析
advdbgger的博客
12-02 2490
塾DRM基于DRM框架的HDMI热插拔流程分析PART.01DRM介绍DRM 全称是Direct Rendering Manager，进行显示输出管理、buffer 分配、帧缓冲。对应userspace 库为libdrm，libdrm 库提供了一系列友好的控制封装，使用户可以方便的进行显示的控制和buffer 申请。GDK8使用的是瑞芯微的RK3328芯片，而瑞芯微的显示框架有两大模块，分别是DR...
RK3288 Android7.1 uboot部分的MIPI显示流程
Mrdeath的博客
01-09 971
rockchip_dsi_panel_init（drivers/video/rockchip_dsi_panel.c） rockchip_dsi_panel_parse_dt (drivers/video/rockchip_dsi_panel.c获取reset-delay等数据)
uboot中使用device tree
隔壁科技宅
03-07 3630
最近搞uboot 驱动，搞了好久才发现uboot的dts规则跟kernel不一样， uboot驱动务必要加入bind函数，否则，驱动不会被初始化。 示例如下： static int mipi_dsi_bind(struct udevice *dev) {              printf("Eric: mipi_dsi bind!\n");     return 0;
STM32MP157A驱动开发 | 04 - Linux DRM显示驱动框架
Mculover666的博客（嵌入式）
08-06 2092
DRM框架包含两部分：DRM core和DRM driver。DRM core提供了一个基本的框架，DRM driver可以注册进DRM框架，同时为用户空间提供一组ioctl。libdrm对底层接口（DRM driver提供的ioctl）进行封装，向上层提供统一的API接口。DRM driver包含了GEM模块和KMS模块。......
Display--基本概念
h_8410435的博客
05-11 4684
文章目录Display中的DRM模块介绍DRM概述： Display中的DRM模块介绍 DRM概述： DRM全称 Direct Rendering Manager(直接渲染管理器),进行显示输出管理、 buffer 分配、 帧缓冲， 是device-independent内核级别驱动，内核提供直接访问硬件的权限， 原本是设计提供给PC使用来支持复杂的图形设备，后来也用于嵌入式系统上。PC一般都有显卡并且有自己的video memory，而嵌入式系统没有。DRM的设备节点为 "/dev/dri/cardX"
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值