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