在uboot中获取设备树的gpio属性并控制+屏幕初始化分析

最新推荐文章于 2024-05-27 14:32:00 发布
最新推荐文章于 2024-05-27 14:32:00 发布
阅读量3.5k 收藏 15
点赞数 7
分类专栏： 驱动 Uboot 文章标签： 驱动开发 单片机 stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68294039/article/details/125067260
版权
1.

在以往调驱动的经历中，改动最多的就是内核，在内核中我们可以去修改设备树，修改驱动源码，在驱动中去获取设备树中相关的硬件信息，但是我们都很少在uboot中修改或者添加代码，然而我们在工作中有时候也会碰到需要在uboot中去修改相关的驱动源码，去获取设备树的相关信息，以此满足项目需求。好了话不多少直接进入正题。
板子是基于rk3368的板子，板子上挂了一块lvds屏,硬件工程师提出要修改一下屏幕的时序，原本想来应该很简单的才对，结果按照以往的思维去内核中panel-simple.c的probe函数添加代码获取设备树中的IO口,然后延时处理，同时在panel_simple_prepare做延时处理，以此满足时序要求，如下：

static int panel_simple_prepare(struct drm_panel *panel)
{
	struct panel_simple *p = to_panel_simple(panel);
	int err;

	if (p->prepared)
		return 0;

	err = regulator_enable(p->supply);
	if (err < 0) {
		dev_err(panel->dev, "failed to enable supply: %d\n", err);
		return err;
	}

	printk("%s----------->\r\n",__func__);
	if (p->power_gpio)
	{
		gpiod_direction_output(p->power_gpio, 1);
		msleep(10);
		//printk("%s:panel->power_gpio, delay\r\n",__func__);
	}
	if (p->enable_gpio)
	{
		gpiod_direction_output(p->enable_gpio, 1);
		msleep(10);
		//printk("%s:panel->enable_gpio, delay\r\n",__func__);
	}

	if (p->reset_gpio)
	{
		gpiod_direction_output(p->reset_gpio, 1);
		//printk("%s:panel->reset_gpio, delay\r\n",__func__);
	}

	msleep(10);

	if (p->backlight_gpio) {
		printk(KERN_ERR"[PANEL]: set backlight power on.\n");
		gpiod_direction_output(p->backlight_gpio, 1);
	}

	if (p->desc && p->desc->delay.prepare)
		msleep(p->desc->delay.prepare);

	p->prepared = true;

	return 0;
}


static int panel_simple_probe(struct device *dev, const struct panel_desc *desc)
{
	struct device_node *backlight, *ddc;
	struct panel_simple *panel;
	struct panel_desc *of_desc;
	u32 val;
	int err;

	panel = devm_kzalloc(dev, sizeof(*panel), GFP_KERNEL);
	if (!panel)
		return -ENOMEM;

	if (!desc)
		of_desc = devm_kzalloc(dev, sizeof(*of_desc), GFP_KERNEL);
	else
		of_desc = devm_kmemdup(dev, desc, sizeof(*of_desc), GFP_KERNEL);

	if (!of_property_read_u32(dev->of_node, "bus-format", &val))
		of_desc->bus_format = val;
	if (!of_property_read_u32(dev->of_node, "delay,prepare", &val))
		of_desc->delay.prepare = val;
	if (!of_property_read_u32(dev->of_node, "delay,enable", &val))
		of_desc->delay.enable = val;
	if (!of_property_read_u32(dev->of_node, "delay,disable", &val))
		of_desc->delay.disable = val;
	if (!of_property_read_u32(dev->of_node, "delay,unprepare", &val))
		of_desc->delay.unprepare = val;

	panel->enabled = false;
	panel->prepared = false;
	panel->desc = of_desc;
	panel->dev = dev;

	panel->supply = devm_regulator_get(dev, "power");
	if (IS_ERR(panel->supply)) {
		err = PTR_ERR(panel->supply);
		dev_err(dev, "failed to request power supply: %d\n", err);
		return PTR_ERR(panel->supply);
	}

	panel->enable_gpio = devm_gpiod_get_optional(dev, "enable", 0);
	if (IS_ERR(panel->enable_gpio)) {
		err = PTR_ERR(panel->enable_gpio);
		dev_err(dev, "failed to request enable GPIO: %d\n", err);
		return err;
	} else {
		gpiod_direction_output(panel->enable_gpio, 1);
		printk("%s:panel->enable_gpio, 0\r\n",__func__);
	}

	panel->power_gpio = devm_gpiod_get_optional(dev, "power", 0);
	if (IS_ERR(panel->power_gpio)) {
		err = PTR_ERR(panel->power_gpio);
		dev_err(dev, "failed to request reset GPIO: %d\n", err);
	} else {
		gpiod_direction_output(panel->power_gpio, 1);
		printk("%s:panel->power_gpio, 0\r\n",__func__);
	}

	panel->backlight_gpio = devm_gpiod_get_optional(dev, "backlight", 0);
	if (IS_ERR(panel->backlight_gpio)) {
		err = PTR_ERR(panel->backlight_gpio);
		dev_err(dev, "failed to request reset GPIO: %d\n", err);
	} else {
		gpiod_direction_output(panel->backlight_gpio, 1);
	}

	panel->reset_gpio = devm_gpiod_get_optional(dev, "reset", 0);
	if (IS_ERR(panel->reset_gpio)) {
		err = PTR_ERR(panel->reset_gpio);
		dev_err(dev, "failed to request reset GPIO: %d\n", err);
	}
	else 
	{
		gpiod_direction_output(panel->reset_gpio, 1);
		printk("%s:panel->reset_gpio, 0\r\n",__func__);
	}
	.....
	}
