xref: /DragonOS/kernel/src/driver/pci/pci_irq.rs (revision 232570ae98cbd1d618cd1208deaef4c220ab41dd) 
1 #![allow(dead_code)]
2 
3 use core::mem::size_of;
4 use core::ptr::NonNull;
5 
6 use alloc::string::String;
7 use alloc::sync::Arc;
8 use alloc::vec::Vec;
9 use log::error;
10 use system_error::SystemError;
11 
12 use super::pci::{PciDeviceStructure, PciDeviceStructureGeneralDevice, PciError};
13 use super::root::pci_root_0;
14 use crate::arch::msi::{arch_msi_message_address, arch_msi_message_data};
15 
16 use crate::driver::base::device::DeviceId;
17 use crate::exception::irqdesc::{IrqHandleFlags, IrqHandler};
18 use crate::exception::manage::irq_manager;
19 use crate::exception::IrqNumber;
20 use crate::libs::volatile::{volread, volwrite, Volatile};
21 
22 /// MSIX表的一项
23 #[repr(C)]
24 struct MsixEntry {
25     msg_addr: Volatile<u32>,
26     msg_upper_addr: Volatile<u32>,
27     msg_data: Volatile<u32>,
28     vector_control: Volatile<u32>,
29 }
30 
31 /// Pending表的一项
32 #[repr(C)]
33 struct PendingEntry {
34     entry: Volatile<u64>,
35 }
36 
37 /// PCI设备中断错误
38 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
39 pub enum PciIrqError {
40     IrqTypeNotSupported,
41     PciDeviceNotSupportIrq,
42     IrqTypeUnmatch,
43     InvalidIrqIndex(u16),
44     InvalidIrqNum(IrqNumber),
45     IrqNumOccupied(IrqNumber),
46     DeviceIrqOverflow,
47     MxiIrqNumWrong,
48     PciBarNotInited,
49     BarGetVaddrFailed,
50     MaskNotSupported,
51     IrqNotInited,
52 }
53 
54 /// PCI设备的中断类型
55 #[derive(Copy, Clone, Debug)]
56 pub enum IrqType {
57     Msi {
58         address_64: bool,
59         maskable: bool,
60         irq_max_num: u16,
61         cap_offset: u8,
62     },
63     Msix {
64         msix_table_bar: u8,
65         msix_table_offset: u32,
66         pending_table_bar: u8,
67         pending_table_offset: u32,
68         irq_max_num: u16,
69         cap_offset: u8,
70     },
71     Legacy,
72     Unused,
73 }
74 
75 // PCI设备install中断时需要传递的参数
76 #[derive(Clone, Debug)]
77 pub struct PciIrqMsg {
78     pub irq_common_message: IrqCommonMsg,
79     pub irq_specific_message: IrqSpecificMsg,
80 }
81 
82 // PCI设备install中断时需要传递的共同参数
83 #[derive(Clone, Debug)]
84 pub struct IrqCommonMsg {
85     irq_index: u16,                      //要install的中断号在PCI设备中的irq_vector的index
86     irq_name: String,                    //中断名字
87     irq_hander: &'static dyn IrqHandler, // 中断处理函数
88     /// 全局设备标志符
89     dev_id: Arc<DeviceId>,
90 }
91 
92 impl IrqCommonMsg {
init_from( irq_index: u16, irq_name: String, irq_hander: &'static dyn IrqHandler, dev_id: Arc<DeviceId>, ) -> Self93     pub fn init_from(
94         irq_index: u16,
95         irq_name: String,
96         irq_hander: &'static dyn IrqHandler,
97         dev_id: Arc<DeviceId>,
98     ) -> Self {
99         IrqCommonMsg {
100             irq_index,
101             irq_name,
102             irq_hander,
103             dev_id,
104         }
105     }
106 
set_handler(&mut self, irq_hander: &'static dyn IrqHandler)107     pub fn set_handler(&mut self, irq_hander: &'static dyn IrqHandler) {
108         self.irq_hander = irq_hander;
109     }
110 
dev_id(&self) -> &Arc<DeviceId>111     pub fn dev_id(&self) -> &Arc<DeviceId> {
112         &self.dev_id
113     }
114 }
115 
116 // PCI设备install中断时需要传递的特有参数，Msi代表MSI与MSIX
117 #[derive(Clone, Debug)]
118 pub enum IrqSpecificMsg {
119     Legacy,
120     Msi {
121         processor: u16,
122         trigger_mode: TriggerMode,
123     },
124 }
125 impl IrqSpecificMsg {
msi_default() -> Self126     pub fn msi_default() -> Self {
127         IrqSpecificMsg::Msi {
128             processor: 0,
129             trigger_mode: TriggerMode::EdgeTrigger,
130         }
131     }
132 }
133 
134 // 申请中断的触发模式，MSI默认为边沿触发
135 #[derive(Copy, Clone, Debug)]
136 pub enum TriggerMode {
137     EdgeTrigger,
138     AssertHigh,
139     AssertLow,
140 }
141 
142 bitflags! {
143     /// 设备中断类型，使用bitflag使得中断类型的选择更多元化
144     pub struct IRQ: u8{
145         const PCI_IRQ_LEGACY = 1 << 0;
146         const PCI_IRQ_MSI = 1 << 1;
147         const PCI_IRQ_MSIX = 1 << 2;
148         const PCI_IRQ_ALL_TYPES=IRQ::PCI_IRQ_LEGACY.bits|IRQ::PCI_IRQ_MSI.bits|IRQ::PCI_IRQ_MSIX.bits;
149     }
150 }
151 
152 /// PciDeviceStructure的子trait，使用继承以直接使用PciDeviceStructure里的接口
153 pub trait PciInterrupt: PciDeviceStructure {
154     /// @brief PCI设备调用该函数选择中断类型
155     /// @param self PCI设备的可变引用
156     /// @param flag 选择的中断类型（支持多个选择），如PCI_IRQ_ALL_TYPES表示所有中断类型均可，让系统按顺序进行选择
157     /// @return Option<IrqType> 失败返回None，成功则返回对应中断类型
irq_init(&mut self, flag: IRQ) -> Option<IrqType>158     fn irq_init(&mut self, flag: IRQ) -> Option<IrqType> {
159         // MSIX中断优先
160         if flag.contains(IRQ::PCI_IRQ_MSIX) {
161             if let Some(cap_offset) = self.msix_capability_offset() {
162                 let data = pci_root_0()
163                     .read_config(self.common_header().bus_device_function, cap_offset.into());
164                 let irq_max_num = ((data >> 16) & 0x7ff) as u16 + 1;
165                 let data = pci_root_0().read_config(
166                     self.common_header().bus_device_function,
167                     (cap_offset + 4).into(),
168                 );
169                 let msix_table_bar = (data & 0x07) as u8;
170                 let msix_table_offset = data & (!0x07);
171                 let data = pci_root_0().read_config(
172                     self.common_header().bus_device_function,
173                     (cap_offset + 8).into(),
174                 );
175                 let pending_table_bar = (data & 0x07) as u8;
176                 let pending_table_offset = data & (!0x07);
177                 *self.irq_type_mut()? = IrqType::Msix {
178                     msix_table_bar,
179                     msix_table_offset,
180                     pending_table_bar,
181                     pending_table_offset,
182                     irq_max_num,
183                     cap_offset,
184                 };
185                 return Some(IrqType::Msix {
186                     msix_table_bar,
187                     msix_table_offset,
188                     pending_table_bar,
189                     pending_table_offset,
190                     irq_max_num,
191                     cap_offset,
192                 });
193             }
194         }
195         // 其次MSI
196         if flag.contains(IRQ::PCI_IRQ_MSI) {
197             if let Some(cap_offset) = self.msi_capability_offset() {
198                 let data = pci_root_0()
199                     .read_config(self.common_header().bus_device_function, cap_offset.into());
200                 let message_control = (data >> 16) as u16;
201                 let maskable = (message_control & 0x0100) != 0;
202                 let address_64 = (message_control & 0x0080) != 0;
203                 let irq_max_num = (1 << (((message_control & 0x000e) >> 1) + 1)) as u16;
204                 *self.irq_type_mut()? = IrqType::Msi {
205                     address_64,
206                     maskable,
207                     irq_max_num,
208                     cap_offset,
209                 };
210                 return Some(IrqType::Msi {
211                     address_64,
212                     maskable,
213                     irq_max_num,
214                     cap_offset,
215                 });
216             }
217         }
218         // 最后选择legacy#
219         if flag.contains(IRQ::PCI_IRQ_LEGACY) {
220             *self.irq_type_mut()? = IrqType::Legacy;
221             return Some(IrqType::Legacy);
222         }
223         None
224     }
225 
226     /// @brief 启动/关闭设备中断
227     /// @param self PCI设备的可变引用
228     /// @param enable 开启/关闭
irq_enable(&mut self, enable: bool) -> Result<u8, PciError>229     fn irq_enable(&mut self, enable: bool) -> Result<u8, PciError> {
230         if let Some(irq_type) = self.irq_type_mut() {
231             match *irq_type {
232                 IrqType::Msix { .. } => {
233                     return self.msix_enable(enable);
234                 }
235                 IrqType::Msi { .. } => {
236                     return self.msi_enable(enable);
237                 }
238                 IrqType::Legacy => {
239                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeNotSupported));
240                 }
241                 IrqType::Unused => {
242                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
243                 }
244             }
245         }
246         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
247     }
248     /// @brief 启动/关闭设备MSIX中断
249     /// @param self PCI设备的可变引用
250     /// @param enable 开启/关闭
msix_enable(&mut self, enable: bool) -> Result<u8, PciError>251     fn msix_enable(&mut self, enable: bool) -> Result<u8, PciError> {
252         if let Some(irq_type) = self.irq_type_mut() {
253             match *irq_type {
254                 IrqType::Msix { cap_offset, .. } => {
255                     let mut message = pci_root_0()
256                         .read_config(self.common_header().bus_device_function, cap_offset.into());
257                     if enable {
258                         message |= 1 << 31;
259                     } else {
260                         message &= !(1 << 31);
261                     }
262                     pci_root_0().write_config(
263                         self.common_header().bus_device_function,
264                         cap_offset.into(),
265                         message,
266                     );
267                     return Ok(0);
268                 }
269                 IrqType::Unused => {
270                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
271                 }
272                 _ => {
273                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
274                 }
275             }
276         }
277         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
278     }
279     /// @brief 启动/关闭设备MSI中断
280     /// @param self PCI设备的可变引用
281     /// @param enable 开启/关闭
msi_enable(&mut self, enable: bool) -> Result<u8, PciError>282     fn msi_enable(&mut self, enable: bool) -> Result<u8, PciError> {
283         if let Some(irq_type) = self.irq_type_mut() {
284             match *irq_type {
285                 IrqType::Msi { cap_offset, .. } => {
286                     let mut message = pci_root_0()
287                         .read_config(self.common_header().bus_device_function, cap_offset.into());
288                     if enable {
289                         message |= 1 << 16;
290                     } else {
291                         message &= !(1 << 16);
292                     }
293                     pci_root_0().write_config(
294                         self.common_header().bus_device_function,
295                         cap_offset.into(),
296                         message,
297                     );
298                     return Ok(0);
299                 }
300                 IrqType::Unused => {
301                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
302                 }
303                 _ => {
304                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
305                 }
306             }
307         }
308         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
309     }
310     /// @brief 获取指定数量的中断号 todo 需要中断重构支持
irq_alloc(_num: u16) -> Option<Vec<u16>>311     fn irq_alloc(_num: u16) -> Option<Vec<u16>> {
312         None
313     }
314     /// @brief 进行PCI设备中断的安装
315     /// @param self PCI设备的可变引用
316     /// @param msg PCI设备install中断时需要传递的共同参数
317     /// @return 一切正常返回Ok(0),有错误返回对应错误原因
irq_install(&mut self, msg: PciIrqMsg) -> Result<u8, PciError>318     fn irq_install(&mut self, msg: PciIrqMsg) -> Result<u8, PciError> {
319         if let Some(irq_vector) = self.irq_vector_mut() {
320             if msg.irq_common_message.irq_index as usize > irq_vector.len() {
321                 return Err(PciError::PciIrqError(PciIrqError::InvalidIrqIndex(
322                     msg.irq_common_message.irq_index,
323                 )));
324             }
325         }
326         self.irq_enable(false)?; //中断设置更改前先关闭对应PCI设备的中断
327         if let Some(irq_type) = self.irq_type_mut() {
328             match *irq_type {
329                 IrqType::Msix { .. } => {
330                     return self.msix_install(msg);
331                 }
332                 IrqType::Msi { .. } => {
333                     return self.msi_install(msg);
334                 }
335                 IrqType::Unused => {
336                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
337                 }
338                 _ => {
339                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeNotSupported));
340                 }
341             }
342         }
343         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
344     }
345     /// @brief 进行PCI设备中断的安装(MSI)
346     /// @param self PCI设备的可变引用
347     /// @param msg PCI设备install中断时需要传递的共同参数
348     /// @return 一切正常返回Ok(0),有错误返回对应错误原因
msi_install(&mut self, msg: PciIrqMsg) -> Result<u8, PciError>349     fn msi_install(&mut self, msg: PciIrqMsg) -> Result<u8, PciError> {
350         if let Some(irq_type) = self.irq_type_mut() {
351             match *irq_type {
352                 IrqType::Msi {
353                     address_64,
354                     irq_max_num,
355                     cap_offset,
356                     ..
357                 } => {
358                     // 注意：MSI中断分配的中断号必须连续且大小为2的倍数
359                     if self.irq_vector_mut().unwrap().len() > irq_max_num as usize {
360                         return Err(PciError::PciIrqError(PciIrqError::DeviceIrqOverflow));
361                     }
362                     let irq_num =
363                         self.irq_vector_mut().unwrap()[msg.irq_common_message.irq_index as usize];
364 
365                     let irq_num = IrqNumber::new(irq_num.into());
366                     let common_msg = &msg.irq_common_message;
367 
368                     let result = irq_manager().request_irq(
369                         irq_num,
370                         common_msg.irq_name.clone(),
371                         common_msg.irq_hander,
372                         IrqHandleFlags::IRQF_SHARED,
373                         Some(common_msg.dev_id.clone()),
374                     );
375 
376                     match result {
377                         Ok(_) => {}
378                         Err(SystemError::EINVAL) => {
379                             return Err(PciError::PciIrqError(PciIrqError::InvalidIrqNum(irq_num)));
380                         }
381 
382                         Err(SystemError::EAGAIN_OR_EWOULDBLOCK) => {
383                             return Err(PciError::PciIrqError(PciIrqError::IrqNumOccupied(
384                                 irq_num,
385                             )));
386                         }
387 
388                         Err(_) => {
389                             error!(
390                                 "Failed to request pci irq {} for device {}",
391                                 irq_num.data(),
392                                 &common_msg.irq_name
393                             );
394                             return Err(PciError::PciIrqError(PciIrqError::IrqNumOccupied(
395                                 irq_num,
396                             )));
397                         }
398                     }
399 
400                     // MSI中断只需配置一次PCI寄存器
401                     if common_msg.irq_index == 0 {
402                         let msg_address = arch_msi_message_address(0);
403                         let trigger = match msg.irq_specific_message {
404                             IrqSpecificMsg::Legacy => {
405                                 return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
406                             }
407                             IrqSpecificMsg::Msi { trigger_mode, .. } => trigger_mode,
408                         };
409                         let msg_data = arch_msi_message_data(irq_num.data() as u16, 0, trigger);
410                         // 写入Message Data和Message Address
411                         if address_64 {
412                             pci_root_0().write_config(
413                                 self.common_header().bus_device_function,
414                                 (cap_offset + 4).into(),
415                                 msg_address,
416                             );
417                             pci_root_0().write_config(
418                                 self.common_header().bus_device_function,
419                                 (cap_offset + 8).into(),
420                                 0,
421                             );
422                             pci_root_0().write_config(
423                                 self.common_header().bus_device_function,
424                                 (cap_offset + 12).into(),
425                                 msg_data,
426                             );
427                         } else {
428                             pci_root_0().write_config(
429                                 self.common_header().bus_device_function,
430                                 (cap_offset + 4).into(),
431                                 msg_address,
432                             );
433                             pci_root_0().write_config(
434                                 self.common_header().bus_device_function,
435                                 (cap_offset + 8).into(),
436                                 msg_data,
437                             );
438                         }
439                         let data = pci_root_0().read_config(
440                             self.common_header().bus_device_function,
441                             cap_offset.into(),
442                         );
443                         let message_control = (data >> 16) as u16;
444                         match self.irq_vector_mut().unwrap().len() {
445                             1 => {
446                                 let temp = message_control & (!0x0070);
447                                 pci_root_0().write_config(
448                                     self.common_header().bus_device_function,
449                                     cap_offset.into(),
450                                     (temp as u32) << 16,
451                                 );
452                             }
453                             2 => {
454                                 let temp = message_control & (!0x0070);
455                                 pci_root_0().write_config(
456                                     self.common_header().bus_device_function,
457                                     cap_offset.into(),
458                                     ((temp | (0x0001 << 4)) as u32) << 16,
459                                 );
460                             }
461                             4 => {
462                                 let temp = message_control & (!0x0070);
463                                 pci_root_0().write_config(
464                                     self.common_header().bus_device_function,
465                                     cap_offset.into(),
466                                     ((temp | (0x0002 << 4)) as u32) << 16,
467                                 );
468                             }
469                             8 => {
470                                 let temp = message_control & (!0x0070);
471                                 pci_root_0().write_config(
472                                     self.common_header().bus_device_function,
473                                     cap_offset.into(),
474                                     ((temp | (0x0003 << 4)) as u32) << 16,
475                                 );
476                             }
477                             16 => {
478                                 let temp = message_control & (!0x0070);
479                                 pci_root_0().write_config(
480                                     self.common_header().bus_device_function,
481                                     cap_offset.into(),
482                                     ((temp | (0x0004 << 4)) as u32) << 16,
483                                 );
484                             }
485                             32 => {
486                                 let temp = message_control & (!0x0070);
487                                 pci_root_0().write_config(
488                                     self.common_header().bus_device_function,
489                                     cap_offset.into(),
490                                     ((temp | (0x0005 << 4)) as u32) << 16,
491                                 );
492                             }
493                             _ => {
494                                 return Err(PciError::PciIrqError(PciIrqError::MxiIrqNumWrong));
495                             }
496                         }
497                     }
498                     return Ok(0);
499                 }
500                 IrqType::Unused => {
501                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
502                 }
503                 _ => {
504                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
505                 }
506             }
507         }
508         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
509     }
510     /// @brief 进行PCI设备中断的安装(MSIX)
511     /// @param self PCI设备的可变引用
512     /// @param msg PCI设备install中断时需要传递的共同参数
513     /// @return 一切正常返回Ok(0),有错误返回对应错误原因
msix_install(&mut self, msg: PciIrqMsg) -> Result<u8, PciError>514     fn msix_install(&mut self, msg: PciIrqMsg) -> Result<u8, PciError> {
515         if let Some(irq_type) = self.irq_type_mut() {
516             match *irq_type {
517                 IrqType::Msix {
518                     irq_max_num,
519                     msix_table_bar,
520                     msix_table_offset,
521                     ..
522                 } => {
523                     if self.irq_vector_mut().unwrap().len() > irq_max_num as usize {
524                         return Err(PciError::PciIrqError(PciIrqError::DeviceIrqOverflow));
525                     }
526                     let irq_num =
527                         self.irq_vector_mut().unwrap()[msg.irq_common_message.irq_index as usize];
528 
529                     let common_msg = &msg.irq_common_message;
530 
531                     let result = irq_manager().request_irq(
532                         irq_num,
533                         common_msg.irq_name.clone(),
534                         common_msg.irq_hander,
535                         IrqHandleFlags::IRQF_SHARED,
536                         Some(common_msg.dev_id.clone()),
537                     );
538 
539                     match result {
540                         Ok(_) => {}
541                         Err(SystemError::EINVAL) => {
542                             return Err(PciError::PciIrqError(PciIrqError::InvalidIrqNum(irq_num)));
543                         }
544 
545                         Err(SystemError::EAGAIN_OR_EWOULDBLOCK) => {
546                             return Err(PciError::PciIrqError(PciIrqError::IrqNumOccupied(
547                                 irq_num,
548                             )));
549                         }
550 
551                         Err(_) => {
552                             error!(
553                                 "Failed to request pci irq {} for device {}",
554                                 irq_num.data(),
555                                 &common_msg.irq_name
556                             );
557                             return Err(PciError::PciIrqError(PciIrqError::IrqNumOccupied(
558                                 irq_num,
559                             )));
560                         }
561                     }
562 
563                     let msg_address = arch_msi_message_address(0);
564                     let trigger = match msg.irq_specific_message {
565                         IrqSpecificMsg::Legacy => {
566                             return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
567                         }
568                         IrqSpecificMsg::Msi { trigger_mode, .. } => trigger_mode,
569                     };
570                     let msg_data = arch_msi_message_data(irq_num.data() as u16, 0, trigger);
571                     //写入Message Data和Message Address
572                     let pcistandardbar = self
573                         .bar()
574                         .ok_or(PciError::PciIrqError(PciIrqError::PciBarNotInited))?;
575                     let msix_bar = pcistandardbar.get_bar(msix_table_bar)?;
576                     let vaddr: crate::mm::VirtAddr = msix_bar
577                         .virtual_address()
578                         .ok_or(PciError::PciIrqError(PciIrqError::BarGetVaddrFailed))?
579                         + msix_table_offset as usize
580                         + msg.irq_common_message.irq_index as usize * size_of::<MsixEntry>();
581                     let msix_entry = NonNull::new(vaddr.data() as *mut MsixEntry).unwrap();
582                     // 这里的操作并不适用于所有架构，需要再优化，msg_upper_data并不一定为0
583                     unsafe {
584                         volwrite!(msix_entry, vector_control, 0);
585                         volwrite!(msix_entry, msg_data, msg_data);
586                         volwrite!(msix_entry, msg_upper_addr, 0);
587                         volwrite!(msix_entry, msg_addr, msg_address);
588                     }
589                     return Ok(0);
590                 }
591                 IrqType::Unused => {
592                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
593                 }
594                 _ => {
595                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
596                 }
597             }
598         }
599         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
600     }
601     /// @brief 进行PCI设备中断的卸载
602     /// @param self PCI设备的可变引用
irq_uninstall(&mut self) -> Result<u8, PciError>603     fn irq_uninstall(&mut self) -> Result<u8, PciError> {
604         self.irq_enable(false)?; //中断设置更改前先关闭对应PCI设备的中断
605         if let Some(irq_type) = self.irq_type_mut() {
606             match *irq_type {
607                 IrqType::Msix { .. } => {
608                     return self.msix_uninstall();
609                 }
610                 IrqType::Msi { .. } => {
611                     return self.msi_uninstall();
612                 }
613                 IrqType::Unused => {
614                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
615                 }
616                 _ => {
617                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeNotSupported));
618                 }
619             }
620         }
621         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
622     }
623     /// @brief 进行PCI设备中断的卸载（MSI）
624     /// @param self PCI设备的可变引用
msi_uninstall(&mut self) -> Result<u8, PciError>625     fn msi_uninstall(&mut self) -> Result<u8, PciError> {
626         if let Some(irq_type) = self.irq_type_mut() {
627             match *irq_type {
628                 IrqType::Msi {
629                     address_64,
630                     cap_offset,
631                     ..
632                 } => {
633                     for vector in self.irq_vector_mut().unwrap() {
634                         let irq = IrqNumber::new((*vector).into());
635                         irq_manager().free_irq(irq, None);
636                     }
637                     pci_root_0().write_config(
638                         self.common_header().bus_device_function,
639                         cap_offset.into(),
640                         0,
641                     );
642                     pci_root_0().write_config(
643                         self.common_header().bus_device_function,
644                         (cap_offset + 4).into(),
645                         0,
646                     );
647                     pci_root_0().write_config(
648                         self.common_header().bus_device_function,
649                         (cap_offset + 8).into(),
650                         0,
651                     );
652                     if address_64 {
653                         pci_root_0().write_config(
654                             self.common_header().bus_device_function,
655                             (cap_offset + 12).into(),
656                             0,
657                         );
658                     }
659                     return Ok(0);
660                 }
661                 IrqType::Unused => {
662                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
663                 }
664                 _ => {
665                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
666                 }
667             }
668         }
669         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
670     }
671     /// @brief 进行PCI设备中断的卸载(MSIX)
672     /// @param self PCI设备的可变引用
msix_uninstall(&mut self) -> Result<u8, PciError>673     fn msix_uninstall(&mut self) -> Result<u8, PciError> {
674         if let Some(irq_type) = self.irq_type_mut() {
675             match *irq_type {
676                 IrqType::Msix {
677                     irq_max_num,
678                     cap_offset,
679                     msix_table_bar,
680                     msix_table_offset,
681                     ..
682                 } => {
683                     for vector in self.irq_vector_mut().unwrap() {
684                         let irq = IrqNumber::new((*vector).into());
685                         irq_manager().free_irq(irq, None);
686                     }
687                     pci_root_0().write_config(
688                         self.common_header().bus_device_function,
689                         cap_offset.into(),
690                         0,
691                     );
692                     let pcistandardbar = self
693                         .bar()
694                         .ok_or(PciError::PciIrqError(PciIrqError::PciBarNotInited))
695                         .unwrap();
696                     let msix_bar = pcistandardbar.get_bar(msix_table_bar).unwrap();
697                     for index in 0..irq_max_num {
698                         let vaddr = msix_bar
699                             .virtual_address()
700                             .ok_or(PciError::PciIrqError(PciIrqError::BarGetVaddrFailed))
701                             .unwrap()
702                             + msix_table_offset as usize
703                             + index as usize * size_of::<MsixEntry>();
704                         let msix_entry = NonNull::new(vaddr.data() as *mut MsixEntry).unwrap();
705                         unsafe {
706                             volwrite!(msix_entry, vector_control, 0);
707                             volwrite!(msix_entry, msg_data, 0);
708                             volwrite!(msix_entry, msg_upper_addr, 0);
709                             volwrite!(msix_entry, msg_addr, 0);
710                         }
711                     }
712                     return Ok(0);
713                 }
714                 IrqType::Unused => {
715                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
716                 }
717                 _ => {
718                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
719                 }
720             }
721         }
722         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
723     }
724     /// @brief 屏蔽相应位置的中断
725     /// @param self PCI设备的可变引用
726     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
irq_mask(&mut self, irq_index: u16) -> Result<u8, PciError>727     fn irq_mask(&mut self, irq_index: u16) -> Result<u8, PciError> {
728         if let Some(irq_type) = self.irq_type_mut() {
729             match *irq_type {
730                 IrqType::Msix { .. } => {
731                     return self.msix_mask(irq_index);
732                 }
733                 IrqType::Msi { .. } => {
734                     return self.msi_mask(irq_index);
735                 }
736                 IrqType::Unused => {
737                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
738                 }
739                 _ => {
740                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeNotSupported));
741                 }
742             }
743         }
744         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
745     }
746     /// @brief 屏蔽相应位置的中断(MSI)
747     /// @param self PCI设备的可变引用
748     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
msi_mask(&mut self, irq_index: u16) -> Result<u8, PciError>749     fn msi_mask(&mut self, irq_index: u16) -> Result<u8, PciError> {
750         if let Some(irq_type) = self.irq_type_mut() {
751             match *irq_type {
752                 IrqType::Msi {
753                     maskable,
754                     address_64,
755                     cap_offset,
756                     irq_max_num,
757                 } => {
758                     if irq_index >= irq_max_num {
759                         return Err(PciError::PciIrqError(PciIrqError::InvalidIrqIndex(
760                             irq_index,
761                         )));
762                     }
763                     if maskable {
764                         match address_64 {
765                             true => {
766                                 let mut mask = pci_root_0().read_config(
767                                     self.common_header().bus_device_function,
768                                     (cap_offset + 16).into(),
769                                 );
770                                 mask |= 1 << irq_index;
771                                 pci_root_0().write_config(
772                                     self.common_header().bus_device_function,
773                                     cap_offset.into(),
774                                     mask,
775                                 );
776                             }
777                             false => {
778                                 let mut mask = pci_root_0().read_config(
779                                     self.common_header().bus_device_function,
780                                     (cap_offset + 12).into(),
781                                 );
782                                 mask |= 1 << irq_index;
783                                 pci_root_0().write_config(
784                                     self.common_header().bus_device_function,
785                                     cap_offset.into(),
786                                     mask,
787                                 );
788                             }
789                         }
790                         return Ok(0);
791                     }
792                     return Err(PciError::PciIrqError(PciIrqError::MaskNotSupported));
793                 }
794                 IrqType::Unused => {
795                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
796                 }
797                 _ => {
798                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
799                 }
800             }
801         }
802         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
803     }
804     /// @brief 屏蔽相应位置的中断(MSIX)
805     /// @param self PCI设备的可变引用
806     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
msix_mask(&mut self, irq_index: u16) -> Result<u8, PciError>807     fn msix_mask(&mut self, irq_index: u16) -> Result<u8, PciError> {
808         if let Some(irq_type) = self.irq_type_mut() {
809             match *irq_type {
810                 IrqType::Msix {
811                     irq_max_num,
812                     msix_table_bar,
813                     msix_table_offset,
814                     ..
815                 } => {
816                     if irq_index >= irq_max_num {
817                         return Err(PciError::PciIrqError(PciIrqError::InvalidIrqIndex(
818                             irq_index,
819                         )));
820                     }
821                     let pcistandardbar = self
822                         .bar()
823                         .ok_or(PciError::PciIrqError(PciIrqError::PciBarNotInited))
824                         .unwrap();
825                     let msix_bar = pcistandardbar.get_bar(msix_table_bar).unwrap();
826                     let vaddr = msix_bar.virtual_address().unwrap()
827                         + msix_table_offset as usize
828                         + irq_index as usize * size_of::<MsixEntry>();
829                     let msix_entry = NonNull::new(vaddr.data() as *mut MsixEntry).unwrap();
830                     unsafe {
831                         volwrite!(msix_entry, vector_control, 1);
832                     }
833                     return Ok(0);
834                 }
835                 IrqType::Unused => {
836                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
837                 }
838                 _ => {
839                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
840                 }
841             }
842         }
843         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
844     }
845     /// @brief 解除屏蔽相应位置的中断
846     /// @param self PCI设备的可变引用
847     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
irq_unmask(&mut self, irq_index: u16) -> Result<u8, PciError>848     fn irq_unmask(&mut self, irq_index: u16) -> Result<u8, PciError> {
849         if let Some(irq_type) = self.irq_type_mut() {
850             match *irq_type {
851                 IrqType::Msix { .. } => {
852                     return self.msix_unmask(irq_index);
853                 }
854                 IrqType::Msi { .. } => {
855                     return self.msi_unmask(irq_index);
856                 }
857                 IrqType::Unused => {
858                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
859                 }
860                 _ => {
861                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeNotSupported));
862                 }
863             }
864         }
865         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
866     }
867     /// @brief 解除屏蔽相应位置的中断（MSI）
868     /// @param self PCI设备的可变引用
869     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
msi_unmask(&mut self, irq_index: u16) -> Result<u8, PciError>870     fn msi_unmask(&mut self, irq_index: u16) -> Result<u8, PciError> {
871         if let Some(irq_type) = self.irq_type_mut() {
872             match *irq_type {
873                 IrqType::Msi {
874                     maskable,
875                     address_64,
876                     cap_offset,
877                     irq_max_num,
878                 } => {
879                     if irq_index >= irq_max_num {
880                         return Err(PciError::PciIrqError(PciIrqError::InvalidIrqIndex(
881                             irq_index,
882                         )));
883                     }
884                     if maskable {
885                         match address_64 {
886                             true => {
887                                 let mut mask = pci_root_0().read_config(
888                                     self.common_header().bus_device_function,
889                                     (cap_offset + 16).into(),
890                                 );
891                                 mask &= !(1 << irq_index);
892                                 pci_root_0().write_config(
893                                     self.common_header().bus_device_function,
894                                     cap_offset.into(),
895                                     mask,
896                                 );
897                             }
898                             false => {
899                                 let mut mask = pci_root_0().read_config(
900                                     self.common_header().bus_device_function,
901                                     (cap_offset + 12).into(),
902                                 );
903                                 mask &= !(1 << irq_index);
904                                 pci_root_0().write_config(
905                                     self.common_header().bus_device_function,
906                                     cap_offset.into(),
907                                     mask,
908                                 );
909                             }
910                         }
911                     }
912                     return Err(PciError::PciIrqError(PciIrqError::MaskNotSupported));
913                 }
914                 IrqType::Unused => {
915                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
916                 }
917                 _ => {
918                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
919                 }
920             }
921         }
922         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
923     }
924     /// @brief 解除屏蔽相应位置的中断(MSIX)
925     /// @param self PCI设备的可变引用
926     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
msix_unmask(&mut self, irq_index: u16) -> Result<u8, PciError>927     fn msix_unmask(&mut self, irq_index: u16) -> Result<u8, PciError> {
928         if let Some(irq_type) = self.irq_type_mut() {
929             match *irq_type {
930                 IrqType::Msix {
931                     irq_max_num,
932                     msix_table_bar,
933                     msix_table_offset,
934                     ..
935                 } => {
936                     if irq_index >= irq_max_num {
937                         return Err(PciError::PciIrqError(PciIrqError::InvalidIrqIndex(
938                             irq_index,
939                         )));
940                     }
941                     let pcistandardbar = self
942                         .bar()
943                         .ok_or(PciError::PciIrqError(PciIrqError::PciBarNotInited))
944                         .unwrap();
945                     let msix_bar = pcistandardbar.get_bar(msix_table_bar).unwrap();
946                     let vaddr = msix_bar.virtual_address().unwrap()
947                         + msix_table_offset as usize
948                         + irq_index as usize * size_of::<MsixEntry>();
949                     let msix_entry = NonNull::new(vaddr.data() as *mut MsixEntry).unwrap();
950                     unsafe {
951                         volwrite!(msix_entry, vector_control, 0);
952                     }
953                     return Ok(0);
954                 }
955                 IrqType::Unused => {
956                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
957                 }
958                 _ => {
959                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
960                 }
961             }
962         }
963         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
964     }
965     /// @brief 检查被挂起的中断是否在挂起的时候产生了
966     /// @param self PCI设备的可变引用
967     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
968     /// @return 是否在挂起过程中产生中断（异常情况也返回false）
irq_check_pending(&mut self, irq_index: u16) -> Result<bool, PciError>969     fn irq_check_pending(&mut self, irq_index: u16) -> Result<bool, PciError> {
970         if let Some(irq_type) = self.irq_type_mut() {
971             match *irq_type {
972                 IrqType::Msix { .. } => {
973                     return self.msix_check_pending(irq_index);
974                 }
975                 IrqType::Msi { .. } => {
976                     return self.msi_check_pending(irq_index);
977                 }
978                 IrqType::Unused => {
979                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
980                 }
981                 _ => {
982                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeNotSupported));
983                 }
984             }
985         }
986         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
987     }
988     /// @brief 检查被挂起的中断是否在挂起的时候产生了(MSI)
989     /// @param self PCI设备的可变引用
990     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
991     /// @return 是否在挂起过程中产生中断（异常情况也返回false）
msi_check_pending(&mut self, irq_index: u16) -> Result<bool, PciError>992     fn msi_check_pending(&mut self, irq_index: u16) -> Result<bool, PciError> {
993         if let Some(irq_type) = self.irq_type_mut() {
994             match *irq_type {
995                 IrqType::Msi {
996                     maskable,
997                     address_64,
998                     cap_offset,
999                     irq_max_num,
1000                 } => {
1001                     if irq_index >= irq_max_num {
1002                         return Err(PciError::PciIrqError(PciIrqError::InvalidIrqIndex(
1003                             irq_index,
1004                         )));
1005                     }
1006                     if maskable {
1007                         match address_64 {
1008                             true => {
1009                                 let mut pend = pci_root_0().read_config(
1010                                     self.common_header().bus_device_function,
1011                                     (cap_offset + 20).into(),
1012                                 );
1013                                 pend &= 1 << irq_index;
1014                                 return Ok(pend != 0);
1015                             }
1016                             false => {
1017                                 let mut pend = pci_root_0().read_config(
1018                                     self.common_header().bus_device_function,
1019                                     (cap_offset + 16).into(),
1020                                 );
1021                                 pend &= 1 << irq_index;
1022                                 return Ok(pend != 0);
1023                             }
1024                         }
1025                     }
1026                 }
1027                 IrqType::Unused => {
1028                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
1029                 }
1030                 _ => {
1031                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
1032                 }
1033             }
1034         }
1035         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
1036     }
1037     /// @brief 检查被挂起的中断是否在挂起的时候产生了(MSIX)
1038     /// @param self PCI设备的可变引用
1039     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
1040     /// @return 是否在挂起过程中产生中断（异常情况也返回false）
msix_check_pending(&mut self, irq_index: u16) -> Result<bool, PciError>1041     fn msix_check_pending(&mut self, irq_index: u16) -> Result<bool, PciError> {
1042         if let Some(irq_type) = self.irq_type_mut() {
1043             match *irq_type {
1044                 IrqType::Msix {
1045                     irq_max_num,
1046                     pending_table_bar,
1047                     pending_table_offset,
1048                     ..
1049                 } => {
1050                     if irq_index >= irq_max_num {
1051                         return Err(PciError::PciIrqError(PciIrqError::InvalidIrqIndex(
1052                             irq_index,
1053                         )));
1054                     }
1055                     let pcistandardbar = self
1056                         .bar()
1057                         .ok_or(PciError::PciIrqError(PciIrqError::PciBarNotInited))
1058                         .unwrap();
1059                     let pending_bar = pcistandardbar.get_bar(pending_table_bar).unwrap();
1060                     let vaddr = pending_bar.virtual_address().unwrap()
1061                         + pending_table_offset as usize
1062                         + (irq_index as usize / 64) * size_of::<PendingEntry>();
1063                     let pending_entry = NonNull::new(vaddr.data() as *mut PendingEntry).unwrap();
1064                     let pending_entry = unsafe { volread!(pending_entry, entry) };
1065                     return Ok(pending_entry & (1 << (irq_index as u64 % 64)) != 0);
1066                 }
1067                 IrqType::Unused => {
1068                     return Err(PciError::PciIrqError(PciIrqError::IrqNotInited));
1069                 }
1070                 _ => {
1071                     return Err(PciError::PciIrqError(PciIrqError::IrqTypeUnmatch));
1072                 }
1073             }
1074         }
1075         return Err(PciError::PciIrqError(PciIrqError::PciDeviceNotSupportIrq));
1076     }
1077 }
1078 /// PCI标准设备的msi/msix中断相关函数块
1079 impl PciInterrupt for PciDeviceStructureGeneralDevice {}
1080