Mastering Embedded Linux Programming 学习 （七）在百问网157开发板上，移植LCD驱动

于 2023-01-08 13:13:21 发布
阅读量283 收藏 2
点赞数
分类专栏： STM32MP157 笔记 文章标签： linux 学习 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_38383364/article/details/128434801
版权

Mastering Embedded Linux Programming 学习 （七）在百问网157开发板上，移植LCD驱动

修改设备树

首先修改设备树，添加LCD的设备节点

vim arch/arm/boot/dts/stm32mp157c-myboard.dts

在根节点下添加如下内容

/*LCD Panel*/
panel {
	compatible = "myir,070tft";
     	interrupts = <11 IRQ_TYPE_EDGE_FALLING>;
     	interrupt-parent = <&gpioe>;
     	pinctrl-names = "default", "sleep";
     	pinctrl-0 = <&ltdc_pins_a>;
     	pinctrl-1 = <&ltdc_pins_sleep_a>;
     	//reset-gpios = <&gpioe 12 GPIO_ACTIVE_LOW>;

	backlight = <&panel_backlight>;
    	 	status = "okay";
	
	port {
		panel_in: endpoint {
			remote-endpoint = <&ltdc_ep0_out>;			
		};

	};
};

在文件里重新设置ltdc，注释原来的ltdc，添加下面的节点

&ltdc {
        status = "okay";

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

                ltdc_ep0_out: endpoint@0 {
                                reg = <0>;
                                remote-endpoint = <&panel_in>;
                                };
           };
};

尝试编译设备树
发现重复定义了panel_in
把同文件下的dsi节点和ltdc节点给注释掉就好了

报错panel_backlight节点不存在
参考不定文件，寻找这个节点
在根节点下添加这个节点

panel_backlight: panel-backlight {
	compatible = "gpio-backlight";
	gpios = <&gpioe 11 GPIO_ACTIVE_HIGH>;
	default-on;	
	status = "okay";
};

再次编译设备树，发现通过了

节点添加完成了，接下来就是添加驱动了

添加驱动代码

参考补丁文件
需要添加文件drivers/gpu/drm/panel/panel-myir070tft.c

panel-myir070tft.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2019 myir
 * Author: licy
 *
 * Based on Panel Simple driver
 */

#include <linux/backlight.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regulator/consumer.h>

#include <video/display_timing.h>
#include <video/videomode.h>

#include <drm/drm_crtc.h>
#include <drm/drm_device.h>
#include <drm/drm_panel.h>


struct myir_panel_desc {
	const struct drm_display_mode *modes;
	unsigned int num_modes;
	const struct display_timing *timings;
	unsigned int num_timings;

	unsigned int bpc;

	/**
	 * @width: width (in millimeters) of the panel's active display area
	 * @height: height (in millimeters) of the panel's active display area
	 */
	struct {
		unsigned int width;
		unsigned int height;
	} size;

	u32 bus_format;
	u32 bus_flags;
};

struct myir_panel {
	struct drm_panel base;
	bool prepared;
	bool enabled;
	const struct myir_panel_desc *desc;
	struct backlight_device *backlight;
	struct regulator *dvdd;
	struct regulator *avdd;
};

static inline struct myir_panel *to_myir_panel(struct drm_panel *panel)
{
	return container_of(panel, struct myir_panel, base);
}

static int myir_panel_get_fixed_modes(struct myir_panel *panel)
{
	struct drm_connector *connector = panel->base.connector;
	struct drm_device *drm = panel->base.drm;
	struct drm_display_mode *mode;
	unsigned int i, num = 0;

	if (!panel->desc)
		return 0;

	for (i = 0; i < panel->desc->num_timings; i++) {
		const struct display_timing *dt = &panel->desc->timings[i];
		struct videomode vm;

		videomode_from_timing(dt, &vm);
		mode = drm_mode_create(drm);
		if (!mode) {
			dev_err(drm->dev, "failed to add mode %ux%u\n",
				dt->hactive.typ, dt->vactive.typ);
			continue;
		}

		drm_display_mode_from_videomode(&vm, mode);

		mode->type |= DRM_MODE_TYPE_DRIVER;

		if (panel->desc->num_timings == 1)
			mode->type |= DRM_MODE_TYPE_PREFERRED;

		drm_mode_probed_add(connector, mode);
		num++;
	}

	for (i = 0; i < panel->desc->num_modes; i++) {
		const struct drm_display_mode *m = &panel->desc->modes[i];

		mode = drm_mode_duplicate(drm, m);
		if (!mode) {
			dev_err(drm->dev, "failed to add mode %ux%u@%u\n",
				m->hdisplay, m->vdisplay, m->vrefresh);
			continue;
		}

		mode->type |= DRM_MODE_TYPE_DRIVER;

		if (panel->desc->num_modes == 1)
			mode->type |= DRM_MODE_TYPE_PREFERRED;

		drm_mode_set_name(mode);

		drm_mode_probed_add(connector, mode);
		num++;
	}

	connector->display_info.bpc = panel->desc->bpc;
	connector->display_info.width_mm = panel->desc->size.width;
	connector->display_info.height_mm = panel->desc->size.height;
	if (panel->desc->bus_format)
		drm_display_info_set_bus_formats(&connector->display_info,
						 &panel->desc->bus_format, 1);
	connector->display_info.bus_flags = panel->desc->bus_flags;

	return num;
}