2.

但是无论怎么修改发现都无法拉低power_gpio口，而硬件要求在上电过程中要把power,stb，reset完全拉低在进行相应的延时处理来达到时序要求，所以修改内核这条路就行不通，于是我们想到直接去uboot中获取设备树的中IO口信息，然后将三个IO口拉低，再做延时处理以此满足要求。下面贴出代码：
设备树：

/{
	lvds_panel: lvds-panel {
		status = "okay";
		compatible = "simple-panel";
		backlight = <&backlight>;
		bus-format = <MEDIA_BUS_FMT_RBG888_1X24>;
		enable-gpios = <&gpio0 RK_PD4 GPIO_ACTIVE_HIGH>;
		reset-gpios = <&gpio0 RK_PB7 GPIO_ACTIVE_HIGH>;
		power-gpios = <&gpio0 RK_PC3 GPIO_ACTIVE_HIGH>;
		backlight-gpios = <&gpio0 RK_PC7 GPIO_ACTIVE_HIGH>;
		rockchip,data-mapping = "vesa";
		rockchip,data-width = <24>;
		rockchip,output = "lvds";
		display-timings {
			native-mode = <&timing0>;

			timing0: timing0 {
			clock-frequency = <60000000>;
			hactive = <1024>;
			vactive = <600>;
			hback-porch = <90>;
			hfront-porch = <160>;
			vback-porch = <13>;
			vfront-porch = <12>;
			hsync-len = <70>;
			vsync-len = <10>;
			hsync-active = <0>;
			vsync-active = <0>;
			de-active = <0>;
			pixelclk-active = <0>;
			};
		};

		ports {
			panel_in_lvds: endpoint {
				remote-endpoint = <&lvds_out_panel>;
			};
		};
	};
};
...

&lvds {
	status = "okay";
	rockchip,panel = <&lvds_panel>;
	pinctrl-names = "default";
	pinctrl-0 = <&gpio0_c3 &gpio0_c7 &gpio0_d4 &gpio0_b7>;

	ports {
		lvds_out: port@1 {
			reg = <1>;
			#address-cells = <1>;
			#size-cells = <0>;

			lvds_out_panel: endpoint@0 {
				reg = <0>;
				remote-endpoint = <&panel_in_lvds>;
			};
		};
	};
};

&route_lvds {
	status = "okay";
};

首先cpu会先执行到：


