NAME

keyboard − video adapter keyboard

DESCRIPTION

The video adapter display (and user’s terminal) is composed of two separate pieces: the keyboard and the display (see display(7)).

The keyboard is used to type data and to send certain control signals to the computer.  UNIX system software performs terminal emulation on the console screen and keyboard, and, in doing so, makes use of several particular keys and key combinations.  These keys and key combinations have special names that are unique to the UNIX system and may or may not correspond to the keytop labels on your keyboard. 

When you press a key, one of the following happens:

− An ASCII value is entered.  − The meaning of another key, or keys, is changed. − A string is sent to the computer. − A function is initiated.

When a key is pressed (a keystroke), the keyboard sends a scancode to the computer.  This scancode is interpreted by the keyboard driver.  The actual code sequence delivered to the terminal input routine (see termio(7)) is defined by a set of internal tables in the driver. These tables can be modified by software (see the discussion of ioctl calls below).  In addition, the driver can be instructed not to do translations, delivering the keyboard up/down scan codes directly. 

Changing Meanings

The action performed by a key can be changed by using certain keys in combination.  For example, SHIFT changes the ASCII values of the alphanumeric keys.  Holding down CTRL while pressing another key sends a control code (such as CTRL d, CTRL s, and CTRL q).  Holding down ALT also modifies a key’s value.  SHIFT, CTRL, and ALT can be used in combination. 

Switching Screens

To switch the current screen, hold down ALT SYSREQ (also labelled ALT PRINTSCRN on some systems) and a key that identifies the desired screen.  Any active screen may be selected by following ALT SYSREQ with Fn, where Fn is one of the function keys.  F1 refers to the first virtual terminal screen, F2 refers to the second virtual terminal screen, etc.  ALT SYSREQ h and ALT SYSREQ F8 refer to the main console display (/dev/console), if the console refers to a video adapter.  The next active screen can be selected with ALT SYSREQ n, and the previous screen can be selected with ALT SYSREQ p. 

The default screen switch enable sequence ( ALT SYSREQ ) is configurable.  The SYSREQ table entry can be modified by software (see discussion of ioctl calls below). 

Special Keys

The following table shows which keys on a typical console correspond to UNIX System keys.  In this table, a hyphen (−) between keys means you must hold down the first key while pressing the second.  The mapping between characters that generate signals and the signal actually generated is set with stty(1) and may be changed (see stty(1)). 

Keyboard Map

The keyboard mapping structure is defined in /usr/include/sys/kd.h.  Each key can have ten states.  The first eight states are:

 BASE
 SHIFT
 CTRL
 ALT
 CTRL-SHIFT
 ALT-SHIFT
 ALT-CTRL
 ALT-CTRL-SHIFT

The two remaining states are indicated by two special bytes.  The first byte is a “special state” byte whose bits indicate whether the key is “special” in one or more of the first eight states.  The second byte is one of four codes represented by the characters C, N, B, or O which indicate how the lock keys affect the particular key. 

The following table describes the default keyboard mapping.  All values, except for special keywords (which are described later), are ASCII character values. 

Heading Description

SCAN CODE This column contains the index to the table.  Numbers 1 through 83 and 86 through 88 are actual scan codes generated by the keyboard hardware when a key is pressed.  The numbers that do not have an entry in the KEY LOCATION column are not used.  The remaining numbers are used for keys that generate a sequence of more than one code.  There are no table entries for the scan code generated by releasing a key. 

KEY LOCATION This column contains the location number for the key on the 101-key keyboard map that precedes the table.  Key location 45 (scan code 86) is for the international 102-key keyboard and is not shown (it is located between keys 44 and 46). 

BASE This column contains the normal value of a key press. 

SHIFT This column contains the value of a key press when the SHIFT key is also being held down. 

LOCK This column indicates which lock keys affect that particular key:

− C indicates CAPS-LOCK
− N indicates NUM-LOCK
− B indicates both
− O indicates locking is off

The remaining columns are the values of key presses when combinations of CTRL, ALT, and SHIFT are also held down. 

