116 lines
3.3 KiB
Rust
116 lines
3.3 KiB
Rust
use core::arch::x86_64::__cpuid;
|
|
|
|
use libk::drivers::memory::FoundryOSFrameAllocator;
|
|
use spin::Lazy;
|
|
use x86_64::{
|
|
PhysAddr, VirtAddr,
|
|
instructions::port::Port,
|
|
registers::model_specific::Msr,
|
|
structures::paging::{
|
|
FrameAllocator, Mapper, Page, PageTableFlags, PhysFrame, Size4KiB, Translate,
|
|
},
|
|
};
|
|
|
|
use crate::serial_print;
|
|
|
|
use super::{cpu::model_specific_registers::*, memmap::PHYSICAL_MEMORY_OFFSET};
|
|
|
|
const IA32_APIC_BASE_MSR: u32 = 0x1b;
|
|
const IA32_APIC_BASE_MSR_BSP: u64 = 0x100;
|
|
const IA32_APIC_BASE_MSR_ENABLE: u64 = 0x800;
|
|
const IA32_APIC_BASE_MSR_DISABLE: u64 = !IA32_APIC_BASE_MSR_ENABLE;
|
|
|
|
const CPUID_FEAT_EDX_APIC: u64 = 1 << 9; // the cpuid instruction will return this flag if it supports APIC
|
|
|
|
// const APIC_VIRTUAL_ADDRESS: Lazy<VirtAddr> = Lazy::new(|| {
|
|
// let apic_base = get_apic_base();
|
|
// let virt_addr = unsafe { phys_to_virt(apic_base) };
|
|
|
|
// virt_addr
|
|
// });
|
|
|
|
fn set_apic_base_enable(apic: PhysAddr) {
|
|
let rax = (apic.as_u64() & 0xfffff0000) | IA32_APIC_BASE_MSR_ENABLE;
|
|
cpu_set_msr(IA32_APIC_BASE_MSR, rax);
|
|
}
|
|
|
|
fn set_apic_base_disable(apic: PhysAddr) {
|
|
let rax = (apic.as_u64() & 0xfffff0000) & IA32_APIC_BASE_MSR_DISABLE;
|
|
cpu_set_msr(IA32_APIC_BASE_MSR, rax);
|
|
}
|
|
|
|
fn get_apic_base() -> PhysAddr {
|
|
let mut value: u64 = 0;
|
|
cpu_get_msr(IA32_APIC_BASE_MSR, &mut value);
|
|
PhysAddr::new(value & 0xfffff0000)
|
|
}
|
|
|
|
fn write_apic_register(apic_base: &VirtAddr, reg: u8, value: u32) {
|
|
let apic_base = apic_base.as_u64();
|
|
let reg_addr = (apic_base & 0xFFFFF0000) + reg as u64;
|
|
unsafe { *(reg_addr as *mut u32) = value };
|
|
}
|
|
|
|
fn read_apic_register(apic_base: &VirtAddr, reg: u8) -> u32 {
|
|
let apic_base = apic_base.as_u64();
|
|
|
|
serial_print!("got apic base");
|
|
|
|
let reg_addr = (apic_base & 0xFFFFF0000) + reg as u64;
|
|
unsafe { *(reg_addr as *const u32) }
|
|
}
|
|
|
|
pub fn check_apic() -> bool {
|
|
let res = unsafe { __cpuid(1) };
|
|
res.edx as u64 & CPUID_FEAT_EDX_APIC != 0
|
|
}
|
|
|
|
#[inline(always)]
|
|
unsafe fn phys_to_virt(phys: PhysAddr) -> VirtAddr {
|
|
let phys = phys.as_u64();
|
|
match phys.checked_add(*PHYSICAL_MEMORY_OFFSET) {
|
|
Some(virt) => {
|
|
serial_print!("map worked!");
|
|
VirtAddr::new(virt)
|
|
}
|
|
None => {
|
|
serial_print!("THIS IS A PROBLEM");
|
|
panic!("overflow")
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn enable_apic(
|
|
mapper: &mut impl Mapper<Size4KiB>,
|
|
frame_allocator: &mut FoundryOSFrameAllocator,
|
|
) {
|
|
let apic_phys_addr = get_apic_base();
|
|
set_apic_base_enable(apic_phys_addr);
|
|
// map virt address of apic
|
|
|
|
let apic_virt = unsafe { phys_to_virt(apic_phys_addr) };
|
|
// let page: Page<Size4KiB> = Page::containing_address(apic_virt);
|
|
// let frame: PhysFrame<Size4KiB> = PhysFrame::containing_address(apic_phys_addr);
|
|
// let flags: PageTableFlags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
|
|
|
|
// unsafe {
|
|
// match mapper.map_to(page, frame, flags, frame_allocator) {
|
|
// Ok(_) => {}
|
|
// Err(why) => panic!("failed to map apic: {:?}", why),
|
|
// }
|
|
// }
|
|
|
|
// // FIXME: this causes a page fault
|
|
// // TODO: map to virtual memor
|
|
|
|
let reg = read_apic_register(&apic_virt, 0xF0);
|
|
|
|
serial_print!("ok2");
|
|
|
|
write_apic_register(&apic_virt, 0xF0, reg | 0x100);
|
|
}
|
|
|
|
pub struct Apic {}
|
|
|
|
pub enum ApicVector {}
|