1 /* $MirOS: src/sys/dev/wscons/wsdisplay_compat_usl.c,v 1.3 2007/02/06 20:54:51 tg Exp $ */
2 /* $OpenBSD: wsdisplay_compat_usl.c,v 1.18 2006/10/16 15:51:26 tom Exp $ */
3 /* $NetBSD: wsdisplay_compat_usl.c,v 1.12 2000/03/23 07:01:47 thorpej Exp $ */
4
5 /*
6 * Copyright (c) 1998
7 * Matthias Drochner. All rights reserved.
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. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 *
29 */
30
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/timeout.h>
34 #include <sys/ioctl.h>
35 #include <sys/kernel.h>
36 #include <sys/proc.h>
37 #include <sys/signalvar.h>
38 #include <sys/malloc.h>
39 #include <sys/errno.h>
40
41 #include <dev/wscons/wsconsio.h>
42 #include <dev/wscons/wsdisplayvar.h>
43 #include <dev/wscons/wscons_callbacks.h>
44 #include <dev/wscons/wsdisplay_usl_io.h>
45
46 #ifdef WSDISPLAY_DEBUG
47 #define DPRINTF(x) if (wsdisplaydebug) printf x
48 int wsdisplaydebug = 0;
49 #else
50 #define DPRINTF(x)
51 #endif
52
53 struct usl_syncdata {
54 struct wsscreen *s_scr;
55 struct proc *s_proc;
56 pid_t s_pid;
57 int s_flags;
58 #define SF_DETACHPENDING 1
59 #define SF_ATTACHPENDING 2
60 int s_acqsig, s_relsig;
61 int s_frsig; /* unused */
62 void (*s_callback)(void *, int, int);
63 void *s_cbarg;
64 struct timeout s_attach_ch;
65 struct timeout s_detach_ch;
66 };
67
68 int usl_sync_init(struct wsscreen *, struct usl_syncdata **,
69 struct proc *, int, int, int);
70 void usl_sync_done(struct usl_syncdata *);
71 int usl_sync_check(struct usl_syncdata *);
72 struct usl_syncdata *usl_sync_get(struct wsscreen *);
73
74 int usl_detachproc(void *, int, void (*)(void *, int, int), void *);
75 int usl_detachack(struct usl_syncdata *, int);
76 void usl_detachtimeout(void *);
77 int usl_attachproc(void *, int, void (*)(void *, int, int), void *);
78 int usl_attachack(struct usl_syncdata *, int);
79 void usl_attachtimeout(void *);
80
81 static const struct wscons_syncops usl_syncops = {
82 usl_detachproc,
83 usl_attachproc,
84 #define _usl_sync_check ((int (*)(void *))usl_sync_check)
85 _usl_sync_check,
86 #define _usl_sync_destroy ((void (*)(void *))usl_sync_done)
87 _usl_sync_destroy
88 };
89
90 #ifndef WSCOMPAT_USL_SYNCTIMEOUT
91 #define WSCOMPAT_USL_SYNCTIMEOUT 5 /* seconds */
92 #endif
93 static int wscompat_usl_synctimeout = WSCOMPAT_USL_SYNCTIMEOUT;
94
95 int
usl_sync_init(scr,sdp,p,acqsig,relsig,frsig)96 usl_sync_init(scr, sdp, p, acqsig, relsig, frsig)
97 struct wsscreen *scr;
98 struct usl_syncdata **sdp;
99 struct proc *p;
100 int acqsig, relsig, frsig;
101 {
102 struct usl_syncdata *sd;
103 int res;
104
105 if (acqsig <= 0 || acqsig >= NSIG || relsig <= 0 || relsig >= NSIG ||
106 frsig <= 0 || frsig >= NSIG)
107 return (EINVAL);
108 sd = malloc(sizeof(struct usl_syncdata), M_DEVBUF, M_NOWAIT);
109 if (!sd)
110 return (ENOMEM);
111 sd->s_scr = scr;
112 sd->s_proc = p;
113 sd->s_pid = p->p_pid;
114 sd->s_flags = 0;
115 sd->s_acqsig = acqsig;
116 sd->s_relsig = relsig;
117 sd->s_frsig = frsig;
118 timeout_set(&sd->s_attach_ch, usl_attachtimeout, sd);
119 timeout_set(&sd->s_detach_ch, usl_detachtimeout, sd);
120 res = wsscreen_attach_sync(scr, &usl_syncops, sd);
121 if (res) {
122 free(sd, M_DEVBUF);
123 return (res);
124 }
125 *sdp = sd;
126 return (0);
127 }
128
129 void
usl_sync_done(sd)130 usl_sync_done(sd)
131 struct usl_syncdata *sd;
132 {
133 if (sd->s_flags & SF_DETACHPENDING) {
134 timeout_del(&sd->s_detach_ch);
135 (*sd->s_callback)(sd->s_cbarg, 0, 0);
136 }
137 if (sd->s_flags & SF_ATTACHPENDING) {
138 timeout_del(&sd->s_attach_ch);
139 (*sd->s_callback)(sd->s_cbarg, ENXIO, 0);
140 }
141 wsscreen_detach_sync(sd->s_scr);
142 free(sd, M_DEVBUF);
143 }
144
145 int
usl_sync_check(sd)146 usl_sync_check(sd)
147 struct usl_syncdata *sd;
148 {
149 if (sd->s_proc == pfind(sd->s_pid))
150 return (1);
151 DPRINTF(("usl_sync_check: process %d died\n", sd->s_pid));
152 usl_sync_done(sd);
153 return (0);
154 }
155
156 struct usl_syncdata *
usl_sync_get(scr)157 usl_sync_get(scr)
158 struct wsscreen *scr;
159 {
160 struct usl_syncdata *sd;
161
162 if (wsscreen_lookup_sync(scr, &usl_syncops, (void **)&sd))
163 return (0);
164 return (sd);
165 }
166
167 int
usl_detachproc(cookie,waitok,callback,cbarg)168 usl_detachproc(cookie, waitok, callback, cbarg)
169 void *cookie;
170 int waitok;
171 void (*callback)(void *, int, int);
172 void *cbarg;
173 {
174 struct usl_syncdata *sd = cookie;
175
176 if (!usl_sync_check(sd))
177 return (0);
178
179 /* we really need a callback */
180 if (!callback)
181 return (EINVAL);
182
183 /*
184 * Normally, this is called from the controlling process.
185 * It is supposed to reply with a VT_RELDISP ioctl(), so
186 * it is not useful to tsleep() here.
187 */
188 sd->s_callback = callback;
189 sd->s_cbarg = cbarg;
190 sd->s_flags |= SF_DETACHPENDING;
191 psignal(sd->s_proc, sd->s_relsig);
192 timeout_add(&sd->s_detach_ch, wscompat_usl_synctimeout * hz);
193
194 return (EAGAIN);
195 }
196
197 int
usl_detachack(sd,ack)198 usl_detachack(sd, ack)
199 struct usl_syncdata *sd;
200 int ack;
201 {
202 if (!(sd->s_flags & SF_DETACHPENDING)) {
203 DPRINTF(("usl_detachack: not detaching\n"));
204 return (EINVAL);
205 }
206
207 timeout_del(&sd->s_detach_ch);
208 sd->s_flags &= ~SF_DETACHPENDING;
209
210 if (sd->s_callback)
211 (*sd->s_callback)(sd->s_cbarg, (ack ? 0 : EIO), 1);
212
213 return (0);
214 }
215
216 void
usl_detachtimeout(arg)217 usl_detachtimeout(arg)
218 void *arg;
219 {
220 struct usl_syncdata *sd = arg;
221
222 DPRINTF(("usl_detachtimeout\n"));
223
224 if (!(sd->s_flags & SF_DETACHPENDING)) {
225 DPRINTF(("usl_detachtimeout: not detaching\n"));
226 return;
227 }
228
229 sd->s_flags &= ~SF_DETACHPENDING;
230
231 if (sd->s_callback)
232 (*sd->s_callback)(sd->s_cbarg, EIO, 0);
233
234 (void) usl_sync_check(sd);
235 }
236
237 int
usl_attachproc(cookie,waitok,callback,cbarg)238 usl_attachproc(cookie, waitok, callback, cbarg)
239 void *cookie;
240 int waitok;
241 void (*callback)(void *, int, int);
242 void *cbarg;
243 {
244 struct usl_syncdata *sd = cookie;
245
246 if (!usl_sync_check(sd))
247 return (0);
248
249 /* we really need a callback */
250 if (!callback)
251 return (EINVAL);
252
253 sd->s_callback = callback;
254 sd->s_cbarg = cbarg;
255 sd->s_flags |= SF_ATTACHPENDING;
256 psignal(sd->s_proc, sd->s_acqsig);
257 timeout_add(&sd->s_attach_ch, wscompat_usl_synctimeout * hz);
258
259 return (EAGAIN);
260 }
261
262 int
usl_attachack(sd,ack)263 usl_attachack(sd, ack)
264 struct usl_syncdata *sd;
265 int ack;
266 {
267 if (!(sd->s_flags & SF_ATTACHPENDING)) {
268 DPRINTF(("usl_attachack: not attaching\n"));
269 return (EINVAL);
270 }
271
272 timeout_del(&sd->s_attach_ch);
273 sd->s_flags &= ~SF_ATTACHPENDING;
274
275 if (sd->s_callback)
276 (*sd->s_callback)(sd->s_cbarg, (ack ? 0 : EIO), 1);
277
278 return (0);
279 }
280
281 void
usl_attachtimeout(arg)282 usl_attachtimeout(arg)
283 void *arg;
284 {
285 struct usl_syncdata *sd = arg;
286
287 DPRINTF(("usl_attachtimeout\n"));
288
289 if (!(sd->s_flags & SF_ATTACHPENDING)) {
290 DPRINTF(("usl_attachtimeout: not attaching\n"));
291 return;
292 }
293
294 sd->s_flags &= ~SF_ATTACHPENDING;
295
296 if (sd->s_callback)
297 (*sd->s_callback)(sd->s_cbarg, EIO, 0);
298
299 (void) usl_sync_check(sd);
300 }
301
302 int
wsdisplay_usl_ioctl1(sc,cmd,data,flag,p)303 wsdisplay_usl_ioctl1(sc, cmd, data, flag, p)
304 struct wsdisplay_softc *sc;
305 u_long cmd;
306 caddr_t data;
307 int flag;
308 struct proc *p;
309 {
310 int idx, maxidx;
311
312 switch (cmd) {
313 case VT_OPENQRY:
314 maxidx = wsdisplay_maxscreenidx(sc);
315 for (idx = 0; idx <= maxidx; idx++) {
316 if (wsdisplay_screenstate(sc, idx) == 0) {
317 *(int *)data = idx + 1;
318 return (0);
319 }
320 }
321 return (ENXIO);
322 case VT_GETACTIVE:
323 idx = wsdisplay_getactivescreen(sc);
324 *(int *)data = idx + 1;
325 return (0);
326 case VT_ACTIVATE:
327 idx = *(int *)data - 1;
328 if (idx < 0)
329 return (EINVAL);
330 return (wsdisplay_switch((struct device *)sc, idx, 1));
331 case VT_WAITACTIVE:
332 idx = *(int *)data - 1;
333 if (idx < 0)
334 return (EINVAL);
335 return (wsscreen_switchwait(sc, idx));
336 case VT_GETSTATE:
337 #define ss ((struct vt_stat *)data)
338 idx = wsdisplay_getactivescreen(sc);
339 ss->v_active = idx + 1;
340 ss->v_state = 0;
341 maxidx = wsdisplay_maxscreenidx(sc);
342 for (idx = 0; idx <= maxidx; idx++)
343 if (wsdisplay_screenstate(sc, idx) == EBUSY)
344 ss->v_state |= (1 << (idx + 1));
345 #undef ss
346 return (0);
347
348 #ifdef WSDISPLAY_COMPAT_PCVT
349 case VGAPCVTID:
350 #define id ((struct pcvtid *)data)
351 strlcpy(id->name, "pcvt", sizeof id->name);
352 id->rmajor = 3;
353 id->rminor = 32;
354 #undef id
355 return (0);
356 #endif
357 #ifdef WSDISPLAY_COMPAT_SYSCONS
358 case CONS_GETVERS:
359 *(int *)data = 0x200; /* version 2.0 */
360 return (0);
361 #endif
362
363 default:
364 return (-1);
365 }
366
367 return (0);
368 }
369
370 int
wsdisplay_usl_ioctl2(sc,scr,cmd,data,flag,p)371 wsdisplay_usl_ioctl2(sc, scr, cmd, data, flag, p)
372 struct wsdisplay_softc *sc;
373 struct wsscreen *scr;
374 u_long cmd;
375 caddr_t data;
376 int flag;
377 struct proc *p;
378 {
379 int intarg, res;
380 u_long req;
381 void *arg;
382 struct usl_syncdata *sd;
383 struct wskbd_bell_data bd;
384
385 switch (cmd) {
386 case VT_SETMODE:
387 #define newmode ((struct vt_mode *)data)
388 if (newmode->mode == VT_PROCESS) {
389 res = usl_sync_init(scr, &sd, p, newmode->acqsig,
390 newmode->relsig, newmode->frsig);
391 if (res)
392 return (res);
393 } else {
394 sd = usl_sync_get(scr);
395 if (sd)
396 usl_sync_done(sd);
397 }
398 #undef newmode
399 return (0);
400 case VT_GETMODE:
401 #define cmode ((struct vt_mode *)data)
402 sd = usl_sync_get(scr);
403 if (sd) {
404 cmode->mode = VT_PROCESS;
405 cmode->relsig = sd->s_relsig;
406 cmode->acqsig = sd->s_acqsig;
407 cmode->frsig = sd->s_frsig;
408 } else
409 cmode->mode = VT_AUTO;
410 #undef cmode
411 return (0);
412 case VT_RELDISP:
413 #define d (*(int *)data)
414 sd = usl_sync_get(scr);
415 if (!sd)
416 return (EINVAL);
417 switch (d) {
418 case VT_FALSE:
419 case VT_TRUE:
420 return (usl_detachack(sd, (d == VT_TRUE)));
421 case VT_ACKACQ:
422 return (usl_attachack(sd, 1));
423 default:
424 return (EINVAL);
425 }
426 #undef d
427 return (0);
428
429 #if defined(__i386__)
430 case KDENABIO:
431 if (suser(p, 0) || securelevel > 0)
432 return (EPERM);
433 /* FALLTHRU */
434 case KDDISABIO:
435 return (0);
436 #else
437 case KDENABIO:
438 case KDDISABIO:
439 /*
440 * This is a lie, but non-x86 platforms are not supposed to
441 * issue these ioctls anyway.
442 */
443 return (0);
444 #endif
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