diff --git a/hal/src/lib.rs b/hal/src/lib.rs
index 5e79d738a..1a1123f0d 100644
--- a/hal/src/lib.rs
+++ b/hal/src/lib.rs
@@ -53,23 +53,9 @@ pub trait Configuration<P> {
 
 /// Platform peripheral base trait
 ///
-/// Defines the fundamental operations that all platform peripherals must implement.
-/// This trait provides a unified interface for enabling and disabling peripheral devices
-/// across different hardware platforms.
-///
-/// All peripheral drivers should implement this trait to ensure consistent power
-/// management and resource control capabilities.
-///
-/// # Trait Bounds
-///
-/// This trait requires implementations to be:
-/// - `Sync` - Safe to share references between threads, Peripherals are often accessed from multiple contexts.
-/// - `Send` - Safe to transfer ownership between threads, Peripherals always exists in system memory.
-/// - `'static` - Lives for the entire duration of the program
-///
-/// These bounds ensure that peripheral instances can be safely used in multi-threaded
-/// environments and stored in static variables, which is common in embedded systems.
-pub trait PlatPeri: Sync + Send + 'static {
+/// Peripherals would be a global singleton,
+/// and the HAL layer would provide a static reference to the peripheral.
+pub trait PlatPeri: 'static {
     fn enable(&self) {}
     fn disable(&self) {}
 }
diff --git a/kernel/src/boards/seeed_xiao_esp32c3/Kconfig b/kernel/src/boards/seeed_xiao_esp32c3/Kconfig
index 0bc6e0a0f..480c4de35 100644
--- a/kernel/src/boards/seeed_xiao_esp32c3/Kconfig
+++ b/kernel/src/boards/seeed_xiao_esp32c3/Kconfig
@@ -19,7 +19,27 @@ choice
           Set irq priority bits to 8.
 endchoice
 
-choice
+config LCD
+    bool "Enable LCD device"
+    default n
+    help
+      Enable LCD module
+
+config FT6336U
+    bool "Enable touch screen device"
+    default n
+    help
+      Enable touch screen
+
+config GPIO
+    bool "Enable gpio device"
+    default n
+    help
+      Enable gpio device
+
+if LCD
+
+  choice
     prompt "LCD controller"
     default ST7789
 
@@ -32,7 +52,9 @@ choice
         bool "Enable LCD ST7796"
         help
           Enable the ST7796 LCD controller.
-endchoice
+  endchoice
+
+endif
 
 config BME280
     bool "BME280 Sensor"
diff --git a/kernel/src/boards/seeed_xiao_esp32c3/mod.rs b/kernel/src/boards/seeed_xiao_esp32c3/mod.rs
index 1e897fbfa..27eebb7d5 100644
--- a/kernel/src/boards/seeed_xiao_esp32c3/mod.rs
+++ b/kernel/src/boards/seeed_xiao_esp32c3/mod.rs
@@ -119,6 +119,9 @@ const RTC_CNTL_WDTCONFIG0_REG: usize = RTC_CNTL_BASE + 0x90;
 
 const USB_SERIAL_JTAG_IRQ: Interrupt = Interrupt::new(26, USB_SERIAL_JTAG_INT_NUM);
 const SYSTIMER_TARGET0_IRQ: Interrupt = Interrupt::new(37, TARGET0_INT_NUM);
+const LED_DEVICE_MAJOR: usize = 242;
+const LED_B_DEVICE_MINOR: usize = 0;
+const LED_R_DEVICE_MINOR: usize = 1;
 
 pub(crate) fn init() {
     assert!(!local_irq_enabled());
@@ -189,6 +192,10 @@ crate::define_peripheral! {
      blueos_driver::gpio::esp32_gpio::Esp32GpioOutputPin::new(21)),
     (lcd_cs, blueos_driver::gpio::esp32_gpio::Esp32GpioOutputPin,
      blueos_driver::gpio::esp32_gpio::Esp32GpioOutputPin::new(20)),
+    (led_b, blueos_driver::gpio::esp32_gpio::Esp32GpioOutputPin,
+     blueos_driver::gpio::esp32_gpio::Esp32GpioOutputPin::new(2)),
+    (led_r, blueos_driver::gpio::esp32_gpio::Esp32GpioOutputPin,
+     blueos_driver::gpio::esp32_gpio::Esp32GpioOutputPin::new(3)),
 }
 
 #[inline(always)]
@@ -215,6 +222,8 @@ crate::define_pin_states!(
     (5, 1, false, true, false, 2, None, None, true, false),        // lcd dc
     (4, 1, false, true, false, 2, None, None, true, false),        // lcd rst
     (21, 1, false, true, false, 2, None, None, true, false),       // touch rst
+    (2, 1, false, true, false, 2, None, None, true, false),        // led blue
+    (3, 1, false, true, false, 2, None, None, true, false),        // led red
 );
 
 crate::define_bus! {
@@ -226,6 +235,7 @@ crate::define_bus! {
             crate::drivers::lcd::st7789::St7789Config::<blueos_driver::gpio::esp32_gpio::Esp32GpioOutputPin> {
                 rst: get_device!(rst_pin),
                 dc: get_device!(dc_pin),
+                cs: Some(get_device!(lcd_cs)),
             }
         ),
         #[cfg(st7796)]
@@ -233,12 +243,27 @@ crate::define_bus! {
             crate::drivers::lcd::st7796::St7796Config::<blueos_driver::gpio::esp32_gpio::Esp32GpioOutputPin> {
                 rst: get_device!(rst_pin),
                 dc: get_device!(dc_pin),
+                cs: Some(get_device!(lcd_cs)),
                 orientation: mipidsi::options::Orientation::new()
                     .rotate(mipidsi::options::Rotation::Deg0)
                     .flip_horizontal(),
             }
         ),
     ),
+    (
+        i2c_bus,
+        crate::devices::i2c_core::block_i2c::BlockI2c<blueos_driver::i2c::esp32_i2c::Esp32I2c>,
+        #[cfg(ft6336u)]
+        (ft6336u, crate::drivers::input::ft6336u::Ft6336uConfig<blueos_driver::gpio::esp32_gpio::Esp32GpioOutputPin>,
+            crate::drivers::input::ft6336u::Ft6336uConfig::<blueos_driver::gpio::esp32_gpio::Esp32GpioOutputPin> {
+                rst: get_device!(touch_rst_pin),
+            }
+        ),
+        #[cfg(bme280)]
+        (bme280, crate::drivers::sensor::bme280::Bme280Config,
+            crate::drivers::sensor::bme280::Bme280Config::new(0x76)
+        ),
+    ),
 }
 
 pub(crate) fn init_spi_bus() {
@@ -283,4 +308,64 @@ pub(crate) fn init_spi_bus() {
     }
 }
 
