1 // 参考手册: PCIe* GbE Controllers Open Source Software Developer’s Manual 2 // Refernce: PCIe* GbE Controllers Open Source Software Developer’s Manual 3 4 use alloc::vec::Vec; 5 use core::intrinsics::unlikely; 6 use core::mem::size_of; 7 use core::ptr::NonNull; 8 use core::slice::{from_raw_parts, from_raw_parts_mut}; 9 use core::sync::atomic::{compiler_fence, Ordering}; 10 11 use super::e1000e_driver::e1000e_driver_init; 12 use crate::driver::net::dma::{dma_alloc, dma_dealloc}; 13 use crate::driver::pci::pci::{ 14 get_pci_device_structure_mut, PciDeviceStructure, PciDeviceStructureGeneralDevice, PciError, 15 PCI_DEVICE_LINKEDLIST, 16 }; 17 use crate::driver::pci::pci_irq::{IrqCommonMsg, IrqMsg, IrqSpecificMsg, PciInterrupt, IRQ}; 18 use crate::include::bindings::bindings::pt_regs; 19 use crate::libs::volatile::{ReadOnly, Volatile, WriteOnly}; 20 use crate::net::net_core::poll_ifaces_try_lock_onetime; 21 use crate::{kdebug, kinfo}; 22 23 const PAGE_SIZE: usize = 4096; 24 const NETWORK_CLASS: u8 = 0x2; 25 const ETHERNET_SUBCLASS: u8 = 0x0; 26 // e1000e系列网卡的device id列表，来源：https://admin.pci-ids.ucw.cz/read/PC/8086 27 const E1000E_DEVICE_ID: [u16; 14] = [ 28 0x10d3, // 8574L, qemu default 29 0x10cc, // 82567LM-2 30 0x10cd, // 82567LF-2 31 0x105f, // 82571EB 32 0x1060, // 82571EB 33 0x107f, // 82572EI 34 0x109a, // 82573L 35 0x10ea, // 82577LM 36 0x10eb, // 82577LC 37 0x10ef, // 82578DM 38 0x10f0, // 82578DC 39 0x1502, // 82579LM 40 0x1503, // 82579V 41 0x150c, // 82583V 42 ]; 43 44 // e1000e网卡与BAR有关的常量 45 // BAR0空间大小(128KB) 46 const E1000E_BAR_REG_SIZE: u32 = 128 * 1024; 47 // BAR0空间对齐(64bit) 48 #[allow(dead_code)] 49 const E1000E_BAR_REG_ALIGN: u8 = 64; 50 // 单个寄存器大小(32bit, 4字节) 51 #[allow(dead_code)] 52 const E1000E_REG_SIZE: u8 = 4; 53 54 // TxBuffer和RxBuffer的大小(DMA页) 55 const E1000E_DMA_PAGES: usize = 1; 56 57 // 中断相关 58 const E1000E_RECV_VECTOR: u16 = 57; 59 60 // napi队列中暂时存储的buffer个数 61 const E1000E_RECV_NAPI: usize = 1024; 62 63 // 收/发包的描述符结构 pp.24 Table 3-1 64 #[repr(C)] 65 #[derive(Copy, Clone, Debug)] 66 struct E1000ETransDesc { 67 addr: u64, 68 len: u16, 69 cso: u8, 70 cmd: u8, 71 status: u8, 72 css: u8, 73 special: u8, 74 } 75 // pp.54 Table 3-12 76 #[repr(C)] 77 #[derive(Copy, Clone, Debug)] 78 struct E1000ERecvDesc { 79 addr: u64, 80 len: u16, 81 chksum: u16, 82 status: u16, 83 error: u8, 84 special: u8, 85 } 86 #[derive(Copy, Clone)] 87 // Buffer的Copy只是指针操作，不涉及实际数据的复制，因此要小心使用，确保不同的buffer不会使用同一块内存 88 pub struct E1000EBuffer { 89 buffer: NonNull<u8>, 90 paddr: usize, 91 // length字段为0则表示这个buffer是一个占位符，不指向实际内存 92 // the buffer is empty and no page is allocated if length field is set 0 93 length: usize, 94 } 95 96 impl E1000EBuffer { 97 pub fn new(length: usize) -> Self { 98 assert!(length <= PAGE_SIZE); 99 if unlikely(length == 0) { 100 // 在某些情况下，我们并不需要实际分配buffer，只需要提供一个占位符即可 101 // we dont need to allocate dma pages for buffer in some cases 102 E1000EBuffer { 103 buffer: NonNull::dangling(), 104 paddr: 0, 105 length: 0, 106 } 107 } else { 108 let (paddr, vaddr) = dma_alloc(E1000E_DMA_PAGES); 109 E1000EBuffer { 110 buffer: vaddr, 111 paddr, 112 length, 113 } 114 } 115 } 116 117 #[allow(dead_code)] 118 pub fn as_addr(&self) -> NonNull<u8> { 119 assert!(self.length != 0); 120 return self.buffer; 121 } 122 123 #[allow(dead_code)] 124 pub fn as_addr_u64(&self) -> u64 { 125 assert!(self.length != 0); 126 return self.buffer.as_ptr() as u64; 127 } 128 129 pub fn as_paddr(&self) -> usize { 130 assert!(self.length != 0); 131 return self.paddr; 132 } 133 134 #[allow(dead_code)] 135 pub fn as_slice(&self) -> &[u8] { 136 assert!(self.length != 0); 137 return unsafe { from_raw_parts(self.buffer.as_ptr(), self.length) }; 138 } 139 140 pub fn as_mut_slice(&mut self) -> &mut [u8] { 141 assert!(self.length != 0); 142 return unsafe { from_raw_parts_mut(self.buffer.as_ptr(), self.length) }; 143 } 144 145 pub fn set_length(&mut self, length: usize) { 146 self.length = length; 147 } 148 149 pub fn len(&self) -> usize { 150 return self.length; 151 } 152 // 释放buffer内部的dma_pages，需要小心使用 153 pub fn free_buffer(self) -> () { 154 if self.length != 0 { 155 unsafe { dma_dealloc(self.paddr, self.buffer, E1000E_DMA_PAGES) }; 156 } 157 } 158 } 159 160 // 中断处理函数, 调用协议栈的poll函数，未来可能会用napi来替换这里 161 // Interrupt handler 162 unsafe extern "C" fn e1000e_irq_handler(_irq_num: u64, _irq_paramer: u64, _regs: *mut pt_regs) { 163 poll_ifaces_try_lock_onetime().ok(); 164 } 165 166 #[allow(dead_code)] 167 pub struct E1000EDevice { 168 // 设备寄存器 169 // device registers 170 general_regs: NonNull<GeneralRegs>, 171 interrupt_regs: NonNull<InterruptRegs>, 172 rctl_regs: NonNull<ReceiveCtrlRegs>, 173 receive_regs: NonNull<ReceiveRegs>, 174 tctl_regs: NonNull<TransmitCtrlRegs>, 175 transimit_regs: NonNull<TransimitRegs>, 176 pcie_regs: NonNull<PCIeRegs>, 177 178 // descriptor环形队列，在操作系统与设备之间共享 179 // descriptor rings are shared between os and device 180 recv_desc_ring: &'static mut [E1000ERecvDesc], 181 trans_desc_ring: &'static mut [E1000ETransDesc], 182 recv_ring_pa: usize, 183 trans_ring_pa: usize, 184 185 // 设备收/发包缓冲区数组 186 // buffers of receive/transmit packets 187 recv_buffers: Vec<E1000EBuffer>, 188 trans_buffers: Vec<E1000EBuffer>, 189 mac: [u8; 6], 190 first_trans: bool, 191 // napi队列，用于存放在中断关闭期间通过轮询收取的buffer 192 // the napi queue is designed to save buffer/packet when the interrupt is close 193 // NOTE: this feature is not completely implemented and not used in the current version 194 napi_buffers: Vec<E1000EBuffer>, 195 napi_buffer_head: usize, 196 napi_buffer_tail: usize, 197 napi_buffer_empty: bool, 198 } 199 200 impl E1000EDevice { 201 // 从PCI标准设备进行驱动初始化 202 // init the device for PCI standard device struct 203 #[allow(unused_assignments)] 204 pub fn new(device: &mut PciDeviceStructureGeneralDevice) -> Result<Self, E1000EPciError> { 205 // 从BAR0获取我们需要的寄存器 206 // Build registers sturcts from BAR0 207 device.bar_ioremap().unwrap()?; 208 device.enable_master(); 209 let bar = device.bar().ok_or(E1000EPciError::BarGetFailed)?; 210 let bar0 = bar.get_bar(0)?; 211 let (address, size) = bar0 212 .memory_address_size() 213 .ok_or(E1000EPciError::UnexpectedBarType)?; 214 if address == 0 { 215 return Err(E1000EPciError::BarNotAllocated); 216 } 217 if size != E1000E_BAR_REG_SIZE { 218 return Err(E1000EPciError::UnexpectedBarSize); 219 } 220 let vaddress = bar0 221 .virtual_address() 222 .ok_or(E1000EPciError::BarGetVaddrFailed)? 223 .data() as u64; 224 225 // 初始化msi中断 226 // initialize msi interupt 227 let irq_vector = device.irq_vector_mut().unwrap(); 228 irq_vector.push(E1000E_RECV_VECTOR); 229 device.irq_init(IRQ::PCI_IRQ_MSI).expect("IRQ Init Failed"); 230 let msg = IrqMsg { 231 irq_common_message: IrqCommonMsg::init_from( 232 0, 233 "E1000E_RECV_IRQ", 234 0, 235 e1000e_irq_handler, 236 None, 237 ), 238 irq_specific_message: IrqSpecificMsg::msi_default(), 239 }; 240 device.irq_install(msg)?; 241 device.irq_enable(true)?; 242 243 let general_regs: NonNull<GeneralRegs> = 244 get_register_ptr(vaddress, E1000E_GENERAL_REGS_OFFSET); 245 let interrupt_regs: NonNull<InterruptRegs> = 246 get_register_ptr(vaddress, E1000E_INTERRRUPT_REGS_OFFSET); 247 let rctl_regs: NonNull<ReceiveCtrlRegs> = 248 get_register_ptr(vaddress, E1000E_RECEIVE_CTRL_REG_OFFSET); 249 let receive_regs: NonNull<ReceiveRegs> = 250 get_register_ptr(vaddress, E1000E_RECEIVE_REGS_OFFSET); 251 let tctl_regs: NonNull<TransmitCtrlRegs> = 252 get_register_ptr(vaddress, E1000E_TRANSMIT_CTRL_REG_OFFSET); 253 let transimit_regs: NonNull<TransimitRegs> = 254 get_register_ptr(vaddress, E1000E_TRANSMIT_REGS_OFFSET); 255 let pcie_regs: NonNull<PCIeRegs> = get_register_ptr(vaddress, E1000E_PCIE_REGS_OFFSET); 256 let ra_regs: NonNull<ReceiveAddressRegs> = 257 get_register_ptr(vaddress, E1000E_RECEIVE_ADDRESS_REGS_OFFSET); 258 // 开始设备初始化 14.3 259 // Initialization Sequence 260 unsafe { 261 let mut ctrl = volread!(general_regs, ctrl); 262 // 关闭中断 263 // close the interrupt 264 volwrite!(interrupt_regs, imc, E1000E_IMC_CLEAR); 265 //SW RESET 266 volwrite!(general_regs, ctrl, ctrl | E1000E_CTRL_RST); 267 compiler_fence(Ordering::AcqRel); 268 // PHY RESET 269 ctrl = volread!(general_regs, ctrl); 270 volwrite!(general_regs, ctrl, ctrl | E1000E_CTRL_PHY_RST); 271 volwrite!(general_regs, ctrl, ctrl); 272 // 关闭中断 273 // close the interrupt 274 volwrite!(interrupt_regs, imc, E1000E_IMC_CLEAR); 275 let mut gcr = volread!(pcie_regs, gcr); 276 gcr = gcr | (1 << 22); 277 volwrite!(pcie_regs, gcr, gcr); 278 compiler_fence(Ordering::AcqRel); 279 // PHY Initialization 14.8.1 280 // MAC/PHY Link Setup 14.8.2 281 ctrl = volread!(general_regs, ctrl); 282 ctrl &= !(E1000E_CTRL_FRCSPD | E1000E_CTRL_FRCDPLX); 283 volwrite!(general_regs, ctrl, ctrl | E1000E_CTRL_SLU); 284 } 285 let status = unsafe { volread!(general_regs, status) }; 286 kdebug!("Status: {status:#X}"); 287 288 // 读取设备的mac地址 289 // Read mac address 290 let ral = unsafe { volread!(ra_regs, ral0) }; 291 let rah = unsafe { volread!(ra_regs, rah0) }; 292 let mac: [u8; 6] = [ 293 ((ral >> 0) & 0xFF) as u8, 294 ((ral >> 8) & 0xFF) as u8, 295 ((ral >> 16) & 0xFF) as u8, 296 ((ral >> 24) & 0xFF) as u8, 297 ((rah >> 0) & 0xFF) as u8, 298 ((rah >> 8) & 0xFF) as u8, 299 ]; 300 // 初始化receive和transimit descriptor环形队列 301 // initialize receive and transimit desciptor ring 302 let (recv_ring_pa, recv_ring_va) = dma_alloc(E1000E_DMA_PAGES); 303 let (trans_ring_pa, trans_ring_va) = dma_alloc(E1000E_DMA_PAGES); 304 let recv_ring_length = PAGE_SIZE / size_of::<E1000ERecvDesc>(); 305 let trans_ring_length = PAGE_SIZE / size_of::<E1000ETransDesc>(); 306 307 let recv_desc_ring = unsafe { 308 from_raw_parts_mut::<E1000ERecvDesc>(recv_ring_va.as_ptr().cast(), recv_ring_length) 309 }; 310 let trans_desc_ring = unsafe { 311 from_raw_parts_mut::<E1000ETransDesc>(trans_ring_va.as_ptr().cast(), trans_ring_length) 312 }; 313 314 // 初始化receive和transmit packet的缓冲区 315 // initialzie receive and transmit buffers 316 let mut recv_buffers: Vec<E1000EBuffer> = Vec::with_capacity(recv_ring_length); 317 let mut trans_buffers: Vec<E1000EBuffer> = Vec::with_capacity(trans_ring_length); 318 319 // 初始化缓冲区与descriptor，descriptor 中的addr字典应当指向buffer的物理地址 320 // Receive buffers of appropriate size should be allocated and pointers to these buffers should be stored in the descriptor ring. 321 for i in 0..recv_ring_length { 322 let buffer = E1000EBuffer::new(PAGE_SIZE); 323 recv_desc_ring[i].addr = buffer.as_paddr() as u64; 324 recv_desc_ring[i].status = 0; 325 recv_buffers.push(buffer); 326 } 327 // Same as receive buffers 328 for i in 0..trans_ring_length { 329 let buffer = E1000EBuffer::new(PAGE_SIZE); 330 trans_desc_ring[i].addr = buffer.as_paddr() as u64; 331 trans_desc_ring[i].status = 1; 332 trans_buffers.push(buffer); 333 } 334 335 // Receive Initialization 14.6 336 // Initialzie mutlicast table array to 0b 337 // 初始化MTA，遍历0x05200-0x053FC中每个寄存器，写入0b，一共128个寄存器 338 let mut mta_adress = vaddress + E1000E_MTA_REGS_START_OFFSET; 339 while mta_adress != vaddress + E1000E_MTA_REGS_END_OFFSET { 340 let mta: NonNull<MTARegs> = get_register_ptr(mta_adress, 0); 341 unsafe { volwrite!(mta, mta, 0) }; 342 mta_adress = mta_adress + 4; 343 } 344 // 连续的寄存器读-写操作，放在同一个unsafe块中 345 unsafe { 346 // 设置descriptor环形队列的基地址 347 // Program the descriptor base address with the address of the region. 348 volwrite!(receive_regs, rdbal0, (recv_ring_pa) as u32); 349 volwrite!(receive_regs, rdbah0, (recv_ring_pa >> 32) as u32); 350 // 设置descriptor环形队列的长度 351 // Set the length register to the size of the descriptor ring. 352 volwrite!(receive_regs, rdlen0, PAGE_SIZE as u32); 353 // 设置队列的首尾指针 354 // Program the head and tail registers 355 volwrite!(receive_regs, rdh0, 0); 356 volwrite!(receive_regs, rdt0, (recv_ring_length - 1) as u32); 357 // 设置控制寄存器的相关功能 14.6.1 358 // Set the receive control register 359 volwrite!( 360 rctl_regs, 361 rctl, 362 E1000E_RCTL_EN 363 | E1000E_RCTL_BAM 364 | E1000E_RCTL_BSIZE_4K 365 | E1000E_RCTL_BSEX 366 | E1000E_RCTL_SECRC 367 ); 368 369 // Transmit Initialization 14.7 370 // 开启发包descriptor的回写功能 371 // Program the TXDCTL register with the desired TX descriptor write-back policy 372 volwrite!( 373 transimit_regs, 374 txdctl, 375 E1000E_TXDCTL_WTHRESH | E1000E_TXDCTL_GRAN 376 ); 377 // 设置descriptor环形队列的基地址，长度与首尾指针 378 // Program the descriptor base address with the address of the region 379 volwrite!(transimit_regs, tdbal0, trans_ring_pa as u32); 380 volwrite!(transimit_regs, tdbah0, (trans_ring_pa >> 32) as u32); 381 // Set the length register to the size of the descriptor ring. 382 volwrite!(transimit_regs, tdlen0, PAGE_SIZE as u32); 383 // Program the head and tail registerss 384 volwrite!(transimit_regs, tdh0, 0); 385 volwrite!(transimit_regs, tdt0, 0); 386 // Program the TIPG register 387 volwrite!( 388 tctl_regs, 389 tipg, 390 E1000E_TIPG_IPGT | E1000E_TIPG_IPGR1 | E1000E_TIPG_IPGR2 391 ); 392 // Program the TCTL register. 393 volwrite!( 394 tctl_regs, 395 tctl, 396 E1000E_TCTL_EN | E1000E_TCTL_PSP | E1000E_TCTL_CT_VAL | E1000E_TCTL_COLD_VAL 397 ); 398 399 let icr = volread!(interrupt_regs, icr); 400 volwrite!(interrupt_regs, icr, icr); 401 // 开启收包相关的中断 402 // Enable receive interrupts 403 let mut ims = volread!(interrupt_regs, ims); 404 ims = E1000E_IMS_LSC | E1000E_IMS_RXT0 | E1000E_IMS_RXDMT0 | E1000E_IMS_OTHER; 405 volwrite!(interrupt_regs, ims, ims); 406 } 407 return Ok(E1000EDevice { 408 general_regs, 409 interrupt_regs, 410 rctl_regs, 411 receive_regs, 412 tctl_regs, 413 transimit_regs, 414 pcie_regs, 415 recv_desc_ring, 416 trans_desc_ring, 417 recv_ring_pa, 418 trans_ring_pa, 419 recv_buffers, 420 trans_buffers, 421 mac, 422 first_trans: true, 423 napi_buffers: vec![E1000EBuffer::new(0); E1000E_RECV_NAPI], 424 napi_buffer_head: 0, 425 napi_buffer_tail: 0, 426 napi_buffer_empty: true, 427 }); 428 } 429 pub fn e1000e_receive(&mut self) -> Option<E1000EBuffer> { 430 self.e1000e_intr(); 431 let mut rdt = unsafe { volread!(self.receive_regs, rdt0) } as usize; 432 let index = (rdt + 1) % self.recv_desc_ring.len(); 433 let desc = &mut self.recv_desc_ring[index]; 434 if (desc.status & E1000E_RXD_STATUS_DD) == 0 { 435 return None; 436 } 437 let mut buffer = self.recv_buffers[index]; 438 let new_buffer = E1000EBuffer::new(PAGE_SIZE); 439 self.recv_buffers[index] = new_buffer; 440 desc.addr = new_buffer.as_paddr() as u64; 441 buffer.set_length(desc.len as usize); 442 rdt = index; 443 unsafe { volwrite!(self.receive_regs, rdt0, rdt as u32) }; 444 // kdebug!("e1000e: receive packet"); 445 return Some(buffer); 446 } 447 448 pub fn e1000e_can_transmit(&self) -> bool { 449 let tdt = unsafe { volread!(self.transimit_regs, tdt0) } as usize; 450 let index = tdt % self.trans_desc_ring.len(); 451 let desc = &self.trans_desc_ring[index]; 452 if (desc.status & E1000E_TXD_STATUS_DD) == 0 { 453 return false; 454 } 455 true 456 } 457 458 pub fn e1000e_transmit(&mut self, packet: E1000EBuffer) { 459 let mut tdt = unsafe { volread!(self.transimit_regs, tdt0) } as usize; 460 let index = tdt % self.trans_desc_ring.len(); 461 let desc = &mut self.trans_desc_ring[index]; 462 let buffer = self.trans_buffers[index]; 463 self.trans_buffers[index] = packet; 464 // recycle unused transmit buffer 465 buffer.free_buffer(); 466 // Set the transmit descriptor 467 desc.addr = packet.as_paddr() as u64; 468 desc.len = packet.len() as u16; 469 desc.status = 0; 470 desc.cmd = E1000E_TXD_CMD_EOP | E1000E_TXD_CMD_RS | E1000E_TXD_CMD_IFCS; 471 tdt = (tdt + 1) % self.trans_desc_ring.len(); 472 unsafe { volwrite!(self.transimit_regs, tdt0, tdt as u32) }; 473 self.first_trans = false; 474 } 475 pub fn mac_address(&self) -> [u8; 6] { 476 return self.mac; 477 } 478 // 向ICR寄存器中的某一bit写入1b表示该中断已经被接收，同时会清空该位 479 // we need to clear ICR to tell e1000e we have read the interrupt 480 pub fn e1000e_intr(&mut self) { 481 let icr = unsafe { volread!(self.interrupt_regs, icr) }; 482 // write 1b to any bit in ICR will clear the bit 483 unsafe { volwrite!(self.interrupt_regs, icr, icr) }; 484 } 485 486 // 切换是否接受分组到达的中断 487 // change whether the receive timer interrupt is enabled 488 // Note: this method is not completely implemented and not used in the current version 489 #[allow(dead_code)] 490 pub fn e1000e_intr_set(&mut self, state: bool) { 491 let mut ims = unsafe { volread!(self.interrupt_regs, ims) }; 492 match state { 493 true => ims = ims | E1000E_IMS_RXT0, 494 false => ims = ims & !E1000E_IMS_RXT0, 495 } 496 unsafe { volwrite!(self.interrupt_regs, ims, ims) }; 497 } 498 499 // 实现了一部分napi机制的收包函数, 现在还没有投入使用 500 // This method is a partial implementation of napi (New API) techniques 501 // Note: this method is not completely implemented and not used in the current version 502 #[allow(dead_code)] 503 pub fn e1000e_receive2(&mut self) -> Option<E1000EBuffer> { 504 // 向设备表明我们已经接受到了之前的中断 505 // Tell e1000e we have received the interrupt 506 self.e1000e_intr(); 507 // 如果napi队列不存在已经收到的分组... 508 // if napi queue is empty... 509 if self.napi_buffer_empty { 510 // 暂时关闭设备中断 511 // close interrupt 512 self.e1000e_intr_set(false); 513 loop { 514 if self.napi_buffer_tail == self.napi_buffer_head && self.napi_buffer_empty == false 515 { 516 // napi缓冲队列已满，停止收包 517 // napi queue is full, stop 518 break; 519 } 520 match self.e1000e_receive() { 521 Some(buffer) => { 522 self.napi_buffers[self.napi_buffer_tail] = buffer; 523 self.napi_buffer_tail = (self.napi_buffer_tail + 1) % E1000E_RECV_NAPI; 524 self.napi_buffer_empty = false; 525 } 526 None => { 527 // 设备队列中没有剩余的已到达的数据包 528 // no packet remains in the device buffer 529 break; 530 } 531 }; 532 } 533 // 重新打开设备中断 534 // open the interrupt 535 self.e1000e_intr_set(true); 536 } 537 538 let result = self.napi_buffers[self.napi_buffer_head]; 539 match result.len() { 540 0 => { 541 // napi队列和网卡队列中都不存在数据包 542 // both napi queue and device buffer is empty, no packet will receive 543 return None; 544 } 545 _ => { 546 // 有剩余的已到达的数据包 547 // there is packet in napi queue 548 self.napi_buffer_head = (self.napi_buffer_head + 1) % E1000E_RECV_NAPI; 549 if self.napi_buffer_head == self.napi_buffer_tail { 550 self.napi_buffer_empty = true; 551 } 552 return Some(result); 553 } 554 } 555 } 556 } 557 558 impl Drop for E1000EDevice { 559 fn drop(&mut self) { 560 // 释放已分配的所有dma页 561 // free all dma pages we have allocated 562 kdebug!("droping..."); 563 let recv_ring_length = PAGE_SIZE / size_of::<E1000ERecvDesc>(); 564 let trans_ring_length = PAGE_SIZE / size_of::<E1000ETransDesc>(); 565 unsafe { 566 // 释放所有buffer中的dma页 567 // free all dma pages in buffers 568 for i in 0..recv_ring_length { 569 self.recv_buffers[i].free_buffer(); 570 } 571 for i in 0..trans_ring_length { 572 self.trans_buffers[i].free_buffer(); 573 } 574 // 释放descriptor ring 575 // free descriptor ring 576 dma_dealloc( 577 self.recv_ring_pa, 578 NonNull::new(self.recv_desc_ring).unwrap().cast(), 579 E1000E_DMA_PAGES, 580 ); 581 dma_dealloc( 582 self.trans_ring_pa, 583 NonNull::new(self.trans_desc_ring).unwrap().cast(), 584 E1000E_DMA_PAGES, 585 ); 586 } 587 } 588 } 589 590 #[no_mangle] 591 pub extern "C" fn rs_e1000e_init() { 592 e1000e_init(); 593 } 594 595 pub fn e1000e_init() -> () { 596 match e1000e_probe() { 597 Ok(_code) => { 598 kinfo!("Successfully init e1000e device!"); 599 } 600 Err(_error) => { 601 kinfo!("Error occurred!"); 602 } 603 } 604 } 605 606 pub fn e1000e_probe() -> Result<u64, E1000EPciError> { 607 let mut list = PCI_DEVICE_LINKEDLIST.write(); 608 let result = get_pci_device_structure_mut(&mut list, NETWORK_CLASS, ETHERNET_SUBCLASS); 609 if result.is_empty() { 610 return Ok(0); 611 } 612 for device in result { 613 let standard_device = device.as_standard_device_mut().unwrap(); 614 let header = &standard_device.common_header; 615 if header.vendor_id == 0x8086 { 616 // intel 617 if E1000E_DEVICE_ID.contains(&header.device_id) { 618 kdebug!( 619 "Detected e1000e PCI device with device id {:#x}", 620 header.device_id 621 ); 622 let e1000e = E1000EDevice::new(standard_device)?; 623 e1000e_driver_init(e1000e); 624 } 625 } 626 } 627 628 return Ok(1); 629 } 630 631 // 用到的e1000e寄存器结构体 632 // pp.275, Table 13-3 633 // 设备通用寄存器 634 #[allow(dead_code)] 635 struct GeneralRegs { 636 ctrl: Volatile<u32>, //0x00000 637 ctrl_alias: Volatile<u32>, //0x00004 638 status: ReadOnly<u32>, //0x00008 639 status_align: ReadOnly<u32>, //0x0000c 640 eec: Volatile<u32>, //0x00010 641 eerd: Volatile<u32>, //0x00014 642 ctrl_ext: Volatile<u32>, //0x00018 643 fla: Volatile<u32>, //0x0001c 644 mdic: Volatile<u32>, //0x00020 645 } 646 // 中断控制 647 #[allow(dead_code)] 648 struct InterruptRegs { 649 icr: Volatile<u32>, //0x000c0 ICR寄存器应当为只读寄存器，但我们需要向其中写入来清除对应位 650 itr: Volatile<u32>, //0x000c4 651 ics: WriteOnly<u32>, //0x000c8 652 ics_align: ReadOnly<u32>, //0x000cc 653 ims: Volatile<u32>, //0x000d0 654 ims_align: ReadOnly<u32>, //0x000d4 655 imc: WriteOnly<u32>, //0x000d8 656 } 657 // 收包功能控制 658 struct ReceiveCtrlRegs { 659 rctl: Volatile<u32>, //0x00100 660 } 661 // 发包功能控制 662 #[allow(dead_code)] 663 struct TransmitCtrlRegs { 664 tctl: Volatile<u32>, //0x00400 665 tctl_ext: Volatile<u32>, //0x00404 666 unused_1: ReadOnly<u32>, //0x00408 667 unused_2: ReadOnly<u32>, //0x0040c 668 tipg: Volatile<u32>, //0x00410 669 } 670 // 收包功能相关 671 #[allow(dead_code)] 672 struct ReceiveRegs { 673 rdbal0: Volatile<u32>, //0x02800 674 rdbah0: Volatile<u32>, //0x02804 675 rdlen0: Volatile<u32>, //0x02808 676 rdl_align: ReadOnly<u32>, //0x0280c 677 rdh0: Volatile<u32>, //0x02810 678 rdh_align: ReadOnly<u32>, //0x02814 679 rdt0: Volatile<u32>, //0x02818 680 rdt_align: ReadOnly<u32>, //0x281c 681 rdtr: Volatile<u32>, //0x2820 682 rdtr_align: ReadOnly<u32>, //0x2824 683 rxdctl: Volatile<u32>, //0x2828 684 } 685 // 发包功能相关 686 #[allow(dead_code)] 687 struct TransimitRegs { 688 tdbal0: Volatile<u32>, //0x03800 689 tdbah0: Volatile<u32>, //0x03804 690 tdlen0: Volatile<u32>, //0x03808 691 tdlen_algin: ReadOnly<u32>, //0x0380c 692 tdh0: Volatile<u32>, //0x03810 693 tdh_align: ReadOnly<u32>, //0x03814 694 tdt0: Volatile<u32>, //0x03818 695 tdt_align: ReadOnly<u32>, //0x0381c 696 tidv: Volatile<u32>, //0x03820 697 tidv_align: ReadOnly<u32>, //0x03824 698 txdctl: Volatile<u32>, //0x03828 699 tadv: Volatile<u32>, //0x0382c 700 } 701 // mac地址 702 struct ReceiveAddressRegs { 703 ral0: Volatile<u32>, //0x05400 704 rah0: Volatile<u32>, //0x05404 705 } 706 // PCIe 通用控制 707 struct PCIeRegs { 708 gcr: Volatile<u32>, //0x05b00 709 } 710 #[allow(dead_code)] 711 struct StatisticsRegs {} 712 713 // 0x05200-0x053fc 714 // 在Receive Initialization 中按照每次一个32bit寄存器的方式来遍历 715 // Multicast Table Array Registers will be written per 32bit 716 struct MTARegs { 717 mta: Volatile<u32>, 718 } 719 720 const E1000E_GENERAL_REGS_OFFSET: u64 = 0x00000; 721 const E1000E_INTERRRUPT_REGS_OFFSET: u64 = 0x000c0; 722 const E1000E_RECEIVE_CTRL_REG_OFFSET: u64 = 0x00100; 723 const E1000E_RECEIVE_REGS_OFFSET: u64 = 0x02800; 724 const E1000E_TRANSMIT_CTRL_REG_OFFSET: u64 = 0x00400; 725 const E1000E_TRANSMIT_REGS_OFFSET: u64 = 0x03800; 726 const E1000E_RECEIVE_ADDRESS_REGS_OFFSET: u64 = 0x05400; 727 const E1000E_PCIE_REGS_OFFSET: u64 = 0x05b00; 728 const E1000E_MTA_REGS_START_OFFSET: u64 = 0x05200; 729 const E1000E_MTA_REGS_END_OFFSET: u64 = 0x053fc; 730 // 寄存器的特定位 731 //CTRL 732 const E1000E_CTRL_SLU: u32 = 1 << 6; 733 const E1000E_CTRL_FRCSPD: u32 = 1 << 11; 734 const E1000E_CTRL_FRCDPLX: u32 = 1 << 12; 735 const E1000E_CTRL_RST: u32 = 1 << 26; 736 #[allow(dead_code)] 737 const E1000E_CTRL_RFCE: u32 = 1 << 27; 738 #[allow(dead_code)] 739 const E1000E_CTRL_TFCE: u32 = 1 << 28; 740 const E1000E_CTRL_PHY_RST: u32 = 1 << 31; 741 742 // IMS 743 const E1000E_IMS_LSC: u32 = 1 << 2; 744 const E1000E_IMS_RXDMT0: u32 = 1 << 4; 745 #[allow(dead_code)] 746 const E1000E_IMS_RXO: u32 = 1 << 6; 747 const E1000E_IMS_RXT0: u32 = 1 << 7; 748 #[allow(dead_code)] 749 const E1000E_IMS_RXQ0: u32 = 1 << 20; 750 const E1000E_IMS_OTHER: u32 = 1 << 24; // qemu use this bit to set msi-x interrupt 751 752 // IMC 753 const E1000E_IMC_CLEAR: u32 = 0xffffffff; 754 755 // RCTL 756 const E1000E_RCTL_EN: u32 = 1 << 1; 757 const E1000E_RCTL_BAM: u32 = 1 << 15; 758 const E1000E_RCTL_BSIZE_4K: u32 = 3 << 16; 759 const E1000E_RCTL_BSEX: u32 = 1 << 25; 760 const E1000E_RCTL_SECRC: u32 = 1 << 26; 761 762 // TCTL 763 const E1000E_TCTL_EN: u32 = 1 << 1; 764 const E1000E_TCTL_PSP: u32 = 1 << 3; 765 const E1000E_TCTL_CT_VAL: u32 = 0x0f << 4; // suggested 16d collision, 手册建议值：16d 766 const E1000E_TCTL_COLD_VAL: u32 = 0x03f << 12; // suggested 64 byte time for Full-Duplex, 手册建议值：64 767 // TXDCTL 768 const E1000E_TXDCTL_WTHRESH: u32 = 1 << 16; 769 const E1000E_TXDCTL_GRAN: u32 = 1 << 24; 770 // TIPG 771 const E1000E_TIPG_IPGT: u32 = 8; 772 const E1000E_TIPG_IPGR1: u32 = 2 << 10; 773 const E1000E_TIPG_IPGR2: u32 = 10 << 20; 774 775 // RxDescriptorStatus 776 const E1000E_RXD_STATUS_DD: u16 = 1 << 0; 777 778 // TxDescriptorStatus 779 const E1000E_TXD_STATUS_DD: u8 = 1 << 0; 780 const E1000E_TXD_CMD_EOP: u8 = 1 << 0; 781 const E1000E_TXD_CMD_IFCS: u8 = 1 << 1; 782 const E1000E_TXD_CMD_RS: u8 = 1 << 3; 783 784 // E1000E驱动初始化过程中可能的错误 785 pub enum E1000EPciError { 786 // 获取到错误类型的BAR（IO BAR） 787 // An IO BAR was provided rather than a memory BAR. 788 UnexpectedBarType, 789 // 获取的BAR没有被分配到某个地址(address == 0) 790 // A BAR which we need was not allocated an address(address == 0). 791 BarNotAllocated, 792 //获取虚拟地址失败 793 BarGetVaddrFailed, 794 // 没有对应的BAR或者获取BAR失败 795 BarGetFailed, 796 // BAR的大小与预期不符(128KB) 797 // Size of BAR is not 128KB 798 UnexpectedBarSize, 799 Pci(PciError), 800 } 801 802 /// PCI error到VirtioPciError的转换，层层上报 803 impl From<PciError> for E1000EPciError { 804 fn from(error: PciError) -> Self { 805 Self::Pci(error) 806 } 807 } 808 809 /** 810 * @brief 获取基地址的某个偏移量的指针，用于在mmio bar中构造寄存器结构体 811 * @brief used for build register struct in mmio bar 812 * @param vaddr: base address (in virtual memory) 813 * @param offset: offset 814 */ 815 fn get_register_ptr<T>(vaddr: u64, offset: u64) -> NonNull<T> { 816 NonNull::new((vaddr + offset) as *mut T).unwrap() 817 } 818