1 /* $NetBSD: drm_ioc32.c,v 1.3 2021/12/18 23:44:57 riastradh Exp $ */
2
3 /*
4 * \file drm_ioc32.c
5 *
6 * 32-bit ioctl compatibility routines for the DRM.
7 *
8 * \author Paul Mackerras <paulus@samba.org>
9 *
10 * Copyright (C) Paul Mackerras 2005.
11 * All Rights Reserved.
12 *
13 * Permission is hereby granted, free of charge, to any person obtaining a
14 * copy of this software and associated documentation files (the "Software"),
15 * to deal in the Software without restriction, including without limitation
16 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
17 * and/or sell copies of the Software, and to permit persons to whom the
18 * Software is furnished to do so, subject to the following conditions:
19 *
20 * The above copyright notice and this permission notice (including the next
21 * paragraph) shall be included in all copies or substantial portions of the
22 * Software.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 * THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
28 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
29 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
30 * IN THE SOFTWARE.
31 */
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: drm_ioc32.c,v 1.3 2021/12/18 23:44:57 riastradh Exp $");
34
35 #include <linux/compat.h>
36 #include <linux/ratelimit.h>
37 #include <linux/export.h>
38
39 #include <drm/drm_agpsupport.h>
40 #include <drm/drm_file.h>
41 #include <drm/drm_print.h>
42
43 #include "drm_crtc_internal.h"
44 #include "drm_internal.h"
45 #include "drm_legacy.h"
46
47 #define DRM_IOCTL_VERSION32 DRM_IOWR(0x00, drm_version32_t)
48 #define DRM_IOCTL_GET_UNIQUE32 DRM_IOWR(0x01, drm_unique32_t)
49 #define DRM_IOCTL_GET_MAP32 DRM_IOWR(0x04, drm_map32_t)
50 #define DRM_IOCTL_GET_CLIENT32 DRM_IOWR(0x05, drm_client32_t)
51 #define DRM_IOCTL_GET_STATS32 DRM_IOR( 0x06, drm_stats32_t)
52
53 #define DRM_IOCTL_SET_UNIQUE32 DRM_IOW( 0x10, drm_unique32_t)
54 #define DRM_IOCTL_ADD_MAP32 DRM_IOWR(0x15, drm_map32_t)
55 #define DRM_IOCTL_ADD_BUFS32 DRM_IOWR(0x16, drm_buf_desc32_t)
56 #define DRM_IOCTL_MARK_BUFS32 DRM_IOW( 0x17, drm_buf_desc32_t)
57 #define DRM_IOCTL_INFO_BUFS32 DRM_IOWR(0x18, drm_buf_info32_t)
58 #define DRM_IOCTL_MAP_BUFS32 DRM_IOWR(0x19, drm_buf_map32_t)
59 #define DRM_IOCTL_FREE_BUFS32 DRM_IOW( 0x1a, drm_buf_free32_t)
60
61 #define DRM_IOCTL_RM_MAP32 DRM_IOW( 0x1b, drm_map32_t)
62
63 #define DRM_IOCTL_SET_SAREA_CTX32 DRM_IOW( 0x1c, drm_ctx_priv_map32_t)
64 #define DRM_IOCTL_GET_SAREA_CTX32 DRM_IOWR(0x1d, drm_ctx_priv_map32_t)
65
66 #define DRM_IOCTL_RES_CTX32 DRM_IOWR(0x26, drm_ctx_res32_t)
67 #define DRM_IOCTL_DMA32 DRM_IOWR(0x29, drm_dma32_t)
68
69 #define DRM_IOCTL_AGP_ENABLE32 DRM_IOW( 0x32, drm_agp_mode32_t)
70 #define DRM_IOCTL_AGP_INFO32 DRM_IOR( 0x33, drm_agp_info32_t)
71 #define DRM_IOCTL_AGP_ALLOC32 DRM_IOWR(0x34, drm_agp_buffer32_t)
72 #define DRM_IOCTL_AGP_FREE32 DRM_IOW( 0x35, drm_agp_buffer32_t)
73 #define DRM_IOCTL_AGP_BIND32 DRM_IOW( 0x36, drm_agp_binding32_t)
74 #define DRM_IOCTL_AGP_UNBIND32 DRM_IOW( 0x37, drm_agp_binding32_t)
75
76 #define DRM_IOCTL_SG_ALLOC32 DRM_IOW( 0x38, drm_scatter_gather32_t)
77 #define DRM_IOCTL_SG_FREE32 DRM_IOW( 0x39, drm_scatter_gather32_t)
78
79 #define DRM_IOCTL_UPDATE_DRAW32 DRM_IOW( 0x3f, drm_update_draw32_t)
80
81 #define DRM_IOCTL_WAIT_VBLANK32 DRM_IOWR(0x3a, drm_wait_vblank32_t)
82
83 #define DRM_IOCTL_MODE_ADDFB232 DRM_IOWR(0xb8, drm_mode_fb_cmd232_t)
84
85 typedef struct drm_version_32 {
86 int version_major; /* Major version */
87 int version_minor; /* Minor version */
88 int version_patchlevel; /* Patch level */
89 u32 name_len; /* Length of name buffer */
90 u32 name; /* Name of driver */
91 u32 date_len; /* Length of date buffer */
92 u32 date; /* User-space buffer to hold date */
93 u32 desc_len; /* Length of desc buffer */
94 u32 desc; /* User-space buffer to hold desc */
95 } drm_version32_t;
96
compat_drm_version(struct file * file,unsigned int cmd,unsigned long arg)97 static int compat_drm_version(struct file *file, unsigned int cmd,
98 unsigned long arg)
99 {
100 drm_version32_t v32;
101 struct drm_version v;
102 int err;
103
104 if (copy_from_user(&v32, (void __user *)arg, sizeof(v32)))
105 return -EFAULT;
106
107 v = (struct drm_version) {
108 .name_len = v32.name_len,
109 .name = compat_ptr(v32.name),
110 .date_len = v32.date_len,
111 .date = compat_ptr(v32.date),
112 .desc_len = v32.desc_len,
113 .desc = compat_ptr(v32.desc),
114 };
115 err = drm_ioctl_kernel(file, drm_version, &v,
116 DRM_RENDER_ALLOW);
117 if (err)
118 return err;
119
120 v32.version_major = v.version_major;
121 v32.version_minor = v.version_minor;
122 v32.version_patchlevel = v.version_patchlevel;
123 v32.name_len = v.name_len;
124 v32.date_len = v.date_len;
125 v32.desc_len = v.desc_len;
126 if (copy_to_user((void __user *)arg, &v32, sizeof(v32)))
127 return -EFAULT;
128 return 0;
129 }
130
131 typedef struct drm_unique32 {
132 u32 unique_len; /* Length of unique */
133 u32 unique; /* Unique name for driver instantiation */
134 } drm_unique32_t;
135
compat_drm_getunique(struct file * file,unsigned int cmd,unsigned long arg)136 static int compat_drm_getunique(struct file *file, unsigned int cmd,
137 unsigned long arg)
138 {
139 drm_unique32_t uq32;
140 struct drm_unique uq;
141 int err;
142
143 if (copy_from_user(&uq32, (void __user *)arg, sizeof(uq32)))
144 return -EFAULT;
145 uq = (struct drm_unique){
146 .unique_len = uq32.unique_len,
147 .unique = compat_ptr(uq32.unique),
148 };
149
150 err = drm_ioctl_kernel(file, drm_getunique, &uq, 0);
151 if (err)
152 return err;
153
154 uq32.unique_len = uq.unique_len;
155 if (copy_to_user((void __user *)arg, &uq32, sizeof(uq32)))
156 return -EFAULT;
157 return 0;
158 }
159
compat_drm_setunique(struct file * file,unsigned int cmd,unsigned long arg)160 static int compat_drm_setunique(struct file *file, unsigned int cmd,
161 unsigned long arg)
162 {
163 /* it's dead */
164 return -EINVAL;
165 }
166
167 #if IS_ENABLED(CONFIG_DRM_LEGACY)
168 typedef struct drm_map32 {
169 u32 offset; /* Requested physical address (0 for SAREA) */
170 u32 size; /* Requested physical size (bytes) */
171 enum drm_map_type type; /* Type of memory to map */
172 enum drm_map_flags flags; /* Flags */
173 u32 handle; /* User-space: "Handle" to pass to mmap() */
174 int mtrr; /* MTRR slot used */
175 } drm_map32_t;
176
compat_drm_getmap(struct file * file,unsigned int cmd,unsigned long arg)177 static int compat_drm_getmap(struct file *file, unsigned int cmd,
178 unsigned long arg)
179 {
180 drm_map32_t __user *argp = (void __user *)arg;
181 drm_map32_t m32;
182 struct drm_map map;
183 int err;
184
185 if (copy_from_user(&m32, argp, sizeof(m32)))
186 return -EFAULT;
187
188 map.offset = m32.offset;
189 err = drm_ioctl_kernel(file, drm_legacy_getmap_ioctl, &map, 0);
190 if (err)
191 return err;
192
193 m32.offset = map.offset;
194 m32.size = map.size;
195 m32.type = map.type;
196 m32.flags = map.flags;
197 m32.handle = ptr_to_compat((void __user *)map.handle);
198 m32.mtrr = map.mtrr;
199 if (copy_to_user(argp, &m32, sizeof(m32)))
200 return -EFAULT;
201 return 0;
202
203 }
204
compat_drm_addmap(struct file * file,unsigned int cmd,unsigned long arg)205 static int compat_drm_addmap(struct file *file, unsigned int cmd,
206 unsigned long arg)
207 {
208 drm_map32_t __user *argp = (void __user *)arg;
209 drm_map32_t m32;
210 struct drm_map map;
211 int err;
212
213 if (copy_from_user(&m32, argp, sizeof(m32)))
214 return -EFAULT;
215
216 map.offset = m32.offset;
217 map.size = m32.size;
218 map.type = m32.type;
219 map.flags = m32.flags;
220
221 err = drm_ioctl_kernel(file, drm_legacy_addmap_ioctl, &map,
222 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
223 if (err)
224 return err;
225
226 m32.offset = map.offset;
227 m32.mtrr = map.mtrr;
228 m32.handle = ptr_to_compat((void __user *)map.handle);
229 if (map.handle != compat_ptr(m32.handle))
230 pr_err_ratelimited("compat_drm_addmap truncated handle %p for type %d offset %x\n",
231 map.handle, m32.type, m32.offset);
232
233 if (copy_to_user(argp, &m32, sizeof(m32)))
234 return -EFAULT;
235
236 return 0;
237 }
238
compat_drm_rmmap(struct file * file,unsigned int cmd,unsigned long arg)239 static int compat_drm_rmmap(struct file *file, unsigned int cmd,
240 unsigned long arg)
241 {
242 drm_map32_t __user *argp = (void __user *)arg;
243 struct drm_map map;
244 u32 handle;
245
246 if (get_user(handle, &argp->handle))
247 return -EFAULT;
248 map.handle = compat_ptr(handle);
249 return drm_ioctl_kernel(file, drm_legacy_rmmap_ioctl, &map, DRM_AUTH);
250 }
251 #endif
252
253 typedef struct drm_client32 {
254 int idx; /* Which client desired? */
255 int auth; /* Is client authenticated? */
256 u32 pid; /* Process ID */
257 u32 uid; /* User ID */
258 u32 magic; /* Magic */
259 u32 iocs; /* Ioctl count */
260 } drm_client32_t;
261
compat_drm_getclient(struct file * file,unsigned int cmd,unsigned long arg)262 static int compat_drm_getclient(struct file *file, unsigned int cmd,
263 unsigned long arg)
264 {
265 drm_client32_t c32;
266 drm_client32_t __user *argp = (void __user *)arg;
267 struct drm_client client;
268 int err;
269
270 if (copy_from_user(&c32, argp, sizeof(c32)))
271 return -EFAULT;
272
273 client.idx = c32.idx;
274
275 err = drm_ioctl_kernel(file, drm_getclient, &client, 0);
276 if (err)
277 return err;
278
279 c32.idx = client.idx;
280 c32.auth = client.auth;
281 c32.pid = client.pid;
282 c32.uid = client.uid;
283 c32.magic = client.magic;
284 c32.iocs = client.iocs;
285
286 if (copy_to_user(argp, &c32, sizeof(c32)))
287 return -EFAULT;
288 return 0;
289 }
290
291 typedef struct drm_stats32 {
292 u32 count;
293 struct {
294 u32 value;
295 enum drm_stat_type type;
296 } data[15];
297 } drm_stats32_t;
298
compat_drm_getstats(struct file * file,unsigned int cmd,unsigned long arg)299 static int compat_drm_getstats(struct file *file, unsigned int cmd,
300 unsigned long arg)
301 {
302 drm_stats32_t __user *argp = (void __user *)arg;
303 int err;
304
305 err = drm_ioctl_kernel(file, drm_noop, NULL, 0);
306 if (err)
307 return err;
308
309 if (clear_user(argp, sizeof(drm_stats32_t)))
310 return -EFAULT;
311 return 0;
312 }
313
314 #if IS_ENABLED(CONFIG_DRM_LEGACY)
315 typedef struct drm_buf_desc32 {
316 int count; /* Number of buffers of this size */
317 int size; /* Size in bytes */
318 int low_mark; /* Low water mark */
319 int high_mark; /* High water mark */
320 int flags;
321 u32 agp_start; /* Start address in the AGP aperture */
322 } drm_buf_desc32_t;
323
compat_drm_addbufs(struct file * file,unsigned int cmd,unsigned long arg)324 static int compat_drm_addbufs(struct file *file, unsigned int cmd,
325 unsigned long arg)
326 {
327 drm_buf_desc32_t __user *argp = (void __user *)arg;
328 drm_buf_desc32_t desc32;
329 struct drm_buf_desc desc;
330 int err;
331
332 if (copy_from_user(&desc32, argp, sizeof(drm_buf_desc32_t)))
333 return -EFAULT;
334
335 desc = (struct drm_buf_desc){
336 desc32.count, desc32.size, desc32.low_mark, desc32.high_mark,
337 desc32.flags, desc32.agp_start
338 };
339
340 err = drm_ioctl_kernel(file, drm_legacy_addbufs, &desc,
341 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
342 if (err)
343 return err;
344
345 desc32 = (drm_buf_desc32_t){
346 desc.count, desc.size, desc.low_mark, desc.high_mark,
347 desc.flags, desc.agp_start
348 };
349 if (copy_to_user(argp, &desc32, sizeof(drm_buf_desc32_t)))
350 return -EFAULT;
351
352 return 0;
353 }
354
compat_drm_markbufs(struct file * file,unsigned int cmd,unsigned long arg)355 static int compat_drm_markbufs(struct file *file, unsigned int cmd,
356 unsigned long arg)
357 {
358 drm_buf_desc32_t b32;
359 drm_buf_desc32_t __user *argp = (void __user *)arg;
360 struct drm_buf_desc buf;
361
362 if (copy_from_user(&b32, argp, sizeof(b32)))
363 return -EFAULT;
364
365 buf.size = b32.size;
366 buf.low_mark = b32.low_mark;
367 buf.high_mark = b32.high_mark;
368
369 return drm_ioctl_kernel(file, drm_legacy_markbufs, &buf,
370 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
371 }
372
373 typedef struct drm_buf_info32 {
374 int count; /**< Entries in list */
375 u32 list;
376 } drm_buf_info32_t;
377
copy_one_buf32(void * data,int count,struct drm_buf_entry * from)378 static int copy_one_buf32(void *data, int count, struct drm_buf_entry *from)
379 {
380 drm_buf_info32_t *request = data;
381 drm_buf_desc32_t __user *to = compat_ptr(request->list);
382 drm_buf_desc32_t v = {.count = from->buf_count,
383 .size = from->buf_size,
384 .low_mark = from->low_mark,
385 .high_mark = from->high_mark};
386
387 if (copy_to_user(to + count, &v, offsetof(drm_buf_desc32_t, flags)))
388 return -EFAULT;
389 return 0;
390 }
391
drm_legacy_infobufs32(struct drm_device * dev,void * data,struct drm_file * file_priv)392 static int drm_legacy_infobufs32(struct drm_device *dev, void *data,
393 struct drm_file *file_priv)
394 {
395 drm_buf_info32_t *request = data;
396 return __drm_legacy_infobufs(dev, data, &request->count, copy_one_buf32);
397 }
398
compat_drm_infobufs(struct file * file,unsigned int cmd,unsigned long arg)399 static int compat_drm_infobufs(struct file *file, unsigned int cmd,
400 unsigned long arg)
401 {
402 drm_buf_info32_t req32;
403 drm_buf_info32_t __user *argp = (void __user *)arg;
404 int err;
405
406 if (copy_from_user(&req32, argp, sizeof(req32)))
407 return -EFAULT;
408
409 if (req32.count < 0)
410 req32.count = 0;
411
412 err = drm_ioctl_kernel(file, drm_legacy_infobufs32, &req32, DRM_AUTH);
413 if (err)
414 return err;
415
416 if (put_user(req32.count, &argp->count))
417 return -EFAULT;
418
419 return 0;
420 }
421
422 typedef struct drm_buf_pub32 {
423 int idx; /**< Index into the master buffer list */
424 int total; /**< Buffer size */
425 int used; /**< Amount of buffer in use (for DMA) */
426 u32 address; /**< Address of buffer */
427 } drm_buf_pub32_t;
428
429 typedef struct drm_buf_map32 {
430 int count; /**< Length of the buffer list */
431 u32 virtual; /**< Mmap'd area in user-virtual */
432 u32 list; /**< Buffer information */
433 } drm_buf_map32_t;
434
map_one_buf32(void * data,int idx,unsigned long virtual,struct drm_buf * buf)435 static int map_one_buf32(void *data, int idx, unsigned long virtual,
436 struct drm_buf *buf)
437 {
438 drm_buf_map32_t *request = data;
439 drm_buf_pub32_t __user *to = compat_ptr(request->list) + idx;
440 drm_buf_pub32_t v;
441
442 v.idx = buf->idx;
443 v.total = buf->total;
444 v.used = 0;
445 v.address = virtual + buf->offset;
446 if (copy_to_user(to, &v, sizeof(v)))
447 return -EFAULT;
448 return 0;
449 }
450
drm_legacy_mapbufs32(struct drm_device * dev,void * data,struct drm_file * file_priv)451 static int drm_legacy_mapbufs32(struct drm_device *dev, void *data,
452 struct drm_file *file_priv)
453 {
454 drm_buf_map32_t *request = data;
455 void __user *v;
456 int err = __drm_legacy_mapbufs(dev, data, &request->count,
457 &v, map_one_buf32,
458 file_priv);
459 request->virtual = ptr_to_compat(v);
460 return err;
461 }
462
compat_drm_mapbufs(struct file * file,unsigned int cmd,unsigned long arg)463 static int compat_drm_mapbufs(struct file *file, unsigned int cmd,
464 unsigned long arg)
465 {
466 drm_buf_map32_t __user *argp = (void __user *)arg;
467 drm_buf_map32_t req32;
468 int err;
469
470 if (copy_from_user(&req32, argp, sizeof(req32)))
471 return -EFAULT;
472 if (req32.count < 0)
473 return -EINVAL;
474
475 err = drm_ioctl_kernel(file, drm_legacy_mapbufs32, &req32, DRM_AUTH);
476 if (err)
477 return err;
478
479 if (put_user(req32.count, &argp->count)
480 || put_user(req32.virtual, &argp->virtual))
481 return -EFAULT;
482
483 return 0;
484 }
485
486 typedef struct drm_buf_free32 {
487 int count;
488 u32 list;
489 } drm_buf_free32_t;
490
compat_drm_freebufs(struct file * file,unsigned int cmd,unsigned long arg)491 static int compat_drm_freebufs(struct file *file, unsigned int cmd,
492 unsigned long arg)
493 {
494 drm_buf_free32_t req32;
495 struct drm_buf_free request;
496 drm_buf_free32_t __user *argp = (void __user *)arg;
497
498 if (copy_from_user(&req32, argp, sizeof(req32)))
499 return -EFAULT;
500
501 request.count = req32.count;
502 request.list = compat_ptr(req32.list);
503 return drm_ioctl_kernel(file, drm_legacy_freebufs, &request, DRM_AUTH);
504 }
505
506 typedef struct drm_ctx_priv_map32 {
507 unsigned int ctx_id; /**< Context requesting private mapping */
508 u32 handle; /**< Handle of map */
509 } drm_ctx_priv_map32_t;
510
compat_drm_setsareactx(struct file * file,unsigned int cmd,unsigned long arg)511 static int compat_drm_setsareactx(struct file *file, unsigned int cmd,
512 unsigned long arg)
513 {
514 drm_ctx_priv_map32_t req32;
515 struct drm_ctx_priv_map request;
516 drm_ctx_priv_map32_t __user *argp = (void __user *)arg;
517
518 if (copy_from_user(&req32, argp, sizeof(req32)))
519 return -EFAULT;
520
521 request.ctx_id = req32.ctx_id;
522 request.handle = compat_ptr(req32.handle);
523 return drm_ioctl_kernel(file, drm_legacy_setsareactx, &request,
524 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
525 }
526
compat_drm_getsareactx(struct file * file,unsigned int cmd,unsigned long arg)527 static int compat_drm_getsareactx(struct file *file, unsigned int cmd,
528 unsigned long arg)
529 {
530 struct drm_ctx_priv_map req;
531 drm_ctx_priv_map32_t req32;
532 drm_ctx_priv_map32_t __user *argp = (void __user *)arg;
533 int err;
534
535 if (copy_from_user(&req32, argp, sizeof(req32)))
536 return -EFAULT;
537
538 req.ctx_id = req32.ctx_id;
539 err = drm_ioctl_kernel(file, drm_legacy_getsareactx, &req, DRM_AUTH);
540 if (err)
541 return err;
542
543 req32.handle = ptr_to_compat((void __user *)req.handle);
544 if (copy_to_user(argp, &req32, sizeof(req32)))
545 return -EFAULT;
546
547 return 0;
548 }
549
550 typedef struct drm_ctx_res32 {
551 int count;
552 u32 contexts;
553 } drm_ctx_res32_t;
554
compat_drm_resctx(struct file * file,unsigned int cmd,unsigned long arg)555 static int compat_drm_resctx(struct file *file, unsigned int cmd,
556 unsigned long arg)
557 {
558 drm_ctx_res32_t __user *argp = (void __user *)arg;
559 drm_ctx_res32_t res32;
560 struct drm_ctx_res res;
561 int err;
562
563 if (copy_from_user(&res32, argp, sizeof(res32)))
564 return -EFAULT;
565
566 res.count = res32.count;
567 res.contexts = compat_ptr(res32.contexts);
568 err = drm_ioctl_kernel(file, drm_legacy_resctx, &res, DRM_AUTH);
569 if (err)
570 return err;
571
572 res32.count = res.count;
573 if (copy_to_user(argp, &res32, sizeof(res32)))
574 return -EFAULT;
575
576 return 0;
577 }
578
579 typedef struct drm_dma32 {
580 int context; /**< Context handle */
581 int send_count; /**< Number of buffers to send */
582 u32 send_indices; /**< List of handles to buffers */
583 u32 send_sizes; /**< Lengths of data to send */
584 enum drm_dma_flags flags; /**< Flags */
585 int request_count; /**< Number of buffers requested */
586 int request_size; /**< Desired size for buffers */
587 u32 request_indices; /**< Buffer information */
588 u32 request_sizes;
589 int granted_count; /**< Number of buffers granted */
590 } drm_dma32_t;
591
compat_drm_dma(struct file * file,unsigned int cmd,unsigned long arg)592 static int compat_drm_dma(struct file *file, unsigned int cmd,
593 unsigned long arg)
594 {
595 drm_dma32_t d32;
596 drm_dma32_t __user *argp = (void __user *)arg;
597 struct drm_dma d;
598 int err;
599
600 if (copy_from_user(&d32, argp, sizeof(d32)))
601 return -EFAULT;
602
603 d.context = d32.context;
604 d.send_count = d32.send_count;
605 d.send_indices = compat_ptr(d32.send_indices);
606 d.send_sizes = compat_ptr(d32.send_sizes);
607 d.flags = d32.flags;
608 d.request_count = d32.request_count;
609 d.request_indices = compat_ptr(d32.request_indices);
610 d.request_sizes = compat_ptr(d32.request_sizes);
611 err = drm_ioctl_kernel(file, drm_legacy_dma_ioctl, &d, DRM_AUTH);
612 if (err)
613 return err;
614
615 if (put_user(d.request_size, &argp->request_size)
616 || put_user(d.granted_count, &argp->granted_count))
617 return -EFAULT;
618
619 return 0;
620 }
621 #endif
622
623 #if IS_ENABLED(CONFIG_AGP)
624 typedef struct drm_agp_mode32 {
625 u32 mode; /**< AGP mode */
626 } drm_agp_mode32_t;
627
compat_drm_agp_enable(struct file * file,unsigned int cmd,unsigned long arg)628 static int compat_drm_agp_enable(struct file *file, unsigned int cmd,
629 unsigned long arg)
630 {
631 drm_agp_mode32_t __user *argp = (void __user *)arg;
632 struct drm_agp_mode mode;
633
634 if (get_user(mode.mode, &argp->mode))
635 return -EFAULT;
636
637 return drm_ioctl_kernel(file, drm_agp_enable_ioctl, &mode,
638 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
639 }
640
641 typedef struct drm_agp_info32 {
642 int agp_version_major;
643 int agp_version_minor;
644 u32 mode;
645 u32 aperture_base; /* physical address */
646 u32 aperture_size; /* bytes */
647 u32 memory_allowed; /* bytes */
648 u32 memory_used;
649
650 /* PCI information */
651 unsigned short id_vendor;
652 unsigned short id_device;
653 } drm_agp_info32_t;
654
compat_drm_agp_info(struct file * file,unsigned int cmd,unsigned long arg)655 static int compat_drm_agp_info(struct file *file, unsigned int cmd,
656 unsigned long arg)
657 {
658 drm_agp_info32_t __user *argp = (void __user *)arg;
659 drm_agp_info32_t i32;
660 struct drm_agp_info info;
661 int err;
662
663 err = drm_ioctl_kernel(file, drm_agp_info_ioctl, &info, DRM_AUTH);
664 if (err)
665 return err;
666
667 i32.agp_version_major = info.agp_version_major;
668 i32.agp_version_minor = info.agp_version_minor;
669 i32.mode = info.mode;
670 i32.aperture_base = info.aperture_base;
671 i32.aperture_size = info.aperture_size;
672 i32.memory_allowed = info.memory_allowed;
673 i32.memory_used = info.memory_used;
674 i32.id_vendor = info.id_vendor;
675 i32.id_device = info.id_device;
676 if (copy_to_user(argp, &i32, sizeof(i32)))
677 return -EFAULT;
678
679 return 0;
680 }
681
682 typedef struct drm_agp_buffer32 {
683 u32 size; /**< In bytes -- will round to page boundary */
684 u32 handle; /**< Used for binding / unbinding */
685 u32 type; /**< Type of memory to allocate */
686 u32 physical; /**< Physical used by i810 */
687 } drm_agp_buffer32_t;
688
compat_drm_agp_alloc(struct file * file,unsigned int cmd,unsigned long arg)689 static int compat_drm_agp_alloc(struct file *file, unsigned int cmd,
690 unsigned long arg)
691 {
692 drm_agp_buffer32_t __user *argp = (void __user *)arg;
693 drm_agp_buffer32_t req32;
694 struct drm_agp_buffer request;
695 int err;
696
697 if (copy_from_user(&req32, argp, sizeof(req32)))
698 return -EFAULT;
699
700 request.size = req32.size;
701 request.type = req32.type;
702 err = drm_ioctl_kernel(file, drm_agp_alloc_ioctl, &request,
703 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
704 if (err)
705 return err;
706
707 req32.handle = request.handle;
708 req32.physical = request.physical;
709 if (copy_to_user(argp, &req32, sizeof(req32))) {
710 drm_ioctl_kernel(file, drm_agp_free_ioctl, &request,
711 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
712 return -EFAULT;
713 }
714
715 return 0;
716 }
717
compat_drm_agp_free(struct file * file,unsigned int cmd,unsigned long arg)718 static int compat_drm_agp_free(struct file *file, unsigned int cmd,
719 unsigned long arg)
720 {
721 drm_agp_buffer32_t __user *argp = (void __user *)arg;
722 struct drm_agp_buffer request;
723
724 if (get_user(request.handle, &argp->handle))
725 return -EFAULT;
726
727 return drm_ioctl_kernel(file, drm_agp_free_ioctl, &request,
728 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
729 }
730
731 typedef struct drm_agp_binding32 {
732 u32 handle; /**< From drm_agp_buffer */
733 u32 offset; /**< In bytes -- will round to page boundary */
734 } drm_agp_binding32_t;
735
compat_drm_agp_bind(struct file * file,unsigned int cmd,unsigned long arg)736 static int compat_drm_agp_bind(struct file *file, unsigned int cmd,
737 unsigned long arg)
738 {
739 drm_agp_binding32_t __user *argp = (void __user *)arg;
740 drm_agp_binding32_t req32;
741 struct drm_agp_binding request;
742
743 if (copy_from_user(&req32, argp, sizeof(req32)))
744 return -EFAULT;
745
746 request.handle = req32.handle;
747 request.offset = req32.offset;
748 return drm_ioctl_kernel(file, drm_agp_bind_ioctl, &request,
749 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
750 }
751
compat_drm_agp_unbind(struct file * file,unsigned int cmd,unsigned long arg)752 static int compat_drm_agp_unbind(struct file *file, unsigned int cmd,
753 unsigned long arg)
754 {
755 drm_agp_binding32_t __user *argp = (void __user *)arg;
756 struct drm_agp_binding request;
757
758 if (get_user(request.handle, &argp->handle))
759 return -EFAULT;
760
761 return drm_ioctl_kernel(file, drm_agp_unbind_ioctl, &request,
762 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
763 }
764 #endif /* CONFIG_AGP */
765
766 #if IS_ENABLED(CONFIG_DRM_LEGACY)
767 typedef struct drm_scatter_gather32 {
768 u32 size; /**< In bytes -- will round to page boundary */
769 u32 handle; /**< Used for mapping / unmapping */
770 } drm_scatter_gather32_t;
771
compat_drm_sg_alloc(struct file * file,unsigned int cmd,unsigned long arg)772 static int compat_drm_sg_alloc(struct file *file, unsigned int cmd,
773 unsigned long arg)
774 {
775 drm_scatter_gather32_t __user *argp = (void __user *)arg;
776 struct drm_scatter_gather request;
777 int err;
778
779 if (get_user(request.size, &argp->size))
780 return -EFAULT;
781
782 err = drm_ioctl_kernel(file, drm_legacy_sg_alloc, &request,
783 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
784 if (err)
785 return err;
786
787 /* XXX not sure about the handle conversion here... */
788 if (put_user(request.handle >> PAGE_SHIFT, &argp->handle))
789 return -EFAULT;
790
791 return 0;
792 }
793
compat_drm_sg_free(struct file * file,unsigned int cmd,unsigned long arg)794 static int compat_drm_sg_free(struct file *file, unsigned int cmd,
795 unsigned long arg)
796 {
797 drm_scatter_gather32_t __user *argp = (void __user *)arg;
798 struct drm_scatter_gather request;
799 unsigned long x;
800
801 if (get_user(x, &argp->handle))
802 return -EFAULT;
803 request.handle = x << PAGE_SHIFT;
804 return drm_ioctl_kernel(file, drm_legacy_sg_free, &request,
805 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
806 }
807 #endif
808 #if defined(CONFIG_X86)
809 typedef struct drm_update_draw32 {
810 drm_drawable_t handle;
811 unsigned int type;
812 unsigned int num;
813 /* 64-bit version has a 32-bit pad here */
814 u64 data; /**< Pointer */
815 } __attribute__((packed)) drm_update_draw32_t;
816
compat_drm_update_draw(struct file * file,unsigned int cmd,unsigned long arg)817 static int compat_drm_update_draw(struct file *file, unsigned int cmd,
818 unsigned long arg)
819 {
820 drm_update_draw32_t update32;
821 if (copy_from_user(&update32, (void __user *)arg, sizeof(update32)))
822 return -EFAULT;
823
824 return drm_ioctl_kernel(file, drm_noop, NULL,
825 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);
826 }
827 #endif
828
829 struct drm_wait_vblank_request32 {
830 enum drm_vblank_seq_type type;
831 unsigned int sequence;
832 u32 signal;
833 };
834
835 struct drm_wait_vblank_reply32 {
836 enum drm_vblank_seq_type type;
837 unsigned int sequence;
838 s32 tval_sec;
839 s32 tval_usec;
840 };
841
842 typedef union drm_wait_vblank32 {
843 struct drm_wait_vblank_request32 request;
844 struct drm_wait_vblank_reply32 reply;
845 } drm_wait_vblank32_t;
846
compat_drm_wait_vblank(struct file * file,unsigned int cmd,unsigned long arg)847 static int compat_drm_wait_vblank(struct file *file, unsigned int cmd,
848 unsigned long arg)
849 {
850 drm_wait_vblank32_t __user *argp = (void __user *)arg;
851 drm_wait_vblank32_t req32;
852 union drm_wait_vblank req;
853 int err;
854
855 if (copy_from_user(&req32, argp, sizeof(req32)))
856 return -EFAULT;
857
858 req.request.type = req32.request.type;
859 req.request.sequence = req32.request.sequence;
860 req.request.signal = req32.request.signal;
861 err = drm_ioctl_kernel(file, drm_wait_vblank_ioctl, &req, DRM_UNLOCKED);
862 if (err)
863 return err;
864
865 req32.reply.type = req.reply.type;
866 req32.reply.sequence = req.reply.sequence;
867 req32.reply.tval_sec = req.reply.tval_sec;
868 req32.reply.tval_usec = req.reply.tval_usec;
869 if (copy_to_user(argp, &req32, sizeof(req32)))
870 return -EFAULT;
871
872 return 0;
873 }
874
875 #if defined(CONFIG_X86)
876 typedef struct drm_mode_fb_cmd232 {
877 u32 fb_id;
878 u32 width;
879 u32 height;
880 u32 pixel_format;
881 u32 flags;
882 u32 handles[4];
883 u32 pitches[4];
884 u32 offsets[4];
885 u64 modifier[4];
886 } __attribute__((packed)) drm_mode_fb_cmd232_t;
887
compat_drm_mode_addfb2(struct file * file,unsigned int cmd,unsigned long arg)888 static int compat_drm_mode_addfb2(struct file *file, unsigned int cmd,
889 unsigned long arg)
890 {
891 struct drm_mode_fb_cmd232 __user *argp = (void __user *)arg;
892 struct drm_mode_fb_cmd2 req64;
893 int err;
894
895 if (copy_from_user(&req64, argp,
896 offsetof(drm_mode_fb_cmd232_t, modifier)))
897 return -EFAULT;
898
899 if (copy_from_user(&req64.modifier, &argp->modifier,
900 sizeof(req64.modifier)))
901 return -EFAULT;
902
903 err = drm_ioctl_kernel(file, drm_mode_addfb2, &req64, 0);
904 if (err)
905 return err;
906
907 if (put_user(req64.fb_id, &argp->fb_id))
908 return -EFAULT;
909
910 return 0;
911 }
912 #endif
913
914 static struct {
915 drm_ioctl_compat_t *fn;
916 char *name;
917 } drm_compat_ioctls[] = {
918 #define DRM_IOCTL32_DEF(n, f) [DRM_IOCTL_NR(n##32)] = {.fn = f, .name = #n}
919 DRM_IOCTL32_DEF(DRM_IOCTL_VERSION, compat_drm_version),
920 DRM_IOCTL32_DEF(DRM_IOCTL_GET_UNIQUE, compat_drm_getunique),
921 #if IS_ENABLED(CONFIG_DRM_LEGACY)
922 DRM_IOCTL32_DEF(DRM_IOCTL_GET_MAP, compat_drm_getmap),
923 #endif
924 DRM_IOCTL32_DEF(DRM_IOCTL_GET_CLIENT, compat_drm_getclient),
925 DRM_IOCTL32_DEF(DRM_IOCTL_GET_STATS, compat_drm_getstats),
926 DRM_IOCTL32_DEF(DRM_IOCTL_SET_UNIQUE, compat_drm_setunique),
927 #if IS_ENABLED(CONFIG_DRM_LEGACY)
928 DRM_IOCTL32_DEF(DRM_IOCTL_ADD_MAP, compat_drm_addmap),
929 DRM_IOCTL32_DEF(DRM_IOCTL_ADD_BUFS, compat_drm_addbufs),
930 DRM_IOCTL32_DEF(DRM_IOCTL_MARK_BUFS, compat_drm_markbufs),
931 DRM_IOCTL32_DEF(DRM_IOCTL_INFO_BUFS, compat_drm_infobufs),
932 DRM_IOCTL32_DEF(DRM_IOCTL_MAP_BUFS, compat_drm_mapbufs),
933 DRM_IOCTL32_DEF(DRM_IOCTL_FREE_BUFS, compat_drm_freebufs),
934 DRM_IOCTL32_DEF(DRM_IOCTL_RM_MAP, compat_drm_rmmap),
935 DRM_IOCTL32_DEF(DRM_IOCTL_SET_SAREA_CTX, compat_drm_setsareactx),
936 DRM_IOCTL32_DEF(DRM_IOCTL_GET_SAREA_CTX, compat_drm_getsareactx),
937 DRM_IOCTL32_DEF(DRM_IOCTL_RES_CTX, compat_drm_resctx),
938 DRM_IOCTL32_DEF(DRM_IOCTL_DMA, compat_drm_dma),
939 #endif
940 #if IS_ENABLED(CONFIG_AGP)
941 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_ENABLE, compat_drm_agp_enable),
942 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_INFO, compat_drm_agp_info),
943 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_ALLOC, compat_drm_agp_alloc),
944 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_FREE, compat_drm_agp_free),
945 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_BIND, compat_drm_agp_bind),
946 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_UNBIND, compat_drm_agp_unbind),
947 #endif
948 #if IS_ENABLED(CONFIG_DRM_LEGACY)
949 DRM_IOCTL32_DEF(DRM_IOCTL_SG_ALLOC, compat_drm_sg_alloc),
950 DRM_IOCTL32_DEF(DRM_IOCTL_SG_FREE, compat_drm_sg_free),
951 #endif
952 #if defined(CONFIG_X86) || defined(CONFIG_IA64)
953 DRM_IOCTL32_DEF(DRM_IOCTL_UPDATE_DRAW, compat_drm_update_draw),
954 #endif
955 DRM_IOCTL32_DEF(DRM_IOCTL_WAIT_VBLANK, compat_drm_wait_vblank),
956 #if defined(CONFIG_X86) || defined(CONFIG_IA64)
957 DRM_IOCTL32_DEF(DRM_IOCTL_MODE_ADDFB2, compat_drm_mode_addfb2),
958 #endif
959 };
960
961 /**
962 * drm_compat_ioctl - 32bit IOCTL compatibility handler for DRM drivers
963 * @filp: file this ioctl is called on
964 * @cmd: ioctl cmd number
965 * @arg: user argument
966 *
967 * Compatibility handler for 32 bit userspace running on 64 kernels. All actual
968 * IOCTL handling is forwarded to drm_ioctl(), while marshalling structures as
969 * appropriate. Note that this only handles DRM core IOCTLs, if the driver has
970 * botched IOCTL itself, it must handle those by wrapping this function.
971 *
972 * Returns:
973 * Zero on success, negative error code on failure.
974 */
drm_compat_ioctl(struct file * filp,unsigned int cmd,unsigned long arg)975 long drm_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
976 {
977 unsigned int nr = DRM_IOCTL_NR(cmd);
978 struct drm_file *file_priv = filp->private_data;
979 drm_ioctl_compat_t *fn;
980 int ret;
981
982 /* Assume that ioctls without an explicit compat routine will just
983 * work. This may not always be a good assumption, but it's better
984 * than always failing.
985 */
986 if (nr >= ARRAY_SIZE(drm_compat_ioctls))
987 return drm_ioctl(filp, cmd, arg);
988
989 fn = drm_compat_ioctls[nr].fn;
990 if (!fn)
991 return drm_ioctl(filp, cmd, arg);
992
993 DRM_DEBUG("pid=%d, dev=0x%lx, auth=%d, %s\n",
994 task_pid_nr(current),
995 (long)old_encode_dev(file_priv->minor->kdev->devt),
996 file_priv->authenticated,
997 drm_compat_ioctls[nr].name);
998 ret = (*fn)(filp, cmd, arg);
999 if (ret)
1000 DRM_DEBUG("ret = %d\n", ret);
1001 return ret;
1002 }
1003 EXPORT_SYMBOL(drm_compat_ioctl);
1004