change wifi driver to cypress

hc

2024-01-05 071106ecf68c401173c58808b1cf5f68cc50d390

 kernel/drivers/gpu/drm/virtio/virtgpu_ioctl.c
..
..
@@ -25,72 +25,43 @@
25
25
  * OTHER DEALINGS IN THE SOFTWARE.
26
26
  */
27
27
 
28
-#include <drm/drmP.h>
29
-#include <drm/virtgpu_drm.h>
30
-#include <drm/ttm/ttm_execbuf_util.h>
28
+#include <linux/file.h>
31
29
 #include <linux/sync_file.h>
30
+#include <linux/uaccess.h>
31
+
32
+#include <drm/drm_file.h>
33
+#include <drm/virtgpu_drm.h>
32
34
 
33
35
 #include "virtgpu_drv.h"
34
36
 
35
-static void convert_to_hw_box(struct virtio_gpu_box *dst,
36
-			      const struct drm_virtgpu_3d_box *src)
37
+void virtio_gpu_create_context(struct drm_device *dev, struct drm_file *file)
37
38
 {
38
-	dst->x = cpu_to_le32(src->x);
39
-	dst->y = cpu_to_le32(src->y);
40
-	dst->z = cpu_to_le32(src->z);
41
-	dst->w = cpu_to_le32(src->w);
42
-	dst->h = cpu_to_le32(src->h);
43
-	dst->d = cpu_to_le32(src->d);
39
+	struct virtio_gpu_device *vgdev = dev->dev_private;
40
+	struct virtio_gpu_fpriv *vfpriv = file->driver_priv;
41
+	char dbgname[TASK_COMM_LEN];
42
+
43
+	mutex_lock(&vfpriv->context_lock);
44
+	if (vfpriv->context_created)
45
+		goto out_unlock;
46
+
47
+	get_task_comm(dbgname, current);
48
+	virtio_gpu_cmd_context_create(vgdev, vfpriv->ctx_id,
49
+				      strlen(dbgname), dbgname);
50
+	vfpriv->context_created = true;
51
+
52
+out_unlock:
53
+	mutex_unlock(&vfpriv->context_lock);
44
54
 }
45
55
 
