home *** CD-ROM | disk | FTP | other *** search
/ The Unsorted BBS Collection / thegreatunsorted.tar / thegreatunsorted / programming / misc_programming / kb < prev    next >
Encoding:
Text File  |  1990-01-04  |  8.6 KB  |  170 lines
  1.                            Chapter  5
  2.  
  3.                         Keyboard Services
  4.                         -----------------
  5.  
  6.  1. Introduction
  7.         
  8.     The ROM BIOS contains two keyboard-related services, a Keyboard ISR and
  9.     a Keyboard DSR (see Figure 1-1):
  10.  
  11.      * Keyboard ISR
  12.        The BIOS Keyboard Interrupt Service Routine (ISR) is invoked via 
  13.        H/W INT 9h each time a key is pressed.  The BIOS Keyboard ISR
  14.        processes keyboard data and converts it into information that is
  15.        useful to the system.  In most cases, this conversion results in 
  16.        the Keyboard ISR placing a two byte character code into the keyboard
  17.        buffer.
  18.  
  19.      * Keyboard DSR
  20.        The BIOS Keyboard Device Service Routine (DSR) is invoked via S/W
  21.        INT 16h.  The BIOS Keyboard DSR provides an interface through which
  22.        the operating system or application S/W can interface with the
  23.        keyboard buffer.  The Keyboard DSR contains functions that read the
  24.        BIOS keyboard buffer, write to the buffer, return the status of the
  25.        buffer, and so on.
  26.  
  27.  
  28.   KB H/W    ┌────────┐     ┌───────────┐       ┌────────┐  Request ┌──────┐
  29.   Interrupt │ KB ISR ├────>│ KB buffer │<─────>│ KB DSR │<─────────┤      │
  30.    (IRQ 1)  │        │     └───────────┘       │        │          │ User │
  31.  ──────────>│ INT 9  │     ┌───────────┐       │ INT 16 │   Data   │      │
  32.             │        │<───>│ KB flags  │<─────>│        │<────────>│      │
  33.             └────────┘     └───────────┘       └────────┘          └──────┘
  34.                               BIOS Data
  35.  
  36.           Figure 1-1. The relation between the Keyboard ISR and DSR
  37.           --------------------------------------------------------- 
  38.  
  39.  
  40.  2. Keyboard ISR (INT 9h) Operation
  41.  
  42.     2.1 Keyboard H/W Architecture
  43.         Figure 2-1 shows the keyboard H/W architecture.  The keyboard
  44.         controller 8042 support the PS/2 MOUSE and KEYBOARD SECURITY.
  45.         And the 8041 doesn't support the PS/2 MOUSE and KEYBOARD SECURITY,
  46.         it is used for supporting the standard PC/AT-compatible machine.
  47.         The code that is transferred between the 8042 and the keyboard is 
  48.         in serial form through the DATA and CLK lines.  Once the 8042 
  49.         wants to send a code to the CPU, it generates IRQ 1 which invokes
  50.         the INT 9 Keyboard ISR.
  51.  
  52.        ┌─────────┐              ┌─────────────┐ KDATA  ┌─────┐
  53.        │         │              │ Keyboard    ├────────┤     │
  54.        │         │    DATA      │ Controller  │ KCLK   │ KB  │
  55.        │         │<════════════>│             ├────────┤     │
  56.        │  CPU    │              │   8042      │        └─────┘
  57.        │         │   Control    │  (8041)     ├─────────────────────┐
  58.        │         │═════════════>│             │                     │
  59.        │         │              │             │ MDATA  ┌-----┐      │
  60.        │         │<─┐           │             │--------|     |      │
  61.        └─────────┘  │           │             │ MCLK   |MOUSE|      │
  62.                     │           │             │--------|     |      │
  63.                     │           │             │        └-----┘      │
  64.                     │           │             │--------┐            │
  65.                     │           └─────────────┘        |            │
  66.                     │                                  |            │
  67.                     │           ┌─────────────┐        |            │
  68.                     │           │ Interrupt   │ IRQ 12 |            │
  69.                     │   INT     │ Control     │<-------┘            │
  70.                     └───────────┤ System      │                     │
  71.                                 │             │  IRQ 1              │
  72.                                 │  8259 * 2   │<────────────────────┘
  73.                                 └─────────────┘
  74.  
  75.           Figure 2-1. Keyboard H/W Architecture
  76.           -------------------------------------
  77.  
  78.     2.2 Key Code
  79.         The code generated by the keyboard H/W is called "scan code".  For
  80.         84-key keyboard, each key has one and only one scan code.  For 
  81.         101/102-key keyboard, the enhanced key simulates a sequence of
  82.         84-key keyboard scan codes plus some special code (E0h, E1h).  The
  83.         scan code can be separated to two types: "make code" and "break 
  84.         code". The keyboard H/W generates the key's make code each time the
  85.         key is pressed, and it generates the key's break code each time the
  86.         key is released.  For PC-compatible key codes, the byte associated 
  87.         with a key's break code is identical to the one associated with its
  88.         make code except that bit 7 is set.
  89.  
  90.     2.3 Keyboard ISR Processing
  91.        The Keyboard ISR analyzes each scan code as follows:
  92.         * Codes generated by keyboard shift or toggle keys cause the
  93.           Keyboard ISR to update the keyboard flags:
  94.  
  95.           017h -- byte -- keyboard flag 1
  96.                   bit 7 = 1 -- Insert function      active
  97.                   bit 6 = 1 -- Caps   Lock function active
  98.                   bit 5 = 1 -- Num    Lock function active
  99.                   bit 4 = 1 -- Scroll Lock function active
  100.                   bit 3 = 1 -- Alt key              pressed
  101.                   bit 2 = 1 -- Ctrl key             pressed
  102.                   bit 1 = 1 -- left Shift key       pressed
  103.                   bit 0 = 1 -- right Shift key      pressed
  104.  
  105.           018h -- byte -- keyboard flag 2
  106.                   bit 7 = 1 -- Insert key           pressed
  107.                   bit 6 = 1 -- Caps   Lock key      pressed
  108.                   bit 5 = 1 -- Num    Lock key      pressed
  109.                   bit 4 = 1 -- Scroll Lock key      pressed
  110.                   bit 3 = 1 -- suspend (Pause key pressed)  active
  111.                   bit 2 = 1 -- System Request key   pressed
  112.                   bit 1 = 1 -- left Alt key         pressed
  113.                   bit 0 = 1 -- left Ctrl key        pressed
  114.  
  115.         * Codes that correspond to ASCII or special key values (e.g., 
  116.           function or edit keys) are converted into two byte character 
  117.           codes and are placed in a 16 word keyboard buffer.  Figure 2-2
  118.           shows the structure of the keyboard buffer, it's a ring queue.
  119.           Keyboard ISR place the character code to the keyboard buffer 
  120.           pointed to by the KB tail, then increments KB tail by 1 word. 
  121.           If KB tail is equal to the KB buffer End, it will wrap around to
  122.           the KB buffer Start.  If keyboard buffer is full, Keyboard ISR
  123.           will issue a short beep and discard this character code.
  124.  
  125.        KB buffer         KB head                     KB tail      KB buffer
  126.        Start                 │                           │           End
  127.         │                    │                           │            │
  128.         V                    V                           V            V
  129.        ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
  130.        │   │   │   │   │   │   │   │   │   │   │   │   │   │   │   │   │
  131.        └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
  132.  
  133.           Figure 2-2. The structure of the keyboard buffer
  134.           ------------------------------------------------
  135.  
  136.         * Shift key combinations, such as Ctrl-Alt-Del, Ctrl-Alt-Esc, and
  137.           Ctrl-Alt-'+', are converted into requests for keyboard ISR
  138.           internal functions, such as Warm-Start, Setup, and Change-Speed.
  139.  
  140.  3. Keyboard DSR (INT 16h) Operation
  141.  
  142.     3.1 Scan Code/Character Code Combinations    
  143.  
  144.         The code placed to the keyboard buffer by Keyboard ISR is called
  145.         "scan code/character code combination", because most of the codes
  146.         contain a scan code and a character code.  Keyboard DSR takes this
  147.         code and make some transformations for 84-key compatible code, then
  148.         passes the code to the caller.
  149.  
  150.     3.2 Keyboard DSR Functions
  151.  
  152.         The Keyboard DSR functions can be roughly separated in two parts:
  153.         standard functions and extended functions.  Standard function 
  154.         supports the 84-key compatible codes, and the extended functions 
  155.         supports the 101/102-key extended codes.  All the Keyboard DSR
  156.         functions are listed as follows:
  157.  
  158.          (ah) = 0   Read key
  159.          (ah) = 1   Read status
  160.          (ah) = 2   Return current shift status
  161.          (ah) = 3   Set typematic rate 
  162.          (ah) = 4   reserved
  163.          (ah) = 5   Write key
  164.          (ah) = 6 - 0fh reserved
  165.          (ah) = 10h Extented read key
  166.          (ah) = 11h Extented read status 
  167.          (ah) = 12h Extented return current shift status
  168.          (ah) = 13h - 0ffh reserved     
  169.  
  170.