10.1.1 Keyboard Interface Hardware

The keyboard unit contains an Intel 8048 microcontroller that is programmed to scan the keyboard for key presses and releases (each counts as an individual keystroke), debounce the keystrokes, implement the "typematic" (hold-to-repeat) feature, maintain a 16-keystroke buffer, and transmit each keystroke serially to the PC's system unit. There are two bidirectional data lines in the cable connecting the keyboard unit to the system unit: KBD DATA carries either the serial keystroke data from the keyboard or a "clear-and-reenable" handshaking signal from the system unit; KBD CLK carries either the baud rate clock from the keyboard unit or a "clock disable" control signal from the system unit. (Note that when the keyboard clock is disabled, the keyboard does not even respond to CTRL-ALT-DEL.

Keystroke data are transmitted serially at 10,000 baud over the KBD DATA line together with the baud rate clock on the KBD CLK line. Each character transmitted consists of 2 start bits and 8 data bits; there are no stop bits. The line is 0 (low) when idle, the start bits are 1 (high). The data bits are transmitted LSB first; bits 0-6 are the "scan code" which uniquely identifies the key by its position on the keyboard, bit 7 (MSB) is 0 for key press and 1 for key release. Holding a key down for more than half a second invokes the "typematic" action: key press scan codes are sent repeatedly at the rate of 10 per second without intervening key release scan codes, until the key is released.

In the system unit the character received on the KBD DATA line is reconverted to parallel format, gated into port 60h, and a interrupt is sent on IRQ1 to the Interrupt Controller. Since the baud rate clock is transmitted along with the data, the circuit needed to deserialize the data is significantly simpler than a UART; it is essentially a serial-in, parallel-out shift register. The Interrupt Controller triggers interrupt 9 for IRQ1.

The interrupt 9 handler must send an End-of-Interrupt signal to the Interrupt Controller, and on the original IBM PC also needs to acknowledge the reception of the character by sending a clear-and-reenable handshaking signal to the keyboard unit over the KBD DATA line. This is done by setting bit 7 of port 61h to 1 and back to 0. (The other bits of port 61h should be left unchanged since they control other functions. E.g., bits 0 and 1 enable the built-in speaker, and bit 6 disables the keyboard clock.) On more recent machines, this acknowledgment is unnecessary but not harmful.

The use of scan codes together with the key press/release information makes it easy to assign arbitrary meanings to the keys, e.g., to convert the standard QWERTY keyboard layout to the Dvorak layout; to discriminate between different keys having the same labels such as the number keys in the main keyboard and the numeric keypad, the left and right SHIFT keys, etc.; to handle special key combinations for "hot key" applications; and to identify the sequence in which certain keys have been pressed and released. For normal typing and character entry, on the other hand, keystrokes should simply be converted to ASCII codes; this is done by the default interrupt 9 handler in the system BIOS, described below.

10.1.2 Keyboard Interrupt 9 Handler

KBD_INT, the name given to the default BIOS Keyboard Interrupt 9 Handler, reads the scan code from port 60h, sends the clear-and-reenable handshaking signal to the keyboard unit, processes the scan code, sends an End-of-Interrupt signal to the Interrupt Controller (code 20h to port 20h), and returns from the interrupt.

The scan code processing performed in the KBD_INT routine in BIOS consists of the following tasks:

1. Intercept the following special key combinations:

   • CTRL-ALT-DEL (invokes a system reset)

   • CTRL-BREAK (invokes interrupt 1Bh. By default an immediate IRET is performed unless the user has installed an interrupt 1Bh handler)

   • CTRL-NUM LOCK (enters a SUSPEND state, i.e. waits in a loop within KBD_INT until any key other than NUM LOCK is pressed)

   • SHIFT-PRTSC (invokes interrupt 5)

2. Maintain a record of the state of the SHIFT, CTRL, ALT, CAPS LOCK, NUM LOCK, SCROLL LOCK, and INSERT keys. This invokes monitoring key presses as well as releases, and suppressing the typematic action of the LOCK and INSERT keys to get toggle action.

3. Convert the scan code for any other key press (and for INSERT) into a two-byte "extended ASCII" code representation and store it in a 16-word circular "type-ahead" buffer KB_BUFFER (or sound a beep if the buffer is full)

4. "Compose" an ASCII code for digits typed on the numeric keypad while ALT is held down. The code is the number (modulo 256).