The SRQTAB column entry is included in this table to provide a simple index of the default virtual terminal key selectors to the scan code to which it is assigned.  The actual SRQTAB table is a stand-alone table which can be read or written via the KDGKBENT and KDSKBENT ioctl calls. 

*Applicable only for 102-key keyboard. 

The following table lists the value of each of the special keywords used in the preceding tables.  The keywords are only used in the preceding tables for readability.  In the actual keyboard map, a special keyword is represented by its value with the corresponding “special state” bit being set. 

The following table lists names and decimal values for ASCII characters in the preceding table.  Names are used in place of numeric constants to make it easier to read the scan code table.  Only the decimal values are placed in the ioctl buffer.  These values are taken from ascii(5). 

String Key Mapping

The string mapping table is an array of 512 bytes (typedef strmap_t) containing null-terminated strings that redefine the function keys.  The first null-terminated string is assigned to the first function key, the second string is assigned to the second function key, etc. 

There is no limit to the length of any particular string as long as the whole table does not exceed 512 bytes, including nulls.  To make a string a null, add extra null characters.  The following table contains default function key values. 

Ioctl Calls

KDGKBMODE
This call gets the current keyboard mode. The argument to the call is the address of an unsigned character. The ioctl sets the unsigned char to one of the following values, as defined in /usr/include/sys/kd.h:

#defineK_RAW0x00/* Send raw scan codes */
#defineK_XLATE0x01/* Translate to ASCII */

KDSKBMODE
This call sets the keyboard mode. The argument to the call is either K_RAW or K_XLATE.  By using raw mode, the program can see the raw up/down scan codes from the keyboard.  In translate mode, the translation tables are used to generate the appropriate character code. 

KDGKBTYPE
This call gets the keyboard type. The argument to the call is the address of an unsigned character. The ioctl sets the unsigned char to one of the following values, as defined in /usr/include/sys/kd.h:

#defineKB_840x00/*84 key keyboard*/
#defineKB_1010x01/*101 key keyboard*/
#defineKB_OTHER0x03 /*Other type keyboard*/

KDGKBENT
This call reads one of the entries in the translation tables. The argument to the call is the address of one of the following structures, defined in /usr/include/sys/kd.h, with the first two fields filled in:

struct kbentry {
uncharkb_table;/* Table to use */
uncharkb_index;/* Entry in table */
ushortkb_value;/* Value to get/set */
};

Valid values for the kb_table field are:

#defineK_NORMTAB 0x00 /* Base */
#defineK_SHIFTTAB 0x01 /* Shifted */
#defineK_ALTTAB 0x02 /* Alt */
#defineK_ALTSHIFTTAB 0x03 /* Shifted alt */
#defineK_SRQTAB 0x04 /* Sysreq table */

The ioctl will get the indicated entry from the indicated table and return it in the kb_value field. 

The kb_value field is 16 bits, with flags in the high-order 8 bits and the character code in the low-order 8 bits.  The values that can be set in the flag byte, as defined in /usr/include/sys/kd.h, are as ­follows:

/∗ Flag bits ∗/
#defineNUMLCK0x8000/∗ key is affected by num lock ∗/
#defineCAPLCK0x4000/∗ key is affected by caps lock ∗/
#defineCTLKEY0x2000/∗ key is affected by control key ∗/
/∗ Key types ∗/
#defineNORMKEY0x0000/∗ key is a normal key ∗/
#defineSHIFTKEY0x0100/∗ key is a shift key ∗/
#defineBREAKKEY0x0200/∗ key is a break key ∗/
#defineSS2PFX0x0300/∗ prefix key with <ESC> N ∗/
#defineSS3PFX0x0400/∗ prefix key with <ESC> O ∗/
#defineCSIPFX0x0500/∗ prefix key with <ESC> [ ∗/
#defineNOKEY0x0f00/∗ key sends nothing ∗/

KDSKBENT
This call sets an entry in one of the translation tables. It uses the same structure as the KDGKBENT ioctl, but with the third field filled in with the value that should be placed in the translation table. This can be used to partially or completely remap the ­keyboard.