static int myir_panel_disable(struct drm_panel *panel)
{
	struct myir_panel *p = to_myir_panel(panel);

	if (!p->enabled)
		return 0;

	if (p->backlight) {
		p->backlight->props.power = FB_BLANK_POWERDOWN;
		p->backlight->props.state |= BL_CORE_FBBLANK;
		backlight_update_status(p->backlight);
	}

	p->enabled = false;

	return 0;
}

static int myir_panel_unprepare(struct drm_panel *panel)
{
	struct myir_panel *p = to_myir_panel(panel);

	if (!p->prepared)
		return 0;

	regulator_disable(p->avdd);

	/* Add a 100ms delay as per the panel datasheet */
	msleep(100);

	regulator_disable(p->dvdd);

	p->prepared = false;

	return 0;
}

static int myir_panel_prepare(struct drm_panel *panel)
{
	struct myir_panel *p = to_myir_panel(panel);
	int err;

	if (p->prepared)
		return 0;
/*
	err = regulator_enable(p->dvdd);
	if (err < 0) {
		dev_err(panel->dev, "failed to enable dvdd: %d\n", err);
		return err;
	}
*/
	/* Add a 100ms delay as per the panel datasheet */
	msleep(100);
/*
	err = regulator_enable(p->avdd);
	if (err < 0) {
		dev_err(panel->dev, "failed to enable avdd: %d\n", err);
		goto disable_dvdd;
	}
*/
	p->prepared = true;

	return 0;

disable_dvdd:
	regulator_disable(p->dvdd);
	return err;
}

static int myir_panel_enable(struct drm_panel *panel)
{
	struct myir_panel *p = to_myir_panel(panel);

	if (p->enabled)
		return 0;

	if (p->backlight) {
		p->backlight->props.state &= ~BL_CORE_FBBLANK;
		p->backlight->props.power = FB_BLANK_UNBLANK;
		backlight_update_status(p->backlight);
	}

	p->enabled = true;

	return 0;
}

static int myir_panel_get_modes(struct drm_panel *panel)
{
	struct myir_panel *p = to_myir_panel(panel);

	/* add hard-coded panel modes */
	return myir_panel_get_fixed_modes(p);
}

static int myir_panel_get_timings(struct drm_panel *panel,
				    unsigned int num_timings,
				    struct display_timing *timings)
{
	struct myir_panel *p = to_myir_panel(panel);
	unsigned int i;

	if (p->desc->num_timings < num_timings)
		num_timings = p->desc->num_timings;

	if (timings)
		for (i = 0; i < num_timings; i++)
			timings[i] = p->desc->timings[i];

	return p->desc->num_timings;
}

static const struct drm_panel_funcs myir_panel_funcs = {
	.disable = myir_panel_disable,
	.unprepare = myir_panel_unprepare,
	.prepare = myir_panel_prepare,
	.enable = myir_panel_enable,
	.get_modes = myir_panel_get_modes,
	.get_timings = myir_panel_get_timings,
};

static int myir_panel_probe(struct device *dev,
					const struct myir_panel_desc *desc)
{
	struct device_node *backlight;
	struct myir_panel *panel;
	int err;

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

	panel->enabled = false;
	panel->prepared = false;
	panel->desc = desc;
/*
	panel->dvdd = devm_regulator_get(dev, "dvdd");
	if (IS_ERR(panel->dvdd))
		return PTR_ERR(panel->dvdd);

	panel->avdd = devm_regulator_get(dev, "avdd");
	if (IS_ERR(panel->avdd))
		return PTR_ERR(panel->avdd);

	backlight = of_parse_phandle(dev->of_node, "backlight", 0);
	if (backlight) {
		panel->backlight = of_find_backlight_by_node(backlight);
		of_node_put(backlight);

		if (!panel->backlight)
			return -EPROBE_DEFER;
	}
*/
	drm_panel_init(&panel->base);
	panel->base.dev = dev;
	panel->base.funcs = &myir_panel_funcs;
    
   
	err = drm_panel_add(&panel->base);
	if (err < 0){
		return err;
    }


	dev_set_drvdata(dev, panel);

	return 0;
}

