OpenHarmony4.0适配LVDS屏幕驱动

1.概述

手头有一块RK3568的开发板OK3568-C，但是还没有适配OpenHarmony，用的还是LVDS屏幕，但是官方和网上好像还没有OpenHarmony4.0的LVDS屏幕驱动的通用实现，所以决定尝试了一下适配该开发板，完成LVDS屏幕驱动的适配，点亮屏幕。
源代码：oh4.0-lvds-ok3568-c

2.具体实现

2.1 添加ok3568产品（非必须，可以跳过，直接修改原有的rk3568产品）

因为OK3568-C开发板使用的是RK3568芯片，和OpenHarmony的主线分支一样，所以添加ok3568产品的基础流程比较简单，就是复制device和vendor下面rk3568的文件夹，改为ok3568，并加入ok3568对应的设备树文件，修改build文件下面的编译配置文件（不修改编译会报错），具体流程可以参考官方和网上的其他教程。

本次使用的LVDS屏幕对应的设备树节点如下：
OK3568-common.dtsi
在这里插入图片描述

2.2 分析原有的MIPI屏幕驱动

参考鸿蒙系统原有的MIPI屏幕驱动目录（drivers/framework/model/display/driver）下面的ili9881_st_5p5.c和hdf_drm_panel.c：
在这里插入图片描述
在这里插入图片描述

可以看出鸿蒙原有的MIPI屏幕驱动实际上参考了Linux内核的drivers/gpu/drm/panel/panel-simple.c的“simple-panel-dsi”部分，不知道为什么官方没有把panel-simple.c中剩下的“simple-panel”部分加进去。而“simple-panel”剩余的部分就是LVDS和EDP这类屏幕通用的驱动。

2.3 实现LVDS屏幕驱动

这里我们也参考Linux内核的drivers/gpu/drm/panel/panel-simple.c

2.3.1 读取设备树里面的"simple-panel"节点，获取Panel的参数

添加如下两个文件：
panel_simple_common.h

/*** HDF is dual licensed: you can use it either under the terms of* the GPL, or the BSD license, at your option.* See the LICENSE file in the root of this repository for complete details.*/#ifndef PANEL_SIMPLE_COMMON_H
#define PANEL_SIMPLE_COMMON_H#include <linux/backlight.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/regulator/consumer.h>
#include <linux/gpio/consumer.h>#include <video/display_timing.h>
#include <video/mipi_display.h>
#include <video/of_display_timing.h>
#include <video/videomode.h>#include <drm/drm_modes.h>
#include <drm/drm_panel.h>#include <uapi/drm/drm_mode.h>#include "securec.h"#include "hdf_disp.h"
#include "hdf_drm_panel_simple.h"#endif  /* PANEL_SIMPLE_COMMON_H */

panel_simple_common.c

