arch/sparc64/kernel/ioctl32.c

   1 /* $Id: ioctl32.c,v 1.136 2002/01/14 09:49:52 davem Exp $
   2  * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
   3  *
   4  * Copyright (C) 1997-2000  Jakub Jelinek  (jakub@redhat.com)
   5  * Copyright (C) 1998  Eddie C. Dost  (ecd@skynet.be)
   6  * Copyright (C) 2003  Pavel Machek (pavel@suse.cz)
   7  *
   8  * These routines maintain argument size conversion between 32bit and 64bit
   9  * ioctls.
  10  */
  11
  12 #define INCLUDES
  13 #include "compat_ioctl.c"
  14 #include <linux/ncp_fs.h>
  15 #include <linux/syscalls.h>
  16 #include <asm/fbio.h>
  17 #include <asm/kbio.h>
  18 #include <asm/vuid_event.h>
  19 #include <asm/envctrl.h>
  20 #include <asm/display7seg.h>
  21 #include <asm/openpromio.h>
  22 #include <asm/audioio.h>
  23 #include <asm/watchdog.h>
  24
  25 /* Use this to get at 32-bit user passed pointers.
  26  * See sys_sparc32.c for description about it.
  27  */
  28 #define A(__x) ((void __user *)(unsigned long)(__x))
  29
  30 static __inline__ void *alloc_user_space(long len)
  31 {
  32         struct pt_regs *regs = current_thread_info()->kregs;
  33         unsigned long usp = regs->u_regs[UREG_I6];
  34
  35         if (!(test_thread_flag(TIF_32BIT)))
  36                 usp += STACK_BIAS;
  37
  38         return (void *) (usp - len);
  39 }
  40
  41 #define CODE
  42 #include "compat_ioctl.c"
  43
  44 struct  fbcmap32 {
  45         int             index;          /* first element (0 origin) */
  46         int             count;
  47         u32             red;
  48         u32             green;
  49         u32             blue;
  50 };
  51
  52 #define FBIOPUTCMAP32   _IOW('F', 3, struct fbcmap32)
  53 #define FBIOGETCMAP32   _IOW('F', 4, struct fbcmap32)
  54
  55 static int fbiogetputcmap(unsigned int fd, unsigned int cmd, unsigned long arg)
  56 {
  57         struct fbcmap f;
  58         int ret;
  59         char red[256], green[256], blue[256];
  60         u32 r, g, b;
  61         mm_segment_t old_fs = get_fs();
  62
  63         ret = get_user(f.index, &(((struct fbcmap32 *)arg)->index));
  64         ret |= __get_user(f.count, &(((struct fbcmap32 *)arg)->count));
  65         ret |= __get_user(r, &(((struct fbcmap32 *)arg)->red));
  66         ret |= __get_user(g, &(((struct fbcmap32 *)arg)->green));
  67         ret |= __get_user(b, &(((struct fbcmap32 *)arg)->blue));
  68         if (ret)
  69                 return -EFAULT;
  70         if ((f.index < 0) || (f.index > 255)) return -EINVAL;
  71         if (f.index + f.count > 256)
  72                 f.count = 256 - f.index;
  73         if (cmd == FBIOPUTCMAP32) {
  74                 ret = copy_from_user (red, A(r), f.count);
  75                 ret |= copy_from_user (green, A(g), f.count);
  76                 ret |= copy_from_user (blue, A(b), f.count);
  77                 if (ret)
  78                         return -EFAULT;
  79         }
  80         f.red = red; f.green = green; f.blue = blue;
  81         set_fs (KERNEL_DS);
  82         ret = sys_ioctl (fd, (cmd == FBIOPUTCMAP32) ? FBIOPUTCMAP_SPARC : FBIOGETCMAP_SPARC, (long)&f);
  83         set_fs (old_fs);
  84         if (!ret && cmd == FBIOGETCMAP32) {
  85                 ret = copy_to_user (A(r), red, f.count);
  86                 ret |= copy_to_user (A(g), green, f.count);
  87                 ret |= copy_to_user (A(b), blue, f.count);
  88         }
  89         return ret ? -EFAULT : 0;
  90 }
  91
  92 struct fbcursor32 {
  93         short set;              /* what to set, choose from the list above */
  94         short enable;           /* cursor on/off */
  95         struct fbcurpos pos;    /* cursor position */
  96         struct fbcurpos hot;    /* cursor hot spot */
  97         struct fbcmap32 cmap;   /* color map info */
  98         struct fbcurpos size;   /* cursor bit map size */
  99         u32     image;          /* cursor image bits */
 100         u32     mask;           /* cursor mask bits */
 101 };
 102
 103 #define FBIOSCURSOR32   _IOW('F', 24, struct fbcursor32)
 104 #define FBIOGCURSOR32   _IOW('F', 25, struct fbcursor32)
 105
 106 static int fbiogscursor(unsigned int fd, unsigned int cmd, unsigned long arg)
 107 {
 108         struct fbcursor f;
 109         int ret;
 110         char red[2], green[2], blue[2];
 111         char image[128], mask[128];
 112         u32 r, g, b;
 113         u32 m, i;
 114         mm_segment_t old_fs = get_fs();
 115
 116         ret = copy_from_user (&f, (struct fbcursor32 *)arg, 2 * sizeof (short) + 2 * sizeof(struct fbcurpos));
 117         ret |= __get_user(f.size.x, &(((struct fbcursor32 *)arg)->size.x));
 118         ret |= __get_user(f.size.y, &(((struct fbcursor32 *)arg)->size.y));
 119         ret |= __get_user(f.cmap.index, &(((struct fbcursor32 *)arg)->cmap.index));
 120         ret |= __get_user(f.cmap.count, &(((struct fbcursor32 *)arg)->cmap.count));
 121         ret |= __get_user(r, &(((struct fbcursor32 *)arg)->cmap.red));
 122         ret |= __get_user(g, &(((struct fbcursor32 *)arg)->cmap.green));
 123         ret |= __get_user(b, &(((struct fbcursor32 *)arg)->cmap.blue));
 124         ret |= __get_user(m, &(((struct fbcursor32 *)arg)->mask));
 125         ret |= __get_user(i, &(((struct fbcursor32 *)arg)->image));
 126         if (ret)
 127                 return -EFAULT;
 128         if (f.set & FB_CUR_SETCMAP) {
 129                 if ((uint) f.size.y > 32)
 130                         return -EINVAL;
 131                 ret = copy_from_user (mask, A(m), f.size.y * 4);
 132                 ret |= copy_from_user (image, A(i), f.size.y * 4);
 133                 if (ret)
 134                         return -EFAULT;
 135                 f.image = image; f.mask = mask;
 136         }
 137         if (f.set & FB_CUR_SETCMAP) {
 138                 ret = copy_from_user (red, A(r), 2);
 139                 ret |= copy_from_user (green, A(g), 2);
 140                 ret |= copy_from_user (blue, A(b), 2);
 141                 if (ret)
 142                         return -EFAULT;
 143                 f.cmap.red = red; f.cmap.green = green; f.cmap.blue = blue;
 144         }
 145         set_fs (KERNEL_DS);
 146         ret = sys_ioctl (fd, FBIOSCURSOR, (long)&f);
 147         set_fs (old_fs);
 148         return ret;
 149 }
 150
 151 struct ncp_ioctl_request_32 {
 152         unsigned int function;
 153         unsigned int size;
 154         compat_caddr_t data;
 155 };
 156
 157 struct ncp_fs_info_v2_32 {
 158         int version;
 159         unsigned int mounted_uid;
 160         unsigned int connection;
 161         unsigned int buffer_size;
 162
 163         unsigned int volume_number;
 164         __u32 directory_id;
 165
 166         __u32 dummy1;
 167         __u32 dummy2;
 168         __u32 dummy3;
 169 };
 170
 171 struct ncp_objectname_ioctl_32
 172 {
 173         int             auth_type;
 174         unsigned int    object_name_len;
 175         compat_caddr_t  object_name;    /* an userspace data, in most cases user name */
 176 };
 177
 178 struct ncp_privatedata_ioctl_32
 179 {
 180         unsigned int    len;
 181         compat_caddr_t  data;           /* ~1000 for NDS */
 182 };
 183
 184 #define NCP_IOC_NCPREQUEST_32           _IOR('n', 1, struct ncp_ioctl_request_32)
 185
 186 #define NCP_IOC_GETMOUNTUID2_32         _IOW('n', 2, unsigned int)
 187
 188 #define NCP_IOC_GET_FS_INFO_V2_32       _IOWR('n', 4, struct ncp_fs_info_v2_32)
 189
 190 #define NCP_IOC_GETOBJECTNAME_32        _IOWR('n', 9, struct ncp_objectname_ioctl_32)
 191 #define NCP_IOC_SETOBJECTNAME_32        _IOR('n', 9, struct ncp_objectname_ioctl_32)
 192 #define NCP_IOC_GETPRIVATEDATA_32       _IOWR('n', 10, struct ncp_privatedata_ioctl_32)
 193 #define NCP_IOC_SETPRIVATEDATA_32       _IOR('n', 10, struct ncp_privatedata_ioctl_32)
 194
 195 static int do_ncp_ncprequest(unsigned int fd, unsigned int cmd, unsigned long arg)
 196 {
 197         struct ncp_ioctl_request_32 n32;
 198         struct ncp_ioctl_request n;
 199         mm_segment_t old_fs;
 200         int err;
 201
 202         if (copy_from_user(&n32, (struct ncp_ioctl_request_32*)arg,
 203             sizeof(n32)))
 204                 return -EFAULT;
 205
 206         n.function = n32.function;
 207         n.size = n32.size;
 208         if (n.size > 65536)
 209                 return -EINVAL;
 210         n.data = vmalloc(65536);        /* 65536 must be same as NCP_PACKET_SIZE_INTERNAL in ncpfs */
 211         if (!n.data)
 212                 return -ENOMEM;
 213         err = -EFAULT;
 214         if (copy_from_user(n.data, A(n32.data), n.size))
 215                 goto out;
 216
 217         old_fs = get_fs(); set_fs (KERNEL_DS);
 218         err = sys_ioctl (fd, NCP_IOC_NCPREQUEST, (unsigned long)&n);
 219         set_fs (old_fs);
 220         if(err <= 0)
 221                 goto out;
 222         if (err > 65536) {
 223                 err = -EINVAL;
 224                 goto out;
 225         }
 226         if (copy_to_user(A(n32.data), n.data, err)) {
 227                 err = -EFAULT;
 228                 goto out;
 229         }
 230  out:
 231         vfree(n.data);
 232         return err;
 233 }
 234
 235 static int do_ncp_getmountuid2(unsigned int fd, unsigned int cmd, unsigned long arg)
 236 {
 237         mm_segment_t old_fs = get_fs();
 238         __kernel_uid_t kuid;
 239         int err;
 240
 241         cmd = NCP_IOC_GETMOUNTUID2;
 242
 243         set_fs(KERNEL_DS);
 244         err = sys_ioctl(fd, cmd, (unsigned long)&kuid);
 245         set_fs(old_fs);
 246
 247         if (!err)
 248                 err = put_user(kuid, (unsigned int*)arg);
 249
 250         return err;
 251 }
 252
 253 static int do_ncp_getfsinfo2(unsigned int fd, unsigned int cmd, unsigned long arg)
 254 {
 255         mm_segment_t old_fs = get_fs();
 256         struct ncp_fs_info_v2_32 n32;
 257         struct ncp_fs_info_v2 n;
 258         int err;
 259
 260         if (copy_from_user(&n32, (struct ncp_fs_info_v2_32*)arg, sizeof(n32)))
 261                 return -EFAULT;
 262         if (n32.version != NCP_GET_FS_INFO_VERSION_V2)
 263                 return -EINVAL;
 264         n.version = NCP_GET_FS_INFO_VERSION_V2;
 265
 266         set_fs(KERNEL_DS);
 267         err = sys_ioctl(fd, NCP_IOC_GET_FS_INFO_V2, (unsigned long)&n);
 268         set_fs(old_fs);
 269
 270         if (!err) {
 271                 n32.version = n.version;
 272                 n32.mounted_uid = n.mounted_uid;
 273                 n32.connection = n.connection;
 274                 n32.buffer_size = n.buffer_size;
 275                 n32.volume_number = n.volume_number;
 276                 n32.directory_id = n.directory_id;
 277                 n32.dummy1 = n.dummy1;
 278                 n32.dummy2 = n.dummy2;
 279                 n32.dummy3 = n.dummy3;
 280                 err = copy_to_user((struct ncp_fs_info_v2_32*)arg, &n32, sizeof(n32)) ? -EFAULT : 0;
 281         }
 282         return err;
 283 }
 284
 285 static int do_ncp_getobjectname(unsigned int fd, unsigned int cmd, unsigned long arg)
 286 {
 287         struct ncp_objectname_ioctl_32 n32;
 288         struct ncp_objectname_ioctl n;
 289         mm_segment_t old_fs;
 290         int err;
 291         size_t tl;
 292
 293         if (copy_from_user(&n32, (struct ncp_objectname_ioctl_32*)arg,
 294             sizeof(n32)))
 295                 return -EFAULT;
 296
 297         n.object_name_len = tl = n32.object_name_len;
 298         if (tl) {
 299                 n.object_name = kmalloc(tl, GFP_KERNEL);
 300                 if (!n.object_name)
 301                         return -ENOMEM;
 302         } else {
 303                 n.object_name = NULL;
 304         }
 305
 306         old_fs = get_fs(); set_fs (KERNEL_DS);
 307         err = sys_ioctl (fd, NCP_IOC_GETOBJECTNAME, (unsigned long)&n);
 308         set_fs (old_fs);
 309         if(err)
 310                 goto out;
 311
 312         if (tl > n.object_name_len)
 313                 tl = n.object_name_len;
 314
 315         err = -EFAULT;
 316         if (tl && copy_to_user(A(n32.object_name), n.object_name, tl))
 317                 goto out;
 318
 319         n32.auth_type = n.auth_type;
 320         n32.object_name_len = n.object_name_len;
 321
 322         if (copy_to_user((struct ncp_objectname_ioctl_32*)arg, &n32, sizeof(n32)))
 323                 goto out;
 324
 325         err = 0;
 326  out:
 327         if (n.object_name)
 328                 kfree(n.object_name);
 329
 330         return err;
 331 }
 332
 333 static int do_ncp_setobjectname(unsigned int fd, unsigned int cmd, unsigned long arg)
 334 {
 335         struct ncp_objectname_ioctl_32 n32;
 336         struct ncp_objectname_ioctl n;
 337         mm_segment_t old_fs;
 338         int err;
 339         size_t tl;
 340
 341         if (copy_from_user(&n32, (struct ncp_objectname_ioctl_32*)arg,
 342             sizeof(n32)))
 343                 return -EFAULT;
 344
 345         n.auth_type = n32.auth_type;
 346         n.object_name_len = tl = n32.object_name_len;
 347         if (tl) {
 348                 n.object_name = kmalloc(tl, GFP_KERNEL);
 349                 if (!n.object_name)
 350                         return -ENOMEM;
 351                 err = -EFAULT;
 352                 if (copy_from_user(n.object_name, A(n32.object_name), tl))
 353                         goto out;
 354         } else {
 355                 n.object_name = NULL;
 356         }
 357
 358         old_fs = get_fs(); set_fs (KERNEL_DS);
 359         err = sys_ioctl (fd, NCP_IOC_SETOBJECTNAME, (unsigned long)&n);
 360         set_fs (old_fs);
 361
 362  out:
 363         if (n.object_name)
 364                 kfree(n.object_name);
 365
 366         return err;
 367 }
 368
 369 static int do_ncp_getprivatedata(unsigned int fd, unsigned int cmd, unsigned long arg)
 370 {
 371         struct ncp_privatedata_ioctl_32 n32;
 372         struct ncp_privatedata_ioctl n;
 373         mm_segment_t old_fs;
 374         int err;
 375         size_t tl;
 376
 377         if (copy_from_user(&n32, (struct ncp_privatedata_ioctl_32*)arg,
 378             sizeof(n32)))
 379                 return -EFAULT;
 380
 381         n.len = tl = n32.len;
 382         if (tl) {
 383                 n.data = kmalloc(tl, GFP_KERNEL);
 384                 if (!n.data)
 385                         return -ENOMEM;
 386         } else {
 387                 n.data = NULL;
 388         }
 389
 390         old_fs = get_fs(); set_fs (KERNEL_DS);
 391         err = sys_ioctl (fd, NCP_IOC_GETPRIVATEDATA, (unsigned long)&n);
 392         set_fs (old_fs);
 393         if(err)
 394                 goto out;
 395
 396         if (tl > n.len)
 397                 tl = n.len;
 398
 399         err = -EFAULT;
 400         if (tl && copy_to_user(A(n32.data), n.data, tl))
 401                 goto out;
 402
 403         n32.len = n.len;
 404
 405         if (copy_to_user((struct ncp_privatedata_ioctl_32*)arg, &n32, sizeof(n32)))
 406                 goto out;
 407
 408         err = 0;
 409  out:
 410         if (n.data)
 411                 kfree(n.data);
 412
 413         return err;
 414 }
 415
 416 static int do_ncp_setprivatedata(unsigned int fd, unsigned int cmd, unsigned long arg)
 417 {
 418         struct ncp_privatedata_ioctl_32 n32;
 419         struct ncp_privatedata_ioctl n;
 420         mm_segment_t old_fs;
 421         int err;
 422         size_t tl;
 423
 424         if (copy_from_user(&n32, (struct ncp_privatedata_ioctl_32*)arg,
 425             sizeof(n32)))
 426                 return -EFAULT;
 427
 428         n.len = tl = n32.len;
 429         if (tl) {
 430                 n.data = kmalloc(tl, GFP_KERNEL);
 431                 if (!n.data)
 432                         return -ENOMEM;
 433                 err = -EFAULT;
 434                 if (copy_from_user(n.data, A(n32.data), tl))
 435                         goto out;
 436         } else {
 437                 n.data = NULL;
 438         }
 439
 440         old_fs = get_fs(); set_fs (KERNEL_DS);
 441         err = sys_ioctl (fd, NCP_IOC_SETPRIVATEDATA, (unsigned long)&n);
 442         set_fs (old_fs);
 443
 444  out:
 445         if (n.data)
 446                 kfree(n.data);
 447
 448         return err;
 449 }
 450
 451 #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
 452 /* This really belongs in include/linux/drm.h -DaveM */
 453 #include "../../../drivers/char/drm/drm.h"
 454
 455 typedef struct drm32_version {
 456         int    version_major;     /* Major version                          */
 457         int    version_minor;     /* Minor version                          */
 458         int    version_patchlevel;/* Patch level                            */
 459         int    name_len;          /* Length of name buffer                  */
 460         u32    name;              /* Name of driver                         */
 461         int    date_len;          /* Length of date buffer                  */
 462         u32    date;              /* User-space buffer to hold date         */
 463         int    desc_len;          /* Length of desc buffer                  */
 464         u32    desc;              /* User-space buffer to hold desc         */
 465 } drm32_version_t;
 466 #define DRM32_IOCTL_VERSION    DRM_IOWR(0x00, drm32_version_t)
 467
 468 static int drm32_version(unsigned int fd, unsigned int cmd, unsigned long arg)
 469 {
 470         drm32_version_t *uversion = (drm32_version_t *)arg;
 471         char __user *name_ptr, *date_ptr, *desc_ptr;
 472         u32 tmp1, tmp2, tmp3;
 473         drm_version_t kversion;
 474         mm_segment_t old_fs;
 475         int ret;
 476
 477         memset(&kversion, 0, sizeof(kversion));
 478         if (get_user(kversion.name_len, &uversion->name_len) ||
 479             get_user(kversion.date_len, &uversion->date_len) ||
 480             get_user(kversion.desc_len, &uversion->desc_len) ||
 481             get_user(tmp1, &uversion->name) ||
 482             get_user(tmp2, &uversion->date) ||
 483             get_user(tmp3, &uversion->desc))
 484                 return -EFAULT;
 485
 486         name_ptr = A(tmp1);
 487         date_ptr = A(tmp2);
 488         desc_ptr = A(tmp3);
 489
 490         ret = -ENOMEM;
 491         if (kversion.name_len && name_ptr) {
 492                 kversion.name = kmalloc(kversion.name_len, GFP_KERNEL);
 493                 if (!kversion.name)
 494                         goto out;
 495         }
 496         if (kversion.date_len && date_ptr) {
 497                 kversion.date = kmalloc(kversion.date_len, GFP_KERNEL);
 498                 if (!kversion.date)
 499                         goto out;
 500         }
 501         if (kversion.desc_len && desc_ptr) {
 502                 kversion.desc = kmalloc(kversion.desc_len, GFP_KERNEL);
 503                 if (!kversion.desc)
 504                         goto out;
 505         }
 506
 507         old_fs = get_fs();
 508         set_fs(KERNEL_DS);
 509         ret = sys_ioctl (fd, DRM_IOCTL_VERSION, (unsigned long)&kversion);
 510         set_fs(old_fs);
 511
 512         if (!ret) {
 513                 if ((kversion.name &&
 514                      copy_to_user(name_ptr, kversion.name, kversion.name_len)) ||
 515                     (kversion.date &&
 516                      copy_to_user(date_ptr, kversion.date, kversion.date_len)) ||
 517                     (kversion.desc &&
 518                      copy_to_user(desc_ptr, kversion.desc, kversion.desc_len)))
 519                         ret = -EFAULT;
 520                 if (put_user(kversion.version_major, &uversion->version_major) ||
 521                     put_user(kversion.version_minor, &uversion->version_minor) ||
 522                     put_user(kversion.version_patchlevel, &uversion->version_patchlevel) ||
 523                     put_user(kversion.name_len, &uversion->name_len) ||
 524                     put_user(kversion.date_len, &uversion->date_len) ||
 525                     put_user(kversion.desc_len, &uversion->desc_len))
 526                         ret = -EFAULT;
 527         }
 528
 529 out:
 530         if (kversion.name)
 531                 kfree(kversion.name);
 532         if (kversion.date)
 533                 kfree(kversion.date);
 534         if (kversion.desc)
 535                 kfree(kversion.desc);
 536         return ret;
 537 }
 538
 539 typedef struct drm32_unique {
 540         int     unique_len;       /* Length of unique                       */
 541         u32     unique;           /* Unique name for driver instantiation   */
 542 } drm32_unique_t;
 543 #define DRM32_IOCTL_GET_UNIQUE DRM_IOWR(0x01, drm32_unique_t)
 544 #define DRM32_IOCTL_SET_UNIQUE DRM_IOW( 0x10, drm32_unique_t)
 545
 546 static int drm32_getsetunique(unsigned int fd, unsigned int cmd, unsigned long arg)
 547 {
 548         drm32_unique_t *uarg = (drm32_unique_t *)arg;
 549         drm_unique_t karg;
 550         mm_segment_t old_fs;
 551         char __user *uptr;
 552         u32 tmp;
 553         int ret;
 554
 555         if (get_user(karg.unique_len, &uarg->unique_len))
 556                 return -EFAULT;
 557         karg.unique = NULL;
 558
 559         if (get_user(tmp, &uarg->unique))
 560                 return -EFAULT;
 561
 562         uptr = A(tmp);
 563
 564         if (uptr) {
 565                 karg.unique = kmalloc(karg.unique_len, GFP_KERNEL);
 566                 if (!karg.unique)
 567                         return -ENOMEM;
 568                 if (cmd == DRM32_IOCTL_SET_UNIQUE &&
 569                     copy_from_user(karg.unique, uptr, karg.unique_len)) {
 570                         kfree(karg.unique);
 571                         return -EFAULT;
 572                 }
 573         }
 574
 575         old_fs = get_fs();
 576         set_fs(KERNEL_DS);
 577         if (cmd == DRM32_IOCTL_GET_UNIQUE)
 578                 ret = sys_ioctl (fd, DRM_IOCTL_GET_UNIQUE, (unsigned long)&karg);
 579         else
 580                 ret = sys_ioctl (fd, DRM_IOCTL_SET_UNIQUE, (unsigned long)&karg);
 581         set_fs(old_fs);
 582
 583         if (!ret) {
 584                 if (cmd == DRM32_IOCTL_GET_UNIQUE &&
 585                     uptr != NULL &&
 586                     copy_to_user(uptr, karg.unique, karg.unique_len))
 587                         ret = -EFAULT;
 588                 if (put_user(karg.unique_len, &uarg->unique_len))
 589                         ret = -EFAULT;
 590         }
 591
 592         if (karg.unique != NULL)
 593                 kfree(karg.unique);
 594
 595         return ret;
 596 }
 597
 598 typedef struct drm32_map {
 599         u32             offset;  /* Requested physical address (0 for SAREA)*/
 600         u32             size;    /* Requested physical size (bytes)         */
 601         drm_map_type_t  type;    /* Type of memory to map                   */
 602         drm_map_flags_t flags;   /* Flags                                   */
 603         u32             handle;  /* User-space: "Handle" to pass to mmap    */
 604                                  /* Kernel-space: kernel-virtual address    */
 605         int             mtrr;    /* MTRR slot used                          */
 606                                  /* Private data                            */
 607 } drm32_map_t;
 608 #define DRM32_IOCTL_ADD_MAP    DRM_IOWR(0x15, drm32_map_t)
 609
 610 static int drm32_addmap(unsigned int fd, unsigned int cmd, unsigned long arg)
 611 {
 612         drm32_map_t *uarg = (drm32_map_t *) arg;
 613         drm_map_t karg;
 614         mm_segment_t old_fs;
 615         u32 tmp;
 616         int ret;
 617
 618         ret  = get_user(karg.offset, &uarg->offset);
 619         ret |= get_user(karg.size, &uarg->size);
 620         ret |= get_user(karg.type, &uarg->type);
 621         ret |= get_user(karg.flags, &uarg->flags);
 622         ret |= get_user(tmp, &uarg->handle);
 623         ret |= get_user(karg.mtrr, &uarg->mtrr);
 624         if (ret)
 625                 return -EFAULT;
 626
 627         karg.handle = A(tmp);
 628
 629         old_fs = get_fs();
 630         set_fs(KERNEL_DS);
 631         ret = sys_ioctl(fd, DRM_IOCTL_ADD_MAP, (unsigned long) &karg);
 632         set_fs(old_fs);
 633
 634         if (!ret) {
 635                 ret  = put_user(karg.offset, &uarg->offset);
 636                 ret |= put_user(karg.size, &uarg->size);
 637                 ret |= put_user(karg.type, &uarg->type);
 638                 ret |= put_user(karg.flags, &uarg->flags);
 639                 tmp = (u32) (long)karg.handle;
 640                 ret |= put_user(tmp, &uarg->handle);
 641                 ret |= put_user(karg.mtrr, &uarg->mtrr);
 642                 if (ret)
 643                         ret = -EFAULT;
 644         }
 645
 646         return ret;
 647 }
 648
 649 typedef struct drm32_buf_info {
 650         int            count;   /* Entries in list                           */
 651         u32            list;    /* (drm_buf_desc_t *) */
 652 } drm32_buf_info_t;
 653 #define DRM32_IOCTL_INFO_BUFS  DRM_IOWR(0x18, drm32_buf_info_t)
 654
 655 static int drm32_info_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
 656 {
 657         drm32_buf_info_t *uarg = (drm32_buf_info_t *)arg;
 658         drm_buf_desc_t __user *ulist;
 659         drm_buf_info_t karg;
 660         mm_segment_t old_fs;
 661         int orig_count, ret;
 662         u32 tmp;
 663
 664         if (get_user(karg.count, &uarg->count) ||
 665             get_user(tmp, &uarg->list))
 666                 return -EFAULT;
 667
 668         ulist = A(tmp);
 669
 670         orig_count = karg.count;
 671
 672         karg.list = kmalloc(karg.count * sizeof(drm_buf_desc_t), GFP_KERNEL);
 673         if (!karg.list)
 674                 return -EFAULT;
 675
 676         old_fs = get_fs();
 677         set_fs(KERNEL_DS);
 678         ret = sys_ioctl(fd, DRM_IOCTL_INFO_BUFS, (unsigned long) &karg);
 679         set_fs(old_fs);
 680
 681         if (!ret) {
 682                 if (karg.count <= orig_count &&
 683                     (copy_to_user(ulist, karg.list,
 684                                   karg.count * sizeof(drm_buf_desc_t))))
 685                         ret = -EFAULT;
 686                 if (put_user(karg.count, &uarg->count))
 687                         ret = -EFAULT;
 688         }
 689
 690         kfree(karg.list);
 691
 692         return ret;
 693 }
 694
 695 typedef struct drm32_buf_free {
 696         int            count;
 697         u32            list;    /* (int *) */
 698 } drm32_buf_free_t;
 699 #define DRM32_IOCTL_FREE_BUFS  DRM_IOW( 0x1a, drm32_buf_free_t)
 700
 701 static int drm32_free_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
 702 {
 703         drm32_buf_free_t *uarg = (drm32_buf_free_t *)arg;
 704         drm_buf_free_t karg;
 705         mm_segment_t old_fs;
 706         int __user *ulist;
 707         int ret;
 708         u32 tmp;
 709
 710         if (get_user(karg.count, &uarg->count) ||
 711             get_user(tmp, &uarg->list))
 712                 return -EFAULT;
 713
 714         ulist = A(tmp);
 715
 716         karg.list = kmalloc(karg.count * sizeof(int), GFP_KERNEL);
 717         if (!karg.list)
 718                 return -ENOMEM;
 719
 720         ret = -EFAULT;
 721         if (copy_from_user(karg.list, ulist, (karg.count * sizeof(int))))
 722                 goto out;
 723
 724         old_fs = get_fs();
 725         set_fs(KERNEL_DS);
 726         ret = sys_ioctl(fd, DRM_IOCTL_FREE_BUFS, (unsigned long) &karg);
 727         set_fs(old_fs);
 728
 729 out:
 730         kfree(karg.list);
 731
 732         return ret;
 733 }
 734
 735 typedef struct drm32_buf_pub {
 736         int               idx;         /* Index into master buflist          */
 737         int               total;       /* Buffer size                        */
 738         int               used;        /* Amount of buffer in use (for DMA)  */
 739         u32               address;     /* Address of buffer (void *)         */
 740 } drm32_buf_pub_t;
 741
 742 typedef struct drm32_buf_map {
 743         int           count;    /* Length of buflist                        */
 744         u32           virtual;  /* Mmaped area in user-virtual (void *)     */
 745         u32           list;     /* Buffer information (drm_buf_pub_t *)     */
 746 } drm32_buf_map_t;
 747 #define DRM32_IOCTL_MAP_BUFS   DRM_IOWR(0x19, drm32_buf_map_t)
 748
 749 static int drm32_map_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
 750 {
 751         drm32_buf_map_t *uarg = (drm32_buf_map_t *)arg;
 752         drm32_buf_pub_t __user *ulist;
 753         drm_buf_map_t karg;
 754         mm_segment_t old_fs;
 755         int orig_count, ret, i;
 756         u32 tmp1, tmp2;
 757
 758         if (get_user(karg.count, &uarg->count) ||
 759             get_user(tmp1, &uarg->virtual) ||
 760             get_user(tmp2, &uarg->list))
 761                 return -EFAULT;
 762
 763         karg.virtual = A(tmp1);
 764         ulist = A(tmp2);
 765
 766         orig_count = karg.count;
 767
 768         karg.list = kmalloc(karg.count * sizeof(drm_buf_pub_t), GFP_KERNEL);
 769         if (!karg.list)
 770                 return -ENOMEM;
 771
 772         ret = -EFAULT;
 773         for (i = 0; i < karg.count; i++) {
 774                 if (get_user(karg.list[i].idx, &ulist[i].idx) ||
 775                     get_user(karg.list[i].total, &ulist[i].total) ||
 776                     get_user(karg.list[i].used, &ulist[i].used) ||
 777                     get_user(tmp1, &ulist[i].address))
 778                         goto out;
 779
 780                 karg.list[i].address = A(tmp1);
 781         }
 782
 783         old_fs = get_fs();
 784         set_fs(KERNEL_DS);
 785         ret = sys_ioctl(fd, DRM_IOCTL_MAP_BUFS, (unsigned long) &karg);
 786         set_fs(old_fs);
 787
 788         if (!ret) {
 789                 for (i = 0; i < orig_count; i++) {
 790                         tmp1 = (u32) (long) karg.list[i].address;
 791                         if (put_user(karg.list[i].idx, &ulist[i].idx) ||
 792                             put_user(karg.list[i].total, &ulist[i].total) ||
 793                             put_user(karg.list[i].used, &ulist[i].used) ||
 794                             put_user(tmp1, &ulist[i].address)) {
 795                                 ret = -EFAULT;
 796                                 goto out;
 797                         }
 798                 }
 799                 if (put_user(karg.count, &uarg->count))
 800                         ret = -EFAULT;
 801         }
 802
 803 out:
 804         kfree(karg.list);
 805         return ret;
 806 }
 807
 808 typedef struct drm32_dma {
 809                                 /* Indices here refer to the offset into
 810                                    buflist in drm_buf_get_t.  */
 811         int             context;          /* Context handle                 */
 812         int             send_count;       /* Number of buffers to send      */
 813         u32             send_indices;     /* List of handles to buffers (int *) */
 814         u32             send_sizes;       /* Lengths of data to send (int *) */
 815         drm_dma_flags_t flags;            /* Flags                          */
 816         int             request_count;    /* Number of buffers requested    */
 817         int             request_size;     /* Desired size for buffers       */
 818         u32             request_indices;  /* Buffer information (int *)     */
 819         u32             request_sizes;    /* (int *) */
 820         int             granted_count;    /* Number of buffers granted      */
 821 } drm32_dma_t;
 822 #define DRM32_IOCTL_DMA      DRM_IOWR(0x29, drm32_dma_t)
 823
 824 /* RED PEN      The DRM layer blindly dereferences the send/request
 825  *              index/size arrays even though they are userland
 826  *              pointers.  -DaveM
 827  */
 828 static int drm32_dma(unsigned int fd, unsigned int cmd, unsigned long arg)
 829 {
 830         drm32_dma_t *uarg = (drm32_dma_t *) arg;
 831         int __user *u_si, *u_ss, *u_ri, *u_rs;
 832         drm_dma_t karg;
 833         mm_segment_t old_fs;
 834         int ret;
 835         u32 tmp1, tmp2, tmp3, tmp4;
 836
 837         karg.send_indices = karg.send_sizes = NULL;
 838         karg.request_indices = karg.request_sizes = NULL;
 839
 840         if (get_user(karg.context, &uarg->context) ||
 841             get_user(karg.send_count, &uarg->send_count) ||
 842             get_user(tmp1, &uarg->send_indices) ||
 843             get_user(tmp2, &uarg->send_sizes) ||
 844             get_user(karg.flags, &uarg->flags) ||
 845             get_user(karg.request_count, &uarg->request_count) ||
 846             get_user(karg.request_size, &uarg->request_size) ||
 847             get_user(tmp3, &uarg->request_indices) ||
 848             get_user(tmp4, &uarg->request_sizes) ||
 849             get_user(karg.granted_count, &uarg->granted_count))
 850                 return -EFAULT;
 851
 852         u_si = A(tmp1);
 853         u_ss = A(tmp2);
 854         u_ri = A(tmp3);
 855         u_rs = A(tmp4);
 856
 857         if (karg.send_count) {
 858                 karg.send_indices = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
 859                 karg.send_sizes = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
 860
 861                 ret = -ENOMEM;
 862                 if (!karg.send_indices || !karg.send_sizes)
 863                         goto out;
 864
 865                 ret = -EFAULT;
 866                 if (copy_from_user(karg.send_indices, u_si,
 867                                    (karg.send_count * sizeof(int))) ||
 868                     copy_from_user(karg.send_sizes, u_ss,
 869                                    (karg.send_count * sizeof(int))))
 870                         goto out;
 871         }
 872
 873         if (karg.request_count) {
 874                 karg.request_indices = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
 875                 karg.request_sizes = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
 876
 877                 ret = -ENOMEM;
 878                 if (!karg.request_indices || !karg.request_sizes)
 879                         goto out;
 880
 881                 ret = -EFAULT;
 882                 if (copy_from_user(karg.request_indices, u_ri,
 883                                    (karg.request_count * sizeof(int))) ||
 884                     copy_from_user(karg.request_sizes, u_rs,
 885                                    (karg.request_count * sizeof(int))))
 886                         goto out;
 887         }
 888
 889         old_fs = get_fs();
 890         set_fs(KERNEL_DS);
 891         ret = sys_ioctl(fd, DRM_IOCTL_DMA, (unsigned long) &karg);
 892         set_fs(old_fs);
 893
 894         if (!ret) {
 895                 if (put_user(karg.context, &uarg->context) ||
 896                     put_user(karg.send_count, &uarg->send_count) ||
 897                     put_user(karg.flags, &uarg->flags) ||
 898                     put_user(karg.request_count, &uarg->request_count) ||
 899                     put_user(karg.request_size, &uarg->request_size) ||
 900                     put_user(karg.granted_count, &uarg->granted_count))
 901                         ret = -EFAULT;
 902
 903                 if (karg.send_count) {
 904                         if (copy_to_user(u_si, karg.send_indices,
 905                                          (karg.send_count * sizeof(int))) ||
 906                             copy_to_user(u_ss, karg.send_sizes,
 907                                          (karg.send_count * sizeof(int))))
 908                                 ret = -EFAULT;
 909                 }
 910                 if (karg.request_count) {
 911                         if (copy_to_user(u_ri, karg.request_indices,
 912                                          (karg.request_count * sizeof(int))) ||
 913                             copy_to_user(u_rs, karg.request_sizes,
 914                                          (karg.request_count * sizeof(int))))
 915                                 ret = -EFAULT;
 916                 }
 917         }
 918
 919 out:
 920         if (karg.send_indices)
 921                 kfree(karg.send_indices);
 922         if (karg.send_sizes)
 923                 kfree(karg.send_sizes);
 924         if (karg.request_indices)
 925                 kfree(karg.request_indices);
 926         if (karg.request_sizes)
 927                 kfree(karg.request_sizes);
 928
 929         return ret;
 930 }
 931
 932 typedef struct drm32_ctx_res {
 933         int             count;
 934         u32             contexts; /* (drm_ctx_t *) */
 935 } drm32_ctx_res_t;
 936 #define DRM32_IOCTL_RES_CTX    DRM_IOWR(0x26, drm32_ctx_res_t)
 937
 938 static int drm32_res_ctx(unsigned int fd, unsigned int cmd, unsigned long arg)
 939 {
 940         drm32_ctx_res_t *uarg = (drm32_ctx_res_t *) arg;
 941         drm_ctx_t __user *ulist;
 942         drm_ctx_res_t karg;
 943         mm_segment_t old_fs;
 944         int orig_count, ret;
 945         u32 tmp;
 946
 947         karg.contexts = NULL;
 948         if (get_user(karg.count, &uarg->count) ||
 949             get_user(tmp, &uarg->contexts))
 950                 return -EFAULT;
 951
 952         ulist = A(tmp);
 953
 954         orig_count = karg.count;
 955         if (karg.count && ulist) {
 956                 karg.contexts = kmalloc((karg.count * sizeof(drm_ctx_t)), GFP_KERNEL);
 957                 if (!karg.contexts)
 958                         return -ENOMEM;
 959                 if (copy_from_user(karg.contexts, ulist,
 960                                    (karg.count * sizeof(drm_ctx_t)))) {
 961                         kfree(karg.contexts);
 962                         return -EFAULT;
 963                 }
 964         }
 965
 966         old_fs = get_fs();
 967         set_fs(KERNEL_DS);
 968         ret = sys_ioctl(fd, DRM_IOCTL_RES_CTX, (unsigned long) &karg);
 969         set_fs(old_fs);
 970
 971         if (!ret) {
 972                 if (orig_count) {
 973                         if (copy_to_user(ulist, karg.contexts,
 974                                          (orig_count * sizeof(drm_ctx_t))))
 975                                 ret = -EFAULT;
 976                 }
 977                 if (put_user(karg.count, &uarg->count))
 978                         ret = -EFAULT;
 979         }
 980
 981         if (karg.contexts)
 982                 kfree(karg.contexts);
 983
 984         return ret;
 985 }
 986
 987 #endif
 988
 989 typedef int (* ioctl32_handler_t)(unsigned int, unsigned int, unsigned long, struct file *);
 990
 991 #define COMPATIBLE_IOCTL(cmd)           HANDLE_IOCTL((cmd),sys_ioctl)
 992 #define HANDLE_IOCTL(cmd,handler)       { (cmd), (ioctl32_handler_t)(handler), NULL },
 993 #define IOCTL_TABLE_START \
 994         struct ioctl_trans ioctl_start[] = {
 995 #define IOCTL_TABLE_END \
 996         };
 997
 998 IOCTL_TABLE_START
 999 #include <linux/compat_ioctl.h>
