forked from koniifer/ableos
117 lines
2.4 KiB
Rust
117 lines
2.4 KiB
Rust
use {
|
|
crate::{
|
|
devices::{pci_inner::DeviceClass, Device, DEVICE_TABLE},
|
|
proc::PID,
|
|
wasm_jumploader::interp,
|
|
},
|
|
alloc::{format, vec::Vec},
|
|
pci::PortOps,
|
|
};
|
|
|
|
/// Experimental scratchpad for testing.
|
|
pub fn scratchpad() {
|
|
let mut dev_list = Vec::new();
|
|
let bus_scan;
|
|
unsafe {
|
|
bus_scan = pci::scan_bus(&PciIO {}, pci::CSpaceAccessMethod::IO);
|
|
}
|
|
for dev in bus_scan {
|
|
dev_list.push(dev);
|
|
}
|
|
|
|
let device_table = &mut *DEVICE_TABLE.lock();
|
|
|
|
for x in dev_list {
|
|
let device_name = format!("{:?}-{}", DeviceClass::from_u8(x.id.class), x.id.device_id);
|
|
|
|
device_table
|
|
.devices
|
|
.insert(device_name.clone(), Device::Pci(x));
|
|
}
|
|
|
|
/*
|
|
for (key, _value) in device_table.devices.iter() {
|
|
debug!("{}", key);
|
|
}
|
|
*/
|
|
// interp();
|
|
|
|
// rhai_shell();
|
|
}
|
|
|
|
pub struct PciIO {}
|
|
|
|
impl PortOps for PciIO {
|
|
unsafe fn read8(&self, port: u16) -> u8 {
|
|
cpuio::inb(port as u16)
|
|
}
|
|
|
|
unsafe fn read16(&self, port: u16) -> u16 {
|
|
cpuio::inw(port as u16)
|
|
}
|
|
|
|
unsafe fn read32(&self, port: u16) -> u32 {
|
|
cpuio::inl(port as u16)
|
|
}
|
|
|
|
unsafe fn write8(&self, port: u16, val: u8) {
|
|
cpuio::outb(val, port as u16);
|
|
}
|
|
|
|
unsafe fn write16(&self, port: u16, val: u16) {
|
|
cpuio::outw(val, port as u16);
|
|
}
|
|
|
|
unsafe fn write32(&self, port: u16, val: u32) {
|
|
cpuio::outl(val, port as u16);
|
|
}
|
|
}
|
|
/*
|
|
/// An experimental process message format
|
|
pub struct ProcessMessage {
|
|
pub to_pid: PID,
|
|
pub from_pid: PID,
|
|
pub message: [u8; 2048],
|
|
|
|
pub sender_time: SecondsTime,
|
|
}
|
|
//
|
|
// use libwasm::syscalls::time_calls::SecondsTime;
|
|
|
|
impl ProcessMessage {
|
|
pub fn new(to_pid: PID, from_pid: PID, message: [u8; 2048]) -> Self {
|
|
ProcessMessage {
|
|
to_pid,
|
|
from_pid,
|
|
message,
|
|
sender_time: SecondsTime {
|
|
seconds: 0,
|
|
milliseconds: 0,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
pub fn rhai_shell() {
|
|
let mut engine = rhai::Engine::new();
|
|
|
|
let ret = engine.eval::<i64>("1 + 2");
|
|
|
|
match ret {
|
|
Ok(x) => println!("{}", x),
|
|
Err(e) => println!("{}", e),
|
|
}
|
|
|
|
loop {}
|
|
}
|
|
lazy_static::lazy_static!(
|
|
pub static ref KEYBUFF: spin::Mutex<Vec<char>> = spin::Mutex::new(
|
|
Vec::new())
|
|
;
|
|
);
|
|
|
|
use alloc::string::String;
|
|
|
|
use crate::arch::sloop;
|