/*** HDF is dual licensed: you can use it either under the terms of* the GPL, or the BSD license, at your option.* See the LICENSE file in the root of this repository for complete details.*/#include "panel_simple_common.h"
#include "gpio_if.h"
#include "hdf_bl.h"
#include "hdf_disp.h"
#include "osal.h"static inline struct panel_simple *to_panel_simple(const struct drm_panel *panel)
{return container_of(panel, struct panel_simple, panel);
}static inline struct panel_simple *to_panel_simple_by_data(const struct PanelData *panel_data)
{return container_of(panel_data, struct panel_simple, panel_data);
}static int panel_simple_parse_cmd_seq(struct device *dev,const u8 *data, int length,struct panel_cmd_seq *seq)
{struct panel_cmd_header *header;struct panel_cmd_desc *desc;char *buf, *d;unsigned int i, cnt, len;if (!seq)return -EINVAL;buf = (u8 *)OsalMemCalloc(length);if (!buf)return -ENOMEM;memcpy_s(buf, length, data, length);d = buf;len = length;cnt = 0;while (len > sizeof(*header)) {header = (struct panel_cmd_header *)d;d += sizeof(*header);len -= sizeof(*header);if (header->payload_length > len)return -EINVAL;d += header->payload_length;len -= header->payload_length;cnt++;}if (len)return -EINVAL;seq->cmd_cnt = cnt;seq->cmds = (struct panel_cmd_desc *)OsalMemCalloc(sizeof(*desc));if (!seq->cmds)return -ENOMEM;d = buf;len = length;for (i = 0; i < cnt; i++) {header = (struct panel_cmd_header *)d;len -= sizeof(*header);d += sizeof(*header);desc = &seq->cmds[i];desc->header = *header;desc->payload = d;d += header->payload_length;len -= header->payload_length;}return 0;
}static int32_t panel_simple_regulator_enable(struct panel_simple *p)
{int32_t err;if (p->power_invert) {if (regulator_is_enabled(p->supply) > 0)regulator_disable(p->supply);} else {err = regulator_enable(p->supply);if (err < 0)return err;}return 0;
}static int32_t panel_simple_regulator_disable(struct panel_simple *p)
{int err;if (p->power_invert) {if (!regulator_is_enabled(p->supply)) {err = regulator_enable(p->supply);if (err < 0)return err;}} else {regulator_disable(p->supply);}return 0;
}int panel_simple_loader_protect(struct drm_panel *panel)
{struct panel_simple *p = to_panel_simple(panel);int err;err = panel_simple_regulator_enable(p);if (err < 0) {HDF_LOGE("failed to enable supply: %d\n", err);return err;}p->prepared = true;p->enabled = true;return 0;
}
EXPORT_SYMBOL(panel_simple_loader_protect);static int panel_simple_get_hpd_gpio(struct device *dev,struct panel_simple *p, bool from_probe)
{int err;p->hpd_gpio = devm_gpiod_get_optional(dev, "hpd", GPIOD_IN);if (IS_ERR(p->hpd_gpio)) {err = PTR_ERR(p->hpd_gpio);/** If we're called from probe we won't consider '-EPROBE_DEFER'* to be an error--we'll leave the error code in "hpd_gpio".* When we try to use it we'll try again.  This allows for* circular dependencies where the component providing the* hpd gpio needs the panel to init before probing.*/if (err != -EPROBE_DEFER || !from_probe) {HDF_LOGE("failed to get 'hpd' GPIO: %d\n", err);return err;}}return 0;
}#define PANEL_SIMPLE_BOUNDS_CHECK(to_check, bounds, field) \(to_check->field.typ >= bounds->field.min && \to_check->field.typ <= bounds->field.max)
static void panel_simple_parse_panel_timing_node(struct device *dev,struct panel_simple *panel,const struct display_timing *ot)
{const struct panel_desc *desc = panel->desc;struct videomode vm;unsigned int i;if (WARN_ON(desc->num_modes)) {HDF_LOGE("Reject override mode: panel has a fixed mode\n");return;}if (WARN_ON(!desc->num_timings)) {HDF_LOGE("Reject override mode: no timings specified\n");return;}for (i = 0; i < panel->desc->num_timings; i++) {const struct display_timing *dt = &panel->desc->timings[i];if (!PANEL_SIMPLE_BOUNDS_CHECK(ot, dt, hactive) ||!PANEL_SIMPLE_BOUNDS_CHECK(ot, dt, hfront_porch) ||!PANEL_SIMPLE_BOUNDS_CHECK(ot, dt, hback_porch) ||!PANEL_SIMPLE_BOUNDS_CHECK(ot, dt, hsync_len) ||!PANEL_SIMPLE_BOUNDS_CHECK(ot, dt, vactive) ||!PANEL_SIMPLE_BOUNDS_CHECK(ot, dt, vfront_porch) ||!PANEL_SIMPLE_BOUNDS_CHECK(ot, dt, vback_porch) ||!PANEL_SIMPLE_BOUNDS_CHECK(ot, dt, vsync_len))continue;if (ot->flags != dt->flags)continue;videomode_from_timing(ot, &vm);drm_display_mode_from_videomode(&vm, &panel->override_mode);panel->override_mode.type |= DRM_MODE_TYPE_DRIVER |DRM_MODE_TYPE_PREFERRED;break;}if (WARN_ON(!panel->override_mode.type))HDF_LOGE("Reject override mode: No display_timing found\n");
}static int32_t PanelOn(struct PanelData *data)
{struct panel_simple *p = to_panel_simple_by_data(data);if (p->enabled)return HDF_SUCCESS;if (p->desc->delay.enable)OsalMSleep(p->desc->delay.enable);p->enabled = true;return HDF_SUCCESS;
}static int32_t PanelOff(struct PanelData *data)
{struct panel_simple *simplePanel = NULL;simplePanel = to_panel_simple_by_data(data);if (simplePanel->desc->delay.disable) {OsalMSleep(simplePanel->desc->delay.disable);}return HDF_SUCCESS;
}static int32_t PanelPrepare(struct PanelData *data)
{struct panel_simple *p = to_panel_simple_by_data(data);unsigned int delay;int err;int hpd_asserted;if (p->prepared)return HDF_SUCCESS;err = panel_simple_regulator_enable(p);if (err < 0) {HDF_LOGE("failed to enable supply: %d\n", err);return err;}gpiod_direction_output(p->enable_gpio, 1);if (p->desc->delay.reset)OsalMSleep(p->desc->delay.reset);gpiod_direction_output(p->reset_gpio, 1);if (p->desc->delay.reset)OsalMSleep(p->desc->delay.reset);gpiod_direction_output(p->reset_gpio, 0);delay = p->desc->delay.prepare;if (p->no_hpd)delay += p->desc->delay.hpd_absent_delay;if (delay)OsalMSleep(delay);// if (p->hpd_gpio) {// 	if (IS_ERR(p->hpd_gpio)) {// 		err = panel_simple_get_hpd_gpio(panel->dev, p, false);// 		if (err)// 			return err;// 	}// 	err = readx_poll_timeout(gpiod_get_value_cansleep, p->hpd_gpio,// 				 hpd_asserted, hpd_asserted,// 				 1000, 2000000);// 	if (hpd_asserted < 0)// 		err = hpd_asserted;// 	if (err) {// 		HDF_LOGE("error waiting for hpd GPIO: %d\n", err);// 		return err;// 	}// }// if (p->desc->init_seq)// 	if (p->dsi)// 		panel_simple_xfer_dsi_cmd_seq(p, p->desc->init_seq);if (p->desc->delay.init)OsalMSleep(p->desc->delay.init);p->prepared = true;return HDF_SUCCESS;
}static int32_t PanelUnprepare(struct PanelData *data)
{int32_t ret;struct panel_simple *p = NULL;p = to_panel_simple_by_data(data);if (!p->prepared)return HDF_SUCCESS;gpiod_direction_output(p->reset_gpio, 1);gpiod_direction_output(p->enable_gpio, 0);panel_simple_regulator_disable(p);if (p->desc->delay.unprepare) {OsalMSleep(p->desc->delay.unprepare);}return HDF_SUCCESS;
}static int32_t PanelInit(struct PanelData *panel)
{return 0;
}static int32_t panel_simple_probe(struct device *dev, struct panel_simple *panel)
{const struct panel_desc *desc = panel->desc;struct display_timing dt;int connector_type;u32 bus_flags;int32_t err;panel->no_hpd = of_property_read_bool(dev->of_node, "no-hpd");if (!panel->no_hpd) {err = panel_simple_get_hpd_gpio(dev, panel, true);if (err){HDF_LOGE("%s Get hpd gpio fail %d", __func__, err);goto FAIL;}}panel->supply = devm_regulator_get(dev, "power");if (IS_ERR(panel->supply)) {HDF_LOGE("%s Get regulator fail %d", __func__, PTR_ERR(panel->supply));goto FAIL;}panel->enable_gpio = devm_gpiod_get_optional(dev, "enable", GPIOD_ASIS);if (IS_ERR(panel->enable_gpio)) {HDF_LOGE("%s get enable_gpio fail %d", __func__, PTR_ERR(panel->enable_gpio));goto FAIL;}panel->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_ASIS);if (IS_ERR(panel->reset_gpio)) {HDF_LOGE("get reset_gpio fail %d", __func__, PTR_ERR(panel->reset_gpio));goto FAIL;}if (!of_get_display_timing(dev->of_node, "panel-timing", &dt))panel_simple_parse_panel_timing_node(dev, panel, &dt);connector_type = desc->connector_type;/* Catch common mistakes for panels. */switch (connector_type) {case 0:HDF_LOGD("Specify missing connector_type\n");connector_type = DRM_MODE_CONNECTOR_DPI;break;case DRM_MODE_CONNECTOR_LVDS:WARN_ON(desc->bus_flags &~(DRM_BUS_FLAG_DE_LOW |DRM_BUS_FLAG_DE_HIGH |DRM_BUS_FLAG_DATA_MSB_TO_LSB |DRM_BUS_FLAG_DATA_LSB_TO_MSB));WARN_ON(desc->bus_format != MEDIA_BUS_FMT_RGB666_1X7X3_SPWG &&desc->bus_format != MEDIA_BUS_FMT_RGB888_1X7X4_SPWG &&desc->bus_format != MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA);WARN_ON(desc->bus_format == MEDIA_BUS_FMT_RGB666_1X7X3_SPWG &&desc->bpc != 6);WARN_ON((desc->bus_format == MEDIA_BUS_FMT_RGB888_1X7X4_SPWG ||desc->bus_format == MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA) &&desc->bpc != 8);break;case DRM_MODE_CONNECTOR_eDP:if (desc->bus_format == 0)HDF_LOGW("Specify missing bus_format\n");if (desc->bpc != 6 && desc->bpc != 8)HDF_LOGW("Expected bpc in {6,8} but got: %u\n", desc->bpc);break;case DRM_MODE_CONNECTOR_DSI:if (desc->bpc != 6 && desc->bpc != 8)HDF_LOGW("Expected bpc in {6,8} but got: %u\n", desc->bpc);break;case DRM_MODE_CONNECTOR_DPI:bus_flags = DRM_BUS_FLAG_DE_LOW |DRM_BUS_FLAG_DE_HIGH |DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE |DRM_BUS_FLAG_PIXDATA_SAMPLE_NEGEDGE |DRM_BUS_FLAG_DATA_MSB_TO_LSB |DRM_BUS_FLAG_DATA_LSB_TO_MSB |DRM_BUS_FLAG_SYNC_SAMPLE_POSEDGE |DRM_BUS_FLAG_SYNC_SAMPLE_NEGEDGE;if (desc->bus_flags & ~bus_flags)HDF_LOGW("Unexpected bus_flags(%d)\n", desc->bus_flags & ~bus_flags);if (!(desc->bus_flags & bus_flags))HDF_LOGW("Specify missing bus_flags\n");if (desc->bus_format == 0)HDF_LOGW("Specify missing bus_format\n");if (desc->bpc != 6 && desc->bpc != 8)HDF_LOGW("Expected bpc in {6,8} but got: %u\n", desc->bpc);break;default:HDF_LOGW("Specify a valid connector_type: %d\n", desc->connector_type);connector_type = DRM_MODE_CONNECTOR_DPI;break;}HDF_LOGI("%s success", __func__);return HDF_SUCCESS;
FAIL:return HDF_FAILURE;
}static bool of_child_node_is_present(const struct device_node *node,const char *name)
{struct device_node *child;child = of_get_child_by_name(node, name);of_node_put(child);return !!child;
}static int panel_simple_of_get_desc_data(struct device *dev,struct panel_desc *desc)
{struct device_node *np = dev->of_node;u32 bus_flags;const void *data;int len;int err;if (of_child_node_is_present(np, "display-timings")) {struct drm_display_mode *mode;mode = (struct drm_display_mode *)OsalMemCalloc(sizeof(*mode));if (!mode)return -ENOMEM;err = of_get_drm_display_mode(np, mode, &bus_flags,OF_USE_NATIVE_MODE);if (!err) {desc->modes = mode;desc->num_modes = 1;desc->bus_flags = bus_flags;}} else if (of_child_node_is_present(np, "panel-timing")) {struct display_timing *timing;struct videomode vm;timing = (struct display_timing *)OsalMemCalloc(sizeof(*timing));if (!timing)return -ENOMEM;if (!of_get_display_timing(np, "panel-timing", timing)) {desc->timings = timing;desc->num_timings = 1;bus_flags = 0;vm.flags = timing->flags;drm_bus_flags_from_videomode(&vm, &bus_flags);desc->bus_flags = bus_flags;}}if (desc->num_modes || desc->num_timings) {of_property_read_u32(np, "bpc", &desc->bpc);of_property_read_u32(np, "bus-format", &desc->bus_format);of_property_read_u32(np, "width-mm", &desc->size.width);of_property_read_u32(np, "height-mm", &desc->size.height);}of_property_read_u32(np, "prepare-delay-ms", &desc->delay.prepare);of_property_read_u32(np, "enable-delay-ms", &desc->delay.enable);of_property_read_u32(np, "disable-delay-ms", &desc->delay.disable);of_property_read_u32(np, "unprepare-delay-ms", &desc->delay.unprepare);of_property_read_u32(np, "reset-delay-ms", &desc->delay.reset);of_property_read_u32(np, "init-delay-ms", &desc->delay.init);data = of_get_property(np, "panel-init-sequence", &len);if (data) {desc->init_seq = (struct panel_cmd_seq *)OsalMemCalloc(sizeof(*desc->init_seq));if (!desc->init_seq)return -ENOMEM;err = panel_simple_parse_cmd_seq(dev, data, len,desc->init_seq);if (err) {HDF_LOGE("failed to parse init sequence\n");return err;}}data = of_get_property(np, "panel-exit-sequence", &len);if (data) {desc->exit_seq = (struct panel_cmd_seq *)OsalMemCalloc(sizeof(*desc->exit_seq));if (!desc->exit_seq)return -ENOMEM;err = panel_simple_parse_cmd_seq(dev, data, len,desc->exit_seq);if (err) {HDF_LOGE("failed to parse exit sequence\n");return err;}}return 0;
}#define BLK_PWM_INDEX             2
#define PWM_MAX_PERIOD            40000
/* backlight setting */
#define MIN_LEVEL                 0
#define MAX_LEVEL                 255
#define DEFAULT_LEVEL             127static struct PanelInfo g_panelInfo = {.width = 720,          /* width */.height = 1280,          /* height */.hbp = 40,             /* horizontal back porch */.hfp = 40,         /* horizontal front porch */.hsw = 10,              /* horizontal sync width */.vbp = 15,              /* vertical back porch */.vfp = 10,              /* vertical front porch */.vsw = 36,               /* vertical sync width */.clockFreq = 75000000,  /* clock */.pWidth = 68,           /* physical width */.pHeight = 121,         /* physical height */.connectorType = DRM_MODE_CONNECTOR_DPI,   /* DRM_MODE_CONNECTOR_DPI=17 */.blk = { BLK_PWM, MIN_LEVEL, MAX_LEVEL, DEFAULT_LEVEL },
};static void PanelDataInit(struct panel_simple *panel, struct HdfDeviceObject *object)
{struct PanelData *panel_data = &panel->panel_data;panel_data->object = object;panel_data->init = PanelInit;panel_data->on = PanelOn;panel_data->off = PanelOff;panel_data->prepare = PanelPrepare;panel_data->unprepare = PanelUnprepare;panel_data->info = &g_panelInfo;panel_data->priv = panel;
}static int32_t PanelEntryInit(struct HdfDeviceObject *object)
{struct device_node *panelNode = NULL;struct platform_device *pdev = NULL;struct panel_simple *simplePanel = NULL;struct panel_desc *desc = NULL;int err;bool hasPanel = false;HDF_LOGI("PanelEntryInit");while((panelNode = of_find_compatible_node(panelNode, NULL, "simple-panel")) != NULL){hasPanel = true;pdev = of_find_device_by_node(panelNode);if (pdev == NULL) {HDF_LOGE("%s of_find_device_by_node fail", __func__);goto FAIL;}desc = (struct panel_desc *)OsalMemCalloc(sizeof(*desc));if (desc == NULL) {HDF_LOGE("%s panel_desc malloc fail", __func__);goto FAIL;}err = panel_simple_of_get_desc_data(&pdev->dev, desc);if (err) {HDF_LOGE("%s failed to get desc data: %d\n", __func__, err);goto FAIL;}simplePanel = (struct panel_simple *)OsalMemCalloc(sizeof(struct panel_simple));if (simplePanel == NULL) {HDF_LOGE("%s simplePanel malloc fail", __func__);goto FAIL;}simplePanel->desc = desc;simplePanel->panel.dev = &pdev->dev;err = panel_simple_probe(&pdev->dev, simplePanel);if (err) {HDF_LOGE("%s failed to panel_simple_probe: %d\n", __func__, err);goto FAIL;}PanelDataInit(simplePanel, object);if (RegisterPanel(&simplePanel->panel_data) != HDF_SUCCESS) {HDF_LOGE("RegisterPanel fail");goto FAIL;}of_node_put(panelNode);}if (!hasPanel) {HDF_LOGE("%s panel simple not found!!!", __func__);goto FAIL;}HDF_LOGI("%s success", __func__);return HDF_SUCCESS;
FAIL:OsalMemFree(desc);OsalMemFree(simplePanel);of_node_put(panelNode);return HDF_FAILURE;
}struct HdfDriverEntry g_commonPanelSimpleDevEntry = {.moduleVersion = 1,.moduleName = "PANEL_SIMPLE_COMMON",.Init = PanelEntryInit,
};HDF_INIT(g_commonPanelSimpleDevEntry);

