1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2014-2015 Broadcom
4 * Copyright (C) 2013 Red Hat
8 * DOC: Broadcom VC4 Graphics Driver
10 * The Broadcom VideoCore 4 (present in the Raspberry Pi) contains a
11 * OpenGL ES 2.0-compatible 3D engine called V3D, and a highly
12 * configurable display output pipeline that supports HDMI, DSI, DPI,
13 * and Composite TV output.
15 * The 3D engine also has an interface for submitting arbitrary
16 * compute shader-style jobs using the same shader processor as is
17 * used for vertex and fragment shaders in GLES 2.0. However, given
18 * that the hardware isn't able to expose any standard interfaces like
19 * OpenGL compute shaders or OpenCL, it isn't supported by this
23 #include <linux/clk.h>
24 #include <linux/component.h>
25 #include <linux/device.h>
26 #include <linux/dma-mapping.h>
28 #include <linux/module.h>
29 #include <linux/of_platform.h>
30 #include <linux/platform_device.h>
31 #include <linux/pm_runtime.h>
33 #include <drm/drm_atomic_helper.h>
34 #include <drm/drm_drv.h>
35 #include <drm/drm_fb_cma_helper.h>
36 #include <drm/drm_fb_helper.h>
37 #include <drm/drm_vblank.h>
39 #include "uapi/drm/vc4_drm.h"
44 #define DRIVER_NAME "vc4"
45 #define DRIVER_DESC "Broadcom VC4 graphics"
46 #define DRIVER_DATE "20140616"
47 #define DRIVER_MAJOR 0
48 #define DRIVER_MINOR 0
49 #define DRIVER_PATCHLEVEL 0
51 /* Helper function for mapping the regs on a platform device. */
52 void __iomem
*vc4_ioremap_regs(struct platform_device
*dev
, int index
)
57 res
= platform_get_resource(dev
, IORESOURCE_MEM
, index
);
58 map
= devm_ioremap_resource(&dev
->dev
, res
);
60 DRM_ERROR("Failed to map registers: %ld\n", PTR_ERR(map
));
67 static int vc4_get_param_ioctl(struct drm_device
*dev
, void *data
,
68 struct drm_file
*file_priv
)
70 struct vc4_dev
*vc4
= to_vc4_dev(dev
);
71 struct drm_vc4_get_param
*args
= data
;
80 switch (args
->param
) {
81 case DRM_VC4_PARAM_V3D_IDENT0
:
82 ret
= vc4_v3d_pm_get(vc4
);
85 args
->value
= V3D_READ(V3D_IDENT0
);
88 case DRM_VC4_PARAM_V3D_IDENT1
:
89 ret
= vc4_v3d_pm_get(vc4
);
92 args
->value
= V3D_READ(V3D_IDENT1
);
95 case DRM_VC4_PARAM_V3D_IDENT2
:
96 ret
= vc4_v3d_pm_get(vc4
);
99 args
->value
= V3D_READ(V3D_IDENT2
);
102 case DRM_VC4_PARAM_SUPPORTS_BRANCHES
:
103 case DRM_VC4_PARAM_SUPPORTS_ETC1
:
104 case DRM_VC4_PARAM_SUPPORTS_THREADED_FS
:
105 case DRM_VC4_PARAM_SUPPORTS_FIXED_RCL_ORDER
:
106 case DRM_VC4_PARAM_SUPPORTS_MADVISE
:
107 case DRM_VC4_PARAM_SUPPORTS_PERFMON
:
111 DRM_DEBUG("Unknown parameter %d\n", args
->param
);
118 static int vc4_open(struct drm_device
*dev
, struct drm_file
*file
)
120 struct vc4_file
*vc4file
;
122 vc4file
= kzalloc(sizeof(*vc4file
), GFP_KERNEL
);
126 vc4_perfmon_open_file(vc4file
);
127 file
->driver_priv
= vc4file
;
131 static void vc4_close(struct drm_device
*dev
, struct drm_file
*file
)
133 struct vc4_dev
*vc4
= to_vc4_dev(dev
);
134 struct vc4_file
*vc4file
= file
->driver_priv
;
136 if (vc4file
->bin_bo_used
)
137 vc4_v3d_bin_bo_put(vc4
);
139 vc4_perfmon_close_file(vc4file
);
143 static const struct vm_operations_struct vc4_vm_ops
= {
145 .open
= drm_gem_vm_open
,
146 .close
= drm_gem_vm_close
,
149 static const struct file_operations vc4_drm_fops
= {
150 .owner
= THIS_MODULE
,
152 .release
= drm_release
,
153 .unlocked_ioctl
= drm_ioctl
,
157 .compat_ioctl
= drm_compat_ioctl
,
158 .llseek
= noop_llseek
,
161 static const struct drm_ioctl_desc vc4_drm_ioctls
[] = {
162 DRM_IOCTL_DEF_DRV(VC4_SUBMIT_CL
, vc4_submit_cl_ioctl
, DRM_RENDER_ALLOW
),
163 DRM_IOCTL_DEF_DRV(VC4_WAIT_SEQNO
, vc4_wait_seqno_ioctl
, DRM_RENDER_ALLOW
),
164 DRM_IOCTL_DEF_DRV(VC4_WAIT_BO
, vc4_wait_bo_ioctl
, DRM_RENDER_ALLOW
),
165 DRM_IOCTL_DEF_DRV(VC4_CREATE_BO
, vc4_create_bo_ioctl
, DRM_RENDER_ALLOW
),
166 DRM_IOCTL_DEF_DRV(VC4_MMAP_BO
, vc4_mmap_bo_ioctl
, DRM_RENDER_ALLOW
),
167 DRM_IOCTL_DEF_DRV(VC4_CREATE_SHADER_BO
, vc4_create_shader_bo_ioctl
, DRM_RENDER_ALLOW
),
168 DRM_IOCTL_DEF_DRV(VC4_GET_HANG_STATE
, vc4_get_hang_state_ioctl
,
170 DRM_IOCTL_DEF_DRV(VC4_GET_PARAM
, vc4_get_param_ioctl
, DRM_RENDER_ALLOW
),
171 DRM_IOCTL_DEF_DRV(VC4_SET_TILING
, vc4_set_tiling_ioctl
, DRM_RENDER_ALLOW
),
172 DRM_IOCTL_DEF_DRV(VC4_GET_TILING
, vc4_get_tiling_ioctl
, DRM_RENDER_ALLOW
),
173 DRM_IOCTL_DEF_DRV(VC4_LABEL_BO
, vc4_label_bo_ioctl
, DRM_RENDER_ALLOW
),
174 DRM_IOCTL_DEF_DRV(VC4_GEM_MADVISE
, vc4_gem_madvise_ioctl
, DRM_RENDER_ALLOW
),
175 DRM_IOCTL_DEF_DRV(VC4_PERFMON_CREATE
, vc4_perfmon_create_ioctl
, DRM_RENDER_ALLOW
),
176 DRM_IOCTL_DEF_DRV(VC4_PERFMON_DESTROY
, vc4_perfmon_destroy_ioctl
, DRM_RENDER_ALLOW
),
177 DRM_IOCTL_DEF_DRV(VC4_PERFMON_GET_VALUES
, vc4_perfmon_get_values_ioctl
, DRM_RENDER_ALLOW
),
180 static struct drm_driver vc4_drm_driver
= {
181 .driver_features
= (DRIVER_MODESET
|
187 .postclose
= vc4_close
,
188 .irq_handler
= vc4_irq
,
189 .irq_preinstall
= vc4_irq_preinstall
,
190 .irq_postinstall
= vc4_irq_postinstall
,
191 .irq_uninstall
= vc4_irq_uninstall
,
193 #if defined(CONFIG_DEBUG_FS)
194 .debugfs_init
= vc4_debugfs_init
,
197 .gem_create_object
= vc4_create_object
,
198 .gem_free_object_unlocked
= vc4_free_object
,
199 .gem_vm_ops
= &vc4_vm_ops
,
201 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
202 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
203 .gem_prime_export
= vc4_prime_export
,
204 .gem_prime_get_sg_table
= drm_gem_cma_prime_get_sg_table
,
205 .gem_prime_import_sg_table
= vc4_prime_import_sg_table
,
206 .gem_prime_vmap
= vc4_prime_vmap
,
207 .gem_prime_vunmap
= drm_gem_cma_prime_vunmap
,
208 .gem_prime_mmap
= vc4_prime_mmap
,
210 .dumb_create
= vc4_dumb_create
,
212 .ioctls
= vc4_drm_ioctls
,
213 .num_ioctls
= ARRAY_SIZE(vc4_drm_ioctls
),
214 .fops
= &vc4_drm_fops
,
219 .major
= DRIVER_MAJOR
,
220 .minor
= DRIVER_MINOR
,
221 .patchlevel
= DRIVER_PATCHLEVEL
,
224 static int compare_dev(struct device
*dev
, void *data
)
229 static void vc4_match_add_drivers(struct device
*dev
,
230 struct component_match
**match
,
231 struct platform_driver
*const *drivers
,
236 for (i
= 0; i
< count
; i
++) {
237 struct device_driver
*drv
= &drivers
[i
]->driver
;
238 struct device
*p
= NULL
, *d
;
240 while ((d
= platform_find_device_by_driver(p
, drv
))) {
242 component_match_add(dev
, match
, compare_dev
, d
);
249 static int vc4_drm_bind(struct device
*dev
)
251 struct platform_device
*pdev
= to_platform_device(dev
);
252 struct drm_device
*drm
;
254 struct device_node
*node
;
257 dev
->coherent_dma_mask
= DMA_BIT_MASK(32);
259 vc4
= devm_kzalloc(dev
, sizeof(*vc4
), GFP_KERNEL
);
263 /* If VC4 V3D is missing, don't advertise render nodes. */
264 node
= of_find_matching_node_and_match(NULL
, vc4_v3d_dt_match
, NULL
);
265 if (!node
|| !of_device_is_available(node
))
266 vc4_drm_driver
.driver_features
&= ~DRIVER_RENDER
;
269 drm
= drm_dev_alloc(&vc4_drm_driver
, dev
);
272 platform_set_drvdata(pdev
, drm
);
274 drm
->dev_private
= vc4
;
275 INIT_LIST_HEAD(&vc4
->debugfs_list
);
277 mutex_init(&vc4
->bin_bo_lock
);
279 ret
= vc4_bo_cache_init(drm
);
283 drm_mode_config_init(drm
);
287 ret
= component_bind_all(dev
, drm
);
291 ret
= vc4_plane_create_additional_planes(drm
);
295 drm_fb_helper_remove_conflicting_framebuffers(NULL
, "vc4drmfb", false);
297 ret
= vc4_kms_load(drm
);
301 ret
= drm_dev_register(drm
, 0);
305 drm_fbdev_generic_setup(drm
, 16);
310 component_unbind_all(dev
, drm
);
312 vc4_gem_destroy(drm
);
313 vc4_bo_cache_destroy(drm
);
319 static void vc4_drm_unbind(struct device
*dev
)
321 struct drm_device
*drm
= dev_get_drvdata(dev
);
322 struct vc4_dev
*vc4
= to_vc4_dev(drm
);
324 drm_dev_unregister(drm
);
326 drm_atomic_helper_shutdown(drm
);
328 drm_mode_config_cleanup(drm
);
330 drm_atomic_private_obj_fini(&vc4
->load_tracker
);
331 drm_atomic_private_obj_fini(&vc4
->ctm_manager
);
336 static const struct component_master_ops vc4_drm_ops
= {
337 .bind
= vc4_drm_bind
,
338 .unbind
= vc4_drm_unbind
,
341 static struct platform_driver
*const component_drivers
[] = {
352 static int vc4_platform_drm_probe(struct platform_device
*pdev
)
354 struct component_match
*match
= NULL
;
355 struct device
*dev
= &pdev
->dev
;
357 vc4_match_add_drivers(dev
, &match
,
358 component_drivers
, ARRAY_SIZE(component_drivers
));
360 return component_master_add_with_match(dev
, &vc4_drm_ops
, match
);
363 static int vc4_platform_drm_remove(struct platform_device
*pdev
)
365 component_master_del(&pdev
->dev
, &vc4_drm_ops
);
370 static const struct of_device_id vc4_of_match
[] = {
371 { .compatible
= "brcm,bcm2835-vc4", },
372 { .compatible
= "brcm,cygnus-vc4", },
375 MODULE_DEVICE_TABLE(of
, vc4_of_match
);
377 static struct platform_driver vc4_platform_driver
= {
378 .probe
= vc4_platform_drm_probe
,
379 .remove
= vc4_platform_drm_remove
,
382 .of_match_table
= vc4_of_match
,
386 static int __init
vc4_drm_register(void)
390 ret
= platform_register_drivers(component_drivers
,
391 ARRAY_SIZE(component_drivers
));
395 return platform_driver_register(&vc4_platform_driver
);
398 static void __exit
vc4_drm_unregister(void)
400 platform_unregister_drivers(component_drivers
,
401 ARRAY_SIZE(component_drivers
));
402 platform_driver_unregister(&vc4_platform_driver
);
405 module_init(vc4_drm_register
);
406 module_exit(vc4_drm_unregister
);
408 MODULE_ALIAS("platform:vc4-drm");
409 MODULE_DESCRIPTION("Broadcom VC4 DRM Driver");
410 MODULE_AUTHOR("Eric Anholt <eric@anholt.net>");
411 MODULE_LICENSE("GPL v2");