?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
syscons - Add option for the default terminal border color to kernel config.
[dragonfly.git] / sys / dev / misc / syscons / syscons.c
blob236e824c2d821faaf3776be3b020511c29819ecc
1 /*-
2 * Copyright (c) 1992-1998 Søren Schmidt
3 * All rights reserved.
4 *
5 * This code is derived from software contributed to The DragonFly Project
6 * by Sascha Wildner <saw@online.de>
7 *
8 * Simple font scaling code by Sascha Wildner and Matthew Dillon
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer,
15 * without modification, immediately at the beginning of the file.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. 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 * $FreeBSD: /usr/local/www/cvsroot/FreeBSD/src/sys/dev/syscons/syscons.c,v 1.336.2.17 2004/03/25 08:41:09 ru Exp $
34 */
35
36 #include "use_splash.h"
37 #include "opt_syscons.h"
38 #include "opt_ddb.h"
39
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/eventhandler.h>
43 #include <sys/reboot.h>
44 #include <sys/conf.h>
45 #include <sys/proc.h>
46 #include <sys/priv.h>
47 #include <sys/signalvar.h>
48 #include <sys/sysctl.h>
49 #include <sys/taskqueue.h>
50 #include <sys/tty.h>
51 #include <sys/kernel.h>
52 #include <sys/cons.h>
53 #include <sys/random.h>
54 #include <ddb/ddb.h>
55
56 #include <sys/thread2.h>
57 #include <sys/mutex2.h>
58
59 #include <machine/clock.h>
60 #include <machine/console.h>
61 #include <machine/psl.h>
62 #include <machine/pc/display.h>
63 #include <machine/frame.h>
64 #include <machine/framebuffer.h>
65
66 #include <dev/misc/kbd/kbdreg.h>
67 #include <dev/video/fb/fbreg.h>
68 #include <dev/video/fb/splashreg.h>
69 #include "syscons.h"
70
71 #define COLD 0
72 #define WARM 1
73
74 #define DEFAULT_BLANKTIME (5*60) /* 5 minutes */
75 #define MAX_BLANKTIME (7*24*60*60) /* 7 days!? */
76
77 #define SCRN_ASYNCOK 0x0001
78 #define SCRN_BULKUNLOCK 0x0002
79
80 #define KEYCODE_BS 0x0e /* "<-- Backspace" key, XXX */
81 #define WANT_UNLOCK(m) do { \
82 if (m) \
83 syscons_unlock(); \
84 } while (0)
85
86 #define WANT_LOCK(m) do { \
87 if (m) \
88 syscons_lock(); \
89 } while(0)
90
91
92 MALLOC_DEFINE(M_SYSCONS, "syscons", "Syscons");
93
94 typedef struct default_attr {
95 int std_color; /* normal hardware color */
96 int rev_color; /* reverse hardware color */
97 } default_attr;
98
99 static default_attr user_default = {
100 SC_NORM_ATTR,
101 SC_NORM_REV_ATTR,
102 };
103
104 static default_attr kernel_default = {
105 SC_KERNEL_CONS_ATTR,
106 SC_KERNEL_CONS_REV_ATTR,
107 };
108
109 static int sc_console_unit = -1;
110 static scr_stat *sc_console;
111 static struct tty *sc_console_tty;
112 static void *kernel_console_ts;
113
114 static char init_done = COLD;
115 static char shutdown_in_progress = FALSE;
116 static char sc_malloc = FALSE;
117 static char sc_filled_border = FALSE; /* filled initial VT border */
118
119 static int saver_mode = CONS_NO_SAVER; /* LKM/user saver */
120 static int run_scrn_saver = FALSE; /* should run the saver? */
121 static long scrn_blank_time = 0; /* screen saver timeout value */
122 #if NSPLASH > 0
123 static int scrn_blanked; /* # of blanked screen */
124 static int sticky_splash = FALSE;
125
126 static void none_saver(sc_softc_t *sc, int blank) { }
127 static void (*current_saver)(sc_softc_t *, int) = none_saver;
128 #endif
129
130 /*
131 * Lock for asynchronous screen update thread, needed to safely modify the
132 * framebuffer information.
133 */
134 static struct lock sc_asynctd_lk;
135
136 #if !defined(SC_NO_FONT_LOADING) && defined(SC_DFLT_FONT)
137 #include "font.h"
138 #endif
139
140 static bios_values_t bios_value;
141
142 static int enable_panic_key;
143 SYSCTL_INT(_machdep, OID_AUTO, enable_panic_key, CTLFLAG_RW, &enable_panic_key,
144 0, "Enable the panic key (CTRL-ALT-SHIFT-ESC)");
145 static int syscons_async;
146 SYSCTL_INT(_kern, OID_AUTO, syscons_async, CTLFLAG_RW, &syscons_async,
147 0, "Asynchronous bulk syscons fb updates");
148
149 static int desired_cols = 0;
150 TUNABLE_INT("kern.kms_columns", &desired_cols);
151
152 #define SC_CONSOLECTL 255
153
154 #define VIRTUAL_TTY(sc, x) ((SC_DEV((sc),(x)) != NULL) ? \
155 (SC_DEV((sc),(x))->si_tty) : NULL)
156 #define ISTTYOPEN(tp) ((tp) && ((tp)->t_state & TS_ISOPEN))
157
158 static int debugger;
159 static cdev_t cctl_dev;
160 #if 0
161 static timeout_t blink_screen_callout;
162 #endif
163 static void sc_blink_screen(scr_stat *scp);
164 static struct mtx syscons_mtx = MTX_INITIALIZER("syscons");
165
166 /* prototypes */
167 static int scvidprobe(int unit, int flags, int cons);
168 static int sckbdprobe(int unit, int flags, int cons);
169 static void scmeminit(void *arg);
170 static int scdevtounit(cdev_t dev);
171 static kbd_callback_func_t sckbdevent;
172 static int scparam(struct tty *tp, struct termios *t);
173 static void scstart(struct tty *tp);
174 static void scinit(int unit, int flags);
175 static void scterm(int unit, int flags);
176 static void scshutdown(void *arg, int howto);
177 static void sc_puts(scr_stat *scp, u_char *buf, int len);
178 static u_int scgetc(sc_softc_t *sc, u_int flags);
179 #define SCGETC_CN 1
180 #define SCGETC_NONBLOCK 2
181 static int sccngetch(int flags);
182 static void sccnupdate(scr_stat *scp);
183 static scr_stat *alloc_scp(sc_softc_t *sc, int vty);
184 static void init_scp(sc_softc_t *sc, int vty, scr_stat *scp);
185 static timeout_t scrn_timer;
186 static int and_region(int *s1, int *e1, int s2, int e2);
187 static void scrn_update(scr_stat *scp, int show_cursor, int flags);
188 static void scrn_update_thread(void *arg);
189
190 static void sc_fb_set_par(void *context, int pending);
191
192 #if NSPLASH > 0
193 static int scsplash_callback(int event, void *arg);
194 static void scsplash_saver(sc_softc_t *sc, int show);
195 static int add_scrn_saver(void (*this_saver)(sc_softc_t *, int));
196 static int remove_scrn_saver(void (*this_saver)(sc_softc_t *, int));
197 static int set_scrn_saver_mode(scr_stat *scp, int mode, u_char *pal, int border);
198 static int restore_scrn_saver_mode(scr_stat *scp, int changemode);
199 static void stop_scrn_saver(sc_softc_t *sc, void (*saver)(sc_softc_t *, int));
200 static int wait_scrn_saver_stop(sc_softc_t *sc);
201 #define scsplash_stick(stick) (sticky_splash = (stick))
202 #else /* !NSPLASH */
203 #define scsplash_stick(stick)
204 #endif /* NSPLASH */
205
206 static void do_switch_scr(sc_softc_t *sc);
207 static int vt_proc_alive(scr_stat *scp);
208 static int signal_vt_rel(scr_stat *scp);
209 static int signal_vt_acq(scr_stat *scp);
210 static int finish_vt_rel(scr_stat *scp, int release);
211 static int finish_vt_acq(scr_stat *scp);
212 static void exchange_scr(sc_softc_t *sc);
213 static void update_cursor_image(scr_stat *scp);
214 static int save_kbd_state(scr_stat *scp, int unlock);
215 static int update_kbd_state(scr_stat *scp, int state, int mask, int unlock);
216 static int update_kbd_leds(scr_stat *scp, int which);
217 static int sc_allocate_keyboard(sc_softc_t *sc, int unit);
218
219 /*
220 * Console locking support functions.
221 *
222 * We use mutex spinlocks here in order to allow reentrancy which should
223 * avoid issues during panics.
224 *
225 * A panic can stop a cpu while it is holding the syscons_mtx. If this
226 * occurs we try for up to 1/2 a second and then blow the spinlock away.
227 * The asynchronous update thread makes this happen more often.
228 */
229 static void
230 syscons_lock(void)
231 {
232 if (panicstr || shutdown_in_progress) {
233 int retries = 500000;
234 while (mtx_spinlock_try(&syscons_mtx)) {
235 tsc_delay(1000); /* 1uS */
236 if (--retries == 0) {
237 mtx_init(&syscons_mtx, "syscons");
238 retries = 500000;
239 }
240 }
241 } else {
242 mtx_spinlock(&syscons_mtx);
243 }
244 }
245
246 /*
247 * Returns 0 on success, EAGAIN on failure.
248 */
249 static int
250 syscons_lock_nonblock(void)
251 {
252 return(mtx_spinlock_try(&syscons_mtx));
253 }
254
255 static void
256 syscons_unlock(void)
257 {
258 mtx_spinunlock(&syscons_mtx);
259 }
260
261 /*
262 * Console driver
263 */
264 static cn_probe_t sccnprobe;
265 static cn_init_t sccninit;
266 static cn_init_t sccninit_fini;
267 static cn_getc_t sccngetc;
268 static cn_checkc_t sccncheckc;
269 static cn_putc_t sccnputc;
270 static cn_dbctl_t sccndbctl;
271 static cn_term_t sccnterm;
272 static cn_poll_t sccnpoll;
273
274 CONS_DRIVER(sc, sccnprobe, sccninit, sccninit_fini, sccnterm,
275 sccngetc, sccncheckc, sccnputc, sccndbctl, sccnpoll);
276
277 static d_open_t scopen;
278 static d_close_t scclose;
279 static d_read_t scread;
280 static d_ioctl_t scioctl;
281 static d_mmap_t scmmap;
282
283 static struct dev_ops sc_ops = {
284 { "sc", 0, D_TTY },
285 .d_open = scopen,
286 .d_close = scclose,
287 .d_read = scread,
288 .d_write = ttywrite,
289 .d_ioctl = scioctl,
290 .d_mmap = scmmap,
291 .d_kqfilter = ttykqfilter,
292 .d_revoke = ttyrevoke
293 };
294
295 int
296 sc_probe_unit(int unit, int flags)
297 {
298 if ((flags & SC_EFI_FB) && (probe_efi_fb(0) != 0)) {
299 if (bootverbose)
300 kprintf("sc%d: no EFI framebuffer found.\n", unit);
301 flags &= ~SC_EFI_FB;
302 }
303
304 if (!(flags & SC_EFI_FB) && !scvidprobe(unit, flags, FALSE)) {
305 if (bootverbose)
306 kprintf("sc%d: no video adapter found.\n", unit);
307 return ENXIO;
308 }
309
310 /* syscons will be attached even when there is no keyboard */
311 sckbdprobe(unit, flags, FALSE);
312
313 return 0;
314 }
315
316 int
317 register_framebuffer(struct fb_info *info)
318 {
319 sc_softc_t *sc;
320
321 /* For now ignore framebuffers, which don't replace the vga display */
322 if (!info->is_vga_boot_display)
323 return 0;
324
325 lwkt_gettoken(&tty_token);
326 sc = sc_get_softc(0, (sc_console_unit == 0) ? SC_KERNEL_CONSOLE : 0);
327 if (sc == NULL) {
328 lwkt_reltoken(&tty_token);
329 kprintf("%s: sc_get_softc(%d, %d) returned NULL\n", __func__,
330 0, (sc_console_unit == 0) ? SC_KERNEL_CONSOLE : 0);
331 return 0;
332 }
333
334 /* Ignore this framebuffer if we already switched to KMS framebuffer */
335 if (sc->fbi != NULL && sc->fbi != &efi_fb_info &&
336 sc->fbi != sc->dummy_fb_info) {
337 lwkt_reltoken(&tty_token);
338 return 0;
339 }
340
341 if (sc->fb_set_par_task == NULL) {
342 sc->fb_set_par_task = kmalloc(sizeof(struct task),
343 M_SYSCONS, M_WAITOK | M_ZERO);
344 }
345 TASK_INIT(sc->fb_set_par_task, 0, sc_fb_set_par, sc);
346
347 /*
348 * Make sure that console messages don't interfere too much with
349 * modesetting.
350 */
351 atomic_add_int(&sc->videoio_in_progress, 1);
352
353 /* Lock against synchronous and asynchronous screen updates */
354 lockmgr(&sc_asynctd_lk, LK_EXCLUSIVE);
355 syscons_lock();
356 sc->fbi = info;
357 sc->fbi_generation++;
358 syscons_unlock();
359
360 kprintf("kms console: xpixels %d ypixels %d\n",
361 sc->fbi->width, sc->fbi->height);
362 sc_update_render(sc->cur_scp);
363 if (info->fbops.fb_set_par != NULL)
364 info->fbops.fb_set_par(info);
365 atomic_add_int(&sc->videoio_in_progress, -1);
366
367 lockmgr(&sc_asynctd_lk, LK_RELEASE);
368 lwkt_reltoken(&tty_token);
369 return 0;
370 }
371
372 void
373 unregister_framebuffer(struct fb_info *info)
374 {
375 sc_softc_t *sc;
376
377 lwkt_gettoken(&tty_token);
378 sc = sc_get_softc(0, (sc_console_unit == 0) ? SC_KERNEL_CONSOLE : 0);
379 if (sc == NULL) {
380 lwkt_reltoken(&tty_token);
381 kprintf("%s: sc_get_softc(%d, %d) returned NULL\n", __func__,
382 0, (sc_console_unit == 0) ? SC_KERNEL_CONSOLE : 0);
383 return;
384 }
385
386 if (sc->fbi != info) {
387 lwkt_reltoken(&tty_token);
388 return;
389 }
390
391 if (sc->fb_set_par_task != NULL &&
392 taskqueue_cancel(taskqueue_thread[0], sc->fb_set_par_task, NULL)) {
393 taskqueue_drain(taskqueue_thread[0], sc->fb_set_par_task);
394 }
395
396 if (sc->dummy_fb_info == NULL) {
397 sc->dummy_fb_info = kmalloc(sizeof(struct fb_info),
398 M_SYSCONS, M_WAITOK | M_ZERO);
399 } else {
400 memset(sc->dummy_fb_info, 0, sizeof(struct fb_info));
401 }
402 *sc->dummy_fb_info = *sc->fbi;
403 sc->dummy_fb_info->vaddr = 0;
404 sc->dummy_fb_info->fbops.fb_set_par = NULL;
405 sc->dummy_fb_info->fbops.fb_blank = NULL;
406 sc->dummy_fb_info->fbops.fb_debug_enter = NULL;
407
408 /* Lock against synchronous and asynchronous screen updates */
409 lockmgr(&sc_asynctd_lk, LK_EXCLUSIVE);
410 syscons_lock();
411 sc->fbi = sc->dummy_fb_info;
412 syscons_unlock();
413 lockmgr(&sc_asynctd_lk, LK_RELEASE);
414
415 lwkt_reltoken(&tty_token);
416 }
417
418 void
419 sc_font_scale(scr_stat *scp, int max_cols, int max_rows)
420 {
421 int cols, rows;
422
423 /*
424 * If columns not specified in /boot/loader.conf then
425 * calculate a non-fractional scaling that yields a
426 * reasonable number of rows and columns. If it is <0,
427 * don't scale at all.
428 */
429 if (desired_cols == 0) {
430 int nomag = 1;
431 while (scp->xpixel / (scp->font_width * nomag) >= 80 &&
432 scp->ypixel / (scp->font_height * nomag) >= 25) {
433 ++nomag;
434 }
435 if (nomag > 1)
436 --nomag;
437 cols = scp->xpixel / (scp->font_width * nomag);
438 } else if (desired_cols < 0) {
439 cols = scp->xpixel / scp->font_width;
440 } else {
441 cols = desired_cols;
442 }
443 scp->blk_width = scp->xpixel / cols;
444 scp->blk_height = scp->blk_width * scp->font_height / scp->font_width;
445 rows = scp->ypixel / scp->blk_height;
446
447 /* scp->xsize = scp->xpixel / scp->blk_width; total possible */
448 scp->xsize = max_cols ? imin(max_cols, cols) : cols;
449 scp->ysize = max_rows ? imin(max_rows, rows) : rows;
450 }
451
452 /* probe video adapters, return TRUE if found */
453 static int
454 scvidprobe(int unit, int flags, int cons)
455 {
456 /*
457 * Access the video adapter driver through the back door!
458 * Video adapter drivers need to be configured before syscons.
459 * However, when syscons is being probed as the low-level console,
460 * they have not been initialized yet. We force them to initialize
461 * themselves here. XXX
462 */
463 vid_configure(cons ? VIO_PROBE_ONLY : 0);
464
465 return (vid_find_adapter("*", unit) >= 0);
466 }
467
468 /* probe the keyboard, return TRUE if found */
469 static int
470 sckbdprobe(int unit, int flags, int cons)
471 {
472 /* access the keyboard driver through the backdoor! */
473 kbd_configure(cons ? KB_CONF_PROBE_ONLY : 0);
474
475 return (kbd_find_keyboard("*", unit) >= 0);
476 }
477
478 static char *
479 adapter_name(video_adapter_t *adp)
480 {
481 static struct {
482 int type;
483 char *name[2];
484 } names[] = {
485 { KD_MONO, { "MDA", "MDA" } },
486 { KD_HERCULES, { "Hercules", "Hercules" } },
487 { KD_CGA, { "CGA", "CGA" } },
488 { KD_EGA, { "EGA", "EGA (mono)" } },
489 { KD_VGA, { "VGA", "VGA (mono)" } },
490 { KD_TGA, { "TGA", "TGA" } },
491 { -1, { "Unknown", "Unknown" } },
492 };
493 int i;
494
495 for (i = 0; names[i].type != -1; ++i)
496 if (names[i].type == adp->va_type)
497 break;
498 return names[i].name[(adp->va_flags & V_ADP_COLOR) ? 0 : 1];
499 }
500
501 int
502 sc_attach_unit(int unit, int flags)
503 {
504 sc_softc_t *sc;
505 scr_stat *scp;
506 int vc;
507 cdev_t dev;
508 flags &= ~SC_KERNEL_CONSOLE;
509
510 if ((flags & SC_EFI_FB) && probe_efi_fb(0) != 0)
511 flags &= ~SC_EFI_FB;
512
513 if (sc_console_unit == unit) {
514 /*
515 * If this unit is being used as the system console, we need to
516 * adjust some variables and buffers before and after scinit().
517 */
518 /* assert(sc_console != NULL) */
519 flags |= SC_KERNEL_CONSOLE;
520 scmeminit(NULL);
521
522 scinit(unit, flags);
523
524 if (sc_console->tsw->te_size > 0) {
525 /* assert(sc_console->ts != NULL); */
526 kernel_console_ts = sc_console->ts;
527 sc_console->ts = kmalloc(sc_console->tsw->te_size,
528 M_SYSCONS, M_WAITOK);
529 bcopy(kernel_console_ts, sc_console->ts, sc_console->tsw->te_size);
530 (*sc_console->tsw->te_default_attr)(sc_console,
531 user_default.std_color,
532 user_default.rev_color);
533 }
534 } else {
535 scinit(unit, flags);
536 }
537
538 sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
539
540 /*
541 * If this is the console we couldn't setup sc->dev before because
542 * malloc wasn't working. Set it up now.
543 */
544 if (flags & SC_KERNEL_CONSOLE) {
545 KKASSERT(sc->dev == NULL);
546 sc->dev = kmalloc(sizeof(cdev_t)*sc->vtys, M_SYSCONS, M_WAITOK|M_ZERO);
547 sc->dev[0] = make_dev(&sc_ops, sc_console_unit*MAXCONS, UID_ROOT,
548 GID_WHEEL, 0600,
549 "ttyv%r", sc_console_unit*MAXCONS);
550 sc->dev[0]->si_tty = ttymalloc(sc->dev[0]->si_tty);
551 sc->dev[0]->si_drv1 = sc_console;
552 }
553
554 /*
555 * Finish up the standard attach
556 */
557 sc->config = flags;
558 callout_init_mp(&sc->scrn_timer_ch);
559 scp = SC_STAT(sc->dev[0]);
560 if (sc_console == NULL) /* sc_console_unit < 0 */
561 sc_console = scp;
562
563 /* initialize cursor */
564 if (!ISGRAPHSC(scp))
565 update_cursor_image(scp);
566
567 /* get screen update going */
568 scrn_timer(sc);
569
570 /* set up the keyboard */
571 kbd_ioctl(sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
572 update_kbd_state(scp, scp->status, LOCK_MASK, FALSE);
573
574 kprintf("sc%d: %s <%d virtual consoles, flags=0x%x>\n",
575 unit, (sc->config & SC_EFI_FB) ? "EFI_FB" : adapter_name(sc->adp),
576 sc->vtys, sc->config);
577 if (bootverbose) {
578 kprintf("sc%d:", unit);
579 if (sc->adapter >= 0)
580 kprintf(" fb%d", sc->adapter);
581 if (sc->keyboard >= 0)
582 kprintf(", kbd%d", sc->keyboard);
583 if (scp->tsw)
584 kprintf(", terminal emulator: %s (%s)",
585 scp->tsw->te_name, scp->tsw->te_desc);
586 kprintf("\n");
587 }
588
589 /* register a shutdown callback for the kernel console */
590 if (sc_console_unit == unit)
591 EVENTHANDLER_REGISTER(shutdown_pre_sync, scshutdown,
592 (void *)(uintptr_t)unit, SHUTDOWN_PRI_DEFAULT);
593
594 /*
595 * create devices.
596 *
597 * The first vty already has struct tty and scr_stat initialized
598 * in scinit(). The other vtys will have these structs when
599 * first opened.
600 */
601 for (vc = 1; vc < sc->vtys; vc++) {
602 dev = make_dev(&sc_ops, vc + unit * MAXCONS,
603 UID_ROOT, GID_WHEEL,
604 0600, "ttyv%r", vc + unit * MAXCONS);
605 sc->dev[vc] = dev;
606 }
607 cctl_dev = make_dev(&sc_ops, SC_CONSOLECTL,
608 UID_ROOT, GID_WHEEL, 0600, "consolectl");
609 cctl_dev->si_tty = sc_console_tty = ttymalloc(sc_console_tty);
610 cctl_dev->si_drv1 = sc_console;
611 return 0;
612 }
613
614 static void
615 scmeminit(void *arg)
616 {
617 if (sc_malloc)
618 return;
619 sc_malloc = TRUE;
620
621 /*
622 * As soon as malloc() becomes functional, we had better allocate
623 * various buffers for the kernel console.
624 */
625
626 if (sc_console_unit < 0) /* sc_console == NULL */
627 return;
628
629 /* copy the temporary buffer to the final buffer */
630 sc_alloc_scr_buffer(sc_console, TRUE, FALSE);
631
632 #ifndef SC_NO_CUTPASTE
633 sc_alloc_cut_buffer(sc_console, TRUE);
634 #endif
635
636 #ifndef SC_NO_HISTORY
637 /* initialize history buffer & pointers */
638 sc_alloc_history_buffer(sc_console, 0, 0, TRUE);
639 #endif
640
641 /* Fill initial terminal border, efi_fb_info.vaddr should be non-NULL now */
642 if (!sc_filled_border) {
643 sc_filled_border = TRUE;
644 sc_set_border(sc_console, sc_console->border);
645 }
646 }
647
648 SYSINIT(sc_mem, SI_BOOT1_POST, SI_ORDER_ANY, scmeminit, NULL);
649
650 static int
651 scdevtounit(cdev_t dev)
652 {
653 int vty = SC_VTY(dev);
654
655 if (vty == SC_CONSOLECTL)
656 return ((sc_console != NULL) ? sc_console->sc->unit : -1);
657 else if ((vty < 0) || (vty >= MAXCONS*sc_max_unit()))
658 return -1;
659 else
660 return vty/MAXCONS;
661 }
662
663 static int
664 scopen(struct dev_open_args *ap)
665 {
666 cdev_t dev = ap->a_head.a_dev;
667 int unit;
668 sc_softc_t *sc;
669 struct tty *tp;
670 scr_stat *scp;
671 keyarg_t key;
672 int error;
673
674 lwkt_gettoken(&tty_token);
675 unit = scdevtounit(dev);
676 DPRINTF(5, ("scopen: dev:%d,%d, unit:%d, vty:%d\n",
677 major(dev), minor(dev), unit, SC_VTY(dev)));
678
679 sc = sc_get_softc(unit, (sc_console_unit == unit) ? SC_KERNEL_CONSOLE : 0);
680 if (sc == NULL) {
681 lwkt_reltoken(&tty_token);
682 return ENXIO;
683 }
684
685 tp = dev->si_tty = ttymalloc(dev->si_tty);
686 tp->t_oproc = scstart;
687 tp->t_param = scparam;
688 tp->t_stop = nottystop;
689
690 tp->t_dev = dev;
691
692 if (!ISTTYOPEN(tp)) {
693 ttychars(tp);
694 /* Use the current setting of the <-- key as default VERASE. */
695 /* If the Delete key is preferable, an stty is necessary */
696 if (sc->kbd != NULL) {
697 key.keynum = KEYCODE_BS;
698 kbd_ioctl(sc->kbd, GIO_KEYMAPENT, (caddr_t)&key);
699 tp->t_cc[VERASE] = key.key.map[0];
700 }
701 tp->t_iflag = TTYDEF_IFLAG;
702 tp->t_oflag = TTYDEF_OFLAG;
703 tp->t_cflag = TTYDEF_CFLAG;
704 tp->t_lflag = TTYDEF_LFLAG;
705 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
706 scparam(tp, &tp->t_termios);
707 (*linesw[tp->t_line].l_modem)(tp, 1);
708 }
709 else
710 if (tp->t_state & TS_XCLUDE && priv_check_cred(ap->a_cred, PRIV_ROOT, 0)) {
711 lwkt_reltoken(&tty_token);
712 return(EBUSY);
713 }
714
715 error = (*linesw[tp->t_line].l_open)(dev, tp);
716
717 scp = SC_STAT(dev);
718 if (scp == NULL) {
719 scp = dev->si_drv1 = alloc_scp(sc, SC_VTY(dev));
720 syscons_lock();
721 if (ISGRAPHSC(scp))
722 sc_set_pixel_mode(scp, NULL, COL, ROW, 16);
723 syscons_unlock();
724 }
725 if (!tp->t_winsize.ws_col && !tp->t_winsize.ws_row) {
726 tp->t_winsize.ws_col = scp->xsize;
727 tp->t_winsize.ws_row = scp->ysize;
728 }
729
730 /*
731 * Start optional support thread for syscons refreshes. This thread
732 * will execute the refresh without the syscons_lock held and will
733 * allow interrupts while it is doing so.
734 */
735 if (scp->asynctd == NULL) {
736 lwkt_create(scrn_update_thread, scp, &scp->asynctd, NULL, 0, -1,
737 "syscons%d", SC_VTY(dev));
738 }
739 lwkt_reltoken(&tty_token);
740 return error;
741 }
742
743 static int
744 scclose(struct dev_close_args *ap)
745 {
746 cdev_t dev = ap->a_head.a_dev;
747 struct tty *tp = dev->si_tty;
748 scr_stat *scp;
749
750 lwkt_gettoken(&tty_token);
751 if (SC_VTY(dev) != SC_CONSOLECTL) {
752 scp = SC_STAT(tp->t_dev);
753 /* were we in the middle of the VT switching process? */
754 DPRINTF(5, ("sc%d: scclose(), ", scp->sc->unit));
755 if ((scp == scp->sc->cur_scp) && (scp->sc->unit == sc_console_unit))
756 cons_unavail = FALSE;
757 if (finish_vt_rel(scp, TRUE) == 0) /* force release */
758 DPRINTF(5, ("reset WAIT_REL, "));
759 if (finish_vt_acq(scp) == 0) /* force acknowledge */
760 DPRINTF(5, ("reset WAIT_ACQ, "));
761 syscons_lock();
762 #if 0 /* notyet */
763 if (scp == &main_console) {
764 scp->pid = 0;
765 scp->proc = NULL;
766 scp->smode.mode = VT_AUTO;
767 }
768 else {
769 sc_vtb_destroy(&scp->vtb);
770 sc_vtb_destroy(&scp->scr);
771 sc_free_history_buffer(scp, scp->ysize);
772 SC_STAT(dev) = NULL;
773 kfree(scp, M_SYSCONS);
774 }
775 #else
776 scp->pid = 0;
777 scp->proc = NULL;
778 scp->smode.mode = VT_AUTO;
779 #endif
780 scp->kbd_mode = K_XLATE;
781 syscons_unlock();
782 if (scp == scp->sc->cur_scp)
783 kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
784 DPRINTF(5, ("done.\n"));
785 }
786 (*linesw[tp->t_line].l_close)(tp, ap->a_fflag);
787 ttyclose(tp);
788 lwkt_reltoken(&tty_token);
789
790 return(0);
791 }
792
793 static int
794 scread(struct dev_read_args *ap)
795 {
796 int ret;
797
798 lwkt_gettoken(&tty_token);
799 sc_touch_scrn_saver();
800 ret = ttyread(ap);
801 lwkt_reltoken(&tty_token);
802 return ret;
803 }
804
805 static int
806 sckbdevent(keyboard_t *thiskbd, int event, void *arg)
807 {
808 sc_softc_t *sc;
809 struct tty *cur_tty;
810 int c;
811 size_t len;
812 u_char *cp;
813
814 lwkt_gettoken(&tty_token);
815 /*
816 * WARNING: In early boot sc->dev may not be setup yet.
817 */
818 sc = (sc_softc_t *)arg;
819 /* assert(thiskbd == sc->kbd) */
820
821 switch (event) {
822 case KBDIO_KEYINPUT:
823 if (sc->kbd && sc->kbd->kb_flags & KB_POLLED) {
824 lwkt_reltoken(&tty_token);
825 return 0;
826 }
827 break;
828 case KBDIO_UNLOADING:
829 syscons_lock();
830 sc->kbd = NULL;
831 sc->keyboard = -1;
832 syscons_unlock();
833 kbd_release(thiskbd, (void *)&sc->keyboard);
834 lwkt_reltoken(&tty_token);
835 return 0;
836 default:
837 lwkt_reltoken(&tty_token);
838 return EINVAL;
839 }
840
841 /*
842 * Loop while there is still input to get from the keyboard.
843 * I don't think this is nessesary, and it doesn't fix
844 * the Xaccel-2.1 keyboard hang, but it can't hurt. XXX
845 */
846 while ((c = scgetc(sc, SCGETC_NONBLOCK)) != NOKEY) {
847 cur_tty = VIRTUAL_TTY(sc, sc->cur_scp->index);
848 if (!ISTTYOPEN(cur_tty)) {
849 cur_tty = sc_console_tty;
850 if (!ISTTYOPEN(cur_tty))
851 continue;
852 }
853
854 syscons_lock();
855 if ((*sc->cur_scp->tsw->te_input)(sc->cur_scp, c, cur_tty)) {
856 syscons_unlock();
857 continue;
858 }
859 syscons_unlock();
860
861 switch (KEYFLAGS(c)) {
862 case 0x0000: /* normal key */
863 (*linesw[cur_tty->t_line].l_rint)(KEYCHAR(c), cur_tty);
864 break;
865 case FKEY: /* function key, return string */
866 cp = kbd_get_fkeystr(thiskbd, KEYCHAR(c), &len);
867 if (cp != NULL) {
868 while (len-- > 0)
869 (*linesw[cur_tty->t_line].l_rint)(*cp++, cur_tty);
870 }
871 break;
872 case MKEY: /* meta is active, prepend ESC */
873 (*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
874 (*linesw[cur_tty->t_line].l_rint)(KEYCHAR(c), cur_tty);
875 break;
876 case BKEY: /* backtab fixed sequence (esc [ Z) */
877 (*linesw[cur_tty->t_line].l_rint)(0x1b, cur_tty);
878 (*linesw[cur_tty->t_line].l_rint)('[', cur_tty);
879 (*linesw[cur_tty->t_line].l_rint)('Z', cur_tty);
880 break;
881 }
882 }
883
884 syscons_lock();
885 sc->cur_scp->status |= MOUSE_HIDDEN;
886 syscons_unlock();
887
888 lwkt_reltoken(&tty_token);
889 return 0;
890 }
891
892 static int
893 scparam(struct tty *tp, struct termios *t)
894 {
895 lwkt_gettoken(&tty_token);
896 tp->t_ispeed = t->c_ispeed;
897 tp->t_ospeed = t->c_ospeed;
898 tp->t_cflag = t->c_cflag;
899 lwkt_reltoken(&tty_token);
900 return 0;
901 }
902
903 static int
904 scioctl(struct dev_ioctl_args *ap)
905 {
906 cdev_t dev = ap->a_head.a_dev;
907 u_long cmd = ap->a_cmd;
908 caddr_t data = ap->a_data;
909 int flag = ap->a_fflag;
910 int error;
911 int i;
912 struct tty *tp;
913 sc_softc_t *sc;
914 scr_stat *scp;
915
916 lwkt_gettoken(&tty_token);
917 tp = dev->si_tty;
918
919 error = sc_vid_ioctl(tp, cmd, data, flag);
920 if (error != ENOIOCTL) {
921 lwkt_reltoken(&tty_token);
922 return error;
923 }
924
925 #ifndef SC_NO_HISTORY
926 error = sc_hist_ioctl(tp, cmd, data, flag);
927 if (error != ENOIOCTL) {
928 lwkt_reltoken(&tty_token);
929 return error;
930 }
931 #endif
932
933 #ifndef SC_NO_SYSMOUSE
934 error = sc_mouse_ioctl(tp, cmd, data, flag);
935 if (error != ENOIOCTL) {
936 lwkt_reltoken(&tty_token);
937 return error;
938 }
939 #endif
940
941 scp = SC_STAT(tp->t_dev);
942 /* assert(scp != NULL) */
943 /* scp is sc_console, if SC_VTY(dev) == SC_CONSOLECTL. */
944 sc = scp->sc;
945
946 if (scp->tsw) {
947 syscons_lock();
948 error = (*scp->tsw->te_ioctl)(scp, tp, cmd, data, flag);
949 syscons_unlock();
950 if (error != ENOIOCTL) {
951 lwkt_reltoken(&tty_token);
952 return error;
953 }
954 }
955
956 switch (cmd) { /* process console hardware related ioctl's */
957
958 case GIO_ATTR: /* get current attributes */
959 /* this ioctl is not processed here, but in the terminal emulator */
960 lwkt_reltoken(&tty_token);
961 return ENOTTY;
962
963 case GIO_COLOR: /* is this a color console ? */
964 if (sc->fbi != NULL)
965 *(int *)data = 1;
966 else
967 *(int *)data = (sc->adp->va_flags & V_ADP_COLOR) ? 1 : 0;
968 lwkt_reltoken(&tty_token);
969 return 0;
970
971 case CONS_BLANKTIME: /* set screen saver timeout (0 = no saver) */
972 if (*(int *)data < 0 || *(int *)data > MAX_BLANKTIME) {
973 lwkt_reltoken(&tty_token);
974 return EINVAL;
975 }
976 syscons_lock();
977 scrn_blank_time = *(int *)data;
978 run_scrn_saver = (scrn_blank_time != 0);
979 syscons_unlock();
980 lwkt_reltoken(&tty_token);
981 return 0;
982
983 case CONS_CURSORTYPE: /* set cursor type blink/noblink */
984 syscons_lock();
985 if (!ISGRAPHSC(sc->cur_scp))
986 sc_remove_cursor_image(sc->cur_scp);
987 if ((*(int*)data) & 0x01)
988 sc->flags |= SC_BLINK_CURSOR;
989 else
990 sc->flags &= ~SC_BLINK_CURSOR;
991 if ((*(int*)data) & 0x02) {
992 sc->flags |= SC_CHAR_CURSOR;
993 } else
994 sc->flags &= ~SC_CHAR_CURSOR;
995 /*
996 * The cursor shape is global property; all virtual consoles
997 * are affected. Update the cursor in the current console...
998 */
999 if (!ISGRAPHSC(sc->cur_scp)) {
1000 sc_set_cursor_image(sc->cur_scp);
1001 sc_draw_cursor_image(sc->cur_scp);
1002 }
1003 syscons_unlock();
1004 lwkt_reltoken(&tty_token);
1005 return 0;
1006
1007 case CONS_BELLTYPE: /* set bell type sound/visual */
1008 syscons_lock();
1009
1010 if ((*(int *)data) & 0x01)
1011 sc->flags |= SC_VISUAL_BELL;
1012 else
1013 sc->flags &= ~SC_VISUAL_BELL;
1014
1015 if ((*(int *)data) & 0x02)
1016 sc->flags |= SC_QUIET_BELL;
1017 else
1018 sc->flags &= ~SC_QUIET_BELL;
1019
1020 syscons_unlock();
1021 lwkt_reltoken(&tty_token);
1022 return 0;
1023
1024 case CONS_GETINFO: /* get current (virtual) console info */
1025 {
1026 vid_info_t *ptr = (vid_info_t*)data;
1027 if (ptr->size == sizeof(struct vid_info)) {
1028 ptr->m_num = sc->cur_scp->index;
1029 ptr->font_size = scp->font_height;
1030 ptr->mv_col = scp->xpos;
1031 ptr->mv_row = scp->ypos;
1032 ptr->mv_csz = scp->xsize;
1033 ptr->mv_rsz = scp->ysize;
1034 /*
1035 * The following fields are filled by the terminal emulator. XXX
1036 *
1037 * ptr->mv_norm.fore
1038 * ptr->mv_norm.back
1039 * ptr->mv_rev.fore
1040 * ptr->mv_rev.back
1041 */
1042 ptr->mv_grfc.fore = 0; /* not supported */
1043 ptr->mv_grfc.back = 0; /* not supported */
1044 ptr->mv_ovscan = scp->border;
1045 if (scp == sc->cur_scp)
1046 save_kbd_state(scp, FALSE);
1047 ptr->mk_keylock = scp->status & LOCK_MASK;
1048 lwkt_reltoken(&tty_token);
1049 return 0;
1050 }
1051 lwkt_reltoken(&tty_token);
1052 return EINVAL;
1053 }
1054
1055 case CONS_GETVERS: /* get version number */
1056 *(int*)data = 0x200; /* version 2.0 */
1057 lwkt_reltoken(&tty_token);
1058 return 0;
1059
1060 case CONS_IDLE: /* see if the screen has been idle */
1061 /*
1062 * When the screen is in the GRAPHICS_MODE or UNKNOWN_MODE,
1063 * the user process may have been writing something on the
1064 * screen and syscons is not aware of it. Declare the screen
1065 * is NOT idle if it is in one of these modes. But there is
1066 * an exception to it; if a screen saver is running in the
1067 * graphics mode in the current screen, we should say that the
1068 * screen has been idle.
1069 */
1070 *(int *)data = (sc->flags & SC_SCRN_IDLE)
1071 && (!ISGRAPHSC(sc->cur_scp)
1072 || (sc->cur_scp->status & SAVER_RUNNING));
1073 lwkt_reltoken(&tty_token);
1074 return 0;
1075
1076 case CONS_SAVERMODE: /* set saver mode */
1077 switch(*(int *)data) {
1078 case CONS_NO_SAVER:
1079 case CONS_USR_SAVER:
1080 syscons_lock();
1081 /* if a LKM screen saver is running, stop it first. */
1082 scsplash_stick(FALSE);
1083 saver_mode = *(int *)data;
1084 #if NSPLASH > 0
1085 if ((error = wait_scrn_saver_stop(NULL))) {
1086 syscons_unlock();
1087 lwkt_reltoken(&tty_token);
1088 return error;
1089 }
1090 #endif /* NSPLASH */
1091 run_scrn_saver = TRUE;
1092 if (saver_mode == CONS_USR_SAVER)
1093 scp->status |= SAVER_RUNNING;
1094 else
1095 scp->status &= ~SAVER_RUNNING;
1096 scsplash_stick(TRUE);
1097 syscons_unlock();
1098 break;
1099 case CONS_LKM_SAVER:
1100 syscons_lock();
1101 if ((saver_mode == CONS_USR_SAVER) && (scp->status & SAVER_RUNNING))
1102 scp->status &= ~SAVER_RUNNING;
1103 saver_mode = *(int *)data;
1104 syscons_unlock();
1105 break;
1106 default:
1107 lwkt_reltoken(&tty_token);
1108 return EINVAL;
1109 }
1110 lwkt_reltoken(&tty_token);
1111 return 0;
1112
1113 case CONS_SAVERSTART: /* immediately start/stop the screen saver */
1114 /*
1115 * Note that this ioctl does not guarantee the screen saver
1116 * actually starts or stops. It merely attempts to do so...
1117 */
1118 syscons_lock();
1119 run_scrn_saver = (*(int *)data != 0);
1120 if (run_scrn_saver)
1121 sc->scrn_time_stamp -= scrn_blank_time;
1122 syscons_unlock();
1123 lwkt_reltoken(&tty_token);
1124 return 0;
1125
1126 case CONS_SCRSHOT: /* get a screen shot */
1127 {
1128 scrshot_t *ptr = (scrshot_t*)data;
1129 syscons_lock();
1130 if (ISGRAPHSC(scp)) {
1131 syscons_unlock();
1132 lwkt_reltoken(&tty_token);
1133 return EOPNOTSUPP;
1134 }
1135 if (scp->xsize != ptr->xsize || scp->ysize != ptr->ysize) {
1136 syscons_unlock();
1137 lwkt_reltoken(&tty_token);
1138 return EINVAL;
1139 }
1140 syscons_unlock();
1141 copyout ((void*)scp->vtb.vtb_buffer, ptr->buf,
1142 ptr->xsize * ptr->ysize * sizeof(uint16_t));
1143 lwkt_reltoken(&tty_token);
1144 return 0;
1145 }
1146
1147 case VT_SETMODE: /* set screen switcher mode */
1148 {
1149 struct vt_mode *mode;
1150
1151 mode = (struct vt_mode *)data;
1152 DPRINTF(5, ("sc%d: VT_SETMODE ", sc->unit));
1153 if (scp->smode.mode == VT_PROCESS) {
1154 if (scp->proc == pfindn(scp->pid) && scp->proc != curproc) {
1155 DPRINTF(5, ("error EPERM\n"));
1156 lwkt_reltoken(&tty_token);
1157 return EPERM;
1158 }
1159 }
1160 syscons_lock();
1161 if (mode->mode == VT_AUTO) {
1162 scp->smode.mode = VT_AUTO;
1163 scp->proc = NULL;
1164 scp->pid = 0;
1165 DPRINTF(5, ("VT_AUTO, "));
1166 if ((scp == sc->cur_scp) && (sc->unit == sc_console_unit))
1167 cons_unavail = FALSE;
1168 if (finish_vt_rel(scp, TRUE) == 0)
1169 DPRINTF(5, ("reset WAIT_REL, "));
1170 if (finish_vt_acq(scp) == 0)
1171 DPRINTF(5, ("reset WAIT_ACQ, "));
1172 } else {
1173 if (!ISSIGVALID(mode->relsig) || !ISSIGVALID(mode->acqsig)
1174 || !ISSIGVALID(mode->frsig)) {
1175 syscons_unlock();
1176 DPRINTF(5, ("error EINVAL\n"));
1177 lwkt_reltoken(&tty_token);
1178 return EINVAL;
1179 }
1180 DPRINTF(5, ("VT_PROCESS %d, ", curproc->p_pid));
1181 bcopy(data, &scp->smode, sizeof(struct vt_mode));
1182 scp->proc = curproc;
1183 scp->pid = scp->proc->p_pid;
1184 if ((scp == sc->cur_scp) && (sc->unit == sc_console_unit))
1185 cons_unavail = TRUE;
1186 }
1187 syscons_unlock();
1188 DPRINTF(5, ("\n"));
1189 lwkt_reltoken(&tty_token);
1190 return 0;
1191 }
1192
1193 case VT_GETMODE: /* get screen switcher mode */
1194 bcopy(&scp->smode, data, sizeof(struct vt_mode));
1195 lwkt_reltoken(&tty_token);
1196 return 0;
1197
1198 case VT_RELDISP: /* screen switcher ioctl */
1199 /*
1200 * This must be the current vty which is in the VT_PROCESS
1201 * switching mode...
1202 */
1203 syscons_lock();
1204 if ((scp != sc->cur_scp) || (scp->smode.mode != VT_PROCESS)) {
1205 syscons_unlock();
1206 lwkt_reltoken(&tty_token);
1207 return EINVAL;
1208 }
1209 /* ...and this process is controlling it. */
1210 if (scp->proc != curproc) {
1211 syscons_unlock();
1212 lwkt_reltoken(&tty_token);
1213 return EPERM;
1214 }
1215 error = EINVAL;
1216 switch(*(int *)data) {
1217 case VT_FALSE: /* user refuses to release screen, abort */
1218 if ((error = finish_vt_rel(scp, FALSE)) == 0)
1219 DPRINTF(5, ("sc%d: VT_FALSE\n", sc->unit));
1220 break;
1221 case VT_TRUE: /* user has released screen, go on */
1222 if ((error = finish_vt_rel(scp, TRUE)) == 0)
1223 DPRINTF(5, ("sc%d: VT_TRUE\n", sc->unit));
1224 break;
1225 case VT_ACKACQ: /* acquire acknowledged, switch completed */
1226 if ((error = finish_vt_acq(scp)) == 0)
1227 DPRINTF(5, ("sc%d: VT_ACKACQ\n", sc->unit));
1228 break;
1229 default:
1230 break;
1231 }
1232 syscons_unlock();
1233 lwkt_reltoken(&tty_token);
1234 return error;
1235
1236 case VT_OPENQRY: /* return free virtual console */
1237 for (i = sc->first_vty; i < sc->first_vty + sc->vtys; i++) {
1238 tp = VIRTUAL_TTY(sc, i);
1239 if (!ISTTYOPEN(tp)) {
1240 *(int *)data = i + 1;
1241 lwkt_reltoken(&tty_token);
1242 return 0;
1243 }
1244 }
1245 lwkt_reltoken(&tty_token);
1246 return EINVAL;
1247
1248 case VT_ACTIVATE: /* switch to screen *data */
1249 i = (*(int *)data == 0) ? scp->index : (*(int *)data - 1);
1250 syscons_lock();
1251 sc_clean_up(sc->cur_scp);
1252 error = sc_switch_scr(sc, i);
1253 syscons_unlock();
1254 lwkt_reltoken(&tty_token);
1255 return error;
1256
1257 case VT_WAITACTIVE: /* wait for switch to occur */
1258 i = (*(int *)data == 0) ? scp->index : (*(int *)data - 1);
1259 if ((i < sc->first_vty) || (i >= sc->first_vty + sc->vtys)) {
1260 lwkt_reltoken(&tty_token);
1261 return EINVAL;
1262 }
1263 syscons_lock();
1264 error = sc_clean_up(sc->cur_scp);
1265 syscons_unlock();
1266 if (error) {
1267 lwkt_reltoken(&tty_token);
1268 return error;
1269 }
1270
1271 /*
1272 * scp might be NULL, we aren't sure why. Check for NULL.
1273 *
1274 * http://bugs.dragonflybsd.org/issues/2481
1275 */
1276 scp = SC_STAT(SC_DEV(sc, i));
1277 if (scp == NULL || scp == scp->sc->cur_scp) {
1278 lwkt_reltoken(&tty_token);
1279 return 0;
1280 }
1281 error = tsleep((caddr_t)&scp->smode, PCATCH, "waitvt", 0);
1282 /* May return ERESTART */
1283 lwkt_reltoken(&tty_token);
1284 return error;
1285
1286 case VT_GETACTIVE: /* get active vty # */
1287 *(int *)data = sc->cur_scp->index + 1;
1288 lwkt_reltoken(&tty_token);
1289 return 0;
1290
1291 case VT_GETINDEX: /* get this vty # */
1292 *(int *)data = scp->index + 1;
1293 lwkt_reltoken(&tty_token);
1294 return 0;
1295
1296 case VT_LOCKSWITCH: /* prevent vty switching */
1297 syscons_lock();
1298 if ((*(int *)data) & 0x01)
1299 sc->flags |= SC_SCRN_VTYLOCK;
1300 else
1301 sc->flags &= ~SC_SCRN_VTYLOCK;
1302 syscons_unlock();
1303 lwkt_reltoken(&tty_token);
1304 return 0;
1305
1306 case KDENABIO: /* allow io operations */
1307 error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0);
1308 if (error != 0) {
1309 lwkt_reltoken(&tty_token);
1310 return error;
1311 }
1312 if (securelevel > 0) {
1313 lwkt_reltoken(&tty_token);
1314 return EPERM;
1315 }
1316 #if defined(__i386__)
1317 curthread->td_lwp->lwp_md.md_regs->tf_eflags |= PSL_IOPL;
1318 #elif defined(__x86_64__)
1319 curthread->td_lwp->lwp_md.md_regs->tf_rflags |= PSL_IOPL;
1320 #endif
1321 lwkt_reltoken(&tty_token);
1322 return 0;
1323
1324 case KDDISABIO: /* disallow io operations (default) */
1325 #if defined(__i386__)
1326 curthread->td_lwp->lwp_md.md_regs->tf_eflags &= ~PSL_IOPL;
1327 #elif defined(__x86_64__)
1328 curthread->td_lwp->lwp_md.md_regs->tf_rflags &= ~PSL_IOPL;
1329 #endif
1330 lwkt_reltoken(&tty_token);
1331 return 0;
1332
1333 case KDSKBSTATE: /* set keyboard state (locks) */
1334 if (*(int *)data & ~LOCK_MASK) {
1335 lwkt_reltoken(&tty_token);
1336 return EINVAL;
1337 }
1338 syscons_lock();
1339 scp->status &= ~LOCK_MASK;
1340 scp->status |= *(int *)data;
1341 syscons_unlock();
1342 if (scp == sc->cur_scp)
1343 update_kbd_state(scp, scp->status, LOCK_MASK, FALSE);
1344 lwkt_reltoken(&tty_token);
1345 return 0;
1346
1347 case KDGKBSTATE: /* get keyboard state (locks) */
1348 if (scp == sc->cur_scp)
1349 save_kbd_state(scp, FALSE);
1350 *(int *)data = scp->status & LOCK_MASK;
1351 lwkt_reltoken(&tty_token);
1352 return 0;
1353
1354 case KDGETREPEAT: /* get keyboard repeat & delay rates */
1355 case KDSETREPEAT: /* set keyboard repeat & delay rates (new) */
1356 error = kbd_ioctl(sc->kbd, cmd, data);
1357 if (error == ENOIOCTL)
1358 error = ENODEV;
1359 lwkt_reltoken(&tty_token);
1360 return error;
1361
1362 case KDSETRAD: /* set keyboard repeat & delay rates (old) */
1363 if (*(int *)data & ~0x7f) {
1364 lwkt_reltoken(&tty_token);
1365 return EINVAL;
1366 }
1367 error = kbd_ioctl(sc->kbd, cmd, data);
1368 if (error == ENOIOCTL)
1369 error = ENODEV;
1370 lwkt_reltoken(&tty_token);
1371 return error;
1372
1373 case KDSKBMODE: /* set keyboard mode */
1374 switch (*(int *)data) {
1375 case K_XLATE: /* switch to XLT ascii mode */
1376 case K_RAW: /* switch to RAW scancode mode */
1377 case K_CODE: /* switch to CODE mode */
1378 scp->kbd_mode = *(int *)data;
1379 if (scp == sc->cur_scp)
1380 kbd_ioctl(sc->kbd, cmd, data);
1381 lwkt_reltoken(&tty_token);
1382 return 0;
1383 default:
1384 lwkt_reltoken(&tty_token);
1385 return EINVAL;
1386 }
1387 /* NOT REACHED */
1388
1389 case KDGKBMODE: /* get keyboard mode */
1390 *(int *)data = scp->kbd_mode;
1391 lwkt_reltoken(&tty_token);
1392 return 0;
1393
1394 case KDGKBINFO:
1395 error = kbd_ioctl(sc->kbd, cmd, data);
1396 if (error == ENOIOCTL)
1397 error = ENODEV;
1398 lwkt_reltoken(&tty_token);
1399 return error;
1400
1401 case KDMKTONE: /* sound the bell */
1402 syscons_lock();
1403 if (*(int*)data)
1404 sc_bell(scp, (*(int*)data)&0xffff,
1405 (((*(int*)data)>>16)&0xffff)*hz/1000);
1406 else
1407 sc_bell(scp, scp->bell_pitch, scp->bell_duration);
1408 syscons_unlock();
1409 lwkt_reltoken(&tty_token);
1410 return 0;
1411
1412 case KIOCSOUND: /* make tone (*data) hz */
1413 syscons_lock();
1414 if (scp == sc->cur_scp) {
1415 if (*(int *)data) {
1416 error = sc_tone(*(int *)data);
1417 } else {
1418 error = sc_tone(0);
1419 }
1420 } else {
1421 error = 0;
1422 }
1423 syscons_unlock();
1424 lwkt_reltoken(&tty_token);
1425 return error;
1426
1427 case KDGKBTYPE: /* get keyboard type */
1428 error = kbd_ioctl(sc->kbd, cmd, data);
1429 if (error == ENOIOCTL) {
1430 /* always return something? XXX */
1431 *(int *)data = 0;
1432 }
1433 lwkt_reltoken(&tty_token);
1434 return 0;
1435
1436 case KDSETLED: /* set keyboard LED status */
1437 if (*(int *)data & ~LED_MASK) { /* FIXME: LOCK_MASK? */
1438 lwkt_reltoken(&tty_token);
1439 return EINVAL;
1440 }
1441 syscons_lock();
1442 scp->status &= ~LED_MASK;
1443 scp->status |= *(int *)data;
1444 syscons_unlock();
1445 if (scp == sc->cur_scp)
1446 update_kbd_leds(scp, scp->status);
1447 lwkt_reltoken(&tty_token);
1448 return 0;
1449
1450 case KDGETLED: /* get keyboard LED status */
1451 if (scp == sc->cur_scp)
1452 save_kbd_state(scp, FALSE);
1453 *(int *)data = scp->status & LED_MASK;
1454 lwkt_reltoken(&tty_token);
1455 return 0;
1456
1457 case KBADDKBD: /* add/remove keyboard to/from mux */
1458 case KBRELKBD:
1459 error = kbd_ioctl(sc->kbd, cmd, data);
1460 if (error == ENOIOCTL)
1461 error = ENODEV;
1462 lwkt_reltoken(&tty_token);
1463 return error;
1464
1465 case CONS_SETKBD: /* set the new keyboard */
1466 {
1467 keyboard_t *newkbd;
1468
1469 newkbd = kbd_get_keyboard(*(int *)data);
1470 if (newkbd == NULL) {
1471 lwkt_reltoken(&tty_token);
1472 return EINVAL;
1473 }
1474 error = 0;
1475 if (sc->kbd != newkbd) {
1476 i = kbd_allocate(newkbd->kb_name, newkbd->kb_unit,
1477 (void *)&sc->keyboard, sckbdevent, sc);
1478 /* i == newkbd->kb_index */
1479 if (i >= 0) {
1480 if (sc->kbd != NULL) {
1481 save_kbd_state(sc->cur_scp, FALSE);
1482 kbd_release(sc->kbd, (void *)&sc->keyboard);
1483 }
1484 syscons_lock();
1485 sc->kbd = kbd_get_keyboard(i); /* sc->kbd == newkbd */
1486 sc->keyboard = i;
1487 syscons_unlock();
1488 kbd_ioctl(sc->kbd, KDSKBMODE,
1489 (caddr_t)&sc->cur_scp->kbd_mode);
1490 update_kbd_state(sc->cur_scp, sc->cur_scp->status,
1491 LOCK_MASK, FALSE);
1492 } else {
1493 error = EPERM; /* XXX */
1494 }
1495 }
1496 lwkt_reltoken(&tty_token);
1497 return error;
1498 }
1499
1500 case CONS_RELKBD: /* release the current keyboard */
1501 error = 0;
1502 if (sc->kbd != NULL) {
1503 save_kbd_state(sc->cur_scp, FALSE);
1504 error = kbd_release(sc->kbd, (void *)&sc->keyboard);
1505 if (error == 0) {
1506 syscons_lock();
1507 sc->kbd = NULL;
1508 sc->keyboard = -1;
1509 syscons_unlock();
1510 }
1511 }
1512 lwkt_reltoken(&tty_token);
1513 return error;
1514
1515 case CONS_GETTERM: /* get the current terminal emulator info */
1516 {
1517 sc_term_sw_t *sw;
1518
1519 if (((term_info_t *)data)->ti_index == 0) {
1520 sw = scp->tsw;
1521 } else {
1522 sw = sc_term_match_by_number(((term_info_t *)data)->ti_index);
1523 }
1524 if (sw != NULL) {
1525 strncpy(((term_info_t *)data)->ti_name, sw->te_name,
1526 sizeof(((term_info_t *)data)->ti_name));
1527 strncpy(((term_info_t *)data)->ti_desc, sw->te_desc,
1528 sizeof(((term_info_t *)data)->ti_desc));
1529 ((term_info_t *)data)->ti_flags = 0;
1530 lwkt_reltoken(&tty_token);
1531 return 0;
1532 } else {
1533 ((term_info_t *)data)->ti_name[0] = '\0';
1534 ((term_info_t *)data)->ti_desc[0] = '\0';
1535 ((term_info_t *)data)->ti_flags = 0;
1536 lwkt_reltoken(&tty_token);
1537 return EINVAL;
1538 }
1539 }
1540
1541 case CONS_SETTERM: /* set the current terminal emulator */
1542 syscons_lock();
1543 error = sc_init_emulator(scp, ((term_info_t *)data)->ti_name);
1544 /* FIXME: what if scp == sc_console! XXX */
1545 syscons_unlock();
1546 lwkt_reltoken(&tty_token);
1547 return error;
1548
1549 case GIO_SCRNMAP: /* get output translation table */
1550 bcopy(&sc->scr_map, data, sizeof(sc->scr_map));
1551 lwkt_reltoken(&tty_token);
1552 return 0;
1553
1554 case PIO_SCRNMAP: /* set output translation table */
1555 bcopy(data, &sc->scr_map, sizeof(sc->scr_map));
1556 for (i=0; i<sizeof(sc->scr_map); i++) {
1557 sc->scr_rmap[sc->scr_map[i]] = i;
1558 }
1559 lwkt_reltoken(&tty_token);
1560 return 0;
1561
1562 case GIO_KEYMAP: /* get keyboard translation table */
1563 case PIO_KEYMAP: /* set keyboard translation table */
1564 case GIO_DEADKEYMAP: /* get accent key translation table */
1565 case PIO_DEADKEYMAP: /* set accent key translation table */
1566 case GETFKEY: /* get function key string */
1567 case SETFKEY: /* set function key string */
1568 error = kbd_ioctl(sc->kbd, cmd, data);
1569 if (error == ENOIOCTL)
1570 error = ENODEV;
1571 lwkt_reltoken(&tty_token);
1572 return error;
1573
1574 #ifndef SC_NO_FONT_LOADING
1575
1576 case PIO_FONT8x8: /* set 8x8 dot font */
1577 if (sc->fbi == NULL && !ISFONTAVAIL(sc->adp->va_flags)) {
1578 lwkt_reltoken(&tty_token);
1579 return ENXIO;
1580 }
1581 syscons_lock();
1582 bcopy(data, sc->font_8, 8*256);
1583 sc->fonts_loaded |= FONT_8;
1584 /*
1585 * FONT KLUDGE
1586 * Always use the font page #0. XXX
1587 * Don't load if the current font size is not 8x8.
1588 */
1589 if (sc->fbi == NULL
1590 && ISTEXTSC(sc->cur_scp) && (sc->cur_scp->font_height < 14)) {
1591 sc_load_font(sc->cur_scp, 0, 8, sc->font_8, 0, 256);
1592 }
1593 syscons_unlock();
1594 lwkt_reltoken(&tty_token);
1595 return 0;
1596
1597 case GIO_FONT8x8: /* get 8x8 dot font */
1598 if (sc->fbi == NULL && !ISFONTAVAIL(sc->adp->va_flags)) {
1599 lwkt_reltoken(&tty_token);
1600 return ENXIO;
1601 }
1602 if (sc->fonts_loaded & FONT_8) {
1603 bcopy(sc->font_8, data, 8*256);
1604 lwkt_reltoken(&tty_token);
1605 return 0;
1606 }
1607 else {
1608 lwkt_reltoken(&tty_token);
1609 return ENXIO;
1610 }
1611
1612 case PIO_FONT8x14: /* set 8x14 dot font */
1613 if (sc->fbi == NULL && !ISFONTAVAIL(sc->adp->va_flags)) {
1614 lwkt_reltoken(&tty_token);
1615 return ENXIO;
1616 }
1617 syscons_lock();
1618 bcopy(data, sc->font_14, 14*256);
1619 sc->fonts_loaded |= FONT_14;
1620 /*
1621 * FONT KLUDGE
1622 * Always use the font page #0. XXX
1623 * Don't load if the current font size is not 8x14.
1624 */
1625 if (sc->fbi == NULL
1626 && ISTEXTSC(sc->cur_scp)
1627 && (sc->cur_scp->font_height >= 14)
1628 && (sc->cur_scp->font_height < 16)) {
1629 sc_load_font(sc->cur_scp, 0, 14, sc->font_14, 0, 256);
1630 }
1631 syscons_unlock();
1632 lwkt_reltoken(&tty_token);
1633 return 0;
1634
1635 case GIO_FONT8x14: /* get 8x14 dot font */
1636 if (sc->fbi == NULL && !ISFONTAVAIL(sc->adp->va_flags)) {
1637 lwkt_reltoken(&tty_token);
1638 return ENXIO;
1639 }
1640 if (sc->fonts_loaded & FONT_14) {
1641 bcopy(sc->font_14, data, 14*256);
1642 lwkt_reltoken(&tty_token);
1643 return 0;
1644 }
1645 else {
1646 lwkt_reltoken(&tty_token);
1647 return ENXIO;
1648 }
1649
1650 case PIO_FONT8x16: /* set 8x16 dot font */
1651 if (sc->fbi == NULL && !ISFONTAVAIL(sc->adp->va_flags)) {
1652 lwkt_reltoken(&tty_token);
1653 return ENXIO;
1654 }
1655 syscons_lock();
1656 bcopy(data, sc->font_16, 16*256);
1657 sc->fonts_loaded |= FONT_16;
1658 /*
1659 * FONT KLUDGE
1660 * Always use the font page #0. XXX
1661 * Don't load if the current font size is not 8x16.
1662 */
1663 if (sc->fbi == NULL
1664 && ISTEXTSC(sc->cur_scp) && (sc->cur_scp->font_height >= 16)) {
1665 sc_load_font(sc->cur_scp, 0, 16, sc->font_16, 0, 256);
1666 }
1667 syscons_unlock();
1668 lwkt_reltoken(&tty_token);
1669 return 0;
1670
1671 case GIO_FONT8x16: /* get 8x16 dot font */
1672 if (sc->fbi == NULL && !ISFONTAVAIL(sc->adp->va_flags)) {
1673 lwkt_reltoken(&tty_token);
1674 return ENXIO;
1675 }
1676 if (sc->fonts_loaded & FONT_16) {
1677 bcopy(sc->font_16, data, 16*256);
1678 lwkt_reltoken(&tty_token);
1679 return 0;
1680 }
1681 else {
1682 lwkt_reltoken(&tty_token);
1683 return ENXIO;
1684 }
1685
1686 #endif /* SC_NO_FONT_LOADING */
1687
1688 default:
1689 break;
1690 }
1691
1692 error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, ap->a_cred);
1693 if (error != ENOIOCTL) {
1694 lwkt_reltoken(&tty_token);
1695 return(error);
1696 }
1697 error = ttioctl(tp, cmd, data, flag);
1698 if (error != ENOIOCTL) {
1699 lwkt_reltoken(&tty_token);
1700 return(error);
1701 }
1702 lwkt_reltoken(&tty_token);
1703 return(ENOTTY);
1704 }
1705
1706 static void
1707 scstart(struct tty *tp)
1708 {
1709 struct clist *rbp;
1710 int len;
1711 u_char buf[PCBURST];
1712 scr_stat *scp = SC_STAT(tp->t_dev);
1713
1714 syscons_lock();
1715 if (scp->status & SLKED ||
1716 (scp == scp->sc->cur_scp && scp->sc->blink_in_progress))
1717 {
1718 syscons_unlock();
1719 return;
1720 }
1721 if (!(tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP))) {
1722 tp->t_state |= TS_BUSY;
1723 rbp = &tp->t_outq;
1724 while (rbp->c_cc) {
1725 len = q_to_b(rbp, buf, PCBURST);
1726 sc_puts(scp, buf, len);
1727 }
1728 tp->t_state &= ~TS_BUSY;
1729 syscons_unlock();
1730 ttwwakeup(tp);
1731 } else {
1732 syscons_unlock();
1733 }
1734 }
1735
1736 static void
1737 sccnprobe(struct consdev *cp)
1738 {
1739 int unit;
1740 int flags;
1741
1742 cp->cn_pri = sc_get_cons_priority(&unit, &flags);
1743
1744 /* a video card is always required */
1745 if (probe_efi_fb(1) != 0 && !scvidprobe(unit, flags, TRUE))
1746 cp->cn_pri = CN_DEAD;
1747
1748 /* syscons will become console even when there is no keyboard */
1749 sckbdprobe(unit, flags, TRUE);
1750
1751 if (cp->cn_pri == CN_DEAD) {
1752 return;
1753 }
1754
1755 /* initialize required fields */
1756 cp->cn_probegood = 1;
1757 }
1758
1759 static void
1760 sccninit(struct consdev *cp)
1761 {
1762 int unit;
1763 int flags;
1764
1765 sc_get_cons_priority(&unit, &flags);
1766 scinit(unit, flags | SC_KERNEL_CONSOLE);
1767 sc_console_unit = unit;
1768 sc_console = sc_get_softc(unit, SC_KERNEL_CONSOLE)->console_scp;
1769 }
1770
1771 static void
1772 sccninit_fini(struct consdev *cp)
1773 {
1774 if (cctl_dev == NULL)
1775 kprintf("sccninit_fini: WARNING: cctl_dev is NULL!\n");
1776 cp->cn_dev = cctl_dev;
1777 }
1778
1779 static void
1780 sccnterm(struct consdev *cp)
1781 {
1782 /* we are not the kernel console any more, release everything */
1783
1784 if (sc_console_unit < 0)
1785 return; /* shouldn't happen */
1786
1787 #if 0 /* XXX */
1788 syscons_lock();
1789 sc_clear_screen(sc_console);
1790 sccnupdate(sc_console);
1791 syscons_unlock();
1792 #endif
1793 scterm(sc_console_unit, SC_KERNEL_CONSOLE);
1794 sc_console_unit = -1;
1795 sc_console = NULL;
1796 }
1797
1798 /*
1799 * Console path - cannot block!
1800 */
1801 static void
1802 sccnputc(void *private, int c)
1803 {
1804 u_char buf[1];
1805 scr_stat *scp = sc_console;
1806 void *save;
1807 #ifndef SC_NO_HISTORY
1808 #if 0
1809 struct tty *tp;
1810 #endif
1811 #endif /* !SC_NO_HISTORY */
1812
1813 /* assert(sc_console != NULL) */
1814
1815 syscons_lock();
1816 #ifndef SC_NO_HISTORY
1817 if (scp == scp->sc->cur_scp && scp->status & SLKED) {
1818 scp->status &= ~SLKED;
1819 #if 0
1820 /* This can block, illegal in the console path */
1821 update_kbd_state(scp, scp->status, SLKED, TRUE);
1822 #endif
1823 if (scp->status & BUFFER_SAVED) {
1824 if (!sc_hist_restore(scp))
1825 sc_remove_cutmarking(scp);
1826 scp->status &= ~BUFFER_SAVED;
1827 scp->status |= CURSOR_ENABLED;
1828 sc_draw_cursor_image(scp);
1829 }
1830 #if 0
1831 tp = VIRTUAL_TTY(scp->sc, scp->index);
1832 /* This can block, illegal in the console path */
1833 if (ISTTYOPEN(tp)) {
1834 scstart(tp);
1835 }
1836 #endif
1837 }
1838 #endif /* !SC_NO_HISTORY */
1839
1840 save = scp->ts;
1841 if (kernel_console_ts != NULL)
1842 scp->ts = kernel_console_ts;
1843 buf[0] = c;
1844 sc_puts(scp, buf, 1);
1845 scp->ts = save;
1846
1847 sccnupdate(scp);
1848 syscons_unlock();
1849 }
1850
1851 /*
1852 * Console path - cannot block!
1853 */
1854 static int
1855 sccngetc(void *private)
1856 {
1857 return sccngetch(0);
1858 }
1859
1860 /*
1861 * Console path - cannot block!
1862 */
1863 static int
1864 sccncheckc(void *private)
1865 {
1866 return sccngetch(SCGETC_NONBLOCK);
1867 }
1868
1869 /*
1870 * Set polling mode (also disables the tty feed), use when
1871 * polling for console key input.
1872 */
1873 static void
1874 sccnpoll(void *private, int on)
1875 {
1876 scr_stat *scp;
1877
1878 syscons_lock();
1879 sc_touch_scrn_saver();
1880 scp = sc_console->sc->cur_scp; /* XXX */
1881 syscons_unlock();
1882 if (scp->sc->kbd)
1883 kbd_poll(scp->sc->kbd, on);
1884 }
1885
1886 static void
1887 sccndbctl(void *private, int on)
1888 {
1889 /* assert(sc_console_unit >= 0) */
1890 /* try to switch to the kernel console screen */
1891 if (on && debugger == 0) {
1892 /*
1893 * TRY to make sure the screen saver is stopped,
1894 * and the screen is updated before switching to
1895 * the vty0.
1896 */
1897 scrn_timer(NULL);
1898 if (!cold
1899 && sc_console->sc->cur_scp->smode.mode == VT_AUTO
1900 && sc_console->smode.mode == VT_AUTO) {
1901 sc_console->sc->cur_scp->status |= MOUSE_HIDDEN;
1902 syscons_lock();
1903 sc_switch_scr(sc_console->sc, sc_console->index);
1904 syscons_unlock();
1905 }
1906 }
1907 if (on)
1908 ++debugger;
1909 else
1910 --debugger;
1911 }
1912
1913 /*
1914 * Console path - cannot block!
1915 */
1916 static int
1917 sccngetch(int flags)
1918 {
1919 static struct fkeytab fkey;
1920 static int fkeycp;
1921 scr_stat *scp;
1922 u_char *p;
1923 int cur_mode;
1924 int c;
1925
1926 syscons_lock();
1927 /* assert(sc_console != NULL) */
1928
1929 /*
1930 * Stop the screen saver and update the screen if necessary.
1931 * What if we have been running in the screen saver code... XXX
1932 */
1933 sc_touch_scrn_saver();
1934 scp = sc_console->sc->cur_scp; /* XXX */
1935 sccnupdate(scp);
1936 syscons_unlock();
1937
1938 if (fkeycp < fkey.len) {
1939 return fkey.str[fkeycp++];
1940 }
1941
1942 if (scp->sc->kbd == NULL) {
1943 return -1;
1944 }
1945
1946 /*
1947 * Make sure the keyboard is accessible even when the kbd device
1948 * driver is disabled.
1949 */
1950 crit_enter();
1951 kbd_enable(scp->sc->kbd);
1952
1953 /* we shall always use the keyboard in the XLATE mode here */
1954 cur_mode = scp->kbd_mode;
1955 scp->kbd_mode = K_XLATE;
1956 kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
1957
1958 c = scgetc(scp->sc, SCGETC_CN | flags);
1959
1960 scp->kbd_mode = cur_mode;
1961 kbd_ioctl(scp->sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
1962 kbd_disable(scp->sc->kbd);
1963 crit_exit();
1964
1965 switch (KEYFLAGS(c)) {
1966 case 0: /* normal char */
1967 return KEYCHAR(c);
1968 case FKEY: /* function key */
1969 p = kbd_get_fkeystr(scp->sc->kbd, KEYCHAR(c), (size_t *)&fkeycp);
1970 fkey.len = fkeycp;
1971 if ((p != NULL) && (fkey.len > 0)) {
1972 bcopy(p, fkey.str, fkey.len);
1973 fkeycp = 1;
1974 return fkey.str[0];
1975 }
1976 return c; /* XXX */
1977 case NOKEY:
1978 if (flags & SCGETC_NONBLOCK)
1979 return c;
1980 /* fall through */
1981 case ERRKEY:
1982 default:
1983 return -1;
1984 }
1985 /* NOT REACHED */
1986 }
1987
1988 static void
1989 sccnupdate(scr_stat *scp)
1990 {
1991 int ddb_active;
1992
1993 #ifdef DDB
1994 ddb_active = db_active;
1995 #else
1996 ddb_active = 0;
1997 #endif
1998
1999 /* this is a cut-down version of scrn_timer()... */
2000
2001 /*
2002 * Don't update if videoio is in progress. However, if we are paniced
2003 * or in the debugger it is possible that the variables might be stuck,
2004 * so ignore it in such cases.
2005 */
2006 if (scp->sc->font_loading_in_progress || scp->sc->videoio_in_progress) {
2007 if (panicstr == NULL && ddb_active == 0 && shutdown_in_progress == 0)
2008 return;
2009 }
2010
2011 if (debugger > 0 || panicstr || ddb_active || shutdown_in_progress) {
2012 sc_touch_scrn_saver();
2013 } else if (scp != scp->sc->cur_scp) {
2014 return;
2015 }
2016
2017 if (!run_scrn_saver)
2018 scp->sc->flags &= ~SC_SCRN_IDLE;
2019 #if NSPLASH > 0
2020 /*
2021 * This is a hard path, we cannot call stop_scrn_saver() here.
2022 */
2023 if ((saver_mode != CONS_LKM_SAVER) || !(scp->sc->flags & SC_SCRN_IDLE))
2024 if (scp->sc->flags & SC_SCRN_BLANKED) {
2025 sc_touch_scrn_saver();
2026 /*stop_scrn_saver(scp->sc, current_saver);*/
2027 }
2028 #endif /* NSPLASH */
2029
2030 if (scp != scp->sc->cur_scp || scp->sc->blink_in_progress
2031 || scp->sc->switch_in_progress) {
2032 return;
2033 }
2034
2035 /*
2036 * FIXME: unlike scrn_timer(), we call scrn_update() from here even
2037 * when write_in_progress is non-zero. XXX
2038 */
2039 if (!ISGRAPHSC(scp) && !(scp->sc->flags & SC_SCRN_BLANKED))
2040 scrn_update(scp, TRUE, SCRN_ASYNCOK);
2041 }
2042
2043 static void
2044 scrn_timer(void *arg)
2045 {
2046 static int kbd_interval = 0;
2047 struct timeval tv;
2048 sc_softc_t *sc;
2049 scr_stat *scp;
2050 int again;
2051
2052 /*
2053 * Setup depending on who called us
2054 */
2055 again = (arg != NULL);
2056 if (arg != NULL) {
2057 sc = (sc_softc_t *)arg;
2058 } else if (sc_console != NULL) {
2059 sc = sc_console->sc;
2060 } else {
2061 return;
2062 }
2063
2064 /*
2065 * Don't do anything when we are performing some I/O operations.
2066 * (These are initiated by the frontend?)
2067 */
2068 if (sc->font_loading_in_progress || sc->videoio_in_progress) {
2069 if (again)
2070 callout_reset(&sc->scrn_timer_ch, hz / 10, scrn_timer, sc);
2071 return;
2072 }
2073
2074 /*
2075 * Try to allocate a keyboard automatically
2076 */
2077 if ((sc->kbd == NULL) && (sc->config & SC_AUTODETECT_KBD)) {
2078 if (++kbd_interval >= 25) {
2079 sc->keyboard = sc_allocate_keyboard(sc, -1);
2080 if (sc->keyboard >= 0) {
2081 sc->kbd = kbd_get_keyboard(sc->keyboard);
2082 kbd_ioctl(sc->kbd, KDSKBMODE,
2083 (caddr_t)&sc->cur_scp->kbd_mode);
2084 update_kbd_state(sc->cur_scp, sc->cur_scp->status,
2085 LOCK_MASK, FALSE);
2086 }
2087 kbd_interval = 0;
2088 }
2089 }
2090
2091 /*
2092 * Should we stop the screen saver? We need the syscons_lock
2093 * for most of this stuff.
2094 */
2095 getmicrouptime(&tv);
2096
2097 if (syscons_lock_nonblock() != 0) {
2098 /* failed to get the lock */
2099 if (again)
2100 callout_reset(&sc->scrn_timer_ch, hz / 10, scrn_timer, sc);
2101 return;
2102 }
2103 /* successful lock */
2104
2105 if (debugger > 0 || panicstr || shutdown_in_progress)
2106 sc_touch_scrn_saver();
2107 if (run_scrn_saver) {
2108 if (tv.tv_sec > sc->scrn_time_stamp + scrn_blank_time)
2109 sc->flags |= SC_SCRN_IDLE;
2110 else
2111 sc->flags &= ~SC_SCRN_IDLE;
2112 } else {
2113 sc->scrn_time_stamp = tv.tv_sec;
2114 sc->flags &= ~SC_SCRN_IDLE;
2115 if (scrn_blank_time > 0)
2116 run_scrn_saver = TRUE;
2117 }
2118 #if NSPLASH > 0
2119 if ((saver_mode != CONS_LKM_SAVER) || !(sc->flags & SC_SCRN_IDLE))
2120 if (sc->flags & SC_SCRN_BLANKED)
2121 stop_scrn_saver(sc, current_saver);
2122 #endif /* NSPLASH */
2123
2124 /* should we just return ? */
2125 if (sc->blink_in_progress || sc->switch_in_progress ||
2126 sc->write_in_progress)
2127 {
2128 syscons_unlock();
2129 if (again)
2130 callout_reset(&sc->scrn_timer_ch, hz / 10, scrn_timer, sc);
2131 return;
2132 }
2133
2134 /* Update the screen */
2135 scp = sc->cur_scp; /* cur_scp may have changed... */
2136 if (!ISGRAPHSC(scp) && !(sc->flags & SC_SCRN_BLANKED))
2137 scrn_update(scp, TRUE, SCRN_ASYNCOK);
2138
2139 #if NSPLASH > 0
2140 /* should we activate the screen saver? */
2141 if ((saver_mode == CONS_LKM_SAVER) && (sc->flags & SC_SCRN_IDLE))
2142 if (!ISGRAPHSC(scp) || (sc->flags & SC_SCRN_BLANKED))
2143 (*current_saver)(sc, TRUE);
2144 #endif /* NSPLASH */
2145
2146 syscons_unlock();
2147 if (again)
2148 callout_reset(&sc->scrn_timer_ch, hz / 25, scrn_timer, sc);
2149 }
2150
2151 static int
2152 and_region(int *s1, int *e1, int s2, int e2)
2153 {
2154 if (*e1 < s2 || e2 < *s1)
2155 return FALSE;
2156 *s1 = imax(*s1, s2);
2157 *e1 = imin(*e1, e2);
2158 return TRUE;
2159 }
2160
2161 /*
2162 * Refresh modified frame buffer range. Also used to
2163 * scroll (entire FB is marked modified).
2164 *
2165 * This function is allowed to run without the syscons_lock,
2166 * so scp fields can change unexpected. We cache most values
2167 * that we care about and silently discard illegal ranges.
2168 */
2169 static void
2170 scrn_update(scr_stat *scp, int show_cursor, int flags)
2171 {
2172 int start;
2173 int end;
2174 int cpos;
2175 int copos;
2176 int s;
2177 int e;
2178 int ddb_active;
2179
2180 #ifdef DDB
2181 ddb_active = db_active;
2182 #else
2183 ddb_active = 0;
2184 #endif
2185
2186 /*
2187 * Try to run large screen updates as an async operation, which will
2188 * call this function again from a thread with BULKUNLOCK set, allowing
2189 * interrupts during the update which tends to make the system behave
2190 * better (no sound glitches, etc).
2191 */
2192 if ((flags & SCRN_ASYNCOK) && syscons_async && scp->asynctd &&
2193 (scp->end - scp->start) > 16 &&
2194 panicstr == NULL && ddb_active == 0 && shutdown_in_progress == 0) {
2195 scp->show_cursor = show_cursor;
2196 scp->queue_update_td = 1;
2197 wakeup(&scp->asynctd);
2198 return;
2199 }
2200 if (flags & SCRN_BULKUNLOCK)
2201 syscons_lock();
2202
2203 /*
2204 * Synchronous operation or called from
2205 */
2206
2207 /* assert(scp == scp->sc->cur_scp) */
2208 atomic_add_int(&scp->sc->videoio_in_progress, 1);
2209
2210 cpos = scp->cursor_pos;
2211 copos = scp->cursor_oldpos;
2212
2213 #ifndef SC_NO_CUTPASTE
2214 /* remove the previous mouse pointer image if necessary */
2215 if (scp->status & MOUSE_VISIBLE) {
2216 s = scp->mouse_pos;
2217 e = scp->mouse_pos + scp->xsize + 1;
2218 if ((scp->status & (MOUSE_MOVED | MOUSE_HIDDEN))
2219 || and_region(&s, &e, scp->start, scp->end)
2220 || ((scp->status & CURSOR_ENABLED) &&
2221 (cpos != copos) &&
2222 (and_region(&s, &e, cpos, cpos)
2223 || and_region(&s, &e, copos, copos)))) {
2224 sc_remove_mouse_image(scp);
2225 if (scp->end >= scp->xsize*scp->ysize)
2226 scp->end = scp->xsize*scp->ysize - 1;
2227 }
2228 }
2229 #endif /* !SC_NO_CUTPASTE */
2230
2231 /*
2232 * WARNING: Don't add debugging kprintf()s with syscons locked.
2233 * Or at all.
2234 */
2235 if (scp->end >= scp->xsize*scp->ysize) {
2236 scp->end = scp->xsize*scp->ysize - 1;
2237 }
2238 if (scp->start < 0) {
2239 scp->start = 0;
2240 }
2241
2242 /*
2243 * Main update, extract update range and reset
2244 * ASAP.
2245 */
2246 start = scp->start;
2247 end = scp->end;
2248 scp->end = 0;
2249 scp->start = scp->xsize * scp->ysize - 1;
2250
2251 if (start <= end) {
2252 if (flags & SCRN_BULKUNLOCK) {
2253 atomic_add_int(&scp->sc->videoio_in_progress, -1);
2254 syscons_unlock();
2255 }
2256 (*scp->rndr->draw)(scp, start, end - start + 1, FALSE);
2257 if (flags & SCRN_BULKUNLOCK) {
2258 syscons_lock();
2259 atomic_add_int(&scp->sc->videoio_in_progress, 1);
2260 }
2261
2262 /*
2263 * Handle cut sequence
2264 */
2265 s = scp->mouse_cut_start;
2266 e = scp->mouse_cut_end;
2267 cpu_ccfence(); /* allowed to race */
2268
2269 if (e >= 0) {
2270 if (s > e) {
2271 int r = s;
2272 s = e;
2273 e = r;
2274 }
2275 /* does the cut-mark region overlap with the update region? */
2276 if (and_region(&s, &e, start, end)) {
2277 if (flags & SCRN_BULKUNLOCK) {
2278 atomic_add_int(&scp->sc->videoio_in_progress, -1);
2279 syscons_unlock();
2280 }
2281 (*scp->rndr->draw)(scp, s, e - s + 1, TRUE);
2282 if (flags & SCRN_BULKUNLOCK) {
2283 syscons_lock();
2284 atomic_add_int(&scp->sc->videoio_in_progress, 1);
2285 }
2286 }
2287 }
2288 }
2289
2290 /* we are not to show the cursor and the mouse pointer... */
2291 if (!show_cursor)
2292 goto cleanup;
2293
2294 /* update cursor image */
2295 if (scp->status & CURSOR_ENABLED) {
2296 s = start;
2297 e = end;
2298 /* did cursor move since last time ? */
2299 if (cpos != copos) {
2300 /* do we need to remove old cursor image ? */
2301 if (!and_region(&s, &e, copos, copos))
2302 sc_remove_cursor_image(scp);
2303 sc_draw_cursor_image(scp);
2304 } else {
2305 if (s <= e && and_region(&s, &e, cpos, cpos)) {
2306 /* cursor didn't move, but has been overwritten */
2307 sc_draw_cursor_image(scp);
2308 } else if (scp->sc->flags & SC_BLINK_CURSOR) {
2309 /* if it's a blinking cursor, update it */
2310 (*scp->rndr->blink_cursor)(scp, cpos,
2311 sc_inside_cutmark(scp, cpos));
2312 }
2313 }
2314 }
2315
2316 #ifndef SC_NO_CUTPASTE
2317 /* update "pseudo" mouse pointer image */
2318 if (scp->sc->flags & SC_MOUSE_ENABLED) {
2319 if (!(scp->status & (MOUSE_VISIBLE | MOUSE_HIDDEN))) {
2320 scp->status &= ~MOUSE_MOVED;
2321 sc_draw_mouse_image(scp);
2322 }
2323 }
2324 #endif /* SC_NO_CUTPASTE */
2325
2326 /*
2327 * Cleanup
2328 */
2329 cleanup:
2330 atomic_add_int(&scp->sc->videoio_in_progress, -1);
2331 if (flags & SCRN_BULKUNLOCK)
2332 syscons_unlock();
2333 }
2334
2335 /*
2336 * Thread handles potentially expensive screen updates. The function is
2337 * expected to operate safely without locks.
2338 */
2339 static void
2340 scrn_update_thread(void *arg)
2341 {
2342 scr_stat *scp = arg;
2343 for (;;) {
2344 if (scp->queue_update_td == 0) {
2345 tsleep_interlock(&scp->asynctd, 0);
2346 if (scp->queue_update_td == 0)
2347 tsleep(&scp->asynctd, PINTERLOCKED, "wait", 0);
2348 }
2349 scp->queue_update_td = 0;
2350 lockmgr(&sc_asynctd_lk, LK_EXCLUSIVE);
2351 atomic_add_int(&scp->sc->videoio_in_progress, 1);
2352 scrn_update(scp, scp->show_cursor, SCRN_BULKUNLOCK);
2353 atomic_add_int(&scp->sc->videoio_in_progress, -1);
2354 lockmgr(&sc_asynctd_lk, LK_RELEASE);
2355 }
2356 }
2357
2358 static void
2359 sc_fb_set_par(void *context, int pending)
2360 {
2361 sc_softc_t *sc = context;
2362 scr_stat *scp = sc->cur_scp;
2363
2364 lwkt_gettoken(&tty_token);
2365 if (ISTEXTSC(scp) &&
2366 sc->fbi != NULL && sc->fbi->fbops.fb_set_par != NULL) {
2367 sc->fbi->fbops.fb_set_par(sc->fbi);
2368 }
2369 lwkt_reltoken(&tty_token);
2370 }
2371
2372 #if NSPLASH > 0
2373 static int
2374 scsplash_callback(int event, void *arg)
2375 {
2376 sc_softc_t *sc;
2377 int error;
2378
2379 sc = (sc_softc_t *)arg;
2380
2381 switch (event) {
2382 case SPLASH_INIT:
2383 if (add_scrn_saver(scsplash_saver) == 0) {
2384 sc->flags &= ~SC_SAVER_FAILED;
2385 run_scrn_saver = TRUE;
2386 if (cold) {
2387 scsplash_stick(TRUE);
2388 (*current_saver)(sc, TRUE);
2389 }
2390 }
2391 return 0;
2392
2393 case SPLASH_TERM:
2394 if (current_saver == scsplash_saver) {
2395 scsplash_stick(FALSE);
2396 error = remove_scrn_saver(scsplash_saver);
2397 if (error) {
2398 return error;
2399 }
2400 }
2401 return 0;
2402
2403 default:
2404 return EINVAL;
2405 }
2406 }
2407
2408 static void
2409 scsplash_saver(sc_softc_t *sc, int show)
2410 {
2411 static int busy = FALSE;
2412 scr_stat *scp;
2413
2414 if (busy)
2415 return;
2416 busy = TRUE;
2417
2418 scp = sc->cur_scp;
2419 if (show) {
2420 if (!(sc->flags & SC_SAVER_FAILED)) {
2421 if (!(sc->flags & SC_SCRN_BLANKED))
2422 set_scrn_saver_mode(scp, -1, NULL, 0);
2423 switch (splash(sc->adp, TRUE)) {
2424 case 0: /* succeeded */
2425 break;
2426 case EAGAIN: /* try later */
2427 restore_scrn_saver_mode(scp, FALSE);
2428 sc_touch_scrn_saver(); /* XXX */
2429 break;
2430 default:
2431 sc->flags |= SC_SAVER_FAILED;
2432 scsplash_stick(FALSE);
2433 restore_scrn_saver_mode(scp, TRUE);
2434 kprintf("scsplash_saver(): failed to put up the image\n");
2435 break;
2436 }
2437 }
2438 } else if (!sticky_splash) {
2439 if ((sc->flags & SC_SCRN_BLANKED) && (splash(sc->adp, FALSE) == 0))
2440 restore_scrn_saver_mode(scp, TRUE);
2441 }
2442 busy = FALSE;
2443 }
2444
2445 static int
2446 add_scrn_saver(void (*this_saver)(sc_softc_t *, int))
2447 {
2448 #if 0
2449 int error;
2450
2451 if (current_saver != none_saver) {
2452 error = remove_scrn_saver(current_saver);
2453 if (error)
2454 return error;
2455 }
2456 #endif
2457 if (current_saver != none_saver) {
2458 return EBUSY;
2459 }
2460
2461 run_scrn_saver = FALSE;
2462 saver_mode = CONS_LKM_SAVER;
2463 current_saver = this_saver;
2464 return 0;
2465 }
2466
2467 static int
2468 remove_scrn_saver(void (*this_saver)(sc_softc_t *, int))
2469 {
2470 if (current_saver != this_saver)
2471 return EINVAL;
2472
2473 #if 0
2474 /*
2475 * In order to prevent `current_saver' from being called by
2476 * the timeout routine `scrn_timer()' while we manipulate
2477 * the saver list, we shall set `current_saver' to `none_saver'
2478 * before stopping the current saver, rather than blocking by `splXX()'.
2479 */
2480 current_saver = none_saver;
2481 if (scrn_blanked)
2482 stop_scrn_saver(this_saver);
2483 #endif
2484 /* unblank all blanked screens */
2485 wait_scrn_saver_stop(NULL);
2486 if (scrn_blanked) {
2487 return EBUSY;
2488 }
2489
2490 current_saver = none_saver;
2491 return 0;
2492 }
2493
2494 static int
2495 set_scrn_saver_mode(scr_stat *scp, int mode, u_char *pal, int border)
2496 {
2497
2498 /* assert(scp == scp->sc->cur_scp) */
2499 crit_enter();
2500 if (!ISGRAPHSC(scp))
2501 sc_remove_cursor_image(scp);
2502 scp->splash_save_mode = scp->mode;
2503 scp->splash_save_status = scp->status & (GRAPHICS_MODE | PIXEL_MODE);
2504 scp->status &= ~(GRAPHICS_MODE | PIXEL_MODE);
2505 scp->status |= (UNKNOWN_MODE | SAVER_RUNNING);
2506 scp->sc->flags |= SC_SCRN_BLANKED;
2507 ++scrn_blanked;
2508 crit_exit();
2509 if (mode < 0) {
2510 return 0;
2511 }
2512 scp->mode = mode;
2513 if (set_mode(scp) == 0) {
2514 if (scp->sc->fbi == NULL &&
2515 scp->sc->adp->va_info.vi_flags & V_INFO_GRAPHICS) {
2516 scp->status |= GRAPHICS_MODE;
2517 }
2518 #ifndef SC_NO_PALETTE_LOADING
2519 if (scp->sc->fbi == NULL && pal != NULL)
2520 load_palette(scp->sc->adp, pal);
2521 #endif
2522 sc_set_border(scp, border);
2523 return 0;
2524 } else {
2525 crit_enter();
2526 scp->mode = scp->splash_save_mode;
2527 scp->status &= ~(UNKNOWN_MODE | SAVER_RUNNING);
2528 scp->status |= scp->splash_save_status;
2529 crit_exit();
2530 return 1;
2531 }
2532 /* NOTREACHED */
2533 }
2534
2535 static int
2536 restore_scrn_saver_mode(scr_stat *scp, int changemode)
2537 {
2538 int mode;
2539 int status;
2540
2541 /* assert(scp == scp->sc->cur_scp) */
2542 crit_enter();
2543 mode = scp->mode;
2544 status = scp->status;
2545 scp->mode = scp->splash_save_mode;
2546 scp->status &= ~(UNKNOWN_MODE | SAVER_RUNNING);
2547 scp->status |= scp->splash_save_status;
2548 scp->sc->flags &= ~SC_SCRN_BLANKED;
2549 if (!changemode) {
2550 if (!ISGRAPHSC(scp))
2551 sc_draw_cursor_image(scp);
2552 --scrn_blanked;
2553 crit_exit();
2554 return 0;
2555 }
2556 if (set_mode(scp) == 0) {
2557 #ifndef SC_NO_PALETTE_LOADING
2558 if (scp->sc->fbi == NULL)
2559 load_palette(scp->sc->adp, scp->sc->palette);
2560 #endif
2561 --scrn_blanked;
2562 crit_exit();
2563 return 0;
2564 } else {
2565 scp->mode = mode;
2566 scp->status = status;
2567 crit_exit();
2568 return 1;
2569 }
2570 /* NOTREACHED */
2571 }
2572
2573 static void
2574 stop_scrn_saver(sc_softc_t *sc, void (*saver)(sc_softc_t *, int))
2575 {
2576 (*saver)(sc, FALSE);
2577 run_scrn_saver = FALSE;
2578 /* the screen saver may have chosen not to stop after all... */
2579 if (sc->flags & SC_SCRN_BLANKED) {
2580 return;
2581 }
2582
2583 mark_all(sc->cur_scp);
2584 if (sc->delayed_next_scr)
2585 sc_switch_scr(sc, sc->delayed_next_scr - 1);
2586 wakeup((caddr_t)&scrn_blanked);
2587 }
2588
2589 static int
2590 wait_scrn_saver_stop(sc_softc_t *sc)
2591 {
2592 int error = 0;
2593
2594 while (scrn_blanked > 0) {
2595 run_scrn_saver = FALSE;
2596 if (sc && !(sc->flags & SC_SCRN_BLANKED)) {
2597 error = 0;
2598 break;
2599 }
2600 error = tsleep((caddr_t)&scrn_blanked, PCATCH, "scrsav", 0);
2601 /* May return ERESTART */
2602 if (error)
2603 break;
2604 }
2605 run_scrn_saver = FALSE;
2606 return error;
2607 }
2608 #endif /* NSPLASH */
2609
2610 void
2611 sc_touch_scrn_saver(void)
2612 {
2613 scsplash_stick(FALSE);
2614 run_scrn_saver = FALSE;
2615 }
2616
2617 int
2618 sc_switch_scr(sc_softc_t *sc, u_int next_scr)
2619 {
2620 scr_stat *cur_scp;
2621 struct tty *tp;
2622
2623 DPRINTF(5, ("sc0: sc_switch_scr() %d ", next_scr + 1));
2624
2625 /* prevent switch if previously requested */
2626 if (sc->flags & SC_SCRN_VTYLOCK) {
2627 sc_bell(sc->cur_scp, sc->cur_scp->bell_pitch,
2628 sc->cur_scp->bell_duration);
2629 return EPERM;
2630 }
2631
2632 /* delay switch if the screen is blanked or being updated */
2633 if ((sc->flags & SC_SCRN_BLANKED) || sc->write_in_progress
2634 || sc->blink_in_progress || sc->videoio_in_progress) {
2635 sc->delayed_next_scr = next_scr + 1;
2636 sc_touch_scrn_saver();
2637 DPRINTF(5, ("switch delayed\n"));
2638 return 0;
2639 }
2640
2641 cur_scp = sc->cur_scp;
2642
2643 /*
2644 * we are in the middle of the vty switching process...
2645 *
2646 * This may be in the console path, be very careful. pfindn() is
2647 * still going to use a spinlock but it no longer uses tokens so
2648 * we should be ok.
2649 */
2650 if (sc->switch_in_progress &&
2651 (cur_scp->smode.mode == VT_PROCESS) &&
2652 cur_scp->proc) {
2653 if (cur_scp->proc != pfindn(cur_scp->pid)) {
2654 /*
2655 * The controlling process has died!!. Do some clean up.
2656 * NOTE:`cur_scp->proc' and `cur_scp->smode.mode'
2657 * are not reset here yet; they will be cleared later.
2658 */
2659 DPRINTF(5, ("cur_scp controlling process %d died, ", cur_scp->pid));
2660 if (cur_scp->status & SWITCH_WAIT_REL) {
2661 /*
2662 * Force the previous switch to finish, but return now
2663 * with error.
2664 *
2665 */
2666 DPRINTF(5, ("reset WAIT_REL, "));
2667 finish_vt_rel(cur_scp, TRUE);
2668 DPRINTF(5, ("finishing previous switch\n"));
2669 return EINVAL;
2670 } else if (cur_scp->status & SWITCH_WAIT_ACQ) {
2671 /* let's assume screen switch has been completed. */
2672 DPRINTF(5, ("reset WAIT_ACQ, "));
2673 finish_vt_acq(cur_scp);
2674 } else {
2675 /*
2676 * We are in between screen release and acquisition, and
2677 * reached here via scgetc() or scrn_timer() which has
2678 * interrupted exchange_scr(). Don't do anything stupid.
2679 */
2680 DPRINTF(5, ("waiting nothing, "));
2681 }
2682 } else {
2683 /*
2684 * The controlling process is alive, but not responding...
2685 * It is either buggy or it may be just taking time.
2686 * The following code is a gross kludge to cope with this
2687 * problem for which there is no clean solution. XXX
2688 */
2689 if (cur_scp->status & SWITCH_WAIT_REL) {
2690 switch (sc->switch_in_progress++) {
2691 case 1:
2692 break;
2693 case 2:
2694 DPRINTF(5, ("sending relsig again, "));
2695 signal_vt_rel(cur_scp);
2696 break;
2697 case 3:
2698 break;
2699 case 4:
2700 default:
2701 /*
2702 * Act as if the controlling program returned
2703 * VT_FALSE.
2704 *
2705 */
2706 DPRINTF(5, ("force reset WAIT_REL, "));
2707 finish_vt_rel(cur_scp, FALSE);
2708 DPRINTF(5, ("act as if VT_FALSE was seen\n"));
2709 return EINVAL;
2710 }
2711 } else if (cur_scp->status & SWITCH_WAIT_ACQ) {
2712 switch (sc->switch_in_progress++) {
2713 case 1:
2714 break;
2715 case 2:
2716 DPRINTF(5, ("sending acqsig again, "));
2717 signal_vt_acq(cur_scp);
2718 break;
2719 case 3:
2720 break;
2721 case 4:
2722 default:
2723 /* clear the flag and finish the previous switch */
2724 DPRINTF(5, ("force reset WAIT_ACQ, "));
2725 finish_vt_acq(cur_scp);
2726 break;
2727 }
2728 }
2729 }
2730 }
2731
2732 /*
2733 * Return error if an invalid argument is given, or vty switch
2734 * is still in progress.
2735 */
2736 if ((next_scr < sc->first_vty) || (next_scr >= sc->first_vty + sc->vtys)
2737 || sc->switch_in_progress) {
2738 sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2739 DPRINTF(5, ("error 1\n"));
2740 return EINVAL;
2741 }
2742
2743 /*
2744 * Don't allow switching away from the graphics mode vty
2745 * if the switch mode is VT_AUTO, unless the next vty is the same
2746 * as the current or the current vty has been closed (but showing).
2747 */
2748 tp = VIRTUAL_TTY(sc, cur_scp->index);
2749 if ((cur_scp->index != next_scr)
2750 && ISTTYOPEN(tp)
2751 && (cur_scp->smode.mode == VT_AUTO)
2752 && ISGRAPHSC(cur_scp)) {
2753 sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2754 DPRINTF(5, ("error, graphics mode\n"));
2755 return EINVAL;
2756 }
2757
2758 /*
2759 * Is the wanted vty open? Don't allow switching to a closed vty.
2760 * If we are in DDB, don't switch to a vty in the VT_PROCESS mode.
2761 * Note that we always allow the user to switch to the kernel
2762 * console even if it is closed.
2763 */
2764 if ((sc_console == NULL) || (next_scr != sc_console->index)) {
2765 tp = VIRTUAL_TTY(sc, next_scr);
2766 if (!ISTTYOPEN(tp)) {
2767 sc_bell(cur_scp, bios_value.bell_pitch, BELL_DURATION);
2768 DPRINTF(5, ("error 2, requested vty isn't open!\n"));
2769 return EINVAL;
2770 }
2771 if ((debugger > 0) && (SC_STAT(tp->t_dev)->smode.mode == VT_PROCESS)) {
2772 DPRINTF(5, ("error 3, requested vty is in the VT_PROCESS mode\n"));
2773 return EINVAL;
2774 }
2775 }
2776
2777 /* this is the start of vty switching process... */
2778 ++sc->switch_in_progress;
2779 sc->delayed_next_scr = 0;
2780 sc->old_scp = cur_scp;
2781 sc->new_scp = SC_STAT(SC_DEV(sc, next_scr));
2782 if (sc->new_scp == sc->old_scp) {
2783 sc->switch_in_progress = 0;
2784 wakeup((caddr_t)&sc->new_scp->smode);
2785 DPRINTF(5, ("switch done (new == old)\n"));
2786 return 0;
2787 }
2788
2789 /* has controlling process died? */
2790 vt_proc_alive(sc->old_scp);
2791 vt_proc_alive(sc->new_scp);
2792
2793 /* wait for the controlling process to release the screen, if necessary */
2794 if (signal_vt_rel(sc->old_scp)) {
2795 return 0;
2796 }
2797
2798 /* go set up the new vty screen */
2799 exchange_scr(sc);
2800
2801 /* wake up processes waiting for this vty */
2802 wakeup((caddr_t)&sc->cur_scp->smode);
2803
2804 /* wait for the controlling process to acknowledge, if necessary */
2805 if (signal_vt_acq(sc->cur_scp)) {
2806 return 0;
2807 }
2808
2809 sc->switch_in_progress = 0;
2810 if (sc->unit == sc_console_unit)
2811 cons_unavail = FALSE;
2812 DPRINTF(5, ("switch done\n"));
2813
2814 return 0;
2815 }
2816
2817 static void
2818 do_switch_scr(sc_softc_t *sc)
2819 {
2820 lwkt_gettoken(&tty_token);
2821 vt_proc_alive(sc->new_scp);
2822
2823 exchange_scr(sc);
2824 /* sc->cur_scp == sc->new_scp */
2825 wakeup((caddr_t)&sc->cur_scp->smode);
2826
2827 /* wait for the controlling process to acknowledge, if necessary */
2828 if (!signal_vt_acq(sc->cur_scp)) {
2829 sc->switch_in_progress = 0;
2830 if (sc->unit == sc_console_unit)
2831 cons_unavail = FALSE;
2832 }
2833 lwkt_reltoken(&tty_token);
2834 }
2835
2836 static int
2837 vt_proc_alive(scr_stat *scp)
2838 {
2839 lwkt_gettoken(&tty_token);
2840 if (scp->proc) {
2841 if (scp->proc == pfindn(scp->pid)) {
2842 lwkt_reltoken(&tty_token);
2843 return TRUE;
2844 }
2845 scp->proc = NULL;
2846 scp->smode.mode = VT_AUTO;
2847 DPRINTF(5, ("vt controlling process %d died\n", scp->pid));
2848 }
2849 lwkt_reltoken(&tty_token);
2850 return FALSE;
2851 }
2852
2853 static int
2854 signal_vt_rel(scr_stat *scp)
2855 {
2856 struct proc *p;
2857
2858 lwkt_gettoken(&tty_token);
2859 if (scp->smode.mode != VT_PROCESS) {
2860 lwkt_reltoken(&tty_token);
2861 return FALSE;
2862 }
2863 scp->status |= SWITCH_WAIT_REL;
2864 p = scp->proc;
2865 PHOLD(p);
2866 ksignal(p, scp->smode.relsig);
2867 PRELE(p);
2868 DPRINTF(5, ("sending relsig to %d\n", scp->pid));
2869 lwkt_reltoken(&tty_token);
2870
2871 return TRUE;
2872 }
2873
2874 static int
2875 signal_vt_acq(scr_stat *scp)
2876 {
2877 struct proc *p;
2878
2879 lwkt_gettoken(&tty_token);
2880 if (scp->smode.mode != VT_PROCESS) {
2881 lwkt_reltoken(&tty_token);
2882 return FALSE;
2883 }
2884 if (scp->sc->unit == sc_console_unit)
2885 cons_unavail = TRUE;
2886 scp->status |= SWITCH_WAIT_ACQ;
2887 p = scp->proc;
2888 PHOLD(p);
2889 ksignal(p, scp->smode.acqsig);
2890 PRELE(p);
2891 DPRINTF(5, ("sending acqsig to %d\n", scp->pid));
2892 lwkt_reltoken(&tty_token);
2893
2894 return TRUE;
2895 }
2896
2897 static int
2898 finish_vt_rel(scr_stat *scp, int release)
2899 {
2900 lwkt_gettoken(&tty_token);
2901 if (scp == scp->sc->old_scp && scp->status & SWITCH_WAIT_REL) {
2902 scp->status &= ~SWITCH_WAIT_REL;
2903 if (release)
2904 do_switch_scr(scp->sc);
2905 else
2906 scp->sc->switch_in_progress = 0;
2907 lwkt_reltoken(&tty_token);
2908 return 0;
2909 }
2910 lwkt_reltoken(&tty_token);
2911 return EINVAL;
2912 }
2913
2914 static int
2915 finish_vt_acq(scr_stat *scp)
2916 {
2917 lwkt_gettoken(&tty_token);
2918 if (scp == scp->sc->new_scp && scp->status & SWITCH_WAIT_ACQ) {
2919 scp->status &= ~SWITCH_WAIT_ACQ;
2920 scp->sc->switch_in_progress = 0;
2921 lwkt_reltoken(&tty_token);
2922 return 0;
2923 }
2924 lwkt_reltoken(&tty_token);
2925 return EINVAL;
2926 }
2927
2928 static void
2929 exchange_scr(sc_softc_t *sc)
2930 {
2931 scr_stat *scp;
2932
2933 lwkt_gettoken(&tty_token);
2934 /* save the current state of video and keyboard */
2935 sc_move_cursor(sc->old_scp, sc->old_scp->xpos, sc->old_scp->ypos);
2936 if (!ISGRAPHSC(sc->old_scp))
2937 sc_remove_cursor_image(sc->old_scp);
2938 if (sc->old_scp->kbd_mode == K_XLATE)
2939 save_kbd_state(sc->old_scp, TRUE);
2940
2941 /* set up the video for the new screen */
2942 scp = sc->cur_scp = sc->new_scp;
2943 if (sc->old_scp->mode != scp->mode || ISUNKNOWNSC(sc->old_scp))
2944 set_mode(scp);
2945 else if (sc->adp != NULL)
2946 sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
2947 (void *)sc->adp->va_window, FALSE);
2948 scp->status |= MOUSE_HIDDEN;
2949 sc_update_render(scp); /* Switch to kms renderer if necessary */
2950 sc_move_cursor(scp, scp->xpos, scp->ypos);
2951 if (!ISGRAPHSC(scp))
2952 sc_set_cursor_image(scp);
2953 #ifndef SC_NO_PALETTE_LOADING
2954 if (sc->fbi == NULL && ISGRAPHSC(sc->old_scp))
2955 load_palette(sc->adp, sc->palette);
2956 #endif
2957 sc_set_border(scp, scp->border);
2958
2959 /* set up the keyboard for the new screen */
2960 if (sc->old_scp->kbd_mode != scp->kbd_mode)
2961 kbd_ioctl(sc->kbd, KDSKBMODE, (caddr_t)&scp->kbd_mode);
2962 update_kbd_state(scp, scp->status, LOCK_MASK, TRUE);
2963
2964 mark_all(scp);
2965
2966 /*
2967 * Restore DRM framebuffer console mode if necessary.
2968 * Especially avoid modesetting when switching to a vt which is in
2969 * graphics mode, because the fb_set_par() from the taskqueue thread
2970 * might race with the modesetting ioctl from the userland application.
2971 */
2972 if (ISTEXTSC(scp) && !ISTEXTSC(sc->old_scp) &&
2973 sc->fbi != NULL && sc->fbi->fbops.fb_set_par != NULL &&
2974 sc->fb_set_par_task != NULL) {
2975 taskqueue_enqueue(taskqueue_thread[0], sc->fb_set_par_task);
2976 }
2977
2978 lwkt_reltoken(&tty_token);
2979 }
2980
2981 static void
2982 sc_puts(scr_stat *scp, u_char *buf, int len)
2983 {
2984 #if NSPLASH > 0
2985 /* make screensaver happy */
2986 if (!sticky_splash && scp == scp->sc->cur_scp)
2987 run_scrn_saver = FALSE;
2988 #endif
2989
2990 if (scp->tsw)
2991 (*scp->tsw->te_puts)(scp, buf, len);
2992
2993 if (scp->sc->delayed_next_scr)
2994 sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1);
2995
2996 }
2997
2998 void
2999 sc_draw_cursor_image(scr_stat *scp)
3000 {
3001 /* assert(scp == scp->sc->cur_scp); */
3002 atomic_add_int(&scp->sc->videoio_in_progress, 1);
3003 (*scp->rndr->draw_cursor)(scp, scp->cursor_pos,
3004 scp->sc->flags & SC_BLINK_CURSOR, TRUE,
3005 sc_inside_cutmark(scp, scp->cursor_pos));
3006 scp->cursor_oldpos = scp->cursor_pos;
3007 atomic_add_int(&scp->sc->videoio_in_progress, -1);
3008 }
3009
3010 void
3011 sc_remove_cursor_image(scr_stat *scp)
3012 {
3013 /* assert(scp == scp->sc->cur_scp); */
3014 atomic_add_int(&scp->sc->videoio_in_progress, 1);
3015 (*scp->rndr->draw_cursor)(scp, scp->cursor_oldpos,
3016 scp->sc->flags & SC_BLINK_CURSOR, FALSE,
3017 sc_inside_cutmark(scp, scp->cursor_oldpos));
3018 atomic_add_int(&scp->sc->videoio_in_progress, -1);
3019 }
3020
3021 static void
3022 update_cursor_image(scr_stat *scp)
3023 {
3024 int blink;
3025
3026 if (scp->sc->flags & SC_CHAR_CURSOR) {
3027 scp->cursor_base = imax(0, scp->sc->cursor_base);
3028 scp->cursor_height = imin(scp->sc->cursor_height, scp->font_height);
3029 } else {
3030 scp->cursor_base = 0;
3031 scp->cursor_height = scp->font_height;
3032 }
3033 blink = scp->sc->flags & SC_BLINK_CURSOR;
3034
3035 /* assert(scp == scp->sc->cur_scp); */
3036 atomic_add_int(&scp->sc->videoio_in_progress, 1);
3037 (*scp->rndr->draw_cursor)(scp, scp->cursor_oldpos, blink, FALSE,
3038 sc_inside_cutmark(scp, scp->cursor_pos));
3039 (*scp->rndr->set_cursor)(scp, scp->cursor_base, scp->cursor_height, blink);
3040 (*scp->rndr->draw_cursor)(scp, scp->cursor_pos, blink, TRUE,
3041 sc_inside_cutmark(scp, scp->cursor_pos));
3042 atomic_add_int(&scp->sc->videoio_in_progress, -1);
3043 }
3044
3045 void
3046 sc_set_cursor_image(scr_stat *scp)
3047 {
3048 if (scp->sc->flags & SC_CHAR_CURSOR) {
3049 scp->cursor_base = imax(0, scp->sc->cursor_base);
3050 scp->cursor_height = imin(scp->sc->cursor_height, scp->font_height);
3051 } else {
3052 scp->cursor_base = 0;
3053 scp->cursor_height = scp->font_height;
3054 }
3055
3056 /* assert(scp == scp->sc->cur_scp); */
3057 atomic_add_int(&scp->sc->videoio_in_progress, 1);
3058 (*scp->rndr->set_cursor)(scp, scp->cursor_base, scp->cursor_height,
3059 scp->sc->flags & SC_BLINK_CURSOR);
3060 atomic_add_int(&scp->sc->videoio_in_progress, -1);
3061 }
3062
3063 static void
3064 scinit(int unit, int flags)
3065 {
3066 /*
3067 * When syscons is being initialized as the kernel console, malloc()
3068 * is not yet functional, because various kernel structures has not been
3069 * fully initialized yet. Therefore, we need to declare the following
3070 * static buffers for the console. This is less than ideal,
3071 * but is necessry evil for the time being. XXX
3072 */
3073 static scr_stat main_console;
3074 static u_short sc_buffer[ROW*COL]; /* XXX */
3075 #ifndef SC_NO_FONT_LOADING
3076 static u_char font_8[256*8];
3077 static u_char font_14[256*14];
3078 static u_char font_16[256*16];
3079 #endif
3080
3081 sc_softc_t *sc;
3082 scr_stat *scp;
3083 video_adapter_t *adp;
3084 int col;
3085 int row;
3086 int i;
3087
3088 /* one time initialization */
3089 if (init_done == COLD)
3090 sc_get_bios_values(&bios_value);
3091 init_done = WARM;
3092
3093 /*
3094 * Allocate resources. Even if we are being called for the second
3095 * time, we must allocate them again, because they might have
3096 * disappeared...
3097 */
3098 sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
3099 adp = NULL;
3100 if (flags & SC_EFI_FB) {
3101 /* Don't replace already registered drm framebuffer here */
3102 if (sc->fbi == NULL) {
3103 sc->fbi = &efi_fb_info;
3104 sc->fbi_generation++;
3105 }
3106 } else if (sc->adapter >= 0) {
3107 vid_release(sc->adp, (void *)&sc->adapter);
3108 adp = sc->adp;
3109 }
3110 sc->adp = NULL;
3111 if (sc->keyboard >= 0) {
3112 DPRINTF(5, ("sc%d: releasing kbd%d\n", unit, sc->keyboard));
3113 i = kbd_release(sc->kbd, (void *)&sc->keyboard);
3114 DPRINTF(5, ("sc%d: kbd_release returned %d\n", unit, i));
3115 if (sc->kbd != NULL) {
3116 DPRINTF(5, ("sc%d: kbd != NULL!, index:%d, unit:%d, flags:0x%x\n",
3117 unit, sc->kbd->kb_index, sc->kbd->kb_unit, sc->kbd->kb_flags));
3118 }
3119 sc->kbd = NULL;
3120 }
3121 if (!(flags & SC_EFI_FB)) {
3122 sc->adapter = vid_allocate("*", unit, (void *)&sc->adapter);
3123 sc->adp = vid_get_adapter(sc->adapter);
3124 /* assert((sc->adapter >= 0) && (sc->adp != NULL)) */
3125 }
3126 sc->keyboard = sc_allocate_keyboard(sc, unit);
3127 DPRINTF(1, ("sc%d: keyboard %d\n", unit, sc->keyboard));
3128 sc->kbd = kbd_get_keyboard(sc->keyboard);
3129 if (sc->kbd != NULL) {
3130 DPRINTF(1, ("sc%d: kbd index:%d, unit:%d, flags:0x%x\n",
3131 unit, sc->kbd->kb_index, sc->kbd->kb_unit, sc->kbd->kb_flags));
3132 }
3133
3134 if (!(sc->flags & SC_INIT_DONE) || (adp != sc->adp)) {
3135
3136 if (sc->fbi != NULL)
3137 sc->initial_mode = 0;
3138 else
3139 sc->initial_mode = sc->adp->va_initial_mode;
3140
3141 #ifndef SC_NO_FONT_LOADING
3142 if (flags & SC_KERNEL_CONSOLE) {
3143 sc->font_8 = font_8;
3144 sc->font_14 = font_14;
3145 sc->font_16 = font_16;
3146 } else if (sc->font_8 == NULL) {
3147 /* assert(sc_malloc) */
3148 sc->font_8 = kmalloc(sizeof(font_8), M_SYSCONS, M_WAITOK);
3149 sc->font_14 = kmalloc(sizeof(font_14), M_SYSCONS, M_WAITOK);
3150 sc->font_16 = kmalloc(sizeof(font_16), M_SYSCONS, M_WAITOK);
3151 }
3152 #endif
3153
3154 if (sc->fbi != NULL) {
3155 col = 0;
3156 row = 0;
3157 } else {
3158 lwkt_gettoken(&tty_token);
3159 /* extract the hw cursor location and hide the cursor for now */
3160 (*vidsw[sc->adapter]->read_hw_cursor)(sc->adp, &col, &row);
3161 (*vidsw[sc->adapter]->set_hw_cursor)(sc->adp, -1, -1);
3162 lwkt_reltoken(&tty_token);
3163 }
3164
3165 /* set up the first console */
3166 sc->first_vty = unit*MAXCONS;
3167 sc->vtys = MAXCONS; /* XXX: should be configurable */
3168 if (flags & SC_KERNEL_CONSOLE) {
3169 scp = &main_console;
3170 sc->console_scp = scp;
3171 init_scp(sc, sc->first_vty, scp);
3172 sc_vtb_init(&scp->vtb, VTB_MEMORY, scp->xsize, scp->ysize,
3173 (void *)sc_buffer, FALSE);
3174 if (sc_init_emulator(scp, SC_DFLT_TERM))
3175 sc_init_emulator(scp, "*");
3176 (*scp->tsw->te_default_attr)(scp,
3177 kernel_default.std_color,
3178 kernel_default.rev_color);
3179 } else {
3180 /* assert(sc_malloc) */
3181 sc->dev = kmalloc(sizeof(cdev_t)*sc->vtys, M_SYSCONS, M_WAITOK | M_ZERO);
3182
3183 sc->dev[0] = make_dev(&sc_ops, unit*MAXCONS, UID_ROOT,
3184 GID_WHEEL, 0600, "ttyv%r", unit*MAXCONS);
3185
3186 sc->dev[0]->si_tty = ttymalloc(sc->dev[0]->si_tty);
3187 scp = alloc_scp(sc, sc->first_vty);
3188 sc->dev[0]->si_drv1 = scp;
3189 }
3190 sc->cur_scp = scp;
3191
3192 /* copy screen to temporary buffer */
3193 if (scp->sc->fbi == NULL) {
3194 sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
3195 (void *)scp->sc->adp->va_window, FALSE);
3196 if (ISTEXTSC(scp))
3197 sc_vtb_copy(&scp->scr, 0, &scp->vtb, 0, scp->xsize*scp->ysize);
3198 }
3199
3200 /* move cursors to the initial positions */
3201 if (col >= scp->xsize)
3202 col = 0;
3203 if (row >= scp->ysize)
3204 row = scp->ysize - 1;
3205 scp->xpos = col;
3206 scp->ypos = row;
3207 if (sc->fbi != NULL) {
3208 scp->cursor_pos = 0;
3209 sc->cursor_base = 0;
3210 sc->cursor_height = scp->font_height;
3211 } else {
3212 scp->cursor_pos = scp->cursor_oldpos = row*scp->xsize + col;
3213 if (bios_value.cursor_end < scp->font_height)
3214 sc->cursor_base = scp->font_height - bios_value.cursor_end - 1;
3215 else
3216 sc->cursor_base = 0;
3217 i = bios_value.cursor_end - bios_value.cursor_start + 1;
3218 sc->cursor_height = imin(i, scp->font_height);
3219 }
3220 #ifndef SC_NO_SYSMOUSE
3221 sc_mouse_move(scp, scp->xpixel/2, scp->ypixel/2);
3222 #endif
3223 if (!ISGRAPHSC(scp)) {
3224 sc_set_cursor_image(scp);
3225 sc_draw_cursor_image(scp);
3226 /* If framebuffer vaddr is still 0, we can't draw the border yet */
3227 if (scp->sc->fbi != NULL && scp->sc->fbi->vaddr != 0) {
3228 sc_filled_border = TRUE;
3229 sc_set_border(scp, scp->border);
3230 }
3231 }
3232
3233 /* save font and palette */
3234 #ifndef SC_NO_FONT_LOADING
3235 sc->fonts_loaded = 0;
3236 #ifdef SC_DFLT_FONT
3237 bcopy(dflt_font_8, sc->font_8, sizeof(dflt_font_8));
3238 bcopy(dflt_font_14, sc->font_14, sizeof(dflt_font_14));
3239 bcopy(dflt_font_16, sc->font_16, sizeof(dflt_font_16));
3240 sc->fonts_loaded = FONT_16 | FONT_14 | FONT_8;
3241 #endif /* SC_DFLT_FONT */
3242 if (sc->adp != NULL && ISFONTAVAIL(sc->adp->va_flags)) {
3243 #ifdef SC_DFLT_FONT
3244 if (scp->font_height < 14) {
3245 sc_load_font(scp, 0, 8, sc->font_8, 0, 256);
3246 } else if (scp->font_height >= 16) {
3247 sc_load_font(scp, 0, 16, sc->font_16, 0, 256);
3248 } else {
3249 sc_load_font(scp, 0, 14, sc->font_14, 0, 256);
3250 }
3251 #else /* !SC_DFLT_FONT */
3252 if (scp->font_height < 14) {
3253 sc_save_font(scp, 0, 8, sc->font_8, 0, 256);
3254 sc->fonts_loaded = FONT_8;
3255 } else if (scp->font_height >= 16) {
3256 sc_save_font(scp, 0, 16, sc->font_16, 0, 256);
3257 sc->fonts_loaded = FONT_16;
3258 } else {
3259 sc_save_font(scp, 0, 14, sc->font_14, 0, 256);
3260 sc->fonts_loaded = FONT_14;
3261 }
3262 #endif /* SC_DFLT_FONT */
3263 /* FONT KLUDGE: always use the font page #0. XXX */
3264 sc_show_font(scp, 0);
3265 }
3266 #endif /* !SC_NO_FONT_LOADING */
3267
3268 #ifndef SC_NO_PALETTE_LOADING
3269 if (!(flags & SC_EFI_FB))
3270 save_palette(sc->adp, sc->palette);
3271 #endif
3272
3273 #if NSPLASH > 0
3274 if (!(sc->flags & SC_SPLASH_SCRN) && (flags & SC_KERNEL_CONSOLE)) {
3275 /* we are ready to put up the splash image! */
3276 splash_init(sc->adp, scsplash_callback, sc);
3277 sc->flags |= SC_SPLASH_SCRN;
3278 }
3279 #endif /* NSPLASH */
3280 }
3281
3282 /* the rest is not necessary, if we have done it once */
3283 if (sc->flags & SC_INIT_DONE) {
3284 return;
3285 }
3286
3287 /* initialize mapscrn arrays to a one to one map */
3288 for (i = 0; i < sizeof(sc->scr_map); i++)
3289 sc->scr_map[i] = sc->scr_rmap[i] = i;
3290
3291 sc->flags |= SC_INIT_DONE;
3292 }
3293
3294 static void
3295 scterm(int unit, int flags)
3296 {
3297 sc_softc_t *sc;
3298 scr_stat *scp;
3299
3300 sc = sc_get_softc(unit, flags & SC_KERNEL_CONSOLE);
3301 if (sc == NULL)
3302 return; /* shouldn't happen */
3303
3304 lwkt_gettoken(&tty_token);
3305 #if NSPLASH > 0
3306 /* this console is no longer available for the splash screen */
3307 if (sc->flags & SC_SPLASH_SCRN) {
3308 splash_term(sc->adp);
3309 sc->flags &= ~SC_SPLASH_SCRN;
3310 }
3311 #endif /* NSPLASH */
3312
3313 #if 0 /* XXX */
3314 /* move the hardware cursor to the upper-left corner */
3315 (*vidsw[sc->adapter]->set_hw_cursor)(sc->adp, 0, 0);
3316 #endif
3317
3318 /* release the keyboard and the video card */
3319 if (sc->keyboard >= 0)
3320 kbd_release(sc->kbd, &sc->keyboard);
3321 if (sc->adapter >= 0)
3322 vid_release(sc->adp, &sc->adapter);
3323
3324 /*
3325 * Stop the terminal emulator, if any. If operating on the
3326 * kernel console sc->dev may not be setup yet.
3327 */
3328 if (flags & SC_KERNEL_CONSOLE)
3329 scp = sc->console_scp;
3330 else
3331 scp = SC_STAT(sc->dev[0]);
3332 if (scp->tsw)
3333 (*scp->tsw->te_term)(scp, &scp->ts);
3334 if (scp->ts != NULL)
3335 kfree(scp->ts, M_SYSCONS);
3336
3337 /* clear the structure */
3338 if (!(flags & SC_KERNEL_CONSOLE)) {
3339 /* XXX: We need delete_dev() for this */
3340 kfree(sc->dev, M_SYSCONS);
3341 #if 0
3342 /* XXX: We need a ttyunregister for this */
3343 kfree(sc->tty, M_SYSCONS);
3344 #endif
3345 #ifndef SC_NO_FONT_LOADING
3346 kfree(sc->font_8, M_SYSCONS);
3347 kfree(sc->font_14, M_SYSCONS);
3348 kfree(sc->font_16, M_SYSCONS);
3349 #endif
3350 /* XXX vtb, history */
3351 }
3352 bzero(sc, sizeof(*sc));
3353 sc->keyboard = -1;
3354 sc->adapter = -1;
3355 lwkt_reltoken(&tty_token);
3356 }
3357
3358 static void
3359 scshutdown(void *arg, int howto)
3360 {
3361 /* assert(sc_console != NULL) */
3362
3363 lwkt_gettoken(&tty_token);
3364 syscons_lock();
3365 sc_touch_scrn_saver();
3366 if (!cold && sc_console
3367 && sc_console->sc->cur_scp->smode.mode == VT_AUTO
3368 && sc_console->smode.mode == VT_AUTO) {
3369 sc_switch_scr(sc_console->sc, sc_console->index);
3370 }
3371 shutdown_in_progress = TRUE;
3372 syscons_unlock();
3373 lwkt_reltoken(&tty_token);
3374 }
3375
3376 int
3377 sc_clean_up(scr_stat *scp)
3378 {
3379 #if NSPLASH > 0
3380 int error;
3381 #endif /* NSPLASH */
3382
3383 lwkt_gettoken(&tty_token);
3384 if (scp->sc->flags & SC_SCRN_BLANKED) {
3385 sc_touch_scrn_saver();
3386 #if NSPLASH > 0
3387 if ((error = wait_scrn_saver_stop(scp->sc))) {
3388 lwkt_reltoken(&tty_token);
3389 return error;
3390 }
3391 #endif /* NSPLASH */
3392 }
3393 scp->status |= MOUSE_HIDDEN;
3394 sc_remove_mouse_image(scp);
3395 sc_remove_cutmarking(scp);
3396 lwkt_reltoken(&tty_token);
3397 return 0;
3398 }
3399
3400 void
3401 sc_alloc_scr_buffer(scr_stat *scp, int wait, int discard)
3402 {
3403 sc_vtb_t new;
3404 sc_vtb_t old;
3405
3406 lwkt_gettoken(&tty_token);
3407 old = scp->vtb;
3408 sc_vtb_init(&new, VTB_MEMORY, scp->xsize, scp->ysize, NULL, wait);
3409 if (!discard && (old.vtb_flags & VTB_VALID)) {
3410 /* retain the current cursor position and buffer contants */
3411 scp->cursor_oldpos = scp->cursor_pos;
3412 /*
3413 * This works only if the old buffer has the same size as or larger
3414 * than the new one. XXX
3415 */
3416 sc_vtb_copy(&old, 0, &new, 0, scp->xsize*scp->ysize);
3417 scp->vtb = new;
3418 } else {
3419 scp->vtb = new;
3420 sc_vtb_destroy(&old);
3421 }
3422
3423 #ifndef SC_NO_SYSMOUSE
3424 /* move the mouse cursor at the center of the screen */
3425 sc_mouse_move(scp, scp->xpixel / 2, scp->ypixel / 2);
3426 #endif
3427 lwkt_reltoken(&tty_token);
3428 }
3429
3430 static scr_stat *
3431 alloc_scp(sc_softc_t *sc, int vty)
3432 {
3433 scr_stat *scp;
3434
3435 /* assert(sc_malloc) */
3436
3437 scp = kmalloc(sizeof(scr_stat), M_SYSCONS, M_WAITOK);
3438 init_scp(sc, vty, scp);
3439
3440 sc_alloc_scr_buffer(scp, TRUE, TRUE);
3441 if (sc_init_emulator(scp, SC_DFLT_TERM))
3442 sc_init_emulator(scp, "*");
3443
3444 #ifndef SC_NO_CUTPASTE
3445 sc_alloc_cut_buffer(scp, TRUE);
3446 #endif
3447
3448 #ifndef SC_NO_HISTORY
3449 sc_alloc_history_buffer(scp, 0, 0, TRUE);
3450 #endif
3451 return scp;
3452 }
3453
3454 /*
3455 * NOTE: Must be called with tty_token held.
3456 */
3457 static void
3458 init_scp(sc_softc_t *sc, int vty, scr_stat *scp)
3459 {
3460 video_info_t info;
3461
3462 bzero(scp, sizeof(*scp));
3463
3464 scp->index = vty;
3465 scp->sc = sc;
3466 scp->status = 0;
3467 scp->mode = sc->initial_mode;
3468 scp->fbi_generation = sc->fbi_generation;
3469 callout_init_mp(&scp->blink_screen_ch);
3470 if (scp->sc->fbi == NULL) {
3471 lwkt_gettoken(&tty_token);
3472 (*vidsw[sc->adapter]->get_info)(sc->adp, scp->mode, &info);
3473 lwkt_reltoken(&tty_token);
3474 }
3475 if (scp->sc->fbi != NULL) {
3476 scp->xpixel = sc->fbi->width;
3477 scp->ypixel = sc->fbi->height;
3478 scp->font_width = 8;
3479 scp->font_height = 16;
3480
3481 /* The first vty uses a statically allocated 80x25 buffer */
3482 if (vty == sc->first_vty)
3483 sc_font_scale(scp, 80, 25);
3484 else
3485 sc_font_scale(scp, 0, 0);
3486
3487 #ifndef SC_NO_FONT_LOADING
3488 scp->font = sc->font_16;
3489 #else
3490 scp->font = NULL;
3491 #endif
3492 } else if (info.vi_flags & V_INFO_GRAPHICS) {
3493 scp->status |= GRAPHICS_MODE;
3494 scp->xpixel = info.vi_width;
3495 scp->ypixel = info.vi_height;
3496 scp->xsize = info.vi_width/8;
3497 scp->ysize = info.vi_height/info.vi_cheight;
3498 scp->font_height = 0;
3499 scp->font_width = 0;
3500 scp->font = NULL;
3501 } else {
3502 scp->xsize = info.vi_width;
3503 scp->ysize = info.vi_height;
3504 scp->xpixel = scp->xsize*8;
3505 scp->ypixel = scp->ysize*info.vi_cheight;
3506 scp->font_width = 8;
3507 if (info.vi_cheight < 14) {
3508 scp->font_height = 8;
3509 #ifndef SC_NO_FONT_LOADING
3510 scp->font = sc->font_8;
3511 #else
3512 scp->font = NULL;
3513 #endif
3514 } else if (info.vi_cheight >= 16) {
3515 scp->font_height = 16;
3516 #ifndef SC_NO_FONT_LOADING
3517 scp->font = sc->font_16;
3518 #else
3519 scp->font = NULL;
3520 #endif
3521 } else {
3522 scp->font_height = 14;
3523 #ifndef SC_NO_FONT_LOADING
3524 scp->font = sc->font_14;
3525 #else
3526 scp->font = NULL;
3527 #endif
3528 }
3529 }
3530 scp->xoff = scp->yoff = 0;
3531 scp->xpos = scp->ypos = 0;
3532 sc_vtb_init(&scp->vtb, VTB_MEMORY, 0, 0, NULL, FALSE);
3533 sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, 0, 0, NULL, FALSE);
3534 scp->start = scp->xsize * scp->ysize - 1;
3535 scp->end = 0;
3536 scp->tsw = NULL;
3537 scp->ts = NULL;
3538 scp->rndr = NULL;
3539 scp->border = SC_BORDER_COLOR;
3540 scp->cursor_base = sc->cursor_base;
3541 scp->cursor_height = imin(sc->cursor_height, scp->font_height);
3542 scp->mouse_cut_start = scp->xsize * scp->ysize;
3543 scp->mouse_cut_end = -1;
3544 scp->mouse_signal = 0;
3545 scp->mouse_pid = 0;
3546 scp->mouse_proc = NULL;
3547 scp->kbd_mode = K_XLATE;
3548 scp->bell_pitch = bios_value.bell_pitch;
3549 scp->bell_duration = BELL_DURATION;
3550 scp->status |= (bios_value.shift_state & NLKED);
3551 scp->status |= CURSOR_ENABLED | MOUSE_HIDDEN;
3552 scp->pid = 0;
3553 scp->proc = NULL;
3554 scp->smode.mode = VT_AUTO;
3555 scp->history = NULL;
3556 scp->history_pos = 0;
3557 scp->history_size = 0;
3558 }
3559
3560 int
3561 sc_init_emulator(scr_stat *scp, char *name)
3562 {
3563 sc_term_sw_t *sw;
3564 sc_rndr_sw_t *rndr;
3565 void *p;
3566 int error;
3567
3568 if (name == NULL) /* if no name is given, use the current emulator */
3569 sw = scp->tsw;
3570 else /* ...otherwise find the named emulator */
3571 sw = sc_term_match(name);
3572 if (sw == NULL) {
3573 return EINVAL;
3574 }
3575
3576 rndr = NULL;
3577 if (strcmp(sw->te_renderer, "*") != 0) {
3578 rndr = sc_render_match(scp, sw->te_renderer, scp->model);
3579 }
3580 if (rndr == NULL && scp->sc->fbi != NULL) {
3581 rndr = sc_render_match(scp, "kms", scp->model);
3582 }
3583 if (rndr == NULL) {
3584 rndr = sc_render_match(scp, scp->sc->adp->va_name, scp->model);
3585 if (rndr == NULL) {
3586 return ENODEV;
3587 }
3588 }
3589
3590 if (sw == scp->tsw) {
3591 error = (*sw->te_init)(scp, &scp->ts, SC_TE_WARM_INIT);
3592 scp->rndr = rndr;
3593 sc_clear_screen(scp);
3594 /* assert(error == 0); */
3595 return error;
3596 }
3597
3598 if (sc_malloc && (sw->te_size > 0))
3599 p = kmalloc(sw->te_size, M_SYSCONS, M_NOWAIT);
3600 else
3601 p = NULL;
3602 error = (*sw->te_init)(scp, &p, SC_TE_COLD_INIT);
3603 if (error) {
3604 return error;
3605 }
3606
3607 if (scp->tsw)
3608 (*scp->tsw->te_term)(scp, &scp->ts);
3609 if (scp->ts != NULL)
3610 kfree(scp->ts, M_SYSCONS);
3611 scp->tsw = sw;
3612 scp->ts = p;
3613 scp->rndr = rndr;
3614
3615 /* XXX */
3616 (*sw->te_default_attr)(scp, user_default.std_color, user_default.rev_color);
3617 sc_clear_screen(scp);
3618
3619 return 0;
3620 }
3621
3622 /*
3623 * scgetc(flags) - get character from keyboard.
3624 * If flags & SCGETC_CN, then avoid harmful side effects.
3625 * If flags & SCGETC_NONBLOCK, then wait until a key is pressed, else
3626 * return NOKEY if there is nothing there.
3627 */
3628 static u_int
3629 scgetc(sc_softc_t *sc, u_int flags)
3630 {
3631 scr_stat *scp;
3632 #ifndef SC_NO_HISTORY
3633 struct tty *tp;
3634 #endif
3635 u_int c;
3636 int this_scr;
3637 int f;
3638 int i;
3639
3640 lwkt_gettoken(&tty_token);
3641 if (sc->kbd == NULL) {
3642 lwkt_reltoken(&tty_token);
3643 return NOKEY;
3644 }
3645
3646 next_code:
3647 #if 1
3648 /* I don't like this, but... XXX */
3649 if (flags & SCGETC_CN) {
3650 syscons_lock();
3651 sccnupdate(sc->cur_scp);
3652 syscons_unlock();
3653 }
3654 #endif
3655 scp = sc->cur_scp;
3656 /* first see if there is something in the keyboard port */
3657 for (;;) {
3658 c = kbd_read_char(sc->kbd, !(flags & SCGETC_NONBLOCK));
3659 if (c == ERRKEY) {
3660 if (!(flags & SCGETC_CN))
3661 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3662 } else if (c == NOKEY) {
3663 lwkt_reltoken(&tty_token);
3664 return c;
3665 } else {
3666 break;
3667 }
3668 }
3669
3670 /* make screensaver happy */
3671 if (!(c & RELKEY))
3672 sc_touch_scrn_saver();
3673
3674 if (!(flags & SCGETC_CN))
3675 /* do the /dev/random device a favour */
3676 add_keyboard_randomness(c);
3677
3678 if (scp->kbd_mode != K_XLATE) {
3679 lwkt_reltoken(&tty_token);
3680 return KEYCHAR(c);
3681 }
3682
3683 /* if scroll-lock pressed allow history browsing */
3684 if (!ISGRAPHSC(scp) && scp->history && scp->status & SLKED) {
3685
3686 scp->status &= ~CURSOR_ENABLED;
3687 sc_remove_cursor_image(scp);
3688
3689 #ifndef SC_NO_HISTORY
3690 if (!(scp->status & BUFFER_SAVED)) {
3691 scp->status |= BUFFER_SAVED;
3692 sc_hist_save(scp);
3693 }
3694 switch (c) {
3695 /* FIXME: key codes */
3696 case SPCLKEY | FKEY | F(49): /* home key */
3697 sc_remove_cutmarking(scp);
3698 sc_hist_home(scp);
3699 goto next_code;
3700
3701 case SPCLKEY | FKEY | F(57): /* end key */
3702 sc_remove_cutmarking(scp);
3703 sc_hist_end(scp);
3704 goto next_code;
3705
3706 case SPCLKEY | FKEY | F(50): /* up arrow key */
3707 sc_remove_cutmarking(scp);
3708 if (sc_hist_up_line(scp))
3709 if (!(flags & SCGETC_CN))
3710 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3711 goto next_code;
3712
3713 case SPCLKEY | FKEY | F(58): /* down arrow key */
3714 sc_remove_cutmarking(scp);
3715 if (sc_hist_down_line(scp))
3716 if (!(flags & SCGETC_CN))
3717 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3718 goto next_code;
3719
3720 case SPCLKEY | FKEY | F(51): /* page up key */
3721 sc_remove_cutmarking(scp);
3722 for (i=0; i<scp->ysize; i++) {
3723 if (sc_hist_up_line(scp)) {
3724 if (!(flags & SCGETC_CN))
3725 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3726 break;
3727 }
3728 }
3729 goto next_code;
3730
3731 case SPCLKEY | FKEY | F(59): /* page down key */
3732 sc_remove_cutmarking(scp);
3733 for (i=0; i<scp->ysize; i++) {
3734 if (sc_hist_down_line(scp)) {
3735 if (!(flags & SCGETC_CN))
3736 sc_bell(scp, bios_value.bell_pitch, BELL_DURATION);
3737 break;
3738 }
3739 }
3740 goto next_code;
3741 }
3742 #endif /* SC_NO_HISTORY */
3743 }
3744
3745 /*
3746 * Process and consume special keys here. Return a plain char code
3747 * or a char code with the META flag or a function key code.
3748 */
3749 if (c & RELKEY) {
3750 /* key released */
3751 /* goto next_code */
3752 } else {
3753 /* key pressed */
3754 if (c & SPCLKEY) {
3755 c &= ~SPCLKEY;
3756 switch (KEYCHAR(c)) {
3757 /* LOCKING KEYS */
3758 case NLK: case CLK: case ALK:
3759 break;
3760 case SLK:
3761 kbd_ioctl(sc->kbd, KDGKBSTATE, (caddr_t)&f);
3762 if (f & SLKED) {
3763 scp->status |= SLKED;
3764 } else {
3765 if (scp->status & SLKED) {
3766 scp->status &= ~SLKED;
3767 #ifndef SC_NO_HISTORY
3768 if (scp->status & BUFFER_SAVED) {
3769 if (!sc_hist_restore(scp))
3770 sc_remove_cutmarking(scp);
3771 scp->status &= ~BUFFER_SAVED;
3772 scp->status |= CURSOR_ENABLED;
3773 sc_draw_cursor_image(scp);
3774 }
3775 tp = VIRTUAL_TTY(sc, scp->index);
3776 if (ISTTYOPEN(tp))
3777 scstart(tp);
3778 #endif
3779 }
3780 }
3781 break;
3782
3783 /* NON-LOCKING KEYS */
3784 case NOP:
3785 case LSH: case RSH: case LCTR: case RCTR:
3786 case LALT: case RALT: case ASH: case META:
3787 break;
3788
3789 case BTAB:
3790 if (!(sc->flags & SC_SCRN_BLANKED)) {
3791 lwkt_reltoken(&tty_token);
3792 return c;
3793 }
3794 break;
3795
3796 case SPSC:
3797 #if NSPLASH > 0
3798 /* force activatation/deactivation of the screen saver */
3799 if (!(sc->flags & SC_SCRN_BLANKED)) {
3800 run_scrn_saver = TRUE;
3801 sc->scrn_time_stamp -= scrn_blank_time;
3802 }
3803 if (cold) {
3804 /*
3805 * While devices are being probed, the screen saver need
3806 * to be invoked explictly. XXX
3807 */
3808 if (sc->flags & SC_SCRN_BLANKED) {
3809 scsplash_stick(FALSE);
3810 stop_scrn_saver(sc, current_saver);
3811 } else {
3812 if (!ISGRAPHSC(scp)) {
3813 scsplash_stick(TRUE);
3814 (*current_saver)(sc, TRUE);
3815 }
3816 }
3817 }
3818 #endif /* NSPLASH */
3819 break;
3820
3821 case RBT:
3822 #ifndef SC_DISABLE_REBOOT
3823 shutdown_nice(0);
3824 #endif
3825 break;
3826
3827 case HALT:
3828 #ifndef SC_DISABLE_REBOOT
3829 shutdown_nice(RB_HALT);
3830 #endif
3831 break;
3832
3833 case PDWN:
3834 #ifndef SC_DISABLE_REBOOT
3835 shutdown_nice(RB_HALT|RB_POWEROFF);
3836 #endif
3837 break;
3838
3839 case SUSP:
3840 case STBY:
3841 break;
3842
3843 case DBG:
3844 #ifndef SC_DISABLE_DDBKEY
3845 #ifdef DDB
3846 lwkt_reltoken(&tty_token);
3847 Debugger("manual escape to debugger");
3848 lwkt_gettoken(&tty_token);
3849 #else
3850 kprintf("No debugger in kernel\n");
3851 #endif
3852 #else /* SC_DISABLE_DDBKEY */
3853 /* do nothing */
3854 #endif /* SC_DISABLE_DDBKEY */
3855 break;
3856
3857 case PNC:
3858 if (enable_panic_key)
3859 panic("Forced by the panic key");
3860 break;
3861
3862 case NEXT:
3863 this_scr = scp->index;
3864 for (i = (this_scr - sc->first_vty + 1)%sc->vtys;
3865 sc->first_vty + i != this_scr;
3866 i = (i + 1)%sc->vtys) {
3867 struct tty *tp = VIRTUAL_TTY(sc, sc->first_vty + i);
3868 if (ISTTYOPEN(tp)) {
3869 syscons_lock();
3870 sc_switch_scr(scp->sc, sc->first_vty + i);
3871 syscons_unlock();
3872 break;
3873 }
3874 }
3875 break;
3876
3877 case PREV:
3878 this_scr = scp->index;
3879 for (i = (this_scr - sc->first_vty + sc->vtys - 1)%sc->vtys;
3880 sc->first_vty + i != this_scr;
3881 i = (i + sc->vtys - 1)%sc->vtys) {
3882 struct tty *tp = VIRTUAL_TTY(sc, sc->first_vty + i);
3883 if (ISTTYOPEN(tp)) {
3884 syscons_lock();
3885 sc_switch_scr(scp->sc, sc->first_vty + i);
3886 syscons_unlock();
3887 break;
3888 }
3889 }
3890 break;
3891
3892 default:
3893 if (KEYCHAR(c) >= F_SCR && KEYCHAR(c) <= L_SCR) {
3894 syscons_lock();
3895 sc_switch_scr(scp->sc, sc->first_vty + KEYCHAR(c) - F_SCR);
3896 syscons_unlock();
3897 break;
3898 }
3899 /* assert(c & FKEY) */
3900 if (!(sc->flags & SC_SCRN_BLANKED)) {
3901 lwkt_reltoken(&tty_token);
3902 return c;
3903 }
3904 break;
3905 }
3906 /* goto next_code */
3907 } else {
3908 /* regular keys (maybe MKEY is set) */
3909 if (!(sc->flags & SC_SCRN_BLANKED)) {
3910 lwkt_reltoken(&tty_token);
3911 return c;
3912 }
3913 }
3914 }
3915
3916 goto next_code;
3917 }
3918
3919 static int
3920 scmmap(struct dev_mmap_args *ap)
3921 {
3922 scr_stat *scp;
3923
3924 lwkt_gettoken(&tty_token);
3925 scp = SC_STAT(ap->a_head.a_dev);
3926 if (scp != scp->sc->cur_scp) {
3927 lwkt_reltoken(&tty_token);
3928 return EINVAL;
3929 }
3930 ap->a_result = (*vidsw[scp->sc->adapter]->mmap)(scp->sc->adp, ap->a_offset,
3931 ap->a_nprot);
3932 lwkt_reltoken(&tty_token);
3933 return(0);
3934 }
3935
3936 static int
3937 save_kbd_state(scr_stat *scp, int unlock)
3938 {
3939 int state;
3940 int error;
3941
3942 WANT_UNLOCK(unlock);
3943 error = kbd_ioctl(scp->sc->kbd, KDGKBSTATE, (caddr_t)&state);
3944 WANT_LOCK(unlock);
3945
3946 if (error == ENOIOCTL)
3947 error = ENODEV;
3948 if (error == 0) {
3949 scp->status &= ~LOCK_MASK;
3950 scp->status |= state;
3951 }
3952 return error;
3953 }
3954
3955 static int
3956 update_kbd_state(scr_stat *scp, int new_bits, int mask, int unlock)
3957 {
3958 int state;
3959 int error;
3960
3961 if (mask != LOCK_MASK) {
3962 WANT_UNLOCK(unlock);
3963 error = kbd_ioctl(scp->sc->kbd, KDGKBSTATE, (caddr_t)&state);
3964 WANT_LOCK(unlock);
3965
3966 if (error == ENOIOCTL)
3967 error = ENODEV;
3968 if (error) {
3969 return error;
3970 }
3971 state &= ~mask;
3972 state |= new_bits & mask;
3973 } else {
3974 state = new_bits & LOCK_MASK;
3975 }
3976 WANT_UNLOCK(unlock);
3977 error = kbd_ioctl(scp->sc->kbd, KDSKBSTATE, (caddr_t)&state);
3978 WANT_LOCK(unlock);
3979 if (error == ENOIOCTL)
3980 error = ENODEV;
3981 return error;
3982 }
3983
3984 static int
3985 update_kbd_leds(scr_stat *scp, int which)
3986 {
3987 int error;
3988
3989 which &= LOCK_MASK;
3990 error = kbd_ioctl(scp->sc->kbd, KDSETLED, (caddr_t)&which);
3991 if (error == ENOIOCTL)
3992 error = ENODEV;
3993 return error;
3994 }
3995
3996 int
3997 set_mode(scr_stat *scp)
3998 {
3999 video_info_t info;
4000
4001 lwkt_gettoken(&tty_token);
4002 /* reject unsupported mode */
4003 if (scp->sc->fbi == NULL && (*vidsw[scp->sc->adapter]->get_info)(scp->sc->adp, scp->mode, &info)) {
4004 lwkt_reltoken(&tty_token);
4005 return 1;
4006 }
4007
4008 /* if this vty is not currently showing, do nothing */
4009 if (scp != scp->sc->cur_scp) {
4010 lwkt_reltoken(&tty_token);
4011 return 0;
4012 }
4013
4014 /* setup video hardware for the given mode */
4015 if (scp->sc->fbi == NULL) {
4016 (*vidsw[scp->sc->adapter]->set_mode)(scp->sc->adp, scp->mode);
4017 sc_vtb_init(&scp->scr, VTB_FRAMEBUFFER, scp->xsize, scp->ysize,
4018 (void *)scp->sc->adp->va_window, FALSE);
4019 } else {
4020 goto done;
4021 }
4022
4023 #ifndef SC_NO_FONT_LOADING
4024 /* load appropriate font */
4025 if (!(scp->status & GRAPHICS_MODE)) {
4026 if (!(scp->status & PIXEL_MODE) && ISFONTAVAIL(scp->sc->adp->va_flags)) {
4027 if (scp->font_height < 14) {
4028 if (scp->sc->fonts_loaded & FONT_8)
4029 sc_load_font(scp, 0, 8, scp->sc->font_8, 0, 256);
4030 } else if (scp->font_height >= 16) {
4031 if (scp->sc->fonts_loaded & FONT_16)
4032 sc_load_font(scp, 0, 16, scp->sc->font_16, 0, 256);
4033 } else {
4034 if (scp->sc->fonts_loaded & FONT_14)
4035 sc_load_font(scp, 0, 14, scp->sc->font_14, 0, 256);
4036 }
4037 /*
4038 * FONT KLUDGE:
4039 * This is an interim kludge to display correct font.
4040 * Always use the font page #0 on the video plane 2.
4041 * Somehow we cannot show the font in other font pages on
4042 * some video cards... XXX
4043 */
4044 sc_show_font(scp, 0);
4045 }
4046 mark_all(scp);
4047 }
4048 #endif /* !SC_NO_FONT_LOADING */
4049
4050 sc_set_border(scp, scp->border);
4051 sc_set_cursor_image(scp);
4052
4053 done:
4054 lwkt_reltoken(&tty_token);
4055 return 0;
4056 }
4057
4058 void
4059 refresh_ega_palette(scr_stat *scp)
4060 {
4061 uint32_t r, g, b;
4062 int reg;
4063 int rsize, gsize, bsize;
4064 int rfld, gfld, bfld;
4065 int i;
4066
4067 rsize = scp->sc->adp->va_info.vi_pixel_fsizes[0];
4068 gsize = scp->sc->adp->va_info.vi_pixel_fsizes[1];
4069 bsize = scp->sc->adp->va_info.vi_pixel_fsizes[2];
4070 rfld = scp->sc->adp->va_info.vi_pixel_fields[0];
4071 gfld = scp->sc->adp->va_info.vi_pixel_fields[1];
4072 bfld = scp->sc->adp->va_info.vi_pixel_fields[2];
4073
4074 for (i = 0; i < 16; i++) {
4075 reg = scp->sc->adp->va_palette_regs[i];
4076
4077 r = scp->sc->palette[reg * 3] >> (8 - rsize);
4078 g = scp->sc->palette[reg * 3 + 1] >> (8 - gsize);
4079 b = scp->sc->palette[reg * 3 + 2] >> (8 - bsize);
4080
4081 scp->ega_palette[i] = (r << rfld) + (g << gfld) + (b << bfld);
4082 }
4083 }
4084
4085 void
4086 sc_set_border(scr_stat *scp, int color)
4087 {
4088 atomic_add_int(&scp->sc->videoio_in_progress, 1);
4089 (*scp->rndr->draw_border)(scp, color);
4090 atomic_add_int(&scp->sc->videoio_in_progress, -1);
4091 }
4092
4093 #ifndef SC_NO_FONT_LOADING
4094 void
4095 sc_load_font(scr_stat *scp, int page, int size, u_char *buf,
4096 int base, int count)
4097 {
4098 sc_softc_t *sc;
4099
4100 sc = scp->sc;
4101 sc->font_loading_in_progress = TRUE;
4102 (*vidsw[sc->adapter]->load_font)(sc->adp, page, size, buf, base, count);
4103 sc->font_loading_in_progress = FALSE;
4104 }
4105
4106 void
4107 sc_save_font(scr_stat *scp, int page, int size, u_char *buf,
4108 int base, int count)
4109 {
4110 sc_softc_t *sc;
4111
4112 sc = scp->sc;
4113 sc->font_loading_in_progress = TRUE;
4114 (*vidsw[sc->adapter]->save_font)(sc->adp, page, size, buf, base, count);
4115 sc->font_loading_in_progress = FALSE;
4116 }
4117
4118 void
4119 sc_show_font(scr_stat *scp, int page)
4120 {
4121 (*vidsw[scp->sc->adapter]->show_font)(scp->sc->adp, page);
4122 }
4123 #endif /* !SC_NO_FONT_LOADING */
4124
4125 void
4126 sc_paste(scr_stat *scp, u_char *p, int count)
4127 {
4128 struct tty *tp;
4129 u_char *rmap;
4130
4131 /*
4132 * Holy hell, don't try to inject a paste buffer if the keyboard
4133 * is not in ascii mode!
4134 */
4135 if (scp->kbd_mode != K_XLATE)
4136 return;
4137
4138 lwkt_gettoken(&tty_token);
4139 if (scp->status & MOUSE_VISIBLE) {
4140 tp = VIRTUAL_TTY(scp->sc, scp->sc->cur_scp->index);
4141 if (!ISTTYOPEN(tp)) {
4142 lwkt_reltoken(&tty_token);
4143 return;
4144 }
4145 rmap = scp->sc->scr_rmap;
4146 for (; count > 0; --count)
4147 (*linesw[tp->t_line].l_rint)(rmap[*p++], tp);
4148 }
4149 lwkt_reltoken(&tty_token);
4150 }
4151
4152 void
4153 sc_bell(scr_stat *scp, int pitch, int duration)
4154 {
4155 if (cold || shutdown_in_progress)
4156 return;
4157
4158 if (scp != scp->sc->cur_scp && (scp->sc->flags & SC_QUIET_BELL)) {
4159 return;
4160 }
4161
4162 if (scp->sc->flags & SC_VISUAL_BELL) {
4163 if (scp->sc->blink_in_progress) {
4164 return;
4165 }
4166 scp->sc->blink_in_progress = 3;
4167 if (scp != scp->sc->cur_scp)
4168 scp->sc->blink_in_progress += 2;
4169 sc_blink_screen(scp->sc->cur_scp);
4170 } else if (duration != 0 && pitch != 0) {
4171 if (scp != scp->sc->cur_scp)
4172 pitch *= 2;
4173 sysbeep(pitch, duration);
4174 }
4175 }
4176
4177 /*
4178 * Two versions of blink_screen(), one called from the console path
4179 * with the syscons locked, and one called from a timer callout.
4180 */
4181 static void
4182 sc_blink_screen(scr_stat *scp)
4183 {
4184 if (ISGRAPHSC(scp) || (scp->sc->blink_in_progress <= 1)) {
4185 scp->sc->blink_in_progress = 0;
4186 mark_all(scp);
4187 if (scp->sc->delayed_next_scr)
4188 sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1);
4189 } else {
4190 (*scp->rndr->draw)(scp, 0, scp->xsize*scp->ysize,
4191 scp->sc->blink_in_progress & 1);
4192 scp->sc->blink_in_progress--;
4193 }
4194 }
4195
4196 #if 0
4197 static void
4198 blink_screen_callout(void *arg)
4199 {
4200 scr_stat *scp = arg;
4201 struct tty *tp;
4202
4203 if (ISGRAPHSC(scp) || (scp->sc->blink_in_progress <= 1)) {
4204 syscons_lock();
4205 scp->sc->blink_in_progress = 0;
4206 mark_all(scp);
4207 syscons_unlock();
4208 tp = VIRTUAL_TTY(scp->sc, scp->index);
4209 if (ISTTYOPEN(tp))
4210 scstart(tp);
4211 if (scp->sc->delayed_next_scr) {
4212 syscons_lock();
4213 sc_switch_scr(scp->sc, scp->sc->delayed_next_scr - 1);
4214 syscons_unlock();
4215 }
4216 } else {
4217 syscons_lock();
4218 (*scp->rndr->draw)(scp, 0, scp->xsize*scp->ysize,
4219 scp->sc->blink_in_progress & 1);
4220 scp->sc->blink_in_progress--;
4221 syscons_unlock();
4222 callout_reset(&scp->blink_screen_ch, hz / 10,
4223 blink_screen_callout, scp);
4224 }
4225 }
4226 #endif
4227
4228 /*
4229 * Allocate active keyboard. Try to allocate "kbdmux" keyboard first, and,
4230 * if found, add all non-busy keyboards to "kbdmux". Otherwise look for
4231 * any keyboard.
4232 */
4233
4234 static int
4235 sc_allocate_keyboard(sc_softc_t *sc, int unit)
4236 {
4237 int idx0, idx;
4238 keyboard_t *k0, *k;
4239 keyboard_info_t ki;
4240
4241 idx0 = kbd_allocate("kbdmux", -1, (void *)&sc->keyboard, sckbdevent, sc);
4242 if (idx0 != -1) {
4243 k0 = kbd_get_keyboard(idx0);
4244
4245 for (idx = kbd_find_keyboard2("*", -1, 0, 0);
4246 idx != -1;
4247 idx = kbd_find_keyboard2("*", -1, idx + 1, 0)) {
4248 k = kbd_get_keyboard(idx);
4249
4250 if (idx == idx0 || KBD_IS_BUSY(k))
4251 continue;
4252
4253 bzero(&ki, sizeof(ki));
4254 strcpy(ki.kb_name, k->kb_name);
4255 ki.kb_unit = k->kb_unit;
4256
4257 kbd_ioctl(k0, KBADDKBD, (caddr_t) &ki);
4258 }
4259 } else
4260 idx0 = kbd_allocate("*", unit, (void *)&sc->keyboard, sckbdevent, sc);
4261
4262 return (idx0);
4263 }
DragonFly BSD