root/dev/wscons/wsdisplay_compat_usl.c

DEFINITIONS

1. usl_sync_init
2. usl_sync_done
3. usl_sync_check
4. usl_sync_get
5. usl_detachproc
6. usl_detachack
7. usl_detachtimeout
8. usl_attachproc
9. usl_attachack
10. usl_attachtimeout
11. wsdisplay_usl_ioctl1
12. wsdisplay_usl_ioctl2

    1 /* $OpenBSD: wsdisplay_compat_usl.c,v 1.19 2007/02/14 01:12:16 jsg Exp $ */
    2 /* $NetBSD: wsdisplay_compat_usl.c,v 1.12 2000/03/23 07:01:47 thorpej Exp $ */
    4 /*
    5  * Copyright (c) 1998
    6  *      Matthias Drochner.  All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   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  */
   30 #include <sys/param.h>
   31 #include <sys/systm.h>
   32 #include <sys/timeout.h>
   33 #include <sys/ioctl.h>
   34 #include <sys/kernel.h>
   35 #include <sys/proc.h>
   36 #include <sys/signalvar.h>
   37 #include <sys/malloc.h>
   38 #include <sys/errno.h>
   40 #include <dev/wscons/wsconsio.h>
   41 #include <dev/wscons/wsdisplayvar.h>
   42 #include <dev/wscons/wscons_callbacks.h>
   43 #include <dev/wscons/wsdisplay_usl_io.h>
   45 #ifdef WSDISPLAY_DEBUG
   46 #define DPRINTF(x)       if (wsdisplaydebug) printf x
   47 int     wsdisplaydebug = 0;
   48 #else
   49 #define DPRINTF(x)
   50 #endif
   52 struct usl_syncdata {
   53         struct wsscreen *s_scr;
   54         struct proc *s_proc;
pid_t s_pid;
   56         int s_flags;
   57 #define SF_DETACHPENDING 1
   58 #define SF_ATTACHPENDING 2
   59         int s_acqsig, s_relsig;
   60         int s_frsig; /* unused */
   61         void (*s_callback)(void *, int, int);
   62         void *s_cbarg;
   63         struct timeout s_attach_ch;
   64         struct timeout s_detach_ch;
   65 };
   67 int usl_sync_init(struct wsscreen *, struct usl_syncdata **,
   68                        struct proc *, int, int, int);
   69 void usl_sync_done(struct usl_syncdata *);
   70 int usl_sync_check(struct usl_syncdata *);
   71 struct usl_syncdata *usl_sync_get(struct wsscreen *);
   73 int usl_detachproc(void *, int, void (*)(void *, int, int), void *);
   74 int usl_detachack(struct usl_syncdata *, int);
   75 void usl_detachtimeout(void *);
   76 int usl_attachproc(void *, int, void (*)(void *, int, int), void *);
   77 int usl_attachack(struct usl_syncdata *, int);
   78 void usl_attachtimeout(void *);
   80 static const struct wscons_syncops usl_syncops = {
usl_detachproc,
usl_attachproc,
   83 #define _usl_sync_check ((int (*)(void *))usl_sync_check)
_usl_sync_check,
   85 #define _usl_sync_destroy ((void (*)(void *))usl_sync_done)
_usl_sync_destroy
   87 };
   89 #ifndef WSCOMPAT_USL_SYNCTIMEOUT
   90 #define WSCOMPAT_USL_SYNCTIMEOUT 5 /* seconds */
   91 #endif
   92 static int wscompat_usl_synctimeout = WSCOMPAT_USL_SYNCTIMEOUT;
   94 int
usl_sync_init(scr, sdp, p, acqsig, relsig, frsig)
   96         struct wsscreen *scr;
   97         struct usl_syncdata **sdp;
   98         struct proc *p;
   99         int acqsig, relsig, frsig;
  100 {
  101         struct usl_syncdata *sd;
  102         int res;
  104         if (acqsig <= 0 || acqsig >= NSIG || relsig <= 0 || relsig >= NSIG ||
frsig <= 0 || frsig >= NSIG)
  106                 return (EINVAL);
sd = malloc(sizeof(struct usl_syncdata), M_DEVBUF, M_NOWAIT);
  108         if (!sd)
  109                 return (ENOMEM);
sd->s_scr = scr;
sd->s_proc = p;
sd->s_pid = p->p_pid;
sd->s_flags = 0;
sd->s_acqsig = acqsig;
sd->s_relsig = relsig;
sd->s_frsig = frsig;
timeout_set(&sd->s_attach_ch, usl_attachtimeout, sd);
timeout_set(&sd->s_detach_ch, usl_detachtimeout, sd);
res = wsscreen_attach_sync(scr, &usl_syncops, sd);
  120         if (res) {
free(sd, M_DEVBUF);
  122                 return (res);
  123         }
  124         *sdp = sd;
  125         return (0);
  126 }
  128 void