KbdInt
        push    ax              ; Save registers
        push    ds              ;
        mov     ax, cs          ; Make sure DS = CS
        mov     ds, ax          ;
        in      al, 60h         ; Get scan code
                ¦               ;
                ¦               ; Process event
                ¦               ;
        in      al, 61h         ; Send acknowledgment without
        or      al, 10000000b   ;   modifying the other bits.
        out     61h, al         ;
        and     al, 01111111b   ;
        out     61h, al         ;
        mov     al, 20h         ; Send End-of-Interrupt signal
        out     20h, al         ;
        pop     ds              ; Restore registers
        pop     ax              ;
        iret                    ; End of handler

10.1.3 Library Procedures for Keyboard Input

One thing to note about the above routines is that they will wait indefinitely until a key is typed. If this is not desired, one should check to see if a key is available before calling kbdine or kbdin. For this you call interrupt 16h with AH=1, which returns with the zero flag ZF=1 if no character has been typed, or ZF=0 if a character is available. An example of how to use this interrupt is shown below:

        mov     ah, 1   ; Get the status of keyboard
                        ;  buffer
        int     16h     ; ZF=1 if buffer is empty
        jz      .nochar ; Do something else if buffer is
                        ;  empty
        call    kbdine  ; Get the character
                ¦
                ¦

10.1.4 BIOS Function Calls

Several useful BIOS routines for the keyboard can be accessed by using INT 16h with AH=0, 1, or 2.

Subfunction 0 (i.e. AH=0) waits, if necessary, until an entry is present in the BIOS type-ahead buffer KB_BUFFER, then removes the entry from KB_BUFFER into register AX. The scan code (or second code) is in AH and the ASCII code (or 00h) is in AL.

Subfunction 1 returns with the entry at the tail of KB_BUFFER copied into AX (but not removed from the buffer) and the zero flag set/reset if the buffer is/isn't empty. I.e., if ZF=1, a new entry is not available, and the entry copied into AX was typed 16 entries ago; if ZF=0, AX contains the new entry (subfunction 0 must be used to actually remove the entry from KB_BUFFER). Subfunction 1 may be used to "preview" a character such as CTRL-C before it is acted upon.

Subfunction 2 copies the first "shift status" byte (see Table 10-1) into AL.

Subfunction 0 and 1 recognize CTRL-BREAK and invoke interrupt 1Bh. The default interrupt 1Bh handler in BIOS is an IRET. A user-written interrupt 1Bh handler may be installed, but care must be taken to issue End-of-Interrupt commands for all hardware interrupts that happen to be in service when CTRL-BREAK was pressed, and to reset those hardware devices.

Here is a short table summarizing the INT 16h functions above:

10.1.5 DOS Function Calls

In addition to the BIOS calls, there are several DOS function calls which also provide keyboard services. The calls are performed using INT 21h with AH=01h, 06h, 07h, 0Ah, 0Bh, and 0Ch. These DOS function calls use the BIOS calls described above. Some functions recognize CTRL-BREAK and SHIFT-PRTSC; note that CTRL-BREAK from a DOS function invokes interrupt 23h.

DOS functions 01h, 07h, or 08h wait (if necessary), read a new buffer entry, and return the ASCII code in register AL; an ASCII code of 00h indicates that a second DOS function call is needed to get the "second code" into AL. Function 01h also echoes the character to the display, functions 07h and 08h don't. Functions 01h and 08h recognize CTRL-BREAK and SHIFT-PRTSC; function 07h ignores them.

DOS function 06h, when used for input by setting DL = -1, is similar to function 07h but does not wait for an entry: if no entry is ready the function returns with the zero flag set, otherwise the zero flag is reset and the ASCII code is returned in AL.

DOS function 0Ah allows input of an entire input string. The characters are echoed to the display as they are entered; the string is terminated with ENTER. Keys requiring a "second code" are ignored. If the allowed maximum length of the string (including the terminating ENTER) is N characters, an (N+2)-byte input buffer pointed to by DS:DX must be set up, with byte 0 set to N. When the complete string has been input, byte 1 of the buffer will be set to the actual character count (not including the terminating ENTER); the characters of the string, including the ENTER, start in byte 2. A beep sounds if the string is too long, i.e., if the Nth character is not ENTER.

DOS function 0Bh returns 0/-1 in register AL if KB_BUFFER is/isn't empty. This function recognizes CTRL-BREAK.

DOS function 0Ch, with AL = 01h, 06h, 07h, 08h, or 0Ah, first clears KB_BUFFER and then invokes the DOS function specified in AL

Here is a short table summarizing the INT 21h functions above:

10.1.6 Extended ASCII Codes

10.1.7 Applications