46
56
 static int virtio_gpu_map_ioctl(struct drm_device *dev, void *data,
47
-				struct drm_file *file_priv)
57
+				struct drm_file *file)
48
58
 {
49
59
 	struct virtio_gpu_device *vgdev = dev->dev_private;
50
60
 	struct drm_virtgpu_map *virtio_gpu_map = data;
51
61
 
52
-	return virtio_gpu_mode_dumb_mmap(file_priv, vgdev->ddev,
62
+	return virtio_gpu_mode_dumb_mmap(file, vgdev->ddev,
53
63
 					 virtio_gpu_map->handle,
54
64
 					 &virtio_gpu_map->offset);
55
-}
56
-
57
-int virtio_gpu_object_list_validate(struct ww_acquire_ctx *ticket,
58
-				    struct list_head *head)
59
-{
60
-	struct ttm_operation_ctx ctx = { false, false };
61
-	struct ttm_validate_buffer *buf;
62
-	struct ttm_buffer_object *bo;
63
-	struct virtio_gpu_object *qobj;
64
-	int ret;
65
-
66
-	ret = ttm_eu_reserve_buffers(ticket, head, true, NULL);
67
-	if (ret != 0)
68
-		return ret;
69
-
70
-	list_for_each_entry(buf, head, head) {
71
-		bo = buf->bo;
72
-		qobj = container_of(bo, struct virtio_gpu_object, tbo);
73
-		ret = ttm_bo_validate(bo, &qobj->placement, &ctx);
74
-		if (ret) {
75
-			ttm_eu_backoff_reservation(ticket, head);
76
-			return ret;
77
-		}
78
-	}
79
-	return 0;
80
-}
81
-
82
-void virtio_gpu_unref_list(struct list_head *head)
83
-{
84
-	struct ttm_validate_buffer *buf;
85
-	struct ttm_buffer_object *bo;
86
-	struct virtio_gpu_object *qobj;
87
-
88
-	list_for_each_entry(buf, head, head) {
89
-		bo = buf->bo;
90
-		qobj = container_of(bo, struct virtio_gpu_object, tbo);
91
-
92
-		drm_gem_object_put_unlocked(&qobj->gem_base);
93
-	}
94
65
 }
95
66
 
96
67
 /*
..
..
@@ -100,21 +71,16 @@
100
71
  * VIRTIO_GPUReleaseInfo struct (first XXX bytes)
101
72
  */
102
73
 static int virtio_gpu_execbuffer_ioctl(struct drm_device *dev, void *data,
103
-				 struct drm_file *drm_file)
74
+				 struct drm_file *file)
104
75
 {
105
76
 	struct drm_virtgpu_execbuffer *exbuf = data;
106
77
 	struct virtio_gpu_device *vgdev = dev->dev_private;
107
-	struct virtio_gpu_fpriv *vfpriv = drm_file->driver_priv;
108
-	struct drm_gem_object *gobj;
78
+	struct virtio_gpu_fpriv *vfpriv = file->driver_priv;
109
79
 	struct virtio_gpu_fence *out_fence;
110
-	struct virtio_gpu_object *qobj;
111
80
 	int ret;
112
81
 	uint32_t *bo_handles = NULL;
113
82
 	void __user *user_bo_handles = NULL;
114
-	struct list_head validate_list;
115
-	struct ttm_validate_buffer *buflist = NULL;
116
-	int i;
117
-	struct ww_acquire_ctx ticket;
83
+	struct virtio_gpu_object_array *buflist = NULL;
118
84
 	struct sync_file *sync_file;
119
85
 	int in_fence_fd = exbuf->fence_fd;
120
86
 	int out_fence_fd = -1;
..
..
@@ -128,6 +94,7 @@
128
94
 
129
95
 	exbuf->fence_fd = -1;
130
96
 
97
+	virtio_gpu_create_context(dev, file);
131
98
 	if (exbuf->flags & VIRTGPU_EXECBUF_FENCE_FD_IN) {
132
99
 		struct dma_fence *in_fence;
133
100
 
..
..
@@ -155,15 +122,10 @@
155
122
 			return out_fence_fd;
156
123
 	}
157
124
 
158
-	INIT_LIST_HEAD(&validate_list);
159
125
 	if (exbuf->num_bo_handles) {
160
-
161
126
 		bo_handles = kvmalloc_array(exbuf->num_bo_handles,
162
-					   sizeof(uint32_t), GFP_KERNEL);
163
-		buflist = kvmalloc_array(exbuf->num_bo_handles,
164
-					   sizeof(struct ttm_validate_buffer),
165
-					   GFP_KERNEL | __GFP_ZERO);
166
-		if (!bo_handles || !buflist) {
127
+					    sizeof(uint32_t), GFP_KERNEL);
128
+		if (!bo_handles) {
167
129
 			ret = -ENOMEM;
168
130
 			goto out_unused_fd;
169
131
 		}
..
..
@@ -175,36 +137,32 @@
175
137
 			goto out_unused_fd;
176
138
 		}
177
139
 
178
-		for (i = 0; i < exbuf->num_bo_handles; i++) {
179
-			gobj = drm_gem_object_lookup(drm_file, bo_handles[i]);
180
-			if (!gobj) {
181
-				ret = -ENOENT;
182
-				goto out_unused_fd;
183
-			}
184
-
185
-			qobj = gem_to_virtio_gpu_obj(gobj);
186
-			buflist[i].bo = &qobj->tbo;
187
-
188
-			list_add(&buflist[i].head, &validate_list);
140
+		buflist = virtio_gpu_array_from_handles(file, bo_handles,
141
+							exbuf->num_bo_handles);
142
+		if (!buflist) {
143
+			ret = -ENOENT;
144
+			goto out_unused_fd;
189
145
 		}
190
146
 		kvfree(bo_handles);
191
147
 		bo_handles = NULL;
192
148
 	}
193
149
 
194
-	ret = virtio_gpu_object_list_validate(&ticket, &validate_list);
195
-	if (ret)
196
-		goto out_free;
197
-
198
150
 	buf = vmemdup_user(u64_to_user_ptr(exbuf->command), exbuf->size);
199
151
 	if (IS_ERR(buf)) {
200
152
 		ret = PTR_ERR(buf);
201
-		goto out_unresv;
153
+		goto out_unused_fd;
154
+	}
155
+
156
+	if (buflist) {
157
+		ret = virtio_gpu_array_lock_resv(buflist);
158
+		if (ret)
159
+			goto out_memdup;
202
160
 	}
203
161
 
204
162
 	out_fence = virtio_gpu_fence_alloc(vgdev);
205
163
 	if(!out_fence) {
206
164
 		ret = -ENOMEM;
207
-		goto out_memdup;
165
+		goto out_unresv;
208
166
 	}
209
167
 
210
168
 	if (out_fence_fd >= 0) {
..
..
@@ -220,24 +178,20 @@
220
178
 	}
221
179
 
222
180
 	virtio_gpu_cmd_submit(vgdev, buf, exbuf->size,
223
-			      vfpriv->ctx_id, out_fence);
224
-
225
-	ttm_eu_fence_buffer_objects(&ticket, &validate_list, &out_fence->f);
226
-
227
-	/* fence the command bo */
228
-	virtio_gpu_unref_list(&validate_list);
229
-	kvfree(buflist);
181
+			      vfpriv->ctx_id, buflist, out_fence);
182
+	dma_fence_put(&out_fence->f);
183
+	virtio_gpu_notify(vgdev);
230
184
 	return 0;
