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  */
  30
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/fcntl.h>
  34 #include <sys/file.h>
  35 #include <sys/filedesc.h>
  36 #include <sys/filio.h>
  37 #include <sys/ioctl_compat.h>
  38 #include <sys/tty.h>
  39 #include <machine/console.h>
  40
  41 #include <sys/sysproto.h>
  42
  43 #include <i386/ibcs2/ibcs2_signal.h>
  44 #include <i386/ibcs2/ibcs2_socksys.h>
  45 #include <i386/ibcs2/ibcs2_stropts.h>
  46 #include <i386/ibcs2/ibcs2_proto.h>
  47 #include <i386/ibcs2/ibcs2_termios.h>
  48 #include <i386/ibcs2/ibcs2_util.h>
  49 #include <i386/ibcs2/ibcs2_ioctl.h>
  50
  51 static void stios2btios __P((struct ibcs2_termios *, struct termios *));
  52 static void btios2stios __P((struct termios *, struct ibcs2_termios *));
  53 static void stios2stio  __P((struct ibcs2_termios *, struct ibcs2_termio *));
  54 static void stio2stios  __P((struct ibcs2_termio *, struct ibcs2_termios *));
  55
  56
  57 int
  58 ibcs2_gtty(struct proc *p, struct ibcs2_gtty_args *args)
  59 {
  60         struct ioctl_args ioctl_arg;
  61
  62         ioctl_arg.fd = args->fd;
  63         ioctl_arg.com = TIOCGETC;
  64         ioctl_arg.data = (caddr_t)args->buf;
  65
  66         return ioctl(p, &ioctl_arg);
  67 }
  68
  69 int
  70 ibcs2_stty(struct proc *p, struct ibcs2_stty_args *args)
  71 {
  72         struct ioctl_args ioctl_arg;
  73
  74         ioctl_arg.fd = args->fd;
  75         ioctl_arg.com = TIOCSETC;
  76         ioctl_arg.data = (caddr_t)args->buf;
  77
  78         return ioctl(p, &ioctl_arg);
  79 }
  80
  81
  82 /*
  83  * iBCS2 ioctl calls.
  84  */
  85
  86 static struct speedtab sptab[] = {
  87         { 0, 0 },
  88         { 50, 1 },
  89         { 75, 2 },
  90         { 110, 3 },
  91         { 134, 4 },
  92         { 135, 4 },
  93         { 150, 5 },
  94         { 200, 6 },
  95         { 300, 7 },
  96         { 600, 8 },
  97         { 1200, 9 },
  98         { 1800, 10 },
  99         { 2400, 11 },
 100         { 4800, 12 },
 101         { 9600, 13 },
 102         { 19200, 14 },
 103         { 38400, 15 },
 104         { -1, -1 }
 105 };
 106
 107 static u_long s2btab[] = {
 108         0,
 109         50,
 110         75,
 111         110,
 112         134,
 113         150,
 114         200,
 115         300,
 116         600,
 117         1200,
 118         1800,
 119         2400,
 120         4800,
 121         9600,
 122         19200,
 123         38400,
 124 };
 125
 126 static void
 127 stios2btios(st, bt)
 128         struct ibcs2_termios *st;
 129         struct termios *bt;
 130 {
 131         register u_long l, r;
 132
 133         l = st->c_iflag;        r = 0;
 134         if (l & IBCS2_IGNBRK)   r |= IGNBRK;
 135         if (l & IBCS2_BRKINT)   r |= BRKINT;
 136         if (l & IBCS2_IGNPAR)   r |= IGNPAR;
 137         if (l & IBCS2_PARMRK)   r |= PARMRK;
 138         if (l & IBCS2_INPCK)    r |= INPCK;
 139         if (l & IBCS2_ISTRIP)   r |= ISTRIP;
 140         if (l & IBCS2_INLCR)    r |= INLCR;
 141         if (l & IBCS2_IGNCR)    r |= IGNCR;
 142         if (l & IBCS2_ICRNL)    r |= ICRNL;
 143         if (l & IBCS2_IXON)     r |= IXON;
 144         if (l & IBCS2_IXANY)    r |= IXANY;
 145         if (l & IBCS2_IXOFF)    r |= IXOFF;
 146         if (l & IBCS2_IMAXBEL)  r |= IMAXBEL;
 147         bt->c_iflag = r;
 148
 149         l = st->c_oflag;        r = 0;
 150         if (l & IBCS2_OPOST)    r |= OPOST;
 151         if (l & IBCS2_ONLCR)    r |= ONLCR;
 152         if (l & IBCS2_TAB3)     r |= OXTABS;
 153         bt->c_oflag = r;
 154
 155         l = st->c_cflag;        r = 0;
 156         switch (l & IBCS2_CSIZE) {
 157         case IBCS2_CS5:         r |= CS5; break;
 158         case IBCS2_CS6:         r |= CS6; break;
 159         case IBCS2_CS7:         r |= CS7; break;
 160         case IBCS2_CS8:         r |= CS8; break;
 161         }
 162         if (l & IBCS2_CSTOPB)   r |= CSTOPB;
 163         if (l & IBCS2_CREAD)    r |= CREAD;
 164         if (l & IBCS2_PARENB)   r |= PARENB;
 165         if (l & IBCS2_PARODD)   r |= PARODD;
 166         if (l & IBCS2_HUPCL)    r |= HUPCL;
 167         if (l & IBCS2_CLOCAL)   r |= CLOCAL;
 168         bt->c_cflag = r;
 169
 170         bt->c_ispeed = bt->c_ospeed = s2btab[l & 0x0000000f];
 171
 172         l = st->c_lflag;        r = 0;
 173         if (l & IBCS2_ISIG)     r |= ISIG;
 174         if (l & IBCS2_ICANON)   r |= ICANON;
 175         if (l & IBCS2_ECHO)     r |= ECHO;
 176         if (l & IBCS2_ECHOE)    r |= ECHOE;
 177         if (l & IBCS2_ECHOK)    r |= ECHOK;
 178         if (l & IBCS2_ECHONL)   r |= ECHONL;
 179         if (l & IBCS2_NOFLSH)   r |= NOFLSH;
 180         if (l & IBCS2_TOSTOP)   r |= TOSTOP;
 181         bt->c_lflag = r;
 182
 183         bt->c_cc[VINTR] =
 184             st->c_cc[IBCS2_VINTR]  ? st->c_cc[IBCS2_VINTR]  : _POSIX_VDISABLE;
 185         bt->c_cc[VQUIT] =
 186             st->c_cc[IBCS2_VQUIT]  ? st->c_cc[IBCS2_VQUIT]  : _POSIX_VDISABLE;
 187         bt->c_cc[VERASE] =
 188             st->c_cc[IBCS2_VERASE] ? st->c_cc[IBCS2_VERASE] : _POSIX_VDISABLE;
 189         bt->c_cc[VKILL] =
 190             st->c_cc[IBCS2_VKILL]  ? st->c_cc[IBCS2_VKILL]  : _POSIX_VDISABLE;
 191         if (bt->c_lflag & ICANON) {
 192                 bt->c_cc[VEOF] =
 193                     st->c_cc[IBCS2_VEOF] ? st->c_cc[IBCS2_VEOF] : _POSIX_VDISABLE;
 194                 bt->c_cc[VEOL] =
 195                     st->c_cc[IBCS2_VEOL] ? st->c_cc[IBCS2_VEOL] : _POSIX_VDISABLE;
 196         } else {
 197                 bt->c_cc[VMIN]  = st->c_cc[IBCS2_VMIN];
 198                 bt->c_cc[VTIME] = st->c_cc[IBCS2_VTIME];
 199         }
 200         bt->c_cc[VEOL2] =
 201             st->c_cc[IBCS2_VEOL2]  ? st->c_cc[IBCS2_VEOL2]  : _POSIX_VDISABLE;
 202 #if 0
 203         bt->c_cc[VSWTCH] =
 204             st->c_cc[IBCS2_VSWTCH] ? st->c_cc[IBCS2_VSWTCH] : _POSIX_VDISABLE;
 205 #endif
 206         bt->c_cc[VSTART] =
 207             st->c_cc[IBCS2_VSTART] ? st->c_cc[IBCS2_VSTART] : _POSIX_VDISABLE;
 208         bt->c_cc[VSTOP] =
 209             st->c_cc[IBCS2_VSTOP]  ? st->c_cc[IBCS2_VSTOP]  : _POSIX_VDISABLE;
 210         bt->c_cc[VSUSP] =
 211             st->c_cc[IBCS2_VSUSP]  ? st->c_cc[IBCS2_VSUSP]  : _POSIX_VDISABLE;
 212         bt->c_cc[VDSUSP]   = _POSIX_VDISABLE;
 213         bt->c_cc[VREPRINT] = _POSIX_VDISABLE;
 214         bt->c_cc[VDISCARD] = _POSIX_VDISABLE;
 215         bt->c_cc[VWERASE]  = _POSIX_VDISABLE;
 216         bt->c_cc[VLNEXT]   = _POSIX_VDISABLE;
 217         bt->c_cc[VSTATUS]  = _POSIX_VDISABLE;
 218 }
 219
 220 static void
 221 btios2stios(bt, st)
 222         struct termios *bt;
 223         struct ibcs2_termios *st;
 224 {
 225         register u_long l, r;
 226
 227         l = bt->c_iflag;        r = 0;
 228         if (l & IGNBRK)         r |= IBCS2_IGNBRK;
 229         if (l & BRKINT)         r |= IBCS2_BRKINT;
 230         if (l & IGNPAR)         r |= IBCS2_IGNPAR;
 231         if (l & PARMRK)         r |= IBCS2_PARMRK;
 232         if (l & INPCK)          r |= IBCS2_INPCK;
 233         if (l & ISTRIP)         r |= IBCS2_ISTRIP;
 234         if (l & INLCR)          r |= IBCS2_INLCR;
 235         if (l & IGNCR)          r |= IBCS2_IGNCR;
 236         if (l & ICRNL)          r |= IBCS2_ICRNL;
 237         if (l & IXON)           r |= IBCS2_IXON;
 238         if (l & IXANY)          r |= IBCS2_IXANY;
 239         if (l & IXOFF)          r |= IBCS2_IXOFF;
 240         if (l & IMAXBEL)        r |= IBCS2_IMAXBEL;
 241         st->c_iflag = r;
 242
 243         l = bt->c_oflag;        r = 0;
 244         if (l & OPOST)          r |= IBCS2_OPOST;
 245         if (l & ONLCR)          r |= IBCS2_ONLCR;
 246         if (l & OXTABS)         r |= IBCS2_TAB3;
 247         st->c_oflag = r;
 248
 249         l = bt->c_cflag;        r = 0;
 250         switch (l & CSIZE) {
 251         case CS5:               r |= IBCS2_CS5; break;
 252         case CS6:               r |= IBCS2_CS6; break;
 253         case CS7:               r |= IBCS2_CS7; break;
 254         case CS8:               r |= IBCS2_CS8; break;
 255         }
 256         if (l & CSTOPB)         r |= IBCS2_CSTOPB;
 257         if (l & CREAD)          r |= IBCS2_CREAD;
 258         if (l & PARENB)         r |= IBCS2_PARENB;
 259         if (l & PARODD)         r |= IBCS2_PARODD;
 260         if (l & HUPCL)          r |= IBCS2_HUPCL;
 261         if (l & CLOCAL)         r |= IBCS2_CLOCAL;
 262         st->c_cflag = r;
 263
 264         l = bt->c_lflag;        r = 0;
 265         if (l & ISIG)           r |= IBCS2_ISIG;
 266         if (l & ICANON)         r |= IBCS2_ICANON;
 267         if (l & ECHO)           r |= IBCS2_ECHO;
 268         if (l & ECHOE)          r |= IBCS2_ECHOE;
 269         if (l & ECHOK)          r |= IBCS2_ECHOK;
 270         if (l & ECHONL)         r |= IBCS2_ECHONL;
 271         if (l & NOFLSH)         r |= IBCS2_NOFLSH;
 272         if (l & TOSTOP)         r |= IBCS2_TOSTOP;
 273         st->c_lflag = r;
 274
 275         l = ttspeedtab(bt->c_ospeed, sptab);
 276         if ((int)l >= 0)
 277                 st->c_cflag |= l;
 278
 279         st->c_cc[IBCS2_VINTR] =
 280             bt->c_cc[VINTR]  != _POSIX_VDISABLE ? bt->c_cc[VINTR]  : 0;
 281         st->c_cc[IBCS2_VQUIT] =
 282             bt->c_cc[VQUIT]  != _POSIX_VDISABLE ? bt->c_cc[VQUIT]  : 0;
 283         st->c_cc[IBCS2_VERASE] =
 284             bt->c_cc[VERASE] != _POSIX_VDISABLE ? bt->c_cc[VERASE] : 0;
 285         st->c_cc[IBCS2_VKILL] =
 286             bt->c_cc[VKILL]  != _POSIX_VDISABLE ? bt->c_cc[VKILL]  : 0;
 287         if (bt->c_lflag & ICANON) {
 288                 st->c_cc[IBCS2_VEOF] =
 289                     bt->c_cc[VEOF] != _POSIX_VDISABLE ? bt->c_cc[VEOF] : 0;
 290                 st->c_cc[IBCS2_VEOL] =
 291                     bt->c_cc[VEOL] != _POSIX_VDISABLE ? bt->c_cc[VEOL] : 0;
 292         } else {
 293                 st->c_cc[IBCS2_VMIN]  = bt->c_cc[VMIN];
 294                 st->c_cc[IBCS2_VTIME] = bt->c_cc[VTIME];
 295         }
 296         st->c_cc[IBCS2_VEOL2] =
 297             bt->c_cc[VEOL2]  != _POSIX_VDISABLE ? bt->c_cc[VEOL2]  : 0;
 298         st->c_cc[IBCS2_VSWTCH] =
 299             0;
 300         st->c_cc[IBCS2_VSUSP] =
 301             bt->c_cc[VSUSP]  != _POSIX_VDISABLE ? bt->c_cc[VSUSP]  : 0;
 302         st->c_cc[IBCS2_VSTART] =
 303             bt->c_cc[VSTART] != _POSIX_VDISABLE ? bt->c_cc[VSTART] : 0;
 304         st->c_cc[IBCS2_VSTOP] =
 305             bt->c_cc[VSTOP]  != _POSIX_VDISABLE ? bt->c_cc[VSTOP]  : 0;
 306
 307         st->c_line = 0;
 308 }
 309
 310 static void
 311 stios2stio(ts, t)
 312         struct ibcs2_termios *ts;
 313         struct ibcs2_termio *t;
 314 {
 315         t->c_iflag = ts->c_iflag;
 316         t->c_oflag = ts->c_oflag;
 317         t->c_cflag = ts->c_cflag;
 318         t->c_lflag = ts->c_lflag;
 319         t->c_line  = ts->c_line;
 320         bcopy(ts->c_cc, t->c_cc, IBCS2_NCC);
 321 }
 322
 323 static void
 324 stio2stios(t, ts)
 325         struct ibcs2_termio *t;
 326         struct ibcs2_termios *ts;
 327 {
 328         ts->c_iflag = t->c_iflag;
 329         ts->c_oflag = t->c_oflag;
 330         ts->c_cflag = t->c_cflag;
 331         ts->c_lflag = t->c_lflag;
 332         ts->c_line  = t->c_line;
 333         bcopy(t->c_cc, ts->c_cc, IBCS2_NCC);
 334 }
 335
 336 int
 337 ibcs2_ioctl(p, uap)
 338         struct proc *p;
 339         struct ibcs2_ioctl_args *uap;
 340 {
 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(p, (struct ioctl_args *)uap);
 495
 496         case IBCS2_TIOCSWINSZ:
 497                 SCARG(uap, cmd) = TIOCSWINSZ;
 498                 return ioctl(p, (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(p, &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(p, (struct ioctl_args *)uap);
 545
 546         case IBCS2_KDSKBMODE:        /* set keyboard translation mode */
 547                 SCARG(uap, cmd) = KDSKBMODE;
 548                 return ioctl(p, (struct ioctl_args *)uap);
 549
 550         case IBCS2_KDMKTONE:        /* sound tone */
 551                 SCARG(uap, cmd) = KDMKTONE;
 552                 return ioctl(p, (struct ioctl_args *)uap);
 553
 554         case IBCS2_KDGETMODE:        /* get text/graphics mode */
 555                 SCARG(uap, cmd) = KDGETMODE;
 556                 return ioctl(p, (struct ioctl_args *)uap);
 557
 558         case IBCS2_KDSETMODE:       /* set text/graphics mode */
 559                 SCARG(uap, cmd) = KDSETMODE;
 560                 return ioctl(p, (struct ioctl_args *)uap);
 561
 562         case IBCS2_KDSBORDER:       /* set ega color border */
 563                 SCARG(uap, cmd) = KDSBORDER;
 564                 return ioctl(p, (struct ioctl_args *)uap);
 565
 566         case IBCS2_KDGKBSTATE:
 567                 SCARG(uap, cmd) = KDGKBSTATE;
 568                 return ioctl(p, (struct ioctl_args *)uap);
 569
 570         case IBCS2_KDSETRAD:
 571                 SCARG(uap, cmd) = KDSETRAD;
 572                 return ioctl(p, (struct ioctl_args *)uap);
 573
 574         case IBCS2_KDENABIO:       /* enable direct I/O to ports */
 575                 SCARG(uap, cmd) = KDENABIO;
 576                 return ioctl(p, (struct ioctl_args *)uap);
 577
 578         case IBCS2_KDDISABIO:       /* disable direct I/O to ports */
 579                 SCARG(uap, cmd) = KDDISABIO;
 580                 return ioctl(p, (struct ioctl_args *)uap);
 581
 582         case IBCS2_KIOCSOUND:       /* start sound generation */
 583                 SCARG(uap, cmd) = KIOCSOUND;
 584                 return ioctl(p, (struct ioctl_args *)uap);
 585
 586         case IBCS2_KDGKBTYPE:       /* get keyboard type */
 587                 SCARG(uap, cmd) = KDGKBTYPE;
 588                 return ioctl(p, (struct ioctl_args *)uap);
 589
 590         case IBCS2_KDGETLED:       /* get keyboard LED status */
 591                 SCARG(uap, cmd) = KDGETLED;
 592                 return ioctl(p, (struct ioctl_args *)uap);
 593
 594         case IBCS2_KDSETLED:       /* set keyboard LED status */
 595                 SCARG(uap, cmd) = KDSETLED;
 596                 return ioctl(p, (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(p, (struct ioctl_args *)uap);
 602
 603         case IBCS2_SETFKEY:      /* Set function key */
 604                 SCARG(uap, cmd) = SETFKEY;
 605                 return ioctl(p, (struct ioctl_args *)uap);
 606
 607         case IBCS2_GIO_SCRNMAP:      /* Get screen output map table */
 608                 SCARG(uap, cmd) = GIO_SCRNMAP;
 609                 return ioctl(p, (struct ioctl_args *)uap);
 610
 611         case IBCS2_PIO_SCRNMAP:      /* Set screen output map table */
 612                 SCARG(uap, cmd) = PIO_SCRNMAP;
 613                 return ioctl(p, (struct ioctl_args *)uap);
 614
 615         case IBCS2_GIO_KEYMAP:      /* Get keyboard map table */
 616                 SCARG(uap, cmd) = GIO_KEYMAP;
 617                 return ioctl(p, (struct ioctl_args *)uap);
 618
 619         case IBCS2_PIO_KEYMAP:      /* Set keyboard map table */
 620                 SCARG(uap, cmd) = PIO_KEYMAP;
 621                 return ioctl(p, (struct ioctl_args *)uap);
 622
 623             /* socksys */
 624         case IBCS2_SIOCSOCKSYS:
 625                 return ibcs2_socksys(p, (struct ibcs2_socksys_args *)uap);
 626
 627         case IBCS2_I_NREAD:     /* STREAMS */
 628                 SCARG(uap, cmd) = FIONREAD;
 629                 return ioctl(p, (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 }