2 * Copyright (C) 2014-2015 Broadcom
3 * Copyright (C) 2013 Red Hat
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
10 #include <linux/clk.h>
11 #include <linux/component.h>
12 #include <linux/device.h>
14 #include <linux/module.h>
15 #include <linux/of_platform.h>
16 #include <linux/platform_device.h>
17 #include <linux/pm_runtime.h>
18 #include "drm_fb_cma_helper.h"
19 #include <drm/drm_fb_helper.h>
21 #include "uapi/drm/vc4_drm.h"
25 #define DRIVER_NAME "vc4"
26 #define DRIVER_DESC "Broadcom VC4 graphics"
27 #define DRIVER_DATE "20140616"
28 #define DRIVER_MAJOR 0
29 #define DRIVER_MINOR 0
30 #define DRIVER_PATCHLEVEL 0
32 /* Helper function for mapping the regs on a platform device. */
33 void __iomem
*vc4_ioremap_regs(struct platform_device
*dev
, int index
)
38 res
= platform_get_resource(dev
, IORESOURCE_MEM
, index
);
39 map
= devm_ioremap_resource(&dev
->dev
, res
);
41 DRM_ERROR("Failed to map registers: %ld\n", PTR_ERR(map
));
48 static int vc4_get_param_ioctl(struct drm_device
*dev
, void *data
,
49 struct drm_file
*file_priv
)
51 struct vc4_dev
*vc4
= to_vc4_dev(dev
);
52 struct drm_vc4_get_param
*args
= data
;
58 switch (args
->param
) {
59 case DRM_VC4_PARAM_V3D_IDENT0
:
60 ret
= pm_runtime_get_sync(&vc4
->v3d
->pdev
->dev
);
63 args
->value
= V3D_READ(V3D_IDENT0
);
64 pm_runtime_put(&vc4
->v3d
->pdev
->dev
);
66 case DRM_VC4_PARAM_V3D_IDENT1
:
67 ret
= pm_runtime_get_sync(&vc4
->v3d
->pdev
->dev
);
70 args
->value
= V3D_READ(V3D_IDENT1
);
71 pm_runtime_put(&vc4
->v3d
->pdev
->dev
);
73 case DRM_VC4_PARAM_V3D_IDENT2
:
74 ret
= pm_runtime_get_sync(&vc4
->v3d
->pdev
->dev
);
77 args
->value
= V3D_READ(V3D_IDENT2
);
78 pm_runtime_put(&vc4
->v3d
->pdev
->dev
);
80 case DRM_VC4_PARAM_SUPPORTS_BRANCHES
:
84 DRM_DEBUG("Unknown parameter %d\n", args
->param
);
91 static void vc4_lastclose(struct drm_device
*dev
)
93 struct vc4_dev
*vc4
= to_vc4_dev(dev
);
95 drm_fbdev_cma_restore_mode(vc4
->fbdev
);
98 static const struct file_operations vc4_drm_fops
= {
101 .release
= drm_release
,
102 .unlocked_ioctl
= drm_ioctl
,
107 .compat_ioctl
= drm_compat_ioctl
,
109 .llseek
= noop_llseek
,
112 static const struct drm_ioctl_desc vc4_drm_ioctls
[] = {
113 DRM_IOCTL_DEF_DRV(VC4_SUBMIT_CL
, vc4_submit_cl_ioctl
, DRM_RENDER_ALLOW
),
114 DRM_IOCTL_DEF_DRV(VC4_WAIT_SEQNO
, vc4_wait_seqno_ioctl
, DRM_RENDER_ALLOW
),
115 DRM_IOCTL_DEF_DRV(VC4_WAIT_BO
, vc4_wait_bo_ioctl
, DRM_RENDER_ALLOW
),
116 DRM_IOCTL_DEF_DRV(VC4_CREATE_BO
, vc4_create_bo_ioctl
, DRM_RENDER_ALLOW
),
117 DRM_IOCTL_DEF_DRV(VC4_MMAP_BO
, vc4_mmap_bo_ioctl
, DRM_RENDER_ALLOW
),
118 DRM_IOCTL_DEF_DRV(VC4_CREATE_SHADER_BO
, vc4_create_shader_bo_ioctl
, DRM_RENDER_ALLOW
),
119 DRM_IOCTL_DEF_DRV(VC4_GET_HANG_STATE
, vc4_get_hang_state_ioctl
,
121 DRM_IOCTL_DEF_DRV(VC4_GET_PARAM
, vc4_get_param_ioctl
, DRM_RENDER_ALLOW
),
124 static struct drm_driver vc4_drm_driver
= {
125 .driver_features
= (DRIVER_MODESET
|
131 .lastclose
= vc4_lastclose
,
132 .irq_handler
= vc4_irq
,
133 .irq_preinstall
= vc4_irq_preinstall
,
134 .irq_postinstall
= vc4_irq_postinstall
,
135 .irq_uninstall
= vc4_irq_uninstall
,
137 .enable_vblank
= vc4_enable_vblank
,
138 .disable_vblank
= vc4_disable_vblank
,
139 .get_vblank_counter
= drm_vblank_no_hw_counter
,
140 .get_scanout_position
= vc4_crtc_get_scanoutpos
,
141 .get_vblank_timestamp
= vc4_crtc_get_vblank_timestamp
,
143 #if defined(CONFIG_DEBUG_FS)
144 .debugfs_init
= vc4_debugfs_init
,
145 .debugfs_cleanup
= vc4_debugfs_cleanup
,
148 .gem_create_object
= vc4_create_object
,
149 .gem_free_object_unlocked
= vc4_free_object
,
150 .gem_vm_ops
= &drm_gem_cma_vm_ops
,
152 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
153 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
154 .gem_prime_import
= drm_gem_prime_import
,
155 .gem_prime_export
= vc4_prime_export
,
156 .gem_prime_get_sg_table
= drm_gem_cma_prime_get_sg_table
,
157 .gem_prime_import_sg_table
= drm_gem_cma_prime_import_sg_table
,
158 .gem_prime_vmap
= vc4_prime_vmap
,
159 .gem_prime_vunmap
= drm_gem_cma_prime_vunmap
,
160 .gem_prime_mmap
= vc4_prime_mmap
,
162 .dumb_create
= vc4_dumb_create
,
163 .dumb_map_offset
= drm_gem_cma_dumb_map_offset
,
164 .dumb_destroy
= drm_gem_dumb_destroy
,
166 .ioctls
= vc4_drm_ioctls
,
167 .num_ioctls
= ARRAY_SIZE(vc4_drm_ioctls
),
168 .fops
= &vc4_drm_fops
,
173 .major
= DRIVER_MAJOR
,
174 .minor
= DRIVER_MINOR
,
175 .patchlevel
= DRIVER_PATCHLEVEL
,
178 static int compare_dev(struct device
*dev
, void *data
)
183 static void vc4_match_add_drivers(struct device
*dev
,
184 struct component_match
**match
,
185 struct platform_driver
*const *drivers
,
190 for (i
= 0; i
< count
; i
++) {
191 struct device_driver
*drv
= &drivers
[i
]->driver
;
192 struct device
*p
= NULL
, *d
;
194 while ((d
= bus_find_device(&platform_bus_type
, p
, drv
,
195 (void *)platform_bus_type
.match
))) {
197 component_match_add(dev
, match
, compare_dev
, d
);
204 static void vc4_kick_out_firmware_fb(void)
206 struct apertures_struct
*ap
;
208 ap
= alloc_apertures(1);
212 /* Since VC4 is a UMA device, the simplefb node may have been
213 * located anywhere in memory.
215 ap
->ranges
[0].base
= 0;
216 ap
->ranges
[0].size
= ~0;
218 drm_fb_helper_remove_conflicting_framebuffers(ap
, "vc4drmfb", false);
222 static int vc4_drm_bind(struct device
*dev
)
224 struct platform_device
*pdev
= to_platform_device(dev
);
225 struct drm_device
*drm
;
229 dev
->coherent_dma_mask
= DMA_BIT_MASK(32);
231 vc4
= devm_kzalloc(dev
, sizeof(*vc4
), GFP_KERNEL
);
235 drm
= drm_dev_alloc(&vc4_drm_driver
, dev
);
238 platform_set_drvdata(pdev
, drm
);
240 drm
->dev_private
= vc4
;
242 vc4_bo_cache_init(drm
);
244 drm_mode_config_init(drm
);
248 ret
= component_bind_all(dev
, drm
);
252 vc4_kick_out_firmware_fb();
254 ret
= drm_dev_register(drm
, 0);
263 component_unbind_all(dev
, drm
);
265 vc4_gem_destroy(drm
);
267 vc4_bo_cache_destroy(drm
);
271 static void vc4_drm_unbind(struct device
*dev
)
273 struct platform_device
*pdev
= to_platform_device(dev
);
274 struct drm_device
*drm
= platform_get_drvdata(pdev
);
275 struct vc4_dev
*vc4
= to_vc4_dev(drm
);
278 drm_fbdev_cma_fini(vc4
->fbdev
);
280 drm_mode_config_cleanup(drm
);
285 static const struct component_master_ops vc4_drm_ops
= {
286 .bind
= vc4_drm_bind
,
287 .unbind
= vc4_drm_unbind
,
290 static struct platform_driver
*const component_drivers
[] = {
298 static int vc4_platform_drm_probe(struct platform_device
*pdev
)
300 struct component_match
*match
= NULL
;
301 struct device
*dev
= &pdev
->dev
;
303 vc4_match_add_drivers(dev
, &match
,
304 component_drivers
, ARRAY_SIZE(component_drivers
));
306 return component_master_add_with_match(dev
, &vc4_drm_ops
, match
);
309 static int vc4_platform_drm_remove(struct platform_device
*pdev
)
311 component_master_del(&pdev
->dev
, &vc4_drm_ops
);
316 static const struct of_device_id vc4_of_match
[] = {
317 { .compatible
= "brcm,bcm2835-vc4", },
320 MODULE_DEVICE_TABLE(of
, vc4_of_match
);
322 static struct platform_driver vc4_platform_driver
= {
323 .probe
= vc4_platform_drm_probe
,
324 .remove
= vc4_platform_drm_remove
,
327 .of_match_table
= vc4_of_match
,
331 static int __init
vc4_drm_register(void)
335 for (i
= 0; i
< ARRAY_SIZE(component_drivers
); i
++) {
336 ret
= platform_driver_register(component_drivers
[i
]);
339 platform_driver_unregister(component_drivers
[i
]);
343 return platform_driver_register(&vc4_platform_driver
);
346 static void __exit
vc4_drm_unregister(void)
350 for (i
= ARRAY_SIZE(component_drivers
) - 1; i
>= 0; i
--)
351 platform_driver_unregister(component_drivers
[i
]);
353 platform_driver_unregister(&vc4_platform_driver
);
356 module_init(vc4_drm_register
);
357 module_exit(vc4_drm_unregister
);
359 MODULE_ALIAS("platform:vc4-drm");
360 MODULE_DESCRIPTION("Broadcom VC4 DRM Driver");
361 MODULE_AUTHOR("Eric Anholt <eric@anholt.net>");
362 MODULE_LICENSE("GPL v2");