/* * Copyright (c) 1992,1993,1994 Hellmuth Michaelis, Brian Dunford-Shore, * Joerg Wunsch and Holger Veit. * * All rights reserved. * * This code is derived from software contributed to Berkeley by * William Jolitz and Don Ahn. * * This code is derived from software contributed to 386BSD by * Holger Veit. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Hellmuth Michaelis, * Brian Dunford-Shore and Joerg Wunsch. * 4. The name authors may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * * @(#)pcvt_kbd.c, 3.00, Last Edit-Date: [Sun Feb 27 17:04:53 1994] * */ /*---------------------------------------------------------------------------* * * pcvt_kbd.c VT220 Driver Keyboard Interface Code * ---------------------------------------------------- * -jw include rather primitive X stuff * -hm patch from Gordon L. Burditt to fix repeat of CAPS LOCK etc. * -hm netbsd: no file ddb.h available * -hm new keyboard routines from netbsd-current * -hm re-introduced keyboard id detection * -hm keyboard id debugging, hp sends special id ... * -jw keyboard overlay table now malloc'ed, SCROLL_SLEEP * -hm keyboard initialization for ddb activists ... * -hm keyboard security no longer ignored * -hm reset cursor when soft reset fkey * -jw USL VT compatibility * -hm CTRL-ALT-Fx switches to virtual terminal x * -hm added totalscreen checking, removed bug in vt220-like kbd part * -hm SCROLL_SLEEPing works * -hm kbd scancode sets 1 and 2 (patch from Onno van der Linden) * -hm printscreen key fix * -jw mouse emulation mode * -jw/hm all ifdef's converted to if's * -jw cleaned up the key prefix recognition * -jw included PCVT_META_ESC * -hm removed typo in cfkey11() (pillhuhns have good eyes ..) * -hm Debugger("kbd") patch from Joerg for FreeBSD * -hm bugfix, ALT-F12 steps over screen 0 * -hm vgapage() -> do_vgapage(), checks if in scrolling * -hm ------------ Release 3.00 -------------- * *---------------------------------------------------------------------------*/ #include "vt.h" #if NVT > 0 #include "pcvt_hdr.h" /* global include */ static void fkey1(void), fkey2(void), fkey3(void), fkey4(void); static void fkey5(void), fkey6(void), fkey7(void), fkey8(void); static void fkey9(void), fkey10(void), fkey11(void), fkey12(void); static void sfkey1(void), sfkey2(void), sfkey3(void), sfkey4(void); static void sfkey5(void), sfkey6(void), sfkey7(void), sfkey8(void); static void sfkey9(void), sfkey10(void), sfkey11(void), sfkey12(void); static void cfkey1(void), cfkey2(void), cfkey3(void), cfkey4(void); static void cfkey5(void), cfkey6(void), cfkey7(void), cfkey8(void); static void cfkey9(void), cfkey10(void), cfkey11(void), cfkey12(void); static void doreset ( void ); static void ovlinit ( int force ); static void settpmrate ( int rate ); static void setlockkeys ( int snc ); static int kbc_8042cmd ( int val ); static int getokeydef ( unsigned key, struct kbd_ovlkey *thisdef ); static int getckeydef ( unsigned key, struct kbd_ovlkey *thisdef ); static int rmkeydef ( int key ); static int setkeydef ( struct kbd_ovlkey *data ); static u_char * xlatkey2ascii( U_short key ); static int ledstate = 0; /* keyboard led's */ static int tpmrate = KBD_TPD500|KBD_TPM100; static u_char altkpflag = 0; static u_short altkpval = 0; #if PCVT_SHOWKEYS u_char rawkeybuf[80]; #endif /* PCVT_SHOWKEYS */ /*---------------------------------------------------------------------------* * function bound to control function key 12 *---------------------------------------------------------------------------*/ static void do_vgapage(int page) { if(critical_scroll) switch_page = page; else vgapage(page); } /*---------------------------------------------------------------------------* * this is one sub-entry for the table. the type can be either * "pointer to a string" or "pointer to a function" *---------------------------------------------------------------------------*/ typedef struct { u_char subtype; /* subtype, string or function */ union what { u_char *string; /* ptr to string, null terminated */ void (*func)(); /* ptr to function */ } what; } entry; /*---------------------------------------------------------------------------* * this is the "outer" table *---------------------------------------------------------------------------*/ typedef struct { u_short type; /* type of key */ u_short ovlindex; /* -hv- index into overload table */ entry unshift; /* normal default codes/funcs */ entry shift; /* shifted default codes/funcs */ entry ctrl; /* control default codes/funcs */ } Keycap_def; #define IDX0 0 /* default indexvalue into ovl table */ #define STR KBD_SUBT_STR /* subtype = ptr to string */ #define FNC KBD_SUBT_FNC /* subtype = ptr to function */ #define CODE_SIZE 5 /*---------------------------------------------------------------------------* * the overlaytable table is a static fixed size scratchpad where all the * overloaded definitions are stored. * an entry consists of a short (holding the new type attribute) and * four entries for a new keydefinition. *---------------------------------------------------------------------------*/ #define OVLTBL_SIZE 64 /* 64 keys can be overloaded */ #define Ovl_tbl struct kbd_ovlkey static Ovl_tbl *ovltbl; /* the table itself */ static ovlinitflag = 0; /* the init flag for the table */ /* * key codes >= 128 denote "virtual" shift/control * They are resolved before any keymapping is handled */ #if PCVT_SCANSET == 2 static u_char scantokey[] = { /* -0- -1- -2- -3- -4- -5- -6- -7- This layout is valid for US only */ /*00*/ 0,120, 0,116,114,112,113,123, /* ?? F9 ?? F5 F3 F1 F2 F12 */ /*08*/ 0,121,119,117,115, 16, 1, 0, /* ?? F10 F8 F6 F4 TAB ` ?? */ /*10*/ 0, 60, 44, 0, 58, 17, 2, 0, /* ?? ALl SHl ?? CTl Q 1 ?? */ /*18*/ 0, 0, 46, 32, 31, 18, 3, 0, /* ?? Z S A W 2 ?? ?? */ /*20*/ 0, 48, 47, 33, 19, 5, 4, 0, /* ?? C X D E 4 3 ?? */ /*28*/ 0, 61, 49, 34, 21, 20, 6, 0, /* ?? SP V F T R 5 ?? */ /*30*/ 0, 51, 50, 36, 35, 22, 7, 0, /* ?? N B H G Y 6 ?? */ /*38*/ 0, 0, 52, 37, 23, 8, 9, 0, /* ?? ?? M J U 7 8 ?? */ /*40*/ 0, 53, 38, 24, 25, 11, 10, 0, /* ?? , K I O 0 9 ?? */ /*48*/ 0, 54, 55, 39, 40, 26, 12, 0, /* ?? . / L ; P - ?? */ /*50*/ 0, 0, 41, 0, 27, 13, 0, 0, /* ?? ?? " ?? [ = ?? ?? */ /*58*/ 30, 57, 43, 28, 0, 29, 0, 0, /* CAP SHr ENT ] ?? \ ?? ?? */ /*60*/ 0, 45, 0, 0, 0, 0, 15, 0, /* ?? NL1 ?? ?? ?? ?? BS ?? */ /*68*/ 0, 93, 0, 92, 91, 0, 0, 0, /* ?? KP1 ?? KP4 KP7 ?? ?? ?? */ /*70*/ 99,104, 98, 97,102, 96,110, 90, /* KP0 KP. KP2 KP5 KP6 KP8 ESC NUM */ /*78*/ 122,106,103,105,100,101,125, 0, /* F11 KP+ KP3 KP- KP* KP9 LOC ?? */ /*80*/ 0, 0, 0,118,127 /* ?? ?? ?? F7 SyRQ */ }; static u_char extscantokey[] = { /* -0- -1- -2- -3- -4- -5- -6- -7- This layout is valid for US only */ /*00*/ 0,120, 0,116,114,112,113,123, /* ?? F9 ?? F5 F3 F1 F2 F12 */ /*08*/ 0,121,119,117,115, 16, 1, 0, /* ?? F10 F8 F6 F4 TAB ` ?? */ /*10*/ 0, 62,128, 0, 58, 17, 2, 0, /* ?? ALr vSh ?? CTr Q 1 ?? */ /*18*/ 0, 0, 46, 32, 31, 18, 3, 0, /* ?? Z S A W 2 ?? ?? */ /*20*/ 0, 48, 47, 33, 19, 5, 4, 0, /* ?? C X D E 4 3 ?? */ /*28*/ 0, 61, 49, 34, 21, 20, 6, 0, /* ?? SP V F T R 5 ?? */ /*30*/ 0, 51, 50, 36, 35, 22, 7, 0, /* ?? N B H G Y 6 ?? */ /*38*/ 0, 0, 52, 37, 23, 8, 9, 0, /* ?? ?? M J U 7 8 ?? */ /*40*/ 0, 53, 38, 24, 25, 11, 10, 0, /* ?? , K I O 0 9 ?? */ /*48*/ 0, 54, 95, 39, 40, 26, 12, 0, /* ?? . KP/ L ; P - ?? */ /*50*/ 0, 0, 41, 0, 27, 13, 0, 0, /* ?? ?? " ?? [ = ?? ?? */ /*58*/ 30, 57,108, 28, 0, 29, 0, 0, /* CAP SHr KPE ] ?? \ ?? ?? */ /*60*/ 0, 45, 0, 0, 0, 0, 15, 0, /* ?? NL1 ?? ?? ?? ?? BS ?? */ /*68*/ 0, 81, 0, 79, 80, 0, 0, 0, /* ?? END ?? LA HOM ?? ?? ?? */ /*70*/ 75, 76, 84, 97, 89, 83,110, 90, /* INS DEL DA KP5 RA UA ESC NUM */ /*78*/ 122,106, 86,105,124, 85,126, 0, /* F11 KP+ PD KP- PSc PU Brk ?? */ /*80*/ 0, 0, 0,118,127 /* ?? ?? ?? F7 SysRq */ }; #else /* PCVT_SCANSET != 2 */ static u_char scantokey[] = { /* -0- -1- -2- -3- -4- -5- -6- -7- This layout is valid for US only */ /*00*/ 0,110, 2, 3, 4, 5, 6, 7, /* ?? ESC 1 2 3 4 5 6 */ /*08*/ 8, 9, 10, 11, 12, 13, 15, 16, /* 7 8 9 0 - = BS TAB */ /*10*/ 17, 18, 19, 20, 21, 22, 23, 24, /* Q W E R T Y U I */ /*18*/ 25, 26, 27, 28, 43, 58, 31, 32, /* O P [ ] ENT CTl A S */ /*20*/ 33, 34, 35, 36, 37, 38, 39, 40, /* D F G H J K L ; */ /*28*/ 41, 1, 44, 29, 46, 47, 48, 49, /* ' ` SHl \ Z X C V */ /*30*/ 50, 51, 52, 53, 54, 55, 57,100, /* B N M , . / SHr KP* */ /*38*/ 60, 61, 30,112,113,114,115,116, /* ALl SP CAP F1 F2 F3 F4 F5 */ /*40*/ 117,118,119,120,121, 90,125, 91, /* F6 F7 F8 F9 F10 NUM LOC KP7 */ /*48*/ 96,101,105, 92, 97,102,106, 93, /* KP8 KP9 KP- KP4 KP5 KP6 KP+ KP1 */ /*50*/ 98,103, 99,104,127, 0, 45,122, /* KP2 KP3 KP0 KP. SyRq?? NL1 F11 */ /*58*/ 123 /* F12 */ }; static u_char extscantokey[] = { /* -0- -1- -2- -3- -4- -5- -6- -7- This layout is valid for US only */ /*00*/ 0,110, 2, 3, 4, 5, 6, 7, /* ?? ESC 1 2 3 4 5 6 */ /*08*/ 8, 9, 10, 11, 12, 13, 15, 16, /* 7 8 9 0 - = BS TAB */ /*10*/ 17, 18, 19, 20, 21, 22, 23, 24, /* Q W E R T Y U I */ /*18*/ 25, 26, 27, 28,108, 58, 31, 32, /* O P [ ] KPE CTr A S */ /*20*/ 33, 34, 35, 36, 37, 38, 39, 40, /* D F G H J K L ; */ /*28*/ 41, 1,128, 29, 46, 47, 48, 49, /* ' ` vSh \ Z X C V */ /*30*/ 50, 51, 52, 53, 54, 95, 57,124, /* B N M , . KP/ SHr KP* */ /*38*/ 62, 61, 30,112,113,114,115,116, /* ALr SP CAP F1 F2 F3 F4 F5 */ /*40*/ 117,118,119,120,121, 90,126, 80, /* F6 F7 F8 F9 F10 NUM Brk HOM */ /*48*/ 83, 85,105, 79, 97, 89,106, 81, /* UA PU KP- LA KP5 RA KP+ END */ /*50*/ 84, 86, 75, 76, 0, 0, 45,122, /* DA PD INS DEL ?? ?? NL1 F11 */ /*58*/ 123, /* F12 */ }; #endif /* PCVT_SCANSET == 2 */ static Keycap_def key2ascii[] = { /* define some shorthands to make the table (almost) fit into 80 columns */ #define C (u_char *) #define V (void *) #define S STR #define F FNC #define I IDX0 /* DONT EVER OVERLOAD KEY 0, THIS IS A KEY THAT MUSTN'T EXIST */ /* type index unshift shift ctrl */ /* ---------------------------------------------------------- */ /* 0*/ KBD_NONE, I, {S,C "df"}, {S,C ""}, {S,C ""}, /* 1*/ KBD_ASCII, I, {S,C "`"}, {S,C "~"}, {S,C "`"}, /* 2*/ KBD_ASCII, I, {S,C "1"}, {S,C "!"}, {S,C "1"}, /* 3*/ KBD_ASCII, I, {S,C "2"}, {S,C "@"}, {S,C "\000"}, /* 4*/ KBD_ASCII, I, {S,C "3"}, {S,C "#"}, {S,C "3"}, /* 5*/ KBD_ASCII, I, {S,C "4"}, {S,C "$"}, {S,C "4"}, /* 6*/ KBD_ASCII, I, {S,C "5"}, {S,C "%"}, {S,C "5"}, /* 7*/ KBD_ASCII, I, {S,C "6"}, {S,C "^"}, {S,C "\036"}, /* 8*/ KBD_ASCII, I, {S,C "7"}, {S,C "&"}, {S,C "7"}, /* 9*/ KBD_ASCII, I, {S,C "8"}, {S,C "*"}, {S,C "9"}, /* 10*/ KBD_ASCII, I, {S,C "9"}, {S,C "("}, {S,C "9"}, /* 11*/ KBD_ASCII, I, {S,C "0"}, {S,C ")"}, {S,C "0"}, /* 12*/ KBD_ASCII, I, {S,C "-"}, {S,C "_"}, {S,C "\037"}, /* 13*/ KBD_ASCII, I, {S,C "="}, {S,C "+"}, {S,C "="}, /* 14*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 15*/ KBD_ASCII, I, {S,C "\177"}, {S,C "\010"}, {S,C "\177"}, /* BS */ /* 16*/ KBD_ASCII, I, {S,C "\t"}, {S,C "\t"}, {S,C "\t"}, /* TAB */ /* 17*/ KBD_ASCII, I, {S,C "q"}, {S,C "Q"}, {S,C "\021"}, /* 18*/ KBD_ASCII, I, {S,C "w"}, {S,C "W"}, {S,C "\027"}, /* 19*/ KBD_ASCII, I, {S,C "e"}, {S,C "E"}, {S,C "\005"}, /* 20*/ KBD_ASCII, I, {S,C "r"}, {S,C "R"}, {S,C "\022"}, /* 21*/ KBD_ASCII, I, {S,C "t"}, {S,C "T"}, {S,C "\024"}, /* 22*/ KBD_ASCII, I, {S,C "y"}, {S,C "Y"}, {S,C "\031"}, /* 23*/ KBD_ASCII, I, {S,C "u"}, {S,C "U"}, {S,C "\025"}, /* 24*/ KBD_ASCII, I, {S,C "i"}, {S,C "I"}, {S,C "\011"}, /* 25*/ KBD_ASCII, I, {S,C "o"}, {S,C "O"}, {S,C "\017"}, /* 26*/ KBD_ASCII, I, {S,C "p"}, {S,C "P"}, {S,C "\020"}, /* 27*/ KBD_ASCII, I, {S,C "["}, {S,C "{"}, {S,C "\033"}, /* 28*/ KBD_ASCII, I, {S,C "]"}, {S,C "}"}, {S,C "\035"}, /* 29*/ KBD_ASCII, I, {S,C "\\"}, {S,C "|"}, {S,C "\034"}, /* 30*/ KBD_CAPS, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 31*/ KBD_ASCII, I, {S,C "a"}, {S,C "A"}, {S,C "\001"}, /* 32*/ KBD_ASCII, I, {S,C "s"}, {S,C "S"}, {S,C "\023"}, /* 33*/ KBD_ASCII, I, {S,C "d"}, {S,C "D"}, {S,C "\004"}, /* 34*/ KBD_ASCII, I, {S,C "f"}, {S,C "F"}, {S,C "\006"}, /* 35*/ KBD_ASCII, I, {S,C "g"}, {S,C "G"}, {S,C "\007"}, /* 36*/ KBD_ASCII, I, {S,C "h"}, {S,C "H"}, {S,C "\010"}, /* 37*/ KBD_ASCII, I, {S,C "j"}, {S,C "J"}, {S,C "\n"}, /* 38*/ KBD_ASCII, I, {S,C "k"}, {S,C "K"}, {S,C "\013"}, /* 39*/ KBD_ASCII, I, {S,C "l"}, {S,C "L"}, {S,C "\014"}, /* 40*/ KBD_ASCII, I, {S,C ";"}, {S,C ":"}, {S,C ";"}, /* 41*/ KBD_ASCII, I, {S,C "'"}, {S,C "\""}, {S,C "'"}, /* 42*/ KBD_ASCII, I, {S,C "\\"}, {S,C "|"}, {S,C "\034"}, /* special */ /* 43*/ KBD_RETURN,I, {S,C "\r"}, {S,C "\r"}, {S,C "\r"}, /* RETURN */ /* 44*/ KBD_SHIFT, I, {S,C ""}, {S,C ""}, {S,C ""}, /* SHIFT left */ /* 45*/ KBD_ASCII, I, {S,C "<"}, {S,C ">"}, {S,C ""}, /* 46*/ KBD_ASCII, I, {S,C "z"}, {S,C "Z"}, {S,C "\032"}, /* 47*/ KBD_ASCII, I, {S,C "x"}, {S,C "X"}, {S,C "\030"}, /* 48*/ KBD_ASCII, I, {S,C "c"}, {S,C "C"}, {S,C "\003"}, /* 49*/ KBD_ASCII, I, {S,C "v"}, {S,C "V"}, {S,C "\026"}, /* 50*/ KBD_ASCII, I, {S,C "b"}, {S,C "B"}, {S,C "\002"}, /* 51*/ KBD_ASCII, I, {S,C "n"}, {S,C "N"}, {S,C "\016"}, /* 52*/ KBD_ASCII, I, {S,C "m"}, {S,C "M"}, {S,C "\r"}, /* 53*/ KBD_ASCII, I, {S,C ","}, {S,C "<"}, {S,C ","}, /* 54*/ KBD_ASCII, I, {S,C "."}, {S,C ">"}, {S,C "."}, /* 55*/ KBD_ASCII, I, {S,C "/"}, {S,C "?"}, {S,C "/"}, /* 56*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 57*/ KBD_SHIFT, I, {S,C ""}, {S,C ""}, {S,C ""}, /* SHIFT right */ /* 58*/ KBD_CTL, I, {S,C ""}, {S,C ""}, {S,C ""}, /* CTL left */ /* 59*/ KBD_ASCII, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 60*/ KBD_META, I, {S,C ""}, {S,C ""}, {S,C ""}, /* ALT left */ #if !PCVT_NULLCHARS /* 61*/ KBD_ASCII, I, {S,C " "}, {S,C " "}, {S,C " "}, /* SPACE */ #else /* 61*/ KBD_ASCII, I, {S,C " "}, {S,C " "}, {S,C "\000"}, /* SPACE */ #endif /* PCVT_NULLCHARS */ /* 62*/ KBD_META, I, {S,C ""}, {S,C ""}, {S,C ""}, /* ALT right */ /* 63*/ KBD_ASCII, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 64*/ KBD_CTL, I, {S,C ""}, {S,C ""}, {S,C ""}, /* CTL right */ /* 65*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 66*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 67*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 68*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 69*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 70*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 71*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 72*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 73*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 74*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 75*/ KBD_FUNC, I, {S,C "\033[2~"},{S,C "\033[2~"},{S,C "\033[2~"},/* INS */ /* 76*/ KBD_FUNC, I, {S,C "\033[3~"},{S,C "\033[3~"},{S,C "\033[3~"},/* DEL */ /* 77*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 78*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 79*/ KBD_CURSOR,I, {S,C "\033[D"},{S,C "\033OD"},{S,C "\033[D"}, /* CU <- */ /* 80*/ KBD_FUNC, I, {S,C "\033[1~"},{S,C "\033[1~"},{S,C "\033[1~"},/* HOME = FIND*/ /* 81*/ KBD_FUNC, I, {S,C "\033[4~"},{S,C "\033[4~"},{S,C "\033[4~"},/* END = SELECT */ /* 82*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 83*/ KBD_CURSOR,I, {S,C "\033[A"},{S,C "\033OA"},{S,C "\033[A"}, /* CU ^ */ /* 84*/ KBD_CURSOR,I, {S,C "\033[B"},{S,C "\033OB"},{S,C "\033[B"}, /* CU v */ /* 85*/ KBD_FUNC, I, {S,C "\033[5~"},{S,C "\033[5~"},{S,C "\033[5~"},/*PG UP*/ /* 86*/ KBD_FUNC, I, {S,C "\033[6~"},{S,C "\033[6~"},{S,C "\033[6~"},/*PG DN*/ /* 87*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 88*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 89*/ KBD_CURSOR,I, {S,C "\033[C"},{S,C "\033OC"},{S,C "\033[C"}, /* CU -> */ /* 90*/ KBD_NUM, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 91*/ KBD_KP, I, {S,C "7"}, {S,C "\033Ow"},{S,C "7"}, /* 92*/ KBD_KP, I, {S,C "4"}, {S,C "\033Ot"},{S,C "4"}, /* 93*/ KBD_KP, I, {S,C "1"}, {S,C "\033Oq"},{S,C "1"}, /* 94*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /* 95*/ KBD_KP, I, {S,C "/"}, {S,C "/"}, {S,C "/"}, /* 96*/ KBD_KP, I, {S,C "8"}, {S,C "\033Ox"},{S,C "8"}, /* 97*/ KBD_KP, I, {S,C "5"}, {S,C "\033Ou"},{S,C "5"}, /* 98*/ KBD_KP, I, {S,C "2"}, {S,C "\033Or"},{S,C "2"}, /* 99*/ KBD_KP, I, {S,C "0"}, {S,C "\033Op"},{S,C "0"}, /*100*/ KBD_KP, I, {S,C "*"}, {S,C "*"}, {S,C "*"}, /*101*/ KBD_KP, I, {S,C "9"}, {S,C "\033Oy"},{S,C "9"}, /*102*/ KBD_KP, I, {S,C "6"}, {S,C "\033Ov"},{S,C "6"}, /*103*/ KBD_KP, I, {S,C "3"}, {S,C "\033Os"},{S,C "3"}, /*104*/ KBD_KP, I, {S,C "."}, {S,C "\033On"},{S,C "."}, /*105*/ KBD_KP, I, {S,C "-"}, {S,C "\033Om"},{S,C "-"}, /*106*/ KBD_KP, I, {S,C "+"}, {S,C "+"}, {S,C "+"}, /*107*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /*108*/ KBD_RETURN,I, {S,C "\r"}, {S,C "\033OM"},{S,C "\r"}, /* KP ENTER */ /*109*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /*110*/ KBD_ASCII, I, {S,C "\033"}, {S,C "\033"}, {S,C "\033"}, /*111*/ KBD_NONE, I, {S,C ""}, {S,C ""}, {S,C ""}, /*112*/ KBD_FUNC, I, {F,V fkey1}, {F,V sfkey1}, {F,V cfkey1}, /* F1 */ /*113*/ KBD_FUNC, I, {F,V fkey2}, {F,V sfkey2}, {F,V cfkey2}, /* F2 */ /*114*/ KBD_FUNC, I, {F,V fkey3}, {F,V sfkey3}, {F,V cfkey3}, /* F3 */ /*115*/ KBD_FUNC, I, {F,V fkey4}, {F,V sfkey4}, {F,V cfkey4}, /* F4 */ /*116*/ KBD_FUNC, I, {F,V fkey5}, {F,V sfkey5}, {F,V cfkey5}, /* F5 */ /*117*/ KBD_FUNC, I, {F,V fkey6}, {F,V sfkey6}, {F,V cfkey6}, /* F6 */ /*118*/ KBD_FUNC, I, {F,V fkey7}, {F,V sfkey7}, {F,V cfkey7}, /* F7 */ /*119*/ KBD_FUNC, I, {F,V fkey8}, {F,V sfkey8}, {F,V cfkey8}, /* F8 */ /*120*/ KBD_FUNC, I, {F,V fkey9}, {F,V sfkey9}, {F,V cfkey9}, /* F9 */ /*121*/ KBD_FUNC, I, {F,V fkey10}, {F,V sfkey10}, {F,V cfkey10}, /* F10 */ /*122*/ KBD_FUNC, I, {F,V fkey11}, {F,V sfkey11}, {F,V cfkey11}, /* F11 */ /*123*/ KBD_FUNC, I, {F,V fkey12}, {F,V sfkey12}, {F,V cfkey12}, /* F12 */ /*124*/ KBD_KP, I, {S,C ""}, {S,C ""}, {S,C ""}, /*125*/ KBD_SCROLL,I, {S,C ""}, {S,C ""}, {S,C ""}, /*126*/ KBD_BREAK, I, {S,C ""}, {S,C ""}, {S,C ""}, /*127*/ KBD_FUNC, I, {S,C ""}, {S,C ""}, {S,C ""}, /* SysRq */ #undef C #undef V #undef S #undef F #undef I }; static short keypad2num[] = { 7, 4, 1, -1, -1, 8, 5, 2, 0, -1, 9, 6, 3, -1, -1, -1, -1 }; #if PCVT_USL_VT_COMPAT #define N_KEYNUMS 128 /* * this is the reverse mapping from keynumbers to scanset 1 codes * it is used to emulate the SysV-style GIO_KEYMAP ioctl cmd */ static u_char key2scan1[N_KEYNUMS] = { 0,0x29,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09, /* 0 */ 0x0a,0x0b,0x0c,0x0d, 0,0x0e,0x0f,0x10,0x11,0x12, /* 10 */ 0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x2b, /* 20 */ 0x3a,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26, /* 30 */ 0x27,0x28, 0,0x1c,0x2a,0x56,0x2c,0x2d,0x2e,0x2f, /* 40 */ 0x30,0x31,0x32,0x33,0x34,0x35,0x56,0x36,0x1d, 0, /* 50 */ 0x38,0x39, 0, 0, 0, 0, 0, 0, 0, 0, /* 60 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 70 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 80 */ 0x45,0x47,0x4b,0x4f, 0, 0,0x48,0x4c,0x50,0x52, /* 90 */ 0x37,0x49,0x4d,0x51,0x53,0x4a,0x4e, 0, 0, 0, /* 100 */ 0x01, 0,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x42, /* 110 */ 0x43,0x44,0x57,0x58, 0,0x46, 0,0x54 /* 120 */ }; /* * SysV is brain-dead enough to stick on the IBM code page 437. So we * have to translate our keymapping into IBM 437 (possibly losing keys), * in order to have the X server convert it back into ISO8859.1 */ /* NB: this table only contains the mapping for codes >= 128 */ static u_char iso2ibm437[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xad, 0x9b, 0x9c, 0, 0x9d, 0, 0x40, 0x6f, 0x63, 0x61, 0xae, 0, 0, 0, 0, 0xf8, 0xf1, 0xfd, 0x33, 0, 0xe6, 0, 0xfa, 0, 0x31, 0x6f, 0xaf, 0xac, 0xab, 0, 0xa8, 0x41, 0x41, 0x41, 0x41, 0x8e, 0x8f, 0x92, 0x80, 0x45, 0x90, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49, 0x81, 0xa5, 0x4f, 0x4f, 0x4f, 0x4f, 0x99, 0x4f, 0x4f, 0x55, 0x55, 0x55, 0x9a, 0x59, 0, 0xe1, 0x85, 0xa0, 0x83, 0x61, 0x84, 0x86, 0x91, 0x87, 0x8a, 0x82, 0x88, 0x89, 0x8d, 0xa1, 0x8c, 0x8b, 0, 0xa4, 0x95, 0xa2, 0x93, 0x6f, 0x94, 0x6f, 0x6f, 0x97, 0xa3, 0x96, 0x81, 0x98, 0, 0 }; #endif /* PCVT_USL_VT_COMPAT */ /*---------------------------------------------------------------------------* * update keyboard led's *---------------------------------------------------------------------------*/ void update_led(void) { ledstate = ((vsp->scroll_lock) | (vsp->num_lock * 2) | (vsp->caps_lock * 4)); if(kbd_cmd(KEYB_C_LEDS) != 0) printf("Keyboard LED command timeout\n"); else if(kbd_cmd(ledstate) != 0) printf("Keyboard LED data timeout\n"); } /*---------------------------------------------------------------------------* * set typamatic rate *---------------------------------------------------------------------------*/ static void settpmrate(int rate) { tpmrate = rate & 0x7f; if(kbd_cmd(KEYB_C_TYPEM) != 0) printf("Keyboard TYPEMATIC command timeout\n"); else if(kbd_cmd(tpmrate) != 0) printf("Keyboard TYPEMATIC data timeout\n"); } /*---------------------------------------------------------------------------* * Pass command to keyboard controller (8042) *---------------------------------------------------------------------------*/ static int kbc_8042cmd(int val) { unsigned timeo; timeo = 100000; /* > 100 msec */ while (inb(CONTROLLER_CTRL) & STATUS_INPBF) if (--timeo == 0) return (-1); delay(6); outb(CONTROLLER_CTRL, val); return (0); } /*---------------------------------------------------------------------------* * Pass command to keyboard itself *---------------------------------------------------------------------------*/ int kbd_cmd(int val) { unsigned timeo; timeo = 100000; /* > 100 msec */ while (inb(CONTROLLER_CTRL) & STATUS_INPBF) if (--timeo == 0) return (-1); delay(6); outb(CONTROLLER_DATA, val); return (0); } /*---------------------------------------------------------------------------* * Read response from keyboard *---------------------------------------------------------------------------*/ int kbd_response(void) { unsigned timeo; timeo = 500000; /* > 500 msec (KEYB_R_SELFOK requires 87) */ while (!(inb(CONTROLLER_CTRL) & STATUS_OUTPBF)) if (--timeo == 0) return (-1); delay(6); return ((u_char) inb(CONTROLLER_DATA)); } /*---------------------------------------------------------------------------* * try to force keyboard into a known state .. *---------------------------------------------------------------------------*/ static void doreset(void) { int again = 0; int response; /* Enable interrupts and keyboard, etc. */ if (kbc_8042cmd(CONTR_WRITE) != 0) printf("Timeout specifying load of keyboard command byte\n"); #if PCVT_USEKBDSEC /* security enabled */ # if PCVT_SCANSET == 2 # define KBDINITCMD COMMAND_SYSFLG|COMMAND_IRQEN # else /* PCVT_SCANSET != 2 */ # define KBDINITCMD COMMAND_PCSCAN|COMMAND_SYSFLG|COMMAND_IRQEN # endif /* PCVT_SCANSET == 2 */ #else /* ! PCVT_USEKBDSEC */ /* security disabled */ # if PCVT_SCANSET == 2 # define KBDINITCMD COMMAND_INHOVR|COMMAND_SYSFLG|COMMAND_IRQEN # else /* PCVT_SCANSET != 2 */ # define KBDINITCMD COMMAND_PCSCAN|COMMAND_INHOVR|COMMAND_SYSFLG\ |COMMAND_IRQEN # endif /* PCVT_SCANSET == 2 */ #endif /* PCVT_USEKBDSEC */ if (kbd_cmd(KBDINITCMD) != 0) printf("Timeout writing keyboard command byte\n"); /* * Discard any stale keyboard activity. The 0.1 boot code isn't * very careful and sometimes leaves a KEYB_R_RESEND. */ while (inb(CONTROLLER_CTRL) & STATUS_OUTPBF) kbd_response(); /* Start keyboard reset */ if (kbd_cmd(KEYB_C_RESET) != 0) printf("Timeout for keyboard reset command\n"); /* Wait for the first response to reset and handle retries */ while ((response = kbd_response()) != KEYB_R_ACK) { if (response < 0) { printf("Timeout for keyboard reset ack byte #1\n"); response = KEYB_R_RESEND; } if (response == KEYB_R_RESEND) { if (!again) { printf("KEYBOARD disconnected: RECONNECT\n"); again = 1; } if (kbd_cmd(KEYB_C_RESET) != 0) printf("Timeout for keyboard reset command\n"); } /* * Other responses are harmless. They may occur for new * keystrokes. */ } /* Wait for the second response to reset */ while ((response = kbd_response()) != KEYB_R_SELFOK) { if (response < 0) { printf("Timeout for keyboard reset ack byte #2\n"); /* * If KEYB_R_SELFOK never arrives, the loop will * finish here unless the keyboard babbles or * STATUS_OUTPBF gets stuck. */ break; } } #if PCVT_KEYBDID if(kbd_cmd(KEYB_C_ID) != 0) { printf("Timeout for keyboard ID command\n"); keyboard_type = KB_UNKNOWN; } else { r_entry: if((response = kbd_response()) == KEYB_R_MF2ID1) { if((response = kbd_response()) == KEYB_R_MF2ID2) { keyboard_type = KB_MFII; } else if(response == KEYB_R_MF2ID2HP) { keyboard_type = KB_MFII; } else { printf("\nkbdid, response 2 = [%d]\n", response); keyboard_type = KB_UNKNOWN; } } else if (response == KEYB_R_ACK) { goto r_entry; } else if (response == -1) { keyboard_type = KB_AT; } else { printf("\nkbdid, response 1 = [%d]\n", response); } } #else /* PCVT_KEYBDID */ keyboard_type = KB_MFII; /* force it .. */ #endif /* PCVT_KEYBDID */ } /*---------------------------------------------------------------------------* * init keyboard code *---------------------------------------------------------------------------*/ void kbd_code_init(void) { doreset(); ovlinit(0); keyboard_is_initialized = 1; } /*---------------------------------------------------------------------------* * init keyboard code, this initializes the keyboard subsystem * just "a bit" so the very very first ddb session is able to * get proper keystrokes, in other words, it's a hack .... *---------------------------------------------------------------------------*/ void kbd_code_init1(void) { doreset(); keyboard_is_initialized = 1; } /*---------------------------------------------------------------------------* * init keyboard overlay table *---------------------------------------------------------------------------*/ static void ovlinit(int force) { register i; if(force || ovlinitflag==0) { if(ovlinitflag == 0 && (ovltbl = (Ovl_tbl *)malloc(sizeof(Ovl_tbl) * OVLTBL_SIZE, M_DEVBUF, M_WAITOK)) == NULL) panic("pcvt_kbd: malloc of Ovl_tbl failed"); for(i=0; i MAXKEYNUM) return EINVAL; thisdef->keynum = key; thisdef->type = key2ascii[key].type; if(key2ascii[key].unshift.subtype == STR) { bcopy((u_char *)(key2ascii[key].unshift.what.string), thisdef->unshift, CODE_SIZE); thisdef->subu = KBD_SUBT_STR; } else { bcopy("", thisdef->unshift, CODE_SIZE); thisdef->subu = KBD_SUBT_FNC; } if(key2ascii[key].shift.subtype == STR) { bcopy((u_char *)(key2ascii[key].shift.what.string), thisdef->shift, CODE_SIZE); thisdef->subs = KBD_SUBT_STR; } else { bcopy("",thisdef->shift,CODE_SIZE); thisdef->subs = KBD_SUBT_FNC; } if(key2ascii[key].ctrl.subtype == STR) { bcopy((u_char *)(key2ascii[key].ctrl.what.string), thisdef->ctrl, CODE_SIZE); thisdef->subc = KBD_SUBT_STR; } else { bcopy("",thisdef->ctrl,CODE_SIZE); thisdef->subc = KBD_SUBT_FNC; } /* deliver at least anything for ALTGR settings ... */ if(key2ascii[key].unshift.subtype == STR) { bcopy((u_char *)(key2ascii[key].unshift.what.string), thisdef->altgr, CODE_SIZE); thisdef->suba = KBD_SUBT_STR; } else { bcopy("",thisdef->altgr, CODE_SIZE); thisdef->suba = KBD_SUBT_FNC; } return 0; } /*---------------------------------------------------------------------------* * get current key definition *---------------------------------------------------------------------------*/ static int getckeydef(unsigned key, Ovl_tbl *thisdef) { u_short type = key2ascii[key].type; if(key>MAXKEYNUM) return EINVAL; if(type & KBD_OVERLOAD) *thisdef = ovltbl[key2ascii[key].ovlindex]; else getokeydef(key,thisdef); return 0; } /*---------------------------------------------------------------------------* * translate keynumber and returns ptr to associated ascii string * if key is bound to a function, executes it, and ret empty ptr *---------------------------------------------------------------------------*/ static u_char * xlatkey2ascii(U_short key) { static u_char capchar[2] = {0, 0}; #if PCVT_META_ESC static u_char metachar[3] = {0x1b, 0, 0}; #else static u_char metachar[2] = {0, 0}; #endif static Ovl_tbl thisdef; int n; void (*fnc)(); if(key==0) /* ignore the NON-KEY */ return 0; getckeydef(key&0x7F, &thisdef); /* get the current ASCII value */ thisdef.type &= KBD_MASK; if(key&0x80) /* special handling of ALT-KEYPAD */ { /* is the ALT Key released? */ if(thisdef.type==KBD_META || thisdef.type==KBD_ALTGR) { if(altkpflag) /* have we been in altkp mode? */ { capchar[0] = altkpval; altkpflag = 0; altkpval = 0; return capchar; } } return 0; } switch(thisdef.type) /* convert the keys */ { case KBD_BREAK: case KBD_ASCII: case KBD_FUNC: fnc = NULL; more_chars = NULL; if(altgr_down) more_chars = (u_char *)thisdef.altgr; else if(shift_down || vsp->shift_lock) { if(key2ascii[key].shift.subtype == STR) more_chars = (u_char *)thisdef.shift; else fnc = key2ascii[key].shift.what.func; } else if(ctrl_down) { if(key2ascii[key].ctrl.subtype == STR) more_chars = (u_char *)thisdef.ctrl; else fnc = key2ascii[key].ctrl.what.func; } else { if(key2ascii[key].unshift.subtype == STR) more_chars = (u_char *)thisdef.unshift; else fnc = key2ascii[key].unshift.what.func; } if(fnc) (*fnc)(); /* execute function */ if((more_chars != NULL) && (more_chars[1] == 0)) { if(vsp->caps_lock && more_chars[0] >= 'a' && more_chars[0] <= 'z') { capchar[0] = *more_chars - ('a'-'A'); more_chars = capchar; } if(meta_down) { #if PCVT_META_ESC metachar[1] = *more_chars; #else metachar[0] = *more_chars | 0x80; #endif more_chars = metachar; } } return(more_chars); case KBD_KP: fnc = NULL; more_chars = NULL; if(meta_down) { switch(key) { case 95: /* / */ altkpflag = 0; more_chars = (u_char *)"\033OQ"; return(more_chars); case 100: /* * */ altkpflag = 0; more_chars = (u_char *)"\033OR"; return(more_chars); case 105: /* - */ altkpflag = 0; more_chars = (u_char *)"\033OS"; return(more_chars); } } if(meta_down || altgr_down) { if((n = keypad2num[key-91]) >= 0) { if(!altkpflag) { /* start ALT-KP mode */ altkpflag = 1; altkpval = 0; } altkpval *= 10; altkpval += n; } else altkpflag = 0; return 0; } if(!(vsp->num_lock)) { if(key2ascii[key].shift.subtype == STR) more_chars = (u_char *)thisdef.shift; else fnc = key2ascii[key].shift.what.func; } else { if(key2ascii[key].unshift.subtype == STR) more_chars = (u_char *)thisdef.unshift; else fnc = key2ascii[key].unshift.what.func; } if(fnc) (*fnc)(); /* execute function */ return(more_chars); case KBD_CURSOR: fnc = NULL; more_chars = NULL; if(vsp->ckm) { if(key2ascii[key].shift.subtype == STR) more_chars = (u_char *)thisdef.shift; else fnc = key2ascii[key].shift.what.func; } else { if(key2ascii[key].unshift.subtype == STR) more_chars = (u_char *)thisdef.unshift; else fnc = key2ascii[key].unshift.what.func; } if(fnc) (*fnc)(); /* execute function */ return(more_chars); case KBD_NUM: /* special kp-num handling */ more_chars = NULL; if(meta_down) { more_chars = (u_char *)"\033OP"; /* PF1 */ } else { vsp->num_lock ^= 1; update_led(); } return(more_chars); case KBD_RETURN: more_chars = NULL; if(!(vsp->num_lock)) { more_chars = (u_char *)thisdef.shift; } else { more_chars = (u_char *)thisdef.unshift; } if(vsp->lnm && (*more_chars == '\r')) { more_chars = (u_char *)"\r\n"; /* CR LF */ } if(meta_down) { #if PCVT_META_ESC metachar[1] = *more_chars; #else metachar[0] = *more_chars | 0x80; #endif more_chars = metachar; } return(more_chars); case KBD_META: /* these keys are */ case KBD_ALTGR: /* handled directly */ case KBD_SCROLL: /* by the keyboard */ case KBD_CAPS: /* handler - they are */ case KBD_SHFTLOCK: /* ignored here */ case KBD_CTL: case KBD_NONE: default: return 0; } } /*---------------------------------------------------------------------------* * get keystrokes from the keyboard. * if noblock = 0, wait until a key is pressed. * else return NULL if no characters present. *---------------------------------------------------------------------------*/ u_char * sgetc(int noblock) { u_char *cp; u_char dt; u_char key; u_short type; static u_char kbd_lastkey = 0; /* last keystroke */ static struct { u_char extended: 1; /* extended prefix seen */ u_char ext1: 1; /* extended prefix 1 seen */ u_char breakseen: 1; /* break code seen */ u_char vshift: 1; /* virtual shift pending */ u_char vcontrol: 1; /* virtual control pending */ u_char sysrq: 1; /* sysrq pressed */ } kbd_status = {0}; #ifdef XSERVER static char keybuf[2] = {0}; /* the second 0 is a delimiter! */ #endif /* XSERVER */ loop: /* see if there is something from the keyboard in the input buffer */ #ifdef XSERVER if (inb(CONTROLLER_CTRL) & STATUS_OUTPBF) { dt = inb(CONTROLLER_DATA); /* yes, get it ! */ /* * If x mode is active, only care for locking keys, then * return the scan code instead of any key translation. * Additionally, this prevents us from any attempts to * execute pcvt internal functions caused by keys (such * as screen flipping). * XXX For now, only the default locking key definitions * are recognized (i.e. if you have overloaded you "A" key * as NUMLOCK, that wont effect X mode:-) * Changing this would be nice, but would require modifi- * cations to the X server. After having this, X will * deal with the LEDs itself, so we are committed. */ /* * Iff PCVT_USL_VT_COMPAT is defined, the behaviour has * been fixed. We need not care about any keys here, since * there are ioctls that deal with the lock key / LED stuff. */ if (pcvt_kbd_raw) { keybuf[0] = dt; #if !PCVT_USL_VT_COMPAT if ((dt & 0x80) == 0) /* key make */ switch(dt) { case 0x45: /* XXX on which virt screen? */ vsp->num_lock ^= 1; update_led(); break; case 0x3a: vsp->caps_lock ^= 1; update_led(); break; case 0x46: vsp->scroll_lock ^= 1; update_led(); break; } #endif /* !PCVT_USL_VT_COMPAT */ #if PCVT_EMU_MOUSE /* * The (mouse systems) mouse emulator. The mouse * device allocates the first device node that is * not used by a virtual terminal. (E.g., you have * eight vtys, /dev/ttyv0 thru /dev/ttyv7, so the * mouse emulator were /dev/ttyv8.) * Currently the emulator only works if the keyboard * is in raw (PC scan code) mode. This is the typic- * al case when running the X server. * It is activated if the num locks LED is active * for the current vty, and if the mouse device * has been opened by at least one process. It * grabs the numerical keypad events (but only * the "non-extended", so the separate arrow keys * continue to work), and three keys for the "mouse * buttons", preferrably F1 thru F3. Any of the * eight directions (N, NE, E, SE, S, SW, W, NW) * is supported, and frequent key presses (less * than e.g. half a second between key presses) * cause the emulator to accelerate the pointer * movement by 6, while single presses result in * single moves, so each point can be reached. */ /* * NB: the following code is spagghetti. * Only eat it with lotta tomato ketchup and * Parmesan cheese:-) */ /* * look whether we will have to steal the keys * and cook them into mouse events */ if(vsp->num_lock && mouse.opened) { int button, accel, i; enum mouse_dir { MOUSE_NW, MOUSE_N, MOUSE_NE, MOUSE_W, MOUSE_0, MOUSE_E, MOUSE_SW, MOUSE_S, MOUSE_SE } move; struct timeval now; /* from sys/kern/kern_time.c */ extern void timevalsub (struct timeval *, struct timeval *); dev_t dummy = makedev(0, mouse.minor); struct tty *mousetty = get_pccons(dummy); /* * strings to send for each mouse event, * indexed by the movement direction and * the "accelerator" value (TRUE for frequent * key presses); note that the first byte * of each string is actually overwritten * by the current button value before sending * the string */ static u_char mousestrings[2][MOUSE_SE+1][5] = { { /* first, the non-accelerated strings*/ {0x87, -1, 1, 0, 0}, /* NW */ {0x87, 0, 1, 0, 0}, /* N */ {0x87, 1, 1, 0, 0}, /* NE */ {0x87, -1, 0, 0, 0}, /* W */ {0x87, 0, 0, 0, 0}, /* 0 */ {0x87, 1, 0, 0, 0}, /* E */ {0x87, -1, -1, 0, 0}, /* SW */ {0x87, 0, -1, 0, 0}, /* S */ {0x87, 1, -1, 0, 0} /* SE */ }, { /* now, 6 steps at once */ {0x87, -4, 4, 0, 0}, /* NW */ {0x87, 0, 6, 0, 0}, /* N */ {0x87, 4, 4, 0, 0}, /* NE */ {0x87, -6, 0, 0, 0}, /* W */ {0x87, 0, 0, 0, 0}, /* 0 */ {0x87, 6, 0, 0, 0}, /* E */ {0x87, -4, -4, 0, 0}, /* SW */ {0x87, 0, -6, 0, 0}, /* S */ {0x87, 4, -4, 0, 0} /* SE */ } }; if(dt == 0xe0) { /* ignore extended scan codes */ mouse.extendedseen = 1; goto no_mouse_event; } if(mouse.extendedseen) { mouse.extendedseen = 0; goto no_mouse_event; } mouse.extendedseen = 0; /* * Note that we cannot use a switch here * since we want to have the keycodes in * a variable */ if((dt & 0x7f) == mousedef.leftbutton) { button = 4; goto do_button; } else if((dt & 0x7f) == mousedef.middlebutton) { button = 2; goto do_button; } else if((dt & 0x7f) == mousedef.rightbutton) { button = 1; do_button: /* * i would really like to give * some acustical support * (pling/plong); i am not sure * whether it is safe to call * sysbeep from within an intr * service, since it calls * timeout in turn which mani- * pulates the spl mask - jw */ # define PLING sysbeep(PCVT_SYSBEEPF / 1500, 2) # define PLONG sysbeep(PCVT_SYSBEEPF / 1200, 2) if(mousedef.stickybuttons) { if(dt & 0x80) { mouse.breakseen = 1; return (u_char *)0; } else if(mouse.buttons == button && !mouse.breakseen) { /* ignore repeats */ return (u_char *)0; } else mouse.breakseen = 0; if(mouse.buttons == button) { /* release it */ mouse.buttons = 0; PLONG; } else { /* * eventually, release * any other button, * and stick this one */ mouse.buttons = button; PLING; } } else { if(dt & 0x80) { mouse.buttons &= ~button; PLONG; } else if((mouse.buttons & button) == 0) { mouse.buttons |= button; PLING; } /*else: ignore same btn press*/ } move = MOUSE_0; accel = 0; } # undef PLING # undef PLONG else switch(dt & 0x7f) { /* the arrow keys - KP 1 thru KP 9 */ case 0x47: move = MOUSE_NW; goto do_move; case 0x48: move = MOUSE_N; goto do_move; case 0x49: move = MOUSE_NE; goto do_move; case 0x4b: move = MOUSE_W; goto do_move; case 0x4c: move = MOUSE_0; goto do_move; case 0x4d: move = MOUSE_E; goto do_move; case 0x4f: move = MOUSE_SW; goto do_move; case 0x50: move = MOUSE_S; goto do_move; case 0x51: move = MOUSE_SE; do_move: if(dt & 0x80) /* * arrow key break events are * of no importance for us */ return (u_char *)0; /* * see whether the last move did * happen "recently", i.e. before * less than half a second */ now = time; timevalsub(&now, &mouse.lastmove); mouse.lastmove = time; accel = (now.tv_sec == 0 && now.tv_usec < mousedef.acceltime); break; default: /* not a mouse-emulating key */ goto no_mouse_event; } mousestrings[accel][move][0] = 0x80 + (~mouse.buttons & 7); /* finally, send the string */ for(i = 0; i < 5; i++) (*linesw[mousetty->t_line].l_rint) (mousestrings[accel][move][i], mousetty); return (u_char *)0; /* not a kbd event */ } no_mouse_event: #endif /* PCVT_EMU_MOUSE */ return ((u_char *)keybuf); } } #else /* !XSERVER */ if(inb(CONTROLLER_CTRL) & STATUS_OUTPBF) dt = inb(CONTROLLER_DATA); /* yes, get it ! */ #endif /* !XSERVER */ else { if(noblock) return NULL; else goto loop; } #if PCVT_SHOWKEYS { int rki; for(rki = 3; rki < 80; rki++) /* shift left buffer */ rawkeybuf[rki-3] = rawkeybuf[rki]; rawkeybuf[77] = ' '; /* delimiter */ rki = (dt & 0xf0) >> 4; /* ms nibble */ if(rki <= 9) rki = rki + '0'; else rki = rki - 10 + 'A'; rawkeybuf[78] = rki; rki = dt & 0x0f; /* ls nibble */ if(rki <= 9) rki = rki + '0'; else rki = rki - 10 + 'A'; rawkeybuf[79] = rki; } #endif /* PCVT_SHOWKEYS */ /* lets look what we got */ switch(dt) { case KEYB_R_OVERRUN0: /* keyboard buffer overflow */ #if PCVT_SCANSET == 2 case KEYB_R_SELFOK: /* keyboard selftest ok */ #endif /* PCVT_SCANSET == 2 */ case KEYB_R_ECHO: /* keyboard response to KEYB_C_ECHO */ case KEYB_R_ACK: /* acknowledge after command has rx'd*/ case KEYB_R_SELFBAD: /* keyboard selftest FAILED */ case KEYB_R_DIAGBAD: /* keyboard self diagnostic failure */ case KEYB_R_RESEND: /* keyboard wants us to resend cmnd */ case KEYB_R_OVERRUN1: /* keyboard buffer overflow */ break; case KEYB_R_EXT1: /* keyboard extended scancode pfx 2 */ kbd_status.ext1 = 1; /* FALLTHROUGH */ case KEYB_R_EXT0: /* keyboard extended scancode pfx 1 */ kbd_status.extended = 1; break; #if PCVT_SCANSET == 2 case KEYB_R_BREAKPFX: /* break code prefix for set 2 and 3 */ kbd_status.breakseen = 1; break; #endif /* PCVT_SCANSET == 2 */ default: goto regular; /* regular key */ } if(noblock) return NULL; else goto loop; /* got a normal scan key */ regular: #if PCVT_SCANSET == 1 kbd_status.breakseen = dt & 0x80 ? 1 : 0; dt &= 0x7f; #endif /* PCVT_SCANSET == 1 */ /* make a keycode from scan code */ if(dt >= sizeof scantokey / sizeof(u_char)) key = 0; else key = kbd_status.extended ? extscantokey[dt] : scantokey[dt]; if(kbd_status.ext1 && key == 58) /* virtual control key */ key = 129; kbd_status.extended = kbd_status.ext1 = 0; #if PCVT_CTRL_ALT_DEL /* Check for cntl-alt-del */ if((key == 76) && ctrl_down && (meta_down||altgr_down)) cpu_reset(); #endif /* PCVT_CTRL_ALT_DEL */ #if !PCVT_NETBSD #include "ddb.h" #endif /* !PCVT_NETBSD */ #if NDDB > 0 || defined(DDB) /* Check for cntl-alt-esc */ if((key == 110) && ctrl_down && (meta_down || altgr_down)) { static u_char in_Debugger; if(!in_Debugger) { in_Debugger = 1; #if PCVT_FREEBSD /* the string is actually not used... */ Debugger("kbd"); #else Debugger(); #endif in_Debugger = 0; if(noblock) return NULL; else goto loop; } } #endif /* NDDB > 0 || defined(DDB) */ /* look for keys with special handling */ if(key == 128) { /* * virtual shift; sent around PrtScr, and around the arrow * keys if the NumLck LED is on */ kbd_status.vshift = !kbd_status.breakseen; key = 0; /* no key */ } else if(key == 129) { /* * virtual control - the most ugly thingie at all * the Pause key sends: * */ if(!kbd_status.breakseen) kbd_status.vcontrol = 1; /* else: let the numlock hook clear this */ key = 0; /* no key */ } else if(key == 90) { /* NumLock, look whether this is rather a Pause */ if(kbd_status.vcontrol) key = 126; /* * if this is the final break code of a Pause key, * clear the virtual control status, too */ if(kbd_status.vcontrol && kbd_status.breakseen) kbd_status.vcontrol = 0; } else if(key == 127) { /* * a SysRq; some keyboards are brain-dead enough to * repeat the SysRq key make code by sending PrtScr * make codes; other keyboards do not repeat SysRq * at all. We keep track of the SysRq state here. */ kbd_status.sysrq = !kbd_status.breakseen; } else if(key == 124) { /* * PrtScr; look whether this is really PrtScr or rather * a silly repeat of a SysRq key */ if(kbd_status.sysrq) /* ignore the garbage */ key = 0; } /* in NOREPEAT MODE ignore the key if it was the same as before */ if(!kbrepflag && key == kbd_lastkey && !kbd_status.breakseen) { if(noblock) return NULL; else goto loop; } type = key2ascii[key].type; if(type & KBD_OVERLOAD) type = ovltbl[key2ascii[key].ovlindex].type; type &= KBD_MASK; switch(type) { case KBD_SHFTLOCK: if(!kbd_status.breakseen && key != kbd_lastkey) { vsp->shift_lock ^= 1; } break; case KBD_CAPS: if(!kbd_status.breakseen && key != kbd_lastkey) { vsp->caps_lock ^= 1; update_led(); } break; case KBD_SCROLL: if(!kbd_status.breakseen && key != kbd_lastkey) { vsp->scroll_lock ^= 1; update_led(); if(!(vsp->scroll_lock)) { /* someone may be sleeping */ wakeup((caddr_t)&(vsp->scroll_lock)); } } break; case KBD_SHIFT: shift_down = kbd_status.breakseen ? 0 : 1; break; case KBD_META: meta_down = kbd_status.breakseen ? 0 : 0x80; break; case KBD_ALTGR: altgr_down = kbd_status.breakseen ? 0 : 1; break; case KBD_CTL: ctrl_down = kbd_status.breakseen ? 0 : 1; break; case KBD_NONE: default: break; /* deliver a key */ } if(kbd_status.breakseen) { key |= 0x80; kbd_status.breakseen = 0; kbd_lastkey = 0; /* -hv- I know this is a bug with */ } /* N-Key-Rollover, but I ignore that */ else /* because avoidance is too complicated */ kbd_lastkey = key; cp = xlatkey2ascii(key); /* have a key */ if(cp == NULL && !noblock) goto loop; return cp; } /*---------------------------------------------------------------------------* * reflect status of locking keys & set led's *---------------------------------------------------------------------------*/ static void setlockkeys(int snc) { vsp->scroll_lock = snc & 1; vsp->num_lock = (snc & 2) ? 1 : 0; vsp->caps_lock = (snc & 4) ? 1 : 0; update_led(); } /*---------------------------------------------------------------------------* * remove a key definition *---------------------------------------------------------------------------*/ static int rmkeydef(int key) { register Ovl_tbl *ref; if(key==0 || key > MAXKEYNUM) return EINVAL; if(key2ascii[key].type & KBD_OVERLOAD) { ref = &ovltbl[key2ascii[key].ovlindex]; ref->keynum = 0; ref->type = 0; ref->unshift[0] = ref->shift[0] = ref->ctrl[0] = ref->altgr[0] = 0; key2ascii[key].type &= KBD_MASK; } return 0; } /*---------------------------------------------------------------------------* * overlay a key *---------------------------------------------------------------------------*/ static int setkeydef(Ovl_tbl *data) { register i; if( data->keynum > MAXKEYNUM || (data->type & KBD_MASK) == KBD_BREAK || (data->type & KBD_MASK) > KBD_SHFTLOCK) return EINVAL; data->unshift[KBDMAXOVLKEYSIZE] = data->shift[KBDMAXOVLKEYSIZE] = data->ctrl[KBDMAXOVLKEYSIZE] = data->altgr[KBDMAXOVLKEYSIZE] = 0; data->subu = data->subs = data->subc = data->suba = KBD_SUBT_STR; /* just strings .. */ data->type |= KBD_OVERLOAD; /* mark overloaded */ /* if key already overloaded, use that slot else find free slot */ if(key2ascii[data->keynum].type & KBD_OVERLOAD) { i = key2ascii[data->keynum].ovlindex; } else { for(i=0; ikeynum].type |= KBD_OVERLOAD; /* mark key */ key2ascii[data->keynum].ovlindex = i; return 0; } /*---------------------------------------------------------------------------* * keyboard ioctl's entry *---------------------------------------------------------------------------*/ int kbdioctl(Dev_t dev, int cmd, caddr_t data, int flag) { int key; switch(cmd) { case KBDRESET: doreset(); ovlinit(1); settpmrate(KBD_TPD500|KBD_TPM100); setlockkeys(0); break; case KBDGTPMAT: *(int *)data = tpmrate; break; case KBDSTPMAT: settpmrate(*(int *)data); break; case KBDGREPSW: *(int *)data = kbrepflag; break; case KBDSREPSW: kbrepflag = (*(int *)data) & 1; break; case KBDGLEDS: *(int *)data = ledstate; break; case KBDSLEDS: update_led(); /* ??? */ break; case KBDGLOCK: *(int *)data = ( (vsp->scroll_lock) | (vsp->num_lock * 2) | (vsp->caps_lock * 4)); break; case KBDSLOCK: setlockkeys(*(int *)data); break; case KBDGCKEY: key = ((Ovl_tbl *)data)->keynum; return getckeydef(key,(Ovl_tbl *)data); case KBDSCKEY: key = ((Ovl_tbl *)data)->keynum; return setkeydef((Ovl_tbl *)data); case KBDGOKEY: key = ((Ovl_tbl *)data)->keynum; return getokeydef(key,(Ovl_tbl *)data); case KBDRMKEY: key = *(int *)data; return rmkeydef(key); case KBDDEFAULT: ovlinit(1); break; default: /* proceed with vga ioctls */ return -1; } return 0; } #if PCVT_EMU_MOUSE /*--------------------------------------------------------------------------* * mouse emulator ioctl *--------------------------------------------------------------------------*/ int mouse_ioctl(Dev_t dev, int cmd, caddr_t data) { struct mousedefs *def = (struct mousedefs *)data; switch(cmd) { case KBDMOUSEGET: *def = mousedef; break; case KBDMOUSESET: mousedef = *def; break; default: return -1; } return 0; } #endif /* PCVT_EMU_MOUSE */ #if PCVT_USL_VT_COMPAT /*---------------------------------------------------------------------------* * convert ISO-8859 style keycode into IBM 437 *---------------------------------------------------------------------------*/ static inline u_char iso2ibm(u_char c) { if(c < 0x80) return c; return iso2ibm437[c - 0x80]; } /*---------------------------------------------------------------------------* * build up a USL style keyboard map *---------------------------------------------------------------------------*/ void get_usl_keymap(keymap_t *map) { int i; bzero((caddr_t)map, sizeof(keymap_t)); map->n_keys = 0x59; /* that many keys we know about */ for(i = 1; i < N_KEYNUMS; i++) { Ovl_tbl kdef; u_char c; int j; int idx = key2scan1[i]; if(idx == 0 || idx >= map->n_keys) continue; getckeydef(i, &kdef); kdef.type &= KBD_MASK; switch(kdef.type) { case KBD_ASCII: case KBD_RETURN: map->key[idx].map[0] = iso2ibm(kdef.unshift[0]); map->key[idx].map[1] = iso2ibm(kdef.shift[0]); map->key[idx].map[2] = map->key[idx].map[3] = iso2ibm(kdef.ctrl[0]); map->key[idx].map[4] = map->key[idx].map[5] = iso2ibm(c = kdef.altgr[0]); /* * XXX this is a hack * since we currently do not map strings to AltGr + * shift, we attempt to use the unshifted AltGr * definition here and try to toggle the case * this should at least work for ISO8859 letters, * but also for (e.g.) russian KOI-8 style */ if((c & 0x7f) >= 0x40) map->key[idx].map[5] = iso2ibm(c ^ 0x20); break; case KBD_FUNC: /* we are only interested in F1 thru F12 here */ if(i >= 112 && i <= 123) { map->key[idx].map[0] = i - 112 + 27; map->key[idx].spcl = 0x80; } break; case KBD_SHIFT: c = i == 44? 2 /* lSh */: 3 /* rSh */; goto special; case KBD_CAPS: c = 4; goto special; case KBD_NUM: c = 5; goto special; case KBD_SCROLL: c = 6; goto special; case KBD_META: c = 7; goto special; case KBD_CTL: c = 9; goto special; special: for(j = 0; j < NUM_STATES; j++) map->key[idx].map[j] = c; map->key[idx].spcl = 0xff; break; default: break; } } } #endif /* PCVT_USL_VT_COMPAT */ /*---------------------------------------------------------------------------* * switch keypad to numeric mode *---------------------------------------------------------------------------*/ void vt_keynum(struct video_state *svsp) { svsp->num_lock = 1; update_led(); } /*---------------------------------------------------------------------------* * switch keypad to application mode *---------------------------------------------------------------------------*/ void vt_keyappl(struct video_state *svsp) { svsp->num_lock = 0; update_led(); } #if PCVT_VT220KEYB /*---------------------------------------------------------------------------* * function bound to function key 1 *---------------------------------------------------------------------------*/ static void fkey1(void) { if(meta_down) more_chars = (u_char *)"\033[23~"; /* F11 */ else do_vgapage(0); } /*---------------------------------------------------------------------------* * function bound to function key 2 *---------------------------------------------------------------------------*/ static void fkey2(void) { if(meta_down) more_chars = (u_char *)"\033[24~"; /* F12 */ else do_vgapage(1); } /*---------------------------------------------------------------------------* * function bound to function key 3 *---------------------------------------------------------------------------*/ static void fkey3(void) { if(meta_down) more_chars = (u_char *)"\033[25~"; /* F13 */ else do_vgapage(2); } /*---------------------------------------------------------------------------* * function bound to function key 4 *---------------------------------------------------------------------------*/ static void fkey4(void) { if(meta_down) more_chars = (u_char *)"\033[26~"; /* F14 */ else do_vgapage(3); } /*---------------------------------------------------------------------------* * function bound to function key 5 *---------------------------------------------------------------------------*/ static void fkey5(void) { if(meta_down) more_chars = (u_char *)"\033[28~"; /* Help */ else { if((current_video_screen + 1) > totalscreens-1) do_vgapage(0); else do_vgapage(current_video_screen + 1); } } /*---------------------------------------------------------------------------* * function bound to function key 6 *---------------------------------------------------------------------------*/ static void fkey6(void) { if(meta_down) more_chars = (u_char *)"\033[29~"; /* DO */ else more_chars = (u_char *)"\033[17~"; /* F6 */ } /*---------------------------------------------------------------------------* * function bound to function key 7 *---------------------------------------------------------------------------*/ static void fkey7(void) { if(meta_down) more_chars = (u_char *)"\033[31~"; /* F17 */ else more_chars = (u_char *)"\033[18~"; /* F7 */ } /*---------------------------------------------------------------------------* * function bound to function key 8 *---------------------------------------------------------------------------*/ static void fkey8(void) { if(meta_down) more_chars = (u_char *)"\033[32~"; /* F18 */ else more_chars = (u_char *)"\033[19~"; /* F8 */ } /*---------------------------------------------------------------------------* * function bound to function key 9 *---------------------------------------------------------------------------*/ static void fkey9(void) { if(meta_down) more_chars = (u_char *)"\033[33~"; /* F19 */ else more_chars = (u_char *)"\033[20~"; /* F9 */ } /*---------------------------------------------------------------------------* * function bound to function key 10 *---------------------------------------------------------------------------*/ static void fkey10(void) { if(meta_down) more_chars = (u_char *)"\033[34~"; /* F20 */ else more_chars = (u_char *)"\033[21~"; /* F10 */ } /*---------------------------------------------------------------------------* * function bound to function key 11 *---------------------------------------------------------------------------*/ static void fkey11(void) { if(meta_down) more_chars = (u_char *)"\0x8FP"; /* PF1 */ else more_chars = (u_char *)"\033[23~"; /* F11 */ } /*---------------------------------------------------------------------------* * function bound to function key 12 *---------------------------------------------------------------------------*/ static void fkey12(void) { if(meta_down) more_chars = (u_char *)"\0x8FQ"; /* PF2 */ else more_chars = (u_char *)"\033[24~"; /* F12 */ } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 1 *---------------------------------------------------------------------------*/ static void sfkey1(void) { if(meta_down) { if(vsp->ukt.length[6]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[6]]); else more_chars = (u_char *)"\033[23~"; /* F11 */ } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 2 *---------------------------------------------------------------------------*/ static void sfkey2(void) { if(meta_down) { if(vsp->ukt.length[7]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[7]]); else more_chars = (u_char *)"\033[24~"; /* F12 */ } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 3 *---------------------------------------------------------------------------*/ static void sfkey3(void) { if(meta_down) { if(vsp->ukt.length[8]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[8]]); else more_chars = (u_char *)"\033[25~"; /* F13 */ } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 4 *---------------------------------------------------------------------------*/ static void sfkey4(void) { if(meta_down) { if(vsp->ukt.length[9]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[9]]); else more_chars = (u_char *)"\033[26~"; /* F14 */ } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 5 *---------------------------------------------------------------------------*/ static void sfkey5(void) { if(meta_down) { if(vsp->ukt.length[11]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[11]]); else more_chars = (u_char *)"\033[28~"; /* Help */ } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 6 *---------------------------------------------------------------------------*/ static void sfkey6(void) { if(!meta_down) { if(vsp->ukt.length[0]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[0]]); else more_chars = (u_char *)"\033[17~"; /* F6 */ } else if(vsp->ukt.length[12]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[12]]); else more_chars = (u_char *)"\033[29~"; /* DO */ } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 7 *---------------------------------------------------------------------------*/ static void sfkey7(void) { if(!meta_down) { if(vsp->ukt.length[1]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[1]]); else more_chars = (u_char *)"\033[18~"; /* F7 */ } else if(vsp->ukt.length[14]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[14]]); else more_chars = (u_char *)"\033[31~"; /* F17 */ } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 8 *---------------------------------------------------------------------------*/ static void sfkey8(void) { if(!meta_down) { if(vsp->ukt.length[2]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[2]]); else more_chars = (u_char *)"\033[19~"; /* F8 */ } else if(vsp->ukt.length[14]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[15]]); else more_chars = (u_char *)"\033[32~"; /* F18 */ } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 9 *---------------------------------------------------------------------------*/ static void sfkey9(void) { if(!meta_down) { if(vsp->ukt.length[3]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[3]]); else more_chars = (u_char *)"\033[20~"; /* F9 */ } else if(vsp->ukt.length[16]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[16]]); else more_chars = (u_char *)"\033[33~"; /* F19 */ } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 10 *---------------------------------------------------------------------------*/ static void sfkey10(void) { if(!meta_down) { if(vsp->ukt.length[4]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[4]]); else more_chars = (u_char *)"\033[21~"; /* F10 */ } else if(vsp->ukt.length[17]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[17]]); else more_chars = (u_char *)"\033[34~"; /* F20 */ } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 11 *---------------------------------------------------------------------------*/ static void sfkey11(void) { if(!meta_down) { if(vsp->ukt.length[6]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[6]]); else more_chars = (u_char *)"\033[23~"; /* F11 */ } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 12 *---------------------------------------------------------------------------*/ static void sfkey12(void) { if(!meta_down) { if(vsp->ukt.length[7]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[7]]); else more_chars = (u_char *)"\033[24~"; /* F12 */ } } /*---------------------------------------------------------------------------* * function bound to control function key 1 *---------------------------------------------------------------------------*/ static void cfkey1(void) { } /*---------------------------------------------------------------------------* * function bound to control function key 2 *---------------------------------------------------------------------------*/ static void cfkey2(void) { } /*---------------------------------------------------------------------------* * function bound to control function key 3 *---------------------------------------------------------------------------*/ static void cfkey3(void) { } /*---------------------------------------------------------------------------* * function bound to control function key 4 *---------------------------------------------------------------------------*/ static void cfkey4(void) { } /*---------------------------------------------------------------------------* * function bound to control function key 5 *---------------------------------------------------------------------------*/ static void cfkey5(void) { if(vsp->which_fkl == SYS_FKL) toggl_bell(vsp); } /*---------------------------------------------------------------------------* * function bound to control function key 6 *---------------------------------------------------------------------------*/ static void cfkey6(void) { if(vsp->which_fkl == SYS_FKL) toggl_sevenbit(vsp); } /*---------------------------------------------------------------------------* * function bound to control function key 7 *---------------------------------------------------------------------------*/ static void cfkey7(void) { if(vsp->which_fkl == SYS_FKL) toggl_dspf(vsp); } /*---------------------------------------------------------------------------* * function bound to control function key 8 *---------------------------------------------------------------------------*/ static void cfkey8(void) { if(vsp->which_fkl == SYS_FKL) toggl_awm(vsp); } /*---------------------------------------------------------------------------* * function bound to control function key 9 *---------------------------------------------------------------------------*/ static void cfkey9(void) { if(vsp->labels_on) /* toggle label display on/off */ fkl_off(vsp); else fkl_on(vsp); } /*---------------------------------------------------------------------------* * function bound to control function key 10 *---------------------------------------------------------------------------*/ static void cfkey10(void) { if(vsp->labels_on) /* toggle user/system fkey labels */ { if(vsp->which_fkl == USR_FKL) sw_sfkl(vsp); else if(vsp->which_fkl == SYS_FKL) sw_ufkl(vsp); } } /*---------------------------------------------------------------------------* * function bound to control function key 11 *---------------------------------------------------------------------------*/ static void cfkey11(void) { if(vsp->vt_pure_mode == M_PUREVT) set_emulation_mode(vsp, M_HPVT); else if(vsp->vt_pure_mode == M_HPVT) set_emulation_mode(vsp, M_PUREVT); } /*---------------------------------------------------------------------------* * function bound to control function key 12 *---------------------------------------------------------------------------*/ static void cfkey12(void) { } #else /* !PCVT_VT220KEYB, HP-like Keyboard layout */ /*---------------------------------------------------------------------------* * function bound to function key 1 *---------------------------------------------------------------------------*/ static void fkey1(void) { if(!meta_down) { if((vsp->vt_pure_mode == M_HPVT) && (vsp->which_fkl == SYS_FKL)) toggl_columns(vsp); else more_chars = (u_char *)"\033[17~"; /* F6 */ } else { if(vsp->vt_pure_mode == M_PUREVT || (vsp->which_fkl == USR_FKL)) more_chars = (u_char *)"\033[26~"; /* F14 */ } } /*---------------------------------------------------------------------------* * function bound to function key 2 *---------------------------------------------------------------------------*/ static void fkey2(void) { if(!meta_down) { if((vsp->vt_pure_mode == M_HPVT) && (vsp->which_fkl == SYS_FKL)) vt_ris(vsp); else more_chars = (u_char *)"\033[18~"; /* F7 */ } else { if(vsp->vt_pure_mode == M_PUREVT || (vsp->which_fkl == USR_FKL)) more_chars = (u_char *)"\033[28~"; /* HELP */ } } /*---------------------------------------------------------------------------* * function bound to function key 3 *---------------------------------------------------------------------------*/ static void fkey3(void) { if(!meta_down) { if((vsp->vt_pure_mode == M_HPVT) && (vsp->which_fkl == SYS_FKL)) toggl_24l(vsp); else more_chars = (u_char *)"\033[19~"; /* F8 */ } else { if(vsp->vt_pure_mode == M_PUREVT || (vsp->which_fkl == USR_FKL)) more_chars = (u_char *)"\033[29~"; /* DO */ } } /*---------------------------------------------------------------------------* * function bound to function key 4 *---------------------------------------------------------------------------*/ static void fkey4(void) { if(!meta_down) { #if PCVT_SHOWKEYS if((vsp->vt_pure_mode == M_HPVT) && (vsp->which_fkl == SYS_FKL)) toggl_kbddbg(vsp); else more_chars = (u_char *)"\033[20~"; /* F9 */ #else if(vsp->vt_pure_mode == M_PUREVT || (vsp->which_fkl == USR_FKL)) more_chars = (u_char *)"\033[20~"; /* F9 */ #endif /* PCVT_SHOWKEYS */ } else { if(vsp->vt_pure_mode == M_PUREVT || (vsp->which_fkl == USR_FKL)) more_chars = (u_char *)"\033[31~"; /* F17 */ } } /*---------------------------------------------------------------------------* * function bound to function key 5 *---------------------------------------------------------------------------*/ static void fkey5(void) { if(!meta_down) { if((vsp->vt_pure_mode == M_HPVT) && (vsp->which_fkl == SYS_FKL)) toggl_bell(vsp); else more_chars = (u_char *)"\033[21~"; /* F10 */ } else { if(vsp->vt_pure_mode == M_PUREVT || (vsp->which_fkl == USR_FKL)) more_chars = (u_char *)"\033[32~"; /* F18 */ } } /*---------------------------------------------------------------------------* * function bound to function key 6 *---------------------------------------------------------------------------*/ static void fkey6(void) { if(!meta_down) { if((vsp->vt_pure_mode == M_HPVT) && (vsp->which_fkl == SYS_FKL)) toggl_sevenbit(vsp); else more_chars = (u_char *)"\033[23~"; /* F11 */ } else { if(vsp->vt_pure_mode == M_PUREVT || (vsp->which_fkl == USR_FKL)) more_chars = (u_char *)"\033[33~"; /* F19 */ } } /*---------------------------------------------------------------------------* * function bound to function key 7 *---------------------------------------------------------------------------*/ static void fkey7(void) { if(!meta_down) { if((vsp->vt_pure_mode == M_HPVT) && (vsp->which_fkl == SYS_FKL)) toggl_dspf(vsp); else more_chars = (u_char *)"\033[24~"; /* F12 */ } else { if(vsp->vt_pure_mode == M_PUREVT || (vsp->which_fkl == USR_FKL)) more_chars = (u_char *)"\033[34~"; /* F20 */ } } /*---------------------------------------------------------------------------* * function bound to function key 8 *---------------------------------------------------------------------------*/ static void fkey8(void) { if(!meta_down) { if((vsp->vt_pure_mode == M_HPVT) && (vsp->which_fkl == SYS_FKL)) toggl_awm(vsp); else more_chars = (u_char *)"\033[25~"; /* F13 */ } else { if(vsp->vt_pure_mode == M_PUREVT || (vsp->which_fkl == USR_FKL)) more_chars = (u_char *)"\033[35~"; /* F21 ??!! */ } } /*---------------------------------------------------------------------------* * function bound to function key 9 *---------------------------------------------------------------------------*/ static void fkey9(void) { if(meta_down) { if(vsp->vt_pure_mode == M_PUREVT) return; if(vsp->labels_on) /* toggle label display on/off */ fkl_off(vsp); else fkl_on(vsp); } else { do_vgapage(0); } } /*---------------------------------------------------------------------------* * function bound to function key 10 *---------------------------------------------------------------------------*/ static void fkey10(void) { if(meta_down) { if(vsp->vt_pure_mode != M_PUREVT && vsp->labels_on) { if(vsp->which_fkl == USR_FKL) sw_sfkl(vsp); else if(vsp->which_fkl == SYS_FKL) sw_ufkl(vsp); } } else { do_vgapage(1); } } /*---------------------------------------------------------------------------* * function bound to function key 11 *---------------------------------------------------------------------------*/ static void fkey11(void) { if(meta_down) { if(vsp->vt_pure_mode == M_PUREVT) set_emulation_mode(vsp, M_HPVT); else if(vsp->vt_pure_mode == M_HPVT) set_emulation_mode(vsp, M_PUREVT); } else { do_vgapage(2); } } /*---------------------------------------------------------------------------* * function bound to function key 12 *---------------------------------------------------------------------------*/ static void fkey12(void) { if(meta_down) { if(current_video_screen + 1 > totalscreens-1) do_vgapage(0); else do_vgapage(current_video_screen + 1); } else { do_vgapage(3); } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 1 *---------------------------------------------------------------------------*/ static void sfkey1(void) { if(!meta_down) { if(vsp->ukt.length[0]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[0]]); } else { if(vsp->ukt.length[9]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[9]]); } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 2 *---------------------------------------------------------------------------*/ static void sfkey2(void) { if(!meta_down) { if(vsp->ukt.length[1]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[1]]); } else { if(vsp->ukt.length[11]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[11]]); } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 3 *---------------------------------------------------------------------------*/ static void sfkey3(void) { if(!meta_down) { if(vsp->ukt.length[2]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[2]]); } else { if(vsp->ukt.length[12]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[12]]); } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 4 *---------------------------------------------------------------------------*/ static void sfkey4(void) { if(!meta_down) { if(vsp->ukt.length[3]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[3]]); } else { if(vsp->ukt.length[13]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[13]]); } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 5 *---------------------------------------------------------------------------*/ static void sfkey5(void) { if(!meta_down) { if(vsp->ukt.length[4]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[4]]); } else { if(vsp->ukt.length[14]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[14]]); } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 6 *---------------------------------------------------------------------------*/ static void sfkey6(void) { if(!meta_down) { if(vsp->ukt.length[6]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[6]]); } else { if(vsp->ukt.length[15]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[15]]); } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 7 *---------------------------------------------------------------------------*/ static void sfkey7(void) { if(!meta_down) { if(vsp->ukt.length[7]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[7]]); } else { if(vsp->ukt.length[16]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[16]]); } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 8 *---------------------------------------------------------------------------*/ static void sfkey8(void) { if(!meta_down) { if(vsp->ukt.length[8]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[8]]); } else { if(vsp->ukt.length[17]) /* entry available ? */ more_chars = (u_char *) &(vsp->udkbuf[vsp->ukt.first[17]]); } } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 9 *---------------------------------------------------------------------------*/ static void sfkey9(void) { } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 10 *---------------------------------------------------------------------------*/ static void sfkey10(void) { } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 11 *---------------------------------------------------------------------------*/ static void sfkey11(void) { } /*---------------------------------------------------------------------------* * function bound to SHIFTED function key 12 *---------------------------------------------------------------------------*/ static void sfkey12(void) { } /*---------------------------------------------------------------------------* * function bound to control function key 1 *---------------------------------------------------------------------------*/ static void cfkey1(void) { if(meta_down) do_vgapage(0); } /*---------------------------------------------------------------------------* * function bound to control function key 2 *---------------------------------------------------------------------------*/ static void cfkey2(void) { if(meta_down) do_vgapage(1); } /*---------------------------------------------------------------------------* * function bound to control function key 3 *---------------------------------------------------------------------------*/ static void cfkey3(void) { if(meta_down) do_vgapage(2); } /*---------------------------------------------------------------------------* * function bound to control function key 4 *---------------------------------------------------------------------------*/ static void cfkey4(void) { if(meta_down) do_vgapage(3); } /*---------------------------------------------------------------------------* * function bound to control function key 5 *---------------------------------------------------------------------------*/ static void cfkey5(void) { if(meta_down) do_vgapage(4); } /*---------------------------------------------------------------------------* * function bound to control function key 6 *---------------------------------------------------------------------------*/ static void cfkey6(void) { if(meta_down) do_vgapage(5); } /*---------------------------------------------------------------------------* * function bound to control function key 7 *---------------------------------------------------------------------------*/ static void cfkey7(void) { if(meta_down) do_vgapage(6); } /*---------------------------------------------------------------------------* * function bound to control function key 8 *---------------------------------------------------------------------------*/ static void cfkey8(void) { if(meta_down) do_vgapage(7); } /*---------------------------------------------------------------------------* * function bound to control function key 9 *---------------------------------------------------------------------------*/ static void cfkey9(void) { if(meta_down) do_vgapage(8); } /*---------------------------------------------------------------------------* * function bound to control function key 10 *---------------------------------------------------------------------------*/ static void cfkey10(void) { if(meta_down) do_vgapage(9); } /*---------------------------------------------------------------------------* * function bound to control function key 11 *---------------------------------------------------------------------------*/ static void cfkey11(void) { if(meta_down) do_vgapage(10); } /*---------------------------------------------------------------------------* * function bound to control function key 12 *---------------------------------------------------------------------------*/ static void cfkey12(void) { if(meta_down) do_vgapage(11); } #endif /* PCVT_VT220KEYB */ #endif /* NVT > 0 */ /* ------------------------------- EOF -------------------------------------*/