int rockchip_display_init(void)
{
	const void *blob = gd->fdt_blob;
	int route, child, phandle, connect, crtc_node, conn_node;
	const struct rockchip_connector *conn;
	const struct rockchip_crtc *crtc;
	struct display_state *s;
	const char *name;

	printf("%s--------------------------------%d\n",__func__,__LINE__);
	route = fdt_path_offset(blob, "/display-subsystem/route");
	if (route < 0) {
		printf("Can't find display display route node\n");
		return -ENODEV;
	}

	printf("%s--------------------->%d\n",__func__,__LINE__);
	if (!fdt_device_is_available(blob, route))
		return -ENODEV;

	init_display_buffer();

	fdt_for_each_subnode(blob, child, route) {
		if (!fdt_device_is_available(blob, child))
			continue;

		phandle = fdt_getprop_u32_default_node(blob, child, 0,
						       "connect", -1);
		if (phandle < 0) {
			printf("Warn: %s: can't find connect node's handle\n",
			       fdt_get_name(blob, child, NULL));
			continue;
		}

		connect = fdt_node_offset_by_phandle(blob, phandle);
		if (connect < 0) {
			printf("Warn: %s: can't find connect node\n",
			       fdt_get_name(blob, child, NULL));
			continue;
		}

		crtc_node = find_crtc_node(blob, connect);
		if (!fdt_device_is_available(blob, crtc_node)) {
			printf("Warn: %s: crtc node is not available\n",
			       fdt_get_name(blob, child, NULL));
			continue;
		}
		crtc = rockchip_get_crtc(blob, crtc_node);
		if (!crtc) {
			printf("Warn: %s: can't find crtc driver\n",
			       fdt_get_name(blob, child, NULL));
			continue;
		}

		conn_node = find_connector_node(blob, connect);
		if (!fdt_device_is_available(blob, conn_node)) {
			printf("Warn: %s: connector node is not available\n",
			       fdt_get_name(blob, child, NULL));
			continue;
		}

		conn = rockchip_get_connector(blob, conn_node);
		if (!conn) {
			printf("Warn: %s: can't find connector driver\n",
			       fdt_get_name(blob, child, NULL));
			continue;
		}

		s = malloc(sizeof(*s));
		if (!s)
			goto err_free;

		memset(s, 0, sizeof(*s));

		INIT_LIST_HEAD(&s->head);
		fdt_get_string(blob, child, "logo,uboot", &s->ulogo_name);
		fdt_get_string(blob, child, "logo,kernel", &s->klogo_name);
		fdt_get_string(blob, child, "logo,mode", &name);
		if (!strcmp(name, "fullscreen"))
			s->logo_mode = ROCKCHIP_DISPLAY_FULLSCREEN;
		else
			s->logo_mode = ROCKCHIP_DISPLAY_CENTER;
		fdt_get_string(blob, child, "charge_logo,mode", &name);
		if (!strcmp(name, "fullscreen"))
			s->charge_logo_mode = ROCKCHIP_DISPLAY_FULLSCREEN;
		else
			s->charge_logo_mode = ROCKCHIP_DISPLAY_CENTER;

		s->blob = blob;
		s->conn_state.node = conn_node;
		s->conn_state.connector = conn;
		s->crtc_state.node = crtc_node;
		s->crtc_state.crtc = crtc;
		s->crtc_state.crtc_id = get_crtc_id(blob, connect);
		s->node = child;

		connector_phy_init(s);
		connector_panel_init(s);
		list_add_tail(&s->head, &rockchip_display_list);
	}

	return 0;

err_free:
	list_for_each_entry(s, &rockchip_display_list, head) {
		list_del(&s->head);
		free(s);
	}
	return -ENODEV;
}

而在这个函数中会调用fdt_path_offset它会去获得lvds主节点关于这个函数有如下说明：

fdt_path_offset
int fdt_path_offset(const void *fdt, const char *path) 
eg：node = fdt_path_offset(gd->fdt_blob, “/aliases”); 
功能：获得dtb下某个节点的路径path的偏移。这个偏移就代表了这个节点

fdt_device_is_available判断节点是否可用

fdt_for_each_subnode:这是一个循环去获取这个节点下的各个子节点属性原型：

/**
 * fdt_for_each_subnode - iterate over all subnodes of a parent
 *
 * This is actually a wrapper around a for loop and would be used like so:
 *
 *	fdt_for_each_subnode(fdt, node, parent) {
 *		...
 *		use node
 *		...
 *	}
 *
 * Note that this is implemented as a macro and node is used as iterator in
 * the loop. It should therefore be a locally allocated variable. The parent
 * variable on the other hand is never modified, so it can be constant or
 * even a literal.
 *
 * @fdt:	FDT blob (const void *)
 * @node:	child node (int)
 * @parent:	parent node (int)
 */
