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.
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)
8 * These routines maintain argument size conversion between 32bit and 64bit
13 #include "compat_ioctl.c"
14 #include <linux/ncp_fs.h>
15 #include <linux/syscalls.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>
25 /* Use this to get at 32-bit user passed pointers.
26 * See sys_sparc32.c for description about it.
28 #define A(__x) ((void __user *)(unsigned long)(__x))
30 static __inline__ void *alloc_user_space(long len)
32 struct pt_regs *regs = current_thread_info()->kregs;
33 unsigned long usp = regs->u_regs[UREG_I6];
35 if (!(test_thread_flag(TIF_32BIT)))
38 return (void *) (usp - len);
42 #include "compat_ioctl.c"
45 int index; /* first element (0 origin) */
52 #define FBIOPUTCMAP32 _IOW('F', 3, struct fbcmap32)
53 #define FBIOGETCMAP32 _IOW('F', 4, struct fbcmap32)
55 static int fbiogetputcmap(unsigned int fd, unsigned int cmd, unsigned long arg)
59 char red[256], green[256], blue[256];
61 mm_segment_t old_fs = get_fs();
63 ret = get_user(f.index, &(((struct fbcmap32 __user *)arg)->index));
64 ret |= __get_user(f.count, &(((struct fbcmap32 __user *)arg)->count));
65 ret |= __get_user(r, &(((struct fbcmap32 __user *)arg)->red));
66 ret |= __get_user(g, &(((struct fbcmap32 __user *)arg)->green));
67 ret |= __get_user(b, &(((struct fbcmap32 __user *)arg)->blue));
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);
80 f.red = red; f.green = green; f.blue = blue;
82 ret = sys_ioctl (fd, (cmd == FBIOPUTCMAP32) ? FBIOPUTCMAP_SPARC : FBIOGETCMAP_SPARC, (long)&f);
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);
89 return ret ? -EFAULT : 0;
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 */
103 #define FBIOSCURSOR32 _IOW('F', 24, struct fbcursor32)
104 #define FBIOGCURSOR32 _IOW('F', 25, struct fbcursor32)
106 static int fbiogscursor(unsigned int fd, unsigned int cmd, unsigned long arg)
110 char red[2], green[2], blue[2];
111 char image[128], mask[128];
114 mm_segment_t old_fs = get_fs();
116 ret = copy_from_user (&f, (struct fbcursor32 __user *) arg,
117 2 * sizeof (short) + 2 * sizeof(struct fbcurpos));
118 ret |= __get_user(f.size.x,
119 &(((struct fbcursor32 __user *)arg)->size.x));
120 ret |= __get_user(f.size.y,
121 &(((struct fbcursor32 __user *)arg)->size.y));
122 ret |= __get_user(f.cmap.index,
123 &(((struct fbcursor32 __user *)arg)->cmap.index));
124 ret |= __get_user(f.cmap.count,
125 &(((struct fbcursor32 __user *)arg)->cmap.count));
126 ret |= __get_user(r, &(((struct fbcursor32 __user *)arg)->cmap.red));
127 ret |= __get_user(g, &(((struct fbcursor32 __user *)arg)->cmap.green));
128 ret |= __get_user(b, &(((struct fbcursor32 __user *)arg)->cmap.blue));
129 ret |= __get_user(m, &(((struct fbcursor32 __user *)arg)->mask));
130 ret |= __get_user(i, &(((struct fbcursor32 __user *)arg)->image));
133 if (f.set & FB_CUR_SETCMAP) {
134 if ((uint) f.size.y > 32)
136 ret = copy_from_user (mask, A(m), f.size.y * 4);
137 ret |= copy_from_user (image, A(i), f.size.y * 4);
140 f.image = image; f.mask = mask;
142 if (f.set & FB_CUR_SETCMAP) {
143 ret = copy_from_user (red, A(r), 2);
144 ret |= copy_from_user (green, A(g), 2);
145 ret |= copy_from_user (blue, A(b), 2);
148 f.cmap.red = red; f.cmap.green = green; f.cmap.blue = blue;
151 ret = sys_ioctl (fd, FBIOSCURSOR, (long)&f);
156 #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
157 /* This really belongs in include/linux/drm.h -DaveM */
158 #include "../../../drivers/char/drm/drm.h"
160 typedef struct drm32_version {
161 int version_major; /* Major version */
162 int version_minor; /* Minor version */
163 int version_patchlevel;/* Patch level */
164 int name_len; /* Length of name buffer */
165 u32 name; /* Name of driver */
166 int date_len; /* Length of date buffer */
167 u32 date; /* User-space buffer to hold date */
168 int desc_len; /* Length of desc buffer */
169 u32 desc; /* User-space buffer to hold desc */
171 #define DRM32_IOCTL_VERSION DRM_IOWR(0x00, drm32_version_t)
173 static int drm32_version(unsigned int fd, unsigned int cmd, unsigned long arg)
175 drm32_version_t __user *uversion = (drm32_version_t __user *)arg;
176 char __user *name_ptr, *date_ptr, *desc_ptr;
177 u32 tmp1, tmp2, tmp3;
178 drm_version_t kversion;
182 memset(&kversion, 0, sizeof(kversion));
183 if (get_user(kversion.name_len, &uversion->name_len) ||
184 get_user(kversion.date_len, &uversion->date_len) ||
185 get_user(kversion.desc_len, &uversion->desc_len) ||
186 get_user(tmp1, &uversion->name) ||
187 get_user(tmp2, &uversion->date) ||
188 get_user(tmp3, &uversion->desc))
196 if (kversion.name_len && name_ptr) {
197 kversion.name = kmalloc(kversion.name_len, GFP_KERNEL);
201 if (kversion.date_len && date_ptr) {
202 kversion.date = kmalloc(kversion.date_len, GFP_KERNEL);
206 if (kversion.desc_len && desc_ptr) {
207 kversion.desc = kmalloc(kversion.desc_len, GFP_KERNEL);
214 ret = sys_ioctl (fd, DRM_IOCTL_VERSION, (unsigned long)&kversion);
218 if ((kversion.name &&
219 copy_to_user(name_ptr, kversion.name, kversion.name_len)) ||
221 copy_to_user(date_ptr, kversion.date, kversion.date_len)) ||
223 copy_to_user(desc_ptr, kversion.desc, kversion.desc_len)))
225 if (put_user(kversion.version_major, &uversion->version_major) ||
226 put_user(kversion.version_minor, &uversion->version_minor) ||
227 put_user(kversion.version_patchlevel, &uversion->version_patchlevel) ||
228 put_user(kversion.name_len, &uversion->name_len) ||
229 put_user(kversion.date_len, &uversion->date_len) ||
230 put_user(kversion.desc_len, &uversion->desc_len))
236 kfree(kversion.name);
238 kfree(kversion.date);
240 kfree(kversion.desc);
244 typedef struct drm32_unique {
245 int unique_len; /* Length of unique */
246 u32 unique; /* Unique name for driver instantiation */
248 #define DRM32_IOCTL_GET_UNIQUE DRM_IOWR(0x01, drm32_unique_t)
249 #define DRM32_IOCTL_SET_UNIQUE DRM_IOW( 0x10, drm32_unique_t)
251 static int drm32_getsetunique(unsigned int fd, unsigned int cmd, unsigned long arg)
253 drm32_unique_t __user *uarg = (drm32_unique_t __user *)arg;
260 if (get_user(karg.unique_len, &uarg->unique_len))
264 if (get_user(tmp, &uarg->unique))
270 karg.unique = kmalloc(karg.unique_len, GFP_KERNEL);
273 if (cmd == DRM32_IOCTL_SET_UNIQUE &&
274 copy_from_user(karg.unique, uptr, karg.unique_len)) {
282 if (cmd == DRM32_IOCTL_GET_UNIQUE)
283 ret = sys_ioctl (fd, DRM_IOCTL_GET_UNIQUE, (unsigned long)&karg);
285 ret = sys_ioctl (fd, DRM_IOCTL_SET_UNIQUE, (unsigned long)&karg);
289 if (cmd == DRM32_IOCTL_GET_UNIQUE &&
291 copy_to_user(uptr, karg.unique, karg.unique_len))
293 if (put_user(karg.unique_len, &uarg->unique_len))
297 if (karg.unique != NULL)
303 typedef struct drm32_map {
304 u32 offset; /* Requested physical address (0 for SAREA)*/
305 u32 size; /* Requested physical size (bytes) */
306 drm_map_type_t type; /* Type of memory to map */
307 drm_map_flags_t flags; /* Flags */
308 u32 handle; /* User-space: "Handle" to pass to mmap */
309 /* Kernel-space: kernel-virtual address */
310 int mtrr; /* MTRR slot used */
313 #define DRM32_IOCTL_ADD_MAP DRM_IOWR(0x15, drm32_map_t)
315 static int drm32_addmap(unsigned int fd, unsigned int cmd, unsigned long arg)
317 drm32_map_t __user *uarg = (drm32_map_t __user *) arg;
323 ret = get_user(karg.offset, &uarg->offset);
324 ret |= get_user(karg.size, &uarg->size);
325 ret |= get_user(karg.type, &uarg->type);
326 ret |= get_user(karg.flags, &uarg->flags);
327 ret |= get_user(tmp, &uarg->handle);
328 ret |= get_user(karg.mtrr, &uarg->mtrr);
332 karg.handle = (void *) (unsigned long) tmp;
336 ret = sys_ioctl(fd, DRM_IOCTL_ADD_MAP, (unsigned long) &karg);
340 ret = put_user(karg.offset, &uarg->offset);
341 ret |= put_user(karg.size, &uarg->size);
342 ret |= put_user(karg.type, &uarg->type);
343 ret |= put_user(karg.flags, &uarg->flags);
344 tmp = (u32) (long)karg.handle;
345 ret |= put_user(tmp, &uarg->handle);
346 ret |= put_user(karg.mtrr, &uarg->mtrr);
354 typedef struct drm32_buf_info {
355 int count; /* Entries in list */
356 u32 list; /* (drm_buf_desc_t *) */
358 #define DRM32_IOCTL_INFO_BUFS DRM_IOWR(0x18, drm32_buf_info_t)
360 static int drm32_info_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
362 drm32_buf_info_t __user *uarg = (drm32_buf_info_t __user *)arg;
363 drm_buf_desc_t __user *ulist;
369 if (get_user(karg.count, &uarg->count) ||
370 get_user(tmp, &uarg->list))
375 orig_count = karg.count;
377 karg.list = kmalloc(karg.count * sizeof(drm_buf_desc_t), GFP_KERNEL);
383 ret = sys_ioctl(fd, DRM_IOCTL_INFO_BUFS, (unsigned long) &karg);
387 if (karg.count <= orig_count &&
388 (copy_to_user(ulist, karg.list,
389 karg.count * sizeof(drm_buf_desc_t))))
391 if (put_user(karg.count, &uarg->count))
400 typedef struct drm32_buf_free {
402 u32 list; /* (int *) */
404 #define DRM32_IOCTL_FREE_BUFS DRM_IOW( 0x1a, drm32_buf_free_t)
406 static int drm32_free_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
408 drm32_buf_free_t __user *uarg = (drm32_buf_free_t __user *)arg;
415 if (get_user(karg.count, &uarg->count) ||
416 get_user(tmp, &uarg->list))
421 karg.list = kmalloc(karg.count * sizeof(int), GFP_KERNEL);
426 if (copy_from_user(karg.list, ulist, (karg.count * sizeof(int))))
431 ret = sys_ioctl(fd, DRM_IOCTL_FREE_BUFS, (unsigned long) &karg);
440 typedef struct drm32_buf_pub {
441 int idx; /* Index into master buflist */
442 int total; /* Buffer size */
443 int used; /* Amount of buffer in use (for DMA) */
444 u32 address; /* Address of buffer (void *) */
447 typedef struct drm32_buf_map {
448 int count; /* Length of buflist */
449 u32 virtual; /* Mmaped area in user-virtual (void *) */
450 u32 list; /* Buffer information (drm_buf_pub_t *) */
452 #define DRM32_IOCTL_MAP_BUFS DRM_IOWR(0x19, drm32_buf_map_t)
454 static int drm32_map_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
456 drm32_buf_map_t __user *uarg = (drm32_buf_map_t __user *)arg;
457 drm32_buf_pub_t __user *ulist;
460 int orig_count, ret, i;
463 if (get_user(karg.count, &uarg->count) ||
464 get_user(tmp1, &uarg->virtual) ||
465 get_user(tmp2, &uarg->list))
468 karg.virtual = (void *) (unsigned long) tmp1;
471 orig_count = karg.count;
473 karg.list = kmalloc(karg.count * sizeof(drm_buf_pub_t), GFP_KERNEL);
478 for (i = 0; i < karg.count; i++) {
479 if (get_user(karg.list[i].idx, &ulist[i].idx) ||
480 get_user(karg.list[i].total, &ulist[i].total) ||
481 get_user(karg.list[i].used, &ulist[i].used) ||
482 get_user(tmp1, &ulist[i].address))
485 karg.list[i].address = (void *) (unsigned long) tmp1;
490 ret = sys_ioctl(fd, DRM_IOCTL_MAP_BUFS, (unsigned long) &karg);
494 for (i = 0; i < orig_count; i++) {
495 tmp1 = (u32) (long) karg.list[i].address;
496 if (put_user(karg.list[i].idx, &ulist[i].idx) ||
497 put_user(karg.list[i].total, &ulist[i].total) ||
498 put_user(karg.list[i].used, &ulist[i].used) ||
499 put_user(tmp1, &ulist[i].address)) {
504 if (put_user(karg.count, &uarg->count))
513 typedef struct drm32_dma {
514 /* Indices here refer to the offset into
515 buflist in drm_buf_get_t. */
516 int context; /* Context handle */
517 int send_count; /* Number of buffers to send */
518 u32 send_indices; /* List of handles to buffers (int *) */
519 u32 send_sizes; /* Lengths of data to send (int *) */
520 drm_dma_flags_t flags; /* Flags */
521 int request_count; /* Number of buffers requested */
522 int request_size; /* Desired size for buffers */
523 u32 request_indices; /* Buffer information (int *) */
524 u32 request_sizes; /* (int *) */
525 int granted_count; /* Number of buffers granted */
527 #define DRM32_IOCTL_DMA DRM_IOWR(0x29, drm32_dma_t)
529 /* RED PEN The DRM layer blindly dereferences the send/request
530 * index/size arrays even though they are userland
533 static int drm32_dma(unsigned int fd, unsigned int cmd, unsigned long arg)
535 drm32_dma_t __user *uarg = (drm32_dma_t __user *) arg;
536 int __user *u_si, *u_ss, *u_ri, *u_rs;
540 u32 tmp1, tmp2, tmp3, tmp4;
542 karg.send_indices = karg.send_sizes = NULL;
543 karg.request_indices = karg.request_sizes = NULL;
545 if (get_user(karg.context, &uarg->context) ||
546 get_user(karg.send_count, &uarg->send_count) ||
547 get_user(tmp1, &uarg->send_indices) ||
548 get_user(tmp2, &uarg->send_sizes) ||
549 get_user(karg.flags, &uarg->flags) ||
550 get_user(karg.request_count, &uarg->request_count) ||
551 get_user(karg.request_size, &uarg->request_size) ||
552 get_user(tmp3, &uarg->request_indices) ||
553 get_user(tmp4, &uarg->request_sizes) ||
554 get_user(karg.granted_count, &uarg->granted_count))
562 if (karg.send_count) {
563 karg.send_indices = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
564 karg.send_sizes = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
567 if (!karg.send_indices || !karg.send_sizes)
571 if (copy_from_user(karg.send_indices, u_si,
572 (karg.send_count * sizeof(int))) ||
573 copy_from_user(karg.send_sizes, u_ss,
574 (karg.send_count * sizeof(int))))
578 if (karg.request_count) {
579 karg.request_indices = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
580 karg.request_sizes = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
583 if (!karg.request_indices || !karg.request_sizes)
587 if (copy_from_user(karg.request_indices, u_ri,
588 (karg.request_count * sizeof(int))) ||
589 copy_from_user(karg.request_sizes, u_rs,
590 (karg.request_count * sizeof(int))))
596 ret = sys_ioctl(fd, DRM_IOCTL_DMA, (unsigned long) &karg);
600 if (put_user(karg.context, &uarg->context) ||
601 put_user(karg.send_count, &uarg->send_count) ||
602 put_user(karg.flags, &uarg->flags) ||
603 put_user(karg.request_count, &uarg->request_count) ||
604 put_user(karg.request_size, &uarg->request_size) ||
605 put_user(karg.granted_count, &uarg->granted_count))
608 if (karg.send_count) {
609 if (copy_to_user(u_si, karg.send_indices,
610 (karg.send_count * sizeof(int))) ||
611 copy_to_user(u_ss, karg.send_sizes,
612 (karg.send_count * sizeof(int))))
615 if (karg.request_count) {
616 if (copy_to_user(u_ri, karg.request_indices,
617 (karg.request_count * sizeof(int))) ||
618 copy_to_user(u_rs, karg.request_sizes,
619 (karg.request_count * sizeof(int))))
625 if (karg.send_indices)
626 kfree(karg.send_indices);
628 kfree(karg.send_sizes);
629 if (karg.request_indices)
630 kfree(karg.request_indices);
631 if (karg.request_sizes)
632 kfree(karg.request_sizes);
637 typedef struct drm32_ctx_res {
639 u32 contexts; /* (drm_ctx_t *) */
641 #define DRM32_IOCTL_RES_CTX DRM_IOWR(0x26, drm32_ctx_res_t)
643 static int drm32_res_ctx(unsigned int fd, unsigned int cmd, unsigned long arg)
645 drm32_ctx_res_t __user *uarg = (drm32_ctx_res_t __user *) arg;
646 drm_ctx_t __user *ulist;
652 karg.contexts = NULL;
653 if (get_user(karg.count, &uarg->count) ||
654 get_user(tmp, &uarg->contexts))
659 orig_count = karg.count;
660 if (karg.count && ulist) {
661 karg.contexts = kmalloc((karg.count * sizeof(drm_ctx_t)), GFP_KERNEL);
664 if (copy_from_user(karg.contexts, ulist,
665 (karg.count * sizeof(drm_ctx_t)))) {
666 kfree(karg.contexts);
673 ret = sys_ioctl(fd, DRM_IOCTL_RES_CTX, (unsigned long) &karg);
678 if (copy_to_user(ulist, karg.contexts,
679 (orig_count * sizeof(drm_ctx_t))))
682 if (put_user(karg.count, &uarg->count))
687 kfree(karg.contexts);
694 typedef int (* ioctl32_handler_t)(unsigned int, unsigned int, unsigned long, struct file *);
696 #define COMPATIBLE_IOCTL(cmd) HANDLE_IOCTL((cmd),sys_ioctl)
697 #define HANDLE_IOCTL(cmd,handler) { (cmd), (ioctl32_handler_t)(handler), NULL },
698 #define IOCTL_TABLE_START \
699 struct ioctl_trans ioctl_start[] = {
700 #define IOCTL_TABLE_END \
704 #include <linux/compat_ioctl.h>
706 #include "compat_ioctl.c"
707 COMPATIBLE_IOCTL(TCSBRKP)
708 COMPATIBLE_IOCTL(TIOCSTART)
709 COMPATIBLE_IOCTL(TIOCSTOP)
710 COMPATIBLE_IOCTL(TIOCSLTC)
711 COMPATIBLE_IOCTL(FBIOGTYPE)
712 COMPATIBLE_IOCTL(FBIOSATTR)
713 COMPATIBLE_IOCTL(FBIOGATTR)
714 COMPATIBLE_IOCTL(FBIOSVIDEO)
715 COMPATIBLE_IOCTL(FBIOGVIDEO)
716 COMPATIBLE_IOCTL(FBIOGCURSOR32) /* This is not implemented yet. Later it should be converted... */
717 COMPATIBLE_IOCTL(FBIOSCURPOS)
718 COMPATIBLE_IOCTL(FBIOGCURPOS)
719 COMPATIBLE_IOCTL(FBIOGCURMAX)
721 COMPATIBLE_IOCTL(KIOCTYPE)
722 COMPATIBLE_IOCTL(KIOCLAYOUT)
723 COMPATIBLE_IOCTL(KIOCGTRANS)
724 COMPATIBLE_IOCTL(KIOCTRANS)
725 COMPATIBLE_IOCTL(KIOCCMD)
726 COMPATIBLE_IOCTL(KIOCSDIRECT)
727 COMPATIBLE_IOCTL(KIOCSLED)
728 COMPATIBLE_IOCTL(KIOCGLED)
729 COMPATIBLE_IOCTL(KIOCSRATE)
730 COMPATIBLE_IOCTL(KIOCGRATE)
731 COMPATIBLE_IOCTL(VUIDSFORMAT)
732 COMPATIBLE_IOCTL(VUIDGFORMAT)
733 /* Little v, the video4linux ioctls */
734 COMPATIBLE_IOCTL(_IOR('p', 20, int[7])) /* RTCGET */
735 COMPATIBLE_IOCTL(_IOW('p', 21, int[7])) /* RTCSET */
736 COMPATIBLE_IOCTL(ENVCTRL_RD_WARNING_TEMPERATURE)
737 COMPATIBLE_IOCTL(ENVCTRL_RD_SHUTDOWN_TEMPERATURE)
738 COMPATIBLE_IOCTL(ENVCTRL_RD_CPU_TEMPERATURE)
739 COMPATIBLE_IOCTL(ENVCTRL_RD_FAN_STATUS)
740 COMPATIBLE_IOCTL(ENVCTRL_RD_VOLTAGE_STATUS)
741 COMPATIBLE_IOCTL(ENVCTRL_RD_SCSI_TEMPERATURE)
742 COMPATIBLE_IOCTL(ENVCTRL_RD_ETHERNET_TEMPERATURE)
743 COMPATIBLE_IOCTL(ENVCTRL_RD_MTHRBD_TEMPERATURE)
744 COMPATIBLE_IOCTL(ENVCTRL_RD_CPU_VOLTAGE)
745 COMPATIBLE_IOCTL(ENVCTRL_RD_GLOBALADDRESS)
746 /* COMPATIBLE_IOCTL(D7SIOCRD) same value as ENVCTRL_RD_VOLTAGE_STATUS */
747 COMPATIBLE_IOCTL(D7SIOCWR)
748 COMPATIBLE_IOCTL(D7SIOCTM)
749 /* OPENPROMIO, SunOS/Solaris only, the NetBSD one's have
750 * embedded pointers in the arg which we'd need to clean up...
752 COMPATIBLE_IOCTL(OPROMGETOPT)
753 COMPATIBLE_IOCTL(OPROMSETOPT)
754 COMPATIBLE_IOCTL(OPROMNXTOPT)
755 COMPATIBLE_IOCTL(OPROMSETOPT2)
756 COMPATIBLE_IOCTL(OPROMNEXT)
757 COMPATIBLE_IOCTL(OPROMCHILD)
758 COMPATIBLE_IOCTL(OPROMGETPROP)
759 COMPATIBLE_IOCTL(OPROMNXTPROP)
760 COMPATIBLE_IOCTL(OPROMU2P)
761 COMPATIBLE_IOCTL(OPROMGETCONS)
762 COMPATIBLE_IOCTL(OPROMGETFBNAME)
763 COMPATIBLE_IOCTL(OPROMGETBOOTARGS)
764 COMPATIBLE_IOCTL(OPROMSETCUR)
765 COMPATIBLE_IOCTL(OPROMPCI2NODE)
766 COMPATIBLE_IOCTL(OPROMPATH2NODE)
768 COMPATIBLE_IOCTL(LOOP_SET_STATUS64)
769 COMPATIBLE_IOCTL(LOOP_GET_STATUS64)
771 COMPATIBLE_IOCTL(AUDIO_GETINFO)
772 COMPATIBLE_IOCTL(AUDIO_SETINFO)
773 COMPATIBLE_IOCTL(AUDIO_DRAIN)
774 COMPATIBLE_IOCTL(AUDIO_GETDEV)
775 COMPATIBLE_IOCTL(AUDIO_GETDEV_SUNOS)
776 COMPATIBLE_IOCTL(AUDIO_FLUSH)
777 COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE_MULTI)
778 #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
779 COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC)
780 COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID)
781 COMPATIBLE_IOCTL(DRM_IOCTL_AUTH_MAGIC)
782 COMPATIBLE_IOCTL(DRM_IOCTL_BLOCK)
783 COMPATIBLE_IOCTL(DRM_IOCTL_UNBLOCK)
784 COMPATIBLE_IOCTL(DRM_IOCTL_CONTROL)
785 COMPATIBLE_IOCTL(DRM_IOCTL_ADD_BUFS)
786 COMPATIBLE_IOCTL(DRM_IOCTL_MARK_BUFS)
787 COMPATIBLE_IOCTL(DRM_IOCTL_ADD_CTX)
788 COMPATIBLE_IOCTL(DRM_IOCTL_RM_CTX)
789 COMPATIBLE_IOCTL(DRM_IOCTL_MOD_CTX)
790 COMPATIBLE_IOCTL(DRM_IOCTL_GET_CTX)
791 COMPATIBLE_IOCTL(DRM_IOCTL_SWITCH_CTX)
792 COMPATIBLE_IOCTL(DRM_IOCTL_NEW_CTX)
793 COMPATIBLE_IOCTL(DRM_IOCTL_ADD_DRAW)
794 COMPATIBLE_IOCTL(DRM_IOCTL_RM_DRAW)
795 COMPATIBLE_IOCTL(DRM_IOCTL_LOCK)
796 COMPATIBLE_IOCTL(DRM_IOCTL_UNLOCK)
797 COMPATIBLE_IOCTL(DRM_IOCTL_FINISH)
799 COMPATIBLE_IOCTL(WIOCSTART)
800 COMPATIBLE_IOCTL(WIOCSTOP)
801 COMPATIBLE_IOCTL(WIOCGSTAT)
802 /* And these ioctls need translation */
803 /* Note SIOCRTMSG is no longer, so this is safe and * the user would have seen just an -EINVAL anyways. */
804 HANDLE_IOCTL(FBIOPUTCMAP32, fbiogetputcmap)
805 HANDLE_IOCTL(FBIOGETCMAP32, fbiogetputcmap)
806 HANDLE_IOCTL(FBIOSCURSOR32, fbiogscursor)
807 #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
808 HANDLE_IOCTL(DRM32_IOCTL_VERSION, drm32_version)
809 HANDLE_IOCTL(DRM32_IOCTL_GET_UNIQUE, drm32_getsetunique)
810 HANDLE_IOCTL(DRM32_IOCTL_SET_UNIQUE, drm32_getsetunique)
811 HANDLE_IOCTL(DRM32_IOCTL_ADD_MAP, drm32_addmap)
812 HANDLE_IOCTL(DRM32_IOCTL_INFO_BUFS, drm32_info_bufs)
813 HANDLE_IOCTL(DRM32_IOCTL_FREE_BUFS, drm32_free_bufs)
814 HANDLE_IOCTL(DRM32_IOCTL_MAP_BUFS, drm32_map_bufs)
815 HANDLE_IOCTL(DRM32_IOCTL_DMA, drm32_dma)
816 HANDLE_IOCTL(DRM32_IOCTL_RES_CTX, drm32_res_ctx)
819 HANDLE_IOCTL(RTC32_IRQP_READ, do_rtc_ioctl)
820 HANDLE_IOCTL(RTC32_IRQP_SET, do_rtc_ioctl)
821 HANDLE_IOCTL(RTC32_EPOCH_READ, do_rtc_ioctl)
822 HANDLE_IOCTL(RTC32_EPOCH_SET, do_rtc_ioctl)
824 /* take care of sizeof(sizeof()) breakage */
827 int ioctl_table_size = ARRAY_SIZE(ioctl_start);