usl_sync_done(sd)
  130         struct usl_syncdata *sd;
  131 {
  132         if (sd->s_flags & SF_DETACHPENDING) {
timeout_del(&sd->s_detach_ch);
  134                 (*sd->s_callback)(sd->s_cbarg, 0, 0);
  135         }
  136         if (sd->s_flags & SF_ATTACHPENDING) {
timeout_del(&sd->s_attach_ch);
  138                 (*sd->s_callback)(sd->s_cbarg, ENXIO, 0);
  139         }
wsscreen_detach_sync(sd->s_scr);
free(sd, M_DEVBUF);
  142 }
  144 int
usl_sync_check(sd)
  146         struct usl_syncdata *sd;
  147 {
  148         if (sd->s_proc == pfind(sd->s_pid))
  149                 return (1);
DPRINTF(("usl_sync_check: process %d died\n", sd->s_pid));
usl_sync_done(sd);
  152         return (0);
  153 }
  155 struct usl_syncdata *
usl_sync_get(scr)
  157         struct wsscreen *scr;
  158 {
  159         struct usl_syncdata *sd;
  161         if (wsscreen_lookup_sync(scr, &usl_syncops, (void **)&sd))
  162                 return (0);
  163         return (sd);
  164 }
  166 int
usl_detachproc(cookie, waitok, callback, cbarg)
  168         void *cookie;
  169         int waitok;
  170         void (*callback)(void *, int, int);
  171         void *cbarg;
  172 {
  173         struct usl_syncdata *sd = cookie;
  175         if (!usl_sync_check(sd))
  176                 return (0);
  178         /* we really need a callback */
  179         if (!callback)
  180                 return (EINVAL);
  182         /*
  183          * Normally, this is called from the controlling process.
  184          * It is supposed to reply with a VT_RELDISP ioctl(), so
  185          * it is not useful to tsleep() here.
  186          */
sd->s_callback = callback;
sd->s_cbarg = cbarg;
sd->s_flags |= SF_DETACHPENDING;
psignal(sd->s_proc, sd->s_relsig);
timeout_add(&sd->s_detach_ch, wscompat_usl_synctimeout * hz);
  193         return (EAGAIN);
  194 }
  196 int
usl_detachack(sd, ack)
  198         struct usl_syncdata *sd;
  199         int ack;
  200 {
  201         if (!(sd->s_flags & SF_DETACHPENDING)) {
DPRINTF(("usl_detachack: not detaching\n"));
  203                 return (EINVAL);
  204         }
timeout_del(&sd->s_detach_ch);
sd->s_flags &= ~SF_DETACHPENDING;
  209         if (sd->s_callback)
  210                 (*sd->s_callback)(sd->s_cbarg, (ack ? 0 : EIO), 1);
  212         return (0);
  213 }
  215 void
usl_detachtimeout(arg)
  217         void *arg;
  218 {
  219         struct usl_syncdata *sd = arg;
DPRINTF(("usl_detachtimeout\n"));
  223         if (!(sd->s_flags & SF_DETACHPENDING)) {
DPRINTF(("usl_detachtimeout: not detaching\n"));
  225                 return;
  226         }
sd->s_flags &= ~SF_DETACHPENDING;
  230         if (sd->s_callback)
  231                 (*sd->s_callback)(sd->s_cbarg, EIO, 0);
  233         (void) usl_sync_check(sd);
  234 }
  236 int
usl_attachproc(cookie, waitok, callback, cbarg)
  238         void *cookie;
  239         int waitok;
  240         void (*callback)(void *, int, int);
  241         void *cbarg;
  242 {
  243         struct usl_syncdata *sd = cookie;
  245         if (!usl_sync_check(sd))
  246                 return (0);
  248         /* we really need a callback */
  249         if (!callback)
  250                 return (EINVAL);
sd->s_callback = callback;
sd->s_cbarg = cbarg;
sd->s_flags |= SF_ATTACHPENDING;
psignal(sd->s_proc, sd->s_acqsig);
timeout_add(&sd->s_attach_ch, wscompat_usl_synctimeout * hz);
  258         return (EAGAIN);
  259 }
  261 int
usl_attachack(sd, ack)
  263         struct usl_syncdata *sd;
  264         int ack;
  265 {
  266         if (!(sd->s_flags & SF_ATTACHPENDING)) {
DPRINTF(("usl_attachack: not attaching\n"));
  268                 return (EINVAL);
  269         }
timeout_del(&sd->s_attach_ch);
sd->s_flags &= ~SF_ATTACHPENDING;
  274         if (sd->s_callback)
  275                 (*sd->s_callback)(sd->s_cbarg, (ack ? 0 : EIO), 1);
  277         return (0);
  278 }
  280 void
