feat(timer): 允许配置定时器间隔

Author: moyanj

kernel/src/drivers/char/serial.rs

@@ -1,6 +1,6 @@
 extern crate alloc;
 
-use super::super::{CharDevice, OldDevice, DeviceError, DeviceInner, DeviceType, SharedDeviceOps};
+use super::super::{CharDevice, DeviceError, DeviceInner, DeviceType, OldDevice, SharedDeviceOps};
 use alloc::format;
 use alloc::string::{String, ToString};
 use alloc::sync::Arc;

kernel/src/drivers/input/mod.rs

@@ -1 +1 @@
-pub mod ps2;
+pub mod ps2;

kernel/src/drivers/mod.rs

@@ -4,8 +4,8 @@ pub mod char;
 pub mod device;
 pub mod input;
 pub mod ops;
-pub mod usb;
 pub mod resource;
+pub mod usb;
 
 pub use device::*;
 pub use ops::*;

kernel/src/drivers/usb.rs

@@ -1,22 +1,23 @@
 //! The USB driver (xHCI).
-//! 
+//!
 //! Copyright (C) RainSTR Studio 2025-2026, All Rights Reserved.
 
 extern crate alloc;
+use crate::libs::pci::scan_all_pci_devices;
 use alloc::vec::Vec;
 use log::warn;
-use crate::libs::pci::scan_all_pci_devices;
 
 pub fn init() {
     let all_pci_devices = scan_all_pci_devices();
 
     // Get xHCI devices
-    let usb_devices = all_pci_devices.iter()
+    let usb_devices = all_pci_devices
+        .iter()
         .filter(|(_, class)| class.class == 0x0C && class.subclass == 0x03 && class.prog_if == 0x30)
         .collect::<Vec<_>>();
 
     if usb_devices.is_empty() {
         warn!("No USB devices found.");
         return;
     }
-}
+}

kernel/src/fs/fs_impl/kernfs.rs

@@ -192,7 +192,11 @@ impl Inode for KernInode {
         }
     }
 
-    fn create_device(&self, name: &str, device: Arc<OldDevice>) -> Result<Arc<dyn Inode>, VfsError> {
+    fn create_device(
+        &self,
+        name: &str,
+        device: Arc<OldDevice>,
+    ) -> Result<Arc<dyn Inode>, VfsError> {
         match &self.content {
             KernNodeContent::Dir(entries) => {
                 let mut map = entries.write();

kernel/src/fs/fs_impl/memfs.rs

@@ -281,7 +281,11 @@ impl Inode for MemVNode {
         }
     }
 
-    fn create_device(&self, name: &str, device: Arc<OldDevice>) -> Result<Arc<dyn Inode>, VfsError> {
+    fn create_device(
+        &self,
+        name: &str,
+        device: Arc<OldDevice>,
+    ) -> Result<Arc<dyn Inode>, VfsError> {
         match &self.content {
             MemNodeContent::Dir { entries } => {
                 let mut entries = entries.write();

kernel/src/fs/vfs.rs

@@ -1,4 +1,4 @@
-use crate::drivers::{OldDevice, DeviceError, DEVICE_MANAGER};
+use crate::drivers::{DeviceError, OldDevice, DEVICE_MANAGER};
 extern crate alloc;
 use super::fs_impl;
 use alloc::format;
@@ -110,7 +110,11 @@ pub trait Inode: Send + Sync + core::fmt::Debug {
         Err(VfsError::NotImplemented)
     }
 
-    fn create_device(&self, name: &str, device: Arc<OldDevice>) -> Result<Arc<dyn Inode>, VfsError> {
+    fn create_device(
+        &self,
+        name: &str,
+        device: Arc<OldDevice>,
+    ) -> Result<Arc<dyn Inode>, VfsError> {
         let _ = (name, device);
         Err(VfsError::NotImplemented)
     }

kernel/src/libs/Kconfig.toml

@@ -15,3 +15,11 @@ default = +8
 desc = "Timezone"
 help = "Timezone offset from UTC (in hours)."
 rust_type = "i8"
+
+[[config]]
+name = "TIMER_PERIOD_MS"
+type = "int"
+default = 10
+desc = "Timer Period (ms)"
+help = "The period of the system timer in milliseconds."
+rust_type = "u64"

kernel/src/libs/time/apic.rs

@@ -13,18 +13,21 @@ pub const XAPIC_TIMER_DIV_CONF_OFFSET: u32 = 0x3E0;
 /// * `timer_vector` - The interrupt vector to use for the timer.
 ///
 /// # Returns
-/// The number of ticks per 10ms.
+/// The number of ticks per the configured period.
 pub unsafe fn calibrate_timer<F1, F2>(read_reg: F1, write_reg: F2, timer_vector: u8) -> u64
 where
     F1: Fn(u32) -> u32,
     F2: Fn(u32, u32),
 {
+    let period_ms = crate::config::TIMER_PERIOD_MS;
+    let period_us = period_ms * 1000;
+
     // Stop timer
     write_reg(XAPIC_TIMER_INIT_COUNT_OFFSET, 0);
     // Set divider to 16
     write_reg(XAPIC_TIMER_DIV_CONF_OFFSET, 0x3);
 
-    let (ticks_per_10ms, _) = super::calibrate_with_pit(10000, || {
+    let (ticks_per_period, _) = super::calibrate_with_pit(period_us, || {
         // Set APIC timer to max
         write_reg(XAPIC_TIMER_INIT_COUNT_OFFSET, 0xFFFFFFFF);
         move || {
@@ -33,11 +36,14 @@ where
         }
     });
 
-    info!("APIC Timer calibrated: {} ticks per 10ms", ticks_per_10ms);
+    info!(
+        "APIC Timer calibrated: {} ticks per {}ms",
+        ticks_per_period, period_ms
+    );
 
-    // Set timer for periodic interrupt at 100Hz (10ms)
+    // Set timer for periodic interrupt at the configured frequency
     write_reg(XAPIC_LVT_TIMER_OFFSET, 0x20000 | timer_vector as u32); // Periodic mode
-    write_reg(XAPIC_TIMER_INIT_COUNT_OFFSET, ticks_per_10ms as u32);
+    write_reg(XAPIC_TIMER_INIT_COUNT_OFFSET, ticks_per_period as u32);
 
-    ticks_per_10ms
+    ticks_per_period
 }

kernel/src/libs/time/mod.rs

@@ -3,7 +3,7 @@ pub mod pit;
 pub mod rtc;
 pub mod tsc;
 
-pub use tsc::{init, sleep_us, time_since_boot};
+pub use tsc::{init, sleep_us, time_since_boot, uptime_ms, uptime_us};
 
 /// Calibrate a timer using the PIT (Programmable Interval Timer).
 ///