projects/linux·blob master · refs

362 lines · 8.8 KiB

1/*
2 * Copyright (C) 2015 Red Hat, Inc.
3 * All Rights Reserved.
4 *
5 * Authors:
6 * Dave Airlie <[email protected]>
7 * Gerd Hoffmann <[email protected]>
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice (including the next
17 * paragraph) shall be included in all copies or substantial portions of the
18 * Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
24 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
25 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
26 * OTHER DEALINGS IN THE SOFTWARE.
27 */
28
29#include <linux/aperture.h>
30#include <linux/module.h>
31#include <linux/pci.h>
32#include <linux/poll.h>
33#include <linux/vgaarb.h>
34#include <linux/wait.h>
35
36#include <drm/clients/drm_client_setup.h>
37#include <drm/drm.h>
38#include <drm/drm_atomic_helper.h>
39#include <drm/drm_drv.h>
40#include <drm/drm_fbdev_shmem.h>
41#include <drm/drm_file.h>
42#include <drm/drm_print.h>
43
44#include "virtgpu_drv.h"
45
46#define PCI_DEVICE_ID_VIRTIO_GPU 0x1050
47
48static const struct drm_driver driver;
49
50static int virtio_gpu_modeset = -1;
51
52MODULE_PARM_DESC(modeset, "Disable/Enable modesetting");
53module_param_named(modeset, virtio_gpu_modeset, int, 0400);
54
55static int virtio_gpu_pci_quirk(struct drm_device *dev)
56{
57 struct pci_dev *pdev = to_pci_dev(dev->dev);
58 const char *pname = dev_name(&pdev->dev);
59 bool vga = pci_is_vga(pdev);
60 int ret;
61
62 DRM_INFO("pci: %s detected at %s\n",
63 vga ? "virtio-vga" : "virtio-gpu-pci",
64 pname);
65 if (vga) {
66 ret = aperture_remove_conflicting_pci_devices(pdev, driver.name);
67 if (ret)
68 return ret;
69 }
70
71 return 0;
72}
73
74static int virtio_gpu_probe(struct virtio_device *vdev)
75{
76 struct drm_device *dev;
77 int ret;
78
79 if (drm_firmware_drivers_only() && virtio_gpu_modeset == -1)
80 return -EINVAL;
81
82 if (virtio_gpu_modeset == 0)
83 return -EINVAL;
84
85 /*
86 * The virtio-gpu device is a virtual device that doesn't have DMA
87 * ops assigned to it, nor DMA mask set and etc. Its parent device
88 * is actual GPU device we want to use it for the DRM's device in
89 * order to benefit from using generic DRM APIs.
90 */
91 dev = drm_dev_alloc(&driver, vdev->dev.parent);
92 if (IS_ERR(dev))
93 return PTR_ERR(dev);
94 vdev->priv = dev;
95
96 if (dev_is_pci(vdev->dev.parent)) {
97 ret = virtio_gpu_pci_quirk(dev);
98 if (ret)
99 goto err_free;
100 }
101
102 dma_set_max_seg_size(dev->dev, dma_max_mapping_size(dev->dev) ?: UINT_MAX);
103 ret = virtio_gpu_init(vdev, dev);
104 if (ret)
105 goto err_free;
106
107 ret = drm_dev_register(dev, 0);
108 if (ret)
109 goto err_deinit;
110
111 drm_client_setup(vdev->priv, NULL);
112
113 return 0;
114
115err_deinit:
116 virtio_gpu_deinit(dev);
117err_free:
118 drm_dev_put(dev);
119 return ret;
120}
121
122/*
123 * Release pending virtqueue waits so the drm_dev_enter/exit() critical
124 * sections complete before drm_dev_unplug() blocks on synchronize_srcu().
125 */
126static void virtio_gpu_release_vqs(struct drm_device *dev)
127{
128 struct virtio_gpu_device *vgdev = dev->dev_private;
129
130 vgdev->vqs_released = true;
131 wake_up_all(&vgdev->ctrlq.ack_queue);
132 wake_up_all(&vgdev->cursorq.ack_queue);
133}
134
135static void virtio_gpu_remove(struct virtio_device *vdev)
136{
137 struct drm_device *dev = vdev->priv;
138
139 virtio_gpu_release_vqs(dev);
140 drm_dev_unplug(dev);
141
142 if (drm_core_check_feature(dev, DRIVER_ATOMIC))
143 drm_atomic_helper_shutdown(dev);
144
145 virtio_gpu_deinit(dev);
146 drm_dev_put(dev);
147}
148
149static void virtio_gpu_shutdown(struct virtio_device *vdev)
150{
151 struct drm_device *dev = vdev->priv;
152
153 virtio_gpu_release_vqs(dev);
154 /* stop talking to the device */
155 drm_dev_unplug(dev);
156}
157
158static void virtio_gpu_config_changed(struct virtio_device *vdev)
159{
160 struct drm_device *dev = vdev->priv;
161 struct virtio_gpu_device *vgdev = dev->dev_private;
162
163 schedule_work(&vgdev->config_changed_work);
164}
165
166static struct virtio_device_id id_table[] = {
167 { VIRTIO_ID_GPU, VIRTIO_DEV_ANY_ID },
168 { 0 },
169};
170
171static unsigned int features[] = {
172#ifdef __LITTLE_ENDIAN
173 /*
174 * Gallium command stream send by virgl is native endian.
175 * Because of that we only support little endian guests on
176 * little endian hosts.
177 */
178 VIRTIO_GPU_F_VIRGL,
179#endif
180 VIRTIO_GPU_F_EDID,
181 VIRTIO_GPU_F_RESOURCE_UUID,
182 VIRTIO_GPU_F_RESOURCE_BLOB,
183 VIRTIO_GPU_F_CONTEXT_INIT,
184 VIRTIO_GPU_F_BLOB_ALIGNMENT,
185};
186
187#ifdef CONFIG_PM_SLEEP
188static void virtgpu_hibernation_restore(struct virtio_gpu_device *vgdev)
189{
190 if (vgdev->hibernated) {
191 vgdev->hibernated = false;
192 virtio_gpu_object_restore_all(vgdev);
193 }
194}
195
196static int virtgpu_freeze(struct virtio_device *vdev)
197{
198 struct drm_device *dev = vdev->priv;
199 struct virtio_gpu_device *vgdev = dev->dev_private;
200 int error;
201
202 error = drm_mode_config_helper_suspend(dev);
203 if (error) {
204 DRM_ERROR("suspend error: %d\n", error);
205 return error;
206 }
207
208 if (vgdev->hibernated)
209 virtio_gpu_object_unref_all(vgdev);
210
211 flush_work(&vgdev->obj_free_work);
212 flush_work(&vgdev->ctrlq.dequeue_work);
213 flush_work(&vgdev->cursorq.dequeue_work);
214 flush_work(&vgdev->config_changed_work);
215
216 error = virtio_gpu_wait_queue(&vgdev->ctrlq, vgdev->ctrlq.vq->num_max);
217 if (error) {
218 DRM_ERROR("ctrlq wait failed: %d\n", error);
219 goto err_resume;
220 }
221
222 error = virtio_gpu_wait_queue(&vgdev->cursorq, vgdev->cursorq.vq->num_max);
223 if (error) {
224 DRM_ERROR("cursorq wait failed: %d\n", error);
225 goto err_resume;
226 }
227
228 virtio_reset_device(vdev);
229 vdev->config->del_vqs(vdev);
230
231 return 0;
232
233err_resume:
234 virtgpu_hibernation_restore(vgdev);
235
236 drm_mode_config_helper_resume(dev);
237
238 return error;
239}
240
241static int virtgpu_restore(struct virtio_device *vdev)
242{
243 struct drm_device *dev = vdev->priv;
244 struct virtio_gpu_device *vgdev = dev->dev_private;
245 int error;
246
247 error = virtio_gpu_find_vqs(vgdev);
248 if (error) {
249 DRM_ERROR("failed to find virt queues\n");
250 return error;
251 }
252
253 virtio_device_ready(vdev);
254
255 virtgpu_hibernation_restore(vgdev);
256
257 error = drm_mode_config_helper_resume(dev);
258 if (error) {
259 DRM_ERROR("resume error: %d\n", error);
260 return error;
261 }
262
263 return 0;
264}
265#endif
266
267static struct virtio_driver virtio_gpu_driver = {
268 .feature_table = features,
269 .feature_table_size = ARRAY_SIZE(features),
270 .driver.name = KBUILD_MODNAME,
271 .id_table = id_table,
272 .probe = virtio_gpu_probe,
273 .remove = virtio_gpu_remove,
274 .shutdown = virtio_gpu_shutdown,
275 .config_changed = virtio_gpu_config_changed,
276#ifdef CONFIG_PM_SLEEP
277 .freeze = virtgpu_freeze,
278 .restore = virtgpu_restore,
279#endif
280};
281
282static int __init virtio_gpu_driver_init(void)
283{
284 struct pci_dev *pdev;
285 int ret;
286
287 pdev = pci_get_device(PCI_VENDOR_ID_REDHAT_QUMRANET,
288 PCI_DEVICE_ID_VIRTIO_GPU,
289 NULL);
290 if (pdev && pci_is_vga(pdev)) {
291 ret = vga_get_interruptible(pdev,
292 VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM);
293 if (ret) {
294 pci_dev_put(pdev);
295 return ret;
296 }
297 }
298
299 ret = register_virtio_driver(&virtio_gpu_driver);
300
301 if (pdev) {
302 if (pci_is_vga(pdev))
303 vga_put(pdev,
304 VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM);
305
306 pci_dev_put(pdev);
307 }
308
309 return ret;
310}
311
312static void __exit virtio_gpu_driver_exit(void)
313{
314 unregister_virtio_driver(&virtio_gpu_driver);
315}
316
317module_init(virtio_gpu_driver_init);
318module_exit(virtio_gpu_driver_exit);
319
320MODULE_DEVICE_TABLE(virtio, id_table);
321MODULE_DESCRIPTION("Virtio GPU driver");
322MODULE_LICENSE("GPL and additional rights");
323MODULE_AUTHOR("Dave Airlie <[email protected]>");
324MODULE_AUTHOR("Gerd Hoffmann <[email protected]>");
325MODULE_AUTHOR("Alon Levy");
326
327DEFINE_DRM_GEM_FOPS(virtio_gpu_driver_fops);
328
329static const struct drm_driver driver = {
330 /*
331 * If KMS is disabled DRIVER_MODESET and DRIVER_ATOMIC are masked
332 * out via drm_device::driver_features:
333 */
334 .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_RENDER | DRIVER_ATOMIC |
335 DRIVER_SYNCOBJ | DRIVER_SYNCOBJ_TIMELINE | DRIVER_CURSOR_HOTSPOT,
336 .open = virtio_gpu_driver_open,
337 .postclose = virtio_gpu_driver_postclose,
338
339 .dumb_create = virtio_gpu_mode_dumb_create,
340
341 DRM_FBDEV_SHMEM_DRIVER_OPS,
342
343#if defined(CONFIG_DEBUG_FS)
344 .debugfs_init = virtio_gpu_debugfs_init,
345#endif
346 .gem_prime_import = virtgpu_gem_prime_import,
347 .gem_prime_import_sg_table = virtgpu_gem_prime_import_sg_table,
348
349 .gem_create_object = virtio_gpu_create_object,
350 .fops = &virtio_gpu_driver_fops,
351
352 .ioctls = virtio_gpu_ioctls,
353 .num_ioctls = DRM_VIRTIO_NUM_IOCTLS,
354
355 .name = DRIVER_NAME,
356 .desc = DRIVER_DESC,
357 .major = DRIVER_MAJOR,
358 .minor = DRIVER_MINOR,
359 .patchlevel = DRIVER_PATCHLEVEL,
360
361 .release = virtio_gpu_release,
362};