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