vbox_main.c@ 68297

Last change on this file since 68297 was 68297, checked in by vboxsync, 7 years ago
Additions/linux/drm: support custom EL7 Linux 3.10 kernel
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 13.8 KB

Line
1	/* $Id: vbox_main.c 68297 2017-08-04 10:25:39Z vboxsync $ */
2	/** @file
3	* VirtualBox Additions Linux kernel video driver
4	*/
5
6	/*
7	* Copyright (C) 2013-2017 Oracle Corporation
8	* This file is based on ast_main.c
9	* Copyright 2012 Red Hat Inc.
10	*
11	* Permission is hereby granted, free of charge, to any person obtaining a
12	* copy of this software and associated documentation files (the
13	* "Software"), to deal in the Software without restriction, including
14	* without limitation the rights to use, copy, modify, merge, publish,
15	* distribute, sub license, and/or sell copies of the Software, and to
16	* permit persons to whom the Software is furnished to do so, subject to
17	* the following conditions:
18	*
19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21	* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
22	* THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
23	* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
24	* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
25	* USE OR OTHER DEALINGS IN THE SOFTWARE.
26	*
27	* The above copyright notice and this permission notice (including the
28	* next paragraph) shall be included in all copies or substantial portions
29	* of the Software.
30	*
31	* Authors: Dave Airlie <[email protected]>,
32	* Michael Thayer <[email protected],
33	* Hans de Goede <[email protected]>
34	*/
35	#include "vbox_drv.h"
36
37	#include <VBoxVideoGuest.h>
38	#include <VBoxVideoVBE.h>
39
40	#include <drm/drm_fb_helper.h>
41	#include <drm/drm_crtc_helper.h>
42
43	static void vbox_user_framebuffer_destroy(struct drm_framebuffer *fb)
44	{
45	struct vbox_framebuffer *vbox_fb = to_vbox_framebuffer(fb);
46
47	if (vbox_fb->obj)
48	drm_gem_object_unreference_unlocked(vbox_fb->obj);
49
50	drm_framebuffer_cleanup(fb);
51	kfree(fb);
52	}
53
54	void vbox_enable_accel(struct vbox_private *vbox)
55	{
56	unsigned int i;
57	struct VBVABUFFER *vbva;
58
59	if (!vbox->vbva_info \|\| !vbox->vbva_buffers) {
60	/* Should never happen... */
61	DRM_ERROR("vboxvideo: failed to set up VBVA.\n");
62	return;
63	}
64
65	for (i = 0; i < vbox->num_crtcs; ++i) {
66	if (!vbox->vbva_info[i].pVBVA) {
67	vbva = (struct VBVABUFFER *)
68	((u8 *)vbox->vbva_buffers +
69	i * VBVA_MIN_BUFFER_SIZE);
70	if (!VBoxVBVAEnable(&vbox->vbva_info[i],
71	vbox->guest_pool, vbva, i)) {
72	/* very old host or driver error. */
73	DRM_ERROR("vboxvideo: VBoxVBVAEnable failed - heap allocation error.\n");
74	return;
75	}
76	}
77	}
78	}
79
80	void vbox_disable_accel(struct vbox_private *vbox)
81	{
82	unsigned int i;
83
84	for (i = 0; i < vbox->num_crtcs; ++i)
85	VBoxVBVADisable(&vbox->vbva_info[i], vbox->guest_pool, i);
86	}
87
88	void vbox_report_caps(struct vbox_private *vbox)
89	{
90	u32 caps = VBVACAPS_DISABLE_CURSOR_INTEGRATION
91	\| VBVACAPS_IRQ \| VBVACAPS_USE_VBVA_ONLY;
92	if (vbox->initial_mode_queried)
93	caps \|= VBVACAPS_VIDEO_MODE_HINTS;
94	VBoxHGSMISendCapsInfo(vbox->guest_pool, caps);
95	}
96
97	/**
98	* Send information about dirty rectangles to VBVA. If necessary we enable
99	* VBVA first, as this is normally disabled after a change of master in case
100	* the new master does not send dirty rectangle information (is this even
101	* allowed?)
102	*/
103	void vbox_framebuffer_dirty_rectangles(struct drm_framebuffer *fb,
104	struct drm_clip_rect *rects,
105	unsigned int num_rects)
106	{
107	struct vbox_private *vbox = fb->dev->dev_private;
108	struct drm_crtc *crtc;
109	unsigned int i;
110
111	mutex_lock(&vbox->hw_mutex);
112	list_for_each_entry(crtc, &fb->dev->mode_config.crtc_list, head) {
113	if (CRTC_FB(crtc) == fb) {
114	vbox_enable_accel(vbox);
115	for (i = 0; i < num_rects; ++i) {
116	VBVACMDHDR cmd_hdr;
117	unsigned int crtc_id =
118	to_vbox_crtc(crtc)->crtc_id;
119
120	if ((rects[i].x1 >
121	crtc->x + crtc->hwmode.hdisplay) \|\|
122	(rects[i].y1 >
123	crtc->y + crtc->hwmode.vdisplay) \|\|
124	(rects[i].x2 < crtc->x) \|\|
125	(rects[i].y2 < crtc->y))
126	continue;
127
128	cmd_hdr.x = (s16)rects[i].x1;
129	cmd_hdr.y = (s16)rects[i].y1;
130	cmd_hdr.w = (u16)rects[i].x2 - rects[i].x1;
131	cmd_hdr.h = (u16)rects[i].y2 - rects[i].y1;
132
133	if (VBoxVBVABufferBeginUpdate(
134	&vbox->vbva_info[crtc_id],
135	vbox->guest_pool)) {
136	VBoxVBVAWrite(&vbox->vbva_info[crtc_id],
137	vbox->guest_pool,
138	&cmd_hdr,
139	sizeof(cmd_hdr));
140	VBoxVBVABufferEndUpdate(
141	&vbox->vbva_info[crtc_id]);
142	}
143	}
144	}
145	}
146	mutex_unlock(&vbox->hw_mutex);
147	}
148
149	static int vbox_user_framebuffer_dirty(struct drm_framebuffer *fb,
150	struct drm_file *file_priv,
151	unsigned int flags, unsigned int color,
152	struct drm_clip_rect *rects,
153	unsigned int num_rects)
154	{
155	vbox_framebuffer_dirty_rectangles(fb, rects, num_rects);
156
157	return 0;
158	}
159
160	static const struct drm_framebuffer_funcs vbox_fb_funcs = {
161	.destroy = vbox_user_framebuffer_destroy,
162	.dirty = vbox_user_framebuffer_dirty,
163	};
164
165	int vbox_framebuffer_init(struct drm_device *dev,
166	struct vbox_framebuffer *vbox_fb,
167	#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0) \|\| defined(RHEL_7)
168	const
169	#endif
170	struct DRM_MODE_FB_CMD *mode_cmd,
171	struct drm_gem_object *obj)
172	{
173	int ret;
174
175	#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
176	drm_helper_mode_fill_fb_struct(dev, &vbox_fb->base, mode_cmd);
177	#else
178	drm_helper_mode_fill_fb_struct(&vbox_fb->base, mode_cmd);
179	#endif
180	vbox_fb->obj = obj;
181	ret = drm_framebuffer_init(dev, &vbox_fb->base, &vbox_fb_funcs);
182	if (ret) {
183	DRM_ERROR("framebuffer init failed %d\n", ret);
184	return ret;
185	}
186
187	return 0;
188	}
189
190	static struct drm_framebuffer *vbox_user_framebuffer_create(
191	struct drm_device *dev,
192	struct drm_file *filp,
193	#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0) \|\| defined(RHEL_7)
194	const struct drm_mode_fb_cmd2 *mode_cmd)
195	#else
196	struct drm_mode_fb_cmd2 *mode_cmd)
197	#endif
198	{
199	struct drm_gem_object *obj;
200	struct vbox_framebuffer *vbox_fb;
201	int ret;
202
203	#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 7, 0)
204	obj = drm_gem_object_lookup(filp, mode_cmd->handles[0]);
205	#else
206	obj = drm_gem_object_lookup(dev, filp, mode_cmd->handles[0]);
207	#endif
208	if (!obj)
209	return ERR_PTR(-ENOENT);
210
211	vbox_fb = kzalloc(sizeof(*vbox_fb), GFP_KERNEL);
212	if (!vbox_fb) {
213	drm_gem_object_unreference_unlocked(obj);
214	return ERR_PTR(-ENOMEM);
215	}
216
217	ret = vbox_framebuffer_init(dev, vbox_fb, mode_cmd, obj);
218	if (ret) {
219	drm_gem_object_unreference_unlocked(obj);
220	kfree(vbox_fb);
221	return ERR_PTR(ret);
222	}
223
224	return &vbox_fb->base;
225	}
226
227	static const struct drm_mode_config_funcs vbox_mode_funcs = {
228	.fb_create = vbox_user_framebuffer_create,
229	};
230
231	static void vbox_accel_fini(struct vbox_private *vbox)
232	{
233	if (vbox->vbva_info) {
234	vbox_disable_accel(vbox);
235	kfree(vbox->vbva_info);
236	vbox->vbva_info = NULL;
237	}
238	if (vbox->vbva_buffers) {
239	pci_iounmap(vbox->dev->pdev, vbox->vbva_buffers);
240	vbox->vbva_buffers = NULL;
241	}
242	}
243
244	#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0) && !defined(RHEL_7)
245	#define pci_iomap_range(dev, bar, offset, maxlen) \
246	ioremap(pci_resource_start(dev, bar) + (offset), maxlen)
247	#endif
248
249	static int vbox_accel_init(struct vbox_private *vbox)
250	{
251	unsigned int i;
252
253	vbox->vbva_info = kcalloc(vbox->num_crtcs, sizeof(*vbox->vbva_info),
254	GFP_KERNEL);
255	if (!vbox->vbva_info)
256	return -ENOMEM;
257
258	/* Take a command buffer for each screen from the end of usable VRAM. */
259	vbox->available_vram_size -= vbox->num_crtcs * VBVA_MIN_BUFFER_SIZE;
260
261	vbox->vbva_buffers = pci_iomap_range(vbox->dev->pdev, 0,
262	vbox->available_vram_size,
263	vbox->num_crtcs *
264	VBVA_MIN_BUFFER_SIZE);
265	if (!vbox->vbva_buffers)
266	return -ENOMEM;
267
268	for (i = 0; i < vbox->num_crtcs; ++i)
269	VBoxVBVASetupBufferContext(&vbox->vbva_info[i],
270	vbox->available_vram_size +
271	i * VBVA_MIN_BUFFER_SIZE,
272	VBVA_MIN_BUFFER_SIZE);
273
274	return 0;
275	}
276
277	/** Do we support the 4.3 plus mode hint reporting interface? */
278	static bool have_hgsmi_mode_hints(struct vbox_private *vbox)
279	{
280	u32 have_hints, have_cursor;
281	int ret;
282
283	ret = VBoxQueryConfHGSMI(vbox->guest_pool,
284	VBOX_VBVA_CONF32_MODE_HINT_REPORTING,
285	&have_hints);
286	if (RT_FAILURE(ret))
287	return false;
288
289	ret = VBoxQueryConfHGSMI(vbox->guest_pool,
290	VBOX_VBVA_CONF32_GUEST_CURSOR_REPORTING,
291	&have_cursor);
292	if (RT_FAILURE(ret))
293	return false;
294
295	return have_hints == VINF_SUCCESS && have_cursor == VINF_SUCCESS;
296	}
297
298	/**
299	* Set up our heaps and data exchange buffers in VRAM before handing the rest
300	* to the memory manager.
301	*/
302	static int vbox_hw_init(struct vbox_private *vbox)
303	{
304	int ret;
305
306	vbox->full_vram_size = VBoxVideoGetVRAMSize();
307	vbox->any_pitch = VBoxVideoAnyWidthAllowed();
308
309	DRM_INFO("VRAM %08x\n", vbox->full_vram_size);
310
311	/* Map guest-heap at end of vram */
312	vbox->guest_heap =
313	pci_iomap_range(vbox->dev->pdev, 0, GUEST_HEAP_OFFSET(vbox),
314	GUEST_HEAP_SIZE);
315	if (!vbox->guest_heap)
316	return -ENOMEM;
317
318	/* Create guest-heap mem-pool use 2^4 = 16 byte chunks */
319	vbox->guest_pool = gen_pool_create(4, -1);
320	if (!vbox->guest_pool)
321	return -ENOMEM;
322
323	ret = gen_pool_add_virt(vbox->guest_pool,
324	(unsigned long)vbox->guest_heap,
325	GUEST_HEAP_OFFSET(vbox),
326	GUEST_HEAP_USABLE_SIZE, -1);
327	if (ret)
328	return ret;
329
330	/* Reduce available VRAM size to reflect the guest heap. */
331	vbox->available_vram_size = GUEST_HEAP_OFFSET(vbox);
332	/* Linux drm represents monitors as a 32-bit array. */
333	vbox->num_crtcs = min_t(u32, VBoxHGSMIGetMonitorCount(vbox->guest_pool),
334	VBOX_MAX_SCREENS);
335
336	if (!have_hgsmi_mode_hints(vbox))
337	return -ENOTSUPP;
338
339	vbox->last_mode_hints =
340	kcalloc(vbox->num_crtcs, sizeof(VBVAMODEHINT), GFP_KERNEL);
341	if (!vbox->last_mode_hints)
342	return -ENOMEM;
343
344	return vbox_accel_init(vbox);
345	}
346
347	static void vbox_hw_fini(struct vbox_private *vbox)
348	{
349	vbox_accel_fini(vbox);
350	kfree(vbox->last_mode_hints);
351	vbox->last_mode_hints = NULL;
352	}
353
354	int vbox_driver_load(struct drm_device *dev, unsigned long flags)
355	{
356	struct vbox_private *vbox;
357	int ret = 0;
358
359	if (!VBoxHGSMIIsSupported())
360	return -ENODEV;
361
362	vbox = kzalloc(sizeof(*vbox), GFP_KERNEL);
363	if (!vbox)
364	return -ENOMEM;
365
366	dev->dev_private = vbox;
367	vbox->dev = dev;
368
369	mutex_init(&vbox->hw_mutex);
370
371	ret = vbox_hw_init(vbox);
372	if (ret)
373	goto out_free;
374
375	ret = vbox_mm_init(vbox);
376	if (ret)
377	goto out_free;
378
379	drm_mode_config_init(dev);
380
381	dev->mode_config.funcs = (void *)&vbox_mode_funcs;
382	dev->mode_config.min_width = 64;
383	dev->mode_config.min_height = 64;
384	dev->mode_config.preferred_depth = 24;
385	dev->mode_config.max_width = VBE_DISPI_MAX_XRES;
386	dev->mode_config.max_height = VBE_DISPI_MAX_YRES;
387
388	ret = vbox_mode_init(dev);
389	if (ret)
390	goto out_free;
391
392	ret = vbox_irq_init(vbox);
393	if (ret)
394	goto out_free;
395
396	ret = vbox_fbdev_init(dev);
397	if (ret)
398	goto out_free;
399
400	return 0;
401
402	out_free:
403	vbox_driver_unload(dev);
404	return ret;
405	}
406
407	#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
408	void vbox_driver_unload(struct drm_device *dev)
409	#else
410	int vbox_driver_unload(struct drm_device *dev)
411	#endif
412	{
413	struct vbox_private *vbox = dev->dev_private;
414
415	vbox_fbdev_fini(dev);
416	vbox_irq_fini(vbox);
417	vbox_mode_fini(dev);
418	if (dev->mode_config.funcs)
419	drm_mode_config_cleanup(dev);
420
421	vbox_hw_fini(vbox);
422	vbox_mm_fini(vbox);
423	if (vbox->guest_pool)
424	gen_pool_destroy(vbox->guest_pool);
425	if (vbox->guest_heap)
426	pci_iounmap(dev->pdev, vbox->guest_heap);
427	kfree(vbox);
428	dev->dev_private = NULL;
429	#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 11, 0)
430	return 0;
431	#endif
432	}
433
434	/**
435	* @note this is described in the DRM framework documentation. AST does not
436	* have it, but we get an oops on driver unload if it is not present.
437	*/
438	void vbox_driver_lastclose(struct drm_device *dev)
439	{
440	struct vbox_private *vbox = dev->dev_private;
441
442	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 0) \|\| defined(RHEL_7)
443	if (vbox->fbdev)
444	drm_fb_helper_restore_fbdev_mode_unlocked(&vbox->fbdev->helper);
445	#else
446	drm_modeset_lock_all(dev);
447	if (vbox->fbdev)
448	drm_fb_helper_restore_fbdev_mode(&vbox->fbdev->helper);
449	drm_modeset_unlock_all(dev);
450	#endif
451	}
452
453	int vbox_gem_create(struct drm_device *dev,
454	u32 size, bool iskernel, struct drm_gem_object **obj)
455	{
456	struct vbox_bo *vboxbo;
457	int ret;
458
459	*obj = NULL;
460
461	size = roundup(size, PAGE_SIZE);
462	if (size == 0)
463	return -EINVAL;
464
465	ret = vbox_bo_create(dev, size, 0, 0, &vboxbo);
466	if (ret) {
467	if (ret != -ERESTARTSYS)
468	DRM_ERROR("failed to allocate GEM object\n");
469	return ret;
470	}
471
472	*obj = &vboxbo->gem;
473
474	return 0;
475	}
476
477	int vbox_dumb_create(struct drm_file *file,
478	struct drm_device dev, struct drm_mode_create_dumb args)
479	{
480	int ret;
481	struct drm_gem_object *gobj;
482	u32 handle;
483
484	args->pitch = args->width * ((args->bpp + 7) / 8);
485	args->size = args->pitch * args->height;
486
487	ret = vbox_gem_create(dev, args->size, false, &gobj);
488	if (ret)
489	return ret;
490
491	ret = drm_gem_handle_create(file, gobj, &handle);
492	drm_gem_object_unreference_unlocked(gobj);
493	if (ret)
494	return ret;
495
496	args->handle = handle;
497
498	return 0;
499	}
500
501	#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 12, 0) && !defined(RHEL_7)
502	int vbox_dumb_destroy(struct drm_file *file,
503	struct drm_device *dev, u32 handle)
504	{
505	return drm_gem_handle_delete(file, handle);
506	}
507	#endif
508
509	static void vbox_bo_unref(struct vbox_bo **bo)
510	{
511	struct ttm_buffer_object *tbo;
512
513	if ((*bo) == NULL)
514	return;
515
516	tbo = &((*bo)->bo);
517	ttm_bo_unref(&tbo);
518	if (!tbo)
519	*bo = NULL;
520	}
521
522	void vbox_gem_free_object(struct drm_gem_object *obj)
523	{
524	struct vbox_bo *vbox_bo = gem_to_vbox_bo(obj);
525
526	vbox_bo_unref(&vbox_bo);
527	}
528
529	static inline u64 vbox_bo_mmap_offset(struct vbox_bo *bo)
530	{
531	#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 12, 0) && !defined(RHEL_7)
532	return bo->bo.addr_space_offset;
533	#else
534	return drm_vma_node_offset_addr(&bo->bo.vma_node);
535	#endif
536	}
537
538	int
539	vbox_dumb_mmap_offset(struct drm_file *file,
540	struct drm_device *dev,
541	u32 handle, u64 *offset)
542	{
543	struct drm_gem_object *obj;
544	int ret;
545	struct vbox_bo *bo;
546
547	mutex_lock(&dev->struct_mutex);
548	#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 7, 0)
549	obj = drm_gem_object_lookup(file, handle);
550	#else
551	obj = drm_gem_object_lookup(dev, file, handle);
552	#endif
553	if (!obj) {
554	ret = -ENOENT;
555	goto out_unlock;
556	}
557
558	bo = gem_to_vbox_bo(obj);
559	*offset = vbox_bo_mmap_offset(bo);
560
561	drm_gem_object_unreference(obj);
562	ret = 0;
563
564	out_unlock:
565	mutex_unlock(&dev->struct_mutex);
566	return ret;
567	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/linux/drm/vbox_main.c@ 68297

Download in other formats: