vbox_main.c@ 63803

Last change on this file since 63803 was 63771, checked in by vboxsync, 8 years ago
bugref:8584: HGSMISetHostGuestFlags() assertion: make the Linux vboxvideo driver report the host flags location to the host before enabling interrupts, as the host sets flags when sending interrupts.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 18.5 KB

Line
1	/* $Id: vbox_main.c 63771 2016-09-08 18:46:39Z vboxsync $ */
2	/** @file
3	* VirtualBox Additions Linux kernel video driver
4	*/
5
6	/*
7	* Copyright (C) 2013-2016 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 <[email protected]>
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	uint32_t vram_map_offset = vbox->available_vram_size - vbox->vram_map_start;
73
74	AssertLogRelReturnVoid(vbox->vbva_info != NULL);
75	for (i = 0; i < vbox->num_crtcs; ++i) {
76	if (vbox->vbva_info[i].pVBVA == NULL) {
77	LogFunc(("vboxvideo: enabling VBVA.\n"));
78	vbva = (struct VBVABUFFER ) ( ((uint8_t )vbox->mapped_vram)
79	+ vram_map_offset
80	+ i * VBVA_MIN_BUFFER_SIZE);
81	if (!VBoxVBVAEnable(&vbox->vbva_info[i], &vbox->submit_info, vbva, i))
82	AssertReleaseMsgFailed(("VBoxVBVAEnable failed - heap allocation error, very old host or driver error.\n"));
83	}
84	}
85	}
86
87	void vbox_disable_accel(struct vbox_private *vbox)
88	{
89	unsigned i;
90
91	for (i = 0; i < vbox->num_crtcs; ++i)
92	VBoxVBVADisable(&vbox->vbva_info[i], &vbox->submit_info, i);
93	}
94
95	void vbox_report_caps(struct vbox_private *vbox)
96	{
97	uint32_t caps = VBVACAPS_DISABLE_CURSOR_INTEGRATION
98	\| VBVACAPS_IRQ
99	\| VBVACAPS_USE_VBVA_ONLY;
100	if (vbox->initial_mode_queried)
101	caps \|= VBVACAPS_VIDEO_MODE_HINTS;
102	VBoxHGSMISendCapsInfo(&vbox->submit_info, caps);
103	}
104
105	/** Send information about dirty rectangles to VBVA. If necessary we enable
106	* VBVA first, as this is normally disabled after a change of master in case
107	* the new master does not send dirty rectangle information (is this even
108	* allowed?) */
109	void vbox_framebuffer_dirty_rectangles(struct drm_framebuffer *fb,
110	struct drm_clip_rect *rects,
111	unsigned num_rects)
112	{
113	struct vbox_private *vbox = fb->dev->dev_private;
114	struct drm_crtc *crtc;
115	unsigned i;
116
117	LogFunc(("vboxvideo: %d: fb=%p, num_rects=%u, vbox=%p\n", __LINE__, fb,
118	num_rects, vbox));
119	mutex_lock(&vbox->hw_mutex);
120	list_for_each_entry(crtc, &fb->dev->mode_config.crtc_list, head) {
121	if (CRTC_FB(crtc) == fb) {
122	vbox_enable_accel(vbox);
123	for (i = 0; i < num_rects; ++i)
124	{
125	unsigned crtc_id = to_vbox_crtc(crtc)->crtc_id;
126	VBVACMDHDR cmd_hdr;
127
128	if ( 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	}
149	mutex_unlock(&vbox->hw_mutex);
150	LogFunc(("vboxvideo: %d\n", __LINE__));
151	}
152
153	static int vbox_user_framebuffer_dirty(struct drm_framebuffer *fb,
154	struct drm_file *file_priv,
155	unsigned flags, unsigned color,
156	struct drm_clip_rect *rects,
157	unsigned num_rects)
158	{
159	vbox_framebuffer_dirty_rectangles(fb, rects, num_rects);
160	return 0;
161	}
162
163	static const struct drm_framebuffer_funcs vbox_fb_funcs = {
164	.destroy = vbox_user_framebuffer_destroy,
165	.dirty = vbox_user_framebuffer_dirty,
166	};
167
168
169	int vbox_framebuffer_init(struct drm_device *dev,
170	struct vbox_framebuffer *vbox_fb,
171	#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0)
172	const
173	#endif
174	struct DRM_MODE_FB_CMD *mode_cmd,
175	struct drm_gem_object *obj)
176	{
177	int ret;
178
179	LogFunc(("vboxvideo: %d: dev=%p, vbox_fb=%p, obj=%p\n", __LINE__, dev,
180	vbox_fb, obj));
181	drm_helper_mode_fill_fb_struct(&vbox_fb->base, mode_cmd);
182	vbox_fb->obj = obj;
183	ret = drm_framebuffer_init(dev, &vbox_fb->base, &vbox_fb_funcs);
184	if (ret) {
185	DRM_ERROR("framebuffer init failed %d\n", ret);
186	LogFunc(("vboxvideo: %d\n", __LINE__));
187	return ret;
188	}
189	LogFunc(("vboxvideo: %d\n", __LINE__));
190	return 0;
191	}
192
193	static struct drm_framebuffer *
194	vbox_user_framebuffer_create(struct drm_device *dev,
195	struct drm_file *filp,
196	#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0)
197	const
198	#endif
199	struct drm_mode_fb_cmd2 *mode_cmd)
200	{
201	struct drm_gem_object *obj;
202	struct vbox_framebuffer *vbox_fb;
203	int ret;
204
205	LogFunc(("vboxvideo: %d\n", __LINE__));
206	#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 7, 0)
207	obj = drm_gem_object_lookup(filp, mode_cmd->handles[0]);
208	#else
209	obj = drm_gem_object_lookup(dev, filp, mode_cmd->handles[0]);
210	#endif
211	if (obj == NULL)
212	return ERR_PTR(-ENOENT);
213
214	vbox_fb = kzalloc(sizeof(*vbox_fb), GFP_KERNEL);
215	if (!vbox_fb) {
216	drm_gem_object_unreference_unlocked(obj);
217	return ERR_PTR(-ENOMEM);
218	}
219
220	ret = vbox_framebuffer_init(dev, vbox_fb, mode_cmd, obj);
221	if (ret) {
222	drm_gem_object_unreference_unlocked(obj);
223	kfree(vbox_fb);
224	return ERR_PTR(ret);
225	}
226	LogFunc(("vboxvideo: %d\n", __LINE__));
227	return &vbox_fb->base;
228	}
229
230	static const struct drm_mode_config_funcs vbox_mode_funcs = {
231	.fb_create = vbox_user_framebuffer_create,
232	};
233
234	static void vbox_accel_fini(struct vbox_private *vbox)
235	{
236	if (vbox->vbva_info)
237	{
238	vbox_disable_accel(vbox);
239	kfree(vbox->vbva_info);
240	vbox->vbva_info = NULL;
241	}
242	}
243
244	static int vbox_accel_init(struct vbox_private *vbox)
245	{
246	unsigned i;
247	LogFunc(("vboxvideo: %d: vbox=%p, vbox->num_crtcs=%u, vbox->vbva_info=%p\n",
248	__LINE__, vbox, (unsigned)vbox->num_crtcs, vbox->vbva_info));
249	if (!vbox->vbva_info)
250	{
251	vbox->vbva_info = kzalloc( sizeof(struct VBVABUFFERCONTEXT)
252	* vbox->num_crtcs,
253	GFP_KERNEL);
254	if (!vbox->vbva_info)
255	return -ENOMEM;
256	}
257	/* Take a command buffer for each screen from the end of usable VRAM. */
258	vbox->available_vram_size -= vbox->num_crtcs * VBVA_MIN_BUFFER_SIZE;
259	for (i = 0; i < vbox->num_crtcs; ++i)
260	VBoxVBVASetupBufferContext(&vbox->vbva_info[i],
261	vbox->available_vram_size + i * VBVA_MIN_BUFFER_SIZE,
262	VBVA_MIN_BUFFER_SIZE);
263	LogFunc(("vboxvideo: %d: vbox->vbva_info=%p, vbox->available_vram_size=%u\n",
264	__LINE__, vbox->vbva_info, (unsigned)vbox->available_vram_size));
265	return 0;
266	}
267
268	/** Allocation function for the HGSMI heap and data. */
269	static DECLCALLBACK(void ) alloc_hgsmi_environ(void environ, HGSMISIZE size)
270	{
271	NOREF(environ);
272	return kmalloc(size, GFP_KERNEL);
273	}
274
275
276	/** Free function for the HGSMI heap and data. */
277	static DECLCALLBACK(void) free_hgsmi_environ(void environ, void ptr)
278	{
279	NOREF(environ);
280	kfree(ptr);
281	}
282
283
284	/** Pointers to the HGSMI heap and data manipulation functions. */
285	static HGSMIENV hgsmi_environ =
286	{
287	NULL,
288	alloc_hgsmi_environ,
289	free_hgsmi_environ
290	};
291
292
293	/** Do we support the 4.3 plus mode hint reporting interface? */
294	static bool have_hgsmi_mode_hints(struct vbox_private *vbox)
295	{
296	uint32_t have_hints, have_cursor;
297
298	return RT_SUCCESS(VBoxQueryConfHGSMI(&vbox->submit_info, VBOX_VBVA_CONF32_MODE_HINT_REPORTING, &have_hints))
299	&& RT_SUCCESS(VBoxQueryConfHGSMI(&vbox->submit_info, VBOX_VBVA_CONF32_GUEST_CURSOR_REPORTING, &have_cursor))
300	&& have_hints == VINF_SUCCESS
301	&& have_cursor == VINF_SUCCESS;
302	}
303
304	#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0)
305	# define pci_iomap_range(dev, bar, offset, maxlen) \
306	ioremap(pci_resource_start(dev, bar) + offset, maxlen)
307	#endif
308
309	/** Set up our heaps and data exchange buffers in VRAM before handing the rest
310	* to the memory manager. */
311	static int vbox_hw_init(struct vbox_private *vbox)
312	{
313	uint32_t base_offset, map_start, guest_heap_offset, guest_heap_size, host_flags_offset;
314	void *guest_heap;
315
316	vbox->full_vram_size = VBoxVideoGetVRAMSize();
317	vbox->any_pitch = VBoxVideoAnyWidthAllowed();
318	DRM_INFO("VRAM %08x\n", vbox->full_vram_size);
319	VBoxHGSMIGetBaseMappingInfo(vbox->full_vram_size, &base_offset, NULL,
320	&guest_heap_offset, &guest_heap_size, &host_flags_offset);
321	map_start = (uint32_t)max((int)base_offset
322	- VBOX_MAX_SCREENS * VBVA_MIN_BUFFER_SIZE, 0);
323	vbox->mapped_vram = pci_iomap_range(vbox->dev->pdev, 0, map_start,
324	vbox->full_vram_size - map_start);
325	if (!vbox->mapped_vram)
326	return -ENOMEM;
327	vbox->vram_map_start = map_start;
328	guest_heap = ((uint8_t *)vbox->mapped_vram) + base_offset - map_start
329	+ guest_heap_offset;
330	vbox->host_flags_offset = base_offset - map_start + host_flags_offset;
331	if (RT_FAILURE(VBoxHGSMISetupGuestContext(&vbox->submit_info, guest_heap,
332	guest_heap_size,
333	base_offset + guest_heap_offset,
334	&hgsmi_environ)))
335	return -ENOMEM;
336	/* Reduce available VRAM size to reflect the guest heap. */
337	vbox->available_vram_size = base_offset;
338	/* Linux drm represents monitors as a 32-bit array. */
339	vbox->num_crtcs = min(VBoxHGSMIGetMonitorCount(&vbox->submit_info),
340	(uint32_t)VBOX_MAX_SCREENS);
341	if (!have_hgsmi_mode_hints(vbox))
342	return -ENOTSUPP;
343	vbox->last_mode_hints = kzalloc(sizeof(VBVAMODEHINT) * vbox->num_crtcs, GFP_KERNEL);
344	if (!vbox->last_mode_hints)
345	return -ENOMEM;
346	return vbox_accel_init(vbox);
347	}
348
349	static void vbox_hw_fini(struct vbox_private *vbox)
350	{
351	vbox_accel_fini(vbox);
352	if (vbox->last_mode_hints)
353	kfree(vbox->last_mode_hints);
354	vbox->last_mode_hints = NULL;
355	}
356
357	int vbox_driver_load(struct drm_device *dev, unsigned long flags)
358	{
359	struct vbox_private *vbox;
360	int ret = 0;
361
362	LogFunc(("vboxvideo: %d: dev=%p\n", __LINE__, dev));
363	if (!VBoxHGSMIIsSupported())
364	return -ENODEV;
365	vbox = kzalloc(sizeof(struct vbox_private), GFP_KERNEL);
366	if (!vbox)
367	return -ENOMEM;
368
369	dev->dev_private = vbox;
370	vbox->dev = dev;
371
372	mutex_init(&vbox->hw_mutex);
373
374	ret = vbox_hw_init(vbox);
375	if (ret)
376	goto out_free;
377
378	ret = vbox_mm_init(vbox);
379	if (ret)
380	goto out_free;
381
382	drm_mode_config_init(dev);
383
384	dev->mode_config.funcs = (void *)&vbox_mode_funcs;
385	dev->mode_config.min_width = 64;
386	dev->mode_config.min_height = 64;
387	dev->mode_config.preferred_depth = 24;
388	dev->mode_config.max_width = VBE_DISPI_MAX_XRES;
389	dev->mode_config.max_height = VBE_DISPI_MAX_YRES;
390
391	ret = vbox_mode_init(dev);
392	if (ret)
393	goto out_free;
394
395	ret = vbox_irq_init(vbox);
396	if (ret)
397	goto out_free;
398
399	ret = vbox_fbdev_init(dev);
400	if (ret)
401	goto out_free;
402	LogFunc(("vboxvideo: %d: vbox=%p, vbox->mapped_vram=%p, vbox->full_vram_size=%u\n",
403	__LINE__, vbox, vbox->mapped_vram, (unsigned)vbox->full_vram_size));
404	return 0;
405	out_free:
406	vbox_driver_unload(dev);
407	LogFunc(("vboxvideo: %d: ret=%d\n", __LINE__, ret));
408	return ret;
409	}
410
411	int vbox_driver_unload(struct drm_device *dev)
412	{
413	struct vbox_private *vbox = dev->dev_private;
414
415	LogFunc(("vboxvideo: %d\n", __LINE__));
416	vbox_fbdev_fini(dev);
417	vbox_irq_fini(vbox);
418	vbox_mode_fini(dev);
419	if (dev->mode_config.funcs)
420	drm_mode_config_cleanup(dev);
421
422	vbox_hw_fini(vbox);
423	vbox_mm_fini(vbox);
424	if (vbox->mapped_vram)
425	pci_iounmap(dev->pdev, vbox->mapped_vram);
426	kfree(vbox);
427	dev->dev_private = NULL;
428	LogFunc(("vboxvideo: %d\n", __LINE__));
429	return 0;
430	}
431
432	/** @note this is described in the DRM framework documentation. AST does not
433	* have it, but we get an oops on driver unload if it is not present. */
434	void vbox_driver_lastclose(struct drm_device *dev)
435	{
436	struct vbox_private *vbox = dev->dev_private;
437
438	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 0)
439	if (vbox->fbdev)
440	drm_fb_helper_restore_fbdev_mode_unlocked(&vbox->fbdev->helper);
441	#else
442	drm_modeset_lock_all(dev);
443	if (vbox->fbdev)
444	drm_fb_helper_restore_fbdev_mode(&vbox->fbdev->helper);
445	drm_modeset_unlock_all(dev);
446	#endif
447	}
448
449	int vbox_gem_create(struct drm_device *dev,
450	u32 size, bool iskernel,
451	struct drm_gem_object **obj)
452	{
453	struct vbox_bo *vboxbo;
454	int ret;
455
456	LogFunc(("vboxvideo: %d: dev=%p, size=%u, iskernel=%u\n", __LINE__,
457	dev, (unsigned)size, (unsigned)iskernel));
458	*obj = NULL;
459
460	size = roundup(size, PAGE_SIZE);
461	if (size == 0)
462	return -EINVAL;
463
464	ret = vbox_bo_create(dev, size, 0, 0, &vboxbo);
465	if (ret) {
466	if (ret != -ERESTARTSYS)
467	DRM_ERROR("failed to allocate GEM object\n");
468	return ret;
469	}
470	*obj = &vboxbo->gem;
471	LogFunc(("vboxvideo: %d: obj=%p\n", __LINE__, obj));
472	return 0;
473	}
474
475	int vbox_dumb_create(struct drm_file *file,
476	struct drm_device *dev,
477	struct drm_mode_create_dumb *args)
478	{
479	int ret;
480	struct drm_gem_object *gobj;
481	u32 handle;
482
483	LogFunc(("vboxvideo: %d: args->width=%u, args->height=%u, args->bpp=%u\n",
484	__LINE__, (unsigned)args->width, (unsigned)args->height,
485	(unsigned)args->bpp));
486	args->pitch = args->width * ((args->bpp + 7) / 8);
487	args->size = args->pitch * args->height;
488
489	ret = vbox_gem_create(dev, args->size, false,
490	&gobj);
491	if (ret)
492	return ret;
493
494	ret = drm_gem_handle_create(file, gobj, &handle);
495	drm_gem_object_unreference_unlocked(gobj);
496	if (ret)
497	return ret;
498
499	args->handle = handle;
500	LogFunc(("vboxvideo: %d: args->handle=%u\n", __LINE__,
501	(unsigned)args->handle));
502	return 0;
503	}
504
505	#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 12, 0)
506	int vbox_dumb_destroy(struct drm_file *file,
507	struct drm_device *dev,
508	uint32_t handle)
509	{
510	LogFunc(("vboxvideo: %d: dev=%p, handle=%u\n", __LINE__, dev,
511	(unsigned)handle));
512	return drm_gem_handle_delete(file, handle);
513	}
514	#endif
515
516	static void vbox_bo_unref(struct vbox_bo **bo)
517	{
518	struct ttm_buffer_object *tbo;
519
520	if ((*bo) == NULL)
521	return;
522
523	LogFunc(("vboxvideo: %d: bo=%p\n", __LINE__, bo));
524	tbo = &((*bo)->bo);
525	ttm_bo_unref(&tbo);
526	if (tbo == NULL)
527	*bo = NULL;
528
529	}
530	void vbox_gem_free_object(struct drm_gem_object *obj)
531	{
532	struct vbox_bo *vbox_bo = gem_to_vbox_bo(obj);
533
534	LogFunc(("vboxvideo: %d: vbox_bo=%p\n", __LINE__, vbox_bo));
535	vbox_bo_unref(&vbox_bo);
536	}
537
538
539	static inline u64 vbox_bo_mmap_offset(struct vbox_bo *bo)
540	{
541	#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 12, 0)
542	return bo->bo.addr_space_offset;
543	#else
544	return drm_vma_node_offset_addr(&bo->bo.vma_node);
545	#endif
546	}
547	int
548	vbox_dumb_mmap_offset(struct drm_file *file,
549	struct drm_device *dev,
550	uint32_t handle,
551	uint64_t *offset)
552	{
553	struct drm_gem_object *obj;
554	int ret;
555	struct vbox_bo *bo;
556
557	LogFunc(("vboxvideo: %d: dev=%p, handle=%u\n", __LINE__,
558	dev, (unsigned)handle));
559	mutex_lock(&dev->struct_mutex);
560	#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 7, 0)
561	obj = drm_gem_object_lookup(file, handle);
562	#else
563	obj = drm_gem_object_lookup(dev, file, handle);
564	#endif
565	if (obj == NULL) {
566	ret = -ENOENT;
567	goto out_unlock;
568	}
569
570	bo = gem_to_vbox_bo(obj);
571	*offset = vbox_bo_mmap_offset(bo);
572
573	drm_gem_object_unreference(obj);
574	ret = 0;
575	LogFunc(("vboxvideo: %d: bo=%p, *offset=%llu\n", __LINE__,
576	bo, (unsigned long long)*offset));
577	out_unlock:
578	mutex_unlock(&dev->struct_mutex);
579	return ret;
580
581	}

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

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

Download in other formats: