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