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/capability.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 54static void stios2btios(struct ibcs2_termios *, struct termios *); 55static void btios2stios(struct termios *, struct ibcs2_termios *); 56static void stios2stio(struct ibcs2_termios *, struct ibcs2_termio *); 57static void stio2stios(struct ibcs2_termio *, struct ibcs2_termios *); 58 59/* 60 * iBCS2 ioctl calls. 61 */ 62 63struct speedtab { 64 int sp_speed; /* Speed. */ 65 int sp_code; /* Code. */ 66}; 67 68static 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 89static 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 108static int 109ttspeedtab(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 118static void 119stios2btios(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 212static void 213btios2stios(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 302static void 303stios2stio(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 315static void 316stio2stios(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 328int 329ibcs2_ioctl(td, uap) 330 struct thread *td; 331 struct ibcs2_ioctl_args *uap; 332{ 333 struct proc *p = td->td_proc; 334 struct file *fp; 335 int error; 336 337 if ((error = fget(td, uap->fd, CAP_IOCTL, &fp)) != 0) { 338 DPRINTF(("ibcs2_ioctl(%d): bad fd %d ", p->p_pid, 339 uap->fd)); 340 return EBADF; 341 } 342 343 if ((fp->f_flag & (FREAD|FWRITE)) == 0) { 344 fdrop(fp, td); 345 DPRINTF(("ibcs2_ioctl(%d): bad fp flag ", p->p_pid)); 346 return EBADF; 347 } 348 349 switch (uap->cmd) { 350 case IBCS2_TCGETA: 351 case IBCS2_XCGETA: 352 case IBCS2_OXCGETA: 353 { 354 struct termios bts; 355 struct ibcs2_termios sts; 356 struct ibcs2_termio st; 357 358 if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, 359 td->td_ucred, td)) != 0) 360 break; 361 362 btios2stios (&bts, &sts); 363 if (uap->cmd == IBCS2_TCGETA) { 364 stios2stio (&sts, &st); 365 error = copyout((caddr_t)&st, uap->data, 366 sizeof (st)); 367#ifdef DEBUG_IBCS2 368 if (error) 369 DPRINTF(("ibcs2_ioctl(%d): copyout failed ", 370 p->p_pid)); 371#endif 372 break; 373 } else { 374 error = copyout((caddr_t)&sts, uap->data, 375 sizeof (sts)); 376 break; 377 } 378 /*NOTREACHED*/ 379 } 380 381 case IBCS2_TCSETA: 382 case IBCS2_TCSETAW: 383 case IBCS2_TCSETAF: 384 { 385 struct termios bts; 386 struct ibcs2_termios sts; 387 struct ibcs2_termio st; 388 389 if ((error = copyin(uap->data, (caddr_t)&st, 390 sizeof(st))) != 0) { 391 DPRINTF(("ibcs2_ioctl(%d): TCSET copyin failed ", 392 p->p_pid)); 393 break; 394 } 395 396 /* get full BSD termios so we don't lose information */ 397 if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, 398 td->td_ucred, td)) != 0) { 399 DPRINTF(("ibcs2_ioctl(%d): TCSET ctl failed fd %d ", 400 p->p_pid, uap->fd)); 401 break; 402 } 403 404 /* 405 * convert to iBCS2 termios, copy in information from 406 * termio, and convert back, then set new values. 407 */ 408 btios2stios(&bts, &sts); 409 stio2stios(&st, &sts); 410 stios2btios(&sts, &bts); 411 412 error = fo_ioctl(fp, uap->cmd - IBCS2_TCSETA + TIOCSETA, 413 (caddr_t)&bts, td->td_ucred, td); 414 break; 415 } 416 417 case IBCS2_XCSETA: 418 case IBCS2_XCSETAW: 419 case IBCS2_XCSETAF: 420 { 421 struct termios bts; 422 struct ibcs2_termios sts; 423 424 if ((error = copyin(uap->data, (caddr_t)&sts, 425 sizeof (sts))) != 0) 426 break; 427 stios2btios (&sts, &bts); 428 error = fo_ioctl(fp, uap->cmd - IBCS2_XCSETA + TIOCSETA, 429 (caddr_t)&bts, td->td_ucred, td); 430 break; 431 } 432 433 case IBCS2_OXCSETA: 434 case IBCS2_OXCSETAW: 435 case IBCS2_OXCSETAF: 436 { 437 struct termios bts; 438 struct ibcs2_termios sts; 439 440 if ((error = copyin(uap->data, (caddr_t)&sts, 441 sizeof (sts))) != 0) 442 break; 443 stios2btios (&sts, &bts); 444 error = fo_ioctl(fp, uap->cmd - IBCS2_OXCSETA + TIOCSETA, 445 (caddr_t)&bts, td->td_ucred, td); 446 break; 447 } 448 449 case IBCS2_TCSBRK: 450 DPRINTF(("ibcs2_ioctl(%d): TCSBRK ", p->p_pid)); 451 error = ENOSYS; 452 break; 453 454 case IBCS2_TCXONC: 455 { 456 switch ((int)uap->data) { 457 case 0: 458 case 1: 459 DPRINTF(("ibcs2_ioctl(%d): TCXONC ", p->p_pid)); 460 error = ENOSYS; 461 break; 462 case 2: 463 error = fo_ioctl(fp, TIOCSTOP, (caddr_t)0, 464 td->td_ucred, td); 465 break; 466 case 3: 467 error = fo_ioctl(fp, TIOCSTART, (caddr_t)1, 468 td->td_ucred, td); 469 break; 470 default: 471 error = EINVAL; 472 break; 473 } 474 break; 475 } 476 477 case IBCS2_TCFLSH: 478 { 479 int arg; 480 481 switch ((int)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 fdrop(fp, td); 493 return EINVAL; 494 } 495 error = fo_ioctl(fp, TIOCFLUSH, (caddr_t)&arg, td->td_ucred, 496 td); 497 break; 498 } 499 500 case IBCS2_TIOCGWINSZ: 501 uap->cmd = TIOCGWINSZ; 502 error = sys_ioctl(td, (struct ioctl_args *)uap); 503 break; 504 505 case IBCS2_TIOCSWINSZ: 506 uap->cmd = TIOCSWINSZ; 507 error = sys_ioctl(td, (struct ioctl_args *)uap); 508 break; 509 510 case IBCS2_TIOCGPGRP: 511 { 512 pid_t pg_id; 513 514 PROC_LOCK(p); 515 pg_id = p->p_pgrp->pg_id; 516 PROC_UNLOCK(p); 517 error = copyout((caddr_t)&pg_id, uap->data, 518 sizeof(pg_id)); 519 break; 520 } 521 522 case IBCS2_TIOCSPGRP: /* XXX - is uap->data a pointer to pgid? */ 523 { 524 struct setpgid_args sa; 525 526 sa.pid = 0; 527 sa.pgid = (int)uap->data; 528 error = sys_setpgid(td, &sa); 529 break; 530 } 531 532 case IBCS2_TCGETSC: /* SCO console - get scancode flags */ 533 error = EINTR; /* ENOSYS; */ 534 break; 535 536 case IBCS2_TCSETSC: /* SCO console - set scancode flags */ 537 error = 0; /* ENOSYS; */ 538 break; 539 540 case IBCS2_JWINSIZE: /* Unix to Jerq I/O control */ 541 { 542 struct ibcs2_jwinsize { 543 char bytex, bytey; 544 short bitx, bity; 545 } ibcs2_jwinsize; 546 547 PROC_LOCK(p); 548 SESS_LOCK(p->p_session); 549 ibcs2_jwinsize.bytex = 80; 550 /* p->p_session->s_ttyp->t_winsize.ws_col; XXX */ 551 ibcs2_jwinsize.bytey = 25; 552 /* p->p_session->s_ttyp->t_winsize.ws_row; XXX */ 553 ibcs2_jwinsize.bitx = 554 p->p_session->s_ttyp->t_winsize.ws_xpixel; 555 ibcs2_jwinsize.bity = 556 p->p_session->s_ttyp->t_winsize.ws_ypixel; 557 SESS_UNLOCK(p->p_session); 558 PROC_UNLOCK(p); 559 error = copyout((caddr_t)&ibcs2_jwinsize, uap->data, 560 sizeof(ibcs2_jwinsize)); 561 break; 562 } 563 564 /* keyboard and display ioctl's -- type 'K' */ 565 case IBCS2_KDGKBMODE: /* get keyboard translation mode */ 566 uap->cmd = KDGKBMODE; 567/* printf("ioctl KDGKBMODE = %x\n", uap->cmd);*/ 568 error = sys_ioctl(td, (struct ioctl_args *)uap); 569 break; 570 571 case IBCS2_KDSKBMODE: /* set keyboard translation mode */ 572 uap->cmd = KDSKBMODE; 573 error = sys_ioctl(td, (struct ioctl_args *)uap); 574 break; 575 576 case IBCS2_KDMKTONE: /* sound tone */ 577 uap->cmd = KDMKTONE; 578 error = sys_ioctl(td, (struct ioctl_args *)uap); 579 break; 580 581 case IBCS2_KDGETMODE: /* get text/graphics mode */ 582 uap->cmd = KDGETMODE; 583 error = sys_ioctl(td, (struct ioctl_args *)uap); 584 break; 585 586 case IBCS2_KDSETMODE: /* set text/graphics mode */ 587 uap->cmd = KDSETMODE; 588 error = sys_ioctl(td, (struct ioctl_args *)uap); 589 break; 590 591 case IBCS2_KDSBORDER: /* set ega color border */ 592 uap->cmd = KDSBORDER; 593 error = sys_ioctl(td, (struct ioctl_args *)uap); 594 break; 595 596 case IBCS2_KDGKBSTATE: 597 uap->cmd = KDGKBSTATE; 598 error = sys_ioctl(td, (struct ioctl_args *)uap); 599 break; 600 601 case IBCS2_KDSETRAD: 602 uap->cmd = KDSETRAD; 603 error = sys_ioctl(td, (struct ioctl_args *)uap); 604 break; 605 606 case IBCS2_KDENABIO: /* enable direct I/O to ports */ 607 uap->cmd = KDENABIO; 608 error = sys_ioctl(td, (struct ioctl_args *)uap); 609 break; 610 611 case IBCS2_KDDISABIO: /* disable direct I/O to ports */ 612 uap->cmd = KDDISABIO; 613 error = sys_ioctl(td, (struct ioctl_args *)uap); 614 break; 615 616 case IBCS2_KIOCSOUND: /* start sound generation */ 617 uap->cmd = KIOCSOUND; 618 error = sys_ioctl(td, (struct ioctl_args *)uap); 619 break; 620 621 case IBCS2_KDGKBTYPE: /* get keyboard type */ 622 uap->cmd = KDGKBTYPE; 623 error = sys_ioctl(td, (struct ioctl_args *)uap); 624 break; 625 626 case IBCS2_KDGETLED: /* get keyboard LED status */ 627 uap->cmd = KDGETLED; 628 error = sys_ioctl(td, (struct ioctl_args *)uap); 629 break; 630 631 case IBCS2_KDSETLED: /* set keyboard LED status */ 632 uap->cmd = KDSETLED; 633 error = sys_ioctl(td, (struct ioctl_args *)uap); 634 break; 635 636 /* Xenix keyboard and display ioctl's from sys/kd.h -- type 'k' */ 637 case IBCS2_GETFKEY: /* Get function key */ 638 uap->cmd = GETFKEY; 639 error = sys_ioctl(td, (struct ioctl_args *)uap); 640 break; 641 642 case IBCS2_SETFKEY: /* Set function key */ 643 uap->cmd = SETFKEY; 644 error = sys_ioctl(td, (struct ioctl_args *)uap); 645 break; 646 647 case IBCS2_GIO_SCRNMAP: /* Get screen output map table */ 648 uap->cmd = GIO_SCRNMAP; 649 error = sys_ioctl(td, (struct ioctl_args *)uap); 650 break; 651 652 case IBCS2_PIO_SCRNMAP: /* Set screen output map table */ 653 uap->cmd = PIO_SCRNMAP; 654 error = sys_ioctl(td, (struct ioctl_args *)uap); 655 break; 656 657 case IBCS2_GIO_KEYMAP: /* Get keyboard map table */ 658 uap->cmd = OGIO_KEYMAP; 659 error = sys_ioctl(td, (struct ioctl_args *)uap); 660 break; 661 662 case IBCS2_PIO_KEYMAP: /* Set keyboard map table */ 663 uap->cmd = OPIO_KEYMAP; 664 error = sys_ioctl(td, (struct ioctl_args *)uap); 665 break; 666 667 /* socksys */ 668 case IBCS2_SIOCSOCKSYS: 669 error = ibcs2_socksys(td, (struct ibcs2_socksys_args *)uap); 670 break; 671 672 case IBCS2_FIONREAD: 673 case IBCS2_I_NREAD: /* STREAMS */ 674 uap->cmd = FIONREAD; 675 error = sys_ioctl(td, (struct ioctl_args *)uap); 676 break; 677 678 default: 679 DPRINTF(("ibcs2_ioctl(%d): unknown cmd 0x%lx ", 680 td->proc->p_pid, uap->cmd)); 681 error = ENOSYS; 682 break; 683 } 684 685 fdrop(fp, td); 686 return error; 687} 688