1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * Copyright (C) 2015 Free Electrons
  4 * Copyright (C) 2015 NextThing Co
  5 *
  6 * Maxime Ripard <maxime.ripard@free-electrons.com>
  7 */
  8
  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>
 15
 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>
 24
 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"
 30
 31static int drm_sun4i_gem_dumb_create(struct drm_file *file_priv,
 32				     struct drm_device *drm,
 33				     struct drm_mode_create_dumb *args)
 34{
 35	/* The hardware only allows even pitches for YUV buffers. */
 36	args->pitch = ALIGN(DIV_ROUND_UP(args->width * args->bpp, 8), 2);
 37
 38	return drm_gem_cma_dumb_create_internal(file_priv, drm, args);
 39}
 40
 41DEFINE_DRM_GEM_CMA_FOPS(sun4i_drv_fops);
 42
 43static struct drm_driver sun4i_drv_driver = {
 44	.driver_features	= DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
 45
 46	/* Generic Operations */
 47	.fops			= &sun4i_drv_fops,
 48	.name			= "sun4i-drm",
 49	.desc			= "Allwinner sun4i Display Engine",
 50	.date			= "20150629",
 51	.major			= 1,
 52	.minor			= 0,
 53
 54	/* GEM Operations */
 55	DRM_GEM_CMA_DRIVER_OPS_VMAP_WITH_DUMB_CREATE(drm_sun4i_gem_dumb_create),
 56};
 57
 58static int sun4i_drv_bind(struct device *dev)
 59{
 60	struct drm_device *drm;
 61	struct sun4i_drv *drv;
 62	int ret;
 63
 64	drm = drm_dev_alloc(&sun4i_drv_driver, dev);
 65	if (IS_ERR(drm))
 66		return PTR_ERR(drm);
 67
 68	drv = devm_kzalloc(dev, sizeof(*drv), GFP_KERNEL);
 69	if (!drv) {
 70		ret = -ENOMEM;
 71		goto free_drm;
 72	}
 73
 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);
 79
 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");
 83		goto free_drm;
 84	}
 85
 86	drm_mode_config_init(drm);
 87
 88	ret = component_bind_all(drm->dev, drm);
 89	if (ret) {
 90		dev_err(drm->dev, "Couldn't bind all pipelines components\n");
 91		goto cleanup_mode_config;
 92	}
 93
 94	/* drm_vblank_init calls kcalloc, which can fail */
 95	ret = drm_vblank_init(drm, drm->mode_config.num_crtc);
 96	if (ret)
 97		goto cleanup_mode_config;
 98
 99	drm->irq_enabled = true;
