keyboard: interrupt routed through APIC

82marbag · wipawel · commit 288ee4fc2364 · 2020-11-10T14:33:50.000+01:00
The keyboard interrupt is routed to the local cpu using APIC

Signed-off-by: Daniele Ahmed &lt;ahmeddan amazon c;om &gt;
diff --git a/arch/x86/traps.c b/arch/x86/traps.c
@@ -162,7 +162,7 @@ void init_traps(unsigned int cpu) {
                   _ul(asm_interrupt_handler_uart), GATE_DPL0, GATE_PRESENT, 0);
     set_intr_gate(&percpu->idt[PIT_IRQ0_OFFSET], __KERN_CS,
                   _ul(asm_interrupt_handler_pit), GATE_DPL0, GATE_PRESENT, 0);
-    set_intr_gate(&percpu->idt[KEYBOARD_IRQ0_OFFSET], __KERN_CS,
+    set_intr_gate(&percpu->idt[KEYBOARD_PORT1_IRQ0_OFFSET], __KERN_CS,
                   _ul(asm_interrupt_handler_keyboard), GATE_DPL0, GATE_PRESENT, 0);
 
     barrier();
diff --git a/common/kernel.c b/common/kernel.c
@@ -67,6 +67,5 @@ void kernel_main(void) {
 
     printk("All tasks done.\n");
 
-    while (1)
-        echo_loop();
+    echo_loop();
 }
diff --git a/common/setup.c b/common/setup.c
@@ -237,7 +237,7 @@ void __noreturn __text_init kernel_start(uint32_t multiboot_magic,
     init_pit(get_bsp_cpu_id());
 
     /* Initialize keyboard */
-    init_keyboard();
+    init_keyboard(get_bsp_cpu_id());
 
     /* Jump from .text.init section to .text */
     asm volatile("push %0; ret" ::"r"(&kernel_main));
diff --git a/drivers/keyboard.c b/drivers/keyboard.c
@@ -22,78 +22,103 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+#include <apic.h>
 #include <drivers/keyboard.h>
 #include <drivers/pic.h>
+#include <ioapic.h>
 #include <lib.h>
 #include <string.h>
 
-static struct {
-    int shift, caps, ctrl, alt;
+/* clang-format off */
+static const unsigned char key_map[] = { /* map scan code to key */
+    0xff,        SCAN_ESC,  '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=',
+    '\b',        '\t',      'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']',
+    SCAN_ENTER,  SCAN_CTRL, 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', '\'', '`',
+    SCAN_LSHIFT, '\\',      'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/',
+    SCAN_RSHIFT, 0x37, SCAN_ALT, ' ', SCAN_CAPS,
+    SCAN_F1, SCAN_F2, SCAN_F3, SCAN_F4, SCAN_F5, SCAN_F6, SCAN_F7, SCAN_F8, SCAN_F9, SCAN_F10,
+    SCAN_NUMLOCK, SCAN_SCROLLLOCK, SCAN_HOME, SCAN_UP, SCAN_PAGEUP, 0x4a, SCAN_LEFT,
+    SCAN_KEYPAD5, SCAN_RIGHT, 0x4e, SCAN_END, SCAN_DOWN, SCAN_PAGEDOWN, SCAN_INS, SCAN_DEL,
+    0x54, SCAN_F11, 0x56, 0x57, SCAN_F12
+};
+
+static const unsigned char key_map_up[] = { /* map scan code to upper key */
+    0xff,        SCAN_ESC,  '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+',
+    '\b',        '\t',      'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}',
+    SCAN_ENTER,  SCAN_CTRL, 'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':', '"', '~',
+    SCAN_LSHIFT, '|',       'Z', 'X', 'C', 'V', 'B', 'N', 'M', '<', '>', '?'};
+/* clang-format on */
+
+struct keyboard_state {
+    bool shift, caps, ctrl, alt;
 
     char buf[KEY_BUF];
     unsigned curr;
     unsigned init;
-} keyboard_state;
+};
+typedef struct keyboard_state keyboard_state_t;
 
-void init_keyboard() {
+static keyboard_state_t keyboard_state;
+
+void init_keyboard(uint8_t dst_cpus) {
     printk("Initializing keyboard driver\n");
 
     /* Disable devices */
-    outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_DISABLE_PORT_0);
     outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_DISABLE_PORT_1);
+    outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_DISABLE_PORT_2);
 
     /* Flush output buffer */
     while (inb(KEYBOARD_PORT_DATA) & KEYBOARD_STATUS_OUT_FULL)
         ; /* discard leftover bytes */
 
     /* Controller configuration */