-pub(crate) fn init_i2c_bus() {}
+pub(crate) fn init_i2c_bus() {
+    use crate::{
+        devices::{bus::Bus, i2c_core::block_i2c::BlockI2c},
+        drivers::InitDriver,
+    };
+    use alloc::sync::Arc;
+
+    if let Ok(block_i2c) = BlockI2c::new(get_device!(i2c0)) {
+        let i2c_bus = Arc::new(Bus::new(block_i2c));
+        for device in crate::boards::get_bus_devices!(i2c_bus) {
+            i2c_bus.register_device(device).unwrap();
+        }
+
+        #[cfg(ft6336u)]
+        if let Ok(driver) =
+            i2c_bus.probe_driver(&crate::drivers::input::ft6336u::Ft6336uDriverModule::<
+                blueos_driver::gpio::esp32_gpio::Esp32GpioOutputPin,
+            >::new())
+        {
+            if let Err(error) = driver.init(&i2c_bus) {
+                log::warn!("Failed to initialize FT6336U driver: {}", error);
+            }
+        } else {
+            log::warn!("Failed to probe FT6336U driver");
+        }
+
+        #[cfg(bme280)]
+        if let Ok(driver) =
+            i2c_bus.probe_driver(&crate::drivers::sensor::bme280::Bme280DriverModule)
+        {
+            if let Err(error) = driver.init(&i2c_bus) {
+                log::warn!("Failed to initialize BME280 driver: {}", error);
+            }
+        } else {
+            log::warn!("Failed to probe BME280 driver");
+        }
+    } else {
+        log::warn!("Failed to initialize ESP32-C3 I2C0 bus");
+    }
+}
+
+pub(crate) fn init_gpio() {
+    crate::devices::gpio::GeneralGpio::new(
+        get_device!(led_b),
+        Some(crate::devices::gpio::Level::High),
+    )
+    .register(
+        alloc::string::String::from("led_b"),
+        crate::devices::DeviceId::new(LED_DEVICE_MAJOR, LED_B_DEVICE_MINOR),
+    )
+    .expect("Failed to register led_b");
+    crate::devices::gpio::GeneralGpio::new(
+        get_device!(led_r),
+        Some(crate::devices::gpio::Level::High),
+    )
+    .register(
+        alloc::string::String::from("led_r"),
+        crate::devices::DeviceId::new(LED_DEVICE_MAJOR, LED_R_DEVICE_MINOR),
+    )
+    .expect("Failed to register led_r");
+}
diff --git a/kernel/src/boot.rs b/kernel/src/boot.rs
index a963289e3..6c1a9f139 100644
--- a/kernel/src/boot.rs
+++ b/kernel/src/boot.rs
@@ -115,6 +115,12 @@ extern "C" fn init() {
         // initialize virtio
         virtio::init_virtio(&fdt);
     }
+    #[cfg(spi_core)]
+    crate::boards::init_spi_bus();
+    #[cfg(i2c_core)]
+    crate::boards::init_i2c_bus();
+    #[cfg(gpio)]
+    crate::boards::init_gpio();
     #[cfg(enable_vfs)]
     init_vfs();
 
@@ -129,11 +135,6 @@ extern "C" fn init() {
         net::net_manager::init();
     }
 
-    #[cfg(spi_core)]
-    crate::boards::init_spi_bus();
-    #[cfg(i2c_core)]
-    crate::boards::init_i2c_bus();
-
     // it's an bug in fact, but at now we use a workaround let newlib do the c++ runtime initialization
     #[cfg(not(target_board = "newlib_mps3_an547"))]
     run_init_array();
