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