231
185
 
186
+out_unresv:
187
+	if (buflist)
188
+		virtio_gpu_array_unlock_resv(buflist);
232
189
 out_memdup:
233
190
 	kvfree(buf);
234
-out_unresv:
235
-	ttm_eu_backoff_reservation(&ticket, &validate_list);
236
-out_free:
237
-	virtio_gpu_unref_list(&validate_list);
238
191
 out_unused_fd:
239
192
 	kvfree(bo_handles);
240
-	kvfree(buflist);
193
+	if (buflist)
194
+		virtio_gpu_array_put_free(buflist);
241
195
 
242
196
 	if (out_fence_fd >= 0)
243
197
 		put_unused_fd(out_fence_fd);
..
..
@@ -246,7 +200,7 @@
246
200
 }
247
201
 
248
202
 static int virtio_gpu_getparam_ioctl(struct drm_device *dev, void *data,
249
-				     struct drm_file *file_priv)
203
+				     struct drm_file *file)
250
204
 {
251
205
 	struct virtio_gpu_device *vgdev = dev->dev_private;
252
206
 	struct drm_virtgpu_getparam *param = data;
..
..
@@ -269,7 +223,7 @@
269
223
 }
270
224
 
271
225
 static int virtio_gpu_resource_create_ioctl(struct drm_device *dev, void *data,
272
-					    struct drm_file *file_priv)
226
+					    struct drm_file *file)
273
227
 {
274
228
 	struct virtio_gpu_device *vgdev = dev->dev_private;
275
229
 	struct drm_virtgpu_resource_create *rc = data;
..
..
@@ -280,7 +234,17 @@
280
234
 	uint32_t handle = 0;
281
235
 	struct virtio_gpu_object_params params = { 0 };
282
236
 
283
-	if (vgdev->has_virgl_3d == false) {
237
+	if (vgdev->has_virgl_3d) {
238
+		virtio_gpu_create_context(dev, file);
239
+		params.virgl = true;
240
+		params.target = rc->target;
241
+		params.bind = rc->bind;
242
+		params.depth = rc->depth;
243
+		params.array_size = rc->array_size;
244
+		params.last_level = rc->last_level;
245
+		params.nr_samples = rc->nr_samples;
246
+		params.flags = rc->flags;
247
+	} else {
284
248
 		if (rc->depth > 1)
285
249
 			return -EINVAL;
286
250
 		if (rc->nr_samples > 1)
..
..
@@ -297,16 +261,6 @@
297
261
 	params.width = rc->width;
298
262
 	params.height = rc->height;
299
263
 	params.size = rc->size;
300
-	if (vgdev->has_virgl_3d) {
301
-		params.virgl = true;
302
-		params.target = rc->target;
303
-		params.bind = rc->bind;
304
-		params.depth = rc->depth;
305
-		params.array_size = rc->array_size;
306
-		params.last_level = rc->last_level;
307
-		params.nr_samples = rc->nr_samples;
308
-		params.flags = rc->flags;
309
-	}
310
264
 	/* allocate a single page size object */
311
265
 	if (params.size == 0)
312
266
 		params.size = PAGE_SIZE;
..
..
@@ -314,40 +268,48 @@
314
268
 	fence = virtio_gpu_fence_alloc(vgdev);
315
269
 	if (!fence)
316
270
 		return -ENOMEM;
317
-	qobj = virtio_gpu_alloc_object(dev, &params, fence);
271
+	ret = virtio_gpu_object_create(vgdev, &params, &qobj, fence);
318
272
 	dma_fence_put(&fence->f);
319
-	if (IS_ERR(qobj))
320
-		return PTR_ERR(qobj);
321
-	obj = &qobj->gem_base;
273
+	if (ret < 0)
274
+		return ret;
275
+	obj = &qobj->base.base;
322
276
 
323
-	ret = drm_gem_handle_create(file_priv, obj, &handle);
277
+	ret = drm_gem_handle_create(file, obj, &handle);
324
278
 	if (ret) {
325
279
 		drm_gem_object_release(obj);
326
280
 		return ret;
327
281
 	}
328
-	drm_gem_object_put_unlocked(obj);
329
282
 
330
283
 	rc->res_handle = qobj->hw_res_handle; /* similiar to a VM address */
331
284
 	rc->bo_handle = handle;
285
+
286
+	/*
287
+	 * The handle owns the reference now.  But we must drop our
288
+	 * remaining reference *after* we no longer need to dereference
289
+	 * the obj.  Otherwise userspace could guess the handle and
290
+	 * race closing it from another thread.
291
+	 */
292
+	drm_gem_object_put(obj);
293
+
332
294
 	return 0;
333
295
 }
334
296
 
335
297
 static int virtio_gpu_resource_info_ioctl(struct drm_device *dev, void *data,
336
-					  struct drm_file *file_priv)
298
+					  struct drm_file *file)
337
299
 {
338
300
 	struct drm_virtgpu_resource_info *ri = data;
339
301
 	struct drm_gem_object *gobj = NULL;
340
302
 	struct virtio_gpu_object *qobj = NULL;
341
303
 
342
-	gobj = drm_gem_object_lookup(file_priv, ri->bo_handle);
304
+	gobj = drm_gem_object_lookup(file, ri->bo_handle);
343
305
 	if (gobj == NULL)
344
306
 		return -ENOENT;
345
307
 
346
308
 	qobj = gem_to_virtio_gpu_obj(gobj);
347
309
 
348
-	ri->size = qobj->gem_base.size;
310
+	ri->size = qobj->base.base.size;
349
311
 	ri->res_handle = qobj->hw_res_handle;
350
-	drm_gem_object_put_unlocked(gobj);
312
+	drm_gem_object_put(gobj);
351
313
 	return 0;
352
314
 }
353
315
 
..
..
@@ -358,50 +320,39 @@
358
320
 	struct virtio_gpu_device *vgdev = dev->dev_private;
359
321
 	struct virtio_gpu_fpriv *vfpriv = file->driver_priv;
360
322
 	struct drm_virtgpu_3d_transfer_from_host *args = data;
361
-	struct ttm_operation_ctx ctx = { true, false };
362
-	struct drm_gem_object *gobj = NULL;
363
-	struct virtio_gpu_object *qobj = NULL;
323
+	struct virtio_gpu_object_array *objs;
364
324
 	struct virtio_gpu_fence *fence;
365
325
 	int ret;
366
326
 	u32 offset = args->offset;
367
-	struct virtio_gpu_box box;
368
327
 
369
328
 	if (vgdev->has_virgl_3d == false)
370
329
 		return -ENOSYS;
371
330
 
372
-	gobj = drm_gem_object_lookup(file, args->bo_handle);
373
-	if (gobj == NULL)
331
+	virtio_gpu_create_context(dev, file);
332
+	objs = virtio_gpu_array_from_handles(file, &args->bo_handle, 1);
333
+	if (objs == NULL)
374
334
 		return -ENOENT;
375
335
 
376
-	qobj = gem_to_virtio_gpu_obj(gobj);
377
-
378
-	ret = virtio_gpu_object_reserve(qobj, false);
379
-	if (ret)
380
-		goto out;
381
-
382
-	ret = ttm_bo_validate(&qobj->tbo, &qobj->placement, &ctx);
383
-	if (unlikely(ret))
384
-		goto out_unres;
385
-
386
-	convert_to_hw_box(&box, &args->box);
336
+	ret = virtio_gpu_array_lock_resv(objs);
337
+	if (ret != 0)
338
+		goto err_put_free;
387
339
 
388
340
 	fence = virtio_gpu_fence_alloc(vgdev);
389
341
 	if (!fence) {
390
342
 		ret = -ENOMEM;
391
-		goto out_unres;
343
+		goto err_unlock;
392
344
 	}
393
345
 	virtio_gpu_cmd_transfer_from_host_3d
394
-		(vgdev, qobj->hw_res_handle,
395
-		 vfpriv->ctx_id, offset, args->level,
396
-		 &box, fence);
397
-	reservation_object_add_excl_fence(qobj->tbo.resv,
398
-					  &fence->f);
399
-
346
+		(vgdev, vfpriv->ctx_id, offset, args->level,
347
+		 &args->box, objs, fence);
400
348
 	dma_fence_put(&fence->f);
401
-out_unres:
402
-	virtio_gpu_object_unreserve(qobj);
403
-out:
404
-	drm_gem_object_put_unlocked(gobj);
349
+	virtio_gpu_notify(vgdev);
350
+	return 0;
351
+
352
+err_unlock:
353
+	virtio_gpu_array_unlock_resv(objs);
354
+err_put_free:
355
+	virtio_gpu_array_put_free(objs);
405
356
 	return ret;
406
357
 }
