目录
一、前景回顾
二、实现键盘输入的中断函数
三、编写键盘驱动
四、实现环形输入缓冲区
五、运行测试
上一回我们完成了锁的实现，并且利用锁优化了终端输出函数。这一回我们来实现键盘的输入，为后面的用户交互功能打好基础。
首先我们需要知道键盘是属于外设，所以对应的中断属于外部中断。在讲中断那一章节时，我们知道了外部中断的处理流程，不过对于键盘的输入中断，还需要增加一点点东西。
8048是键盘上的芯片，其主要任务就是监控哪个键被按下，一旦有按键信息，8048就将按键信息传递给键盘控制器8042（8042通常是Intel 8042或兼容芯片，集成在主机内部的主板上），再由8042发送中断信号给8259A。最重要的一点是，键盘的中断号。
我们可以看到键盘对应的是IR1口，这个是硬件上决定的，所以我们无法更改。除此之外，在我们的程序中，我们将IR0口的中断号设置为0x20，后面依次递增，所以我们可以知道键盘的中断号为0x21。这里我们不管按键信息如何，我们只需要知道一旦有按键按下，就会有中断触发，所以我们尝试写一下按键的中断处理函数。
在project/kernel目录下新建keyboard.c、keyboard.h文件，除此之外还需要修改interrupt.c文件。
1 #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("k\n"); 13 inb(KBD_BUF_PORT); 14 } 15
16 /*键盘初始化*/
17 void keyboard_init(void) 18 { 19 put_str("keyboard init start\n"); 20 register_handler(0x21, intr_keyboard_handler); 21 put_str("keyboard init done\n"); 22 }
1 #ifndef __KERNEL_KEYBOARD_H 2 #define __KERNEL_KEYBOARD_H
3
4 void keyboard_init(void); 5 static void intr_keyboard_handler(void); 6 #endif
1 ... 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 done\n"); 22 } 23
24 ...
最后编译运行，可以看到我们一旦按下按键，屏幕便会打印信息，而且释放按键也会打印信息。当然这是后面需要讲解的内容，总之到现在，我们已经成功实现了按键的中断处理函数。
现在来说说为什么按下按键和释放按键都会触发中断。其实这是硬件所决定的，一个键的状态要么是按下，要么是弹起，因此一个按键有两个编码，按键被按下时的编码是通码，按键被释放时的编码是断码。
无论是按下键或是松开键，当键的状态改变后，键盘中的8048芯片把按键对应的扫描码（通码或者断码）发送到主板上的8042芯片，由8042处理后保存在自己的寄存器中，然后向8259A发送中断信号，这样处理器便去执行键盘中断处理程序，将8042处理过的扫描码从它的寄存器中读取出来，随后将扫描码转换成对应的ASCII码。
所以我们的函数中需要自己完善这么一个映射关系，也就是扫描码到ASCII码的映射。这里就偷懒直接抄书上的，我也没有去仔细看了，总之能知道整个流程就行了。
所以进一步完善我们的keyboard.c文件如下。
1 #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 '\033'
13 #define backspace '\b'
14 #define tab '\t'
15 #define enter '\r'
16 #define delete '\0177'
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 start\n"); 178 register_handler(0x21, intr_keyboard_handler); 179 put_str("keyboard init done\n"); 180 }
此时可以发现，我们在键盘上按下键，屏幕上能相应地输出字符。
虽然我们已经实现了键盘驱动，但是目前能实现的功能仅仅是在屏幕上输出我们所按下的按键，但是并没有什么实用的地方。我们在键盘上操作是为了能和系统进行交互，而交互过程一般都是键入各种shell命令，然后shell解析并且执行。
所以我们需要实现一个缓冲区，在按键的中断处理函数中将输入的按键信息保存在缓冲区中，将来实现的shell进程在该缓冲区中读取数据并且输出到屏幕上，等到我们按下了回车后，就将前面读取到的字符解析去处理。虽然我们还没有实现shell进程，但是我们可以新建线程来读取数据，测试缓冲区的功能。
所以下面的代码便是实现缓冲区，在project/kernel目录下新建ioqueue.c和ioqueue.h文件。
1 #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 }
1 #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文件，我们前面只开启了键盘中断，现在加入线程调度，所以需要开启时钟中断。修改的代码一并如下：
1 ... 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 done\n"); 22 } 23
24 ...
1 #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 KERNEL\n"); 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 }
1 #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
1 #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_all\n"); 14 idt_init(); 15 timer_init(); 16 mem_init(); 17 thread_init(); 18 console_init(); 19 keyboard_init(); 20 }
1 #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 '\033'
13 #define backspace '\b'
14 #define tab '\t'
15 #define enter '\r'
16 #define delete '\0177'
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 key\n"); 185 } 186 return; 187 } 188
189
190 /*键盘初始化*/
191 void keyboard_init(void) 192 { 193 put_str("keyboard init start\n"); 194 ioqueue_init(&kbd_buf); 195 register_handler(0x21, intr_keyboard_handler); 196 put_str("keyboard init done\n"); 197 }
本回到此结束，预知后事如何，请看下回分解。