2015-10-29 15:36:23 +07:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2015 Free Electrons
|
|
|
|
* Copyright (C) 2015 NextThing Co
|
|
|
|
*
|
|
|
|
* Maxime Ripard <maxime.ripard@free-electrons.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation; either version 2 of
|
|
|
|
* the License, or (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/component.h>
|
drm/sun4i: Implement endpoint parsing using kfifo
The commit da82b8785eeb ("drm/sun4i: add components in breadth first
traversal order") implemented a breadth first traversal of our device tree
nodes graph. However, it was relying on the kernel linked lists, and those
are not really safe for addition.
Indeed, in a single pipeline stage, your first stage (ie, the mixer or
fronted) will be queued, and it will be the final iteration of that list as
far as list_for_each_entry_safe is concerned. Then, during that final
iteration, we'll queue another element (the TCON or the backend) that
list_for_each_entry_safe will not account for, and we will leave the loop
without having iterated over all the elements. And since we won't have
built our components list properly, the DRM driver will be left
non-functional.
We can instead use a kfifo to queue and enqueue components in-order, as was
the original intention. This also has the benefit of removing any dynamic
allocation, making the error handling path simpler too. The only thing
we're losing is the ability to tell whether an element has already been
queued, but that was only needed to remove spurious logs, and therefore
purely cosmetic.
This means that this commit effectively reverses e8afb7b67fba ("drm/sun4i:
don't add components that are already in the queue").
Fixes: da82b8785eeb ("drm/sun4i: add components in breadth first traversal order")
Reviewed-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/4ecb323e787918208f6a5d9f0ebba12c62583c98.1508231063.git-series.maxime.ripard@free-electrons.com
2017-10-17 16:06:08 +07:00
|
|
|
#include <linux/kfifo.h>
|
2015-10-29 15:36:23 +07:00
|
|
|
#include <linux/of_graph.h>
|
2017-02-09 23:39:18 +07:00
|
|
|
#include <linux/of_reserved_mem.h>
|
2015-10-29 15:36:23 +07:00
|
|
|
|
|
|
|
#include <drm/drmP.h>
|
|
|
|
#include <drm/drm_crtc_helper.h>
|
|
|
|
#include <drm/drm_fb_cma_helper.h>
|
|
|
|
#include <drm/drm_gem_cma_helper.h>
|
2016-08-10 23:52:34 +07:00
|
|
|
#include <drm/drm_fb_helper.h>
|
2016-10-19 17:28:27 +07:00
|
|
|
#include <drm/drm_of.h>
|
2015-10-29 15:36:23 +07:00
|
|
|
|
|
|
|
#include "sun4i_drv.h"
|
|
|
|
#include "sun4i_framebuffer.h"
|
2017-02-23 15:05:36 +07:00
|
|
|
#include "sun4i_tcon.h"
|
2015-10-29 15:36:23 +07:00
|
|
|
|
2017-07-10 13:55:04 +07:00
|
|
|
static void sun4i_drv_lastclose(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct sun4i_drv *drv = dev->dev_private;
|
|
|
|
|
|
|
|
drm_fbdev_cma_restore_mode(drv->fbdev);
|
|
|
|
}
|
|
|
|
|
2017-03-08 21:12:56 +07:00
|
|
|
DEFINE_DRM_GEM_CMA_FOPS(sun4i_drv_fops);
|
2015-10-29 15:36:23 +07:00
|
|
|
|
|
|
|
static struct drm_driver sun4i_drv_driver = {
|
|
|
|
.driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_PRIME | DRIVER_ATOMIC,
|
|
|
|
|
|
|
|
/* Generic Operations */
|
2017-07-10 13:55:04 +07:00
|
|
|
.lastclose = sun4i_drv_lastclose,
|
2015-10-29 15:36:23 +07:00
|
|
|
.fops = &sun4i_drv_fops,
|
|
|
|
.name = "sun4i-drm",
|
|
|
|
.desc = "Allwinner sun4i Display Engine",
|
|
|
|
.date = "20150629",
|
|
|
|
.major = 1,
|
|
|
|
.minor = 0,
|
|
|
|
|
|
|
|
/* GEM Operations */
|
|
|
|
.dumb_create = drm_gem_cma_dumb_create,
|
2016-05-31 00:53:15 +07:00
|
|
|
.gem_free_object_unlocked = drm_gem_cma_free_object,
|
2015-10-29 15:36:23 +07:00
|
|
|
.gem_vm_ops = &drm_gem_cma_vm_ops,
|
|
|
|
|
|
|
|
/* PRIME Operations */
|
|
|
|
.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
|
|
|
|
.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
|
|
|
|
.gem_prime_import = drm_gem_prime_import,
|
|
|
|
.gem_prime_export = drm_gem_prime_export,
|
|
|
|
.gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table,
|
|
|
|
.gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table,
|
|
|
|
.gem_prime_vmap = drm_gem_cma_prime_vmap,
|
|
|
|
.gem_prime_vunmap = drm_gem_cma_prime_vunmap,
|
|
|
|
.gem_prime_mmap = drm_gem_cma_prime_mmap,
|
|
|
|
|
|
|
|
/* Frame Buffer Operations */
|
|
|
|
};
|
|
|
|
|
2016-05-11 21:52:50 +07:00
|
|
|
static void sun4i_remove_framebuffers(void)
|
|
|
|
{
|
|
|
|
struct apertures_struct *ap;
|
|
|
|
|
|
|
|
ap = alloc_apertures(1);
|
|
|
|
if (!ap)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* The framebuffer can be located anywhere in RAM */
|
|
|
|
ap->ranges[0].base = 0;
|
|
|
|
ap->ranges[0].size = ~0;
|
|
|
|
|
2016-08-10 23:52:34 +07:00
|
|
|
drm_fb_helper_remove_conflicting_framebuffers(ap, "sun4i-drm-fb", false);
|
2016-05-11 21:52:50 +07:00
|
|
|
kfree(ap);
|
|
|
|
}
|
|
|
|
|
2015-10-29 15:36:23 +07:00
|
|
|
static int sun4i_drv_bind(struct device *dev)
|
|
|
|
{
|
|
|
|
struct drm_device *drm;
|
|
|
|
struct sun4i_drv *drv;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
drm = drm_dev_alloc(&sun4i_drv_driver, dev);
|
2016-09-21 21:59:19 +07:00
|
|
|
if (IS_ERR(drm))
|
|
|
|
return PTR_ERR(drm);
|
2015-10-29 15:36:23 +07:00
|
|
|
|
|
|
|
drv = devm_kzalloc(dev, sizeof(*drv), GFP_KERNEL);
|
|
|
|
if (!drv) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto free_drm;
|
|
|
|
}
|
|
|
|
drm->dev_private = drv;
|
2017-05-17 21:47:17 +07:00
|
|
|
INIT_LIST_HEAD(&drv->engine_list);
|
2017-04-21 15:38:50 +07:00
|
|
|
INIT_LIST_HEAD(&drv->tcon_list);
|
2015-10-29 15:36:23 +07:00
|
|
|
|
2017-02-09 23:39:18 +07:00
|
|
|
ret = of_reserved_mem_device_init(dev);
|
|
|
|
if (ret && ret != -ENODEV) {
|
|
|
|
dev_err(drm->dev, "Couldn't claim our memory region\n");
|
|
|
|
goto free_drm;
|
|
|
|
}
|
|
|
|
|
2015-10-29 15:36:23 +07:00
|
|
|
drm_mode_config_init(drm);
|
|
|
|
|
|
|
|
ret = component_bind_all(drm->dev, drm);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(drm->dev, "Couldn't bind all pipelines components\n");
|
2017-02-17 10:13:25 +07:00
|
|
|
goto cleanup_mode_config;
|
2015-10-29 15:36:23 +07:00
|
|
|
}
|
|
|
|
|
2017-09-08 14:50:15 +07:00
|
|
|
/* drm_vblank_init calls kcalloc, which can fail */
|
|
|
|
ret = drm_vblank_init(drm, drm->mode_config.num_crtc);
|
|
|
|
if (ret)
|
|
|
|
goto free_mem_region;
|
|
|
|
|
2015-10-29 15:36:23 +07:00
|
|
|
drm->irq_enabled = true;
|
|
|
|
|
2016-05-11 21:52:50 +07:00
|
|
|
/* Remove early framebuffers (ie. simplefb) */
|
|
|
|
sun4i_remove_framebuffers();
|
|
|
|
|
2015-10-29 15:36:23 +07:00
|
|
|
/* Create our framebuffer */
|
|
|
|
drv->fbdev = sun4i_framebuffer_init(drm);
|
|
|
|
if (IS_ERR(drv->fbdev)) {
|
|
|
|
dev_err(drm->dev, "Couldn't create our framebuffer\n");
|
|
|
|
ret = PTR_ERR(drv->fbdev);
|
2017-02-17 10:13:25 +07:00
|
|
|
goto cleanup_mode_config;
|
2015-10-29 15:36:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Enable connectors polling */
|
|
|
|
drm_kms_helper_poll_init(drm);
|
|
|
|
|
|
|
|
ret = drm_dev_register(drm, 0);
|
|
|
|
if (ret)
|
2017-02-17 10:13:25 +07:00
|
|
|
goto finish_poll;
|
2015-10-29 15:36:23 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2017-02-17 10:13:25 +07:00
|
|
|
finish_poll:
|
|
|
|
drm_kms_helper_poll_fini(drm);
|
|
|
|
sun4i_framebuffer_free(drm);
|
|
|
|
cleanup_mode_config:
|
|
|
|
drm_mode_config_cleanup(drm);
|
2017-02-09 23:39:18 +07:00
|
|
|
free_mem_region:
|
|
|
|
of_reserved_mem_device_release(dev);
|
2015-10-29 15:36:23 +07:00
|
|
|
free_drm:
|
|
|
|
drm_dev_unref(drm);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sun4i_drv_unbind(struct device *dev)
|
|
|
|
{
|
|
|
|
struct drm_device *drm = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
drm_dev_unregister(drm);
|
|
|
|
drm_kms_helper_poll_fini(drm);
|
|
|
|
sun4i_framebuffer_free(drm);
|
2017-02-17 10:13:24 +07:00
|
|
|
drm_mode_config_cleanup(drm);
|
2017-02-09 23:39:18 +07:00
|
|
|
of_reserved_mem_device_release(dev);
|
2015-10-29 15:36:23 +07:00
|
|
|
drm_dev_unref(drm);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct component_master_ops sun4i_drv_master_ops = {
|
|
|
|
.bind = sun4i_drv_bind,
|
|
|
|
.unbind = sun4i_drv_unbind,
|
|
|
|
};
|
|
|
|
|
2017-05-27 23:09:32 +07:00
|
|
|
static bool sun4i_drv_node_is_connector(struct device_node *node)
|
|
|
|
{
|
|
|
|
return of_device_is_compatible(node, "hdmi-connector");
|
|
|
|
}
|
|
|
|
|
2015-10-29 15:36:23 +07:00
|
|
|
static bool sun4i_drv_node_is_frontend(struct device_node *node)
|
|
|
|
{
|
2016-01-07 18:32:25 +07:00
|
|
|
return of_device_is_compatible(node, "allwinner,sun5i-a13-display-frontend") ||
|
2016-10-20 10:43:41 +07:00
|
|
|
of_device_is_compatible(node, "allwinner,sun6i-a31-display-frontend") ||
|
2016-01-07 18:32:25 +07:00
|
|
|
of_device_is_compatible(node, "allwinner,sun8i-a33-display-frontend");
|
2015-10-29 15:36:23 +07:00
|
|
|
}
|
|
|
|
|
2015-10-29 15:37:32 +07:00
|
|
|
static bool sun4i_drv_node_is_tcon(struct device_node *node)
|
|
|
|
{
|
2017-10-17 19:17:59 +07:00
|
|
|
return of_device_is_compatible(node, "allwinner,sun4i-a10-tcon") ||
|
|
|
|
of_device_is_compatible(node, "allwinner,sun5i-a13-tcon") ||
|
2016-10-20 10:43:40 +07:00
|
|
|
of_device_is_compatible(node, "allwinner,sun6i-a31-tcon") ||
|
|
|
|
of_device_is_compatible(node, "allwinner,sun6i-a31s-tcon") ||
|
2017-05-17 21:47:22 +07:00
|
|
|
of_device_is_compatible(node, "allwinner,sun8i-a33-tcon") ||
|
|
|
|
of_device_is_compatible(node, "allwinner,sun8i-v3s-tcon");
|
2015-10-29 15:37:32 +07:00
|
|
|
}
|
|
|
|
|
2015-10-29 15:36:23 +07:00
|
|
|
static int compare_of(struct device *dev, void *data)
|
|
|
|
{
|
2017-07-19 04:43:04 +07:00
|
|
|
DRM_DEBUG_DRIVER("Comparing of node %pOF with %pOF\n",
|
|
|
|
dev->of_node,
|
|
|
|
data);
|
2015-10-29 15:36:23 +07:00
|
|
|
|
|
|
|
return dev->of_node == data;
|
|
|
|
}
|
|
|
|
|
drm/sun4i: add components in breadth first traversal order
The encoder drivers use drm_of_find_possible_crtcs to get upstream
crtcs from the device tree using of_graph. For the results to be
correct, encoders must be probed/bound after _all_ crtcs have been
created. The existing code uses a depth first recursive traversal
of the of_graph, which means the encoders downstream of the TCON
get add right after the first TCON. The second TCON or CRTC will
never be properly associated with encoders connected to it.
Other platforms, such as Rockchip, deal with this by probing all
CRTCs first, then all subsequent components. This is easy to do
since the CRTCs correspond to just one device node, and are the
first nodes in the pipeline.
However with Allwinner SoCs, the function of the CRTC is split
between the display backend (DE 1.0) or mixer (DE 2.0), which does
scan-out and compositing, and the TCON, which generates the display
timing signals. Further complicating the process, there may be a
Dynamic Range Controller between the backend and the TCON. Also, the
backend is preceded by the frontend, with a Display Enhancement Unit
possibly in between.
In a dual display pipeline setup, both frontends can feed either
backend, and both backends can feed either TCON. We want all
components of the same type to be added before the next type in the
pipeline. Fortunately, the pipelines are perfectly symmetric, i.e.
components of the same type are at the same depth when counted from
the frontend. The only exception is the third pipeline in the A80
SoC, which we do not support anyway.
Hence we can use a breadth first search traversal order to add
components. We do not need to check for duplicates. The component
matching system handles this for us.
Signed-off-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20170908075016.18657-3-wens@csie.org
2017-09-08 14:50:10 +07:00
|
|
|
/*
|
|
|
|
* The encoder drivers use drm_of_find_possible_crtcs to get upstream
|
|
|
|
* crtcs from the device tree using of_graph. For the results to be
|
|
|
|
* correct, encoders must be probed/bound after _all_ crtcs have been
|
|
|
|
* created. The existing code uses a depth first recursive traversal
|
|
|
|
* of the of_graph, which means the encoders downstream of the TCON
|
|
|
|
* get add right after the first TCON. The second TCON or CRTC will
|
|
|
|
* never be properly associated with encoders connected to it.
|
|
|
|
*
|
|
|
|
* Also, in a dual display pipeline setup, both frontends can feed
|
|
|
|
* either backend, and both backends can feed either TCON, we want
|
|
|
|
* all components of the same type to be added before the next type
|
|
|
|
* in the pipeline. Fortunately, the pipelines are perfectly symmetric,
|
|
|
|
* i.e. components of the same type are at the same depth when counted
|
|
|
|
* from the frontend. The only exception is the third pipeline in
|
|
|
|
* the A80 SoC, which we do not support anyway.
|
|
|
|
*
|
|
|
|
* Hence we can use a breadth first search traversal order to add
|
|
|
|
* components. We do not need to check for duplicates. The component
|
|
|
|
* matching system handles this for us.
|
|
|
|
*/
|
|
|
|
struct endpoint_list {
|
drm/sun4i: Implement endpoint parsing using kfifo
The commit da82b8785eeb ("drm/sun4i: add components in breadth first
traversal order") implemented a breadth first traversal of our device tree
nodes graph. However, it was relying on the kernel linked lists, and those
are not really safe for addition.
Indeed, in a single pipeline stage, your first stage (ie, the mixer or
fronted) will be queued, and it will be the final iteration of that list as
far as list_for_each_entry_safe is concerned. Then, during that final
iteration, we'll queue another element (the TCON or the backend) that
list_for_each_entry_safe will not account for, and we will leave the loop
without having iterated over all the elements. And since we won't have
built our components list properly, the DRM driver will be left
non-functional.
We can instead use a kfifo to queue and enqueue components in-order, as was
the original intention. This also has the benefit of removing any dynamic
allocation, making the error handling path simpler too. The only thing
we're losing is the ability to tell whether an element has already been
queued, but that was only needed to remove spurious logs, and therefore
purely cosmetic.
This means that this commit effectively reverses e8afb7b67fba ("drm/sun4i:
don't add components that are already in the queue").
Fixes: da82b8785eeb ("drm/sun4i: add components in breadth first traversal order")
Reviewed-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/4ecb323e787918208f6a5d9f0ebba12c62583c98.1508231063.git-series.maxime.ripard@free-electrons.com
2017-10-17 16:06:08 +07:00
|
|
|
DECLARE_KFIFO(fifo, struct device_node *, 16);
|
drm/sun4i: add components in breadth first traversal order
The encoder drivers use drm_of_find_possible_crtcs to get upstream
crtcs from the device tree using of_graph. For the results to be
correct, encoders must be probed/bound after _all_ crtcs have been
created. The existing code uses a depth first recursive traversal
of the of_graph, which means the encoders downstream of the TCON
get add right after the first TCON. The second TCON or CRTC will
never be properly associated with encoders connected to it.
Other platforms, such as Rockchip, deal with this by probing all
CRTCs first, then all subsequent components. This is easy to do
since the CRTCs correspond to just one device node, and are the
first nodes in the pipeline.
However with Allwinner SoCs, the function of the CRTC is split
between the display backend (DE 1.0) or mixer (DE 2.0), which does
scan-out and compositing, and the TCON, which generates the display
timing signals. Further complicating the process, there may be a
Dynamic Range Controller between the backend and the TCON. Also, the
backend is preceded by the frontend, with a Display Enhancement Unit
possibly in between.
In a dual display pipeline setup, both frontends can feed either
backend, and both backends can feed either TCON. We want all
components of the same type to be added before the next type in the
pipeline. Fortunately, the pipelines are perfectly symmetric, i.e.
components of the same type are at the same depth when counted from
the frontend. The only exception is the third pipeline in the A80
SoC, which we do not support anyway.
Hence we can use a breadth first search traversal order to add
components. We do not need to check for duplicates. The component
matching system handles this for us.
Signed-off-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20170908075016.18657-3-wens@csie.org
2017-09-08 14:50:10 +07:00
|
|
|
};
|
|
|
|
|
2015-10-29 15:36:23 +07:00
|
|
|
static int sun4i_drv_add_endpoints(struct device *dev,
|
drm/sun4i: Implement endpoint parsing using kfifo
The commit da82b8785eeb ("drm/sun4i: add components in breadth first
traversal order") implemented a breadth first traversal of our device tree
nodes graph. However, it was relying on the kernel linked lists, and those
are not really safe for addition.
Indeed, in a single pipeline stage, your first stage (ie, the mixer or
fronted) will be queued, and it will be the final iteration of that list as
far as list_for_each_entry_safe is concerned. Then, during that final
iteration, we'll queue another element (the TCON or the backend) that
list_for_each_entry_safe will not account for, and we will leave the loop
without having iterated over all the elements. And since we won't have
built our components list properly, the DRM driver will be left
non-functional.
We can instead use a kfifo to queue and enqueue components in-order, as was
the original intention. This also has the benefit of removing any dynamic
allocation, making the error handling path simpler too. The only thing
we're losing is the ability to tell whether an element has already been
queued, but that was only needed to remove spurious logs, and therefore
purely cosmetic.
This means that this commit effectively reverses e8afb7b67fba ("drm/sun4i:
don't add components that are already in the queue").
Fixes: da82b8785eeb ("drm/sun4i: add components in breadth first traversal order")
Reviewed-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/4ecb323e787918208f6a5d9f0ebba12c62583c98.1508231063.git-series.maxime.ripard@free-electrons.com
2017-10-17 16:06:08 +07:00
|
|
|
struct endpoint_list *list,
|
2015-10-29 15:36:23 +07:00
|
|
|
struct component_match **match,
|
|
|
|
struct device_node *node)
|
|
|
|
{
|
|
|
|
struct device_node *port, *ep, *remote;
|
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't support the frontend for now, so we will never
|
|
|
|
* have a device bound. Just skip over it, but we still want
|
|
|
|
* the rest our pipeline to be added.
|
|
|
|
*/
|
|
|
|
if (!sun4i_drv_node_is_frontend(node) &&
|
|
|
|
!of_device_is_available(node))
|
|
|
|
return 0;
|
|
|
|
|
2017-05-27 23:09:32 +07:00
|
|
|
/*
|
|
|
|
* The connectors will be the last nodes in our pipeline, we
|
|
|
|
* can just bail out.
|
|
|
|
*/
|
|
|
|
if (sun4i_drv_node_is_connector(node))
|
|
|
|
return 0;
|
|
|
|
|
2015-10-29 15:36:23 +07:00
|
|
|
if (!sun4i_drv_node_is_frontend(node)) {
|
|
|
|
/* Add current component */
|
2017-07-19 04:43:04 +07:00
|
|
|
DRM_DEBUG_DRIVER("Adding component %pOF\n", node);
|
2016-10-19 17:28:27 +07:00
|
|
|
drm_of_component_match_add(dev, match, compare_of, node);
|
2015-10-29 15:36:23 +07:00
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Inputs are listed first, then outputs */
|
|
|
|
port = of_graph_get_port_by_id(node, 1);
|
|
|
|
if (!port) {
|
|
|
|
DRM_DEBUG_DRIVER("No output to bind\n");
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
for_each_available_child_of_node(port, ep) {
|
|
|
|
remote = of_graph_get_remote_port_parent(ep);
|
|
|
|
if (!remote) {
|
|
|
|
DRM_DEBUG_DRIVER("Error retrieving the output node\n");
|
|
|
|
of_node_put(remote);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-10-29 15:37:32 +07:00
|
|
|
/*
|
2016-04-11 17:16:33 +07:00
|
|
|
* If the node is our TCON, the first port is used for
|
|
|
|
* panel or bridges, and will not be part of the
|
2015-10-29 15:37:32 +07:00
|
|
|
* component framework.
|
|
|
|
*/
|
|
|
|
if (sun4i_drv_node_is_tcon(node)) {
|
|
|
|
struct of_endpoint endpoint;
|
|
|
|
|
|
|
|
if (of_graph_parse_endpoint(ep, &endpoint)) {
|
|
|
|
DRM_DEBUG_DRIVER("Couldn't parse endpoint\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!endpoint.id) {
|
|
|
|
DRM_DEBUG_DRIVER("Endpoint is our panel... skipping\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
drm/sun4i: Implement endpoint parsing using kfifo
The commit da82b8785eeb ("drm/sun4i: add components in breadth first
traversal order") implemented a breadth first traversal of our device tree
nodes graph. However, it was relying on the kernel linked lists, and those
are not really safe for addition.
Indeed, in a single pipeline stage, your first stage (ie, the mixer or
fronted) will be queued, and it will be the final iteration of that list as
far as list_for_each_entry_safe is concerned. Then, during that final
iteration, we'll queue another element (the TCON or the backend) that
list_for_each_entry_safe will not account for, and we will leave the loop
without having iterated over all the elements. And since we won't have
built our components list properly, the DRM driver will be left
non-functional.
We can instead use a kfifo to queue and enqueue components in-order, as was
the original intention. This also has the benefit of removing any dynamic
allocation, making the error handling path simpler too. The only thing
we're losing is the ability to tell whether an element has already been
queued, but that was only needed to remove spurious logs, and therefore
purely cosmetic.
This means that this commit effectively reverses e8afb7b67fba ("drm/sun4i:
don't add components that are already in the queue").
Fixes: da82b8785eeb ("drm/sun4i: add components in breadth first traversal order")
Reviewed-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/4ecb323e787918208f6a5d9f0ebba12c62583c98.1508231063.git-series.maxime.ripard@free-electrons.com
2017-10-17 16:06:08 +07:00
|
|
|
kfifo_put(&list->fifo, remote);
|
2015-10-29 15:36:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sun4i_drv_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct component_match *match = NULL;
|
drm/sun4i: Implement endpoint parsing using kfifo
The commit da82b8785eeb ("drm/sun4i: add components in breadth first
traversal order") implemented a breadth first traversal of our device tree
nodes graph. However, it was relying on the kernel linked lists, and those
are not really safe for addition.
Indeed, in a single pipeline stage, your first stage (ie, the mixer or
fronted) will be queued, and it will be the final iteration of that list as
far as list_for_each_entry_safe is concerned. Then, during that final
iteration, we'll queue another element (the TCON or the backend) that
list_for_each_entry_safe will not account for, and we will leave the loop
without having iterated over all the elements. And since we won't have
built our components list properly, the DRM driver will be left
non-functional.
We can instead use a kfifo to queue and enqueue components in-order, as was
the original intention. This also has the benefit of removing any dynamic
allocation, making the error handling path simpler too. The only thing
we're losing is the ability to tell whether an element has already been
queued, but that was only needed to remove spurious logs, and therefore
purely cosmetic.
This means that this commit effectively reverses e8afb7b67fba ("drm/sun4i:
don't add components that are already in the queue").
Fixes: da82b8785eeb ("drm/sun4i: add components in breadth first traversal order")
Reviewed-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/4ecb323e787918208f6a5d9f0ebba12c62583c98.1508231063.git-series.maxime.ripard@free-electrons.com
2017-10-17 16:06:08 +07:00
|
|
|
struct device_node *np = pdev->dev.of_node, *endpoint;
|
|
|
|
struct endpoint_list list;
|
drm/sun4i: add components in breadth first traversal order
The encoder drivers use drm_of_find_possible_crtcs to get upstream
crtcs from the device tree using of_graph. For the results to be
correct, encoders must be probed/bound after _all_ crtcs have been
created. The existing code uses a depth first recursive traversal
of the of_graph, which means the encoders downstream of the TCON
get add right after the first TCON. The second TCON or CRTC will
never be properly associated with encoders connected to it.
Other platforms, such as Rockchip, deal with this by probing all
CRTCs first, then all subsequent components. This is easy to do
since the CRTCs correspond to just one device node, and are the
first nodes in the pipeline.
However with Allwinner SoCs, the function of the CRTC is split
between the display backend (DE 1.0) or mixer (DE 2.0), which does
scan-out and compositing, and the TCON, which generates the display
timing signals. Further complicating the process, there may be a
Dynamic Range Controller between the backend and the TCON. Also, the
backend is preceded by the frontend, with a Display Enhancement Unit
possibly in between.
In a dual display pipeline setup, both frontends can feed either
backend, and both backends can feed either TCON. We want all
components of the same type to be added before the next type in the
pipeline. Fortunately, the pipelines are perfectly symmetric, i.e.
components of the same type are at the same depth when counted from
the frontend. The only exception is the third pipeline in the A80
SoC, which we do not support anyway.
Hence we can use a breadth first search traversal order to add
components. We do not need to check for duplicates. The component
matching system handles this for us.
Signed-off-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20170908075016.18657-3-wens@csie.org
2017-09-08 14:50:10 +07:00
|
|
|
int i, ret, count = 0;
|
drm/sun4i: Implement endpoint parsing using kfifo
The commit da82b8785eeb ("drm/sun4i: add components in breadth first
traversal order") implemented a breadth first traversal of our device tree
nodes graph. However, it was relying on the kernel linked lists, and those
are not really safe for addition.
Indeed, in a single pipeline stage, your first stage (ie, the mixer or
fronted) will be queued, and it will be the final iteration of that list as
far as list_for_each_entry_safe is concerned. Then, during that final
iteration, we'll queue another element (the TCON or the backend) that
list_for_each_entry_safe will not account for, and we will leave the loop
without having iterated over all the elements. And since we won't have
built our components list properly, the DRM driver will be left
non-functional.
We can instead use a kfifo to queue and enqueue components in-order, as was
the original intention. This also has the benefit of removing any dynamic
allocation, making the error handling path simpler too. The only thing
we're losing is the ability to tell whether an element has already been
queued, but that was only needed to remove spurious logs, and therefore
purely cosmetic.
This means that this commit effectively reverses e8afb7b67fba ("drm/sun4i:
don't add components that are already in the queue").
Fixes: da82b8785eeb ("drm/sun4i: add components in breadth first traversal order")
Reviewed-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/4ecb323e787918208f6a5d9f0ebba12c62583c98.1508231063.git-series.maxime.ripard@free-electrons.com
2017-10-17 16:06:08 +07:00
|
|
|
|
|
|
|
INIT_KFIFO(list.fifo);
|
2015-10-29 15:36:23 +07:00
|
|
|
|
|
|
|
for (i = 0;; i++) {
|
|
|
|
struct device_node *pipeline = of_parse_phandle(np,
|
|
|
|
"allwinner,pipelines",
|
|
|
|
i);
|
|
|
|
if (!pipeline)
|
|
|
|
break;
|
|
|
|
|
drm/sun4i: Implement endpoint parsing using kfifo
The commit da82b8785eeb ("drm/sun4i: add components in breadth first
traversal order") implemented a breadth first traversal of our device tree
nodes graph. However, it was relying on the kernel linked lists, and those
are not really safe for addition.
Indeed, in a single pipeline stage, your first stage (ie, the mixer or
fronted) will be queued, and it will be the final iteration of that list as
far as list_for_each_entry_safe is concerned. Then, during that final
iteration, we'll queue another element (the TCON or the backend) that
list_for_each_entry_safe will not account for, and we will leave the loop
without having iterated over all the elements. And since we won't have
built our components list properly, the DRM driver will be left
non-functional.
We can instead use a kfifo to queue and enqueue components in-order, as was
the original intention. This also has the benefit of removing any dynamic
allocation, making the error handling path simpler too. The only thing
we're losing is the ability to tell whether an element has already been
queued, but that was only needed to remove spurious logs, and therefore
purely cosmetic.
This means that this commit effectively reverses e8afb7b67fba ("drm/sun4i:
don't add components that are already in the queue").
Fixes: da82b8785eeb ("drm/sun4i: add components in breadth first traversal order")
Reviewed-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/4ecb323e787918208f6a5d9f0ebba12c62583c98.1508231063.git-series.maxime.ripard@free-electrons.com
2017-10-17 16:06:08 +07:00
|
|
|
kfifo_put(&list.fifo, pipeline);
|
drm/sun4i: add components in breadth first traversal order
The encoder drivers use drm_of_find_possible_crtcs to get upstream
crtcs from the device tree using of_graph. For the results to be
correct, encoders must be probed/bound after _all_ crtcs have been
created. The existing code uses a depth first recursive traversal
of the of_graph, which means the encoders downstream of the TCON
get add right after the first TCON. The second TCON or CRTC will
never be properly associated with encoders connected to it.
Other platforms, such as Rockchip, deal with this by probing all
CRTCs first, then all subsequent components. This is easy to do
since the CRTCs correspond to just one device node, and are the
first nodes in the pipeline.
However with Allwinner SoCs, the function of the CRTC is split
between the display backend (DE 1.0) or mixer (DE 2.0), which does
scan-out and compositing, and the TCON, which generates the display
timing signals. Further complicating the process, there may be a
Dynamic Range Controller between the backend and the TCON. Also, the
backend is preceded by the frontend, with a Display Enhancement Unit
possibly in between.
In a dual display pipeline setup, both frontends can feed either
backend, and both backends can feed either TCON. We want all
components of the same type to be added before the next type in the
pipeline. Fortunately, the pipelines are perfectly symmetric, i.e.
components of the same type are at the same depth when counted from
the frontend. The only exception is the third pipeline in the A80
SoC, which we do not support anyway.
Hence we can use a breadth first search traversal order to add
components. We do not need to check for duplicates. The component
matching system handles this for us.
Signed-off-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20170908075016.18657-3-wens@csie.org
2017-09-08 14:50:10 +07:00
|
|
|
}
|
|
|
|
|
drm/sun4i: Implement endpoint parsing using kfifo
The commit da82b8785eeb ("drm/sun4i: add components in breadth first
traversal order") implemented a breadth first traversal of our device tree
nodes graph. However, it was relying on the kernel linked lists, and those
are not really safe for addition.
Indeed, in a single pipeline stage, your first stage (ie, the mixer or
fronted) will be queued, and it will be the final iteration of that list as
far as list_for_each_entry_safe is concerned. Then, during that final
iteration, we'll queue another element (the TCON or the backend) that
list_for_each_entry_safe will not account for, and we will leave the loop
without having iterated over all the elements. And since we won't have
built our components list properly, the DRM driver will be left
non-functional.
We can instead use a kfifo to queue and enqueue components in-order, as was
the original intention. This also has the benefit of removing any dynamic
allocation, making the error handling path simpler too. The only thing
we're losing is the ability to tell whether an element has already been
queued, but that was only needed to remove spurious logs, and therefore
purely cosmetic.
This means that this commit effectively reverses e8afb7b67fba ("drm/sun4i:
don't add components that are already in the queue").
Fixes: da82b8785eeb ("drm/sun4i: add components in breadth first traversal order")
Reviewed-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/4ecb323e787918208f6a5d9f0ebba12c62583c98.1508231063.git-series.maxime.ripard@free-electrons.com
2017-10-17 16:06:08 +07:00
|
|
|
while (kfifo_get(&list.fifo, &endpoint)) {
|
drm/sun4i: add components in breadth first traversal order
The encoder drivers use drm_of_find_possible_crtcs to get upstream
crtcs from the device tree using of_graph. For the results to be
correct, encoders must be probed/bound after _all_ crtcs have been
created. The existing code uses a depth first recursive traversal
of the of_graph, which means the encoders downstream of the TCON
get add right after the first TCON. The second TCON or CRTC will
never be properly associated with encoders connected to it.
Other platforms, such as Rockchip, deal with this by probing all
CRTCs first, then all subsequent components. This is easy to do
since the CRTCs correspond to just one device node, and are the
first nodes in the pipeline.
However with Allwinner SoCs, the function of the CRTC is split
between the display backend (DE 1.0) or mixer (DE 2.0), which does
scan-out and compositing, and the TCON, which generates the display
timing signals. Further complicating the process, there may be a
Dynamic Range Controller between the backend and the TCON. Also, the
backend is preceded by the frontend, with a Display Enhancement Unit
possibly in between.
In a dual display pipeline setup, both frontends can feed either
backend, and both backends can feed either TCON. We want all
components of the same type to be added before the next type in the
pipeline. Fortunately, the pipelines are perfectly symmetric, i.e.
components of the same type are at the same depth when counted from
the frontend. The only exception is the third pipeline in the A80
SoC, which we do not support anyway.
Hence we can use a breadth first search traversal order to add
components. We do not need to check for duplicates. The component
matching system handles this for us.
Signed-off-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20170908075016.18657-3-wens@csie.org
2017-09-08 14:50:10 +07:00
|
|
|
/* process this endpoint */
|
drm/sun4i: Implement endpoint parsing using kfifo
The commit da82b8785eeb ("drm/sun4i: add components in breadth first
traversal order") implemented a breadth first traversal of our device tree
nodes graph. However, it was relying on the kernel linked lists, and those
are not really safe for addition.
Indeed, in a single pipeline stage, your first stage (ie, the mixer or
fronted) will be queued, and it will be the final iteration of that list as
far as list_for_each_entry_safe is concerned. Then, during that final
iteration, we'll queue another element (the TCON or the backend) that
list_for_each_entry_safe will not account for, and we will leave the loop
without having iterated over all the elements. And since we won't have
built our components list properly, the DRM driver will be left
non-functional.
We can instead use a kfifo to queue and enqueue components in-order, as was
the original intention. This also has the benefit of removing any dynamic
allocation, making the error handling path simpler too. The only thing
we're losing is the ability to tell whether an element has already been
queued, but that was only needed to remove spurious logs, and therefore
purely cosmetic.
This means that this commit effectively reverses e8afb7b67fba ("drm/sun4i:
don't add components that are already in the queue").
Fixes: da82b8785eeb ("drm/sun4i: add components in breadth first traversal order")
Reviewed-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/4ecb323e787918208f6a5d9f0ebba12c62583c98.1508231063.git-series.maxime.ripard@free-electrons.com
2017-10-17 16:06:08 +07:00
|
|
|
ret = sun4i_drv_add_endpoints(&pdev->dev, &list, &match,
|
|
|
|
endpoint);
|
drm/sun4i: add components in breadth first traversal order
The encoder drivers use drm_of_find_possible_crtcs to get upstream
crtcs from the device tree using of_graph. For the results to be
correct, encoders must be probed/bound after _all_ crtcs have been
created. The existing code uses a depth first recursive traversal
of the of_graph, which means the encoders downstream of the TCON
get add right after the first TCON. The second TCON or CRTC will
never be properly associated with encoders connected to it.
Other platforms, such as Rockchip, deal with this by probing all
CRTCs first, then all subsequent components. This is easy to do
since the CRTCs correspond to just one device node, and are the
first nodes in the pipeline.
However with Allwinner SoCs, the function of the CRTC is split
between the display backend (DE 1.0) or mixer (DE 2.0), which does
scan-out and compositing, and the TCON, which generates the display
timing signals. Further complicating the process, there may be a
Dynamic Range Controller between the backend and the TCON. Also, the
backend is preceded by the frontend, with a Display Enhancement Unit
possibly in between.
In a dual display pipeline setup, both frontends can feed either
backend, and both backends can feed either TCON. We want all
components of the same type to be added before the next type in the
pipeline. Fortunately, the pipelines are perfectly symmetric, i.e.
components of the same type are at the same depth when counted from
the frontend. The only exception is the third pipeline in the A80
SoC, which we do not support anyway.
Hence we can use a breadth first search traversal order to add
components. We do not need to check for duplicates. The component
matching system handles this for us.
Signed-off-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20170908075016.18657-3-wens@csie.org
2017-09-08 14:50:10 +07:00
|
|
|
|
|
|
|
/* sun4i_drv_add_endpoints can fail to allocate memory */
|
|
|
|
if (ret < 0)
|
drm/sun4i: Implement endpoint parsing using kfifo
The commit da82b8785eeb ("drm/sun4i: add components in breadth first
traversal order") implemented a breadth first traversal of our device tree
nodes graph. However, it was relying on the kernel linked lists, and those
are not really safe for addition.
Indeed, in a single pipeline stage, your first stage (ie, the mixer or
fronted) will be queued, and it will be the final iteration of that list as
far as list_for_each_entry_safe is concerned. Then, during that final
iteration, we'll queue another element (the TCON or the backend) that
list_for_each_entry_safe will not account for, and we will leave the loop
without having iterated over all the elements. And since we won't have
built our components list properly, the DRM driver will be left
non-functional.
We can instead use a kfifo to queue and enqueue components in-order, as was
the original intention. This also has the benefit of removing any dynamic
allocation, making the error handling path simpler too. The only thing
we're losing is the ability to tell whether an element has already been
queued, but that was only needed to remove spurious logs, and therefore
purely cosmetic.
This means that this commit effectively reverses e8afb7b67fba ("drm/sun4i:
don't add components that are already in the queue").
Fixes: da82b8785eeb ("drm/sun4i: add components in breadth first traversal order")
Reviewed-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/4ecb323e787918208f6a5d9f0ebba12c62583c98.1508231063.git-series.maxime.ripard@free-electrons.com
2017-10-17 16:06:08 +07:00
|
|
|
return ret;
|
drm/sun4i: add components in breadth first traversal order
The encoder drivers use drm_of_find_possible_crtcs to get upstream
crtcs from the device tree using of_graph. For the results to be
correct, encoders must be probed/bound after _all_ crtcs have been
created. The existing code uses a depth first recursive traversal
of the of_graph, which means the encoders downstream of the TCON
get add right after the first TCON. The second TCON or CRTC will
never be properly associated with encoders connected to it.
Other platforms, such as Rockchip, deal with this by probing all
CRTCs first, then all subsequent components. This is easy to do
since the CRTCs correspond to just one device node, and are the
first nodes in the pipeline.
However with Allwinner SoCs, the function of the CRTC is split
between the display backend (DE 1.0) or mixer (DE 2.0), which does
scan-out and compositing, and the TCON, which generates the display
timing signals. Further complicating the process, there may be a
Dynamic Range Controller between the backend and the TCON. Also, the
backend is preceded by the frontend, with a Display Enhancement Unit
possibly in between.
In a dual display pipeline setup, both frontends can feed either
backend, and both backends can feed either TCON. We want all
components of the same type to be added before the next type in the
pipeline. Fortunately, the pipelines are perfectly symmetric, i.e.
components of the same type are at the same depth when counted from
the frontend. The only exception is the third pipeline in the A80
SoC, which we do not support anyway.
Hence we can use a breadth first search traversal order to add
components. We do not need to check for duplicates. The component
matching system handles this for us.
Signed-off-by: Chen-Yu Tsai <wens@csie.org>
Signed-off-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20170908075016.18657-3-wens@csie.org
2017-09-08 14:50:10 +07:00
|
|
|
|
|
|
|
count += ret;
|
2015-10-29 15:36:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (count)
|
|
|
|
return component_master_add_with_match(&pdev->dev,
|
|
|
|
&sun4i_drv_master_ops,
|
|
|
|
match);
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sun4i_drv_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct of_device_id sun4i_drv_of_table[] = {
|
2017-05-27 23:09:36 +07:00
|
|
|
{ .compatible = "allwinner,sun5i-a10s-display-engine" },
|
2015-10-29 15:36:23 +07:00
|
|
|
{ .compatible = "allwinner,sun5i-a13-display-engine" },
|
2016-10-20 10:43:41 +07:00
|
|
|
{ .compatible = "allwinner,sun6i-a31-display-engine" },
|
|
|
|
{ .compatible = "allwinner,sun6i-a31s-display-engine" },
|
2016-01-07 18:32:25 +07:00
|
|
|
{ .compatible = "allwinner,sun8i-a33-display-engine" },
|
2017-05-17 21:47:21 +07:00
|
|
|
{ .compatible = "allwinner,sun8i-v3s-display-engine" },
|
2015-10-29 15:36:23 +07:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, sun4i_drv_of_table);
|
|
|
|
|
|
|
|
static struct platform_driver sun4i_drv_platform_driver = {
|
|
|
|
.probe = sun4i_drv_probe,
|
|
|
|
.remove = sun4i_drv_remove,
|
|
|
|
.driver = {
|
|
|
|
.name = "sun4i-drm",
|
|
|
|
.of_match_table = sun4i_drv_of_table,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
module_platform_driver(sun4i_drv_platform_driver);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Boris Brezillon <boris.brezillon@free-electrons.com>");
|
|
|
|
MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
|
|
|
|
MODULE_DESCRIPTION("Allwinner A10 Display Engine DRM/KMS Driver");
|
|
|
|
MODULE_LICENSE("GPL");
|