usl_attachtimeout(arg)
  282         void *arg;
  283 {
  284         struct usl_syncdata *sd = arg;
DPRINTF(("usl_attachtimeout\n"));
  288         if (!(sd->s_flags & SF_ATTACHPENDING)) {
DPRINTF(("usl_attachtimeout: not attaching\n"));
  290                 return;
  291         }
sd->s_flags &= ~SF_ATTACHPENDING;
  295         if (sd->s_callback)
  296                 (*sd->s_callback)(sd->s_cbarg, EIO, 0);
  298         (void) usl_sync_check(sd);
  299 }
  301 int
wsdisplay_usl_ioctl1(sc, cmd, data, flag, p)
  303         struct wsdisplay_softc *sc;
u_long cmd;
caddr_t data;
  306         int flag;
  307         struct proc *p;
  308 {
  309         int idx, maxidx;
  311         switch (cmd) {
  312             case VT_OPENQRY:
maxidx = wsdisplay_maxscreenidx(sc);
  314                 for (idx = 0; idx <= maxidx; idx++) {
  315                         if (wsdisplay_screenstate(sc, idx) == 0) {
  316                                 *(int *)data = idx + 1;
  317                                 return (0);
  318                         }
  319                 }
  320                 return (ENXIO);
  321             case VT_GETACTIVE:
idx = wsdisplay_getactivescreen(sc);
  323                 *(int *)data = idx + 1;
  324                 return (0);
  325             case VT_ACTIVATE:
idx = *(int *)data - 1;
  327                 if (idx < 0)
  328                         return (EINVAL);
  329                 return (wsdisplay_switch((struct device *)sc, idx, 1));
  330             case VT_WAITACTIVE:
idx = *(int *)data - 1;
  332                 if (idx < 0)
  333                         return (EINVAL);
  334                 return (wsscreen_switchwait(sc, idx));
  335             case VT_GETSTATE:
  336 #define ss ((struct vt_stat *)data)
idx = wsdisplay_getactivescreen(sc);
ss->v_active = idx + 1;
ss->v_state = 0;
maxidx = wsdisplay_maxscreenidx(sc);
  341                 for (idx = 0; idx <= maxidx; idx++)
  342                         if (wsdisplay_screenstate(sc, idx) == EBUSY)
ss->v_state |= (1 << (idx + 1));
  344 #undef ss
  345                 return (0);
  347 #ifdef WSDISPLAY_COMPAT_PCVT
  348             case VGAPCVTID:
  349 #define id ((struct pcvtid *)data)
strlcpy(id->name, "pcvt", sizeof id->name);
id->rmajor = 3;
id->rminor = 32;
  353 #undef id
  354                 return (0);
  355 #endif
  356 #ifdef WSDISPLAY_COMPAT_SYSCONS
  357             case CONS_GETVERS:
  358                 *(int *)data = 0x200;    /* version 2.0 */
  359                 return (0);
  360 #endif
  362             default:
  363                 return (-1);
  364         }
  366         return (0);
  367 }
  369 int
wsdisplay_usl_ioctl2(sc, scr, cmd, data, flag, p)
  371         struct wsdisplay_softc *sc;
  372         struct wsscreen *scr;
