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 *)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));
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 *)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));
128 if (f.set & FB_CUR_SETCMAP) {
129 if ((uint) f.size.y > 32)
131 ret = copy_from_user (mask, A(m), f.size.y * 4);
132 ret |= copy_from_user (image, A(i), f.size.y * 4);
135 f.image = image; f.mask = mask;
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);
143 f.cmap.red = red; f.cmap.green = green; f.cmap.blue = blue;
146 ret = sys_ioctl (fd, FBIOSCURSOR, (long)&f);
151 struct ncp_ioctl_request_32 {
152 unsigned int function;
157 struct ncp_fs_info_v2_32 {
159 unsigned int mounted_uid;
160 unsigned int connection;
161 unsigned int buffer_size;
163 unsigned int volume_number;
171 struct ncp_objectname_ioctl_32
174 unsigned int object_name_len;
175 compat_caddr_t object_name; /* an userspace data, in most cases user name */
178 struct ncp_privatedata_ioctl_32
181 compat_caddr_t data; /* ~1000 for NDS */
184 #define NCP_IOC_NCPREQUEST_32 _IOR('n', 1, struct ncp_ioctl_request_32)
186 #define NCP_IOC_GETMOUNTUID2_32 _IOW('n', 2, unsigned int)
188 #define NCP_IOC_GET_FS_INFO_V2_32 _IOWR('n', 4, struct ncp_fs_info_v2_32)
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)
195 static int do_ncp_ncprequest(unsigned int fd, unsigned int cmd, unsigned long arg)
197 struct ncp_ioctl_request_32 n32;
198 struct ncp_ioctl_request n;
202 if (copy_from_user(&n32, (struct ncp_ioctl_request_32*)arg,
206 n.function = n32.function;
210 n.data = vmalloc(65536); /* 65536 must be same as NCP_PACKET_SIZE_INTERNAL in ncpfs */
214 if (copy_from_user(n.data, A(n32.data), n.size))
217 old_fs = get_fs(); set_fs (KERNEL_DS);
218 err = sys_ioctl (fd, NCP_IOC_NCPREQUEST, (unsigned long)&n);
226 if (copy_to_user(A(n32.data), n.data, err)) {
235 static int do_ncp_getmountuid2(unsigned int fd, unsigned int cmd, unsigned long arg)
237 mm_segment_t old_fs = get_fs();
241 cmd = NCP_IOC_GETMOUNTUID2;
244 err = sys_ioctl(fd, cmd, (unsigned long)&kuid);
248 err = put_user(kuid, (unsigned int*)arg);
253 static int do_ncp_getfsinfo2(unsigned int fd, unsigned int cmd, unsigned long arg)
255 mm_segment_t old_fs = get_fs();
256 struct ncp_fs_info_v2_32 n32;
257 struct ncp_fs_info_v2 n;
260 if (copy_from_user(&n32, (struct ncp_fs_info_v2_32*)arg, sizeof(n32)))
262 if (n32.version != NCP_GET_FS_INFO_VERSION_V2)
264 n.version = NCP_GET_FS_INFO_VERSION_V2;
267 err = sys_ioctl(fd, NCP_IOC_GET_FS_INFO_V2, (unsigned long)&n);
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;
285 static int do_ncp_getobjectname(unsigned int fd, unsigned int cmd, unsigned long arg)
287 struct ncp_objectname_ioctl_32 n32;
288 struct ncp_objectname_ioctl n;
293 if (copy_from_user(&n32, (struct ncp_objectname_ioctl_32*)arg,
297 n.object_name_len = tl = n32.object_name_len;
299 n.object_name = kmalloc(tl, GFP_KERNEL);
303 n.object_name = NULL;
306 old_fs = get_fs(); set_fs (KERNEL_DS);
307 err = sys_ioctl (fd, NCP_IOC_GETOBJECTNAME, (unsigned long)&n);
312 if (tl > n.object_name_len)
313 tl = n.object_name_len;
316 if (tl && copy_to_user(A(n32.object_name), n.object_name, tl))
319 n32.auth_type = n.auth_type;
320 n32.object_name_len = n.object_name_len;
322 if (copy_to_user((struct ncp_objectname_ioctl_32*)arg, &n32, sizeof(n32)))
328 kfree(n.object_name);
333 static int do_ncp_setobjectname(unsigned int fd, unsigned int cmd, unsigned long arg)
335 struct ncp_objectname_ioctl_32 n32;
336 struct ncp_objectname_ioctl n;
341 if (copy_from_user(&n32, (struct ncp_objectname_ioctl_32*)arg,
345 n.auth_type = n32.auth_type;
346 n.object_name_len = tl = n32.object_name_len;
348 n.object_name = kmalloc(tl, GFP_KERNEL);
352 if (copy_from_user(n.object_name, A(n32.object_name), tl))
355 n.object_name = NULL;
358 old_fs = get_fs(); set_fs (KERNEL_DS);
359 err = sys_ioctl (fd, NCP_IOC_SETOBJECTNAME, (unsigned long)&n);
364 kfree(n.object_name);
369 static int do_ncp_getprivatedata(unsigned int fd, unsigned int cmd, unsigned long arg)
371 struct ncp_privatedata_ioctl_32 n32;
372 struct ncp_privatedata_ioctl n;
377 if (copy_from_user(&n32, (struct ncp_privatedata_ioctl_32*)arg,
381 n.len = tl = n32.len;
383 n.data = kmalloc(tl, GFP_KERNEL);
390 old_fs = get_fs(); set_fs (KERNEL_DS);
391 err = sys_ioctl (fd, NCP_IOC_GETPRIVATEDATA, (unsigned long)&n);
400 if (tl && copy_to_user(A(n32.data), n.data, tl))
405 if (copy_to_user((struct ncp_privatedata_ioctl_32*)arg, &n32, sizeof(n32)))
416 static int do_ncp_setprivatedata(unsigned int fd, unsigned int cmd, unsigned long arg)
418 struct ncp_privatedata_ioctl_32 n32;
419 struct ncp_privatedata_ioctl n;
424 if (copy_from_user(&n32, (struct ncp_privatedata_ioctl_32*)arg,
428 n.len = tl = n32.len;
430 n.data = kmalloc(tl, GFP_KERNEL);
434 if (copy_from_user(n.data, A(n32.data), tl))
440 old_fs = get_fs(); set_fs (KERNEL_DS);
441 err = sys_ioctl (fd, NCP_IOC_SETPRIVATEDATA, (unsigned long)&n);
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"
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 */
466 #define DRM32_IOCTL_VERSION DRM_IOWR(0x00, drm32_version_t)
468 static int drm32_version(unsigned int fd, unsigned int cmd, unsigned long arg)
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;
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))
491 if (kversion.name_len && name_ptr) {
492 kversion.name = kmalloc(kversion.name_len, GFP_KERNEL);
496 if (kversion.date_len && date_ptr) {
497 kversion.date = kmalloc(kversion.date_len, GFP_KERNEL);
501 if (kversion.desc_len && desc_ptr) {
502 kversion.desc = kmalloc(kversion.desc_len, GFP_KERNEL);
509 ret = sys_ioctl (fd, DRM_IOCTL_VERSION, (unsigned long)&kversion);
513 if ((kversion.name &&
514 copy_to_user(name_ptr, kversion.name, kversion.name_len)) ||
516 copy_to_user(date_ptr, kversion.date, kversion.date_len)) ||
518 copy_to_user(desc_ptr, kversion.desc, kversion.desc_len)))
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))
531 kfree(kversion.name);
533 kfree(kversion.date);
535 kfree(kversion.desc);
539 typedef struct drm32_unique {
540 int unique_len; /* Length of unique */
541 u32 unique; /* Unique name for driver instantiation */
543 #define DRM32_IOCTL_GET_UNIQUE DRM_IOWR(0x01, drm32_unique_t)
544 #define DRM32_IOCTL_SET_UNIQUE DRM_IOW( 0x10, drm32_unique_t)
546 static int drm32_getsetunique(unsigned int fd, unsigned int cmd, unsigned long arg)
548 drm32_unique_t *uarg = (drm32_unique_t *)arg;
555 if (get_user(karg.unique_len, &uarg->unique_len))
559 if (get_user(tmp, &uarg->unique))
565 karg.unique = kmalloc(karg.unique_len, GFP_KERNEL);
568 if (cmd == DRM32_IOCTL_SET_UNIQUE &&
569 copy_from_user(karg.unique, uptr, karg.unique_len)) {
577 if (cmd == DRM32_IOCTL_GET_UNIQUE)
578 ret = sys_ioctl (fd, DRM_IOCTL_GET_UNIQUE, (unsigned long)&karg);
580 ret = sys_ioctl (fd, DRM_IOCTL_SET_UNIQUE, (unsigned long)&karg);
584 if (cmd == DRM32_IOCTL_GET_UNIQUE &&
586 copy_to_user(uptr, karg.unique, karg.unique_len))
588 if (put_user(karg.unique_len, &uarg->unique_len))
592 if (karg.unique != NULL)
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 */
608 #define DRM32_IOCTL_ADD_MAP DRM_IOWR(0x15, drm32_map_t)
610 static int drm32_addmap(unsigned int fd, unsigned int cmd, unsigned long arg)
612 drm32_map_t *uarg = (drm32_map_t *) arg;
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);
627 karg.handle = A(tmp);
631 ret = sys_ioctl(fd, DRM_IOCTL_ADD_MAP, (unsigned long) &karg);
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);
649 typedef struct drm32_buf_info {
650 int count; /* Entries in list */
651 u32 list; /* (drm_buf_desc_t *) */
653 #define DRM32_IOCTL_INFO_BUFS DRM_IOWR(0x18, drm32_buf_info_t)
655 static int drm32_info_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
657 drm32_buf_info_t *uarg = (drm32_buf_info_t *)arg;
658 drm_buf_desc_t __user *ulist;
664 if (get_user(karg.count, &uarg->count) ||
665 get_user(tmp, &uarg->list))
670 orig_count = karg.count;
672 karg.list = kmalloc(karg.count * sizeof(drm_buf_desc_t), GFP_KERNEL);
678 ret = sys_ioctl(fd, DRM_IOCTL_INFO_BUFS, (unsigned long) &karg);
682 if (karg.count <= orig_count &&
683 (copy_to_user(ulist, karg.list,
684 karg.count * sizeof(drm_buf_desc_t))))
686 if (put_user(karg.count, &uarg->count))
695 typedef struct drm32_buf_free {
697 u32 list; /* (int *) */
699 #define DRM32_IOCTL_FREE_BUFS DRM_IOW( 0x1a, drm32_buf_free_t)
701 static int drm32_free_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
703 drm32_buf_free_t *uarg = (drm32_buf_free_t *)arg;
710 if (get_user(karg.count, &uarg->count) ||
711 get_user(tmp, &uarg->list))
716 karg.list = kmalloc(karg.count * sizeof(int), GFP_KERNEL);
721 if (copy_from_user(karg.list, ulist, (karg.count * sizeof(int))))
726 ret = sys_ioctl(fd, DRM_IOCTL_FREE_BUFS, (unsigned long) &karg);
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 *) */
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 *) */
747 #define DRM32_IOCTL_MAP_BUFS DRM_IOWR(0x19, drm32_buf_map_t)
749 static int drm32_map_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
751 drm32_buf_map_t *uarg = (drm32_buf_map_t *)arg;
752 drm32_buf_pub_t __user *ulist;
755 int orig_count, ret, i;
758 if (get_user(karg.count, &uarg->count) ||
759 get_user(tmp1, &uarg->virtual) ||
760 get_user(tmp2, &uarg->list))
763 karg.virtual = A(tmp1);
766 orig_count = karg.count;
768 karg.list = kmalloc(karg.count * sizeof(drm_buf_pub_t), GFP_KERNEL);
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))
780 karg.list[i].address = A(tmp1);
785 ret = sys_ioctl(fd, DRM_IOCTL_MAP_BUFS, (unsigned long) &karg);
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)) {
799 if (put_user(karg.count, &uarg->count))
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 */
822 #define DRM32_IOCTL_DMA DRM_IOWR(0x29, drm32_dma_t)
824 /* RED PEN The DRM layer blindly dereferences the send/request
825 * index/size arrays even though they are userland
828 static int drm32_dma(unsigned int fd, unsigned int cmd, unsigned long arg)
830 drm32_dma_t *uarg = (drm32_dma_t *) arg;
831 int __user *u_si, *u_ss, *u_ri, *u_rs;
835 u32 tmp1, tmp2, tmp3, tmp4;
837 karg.send_indices = karg.send_sizes = NULL;
838 karg.request_indices = karg.request_sizes = NULL;
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))
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);
862 if (!karg.send_indices || !karg.send_sizes)
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))))
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);
878 if (!karg.request_indices || !karg.request_sizes)
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))))
891 ret = sys_ioctl(fd, DRM_IOCTL_DMA, (unsigned long) &karg);
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))
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))))
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))))
920 if (karg.send_indices)
921 kfree(karg.send_indices);
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);
932 typedef struct drm32_ctx_res {
934 u32 contexts; /* (drm_ctx_t *) */
936 #define DRM32_IOCTL_RES_CTX DRM_IOWR(0x26, drm32_ctx_res_t)
938 static int drm32_res_ctx(unsigned int fd, unsigned int cmd, unsigned long arg)
940 drm32_ctx_res_t *uarg = (drm32_ctx_res_t *) arg;
941 drm_ctx_t __user *ulist;
947 karg.contexts = NULL;
948 if (get_user(karg.count, &uarg->count) ||
949 get_user(tmp, &uarg->contexts))
954 orig_count = karg.count;
955 if (karg.count && ulist) {
956 karg.contexts = kmalloc((karg.count * sizeof(drm_ctx_t)), GFP_KERNEL);
959 if (copy_from_user(karg.contexts, ulist,
960 (karg.count * sizeof(drm_ctx_t)))) {
961 kfree(karg.contexts);
968 ret = sys_ioctl(fd, DRM_IOCTL_RES_CTX, (unsigned long) &karg);
973 if (copy_to_user(ulist, karg.contexts,
974 (orig_count * sizeof(drm_ctx_t))))
977 if (put_user(karg.count, &uarg->count))
982 kfree(karg.contexts);
989 typedef int (* ioctl32_handler_t)(unsigned int, unsigned int, unsigned long, struct file *);
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 \
999 #include <linux/compat_ioctl.h>
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)
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...
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)
1063 COMPATIBLE_IOCTL(LOOP_SET_STATUS64)
1064 COMPATIBLE_IOCTL(LOOP_GET_STATUS64)
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)
1106 COMPATIBLE_IOCTL(WIOCSTART)
1107 COMPATIBLE_IOCTL(WIOCSTOP)
1108 COMPATIBLE_IOCTL(WIOCGSTAT)
1109 /* And these ioctls need translation */
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)
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)
1139 /* take care of sizeof(sizeof()) breakage */
1142 int ioctl_table_size = ARRAY_SIZE(ioctl_start);