static int myir_panel_remove(struct platform_device *pdev)
{
	struct myir_panel *panel = dev_get_drvdata(&pdev->dev);

	drm_panel_remove(&panel->base);

	myir_panel_disable(&panel->base);

	if (panel->backlight)
		put_device(&panel->backlight->dev);

	return 0;
}

static void myir_panel_shutdown(struct platform_device *pdev)
{
	struct myir_panel *panel = dev_get_drvdata(&pdev->dev);

	myir_panel_disable(&panel->base);
}

static const struct display_timing myir_070tft_timing = {
/*	.pixelclock = { 33300000, 33300000, 33300000 },
	.hactive = { 800, 800, 800 },
	.hfront_porch = {  210, 210, 210 },
	.hback_porch = { 46, 46, 46 },
	.hsync_len = { 40, 40, 40 },

	.vactive = { 480, 480, 480 },
	.vfront_porch = { 22, 22, 22 },
	.vback_porch = { 23, 23, 23 },
	.vsync_len = { 1, 1, 1 },
*/

   // 100ask

        .pixelclock = {50000000,50000000,50000000},
        .hactive = {1024,1024,1024},
        .hfront_porch = {160,160,160},
        .hback_porch = {140,140,140},
        .hsync_len = {20,20,20},
        .vactive = {600,600,600},
        .vfront_porch = {12,12,12},
        .vback_porch = {20,20,20},
        .vsync_len = {3,3,3},
	//.flags = DISPLAY_FLAGS_DE_LOW,


};

static const struct myir_panel_desc myir_070tft = {
	.timings = &myir_070tft_timing,
	.num_timings = 1,
	.bpc = 6,
	.size = {
		.width = 154,
		.height = 86,

	},
	.bus_format = MEDIA_BUS_FMT_RGB888_1X24,
	//.bus_flags = DRM_BUS_FLAG_DE_HIGH | DRM_BUS_FLAG_PIXDATA_POSEDGE,

};

static const struct of_device_id platform_of_match[] = {
	{
		.compatible = "myir,070tft",
		.data = &myir_070tft,
	}, {
		/* sentinel */
	}
};
MODULE_DEVICE_TABLE(of, platform_of_match);

static int myir_panel_platform_probe(struct platform_device *pdev)
{
	const struct of_device_id *id;

	id = of_match_node(platform_of_match, pdev->dev.of_node);
	if (!id)
		return -ENODEV;

	return myir_panel_probe(&pdev->dev, id->data);
}

static struct platform_driver myir_panel_platform_driver = {
	.driver = {
		.name = "myir_panel",
		.of_match_table = platform_of_match,
	},
	.probe = myir_panel_platform_probe,
	.remove = myir_panel_remove,
	.shutdown = myir_panel_shutdown,
};
module_platform_driver(myir_panel_platform_driver);

MODULE_AUTHOR("licy");
MODULE_DESCRIPTION("myir 070-tft panel driver");
MODULE_LICENSE("GPL v2");

修改drivers/gpu/drm/panel/Kconfig添加配置信息

config DRM_PANEL_MYIR070TFT
    tristate "DRM_PANEL_MYIR070TFT panel"
    depends on OF
    select VIDEOMODE_HELPERS
    help
        Say Y here if you want to enable support for RGB video mode
        The panel has a 800x480 resolution and uses

修改drivers/gpu/drm/panel/Makefile，根据配置来编译我们的驱动

obj-$(CONFIG_DRM_PANEL_MYIR070TFT) += panel-myir070tft.o

使用make menuconfig来配置我们的LCD驱动
重新编译内核

报错了

drivers/gpu/drm/panel/panel-myir070tft.c:62:48: error: 'struct drm_panel' has no member named 'connector';
drivers/gpu/drm/panel/panel-myir070tft.c:99:32: error: 'const struct drm_display_mode' has no member named 'vrefresh'

第一个问题，首先找到这个结构体，是在include/drm/drm_panel.h:150里面定义的

第二个问题，把引用vrefresh修改成drm_mode_vrefresh(m)

还有一些其他地方的修改，这里不一一列举，后面会给出完整的驱动代码。

修改drivers/video/fbdev/core/fbmem.c

参考

最后参考正点原子的教程配置内核编译157的ltdc驱动，最后启动可以看到屏幕上有启动log日志

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值