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