![[BACK]](/icons/back.gif){kind=icon}
Return to wsdisplay_compat_usl.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / wscons|
Return to wsdisplay_compat_usl.c CVS log | Up to [local] / sys / dev / wscons |
1.1 nbrk 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 $ */
3:
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: */
29:
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>
39:
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>
44:
45: #ifdef WSDISPLAY_DEBUG
46: #define DPRINTF(x) if (wsdisplaydebug) printf x
47: int wsdisplaydebug = 0;
48: #else
49: #define DPRINTF(x)
50: #endif
51:
52: struct usl_syncdata {
53: struct wsscreen *s_scr;
54: struct proc *s_proc;
55: 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: };
66:
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 *);
72:
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 *);
79:
80: static const struct wscons_syncops usl_syncops = {
81: usl_detachproc,
82: usl_attachproc,
83: #define _usl_sync_check ((int (*)(void *))usl_sync_check)
84: _usl_sync_check,
85: #define _usl_sync_destroy ((void (*)(void *))usl_sync_done)
86: _usl_sync_destroy
87: };
88:
89: #ifndef WSCOMPAT_USL_SYNCTIMEOUT
90: #define WSCOMPAT_USL_SYNCTIMEOUT 5 /* seconds */
91: #endif
92: static int wscompat_usl_synctimeout = WSCOMPAT_USL_SYNCTIMEOUT;
93:
94: int
95: 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;
103:
104: if (acqsig <= 0 || acqsig >= NSIG || relsig <= 0 || relsig >= NSIG ||
105: frsig <= 0 || frsig >= NSIG)
106: return (EINVAL);
107: sd = malloc(sizeof(struct usl_syncdata), M_DEVBUF, M_NOWAIT);
108: if (!sd)
109: return (ENOMEM);
110: sd->s_scr = scr;
111: sd->s_proc = p;
112: sd->s_pid = p->p_pid;
113: sd->s_flags = 0;
114: sd->s_acqsig = acqsig;
115: sd->s_relsig = relsig;
116: sd->s_frsig = frsig;
117: timeout_set(&sd->s_attach_ch, usl_attachtimeout, sd);
118: timeout_set(&sd->s_detach_ch, usl_detachtimeout, sd);
119: res = wsscreen_attach_sync(scr, &usl_syncops, sd);
120: if (res) {
121: free(sd, M_DEVBUF);
122: return (res);
123: }
124: *sdp = sd;
125: return (0);
126: }
127:
128: void
129: usl_sync_done(sd)
130: struct usl_syncdata *sd;
131: {
132: if (sd->s_flags & SF_DETACHPENDING) {
133: timeout_del(&sd->s_detach_ch);
134: (*sd->s_callback)(sd->s_cbarg, 0, 0);
135: }
136: if (sd->s_flags & SF_ATTACHPENDING) {
137: timeout_del(&sd->s_attach_ch);
138: (*sd->s_callback)(sd->s_cbarg, ENXIO, 0);
139: }
140: wsscreen_detach_sync(sd->s_scr);
141: free(sd, M_DEVBUF);
142: }
143:
144: int
145: usl_sync_check(sd)
146: struct usl_syncdata *sd;
147: {
148: if (sd->s_proc == pfind(sd->s_pid))
149: return (1);
150: DPRINTF(("usl_sync_check: process %d died\n", sd->s_pid));
151: usl_sync_done(sd);
152: return (0);
153: }
154:
155: struct usl_syncdata *
156: usl_sync_get(scr)
157: struct wsscreen *scr;
158: {
159: struct usl_syncdata *sd;
160:
161: if (wsscreen_lookup_sync(scr, &usl_syncops, (void **)&sd))
162: return (0);
163: return (sd);
164: }
165:
166: int
167: 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;
174:
175: if (!usl_sync_check(sd))
176: return (0);
177:
178: /* we really need a callback */
179: if (!callback)
180: return (EINVAL);
181:
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: */
187: sd->s_callback = callback;
188: sd->s_cbarg = cbarg;
189: sd->s_flags |= SF_DETACHPENDING;
190: psignal(sd->s_proc, sd->s_relsig);
191: timeout_add(&sd->s_detach_ch, wscompat_usl_synctimeout * hz);
192:
193: return (EAGAIN);
194: }
195:
196: int
197: usl_detachack(sd, ack)
198: struct usl_syncdata *sd;
199: int ack;
200: {
201: if (!(sd->s_flags & SF_DETACHPENDING)) {
202: DPRINTF(("usl_detachack: not detaching\n"));
203: return (EINVAL);
204: }
205:
206: timeout_del(&sd->s_detach_ch);
207: sd->s_flags &= ~SF_DETACHPENDING;
208:
209: if (sd->s_callback)
210: (*sd->s_callback)(sd->s_cbarg, (ack ? 0 : EIO), 1);
211:
212: return (0);
213: }
214:
215: void
216: usl_detachtimeout(arg)
217: void *arg;
218: {
219: struct usl_syncdata *sd = arg;
220:
221: DPRINTF(("usl_detachtimeout\n"));
222:
223: if (!(sd->s_flags & SF_DETACHPENDING)) {
224: DPRINTF(("usl_detachtimeout: not detaching\n"));
225: return;
226: }
227:
228: sd->s_flags &= ~SF_DETACHPENDING;
229:
230: if (sd->s_callback)
231: (*sd->s_callback)(sd->s_cbarg, EIO, 0);
232:
233: (void) usl_sync_check(sd);
234: }
235:
236: int
237: 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;
244:
245: if (!usl_sync_check(sd))
246: return (0);
247:
248: /* we really need a callback */
249: if (!callback)
250: return (EINVAL);
251:
252: sd->s_callback = callback;
253: sd->s_cbarg = cbarg;
254: sd->s_flags |= SF_ATTACHPENDING;
255: psignal(sd->s_proc, sd->s_acqsig);
256: timeout_add(&sd->s_attach_ch, wscompat_usl_synctimeout * hz);
257:
258: return (EAGAIN);
259: }
260:
261: int
262: usl_attachack(sd, ack)
263: struct usl_syncdata *sd;
264: int ack;
265: {
266: if (!(sd->s_flags & SF_ATTACHPENDING)) {
267: DPRINTF(("usl_attachack: not attaching\n"));
268: return (EINVAL);
269: }
270:
271: timeout_del(&sd->s_attach_ch);
272: sd->s_flags &= ~SF_ATTACHPENDING;
273:
274: if (sd->s_callback)
275: (*sd->s_callback)(sd->s_cbarg, (ack ? 0 : EIO), 1);
276:
277: return (0);
278: }
279:
280: void
281: usl_attachtimeout(arg)
282: void *arg;
283: {
284: struct usl_syncdata *sd = arg;
285:
286: DPRINTF(("usl_attachtimeout\n"));
287:
288: if (!(sd->s_flags & SF_ATTACHPENDING)) {
289: DPRINTF(("usl_attachtimeout: not attaching\n"));
290: return;
291: }
292:
293: sd->s_flags &= ~SF_ATTACHPENDING;
294:
295: if (sd->s_callback)
296: (*sd->s_callback)(sd->s_cbarg, EIO, 0);
297:
298: (void) usl_sync_check(sd);
299: }
300:
301: int
302: wsdisplay_usl_ioctl1(sc, cmd, data, flag, p)
303: struct wsdisplay_softc *sc;
304: u_long cmd;
305: caddr_t data;
306: int flag;
307: struct proc *p;
308: {
309: int idx, maxidx;
310:
311: switch (cmd) {
312: case VT_OPENQRY:
313: 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:
322: idx = wsdisplay_getactivescreen(sc);
323: *(int *)data = idx + 1;
324: return (0);
325: case VT_ACTIVATE:
326: idx = *(int *)data - 1;
327: if (idx < 0)
328: return (EINVAL);
329: return (wsdisplay_switch((struct device *)sc, idx, 1));
330: case VT_WAITACTIVE:
331: 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)
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 ss
345: return (0);
346:
347: #ifdef WSDISPLAY_COMPAT_PCVT
348: case VGAPCVTID:
349: #define id ((struct pcvtid *)data)
350: strlcpy(id->name, "pcvt", sizeof id->name);
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 intarg, res;
379: u_long req;
380: void *arg;
381: struct usl_syncdata *sd;
382: struct wskbd_bell_data bd;
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: #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;
439:
440: if (p->p_emul == &emul_freebsd_aout ||
441: p->p_emul == &emul_freebsd_elf) {
442: if (cmd == KDENABIO)
443: fp->tf_eflags |= PSL_IOPL;
444: else
445: 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);
462:
463: default:
464: return (-1);
465:
466: /*
467: * the following are converted to wsdisplay ioctls
468: */
469: case KDSETMODE:
470: req = WSDISPLAYIO_SMODE;
471: #define d (*(int *)data)
472: switch (d) {
473: case KD_GRAPHICS:
474: intarg = WSDISPLAYIO_MODE_MAPPED;
475: break;
476: case KD_TEXT:
477: intarg = WSDISPLAYIO_MODE_EMUL;
478: break;
479: default:
480: return (EINVAL);
481: }
482: #undef d
483: arg = &intarg;
484: break;
485: case KDMKTONE:
486: req = WSKBDIO_COMPLEXBELL;
487: #define d (*(int *)data)
488: if (d) {
489: #define PCVT_SYSBEEPF 1193182
490: if (d >> 16) {
491: bd.which = WSKBD_BELL_DOPERIOD;
492: bd.period = d >> 16; /* ms */
493: }
494: else
495: bd.which = 0;
496: if (d & 0xffff) {
497: bd.which |= WSKBD_BELL_DOPITCH;
498: bd.pitch = PCVT_SYSBEEPF/(d & 0xffff); /* Hz */
499: }
500: } else
501: bd.which = 0; /* default */
502: #undef d
503: arg = &bd;
504: break;
505: case KDSETLED:
506: req = WSKBDIO_SETLEDS;
507: intarg = 0;
508: #define d (*(int *)data)
509: if (d & LED_CAP)
510: intarg |= WSKBD_LED_CAPS;
511: if (d & LED_NUM)
512: intarg |= WSKBD_LED_NUM;
513: if (d & LED_SCR)
514: intarg |= WSKBD_LED_SCROLL;
515: #undef d
516: arg = &intarg;
517: break;
518: case KDGETLED:
519: req = WSKBDIO_GETLEDS;
520: arg = &intarg;
521: break;
522: #ifdef WSDISPLAY_COMPAT_RAWKBD
523: case KDSKBMODE:
524: req = WSKBDIO_SETMODE;
525: switch (*(int *)data) {
526: case K_RAW:
527: intarg = WSKBD_RAW;
528: break;
529: case K_XLATE:
530: intarg = WSKBD_TRANSLATED;
531: break;
532: default:
533: return (EINVAL);
534: }
535: arg = &intarg;
536: break;
537: case KDGKBMODE:
538: req = WSKBDIO_GETMODE;
539: arg = &intarg;
540: break;
541: #endif
542: }
543:
544: res = wsdisplay_internal_ioctl(sc, scr, req, arg, flag, p);
545: if (res)
546: return (res);
547:
548: switch (cmd) {
549: case KDGETLED:
550: #define d (*(int *)data)
551: d = 0;
552: if (intarg & WSKBD_LED_CAPS)
553: d |= LED_CAP;
554: if (intarg & WSKBD_LED_NUM)
555: d |= LED_NUM;
556: if (intarg & WSKBD_LED_SCROLL)
557: 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: }
566:
567: return (0);
568: }