1000 #define DECLARES
1001 #include "compat_ioctl.c"
1002 COMPATIBLE_IOCTL(TCSBRKP)
1003 COMPATIBLE_IOCTL(TIOCSTART)
1004 COMPATIBLE_IOCTL(TIOCSTOP)
1005 COMPATIBLE_IOCTL(TIOCSLTC)
1006 COMPATIBLE_IOCTL(FBIOGTYPE)
1007 COMPATIBLE_IOCTL(FBIOSATTR)
1008 COMPATIBLE_IOCTL(FBIOGATTR)
1009 COMPATIBLE_IOCTL(FBIOSVIDEO)
1010 COMPATIBLE_IOCTL(FBIOGVIDEO)
1011 COMPATIBLE_IOCTL(FBIOGCURSOR32)  /* This is not implemented yet. Later it should be converted... */
1012 COMPATIBLE_IOCTL(FBIOSCURPOS)
1013 COMPATIBLE_IOCTL(FBIOGCURPOS)
1014 COMPATIBLE_IOCTL(FBIOGCURMAX)
1015 /* Little k */
1016 COMPATIBLE_IOCTL(KIOCTYPE)
1017 COMPATIBLE_IOCTL(KIOCLAYOUT)
1018 COMPATIBLE_IOCTL(KIOCGTRANS)
1019 COMPATIBLE_IOCTL(KIOCTRANS)
1020 COMPATIBLE_IOCTL(KIOCCMD)
1021 COMPATIBLE_IOCTL(KIOCSDIRECT)
1022 COMPATIBLE_IOCTL(KIOCSLED)
1023 COMPATIBLE_IOCTL(KIOCGLED)
1024 COMPATIBLE_IOCTL(KIOCSRATE)
1025 COMPATIBLE_IOCTL(KIOCGRATE)
1026 COMPATIBLE_IOCTL(VUIDSFORMAT)
1027 COMPATIBLE_IOCTL(VUIDGFORMAT)
1028 /* Little v, the video4linux ioctls */
1029 COMPATIBLE_IOCTL(_IOR('p', 20, int[7])) /* RTCGET */
1030 COMPATIBLE_IOCTL(_IOW('p', 21, int[7])) /* RTCSET */
1031 COMPATIBLE_IOCTL(ENVCTRL_RD_WARNING_TEMPERATURE)
1032 COMPATIBLE_IOCTL(ENVCTRL_RD_SHUTDOWN_TEMPERATURE)
1033 COMPATIBLE_IOCTL(ENVCTRL_RD_CPU_TEMPERATURE)
1034 COMPATIBLE_IOCTL(ENVCTRL_RD_FAN_STATUS)
1035 COMPATIBLE_IOCTL(ENVCTRL_RD_VOLTAGE_STATUS)
1036 COMPATIBLE_IOCTL(ENVCTRL_RD_SCSI_TEMPERATURE)
1037 COMPATIBLE_IOCTL(ENVCTRL_RD_ETHERNET_TEMPERATURE)
1038 COMPATIBLE_IOCTL(ENVCTRL_RD_MTHRBD_TEMPERATURE)
1039 COMPATIBLE_IOCTL(ENVCTRL_RD_CPU_VOLTAGE)
1040 COMPATIBLE_IOCTL(ENVCTRL_RD_GLOBALADDRESS)
1041 /* COMPATIBLE_IOCTL(D7SIOCRD) same value as ENVCTRL_RD_VOLTAGE_STATUS */
1042 COMPATIBLE_IOCTL(D7SIOCWR)
1043 COMPATIBLE_IOCTL(D7SIOCTM)
1044 /* OPENPROMIO, SunOS/Solaris only, the NetBSD one's have
1045  * embedded pointers in the arg which we'd need to clean up...
1046  */
1047 COMPATIBLE_IOCTL(OPROMGETOPT)
1048 COMPATIBLE_IOCTL(OPROMSETOPT)
1049 COMPATIBLE_IOCTL(OPROMNXTOPT)
1050 COMPATIBLE_IOCTL(OPROMSETOPT2)
1051 COMPATIBLE_IOCTL(OPROMNEXT)
1052 COMPATIBLE_IOCTL(OPROMCHILD)
1053 COMPATIBLE_IOCTL(OPROMGETPROP)
1054 COMPATIBLE_IOCTL(OPROMNXTPROP)
1055 COMPATIBLE_IOCTL(OPROMU2P)
1056 COMPATIBLE_IOCTL(OPROMGETCONS)
1057 COMPATIBLE_IOCTL(OPROMGETFBNAME)
1058 COMPATIBLE_IOCTL(OPROMGETBOOTARGS)
1059 COMPATIBLE_IOCTL(OPROMSETCUR)
1060 COMPATIBLE_IOCTL(OPROMPCI2NODE)
1061 COMPATIBLE_IOCTL(OPROMPATH2NODE)
1062 /* Big L */
1063 COMPATIBLE_IOCTL(LOOP_SET_STATUS64)
1064 COMPATIBLE_IOCTL(LOOP_GET_STATUS64)
1065 /* Big A */
1066 COMPATIBLE_IOCTL(AUDIO_GETINFO)
1067 COMPATIBLE_IOCTL(AUDIO_SETINFO)
1068 COMPATIBLE_IOCTL(AUDIO_DRAIN)
1069 COMPATIBLE_IOCTL(AUDIO_GETDEV)
1070 COMPATIBLE_IOCTL(AUDIO_GETDEV_SUNOS)
1071 COMPATIBLE_IOCTL(AUDIO_FLUSH)
1072 COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE_MULTI)
1073 /* NCP ioctls which do not need any translations */
1074 COMPATIBLE_IOCTL(NCP_IOC_CONN_LOGGED_IN)
1075 COMPATIBLE_IOCTL(NCP_IOC_SIGN_INIT)
1076 COMPATIBLE_IOCTL(NCP_IOC_SIGN_WANTED)
1077 COMPATIBLE_IOCTL(NCP_IOC_SET_SIGN_WANTED)
1078 COMPATIBLE_IOCTL(NCP_IOC_LOCKUNLOCK)
1079 COMPATIBLE_IOCTL(NCP_IOC_GETROOT)
1080 COMPATIBLE_IOCTL(NCP_IOC_SETROOT)
1081 COMPATIBLE_IOCTL(NCP_IOC_GETCHARSETS)
1082 COMPATIBLE_IOCTL(NCP_IOC_SETCHARSETS)
1083 COMPATIBLE_IOCTL(NCP_IOC_GETDENTRYTTL)
1084 COMPATIBLE_IOCTL(NCP_IOC_SETDENTRYTTL)
1085 #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
1086 COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC)
1087 COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID)
1088 COMPATIBLE_IOCTL(DRM_IOCTL_AUTH_MAGIC)
1089 COMPATIBLE_IOCTL(DRM_IOCTL_BLOCK)
1090 COMPATIBLE_IOCTL(DRM_IOCTL_UNBLOCK)
1091 COMPATIBLE_IOCTL(DRM_IOCTL_CONTROL)
1092 COMPATIBLE_IOCTL(DRM_IOCTL_ADD_BUFS)
1093 COMPATIBLE_IOCTL(DRM_IOCTL_MARK_BUFS)
1094 COMPATIBLE_IOCTL(DRM_IOCTL_ADD_CTX)
1095 COMPATIBLE_IOCTL(DRM_IOCTL_RM_CTX)
1096 COMPATIBLE_IOCTL(DRM_IOCTL_MOD_CTX)
1097 COMPATIBLE_IOCTL(DRM_IOCTL_GET_CTX)
1098 COMPATIBLE_IOCTL(DRM_IOCTL_SWITCH_CTX)
1099 COMPATIBLE_IOCTL(DRM_IOCTL_NEW_CTX)
1100 COMPATIBLE_IOCTL(DRM_IOCTL_ADD_DRAW)
1101 COMPATIBLE_IOCTL(DRM_IOCTL_RM_DRAW)
1102 COMPATIBLE_IOCTL(DRM_IOCTL_LOCK)
1103 COMPATIBLE_IOCTL(DRM_IOCTL_UNLOCK)
1104 COMPATIBLE_IOCTL(DRM_IOCTL_FINISH)
1105 #endif /* DRM */
1106 COMPATIBLE_IOCTL(WIOCSTART)
1107 COMPATIBLE_IOCTL(WIOCSTOP)
1108 COMPATIBLE_IOCTL(WIOCGSTAT)
1109 /* And these ioctls need translation */
1110 /* NCPFS */
1111 HANDLE_IOCTL(NCP_IOC_NCPREQUEST_32, do_ncp_ncprequest)
1112 HANDLE_IOCTL(NCP_IOC_GETMOUNTUID2_32, do_ncp_getmountuid2)
1113 HANDLE_IOCTL(NCP_IOC_GET_FS_INFO_V2_32, do_ncp_getfsinfo2)
1114 HANDLE_IOCTL(NCP_IOC_GETOBJECTNAME_32, do_ncp_getobjectname)
1115 HANDLE_IOCTL(NCP_IOC_SETOBJECTNAME_32, do_ncp_setobjectname)
1116 HANDLE_IOCTL(NCP_IOC_GETPRIVATEDATA_32, do_ncp_getprivatedata)
1117 HANDLE_IOCTL(NCP_IOC_SETPRIVATEDATA_32, do_ncp_setprivatedata)
1118 /* Note SIOCRTMSG is no longer, so this is safe and * the user would have seen just an -EINVAL anyways. */
1119 HANDLE_IOCTL(FBIOPUTCMAP32, fbiogetputcmap)
1120 HANDLE_IOCTL(FBIOGETCMAP32, fbiogetputcmap)
1121 HANDLE_IOCTL(FBIOSCURSOR32, fbiogscursor)
1122 #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
1123 HANDLE_IOCTL(DRM32_IOCTL_VERSION, drm32_version)
1124 HANDLE_IOCTL(DRM32_IOCTL_GET_UNIQUE, drm32_getsetunique)
1125 HANDLE_IOCTL(DRM32_IOCTL_SET_UNIQUE, drm32_getsetunique)
1126 HANDLE_IOCTL(DRM32_IOCTL_ADD_MAP, drm32_addmap)
1127 HANDLE_IOCTL(DRM32_IOCTL_INFO_BUFS, drm32_info_bufs)
1128 HANDLE_IOCTL(DRM32_IOCTL_FREE_BUFS, drm32_free_bufs)
1129 HANDLE_IOCTL(DRM32_IOCTL_MAP_BUFS, drm32_map_bufs)
1130 HANDLE_IOCTL(DRM32_IOCTL_DMA, drm32_dma)
1131 HANDLE_IOCTL(DRM32_IOCTL_RES_CTX, drm32_res_ctx)
1132 #endif /* DRM */
1133 #if 0
1134 HANDLE_IOCTL(RTC32_IRQP_READ, do_rtc_ioctl)
1135 HANDLE_IOCTL(RTC32_IRQP_SET, do_rtc_ioctl)
1136 HANDLE_IOCTL(RTC32_EPOCH_READ, do_rtc_ioctl)
1137 HANDLE_IOCTL(RTC32_EPOCH_SET, do_rtc_ioctl)
1138 #endif
1139 /* take care of sizeof(sizeof()) breakage */
1140 IOCTL_TABLE_END
1141
1142 int ioctl_table_size = ARRAY_SIZE(ioctl_start);