1 use core::{ 2 any::Any, 3 fmt::Debug, 4 sync::atomic::{AtomicI64, Ordering}, 5 }; 6 7 use alloc::{ 8 collections::{btree_map, BTreeMap}, 9 string::{String, ToString}, 10 sync::{Arc, Weak}, 11 vec::Vec, 12 }; 13 use system_error::SystemError; 14 15 use crate::{ 16 arch::{interrupt::TrapFrame, CurrentIrqArch}, 17 driver::base::{ 18 device::DeviceId, 19 kobject::{KObjType, KObject, KObjectState, LockedKObjectState}, 20 kset::KSet, 21 }, 22 filesystem::kernfs::KernFSInode, 23 libs::{ 24 mutex::{Mutex, MutexGuard}, 25 rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard}, 26 spinlock::{SpinLock, SpinLockGuard}, 27 }, 28 process::ProcessControlBlock, 29 sched::completion::Completion, 30 }; 31 32 use super::{ 33 dummychip::no_irq_chip, 34 handle::bad_irq_handler, 35 irqdata::{IrqCommonData, IrqData, IrqHandlerData, IrqLineStatus, IrqStatus}, 36 sysfs::{irq_sysfs_del, IrqKObjType}, 37 HardwareIrqNumber, InterruptArch, IrqNumber, 38 }; 39 40 /// 中断流处理程序 41 pub trait IrqFlowHandler: Debug + Send + Sync + Any { 42 fn handle(&self, irq_desc: &Arc<IrqDesc>, trap_frame: &mut TrapFrame); 43 } 44 45 /// 中断处理程序 46 pub trait IrqHandler: Debug + Send + Sync + Any { 47 fn handle( 48 &self, 49 irq: IrqNumber, 50 static_data: Option<&dyn IrqHandlerData>, 51 dynamic_data: Option<Arc<dyn IrqHandlerData>>, 52 ) -> Result<IrqReturn, SystemError>; 53 } 54 55 /// 中断处理函数返回值 56 /// 57 /// 用于指示中断处理函数是否处理了中断 58 #[derive(Debug, Clone, Copy, PartialEq, Eq)] 59 pub enum IrqReturn { 60 /// 中断未被处理 61 NotHandled, 62 /// 中断已被处理 63 Handled, 64 /// 中断已被处理，并且需要唤醒中断线程 65 WakeThread, 66 } 67 68 /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/include/linux/irqdesc.h#55 69 #[derive(Debug)] 70 pub struct IrqDesc { 71 inner: SpinLock<InnerIrqDesc>, 72 73 handler: RwLock<Option<&'static dyn IrqFlowHandler>>, 74 /// 一个用于串行化 request_irq()和free_irq() 的互斥锁 75 request_mutex: Mutex<()>, 76 kobj_state: LockedKObjectState, 77 /// 当前描述符内正在运行的中断线程数 78 threads_active: AtomicI64, 79 } 80 81 impl IrqDesc { 82 #[inline(never)] 83 pub fn new(irq: IrqNumber, name: Option<String>, irqd_flags: IrqStatus) -> Arc<Self> { 84 // 初始化的过程参考 https://code.dragonos.org.cn/xref/linux-6.1.9/kernel/irq/irqdesc.c#392 85 let common_data = Arc::new(IrqCommonData::new()); 86 let irq_data = Arc::new(IrqData::new( 87 irq, 88 HardwareIrqNumber::new(irq.data()), 89 common_data.clone(), 90 no_irq_chip(), 91 )); 92 93 irq_data.irqd_set(IrqStatus::IRQD_IRQ_DISABLED); 94 common_data.insert_status(IrqStatus::IRQD_IRQ_MASKED); 95 96 let irq_desc = IrqDesc { 97 inner: SpinLock::new(InnerIrqDesc { 98 common_data, 99 irq_data, 100 desc_internal_state: IrqDescState::empty(), 101 line_status: IrqLineStatus::empty(), 102 actions: Vec::new(), 103 name, 104 parent_irq: None, 105 depth: 1, 106 wake_depth: 0, 107 kern_inode: None, 108 kset: None, 109 parent_kobj: None, 110 }), 111 request_mutex: Mutex::new(()), 112 handler: RwLock::new(None), 113 kobj_state: LockedKObjectState::new(Some(KObjectState::INITIALIZED)), 114 threads_active: AtomicI64::new(0), 115 }; 116 117 irq_desc.set_handler(bad_irq_handler()); 118 irq_desc.inner().irq_data.irqd_set(irqd_flags); 119 120 return Arc::new(irq_desc); 121 } 122 123 /// 返回当前活跃的中断线程数量 124 #[allow(dead_code)] 125 pub fn threads_active(&self) -> i64 { 126 self.threads_active.load(Ordering::SeqCst) 127 } 128 129 /// 增加当前活跃的中断线程数量, 返回增加前的值 130 pub fn inc_threads_active(&self) -> i64 { 131 self.threads_active.fetch_add(1, Ordering::SeqCst) 132 } 133 134 /// 减少当前活跃的中断线程数量, 返回减少前的值 135 #[allow(dead_code)] 136 pub fn dec_threads_active(&self) -> i64 { 137 self.threads_active.fetch_sub(1, Ordering::SeqCst) 138 } 139 140 pub fn set_handler(&self, handler: &'static dyn IrqFlowHandler) { 141 self.chip_bus_lock(); 142 let mut guard = self.handler.write_irqsave(); 143 *guard = Some(handler); 144 self.chip_bus_sync_unlock(); 145 } 146 147 pub fn handler(&self) -> Option<&'static dyn IrqFlowHandler> { 148 let guard = self.handler.read_irqsave(); 149 *guard 150 } 151 152 pub fn inner(&self) -> SpinLockGuard<InnerIrqDesc> { 153 self.inner.lock_irqsave() 154 } 155 156 pub fn actions(&self) -> Vec<Arc<IrqAction>> { 157 self.inner().actions.clone() 158 } 159 160 /// 对中断请求过程加锁 161 pub fn request_mutex_lock(&self) -> MutexGuard<()> { 162 self.request_mutex.lock() 163 } 164 165 pub fn irq(&self) -> IrqNumber { 166 self.inner().irq_data.irq() 167 } 168 169 pub fn hardware_irq(&self) -> HardwareIrqNumber { 170 self.inner().irq_data.hardware_irq() 171 } 172 173 pub fn irq_data(&self) -> Arc<IrqData> { 174 self.inner().irq_data.clone() 175 } 176 177 /// 标记当前irq描述符已经被添加到sysfs 178 pub fn mark_in_sysfs(&self) { 179 self.inner() 180 .desc_internal_state 181 .insert(IrqDescState::IRQS_SYSFS); 182 } 183 184 pub fn mark_not_in_sysfs(&self) { 185 self.inner() 186 .desc_internal_state 187 .remove(IrqDescState::IRQS_SYSFS); 188 } 189 190 /// 判断当前描述符是否已经添加到了sysfs 191 pub fn in_sysfs(&self) -> bool { 192 self.inner() 193 .desc_internal_state 194 .contains(IrqDescState::IRQS_SYSFS) 195 } 196 197 pub fn name(&self) -> Option<String> { 198 self.inner().name.clone() 199 } 200 201 pub fn can_request(&self) -> bool { 202 self.inner().can_request() 203 } 204 205 #[allow(dead_code)] 206 pub fn set_norequest(&self) { 207 self.inner().set_norequest(); 208 } 209 210 #[allow(dead_code)] 211 pub fn clear_norequest(&self) { 212 self.inner().clear_norequest(); 213 } 214 215 pub fn nested_thread(&self) -> bool { 216 self.inner().nested_thread() 217 } 218 219 /// 中断是否可以线程化 220 pub fn can_thread(&self) -> bool { 221 !self 222 .inner() 223 .line_status 224 .contains(IrqLineStatus::IRQ_NOTHREAD) 225 } 226 227 pub fn chip_bus_lock(&self) { 228 let irq_data = self.inner().irq_data.clone(); 229 irq_data 230 .chip_info_read_irqsave() 231 .chip() 232 .irq_bus_lock(&irq_data) 233 .ok(); 234 } 235 236 /// 同步释放低速总线锁 237 /// 238 /// ## 锁 239 /// 240 /// 进入此函数时，必须持有低速总线锁，并且desc的inner锁和irqdata的inner锁 241 /// 必须已经释放。否则将死锁。 242 pub fn chip_bus_sync_unlock(&self) { 243 let irq_data = self.inner().irq_data.clone(); 244 irq_data 245 .chip_info_write_irqsave() 246 .chip() 247 .irq_bus_sync_unlock(&irq_data) 248 .ok(); 249 } 250 251 pub fn modify_status(&self, clear: IrqLineStatus, set: IrqLineStatus) { 252 let mut desc_guard = self.inner(); 253 desc_guard.line_status.remove(clear); 254 desc_guard.line_status.insert(set); 255 256 let mut trigger = desc_guard.common_data().trigger_type(); 257 258 desc_guard.common_data().clear_status( 259 IrqStatus::IRQD_NO_BALANCING 260 | IrqStatus::IRQD_PER_CPU 261 | IrqStatus::IRQD_TRIGGER_MASK 262 | IrqStatus::IRQD_LEVEL 263 | IrqStatus::IRQD_MOVE_PCNTXT, 264 ); 265 266 if desc_guard 267 .line_status 268 .contains(IrqLineStatus::IRQ_NO_BALANCING) 269 { 270 desc_guard 271 .common_data() 272 .insert_status(IrqStatus::IRQD_NO_BALANCING); 273 } 274 275 if desc_guard.line_status.contains(IrqLineStatus::IRQ_PER_CPU) { 276 desc_guard 277 .common_data() 278 .insert_status(IrqStatus::IRQD_PER_CPU); 279 } 280 281 if desc_guard 282 .line_status 283 .contains(IrqLineStatus::IRQ_MOVE_PCNTXT) 284 { 285 desc_guard 286 .common_data() 287 .insert_status(IrqStatus::IRQD_MOVE_PCNTXT); 288 } 289 290 if desc_guard.line_status.is_level_type() { 291 desc_guard 292 .common_data() 293 .insert_status(IrqStatus::IRQD_LEVEL); 294 } 295 296 let tmp = desc_guard.line_status.trigger_type(); 297 298 if tmp != IrqLineStatus::IRQ_TYPE_NONE { 299 trigger = tmp; 300 } 301 302 desc_guard.common_data().set_trigger_type(trigger); 303 } 304 } 305 306 #[allow(dead_code)] 307 #[derive(Debug)] 308 pub struct InnerIrqDesc { 309 /// per irq and chip data passed down to chip functions 310 common_data: Arc<IrqCommonData>, 311 irq_data: Arc<IrqData>, 312 actions: Vec<Arc<IrqAction>>, 313 name: Option<String>, 314 parent_irq: Option<IrqNumber>, 315 /// nested irq disables 316 depth: u32, 317 /// nested wake enables 318 wake_depth: u32, 319 desc_internal_state: IrqDescState, 320 /// 中断线的状态 321 line_status: IrqLineStatus, 322 323 kern_inode: Option<Arc<KernFSInode>>, 324 kset: Option<Arc<KSet>>, 325 parent_kobj: Option<Weak<dyn KObject>>, 326 // wait_for_threads: EventWaitQueue 327 } 328 329 impl InnerIrqDesc { 330 pub fn name(&self) -> Option<&String> { 331 self.name.as_ref() 332 } 333 334 pub fn can_request(&self) -> bool { 335 !self.line_status.contains(IrqLineStatus::IRQ_NOREQUEST) 336 } 337 338 #[allow(dead_code)] 339 pub fn set_norequest(&mut self) { 340 self.line_status.insert(IrqLineStatus::IRQ_NOREQUEST); 341 } 342 343 #[allow(dead_code)] 344 pub fn clear_norequest(&mut self) { 345 self.line_status.remove(IrqLineStatus::IRQ_NOREQUEST); 346 } 347 348 pub fn nested_thread(&self) -> bool { 349 self.line_status.contains(IrqLineStatus::IRQ_NESTED_THREAD) 350 } 351 352 pub fn line_status_set_per_cpu(&mut self) { 353 self.line_status.insert(IrqLineStatus::IRQ_PER_CPU); 354 } 355 356 #[allow(dead_code)] 357 pub fn line_status_clear_per_cpu(&mut self) { 358 self.line_status.remove(IrqLineStatus::IRQ_PER_CPU); 359 } 360 361 #[allow(dead_code)] 362 pub fn line_status(&self) -> &IrqLineStatus { 363 &self.line_status 364 } 365 366 pub fn line_status_set_no_debug(&mut self) { 367 self.line_status.insert(IrqLineStatus::IRQ_NO_BALANCING); 368 } 369 370 #[allow(dead_code)] 371 pub fn line_status_clear_no_debug(&mut self) { 372 self.line_status.remove(IrqLineStatus::IRQ_NO_BALANCING); 373 } 374 375 pub fn can_autoenable(&self) -> bool { 376 !self.line_status.contains(IrqLineStatus::IRQ_NOAUTOEN) 377 } 378 379 pub fn can_thread(&self) -> bool { 380 !self.line_status.contains(IrqLineStatus::IRQ_NOTHREAD) 381 } 382 383 /// 中断是否可以设置CPU亲和性 384 pub fn can_set_affinity(&self) -> bool { 385 if self.common_data.status().can_balance() == false 386 || self 387 .irq_data() 388 .chip_info_read_irqsave() 389 .chip() 390 .can_set_affinity() 391 == false 392 { 393 return false; 394 } 395 396 return true; 397 } 398 399 pub fn actions(&self) -> &Vec<Arc<IrqAction>> { 400 &self.actions 401 } 402 403 pub fn add_action(&mut self, action: Arc<IrqAction>) { 404 self.actions.push(action); 405 } 406 407 pub fn internal_state(&self) -> &IrqDescState { 408 &self.desc_internal_state 409 } 410 411 pub(super) fn internal_state_mut(&mut self) -> &mut IrqDescState { 412 &mut self.desc_internal_state 413 } 414 415 pub fn irq_data(&self) -> &Arc<IrqData> { 416 &self.irq_data 417 } 418 419 pub fn common_data(&self) -> &Arc<IrqCommonData> { 420 &self.common_data 421 } 422 423 pub fn depth(&self) -> u32 { 424 self.depth 425 } 426 427 pub fn wake_depth(&self) -> u32 { 428 self.wake_depth 429 } 430 431 pub fn set_depth(&mut self, depth: u32) { 432 self.depth = depth; 433 } 434 435 pub fn set_trigger_type(&mut self, trigger: IrqLineStatus) { 436 self.line_status.remove(IrqLineStatus::IRQ_TYPE_SENSE_MASK); 437 self.line_status 438 .insert(trigger & IrqLineStatus::IRQ_TYPE_SENSE_MASK); 439 } 440 441 pub fn clear_level(&mut self) { 442 self.line_status.remove(IrqLineStatus::IRQ_LEVEL); 443 } 444 445 pub fn set_level(&mut self) { 446 self.line_status.insert(IrqLineStatus::IRQ_LEVEL); 447 } 448 } 449 450 impl KObject for IrqDesc { 451 fn as_any_ref(&self) -> &dyn Any { 452 self 453 } 454 455 fn set_inode(&self, inode: Option<Arc<KernFSInode>>) { 456 self.inner().kern_inode = inode; 457 } 458 459 fn inode(&self) -> Option<Arc<KernFSInode>> { 460 self.inner().kern_inode.clone() 461 } 462 463 fn parent(&self) -> Option<Weak<dyn KObject>> { 464 self.inner().parent_kobj.clone() 465 } 466 467 fn set_parent(&self, parent: Option<Weak<dyn KObject>>) { 468 self.inner().parent_kobj = parent; 469 } 470 471 fn kset(&self) -> Option<Arc<KSet>> { 472 self.inner().kset.clone() 473 } 474 475 fn set_kset(&self, kset: Option<Arc<KSet>>) { 476 self.inner().kset = kset; 477 } 478 479 fn kobj_type(&self) -> Option<&'static dyn KObjType> { 480 Some(&IrqKObjType) 481 } 482 483 fn set_kobj_type(&self, _ktype: Option<&'static dyn KObjType>) {} 484 485 fn name(&self) -> String { 486 self.inner().irq_data.irq().data().to_string() 487 } 488 489 fn set_name(&self, _name: String) {} 490 491 fn kobj_state(&self) -> RwLockReadGuard<KObjectState> { 492 self.kobj_state.read() 493 } 494 495 fn kobj_state_mut(&self) -> RwLockWriteGuard<KObjectState> { 496 self.kobj_state.write() 497 } 498 499 fn set_kobj_state(&self, state: KObjectState) { 500 *self.kobj_state_mut() = state; 501 } 502 } 503 504 bitflags! { 505 /// Bit masks for desc->desc_internal_state 506 pub struct IrqDescState: u32 { 507 /// autodetection in progress 508 const IRQS_AUTODETECT = 0x00000001; 509 /// was disabled due to spurious interrupt detection 510 const IRQS_SPURIOUS_DISABLED = 0x00000002; 511 /// polling in progress 512 const IRQS_POLL_INPROGRESS = 0x00000008; 513 /// irq is not unmasked in primary handler 514 const IRQS_ONESHOT = 0x00000020; 515 /// irq is replayed 516 const IRQS_REPLAY = 0x00000040; 517 /// irq is waiting 518 const IRQS_WAITING = 0x00000080; 519 /// irq is pending and replayed later 520 const IRQS_PENDING = 0x00000200; 521 /// irq is suspended 522 const IRQS_SUSPENDED = 0x00000800; 523 /// irq line is used to deliver NMIs 524 const IRQS_NMI = 0x00002000; 525 /// descriptor has been added to sysfs 526 const IRQS_SYSFS = 0x00004000; 527 } 528 } 529 530 /// 每个中断的响应动作的描述符 531 /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/include/linux/interrupt.h#118 532 #[allow(dead_code)] 533 #[derive(Debug)] 534 pub struct IrqAction { 535 inner: SpinLock<InnerIrqAction>, 536 /// 用于等待线程被创建的完成量 537 thread_completion: Completion, 538 } 539 540 impl IrqAction { 541 #[allow(dead_code)] 542 pub fn new( 543 irq: IrqNumber, 544 name: String, 545 handler: Option<&'static dyn IrqHandler>, 546 thread_fn: Option<&'static dyn IrqHandler>, 547 ) -> Arc<Self> { 548 let action: IrqAction = IrqAction { 549 inner: SpinLock::new(InnerIrqAction { 550 dev_id: None, 551 handler, 552 thread_fn, 553 thread: None, 554 secondary: None, 555 irq, 556 flags: IrqHandleFlags::empty(), 557 name, 558 thread_flags: ThreadedHandlerFlags::empty(), 559 }), 560 thread_completion: Completion::new(), 561 }; 562 563 return Arc::new(action); 564 } 565 566 pub fn inner(&self) -> SpinLockGuard<InnerIrqAction> { 567 self.inner.lock_irqsave() 568 } 569 570 pub fn thread_completion(&self) -> &Completion { 571 &self.thread_completion 572 } 573 } 574 575 #[allow(dead_code)] 576 #[derive(Debug)] 577 pub struct InnerIrqAction { 578 /// cookie to identify the device 579 dev_id: Option<Arc<DeviceId>>, 580 /// 中断处理程序 581 handler: Option<&'static dyn IrqHandler>, 582 /// interrupt handler function for threaded interrupts 583 thread_fn: Option<&'static dyn IrqHandler>, 584 /// thread pointer for threaded interrupts 585 thread: Option<Arc<ProcessControlBlock>>, 586 /// pointer to secondary irqaction (force threading) 587 secondary: Option<Arc<IrqAction>>, 588 /// 中断号 589 irq: IrqNumber, 590 flags: IrqHandleFlags, 591 /// 中断线程的标志 592 thread_flags: ThreadedHandlerFlags, 593 /// name of the device 594 name: String, 595 } 596 597 impl InnerIrqAction { 598 pub fn dev_id(&self) -> &Option<Arc<DeviceId>> { 599 &self.dev_id 600 } 601 602 pub fn dev_id_mut(&mut self) -> &mut Option<Arc<DeviceId>> { 603 &mut self.dev_id 604 } 605 606 pub fn handler(&self) -> Option<&'static dyn IrqHandler> { 607 self.handler 608 } 609 610 pub fn set_handler(&mut self, handler: Option<&'static dyn IrqHandler>) { 611 self.handler = handler; 612 } 613 614 pub fn thread_fn(&self) -> Option<&'static dyn IrqHandler> { 615 self.thread_fn 616 } 617 618 pub fn thread(&self) -> Option<Arc<ProcessControlBlock>> { 619 self.thread.clone() 620 } 621 622 pub fn set_thread(&mut self, thread: Option<Arc<ProcessControlBlock>>) { 623 self.thread = thread; 624 } 625 626 #[allow(dead_code)] 627 pub fn thread_flags(&self) -> &ThreadedHandlerFlags { 628 &self.thread_flags 629 } 630 631 pub fn thread_flags_mut(&mut self) -> &mut ThreadedHandlerFlags { 632 &mut self.thread_flags 633 } 634 635 pub fn secondary(&self) -> Option<Arc<IrqAction>> { 636 self.secondary.clone() 637 } 638 639 #[allow(dead_code)] 640 pub fn irq(&self) -> IrqNumber { 641 self.irq 642 } 643 644 #[allow(dead_code)] 645 pub fn set_irq(&mut self, irq: IrqNumber) { 646 self.irq = irq; 647 } 648 649 pub fn flags(&self) -> &IrqHandleFlags { 650 &self.flags 651 } 652 653 pub fn flags_mut(&mut self) -> &mut IrqHandleFlags { 654 &mut self.flags 655 } 656 657 pub fn name(&self) -> &String { 658 &self.name 659 } 660 } 661 662 bitflags! { 663 /// 这些标志由线程处理程序使用 664 pub struct ThreadedHandlerFlags: u32 { 665 /// IRQTF_RUNTHREAD - 表示应运行中断处理程序线程 666 const IRQTF_RUNTHREAD = 1 << 0; 667 /// IRQTF_WARNED - 已打印警告 "IRQ_WAKE_THREAD w/o thread_fn" 668 const IRQTF_WARNED = 1 << 1; 669 /// IRQTF_AFFINITY - 请求irq线程调整亲和性 670 const IRQTF_AFFINITY = 1 << 2; 671 /// IRQTF_FORCED_THREAD - irq操作被强制线程化 672 const IRQTF_FORCED_THREAD = 1 << 3; 673 /// IRQTF_READY - 表示irq线程已准备就绪 674 const IRQTF_READY = 1 << 4; 675 } 676 } 677 678 /// Implements the `ThreadedHandlerFlags` structure. 679 impl ThreadedHandlerFlags { 680 /// 在 `ThreadedHandlerFlags` 结构中测试并设置特定的位。 681 /// 682 /// # 参数 683 /// 684 /// * `bit` - 要测试并设置的位。 685 /// 686 /// # 返回 687 /// 688 /// 如果操作前该位已被设置，则返回 `true`，否则返回 `false`。 689 pub fn test_and_set_bit(&mut self, bit: ThreadedHandlerFlags) -> bool { 690 let res = (self.bits & bit.bits) != 0; 691 self.bits |= bit.bits; 692 return res; 693 } 694 } 695 696 // 定义IrqFlags位标志 697 bitflags! { 698 /// 这些标志仅由内核在中断处理例程中使用。 699 pub struct IrqHandleFlags: u32 { 700 701 const IRQF_TRIGGER_NONE = IrqLineStatus::IRQ_TYPE_NONE.bits(); 702 const IRQF_TRIGGER_RISING = IrqLineStatus::IRQ_TYPE_EDGE_RISING.bits(); 703 const IRQF_TRIGGER_FALLING = IrqLineStatus::IRQ_TYPE_EDGE_FALLING.bits(); 704 const IRQF_TRIGGER_HIGH = IrqLineStatus::IRQ_TYPE_LEVEL_HIGH.bits(); 705 const IRQF_TRIGGER_LOW = IrqLineStatus::IRQ_TYPE_LEVEL_LOW.bits(); 706 const IRQF_TRIGGER_MASK = Self::IRQF_TRIGGER_HIGH.bits | Self::IRQF_TRIGGER_LOW.bits | Self::IRQF_TRIGGER_RISING.bits | Self::IRQF_TRIGGER_FALLING.bits; 707 /// IRQF_SHARED - 允许多个设备共享中断 708 const IRQF_SHARED = 0x00000080; 709 /// IRQF_PROBE_SHARED - 当预期出现共享不匹配时，由调用者设置 710 const IRQF_PROBE_SHARED = 0x00000100; 711 /// IRQF_TIMER - 标记此中断为定时器中断 712 const __IRQF_TIMER = 0x00000200; 713 /// IRQF_PERCPU - 中断是每个CPU的 714 const IRQF_PERCPU = 0x00000400; 715 /// IRQF_NOBALANCING - 将此中断从中断平衡中排除 716 const IRQF_NOBALANCING = 0x00000800; 717 /// IRQF_IRQPOLL - 中断用于轮询（出于性能原因，只有在共享中断中首次注册的中断会被考虑） 718 const IRQF_IRQPOLL = 0x00001000; 719 /// IRQF_ONESHOT - 在硬中断处理程序完成后，不会重新启用中断。由需要在运行线程处理程序之前保持中断线路禁用的线程中断使用。 720 const IRQF_ONESHOT = 0x00002000; 721 /// IRQF_NO_SUSPEND - 在挂起期间不禁用此IRQ。不能保证此中断会从挂起状态唤醒系统。 722 const IRQF_NO_SUSPEND = 0x00004000; 723 /// IRQF_FORCE_RESUME - 即使设置了IRQF_NO_SUSPEND，也强制在恢复时启用它 724 const IRQF_FORCE_RESUME = 0x00008000; 725 /// IRQF_NO_THREAD - 中断不能被线程化 726 const IRQF_NO_THREAD = 0x00010000; 727 /// IRQF_EARLY_RESUME - 在syscore而不是在设备恢复时间早期恢复IRQ。 728 const IRQF_EARLY_RESUME = 0x00020000; 729 /// IRQF_COND_SUSPEND - 如果IRQ与NO_SUSPEND用户共享，则在挂起中断后执行此中断处理程序。对于系统唤醒设备用户，需要在他们的中断处理程序中实现唤醒检测。 730 const IRQF_COND_SUSPEND = 0x00040000; 731 /// IRQF_NO_AUTOEN - 当用户请求时，不会自动启用IRQ或NMI。用户稍后会通过enable_irq()或enable_nmi()显式启用它。 732 const IRQF_NO_AUTOEN = 0x00080000; 733 /// IRQF_NO_DEBUG - 从IPI和类似处理程序的逃逸检测中排除，取决于IRQF_PERCPU。 734 const IRQF_NO_DEBUG = 0x00100000; 735 const IRQF_TIMER = Self::__IRQF_TIMER.bits | Self::IRQF_NO_SUSPEND.bits | Self::IRQF_NO_THREAD.bits; 736 } 737 } 738 739 impl IrqHandleFlags { 740 /// 检查是否指定了触发类型 741 #[inline(always)] 742 pub fn trigger_type_specified(&self) -> bool { 743 (self.bits & Self::IRQF_TRIGGER_MASK.bits) != 0 744 } 745 746 /// 插入触发类型 747 pub fn insert_trigger_type(&mut self, trigger: IrqLineStatus) { 748 self.bits |= trigger.trigger_bits() & IrqHandleFlags::IRQF_TRIGGER_MASK.bits; 749 } 750 751 #[allow(dead_code)] 752 pub fn remove_trigger_type(&mut self, trigger: IrqLineStatus) { 753 self.bits &= !(trigger.trigger_bits() & IrqHandleFlags::IRQF_TRIGGER_MASK.bits); 754 } 755 756 pub fn trigger_type(&self) -> IrqLineStatus { 757 IrqLineStatus::from_bits_truncate(self.bits & IrqHandleFlags::IRQF_TRIGGER_MASK.bits) 758 } 759 } 760 761 #[inline(never)] 762 pub(super) fn early_irq_init() -> Result<(), SystemError> { 763 let irqcnt = CurrentIrqArch::probe_total_irq_num(); 764 let mut manager = IrqDescManager::new(); 765 for i in 0..irqcnt { 766 let irq_desc = IrqDesc::new(IrqNumber::new(i), None, IrqStatus::empty()); 767 manager.insert(IrqNumber::new(i), irq_desc); 768 } 769 770 unsafe { 771 IRQ_DESC_MANAGER = Some(manager); 772 } 773 774 return CurrentIrqArch::arch_early_irq_init(); 775 } 776 777 static mut IRQ_DESC_MANAGER: Option<IrqDescManager> = None; 778 779 /// 获取中断描述符管理器的引用 780 #[inline(always)] 781 pub fn irq_desc_manager() -> &'static IrqDescManager { 782 return unsafe { IRQ_DESC_MANAGER.as_ref().unwrap() }; 783 } 784 785 pub struct IrqDescManager { 786 irq_descs: BTreeMap<IrqNumber, Arc<IrqDesc>>, 787 } 788 789 impl IrqDescManager { 790 fn new() -> Self { 791 IrqDescManager { 792 irq_descs: BTreeMap::new(), 793 } 794 } 795 796 /// 查找中断描述符 797 pub fn lookup(&self, irq: IrqNumber) -> Option<Arc<IrqDesc>> { 798 self.irq_descs.get(&irq).map(|desc| desc.clone()) 799 } 800 801 fn insert(&mut self, irq: IrqNumber, desc: Arc<IrqDesc>) { 802 self.irq_descs.insert(irq, desc); 803 } 804 805 /// 释放中断描述符 806 #[allow(dead_code)] 807 fn free_desc(&mut self, irq: IrqNumber) { 808 if let Some(desc) = self.irq_descs.get(&irq) { 809 irq_sysfs_del(desc); 810 self.irq_descs.remove(&irq); 811 } 812 } 813 814 /// 迭代中断描述符 815 pub fn iter_descs(&self) -> btree_map::Iter<'_, IrqNumber, Arc<IrqDesc>> { 816 self.irq_descs.iter() 817 } 818 } 819