1
2
3
4
5
6
7
8
9
10
11#include <linux/config.h>
12#include <linux/types.h>
13#include <linux/kernel.h>
14#include <linux/sched.h>
15#include <linux/smp.h>
16#include <linux/smp_lock.h>
17#include <linux/ioctl.h>
18#include <linux/if.h>
19#include <linux/slab.h>
20#include <linux/hdreg.h>
21#include <linux/raid/md.h>
22#include <linux/kd.h>
23#include <linux/route.h>
24#include <linux/in6.h>
25#include <linux/ipv6_route.h>
26#include <linux/skbuff.h>
27#include <linux/netlink.h>
28#include <linux/vt.h>
29#include <linux/fs.h>
30#include <linux/file.h>
31#include <linux/fd.h>
32#include <linux/ppp_defs.h>
33#include <linux/if_ppp.h>
34#include <linux/if_pppox.h>
35#include <linux/if_tun.h>
36#include <linux/mtio.h>
37#include <linux/cdrom.h>
38#include <linux/loop.h>
39#include <linux/auto_fs.h>
40#include <linux/auto_fs4.h>
41#include <linux/devfs_fs.h>
42#include <linux/tty.h>
43#include <linux/vt_kern.h>
44#include <linux/fb.h>
45#include <linux/ext2_fs.h>
46#include <linux/videodev.h>
47#include <linux/netdevice.h>
48#include <linux/raw.h>
49#include <linux/smb_fs.h>
50#include <linux/ncp_fs.h>
51#include <linux/blkpg.h>
52#include <linux/blk.h>
53#include <linux/elevator.h>
54#include <linux/rtc.h>
55#include <linux/pci.h>
56#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
57#include <linux/lvm.h>
58#endif
59
60#include <scsi/scsi.h>
61
62#undef __KERNEL__
63#include <scsi/scsi_ioctl.h>
64#define __KERNEL__
65#include <scsi/sg.h>
66
67#include <asm/types.h>
68#include <asm/uaccess.h>
69#include <asm/fbio.h>
70#include <asm/kbio.h>
71#include <asm/vuid_event.h>
72#include <asm/openpromio.h>
73#include <asm/envctrl.h>
74#include <asm/audioio.h>
75#include <linux/ethtool.h>
76#include <linux/mii.h>
77#include <linux/if_bonding.h>
78#include <asm/display7seg.h>
79#include <asm/watchdog.h>
80#include <asm/module.h>
81#include <linux/soundcard.h>
82#include <linux/lp.h>
83
84#include <linux/atm.h>
85#include <linux/atmarp.h>
86#include <linux/atmclip.h>
87#include <linux/atmdev.h>
88#include <linux/atmioc.h>
89#include <linux/atmlec.h>
90#include <linux/atmmpc.h>
91#include <linux/atmsvc.h>
92#include <linux/atm_tcp.h>
93#include <linux/sonet.h>
94#include <linux/atm_suni.h>
95#include <linux/mtd/mtd.h>
96
97#include <net/bluetooth/bluetooth.h>
98#include <net/bluetooth/hci.h>
99#include <net/bluetooth/rfcomm.h>
100
101#include <linux/usb.h>
102#include <linux/usbdevice_fs.h>
103#include <linux/usb_scanner_ioctl.h>
104#include <linux/nbd.h>
105#include <linux/random.h>
106#include <linux/filter.h>
107
108
109
110#define A(__x) ((unsigned long)(__x))
111#define AA(__x) \
112({ unsigned long __ret; \
113 __asm__ ("srl %0, 0, %0" \
114 : "=r" (__ret) \
115 : "0" (__x)); \
116 __ret; \
117})
118
119
120#define EXT2_IOC32_GETFLAGS _IOR('f', 1, int)
121#define EXT2_IOC32_SETFLAGS _IOW('f', 2, int)
122#define EXT2_IOC32_GETVERSION _IOR('v', 1, int)
123#define EXT2_IOC32_SETVERSION _IOW('v', 2, int)
124
125extern asmlinkage int sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg);
126
127static int w_long(unsigned int fd, unsigned int cmd, unsigned long arg)
128{
129 mm_segment_t old_fs = get_fs();
130 int err;
131 unsigned long val;
132
133 set_fs (KERNEL_DS);
134 err = sys_ioctl(fd, cmd, (unsigned long)&val);
135 set_fs (old_fs);
136 if (!err && put_user(val, (u32 *)arg))
137 return -EFAULT;
138 return err;
139}
140
141static int rw_long(unsigned int fd, unsigned int cmd, unsigned long arg)
142{
143 mm_segment_t old_fs = get_fs();
144 int err;
145 unsigned long val;
146
147 if(get_user(val, (u32 *)arg))
148 return -EFAULT;
149 set_fs (KERNEL_DS);
150 err = sys_ioctl(fd, cmd, (unsigned long)&val);
151 set_fs (old_fs);
152 if (!err && put_user(val, (u32 *)arg))
153 return -EFAULT;
154 return err;
155}
156
157static int do_ext2_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
158{
159
160 switch (cmd) {
161 case EXT2_IOC32_GETFLAGS: cmd = EXT2_IOC_GETFLAGS; break;
162 case EXT2_IOC32_SETFLAGS: cmd = EXT2_IOC_SETFLAGS; break;
163 case EXT2_IOC32_GETVERSION: cmd = EXT2_IOC_GETVERSION; break;
164 case EXT2_IOC32_SETVERSION: cmd = EXT2_IOC_SETVERSION; break;
165 }
166 return sys_ioctl(fd, cmd, arg);
167}
168
169struct video_tuner32 {
170 s32 tuner;
171 u8 name[32];
172 u32 rangelow, rangehigh;
173 u32 flags;
174 u16 mode, signal;
175};
176
177static int get_video_tuner32(struct video_tuner *kp, struct video_tuner32 *up)
178{
179 int i;
180
181 if(get_user(kp->tuner, &up->tuner))
182 return -EFAULT;
183 for(i = 0; i < 32; i++)
184 __get_user(kp->name[i], &up->name[i]);
185 __get_user(kp->rangelow, &up->rangelow);
186 __get_user(kp->rangehigh, &up->rangehigh);
187 __get_user(kp->flags, &up->flags);
188 __get_user(kp->mode, &up->mode);
189 __get_user(kp->signal, &up->signal);
190 return 0;
191}
192
193static int put_video_tuner32(struct video_tuner *kp, struct video_tuner32 *up)
194{
195 int i;
196
197 if(put_user(kp->tuner, &up->tuner))
198 return -EFAULT;
199 for(i = 0; i < 32; i++)
200 __put_user(kp->name[i], &up->name[i]);
201 __put_user(kp->rangelow, &up->rangelow);
202 __put_user(kp->rangehigh, &up->rangehigh);
203 __put_user(kp->flags, &up->flags);
204 __put_user(kp->mode, &up->mode);
205 __put_user(kp->signal, &up->signal);
206 return 0;
207}
208
209struct video_buffer32 {
210 u32 base;
211 s32 height, width, depth, bytesperline;
212};
213
214static int get_video_buffer32(struct video_buffer *kp, struct video_buffer32 *up)
215{
216 u32 tmp;
217
218 if(get_user(tmp, &up->base))
219 return -EFAULT;
220 kp->base = (void *) ((unsigned long)tmp);
221 __get_user(kp->height, &up->height);
222 __get_user(kp->width, &up->width);
223 __get_user(kp->depth, &up->depth);
224 __get_user(kp->bytesperline, &up->bytesperline);
225 return 0;
226}
227
228static int put_video_buffer32(struct video_buffer *kp, struct video_buffer32 *up)
229{
230 u32 tmp = (u32)((unsigned long)kp->base);
231
232 if(put_user(tmp, &up->base))
233 return -EFAULT;
234 __put_user(kp->height, &up->height);
235 __put_user(kp->width, &up->width);
236 __put_user(kp->depth, &up->depth);
237 __put_user(kp->bytesperline, &up->bytesperline);
238 return 0;
239}
240
241struct video_clip32 {
242 s32 x, y, width, height;
243 u32 next;
244};
245
246struct video_window32 {
247 u32 x, y, width, height, chromakey, flags;
248 u32 clips;
249 s32 clipcount;
250};
251
252static void free_kvideo_clips(struct video_window *kp)
253{
254 struct video_clip *cp;
255
256 cp = kp->clips;
257 if(cp != NULL)
258 kfree(cp);
259}
260
261static int get_video_window32(struct video_window *kp, struct video_window32 *up)
262{
263 struct video_clip32 *ucp;
264 struct video_clip *kcp;
265 int nclips, err, i;
266 u32 tmp;
267
268 if(get_user(kp->x, &up->x))
269 return -EFAULT;
270 __get_user(kp->y, &up->y);
271 __get_user(kp->width, &up->width);
272 __get_user(kp->height, &up->height);
273 __get_user(kp->chromakey, &up->chromakey);
274 __get_user(kp->flags, &up->flags);
275 __get_user(kp->clipcount, &up->clipcount);
276 __get_user(tmp, &up->clips);
277 ucp = (struct video_clip32 *)A(tmp);
278 kp->clips = NULL;
279
280 nclips = kp->clipcount;
281 if(nclips == 0)
282 return 0;
283
284 if(ucp == 0)
285 return -EINVAL;
286
287
288 if(nclips < 0)
289 nclips = VIDEO_CLIPMAP_SIZE;
290
291 kcp = kmalloc(nclips * sizeof(struct video_clip), GFP_KERNEL);
292 err = -ENOMEM;
293 if(kcp == NULL)
294 goto cleanup_and_err;
295
296 kp->clips = kcp;
297 for(i = 0; i < nclips; i++) {
298 __get_user(kcp[i].x, &ucp[i].x);
299 __get_user(kcp[i].y, &ucp[i].y);
300 __get_user(kcp[i].width, &ucp[i].width);
301 __get_user(kcp[i].height, &ucp[i].height);
302 kcp[nclips].next = NULL;
303 }
304
305 return 0;
306
307cleanup_and_err:
308 free_kvideo_clips(kp);
309 return err;
310}
311
312
313static int put_video_window32(struct video_window *kp, struct video_window32 *up)
314{
315 if(put_user(kp->x, &up->x))
316 return -EFAULT;
317 __put_user(kp->y, &up->y);
318 __put_user(kp->width, &up->width);
319 __put_user(kp->height, &up->height);
320 __put_user(kp->chromakey, &up->chromakey);
321 __put_user(kp->flags, &up->flags);
322 __put_user(kp->clipcount, &up->clipcount);
323 return 0;
324}
325
326#define VIDIOCGTUNER32 _IOWR('v',4, struct video_tuner32)
327#define VIDIOCSTUNER32 _IOW('v',5, struct video_tuner32)
328#define VIDIOCGWIN32 _IOR('v',9, struct video_window32)
329#define VIDIOCSWIN32 _IOW('v',10, struct video_window32)
330#define VIDIOCGFBUF32 _IOR('v',11, struct video_buffer32)
331#define VIDIOCSFBUF32 _IOW('v',12, struct video_buffer32)
332#define VIDIOCGFREQ32 _IOR('v',14, u32)
333#define VIDIOCSFREQ32 _IOW('v',15, u32)
334
335static int do_video_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
336{
337 union {
338 struct video_tuner vt;
339 struct video_buffer vb;
340 struct video_window vw;
341 unsigned long vx;
342 } karg;
343 mm_segment_t old_fs = get_fs();
344 void *up = (void *)arg;
345 int err = 0;
346
347
348 switch(cmd) {
349 case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break;
350 case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break;
351 case VIDIOCGWIN32: cmd = VIDIOCGWIN; break;
352 case VIDIOCSWIN32: cmd = VIDIOCSWIN; break;
353 case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break;
354 case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break;
355 case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break;
356 case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break;
357 };
358
359 switch(cmd) {
360 case VIDIOCSTUNER:
361 case VIDIOCGTUNER:
362 err = get_video_tuner32(&karg.vt, up);
363 break;
364
365 case VIDIOCSWIN:
366 err = get_video_window32(&karg.vw, up);
367 break;
368
369 case VIDIOCSFBUF:
370 err = get_video_buffer32(&karg.vb, up);
371 break;
372
373 case VIDIOCSFREQ:
374 err = get_user(karg.vx, (u32 *)up);
375 break;
376 };
377 if(err)
378 goto out;
379
380 set_fs(KERNEL_DS);
381 err = sys_ioctl(fd, cmd, (unsigned long)&karg);
382 set_fs(old_fs);
383
384 if(cmd == VIDIOCSWIN)
385 free_kvideo_clips(&karg.vw);
386
387 if(err == 0) {
388 switch(cmd) {
389 case VIDIOCGTUNER:
390 err = put_video_tuner32(&karg.vt, up);
391 break;
392
393 case VIDIOCGWIN:
394 err = put_video_window32(&karg.vw, up);
395 break;
396
397 case VIDIOCGFBUF:
398 err = put_video_buffer32(&karg.vb, up);
399 break;
400
401 case VIDIOCGFREQ:
402 err = put_user(((u32)karg.vx), (u32 *)up);
403 break;
404 };
405 }
406out:
407 return err;
408}
409
410struct timeval32 {
411 int tv_sec;
412 int tv_usec;
413};
414
415static int do_siocgstamp(unsigned int fd, unsigned int cmd, unsigned long arg)
416{
417 struct timeval32 *up = (struct timeval32 *)arg;
418 struct timeval ktv;
419 mm_segment_t old_fs = get_fs();
420 int err;
421
422 set_fs(KERNEL_DS);
423 err = sys_ioctl(fd, cmd, (unsigned long)&ktv);
424 set_fs(old_fs);
425 if(!err) {
426 err = put_user(ktv.tv_sec, &up->tv_sec);
427 err |= __put_user(ktv.tv_usec, &up->tv_usec);
428 }
429 return err;
430}
431
432struct ifmap32 {
433 u32 mem_start;
434 u32 mem_end;
435 unsigned short base_addr;
436 unsigned char irq;
437 unsigned char dma;
438 unsigned char port;
439};
440
441struct ifreq32 {
442#define IFHWADDRLEN 6
443#define IFNAMSIZ 16
444 union {
445 char ifrn_name[IFNAMSIZ];
446 } ifr_ifrn;
447 union {
448 struct sockaddr ifru_addr;
449 struct sockaddr ifru_dstaddr;
450 struct sockaddr ifru_broadaddr;
451 struct sockaddr ifru_netmask;
452 struct sockaddr ifru_hwaddr;
453 short ifru_flags;
454 int ifru_ivalue;
455 int ifru_mtu;
456 struct ifmap32 ifru_map;
457 char ifru_slave[IFNAMSIZ];
458 char ifru_newname[IFNAMSIZ];
459 __kernel_caddr_t32 ifru_data;
460 } ifr_ifru;
461};
462
463struct ifconf32 {
464 int ifc_len;
465 __kernel_caddr_t32 ifcbuf;
466};
467
468#ifdef CONFIG_NET
469static int dev_ifname32(unsigned int fd, unsigned int cmd, unsigned long arg)
470{
471 struct net_device *dev;
472 struct ifreq32 ifr32;
473 int err;
474
475 if (copy_from_user(&ifr32, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
476 return -EFAULT;
477
478 dev = dev_get_by_index(ifr32.ifr_ifindex);
479 if (!dev)
480 return -ENODEV;
481
482 strcpy(ifr32.ifr_name, dev->name);
483 dev_put(dev);
484
485 err = copy_to_user((struct ifreq32 *)arg, &ifr32, sizeof(struct ifreq32));
486 return (err ? -EFAULT : 0);
487}
488#endif
489
490static int dev_ifconf(unsigned int fd, unsigned int cmd, unsigned long arg)
491{
492 struct ifconf32 ifc32;
493 struct ifconf ifc;
494 struct ifreq32 *ifr32;
495 struct ifreq *ifr;
496 mm_segment_t old_fs;
497 unsigned int i, j;
498 int err;
499
500 if (copy_from_user(&ifc32, (struct ifconf32 *)arg, sizeof(struct ifconf32)))
501 return -EFAULT;
502
503 if(ifc32.ifcbuf == 0) {
504 ifc32.ifc_len = 0;
505 ifc.ifc_len = 0;
506 ifc.ifc_buf = NULL;
507 } else {
508 ifc.ifc_len = ((ifc32.ifc_len / sizeof (struct ifreq32)) + 1) *
509 sizeof (struct ifreq);
510 ifc.ifc_buf = kmalloc (ifc.ifc_len, GFP_KERNEL);
511 if (!ifc.ifc_buf)
512 return -ENOMEM;
513 }
514 ifr = ifc.ifc_req;
515 ifr32 = (struct ifreq32 *)A(ifc32.ifcbuf);
516 for (i = 0; i < ifc32.ifc_len; i += sizeof (struct ifreq32)) {
517 if (copy_from_user(ifr++, ifr32++, sizeof (struct ifreq32))) {
518 kfree (ifc.ifc_buf);
519 return -EFAULT;
520 }
521 }
522 old_fs = get_fs(); set_fs (KERNEL_DS);
523 err = sys_ioctl (fd, SIOCGIFCONF, (unsigned long)&ifc);
524 set_fs (old_fs);
525 if (!err) {
526 ifr = ifc.ifc_req;
527 ifr32 = (struct ifreq32 *)A(ifc32.ifcbuf);
528 for (i = 0, j = 0; i < ifc32.ifc_len && j < ifc.ifc_len;
529 i += sizeof (struct ifreq32), j += sizeof (struct ifreq)) {
530 if (copy_to_user(ifr32++, ifr++, sizeof (struct ifreq32))) {
531 err = -EFAULT;
532 break;
533 }
534 }
535 if (!err) {
536 if (ifc32.ifcbuf == 0) {
537
538
539
540 i = ifc.ifc_len;
541 i = ((i / sizeof(struct ifreq)) * sizeof(struct ifreq32));
542 ifc32.ifc_len = i;
543 } else {
544 if (i <= ifc32.ifc_len)
545 ifc32.ifc_len = i;
546 else
547 ifc32.ifc_len = i - sizeof (struct ifreq32);
548 }
549 if (copy_to_user((struct ifconf32 *)arg, &ifc32, sizeof(struct ifconf32)))
550 err = -EFAULT;
551 }
552 }
553 if(ifc.ifc_buf != NULL)
554 kfree (ifc.ifc_buf);
555 return err;
556}
557
558static __inline__ void *alloc_user_space(long len)
559{
560 struct pt_regs *regs = current->thread.kregs;
561 unsigned long usp = regs->u_regs[UREG_I6];
562
563 if (!(current->thread.flags & SPARC_FLAG_32BIT))
564 usp += STACK_BIAS;
565
566 return (void *) (usp - len);
567}
568
569static int ethtool_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
570{
571 struct ifreq *ifr;
572 struct ifreq32 *ifr32;
573 u32 data;
574 void *datap;
575
576 ifr = alloc_user_space(sizeof(*ifr));
577 ifr32 = (struct ifreq32 *) arg;
578
579 if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
580 return -EFAULT;
581
582 if (get_user(data, &ifr32->ifr_ifru.ifru_data))
583 return -EFAULT;
584
585 datap = (void *) (unsigned long) data;
586 if (put_user(datap, &ifr->ifr_ifru.ifru_data))
587 return -EFAULT;
588
589 return sys_ioctl(fd, cmd, (unsigned long) ifr);
590}
591
592static int bond_ioctl(unsigned long fd, unsigned int cmd, unsigned long arg)
593{
594 struct ifreq ifr;
595 mm_segment_t old_fs;
596 int err, len;
597 u32 data;
598
599 if (copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
600 return -EFAULT;
601 ifr.ifr_data = (__kernel_caddr_t)get_free_page(GFP_KERNEL);
602 if (!ifr.ifr_data)
603 return -EAGAIN;
604
605 switch (cmd) {
606 case SIOCBONDENSLAVE:
607 case SIOCBONDRELEASE:
608 case SIOCBONDSETHWADDR:
609 case SIOCBONDCHANGEACTIVE:
610 len = IFNAMSIZ * sizeof(char);
611 break;
612 case SIOCBONDSLAVEINFOQUERY:
613 len = sizeof(struct ifslave);
614 break;
615 case SIOCBONDINFOQUERY:
616 len = sizeof(struct ifbond);
617 break;
618 default:
619 err = -EINVAL;
620 goto out;
621 };
622
623 __get_user(data, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_data));
624 if (copy_from_user(ifr.ifr_data, (char *)A(data), len)) {
625 err = -EFAULT;
626 goto out;
627 }
628
629 old_fs = get_fs();
630 set_fs (KERNEL_DS);
631 err = sys_ioctl (fd, cmd, (unsigned long)&ifr);
632 set_fs (old_fs);
633 if (!err) {
634 len = copy_to_user((char *)A(data), ifr.ifr_data, len);
635 if (len)
636 err = -EFAULT;
637 }
638
639out:
640 free_page((unsigned long)ifr.ifr_data);
641 return err;
642}
643
644static int siocdevprivate_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
645{
646 struct ifreq *u_ifreq64;
647 struct ifreq32 *u_ifreq32 = (struct ifreq32 *) arg;
648 char tmp_buf[IFNAMSIZ];
649 void *data64;
650 u32 data32;
651
652 if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]),
653 IFNAMSIZ))
654 return -EFAULT;
655 if (__get_user(data32, &u_ifreq32->ifr_ifru.ifru_data))
656 return -EFAULT;
657 data64 = (void *) A(data32);
658
659 u_ifreq64 = alloc_user_space(sizeof(*u_ifreq64));
660
661
662
663
664 copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0], IFNAMSIZ);
665 __put_user(data64, &u_ifreq64->ifr_ifru.ifru_data);
666
667 return sys_ioctl(fd, cmd, (unsigned long) u_ifreq64);
668}
669
670static int dev_ifsioc(unsigned int fd, unsigned int cmd, unsigned long arg)
671{
672 struct ifreq ifr;
673 mm_segment_t old_fs;
674 int err;
675
676 switch (cmd) {
677 case SIOCSIFMAP:
678 err = copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(ifr.ifr_name));
679 err |= __get_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
680 err |= __get_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
681 err |= __get_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
682 err |= __get_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
683 err |= __get_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
684 err |= __get_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
685 if (err)
686 return -EFAULT;
687 break;
688 default:
689 if (copy_from_user(&ifr, (struct ifreq32 *)arg, sizeof(struct ifreq32)))
690 return -EFAULT;
691 break;
692 }
693 old_fs = get_fs();
694 set_fs (KERNEL_DS);
695 err = sys_ioctl (fd, cmd, (unsigned long)&ifr);
696 set_fs (old_fs);
697 if (!err) {
698 switch (cmd) {
699 case SIOCGIFFLAGS:
700 case SIOCGIFMETRIC:
701 case SIOCGIFMTU:
702 case SIOCGIFMEM:
703 case SIOCGIFHWADDR:
704 case SIOCGIFINDEX:
705 case SIOCGIFADDR:
706 case SIOCGIFBRDADDR:
707 case SIOCGIFDSTADDR:
708 case SIOCGIFNETMASK:
709 case SIOCGIFTXQLEN:
710 if (copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(struct ifreq32)))
711 return -EFAULT;
712 break;
713 case SIOCGIFMAP:
714 err = copy_to_user((struct ifreq32 *)arg, &ifr, sizeof(ifr.ifr_name));
715 err |= __put_user(ifr.ifr_map.mem_start, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_start));
716 err |= __put_user(ifr.ifr_map.mem_end, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.mem_end));
717 err |= __put_user(ifr.ifr_map.base_addr, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.base_addr));
718 err |= __put_user(ifr.ifr_map.irq, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.irq));
719 err |= __put_user(ifr.ifr_map.dma, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.dma));
720 err |= __put_user(ifr.ifr_map.port, &(((struct ifreq32 *)arg)->ifr_ifru.ifru_map.port));
721 if (err)
722 err = -EFAULT;
723 break;
724 }
725 }
726 return err;
727}
728
729struct rtentry32 {
730 u32 rt_pad1;
731 struct sockaddr rt_dst;
732 struct sockaddr rt_gateway;
733 struct sockaddr rt_genmask;
734 unsigned short rt_flags;
735 short rt_pad2;
736 u32 rt_pad3;
737 unsigned char rt_tos;
738 unsigned char rt_class;
739 short rt_pad4;
740 short rt_metric;
741 u32 rt_dev;
742 u32 rt_mtu;
743 u32 rt_window;
744 unsigned short rt_irtt;
745
746};
747
748struct in6_rtmsg32 {
749 struct in6_addr rtmsg_dst;
750 struct in6_addr rtmsg_src;
751 struct in6_addr rtmsg_gateway;
752 u32 rtmsg_type;
753 u16 rtmsg_dst_len;
754 u16 rtmsg_src_len;
755 u32 rtmsg_metric;
756 u32 rtmsg_info;
757 u32 rtmsg_flags;
758 s32 rtmsg_ifindex;
759};
760
761extern struct socket *sockfd_lookup(int fd, int *err);
762
763extern __inline__ void sockfd_put(struct socket *sock)
764{
765 fput(sock->file);
766}
767
768static int routing_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
769{
770 int ret;
771 void *r = NULL;
772 struct in6_rtmsg r6;
773 struct rtentry r4;
774 char devname[16];
775 u32 rtdev;
776 mm_segment_t old_fs = get_fs();
777
778 struct socket *mysock = sockfd_lookup(fd, &ret);
779
780 if (mysock && mysock->sk && mysock->sk->family == AF_INET6) {
781 ret = copy_from_user (&r6.rtmsg_dst, &(((struct in6_rtmsg32 *)arg)->rtmsg_dst),
782 3 * sizeof(struct in6_addr));
783 ret |= __get_user (r6.rtmsg_type, &(((struct in6_rtmsg32 *)arg)->rtmsg_type));
784 ret |= __get_user (r6.rtmsg_dst_len, &(((struct in6_rtmsg32 *)arg)->rtmsg_dst_len));
785 ret |= __get_user (r6.rtmsg_src_len, &(((struct in6_rtmsg32 *)arg)->rtmsg_src_len));
786 ret |= __get_user (r6.rtmsg_metric, &(((struct in6_rtmsg32 *)arg)->rtmsg_metric));
787 ret |= __get_user (r6.rtmsg_info, &(((struct in6_rtmsg32 *)arg)->rtmsg_info));
788 ret |= __get_user (r6.rtmsg_flags, &(((struct in6_rtmsg32 *)arg)->rtmsg_flags));
789 ret |= __get_user (r6.rtmsg_ifindex, &(((struct in6_rtmsg32 *)arg)->rtmsg_ifindex));
790
791 r = (void *) &r6;
792 } else {
793 ret = copy_from_user (&r4.rt_dst, &(((struct rtentry32 *)arg)->rt_dst), 3 * sizeof(struct sockaddr));
794 ret |= __get_user (r4.rt_flags, &(((struct rtentry32 *)arg)->rt_flags));
795 ret |= __get_user (r4.rt_metric, &(((struct rtentry32 *)arg)->rt_metric));
796 ret |= __get_user (r4.rt_mtu, &(((struct rtentry32 *)arg)->rt_mtu));
797 ret |= __get_user (r4.rt_window, &(((struct rtentry32 *)arg)->rt_window));
798 ret |= __get_user (r4.rt_irtt, &(((struct rtentry32 *)arg)->rt_irtt));
799 ret |= __get_user (rtdev, &(((struct rtentry32 *)arg)->rt_dev));
800 if (rtdev) {
801 ret |= copy_from_user (devname, (char *)A(rtdev), 15);
802 r4.rt_dev = devname; devname[15] = 0;
803 } else
804 r4.rt_dev = 0;
805
806 r = (void *) &r4;
807 }
808
809 if (ret)
810 return -EFAULT;
811
812 set_fs (KERNEL_DS);
813 ret = sys_ioctl (fd, cmd, (long) r);
814 set_fs (old_fs);
815
816 if (mysock)
817 sockfd_put(mysock);
818
819 return ret;
820}
821
822struct hd_geometry32 {
823 unsigned char heads;
824 unsigned char sectors;
825 unsigned short cylinders;
826 u32 start;
827};
828
829static int hdio_getgeo(unsigned int fd, unsigned int cmd, unsigned long arg)
830{
831 mm_segment_t old_fs = get_fs();
832 struct hd_geometry geo;
833 int err;
834
835 set_fs (KERNEL_DS);
836 err = sys_ioctl(fd, HDIO_GETGEO, (unsigned long)&geo);
837 set_fs (old_fs);
838 if (!err) {
839 if (copy_to_user ((struct hd_geometry32 *)arg, &geo, 4) ||
840 __put_user (geo.start, &(((struct hd_geometry32 *)arg)->start)))
841 err = -EFAULT;
842 }
843 return err;
844}
845
846struct hd_big_geometry32 {
847 unsigned char heads;
848 unsigned char sectors;
849 unsigned int cylinders;
850 u32 start;
851};
852
853static int hdio_getgeo_big(unsigned int fd, unsigned int cmd, unsigned long arg)
854{
855 mm_segment_t old_fs = get_fs();
856 struct hd_big_geometry geo;
857 int err;
858
859 set_fs (KERNEL_DS);
860 err = sys_ioctl(fd, cmd, (unsigned long)&geo);
861 set_fs (old_fs);
862 if (!err) {
863 struct hd_big_geometry32 *up = (struct hd_big_geometry32 *) arg;
864
865 if (put_user(geo.heads, &up->heads) ||
866 __put_user(geo.sectors, &up->sectors) ||
867 __put_user(geo.cylinders, &up->cylinders) ||
868 __put_user(((u32) geo.start), &up->start))
869 err = -EFAULT;
870 }
871 return err;
872}
873
874struct fbcmap32 {
875 int index;
876 int count;
877 u32 red;
878 u32 green;
879 u32 blue;
880};
881
882#define FBIOPUTCMAP32 _IOW('F', 3, struct fbcmap32)
883#define FBIOGETCMAP32 _IOW('F', 4, struct fbcmap32)
884
885static int fbiogetputcmap(unsigned int fd, unsigned int cmd, unsigned long arg)
886{
887 struct fbcmap f;
888 int ret;
889 char red[256], green[256], blue[256];
890 u32 r, g, b;
891 mm_segment_t old_fs = get_fs();
892
893 ret = get_user(f.index, &(((struct fbcmap32 *)arg)->index));
894 ret |= __get_user(f.count, &(((struct fbcmap32 *)arg)->count));
895 ret |= __get_user(r, &(((struct fbcmap32 *)arg)->red));
896 ret |= __get_user(g, &(((struct fbcmap32 *)arg)->green));
897 ret |= __get_user(b, &(((struct fbcmap32 *)arg)->blue));
898 if (ret)
899 return -EFAULT;
900 if ((f.index < 0) || (f.index > 255)) return -EINVAL;
901 if (f.index + f.count > 256)
902 f.count = 256 - f.index;
903 if (cmd == FBIOPUTCMAP32) {
904 ret = copy_from_user (red, (char *)A(r), f.count);
905 ret |= copy_from_user (green, (char *)A(g), f.count);
906 ret |= copy_from_user (blue, (char *)A(b), f.count);
907 if (ret)
908 return -EFAULT;
909 }
910 f.red = red; f.green = green; f.blue = blue;
911 set_fs (KERNEL_DS);
912 ret = sys_ioctl (fd, (cmd == FBIOPUTCMAP32) ? FBIOPUTCMAP_SPARC : FBIOGETCMAP_SPARC, (long)&f);
913 set_fs (old_fs);
914 if (!ret && cmd == FBIOGETCMAP32) {
915 ret = copy_to_user ((char *)A(r), red, f.count);
916 ret |= copy_to_user ((char *)A(g), green, f.count);
917 ret |= copy_to_user ((char *)A(b), blue, f.count);
918 }
919 return ret ? -EFAULT : 0;
920}
921
922struct fbcursor32 {
923 short set;
924 short enable;
925 struct fbcurpos pos;
926 struct fbcurpos hot;
927 struct fbcmap32 cmap;
928 struct fbcurpos size;
929 u32 image;
930 u32 mask;
931};
932
933#define FBIOSCURSOR32 _IOW('F', 24, struct fbcursor32)
934#define FBIOGCURSOR32 _IOW('F', 25, struct fbcursor32)
935
936static int fbiogscursor(unsigned int fd, unsigned int cmd, unsigned long arg)
937{
938 struct fbcursor f;
939 int ret;
940 char red[2], green[2], blue[2];
941 char image[128], mask[128];
942 u32 r, g, b;
943 u32 m, i;
944 mm_segment_t old_fs = get_fs();
945
946 ret = copy_from_user (&f, (struct fbcursor32 *)arg, 2 * sizeof (short) + 2 * sizeof(struct fbcurpos));
947 ret |= __get_user(f.size.fbx, &(((struct fbcursor32 *)arg)->size.fbx));
948 ret |= __get_user(f.size.fby, &(((struct fbcursor32 *)arg)->size.fby));
949 ret |= __get_user(f.cmap.index, &(((struct fbcursor32 *)arg)->cmap.index));
950 ret |= __get_user(f.cmap.count, &(((struct fbcursor32 *)arg)->cmap.count));
951 ret |= __get_user(r, &(((struct fbcursor32 *)arg)->cmap.red));
952 ret |= __get_user(g, &(((struct fbcursor32 *)arg)->cmap.green));
953 ret |= __get_user(b, &(((struct fbcursor32 *)arg)->cmap.blue));
954 ret |= __get_user(m, &(((struct fbcursor32 *)arg)->mask));
955 ret |= __get_user(i, &(((struct fbcursor32 *)arg)->image));
956 if (ret)
957 return -EFAULT;
958 if (f.set & FB_CUR_SETCMAP) {
959 if ((uint) f.size.fby > 32)
960 return -EINVAL;
961 ret = copy_from_user (mask, (char *)A(m), f.size.fby * 4);
962 ret |= copy_from_user (image, (char *)A(i), f.size.fby * 4);
963 if (ret)
964 return -EFAULT;
965 f.image = image; f.mask = mask;
966 }
967 if (f.set & FB_CUR_SETCMAP) {
968 ret = copy_from_user (red, (char *)A(r), 2);
969 ret |= copy_from_user (green, (char *)A(g), 2);
970 ret |= copy_from_user (blue, (char *)A(b), 2);
971 if (ret)
972 return -EFAULT;
973 f.cmap.red = red; f.cmap.green = green; f.cmap.blue = blue;
974 }
975 set_fs (KERNEL_DS);
976 ret = sys_ioctl (fd, FBIOSCURSOR, (long)&f);
977 set_fs (old_fs);
978 return ret;
979}
980
981struct fb_fix_screeninfo32 {
982 char id[16];
983 __kernel_caddr_t32 smem_start;
984 __u32 smem_len;
985 __u32 type;
986 __u32 type_aux;
987 __u32 visual;
988 __u16 xpanstep;
989 __u16 ypanstep;
990 __u16 ywrapstep;
991 __u32 line_length;
992 __kernel_caddr_t32 mmio_start;
993 __u32 mmio_len;
994 __u32 accel;
995 __u16 reserved[3];
996};
997
998struct fb_cmap32 {
999 __u32 start;
1000 __u32 len;
1001 __kernel_caddr_t32 red;
1002 __kernel_caddr_t32 green;
1003 __kernel_caddr_t32 blue;
1004 __kernel_caddr_t32 transp;
1005};
1006
1007static int do_cmap_ptr(__u16 **ptr64, __u32 *ptr32)
1008{
1009 __u32 data;
1010 void *datap;
1011
1012 if (get_user(data, ptr32))
1013 return -EFAULT;
1014 datap = (void *) (unsigned long) data;
1015 if (put_user(datap, ptr64))
1016 return -EFAULT;
1017 return 0;
1018}
1019
1020static int fb_getput_cmap(unsigned int fd, unsigned int cmd, unsigned long arg)
1021{
1022 struct fb_cmap *cmap;
1023 struct fb_cmap32 *cmap32;
1024 int err;
1025
1026 cmap = alloc_user_space(sizeof(*cmap));
1027 cmap32 = (struct fb_cmap32 *) arg;
1028
1029 if (copy_in_user(&cmap->start, &cmap32->start, 2 * sizeof(__u32)))
1030 return -EFAULT;
1031
1032 if (do_cmap_ptr(&cmap->red, &cmap32->red) ||
1033 do_cmap_ptr(&cmap->green, &cmap32->green) ||
1034 do_cmap_ptr(&cmap->blue, &cmap32->blue) ||
1035 do_cmap_ptr(&cmap->transp, &cmap32->transp))
1036 return -EFAULT;
1037
1038 err = sys_ioctl(fd, cmd, (unsigned long) cmap);
1039
1040 if (!err) {
1041 if (copy_in_user(&cmap32->start,
1042 &cmap->start,
1043 2 * sizeof(__u32)))
1044 err = -EFAULT;
1045 }
1046 return err;
1047}
1048
1049static int do_fscreeninfo_to_user(struct fb_fix_screeninfo *fix,
1050 struct fb_fix_screeninfo32 *fix32)
1051{
1052 __u32 data;
1053 int err;
1054
1055 err = copy_to_user(&fix32->id, &fix->id, sizeof(fix32->id));
1056
1057 data = (__u32) (unsigned long) fix->smem_start;
1058 err |= put_user(data, &fix32->smem_start);
1059
1060 err |= put_user(fix->smem_len, &fix32->smem_len);
1061 err |= put_user(fix->type, &fix32->type);
1062 err |= put_user(fix->type_aux, &fix32->type_aux);
1063 err |= put_user(fix->visual, &fix32->visual);
1064 err |= put_user(fix->xpanstep, &fix32->xpanstep);
1065 err |= put_user(fix->ypanstep, &fix32->ypanstep);
1066 err |= put_user(fix->ywrapstep, &fix32->ywrapstep);
1067 err |= put_user(fix->line_length, &fix32->line_length);
1068
1069 data = (__u32) (unsigned long) fix->mmio_start;
1070 err |= put_user(data, &fix32->mmio_start);
1071
1072 err |= put_user(fix->mmio_len, &fix32->mmio_len);
1073 err |= put_user(fix->accel, &fix32->accel);
1074 err |= copy_to_user(fix32->reserved, fix->reserved,
1075 sizeof(fix->reserved));
1076
1077 return err;
1078}
1079
1080static int fb_get_fscreeninfo(unsigned int fd, unsigned int cmd, unsigned long arg)
1081{
1082 mm_segment_t old_fs;
1083 struct fb_fix_screeninfo fix;
1084 struct fb_fix_screeninfo32 *fix32;
1085 int err;
1086
1087 fix32 = (struct fb_fix_screeninfo32 *) arg;
1088
1089 old_fs = get_fs();
1090 set_fs(KERNEL_DS);
1091 err = sys_ioctl(fd, cmd, (unsigned long) &fix);
1092 set_fs(old_fs);
1093
1094 if (!err)
1095 err = do_fscreeninfo_to_user(&fix, fix32);
1096
1097 return err;
1098}
1099
1100static int fb_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1101{
1102 int err;
1103
1104 switch (cmd) {
1105 case FBIOGET_FSCREENINFO:
1106 err = fb_get_fscreeninfo(fd,cmd, arg);
1107 break;
1108
1109 case FBIOGETCMAP:
1110 case FBIOPUTCMAP:
1111 err = fb_getput_cmap(fd, cmd, arg);
1112 break;
1113
1114 default:
1115 do {
1116 static int count;
1117 if (++count <= 20)
1118 printk("%s: Unknown fb ioctl cmd fd(%d) "
1119 "cmd(%08x) arg(%08lx)\n",
1120 __FUNCTION__, fd, cmd, arg);
1121 } while(0);
1122 err = -ENOSYS;
1123 break;
1124 };
1125
1126 return err;
1127}
1128
1129static int hdio_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1130{
1131 mm_segment_t old_fs = get_fs();
1132 unsigned long kval;
1133 unsigned int *uvp;
1134 int error;
1135
1136 set_fs(KERNEL_DS);
1137 error = sys_ioctl(fd, cmd, (long)&kval);
1138 set_fs(old_fs);
1139
1140 if(error == 0) {
1141 uvp = (unsigned int *)arg;
1142 if(put_user(kval, uvp))
1143 error = -EFAULT;
1144 }
1145 return error;
1146}
1147
1148struct floppy_struct32 {
1149 unsigned int size;
1150 unsigned int sect;
1151 unsigned int head;
1152 unsigned int track;
1153 unsigned int stretch;
1154 unsigned char gap;
1155 unsigned char rate;
1156 unsigned char spec1;
1157 unsigned char fmt_gap;
1158 const __kernel_caddr_t32 name;
1159};
1160
1161struct floppy_drive_params32 {
1162 char cmos;
1163 u32 max_dtr;
1164 u32 hlt;
1165 u32 hut;
1166 u32 srt;
1167 u32 spinup;
1168 u32 spindown;
1169 unsigned char spindown_offset;
1170 unsigned char select_delay;
1171 unsigned char rps;
1172 unsigned char tracks;
1173 u32 timeout;
1174 unsigned char interleave_sect;
1175 struct floppy_max_errors max_errors;
1176 char flags;
1177 char read_track;
1178 short autodetect[8];
1179 int checkfreq;
1180 int native_format;
1181};
1182
1183struct floppy_drive_struct32 {
1184 signed char flags;
1185 u32 spinup_date;
1186 u32 select_date;
1187 u32 first_read_date;
1188 short probed_format;
1189 short track;
1190 short maxblock;
1191 short maxtrack;
1192 int generation;
1193 int keep_data;
1194 int fd_ref;
1195 int fd_device;
1196 int last_checked;
1197 __kernel_caddr_t32 dmabuf;
1198 int bufblocks;
1199};
1200
1201struct floppy_fdc_state32 {
1202 int spec1;
1203 int spec2;
1204 int dtr;
1205 unsigned char version;
1206 unsigned char dor;
1207 u32 address;
1208 unsigned int rawcmd:2;
1209 unsigned int reset:1;
1210 unsigned int need_configure:1;
1211 unsigned int perp_mode:2;
1212 unsigned int has_fifo:1;
1213 unsigned int driver_version;
1214 unsigned char track[4];
1215};
1216
1217struct floppy_write_errors32 {
1218 unsigned int write_errors;
1219 u32 first_error_sector;
1220 int first_error_generation;
1221 u32 last_error_sector;
1222 int last_error_generation;
1223 unsigned int badness;
1224};
1225
1226#define FDSETPRM32 _IOW(2, 0x42, struct floppy_struct32)
1227#define FDDEFPRM32 _IOW(2, 0x43, struct floppy_struct32)
1228#define FDGETPRM32 _IOR(2, 0x04, struct floppy_struct32)
1229#define FDSETDRVPRM32 _IOW(2, 0x90, struct floppy_drive_params32)
1230#define FDGETDRVPRM32 _IOR(2, 0x11, struct floppy_drive_params32)
1231#define FDGETDRVSTAT32 _IOR(2, 0x12, struct floppy_drive_struct32)
1232#define FDPOLLDRVSTAT32 _IOR(2, 0x13, struct floppy_drive_struct32)
1233#define FDGETFDCSTAT32 _IOR(2, 0x15, struct floppy_fdc_state32)
1234#define FDWERRORGET32 _IOR(2, 0x17, struct floppy_write_errors32)
1235
1236static struct {
1237 unsigned int cmd32;
1238 unsigned int cmd;
1239} fd_ioctl_trans_table[] = {
1240 { FDSETPRM32, FDSETPRM },
1241 { FDDEFPRM32, FDDEFPRM },
1242 { FDGETPRM32, FDGETPRM },
1243 { FDSETDRVPRM32, FDSETDRVPRM },
1244 { FDGETDRVPRM32, FDGETDRVPRM },
1245 { FDGETDRVSTAT32, FDGETDRVSTAT },
1246 { FDPOLLDRVSTAT32, FDPOLLDRVSTAT },
1247 { FDGETFDCSTAT32, FDGETFDCSTAT },
1248 { FDWERRORGET32, FDWERRORGET }
1249};
1250
1251#define NR_FD_IOCTL_TRANS (sizeof(fd_ioctl_trans_table)/sizeof(fd_ioctl_trans_table[0]))
1252
1253static int fd_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1254{
1255 mm_segment_t old_fs = get_fs();
1256 void *karg = NULL;
1257 unsigned int kcmd = 0;
1258 int i, err;
1259
1260 for (i = 0; i < NR_FD_IOCTL_TRANS; i++)
1261 if (cmd == fd_ioctl_trans_table[i].cmd32) {
1262 kcmd = fd_ioctl_trans_table[i].cmd;
1263 break;
1264 }
1265 if (!kcmd)
1266 return -EINVAL;
1267
1268 switch (cmd) {
1269 case FDSETPRM32:
1270 case FDDEFPRM32:
1271 case FDGETPRM32:
1272 {
1273 struct floppy_struct *f;
1274 u32 u_name;
1275
1276 f = karg = kmalloc(sizeof(struct floppy_struct), GFP_KERNEL);
1277 if (!karg)
1278 return -ENOMEM;
1279 if (cmd == FDGETPRM32)
1280 break;
1281 err = __get_user(f->size, &((struct floppy_struct32 *)arg)->size);
1282 err |= __get_user(f->sect, &((struct floppy_struct32 *)arg)->sect);
1283 err |= __get_user(f->head, &((struct floppy_struct32 *)arg)->head);
1284 err |= __get_user(f->track, &((struct floppy_struct32 *)arg)->track);
1285 err |= __get_user(f->stretch, &((struct floppy_struct32 *)arg)->stretch);
1286 err |= __get_user(f->gap, &((struct floppy_struct32 *)arg)->gap);
1287 err |= __get_user(f->rate, &((struct floppy_struct32 *)arg)->rate);
1288 err |= __get_user(f->spec1, &((struct floppy_struct32 *)arg)->spec1);
1289 err |= __get_user(f->fmt_gap, &((struct floppy_struct32 *)arg)->fmt_gap);
1290 err |= __get_user(u_name, &((struct floppy_struct32 *)arg)->name);
1291 f->name = (void *) (long) u_name;
1292 if (err) {
1293 err = -EFAULT;
1294 goto out;
1295 }
1296 break;
1297 }
1298 case FDSETDRVPRM32:
1299 case FDGETDRVPRM32:
1300 {
1301 struct floppy_drive_params *f;
1302
1303 f = karg = kmalloc(sizeof(struct floppy_drive_params), GFP_KERNEL);
1304 if (!karg)
1305 return -ENOMEM;
1306 if (cmd == FDGETDRVPRM32)
1307 break;
1308 err = __get_user(f->cmos, &((struct floppy_drive_params32 *)arg)->cmos);
1309 err |= __get_user(f->max_dtr, &((struct floppy_drive_params32 *)arg)->max_dtr);
1310 err |= __get_user(f->hlt, &((struct floppy_drive_params32 *)arg)->hlt);
1311 err |= __get_user(f->hut, &((struct floppy_drive_params32 *)arg)->hut);
1312 err |= __get_user(f->srt, &((struct floppy_drive_params32 *)arg)->srt);
1313 err |= __get_user(f->spinup, &((struct floppy_drive_params32 *)arg)->spinup);
1314 err |= __get_user(f->spindown, &((struct floppy_drive_params32 *)arg)->spindown);
1315 err |= __get_user(f->spindown_offset, &((struct floppy_drive_params32 *)arg)->spindown_offset);
1316 err |= __get_user(f->select_delay, &((struct floppy_drive_params32 *)arg)->select_delay);
1317 err |= __get_user(f->rps, &((struct floppy_drive_params32 *)arg)->rps);
1318 err |= __get_user(f->tracks, &((struct floppy_drive_params32 *)arg)->tracks);
1319 err |= __get_user(f->timeout, &((struct floppy_drive_params32 *)arg)->timeout);
1320 err |= __get_user(f->interleave_sect, &((struct floppy_drive_params32 *)arg)->interleave_sect);
1321 err |= __copy_from_user(&f->max_errors, &((struct floppy_drive_params32 *)arg)->max_errors, sizeof(f->max_errors));
1322 err |= __get_user(f->flags, &((struct floppy_drive_params32 *)arg)->flags);
1323 err |= __get_user(f->read_track, &((struct floppy_drive_params32 *)arg)->read_track);
1324 err |= __copy_from_user(f->autodetect, ((struct floppy_drive_params32 *)arg)->autodetect, sizeof(f->autodetect));
1325 err |= __get_user(f->checkfreq, &((struct floppy_drive_params32 *)arg)->checkfreq);
1326 err |= __get_user(f->native_format, &((struct floppy_drive_params32 *)arg)->native_format);
1327 if (err) {
1328 err = -EFAULT;
1329 goto out;
1330 }
1331 break;
1332 }
1333 case FDGETDRVSTAT32:
1334 case FDPOLLDRVSTAT32:
1335 karg = kmalloc(sizeof(struct floppy_drive_struct), GFP_KERNEL);
1336 if (!karg)
1337 return -ENOMEM;
1338 break;
1339 case FDGETFDCSTAT32:
1340 karg = kmalloc(sizeof(struct floppy_fdc_state), GFP_KERNEL);
1341 if (!karg)
1342 return -ENOMEM;
1343 break;
1344 case FDWERRORGET32:
1345 karg = kmalloc(sizeof(struct floppy_write_errors), GFP_KERNEL);
1346 if (!karg)
1347 return -ENOMEM;
1348 break;
1349 default:
1350 return -EINVAL;
1351 }
1352 set_fs (KERNEL_DS);
1353 err = sys_ioctl (fd, kcmd, (unsigned long)karg);
1354 set_fs (old_fs);
1355 if (err)
1356 goto out;
1357 switch (cmd) {
1358 case FDGETPRM32:
1359 {
1360 struct floppy_struct *f = karg;
1361
1362 err = __put_user(f->size, &((struct floppy_struct32 *)arg)->size);
1363 err |= __put_user(f->sect, &((struct floppy_struct32 *)arg)->sect);
1364 err |= __put_user(f->head, &((struct floppy_struct32 *)arg)->head);
1365 err |= __put_user(f->track, &((struct floppy_struct32 *)arg)->track);
1366 err |= __put_user(f->stretch, &((struct floppy_struct32 *)arg)->stretch);
1367 err |= __put_user(f->gap, &((struct floppy_struct32 *)arg)->gap);
1368 err |= __put_user(f->rate, &((struct floppy_struct32 *)arg)->rate);
1369 err |= __put_user(f->spec1, &((struct floppy_struct32 *)arg)->spec1);
1370 err |= __put_user(f->fmt_gap, &((struct floppy_struct32 *)arg)->fmt_gap);
1371 err |= __put_user((u64)f->name, &((struct floppy_struct32 *)arg)->name);
1372 break;
1373 }
1374 case FDGETDRVPRM32:
1375 {
1376 struct floppy_drive_params *f = karg;
1377
1378 err = __put_user(f->cmos, &((struct floppy_drive_params32 *)arg)->cmos);
1379 err |= __put_user(f->max_dtr, &((struct floppy_drive_params32 *)arg)->max_dtr);
1380 err |= __put_user(f->hlt, &((struct floppy_drive_params32 *)arg)->hlt);
1381 err |= __put_user(f->hut, &((struct floppy_drive_params32 *)arg)->hut);
1382 err |= __put_user(f->srt, &((struct floppy_drive_params32 *)arg)->srt);
1383 err |= __put_user(f->spinup, &((struct floppy_drive_params32 *)arg)->spinup);
1384 err |= __put_user(f->spindown, &((struct floppy_drive_params32 *)arg)->spindown);
1385 err |= __put_user(f->spindown_offset, &((struct floppy_drive_params32 *)arg)->spindown_offset);
1386 err |= __put_user(f->select_delay, &((struct floppy_drive_params32 *)arg)->select_delay);
1387 err |= __put_user(f->rps, &((struct floppy_drive_params32 *)arg)->rps);
1388 err |= __put_user(f->tracks, &((struct floppy_drive_params32 *)arg)->tracks);
1389 err |= __put_user(f->timeout, &((struct floppy_drive_params32 *)arg)->timeout);
1390 err |= __put_user(f->interleave_sect, &((struct floppy_drive_params32 *)arg)->interleave_sect);
1391 err |= __copy_to_user(&((struct floppy_drive_params32 *)arg)->max_errors, &f->max_errors, sizeof(f->max_errors));
1392 err |= __put_user(f->flags, &((struct floppy_drive_params32 *)arg)->flags);
1393 err |= __put_user(f->read_track, &((struct floppy_drive_params32 *)arg)->read_track);
1394 err |= __copy_to_user(((struct floppy_drive_params32 *)arg)->autodetect, f->autodetect, sizeof(f->autodetect));
1395 err |= __put_user(f->checkfreq, &((struct floppy_drive_params32 *)arg)->checkfreq);
1396 err |= __put_user(f->native_format, &((struct floppy_drive_params32 *)arg)->native_format);
1397 break;
1398 }
1399 case FDGETDRVSTAT32:
1400 case FDPOLLDRVSTAT32:
1401 {
1402 struct floppy_drive_struct *f = karg;
1403
1404 err = __put_user(f->flags, &((struct floppy_drive_struct32 *)arg)->flags);
1405 err |= __put_user(f->spinup_date, &((struct floppy_drive_struct32 *)arg)->spinup_date);
1406 err |= __put_user(f->select_date, &((struct floppy_drive_struct32 *)arg)->select_date);
1407 err |= __put_user(f->first_read_date, &((struct floppy_drive_struct32 *)arg)->first_read_date);
1408 err |= __put_user(f->probed_format, &((struct floppy_drive_struct32 *)arg)->probed_format);
1409 err |= __put_user(f->track, &((struct floppy_drive_struct32 *)arg)->track);
1410 err |= __put_user(f->maxblock, &((struct floppy_drive_struct32 *)arg)->maxblock);
1411 err |= __put_user(f->maxtrack, &((struct floppy_drive_struct32 *)arg)->maxtrack);
1412 err |= __put_user(f->generation, &((struct floppy_drive_struct32 *)arg)->generation);
1413 err |= __put_user(f->keep_data, &((struct floppy_drive_struct32 *)arg)->keep_data);
1414 err |= __put_user(f->fd_ref, &((struct floppy_drive_struct32 *)arg)->fd_ref);
1415 err |= __put_user(f->fd_device, &((struct floppy_drive_struct32 *)arg)->fd_device);
1416 err |= __put_user(f->last_checked, &((struct floppy_drive_struct32 *)arg)->last_checked);
1417 err |= __put_user((u64)f->dmabuf, &((struct floppy_drive_struct32 *)arg)->dmabuf);
1418 err |= __put_user((u64)f->bufblocks, &((struct floppy_drive_struct32 *)arg)->bufblocks);
1419 break;
1420 }
1421 case FDGETFDCSTAT32:
1422 {
1423 struct floppy_fdc_state *f = karg;
1424
1425 err = __put_user(f->spec1, &((struct floppy_fdc_state32 *)arg)->spec1);
1426 err |= __put_user(f->spec2, &((struct floppy_fdc_state32 *)arg)->spec2);
1427 err |= __put_user(f->dtr, &((struct floppy_fdc_state32 *)arg)->dtr);
1428 err |= __put_user(f->version, &((struct floppy_fdc_state32 *)arg)->version);
1429 err |= __put_user(f->dor, &((struct floppy_fdc_state32 *)arg)->dor);
1430 err |= __put_user(f->address, &((struct floppy_fdc_state32 *)arg)->address);
1431 err |= __copy_to_user((char *)&((struct floppy_fdc_state32 *)arg)->address
1432 + sizeof(((struct floppy_fdc_state32 *)arg)->address),
1433 (char *)&f->address + sizeof(f->address), sizeof(int));
1434 err |= __put_user(f->driver_version, &((struct floppy_fdc_state32 *)arg)->driver_version);
1435 err |= __copy_to_user(((struct floppy_fdc_state32 *)arg)->track, f->track, sizeof(f->track));
1436 break;
1437 }
1438 case FDWERRORGET32:
1439 {
1440 struct floppy_write_errors *f = karg;
1441
1442 err = __put_user(f->write_errors, &((struct floppy_write_errors32 *)arg)->write_errors);
1443 err |= __put_user(f->first_error_sector, &((struct floppy_write_errors32 *)arg)->first_error_sector);
1444 err |= __put_user(f->first_error_generation, &((struct floppy_write_errors32 *)arg)->first_error_generation);
1445 err |= __put_user(f->last_error_sector, &((struct floppy_write_errors32 *)arg)->last_error_sector);
1446 err |= __put_user(f->last_error_generation, &((struct floppy_write_errors32 *)arg)->last_error_generation);
1447 err |= __put_user(f->badness, &((struct floppy_write_errors32 *)arg)->badness);
1448 break;
1449 }
1450 default:
1451 break;
1452 }
1453 if (err)
1454 err = -EFAULT;
1455
1456out: if (karg) kfree(karg);
1457 return err;
1458}
1459
1460typedef struct sg_io_hdr32 {
1461 s32 interface_id;
1462 s32 dxfer_direction;
1463 u8 cmd_len;
1464 u8 mx_sb_len;
1465 u16 iovec_count;
1466 u32 dxfer_len;
1467 u32 dxferp;
1468
1469 u32 cmdp;
1470 u32 sbp;
1471 u32 timeout;
1472 u32 flags;
1473 s32 pack_id;
1474 u32 usr_ptr;
1475 u8 status;
1476 u8 masked_status;
1477 u8 msg_status;
1478 u8 sb_len_wr;
1479 u16 host_status;
1480 u16 driver_status;
1481 s32 resid;
1482 u32 duration;
1483 u32 info;
1484} sg_io_hdr32_t;
1485
1486typedef struct sg_iovec32 {
1487 u32 iov_base;
1488 u32 iov_len;
1489} sg_iovec32_t;
1490
1491static int sg_build_iovec(sg_io_hdr_t *sgio, void *dxferp, u16 iovec_count)
1492{
1493 sg_iovec_t *iov = (sg_iovec_t *) (sgio + 1);
1494 sg_iovec32_t *iov32 = dxferp;
1495 int i;
1496
1497 for (i = 0; i < iovec_count; i++) {
1498 u32 base, len;
1499
1500 if (get_user(base, &iov32[i].iov_base) ||
1501 get_user(len, &iov32[i].iov_len) ||
1502 put_user((void *)(unsigned long)base, &iov[i].iov_base) ||
1503 put_user(len, &iov[i].iov_len))
1504 return -EFAULT;
1505 }
1506
1507 return 0;
1508}
1509
1510static int sg_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1511{
1512 sg_io_hdr_t *sgio;
1513 sg_io_hdr32_t *sgio32;
1514 u16 iovec_count;
1515 u32 data;
1516 void *dxferp;
1517 int err;
1518
1519 sgio32 = (sg_io_hdr32_t *) arg;
1520 if (get_user(iovec_count, &sgio32->iovec_count))
1521 return -EFAULT;
1522
1523 {
1524 void *new, *top;
1525
1526 top = alloc_user_space(0);
1527 new = alloc_user_space(sizeof(sg_io_hdr_t) +
1528 (iovec_count *
1529 sizeof(sg_iovec_t)));
1530 if (new > top)
1531 return -EINVAL;
1532
1533 sgio = new;
1534 }
1535
1536
1537 if (copy_in_user(&sgio->interface_id, &sgio32->interface_id,
1538 (2 * sizeof(int)) +
1539 (2 * sizeof(unsigned char)) +
1540 (1 * sizeof(unsigned short)) +
1541 (1 * sizeof(unsigned int))))
1542 return -EFAULT;
1543
1544 if (get_user(data, &sgio32->dxferp))
1545 return -EFAULT;
1546 dxferp = (void *) (unsigned long) data;
1547 if (iovec_count) {
1548 if (sg_build_iovec(sgio, dxferp, iovec_count))
1549 return -EFAULT;
1550 } else {
1551 if (put_user(dxferp, &sgio->dxferp))
1552 return -EFAULT;
1553 }
1554
1555 {
1556 unsigned char *cmdp, *sbp;
1557
1558 if (get_user(data, &sgio32->cmdp))
1559 return -EFAULT;
1560 cmdp = (unsigned char *) (unsigned long) data;
1561
1562 if (get_user(data, &sgio32->sbp))
1563 return -EFAULT;
1564 sbp = (unsigned char *) (unsigned long) data;
1565
1566 if (put_user(cmdp, &sgio->cmdp) ||
1567 put_user(sbp, &sgio->sbp))
1568 return -EFAULT;
1569 }
1570
1571 if (copy_in_user(&sgio->timeout, &sgio32->timeout,
1572 3 * sizeof(int)))
1573 return -EFAULT;
1574
1575 if (get_user(data, &sgio32->usr_ptr))
1576 return -EFAULT;
1577 if (put_user((void *)(unsigned long)data, &sgio->usr_ptr))
1578 return -EFAULT;
1579
1580 if (copy_in_user(&sgio->status, &sgio32->status,
1581 (4 * sizeof(unsigned char)) +
1582 (2 * sizeof(unsigned (short))) +
1583 (3 * sizeof(int))))
1584 return -EFAULT;
1585
1586 err = sys_ioctl(fd, cmd, (unsigned long) sgio);
1587
1588 if (err >= 0) {
1589 void *datap;
1590
1591 if (copy_in_user(&sgio32->pack_id, &sgio->pack_id,
1592 sizeof(int)) ||
1593 get_user(datap, &sgio->usr_ptr) ||
1594 put_user((u32)(unsigned long)datap,
1595 &sgio32->usr_ptr) ||
1596 copy_in_user(&sgio32->status, &sgio->status,
1597 (4 * sizeof(unsigned char)) +
1598 (2 * sizeof(unsigned short)) +
1599 (3 * sizeof(int))))
1600 err = -EFAULT;
1601 }
1602
1603 return err;
1604}
1605
1606struct sock_fprog32 {
1607 __u16 len;
1608 __u32 filter;
1609};
1610
1611#define PPPIOCSPASS32 _IOW('t', 71, struct sock_fprog32)
1612#define PPPIOCSACTIVE32 _IOW('t', 70, struct sock_fprog32)
1613
1614static int ppp_sock_fprog_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1615{
1616 struct sock_fprog32 *u_fprog32 = (struct sock_fprog32 *) arg;
1617 struct sock_fprog *u_fprog64 = alloc_user_space(sizeof(struct sock_fprog));
1618 void *fptr64;
1619 u32 fptr32;
1620 u16 flen;
1621
1622 if (get_user(flen, &u_fprog32->len) ||
1623 get_user(fptr32, &u_fprog32->filter))
1624 return -EFAULT;
1625
1626 fptr64 = (void *) A(fptr32);
1627
1628 if (put_user(flen, &u_fprog64->len) ||
1629 put_user(fptr64, &u_fprog64->filter))
1630 return -EFAULT;
1631
1632 if (cmd == PPPIOCSPASS32)
1633 cmd = PPPIOCSPASS;
1634 else
1635 cmd = PPPIOCSACTIVE;
1636
1637 return sys_ioctl(fd, cmd, (unsigned long) u_fprog64);
1638}
1639
1640struct ppp_option_data32 {
1641 __kernel_caddr_t32 ptr;
1642 __u32 length;
1643 int transmit;
1644};
1645#define PPPIOCSCOMPRESS32 _IOW('t', 77, struct ppp_option_data32)
1646
1647struct ppp_idle32 {
1648 __kernel_time_t32 xmit_idle;
1649 __kernel_time_t32 recv_idle;
1650};
1651#define PPPIOCGIDLE32 _IOR('t', 63, struct ppp_idle32)
1652
1653static int ppp_gidle(unsigned int fd, unsigned int cmd, unsigned long arg)
1654{
1655 struct ppp_idle *idle;
1656 struct ppp_idle32 *idle32;
1657 __kernel_time_t xmit, recv;
1658 int err;
1659
1660 idle = alloc_user_space(sizeof(*idle));
1661 idle32 = (struct ppp_idle32 *) arg;
1662
1663 err = sys_ioctl(fd, PPPIOCGIDLE, (unsigned long) idle);
1664
1665 if (!err) {
1666 if (get_user(xmit, &idle->xmit_idle) ||
1667 get_user(recv, &idle->recv_idle) ||
1668 put_user(xmit, &idle32->xmit_idle) ||
1669 put_user(recv, &idle32->recv_idle))
1670 err = -EFAULT;
1671 }
1672 return err;
1673}
1674
1675static int ppp_scompress(unsigned int fd, unsigned int cmd, unsigned long arg)
1676{
1677 struct ppp_option_data *odata;
1678 struct ppp_option_data32 *odata32;
1679 __u32 data;
1680 void *datap;
1681
1682 odata = alloc_user_space(sizeof(*odata));
1683 odata32 = (struct ppp_option_data32 *) arg;
1684
1685 if (get_user(data, &odata32->ptr))
1686 return -EFAULT;
1687
1688 datap = (void *) (unsigned long) data;
1689 if (put_user(datap, &odata->ptr))
1690 return -EFAULT;
1691
1692 if (copy_in_user(&odata->length, &odata32->length,
1693 sizeof(__u32) + sizeof(int)))
1694 return -EFAULT;
1695
1696 return sys_ioctl(fd, PPPIOCSCOMPRESS, (unsigned long) odata);
1697}
1698
1699static int ppp_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1700{
1701 int err;
1702
1703 switch (cmd) {
1704 case PPPIOCGIDLE32:
1705 err = ppp_gidle(fd, cmd, arg);
1706 break;
1707
1708 case PPPIOCSCOMPRESS32:
1709 err = ppp_scompress(fd, cmd, arg);
1710 break;
1711
1712 default:
1713 do {
1714 static int count;
1715 if (++count <= 20)
1716 printk("ppp_ioctl: Unknown cmd fd(%d) "
1717 "cmd(%08x) arg(%08x)\n",
1718 (int)fd, (unsigned int)cmd, (unsigned int)arg);
1719 } while(0);
1720 err = -EINVAL;
1721 break;
1722 };
1723
1724 return err;
1725}
1726
1727
1728struct mtget32 {
1729 __u32 mt_type;
1730 __u32 mt_resid;
1731 __u32 mt_dsreg;
1732 __u32 mt_gstat;
1733 __u32 mt_erreg;
1734 __kernel_daddr_t32 mt_fileno;
1735 __kernel_daddr_t32 mt_blkno;
1736};
1737#define MTIOCGET32 _IOR('m', 2, struct mtget32)
1738
1739struct mtpos32 {
1740 __u32 mt_blkno;
1741};
1742#define MTIOCPOS32 _IOR('m', 3, struct mtpos32)
1743
1744struct mtconfiginfo32 {
1745 __u32 mt_type;
1746 __u32 ifc_type;
1747 __u16 irqnr;
1748 __u16 dmanr;
1749 __u16 port;
1750 __u32 debug;
1751 __u32 have_dens:1;
1752 __u32 have_bsf:1;
1753 __u32 have_fsr:1;
1754 __u32 have_bsr:1;
1755 __u32 have_eod:1;
1756 __u32 have_seek:1;
1757 __u32 have_tell:1;
1758 __u32 have_ras1:1;
1759 __u32 have_ras2:1;
1760 __u32 have_ras3:1;
1761 __u32 have_qfa:1;
1762 __u32 pad1:5;
1763 char reserved[10];
1764};
1765#define MTIOCGETCONFIG32 _IOR('m', 4, struct mtconfiginfo32)
1766#define MTIOCSETCONFIG32 _IOW('m', 5, struct mtconfiginfo32)
1767
1768static int mt_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1769{
1770 mm_segment_t old_fs = get_fs();
1771 struct mtconfiginfo info;
1772 struct mtget get;
1773 struct mtpos pos;
1774 unsigned long kcmd;
1775 void *karg;
1776 int err = 0;
1777
1778 switch(cmd) {
1779 case MTIOCPOS32:
1780 kcmd = MTIOCPOS;
1781 karg = &pos;
1782 break;
1783 case MTIOCGET32:
1784 kcmd = MTIOCGET;
1785 karg = &get;
1786 break;
1787 case MTIOCGETCONFIG32:
1788 kcmd = MTIOCGETCONFIG;
1789 karg = &info;
1790 break;
1791 case MTIOCSETCONFIG32:
1792 kcmd = MTIOCSETCONFIG;
1793 karg = &info;
1794 err = __get_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
1795 err |= __get_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
1796 err |= __get_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
1797 err |= __get_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
1798 err |= __get_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
1799 err |= __get_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
1800 err |= __copy_from_user((char *)&info.debug + sizeof(info.debug),
1801 (char *)&((struct mtconfiginfo32 *)arg)->debug
1802 + sizeof(((struct mtconfiginfo32 *)arg)->debug), sizeof(__u32));
1803 if (err)
1804 return -EFAULT;
1805 break;
1806 default:
1807 do {
1808 static int count;
1809 if (++count <= 20)
1810 printk("mt_ioctl: Unknown cmd fd(%d) "
1811 "cmd(%08x) arg(%08x)\n",
1812 (int)fd, (unsigned int)cmd, (unsigned int)arg);
1813 } while(0);
1814 return -EINVAL;
1815 }
1816 set_fs (KERNEL_DS);
1817 err = sys_ioctl (fd, kcmd, (unsigned long)karg);
1818 set_fs (old_fs);
1819 if (err)
1820 return err;
1821 switch (cmd) {
1822 case MTIOCPOS32:
1823 err = __put_user(pos.mt_blkno, &((struct mtpos32 *)arg)->mt_blkno);
1824 break;
1825 case MTIOCGET32:
1826 err = __put_user(get.mt_type, &((struct mtget32 *)arg)->mt_type);
1827 err |= __put_user(get.mt_resid, &((struct mtget32 *)arg)->mt_resid);
1828 err |= __put_user(get.mt_dsreg, &((struct mtget32 *)arg)->mt_dsreg);
1829 err |= __put_user(get.mt_gstat, &((struct mtget32 *)arg)->mt_gstat);
1830 err |= __put_user(get.mt_erreg, &((struct mtget32 *)arg)->mt_erreg);
1831 err |= __put_user(get.mt_fileno, &((struct mtget32 *)arg)->mt_fileno);
1832 err |= __put_user(get.mt_blkno, &((struct mtget32 *)arg)->mt_blkno);
1833 break;
1834 case MTIOCGETCONFIG32:
1835 err = __put_user(info.mt_type, &((struct mtconfiginfo32 *)arg)->mt_type);
1836 err |= __put_user(info.ifc_type, &((struct mtconfiginfo32 *)arg)->ifc_type);
1837 err |= __put_user(info.irqnr, &((struct mtconfiginfo32 *)arg)->irqnr);
1838 err |= __put_user(info.dmanr, &((struct mtconfiginfo32 *)arg)->dmanr);
1839 err |= __put_user(info.port, &((struct mtconfiginfo32 *)arg)->port);
1840 err |= __put_user(info.debug, &((struct mtconfiginfo32 *)arg)->debug);
1841 err |= __copy_to_user((char *)&((struct mtconfiginfo32 *)arg)->debug
1842 + sizeof(((struct mtconfiginfo32 *)arg)->debug),
1843 (char *)&info.debug + sizeof(info.debug), sizeof(__u32));
1844 break;
1845 case MTIOCSETCONFIG32:
1846 break;
1847 }
1848 return err ? -EFAULT: 0;
1849}
1850
1851struct cdrom_read_audio32 {
1852 union cdrom_addr addr;
1853 u_char addr_format;
1854 int nframes;
1855 __kernel_caddr_t32 buf;
1856};
1857
1858struct cdrom_generic_command32 {
1859 unsigned char cmd[CDROM_PACKET_SIZE];
1860 __kernel_caddr_t32 buffer;
1861 unsigned int buflen;
1862 int stat;
1863 __kernel_caddr_t32 sense;
1864 unsigned char data_direction;
1865 int quiet;
1866 int timeout;
1867 __kernel_caddr_t32 reserved[1];
1868};
1869
1870static int cdrom_do_read_audio(unsigned int fd, unsigned int cmd, unsigned long arg)
1871{
1872 struct cdrom_read_audio *cdread_audio;
1873 struct cdrom_read_audio32 *cdread_audio32;
1874 __u32 data;
1875 void *datap;
1876
1877 cdread_audio = alloc_user_space(sizeof(*cdread_audio));
1878 cdread_audio32 = (struct cdrom_read_audio32 *) arg;
1879
1880 if (copy_in_user(&cdread_audio->addr,
1881 &cdread_audio32->addr,
1882 (sizeof(*cdread_audio32) -
1883 sizeof(__kernel_caddr_t32))))
1884 return -EFAULT;
1885
1886 if (get_user(data, &cdread_audio32->buf))
1887 return -EFAULT;
1888 datap = (void *) (unsigned long) data;
1889 if (put_user(datap, &cdread_audio->buf))
1890 return -EFAULT;
1891
1892 return sys_ioctl(fd, cmd, (unsigned long) cdread_audio);
1893}
1894
1895static int __cgc_do_ptr(void **ptr64, __u32 *ptr32)
1896{
1897 u32 data;
1898 void *datap;
1899
1900 if (get_user(data, ptr32))
1901 return -EFAULT;
1902 datap = (void *) (unsigned long) data;
1903 if (put_user(datap, ptr64))
1904 return -EFAULT;
1905
1906 return 0;
1907}
1908
1909static int cdrom_do_generic_command(unsigned int fd, unsigned int cmd, unsigned long arg)
1910{
1911 struct cdrom_generic_command *cgc;
1912 struct cdrom_generic_command32 *cgc32;
1913 unsigned char dir;
1914
1915 cgc = alloc_user_space(sizeof(*cgc));
1916 cgc32 = (struct cdrom_generic_command32 *) arg;
1917
1918 if (copy_in_user(&cgc->cmd, &cgc32->cmd, sizeof(cgc->cmd)) ||
1919 __cgc_do_ptr((void **) &cgc->buffer, &cgc32->buffer) ||
1920 copy_in_user(&cgc->buflen, &cgc32->buflen,
1921 (sizeof(unsigned int) + sizeof(int))) ||
1922 __cgc_do_ptr((void **) &cgc->sense, &cgc32->sense))
1923 return -EFAULT;
1924
1925 if (get_user(dir, &cgc32->data_direction) ||
1926 put_user(dir, &cgc->data_direction))
1927 return -EFAULT;
1928
1929 if (copy_in_user(&cgc->quiet, &cgc32->quiet,
1930 2 * sizeof(int)))
1931 return -EFAULT;
1932
1933 if (__cgc_do_ptr(&cgc->reserved[0], &cgc32->reserved[0]))
1934 return -EFAULT;
1935
1936 return sys_ioctl(fd, cmd, (unsigned long) cgc);
1937}
1938
1939static int cdrom_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
1940{
1941 int err;
1942
1943 switch(cmd) {
1944 case CDROMREADAUDIO:
1945 err = cdrom_do_read_audio(fd, cmd, arg);
1946 break;
1947
1948 case CDROM_SEND_PACKET:
1949 err = cdrom_do_generic_command(fd, cmd, arg);
1950 break;
1951
1952 default:
1953 do {
1954 static int count;
1955 if (++count <= 20)
1956 printk("cdrom_ioctl: Unknown cmd fd(%d) "
1957 "cmd(%08x) arg(%08x)\n",
1958 (int)fd, (unsigned int)cmd, (unsigned int)arg);
1959 } while(0);
1960 err = -EINVAL;
1961 break;
1962 };
1963
1964 return err;
1965}
1966
1967struct loop_info32 {
1968 int lo_number;
1969 __kernel_dev_t32 lo_device;
1970 unsigned int lo_inode;
1971 __kernel_dev_t32 lo_rdevice;
1972 int lo_offset;
1973 int lo_encrypt_type;
1974 int lo_encrypt_key_size;
1975 int lo_flags;
1976 char lo_name[LO_NAME_SIZE];
1977 unsigned char lo_encrypt_key[LO_KEY_SIZE];
1978 unsigned int lo_init[2];
1979 char reserved[4];
1980};
1981
1982static int loop_status(unsigned int fd, unsigned int cmd, unsigned long arg)
1983{
1984 mm_segment_t old_fs = get_fs();
1985 struct loop_info l;
1986 int err = -EINVAL;
1987
1988 switch(cmd) {
1989 case LOOP_SET_STATUS:
1990 err = get_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);
1991 err |= __get_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);
1992 err |= __get_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);
1993 err |= __get_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);
1994 err |= __copy_from_user((char *)&l.lo_offset, (char *)&((struct loop_info32 *)arg)->lo_offset,
1995 8 + (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);
1996 if (err) {
1997 err = -EFAULT;
1998 } else {
1999 set_fs (KERNEL_DS);
2000 err = sys_ioctl (fd, cmd, (unsigned long)&l);
2001 set_fs (old_fs);
2002 }
2003 break;
2004 case LOOP_GET_STATUS:
2005 set_fs (KERNEL_DS);
2006 err = sys_ioctl (fd, cmd, (unsigned long)&l);
2007 set_fs (old_fs);
2008 if (!err) {
2009 err = put_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);
2010 err |= __put_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);
2011 err |= __put_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);
2012 err |= __put_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);
2013 err |= __copy_to_user((char *)&((struct loop_info32 *)arg)->lo_offset,
2014 (char *)&l.lo_offset, (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);
2015 if (err)
2016 err = -EFAULT;
2017 }
2018 break;
2019 default: {
2020 static int count;
2021 if (++count <= 20)
2022 printk("%s: Unknown loop ioctl cmd, fd(%d) "
2023 "cmd(%08x) arg(%08lx)\n",
2024 __FUNCTION__, fd, cmd, arg);
2025 }
2026 }
2027 return err;
2028}
2029
2030extern int tty_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg);
2031
2032static int vt_check(struct file *file)
2033{
2034 struct tty_struct *tty;
2035 struct inode *inode = file->f_dentry->d_inode;
2036
2037 if (file->f_op->ioctl != tty_ioctl)
2038 return -EINVAL;
2039
2040 tty = (struct tty_struct *)file->private_data;
2041 if (tty_paranoia_check(tty, inode->i_rdev, "tty_ioctl"))
2042 return -EINVAL;
2043
2044 if (tty->driver.ioctl != vt_ioctl)
2045 return -EINVAL;
2046
2047
2048
2049
2050
2051 if (current->tty == tty || suser())
2052 return 1;
2053 return 0;
2054}
2055
2056struct consolefontdesc32 {
2057 unsigned short charcount;
2058 unsigned short charheight;
2059 u32 chardata;
2060};
2061
2062static int do_fontx_ioctl(unsigned int fd, int cmd, struct consolefontdesc32 *user_cfd, struct file *file)
2063{
2064 struct consolefontdesc cfdarg;
2065 struct console_font_op op;
2066 int i, perm;
2067
2068 perm = vt_check(file);
2069 if (perm < 0) return perm;
2070
2071 if (copy_from_user(&cfdarg, user_cfd, sizeof(struct consolefontdesc32)))
2072 return -EFAULT;
2073
2074 cfdarg.chardata = (unsigned char *)A(((struct consolefontdesc32 *)&cfdarg)->chardata);
2075
2076 switch (cmd) {
2077 case PIO_FONTX:
2078 if (!perm)
2079 return -EPERM;
2080 op.op = KD_FONT_OP_SET;
2081 op.flags = 0;
2082 op.width = 8;
2083 op.height = cfdarg.charheight;
2084 op.charcount = cfdarg.charcount;
2085 op.data = cfdarg.chardata;
2086 return con_font_op(fg_console, &op);
2087 case GIO_FONTX:
2088 if (!cfdarg.chardata)
2089 return 0;
2090 op.op = KD_FONT_OP_GET;
2091 op.flags = 0;
2092 op.width = 8;
2093 op.height = cfdarg.charheight;
2094 op.charcount = cfdarg.charcount;
2095 op.data = cfdarg.chardata;
2096 i = con_font_op(fg_console, &op);
2097 if (i)
2098 return i;
2099 cfdarg.charheight = op.height;
2100 cfdarg.charcount = op.charcount;
2101 ((struct consolefontdesc32 *)&cfdarg)->chardata = (unsigned long)cfdarg.chardata;
2102 if (copy_to_user(user_cfd, &cfdarg, sizeof(struct consolefontdesc32)))
2103 return -EFAULT;
2104 return 0;
2105 }
2106 return -EINVAL;
2107}
2108
2109struct console_font_op32 {
2110 unsigned int op;
2111 unsigned int flags;
2112 unsigned int width, height;
2113 unsigned int charcount;
2114 u32 data;
2115};
2116
2117static int do_kdfontop_ioctl(unsigned int fd, unsigned int cmd, struct console_font_op32 *fontop, struct file *file)
2118{
2119 struct console_font_op op;
2120 int perm = vt_check(file), i;
2121 struct vt_struct *vt;
2122
2123 if (perm < 0) return perm;
2124
2125 if (copy_from_user(&op, (void *) fontop, sizeof(struct console_font_op32)))
2126 return -EFAULT;
2127 if (!perm && op.op != KD_FONT_OP_GET)
2128 return -EPERM;
2129 op.data = (unsigned char *)A(((struct console_font_op32 *)&op)->data);
2130 op.flags |= KD_FONT_FLAG_OLD;
2131 vt = (struct vt_struct *)((struct tty_struct *)file->private_data)->driver_data;
2132 i = con_font_op(vt->vc_num, &op);
2133 if (i) return i;
2134 ((struct console_font_op32 *)&op)->data = (unsigned long)op.data;
2135 if (copy_to_user((void *) fontop, &op, sizeof(struct console_font_op32)))
2136 return -EFAULT;
2137 return 0;
2138}
2139
2140struct unimapdesc32 {
2141 unsigned short entry_ct;
2142 u32 entries;
2143};
2144
2145static int do_unimap_ioctl(unsigned int fd, unsigned int cmd, struct unimapdesc32 *user_ud, struct file *file)
2146{
2147 struct unimapdesc32 tmp;
2148 int perm = vt_check(file);
2149
2150 if (perm < 0) return perm;
2151 if (copy_from_user(&tmp, user_ud, sizeof tmp))
2152 return -EFAULT;
2153 switch (cmd) {
2154 case PIO_UNIMAP:
2155 if (!perm) return -EPERM;
2156 return con_set_unimap(fg_console, tmp.entry_ct, (struct unipair *)A(tmp.entries));
2157 case GIO_UNIMAP:
2158 return con_get_unimap(fg_console, tmp.entry_ct, &(user_ud->entry_ct), (struct unipair *)A(tmp.entries));
2159 }
2160 return 0;
2161}
2162
2163static int do_smb_getmountuid(unsigned int fd, unsigned int cmd, unsigned long arg)
2164{
2165 mm_segment_t old_fs = get_fs();
2166 __kernel_uid_t kuid;
2167 int err;
2168
2169 cmd = SMB_IOC_GETMOUNTUID;
2170
2171 set_fs(KERNEL_DS);
2172 err = sys_ioctl(fd, cmd, (unsigned long)&kuid);
2173 set_fs(old_fs);
2174
2175 if (err >= 0)
2176 err = put_user(kuid, (__kernel_uid_t32 *)arg);
2177
2178 return err;
2179}
2180
2181struct ncp_ioctl_request_32 {
2182 unsigned int function;
2183 unsigned int size;
2184 __kernel_caddr_t32 data;
2185};
2186
2187struct ncp_fs_info_v2_32 {
2188 int version;
2189 unsigned int mounted_uid;
2190 unsigned int connection;
2191 unsigned int buffer_size;
2192
2193 unsigned int volume_number;
2194 __u32 directory_id;
2195
2196 __u32 dummy1;
2197 __u32 dummy2;
2198 __u32 dummy3;
2199};
2200
2201struct ncp_objectname_ioctl_32
2202{
2203 int auth_type;
2204 unsigned int object_name_len;
2205 __kernel_caddr_t32 object_name;
2206};
2207
2208struct ncp_privatedata_ioctl_32
2209{
2210 unsigned int len;
2211 __kernel_caddr_t32 data;
2212};
2213
2214#define NCP_IOC_NCPREQUEST_32 _IOR('n', 1, struct ncp_ioctl_request_32)
2215
2216#define NCP_IOC_GETMOUNTUID2_32 _IOW('n', 2, unsigned int)
2217
2218#define NCP_IOC_GET_FS_INFO_V2_32 _IOWR('n', 4, struct ncp_fs_info_v2_32)
2219
2220#define NCP_IOC_GETOBJECTNAME_32 _IOWR('n', 9, struct ncp_objectname_ioctl_32)
2221#define NCP_IOC_SETOBJECTNAME_32 _IOR('n', 9, struct ncp_objectname_ioctl_32)
2222#define NCP_IOC_GETPRIVATEDATA_32 _IOWR('n', 10, struct ncp_privatedata_ioctl_32)
2223#define NCP_IOC_SETPRIVATEDATA_32 _IOR('n', 10, struct ncp_privatedata_ioctl_32)
2224
2225static int do_ncp_ncprequest(unsigned int fd, unsigned int cmd, unsigned long arg)
2226{
2227 struct ncp_ioctl_request_32 n32;
2228 struct ncp_ioctl_request n;
2229 mm_segment_t old_fs;
2230 int err;
2231
2232 if (copy_from_user(&n32, (struct ncp_ioctl_request_32*)arg,
2233 sizeof(n32)))
2234 return -EFAULT;
2235
2236 n.function = n32.function;
2237 n.size = n32.size;
2238 if (n.size > 65536)
2239 return -EINVAL;
2240 n.data = vmalloc(65536);
2241 if (!n.data)
2242 return -ENOMEM;
2243 err = -EFAULT;
2244 if (copy_from_user(n.data, A(n32.data), n.size))
2245 goto out;
2246
2247 old_fs = get_fs(); set_fs (KERNEL_DS);
2248 err = sys_ioctl (fd, NCP_IOC_NCPREQUEST, (unsigned long)&n);
2249 set_fs (old_fs);
2250 if(err <= 0)
2251 goto out;
2252 if (err > 65536) {
2253 err = -EINVAL;
2254 goto out;
2255 }
2256 if (copy_to_user(A(n32.data), n.data, err)) {
2257 err = -EFAULT;
2258 goto out;
2259 }
2260 out:
2261 vfree(n.data);
2262 return err;
2263}
2264
2265static int do_ncp_getmountuid2(unsigned int fd, unsigned int cmd, unsigned long arg)
2266{
2267 mm_segment_t old_fs = get_fs();
2268 __kernel_uid_t kuid;
2269 int err;
2270
2271 cmd = NCP_IOC_GETMOUNTUID2;
2272
2273 set_fs(KERNEL_DS);
2274 err = sys_ioctl(fd, cmd, (unsigned long)&kuid);
2275 set_fs(old_fs);
2276
2277 if (!err)
2278 err = put_user(kuid, (unsigned int*)arg);
2279
2280 return err;
2281}
2282
2283static int do_ncp_getfsinfo2(unsigned int fd, unsigned int cmd, unsigned long arg)
2284{
2285 mm_segment_t old_fs = get_fs();
2286 struct ncp_fs_info_v2_32 n32;
2287 struct ncp_fs_info_v2 n;
2288 int err;
2289
2290 if (copy_from_user(&n32, (struct ncp_fs_info_v2_32*)arg, sizeof(n32)))
2291 return -EFAULT;
2292 if (n32.version != NCP_GET_FS_INFO_VERSION_V2)
2293 return -EINVAL;
2294 n.version = NCP_GET_FS_INFO_VERSION_V2;
2295
2296 set_fs(KERNEL_DS);
2297 err = sys_ioctl(fd, NCP_IOC_GET_FS_INFO_V2, (unsigned long)&n);
2298 set_fs(old_fs);
2299
2300 if (!err) {
2301 n32.version = n.version;
2302 n32.mounted_uid = n.mounted_uid;
2303 n32.connection = n.connection;
2304 n32.buffer_size = n.buffer_size;
2305 n32.volume_number = n.volume_number;
2306 n32.directory_id = n.directory_id;
2307 n32.dummy1 = n.dummy1;
2308 n32.dummy2 = n.dummy2;
2309 n32.dummy3 = n.dummy3;
2310 err = copy_to_user((struct ncp_fs_info_v2_32*)arg, &n32, sizeof(n32)) ? -EFAULT : 0;
2311 }
2312 return err;
2313}
2314
2315static int do_ncp_getobjectname(unsigned int fd, unsigned int cmd, unsigned long arg)
2316{
2317 struct ncp_objectname_ioctl_32 n32;
2318 struct ncp_objectname_ioctl n;
2319 mm_segment_t old_fs;
2320 int err;
2321 size_t tl;
2322
2323 if (copy_from_user(&n32, (struct ncp_objectname_ioctl_32*)arg,
2324 sizeof(n32)))
2325 return -EFAULT;
2326
2327 n.object_name_len = tl = n32.object_name_len;
2328 if (tl) {
2329 n.object_name = kmalloc(tl, GFP_KERNEL);
2330 if (!n.object_name)
2331 return -ENOMEM;
2332 } else {
2333 n.object_name = NULL;
2334 }
2335
2336 old_fs = get_fs(); set_fs (KERNEL_DS);
2337 err = sys_ioctl (fd, NCP_IOC_GETOBJECTNAME, (unsigned long)&n);
2338 set_fs (old_fs);
2339 if(err)
2340 goto out;
2341
2342 if (tl > n.object_name_len)
2343 tl = n.object_name_len;
2344
2345 err = -EFAULT;
2346 if (tl && copy_to_user(A(n32.object_name), n.object_name, tl))
2347 goto out;
2348
2349 n32.auth_type = n.auth_type;
2350 n32.object_name_len = n.object_name_len;
2351
2352 if (copy_to_user((struct ncp_objectname_ioctl_32*)arg, &n32, sizeof(n32)))
2353 goto out;
2354
2355 err = 0;
2356 out:
2357 if (n.object_name)
2358 kfree(n.object_name);
2359
2360 return err;
2361}
2362
2363static int do_ncp_setobjectname(unsigned int fd, unsigned int cmd, unsigned long arg)
2364{
2365 struct ncp_objectname_ioctl_32 n32;
2366 struct ncp_objectname_ioctl n;
2367 mm_segment_t old_fs;
2368 int err;
2369 size_t tl;
2370
2371 if (copy_from_user(&n32, (struct ncp_objectname_ioctl_32*)arg,
2372 sizeof(n32)))
2373 return -EFAULT;
2374
2375 n.auth_type = n32.auth_type;
2376 n.object_name_len = tl = n32.object_name_len;
2377 if (tl) {
2378 n.object_name = kmalloc(tl, GFP_KERNEL);
2379 if (!n.object_name)
2380 return -ENOMEM;
2381 err = -EFAULT;
2382 if (copy_from_user(n.object_name, A(n32.object_name), tl))
2383 goto out;
2384 } else {
2385 n.object_name = NULL;
2386 }
2387
2388 old_fs = get_fs(); set_fs (KERNEL_DS);
2389 err = sys_ioctl (fd, NCP_IOC_SETOBJECTNAME, (unsigned long)&n);
2390 set_fs (old_fs);
2391
2392 out:
2393 if (n.object_name)
2394 kfree(n.object_name);
2395
2396 return err;
2397}
2398
2399static int do_ncp_getprivatedata(unsigned int fd, unsigned int cmd, unsigned long arg)
2400{
2401 struct ncp_privatedata_ioctl_32 n32;
2402 struct ncp_privatedata_ioctl n;
2403 mm_segment_t old_fs;
2404 int err;
2405 size_t tl;
2406
2407 if (copy_from_user(&n32, (struct ncp_privatedata_ioctl_32*)arg,
2408 sizeof(n32)))
2409 return -EFAULT;
2410
2411 n.len = tl = n32.len;
2412 if (tl) {
2413 n.data = kmalloc(tl, GFP_KERNEL);
2414 if (!n.data)
2415 return -ENOMEM;
2416 } else {
2417 n.data = NULL;
2418 }
2419
2420 old_fs = get_fs(); set_fs (KERNEL_DS);
2421 err = sys_ioctl (fd, NCP_IOC_GETPRIVATEDATA, (unsigned long)&n);
2422 set_fs (old_fs);
2423 if(err)
2424 goto out;
2425
2426 if (tl > n.len)
2427 tl = n.len;
2428
2429 err = -EFAULT;
2430 if (tl && copy_to_user(A(n32.data), n.data, tl))
2431 goto out;
2432
2433 n32.len = n.len;
2434
2435 if (copy_to_user((struct ncp_privatedata_ioctl_32*)arg, &n32, sizeof(n32)))
2436 goto out;
2437
2438 err = 0;
2439 out:
2440 if (n.data)
2441 kfree(n.data);
2442
2443 return err;
2444}
2445
2446static int do_ncp_setprivatedata(unsigned int fd, unsigned int cmd, unsigned long arg)
2447{
2448 struct ncp_privatedata_ioctl_32 n32;
2449 struct ncp_privatedata_ioctl n;
2450 mm_segment_t old_fs;
2451 int err;
2452 size_t tl;
2453
2454 if (copy_from_user(&n32, (struct ncp_privatedata_ioctl_32*)arg,
2455 sizeof(n32)))
2456 return -EFAULT;
2457
2458 n.len = tl = n32.len;
2459 if (tl) {
2460 n.data = kmalloc(tl, GFP_KERNEL);
2461 if (!n.data)
2462 return -ENOMEM;
2463 err = -EFAULT;
2464 if (copy_from_user(n.data, A(n32.data), tl))
2465 goto out;
2466 } else {
2467 n.data = NULL;
2468 }
2469
2470 old_fs = get_fs(); set_fs (KERNEL_DS);
2471 err = sys_ioctl (fd, NCP_IOC_SETPRIVATEDATA, (unsigned long)&n);
2472 set_fs (old_fs);
2473
2474 out:
2475 if (n.data)
2476 kfree(n.data);
2477
2478 return err;
2479}
2480
2481
2482struct atmif_sioc32 {
2483 int number;
2484 int length;
2485 __kernel_caddr_t32 arg;
2486};
2487
2488struct atm_iobuf32 {
2489 int length;
2490 __kernel_caddr_t32 buffer;
2491};
2492
2493#define ATM_GETLINKRATE32 _IOW('a', ATMIOC_ITF+1, struct atmif_sioc32)
2494#define ATM_GETNAMES32 _IOW('a', ATMIOC_ITF+3, struct atm_iobuf32)
2495#define ATM_GETTYPE32 _IOW('a', ATMIOC_ITF+4, struct atmif_sioc32)
2496#define ATM_GETESI32 _IOW('a', ATMIOC_ITF+5, struct atmif_sioc32)
2497#define ATM_GETADDR32 _IOW('a', ATMIOC_ITF+6, struct atmif_sioc32)
2498#define ATM_RSTADDR32 _IOW('a', ATMIOC_ITF+7, struct atmif_sioc32)
2499#define ATM_ADDADDR32 _IOW('a', ATMIOC_ITF+8, struct atmif_sioc32)
2500#define ATM_DELADDR32 _IOW('a', ATMIOC_ITF+9, struct atmif_sioc32)
2501#define ATM_GETCIRANGE32 _IOW('a', ATMIOC_ITF+10, struct atmif_sioc32)
2502#define ATM_SETCIRANGE32 _IOW('a', ATMIOC_ITF+11, struct atmif_sioc32)
2503#define ATM_SETESI32 _IOW('a', ATMIOC_ITF+12, struct atmif_sioc32)
2504#define ATM_SETESIF32 _IOW('a', ATMIOC_ITF+13, struct atmif_sioc32)
2505#define ATM_GETSTAT32 _IOW('a', ATMIOC_SARCOM+0, struct atmif_sioc32)
2506#define ATM_GETSTATZ32 _IOW('a', ATMIOC_SARCOM+1, struct atmif_sioc32)
2507#define ATM_GETLOOP32 _IOW('a', ATMIOC_SARCOM+2, struct atmif_sioc32)
2508#define ATM_SETLOOP32 _IOW('a', ATMIOC_SARCOM+3, struct atmif_sioc32)
2509#define ATM_QUERYLOOP32 _IOW('a', ATMIOC_SARCOM+4, struct atmif_sioc32)
2510
2511static struct {
2512 unsigned int cmd32;
2513 unsigned int cmd;
2514} atm_ioctl_map[] = {
2515 { ATM_GETLINKRATE32, ATM_GETLINKRATE },
2516 { ATM_GETNAMES32, ATM_GETNAMES },
2517 { ATM_GETTYPE32, ATM_GETTYPE },
2518 { ATM_GETESI32, ATM_GETESI },
2519 { ATM_GETADDR32, ATM_GETADDR },
2520 { ATM_RSTADDR32, ATM_RSTADDR },
2521 { ATM_ADDADDR32, ATM_ADDADDR },
2522 { ATM_DELADDR32, ATM_DELADDR },
2523 { ATM_GETCIRANGE32, ATM_GETCIRANGE },
2524 { ATM_SETCIRANGE32, ATM_SETCIRANGE },
2525 { ATM_SETESI32, ATM_SETESI },
2526 { ATM_SETESIF32, ATM_SETESIF },
2527 { ATM_GETSTAT32, ATM_GETSTAT },
2528 { ATM_GETSTATZ32, ATM_GETSTATZ },
2529 { ATM_GETLOOP32, ATM_GETLOOP },
2530 { ATM_SETLOOP32, ATM_SETLOOP },
2531 { ATM_QUERYLOOP32, ATM_QUERYLOOP }
2532};
2533
2534#define NR_ATM_IOCTL (sizeof(atm_ioctl_map)/sizeof(atm_ioctl_map[0]))
2535
2536
2537static int do_atm_iobuf(unsigned int fd, unsigned int cmd, unsigned long arg)
2538{
2539 struct atm_iobuf *iobuf;
2540 struct atm_iobuf32 *iobuf32;
2541 u32 data;
2542 void *datap;
2543 int len, err;
2544
2545 iobuf = alloc_user_space(sizeof(*iobuf));
2546 iobuf32 = (struct atm_iobuf32 *) arg;
2547
2548 if (get_user(len, &iobuf32->length) ||
2549 get_user(data, &iobuf32->buffer))
2550 return -EFAULT;
2551 datap = (void *) (unsigned long) data;
2552 if (put_user(len, &iobuf->length) ||
2553 put_user(datap, &iobuf->buffer))
2554 return -EFAULT;
2555
2556 err = sys_ioctl(fd, cmd, (unsigned long)iobuf);
2557
2558 if (!err) {
2559 if (copy_in_user(&iobuf32->length, &iobuf->length,
2560 sizeof(int)))
2561 err = -EFAULT;
2562 }
2563
2564 return err;
2565}
2566
2567
2568static int do_atmif_sioc(unsigned int fd, unsigned int cmd, unsigned long arg)
2569{
2570 struct atmif_sioc *sioc;
2571 struct atmif_sioc32 *sioc32;
2572 u32 data;
2573 void *datap;
2574 int err;
2575
2576 sioc = alloc_user_space(sizeof(*sioc));
2577 sioc32 = (struct atmif_sioc32 *) arg;
2578
2579 if (copy_in_user(&sioc->number, &sioc32->number, 2 * sizeof(int)) ||
2580 get_user(data, &sioc32->arg))
2581 return -EFAULT;
2582 datap = (void *) (unsigned long) data;
2583 if (put_user(datap, &sioc->arg))
2584 return -EFAULT;
2585
2586 err = sys_ioctl(fd, cmd, (unsigned long) sioc);
2587
2588 if (!err) {
2589 if (copy_in_user(&sioc32->length, &sioc->length,
2590 sizeof(int)))
2591 err = -EFAULT;
2592 }
2593 return err;
2594}
2595
2596
2597static int do_atm_ioctl(unsigned int fd, unsigned int cmd32, unsigned long arg)
2598{
2599 int i;
2600 unsigned int cmd = 0;
2601
2602 switch (cmd32) {
2603 case SONET_GETSTAT:
2604 case SONET_GETSTATZ:
2605 case SONET_GETDIAG:
2606 case SONET_SETDIAG:
2607 case SONET_CLRDIAG:
2608 case SONET_SETFRAMING:
2609 case SONET_GETFRAMING:
2610 case SONET_GETFRSENSE:
2611 return do_atmif_sioc(fd, cmd32, arg);
2612 }
2613
2614 for (i = 0; i < NR_ATM_IOCTL; i++) {
2615 if (cmd32 == atm_ioctl_map[i].cmd32) {
2616 cmd = atm_ioctl_map[i].cmd;
2617 break;
2618 }
2619 }
2620 if (i == NR_ATM_IOCTL)
2621 return -EINVAL;
2622
2623 switch (cmd) {
2624 case ATM_GETNAMES:
2625 return do_atm_iobuf(fd, cmd, arg);
2626
2627 case ATM_GETLINKRATE:
2628 case ATM_GETTYPE:
2629 case ATM_GETESI:
2630 case ATM_GETADDR:
2631 case ATM_RSTADDR:
2632 case ATM_ADDADDR:
2633 case ATM_DELADDR:
2634 case ATM_GETCIRANGE:
2635 case ATM_SETCIRANGE:
2636 case ATM_SETESI:
2637 case ATM_SETESIF:
2638 case ATM_GETSTAT:
2639 case ATM_GETSTATZ:
2640 case ATM_GETLOOP:
2641 case ATM_SETLOOP:
2642 case ATM_QUERYLOOP:
2643 return do_atmif_sioc(fd, cmd, arg);
2644 }
2645
2646 return -EINVAL;
2647}
2648
2649#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
2650
2651typedef struct {
2652 uint8_t vg_name[NAME_LEN];
2653 uint32_t vg_number;
2654 uint32_t vg_access;
2655 uint32_t vg_status;
2656 uint32_t lv_max;
2657 uint32_t lv_cur;
2658 uint32_t lv_open;
2659 uint32_t pv_max;
2660 uint32_t pv_cur;
2661 uint32_t pv_act;
2662 uint32_t dummy;
2663 uint32_t vgda;
2664 uint32_t pe_size;
2665 uint32_t pe_total;
2666 uint32_t pe_allocated;
2667 uint32_t pvg_total;
2668 u32 proc;
2669 u32 pv[ABS_MAX_PV + 1];
2670 u32 lv[ABS_MAX_LV + 1];
2671 uint8_t vg_uuid[UUID_LEN+1];
2672 uint8_t dummy1[200];
2673} vg32_t;
2674
2675typedef struct {
2676 uint8_t id[2];
2677 uint16_t version;
2678 lvm_disk_data_t pv_on_disk;
2679 lvm_disk_data_t vg_on_disk;
2680 lvm_disk_data_t pv_namelist_on_disk;
2681 lvm_disk_data_t lv_on_disk;
2682 lvm_disk_data_t pe_on_disk;
2683 uint8_t pv_name[NAME_LEN];
2684 uint8_t vg_name[NAME_LEN];
2685 uint8_t system_id[NAME_LEN];
2686 kdev_t pv_dev;
2687 uint32_t pv_number;
2688 uint32_t pv_status;
2689 uint32_t pv_allocatable;
2690 uint32_t pv_size;
2691 uint32_t lv_cur;
2692 uint32_t pe_size;
2693 uint32_t pe_total;
2694 uint32_t pe_allocated;
2695 uint32_t pe_stale;
2696 u32 pe;
2697 u32 inode;
2698 uint8_t pv_uuid[UUID_LEN+1];
2699} pv32_t;
2700
2701typedef struct {
2702 char lv_name[NAME_LEN];
2703 u32 lv;
2704} lv_req32_t;
2705
2706typedef struct {
2707 u32 lv_index;
2708 u32 lv;
2709
2710 uint16_t size;
2711} lv_status_byindex_req32_t;
2712
2713typedef struct {
2714 __kernel_dev_t32 dev;
2715 u32 lv;
2716} lv_status_bydev_req32_t;
2717
2718typedef struct {
2719 uint8_t lv_name[NAME_LEN];
2720 kdev_t old_dev;
2721 kdev_t new_dev;
2722 u32 old_pe;
2723 u32 new_pe;
2724} le_remap_req32_t;
2725
2726typedef struct {
2727 char pv_name[NAME_LEN];
2728 u32 pv;
2729} pv_status_req32_t;
2730
2731typedef struct {
2732 uint8_t lv_name[NAME_LEN];
2733 uint8_t vg_name[NAME_LEN];
2734 uint32_t lv_access;
2735 uint32_t lv_status;
2736 uint32_t lv_open;
2737 kdev_t lv_dev;
2738 uint32_t lv_number;
2739 uint32_t lv_mirror_copies;
2740 uint32_t lv_recovery;
2741 uint32_t lv_schedule;
2742 uint32_t lv_size;
2743 u32 lv_current_pe;
2744 uint32_t lv_current_le;
2745 uint32_t lv_allocated_le;
2746 uint32_t lv_stripes;
2747 uint32_t lv_stripesize;
2748 uint32_t lv_badblock;
2749 uint32_t lv_allocation;
2750 uint32_t lv_io_timeout;
2751 uint32_t lv_read_ahead;
2752
2753 u32 lv_snapshot_org;
2754 u32 lv_snapshot_prev;
2755 u32 lv_snapshot_next;
2756 u32 lv_block_exception;
2757 uint32_t lv_remap_ptr;
2758 uint32_t lv_remap_end;
2759 uint32_t lv_chunk_size;
2760 uint32_t lv_snapshot_minor;
2761 char dummy[200];
2762} lv32_t;
2763
2764typedef struct {
2765 u32 hash[2];
2766 u32 rsector_org;
2767 kdev_t rdev_org;
2768 u32 rsector_new;
2769 kdev_t rdev_new;
2770} lv_block_exception32_t;
2771
2772static void put_lv_t(lv_t *l)
2773{
2774 if (l->lv_current_pe) vfree(l->lv_current_pe);
2775 if (l->lv_block_exception) vfree(l->lv_block_exception);
2776 kfree(l);
2777}
2778
2779static lv_t *get_lv_t(u32 p, int *errp)
2780{
2781 int err, i;
2782 u32 ptr1, ptr2;
2783 size_t size;
2784 lv_block_exception32_t *lbe32;
2785 lv_block_exception_t *lbe;
2786 lv32_t *ul = (lv32_t *)A(p);
2787 lv_t *l = (lv_t *) kmalloc(sizeof(lv_t), GFP_KERNEL);
2788
2789 if (!l) {
2790 *errp = -ENOMEM;
2791 return NULL;
2792 }
2793 memset(l, 0, sizeof(lv_t));
2794 err = copy_from_user(l, ul, (long)&((lv32_t *)0)->lv_current_pe);
2795 err |= __copy_from_user(&l->lv_current_le, &ul->lv_current_le,
2796 ((long)&ul->lv_snapshot_org) - ((long)&ul->lv_current_le));
2797 err |= __copy_from_user(&l->lv_remap_ptr, &ul->lv_remap_ptr,
2798 ((long)&ul->dummy[0]) - ((long)&ul->lv_remap_ptr));
2799 err |= __get_user(ptr1, &ul->lv_current_pe);
2800 err |= __get_user(ptr2, &ul->lv_block_exception);
2801 if (err) {
2802 kfree(l);
2803 *errp = -EFAULT;
2804 return NULL;
2805 }
2806 if (ptr1) {
2807 size = l->lv_allocated_le * sizeof(pe_t);
2808 l->lv_current_pe = vmalloc(size);
2809 if (l->lv_current_pe)
2810 err = copy_from_user(l->lv_current_pe, (void *)A(ptr1), size);
2811 }
2812 if (!err && ptr2) {
2813 size = l->lv_remap_end * sizeof(lv_block_exception_t);
2814 l->lv_block_exception = lbe = vmalloc(size);
2815 if (l->lv_block_exception) {
2816 lbe32 = (lv_block_exception32_t *)A(ptr2);
2817 memset(lbe, 0, size);
2818 for (i = 0; i < l->lv_remap_end; i++, lbe++, lbe32++) {
2819 err |= get_user(lbe->rsector_org, &lbe32->rsector_org);
2820 err |= __get_user(lbe->rdev_org, &lbe32->rdev_org);
2821 err |= __get_user(lbe->rsector_new, &lbe32->rsector_new);
2822 err |= __get_user(lbe->rdev_new, &lbe32->rdev_new);
2823 }
2824 }
2825 }
2826 if (err || (ptr1 && !l->lv_current_pe) || (ptr2 && !l->lv_block_exception)) {
2827 if (!err)
2828 *errp = -ENOMEM;
2829 else
2830 *errp = -EFAULT;
2831 put_lv_t(l);
2832 return NULL;
2833 }
2834 return l;
2835}
2836
2837static int copy_lv_t(u32 ptr, lv_t *l)
2838{
2839 int err;
2840 lv32_t *ul = (lv32_t *)A(ptr);
2841 u32 ptr1;
2842 size_t size;
2843
2844 err = get_user(ptr1, &ul->lv_current_pe);
2845 if (err)
2846 return -EFAULT;
2847 err = copy_to_user(ul, l, (long)&((lv32_t *)0)->lv_current_pe);
2848 err |= __copy_to_user(&ul->lv_current_le, &l->lv_current_le,
2849 ((long)&ul->lv_snapshot_org) - ((long)&ul->lv_current_le));
2850 err |= __copy_to_user(&ul->lv_remap_ptr, &l->lv_remap_ptr,
2851 ((long)&ul->dummy[0]) - ((long)&ul->lv_remap_ptr));
2852 size = l->lv_allocated_le * sizeof(pe_t);
2853 if (ptr1)
2854 err |= __copy_to_user((void *)A(ptr1), l->lv_current_pe, size);
2855 return err ? -EFAULT : 0;
2856}
2857
2858static int do_lvm_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
2859{
2860 vg_t *v = NULL;
2861 union {
2862 lv_req_t lv_req;
2863 le_remap_req_t le_remap;
2864 lv_status_byindex_req_t lv_byindex;
2865 lv_status_bydev_req_t lv_bydev;
2866 pv_status_req_t pv_status;
2867 } u;
2868 pv_t p;
2869 int err;
2870 u32 ptr = 0;
2871 int i;
2872 mm_segment_t old_fs;
2873 void *karg = &u;
2874
2875 switch (cmd) {
2876 case VG_STATUS:
2877 v = kmalloc(sizeof(vg_t), GFP_KERNEL);
2878 if (!v)
2879 return -ENOMEM;
2880 karg = v;
2881 break;
2882
2883 case VG_CREATE_OLD:
2884 case VG_CREATE:
2885 v = kmalloc(sizeof(vg_t), GFP_KERNEL);
2886 if (!v)
2887 return -ENOMEM;
2888 if (copy_from_user(v, (void *)arg, (long)&((vg32_t *)0)->proc)) {
2889 kfree(v);
2890 return -EFAULT;
2891 }
2892
2893 v->proc = NULL;
2894 if (copy_from_user(v->vg_uuid, ((vg32_t *)arg)->vg_uuid, UUID_LEN+1)) {
2895 kfree(v);
2896 return -EFAULT;
2897 }
2898
2899 karg = v;
2900 memset(v->pv, 0, sizeof(v->pv) + sizeof(v->lv));
2901 if (v->pv_max > ABS_MAX_PV || v->lv_max > ABS_MAX_LV)
2902 return -EPERM;
2903 for (i = 0; i < v->pv_max; i++) {
2904 err = __get_user(ptr, &((vg32_t *)arg)->pv[i]);
2905 if (err)
2906 break;
2907 if (ptr) {
2908 v->pv[i] = kmalloc(sizeof(pv_t), GFP_KERNEL);
2909 if (!v->pv[i]) {
2910 err = -ENOMEM;
2911 break;
2912 }
2913 err = copy_from_user(v->pv[i], (void *)A(ptr),
2914 sizeof(pv32_t) - 8 - UUID_LEN+1);
2915 if (err) {
2916 err = -EFAULT;
2917 break;
2918 }
2919 err = copy_from_user(v->pv[i]->pv_uuid,
2920 ((pv32_t *)A(ptr))->pv_uuid,
2921 UUID_LEN+1);
2922 if (err) {
2923 err = -EFAULT;
2924 break;
2925 }
2926
2927 v->pv[i]->pe = NULL;
2928 v->pv[i]->bd = NULL;
2929 }
2930 }
2931 if (!err) {
2932 for (i = 0; i < v->lv_max; i++) {
2933 err = __get_user(ptr, &((vg32_t *)arg)->lv[i]);
2934 if (err)
2935 break;
2936 if (ptr) {
2937 v->lv[i] = get_lv_t(ptr, &err);
2938 if (err)
2939 break;
2940 }
2941 }
2942 }
2943 break;
2944
2945 case LV_CREATE:
2946 case LV_EXTEND:
2947 case LV_REDUCE:
2948 case LV_REMOVE:
2949 case LV_RENAME:
2950 case LV_STATUS_BYNAME:
2951 err = copy_from_user(&u.lv_req, arg, sizeof(u.lv_req.lv_name));
2952 if (err)
2953 return -EFAULT;
2954 if (cmd != LV_REMOVE) {
2955 err = __get_user(ptr, &((lv_req32_t *)arg)->lv);
2956 if (err)
2957 return err;
2958 u.lv_req.lv = get_lv_t(ptr, &err);
2959 } else
2960 u.lv_req.lv = NULL;
2961 break;
2962
2963 case LV_STATUS_BYINDEX:
2964 err = get_user(u.lv_byindex.lv_index,
2965 &((lv_status_byindex_req32_t *)arg)->lv_index);
2966 err |= __get_user(ptr, &((lv_status_byindex_req32_t *)arg)->lv);
2967 if (err)
2968 return err;
2969 u.lv_byindex.lv = get_lv_t(ptr, &err);
2970 break;
2971
2972 case LV_STATUS_BYDEV:
2973 err = get_user(u.lv_bydev.dev, &((lv_status_bydev_req32_t *)arg)->dev);
2974 err |= __get_user(ptr, &((lv_status_bydev_req32_t *)arg)->lv);
2975 if (err)
2976 return err;
2977 u.lv_bydev.lv = get_lv_t(ptr, &err);
2978 break;
2979
2980 case VG_EXTEND:
2981 err = copy_from_user(&p, (void *)arg, sizeof(pv32_t) - 8 - UUID_LEN+1);
2982 if (err)
2983 return -EFAULT;
2984 err = copy_from_user(p.pv_uuid, ((pv32_t *)arg)->pv_uuid, UUID_LEN+1);
2985 if (err)
2986 return -EFAULT;
2987 p.pe = NULL;
2988 p.bd = NULL;
2989 karg = &p;
2990 break;
2991
2992 case PV_CHANGE:
2993 case PV_STATUS:
2994 err = copy_from_user(&u.pv_status, arg, sizeof(u.pv_status.pv_name));
2995 if (err)
2996 return -EFAULT;
2997 err = __get_user(ptr, &((pv_status_req32_t *)arg)->pv);
2998 if (err)
2999 return err;
3000 u.pv_status.pv = &p;
3001 if (cmd == PV_CHANGE) {
3002 err = copy_from_user(&p, (void *)A(ptr),
3003 sizeof(pv32_t) - 8 - UUID_LEN+1);
3004 if (err)
3005 return -EFAULT;
3006 p.pe = NULL;
3007 p.bd = NULL;
3008 }
3009 break;
3010 };
3011
3012 old_fs = get_fs(); set_fs (KERNEL_DS);
3013 err = sys_ioctl (fd, cmd, (unsigned long)karg);
3014 set_fs (old_fs);
3015
3016 switch (cmd) {
3017 case VG_STATUS:
3018 if (!err) {
3019 if (copy_to_user((void *)arg, v, (long)&((vg32_t *)0)->proc) ||
3020 clear_user(&((vg32_t *)arg)->proc, sizeof(vg32_t) - (long)&((vg32_t *)0)->proc))
3021 err = -EFAULT;
3022 }
3023 if (copy_to_user(((vg32_t *)arg)->vg_uuid, v->vg_uuid, UUID_LEN+1)) {
3024 err = -EFAULT;
3025 }
3026 kfree(v);
3027 break;
3028
3029 case VG_CREATE_OLD:
3030 case VG_CREATE:
3031 for (i = 0; i < v->pv_max; i++) {
3032 if (v->pv[i])
3033 kfree(v->pv[i]);
3034 }
3035 for (i = 0; i < v->lv_max; i++) {
3036 if (v->lv[i])
3037 put_lv_t(v->lv[i]);
3038 }
3039 kfree(v);
3040 break;
3041
3042 case LV_STATUS_BYNAME:
3043 if (!err && u.lv_req.lv)
3044 err = copy_lv_t(ptr, u.lv_req.lv);
3045
3046
3047 case LV_CREATE:
3048 case LV_EXTEND:
3049 case LV_REDUCE:
3050 if (u.lv_req.lv)
3051 put_lv_t(u.lv_req.lv);
3052 break;
3053
3054 case LV_STATUS_BYINDEX:
3055 if (u.lv_byindex.lv) {
3056 if (!err)
3057 err = copy_lv_t(ptr, u.lv_byindex.lv);
3058 put_lv_t(u.lv_byindex.lv);
3059 }
3060 break;
3061
3062 case LV_STATUS_BYDEV:
3063 if (u.lv_bydev.lv) {
3064 if (!err)
3065 err = copy_lv_t(ptr, u.lv_bydev.lv);
3066 put_lv_t(u.lv_bydev.lv);
3067 }
3068 break;
3069
3070 case PV_STATUS:
3071 if (!err) {
3072 err = copy_to_user((void *)A(ptr), &p, sizeof(pv32_t) - 8 - UUID_LEN+1);
3073 if (err)
3074 return -EFAULT;
3075 err = copy_to_user(((pv_t *)A(ptr))->pv_uuid, p.pv_uuid, UUID_LEN + 1);
3076 if (err)
3077 return -EFAULT;
3078 }
3079 break;
3080 };
3081
3082 return err;
3083}
3084#endif
3085
3086#if defined(CONFIG_IEEE1394) || defined(CONFIG_IEEE1394_MODULE)
3087#include "../../../drivers/ieee1394/ieee1394-ioctl.h"
3088#include "../../../drivers/ieee1394/amdtp.h"
3089#include "../../../drivers/ieee1394/dv1394.h"
3090#include "../../../drivers/ieee1394/video1394.h"
3091
3092#define DV1394_IOC32_INIT _IOW('#', 0x06, struct dv1394_init32)
3093#define DV1394_IOC32_GET_STATUS _IOR('#', 0x0c, struct dv1394_status32)
3094
3095struct dv1394_init32 {
3096 u32 api_version;
3097 u32 channel;
3098 u32 n_frames;
3099 u32 format;
3100 u32 cip_n;
3101 u32 cip_d;
3102 u32 syt_offset;
3103};
3104
3105struct dv1394_status32 {
3106 struct dv1394_init32 init;
3107 s32 active_frame;
3108 u32 first_clear_frame;
3109 u32 n_clear_frames;
3110 u32 dropped_frames;
3111};
3112
3113static int handle_dv1394_init(unsigned int fd, unsigned int cmd, unsigned long arg)
3114{
3115 struct dv1394_init32 dv32;
3116 struct dv1394_init dv;
3117 mm_segment_t old_fs;
3118 int ret;
3119
3120 if (copy_from_user(&dv32, (void *)arg, sizeof(dv32)))
3121 return -EFAULT;
3122
3123 dv.api_version = dv32.api_version;
3124 dv.channel = dv32.channel;
3125 dv.n_frames = dv32.n_frames;
3126 dv.format = dv32.format;
3127 dv.cip_n = (unsigned long)dv32.cip_n;
3128 dv.cip_d = (unsigned long)dv32.cip_d;
3129 dv.syt_offset = dv32.syt_offset;
3130
3131 old_fs = get_fs();
3132 set_fs(KERNEL_DS);
3133 ret = sys_ioctl(fd, DV1394_IOC_INIT, (unsigned long) &dv);
3134 set_fs(old_fs);
3135
3136 return ret;
3137}
3138
3139static int handle_dv1394_get_status(unsigned int fd, unsigned int cmd, unsigned long arg)
3140{
3141 struct dv1394_status32 dv32;
3142 struct dv1394_status dv;
3143 mm_segment_t old_fs;
3144 int ret;
3145
3146 old_fs = get_fs();
3147 set_fs(KERNEL_DS);
3148 ret = sys_ioctl(fd, DV1394_IOC_GET_STATUS, (unsigned long) &dv);
3149 set_fs(old_fs);
3150
3151 if (!ret) {
3152 dv32.init.api_version = dv.init.api_version;
3153 dv32.init.channel = dv.init.channel;
3154 dv32.init.n_frames = dv.init.n_frames;
3155 dv32.init.format = dv.init.format;
3156 dv32.init.cip_n = (u32)dv.init.cip_n;
3157 dv32.init.cip_d = (u32)dv.init.cip_d;
3158 dv32.init.syt_offset = dv.init.syt_offset;
3159 dv32.active_frame = dv.active_frame;
3160 dv32.first_clear_frame = dv.first_clear_frame;
3161 dv32.n_clear_frames = dv.n_clear_frames;
3162 dv32.dropped_frames = dv.dropped_frames;
3163
3164 if (copy_to_user((struct dv1394_status32 *)arg, &dv32, sizeof(dv32)))
3165 ret = -EFAULT;
3166 }
3167
3168 return ret;
3169}
3170
3171#define VIDEO1394_IOC32_LISTEN_QUEUE_BUFFER \
3172 _IOW ('#', 0x12, struct video1394_wait32)
3173#define VIDEO1394_IOC32_LISTEN_WAIT_BUFFER \
3174 _IOWR('#', 0x13, struct video1394_wait32)
3175#define VIDEO1394_IOC32_TALK_WAIT_BUFFER \
3176 _IOW ('#', 0x17, struct video1394_wait32)
3177#define VIDEO1394_IOC32_LISTEN_POLL_BUFFER \
3178 _IOWR('#', 0x18, struct video1394_wait32)
3179
3180struct video1394_wait32 {
3181 u32 channel;
3182 u32 buffer;
3183 struct timeval32 filltime;
3184};
3185
3186static int video1394_wr_wait32(unsigned int fd, unsigned int cmd, unsigned long arg)
3187{
3188 struct video1394_wait32 wait32;
3189 struct video1394_wait wait;
3190 mm_segment_t old_fs;
3191 int ret;
3192
3193 if (copy_from_user(&wait32, (void *)arg, sizeof(wait32)))
3194 return -EFAULT;
3195
3196 wait.channel = wait32.channel;
3197 wait.buffer = wait32.buffer;
3198 wait.filltime.tv_sec = (time_t)wait32.filltime.tv_sec;
3199 wait.filltime.tv_usec = (suseconds_t)wait32.filltime.tv_usec;
3200
3201 old_fs = get_fs();
3202 set_fs(KERNEL_DS);
3203 if (cmd == VIDEO1394_IOC32_LISTEN_WAIT_BUFFER)
3204 ret = sys_ioctl(fd, VIDEO1394_IOC_LISTEN_WAIT_BUFFER, (unsigned long) &wait);
3205 else
3206 ret = sys_ioctl(fd, VIDEO1394_IOC_LISTEN_POLL_BUFFER, (unsigned long) &wait);
3207 set_fs(old_fs);
3208
3209 if (!ret) {
3210 wait32.channel = wait.channel;
3211 wait32.buffer = wait.buffer;
3212 wait32.filltime.tv_sec = (int)wait.filltime.tv_sec;
3213 wait32.filltime.tv_usec = (int)wait.filltime.tv_usec;
3214
3215 if (copy_to_user((struct video1394_wait32 *)arg, &wait32, sizeof(wait32)))
3216 ret = -EFAULT;
3217 }
3218
3219 return ret;
3220}
3221
3222static int video1394_w_wait32(unsigned int fd, unsigned int cmd, unsigned long arg)
3223{
3224 struct video1394_wait32 wait32;
3225 struct video1394_wait wait;
3226 mm_segment_t old_fs;
3227 int ret;
3228
3229 if (copy_from_user(&wait32, (void *)arg, sizeof(wait32)))
3230 return -EFAULT;
3231
3232 wait.channel = wait32.channel;
3233 wait.buffer = wait32.buffer;
3234 wait.filltime.tv_sec = (time_t)wait32.filltime.tv_sec;
3235 wait.filltime.tv_usec = (suseconds_t)wait32.filltime.tv_usec;
3236
3237 old_fs = get_fs();
3238 set_fs(KERNEL_DS);
3239 if (cmd == VIDEO1394_IOC32_LISTEN_QUEUE_BUFFER)
3240 ret = sys_ioctl(fd, VIDEO1394_IOC_LISTEN_QUEUE_BUFFER, (unsigned long) &wait);
3241 else
3242 ret = sys_ioctl(fd, VIDEO1394_IOC_TALK_WAIT_BUFFER, (unsigned long) &wait);
3243 set_fs(old_fs);
3244
3245 return ret;
3246}
3247
3248static int video1394_queue_buf32(unsigned int fd, unsigned int cmd, unsigned long arg)
3249{
3250 return -EFAULT;
3251}
3252
3253#endif
3254
3255#if defined(CONFIG_DRM_NEW) || defined(CONFIG_DRM_NEW_MODULE)
3256
3257#include "../../../drivers/char/drm/drm.h"
3258
3259typedef struct drm32_version {
3260 int version_major;
3261 int version_minor;
3262 int version_patchlevel;
3263 int name_len;
3264 u32 name;
3265 int date_len;
3266 u32 date;
3267 int desc_len;
3268 u32 desc;
3269} drm32_version_t;
3270#define DRM32_IOCTL_VERSION DRM_IOWR(0x00, drm32_version_t)
3271
3272static int drm32_version(unsigned int fd, unsigned int cmd, unsigned long arg)
3273{
3274 drm32_version_t *uversion = (drm32_version_t *)arg;
3275 char *name_ptr, *date_ptr, *desc_ptr;
3276 u32 tmp1, tmp2, tmp3;
3277 drm_version_t kversion;
3278 mm_segment_t old_fs;
3279 int ret;
3280
3281 memset(&kversion, 0, sizeof(kversion));
3282 if (get_user(kversion.name_len, &uversion->name_len) ||
3283 get_user(kversion.date_len, &uversion->date_len) ||
3284 get_user(kversion.desc_len, &uversion->desc_len) ||
3285 get_user(tmp1, &uversion->name) ||
3286 get_user(tmp2, &uversion->date) ||
3287 get_user(tmp3, &uversion->desc))
3288 return -EFAULT;
3289
3290 name_ptr = (char *) A(tmp1);
3291 date_ptr = (char *) A(tmp2);
3292 desc_ptr = (char *) A(tmp3);
3293
3294 ret = -ENOMEM;
3295 if (kversion.name_len && name_ptr) {
3296 kversion.name = kmalloc(kversion.name_len, GFP_KERNEL);
3297 if (!kversion.name)
3298 goto out;
3299 }
3300 if (kversion.date_len && date_ptr) {
3301 kversion.date = kmalloc(kversion.date_len, GFP_KERNEL);
3302 if (!kversion.date)
3303 goto out;
3304 }
3305 if (kversion.desc_len && desc_ptr) {
3306 kversion.desc = kmalloc(kversion.desc_len, GFP_KERNEL);
3307 if (!kversion.desc)
3308 goto out;
3309 }
3310
3311 old_fs = get_fs();
3312 set_fs(KERNEL_DS);
3313 ret = sys_ioctl (fd, DRM_IOCTL_VERSION, (unsigned long)&kversion);
3314 set_fs(old_fs);
3315
3316 if (!ret) {
3317 if ((kversion.name &&
3318 copy_to_user(name_ptr, kversion.name, kversion.name_len)) ||
3319 (kversion.date &&
3320 copy_to_user(date_ptr, kversion.date, kversion.date_len)) ||
3321 (kversion.desc &&
3322 copy_to_user(desc_ptr, kversion.desc, kversion.desc_len)))
3323 ret = -EFAULT;
3324 if (put_user(kversion.version_major, &uversion->version_major) ||
3325 put_user(kversion.version_minor, &uversion->version_minor) ||
3326 put_user(kversion.version_patchlevel, &uversion->version_patchlevel) ||
3327 put_user(kversion.name_len, &uversion->name_len) ||
3328 put_user(kversion.date_len, &uversion->date_len) ||
3329 put_user(kversion.desc_len, &uversion->desc_len))
3330 ret = -EFAULT;
3331 }
3332
3333out:
3334 if (kversion.name)
3335 kfree(kversion.name);
3336 if (kversion.date)
3337 kfree(kversion.date);
3338 if (kversion.desc)
3339 kfree(kversion.desc);
3340 return ret;
3341}
3342
3343typedef struct drm32_unique {
3344 int unique_len;
3345 u32 unique;
3346} drm32_unique_t;
3347#define DRM32_IOCTL_GET_UNIQUE DRM_IOWR(0x01, drm32_unique_t)
3348#define DRM32_IOCTL_SET_UNIQUE DRM_IOW( 0x10, drm32_unique_t)
3349
3350static int drm32_getsetunique(unsigned int fd, unsigned int cmd, unsigned long arg)
3351{
3352 drm32_unique_t *uarg = (drm32_unique_t *)arg;
3353 drm_unique_t karg;
3354 mm_segment_t old_fs;
3355 char *uptr;
3356 u32 tmp;
3357 int ret;
3358
3359 if (get_user(karg.unique_len, &uarg->unique_len))
3360 return -EFAULT;
3361 karg.unique = NULL;
3362
3363 if (get_user(tmp, &uarg->unique))
3364 return -EFAULT;
3365
3366 uptr = (char *) A(tmp);
3367
3368 if (uptr) {
3369 karg.unique = kmalloc(karg.unique_len, GFP_KERNEL);
3370 if (!karg.unique)
3371 return -ENOMEM;
3372 if (cmd == DRM32_IOCTL_SET_UNIQUE &&
3373 copy_from_user(karg.unique, uptr, karg.unique_len)) {
3374 kfree(karg.unique);
3375 return -EFAULT;
3376 }
3377 }
3378
3379 old_fs = get_fs();
3380 set_fs(KERNEL_DS);
3381 if (cmd == DRM32_IOCTL_GET_UNIQUE)
3382 ret = sys_ioctl (fd, DRM_IOCTL_GET_UNIQUE, (unsigned long)&karg);
3383 else
3384 ret = sys_ioctl (fd, DRM_IOCTL_SET_UNIQUE, (unsigned long)&karg);
3385 set_fs(old_fs);
3386
3387 if (!ret) {
3388 if (cmd == DRM32_IOCTL_GET_UNIQUE &&
3389 uptr != NULL &&
3390 copy_to_user(uptr, karg.unique, karg.unique_len))
3391 ret = -EFAULT;
3392 if (put_user(karg.unique_len, &uarg->unique_len))
3393 ret = -EFAULT;
3394 }
3395
3396 if (karg.unique != NULL)
3397 kfree(karg.unique);
3398
3399 return ret;
3400}
3401
3402typedef struct drm32_map {
3403 u32 offset;
3404 u32 size;
3405 drm_map_type_t type;
3406 drm_map_flags_t flags;
3407 u32 handle;
3408
3409 int mtrr;
3410
3411} drm32_map_t;
3412#define DRM32_IOCTL_ADD_MAP DRM_IOWR(0x15, drm32_map_t)
3413
3414static int drm32_addmap(unsigned int fd, unsigned int cmd, unsigned long arg)
3415{
3416 drm32_map_t *uarg = (drm32_map_t *) arg;
3417 drm_map_t karg;
3418 mm_segment_t old_fs;
3419 u32 tmp;
3420 int ret;
3421
3422 ret = get_user(karg.offset, &uarg->offset);
3423 ret |= get_user(karg.size, &uarg->size);
3424 ret |= get_user(karg.type, &uarg->type);
3425 ret |= get_user(karg.flags, &uarg->flags);
3426 ret |= get_user(tmp, &uarg->handle);
3427 ret |= get_user(karg.mtrr, &uarg->mtrr);
3428 if (ret)
3429 return -EFAULT;
3430
3431 karg.handle = (void *) A(tmp);
3432
3433 old_fs = get_fs();
3434 set_fs(KERNEL_DS);
3435 ret = sys_ioctl(fd, DRM_IOCTL_ADD_MAP, (unsigned long) &karg);
3436 set_fs(old_fs);
3437
3438 if (!ret) {
3439 ret = put_user(karg.offset, &uarg->offset);
3440 ret |= put_user(karg.size, &uarg->size);
3441 ret |= put_user(karg.type, &uarg->type);
3442 ret |= put_user(karg.flags, &uarg->flags);
3443 tmp = (u32) (long)karg.handle;
3444 ret |= put_user(tmp, &uarg->handle);
3445 ret |= put_user(karg.mtrr, &uarg->mtrr);
3446 if (ret)
3447 ret = -EFAULT;
3448 }
3449
3450 return ret;
3451}
3452
3453typedef struct drm32_buf_info {
3454 int count;
3455 u32 list;
3456} drm32_buf_info_t;
3457#define DRM32_IOCTL_INFO_BUFS DRM_IOWR(0x18, drm32_buf_info_t)
3458
3459static int drm32_info_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
3460{
3461 drm32_buf_info_t *uarg = (drm32_buf_info_t *)arg;
3462 drm_buf_desc_t *ulist;
3463 drm_buf_info_t karg;
3464 mm_segment_t old_fs;
3465 int orig_count, ret;
3466 u32 tmp;
3467
3468 if (get_user(karg.count, &uarg->count) ||
3469 get_user(tmp, &uarg->list))
3470 return -EFAULT;
3471
3472 ulist = (drm_buf_desc_t *) A(tmp);
3473
3474 orig_count = karg.count;
3475
3476 karg.list = kmalloc(karg.count * sizeof(drm_buf_desc_t), GFP_KERNEL);
3477 if (!karg.list)
3478 return -EFAULT;
3479
3480 old_fs = get_fs();
3481 set_fs(KERNEL_DS);
3482 ret = sys_ioctl(fd, DRM_IOCTL_INFO_BUFS, (unsigned long) &karg);
3483 set_fs(old_fs);
3484
3485 if (!ret) {
3486 if (karg.count <= orig_count &&
3487 (copy_to_user(ulist, karg.list,
3488 karg.count * sizeof(drm_buf_desc_t))))
3489 ret = -EFAULT;
3490 if (put_user(karg.count, &uarg->count))
3491 ret = -EFAULT;
3492 }
3493
3494 kfree(karg.list);
3495
3496 return ret;
3497}
3498
3499typedef struct drm32_buf_free {
3500 int count;
3501 u32 list;
3502} drm32_buf_free_t;
3503#define DRM32_IOCTL_FREE_BUFS DRM_IOW( 0x1a, drm32_buf_free_t)
3504
3505static int drm32_free_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
3506{
3507 drm32_buf_free_t *uarg = (drm32_buf_free_t *)arg;
3508 drm_buf_free_t karg;
3509 mm_segment_t old_fs;
3510 int *ulist;
3511 int ret;
3512 u32 tmp;
3513
3514 if (get_user(karg.count, &uarg->count) ||
3515 get_user(tmp, &uarg->list))
3516 return -EFAULT;
3517
3518 ulist = (int *) A(tmp);
3519
3520 karg.list = kmalloc(karg.count * sizeof(int), GFP_KERNEL);
3521 if (!karg.list)
3522 return -ENOMEM;
3523
3524 ret = -EFAULT;
3525 if (copy_from_user(karg.list, ulist, (karg.count * sizeof(int))))
3526 goto out;
3527
3528 old_fs = get_fs();
3529 set_fs(KERNEL_DS);
3530 ret = sys_ioctl(fd, DRM_IOCTL_FREE_BUFS, (unsigned long) &karg);
3531 set_fs(old_fs);
3532
3533out:
3534 kfree(karg.list);
3535
3536 return ret;
3537}
3538
3539typedef struct drm32_buf_pub {
3540 int idx;
3541 int total;
3542 int used;
3543 u32 address;
3544} drm32_buf_pub_t;
3545
3546typedef struct drm32_buf_map {
3547 int count;
3548 u32 virtual;
3549 u32 list;
3550} drm32_buf_map_t;
3551#define DRM32_IOCTL_MAP_BUFS DRM_IOWR(0x19, drm32_buf_map_t)
3552
3553static int drm32_map_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
3554{
3555 drm32_buf_map_t *uarg = (drm32_buf_map_t *)arg;
3556 drm32_buf_pub_t *ulist;
3557 drm_buf_map_t karg;
3558 mm_segment_t old_fs;
3559 int orig_count, ret, i;
3560 u32 tmp1, tmp2;
3561
3562 if (get_user(karg.count, &uarg->count) ||
3563 get_user(tmp1, &uarg->virtual) ||
3564 get_user(tmp2, &uarg->list))
3565 return -EFAULT;
3566
3567 karg.virtual = (void *) A(tmp1);
3568 ulist = (drm32_buf_pub_t *) A(tmp2);
3569
3570 orig_count = karg.count;
3571
3572 karg.list = kmalloc(karg.count * sizeof(drm_buf_pub_t), GFP_KERNEL);
3573 if (!karg.list)
3574 return -ENOMEM;
3575
3576 ret = -EFAULT;
3577 for (i = 0; i < karg.count; i++) {
3578 if (get_user(karg.list[i].idx, &ulist[i].idx) ||
3579 get_user(karg.list[i].total, &ulist[i].total) ||
3580 get_user(karg.list[i].used, &ulist[i].used) ||
3581 get_user(tmp1, &ulist[i].address))
3582 goto out;
3583
3584 karg.list[i].address = (void *) A(tmp1);
3585 }
3586
3587 old_fs = get_fs();
3588 set_fs(KERNEL_DS);
3589 ret = sys_ioctl(fd, DRM_IOCTL_MAP_BUFS, (unsigned long) &karg);
3590 set_fs(old_fs);
3591
3592 if (!ret) {
3593 for (i = 0; i < orig_count; i++) {
3594 tmp1 = (u32) (long) karg.list[i].address;
3595 if (put_user(karg.list[i].idx, &ulist[i].idx) ||
3596 put_user(karg.list[i].total, &ulist[i].total) ||
3597 put_user(karg.list[i].used, &ulist[i].used) ||
3598 put_user(tmp1, &ulist[i].address)) {
3599 ret = -EFAULT;
3600 goto out;
3601 }
3602 }
3603 if (put_user(karg.count, &uarg->count))
3604 ret = -EFAULT;
3605 }
3606
3607out:
3608 kfree(karg.list);
3609 return ret;
3610}
3611
3612typedef struct drm32_dma {
3613
3614
3615 int context;
3616 int send_count;
3617 u32 send_indices;
3618 u32 send_sizes;
3619 drm_dma_flags_t flags;
3620 int request_count;
3621 int request_size;
3622 u32 request_indices;
3623 u32 request_sizes;
3624 int granted_count;
3625} drm32_dma_t;
3626#define DRM32_IOCTL_DMA DRM_IOWR(0x29, drm32_dma_t)
3627
3628
3629
3630
3631
3632static int drm32_dma(unsigned int fd, unsigned int cmd, unsigned long arg)
3633{
3634 drm32_dma_t *uarg = (drm32_dma_t *) arg;
3635 int *u_si, *u_ss, *u_ri, *u_rs;
3636 drm_dma_t karg;
3637 mm_segment_t old_fs;
3638 int ret;
3639 u32 tmp1, tmp2, tmp3, tmp4;
3640
3641 karg.send_indices = karg.send_sizes = NULL;
3642 karg.request_indices = karg.request_sizes = NULL;
3643
3644 if (get_user(karg.context, &uarg->context) ||
3645 get_user(karg.send_count, &uarg->send_count) ||
3646 get_user(tmp1, &uarg->send_indices) ||
3647 get_user(tmp2, &uarg->send_sizes) ||
3648 get_user(karg.flags, &uarg->flags) ||
3649 get_user(karg.request_count, &uarg->request_count) ||
3650 get_user(karg.request_size, &uarg->request_size) ||
3651 get_user(tmp3, &uarg->request_indices) ||
3652 get_user(tmp4, &uarg->request_sizes) ||
3653 get_user(karg.granted_count, &uarg->granted_count))
3654 return -EFAULT;
3655
3656 u_si = (int *) A(tmp1);
3657 u_ss = (int *) A(tmp2);
3658 u_ri = (int *) A(tmp3);
3659 u_rs = (int *) A(tmp4);
3660
3661 if (karg.send_count) {
3662 karg.send_indices = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
3663 karg.send_sizes = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
3664
3665 ret = -ENOMEM;
3666 if (!karg.send_indices || !karg.send_sizes)
3667 goto out;
3668
3669 ret = -EFAULT;
3670 if (copy_from_user(karg.send_indices, u_si,
3671 (karg.send_count * sizeof(int))) ||
3672 copy_from_user(karg.send_sizes, u_ss,
3673 (karg.send_count * sizeof(int))))
3674 goto out;
3675 }
3676
3677 if (karg.request_count) {
3678 karg.request_indices = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
3679 karg.request_sizes = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
3680
3681 ret = -ENOMEM;
3682 if (!karg.request_indices || !karg.request_sizes)
3683 goto out;
3684
3685 ret = -EFAULT;
3686 if (copy_from_user(karg.request_indices, u_ri,
3687 (karg.request_count * sizeof(int))) ||
3688 copy_from_user(karg.request_sizes, u_rs,
3689 (karg.request_count * sizeof(int))))
3690 goto out;
3691 }
3692
3693 old_fs = get_fs();
3694 set_fs(KERNEL_DS);
3695 ret = sys_ioctl(fd, DRM_IOCTL_DMA, (unsigned long) &karg);
3696 set_fs(old_fs);
3697
3698 if (!ret) {
3699 if (put_user(karg.context, &uarg->context) ||
3700 put_user(karg.send_count, &uarg->send_count) ||
3701 put_user(karg.flags, &uarg->flags) ||
3702 put_user(karg.request_count, &uarg->request_count) ||
3703 put_user(karg.request_size, &uarg->request_size) ||
3704 put_user(karg.granted_count, &uarg->granted_count))
3705 ret = -EFAULT;
3706
3707 if (karg.send_count) {
3708 if (copy_to_user(u_si, karg.send_indices,
3709 (karg.send_count * sizeof(int))) ||
3710 copy_to_user(u_ss, karg.send_sizes,
3711 (karg.send_count * sizeof(int))))
3712 ret = -EFAULT;
3713 }
3714 if (karg.request_count) {
3715 if (copy_to_user(u_ri, karg.request_indices,
3716 (karg.request_count * sizeof(int))) ||
3717 copy_to_user(u_rs, karg.request_sizes,
3718 (karg.request_count * sizeof(int))))
3719 ret = -EFAULT;
3720 }
3721 }
3722
3723out:
3724 if (karg.send_indices)
3725 kfree(karg.send_indices);
3726 if (karg.send_sizes)
3727 kfree(karg.send_sizes);
3728 if (karg.request_indices)
3729 kfree(karg.request_indices);
3730 if (karg.request_sizes)
3731 kfree(karg.request_sizes);
3732
3733 return ret;
3734}
3735
3736typedef struct drm32_ctx_res {
3737 int count;
3738 u32 contexts;
3739} drm32_ctx_res_t;
3740#define DRM32_IOCTL_RES_CTX DRM_IOWR(0x26, drm32_ctx_res_t)
3741
3742static int drm32_res_ctx(unsigned int fd, unsigned int cmd, unsigned long arg)
3743{
3744 drm32_ctx_res_t *uarg = (drm32_ctx_res_t *) arg;
3745 drm_ctx_t *ulist;
3746 drm_ctx_res_t karg;
3747 mm_segment_t old_fs;
3748 int orig_count, ret;
3749 u32 tmp;
3750
3751 karg.contexts = NULL;
3752 if (get_user(karg.count, &uarg->count) ||
3753 get_user(tmp, &uarg->contexts))
3754 return -EFAULT;
3755
3756 ulist = (drm_ctx_t *) A(tmp);
3757
3758 orig_count = karg.count;
3759 if (karg.count && ulist) {
3760 karg.contexts = kmalloc((karg.count * sizeof(drm_ctx_t)), GFP_KERNEL);
3761 if (!karg.contexts)
3762 return -ENOMEM;
3763 if (copy_from_user(karg.contexts, ulist,
3764 (karg.count * sizeof(drm_ctx_t)))) {
3765 kfree(karg.contexts);
3766 return -EFAULT;
3767 }
3768 }
3769
3770 old_fs = get_fs();
3771 set_fs(KERNEL_DS);
3772 ret = sys_ioctl(fd, DRM_IOCTL_RES_CTX, (unsigned long) &karg);
3773 set_fs(old_fs);
3774
3775 if (!ret) {
3776 if (orig_count) {
3777 if (copy_to_user(ulist, karg.contexts,
3778 (orig_count * sizeof(drm_ctx_t))))
3779 ret = -EFAULT;
3780 }
3781 if (put_user(karg.count, &uarg->count))
3782 ret = -EFAULT;
3783 }
3784
3785 if (karg.contexts)
3786 kfree(karg.contexts);
3787
3788 return ret;
3789}
3790
3791#endif
3792
3793static int ret_einval(unsigned int fd, unsigned int cmd, unsigned long arg)
3794{
3795 return -EINVAL;
3796}
3797
3798static int broken_blkgetsize(unsigned int fd, unsigned int cmd, unsigned long arg)
3799{
3800
3801 return w_long(fd, BLKGETSIZE, arg);
3802}
3803
3804struct blkpg_ioctl_arg32 {
3805 int op;
3806 int flags;
3807 int datalen;
3808 u32 data;
3809};
3810
3811static int blkpg_ioctl_trans(unsigned int fd, unsigned int cmd, struct blkpg_ioctl_arg32 *arg)
3812{
3813 struct blkpg_ioctl_arg a;
3814 struct blkpg_partition p;
3815 u32 u_data;
3816 int err;
3817 mm_segment_t old_fs = get_fs();
3818
3819 err = get_user(a.op, &arg->op);
3820 err |= __get_user(a.flags, &arg->flags);
3821 err |= __get_user(a.datalen, &arg->datalen);
3822 err |= __get_user(u_data, &arg->data);
3823 a.data = (void *) (long) u_data;
3824 if (err) return err;
3825 switch (a.op) {
3826 case BLKPG_ADD_PARTITION:
3827 case BLKPG_DEL_PARTITION:
3828 if (a.datalen < sizeof(struct blkpg_partition))
3829 return -EINVAL;
3830 if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))
3831 return -EFAULT;
3832 a.data = &p;
3833 set_fs (KERNEL_DS);
3834 err = sys_ioctl(fd, cmd, (unsigned long)&a);
3835 set_fs (old_fs);
3836 default:
3837 return -EINVAL;
3838 }
3839 return err;
3840}
3841
3842static int ioc_settimeout(unsigned int fd, unsigned int cmd, unsigned long arg)
3843{
3844 return rw_long(fd, AUTOFS_IOC_SETTIMEOUT, arg);
3845}
3846
3847struct usbdevfs_ctrltransfer32 {
3848 __u8 requesttype;
3849 __u8 request;
3850 __u16 value;
3851 __u16 index;
3852 __u16 length;
3853 __u32 timeout;
3854 __u32 data;
3855};
3856
3857#define USBDEVFS_CONTROL32 _IOWR('U', 0, struct usbdevfs_ctrltransfer32)
3858
3859static int do_usbdevfs_control(unsigned int fd, unsigned int cmd, unsigned long arg)
3860{
3861 struct usbdevfs_ctrltransfer kctrl;
3862 struct usbdevfs_ctrltransfer32 *uctrl;
3863 mm_segment_t old_fs;
3864 __u32 udata;
3865 void *uptr, *kptr;
3866 int err;
3867
3868 uctrl = (struct usbdevfs_ctrltransfer32 *) arg;
3869
3870 if (copy_from_user(&kctrl, uctrl,
3871 (sizeof(struct usbdevfs_ctrltransfer) -
3872 sizeof(void *))))
3873 return -EFAULT;
3874
3875 if (get_user(udata, &uctrl->data))
3876 return -EFAULT;
3877 uptr = (void *) A(udata);
3878
3879
3880
3881
3882 if (!uptr || kctrl.length > PAGE_SIZE)
3883 return -EINVAL;
3884
3885 kptr = (void *)__get_free_page(GFP_KERNEL);
3886
3887 if ((kctrl.requesttype & 0x80) == 0) {
3888 err = -EFAULT;
3889 if (copy_from_user(kptr, uptr, kctrl.length))
3890 goto out;
3891 }
3892
3893 kctrl.data = kptr;
3894
3895 old_fs = get_fs();
3896 set_fs(KERNEL_DS);
3897 err = sys_ioctl(fd, USBDEVFS_CONTROL, (unsigned long)&kctrl);
3898 set_fs(old_fs);
3899
3900 if (err >= 0 &&
3901 ((kctrl.requesttype & 0x80) != 0)) {
3902 if (copy_to_user(uptr, kptr, kctrl.length))
3903 err = -EFAULT;
3904 }
3905
3906out:
3907 free_page((unsigned long) kptr);
3908 return err;
3909}
3910
3911struct usbdevfs_bulktransfer32 {
3912 unsigned int ep;
3913 unsigned int len;
3914 unsigned int timeout;
3915 __u32 data;
3916};
3917
3918#define USBDEVFS_BULK32 _IOWR('U', 2, struct usbdevfs_bulktransfer32)
3919
3920static int do_usbdevfs_bulk(unsigned int fd, unsigned int cmd, unsigned long arg)
3921{
3922 struct usbdevfs_bulktransfer kbulk;
3923 struct usbdevfs_bulktransfer32 *ubulk;
3924 mm_segment_t old_fs;
3925 __u32 udata;
3926 void *uptr, *kptr;
3927 int err;
3928
3929 ubulk = (struct usbdevfs_bulktransfer32 *) arg;
3930
3931 if (get_user(kbulk.ep, &ubulk->ep) ||
3932 get_user(kbulk.len, &ubulk->len) ||
3933 get_user(kbulk.timeout, &ubulk->timeout) ||
3934 get_user(udata, &ubulk->data))
3935 return -EFAULT;
3936
3937 uptr = (void *) A(udata);
3938
3939
3940
3941
3942 if (!uptr || kbulk.len > PAGE_SIZE)
3943 return -EINVAL;
3944
3945 kptr = (void *) __get_free_page(GFP_KERNEL);
3946
3947 if ((kbulk.ep & 0x80) == 0) {
3948 err = -EFAULT;
3949 if (copy_from_user(kptr, uptr, kbulk.len))
3950 goto out;
3951 }
3952
3953 kbulk.data = kptr;
3954
3955 old_fs = get_fs();
3956 set_fs(KERNEL_DS);
3957 err = sys_ioctl(fd, USBDEVFS_BULK, (unsigned long) &kbulk);
3958 set_fs(old_fs);
3959
3960 if (err >= 0 &&
3961 ((kbulk.ep & 0x80) != 0)) {
3962 if (copy_to_user(uptr, kptr, kbulk.len))
3963 err = -EFAULT;
3964 }
3965
3966out:
3967 free_page((unsigned long) kptr);
3968 return err;
3969}
3970
3971
3972
3973
3974
3975
3976
3977
3978
3979
3980
3981
3982
3983
3984
3985
3986
3987
3988
3989
3990
3991
3992
3993
3994
3995
3996
3997
3998
3999
4000
4001
4002
4003
4004
4005
4006
4007
4008
4009
4010
4011#if 0
4012struct usbdevfs_urb32 {
4013 __u8 type;
4014 __u8 endpoint;
4015 __s32 status;
4016 __u32 flags;
4017 __u32 buffer;
4018 __s32 buffer_length;
4019 __s32 actual_length;
4020 __s32 start_frame;
4021 __s32 number_of_packets;
4022 __s32 error_count;
4023 __u32 signr;
4024 __u32 usercontext;
4025 struct usbdevfs_iso_packet_desc iso_frame_desc[0];
4026};
4027
4028#define USBDEVFS_SUBMITURB32 _IOR('U', 10, struct usbdevfs_urb32)
4029
4030static int get_urb32(struct usbdevfs_urb *kurb,
4031 struct usbdevfs_urb32 *uurb)
4032{
4033 if (get_user(kurb->type, &uurb->type) ||
4034 __get_user(kurb->endpoint, &uurb->endpoint) ||
4035 __get_user(kurb->status, &uurb->status) ||
4036 __get_user(kurb->flags, &uurb->flags) ||
4037 __get_user(kurb->buffer_length, &uurb->buffer_length) ||
4038 __get_user(kurb->actual_length, &uurb->actual_length) ||
4039 __get_user(kurb->start_frame, &uurb->start_frame) ||
4040 __get_user(kurb->number_of_packets, &uurb->number_of_packets) ||
4041 __get_user(kurb->error_count, &uurb->error_count) ||
4042 __get_user(kurb->signr, &uurb->signr))
4043 return -EFAULT;
4044
4045 kurb->usercontext = 0;
4046
4047 return 0;
4048}
4049
4050
4051static int put_urb32(struct usbdevfs_urb *kurb,
4052 struct usbdevfs_urb32 *uurb)
4053{
4054 if (put_user(kurb->status, &uurb->status) ||
4055 __put_user(kurb->actual_length, &uurb->actual_length) ||
4056 __put_user(kurb->error_count, &uurb->error_count))
4057 return -EFAULT;
4058
4059 if (kurb->number_of_packets != 0) {
4060 int i;
4061
4062 for (i = 0; i < kurb->number_of_packets; i++) {
4063 if (__put_user(kurb->iso_frame_desc[i].actual_length,
4064 &uurb->iso_frame_desc[i].actual_length) ||
4065 __put_user(kurb->iso_frame_desc[i].status,
4066 &uurb->iso_frame_desc[i].status))
4067 return -EFAULT;
4068 }
4069 }
4070
4071 return 0;
4072}
4073
4074static int get_urb32_isoframes(struct usbdevfs_urb *kurb,
4075 struct usbdevfs_urb32 *uurb)
4076{
4077 unsigned int totlen;
4078 int i;
4079
4080 if (kurb->type != USBDEVFS_URB_TYPE_ISO) {
4081 kurb->number_of_packets = 0;
4082 return 0;
4083 }
4084
4085 if (kurb->number_of_packets < 1 ||
4086 kurb->number_of_packets > 128)
4087 return -EINVAL;
4088
4089 if (copy_from_user(&kurb->iso_frame_desc[0],
4090 &uurb->iso_frame_desc[0],
4091 sizeof(struct usbdevfs_iso_packet_desc) *
4092 kurb->number_of_packets))
4093 return -EFAULT;
4094
4095 totlen = 0;
4096 for (i = 0; i < kurb->number_of_packets; i++) {
4097 unsigned int this_len;
4098
4099 this_len = kurb->iso_frame_desc[i].length;
4100 if (this_len > 1023)
4101 return -EINVAL;
4102
4103 totlen += this_len;
4104 }
4105
4106 if (totlen > 32768)
4107 return -EINVAL;
4108
4109 kurb->buffer_length = totlen;
4110
4111 return 0;
4112}
4113
4114static int do_usbdevfs_urb(unsigned int fd, unsigned int cmd, unsigned long arg)
4115{
4116 struct usbdevfs_urb *kurb;
4117 struct usbdevfs_urb32 *uurb;
4118 mm_segment_t old_fs;
4119 __u32 udata;
4120 void *uptr, *kptr;
4121 unsigned int buflen;
4122 int err;
4123
4124 uurb = (struct usbdevfs_urb32 *) arg;
4125
4126 err = -ENOMEM;
4127 kurb = kmalloc(sizeof(struct usbdevfs_urb) +
4128 (sizeof(struct usbdevfs_iso_packet_desc) * 128),
4129 GFP_KERNEL);
4130 if (!kurb)
4131 goto out;
4132
4133 err = -EFAULT;
4134 if (get_urb32(kurb, uurb))
4135 goto out;
4136
4137 err = get_urb32_isoframes(kurb, uurb);
4138 if (err)
4139 goto out;
4140
4141 err = -EFAULT;
4142 if (__get_user(udata, &uurb->buffer))
4143 goto out;
4144 uptr = (void *) A(udata);
4145
4146 err = -ENOMEM;
4147 buflen = kurb->buffer_length;
4148 kptr = kmalloc(buflen, GFP_KERNEL);
4149 if (!kptr)
4150 goto out;
4151
4152 kurb->buffer = kptr;
4153
4154 err = -EFAULT;
4155 if (copy_from_user(kptr, uptr, buflen))
4156 goto out_kptr;
4157
4158 old_fs = get_fs();
4159 set_fs(KERNEL_DS);
4160 err = sys_ioctl(fd, USBDEVFS_SUBMITURB, (unsigned long) kurb);
4161 set_fs(old_fs);
4162
4163 if (err >= 0) {
4164
4165 if (put_urb32(kurb, uurb)) {
4166 err = -EFAULT;
4167 } else if ((kurb->endpoint & USB_DIR_IN) != 0) {
4168 if (copy_to_user(uptr, kptr, buflen))
4169 err = -EFAULT;
4170 }
4171 }
4172
4173out_kptr:
4174 kfree(kptr);
4175
4176out:
4177 kfree(kurb);
4178 return err;
4179}
4180#endif
4181
4182#define USBDEVFS_REAPURB32 _IOW('U', 12, u32)
4183#define USBDEVFS_REAPURBNDELAY32 _IOW('U', 13, u32)
4184
4185static int do_usbdevfs_reapurb(unsigned int fd, unsigned int cmd, unsigned long arg)
4186{
4187 mm_segment_t old_fs;
4188 void *kptr;
4189 int err;
4190
4191 old_fs = get_fs();
4192 set_fs(KERNEL_DS);
4193 err = sys_ioctl(fd,
4194 (cmd == USBDEVFS_REAPURB32 ?
4195 USBDEVFS_REAPURB :
4196 USBDEVFS_REAPURBNDELAY),
4197 (unsigned long) &kptr);
4198 set_fs(old_fs);
4199
4200 if (err >= 0 &&
4201 put_user(((u32)(long)kptr), (u32 *) A(arg)))
4202 err = -EFAULT;
4203
4204 return err;
4205}
4206
4207struct usbdevfs_disconnectsignal32 {
4208 unsigned int signr;
4209 u32 context;
4210};
4211
4212#define USBDEVFS_DISCSIGNAL32 _IOR('U', 14, struct usbdevfs_disconnectsignal32)
4213
4214static int do_usbdevfs_discsignal(unsigned int fd, unsigned int cmd, unsigned long arg)
4215{
4216 struct usbdevfs_disconnectsignal kdis;
4217 struct usbdevfs_disconnectsignal32 *udis;
4218 mm_segment_t old_fs;
4219 u32 uctx;
4220 int err;
4221
4222 udis = (struct usbdevfs_disconnectsignal32 *) arg;
4223
4224 if (get_user(kdis.signr, &udis->signr) ||
4225 __get_user(uctx, &udis->context))
4226 return -EFAULT;
4227
4228 kdis.context = (void *) (long)uctx;
4229
4230 old_fs = get_fs();
4231 set_fs(KERNEL_DS);
4232 err = sys_ioctl(fd, USBDEVFS_DISCSIGNAL, (unsigned long) &kdis);
4233 set_fs(old_fs);
4234
4235 return err;
4236}
4237
4238struct mtd_oob_buf32 {
4239 u32 start;
4240 u32 length;
4241 u32 ptr;
4242};
4243
4244#define MEMWRITEOOB32 _IOWR('M',3,struct mtd_oob_buf32)
4245#define MEMREADOOB32 _IOWR('M',4,struct mtd_oob_buf32)
4246
4247static int mtd_rw_oob(unsigned int fd, unsigned int cmd, unsigned long arg)
4248{
4249 struct mtd_oob_buf *buf = alloc_user_space(sizeof(*buf));
4250 struct mtd_oob_buf32 *buf32 = (struct mtd_oob_buf32 *) arg;
4251 u32 data;
4252 char *datap;
4253 unsigned int real_cmd;
4254 int err;
4255
4256 real_cmd = (cmd == MEMREADOOB32) ?
4257 MEMREADOOB : MEMWRITEOOB;
4258
4259 if (copy_in_user(&buf->start, &buf32->start,
4260 2 * sizeof(u32)) ||
4261 get_user(data, &buf32->ptr))
4262 return -EFAULT;
4263 datap = (void *) (unsigned long) data;
4264 if (put_user(datap, &buf->ptr))
4265 return -EFAULT;
4266
4267 err = sys_ioctl(fd, real_cmd, (unsigned long) buf);
4268
4269 if (!err) {
4270 if (copy_in_user(&buf32->start, &buf->start,
4271 2 * sizeof(u32)))
4272 err = -EFAULT;
4273 }
4274
4275 return err;
4276}
4277
4278
4279#define BLKELVGET_32 _IOR(0x12,106,int)
4280#define BLKELVSET_32 _IOW(0x12,107,int)
4281#define BLKBSZGET_32 _IOR(0x12,112,int)
4282#define BLKBSZSET_32 _IOW(0x12,113,int)
4283#define BLKGETSIZE64_32 _IOR(0x12,114,int)
4284
4285static int do_blkelvget(unsigned int fd, unsigned int cmd, unsigned long arg)
4286{
4287 return sys_ioctl(fd, BLKELVGET, arg);
4288}
4289
4290static int do_blkelvset(unsigned int fd, unsigned int cmd, unsigned long arg)
4291{
4292 return sys_ioctl(fd, BLKELVSET, arg);
4293}
4294
4295static int do_blkbszget(unsigned int fd, unsigned int cmd, unsigned long arg)
4296{
4297 return sys_ioctl(fd, BLKBSZGET, arg);
4298}
4299
4300static int do_blkbszset(unsigned int fd, unsigned int cmd, unsigned long arg)
4301{
4302 return sys_ioctl(fd, BLKBSZSET, arg);
4303}
4304
4305static int do_blkgetsize64(unsigned int fd, unsigned int cmd,
4306 unsigned long arg)
4307{
4308 return sys_ioctl(fd, BLKGETSIZE64, arg);
4309}
4310
4311
4312#define HCIUARTSETPROTO _IOW('U', 200, int)
4313#define HCIUARTGETPROTO _IOR('U', 201, int)
4314
4315#define BNEPCONNADD _IOW('B', 200, int)
4316#define BNEPCONNDEL _IOW('B', 201, int)
4317#define BNEPGETCONNLIST _IOR('B', 210, int)
4318#define BNEPGETCONNINFO _IOR('B', 211, int)
4319
4320#define CMTPCONNADD _IOW('C', 200, int)
4321#define CMTPCONNDEL _IOW('C', 201, int)
4322#define CMTPGETCONNLIST _IOR('C', 210, int)
4323#define CMTPGETCONNINFO _IOR('C', 211, int)
4324
4325struct ioctl_trans {
4326 unsigned int cmd;
4327 unsigned int handler;
4328 unsigned int next;
4329};
4330
4331#define COMPATIBLE_IOCTL(cmd) asm volatile(".word %0, sys_ioctl, 0" : : "i" (cmd));
4332#define HANDLE_IOCTL(cmd,handler) asm volatile(".word %0, %1, 0" : : "i" (cmd), "i" (handler));
4333#define IOCTL_TABLE_START void ioctl32_foo(void) { asm volatile(".data\nioctl_translations:");
4334#define IOCTL_TABLE_END asm volatile("\nioctl_translations_end:\n\t.previous"); }
4335
4336IOCTL_TABLE_START
4337
4338
4339
4340
4341COMPATIBLE_IOCTL(TCGETA)
4342COMPATIBLE_IOCTL(TCSETA)
4343COMPATIBLE_IOCTL(TCSETAW)
4344COMPATIBLE_IOCTL(TCSETAF)
4345COMPATIBLE_IOCTL(TCSBRK)
4346COMPATIBLE_IOCTL(TCSBRKP)
4347COMPATIBLE_IOCTL(TCXONC)
4348COMPATIBLE_IOCTL(TCFLSH)
4349COMPATIBLE_IOCTL(TCGETS)
4350COMPATIBLE_IOCTL(TCSETS)
4351COMPATIBLE_IOCTL(TCSETSW)
4352COMPATIBLE_IOCTL(TCSETSF)
4353COMPATIBLE_IOCTL(TIOCLINUX)
4354COMPATIBLE_IOCTL(TIOCSTART)
4355COMPATIBLE_IOCTL(TIOCSTOP)
4356
4357COMPATIBLE_IOCTL(TIOCGETD)
4358COMPATIBLE_IOCTL(TIOCSETD)
4359COMPATIBLE_IOCTL(TIOCEXCL)
4360COMPATIBLE_IOCTL(TIOCNXCL)
4361COMPATIBLE_IOCTL(TIOCCONS)
4362COMPATIBLE_IOCTL(TIOCGSOFTCAR)
4363COMPATIBLE_IOCTL(TIOCSSOFTCAR)
4364COMPATIBLE_IOCTL(TIOCSWINSZ)
4365COMPATIBLE_IOCTL(TIOCGWINSZ)
4366COMPATIBLE_IOCTL(TIOCMGET)
4367COMPATIBLE_IOCTL(TIOCMBIC)
4368COMPATIBLE_IOCTL(TIOCMBIS)
4369COMPATIBLE_IOCTL(TIOCMSET)
4370COMPATIBLE_IOCTL(TIOCPKT)
4371COMPATIBLE_IOCTL(TIOCNOTTY)
4372COMPATIBLE_IOCTL(TIOCSTI)
4373COMPATIBLE_IOCTL(TIOCOUTQ)
4374COMPATIBLE_IOCTL(TIOCSPGRP)
4375COMPATIBLE_IOCTL(TIOCGPGRP)
4376COMPATIBLE_IOCTL(TIOCSCTTY)
4377COMPATIBLE_IOCTL(TIOCGPTN)
4378COMPATIBLE_IOCTL(TIOCSPTLCK)
4379COMPATIBLE_IOCTL(TIOCGSERIAL)
4380COMPATIBLE_IOCTL(TIOCSSERIAL)
4381COMPATIBLE_IOCTL(TIOCSERGETLSR)
4382COMPATIBLE_IOCTL(TIOCSLTC)
4383
4384COMPATIBLE_IOCTL(FBIOGTYPE)
4385COMPATIBLE_IOCTL(FBIOSATTR)
4386COMPATIBLE_IOCTL(FBIOGATTR)
4387COMPATIBLE_IOCTL(FBIOSVIDEO)
4388COMPATIBLE_IOCTL(FBIOGVIDEO)
4389COMPATIBLE_IOCTL(FBIOGCURSOR32)
4390COMPATIBLE_IOCTL(FBIOSCURPOS)
4391COMPATIBLE_IOCTL(FBIOGCURPOS)
4392COMPATIBLE_IOCTL(FBIOGCURMAX)
4393COMPATIBLE_IOCTL(FBIOGET_VSCREENINFO)
4394COMPATIBLE_IOCTL(FBIOPUT_VSCREENINFO)
4395COMPATIBLE_IOCTL(FBIOPAN_DISPLAY)
4396COMPATIBLE_IOCTL(FBIOGET_FCURSORINFO)
4397COMPATIBLE_IOCTL(FBIOGET_VCURSORINFO)
4398COMPATIBLE_IOCTL(FBIOPUT_VCURSORINFO)
4399COMPATIBLE_IOCTL(FBIOGET_CURSORSTATE)
4400COMPATIBLE_IOCTL(FBIOPUT_CURSORSTATE)
4401COMPATIBLE_IOCTL(FBIOGET_CON2FBMAP)
4402COMPATIBLE_IOCTL(FBIOPUT_CON2FBMAP)
4403
4404COMPATIBLE_IOCTL(FIOCLEX)
4405COMPATIBLE_IOCTL(FIONCLEX)
4406COMPATIBLE_IOCTL(FIOASYNC)
4407COMPATIBLE_IOCTL(FIONBIO)
4408COMPATIBLE_IOCTL(FIONREAD)
4409
4410COMPATIBLE_IOCTL(FIBMAP)
4411COMPATIBLE_IOCTL(FIGETBSZ)
4412
4413
4414
4415COMPATIBLE_IOCTL(HDIO_GET_IDENTITY)
4416COMPATIBLE_IOCTL(HDIO_SET_DMA)
4417COMPATIBLE_IOCTL(HDIO_SET_KEEPSETTINGS)
4418COMPATIBLE_IOCTL(HDIO_SET_UNMASKINTR)
4419COMPATIBLE_IOCTL(HDIO_SET_NOWERR)
4420COMPATIBLE_IOCTL(HDIO_SET_32BIT)
4421COMPATIBLE_IOCTL(HDIO_SET_MULTCOUNT)
4422COMPATIBLE_IOCTL(HDIO_DRIVE_CMD)
4423COMPATIBLE_IOCTL(HDIO_DRIVE_TASK)
4424COMPATIBLE_IOCTL(HDIO_SET_PIO_MODE)
4425COMPATIBLE_IOCTL(HDIO_SCAN_HWIF)
4426COMPATIBLE_IOCTL(HDIO_SET_NICE)
4427
4428COMPATIBLE_IOCTL(FDMSGON)
4429COMPATIBLE_IOCTL(FDMSGOFF)
4430COMPATIBLE_IOCTL(FDSETEMSGTRESH)
4431COMPATIBLE_IOCTL(FDFLUSH)
4432COMPATIBLE_IOCTL(FDWERRORCLR)
4433COMPATIBLE_IOCTL(FDSETMAXERRS)
4434COMPATIBLE_IOCTL(FDGETMAXERRS)
4435COMPATIBLE_IOCTL(FDGETDRVTYP)
4436COMPATIBLE_IOCTL(FDEJECT)
4437COMPATIBLE_IOCTL(FDCLRPRM)
4438COMPATIBLE_IOCTL(FDFMTBEG)
4439COMPATIBLE_IOCTL(FDFMTEND)
4440COMPATIBLE_IOCTL(FDRESET)
4441COMPATIBLE_IOCTL(FDTWADDLE)
4442COMPATIBLE_IOCTL(FDFMTTRK)
4443COMPATIBLE_IOCTL(FDRAWCMD)
4444
4445COMPATIBLE_IOCTL(BLKROSET)
4446COMPATIBLE_IOCTL(BLKROGET)
4447COMPATIBLE_IOCTL(BLKRRPART)
4448COMPATIBLE_IOCTL(BLKFLSBUF)
4449COMPATIBLE_IOCTL(BLKRASET)
4450COMPATIBLE_IOCTL(BLKFRASET)
4451COMPATIBLE_IOCTL(BLKSECTSET)
4452COMPATIBLE_IOCTL(BLKSSZGET)
4453
4454COMPATIBLE_IOCTL(RAID_VERSION)
4455COMPATIBLE_IOCTL(GET_ARRAY_INFO)
4456COMPATIBLE_IOCTL(GET_DISK_INFO)
4457COMPATIBLE_IOCTL(PRINT_RAID_DEBUG)
4458COMPATIBLE_IOCTL(CLEAR_ARRAY)
4459COMPATIBLE_IOCTL(ADD_NEW_DISK)
4460COMPATIBLE_IOCTL(HOT_REMOVE_DISK)
4461COMPATIBLE_IOCTL(SET_ARRAY_INFO)
4462COMPATIBLE_IOCTL(SET_DISK_INFO)
4463COMPATIBLE_IOCTL(WRITE_RAID_INFO)
4464COMPATIBLE_IOCTL(UNPROTECT_ARRAY)
4465COMPATIBLE_IOCTL(PROTECT_ARRAY)
4466COMPATIBLE_IOCTL(HOT_ADD_DISK)
4467COMPATIBLE_IOCTL(SET_DISK_FAULTY)
4468COMPATIBLE_IOCTL(RUN_ARRAY)
4469COMPATIBLE_IOCTL(START_ARRAY)
4470COMPATIBLE_IOCTL(STOP_ARRAY)
4471COMPATIBLE_IOCTL(STOP_ARRAY_RO)
4472COMPATIBLE_IOCTL(RESTART_ARRAY_RW)
4473COMPATIBLE_IOCTL(RAID_AUTORUN)
4474
4475
4476COMPATIBLE_IOCTL(PIO_FONT)
4477COMPATIBLE_IOCTL(GIO_FONT)
4478COMPATIBLE_IOCTL(KDSIGACCEPT)
4479COMPATIBLE_IOCTL(KDGETKEYCODE)
4480COMPATIBLE_IOCTL(KDSETKEYCODE)
4481COMPATIBLE_IOCTL(KIOCSOUND)
4482COMPATIBLE_IOCTL(KDMKTONE)
4483COMPATIBLE_IOCTL(KDGKBTYPE)
4484COMPATIBLE_IOCTL(KDSETMODE)
4485COMPATIBLE_IOCTL(KDGETMODE)
4486COMPATIBLE_IOCTL(KDSKBMODE)
4487COMPATIBLE_IOCTL(KDGKBMODE)
4488COMPATIBLE_IOCTL(KDSKBMETA)
4489COMPATIBLE_IOCTL(KDGKBMETA)
4490COMPATIBLE_IOCTL(KDGKBENT)
4491COMPATIBLE_IOCTL(KDSKBENT)
4492COMPATIBLE_IOCTL(KDGKBSENT)
4493COMPATIBLE_IOCTL(KDSKBSENT)
4494COMPATIBLE_IOCTL(KDGKBDIACR)
4495COMPATIBLE_IOCTL(KDKBDREP)
4496COMPATIBLE_IOCTL(KDSKBDIACR)
4497COMPATIBLE_IOCTL(KDGKBLED)
4498COMPATIBLE_IOCTL(KDSKBLED)
4499COMPATIBLE_IOCTL(KDGETLED)
4500COMPATIBLE_IOCTL(KDSETLED)
4501COMPATIBLE_IOCTL(GIO_SCRNMAP)
4502COMPATIBLE_IOCTL(PIO_SCRNMAP)
4503COMPATIBLE_IOCTL(GIO_UNISCRNMAP)
4504COMPATIBLE_IOCTL(PIO_UNISCRNMAP)
4505COMPATIBLE_IOCTL(PIO_FONTRESET)
4506COMPATIBLE_IOCTL(PIO_UNIMAPCLR)
4507
4508COMPATIBLE_IOCTL(KIOCTYPE)
4509COMPATIBLE_IOCTL(KIOCLAYOUT)
4510COMPATIBLE_IOCTL(KIOCGTRANS)
4511COMPATIBLE_IOCTL(KIOCTRANS)
4512COMPATIBLE_IOCTL(KIOCCMD)
4513COMPATIBLE_IOCTL(KIOCSDIRECT)
4514COMPATIBLE_IOCTL(KIOCSLED)
4515COMPATIBLE_IOCTL(KIOCGLED)
4516COMPATIBLE_IOCTL(KIOCSRATE)
4517COMPATIBLE_IOCTL(KIOCGRATE)
4518
4519COMPATIBLE_IOCTL(SCSI_IOCTL_GET_IDLUN)
4520COMPATIBLE_IOCTL(SCSI_IOCTL_PROBE_HOST)
4521COMPATIBLE_IOCTL(SCSI_IOCTL_GET_PCI)
4522COMPATIBLE_IOCTL(SCSI_IOCTL_DOORLOCK)
4523COMPATIBLE_IOCTL(SCSI_IOCTL_DOORUNLOCK)
4524COMPATIBLE_IOCTL(SCSI_IOCTL_TEST_UNIT_READY)
4525COMPATIBLE_IOCTL(SCSI_IOCTL_TAGGED_ENABLE)
4526COMPATIBLE_IOCTL(SCSI_IOCTL_TAGGED_DISABLE)
4527COMPATIBLE_IOCTL(SCSI_IOCTL_GET_BUS_NUMBER)
4528COMPATIBLE_IOCTL(SCSI_IOCTL_SEND_COMMAND)
4529
4530COMPATIBLE_IOCTL(TUNSETNOCSUM)
4531COMPATIBLE_IOCTL(TUNSETDEBUG)
4532COMPATIBLE_IOCTL(TUNSETPERSIST)
4533COMPATIBLE_IOCTL(TUNSETOWNER)
4534
4535COMPATIBLE_IOCTL(VT_SETMODE)
4536COMPATIBLE_IOCTL(VT_GETMODE)
4537COMPATIBLE_IOCTL(VT_GETSTATE)
4538COMPATIBLE_IOCTL(VT_OPENQRY)
4539COMPATIBLE_IOCTL(VT_ACTIVATE)
4540COMPATIBLE_IOCTL(VT_WAITACTIVE)
4541COMPATIBLE_IOCTL(VT_RELDISP)
4542COMPATIBLE_IOCTL(VT_DISALLOCATE)
4543COMPATIBLE_IOCTL(VT_RESIZE)
4544COMPATIBLE_IOCTL(VT_RESIZEX)
4545COMPATIBLE_IOCTL(VT_LOCKSWITCH)
4546COMPATIBLE_IOCTL(VT_UNLOCKSWITCH)
4547
4548COMPATIBLE_IOCTL(VUIDSFORMAT)
4549COMPATIBLE_IOCTL(VUIDGFORMAT)
4550
4551COMPATIBLE_IOCTL(VIDIOCGCAP)
4552COMPATIBLE_IOCTL(VIDIOCGCHAN)
4553COMPATIBLE_IOCTL(VIDIOCSCHAN)
4554COMPATIBLE_IOCTL(VIDIOCGPICT)
4555COMPATIBLE_IOCTL(VIDIOCSPICT)
4556COMPATIBLE_IOCTL(VIDIOCCAPTURE)
4557COMPATIBLE_IOCTL(VIDIOCKEY)
4558COMPATIBLE_IOCTL(VIDIOCGAUDIO)
4559COMPATIBLE_IOCTL(VIDIOCSAUDIO)
4560COMPATIBLE_IOCTL(VIDIOCSYNC)
4561COMPATIBLE_IOCTL(VIDIOCMCAPTURE)
4562COMPATIBLE_IOCTL(VIDIOCGMBUF)
4563COMPATIBLE_IOCTL(VIDIOCGUNIT)
4564COMPATIBLE_IOCTL(VIDIOCGCAPTURE)
4565COMPATIBLE_IOCTL(VIDIOCSCAPTURE)
4566
4567COMPATIBLE_IOCTL(_IOW('v', BASE_VIDIOCPRIVATE+0, char [256]))
4568COMPATIBLE_IOCTL(_IOR('v', BASE_VIDIOCPRIVATE+1, char [256]))
4569COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int))
4570COMPATIBLE_IOCTL(_IOW('v' , BASE_VIDIOCPRIVATE+3, char [16]))
4571COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+4, int))
4572COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+5, int))
4573COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+6, int))
4574COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+7, int))
4575
4576COMPATIBLE_IOCTL(_IOR('p', 20, int[7]))
4577COMPATIBLE_IOCTL(_IOW('p', 21, int[7]))
4578COMPATIBLE_IOCTL(RTC_AIE_ON)
4579COMPATIBLE_IOCTL(RTC_AIE_OFF)
4580COMPATIBLE_IOCTL(RTC_UIE_ON)
4581COMPATIBLE_IOCTL(RTC_UIE_OFF)
4582COMPATIBLE_IOCTL(RTC_PIE_ON)
4583COMPATIBLE_IOCTL(RTC_PIE_OFF)
4584COMPATIBLE_IOCTL(RTC_WIE_ON)
4585COMPATIBLE_IOCTL(RTC_WIE_OFF)
4586COMPATIBLE_IOCTL(RTC_ALM_SET)
4587COMPATIBLE_IOCTL(RTC_ALM_READ)
4588COMPATIBLE_IOCTL(RTC_RD_TIME)
4589COMPATIBLE_IOCTL(RTC_SET_TIME)
4590COMPATIBLE_IOCTL(RTC_WKALM_SET)
4591COMPATIBLE_IOCTL(RTC_WKALM_RD)
4592COMPATIBLE_IOCTL(ENVCTRL_RD_WARNING_TEMPERATURE)
4593COMPATIBLE_IOCTL(ENVCTRL_RD_SHUTDOWN_TEMPERATURE)
4594COMPATIBLE_IOCTL(ENVCTRL_RD_CPU_TEMPERATURE)
4595COMPATIBLE_IOCTL(ENVCTRL_RD_FAN_STATUS)
4596COMPATIBLE_IOCTL(ENVCTRL_RD_VOLTAGE_STATUS)
4597COMPATIBLE_IOCTL(ENVCTRL_RD_SCSI_TEMPERATURE)
4598COMPATIBLE_IOCTL(ENVCTRL_RD_ETHERNET_TEMPERATURE)
4599COMPATIBLE_IOCTL(ENVCTRL_RD_MTHRBD_TEMPERATURE)
4600COMPATIBLE_IOCTL(ENVCTRL_RD_CPU_VOLTAGE)
4601COMPATIBLE_IOCTL(ENVCTRL_RD_GLOBALADDRESS)
4602
4603COMPATIBLE_IOCTL(D7SIOCWR)
4604COMPATIBLE_IOCTL(D7SIOCTM)
4605
4606COMPATIBLE_IOCTL(MTIOCTOP)
4607
4608
4609
4610COMPATIBLE_IOCTL(OPROMGETOPT)
4611COMPATIBLE_IOCTL(OPROMSETOPT)
4612COMPATIBLE_IOCTL(OPROMNXTOPT)
4613COMPATIBLE_IOCTL(OPROMSETOPT2)
4614COMPATIBLE_IOCTL(OPROMNEXT)
4615COMPATIBLE_IOCTL(OPROMCHILD)
4616COMPATIBLE_IOCTL(OPROMGETPROP)
4617COMPATIBLE_IOCTL(OPROMNXTPROP)
4618COMPATIBLE_IOCTL(OPROMU2P)
4619COMPATIBLE_IOCTL(OPROMGETCONS)
4620COMPATIBLE_IOCTL(OPROMGETFBNAME)
4621COMPATIBLE_IOCTL(OPROMGETBOOTARGS)
4622COMPATIBLE_IOCTL(OPROMSETCUR)
4623COMPATIBLE_IOCTL(OPROMPCI2NODE)
4624COMPATIBLE_IOCTL(OPROMPATH2NODE)
4625
4626COMPATIBLE_IOCTL(FIOSETOWN)
4627COMPATIBLE_IOCTL(SIOCSPGRP)
4628COMPATIBLE_IOCTL(FIOGETOWN)
4629COMPATIBLE_IOCTL(SIOCGPGRP)
4630COMPATIBLE_IOCTL(SIOCATMARK)
4631COMPATIBLE_IOCTL(SIOCSIFLINK)
4632COMPATIBLE_IOCTL(SIOCSIFENCAP)
4633COMPATIBLE_IOCTL(SIOCGIFENCAP)
4634COMPATIBLE_IOCTL(SIOCSIFBR)
4635COMPATIBLE_IOCTL(SIOCGIFBR)
4636COMPATIBLE_IOCTL(SIOCSARP)
4637COMPATIBLE_IOCTL(SIOCGARP)
4638COMPATIBLE_IOCTL(SIOCDARP)
4639COMPATIBLE_IOCTL(SIOCSRARP)
4640COMPATIBLE_IOCTL(SIOCGRARP)
4641COMPATIBLE_IOCTL(SIOCDRARP)
4642COMPATIBLE_IOCTL(SIOCADDDLCI)
4643COMPATIBLE_IOCTL(SIOCDELDLCI)
4644COMPATIBLE_IOCTL(SIOCGMIIPHY)
4645COMPATIBLE_IOCTL(SIOCGMIIREG)
4646COMPATIBLE_IOCTL(SIOCSMIIREG)
4647COMPATIBLE_IOCTL(SIOCGIFVLAN)
4648COMPATIBLE_IOCTL(SIOCSIFVLAN)
4649
4650COMPATIBLE_IOCTL(SG_SET_TIMEOUT)
4651COMPATIBLE_IOCTL(SG_GET_TIMEOUT)
4652COMPATIBLE_IOCTL(SG_EMULATED_HOST)
4653COMPATIBLE_IOCTL(SG_SET_TRANSFORM)
4654COMPATIBLE_IOCTL(SG_GET_TRANSFORM)
4655COMPATIBLE_IOCTL(SG_SET_RESERVED_SIZE)
4656COMPATIBLE_IOCTL(SG_GET_RESERVED_SIZE)
4657COMPATIBLE_IOCTL(SG_GET_SCSI_ID)
4658COMPATIBLE_IOCTL(SG_SET_FORCE_LOW_DMA)
4659COMPATIBLE_IOCTL(SG_GET_LOW_DMA)
4660COMPATIBLE_IOCTL(SG_SET_FORCE_PACK_ID)
4661COMPATIBLE_IOCTL(SG_GET_PACK_ID)
4662COMPATIBLE_IOCTL(SG_GET_NUM_WAITING)
4663COMPATIBLE_IOCTL(SG_SET_DEBUG)
4664COMPATIBLE_IOCTL(SG_GET_SG_TABLESIZE)
4665COMPATIBLE_IOCTL(SG_GET_COMMAND_Q)
4666COMPATIBLE_IOCTL(SG_SET_COMMAND_Q)
4667COMPATIBLE_IOCTL(SG_GET_VERSION_NUM)
4668COMPATIBLE_IOCTL(SG_NEXT_CMD_LEN)
4669COMPATIBLE_IOCTL(SG_SCSI_RESET)
4670COMPATIBLE_IOCTL(SG_GET_REQUEST_TABLE)
4671COMPATIBLE_IOCTL(SG_SET_KEEP_ORPHAN)
4672COMPATIBLE_IOCTL(SG_GET_KEEP_ORPHAN)
4673
4674COMPATIBLE_IOCTL(PPPIOCGFLAGS)
4675COMPATIBLE_IOCTL(PPPIOCSFLAGS)
4676COMPATIBLE_IOCTL(PPPIOCGASYNCMAP)
4677COMPATIBLE_IOCTL(PPPIOCSASYNCMAP)
4678COMPATIBLE_IOCTL(PPPIOCGUNIT)
4679COMPATIBLE_IOCTL(PPPIOCGRASYNCMAP)
4680COMPATIBLE_IOCTL(PPPIOCSRASYNCMAP)
4681COMPATIBLE_IOCTL(PPPIOCGMRU)
4682COMPATIBLE_IOCTL(PPPIOCSMRU)
4683COMPATIBLE_IOCTL(PPPIOCSMAXCID)
4684COMPATIBLE_IOCTL(PPPIOCGXASYNCMAP)
4685COMPATIBLE_IOCTL(PPPIOCSXASYNCMAP)
4686COMPATIBLE_IOCTL(PPPIOCXFERUNIT)
4687
4688COMPATIBLE_IOCTL(PPPIOCGNPMODE)
4689COMPATIBLE_IOCTL(PPPIOCSNPMODE)
4690
4691
4692COMPATIBLE_IOCTL(PPPIOCGDEBUG)
4693COMPATIBLE_IOCTL(PPPIOCSDEBUG)
4694
4695COMPATIBLE_IOCTL(PPPIOCNEWUNIT)
4696COMPATIBLE_IOCTL(PPPIOCATTACH)
4697COMPATIBLE_IOCTL(PPPIOCDETACH)
4698COMPATIBLE_IOCTL(PPPIOCSMRRU)
4699COMPATIBLE_IOCTL(PPPIOCCONNECT)
4700COMPATIBLE_IOCTL(PPPIOCDISCONN)
4701COMPATIBLE_IOCTL(PPPIOCATTCHAN)
4702COMPATIBLE_IOCTL(PPPIOCGCHAN)
4703
4704COMPATIBLE_IOCTL(LPGETSTATUS)
4705
4706COMPATIBLE_IOCTL(PPPOEIOCSFWD)
4707COMPATIBLE_IOCTL(PPPOEIOCDFWD)
4708
4709COMPATIBLE_IOCTL(CDROMPAUSE)
4710COMPATIBLE_IOCTL(CDROMRESUME)
4711COMPATIBLE_IOCTL(CDROMPLAYMSF)
4712COMPATIBLE_IOCTL(CDROMPLAYTRKIND)
4713COMPATIBLE_IOCTL(CDROMREADTOCHDR)
4714COMPATIBLE_IOCTL(CDROMREADTOCENTRY)
4715COMPATIBLE_IOCTL(CDROMSTOP)
4716COMPATIBLE_IOCTL(CDROMSTART)
4717COMPATIBLE_IOCTL(CDROMEJECT)
4718COMPATIBLE_IOCTL(CDROMVOLCTRL)
4719COMPATIBLE_IOCTL(CDROMSUBCHNL)
4720COMPATIBLE_IOCTL(CDROMEJECT_SW)
4721COMPATIBLE_IOCTL(CDROMMULTISESSION)
4722COMPATIBLE_IOCTL(CDROM_GET_MCN)
4723COMPATIBLE_IOCTL(CDROMRESET)
4724COMPATIBLE_IOCTL(CDROMVOLREAD)
4725COMPATIBLE_IOCTL(CDROMSEEK)
4726COMPATIBLE_IOCTL(CDROMPLAYBLK)
4727COMPATIBLE_IOCTL(CDROMCLOSETRAY)
4728COMPATIBLE_IOCTL(CDROM_SET_OPTIONS)
4729COMPATIBLE_IOCTL(CDROM_CLEAR_OPTIONS)
4730COMPATIBLE_IOCTL(CDROM_SELECT_SPEED)
4731COMPATIBLE_IOCTL(CDROM_SELECT_DISC)
4732COMPATIBLE_IOCTL(CDROM_MEDIA_CHANGED)
4733COMPATIBLE_IOCTL(CDROM_DRIVE_STATUS)
4734COMPATIBLE_IOCTL(CDROM_DISC_STATUS)
4735COMPATIBLE_IOCTL(CDROM_CHANGER_NSLOTS)
4736COMPATIBLE_IOCTL(CDROM_LOCKDOOR)
4737COMPATIBLE_IOCTL(CDROM_DEBUG)
4738COMPATIBLE_IOCTL(CDROM_GET_CAPABILITY)
4739
4740
4741
4742
4743COMPATIBLE_IOCTL(CDROMREADMODE2)
4744COMPATIBLE_IOCTL(CDROMREADMODE1)
4745COMPATIBLE_IOCTL(CDROMREADRAW)
4746COMPATIBLE_IOCTL(CDROMREADCOOKED)
4747COMPATIBLE_IOCTL(CDROMREADALL)
4748
4749COMPATIBLE_IOCTL(DVD_READ_STRUCT)
4750COMPATIBLE_IOCTL(DVD_WRITE_STRUCT)
4751COMPATIBLE_IOCTL(DVD_AUTH)
4752
4753COMPATIBLE_IOCTL(LOOP_SET_FD)
4754COMPATIBLE_IOCTL(LOOP_CLR_FD)
4755
4756COMPATIBLE_IOCTL(AUDIO_GETINFO)
4757COMPATIBLE_IOCTL(AUDIO_SETINFO)
4758COMPATIBLE_IOCTL(AUDIO_DRAIN)
4759COMPATIBLE_IOCTL(AUDIO_GETDEV)
4760COMPATIBLE_IOCTL(AUDIO_GETDEV_SUNOS)
4761COMPATIBLE_IOCTL(AUDIO_FLUSH)
4762
4763COMPATIBLE_IOCTL(SNDCTL_SEQ_RESET)
4764COMPATIBLE_IOCTL(SNDCTL_SEQ_SYNC)
4765COMPATIBLE_IOCTL(SNDCTL_SYNTH_INFO)
4766COMPATIBLE_IOCTL(SNDCTL_SEQ_CTRLRATE)
4767COMPATIBLE_IOCTL(SNDCTL_SEQ_GETOUTCOUNT)
4768COMPATIBLE_IOCTL(SNDCTL_SEQ_GETINCOUNT)
4769COMPATIBLE_IOCTL(SNDCTL_SEQ_PERCMODE)
4770COMPATIBLE_IOCTL(SNDCTL_FM_LOAD_INSTR)
4771COMPATIBLE_IOCTL(SNDCTL_SEQ_TESTMIDI)
4772COMPATIBLE_IOCTL(SNDCTL_SEQ_RESETSAMPLES)
4773COMPATIBLE_IOCTL(SNDCTL_SEQ_NRSYNTHS)
4774COMPATIBLE_IOCTL(SNDCTL_SEQ_NRMIDIS)
4775COMPATIBLE_IOCTL(SNDCTL_MIDI_INFO)
4776COMPATIBLE_IOCTL(SNDCTL_SEQ_THRESHOLD)
4777COMPATIBLE_IOCTL(SNDCTL_SYNTH_MEMAVL)
4778COMPATIBLE_IOCTL(SNDCTL_FM_4OP_ENABLE)
4779COMPATIBLE_IOCTL(SNDCTL_SEQ_PANIC)
4780COMPATIBLE_IOCTL(SNDCTL_SEQ_OUTOFBAND)
4781COMPATIBLE_IOCTL(SNDCTL_SEQ_GETTIME)
4782COMPATIBLE_IOCTL(SNDCTL_SYNTH_ID)
4783COMPATIBLE_IOCTL(SNDCTL_SYNTH_CONTROL)
4784COMPATIBLE_IOCTL(SNDCTL_SYNTH_REMOVESAMPLE)
4785
4786COMPATIBLE_IOCTL(SNDCTL_TMR_TIMEBASE)
4787COMPATIBLE_IOCTL(SNDCTL_TMR_START)
4788COMPATIBLE_IOCTL(SNDCTL_TMR_STOP)
4789COMPATIBLE_IOCTL(SNDCTL_TMR_CONTINUE)
4790COMPATIBLE_IOCTL(SNDCTL_TMR_TEMPO)
4791COMPATIBLE_IOCTL(SNDCTL_TMR_SOURCE)
4792COMPATIBLE_IOCTL(SNDCTL_TMR_METRONOME)
4793COMPATIBLE_IOCTL(SNDCTL_TMR_SELECT)
4794
4795COMPATIBLE_IOCTL(SNDCTL_MIDI_PRETIME)
4796COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUMODE)
4797COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUCMD)
4798
4799COMPATIBLE_IOCTL(SNDCTL_DSP_RESET)
4800COMPATIBLE_IOCTL(SNDCTL_DSP_SYNC)
4801COMPATIBLE_IOCTL(SNDCTL_DSP_SPEED)
4802COMPATIBLE_IOCTL(SNDCTL_DSP_STEREO)
4803COMPATIBLE_IOCTL(SNDCTL_DSP_GETBLKSIZE)
4804COMPATIBLE_IOCTL(SNDCTL_DSP_CHANNELS)
4805COMPATIBLE_IOCTL(SOUND_PCM_WRITE_FILTER)
4806COMPATIBLE_IOCTL(SNDCTL_DSP_POST)
4807COMPATIBLE_IOCTL(SNDCTL_DSP_SUBDIVIDE)
4808COMPATIBLE_IOCTL(SNDCTL_DSP_SETFRAGMENT)
4809COMPATIBLE_IOCTL(SNDCTL_DSP_GETFMTS)
4810COMPATIBLE_IOCTL(SNDCTL_DSP_SETFMT)
4811COMPATIBLE_IOCTL(SNDCTL_DSP_GETOSPACE)
4812COMPATIBLE_IOCTL(SNDCTL_DSP_GETISPACE)
4813COMPATIBLE_IOCTL(SNDCTL_DSP_NONBLOCK)
4814COMPATIBLE_IOCTL(SNDCTL_DSP_GETCAPS)
4815COMPATIBLE_IOCTL(SNDCTL_DSP_GETTRIGGER)
4816COMPATIBLE_IOCTL(SNDCTL_DSP_SETTRIGGER)
4817COMPATIBLE_IOCTL(SNDCTL_DSP_GETIPTR)
4818COMPATIBLE_IOCTL(SNDCTL_DSP_GETOPTR)
4819
4820
4821COMPATIBLE_IOCTL(SNDCTL_DSP_SETSYNCRO)
4822COMPATIBLE_IOCTL(SNDCTL_DSP_SETDUPLEX)
4823COMPATIBLE_IOCTL(SNDCTL_DSP_GETODELAY)
4824COMPATIBLE_IOCTL(SNDCTL_DSP_PROFILE)
4825COMPATIBLE_IOCTL(SOUND_PCM_READ_RATE)
4826COMPATIBLE_IOCTL(SOUND_PCM_READ_CHANNELS)
4827COMPATIBLE_IOCTL(SOUND_PCM_READ_BITS)
4828COMPATIBLE_IOCTL(SOUND_PCM_READ_FILTER)
4829
4830COMPATIBLE_IOCTL(SNDCTL_COPR_RESET)
4831COMPATIBLE_IOCTL(SNDCTL_COPR_LOAD)
4832COMPATIBLE_IOCTL(SNDCTL_COPR_RDATA)
4833COMPATIBLE_IOCTL(SNDCTL_COPR_RCODE)
4834COMPATIBLE_IOCTL(SNDCTL_COPR_WDATA)
4835COMPATIBLE_IOCTL(SNDCTL_COPR_WCODE)
4836COMPATIBLE_IOCTL(SNDCTL_COPR_RUN)
4837COMPATIBLE_IOCTL(SNDCTL_COPR_HALT)
4838COMPATIBLE_IOCTL(SNDCTL_COPR_SENDMSG)
4839COMPATIBLE_IOCTL(SNDCTL_COPR_RCVMSG)
4840
4841COMPATIBLE_IOCTL(SOUND_MIXER_READ_VOLUME)
4842COMPATIBLE_IOCTL(SOUND_MIXER_READ_BASS)
4843COMPATIBLE_IOCTL(SOUND_MIXER_READ_TREBLE)
4844COMPATIBLE_IOCTL(SOUND_MIXER_READ_SYNTH)
4845COMPATIBLE_IOCTL(SOUND_MIXER_READ_PCM)
4846COMPATIBLE_IOCTL(SOUND_MIXER_READ_SPEAKER)
4847COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE)
4848COMPATIBLE_IOCTL(SOUND_MIXER_READ_MIC)
4849COMPATIBLE_IOCTL(SOUND_MIXER_READ_CD)
4850COMPATIBLE_IOCTL(SOUND_MIXER_READ_IMIX)
4851COMPATIBLE_IOCTL(SOUND_MIXER_READ_ALTPCM)
4852COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECLEV)
4853COMPATIBLE_IOCTL(SOUND_MIXER_READ_IGAIN)
4854COMPATIBLE_IOCTL(SOUND_MIXER_READ_OGAIN)
4855COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE1)
4856COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE2)
4857COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE3)
4858COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL1))
4859COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL2))
4860COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL3))
4861COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEIN))
4862COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEOUT))
4863COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_VIDEO))
4864COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_RADIO))
4865COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_MONITOR))
4866COMPATIBLE_IOCTL(SOUND_MIXER_READ_MUTE)
4867
4868
4869COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECSRC)
4870COMPATIBLE_IOCTL(SOUND_MIXER_READ_DEVMASK)
4871COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECMASK)
4872COMPATIBLE_IOCTL(SOUND_MIXER_READ_STEREODEVS)
4873COMPATIBLE_IOCTL(SOUND_MIXER_READ_CAPS)
4874COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_VOLUME)
4875COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_BASS)
4876COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_TREBLE)
4877COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SYNTH)
4878COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_PCM)
4879COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SPEAKER)
4880COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE)
4881COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MIC)
4882COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_CD)
4883COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IMIX)
4884COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_ALTPCM)
4885COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECLEV)
4886COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IGAIN)
4887COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_OGAIN)
4888COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE1)
4889COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE2)
4890COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE3)
4891COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL1))
4892COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL2))
4893COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL3))
4894COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEIN))
4895COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEOUT))
4896COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_VIDEO))
4897COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_RADIO))
4898COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_MONITOR))
4899COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MUTE)
4900
4901
4902COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECSRC)
4903COMPATIBLE_IOCTL(SOUND_MIXER_INFO)
4904COMPATIBLE_IOCTL(SOUND_OLD_MIXER_INFO)
4905COMPATIBLE_IOCTL(SOUND_MIXER_ACCESS)
4906COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE1)
4907COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE2)
4908COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE3)
4909COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE4)
4910COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE5)
4911COMPATIBLE_IOCTL(SOUND_MIXER_GETLEVELS)
4912COMPATIBLE_IOCTL(SOUND_MIXER_SETLEVELS)
4913COMPATIBLE_IOCTL(OSS_GETVERSION)
4914
4915COMPATIBLE_IOCTL(AUTOFS_IOC_READY)
4916COMPATIBLE_IOCTL(AUTOFS_IOC_FAIL)
4917COMPATIBLE_IOCTL(AUTOFS_IOC_CATATONIC)
4918COMPATIBLE_IOCTL(AUTOFS_IOC_PROTOVER)
4919COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE)
4920COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE_MULTI)
4921
4922COMPATIBLE_IOCTL(DEVFSDIOC_GET_PROTO_REV)
4923COMPATIBLE_IOCTL(DEVFSDIOC_SET_EVENT_MASK)
4924COMPATIBLE_IOCTL(DEVFSDIOC_RELEASE_EVENT_QUEUE)
4925COMPATIBLE_IOCTL(DEVFSDIOC_SET_DEBUG_MASK)
4926
4927COMPATIBLE_IOCTL(RAW_SETBIND)
4928COMPATIBLE_IOCTL(RAW_GETBIND)
4929
4930COMPATIBLE_IOCTL(SMB_IOC_NEWCONN)
4931
4932COMPATIBLE_IOCTL(NCP_IOC_CONN_LOGGED_IN)
4933COMPATIBLE_IOCTL(NCP_IOC_SIGN_INIT)
4934COMPATIBLE_IOCTL(NCP_IOC_SIGN_WANTED)
4935COMPATIBLE_IOCTL(NCP_IOC_SET_SIGN_WANTED)
4936COMPATIBLE_IOCTL(NCP_IOC_LOCKUNLOCK)
4937COMPATIBLE_IOCTL(NCP_IOC_GETROOT)
4938COMPATIBLE_IOCTL(NCP_IOC_SETROOT)
4939COMPATIBLE_IOCTL(NCP_IOC_GETCHARSETS)
4940COMPATIBLE_IOCTL(NCP_IOC_SETCHARSETS)
4941COMPATIBLE_IOCTL(NCP_IOC_GETDENTRYTTL)
4942COMPATIBLE_IOCTL(NCP_IOC_SETDENTRYTTL)
4943
4944COMPATIBLE_IOCTL(ATMSIGD_CTRL)
4945COMPATIBLE_IOCTL(ATMARPD_CTRL)
4946COMPATIBLE_IOCTL(ATMLEC_CTRL)
4947COMPATIBLE_IOCTL(ATMLEC_MCAST)
4948COMPATIBLE_IOCTL(ATMLEC_DATA)
4949COMPATIBLE_IOCTL(ATM_SETSC)
4950COMPATIBLE_IOCTL(SIOCSIFATMTCP)
4951COMPATIBLE_IOCTL(SIOCMKCLIP)
4952COMPATIBLE_IOCTL(ATMARP_MKIP)
4953COMPATIBLE_IOCTL(ATMARP_SETENTRY)
4954COMPATIBLE_IOCTL(ATMARP_ENCAP)
4955COMPATIBLE_IOCTL(ATMTCP_CREATE)
4956COMPATIBLE_IOCTL(ATMTCP_REMOVE)
4957COMPATIBLE_IOCTL(ATMMPC_CTRL)
4958COMPATIBLE_IOCTL(ATMMPC_DATA)
4959#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
4960
4961COMPATIBLE_IOCTL(VG_SET_EXTENDABLE)
4962COMPATIBLE_IOCTL(VG_STATUS_GET_COUNT)
4963COMPATIBLE_IOCTL(VG_STATUS_GET_NAMELIST)
4964COMPATIBLE_IOCTL(VG_REMOVE)
4965COMPATIBLE_IOCTL(VG_RENAME)
4966COMPATIBLE_IOCTL(VG_REDUCE)
4967COMPATIBLE_IOCTL(PE_LOCK_UNLOCK)
4968COMPATIBLE_IOCTL(PV_FLUSH)
4969COMPATIBLE_IOCTL(LVM_LOCK_LVM)
4970COMPATIBLE_IOCTL(LVM_GET_IOP_VERSION)
4971#ifdef LVM_TOTAL_RESET
4972COMPATIBLE_IOCTL(LVM_RESET)
4973#endif
4974COMPATIBLE_IOCTL(LV_SET_ACCESS)
4975COMPATIBLE_IOCTL(LV_SET_STATUS)
4976COMPATIBLE_IOCTL(LV_SET_ALLOCATION)
4977COMPATIBLE_IOCTL(LE_REMAP)
4978COMPATIBLE_IOCTL(LV_BMAP)
4979COMPATIBLE_IOCTL(LV_SNAPSHOT_USE_RATE)
4980#endif
4981#if defined(CONFIG_DRM_NEW) || defined(CONFIG_DRM_NEW_MODULE)
4982COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC)
4983COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID)
4984COMPATIBLE_IOCTL(DRM_IOCTL_AUTH_MAGIC)
4985COMPATIBLE_IOCTL(DRM_IOCTL_BLOCK)
4986COMPATIBLE_IOCTL(DRM_IOCTL_UNBLOCK)
4987COMPATIBLE_IOCTL(DRM_IOCTL_CONTROL)
4988COMPATIBLE_IOCTL(DRM_IOCTL_ADD_BUFS)
4989COMPATIBLE_IOCTL(DRM_IOCTL_MARK_BUFS)
4990COMPATIBLE_IOCTL(DRM_IOCTL_ADD_CTX)
4991COMPATIBLE_IOCTL(DRM_IOCTL_RM_CTX)
4992COMPATIBLE_IOCTL(DRM_IOCTL_MOD_CTX)
4993COMPATIBLE_IOCTL(DRM_IOCTL_GET_CTX)
4994COMPATIBLE_IOCTL(DRM_IOCTL_SWITCH_CTX)
4995COMPATIBLE_IOCTL(DRM_IOCTL_NEW_CTX)
4996COMPATIBLE_IOCTL(DRM_IOCTL_ADD_DRAW)
4997COMPATIBLE_IOCTL(DRM_IOCTL_RM_DRAW)
4998COMPATIBLE_IOCTL(DRM_IOCTL_LOCK)
4999COMPATIBLE_IOCTL(DRM_IOCTL_UNLOCK)
5000COMPATIBLE_IOCTL(DRM_IOCTL_FINISH)
5001#endif
5002
5003
5004COMPATIBLE_IOCTL(WDIOC_GETSTATUS)
5005COMPATIBLE_IOCTL(WDIOC_GETBOOTSTATUS)
5006COMPATIBLE_IOCTL(WDIOC_GETTEMP)
5007COMPATIBLE_IOCTL(WDIOC_SETOPTIONS)
5008COMPATIBLE_IOCTL(WDIOC_KEEPALIVE)
5009COMPATIBLE_IOCTL(WIOCSTART)
5010COMPATIBLE_IOCTL(WIOCSTOP)
5011COMPATIBLE_IOCTL(WIOCGSTAT)
5012
5013COMPATIBLE_IOCTL(RNDGETENTCNT)
5014COMPATIBLE_IOCTL(RNDADDTOENTCNT)
5015COMPATIBLE_IOCTL(RNDGETPOOL)
5016COMPATIBLE_IOCTL(RNDADDENTROPY)
5017COMPATIBLE_IOCTL(RNDZAPENTCNT)
5018COMPATIBLE_IOCTL(RNDCLEARPOOL)
5019
5020COMPATIBLE_IOCTL(HCIDEVUP)
5021COMPATIBLE_IOCTL(HCIDEVDOWN)
5022COMPATIBLE_IOCTL(HCIDEVRESET)
5023COMPATIBLE_IOCTL(HCIDEVRESTAT)
5024COMPATIBLE_IOCTL(HCIGETDEVLIST)
5025COMPATIBLE_IOCTL(HCIGETDEVINFO)
5026COMPATIBLE_IOCTL(HCIGETCONNLIST)
5027COMPATIBLE_IOCTL(HCIGETCONNINFO)
5028COMPATIBLE_IOCTL(HCISETRAW)
5029COMPATIBLE_IOCTL(HCISETSCAN)
5030COMPATIBLE_IOCTL(HCISETAUTH)
5031COMPATIBLE_IOCTL(HCISETENCRYPT)
5032COMPATIBLE_IOCTL(HCISETPTYPE)
5033COMPATIBLE_IOCTL(HCISETLINKPOL)
5034COMPATIBLE_IOCTL(HCISETLINKMODE)
5035COMPATIBLE_IOCTL(HCISETACLMTU)
5036COMPATIBLE_IOCTL(HCISETSCOMTU)
5037COMPATIBLE_IOCTL(HCIINQUIRY)
5038COMPATIBLE_IOCTL(HCIUARTSETPROTO)
5039COMPATIBLE_IOCTL(HCIUARTGETPROTO)
5040COMPATIBLE_IOCTL(RFCOMMCREATEDEV)
5041COMPATIBLE_IOCTL(RFCOMMRELEASEDEV)
5042COMPATIBLE_IOCTL(RFCOMMGETDEVLIST)
5043COMPATIBLE_IOCTL(RFCOMMGETDEVINFO)
5044COMPATIBLE_IOCTL(RFCOMMSTEALDLC)
5045COMPATIBLE_IOCTL(BNEPCONNADD)
5046COMPATIBLE_IOCTL(BNEPCONNDEL)
5047COMPATIBLE_IOCTL(BNEPGETCONNLIST)
5048COMPATIBLE_IOCTL(BNEPGETCONNINFO)
5049COMPATIBLE_IOCTL(CMTPCONNADD)
5050COMPATIBLE_IOCTL(CMTPCONNDEL)
5051COMPATIBLE_IOCTL(CMTPGETCONNLIST)
5052COMPATIBLE_IOCTL(CMTPGETCONNINFO)
5053
5054COMPATIBLE_IOCTL(SCANNER_IOCTL_VENDOR)
5055COMPATIBLE_IOCTL(SCANNER_IOCTL_PRODUCT)
5056COMPATIBLE_IOCTL(SCANNER_IOCTL_CTRLMSG)
5057
5058COMPATIBLE_IOCTL(0x41545900)
5059COMPATIBLE_IOCTL(0x41545901)
5060COMPATIBLE_IOCTL(PCIIOC_CONTROLLER)
5061COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_IO)
5062COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_MEM)
5063COMPATIBLE_IOCTL(PCIIOC_WRITE_COMBINE)
5064
5065COMPATIBLE_IOCTL(USBDEVFS_RESETEP)
5066COMPATIBLE_IOCTL(USBDEVFS_SETINTERFACE)
5067COMPATIBLE_IOCTL(USBDEVFS_SETCONFIGURATION)
5068COMPATIBLE_IOCTL(USBDEVFS_GETDRIVER)
5069COMPATIBLE_IOCTL(USBDEVFS_DISCARDURB)
5070COMPATIBLE_IOCTL(USBDEVFS_CLAIMINTERFACE)
5071COMPATIBLE_IOCTL(USBDEVFS_RELEASEINTERFACE)
5072COMPATIBLE_IOCTL(USBDEVFS_CONNECTINFO)
5073COMPATIBLE_IOCTL(USBDEVFS_HUB_PORTINFO)
5074COMPATIBLE_IOCTL(USBDEVFS_RESET)
5075COMPATIBLE_IOCTL(USBDEVFS_CLEAR_HALT)
5076
5077COMPATIBLE_IOCTL(MEMGETINFO)
5078COMPATIBLE_IOCTL(MEMERASE)
5079COMPATIBLE_IOCTL(MEMLOCK)
5080COMPATIBLE_IOCTL(MEMUNLOCK)
5081COMPATIBLE_IOCTL(MEMGETREGIONCOUNT)
5082COMPATIBLE_IOCTL(MEMGETREGIONINFO)
5083
5084COMPATIBLE_IOCTL(NBD_SET_SOCK)
5085COMPATIBLE_IOCTL(NBD_SET_BLKSIZE)
5086COMPATIBLE_IOCTL(NBD_SET_SIZE)
5087COMPATIBLE_IOCTL(NBD_DO_IT)
5088COMPATIBLE_IOCTL(NBD_CLEAR_SOCK)
5089COMPATIBLE_IOCTL(NBD_CLEAR_QUE)
5090COMPATIBLE_IOCTL(NBD_PRINT_DEBUG)
5091COMPATIBLE_IOCTL(NBD_SET_SIZE_BLOCKS)
5092COMPATIBLE_IOCTL(NBD_DISCONNECT)
5093
5094#if defined(CONFIG_IEEE1394) || defined(CONFIG_IEEE1394_MODULE)
5095COMPATIBLE_IOCTL(AMDTP_IOC_CHANNEL)
5096COMPATIBLE_IOCTL(AMDTP_IOC_PLUG)
5097COMPATIBLE_IOCTL(AMDTP_IOC_PING)
5098COMPATIBLE_IOCTL(AMDTP_IOC_ZAP)
5099COMPATIBLE_IOCTL(DV1394_IOC_SHUTDOWN)
5100COMPATIBLE_IOCTL(DV1394_IOC_SUBMIT_FRAMES)
5101COMPATIBLE_IOCTL(DV1394_IOC_WAIT_FRAMES)
5102COMPATIBLE_IOCTL(DV1394_IOC_RECEIVE_FRAMES)
5103COMPATIBLE_IOCTL(DV1394_IOC_START_RECEIVE)
5104COMPATIBLE_IOCTL(VIDEO1394_IOC_LISTEN_CHANNEL)
5105COMPATIBLE_IOCTL(VIDEO1394_IOC_UNLISTEN_CHANNEL)
5106COMPATIBLE_IOCTL(VIDEO1394_IOC_TALK_CHANNEL)
5107COMPATIBLE_IOCTL(VIDEO1394_IOC_UNTALK_CHANNEL)
5108#endif
5109
5110
5111#if defined(CONFIG_IEEE1394) || defined(CONFIG_IEEE1394_MODULE)
5112HANDLE_IOCTL(DV1394_IOC32_INIT, handle_dv1394_init)
5113HANDLE_IOCTL(DV1394_IOC32_GET_STATUS, handle_dv1394_get_status)
5114HANDLE_IOCTL(VIDEO1394_IOC32_LISTEN_QUEUE_BUFFER, video1394_w_wait32)
5115HANDLE_IOCTL(VIDEO1394_IOC32_LISTEN_WAIT_BUFFER, video1394_wr_wait32)
5116HANDLE_IOCTL(VIDEO1394_IOC_TALK_QUEUE_BUFFER, video1394_queue_buf32)
5117HANDLE_IOCTL(VIDEO1394_IOC32_TALK_WAIT_BUFFER, video1394_w_wait32)
5118HANDLE_IOCTL(VIDEO1394_IOC32_LISTEN_POLL_BUFFER, video1394_wr_wait32)
5119#endif
5120HANDLE_IOCTL(MEMREADOOB32, mtd_rw_oob)
5121HANDLE_IOCTL(MEMWRITEOOB32, mtd_rw_oob)
5122#ifdef CONFIG_NET
5123HANDLE_IOCTL(SIOCGIFNAME, dev_ifname32)
5124#endif
5125HANDLE_IOCTL(SIOCGIFCONF, dev_ifconf)
5126HANDLE_IOCTL(SIOCGIFFLAGS, dev_ifsioc)
5127HANDLE_IOCTL(SIOCSIFFLAGS, dev_ifsioc)
5128HANDLE_IOCTL(SIOCGIFMETRIC, dev_ifsioc)
5129HANDLE_IOCTL(SIOCSIFMETRIC, dev_ifsioc)
5130HANDLE_IOCTL(SIOCGIFMTU, dev_ifsioc)
5131HANDLE_IOCTL(SIOCSIFMTU, dev_ifsioc)
5132HANDLE_IOCTL(SIOCGIFMEM, dev_ifsioc)
5133HANDLE_IOCTL(SIOCSIFMEM, dev_ifsioc)
5134HANDLE_IOCTL(SIOCGIFHWADDR, dev_ifsioc)
5135HANDLE_IOCTL(SIOCSIFHWADDR, dev_ifsioc)
5136HANDLE_IOCTL(SIOCADDMULTI, dev_ifsioc)
5137HANDLE_IOCTL(SIOCDELMULTI, dev_ifsioc)
5138HANDLE_IOCTL(SIOCGIFINDEX, dev_ifsioc)
5139HANDLE_IOCTL(SIOCGIFMAP, dev_ifsioc)
5140HANDLE_IOCTL(SIOCSIFMAP, dev_ifsioc)
5141HANDLE_IOCTL(SIOCGIFADDR, dev_ifsioc)
5142HANDLE_IOCTL(SIOCSIFADDR, dev_ifsioc)
5143HANDLE_IOCTL(SIOCGIFBRDADDR, dev_ifsioc)
5144HANDLE_IOCTL(SIOCSIFBRDADDR, dev_ifsioc)
5145HANDLE_IOCTL(SIOCGIFDSTADDR, dev_ifsioc)
5146HANDLE_IOCTL(SIOCSIFDSTADDR, dev_ifsioc)
5147HANDLE_IOCTL(SIOCGIFNETMASK, dev_ifsioc)
5148HANDLE_IOCTL(SIOCSIFNETMASK, dev_ifsioc)
5149HANDLE_IOCTL(SIOCSIFPFLAGS, dev_ifsioc)
5150HANDLE_IOCTL(SIOCGIFPFLAGS, dev_ifsioc)
5151HANDLE_IOCTL(SIOCGIFTXQLEN, dev_ifsioc)
5152HANDLE_IOCTL(SIOCSIFTXQLEN, dev_ifsioc)
5153HANDLE_IOCTL(TUNSETIFF, dev_ifsioc)
5154HANDLE_IOCTL(SIOCETHTOOL, ethtool_ioctl)
5155HANDLE_IOCTL(SIOCBONDENSLAVE, bond_ioctl)
5156HANDLE_IOCTL(SIOCBONDRELEASE, bond_ioctl)
5157HANDLE_IOCTL(SIOCBONDSETHWADDR, bond_ioctl)
5158HANDLE_IOCTL(SIOCBONDSLAVEINFOQUERY, bond_ioctl)
5159HANDLE_IOCTL(SIOCBONDINFOQUERY, bond_ioctl)
5160HANDLE_IOCTL(SIOCBONDCHANGEACTIVE, bond_ioctl)
5161HANDLE_IOCTL(SIOCADDRT, routing_ioctl)
5162HANDLE_IOCTL(SIOCDELRT, routing_ioctl)
5163
5164HANDLE_IOCTL(SIOCRTMSG, ret_einval)
5165HANDLE_IOCTL(SIOCGSTAMP, do_siocgstamp)
5166HANDLE_IOCTL(HDIO_GETGEO, hdio_getgeo)
5167HANDLE_IOCTL(HDIO_GETGEO_BIG, hdio_getgeo_big)
5168HANDLE_IOCTL(HDIO_GETGEO_BIG_RAW, hdio_getgeo_big)
5169HANDLE_IOCTL(BLKRAGET, w_long)
5170HANDLE_IOCTL(BLKGETSIZE, w_long)
5171HANDLE_IOCTL(0x1260, broken_blkgetsize)
5172HANDLE_IOCTL(BLKFRAGET, w_long)
5173HANDLE_IOCTL(BLKSECTGET, w_long)
5174HANDLE_IOCTL(BLKPG, blkpg_ioctl_trans)
5175HANDLE_IOCTL(FBIOPUTCMAP32, fbiogetputcmap)
5176HANDLE_IOCTL(FBIOGETCMAP32, fbiogetputcmap)
5177HANDLE_IOCTL(FBIOSCURSOR32, fbiogscursor)
5178HANDLE_IOCTL(FBIOGET_FSCREENINFO, fb_ioctl_trans)
5179HANDLE_IOCTL(FBIOGETCMAP, fb_ioctl_trans)
5180HANDLE_IOCTL(FBIOPUTCMAP, fb_ioctl_trans)
5181HANDLE_IOCTL(HDIO_GET_KEEPSETTINGS, hdio_ioctl_trans)
5182HANDLE_IOCTL(HDIO_GET_UNMASKINTR, hdio_ioctl_trans)
5183HANDLE_IOCTL(HDIO_GET_DMA, hdio_ioctl_trans)
5184HANDLE_IOCTL(HDIO_GET_32BIT, hdio_ioctl_trans)
5185HANDLE_IOCTL(HDIO_GET_MULTCOUNT, hdio_ioctl_trans)
5186HANDLE_IOCTL(HDIO_GET_NOWERR, hdio_ioctl_trans)
5187HANDLE_IOCTL(HDIO_GET_NICE, hdio_ioctl_trans)
5188HANDLE_IOCTL(FDSETPRM32, fd_ioctl_trans)
5189HANDLE_IOCTL(FDDEFPRM32, fd_ioctl_trans)
5190HANDLE_IOCTL(FDGETPRM32, fd_ioctl_trans)
5191HANDLE_IOCTL(FDSETDRVPRM32, fd_ioctl_trans)
5192HANDLE_IOCTL(FDGETDRVPRM32, fd_ioctl_trans)
5193HANDLE_IOCTL(FDGETDRVSTAT32, fd_ioctl_trans)
5194HANDLE_IOCTL(FDPOLLDRVSTAT32, fd_ioctl_trans)
5195HANDLE_IOCTL(FDGETFDCSTAT32, fd_ioctl_trans)
5196HANDLE_IOCTL(FDWERRORGET32, fd_ioctl_trans)
5197HANDLE_IOCTL(SG_IO,sg_ioctl_trans)
5198HANDLE_IOCTL(PPPIOCGIDLE32, ppp_ioctl_trans)
5199HANDLE_IOCTL(PPPIOCSCOMPRESS32, ppp_ioctl_trans)
5200HANDLE_IOCTL(PPPIOCSPASS32, ppp_sock_fprog_ioctl_trans)
5201HANDLE_IOCTL(PPPIOCSACTIVE32, ppp_sock_fprog_ioctl_trans)
5202HANDLE_IOCTL(MTIOCGET32, mt_ioctl_trans)
5203HANDLE_IOCTL(MTIOCPOS32, mt_ioctl_trans)
5204HANDLE_IOCTL(MTIOCGETCONFIG32, mt_ioctl_trans)
5205HANDLE_IOCTL(MTIOCSETCONFIG32, mt_ioctl_trans)
5206HANDLE_IOCTL(CDROMREADAUDIO, cdrom_ioctl_trans)
5207HANDLE_IOCTL(CDROM_SEND_PACKET, cdrom_ioctl_trans)
5208HANDLE_IOCTL(LOOP_SET_STATUS, loop_status)
5209HANDLE_IOCTL(LOOP_GET_STATUS, loop_status)
5210#define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,unsigned int)
5211HANDLE_IOCTL(AUTOFS_IOC_SETTIMEOUT32, ioc_settimeout)
5212HANDLE_IOCTL(PIO_FONTX, do_fontx_ioctl)
5213HANDLE_IOCTL(GIO_FONTX, do_fontx_ioctl)
5214HANDLE_IOCTL(PIO_UNIMAP, do_unimap_ioctl)
5215HANDLE_IOCTL(GIO_UNIMAP, do_unimap_ioctl)
5216HANDLE_IOCTL(KDFONTOP, do_kdfontop_ioctl)
5217HANDLE_IOCTL(EXT2_IOC32_GETFLAGS, do_ext2_ioctl)
5218HANDLE_IOCTL(EXT2_IOC32_SETFLAGS, do_ext2_ioctl)
5219HANDLE_IOCTL(EXT2_IOC32_GETVERSION, do_ext2_ioctl)
5220HANDLE_IOCTL(EXT2_IOC32_SETVERSION, do_ext2_ioctl)
5221HANDLE_IOCTL(VIDIOCGTUNER32, do_video_ioctl)
5222HANDLE_IOCTL(VIDIOCSTUNER32, do_video_ioctl)
5223HANDLE_IOCTL(VIDIOCGWIN32, do_video_ioctl)
5224HANDLE_IOCTL(VIDIOCSWIN32, do_video_ioctl)
5225HANDLE_IOCTL(VIDIOCGFBUF32, do_video_ioctl)
5226HANDLE_IOCTL(VIDIOCSFBUF32, do_video_ioctl)
5227HANDLE_IOCTL(VIDIOCGFREQ32, do_video_ioctl)
5228HANDLE_IOCTL(VIDIOCSFREQ32, do_video_ioctl)
5229
5230#define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, __kernel_uid_t32)
5231HANDLE_IOCTL(SMB_IOC_GETMOUNTUID_32, do_smb_getmountuid)
5232
5233HANDLE_IOCTL(NCP_IOC_NCPREQUEST_32, do_ncp_ncprequest)
5234HANDLE_IOCTL(NCP_IOC_GETMOUNTUID2_32, do_ncp_getmountuid2)
5235HANDLE_IOCTL(NCP_IOC_GET_FS_INFO_V2_32, do_ncp_getfsinfo2)
5236HANDLE_IOCTL(NCP_IOC_GETOBJECTNAME_32, do_ncp_getobjectname)
5237HANDLE_IOCTL(NCP_IOC_SETOBJECTNAME_32, do_ncp_setobjectname)
5238HANDLE_IOCTL(NCP_IOC_GETPRIVATEDATA_32, do_ncp_getprivatedata)
5239HANDLE_IOCTL(NCP_IOC_SETPRIVATEDATA_32, do_ncp_setprivatedata)
5240HANDLE_IOCTL(ATM_GETLINKRATE32, do_atm_ioctl)
5241HANDLE_IOCTL(ATM_GETNAMES32, do_atm_ioctl)
5242HANDLE_IOCTL(ATM_GETTYPE32, do_atm_ioctl)
5243HANDLE_IOCTL(ATM_GETESI32, do_atm_ioctl)
5244HANDLE_IOCTL(ATM_GETADDR32, do_atm_ioctl)
5245HANDLE_IOCTL(ATM_RSTADDR32, do_atm_ioctl)
5246HANDLE_IOCTL(ATM_ADDADDR32, do_atm_ioctl)
5247HANDLE_IOCTL(ATM_DELADDR32, do_atm_ioctl)
5248HANDLE_IOCTL(ATM_GETCIRANGE32, do_atm_ioctl)
5249HANDLE_IOCTL(ATM_SETCIRANGE32, do_atm_ioctl)
5250HANDLE_IOCTL(ATM_SETESI32, do_atm_ioctl)
5251HANDLE_IOCTL(ATM_SETESIF32, do_atm_ioctl)
5252HANDLE_IOCTL(ATM_GETSTAT32, do_atm_ioctl)
5253HANDLE_IOCTL(ATM_GETSTATZ32, do_atm_ioctl)
5254HANDLE_IOCTL(ATM_GETLOOP32, do_atm_ioctl)
5255HANDLE_IOCTL(ATM_SETLOOP32, do_atm_ioctl)
5256HANDLE_IOCTL(ATM_QUERYLOOP32, do_atm_ioctl)
5257HANDLE_IOCTL(SONET_GETSTAT, do_atm_ioctl)
5258HANDLE_IOCTL(SONET_GETSTATZ, do_atm_ioctl)
5259HANDLE_IOCTL(SONET_GETDIAG, do_atm_ioctl)
5260HANDLE_IOCTL(SONET_SETDIAG, do_atm_ioctl)
5261HANDLE_IOCTL(SONET_CLRDIAG, do_atm_ioctl)
5262HANDLE_IOCTL(SONET_SETFRAMING, do_atm_ioctl)
5263HANDLE_IOCTL(SONET_GETFRAMING, do_atm_ioctl)
5264HANDLE_IOCTL(SONET_GETFRSENSE, do_atm_ioctl)
5265#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
5266HANDLE_IOCTL(VG_STATUS, do_lvm_ioctl)
5267HANDLE_IOCTL(VG_CREATE_OLD, do_lvm_ioctl)
5268HANDLE_IOCTL(VG_CREATE, do_lvm_ioctl)
5269HANDLE_IOCTL(VG_EXTEND, do_lvm_ioctl)
5270HANDLE_IOCTL(LV_CREATE, do_lvm_ioctl)
5271HANDLE_IOCTL(LV_REMOVE, do_lvm_ioctl)
5272HANDLE_IOCTL(LV_EXTEND, do_lvm_ioctl)
5273HANDLE_IOCTL(LV_REDUCE, do_lvm_ioctl)
5274HANDLE_IOCTL(LV_RENAME, do_lvm_ioctl)
5275HANDLE_IOCTL(LV_STATUS_BYNAME, do_lvm_ioctl)
5276HANDLE_IOCTL(LV_STATUS_BYINDEX, do_lvm_ioctl)
5277HANDLE_IOCTL(LV_STATUS_BYDEV, do_lvm_ioctl)
5278HANDLE_IOCTL(PV_CHANGE, do_lvm_ioctl)
5279HANDLE_IOCTL(PV_STATUS, do_lvm_ioctl)
5280#endif
5281#if defined(CONFIG_DRM_NEW) || defined(CONFIG_DRM_NEW_MODULE)
5282HANDLE_IOCTL(DRM32_IOCTL_VERSION, drm32_version)
5283HANDLE_IOCTL(DRM32_IOCTL_GET_UNIQUE, drm32_getsetunique)
5284HANDLE_IOCTL(DRM32_IOCTL_SET_UNIQUE, drm32_getsetunique)
5285HANDLE_IOCTL(DRM32_IOCTL_ADD_MAP, drm32_addmap)
5286HANDLE_IOCTL(DRM32_IOCTL_INFO_BUFS, drm32_info_bufs)
5287HANDLE_IOCTL(DRM32_IOCTL_FREE_BUFS, drm32_free_bufs)
5288HANDLE_IOCTL(DRM32_IOCTL_MAP_BUFS, drm32_map_bufs)
5289HANDLE_IOCTL(DRM32_IOCTL_DMA, drm32_dma)
5290HANDLE_IOCTL(DRM32_IOCTL_RES_CTX, drm32_res_ctx)
5291#endif
5292#if 0
5293HANDLE_IOCTL(RTC32_IRQP_READ, do_rtc_ioctl)
5294HANDLE_IOCTL(RTC32_IRQP_SET, do_rtc_ioctl)
5295HANDLE_IOCTL(RTC32_EPOCH_READ, do_rtc_ioctl)
5296HANDLE_IOCTL(RTC32_EPOCH_SET, do_rtc_ioctl)
5297#endif
5298HANDLE_IOCTL(USBDEVFS_CONTROL32, do_usbdevfs_control)
5299HANDLE_IOCTL(USBDEVFS_BULK32, do_usbdevfs_bulk)
5300
5301HANDLE_IOCTL(USBDEVFS_REAPURB32, do_usbdevfs_reapurb)
5302HANDLE_IOCTL(USBDEVFS_REAPURBNDELAY32, do_usbdevfs_reapurb)
5303HANDLE_IOCTL(USBDEVFS_DISCSIGNAL32, do_usbdevfs_discsignal)
5304
5305
5306HANDLE_IOCTL(BLKELVGET_32, do_blkelvget)
5307HANDLE_IOCTL(BLKELVSET_32, do_blkelvset)
5308
5309HANDLE_IOCTL(BLKBSZGET_32, do_blkbszget)
5310HANDLE_IOCTL(BLKBSZSET_32, do_blkbszset)
5311HANDLE_IOCTL(BLKGETSIZE64_32, do_blkgetsize64)
5312IOCTL_TABLE_END
5313
5314unsigned int ioctl32_hash_table[1024];
5315
5316static inline unsigned long ioctl32_hash(unsigned long cmd)
5317{
5318 return ((cmd >> 6) ^ (cmd >> 4) ^ cmd) & 0x3ff;
5319}
5320
5321static void ioctl32_insert_translation(struct ioctl_trans *trans)
5322{
5323 unsigned long hash;
5324 struct ioctl_trans *t;
5325
5326 hash = ioctl32_hash (trans->cmd);
5327 if (!ioctl32_hash_table[hash])
5328 ioctl32_hash_table[hash] = (u32)(long)trans;
5329 else {
5330 t = (struct ioctl_trans *)(long)ioctl32_hash_table[hash];
5331 while (t->next)
5332 t = (struct ioctl_trans *)(long)t->next;
5333 trans->next = 0;
5334 t->next = (u32)(long)trans;
5335 }
5336}
5337
5338static int __init init_sys32_ioctl(void)
5339{
5340 int i;
5341 extern struct ioctl_trans ioctl_translations[], ioctl_translations_end[];
5342
5343 for (i = 0; &ioctl_translations[i] < &ioctl_translations_end[0]; i++)
5344 ioctl32_insert_translation(&ioctl_translations[i]);
5345 return 0;
5346}
5347
5348__initcall(init_sys32_ioctl);
5349
5350static struct ioctl_trans *additional_ioctls;
5351
5352
5353
5354int register_ioctl32_conversion(unsigned int cmd, int (*handler)(unsigned int, unsigned int, unsigned long, struct file *))
5355{
5356 int i;
5357 if (!additional_ioctls) {
5358 additional_ioctls = module_map(PAGE_SIZE);
5359 if (!additional_ioctls)
5360 return -ENOMEM;
5361 memset(additional_ioctls, 0, PAGE_SIZE);
5362 }
5363 for (i = 0; i < PAGE_SIZE/sizeof(struct ioctl_trans); i++)
5364 if (!additional_ioctls[i].cmd)
5365 break;
5366 if (i == PAGE_SIZE/sizeof(struct ioctl_trans))
5367 return -ENOMEM;
5368 additional_ioctls[i].cmd = cmd;
5369 if (!handler)
5370 additional_ioctls[i].handler = (u32)(long)sys_ioctl;
5371 else
5372 additional_ioctls[i].handler = (u32)(long)handler;
5373 ioctl32_insert_translation(&additional_ioctls[i]);
5374 return 0;
5375}
5376
5377int unregister_ioctl32_conversion(unsigned int cmd)
5378{
5379 unsigned long hash = ioctl32_hash(cmd);
5380 struct ioctl_trans *t, *t1;
5381
5382 t = (struct ioctl_trans *)(long)ioctl32_hash_table[hash];
5383 if (!t) return -EINVAL;
5384 if (t->cmd == cmd && t >= additional_ioctls &&
5385 (unsigned long)t < ((unsigned long)additional_ioctls) + PAGE_SIZE) {
5386 ioctl32_hash_table[hash] = t->next;
5387 t->cmd = 0;
5388 t->next = 0;
5389 return 0;
5390 } else while (t->next) {
5391 t1 = (struct ioctl_trans *)(long)t->next;
5392 if (t1->cmd == cmd && t1 >= additional_ioctls &&
5393 (unsigned long)t1 < ((unsigned long)additional_ioctls) + PAGE_SIZE) {
5394 t->next = t1->next;
5395 t1->cmd = 0;
5396 t1->next = 0;
5397 return 0;
5398 }
5399 t = t1;
5400 }
5401 return -EINVAL;
5402}
5403
5404asmlinkage int sys32_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
5405{
5406 struct file * filp;
5407 int error = -EBADF;
5408 int (*handler)(unsigned int, unsigned int, unsigned long, struct file * filp);
5409 struct ioctl_trans *t;
5410
5411 filp = fget(fd);
5412 if(!filp)
5413 goto out2;
5414
5415 if (!filp->f_op || !filp->f_op->ioctl) {
5416 error = sys_ioctl (fd, cmd, arg);
5417 goto out;
5418 }
5419
5420 t = (struct ioctl_trans *)(long)ioctl32_hash_table [ioctl32_hash (cmd)];
5421
5422 while (t && t->cmd != cmd)
5423 t = (struct ioctl_trans *)(long)t->next;
5424 if (t) {
5425 handler = (void *)(long)t->handler;
5426 error = handler(fd, cmd, arg, filp);
5427 } else if (cmd >= SIOCDEVPRIVATE &&
5428 cmd <= (SIOCDEVPRIVATE + 15)) {
5429 error = siocdevprivate_ioctl(fd, cmd, arg);
5430 } else {
5431 static int count;
5432 if (++count <= 20)
5433 printk("sys32_ioctl(%s:%d): Unknown cmd fd(%d) "
5434 "cmd(%08x) arg(%08x)\n",
5435 current->comm, current->pid,
5436 (int)fd, (unsigned int)cmd, (unsigned int)arg);
5437 error = -EINVAL;
5438 }
5439out:
5440 fput(filp);
5441out2:
5442 return error;
5443}
5444
