[自制操作系统] 第17回 编写键盘驱动

目录
一、前景回顾
二、实现键盘输入的中断函数
三、编写键盘驱动
四、实现环形输入缓冲区
五、运行测试

 

一、前景回顾

　　上一回我们完成了锁的实现，并且利用锁优化了终端输出函数。这一回我们来实现键盘的输入，为后面的用户交互功能打好基础。

二、实现键盘输入的中断函数

　　首先我们需要知道键盘是属于外设，所以对应的中断属于外部中断。在讲中断那一章节时，我们知道了外部中断的处理流程，不过对于键盘的输入中断，还需要增加一点点东西。

 　　

　　8048是键盘上的芯片，其主要任务就是监控哪个键被按下，一旦有按键信息，8048就将按键信息传递给键盘控制器8042（8042通常是Intel 8042或兼容芯片，集成在主机内部的主板上），再由8042发送中断信号给8259A。最重要的一点是，键盘的中断号。

 　　

　　我们可以看到键盘对应的是IR1口，这个是硬件上决定的，所以我们无法更改。除此之外，在我们的程序中，我们将IR0口的中断号设置为0x20，后面依次递增，所以我们可以知道键盘的中断号为0x21。这里我们不管按键信息如何，我们只需要知道一旦有按键按下，就会有中断触发，所以我们尝试写一下按键的中断处理函数。

　　在project/kernel目录下新建keyboard.c、keyboard.h文件，除此之外还需要修改interrupt.c文件。

#include "keyboard.h"  2 #include "print.h"  3 #include "interrupt.h"  4 #include "io.h"  5 #include "global.h"  6 #include "stdint.h"  7   8 #define KBD_BUF_PORT  0x60  9  10 static void intr_keyboard_handler(void) 11 { 12     put_str("kn"); 13     inb(KBD_BUF_PORT); 14 } 15  16 /*键盘初始化*/ 17 void keyboard_init(void) 18 { 19     put_str("keyboard init startn"); 20     register_handler(0x21, intr_keyboard_handler); 21     put_str("keyboard init donen"); 22 }

#ifndef  __KERNEL_KEYBOARD_H 2 #define  __KERNEL_KEYBOARD_H 3  4 void keyboard_init(void); 5 static void intr_keyboard_handler(void); 6 #endif

