1 use core::sync::atomic::{AtomicBool, Ordering};
2
3 use crate::{
4 arch::MMArch,
5 init::boot_params,
6 kinfo,
7 libs::{
8 align::page_align_up,
9 lib_ui::screen_manager::{ScmBuffer, ScmBufferFlag, ScmBufferInfo},
10 rwlock::{RwLock, RwLockReadGuard},
11 spinlock::SpinLock,
12 },
13 mm::{
14 allocator::page_frame::PageFrameCount, kernel_mapper::KernelMapper, page::PageFlags,
15 MemoryManagementArch,
16 },
17 time::timer::{Timer, TimerFunction},
18 };
19 use alloc::{boxed::Box, sync::Arc};
20 use system_error::SystemError;
21
22 pub mod fbdev;
23
24 static mut __MAMAGER: Option<VideoRefreshManager> = None;
25
video_refresh_manager() -> &'static VideoRefreshManager26 pub fn video_refresh_manager() -> &'static VideoRefreshManager {
27 return unsafe {
28 &__MAMAGER
29 .as_ref()
30 .expect("Video refresh manager has not been initialized yet!")
31 };
32 }
33
34 ///管理显示刷新变量的结构体
35 pub struct VideoRefreshManager {
36 device_buffer: RwLock<ScmBufferInfo>,
37 refresh_target: RwLock<Option<Arc<SpinLock<Box<[u32]>>>>>,
38 running: AtomicBool,
39 }
40
41 const REFRESH_INTERVAL: u64 = 30;
42
43 impl VideoRefreshManager {
44 /**
45 * @brief 启动定时刷新
46 * @return 启动成功: true, 失败: false
47 */
run_video_refresh(&self) -> bool48 pub fn run_video_refresh(&self) -> bool {
49 //设置Manager运行标志
50 let res = self.set_run();
51
52 //设置成功则开始任务，否则直接返回false
53 if res {
54 //第一次将expire_jiffies设置小一点，使得这次刷新尽快开始，后续的刷新将按照REFRESH_INTERVAL间隔进行
55 let timer = Timer::new(VideoRefreshExecutor::new(), 1);
56 //将新一次定时任务加入队列
57 timer.activate();
58 }
59 return res;
60 }
61
62 /// 停止定时刷新
63 #[allow(dead_code)]
stop_video_refresh(&self)64 pub fn stop_video_refresh(&self) {
65 self.running.store(false, Ordering::SeqCst);
66 }
67
set_run(&self) -> bool68 fn set_run(&self) -> bool {
69 let res = self
70 .running
71 .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst);
72 if res.is_ok() {
73 return true;
74 } else {
75 return false;
76 }
77 }
78
79 /**
80 * @brief VBE帧缓存区的地址重新映射
81 * 将帧缓存区映射到地址SPECIAL_MEMOEY_MAPPING_VIRT_ADDR_BASE处
82 */
init_frame_buffer(&self)83 fn init_frame_buffer(&self) {
84 kinfo!("Re-mapping VBE frame buffer...");
85 let buf_vaddr = boot_params()
86 .read_irqsave()
87 .screen_info
88 .lfb_virt_base
89 .unwrap();
90
91 let mut frame_buffer_info_guard = self.device_buffer.write();
92 if let ScmBuffer::DeviceBuffer(vaddr) = &mut (frame_buffer_info_guard).buf {
93 *vaddr = buf_vaddr;
94 }
95
96 // 地址映射
97 let mut paddr = boot_params().read().screen_info.lfb_base;
98 let count = PageFrameCount::new(
99 page_align_up(frame_buffer_info_guard.buf_size()) / MMArch::PAGE_SIZE,
100 );
101 let page_flags: PageFlags<MMArch> = PageFlags::new().set_execute(true).set_write(true);
102
103 let mut kernel_mapper = KernelMapper::lock();
104 let mut kernel_mapper = kernel_mapper.as_mut();
105 assert!(kernel_mapper.is_some());
106 let mut vaddr = buf_vaddr;
107 unsafe {
108 for _ in 0..count.data() {
109 let flusher = kernel_mapper
110 .as_mut()
111 .unwrap()
112 .map_phys(vaddr, paddr, page_flags)
113 .unwrap();
114
115 flusher.flush();
116 vaddr += MMArch::PAGE_SIZE;
117 paddr += MMArch::PAGE_SIZE;
118 }
119 }
120
121 kinfo!("VBE frame buffer successfully Re-mapped!");
122 }
123
124 /**
125 * @brief 初始化显示模块，需先低级初始化才能高级初始化
126 * @param level 初始化等级
127 * false -> 低级初始化：不使用double buffer
128 * true ->高级初始化：增加double buffer的支持
129 * @return int
130 */
video_reinitialize(&self, level: bool) -> Result<(), SystemError>131 pub fn video_reinitialize(&self, level: bool) -> Result<(), SystemError> {
132 if !level {
133 self.init_frame_buffer();
134 } else {
135 // 开启屏幕计时刷新
136 assert!(self.run_video_refresh());
137 }
138 return Ok(());
139 }
140
141 /**
142 * @brief 设置帧缓冲区刷新目标
143 *
144 * @param buf
145 * @return int
146 */
set_refresh_target(&self, buf_info: &ScmBufferInfo) -> Result<(), SystemError>147 pub fn set_refresh_target(&self, buf_info: &ScmBufferInfo) -> Result<(), SystemError> {
148 let mut refresh_target = self.refresh_target.write_irqsave();
149 if let ScmBuffer::DoubleBuffer(double_buffer) = &buf_info.buf {
150 *refresh_target = Some(double_buffer.clone());
151 return Ok(());
152 }
153 return Err(SystemError::EINVAL);
154 }
155
156 #[allow(dead_code)]
refresh_target(&self) -> RwLockReadGuard<'_, Option<Arc<SpinLock<Box<[u32]>>>>>157 pub fn refresh_target(&self) -> RwLockReadGuard<'_, Option<Arc<SpinLock<Box<[u32]>>>>> {
158 let x = self.refresh_target.read();
159
160 return x;
161 }
162
device_buffer(&self) -> RwLockReadGuard<'_, ScmBufferInfo>163 pub fn device_buffer(&self) -> RwLockReadGuard<'_, ScmBufferInfo> {
164 return self.device_buffer.read();
165 }
166
167 /// 在riscv64平台下暂时不支持
168 #[cfg(target_arch = "riscv64")]
video_init() -> Result<(), SystemError>169 pub unsafe fn video_init() -> Result<(), SystemError> {
170 return Err(SystemError::ENOSYS);
171 }
172
173 /// 此函数用于初始化显示驱动，为后续的图形输出做好准备。
174 #[cfg(target_arch = "x86_64")]
video_init() -> Result<(), SystemError>175 pub unsafe fn video_init() -> Result<(), SystemError> {
176 use crate::{
177 arch::driver::video::arch_video_early_init,
178 driver::{
179 serial::serial8250::send_to_default_serial8250_port,
180 video::fbdev::base::BootTimeVideoType,
181 },
182 };
183
184 arch_video_early_init()?;
185
186 let boot_params_guard = boot_params().read();
187 let screen_info = &boot_params_guard.screen_info;
188 let buf_vaddr = screen_info.lfb_virt_base.unwrap();
189
190 let buf_flag: ScmBufferFlag;
191 let device_buffer: ScmBufferInfo;
192
193 if screen_info.video_type == BootTimeVideoType::Mda {
194 buf_flag = ScmBufferFlag::SCM_BF_TEXT | ScmBufferFlag::SCM_BF_FB;
195 device_buffer = ScmBufferInfo::new_device_buffer(
196 screen_info.origin_video_cols.into(),
197 screen_info.origin_video_lines.into(),
198 screen_info.lfb_size as u32,
199 screen_info.lfb_depth.into(),
200 buf_flag,
201 buf_vaddr,
202 )
203 .unwrap();
204 } else {
205 // 图形模式
206 buf_flag = ScmBufferFlag::SCM_BF_PIXEL | ScmBufferFlag::SCM_BF_FB;
207 device_buffer = ScmBufferInfo::new_device_buffer(
208 screen_info.lfb_width,
209 screen_info.lfb_height,
210 screen_info.lfb_size as u32,
211 screen_info.lfb_depth.into(),
212 buf_flag,
213 buf_vaddr,
214 )
215 .unwrap();
216 }
217
218 let result = Self {
219 device_buffer: RwLock::new(device_buffer),
220 refresh_target: RwLock::new(None),
221 running: AtomicBool::new(false),
222 };
223
224 __MAMAGER = Some(result);
225
226 let init_text = "Video driver initialized.\n\0";
227 send_to_default_serial8250_port(init_text.as_bytes());
228 return Ok(());
229 }
230 }
231
232 //刷新任务执行器
233 #[derive(Debug)]
234 struct VideoRefreshExecutor;
235
236 impl VideoRefreshExecutor {
new() -> Box<VideoRefreshExecutor>237 fn new() -> Box<VideoRefreshExecutor> {
238 return Box::new(VideoRefreshExecutor);
239 }
240 }
241
242 impl TimerFunction for VideoRefreshExecutor {
243 /**
244 * @brief 交给定时器执行的任务，此方法不应手动调用
245 * @return Ok(())
246 */
run(&mut self) -> Result<(), SystemError>247 fn run(&mut self) -> Result<(), SystemError> {
248 // 获得Manager
249 let manager = video_refresh_manager();
250
251 let start_next_refresh = || {
252 //判断是否还需要刷新，若需要则继续分配下一次计时任务，否则不分配
253 if manager.running.load(Ordering::SeqCst) {
254 let timer = Timer::new(VideoRefreshExecutor::new(), REFRESH_INTERVAL);
255 //将新一次定时任务加入队列
256 timer.activate();
257 }
258 };
259
260 let mut refresh_target: Option<RwLockReadGuard<'_, Option<Arc<SpinLock<Box<[u32]>>>>>> =
261 None;
262 const TRY_TIMES: i32 = 2;
263 for i in 0..TRY_TIMES {
264 let g = manager.refresh_target.try_read();
265 if g.is_none() {
266 if i == TRY_TIMES - 1 {
267 start_next_refresh();
268 return Ok(());
269 }
270 continue;
271 }
272 refresh_target = Some(g.unwrap());
273 break;
274 }
275
276 let refresh_target = refresh_target.unwrap();
277
278 if let ScmBuffer::DeviceBuffer(vaddr) = manager.device_buffer().buf {
279 let p = vaddr.as_ptr() as *mut u8;
280 let mut target_guard = None;
281 for _ in 0..2 {
282 if let Ok(guard) = refresh_target.as_ref().unwrap().try_lock_irqsave() {
283 target_guard = Some(guard);
284 break;
285 }
286 }
287 if target_guard.is_none() {
288 start_next_refresh();
289 return Ok(());
290 }
291 let mut target_guard = target_guard.unwrap();
292 unsafe {
293 p.copy_from_nonoverlapping(
294 target_guard.as_mut_ptr() as *mut u8,
295 manager.device_buffer().buf_size() as usize,
296 )
297 }
298 }
299
300 start_next_refresh();
301
302 return Ok(());
303 }
304 }
305
306 #[no_mangle]
rs_video_init() -> i32307 pub unsafe extern "C" fn rs_video_init() -> i32 {
308 return VideoRefreshManager::video_init()
309 .map(|_| 0)
310 .unwrap_or_else(|e| e.to_posix_errno());
311 }
312