1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2015 Free Electrons
4 * Copyright (C) 2015 NextThing Co
6 * Maxime Ripard <maxime.ripard@free-electrons.com>
9 #include <linux/component.h>
10 #include <linux/kfifo.h>
11 #include <linux/module.h>
12 #include <linux/of_graph.h>
13 #include <linux/of_reserved_mem.h>
14 #include <linux/platform_device.h>
16 #include <drm/drm_atomic_helper.h>
17 #include <drm/drm_drv.h>
18 #include <drm/drm_fb_cma_helper.h>
19 #include <drm/drm_fb_helper.h>
20 #include <drm/drm_gem_cma_helper.h>
21 #include <drm/drm_of.h>
22 #include <drm/drm_probe_helper.h>
23 #include <drm/drm_vblank.h>
25 #include "sun4i_drv.h"
26 #include "sun4i_frontend.h"
27 #include "sun4i_framebuffer.h"
28 #include "sun4i_tcon.h"
29 #include "sun8i_tcon_top.h"
31 static int drm_sun4i_gem_dumb_create(struct drm_file
*file_priv
,
32 struct drm_device
*drm
,
33 struct drm_mode_create_dumb
*args
)
35 /* The hardware only allows even pitches for YUV buffers. */
36 args
->pitch
= ALIGN(DIV_ROUND_UP(args
->width
* args
->bpp
, 8), 2);
38 return drm_gem_cma_dumb_create_internal(file_priv
, drm
, args
);
41 DEFINE_DRM_GEM_CMA_FOPS(sun4i_drv_fops
);
43 static const struct drm_driver sun4i_drv_driver
= {
44 .driver_features
= DRIVER_GEM
| DRIVER_MODESET
| DRIVER_ATOMIC
,
46 /* Generic Operations */
47 .fops
= &sun4i_drv_fops
,
49 .desc
= "Allwinner sun4i Display Engine",
55 DRM_GEM_CMA_DRIVER_OPS_VMAP_WITH_DUMB_CREATE(drm_sun4i_gem_dumb_create
),
58 static int sun4i_drv_bind(struct device
*dev
)
60 struct drm_device
*drm
;
61 struct sun4i_drv
*drv
;
64 drm
= drm_dev_alloc(&sun4i_drv_driver
, dev
);
68 drv
= devm_kzalloc(dev
, sizeof(*drv
), GFP_KERNEL
);
74 dev_set_drvdata(dev
, drm
);
75 drm
->dev_private
= drv
;
76 INIT_LIST_HEAD(&drv
->frontend_list
);
77 INIT_LIST_HEAD(&drv
->engine_list
);
78 INIT_LIST_HEAD(&drv
->tcon_list
);
80 ret
= of_reserved_mem_device_init(dev
);
81 if (ret
&& ret
!= -ENODEV
) {
82 dev_err(drm
->dev
, "Couldn't claim our memory region\n");
86 drm_mode_config_init(drm
);
88 ret
= component_bind_all(drm
->dev
, drm
);
90 dev_err(drm
->dev
, "Couldn't bind all pipelines components\n");
91 goto cleanup_mode_config
;
94 /* drm_vblank_init calls kcalloc, which can fail */
95 ret
= drm_vblank_init(drm
, drm
->mode_config
.num_crtc
);
97 goto cleanup_mode_config
;
99 drm
->irq_enabled
= true;
101 /* Remove early framebuffers (ie. simplefb) */
102 drm_fb_helper_remove_conflicting_framebuffers(NULL
, "sun4i-drm-fb", false);
104 sun4i_framebuffer_init(drm
);
106 /* Enable connectors polling */
107 drm_kms_helper_poll_init(drm
);
109 ret
= drm_dev_register(drm
, 0);
113 drm_fbdev_generic_setup(drm
, 32);
118 drm_kms_helper_poll_fini(drm
);
120 drm_mode_config_cleanup(drm
);
121 of_reserved_mem_device_release(dev
);
127 static void sun4i_drv_unbind(struct device
*dev
)
129 struct drm_device
*drm
= dev_get_drvdata(dev
);
131 drm_dev_unregister(drm
);
132 drm_kms_helper_poll_fini(drm
);
133 drm_atomic_helper_shutdown(drm
);
134 drm_mode_config_cleanup(drm
);
136 component_unbind_all(dev
, NULL
);
137 of_reserved_mem_device_release(dev
);
142 static const struct component_master_ops sun4i_drv_master_ops
= {
143 .bind
= sun4i_drv_bind
,
144 .unbind
= sun4i_drv_unbind
,
147 static bool sun4i_drv_node_is_connector(struct device_node
*node
)
149 return of_device_is_compatible(node
, "hdmi-connector");
152 static bool sun4i_drv_node_is_frontend(struct device_node
*node
)
154 return of_device_is_compatible(node
, "allwinner,sun4i-a10-display-frontend") ||
155 of_device_is_compatible(node
, "allwinner,sun5i-a13-display-frontend") ||
156 of_device_is_compatible(node
, "allwinner,sun6i-a31-display-frontend") ||
157 of_device_is_compatible(node
, "allwinner,sun7i-a20-display-frontend") ||
158 of_device_is_compatible(node
, "allwinner,sun8i-a23-display-frontend") ||
159 of_device_is_compatible(node
, "allwinner,sun8i-a33-display-frontend") ||
160 of_device_is_compatible(node
, "allwinner,sun9i-a80-display-frontend");
163 static bool sun4i_drv_node_is_deu(struct device_node
*node
)
165 return of_device_is_compatible(node
, "allwinner,sun9i-a80-deu");
168 static bool sun4i_drv_node_is_supported_frontend(struct device_node
*node
)
170 if (IS_ENABLED(CONFIG_DRM_SUN4I_BACKEND
))
171 return !!of_match_node(sun4i_frontend_of_table
, node
);
176 static bool sun4i_drv_node_is_tcon(struct device_node
*node
)
178 return !!of_match_node(sun4i_tcon_of_table
, node
);
181 static bool sun4i_drv_node_is_tcon_with_ch0(struct device_node
*node
)
183 const struct of_device_id
*match
;
185 match
= of_match_node(sun4i_tcon_of_table
, node
);
187 struct sun4i_tcon_quirks
*quirks
;
189 quirks
= (struct sun4i_tcon_quirks
*)match
->data
;
191 return quirks
->has_channel_0
;
197 static bool sun4i_drv_node_is_tcon_top(struct device_node
*node
)
199 return IS_ENABLED(CONFIG_DRM_SUN8I_TCON_TOP
) &&
200 !!of_match_node(sun8i_tcon_top_of_table
, node
);
203 static int compare_of(struct device
*dev
, void *data
)
205 DRM_DEBUG_DRIVER("Comparing of node %pOF with %pOF\n",
209 return dev
->of_node
== data
;
213 * The encoder drivers use drm_of_find_possible_crtcs to get upstream
214 * crtcs from the device tree using of_graph. For the results to be
215 * correct, encoders must be probed/bound after _all_ crtcs have been
216 * created. The existing code uses a depth first recursive traversal
217 * of the of_graph, which means the encoders downstream of the TCON
218 * get add right after the first TCON. The second TCON or CRTC will
219 * never be properly associated with encoders connected to it.
221 * Also, in a dual display pipeline setup, both frontends can feed
222 * either backend, and both backends can feed either TCON, we want
223 * all components of the same type to be added before the next type
224 * in the pipeline. Fortunately, the pipelines are perfectly symmetric,
225 * i.e. components of the same type are at the same depth when counted
226 * from the frontend. The only exception is the third pipeline in
227 * the A80 SoC, which we do not support anyway.
229 * Hence we can use a breadth first search traversal order to add
230 * components. We do not need to check for duplicates. The component
231 * matching system handles this for us.
233 struct endpoint_list
{
234 DECLARE_KFIFO(fifo
, struct device_node
*, 16);
237 static void sun4i_drv_traverse_endpoints(struct endpoint_list
*list
,
238 struct device_node
*node
,
241 struct device_node
*ep
, *remote
, *port
;
243 port
= of_graph_get_port_by_id(node
, port_id
);
245 DRM_DEBUG_DRIVER("No output to bind on port %d\n", port_id
);
249 for_each_available_child_of_node(port
, ep
) {
250 remote
= of_graph_get_remote_port_parent(ep
);
252 DRM_DEBUG_DRIVER("Error retrieving the output node\n");
256 if (sun4i_drv_node_is_tcon(node
)) {
258 * TCON TOP is always probed before TCON. However, TCON
259 * points back to TCON TOP when it is source for HDMI.
260 * We have to skip it here to prevent infinite looping
261 * between TCON TOP and TCON.
263 if (sun4i_drv_node_is_tcon_top(remote
)) {
264 DRM_DEBUG_DRIVER("TCON output endpoint is TCON TOP... skipping\n");
270 * If the node is our TCON with channel 0, the first
271 * port is used for panel or bridges, and will not be
272 * part of the component framework.
274 if (sun4i_drv_node_is_tcon_with_ch0(node
)) {
275 struct of_endpoint endpoint
;
277 if (of_graph_parse_endpoint(ep
, &endpoint
)) {
278 DRM_DEBUG_DRIVER("Couldn't parse endpoint\n");
284 DRM_DEBUG_DRIVER("Endpoint is our panel... skipping\n");
291 kfifo_put(&list
->fifo
, remote
);
295 static int sun4i_drv_add_endpoints(struct device
*dev
,
296 struct endpoint_list
*list
,
297 struct component_match
**match
,
298 struct device_node
*node
)
303 * The frontend has been disabled in some of our old device
304 * trees. If we find a node that is the frontend and is
305 * disabled, we should just follow through and parse its
306 * child, but without adding it to the component list.
307 * Otherwise, we obviously want to add it to the list.
309 if (!sun4i_drv_node_is_frontend(node
) &&
310 !of_device_is_available(node
))
314 * The connectors will be the last nodes in our pipeline, we
317 if (sun4i_drv_node_is_connector(node
))
321 * If the device is either just a regular device, or an
322 * enabled frontend supported by the driver, we add it to our
325 if (!(sun4i_drv_node_is_frontend(node
) ||
326 sun4i_drv_node_is_deu(node
)) ||
327 (sun4i_drv_node_is_supported_frontend(node
) &&
328 of_device_is_available(node
))) {
329 /* Add current component */
330 DRM_DEBUG_DRIVER("Adding component %pOF\n", node
);
331 drm_of_component_match_add(dev
, match
, compare_of
, node
);
335 /* each node has at least one output */
336 sun4i_drv_traverse_endpoints(list
, node
, 1);
338 /* TCON TOP has second and third output */
339 if (sun4i_drv_node_is_tcon_top(node
)) {
340 sun4i_drv_traverse_endpoints(list
, node
, 3);
341 sun4i_drv_traverse_endpoints(list
, node
, 5);
347 #ifdef CONFIG_PM_SLEEP
348 static int sun4i_drv_drm_sys_suspend(struct device
*dev
)
350 struct drm_device
*drm
= dev_get_drvdata(dev
);
352 return drm_mode_config_helper_suspend(drm
);
355 static int sun4i_drv_drm_sys_resume(struct device
*dev
)
357 struct drm_device
*drm
= dev_get_drvdata(dev
);
359 return drm_mode_config_helper_resume(drm
);
363 static const struct dev_pm_ops sun4i_drv_drm_pm_ops
= {
364 SET_SYSTEM_SLEEP_PM_OPS(sun4i_drv_drm_sys_suspend
,
365 sun4i_drv_drm_sys_resume
)
368 static int sun4i_drv_probe(struct platform_device
*pdev
)
370 struct component_match
*match
= NULL
;
371 struct device_node
*np
= pdev
->dev
.of_node
, *endpoint
;
372 struct endpoint_list list
;
373 int i
, ret
, count
= 0;
375 INIT_KFIFO(list
.fifo
);
378 struct device_node
*pipeline
= of_parse_phandle(np
,
379 "allwinner,pipelines",
384 kfifo_put(&list
.fifo
, pipeline
);
387 while (kfifo_get(&list
.fifo
, &endpoint
)) {
388 /* process this endpoint */
389 ret
= sun4i_drv_add_endpoints(&pdev
->dev
, &list
, &match
,
392 /* sun4i_drv_add_endpoints can fail to allocate memory */
400 return component_master_add_with_match(&pdev
->dev
,
401 &sun4i_drv_master_ops
,
407 static int sun4i_drv_remove(struct platform_device
*pdev
)
409 component_master_del(&pdev
->dev
, &sun4i_drv_master_ops
);
414 static const struct of_device_id sun4i_drv_of_table
[] = {
415 { .compatible
= "allwinner,sun4i-a10-display-engine" },
416 { .compatible
= "allwinner,sun5i-a10s-display-engine" },
417 { .compatible
= "allwinner,sun5i-a13-display-engine" },
418 { .compatible
= "allwinner,sun6i-a31-display-engine" },
419 { .compatible
= "allwinner,sun6i-a31s-display-engine" },
420 { .compatible
= "allwinner,sun7i-a20-display-engine" },
421 { .compatible
= "allwinner,sun8i-a23-display-engine" },
422 { .compatible
= "allwinner,sun8i-a33-display-engine" },
423 { .compatible
= "allwinner,sun8i-a83t-display-engine" },
424 { .compatible
= "allwinner,sun8i-h3-display-engine" },
425 { .compatible
= "allwinner,sun8i-r40-display-engine" },
426 { .compatible
= "allwinner,sun8i-v3s-display-engine" },
427 { .compatible
= "allwinner,sun9i-a80-display-engine" },
428 { .compatible
= "allwinner,sun50i-a64-display-engine" },
429 { .compatible
= "allwinner,sun50i-h6-display-engine" },
432 MODULE_DEVICE_TABLE(of
, sun4i_drv_of_table
);
434 static struct platform_driver sun4i_drv_platform_driver
= {
435 .probe
= sun4i_drv_probe
,
436 .remove
= sun4i_drv_remove
,
439 .of_match_table
= sun4i_drv_of_table
,
440 .pm
= &sun4i_drv_drm_pm_ops
,
443 module_platform_driver(sun4i_drv_platform_driver
);
445 MODULE_AUTHOR("Boris Brezillon <boris.brezillon@free-electrons.com>");
446 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
447 MODULE_DESCRIPTION("Allwinner A10 Display Engine DRM/KMS Driver");
448 MODULE_LICENSE("GPL");