...  2   3 /* 初始化可编程中断控制器8259A */  4 static void pic_init(void) {  5    /* 初始化主片 */  6    outb (PIC_M_CTRL, 0x11);   // ICW1: 边沿触发,级联8259, 需要ICW4.  7    outb (PIC_M_DATA, 0x20);   // ICW2: 起始中断向量号为0x20,也就是IR[0-7] 为 0x20 ~ 0x27.  8    outb (PIC_M_DATA, 0x04);   // ICW3: IR2接从片.   9    outb (PIC_M_DATA, 0x01);   // ICW4: 8086模式, 正常EOI 10  11    /* 初始化从片 */ 12    outb (PIC_S_CTRL, 0x11);    // ICW1: 边沿触发,级联8259, 需要ICW4. 13    outb (PIC_S_DATA, 0x28);    // ICW2: 起始中断向量号为0x28,也就是IR[8-15] 为 0x28 ~ 0x2F. 14    outb (PIC_S_DATA, 0x02);    // ICW3: 设置从片连接到主片的IR2引脚 15    outb (PIC_S_DATA, 0x01);    // ICW4: 8086模式, 正常EOI 16  17    /*只打开键盘中断*/ 18    outb (PIC_M_DATA, 0xfd); 19    outb (PIC_S_DATA, 0xff); 20  21    put_str("pic_init donen"); 22 } 23  24 ...

　　最后编译运行，可以看到我们一旦按下按键，屏幕便会打印信息，而且释放按键也会打印信息。当然这是后面需要讲解的内容，总之到现在，我们已经成功实现了按键的中断处理函数。

 　　

三、编写键盘驱动

　　现在来说说为什么按下按键和释放按键都会触发中断。其实这是硬件所决定的，一个键的状态要么是按下，要么是弹起，因此一个按键有两个编码，按键被按下时的编码是通码，按键被释放时的编码是断码。

　　无论是按下键或是松开键，当键的状态改变后，键盘中的8048芯片把按键对应的扫描码（通码或者断码）发送到主板上的8042芯片，由8042处理后保存在自己的寄存器中，然后向8259A发送中断信号，这样处理器便去执行键盘中断处理程序，将8042处理过的扫描码从它的寄存器中读取出来，随后将扫描码转换成对应的ASCII码。

　　所以我们的函数中需要自己完善这么一个映射关系，也就是扫描码到ASCII码的映射。这里就偷懒直接抄书上的，我也没有去仔细看了，总之能知道整个流程就行了。

　　所以进一步完善我们的keyboard.c文件如下。

#include "keyboard.h"   2 #include "print.h"   3 #include "interrupt.h"   4 #include "io.h"   5 #include "global.h"   6 #include "stdint.h"   7 #include "ioqueue.h"   8    9 #define KBD_BUF_PORT  0x60  10   11 /*用转移字符定义部分控制字符*/  12 #define esc        '33'  13 #define backspace  'b'  14 #define tab        't'  15 #define enter      'r'  16 #define delete     '177'  17   18 /*以下不可见字符一律为0*/  19 #define char_invisible  0  20 #define ctrl_l_char     char_invisible  21 #define ctrl_r_char     char_invisible  22 #define shift_l_char    char_invisible  23 #define shift_r_char    char_invisible  24 #define alt_l_char      char_invisible  25 #define alt_r_char      char_invisible  26 #define caps_lock_char  char_invisible  27   28 /*定义控制字符的通码和断码*/  29 #define shift_l_make     0x2a  30 #define shift_r_make     0x36  31 #define alt_l_make       0x38  32 #define alt_r_make       0xe038  33 #define alt_r_break      0xe0b8  34 #define ctrl_l_make      0x1d  35 #define ctrl_r_make      0xe01d  36 #define ctrl_r_break     0xe09d  37 #define caps_lock_make   0x3a  38    39 /*定义以下变量记录相应键是否按下的状态*/  40 static bool ctrl_status, shift_status, alt_status, caps_lock_status, ext_scancode;  41   42   43 /*以通码make_code为索引的二维数组*/  44 static char keymap[][2] = {  45 /*扫描码未与shift组合*/  46 /* 0x00 */    {0,    0},          47 /* 0x01 */    {esc,    esc},          48 /* 0x02 */    {'1',    '!'},          49 /* 0x03 */    {'2',    '@'},          50 /* 0x04 */    {'3',    '#'},          51 /* 0x05 */    {'4',    '$'},          52 /* 0x06 */    {'5',    '%'},          53 /* 0x07 */    {'6',    '^'},          54 /* 0x08 */    {'7',    '&'},          55 /* 0x09 */    {'8',    '*'},          56 /* 0x0A */    {'9',    '('},          57 /* 0x0B */    {'0',    ')'},          58 /* 0x0C */    {'-',    '_'},          59 /* 0x0D */    {'=',    '+'},          60 /* 0x0E */    {backspace, backspace},      61 /* 0x0F */    {tab,    tab},          62 /* 0x10 */    {'q',    'Q'},          63 /* 0x11 */    {'w',    'W'},          64 /* 0x12 */    {'e',    'E'},          65 /* 0x13 */    {'r',    'R'},          66 /* 0x14 */    {'t',    'T'},          67 /* 0x15 */    {'y',    'Y'},          68 /* 0x16 */    {'u',    'U'},          69 /* 0x17 */    {'i',    'I'},          70 /* 0x18 */    {'o',    'O'},          71 /* 0x19 */    {'p',    'P'},          72 /* 0x1A */    {'[',    '{'},          73 /* 0x1B */    {']',    '}'},          74 /* 0x1C */    {enter,  enter},  75 /* 0x1D */    {ctrl_l_char, ctrl_l_char},  76 /* 0x1E */    {'a',    'A'},          77 /* 0x1F */    {'s',    'S'},          78 /* 0x20 */    {'d',    'D'},          79 /* 0x21 */    {'f',    'F'},          80 /* 0x22 */    {'g',    'G'},          81 /* 0x23 */    {'h',    'H'},          82 /* 0x24 */    {'j',    'J'},          83 /* 0x25 */    {'k',    'K'},          84 /* 0x26 */    {'l',    'L'},          85 /* 0x27 */    {';',    ':'},          86 /* 0x28 */    {''',    '"'},          87 /* 0x29 */    {'`',    '~'},          88 /* 0x2A */    {shift_l_char, shift_l_char},      89 /* 0x2B */    {'\',    '|'},          90 /* 0x2C */    {'z',    'Z'},          91 /* 0x2D */    {'x',    'X'},          92 /* 0x2E */    {'c',    'C'},          93 /* 0x2F */    {'v',    'V'},          94 /* 0x30 */    {'b',    'B'},          95 /* 0x31 */    {'n',    'N'},          96 /* 0x32 */    {'m',    'M'},          97 /* 0x33 */    {',',    '<'},          98 /* 0x34 */    {'.',    '>'},          99 /* 0x35 */    {'/',    '?'}, 100 /* 0x36    */    {shift_r_char, shift_r_char},     101 /* 0x37 */    {'*',    '*'},         102 /* 0x38 */    {alt_l_char, alt_l_char}, 103 /* 0x39 */    {' ',    ' '},         104 /* 0x3A */    {caps_lock_char, caps_lock_char} 105 }; 106  107 /*键盘中断处理程序*/ 108 static void intr_keyboard_handler(void) 109 { 110     bool ctrl_down_last = ctrl_status; 111     bool shift_down_last = shift_status; 112     bool caps_lock_last = caps_lock_status; 113  114  115     bool break_code; 116     uint16_t scancode = inb(KBD_BUF_PORT); 117  118     /*若扫描码scancode是以e0开头的，表示此键的按下将产生多个扫描码 119     所以马上结束此次中断处理函数，等待下一个扫描码进入*/ 120     if (scancode == 0xe0) { 121         ext_scancode = true; 122         return; 123     } 124  125     /*如果赏赐是以0xe0开头的，将扫描码合并*/ 126     if (ext_scancode) { 127         scancode = ((0xe00) | scancode); 128         ext_scancode = false; 129     } 130  131     break_code = ((scancode & 0x0080) != 0); 132     if (break_code) { 133         uint16_t make_code = (scancode &= 0xff7f); //多字节不处理 134         if(make_code == ctrl_l_make || make_code == ctrl_r_make) { 135             ctrl_status = false; 136         }  137         else if (make_code == shift_l_make || make_code == shift_r_make) { 138             shift_status = false; 139         } 140         else if (make_code == alt_l_make || make_code == alt_r_make) { 141             alt_status = false; 142         } 143         return; 144     } 145     else if((scancode > 0x00 && scancode < 0x3b) || (scancode == alt_r_make) || (scancode == ctrl_r_make)) { 146         bool shift = false; //先默认设置成false 147         if ((scancode < 0x0e) || (scancode == 0x29) || (scancode == 0x1a) ||  148         (scancode == 0x1b) || (scancode == 0x2b) || (scancode == 0x27) ||  149         (scancode == 0x28) || (scancode == 0x33) || (scancode == 0x34) ||  150         (scancode == 0x35)) 151         { 152             if (shift_down_last) { 153                 shift = true; 154             }     155         } else { 156             if (shift_down_last && caps_lock_last) { 157                 shift = false; //效果确实是这样子的 我试了一下 158             }     159             else if(shift_down_last || caps_lock_last) { 160                 shift = true; //其中任意一个都是大写的作用 161             }  162             else shift = false; 163         } 164          165         uint8_t index = (scancode & 0x00ff); 166         char cur_char = keymap[index][shift]; 167  168     put_char(cur_char); 169     } 170     return; 171 } 172  173  174 /*键盘初始化*/ 175 void keyboard_init(void) 176 { 177     put_str("keyboard init startn"); 178     register_handler(0x21, intr_keyboard_handler); 179     put_str("keyboard init donen"); 180 }

 　　

　　此时可以发现，我们在键盘上按下键，屏幕上能相应地输出字符。

四、实现环形输入缓冲区

　　虽然我们已经实现了键盘驱动，但是目前能实现的功能仅仅是在屏幕上输出我们所按下的按键，但是并没有什么实用的地方。我们在键盘上操作是为了能和系统进行交互，而交互过程一般都是键入各种shell命令，然后shell解析并且执行。

　　所以我们需要实现一个缓冲区，在按键的中断处理函数中将输入的按键信息保存在缓冲区中，将来实现的shell进程在该缓冲区中读取数据并且输出到屏幕上，等到我们按下了回车后，就将前面读取到的字符解析去处理。虽然我们还没有实现shell进程，但是我们可以新建线程来读取数据，测试缓冲区的功能。

　　所以下面的代码便是实现缓冲区，在project/kernel目录下新建ioqueue.c和ioqueue.h文件。

#include "ioqueue.h"  2 #include "interrupt.h"  3 #include "global.h"  4 #include "debug.h"  5 #include "thread.h"  6 #include "stdbool.h"  7 #include "stddef.h"  8   9 /*初始化io队列ioq*/ 10 void ioqueue_init(struct ioqueue *ioq) 11 { 12     lock_init(&ioq->lock); 13     ioq->consumer = ioq->producer = NULL; 14     ioq->head = ioq->tail = 0;      /*队列的首尾指针都指向缓冲区数组的第0个位置*/       15 } 16  17 /*返回pos在缓冲区的下一个位置*/ 18 static int32_t next_pos(int32_t pos) 19 { 20     return ((pos + 1) % bufsize); 21 } 22  23 /*判断队列是否已满*/ 24 bool ioq_full(struct ioqueue *ioq) 25 { 26     //return ((ioq->head + 1) % bufsize == ioq->tail) ? true : false; 27     ASSERT(intr_get_status() == INTR_OFF); 28     return next_pos(ioq->head) == ioq->tail; 29 } 30  31 /*判断队列是否为空*/ 32 bool ioq_empty(struct ioqueue *ioq) 33 { 34     ASSERT(intr_get_status() == INTR_OFF); 35     return ioq->head == ioq->tail; 36 } 37  38 /*使当前生产者或消费者在此缓冲区上等待*/ 39 static void ioq_wait(struct task_struct **waiter) 40 { 41     ASSERT(*waiter == NULL && waiter != NULL); 42     *waiter = running_thread(); 43     thread_block(TASK_BLOCKED); 44 } 45  46 /*唤醒waiter*/ 47 static void wakeup(struct task_struct **waiter) 48 { 49     ASSERT(*waiter != NULL); 50     thread_unblock(*waiter); 51     *waiter = NULL; 52 } 53  54   55 /*消费者从ioq队列中获取一个字符*/ 56 char ioq_getchar(struct ioqueue *ioq) 57 { 58     ASSERT(intr_get_status() == INTR_OFF); 59  60     while (ioq_empty(ioq)) { 61         lock_acquire(&ioq->lock); 62         ioq_wait(&ioq->consumer); 63         lock_release(&ioq->lock); 64     } 65  66     char byte = ioq->buf[ioq->tail]; 67     ioq->tail = next_pos(ioq->tail); 68  69     if (ioq->producer != NULL) { 70         wakeup(&ioq->producer); 71     } 72     return byte; 73 } 74  75  76 /*生产者往ioq队列中写入一个字符byte*/ 77 void ioq_putchar(struct ioqueue *ioq, char byte) 78 { 79     while (ioq_full(ioq)) { 80         lock_acquire(&ioq->lock); 81         ioq_wait(&ioq->producer); 82         lock_release(&ioq->lock); 83     } 84     ioq->buf[ioq->head] = byte;  85     ioq->head = next_pos(ioq->head); 86  87     if (ioq->consumer != NULL) { 88         wakeup(&ioq->consumer); 89     } 90 }

#ifndef  __KERNEL_IOQUEUE_H  2 #define  __KERNEL_IOQUEUE_H  3 #include "sync.h"  4 #include "stdint.h"  5   6 #define bufsize 64  7   8 /*环形队列*/  9 struct ioqueue { 10 /*生产者消费问题*/ 11     struct lock lock; 12     struct task_struct *producer; 13     struct task_struct *consumer; 14     char buf[bufsize]; 15     int32_t head; 16     int32_t tail; 17 }; 18  19 void ioq_putchar(struct ioqueue *ioq, char byte); 20 char ioq_getchar(struct ioqueue *ioq); 21 static void wakeup(struct task_struct **waiter); 22 static void ioq_wait(struct task_struct **waiter); 23 bool ioq_empty(struct ioqueue *ioq); 24 bool ioq_full(struct ioqueue *ioq); 25 static int32_t next_pos(int32_t pos); 26 void ioqueue_init(struct ioqueue *ioq); 27  28 #endif

五、运行测试

　　上面我们已经实现了环形输入缓冲区，接下来我们在main函数中新建两个线程，这两个线程不停地从缓冲区中一个字节一个字节地取数据，如果没有便阻塞，直到缓冲区中又有数据。除此之外还需要修改interrupt.c文件，我们前面只开启了键盘中断，现在加入线程调度，所以需要开启时钟中断。修改的代码一并如下：

...  2   3 /* 初始化可编程中断控制器8259A */  4 static void pic_init(void) {  5    /* 初始化主片 */  6    outb (PIC_M_CTRL, 0x11);   // ICW1: 边沿触发,级联8259, 需要ICW4.  7    outb (PIC_M_DATA, 0x20);   // ICW2: 起始中断向量号为0x20,也就是IR[0-7] 为 0x20 ~ 0x27.  8    outb (PIC_M_DATA, 0x04);   // ICW3: IR2接从片.   9    outb (PIC_M_DATA, 0x01);   // ICW4: 8086模式, 正常EOI 10  11    /* 初始化从片 */ 12    outb (PIC_S_CTRL, 0x11);    // ICW1: 边沿触发,级联8259, 需要ICW4. 13    outb (PIC_S_DATA, 0x28);    // ICW2: 起始中断向量号为0x28,也就是IR[8-15] 为 0x28 ~ 0x2F. 14    outb (PIC_S_DATA, 0x02);    // ICW3: 设置从片连接到主片的IR2引脚 15    outb (PIC_S_DATA, 0x01);    // ICW4: 8086模式, 正常EOI 16  17    /*打开键盘和时钟中断*/ 18    outb (PIC_M_DATA, 0xfc); 19    outb (PIC_S_DATA, 0xff); 20     21    put_str("pic_init donen"); 22 } 23  24 ...

#include "print.h"  2 #include "init.h"  3 #include "memory.h"  4 #include "thread.h"  5 #include "list.h"  6 #include "interrupt.h"  7 #include "console.h"  8 #include "ioqueue.h"  9 #include "keyboard.h" 10  11 void k_thread_a(void *arg); 12 void k_thread_b(void *arg); 13  14 int main(void) 15 { 16     put_str("HELLO KERNELn"); 17     init_all(); 18     thread_start("k_thread_a", 31, k_thread_a, "ThreadA_"); 19     thread_start("k_thread_b", 8, k_thread_b, "ThreadB_"); 20     intr_enable(); 21     while(1); 22 } 23  24 /*在线程中运行的函数k_thread_a*/ 25 void k_thread_a(void *arg) 26 { 27     char *para = arg; 28     while(1) { 29         enum intr_status old_status = intr_disable(); 30         if (!ioq_empty(&kbd_buf)) { 31             console_put_str(arg); 32             char byte = ioq_getchar(&kbd_buf); 33             console_put_char(byte); 34             console_put_str("n"); 35         } 36         intr_set_status(old_status); 37     } 38 } 39  40 /*在线程中运行的函数k_thread_b*/ 41 void k_thread_b(void *arg) 42 { 43     char *para = arg; 44     while(1) { 45         enum intr_status old_status = intr_disable(); 46         if (!ioq_empty(&kbd_buf)) { 47             console_put_str(arg); 48             char byte = ioq_getchar(&kbd_buf); 49             console_put_char(byte); 50             console_put_str("n"); 51         } 52         intr_set_status(old_status); 53     } 54 }

#ifndef  __KERNEL_KEYBOARD_H 2 #define  __KERNEL_KEYBOARD_H 3  4 void keyboard_init(void); 5 static void intr_keyboard_handler(void); 6 extern struct ioqueue kbd_buf; 7 #endif

　

#include "init.h"  2 #include "print.h"  3 #include "interrupt.h"  4 #include "timer.h"  5 #include "memory.h"  6 #include "thread.h"  7 #include "list.h"  8 #include "console.h"  9 #include "keyboard.h" 10  11 void init_all(void) 12 { 13     put_str("init_alln"); 14     idt_init(); 15     timer_init(); 16     mem_init(); 17     thread_init(); 18     console_init(); 19     keyboard_init(); 20 }

　

#include "keyboard.h"   2 #include "print.h"   3 #include "interrupt.h"   4 #include "io.h"   5 #include "global.h"   6 #include "stdint.h"   7 #include "ioqueue.h"   8    9 #define KBD_BUF_PORT  0x60  10   11 /*用转移字符定义部分控制字符*/  12 #define esc        '33'  13 #define backspace  'b'  14 #define tab        't'  15 #define enter      'r'  16 #define delete     '177'  17   18 /*以下不可见字符一律为0*/  19 #define char_invisible  0  20 #define ctrl_l_char     char_invisible  21 #define ctrl_r_char     char_invisible  22 #define shift_l_char    char_invisible  23 #define shift_r_char    char_invisible  24 #define alt_l_char      char_invisible  25 #define alt_r_char      char_invisible  26 #define caps_lock_char  char_invisible  27   28 /*定义控制字符的通码和断码*/  29 #define shift_l_make     0x2a  30 #define shift_r_make     0x36  31 #define alt_l_make       0x38  32 #define alt_r_make       0xe038  33 #define alt_r_break      0xe0b8  34 #define ctrl_l_make      0x1d  35 #define ctrl_r_make      0xe01d  36 #define ctrl_r_break     0xe09d  37 #define caps_lock_make   0x3a  38    39 /*定义以下变量记录相应键是否按下的状态*/  40 static bool ctrl_status, shift_status, alt_status, caps_lock_status, ext_scancode;  41   42 struct ioqueue kbd_buf;  43   44 /*以通码make_code为索引的二维数组*/  45 static char keymap[][2] = {  46 /*扫描码未与shift组合*/  47 /* 0x00 */    {0,    0},          48 /* 0x01 */    {esc,    esc},          49 /* 0x02 */    {'1',    '!'},          50 /* 0x03 */    {'2',    '@'},          51 /* 0x04 */    {'3',    '#'},          52 /* 0x05 */    {'4',    '$'},          53 /* 0x06 */    {'5',    '%'},          54 /* 0x07 */    {'6',    '^'},          55 /* 0x08 */    {'7',    '&'},          56 /* 0x09 */    {'8',    '*'},          57 /* 0x0A */    {'9',    '('},          58 /* 0x0B */    {'0',    ')'},          59 /* 0x0C */    {'-',    '_'},          60 /* 0x0D */    {'=',    '+'},          61 /* 0x0E */    {backspace, backspace},      62 /* 0x0F */    {tab,    tab},          63 /* 0x10 */    {'q',    'Q'},          64 /* 0x11 */    {'w',    'W'},          65 /* 0x12 */    {'e',    'E'},          66 /* 0x13 */    {'r',    'R'},          67 /* 0x14 */    {'t',    'T'},          68 /* 0x15 */    {'y',    'Y'},          69 /* 0x16 */    {'u',    'U'},          70 /* 0x17 */    {'i',    'I'},          71 /* 0x18 */    {'o',    'O'},          72 /* 0x19 */    {'p',    'P'},          73 /* 0x1A */    {'[',    '{'},          74 /* 0x1B */    {']',    '}'},          75 /* 0x1C */    {enter,  enter},  76 /* 0x1D */    {ctrl_l_char, ctrl_l_char},  77 /* 0x1E */    {'a',    'A'},          78 /* 0x1F */    {'s',    'S'},          79 /* 0x20 */    {'d',    'D'},          80 /* 0x21 */    {'f',    'F'},          81 /* 0x22 */    {'g',    'G'},          82 /* 0x23 */    {'h',    'H'},          83 /* 0x24 */    {'j',    'J'},          84 /* 0x25 */    {'k',    'K'},          85 /* 0x26 */    {'l',    'L'},          86 /* 0x27 */    {';',    ':'},          87 /* 0x28 */    {''',    '"'},          88 /* 0x29 */    {'`',    '~'},          89 /* 0x2A */    {shift_l_char, shift_l_char},      90 /* 0x2B */    {'\',    '|'},          91 /* 0x2C */    {'z',    'Z'},          92 /* 0x2D */    {'x',    'X'},          93 /* 0x2E */    {'c',    'C'},          94 /* 0x2F */    {'v',    'V'},          95 /* 0x30 */    {'b',    'B'},          96 /* 0x31 */    {'n',    'N'},          97 /* 0x32 */    {'m',    'M'},          98 /* 0x33 */    {',',    '<'},          99 /* 0x34 */    {'.',    '>'},         100 /* 0x35 */    {'/',    '?'}, 101 /* 0x36    */    {shift_r_char, shift_r_char},     102 /* 0x37 */    {'*',    '*'},         103 /* 0x38 */    {alt_l_char, alt_l_char}, 104 /* 0x39 */    {' ',    ' '},         105 /* 0x3A */    {caps_lock_char, caps_lock_char} 106 }; 107  108 /*键盘中断处理程序*/ 109 static void intr_keyboard_handler(void) 110 { 111     bool ctrl_down_last = ctrl_status; 112     bool shift_down_last = shift_status; 113     bool caps_lock_last = caps_lock_status; 114  115  116     bool break_code; 117     uint16_t scancode = inb(KBD_BUF_PORT); 118  119     /*若扫描码scancode是以e0开头的，表示此键的按下将产生多个扫描码 120     所以马上结束此次中断处理函数，等待下一个扫描码进入*/ 121     if (scancode == 0xe0) { 122         ext_scancode = true; 123         return; 124     } 125  126     /*如果赏赐是以0xe0开头的，将扫描码合并*/ 127     if (ext_scancode) { 128         scancode = ((0xe00) | scancode); 129         ext_scancode = false; 130     } 131  132     break_code = ((scancode & 0x0080) != 0); 133     if (break_code) { 134         uint16_t make_code = (scancode &= 0xff7f); //多字节不处理 135         if(make_code == ctrl_l_make || make_code == ctrl_r_make) { 136             ctrl_status = false; 137         }  138         else if (make_code == shift_l_make || make_code == shift_r_make) { 139             shift_status = false; 140         } 141         else if (make_code == alt_l_make || make_code == alt_r_make) { 142             alt_status = false; 143         } 144         return; 145     } 146     else if((scancode > 0x00 && scancode < 0x3b) || (scancode == alt_r_make) || (scancode == ctrl_r_make)) { 147         bool shift = false; //先默认设置成false 148         if ((scancode < 0x0e) || (scancode == 0x29) || (scancode == 0x1a) ||  149         (scancode == 0x1b) || (scancode == 0x2b) || (scancode == 0x27) ||  150         (scancode == 0x28) || (scancode == 0x33) || (scancode == 0x34) ||  151         (scancode == 0x35)) 152         { 153             if (shift_down_last) { 154                 shift = true; 155             }     156         } else { 157             if (shift_down_last && caps_lock_last) { 158                 shift = false; //效果确实是这样子的 我试了一下 159             }     160             else if(shift_down_last || caps_lock_last) { 161                 shift = true; //其中任意一个都是大写的作用 162             }  163             else shift = false; 164         } 165          166         uint8_t index = (scancode & 0x00ff); 167         char cur_char = keymap[index][shift]; 168      169         if (cur_char) { 170             if (!ioq_full(&kbd_buf)) { 171                 ioq_putchar(&kbd_buf, cur_char); 172             } 173             return; 174         } 175      176     if(scancode == ctrl_l_make || scancode == ctrl_r_make)         177         ctrl_status = true; 178     else if(scancode == shift_l_make || scancode == shift_r_make) 179             shift_status = true; 180     else if(scancode == alt_l_make || scancode == alt_r_make) 181         alt_status = true; 182     else if(scancode == caps_lock_make) 183         caps_lock_status = !caps_lock_status; 184     else put_str("unknown keyn"); 185     } 186     return; 187 } 188  189  190 /*键盘初始化*/ 191 void keyboard_init(void) 192 { 193     put_str("keyboard init startn"); 194     ioqueue_init(&kbd_buf); 195     register_handler(0x21, intr_keyboard_handler); 196     put_str("keyboard init donen"); 197 }

　　

　　 本回到此结束，预知后事如何，请看下回分解。