-    char current_status;
-    int dual_channel;
+    keyboard_controller_config_t current_status;
+    bool dual_channel;
 
     /* Read controller config */
     outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_READ_CONFIGURATION);
-    current_status = inb(KEYBOARD_PORT_DATA);
+    current_status.config = inb(KEYBOARD_PORT_DATA);
+
+    dual_channel = current_status.clock2 == 0 ? 1 : 0; /* second channel enabled if 0 */
+
+    printk("Current PS/2 status before: %x\n", current_status.config);
 
-    dual_channel = !!(current_status & (1 << KEYBOARD_CONTROLLER_CONFIG_BIT_CLOCK_1));
-    printk("Current PS/2 status before: %x\n", current_status);
     /* Disable IRQs and translation */
-    current_status = current_status &
-                     ~(1 << KEYBOARD_CONTROLLER_CONFIG_BIT_PORT_0_INTERRUPT) &
-                     ~(1 << KEYBOARD_CONTROLLER_CONFIG_BIT_PORT_1_INTERRUPT) &
-                     ~(1 << KEYBOARD_CONTROLLER_CONFIG_BIT_TRANSLATION);
+    current_status.port1_int = 0;
+    current_status.port2_int = 0;
+    current_status.translation = 0;
+
     /* Write controller config */
     outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_WRITE_CONFIGURATION);
-    outb(KEYBOARD_PORT_DATA, current_status);
+    outb(KEYBOARD_PORT_DATA, current_status.config);
 
-    printk("Current PS/2 status after mods: %x\n", current_status);
+    printk("Current PS/2 status after mods: %x\n", current_status.config);
     printk("PS/2 dual channel? %d\n", dual_channel);
 
     /* Controller self test */
     outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_SELF_TEST);
     if (inb(KEYBOARD_PORT_DATA) != KEYBOARD_RES_SELF_TEST) {
-        printk("Self test did not succed\n");
+        printk("Self test did not succeed\n");
         return;
     }
 
     /* Determine whether second channel exists */
     if (dual_channel) {
-        printk("Enabling second PS/2 port\n");
-        outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_ENABLE_PORT_1);
+        outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_ENABLE_PORT_2);
         outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_READ_CONFIGURATION);
-        current_status = inb(KEYBOARD_PORT_DATA);
-        dual_channel =
-            (current_status & (1 << KEYBOARD_CONTROLLER_CONFIG_BIT_CLOCK_1)) == 0;
+        current_status.config = inb(KEYBOARD_PORT_DATA);
+        dual_channel = current_status.clock2 == 0 ? 1 : 0;
     }
     if (dual_channel)
-        outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_DISABLE_PORT_1);
+        outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_DISABLE_PORT_2);
 
     /* Interface tests */
     int port1, port2 = 0;
-    outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_TEST_PORT_0);
-    port1 = inb(KEYBOARD_PORT_DATA) == 0;
+    outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_TEST_PORT_1);
+    port1 = inb(KEYBOARD_PORT_DATA) == 0 ? 1 : 0;
     if (dual_channel) {
-        outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_TEST_PORT_1);
-        port2 = inb(KEYBOARD_PORT_DATA) == 0;
+        outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_TEST_PORT_2);
+        port2 = inb(KEYBOARD_PORT_DATA) == 0 ? 1 : 0;
     }
 
     printk("Port1 available? %d - port2 available? %d\n", port1, port2);
