1 use core::ops::{BitXor, Deref, DerefMut};
2
3 use alloc::{string::String, sync::Arc};
4
5 use log::{debug, error, warn};
6 use system_error::SystemError;
7
8 use crate::{
9 driver::base::device::DeviceId,
10 exception::{
11 irqchip::IrqChipSetMaskResult,
12 irqdesc::{irq_desc_manager, InnerIrqDesc, IrqAction},
13 },
14 libs::{cpumask::CpuMask, spinlock::SpinLockGuard},
15 process::{kthread::KernelThreadMechanism, ProcessManager},
16 smp::cpu::ProcessorId,
17 };
18
19 use super::{
20 dummychip::no_irq_chip,
21 irqchip::IrqChipFlags,
22 irqdata::{IrqData, IrqHandlerData, IrqLineStatus, IrqStatus},
23 irqdesc::{InnerIrqAction, IrqDesc, IrqDescState, IrqHandleFlags, IrqHandler, IrqReturn},
24 irqdomain::irq_domain_manager,
25 IrqNumber,
26 };
27
28 lazy_static! {
29 /// 默认的中断亲和性
30 static ref IRQ_DEFAULT_AFFINITY: CpuMask = {
31 let mut mask = CpuMask::new();
32 // 默认情况下，中断处理程序将在第一个处理器上运行
33 mask.set(ProcessorId::new(0), true);
34 mask
35 };
36 }
37
irq_manager() -> &'static IrqManager38 pub fn irq_manager() -> &'static IrqManager {
39 &IrqManager
40 }
41
42 /// 中断管理器
43 pub struct IrqManager;
44
45 impl IrqManager {
46 pub const IRQ_RESEND: bool = true;
47 #[allow(dead_code)]
48 pub const IRQ_NORESEND: bool = false;
49 #[allow(dead_code)]
50 pub const IRQ_START_FORCE: bool = true;
51 pub const IRQ_START_COND: bool = false;
52
53 /// 在中断线上添加一个处理函数
54 ///
55 /// ## 参数
56 ///
57 /// - irq: 虚拟中断号(中断线号)
58 /// - name: 生成该中断的设备名称
59 /// - handler: 中断处理函数
60 /// - flags: 中断处理标志
61 /// - dev_id: 一个用于标识设备的cookie
request_irq( &self, irq: IrqNumber, name: String, handler: &'static dyn IrqHandler, flags: IrqHandleFlags, dev_id: Option<Arc<DeviceId>>, ) -> Result<(), SystemError>62 pub fn request_irq(
63 &self,
64 irq: IrqNumber,
65 name: String,
66 handler: &'static dyn IrqHandler,
67 flags: IrqHandleFlags,
68 dev_id: Option<Arc<DeviceId>>,
69 ) -> Result<(), SystemError> {
70 return self.request_threaded_irq(irq, Some(handler), None, flags, name, dev_id);
71 }
72
73 /// 在中断线上添加一个处理函数（可以是线程化的中断）
74 ///
75 /// ## 参数
76 ///
77 /// - irq: 虚拟中断号
78 /// - handler: 当中断发生时将被调用的函数，是
79 /// 线程化中断的初级处理程序。如果handler为`None`并且thread_fn不为`None`，
80 /// 将安装默认的初级处理程序
81 /// - thread_fn: 在中断处理程序线程中调用的函数. 如果为`None`，则不会创建irq线程
82 /// - flags: 中断处理标志
83 /// - IRQF_SHARED: 中断是共享的
84 /// - IRQF_TRIGGER*: 指定中断触发方式
85 /// - IRQF_ONESHOT: 在thread_fn中运行时，中断线被遮蔽
86 /// - dev_name: 生成该中断的设备名称
87 /// - dev_id: 一个用于标识设备的cookie
88 ///
89 /// ## 说明
90 ///
91 /// 此调用分配中断资源并启用中断线和IRQ处理。
92 /// 从这一点开始，您的处理程序函数可能会被调用。
93 /// 因此，您必须确保首先初始化您的硬件，
94 /// 并确保以正确的顺序设置中断处理程序。
95 ///
96 /// 如果您想为您的设备设置线程化中断处理程序
97 /// 则需要提供@handler和@thread_fn。@handler仍然
98 /// 在硬中断上下文中调用，并且必须检查
99 /// 中断是否来自设备。如果是，它需要禁用设备上的中断
100 /// 并返回IRQ_WAKE_THREAD，这将唤醒处理程序线程并运行
101 /// @thread_fn。这种拆分处理程序设计是为了支持
102 /// 共享中断。
103 ///
104 /// dev_id必须是全局唯一的。通常使用设备数据结构的地址或者uuid
105 /// 作为cookie。由于处理程序接收这个值，因此使用它是有意义的。
106 ///
107 /// 如果您的中断是共享的，您必须传递一个非NULL的dev_id
108 /// 因为当释放中断时需要它。
request_threaded_irq( &self, irq: IrqNumber, mut handler: Option<&'static dyn IrqHandler>, thread_fn: Option<&'static dyn IrqHandler>, flags: IrqHandleFlags, dev_name: String, dev_id: Option<Arc<DeviceId>>, ) -> Result<(), SystemError>109 pub fn request_threaded_irq(
110 &self,
111 irq: IrqNumber,
112 mut handler: Option<&'static dyn IrqHandler>,
113 thread_fn: Option<&'static dyn IrqHandler>,
114 flags: IrqHandleFlags,
115 dev_name: String,
116 dev_id: Option<Arc<DeviceId>>,
117 ) -> Result<(), SystemError> {
118 if irq == IrqNumber::IRQ_NOTCONNECTED {
119 return Err(SystemError::ENOTCONN);
120 }
121
122 // 逻辑检查：共享中断必须传入一个真正的设备ID，
123 // 否则后来我们将难以确定哪个中断是哪个（会搞乱中断释放逻辑等）。
124 // 此外，共享中断与禁用自动使能不相符。 共享中断可能在仍然禁用时请求它，然后永远等待中断。
125 // 另外，IRQF_COND_SUSPEND 仅适用于共享中断，并且它不能与 IRQF_NO_SUSPEND 同时设置。
126
127 if ((flags.contains(IrqHandleFlags::IRQF_SHARED)) && dev_id.is_none())
128 || ((flags.contains(IrqHandleFlags::IRQF_SHARED))
129 && (flags.contains(IrqHandleFlags::IRQF_NO_AUTOEN)))
130 || (!(flags.contains(IrqHandleFlags::IRQF_SHARED))
131 && (flags.contains(IrqHandleFlags::IRQF_COND_SUSPEND)))
132 || ((flags.contains(IrqHandleFlags::IRQF_NO_SUSPEND))
133 && (flags.contains(IrqHandleFlags::IRQF_COND_SUSPEND)))
134 {
135 return Err(SystemError::EINVAL);
136 }
137 let desc = irq_desc_manager().lookup(irq).ok_or(SystemError::EINVAL)?;
138 if !desc.can_request() {
139 warn!("desc {} can not request", desc.irq().data());
140 return Err(SystemError::EINVAL);
141 }
142
143 if handler.is_none() {
144 if thread_fn.is_none() {
145 // 不允许中断处理函数和线程处理函数都为空
146 return Err(SystemError::EINVAL);
147 }
148
149 // 如果中断处理函数为空，线程处理函数不为空，则使用默认的中断处理函数
150 handler = Some(&DefaultPrimaryIrqHandler);
151 }
152
153 let irqaction = IrqAction::new(irq, dev_name, handler, thread_fn);
154
155 let mut action_guard = irqaction.inner();
156 *action_guard.flags_mut() = flags;
157 *action_guard.dev_id_mut() = dev_id;
158 drop(action_guard);
159 debug!("to inner_setup_irq: {irq:?}");
160 return self.inner_setup_irq(irq, irqaction, desc);
161 }
162
163 /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/kernel/irq/manage.c?r=&mo=59252&fi=2138#1497
164 #[inline(never)]
inner_setup_irq( &self, irq: IrqNumber, action: Arc<IrqAction>, desc: Arc<IrqDesc>, ) -> Result<(), SystemError>165 fn inner_setup_irq(
166 &self,
167 irq: IrqNumber,
168 action: Arc<IrqAction>,
169 desc: Arc<IrqDesc>,
170 ) -> Result<(), SystemError> {
171 // ==== 定义错误处理函数 ====
172 let err_out_thread =
173 |e: SystemError, mut action_guard: SpinLockGuard<'_, InnerIrqAction>| -> SystemError {
174 if let Some(thread_pcb) = action_guard.thread() {
175 action_guard.set_thread(None);
176 KernelThreadMechanism::stop(&thread_pcb).ok();
177 }
178
179 if let Some(secondary) = action_guard.secondary() {
180 let mut secondary_guard = secondary.inner();
181 if let Some(thread_pcb) = secondary_guard.thread() {
182 secondary_guard.set_thread(None);
183 KernelThreadMechanism::stop(&thread_pcb).ok();
184 }
185 }
186 return e;
187 };
188
189 let err_out_bus_unlock = |e: SystemError,
190 desc: Arc<IrqDesc>,
191 req_mutex_guard: crate::libs::mutex::MutexGuard<'_, ()>,
192 action_guard: SpinLockGuard<'_, InnerIrqAction>|
193 -> SystemError {
194 desc.chip_bus_sync_unlock();
195 drop(req_mutex_guard);
196 return err_out_thread(e, action_guard);
197 };
198
199 let err_out_unlock = |e: SystemError,
200 desc_guard: SpinLockGuard<'_, InnerIrqDesc>,
201 desc: Arc<IrqDesc>,
202 req_mutex_guard: crate::libs::mutex::MutexGuard<'_, ()>,
203 action_guard: SpinLockGuard<'_, InnerIrqAction>|
204 -> SystemError {
205 drop(desc_guard);
206 return err_out_bus_unlock(e, desc, req_mutex_guard, action_guard);
207 };
208
209 let err_out_mismatch = |old_action_guard: SpinLockGuard<'_, InnerIrqAction>,
210 desc_guard: SpinLockGuard<'_, InnerIrqDesc>,
211 action_guard: SpinLockGuard<'_, InnerIrqAction>,
212 desc: Arc<IrqDesc>,
213 req_mutex_guard: crate::libs::mutex::MutexGuard<'_, ()>|
214 -> SystemError {
215 if !action_guard
216 .flags()
217 .contains(IrqHandleFlags::IRQF_PROBE_SHARED)
218 {
219 error!("Flags mismatch for irq {} (name: {}, flags: {:?}). old action name: {}, old flags: {:?}", irq.data(), action_guard.name(), action_guard.flags(), old_action_guard.name(), old_action_guard.flags());
220 }
221 return err_out_unlock(
222 SystemError::EBUSY,
223 desc_guard,
224 desc,
225 req_mutex_guard,
226 action_guard,
227 );
228 };
229
230 // ===== 代码开始 =====
231
232 if Arc::ptr_eq(
233 &desc.irq_data().chip_info_read_irqsave().chip(),
234 &no_irq_chip(),
235 ) {
236 return Err(SystemError::ENOSYS);
237 }
238
239 let mut action_guard = action.inner();
240 if !action_guard.flags().trigger_type_specified() {
241 // 如果没有指定触发类型，则使用默认的触发类型
242 action_guard
243 .flags_mut()
244 .insert_trigger_type(desc.irq_data().common_data().trigger_type())
245 }
246
247 let nested = desc.nested_thread();
248
249 if nested {
250 if action_guard.thread_fn().is_none() {
251 return Err(SystemError::EINVAL);
252 }
253
254 action_guard.set_handler(Some(&IrqNestedPrimaryHandler));
255 } else if desc.can_thread() {
256 self.setup_forced_threading(action_guard.deref_mut())?;
257 }
258
259 // 如果具有中断线程处理程序，并且中断不是嵌套的，则设置中断线程
260 if action_guard.thread_fn().is_some() && !nested {
261 self.setup_irq_thread(irq, action_guard.deref(), false)?;
262
263 if let Some(secondary) = action_guard.secondary() {
264 let secondary_guard = secondary.inner();
265 if let Err(e) = self.setup_irq_thread(irq, secondary_guard.deref(), true) {
266 return Err(err_out_thread(e, action_guard));
267 }
268 }
269 }
270
271 // Drivers are often written to work w/o knowledge about the
272 // underlying irq chip implementation, so a request for a
273 // threaded irq without a primary hard irq context handler
274 // requires the ONESHOT flag to be set. Some irq chips like
275 // MSI based interrupts are per se one shot safe. Check the
276 // chip flags, so we can avoid the unmask dance at the end of
277 // the threaded handler for those.
278
279 if desc
280 .irq_data()
281 .chip_info_read_irqsave()
282 .chip()
283 .flags()
284 .contains(IrqChipFlags::IRQCHIP_ONESHOT_SAFE)
285 {
286 *action_guard.flags_mut() &= !IrqHandleFlags::IRQF_ONESHOT;
287 }
288
289 // Protects against a concurrent __free_irq() call which might wait
290 // for synchronize_hardirq() to complete without holding the optional
291 // chip bus lock and desc->lock. Also protects against handing out
292 // a recycled oneshot thread_mask bit while it's still in use by
293 // its previous owner.
294 let req_mutex_guard = desc.request_mutex_lock();
295
296 // Acquire bus lock as the irq_request_resources() callback below
297 // might rely on the serialization or the magic power management
298 // functions which are abusing the irq_bus_lock() callback,
299 desc.chip_bus_lock();
300
301 // 如果当前中断线上还没有irqaction, 则先为中断线申请资源
302 if desc.actions().is_empty() {
303 if let Err(e) = self.irq_request_resources(desc.clone()) {
304 error!(
305 "Failed to request resources for {} (irq {}) on irqchip {}, error {:?}",
306 action_guard.name(),
307 irq.data(),
308 desc.irq_data().chip_info_read_irqsave().chip().name(),
309 e
310 );
311 return Err(err_out_bus_unlock(
312 e,
313 desc.clone(),
314 req_mutex_guard,
315 action_guard,
316 ));
317 }
318 }
319
320 let mut desc_inner_guard: SpinLockGuard<'_, InnerIrqDesc> = desc.inner();
321
322 // 标记当前irq是否是共享的
323 let mut irq_shared = false;
324 if !desc_inner_guard.actions().is_empty() {
325 // 除非双方都同意并且是相同类型（级别、边沿、极性），否则不能共享中断。
326 // 因此，两个标志字段都必须设置IRQF_SHARED，并且设置触发类型的位必须匹配。
327 // 另外，所有各方都必须就ONESHOT达成一致。
328 // NMI用途的中断线不能共享。
329 if desc_inner_guard
330 .internal_state()
331 .contains(IrqDescState::IRQS_NMI)
332 {
333 error!(
334 "Invalid attempt to share NMI for {} (irq {}) on irqchip {}",
335 action_guard.name(),
336 irq.data(),
337 desc_inner_guard
338 .irq_data()
339 .chip_info_read_irqsave()
340 .chip()
341 .name()
342 );
343 return Err(err_out_unlock(
344 SystemError::EINVAL,
345 desc_inner_guard,
346 desc.clone(),
347 req_mutex_guard,
348 action_guard,
349 ));
350 }
351
352 let irq_data = desc_inner_guard.irq_data();
353
354 let old_trigger_type: super::irqdata::IrqLineStatus;
355 let status = irq_data.common_data().status();
356 if status.trigger_type_was_set() {
357 old_trigger_type = status.trigger_type();
358 } else {
359 old_trigger_type = action_guard.flags().trigger_type();
360 irq_data.common_data().set_trigger_type(old_trigger_type);
361 }
362
363 let old = &desc_inner_guard.actions()[0].clone();
364 let old_guard = old.inner();
365
366 if (!(old_guard
367 .flags()
368 .intersection(*action_guard.flags())
369 .contains(IrqHandleFlags::IRQF_SHARED)))
370 || (old_trigger_type != (action_guard.flags().trigger_type()))
371 || ((old_guard.flags().bitxor(*action_guard.flags()))
372 .contains(IrqHandleFlags::IRQF_ONESHOT))
373 {
374 debug!(
375 "Flags mismatch for irq {} (name: {}, flags: {:?}). old action name: {}, old flags: {:?}",
376 irq.data(),
377 action_guard.name(),
378 action_guard.flags(),
379 old_guard.name(),
380 old_guard.flags()
381 );
382
383 return Err(err_out_mismatch(
384 old_guard,
385 desc_inner_guard,
386 action_guard,
387 desc.clone(),
388 req_mutex_guard,
389 ));
390 }
391
392 // all handlers must agree on per-cpuness
393 if *old_guard.flags() & IrqHandleFlags::IRQF_PERCPU
394 != *action_guard.flags() & IrqHandleFlags::IRQF_PERCPU
395 {
396 debug!(
397 "Per-cpu mismatch for irq {} (name: {}, flags: {:?})",
398 irq.data(),
399 action_guard.name(),
400 action_guard.flags()
401 );
402 return Err(err_out_mismatch(
403 old_guard,
404 desc_inner_guard,
405 action_guard,
406 desc.clone(),
407 req_mutex_guard,
408 ));
409 }
410
411 irq_shared = true;
412 }
413
414 if action_guard.flags().contains(IrqHandleFlags::IRQF_ONESHOT) {
415 // todo: oneshot
416 } else if action_guard.handler().is_some_and(|h| {
417 h.type_id() == (&DefaultPrimaryIrqHandler as &dyn IrqHandler).type_id()
418 }) && !desc_inner_guard
419 .irq_data()
420 .chip_info_read_irqsave()
421 .chip()
422 .flags()
423 .contains(IrqChipFlags::IRQCHIP_ONESHOT_SAFE)
424 {
425 // 请求中断时 hander = NULL，因此我们为其使用默认的主处理程序。
426 // 但它没有设置ONESHOT标志。与电平触发中断结合时，
427 // 这是致命的，因为默认的主处理程序只是唤醒线程，然后重新启用 irq 线路，
428 // 但设备仍然保持电平中断生效。周而复始....
429 // 虽然这对于边缘类型中断来说可行，但我们为了安全起见，不加条件地拒绝，
430 // 因为我们不能确定这个中断实际上具有什么类型。
431 // 由于底层芯片实现可能会覆盖它们，所以类型标志并不可靠.
432
433 error!(
434 "Requesting irq {} without a handler, and ONESHOT flags not set for irqaction: {}",
435 irq.data(),
436 action_guard.name()
437 );
438 return Err(err_out_unlock(
439 SystemError::EINVAL,
440 desc_inner_guard,
441 desc.clone(),
442 req_mutex_guard,
443 action_guard,
444 ));
445 }
446
447 // 第一次在当前irqdesc上注册中断处理函数
448 if !irq_shared {
449 // 设置中断触发方式
450 if action_guard.flags().trigger_type_specified() {
451 let trigger_type = action_guard.flags().trigger_type();
452 if let Err(e) =
453 self.do_set_irq_trigger(desc.clone(), &mut desc_inner_guard, trigger_type)
454 {
455 debug!(
456 "Failed to set trigger type for irq {} (name: {}, flags: {:?}), error {:?}",
457 irq.data(),
458 action_guard.name(),
459 action_guard.flags(),
460 e
461 );
462 return Err(err_out_unlock(
463 e,
464 desc_inner_guard,
465 desc.clone(),
466 req_mutex_guard,
467 action_guard,
468 ));
469 }
470 }
471 debug!("to irq_activate");
472 // 激活中断。这种激活必须独立于IRQ_NOAUTOEN进行*desc_inner_guard.internal_state_mut() |= IrqDescState::IRQS_NOREQUEST;uest.
473 if let Err(e) = self.irq_activate(&desc, &mut desc_inner_guard) {
474 debug!(
475 "Failed to activate irq {} (name: {}, flags: {:?}), error {:?}",
476 irq.data(),
477 action_guard.name(),
478 action_guard.flags(),
479 e
480 );
481 return Err(err_out_unlock(
482 e,
483 desc_inner_guard,
484 desc.clone(),
485 req_mutex_guard,
486 action_guard,
487 ));
488 }
489
490 *desc_inner_guard.internal_state_mut() &= !(IrqDescState::IRQS_AUTODETECT
491 | IrqDescState::IRQS_SPURIOUS_DISABLED
492 | IrqDescState::IRQS_ONESHOT
493 | IrqDescState::IRQS_WAITING);
494 desc_inner_guard
495 .common_data()
496 .clear_status(IrqStatus::IRQD_IRQ_INPROGRESS);
497
498 if action_guard.flags().contains(IrqHandleFlags::IRQF_PERCPU) {
499 desc_inner_guard
500 .common_data()
501 .insert_status(IrqStatus::IRQD_PER_CPU);
502 desc_inner_guard.line_status_set_per_cpu();
503
504 if action_guard.flags().contains(IrqHandleFlags::IRQF_NO_DEBUG) {
505 desc_inner_guard.line_status_set_no_debug();
506 }
507 }
508
509 if action_guard.flags().contains(IrqHandleFlags::IRQF_ONESHOT) {
510 *desc_inner_guard.internal_state_mut() |= IrqDescState::IRQS_ONESHOT;
511 }
512
513 // 如果有要求的话，则忽略IRQ的均衡。
514 if action_guard
515 .flags()
516 .contains(IrqHandleFlags::IRQF_NOBALANCING)
517 {
518 todo!("IRQF_NO_BALANCING");
519 }
520
521 if !action_guard
522 .flags()
523 .contains(IrqHandleFlags::IRQF_NO_AUTOEN)
524 && desc_inner_guard.can_autoenable()
525 {
526 // 如果没有设置IRQF_NOAUTOEN，则自动使能中断
527 self.irq_startup(
528 &desc,
529 &mut desc_inner_guard,
530 Self::IRQ_RESEND,
531 Self::IRQ_START_COND,
532 )
533 .ok();
534 } else {
535 // 共享中断与禁用自动使能不太兼容。
536 // 共享中断可能在它仍然被禁用时请求它，然后永远等待中断。
537
538 static mut WARNED: bool = false;
539 if action_guard.flags().contains(IrqHandleFlags::IRQF_SHARED) && unsafe { !WARNED }
540 {
541 warn!(
542 "Shared interrupt {} for {} requested but not auto enabled",
543 irq.data(),
544 action_guard.name()
545 );
546 unsafe { WARNED = true };
547 }
548
549 desc_inner_guard.set_depth(1);
550 }
551 } else if action_guard.flags().trigger_type_specified() {
552 let new_trigger_type = action_guard.flags().trigger_type();
553 let old_trigger_type = desc_inner_guard.common_data().trigger_type();
554 if new_trigger_type != old_trigger_type {
555 warn!("Irq {} uses trigger type: {old_trigger_type:?}, but requested trigger type: {new_trigger_type:?}.", irq.data());
556 }
557 }
558
559 // 在队列末尾添加新的irqaction
560 desc_inner_guard.add_action(action.clone());
561
562 // 检查我们是否曾经通过虚构的中断处理程序禁用过irq。重新启用它并再给它一次机会。
563 if irq_shared
564 && desc_inner_guard
565 .internal_state()
566 .contains(IrqDescState::IRQS_SPURIOUS_DISABLED)
567 {
568 desc_inner_guard
569 .internal_state_mut()
570 .remove(IrqDescState::IRQS_SPURIOUS_DISABLED);
571 self.do_enable_irq(desc.clone(), &mut desc_inner_guard).ok();
572 }
573
574 drop(desc_inner_guard);
575 desc.chip_bus_sync_unlock();
576 drop(req_mutex_guard);
577
578 drop(action_guard);
579 self.wake_up_and_wait_for_irq_thread_ready(&desc, Some(action.clone()));
580 self.wake_up_and_wait_for_irq_thread_ready(&desc, action.inner().secondary());
581 return Ok(());
582 }
583
584 /// 唤醒中断线程并等待中断线程准备好
585 ///
586 /// ## 参数
587 ///
588 /// - desc: 中断描述符
589 /// - action: 要唤醒的中断处理函数
590 ///
591 /// ## 锁
592 ///
593 /// 进入当前函数时，`action`的锁需要被释放
wake_up_and_wait_for_irq_thread_ready( &self, desc: &Arc<IrqDesc>, action: Option<Arc<IrqAction>>, )594 fn wake_up_and_wait_for_irq_thread_ready(
595 &self,
596 desc: &Arc<IrqDesc>,
597 action: Option<Arc<IrqAction>>,
598 ) {
599 if action.is_none() {
600 return;
601 }
602
603 let action = action.unwrap();
604
605 let action_guard = action.inner();
606 if action_guard.thread().is_none() {
607 return;
608 }
609
610 ProcessManager::wakeup(&action_guard.thread().unwrap()).ok();
611 drop(action_guard);
612 action
613 .thread_completion()
614 .wait_for_completion()
615 .map_err(|e| {
616 warn!(
617 "Failed to wait for irq thread ready for {} (irq {:?}), error {:?}",
618 action.inner().name(),
619 desc.irq_data().irq(),
620 e
621 );
622 })
623 .ok();
624 }
625
irq_activate_and_startup( &self, desc: &Arc<IrqDesc>, desc_inner_guard: &mut SpinLockGuard<'_, InnerIrqDesc>, resend: bool, ) -> Result<(), SystemError>626 pub(super) fn irq_activate_and_startup(
627 &self,
628 desc: &Arc<IrqDesc>,
629 desc_inner_guard: &mut SpinLockGuard<'_, InnerIrqDesc>,
630 resend: bool,
631 ) -> Result<(), SystemError> {
632 debug!(
633 "irq_activate_and_startup: irq: {}, name: {:?}",
634 desc.irq().data(),
635 desc_inner_guard.name()
636 );
637 self.irq_activate(desc, desc_inner_guard)?;
638 self.irq_startup(desc, desc_inner_guard, resend, Self::IRQ_START_FORCE)
639 }
640
irq_activate( &self, _desc: &Arc<IrqDesc>, desc_inner_guard: &mut SpinLockGuard<'_, InnerIrqDesc>, ) -> Result<(), SystemError>641 pub(super) fn irq_activate(
642 &self,
643 _desc: &Arc<IrqDesc>,
644 desc_inner_guard: &mut SpinLockGuard<'_, InnerIrqDesc>,
645 ) -> Result<(), SystemError> {
646 let irq_data = desc_inner_guard.irq_data();
647
648 if !desc_inner_guard.common_data().status().affinity_managed() {
649 return irq_domain_manager().activate_irq(irq_data, false);
650 }
651
652 return Ok(());
653 }
654
655 /// 设置CPU亲和性并开启中断
irq_startup( &self, desc: &Arc<IrqDesc>, desc_inner_guard: &mut SpinLockGuard<'_, InnerIrqDesc>, resend: bool, force: bool, ) -> Result<(), SystemError>656 pub(super) fn irq_startup(
657 &self,
658 desc: &Arc<IrqDesc>,
659 desc_inner_guard: &mut SpinLockGuard<'_, InnerIrqDesc>,
660 resend: bool,
661 force: bool,
662 ) -> Result<(), SystemError> {
663 debug!(
664 "irq_startup: irq: {}, name: {:?}",
665 desc_inner_guard.irq_data().irq().data(),
666 desc_inner_guard.name()
667 );
668 let mut ret = Ok(());
669 let irq_data = desc_inner_guard.irq_data().clone();
670 let affinity = desc_inner_guard.common_data().affinity();
671 desc_inner_guard.set_depth(0);
672
673 if desc_inner_guard.common_data().status().started() {
674 self.irq_enable(desc_inner_guard);
675 } else {
676 match self.__irq_startup_managed(desc_inner_guard, &affinity, force) {
677 IrqStartupResult::Normal => {
678 if irq_data
679 .chip_info_read_irqsave()
680 .chip()
681 .flags()
682 .contains(IrqChipFlags::IRQCHIP_AFFINITY_PRE_STARTUP)
683 {
684 self.irq_setup_affinity(desc, desc_inner_guard).ok();
685 }
686
687 ret = self.__irq_startup(desc_inner_guard);
688
689 if !irq_data
690 .chip_info_read_irqsave()
691 .chip()
692 .flags()
693 .contains(IrqChipFlags::IRQCHIP_AFFINITY_PRE_STARTUP)
694 {
695 self.irq_setup_affinity(desc, desc_inner_guard).ok();
696 }
697 }
698 IrqStartupResult::Managed => {
699 self.irq_do_set_affinity(&irq_data, desc_inner_guard, &affinity, false)
700 .ok();
701 ret = self.__irq_startup(desc_inner_guard);
702 }
703 IrqStartupResult::Abort => {
704 desc_inner_guard
705 .common_data()
706 .insert_status(IrqStatus::IRQD_MANAGED_SHUTDOWN);
707 return Ok(());
708 }
709 }
710 }
711
712 if resend {
713 if let Err(e) = self.irq_check_and_resend(desc_inner_guard, false) {
714 error!(
715 "Failed to check and resend irq {}, error {:?}",
716 irq_data.irq().data(),
717 e
718 );
719 }
720 }
721
722 return ret;
723 }
724
irq_enable(&self, desc_inner_guard: &SpinLockGuard<'_, InnerIrqDesc>)725 pub fn irq_enable(&self, desc_inner_guard: &SpinLockGuard<'_, InnerIrqDesc>) {
726 let common_data = desc_inner_guard.common_data();
727 if !common_data.status().disabled() {
728 self.unmask_irq(desc_inner_guard);
729 } else {
730 common_data.clear_disabled();
731
732 let chip = desc_inner_guard.irq_data().chip_info_read_irqsave().chip();
733
734 if let Err(e) = chip.irq_enable(desc_inner_guard.irq_data()) {
735 if e == SystemError::ENOSYS {
736 self.unmask_irq(desc_inner_guard);
737 }
738 error!(
739 "Failed to enable irq {} (name: {:?}), error {:?}",
740 desc_inner_guard.irq_data().irq().data(),
741 desc_inner_guard.name(),
742 e
743 );
744 } else {
745 common_data.clear_masked();
746 }
747 }
748 }
749
750 /// 自动设置中断的CPU亲和性
751 ///
752 ///
753 /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/kernel/irq/manage.c#589
irq_setup_affinity( &self, _desc: &Arc<IrqDesc>, desc_inner_guard: &mut SpinLockGuard<'_, InnerIrqDesc>, ) -> Result<(), SystemError>754 pub fn irq_setup_affinity(
755 &self,
756 _desc: &Arc<IrqDesc>,
757 desc_inner_guard: &mut SpinLockGuard<'_, InnerIrqDesc>,
758 ) -> Result<(), SystemError> {
759 let common_data = desc_inner_guard.common_data();
760 if !desc_inner_guard.can_set_affinity() {
761 return Ok(());
762 }
763
764 let mut to_set = IRQ_DEFAULT_AFFINITY.clone();
765 if common_data.status().affinity_managed()
766 || common_data.status().contains(IrqStatus::IRQD_AFFINITY_SET)
767 {
768 // FIXME: 要判断affinity跟已上线的CPU是否有交集
769
770 let irq_aff = common_data.affinity();
771 if irq_aff.is_empty() {
772 common_data.clear_status(IrqStatus::IRQD_AFFINITY_SET);
773 } else {
774 to_set = irq_aff;
775 }
776 }
777
778 // FIXME: 求to_set和在线CPU的交集
779
780 return self.irq_do_set_affinity(
781 desc_inner_guard.irq_data(),
782 desc_inner_guard,
783 &to_set,
784 false,
785 );
786 }
787
irq_set_affinity( &self, irq_data: &Arc<IrqData>, desc_inner_guard: &SpinLockGuard<'_, InnerIrqDesc>, cpumask: &CpuMask, ) -> Result<(), SystemError>788 pub fn irq_set_affinity(
789 &self,
790 irq_data: &Arc<IrqData>,
791 desc_inner_guard: &SpinLockGuard<'_, InnerIrqDesc>,
792 cpumask: &CpuMask,
793 ) -> Result<(), SystemError> {
794 return self.irq_do_set_affinity(irq_data, desc_inner_guard, cpumask, false);
795 }
irq_do_set_affinity( &self, irq_data: &Arc<IrqData>, desc_inner_guard: &SpinLockGuard<'_, InnerIrqDesc>, cpumask: &CpuMask, force: bool, ) -> Result<(), SystemError>796 fn irq_do_set_affinity(
797 &self,
798 irq_data: &Arc<IrqData>,
799 desc_inner_guard: &SpinLockGuard<'_, InnerIrqDesc>,
800 cpumask: &CpuMask,
801 force: bool,
802 ) -> Result<(), SystemError> {
803 let chip = irq_data.chip_info_read_irqsave().chip();
804 if !chip.can_set_affinity() {
805 return Err(SystemError::EINVAL);
806 }
807
808 // todo: 处理CPU中断隔离相关的逻辑
809
810 let common_data = desc_inner_guard.common_data();
811 let r = if force || !cpumask.is_empty() {
812 chip.irq_set_affinity(irq_data, cpumask, force)
813 } else {
814 return Err(SystemError::EINVAL);
815 };
816
817 let mut ret = Ok(());
818 if let Ok(rs) = r {
819 match rs {
820 IrqChipSetMaskResult::Success | IrqChipSetMaskResult::Done => {
821 common_data.set_affinity(cpumask.clone());
822 }
823 IrqChipSetMaskResult::NoChange => {
824
825 // irq_validate_effective_affinity(data);
826 // irq_set_thread_affinity(desc);
827 }
828 }
829 } else {
830 ret = Err(r.unwrap_err());
831 }
832
833 return ret;
834 }
835
__irq_startup( &self, desc_inner_guard: &SpinLockGuard<'_, InnerIrqDesc>, ) -> Result<(), SystemError>836 fn __irq_startup(
837 &self,
838 desc_inner_guard: &SpinLockGuard<'_, InnerIrqDesc>,
839 ) -> Result<(), SystemError> {
840 let common_data = desc_inner_guard.common_data();
841
842 if let Err(e) = desc_inner_guard
843 .irq_data()
844 .chip_info_read_irqsave()
845 .chip()
846 .irq_startup(desc_inner_guard.irq_data())
847 {
848 if e == SystemError::ENOSYS {
849 self.irq_enable(desc_inner_guard);
850 } else {
851 return Err(e);
852 }
853 } else {
854 common_data.clear_disabled();
855 common_data.clear_masked();
856 }
857
858 common_data.set_started();
859
860 return Ok(());
861 }
862
__irq_startup_managed( &self, desc_inner_guard: &SpinLockGuard<'_, InnerIrqDesc>, _affinity: &CpuMask, _force: bool, ) -> IrqStartupResult863 fn __irq_startup_managed(
864 &self,
865 desc_inner_guard: &SpinLockGuard<'_, InnerIrqDesc>,
866 _affinity: &CpuMask,
867 _force: bool,
868 ) -> IrqStartupResult {
869 let irq_data = desc_inner_guard.irq_data();
870 let common_data = desc_inner_guard.common_data();
871
872 if !common_data.status().affinity_managed() {
873 return IrqStartupResult::Normal;
874 }
875
876 common_data.clear_managed_shutdown();
877
878 /*
879 - 检查Affinity掩码是否包括所有的在线CPU。如果是，这意味着有代码试图在管理的中断上使用enable_irq()，
880 这可能是非法的。在这种情况下，如果force不是真值，函数会返回IRQ_STARTUP_ABORT，表示中断处理应该被放弃。
881 - 如果Affinity掩码中没有任何在线的CPU，那么中断请求是不可用的，因为没有任何CPU可以处理它。
882 在这种情况下，如果force不是真值，函数同样会返回IRQ_STARTUP_ABORT。
883 - 如果以上条件都不满足，尝试激活中断，并将其设置为管理模式。这是通过调用 `irq_domain_manager().activate_irq()` 函数来实现的。
884 如果这个调用失败，表示有保留的资源无法访问，函数会返回IRQ_STARTUP_ABORT。
885 - 如果一切顺利，函数会返回IRQ_STARTUP_MANAGED，表示中断已经被成功管理并激活。
886 */
887
888 // if (cpumask_any_and(aff, cpu_online_mask) >= nr_cpu_ids) {
889 // /*
890 // * Catch code which fiddles with enable_irq() on a managed
891 // * and potentially shutdown IRQ. Chained interrupt
892 // * installment or irq auto probing should not happen on
893 // * managed irqs either.
894 // */
895 // if (WARN_ON_ONCE(force))
896 // return IRQ_STARTUP_ABORT;
897 // /*
898 // * The interrupt was requested, but there is no online CPU
899 // * in it's affinity mask. Put it into managed shutdown
900 // * state and let the cpu hotplug mechanism start it up once
901 // * a CPU in the mask becomes available.
902 // */
903 // return IRQ_STARTUP_ABORT;
904 // }
905
906 let r = irq_domain_manager().activate_irq(irq_data, false);
907 if r.is_err() {
908 return IrqStartupResult::Abort;
909 }
910
911 return IrqStartupResult::Managed;
912 }
913
do_enable_irq( &self, _desc: Arc<IrqDesc>, _desc_inner_guard: &mut SpinLockGuard<'_, InnerIrqDesc>, ) -> Result<(), SystemError>914 pub fn do_enable_irq(
915 &self,
916 _desc: Arc<IrqDesc>,
917 _desc_inner_guard: &mut SpinLockGuard<'_, InnerIrqDesc>,
918 ) -> Result<(), SystemError> {
919 // https://code.dragonos.org.cn/xref/linux-6.1.9/kernel/irq/manage.c?r=&mo=59252&fi=2138#776
920 todo!("do_enable_irq")
921 }
922
923 #[inline(never)]
do_set_irq_trigger( &self, _desc: Arc<IrqDesc>, desc_inner_guard: &mut SpinLockGuard<'_, InnerIrqDesc>, mut trigger_type: IrqLineStatus, ) -> Result<(), SystemError>924 pub fn do_set_irq_trigger(
925 &self,
926 _desc: Arc<IrqDesc>,
927 desc_inner_guard: &mut SpinLockGuard<'_, InnerIrqDesc>,
928 mut trigger_type: IrqLineStatus,
929 ) -> Result<(), SystemError> {
930 let chip = desc_inner_guard.irq_data().chip_info_read_irqsave().chip();
931 let mut to_unmask = false;
932
933 if !chip.can_set_flow_type() {
934 // debug!(
935 // "No set_irq_type function for irq {}, chip {}",
936 // desc_inner_guard.irq_data().irq().data(),
937 // chip.name()
938 // );
939 return Ok(());
940 }
941
942 if chip.flags().contains(IrqChipFlags::IRQCHIP_SET_TYPE_MASKED) {
943 if !desc_inner_guard.common_data().status().masked() {
944 self.mask_irq(desc_inner_guard.irq_data());
945 }
946 if !desc_inner_guard.common_data().status().disabled() {
947 to_unmask = true;
948 }
949 }
950
951 trigger_type &= IrqLineStatus::IRQ_TYPE_SENSE_MASK;
952
953 let r = chip.irq_set_type(desc_inner_guard.irq_data(), trigger_type);
954 let ret;
955 if let Ok(rs) = r {
956 match rs {
957 IrqChipSetMaskResult::Success | IrqChipSetMaskResult::Done => {
958 let common_data = desc_inner_guard.common_data();
959 common_data.clear_status(IrqStatus::IRQD_TRIGGER_MASK);
960 let mut irqstatus = IrqStatus::empty();
961 irqstatus.set_trigger_type(trigger_type);
962 common_data.insert_status(irqstatus);
963 }
964 IrqChipSetMaskResult::NoChange => {
965 let flags = desc_inner_guard.common_data().trigger_type();
966 desc_inner_guard.set_trigger_type(flags);
967 desc_inner_guard
968 .common_data()
969 .clear_status(IrqStatus::IRQD_LEVEL);
970 desc_inner_guard.clear_level();
971
972 if !(flags & IrqLineStatus::IRQ_TYPE_LEVEL_MASK).is_empty() {
973 desc_inner_guard.set_level();
974 desc_inner_guard
975 .common_data()
976 .insert_status(IrqStatus::IRQD_LEVEL);
977 }
978 }
979 }
980
981 ret = Ok(());
982 } else {
983 error!(
984 "Failed to set irq {} trigger type to {:?} on irqchip {}, error {:?}",
985 desc_inner_guard.irq_data().irq().data(),
986 trigger_type,
987 chip.name(),
988 r
989 );
990
991 ret = Err(r.unwrap_err());
992 }
993
994 if to_unmask {
995 self.unmask_irq(desc_inner_guard);
996 }
997 return ret;
998 }
999
irq_request_resources(&self, desc: Arc<IrqDesc>) -> Result<(), SystemError>1000 fn irq_request_resources(&self, desc: Arc<IrqDesc>) -> Result<(), SystemError> {
1001 let irq_data = desc.irq_data();
1002 let irq_chip = irq_data.chip_info_read_irqsave().chip();
1003 irq_chip.irq_request_resources(&irq_data)
1004 }
1005
1006 /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/kernel/irq/manage.c?r=&mo=59252&fi=2138#1448
setup_irq_thread( &self, _irq: IrqNumber, _action: &InnerIrqAction, _secondary: bool, ) -> Result<(), SystemError>1007 fn setup_irq_thread(
1008 &self,
1009 _irq: IrqNumber,
1010 _action: &InnerIrqAction,
1011 _secondary: bool,
1012 ) -> Result<(), SystemError> {
1013 // if secondary {
1014 // KernelThreadMechanism::create(func, name)
1015 // }
1016
1017 todo!("setup_irq_thread")
1018 }
1019
setup_forced_threading(&self, _action: &mut InnerIrqAction) -> Result<(), SystemError>1020 fn setup_forced_threading(&self, _action: &mut InnerIrqAction) -> Result<(), SystemError> {
1021 // todo: 处理强制线程化的逻辑，参考linux的`irq_setup_forced_threading()`
1022 return Ok(());
1023 }
1024
irq_clear_status_flags( &self, irq: IrqNumber, status: IrqLineStatus, ) -> Result<(), SystemError>1025 pub fn irq_clear_status_flags(
1026 &self,
1027 irq: IrqNumber,
1028 status: IrqLineStatus,
1029 ) -> Result<(), SystemError> {
1030 let desc = irq_desc_manager().lookup(irq).ok_or(SystemError::EINVAL)?;
1031 desc.modify_status(status, IrqLineStatus::empty());
1032 return Ok(());
1033 }
1034
1035 /// 屏蔽中断
mask_irq(&self, irq_data: &Arc<IrqData>)1036 pub(super) fn mask_irq(&self, irq_data: &Arc<IrqData>) {
1037 if irq_data.common_data().status().masked() {
1038 return;
1039 }
1040
1041 let chip = irq_data.chip_info_read_irqsave().chip();
1042 let r = chip.irq_mask(irq_data);
1043
1044 if r.is_ok() {
1045 irq_data.common_data().set_masked();
1046 }
1047 }
1048
1049 /// 解除屏蔽中断
unmask_irq(&self, desc_inner_guard: &SpinLockGuard<'_, InnerIrqDesc>)1050 pub(super) fn unmask_irq(&self, desc_inner_guard: &SpinLockGuard<'_, InnerIrqDesc>) {
1051 if !desc_inner_guard.common_data().status().masked() {
1052 return;
1053 }
1054
1055 let r = desc_inner_guard
1056 .irq_data()
1057 .chip_info_read_irqsave()
1058 .chip()
1059 .irq_unmask(desc_inner_guard.irq_data());
1060
1061 if let Err(e) = r {
1062 if e != SystemError::ENOSYS {
1063 error!(
1064 "Failed to unmask irq {} on irqchip {}, error {:?}",
1065 desc_inner_guard.irq_data().irq().data(),
1066 desc_inner_guard
1067 .irq_data()
1068 .chip_info_read_irqsave()
1069 .chip()
1070 .name(),
1071 e
1072 );
1073 }
1074 } else {
1075 desc_inner_guard
1076 .common_data()
1077 .clear_status(IrqStatus::IRQD_IRQ_MASKED);
1078 }
1079 }
1080
1081 /// 释放使用request_irq分配的中断
1082 ///
1083 /// ## 参数
1084 ///
1085 /// - irq: 要释放的中断线
1086 /// - dev_id: 要释放的设备身份
1087 ///
1088 /// ## 返回
1089 ///
1090 /// 返回传递给request_irq的devname参数
1091 ///
1092 /// ## 说明
1093 ///
1094 /// 移除一个中断处理程序。处理程序被移除，如果该中断线不再被任何驱动程序使用，则会被禁用。
1095 ///
1096 /// 在共享IRQ的情况下，调用者必须确保在调用此功能之前，它在所驱动的卡上禁用了中断。
1097 ///
1098 /// ## 注意
1099 ///
1100 /// 此函数不可以在中断上下文中调用。
1101 ///
1102 /// 参考 https://code.dragonos.org.cn/xref/linux-6.6.21/kernel/irq/manage.c#2026
free_irq(&self, _irq: IrqNumber, _dev_id: Option<Arc<DeviceId>>)1103 pub fn free_irq(&self, _irq: IrqNumber, _dev_id: Option<Arc<DeviceId>>) {
1104 warn!("Unimplemented free_irq");
1105 }
1106 }
1107
1108 enum IrqStartupResult {
1109 Normal,
1110 Managed,
1111 Abort,
1112 }
1113 /// 默认的初级中断处理函数
1114 ///
1115 /// 该处理函数仅仅返回`WakeThread`，即唤醒中断线程
1116 #[derive(Debug)]
1117 struct DefaultPrimaryIrqHandler;
1118
1119 impl IrqHandler for DefaultPrimaryIrqHandler {
handle( &self, _irq: IrqNumber, _static_data: Option<&dyn IrqHandlerData>, _dynamic_data: Option<Arc<dyn IrqHandlerData>>, ) -> Result<IrqReturn, SystemError>1120 fn handle(
1121 &self,
1122 _irq: IrqNumber,
1123 _static_data: Option<&dyn IrqHandlerData>,
1124 _dynamic_data: Option<Arc<dyn IrqHandlerData>>,
1125 ) -> Result<IrqReturn, SystemError> {
1126 return Ok(IrqReturn::WakeThread);
1127 }
1128 }
1129
1130 /// Primary handler for nested threaded interrupts.
1131 /// Should never be called.
1132 #[derive(Debug)]
1133 struct IrqNestedPrimaryHandler;
1134
1135 impl IrqHandler for IrqNestedPrimaryHandler {
handle( &self, irq: IrqNumber, _static_data: Option<&dyn IrqHandlerData>, _dynamic_data: Option<Arc<dyn IrqHandlerData>>, ) -> Result<IrqReturn, SystemError>1136 fn handle(
1137 &self,
1138 irq: IrqNumber,
1139 _static_data: Option<&dyn IrqHandlerData>,
1140 _dynamic_data: Option<Arc<dyn IrqHandlerData>>,
1141 ) -> Result<IrqReturn, SystemError> {
1142 warn!("Primary handler called for nested irq {}", irq.data());
1143 return Ok(IrqReturn::NotHandled);
1144 }
1145 }
1146