2 * Copyright (C) 2015 Free Electrons
3 * Copyright (C) 2015 NextThing Co
5 * Maxime Ripard <maxime.ripard@free-electrons.com>
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License as
9 * published by the Free Software Foundation; either version 2 of
10 * the License, or (at your option) any later version.
13 #include <linux/component.h>
14 #include <linux/kfifo.h>
15 #include <linux/of_graph.h>
16 #include <linux/of_reserved_mem.h>
19 #include <drm/drm_fb_cma_helper.h>
20 #include <drm/drm_fb_helper.h>
21 #include <drm/drm_gem_cma_helper.h>
22 #include <drm/drm_of.h>
23 #include <drm/drm_probe_helper.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 struct drm_driver sun4i_drv_driver
= {
44 .driver_features
= DRIVER_GEM
| DRIVER_MODESET
| DRIVER_PRIME
| DRIVER_ATOMIC
,
46 /* Generic Operations */
47 .fops
= &sun4i_drv_fops
,
49 .desc
= "Allwinner sun4i Display Engine",
55 .dumb_create
= drm_sun4i_gem_dumb_create
,
56 .gem_free_object_unlocked
= drm_gem_cma_free_object
,
57 .gem_vm_ops
= &drm_gem_cma_vm_ops
,
59 /* PRIME Operations */
60 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
61 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
62 .gem_prime_import
= drm_gem_prime_import
,
63 .gem_prime_export
= drm_gem_prime_export
,
64 .gem_prime_get_sg_table
= drm_gem_cma_prime_get_sg_table
,
65 .gem_prime_import_sg_table
= drm_gem_cma_prime_import_sg_table
,
66 .gem_prime_vmap
= drm_gem_cma_prime_vmap
,
67 .gem_prime_vunmap
= drm_gem_cma_prime_vunmap
,
68 .gem_prime_mmap
= drm_gem_cma_prime_mmap
,
70 /* Frame Buffer Operations */
73 static int sun4i_drv_bind(struct device
*dev
)
75 struct drm_device
*drm
;
76 struct sun4i_drv
*drv
;
79 drm
= drm_dev_alloc(&sun4i_drv_driver
, dev
);
83 drv
= devm_kzalloc(dev
, sizeof(*drv
), GFP_KERNEL
);
88 drm
->dev_private
= drv
;
89 INIT_LIST_HEAD(&drv
->frontend_list
);
90 INIT_LIST_HEAD(&drv
->engine_list
);
91 INIT_LIST_HEAD(&drv
->tcon_list
);
93 ret
= of_reserved_mem_device_init(dev
);
94 if (ret
&& ret
!= -ENODEV
) {
95 dev_err(drm
->dev
, "Couldn't claim our memory region\n");
99 drm_mode_config_init(drm
);
100 drm
->mode_config
.allow_fb_modifiers
= true;
102 ret
= component_bind_all(drm
->dev
, drm
);
104 dev_err(drm
->dev
, "Couldn't bind all pipelines components\n");
105 goto cleanup_mode_config
;
108 /* drm_vblank_init calls kcalloc, which can fail */
109 ret
= drm_vblank_init(drm
, drm
->mode_config
.num_crtc
);
111 goto cleanup_mode_config
;
113 drm
->irq_enabled
= true;
115 /* Remove early framebuffers (ie. simplefb) */
116 drm_fb_helper_remove_conflicting_framebuffers(NULL
, "sun4i-drm-fb", false);
118 sun4i_framebuffer_init(drm
);
120 /* Enable connectors polling */
121 drm_kms_helper_poll_init(drm
);
123 ret
= drm_dev_register(drm
, 0);
127 drm_fbdev_generic_setup(drm
, 32);
132 drm_kms_helper_poll_fini(drm
);
134 drm_mode_config_cleanup(drm
);
135 of_reserved_mem_device_release(dev
);
141 static void sun4i_drv_unbind(struct device
*dev
)
143 struct drm_device
*drm
= dev_get_drvdata(dev
);
145 drm_dev_unregister(drm
);
146 drm_kms_helper_poll_fini(drm
);
147 drm_mode_config_cleanup(drm
);
148 of_reserved_mem_device_release(dev
);
152 static const struct component_master_ops sun4i_drv_master_ops
= {
153 .bind
= sun4i_drv_bind
,
154 .unbind
= sun4i_drv_unbind
,
157 static bool sun4i_drv_node_is_connector(struct device_node
*node
)
159 return of_device_is_compatible(node
, "hdmi-connector");
162 static bool sun4i_drv_node_is_frontend(struct device_node
*node
)
164 return of_device_is_compatible(node
, "allwinner,sun4i-a10-display-frontend") ||
165 of_device_is_compatible(node
, "allwinner,sun5i-a13-display-frontend") ||
166 of_device_is_compatible(node
, "allwinner,sun6i-a31-display-frontend") ||
167 of_device_is_compatible(node
, "allwinner,sun7i-a20-display-frontend") ||
168 of_device_is_compatible(node
, "allwinner,sun8i-a23-display-frontend") ||
169 of_device_is_compatible(node
, "allwinner,sun8i-a33-display-frontend") ||
170 of_device_is_compatible(node
, "allwinner,sun9i-a80-display-frontend");
173 static bool sun4i_drv_node_is_deu(struct device_node
*node
)
175 return of_device_is_compatible(node
, "allwinner,sun9i-a80-deu");
178 static bool sun4i_drv_node_is_supported_frontend(struct device_node
*node
)
180 if (IS_ENABLED(CONFIG_DRM_SUN4I_BACKEND
))
181 return !!of_match_node(sun4i_frontend_of_table
, node
);
186 static bool sun4i_drv_node_is_tcon(struct device_node
*node
)
188 return !!of_match_node(sun4i_tcon_of_table
, node
);
191 static bool sun4i_drv_node_is_tcon_with_ch0(struct device_node
*node
)
193 const struct of_device_id
*match
;
195 match
= of_match_node(sun4i_tcon_of_table
, node
);
197 struct sun4i_tcon_quirks
*quirks
;
199 quirks
= (struct sun4i_tcon_quirks
*)match
->data
;
201 return quirks
->has_channel_0
;
207 static bool sun4i_drv_node_is_tcon_top(struct device_node
*node
)
209 return IS_ENABLED(CONFIG_DRM_SUN8I_TCON_TOP
) &&
210 !!of_match_node(sun8i_tcon_top_of_table
, node
);
213 static int compare_of(struct device
*dev
, void *data
)
215 DRM_DEBUG_DRIVER("Comparing of node %pOF with %pOF\n",
219 return dev
->of_node
== data
;
223 * The encoder drivers use drm_of_find_possible_crtcs to get upstream
224 * crtcs from the device tree using of_graph. For the results to be
225 * correct, encoders must be probed/bound after _all_ crtcs have been
226 * created. The existing code uses a depth first recursive traversal
227 * of the of_graph, which means the encoders downstream of the TCON
228 * get add right after the first TCON. The second TCON or CRTC will
229 * never be properly associated with encoders connected to it.
231 * Also, in a dual display pipeline setup, both frontends can feed
232 * either backend, and both backends can feed either TCON, we want
233 * all components of the same type to be added before the next type
234 * in the pipeline. Fortunately, the pipelines are perfectly symmetric,
235 * i.e. components of the same type are at the same depth when counted
236 * from the frontend. The only exception is the third pipeline in
237 * the A80 SoC, which we do not support anyway.
239 * Hence we can use a breadth first search traversal order to add
240 * components. We do not need to check for duplicates. The component
241 * matching system handles this for us.
243 struct endpoint_list
{
244 DECLARE_KFIFO(fifo
, struct device_node
*, 16);
247 static void sun4i_drv_traverse_endpoints(struct endpoint_list
*list
,
248 struct device_node
*node
,
251 struct device_node
*ep
, *remote
, *port
;
253 port
= of_graph_get_port_by_id(node
, port_id
);
255 DRM_DEBUG_DRIVER("No output to bind on port %d\n", port_id
);
259 for_each_available_child_of_node(port
, ep
) {
260 remote
= of_graph_get_remote_port_parent(ep
);
262 DRM_DEBUG_DRIVER("Error retrieving the output node\n");
266 if (sun4i_drv_node_is_tcon(node
)) {
268 * TCON TOP is always probed before TCON. However, TCON
269 * points back to TCON TOP when it is source for HDMI.
270 * We have to skip it here to prevent infinite looping
271 * between TCON TOP and TCON.
273 if (sun4i_drv_node_is_tcon_top(remote
)) {
274 DRM_DEBUG_DRIVER("TCON output endpoint is TCON TOP... skipping\n");
280 * If the node is our TCON with channel 0, the first
281 * port is used for panel or bridges, and will not be
282 * part of the component framework.
284 if (sun4i_drv_node_is_tcon_with_ch0(node
)) {
285 struct of_endpoint endpoint
;
287 if (of_graph_parse_endpoint(ep
, &endpoint
)) {
288 DRM_DEBUG_DRIVER("Couldn't parse endpoint\n");
294 DRM_DEBUG_DRIVER("Endpoint is our panel... skipping\n");
301 kfifo_put(&list
->fifo
, remote
);
305 static int sun4i_drv_add_endpoints(struct device
*dev
,
306 struct endpoint_list
*list
,
307 struct component_match
**match
,
308 struct device_node
*node
)
313 * The frontend has been disabled in some of our old device
314 * trees. If we find a node that is the frontend and is
315 * disabled, we should just follow through and parse its
316 * child, but without adding it to the component list.
317 * Otherwise, we obviously want to add it to the list.
319 if (!sun4i_drv_node_is_frontend(node
) &&
320 !of_device_is_available(node
))
324 * The connectors will be the last nodes in our pipeline, we
327 if (sun4i_drv_node_is_connector(node
))
331 * If the device is either just a regular device, or an
332 * enabled frontend supported by the driver, we add it to our
335 if (!(sun4i_drv_node_is_frontend(node
) ||
336 sun4i_drv_node_is_deu(node
)) ||
337 (sun4i_drv_node_is_supported_frontend(node
) &&
338 of_device_is_available(node
))) {
339 /* Add current component */
340 DRM_DEBUG_DRIVER("Adding component %pOF\n", node
);
341 drm_of_component_match_add(dev
, match
, compare_of
, node
);
345 /* each node has at least one output */
346 sun4i_drv_traverse_endpoints(list
, node
, 1);
348 /* TCON TOP has second and third output */
349 if (sun4i_drv_node_is_tcon_top(node
)) {
350 sun4i_drv_traverse_endpoints(list
, node
, 3);
351 sun4i_drv_traverse_endpoints(list
, node
, 5);
357 static int sun4i_drv_probe(struct platform_device
*pdev
)
359 struct component_match
*match
= NULL
;
360 struct device_node
*np
= pdev
->dev
.of_node
, *endpoint
;
361 struct endpoint_list list
;
362 int i
, ret
, count
= 0;
364 INIT_KFIFO(list
.fifo
);
367 struct device_node
*pipeline
= of_parse_phandle(np
,
368 "allwinner,pipelines",
373 kfifo_put(&list
.fifo
, pipeline
);
376 while (kfifo_get(&list
.fifo
, &endpoint
)) {
377 /* process this endpoint */
378 ret
= sun4i_drv_add_endpoints(&pdev
->dev
, &list
, &match
,
381 /* sun4i_drv_add_endpoints can fail to allocate memory */
389 return component_master_add_with_match(&pdev
->dev
,
390 &sun4i_drv_master_ops
,
396 static int sun4i_drv_remove(struct platform_device
*pdev
)
401 static const struct of_device_id sun4i_drv_of_table
[] = {
402 { .compatible
= "allwinner,sun4i-a10-display-engine" },
403 { .compatible
= "allwinner,sun5i-a10s-display-engine" },
404 { .compatible
= "allwinner,sun5i-a13-display-engine" },
405 { .compatible
= "allwinner,sun6i-a31-display-engine" },
406 { .compatible
= "allwinner,sun6i-a31s-display-engine" },
407 { .compatible
= "allwinner,sun7i-a20-display-engine" },
408 { .compatible
= "allwinner,sun8i-a23-display-engine" },
409 { .compatible
= "allwinner,sun8i-a33-display-engine" },
410 { .compatible
= "allwinner,sun8i-a83t-display-engine" },
411 { .compatible
= "allwinner,sun8i-h3-display-engine" },
412 { .compatible
= "allwinner,sun8i-r40-display-engine" },
413 { .compatible
= "allwinner,sun8i-v3s-display-engine" },
414 { .compatible
= "allwinner,sun9i-a80-display-engine" },
415 { .compatible
= "allwinner,sun50i-a64-display-engine" },
416 { .compatible
= "allwinner,sun50i-h6-display-engine" },
419 MODULE_DEVICE_TABLE(of
, sun4i_drv_of_table
);
421 static struct platform_driver sun4i_drv_platform_driver
= {
422 .probe
= sun4i_drv_probe
,
423 .remove
= sun4i_drv_remove
,
426 .of_match_table
= sun4i_drv_of_table
,
429 module_platform_driver(sun4i_drv_platform_driver
);
431 MODULE_AUTHOR("Boris Brezillon <boris.brezillon@free-electrons.com>");
432 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
433 MODULE_DESCRIPTION("Allwinner A10 Display Engine DRM/KMS Driver");
434 MODULE_LICENSE("GPL");