@@ -105,25 +130,25 @@ void init_keyboard() {
     /* Enable devices */
     if (port1) {
         printk("Keyboard: enabling first channel\n");
-        current_status = current_status |
-                         (1 << KEYBOARD_CONTROLLER_CONFIG_BIT_PORT_0_INTERRUPT) |
-                         (1 << KEYBOARD_CONTROLLER_CONFIG_BIT_CLOCK_1) |
-                         (1 << KEYBOARD_CONTROLLER_CONFIG_BIT_TRANSLATION);
+        current_status.port1_int = 1;
+        current_status.clock2 = 1; /* disable second port clock */
+        current_status.translation = 1;
         outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_WRITE_CONFIGURATION);
-        outb(KEYBOARD_PORT_DATA, current_status);
+        outb(KEYBOARD_PORT_DATA, current_status.config);
 
-        pic_enable_irq(PIC1_DEVICE_SEL, KEYBOARD_IRQ);
-        outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_ENABLE_PORT_0);
+        configure_isa_irq(KEYBOARD_PORT1_IRQ, KEYBOARD_PORT1_IRQ0_OFFSET,
+                          IOAPIC_DEST_MODE_PHYSICAL, dst_cpus);
+        outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_ENABLE_PORT_1);
     }
     else {
         printk("Keyboard: enabling second channel\n");
-        current_status =
-            current_status | (1 << KEYBOARD_CONTROLLER_CONFIG_BIT_PORT_1_INTERRUPT);
+        current_status.port2_int = 1;
         outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_WRITE_CONFIGURATION);
-        outb(KEYBOARD_PORT_DATA, current_status);
+        outb(KEYBOARD_PORT_DATA, current_status.config);
 
-        pic_enable_irq(PIC1_DEVICE_SEL, KEYBOARD_IRQ_2);
-        outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_ENABLE_PORT_1);
+        configure_isa_irq(KEYBOARD_PORT2_IRQ, KEYBOARD_PORT2_IRQ0_OFFSET,
+                          IOAPIC_DEST_MODE_PHYSICAL, dst_cpus);
+        outb(KEYBOARD_PORT_CMD, KEYBOARD_CMD_ENABLE_PORT_2);
     }
 
     memset(&keyboard_state, 0, sizeof(keyboard_state));