#define fdt_for_each_subnode(fdt, node, parent)		\
	for (node = fdt_first_subnode(fdt, parent);	\
	     node >= 0;					\
	     node = fdt_next_subnode(fdt, node))

  • connector_phy_init(s);
    这个函数是去初始化lvds外设

  • list_add_tail(&s->head, &rockchip_display_list);
    添加设备链表节点

  • connector_panel_init(s);
    这个函数当中就有初始化屏幕的调用，而我们的时序就是要在这个函数中去作处理。

3.

connector_panel_init(s)的源码：

static int connector_panel_init(struct display_state *state)
{
	struct connector_state *conn_state = &state->conn_state;
	struct panel_state *panel_state = &state->panel_state;
	const void *blob = state->blob;
	int conn_node = conn_state->node;
	const struct rockchip_panel *panel;
	int panel_node;
	int ret;

	printf("%s---------------------%d\r\n",__func__,__LINE__);
	panel_node = get_panel_node(state, conn_node);
	if (panel_node < 0) {
		printf("failed to find panel node\n");
		return -ENODEV;
	}

	if (!fdt_device_is_available(blob, panel_node)) {
		printf("panel is disabled\n");
		return -ENODEV;
	}

	panel_state->node = panel_node;

	panel = rockchip_get_panel(blob, panel_node);
	if (!panel) {
		printf("failed to find panel driver\n");
		return 0;
	}

	panel_state->panel = panel;

	ret = rockchip_panel_init(state);
	if (ret) {
		printf("failed to init panel driver\n");
		return ret;
	}

	return 0;
}
  • get_panel_node
    这个函数就是去获取lvds_panel这个节点，原型：
static int get_panel_node(struct display_state *state, int conn_node)
{
	const void *blob = state->blob;
	int panel, ports, port, ep, remote, ph, nodedepth;

	panel = fdt_subnode_offset(blob, conn_node, "panel");
	if (panel > 0)
		return panel;

	ports = fdt_subnode_offset(blob, conn_node, "ports");
	if (ports < 0)
		return -ENODEV;

	fdt_for_each_subnode(blob, port, ports) {
		fdt_for_each_subnode(blob, ep, port) {
			ph = fdt_getprop_u32_default_node(blob, ep, 0,
							  "remote-endpoint", 0);
			if (!ph)
				continue;

			remote = fdt_node_offset_by_phandle(blob, ph);

			nodedepth = fdt_node_depth(blob, remote);
			if (nodedepth < 2)
				continue;

			panel = fdt_supernode_atdepth_offset(blob, remote,
							     nodedepth - 2,
							     NULL);
			break;
		}
	}

	return panel;
}
  • rockchip_get_panel
    这个函数是获取匹配属性,原型：
const struct rockchip_panel *rockchip_get_panel(const void *blob, int node)
{
	const char *name;
	int i;

	fdt_get_string(blob, node, "compatible", &name);

	for (i = 0; i < ARRAY_SIZE(g_panel); i++)
		if (!strcmp(name, g_panel[i].compatible))
			break;

	if (i >= ARRAY_SIZE(g_panel))
		return NULL;

	return &g_panel[i];
}
  • rockchip_panel_init
    这个函数就会去初始化屏幕
3.

rockchip_panel_init原型如下：

int rockchip_panel_init(struct display_state *state)
{
struct panel_state *panel_state = &state->panel_state;
const struct rockchip_panel *panel = panel_state->panel;

printf("%s---------------------%d\r\n",__func__,__LINE__);
if (!panel || !panel->funcs || !panel->funcs->init) {
	printf("%s: failed to find panel init funcs\n", __func__);
	return -ENODEV;
}

return panel->funcs->init(state);

}
而在返回值这里使用了函数指针，panel->funcs->init(state);
而在这个const struct rockchip_panel *panel中有const struct rockchip_panel_funcs *funcs;这个成员变量，struct rockchip_panel 这个结构体内容如下：

struct rockchip_panel {
	char compatible[30];
	const struct rockchip_panel_funcs *funcs;
	const void *data;
};

struct rockchip_panel_funcs 这个结构体的内容如下：


struct rockchip_panel_funcs {
	int (*init)(struct display_state *state);
	void (*deinit)(struct display_state *state);
	int (*prepare)(struct display_state *state);
	int (*unprepare)(struct display_state *state);
	int (*enable)(struct display_state *state);
	int (*disable)(struct display_state *state);
};

而这些函数的实现是在panel_simple.c中,其中init函数赋值如下：

