?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
doscmd(1): Raise WARNS to 6 and silence all warnings.
[dragonfly.git] / usr.bin / doscmd / tty.c
blob09860d85b17d0977d809dc6343e74c5e50e718c5
1 /*
2 * Copyright (c) 1992, 1993, 1996
3 * Berkeley Software Design, Inc. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Berkeley Software
16 * Design, Inc.
17 *
18 * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 *
30 * BSDI tty.c,v 2.4 1996/04/08 22:03:27 prb Exp
31 *
32 * $FreeBSD: src/usr.bin/doscmd/tty.c,v 1.8.2.2 2002/04/25 11:04:51 tg Exp $
33 * $DragonFly: src/usr.bin/doscmd/tty.c,v 1.6 2004/01/26 18:16:18 drhodus Exp $
34 */
35
36 #include <sys/ioctl.h>
37 #include <sys/time.h>
38 #include <sys/types.h>
39 #include <sys/mman.h>
40 #include <ctype.h>
41 #include <err.h>
42 #include <fcntl.h>
43 #include <limits.h>
44 #include <paths.h>
45 #include <signal.h>
46 #include <stdio.h>
47 #include <termios.h>
48 #include <unistd.h>
49 #ifdef __DragonFly__
50 # include <osreldate.h>
51 # include <machine/console.h>
52 #endif
53
54 #ifndef NO_X
55 #include <X11/Xlib.h>
56 #include <X11/Xutil.h>
57 #include <X11/keysym.h>
58 #endif
59
60 #include "doscmd.h"
61 #include "AsyncIO.h"
62 #include "font8x8.h"
63 #include "font8x14.h"
64 #include "font8x16.h"
65 #include "mouse.h"
66 #include "trap.h"
67 #include "tty.h"
68 #include "video.h"
69
70 #ifndef NO_X
71 static int show = 1;
72 #endif
73 static int blink = 1;
74 int flipdelete = 0; /* Flip meaning of delete and backspace */
75 static u_short break_code = 0x00;
76 static u_short scan_code = 0x00;
77 int height;
78 int width;
79 int vattr;
80 const char *xfont = 0;
81
82 #ifndef NO_X
83 Display *dpy;
84 Window win;
85 XFontStruct *font;
86 XImage *xi = 0;
87 Visual *visual;
88 unsigned int depth;
89 unsigned long black;
90 unsigned long white;
91 int FW, FH, FD;
92 GC gc;
93 GC cgc;
94 int xfd;
95
96 /* LUT for the vram -> XImage conversion */
97 u_int8_t lut[4][256][8];
98
99 /* X pixel values for the RGB triples */
100 unsigned long pixels[16];
101 #endif
102
103 typedef struct TextLine {
104 u_short *data;
105 u_char max_length; /* Not used, but here for future use */
106 u_char changed:1;
107 } TextLine;
108 TextLine *lines = NULL;
109
110 int kbd_fd = -1;
111 int kbd_read = 0;
112
113 static struct termios tty_cook, tty_raw;
114
115 #define row (CursRow0)
116 #define col (CursCol0)
117
118 /* Local functions */
119 static void _kbd_event(int, int, void *, regcontext_t *);
120 static void Failure(void *);
121 static void SetVREGCur(void);
122 static void debug_event(int, int, void *, regcontext_t *);
123 static unsigned char inb_port60(int);
124 static int inrange(int, int, int);
125 static void kbd_event(int, int, void *, regcontext_t *);
126 static u_short read_raw_kbd(int, u_short *);
127 static void setgc(u_short);
128 static void video_async_event(int, int, void *, regcontext_t *);
129
130 #ifndef NO_X
131 static void dac2rgb(XColor *, int);
132 static void prepare_lut(void);
133 static void putchar_graphics(int, int, int);
134 static void tty_rwrite_graphics(int, int, int);
135 static int video_event(XEvent *ev);
136 static void video_update_graphics(void);
137 static void video_update_text(void);
138 static void vram2ximage(void);
139 #endif
140
141 #define PEEKSZ 16
142
143 #define K_NEXT *(u_short *)0x41a
144 #define K_FREE *(u_short *)0x41c
145 #define K_BUFSTARTP *(u_short *)0x480
146 #define K_BUFENDP *(u_short *)0x482
147 #define K_BUFSTART ((u_short *)(0x400 + *(u_short *)0x480))
148 #define K_BUFEND ((u_short *)(0x400 + *(u_short *)0x482))
149 #define K_BUF(i) *((u_short *)((u_char *)0x400 + (i)))
150
151 #define K1_STATUS BIOSDATA[0x17]
152 #define K1_RSHIFT 0x01
153 #define K1_LSHIFT 0x02
154 #define K1_SHIFT 0x03
155 #define K1_CTRL 0x04
156 #define K1_ALT 0x08
157 #define K1_SLOCK 0x10 /* Active */
158 #define K1_NLOCK 0x20 /* Active */
159 #define K1_CLOCK 0x40 /* Active */
160 #define K1_INSERT 0x80 /* Active */
161
162 #define K2_STATUS BIOSDATA[0x18]
163 #define K2_LCTRL 0x01
164 #define K2_LALT 0x02
165 #define K2_SYSREQ 0x04
166 #define K2_PAUSE 0x08
167 #define K2_SLOCK 0x10 /* Actually held down */
168 #define K2_NLOCK 0x20 /* Actually held down */
169 #define K2_CLOCK 0x40 /* Actually held down */
170 #define K2_INSERT 0x80 /* Actually held down */
171
172 #define K3_STATUS BIOSDATA[0x96]
173 #define K3_E1 0x01 /* Last code read was e1 */
174 #define K3_E2 0x02 /* Last code read was e2 */
175 #define K3_RCTRL 0x04
176 #define K3_RALT 0x08
177 #define K3_ENHANCED 0x10
178 #define K3_FORCENLOCK 0x20
179 #define K3_TWOBYTE 0x40 /* last code was first of 2 */
180 #define K3_READID 0x80 /* read ID in progress */
181
182 #define K4_STATUS BIOSDATA[0x97]
183 #define K4_SLOCK_LED 0x01
184 #define K4_NLOCK_LED 0x02
185 #define K4_CLOCK_LED 0x04
186 #define K4_ACK 0x10 /* ACK recieved from keyboard */
187 #define K4_RESEND 0x20 /* RESEND recieved from keyboard */
188 #define K4_LED 0x40 /* LED update in progress */
189 #define K4_ERROR 0x80
190
191 static void
192 Failure(void *arg __unused)
193 {
194 fprintf(stderr, "X Connection shutdown\n");
195 quit(1);
196 }
197
198 static void
199 SetVREGCur(void)
200 {
201 int cp = row * width + col;
202 VGA_CRTC[CRTC_CurLocHi] = cp >> 8;
203 VGA_CRTC[CRTC_CurLocLo] = cp & 0xff;
204 }
205
206 static void
207 console_denit(void *arg)
208 {
209 int fd = *(int *)arg;
210
211 #if defined (__DragonFly__)
212 if (ioctl(fd, KDSKBMODE, K_XLATE))
213 perror("KDSKBMODE/K_XLATE");
214 #else
215 # ifdef __NetBSD__
216 if (ioctl(fd, CONSOLE_X_MODE_OFF, 0))
217 perror("CONSOLE_X_MODE_OFF");
218 # else /* BSD/OS */
219 if (ioctl(fd, PCCONIOCCOOK, 0))
220 perror("PCCONIOCCOOK");
221 # endif
222 #endif
223 if (tcsetattr(fd, TCSANOW, &tty_cook))
224 perror("tcsetattr");
225 }
226
227 void
228 _kbd_event(int fd, int cond, void *arg __unused, regcontext_t *REGS __unused)
229 {
230 if (!(cond & AS_RD))
231 return;
232 printf("_kbd_event: fd=%d\n", fd);
233 kbd_read = 1;
234 }
235
236 void
237 console_init(void)
238 {
239 int fd;
240 caddr_t addr;
241
242 if ((fd = open(_PATH_DEV "vga", 2)) < 0) {
243 perror(_PATH_DEV "vga");
244 quit(1);
245 }
246 addr = mmap((caddr_t)0xA0000, 5 * 64 * 1024,
247 PROT_EXEC | PROT_READ | PROT_WRITE,
248 MAP_FILE | MAP_FIXED | MAP_SHARED,
249 fd, 0);
250 if (addr != (caddr_t)0xA0000) {
251 perror("mmap");
252 quit(1);
253 }
254
255 #if 0
256 addr = mmap((caddr_t)0x100000 - 0x1000, 0x1000,
257 PROT_EXEC | PROT_READ | PROT_WRITE,
258 MAP_FILE | MAP_FIXED | MAP_SHARED,
259 fd, 0);
260 if (addr != (caddr_t)(0x100000 - 0x1000)) {
261 perror("mmap");
262 quit(1);
263 }
264 #endif
265
266 if ((fd = open(_PATH_CONSOLE, 2)) < 0) {
267 perror(_PATH_CONSOLE);
268 quit(1);
269 }
270
271 fd = squirrel_fd(fd);
272 kbd_fd = fd;
273
274 #if defined (__DragonFly__)
275 if (ioctl(fd, KDSKBMODE, K_RAW)) {
276 perror("KDSKBMODE/K_RAW");
277 quit(1);
278 }
279 #else
280 # ifdef __NetBSD__
281 if (ioctl(fd, CONSOLE_X_MODE_ON, 0)) {
282 perror("CONSOLE_X_MODE_ON");
283 quit(1);
284 }
285 # else /* BSD/OS */
286 if (ioctl(fd, PCCONIOCRAW, 0)) {
287 perror("PCCONIOCRAW");
288 quit(1);
289 }
290 # endif
291 #endif
292
293 call_on_quit(console_denit, &kbd_fd);
294
295 if (fcntl(fd, F_SETFL, O_NDELAY|O_ASYNC) < 0) {
296 perror("fcntl");
297 quit(1);
298 }
299 if (tcgetattr(fd, &tty_cook)) {
300 perror("tcgetattr");
301 quit(1);
302 }
303 tty_raw = tty_cook;
304 cfmakeraw(&tty_raw);
305 if (tcsetattr(fd, TCSANOW, &tty_raw)) {
306 perror("tcsetattr");
307 quit(1);
308 }
309
310 #if 0
311 _RegisterIO(STDIN_FILENO, debug_event, 0, Failure);
312 _RegisterIO(fd, kbd_event, 0, Failure);
313 #endif
314 _RegisterIO(fd, _kbd_event, 0, Failure);
315 }
316
317 void
318 video_setborder(int color)
319 {
320 #ifndef NO_X
321 XSetWindowBackground(dpy, win, pixels[color & 0xf]);
322 #endif
323 }
324 void
325 video_blink(int mode)
326 {
327 blink = mode;
328 }
329
330 static void
331 setgc(u_short attr)
332 {
333 #ifndef NO_X
334 XGCValues v;
335 if (blink && !show && (attr & 0x8000))
336 v.foreground = pixels[(attr >> 12) & 0x07];
337 else
338 v.foreground = pixels[(attr >> 8) & 0x0f];
339
340 v.background = pixels[(attr >> 12) & (blink ? 0x07 : 0x0f)];
341 XChangeGC(dpy, gc, GCForeground|GCBackground, &v);
342 #endif
343 }
344
345 void
346 video_update(regcontext_t *REGS __unused)
347 {
348 #ifndef NO_X
349 static int icnt = 3;
350
351 if (kbd_read)
352 kbd_event(kbd_fd, AS_RD, 0, REGS);
353
354 if (--icnt == 0) {
355 icnt = 3;
356
357 lpt_poll(); /* Handle timeout on lpt code */
358
359 /* quick and dirty */
360 if (VGA_ATC[ATC_ModeCtrl] & 1)
361 video_update_graphics();
362 else
363 video_update_text();
364 }
365 #endif
366 }
367
368 #ifndef NO_X
369 static void
370 video_update_graphics(void)
371 {
372 vram2ximage();
373
374 XPutImage(dpy, win, DefaultGC(dpy, DefaultScreen(dpy)),
375 xi, 0, 0, 0, 0, width, height);
376 XFlush(dpy);
377
378 return;
379 }
380
381 static void
382 video_update_text(void)
383 {
384 static int or = -1;
385 static int oc = -1;
386
387
388 static char buf[256];
389 int r, c;
390 int attr = vmem[0] & 0xff00;
391 XGCValues v;
392
393 if (xmode) {
394 wakeup_poll(); /* Wake up anyone waiting on kbd poll */
395
396 show ^= 1;
397
398 setgc(attr);
399
400 for (r = 0; r < height; ++r) {
401 int cc = 0;
402
403 if (!lines[r].changed) {
404 if ((r == or || r == row) && (or != row || oc != col))
405 lines[r].changed = 1;
406 else {
407 for (c = 0; c < width; ++c) {
408 if (lines[r].data[c] != vmem[r * width + c]) {
409 lines[r].changed = 1;
410 break;
411 }
412 if (blink && lines[r].data[c] & 0x8000) {
413 lines[r].changed = 1;
414 break;
415 }
416 }
417 }
418 }
419
420 if (!lines[r].changed)
421 continue;
422
423 reset_poll();
424 lines[r].changed = 0;
425 memcpy(lines[r].data,
426 &vmem[r * width], sizeof(u_short) * width);
427
428 for (c = 0; c < width; ++c) {
429 int cv = vmem[r * width + c];
430 if ((cv & 0xff00) != attr) {
431 if (cc < c)
432 XDrawImageString(dpy, win, gc,
433 2 + cc * FW,
434 2 + (r + 1) * FH,
435 buf + cc, c - cc);
436 cc = c;
437 attr = cv & 0xff00;
438 setgc(attr);
439 }
440 buf[c] = (cv & 0xff) ? cv & 0xff : ' ';
441 }
442 if (cc < c) {
443 XDrawImageString(dpy, win, gc,
444 2 + cc * FW,
445 2 + (r + 1) * FH,
446 buf + cc, c - cc);
447 }
448 }
449 or = row;
450 oc = col;
451
452 if (CursStart <= CursEnd && CursEnd <= FH &&
453 show && row < height && col < width) {
454
455 attr = vmem[row * width + col] & 0xff00;
456 v.foreground = pixels[(attr >> 8) & 0x0f] ^
457 pixels[(attr >> 12) & (blink ? 0x07 : 0x0f)];
458 if (v.foreground) {
459 v.function = GXxor;
460 } else {
461 v.foreground = pixels[7];
462 v.function = GXcopy;
463 }
464 XChangeGC(dpy, cgc, GCForeground | GCFunction, &v);
465 XFillRectangle(dpy, win, cgc,
466 2 + col * FW,
467 2 + row * FH + CursStart + FD,
468 FW, CursEnd + 1 - CursStart);
469 }
470
471 if (mouse_status.installed && mouse_status.show) {
472 c = mouse_status.x / mouse_status.hmickey;
473 r = mouse_status.y / mouse_status.vmickey;
474
475 lines[r].changed = 1;
476 attr = vmem[r * width + c] & 0xff00;
477 v.foreground = pixels[(attr >> 8) & 0x0f] ^
478 pixels[(attr >> 12) & 0x0f];
479 if (v.foreground) {
480 v.function = GXxor;
481 } else {
482 v.foreground = pixels[7];
483 v.function = GXcopy;
484 }
485 XChangeGC(dpy, cgc, GCForeground | GCFunction, &v);
486 XFillRectangle(dpy, win, cgc,
487 2 + c * FW,
488 2 + r * FH + 2,
489 FW, FH);
490 }
491
492 XFlush(dpy);
493 }
494 }
495
496 /* Convert the contents of the video RAM into an XImage.
497
498 Bugs: - The function is way too slow.
499 - It only works for the 16 color modes.
500 - It only works on 15/16-bit TrueColor visuals. */
501 static void
502 vram2ximage(void)
503 {
504 int i, x, y, yoffset;
505 u_int16_t *image = (u_int16_t *)xi->data;
506
507 yoffset = 0;
508 for (y = 0; y < height; y++) {
509 yoffset += width / 8;
510 for (x = 0; x < width; x += 8) {
511 int offset = yoffset + x / 8;
512 for (i = 0; i < 8; i++) {
513 int color = lut[0][vplane0[offset]][i] |
514 lut[1][vplane1[offset]][i] |
515 lut[2][vplane2[offset]][i] |
516 lut[3][vplane3[offset]][i];
517 *image++ = (u_int16_t)pixels[color];
518 }
519 }
520 }
521
522 return;
523 }
524 #endif
525
526 static u_short Ascii2Scan[] = {
527 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
528 0x000e, 0x000f, 0xffff, 0xffff, 0xffff, 0x001c, 0xffff, 0xffff,
529 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
530 0xffff, 0xffff, 0xffff, 0x0001, 0xffff, 0xffff, 0xffff, 0xffff,
531 0x0039, 0x0102, 0x0128, 0x0104, 0x0105, 0x0106, 0x0108, 0x0028,
532 0x010a, 0x010b, 0x0109, 0x010d, 0x0033, 0x000c, 0x0034, 0x0035,
533 0x000b, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
534 0x0009, 0x000a, 0x0127, 0x0027, 0x0133, 0x000d, 0x0134, 0x0135,
535 0x0103, 0x011e, 0x0130, 0x012e, 0x0120, 0x0112, 0x0121, 0x0122,
536 0x0123, 0x0117, 0x0124, 0x0125, 0x0126, 0x0132, 0x0131, 0x0118,
537 0x0119, 0x0110, 0x0113, 0x011f, 0x0114, 0x0116, 0x012f, 0x0111,
538 0x012d, 0x0115, 0x012c, 0x001a, 0x002b, 0x001b, 0x0107, 0x010c,
539 0x0029, 0x001e, 0x0030, 0x002e, 0x0020, 0x0012, 0x0021, 0x0022,
540 0x0023, 0x0017, 0x0024, 0x0025, 0x0026, 0x0032, 0x0031, 0x0018,
541 0x0019, 0x0010, 0x0013, 0x001f, 0x0014, 0x0016, 0x002f, 0x0011,
542 0x002d, 0x0015, 0x002c, 0x011a, 0x012b, 0x011b, 0x0129, 0xffff,
543 };
544
545 struct {
546 u_short base;
547 u_short shift;
548 u_short ctrl;
549 u_short alt;
550 } ScanCodes[] = {
551 { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 0 */
552 { 0x011b, 0x011b, 0x011b, 0xffff }, /* key 1 - Escape key */
553 { 0x0231, 0x0221, 0xffff, 0x7800 }, /* key 2 - '1' */
554 { 0x0332, 0x0340, 0x0300, 0x7900 }, /* key 3 - '2' - special handling */
555 { 0x0433, 0x0423, 0xffff, 0x7a00 }, /* key 4 - '3' */
556 { 0x0534, 0x0524, 0xffff, 0x7b00 }, /* key 5 - '4' */
557 { 0x0635, 0x0625, 0xffff, 0x7c00 }, /* key 6 - '5' */
558 { 0x0736, 0x075e, 0x071e, 0x7d00 }, /* key 7 - '6' */
559 { 0x0837, 0x0826, 0xffff, 0x7e00 }, /* key 8 - '7' */
560 { 0x0938, 0x092a, 0xffff, 0x7f00 }, /* key 9 - '8' */
561 { 0x0a39, 0x0a28, 0xffff, 0x8000 }, /* key 10 - '9' */
562 { 0x0b30, 0x0b29, 0xffff, 0x8100 }, /* key 11 - '0' */
563 { 0x0c2d, 0x0c5f, 0x0c1f, 0x8200 }, /* key 12 - '-' */
564 { 0x0d3d, 0x0d2b, 0xffff, 0x8300 }, /* key 13 - '=' */
565 { 0x0e08, 0x0e08, 0x0e7f, 0xffff }, /* key 14 - backspace */
566 { 0x0f09, 0x0f00, 0xffff, 0xffff }, /* key 15 - tab */
567 { 0x1071, 0x1051, 0x1011, 0x1000 }, /* key 16 - 'Q' */
568 { 0x1177, 0x1157, 0x1117, 0x1100 }, /* key 17 - 'W' */
569 { 0x1265, 0x1245, 0x1205, 0x1200 }, /* key 18 - 'E' */
570 { 0x1372, 0x1352, 0x1312, 0x1300 }, /* key 19 - 'R' */
571 { 0x1474, 0x1454, 0x1414, 0x1400 }, /* key 20 - 'T' */
572 { 0x1579, 0x1559, 0x1519, 0x1500 }, /* key 21 - 'Y' */
573 { 0x1675, 0x1655, 0x1615, 0x1600 }, /* key 22 - 'U' */
574 { 0x1769, 0x1749, 0x1709, 0x1700 }, /* key 23 - 'I' */
575 { 0x186f, 0x184f, 0x180f, 0x1800 }, /* key 24 - 'O' */
576 { 0x1970, 0x1950, 0x1910, 0x1900 }, /* key 25 - 'P' */
577 { 0x1a5b, 0x1a7b, 0x1a1b, 0xffff }, /* key 26 - '[' */
578 { 0x1b5d, 0x1b7d, 0x1b1d, 0xffff }, /* key 27 - ']' */
579 { 0x1c0d, 0x1c0d, 0x1c0a, 0xffff }, /* key 28 - CR */
580 { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 29 - control */
581 { 0x1e61, 0x1e41, 0x1e01, 0x1e00 }, /* key 30 - 'A' */
582 { 0x1f73, 0x1f53, 0x1f13, 0x1f00 }, /* key 31 - 'S' */
583 { 0x2064, 0x2044, 0x2004, 0x2000 }, /* key 32 - 'D' */
584 { 0x2166, 0x2146, 0x2106, 0x2100 }, /* key 33 - 'F' */
585 { 0x2267, 0x2247, 0x2207, 0x2200 }, /* key 34 - 'G' */
586 { 0x2368, 0x2348, 0x2308, 0x2300 }, /* key 35 - 'H' */
587 { 0x246a, 0x244a, 0x240a, 0x2400 }, /* key 36 - 'J' */
588 { 0x256b, 0x254b, 0x250b, 0x2500 }, /* key 37 - 'K' */
589 { 0x266c, 0x264c, 0x260c, 0x2600 }, /* key 38 - 'L' */
590 { 0x273b, 0x273a, 0xffff, 0xffff }, /* key 39 - ';' */
591 { 0x2827, 0x2822, 0xffff, 0xffff }, /* key 40 - ''' */
592 { 0x2960, 0x297e, 0xffff, 0xffff }, /* key 41 - '`' */
593 { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 42 - left shift */
594 { 0x2b5c, 0x2b7c, 0x2b1c, 0xffff }, /* key 43 - '' */
595 { 0x2c7a, 0x2c5a, 0x2c1a, 0x2c00 }, /* key 44 - 'Z' */
596 { 0x2d78, 0x2d58, 0x2d18, 0x2d00 }, /* key 45 - 'X' */
597 { 0x2e63, 0x2e43, 0x2e03, 0x2e00 }, /* key 46 - 'C' */
598 { 0x2f76, 0x2f56, 0x2f16, 0x2f00 }, /* key 47 - 'V' */
599 { 0x3062, 0x3042, 0x3002, 0x3000 }, /* key 48 - 'B' */
600 { 0x316e, 0x314e, 0x310e, 0x3100 }, /* key 49 - 'N' */
601 { 0x326d, 0x324d, 0x320d, 0x3200 }, /* key 50 - 'M' */
602 { 0x332c, 0x333c, 0xffff, 0xffff }, /* key 51 - ',' */
603 { 0x342e, 0x343e, 0xffff, 0xffff }, /* key 52 - '.' */
604 { 0x352f, 0x353f, 0xffff, 0xffff }, /* key 53 - '/' */
605 { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 54 - right shift - */
606 { 0x372a, 0xffff, 0x3772, 0xffff }, /* key 55 - prt-scr - */
607 { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 56 - Alt - */
608 { 0x3920, 0x3920, 0x3920, 0x3920 }, /* key 57 - space bar */
609 { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 58 - caps-lock - */
610 { 0x3b00, 0x5400, 0x5e00, 0x6800 }, /* key 59 - F1 */
611 { 0x3c00, 0x5500, 0x5f00, 0x6900 }, /* key 60 - F2 */
612 { 0x3d00, 0x5600, 0x6000, 0x6a00 }, /* key 61 - F3 */
613 { 0x3e00, 0x5700, 0x6100, 0x6b00 }, /* key 62 - F4 */
614 { 0x3f00, 0x5800, 0x6200, 0x6c00 }, /* key 63 - F5 */
615 { 0x4000, 0x5900, 0x6300, 0x6d00 }, /* key 64 - F6 */
616 { 0x4100, 0x5a00, 0x6400, 0x6e00 }, /* key 65 - F7 */
617 { 0x4200, 0x5b00, 0x6500, 0x6f00 }, /* key 66 - F8 */
618 { 0x4300, 0x5c00, 0x6600, 0x7000 }, /* key 67 - F9 */
619 { 0x4400, 0x5d00, 0x6700, 0x7100 }, /* key 68 - F10 */
620 { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 69 - num-lock - */
621 { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 70 - scroll-lock - */
622 { 0x4700, 0x4737, 0x7700, 0xffff }, /* key 71 - home */
623 { 0x4800, 0x4838, 0xffff, 0xffff }, /* key 72 - cursor up */
624 { 0x4900, 0x4939, 0x8400, 0xffff }, /* key 73 - page up */
625 { 0x4a2d, 0x4a2d, 0xffff, 0xffff }, /* key 74 - minus sign */
626 { 0x4b00, 0x4b34, 0x7300, 0xffff }, /* key 75 - cursor left */
627 { 0xffff, 0x4c35, 0xffff, 0xffff }, /* key 76 - center key */
628 { 0x4d00, 0x4d36, 0x7400, 0xffff }, /* key 77 - cursor right */
629 { 0x4e2b, 0x4e2b, 0xffff, 0xffff }, /* key 78 - plus sign */
630 { 0x4f00, 0x4f31, 0x7500, 0xffff }, /* key 79 - end */
631 { 0x5000, 0x5032, 0xffff, 0xffff }, /* key 80 - cursor down */
632 { 0x5100, 0x5133, 0x7600, 0xffff }, /* key 81 - page down */
633 { 0x5200, 0x5230, 0xffff, 0xffff }, /* key 82 - insert */
634 { 0x5300, 0x532e, 0xffff, 0xffff }, /* key 83 - delete */
635 { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 84 - sys key */
636 { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 85 */
637 { 0xffff, 0xffff, 0xffff, 0xffff }, /* key 86 */
638 { 0x8500, 0x5787, 0x8900, 0x8b00 }, /* key 87 - F11 */
639 { 0x8600, 0x5888, 0x8a00, 0x8c00 }, /* key 88 - F12 */
640 };
641
642 void
643 debug_event(int fd __unused, int cond, void *arg __unused, regcontext_t *REGS)
644 {
645 static char ibuf[1024];
646 static int icnt = 0;
647 static u_short ds = 0;
648 static u_short di = 0;
649 static u_short cnt = 16 * 8;
650 char *ep;
651 int r;
652
653 if (!(cond & AS_RD))
654 return;
655
656 r = read(STDIN_FILENO, ibuf + icnt, sizeof(ibuf) - icnt);
657 if (r <= 0)
658 return;
659
660 icnt += r;
661
662 ibuf[icnt] = 0;
663 while ((ep = strchr(ibuf, '\n')) != 0) {
664 int ac;
665 char *_av[16];
666 char **av;
667
668 *ep++ = 0;
669 ac = ParseBuffer(ibuf, av = _av, 16);
670
671 if (ac > 0) {
672 if (!strcasecmp(av[0], "dump")) {
673 if (ac > 1) {
674 char *c;
675 if ((c = strchr(av[1], ':')) != 0) {
676 ds = strtol(av[1], 0, 16);
677 di = strtol(c+1, 0, 16);
678 } else
679 di = strtol(av[1], 0, 16);
680 }
681 if (ac > 2)
682 cnt = strtol(av[2], 0, 0);
683 cnt = (cnt + 0xf) & ~0xf;
684 if (cnt == 0)
685 cnt = 0x10;
686 di &= ~0xf;
687
688 for (r = 0; r < cnt; r += 0x10, di = (di + 0x10) & 0xffff) {
689 int i;
690 u_char *ap = (u_char *)(((u_long)ds << 4) + di);
691
692 printf("%04x:%04x:", ds, di);
693 for (i = 0; i < 8; ++i)
694 printf(" %02x", ap[i]);
695 printf(" ");
696 for (i = 8; i < 16; ++i)
697 printf(" %02x", ap[i]);
698 printf(": ");
699 for (i = 0; i < 8; ++i)
700 printf("%c",(ap[i] < ' ' || ap[i] > '~') ? '.' : ap[i]);
701 printf(" ");
702 for (i = 8; i < 16; ++i)
703 printf("%c",(ap[i] < ' ' || ap[i] > '~') ? '.' : ap[i]);
704 printf("\n");
705 }
706 } else if (!strcasecmp(av[0], "dis")) {
707 u_char *ap = (u_char *)(((u_long)ds << 4) + di);
708
709 if (ac > 1) {
710 char *c;
711 if ((c = strchr(av[1], ':')) != 0) {
712 ds = strtol(av[1], 0, 16);
713 di = strtol(c+1, 0, 16);
714 } else
715 di = strtol(av[1], 0, 16);
716 }
717 if (ac > 2)
718 cnt = strtol(av[2], 0, 0);
719
720 for (r = 0; r < cnt; ++r) {
721 char buf[16];
722 int c = i386dis(ds, di, ap, buf, 0);
723 printf("%04x:%04x %s\n", ds, di, buf);
724 di += c;
725 ap += c;
726 }
727 } else if (!strcasecmp(av[0], "regs")) {
728 dump_regs(REGS);
729 } else if (!strcasecmp(av[0], "force")) {
730 char *p = av[1];
731
732 while ((p = *++av) != 0) {
733 while (*p) {
734 if (*p >= ' ' && *p <= '~')
735 KbdWrite(ScanCodes[Ascii2Scan[(int)*p] & 0xff].base);
736 ++p;
737 }
738 }
739 KbdWrite(ScanCodes[28].base);
740 } else if (!strcasecmp(av[0], "bell")) {
741 #ifndef NO_X
742 XBell(dpy, 0);
743 XFlush(dpy);
744 #endif
745 } else {
746 fprintf(stderr, "%s: unknown command\n", av[0]);
747 }
748 }
749
750 if (ep < ibuf + icnt) {
751 char *f = ep;
752 char *t = ibuf;
753 icnt -= ep - ibuf;
754 while (icnt--)
755 *t++ = *f++;
756 } else
757 icnt = 0;
758 ibuf[icnt] = 0;
759 }
760 }
761
762 unsigned char
763 inb_port60(int port __unused)
764 {
765 int r = break_code;
766 break_code = 0;
767 scan_code = 0xffff;
768 return(r);
769 }
770
771 void
772 kbd_event(int fd, int cond, void *arg __unused, regcontext_t *REGS __unused)
773 {
774 if (!(cond & AS_RD))
775 return;
776
777 kbd_read = 0;
778
779 printf("kbd_event: fd=%d\n", fd);
780 if ((break_code = read_raw_kbd(fd, &scan_code)) != 0xffff)
781 hardint(0x01);
782 }
783
784 void
785 int09(REGISTERS __unused)
786 {
787 if (raw_kbd) {
788 if (scan_code != 0xffff) {
789 KbdWrite(scan_code);
790 break_code = 0;
791 scan_code = 0xffff;
792 #if 0
793 kbd_event(kbd_fd, 0, sc, REGS);
794 #endif
795 }
796 }
797 send_eoi();
798 }
799
800 u_short
801 read_raw_kbd(int fd, u_short *code)
802 {
803 unsigned char c;
804
805 *code = 0xffff;
806
807 if (read(fd, &c, 1) == 1) {
808 if (c == 0xe0) {
809 K3_STATUS |= K3_TWOBYTE;
810 return(c);
811 }
812 switch (c) {
813 case 29: /* Control */
814 K1_STATUS |= K1_CTRL;
815 if (K3_STATUS & K3_TWOBYTE)
816 K3_STATUS |= K3_RCTRL;
817 else
818 K2_STATUS |= K2_LCTRL;
819 break;
820 case 29 | 0x80: /* Control */
821 K1_STATUS &= ~K1_CTRL;
822 if (K3_STATUS & K3_TWOBYTE)
823 K3_STATUS &= ~K3_RCTRL;
824 else
825 K2_STATUS &= ~K2_LCTRL;
826 break;
827
828 case 42: /* left shift */
829 K1_STATUS |= K1_LSHIFT;
830 break;
831 case 42 | 0x80: /* left shift */
832 K1_STATUS &= ~K1_LSHIFT;
833 break;
834
835 case 54: /* right shift */
836 K1_STATUS |= K1_RSHIFT;
837 break;
838 case 54 | 0x80: /* right shift */
839 K1_STATUS &= ~K1_RSHIFT;
840 break;
841
842 case 56: /* Alt */
843 K1_STATUS |= K1_ALT;
844 if (K3_STATUS & K3_TWOBYTE)
845 K3_STATUS |= K3_RALT;
846 else
847 K2_STATUS |= K2_LALT;
848 break;
849 case 56 | 0x80: /* Alt */
850 K1_STATUS &= ~K1_ALT;
851 if (K3_STATUS & K3_TWOBYTE)
852 K3_STATUS &= ~K3_RALT;
853 else
854 K2_STATUS &= ~K2_LALT;
855 break;
856
857 case 58: /* caps-lock */
858 K1_STATUS ^= K1_CLOCK;
859 if (K1_STATUS & K1_CLOCK)
860 K4_STATUS |= K4_CLOCK_LED;
861 else
862 K4_STATUS &= ~K4_CLOCK_LED;
863 K2_STATUS |= K2_CLOCK;
864 break;
865 case 58 | 0x80: /* caps-lock */
866 K2_STATUS &= ~K2_CLOCK;
867 break;
868
869 case 69: /* num-lock */
870 K1_STATUS ^= K1_NLOCK;
871 if (K1_STATUS & K1_NLOCK)
872 K4_STATUS |= K4_NLOCK_LED;
873 else
874 K4_STATUS &= ~K4_NLOCK_LED;
875 K2_STATUS |= K2_NLOCK;
876 break;
877 case 69 | 0x80: /* num-lock */
878 K2_STATUS &= ~K2_NLOCK;
879 break;
880
881 case 70: /* scroll-lock */
882 K1_STATUS ^= K1_SLOCK;
883 if (K1_STATUS & K1_SLOCK)
884 K4_STATUS |= K4_SLOCK_LED;
885 else
886 K4_STATUS &= ~K4_SLOCK_LED;
887 K2_STATUS |= K2_SLOCK;
888 break;
889 case 70 | 0x80: /* scroll-lock */
890 K2_STATUS &= ~K2_SLOCK;
891 break;
892
893 case 82: /* insert */
894 K1_STATUS ^= K1_INSERT;
895 K2_STATUS |= K2_INSERT;
896 break;
897 case 82 | 0x80: /* insert */
898 K2_STATUS &= ~K2_INSERT;
899 break;
900
901 }
902
903 #if 0 /*XXXXX*/
904 if ((K4_STATUS & 0x07) != oldled) {
905 oldled = K4_STATUS & 0x07;
906 ioctl (fd, PCCONIOCSETLED, &oldled);
907 }
908 #endif
909
910 if (c == 83 && (K1_STATUS & (K1_ALT|K1_CTRL)) == (K1_ALT|K1_CTRL))
911 quit(0);
912
913 if (c < 89) {
914 u_short scode;
915
916 if (K1_STATUS & K1_ALT) {
917 scode = ScanCodes[c].alt;
918 } else if (K1_STATUS & K1_CTRL) {
919 scode = ScanCodes[c].ctrl;
920 } else if (K1_STATUS & K1_SHIFT) {
921 scode = ScanCodes[c].shift;
922 } else {
923 scode = ScanCodes[c].base;
924 if (K1_STATUS & K1_CLOCK) {
925 if (islower(scode & 0xff)) {
926 scode = (scode & 0xff00) | toupper(scode & 0xff);
927 }
928 }
929 if ((K1_STATUS & K1_NLOCK) && (K3_STATUS & K3_TWOBYTE) == 0) {
930 switch (c) {
931 case 71: /* home */
932 case 72: /* cursor up */
933 case 73: /* page up */
934 case 75: /* cursor left */
935 case 76: /* center key */
936 case 77: /* cursor right */
937 case 79: /* end */
938 case 80: /* cursor down */
939 case 81: /* page down */
940 case 82: /* insert */
941 case 83: /* delete */
942 scode = ScanCodes[c].shift;
943 break;
944 }
945 }
946 }
947 *code = scode;
948 }
949 K3_STATUS &= ~K3_TWOBYTE;
950 if ((K1_STATUS&(K1_ALT|K1_CTRL)) == (K1_ALT|K1_CTRL)) {
951 switch (c) {
952 case 0x13: /* R */
953 kill(getpid(), SIGALRM); /* force redraw */
954 printf("FORCED REDRAW\n");
955 return(0xffff);
956 case 0x14: /* T */
957 tmode ^= 1;
958 if (!tmode)
959 resettrace((regcontext_t *)&saved_sigframe->
960 sf_uc.uc_mcontext);
961 return(0xffff);
962 case 0x53: /* DEL */
963 quit(0);
964 }
965 }
966 return(c);
967 } else {
968 return(0xffff);
969 }
970 }
971
972 void
973 video_async_event(int fd, int cond, void *arg __unused,
974 regcontext_t *REGS __unused)
975 {
976 #ifndef NO_X
977 int int9 = 0;
978
979 if (!(cond & AS_RD))
980 return;
981
982 for (;;) {
983 int x;
984 fd_set fdset;
985 XEvent ev;
986 static struct timeval tv;
987
988 /*
989 * Handle any events just sitting around...
990 */
991 XFlush(dpy);
992 while (QLength(dpy) > 0) {
993 XNextEvent(dpy, &ev);
994 int9 |= video_event(&ev);
995 }
996
997 FD_ZERO(&fdset);
998 FD_SET(fd, &fdset);
999
1000 x = select(FD_SETSIZE, &fdset, 0, 0, &tv);
1001
1002 switch (x) {
1003 case -1:
1004 /*
1005 * Errno might be wrong, so we just select again.
1006 * This could cause a problem is something really
1007 * was wrong with select....
1008 */
1009 perror("select");
1010 return;
1011 case 0:
1012 XFlush(dpy);
1013 if (int9)
1014 hardint(0x01);
1015 return;
1016 default:
1017 if (FD_ISSET(fd, &fdset)) {
1018 do {
1019 XNextEvent(dpy, &ev);
1020 int9 |= video_event(&ev);
1021 } while (QLength(dpy));
1022 }
1023 break;
1024 }
1025 }
1026 #endif
1027 }
1028
1029 #ifndef NO_X
1030 static int
1031 video_event(XEvent *ev)
1032 {
1033 switch (ev->type) {
1034 case MotionNotify: {
1035 XMotionEvent *me = (XMotionEvent *)ev;
1036 me->x -= 2;
1037 me->y -= 2;
1038
1039 mouse_status.x = (me->x < mouse_status.range.x)
1040 ? mouse_status.range.x
1041 : (me->x > mouse_status.range.w)
1042 ? mouse_status.range.w : me->x;
1043 mouse_status.y = (me->y < mouse_status.range.y)
1044 ? mouse_status.range.y
1045 : (me->y > mouse_status.range.h)
1046 ? mouse_status.range.h : me->y;
1047 break;
1048 }
1049 case ButtonRelease: {
1050 XButtonEvent *be = (XButtonEvent *)ev;
1051 be->x -= 2;
1052 be->y -= 2;
1053
1054 if (be->button < 3)
1055 mouse_status.ups[be->button]++;
1056
1057 mouse_status.x = (be->x < mouse_status.range.x)
1058 ? mouse_status.range.x
1059 : (be->x > mouse_status.range.w)
1060 ? mouse_status.range.w : be->x;
1061 mouse_status.y = (be->y < mouse_status.range.y)
1062 ? mouse_status.range.y
1063 : (be->y > mouse_status.range.h)
1064 ? mouse_status.range.h : be->y;
1065 break;
1066 }
1067 case ButtonPress: {
1068 XButtonEvent *be = (XButtonEvent *)ev;
1069 be->x -= 2;
1070 be->y -= 2;
1071
1072 if (be->button < 3)
1073 mouse_status.downs[be->button]++;
1074
1075 mouse_status.x = (be->x < mouse_status.range.x)
1076 ? mouse_status.range.x
1077 : (be->x > mouse_status.range.w)
1078 ? mouse_status.range.w : be->x;
1079 mouse_status.y = (be->y < mouse_status.range.y)
1080 ? mouse_status.range.y
1081 : (be->y > mouse_status.range.h)
1082 ? mouse_status.range.h : be->y;
1083
1084 if ((K1_STATUS & (K1_ALT|K1_CTRL)) == (K1_ALT|K1_CTRL)) {
1085 quit(0);
1086 }
1087 break;
1088 }
1089 case NoExpose:
1090 break;
1091 case GraphicsExpose:
1092 case Expose: {
1093 int r;
1094 for (r = 0; r < height; ++r)
1095 lines[r].changed = 1;
1096 break;
1097 }
1098 case KeyRelease: {
1099 static char buf[128];
1100 KeySym ks;
1101
1102 break_code |= 0x80;
1103
1104 if (!(ev->xkey.state & ShiftMask)) {
1105 K1_STATUS &= ~K1_LSHIFT;
1106 K1_STATUS &= ~K1_RSHIFT;
1107 }
1108 if (!(ev->xkey.state & ControlMask)) {
1109 K1_STATUS &= ~K1_CTRL;
1110 K2_STATUS &= ~K2_LCTRL;
1111 K3_STATUS &= ~K3_RCTRL;
1112 }
1113 if (!(ev->xkey.state & Mod1Mask)) {
1114 K1_STATUS &= ~K1_ALT;
1115 K2_STATUS &= ~K2_LALT;
1116 K3_STATUS &= ~K3_RALT;
1117 }
1118 if (!(ev->xkey.state & LockMask)) {
1119 K2_STATUS &= ~K2_CLOCK;
1120 }
1121
1122 XLookupString((XKeyEvent *)ev, buf, sizeof(buf), &ks, 0);
1123 switch (ks) {
1124 case XK_Shift_L:
1125 K1_STATUS &= ~K1_LSHIFT;
1126 break;
1127 case XK_Shift_R:
1128 K1_STATUS &= ~K1_RSHIFT;
1129 break;
1130 case XK_Control_L:
1131 K1_STATUS &= ~K1_CTRL;
1132 K2_STATUS &= ~K2_LCTRL;
1133 break;
1134 case XK_Control_R:
1135 K1_STATUS &= ~K1_CTRL;
1136 K3_STATUS &= ~K3_RCTRL;
1137 break;
1138 case XK_Alt_L:
1139 K1_STATUS &= ~K1_ALT;
1140 K2_STATUS &= ~K2_LALT;
1141 break;
1142 case XK_Alt_R:
1143 K1_STATUS &= ~K1_ALT;
1144 K3_STATUS &= ~K3_RALT;
1145 break;
1146 case XK_Scroll_Lock:
1147 K2_STATUS &= ~K2_SLOCK;
1148 break;
1149 case XK_Num_Lock:
1150 K2_STATUS &= ~K2_NLOCK;
1151 break;
1152 case XK_Caps_Lock:
1153 K2_STATUS &= ~K2_CLOCK;
1154 break;
1155 case XK_Insert:
1156 K2_STATUS &= ~K2_INSERT;
1157 break;
1158 }
1159 return(1);
1160 }
1161 case KeyPress: {
1162 static char buf[128];
1163 KeySym ks;
1164 int n;
1165 int nlock = 0;
1166 u_short scan = 0xffff;
1167
1168 if (!(ev->xkey.state & ShiftMask)) {
1169 K1_STATUS &= ~K1_LSHIFT;
1170 K1_STATUS &= ~K1_RSHIFT;
1171 }
1172 if (!(ev->xkey.state & ControlMask)) {
1173 K1_STATUS &= ~K1_CTRL;
1174 K2_STATUS &= ~K2_LCTRL;
1175 K3_STATUS &= ~K3_RCTRL;
1176 }
1177 if (!(ev->xkey.state & Mod1Mask)) {
1178 K1_STATUS &= ~K1_ALT;
1179 K2_STATUS &= ~K2_LALT;
1180 K3_STATUS &= ~K3_RALT;
1181 }
1182 if (!(ev->xkey.state & LockMask)) {
1183 K2_STATUS &= ~K2_CLOCK;
1184 }
1185
1186 n = XLookupString((XKeyEvent *)ev, buf, sizeof(buf), &ks, 0);
1187
1188 switch (ks) {
1189 case XK_Shift_L:
1190 K1_STATUS |= K1_LSHIFT;
1191 break;
1192 case XK_Shift_R:
1193 K1_STATUS |= K1_RSHIFT;
1194 break;
1195 case XK_Control_L:
1196 K1_STATUS |= K1_CTRL;
1197 K2_STATUS |= K2_LCTRL;
1198 break;
1199 case XK_Control_R:
1200 K1_STATUS |= K1_CTRL;
1201 K3_STATUS |= K3_RCTRL;
1202 break;
1203 case XK_Alt_L:
1204 K1_STATUS |= K1_ALT;
1205 K2_STATUS |= K2_LALT;
1206 break;
1207 case XK_Alt_R:
1208 K1_STATUS |= K1_ALT;
1209 K3_STATUS |= K3_RALT;
1210 break;
1211 case XK_Scroll_Lock:
1212 K1_STATUS ^= K1_SLOCK;
1213 K2_STATUS |= K2_SLOCK;
1214 break;
1215 case XK_Num_Lock:
1216 K1_STATUS ^= K1_NLOCK;
1217 K2_STATUS |= K2_NLOCK;
1218 break;
1219 case XK_Caps_Lock:
1220 K1_STATUS ^= K1_CLOCK;
1221 K2_STATUS |= K2_CLOCK;
1222 break;
1223 case XK_Insert:
1224 case XK_KP_Insert:
1225 K1_STATUS ^= K1_INSERT;
1226 K2_STATUS |= K2_INSERT;
1227 scan = 82;
1228 goto docode;
1229
1230 case XK_Escape:
1231 scan = 1;
1232 goto docode;
1233
1234 case XK_Tab:
1235 case XK_ISO_Left_Tab:
1236 scan = 15;
1237 goto docode;
1238
1239 case XK_Return:
1240 case XK_KP_Enter:
1241 scan = 28;
1242 goto docode;
1243
1244 case XK_Print:
1245 scan = 55;
1246 goto docode;
1247
1248 case XK_F1:
1249 case XK_F2:
1250 case XK_F3:
1251 case XK_F4:
1252 case XK_F5:
1253 case XK_F6:
1254 case XK_F7:
1255 case XK_F8:
1256 case XK_F9:
1257 case XK_F10:
1258 scan = ks - XK_F1 + 59;
1259 goto docode;
1260
1261 case XK_KP_7:
1262 nlock = 1;
1263 case XK_Home:
1264 case XK_KP_Home:
1265 scan = 71;
1266 goto docode;
1267 case XK_KP_8:
1268 nlock = 1;
1269 case XK_Up:
1270 case XK_KP_Up:
1271 scan = 72;
1272 goto docode;
1273 case XK_KP_9:
1274 nlock = 1;
1275 case XK_Prior:
1276 case XK_KP_Prior:
1277 scan = 73;
1278 goto docode;
1279 case XK_KP_Subtract:
1280 scan = 74;
1281 goto docode;
1282 case XK_KP_4:
1283 nlock = 1;
1284 case XK_Left:
1285 case XK_KP_Left:
1286 scan = 75;
1287 goto docode;
1288 case XK_KP_5:
1289 nlock = 1;
1290 case XK_Begin:
1291 case XK_KP_Begin:
1292 scan = 76;
1293 goto docode;
1294 case XK_KP_6:
1295 nlock = 1;
1296 case XK_Right:
1297 case XK_KP_Right:
1298 scan = 77;
1299 goto docode;
1300 case XK_KP_Add:
1301 scan = 78;
1302 goto docode;
1303 case XK_KP_1:
1304 nlock = 1;
1305 case XK_End:
1306 case XK_KP_End:
1307 scan = 79;
1308 goto docode;
1309 case XK_KP_2:
1310 nlock = 1;
1311 case XK_Down:
1312 case XK_KP_Down:
1313 scan = 80;
1314 goto docode;
1315 case XK_KP_3:
1316 nlock = 1;
1317 case XK_Next:
1318 case XK_KP_Next:
1319 scan = 81;
1320 goto docode;
1321 case XK_KP_0:
1322 nlock = 1;
1323 /* case XK_Insert: This is above */
1324 scan = 82;
1325 goto docode;
1326
1327 case XK_KP_Decimal:
1328 nlock = 1;
1329 scan = 83;
1330 goto docode;
1331
1332 case XK_Delete:
1333 case XK_KP_Delete:
1334 scan = flipdelete ? 14 : 83;
1335 goto docode;
1336
1337 case XK_BackSpace:
1338 scan = flipdelete ? 83 : 14;
1339 goto docode;
1340
1341 case XK_F11:
1342 scan = 87;
1343 goto docode;
1344 case XK_F12:
1345 scan = 88;
1346 goto docode;
1347
1348
1349 case XK_KP_Divide:
1350 scan = Ascii2Scan['/'];
1351 goto docode;
1352
1353 case XK_KP_Multiply:
1354 scan = Ascii2Scan['*'];
1355 goto docode;
1356
1357 default:
1358 if ((K1_STATUS&(K1_ALT|K1_CTRL)) == (K1_ALT|K1_CTRL)) {
1359 if (ks == 'T' || ks == 't') {
1360 tmode ^= 1;
1361 if (!tmode)
1362 resettrace((regcontext_t *)&saved_sigframe->
1363 sf_uc.uc_mcontext);
1364 break;
1365 }
1366 if (ks == 'R' || ks == 'r') {
1367 kill(getpid(), SIGALRM); /* redraw */
1368 break;
1369 }
1370 }
1371 if (ks < ' ' || ks > '~')
1372 break;
1373 scan = Ascii2Scan[ks];
1374 docode:
1375 if (nlock)
1376 scan |= 0x100;
1377
1378 if ((scan & ~0x100) > 88) {
1379 scan = 0xffff;
1380 break;
1381 }
1382
1383 if ((K1_STATUS & K1_SHIFT) || (scan & 0x100)) {
1384 scan = ScanCodes[scan & 0xff].shift;
1385 } else if (K1_STATUS & K1_CTRL) {
1386 scan = ScanCodes[scan & 0xff].ctrl;
1387 } else if (K1_STATUS & K1_ALT) {
1388 scan = ScanCodes[scan & 0xff].alt;
1389 } else
1390 scan = ScanCodes[scan & 0xff].base;
1391
1392 break;
1393 }
1394 if (scan != 0xffff) {
1395 break_code = scan >> 8;
1396 KbdWrite(scan);
1397 }
1398 return(1);
1399 }
1400 default:
1401 break;
1402 }
1403 return(0);
1404 }
1405 #endif
1406
1407 void
1408 tty_move(int r, int c)
1409 {
1410 row = r;
1411 col = c;
1412 SetVREGCur();
1413 }
1414
1415 void
1416 tty_report(int *r, int *c)
1417 {
1418 *r = row;
1419 *c = col;
1420 }
1421
1422 void
1423 tty_flush(void)
1424 {
1425 K_NEXT = K_FREE = K_BUFSTARTP;
1426 }
1427
1428 void
1429 tty_index(int scroll)
1430 {
1431 int i;
1432
1433 if (row > (height - 1))
1434 row = 0;
1435 else if (++row >= height) {
1436 row = height - 1;
1437 if (scroll) {
1438 memcpy(vmem, &vmem[width], 2 * width * (height - 1));
1439 for (i = 0; i < width; ++i)
1440 vmem[(height - 1) * width + i] = vattr | ' ';
1441 }
1442 }
1443 SetVREGCur();
1444 }
1445
1446 void
1447 tty_write(int c, int attr)
1448 {
1449 if (attr == TTYF_REDIRECT) {
1450 if (redirect1) {
1451 write(1, &c, 1);
1452 return;
1453 }
1454 attr = -1;
1455 }
1456 if (capture_fd >= 0) {
1457 char cc = c;
1458 write(capture_fd, &cc, 1);
1459 }
1460 c &= 0xff;
1461 switch (c) {
1462 case 0x07:
1463 if (xmode) {
1464 #ifndef NO_X
1465 XBell(dpy, 0);
1466 #endif
1467 } else
1468 write(1, "\007", 1);
1469 break;
1470 case 0x08:
1471 if (row > (height - 1) || col > width)
1472 break;
1473 if (col > 0)
1474 --col;
1475 vmem[row * width + col] &= 0xff00;
1476 break;
1477 case '\t':
1478 if (row > (height - 1))
1479 row = 0;
1480 col = (col + 8) & ~0x07;
1481 if (col > width) {
1482 col = 0;
1483 tty_index(1);
1484 }
1485 break;
1486 case '\r':
1487 col = 0;
1488 break;
1489 case '\n':
1490 tty_index(1);
1491 break;
1492 default:
1493 if (col >= width) {
1494 col = 0;
1495 tty_index(1);
1496 }
1497 if (row > (height - 1))
1498 row = 0;
1499 if (attr >= 0)
1500 vmem[row * width + col] = attr & 0xff00;
1501 else
1502 vmem[row * width + col] &= 0xff00;
1503 vmem[row * width + col++] |= c;
1504 break;
1505 }
1506 SetVREGCur();
1507 }
1508
1509 void
1510 tty_rwrite(int n, int c, int attr)
1511 {
1512 u_char srow, scol;
1513 c &= 0xff;
1514
1515 #ifndef NO_X
1516 if (VGA_ATC[ATC_ModeCtrl] & 1) {
1517 tty_rwrite_graphics(n, c, attr);
1518 return;
1519 }
1520 #endif
1521
1522 srow = row;
1523 scol = col;
1524 while (n--) {
1525 if (col >= width) {
1526 col = 0;
1527 tty_index(0);
1528 }
1529 if (row > (height - 1))
1530 row = 0;
1531 if (attr >= 0)
1532 vmem[row * width + col] = attr & 0xff00;
1533 else
1534 vmem[row * width + col] &= 0xff00;
1535 vmem[row * width + col++] |= c;
1536 }
1537 row = srow;
1538 col = scol;
1539 SetVREGCur();
1540 }
1541
1542 #ifndef NO_X
1543 /* Write a character in graphics mode. Note that the text is put at *text*
1544 coordinates. */
1545 static void
1546 tty_rwrite_graphics(int n, int c, int attr)
1547 {
1548 u_int8_t srow, scol;
1549 int ht = height / CharHeight;
1550 int wd = width / 8;
1551
1552 srow = row;
1553 scol = col;
1554
1555 while (n--) {
1556 if (col >= wd) {
1557 col = 0;
1558 /* tty_index(0); *//* scroll up if last line is filled */
1559 }
1560 if (row > (ht - 1))
1561 row = 0;
1562 putchar_graphics(row * wd * CharHeight + col, c, attr);
1563 col++;
1564 }
1565 row = srow;
1566 col = scol;
1567 SetVREGCur();
1568
1569 return;
1570 }
1571
1572 /* Put the character together from its pixel representation in 'font8xXX[]'
1573 and write it to 'vram'. The attribute byte gives the desired color; if bit
1574 7 is set, the pixels are XOR'd with the underlying color(s).
1575
1576 XXX This must be updated for the 256 color modes. */
1577 static void
1578 putchar_graphics(int xy, int c, int attr)
1579 {
1580 int i, j;
1581 u_int8_t cline;
1582 u_int8_t *cpos;
1583
1584 /* get char position in the pixel representation */
1585 cpos = (u_int8_t *)(0xC3000 + c * CharHeight);
1586
1587 for (i = 0; i < CharHeight; i++) {
1588 cline = cpos[i];
1589 for (j = 0; j < 4; j++) {
1590 if (attr & 0x8000) {
1591 /* XOR */
1592 if (attr & (0x0100 << j))
1593 vram[xy + i * width / 8 + j * 0x10000] ^= cline;
1594 } else {
1595 /* replace */
1596 if (attr & (0x0100 << j))
1597 vram[xy + i * width / 8 + j * 0x10000] &= ~cline;
1598 else
1599 vram[xy + i * width / 8 + j * 0x10000] |= cline;
1600 }
1601 }
1602 }
1603
1604 return;
1605 }
1606 #endif
1607
1608 void tty_pause(void)
1609 {
1610 sigset_t set;
1611
1612 sigprocmask(0, 0, &set);
1613 sigdelset(&set, SIGIO);
1614 sigdelset(&set, SIGALRM);
1615 sigsuspend(&set);
1616 }
1617
1618 static int nextchar = 0;
1619
1620 int
1621 tty_read(REGISTERS, int flag)
1622 {
1623 int r;
1624
1625 if ((r = nextchar) != 0) {
1626 nextchar = 0;
1627 return(r & 0xff);
1628 }
1629
1630 if ((flag & TTYF_REDIRECT) && redirect0) {
1631 char c;
1632 if (read(STDIN_FILENO, &c, 1) != 1)
1633 return(-1);
1634 if (c == '\n')
1635 c = '\r';
1636 return(c);
1637 }
1638
1639 if (KbdEmpty()) {
1640 if (flag & TTYF_BLOCK) {
1641 while (KbdEmpty())
1642 tty_pause();
1643 } else {
1644 return(-1);
1645 }
1646 }
1647
1648 r = KbdRead();
1649 if ((r & 0xff) == 0)
1650 nextchar = r >> 8;
1651 r &= 0xff;
1652 if (flag & TTYF_CTRL) {
1653 if (r == 3) {
1654 /*
1655 * XXX - Not quite sure where we should return, maybe not
1656 * all the way to the user, but...
1657 */
1658 if (ivec[0x23] && (ivec[0x23] >> 16) != 0xF000) {
1659 fake_int(REGS, 0x23);
1660 R_EIP = R_EIP - 2;
1661 return(-2);
1662 }
1663 }
1664 }
1665 if (flag & TTYF_ECHO) {
1666 if ((flag & TTYF_ECHONL) && (r == '\n' || r == '\r')) {
1667 tty_write('\r', -1);
1668 tty_write('\n', -1);
1669 } else
1670 tty_write(r, -1);
1671 }
1672 return(r & 0xff);
1673 }
1674
1675 int
1676 tty_peek(REGISTERS, int flag)
1677 {
1678 int c = 0;
1679
1680 if (c == nextchar)
1681 return(nextchar & 0xff);
1682
1683 if (KbdEmpty()) {
1684 if (flag & TTYF_POLL) {
1685 sleep_poll();
1686 if (KbdEmpty())
1687 return(0);
1688 } else if (flag & TTYF_BLOCK) {
1689 while (KbdEmpty())
1690 tty_pause();
1691 } else
1692 return(0);
1693 }
1694 c = KbdPeek();
1695 if ((c & 0xff) == 3) {
1696 /*
1697 * XXX - Not quite sure where we should return, maybe not
1698 * all the way to the user, but...
1699 */
1700 if (ivec[0x23] && (ivec[0x23] >> 16) != 0xF000) {
1701 fake_int(REGS, 0x23);
1702 R_EIP = R_EIP - 2;
1703 return(-2);
1704 }
1705 }
1706 return(0xff);
1707 }
1708
1709 int
1710 tty_state(void)
1711 {
1712 return(K1_STATUS);
1713 }
1714
1715 int
1716 tty_estate(void)
1717 {
1718 int state = 0;
1719 if (K2_STATUS & K2_SYSREQ)
1720 state |= 0x80;
1721 if (K2_STATUS & K2_CLOCK)
1722 state |= 0x40;
1723 if (K2_STATUS & K2_NLOCK)
1724 state |= 0x20;
1725 if (K2_STATUS & K2_SLOCK)
1726 state |= 0x10;
1727 if (K3_STATUS & K3_RALT)
1728 state |= 0x08;
1729 if (K3_STATUS & K3_RCTRL)
1730 state |= 0x04;
1731 if (K2_STATUS & K2_LALT)
1732 state |= 0x02;
1733 if (K2_STATUS & K2_LCTRL)
1734 state |= 0x01;
1735 return(state);
1736 }
1737
1738 static int
1739 inrange(int a, int n, int x)
1740 {
1741 return(a < n ? n : a > x ? x : a);
1742 }
1743
1744 void
1745 tty_scroll(int sr, int sc, int er, int ec, int n, int attr)
1746 {
1747 int i, j;
1748
1749 sr = inrange(sr, 0, height);
1750 er = inrange(er, 0, height);
1751 sc = inrange(sc, 0, width);
1752 ec = inrange(ec, 0, width);
1753 if (sr > er || sc > ec)
1754 return;
1755 ++er;
1756 ++ec;
1757
1758 attr &= 0xff00;
1759 attr |= ' ';
1760
1761 if (n > 0 && n < er - sr) {
1762 for (j = sr; j < er - n; ) {
1763 memcpy(&vmem[j * width + sc],
1764 &vmem[(j + n) * width + sc],
1765 sizeof(vmem[0]) * (ec - sc));
1766 ++j;
1767 }
1768 } else
1769 n = er - sr;
1770 for (j = er - n; j < er; ) {
1771 for (i = sc; i < ec; ++i)
1772 vmem[j * width + i] = attr;
1773 ++j;
1774 }
1775 }
1776
1777 void
1778 tty_rscroll(int sr, int sc, int er, int ec, int n, int attr)
1779 {
1780 int i, j;
1781
1782 sr = inrange(sr, 0, height);
1783 er = inrange(er, 0, height);
1784 sc = inrange(sc, 0, width);
1785 ec = inrange(ec, 0, width);
1786 if (sr > er || sc > ec)
1787 return;
1788 ++er;
1789 ++ec;
1790
1791 attr &= 0xff00;
1792 attr |= ' ';
1793
1794 if (n > 0 && n < er - sr) {
1795 for (j = er; j > sr + n; ) {
1796 --j;
1797 memcpy(&vmem[j * width + sc],
1798 &vmem[(j - n) * width + sc],
1799 sizeof(vmem[0]) * (ec - sc));
1800 }
1801 } else
1802 n = er - sr;
1803 for (j = sr + n; j > sr; ) {
1804 --j;
1805 for (i = sc; i < ec; ++i)
1806 vmem[j * width + i] = attr;
1807 }
1808 }
1809
1810 int
1811 tty_char(int r, int c)
1812 {
1813 if (r == -1)
1814 r = row;
1815 if (c == -1)
1816 c = col;
1817 r = inrange(r, 0, height);
1818 c = inrange(c, 0, width);
1819 return(vmem[r * width + c]);
1820 }
1821
1822 int
1823 KbdEmpty(void)
1824 {
1825 return(K_NEXT == K_FREE);
1826 }
1827
1828 void
1829 KbdWrite(u_short code)
1830 {
1831 int kf;
1832
1833 kf = K_FREE + 2;
1834 if (kf == K_BUFENDP)
1835 kf = K_BUFSTARTP;
1836
1837 if (kf == K_NEXT) {
1838 #ifndef NO_X
1839 XBell(dpy, 0);
1840 #endif
1841 return;
1842 }
1843 K_BUF(K_FREE) = code;
1844 K_FREE = kf;
1845 }
1846
1847 u_short
1848 KbdRead(void)
1849 {
1850 int kf = K_NEXT;
1851
1852 K_NEXT = K_NEXT + 2;
1853 if (K_NEXT == K_BUFENDP)
1854 K_NEXT = K_BUFSTARTP;
1855
1856 return(K_BUF(kf));
1857 }
1858
1859 u_short
1860 KbdPeek(void)
1861 {
1862 return(K_BUF(K_NEXT));
1863 }
1864
1865 void
1866 kbd_init(void)
1867 {
1868 u_long vec;
1869
1870 define_input_port_handler(0x60, inb_port60);
1871
1872 K_BUFSTARTP = 0x1e; /* Start of keyboard buffer */
1873 K_BUFENDP = 0x3e; /* End of keyboard buffer */
1874 K_NEXT = K_FREE = K_BUFSTARTP;
1875
1876 vec = insert_hardint_trampoline();
1877 ivec[0x09] = vec;
1878 register_callback(vec, int09, "int 09");
1879
1880 return;
1881 }
1882
1883 void
1884 kbd_bios_init(void)
1885 {
1886 BIOSDATA[0x96] = 0x10; /* MF II kbd, 101 keys */
1887 K1_STATUS = 0;
1888 K2_STATUS = 0;
1889 K3_STATUS = 0;
1890 K4_STATUS = 0;
1891 }
1892
1893 #ifndef NO_X
1894 /* Calculate 16 bit RGB values for X from the 6 bit DAC values and the
1895 palette. This works for 16 and 256 color modes, although we don't really
1896 support the latter yet. */
1897 static void
1898 dac2rgb(XColor *color, int i)
1899 {
1900 int n, m;
1901
1902 /* 256 colors are easy; just take the RGB values from the DAC and
1903 shift left. For the pedants: multiplication with 65535./63. and
1904 rounding makes a difference of less than two percent. */
1905 if (VGA_ATC[ATC_ModeCtrl] & 0x40) {
1906 color->red = dac_rgb[i].red << 10;
1907 color->green = dac_rgb[i].green << 10;
1908 color->blue = dac_rgb[i].blue << 10;
1909
1910 return;
1911 }
1912
1913 /* For the 16 color modes, check bit 7 of the Mode Control register in
1914 the ATC. If set, we take bits 0-3 of the Color Select register and
1915 bits 0-3 of the palette register 'i' to build the index into the
1916 DAC table; otherwise, bits 2 and 3 of the CS reg and bits 0-5 of
1917 the palette register are used. Note that the entries in 'palette[]'
1918 are supposed to be already masked to 6 bits. */
1919 if (VGA_ATC[ATC_ModeCtrl] & 0x80) {
1920 n = VGA_ATC[ATC_ColorSelect] & 0x0f;
1921 m = palette[i] & 0x0f;
1922 } else {
1923 n = VGA_ATC[ATC_ColorSelect] & 0x0c;
1924 m = palette[i];
1925 }
1926 color->red = dac_rgb[16*n + m].red << 10;
1927 color->green = dac_rgb[16*n + m].green << 10;
1928 color->blue = dac_rgb[16*n + m].blue << 10;
1929 }
1930 #endif
1931
1932 /* Get a connection to the X server and create the window. */
1933 void
1934 init_window(void)
1935 {
1936 #ifndef NO_X
1937 XGCValues gcv;
1938 int i;
1939
1940 {
1941 /*
1942 * Arg... I can no longer change X's fd out from under it.
1943 * Open up all the available fd's, leave 3 behind for X
1944 * to play with, open X and then release all the other fds
1945 */
1946 int nfds = sysconf(_SC_OPEN_MAX);
1947 int *fds = malloc(sizeof(int) * nfds);
1948 i = 0;
1949 if (fds)
1950 for (i = 0; i < nfds && (i == 0 || fds[i-1] < 63); ++i)
1951 if ((fds[i] = open(_PATH_DEVNULL, 0)) < 0)
1952 break;
1953 /*
1954 * Leave 3 fds behind for X to play with
1955 */
1956 if (i > 0) close(fds[--i]);
1957 if (i > 0) close(fds[--i]);
1958 if (i > 0) close(fds[--i]);
1959
1960 dpy = XOpenDisplay(NULL);
1961
1962 while (i > 0)
1963 close(fds[--i]);
1964 }
1965 if (dpy == NULL)
1966 err(1, "Could not open display ``%s''\n", XDisplayName(NULL));
1967 xfd = ConnectionNumber(dpy);
1968
1969 _RegisterIO(xfd, video_async_event, 0, Failure);
1970 if (debug_flags & D_DEBUGIN)
1971 _RegisterIO(0, debug_event, 0, Failure);
1972
1973 /* Create window, but defer setting a size and GC. */
1974 win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0,
1975 1, 1, 2, black, black);
1976
1977 gcv.foreground = white;
1978 gcv.background = black;
1979 gc = XCreateGC(dpy, win, GCForeground | GCBackground, &gcv);
1980
1981 gcv.foreground = 1;
1982 gcv.background = 0;
1983 gcv.function = GXxor;
1984 cgc = XCreateGC(dpy, win, GCForeground|GCBackground|GCFunction, &gcv);
1985
1986 if (raw_kbd) {
1987 XSelectInput(dpy, win, ExposureMask | ButtonPressMask
1988 | ButtonReleaseMask | PointerMotionMask );
1989 } else {
1990 XSelectInput(dpy, win, KeyReleaseMask | KeyPressMask |
1991 ExposureMask | ButtonPressMask
1992 | ButtonReleaseMask | PointerMotionMask );
1993 }
1994
1995 XStoreName(dpy, win, "DOS");
1996
1997 /* Get the default visual and depth for later use. */
1998 depth = DefaultDepth(dpy, DefaultScreen(dpy));
1999 visual = DefaultVisual(dpy, DefaultScreen(dpy));
2000
2001 prepare_lut();
2002
2003 #if 0
2004 /* While we are developing the graphics code ... */
2005 call_on_quit(write_vram, NULL);
2006 #endif
2007 #endif
2008 }
2009
2010 void
2011 load_font(void)
2012 {
2013 #ifndef NO_X
2014 XGCValues gcv;
2015
2016 if (!xfont)
2017 xfont = FONTVGA;
2018
2019 font = XLoadQueryFont(dpy, xfont);
2020
2021 if (font == NULL)
2022 font = XLoadQueryFont(dpy, FONTVGA);
2023
2024 if (font == NULL)
2025 err(1, "Could not open font ``%s''\n", xfont);
2026
2027 gcv.font = font->fid;
2028 XChangeGC(dpy, gc, GCFont, &gcv);
2029
2030 FW = font->max_bounds.width;
2031 FH = font->max_bounds.ascent + font->max_bounds.descent;
2032 FD = font->max_bounds.descent;
2033
2034 /* Put the pixel representation at c000:3000. */
2035 switch (CharHeight) {
2036 case 8:
2037 memcpy((void *)0xc3000, font8x8, sizeof(font8x8));
2038 break;
2039 case 14:
2040 memcpy((void *)0xc3000, font8x14, sizeof(font8x14));
2041 break;
2042 case 16:
2043 memcpy((void *)0xc3000, font8x16, sizeof(font8x16));
2044 break;
2045 default:
2046 err(1, "load_font: CharHeight = %d?", CharHeight);
2047 }
2048
2049 return;
2050 #endif
2051 }
2052
2053 /* Get a new, or resize an old XImage as canvas for the graphics display. */
2054 void
2055 get_ximage(void)
2056 {
2057 #ifndef NO_X
2058 if (xi != NULL)
2059 XFree(xi);
2060
2061 xi = XCreateImage(dpy, visual, depth, ZPixmap, 0, NULL,
2062 width, height, 32, 0);
2063 if (xi == NULL)
2064 err(1, "Could not get ximage");
2065
2066 xi->data = malloc(width * height * depth / 8);
2067 if (xi->data == NULL) {
2068 XDestroyImage(xi);
2069 err(1, "Could not get memory for ximage data");
2070 }
2071
2072 return;
2073 #endif
2074 }
2075
2076 /* Get memory for the text line buffer. */
2077 void
2078 get_lines(void)
2079 {
2080 int i;
2081
2082 if (lines == NULL) {
2083 lines = (TextLine *)malloc(sizeof(TextLine) * height);
2084 if (lines == NULL)
2085 err(1, "Could not allocate data structure for text lines\n");
2086
2087 for (i = 0; i < height; ++i) {
2088 lines[i].max_length = width;
2089 lines[i].data = (u_short *)malloc(width * sizeof(u_short));
2090 if (lines[i].data == NULL)
2091 err(1, "Could not allocate data structure for text lines\n");
2092 lines[i].changed = 1;
2093 }
2094 } else {
2095 lines = (TextLine *)realloc(lines, sizeof(TextLine) * height);
2096 if (lines == NULL)
2097 err(1, "Could not allocate data structure for text lines\n");
2098
2099 for (i = 0; i < height; ++i) {
2100 lines[i].max_length = width;
2101 lines[i].data = (u_short *)realloc(lines[i].data,
2102 width * sizeof(u_short));
2103 if (lines[i].data == NULL)
2104 err(1, "Could not allocate data structure for text lines\n");
2105 lines[i].changed = 1;
2106 }
2107 }
2108 }
2109
2110 #ifndef NO_X
2111 /* Prepare the LUT for the VRAM -> XImage conversion. */
2112 static void
2113 prepare_lut(void)
2114 {
2115 int i, j, k;
2116
2117 for (i = 0; i < 4; i++) {
2118 for (j = 0; j < 256; j++) {
2119 for (k = 0; k < 8; k++) {
2120 lut[i][j][7 - k] = ((j & (1 << k)) ? (1 << i) : 0);
2121 }
2122 }
2123 }
2124
2125 return;
2126 }
2127 #endif
2128
2129 /* Resize the window, using information from 'vga_status[]'. This function is
2130 called after a mode change. */
2131 void
2132 resize_window(void)
2133 {
2134 #ifndef NO_X
2135 XSizeHints *sh;
2136 vmode_t vmode;
2137
2138 sh = XAllocSizeHints();
2139 if (sh == NULL)
2140 err(1, "Could not get XSizeHints structure");
2141 #endif
2142
2143 width = DpyCols;
2144 height = DpyRows + 1;
2145
2146 #ifndef NO_X
2147 vmode = vmodelist[find_vmode(VideoMode)];
2148 if (vmode.type == TEXT) {
2149 sh->base_width = FW * width + 4;
2150 sh->base_height = FH * height + 4;
2151 sh->base_width += 4;
2152 sh->base_height += 4;
2153 } else {
2154 width *= 8;
2155 height *= CharHeight;
2156 sh->base_width = width;
2157 sh->base_height = height;
2158 }
2159
2160 sh->min_width = sh->max_width = sh->base_width;
2161 sh->min_height = sh->max_height = sh->base_height;
2162 sh->flags = USSize | PMinSize | PMaxSize | PSize;
2163
2164 debug(D_VIDEO, "VGA: Set window size %dx%d\n",
2165 sh->base_width, sh->base_height);
2166
2167 XSetWMNormalHints(dpy, win, sh);
2168 XResizeWindow(dpy, win, sh->base_width, sh->base_height);
2169 XMapWindow(dpy, win);
2170 XFlush(dpy);
2171
2172 XFree(sh);
2173
2174 return;
2175 #endif
2176 }
2177
2178 /* Calculate 'pixels[]' from the current DAC table and palette.
2179
2180 To do: do not use 'pixels[]', use an array of 'XColor's which we can
2181 allocate and free on demand. Install a private colormap if necessary. */
2182 void
2183 update_pixels(void)
2184 {
2185 #ifndef NO_X
2186 int i;
2187
2188 /* We support only 16 colors for now. */
2189 for (i = 0; i < 16; i++) {
2190 XColor color;
2191
2192 dac2rgb(&color, i);
2193 if (XAllocColor(dpy,
2194 DefaultColormap(dpy, DefaultScreen(dpy)), &color)) {
2195 pixels[i] = color.pixel;
2196 } else if (i < 7)
2197 pixels[i] = BlackPixel(dpy, DefaultScreen(dpy));
2198 else
2199 pixels[i] = WhitePixel(dpy, DefaultScreen(dpy));
2200 }
2201 #endif
2202 }
2203
2204 void
2205 write_vram(void *arg __unused)
2206 {
2207 int fd;
2208
2209 if ((fd = open("vram", O_WRONLY | O_CREAT, 0644)) == -1)
2210 err(1, "Can't open vram file");
2211 (void)write(fd, (void *)vram, 256 * 1024);
2212
2213 return;
2214 }
DragonFly BSD