now delivers keycodes. prone to random lockup

Author: braindigitalis

include/keyboard.h

@@ -134,3 +134,13 @@ void load_keymap_from_string(const char* text);
 bool key_waiting();
 
 _Noreturn void reboot(void);
+
+/**
+ * @brief Push a keyboard scan code into the keyboard buffer.
+ *
+ * This is a generic input function that can be fed by the
+ * PS2 keyboard interrupt, XHCI HID, a spool file, or whatever.
+ *
+ * @param sc Scan code
+ */
+void keyboard_process_scancode_input(uint8_t sc);

include/usb_hid.h

@@ -1,4 +1,3 @@
-/* usb_hid.h */
 #pragma once
 #include <kernel.h>
 #include "usb_core.h"

include/usb_xhci.h

@@ -78,6 +78,7 @@ struct usb_ep {
 
 /* bits in TRB dword3 */
 #define TRB_CYCLE           (1u << 0)
+#define TRB_TOGGLE          (1u << 1)
 #define TRB_ENT             (1u << 1)
 #define TRB_ISP             (1u << 2)
 #define TRB_NS              (1u << 3)
@@ -94,18 +95,8 @@ struct usb_ep {
 #define PORTSC_PRC   (1u << 21)  /* Port Reset Change */
 #define PORTSC_PLC   (1u << 22)  /* Port Link State Change */
 #define PORTSC_CEC   (1u << 23)  /* Port Config Error Change */
-#define PORTSC_PED   (1u <<1)    /* Port enable/disable */
 
-#define PORTSC_RW1C_MASK (PORTSC_CSC | PORTSC_PEC | PORTSC_WRC | \
-                          PORTSC_OCC | PORTSC_PRC | PORTSC_PLC | PORTSC_CEC)
-
-#define XHCI_OP_USBCMD     0x00
-#define XHCI_OP_USBSTS     0x04
-
-#define XHCI_DNCTRL 0x14
-
-/* Toggle Cycle (TC) for Link TRBs (matches xHCI spec & libpayload usage) */
-#define TRB_TOGGLE (1u << 1)
+#define PORTSC_RW1C_MASK (PORTSC_CSC | PORTSC_PEC | PORTSC_WRC | PORTSC_OCC | PORTSC_PRC | PORTSC_PLC | PORTSC_CEC)
 
 /* helper macros to build TRB fields */
 #define TRB_SET_TYPE(x)     ((uint32_t)((x) & 0x3Fu) << 10)
@@ -210,7 +201,7 @@ struct xhci_hc {
 		int speed;
 
 		uint8_t  *ctrl_dma;        // low-memory bounce for ctrl DATA stage
-		uint64_t  ctrl_dma_phys;   // same value as virtual in your setup
+		uint64_t  ctrl_dma_phys;   // same value as virtual
 		uint16_t  ctrl_dma_sz;     // size of the bounce buffer
 
 		/* interrupt IN endpoint discovery (from config desc) */

src/keyboard.c

@@ -312,18 +312,7 @@ static void push_to_buffer(char x) {
 	}
 }
 
-void keyboard_handler(uint8_t isr, uint64_t errorcode, uint64_t irq, void *opaque) {
-
-	uint8_t st = inb(0x64);
-	if ((st & 0x01) == 0) {
-		return; /* no data */
-	}
-	if (st & 0x20) {
-		return; /* AUX (mouse) byte pending: leave it */
-	}
-
-	uint8_t sc = inb(0x60);
-
+void keyboard_process_scancode_input(uint8_t sc) {
 	if (sc == 0xE0) {
 		escaped = true;
 		return; /* wait for the next byte */
@@ -382,6 +371,18 @@ void keyboard_handler(uint8_t isr, uint64_t errorcode, uint64_t irq, void *opaqu
 	}
 }
 
+void keyboard_handler(uint8_t isr, uint64_t errorcode, uint64_t irq, void *opaque) {
+
+	uint8_t st = inb(0x64);
+	if ((st & 0x01) == 0) {
+		return; /* no data */
+	}
+	if (st & 0x20) {
+		return; /* AUX (mouse) byte pending: leave it */
+	}
+	keyboard_process_scancode_input(inb(0x60));
+}
+
 bool key_waiting() {
 	return (buffer_read_ptr < buffer_write_ptr);
 }

src/usb/hid.c

@@ -1,40 +1,183 @@
 /* usb_hid.c */
 #include "usb_hid.h"
 
-static void hid_keyboard_report_cb(struct usb_dev *ud, const uint8_t *pkt, uint16_t len) {
-	if (len < 8u) {
-		return;
+static uint8_t last_report[8];
+
+/* sink for raw scancodes (make = code, break = code|0x80) */
+void keyboard_process_scancode_input(uint8_t sc);
+
+/* last 8-byte HID boot report snapshot */
+static uint8_t last_report[8];
+
+static inline void emit_make(uint8_t code)  {
+	if (code) {
+		keyboard_process_scancode_input(code);
+	}
+}
+static inline void emit_break(uint8_t code) {
+	if (code) {
+		keyboard_process_scancode_input((uint8_t)(code | 0x80u));
+	}
+}
+
+/* USB HID Boot Keyboard usage -> PS/2 Set-1 MAKE code (no break bit).
+ * 0 means "unmapped/ignore".
+ */
+static const uint8_t hid_to_set1[0xE8] = {
+	/* Letters a..z (0x04..0x1D) */
+	[0x04]=0x1E, /* A */ [0x05]=0x30, /* B */ [0x06]=0x2E, /* C */ [0x07]=0x20, /* D */
+	[0x08]=0x12, /* E */ [0x09]=0x21, /* F */ [0x0A]=0x22, /* G */ [0x0B]=0x23, /* H */
+	[0x0C]=0x17, /* I */ [0x0D]=0x24, /* J */ [0x0E]=0x25, /* K */ [0x0F]=0x26, /* L */
+	[0x10]=0x32, /* M */ [0x11]=0x31, /* N */ [0x12]=0x18, /* O */ [0x13]=0x19, /* P */
+	[0x14]=0x10, /* Q */ [0x15]=0x13, /* R */ [0x16]=0x1F, /* S */ [0x17]=0x14, /* T */
+	[0x18]=0x16, /* U */ [0x19]=0x2F, /* V */ [0x1A]=0x11, /* W */ [0x1B]=0x2D, /* X */
+	[0x1C]=0x15, /* Y */ [0x1D]=0x2C, /* Z */
+
+	/* Number row 1..0 (0x1E..0x27) */
+	[0x1E]=0x02,[0x1F]=0x03,[0x20]=0x04,[0x21]=0x05,[0x22]=0x06,
+	[0x23]=0x07,[0x24]=0x08,[0x25]=0x09,[0x26]=0x0A,[0x27]=0x0B,
+
+	/* Control / punctuation (0x28..0x38) */
+	[0x28]=0x1C, /* Enter */
+	[0x29]=0x01, /* Escape */
+	[0x2A]=0x0E, /* Backspace */
+	[0x2B]=0x0F, /* Tab */
+	[0x2C]=0x39, /* Space */
+	[0x2D]=0x0C, /* - */
+	[0x2E]=0x0D, /* = */
+	[0x2F]=0x1A, /* [ */
+	[0x30]=0x1B, /* ] */
+	[0x31]=0x2B, /* \ (US) */
+	/* 0x32 = Non-US #/~ (ISO “102nd key”): Set-1 = 0x56 on ISO keyboards */
+	[0x32]=0x56,
+	[0x33]=0x27, /* ; */
+	[0x34]=0x28, /* ' */
+	[0x35]=0x29, /* ` */
+	[0x36]=0x33, /* , */
+	[0x37]=0x34, /* . */
+	[0x38]=0x35, /* / */
+
+	/* Locks & F-keys */
+	[0x39]=0x3A, /* Caps Lock */
+	[0x3A]=0x3B, /* F1  */ [0x3B]=0x3C, /* F2  */ [0x3C]=0x3D, /* F3  */
+	[0x3D]=0x3E, /* F4  */ [0x3E]=0x3F, /* F5  */ [0x3F]=0x40, /* F6  */
+	[0x40]=0x41, /* F7  */ [0x41]=0x42, /* F8  */ [0x42]=0x43, /* F9  */
+	[0x43]=0x44, /* F10 */ [0x44]=0x57, /* F11 */ [0x45]=0x58, /* F12 */
+
+	/* Print/Scroll/Pause */
+	/* [0x46] PrintScreen -> E0 2A E0 37 (complex), leave 0 for now */
+	[0x47]=0x46, /* Scroll Lock */
+	/* [0x48] Pause -> complex, leave unmapped here */
+
+	/* Insert/Home/PgUp/Delete/End/PgDn & arrows (all extended: prefix 0xE0) */
+	[0x49]=0x52, /* Insert  -> E0 52 */
+	[0x4A]=0x47, /* Home    -> E0 47 */
+	[0x4B]=0x49, /* PageUp  -> E0 49 */
+	[0x4C]=0x53, /* Delete  -> E0 53 */
+	[0x4D]=0x4F, /* End     -> E0 4F */
+	[0x4E]=0x51, /* PageDn  -> E0 51 */
+	[0x4F]=0x4D, /* Right   -> E0 4D */
+	[0x50]=0x4B, /* Left    -> E0 4B */
+	[0x51]=0x50, /* Down    -> E0 50 */
+	[0x52]=0x48, /* Up      -> E0 48 */
+
+	/* Keypad cluster */
+	[0x53]=0x45, /* Num Lock */
+	[0x54]=0x35, /* KP /    -> E0 35 (extended) */
+	[0x55]=0x37, /* KP *    */
+	[0x56]=0x4A, /* KP -    */
+	[0x57]=0x4E, /* KP +    */
+	[0x58]=0x1C, /* KP Enter -> E0 1C (extended) */
+	[0x59]=0x4F, /* KP 1 */ [0x5A]=0x50, /* KP 2 */ [0x5B]=0x51, /* KP 3 */
+	[0x5C]=0x4B, /* KP 4 */ [0x5D]=0x4C, /* KP 5 */ [0x5E]=0x4D, /* KP 6 */
+	[0x5F]=0x47, /* KP 7 */ [0x60]=0x48, /* KP 8 */ [0x61]=0x49, /* KP 9 */
+	[0x62]=0x52, /* KP 0 */ [0x63]=0x53, /* KP . */
+
+	/* Application/Menu (extended) & Non-US \| on ISO boards */
+	[0x65]=0x5D, /* Application -> E0 5D */
+
+	/* Modifiers (L* are normal, R* are extended in Set-1) */
+	[0xE0]=0x1D, /* LCtrl */
+	[0xE1]=0x2A, /* LShift */
+	[0xE2]=0x38, /* LAlt */
+	[0xE3]=0x5B, /* LGUI (Win) -> E0 5B */
+	[0xE4]=0x1D, /* RCtrl      -> E0 1D */
+	[0xE5]=0x36, /* RShift */
+	[0xE6]=0x38, /* RAlt (AltGr) -> E0 38 */
+	[0xE7]=0x5C, /* RGUI          -> E0 5C */
+};
+
+/* Which HID usages should be emitted with an 0xE0 prefix in Set-1? */
+static inline int hid_usage_needs_e0(uint8_t u)
+{
+	switch (u) {
+		/* arrows + edit cluster */
+		case 0x49: case 0x4A: case 0x4B: case 0x4C:
+		case 0x4D: case 0x4E: case 0x4F: case 0x50:
+		case 0x51: case 0x52:
+			/* keypad / and Enter */
+		case 0x54: case 0x58:
+			/* right-side modifiers and GUI keys */
+		case 0xE4: case 0xE6: case 0xE3: case 0xE7:
+			return 1;
+		default:
+			return 0;
 	}
-	dprintf("keyboard report cb\n");
-	/* pkt[2..7] are keycodes; translate via simple table, raise input events */
-	/* Minimal: stash last key, push to your input layer. */
 }
 
-/* Call this right after you arm EP1-IN (before “waiting for interrupts”). */
-static void hid_try_get_report_snapshot(struct usb_dev *ud) {
-	uint8_t __attribute__((aligned(64))) setup[8] = {
-		0xA1, 0x01,        /* bmReqType=Class|Interface|IN, bRequest=GET_REPORT */
-		0x01, 0x00,        /* wValue = (ReportType=Input=1)<<8 | ReportID=0 */
-		0x00, 0x00,        /* wIndex = interface 0 */
-		0x08, 0x00         /* wLength = 8 */
-	};
-	uint8_t __attribute__((aligned(64))) buf[8] = {0};
-	int ok = xhci_ctrl_xfer(ud, setup, buf, 8, 1);
-	dprintf("hid: GET_REPORT(Input,id=0) %s, data=%02x %02x %02x %02x %02x %02x %02x %02x\n",
-		ok ? "OK" : "FAIL",
-		buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7]);
+static inline uint8_t hid_usage_to_set1(uint8_t u)
+{
+	return (u < sizeof(hid_to_set1)) ? hid_to_set1[u] : 0;
+}
+
+static int usage_present(const uint8_t *rep, uint8_t usage)
+{
+	for (int i = 2; i < 8; ++i) if (rep[i] == usage) return 1;
+	return 0;
+}
+
+static void process_mod_changes(uint8_t prev_mod, uint8_t cur_mod)
+{
+	uint8_t changed = (uint8_t)(prev_mod ^ cur_mod);
+	while (changed) {
+		uint8_t bit = (uint8_t)(changed & (uint8_t)(-((int8_t)changed)));
+		int idx = __builtin_ctz(changed);             /* 0..7 */
+		uint8_t usage = (uint8_t)(0xE0u + idx);
+		uint8_t make  = hid_usage_to_set1(usage);
+		if (cur_mod & bit) emit_make(make); else emit_break(make);
+		changed = (uint8_t)(changed & (changed - 1));
+	}
 }
 
-static void hid_toggle_numlock(struct usb_dev *ud, int on) {
-	uint8_t __attribute__((aligned(64))) setup[8] = {
-		0x21, 0x09,        /* bmReqType=Class|Interface|OUT, bRequest=SET_REPORT */
-		0x02, 0x00,        /* wValue = (ReportType=Output=2)<<8 | ReportID=0 */
-		0x00, 0x00,        /* wIndex = interface 0 */
-		0x01, 0x00         /* wLength = 1 */
-	};
-	uint8_t __attribute__((aligned(64))) led = (on ? 0x01 : 0x00); /* bit0 = NumLock */
-	int ok = xhci_ctrl_xfer(ud, setup, &led, 1, 0);
-	dprintf("hid: SET_REPORT(Output LED NumLock=%d) %s\n", on, ok ? "OK" : "FAIL");
+static void hid_keyboard_report_cb(struct usb_dev *ud, const uint8_t *pkt, uint16_t len)
+{
+	(void)ud;
+	if (len < 8u) return;
+
+	/* drop identical snapshot (disables HID’s built-in key repeat) */
+	if (memcmp(pkt, last_report, 8) == 0) return;
+
+	/* 1) modifiers (byte 0) */
+	process_mod_changes(last_report[0], pkt[0]);
+
+	/* 2) key array (bytes 2..7): releases first… */
+	for (int i = 2; i < 8; ++i) {
+		uint8_t u = last_report[i];
+		if (u && !usage_present(pkt, u)) {
+			uint8_t mk = hid_usage_to_set1(u);
+			emit_break(mk);
+		}
+	}
+	/* …then presses */
+	for (int i = 2; i < 8; ++i) {
+		uint8_t u = pkt[i];
+		if (u && !usage_present(last_report, u)) {
+			uint8_t mk = hid_usage_to_set1(u);
+			emit_make(mk);
+		}
+	}
+
+	memcpy(last_report, pkt, 8);
 }
 
 static void hid_on_device_added(const struct usb_dev *ud_c)
@@ -43,11 +186,8 @@ static void hid_on_device_added(const struct usb_dev *ud_c)
 	if (!ud_c) return;
 
 	/* Only handle HID Boot Keyboard */
-	if (!(ud_c->dev_class == USB_CLASS_HID &&
-	      ud_c->dev_subclass == USB_SUBCLASS_BOOT &&
-	      ud_c->dev_proto == USB_PROTO_KEYBOARD)) {
-		dprintf("hid: ignore dev class=%02x sub=%02x proto=%02x\n",
-			ud_c->dev_class, ud_c->dev_subclass, ud_c->dev_proto);
+	if (!(ud_c->dev_class == USB_CLASS_HID && ud_c->dev_subclass == USB_SUBCLASS_BOOT && ud_c->dev_proto == USB_PROTO_KEYBOARD)) {
+		dprintf("hid: ignore dev class=%02x sub=%02x proto=%02x\n", ud_c->dev_class, ud_c->dev_subclass, ud_c->dev_proto);
 		return;
 	}
 
@@ -102,9 +242,6 @@ static void hid_on_device_added(const struct usb_dev *ud_c)
 		return;
 	}
 	dprintf("hid: keyboard armed (EP1 IN), waiting for interrupts\n");
-
-	hid_try_get_report_snapshot(ud);
-	hid_toggle_numlock(ud, 1);
 }
 
 static void hid_on_device_removed(const struct usb_dev *ud) {