407
358
 
..
..
@@ -411,75 +362,71 @@
411
362
 	struct virtio_gpu_device *vgdev = dev->dev_private;
412
363
 	struct virtio_gpu_fpriv *vfpriv = file->driver_priv;
413
364
 	struct drm_virtgpu_3d_transfer_to_host *args = data;
414
-	struct ttm_operation_ctx ctx = { true, false };
415
-	struct drm_gem_object *gobj = NULL;
416
-	struct virtio_gpu_object *qobj = NULL;
365
+	struct virtio_gpu_object_array *objs;
417
366
 	struct virtio_gpu_fence *fence;
418
-	struct virtio_gpu_box box;
419
367
 	int ret;
420
368
 	u32 offset = args->offset;
421
369
 
422
-	gobj = drm_gem_object_lookup(file, args->bo_handle);
423
-	if (gobj == NULL)
370
+	objs = virtio_gpu_array_from_handles(file, &args->bo_handle, 1);
371
+	if (objs == NULL)
424
372
 		return -ENOENT;
425
373
 
426
-	qobj = gem_to_virtio_gpu_obj(gobj);
427
-
428
-	ret = virtio_gpu_object_reserve(qobj, false);
429
-	if (ret)
430
-		goto out;
431
-
432
-	ret = ttm_bo_validate(&qobj->tbo, &qobj->placement, &ctx);
433
-	if (unlikely(ret))
434
-		goto out_unres;
435
-
436
-	convert_to_hw_box(&box, &args->box);
437
374
 	if (!vgdev->has_virgl_3d) {
438
375
 		virtio_gpu_cmd_transfer_to_host_2d
439
-			(vgdev, qobj, offset,
440
-			 box.w, box.h, box.x, box.y, NULL);
376
+			(vgdev, offset,
377
+			 args->box.w, args->box.h, args->box.x, args->box.y,
378
+			 objs, NULL);
441
379
 	} else {
380
+		virtio_gpu_create_context(dev, file);
381
+		ret = virtio_gpu_array_lock_resv(objs);
382
+		if (ret != 0)
383
+			goto err_put_free;
384
+
385
+		ret = -ENOMEM;
442
386
 		fence = virtio_gpu_fence_alloc(vgdev);
443
-		if (!fence) {
444
-			ret = -ENOMEM;
445
-			goto out_unres;
446
-		}
387
+		if (!fence)
388
+			goto err_unlock;
389
+
447
390
 		virtio_gpu_cmd_transfer_to_host_3d
448
-			(vgdev, qobj,
391
+			(vgdev,
449
392
 			 vfpriv ? vfpriv->ctx_id : 0, offset,
450
-			 args->level, &box, fence);
451
-		reservation_object_add_excl_fence(qobj->tbo.resv,
452
-						  &fence->f);
393
+			 args->level, &args->box, objs, fence);
453
394
 		dma_fence_put(&fence->f);
454
395
 	}