const struct rockchip_panel_funcs panel_simple_funcs = {
	.init		= panel_simple_init,
	.deinit		= panel_simple_deinit,
	.prepare	= panel_simple_prepare,
	.unprepare	= panel_simple_unprepare,
	.enable		= panel_simple_enable,
	.disable	= panel_simple_disable,
};

实现如下：


struct fdt_gpio_state gpio_ctl[3];
static int panel_simple_init(struct display_state *state)
{
	const void *blob = state->blob;
	struct connector_state *conn_state = &state->conn_state;
	struct panel_state *panel_state = &state->panel_state;
	int node = panel_state->node;
	const struct drm_display_mode *mode = panel_state->panel->data;
	struct panel_simple *panel;
	int ret;
	printf("%s---------------------%d\r\n",__func__,__LINE__);
	node = fdt_node_offset_by_compatible(blob,0, "simple-panel");
    if (node < 0) {
        printf("%s-->No detect Pine,mini_control.\n", __func__);
        return -ENODEV;
    }
    if (!fdt_device_is_available(blob,node)) {
        printf("%s-->device gpio_ctl is disabled\n", __func__);
        return -1;
    }
    fdtdec_decode_gpios(blob, node, "power-gpios", &gpio_ctl[0], 1);
	printf("%s:---------power_gpio:%d\r\n",__func__,gpio_ctl[0].gpio);

    fdtdec_decode_gpios(blob, node, "enable-gpios", &gpio_ctl[1], 1);
	printf("%s:---------enable_gpio:%d\r\n",__func__,gpio_ctl[1].gpio);

    fdtdec_decode_gpios(blob, node, "reset-gpios", &gpio_ctl[2], 1);
	printf("%s:---------reset_gpio:%d\r\n",__func__,gpio_ctl[2].gpio);

	gpio_direction_output(gpio_ctl[0].gpio,(gpio_ctl[0].flags& OF_GPIO_ACTIVE_LOW));
	gpio_direction_output(gpio_ctl[1].gpio,(gpio_ctl[1].flags& OF_GPIO_ACTIVE_LOW));
	gpio_direction_output(gpio_ctl[2].gpio,(gpio_ctl[2].flags& OF_GPIO_ACTIVE_LOW));
	msleep(1000);

	gpio_direction_output(gpio_ctl[0].gpio,!(gpio_ctl[0].flags& OF_GPIO_ACTIVE_LOW));
	msleep(10);
	gpio_direction_output(gpio_ctl[1].gpio,!(gpio_ctl[1].flags& OF_GPIO_ACTIVE_LOW));
	msleep(10);
	gpio_direction_output(gpio_ctl[2].gpio,!(gpio_ctl[2].flags& OF_GPIO_ACTIVE_LOW));


	panel = malloc(sizeof(*panel));
	if (!panel)
		return -ENOMEM;

	panel->blob = blob;
	panel->node = node;
	panel->mode = mode;
	panel_state->private = panel;

	ret = panel_simple_parse_dt(blob, node, panel);
	if (ret) {
		printf("%s: failed to parse DT\n", __func__);
		free(panel);
		return ret;
	}

	conn_state->bus_format = panel->bus_format;

	return 0;
}

在该函数中我是参考panel_simple_parse_dt这个函数去获取设备树中的IO属性的实现如下：

static int panel_simple_parse_dt(const void *blob, int node,
				 struct panel_simple *panel)
{
	struct fdt_gpio_state *enable_gpio = &panel->enable_gpio;

	fdtdec_decode_gpio(blob, node, "enable-gpios", enable_gpio);

	panel->delay_prepare = fdtdec_get_int(blob, node, "delay,prepare", 0);
	panel->delay_unprepare = fdtdec_get_int(blob, node, "delay,unprepare", 0);
	panel->delay_enable = fdtdec_get_int(blob, node, "delay,enable", 0);
	panel->delay_disable = fdtdec_get_int(blob, node, "delay,disable", 0);
	panel->bus_format = fdtdec_get_int(blob, node, "bus-format", MEDIA_BUS_FMT_RBG888_1X24);

	printf("delay prepare[%d] unprepare[%d] enable[%d] disable[%d]\n",
	       panel->delay_prepare, panel->delay_unprepare,
	       panel->delay_enable, panel->delay_disable);