u_long cmd;
caddr_t data;
  375         int flag;
  376         struct proc *p;
  377 {
  378         int intarg, res;
u_long req;
  380         void *arg;
  381         struct usl_syncdata *sd;
  382         struct wskbd_bell_data bd;
  384         switch (cmd) {
  385             case VT_SETMODE:
  386 #define newmode ((struct vt_mode *)data)
  387                 if (newmode->mode == VT_PROCESS) {
res = usl_sync_init(scr, &sd, p, newmode->acqsig,
newmode->relsig, newmode->frsig);
  390                         if (res)
  391                                 return (res);
  392                 } else {
sd = usl_sync_get(scr);
  394                         if (sd)
usl_sync_done(sd);
  396                 }
  397 #undef newmode
  398                 return (0);
  399             case VT_GETMODE:
  400 #define cmode ((struct vt_mode *)data)
sd = usl_sync_get(scr);
  402                 if (sd) {
cmode->mode = VT_PROCESS;
cmode->relsig = sd->s_relsig;
cmode->acqsig = sd->s_acqsig;
cmode->frsig = sd->s_frsig;
  407                 } else
cmode->mode = VT_AUTO;
  409 #undef cmode
  410                 return (0);
  411             case VT_RELDISP:
  412 #define d (*(int *)data)
sd = usl_sync_get(scr);
  414                 if (!sd)
  415                         return (EINVAL);
  416                 switch (d) {
  417                     case VT_FALSE:
  418                     case VT_TRUE:
  419                         return (usl_detachack(sd, (d == VT_TRUE)));
  420                     case VT_ACKACQ:
  421                         return (usl_attachack(sd, 1));
  422                     default:
  423                         return (EINVAL);
  424                 }
  425 #undef d
  426                 return (0);
  428 #if defined(__i386__)
  429             case KDENABIO:
  430                 if (suser(p, 0) || securelevel > 0)
  431                         return (EPERM);
  432                 /* FALLTHROUGH */
  433             case KDDISABIO:
  434 #if defined(COMPAT_FREEBSD)
  435                 {
  436                 struct trapframe *fp = (struct trapframe *)p->p_md.md_regs;
  437                 extern struct emul emul_freebsd_aout;
  438                 extern struct emul emul_freebsd_elf;
  440                 if (p->p_emul == &emul_freebsd_aout ||
p->p_emul == &emul_freebsd_elf) {
  442                         if (cmd == KDENABIO)
fp->tf_eflags |= PSL_IOPL;
  444                         else
fp->tf_eflags &= ~PSL_IOPL;
  446                         }
  447                 }
  448 #endif
  449                 return (0);
  450 #else
  451             case KDENABIO:
  452             case KDDISABIO:
  453                 /*
  454                  * This is a lie, but non-x86 platforms are not supposed to
  455                  * issue these ioctls anyway.
  456                  */
  457                 return (0);
  458 #endif
  459             case KDSETRAD:
  460                 /* XXX ignore for now */
  461                 return (0);
  463             default:
  464                 return (-1);
  466             /*
  467              * the following are converted to wsdisplay ioctls
  468              */
  469             case KDSETMODE:
req = WSDISPLAYIO_SMODE;
  471 #define d (*(int *)data)
  472                 switch (d) {
  473                     case KD_GRAPHICS:
intarg = WSDISPLAYIO_MODE_MAPPED;
  475                         break;
  476                     case KD_TEXT:
intarg = WSDISPLAYIO_MODE_EMUL;
  478                         break;
  479                     default:
  480                         return (EINVAL);
  481                 }
  482 #undef d
arg = &intarg;
  484                 break;
  485             case KDMKTONE:
req = WSKBDIO_COMPLEXBELL;
  487 #define d (*(int *)data)
  488                 if (d) {
  489 #define PCVT_SYSBEEPF   1193182
  490                         if (d >> 16) {
bd.which = WSKBD_BELL_DOPERIOD;
bd.period = d >> 16; /* ms */
  493                         }
  494                         else
bd.which = 0;
  496                         if (d & 0xffff) {
bd.which |= WSKBD_BELL_DOPITCH;
bd.pitch = PCVT_SYSBEEPF/(d & 0xffff); /* Hz */
  499                         }
  500                 } else
bd.which = 0; /* default */
  502 #undef d
arg = &bd;
  504                 break;
  505             case KDSETLED:
req = WSKBDIO_SETLEDS;
intarg = 0;
  508 #define d (*(int *)data)
  509                 if (d & LED_CAP)
intarg |= WSKBD_LED_CAPS;
  511                 if (d & LED_NUM)
intarg |= WSKBD_LED_NUM;
  513                 if (d & LED_SCR)
intarg |= WSKBD_LED_SCROLL;
  515 #undef d
arg = &intarg;
  517                 break;
  518             case KDGETLED:
req = WSKBDIO_GETLEDS;
arg = &intarg;
  521                 break;
  522 #ifdef WSDISPLAY_COMPAT_RAWKBD
  523             case KDSKBMODE:
req = WSKBDIO_SETMODE;
  525                 switch (*(int *)data) {
  526                     case K_RAW:
intarg = WSKBD_RAW;
  528                         break;
  529                     case K_XLATE:
intarg = WSKBD_TRANSLATED;
  531                         break;
  532                     default:
  533                         return (EINVAL);
  534                 }
arg = &intarg;
  536                 break;
  537             case KDGKBMODE:
req = WSKBDIO_GETMODE;
arg = &intarg;
  540                 break;
  541 #endif
  542         }
res = wsdisplay_internal_ioctl(sc, scr, req, arg, flag, p);
  545         if (res)
  546                 return (res);
  548         switch (cmd) {
  549             case KDGETLED:
  550 #define d (*(int *)data)
d = 0;
  552                 if (intarg & WSKBD_LED_CAPS)
d |= LED_CAP;
  554                 if (intarg & WSKBD_LED_NUM)
d |= LED_NUM;
  556                 if (intarg & WSKBD_LED_SCROLL)
d |= LED_SCR;
  558 #undef d
  559                 break;
  560 #ifdef WSDISPLAY_COMPAT_RAWKBD
  561             case KDGKBMODE:
  562                 *(int *)data = (intarg == WSKBD_RAW ? K_RAW : K_XLATE);
  563                 break;
  564 #endif
  565         }
  567         return (0);
  568 }