proc->thread stage 4: rework the VFS and DEVICE subsystems to take thread
[dragonfly.git] / sys / emulation / ibcs2 / i386 / ibcs2_ioctl.c
1 /*      $NetBSD: ibcs2_ioctl.c,v 1.6 1995/03/14 15:12:28 scottb Exp $   */
2
3 /*
4  * Copyright (c) 1994, 1995 Scott Bartram
5  * All rights reserved.
6  *
7  * based on compat/sunos/sun_ioctl.c
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. The name of the author may not be used to endorse or promote products
15  *    derived from this software without specific prior written permission
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  *
28  * $FreeBSD: src/sys/i386/ibcs2/ibcs2_ioctl.c,v 1.13.2.1 2001/07/31 20:14:21 jon Exp $
29  * $DragonFly: src/sys/emulation/ibcs2/i386/Attic/ibcs2_ioctl.c,v 1.4 2003/06/25 03:55:53 dillon Exp $
30  */
31
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/fcntl.h>
35 #include <sys/file.h>
36 #include <sys/filedesc.h>
37 #include <sys/filio.h>
38 #include <sys/proc.h>
39 #include <sys/ioctl_compat.h>
40 #include <sys/tty.h>
41 #include <machine/console.h>
42 #include <sys/file2.h>
43
44 #include <sys/sysproto.h>
45
46 #include <i386/ibcs2/ibcs2_signal.h>
47 #include <i386/ibcs2/ibcs2_socksys.h>
48 #include <i386/ibcs2/ibcs2_stropts.h>
49 #include <i386/ibcs2/ibcs2_proto.h>
50 #include <i386/ibcs2/ibcs2_termios.h>
51 #include <i386/ibcs2/ibcs2_util.h>
52 #include <i386/ibcs2/ibcs2_ioctl.h>
53
54 static void stios2btios __P((struct ibcs2_termios *, struct termios *));
55 static void btios2stios __P((struct termios *, struct ibcs2_termios *));
56 static void stios2stio  __P((struct ibcs2_termios *, struct ibcs2_termio *));
57 static void stio2stios  __P((struct ibcs2_termio *, struct ibcs2_termios *));
58
59
60 int
61 ibcs2_gtty(struct ibcs2_gtty_args *args)
62 {
63         struct ioctl_args ioctl_arg;
64
65         ioctl_arg.fd = args->fd;
66         ioctl_arg.com = TIOCGETC;
67         ioctl_arg.data = (caddr_t)args->buf;
68
69         return ioctl(&ioctl_arg);
70 }
71
72 int
73 ibcs2_stty(struct ibcs2_stty_args *args)
74 {
75         struct ioctl_args ioctl_arg;
76
77         ioctl_arg.fd = args->fd;
78         ioctl_arg.com = TIOCSETC;
79         ioctl_arg.data = (caddr_t)args->buf;
80
81         return ioctl(&ioctl_arg);
82 }
83
84
85 /*
86  * iBCS2 ioctl calls.
87  */
88
89 static struct speedtab sptab[] = {
90         { 0, 0 },
91         { 50, 1 },
92         { 75, 2 },
93         { 110, 3 },
94         { 134, 4 },
95         { 135, 4 },
96         { 150, 5 },
97         { 200, 6 },
98         { 300, 7 },
99         { 600, 8 },
100         { 1200, 9 },
101         { 1800, 10 },
102         { 2400, 11 },
103         { 4800, 12 },
104         { 9600, 13 },
105         { 19200, 14 },
106         { 38400, 15 },
107         { -1, -1 }
108 };
109
110 static u_long s2btab[] = { 
111         0,
112         50,
113         75,
114         110,
115         134,
116         150,
117         200,
118         300,
119         600,
120         1200,
121         1800,
122         2400,
123         4800,
124         9600,
125         19200,
126         38400,
127 };
128
129 static void
130 stios2btios(st, bt)
131         struct ibcs2_termios *st;
132         struct termios *bt;
133 {
134         register u_long l, r;
135
136         l = st->c_iflag;        r = 0;
137         if (l & IBCS2_IGNBRK)   r |= IGNBRK;
138         if (l & IBCS2_BRKINT)   r |= BRKINT;
139         if (l & IBCS2_IGNPAR)   r |= IGNPAR;
140         if (l & IBCS2_PARMRK)   r |= PARMRK;
141         if (l & IBCS2_INPCK)    r |= INPCK;
142         if (l & IBCS2_ISTRIP)   r |= ISTRIP;
143         if (l & IBCS2_INLCR)    r |= INLCR;
144         if (l & IBCS2_IGNCR)    r |= IGNCR;
145         if (l & IBCS2_ICRNL)    r |= ICRNL;
146         if (l & IBCS2_IXON)     r |= IXON;
147         if (l & IBCS2_IXANY)    r |= IXANY;
148         if (l & IBCS2_IXOFF)    r |= IXOFF;
149         if (l & IBCS2_IMAXBEL)  r |= IMAXBEL;
150         bt->c_iflag = r;
151
152         l = st->c_oflag;        r = 0;
153         if (l & IBCS2_OPOST)    r |= OPOST;
154         if (l & IBCS2_ONLCR)    r |= ONLCR;
155         if (l & IBCS2_TAB3)     r |= OXTABS;
156         bt->c_oflag = r;
157
158         l = st->c_cflag;        r = 0;
159         switch (l & IBCS2_CSIZE) {
160         case IBCS2_CS5:         r |= CS5; break;
161         case IBCS2_CS6:         r |= CS6; break;
162         case IBCS2_CS7:         r |= CS7; break;
163         case IBCS2_CS8:         r |= CS8; break;
164         }
165         if (l & IBCS2_CSTOPB)   r |= CSTOPB;
166         if (l & IBCS2_CREAD)    r |= CREAD;
167         if (l & IBCS2_PARENB)   r |= PARENB;
168         if (l & IBCS2_PARODD)   r |= PARODD;
169         if (l & IBCS2_HUPCL)    r |= HUPCL;
170         if (l & IBCS2_CLOCAL)   r |= CLOCAL;
171         bt->c_cflag = r;
172
173         bt->c_ispeed = bt->c_ospeed = s2btab[l & 0x0000000f];
174
175         l = st->c_lflag;        r = 0;
176         if (l & IBCS2_ISIG)     r |= ISIG;
177         if (l & IBCS2_ICANON)   r |= ICANON;
178         if (l & IBCS2_ECHO)     r |= ECHO;
179         if (l & IBCS2_ECHOE)    r |= ECHOE;
180         if (l & IBCS2_ECHOK)    r |= ECHOK;
181         if (l & IBCS2_ECHONL)   r |= ECHONL;
182         if (l & IBCS2_NOFLSH)   r |= NOFLSH;
183         if (l & IBCS2_TOSTOP)   r |= TOSTOP;
184         bt->c_lflag = r;
185
186         bt->c_cc[VINTR] =
187             st->c_cc[IBCS2_VINTR]  ? st->c_cc[IBCS2_VINTR]  : _POSIX_VDISABLE;
188         bt->c_cc[VQUIT] =
189             st->c_cc[IBCS2_VQUIT]  ? st->c_cc[IBCS2_VQUIT]  : _POSIX_VDISABLE;
190         bt->c_cc[VERASE] =
191             st->c_cc[IBCS2_VERASE] ? st->c_cc[IBCS2_VERASE] : _POSIX_VDISABLE;
192         bt->c_cc[VKILL] =
193             st->c_cc[IBCS2_VKILL]  ? st->c_cc[IBCS2_VKILL]  : _POSIX_VDISABLE;
194         if (bt->c_lflag & ICANON) {
195                 bt->c_cc[VEOF] =
196                     st->c_cc[IBCS2_VEOF] ? st->c_cc[IBCS2_VEOF] : _POSIX_VDISABLE;
197                 bt->c_cc[VEOL] =
198                     st->c_cc[IBCS2_VEOL] ? st->c_cc[IBCS2_VEOL] : _POSIX_VDISABLE;
199         } else {
200                 bt->c_cc[VMIN]  = st->c_cc[IBCS2_VMIN];
201                 bt->c_cc[VTIME] = st->c_cc[IBCS2_VTIME];
202         }
203         bt->c_cc[VEOL2] =
204             st->c_cc[IBCS2_VEOL2]  ? st->c_cc[IBCS2_VEOL2]  : _POSIX_VDISABLE;
205 #if 0
206         bt->c_cc[VSWTCH] =
207             st->c_cc[IBCS2_VSWTCH] ? st->c_cc[IBCS2_VSWTCH] : _POSIX_VDISABLE;
208 #endif
209         bt->c_cc[VSTART] =
210             st->c_cc[IBCS2_VSTART] ? st->c_cc[IBCS2_VSTART] : _POSIX_VDISABLE;
211         bt->c_cc[VSTOP] =
212             st->c_cc[IBCS2_VSTOP]  ? st->c_cc[IBCS2_VSTOP]  : _POSIX_VDISABLE;
213         bt->c_cc[VSUSP] =
214             st->c_cc[IBCS2_VSUSP]  ? st->c_cc[IBCS2_VSUSP]  : _POSIX_VDISABLE;
215         bt->c_cc[VDSUSP]   = _POSIX_VDISABLE;
216         bt->c_cc[VREPRINT] = _POSIX_VDISABLE;
217         bt->c_cc[VDISCARD] = _POSIX_VDISABLE;
218         bt->c_cc[VWERASE]  = _POSIX_VDISABLE;
219         bt->c_cc[VLNEXT]   = _POSIX_VDISABLE;
220         bt->c_cc[VSTATUS]  = _POSIX_VDISABLE;
221 }
222
223 static void
224 btios2stios(bt, st)
225         struct termios *bt;
226         struct ibcs2_termios *st;
227 {
228         register u_long l, r;
229
230         l = bt->c_iflag;        r = 0;
231         if (l & IGNBRK)         r |= IBCS2_IGNBRK;
232         if (l & BRKINT)         r |= IBCS2_BRKINT;
233         if (l & IGNPAR)         r |= IBCS2_IGNPAR;
234         if (l & PARMRK)         r |= IBCS2_PARMRK;
235         if (l & INPCK)          r |= IBCS2_INPCK;
236         if (l & ISTRIP)         r |= IBCS2_ISTRIP;
237         if (l & INLCR)          r |= IBCS2_INLCR;
238         if (l & IGNCR)          r |= IBCS2_IGNCR;
239         if (l & ICRNL)          r |= IBCS2_ICRNL;
240         if (l & IXON)           r |= IBCS2_IXON;
241         if (l & IXANY)          r |= IBCS2_IXANY;
242         if (l & IXOFF)          r |= IBCS2_IXOFF;
243         if (l & IMAXBEL)        r |= IBCS2_IMAXBEL;
244         st->c_iflag = r;
245
246         l = bt->c_oflag;        r = 0;
247         if (l & OPOST)          r |= IBCS2_OPOST;
248         if (l & ONLCR)          r |= IBCS2_ONLCR;
249         if (l & OXTABS)         r |= IBCS2_TAB3;
250         st->c_oflag = r;
251
252         l = bt->c_cflag;        r = 0;
253         switch (l & CSIZE) {
254         case CS5:               r |= IBCS2_CS5; break;
255         case CS6:               r |= IBCS2_CS6; break;
256         case CS7:               r |= IBCS2_CS7; break;
257         case CS8:               r |= IBCS2_CS8; break;
258         }
259         if (l & CSTOPB)         r |= IBCS2_CSTOPB;
260         if (l & CREAD)          r |= IBCS2_CREAD;
261         if (l & PARENB)         r |= IBCS2_PARENB;
262         if (l & PARODD)         r |= IBCS2_PARODD;
263         if (l & HUPCL)          r |= IBCS2_HUPCL;
264         if (l & CLOCAL)         r |= IBCS2_CLOCAL;
265         st->c_cflag = r;
266
267         l = bt->c_lflag;        r = 0;
268         if (l & ISIG)           r |= IBCS2_ISIG;
269         if (l & ICANON)         r |= IBCS2_ICANON;
270         if (l & ECHO)           r |= IBCS2_ECHO;
271         if (l & ECHOE)          r |= IBCS2_ECHOE;
272         if (l & ECHOK)          r |= IBCS2_ECHOK;
273         if (l & ECHONL)         r |= IBCS2_ECHONL;
274         if (l & NOFLSH)         r |= IBCS2_NOFLSH;
275         if (l & TOSTOP)         r |= IBCS2_TOSTOP;
276         st->c_lflag = r;
277
278         l = ttspeedtab(bt->c_ospeed, sptab);
279         if ((int)l >= 0)
280                 st->c_cflag |= l;
281
282         st->c_cc[IBCS2_VINTR] =
283             bt->c_cc[VINTR]  != _POSIX_VDISABLE ? bt->c_cc[VINTR]  : 0;
284         st->c_cc[IBCS2_VQUIT] =
285             bt->c_cc[VQUIT]  != _POSIX_VDISABLE ? bt->c_cc[VQUIT]  : 0;
286         st->c_cc[IBCS2_VERASE] =
287             bt->c_cc[VERASE] != _POSIX_VDISABLE ? bt->c_cc[VERASE] : 0;
288         st->c_cc[IBCS2_VKILL] =
289             bt->c_cc[VKILL]  != _POSIX_VDISABLE ? bt->c_cc[VKILL]  : 0;
290         if (bt->c_lflag & ICANON) {
291                 st->c_cc[IBCS2_VEOF] =
292                     bt->c_cc[VEOF] != _POSIX_VDISABLE ? bt->c_cc[VEOF] : 0;
293                 st->c_cc[IBCS2_VEOL] =
294                     bt->c_cc[VEOL] != _POSIX_VDISABLE ? bt->c_cc[VEOL] : 0;
295         } else {
296                 st->c_cc[IBCS2_VMIN]  = bt->c_cc[VMIN];
297                 st->c_cc[IBCS2_VTIME] = bt->c_cc[VTIME];
298         }
299         st->c_cc[IBCS2_VEOL2] =
300             bt->c_cc[VEOL2]  != _POSIX_VDISABLE ? bt->c_cc[VEOL2]  : 0;
301         st->c_cc[IBCS2_VSWTCH] =
302             0;
303         st->c_cc[IBCS2_VSUSP] =
304             bt->c_cc[VSUSP]  != _POSIX_VDISABLE ? bt->c_cc[VSUSP]  : 0;
305         st->c_cc[IBCS2_VSTART] =
306             bt->c_cc[VSTART] != _POSIX_VDISABLE ? bt->c_cc[VSTART] : 0;
307         st->c_cc[IBCS2_VSTOP] =
308             bt->c_cc[VSTOP]  != _POSIX_VDISABLE ? bt->c_cc[VSTOP]  : 0;
309
310         st->c_line = 0;
311 }
312
313 static void
314 stios2stio(ts, t)
315         struct ibcs2_termios *ts;
316         struct ibcs2_termio *t;
317 {
318         t->c_iflag = ts->c_iflag;
319         t->c_oflag = ts->c_oflag;
320         t->c_cflag = ts->c_cflag;
321         t->c_lflag = ts->c_lflag;
322         t->c_line  = ts->c_line;
323         bcopy(ts->c_cc, t->c_cc, IBCS2_NCC);
324 }
325
326 static void
327 stio2stios(t, ts)
328         struct ibcs2_termio *t;
329         struct ibcs2_termios *ts;
330 {
331         ts->c_iflag = t->c_iflag;
332         ts->c_oflag = t->c_oflag;
333         ts->c_cflag = t->c_cflag;
334         ts->c_lflag = t->c_lflag;
335         ts->c_line  = t->c_line;
336         bcopy(t->c_cc, ts->c_cc, IBCS2_NCC);
337 }
338
339 int
340 ibcs2_ioctl(struct ibcs2_ioctl_args *uap)
341 {
342         struct thread *td = curthread;
343         struct proc *p = td->td_proc;
344         struct filedesc *fdp;
345         struct file *fp;
346         int error;
347
348         KKASSERT(p);
349         fdp = p->p_fd;
350
351         if (SCARG(uap, fd) < 0 || SCARG(uap, fd) >= fdp->fd_nfiles ||
352             (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) {
353                 DPRINTF(("ibcs2_ioctl(td=%p): bad fd %d ", td, SCARG(uap, fd)));
354                 return EBADF;
355         }
356
357         if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
358                 DPRINTF(("ibcs2_ioctl(td=%p): bad fp flag ", td));
359                 return EBADF;
360         }
361
362         switch (SCARG(uap, cmd)) {
363         case IBCS2_TCGETA:
364         case IBCS2_XCGETA:
365         case IBCS2_OXCGETA:
366             {
367                 struct termios bts;
368                 struct ibcs2_termios sts;
369                 struct ibcs2_termio st;
370         
371                 if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, td)) != 0)
372                         return error;
373         
374                 btios2stios (&bts, &sts);
375                 if (SCARG(uap, cmd) == IBCS2_TCGETA) {
376                         stios2stio (&sts, &st);
377                         error = copyout((caddr_t)&st, SCARG(uap, data),
378                                         sizeof (st));
379 #ifdef DEBUG_IBCS2
380                         if (error)
381                                 DPRINTF(("ibcs2_ioctl(%d): copyout failed ",
382                                          p->p_pid));
383 #endif
384                         return error;
385                 } else
386                         return copyout((caddr_t)&sts, SCARG(uap, data),
387                                         sizeof (sts));
388                 /*NOTREACHED*/
389             }
390
391         case IBCS2_TCSETA:
392         case IBCS2_TCSETAW:
393         case IBCS2_TCSETAF:
394             {
395                 struct termios bts;
396                 struct ibcs2_termios sts;
397                 struct ibcs2_termio st;
398
399                 if ((error = copyin(SCARG(uap, data), (caddr_t)&st,
400                                     sizeof(st))) != 0) {
401                         DPRINTF(("ibcs2_ioctl(%d): TCSET copyin failed ",
402                                  p->p_pid));
403                         return error;
404                 }
405
406                 /* get full BSD termios so we don't lose information */
407                 if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, td)) != 0) {
408                         DPRINTF(("ibcs2_ioctl(%d): TCSET ctl failed fd %d ",
409                                  p->p_pid, SCARG(uap, fd)));
410                         return error;
411                 }
412
413                 /*
414                  * convert to iBCS2 termios, copy in information from
415                  * termio, and convert back, then set new values.
416                  */
417                 btios2stios(&bts, &sts);
418                 stio2stios(&st, &sts);
419                 stios2btios(&sts, &bts);
420
421                 return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_TCSETA + TIOCSETA,
422                               (caddr_t)&bts, td);
423             }
424
425         case IBCS2_XCSETA:
426         case IBCS2_XCSETAW:
427         case IBCS2_XCSETAF:
428             {
429                 struct termios bts;
430                 struct ibcs2_termios sts;
431
432                 if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
433                                     sizeof (sts))) != 0) {
434                         return error;
435                 }
436                 stios2btios (&sts, &bts);
437                 return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_XCSETA + TIOCSETA,
438                               (caddr_t)&bts, td);
439             }
440
441         case IBCS2_OXCSETA:
442         case IBCS2_OXCSETAW:
443         case IBCS2_OXCSETAF:
444             {
445                 struct termios bts;
446                 struct ibcs2_termios sts;
447
448                 if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
449                                     sizeof (sts))) != 0) {
450                         return error;
451                 }
452                 stios2btios (&sts, &bts);
453                 return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_OXCSETA + TIOCSETA,
454                               (caddr_t)&bts, td);
455             }
456
457         case IBCS2_TCSBRK:
458                 DPRINTF(("ibcs2_ioctl(td=%p): TCSBRK ", td));
459                 return ENOSYS;
460
461         case IBCS2_TCXONC:
462             {
463                 switch ((int)SCARG(uap, data)) {
464                 case 0:
465                 case 1:
466                         DPRINTF(("ibcs2_ioctl(td=%p): TCXONC ", td));
467                         return ENOSYS;
468                 case 2:
469                         return fo_ioctl(fp, TIOCSTOP, (caddr_t)0, td);
470                 case 3:
471                         return fo_ioctl(fp, TIOCSTART, (caddr_t)1, td);
472                 default:
473                         return EINVAL;
474                 }
475             }
476
477         case IBCS2_TCFLSH:
478             {
479                 int arg;
480
481                 switch ((int)SCARG(uap, data)) {
482                 case 0:
483                         arg = FREAD;
484                         break;
485                 case 1:
486                         arg = FWRITE;
487                         break;
488                 case 2:
489                         arg = FREAD | FWRITE;
490                         break;
491                 default:
492                         return EINVAL;
493                 }
494                 return fo_ioctl(fp, TIOCFLUSH, (caddr_t)&arg, td);
495             }
496
497         case IBCS2_TIOCGWINSZ:
498                 SCARG(uap, cmd) = TIOCGWINSZ;
499                 return ioctl((struct ioctl_args *)uap);
500
501         case IBCS2_TIOCSWINSZ:
502                 SCARG(uap, cmd) = TIOCSWINSZ;
503                 return ioctl((struct ioctl_args *)uap);
504
505         case IBCS2_TIOCGPGRP:
506                 return copyout((caddr_t)&p->p_pgrp->pg_id, SCARG(uap, data),
507                                 sizeof(p->p_pgrp->pg_id));
508
509         case IBCS2_TIOCSPGRP:   /* XXX - is uap->data a pointer to pgid? */
510             {
511                 struct setpgid_args sa;
512
513                 SCARG(&sa, pid) = 0;
514                 SCARG(&sa, pgid) = (int)SCARG(uap, data);
515                 if ((error = setpgid(&sa)) != 0)
516                         return error;
517                 return 0;
518             }
519
520         case IBCS2_TCGETSC:     /* SCO console - get scancode flags */
521                 return EINTR;  /* ENOSYS; */
522
523         case IBCS2_TCSETSC:     /* SCO console - set scancode flags */
524                 return 0;   /* ENOSYS; */
525
526         case IBCS2_JWINSIZE:    /* Unix to Jerq I/O control */
527             {
528                 struct ibcs2_jwinsize {
529                   char bytex, bytey; 
530                   short bitx, bity;
531                 } ibcs2_jwinsize;
532
533                 ibcs2_jwinsize.bytex = 80;
534                   /* p->p_session->s_ttyp->t_winsize.ws_col; XXX */
535                 ibcs2_jwinsize.bytey = 25;
536                   /* p->p_session->s_ttyp->t_winsize.ws_row; XXX */
537                 ibcs2_jwinsize.bitx = 
538                   p->p_session->s_ttyp->t_winsize.ws_xpixel;
539                 ibcs2_jwinsize.bity =
540                   p->p_session->s_ttyp->t_winsize.ws_ypixel;
541                 return copyout((caddr_t)&ibcs2_jwinsize, SCARG(uap, data),
542                                sizeof(ibcs2_jwinsize));
543              }
544
545         /* keyboard and display ioctl's -- type 'K' */
546         case IBCS2_KDGKBMODE:        /* get keyboard translation mode */
547                 SCARG(uap, cmd) = KDGKBMODE;
548 /* printf("ioctl KDGKBMODE = %x\n", SCARG(uap, cmd));*/
549                 return ioctl((struct ioctl_args *)uap);
550
551         case IBCS2_KDSKBMODE:        /* set keyboard translation mode */
552                 SCARG(uap, cmd) = KDSKBMODE;
553                 return ioctl((struct ioctl_args *)uap);
554
555         case IBCS2_KDMKTONE:        /* sound tone */
556                 SCARG(uap, cmd) = KDMKTONE;
557                 return ioctl((struct ioctl_args *)uap);
558
559         case IBCS2_KDGETMODE:        /* get text/graphics mode */  
560                 SCARG(uap, cmd) = KDGETMODE;
561                 return ioctl((struct ioctl_args *)uap);
562
563         case IBCS2_KDSETMODE:       /* set text/graphics mode */
564                 SCARG(uap, cmd) = KDSETMODE;
565                 return ioctl((struct ioctl_args *)uap);
566
567         case IBCS2_KDSBORDER:       /* set ega color border */
568                 SCARG(uap, cmd) = KDSBORDER;
569                 return ioctl((struct ioctl_args *)uap);
570
571         case IBCS2_KDGKBSTATE:
572                 SCARG(uap, cmd) = KDGKBSTATE;
573                 return ioctl((struct ioctl_args *)uap);
574
575         case IBCS2_KDSETRAD:
576                 SCARG(uap, cmd) = KDSETRAD;
577                 return ioctl((struct ioctl_args *)uap);
578
579         case IBCS2_KDENABIO:       /* enable direct I/O to ports */
580                 SCARG(uap, cmd) = KDENABIO;
581                 return ioctl((struct ioctl_args *)uap);
582
583         case IBCS2_KDDISABIO:       /* disable direct I/O to ports */
584                 SCARG(uap, cmd) = KDDISABIO;
585                 return ioctl((struct ioctl_args *)uap);
586
587         case IBCS2_KIOCSOUND:       /* start sound generation */
588                 SCARG(uap, cmd) = KIOCSOUND;
589                 return ioctl((struct ioctl_args *)uap);
590
591         case IBCS2_KDGKBTYPE:       /* get keyboard type */
592                 SCARG(uap, cmd) = KDGKBTYPE;
593                 return ioctl((struct ioctl_args *)uap);
594
595         case IBCS2_KDGETLED:       /* get keyboard LED status */
596                 SCARG(uap, cmd) = KDGETLED;
597                 return ioctl((struct ioctl_args *)uap);
598
599         case IBCS2_KDSETLED:       /* set keyboard LED status */
600                 SCARG(uap, cmd) = KDSETLED;
601                 return ioctl((struct ioctl_args *)uap);
602
603             /* Xenix keyboard and display ioctl's from sys/kd.h -- type 'k' */
604         case IBCS2_GETFKEY:      /* Get function key */
605                 SCARG(uap, cmd) = GETFKEY;
606                 return ioctl((struct ioctl_args *)uap);
607
608         case IBCS2_SETFKEY:      /* Set function key */
609                 SCARG(uap, cmd) = SETFKEY;
610                 return ioctl((struct ioctl_args *)uap);
611
612         case IBCS2_GIO_SCRNMAP:      /* Get screen output map table */
613                 SCARG(uap, cmd) = GIO_SCRNMAP;
614                 return ioctl((struct ioctl_args *)uap);
615
616         case IBCS2_PIO_SCRNMAP:      /* Set screen output map table */
617                 SCARG(uap, cmd) = PIO_SCRNMAP;
618                 return ioctl((struct ioctl_args *)uap);
619
620         case IBCS2_GIO_KEYMAP:      /* Get keyboard map table */
621                 SCARG(uap, cmd) = GIO_KEYMAP;
622                 return ioctl((struct ioctl_args *)uap);
623
624         case IBCS2_PIO_KEYMAP:      /* Set keyboard map table */
625                 SCARG(uap, cmd) = PIO_KEYMAP;
626                 return ioctl((struct ioctl_args *)uap);
627
628             /* socksys */
629         case IBCS2_SIOCSOCKSYS:
630                 return ibcs2_socksys((struct ibcs2_socksys_args *)uap);
631
632         case IBCS2_I_NREAD:     /* STREAMS */
633                 SCARG(uap, cmd) = FIONREAD;
634                 return ioctl((struct ioctl_args *)uap);
635
636         default:
637                 DPRINTF(("ibcs2_ioctl(%d): unknown cmd 0x%lx ",
638                          p->p_pid, SCARG(uap, cmd)));
639                 return ENOSYS;
640         }
641         return ENOSYS;
642 }