1
[dependencies]
2
pic8259_simple = "0.2.0"

1
use pic8259_simple::ChainedPics;
2
use spin;
3

4
pub const PIC_1_OFFSET: u8 = 32;
5
pub const PIC_2_OFFSET: u8 = PIC_1_OFFSET + 8;
6

7
pub static PICS: spin::Mutex<ChainedPics> =
8
    spin::Mutex::new(unsafe { ChainedPics::new(PIC_1_OFFSET, PIC_2_OFFSET) });

1
pub fn init() {
2
    gdt::init();
3
    interrupts::init_idt();
4
    unsafe { interrupts::PICS.lock().initialize() }; // new
5
}

1
#[derive(Debug, Clone, Copy)]
2
#[repr(u8)]
3
pub enum InterruptIndex {
4
    Timer = PIC_1_OFFSET,
5
}
6

7
impl InterruptIndex {
8
    fn as_u8(self) -> u8 {
9
        self as u8
10
    }
11

12
    fn as_usize(self) -> usize {
13
        usize::from(self.as_u8())
14
    }
15
}

1
use crate::print;
2

3
lazy_static! {
4
    static ref IDT: InterruptDescriptorTable = {
5
        let mut idt = InterruptDescriptorTable::new();
6
        idt.breakpoint.set_handler_fn(breakpoint_handler);
7
        […]
8
        idt[InterruptIndex::Timer.as_usize()]
9
            .set_handler_fn(timer_interrupt_handler); // new
10

11
        idt
12
    };
13
}
14

15
extern "x86-interrupt" fn timer_interrupt_handler(
16
    _stack_frame: &mut InterruptStackFrame)
17
{
18
    print!(".");
19
}

1
extern "x86-interrupt" fn timer_interrupt_handler(
2
    _stack_frame: &mut InterruptStackFrame)
3
{
4
    print!(".");
5

6
    unsafe {
7
        PICS.lock()
8
            .notify_end_of_interrupt(InterruptIndex::Timer.as_u8());
9
    }
10
}

1
#[no_mangle]
2
pub extern "C" fn _start() -> ! {
3
    […]
4
    loop {
5
        use blog_os::print;
6
        print!("-");        // new
7
    }
8
}

1
/// Prints the given formatted string to the VGA text buffer
2
/// through the global `WRITER` instance.
3
#[doc(hidden)]
4
pub fn _print(args: fmt::Arguments) {
5
    use core::fmt::Write;
6
    use x86_64::instructions::interrupts;   // new
7

8
    interrupts::without_interrupts(|| {     // new
9
        WRITER.lock().write_fmt(args).unwrap();
10
    });
11
}

1
#[doc(hidden)]
2
pub fn _print(args: ::core::fmt::Arguments) {
3
    use core::fmt::Write;
4
    use x86_64::instructions::interrupts;       // new
5

6
    interrupts::without_interrupts(|| {         // new
7
        SERIAL1
8
            .lock()
9
            .write_fmt(args)
10
            .expect("Printing to serial failed");
11
    });
12
}

1
extern "x86-interrupt" fn keyboard_interrupt_handler(
2
    _stack_frame: &mut InterruptStackFrame)
3
{
4
    use x86_64::instructions::port::Port;
5

6
    let mut port = Port::new(0x60);
7
    let scancode: u8 = unsafe { port.read() };
8
    print!("{}", scancode);
9

10
    unsafe {
11
        PICS.lock()
12
            .notify_end_of_interrupt(InterruptIndex::Keyboard.as_u8());
13
    }
14
}

1
extern "x86-interrupt" fn keyboard_interrupt_handler(
2
    _stack_frame: &mut InterruptStackFrame)
3
{
4
    use x86_64::instructions::port::Port;
5

6
    let mut port = Port::new(0x60);
7
    let scancode: u8 = unsafe { port.read() };
8

9
    // new
10
    let key = match scancode {
11
        0x02 => Some('1'),
12
        0x03 => Some('2'),
13
        0x04 => Some('3'),
14
        0x05 => Some('4'),
15
        0x06 => Some('5'),
16
        0x07 => Some('6'),
17
        0x08 => Some('7'),
18
        0x09 => Some('8'),
19
        0x0a => Some('9'),
20
        0x0b => Some('0'),
21
        _ => None,
22
    };
23
    if let Some(key) = key {
24
        print!("{}", key);
25
    }
26

27
    unsafe {
28
        PICS.lock()
29
            .notify_end_of_interrupt(InterruptIndex::Keyboard.as_u8());
30
    }
31
}

1
[dependencies]
2
pc-keyboard = "0.5.0"

1
extern "x86-interrupt" fn keyboard_interrupt_handler(
2
    _stack_frame: &mut InterruptStackFrame)
3
{
4
    use pc_keyboard::{layouts, DecodedKey, HandleControl, Keyboard, ScancodeSet1};
5
    use spin::Mutex;
6
    use x86_64::instructions::port::Port;
7

8
    lazy_static! {
9
        static ref KEYBOARD: Mutex<Keyboard<layouts::Us104Key, ScancodeSet1>> =
10
            Mutex::new(Keyboard::new(layouts::Us104Key, ScancodeSet1,
11
                HandleControl::Ignore)
12
            );
13
    }
14

15
    let mut keyboard = KEYBOARD.lock();
16
    let mut port = Port::new(0x60);
17

18
    let scancode: u8 = unsafe { port.read() };
19
    if let Ok(Some(key_event)) = keyboard.add_byte(scancode) {
20
        if let Some(key) = keyboard.process_keyevent(key_event) {
21
            match key {
22
                DecodedKey::Unicode(character) => print!("{}", character),
23
                DecodedKey::RawKey(key) => print!("{:?}", key),
24
            }
25
        }
26
    }
27

28
    unsafe {
29
        PICS.lock()
30
            .notify_end_of_interrupt(InterruptIndex::Keyboard.as_u8());
31
    }
32
}