wsdisplay.c revision 1.122.4.1 1 /* $NetBSD: wsdisplay.c,v 1.122.4.1 2009/01/19 13:19:18 skrll Exp $ */
2
3 /*
4 * Copyright (c) 1996, 1997 Christopher G. Demetriou. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. All advertising materials mentioning features or use of this software
15 * must display the following acknowledgement:
16 * This product includes software developed by Christopher G. Demetriou
17 * for the NetBSD Project.
18 * 4. The name of the author may not be used to endorse or promote products
19 * derived from this software without specific prior written permission
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #include <sys/cdefs.h>
34 __KERNEL_RCSID(0, "$NetBSD: wsdisplay.c,v 1.122.4.1 2009/01/19 13:19:18 skrll Exp $");
35
36 #include "opt_wsdisplay_compat.h"
37 #include "opt_wsmsgattrs.h"
38 #include "wskbd.h"
39 #include "wsmux.h"
40 #include "wsdisplay.h"
41
42 #include <sys/param.h>
43 #include <sys/conf.h>
44 #include <sys/device.h>
45 #include <sys/ioctl.h>
46 #include <sys/poll.h>
47 #include <sys/kernel.h>
48 #include <sys/proc.h>
49 #include <sys/malloc.h>
50 #include <sys/syslog.h>
51 #include <sys/systm.h>
52 #include <sys/tty.h>
53 #include <sys/signalvar.h>
54 #include <sys/errno.h>
55 #include <sys/fcntl.h>
56 #include <sys/vnode.h>
57 #include <sys/kauth.h>
58
59 #include <dev/wscons/wsconsio.h>
60 #include <dev/wscons/wseventvar.h>
61 #include <dev/wscons/wsmuxvar.h>
62 #include <dev/wscons/wsdisplayvar.h>
63 #include <dev/wscons/wsksymvar.h>
64 #include <dev/wscons/wsksymdef.h>
65 #include <dev/wscons/wsemulvar.h>
66 #include <dev/wscons/wscons_callbacks.h>
67 #include <dev/cons.h>
68
69 struct wsscreen_internal {
70 const struct wsdisplay_emulops *emulops;
71 void *emulcookie;
72
73 const struct wsscreen_descr *scrdata;
74
75 const struct wsemul_ops *wsemul;
76 void *wsemulcookie;
77 };
78
79 struct wsscreen {
80 struct wsscreen_internal *scr_dconf;
81
82 struct tty *scr_tty;
83 int scr_hold_screen; /* hold tty output */
84
85 int scr_flags;
86 #define SCR_OPEN 1 /* is it open? */
87 #define SCR_WAITACTIVE 2 /* someone waiting on activation */
88 #define SCR_GRAPHICS 4 /* graphics mode, no text (emulation) output */
89 #define SCR_DUMBFB 8 /* in use as a dumb fb (iff SCR_GRAPHICS) */
90 const struct wscons_syncops *scr_syncops;
91 void *scr_synccookie;
92
93 #ifdef WSDISPLAY_COMPAT_RAWKBD
94 int scr_rawkbd;
95 #endif
96
97 struct wsdisplay_softc *sc;
98 };
99
100 struct wsscreen *wsscreen_attach(struct wsdisplay_softc *, int,
101 const char *,
102 const struct wsscreen_descr *, void *,
103 int, int, long);
104 void wsscreen_detach(struct wsscreen *);
105 int wsdisplay_addscreen(struct wsdisplay_softc *, int, const char *, const char *);
106 static void wsdisplay_addscreen_print(struct wsdisplay_softc *, int, int);
107 static void wsdisplay_closescreen(struct wsdisplay_softc *, struct wsscreen *);
108 int wsdisplay_delscreen(struct wsdisplay_softc *, int, int);
109
110 #define WSDISPLAY_MAXSCREEN 8
111
112 struct wsdisplay_softc {
113 device_t sc_dev;
114
115 const struct wsdisplay_accessops *sc_accessops;
116 void *sc_accesscookie;
117
118 const struct wsscreen_list *sc_scrdata;
119 #ifdef WSDISPLAY_SCROLLSUPPORT
120 struct wsdisplay_scroll_data sc_scroll_values;
121 #endif
122
123 struct wsscreen *sc_scr[WSDISPLAY_MAXSCREEN];
124 int sc_focusidx; /* available only if sc_focus isn't null */
125 struct wsscreen *sc_focus;
126
127 struct wseventvar evar;
128
129 int sc_isconsole;
130
131 int sc_flags;
132 #define SC_SWITCHPENDING 1
133 #define SC_SWITCHERROR 2
134 #define SC_XATTACHED 4 /* X server active */
135 kmutex_t sc_flagsmtx; /* for flags, might also be used for focus */
136 kcondvar_t sc_flagscv;
137
138 int sc_screenwanted, sc_oldscreen; /* valid with SC_SWITCHPENDING */
139
140 #if NWSKBD > 0
141 struct wsevsrc *sc_input;
142 #ifdef WSDISPLAY_COMPAT_RAWKBD
143 int sc_rawkbd;
144 #endif
145 #endif /* NWSKBD > 0 */
146 };
147
148 #ifdef WSDISPLAY_SCROLLSUPPORT
149
150 struct wsdisplay_scroll_data wsdisplay_default_scroll_values = {
151 WSDISPLAY_SCROLL_DOALL,
152 25,
153 2,
154 };
155 #endif
156
157 extern struct cfdriver wsdisplay_cd;
158
159 /* Autoconfiguration definitions. */
160 static int wsdisplay_emul_match(device_t , cfdata_t, void *);
161 static void wsdisplay_emul_attach(device_t, device_t, void *);
162 static int wsdisplay_noemul_match(device_t, cfdata_t, void *);
163 static void wsdisplay_noemul_attach(device_t, device_t, void *);
164 static bool wsdisplay_suspend(device_t PMF_FN_PROTO);
165
166 CFATTACH_DECL_NEW(wsdisplay_emul, sizeof (struct wsdisplay_softc),
167 wsdisplay_emul_match, wsdisplay_emul_attach, NULL, NULL);
168
169 CFATTACH_DECL_NEW(wsdisplay_noemul, sizeof (struct wsdisplay_softc),
170 wsdisplay_noemul_match, wsdisplay_noemul_attach, NULL, NULL);
171
172 dev_type_open(wsdisplayopen);
173 dev_type_close(wsdisplayclose);
174 dev_type_read(wsdisplayread);
175 dev_type_write(wsdisplaywrite);
176 dev_type_ioctl(wsdisplayioctl);
177 dev_type_stop(wsdisplaystop);
178 dev_type_tty(wsdisplaytty);
179 dev_type_poll(wsdisplaypoll);
180 dev_type_mmap(wsdisplaymmap);
181 dev_type_kqfilter(wsdisplaykqfilter);
182
183 const struct cdevsw wsdisplay_cdevsw = {
184 wsdisplayopen, wsdisplayclose, wsdisplayread, wsdisplaywrite,
185 wsdisplayioctl, wsdisplaystop, wsdisplaytty, wsdisplaypoll,
186 wsdisplaymmap, wsdisplaykqfilter, D_TTY
187 };
188
189 static void wsdisplaystart(struct tty *);
190 static int wsdisplayparam(struct tty *, struct termios *);
191
192
193 #define WSDISPLAYUNIT(dev) (minor(dev) >> 8)
194 #define WSDISPLAYSCREEN(dev) (minor(dev) & 0xff)
195 #define ISWSDISPLAYSTAT(dev) (WSDISPLAYSCREEN(dev) == 254)
196 #define ISWSDISPLAYCTL(dev) (WSDISPLAYSCREEN(dev) == 255)
197 #define WSDISPLAYMINOR(unit, screen) (((unit) << 8) | (screen))
198
199 #define WSSCREEN_HAS_EMULATOR(scr) ((scr)->scr_dconf->wsemul != NULL)
200 #define WSSCREEN_HAS_TTY(scr) ((scr)->scr_tty != NULL)
201
202 static void wsdisplay_common_attach(struct wsdisplay_softc *sc,
203 int console, int kbdmux, const struct wsscreen_list *,
204 const struct wsdisplay_accessops *accessops,
205 void *accesscookie);
206
207 #ifdef WSDISPLAY_COMPAT_RAWKBD
208 int wsdisplay_update_rawkbd(struct wsdisplay_softc *,
209 struct wsscreen *);
210 #endif
211
212 static int wsdisplay_console_initted;
213 static int wsdisplay_console_attached;
214 static struct wsdisplay_softc *wsdisplay_console_device;
215 static struct wsscreen_internal wsdisplay_console_conf;
216
217 static int wsdisplay_getc_dummy(dev_t);
218 static void wsdisplay_pollc(dev_t, int);
219
220 static int wsdisplay_cons_pollmode;
221 static void (*wsdisplay_cons_kbd_pollc)(dev_t, int);
222
223 static struct consdev wsdisplay_cons = {
224 NULL, NULL, wsdisplay_getc_dummy, wsdisplay_cnputc,
225 wsdisplay_pollc, NULL, NULL, NULL, NODEV, CN_NORMAL
226 };
227
228 #ifndef WSDISPLAY_DEFAULTSCREENS
229 # define WSDISPLAY_DEFAULTSCREENS 0
230 #endif
231 int wsdisplay_defaultscreens = WSDISPLAY_DEFAULTSCREENS;
232
233 static int wsdisplay_switch1(device_t, int, int);
234 static void wsdisplay_switch1_cb(void *, int, int);
235 static int wsdisplay_switch2(device_t, int, int);
236 static void wsdisplay_switch2_cb(void *, int, int);
237 static int wsdisplay_switch3(device_t, int, int);
238 static void wsdisplay_switch3_cb(void *, int, int);
239
240 int wsdisplay_clearonclose;
241
242 struct wsscreen *
243 wsscreen_attach(struct wsdisplay_softc *sc, int console, const char *emul,
244 const struct wsscreen_descr *type, void *cookie, int ccol,
245 int crow, long defattr)
246 {
247 struct wsscreen_internal *dconf;
248 struct wsscreen *scr;
249
250 scr = malloc(sizeof(struct wsscreen), M_DEVBUF, M_WAITOK);
251 if (!scr)
252 return (NULL);
253
254 if (console) {
255 dconf = &wsdisplay_console_conf;
256 /*
257 * If there's an emulation, tell it about the callback argument.
258 * The other stuff is already there.
259 */
260 if (dconf->wsemul != NULL)
261 (*dconf->wsemul->attach)(1, 0, 0, 0, 0, scr, 0);
262 } else { /* not console */
263 dconf = malloc(sizeof(struct wsscreen_internal),
264 M_DEVBUF, M_NOWAIT);
265 dconf->emulops = type->textops;
266 dconf->emulcookie = cookie;
267 if (dconf->emulops) {
268 dconf->wsemul = wsemul_pick(emul);
269 if (dconf->wsemul == NULL) {
270 free(dconf, M_DEVBUF);
271 free(scr, M_DEVBUF);
272 return (NULL);
273 }
274 dconf->wsemulcookie =
275 (*dconf->wsemul->attach)(0, type, cookie,
276 ccol, crow, scr, defattr);
277 } else
278 dconf->wsemul = NULL;
279 dconf->scrdata = type;
280 }
281
282 scr->scr_dconf = dconf;
283
284 scr->scr_tty = ttymalloc();
285 tty_attach(scr->scr_tty);
286 scr->scr_hold_screen = 0;
287 if (WSSCREEN_HAS_EMULATOR(scr))
288 scr->scr_flags = 0;
289 else
290 scr->scr_flags = SCR_GRAPHICS;
291
292 scr->scr_syncops = 0;
293 scr->sc = sc;
294 #ifdef WSDISPLAY_COMPAT_RAWKBD
295 scr->scr_rawkbd = 0;
296 #endif
297 return (scr);
298 }
299
300 void
301 wsscreen_detach(struct wsscreen *scr)
302 {
303 u_int ccol, crow; /* XXX */
304
305 if (WSSCREEN_HAS_TTY(scr)) {
306 tty_detach(scr->scr_tty);
307 ttyfree(scr->scr_tty);
308 }
309 if (WSSCREEN_HAS_EMULATOR(scr))
310 (*scr->scr_dconf->wsemul->detach)(scr->scr_dconf->wsemulcookie,
311 &ccol, &crow);
312 free(scr->scr_dconf, M_DEVBUF);
313 free(scr, M_DEVBUF);
314 }
315
316 const struct wsscreen_descr *
317 wsdisplay_screentype_pick(const struct wsscreen_list *scrdata, const char *name)
318 {
319 int i;
320 const struct wsscreen_descr *scr;
321
322 KASSERT(scrdata->nscreens > 0);
323
324 if (name == NULL)
325 return (scrdata->screens[0]);
326
327 for (i = 0; i < scrdata->nscreens; i++) {
328 scr = scrdata->screens[i];
329 if (!strcmp(name, scr->name))
330 return (scr);
331 }
332
333 return (0);
334 }
335
336 /*
337 * print info about attached screen
338 */
339 static void
340 wsdisplay_addscreen_print(struct wsdisplay_softc *sc, int idx, int count)
341 {
342 aprint_verbose_dev(sc->sc_dev, "screen %d", idx);
343 if (count > 1)
344 aprint_verbose("-%d", idx + (count-1));
345 aprint_verbose(" added (%s", sc->sc_scr[idx]->scr_dconf->scrdata->name);
346 if (WSSCREEN_HAS_EMULATOR(sc->sc_scr[idx])) {
347 aprint_verbose(", %s emulation",
348 sc->sc_scr[idx]->scr_dconf->wsemul->name);
349 }
350 aprint_verbose(")\n");
351 }
352
353 int
354 wsdisplay_addscreen(struct wsdisplay_softc *sc, int idx,
355 const char *screentype, const char *emul)
356 {
357 const struct wsscreen_descr *scrdesc;
358 int error;
359 void *cookie;
360 int ccol, crow;
361 long defattr;
362 struct wsscreen *scr;
363 int s;
364
365 if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
366 return (EINVAL);
367 if (sc->sc_scr[idx] != NULL)
368 return (EBUSY);
369
370 scrdesc = wsdisplay_screentype_pick(sc->sc_scrdata, screentype);
371 if (!scrdesc)
372 return (ENXIO);
373 error = (*sc->sc_accessops->alloc_screen)(sc->sc_accesscookie,
374 scrdesc, &cookie, &ccol, &crow, &defattr);
375 if (error)
376 return (error);
377
378 scr = wsscreen_attach(sc, 0, emul, scrdesc,
379 cookie, ccol, crow, defattr);
380 if (scr == NULL) {
381 (*sc->sc_accessops->free_screen)(sc->sc_accesscookie,
382 cookie);
383 return (ENXIO);
384 }
385
386 sc->sc_scr[idx] = scr;
387
388 /* if no screen has focus yet, activate the first we get */
389 s = spltty();
390 if (!sc->sc_focus) {
391 (*sc->sc_accessops->show_screen)(sc->sc_accesscookie,
392 scr->scr_dconf->emulcookie,
393 0, 0, 0);
394 sc->sc_focusidx = idx;
395 sc->sc_focus = scr;
396 }
397 splx(s);
398 return (0);
399 }
400
401 static void
402 wsdisplay_closescreen(struct wsdisplay_softc *sc, struct wsscreen *scr)
403 {
404 int maj, mn, idx;
405
406 /* hangup */
407 if (WSSCREEN_HAS_TTY(scr)) {
408 struct tty *tp = scr->scr_tty;
409 (*tp->t_linesw->l_modem)(tp, 0);
410 }
411
412 /* locate the major number */
413 maj = cdevsw_lookup_major(&wsdisplay_cdevsw);
414 /* locate the screen index */
415 for (idx = 0; idx < WSDISPLAY_MAXSCREEN; idx++)
416 if (scr == sc->sc_scr[idx])
417 break;
418 #ifdef DIAGNOSTIC
419 if (idx == WSDISPLAY_MAXSCREEN)
420 panic("wsdisplay_forceclose: bad screen");
421 #endif
422
423 /* nuke the vnodes */
424 mn = WSDISPLAYMINOR(device_unit(sc->sc_dev), idx);
425 vdevgone(maj, mn, mn, VCHR);
426 }
427
428 #ifdef WSDISPLAY_SCROLLSUPPORT
429 void
430 wsdisplay_scroll(void *arg, int op)
431 {
432 device_t dv = arg;
433 struct wsdisplay_softc *sc = device_private(dv);
434 struct wsscreen *scr;
435 int lines;
436
437 scr = sc->sc_focus;
438
439 if (!scr)
440 return;
441
442 if (op == WSDISPLAY_SCROLL_RESET)
443 lines = 0;
444 else {
445 lines = (op & WSDISPLAY_SCROLL_LOW) ?
446 sc->sc_scroll_values.slowlines :
447 sc->sc_scroll_values.fastlines;
448 if (op & WSDISPLAY_SCROLL_BACKWARD)
449 lines = -(lines);
450 }
451
452 if (sc->sc_accessops->scroll) {
453 (*sc->sc_accessops->scroll)(sc->sc_accesscookie,
454 sc->sc_focus->scr_dconf->emulcookie, lines);
455 }
456 }
457 #endif
458
459 int
460 wsdisplay_delscreen(struct wsdisplay_softc *sc, int idx, int flags)
461 {
462 struct wsscreen *scr;
463 int s;
464 void *cookie;
465
466 if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
467 return (EINVAL);
468 if ((scr = sc->sc_scr[idx]) == NULL)
469 return (ENXIO);
470
471 if (scr->scr_dconf == &wsdisplay_console_conf ||
472 scr->scr_syncops ||
473 ((scr->scr_flags & SCR_OPEN) && !(flags & WSDISPLAY_DELSCR_FORCE)))
474 return(EBUSY);
475
476 wsdisplay_closescreen(sc, scr);
477
478 /*
479 * delete pointers, so neither device entries
480 * nor keyboard input can reference it anymore
481 */
482 s = spltty();
483 if (sc->sc_focus == scr) {
484 sc->sc_focus = 0;
485 #ifdef WSDISPLAY_COMPAT_RAWKBD
486 wsdisplay_update_rawkbd(sc, 0);
487 #endif
488 }
489 sc->sc_scr[idx] = 0;
490 splx(s);
491
492 /*
493 * Wake up processes waiting for the screen to
494 * be activated. Sleepers must check whether
495 * the screen still exists.
496 */
497 if (scr->scr_flags & SCR_WAITACTIVE)
498 wakeup(scr);
499
500 /* save a reference to the graphics screen */
501 cookie = scr->scr_dconf->emulcookie;
502
503 wsscreen_detach(scr);
504
505 (*sc->sc_accessops->free_screen)(sc->sc_accesscookie,
506 cookie);
507
508 aprint_verbose_dev(sc->sc_dev, "screen %d deleted\n", idx);
509 return (0);
510 }
511
512 /*
513 * Autoconfiguration functions.
514 */
515 int
516 wsdisplay_emul_match(device_t parent, cfdata_t match, void *aux)
517 {
518 struct wsemuldisplaydev_attach_args *ap = aux;
519
520 if (match->wsemuldisplaydevcf_console !=
521 WSEMULDISPLAYDEVCF_CONSOLE_UNK) {
522 /*
523 * If console-ness of device specified, either match
524 * exactly (at high priority), or fail.
525 */
526 if (match->wsemuldisplaydevcf_console != 0 &&
527 ap->console != 0)
528 return (10);
529 else
530 return (0);
531 }
532
533 /* If console-ness unspecified, it wins. */
534 return (1);
535 }
536
537 void
538 wsdisplay_emul_attach(device_t parent, device_t self, void *aux)
539 {
540 struct wsdisplay_softc *sc = device_private(self);
541 struct wsemuldisplaydev_attach_args *ap = aux;
542
543 sc->sc_dev = self;
544
545 /* Don't allow more than one console to attach */
546 if (wsdisplay_console_attached && ap->console)
547 ap->console = 0;
548
549 wsdisplay_common_attach(sc, ap->console,
550 device_cfdata(self)->wsemuldisplaydevcf_kbdmux, ap->scrdata,
551 ap->accessops, ap->accesscookie);
552
553 if (ap->console) {
554 int maj;
555
556 /* locate the major number */
557 maj = cdevsw_lookup_major(&wsdisplay_cdevsw);
558
559 cn_tab->cn_dev = makedev(maj, WSDISPLAYMINOR(device_unit(self),
560 0));
561 }
562 }
563
564 /* Print function (for parent devices). */
565 int
566 wsemuldisplaydevprint(void *aux, const char *pnp)
567 {
568 #if 0 /* -Wunused */
569 struct wsemuldisplaydev_attach_args *ap = aux;
570 #endif
571
572 if (pnp)
573 aprint_normal("wsdisplay at %s", pnp);
574 #if 0 /* don't bother; it's ugly */
575 aprint_normal(" console %d", ap->console);
576 #endif
577
578 return (UNCONF);
579 }
580
581 int
582 wsdisplay_noemul_match(device_t parent, cfdata_t match, void *aux)
583 {
584 #if 0 /* -Wunused */
585 struct wsdisplaydev_attach_args *ap = aux;
586 #endif
587
588 /* Always match. */
589 return (1);
590 }
591
592 void
593 wsdisplay_noemul_attach(device_t parent, device_t self, void *aux)
594 {
595 struct wsdisplay_softc *sc = device_private(self);
596 struct wsdisplaydev_attach_args *ap = aux;
597
598 sc->sc_dev = self;
599
600 wsdisplay_common_attach(sc, 0,
601 device_cfdata(self)->wsemuldisplaydevcf_kbdmux, NULL,
602 ap->accessops, ap->accesscookie);
603 }
604
605 static void
606 wsdisplay_swdone_cb(void *arg, int error, int waitok)
607 {
608 struct wsdisplay_softc *sc = arg;
609
610 mutex_enter(&sc->sc_flagsmtx);
611 KASSERT(sc->sc_flags & SC_SWITCHPENDING);
612 if (error)
613 sc->sc_flags |= SC_SWITCHERROR;
614 sc->sc_flags &= ~SC_SWITCHPENDING;
615 cv_signal(&sc->sc_flagscv);
616 mutex_exit(&sc->sc_flagsmtx);
617 }
618
619 static int
620 wsdisplay_dosync(struct wsdisplay_softc *sc, int attach)
621 {
622 struct wsscreen *scr;
623 int (*op)(void *, int, void (*)(void *, int, int), void *);
624 int res;
625
626 scr = sc->sc_focus;
627 if (!scr || !scr->scr_syncops)
628 return 0; /* XXX check SCR_GRAPHICS? */
629
630 sc->sc_flags |= SC_SWITCHPENDING;
631 sc->sc_flags &= ~SC_SWITCHERROR;
632 if (attach)
633 op = scr->scr_syncops->attach;
634 else
635 op = scr->scr_syncops->detach;
636 res = (*op)(scr->scr_synccookie, 1, wsdisplay_swdone_cb, sc);
637 if (res == EAGAIN) {
638 /* wait for callback */
639 mutex_enter(&sc->sc_flagsmtx);
640 while (sc->sc_flags & SC_SWITCHPENDING)
641 cv_wait_sig(&sc->sc_flagscv, &sc->sc_flagsmtx);
642 mutex_exit(&sc->sc_flagsmtx);
643 if (sc->sc_flags & SC_SWITCHERROR)
644 return (EIO); /* XXX pass real error */
645 } else {
646 sc->sc_flags &= ~SC_SWITCHPENDING;
647 if (res)
648 return (res);
649 }
650 if (attach)
651 sc->sc_flags |= SC_XATTACHED;
652 else
653 sc->sc_flags &= ~SC_XATTACHED;
654 return 0;
655 }
656
657 int
658 wsdisplay_handlex(int resume)
659 {
660 int i, res;
661 device_t dv;
662
663 for (i = 0; i < wsdisplay_cd.cd_ndevs; i++) {
664 dv = device_lookup(&wsdisplay_cd, i);
665 if (!dv)
666 continue;
667 res = wsdisplay_dosync(device_private(dv), resume);
668 if (res)
669 return (res);
670 }
671 return (0);
672 }
673
674 static bool
675 wsdisplay_suspend(device_t dv PMF_FN_ARGS)
676 {
677 struct wsdisplay_softc *sc = device_private(dv);
678 #ifdef DIAGNOSTIC
679 struct wsscreen *scr = sc->sc_focus;
680 if (sc->sc_flags & SC_XATTACHED) {
681 KASSERT(scr && scr->scr_syncops);
682 }
683 #endif
684 #if 1
685 /*
686 * XXX X servers should have been detached earlier.
687 * pmf currently ignores our return value and suspends the system
688 * after device suspend failures. We try to avoid bigger damage
689 * and try to detach the X server here. This is not safe because
690 * other parts of the system which the X server deals with
691 * might already be suspended.
692 */
693 if (sc->sc_flags & SC_XATTACHED) {
694 printf("%s: emergency X server detach\n", device_xname(dv));
695 wsdisplay_dosync(sc, 0);
696 }
697 #endif
698 return (!(sc->sc_flags & SC_XATTACHED));
699 }
700
701 /* Print function (for parent devices). */
702 int
703 wsdisplaydevprint(void *aux, const char *pnp)
704 {
705 #if 0 /* -Wunused */
706 struct wsdisplaydev_attach_args *ap = aux;
707 #endif
708
709 if (pnp)
710 aprint_normal("wsdisplay at %s", pnp);
711
712 return (UNCONF);
713 }
714
715 static void
716 wsdisplay_common_attach(struct wsdisplay_softc *sc, int console, int kbdmux,
717 const struct wsscreen_list *scrdata,
718 const struct wsdisplay_accessops *accessops,
719 void *accesscookie)
720 {
721 int i, start=0;
722 #if NWSKBD > 0
723 struct wsevsrc *kme;
724 #if NWSMUX > 0
725 struct wsmux_softc *mux;
726
727 if (kbdmux >= 0)
728 mux = wsmux_getmux(kbdmux);
729 else
730 mux = wsmux_create("dmux", device_unit(sc->sc_dev));
731 /* XXX panic()ing isn't nice, but attach cannot fail */
732 if (mux == NULL)
733 panic("wsdisplay_common_attach: no memory");
734 sc->sc_input = &mux->sc_base;
735 mux->sc_base.me_dispdv = sc->sc_dev;
736 aprint_normal(" kbdmux %d", kbdmux);
737 #else
738 if (kbdmux >= 0)
739 aprint_normal(" (kbdmux ignored)");
740 #endif
741 #endif
742
743 sc->sc_isconsole = console;
744
745 if (console) {
746 KASSERT(wsdisplay_console_initted);
747 KASSERT(wsdisplay_console_device == NULL);
748
749 sc->sc_scr[0] = wsscreen_attach(sc, 1, 0, 0, 0, 0, 0, 0);
750 wsdisplay_console_device = sc;
751
752 aprint_normal(": console (%s, %s emulation)",
753 wsdisplay_console_conf.scrdata->name,
754 wsdisplay_console_conf.wsemul->name);
755
756 #if NWSKBD > 0
757 kme = wskbd_set_console_display(sc->sc_dev, sc->sc_input);
758 if (kme != NULL)
759 aprint_normal(", using %s", device_xname(kme->me_dv));
760 #if NWSMUX == 0
761 sc->sc_input = kme;
762 #endif
763 #endif
764
765 sc->sc_focusidx = 0;
766 sc->sc_focus = sc->sc_scr[0];
767 start = 1;
768
769 wsdisplay_console_attached = 1;
770 }
771 aprint_normal("\n");
772
773 #if NWSKBD > 0 && NWSMUX > 0
774 wsmux_set_display(mux, sc->sc_dev);
775 #endif
776
777 mutex_init(&sc->sc_flagsmtx, MUTEX_DEFAULT, IPL_NONE);
778 cv_init(&sc->sc_flagscv, "wssw");
779
780 sc->sc_accessops = accessops;
781 sc->sc_accesscookie = accesscookie;
782 sc->sc_scrdata = scrdata;
783
784 #ifdef WSDISPLAY_SCROLLSUPPORT
785 sc->sc_scroll_values = wsdisplay_default_scroll_values;
786 #endif
787
788 /*
789 * Set up a number of virtual screens if wanted. The
790 * WSDISPLAYIO_ADDSCREEN ioctl is more flexible, so this code
791 * is for special cases like installation kernels.
792 */
793 for (i = start; i < wsdisplay_defaultscreens; i++) {
794 if (wsdisplay_addscreen(sc, i, 0, 0))
795 break;
796 }
797
798 if (i > start)
799 wsdisplay_addscreen_print(sc, start, i-start);
800
801 if (!pmf_device_register(sc->sc_dev, wsdisplay_suspend, NULL))
802 aprint_error_dev(sc->sc_dev, "couldn't establish power handler\n");
803 }
804
805 void
806 wsdisplay_cnattach(const struct wsscreen_descr *type, void *cookie,
807 int ccol, int crow, long defattr)
808 {
809 const struct wsemul_ops *wsemul;
810
811 KASSERT(wsdisplay_console_initted < 2);
812 KASSERT(type->nrows > 0);
813 KASSERT(type->ncols > 0);
814 KASSERT(crow < type->nrows);
815 KASSERT(ccol < type->ncols);
816
817 wsdisplay_console_conf.emulops = type->textops;
818 wsdisplay_console_conf.emulcookie = cookie;
819 wsdisplay_console_conf.scrdata = type;
820
821 wsemul = wsemul_pick(0); /* default */
822 wsdisplay_console_conf.wsemul = wsemul;
823 wsdisplay_console_conf.wsemulcookie = (*wsemul->cnattach)(type, cookie,
824 ccol, crow,
825 defattr);
826
827 cn_tab = &wsdisplay_cons;
828 wsdisplay_console_initted = 2;
829 }
830
831 void
832 wsdisplay_preattach(const struct wsscreen_descr *type, void *cookie,
833 int ccol, int crow, long defattr)
834 {
835 const struct wsemul_ops *wsemul;
836
837 KASSERT(!wsdisplay_console_initted);
838 KASSERT(type->nrows > 0);
839 KASSERT(type->ncols > 0);
840 KASSERT(crow < type->nrows);
841 KASSERT(ccol < type->ncols);
842
843 wsdisplay_console_conf.emulops = type->textops;
844 wsdisplay_console_conf.emulcookie = cookie;
845 wsdisplay_console_conf.scrdata = type;
846
847 wsemul = wsemul_pick(0); /* default */
848 wsdisplay_console_conf.wsemul = wsemul;
849 wsdisplay_console_conf.wsemulcookie = (*wsemul->cnattach)(type, cookie,
850 ccol, crow,
851 defattr);
852
853 cn_tab = &wsdisplay_cons;
854 wsdisplay_console_initted = 1;
855 }
856
857 /*
858 * Tty and cdevsw functions.
859 */
860 int
861 wsdisplayopen(dev_t dev, int flag, int mode, struct lwp *l)
862 {
863 struct wsdisplay_softc *sc;
864 struct tty *tp;
865 int newopen, error;
866 struct wsscreen *scr;
867
868 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
869 if (sc == NULL) /* make sure it was attached */
870 return (ENXIO);
871
872 if (ISWSDISPLAYSTAT(dev)) {
873 wsevent_init(&sc->evar, l->l_proc);
874 return (0);
875 }
876
877 if (ISWSDISPLAYCTL(dev))
878 return (0);
879
880 if (WSDISPLAYSCREEN(dev) >= WSDISPLAY_MAXSCREEN)
881 return (ENXIO);
882 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
883 return (ENXIO);
884
885 if (WSSCREEN_HAS_TTY(scr)) {
886 tp = scr->scr_tty;
887 tp->t_oproc = wsdisplaystart;
888 tp->t_param = wsdisplayparam;
889 tp->t_dev = dev;
890 newopen = (tp->t_state & TS_ISOPEN) == 0;
891
892 if (kauth_authorize_device_tty(l->l_cred,
893 KAUTH_DEVICE_TTY_OPEN, tp))
894 return (EBUSY);
895
896 if (newopen) {
897 ttychars(tp);
898 tp->t_iflag = TTYDEF_IFLAG;
899 tp->t_oflag = TTYDEF_OFLAG;
900 tp->t_cflag = TTYDEF_CFLAG;
901 tp->t_lflag = TTYDEF_LFLAG;
902 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
903 wsdisplayparam(tp, &tp->t_termios);
904 ttsetwater(tp);
905 }
906 tp->t_state |= TS_CARR_ON;
907
908 error = ((*tp->t_linesw->l_open)(dev, tp));
909 if (error)
910 return (error);
911
912 if (newopen && WSSCREEN_HAS_EMULATOR(scr)) {
913 /* set window sizes as appropriate, and reset
914 the emulation */
915 tp->t_winsize.ws_row = scr->scr_dconf->scrdata->nrows;
916 tp->t_winsize.ws_col = scr->scr_dconf->scrdata->ncols;
917
918 /* wsdisplay_set_emulation() */
919 }
920 }
921
922 scr->scr_flags |= SCR_OPEN;
923 return (0);
924 }
925
926 int
927 wsdisplayclose(dev_t dev, int flag, int mode, struct lwp *l)
928 {
929 device_t dv;
930 struct wsdisplay_softc *sc;
931 struct tty *tp;
932 struct wsscreen *scr;
933
934 dv = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
935 sc = device_private(dv);
936
937 if (ISWSDISPLAYSTAT(dev)) {
938 wsevent_fini(&sc->evar);
939 return (0);
940 }
941
942 if (ISWSDISPLAYCTL(dev))
943 return (0);
944
945 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
946 return (0);
947
948 if (WSSCREEN_HAS_TTY(scr)) {
949 if (scr->scr_hold_screen) {
950 int s;
951
952 /* XXX RESET KEYBOARD LEDS, etc. */
953 s = spltty(); /* avoid conflict with keyboard */
954 wsdisplay_kbdholdscreen(dv, 0);
955 splx(s);
956 }
957 tp = scr->scr_tty;
958 (*tp->t_linesw->l_close)(tp, flag);
959 ttyclose(tp);
960 }
961
962 if (scr->scr_syncops)
963 (*scr->scr_syncops->destroy)(scr->scr_synccookie);
964
965 if (WSSCREEN_HAS_EMULATOR(scr)) {
966 scr->scr_flags &= ~SCR_GRAPHICS;
967 (*scr->scr_dconf->wsemul->reset)(scr->scr_dconf->wsemulcookie,
968 WSEMUL_RESET);
969 if (wsdisplay_clearonclose)
970 (*scr->scr_dconf->wsemul->reset)
971 (scr->scr_dconf->wsemulcookie,
972 WSEMUL_CLEARSCREEN);
973 }
974
975 #ifdef WSDISPLAY_COMPAT_RAWKBD
976 if (scr->scr_rawkbd) {
977 int kbmode = WSKBD_TRANSLATED;
978 (void)wsdisplay_internal_ioctl(sc, scr, WSKBDIO_SETMODE,
979 (void *)&kbmode, 0, l);
980 }
981 #endif
982
983 scr->scr_flags &= ~SCR_OPEN;
984
985 return (0);
986 }
987
988 int
989 wsdisplayread(dev_t dev, struct uio *uio, int flag)
990 {
991 struct wsdisplay_softc *sc;
992 struct tty *tp;
993 struct wsscreen *scr;
994 int error;
995
996 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
997
998 if (ISWSDISPLAYSTAT(dev)) {
999 error = wsevent_read(&sc->evar, uio, flag);
1000 return (error);
1001 }
1002
1003 if (ISWSDISPLAYCTL(dev))
1004 return (0);
1005
1006 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1007 return (ENXIO);
1008
1009 if (!WSSCREEN_HAS_TTY(scr))
1010 return (ENODEV);
1011
1012 tp = scr->scr_tty;
1013 return ((*tp->t_linesw->l_read)(tp, uio, flag));
1014 }
1015
1016 int
1017 wsdisplaywrite(dev_t dev, struct uio *uio, int flag)
1018 {
1019 struct wsdisplay_softc *sc;
1020 struct tty *tp;
1021 struct wsscreen *scr;
1022
1023 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1024
1025 if (ISWSDISPLAYSTAT(dev)) {
1026 return (0);
1027 }
1028
1029 if (ISWSDISPLAYCTL(dev))
1030 return (0);
1031
1032 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1033 return (ENXIO);
1034
1035 if (!WSSCREEN_HAS_TTY(scr))
1036 return (ENODEV);
1037
1038 tp = scr->scr_tty;
1039 return ((*tp->t_linesw->l_write)(tp, uio, flag));
1040 }
1041
1042 int
1043 wsdisplaypoll(dev_t dev, int events, struct lwp *l)
1044 {
1045 struct wsdisplay_softc *sc;
1046 struct tty *tp;
1047 struct wsscreen *scr;
1048
1049 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1050
1051 if (ISWSDISPLAYSTAT(dev))
1052 return (wsevent_poll(&sc->evar, events, l));
1053
1054 if (ISWSDISPLAYCTL(dev))
1055 return (0);
1056
1057 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1058 return (POLLHUP);
1059
1060 if (!WSSCREEN_HAS_TTY(scr))
1061 return (POLLERR);
1062
1063 tp = scr->scr_tty;
1064 return ((*tp->t_linesw->l_poll)(tp, events, l));
1065 }
1066
1067 int
1068 wsdisplaykqfilter(dev_t dev, struct knote *kn)
1069 {
1070 struct wsdisplay_softc *sc;
1071 struct wsscreen *scr;
1072
1073 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1074
1075 if (ISWSDISPLAYCTL(dev))
1076 return (1);
1077
1078 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1079 return (1);
1080
1081
1082 if (WSSCREEN_HAS_TTY(scr))
1083 return (ttykqfilter(dev, kn));
1084 else
1085 return (1);
1086 }
1087
1088 struct tty *
1089 wsdisplaytty(dev_t dev)
1090 {
1091 struct wsdisplay_softc *sc;
1092 struct wsscreen *scr;
1093
1094 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1095
1096 if (ISWSDISPLAYSTAT(dev))
1097 panic("wsdisplaytty() on status device");
1098
1099 if (ISWSDISPLAYCTL(dev))
1100 panic("wsdisplaytty() on ctl device");
1101
1102 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1103 return NULL;
1104
1105 return (scr->scr_tty);
1106 }
1107
1108 int
1109 wsdisplayioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
1110 {
1111 device_t dv;
1112 struct wsdisplay_softc *sc;
1113 struct tty *tp;
1114 int error;
1115 struct wsscreen *scr;
1116
1117 dv = device_lookup(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1118 sc = device_private(dv);
1119
1120 #ifdef WSDISPLAY_COMPAT_USL
1121 error = wsdisplay_usl_ioctl1(dv, cmd, data, flag, l);
1122 if (error != EPASSTHROUGH)
1123 return (error);
1124 #endif
1125
1126 if (ISWSDISPLAYSTAT(dev))
1127 return (wsdisplay_stat_ioctl(sc, cmd, data, flag, l));
1128
1129 if (ISWSDISPLAYCTL(dev))
1130 return (wsdisplay_cfg_ioctl(sc, cmd, data, flag, l));
1131
1132 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1133 return (ENXIO);
1134
1135 if (WSSCREEN_HAS_TTY(scr)) {
1136 tp = scr->scr_tty;
1137
1138 /* printf("disc\n"); */
1139 /* do the line discipline ioctls first */
1140 error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, l);
1141 if (error != EPASSTHROUGH)
1142 return (error);
1143
1144 /* printf("tty\n"); */
1145 /* then the tty ioctls */
1146 error = ttioctl(tp, cmd, data, flag, l);
1147 if (error != EPASSTHROUGH)
1148 return (error);
1149 }
1150
1151 #ifdef WSDISPLAY_COMPAT_USL
1152 error = wsdisplay_usl_ioctl2(sc, scr, cmd, data, flag, l);
1153 if (error != EPASSTHROUGH)
1154 return (error);
1155 #endif
1156
1157 return (wsdisplay_internal_ioctl(sc, scr, cmd, data, flag, l));
1158 }
1159
1160 int
1161 wsdisplay_param(device_t dv, u_long cmd, struct wsdisplay_param *dp)
1162 {
1163 struct wsdisplay_softc *sc = device_private(dv);
1164 return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie,
1165 sc->sc_focus->scr_dconf->emulcookie,
1166 cmd, (void *)dp, 0, NULL));
1167 }
1168
1169 int
1170 wsdisplay_internal_ioctl(struct wsdisplay_softc *sc, struct wsscreen *scr,
1171 u_long cmd, void *data, int flag, struct lwp *l)
1172 {
1173 int error;
1174 char namebuf[16];
1175 struct wsdisplay_font fd;
1176 #ifdef WSDISPLAY_SCROLLSUPPORT
1177 struct wsdisplay_scroll_data *ksdp, *usdp;
1178 #endif
1179
1180 #if NWSKBD > 0
1181 struct wsevsrc *inp;
1182
1183 #ifdef WSDISPLAY_COMPAT_RAWKBD
1184 switch (cmd) {
1185 case WSKBDIO_SETMODE:
1186 scr->scr_rawkbd = (*(int *)data == WSKBD_RAW);
1187 return (wsdisplay_update_rawkbd(sc, scr));
1188 case WSKBDIO_GETMODE:
1189 *(int *)data = (scr->scr_rawkbd ?
1190 WSKBD_RAW : WSKBD_TRANSLATED);
1191 return (0);
1192 }
1193 #endif
1194 inp = sc->sc_input;
1195 if (inp == NULL)
1196 return (ENXIO);
1197 error = wsevsrc_display_ioctl(inp, cmd, data, flag, l);
1198 if (error != EPASSTHROUGH)
1199 return (error);
1200 #endif /* NWSKBD > 0 */
1201
1202 switch (cmd) {
1203 case WSDISPLAYIO_GMODE:
1204 if (scr->scr_flags & SCR_GRAPHICS) {
1205 if (scr->scr_flags & SCR_DUMBFB)
1206 *(u_int *)data = WSDISPLAYIO_MODE_DUMBFB;
1207 else
1208 *(u_int *)data = WSDISPLAYIO_MODE_MAPPED;
1209 } else
1210 *(u_int *)data = WSDISPLAYIO_MODE_EMUL;
1211 return (0);
1212
1213 case WSDISPLAYIO_SMODE:
1214 #define d (*(int *)data)
1215 if (d != WSDISPLAYIO_MODE_EMUL &&
1216 d != WSDISPLAYIO_MODE_MAPPED &&
1217 d != WSDISPLAYIO_MODE_DUMBFB)
1218 return (EINVAL);
1219
1220 if (WSSCREEN_HAS_EMULATOR(scr)) {
1221 scr->scr_flags &= ~SCR_GRAPHICS;
1222 if (d == WSDISPLAYIO_MODE_MAPPED ||
1223 d == WSDISPLAYIO_MODE_DUMBFB)
1224 scr->scr_flags |= SCR_GRAPHICS |
1225 ((d == WSDISPLAYIO_MODE_DUMBFB) ? SCR_DUMBFB : 0);
1226 } else if (d == WSDISPLAYIO_MODE_EMUL)
1227 return (EINVAL);
1228
1229 (void)(*sc->sc_accessops->ioctl)(sc->sc_accesscookie,
1230 scr->scr_dconf->emulcookie, cmd, data, flag, l);
1231
1232 return (0);
1233 #undef d
1234
1235 #ifdef WSDISPLAY_SCROLLSUPPORT
1236 #define SETSCROLLLINES(dstp, srcp, dfltp) \
1237 do { \
1238 (dstp)->fastlines = ((srcp)->which & \
1239 WSDISPLAY_SCROLL_DOFASTLINES) ? \
1240 (srcp)->fastlines : (dfltp)->fastlines; \
1241 (dstp)->slowlines = ((srcp)->which & \
1242 WSDISPLAY_SCROLL_DOSLOWLINES) ? \
1243 (srcp)->slowlines : (dfltp)->slowlines; \
1244 (dstp)->which = WSDISPLAY_SCROLL_DOALL; \
1245 } while (0)
1246
1247
1248 case WSDISPLAYIO_DSSCROLL:
1249 usdp = (struct wsdisplay_scroll_data *)data;
1250 ksdp = &sc->sc_scroll_values;
1251 SETSCROLLLINES(ksdp, usdp, ksdp);
1252 return (0);
1253
1254 case WSDISPLAYIO_DGSCROLL:
1255 usdp = (struct wsdisplay_scroll_data *)data;
1256 ksdp = &sc->sc_scroll_values;
1257 SETSCROLLLINES(usdp, ksdp, ksdp);
1258 return (0);
1259 #else
1260 case WSDISPLAYIO_DSSCROLL:
1261 case WSDISPLAYIO_DGSCROLL:
1262 return ENODEV;
1263 #endif
1264
1265 case WSDISPLAYIO_SFONT:
1266 #define d ((struct wsdisplay_usefontdata *)data)
1267 if (!sc->sc_accessops->load_font)
1268 return (EINVAL);
1269 if (d->name) {
1270 error = copyinstr(d->name, namebuf, sizeof(namebuf), 0);
1271 if (error)
1272 return (error);
1273 fd.name = namebuf;
1274 } else
1275 fd.name = 0;
1276 fd.data = 0;
1277 error = (*sc->sc_accessops->load_font)(sc->sc_accesscookie,
1278 scr->scr_dconf->emulcookie, &fd);
1279 if (!error && WSSCREEN_HAS_EMULATOR(scr))
1280 (*scr->scr_dconf->wsemul->reset)
1281 (scr->scr_dconf->wsemulcookie, WSEMUL_SYNCFONT);
1282 return (error);
1283 #undef d
1284
1285 #ifdef WSDISPLAY_CUSTOM_OUTPUT
1286 case WSDISPLAYIO_GMSGATTRS:
1287 #define d ((struct wsdisplay_msgattrs *)data)
1288 (*scr->scr_dconf->wsemul->getmsgattrs)
1289 (scr->scr_dconf->wsemulcookie, d);
1290 return (0);
1291 #undef d
1292
1293 case WSDISPLAYIO_SMSGATTRS: {
1294 #define d ((struct wsdisplay_msgattrs *)data)
1295 int i;
1296 for (i = 0; i < WSDISPLAY_MAXSCREEN; i++)
1297 if (sc->sc_scr[i] != NULL)
1298 (*sc->sc_scr[i]->scr_dconf->wsemul->setmsgattrs)
1299 (sc->sc_scr[i]->scr_dconf->wsemulcookie,
1300 sc->sc_scr[i]->scr_dconf->scrdata,
1301 d);
1302 }
1303 return (0);
1304 #undef d
1305 #else
1306 case WSDISPLAYIO_GMSGATTRS:
1307 case WSDISPLAYIO_SMSGATTRS:
1308 return (ENODEV);
1309 #endif
1310 case WSDISPLAYIO_SETVERSION:
1311 return wsevent_setversion(&sc->evar, *(int *)data);
1312 }
1313
1314 /* check ioctls for display */
1315 return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie,
1316 scr->scr_dconf->emulcookie, cmd, data, flag, l));
1317 }
1318
1319 int
1320 wsdisplay_stat_ioctl(struct wsdisplay_softc *sc, u_long cmd, void *data,
1321 int flag, struct lwp *l)
1322 {
1323 switch (cmd) {
1324 case WSDISPLAYIO_GETACTIVESCREEN:
1325 *(int*)data = wsdisplay_getactivescreen(sc);
1326 return (0);
1327 }
1328
1329 return (EPASSTHROUGH);
1330 }
1331
1332 int
1333 wsdisplay_cfg_ioctl(struct wsdisplay_softc *sc, u_long cmd, void *data,
1334 int flag, struct lwp *l)
1335 {
1336 int error;
1337 char *type, typebuf[16], *emul, emulbuf[16];
1338 void *tbuf;
1339 u_int fontsz;
1340 #if defined(COMPAT_14) && NWSKBD > 0
1341 struct wsmux_device wsmuxdata;
1342 #endif
1343 #if NWSKBD > 0
1344 struct wsevsrc *inp;
1345 #endif
1346
1347 switch (cmd) {
1348 case WSDISPLAYIO_ADDSCREEN:
1349 #define d ((struct wsdisplay_addscreendata *)data)
1350 if (d->screentype) {
1351 error = copyinstr(d->screentype, typebuf,
1352 sizeof(typebuf), 0);
1353 if (error)
1354 return (error);
1355 type = typebuf;
1356 } else
1357 type = 0;
1358 if (d->emul) {
1359 error = copyinstr(d->emul, emulbuf, sizeof(emulbuf),0);
1360 if (error)
1361 return (error);
1362 emul = emulbuf;
1363 } else
1364 emul = 0;
1365
1366 if ((error = wsdisplay_addscreen(sc, d->idx, type, emul)) == 0)
1367 wsdisplay_addscreen_print(sc, d->idx, 0);
1368 return (error);
1369 #undef d
1370 case WSDISPLAYIO_DELSCREEN:
1371 #define d ((struct wsdisplay_delscreendata *)data)
1372 return (wsdisplay_delscreen(sc, d->idx, d->flags));
1373 #undef d
1374 case WSDISPLAYIO_LDFONT:
1375 #define d ((struct wsdisplay_font *)data)
1376 if (!sc->sc_accessops->load_font)
1377 return (EINVAL);
1378 if (d->name) {
1379 error = copyinstr(d->name, typebuf, sizeof(typebuf), 0);
1380 if (error)
1381 return (error);
1382 d->name = typebuf;
1383 } else
1384 d->name = "loaded"; /* ??? */
1385 fontsz = d->fontheight * d->stride * d->numchars;
1386 if (fontsz > WSDISPLAY_MAXFONTSZ)
1387 return (EINVAL);
1388
1389 tbuf = malloc(fontsz, M_DEVBUF, M_WAITOK);
1390 error = copyin(d->data, tbuf, fontsz);
1391 if (error) {
1392 free(tbuf, M_DEVBUF);
1393 return (error);
1394 }
1395 d->data = tbuf;
1396 error =
1397 (*sc->sc_accessops->load_font)(sc->sc_accesscookie, 0, d);
1398 free(tbuf, M_DEVBUF);
1399 #undef d
1400 return (error);
1401
1402 #if NWSKBD > 0
1403 #ifdef COMPAT_14
1404 case _O_WSDISPLAYIO_SETKEYBOARD:
1405 #define d ((struct wsdisplay_kbddata *)data)
1406 inp = sc->sc_input;
1407 if (inp == NULL)
1408 return (ENXIO);
1409 switch (d->op) {
1410 case _O_WSDISPLAY_KBD_ADD:
1411 if (d->idx == -1) {
1412 d->idx = wskbd_pickfree();
1413 if (d->idx == -1)
1414 return (ENXIO);
1415 }
1416 wsmuxdata.type = WSMUX_KBD;
1417 wsmuxdata.idx = d->idx;
1418 return (wsevsrc_ioctl(inp, WSMUX_ADD_DEVICE,
1419 &wsmuxdata, flag, l));
1420 case _O_WSDISPLAY_KBD_DEL:
1421 wsmuxdata.type = WSMUX_KBD;
1422 wsmuxdata.idx = d->idx;
1423 return (wsevsrc_ioctl(inp, WSMUX_REMOVE_DEVICE,
1424 &wsmuxdata, flag, l));
1425 default:
1426 return (EINVAL);
1427 }
1428 #undef d
1429 #endif
1430
1431 case WSMUXIO_ADD_DEVICE:
1432 #define d ((struct wsmux_device *)data)
1433 if (d->idx == -1 && d->type == WSMUX_KBD)
1434 d->idx = wskbd_pickfree();
1435 #undef d
1436 /* fall into */
1437 case WSMUXIO_INJECTEVENT:
1438 case WSMUXIO_REMOVE_DEVICE:
1439 case WSMUXIO_LIST_DEVICES:
1440 inp = sc->sc_input;
1441 if (inp == NULL)
1442 return (ENXIO);
1443 return (wsevsrc_ioctl(inp, cmd, data, flag, l));
1444 #endif /* NWSKBD > 0 */
1445
1446 }
1447 return (EPASSTHROUGH);
1448 }
1449
1450 int
1451 wsdisplay_stat_inject(device_t dv, u_int type, int value)
1452 {
1453 struct wsdisplay_softc *sc = device_private(dv);
1454 struct wseventvar *evar;
1455 struct wscons_event event;
1456
1457 evar = &sc->evar;
1458
1459 if (evar == NULL)
1460 return (0);
1461
1462 if (evar->q == NULL)
1463 return (1);
1464
1465 event.type = type;
1466 event.value = value;
1467 if (wsevent_inject(evar, &event, 1) != 0) {
1468 log(LOG_WARNING, "wsdisplay: event queue overflow\n");
1469 return (1);
1470 }
1471
1472 return (0);
1473 }
1474
1475 paddr_t
1476 wsdisplaymmap(dev_t dev, off_t offset, int prot)
1477 {
1478 struct wsdisplay_softc *sc;
1479 struct wsscreen *scr;
1480
1481 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(dev));
1482
1483 if (ISWSDISPLAYSTAT(dev))
1484 return (-1);
1485
1486 if (ISWSDISPLAYCTL(dev))
1487 return (-1);
1488
1489 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
1490 return (-1);
1491
1492 if (!(scr->scr_flags & SCR_GRAPHICS))
1493 return (-1);
1494
1495 /* pass mmap to display */
1496 return ((*sc->sc_accessops->mmap)(sc->sc_accesscookie,
1497 scr->scr_dconf->emulcookie, offset, prot));
1498 }
1499
1500 void
1501 wsdisplaystart(struct tty *tp)
1502 {
1503 struct wsdisplay_softc *sc;
1504 struct wsscreen *scr;
1505 int s, n;
1506 u_char *tbuf;
1507
1508 s = spltty();
1509 if (tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP)) {
1510 splx(s);
1511 return;
1512 }
1513 sc = device_lookup_private(&wsdisplay_cd, WSDISPLAYUNIT(tp->t_dev));
1514 if ((scr = sc->sc_scr[WSDISPLAYSCREEN(tp->t_dev)]) == NULL) {
1515 splx(s);
1516 return;
1517 }
1518
1519 if (scr->scr_hold_screen) {
1520 tp->t_state |= TS_TIMEOUT;
1521 splx(s);
1522 return;
1523 }
1524 tp->t_state |= TS_BUSY;
1525 splx(s);
1526
1527 /*
1528 * Drain output from ring buffer.
1529 * The output will normally be in one contiguous chunk, but when the
1530 * ring wraps, it will be in two pieces.. one at the end of the ring,
1531 * the other at the start. For performance, rather than loop here,
1532 * we output one chunk, see if there's another one, and if so, output
1533 * it too.
1534 */
1535
1536 n = ndqb(&tp->t_outq, 0);
1537 tbuf = tp->t_outq.c_cf;
1538
1539 if (!(scr->scr_flags & SCR_GRAPHICS)) {
1540 KASSERT(WSSCREEN_HAS_EMULATOR(scr));
1541 (*scr->scr_dconf->wsemul->output)(scr->scr_dconf->wsemulcookie,
1542 tbuf, n, 0);
1543 }
1544 ndflush(&tp->t_outq, n);
1545
1546 if ((n = ndqb(&tp->t_outq, 0)) > 0) {
1547 tbuf = tp->t_outq.c_cf;
1548
1549 if (!(scr->scr_flags & SCR_GRAPHICS)) {
1550 KASSERT(WSSCREEN_HAS_EMULATOR(scr));
1551 (*scr->scr_dconf->wsemul->output)
1552 (scr->scr_dconf->wsemulcookie, tbuf, n, 0);
1553 }
1554 ndflush(&tp->t_outq, n);
1555 }
1556
1557 s = spltty();
1558 tp->t_state &= ~TS_BUSY;
1559 /* Come back if there's more to do */
1560 if (ttypull(tp)) {
1561 tp->t_state |= TS_TIMEOUT;
1562 callout_schedule(&tp->t_rstrt_ch, (hz > 128) ? (hz / 128) : 1);
1563 }
1564 splx(s);
1565 }
1566
1567 void
1568 wsdisplaystop(struct tty *tp, int flag)
1569 {
1570 int s;
1571
1572 s = spltty();
1573 if (ISSET(tp->t_state, TS_BUSY))
1574 if (!ISSET(tp->t_state, TS_TTSTOP))
1575 SET(tp->t_state, TS_FLUSH);
1576 splx(s);
1577 }
1578
1579 /* Set line parameters. */
1580 int
1581 wsdisplayparam(struct tty *tp, struct termios *t)
1582 {
1583
1584 tp->t_ispeed = t->c_ispeed;
1585 tp->t_ospeed = t->c_ospeed;
1586 tp->t_cflag = t->c_cflag;
1587 return 0;
1588 }
1589
1590 /*
1591 * Callbacks for the emulation code.
1592 */
1593 void
1594 wsdisplay_emulbell(void *v)
1595 {
1596 struct wsscreen *scr = v;
1597
1598 if (scr == NULL) /* console, before real attach */
1599 return;
1600
1601 if (scr->scr_flags & SCR_GRAPHICS) /* can this happen? */
1602 return;
1603
1604 (void) wsdisplay_internal_ioctl(scr->sc, scr, WSKBDIO_BELL, NULL,
1605 FWRITE, NULL);
1606 }
1607
1608 void
1609 wsdisplay_emulinput(void *v, const u_char *data, u_int count)
1610 {
1611 struct wsscreen *scr = v;
1612 struct tty *tp;
1613
1614 if (v == NULL) /* console, before real attach */
1615 return;
1616
1617 if (scr->scr_flags & SCR_GRAPHICS) /* XXX can't happen */
1618 return;
1619 if (!WSSCREEN_HAS_TTY(scr))
1620 return;
1621
1622 tp = scr->scr_tty;
1623 while (count-- > 0)
1624 (*tp->t_linesw->l_rint)(*data++, tp);
1625 }
1626
1627 /*
1628 * Calls from the keyboard interface.
1629 */
1630 void
1631 wsdisplay_kbdinput(device_t dv, keysym_t ks)
1632 {
1633 struct wsdisplay_softc *sc = device_private(dv);
1634 struct wsscreen *scr;
1635 const char *dp;
1636 int count;
1637 struct tty *tp;
1638
1639 KASSERT(sc != NULL);
1640
1641 scr = sc->sc_focus;
1642
1643 if (!scr || !WSSCREEN_HAS_TTY(scr))
1644 return;
1645
1646 tp = scr->scr_tty;
1647
1648 if (KS_GROUP(ks) == KS_GROUP_Ascii)
1649 (*tp->t_linesw->l_rint)(KS_VALUE(ks), tp);
1650 else if (WSSCREEN_HAS_EMULATOR(scr)) {
1651 count = (*scr->scr_dconf->wsemul->translate)
1652 (scr->scr_dconf->wsemulcookie, ks, &dp);
1653 while (count-- > 0)
1654 (*tp->t_linesw->l_rint)(*dp++, tp);
1655 }
1656 }
1657
1658 #if defined(WSDISPLAY_COMPAT_RAWKBD)
1659 int
1660 wsdisplay_update_rawkbd(struct wsdisplay_softc *sc, struct wsscreen *scr)
1661 {
1662 #if NWSKBD > 0
1663 int s, raw, data, error;
1664 struct wsevsrc *inp;
1665
1666 s = spltty();
1667
1668 raw = (scr ? scr->scr_rawkbd : 0);
1669
1670 if (scr != sc->sc_focus ||
1671 sc->sc_rawkbd == raw) {
1672 splx(s);
1673 return (0);
1674 }
1675
1676 data = raw ? WSKBD_RAW : WSKBD_TRANSLATED;
1677 inp = sc->sc_input;
1678 if (inp == NULL) {
1679 splx(s);
1680 return (ENXIO);
1681 }
1682 error = wsevsrc_display_ioctl(inp, WSKBDIO_SETMODE, &data, 0, 0);
1683 if (!error)
1684 sc->sc_rawkbd = raw;
1685 splx(s);
1686 return (error);
1687 #else
1688 return (0);
1689 #endif
1690 }
1691 #endif
1692
1693 static void
1694 wsdisplay_switch3_cb(void *arg, int error, int waitok)
1695 {
1696 device_t dv = arg;
1697
1698 wsdisplay_switch3(dv, error, waitok);
1699 }
1700
1701 static int
1702 wsdisplay_switch3(device_t dv, int error, int waitok)
1703 {
1704 struct wsdisplay_softc *sc = device_private(dv);
1705 int no;
1706 struct wsscreen *scr;
1707
1708 if (!(sc->sc_flags & SC_SWITCHPENDING)) {
1709 aprint_error_dev(dv, "wsdisplay_switch3: not switching\n");
1710 return (EINVAL);
1711 }
1712
1713 no = sc->sc_screenwanted;
1714 if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
1715 panic("wsdisplay_switch3: invalid screen %d", no);
1716 scr = sc->sc_scr[no];
1717 if (!scr) {
1718 aprint_error_dev(dv,
1719 "wsdisplay_switch3: screen %d disappeared\n", no);
1720 error = ENXIO;
1721 }
1722
1723 if (error) {
1724 /* try to recover, avoid recursion */
1725
1726 if (sc->sc_oldscreen == WSDISPLAY_NULLSCREEN) {
1727 aprint_error_dev(dv, "wsdisplay_switch3: giving up\n");
1728 sc->sc_focus = 0;
1729 #ifdef WSDISPLAY_COMPAT_RAWKBD
1730 wsdisplay_update_rawkbd(sc, 0);
1731 #endif
1732 sc->sc_flags &= ~SC_SWITCHPENDING;
1733 return (error);
1734 }
1735
1736 sc->sc_screenwanted = sc->sc_oldscreen;
1737 sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
1738 return (wsdisplay_switch1(dv, 0, waitok));
1739 }
1740
1741 if (scr->scr_syncops && !error)
1742 sc->sc_flags |= SC_XATTACHED;
1743
1744 sc->sc_flags &= ~SC_SWITCHPENDING;
1745
1746 if (!error && (scr->scr_flags & SCR_WAITACTIVE))
1747 wakeup(scr);
1748 return (error);
1749 }
1750
1751 static void
1752 wsdisplay_switch2_cb(void *arg, int error, int waitok)
1753 {
1754 device_t dv = arg;
1755
1756 wsdisplay_switch2(dv, error, waitok);
1757 }
1758
1759 static int
1760 wsdisplay_switch2(device_t dv, int error, int waitok)
1761 {
1762 struct wsdisplay_softc *sc = device_private(dv);
1763 int no;
1764 struct wsscreen *scr;
1765
1766 if (!(sc->sc_flags & SC_SWITCHPENDING)) {
1767 aprint_error_dev(dv, "wsdisplay_switch2: not switching\n");
1768 return (EINVAL);
1769 }
1770
1771 no = sc->sc_screenwanted;
1772 if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
1773 panic("wsdisplay_switch2: invalid screen %d", no);
1774 scr = sc->sc_scr[no];
1775 if (!scr) {
1776 aprint_error_dev(dv,
1777 "wsdisplay_switch2: screen %d disappeared\n", no);
1778 error = ENXIO;
1779 }
1780
1781 if (error) {
1782 /* try to recover, avoid recursion */
1783
1784 if (sc->sc_oldscreen == WSDISPLAY_NULLSCREEN) {
1785 aprint_error_dev(dv, "wsdisplay_switch2: giving up\n");
1786 sc->sc_focus = 0;
1787 sc->sc_flags &= ~SC_SWITCHPENDING;
1788 return (error);
1789 }
1790
1791 sc->sc_screenwanted = sc->sc_oldscreen;
1792 sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
1793 return (wsdisplay_switch1(dv, 0, waitok));
1794 }
1795
1796 sc->sc_focusidx = no;
1797 sc->sc_focus = scr;
1798
1799 #ifdef WSDISPLAY_COMPAT_RAWKBD
1800 (void) wsdisplay_update_rawkbd(sc, scr);
1801 #endif
1802 /* keyboard map??? */
1803
1804 if (scr->scr_syncops &&
1805 !(sc->sc_isconsole && wsdisplay_cons_pollmode)) {
1806 error = (*scr->scr_syncops->attach)(scr->scr_synccookie, waitok,
1807 wsdisplay_switch3_cb, dv);
1808 if (error == EAGAIN) {
1809 /* switch will be done asynchronously */
1810 return (0);
1811 }
1812 }
1813
1814 return (wsdisplay_switch3(dv, error, waitok));
1815 }
1816
1817 static void
1818 wsdisplay_switch1_cb(void *arg, int error, int waitok)
1819 {
1820 device_t dv = arg;
1821
1822 wsdisplay_switch1(dv, error, waitok);
1823 }
1824
1825 static int
1826 wsdisplay_switch1(device_t dv, int error, int waitok)
1827 {
1828 struct wsdisplay_softc *sc = device_private(dv);
1829 int no;
1830 struct wsscreen *scr;
1831
1832 if (!(sc->sc_flags & SC_SWITCHPENDING)) {
1833 aprint_error_dev(dv, "wsdisplay_switch1: not switching\n");
1834 return (EINVAL);
1835 }
1836
1837 no = sc->sc_screenwanted;
1838 if (no == WSDISPLAY_NULLSCREEN) {
1839 sc->sc_flags &= ~SC_SWITCHPENDING;
1840 if (!error) {
1841 sc->sc_flags &= ~SC_XATTACHED;
1842 sc->sc_focus = 0;
1843 }
1844 wakeup(sc);
1845 return (error);
1846 }
1847 if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
1848 panic("wsdisplay_switch1: invalid screen %d", no);
1849 scr = sc->sc_scr[no];
1850 if (!scr) {
1851 aprint_error_dev(dv, "wsdisplay_switch1: screen %d disappeared\n", no);
1852 error = ENXIO;
1853 }
1854
1855 if (error) {
1856 sc->sc_flags &= ~SC_SWITCHPENDING;
1857 return (error);
1858 }
1859
1860 sc->sc_flags &= ~SC_XATTACHED;
1861
1862 error = (*sc->sc_accessops->show_screen)(sc->sc_accesscookie,
1863 scr->scr_dconf->emulcookie,
1864 waitok,
1865 sc->sc_isconsole && wsdisplay_cons_pollmode ? 0 : wsdisplay_switch2_cb, dv);
1866 if (error == EAGAIN) {
1867 /* switch will be done asynchronously */
1868 return (0);
1869 }
1870
1871 return (wsdisplay_switch2(dv, error, waitok));
1872 }
1873
1874 int
1875 wsdisplay_switch(device_t dv, int no, int waitok)
1876 {
1877 struct wsdisplay_softc *sc = device_private(dv);
1878 int s, res = 0;
1879 struct wsscreen *scr;
1880
1881 if (no != WSDISPLAY_NULLSCREEN) {
1882 if ((no < 0 || no >= WSDISPLAY_MAXSCREEN))
1883 return (EINVAL);
1884 if (sc->sc_scr[no] == NULL)
1885 return (ENXIO);
1886 }
1887
1888 wsdisplay_stat_inject(dv, WSCONS_EVENT_SCREEN_SWITCH, no);
1889
1890 s = spltty();
1891
1892 if ((sc->sc_focus && no == sc->sc_focusidx) ||
1893 (sc->sc_focus == NULL && no == WSDISPLAY_NULLSCREEN)) {
1894 splx(s);
1895 return (0);
1896 }
1897
1898 if (sc->sc_flags & SC_SWITCHPENDING) {
1899 splx(s);
1900 return (EBUSY);
1901 }
1902
1903 sc->sc_flags |= SC_SWITCHPENDING;
1904 sc->sc_screenwanted = no;
1905
1906 splx(s);
1907
1908 scr = sc->sc_focus;
1909 if (!scr) {
1910 sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
1911 return (wsdisplay_switch1(dv, 0, waitok));
1912 } else
1913 sc->sc_oldscreen = sc->sc_focusidx;
1914
1915 if (scr->scr_syncops) {
1916 if (!(sc->sc_flags & SC_XATTACHED) ||
1917 (sc->sc_isconsole && wsdisplay_cons_pollmode)) {
1918 /* nothing to do here */
1919 return (wsdisplay_switch1(dv, 0, waitok));
1920 }
1921 res = (*scr->scr_syncops->detach)(scr->scr_synccookie, waitok,
1922 wsdisplay_switch1_cb, dv);
1923 if (res == EAGAIN) {
1924 /* switch will be done asynchronously */
1925 return (0);
1926 }
1927 } else if (scr->scr_flags & SCR_GRAPHICS) {
1928 /* no way to save state */
1929 res = EBUSY;
1930 }
1931
1932 return (wsdisplay_switch1(dv, res, waitok));
1933 }
1934
1935 void
1936 wsdisplay_reset(device_t dv, enum wsdisplay_resetops op)
1937 {
1938 struct wsdisplay_softc *sc = device_private(dv);
1939 struct wsscreen *scr;
1940
1941 KASSERT(sc != NULL);
1942 scr = sc->sc_focus;
1943
1944 if (!scr)
1945 return;
1946
1947 switch (op) {
1948 case WSDISPLAY_RESETEMUL:
1949 if (!WSSCREEN_HAS_EMULATOR(scr))
1950 break;
1951 (*scr->scr_dconf->wsemul->reset)(scr->scr_dconf->wsemulcookie,
1952 WSEMUL_RESET);
1953 break;
1954 case WSDISPLAY_RESETCLOSE:
1955 wsdisplay_closescreen(sc, scr);
1956 break;
1957 }
1958 }
1959
1960 /*
1961 * Interface for (external) VT switch / process synchronization code
1962 */
1963 int
1964 wsscreen_attach_sync(struct wsscreen *scr, const struct wscons_syncops *ops,
1965 void *cookie)
1966 {
1967 if (scr->scr_syncops) {
1968 /*
1969 * The screen is already claimed.
1970 * Check if the owner is still alive.
1971 */
1972 if ((*scr->scr_syncops->check)(scr->scr_synccookie))
1973 return (EBUSY);
1974 }
1975 scr->scr_syncops = ops;
1976 scr->scr_synccookie = cookie;
1977 if (scr == scr->sc->sc_focus)
1978 scr->sc->sc_flags |= SC_XATTACHED;
1979 return (0);
1980 }
1981
1982 int
1983 wsscreen_detach_sync(struct wsscreen *scr)
1984 {
1985 if (!scr->scr_syncops)
1986 return (EINVAL);
1987 scr->scr_syncops = 0;
1988 if (scr == scr->sc->sc_focus)
1989 scr->sc->sc_flags &= ~SC_XATTACHED;
1990 return (0);
1991 }
1992
1993 int
1994 wsscreen_lookup_sync(struct wsscreen *scr,
1995 const struct wscons_syncops *ops, /* used as ID */
1996 void **cookiep)
1997 {
1998 if (!scr->scr_syncops || ops != scr->scr_syncops)
1999 return (EINVAL);
2000 *cookiep = scr->scr_synccookie;
2001 return (0);
2002 }
2003
2004 /*
2005 * Interface to virtual screen stuff
2006 */
2007 int
2008 wsdisplay_maxscreenidx(struct wsdisplay_softc *sc)
2009 {
2010 return (WSDISPLAY_MAXSCREEN - 1);
2011 }
2012
2013 int
2014 wsdisplay_screenstate(struct wsdisplay_softc *sc, int idx)
2015 {
2016 if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
2017 return (EINVAL);
2018 if (!sc->sc_scr[idx])
2019 return (ENXIO);
2020 return ((sc->sc_scr[idx]->scr_flags & SCR_OPEN) ? EBUSY : 0);
2021 }
2022
2023 int
2024 wsdisplay_getactivescreen(struct wsdisplay_softc *sc)
2025 {
2026 return (sc->sc_focus ? sc->sc_focusidx : WSDISPLAY_NULLSCREEN);
2027 }
2028
2029 int
2030 wsscreen_switchwait(struct wsdisplay_softc *sc, int no)
2031 {
2032 struct wsscreen *scr;
2033 int s, res = 0;
2034
2035 if (no == WSDISPLAY_NULLSCREEN) {
2036 s = spltty();
2037 while (sc->sc_focus && res == 0) {
2038 res = tsleep(sc, PCATCH, "wswait", 0);
2039 }
2040 splx(s);
2041 return (res);
2042 }
2043
2044 if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
2045 return (ENXIO);
2046 scr = sc->sc_scr[no];
2047 if (!scr)
2048 return (ENXIO);
2049
2050 s = spltty();
2051 if (scr != sc->sc_focus) {
2052 scr->scr_flags |= SCR_WAITACTIVE;
2053 res = tsleep(scr, PCATCH, "wswait", 0);
2054 if (scr != sc->sc_scr[no])
2055 res = ENXIO; /* disappeared in the meantime */
2056 else
2057 scr->scr_flags &= ~SCR_WAITACTIVE;
2058 }
2059 splx(s);
2060 return (res);
2061 }
2062
2063 void
2064 wsdisplay_kbdholdscreen(device_t dv, int hold)
2065 {
2066 struct wsdisplay_softc *sc = device_private(dv);
2067 struct wsscreen *scr;
2068
2069 scr = sc->sc_focus;
2070
2071 if (!scr)
2072 return;
2073
2074 if (hold)
2075 scr->scr_hold_screen = 1;
2076 else {
2077 scr->scr_hold_screen = 0;
2078 callout_schedule(&scr->scr_tty->t_rstrt_ch, 0);
2079 }
2080 }
2081
2082 #if NWSKBD > 0
2083 void
2084 wsdisplay_set_console_kbd(struct wsevsrc *src)
2085 {
2086 if (wsdisplay_console_device == NULL) {
2087 src->me_dispdv = NULL;
2088 return;
2089 }
2090 #if NWSMUX > 0
2091 if (wsmux_attach_sc((struct wsmux_softc *)
2092 wsdisplay_console_device->sc_input, src)) {
2093 src->me_dispdv = NULL;
2094 return;
2095 }
2096 #else
2097 wsdisplay_console_device->sc_input = src;
2098 #endif
2099 src->me_dispdv = wsdisplay_console_device->sc_dev;
2100 }
2101 #endif /* NWSKBD > 0 */
2102
2103 /*
2104 * Console interface.
2105 */
2106 void
2107 wsdisplay_cnputc(dev_t dev, int i)
2108 {
2109 struct wsscreen_internal *dc;
2110 u_char c = i;
2111
2112 if (!wsdisplay_console_initted)
2113 return;
2114
2115 if ((wsdisplay_console_device != NULL) &&
2116 (wsdisplay_console_device->sc_scr[0] != NULL) &&
2117 (wsdisplay_console_device->sc_scr[0]->scr_flags & SCR_GRAPHICS))
2118 return;
2119
2120 dc = &wsdisplay_console_conf;
2121 (*dc->wsemul->output)(dc->wsemulcookie, &c, 1, 1);
2122 }
2123
2124 static int
2125 wsdisplay_getc_dummy(dev_t dev)
2126 {
2127 /* panic? */
2128 return (0);
2129 }
2130
2131 static void
2132 wsdisplay_pollc(dev_t dev, int on)
2133 {
2134
2135 wsdisplay_cons_pollmode = on;
2136
2137 /* notify to fb drivers */
2138 if (wsdisplay_console_device != NULL &&
2139 wsdisplay_console_device->sc_accessops->pollc != NULL)
2140 (*wsdisplay_console_device->sc_accessops->pollc)
2141 (wsdisplay_console_device->sc_accesscookie, on);
2142
2143 /* notify to kbd drivers */
2144 if (wsdisplay_cons_kbd_pollc)
2145 (*wsdisplay_cons_kbd_pollc)(NODEV, on);
2146 }
2147
2148 void
2149 wsdisplay_set_cons_kbd(int (*get)(dev_t), void (*poll)(dev_t, int),
2150 void (*bell)(dev_t, u_int, u_int, u_int))
2151 {
2152 wsdisplay_cons.cn_getc = get;
2153 wsdisplay_cons.cn_bell = bell;
2154 wsdisplay_cons_kbd_pollc = poll;
2155 }
2156
2157 void
2158 wsdisplay_unset_cons_kbd(void)
2159 {
2160 wsdisplay_cons.cn_getc = wsdisplay_getc_dummy;
2161 wsdisplay_cons.cn_bell = NULL;
2162 wsdisplay_cons_kbd_pollc = 0;
2163 }
2164