@@ -197,7 +198,12 @@ fn init_apps() {
     unsafe {
         let mut app = addr_of!(__bk_app_array_start);
         while app < addr_of!(__bk_app_array_end) {
-            thread::Builder::new(thread::Entry::C(*app)).start();
+            let stack =
+                thread::Stack::from_size(blueos_kconfig::CONFIG_MAIN_THREAD_STACK_SIZE as usize)
+                    .expect("Invalid main thread stack size");
+            thread::Builder::new(thread::Entry::C(*app))
+                .set_stack(stack)
+                .start();
             app = app.offset(1);
         }
     }
diff --git a/kernel/src/devices/bus/mod.rs b/kernel/src/devices/bus/mod.rs
index 6c74d1901..2f3d64d09 100644
--- a/kernel/src/devices/bus/mod.rs
+++ b/kernel/src/devices/bus/mod.rs
@@ -33,12 +33,7 @@ pub struct Bus<B: BusInterface> {
 unsafe impl<B: BusInterface> Send for Bus<B> {}
 unsafe impl<B: BusInterface> Sync for Bus<B> {}
 
-pub trait BusInterface: Sync + Send + Sized {
-    type Region;
-    fn read_region(&self, region: Self::Region, buffer: &mut [u8]) -> crate::drivers::Result<()>;
-
-    fn write_region(&self, region: Self::Region, data: &[u8]) -> crate::drivers::Result<()>;
-}
+pub trait BusInterface: Sized {}
 
 impl<B: BusInterface> Bus<B> {
     pub fn new(intf: B) -> Self {
diff --git a/kernel/src/devices/framebuffer.rs b/kernel/src/devices/framebuffer.rs
index 12044399d..768f71f68 100644
--- a/kernel/src/devices/framebuffer.rs
+++ b/kernel/src/devices/framebuffer.rs
@@ -14,9 +14,9 @@
 
 use crate::devices::{Device, DeviceClass, DeviceId, DeviceManager};
 use alloc::{format, string::String, sync::Arc, vec, vec::Vec};
+use blueos_infra::tinyrwlock::RwLock;
 use embedded_io::ErrorKind;
 use libc::{FBIOGET_FSCREENINFO, FBIOGET_VSCREENINFO, FBIOPUT_VSCREENINFO};
-use spin::Mutex;
 
 /// Linux framebuffer character-device major number.
 pub const FRAMEBUFFER_MAJOR: usize = 29;
@@ -171,7 +171,7 @@ unsafe fn store_user_variable_info(
 }
 
 /// Driver-facing framebuffer operations.
-pub trait FramebufferOps: Send + Sync {
+pub trait FramebufferOps {
     /// Return fixed framebuffer metadata.
     fn fixed_info(&self) -> Result<FramebufferFixedInfo, ErrorKind>;
 
@@ -180,31 +180,34 @@ pub trait FramebufferOps: Send + Sync {
 
     /// Validate and apply a variable-info update, returning the effective state.
     fn set_variable_info(
-        &self,
+        &mut self,
         variable_info: &FramebufferVariableInfo,
     ) -> Result<FramebufferVariableInfo, ErrorKind>;
 
     /// Read framebuffer bytes starting at `offset`.
-    fn read_bytes(&self, offset: u64, buf: &mut [u8]) -> Result<usize, ErrorKind>;
+    fn read_bytes(&mut self, offset: u64, buf: &mut [u8]) -> Result<usize, ErrorKind>;
 
     /// Write framebuffer bytes starting at `offset`.
-    fn write_bytes(&self, offset: u64, buf: &[u8]) -> Result<usize, ErrorKind>;
+    fn write_bytes(&mut self, offset: u64, buf: &[u8]) -> Result<usize, ErrorKind>;
 
     /// Return the framebuffer byte length.
     fn byte_len(&self) -> Result<u64, ErrorKind>;
 }
 
 /// Character-device wrapper for a framebuffer implementation.
-pub struct FramebufferDevice {
+pub struct FramebufferDevice<T: FramebufferOps> {
     name: String,
     id: DeviceId,
-    ops: Arc<dyn FramebufferOps>,
+    ops: Arc<RwLock<T>>,
 }
 
-impl FramebufferDevice {
+unsafe impl<T: FramebufferOps> Send for FramebufferDevice<T> {}
+unsafe impl<T: FramebufferOps> Sync for FramebufferDevice<T> {}
+
+impl<T: FramebufferOps + 'static> FramebufferDevice<T> {
     /// Create a framebuffer device named `fb{index}` with Linux framebuffer major `29`.
     #[must_use]
-    pub fn new(index: usize, ops: Arc<dyn FramebufferOps>) -> Self {
+    pub fn new(index: usize, ops: Arc<RwLock<T>>) -> Self {
         Self::with_id(
             format!("fb{index}"),
             DeviceId::new(FRAMEBUFFER_MAJOR, index),
@@ -214,12 +217,12 @@ impl FramebufferDevice {
 
     /// Create a framebuffer device with an explicit name and device id.
     #[must_use]
-    pub fn with_id(name: String, id: DeviceId, ops: Arc<dyn FramebufferOps>) -> Self {
+    pub fn with_id(name: String, id: DeviceId, ops: Arc<RwLock<T>>) -> Self {
         Self { name, id, ops }
     }
 
     /// Register a framebuffer device named `fb{index}`.
-    pub fn register(index: usize, ops: Arc<dyn FramebufferOps>) -> Result<(), ErrorKind> {
+    pub fn register(index: usize, ops: Arc<RwLock<T>>) -> Result<(), ErrorKind> {
         Self::register_device(Arc::new(Self::new(index, ops)))
     }
 
@@ -244,12 +247,12 @@ impl FramebufferDevice {
 
     /// Return fixed framebuffer metadata.
     pub fn fixed_info(&self) -> Result<FramebufferFixedInfo, ErrorKind> {
-        self.ops.fixed_info()
+        self.ops.read().fixed_info()
     }
 
     /// Return variable framebuffer metadata.
     pub fn variable_info(&self) -> Result<FramebufferVariableInfo, ErrorKind> {
-        self.ops.variable_info()
+        self.ops.read().variable_info()
     }
 
     /// Validate and apply a variable-info update, returning the effective state.
@@ -257,11 +260,11 @@ impl FramebufferDevice {
         &self,
         variable_info: &FramebufferVariableInfo,
     ) -> Result<FramebufferVariableInfo, ErrorKind> {
-        self.ops.set_variable_info(variable_info)
+        self.ops.write().set_variable_info(variable_info)
     }
 }
 
-impl Device for FramebufferDevice {
+impl<T: FramebufferOps + 'static> Device for FramebufferDevice<T> {
     fn name(&self) -> String {
         self.name.clone()
     }
@@ -279,7 +282,7 @@ impl Device for FramebufferDevice {
             return Ok(0);
         }
 
-        let byte_len = self.ops.byte_len()?;
+        let byte_len = self.ops.read().byte_len()?;
         if pos >= byte_len {
             return Ok(0);
         }
@@ -287,7 +290,7 @@ impl Device for FramebufferDevice {
         let remaining = byte_len - pos;
         let read_len =
             usize::try_from(remaining).map_or(buf.len(), |remaining| remaining.min(buf.len()));
-        self.ops.read_bytes(pos, &mut buf[..read_len])
+        self.ops.write().read_bytes(pos, &mut buf[..read_len])
     }
 
     fn write(&self, pos: u64, buf: &[u8], _is_nonblocking: bool) -> Result<usize, ErrorKind> {
@@ -295,7 +298,7 @@ impl Device for FramebufferDevice {
             return Ok(0);
         }
 
-        let byte_len = self.ops.byte_len()?;
+        let byte_len = self.ops.read().byte_len()?;
         if pos >= byte_len {
             return Ok(0);
         }
@@ -303,17 +306,17 @@ impl Device for FramebufferDevice {
         let remaining = byte_len - pos;
         let write_len =
             usize::try_from(remaining).map_or(buf.len(), |remaining| remaining.min(buf.len()));
-        self.ops.write_bytes(pos, &buf[..write_len])
+        self.ops.write().write_bytes(pos, &buf[..write_len])
     }
 
     fn ioctl(&self, request: u32, arg: usize) -> Result<(), ErrorKind> {
         match request {
             req if req == FBIOGET_FSCREENINFO => {
-                let fixed_info = self.ops.fixed_info()?;
+                let fixed_info = self.ops.read().fixed_info()?;
                 unsafe { store_user_fixed_info(arg as *mut FramebufferFixedInfo, &fixed_info) }
             }
             req if req == FBIOGET_VSCREENINFO => {
-                let variable_info = self.ops.variable_info()?;
+                let variable_info = self.ops.read().variable_info()?;
                 unsafe {
                     store_user_variable_info(arg as *mut FramebufferVariableInfo, &variable_info)
                 }
@@ -321,7 +324,7 @@ impl Device for FramebufferDevice {
             req if req == FBIOPUT_VSCREENINFO => {
                 let requested_info =
                     unsafe { load_user_variable_info(arg as *const FramebufferVariableInfo)? };
-                let effective_info = self.ops.set_variable_info(&requested_info)?;
+                let effective_info = self.ops.write().set_variable_info(&requested_info)?;
                 unsafe {
                     store_user_variable_info(arg as *mut FramebufferVariableInfo, &effective_info)
                 }
@@ -331,6 +334,6 @@ impl Device for FramebufferDevice {
     }
 
     fn capacity(&self) -> Result<u64, ErrorKind> {
-        self.ops.byte_len()
+        self.ops.read().byte_len()
     }
 }
diff --git a/kernel/src/devices/gpio/mod.rs b/kernel/src/devices/gpio/mod.rs
index 42cdf1f14..0b76b52ce 100644
--- a/kernel/src/devices/gpio/mod.rs
+++ b/kernel/src/devices/gpio/mod.rs
@@ -12,12 +12,23 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use core::cell::Cell;
+
+use crate::{
+    devices::{Device, DeviceClass, DeviceId, DeviceManager},
+    sync::SpinLock,
+};
+use alloc::{string::String, sync::Arc};
+use embedded_io::ErrorKind;
+
 pub struct GeneralGpio<T: blueos_hal::gpio::OutputPin> {
     inner: &'static T,
+    level: Option<Level>,
 }
 
 impl<T: blueos_hal::gpio::OutputPin> !Sync for GeneralGpio<T> {}
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub(crate) enum Level {
     Low,
     High,
@@ -25,18 +36,122 @@ pub(crate) enum Level {
 
 impl<T: blueos_hal::gpio::OutputPin> GeneralGpio<T> {
     pub fn new(inner: &'static T, level: Option<Level>) -> Self {
-        let mut gpio = GeneralGpio { inner };
+        let mut gpio = GeneralGpio { inner, level: None };
         if let Some(level) = level {
             gpio.set_level(level).ok();
         }
         gpio
     }
 
+    /// Register this GPIO as a character device.
+    ///
+    /// Reads return `0\n` or `1\n`; writes accept ASCII `0` or `1`, with
+    /// optional surrounding whitespace.
+    pub fn register(self, name: String, id: DeviceId) -> Result<(), ErrorKind> {
+        let device = Arc::new(GeneralGpioDevice::new(name.clone(), id, self));
+        DeviceManager::get().register_device(name, device)
+    }
+
     fn set_level(&mut self, level: Level) -> crate::drivers::Result<()> {
         match level {
-            Level::Low => self.inner.set_low().map_err(|_| crate::error::code::EIO),
-            Level::High => self.inner.set_high().map_err(|_| crate::error::code::EIO),
+            Level::Low => self.inner.set_low().map_err(|_| crate::error::code::EIO)?,
+            Level::High => self.inner.set_high().map_err(|_| crate::error::code::EIO)?,
+        };
+        self.level = Some(level);
+        Ok(())
+    }
+}
+
+struct GeneralGpioDevice<T: blueos_hal::gpio::OutputPin> {
+    name: String,
+    id: DeviceId,
+    inner: SpinLock<&'static T>,
+    level: Cell<Option<Level>>,
+}
+
+/// Safety: `GeneralGpioDevice` is safe to share between threads
+/// because it uses a `SpinLock` to protect access to the
+/// underlying GPIO pin, ensuring that only one thread can modify
+/// the pin state at a time. The `level` field is a `Cell`,
+/// which allows for interior mutability, but since it
+/// is only accessed within the locked context, it does not
+/// introduce data races. Therefore, it is safe to implement `Sync`
+unsafe impl<T: blueos_hal::gpio::OutputPin> Sync for GeneralGpioDevice<T> {}
+unsafe impl<T: blueos_hal::gpio::OutputPin> Send for GeneralGpioDevice<T> {}
+
+impl<T: blueos_hal::gpio::OutputPin> GeneralGpioDevice<T> {
+    fn new(name: String, id: DeviceId, gpio: GeneralGpio<T>) -> Self {
+        Self {
+            name,
+            id,
+            inner: SpinLock::new(gpio.inner),
+            level: Cell::new(gpio.level),
+        }
+    }
+
+    fn set_level(&self, level: Level) -> Result<(), ErrorKind> {
+        let l = self.inner.lock();
+        let mut current_level = self.level.get();
+        match level {
+            Level::Low => l.set_low().map_err(|_| ErrorKind::Other)?,
+            Level::High => l.set_high().map_err(|_| ErrorKind::Other)?,
+        };
+        self.level.set(Some(level));
+        drop(l);
+        Ok(())
+    }
+}
+
+impl<T: blueos_hal::gpio::OutputPin> Device for GeneralGpioDevice<T> {
+    fn name(&self) -> String {
+        self.name.clone()
+    }
+
+    fn class(&self) -> DeviceClass {
+        DeviceClass::Char
+    }
+
+    fn id(&self) -> DeviceId {
+        self.id
+    }
+
+    fn read(&self, pos: u64, buf: &mut [u8], _is_nonblocking: bool) -> Result<usize, ErrorKind> {
+        let l = self.inner.lock();
+        let level = self.level.get().ok_or(ErrorKind::Other)?;
+        let value = match level {
+            Level::Low => b"0\n",
+            Level::High => b"1\n",
+        };
+        let pos = usize::try_from(pos).map_err(|_| ErrorKind::InvalidInput)?;
+        if pos >= value.len() {
+            return Ok(0);
         }
+
+        let len = buf.len().min(value.len() - pos);
+        buf[..len].copy_from_slice(&value[pos..pos + len]);
+        drop(l);
+        Ok(len)
+    }
+
+    fn write(&self, _pos: u64, buf: &[u8], _is_nonblocking: bool) -> Result<usize, ErrorKind> {
+        let mut values = buf
+            .iter()
+            .copied()
+            .filter(|byte| !byte.is_ascii_whitespace());
+        let level = match values.next() {
+            Some(b'0') => Level::Low,
+            Some(b'1') => Level::High,
+            // Formatting helpers may send a trailing newline in a separate
+            // write. It has no GPIO value to apply, so accept it as a no-op.
+            None => return Ok(buf.len()),
+            _ => return Err(ErrorKind::InvalidInput),
+        };
+        if values.next().is_some() {
+            return Err(ErrorKind::InvalidInput);
+        }
+
+        self.set_level(level)?;
+        Ok(buf.len())
     }
 }
 
@@ -56,10 +171,10 @@ impl embedded_hal::digital::Error for crate::error::Error {
 #[cfg(use_embedded_hal_v1)]
 impl<T: blueos_hal::gpio::OutputPin> embedded_hal::digital::OutputPin for GeneralGpio<T> {
     fn set_low(&mut self) -> Result<(), Self::Error> {
-        self.inner.set_low().map_err(|_| crate::error::code::EIO)
+        self.set_level(Level::Low)
     }
 
     fn set_high(&mut self) -> Result<(), Self::Error> {
-        self.inner.set_high().map_err(|_| crate::error::code::EIO)
+        self.set_level(Level::High)
     }
 }
diff --git a/kernel/src/devices/i2c_core/block_i2c.rs b/kernel/src/devices/i2c_core/block_i2c.rs
index 4ef4b3665..d0b1479f2 100644
--- a/kernel/src/devices/i2c_core/block_i2c.rs
+++ b/kernel/src/devices/i2c_core/block_i2c.rs
@@ -118,23 +118,7 @@ impl<T: blueos_hal::i2c::I2c<I2cConfig, ()>> BlockI2c<T> {
     }
 }
 
-impl<T: blueos_hal::i2c::I2c<I2cConfig, ()>> BusInterface for BlockI2c<T> {
-    type Region = (bool, u8, bool);
-
-    fn read_region(&self, region: Self::Region, buffer: &mut [u8]) -> crate::drivers::Result<()> {
-        let (first, address, last) = region;
-        self.read_bytes(address, buffer, first, last)
-            .map_err(|error| self.report_error("read", error))?;
-        Ok(())
-    }
-
-    fn write_region(&self, region: Self::Region, data: &[u8]) -> crate::drivers::Result<()> {
-        let (first, address, last) = region;
-        self.write_bytes(address, data, first, last)
-            .map_err(|error| self.report_error("write", error))?;
-        Ok(())
-    }
-}
+impl<T: blueos_hal::i2c::I2c<I2cConfig, ()>> BusInterface for BlockI2c<T> {}
 
 #[cfg(use_embedded_hal_v1)]
 impl<T: blueos_hal::i2c::I2c<I2cConfig, ()>> embedded_hal::i2c::ErrorType
@@ -175,12 +159,12 @@ impl<T: blueos_hal::i2c::I2c<I2cConfig, ()>> embedded_hal::i2c::I2c for BusWrapp
         while let Some(operation) = operations.next() {
             let last = operations.peek().is_none();
             match operation {
-                embedded_hal::i2c::Operation::Read(buf) => {
-                    inner.read_region((first, address, last), buf)?
-                }
-                embedded_hal::i2c::Operation::Write(buf) => {
-                    inner.write_region((first, address, last), buf)?
-                }
+                embedded_hal::i2c::Operation::Read(buf) => inner
+                    .read_bytes(address, buf, first, last)
+                    .map_err(|error| inner.report_error("read", error))?,
+                embedded_hal::i2c::Operation::Write(buf) => inner
+                    .write_bytes(address, buf, first, last)
+                    .map_err(|error| inner.report_error("write", error))?,
             };
             first = false;
         }
diff --git a/kernel/src/devices/mod.rs b/kernel/src/devices/mod.rs
index c53272de5..31f86773f 100644
--- a/kernel/src/devices/mod.rs
+++ b/kernel/src/devices/mod.rs
@@ -423,20 +423,7 @@ mod tests {
     }
 
     struct DummyBus;
-    impl BusInterface for DummyBus {
-        type Region = u8;
-        fn read_region(
-            &self,
-            region: Self::Region,
-            buffer: &mut [u8],
-        ) -> crate::drivers::Result<()> {
-            Ok(())
-        }
-
-        fn write_region(&self, region: Self::Region, data: &[u8]) -> crate::drivers::Result<()> {
-            Ok(())
-        }
-    }
+    impl BusInterface for DummyBus {}
 
     #[test]
     fn test_device_match() {
diff --git a/kernel/src/devices/spi_core/block_spi.rs b/kernel/src/devices/spi_core/block_spi.rs
index 772b86ce1..cdd0788a9 100644
--- a/kernel/src/devices/spi_core/block_spi.rs
+++ b/kernel/src/devices/spi_core/block_spi.rs
@@ -42,88 +42,29 @@ impl<T: blueos_hal::spi::Spi<SpiConfig, ()>, G: blueos_hal::gpio::OutputPin> Blo
         self.cs.set_high().ok();
     }
 
-    fn read(&mut self, words: &mut [u8]) -> Result<(), crate::error::Error> {
+    pub fn read(&mut self, words: &mut [u8]) -> Result<(), crate::error::Error> {
         self.inner.read(words).map_err(|_| crate::error::code::EIO)
     }
 
-    fn write(&mut self, words: &[u8]) -> Result<(), crate::error::Error> {
+    pub fn write(&mut self, words: &[u8]) -> Result<(), crate::error::Error> {
         self.inner.write(words).map_err(|_| crate::error::code::EIO)
     }
 
-    fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), crate::error::Error> {
+    pub fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), crate::error::Error> {
         self.inner
             .transfer(read, write)
             .map_err(|_| crate::error::code::EIO)
     }
 
-    fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), crate::error::Error> {
+    pub fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), crate::error::Error> {
         self.inner
             .write(words)
             .map_err(|_| crate::error::code::EIO)?;
         self.inner.read(words).map_err(|_| crate::error::code::EIO)
     }
-
-    fn flush(&mut self) -> Result<(), crate::error::Error> {
-        Ok(())
-    }
 }
 
 impl<T: blueos_hal::spi::Spi<SpiConfig, ()>, G: blueos_hal::gpio::OutputPin> BusInterface
     for BlockSpi<T, G>
 {
-    type Region = ();
-
-    fn read_region(&self, region: Self::Region, buffer: &mut [u8]) -> crate::drivers::Result<()> {
-        todo!()
-    }
-
-    fn write_region(&self, region: Self::Region, data: &[u8]) -> crate::drivers::Result<()> {
-        todo!()
-    }
-}
-
-#[cfg(use_embedded_hal_v1)]
-impl<T: blueos_hal::spi::Spi<SpiConfig, ()>, G: blueos_hal::gpio::OutputPin>
-    embedded_hal::spi::ErrorType for BusWrapper<BlockSpi<T, G>>
-{
-    type Error = crate::error::Error;
-}
-
-#[cfg(use_embedded_hal_v1)]
-impl embedded_hal::spi::Error for crate::error::Error {
-    fn kind(&self) -> embedded_hal::spi::ErrorKind {
-        // FIXME: Map the error code to embedded_hal::spi::ErrorKind
-        embedded_hal::spi::ErrorKind::Other
-    }
-}
-
-#[cfg(use_embedded_hal_v1)]
-impl<T: blueos_hal::spi::Spi<SpiConfig, ()>, G: blueos_hal::gpio::OutputPin>
-    embedded_hal::spi::SpiDevice<u8> for BusWrapper<BlockSpi<T, G>>
-{
-    fn transaction(&mut self, operations: &mut [Operation<'_, u8>]) -> Result<(), Self::Error> {
-        let mut inner = self.0.lock();
-        inner.assert_cs();
-
-        let op_res = operations.iter_mut().try_for_each(|op| match op {
-            Operation::Read(buf) => inner.read(buf),
-            Operation::Write(buf) => inner.write(buf),
-            Operation::Transfer(read, write) => inner.transfer(read, write),
-            Operation::TransferInPlace(buf) => inner.transfer_in_place(buf),
-            Operation::DelayNs(ns) => {
-                use embedded_hal::delay::DelayNs;
-                inner.flush()?;
-                let mut kernel = KernelDelay;
-                kernel.delay_ns(*ns);
-                Ok(())
-            }
-        });
-
-        let flush_res = inner.flush();
-        inner.deassert_cs();
-        op_res?;
-        flush_res?;
-
-        Ok(())
-    }
 }
diff --git a/kernel/src/devices/spi_core/mod.rs b/kernel/src/devices/spi_core/mod.rs
index 56d071305..eefc13752 100644
--- a/kernel/src/devices/spi_core/mod.rs
+++ b/kernel/src/devices/spi_core/mod.rs
@@ -12,4 +12,78 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use crate::{
+    devices::{bus::BusWrapper, spi_core::block_spi::BlockSpi},
+    sync::KernelDelay,
+};
+use blueos_driver::spi::SpiConfig;
+use embedded_hal::spi::Operation;
 pub mod block_spi;
+
+pub struct ExclusiveSpiWithCs<
+    T: blueos_hal::spi::Spi<SpiConfig, ()>,
+    G: blueos_hal::gpio::OutputPin,
+> {
+    spi: BusWrapper<BlockSpi<T, G>>,
+    cs: &'static G,
+}
+
+impl<T: blueos_hal::spi::Spi<SpiConfig, ()>, G: blueos_hal::gpio::OutputPin>
+    ExclusiveSpiWithCs<T, G>
+{
+    pub fn new(spi: BusWrapper<BlockSpi<T, G>>, cs: &'static G) -> Self {
+        ExclusiveSpiWithCs { spi, cs }
+    }
+
+    fn assert_cs(&self) {
+        self.cs.set_low().ok();
+    }
+
+    fn deassert_cs(&self) {
+        self.cs.set_high().ok();
+    }
+}
+
+#[cfg(use_embedded_hal_v1)]
+impl embedded_hal::spi::Error for crate::error::Error {
+    fn kind(&self) -> embedded_hal::spi::ErrorKind {
+        // FIXME: Map the error code to embedded_hal::spi::ErrorKind
+        embedded_hal::spi::ErrorKind::Other
+    }
+}
+
+#[cfg(use_embedded_hal_v1)]
+impl<T: blueos_hal::spi::Spi<SpiConfig, ()>, G: blueos_hal::gpio::OutputPin>
+    embedded_hal::spi::ErrorType for ExclusiveSpiWithCs<T, G>
+{
+    type Error = crate::error::Error;
+}
+
+#[cfg(use_embedded_hal_v1)]
+impl<T: blueos_hal::spi::Spi<SpiConfig, ()>, G: blueos_hal::gpio::OutputPin>
+    embedded_hal::spi::SpiDevice<u8> for ExclusiveSpiWithCs<T, G>
+{
+    fn transaction(
+        &mut self,
+        operations: &mut [embedded_hal::spi::Operation<'_, u8>],
+    ) -> Result<(), Self::Error> {
+        let mut inner = self.spi.0.lock();
+        self.assert_cs();
+
+        let op_res = operations.iter_mut().try_for_each(|op| match op {
+            Operation::Read(buf) => inner.read(buf),
+            Operation::Write(buf) => inner.write(buf),
+            Operation::Transfer(read, write) => inner.transfer(read, write),
+            Operation::TransferInPlace(buf) => inner.transfer_in_place(buf),
+            Operation::DelayNs(ns) => {
+                use embedded_hal::delay::DelayNs;
+                let mut kernel = KernelDelay;
+                kernel.delay_ns(*ns);
+                Ok(())
+            }
+        });
+
+        self.deassert_cs();
+        Ok(())
+    }
+}
diff --git a/kernel/src/drivers/input/ft6336u.rs b/kernel/src/drivers/input/ft6336u.rs
new file mode 100644
index 000000000..8915d17e0
--- /dev/null
+++ b/kernel/src/drivers/input/ft6336u.rs
@@ -0,0 +1,207 @@
+// Copyright (c) 2026 vivo Mobile Communication Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use blueos_driver::i2c::I2cConfig;
+use embedded_io::ErrorKind;
+use ft6336u_driver::{TouchData, TouchStatus, FT6336U};
+
+use crate::{
+    devices::{
+        bus::{Bus, BusWrapper},
+        gpio::{GeneralGpio, Level},
+        i2c_core::block_i2c::BlockI2c,
+        Device, DeviceClass, DeviceData, DeviceId, DeviceManager,
+    },
+    drivers::{DriverModule, InitDriver, Result as DriverResult},
+    sync::{KernelDelay, SpinLock},
+};
+use alloc::{string::String, sync::Arc};
+
+const FT6336U_CHIP_ID: u8 = 0x64;
+const RESET_LOW_MS: u32 = 10;
+const STARTUP_DELAY_MS: u32 = 300;
+const CHIP_ID_RETRIES: usize = 5;
+const CHIP_ID_RETRY_DELAY_MS: u32 = 50;
+const FT6336U_DEVICE_NAME: &str = "ft6336u0";
+const FT6336U_DEVICE_MAJOR: usize = 240;
+const FT6336U_DEVICE_MINOR: usize = 0;
+
+/// Binary report returned by `/dev/ft6336u0`.
+///
+/// Layout (all 16-bit fields are little-endian):
+/// - byte 0: format version (`1`)
+/// - byte 1: active touch count (`0..=2`)
+/// - bytes 2..=6: point 0 status, x, y
+/// - bytes 7..=11: point 1 status, x, y
+///
+/// Status values are `0 = released`, `1 = new touch`, `2 = continuing touch`.
+pub const FT6336U_REPORT_SIZE: usize = 12;
+const FT6336U_REPORT_VERSION: u8 = 1;
+
+pub struct Ft6336uDevice<T: blueos_hal::i2c::I2c<I2cConfig, ()>> {
+    touch: SpinLock<FT6336U<BusWrapper<BlockI2c<T>>>>,
+}
+
+impl<T: blueos_hal::i2c::I2c<I2cConfig, ()>> Ft6336uDevice<T> {
+    fn new(touch: FT6336U<BusWrapper<BlockI2c<T>>>) -> Self {
+        Self {
+            touch: SpinLock::new(touch),
+        }
+    }
+
+    fn encode_report(data: TouchData, report: &mut [u8; FT6336U_REPORT_SIZE]) {
+        report[0] = FT6336U_REPORT_VERSION;
+        report[1] = data.touch_count.min(2);
+
+        for (index, point) in data.points.iter().enumerate() {
+            let offset = 2 + index * 5;
+            report[offset] = match point.status {
+                TouchStatus::Release => 0,
+                TouchStatus::Touch => 1,
+                TouchStatus::Stream => 2,
+            };
+            report[offset + 1..offset + 3].copy_from_slice(&point.x.to_le_bytes());
+            report[offset + 3..offset + 5].copy_from_slice(&point.y.to_le_bytes());
+        }
+    }
+}
+
+impl<T: blueos_hal::i2c::I2c<I2cConfig, ()>> Device for Ft6336uDevice<T> {
+    fn name(&self) -> String {
+        String::from(FT6336U_DEVICE_NAME)
+    }
+
+    fn class(&self) -> DeviceClass {
+        DeviceClass::Char
+    }
+
+    fn id(&self) -> DeviceId {
+        DeviceId::new(FT6336U_DEVICE_MAJOR, FT6336U_DEVICE_MINOR)
+    }
+
+    fn read(
+        &self,
+        _pos: u64,
+        buf: &mut [u8],
+        _is_nonblocking: bool,
+    ) -> core::result::Result<usize, ErrorKind> {
+        if buf.len() < FT6336U_REPORT_SIZE {
+            return Err(ErrorKind::InvalidInput);
+        }
+
+        let data = self.touch.lock().scan().map_err(|error| {
+            log::warn!("Failed to scan FT6336U touch data: {:?}", error);
+            ErrorKind::Other
+        })?;
+        let mut report = [0u8; FT6336U_REPORT_SIZE];
+        Self::encode_report(data, &mut report);
+        buf[..FT6336U_REPORT_SIZE].copy_from_slice(&report);
+        Ok(FT6336U_REPORT_SIZE)
+    }
+
+    fn write(
+        &self,
+        _pos: u64,
+        _buf: &[u8],
+        _is_nonblocking: bool,
+    ) -> core::result::Result<usize, ErrorKind> {
+        Err(ErrorKind::Unsupported)
+    }
+}
+
+pub struct Ft6336uConfig<G: blueos_hal::gpio::OutputPin> {
+    pub rst: &'static G,
+}
+
+impl<T: blueos_hal::i2c::I2c<I2cConfig, ()>, G: blueos_hal::gpio::OutputPin> InitDriver<BlockI2c<T>>
+    for Ft6336uConfig<G>
+{
+    type Data = ();
+    fn init(self, bus: &Bus<BlockI2c<T>>) -> DriverResult<Self::Data> {
+        use embedded_hal::{delay::DelayNs, digital::OutputPin};
+
+        let mut delay = KernelDelay;
+        let mut rst = GeneralGpio::new(self.rst, Some(Level::Low));
+        delay.delay_ms(RESET_LOW_MS);
+        rst.set_high()?;
+        delay.delay_ms(STARTUP_DELAY_MS);
+
+        let mut touch = FT6336U::new(bus.intf.clone());
+        let mut last_chip_id = None;
+        for attempt in 0..CHIP_ID_RETRIES {
+            match touch.read_chip_id() {
+                Ok(FT6336U_CHIP_ID) => {
+                    log::debug!("FT6336U chip ID: 0x{:X}", FT6336U_CHIP_ID);
+                    let device = Arc::new(Ft6336uDevice::<T>::new(touch));
+                    DeviceManager::get()
+                        .register_device(String::from(FT6336U_DEVICE_NAME), device)
+                        .map_err(|_| crate::error::code::EIO)?;
+                    return Ok(());
+                }
+                Ok(id) => last_chip_id = Some(id),
+                Err(error) if attempt + 1 == CHIP_ID_RETRIES => {
+                    log::warn!("Failed to read FT6336U chip ID: {:?}", error);
+                }
+                Err(_) => {}
+            }
+
+            if attempt + 1 < CHIP_ID_RETRIES {
+                delay.delay_ms(CHIP_ID_RETRY_DELAY_MS);
+            }
+        }
+
+        log::warn!(
+            "Unexpected FT6336U chip ID: {:?}, library version: {:?}, firmware ID: {:?}, FocalTech ID: {:?}",
+            last_chip_id,
+            touch.read_library_version(),
+            touch.read_firmware_id(),
+            touch.read_focaltech_id(),
+        );
+        Err(crate::error::code::EIO)
+    }
+}
+
+pub struct Ft6336uDriverModule<G> {
+    _marker: core::marker::PhantomData<G>,
+}
+
+impl<G> Ft6336uDriverModule<G> {
+    pub const fn new() -> Self {
+        Ft6336uDriverModule {
+            _marker: core::marker::PhantomData,
+        }
+    }
+}
+
+impl<T: blueos_hal::i2c::I2c<I2cConfig, ()>, G: blueos_hal::gpio::OutputPin>
+    DriverModule<BlockI2c<T>> for Ft6336uDriverModule<G>
+{
+    type Data = Ft6336uConfig<G>;
+    fn probe(dev: &crate::devices::DeviceData) -> DriverResult<Self::Data> {
+        match dev {
+            DeviceData::Native(native_dev) => {
+                if native_dev.is_attached() {
+                    return Err(crate::error::code::ENODEV);
+                }
+
+                if let Some(config) = native_dev.config::<Ft6336uConfig<G>>() {
+                    Ok(Ft6336uConfig::<G> { rst: config.rst })
+                } else {
+                    Err(crate::error::code::ENODEV)
+                }
+            }
+            _ => Err(crate::error::code::ENODEV),
+        }
+    }
+}
diff --git a/kernel/src/drivers/input/mod.rs b/kernel/src/drivers/input/mod.rs
new file mode 100644
index 000000000..78018b93f
--- /dev/null
+++ b/kernel/src/drivers/input/mod.rs
@@ -0,0 +1,16 @@
+// Copyright (c) 2026 vivo Mobile Communication Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#[cfg(ft6336u)]
+pub mod ft6336u;
diff --git a/kernel/src/drivers/lcd/mod.rs b/kernel/src/drivers/lcd/mod.rs
index 2faab8afa..185204bf1 100644
--- a/kernel/src/drivers/lcd/mod.rs
+++ b/kernel/src/drivers/lcd/mod.rs
@@ -19,7 +19,7 @@ use crate::devices::framebuffer::{
     FramebufferVariableInfo,
 };
 use alloc::sync::Arc;
-use spin::Mutex;
+use blueos_infra::tinyrwlock::RwLock;
 
 // FIXME: Only support 16-bit RGB565 format for now, need to support more formats in the future.
 const LCD_BITS_PER_PIXEL: u32 = 16;
@@ -35,7 +35,7 @@ pub mod st7796;
 pub struct LcdFramebuffer<T> {
     width: u32,
     height: u32,
-    display: Mutex<T>,
+    display: T,
 }
 
 impl<T: Lcd> LcdFramebuffer<T> {
@@ -46,14 +46,16 @@ impl<T: Lcd> LcdFramebuffer<T> {
     fn byte_len(&self) -> u32 {
         self.line_length() * self.height
     }
+}
 
+impl<T: Lcd + 'static> LcdFramebuffer<T> {
     fn register_lcd(lcd: T, width: u32, height: u32) -> Result<(), embedded_io::ErrorKind> {
         static INDEX: AtomicUsize = AtomicUsize::new(0);
-        let fb = Arc::new(LcdFramebuffer::<T> {
+        let fb = Arc::new(RwLock::new(LcdFramebuffer::<T> {
             width,
             height,
-            display: Mutex::new(lcd),
-        });
+            display: lcd,
+        }));
         FramebufferDevice::register(INDEX.load(core::sync::atomic::Ordering::Relaxed), fb)?;
         INDEX.fetch_add(1, core::sync::atomic::Ordering::SeqCst);
         Ok(())
@@ -105,17 +107,17 @@ impl<T: Lcd> FramebufferOps for LcdFramebuffer<T> {
     }
 
     fn set_variable_info(
-        &self,
+        &mut self,
         variable_info: &crate::devices::framebuffer::FramebufferVariableInfo,
     ) -> Result<crate::devices::framebuffer::FramebufferVariableInfo, embedded_io::ErrorKind> {
         todo!()
     }
 
-    fn read_bytes(&self, offset: u64, buf: &mut [u8]) -> Result<usize, embedded_io::ErrorKind> {
+    fn read_bytes(&mut self, offset: u64, buf: &mut [u8]) -> Result<usize, embedded_io::ErrorKind> {
         todo!()
     }
 
-    fn write_bytes(&self, offset: u64, buf: &[u8]) -> Result<usize, embedded_io::ErrorKind> {
+    fn write_bytes(&mut self, offset: u64, buf: &[u8]) -> Result<usize, embedded_io::ErrorKind> {
         if offset % u64::from(LCD_BYTES_PER_PIXEL) != 0
             || buf.len() % LCD_BYTES_PER_PIXEL as usize != 0
         {
@@ -125,7 +127,7 @@ impl<T: Lcd> FramebufferOps for LcdFramebuffer<T> {
         let mut pixel_index = u32::try_from(offset / u64::from(LCD_BYTES_PER_PIXEL))
             .map_err(|_| embedded_io::ErrorKind::InvalidInput)?;
         let mut written = 0;
-        let mut display = self.display.lock();
+        let mut display = &mut self.display;
 
         while written < buf.len() {
             let row = pixel_index / self.width;
@@ -178,6 +180,6 @@ fn lcd_error_to_io_error(error: LcdError) -> embedded_io::ErrorKind {
     }
 }
 
-pub trait Lcd: Send + 'static {
+pub trait Lcd {
     fn draw_area(&mut self, area: DrawArea, color: &[u8]) -> Result<(), LcdError>;
 }
diff --git a/kernel/src/drivers/lcd/st7789.rs b/kernel/src/drivers/lcd/st7789.rs
index a91ce0d3a..9bc7699a2 100644
--- a/kernel/src/drivers/lcd/st7789.rs
+++ b/kernel/src/drivers/lcd/st7789.rs
@@ -33,6 +33,7 @@ use mipidsi::{
 pub struct St7789Config<G: blueos_hal::gpio::OutputPin> {
     pub rst: &'static G,
     pub dc: &'static G,
+    pub cs: Option<&'static G>,
 }
 
 static mut BUFFER: [u8; 512] = [0; 512];
@@ -91,6 +92,7 @@ impl<T: blueos_hal::spi::Spi<SpiConfig, ()>, G: blueos_hal::gpio::OutputPin>
                     Ok(St7789Config::<G> {
                         rst: config.rst,
                         dc: config.dc,
+                        cs: config.cs,
                     })
                 } else {
                     Err(crate::error::code::ENODEV)
diff --git a/kernel/src/drivers/lcd/st7796.rs b/kernel/src/drivers/lcd/st7796.rs
index 045dbc3a9..cbb930061 100644
--- a/kernel/src/drivers/lcd/st7796.rs
+++ b/kernel/src/drivers/lcd/st7796.rs
@@ -16,7 +16,7 @@ use crate::{
     devices::{
         bus::{Bus, BusWrapper},
         gpio::{GeneralGpio, Level},
-        spi_core::block_spi::BlockSpi,
+        spi_core::{block_spi::BlockSpi, ExclusiveSpiWithCs},
         DeviceData,
     },
     drivers::{DriverModule, InitDriver},
@@ -34,6 +34,7 @@ use mipidsi::{
 pub struct St7796Config<G: blueos_hal::gpio::OutputPin> {
     pub rst: &'static G,
     pub dc: &'static G,
+    pub cs: Option<&'static G>,
     pub orientation: Orientation,
 }
 
@@ -54,6 +55,7 @@ impl<T: blueos_hal::spi::Spi<SpiConfig, ()>, G: blueos_hal::gpio::OutputPin>
 
         let orientation = self.orientation;
         let spi_device = bus.intf.clone();
+        let spi_device = ExclusiveSpiWithCs::new(spi_device, self.cs.unwrap());
         let di = SpiInterface::new(spi_device, dc, unsafe { &mut BUFFER });
         let display = Builder::new(ST7796, di)
             .reset_pin(rst)
@@ -98,6 +100,7 @@ impl<T: blueos_hal::spi::Spi<SpiConfig, ()>, G: blueos_hal::gpio::OutputPin>
                     Ok(St7796Config::<G> {
                         rst: config.rst,
                         dc: config.dc,
+                        cs: config.cs,
                         orientation: config.orientation,
                     })
                 } else {
@@ -111,10 +114,10 @@ impl<T: blueos_hal::spi::Spi<SpiConfig, ()>, G: blueos_hal::gpio::OutputPin>
 
 impl<
         G1: blueos_hal::gpio::OutputPin,
-        G2: embedded_hal::digital::OutputPin + Send + 'static,
+        G2: embedded_hal::digital::OutputPin + 'static,
         T: blueos_hal::spi::Spi<SpiConfig, ()>,
     > super::Lcd
-    for Display<SpiInterface<'static, BusWrapper<BlockSpi<T, G1>>, G2>, ST7796, GeneralGpio<G1>>
+    for Display<SpiInterface<'static, ExclusiveSpiWithCs<T, G1>, G2>, ST7796, GeneralGpio<G1>>
 {
     fn draw_area(&mut self, area: super::DrawArea, color: &[u8]) -> Result<(), super::LcdError> {
         let area_width = area
diff --git a/kernel/src/drivers/mod.rs b/kernel/src/drivers/mod.rs
index d14991be5..69c80503a 100644
--- a/kernel/src/drivers/mod.rs
+++ b/kernel/src/drivers/mod.rs
@@ -17,6 +17,8 @@
 use crate::devices::bus::{Bus, BusInterface};
 
 pub(crate) mod ic;
+pub(crate) mod input;
+#[cfg(lcd)]
 pub(crate) mod lcd;
 pub(crate) mod msip;
 pub(crate) mod sensor;
diff --git a/kernel/src/drivers/sensor/bme280.rs b/kernel/src/drivers/sensor/bme280.rs
index 55325bbe2..ef0e6ef37 100644
--- a/kernel/src/drivers/sensor/bme280.rs
+++ b/kernel/src/drivers/sensor/bme280.rs
@@ -14,23 +14,136 @@
 
 use blueos_driver::i2c::I2cConfig;
 use blueos_hal::PlatPeri;
-use blueos_infra::tinyarc::TinyArc;
 use bme280::i2c::BME280;
+use embedded_hal::delay::DelayNs;
+use embedded_io::ErrorKind;
 
 use crate::{
-    devices::{bus::Bus, i2c_core::block_i2c::BlockI2c, DeviceData},
+    devices::{
+        bus::{Bus, BusWrapper},
+        i2c_core::block_i2c::BlockI2c,
+        Device, DeviceClass, DeviceData, DeviceId, DeviceManager,
+    },
     drivers::{DriverModule, InitDriver},
-    sync::KernelDelay,
+    sync::{KernelDelay, SpinLock},
 };
+use alloc::{string::String, sync::Arc};
+
+const BME280_RESET_DELAY_MS: u32 = 2;
+const BME280_SAFE_RESET_DELAY_MS: u32 = 10;
+const BME280_DEVICE_NAME: &str = "bme2800";
+const BME280_DEVICE_MAJOR: usize = 241;
+const BME280_DEVICE_MINOR: usize = 0;
+
+/// Binary measurement report returned by `/dev/bme2800`.
+///
+/// Layout (all multi-byte fields are little-endian):
+/// - byte 0: format version (`1`)
+/// - bytes 1..=4: temperature in milli-degrees Celsius (`i32`)
+/// - bytes 5..=8: pressure in pascals (`u32`)
+/// - bytes 9..=12: relative humidity in thousandths of a percent (`u32`)
+pub const BME280_REPORT_SIZE: usize = 13;
+const BME280_REPORT_VERSION: u8 = 1;
+
+/// Extends the BME280 crate's nominal post-reset delay so the sensor has
+/// enough time to copy its NVM calibration data before initialization reads it.
+struct Bme280Delay(KernelDelay);
+
+impl DelayNs for Bme280Delay {
+    fn delay_ns(&mut self, ns: u32) {
+        self.0.delay_ns(ns);
+    }
+
+    fn delay_ms(&mut self, ms: u32) {
+        let ms = if ms == BME280_RESET_DELAY_MS {
+            BME280_SAFE_RESET_DELAY_MS
+        } else {
+            ms
+        };
+        self.0.delay_ms(ms);
+    }
+}
 
 #[derive(Default)]
 pub struct Bme280Config {
     pub device_addr: u8,
 }
 
-#[derive(Default)]
-pub struct Bme280Driver {
-    device_addr: u8,
+pub struct Bme280Device<T: blueos_hal::i2c::I2c<I2cConfig, ()>> {
+    sensor: SpinLock<BME280<BusWrapper<BlockI2c<T>>>>,
+}
+
+impl<T: blueos_hal::i2c::I2c<I2cConfig, ()>> Bme280Device<T> {
+    fn new(sensor: BME280<BusWrapper<BlockI2c<T>>>) -> Self {
+        Self {
+            sensor: SpinLock::new(sensor),
+        }
+    }
+
+    fn encode_report(
+        temperature: f32,
+        pressure: f32,
+        humidity: f32,
+        report: &mut [u8; BME280_REPORT_SIZE],
+    ) {
+        let temperature_milli_celsius = (temperature * 1_000.0) as i32;
+        let pressure_pascals = pressure as u32;
+        let humidity_milli_percent = (humidity * 1_000.0) as u32;
+
+        report[0] = BME280_REPORT_VERSION;
+        report[1..5].copy_from_slice(&temperature_milli_celsius.to_le_bytes());
+        report[5..9].copy_from_slice(&pressure_pascals.to_le_bytes());
+        report[9..13].copy_from_slice(&humidity_milli_percent.to_le_bytes());
+    }
+}
+
+impl<T: blueos_hal::i2c::I2c<I2cConfig, ()>> Device for Bme280Device<T> {
+    fn name(&self) -> String {
+        String::from(BME280_DEVICE_NAME)
+    }
+
+    fn class(&self) -> DeviceClass {
+        DeviceClass::Char
+    }
+
+    fn id(&self) -> DeviceId {
+        DeviceId::new(BME280_DEVICE_MAJOR, BME280_DEVICE_MINOR)
+    }
+
+    fn read(
+        &self,
+        _pos: u64,
+        buf: &mut [u8],
+        _is_nonblocking: bool,
+    ) -> core::result::Result<usize, ErrorKind> {
+        if buf.len() < BME280_REPORT_SIZE {
+            return Err(ErrorKind::InvalidInput);
+        }
+
+        let mut delay = Bme280Delay(KernelDelay);
+        let measurements = self.sensor.lock().measure(&mut delay).map_err(|error| {
+            log::warn!("Failed to measure BME280 data: {:?}", error);
+            ErrorKind::Other
+        })?;
+        let mut report = [0u8; BME280_REPORT_SIZE];
+        Self::encode_report(
+            measurements.temperature,
+            measurements.pressure,
+            measurements.humidity,
+            &mut report,
+        );
+        buf[..BME280_REPORT_SIZE].copy_from_slice(&report);
+        Ok(BME280_REPORT_SIZE)
+    }
+
+    fn write(
+        &self,
+        _pos: u64,
+        _buf: &[u8],
+        _is_nonblocking: bool,
+    ) -> core::result::Result<usize, ErrorKind> {
+        Err(ErrorKind::Unsupported)
+    }
 }
 
 impl Bme280Config {
@@ -42,7 +155,7 @@ impl Bme280Config {
 impl<T: blueos_hal::i2c::I2c<I2cConfig, ()>> InitDriver<BlockI2c<T>> for Bme280Config {
     type Data = ();
     fn init(self, bus: &Bus<BlockI2c<T>>) -> crate::drivers::Result<Self::Data> {
-        let mut delay = KernelDelay;
+        let mut delay = Bme280Delay(KernelDelay);
 
         let mut bme280 = match self.device_addr {
             0x76 => BME280::new_primary(bus.intf.clone()),
@@ -54,9 +167,15 @@ impl<T: blueos_hal::i2c::I2c<I2cConfig, ()>> InitDriver<BlockI2c<T>> for Bme280C
             .init(&mut delay)
             .map_err(|_| crate::error::code::EINVAL)?;
 
+        let device = Arc::new(Bme280Device::<T>::new(bme280));
+        DeviceManager::get()
+            .register_device(String::from(BME280_DEVICE_NAME), device)
+            .map_err(|_| crate::error::code::EIO)?;
+
         log::info!(
-            "BME280 initialized successfully at address 0x{:X}",
-            self.device_addr
+            "BME280 initialized successfully at address 0x{:X} as /dev/{}",
+            self.device_addr,
+            BME280_DEVICE_NAME
         );
 
         Ok(())
diff --git a/kernel/src/vfs/path.rs b/kernel/src/vfs/path.rs
index ec6f2560a..2a7e643f8 100644
--- a/kernel/src/vfs/path.rs
+++ b/kernel/src/vfs/path.rs
@@ -122,8 +122,13 @@ pub fn open_path(path: &str, flags: i32, mode: mode_t) -> Result<File, Error> {
             }
         }
     };
-    // resize to 0 if O_TRUNC is set
-    if open_flags.contains(OpenFlags::O_TRUNC) && access_mode.is_writable() {
+    // Linux applies O_TRUNC only to regular files. Device nodes and other
+    // special files ignore it, which allows shell redirection such as
+    // `echo 1 > /dev/led_b` to open a character device successfully.
+    if open_flags.contains(OpenFlags::O_TRUNC)
+        && access_mode.is_writable()
+        && dcache.type_().is_regular_file()
+    {
         dcache.inode().resize(0)?;
     }