100
101	/* Remove early framebuffers (ie. simplefb) */
102	drm_fb_helper_remove_conflicting_framebuffers(NULL, "sun4i-drm-fb", false);
103
104	sun4i_framebuffer_init(drm);
105
106	/* Enable connectors polling */
107	drm_kms_helper_poll_init(drm);
108
109	ret = drm_dev_register(drm, 0);
110	if (ret)
111		goto finish_poll;
112
113	drm_fbdev_generic_setup(drm, 32);
114
115	return 0;
116
117finish_poll:
118	drm_kms_helper_poll_fini(drm);
119cleanup_mode_config:
120	drm_mode_config_cleanup(drm);
121	of_reserved_mem_device_release(dev);
122free_drm:
123	drm_dev_put(drm);
124	return ret;
125}
126
127static void sun4i_drv_unbind(struct device *dev)
128{
129	struct drm_device *drm = dev_get_drvdata(dev);
130
131	drm_dev_unregister(drm);
132	drm_kms_helper_poll_fini(drm);
133	drm_atomic_helper_shutdown(drm);
134	drm_mode_config_cleanup(drm);
135
136	component_unbind_all(dev, NULL);
137	of_reserved_mem_device_release(dev);
138
139	drm_dev_put(drm);
140}
141
142static const struct component_master_ops sun4i_drv_master_ops = {
143	.bind	= sun4i_drv_bind,
144	.unbind	= sun4i_drv_unbind,
145};
146
147static bool sun4i_drv_node_is_connector(struct device_node *node)
148{
149	return of_device_is_compatible(node, "hdmi-connector");
150}
151
152static bool sun4i_drv_node_is_frontend(struct device_node *node)
153{
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");
161}
162
163static bool sun4i_drv_node_is_deu(struct device_node *node)
164{
165	return of_device_is_compatible(node, "allwinner,sun9i-a80-deu");
166}
167
168static bool sun4i_drv_node_is_supported_frontend(struct device_node *node)
169{
170	if (IS_ENABLED(CONFIG_DRM_SUN4I_BACKEND))
171		return !!of_match_node(sun4i_frontend_of_table, node);
172
173	return false;
174}
175
176static bool sun4i_drv_node_is_tcon(struct device_node *node)
177{
178	return !!of_match_node(sun4i_tcon_of_table, node);
179}
180
181static bool sun4i_drv_node_is_tcon_with_ch0(struct device_node *node)
182{
183	const struct of_device_id *match;
184
185	match = of_match_node(sun4i_tcon_of_table, node);
186	if (match) {
187		struct sun4i_tcon_quirks *quirks;
188
189		quirks = (struct sun4i_tcon_quirks *)match->data;
190
191		return quirks->has_channel_0;
192	}
193
194	return false;
195}
196
197static bool sun4i_drv_node_is_tcon_top(struct device_node *node)
198{
199	return IS_ENABLED(CONFIG_DRM_SUN8I_TCON_TOP) &&
200		!!of_match_node(sun8i_tcon_top_of_table, node);
201}
202
203static int compare_of(struct device *dev, void *data)
204{
205	DRM_DEBUG_DRIVER("Comparing of node %pOF with %pOF\n",
206			 dev->of_node,
207			 data);
208
209	return dev->of_node == data;
210}
211
212/*
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.
220 *
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.
228 *
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.
232 */
233struct endpoint_list {
234	DECLARE_KFIFO(fifo, struct device_node *, 16);
235};
236
237static void sun4i_drv_traverse_endpoints(struct endpoint_list *list,
238					 struct device_node *node,
239					 int port_id)
240{
241	struct device_node *ep, *remote, *port;
242
243	port = of_graph_get_port_by_id(node, port_id);
244	if (!port) {
245		DRM_DEBUG_DRIVER("No output to bind on port %d\n", port_id);
246		return;
247	}
248
249	for_each_available_child_of_node(port, ep) {
250		remote = of_graph_get_remote_port_parent(ep);
251		if (!remote) {
252			DRM_DEBUG_DRIVER("Error retrieving the output node\n");
253			continue;
254		}
255
256		if (sun4i_drv_node_is_tcon(node)) {
257			/*
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.
262			 */
263			if (sun4i_drv_node_is_tcon_top(remote)) {
264				DRM_DEBUG_DRIVER("TCON output endpoint is TCON TOP... skipping\n");
265				of_node_put(remote);
266				continue;
267			}
268
269			/*
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.
273			 */
274			if (sun4i_drv_node_is_tcon_with_ch0(node)) {
275				struct of_endpoint endpoint;
276
277				if (of_graph_parse_endpoint(ep, &endpoint)) {
278					DRM_DEBUG_DRIVER("Couldn't parse endpoint\n");
279					of_node_put(remote);
280					continue;
281				}
282
283				if (!endpoint.id) {
284					DRM_DEBUG_DRIVER("Endpoint is our panel... skipping\n");
285					of_node_put(remote);
286					continue;
287				}
288			}
289		}
290
291		kfifo_put(&list->fifo, remote);
292	}
293}
294
295static int sun4i_drv_add_endpoints(struct device *dev,
296				   struct endpoint_list *list,
297				   struct component_match **match,
298				   struct device_node *node)
299{
300	int count = 0;
301
302	/*
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.
308	 */
309	if (!sun4i_drv_node_is_frontend(node) &&
310	    !of_device_is_available(node))
311		return 0;
312
313	/*
314	 * The connectors will be the last nodes in our pipeline, we
315	 * can just bail out.
316	 */
317	if (sun4i_drv_node_is_connector(node))
318		return 0;
319
320	/*
321	 * If the device is either just a regular device, or an
322	 * enabled frontend supported by the driver, we add it to our
323	 * component list.
324	 */
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);
332		count++;
333	}
334
335	/* each node has at least one output */
336	sun4i_drv_traverse_endpoints(list, node, 1);
337
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);
342	}
343
344	return count;
345}
346
347#ifdef CONFIG_PM_SLEEP
348static int sun4i_drv_drm_sys_suspend(struct device *dev)
349{
350	struct drm_device *drm = dev_get_drvdata(dev);
351
352	return drm_mode_config_helper_suspend(drm);
353}
354
355static int sun4i_drv_drm_sys_resume(struct device *dev)
356{
357	struct drm_device *drm = dev_get_drvdata(dev);
358
359	return drm_mode_config_helper_resume(drm);
360}
361#endif
362
363static 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)
366};
367
368static int sun4i_drv_probe(struct platform_device *pdev)
369{
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;
374
375	INIT_KFIFO(list.fifo);
376
377	for (i = 0;; i++) {
378		struct device_node *pipeline = of_parse_phandle(np,
379								"allwinner,pipelines",
380								i);
381		if (!pipeline)
382			break;
383
384		kfifo_put(&list.fifo, pipeline);
385	}
386
387	while (kfifo_get(&list.fifo, &endpoint)) {
388		/* process this endpoint */
389		ret = sun4i_drv_add_endpoints(&pdev->dev, &list, &match,
390					      endpoint);
391
392		/* sun4i_drv_add_endpoints can fail to allocate memory */
393		if (ret < 0)
394			return ret;
395
396		count += ret;
397	}
398
399	if (count)
400		return component_master_add_with_match(&pdev->dev,
401						       &sun4i_drv_master_ops,
402						       match);
403	else
404		return 0;
405}
406
407static int sun4i_drv_remove(struct platform_device *pdev)
408{
409	component_master_del(&pdev->dev, &sun4i_drv_master_ops);
410
411	return 0;
412}
413
414static 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" },
430	{ }
431};
432MODULE_DEVICE_TABLE(of, sun4i_drv_of_table);
433
434static struct platform_driver sun4i_drv_platform_driver = {
435	.probe		= sun4i_drv_probe,
436	.remove		= sun4i_drv_remove,
437	.driver		= {
438		.name		= "sun4i-drm",
439		.of_match_table	= sun4i_drv_of_table,
440		.pm = &sun4i_drv_drm_pm_ops,
441	},
442};
443module_platform_driver(sun4i_drv_platform_driver);
444
445MODULE_AUTHOR("Boris Brezillon <boris.brezillon@free-electrons.com>");
446MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
447MODULE_DESCRIPTION("Allwinner A10 Display Engine DRM/KMS Driver");
448MODULE_LICENSE("GPL");