vbox_main.c@ 62489

Last change on this file since 62489 was 61431, checked in by vboxsync, 9 years ago
Additions/linux/drm: Linux 4.7 fixes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 17.8 KB

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

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

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

Download in other formats: