wsdisplay_compat_usl.c revision 1.13
1 /* $NetBSD: wsdisplay_compat_usl.c,v 1.13 2000/09/08 15:32:57 simonb Exp $ */ 2 3 /* 4 * Copyright (c) 1998 5 * Matthias Drochner. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed for the NetBSD Project 18 * by Matthias Drochner. 19 * 4. The name of the author may not be used to endorse or promote products 20 * derived from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 * 33 */ 34 35 #include "opt_compat_freebsd.h" 36 #include "opt_compat_netbsd.h" 37 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/callout.h> 41 #include <sys/ioctl.h> 42 #include <sys/kernel.h> 43 #include <sys/proc.h> 44 #include <sys/signalvar.h> 45 #include <sys/malloc.h> 46 #include <sys/errno.h> 47 48 #include <dev/wscons/wsconsio.h> 49 #include <dev/wscons/wsdisplayvar.h> 50 #include <dev/wscons/wscons_callbacks.h> 51 #include <dev/wscons/wsdisplay_usl_io.h> 52 53 #include "opt_wsdisplay_compat.h" 54 55 struct usl_syncdata { 56 struct wsscreen *s_scr; 57 struct proc *s_proc; 58 pid_t s_pid; 59 int s_flags; 60 #define SF_DETACHPENDING 1 61 #define SF_ATTACHPENDING 2 62 int s_acqsig, s_relsig; 63 int s_frsig; /* unused */ 64 void (*s_callback) __P((void *, int, int)); 65 void *s_cbarg; 66 struct callout s_attach_ch; 67 struct callout s_detach_ch; 68 }; 69 70 static int usl_sync_init __P((struct wsscreen *, struct usl_syncdata **, 71 struct proc *, int, int, int)); 72 static void usl_sync_done __P((struct usl_syncdata *)); 73 static int usl_sync_check __P((struct usl_syncdata *)); 74 static struct usl_syncdata *usl_sync_get __P((struct wsscreen *)); 75 76 static int usl_detachproc __P((void *, int, 77 void (*)(void *, int, int), void *)); 78 static int usl_detachack __P((struct usl_syncdata *, int)); 79 static void usl_detachtimeout __P((void *)); 80 static int usl_attachproc __P((void *, int, 81 void (*)(void *, int, int), void *)); 82 static int usl_attachack __P((struct usl_syncdata *, int)); 83 static void usl_attachtimeout __P((void *)); 84 85 static const struct wscons_syncops usl_syncops = { 86 usl_detachproc, 87 usl_attachproc, 88 #define _usl_sync_check ((int (*) __P((void *)))usl_sync_check) 89 _usl_sync_check, 90 #define _usl_sync_destroy ((void (*) __P((void *)))usl_sync_done) 91 _usl_sync_destroy 92 }; 93 94 #ifndef WSCOMPAT_USL_SYNCTIMEOUT 95 #define WSCOMPAT_USL_SYNCTIMEOUT 5 /* seconds */ 96 #endif 97 static int wscompat_usl_synctimeout = WSCOMPAT_USL_SYNCTIMEOUT; 98 99 static int 100 usl_sync_init(scr, sdp, p, acqsig, relsig, frsig) 101 struct wsscreen *scr; 102 struct usl_syncdata **sdp; 103 struct proc *p; 104 int acqsig, relsig, frsig; 105 { 106 struct usl_syncdata *sd; 107 int res; 108 109 sd = malloc(sizeof(struct usl_syncdata), M_DEVBUF, M_WAITOK); 110 if (!sd) 111 return (ENOMEM); 112 sd->s_scr = scr; 113 sd->s_proc = p; 114 sd->s_pid = p->p_pid; 115 sd->s_flags = 0; 116 sd->s_acqsig = acqsig; 117 sd->s_relsig = relsig; 118 sd->s_frsig = frsig; 119 callout_init(&sd->s_attach_ch); 120 callout_init(&sd->s_detach_ch); 121 res = wsscreen_attach_sync(scr, &usl_syncops, sd); 122 if (res) { 123 free(sd, M_DEVBUF); 124 return (res); 125 } 126 *sdp = sd; 127 return (0); 128 } 129 130 static void 131 usl_sync_done(sd) 132 struct usl_syncdata *sd; 133 { 134 if (sd->s_flags & SF_DETACHPENDING) { 135 callout_stop(&sd->s_detach_ch); 136 (*sd->s_callback)(sd->s_cbarg, 0, 0); 137 } 138 if (sd->s_flags & SF_ATTACHPENDING) { 139 callout_stop(&sd->s_attach_ch); 140 (*sd->s_callback)(sd->s_cbarg, ENXIO, 0); 141 } 142 wsscreen_detach_sync(sd->s_scr); 143 free(sd, M_DEVBUF); 144 } 145 146 static int 147 usl_sync_check(sd) 148 struct usl_syncdata *sd; 149 { 150 if (sd->s_proc == pfind(sd->s_pid)) 151 return (1); 152 printf("usl_sync_check: process %d died\n", sd->s_pid); 153 usl_sync_done(sd); 154 return (0); 155 } 156 157 static struct usl_syncdata * 158 usl_sync_get(scr) 159 struct wsscreen *scr; 160 { 161 struct usl_syncdata *sd; 162 163 if (wsscreen_lookup_sync(scr, &usl_syncops, (void **)&sd)) 164 return (0); 165 return (sd); 166 } 167 168 static int 169 usl_detachproc(cookie, waitok, callback, cbarg) 170 void *cookie; 171 int waitok; 172 void (*callback) __P((void *, int, int)); 173 void *cbarg; 174 { 175 struct usl_syncdata *sd = cookie; 176 177 if (!usl_sync_check(sd)) 178 return (0); 179 180 /* we really need a callback */ 181 if (!callback) 182 return (EINVAL); 183 184 /* 185 * Normally, this is called from the controlling process. 186 * Is is supposed to reply with a VT_RELDISP ioctl(), so 187 * it is not useful to tsleep() here. 188 */ 189 sd->s_callback = callback; 190 sd->s_cbarg = cbarg; 191 sd->s_flags |= SF_DETACHPENDING; 192 psignal(sd->s_proc, sd->s_relsig); 193 callout_reset(&sd->s_detach_ch, wscompat_usl_synctimeout * hz, 194 usl_detachtimeout, sd); 195 196 return (EAGAIN); 197 } 198 199 static int 200 usl_detachack(sd, ack) 201 struct usl_syncdata *sd; 202 int ack; 203 { 204 if (!(sd->s_flags & SF_DETACHPENDING)) { 205 printf("usl_detachack: not detaching\n"); 206 return (EINVAL); 207 } 208 209 callout_stop(&sd->s_detach_ch); 210 sd->s_flags &= ~SF_DETACHPENDING; 211 212 if (sd->s_callback) 213 (*sd->s_callback)(sd->s_cbarg, (ack ? 0 : EIO), 1); 214 215 return (0); 216 } 217 218 static void 219 usl_detachtimeout(arg) 220 void *arg; 221 { 222 struct usl_syncdata *sd = arg; 223 224 printf("usl_detachtimeout\n"); 225 226 if (!(sd->s_flags & SF_DETACHPENDING)) { 227 printf("usl_detachtimeout: not detaching\n"); 228 return; 229 } 230 231 sd->s_flags &= ~SF_DETACHPENDING; 232 233 if (sd->s_callback) 234 (*sd->s_callback)(sd->s_cbarg, EIO, 0); 235 236 (void) usl_sync_check(sd); 237 } 238 239 static int 240 usl_attachproc(cookie, waitok, callback, cbarg) 241 void *cookie; 242 int waitok; 243 void (*callback) __P((void *, int, int)); 244 void *cbarg; 245 { 246 struct usl_syncdata *sd = cookie; 247 248 if (!usl_sync_check(sd)) 249 return (0); 250 251 /* we really need a callback */ 252 if (!callback) 253 return (EINVAL); 254 255 sd->s_callback = callback; 256 sd->s_cbarg = cbarg; 257 sd->s_flags |= SF_ATTACHPENDING; 258 psignal(sd->s_proc, sd->s_acqsig); 259 callout_reset(&sd->s_attach_ch, wscompat_usl_synctimeout * hz, 260 usl_attachtimeout, sd); 261 262 return (EAGAIN); 263 } 264 265 static int 266 usl_attachack(sd, ack) 267 struct usl_syncdata *sd; 268 int ack; 269 { 270 if (!(sd->s_flags & SF_ATTACHPENDING)) { 271 printf("usl_attachack: not attaching\n"); 272 return (EINVAL); 273 } 274 275 callout_stop(&sd->s_attach_ch); 276 sd->s_flags &= ~SF_ATTACHPENDING; 277 278 if (sd->s_callback) 279 (*sd->s_callback)(sd->s_cbarg, (ack ? 0 : EIO), 1); 280 281 return (0); 282 } 283 284 static void 285 usl_attachtimeout(arg) 286 void *arg; 287 { 288 struct usl_syncdata *sd = arg; 289 290 printf("usl_attachtimeout\n"); 291 292 if (!(sd->s_flags & SF_ATTACHPENDING)) { 293 printf("usl_attachtimeout: not attaching\n"); 294 return; 295 } 296 297 sd->s_flags &= ~SF_ATTACHPENDING; 298 299 if (sd->s_callback) 300 (*sd->s_callback)(sd->s_cbarg, EIO, 0); 301 302 (void) usl_sync_check(sd); 303 } 304 305 int 306 wsdisplay_usl_ioctl1(sc, cmd, data, flag, p) 307 struct wsdisplay_softc *sc; 308 u_long cmd; 309 caddr_t data; 310 int flag; 311 struct proc *p; 312 { 313 int idx, maxidx; 314 315 switch (cmd) { 316 case VT_OPENQRY: 317 maxidx = wsdisplay_maxscreenidx(sc); 318 for (idx = 0; idx <= maxidx; idx++) { 319 if (wsdisplay_screenstate(sc, idx) == 0) { 320 *(int *)data = idx + 1; 321 return (0); 322 } 323 } 324 return (ENXIO); 325 case VT_GETACTIVE: 326 idx = wsdisplay_getactivescreen(sc); 327 *(int *)data = idx + 1; 328 return (0); 329 case VT_ACTIVATE: 330 idx = *(int *)data - 1; 331 return (wsdisplay_switch((struct device *)sc, idx, 1)); 332 case VT_WAITACTIVE: 333 idx = *(int *)data - 1; 334 return (wsscreen_switchwait(sc, idx)); 335 case VT_GETSTATE: 336 #define ss ((struct vt_stat *)data) 337 idx = wsdisplay_getactivescreen(sc); 338 ss->v_active = idx + 1; 339 ss->v_state = 0; 340 maxidx = wsdisplay_maxscreenidx(sc); 341 for (idx = 0; idx <= maxidx; idx++) 342 if (wsdisplay_screenstate(sc, idx) == EBUSY) 343 ss->v_state |= (1 << (idx + 1)); 344 #undef s 345 return (0); 346 347 #ifdef WSDISPLAY_COMPAT_PCVT 348 case VGAPCVTID: 349 #define id ((struct pcvtid *)data) 350 strcpy(id->name, "pcvt"); 351 id->rmajor = 3; 352 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 361 362 default: 363 return (-1); 364 } 365 366 return (0); 367 } 368 369 int 370 wsdisplay_usl_ioctl2(sc, scr, cmd, data, flag, p) 371 struct wsdisplay_softc *sc; 372 struct wsscreen *scr; 373 u_long cmd; 374 caddr_t data; 375 int flag; 376 struct proc *p; 377 { 378 int res, intarg; 379 u_long req; 380 struct usl_syncdata *sd; 381 struct wskbd_bell_data bd; 382 void *arg; 383 384 switch (cmd) { 385 case VT_SETMODE: 386 #define newmode ((struct vt_mode *)data) 387 if (newmode->mode == VT_PROCESS) { 388 res = usl_sync_init(scr, &sd, p, newmode->acqsig, 389 newmode->relsig, newmode->frsig); 390 if (res) 391 return (res); 392 } else { 393 sd = usl_sync_get(scr); 394 if (sd) 395 usl_sync_done(sd); 396 } 397 #undef newmode 398 return (0); 399 case VT_GETMODE: 400 #define cmode ((struct vt_mode *)data) 401 sd = usl_sync_get(scr); 402 if (sd) { 403 cmode->mode = VT_PROCESS; 404 cmode->relsig = sd->s_relsig; 405 cmode->acqsig = sd->s_acqsig; 406 cmode->frsig = sd->s_frsig; 407 } else 408 cmode->mode = VT_AUTO; 409 #undef cmode 410 return (0); 411 case VT_RELDISP: 412 #define d (*(int *)data) 413 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); 427 428 case KDENABIO: 429 if (suser(p->p_ucred, &p->p_acflag) || securelevel > 1) 430 return (EPERM); 431 /* FALLTHRU */ 432 case KDDISABIO: 433 #if defined(__i386__) 434 #if defined(COMPAT_10) || defined(COMPAT_11) || defined(COMPAT_FREEBSD) 435 { 436 struct trapframe *fp = (struct trapframe *)p->p_md.md_regs; 437 if (cmd == KDENABIO) 438 fp->tf_eflags |= PSL_IOPL; 439 else 440 fp->tf_eflags &= ~PSL_IOPL; 441 } 442 #endif 443 #endif 444 return (0); 445 case KDSETRAD: 446 /* XXX ignore for now */ 447 return (0); 448 449 default: 450 return (-1); 451 452 /* 453 * the following are converted to wsdisplay ioctls 454 */ 455 case KDSETMODE: 456 req = WSDISPLAYIO_SMODE; 457 #define d (*(int *)data) 458 switch (d) { 459 case KD_GRAPHICS: 460 intarg = WSDISPLAYIO_MODE_MAPPED; 461 break; 462 case KD_TEXT: 463 intarg = WSDISPLAYIO_MODE_EMUL; 464 break; 465 default: 466 return (EINVAL); 467 } 468 #undef d 469 arg = &intarg; 470 break; 471 case KDMKTONE: 472 req = WSKBDIO_COMPLEXBELL; 473 #define d (*(int *)data) 474 if (d) { 475 #define PCVT_SYSBEEPF 1193182 476 if (d >> 16) { 477 bd.which = WSKBD_BELL_DOPERIOD; 478 bd.period = d >> 16; /* ms */ 479 } 480 else 481 bd.which = 0; 482 if (d & 0xffff) { 483 bd.which |= WSKBD_BELL_DOPITCH; 484 bd.pitch = PCVT_SYSBEEPF/(d & 0xffff); /* Hz */ 485 } 486 } else 487 bd.which = 0; /* default */ 488 #undef d 489 arg = &bd; 490 break; 491 case KDSETLED: 492 req = WSKBDIO_SETLEDS; 493 intarg = 0; 494 #define d (*(int *)data) 495 if (d & LED_CAP) 496 intarg |= WSKBD_LED_CAPS; 497 if (d & LED_NUM) 498 intarg |= WSKBD_LED_NUM; 499 if (d & LED_SCR) 500 intarg |= WSKBD_LED_SCROLL; 501 #undef d 502 arg = &intarg; 503 break; 504 case KDGETLED: 505 req = WSKBDIO_GETLEDS; 506 arg = &intarg; 507 break; 508 #ifdef WSDISPLAY_COMPAT_RAWKBD 509 case KDSKBMODE: 510 req = WSKBDIO_SETMODE; 511 switch (*(int *)data) { 512 case K_RAW: 513 intarg = WSKBD_RAW; 514 break; 515 case K_XLATE: 516 intarg = WSKBD_TRANSLATED; 517 break; 518 default: 519 return (EINVAL); 520 } 521 arg = &intarg; 522 break; 523 case KDGKBMODE: 524 req = WSKBDIO_GETMODE; 525 arg = &intarg; 526 break; 527 #endif 528 } 529 530 res = wsdisplay_internal_ioctl(sc, scr, req, arg, flag, p); 531 if (res) 532 return (res); 533 534 switch (cmd) { 535 case KDGETLED: 536 #define d (*(int *)data) 537 d = 0; 538 if (intarg & WSKBD_LED_CAPS) 539 d |= LED_CAP; 540 if (intarg & WSKBD_LED_NUM) 541 d |= LED_NUM; 542 if (intarg & WSKBD_LED_SCROLL) 543 d |= LED_SCR; 544 #undef d 545 break; 546 #ifdef WSDISPLAY_COMPAT_RAWKBD 547 case KDGKBMODE: 548 *(int *)data = (intarg == WSKBD_RAW ? K_RAW : K_XLATE); 549 break; 550 #endif 551 } 552 553 return (0); 554 } 555
Indexes created Thu Sep 25 16:09:42 GMT 2025