Commit 21b7661e authored by Tushar Khandelwal's avatar Tushar Khandelwal Committed by Patrik
Browse files

drm: Add component-aware simple encoder



This is a simple DRM encoder that gets its connector timings information
from a OF subnode in the device tree and exposes that as a "discovered"
panel. It can be used together with component-based DRM drivers in an
emulated environment where no real encoder or connector hardware exists
and the display output is configured outside the kernel.
Signed-off-by: default avatarTushar Khandelwal <tushar.khandelwal@arm.com>

Upstream-Status: Backport [https://git.linaro.org/landing-teams/working/arm/kernel-release.git/commit/?h=latest-armlt&id=15283f7be4b1e586702551e85b4caf06531ac2fc

]
Signed-off-by: default avatarArunachalam Ganapathy <arunachalam.ganapathy@arm.com>

Cherry-pick from https://git.yoctoproject.org/cgit/cgit.cgi/meta-arm/tree/meta-arm-bsp/recipes-kernel/linux/linux-arm64-ack-5.10/tc/0001-drm-Add-component-aware-simple-encoder.patch?h=36e43a3a21282d67c5e010336fd1619f1c6aaac7
Change-Id: I30dc263c093adcc6fb8100ceb7473691f4a01f62
parent bb7503dc
Pipeline #40227 passed with stages
in 74 minutes and 54 seconds
......@@ -300,6 +300,17 @@ config DRM_VKMS
If M is selected the module will be called vkms.
config DRM_VIRT_ENCODER
tristate "Virtual OF-based encoder"
depends on DRM && OF
select VIDEOMODE_HELPERS
help
Choose this option to get a virtual encoder and its associated
connector that will use the device tree to read the display
timings information. If M is selected the module will be called
drm_vencoder.
source "drivers/gpu/drm/exynos/Kconfig"
source "drivers/gpu/drm/rockchip/Kconfig"
......
......@@ -56,6 +56,8 @@ drm_kms_helper-$(CONFIG_DRM_DP_CEC) += drm_dp_cec.o
obj-$(CONFIG_DRM_KMS_HELPER) += drm_kms_helper.o
obj-$(CONFIG_DRM_DEBUG_SELFTEST) += selftests/
drm_vencoder-y := drm_virtual_encoder.o
obj-$(CONFIG_DRM_VIRT_ENCODER) += drm_vencoder.o
obj-$(CONFIG_DRM) += drm.o
obj-$(CONFIG_DRM_MIPI_DBI) += drm_mipi_dbi.o
......
/*
* Copyright (C) 2016 ARM Limited
* Author: Liviu Dudau <Liviu.Dudau@arm.com>
*
* Dummy encoder and connector that use the OF to "discover" the attached
* display timings. Can be used in situations where the encoder and connector's
* functionality are emulated and no setup steps are needed, or to describe
* attached panels for which no driver exists but can be used without
* additional hardware setup.
*
* The encoder also uses the component framework so that it can be a quick
* replacement for existing drivers when testing in an emulated environment.
*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file COPYING in the main directory of this archive
* for more details.
*
*/
#include <drm/drm_crtc.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_probe_helper.h>
#include <drm/drm_print.h>
#include <linux/platform_device.h>
#include <drm/drm_of.h>
#include <linux/component.h>
#include <video/display_timing.h>
#include <video/of_display_timing.h>
#include <video/videomode.h>
struct drm_virt_priv {
struct drm_connector connector;
struct drm_encoder encoder;
struct display_timings *timings;
};
#define connector_to_drm_virt_priv(x) \
container_of(x, struct drm_virt_priv, connector)
#define encoder_to_drm_virt_priv(x) \
container_of(x, struct drm_virt_priv, encoder)
static void drm_virtcon_destroy(struct drm_connector *connector)
{
struct drm_virt_priv *conn = connector_to_drm_virt_priv(connector);
drm_connector_cleanup(connector);
display_timings_release(conn->timings);
}
static enum drm_connector_status
drm_virtcon_detect(struct drm_connector *connector, bool force)
{
return connector_status_connected;
}
static const struct drm_connector_funcs drm_virtcon_funcs = {
.reset = drm_atomic_helper_connector_reset,
.detect = drm_virtcon_detect,
.fill_modes = drm_helper_probe_single_connector_modes,
.destroy = drm_virtcon_destroy,
.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
};
static int drm_virtcon_get_modes(struct drm_connector *connector)
{
struct drm_virt_priv *conn = connector_to_drm_virt_priv(connector);
struct display_timings *timings = conn->timings;
int i;
for (i = 0; i < timings->num_timings; i++) {
struct drm_display_mode *mode = drm_mode_create(connector->dev);
struct videomode vm;
if (videomode_from_timings(timings, &vm, i))
break;
drm_display_mode_from_videomode(&vm, mode);
mode->type = DRM_MODE_TYPE_DRIVER;
if (timings->native_mode == i)
mode->type = DRM_MODE_TYPE_PREFERRED;
drm_mode_set_name(mode);
drm_mode_probed_add(connector, mode);
}
return i;
}
static int drm_virtcon_mode_valid(struct drm_connector *connector,
struct drm_display_mode *mode)
{
return MODE_OK;
}
struct drm_encoder *drm_virtcon_best_encoder(struct drm_connector *connector)
{
struct drm_virt_priv *priv = connector_to_drm_virt_priv(connector);
return &priv->encoder;
}
struct drm_encoder *
drm_virtcon_atomic_best_encoder(struct drm_connector *connector,
struct drm_connector_state *connector_state)
{
struct drm_virt_priv *priv = connector_to_drm_virt_priv(connector);
return &priv->encoder;
}
static const struct drm_connector_helper_funcs drm_virtcon_helper_funcs = {
.get_modes = drm_virtcon_get_modes,
.mode_valid = drm_virtcon_mode_valid,
.best_encoder = drm_virtcon_best_encoder,
.atomic_best_encoder = drm_virtcon_atomic_best_encoder,
};
static void drm_vencoder_destroy(struct drm_encoder *encoder)
{
drm_encoder_cleanup(encoder);
}
static const struct drm_encoder_funcs drm_vencoder_funcs = {
.destroy = drm_vencoder_destroy,
};
static void drm_vencoder_dpms(struct drm_encoder *encoder, int mode)
{
/* nothing needed */
}
static bool drm_vencoder_mode_fixup(struct drm_encoder *encoder,
const struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode)
{
/* nothing needed */
return true;
}
static void drm_vencoder_prepare(struct drm_encoder *encoder)
{
drm_vencoder_dpms(encoder, DRM_MODE_DPMS_OFF);
}
static void drm_vencoder_commit(struct drm_encoder *encoder)
{
drm_vencoder_dpms(encoder, DRM_MODE_DPMS_ON);
}
static void drm_vencoder_mode_set(struct drm_encoder *encoder,
struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode)
{
/* nothing needed */
}
static const struct drm_encoder_helper_funcs drm_vencoder_helper_funcs = {
.dpms = drm_vencoder_dpms,
.mode_fixup = drm_vencoder_mode_fixup,
.prepare = drm_vencoder_prepare,
.commit = drm_vencoder_commit,
.mode_set = drm_vencoder_mode_set,
};
static int drm_vencoder_bind(struct device *dev, struct device *master,
void *data)
{
struct drm_encoder *encoder;
struct drm_virt_priv *con;
struct drm_connector *connector;
struct drm_device *drm = data;
u32 crtcs = 0;
int ret;
con = devm_kzalloc(dev, sizeof(*con), GFP_KERNEL);
if (!con)
return -ENOMEM;
dev_set_drvdata(dev, con);
connector = &con->connector;
encoder = &con->encoder;
if (dev->of_node) {
struct drm_bridge *bridge;
crtcs = drm_of_find_possible_crtcs(drm, dev->of_node);
bridge = of_drm_find_bridge(dev->of_node);
if (bridge) {
ret = drm_bridge_attach(encoder, bridge, NULL, 0);
if (ret) {
DRM_ERROR("Failed to initialize bridge\n");
return ret;
}
}
con->timings = of_get_display_timings(dev->of_node);
if (!con->timings) {
dev_err(dev, "failed to get display panel timings\n");
return ENXIO;
}
}
/* If no CRTCs were found, fall back to the old encoder's behaviour */
if (crtcs == 0) {
dev_warn(dev, "Falling back to first CRTC\n");
crtcs = 1 << 0;
}
encoder->possible_crtcs = crtcs ? crtcs : 1;
encoder->possible_clones = 0;
ret = drm_encoder_init(drm, encoder, &drm_vencoder_funcs,
DRM_MODE_ENCODER_VIRTUAL, NULL);
if (ret)
goto encoder_init_err;
drm_encoder_helper_add(encoder, &drm_vencoder_helper_funcs);
/* bogus values, pretend we're a 24" screen for DPI calculations */
connector->display_info.width_mm = 519;
connector->display_info.height_mm = 324;
connector->interlace_allowed = false;
connector->doublescan_allowed = false;
connector->polled = 0;
ret = drm_connector_init(drm, connector, &drm_virtcon_funcs,
DRM_MODE_CONNECTOR_VIRTUAL);
if (ret)
goto connector_init_err;
drm_connector_helper_add(connector, &drm_virtcon_helper_funcs);
drm_connector_register(connector);
ret = drm_connector_attach_encoder(connector, encoder);
if (ret)
goto attach_err;
return ret;
attach_err:
drm_connector_unregister(connector);
drm_connector_cleanup(connector);
connector_init_err:
drm_encoder_cleanup(encoder);
encoder_init_err:
display_timings_release(con->timings);
return ret;
};
static void drm_vencoder_unbind(struct device *dev, struct device *master,
void *data)
{
struct drm_virt_priv *con = dev_get_drvdata(dev);
drm_connector_unregister(&con->connector);
drm_connector_cleanup(&con->connector);
drm_encoder_cleanup(&con->encoder);
display_timings_release(con->timings);
}
static const struct component_ops drm_vencoder_ops = {
.bind = drm_vencoder_bind,
.unbind = drm_vencoder_unbind,
};
static int drm_vencoder_probe(struct platform_device *pdev)
{
return component_add(&pdev->dev, &drm_vencoder_ops);
}
static int drm_vencoder_remove(struct platform_device *pdev)
{
component_del(&pdev->dev, &drm_vencoder_ops);
return 0;
}
static const struct of_device_id drm_vencoder_of_match[] = {
{ .compatible = "drm,virtual-encoder", },
{},
};
MODULE_DEVICE_TABLE(of, drm_vencoder_of_match);
static struct platform_driver drm_vencoder_driver = {
.probe = drm_vencoder_probe,
.remove = drm_vencoder_remove,
.driver = {
.name = "drm_vencoder",
.of_match_table = drm_vencoder_of_match,
},
};
module_platform_driver(drm_vencoder_driver);
MODULE_AUTHOR("Liviu Dudau");
MODULE_DESCRIPTION("Virtual DRM Encoder");
MODULE_LICENSE("GPL v2");
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment