1004e86ffSlogin use super::{_port, hba::HbaCmdTable, virt_2_phys}; 2004e86ffSlogin use crate::driver::disk::ahci::HBA_PxIS_TFES; 3004e86ffSlogin use crate::filesystem::mbr::MbrDiskPartionTable; 4004e86ffSlogin use crate::io::{device::BlockDevice, disk_info::Partition, SeekFrom}; 5004e86ffSlogin 6004e86ffSlogin use crate::libs::{spinlock::SpinLock, vec_cursor::VecCursor}; 7004e86ffSlogin use crate::mm::phys_2_virt; 8*676b8ef6SMork use crate::syscall::SystemError; 9004e86ffSlogin use crate::{ 10004e86ffSlogin driver::disk::ahci::hba::{ 11004e86ffSlogin FisRegH2D, FisType, HbaCmdHeader, ATA_CMD_READ_DMA_EXT, ATA_CMD_WRITE_DMA_EXT, 12004e86ffSlogin ATA_DEV_BUSY, ATA_DEV_DRQ, 13004e86ffSlogin }, 14004e86ffSlogin kerror, 15004e86ffSlogin }; 16004e86ffSlogin 17004e86ffSlogin use alloc::sync::Weak; 18004e86ffSlogin use alloc::{string::String, sync::Arc, vec::Vec}; 19004e86ffSlogin 20004e86ffSlogin use core::fmt::Debug; 21004e86ffSlogin use core::sync::atomic::compiler_fence; 22004e86ffSlogin use core::{mem::size_of, ptr::write_bytes}; 23004e86ffSlogin 24004e86ffSlogin /// @brief: 只支持MBR分区格式的磁盘结构体 25004e86ffSlogin pub struct AhciDisk { 26004e86ffSlogin pub name: String, 27004e86ffSlogin pub flags: u16, // 磁盘的状态flags 28004e86ffSlogin pub partitions: Vec<Arc<Partition>>, // 磁盘分区数组 29004e86ffSlogin // port: &'static mut HbaPort, // 控制硬盘的端口 30004e86ffSlogin pub ctrl_num: u8, 31004e86ffSlogin pub port_num: u8, 32004e86ffSlogin /// 指向LockAhciDisk的弱引用 33004e86ffSlogin self_ref: Weak<LockedAhciDisk>, 34004e86ffSlogin } 35004e86ffSlogin 36004e86ffSlogin /// @brief: 带锁的AhciDisk 37004e86ffSlogin #[derive(Debug)] 38004e86ffSlogin pub struct LockedAhciDisk(pub SpinLock<AhciDisk>); 39004e86ffSlogin /// 函数实现 40004e86ffSlogin impl Debug for AhciDisk { 41004e86ffSlogin fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 42004e86ffSlogin write!( 43004e86ffSlogin f, 44004e86ffSlogin "{{ name: {}, flags: {}, part_s: {:?} }}", 45004e86ffSlogin self.name, self.flags, self.partitions 46004e86ffSlogin )?; 47004e86ffSlogin return Ok(()); 48004e86ffSlogin } 49004e86ffSlogin } 50004e86ffSlogin 51004e86ffSlogin impl AhciDisk { 52004e86ffSlogin fn read_at( 53004e86ffSlogin &self, 54004e86ffSlogin lba_id_start: crate::io::device::BlockId, // 起始lba编号 55004e86ffSlogin count: usize, // 读取lba的数量 56004e86ffSlogin buf: &mut [u8], 57*676b8ef6SMork ) -> Result<usize, SystemError> { 58004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 59004e86ffSlogin let check_length = ((count - 1) >> 4) + 1; // prdt length 60004e86ffSlogin if count * 512 > buf.len() || check_length > u16::MAX as usize { 61004e86ffSlogin kerror!("ahci read: e2big"); 62004e86ffSlogin // 不可能的操作 63*676b8ef6SMork return Err(SystemError::E2BIG); 64004e86ffSlogin } else if count == 0 { 65004e86ffSlogin return Ok(0); 66004e86ffSlogin } 67004e86ffSlogin 68004e86ffSlogin let port = _port(self.ctrl_num, self.port_num); 69004e86ffSlogin volatile_write!(port.is, u32::MAX); // Clear pending interrupt bits 70004e86ffSlogin 71004e86ffSlogin let slot = port.find_cmdslot().unwrap_or(u32::MAX); 72004e86ffSlogin 73004e86ffSlogin if slot == u32::MAX { 74*676b8ef6SMork return Err(SystemError::EIO); 75004e86ffSlogin } 76004e86ffSlogin 77004e86ffSlogin #[allow(unused_unsafe)] 78004e86ffSlogin let cmdheader: &mut HbaCmdHeader = unsafe { 79004e86ffSlogin (phys_2_virt( 80004e86ffSlogin volatile_read!(port.clb) as usize 81004e86ffSlogin + slot as usize * size_of::<HbaCmdHeader>() as usize, 82004e86ffSlogin ) as *mut HbaCmdHeader) 83004e86ffSlogin .as_mut() 84004e86ffSlogin .unwrap() 85004e86ffSlogin }; 86004e86ffSlogin 87004e86ffSlogin volatile_write_bit!( 88004e86ffSlogin cmdheader.cfl, 89004e86ffSlogin (1 << 5) - 1 as u8, 90004e86ffSlogin (size_of::<FisRegH2D>() / size_of::<u32>()) as u8 91004e86ffSlogin ); // Command FIS size 92004e86ffSlogin 93004e86ffSlogin volatile_set_bit!(cmdheader.cfl, 1 << 6, false); // Read/Write bit : Read from device 94004e86ffSlogin volatile_write!(cmdheader.prdtl, check_length as u16); // PRDT entries count 95004e86ffSlogin 96004e86ffSlogin // 设置数据存放地址 97004e86ffSlogin let mut buf_ptr = buf as *mut [u8] as *mut usize as usize; 98004e86ffSlogin #[allow(unused_unsafe)] 99004e86ffSlogin let cmdtbl = unsafe { 100004e86ffSlogin (phys_2_virt(volatile_read!(cmdheader.ctba) as usize) as *mut HbaCmdTable) 101004e86ffSlogin .as_mut() 102004e86ffSlogin .unwrap() // 必须使用 as_mut ,得到的才是原来的变量 103004e86ffSlogin }; 104004e86ffSlogin let mut tmp_count = count; 105004e86ffSlogin 106004e86ffSlogin unsafe { 107004e86ffSlogin // 清空整个table的旧数据 108004e86ffSlogin write_bytes(cmdtbl, 0, 1); 109004e86ffSlogin } 110004e86ffSlogin 111004e86ffSlogin // 8K bytes (16 sectors) per PRDT 112004e86ffSlogin for i in 0..((volatile_read!(cmdheader.prdtl) - 1) as usize) { 113004e86ffSlogin volatile_write!(cmdtbl.prdt_entry[i].dba, virt_2_phys(buf_ptr) as u64); 114004e86ffSlogin volatile_write_bit!(cmdtbl.prdt_entry[i].dbc, (1 << 22) - 1, 8 * 1024 - 1); // 数据长度 prdt_entry.dbc 115004e86ffSlogin volatile_set_bit!(cmdtbl.prdt_entry[i].dbc, 1 << 31, true); // 允许中断 prdt_entry.i 116004e86ffSlogin buf_ptr += 8 * 1024; 117004e86ffSlogin tmp_count -= 16; 118004e86ffSlogin } 119004e86ffSlogin 120004e86ffSlogin // Last entry 121004e86ffSlogin let las = (volatile_read!(cmdheader.prdtl) - 1) as usize; 122004e86ffSlogin volatile_write!(cmdtbl.prdt_entry[las].dba, virt_2_phys(buf_ptr) as u64); 123004e86ffSlogin volatile_write_bit!( 124004e86ffSlogin cmdtbl.prdt_entry[las].dbc, 125004e86ffSlogin (1 << 22) - 1, 126004e86ffSlogin ((tmp_count << 9) - 1) as u32 127004e86ffSlogin ); // 数据长度 128004e86ffSlogin volatile_set_bit!(cmdtbl.prdt_entry[las].dbc, 1 << 31, true); // 允许中断 129004e86ffSlogin 130004e86ffSlogin // 设置命令 131004e86ffSlogin let cmdfis = unsafe { 132004e86ffSlogin ((&mut cmdtbl.cfis) as *mut [u8] as *mut usize as *mut FisRegH2D) 133004e86ffSlogin .as_mut() 134004e86ffSlogin .unwrap() 135004e86ffSlogin }; 136004e86ffSlogin volatile_write!(cmdfis.fis_type, FisType::RegH2D as u8); 137004e86ffSlogin volatile_set_bit!(cmdfis.pm, 1 << 7, true); // command_bit set 138004e86ffSlogin volatile_write!(cmdfis.command, ATA_CMD_READ_DMA_EXT); 139004e86ffSlogin 140004e86ffSlogin volatile_write!(cmdfis.lba0, (lba_id_start & 0xFF) as u8); 141004e86ffSlogin volatile_write!(cmdfis.lba1, ((lba_id_start >> 8) & 0xFF) as u8); 142004e86ffSlogin volatile_write!(cmdfis.lba2, ((lba_id_start >> 16) & 0xFF) as u8); 143004e86ffSlogin volatile_write!(cmdfis.lba3, ((lba_id_start >> 24) & 0xFF) as u8); 144004e86ffSlogin volatile_write!(cmdfis.lba4, ((lba_id_start >> 32) & 0xFF) as u8); 145004e86ffSlogin volatile_write!(cmdfis.lba5, ((lba_id_start >> 40) & 0xFF) as u8); 146004e86ffSlogin 147004e86ffSlogin volatile_write!(cmdfis.countl, (count & 0xFF) as u8); 148004e86ffSlogin volatile_write!(cmdfis.counth, ((count >> 8) & 0xFF) as u8); 149004e86ffSlogin 150004e86ffSlogin volatile_write!(cmdfis.device, 1 << 6); // LBA Mode 151004e86ffSlogin 152004e86ffSlogin // 等待之前的操作完成 153004e86ffSlogin let mut spin_count = 0; 154004e86ffSlogin const SPIN_LIMIT: u32 = 10000; 155004e86ffSlogin 156004e86ffSlogin while (volatile_read!(port.tfd) as u8 & (ATA_DEV_BUSY | ATA_DEV_DRQ)) > 0 157004e86ffSlogin && spin_count < SPIN_LIMIT 158004e86ffSlogin { 159004e86ffSlogin spin_count += 1; 160004e86ffSlogin } 161004e86ffSlogin 162004e86ffSlogin if spin_count == SPIN_LIMIT { 163004e86ffSlogin kerror!("Port is hung"); 164*676b8ef6SMork return Err(SystemError::EIO); 165004e86ffSlogin } 166004e86ffSlogin 167004e86ffSlogin volatile_set_bit!(port.ci, 1 << slot, true); // Issue command 168004e86ffSlogin // kdebug!("To wait ahci read complete."); 169004e86ffSlogin // 等待操作完成 170004e86ffSlogin loop { 171004e86ffSlogin if (volatile_read!(port.ci) & (1 << slot)) == 0 { 172004e86ffSlogin break; 173004e86ffSlogin } 174004e86ffSlogin if (volatile_read!(port.is) & HBA_PxIS_TFES) > 0 { 175004e86ffSlogin kerror!("Read disk error"); 176*676b8ef6SMork return Err(SystemError::EIO); 177004e86ffSlogin } 178004e86ffSlogin } 179004e86ffSlogin 180004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 181004e86ffSlogin // successfully read 182004e86ffSlogin return Ok(count * 512); 183004e86ffSlogin } 184004e86ffSlogin 185004e86ffSlogin fn write_at( 186004e86ffSlogin &self, 187004e86ffSlogin lba_id_start: crate::io::device::BlockId, 188004e86ffSlogin count: usize, 189004e86ffSlogin buf: &[u8], 190*676b8ef6SMork ) -> Result<usize, SystemError> { 191004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 192004e86ffSlogin let check_length = ((count - 1) >> 4) + 1; // prdt length 193004e86ffSlogin if count * 512 > buf.len() || check_length > u16::MAX as usize { 194004e86ffSlogin // 不可能的操作 195*676b8ef6SMork return Err(SystemError::E2BIG); 196004e86ffSlogin } else if count == 0 { 197004e86ffSlogin return Ok(0); 198004e86ffSlogin } 199004e86ffSlogin 200004e86ffSlogin let port = _port(self.ctrl_num, self.port_num); 201004e86ffSlogin 202004e86ffSlogin volatile_write!(port.is, u32::MAX); // Clear pending interrupt bits 203004e86ffSlogin 204004e86ffSlogin let slot = port.find_cmdslot().unwrap_or(u32::MAX); 205004e86ffSlogin 206004e86ffSlogin if slot == u32::MAX { 207*676b8ef6SMork return Err(SystemError::EIO); 208004e86ffSlogin } 209004e86ffSlogin 210004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 211004e86ffSlogin #[allow(unused_unsafe)] 212004e86ffSlogin let cmdheader: &mut HbaCmdHeader = unsafe { 213004e86ffSlogin (phys_2_virt( 214004e86ffSlogin volatile_read!(port.clb) as usize 215004e86ffSlogin + slot as usize * size_of::<HbaCmdHeader>() as usize, 216004e86ffSlogin ) as *mut HbaCmdHeader) 217004e86ffSlogin .as_mut() 218004e86ffSlogin .unwrap() 219004e86ffSlogin }; 220004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 221004e86ffSlogin 222004e86ffSlogin volatile_write_bit!( 223004e86ffSlogin cmdheader.cfl, 224004e86ffSlogin (1 << 5) - 1 as u8, 225004e86ffSlogin (size_of::<FisRegH2D>() / size_of::<u32>()) as u8 226004e86ffSlogin ); // Command FIS size 227004e86ffSlogin 228004e86ffSlogin volatile_set_bit!(cmdheader.cfl, 7 << 5, true); // (p,c,w)都设置为1, Read/Write bit : Write from device 229004e86ffSlogin volatile_write!(cmdheader.prdtl, check_length as u16); // PRDT entries count 230004e86ffSlogin 231004e86ffSlogin // 设置数据存放地址 232004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 233004e86ffSlogin let mut buf_ptr = buf as *const [u8] as *mut usize as usize; 234004e86ffSlogin #[allow(unused_unsafe)] 235004e86ffSlogin let cmdtbl = unsafe { 236004e86ffSlogin (phys_2_virt(volatile_read!(cmdheader.ctba) as usize) as *mut HbaCmdTable) 237004e86ffSlogin .as_mut() 238004e86ffSlogin .unwrap() 239004e86ffSlogin }; 240004e86ffSlogin let mut tmp_count = count; 241004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 242004e86ffSlogin 243004e86ffSlogin unsafe { 244004e86ffSlogin // 清空整个table的旧数据 245004e86ffSlogin write_bytes(cmdtbl, 0, 1); 246004e86ffSlogin } 247004e86ffSlogin 248004e86ffSlogin // 8K bytes (16 sectors) per PRDT 249004e86ffSlogin for i in 0..((volatile_read!(cmdheader.prdtl) - 1) as usize) { 250004e86ffSlogin volatile_write!(cmdtbl.prdt_entry[i].dba, virt_2_phys(buf_ptr) as u64); 251004e86ffSlogin volatile_write_bit!(cmdtbl.prdt_entry[i].dbc, (1 << 22) - 1, 8 * 1024 - 1); // 数据长度 252004e86ffSlogin volatile_set_bit!(cmdtbl.prdt_entry[i].dbc, 1 << 31, true); // 允许中断 253004e86ffSlogin buf_ptr += 8 * 1024; 254004e86ffSlogin tmp_count -= 16; 255004e86ffSlogin } 256004e86ffSlogin 257004e86ffSlogin // Last entry 258004e86ffSlogin let las = (volatile_read!(cmdheader.prdtl) - 1) as usize; 259004e86ffSlogin volatile_write!(cmdtbl.prdt_entry[las].dba, virt_2_phys(buf_ptr) as u64); 260004e86ffSlogin volatile_set_bit!(cmdtbl.prdt_entry[las].dbc, 1 << 31, true); // 允许中断 261004e86ffSlogin volatile_write_bit!( 262004e86ffSlogin cmdtbl.prdt_entry[las].dbc, 263004e86ffSlogin (1 << 22) - 1, 264004e86ffSlogin ((tmp_count << 9) - 1) as u32 265004e86ffSlogin ); // 数据长度 266004e86ffSlogin 267004e86ffSlogin // 设置命令 268004e86ffSlogin let cmdfis = unsafe { 269004e86ffSlogin ((&mut cmdtbl.cfis) as *mut [u8] as *mut usize as *mut FisRegH2D) 270004e86ffSlogin .as_mut() 271004e86ffSlogin .unwrap() 272004e86ffSlogin }; 273004e86ffSlogin volatile_write!(cmdfis.fis_type, FisType::RegH2D as u8); 274004e86ffSlogin volatile_set_bit!(cmdfis.pm, 1 << 7, true); // command_bit set 275004e86ffSlogin volatile_write!(cmdfis.command, ATA_CMD_WRITE_DMA_EXT); 276004e86ffSlogin 277004e86ffSlogin volatile_write!(cmdfis.lba0, (lba_id_start & 0xFF) as u8); 278004e86ffSlogin volatile_write!(cmdfis.lba1, ((lba_id_start >> 8) & 0xFF) as u8); 279004e86ffSlogin volatile_write!(cmdfis.lba2, ((lba_id_start >> 16) & 0xFF) as u8); 280004e86ffSlogin volatile_write!(cmdfis.lba3, ((lba_id_start >> 24) & 0xFF) as u8); 281004e86ffSlogin volatile_write!(cmdfis.lba4, ((lba_id_start >> 32) & 0xFF) as u8); 282004e86ffSlogin volatile_write!(cmdfis.lba5, ((lba_id_start >> 40) & 0xFF) as u8); 283004e86ffSlogin 284004e86ffSlogin volatile_write!(cmdfis.countl, (count & 0xFF) as u8); 285004e86ffSlogin volatile_write!(cmdfis.counth, ((count >> 8) & 0xFF) as u8); 286004e86ffSlogin 287004e86ffSlogin volatile_write!(cmdfis.device, 1 << 6); // LBA Mode 288004e86ffSlogin 289004e86ffSlogin volatile_set_bit!(port.ci, 1 << slot, true); // Issue command 290004e86ffSlogin 291004e86ffSlogin // 等待操作完成 292004e86ffSlogin loop { 293004e86ffSlogin if (volatile_read!(port.ci) & (1 << slot)) == 0 { 294004e86ffSlogin break; 295004e86ffSlogin } 296004e86ffSlogin if (volatile_read!(port.is) & HBA_PxIS_TFES) > 0 { 297004e86ffSlogin kerror!("Write disk error"); 298*676b8ef6SMork return Err(SystemError::EIO); 299004e86ffSlogin } 300004e86ffSlogin } 301004e86ffSlogin 302004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 303004e86ffSlogin // successfully read 304004e86ffSlogin return Ok(count * 512); 305004e86ffSlogin } 306004e86ffSlogin 307*676b8ef6SMork fn sync(&self) -> Result<(), SystemError> { 308004e86ffSlogin // 由于目前没有block cache, 因此sync返回成功即可 309004e86ffSlogin return Ok(()); 310004e86ffSlogin } 311004e86ffSlogin } 312004e86ffSlogin 313004e86ffSlogin impl LockedAhciDisk { 314004e86ffSlogin pub fn new( 315004e86ffSlogin name: String, 316004e86ffSlogin flags: u16, 317004e86ffSlogin ctrl_num: u8, 318004e86ffSlogin port_num: u8, 319*676b8ef6SMork ) -> Result<Arc<LockedAhciDisk>, SystemError> { 320004e86ffSlogin let mut part_s: Vec<Arc<Partition>> = Vec::new(); 321004e86ffSlogin 322004e86ffSlogin // 构建磁盘结构体 323004e86ffSlogin let result: Arc<LockedAhciDisk> = Arc::new(LockedAhciDisk(SpinLock::new(AhciDisk { 324004e86ffSlogin name, 325004e86ffSlogin flags, 326004e86ffSlogin partitions: Default::default(), 327004e86ffSlogin ctrl_num, 328004e86ffSlogin port_num, 329004e86ffSlogin self_ref: Weak::default(), 330004e86ffSlogin }))); 331004e86ffSlogin 332004e86ffSlogin let table: MbrDiskPartionTable = result.read_mbr_table()?; 333004e86ffSlogin let weak_this: Weak<LockedAhciDisk> = Arc::downgrade(&result); // 获取this的弱指针 334004e86ffSlogin 335004e86ffSlogin // 求出有多少可用分区 336004e86ffSlogin for i in 0..4 { 337004e86ffSlogin if table.dpte[i].part_type != 0 { 338004e86ffSlogin part_s.push(Partition::new( 339004e86ffSlogin table.dpte[i].starting_sector() as u64, 340004e86ffSlogin table.dpte[i].starting_lba as u64, 341004e86ffSlogin table.dpte[i].total_sectors as u64, 342004e86ffSlogin weak_this.clone(), 343004e86ffSlogin i as u16, 344004e86ffSlogin )); 345004e86ffSlogin } 346004e86ffSlogin } 347004e86ffSlogin 348004e86ffSlogin result.0.lock().partitions = part_s; 349004e86ffSlogin result.0.lock().self_ref = weak_this; 350004e86ffSlogin return Ok(result); 351004e86ffSlogin } 352004e86ffSlogin 353004e86ffSlogin /// @brief: 从磁盘中读取 MBR 分区表结构体 TODO: Cursor 354*676b8ef6SMork pub fn read_mbr_table(&self) -> Result<MbrDiskPartionTable, SystemError> { 355004e86ffSlogin let mut table: MbrDiskPartionTable = Default::default(); 356004e86ffSlogin 357004e86ffSlogin // 数据缓冲区 358004e86ffSlogin let mut buf: Vec<u8> = Vec::new(); 359004e86ffSlogin buf.resize(size_of::<MbrDiskPartionTable>(), 0); 360004e86ffSlogin 361004e86ffSlogin self.read_at(0, 1, &mut buf)?; 362004e86ffSlogin 363004e86ffSlogin // 创建 Cursor 用于按字节读取 364004e86ffSlogin let mut cursor = VecCursor::new(buf); 365004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(446))?; 366004e86ffSlogin 367004e86ffSlogin for i in 0..4 { 368004e86ffSlogin // kdebug!("infomation of partition {}:\n", i); 369004e86ffSlogin 370004e86ffSlogin table.dpte[i].flags = cursor.read_u8()?; 371004e86ffSlogin table.dpte[i].starting_head = cursor.read_u8()?; 372004e86ffSlogin table.dpte[i].starting_sector_cylinder = cursor.read_u16()?; 373004e86ffSlogin table.dpte[i].part_type = cursor.read_u8()?; 374004e86ffSlogin table.dpte[i].ending_head = cursor.read_u8()?; 375004e86ffSlogin table.dpte[i].ending_sector_cylingder = cursor.read_u16()?; 376004e86ffSlogin table.dpte[i].starting_lba = cursor.read_u32()?; 377004e86ffSlogin table.dpte[i].total_sectors = cursor.read_u32()?; 378004e86ffSlogin 379004e86ffSlogin // kdebug!("dpte[i] = {:?}", table.dpte[i]); 380004e86ffSlogin } 381004e86ffSlogin table.bs_trailsig = cursor.read_u16()?; 382004e86ffSlogin // kdebug!("bs_trailsig = {}", unsafe { 383004e86ffSlogin // read_unaligned(addr_of!(table.bs_trailsig)) 384004e86ffSlogin // }); 385004e86ffSlogin 386004e86ffSlogin return Ok(table); 387004e86ffSlogin } 388004e86ffSlogin } 389004e86ffSlogin 390004e86ffSlogin impl BlockDevice for LockedAhciDisk { 391004e86ffSlogin #[inline] 392004e86ffSlogin fn as_any_ref(&self) -> &dyn core::any::Any { 393004e86ffSlogin self 394004e86ffSlogin } 395004e86ffSlogin 396004e86ffSlogin #[inline] 397004e86ffSlogin fn blk_size_log2(&self) -> u8 { 398004e86ffSlogin 9 399004e86ffSlogin } 400004e86ffSlogin 401004e86ffSlogin #[inline] 402004e86ffSlogin fn read_at( 403004e86ffSlogin &self, 404004e86ffSlogin lba_id_start: crate::io::device::BlockId, 405004e86ffSlogin count: usize, 406004e86ffSlogin buf: &mut [u8], 407*676b8ef6SMork ) -> Result<usize, SystemError> { 408004e86ffSlogin // kdebug!( 409004e86ffSlogin // "ahci read at {lba_id_start}, count={count}, lock={:?}", 410004e86ffSlogin // self.0 411004e86ffSlogin // ); 412004e86ffSlogin return self.0.lock().read_at(lba_id_start, count, buf); 413004e86ffSlogin } 414004e86ffSlogin 415004e86ffSlogin #[inline] 416004e86ffSlogin fn write_at( 417004e86ffSlogin &self, 418004e86ffSlogin lba_id_start: crate::io::device::BlockId, 419004e86ffSlogin count: usize, 420004e86ffSlogin buf: &[u8], 421*676b8ef6SMork ) -> Result<usize, SystemError> { 422004e86ffSlogin self.0.lock().write_at(lba_id_start, count, buf) 423004e86ffSlogin } 424004e86ffSlogin 425*676b8ef6SMork fn sync(&self) -> Result<(), SystemError> { 426004e86ffSlogin return self.0.lock().sync(); 427004e86ffSlogin } 428004e86ffSlogin 429004e86ffSlogin #[inline] 430004e86ffSlogin fn device(&self) -> Arc<dyn crate::io::device::Device> { 431004e86ffSlogin return self.0.lock().self_ref.upgrade().unwrap(); 432004e86ffSlogin } 433004e86ffSlogin 434004e86ffSlogin fn block_size(&self) -> usize { 435004e86ffSlogin todo!() 436004e86ffSlogin } 437004e86ffSlogin 438004e86ffSlogin fn partitions(&self) -> Vec<Arc<Partition>> { 439004e86ffSlogin return self.0.lock().partitions.clone(); 440004e86ffSlogin } 441004e86ffSlogin } 442