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::{ 10*1496ba7bSLoGin driver::{ 11*1496ba7bSLoGin uart::uart_device::{c_uart_send_str, UartPort}, 12*1496ba7bSLoGin video::video_refresh_manager, 13abe3a6eaShanjiezhou }, 14abe3a6eaShanjiezhou libs::{rwlock::RwLock, spinlock::SpinLock}, 15abe3a6eaShanjiezhou mm::VirtAddr, 16abe3a6eaShanjiezhou syscall::SystemError, 17abe3a6eaShanjiezhou }; 18abe3a6eaShanjiezhou 19abe3a6eaShanjiezhou use super::textui_no_alloc::textui_init_no_alloc; 20abe3a6eaShanjiezhou 21abe3a6eaShanjiezhou /// 全局的UI框架列表 22*1496ba7bSLoGin pub static SCM_FRAMEWORK_LIST: SpinLock<LinkedList<Arc<dyn ScmUiFramework>>> = 23abe3a6eaShanjiezhou SpinLock::new(LinkedList::new()); 24abe3a6eaShanjiezhou 25*1496ba7bSLoGin /// 当前在使用的UI框架 26*1496ba7bSLoGin pub static CURRENT_FRAMEWORK: RwLock<Option<Arc<dyn ScmUiFramework>>> = RwLock::new(None); 27abe3a6eaShanjiezhou 28abe3a6eaShanjiezhou /// 是否启用双缓冲 29abe3a6eaShanjiezhou pub static SCM_DOUBLE_BUFFER_ENABLED: AtomicBool = AtomicBool::new(false); 30abe3a6eaShanjiezhou 31abe3a6eaShanjiezhou bitflags! { 32abe3a6eaShanjiezhou pub struct ScmBufferFlag:u8 { 33abe3a6eaShanjiezhou // 帧缓冲区标志位 34abe3a6eaShanjiezhou const SCM_BF_FB = 1 << 0; // 当前buffer是设备显存中的帧缓冲区 35abe3a6eaShanjiezhou const SCM_BF_DB = 1 << 1; // 当前buffer是双缓冲 36abe3a6eaShanjiezhou const SCM_BF_TEXT = 1 << 2; // 使用文本模式 37abe3a6eaShanjiezhou const SCM_BF_PIXEL = 1 << 3; // 使用图像模式 38abe3a6eaShanjiezhou } 39abe3a6eaShanjiezhou } 40abe3a6eaShanjiezhou #[derive(Clone, Debug)] 41abe3a6eaShanjiezhou #[allow(dead_code)] 42abe3a6eaShanjiezhou pub enum ScmFramworkType { 43abe3a6eaShanjiezhou Text, 44abe3a6eaShanjiezhou Gui, 45abe3a6eaShanjiezhou Unused, 46abe3a6eaShanjiezhou } 47*1496ba7bSLoGin #[derive(Debug, Clone)] 48abe3a6eaShanjiezhou pub enum ScmBuffer { 49*1496ba7bSLoGin DeviceBuffer(VirtAddr), 50*1496ba7bSLoGin DoubleBuffer(Arc<SpinLock<Box<[u32]>>>), 51abe3a6eaShanjiezhou } 52*1496ba7bSLoGin 53*1496ba7bSLoGin #[derive(Debug, Clone)] 54abe3a6eaShanjiezhou pub struct ScmBufferInfo { 55abe3a6eaShanjiezhou width: u32, // 帧缓冲区宽度(pixel或columns) 56abe3a6eaShanjiezhou height: u32, // 帧缓冲区高度(pixel或lines) 57abe3a6eaShanjiezhou size: u32, // 帧缓冲区大小(bytes) 58abe3a6eaShanjiezhou bit_depth: u32, // 像素点位深度 59abe3a6eaShanjiezhou pub buf: ScmBuffer, 60abe3a6eaShanjiezhou flags: ScmBufferFlag, // 帧缓冲区标志位 61abe3a6eaShanjiezhou } 62abe3a6eaShanjiezhou 63*1496ba7bSLoGin #[allow(dead_code)] 64abe3a6eaShanjiezhou impl ScmBufferInfo { 65abe3a6eaShanjiezhou /// 创建新的帧缓冲区信息 66abe3a6eaShanjiezhou /// 67abe3a6eaShanjiezhou /// ## 参数 68abe3a6eaShanjiezhou /// 69abe3a6eaShanjiezhou /// - `buf_type` 帧缓冲区类型 70abe3a6eaShanjiezhou /// 71abe3a6eaShanjiezhou /// ## 返回值 72abe3a6eaShanjiezhou /// 73abe3a6eaShanjiezhou /// - `Result<Self, SystemError>` 创建成功返回新的帧缓冲区结构体,创建失败返回错误码 74*1496ba7bSLoGin pub fn new(mut buf_type: ScmBufferFlag) -> Result<Self, SystemError> { 75abe3a6eaShanjiezhou if unlikely(SCM_DOUBLE_BUFFER_ENABLED.load(Ordering::SeqCst) == false) { 76*1496ba7bSLoGin let mut device_buffer = video_refresh_manager().device_buffer().clone(); 77*1496ba7bSLoGin buf_type.remove(ScmBufferFlag::SCM_BF_DB); 78*1496ba7bSLoGin buf_type.insert(ScmBufferFlag::SCM_BF_FB); 79*1496ba7bSLoGin device_buffer.flags = buf_type; 80*1496ba7bSLoGin return Ok(device_buffer); 81abe3a6eaShanjiezhou } else { 82*1496ba7bSLoGin let device_buffer_guard = video_refresh_manager().device_buffer(); 83abe3a6eaShanjiezhou 84*1496ba7bSLoGin let buf_space: Arc<SpinLock<Box<[u32]>>> = Arc::new(SpinLock::new( 85*1496ba7bSLoGin vec![0u32; (device_buffer_guard.size / 4) as usize].into_boxed_slice(), 86abe3a6eaShanjiezhou )); 87abe3a6eaShanjiezhou 88*1496ba7bSLoGin assert!(buf_type.contains(ScmBufferFlag::SCM_BF_DB)); 89abe3a6eaShanjiezhou 90*1496ba7bSLoGin assert_eq!( 91*1496ba7bSLoGin device_buffer_guard.size as usize, 92*1496ba7bSLoGin buf_space.lock().len() * core::mem::size_of::<u32>() 93*1496ba7bSLoGin ); 94abe3a6eaShanjiezhou 95*1496ba7bSLoGin // 创建双缓冲区 96*1496ba7bSLoGin let buffer = Self { 97*1496ba7bSLoGin width: device_buffer_guard.width, 98*1496ba7bSLoGin height: device_buffer_guard.height, 99*1496ba7bSLoGin size: device_buffer_guard.size, 100*1496ba7bSLoGin bit_depth: device_buffer_guard.bit_depth, 101*1496ba7bSLoGin flags: buf_type, 102*1496ba7bSLoGin buf: ScmBuffer::DoubleBuffer(buf_space), 103abe3a6eaShanjiezhou }; 104*1496ba7bSLoGin drop(device_buffer_guard); 105*1496ba7bSLoGin 106*1496ba7bSLoGin return Ok(buffer); 107abe3a6eaShanjiezhou } 108abe3a6eaShanjiezhou } 109*1496ba7bSLoGin 110*1496ba7bSLoGin pub unsafe fn new_device_buffer( 111*1496ba7bSLoGin width: u32, 112*1496ba7bSLoGin height: u32, 113*1496ba7bSLoGin size: u32, 114*1496ba7bSLoGin bit_depth: u32, 115*1496ba7bSLoGin buf_type: ScmBufferFlag, 116*1496ba7bSLoGin vaddr: VirtAddr, 117*1496ba7bSLoGin ) -> Result<Self, SystemError> { 118*1496ba7bSLoGin let buffer = Self { 119*1496ba7bSLoGin width, 120*1496ba7bSLoGin height, 121*1496ba7bSLoGin size, 122*1496ba7bSLoGin bit_depth, 123*1496ba7bSLoGin flags: buf_type, 124*1496ba7bSLoGin buf: ScmBuffer::DeviceBuffer(vaddr), 125*1496ba7bSLoGin }; 126*1496ba7bSLoGin return Ok(buffer); 127abe3a6eaShanjiezhou } 128*1496ba7bSLoGin 129*1496ba7bSLoGin pub fn buf_size(&self) -> usize { 130*1496ba7bSLoGin self.size as usize 131*1496ba7bSLoGin } 132*1496ba7bSLoGin 133*1496ba7bSLoGin pub fn bit_depth(&self) -> u32 { 134*1496ba7bSLoGin self.bit_depth 135*1496ba7bSLoGin } 136*1496ba7bSLoGin 137*1496ba7bSLoGin pub fn height(&self) -> u32 { 138abe3a6eaShanjiezhou self.height 139abe3a6eaShanjiezhou } 140*1496ba7bSLoGin 141*1496ba7bSLoGin pub fn width(&self) -> u32 { 142abe3a6eaShanjiezhou self.width 143abe3a6eaShanjiezhou } 144*1496ba7bSLoGin 145abe3a6eaShanjiezhou pub fn is_double_buffer(&self) -> bool { 146abe3a6eaShanjiezhou match &self.buf { 147abe3a6eaShanjiezhou ScmBuffer::DoubleBuffer(_) => true, 148abe3a6eaShanjiezhou _ => false, 149abe3a6eaShanjiezhou } 150abe3a6eaShanjiezhou } 151abe3a6eaShanjiezhou pub fn is_device_buffer(&self) -> bool { 152abe3a6eaShanjiezhou match &self.buf { 153abe3a6eaShanjiezhou ScmBuffer::DeviceBuffer(_) => true, 154abe3a6eaShanjiezhou _ => false, 155abe3a6eaShanjiezhou } 156abe3a6eaShanjiezhou } 157*1496ba7bSLoGin 158*1496ba7bSLoGin pub fn copy_from_nonoverlapping(&mut self, src: &ScmBufferInfo) { 159*1496ba7bSLoGin assert!(self.buf_size() == src.buf_size()); 160*1496ba7bSLoGin match &self.buf { 161*1496ba7bSLoGin ScmBuffer::DeviceBuffer(vaddr) => { 162*1496ba7bSLoGin let len = self.buf_size() / core::mem::size_of::<u32>(); 163*1496ba7bSLoGin let self_buf_guard = 164*1496ba7bSLoGin unsafe { core::slice::from_raw_parts_mut(vaddr.data() as *mut u32, len) }; 165*1496ba7bSLoGin match &src.buf { 166*1496ba7bSLoGin ScmBuffer::DeviceBuffer(vaddr) => { 167*1496ba7bSLoGin let src_buf_guard = 168*1496ba7bSLoGin unsafe { core::slice::from_raw_parts(vaddr.data() as *const u32, len) }; 169*1496ba7bSLoGin self_buf_guard.copy_from_slice(src_buf_guard); 170*1496ba7bSLoGin } 171*1496ba7bSLoGin ScmBuffer::DoubleBuffer(double_buffer) => { 172*1496ba7bSLoGin let src_buf_guard = double_buffer.lock(); 173*1496ba7bSLoGin self_buf_guard.copy_from_slice(src_buf_guard.as_ref()); 174*1496ba7bSLoGin } 175*1496ba7bSLoGin }; 176abe3a6eaShanjiezhou } 177abe3a6eaShanjiezhou 178*1496ba7bSLoGin ScmBuffer::DoubleBuffer(double_buffer) => { 179*1496ba7bSLoGin let mut double_buffer_guard = double_buffer.lock(); 180*1496ba7bSLoGin match &src.buf { 181*1496ba7bSLoGin ScmBuffer::DeviceBuffer(vaddr) => { 182*1496ba7bSLoGin let len = src.buf_size() / core::mem::size_of::<u32>(); 183*1496ba7bSLoGin double_buffer_guard.as_mut().copy_from_slice(unsafe { 184*1496ba7bSLoGin core::slice::from_raw_parts(vaddr.data() as *const u32, len) 185*1496ba7bSLoGin }); 186*1496ba7bSLoGin } 187*1496ba7bSLoGin ScmBuffer::DoubleBuffer(double_buffer) => { 188*1496ba7bSLoGin let x = double_buffer.lock(); 189*1496ba7bSLoGin double_buffer_guard.as_mut().copy_from_slice(x.as_ref()); 190*1496ba7bSLoGin } 191*1496ba7bSLoGin }; 192abe3a6eaShanjiezhou } 193abe3a6eaShanjiezhou } 194abe3a6eaShanjiezhou } 195abe3a6eaShanjiezhou } 196*1496ba7bSLoGin 197abe3a6eaShanjiezhou #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)] 198abe3a6eaShanjiezhou pub struct ScmUiFrameworkId(u32); 199abe3a6eaShanjiezhou 200abe3a6eaShanjiezhou impl ScmUiFrameworkId { 201abe3a6eaShanjiezhou /// 分配一个新的框架id 202abe3a6eaShanjiezhou pub fn new() -> Self { 203abe3a6eaShanjiezhou static MAX_ID: AtomicU32 = AtomicU32::new(0); 204abe3a6eaShanjiezhou return ScmUiFrameworkId(MAX_ID.fetch_add(1, Ordering::SeqCst)); 205abe3a6eaShanjiezhou } 206abe3a6eaShanjiezhou } 207abe3a6eaShanjiezhou #[allow(dead_code)] 208abe3a6eaShanjiezhou #[derive(Debug, Clone)] 209abe3a6eaShanjiezhou pub struct ScmUiFrameworkMetadata { 210abe3a6eaShanjiezhou id: ScmUiFrameworkId, 211abe3a6eaShanjiezhou name: String, 212abe3a6eaShanjiezhou framework_type: ScmFramworkType, 213abe3a6eaShanjiezhou pub buf_info: ScmBufferInfo, 214abe3a6eaShanjiezhou } 215abe3a6eaShanjiezhou 216abe3a6eaShanjiezhou impl ScmUiFrameworkMetadata { 217abe3a6eaShanjiezhou pub fn new(name: String, framework_type: ScmFramworkType) -> Self { 218abe3a6eaShanjiezhou match framework_type { 219abe3a6eaShanjiezhou ScmFramworkType::Text => { 220abe3a6eaShanjiezhou let result = ScmUiFrameworkMetadata { 221abe3a6eaShanjiezhou id: ScmUiFrameworkId::new(), 222abe3a6eaShanjiezhou name, 223abe3a6eaShanjiezhou framework_type: ScmFramworkType::Text, 224*1496ba7bSLoGin buf_info: ScmBufferInfo::new( 225*1496ba7bSLoGin ScmBufferFlag::SCM_BF_TEXT | ScmBufferFlag::SCM_BF_DB, 226*1496ba7bSLoGin ) 227*1496ba7bSLoGin .unwrap(), 228abe3a6eaShanjiezhou }; 229abe3a6eaShanjiezhou 230abe3a6eaShanjiezhou return result; 231abe3a6eaShanjiezhou } 232abe3a6eaShanjiezhou ScmFramworkType::Gui => todo!(), 233abe3a6eaShanjiezhou ScmFramworkType::Unused => todo!(), 234abe3a6eaShanjiezhou } 235abe3a6eaShanjiezhou } 236abe3a6eaShanjiezhou pub fn buf_info(&self) -> ScmBufferInfo { 237abe3a6eaShanjiezhou return self.buf_info.clone(); 238abe3a6eaShanjiezhou } 239abe3a6eaShanjiezhou pub fn set_buf_info(&mut self, buf_info: ScmBufferInfo) { 240abe3a6eaShanjiezhou self.buf_info = buf_info; 241abe3a6eaShanjiezhou } 242abe3a6eaShanjiezhou } 243abe3a6eaShanjiezhou pub trait ScmUiFramework: Sync + Send + Debug { 244abe3a6eaShanjiezhou // 安装ui框架的回调函数 245abe3a6eaShanjiezhou fn install(&self) -> Result<i32, SystemError> { 246abe3a6eaShanjiezhou return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 247abe3a6eaShanjiezhou } 248abe3a6eaShanjiezhou // 卸载ui框架的回调函数 249abe3a6eaShanjiezhou fn uninstall(&self) -> Result<i32, SystemError> { 250abe3a6eaShanjiezhou return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 251abe3a6eaShanjiezhou } 252abe3a6eaShanjiezhou // 启用ui框架的回调函数 253abe3a6eaShanjiezhou fn enable(&self) -> Result<i32, SystemError> { 254abe3a6eaShanjiezhou return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 255abe3a6eaShanjiezhou } 256abe3a6eaShanjiezhou // 禁用ui框架的回调函数 257abe3a6eaShanjiezhou fn disable(&self) -> Result<i32, SystemError> { 258abe3a6eaShanjiezhou return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 259abe3a6eaShanjiezhou } 260abe3a6eaShanjiezhou // 改变ui框架的帧缓冲区的回调函数 261abe3a6eaShanjiezhou fn change(&self, _buf: ScmBufferInfo) -> Result<i32, SystemError> { 262abe3a6eaShanjiezhou return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 263abe3a6eaShanjiezhou } 264abe3a6eaShanjiezhou /// @brief 获取ScmUiFramework的元数据 265abe3a6eaShanjiezhou /// @return 成功:Ok(ScmUiFramework的元数据) 266abe3a6eaShanjiezhou /// 失败:Err(错误码) 267abe3a6eaShanjiezhou fn metadata(&self) -> Result<ScmUiFrameworkMetadata, SystemError> { 268abe3a6eaShanjiezhou // 若文件系统没有实现此方法,则返回“不支持” 269abe3a6eaShanjiezhou return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 270abe3a6eaShanjiezhou } 271abe3a6eaShanjiezhou } 272abe3a6eaShanjiezhou 273abe3a6eaShanjiezhou /// 初始化屏幕控制模块 274abe3a6eaShanjiezhou /// 275abe3a6eaShanjiezhou /// ## 调用时机 276abe3a6eaShanjiezhou /// 277abe3a6eaShanjiezhou /// 该函数在内核启动的早期进行调用。调用时,内存管理模块尚未初始化。 278abe3a6eaShanjiezhou #[no_mangle] 279abe3a6eaShanjiezhou pub extern "C" fn scm_init() { 280abe3a6eaShanjiezhou SCM_DOUBLE_BUFFER_ENABLED.store(false, Ordering::SeqCst); // 禁用双缓冲 281abe3a6eaShanjiezhou 282abe3a6eaShanjiezhou textui_init_no_alloc(); 283abe3a6eaShanjiezhou 284abe3a6eaShanjiezhou c_uart_send_str(UartPort::COM1.to_u16(), "\nfinish_scm_init\n\0".as_ptr()); 285abe3a6eaShanjiezhou } 286abe3a6eaShanjiezhou 287abe3a6eaShanjiezhou /// 启用某个ui框架,将它的帧缓冲区渲染到屏幕上 288abe3a6eaShanjiezhou /// ## 参数 289abe3a6eaShanjiezhou /// 290abe3a6eaShanjiezhou /// - framework 要启动的ui框架 291abe3a6eaShanjiezhou 292abe3a6eaShanjiezhou pub fn scm_framework_enable(framework: Arc<dyn ScmUiFramework>) -> Result<i32, SystemError> { 293abe3a6eaShanjiezhou // 获取信息 294abe3a6eaShanjiezhou let metadata = framework.metadata()?; 295abe3a6eaShanjiezhou 296abe3a6eaShanjiezhou // if metadata.buf_info.buf.is_null() { 297abe3a6eaShanjiezhou // return Err(SystemError::EINVAL); 298abe3a6eaShanjiezhou // } 299abe3a6eaShanjiezhou let mut current_framework = CURRENT_FRAMEWORK.write(); 300abe3a6eaShanjiezhou 301abe3a6eaShanjiezhou if SCM_DOUBLE_BUFFER_ENABLED.load(Ordering::SeqCst) == true { 302*1496ba7bSLoGin video_refresh_manager().set_refresh_target(&metadata.buf_info)?; 303abe3a6eaShanjiezhou } 304abe3a6eaShanjiezhou 305*1496ba7bSLoGin framework.enable()?; 306abe3a6eaShanjiezhou current_framework.replace(framework); 307abe3a6eaShanjiezhou 308abe3a6eaShanjiezhou return Ok(0); 309abe3a6eaShanjiezhou } 310abe3a6eaShanjiezhou /// 向屏幕管理器注册UI框架 311abe3a6eaShanjiezhou /// 312abe3a6eaShanjiezhou /// ## 参数 313abe3a6eaShanjiezhou /// - framework 框架结构体 314abe3a6eaShanjiezhou 315abe3a6eaShanjiezhou pub fn scm_register(framework: Arc<dyn ScmUiFramework>) -> Result<i32, SystemError> { 316abe3a6eaShanjiezhou // 把ui框架加入链表 317abe3a6eaShanjiezhou 318abe3a6eaShanjiezhou SCM_FRAMEWORK_LIST.lock().push_back(framework.clone()); 319abe3a6eaShanjiezhou // 调用ui框架的回调函数以安装ui框架,并将其激活 320abe3a6eaShanjiezhou framework.install()?; 321abe3a6eaShanjiezhou 322abe3a6eaShanjiezhou // 如果当前还没有框架获得了屏幕的控制权,就让其拿去 323abe3a6eaShanjiezhou if CURRENT_FRAMEWORK.read().is_none() { 324abe3a6eaShanjiezhou return scm_framework_enable(framework); 325abe3a6eaShanjiezhou } 326abe3a6eaShanjiezhou return Ok(0); 327abe3a6eaShanjiezhou } 328abe3a6eaShanjiezhou 329*1496ba7bSLoGin /// 屏幕管理器启用双缓冲区 330*1496ba7bSLoGin #[allow(dead_code)] 331*1496ba7bSLoGin pub fn scm_enable_double_buffer() -> Result<i32, SystemError> { 332abe3a6eaShanjiezhou if SCM_DOUBLE_BUFFER_ENABLED.load(Ordering::SeqCst) { 333abe3a6eaShanjiezhou // 已经开启了双缓冲区了, 直接退出 334abe3a6eaShanjiezhou return Ok(0); 335abe3a6eaShanjiezhou } 336abe3a6eaShanjiezhou let scm_list = SCM_FRAMEWORK_LIST.lock(); 337abe3a6eaShanjiezhou if scm_list.is_empty() { 338abe3a6eaShanjiezhou // scm 框架链表为空 339abe3a6eaShanjiezhou return Ok(0); 340abe3a6eaShanjiezhou } 341abe3a6eaShanjiezhou drop(scm_list); 342abe3a6eaShanjiezhou SCM_DOUBLE_BUFFER_ENABLED.store(true, Ordering::SeqCst); 343abe3a6eaShanjiezhou // 创建双缓冲区 344*1496ba7bSLoGin let buf_info = ScmBufferInfo::new(ScmBufferFlag::SCM_BF_DB | ScmBufferFlag::SCM_BF_PIXEL)?; 345*1496ba7bSLoGin 346*1496ba7bSLoGin // 设置定时刷新的对象 347*1496ba7bSLoGin video_refresh_manager() 348*1496ba7bSLoGin .set_refresh_target(&buf_info) 349*1496ba7bSLoGin .expect("set refresh target failed"); 350*1496ba7bSLoGin 351*1496ba7bSLoGin // 设置当前框架的帧缓冲区 352abe3a6eaShanjiezhou CURRENT_FRAMEWORK 353abe3a6eaShanjiezhou .write() 354abe3a6eaShanjiezhou .as_ref() 355abe3a6eaShanjiezhou .unwrap() 356abe3a6eaShanjiezhou .change(buf_info)?; 357abe3a6eaShanjiezhou // 遍历当前所有使用帧缓冲区的框架,更新为双缓冲区 358abe3a6eaShanjiezhou for framework in SCM_FRAMEWORK_LIST.lock().iter_mut() { 359abe3a6eaShanjiezhou if !(*framework).metadata()?.buf_info.is_double_buffer() { 360abe3a6eaShanjiezhou let new_buf_info = 361abe3a6eaShanjiezhou ScmBufferInfo::new(ScmBufferFlag::SCM_BF_DB | ScmBufferFlag::SCM_BF_PIXEL)?; 362abe3a6eaShanjiezhou (*framework).change(new_buf_info)?; 363abe3a6eaShanjiezhou } 364abe3a6eaShanjiezhou } 365abe3a6eaShanjiezhou // 通知显示驱动,启动双缓冲 366*1496ba7bSLoGin video_refresh_manager().video_reinitialize(true)?; 367abe3a6eaShanjiezhou 368abe3a6eaShanjiezhou return Ok(0); 369abe3a6eaShanjiezhou } 370*1496ba7bSLoGin 371abe3a6eaShanjiezhou /// 允许往窗口打印信息 372abe3a6eaShanjiezhou pub fn scm_enable_put_to_window() { 373*1496ba7bSLoGin // mm之前要继续往窗口打印信息时,因为没有动态内存分配(textui并没有往scm注册),且使用的是textui,要直接修改textui里面的值 374abe3a6eaShanjiezhou if CURRENT_FRAMEWORK.read().is_none() { 375abe3a6eaShanjiezhou super::textui::ENABLE_PUT_TO_WINDOW.store(true, Ordering::SeqCst); 376abe3a6eaShanjiezhou } else { 377abe3a6eaShanjiezhou let r = CURRENT_FRAMEWORK 378abe3a6eaShanjiezhou .write() 379abe3a6eaShanjiezhou .as_ref() 380abe3a6eaShanjiezhou .unwrap() 381abe3a6eaShanjiezhou .enable() 382abe3a6eaShanjiezhou .unwrap_or_else(|e| e.to_posix_errno()); 383abe3a6eaShanjiezhou if r.is_negative() { 384abe3a6eaShanjiezhou c_uart_send_str( 385abe3a6eaShanjiezhou UartPort::COM1.to_u16(), 386abe3a6eaShanjiezhou "scm_enable_put_to_window() failed.\n\0".as_ptr(), 387abe3a6eaShanjiezhou ); 388abe3a6eaShanjiezhou } 389abe3a6eaShanjiezhou } 390abe3a6eaShanjiezhou } 391abe3a6eaShanjiezhou /// 禁止往窗口打印信息 392abe3a6eaShanjiezhou pub fn scm_disable_put_to_window() { 393abe3a6eaShanjiezhou // mm之前要停止往窗口打印信息时,因为没有动态内存分配(rwlock与otion依然能用,但是textui并没有往scm注册),且使用的是textui,要直接修改textui里面的值 394abe3a6eaShanjiezhou if CURRENT_FRAMEWORK.read().is_none() { 395abe3a6eaShanjiezhou super::textui::ENABLE_PUT_TO_WINDOW.store(false, Ordering::SeqCst); 396abe3a6eaShanjiezhou assert!(super::textui::ENABLE_PUT_TO_WINDOW.load(Ordering::SeqCst) == false); 397abe3a6eaShanjiezhou } else { 398abe3a6eaShanjiezhou let r = CURRENT_FRAMEWORK 399abe3a6eaShanjiezhou .write() 400abe3a6eaShanjiezhou .as_ref() 401abe3a6eaShanjiezhou .unwrap() 402abe3a6eaShanjiezhou .disable() 403abe3a6eaShanjiezhou .unwrap_or_else(|e| e.to_posix_errno()); 404abe3a6eaShanjiezhou if r.is_negative() { 405abe3a6eaShanjiezhou c_uart_send_str( 406abe3a6eaShanjiezhou UartPort::COM1.to_u16(), 407abe3a6eaShanjiezhou "scm_disable_put_to_window() failed.\n\0".as_ptr(), 408abe3a6eaShanjiezhou ); 409abe3a6eaShanjiezhou } 410abe3a6eaShanjiezhou } 411abe3a6eaShanjiezhou } 412abe3a6eaShanjiezhou /// 当内存管理单元被初始化之后,重新处理帧缓冲区问题 413abe3a6eaShanjiezhou #[no_mangle] 414abe3a6eaShanjiezhou pub extern "C" fn scm_reinit() -> i32 { 415abe3a6eaShanjiezhou let r = true_scm_reinit().unwrap_or_else(|e| e.to_posix_errno()); 416abe3a6eaShanjiezhou if r.is_negative() { 417abe3a6eaShanjiezhou c_uart_send_str(UartPort::COM1.to_u16(), "scm reinit failed.\n\0".as_ptr()); 418abe3a6eaShanjiezhou } 419abe3a6eaShanjiezhou return r; 420abe3a6eaShanjiezhou } 421abe3a6eaShanjiezhou fn true_scm_reinit() -> Result<i32, SystemError> { 422*1496ba7bSLoGin video_refresh_manager() 423*1496ba7bSLoGin .video_reinitialize(false) 424*1496ba7bSLoGin .expect("video reinitialize failed"); 425abe3a6eaShanjiezhou 426abe3a6eaShanjiezhou // 遍历当前所有使用帧缓冲区的框架,更新地址 427*1496ba7bSLoGin let device_buffer = video_refresh_manager().device_buffer().clone(); 428abe3a6eaShanjiezhou for framework in SCM_FRAMEWORK_LIST.lock().iter_mut() { 429abe3a6eaShanjiezhou if framework.metadata()?.buf_info().is_device_buffer() { 430*1496ba7bSLoGin framework.change(device_buffer.clone())?; 431abe3a6eaShanjiezhou } 432abe3a6eaShanjiezhou } 433abe3a6eaShanjiezhou 434abe3a6eaShanjiezhou scm_enable_put_to_window(); 435abe3a6eaShanjiezhou 436abe3a6eaShanjiezhou return Ok(0); 437abe3a6eaShanjiezhou } 438