2.3.2 在DRM显示框架中注册上一步获取到的Panel对象

添加如下两个文件：
hdf_drm_panel_simple.h

/** Copyright (c) 2020-2021 Huawei Device Co., Ltd.** HDF is dual licensed: you can use it either under the terms of* the GPL, or the BSD license, at your option.* See the LICENSE file in the root of this repository for complete details.*/#ifndef HDF_DRM_PANEL_SIMPLE_H
#define HDF_DRM_PANEL_SIMPLE_H
#include <linux/of_platform.h>
#include <linux/platform_device.h>#include <video/display_timing.h>
#include <video/mipi_display.h>
#include <video/of_display_timing.h>
#include <video/videomode.h>#include <drm/drm_crtc.h>
#include <drm/drm_device.h>
#include <drm/drm_mipi_dsi.h>
#include <drm/drm_panel.h>
#include <drm/drm_dsc.h>#include "hdf_disp.h"
#include "hdf_bl.h"struct panel_cmd_header {u8 data_type;u8 delay;u8 payload_length;
} __packed;struct panel_cmd_desc {struct panel_cmd_header header;u8 *payload;
};struct panel_cmd_seq {struct panel_cmd_desc *cmds;unsigned int cmd_cnt;
};/*** @modes: Pointer to array of fixed modes appropriate for this panel.  If*         only one mode then this can just be the address of this the mode.*         NOTE: cannot be used with "timings" and also if this is specified*         then you cannot override the mode in the device tree.* @num_modes: Number of elements in modes array.* @timings: Pointer to array of display timings.  NOTE: cannot be used with*           "modes" and also these will be used to validate a device tree*           override if one is present.* @num_timings: Number of elements in timings array.* @bpc: Bits per color.* @size: Structure containing the physical size of this panel.* @delay: Structure containing various delay values for this panel.* @bus_format: See MEDIA_BUS_FMT_... defines.* @bus_flags: See DRM_BUS_FLAG_... defines.*/
struct 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;/*** @prepare: the time (in milliseconds) that it takes for the panel to*           become ready and start receiving video data* @hpd_absent_delay: Add this to the prepare delay if we know Hot*                    Plug Detect isn't used.* @enable: the time (in milliseconds) that it takes for the panel to*          display the first valid frame after starting to receive*          video data* @disable: the time (in milliseconds) that it takes for the panel to*           turn the display off (no content is visible)* @unprepare: the time (in milliseconds) that it takes for the panel*             to power itself down completely* @reset: the time (in milliseconds) that it takes for the panel*         to reset itself completely* @init: the time (in milliseconds) that it takes for the panel to*	  send init command sequence after reset deassert*/struct {unsigned int prepare;unsigned int hpd_absent_delay;unsigned int enable;unsigned int disable;unsigned int unprepare;unsigned int reset;unsigned int init;} delay;u32 bus_format;u32 bus_flags;int connector_type;struct panel_cmd_seq *init_seq;struct panel_cmd_seq *exit_seq;
};struct panel_simple {struct drm_panel panel;struct mipi_dsi_device *dsi;bool prepared;bool enabled;bool power_invert;bool no_hpd;const struct panel_desc *desc;struct regulator *supply;struct gpio_desc *enable_gpio;struct gpio_desc *reset_gpio;struct gpio_desc *hpd_gpio;struct drm_display_mode override_mode;enum drm_panel_orientation orientation;struct PanelData panel_data;uint32_t index;struct DispManager *manager;
};#endif /* HDF_DRM_PANEL_SIMPLE_H */

