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.3 2003/06/23 17:55:38 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 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(&ioctl_arg);
  68 }
  69
  70 int
  71 ibcs2_stty(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(&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(struct ibcs2_ioctl_args *uap)
 339 {
 340         struct proc *p = curproc;
 341         struct filedesc *fdp = p->p_fd;
 342         struct file *fp;
 343         int error;
 344
 345         if (SCARG(uap, fd) < 0 || SCARG(uap, fd) >= fdp->fd_nfiles ||
 346             (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) {
 347                 DPRINTF(("ibcs2_ioctl(%d): bad fd %d ", p->p_pid,
 348                          SCARG(uap, fd)));
 349                 return EBADF;
 350         }
 351
 352         if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
 353                 DPRINTF(("ibcs2_ioctl(%d): bad fp flag ", p->p_pid));
 354                 return EBADF;
 355         }
 356
 357         switch (SCARG(uap, cmd)) {
 358         case IBCS2_TCGETA:
 359         case IBCS2_XCGETA:
 360         case IBCS2_OXCGETA:
 361             {
 362                 struct termios bts;
 363                 struct ibcs2_termios sts;
 364                 struct ibcs2_termio st;
 365
 366                 if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, p)) != 0)
 367                         return error;
 368
 369                 btios2stios (&bts, &sts);
 370                 if (SCARG(uap, cmd) == IBCS2_TCGETA) {
 371                         stios2stio (&sts, &st);
 372                         error = copyout((caddr_t)&st, SCARG(uap, data),
 373                                         sizeof (st));
 374 #ifdef DEBUG_IBCS2
 375                         if (error)
 376                                 DPRINTF(("ibcs2_ioctl(%d): copyout failed ",
 377                                          p->p_pid));
 378 #endif
 379                         return error;
 380                 } else
 381                         return copyout((caddr_t)&sts, SCARG(uap, data),
 382                                         sizeof (sts));
 383                 /*NOTREACHED*/
 384             }
 385
 386         case IBCS2_TCSETA:
 387         case IBCS2_TCSETAW:
 388         case IBCS2_TCSETAF:
 389             {
 390                 struct termios bts;
 391                 struct ibcs2_termios sts;
 392                 struct ibcs2_termio st;
 393
 394                 if ((error = copyin(SCARG(uap, data), (caddr_t)&st,
 395                                     sizeof(st))) != 0) {
 396                         DPRINTF(("ibcs2_ioctl(%d): TCSET copyin failed ",
 397                                  p->p_pid));
 398                         return error;
 399                 }
 400
 401                 /* get full BSD termios so we don't lose information */
 402                 if ((error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bts, p)) != 0) {
 403                         DPRINTF(("ibcs2_ioctl(%d): TCSET ctl failed fd %d ",
 404                                  p->p_pid, SCARG(uap, fd)));
 405                         return error;
 406                 }
 407
 408                 /*
 409                  * convert to iBCS2 termios, copy in information from
 410                  * termio, and convert back, then set new values.
 411                  */
 412                 btios2stios(&bts, &sts);
 413                 stio2stios(&st, &sts);
 414                 stios2btios(&sts, &bts);
 415
 416                 return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_TCSETA + TIOCSETA,
 417                               (caddr_t)&bts, p);
 418             }
 419
 420         case IBCS2_XCSETA:
 421         case IBCS2_XCSETAW:
 422         case IBCS2_XCSETAF:
 423             {
 424                 struct termios bts;
 425                 struct ibcs2_termios sts;
 426
 427                 if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
 428                                     sizeof (sts))) != 0) {
 429                         return error;
 430                 }
 431                 stios2btios (&sts, &bts);
 432                 return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_XCSETA + TIOCSETA,
 433                               (caddr_t)&bts, p);
 434             }
 435
 436         case IBCS2_OXCSETA:
 437         case IBCS2_OXCSETAW:
 438         case IBCS2_OXCSETAF:
 439             {
 440                 struct termios bts;
 441                 struct ibcs2_termios sts;
 442
 443                 if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
 444                                     sizeof (sts))) != 0) {
 445                         return error;
 446                 }
 447                 stios2btios (&sts, &bts);
 448                 return fo_ioctl(fp, SCARG(uap, cmd) - IBCS2_OXCSETA + TIOCSETA,
 449                               (caddr_t)&bts, p);
 450             }
 451
 452         case IBCS2_TCSBRK:
 453                 DPRINTF(("ibcs2_ioctl(%d): TCSBRK ", p->p_pid));
 454                 return ENOSYS;
 455
 456         case IBCS2_TCXONC:
 457             {
 458                 switch ((int)SCARG(uap, data)) {
 459                 case 0:
 460                 case 1:
 461                         DPRINTF(("ibcs2_ioctl(%d): TCXONC ", p->p_pid));
 462                         return ENOSYS;
 463                 case 2:
 464                         return fo_ioctl(fp, TIOCSTOP, (caddr_t)0, p);
 465                 case 3:
 466                         return fo_ioctl(fp, TIOCSTART, (caddr_t)1, p);
 467                 default:
 468                         return EINVAL;
 469                 }
 470             }
 471
 472         case IBCS2_TCFLSH:
 473             {
 474                 int arg;
 475
 476                 switch ((int)SCARG(uap, data)) {
 477                 case 0:
 478                         arg = FREAD;
 479                         break;
 480                 case 1:
 481                         arg = FWRITE;
 482                         break;
 483                 case 2:
 484                         arg = FREAD | FWRITE;
 485                         break;
 486                 default:
 487                         return EINVAL;
 488                 }
 489                 return fo_ioctl(fp, TIOCFLUSH, (caddr_t)&arg, p);
 490             }
 491
 492         case IBCS2_TIOCGWINSZ:
 493                 SCARG(uap, cmd) = TIOCGWINSZ;
 494                 return ioctl((struct ioctl_args *)uap);
 495
 496         case IBCS2_TIOCSWINSZ:
 497                 SCARG(uap, cmd) = TIOCSWINSZ;
 498                 return ioctl((struct ioctl_args *)uap);
 499
 500         case IBCS2_TIOCGPGRP:
 501                 return copyout((caddr_t)&p->p_pgrp->pg_id, SCARG(uap, data),
 502                                 sizeof(p->p_pgrp->pg_id));
 503
 504         case IBCS2_TIOCSPGRP:   /* XXX - is uap->data a pointer to pgid? */
 505             {
 506                 struct setpgid_args sa;
 507
 508                 SCARG(&sa, pid) = 0;
 509                 SCARG(&sa, pgid) = (int)SCARG(uap, data);
 510                 if ((error = setpgid(&sa)) != 0)
 511                         return error;
 512                 return 0;
 513             }
 514
 515         case IBCS2_TCGETSC:     /* SCO console - get scancode flags */
 516                 return EINTR;  /* ENOSYS; */
 517
 518         case IBCS2_TCSETSC:     /* SCO console - set scancode flags */
 519                 return 0;   /* ENOSYS; */
 520
 521         case IBCS2_JWINSIZE:    /* Unix to Jerq I/O control */
 522             {
 523                 struct ibcs2_jwinsize {
 524                   char bytex, bytey;
 525                   short bitx, bity;
 526                 } ibcs2_jwinsize;
 527
 528                 ibcs2_jwinsize.bytex = 80;
 529                   /* p->p_session->s_ttyp->t_winsize.ws_col; XXX */
 530                 ibcs2_jwinsize.bytey = 25;
 531                   /* p->p_session->s_ttyp->t_winsize.ws_row; XXX */
 532                 ibcs2_jwinsize.bitx =
 533                   p->p_session->s_ttyp->t_winsize.ws_xpixel;
 534                 ibcs2_jwinsize.bity =
 535                   p->p_session->s_ttyp->t_winsize.ws_ypixel;
 536                 return copyout((caddr_t)&ibcs2_jwinsize, SCARG(uap, data),
 537                                sizeof(ibcs2_jwinsize));
 538              }
 539
 540         /* keyboard and display ioctl's -- type 'K' */
 541         case IBCS2_KDGKBMODE:        /* get keyboard translation mode */
 542                 SCARG(uap, cmd) = KDGKBMODE;
 543 /* printf("ioctl KDGKBMODE = %x\n", SCARG(uap, cmd));*/
 544                 return ioctl((struct ioctl_args *)uap);
 545
 546         case IBCS2_KDSKBMODE:        /* set keyboard translation mode */
 547                 SCARG(uap, cmd) = KDSKBMODE;
 548                 return ioctl((struct ioctl_args *)uap);
 549
 550         case IBCS2_KDMKTONE:        /* sound tone */
 551                 SCARG(uap, cmd) = KDMKTONE;
 552                 return ioctl((struct ioctl_args *)uap);
 553
 554         case IBCS2_KDGETMODE:        /* get text/graphics mode */
 555                 SCARG(uap, cmd) = KDGETMODE;
 556                 return ioctl((struct ioctl_args *)uap);
 557
 558         case IBCS2_KDSETMODE:       /* set text/graphics mode */
 559                 SCARG(uap, cmd) = KDSETMODE;
 560                 return ioctl((struct ioctl_args *)uap);
 561
 562         case IBCS2_KDSBORDER:       /* set ega color border */
 563                 SCARG(uap, cmd) = KDSBORDER;
 564                 return ioctl((struct ioctl_args *)uap);
 565
 566         case IBCS2_KDGKBSTATE:
 567                 SCARG(uap, cmd) = KDGKBSTATE;
 568                 return ioctl((struct ioctl_args *)uap);
 569
 570         case IBCS2_KDSETRAD:
 571                 SCARG(uap, cmd) = KDSETRAD;
 572                 return ioctl((struct ioctl_args *)uap);
 573
 574         case IBCS2_KDENABIO:       /* enable direct I/O to ports */
 575                 SCARG(uap, cmd) = KDENABIO;
 576                 return ioctl((struct ioctl_args *)uap);
 577
 578         case IBCS2_KDDISABIO:       /* disable direct I/O to ports */
 579                 SCARG(uap, cmd) = KDDISABIO;
 580                 return ioctl((struct ioctl_args *)uap);
 581
 582         case IBCS2_KIOCSOUND:       /* start sound generation */
 583                 SCARG(uap, cmd) = KIOCSOUND;
 584                 return ioctl((struct ioctl_args *)uap);
 585
 586         case IBCS2_KDGKBTYPE:       /* get keyboard type */
 587                 SCARG(uap, cmd) = KDGKBTYPE;
 588                 return ioctl((struct ioctl_args *)uap);
 589
 590         case IBCS2_KDGETLED:       /* get keyboard LED status */
 591                 SCARG(uap, cmd) = KDGETLED;
 592                 return ioctl((struct ioctl_args *)uap);
 593
 594         case IBCS2_KDSETLED:       /* set keyboard LED status */
 595                 SCARG(uap, cmd) = KDSETLED;
 596                 return ioctl((struct ioctl_args *)uap);
 597
 598             /* Xenix keyboard and display ioctl's from sys/kd.h -- type 'k' */
 599         case IBCS2_GETFKEY:      /* Get function key */
 600                 SCARG(uap, cmd) = GETFKEY;
 601                 return ioctl((struct ioctl_args *)uap);
 602
 603         case IBCS2_SETFKEY:      /* Set function key */
 604                 SCARG(uap, cmd) = SETFKEY;
 605                 return ioctl((struct ioctl_args *)uap);
 606
 607         case IBCS2_GIO_SCRNMAP:      /* Get screen output map table */
 608                 SCARG(uap, cmd) = GIO_SCRNMAP;
 609                 return ioctl((struct ioctl_args *)uap);
 610
 611         case IBCS2_PIO_SCRNMAP:      /* Set screen output map table */
 612                 SCARG(uap, cmd) = PIO_SCRNMAP;
 613                 return ioctl((struct ioctl_args *)uap);
 614
 615         case IBCS2_GIO_KEYMAP:      /* Get keyboard map table */
 616                 SCARG(uap, cmd) = GIO_KEYMAP;
 617                 return ioctl((struct ioctl_args *)uap);
 618
 619         case IBCS2_PIO_KEYMAP:      /* Set keyboard map table */
 620                 SCARG(uap, cmd) = PIO_KEYMAP;
 621                 return ioctl((struct ioctl_args *)uap);
 622
 623             /* socksys */
 624         case IBCS2_SIOCSOCKSYS:
 625                 return ibcs2_socksys((struct ibcs2_socksys_args *)uap);
 626
 627         case IBCS2_I_NREAD:     /* STREAMS */
 628                 SCARG(uap, cmd) = FIONREAD;
 629                 return ioctl((struct ioctl_args *)uap);
 630
 631         default:
 632                 DPRINTF(("ibcs2_ioctl(%d): unknown cmd 0x%lx ",
 633                          p->p_pid, SCARG(uap, cmd)));
 634                 return ENOSYS;
 635         }
 636         return ENOSYS;
 637 }