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.2 2003/06/17 04:28:35 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/ioctl_compat.h>
  39 #include <sys/tty.h>
  40 #include <machine/console.h>
  41
  42 #include <sys/sysproto.h>
  43
  44 #include <i386/ibcs2/ibcs2_signal.h>
  45 #include <i386/ibcs2/ibcs2_socksys.h>
  46 #include <i386/ibcs2/ibcs2_stropts.h>
  47 #include <i386/ibcs2/ibcs2_proto.h>
  48 #include <i386/ibcs2/ibcs2_termios.h>
  49 #include <i386/ibcs2/ibcs2_util.h>
  50 #include <i386/ibcs2/ibcs2_ioctl.h>
  51
  52 static void stios2btios __P((struct ibcs2_termios *, struct termios *));
  53 static void btios2stios __P((struct termios *, struct ibcs2_termios *));
  54 static void stios2stio  __P((struct ibcs2_termios *, struct ibcs2_termio *));
  55 static void stio2stios  __P((struct ibcs2_termio *, struct ibcs2_termios *));
  56
  57
  58 int
  59 ibcs2_gtty(struct proc *p, struct ibcs2_gtty_args *args)
  60 {
  61         struct ioctl_args ioctl_arg;
  62
  63         ioctl_arg.fd = args->fd;
  64         ioctl_arg.com = TIOCGETC;
  65         ioctl_arg.data = (caddr_t)args->buf;
  66
  67         return ioctl(p, &ioctl_arg);
  68 }
  69
  70 int
  71 ibcs2_stty(struct proc *p, struct ibcs2_stty_args *args)
  72 {
  73         struct ioctl_args ioctl_arg;
  74
  75         ioctl_arg.fd = args->fd;
  76         ioctl_arg.com = TIOCSETC;
  77         ioctl_arg.data = (caddr_t)args->buf;
  78
  79         return ioctl(p, &ioctl_arg);
  80 }
  81
  82
  83 /*
  84  * iBCS2 ioctl calls.
  85  */
  86
  87 static struct speedtab sptab[] = {
  88         { 0, 0 },
  89         { 50, 1 },
  90         { 75, 2 },
  91         { 110, 3 },
  92         { 134, 4 },
  93         { 135, 4 },
  94         { 150, 5 },
  95         { 200, 6 },
  96         { 300, 7 },
  97         { 600, 8 },
  98         { 1200, 9 },
  99         { 1800, 10 },
 100         { 2400, 11 },
 101         { 4800, 12 },
 102         { 9600, 13 },
 103         { 19200, 14 },
 104         { 38400, 15 },
 105         { -1, -1 }
 106 };
 107
 108 static u_long s2btab[] = {
 109         0,
 110         50,
 111         75,
 112         110,
 113         134,
 114         150,
 115         200,
 116         300,
 117         600,
 118         1200,
 119         1800,
 120         2400,
 121         4800,
 122         9600,
 123         19200,
 124         38400,
 125 };
 126
 127 static void
 128 stios2btios(st, bt)
 129         struct ibcs2_termios *st;
 130         struct termios *bt;
 131 {
 132         register u_long l, r;
 133
 134         l = st->c_iflag;        r = 0;
 135         if (l & IBCS2_IGNBRK)   r |= IGNBRK;
 136         if (l & IBCS2_BRKINT)   r |= BRKINT;
 137         if (l & IBCS2_IGNPAR)   r |= IGNPAR;
 138         if (l & IBCS2_PARMRK)   r |= PARMRK;
 139         if (l & IBCS2_INPCK)    r |= INPCK;
 140         if (l & IBCS2_ISTRIP)   r |= ISTRIP;
 141         if (l & IBCS2_INLCR)    r |= INLCR;
 142         if (l & IBCS2_IGNCR)    r |= IGNCR;
 143         if (l & IBCS2_ICRNL)    r |= ICRNL;
 144         if (l & IBCS2_IXON)     r |= IXON;
 145         if (l & IBCS2_IXANY)    r |= IXANY;
 146         if (l & IBCS2_IXOFF)    r |= IXOFF;
 147         if (l & IBCS2_IMAXBEL)  r |= IMAXBEL;
 148         bt->c_iflag = r;
 149
 150         l = st->c_oflag;        r = 0;
 151         if (l & IBCS2_OPOST)    r |= OPOST;
 152         if (l & IBCS2_ONLCR)    r |= ONLCR;
 153         if (l & IBCS2_TAB3)     r |= OXTABS;
 154         bt->c_oflag = r;
 155
 156         l = st->c_cflag;        r = 0;
 157         switch (l & IBCS2_CSIZE) {
 158         case IBCS2_CS5:         r |= CS5; break;
 159         case IBCS2_CS6:         r |= CS6; break;
 160         case IBCS2_CS7:         r |= CS7; break;
 161         case IBCS2_CS8:         r |= CS8; break;
 162         }
 163         if (l & IBCS2_CSTOPB)   r |= CSTOPB;
 164         if (l & IBCS2_CREAD)    r |= CREAD;
 165         if (l & IBCS2_PARENB)   r |= PARENB;
 166         if (l & IBCS2_PARODD)   r |= PARODD;
 167         if (l & IBCS2_HUPCL)    r |= HUPCL;
 168         if (l & IBCS2_CLOCAL)   r |= CLOCAL;
 169         bt->c_cflag = r;
 170
 171         bt->c_ispeed = bt->c_ospeed = s2btab[l & 0x0000000f];
 172
 173         l = st->c_lflag;        r = 0;
 174         if (l & IBCS2_ISIG)     r |= ISIG;
 175         if (l & IBCS2_ICANON)   r |= ICANON;
 176         if (l & IBCS2_ECHO)     r |= ECHO;
 177         if (l & IBCS2_ECHOE)    r |= ECHOE;
 178         if (l & IBCS2_ECHOK)    r |= ECHOK;
 179         if (l & IBCS2_ECHONL)   r |= ECHONL;
 180         if (l & IBCS2_NOFLSH)   r |= NOFLSH;
 181         if (l & IBCS2_TOSTOP)   r |= TOSTOP;
 182         bt->c_lflag = r;
 183
 184         bt->c_cc[VINTR] =
 185             st->c_cc[IBCS2_VINTR]  ? st->c_cc[IBCS2_VINTR]  : _POSIX_VDISABLE;
 186         bt->c_cc[VQUIT] =
 187             st->c_cc[IBCS2_VQUIT]  ? st->c_cc[IBCS2_VQUIT]  : _POSIX_VDISABLE;
 188         bt->c_cc[VERASE] =
 189             st->c_cc[IBCS2_VERASE] ? st->c_cc[IBCS2_VERASE] : _POSIX_VDISABLE;
 190         bt->c_cc[VKILL] =
 191             st->c_cc[IBCS2_VKILL]  ? st->c_cc[IBCS2_VKILL]  : _POSIX_VDISABLE;
 192         if (bt->c_lflag & ICANON) {
 193                 bt->c_cc[VEOF] =
 194                     st->c_cc[IBCS2_VEOF] ? st->c_cc[IBCS2_VEOF] : _POSIX_VDISABLE;
 195                 bt->c_cc[VEOL] =
 196                     st->c_cc[IBCS2_VEOL] ? st->c_cc[IBCS2_VEOL] : _POSIX_VDISABLE;
 197         } else {
 198                 bt->c_cc[VMIN]  = st->c_cc[IBCS2_VMIN];
 199                 bt->c_cc[VTIME] = st->c_cc[IBCS2_VTIME];
 200         }
 201         bt->c_cc[VEOL2] =
 202             st->c_cc[IBCS2_VEOL2]  ? st->c_cc[IBCS2_VEOL2]  : _POSIX_VDISABLE;
 203 #if 0
 204         bt->c_cc[VSWTCH] =
 205             st->c_cc[IBCS2_VSWTCH] ? st->c_cc[IBCS2_VSWTCH] : _POSIX_VDISABLE;
 206 #endif
 207         bt->c_cc[VSTART] =
 208             st->c_cc[IBCS2_VSTART] ? st->c_cc[IBCS2_VSTART] : _POSIX_VDISABLE;
 209         bt->c_cc[VSTOP] =
 210             st->c_cc[IBCS2_VSTOP]  ? st->c_cc[IBCS2_VSTOP]  : _POSIX_VDISABLE;
 211         bt->c_cc[VSUSP] =
 212             st->c_cc[IBCS2_VSUSP]  ? st->c_cc[IBCS2_VSUSP]  : _POSIX_VDISABLE;
 213         bt->c_cc[VDSUSP]   = _POSIX_VDISABLE;
 214         bt->c_cc[VREPRINT] = _POSIX_VDISABLE;
 215         bt->c_cc[VDISCARD] = _POSIX_VDISABLE;
 216         bt->c_cc[VWERASE]  = _POSIX_VDISABLE;
 217         bt->c_cc[VLNEXT]   = _POSIX_VDISABLE;
 218         bt->c_cc[VSTATUS]  = _POSIX_VDISABLE;
 219 }
 220
 221 static void
 222 btios2stios(bt, st)
 223         struct termios *bt;
 224         struct ibcs2_termios *st;
 225 {
 226         register u_long l, r;
 227
 228         l = bt->c_iflag;        r = 0;
 229         if (l & IGNBRK)         r |= IBCS2_IGNBRK;
 230         if (l & BRKINT)         r |= IBCS2_BRKINT;
 231         if (l & IGNPAR)         r |= IBCS2_IGNPAR;
 232         if (l & PARMRK)         r |= IBCS2_PARMRK;
 233         if (l & INPCK)          r |= IBCS2_INPCK;
 234         if (l & ISTRIP)         r |= IBCS2_ISTRIP;
 235         if (l & INLCR)          r |= IBCS2_INLCR;
 236         if (l & IGNCR)          r |= IBCS2_IGNCR;
 237         if (l & ICRNL)          r |= IBCS2_ICRNL;
 238         if (l & IXON)           r |= IBCS2_IXON;
 239         if (l & IXANY)          r |= IBCS2_IXANY;
 240         if (l & IXOFF)          r |= IBCS2_IXOFF;
 241         if (l & IMAXBEL)        r |= IBCS2_IMAXBEL;
 242         st->c_iflag = r;
 243
 244         l = bt->c_oflag;        r = 0;
 245         if (l & OPOST)          r |= IBCS2_OPOST;
 246         if (l & ONLCR)          r |= IBCS2_ONLCR;
 247         if (l & OXTABS)         r |= IBCS2_TAB3;
 248         st->c_oflag = r;
 249
 250         l = bt->c_cflag;        r = 0;
 251         switch (l & CSIZE) {
 252         case CS5:               r |= IBCS2_CS5; break;
 253         case CS6:               r |= IBCS2_CS6; break;
 254         case CS7:               r |= IBCS2_CS7; break;
 255         case CS8:               r |= IBCS2_CS8; break;
 256         }
 257         if (l & CSTOPB)         r |= IBCS2_CSTOPB;
 258         if (l & CREAD)          r |= IBCS2_CREAD;
 259         if (l & PARENB)         r |= IBCS2_PARENB;
 260         if (l & PARODD)         r |= IBCS2_PARODD;
 261         if (l & HUPCL)          r |= IBCS2_HUPCL;
 262         if (l & CLOCAL)         r |= IBCS2_CLOCAL;
 263         st->c_cflag = r;
 264
 265         l = bt->c_lflag;        r = 0;
 266         if (l & ISIG)           r |= IBCS2_ISIG;
 267         if (l & ICANON)         r |= IBCS2_ICANON;
 268         if (l & ECHO)           r |= IBCS2_ECHO;
 269         if (l & ECHOE)          r |= IBCS2_ECHOE;
 270         if (l & ECHOK)          r |= IBCS2_ECHOK;
 271         if (l & ECHONL)         r |= IBCS2_ECHONL;
 272         if (l & NOFLSH)         r |= IBCS2_NOFLSH;
 273         if (l & TOSTOP)         r |= IBCS2_TOSTOP;
 274         st->c_lflag = r;
 275
 276         l = ttspeedtab(bt->c_ospeed, sptab);
 277         if ((int)l >= 0)
 278                 st->c_cflag |= l;
 279
 280         st->c_cc[IBCS2_VINTR] =
 281             bt->c_cc[VINTR]  != _POSIX_VDISABLE ? bt->c_cc[VINTR]  : 0;
 282         st->c_cc[IBCS2_VQUIT] =
 283             bt->c_cc[VQUIT]  != _POSIX_VDISABLE ? bt->c_cc[VQUIT]  : 0;
 284         st->c_cc[IBCS2_VERASE] =
 285             bt->c_cc[VERASE] != _POSIX_VDISABLE ? bt->c_cc[VERASE] : 0;
 286         st->c_cc[IBCS2_VKILL] =
 287             bt->c_cc[VKILL]  != _POSIX_VDISABLE ? bt->c_cc[VKILL]  : 0;
 288         if (bt->c_lflag & ICANON) {
 289                 st->c_cc[IBCS2_VEOF] =
 290                     bt->c_cc[VEOF] != _POSIX_VDISABLE ? bt->c_cc[VEOF] : 0;
 291                 st->c_cc[IBCS2_VEOL] =
 292                     bt->c_cc[VEOL] != _POSIX_VDISABLE ? bt->c_cc[VEOL] : 0;
 293         } else {
 294                 st->c_cc[IBCS2_VMIN]  = bt->c_cc[VMIN];
 295                 st->c_cc[IBCS2_VTIME] = bt->c_cc[VTIME];
 296         }
 297         st->c_cc[IBCS2_VEOL2] =
 298             bt->c_cc[VEOL2]  != _POSIX_VDISABLE ? bt->c_cc[VEOL2]  : 0;
 299         st->c_cc[IBCS2_VSWTCH] =
 300             0;
 301         st->c_cc[IBCS2_VSUSP] =
 302             bt->c_cc[VSUSP]  != _POSIX_VDISABLE ? bt->c_cc[VSUSP]  : 0;
 303         st->c_cc[IBCS2_VSTART] =
 304             bt->c_cc[VSTART] != _POSIX_VDISABLE ? bt->c_cc[VSTART] : 0;
 305         st->c_cc[IBCS2_VSTOP] =
 306             bt->c_cc[VSTOP]  != _POSIX_VDISABLE ? bt->c_cc[VSTOP]  : 0;
 307
 308         st->c_line = 0;
 309 }
 310
 311 static void
 312 stios2stio(ts, t)
 313         struct ibcs2_termios *ts;
 314         struct ibcs2_termio *t;
 315 {
 316         t->c_iflag = ts->c_iflag;
 317         t->c_oflag = ts->c_oflag;
 318         t->c_cflag = ts->c_cflag;
 319         t->c_lflag = ts->c_lflag;
 320         t->c_line  = ts->c_line;
 321         bcopy(ts->c_cc, t->c_cc, IBCS2_NCC);
 322 }
 323
 324 static void
 325 stio2stios(t, ts)
 326         struct ibcs2_termio *t;
 327         struct ibcs2_termios *ts;
 328 {
 329         ts->c_iflag = t->c_iflag;
 330         ts->c_oflag = t->c_oflag;
 331         ts->c_cflag = t->c_cflag;
 332         ts->c_lflag = t->c_lflag;
 333         ts->c_line  = t->c_line;
 334         bcopy(t->c_cc, ts->c_cc, IBCS2_NCC);
 335 }
 336
 337 int
 338 ibcs2_ioctl(p, uap)
 339         struct proc *p;
 340         struct ibcs2_ioctl_args *uap;
 341 {
 342         struct filedesc *fdp = p->p_fd;
 343         struct file *fp;
 344         int error;
 345
 346         if (SCARG(uap, fd) < 0 || SCARG(uap, fd) >= fdp->fd_nfiles ||
 347             (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) {
 348                 DPRINTF(("ibcs2_ioctl(%d): bad fd %d ", p->p_pid,
 349                          SCARG(uap, fd)));
 350                 return EBADF;
 351         }
 352
 353         if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
 354                 DPRINTF(("ibcs2_ioctl(%d): bad fp flag ", p->p_pid));
 355                 return EBADF;
 356         }
 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 = fo_ioctl(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 = fo_ioctl(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 fo_ioctl(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 fo_ioctl(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 fo_ioctl(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 fo_ioctl(fp, TIOCSTOP, (caddr_t)0, p);
 466                 case 3:
 467                         return fo_ioctl(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 fo_ioctl(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)) != 0)
 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 }