	/* keep panel blank on init. */
	gpio_direction_output(enable_gpio->gpio,!(enable_gpio->flags & OF_GPIO_ACTIVE_LOW));

#ifdef CONFIG_RK_PWM_BL
	rk_pwm_bl_config(0);
#endif
	return 0;
}

fdtdec_decode_gpio该函数就是去获取IO口的，而这个struct fdt_gpio_state中的内容如下：

/* This is the state of a GPIO pin as defined by the fdt */
struct fdt_gpio_state {
	const char *name;	/* name of the fdt property defining this */
	uint gpio;		/* GPIO number, or FDT_GPIO_NONE if none */
	u8 flags;		/* FDT_GPIO_... flags */
};

用法就不说了上面有，控制输出高低：

	gpio_direction_output(gpio_ctl[2].gpio,(gpio_ctl[2].flags& OF_GPIO_ACTIVE_LOW));

驱动很绕，贴代码不容易呀，想想写出这驱动的更不容易～_～

lkdcom
关注
  • 7
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RK3399平台开发系列讲解（内核驱动外设篇）6.18、调试笔记显示屏参的三种配置方法
内核笔记
01-20 4211
平台 内核版本 安卓版本 RK3399 Linux4.4 Android7.1 文章目录屏配置方式一: 使用短字符串匹配写死的`timing`屏配置方式二: 直接将`timing`写在`dts`文件中屏配置方式三: 使用`edid` 屏配置方式一: 使用短字符串匹配写死的timing 把timings写在drivers/gpu/drm/panel/panel-simple.c中...
uboot GPIO调试
无线互联&网络介绍
04-25 266
268 /**270 *274 */整理下gpio_direction_output的调用流程，其他接口也可以535{538545548}42/**44 *48 *52 */54{57 int ret;5860 dev;67 }68 }6972}Note: gpio_to_device的作用是把GPIO Num找到对应的设备（dts可以配置多个gpio device）
uboot中展示gpio接口的驱动
永不秃头的程序员的博客
06-06 1233
按照道理来说，其实uboot就是一个简单的kernel模型，其操作方法和kernel中的类似。只是函数接口不一样。
RK3568 编写U-BOOT驱动 demo
最新发布
jamecer的博客
05-27 289
U-BOOT的启动也分阶段，第一阶段是SPL阶段，主要负责初始化芯片，这部分代码一般是SOC厂商来编写的；第二阶段就是U-boot的BL2，会执行一些板级初始化，其中我们主要关注的是外设的初始化。
uboot控制gpio
weixin_41252596的博客
12-22 2970
uboot控制gpio
uboot下的gpio的命令调试
10-19 930
4 gpio_request()-->gpio_to_device() 错误由gpio_to_device()返回。5 加打印调试发现 gpio_base和gpio_count都为0，应该是驱动中哪块没有正常赋值导致的。故修改代码为plat->name = fdt_get_name(blob, node, NULL);3 gpio_request申请gpio失败，打印errno=3。
RK3399 Linux-SDK mipi屏幕驱动及调试
热门推荐
sunqinglin4826的博客
03-13 2万+
一，流程及通路 我接触到的三款mipi屏幕，基本的点亮流程都是很一致的，就是背光使能-背光点亮-屏幕使能-reset引脚按指定时序/波形拉高或拉低-初始化序列命令发送。 3399的linuxSDK中，包含一种类似通用的屏幕驱动。本文档以使用此驱动为前提，不包含原理内容（硬件基础实在太差，原理自己也没有搞很通），只描述如何尽快的完成屏幕配置并最终将屏幕点亮。给自己留一个记录，也希...
RK3588S Andriod12调试OLED屏幕背光
u011774634的博客
06-08 2083
4，kernel-5.10/drivers/gpu/drm/drm_mipi_dsi.c中mipi_dsi_dcs_set_display_brightness函数就是调节亮度的地方。这一步很重要，因为上层调节背光时就是操作的这个背光设备节点（/sys/class/backlight/backlight），如果名字不对，上层调用的通路就没有打通。之后在dcs_bl_update_status函数中做个映射，通过调整brightness_table中的值就可以对背光亮度的调节曲线作出调整。
ROCKCHIP U-BOOT下操作GPIO
YuZhuQue的博客
12-23 1711
背景： 在进入 loader 模式的时候需要将一个 GPIO 拉高 代码修改 --- a/arch/arm/mach-rockchip/boot_rkimg.c +++ b/arch/arm/mach-rockchip/boot_rkimg.c @@ -33,6 +33,7 @@ #include <u-boot/sha1.h> #include <u-boot/sha256.h> #include <linux/usb/phy-rockchip-usb2.h>
jz2440 uboot设备树
01-13
在现代Linux系统中，设备树（Device Tree）已经成为配置和初始化硬件的重要手段。设备树不仅简化了内核的复杂性，同时也使得硬件平台的移植更为便捷。本文将深入探讨jz2440处理器在U-Boot中如何运用设备树，以及它与...
UBoot源码分析及在S3C2440的移植过程_Uboot源码分析_uboot_UBOOT移植_
10-03
4. **串口通信**：调试通常通过串口进行，需确保UBoot能够正确初始化串口，并输出调试信息。 5. **启动加载**：编写启动脚本，定义如何加载和启动操作系统映像。 6. **编译与烧录**：编译源码生成二进制文件，然后...
Simple-Panel
04-12
＃简单面板 自述文件即将推出...
Hi3518ev200在uboot下设置gpio默认电平
07-14
基本海思Hi3518ev200平台,在在uboot下设置gpio的默认输出电平
Uboot-boot-analyse.rar_uboot_启动分析
09-14
它负责在系统上电后初始化硬件，加载操作系统内核到内存中，然后将控制权交给内核，使得系统能够正常运行。本资料主要针对UBoot的启动过程进行详细分析，帮助读者理解其工作原理。 1. **UBoot概述** UBoot是一个...
Uboot-1.1.2+for+PXA270源码分析[归类].pdf
10-20
通过以上分析，我们可以了解到UBoot在PXA270处理器上的运行流程，从启动、初始化到执行用户命令的细节。深入理解这些源码不仅有助于我们调试和定制UBoot，也为嵌入式系统开发提供了宝贵的知识基础。对于希望深入...
imx8mp uboot
05-05
UBoot（Universal Boot Loader）是嵌入式系统中广泛使用的引导加载程序，它负责初始化硬件、加载操作系统内核并传递控制权。本篇文章将深入探讨IMX8MP处理器与UBoot之间的关联，以及UBoot在IMX8MP平台上的具体实现和...
Tina Linux：uboot里读取gpio的状态并传递字符串到kernel
12-30 1848
Tina Linux uboot kernel cmdline
Linux图形显示DRM子系统环境实践
Neil驱动的博客
07-30 3409
学习Linux图形DRM子系统，还是需要有一个运行DRM框架的linux系统，这样无论在学习DRM应用程序还是驱动程序时，可以实际动手修改调试，运行看到效果，学习起来也是比较有动力和成就感的。下面是一个搭建LinuxDRM运行环境的实践。.........
[RK3399] [Android 9.0] 调试2560x1440分辨率EDP显示屏，和碰到的休眠唤醒后花屏问题
qq1226176787的博客
01-09 5103
屏参： panel: panel { compatible = "simple-panel"; backlight = <&backlight>; power-supply = <&vcc_lcd>; enable-gpios = <&gpio3 16 GPIO_ACT...
xilinx uboot2019中rtl8211fd初始化流程
10-09
xilinx uboot 2019中rtl8211fd的初始化流程如下： 1. 首先，uboot会在设备启动时初始化MDIO（介质独立接口），用于与PHY（物理层接口）通信。 2. 接下来，uboot会配置PHY的寄存器，以便与外部设备进行通信。对于rtl8211fd，则需要进行以下操作： - 设置PHY的控制寄存器CR0，以启用PHY。 - 配置PHY的控制寄存器CR1，以选择合适的速度和双工模式。 - 配置PHY的其他寄存器，以满足特定的应用需求。 3. 在完成PHY配置后，uboot会检查PHY的状态，以确保它已经准备好与外部设备进行通信。 4. 最后，uboot会初始化以太网控制器，将PHY与以太网控制器连接起来。这涉及到配置以太网控制器的寄存器，以使用PHY提供的信息进行通信。 总结起来，xilinx uboot 2019中rtl8211fd的初始化流程主要包括初始化MDIO、配置PHY的寄存器、检查PHY状态和初始化以太网控制器。这些步骤确保PHY和以太网控制器之间的正常通信，从而使设备能够与外部网络进行数据交换。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值