wsdisplay_compat_usl.c revision 1.14
1 /* $NetBSD: wsdisplay_compat_usl.c,v 1.14 2000/09/10 09:39:57 takemura 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 if (idx < 0) 332 return (EINVAL); 333 return (wsdisplay_switch((struct device *)sc, idx, 1)); 334 case VT_WAITACTIVE: 335 idx = *(int *)data - 1; 336 if (idx < 0) 337 return (EINVAL); 338 return (wsscreen_switchwait(sc, idx)); 339 case VT_GETSTATE: 340 #define ss ((struct vt_stat *)data) 341 idx = wsdisplay_getactivescreen(sc); 342 ss->v_active = idx + 1; 343 ss->v_state = 0; 344 maxidx = wsdisplay_maxscreenidx(sc); 345 for (idx = 0; idx <= maxidx; idx++) 346 if (wsdisplay_screenstate(sc, idx) == EBUSY) 347 ss->v_state |= (1 << (idx + 1)); 348 #undef s 349 return (0); 350 351 #ifdef WSDISPLAY_COMPAT_PCVT 352 case VGAPCVTID: 353 #define id ((struct pcvtid *)data) 354 strcpy(id->name, "pcvt"); 355 id->rmajor = 3; 356 id->rminor = 32; 357 #undef id 358 return (0); 359 #endif 360 #ifdef WSDISPLAY_COMPAT_SYSCONS 361 case CONS_GETVERS: 362 *(int *)data = 0x200; /* version 2.0 */ 363 return (0); 364 #endif 365 366 default: 367 return (-1); 368 } 369 370 return (0); 371 } 372 373 int 374 wsdisplay_usl_ioctl2(sc, scr, cmd, data, flag, p) 375 struct wsdisplay_softc *sc; 376 struct wsscreen *scr; 377 u_long cmd; 378 caddr_t data; 379 int flag; 380 struct proc *p; 381 { 382 int res, intarg; 383 u_long req; 384 struct usl_syncdata *sd; 385 struct wskbd_bell_data bd; 386 void *arg; 387 388 switch (cmd) { 389 case VT_SETMODE: 390 #define newmode ((struct vt_mode *)data) 391 if (newmode->mode == VT_PROCESS) { 392 res = usl_sync_init(scr, &sd, p, newmode->acqsig, 393 newmode->relsig, newmode->frsig); 394 if (res) 395 return (res); 396 } else { 397 sd = usl_sync_get(scr); 398 if (sd) 399 usl_sync_done(sd); 400 } 401 #undef newmode 402 return (0); 403 case VT_GETMODE: 404 #define cmode ((struct vt_mode *)data) 405 sd = usl_sync_get(scr); 406 if (sd) { 407 cmode->mode = VT_PROCESS; 408 cmode->relsig = sd->s_relsig; 409 cmode->acqsig = sd->s_acqsig; 410 cmode->frsig = sd->s_frsig; 411 } else 412 cmode->mode = VT_AUTO; 413 #undef cmode 414 return (0); 415 case VT_RELDISP: 416 #define d (*(int *)data) 417 sd = usl_sync_get(scr); 418 if (!sd) 419 return (EINVAL); 420 switch (d) { 421 case VT_FALSE: 422 case VT_TRUE: 423 return (usl_detachack(sd, (d == VT_TRUE))); 424 case VT_ACKACQ: 425 return (usl_attachack(sd, 1)); 426 default: 427 return (EINVAL); 428 } 429 #undef d 430 return (0); 431 432 case KDENABIO: 433 if (suser(p->p_ucred, &p->p_acflag) || securelevel > 1) 434 return (EPERM); 435 /* FALLTHRU */ 436 case KDDISABIO: 437 #if defined(__i386__) 438 #if defined(COMPAT_10) || defined(COMPAT_11) || defined(COMPAT_FREEBSD) 439 { 440 struct trapframe *fp = (struct trapframe *)p->p_md.md_regs; 441 if (cmd == KDENABIO) 442 fp->tf_eflags |= PSL_IOPL; 443 else 444 fp->tf_eflags &= ~PSL_IOPL; 445 } 446 #endif 447 #endif 448 return (0); 449 case KDSETRAD: 450 /* XXX ignore for now */ 451 return (0); 452 453 default: 454 return (-1); 455 456 /* 457 * the following are converted to wsdisplay ioctls 458 */ 459 case KDSETMODE: 460 req = WSDISPLAYIO_SMODE; 461 #define d (*(int *)data) 462 switch (d) { 463 case KD_GRAPHICS: 464 intarg = WSDISPLAYIO_MODE_MAPPED; 465 break; 466 case KD_TEXT: 467 intarg = WSDISPLAYIO_MODE_EMUL; 468 break; 469 default: 470 return (EINVAL); 471 } 472 #undef d 473 arg = &intarg; 474 break; 475 case KDMKTONE: 476 req = WSKBDIO_COMPLEXBELL; 477 #define d (*(int *)data) 478 if (d) { 479 #define PCVT_SYSBEEPF 1193182 480 if (d >> 16) { 481 bd.which = WSKBD_BELL_DOPERIOD; 482 bd.period = d >> 16; /* ms */ 483 } 484 else 485 bd.which = 0; 486 if (d & 0xffff) { 487 bd.which |= WSKBD_BELL_DOPITCH; 488 bd.pitch = PCVT_SYSBEEPF/(d & 0xffff); /* Hz */ 489 } 490 } else 491 bd.which = 0; /* default */ 492 #undef d 493 arg = &bd; 494 break; 495 case KDSETLED: 496 req = WSKBDIO_SETLEDS; 497 intarg = 0; 498 #define d (*(int *)data) 499 if (d & LED_CAP) 500 intarg |= WSKBD_LED_CAPS; 501 if (d & LED_NUM) 502 intarg |= WSKBD_LED_NUM; 503 if (d & LED_SCR) 504 intarg |= WSKBD_LED_SCROLL; 505 #undef d 506 arg = &intarg; 507 break; 508 case KDGETLED: 509 req = WSKBDIO_GETLEDS; 510 arg = &intarg; 511 break; 512 #ifdef WSDISPLAY_COMPAT_RAWKBD 513 case KDSKBMODE: 514 req = WSKBDIO_SETMODE; 515 switch (*(int *)data) { 516 case K_RAW: 517 intarg = WSKBD_RAW; 518 break; 519 case K_XLATE: 520 intarg = WSKBD_TRANSLATED; 521 break; 522 default: 523 return (EINVAL); 524 } 525 arg = &intarg; 526 break; 527 case KDGKBMODE: 528 req = WSKBDIO_GETMODE; 529 arg = &intarg; 530 break; 531 #endif 532 } 533 534 res = wsdisplay_internal_ioctl(sc, scr, req, arg, flag, p); 535 if (res) 536 return (res); 537 538 switch (cmd) { 539 case KDGETLED: 540 #define d (*(int *)data) 541 d = 0; 542 if (intarg & WSKBD_LED_CAPS) 543 d |= LED_CAP; 544 if (intarg & WSKBD_LED_NUM) 545 d |= LED_NUM; 546 if (intarg & WSKBD_LED_SCROLL) 547 d |= LED_SCR; 548 #undef d 549 break; 550 #ifdef WSDISPLAY_COMPAT_RAWKBD 551 case KDGKBMODE: 552 *(int *)data = (intarg == WSKBD_RAW ? K_RAW : K_XLATE); 553 break; 554 #endif 555 } 556 557 return (0); 558 } 559
Indexes created Fri Sep 26 20:09:58 GMT 2025