396
+	virtio_gpu_notify(vgdev);
397
+	return 0;
455
398
 
456
-out_unres:
457
-	virtio_gpu_object_unreserve(qobj);
458
-out:
459
-	drm_gem_object_put_unlocked(gobj);
399
+err_unlock:
400
+	virtio_gpu_array_unlock_resv(objs);
401
+err_put_free:
402
+	virtio_gpu_array_put_free(objs);
460
403
 	return ret;
461
404
 }
462
405
 
463
406
 static int virtio_gpu_wait_ioctl(struct drm_device *dev, void *data,
464
-			    struct drm_file *file)
407
+				 struct drm_file *file)
465
408
 {
466
409
 	struct drm_virtgpu_3d_wait *args = data;
467
-	struct drm_gem_object *gobj = NULL;
468
-	struct virtio_gpu_object *qobj = NULL;
410
+	struct drm_gem_object *obj;
411
+	long timeout = 15 * HZ;
469
412
 	int ret;
470
-	bool nowait = false;
471
413
 
472
-	gobj = drm_gem_object_lookup(file, args->handle);
473
-	if (gobj == NULL)
414
+	obj = drm_gem_object_lookup(file, args->handle);
415
+	if (obj == NULL)
474
416
 		return -ENOENT;
475
417
 
476
-	qobj = gem_to_virtio_gpu_obj(gobj);
418
+	if (args->flags & VIRTGPU_WAIT_NOWAIT) {
419
+		ret = dma_resv_test_signaled_rcu(obj->resv, true);
420
+	} else {
421
+		ret = dma_resv_wait_timeout_rcu(obj->resv, true, true,
422
+						timeout);
423
+	}
424
+	if (ret == 0)
425
+		ret = -EBUSY;
426
+	else if (ret > 0)
427
+		ret = 0;
477
428
 
478
-	if (args->flags & VIRTGPU_WAIT_NOWAIT)
479
-		nowait = true;
480
-	ret = virtio_gpu_object_wait(qobj, nowait);
481
-
482
-	drm_gem_object_put_unlocked(gobj);
429
+	drm_gem_object_put(obj);
483
430
 	return ret;
484
431
 }
