2 * Copyright (C) 2016 BayLibre, SAS
3 * Author: Neil Armstrong <narmstrong@baylibre.com>
4 * Copyright (C) 2014 Endless Mobile
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation; either version 2 of the
9 * License, or (at your option) any later version.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 * Jasper St. Pierre <jstpierre@mecheye.net>
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/mutex.h>
26 #include <linux/platform_device.h>
27 #include <linux/component.h>
28 #include <linux/of_graph.h>
31 #include <drm/drm_atomic.h>
32 #include <drm/drm_atomic_helper.h>
33 #include <drm/drm_flip_work.h>
34 #include <drm/drm_crtc_helper.h>
35 #include <drm/drm_plane_helper.h>
36 #include <drm/drm_gem_cma_helper.h>
37 #include <drm/drm_gem_framebuffer_helper.h>
38 #include <drm/drm_fb_cma_helper.h>
39 #include <drm/drm_rect.h>
40 #include <drm/drm_fb_helper.h>
42 #include "meson_drv.h"
43 #include "meson_plane.h"
44 #include "meson_crtc.h"
45 #include "meson_venc_cvbs.h"
47 #include "meson_vpp.h"
48 #include "meson_viu.h"
49 #include "meson_venc.h"
50 #include "meson_canvas.h"
51 #include "meson_registers.h"
53 #define DRIVER_NAME "meson"
54 #define DRIVER_DESC "Amlogic Meson DRM driver"
57 * DOC: Video Processing Unit
59 * VPU Handles the Global Video Processing, it includes management of the
60 * clocks gates, blocks reset lines and power domains.
64 * - Full reset of entire video processing HW blocks
65 * - Scaling and setup of the VPU clock
67 * - Powering up video processing HW blocks
68 * - Powering Up HDMI controller and PHY
71 static void meson_fb_output_poll_changed(struct drm_device
*dev
)
73 struct meson_drm
*priv
= dev
->dev_private
;
75 drm_fbdev_cma_hotplug_event(priv
->fbdev
);
78 static const struct drm_mode_config_funcs meson_mode_config_funcs
= {
79 .output_poll_changed
= meson_fb_output_poll_changed
,
80 .atomic_check
= drm_atomic_helper_check
,
81 .atomic_commit
= drm_atomic_helper_commit
,
82 .fb_create
= drm_gem_fb_create
,
85 static irqreturn_t
meson_irq(int irq
, void *arg
)
87 struct drm_device
*dev
= arg
;
88 struct meson_drm
*priv
= dev
->dev_private
;
90 (void)readl_relaxed(priv
->io_base
+ _REG(VENC_INTFLAG
));
97 DEFINE_DRM_GEM_CMA_FOPS(fops
);
99 static struct drm_driver meson_driver
= {
100 .driver_features
= DRIVER_HAVE_IRQ
| DRIVER_GEM
|
101 DRIVER_MODESET
| DRIVER_PRIME
|
105 .irq_handler
= meson_irq
,
108 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
109 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
110 .gem_prime_import
= drm_gem_prime_import
,
111 .gem_prime_export
= drm_gem_prime_export
,
112 .gem_prime_get_sg_table
= drm_gem_cma_prime_get_sg_table
,
113 .gem_prime_import_sg_table
= drm_gem_cma_prime_import_sg_table
,
114 .gem_prime_vmap
= drm_gem_cma_prime_vmap
,
115 .gem_prime_vunmap
= drm_gem_cma_prime_vunmap
,
116 .gem_prime_mmap
= drm_gem_cma_prime_mmap
,
119 .dumb_create
= drm_gem_cma_dumb_create
,
120 .gem_free_object_unlocked
= drm_gem_cma_free_object
,
121 .gem_vm_ops
= &drm_gem_cma_vm_ops
,
132 static bool meson_vpu_has_available_connectors(struct device
*dev
)
134 struct device_node
*ep
, *remote
;
136 /* Parses each endpoint and check if remote exists */
137 for_each_endpoint_of_node(dev
->of_node
, ep
) {
138 /* If the endpoint node exists, consider it enabled */
139 remote
= of_graph_get_remote_port(ep
);
147 static struct regmap_config meson_regmap_config
= {
151 .max_register
= 0x1000,
154 static void meson_vpu_init(struct meson_drm
*priv
)
156 writel_relaxed(0x210000, priv
->io_base
+ _REG(VPU_RDARB_MODE_L1C1
));
157 writel_relaxed(0x10000, priv
->io_base
+ _REG(VPU_RDARB_MODE_L1C2
));
158 writel_relaxed(0x900000, priv
->io_base
+ _REG(VPU_RDARB_MODE_L2C1
));
159 writel_relaxed(0x20000, priv
->io_base
+ _REG(VPU_WRARB_MODE_L2C1
));
162 static int meson_drv_bind_master(struct device
*dev
, bool has_components
)
164 struct platform_device
*pdev
= to_platform_device(dev
);
165 struct meson_drm
*priv
;
166 struct drm_device
*drm
;
167 struct resource
*res
;
171 /* Checks if an output connector is available */
172 if (!meson_vpu_has_available_connectors(dev
)) {
173 dev_err(dev
, "No output connector available\n");
177 drm
= drm_dev_alloc(&meson_driver
, dev
);
181 priv
= devm_kzalloc(dev
, sizeof(*priv
), GFP_KERNEL
);
186 drm
->dev_private
= priv
;
190 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, "vpu");
191 regs
= devm_ioremap_resource(dev
, res
);
197 priv
->io_base
= regs
;
199 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, "hhi");
204 /* Simply ioremap since it may be a shared register zone */
205 regs
= devm_ioremap(dev
, res
->start
, resource_size(res
));
207 ret
= -EADDRNOTAVAIL
;
211 priv
->hhi
= devm_regmap_init_mmio(dev
, regs
,
212 &meson_regmap_config
);
213 if (IS_ERR(priv
->hhi
)) {
214 dev_err(&pdev
->dev
, "Couldn't create the HHI regmap\n");
215 ret
= PTR_ERR(priv
->hhi
);
219 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, "dmc");
224 /* Simply ioremap since it may be a shared register zone */
225 regs
= devm_ioremap(dev
, res
->start
, resource_size(res
));
227 ret
= -EADDRNOTAVAIL
;
231 priv
->dmc
= devm_regmap_init_mmio(dev
, regs
,
232 &meson_regmap_config
);
233 if (IS_ERR(priv
->dmc
)) {
234 dev_err(&pdev
->dev
, "Couldn't create the DMC regmap\n");
235 ret
= PTR_ERR(priv
->dmc
);
239 priv
->vsync_irq
= platform_get_irq(pdev
, 0);
241 ret
= drm_vblank_init(drm
, 1);
245 drm_mode_config_init(drm
);
246 drm
->mode_config
.max_width
= 3840;
247 drm
->mode_config
.max_height
= 2160;
248 drm
->mode_config
.funcs
= &meson_mode_config_funcs
;
250 /* Hardware Initialization */
252 meson_vpu_init(priv
);
253 meson_venc_init(priv
);
254 meson_vpp_init(priv
);
255 meson_viu_init(priv
);
257 /* Encoder Initialization */
259 ret
= meson_venc_cvbs_create(priv
);
263 if (has_components
) {
264 ret
= component_bind_all(drm
->dev
, drm
);
266 dev_err(drm
->dev
, "Couldn't bind all components\n");
271 ret
= meson_plane_create(priv
);
275 ret
= meson_crtc_create(priv
);
279 ret
= drm_irq_install(drm
, priv
->vsync_irq
);
283 drm_mode_config_reset(drm
);
285 priv
->fbdev
= drm_fbdev_cma_init(drm
, 32,
286 drm
->mode_config
.num_connector
);
287 if (IS_ERR(priv
->fbdev
)) {
288 ret
= PTR_ERR(priv
->fbdev
);
292 drm_kms_helper_poll_init(drm
);
294 platform_set_drvdata(pdev
, priv
);
296 ret
= drm_dev_register(drm
, 0);
308 static int meson_drv_bind(struct device
*dev
)
310 return meson_drv_bind_master(dev
, true);
313 static void meson_drv_unbind(struct device
*dev
)
315 struct drm_device
*drm
= dev_get_drvdata(dev
);
316 struct meson_drm
*priv
= drm
->dev_private
;
318 drm_dev_unregister(drm
);
319 drm_kms_helper_poll_fini(drm
);
320 drm_fbdev_cma_fini(priv
->fbdev
);
321 drm_mode_config_cleanup(drm
);
326 static const struct component_master_ops meson_drv_master_ops
= {
327 .bind
= meson_drv_bind
,
328 .unbind
= meson_drv_unbind
,
331 static int compare_of(struct device
*dev
, void *data
)
333 DRM_DEBUG_DRIVER("Comparing of node %pOF with %pOF\n",
336 return dev
->of_node
== data
;
339 /* Possible connectors nodes to ignore */
340 static const struct of_device_id connectors_match
[] = {
341 { .compatible
= "composite-video-connector" },
342 { .compatible
= "svideo-connector" },
343 { .compatible
= "hdmi-connector" },
344 { .compatible
= "dvi-connector" },
348 static int meson_probe_remote(struct platform_device
*pdev
,
349 struct component_match
**match
,
350 struct device_node
*parent
,
351 struct device_node
*remote
)
353 struct device_node
*ep
, *remote_node
;
356 /* If node is a connector, return and do not add to match table */
357 if (of_match_node(connectors_match
, remote
))
360 component_match_add(&pdev
->dev
, match
, compare_of
, remote
);
362 for_each_endpoint_of_node(remote
, ep
) {
363 remote_node
= of_graph_get_remote_port_parent(ep
);
365 remote_node
== parent
|| /* Ignore parent endpoint */
366 !of_device_is_available(remote_node
))
369 count
+= meson_probe_remote(pdev
, match
, remote
, remote_node
);
371 of_node_put(remote_node
);
377 static int meson_drv_probe(struct platform_device
*pdev
)
379 struct component_match
*match
= NULL
;
380 struct device_node
*np
= pdev
->dev
.of_node
;
381 struct device_node
*ep
, *remote
;
384 for_each_endpoint_of_node(np
, ep
) {
385 remote
= of_graph_get_remote_port_parent(ep
);
386 if (!remote
|| !of_device_is_available(remote
))
389 count
+= meson_probe_remote(pdev
, &match
, np
, remote
);
393 return meson_drv_bind_master(&pdev
->dev
, false);
395 /* If some endpoints were found, initialize the nodes */
397 dev_info(&pdev
->dev
, "Queued %d outputs on vpu\n", count
);
399 return component_master_add_with_match(&pdev
->dev
,
400 &meson_drv_master_ops
,
404 /* If no output endpoints were available, simply bail out */
408 static const struct of_device_id dt_match
[] = {
409 { .compatible
= "amlogic,meson-gxbb-vpu" },
410 { .compatible
= "amlogic,meson-gxl-vpu" },
411 { .compatible
= "amlogic,meson-gxm-vpu" },
414 MODULE_DEVICE_TABLE(of
, dt_match
);
416 static struct platform_driver meson_drm_platform_driver
= {
417 .probe
= meson_drv_probe
,
420 .of_match_table
= dt_match
,
424 module_platform_driver(meson_drm_platform_driver
);
426 MODULE_AUTHOR("Jasper St. Pierre <jstpierre@mecheye.net>");
427 MODULE_AUTHOR("Neil Armstrong <narmstrong@baylibre.com>");
428 MODULE_DESCRIPTION(DRIVER_DESC
);
429 MODULE_LICENSE("GPL");