1abe3a6eaShanjiezhou use core::{ 2abe3a6eaShanjiezhou fmt::Debug, 3abe3a6eaShanjiezhou intrinsics::unlikely, 4abe3a6eaShanjiezhou sync::atomic::{AtomicBool, AtomicU32, Ordering}, 5abe3a6eaShanjiezhou }; 6abe3a6eaShanjiezhou 7abe3a6eaShanjiezhou use alloc::{boxed::Box, collections::LinkedList, string::String, sync::Arc}; 8abe3a6eaShanjiezhou 9abe3a6eaShanjiezhou use crate::{ 101496ba7bSLoGin driver::{ 11*a03c4f9dSLoGin tty::serial::serial8250::send_to_default_serial8250_port, video::video_refresh_manager, 12abe3a6eaShanjiezhou }, 13abe3a6eaShanjiezhou libs::{rwlock::RwLock, spinlock::SpinLock}, 14abe3a6eaShanjiezhou mm::VirtAddr, 15abe3a6eaShanjiezhou syscall::SystemError, 16abe3a6eaShanjiezhou }; 17abe3a6eaShanjiezhou 18abe3a6eaShanjiezhou use super::textui_no_alloc::textui_init_no_alloc; 19abe3a6eaShanjiezhou 20abe3a6eaShanjiezhou /// 全局的UI框架列表 211496ba7bSLoGin pub static SCM_FRAMEWORK_LIST: SpinLock<LinkedList<Arc<dyn ScmUiFramework>>> = 22abe3a6eaShanjiezhou SpinLock::new(LinkedList::new()); 23abe3a6eaShanjiezhou 241496ba7bSLoGin /// 当前在使用的UI框架 251496ba7bSLoGin pub static CURRENT_FRAMEWORK: RwLock<Option<Arc<dyn ScmUiFramework>>> = RwLock::new(None); 26abe3a6eaShanjiezhou 27abe3a6eaShanjiezhou /// 是否启用双缓冲 28abe3a6eaShanjiezhou pub static SCM_DOUBLE_BUFFER_ENABLED: AtomicBool = AtomicBool::new(false); 29abe3a6eaShanjiezhou 30abe3a6eaShanjiezhou bitflags! { 31abe3a6eaShanjiezhou pub struct ScmBufferFlag:u8 { 32abe3a6eaShanjiezhou // 帧缓冲区标志位 33abe3a6eaShanjiezhou const SCM_BF_FB = 1 << 0; // 当前buffer是设备显存中的帧缓冲区 34abe3a6eaShanjiezhou const SCM_BF_DB = 1 << 1; // 当前buffer是双缓冲 35abe3a6eaShanjiezhou const SCM_BF_TEXT = 1 << 2; // 使用文本模式 36abe3a6eaShanjiezhou const SCM_BF_PIXEL = 1 << 3; // 使用图像模式 37abe3a6eaShanjiezhou } 38abe3a6eaShanjiezhou } 39abe3a6eaShanjiezhou #[derive(Clone, Debug)] 40abe3a6eaShanjiezhou #[allow(dead_code)] 41abe3a6eaShanjiezhou pub enum ScmFramworkType { 42abe3a6eaShanjiezhou Text, 43abe3a6eaShanjiezhou Gui, 44abe3a6eaShanjiezhou Unused, 45abe3a6eaShanjiezhou } 461496ba7bSLoGin #[derive(Debug, Clone)] 47abe3a6eaShanjiezhou pub enum ScmBuffer { 481496ba7bSLoGin DeviceBuffer(VirtAddr), 491496ba7bSLoGin DoubleBuffer(Arc<SpinLock<Box<[u32]>>>), 50abe3a6eaShanjiezhou } 511496ba7bSLoGin 521496ba7bSLoGin #[derive(Debug, Clone)] 53abe3a6eaShanjiezhou pub struct ScmBufferInfo { 54abe3a6eaShanjiezhou width: u32, // 帧缓冲区宽度(pixel或columns) 55abe3a6eaShanjiezhou height: u32, // 帧缓冲区高度(pixel或lines) 56abe3a6eaShanjiezhou size: u32, // 帧缓冲区大小(bytes) 57abe3a6eaShanjiezhou bit_depth: u32, // 像素点位深度 58abe3a6eaShanjiezhou pub buf: ScmBuffer, 59abe3a6eaShanjiezhou flags: ScmBufferFlag, // 帧缓冲区标志位 60abe3a6eaShanjiezhou } 61abe3a6eaShanjiezhou 621496ba7bSLoGin #[allow(dead_code)] 63abe3a6eaShanjiezhou impl ScmBufferInfo { 64abe3a6eaShanjiezhou /// 创建新的帧缓冲区信息 65abe3a6eaShanjiezhou /// 66abe3a6eaShanjiezhou /// ## 参数 67abe3a6eaShanjiezhou /// 68abe3a6eaShanjiezhou /// - `buf_type` 帧缓冲区类型 69abe3a6eaShanjiezhou /// 70abe3a6eaShanjiezhou /// ## 返回值 71abe3a6eaShanjiezhou /// 72abe3a6eaShanjiezhou /// - `Result<Self, SystemError>` 创建成功返回新的帧缓冲区结构体,创建失败返回错误码 731496ba7bSLoGin pub fn new(mut buf_type: ScmBufferFlag) -> Result<Self, SystemError> { 74abe3a6eaShanjiezhou if unlikely(SCM_DOUBLE_BUFFER_ENABLED.load(Ordering::SeqCst) == false) { 751496ba7bSLoGin let mut device_buffer = video_refresh_manager().device_buffer().clone(); 761496ba7bSLoGin buf_type.remove(ScmBufferFlag::SCM_BF_DB); 771496ba7bSLoGin buf_type.insert(ScmBufferFlag::SCM_BF_FB); 781496ba7bSLoGin device_buffer.flags = buf_type; 791496ba7bSLoGin return Ok(device_buffer); 80abe3a6eaShanjiezhou } else { 811496ba7bSLoGin let device_buffer_guard = video_refresh_manager().device_buffer(); 82abe3a6eaShanjiezhou 831496ba7bSLoGin let buf_space: Arc<SpinLock<Box<[u32]>>> = Arc::new(SpinLock::new( 841496ba7bSLoGin vec![0u32; (device_buffer_guard.size / 4) as usize].into_boxed_slice(), 85abe3a6eaShanjiezhou )); 86abe3a6eaShanjiezhou 871496ba7bSLoGin assert!(buf_type.contains(ScmBufferFlag::SCM_BF_DB)); 88abe3a6eaShanjiezhou 891496ba7bSLoGin assert_eq!( 901496ba7bSLoGin device_buffer_guard.size as usize, 911496ba7bSLoGin buf_space.lock().len() * core::mem::size_of::<u32>() 921496ba7bSLoGin ); 93abe3a6eaShanjiezhou 941496ba7bSLoGin // 创建双缓冲区 951496ba7bSLoGin let buffer = Self { 961496ba7bSLoGin width: device_buffer_guard.width, 971496ba7bSLoGin height: device_buffer_guard.height, 981496ba7bSLoGin size: device_buffer_guard.size, 991496ba7bSLoGin bit_depth: device_buffer_guard.bit_depth, 1001496ba7bSLoGin flags: buf_type, 1011496ba7bSLoGin buf: ScmBuffer::DoubleBuffer(buf_space), 102abe3a6eaShanjiezhou }; 1031496ba7bSLoGin drop(device_buffer_guard); 1041496ba7bSLoGin 1051496ba7bSLoGin return Ok(buffer); 106abe3a6eaShanjiezhou } 107abe3a6eaShanjiezhou } 1081496ba7bSLoGin 1091496ba7bSLoGin pub unsafe fn new_device_buffer( 1101496ba7bSLoGin width: u32, 1111496ba7bSLoGin height: u32, 1121496ba7bSLoGin size: u32, 1131496ba7bSLoGin bit_depth: u32, 1141496ba7bSLoGin buf_type: ScmBufferFlag, 1151496ba7bSLoGin vaddr: VirtAddr, 1161496ba7bSLoGin ) -> Result<Self, SystemError> { 1171496ba7bSLoGin let buffer = Self { 1181496ba7bSLoGin width, 1191496ba7bSLoGin height, 1201496ba7bSLoGin size, 1211496ba7bSLoGin bit_depth, 1221496ba7bSLoGin flags: buf_type, 1231496ba7bSLoGin buf: ScmBuffer::DeviceBuffer(vaddr), 1241496ba7bSLoGin }; 1251496ba7bSLoGin return Ok(buffer); 126abe3a6eaShanjiezhou } 1271496ba7bSLoGin 1281496ba7bSLoGin pub fn buf_size(&self) -> usize { 1291496ba7bSLoGin self.size as usize 1301496ba7bSLoGin } 1311496ba7bSLoGin 1321496ba7bSLoGin pub fn bit_depth(&self) -> u32 { 1331496ba7bSLoGin self.bit_depth 1341496ba7bSLoGin } 1351496ba7bSLoGin 1361496ba7bSLoGin pub fn height(&self) -> u32 { 137abe3a6eaShanjiezhou self.height 138abe3a6eaShanjiezhou } 1391496ba7bSLoGin 1401496ba7bSLoGin pub fn width(&self) -> u32 { 141abe3a6eaShanjiezhou self.width 142abe3a6eaShanjiezhou } 1431496ba7bSLoGin 144abe3a6eaShanjiezhou pub fn is_double_buffer(&self) -> bool { 145abe3a6eaShanjiezhou match &self.buf { 146abe3a6eaShanjiezhou ScmBuffer::DoubleBuffer(_) => true, 147abe3a6eaShanjiezhou _ => false, 148abe3a6eaShanjiezhou } 149abe3a6eaShanjiezhou } 150abe3a6eaShanjiezhou pub fn is_device_buffer(&self) -> bool { 151abe3a6eaShanjiezhou match &self.buf { 152abe3a6eaShanjiezhou ScmBuffer::DeviceBuffer(_) => true, 153abe3a6eaShanjiezhou _ => false, 154abe3a6eaShanjiezhou } 155abe3a6eaShanjiezhou } 1561496ba7bSLoGin 1571496ba7bSLoGin pub fn copy_from_nonoverlapping(&mut self, src: &ScmBufferInfo) { 1581496ba7bSLoGin assert!(self.buf_size() == src.buf_size()); 1591496ba7bSLoGin match &self.buf { 1601496ba7bSLoGin ScmBuffer::DeviceBuffer(vaddr) => { 1611496ba7bSLoGin let len = self.buf_size() / core::mem::size_of::<u32>(); 1621496ba7bSLoGin let self_buf_guard = 1631496ba7bSLoGin unsafe { core::slice::from_raw_parts_mut(vaddr.data() as *mut u32, len) }; 1641496ba7bSLoGin match &src.buf { 1651496ba7bSLoGin ScmBuffer::DeviceBuffer(vaddr) => { 1661496ba7bSLoGin let src_buf_guard = 1671496ba7bSLoGin unsafe { core::slice::from_raw_parts(vaddr.data() as *const u32, len) }; 1681496ba7bSLoGin self_buf_guard.copy_from_slice(src_buf_guard); 1691496ba7bSLoGin } 1701496ba7bSLoGin ScmBuffer::DoubleBuffer(double_buffer) => { 1711496ba7bSLoGin let src_buf_guard = double_buffer.lock(); 1721496ba7bSLoGin self_buf_guard.copy_from_slice(src_buf_guard.as_ref()); 1731496ba7bSLoGin } 1741496ba7bSLoGin }; 175abe3a6eaShanjiezhou } 176abe3a6eaShanjiezhou 1771496ba7bSLoGin ScmBuffer::DoubleBuffer(double_buffer) => { 1781496ba7bSLoGin let mut double_buffer_guard = double_buffer.lock(); 1791496ba7bSLoGin match &src.buf { 1801496ba7bSLoGin ScmBuffer::DeviceBuffer(vaddr) => { 1811496ba7bSLoGin let len = src.buf_size() / core::mem::size_of::<u32>(); 1821496ba7bSLoGin double_buffer_guard.as_mut().copy_from_slice(unsafe { 1831496ba7bSLoGin core::slice::from_raw_parts(vaddr.data() as *const u32, len) 1841496ba7bSLoGin }); 1851496ba7bSLoGin } 1861496ba7bSLoGin ScmBuffer::DoubleBuffer(double_buffer) => { 1871496ba7bSLoGin let x = double_buffer.lock(); 1881496ba7bSLoGin double_buffer_guard.as_mut().copy_from_slice(x.as_ref()); 1891496ba7bSLoGin } 1901496ba7bSLoGin }; 191abe3a6eaShanjiezhou } 192abe3a6eaShanjiezhou } 193abe3a6eaShanjiezhou } 194abe3a6eaShanjiezhou } 1951496ba7bSLoGin 196abe3a6eaShanjiezhou #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)] 197abe3a6eaShanjiezhou pub struct ScmUiFrameworkId(u32); 198abe3a6eaShanjiezhou 199abe3a6eaShanjiezhou impl ScmUiFrameworkId { 200abe3a6eaShanjiezhou /// 分配一个新的框架id 201abe3a6eaShanjiezhou pub fn new() -> Self { 202abe3a6eaShanjiezhou static MAX_ID: AtomicU32 = AtomicU32::new(0); 203abe3a6eaShanjiezhou return ScmUiFrameworkId(MAX_ID.fetch_add(1, Ordering::SeqCst)); 204abe3a6eaShanjiezhou } 205abe3a6eaShanjiezhou } 206abe3a6eaShanjiezhou #[allow(dead_code)] 207abe3a6eaShanjiezhou #[derive(Debug, Clone)] 208abe3a6eaShanjiezhou pub struct ScmUiFrameworkMetadata { 209abe3a6eaShanjiezhou id: ScmUiFrameworkId, 210abe3a6eaShanjiezhou name: String, 211abe3a6eaShanjiezhou framework_type: ScmFramworkType, 212abe3a6eaShanjiezhou pub buf_info: ScmBufferInfo, 213abe3a6eaShanjiezhou } 214abe3a6eaShanjiezhou 215abe3a6eaShanjiezhou impl ScmUiFrameworkMetadata { 216abe3a6eaShanjiezhou pub fn new(name: String, framework_type: ScmFramworkType) -> Self { 217abe3a6eaShanjiezhou match framework_type { 218abe3a6eaShanjiezhou ScmFramworkType::Text => { 219abe3a6eaShanjiezhou let result = ScmUiFrameworkMetadata { 220abe3a6eaShanjiezhou id: ScmUiFrameworkId::new(), 221abe3a6eaShanjiezhou name, 222abe3a6eaShanjiezhou framework_type: ScmFramworkType::Text, 2231496ba7bSLoGin buf_info: ScmBufferInfo::new( 2241496ba7bSLoGin ScmBufferFlag::SCM_BF_TEXT | ScmBufferFlag::SCM_BF_DB, 2251496ba7bSLoGin ) 2261496ba7bSLoGin .unwrap(), 227abe3a6eaShanjiezhou }; 228abe3a6eaShanjiezhou 229abe3a6eaShanjiezhou return result; 230abe3a6eaShanjiezhou } 231abe3a6eaShanjiezhou ScmFramworkType::Gui => todo!(), 232abe3a6eaShanjiezhou ScmFramworkType::Unused => todo!(), 233abe3a6eaShanjiezhou } 234abe3a6eaShanjiezhou } 235abe3a6eaShanjiezhou pub fn buf_info(&self) -> ScmBufferInfo { 236abe3a6eaShanjiezhou return self.buf_info.clone(); 237abe3a6eaShanjiezhou } 238abe3a6eaShanjiezhou pub fn set_buf_info(&mut self, buf_info: ScmBufferInfo) { 239abe3a6eaShanjiezhou self.buf_info = buf_info; 240abe3a6eaShanjiezhou } 241abe3a6eaShanjiezhou } 242abe3a6eaShanjiezhou pub trait ScmUiFramework: Sync + Send + Debug { 243abe3a6eaShanjiezhou // 安装ui框架的回调函数 244abe3a6eaShanjiezhou fn install(&self) -> Result<i32, SystemError> { 245abe3a6eaShanjiezhou return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 246abe3a6eaShanjiezhou } 247abe3a6eaShanjiezhou // 卸载ui框架的回调函数 248abe3a6eaShanjiezhou fn uninstall(&self) -> Result<i32, SystemError> { 249abe3a6eaShanjiezhou return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 250abe3a6eaShanjiezhou } 251abe3a6eaShanjiezhou // 启用ui框架的回调函数 252abe3a6eaShanjiezhou fn enable(&self) -> Result<i32, SystemError> { 253abe3a6eaShanjiezhou return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 254abe3a6eaShanjiezhou } 255abe3a6eaShanjiezhou // 禁用ui框架的回调函数 256abe3a6eaShanjiezhou fn disable(&self) -> Result<i32, SystemError> { 257abe3a6eaShanjiezhou return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 258abe3a6eaShanjiezhou } 259abe3a6eaShanjiezhou // 改变ui框架的帧缓冲区的回调函数 260abe3a6eaShanjiezhou fn change(&self, _buf: ScmBufferInfo) -> Result<i32, SystemError> { 261abe3a6eaShanjiezhou return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 262abe3a6eaShanjiezhou } 263abe3a6eaShanjiezhou /// @brief 获取ScmUiFramework的元数据 264abe3a6eaShanjiezhou /// @return 成功:Ok(ScmUiFramework的元数据) 265abe3a6eaShanjiezhou /// 失败:Err(错误码) 266abe3a6eaShanjiezhou fn metadata(&self) -> Result<ScmUiFrameworkMetadata, SystemError> { 267abe3a6eaShanjiezhou // 若文件系统没有实现此方法,则返回“不支持” 268abe3a6eaShanjiezhou return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 269abe3a6eaShanjiezhou } 270abe3a6eaShanjiezhou } 271abe3a6eaShanjiezhou 272abe3a6eaShanjiezhou /// 初始化屏幕控制模块 273abe3a6eaShanjiezhou /// 274abe3a6eaShanjiezhou /// ## 调用时机 275abe3a6eaShanjiezhou /// 276abe3a6eaShanjiezhou /// 该函数在内核启动的早期进行调用。调用时,内存管理模块尚未初始化。 277*a03c4f9dSLoGin pub fn scm_init() { 278abe3a6eaShanjiezhou SCM_DOUBLE_BUFFER_ENABLED.store(false, Ordering::SeqCst); // 禁用双缓冲 279abe3a6eaShanjiezhou 280abe3a6eaShanjiezhou textui_init_no_alloc(); 281abe3a6eaShanjiezhou 282*a03c4f9dSLoGin send_to_default_serial8250_port("\nfinish_scm_init\n\0".as_bytes()); 283abe3a6eaShanjiezhou } 284abe3a6eaShanjiezhou 285abe3a6eaShanjiezhou /// 启用某个ui框架,将它的帧缓冲区渲染到屏幕上 286abe3a6eaShanjiezhou /// ## 参数 287abe3a6eaShanjiezhou /// 288abe3a6eaShanjiezhou /// - framework 要启动的ui框架 289abe3a6eaShanjiezhou 290abe3a6eaShanjiezhou pub fn scm_framework_enable(framework: Arc<dyn ScmUiFramework>) -> Result<i32, SystemError> { 291abe3a6eaShanjiezhou // 获取信息 292abe3a6eaShanjiezhou let metadata = framework.metadata()?; 293abe3a6eaShanjiezhou 294abe3a6eaShanjiezhou // if metadata.buf_info.buf.is_null() { 295abe3a6eaShanjiezhou // return Err(SystemError::EINVAL); 296abe3a6eaShanjiezhou // } 297abe3a6eaShanjiezhou let mut current_framework = CURRENT_FRAMEWORK.write(); 298abe3a6eaShanjiezhou 299abe3a6eaShanjiezhou if SCM_DOUBLE_BUFFER_ENABLED.load(Ordering::SeqCst) == true { 3001496ba7bSLoGin video_refresh_manager().set_refresh_target(&metadata.buf_info)?; 301abe3a6eaShanjiezhou } 302abe3a6eaShanjiezhou 3031496ba7bSLoGin framework.enable()?; 304abe3a6eaShanjiezhou current_framework.replace(framework); 305abe3a6eaShanjiezhou 306abe3a6eaShanjiezhou return Ok(0); 307abe3a6eaShanjiezhou } 308abe3a6eaShanjiezhou /// 向屏幕管理器注册UI框架 309abe3a6eaShanjiezhou /// 310abe3a6eaShanjiezhou /// ## 参数 311abe3a6eaShanjiezhou /// - framework 框架结构体 312abe3a6eaShanjiezhou 313abe3a6eaShanjiezhou pub fn scm_register(framework: Arc<dyn ScmUiFramework>) -> Result<i32, SystemError> { 314abe3a6eaShanjiezhou // 把ui框架加入链表 315abe3a6eaShanjiezhou 316abe3a6eaShanjiezhou SCM_FRAMEWORK_LIST.lock().push_back(framework.clone()); 317abe3a6eaShanjiezhou // 调用ui框架的回调函数以安装ui框架,并将其激活 318abe3a6eaShanjiezhou framework.install()?; 319abe3a6eaShanjiezhou 320abe3a6eaShanjiezhou // 如果当前还没有框架获得了屏幕的控制权,就让其拿去 321abe3a6eaShanjiezhou if CURRENT_FRAMEWORK.read().is_none() { 322abe3a6eaShanjiezhou return scm_framework_enable(framework); 323abe3a6eaShanjiezhou } 324abe3a6eaShanjiezhou return Ok(0); 325abe3a6eaShanjiezhou } 326abe3a6eaShanjiezhou 3271496ba7bSLoGin /// 屏幕管理器启用双缓冲区 3281496ba7bSLoGin #[allow(dead_code)] 3291496ba7bSLoGin pub fn scm_enable_double_buffer() -> Result<i32, SystemError> { 330abe3a6eaShanjiezhou if SCM_DOUBLE_BUFFER_ENABLED.load(Ordering::SeqCst) { 331abe3a6eaShanjiezhou // 已经开启了双缓冲区了, 直接退出 332abe3a6eaShanjiezhou return Ok(0); 333abe3a6eaShanjiezhou } 334abe3a6eaShanjiezhou let scm_list = SCM_FRAMEWORK_LIST.lock(); 335abe3a6eaShanjiezhou if scm_list.is_empty() { 336abe3a6eaShanjiezhou // scm 框架链表为空 337abe3a6eaShanjiezhou return Ok(0); 338abe3a6eaShanjiezhou } 339abe3a6eaShanjiezhou drop(scm_list); 340abe3a6eaShanjiezhou SCM_DOUBLE_BUFFER_ENABLED.store(true, Ordering::SeqCst); 341abe3a6eaShanjiezhou // 创建双缓冲区 3421496ba7bSLoGin let buf_info = ScmBufferInfo::new(ScmBufferFlag::SCM_BF_DB | ScmBufferFlag::SCM_BF_PIXEL)?; 3431496ba7bSLoGin 3441496ba7bSLoGin // 设置定时刷新的对象 3451496ba7bSLoGin video_refresh_manager() 3461496ba7bSLoGin .set_refresh_target(&buf_info) 3471496ba7bSLoGin .expect("set refresh target failed"); 3481496ba7bSLoGin 3491496ba7bSLoGin // 设置当前框架的帧缓冲区 350abe3a6eaShanjiezhou CURRENT_FRAMEWORK 351abe3a6eaShanjiezhou .write() 352abe3a6eaShanjiezhou .as_ref() 353abe3a6eaShanjiezhou .unwrap() 354abe3a6eaShanjiezhou .change(buf_info)?; 355abe3a6eaShanjiezhou // 遍历当前所有使用帧缓冲区的框架,更新为双缓冲区 356abe3a6eaShanjiezhou for framework in SCM_FRAMEWORK_LIST.lock().iter_mut() { 357abe3a6eaShanjiezhou if !(*framework).metadata()?.buf_info.is_double_buffer() { 358abe3a6eaShanjiezhou let new_buf_info = 359abe3a6eaShanjiezhou ScmBufferInfo::new(ScmBufferFlag::SCM_BF_DB | ScmBufferFlag::SCM_BF_PIXEL)?; 360abe3a6eaShanjiezhou (*framework).change(new_buf_info)?; 361abe3a6eaShanjiezhou } 362abe3a6eaShanjiezhou } 363abe3a6eaShanjiezhou // 通知显示驱动,启动双缓冲 3641496ba7bSLoGin video_refresh_manager().video_reinitialize(true)?; 365abe3a6eaShanjiezhou 366abe3a6eaShanjiezhou return Ok(0); 367abe3a6eaShanjiezhou } 3681496ba7bSLoGin 369abe3a6eaShanjiezhou /// 允许往窗口打印信息 370abe3a6eaShanjiezhou pub fn scm_enable_put_to_window() { 3711496ba7bSLoGin // mm之前要继续往窗口打印信息时,因为没有动态内存分配(textui并没有往scm注册),且使用的是textui,要直接修改textui里面的值 372abe3a6eaShanjiezhou if CURRENT_FRAMEWORK.read().is_none() { 373abe3a6eaShanjiezhou super::textui::ENABLE_PUT_TO_WINDOW.store(true, Ordering::SeqCst); 374abe3a6eaShanjiezhou } else { 375abe3a6eaShanjiezhou let r = CURRENT_FRAMEWORK 376abe3a6eaShanjiezhou .write() 377abe3a6eaShanjiezhou .as_ref() 378abe3a6eaShanjiezhou .unwrap() 379abe3a6eaShanjiezhou .enable() 380abe3a6eaShanjiezhou .unwrap_or_else(|e| e.to_posix_errno()); 381abe3a6eaShanjiezhou if r.is_negative() { 382*a03c4f9dSLoGin send_to_default_serial8250_port("scm_enable_put_to_window() failed.\n\0".as_bytes()); 383abe3a6eaShanjiezhou } 384abe3a6eaShanjiezhou } 385abe3a6eaShanjiezhou } 386abe3a6eaShanjiezhou /// 禁止往窗口打印信息 387abe3a6eaShanjiezhou pub fn scm_disable_put_to_window() { 388abe3a6eaShanjiezhou // mm之前要停止往窗口打印信息时,因为没有动态内存分配(rwlock与otion依然能用,但是textui并没有往scm注册),且使用的是textui,要直接修改textui里面的值 389abe3a6eaShanjiezhou if CURRENT_FRAMEWORK.read().is_none() { 390abe3a6eaShanjiezhou super::textui::ENABLE_PUT_TO_WINDOW.store(false, Ordering::SeqCst); 391abe3a6eaShanjiezhou assert!(super::textui::ENABLE_PUT_TO_WINDOW.load(Ordering::SeqCst) == false); 392abe3a6eaShanjiezhou } else { 393abe3a6eaShanjiezhou let r = CURRENT_FRAMEWORK 394abe3a6eaShanjiezhou .write() 395abe3a6eaShanjiezhou .as_ref() 396abe3a6eaShanjiezhou .unwrap() 397abe3a6eaShanjiezhou .disable() 398abe3a6eaShanjiezhou .unwrap_or_else(|e| e.to_posix_errno()); 399abe3a6eaShanjiezhou if r.is_negative() { 400*a03c4f9dSLoGin send_to_default_serial8250_port("scm_disable_put_to_window() failed.\n\0".as_bytes()); 401abe3a6eaShanjiezhou } 402abe3a6eaShanjiezhou } 403abe3a6eaShanjiezhou } 404abe3a6eaShanjiezhou /// 当内存管理单元被初始化之后,重新处理帧缓冲区问题 405abe3a6eaShanjiezhou #[no_mangle] 406abe3a6eaShanjiezhou pub extern "C" fn scm_reinit() -> i32 { 407abe3a6eaShanjiezhou let r = true_scm_reinit().unwrap_or_else(|e| e.to_posix_errno()); 408abe3a6eaShanjiezhou if r.is_negative() { 409*a03c4f9dSLoGin send_to_default_serial8250_port("scm reinit failed.\n\0".as_bytes()); 410abe3a6eaShanjiezhou } 411abe3a6eaShanjiezhou return r; 412abe3a6eaShanjiezhou } 413abe3a6eaShanjiezhou fn true_scm_reinit() -> Result<i32, SystemError> { 4141496ba7bSLoGin video_refresh_manager() 4151496ba7bSLoGin .video_reinitialize(false) 4161496ba7bSLoGin .expect("video reinitialize failed"); 417abe3a6eaShanjiezhou 418abe3a6eaShanjiezhou // 遍历当前所有使用帧缓冲区的框架,更新地址 4191496ba7bSLoGin let device_buffer = video_refresh_manager().device_buffer().clone(); 420abe3a6eaShanjiezhou for framework in SCM_FRAMEWORK_LIST.lock().iter_mut() { 421abe3a6eaShanjiezhou if framework.metadata()?.buf_info().is_device_buffer() { 4221496ba7bSLoGin framework.change(device_buffer.clone())?; 423abe3a6eaShanjiezhou } 424abe3a6eaShanjiezhou } 425abe3a6eaShanjiezhou 426abe3a6eaShanjiezhou scm_enable_put_to_window(); 427abe3a6eaShanjiezhou 428abe3a6eaShanjiezhou return Ok(0); 429abe3a6eaShanjiezhou } 430