485
432
 
..
..
@@ -531,8 +478,11 @@
531
478
 	spin_unlock(&vgdev->display_info_lock);
532
479
 
533
480
 	/* not in cache - need to talk to hw */
534
-	virtio_gpu_cmd_get_capset(vgdev, found_valid, args->cap_set_ver,
535
-				  &cache_ent);
481
+	ret = virtio_gpu_cmd_get_capset(vgdev, found_valid, args->cap_set_ver,
482
+					&cache_ent);
483
+	if (ret)
484
+		return ret;
485
+	virtio_gpu_notify(vgdev);
536
486
 
537
487
 copy_exit:
538
488
 	ret = wait_event_timeout(vgdev->resp_wq,
..
..
@@ -553,34 +503,34 @@
553
503
 
554
504
 struct drm_ioctl_desc virtio_gpu_ioctls[DRM_VIRTIO_NUM_IOCTLS] = {
555
505
 	DRM_IOCTL_DEF_DRV(VIRTGPU_MAP, virtio_gpu_map_ioctl,
556
-			  DRM_AUTH | DRM_RENDER_ALLOW),
506
+			  DRM_RENDER_ALLOW),
557
507
 
558
508
 	DRM_IOCTL_DEF_DRV(VIRTGPU_EXECBUFFER, virtio_gpu_execbuffer_ioctl,
559
-			  DRM_AUTH | DRM_RENDER_ALLOW),
509
+			  DRM_RENDER_ALLOW),
560
510
 