hdf_drm_panel_simple.c

/*** HDF is dual licensed: you can use it either under the terms of* the GPL, or the BSD license, at your option.* See the LICENSE file in the root of this repository for complete details.*/#include "hdf_drm_panel_simple.h"
#include <drm/drm_device.h>
#include <drm/drm_atomic_helper.h>
#include <linux/backlight.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/pm_runtime.h>
#include <linux/regulator/consumer.h>
#include <video/mipi_display.h>
#include <video/of_display_timing.h>
#include <video/videomode.h>
#include <uapi/drm/drm_mode.h>
#include "osal_mem.h"
#include "osal.h"static inline struct panel_simple *to_panel_simple(const struct drm_panel *panel)
{return container_of(panel, struct panel_simple, panel);
}static int HdfDrmPanelSimpleUnprepare(struct drm_panel *panel)
{struct panel_simple *simpePanel = to_panel_simple(panel);struct PanelData *panelData;struct DispManager *manager = GetDispManager();HDF_LOGD("HdfDrmPanelSimpleUnprepare");if (simpePanel->index >= PANEL_MAX) {HDF_LOGE("panel num out of PANEL_MAX");return HDF_FAILURE;}OsalMutexLock(&manager->dispMutex);panelData = manager->panelManager->panel[simpePanel->index];panelData->unprepare(panelData);OsalMutexUnlock(&manager->dispMutex);return HDF_SUCCESS;
}static int HdfDrmPanelSimplePrepare(struct drm_panel *panel)
{struct panel_simple *simpePanel = to_panel_simple(panel);struct PanelData *panelData;struct DispManager *manager = GetDispManager();HDF_LOGD("HdfDrmPanelSimplePrepare");if (simpePanel->index >= PANEL_MAX) {HDF_LOGE("panel num out of PANEL_MAX");return HDF_FAILURE;}OsalMutexLock(&manager->dispMutex);panelData = manager->panelManager->panel[simpePanel->index];panelData->prepare(panelData);OsalMutexUnlock(&manager->dispMutex);return HDF_SUCCESS;
}static int HdfDrmPanelSimpleDisable(struct drm_panel *panel)
{struct panel_simple *simpePanel = to_panel_simple(panel);struct PanelData *panelData;struct DispManager *manager = GetDispManager();HDF_LOGD("HdfDrmPanelSimpleDisable");if (simpePanel->index >= PANEL_MAX) {HDF_LOGE("panel num out of PANEL_MAX");return HDF_FAILURE;}OsalMutexLock(&manager->dispMutex);panelData = manager->panelManager->panel[simpePanel->index];panelData->off(panelData);OsalMutexUnlock(&manager->dispMutex);return HDF_SUCCESS;
}static int HdfDrmPanelSimpleEnable(struct drm_panel *panel)
{struct panel_simple *simpePanel = to_panel_simple(panel);struct PanelData *panelData;struct DispManager *manager = GetDispManager();HDF_LOGD("HdfDrmPanelSimpleEnable");if (simpePanel->index >= PANEL_MAX) {HDF_LOGE("panel num out of PANEL_MAX");return HDF_FAILURE;}panelData = manager->panelManager->panel[simpePanel->index];OsalMutexLock(&manager->dispMutex);panelData->on(panelData);OsalMutexUnlock(&manager->dispMutex);return HDF_SUCCESS;
}#define MIN_LEVEL                 0
#define MAX_LEVEL                 255
#define DEFAULT_LEVEL             100static int32_t SetPanelInfo(struct panel_simple *simplePanel, struct drm_display_mode *mode)
{HDF_LOGI("SetPanelInfo enter");struct PanelData *panel = &simplePanel->panel_data;panel->info->clockFreq = mode->clock * 1000;panel->info->width = mode->hdisplay;panel->info->height = mode->vdisplay;panel->info->hbp = mode->htotal - mode->hsync_end;panel->info->hfp = mode->hsync_start - mode->hdisplay;panel->info->hsw = mode->hsync_end - mode->hsync_start;panel->info->vbp = mode->vtotal - mode->vsync_end;panel->info->vfp = mode->vsync_start - mode->vdisplay;panel->info->vsw = mode->vsync_end - mode->vsync_start;// panel->info->intfType = LCD_24BIT;// panel->info->intfSync = 0;// panel->info->frameRate = 0;panel->info->blk.type = BLK_PWM;panel->info->blk.minLevel = MIN_LEVEL;panel->info->blk.maxLevel = MAX_LEVEL;panel->info->blk.defLevel = DEFAULT_LEVEL;return HDF_SUCCESS;
}static unsigned int panel_simple_get_timings_modes(struct panel_simple *panel,struct drm_connector *connector)
{struct drm_display_mode *mode;unsigned int i, num = 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(connector->dev);if (!mode) {HDF_LOGE("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++;HDF_LOGI("panel_simple_get_timings_modes SetPanelInfo:%d", i);SetPanelInfo(panel, mode);}return num;
}static unsigned int panel_simple_get_display_modes(struct panel_simple *panel,struct drm_connector *connector)
{struct drm_display_mode *mode;unsigned int i, num = 0;HDF_LOGI("panel_simple_get_display_modes enter");for (i = 0; i < panel->desc->num_modes; i++) {const struct drm_display_mode *m = &panel->desc->modes[i];mode = drm_mode_duplicate(connector->dev, m);if (!mode) {HDF_LOGE("failed to add mode %ux%u@%u\n",m->hdisplay, m->vdisplay,drm_mode_vrefresh(m));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++;HDF_LOGI("panel_simple_get_display_modes SetPanelInfo:%d num:%d", i, num);SetPanelInfo(panel, mode);}return num;
}static int panel_simple_get_non_edid_modes(struct panel_simple *panel,struct drm_connector *connector)
{struct drm_display_mode *mode;bool has_override = panel->override_mode.type;unsigned int num = 0;if (!panel->desc)return 0;if (has_override) {mode = drm_mode_duplicate(connector->dev,&panel->override_mode);if (mode) {drm_mode_probed_add(connector, mode);num = 1;HDF_LOGI("panel_simple_get_non_edid_modes SetPanelInfo");SetPanelInfo(panel, mode);} else {HDF_LOGE("failed to add override mode\n");}}/* Only add timings if override was not there or failed to validate */if (num == 0 && panel->desc->num_timings)num = panel_simple_get_timings_modes(panel, connector);/** Only add fixed modes if timings/override added no mode.** We should only ever have either the display timings specified* or a fixed mode. Anything else is rather bogus.*/WARN_ON(panel->desc->num_timings && panel->desc->num_modes);if (num == 0)num = panel_simple_get_display_modes(panel, connector);if (panel->desc->bpc)connector->display_info.bpc = panel->desc->bpc;if (panel->desc->size.width)connector->display_info.width_mm = panel->desc->size.width;if (panel->desc->size.height)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);if (panel->desc->bus_flags)connector->display_info.bus_flags = panel->desc->bus_flags;return num;
}static int HdfDrmPanelSimpleGetModes(struct drm_panel *panel, struct drm_connector *connector)
{struct panel_simple *p = to_panel_simple(panel);int num = 0;HDF_LOGI("HdfDrmPanelSimpleGetModes");if (panel == NULL) {HDF_LOGE("panel is NULL");return 0;}if (connector == NULL) {HDF_LOGE("connector is NULL");return 0;}// /* probe EDID if a DDC bus is available */// if (p->ddc) {// 	struct edid *edid = drm_get_edid(connector, p->ddc);// 	drm_connector_update_edid_property(connector, edid);// 	if (edid) {// 		num += drm_add_edid_modes(connector, edid);// 		kfree(edid);// 	}// }/* add hard-coded panel modes */num += panel_simple_get_non_edid_modes(p, connector);// /* set up connector's "panel orientation" property */// drm_connector_set_panel_orientation(connector, p->orientation);return num;
}static int HdfDrmPanelSimpleGetTimings(struct drm_panel *panel,unsigned int num_timings,struct display_timing *timings)
{struct panel_simple *p = to_panel_simple(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 struct drm_panel_funcs g_hdfDrmPanelFuncs = {.disable = HdfDrmPanelSimpleDisable,.unprepare = HdfDrmPanelSimpleUnprepare,.prepare = HdfDrmPanelSimplePrepare,.enable = HdfDrmPanelSimpleEnable,.get_modes = HdfDrmPanelSimpleGetModes,.get_timings = HdfDrmPanelSimpleGetTimings,
};static ssize_t SuspendStore(struct device *dev,struct device_attribute *attr, const char *buf, size_t count)
{int32_t ret;struct panel_simple *simpePanel = dev_get_drvdata(dev);ret = HdfDrmPanelSimpleDisable(&simpePanel->panel);if (ret != HDF_SUCCESS) {HDF_LOGE("%s HdfDrmPanelSimpleDisable fail", __func__);return count;}ret = HdfDrmPanelSimpleUnprepare(&simpePanel->panel);if (ret != HDF_SUCCESS) {HDF_LOGE("%s HdfDrmPanelSimpleUnprepare fail", __func__);return count;}return count;
}
static DEVICE_ATTR(suspend, S_IWUSR, NULL, SuspendStore);static ssize_t ResumeStore(struct device *dev,struct device_attribute *attr, const char *buf, size_t count)
{int32_t ret;struct panel_simple *simpePanel = dev_get_drvdata(dev);ret = HdfDrmPanelSimplePrepare(&simpePanel->panel);if (ret != HDF_SUCCESS) {HDF_LOGE("%s HdfDrmPanelSimplePrepare fail", __func__);return count;}ret = HdfDrmPanelSimpleEnable(&simpePanel->panel);if (ret != HDF_SUCCESS) {HDF_LOGE("%s HdfDrmPanelSimpleEnable fail", __func__);return count;}return count;
}
static DEVICE_ATTR(resume, S_IWUSR, NULL, ResumeStore);static ssize_t BacklightStore(struct device *dev,struct device_attribute *attr, const char *buf, size_t count)
{int32_t ret;unsigned long level;struct PanelData *panelData = NULL;struct panel_simple *simpePanel = dev_get_drvdata(dev);struct DispManager *manager = GetDispManager();ret = kstrtoul(buf, 0, &level);if (ret != 0) {return ret;}HDF_LOGI("%s enter", __func__);OsalMutexLock(&manager->dispMutex);panelData = manager->panelManager->panel[simpePanel->index];OsalMutexUnlock(&manager->dispMutex);ret = UpdateBrightness(panelData->blDev, level);if (ret != HDF_SUCCESS) {HDF_LOGE("%s UpdateBrightness fail", __func__);}return count;
}
static DEVICE_ATTR(backlight, S_IWUSR, NULL, BacklightStore);#define ATTR_NUM  3
static struct device_attribute *g_panelAttrs[] = {&dev_attr_suspend,&dev_attr_resume,&dev_attr_backlight,NULL,
};static int32_t HdfDrmPanelSimpleEntryInit(struct HdfDeviceObject *object)
{(void)object;uint32_t ret;uint32_t i;uint32_t j;uint32_t panelNum;struct panel_simple *simplePanel = NULL;struct DispManager *manager = NULL;struct drm_panel *panel = NULL;struct device *dev = NULL;manager = GetDispManager();if (manager == NULL) {HDF_LOGE("%s manager is null", __func__);return HDF_FAILURE;}panelNum = manager->panelManager->panelNum;for (i = 0; i < panelNum; i++) {simplePanel = (struct panel_simple *)manager->panelManager->panel[i]->priv;simplePanel->index = i;panel = &simplePanel->panel;dev = panel->dev;drm_panel_init(panel, dev, &g_hdfDrmPanelFuncs, simplePanel->desc->connector_type);ret = drm_panel_of_backlight(panel);if (ret){HDF_LOGE("%s drm_panel_of_backlight failed %d", __func__, ret);drm_panel_remove(panel);return ret;}drm_panel_add(panel);dev_set_drvdata(dev, simplePanel);for (j = 0; j < ATTR_NUM; j++) {if (device_create_file(dev, g_panelAttrs[j]) != 0) {HDF_LOGE("%s line = %d device_create_file fail", __func__, __LINE__);}}HDF_LOGI("%s panel[%d] registered success", __func__, i);}HDF_LOGI("%s success", __func__);return HDF_SUCCESS;
}struct HdfDriverEntry g_hdfDrmPanelSimpleEntry = {.moduleVersion = 1,.moduleName = "HDF_DRM_PANEL_SIMPLE",.Init = HdfDrmPanelSimpleEntryInit,
};HDF_INIT(g_hdfDrmPanelSimpleEntry);

2.3.3 修改panel驱动的编译配置文件

前两步添加的文件需要加到编译配置文件里面才可以进行编译，如下：
Makefile

在这里插入图片描述

2.3.4 修改device_info驱动配置文件

device_info驱动配置文件原来加载的是MIPI屏幕驱动，这里我们改成加载我们编写的LVDS屏幕驱动，如下：
device_info.hcs
在这里插入图片描述

3. 编译运行

3.1 编译我们修改过的源码

./build.sh --product-name ok3568 --target-cpu arm64

在这里插入图片描述

3.2 烧录镜像文件并运行查看效果

在这里插入图片描述
在这里插入图片描述

4. 可能遇到的问题

4.1 pwm背光调节没有反应

原因： RK3568背光功能默认使用原生pwm驱动，并且pwm路径已经写死了，如下：
在这里插入图片描述
解决办法： 找到设备树里面lvds屏幕所使用的 “pwm-backlight” 节点，修改节点名字为backlight，如下
在这里插入图片描述
或者修改drm_connector.cpp文件中的背光调节功能的文件路径。

5. 参考

标准系统方案之瑞芯微RK3568移植案例

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/409846.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

MongoDB - 库、集合、文档（操作 + 演示 + 注意事项）

MongoDB - 库、集合、文档（操作 + 演示 + 注意事项）

目录 一、MongoDB 1.1、简介 a&#xff09;MongoDB 是什么&#xff1f;为什么要使用 MongoDB&#xff1f; b&#xff09;应用场景 c&#xff09;MongoDB 这么强大&#xff0c;是不是可以直接代替 MySQL &#xff1f; d&#xff09;MongoDB 中的一些概念 e&#xff09;Do…
阅读更多...
meter报OOM错误，如何解决？

meter报OOM错误，如何解决？

根据在之前的压测过程碰到的问题&#xff0c;今天稍微总结总结&#xff0c;以后方便自己查找。 一、单台Mac进行压测时候&#xff0c;压测客户端Jmeter启动超过2000个线程&#xff0c;Jmeter报OOM错误&#xff0c;如何解决&#xff1f; 解答&#xff1a;单台Mac配置内存为8G&…
阅读更多...
ATA-1222A宽带放大器在二极管测试中的应用有哪些

ATA-1222A宽带放大器在二极管测试中的应用有哪些

宽带放大器是一种用于放大高频信号的电子设备&#xff0c;它在二极管测试中有多种应用。下面安泰电子将介绍宽带放大器在二极管测试中的几种常见应用。 宽带放大器可以用于二极管参数测试。二极管是一种常见的半导体器件&#xff0c;有正向电压-电流特性和反向电压-电流特性。为…
阅读更多...
SpringBoot-Starter 自动锁组件

SpringBoot-Starter 自动锁组件

在日常业务开发的过程中&#xff0c;我们经常会遇到存在高并发的场景&#xff0c;这个时候都会选择使用redis来实现一个锁&#xff0c;来防止并发。 但是很多时候&#xff0c;我们可能业务完成后&#xff0c;就需要把锁释放掉&#xff0c;给下一个线程用&#xff0c;但是如果我…
阅读更多...
Python爬虫实战：IP代理池助你突破限制，高效采集数据

Python爬虫实战：IP代理池助你突破限制，高效采集数据

当今互联网环境中&#xff0c;为了应对反爬虫、匿名访问或绕过某些地域限制等需求&#xff0c;IP代理池成为了一种常用的解决方案。IP代理池是一个包含多个可用代理IP地址的集合&#xff0c;可以通过该代理池随机选择可用IP地址来进行网络请求。 IP代理池是一组可用的代理IP地址…
阅读更多...
纯c++简易的迷宫小游戏

纯c++简易的迷宫小游戏

一个用c写的黑框框迷宫 适合新手入门学习 也适合大学生小作业 下面附上代码 总体思路 初始化游戏界面&#xff1a;设置迷宫的大小&#xff08;WIDTH和HEIGH&#xff09;&#xff0c;生成迷宫地图&#xff08;map&#xff09;&#xff0c;包括墙壁、空地、起点和终点。显示…
阅读更多...
Spark与HBase的集成与数据访问

Spark与HBase的集成与数据访问

Apache Spark和Apache HBase分别是大数据处理和分布式NoSQL数据库领域的两个重要工具。在本文中&#xff0c;将深入探讨如何在Spark中集成HBase&#xff0c;并演示如何通过Spark访问和操作HBase中的数据。将提供丰富的示例代码&#xff0c;以便更好地理解这一集成过程。 Spark…
阅读更多...
物联网介绍

物联网介绍

阅读引言&#xff1a; 本文从多方面叙述物联网的定义以及在物联网当中的各种通信的介绍。 一、物联网的定义 1.1 通用的定义 物联网&#xff08;Internet of Things&#xff0c;IOT&#xff1b;也称为Web of Things&#xff09;是指通过各种信息传感设 备&#xff0c;如传感器、…
阅读更多...
STM32 定时器输入捕获2——捕获高电平时长

STM32 定时器输入捕获2——捕获高电平时长

由上图我们可以知道&#xff0c;高电平时间t2-t1。在代码中&#xff0c;可以记录此时t1的时间然后再记录t2的时间&#xff0c;t2-t1&#xff0c;就是我们所想要的答案。 但是&#xff0c;还有更简单一点点的&#xff0c;当到达t1的时候&#xff0c;我们把定时器清零&#xff0c…
阅读更多...
力扣电话号码的组合

力扣电话号码的组合

文章目录 题目说明做题思路代码实现代码解析 题目链接 题目说明 首先我们先分析一下这个题目题目中说呢先给出一个字符串这个字符串其实就是这个九键数字我们要按照要求将数字所代表的字符进行自由组合形成一个字符串并且这个字符串的长度和输入的数字字符串长度相同&#xff0…
阅读更多...
Ansible Filter滤波器的使用（二）

Ansible Filter滤波器的使用（二）

一、【说在前面】 Ansible Filter一般被称为滤波器或者叫过滤器。 这个东西初次听到以为是什么科学计算的东西&#xff0c;但是想来ansible不太可能有什么滤波操作&#xff0c;所以这个东西本质是一个数值筛选器&#xff0c;内置函数&#xff0c;本质是一个为了做区别化的工具…
阅读更多...
【MapReduce】对员工数据按照部门分区并对每个分区排序

【MapReduce】对员工数据按照部门分区并对每个分区排序

员工信息全部存储在emp.csv文件中&#xff0c;员工的属性有&#xff1a;员工id、名称、职位、领导id、雇佣时间、工资、奖金、部门号。 在MapReduce中想要使用员工的信息&#xff0c;需要对员工进行序列化处理。因为MapReduce是一个分布式框架数据会在不同节点之间进行传输&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023