Merge pull request #207 from ryanbreen/feat/audio-bell-and-fixes

feat: tab completion bell chime and sound driver cleanup

Author: ryanbreen

kernel/src/arch_impl/aarch64/elf.rs

@@ -281,7 +281,7 @@ pub fn load_elf_into_page_table(
     // Validate ELF header
     let header = validate_elf_header(data)?;
 
-    crate::serial_println!(
+    log::debug!(
         "[elf-arm64] Loading ELF into process page table: entry={:#x}, {} program headers",
         header.entry,
         header.phnum
@@ -323,7 +323,7 @@ pub fn load_elf_into_page_table(
     // Page-align the heap start (4KB alignment)
     let heap_start = (max_segment_end + 0xfff) & !0xfff;
 
-    crate::serial_println!(
+    log::debug!(
         "[elf-arm64] Loaded: base={:#x}, end={:#x}, entry={:#x}",
         if min_load_addr == u64::MAX { 0 } else { min_load_addr },
         heap_start,
@@ -359,7 +359,7 @@ fn load_segment_into_page_table(
         return Err("Segment data out of bounds");
     }
 
-    crate::serial_println!(
+    log::trace!(
         "[elf-arm64] Loading segment: vaddr={:#x}, filesz={:#x}, memsz={:#x}, flags={:#x}",
         vaddr.as_u64(),
         file_size,
@@ -388,7 +388,7 @@ fn load_segment_into_page_table(
         page_flags |= PageTableFlags::NO_EXECUTE;
     }
 
-    crate::serial_println!(
+    log::trace!(
         "[elf-arm64] Segment permissions: R={}, W={}, X={}",
         segment_readable,
         segment_writable,
@@ -411,7 +411,7 @@ fn load_segment_into_page_table(
 
         let (frame, already_mapped) = if let Some(existing_phys) = existing_phys_opt {
             let existing_frame = PhysFrame::containing_address(PhysAddr::new(existing_phys.as_u64()));
-            crate::serial_println!(
+            log::trace!(
                 "[elf-arm64] Page {:#x} already mapped to frame {:#x}, reusing",
                 page_vaddr.as_u64(),
                 existing_frame.start_address().as_u64()
@@ -422,7 +422,7 @@ fn load_segment_into_page_table(
             let new_frame = crate::memory::frame_allocator::allocate_frame()
                 .ok_or("Out of memory allocating frame for ELF segment")?;
 
-            crate::serial_println!(
+            log::trace!(
                 "[elf-arm64] Allocated frame {:#x} for page {:#x}",
                 new_frame.start_address().as_u64(),
                 page_vaddr.as_u64()
@@ -473,7 +473,7 @@ fn load_segment_into_page_table(
                 core::ptr::copy_nonoverlapping(src, dst, copy_size);
             }
 
-            crate::serial_println!(
+            log::trace!(
                 "[elf-arm64] Copied {} bytes to frame {:#x} (page {:#x}) at offset {}",
                 copy_size,
                 frame_phys_addr.as_u64(),
@@ -491,7 +491,7 @@ fn load_segment_into_page_table(
         count
     };
 
-    crate::serial_println!(
+    log::trace!(
         "[elf-arm64] Successfully loaded segment with {} pages",
         page_count
     );

kernel/src/arch_impl/aarch64/syscall_entry.rs

@@ -396,14 +396,14 @@ fn dispatch_syscall(
         SyscallNumber::Pause | SyscallNumber::Sigsuspend => (-38_i64) as u64,
 
         // I/O syscalls (ARM64 io module)
-        SyscallNumber::Write => result_to_u64(crate::syscall::io::sys_write(arg1, arg2, arg3)),
-        SyscallNumber::Read => result_to_u64(crate::syscall::io::sys_read(arg1, arg2, arg3)),
+        SyscallNumber::Write => result_to_u64(crate::syscall::handlers::sys_write(arg1, arg2, arg3)),
+        SyscallNumber::Read => result_to_u64(crate::syscall::handlers::sys_read(arg1, arg2, arg3)),
         SyscallNumber::Close => result_to_u64(crate::syscall::pipe::sys_close(arg1 as i32)),
-        SyscallNumber::Dup => result_to_u64(crate::syscall::io::sys_dup(arg1)),
-        SyscallNumber::Dup2 => result_to_u64(crate::syscall::io::sys_dup2(arg1, arg2)),
-        SyscallNumber::Fcntl => result_to_u64(crate::syscall::io::sys_fcntl(arg1, arg2, arg3)),
-        SyscallNumber::Poll => result_to_u64(crate::syscall::io::sys_poll(arg1, arg2, arg3 as i32)),
-        SyscallNumber::Select => result_to_u64(crate::syscall::io::sys_select(arg1 as i32, arg2, arg3, arg4, arg5)),
+        SyscallNumber::Dup => result_to_u64(crate::syscall::handlers::sys_dup(arg1)),
+        SyscallNumber::Dup2 => result_to_u64(crate::syscall::handlers::sys_dup2(arg1, arg2)),
+        SyscallNumber::Fcntl => result_to_u64(crate::syscall::handlers::sys_fcntl(arg1, arg2, arg3)),
+        SyscallNumber::Poll => result_to_u64(crate::syscall::handlers::sys_poll(arg1, arg2, arg3 as i32)),
+        SyscallNumber::Select => result_to_u64(crate::syscall::handlers::sys_select(arg1 as i32, arg2, arg3, arg4, arg5)),
         SyscallNumber::Ioctl => result_to_u64(crate::syscall::ioctl::sys_ioctl(arg1, arg2, arg3)),
         SyscallNumber::Pipe => result_to_u64(crate::syscall::pipe::sys_pipe(arg1)),
         SyscallNumber::Pipe2 => result_to_u64(crate::syscall::pipe::sys_pipe2(arg1, arg2)),
@@ -488,6 +488,10 @@ fn dispatch_syscall(
         SyscallNumber::FbMmap => result_to_u64(crate::syscall::graphics::sys_fbmmap()),
         SyscallNumber::GetMousePos => result_to_u64(crate::syscall::graphics::sys_get_mouse_pos(arg1)),
 
+        // Audio syscalls
+        SyscallNumber::AudioInit => result_to_u64(crate::syscall::audio::sys_audio_init()),
+        SyscallNumber::AudioWrite => result_to_u64(crate::syscall::audio::sys_audio_write(arg1, arg2)),
+
         // Testing/diagnostic syscalls
         SyscallNumber::CowStats => sys_cow_stats_aarch64(arg1),
         SyscallNumber::SimulateOom => sys_simulate_oom_aarch64(arg1),

kernel/src/drivers/mod.rs

@@ -54,6 +54,16 @@ pub fn init() -> usize {
         }
     }
 
+    // Initialize VirtIO sound driver
+    match virtio::sound::init() {
+        Ok(()) => {
+            log::info!("VirtIO sound driver initialized successfully");
+        }
+        Err(e) => {
+            log::warn!("VirtIO sound driver initialization failed: {}", e);
+        }
+    }
+
     log::info!("Driver subsystem initialized");
     device_count
 }
@@ -123,6 +133,16 @@ pub fn init() -> usize {
         }
     }
 
+    // Initialize VirtIO sound driver
+    match virtio::sound_mmio::init() {
+        Ok(()) => {
+            serial_println!("[drivers] VirtIO sound driver initialized");
+        }
+        Err(e) => {
+            serial_println!("[drivers] VirtIO sound driver init failed: {}", e);
+        }
+    }
+
     serial_println!("[drivers] Driver subsystem initialized");
     device_count
 }

kernel/src/drivers/pci.rs

@@ -45,6 +45,10 @@ pub const VIRTIO_VENDOR_ID: u16 = 0x1AF4;
 pub const VIRTIO_BLOCK_DEVICE_ID_LEGACY: u16 = 0x1001;
 /// VirtIO block device ID (modern)
 pub const VIRTIO_BLOCK_DEVICE_ID_MODERN: u16 = 0x1042;
+/// VirtIO sound device ID (legacy)
+pub const VIRTIO_SOUND_DEVICE_ID_LEGACY: u16 = 0x1019;
+/// VirtIO sound device ID (modern)
+pub const VIRTIO_SOUND_DEVICE_ID_MODERN: u16 = 0x1059;
 /// VirtIO network device ID (legacy)
 pub const VIRTIO_NET_DEVICE_ID_LEGACY: u16 = 0x1000;
 /// VirtIO network device ID (modern)
@@ -196,6 +200,12 @@ impl Device {
     }
 
     /// Check if this is any network controller
+    pub fn is_virtio_sound(&self) -> bool {
+        self.is_virtio()
+            && (self.device_id == VIRTIO_SOUND_DEVICE_ID_LEGACY
+                || self.device_id == VIRTIO_SOUND_DEVICE_ID_MODERN)
+    }
+
     pub fn is_network(&self) -> bool {
         self.class == DeviceClass::Network
     }
@@ -679,3 +689,13 @@ pub fn find_virtio_net_devices() -> Vec<Device> {
         None => Vec::new(),
     }
 }
+
+/// Find all VirtIO sound devices
+#[allow(dead_code)] // Part of public API, will be used by VirtIO sound driver
+pub fn find_virtio_sound_devices() -> Vec<Device> {
+    let devices = PCI_DEVICES.lock();
+    match devices.as_ref() {
+        Some(devs) => devs.iter().filter(|d| d.is_virtio_sound()).cloned().collect(),
+        None => Vec::new(),
+    }
+}

kernel/src/drivers/virtio/input_mmio.rs

@@ -644,6 +644,18 @@ pub fn handle_interrupt() {
                     }
                 }
 
+                // Generate VT100 escape sequences for special keys
+                // (arrows, Home, End, Delete) that can't be represented
+                // as a single character.
+                if let Some(seq) = keycode_to_escape_seq(keycode) {
+                    for &b in seq {
+                        if !crate::tty::push_char_nonblock(b) {
+                            crate::ipc::stdin::push_byte_from_irq(b);
+                        }
+                    }
+                    continue;
+                }
+
                 let shift = SHIFT_PRESSED.load(core::sync::atomic::Ordering::Relaxed);
                 let caps = CAPS_LOCK_ACTIVE.load(core::sync::atomic::Ordering::Relaxed);
                 let ctrl = CTRL_PRESSED.load(core::sync::atomic::Ordering::Relaxed);
@@ -900,6 +912,21 @@ pub fn keycode_to_char(code: u16, shift: bool) -> Option<char> {
     Some(c)
 }
 
+/// Convert a Linux keycode to a VT100 escape sequence for special keys
+/// that require multi-byte output (arrow keys, Home, End, Delete).
+fn keycode_to_escape_seq(code: u16) -> Option<&'static [u8]> {
+    match code {
+        103 => Some(b"\x1b[A"),  // Up
+        108 => Some(b"\x1b[B"),  // Down
+        106 => Some(b"\x1b[C"),  // Right
+        105 => Some(b"\x1b[D"),  // Left
+        102 => Some(b"\x1b[H"),  // Home
+        107 => Some(b"\x1b[F"),  // End
+        111 => Some(b"\x1b[3~"), // Delete
+        _ => None,
+    }
+}
+
 /// Check if a keycode is a modifier key
 pub fn is_modifier(code: u16) -> bool {
     matches!(code,

kernel/src/drivers/virtio/mmio.rs

@@ -56,6 +56,7 @@ pub mod device_id {
     pub const SCSI: u32 = 8;
     pub const GPU: u32 = 16;
     pub const INPUT: u32 = 18;
+    pub const SOUND: u32 = 25;
 }
 
 /// VirtIO MMIO register offsets
@@ -403,6 +404,7 @@ pub fn device_type_name(device_id: u32) -> &'static str {
         device_id::SCSI => "SCSI",
         device_id::GPU => "GPU",
         device_id::INPUT => "input",
+        device_id::SOUND => "sound",
         _ => "unknown",
     }
 }

kernel/src/drivers/virtio/mod.rs

@@ -33,6 +33,11 @@ pub mod net_mmio;
 pub mod gpu_mmio;
 #[cfg(target_arch = "aarch64")]
 pub mod input_mmio;
+#[cfg(target_arch = "aarch64")]
+pub mod sound_mmio;
+
+#[cfg(target_arch = "x86_64")]
+pub mod sound;
 
 #[cfg(target_arch = "x86_64")]
 use x86_64::instructions::port::Port;