561
511
 	DRM_IOCTL_DEF_DRV(VIRTGPU_GETPARAM, virtio_gpu_getparam_ioctl,
562
-			  DRM_AUTH | DRM_RENDER_ALLOW),
512
+			  DRM_RENDER_ALLOW),
563
513
 
564
514
 	DRM_IOCTL_DEF_DRV(VIRTGPU_RESOURCE_CREATE,
565
515
 			  virtio_gpu_resource_create_ioctl,
566
-			  DRM_AUTH | DRM_RENDER_ALLOW),
516
+			  DRM_RENDER_ALLOW),
567
517
 
568
518
 	DRM_IOCTL_DEF_DRV(VIRTGPU_RESOURCE_INFO, virtio_gpu_resource_info_ioctl,
569
-			  DRM_AUTH | DRM_RENDER_ALLOW),
519
+			  DRM_RENDER_ALLOW),
570
520
 
571
521
 	/* make transfer async to the main ring? - no sure, can we
572
522
 	 * thread these in the underlying GL
573
523
 	 */
574
524
 	DRM_IOCTL_DEF_DRV(VIRTGPU_TRANSFER_FROM_HOST,
575
525
 			  virtio_gpu_transfer_from_host_ioctl,
576
-			  DRM_AUTH | DRM_RENDER_ALLOW),
526
+			  DRM_RENDER_ALLOW),
577
527
 	DRM_IOCTL_DEF_DRV(VIRTGPU_TRANSFER_TO_HOST,
578
528
 			  virtio_gpu_transfer_to_host_ioctl,
579
-			  DRM_AUTH | DRM_RENDER_ALLOW),
529
+			  DRM_RENDER_ALLOW),
580
530
 
581
531
 	DRM_IOCTL_DEF_DRV(VIRTGPU_WAIT, virtio_gpu_wait_ioctl,
582
-			  DRM_AUTH | DRM_RENDER_ALLOW),
532
+			  DRM_RENDER_ALLOW),
583
533
 
584
534
 	DRM_IOCTL_DEF_DRV(VIRTGPU_GET_CAPS, virtio_gpu_get_caps_ioctl,
585
-			  DRM_AUTH | DRM_RENDER_ALLOW),
535
+			  DRM_RENDER_ALLOW),
586
536
 };