@@ -164,13 +189,12 @@ unsigned int keyboard_process_keys(void) {
 
 void keyboard_interrupt_handler(void) {
     unsigned char status;
-    int released;
 
     status = inb(KEYBOARD_PORT_CMD);
     if (status & KEYBOARD_STATUS_OUT_FULL) {
         char scan = inb(KEYBOARD_PORT_DATA);
+        int released = !!(scan & SCAN_RELEASE_MASK);
 
-        released = !!(scan & SCAN_RELEASE_MASK);
         scan = scan & (SCAN_RELEASE_MASK - 1);
 
         switch (scan) {
@@ -199,5 +223,5 @@ void keyboard_interrupt_handler(void) {
         }
     }
 
-    outb(PIC1_PORT_CMD, PIC_EOI);
+    apic_EOI();
 }
diff --git a/include/drivers/keyboard.h b/include/drivers/keyboard.h
@@ -30,106 +30,93 @@
 #define KEYBOARD_PORT_CMD  0x64 /* keyboard command port */
 #define KEYBOARD_PORT_DATA 0x60 /* keyboard data port */
 
-#define KEYBOARD_IRQ   0x01
-#define KEYBOARD_IRQ_2 0x04 /* Second port */
-#define KEYBOARD_IRQ0_OFFSET                                                             \
-    (PIC_IRQ0_OFFSET + KEYBOARD_IRQ) /* keyboard first channel irq offset */
-#define KEYBOARD_2_IRQ0_OFFSET (PIC_IRQ0_OFFSET + KEYBOARD_IRQ_2)
+#define KEYBOARD_PORT1_IRQ 0x01
+#define KEYBOARD_PORT2_IRQ 0x04 /* Second port */
+#define KEYBOARD_PORT1_IRQ0_OFFSET                                                       \
+    (PIC_IRQ0_OFFSET + KEYBOARD_PORT1_IRQ) /* keyboard first channel irq offset */
+#define KEYBOARD_PORT2_IRQ0_OFFSET (PIC_IRQ0_OFFSET + KEYBOARD_PORT2_IRQ)
 
 #define KEYBOARD_STATUS_OUT_FULL 0x01 /* bit set when the keyboard buffer is full */
 
 enum {
     KEYBOARD_CMD_WRITE_CONFIGURATION = 0x60, /* Write configuration byte */
     KEYBOARD_CMD_READ_CONFIGURATION = 0x20,  /* Read configuration byte */
     KEYBOARD_CMD_SELF_TEST = 0xAA,
-    KEYBOARD_CMD_TEST_PORT_0 = 0xAB,
-    KEYBOARD_CMD_TEST_PORT_1 = 0xA9,
-    KEYBOARD_CMD_DISABLE_PORT_0 = 0xAD,
-    KEYBOARD_CMD_DISABLE_PORT_1 = 0xA7,
-    KEYBOARD_CMD_ENABLE_PORT_0 = 0xAE,
-    KEYBOARD_CMD_ENABLE_PORT_1 = 0xA8,
+    KEYBOARD_CMD_TEST_PORT_1 = 0xAB,
+    KEYBOARD_CMD_TEST_PORT_2 = 0xA9,
+    KEYBOARD_CMD_DISABLE_PORT_1 = 0xAD,
+    KEYBOARD_CMD_DISABLE_PORT_2 = 0xA7,
+    KEYBOARD_CMD_ENABLE_PORT_1 = 0xAE,
+    KEYBOARD_CMD_ENABLE_PORT_2 = 0xA8,
 } keyboard_cmd;
 typedef enum keyboard_cmd keyboard_cmd_t;
 
-enum {
-    KEYBOARD_RES_SELF_TEST = 0x55,
-} keyboard_res;
+#define KEYBOARD_RES_SELF_TEST 0x55
 
-enum {
-    KEYBOARD_CONTROLLER_CONFIG_BIT_PORT_0_INTERRUPT,
-    KEYBOARD_CONTROLLER_CONFIG_BIT_PORT_1_INTERRUPT,
-    KEYBOARD_CONTROLLER_CONFIG_BIT_SYS_FLAG,
-    KEYBOARD_CONTROLLER_CONFIG_BIT_ZERO,
-    KEYBOARD_CONTROLLER_CONFIG_BIT_CLOCK_0,
-    KEYBOARD_CONTROLLER_CONFIG_BIT_CLOCK_1,
-    KEYBOARD_CONTROLLER_CONFIG_BIT_TRANSLATION,
-    KEYBOARD_CONTROLLER_CONFIG_BIT_ZERO_,
-} keyboard_controller_config_byte;
-typedef enum keyboard_controller_config_byte keyboard_controller_config_byte_t;
+union keyboard_controller_config {
+    struct {
+        /* clang-format off */
+        uint8_t port1_int : 1,
+                port2_int : 1,
+                sys_flag : 1,
+                zero0 : 1,
+                clock1 : 1,
+                clock2 : 1,
+                translation : 1,
+                zero1 : 1;
+        /* clang-format on */
+    } __packed;
+    uint8_t config;
+};
+typedef union keyboard_controller_config keyboard_controller_config_t;
 
 #define KEY_BUF 80 /* size of internal input buffer */
 
 #define SCAN_RELEASE_MASK 0x80 /* bit set on key release */
 
 #define KEY_NULL 0x00 /* no key */
 
-/* scan codes */
-#define SCAN_NULL       0x0
-#define SCAN_ESC        0x1
-#define SCAN_ENTER      0x1c
-#define SCAN_CTRL       0x1d
-#define SCAN_LSHIFT     0x2a
-#define SCAN_RSHIFT     0x36
-#define SCAN_ALT        0x38
-#define SCAN_CAPS       0x3a
-#define SCAN_F1         0x3b
-#define SCAN_F2         0x3c
-#define SCAN_F3         0x3d
-#define SCAN_F4         0x3e
-#define SCAN_F5         0x3f
-#define SCAN_F6         0x40
-#define SCAN_F7         0x41
-#define SCAN_F8         0x42
-#define SCAN_F9         0x43
-#define SCAN_F10        0x44
-#define SCAN_F11        0x55
-#define SCAN_F12        0x58
-#define SCAN_NUMLOCK    0x45
-#define SCAN_SCROLLLOCK 0x46
-#define SCAN_HOME       0x47
-#define SCAN_UP         0x48
-#define SCAN_PAGEUP     0x49
-#define SCAN_LEFT       0x4b
-#define SCAN_KEYPAD5    0x4c
-#define SCAN_RIGHT      0x4d
-#define SCAN_END        0x4f
-#define SCAN_DOWN       0x50
-#define SCAN_PAGEDOWN   0x51
-#define SCAN_INS        0x52
-#define SCAN_DEL        0x53
-
-void init_keyboard();
-void keyboard_interrupt_handler(void);
-unsigned int keyboard_process_keys(void);
-
-/* clang-format off */
-static const unsigned char key_map[] = { /* map scan code to key */
-    0xff,        SCAN_ESC,  '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=',
-    '\b',        '\t',      'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']',
-    SCAN_ENTER,  SCAN_CTRL, 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', '\'', '`',
-    SCAN_LSHIFT, '\\',      'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/',
-    SCAN_RSHIFT, 0x37, SCAN_ALT, ' ', SCAN_CAPS,
-    SCAN_F1, SCAN_F2, SCAN_F3, SCAN_F4, SCAN_F5, SCAN_F6, SCAN_F7, SCAN_F8, SCAN_F9, SCAN_F10,
-    SCAN_NUMLOCK, SCAN_SCROLLLOCK, SCAN_HOME, SCAN_UP, SCAN_PAGEUP, 0x4a, SCAN_LEFT,
-    SCAN_KEYPAD5, SCAN_RIGHT, 0x4e, SCAN_END, SCAN_DOWN, SCAN_PAGEDOWN, SCAN_INS, SCAN_DEL,
-    0x54, SCAN_F11, 0x56, 0x57, SCAN_F12
+enum scan_code {
+    SCAN_NULL = 0x00,
+    SCAN_ESC = 0x01,
+    SCAN_ENTER = 0x1c,
+    SCAN_CTRL = 0x1d,
+    SCAN_LSHIFT = 0x2a,
+    SCAN_RSHIFT = 0x36,
+    SCAN_ALT = 0x38,
+    SCAN_CAPS = 0x3a,
+    SCAN_F1 = 0x3b,
+    SCAN_F2 = 0x3c,
+    SCAN_F3 = 0x3d,
+    SCAN_F4 = 0x3e,
+    SCAN_F5 = 0x3f,
+    SCAN_F6 = 0x40,
+    SCAN_F7 = 0x41,
+    SCAN_F8 = 0x42,
+    SCAN_F9 = 0x43,
+    SCAN_F10 = 0x44,
+    SCAN_F11 = 0x55,
+    SCAN_F12 = 0x58,
+    SCAN_NUMLOCK = 0x45,
+    SCAN_SCROLLLOCK = 0x46,
+    SCAN_HOME = 0x47,
+    SCAN_UP = 0x48,
+    SCAN_PAGEUP = 0x49,
+    SCAN_LEFT = 0x4b,
+    SCAN_KEYPAD5 = 0x4c,
+    SCAN_RIGHT = 0x4d,
+    SCAN_END = 0x4f,
+    SCAN_DOWN = 0x50,
+    SCAN_PAGEDOWN = 0x51,
+    SCAN_INS = 0x52,
+    SCAN_DEL = 0x53
 };
+typedef enum scan_code scan_code_t;
+
+/* External Declarations */
 
-static const unsigned char key_map_up[] = { /* map scan code to upper key */
-    0xff,        SCAN_ESC,  '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+',
-    '\b',        '\t',      'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}',
-    SCAN_ENTER,  SCAN_CTRL, 'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':', '"', '~',
-    SCAN_LSHIFT, '|',       'Z', 'X', 'C', 'V', 'B', 'N', 'M', '<', '>', '?'};
-/* clang-format on */
+extern void init_keyboard(uint8_t dst_cpus);
+extern void keyboard_interrupt_handler(void);
+extern unsigned int keyboard_process_keys(void);
 
 #endif

Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,5 @@ void kernel_main(void) {`
`67`	`67`
`68`	`68`	`printk("All tasks done.\n");`
`69`	`69`
`70`		`- while (1)`
`71`		`- echo_loop();`
	`70`	`+ echo_loop();`
`72`	`71`	`}`