xircon/Nanite
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Vastly Improve the Keyboard Driver

Browse Source
This commit is contained in:
Tyler McGurrin 2025-06-04 09:59:53 -04:00
parent 6987737813
commit 8490ef9449
8 changed files with 168 additions and 486 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

434
src/kernel/dri/keyboard.c
View File

@ -5,349 +5,109 @@
\*----------------*/
#include "keyboard.h"
#include <stdint.h>
#include <stdbool.h>
#include <arch/i686/irq.h>
#include <arch/i686/io.h>
#include <dri/serial.h>
#include <stdio.h>
void Print_Key(int scancode) {
char* key;
switch (scancode) {
bool _keyboard_disable;
bool _numlock, _capslock, _scrolllock;
bool _ctrl, _alt, _shift;
case KEYSCAN_1:
key = "1";
break;
uint8_t _keyboard_scancode;
case KEYSCAN_2:
key = "2";
break;
case KEYSCAN_3:
key = "3";
break;
case KEYSCAN_4:
key = "4";
break;
case KEYSCAN_5:
key = "5";
break;
case KEYSCAN_6:
key = "6";
break;
case KEYSCAN_7:
key = "7";
break;
case KEYSCAN_8:
key = "8";
break;
case KEYSCAN_9:
key = "9";
break;
case KEYSCAN_0:
key = "0";
break;
case KEYSCAN_Minus:
key = "-";
break;
case KEYSCAN_Equals:
key = "=";
break;
case KEYSCAN_Q:
key = "q";
break;
case KEYSCAN_W:
key = "w";
break;
case KEYSCAN_E:
key = "e";
break;
case KEYSCAN_R:
key = "r";
break;
case KEYSCAN_T:
key = "t";
break;
case KEYSCAN_Y:
key = "y";
break;
case KEYSCAN_U:
key = "u";
break;
case KEYSCAN_I:
key = "i";
break;
case KEYSCAN_O:
key = "o";
break;
case KEYSCAN_P:
key = "p";
break;
case KEYSCAN_LeftBracket:
key = "[";
break;
case KEYSCAN_RightBracket:
key = "]";
break;
case KEYSCAN_A:
key = "a";
break;
case KEYSCAN_S:
key = "s";
break;
case KEYSCAN_D:
key = "d";
break;
case KEYSCAN_F:
key = "f";
break;
case KEYSCAN_G:
key = "g";
break;
case KEYSCAN_H:
key = "h";
break;
case KEYSCAN_J:
key = "j";
break;
case KEYSCAN_K:
key = "k";
break;
case KEYSCAN_L:
key = "l";
break;
case KEYSCAN_Semicolon:
key = ";";
break;
case KEYSCAN_Apostrophe:
key = "'";
break;
case KEYSCAN_Grave:
key = "`";
break;
case KEYSCAN_Backslash:
key = "\\";
break;
case KEYSCAN_Z:
key = "z";
break;
case KEYSCAN_X:
key = "x";
break;
case KEYSCAN_C:
key = "c";
break;
case KEYSCAN_V:
key = "v";
break;
case KEYSCAN_B:
key = "b";
break;
case KEYSCAN_N:
key = "n";
break;
case KEYSCAN_M:
key = "m";
break;
case KEYSCAN_Comma:
key = ",";
break;
case KEYSCAN_Period:
key = ".";
break;
case KEYSCAN_Forwardslash:
key = "/";
break;
case KEYSCAN_Space:
key = " ";
break;
case KEYSCAN_Enter:
key = "\n";
break;
case KEYSCAN_BackSpace:
key = "\b \b";
break;
case KEYSCAN_Tab:
key = "\t";
break;
case KEYSCAN_CTRL:
key = "";
break;
case KEYSCAN_LShift:
key = "";
break;
case KEYSCAN_RShift:
key = "";
break;
case KEYSCAN_PrtSc:
key = "";
break;
case KEYSCAN_Alt:
key = "";
break;
case KEYSCAN_Caps:
key = "";
break;
case KEYSCAN_F1:
key = "";
break;
case KEYSCAN_F2:
key = "";
break;
case KEYSCAN_F3:
key = "";
break;
case KEYSCAN_F4:
key = "";
break;
case KEYSCAN_F5:
key = "";
break;
case KEYSCAN_F6:
key = "";
break;
case KEYSCAN_F7:
key = "";
break;
case KEYSCAN_F8:
key = "";
break;
case KEYSCAN_F9:
key = "";
break;
case KEYSCAN_F10:
key = "";
break;
case KEYSCAN_Num:
key = "";
break;
case KEYSCAN_Scroll:
key = "";
break;
case KEYSCAN_Home:
key = "";
break;
case KEYSCAN_Up:
key = "";
break;
case KEYSCAN_PgUp:
key = "";
break;
case KEYSCAN_Minus2:
key = "";
break;
case KEYSCAN_Left:
key = "";
break;
case KEYSCAN_Center:
key = "";
break;
case KEYSCAN_Right:
key = "";
break;
case KEYSCAN_Plus:
key = "";
break;
case KEYSCAN_End:
key = "";
break;
case KEYSCAN_Down:
key = "";
break;
case KEYSCAN_PgDn:
key = "";
break;
case KEYSCAN_Ins:
key = "";
break;
case KEYSCAN_Delete:
key = "";
break;
case KEYSCAN_ESC:
key = "";
break;
default:
break;
extern uint16_t DEBUG_COM_PORT;
void Keyboard_Handler()
{
_keyboard_scancode = inb(KEYBOARD_ENC_INPUT_BUF);
Serial_Printf(DEBUG_COM_PORT, "KEYBOARD:> Scancode %u Character %s\n", _keyboard_scancode);
}
printf("%s", key);
uint8_t Keyboard_Controller_Status()
{
return inb (KEYBOARD_CTRL_STATS_REG);
}
uint8_t Keyboard_Read_Encoder_Buffer()
{
return inb (KEYBOARD_ENC_INPUT_BUF);
}
void Keyboard_Controller_Send_Command(uint8_t command)
{
// wait for controller input buffer to be clear
Serial_Printf(DEBUG_COM_PORT, "KEYBOARD:> Sending Command %u To Controller.\n", command);
while (1)
if ( (Keyboard_Controller_Status() & KEYBOARD_CTRL_STATS_MASK_IN_BUF) == 0)
break;
outb (KEYBOARD_CTRL_CMD_REG, command);
}
void Keyboard_Encoder_Send_Command(uint8_t command)
{
// wait for controller input buffer to be clear
Serial_Printf(DEBUG_COM_PORT, "KEYBOARD:> Sending Command %u To Encoder.\n", command);
while (1)
if ( (Keyboard_Controller_Status() & KEYBOARD_CTRL_STATS_MASK_IN_BUF) == 0)
break;
// send command byte to KEYBOARD encoder
outb (KEYBOARD_ENC_CMD_REG, command);
}
void Keyboard_Set_Lock_LEDs(bool num, bool caps, bool scroll)
{
uint8_t data = 0;
data = (scroll) ? (data | 1) : (data & 1);
data = (num) ? (num | 2) : (num & 2);
data = (caps) ? (num | 4) : (num & 4);
Keyboard_Encoder_Send_Command(KEYBOARD_ENC_CMD_SET_LED);
Keyboard_Encoder_Send_Command(data);
}
bool Keyboard_Self_Test()
{
Keyboard_Controller_Send_Command(KEYBOARD_CTRL_CMD_SELF_TEST);
while (1)
if (Keyboard_Controller_Status() & KEYBOARD_CTRL_STATS_MASK_OUT_BUF)
break;
return (Keyboard_Read_Encoder_Buffer() == 0x55) ? true : false;
}
void Keyboard_Disable()
{
Keyboard_Controller_Send_Command(KEYBOARD_CTRL_CMD_DISABLE);
_keyboard_disable = true;
Serial_Printf(DEBUG_COM_PORT, "KEYBOARD:> Disabled Input.\n");
}
void Keyboard_Enable()
{
Keyboard_Controller_Send_Command(KEYBOARD_CTRL_CMD_ENABLE);
_keyboard_disable = false;
Serial_Printf(DEBUG_COM_PORT, "KEYBOARD:> Enabled Input.\n");
}
void Keyboard_Reset_System()
{
//! writes 11111110 to the output port (sets reset system line low)
Keyboard_Controller_Send_Command(KEYBOARD_CTRL_CMD_WRITE_OUT_PORT);
Keyboard_Encoder_Send_Command(0xfe);
}
void Keyboard_Init()
{
// set lock keys and led lights
_numlock = _scrolllock = _capslock = false;
Keyboard_Set_Lock_LEDs(false, false, false);
// shift, ctrl, and alt keys
_shift = _alt = _ctrl = false;
}

142
src/kernel/dri/keyboard.h
View File

@ -5,92 +5,56 @@
\*----------------*/
#pragma once
void Print_Key(int scancode);
// Scancodes for a QWERTY layout;
// Will add support for alt layouts like for example DVORAK (my layout of choice)
// Kinda need to tbh, cuz even with QEMU i can't type lolololol
typedef enum {
KEYSCAN_ESC = 1 ,
KEYSCAN_1 = 2 ,
KEYSCAN_2 = 3 ,
KEYSCAN_3 = 4 ,
KEYSCAN_4 = 5 ,
KEYSCAN_5 = 6 ,
KEYSCAN_6 = 7 ,
KEYSCAN_7 = 8 ,
KEYSCAN_8 = 9 ,
KEYSCAN_9 = 10,
KEYSCAN_0 = 11,
KEYSCAN_Minus = 12,
KEYSCAN_Equals = 13,
KEYSCAN_BackSpace = 14,
KEYSCAN_Tab = 15,
KEYSCAN_Q = 16,
KEYSCAN_W = 17,
KEYSCAN_E = 18,
KEYSCAN_R = 19,
KEYSCAN_T = 20,
KEYSCAN_Y = 21,
KEYSCAN_U = 22,
KEYSCAN_I = 23,
KEYSCAN_O = 24,
KEYSCAN_P = 25,
KEYSCAN_LeftBracket = 26,
KEYSCAN_RightBracket = 27,
KEYSCAN_Enter = 28,
KEYSCAN_CTRL = 29,
KEYSCAN_A = 30,
KEYSCAN_S = 31,
KEYSCAN_D = 32,
KEYSCAN_F = 33,
KEYSCAN_G = 34,
KEYSCAN_H = 35,
KEYSCAN_J = 36,
KEYSCAN_K = 37,
KEYSCAN_L = 38,
KEYSCAN_Semicolon = 39,
KEYSCAN_Apostrophe = 40,
KEYSCAN_Grave = 41,
KEYSCAN_LShift = 42,
KEYSCAN_Backslash = 43,
KEYSCAN_Z = 44,
KEYSCAN_X = 45,
KEYSCAN_C = 46,
KEYSCAN_V = 47,
KEYSCAN_B = 48,
KEYSCAN_N = 49,
KEYSCAN_M = 50,
KEYSCAN_Comma = 51,
KEYSCAN_Period = 52,
KEYSCAN_Forwardslash = 53,
KEYSCAN_RShift = 54,
KEYSCAN_PrtSc = 55,
KEYSCAN_Alt = 56,
KEYSCAN_Space = 57,
KEYSCAN_Caps = 58,
KEYSCAN_F1 = 59,
KEYSCAN_F2 = 60,
KEYSCAN_F3 = 61,
KEYSCAN_F4 = 62,
KEYSCAN_F5 = 63,
KEYSCAN_F6 = 64,
KEYSCAN_F7 = 65,
KEYSCAN_F8 = 66,
KEYSCAN_F9 = 67,
KEYSCAN_F10 = 68,
KEYSCAN_Num = 69,
KEYSCAN_Scroll = 70,
KEYSCAN_Home = 71,
KEYSCAN_Up = 72,
KEYSCAN_PgUp = 73,
KEYSCAN_Minus2 = 74,
KEYSCAN_Left = 75,
KEYSCAN_Center = 76,
KEYSCAN_Right = 77,
KEYSCAN_Plus = 78,
KEYSCAN_End = 79,
KEYSCAN_Down = 80,
KEYSCAN_PgDn = 81,
KEYSCAN_Ins = 82,
KEYSCAN_Delete = 83
} Scancodes;
#include <stdint.h>
#include <stdbool.h>
void Keyboard_Handler();
void Keyboard_Init();
void Keyboard_Reset_System();
void Keyboard_Enable();
void Keyboard_Disable();
void Keyboard_Set_Lock_LEDs(bool num, bool caps, bool scroll);
void Keyboard_Encoder_Send_Command(uint8_t command);
void Keyboard_Controller_Send_Command(uint8_t command);
uint8_t Keyboard_Controller_Status();
uint8_t Keyboard_Read_Encoder_Buffer();
bool Keyboard_Self_Test();
enum KEYBOARD_ENCODER_IO {
KEYBOARD_ENC_INPUT_BUF = 0x60,
KEYBOARD_ENC_CMD_REG = 0x60
};
enum KEYBOARD_CTRL_IO {
KEYBOARD_CTRL_STATS_REG = 0x64,
KEYBOARD_CTRL_CMD_REG = 0x64
};
enum KEYBOARD_CTRL_STATS_MASK {
KEYBOARD_CTRL_STATS_MASK_OUT_BUF = 1, //00000001
KEYBOARD_CTRL_STATS_MASK_IN_BUF = 2, //00000010
KEYBOARD_CTRL_STATS_MASK_SYSTEM = 4, //00000100
KEYBOARD_CTRL_STATS_MASK_CMD_DATA = 8, //00001000
KEYBOARD_CTRL_STATS_MASK_LOCKED = 0x10, //00010000
KEYBOARD_CTRL_STATS_MASK_AUX_BUF = 0x20, //00100000
KEYBOARD_CTRL_STATS_MASK_TIMEOUT = 0x40, //01000000
KEYBOARD_CTRL_STATS_MASK_PARITY = 0x80 //10000000
};
enum KEYBOARD_CTRL_CMD {
KEYBOARD_CTRL_CMD_DISABLE = 0xAD,
KEYBOARD_CTRL_CMD_ENABLE = 0xAE,
KEYBOARD_CTRL_CMD_SELF_TEST = 0xAA,
KEYBOARD_CTRL_CMD_WRITE_OUT_PORT = 0xD1
};
enum KEYBOARD_ENC_CMD {
KEYBOARD_ENC_CMD_SET_LED = 0xED
};

2
src/kernel/dri/serial.c
View File

@ -39,7 +39,7 @@ void COM1_Serial_Handler()
printf("IRQ 4 Triggered!");
}
int Init_Serial(uint16_t COM_Port, int Baud)
int Serial_Init(uint16_t COM_Port, int Baud)
{
uint8_t Divisor = 115200 / Baud;

2
src/kernel/dri/serial.h
View File

@ -26,5 +26,5 @@ int Serial_Received(uint16_t COM_Port);
char Read_Serial(uint16_t COM_Port);
int Serial_Transmit_Empty(uint16_t COM_Port);
void Write_Serial(uint16_t COM_Port, char a);
int Init_Serial(uint16_t COM_Port, int Baud);
int Serial_Init(uint16_t COM_Port, int Baud);
void Serial_Printf(uint16_t COM_Port, const char* fmt, ...);

32
src/kernel/main.c
View File

@ -28,9 +28,6 @@ extern uint8_t __end;
uint16_t DEBUG_COM_PORT = COM1_PORT;
int masterFDDType;
int slaveFDDType;
int uptime;
void timer(Registers* regs)
{
@ -39,13 +36,6 @@ void timer(Registers* regs)
// movecursorpos(8,14);
}
int keyboard_scancode;
void keyboard()
{
keyboard_scancode = inb(PS2_KEYBOARD_PORT);
// Debug Message, need to make a serial output thingy :)
Serial_Printf(DEBUG_COM_PORT, "Keycode = %d Port = %d\n", keyboard_scancode, PS2_KEYBOARD_PORT);
}
void __attribute__((section(".entry"))) start(BootParams* bootParams) {
@ -60,22 +50,22 @@ void __attribute__((section(".entry"))) start(BootParams* bootParams) {
HAL_Initialize();
movecursorpos(19, 8);
printf("Done!\n\n\n\n\n");
Init_Serial(DEBUG_COM_PORT, 9600);
// Register IRQs
printf("Registering IRQs...");
IRQ_RegisterHandler(0, timer);
IRQ_RegisterHandler(8, CMOS_RTC_Handler);
IRQ_RegisterHandler(1, Keyboard_Handler);
IRQ_RegisterHandler(4, COM1_Serial_Handler);
// Begin Loading Basic Drivers
printf("Load Keyboard Driver...");
IRQ_RegisterHandler(1, keyboard);
printf("Done!\n");
printf("Load Basic Storage Drivers...");
IRQ_RegisterHandler(6, Floppy_Handler);
IRQ_RegisterHandler(8, CMOS_RTC_Handler);
printf("Done!\n");
masterFDDType = Master_FDD_Detect();
slaveFDDType = Slave_FDD_Detect();
// Init Drivers
printf("Initializing Basic Drivers...");
Serial_Init(DEBUG_COM_PORT, 9600);
Keyboard_Init();
Floppy_Init();
printf("Done!\n");

24
src/kernel/shell/shell.c
View File

@ -1,24 +0,0 @@
/*----------------*\
|Nanite OS |
|Copyright (C) 2025|
|Tyler McGurrin |
\*----------------*/
#include "shell.h"
#include <stdio.h>
char* cursor = "=>";
/*
A simple Rescue shell
Because, Yes.
*/
void shell()
{
printf("NANITE Rescue Shell");
while(1 == 1) {
printf("%s", cursor);
}
}

8
src/kernel/shell/shell.h
View File

@ -1,8 +0,0 @@
/*----------------*\
|Nanite OS |
|Copyright (C) 2025|
|Tyler McGurrin |
\*----------------*/
#pragma once
void shell();

2
src/libs/version.h
View File

@ -6,5 +6,5 @@
#pragma once
#define LOGO " _ _____ _ __________________\n / | / / | / | / / _/_ __/ ____/\n / |/ / /| | / |/ // / / / / __/ \n / /| / ___ |/ /| // / / / / /___ \n/_/ |_/_/ |_/_/ |_/___/ /_/ /_____/ \n"
#define VERSION "RD-00029"
#define VERSION "RD-00030"
#define BOOTLOGO " _ ______ ____ ____ ______\n / | / / __ )/ __ \\/ __ /_ __/\n / |/ / __ / / / / / / // / \n / /| / /_/ / /_/ / /_/ // / \n/_/ |_/_____/\\____/\\____//_/ \n"