1 use core::sync::atomic::AtomicBool; 2 3 use alloc::{ 4 string::{String, ToString}, 5 sync::{Arc, Weak}, 6 vec::Vec, 7 }; 8 use log::{info, warn}; 9 use system_error::SystemError; 10 use unified_init::macros::unified_init; 11 12 use crate::{ 13 driver::{ 14 base::{ 15 class::Class, 16 device::{ 17 bus::Bus, device_manager, driver::Driver, Device, DeviceState, DeviceType, IdTable, 18 }, 19 kobject::{KObjType, KObject, KObjectState, LockedKObjectState}, 20 kset::KSet, 21 platform::{ 22 platform_device::{platform_device_manager, PlatformDevice}, 23 platform_driver::{platform_driver_manager, PlatformDriver}, 24 }, 25 }, 26 serial::serial8250::send_to_default_serial8250_port, 27 video::fbdev::base::{fbmem::frame_buffer_manager, FbVisual, FRAME_BUFFER_SET}, 28 }, 29 filesystem::{ 30 kernfs::KernFSInode, 31 sysfs::{file::sysfs_emit_str, Attribute, AttributeGroup, SysFSOpsSupport}, 32 vfs::syscall::ModeType, 33 }, 34 init::{boot::boot_callbacks, boot_params, initcall::INITCALL_DEVICE}, 35 libs::{ 36 once::Once, 37 rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard}, 38 spinlock::SpinLock, 39 }, 40 mm::{early_ioremap::EarlyIoRemap, PhysAddr, VirtAddr}, 41 }; 42 43 use super::base::{ 44 fbmem::FbDevice, BlankMode, BootTimeVideoType, FbAccel, FbActivateFlags, FbId, FbState, FbType, 45 FbVModeFlags, FbVarScreenInfo, FbVideoMode, FixedScreenInfo, FrameBuffer, FrameBufferInfo, 46 FrameBufferInfoData, FrameBufferOps, 47 }; 48 49 /// 当前机器上面是否有vesa帧缓冲区 50 static HAS_VESA_FB: AtomicBool = AtomicBool::new(false); 51 52 lazy_static! { 53 static ref VESAFB_FIX_INFO: RwLock<FixedScreenInfo> = RwLock::new(FixedScreenInfo { 54 id: FixedScreenInfo::name2id("VESA VGA"), 55 fb_type: FbType::PackedPixels, 56 accel: FbAccel::None, 57 ..Default::default() 58 }); 59 static ref VESAFB_DEFINED: RwLock<FbVarScreenInfo> = RwLock::new(FbVarScreenInfo { 60 activate: FbActivateFlags::FB_ACTIVATE_NOW, 61 height: None, 62 width: None, 63 right_margin: 32, 64 upper_margin: 16, 65 lower_margin: 4, 66 vsync_len: 4, 67 vmode: FbVModeFlags::FB_VMODE_NONINTERLACED, 68 69 ..Default::default() 70 }); 71 } 72 73 #[derive(Debug)] 74 #[cast_to([sync] Device)] 75 #[cast_to([sync] PlatformDevice)] 76 pub struct VesaFb { 77 inner: SpinLock<InnerVesaFb>, 78 kobj_state: LockedKObjectState, 79 fb_data: RwLock<FrameBufferInfoData>, 80 } 81 82 impl VesaFb { 83 pub const NAME: &'static str = "vesa_vga"; 84 pub fn new() -> Self { 85 let mut fb_info_data = FrameBufferInfoData::new(); 86 fb_info_data.pesudo_palette.resize(256, 0); 87 return Self { 88 inner: SpinLock::new(InnerVesaFb { 89 bus: None, 90 class: None, 91 driver: None, 92 kern_inode: None, 93 parent: None, 94 kset: None, 95 kobj_type: None, 96 device_state: DeviceState::NotInitialized, 97 pdev_id: 0, 98 pdev_id_auto: false, 99 fb_id: FbId::INIT, 100 fb_device: None, 101 fb_state: FbState::Suspended, 102 }), 103 kobj_state: LockedKObjectState::new(None), 104 fb_data: RwLock::new(fb_info_data), 105 }; 106 } 107 } 108 109 #[derive(Debug)] 110 struct InnerVesaFb { 111 bus: Option<Weak<dyn Bus>>, 112 class: Option<Weak<dyn Class>>, 113 driver: Option<Weak<dyn Driver>>, 114 kern_inode: Option<Arc<KernFSInode>>, 115 parent: Option<Weak<dyn KObject>>, 116 kset: Option<Arc<KSet>>, 117 kobj_type: Option<&'static dyn KObjType>, 118 device_state: DeviceState, 119 pdev_id: i32, 120 pdev_id_auto: bool, 121 fb_id: FbId, 122 fb_device: Option<Arc<FbDevice>>, 123 fb_state: FbState, 124 } 125 126 impl FrameBuffer for VesaFb { 127 fn fb_id(&self) -> FbId { 128 self.inner.lock().fb_id 129 } 130 131 fn set_fb_id(&self, id: FbId) { 132 self.inner.lock().fb_id = id; 133 } 134 } 135 136 impl PlatformDevice for VesaFb { 137 fn pdev_name(&self) -> &str { 138 Self::NAME 139 } 140 141 fn set_pdev_id(&self, id: i32) { 142 self.inner.lock().pdev_id = id; 143 } 144 145 fn set_pdev_id_auto(&self, id_auto: bool) { 146 self.inner.lock().pdev_id_auto = id_auto; 147 } 148 149 fn is_initialized(&self) -> bool { 150 self.inner.lock().device_state == DeviceState::Initialized 151 } 152 153 fn set_state(&self, set_state: DeviceState) { 154 self.inner.lock().device_state = set_state; 155 } 156 } 157 158 impl Device for VesaFb { 159 fn dev_type(&self) -> DeviceType { 160 DeviceType::Char 161 } 162 163 fn id_table(&self) -> IdTable { 164 IdTable::new(self.name(), None) 165 } 166 167 fn bus(&self) -> Option<Weak<dyn Bus>> { 168 self.inner.lock().bus.clone() 169 } 170 171 fn set_bus(&self, bus: Option<Weak<dyn Bus>>) { 172 self.inner.lock().bus = bus; 173 } 174 175 fn set_class(&self, class: Option<Weak<dyn Class>>) { 176 self.inner.lock().class = class; 177 } 178 179 fn class(&self) -> Option<Arc<dyn Class>> { 180 let mut guard = self.inner.lock(); 181 182 let r = guard.class.clone()?.upgrade(); 183 if r.is_none() { 184 // 为了让弱引用失效 185 guard.class = None; 186 } 187 188 return r; 189 } 190 191 fn driver(&self) -> Option<Arc<dyn Driver>> { 192 self.inner.lock().driver.clone()?.upgrade() 193 } 194 195 fn set_driver(&self, driver: Option<Weak<dyn Driver>>) { 196 self.inner.lock().driver = driver; 197 } 198 199 fn is_dead(&self) -> bool { 200 false 201 } 202 203 fn can_match(&self) -> bool { 204 true 205 } 206 207 fn set_can_match(&self, _can_match: bool) {} 208 209 fn state_synced(&self) -> bool { 210 true 211 } 212 } 213 214 impl KObject for VesaFb { 215 fn as_any_ref(&self) -> &dyn core::any::Any { 216 self 217 } 218 219 fn set_inode(&self, inode: Option<Arc<KernFSInode>>) { 220 self.inner.lock().kern_inode = inode; 221 } 222 223 fn inode(&self) -> Option<Arc<KernFSInode>> { 224 self.inner.lock().kern_inode.clone() 225 } 226 227 fn parent(&self) -> Option<Weak<dyn KObject>> { 228 self.inner.lock().parent.clone() 229 } 230 231 fn set_parent(&self, parent: Option<Weak<dyn KObject>>) { 232 self.inner.lock().parent = parent; 233 } 234 235 fn kset(&self) -> Option<Arc<KSet>> { 236 self.inner.lock().kset.clone() 237 } 238 239 fn set_kset(&self, kset: Option<Arc<KSet>>) { 240 self.inner.lock().kset = kset; 241 } 242 243 fn kobj_type(&self) -> Option<&'static dyn KObjType> { 244 self.inner.lock().kobj_type 245 } 246 247 fn set_kobj_type(&self, ktype: Option<&'static dyn KObjType>) { 248 self.inner.lock().kobj_type = ktype; 249 } 250 251 fn name(&self) -> String { 252 Self::NAME.to_string() 253 } 254 255 fn set_name(&self, _name: String) { 256 // do nothing 257 } 258 259 fn kobj_state(&self) -> RwLockReadGuard<KObjectState> { 260 self.kobj_state.read() 261 } 262 263 fn kobj_state_mut(&self) -> RwLockWriteGuard<KObjectState> { 264 self.kobj_state.write() 265 } 266 267 fn set_kobj_state(&self, state: KObjectState) { 268 *self.kobj_state.write() = state; 269 } 270 } 271 272 impl FrameBufferOps for VesaFb { 273 fn fb_open(&self, _user: bool) { 274 todo!() 275 } 276 277 fn fb_release(&self, _user: bool) { 278 todo!() 279 } 280 281 fn fb_set_color_register( 282 &self, 283 regno: u16, 284 mut red: u16, 285 mut green: u16, 286 mut blue: u16, 287 ) -> Result<(), SystemError> { 288 let mut fb_data = self.framebuffer_info_data().write(); 289 let var = self.current_fb_var(); 290 if regno as usize >= fb_data.pesudo_palette.len() { 291 return Err(SystemError::E2BIG); 292 } 293 294 if var.bits_per_pixel == 8 { 295 todo!("vesa_setpalette todo"); 296 } else if regno < 16 { 297 match var.bits_per_pixel { 298 16 => { 299 if var.red.offset == 10 { 300 // RGB 1:5:5:5 301 fb_data.pesudo_palette[regno as usize] = ((red as u32 & 0xf800) >> 1) 302 | ((green as u32 & 0xf800) >> 6) 303 | ((blue as u32 & 0xf800) >> 11); 304 } else { 305 fb_data.pesudo_palette[regno as usize] = (red as u32 & 0xf800) 306 | ((green as u32 & 0xfc00) >> 5) 307 | ((blue as u32 & 0xf800) >> 11); 308 } 309 } 310 24 | 32 => { 311 red >>= 8; 312 green >>= 8; 313 blue >>= 8; 314 fb_data.pesudo_palette[regno as usize] = ((red as u32) << var.red.offset) 315 | ((green as u32) << var.green.offset) 316 | ((blue as u32) << var.blue.offset); 317 } 318 _ => {} 319 } 320 } 321 322 Ok(()) 323 } 324 325 fn fb_blank(&self, _blank_mode: BlankMode) -> Result<(), SystemError> { 326 todo!() 327 } 328 329 fn fb_destroy(&self) { 330 todo!() 331 } 332 333 fn fb_read(&self, buf: &mut [u8], pos: usize) -> Result<usize, SystemError> { 334 let bp = boot_params().read(); 335 336 let vaddr = bp.screen_info.lfb_virt_base.ok_or(SystemError::ENODEV)?; 337 let size = self.current_fb_fix().smem_len; 338 drop(bp); 339 if pos >= size { 340 return Ok(0); 341 } 342 343 let pos = pos as i64; 344 let size = size as i64; 345 346 let len = core::cmp::min(size - pos, buf.len() as i64) as usize; 347 348 let slice = unsafe { core::slice::from_raw_parts(vaddr.as_ptr::<u8>(), size as usize) }; 349 buf[..len].copy_from_slice(&slice[pos as usize..(pos as usize + len)]); 350 351 return Ok(len); 352 } 353 354 fn fb_write(&self, buf: &[u8], pos: usize) -> Result<usize, SystemError> { 355 let bp = boot_params().read(); 356 357 let vaddr = bp.screen_info.lfb_virt_base.ok_or(SystemError::ENODEV)?; 358 let size = self.current_fb_fix().smem_len; 359 360 if pos >= size { 361 return Ok(0); 362 } 363 364 let pos = pos as i64; 365 let size = size as i64; 366 367 let len = core::cmp::min(size - pos, buf.len() as i64) as usize; 368 369 let slice = unsafe { core::slice::from_raw_parts_mut(vaddr.as_ptr::<u8>(), size as usize) }; 370 slice[pos as usize..(pos as usize + len)].copy_from_slice(&buf[..len]); 371 372 return Ok(len); 373 } 374 375 fn fb_image_blit(&self, image: &super::base::FbImage) { 376 self.generic_imageblit(image); 377 } 378 379 /// ## 填充矩形 380 fn fb_fillrect(&self, rect: super::base::FillRectData) -> Result<(), SystemError> { 381 // warn!("rect {rect:?}"); 382 383 let boot_param = boot_params().read(); 384 let screen_base = boot_param 385 .screen_info 386 .lfb_virt_base 387 .ok_or(SystemError::ENODEV)?; 388 389 let fg = if self.current_fb_fix().visual == FbVisual::TrueColor 390 || self.current_fb_fix().visual == FbVisual::DirectColor 391 { 392 self.fb_data.read().pesudo_palette[rect.color as usize] 393 } else { 394 rect.color 395 }; 396 397 let bpp = self.current_fb_var().bits_per_pixel; 398 // 每行像素数 399 let line_offset = self.current_fb_var().xres; 400 match bpp { 401 32 => { 402 let base = screen_base.as_ptr::<u32>(); 403 404 for y in rect.dy..(rect.dy + rect.height) { 405 for x in rect.dx..(rect.dx + rect.width) { 406 unsafe { *base.add((y * line_offset + x) as usize) = fg }; 407 } 408 } 409 } 410 16 => { 411 let base = screen_base.as_ptr::<u16>(); 412 413 for y in rect.dy..(rect.dy + rect.height) { 414 for x in rect.dx..(rect.dx + rect.width) { 415 unsafe { *base.add((y * line_offset + x) as usize) = 0x0000 }; 416 } 417 } 418 } 419 24 => { 420 let base = screen_base.as_ptr::<[u8; 3]>(); 421 422 for y in rect.dy..(rect.dy + rect.height) { 423 for x in rect.dx..(rect.dx + rect.width) { 424 unsafe { *base.add((y * line_offset + x) as usize) = [0, 0, 0] }; 425 } 426 } 427 } 428 _ => { 429 send_to_default_serial8250_port( 430 format!("unsupported bit depth:{}!\n\0", bpp).as_bytes(), 431 ); 432 todo!() 433 } 434 } 435 436 Ok(()) 437 } 438 439 #[inline(never)] 440 fn fb_copyarea(&self, data: super::base::CopyAreaData) { 441 let bp = boot_params().read(); 442 let base = bp.screen_info.lfb_virt_base.unwrap(); 443 let var = self.current_fb_var(); 444 445 // 原区域或者目标区域全在屏幕外，则直接返回 446 if data.sx > var.xres as i32 447 || data.sy > var.yres as i32 448 || data.dx > var.xres as i32 449 || data.dy > var.yres as i32 450 || (data.sx + data.width as i32) < 0 451 || (data.sy + data.height as i32) < 0 452 || (data.dx + data.width as i32) < 0 453 || (data.dy + data.height as i32) < 0 454 { 455 return; 456 } 457 458 // 求两个矩形可视范围交集 459 let (s_visiable_x, s_w) = if data.sx < 0 { 460 (0, (data.width - ((-data.sx) as u32)).min(var.xres)) 461 } else { 462 let w = if data.sx as u32 + data.width > var.xres { 463 var.xres - data.sx as u32 464 } else { 465 data.width 466 }; 467 468 (data.sx, w) 469 }; 470 let (s_visiable_y, s_h) = if data.sy < 0 { 471 (0, (data.height - ((-data.sy) as u32).min(var.yres))) 472 } else { 473 let h = if data.sy as u32 + data.height > var.yres { 474 var.yres - data.sy as u32 475 } else { 476 data.height 477 }; 478 479 (data.sy, h) 480 }; 481 482 let (d_visiable_x, d_w) = if data.dx < 0 { 483 (0, (data.width - ((-data.dx) as u32)).min(var.xres)) 484 } else { 485 let w = if data.dx as u32 + data.width > var.xres { 486 var.xres - data.dx as u32 487 } else { 488 data.width 489 }; 490 491 (data.dx, w) 492 }; 493 let (d_visiable_y, d_h) = if data.dy < 0 { 494 (0, (data.height - ((-data.dy) as u32).min(var.yres))) 495 } else { 496 let h = if data.dy as u32 + data.height > var.yres { 497 var.yres - data.dy as u32 498 } else { 499 data.height 500 }; 501 502 (data.dy, h) 503 }; 504 505 // 可视范围无交集 506 if !(d_h + s_h > data.height && s_w + d_w > data.width) { 507 return; 508 } 509 510 // 可视区域左上角相对于矩形的坐标 511 let s_relative_x = s_visiable_x - data.sx; 512 let s_relative_y = s_visiable_y - data.sy; 513 let d_relative_x = d_visiable_x - data.dx; 514 let d_relative_y = d_visiable_y - data.dy; 515 516 let visiable_x = s_relative_x.max(d_relative_x); 517 let visiable_y = s_relative_y.max(d_relative_y); 518 let visiable_h = d_h + s_h - data.height; 519 let visiable_w = d_w + s_w - data.width; 520 521 let s_real_x = (visiable_x + data.sx) as u32; 522 let s_real_y = (visiable_y + data.sy) as u32; 523 let d_real_x = (visiable_x + data.dx) as u32; 524 let d_real_y = (visiable_y + data.dy) as u32; 525 526 let bytes_per_pixel = var.bits_per_pixel >> 3; 527 let bytes_per_line = var.xres * bytes_per_pixel; 528 529 let src = 530 base + VirtAddr::new((s_real_y * bytes_per_line + s_real_x * bytes_per_pixel) as usize); 531 532 let dst = 533 base + VirtAddr::new((d_real_y * bytes_per_line + d_real_x * bytes_per_pixel) as usize); 534 535 let size = (visiable_h * visiable_w) as usize; 536 537 match bytes_per_pixel { 538 4 => { 539 // 32bpp 540 let mut dst = dst.as_ptr::<u32>(); 541 let mut src = src.as_ptr::<u32>(); 542 let line_offset = var.xres as usize; 543 544 if s_real_x > d_real_x { 545 // 如果src在dst下方，则可以直接拷贝不会出现指针覆盖 546 unsafe { 547 for _ in 0..visiable_h { 548 core::ptr::copy(src, dst, visiable_w as usize); 549 src = src.add(line_offset); 550 dst = dst.add(visiable_w as usize); 551 } 552 } 553 } else { 554 let mut tmp: Vec<u32> = vec![0; size]; 555 let mut tmp_ptr = tmp.as_mut_ptr(); 556 557 // 这里是一个可以优化的点，现在为了避免指针拷贝时覆盖，统一先拷贝进入buf再拷贝到dst 558 unsafe { 559 for _ in 0..visiable_h { 560 core::ptr::copy(src, tmp_ptr, visiable_w as usize); 561 src = src.add(line_offset); 562 tmp_ptr = tmp_ptr.add(visiable_w as usize); 563 } 564 565 tmp_ptr = tmp_ptr.sub(size); 566 for _ in 0..visiable_h { 567 core::ptr::copy(tmp_ptr, dst, visiable_w as usize); 568 dst = dst.add(line_offset); 569 tmp_ptr = tmp_ptr.add(visiable_w as usize); 570 } 571 } 572 } 573 } 574 2 => { 575 let mut dst = dst.as_ptr::<u16>(); 576 let mut src = src.as_ptr::<u16>(); 577 let line_offset = var.xres as usize; 578 579 if s_real_x > d_real_x { 580 // 如果src在dst下方，则可以直接拷贝不会出现指针覆盖 581 unsafe { 582 for _ in 0..visiable_h { 583 core::ptr::copy(src, dst, visiable_w as usize); 584 src = src.add(line_offset); 585 dst = dst.add(visiable_w as usize); 586 } 587 } 588 } else { 589 let mut tmp: Vec<u16> = vec![0; size]; 590 let mut tmp_ptr = tmp.as_mut_ptr(); 591 592 // 这里是一个可以优化的点，现在为了避免指针拷贝时覆盖，统一先拷贝进入buf再拷贝到dst 593 unsafe { 594 for _ in 0..visiable_h { 595 core::ptr::copy(src, tmp_ptr, visiable_w as usize); 596 src = src.add(line_offset); 597 tmp_ptr = tmp_ptr.add(visiable_w as usize); 598 } 599 600 tmp_ptr = tmp_ptr.sub(size); 601 for _ in 0..visiable_h { 602 core::ptr::copy(tmp_ptr, dst, visiable_w as usize); 603 dst = dst.add(line_offset); 604 tmp_ptr = tmp_ptr.add(visiable_w as usize); 605 } 606 } 607 } 608 } 609 3 => { 610 let mut dst = dst.as_ptr::<[u8; 3]>(); 611 let mut src = src.as_ptr::<[u8; 3]>(); 612 let line_offset = var.xres as usize; 613 614 if s_real_x > d_real_x { 615 // 如果src在dst下方，则可以直接拷贝不会出现指针覆盖 616 unsafe { 617 for _ in 0..visiable_h { 618 core::ptr::copy(src, dst, visiable_w as usize); 619 src = src.add(line_offset); 620 dst = dst.add(visiable_w as usize); 621 } 622 } 623 } else { 624 let mut tmp: Vec<u32> = vec![0; size]; 625 let mut tmp_ptr = tmp.as_mut_ptr() as *mut [u8; 3]; 626 627 // 这里是一个可以优化的点，现在为了避免指针拷贝时覆盖，统一先拷贝进入buf再拷贝到dst 628 unsafe { 629 for _ in 0..visiable_h { 630 core::ptr::copy(src, tmp_ptr, visiable_w as usize); 631 src = src.add(line_offset); 632 tmp_ptr = tmp_ptr.add(visiable_w as usize); 633 } 634 635 tmp_ptr = tmp_ptr.sub(size); 636 for _ in 0..visiable_h { 637 core::ptr::copy(tmp_ptr, dst, visiable_w as usize); 638 dst = dst.add(line_offset); 639 tmp_ptr = tmp_ptr.add(visiable_w as usize); 640 } 641 } 642 } 643 } 644 645 _ => { 646 send_to_default_serial8250_port( 647 format!("bytes_per_pixel:{}\n\0", bytes_per_pixel).as_bytes(), 648 ); 649 todo!() 650 } 651 } 652 } 653 } 654 655 impl FrameBufferInfo for VesaFb { 656 fn fb_device(&self) -> Option<Arc<FbDevice>> { 657 self.inner.lock().fb_device.clone() 658 } 659 660 fn set_fb_device(&self, device: Option<Arc<FbDevice>>) { 661 self.inner.lock().fb_device = device; 662 } 663 664 fn screen_size(&self) -> usize { 665 todo!() 666 } 667 668 fn current_fb_var(&self) -> FbVarScreenInfo { 669 *VESAFB_DEFINED.read() 670 } 671 672 fn current_fb_fix(&self) -> FixedScreenInfo { 673 *VESAFB_FIX_INFO.read() 674 } 675 676 fn video_mode(&self) -> Option<&FbVideoMode> { 677 todo!() 678 } 679 680 fn state(&self) -> FbState { 681 self.inner.lock().fb_state 682 } 683 684 fn framebuffer_info_data(&self) -> &RwLock<FrameBufferInfoData> { 685 &self.fb_data 686 } 687 } 688 689 #[derive(Debug)] 690 #[cast_to([sync] PlatformDriver)] 691 struct VesaFbDriver { 692 inner: SpinLock<InnerVesaFbDriver>, 693 kobj_state: LockedKObjectState, 694 } 695 696 impl VesaFbDriver { 697 pub fn new() -> Arc<Self> { 698 let r = Arc::new(Self { 699 inner: SpinLock::new(InnerVesaFbDriver { 700 ktype: None, 701 kset: None, 702 parent: None, 703 kernfs_inode: None, 704 devices: Vec::new(), 705 bus: None, 706 self_ref: Weak::new(), 707 }), 708 kobj_state: LockedKObjectState::new(None), 709 }); 710 711 r.inner.lock().self_ref = Arc::downgrade(&r); 712 713 return r; 714 } 715 } 716 717 #[derive(Debug)] 718 struct InnerVesaFbDriver { 719 ktype: Option<&'static dyn KObjType>, 720 kset: Option<Arc<KSet>>, 721 parent: Option<Weak<dyn KObject>>, 722 kernfs_inode: Option<Arc<KernFSInode>>, 723 devices: Vec<Arc<dyn Device>>, 724 bus: Option<Weak<dyn Bus>>, 725 726 self_ref: Weak<VesaFbDriver>, 727 } 728 729 impl VesaFbDriver { 730 const NAME: &'static str = "vesa-framebuffer"; 731 } 732 733 impl PlatformDriver for VesaFbDriver { 734 fn probe(&self, device: &Arc<dyn PlatformDevice>) -> Result<(), SystemError> { 735 let device = device 736 .clone() 737 .arc_any() 738 .downcast::<VesaFb>() 739 .map_err(|_| SystemError::EINVAL)?; 740 741 device.set_driver(Some(self.inner.lock_irqsave().self_ref.clone())); 742 743 return Ok(()); 744 } 745 746 fn remove(&self, _device: &Arc<dyn PlatformDevice>) -> Result<(), SystemError> { 747 todo!() 748 } 749 750 fn shutdown(&self, _device: &Arc<dyn PlatformDevice>) -> Result<(), SystemError> { 751 // do nothing 752 return Ok(()); 753 } 754 755 fn suspend(&self, _device: &Arc<dyn PlatformDevice>) -> Result<(), SystemError> { 756 // do nothing 757 return Ok(()); 758 } 759 760 fn resume(&self, _device: &Arc<dyn PlatformDevice>) -> Result<(), SystemError> { 761 todo!() 762 } 763 } 764 765 impl Driver for VesaFbDriver { 766 fn id_table(&self) -> Option<IdTable> { 767 Some(IdTable::new(VesaFb::NAME.to_string(), None)) 768 } 769 770 fn devices(&self) -> Vec<Arc<dyn Device>> { 771 self.inner.lock().devices.clone() 772 } 773 774 fn add_device(&self, device: Arc<dyn Device>) { 775 let mut guard = self.inner.lock(); 776 // check if the device is already in the list 777 if guard.devices.iter().any(|dev| Arc::ptr_eq(dev, &device)) { 778 return; 779 } 780 781 guard.devices.push(device); 782 } 783 784 fn delete_device(&self, device: &Arc<dyn Device>) { 785 let mut guard = self.inner.lock(); 786 guard.devices.retain(|dev| !Arc::ptr_eq(dev, device)); 787 } 788 789 fn set_bus(&self, bus: Option<Weak<dyn Bus>>) { 790 self.inner.lock().bus = bus; 791 } 792 793 fn bus(&self) -> Option<Weak<dyn Bus>> { 794 self.inner.lock().bus.clone() 795 } 796 797 fn dev_groups(&self) -> &'static [&'static dyn AttributeGroup] { 798 return &[&VesaFbAnonAttributeGroup]; 799 } 800 } 801 802 impl KObject for VesaFbDriver { 803 fn as_any_ref(&self) -> &dyn core::any::Any { 804 self 805 } 806 807 fn set_inode(&self, inode: Option<Arc<KernFSInode>>) { 808 self.inner.lock().kernfs_inode = inode; 809 } 810 811 fn inode(&self) -> Option<Arc<KernFSInode>> { 812 self.inner.lock().kernfs_inode.clone() 813 } 814 815 fn parent(&self) -> Option<Weak<dyn KObject>> { 816 self.inner.lock().parent.clone() 817 } 818 819 fn set_parent(&self, parent: Option<Weak<dyn KObject>>) { 820 self.inner.lock().parent = parent; 821 } 822 823 fn kset(&self) -> Option<Arc<KSet>> { 824 self.inner.lock().kset.clone() 825 } 826 827 fn set_kset(&self, kset: Option<Arc<KSet>>) { 828 self.inner.lock().kset = kset; 829 } 830 831 fn kobj_type(&self) -> Option<&'static dyn KObjType> { 832 self.inner.lock().ktype 833 } 834 835 fn set_kobj_type(&self, ktype: Option<&'static dyn KObjType>) { 836 self.inner.lock().ktype = ktype; 837 } 838 839 fn name(&self) -> String { 840 Self::NAME.to_string() 841 } 842 843 fn set_name(&self, _name: String) { 844 // do nothing 845 } 846 847 fn kobj_state(&self) -> RwLockReadGuard<KObjectState> { 848 self.kobj_state.read() 849 } 850 851 fn kobj_state_mut(&self) -> RwLockWriteGuard<KObjectState> { 852 self.kobj_state.write() 853 } 854 855 fn set_kobj_state(&self, state: KObjectState) { 856 *self.kobj_state.write() = state; 857 } 858 } 859 860 #[derive(Debug)] 861 struct VesaFbAnonAttributeGroup; 862 863 impl AttributeGroup for VesaFbAnonAttributeGroup { 864 fn name(&self) -> Option<&str> { 865 None 866 } 867 868 fn attrs(&self) -> &[&'static dyn Attribute] { 869 &[&AnonAttrPhysAddr as &'static dyn Attribute] 870 } 871 872 fn is_visible( 873 &self, 874 _kobj: Arc<dyn KObject>, 875 attr: &'static dyn Attribute, 876 ) -> Option<ModeType> { 877 Some(attr.mode()) 878 } 879 } 880 881 #[derive(Debug)] 882 struct AnonAttrPhysAddr; 883 884 impl Attribute for AnonAttrPhysAddr { 885 fn name(&self) -> &str { 886 "smem_start" 887 } 888 889 fn mode(&self) -> ModeType { 890 ModeType::S_IRUGO 891 } 892 893 fn support(&self) -> SysFSOpsSupport { 894 SysFSOpsSupport::ATTR_SHOW 895 } 896 897 fn show(&self, _kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> { 898 sysfs_emit_str( 899 buf, 900 format!( 901 "0x{:x}\n", 902 VESAFB_FIX_INFO 903 .read() 904 .smem_start 905 .unwrap_or(PhysAddr::new(0)) 906 .data() 907 ) 908 .as_str(), 909 ) 910 } 911 } 912 913 #[unified_init(INITCALL_DEVICE)] 914 pub fn vesa_fb_driver_init() -> Result<(), SystemError> { 915 let driver = VesaFbDriver::new(); 916 917 platform_driver_manager().register(driver)?; 918 919 return Ok(()); 920 } 921 922 /// 在内存管理初始化之前,初始化vesafb 923 pub fn vesafb_early_init() -> Result<(), SystemError> { 924 let mut boot_params_guard = boot_params().write(); 925 boot_callbacks().early_init_framebuffer_info(&mut boot_params_guard.screen_info)?; 926 927 HAS_VESA_FB.store(true, core::sync::atomic::Ordering::SeqCst); 928 929 return Ok(()); 930 } 931 932 pub fn vesafb_early_map(paddr: PhysAddr, size: usize) -> Result<VirtAddr, SystemError> { 933 let (buf_vaddr, _) = EarlyIoRemap::map(paddr, size, false)?; 934 935 return Ok(buf_vaddr); 936 } 937 938 #[unified_init(INITCALL_DEVICE)] 939 fn vesa_fb_device_init() -> Result<(), SystemError> { 940 // 如果没有vesa帧缓冲区，直接返回 941 if !HAS_VESA_FB.load(core::sync::atomic::Ordering::SeqCst) { 942 return Ok(()); 943 } 944 945 static INIT: Once = Once::new(); 946 INIT.call_once(|| { 947 info!("vesa fb device init"); 948 let device = Arc::new(VesaFb::new()); 949 950 let mut fb_fix = VESAFB_FIX_INFO.write_irqsave(); 951 let mut fb_var = VESAFB_DEFINED.write_irqsave(); 952 953 let boot_params_guard = boot_params().read(); 954 let boottime_screen_info = &boot_params_guard.screen_info; 955 956 fb_fix.smem_start = Some(boottime_screen_info.lfb_base); 957 fb_fix.smem_len = boottime_screen_info.lfb_size; 958 959 if boottime_screen_info.video_type == BootTimeVideoType::Mda { 960 fb_fix.visual = FbVisual::Mono10; 961 fb_var.bits_per_pixel = 8; 962 fb_fix.line_length = 963 (boottime_screen_info.origin_video_cols as u32) * (fb_var.bits_per_pixel / 8); 964 fb_var.xres_virtual = boottime_screen_info.origin_video_cols as u32; 965 fb_var.yres_virtual = boottime_screen_info.origin_video_lines as u32; 966 } else { 967 fb_fix.visual = FbVisual::TrueColor; 968 fb_var.bits_per_pixel = boottime_screen_info.lfb_depth as u32; 969 fb_fix.line_length = 970 (boottime_screen_info.lfb_width as u32) * (fb_var.bits_per_pixel / 8); 971 fb_var.xres_virtual = boottime_screen_info.lfb_width as u32; 972 fb_var.yres_virtual = boottime_screen_info.lfb_height as u32; 973 fb_var.xres = boottime_screen_info.lfb_width as u32; 974 fb_var.yres = boottime_screen_info.lfb_height as u32; 975 } 976 977 fb_var.red.length = boottime_screen_info.red_size as u32; 978 fb_var.green.length = boottime_screen_info.green_size as u32; 979 fb_var.blue.length = boottime_screen_info.blue_size as u32; 980 981 fb_var.red.offset = boottime_screen_info.red_pos as u32; 982 fb_var.green.offset = boottime_screen_info.green_pos as u32; 983 fb_var.blue.offset = boottime_screen_info.blue_pos as u32; 984 985 // TODO: 这里是暂时这样写的，初始化为RGB888格式，后续vesa初始化完善后删掉下面 986 fb_var.red.offset = 16; 987 fb_var.green.offset = 8; 988 fb_var.blue.offset = 0; 989 990 if fb_var.bits_per_pixel >= 1 && fb_var.bits_per_pixel <= 8 { 991 fb_var.red.length = fb_var.bits_per_pixel; 992 fb_var.green.length = fb_var.bits_per_pixel; 993 fb_var.blue.length = fb_var.bits_per_pixel; 994 } 995 996 device_manager().device_default_initialize(&(device.clone() as Arc<dyn Device>)); 997 998 platform_device_manager() 999 .device_add(device.clone() as Arc<dyn PlatformDevice>) 1000 .expect("vesa_fb_device_init: platform_device_manager().device_add failed"); 1001 1002 frame_buffer_manager() 1003 .register_fb(device.clone() as Arc<dyn FrameBuffer>) 1004 .expect("vesa_fb_device_init: frame_buffer_manager().register_fb failed"); 1005 1006 // 加入全局fb表 1007 let mut guard = FRAME_BUFFER_SET.write(); 1008 if guard.get(device.fb_id().data() as usize).unwrap().is_some() { 1009 warn!( 1010 "vesa_fb_device_init: There is already an element {:?} in the FRAME_BUFFER_SET", 1011 device.fb_id() 1012 ); 1013 } 1014 guard[device.fb_id().data() as usize] = Some(device.clone()); 1015 1016 // 设置vesa fb的状态为运行中 1017 device.inner.lock().fb_state = FbState::Running; 1018 }); 1019 1020 return Ok(()); 1021 } 1022