--- Gnu-Mach/i386/i386at/kd.c 2020/09/02 04:36:58 1.1 +++ Gnu-Mach/i386/i386at/kd.c 2020/09/02 04:51:31 1.1.1.6 @@ -1,34 +1,34 @@ -/* +/* * Mach Operating System * Copyright (c) 1991,1990,1989 Carnegie Mellon University * All Rights Reserved. - * + * * Permission to use, copy, modify and distribute this software and its * documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. - * + * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. - * + * * Carnegie Mellon requests users of this software to return to - * + * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 - * + * * any improvements or extensions that they make and grant Carnegie Mellon * the rights to redistribute these changes. */ -/* +/* * Olivetti Mach Console driver v0.0 * Copyright Ing. C. Olivetti & C. S.p.A. 1988, 1989 * All rights reserved. * - */ + */ /* Copyright 1988, 1989 by Olivetti Advanced Technology Center, Inc., Cupertino, California. @@ -76,63 +76,41 @@ WITH THE USE OR PERFORMANCE OF THIS SOFT /* $ Header: $ */ -#include - #include -#include +#include +#include +#include #include #include #include -#include /* for struct uio (!) */ -#include +#include #include -#include "vm_param.h" +#include +#include +#include #include +#include #include #include +#include +#include #include -#include - -#include -#if NBLIT > 0 -#include -#else -#define blit_present() FALSE -#define blit_init() /* nothing */ -#endif - -#include -#if NEVC > 0 -int evc1init(); -#else -#define evc1init() FALSE -#endif +#include +#include #define DEBUG 1 /* export feep() */ -#define DEFAULT -1 /* see kd_atoi */ - -void kd_enqsc(); /* enqueues a scancode */ - -void timeout(); - #if 0 #define BROKEN_KEYBOARD_RESET #endif struct tty kd_tty; -extern int rebootflag; +extern boolean_t rebootflag; static void charput(), charmvup(), charmvdown(), charclear(), charsetcursor(); -static void kd_noopreset(); -boolean_t kdcheckmagic(); - -int kdcnprobe(struct consdev *cp); -int kdcninit(struct consdev *cp); -int kdcngetc(dev_t dev, int wait); -int kdcnputc(dev_t dev, int c); +static void kd_noopreset(void); -/* +/* * These routines define the interface to the device-specific layer. * See kdsoft.h for a more complete description of what each routine does. */ @@ -144,25 +122,23 @@ void (*kd_dsetcursor)() = charsetcursor; /* set cursor position on displayed page */ void (*kd_dreset)() = kd_noopreset; /* prepare for reboot */ -/* forward declarations */ -unsigned char kd_getdata(), state2leds(); - - /* * Globals used for both character-based controllers and bitmap-based * controllers. Default is EGA. */ vm_offset_t kd_bitmap_start = (vm_offset_t)0xa0000; /* XXX - put in kd.h */ -u_char *vid_start = (u_char *)EGA_START; +u_char *vid_start = (u_char *)EGA_START; /* VM start of video RAM or frame buffer */ csrpos_t kd_curpos = 0; /* set indirectly by kd_setpos--see kdsoft.h */ short kd_lines = 25; short kd_cols = 80; char kd_attr = KA_NORMAL; /* current attribute */ +char kd_color = KA_NORMAL; +char kd_attrflags = 0; /* Not reverse, underline, blink */ -/* - * kd_state shows the state of the modifier keys (ctrl, caps lock, +/* + * kd_state shows the state of the modifier keys (ctrl, caps lock, * etc.) It should normally be changed by calling set_kd_state(), so * that the keyboard status LEDs are updated correctly. */ @@ -176,18 +152,18 @@ int kd_kbd_mouse = 0; int kd_kbd_magic_scale = 6; int kd_kbd_magic_button = 0; -/* - * Some keyboard commands work by sending a command, waiting for an - * ack (handled by kdintr), then sending data, which generates a +/* + * Some keyboard commands work by sending a command, waiting for an + * ack (handled by kdintr), then sending data, which generates a * second ack. If we are in the middle of such a sequence, kd_ack * shows what the ack is for. - * - * When a byte is sent to the keyboard, it is kept around in last_sent + * + * When a byte is sent to the keyboard, it is kept around in last_sent * in case it needs to be resent. - * + * * The rest of the variables here hold the data required to complete * the sequence. - * + * * XXX - the System V driver keeps a command queue, I guess in case we * want to start a command while another is in progress. Is this * something we should worry about? @@ -208,113 +184,122 @@ boolean_t kd_initialized = FALSE; /* dr boolean_t kd_extended = FALSE; /* Array for processing escape sequences. */ -#define K_MAXESC 16 +#define K_MAXESC 32 u_char esc_seq[K_MAXESC]; u_char *esc_spt = (u_char *)0; /* * This array maps scancodes to Ascii characters (or character - * sequences). + * sequences). * Each row corresponds to one key. There are NUMOUTPUT bytes per key * state. The states are ordered: Normal, SHIFT, CTRL, ALT, * SHIFT/ALT. */ + +/* This new keymap from Tudor Hulubei (tudor@cs.unh.edu) makes the + following changes to the keyboard driver: + + - Alt + key (m-key) returns `ESC key' instead of `ESC N key'. + - Backspace returns 0x7f instead of 0x08. + - Delete returns `ESC [ 9' instead of 0x7f. + - Alt + function keys return key sequences that are different + from the key sequences returned by the function keys alone. + This is done with the idea of allowing a terminal server to + implement multiple virtual consoles mapped on Alt+F1, Alt+F2, + etc, as in Linux. + + -- Derek Upham 1997/06/25 */ + unsigned char key_map[NUMKEYS][WIDTH_KMAP] = { -{NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC}, -{K_ESC,NC,NC, K_ESC,NC,NC, K_ESC,NC,NC, K_ESC,NC,NC, K_ESC,NC,NC}, -{K_ONE,NC,NC, K_BANG,NC,NC, K_ONE,NC,NC, 0x1b,0x4e,0x31, 0x1b,0x4e,0x21}, -{K_TWO,NC,NC, K_ATSN,NC,NC, K_NUL,NC,NC, 0x1b,0x4e,0x32, 0x1b,0x4e,0x40}, -{K_THREE,NC,NC, K_POUND,NC,NC, K_THREE,NC,NC, 0x1b,0x4e,0x33, 0x1b,0x4e,0x23}, -{K_FOUR,NC,NC, K_DOLLAR,NC,NC, K_FOUR,NC,NC, 0x1b,0x4e,0x34, 0x1b,0x4e,0x24}, -{K_FIVE,NC,NC, K_PERC,NC,NC, K_FIVE,NC,NC, 0x1b,0x4e,0x35, 0x1b,0x4e,0x25}, -{K_SIX,NC,NC, K_CARET,NC,NC, K_RS,NC,NC, 0x1b,0x4e,0x36, 0x1b,0x4e,0x5e}, -{K_SEVEN,NC,NC, K_AMPER,NC,NC, K_SEVEN,NC,NC, 0x1b,0x4e,0x37, 0x1b,0x4e,0x26}, -{K_EIGHT,NC,NC, K_ASTER,NC,NC, K_EIGHT,NC,NC, 0x1b,0x4e,0x38, 0x1b,0x4e,0x2a}, -{K_NINE,NC,NC, K_LPAREN,NC,NC, K_NINE,NC,NC, 0x1b,0x4e,0x39,0x1b,0x4e,0x28}, -{K_ZERO,NC,NC, K_RPAREN,NC,NC, K_ZERO,NC,NC, 0x1b,0x4e,0x30,0x1b,0x4e,0x29}, -{K_MINUS,NC,NC, K_UNDSC,NC,NC, K_US,NC,NC, 0x1b,0x4e,0x2d, 0x1b,0x4e,0x5f}, -{K_EQL,NC,NC, K_PLUS,NC,NC, K_EQL,NC,NC, 0x1b,0x4e,0x3d, 0x1b,0x4e,0x2b}, -{K_BS,NC,NC, K_BS,NC,NC, K_BS,NC,NC, K_BS,NC,NC, K_BS,NC,NC}, -{K_HT,NC,NC, K_GS,NC,NC, K_HT,NC,NC, K_HT,NC,NC, K_GS,NC,NC}, -{K_q,NC,NC, K_Q,NC,NC, K_DC1,NC,NC, 0x1b,0x4e,0x71, 0x1b,0x4e,0x51}, -{K_w,NC,NC, K_W,NC,NC, K_ETB,NC,NC, 0x1b,0x4e,0x77, 0x1b,0x4e,0x57}, -{K_e,NC,NC, K_E,NC,NC, K_ENQ,NC,NC, 0x1b,0x4e,0x65, 0x1b,0x4e,0x45}, -{K_r,NC,NC, K_R,NC,NC, K_DC2,NC,NC, 0x1b,0x4e,0x72, 0x1b,0x4e,0x52}, -{K_t,NC,NC, K_T,NC,NC, K_DC4,NC,NC, 0x1b,0x4e,0x74, 0x1b,0x4e,0x54}, -{K_y,NC,NC, K_Y,NC,NC, K_EM,NC,NC, 0x1b,0x4e,0x79, 0x1b,0x4e,0x59}, -{K_u,NC,NC, K_U,NC,NC, K_NAK,NC,NC, 0x1b,0x4e,0x75, 0x1b,0x4e,0x55}, -{K_i,NC,NC, K_I,NC,NC, K_HT,NC,NC, 0x1b,0x4e,0x69, 0x1b,0x4e,0x49}, -{K_o,NC,NC, K_O,NC,NC, K_SI,NC,NC, 0x1b,0x4e,0x6f, 0x1b,0x4e,0x4f}, -{K_p,NC,NC, K_P,NC,NC, K_DLE,NC,NC, 0x1b,0x4e,0x70, 0x1b,0x4e,0x50}, -{K_LBRKT,NC,NC, K_LBRACE,NC,NC, K_ESC,NC,NC, 0x1b,0x4e,0x5b, 0x1b,0x4e,0x7b}, -{K_RBRKT,NC,NC, K_RBRACE,NC,NC, K_GS,NC,NC, 0x1b,0x4e,0x5d, 0x1b,0x4e,0x7d}, -{K_CR,NC,NC, K_CR,NC,NC, K_CR,NC,NC, K_CR,NC,NC, K_CR,NC,NC}, -{K_SCAN,K_CTLSC,NC, K_SCAN,K_CTLSC,NC, K_SCAN,K_CTLSC,NC, K_SCAN,K_CTLSC,NC, - K_SCAN,K_CTLSC,NC}, -{K_a,NC,NC, K_A,NC,NC, K_SOH,NC,NC, 0x1b,0x4e,0x61, 0x1b,0x4e,0x41}, -{K_s,NC,NC, K_S,NC,NC, K_DC3,NC,NC, 0x1b,0x4e,0x73, 0x1b,0x4e,0x53}, -{K_d,NC,NC, K_D,NC,NC, K_EOT,NC,NC, 0x1b,0x4e,0x65, 0x1b,0x4e,0x45}, -{K_f,NC,NC, K_F,NC,NC, K_ACK,NC,NC, 0x1b,0x4e,0x66, 0x1b,0x4e,0x46}, -{K_g,NC,NC, K_G,NC,NC, K_BEL,NC,NC, 0x1b,0x4e,0x67, 0x1b,0x4e,0x47}, -{K_h,NC,NC, K_H,NC,NC, K_BS,NC,NC, 0x1b,0x4e,0x68, 0x1b,0x4e,0x48}, -{K_j,NC,NC, K_J,NC,NC, K_LF,NC,NC, 0x1b,0x4e,0x6a, 0x1b,0x4e,0x4a}, -{K_k,NC,NC, K_K,NC,NC, K_VT,NC,NC, 0x1b,0x4e,0x6b, 0x1b,0x4e,0x4b}, -{K_l,NC,NC, K_L,NC,NC, K_FF,NC,NC, 0x1b,0x4e,0x6c, 0x1b,0x4e,0x4c}, -{K_SEMI,NC,NC, K_COLON,NC,NC, K_SEMI,NC,NC, 0x1b,0x4e,0x3b, 0x1b,0x4e,0x3a}, -{K_SQUOTE,NC,NC,K_DQUOTE,NC,NC,K_SQUOTE,NC,NC,0x1b,0x4e,0x27,0x1b,0x4e,0x22}, -{K_GRAV,NC,NC, K_TILDE,NC,NC, K_RS,NC,NC, 0x1b,0x4e,0x60, 0x1b,0x4e,0x7e}, -{K_SCAN,K_LSHSC,NC, K_SCAN,K_LSHSC,NC, K_SCAN,K_LSHSC,NC, K_SCAN,K_LSHSC,NC, - K_SCAN,K_LSHSC,NC}, -{K_BSLSH,NC,NC, K_PIPE,NC,NC, K_FS,NC,NC, 0x1b,0x4e,0x5c, 0x1b,0x4e,0x7c}, -{K_z,NC,NC, K_Z,NC,NC, K_SUB,NC,NC, 0x1b,0x4e,0x7a, 0x1b,0x4e,0x5a}, -{K_x,NC,NC, K_X,NC,NC, K_CAN,NC,NC, 0x1b,0x4e,0x78, 0x1b,0x4e,0x58}, -{K_c,NC,NC, K_C,NC,NC, K_ETX,NC,NC, 0x1b,0x4e,0x63, 0x1b,0x4e,0x43}, -{K_v,NC,NC, K_V,NC,NC, K_SYN,NC,NC, 0x1b,0x4e,0x76, 0x1b,0x4e,0x56}, -{K_b,NC,NC, K_B,NC,NC, K_STX,NC,NC, 0x1b,0x4e,0x62, 0x1b,0x4e,0x42}, -{K_n,NC,NC, K_N,NC,NC, K_SO,NC,NC, 0x1b,0x4e,0x6e, 0x1b,0x4e,0x4e}, -{K_m,NC,NC, K_M,NC,NC, K_CR,NC,NC, 0x1b,0x4e,0x6d, 0x1b,0x4e,0x4d}, -{K_COMMA,NC,NC, K_LTHN,NC,NC, K_COMMA,NC,NC, 0x1b,0x4e,0x2c, 0x1b,0x4e,0x3c}, -{K_PERIOD,NC,NC, K_GTHN,NC,NC, K_PERIOD,NC,NC,0x1b,0x4e,0x2e,0x1b,0x4e,0x3e}, -{K_SLASH,NC,NC, K_QUES,NC,NC, K_SLASH,NC,NC, 0x1b,0x4e,0x2f, 0x1b,0x4e,0x3f}, -{K_SCAN,K_RSHSC,NC, K_SCAN,K_RSHSC,NC, K_SCAN,K_RSHSC,NC, K_SCAN,K_RSHSC,NC, - K_SCAN,K_RSHSC,NC}, -{K_ASTER,NC,NC, K_ASTER,NC,NC, K_ASTER,NC,NC, 0x1b,0x4e,0x2a,0x1b,0x4e,0x2a}, -{K_SCAN,K_ALTSC,NC, K_SCAN,K_ALTSC,NC, K_SCAN,K_ALTSC,NC, K_SCAN,K_ALTSC,NC, - K_SCAN,K_ALTSC,NC}, -{K_SPACE,NC,NC, K_SPACE,NC,NC, K_NUL,NC,NC, K_SPACE,NC,NC, K_SPACE,NC,NC}, -{K_SCAN,K_CLCKSC,NC, K_SCAN,K_CLCKSC,NC, K_SCAN,K_CLCKSC,NC, - K_SCAN,K_CLCKSC,NC, K_SCAN,K_CLCKSC,NC}, -{K_F1, K_F1S, K_F1, K_F1, K_F1S}, -{K_F2, K_F2S, K_F2, K_F2, K_F2S}, -{K_F3, K_F3S, K_F3, K_F3, K_F3S}, -{K_F4, K_F4S, K_F4, K_F4, K_F4S}, -{K_F5, K_F5S, K_F5, K_F5, K_F5S}, -{K_F6, K_F6S, K_F6, K_F6, K_F6S}, -{K_F7, K_F7S, K_F7, K_F7, K_F7S}, -{K_F8, K_F8S, K_F8, K_F8, K_F8S}, -{K_F9, K_F9S, K_F9, K_F9, K_F9S}, -{K_F10, K_F10S, K_F10, K_F10, K_F10S}, -{K_SCAN,K_NLCKSC,NC, K_SCAN,K_NLCKSC,NC, K_SCAN,K_NLCKSC,NC, - K_SCAN,K_NLCKSC,NC, K_SCAN,K_NLCKSC,NC}, -{K_SCRL, K_NUL,NC,NC, K_SCRL, K_SCRL, K_NUL,NC,NC}, -{K_HOME, K_SEVEN,NC,NC, K_HOME, K_HOME, 0x1b,0x4e,0x37}, -{K_UA, K_EIGHT,NC,NC, K_UA, K_UA, 0x1b,0x4e,0x38}, -{K_PUP, K_NINE,NC,NC, K_PUP, K_PUP, 0x1b,0x4e,0x39}, -{0x1b,0x5b,0x53, K_MINUS,NC,NC, 0x1b,0x5b,0x53,0x1b,0x5b,0x53,0x1b,0x4e,0x2d}, -{K_LA, K_FOUR,NC,NC, K_LA, K_LA, 0x1b,0x4e,0x34}, -{0x1b,0x5b,0x47,K_FIVE,NC,NC,0x1b,0x5b,0x47, 0x1b,0x5b,0x47, 0x1b,0x4e,0x35}, -{K_RA, K_SIX,NC,NC, K_RA, K_RA, 0x1b,0x4e,0x36}, -{0x1b,0x5b,0x54,K_PLUS,NC,NC, 0x1b,0x5b,0x54, 0x1b,0x5b,0x54, 0x1b,0x4e,0x2b}, -{K_END, K_ONE,NC,NC, K_END, K_END, 0x1b,0x4e,0x31}, -{K_DA, K_TWO,NC,NC, K_DA, K_DA, 0x1b,0x4e,0x32}, -{K_PDN, K_THREE,NC,NC, K_PDN, K_PDN, 0x1b,0x4e,0x33}, -{K_INS, K_ZERO,NC,NC, K_INS, K_INS, 0x1b,0x4e,0x30}, -{K_DEL,NC,NC, K_PERIOD,NC,NC, K_DEL,NC,NC, K_DEL,NC,NC, 0x1b,0x4e,0x2e}, -{NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC}, -{NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC}, -{NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC,NC}, -{K_F11, K_F11S, K_F11, K_F11, K_F11S}, -{K_F12, K_F12S, K_F12, K_F12, K_F12S} +{NC,NC,NC, NC,NC,NC, NC,NC,NC, NC,NC,NC, NC,NC,NC}, +{K_ESC,NC,NC, K_ESC,NC,NC, K_ESC,NC,NC, 0x1b,K_ESC,NC, K_ESC,NC,NC}, +{K_ONE,NC,NC, K_BANG,NC,NC, K_ONE,NC,NC, 0x1b,K_ONE,NC, 0x1b,0x4e,K_BANG}, +{K_TWO,NC,NC, K_ATSN,NC,NC, K_NUL,NC,NC, 0x1b,K_TWO,NC, 0x1b,0x4e,K_ATSN}, +{K_THREE,NC,NC, K_POUND,NC,NC, K_THREE,NC,NC, 0x1b,K_THREE,NC, 0x1b,0x4e,K_POUND}, +{K_FOUR,NC,NC, K_DOLLAR,NC,NC, K_FOUR,NC,NC, 0x1b,K_FOUR,NC, 0x1b,0x4e,K_DOLLAR}, +{K_FIVE,NC,NC, K_PERC,NC,NC, K_FIVE,NC,NC, 0x1b,K_FIVE,NC, 0x1b,0x4e,K_PERC}, +{K_SIX,NC,NC, K_CARET,NC,NC, K_RS,NC,NC, 0x1b,K_SIX,NC, 0x1b,0x4e,K_CARET}, +{K_SEVEN,NC,NC, K_AMPER,NC,NC, K_SEVEN,NC,NC, 0x1b,K_SEVEN,NC, 0x1b,0x4e,K_AMPER}, +{K_EIGHT,NC,NC, K_ASTER,NC,NC, K_EIGHT,NC,NC, 0x1b,K_EIGHT,NC, 0x1b,0x4e,K_ASTER}, +{K_NINE,NC,NC, K_LPAREN,NC,NC, K_NINE,NC,NC, 0x1b,K_NINE,NC, 0x1b,0x4e,K_LPAREN}, +{K_ZERO,NC,NC, K_RPAREN,NC,NC, K_ZERO,NC,NC, 0x1b,K_ZERO,NC, 0x1b,0x4e,K_RPAREN}, +{K_MINUS,NC,NC, K_UNDSC,NC,NC, K_US,NC,NC, 0x1b,K_MINUS,NC, 0x1b,0x4e,K_UNDSC}, +{K_EQL,NC,NC, K_PLUS,NC,NC, K_EQL,NC,NC, 0x1b,K_EQL,NC, 0x1b,0x4e,K_PLUS}, +{K_DEL,NC,NC, K_DEL,NC,NC, K_DEL,NC,NC, 0x1b,K_DEL,NC, K_DEL,NC,NC}, +{K_HT,NC,NC, K_GS,NC,NC, K_HT,NC,NC, 0x1b,K_HT,NC, K_GS,NC,NC}, +{K_q,NC,NC, K_Q,NC,NC, K_DC1,NC,NC, 0x1b,K_q,NC, 0x1b,0x4e,K_Q}, +{K_w,NC,NC, K_W,NC,NC, K_ETB,NC,NC, 0x1b,K_w,NC, 0x1b,0x4e,K_W}, +{K_e,NC,NC, K_E,NC,NC, K_ENQ,NC,NC, 0x1b,K_e,NC, 0x1b,0x4e,K_E}, +{K_r,NC,NC, K_R,NC,NC, K_DC2,NC,NC, 0x1b,K_r,NC, 0x1b,0x4e,K_R}, +{K_t,NC,NC, K_T,NC,NC, K_DC4,NC,NC, 0x1b,K_t,NC, 0x1b,0x4e,K_T}, +{K_y,NC,NC, K_Y,NC,NC, K_EM,NC,NC, 0x1b,K_y,NC, 0x1b,0x4e,K_Y}, +{K_u,NC,NC, K_U,NC,NC, K_NAK,NC,NC, 0x1b,K_u,NC, 0x1b,0x4e,K_U}, +{K_i,NC,NC, K_I,NC,NC, K_HT,NC,NC, 0x1b,K_i,NC, 0x1b,0x4e,K_I}, +{K_o,NC,NC, K_O,NC,NC, K_SI,NC,NC, 0x1b,K_o,NC, 0x1b,0x4e,K_O}, +{K_p,NC,NC, K_P,NC,NC, K_DLE,NC,NC, 0x1b,K_p,NC, 0x1b,0x4e,K_P}, +{K_LBRKT,NC,NC, K_LBRACE,NC,NC, K_ESC,NC,NC, 0x1b,K_LBRKT,NC, 0x1b,0x4e,K_LBRACE}, +{K_RBRKT,NC,NC, K_RBRACE,NC,NC, K_GS,NC,NC, 0x1b,K_RBRKT,NC, 0x1b,0x4e,K_RBRACE}, +{K_CR,NC,NC, K_CR,NC,NC, K_CR,NC,NC, 0x1b,K_CR,NC, K_CR,NC,NC}, +{K_SCAN,K_CTLSC,NC, K_SCAN,K_CTLSC,NC, K_SCAN,K_CTLSC,NC, K_SCAN,K_CTLSC,NC, K_SCAN,K_CTLSC,NC}, +{K_a,NC,NC, K_A,NC,NC, K_SOH,NC,NC, 0x1b,K_a,NC, 0x1b,0x4e,K_A}, +{K_s,NC,NC, K_S,NC,NC, K_DC3,NC,NC, 0x1b,K_s,NC, 0x1b,0x4e,K_S}, +{K_d,NC,NC, K_D,NC,NC, K_EOT,NC,NC, 0x1b,K_d,NC, 0x1b,0x4e,K_D}, +{K_f,NC,NC, K_F,NC,NC, K_ACK,NC,NC, 0x1b,K_f,NC, 0x1b,0x4e,K_F}, +{K_g,NC,NC, K_G,NC,NC, K_BEL,NC,NC, 0x1b,K_g,NC, 0x1b,0x4e,K_G}, +{K_h,NC,NC, K_H,NC,NC, K_BS,NC,NC, 0x1b,K_h,NC, 0x1b,0x4e,K_H}, +{K_j,NC,NC, K_J,NC,NC, K_LF,NC,NC, 0x1b,K_j,NC, 0x1b,0x4e,K_J}, +{K_k,NC,NC, K_K,NC,NC, K_VT,NC,NC, 0x1b,K_k,NC, 0x1b,0x4e,K_K}, +{K_l,NC,NC, K_L,NC,NC, K_FF,NC,NC, 0x1b,K_l,NC, 0x1b,0x4e,K_L}, +{K_SEMI,NC,NC, K_COLON,NC,NC, K_SEMI,NC,NC, 0x1b,K_SEMI,NC, 0x1b,0x4e,K_COLON}, +{K_SQUOTE,NC,NC,K_DQUOTE,NC,NC, K_SQUOTE,NC,NC,0x1b,K_SQUOTE,NC, 0x1b,0x4e,K_DQUOTE}, +{K_GRAV,NC,NC, K_TILDE,NC,NC, K_RS,NC,NC, 0x1b,K_GRAV,NC, 0x1b,0x4e,K_TILDE}, +{K_SCAN,K_LSHSC,NC, K_SCAN,K_LSHSC,NC, K_SCAN,K_LSHSC,NC, K_SCAN,K_LSHSC,NC, K_SCAN,K_LSHSC,NC}, +{K_BSLSH,NC,NC, K_PIPE,NC,NC, K_FS,NC,NC, 0x1b,K_BSLSH,NC, 0x1b,0x4e,K_PIPE}, +{K_z,NC,NC, K_Z,NC,NC, K_SUB,NC,NC, 0x1b,K_z,NC, 0x1b,0x4e,K_Z}, +{K_x,NC,NC, K_X,NC,NC, K_CAN,NC,NC, 0x1b,K_x,NC, 0x1b,0x4e,K_X}, +{K_c,NC,NC, K_C,NC,NC, K_ETX,NC,NC, 0x1b,K_c,NC, 0x1b,0x4e,K_C}, +{K_v,NC,NC, K_V,NC,NC, K_SYN,NC,NC, 0x1b,K_v,NC, 0x1b,0x4e,K_V}, +{K_b,NC,NC, K_B,NC,NC, K_STX,NC,NC, 0x1b,K_b,NC, 0x1b,0x4e,K_B}, +{K_n,NC,NC, K_N,NC,NC, K_SO,NC,NC, 0x1b,K_n,NC, 0x1b,0x4e,K_N}, +{K_m,NC,NC, K_M,NC,NC, K_CR,NC,NC, 0x1b,K_m,NC, 0x1b,0x4e,K_M}, +{K_COMMA,NC,NC, K_LTHN,NC,NC, K_COMMA,NC,NC, 0x1b,K_COMMA,NC, 0x1b,0x4e,K_LTHN}, +{K_PERIOD,NC,NC,K_GTHN,NC,NC, K_PERIOD,NC,NC,0x1b,K_PERIOD,NC, 0x1b,0x4e,K_GTHN}, +{K_SLASH,NC,NC, K_QUES,NC,NC, K_SLASH,NC,NC, 0x1b,K_SLASH,NC, 0x1b,0x4e,K_QUES}, +{K_SCAN,K_RSHSC,NC, K_SCAN,K_RSHSC,NC, K_SCAN,K_RSHSC,NC, K_SCAN,K_RSHSC,NC, K_SCAN,K_RSHSC,NC}, +{K_ASTER,NC,NC, K_ASTER,NC,NC, K_ASTER,NC,NC, 0x1b,K_ASTER,NC, 0x1b,0x4e,K_ASTER}, +{K_SCAN,K_ALTSC,NC, K_SCAN,K_ALTSC,NC, K_SCAN,K_ALTSC,NC, K_SCAN,K_ALTSC,NC, K_SCAN,K_ALTSC,NC}, +{K_SPACE,NC,NC, K_SPACE,NC,NC, K_NUL,NC,NC, 0x1b,K_SPACE,NC, K_SPACE,NC,NC}, +{K_SCAN,K_CLCKSC,NC, K_SCAN,K_CLCKSC,NC, K_SCAN,K_CLCKSC,NC, K_SCAN,K_CLCKSC,NC, K_SCAN,K_CLCKSC,NC}, +{K_F1, K_F1S, K_F1, K_F1A, K_F1S}, +{K_F2, K_F2S, K_F2, K_F2A, K_F2S}, +{K_F3, K_F3S, K_F3, K_F3A, K_F3S}, +{K_F4, K_F4S, K_F4, K_F4A, K_F4S}, +{K_F5, K_F5S, K_F5, K_F5A, K_F5S}, +{K_F6, K_F6S, K_F6, K_F6A, K_F6S}, +{K_F7, K_F7S, K_F7, K_F7A, K_F7S}, +{K_F8, K_F8S, K_F8, K_F8A, K_F8S}, +{K_F9, K_F9S, K_F9, K_F9A, K_F9S}, +{K_F10, K_F10S, K_F10, K_F10A, K_F10S}, +{K_SCAN,K_NLCKSC,NC, K_SCAN,K_NLCKSC,NC, K_SCAN,K_NLCKSC,NC, K_SCAN,K_NLCKSC,NC, K_SCAN,K_NLCKSC,NC}, +{K_SCRL, K_NUL,NC,NC, K_SCRL, K_SCRL, K_NUL,NC,NC}, +{K_HOME, K_SEVEN,NC,NC, K_HOME, K_HOME, 0x1b,0x4e,K_SEVEN}, +{K_UA, K_EIGHT,NC,NC, K_UA, K_UA, 0x1b,0x4e,K_EIGHT}, +{K_PUP, K_NINE,NC,NC, K_PUP, K_PUP, 0x1b,0x4e,K_NINE}, +{0x1b,0x5b,0x53, K_MINUS,NC,NC, 0x1b,0x5b,0x53, 0x1b,0x5b,0x53, 0x1b,0x4e,0x2d}, +{K_LA, K_FOUR,NC,NC, K_LA, K_LA, 0x1b,0x4e,K_FOUR}, +{0x1b,0x5b,0x47, K_FIVE,NC,NC, 0x1b,0x5b,0x47, 0x1b,0x5b,0x47, 0x1b,0x4e,0x35}, +{K_RA, K_SIX,NC,NC, K_RA, K_RA, 0x1b,0x4e,K_SIX}, +{0x1b,0x5b,0x54, K_PLUS,NC,NC, 0x1b,0x5b,0x54, 0x1b,0x5b,0x54, 0x1b,0x4e,0x2b}, +{K_END, K_ONE,NC,NC, K_END, K_END, 0x1b,0x4e,K_ONE}, +{K_DA, K_TWO,NC,NC, K_DA, K_DA, 0x1b,0x4e,K_TWO}, +{K_PDN, K_THREE,NC,NC, K_PDN, K_PDN, 0x1b,0x4e,K_THREE}, +{K_INS, K_ZERO,NC,NC, K_INS, K_INS, 0x1b,0x4e,K_ZERO}, +{0x1b,0x5b,0x39, K_PERIOD,NC,NC, K_DEL,NC,NC, K_DEL,NC,NC, 0x1b,0x4e,K_PERIOD}, +{NC,NC,NC, NC,NC,NC, NC,NC,NC, NC,NC,NC, NC,NC,NC}, +{NC,NC,NC, NC,NC,NC, NC,NC,NC, NC,NC,NC, NC,NC,NC}, +{NC,NC,NC, NC,NC,NC, NC,NC,NC, NC,NC,NC, NC,NC,NC}, +{K_F11, K_F11S, K_F11, K_F11A, K_F11S}, +{K_F12, K_F12S, K_F12, K_F12A, K_F12S} }; @@ -325,31 +310,6 @@ unsigned char key_map[NUMKEYS][WIDTH_KMA short kd_index_reg = EGA_IDX_REG; short kd_io_reg = EGA_IO_REG; -/* - * IO port sets for different controllers. - */ -io_reg_t vga_port_list[] = { - 0x3b4, 0x3b5, 0x3b8, 0x3b9, 0x3ba, /* MDA/EGA */ - 0x3d4, 0x3d5, 0x3d8, 0x3d9, 0x3da, /* CGA/EGA */ - 0x3c0, 0x3c1, 0x3c2, 0x3c3, 0x3c4, 0x3c5, 0x3c6, 0x3c7, - 0x3c8, 0x3c9, 0x3ca, 0x3cb, 0x3cc, 0x3cd, 0x3ce, 0x3cf, - IO_REG_NULL -}; - -mach_device_t kd_io_device = 0; - -kd_io_map_open(device) - mach_device_t device; -{ - kd_io_device = device; - io_port_create(device, vga_port_list); -} - -kd_io_map_close() -{ - io_port_destroy(kd_io_device); - kd_io_device = 0; -} /* * Globals used only for bitmap-based controllers. See kdsoft.h for @@ -382,23 +342,25 @@ short font_byte_width = 0; /* num bytes int kd_pollc = 0; #ifdef DEBUG -/* +/* * feep: * - * Ring the bell for a short time. + * Ring the bell for a short time. * Warning: uses outb(). You may prefer to use kd_debug_put. */ -feep() +void +feep(void) { int i; kd_bellon(); for (i = 0; i < 50000; ++i) ; - kd_belloff(); + kd_belloff(NULL); } -pause() +void +pause(void) { int i; @@ -406,14 +368,15 @@ pause() ; } -/* +/* * Put a debugging character on the screen. - * LOC=0 means put it in the bottom right corner, LOC=1 means put it + * LOC=0 means put it in the bottom right corner, LOC=1 means put it * one column to the left, etc. */ -kd_debug_put(loc, c) -int loc; -char c; +void +kd_debug_put( + int loc, + char c) { csrpos_t pos = ONE_PAGE - (loc+1) * ONE_SPACE; @@ -422,11 +385,11 @@ char c; #endif /* DEBUG */ -extern int mouse_in_use; -int old_kb_mode; +extern boolean_t mouse_in_use; +int old_kb_mode; -cnpollc(on) -boolean_t on; +void +cnpollc(boolean_t on) { if (mouse_in_use) { if (on) { @@ -466,15 +429,14 @@ boolean_t on; * output: device is opened and setup * */ -kdopen(dev, flag, ior) - dev_t dev; - int flag; - io_req_t ior; +int +kdopen( + dev_t dev, + int flag, + io_req_t ior) { struct tty *tp; - int kdstart(); spl_t o_pri; - int kdstop(); tp = &kd_tty; o_pri = spltty(); @@ -487,17 +449,12 @@ kdopen(dev, flag, ior) /* * Special support for boot-time rc scripts, which don't * stty the console. - */ + */ tp->t_oproc = kdstart; tp->t_stop = kdstop; tp->t_ospeed = tp->t_ispeed = B9600; tp->t_flags = ODDP|EVENP|ECHO|CRMOD|XTABS; kdinit(); - - /* XXX kd_io_map_open allocates memory */ - simple_unlock(&tp->t_lock); - kd_io_map_open(ior->io_device); - simple_lock(&tp->t_lock); } tp->t_state |= TS_CARR_ON; simple_unlock(&tp->t_lock); @@ -513,13 +470,14 @@ kdopen(dev, flag, ior) * closing the line discipline. * * input: device number 'dev', and flag - * + * * output: device is closed * */ /*ARGSUSED*/ +void kdclose(dev, flag) -int dev; +dev_t dev; int flag; { struct tty *tp; @@ -533,10 +491,7 @@ int flag; splx(s); } - kd_io_map_close(); - return; - } @@ -552,12 +507,13 @@ int flag; * */ /*ARGSUSED*/ +int kdread(dev, uio) -int dev; -struct uio *uio; +dev_t dev; +io_req_t uio; { struct tty *tp; - + tp = &kd_tty; tp->t_state |= TS_CARR_ON; return((*linesw[kd_tty.t_line].l_read)(tp, uio)); @@ -576,14 +532,15 @@ struct uio *uio; * */ /*ARGSUSED*/ +int kdwrite(dev, uio) -int dev; -struct uio *uio; +dev_t dev; +io_req_t uio; { return((*linesw[kd_tty.t_line].l_write)(&kd_tty, uio)); } -/* +/* * Mmap. */ @@ -591,29 +548,30 @@ struct uio *uio; int kdmmap(dev, off, prot) dev_t dev; - off_t off; - int prot; + vm_offset_t off; + vm_prot_t prot; { - if ((u_int) off >= (128*1024)) + if (off >= (128*1024)) return(-1); /* Get page frame number for the page to be mapped. */ return(i386_btop(kd_bitmap_start+off)); } -kdportdeath(dev, port) - dev_t dev; - mach_port_t port; +int +kdportdeath( + dev_t dev, + mach_port_t port) { - return (tty_portdeath(&kd_tty, port)); + return (tty_portdeath(&kd_tty, (ipc_port_t)port)); } /*ARGSUSED*/ -io_return_t kdgetstat(dev, flavor, data, count) - dev_t dev; - int flavor; - int * data; /* pointer to OUT array */ - unsigned int *count; /* OUT */ +io_return_t kdgetstat( + dev_t dev, + int flavor, + int * data, /* pointer to OUT array */ + natural_t *count) /* OUT */ { io_return_t result; @@ -639,11 +597,11 @@ io_return_t kdgetstat(dev, flavor, data, } /*ARGSUSED*/ -io_return_t kdsetstat(dev, flavor, data, count) - dev_t dev; - int flavor; - int * data; - unsigned int count; +io_return_t kdsetstat( + dev_t dev, + int flavor, + int * data, + natural_t count) { io_return_t result; @@ -669,37 +627,36 @@ io_return_t kdsetstat(dev, flavor, data, -/* +/* * kdsetbell: - * - * Turn the bell on or off. Returns error code, if given bogus + * + * Turn the bell on or off. Returns error code, if given bogus * on/off value. */ -kdsetbell(val, flags) -int val; /* on or off */ -int flags; /* flags set for console */ +int +kdsetbell( + int val, /* on or off */ + int flags) /* flags set for console */ { int err = 0; - if (val == KD_BELLON) kd_bellon(); else if (val == KD_BELLOFF) - kd_belloff(); + kd_belloff(NULL); else err = D_INVALID_OPERATION; return(err); } - -/* +/* * kdgetkbent: - * + * * Get entry from key mapping table. Returns error code, if any. */ -kdgetkbent(kbent) -struct kbentry * kbent; +int +kdgetkbent(struct kbentry *kbent) { u_char *cp; spl_t o_pri = SPLKD(); /* probably superfluous */ @@ -713,15 +670,15 @@ struct kbentry * kbent; } -/* +/* * kdsetkbent: - * + * * Set entry in key mapping table. Return error code, if any. */ int -kdsetkbent(kbent, flags) -struct kbentry * kbent; -int flags; /* flags set for console */ +kdsetkbent( + struct kbentry *kbent, + int flags) /* flags set for console */ { u_char *cp; spl_t o_pri; @@ -740,8 +697,8 @@ int flags; /* flags set for console * * * This function is the interrupt code for the driver. Since this is * a special tty (console), interrupts are only for input, so we read in - * the character. If in ascii mode, we then do the mapping translation - * from the keyboard switch table and place the characters on the tty's + * the character. If in ascii mode, we then do the mapping translation + * from the keyboard switch table and place the characters on the tty's * input switch table. If in event mode, we create and queue a kd_event. * * input: interrupt vector 'vec' @@ -750,46 +707,48 @@ int flags; /* flags set for console * * */ /*ARGSUSED*/ -kdintr(vec, regs) -int vec; -int regs; +void +kdintr(int vec) { struct tty *tp; unsigned char c; unsigned char scancode; - int o_pri; - int char_idx; + unsigned int char_idx; boolean_t up = FALSE; /* key-up event */ - extern int mouse_in_use; + if (kd_pollc) return; /* kdb polling kbd */ + if (!kd_initialized) + return; + tp = &kd_tty; #ifdef old - while ((inb(K_STATUS) & K_OBUF_FUL) == 0); /* this should never loop */ -#else old + while ((inb(K_STATUS) & K_OBUF_FUL) == 0) + ; /* this should never loop */ +#else /* old */ { /* - * Allow for keyboards that raise interrupt before + * Allow for keyboards that raise interrupt before * the character gets to the buffer. But don't wait * forever if grabbing the character by polling leaves * the interrupt on but buffer empty. */ /* - * Micronics VLB motherboard with 486DX2 can report keyboard + * Micronics VLB motherboard with 486DX2 can report keyboard * interrupt before K_STATUS register indicates that the * output buffer is full. Moreover, the bus won't settle w * while we poll K_STATUS at speed. Temporary fix is to break - * out after safety runs out and pick up keyboard event. This - * should be fixed eventually by putting a 1us timout between - * inb's to K_STATUS and fix the pic initialization order to + * out after safety runs out and pick up keyboard event. This + * should be fixed eventually by putting a 1us timout between + * inb's to K_STATUS and fix the pic initialization order to * avoid bootup keyboard wedging (ie make kd a real device) */ int safety = 1000; while ((inb(K_STATUS) & K_OBUF_FUL) == 0) if (!safety--) break; /* XXX */ } -#endif old +#endif /* old */ /* * We may have seen a mouse event. */ @@ -804,9 +763,8 @@ int regs; } scancode = inb(K_RDWR); - if (scancode == K_EXTEND) { - if (kb_mode != KB_EVENT) - kd_extended = TRUE; + if (scancode == K_EXTEND && kb_mode != KB_EVENT) { + kd_extended = TRUE; goto done; } else if (scancode == K_RESEND) { kd_resend(); @@ -816,7 +774,7 @@ int regs; goto done; } else if (kd_kbd_mouse && kd_kbd_magic(scancode)) { goto done; - } else if (kdcheckmagic(scancode, ®s)) { + } else if (kdcheckmagic(scancode)) { goto done; } else if (kb_mode == KB_EVENT) { kd_enqsc(scancode); @@ -836,7 +794,7 @@ int regs; set_kd_state(do_modifier(kd_state, c, up)); } else if (!up) { /* regular key-down */ - int max; /* max index for char sequence */ + unsigned int max; /* max index for char sequence */ max = char_idx + NUMOUTPUT; char_idx++; @@ -867,13 +825,13 @@ int regs; } } - /* + /* * here's where we actually put the char (or * char sequence, for function keys) onto the * input queue. */ - for ( ; (c != K_DONE) && (char_idx <= max); - c = key_map[scancode][char_idx++]) { + for ( ; (c != K_DONE) && (char_idx <= max); + c = key_map[scancode][char_idx++]) { (*linesw[tp->t_line].l_rint)(c, tp); } kd_extended = FALSE; @@ -884,13 +842,14 @@ int regs; return; } -/* +/* * kd_handle_ack: - * - * For pending commands, complete the command. For data bytes, + * + * For pending commands, complete the command. For data bytes, * drop the ack on the floor. */ -kd_handle_ack() +void +kd_handle_ack(void) { switch (kd_ack) { case SET_LEDS: @@ -909,14 +868,15 @@ kd_handle_ack() } } -/* +/* * kd_resend: * * Resend a missed keyboard command or data byte. */ -kd_resend() +void +kd_resend(void) { - if (kd_ack == NOT_WAITING) + if (kd_ack == NOT_WAITING) printf("unexpected RESEND from keyboard\n"); else kd_senddata(last_sent); @@ -929,15 +889,16 @@ kd_resend() * Change keyboard state according to which modifier key and * whether it went down or up. * - * input: the current state, the key, and the key's direction. + * input: the current state, the key, and the key's direction. * The key can be any key, not just a modifier key. - * + * * output: the new state */ -do_modifier(state, c, up) -int state; -Scancode c; -boolean_t up; +int +do_modifier( + int state, + Scancode c, + boolean_t up) { switch (c) { case (K_ALTSC): @@ -949,7 +910,7 @@ boolean_t up; break; #ifndef ORC case (K_CLCKSC): -#endif ORC +#endif /* ORC */ case (K_CTLSC): if (up) state &= ~KS_CTLED; @@ -962,7 +923,7 @@ boolean_t up; if (!up) state ^= KS_CLKED; break; -#endif ORC +#endif /* ORC */ case (K_NLCKSC): if (!up) state ^= KS_NLKED; @@ -981,31 +942,28 @@ boolean_t up; } -/* +/* * kdcheckmagic: - * - * Check for magic keystrokes for invoking the debugger or + * + * Check for magic keystrokes for invoking the debugger or * rebooting or ... * * input: an unprocessed scancode - * - * output: TRUE if a magic key combination was recognized and + * + * output: TRUE if a magic key combination was recognized and * processed. FALSE otherwise. * - * side effects: + * side effects: * various actions possible, depending on which keys are - * pressed. If the debugger is called, steps are taken - * to ensure that the system doesn't think the magic keys + * pressed. If the debugger is called, steps are taken + * to ensure that the system doesn't think the magic keys * are still held down. */ boolean_t -kdcheckmagic(scancode, regs) -Scancode scancode; -int *regs; +kdcheckmagic(Scancode scancode) { static int magic_state = KS_NORMAL; /* like kd_state */ boolean_t up = FALSE; - extern int rebootflag; if (scancode == 0x46) /* scroll lock */ /* if (scancode == 0x52) ** insert key */ @@ -1038,7 +996,7 @@ int *regs; } return(TRUE); break; -#endif MACH_KDB +#endif /* MACH_KDB */ case K_DELSC: /* ctl-alt-del */ /* if rebootflag is on, reboot the system */ if (rebootflag) @@ -1053,11 +1011,12 @@ int *regs; /* * kdstate2idx: * - * Return the value for the 2nd index into key_map that + * Return the value for the 2nd index into key_map that * corresponds to the given state. */ +unsigned int kdstate2idx(state, extended) -int state; /* bit vector, not a state index */ +unsigned int state; /* bit vector, not a state index */ boolean_t extended; { int state_idx = NORM_STATE; @@ -1065,12 +1024,15 @@ boolean_t extended; if ((!extended) && state != KS_NORMAL) { if ((state&(KS_SHIFTED|KS_ALTED)) == (KS_SHIFTED|KS_ALTED)) state_idx = SHIFT_ALT; + /* CTRL should have higher priority than SHIFT. That + way, CTRL-SHIFT-2 and CTRL-2 produce the same keycode. + --Derek Upham 1997/06/25 */ + else if (state&KS_CTLED) + state_idx = CTRL_STATE; else if (state&KS_SHIFTED) state_idx = SHIFT_STATE; else if (state&KS_ALTED) state_idx = ALT_STATE; - else if (state&KS_CTLED) - state_idx = CTRL_STATE; } return (CHARIDX(state_idx)); @@ -1092,48 +1054,26 @@ boolean_t extended; * Entered and left at spltty. Drops priority to spl0 to display character. * ASSUMES that it is never called from interrupt-driven code. */ -kdstart(tp) -struct tty *tp; +void +kdstart(struct tty *tp) { spl_t o_pri; int ch; - unsigned char c; - + if (tp->t_state & TS_TTSTOP) return; for ( ; ; ) { - tp->t_state &= ~TS_BUSY; + tp->t_state &= ~TS_BUSY; if (tp->t_state & TS_TTSTOP) break; if ((tp->t_outq.c_cc <= 0) || (ch = getc(&tp->t_outq)) == -1) break; - c = ch; /* * Drop priority for long screen updates. ttstart() calls us at * spltty. */ o_pri = splsoftclock(); /* block timeout */ - if (c == (K_ESC)) { - if (esc_spt == esc_seq) { - *(esc_spt++)=(K_ESC); - *(esc_spt) = '\0'; - } else { - kd_putc((K_ESC)); - esc_spt = esc_seq; - } - } else { - if (esc_spt - esc_seq) { - if (esc_spt - esc_seq > K_MAXESC - 1) - esc_spt = esc_seq; - else { - *(esc_spt++) = c; - *(esc_spt) = '\0'; - kd_parseesc(); - } - } else { - kd_putc(c); - } - } + kd_putc_esc(ch); splx(o_pri); } if (tp->t_outq.c_cc <= TTLOWAT(tp)) { @@ -1142,9 +1082,10 @@ struct tty *tp; } /*ARGSUSED*/ -kdstop(tp, flags) - register struct tty *tp; - int flags; +void +kdstop( + struct tty *tp, + int flags) { /* * do nothing - all characters are output by one call to @@ -1156,7 +1097,7 @@ kdstop(tp, flags) * kdinit: * * This code initializes the structures and sets up the port registers - * for the console driver. + * for the console driver. * * Each bitmap-based graphics card is likely to require a unique * way to determine the card's presence. The driver runs through @@ -1168,9 +1109,9 @@ kdstop(tp, flags) * output : Driver is initialized * */ -kdinit() +void +kdinit(void) { - void kd_xga_init(); unsigned char k_comm; /* keyboard command byte */ if (kd_initialized) @@ -1179,15 +1120,13 @@ kdinit() esc_spt = esc_seq; kd_attr = KA_NORMAL; + kd_attrflags = 0; + kd_color = KA_NORMAL; /* * board specific initialization: set up globals and kd_dxxx * pointers, and synch displayed cursor with logical cursor. */ - if (!evc1init()) - if (blit_present()) - blit_init(); - else - kd_xga_init(); + kd_xga_init(); /* get rid of any garbage in output buffer */ if (inb(K_STATUS) & K_OBUF_FUL) @@ -1201,25 +1140,28 @@ kdinit() kd_senddata(k_comm); kd_initialized = TRUE; -#ifdef ENABLE_IMMEDIATE_CONSOLE +#if ENABLE_IMMEDIATE_CONSOLE /* Now that we're set up, we no longer need or want the immediate console. */ { - extern int immediate_console_enable; - immediate_console_enable = 0; + extern boolean_t immediate_console_enable; + immediate_console_enable = FALSE; } /* The immediate console printed stuff at the bottom of the screen rather than at the cursor position, so that's where we should start. */ kd_setpos(ONE_PAGE - ONE_LINE); printf("\n"); -#endif +#endif /* ENABLE_IMMEDIATE_CONSOLE */ cnsetleds(kd_state = KS_NORMAL); /* clear the LEDs AFTER we enable the keyboard controller. This keeps NUM-LOCK from being set on the NEC Versa. */ + + /* Allocate the input buffer. */ + ttychars(&kd_tty); } /* @@ -1232,14 +1174,16 @@ kdinit() * output : bell is turned off * */ -static unsigned int kd_bellstate = 0; -kd_belloff() +static boolean_t kd_bellstate = FALSE; + +void +kd_belloff(void * param) { unsigned char status; status = (inb(K_PORTB) & ~(K_SPKRDATA | K_ENABLETMR2)); outb(K_PORTB, status); - kd_bellstate = 0; + kd_bellstate = FALSE; return; } @@ -1253,7 +1197,8 @@ kd_belloff() * output : bell is turned on * */ -kd_bellon() +void +kd_bellon(void) { unsigned char status; @@ -1270,6 +1215,43 @@ kd_bellon() /* * + * Function kd_putc_esc(): + * + * This function puts a character on the screen, handling escape + * sequences. + * + * input : character to be displayed (or part of an escape code) + * output : character is displayed, or some action is taken + * + */ +void +kd_putc_esc(u_char c) +{ + if (c == (K_ESC)) { + if (esc_spt == esc_seq) { + *(esc_spt++)=(K_ESC); + *(esc_spt) = '\0'; + } else { + kd_putc((K_ESC)); + esc_spt = esc_seq; + } + } else { + if (esc_spt - esc_seq) { + if (esc_spt - esc_seq > K_MAXESC - 1) + esc_spt = esc_seq; + else { + *(esc_spt++) = c; + *(esc_spt) = '\0'; + kd_parseesc(); + } + } else { + kd_putc(c); + } + } +} + +/* + * * Function kd_putc(): * * This function simply puts a character on the screen. It does some @@ -1282,17 +1264,17 @@ kd_bellon() */ int sit_for_0 = 1; -kd_putc(ch) -u_char ch; +void +kd_putc(u_char ch) { if ((!ch) && sit_for_0) return; - switch (ch) { + switch (ch) { case ((K_LF)): kd_down(); break; - case ((K_CR)): + case ((K_CR)): kd_cr(); break; case ((K_BS)): @@ -1310,7 +1292,7 @@ u_char ch; { kd_bellon(); timeout(kd_belloff, 0, hz/8 ); - kd_bellstate = 1; + kd_bellstate = TRUE; } break; default: @@ -1335,8 +1317,8 @@ u_char ch; * screen. * */ -kd_setpos(newpos) -csrpos_t newpos; +void +kd_setpos(csrpos_t newpos) { if (newpos > ONE_PAGE) { kd_scrollup(); @@ -1361,7 +1343,8 @@ csrpos_t newpos; * output : lines on screen appear to be shifted up one line * */ -kd_scrollup() +void +kd_scrollup(void) { csrpos_t to; csrpos_t from; @@ -1390,7 +1373,8 @@ kd_scrollup() * output : Lines on screen appear to be moved down one line * */ -kd_scrolldn() +void +kd_scrolldn(void) { csrpos_t to; csrpos_t from; @@ -1407,7 +1391,7 @@ kd_scrolldn() count = ONE_LINE/ONE_SPACE; (*kd_dclear)(to, count, kd_attr); return; - + } @@ -1415,7 +1399,7 @@ kd_scrolldn() * kd_parseesc: * * This routine begins the parsing of an escape sequence. It uses the - * escape sequence array and the escape spot pointer to handle + * escape sequence array and the escape spot pointer to handle * asynchronous parsing of escape sequences. * * input : String of characters prepended by an escape @@ -1423,7 +1407,8 @@ kd_scrolldn() * defined by the ansi terminal specification * */ -kd_parseesc() +void +kd_parseesc(void) { u_char *escp; @@ -1450,6 +1435,37 @@ kd_parseesc() } +/* kd_update_kd_attr: + * + * Updates kd_attr according to kd_attrflags and kd_color. + * This code has its origin from console.c and selection.h in + * linux 2.2 drivers/char/. + * Modified for GNU Mach by Marcus Brinkmann. + */ + +#define reverse_video_char(a) (((a) & 0x88) | ((((a) >> 4) | ((a) << 4)) & 0x77)) +void +kd_update_kd_attr(void) +{ + kd_attr = kd_color; + if (kd_attrflags & KAX_UNDERLINE) + kd_attr = (kd_attr & 0xf0) | KAX_COL_UNDERLINE; + else if (kd_attrflags & KAX_DIM) + kd_attr = (kd_attr & 0xf0) | KAX_COL_DIM; + if (kd_attrflags & KAX_REVERSE) + kd_attr = reverse_video_char(kd_attr); + if (kd_attrflags & KAX_BLINK) + kd_attr ^= 0x80; + if (kd_attrflags & KAX_BOLD) + kd_attr ^= 0x08; +} + +/* color_table added by Julio Merino to take proper color order. + * I get this code from Linux 2.2 source code in file: + * linux/drivers/char/console.c + */ +unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7, + 8,12,10,14, 9,13,11,15 }; /* * kd_parserest: * @@ -1463,143 +1479,185 @@ kd_parseesc() * sequence acceptable to the ansi terminal specification * */ -kd_parserest(cp) -u_char *cp; +void +kd_parserest(u_char *cp) { - int number; + int number[16], npar = 0, i; csrpos_t newpos; - cp += kd_atoi(cp, &number); + for(i=0;i<=15;i++) + number[i] = MACH_ATOI_DEFAULT; + + do { + cp += mach_atoi(cp, &number[npar]); + } while (*cp == ';' && ++npar <= 15 && cp++); + switch(*cp) { case 'm': - switch(number) { - case DEFAULT: - case 0: - kd_attr = KA_NORMAL; - break; - case 7: - kd_attr = KA_REVERSE; - break; - default: - kd_attr = KA_NORMAL; - break; - } + for (i=0;i<=npar;i++) + switch(number[i]) { + case MACH_ATOI_DEFAULT: + case 0: + kd_attrflags = 0; + kd_color = KA_NORMAL; + break; + case 1: + kd_attrflags |= KAX_BOLD; + kd_attrflags &= ~KAX_DIM; + break; + case 2: + kd_attrflags |= KAX_DIM; + kd_attrflags &= ~KAX_BOLD; + break; + case 4: + kd_attrflags |= KAX_UNDERLINE; + break; + case 5: + kd_attrflags |= KAX_BLINK; + break; + case 7: + kd_attrflags |= KAX_REVERSE; + break; + case 8: + kd_attrflags |= KAX_INVISIBLE; + break; + case 21: + case 22: + kd_attrflags &= ~(KAX_BOLD | KAX_DIM); + break; + case 24: + kd_attrflags &= ~KAX_UNDERLINE; + break; + case 25: + kd_attrflags &= ~KAX_BLINK; + break; + case 27: + kd_attrflags &= ~KAX_REVERSE; + break; + case 38: + kd_attrflags |= KAX_UNDERLINE; + kd_color = (kd_color & 0xf0) | (KA_NORMAL & 0x0f); + break; + case 39: + kd_attrflags &= ~KAX_UNDERLINE; + kd_color = (kd_color & 0xf0) | (KA_NORMAL & 0x0f); + break; + default: + if (number[i] >= 30 && number[i] <= 37) { + /* foreground color */ + kd_color = (kd_color & 0xf0) | color_table[(number[i] - 30)]; + } else if (number[i] >= 40 && number[i] <= 47) { + /* background color */ + kd_color = (kd_color & 0x0f) | (color_table[(number[i] - 40)] << 4); + } + break; + } + kd_update_kd_attr(); esc_spt = esc_seq; break; case '@': - if (number == DEFAULT) + if (number[0] == MACH_ATOI_DEFAULT) kd_insch(1); else - kd_insch(number); - esc_spt = esc_seq; - break; - case 'H': - kd_home(); + kd_insch(number[0]); esc_spt = esc_seq; break; case 'A': - if (number == DEFAULT) + if (number[0] == MACH_ATOI_DEFAULT) kd_up(); else - while (number--) + while (number[0]--) kd_up(); esc_spt = esc_seq; break; case 'B': - if (number == DEFAULT) + if (number[0] == MACH_ATOI_DEFAULT) kd_down(); else - while (number--) + while (number[0]--) kd_down(); esc_spt = esc_seq; break; case 'C': - if (number == DEFAULT) + if (number[0] == MACH_ATOI_DEFAULT) kd_right(); else - while (number--) + while (number[0]--) kd_right(); esc_spt = esc_seq; break; case 'D': - if (number == DEFAULT) + if (number[0] == MACH_ATOI_DEFAULT) kd_left(); else - while (number--) + while (number[0]--) kd_left(); esc_spt = esc_seq; break; case 'E': kd_cr(); - if (number == DEFAULT) + if (number[0] == MACH_ATOI_DEFAULT) kd_down(); else - while (number--) + while (number[0]--) kd_down(); esc_spt = esc_seq; break; case 'F': kd_cr(); - if (number == DEFAULT) + if (number[0] == MACH_ATOI_DEFAULT) kd_up(); else - while (number--) + while (number[0]--) kd_up(); esc_spt = esc_seq; break; case 'G': - if (number == DEFAULT) - number = 0; + if (number[0] == MACH_ATOI_DEFAULT) + number[0] = 0; else - if (number > 0) - --number; /* because number is from 1 */ - kd_setpos(BEG_OF_LINE(kd_curpos) + number * ONE_SPACE); + if (number[0] > 0) + --number[0]; /* because number[0] is from 1 */ + kd_setpos(BEG_OF_LINE(kd_curpos) + number[0] * ONE_SPACE); esc_spt = esc_seq; break; - case ';': - ++cp; - if (*cp == '\0') - break; /* not ready yet */ - if (number == DEFAULT) - number = 0; - else - if (number > 0) - --number; /* numbered from 1 */ - newpos = (number * ONE_LINE); /* setup row */ - cp += kd_atoi(cp, &number); - if (*cp == '\0') - break; /* not ready yet */ - if (number == DEFAULT) - number = 0; - else if (number > 0) - number--; - newpos += (number * ONE_SPACE); /* setup column */ + case 'f': + case 'H': + if (number[0] == MACH_ATOI_DEFAULT && number[1] == MACH_ATOI_DEFAULT) + { + kd_home(); + esc_spt = esc_seq; + break; + } + if (number[0] == MACH_ATOI_DEFAULT) + number[0] = 0; + else if (number[0] > 0) + --number[0]; /* numbered from 1 */ + newpos = (number[0] * ONE_LINE); /* setup row */ + if (number[1] == MACH_ATOI_DEFAULT) + number[1] = 0; + else if (number[1] > 0) + number[1]--; + newpos += (number[1] * ONE_SPACE); /* setup column */ if (newpos < 0) newpos = 0; /* upper left */ if (newpos > ONE_PAGE) - newpos = (ONE_PAGE - ONE_SPACE); - /* lower right */ - if (*cp == '\0') - break; /* not ready yet */ - if (*cp == 'H') { - kd_setpos(newpos); - esc_spt = esc_seq; /* done, reset */ - } - else - esc_spt = esc_seq; + newpos = (ONE_PAGE - ONE_SPACE); /* lower right */ + kd_setpos(newpos); + esc_spt = esc_seq; break; /* done or not ready */ case 'J': - switch(number) { - case DEFAULT: + switch(number[0]) { + case MACH_ATOI_DEFAULT: case 0: kd_cltobcur(); /* clears from current pos to bottom. - */ + */ break; case 1: kd_cltopcur(); /* clears from top to current pos. - */ + */ break; case 2: kd_cls(); @@ -1610,12 +1668,12 @@ u_char *cp; esc_spt = esc_seq; /* reset it */ break; case 'K': - switch(number) { - case DEFAULT: + switch(number[0]) { + case MACH_ATOI_DEFAULT: case 0: kd_cltoecur(); /* clears from current pos to eoln. - */ + */ break; case 1: kd_clfrbcur(); /* clears from begin @@ -1632,49 +1690,49 @@ u_char *cp; esc_spt = esc_seq; break; case 'L': - if (number == DEFAULT) + if (number[0] == MACH_ATOI_DEFAULT) kd_insln(1); else - kd_insln(number); + kd_insln(number[0]); esc_spt = esc_seq; break; case 'M': - if (number == DEFAULT) + if (number[0] == MACH_ATOI_DEFAULT) kd_delln(1); else - kd_delln(number); + kd_delln(number[0]); esc_spt = esc_seq; break; case 'P': - if (number == DEFAULT) + if (number[0] == MACH_ATOI_DEFAULT) kd_delch(1); else - kd_delch(number); + kd_delch(number[0]); esc_spt = esc_seq; break; case 'S': - if (number == DEFAULT) + if (number[0] == MACH_ATOI_DEFAULT) kd_scrollup(); else - while (number--) + while (number[0]--) kd_scrollup(); esc_spt = esc_seq; break; case 'T': - if (number == DEFAULT) + if (number[0] == MACH_ATOI_DEFAULT) kd_scrolldn(); else - while (number--) + while (number[0]--) kd_scrolldn(); esc_spt = esc_seq; break; case 'X': - if (number == DEFAULT) + if (number[0] == MACH_ATOI_DEFAULT) kd_erase(1); else - kd_erase(number); + kd_erase(number[0]); esc_spt = esc_seq; - break; + break; case '\0': break; /* not enough yet */ default: @@ -1685,38 +1743,8 @@ u_char *cp; return; } -/* - * kd_atoi: - * - * This function converts an ascii string into an integer, and - * returns DEFAULT if no integer was found. Note that this is why - * we don't use the regular atio(), because ZERO is ZERO and not - * the DEFAULT in all cases. - * - * input : string - * output : a number or possibly DEFAULT, and the count of characters - * consumed by the conversion - * - */ -int -kd_atoi(cp, nump) -u_char *cp; -int *nump; -{ - int number; - u_char *original; - - original = cp; - for (number = 0; ('0' <= *cp) && (*cp <= '9'); cp++) - number = (number * 10) + (*cp - '0'); - if (original == cp) - *nump = DEFAULT; - else - *nump = number; - return(cp - original); -} - -kd_tab() +void +kd_tab(void) { int i; @@ -1736,7 +1764,8 @@ kd_tab() * output : Screen is cleared * */ -kd_cls() +void +kd_cls(void) { (*kd_dclear)(0, ONE_PAGE/ONE_SPACE, kd_attr); return; @@ -1753,7 +1782,8 @@ kd_cls() * output : Cursor position is moved * */ -kd_home() +void +kd_home(void) { kd_setpos(0); return; @@ -1769,7 +1799,8 @@ kd_home() * output : Cursor moves up one line, or screen is scrolled * */ -kd_up() +void +kd_up(void) { if (kd_curpos < ONE_LINE) kd_scrolldn(); @@ -1788,7 +1819,8 @@ kd_up() * output : Cursor moves down one line or the screen is scrolled * */ -kd_down() +void +kd_down(void) { if (kd_curpos >= (ONE_PAGE - ONE_LINE)) kd_scrollup(); @@ -1807,7 +1839,8 @@ kd_down() * output : Cursor moves one position to the right * */ -kd_right() +void +kd_right(void) { if (kd_curpos < (ONE_PAGE - ONE_SPACE)) kd_setpos(kd_curpos + ONE_SPACE); @@ -1828,7 +1861,8 @@ kd_right() * output : Cursor moves one position to the left * */ -kd_left() +void +kd_left(void) { if (0 < kd_curpos) kd_setpos(kd_curpos - ONE_SPACE); @@ -1846,7 +1880,8 @@ kd_left() * output : Cursor moves to the beginning of the current line * */ -kd_cr() +void +kd_cr(void) { kd_setpos(BEG_OF_LINE(kd_curpos)); return; @@ -1860,10 +1895,11 @@ kd_cr() * of the screen. * * input : None - * output : Screen is cleared from current cursor postion to bottom + * output : Screen is cleared from current cursor position to bottom * */ -kd_cltobcur() +void +kd_cltobcur(void) { csrpos_t start; int count; @@ -1882,10 +1918,11 @@ kd_cltobcur() * of the screen. * * input : None - * output : Screen is cleared from current cursor postion to top + * output : Screen is cleared from current cursor position to top * */ -kd_cltopcur() +void +kd_cltopcur(void) { int count; @@ -1898,13 +1935,14 @@ kd_cltopcur() /* * kd_cltoecur: * - * This function clears from the current cursor position to eoln. + * This function clears from the current cursor position to eoln. * * input : None * output : Line is cleared from current cursor position to eoln * */ -kd_cltoecur() +void +kd_cltoecur(void) { csrpos_t i; csrpos_t hold; @@ -1926,7 +1964,8 @@ kd_cltoecur() * output : Line is cleared from beginning to current position * */ -kd_clfrbcur() +void +kd_clfrbcur(void) { csrpos_t i; @@ -1946,8 +1985,8 @@ kd_clfrbcur() * output : lines appear to be deleted * */ -kd_delln(number) -int number; +void +kd_delln(int number) { csrpos_t to; csrpos_t from; @@ -1984,8 +2023,8 @@ int number; * output : New lines appear to be inserted * */ -kd_insln(number) -int number; +void +kd_insln(int number) { csrpos_t to; csrpos_t from; @@ -2016,19 +2055,19 @@ int number; /* * kd_delch: * - * This function deletes a number of characters from the current + * This function deletes a number of characters from the current * position in the line. * * input : number of characters to delete * output : characters appear to be deleted * */ -kd_delch(number) -int number; +void +kd_delch(int number) { - int count; /* num words moved/filled */ - int delbytes; /* bytes to delete */ - register csrpos_t to; + int count; /* num words moved/filled */ + int delbytes; /* bytes to delete */ + csrpos_t to; csrpos_t from; csrpos_t nextline; /* start of next line */ @@ -2064,13 +2103,13 @@ int number; * output : characters appear to be blanked or erased * */ -kd_erase(number) -int number; +void +kd_erase(int number) { csrpos_t i; csrpos_t stop; - stop = kd_curpos + (ONE_SPACE * number); + stop = kd_curpos + (ONE_SPACE * number); if (stop > BEG_OF_LINE(kd_curpos) + ONE_LINE) stop = BEG_OF_LINE(kd_curpos) + ONE_LINE; for (i = kd_curpos; i < stop; i += ONE_SPACE) { @@ -2089,13 +2128,14 @@ int number; * output : Current line is erased * */ -kd_eraseln() +void +kd_eraseln(void) { csrpos_t i; csrpos_t stop; stop = BEG_OF_LINE(kd_curpos) + ONE_LINE; - for (i = BEG_OF_LINE(kd_curpos); i < stop; i += ONE_SPACE) { + for (i = BEG_OF_LINE(kd_curpos); i < stop; i += ONE_SPACE) { (*kd_dput)(i, K_SPACE, kd_attr); } return; @@ -2112,8 +2152,8 @@ kd_eraseln() * output : Blanks are inserted at cursor position * */ -kd_insch(number) -int number; +void +kd_insch(int number) { csrpos_t to; csrpos_t from; @@ -2153,16 +2193,16 @@ int number; * returns TRUE if character is lowercase * */ -kd_isupper(c) -u_char c; +boolean_t +kd_isupper(u_char c) { if (('A' <= c) && (c <= 'Z')) return(TRUE); return(FALSE); } -kd_islower(c) -u_char c; +boolean_t +kd_islower(u_char c) { if (('a' <= c) && (c <= 'z')) return(TRUE); @@ -2178,10 +2218,11 @@ u_char c; * keyboard command. * */ -kd_senddata(ch) -unsigned char ch; +void +kd_senddata(unsigned char ch) { - while (inb(K_STATUS) & K_IBUF_FUL); + while (inb(K_STATUS) & K_IBUF_FUL) + ; outb(K_RDWR, ch); last_sent = ch; return; @@ -2195,81 +2236,89 @@ unsigned char ch; * clear before sending the data. * */ -kd_sendcmd(ch) -unsigned char ch; +void +kd_sendcmd(unsigned char ch) { - while (inb(K_STATUS) & K_IBUF_FUL); + while (inb(K_STATUS) & K_IBUF_FUL) + ; outb(K_CMD, ch); return; } -/* +/* * kd_getdata: - * - * This function returns a data byte from the keyboard RDWR port, - * after waiting until the port is flagged as having something to - * read. + * + * This function returns a data byte from the keyboard RDWR port, + * after waiting until the port is flagged as having something to + * read. */ unsigned char -kd_getdata() +kd_getdata(void) { - while ((inb(K_STATUS) & K_OBUF_FUL) == 0); + while ((inb(K_STATUS) & K_OBUF_FUL) == 0) + ; return(inb(K_RDWR)); } -kd_cmdreg_read() +unsigned char +kd_cmdreg_read(void) { int ch=KC_CMD_READ; - while (inb(K_STATUS) & K_IBUF_FUL); + while (inb(K_STATUS) & K_IBUF_FUL) + ; outb(K_CMD, ch); - while ((inb(K_STATUS) & K_OBUF_FUL) == 0); + while ((inb(K_STATUS) & K_OBUF_FUL) == 0) + ; return(inb(K_RDWR)); } -kd_cmdreg_write(val) +void +kd_cmdreg_write(int val) { int ch=KC_CMD_WRITE; - while (inb(K_STATUS) & K_IBUF_FUL); + while (inb(K_STATUS) & K_IBUF_FUL) + ; outb(K_CMD, ch); - while (inb(K_STATUS) & K_IBUF_FUL); + while (inb(K_STATUS) & K_IBUF_FUL) + ; outb(K_RDWR, val); } -kd_mouse_drain() +void +kd_mouse_drain(void) { int i; - while(inb(K_STATUS) & K_IBUF_FUL); + while(inb(K_STATUS) & K_IBUF_FUL) + ; while((i = inb(K_STATUS)) & K_OBUF_FUL) printf("kbd: S = %x D = %x\n", i, inb(K_RDWR)); } -/* +/* * set_kd_state: - * + * * Set kd_state and update the keyboard status LEDs. */ - -set_kd_state(newstate) -int newstate; +void +set_kd_state(int newstate) { kd_state = newstate; kd_setleds1(state2leds(newstate)); } -/* +/* * state2leds: - * - * Return a byte containing LED settings for the keyboard, given + * + * Return a byte containing LED settings for the keyboard, given * a state vector. */ u_char -state2leds(state) -int state; +state2leds(int state) { u_char result = 0; @@ -2280,16 +2329,18 @@ int state; return(result); } -/* +/* * kd_setleds[12]: - * - * Set the keyboard LEDs according to the given byte. + * + * Set the keyboard LEDs according to the given byte. */ -kd_setleds1(val) -u_char val; +void +kd_setleds1(u_char val) { if (kd_ack != NOT_WAITING) { +#ifdef MACH_KBD printf("kd_setleds1: unexpected state (%d)\n", kd_ack); +#endif return; } @@ -2298,21 +2349,22 @@ u_char val; kd_senddata(K_CMD_LEDS); } -kd_setleds2() +void +kd_setleds2(void) { kd_senddata(kd_nextled); } -/* +/* * cnsetleds: - * + * * like kd_setleds[12], but not interrupt-based. - * Currently disabled because cngetc ignores caps lock and num + * Currently disabled because cngetc ignores caps lock and num * lock anyway. */ -cnsetleds(val) -u_char val; +void +cnsetleds(u_char val) { kd_senddata(K_CMD_LEDS); (void)kd_getdata(); /* XXX - assume is ACK */ @@ -2320,7 +2372,8 @@ u_char val; (void)kd_getdata(); /* XXX - assume is ACK */ } -kdreboot() +void +kdreboot(void) { (*kd_dreset)(); @@ -2328,9 +2381,9 @@ kdreboot() kd_sendcmd(0xFE); /* XXX - magic # */ delay(1000000); /* wait to see if anything happens */ #endif - /* + /* * If that didn't work, then we'll just have to try and - * do it the hard way. + * do it the hard way. */ cpu_shutdown(); } @@ -2338,7 +2391,8 @@ kdreboot() static int which_button[] = {0, MOUSE_LEFT, MOUSE_MIDDLE, MOUSE_RIGHT}; static struct mouse_motion moved; -kd_kbd_magic(scancode) +int +kd_kbd_magic(int scancode) { int new_button = 0; @@ -2432,14 +2486,18 @@ int new_button = 0; * Initialization specific to character-based graphics adapters. */ void -kd_xga_init() +kd_xga_init(void) { csrpos_t xga_getpos(); unsigned char screen; + unsigned char start, stop; outb(CMOS_ADDR, CMOS_EB); screen = inb(CMOS_DATA) & CM_SCRMSK; switch(screen) { + default: + printf("kd: unknown screen type, defaulting to EGA\n"); + /* FALLTHROUGH */ case CM_EGA_VGA: /* * Here we'll want to query to bios on the card @@ -2451,7 +2509,7 @@ kd_xga_init() * memory location for these cards. * */ - + vid_start = (u_char *)phystokv(EGA_START); kd_index_reg = EGA_IDX_REG; kd_io_reg = EGA_IO_REG; @@ -2465,6 +2523,8 @@ kd_xga_init() addr[i] = 0x00; } break; +#if 0 + /* XXX: some buggy BIOSes report these... */ case CM_CGA_40: vid_start = (u_char *)phystokv(CGA_START); kd_index_reg = CGA_IDX_REG; @@ -2486,8 +2546,25 @@ kd_xga_init() kd_lines = 25; kd_cols = 80; break; - default: - printf("kd: unknown screen type, defaulting to EGA\n"); +#endif + } + + outb(kd_index_reg, C_START); + start = inb(kd_io_reg); + /* Make sure cursor is enabled */ + start &= ~0x20; + outb(kd_io_reg, start); + outb(kd_index_reg, C_STOP); + stop = inb(kd_io_reg); + + if (!start && !stop) + { + /* Some firmware seem not to be initializing the cursor size + * any more... Try using standard values. */ + outb(kd_index_reg, C_START); + outb(kd_io_reg, 14); + outb(kd_index_reg, C_STOP); + outb(kd_io_reg, 15); } kd_setpos(xga_getpos()); @@ -2505,7 +2582,7 @@ kd_xga_init() * */ csrpos_t -xga_getpos() +xga_getpos(void) { unsigned char low; @@ -2602,44 +2679,30 @@ char chattr; } -/* +/* * kd_noopreset: - * + * * No-op reset routine for kd_dreset. */ static void -kd_noopreset() +kd_noopreset(void) { } - -/* - * Generic routines for bitmap devices (i.e., assume no hardware - * assist). Assumes a simple byte ordering (i.e., a byte at a lower - * address is to the left of the byte at the next higher address). - * For the 82786, this works anyway if the characters are 2 bytes - * wide. (more bubble gum and paper clips.) - * - * See the comments above about SLAMBPW. - */ - -void bmpch2bit(), bmppaintcsr(); -u_char *bit2fbptr(); - - /* * bmpput: Copy a character from the font to the frame buffer. */ void -bmpput(pos, ch, chattr) -csrpos_t pos; -char ch, chattr; +bmpput( + csrpos_t pos, + char ch, + char chattr) { short xbit, ybit; /* u/l corner of char pos */ - register u_char *to, *from; - register short i, j; + u_char *to, *from; + short i, j; u_char mask = (chattr == KA_REVERSE ? 0xff : 0); if ((u_char)ch >= chars_in_font) @@ -2661,13 +2724,14 @@ char ch, chattr; * another. */ void -bmpcp1char(from, to) -csrpos_t from, to; +bmpcp1char( + csrpos_t from, + csrpos_t to) { short from_xbit, from_ybit; short to_xbit, to_ybit; - register u_char *tp, *fp; - register short i, j; + u_char *tp, *fp; + short i, j; bmpch2bit(from, &from_xbit, &from_ybit); bmpch2bit(to, &to_xbit, &to_ybit); @@ -2687,9 +2751,10 @@ csrpos_t from, to; * bmpvmup: Copy a block of character positions upwards. */ void -bmpmvup(from, to, count) -csrpos_t from, to; -int count; +bmpmvup( + csrpos_t from, + csrpos_t to, + int count) { short from_xbit, from_ybit; short to_xbit, to_ybit; @@ -2705,7 +2770,7 @@ int count; count /= kd_cols; /* num lines */ count *= fb_byte_width * (char_height+cursor_height); kd_slmscu(bit2fbptr(from_xbit, from_ybit), - bit2fbptr(to_xbit, to_ybit), + bit2fbptr(to_xbit, to_ybit), count/SLAMBPW); bmppaintcsr(kd_curpos, char_white); } else { @@ -2722,9 +2787,10 @@ int count; * bmpmvdown: copy a block of characters down. */ void -bmpmvdown(from, to, count) -csrpos_t from, to; -int count; +bmpmvdown( + csrpos_t from, + csrpos_t to, + int count) { short from_xbit, from_ybit; short to_xbit, to_ybit; @@ -2760,12 +2826,12 @@ int count; * bmpclear: clear one or more character positions. */ void -bmpclear(to, count, chattr) -csrpos_t to; /* 1st char */ -int count; /* num chars */ -char chattr; /* reverse or normal */ +bmpclear( + csrpos_t to, /* 1st char */ + int count, /* num chars */ + char chattr) /* reverse or normal */ { - register short i; + short i; u_short clearval; u_short clearbyte = (chattr == KA_REVERSE ? char_white : char_black); @@ -2774,7 +2840,7 @@ char chattr; /* reverse or normal */ /* fast case - entire page */ kd_slmwd(vid_start, (fb_byte_width * fb_height)/SLAMBPW, clearval); - } else + } else /* slow case */ for (i = 0; i < count; ++i) { bmpput(to, K_SPACE, chattr); @@ -2786,8 +2852,7 @@ char chattr; /* reverse or normal */ * bmpsetcursor: update the display and set the logical cursor. */ void -bmpsetcursor(pos) -csrpos_t pos; +bmpsetcursor(csrpos_t pos) { /* erase old cursor & paint new one */ bmppaintcsr(kd_curpos, char_black); @@ -2799,13 +2864,13 @@ csrpos_t pos; * bmppaintcsr: paint cursor bits. */ void -bmppaintcsr(pos, val) -csrpos_t pos; -u_char val; +bmppaintcsr( + csrpos_t pos, + u_char val) { short xbit, ybit; - register u_char *cp; - register short line, byte; + u_char *cp; + short line, byte; bmpch2bit(pos, &xbit, &ybit); ybit += char_height; /* position at bottom of line */ @@ -2822,11 +2887,12 @@ u_char val; * (0, 0) is the upper left corner. */ void -bmpch2bit(pos, xb, yb) -csrpos_t pos; -short *xb, *yb; /* x, y bit positions, u/l corner */ +bmpch2bit( + csrpos_t pos, + short *xb, + short *yb) /* x, y bit positions, u/l corner */ { - register short xch, ych; + short xch, ych; xch = (pos / ONE_SPACE) % kd_cols; ych = pos / (ONE_SPACE * kd_cols); @@ -2841,8 +2907,9 @@ short *xb, *yb; /* x, y bit positions, * byte. */ u_char * -bit2fbptr(xb, yb) -short xb, yb; +bit2fbptr( + short xb, + short yb) { return(vid_start + yb * fb_byte_width + xb/8); } @@ -2863,9 +2930,10 @@ kdcnprobe(struct consdev *cp) maj = 0; unit = 0; pri = CN_INTERNAL; - + cp->cn_dev = makedev(maj, unit); cp->cn_pri = pri; + return 0; } int @@ -2891,24 +2959,24 @@ kdcngetc(dev_t dev, int wait) int kdcnputc(dev_t dev, int c) { - int i; - if (!kd_initialized) - return; + return -1; /* Note that tab is handled in kd_putc */ if (c == '\n') kd_putc('\r'); - kd_putc(c); + kd_putc_esc(c); + + return 0; } -/* +/* * kdcnmaygetc: - * - * Get one character using polling, rather than interrupts. Used + * + * Get one character using polling, rather than interrupts. Used * by the kernel debugger. Note that Caps Lock is ignored. - * Normally this routine is called with interrupts already - * disabled, but there is code in place so that it will be more + * Normally this routine is called with interrupts already + * disabled, but there is code in place so that it will be more * likely to work even if interrupts are turned on. */ int @@ -2976,6 +3044,39 @@ kdcnmaygetc(void) #ifdef notdef cnsetleds(state2leds(kd_state)); #endif + } else if (! up + && c == K_ESC + && key_map[scancode][char_idx+1] == 0x5b) { + /* As a convenience for the nice + people using our debugger, remap + some keys to the readline-like + shortcuts supported by dde. + + XXX This is a workaround for the + limited kernel getchar interface. + It is only used by the debugger. */ + c = key_map[scancode][char_idx+2]; + switch (c) { +#define _MAP(A,B,C) (C) +#define MAP(T) _MAP(T) +#define CTRL(c) ((c) & 0x1f) + case MAP(K_HOME): c = CTRL('a'); break; + case MAP(K_UA): c = CTRL('p'); break; + case MAP(K_LA): c = CTRL('b'); break; + case MAP(K_RA): c = CTRL('f'); break; + case MAP(K_DA): c = CTRL('n'); break; + case MAP(K_END): c = CTRL('e'); break; + /* delete */ + case 0x39: c = CTRL('d'); break; +#undef CTRL +#undef MAP +#undef _MAP + default: + /* Retain the old behavior. */ + c = K_ESC; + } + + return(c); } else if (!up) { /* regular key-down */ if (c == K_CR)