The kd driver provides support for virtual terminals.  Two ioctls are provided for virtual terminal support:

VT_GETSTATE
The VT_GETSTATE ioctl returns global virtual terminal state information.  It returns the active virtual terminal in the v_active field, and the number of active virtual terminals and a bit mask of the global state in the vt_state field, where “bit x” is the state of “vt x” (1 indicates that the virtual terminal is open). 

VT_SENDSIG
The VT_SENDSIG ioctl specifies a signal (in vt_signal) to be sent to a bit mask of virtual terminals (in vt_state). 

The data structure used by the VT_GETSTATE and VT_SENDSIG ioctls is:

struct vt_stat {
ushort v_active; /* active vt */
ushort v_signal; /* signal to send (VT_SENDSIG) */
ushort v_state; /* vt bit mask (VT_SENDSIG and VT_GETSTATE) */
};

and is defined in /usr/include/sys/vt.h. 

VT_OPENQRY
The VT_OPENQRY ioctl is used to get the next available virtual terminal.  This value is set in the last argument of the ioctl(2) call.

GIO_KEYMAP
This call gets the entire keyboard mapping table from the kernel. The structure of the argument is given in /usr/include/sys/kd.h. 

PIO_KEYMAP
This call sets the entire keyboard mapping table. The structure of the argument is given in /usr/include/sys/kd.h. 

GIO_STRMAP
This call gets the string key mapping table from the kernel. The structure of the argument is given in /usr/include/sys/kd.h. 

PIO_STRMAP
This call sets the string key mapping table. The structure of the argument is given in /usr/include/sys/kd.h. 

TIOCKBOF
Extended character codes are disabled. This is the default mode.

TIOCKBON
Allows extended characters to be transmitted to the user program. The extended characters are transmitted as a null byte followed by a second byte containing the character’s extended code. When a true null byte is sent, it is transmitted as two consecutive null bytes.

KDSETRAD
This call allows the application to set the keyboard typematic rate and delay. The default value is 0x20, which sets the keyboard at 30 characters per second with a ½-second start-up delay. For other allowable values, refer to the IBM Technical Reference Manual.

When the keyboard is fully enabled, an 8-bit character code can be obtained by holding down the ALT key and entering the 3-digit decimal value of the character from the numeric keypad.  The character is transmitted when the ALT key is released. 

Some keyboard characters have special meaning.  Under default operations, pressing the DELETE key generates an interrupt signal which is sent to all processes designated with the associated control terminal.  When the keyboard is fully enabled, holding down the ALT key and pressing the 8 key on the home keyboard (not on the numeric keypad) returns a null byte followed by 0x7F.  This will produce the same effect as the DELETE key (0x7F) unless you have executed the stty(1) command with the −isig option. 

KBENABLED
If the keyboard is fully enabled (TIOCKBON), a nonzero value will be returned.  If the keyboard is not fully enabled (TIOCKBOF), a value of zero will be returned. 

GETFKEY
Obtains the current definition of a function key. The argument to the call is the address of one of the following structures defined in /usr/include/sys/kd.h:

struct fkeyarg {
unsigned intkeynum;
charkeydef [MAXFK]; /*Comes from ioctl.h via comcrt.h*/
charflen;
};

The function key number must be passed in keynum (see arg structure above).  The string currently assigned to the key will be returned in keydef, and the length of the string will be returned in flen when the ioctl is performed. 

SETFKEY
Assigns a given string to a function key. It uses the same structure as the GETFKEY ioctl. The function key number must be passed in keynum, the string must be passed in keydef, and the length of the string (number of characters) must be passed in flen. 

FILES

/dev/console
/dev/vt00-n
/usr/include/sys/kd.h

SEE ALSO

stty(1), ioctl(2), ascii(5), console(7), display(7), termio(7). 

ADDED VALUE

This entry, supplied by SunSoft, Inc., contains enhancements to UNIX ­System V. 

\*U  —  Version 1.0