From nobody Wed Oct 8 12:36:08 2025 Received: from sender4-pp-f112.zoho.com (sender4-pp-f112.zoho.com [136.143.188.112]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 199EF2D3EFA; Fri, 27 Jun 2025 16:22:08 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=pass smtp.client-ip=136.143.188.112 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751041330; cv=pass; b=Zc6TunhHeo8voUpr/tufu0jLXtoGsFTdgcb6Tqyz89xXI80/kNsHElKBT7dkRMaC6wPhK4dHlSKeyFSbG9V9OyCuuYL5G4TBNmNKIWfpS+fliFX9VirroXeXtUZKhP37GzLbjbG1Ilu3beSoPyowzyZQE/BLQ+MhHG/TJGT7weY= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751041330; c=relaxed/simple; bh=aEMkXvUthUB8l3Ze03TQRSrmmhr7dlle2OHZ3th5mnM=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=r+Mkg9RftQJ76Bit9Bj97G++KyjsFg34vc2JMG3n4yi4YkWKMUTGzq6nECLKRrP5IvjHsSqE3qzjJwuEFyyAdtsklMItK7Eb49pGYsvDpi1nvUW16Za4uclMaM1ibG22jmGloglN9noPfB5rQ9SqHGYq7aTPwrhbIfAFbopQMVI= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com; spf=pass smtp.mailfrom=collabora.com; dkim=pass (1024-bit key) header.d=collabora.com header.i=daniel.almeida@collabora.com header.b=kSbvSdQB; arc=pass smtp.client-ip=136.143.188.112 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=collabora.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=collabora.com header.i=daniel.almeida@collabora.com header.b="kSbvSdQB" ARC-Seal: i=1; a=rsa-sha256; t=1751041295; cv=none; d=zohomail.com; s=zohoarc; b=aHI2MeTlFnNzSo7CFpMiOLuw7trvYJFSOFVXU6I8Kax7opliYG29fVzRj6KVPs/124kAd8EeFXS+Bpz2XU3UN5Q5VMmm4+qWbPPnrjdY3yKTGzUPW3QvYFAWpnH6/MlsZz1CVUMSpeiikh5nck6V9zskAa3NHki3TaN6C0VxHzo= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1751041295; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:MIME-Version:Message-ID:References:Subject:Subject:To:To:Message-Id:Reply-To; bh=gfN2hhL3lfXYyJIhQf1mFRJtLEy5tuC2aFyzf06oeU0=; b=m2a4kSCzmCQIdTYYrlM+f1uc+dXqn7CzRirHDbVaqjmgIytDCoQC+XAPYqpRppubUD5X8qdszs4D2HUnMM6kzAkcVI6qyWVzI2MBfbtiiTt5M+rx8nj39KcMMyVK8BhNRQ0iMF3Ci3vitwxDOYvbLUja4jocXvBUsaRvSl7qAds= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass header.i=collabora.com; spf=pass smtp.mailfrom=daniel.almeida@collabora.com; dmarc=pass header.from= DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; t=1751041294; s=zohomail; d=collabora.com; i=daniel.almeida@collabora.com; h=From:From:Date:Date:Subject:Subject:MIME-Version:Content-Type:Content-Transfer-Encoding:Message-Id:Message-Id:References:In-Reply-To:To:To:Cc:Cc:Reply-To; bh=gfN2hhL3lfXYyJIhQf1mFRJtLEy5tuC2aFyzf06oeU0=; b=kSbvSdQB1T6NxjWP3K/HdNzqz+9doVXOMIdNoY6/DiUa0vDgSh8zGrsnfHWvQtsF H914RiOlcQPJ7TbpmNjJbTaxCvHCmczAjpaw7kxU1xaJIeLRRPhEzfvO0zQY4PYaxYL QqsGqCx0ITWamp75jXqKlnjF8lHvBvmqfxg0Jgh0= Received: by mx.zohomail.com with SMTPS id 1751041293651663.112480858902; Fri, 27 Jun 2025 09:21:33 -0700 (PDT) From: Daniel Almeida Date: Fri, 27 Jun 2025 13:21:03 -0300 Subject: [PATCH v5 1/6] rust: irq: add irq module Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250627-topics-tyr-request_irq-v5-1-0545ee4dadf6@collabora.com> References: <20250627-topics-tyr-request_irq-v5-0-0545ee4dadf6@collabora.com> In-Reply-To: <20250627-topics-tyr-request_irq-v5-0-0545ee4dadf6@collabora.com> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Thomas Gleixner , Benno Lossin , Bjorn Helgaas , =?utf-8?q?Krzysztof_Wilczy=C5=84ski?= , Benno Lossin Cc: linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-pci@vger.kernel.org, Daniel Almeida X-Mailer: b4 0.14.2 X-ZohoMailClient: External Add the IRQ module. Future patches will then introduce support for IRQ registrations and handlers. Signed-off-by: Daniel Almeida --- rust/kernel/irq.rs | 11 +++++++++++ rust/kernel/lib.rs | 1 + 2 files changed, 12 insertions(+) diff --git a/rust/kernel/irq.rs b/rust/kernel/irq.rs new file mode 100644 index 0000000000000000000000000000000000000000..fae7b15effc80c936d6bffbd5b4= 150000d6c2898 --- /dev/null +++ b/rust/kernel/irq.rs @@ -0,0 +1,11 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! IRQ abstractions. +//! +//! An IRQ is an interrupt request from a device. It is used to get the CP= U's +//! attention so it can service a hardware event in a timely manner. +//! +//! The current abstractions handle IRQ requests and handlers, i.e.: it al= lows +//! drivers to register a handler for a given IRQ line. +//! +//! C header: [`include/linux/device.h`](srctree/include/linux/interrupt.h) diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index 6b4774b2b1c37f4da1866e993be6230bc6715841..28dd0ef077fa47211fc0eae899a= e4ac82fb6be24 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -81,6 +81,7 @@ pub mod init; pub mod io; pub mod ioctl; +pub mod irq; pub mod jump_label; #[cfg(CONFIG_KUNIT)] pub mod kunit; --=20 2.50.0 From nobody Wed Oct 8 12:36:09 2025 Received: from sender4-pp-f112.zoho.com (sender4-pp-f112.zoho.com [136.143.188.112]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 135692EB5B0; Fri, 27 Jun 2025 16:22:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=pass smtp.client-ip=136.143.188.112 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751041339; cv=pass; b=aZ1sp/d0g5tRHBbk6tyrJjm0cHYg3r7E3dRJXVaIREZP8u8hNKfP/GRjDN2BmEX0UAMqXwruhx8NKFpGJVwTWH+/CkQJV7ys9xqi4bMH+Av/Scrp7lX0XQ8k4/56TFPI6GElWQd9Rtr3QN4GHqS881dcE7qBgs7pWbkrJnVxZS0= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751041339; c=relaxed/simple; bh=FN+vUZHISonksf0avqO410vexj0U6dH3mX8aymZfaNY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=J5Kx8hWIA5SH6vwKI/2pFxKePTZQOEVEti8Et2/Vc4IROHn23FF9eFYT8Jv4+f3imqAZbZ7PpACrJRQPnKUojY1SJS9/X8FY/OUTjVxtipJ8KeC/BSMbE3Ni3iVmbYfFh2cf9/KTI1TjsJGPagMFhCKwtq13c1G0iXDSrE5FTdE= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com; spf=pass smtp.mailfrom=collabora.com; dkim=pass (1024-bit key) header.d=collabora.com header.i=daniel.almeida@collabora.com header.b=LO4Pf+Mj; arc=pass smtp.client-ip=136.143.188.112 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=collabora.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=collabora.com header.i=daniel.almeida@collabora.com header.b="LO4Pf+Mj" ARC-Seal: i=1; a=rsa-sha256; t=1751041301; cv=none; d=zohomail.com; s=zohoarc; b=RxYnhlBODXP9kQVzTV9DtlMLQ3wk4VvlZsk77xeQ1PSqPro8ZN9Hr2l+uaqXqfoycIKNj3053wi5dIeIvmqJjRskx/qKNmmfw9X7dnleCbH3wvM9zldCiEFLBd932jfA8jvm8KMxTbV2G8+/N+vmUXA0ndUnBOdA3v4kz+BKA7k= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1751041301; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:MIME-Version:Message-ID:References:Subject:Subject:To:To:Message-Id:Reply-To; bh=alrRo8Nvsmb0Eo4JXfNn9cIOlYnb8zdQKewhwjmgfsI=; b=FxgpqTeeAqoRXdJXoaWPSxuKxU/P8OXScnmKY92dyHn5mn6XJ4LrA68bAtCG+II3NLcAL3/yHH26HYoG29zlnzni0J87gar1EGoLley+a+NSKDD+Dw4M02kPKKBzg1SR3ofIyQrQyfDCjZQ0K7fipIdqkULucmfUcsofPJ/pfaw= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass header.i=collabora.com; spf=pass smtp.mailfrom=daniel.almeida@collabora.com; dmarc=pass header.from= DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; t=1751041300; s=zohomail; d=collabora.com; i=daniel.almeida@collabora.com; h=From:From:Date:Date:Subject:Subject:MIME-Version:Content-Type:Content-Transfer-Encoding:Message-Id:Message-Id:References:In-Reply-To:To:To:Cc:Cc:Reply-To; bh=alrRo8Nvsmb0Eo4JXfNn9cIOlYnb8zdQKewhwjmgfsI=; b=LO4Pf+Mjm1lG0Zt22yYhs4d77NY7wFAieT5GBPs8C4n9w7PgX2sdcFNhrAkKIR0q lh1lhCFzFUaQmGyrZqkh4/cwzPZotoyfTaMD/xUdr1eBVz4Tifsm7uyrhAREzZqOIhG yy0X5NQSDXK9Z2li2BsGLmYfi28HUNks0HTDRYJA= Received: by mx.zohomail.com with SMTPS id 175104129788879.48504996482723; Fri, 27 Jun 2025 09:21:37 -0700 (PDT) From: Daniel Almeida Date: Fri, 27 Jun 2025 13:21:04 -0300 Subject: [PATCH v5 2/6] rust: irq: add flags module Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250627-topics-tyr-request_irq-v5-2-0545ee4dadf6@collabora.com> References: <20250627-topics-tyr-request_irq-v5-0-0545ee4dadf6@collabora.com> In-Reply-To: <20250627-topics-tyr-request_irq-v5-0-0545ee4dadf6@collabora.com> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Thomas Gleixner , Benno Lossin , Bjorn Helgaas , =?utf-8?q?Krzysztof_Wilczy=C5=84ski?= , Benno Lossin Cc: linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-pci@vger.kernel.org, Daniel Almeida X-Mailer: b4 0.14.2 X-ZohoMailClient: External Manipulating IRQ flags (i.e.: IRQF_*) will soon be necessary, specially to register IRQ handlers through bindings::request_irq(). Add a kernel::irq::Flags for that purpose. Signed-off-by: Daniel Almeida --- rust/kernel/irq.rs | 3 ++ rust/kernel/irq/flags.rs | 102 +++++++++++++++++++++++++++++++++++++++++++= ++++ 2 files changed, 105 insertions(+) diff --git a/rust/kernel/irq.rs b/rust/kernel/irq.rs index fae7b15effc80c936d6bffbd5b4150000d6c2898..9abd9a6dc36f3e3ecc1f92ad7b0= 040176b56a079 100644 --- a/rust/kernel/irq.rs +++ b/rust/kernel/irq.rs @@ -9,3 +9,6 @@ //! drivers to register a handler for a given IRQ line. //! //! C header: [`include/linux/device.h`](srctree/include/linux/interrupt.h) + +/// Flags to be used when registering IRQ handlers. +pub mod flags; diff --git a/rust/kernel/irq/flags.rs b/rust/kernel/irq/flags.rs new file mode 100644 index 0000000000000000000000000000000000000000..3cfaef65ae14f6c02f55ebcf4d5= 2450c0052df30 --- /dev/null +++ b/rust/kernel/irq/flags.rs @@ -0,0 +1,102 @@ +// SPDX-License-Identifier: GPL-2.0 +// SPDX-FileCopyrightText: Copyright 2025 Collabora ltd. + +use crate::bindings; + +/// Flags to be used when registering IRQ handlers. +/// +/// They can be combined with the operators `|`, `&`, and `!`. +#[derive(Clone, Copy, PartialEq, Eq)] +pub struct Flags(u64); + +impl Flags { + pub(crate) fn into_inner(self) -> u64 { + self.0 + } +} + +impl core::ops::BitOr for Flags { + type Output =3D Self; + fn bitor(self, rhs: Self) -> Self::Output { + Self(self.0 | rhs.0) + } +} + +impl core::ops::BitAnd for Flags { + type Output =3D Self; + fn bitand(self, rhs: Self) -> Self::Output { + Self(self.0 & rhs.0) + } +} + +impl core::ops::Not for Flags { + type Output =3D Self; + fn not(self) -> Self::Output { + Self(!self.0) + } +} + +/// Use the interrupt line as already configured. +pub const TRIGGER_NONE: Flags =3D Flags(bindings::IRQF_TRIGGER_NONE as u64= ); + +/// The interrupt is triggered when the signal goes from low to high. +pub const TRIGGER_RISING: Flags =3D Flags(bindings::IRQF_TRIGGER_RISING as= u64); + +/// The interrupt is triggered when the signal goes from high to low. +pub const TRIGGER_FALLING: Flags =3D Flags(bindings::IRQF_TRIGGER_FALLING = as u64); + +/// The interrupt is triggered while the signal is held high. +pub const TRIGGER_HIGH: Flags =3D Flags(bindings::IRQF_TRIGGER_HIGH as u64= ); + +/// The interrupt is triggered while the signal is held low. +pub const TRIGGER_LOW: Flags =3D Flags(bindings::IRQF_TRIGGER_LOW as u64); + +/// Allow sharing the irq among several devices. +pub const SHARED: Flags =3D Flags(bindings::IRQF_SHARED as u64); + +/// Set by callers when they expect sharing mismatches to occur. +pub const PROBE_SHARED: Flags =3D Flags(bindings::IRQF_PROBE_SHARED as u64= ); + +/// Flag to mark this interrupt as timer interrupt. +pub const TIMER: Flags =3D Flags(bindings::IRQF_TIMER as u64); + +/// Interrupt is per cpu. +pub const PERCPU: Flags =3D Flags(bindings::IRQF_PERCPU as u64); + +/// Flag to exclude this interrupt from irq balancing. +pub const NOBALANCING: Flags =3D Flags(bindings::IRQF_NOBALANCING as u64); + +/// Interrupt is used for polling (only the interrupt that is registered +/// first in a shared interrupt is considered for performance reasons). +pub const IRQPOLL: Flags =3D Flags(bindings::IRQF_IRQPOLL as u64); + +/// Interrupt is not reenabled after the hardirq handler finished. Used by +/// threaded interrupts which need to keep the irq line disabled until the +/// threaded handler has been run. +pub const ONESHOT: Flags =3D Flags(bindings::IRQF_ONESHOT as u64); + +/// Do not disable this IRQ during suspend. Does not guarantee that this +/// interrupt will wake the system from a suspended state. +pub const NO_SUSPEND: Flags =3D Flags(bindings::IRQF_NO_SUSPEND as u64); + +/// Force enable it on resume even if [`NO_SUSPEND`] is set. +pub const FORCE_RESUME: Flags =3D Flags(bindings::IRQF_FORCE_RESUME as u64= ); + +/// Interrupt cannot be threaded. +pub const NO_THREAD: Flags =3D Flags(bindings::IRQF_NO_THREAD as u64); + +/// Resume IRQ early during syscore instead of at device resume time. +pub const EARLY_RESUME: Flags =3D Flags(bindings::IRQF_EARLY_RESUME as u64= ); + +/// If the IRQ is shared with a [`NO_SUSPEND`] user, execute this interrupt +/// handler after suspending interrupts. For system wakeup devices users +/// need to implement wakeup detection in their interrupt handlers. +pub const COND_SUSPEND: Flags =3D Flags(bindings::IRQF_COND_SUSPEND as u64= ); + +/// Don't enable IRQ or NMI automatically when users request it. Users will +/// enable it explicitly by `enable_irq` or `enable_nmi` later. +pub const NO_AUTOEN: Flags =3D Flags(bindings::IRQF_NO_AUTOEN as u64); + +/// Exclude from runnaway detection for IPI and similar handlers, depends = on +/// `PERCPU`. +pub const NO_DEBUG: Flags =3D Flags(bindings::IRQF_NO_DEBUG as u64); --=20 2.50.0 From nobody Wed Oct 8 12:36:09 2025 Received: from sender4-pp-f112.zoho.com (sender4-pp-f112.zoho.com [136.143.188.112]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3BC322EB5DF; Fri, 27 Jun 2025 16:22:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=pass smtp.client-ip=136.143.188.112 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751041341; cv=pass; b=SGCXTbWsNcBA+uY+7dKilfJhFdl8g0Mf58EjxArgiP1zB1g0c+64CAUENuHarmOQfVbMjfDUfvFti1PmHQa1KTNThLk3lEzVMSjUdhdCJ80pix+5AoDqIIsfYlMTfUJNwmipb+jhhhUxle1/Lv3kq3VY5cjqdwoP7Q8WZAT5gp8= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751041341; c=relaxed/simple; bh=PxtsYKLd4SaE3lF6tcvnkB6QCoNzHI76aw8CvA9lT58=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=p94DEN9s6m8MLeJbhGosoIbt9PIPuBtfXMY2Bjw8v7xLwWRr9NTOSxZYxT6LwDUWEWGKwJND9mgXsxhPjZIt+uk/BT1nOqe9fBjsxCBiZozBLrnm/6MRzodbWFnDjSHOFRui+YWoh0zb4rYNc3JvsaGhe1/AranwRwbYb5N0ppA= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com; spf=pass smtp.mailfrom=collabora.com; dkim=pass (1024-bit key) header.d=collabora.com header.i=daniel.almeida@collabora.com header.b=BSxC5czS; arc=pass smtp.client-ip=136.143.188.112 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=collabora.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=collabora.com header.i=daniel.almeida@collabora.com header.b="BSxC5czS" ARC-Seal: i=1; a=rsa-sha256; t=1751041305; cv=none; d=zohomail.com; s=zohoarc; b=imPpu1B/0fpD4AxzCfLBEaAeAbmftgk1aatPWk5CQgshGEaloNqFB1NHDWBZghY0iUAEJ5ZI19WfnpmqEIN28DbUVfwdUqFTdHQscm/7k5rqyeIhNYnSFecbuFIyeccTeo1WnrKkDsHv4RVBZtckJ8Ywhad+huUGBtz386GTfo0= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1751041305; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:MIME-Version:Message-ID:References:Subject:Subject:To:To:Message-Id:Reply-To; bh=jsHm1g1hSHQeuOtDdCQq97QEkWY3DPRorMSjwNzWAIs=; b=JbZRtOyLiT/sEsZKbsuIUGNBkDlcP75r0i1oneKFA9StlnfQp3pZ459O32ZxqPKCDf6qxs6eQcHfl7Sd1X/gko6vurQFYyRQ7tc4hvQaiiW50WpgfVG4mXxSbzTZt0uGMoVDNvaUbs69bnvxxG+JrIEN2uWxCWZNskBTX0Q4eVM= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass header.i=collabora.com; spf=pass smtp.mailfrom=daniel.almeida@collabora.com; dmarc=pass header.from= DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; t=1751041305; s=zohomail; d=collabora.com; i=daniel.almeida@collabora.com; h=From:From:Date:Date:Subject:Subject:MIME-Version:Content-Type:Content-Transfer-Encoding:Message-Id:Message-Id:References:In-Reply-To:To:To:Cc:Cc:Reply-To; bh=jsHm1g1hSHQeuOtDdCQq97QEkWY3DPRorMSjwNzWAIs=; b=BSxC5czSk7bfOVzxTnMRbWh9EoWtpLo7sYUpxZKaAl68XcfpD/L3c5qLbKra09JW cKlKNK1vdaHtxSH/uiOGnigFfe/JqWe/BJ0PgxHZHCVWd91G/jdh9Yr2VM9UfuYcmcK 16Y/rX8m577v4qnZ214K+7Egqw4uDfyI66AMJFHc= Received: by mx.zohomail.com with SMTPS id 1751041302188894.7255377856379; Fri, 27 Jun 2025 09:21:42 -0700 (PDT) From: Daniel Almeida Date: Fri, 27 Jun 2025 13:21:05 -0300 Subject: [PATCH v5 3/6] rust: irq: add support for non-threaded IRQs and handlers Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250627-topics-tyr-request_irq-v5-3-0545ee4dadf6@collabora.com> References: <20250627-topics-tyr-request_irq-v5-0-0545ee4dadf6@collabora.com> In-Reply-To: <20250627-topics-tyr-request_irq-v5-0-0545ee4dadf6@collabora.com> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Thomas Gleixner , Benno Lossin , Bjorn Helgaas , =?utf-8?q?Krzysztof_Wilczy=C5=84ski?= , Benno Lossin Cc: linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-pci@vger.kernel.org, Daniel Almeida X-Mailer: b4 0.14.2 X-ZohoMailClient: External This patch adds support for non-threaded IRQs and handlers through irq::Registration and the irq::Handler trait. Registering an irq is dependent upon having a IrqRequest that was previously allocated by a given device. This will be introduced in subsequent patches. Signed-off-by: Daniel Almeida --- rust/bindings/bindings_helper.h | 1 + rust/helpers/helpers.c | 1 + rust/helpers/irq.c | 9 ++ rust/kernel/irq.rs | 5 + rust/kernel/irq/request.rs | 267 ++++++++++++++++++++++++++++++++++++= ++++ 5 files changed, 283 insertions(+) diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helpe= r.h index 8cbb660e2ec218021d16e6e0144acf6f4d7cca13..da0bd23fad59a2373bd873d12ad= 69c55208aaa38 100644 --- a/rust/bindings/bindings_helper.h +++ b/rust/bindings/bindings_helper.h @@ -51,6 +51,7 @@ #include #include #include +#include #include #include #include diff --git a/rust/helpers/helpers.c b/rust/helpers/helpers.c index 393ad201befb80a9ae39866a725744ab88620fbb..e3579fc7e1cfc30c913207a4a78= b790259d7ae7a 100644 --- a/rust/helpers/helpers.c +++ b/rust/helpers/helpers.c @@ -22,6 +22,7 @@ #include "dma.c" #include "drm.c" #include "err.c" +#include "irq.c" #include "fs.c" #include "io.c" #include "jump_label.c" diff --git a/rust/helpers/irq.c b/rust/helpers/irq.c new file mode 100644 index 0000000000000000000000000000000000000000..1faca428e2c047a656dec317185= 5c1508d67e60b --- /dev/null +++ b/rust/helpers/irq.c @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include + +int rust_helper_request_irq(unsigned int irq, irq_handler_t handler, + unsigned long flags, const char *name, void *dev) +{ + return request_irq(irq, handler, flags, name, dev); +} diff --git a/rust/kernel/irq.rs b/rust/kernel/irq.rs index 9abd9a6dc36f3e3ecc1f92ad7b0040176b56a079..01bd08884b72c2a3a9460897bce= 751c732a19794 100644 --- a/rust/kernel/irq.rs +++ b/rust/kernel/irq.rs @@ -12,3 +12,8 @@ =20 /// Flags to be used when registering IRQ handlers. pub mod flags; + +/// IRQ allocation and handling. +pub mod request; + +pub use request::{Handler, IrqRequest, IrqReturn, Registration}; diff --git a/rust/kernel/irq/request.rs b/rust/kernel/irq/request.rs new file mode 100644 index 0000000000000000000000000000000000000000..980803b54fcc482b7a42dfa30cd= e23ed57a0bbec --- /dev/null +++ b/rust/kernel/irq/request.rs @@ -0,0 +1,267 @@ +// SPDX-License-Identifier: GPL-2.0 +// SPDX-FileCopyrightText: Copyright 2025 Collabora ltd. + +//! This module provides types like [`Registration`] which allow users to +//! register handlers for a given IRQ line. + +use core::marker::PhantomPinned; + +use crate::alloc::Allocator; +use crate::device::Bound; +use crate::device::Device; +use crate::devres::Devres; +use crate::error::to_result; +use crate::irq::flags::Flags; +use crate::prelude::*; +use crate::str::CStr; +use crate::sync::Arc; + +/// The value that can be returned from an IrqHandler or a ThreadedIrqHand= ler. +pub enum IrqReturn { + /// The interrupt was not from this device or was not handled. + None, + + /// The interrupt was handled by this device. + Handled, +} + +impl IrqReturn { + fn into_inner(self) -> u32 { + match self { + IrqReturn::None =3D> bindings::irqreturn_IRQ_NONE, + IrqReturn::Handled =3D> bindings::irqreturn_IRQ_HANDLED, + } + } +} + +/// Callbacks for an IRQ handler. +pub trait Handler: Sync { + /// The actual handler function. As usual, sleeps are not allowed in I= RQ + /// context. + fn handle(&self) -> IrqReturn; +} + +impl Handler for Arc { + fn handle(&self) -> IrqReturn { + T::handle(self) + } +} + +impl Handler for Box { + fn handle(&self) -> IrqReturn { + T::handle(self) + } +} + +/// # Invariants +/// +/// - `self.irq` is the same as the one passed to `request_{threaded}_irq`. +/// - `cookie` was passed to `request_{threaded}_irq` as the cookie. It +/// is guaranteed to be unique by the type system, since each call to +/// register` will return a different instance of `Registration`. +#[pin_data(PinnedDrop)] +struct RegistrationInner { + irq: u32, + cookie: *mut kernel::ffi::c_void, +} + +impl RegistrationInner { + fn synchronize(&self) { + // SAFETY: safe as per the invariants of `RegistrationInner` + unsafe { bindings::synchronize_irq(self.irq) }; + } +} + +#[pinned_drop] +impl PinnedDrop for RegistrationInner { + fn drop(self: Pin<&mut Self>) { + // SAFETY: + // + // Safe as per the invariants of `RegistrationInner` and: + // + // - The containing struct is `!Unpin` and was initializing using + // pin-init, so it occupied the same memory location for the entir= ety of + // its lifetime. + // + // Notice that this will block until all handlers finish executing, + // i.e.: at no point will &self be invalid while the handler is ru= nning. + unsafe { bindings::free_irq(self.irq, self.cookie) }; + } +} + +// SAFETY: We only use `inner` on drop, which called at most once with no +// concurrent access. +unsafe impl Sync for RegistrationInner {} + +// SAFETY: It is safe to send `RegistrationInner` across threads. +unsafe impl Send for RegistrationInner {} + +/// A request for an IRQ line for a given device. +/// +/// # Invariants +/// +/// - `=C3=ACrq` is the number of an interrupt source of `dev`. +/// - `irq` has not been registered yet. +pub struct IrqRequest<'a> { + dev: &'a Device, + irq: u32, +} + +impl<'a> IrqRequest<'a> { + /// Creates a new IRQ request for the given device and IRQ number. + /// + /// # Safety + /// + /// - `irq` should be a valid IRQ number for `dev`. + pub(crate) unsafe fn new(dev: &'a Device, irq: u32) -> Self { + IrqRequest { dev, irq } + } +} + +/// A registration of an IRQ handler for a given IRQ line. +/// +/// # Examples +/// +/// The following is an example of using `Registration`. It uses a +/// [`AtomicU32`](core::sync::AtomicU32) to provide the interior mutabilit= y. +/// +/// ``` +/// use core::sync::atomic::AtomicU32; +/// use core::sync::atomic::Ordering; +/// +/// use kernel::prelude::*; +/// use kernel::device::Bound; +/// use kernel::irq::flags; +/// use kernel::irq::Registration; +/// use kernel::irq::IrqRequest; +/// use kernel::irq::IrqReturn; +/// use kernel::sync::Arc; +/// use kernel::c_str; +/// use kernel::alloc::flags::GFP_KERNEL; +/// +/// // Declare a struct that will be passed in when the interrupt fires. T= he u32 +/// // merely serves as an example of some internal data. +/// struct Data(AtomicU32); +/// +/// // [`kernel::irq::request::Handler::handle`] takes `&self`. This examp= le +/// // illustrates how interior mutability can be used when sharing the da= ta +/// // between process context and IRQ context. +/// +/// type Handler =3D Data; +/// +/// impl kernel::irq::request::Handler for Handler { +/// // This is executing in IRQ context in some CPU. Other CPUs can st= ill +/// // try to access to data. +/// fn handle(&self) -> IrqReturn { +/// self.0.fetch_add(1, Ordering::Relaxed); +/// +/// IrqReturn::Handled +/// } +/// } +/// +/// // Registers an IRQ handler for the given IrqRequest. +/// // +/// // This is executing in process context and assumes that `request` was +/// // previously acquired from a device. +/// fn register_irq(handler: Handler, request: IrqRequest<'_>) -> Result>> { +/// let registration =3D Registration::new(request, flags::SHARED, c_s= tr!("my_device"), handler); +/// +/// let registration =3D Arc::pin_init(registration, GFP_KERNEL)?; +/// +/// // The data can be accessed from process context too. +/// registration.handler().0.fetch_add(1, Ordering::Relaxed); +/// +/// Ok(registration) +/// } +/// # Ok::<(), Error>(()) +/// ``` +/// +/// # Invariants +/// +/// * We own an irq handler using `&self.handler` as its private data. +/// +#[pin_data] +pub struct Registration { + #[pin] + inner: Devres, + + #[pin] + handler: T, + + /// Pinned because we need address stability so that we can pass a poi= nter + /// to the callback. + #[pin] + _pin: PhantomPinned, +} + +impl Registration { + /// Registers the IRQ handler with the system for the given IRQ number. + pub fn new<'a>( + request: IrqRequest<'a>, + flags: Flags, + name: &'static CStr, + handler: T, + ) -> impl PinInit + 'a { + try_pin_init!(&this in Self { + handler, + inner <- Devres::new( + request.dev, + try_pin_init!(RegistrationInner { + // SAFETY: `this` is a valid pointer to the `Registrat= ion` instance + cookie: unsafe { &raw mut (*this.as_ptr()).handler }.c= ast(), + irq: { + // SAFETY: + // - The callbacks are valid for use with request_= irq. + // - If this succeeds, the slot is guaranteed to b= e valid until the + // destructor of Self runs, which will deregister = the callbacks + // before the memory location becomes invalid. + to_result(unsafe { + bindings::request_irq( + request.irq, + Some(handle_irq_callback::), + flags.into_inner() as usize, + name.as_char_ptr(), + (&raw mut (*this.as_ptr()).handler).cast(), + ) + })?; + request.irq + } + }) + ), + _pin: PhantomPinned, + }) + } + + /// Returns a reference to the handler that was registered with the sy= stem. + pub fn handler(&self) -> &T { + &self.handler + } + + /// Wait for pending IRQ handlers on other CPUs. + /// + /// This will attempt to access the inner [`Devres`] container. + pub fn try_synchronize(&self) -> Result { + let inner =3D self.inner.try_access().ok_or(ENODEV)?; + inner.synchronize(); + Ok(()) + } + + /// Wait for pending IRQ handlers on other CPUs. + pub fn synchronize(&self, dev: &Device) -> Result { + let inner =3D self.inner.access(dev)?; + inner.synchronize(); + Ok(()) + } +} + +/// # Safety +/// +/// This function should be only used as the callback in `request_irq`. +unsafe extern "C" fn handle_irq_callback( + _irq: i32, + ptr: *mut core::ffi::c_void, +) -> core::ffi::c_uint { + // SAFETY: `ptr` is a pointer to T set in `Registration::new` + let handler =3D unsafe { &*(ptr as *const T) }; + T::handle(handler).into_inner() +} --=20 2.50.0 From nobody Wed Oct 8 12:36:09 2025 Received: from sender4-pp-f112.zoho.com (sender4-pp-f112.zoho.com [136.143.188.112]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9EB042EAB89; Fri, 27 Jun 2025 16:22:15 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=pass smtp.client-ip=136.143.188.112 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751041337; cv=pass; b=EMKuQ3+PJ3A7cOnDvK8qpx5fJU6fNh5W//8KZGkDnT2caxAWHuLy9CLVLY5oWBNrlR12FE5S5dbAoxt6jwEElU0mCJVZGNAV2YORf5k7JN4V2fjUSlg1jiYdgTZ5nwKnzwi/EklAZK/ePJgO+aKl+TaxDTKB50nBIJu6TZtze0Q= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751041337; c=relaxed/simple; bh=XT90ZCY0cK5tLKrcs0GiMqpMHSQGHn1rqMeStYSPh6g=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=k/Hnm6bT9CvIsHJemzYrrQyPsX2wxdH1Ub7Pyjbz0Oa/sF4/VUI29nZdPEOHtucaQlR1j0f4KsvGpFQ4FEdwvaBWcG9x+Zg+veIG+rH+cJp/HFE7owad/j0wzn9fcjAhV5WxwlnAoPa0xzvVdhujB4dUcq7D78MapXEWQ8mu5Us= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com; spf=pass smtp.mailfrom=collabora.com; dkim=pass (1024-bit key) header.d=collabora.com header.i=daniel.almeida@collabora.com header.b=c287lIHo; arc=pass smtp.client-ip=136.143.188.112 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=collabora.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=collabora.com header.i=daniel.almeida@collabora.com header.b="c287lIHo" ARC-Seal: i=1; a=rsa-sha256; t=1751041310; cv=none; d=zohomail.com; s=zohoarc; b=Z9Wv5zMPDNo6zREsYBq4Sf2bercy2eU7yB5E6WKq74Eff+87ISfCMMltpOdkhe5Gcbxc0hxzo/aa+oEXU9SqIvUeWwsjKnFjUGXd1cWoCHQ3dYFt/g6Zs1euILdI9W93vXUIzgcbPwdwf1J3+8pmJH72o71+ZNRAD8ZAd41UQN8= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1751041310; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:MIME-Version:Message-ID:References:Subject:Subject:To:To:Message-Id:Reply-To; bh=SHEK1SG4xOfkLhryYT/WkgHuKX/Wf2xzFHRxYOq/ics=; b=XI12ERhW0FFKLLk1plY0PZF2n0KPMcAmneJnczCTzfv/4ToG9c+b27LImMDBQ8Zt5ajqR4bdztfwFKq5R7mtVkt8Ppm1N5KUhWuY6JPcmcfoPMOr5ib7tvOaAWGyqZNopXJOFRi1lXjtVPT8EM+jr1mLCPxVAOE7zRVSu6v3TM8= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass header.i=collabora.com; spf=pass smtp.mailfrom=daniel.almeida@collabora.com; dmarc=pass header.from= DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; t=1751041309; s=zohomail; d=collabora.com; i=daniel.almeida@collabora.com; h=From:From:Date:Date:Subject:Subject:MIME-Version:Content-Type:Content-Transfer-Encoding:Message-Id:Message-Id:References:In-Reply-To:To:To:Cc:Cc:Reply-To; bh=SHEK1SG4xOfkLhryYT/WkgHuKX/Wf2xzFHRxYOq/ics=; b=c287lIHogLCeQojPJ7JN+BJyIUCSyz2hlwwTEYH6w72FdfqpYaBD3p55t+8vvYZR fOypzL/pYOhbklf9UXtV9/OfFDHNccuAi+3a5HlKjyb+cwLhB3eCEaCb+v4bS/0aJDW HJ0SflMT1zlipWj3mx/xHpOzr5eFWPi2aZsA+WEM= Received: by mx.zohomail.com with SMTPS id 1751041306382261.8961078567744; Fri, 27 Jun 2025 09:21:46 -0700 (PDT) From: Daniel Almeida Date: Fri, 27 Jun 2025 13:21:06 -0300 Subject: [PATCH v5 4/6] rust: irq: add support for threaded IRQs and handlers Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250627-topics-tyr-request_irq-v5-4-0545ee4dadf6@collabora.com> References: <20250627-topics-tyr-request_irq-v5-0-0545ee4dadf6@collabora.com> In-Reply-To: <20250627-topics-tyr-request_irq-v5-0-0545ee4dadf6@collabora.com> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Thomas Gleixner , Benno Lossin , Bjorn Helgaas , =?utf-8?q?Krzysztof_Wilczy=C5=84ski?= , Benno Lossin Cc: linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-pci@vger.kernel.org, Daniel Almeida X-Mailer: b4 0.14.2 X-ZohoMailClient: External This patch adds support for threaded IRQs and handlers through irq::ThreadedRegistration and the irq::ThreadedHandler trait. Threaded interrupts are more permissive in the sense that further processing is possible in a kthread. This means that said execution takes place outside of interrupt context, which is rather restrictive in many ways. Registering a threaded irq is dependent upon having an IrqRequest that was previously allocated by a given device. This will be introduced in subsequent patches. Signed-off-by: Daniel Almeida --- rust/kernel/irq.rs | 5 +- rust/kernel/irq/request.rs | 233 +++++++++++++++++++++++++++++++++++++++++= +++- 2 files changed, 235 insertions(+), 3 deletions(-) diff --git a/rust/kernel/irq.rs b/rust/kernel/irq.rs index 01bd08884b72c2a3a9460897bce751c732a19794..aaa40001bafca617c588c799bb4= 1144921595cae 100644 --- a/rust/kernel/irq.rs +++ b/rust/kernel/irq.rs @@ -16,4 +16,7 @@ /// IRQ allocation and handling. pub mod request; =20 -pub use request::{Handler, IrqRequest, IrqReturn, Registration}; +pub use request::{ + Handler, IrqRequest, IrqReturn, Registration, ThreadedHandler, Threade= dIrqReturn, + ThreadedRegistration, +}; diff --git a/rust/kernel/irq/request.rs b/rust/kernel/irq/request.rs index 980803b54fcc482b7a42dfa30cde23ed57a0bbec..7a6e3e7ac2045d6a33f81472c02= ee2c81372dec8 100644 --- a/rust/kernel/irq/request.rs +++ b/rust/kernel/irq/request.rs @@ -1,8 +1,9 @@ // SPDX-License-Identifier: GPL-2.0 // SPDX-FileCopyrightText: Copyright 2025 Collabora ltd. =20 -//! This module provides types like [`Registration`] which allow users to -//! register handlers for a given IRQ line. +//! This module provides types like [`Registration`] and +//! [`ThreadedRegistration`], which allow users to register handlers for a= given +//! IRQ line. =20 use core::marker::PhantomPinned; =20 @@ -265,3 +266,231 @@ pub fn synchronize(&self, dev: &Device) -> Res= ult { let handler =3D unsafe { &*(ptr as *const T) }; T::handle(handler).into_inner() } + +/// The value that can be returned from `ThreadedHandler::handle_irq`. +pub enum ThreadedIrqReturn { + /// The interrupt was not from this device or was not handled. + None, + + /// The interrupt was handled by this device. + Handled, + + /// The handler wants the handler thread to wake up. + WakeThread, +} + +impl ThreadedIrqReturn { + fn into_inner(self) -> u32 { + match self { + ThreadedIrqReturn::None =3D> bindings::irqreturn_IRQ_NONE, + ThreadedIrqReturn::Handled =3D> bindings::irqreturn_IRQ_HANDLE= D, + ThreadedIrqReturn::WakeThread =3D> bindings::irqreturn_IRQ_WAK= E_THREAD, + } + } +} + +/// Callbacks for a threaded IRQ handler. +pub trait ThreadedHandler: Sync { + /// The actual handler function. As usual, sleeps are not allowed in I= RQ + /// context. + fn handle(&self) -> ThreadedIrqReturn; + + /// The threaded handler function. This function is called from the irq + /// handler thread, which is automatically created by the system. + fn handle_on_thread(&self) -> IrqReturn; +} + +impl ThreadedHandler for Arc { + fn handle(&self) -> ThreadedIrqReturn { + T::handle(self) + } + + fn handle_on_thread(&self) -> IrqReturn { + T::handle_on_thread(self) + } +} + +impl ThreadedHandler for Box { + fn handle(&self) -> ThreadedIrqReturn { + T::handle(self) + } + + fn handle_on_thread(&self) -> IrqReturn { + T::handle_on_thread(self) + } +} + +/// A registration of a threaded IRQ handler for a given IRQ line. +/// +/// Two callbacks are required: one to handle the IRQ, and one to handle a= ny +/// other work in a separate thread. +/// +/// The thread handler is only called if the IRQ handler returns `WakeThre= ad`. +/// +/// # Examples +/// +/// The following is an example of using `ThreadedRegistration`. It uses a +/// [`AtomicU32`](core::sync::AtomicU32) to provide the interior mutabilit= y. +/// +/// ``` +/// use core::sync::atomic::AtomicU32; +/// use core::sync::atomic::Ordering; +/// +/// use kernel::prelude::*; +/// use kernel::device::Bound; +/// use kernel::irq::flags; +/// use kernel::irq::ThreadedIrqReturn; +/// use kernel::irq::ThreadedRegistration; +/// use kernel::irq::IrqRequest; +/// use kernel::irq::IrqReturn; +/// use kernel::sync::Arc; +/// use kernel::c_str; +/// use kernel::alloc::flags::GFP_KERNEL; +/// +/// // Declare a struct that will be passed in when the interrupt fires. T= he u32 +/// // merely serves as an example of some internal data. +/// struct Data(AtomicU32); +/// +/// // [`kernel::irq::request::ThreadedHandler::handle`] takes `&self`. Th= is example +/// // illustrates how interior mutability can be used when sharing the da= ta +/// // between process context and IRQ context. +/// type Handler =3D Data; +/// +/// impl kernel::irq::request::ThreadedHandler for Handler { +/// // This is executing in IRQ context in some CPU. Other CPUs can st= ill +/// // try to access the data. +/// fn handle(&self) -> ThreadedIrqReturn { +/// self.0.fetch_add(1, Ordering::Relaxed); +/// // By returning `WakeThread`, we indicate to the system that t= he +/// // thread function should be called. Otherwise, return +/// // ThreadedIrqReturn::Handled. +/// ThreadedIrqReturn::WakeThread +/// } +/// +/// // This will run (in a separate kthread) if and only if `handle` +/// // returns `WakeThread`. +/// fn handle_on_thread(&self) -> IrqReturn { +/// self.0.fetch_add(1, Ordering::Relaxed); +/// IrqReturn::Handled +/// } +/// } +/// +/// // Registers a threaded IRQ handler for the given IrqRequest. +/// // +/// // This is executing in process context and assumes that `request` was +/// // previously acquired from a device. +/// fn register_threaded_irq(handler: Handler, request: IrqRequest<'_>) ->= Result>> { +/// let registration =3D ThreadedRegistration::new(request, flags::SHA= RED, c_str!("my_device"), handler); +/// +/// let registration =3D Arc::pin_init(registration, GFP_KERNEL)?; +/// +/// // The data can be accessed from process context too. +/// registration.handler().0.fetch_add(1, Ordering::Relaxed); +/// +/// Ok(registration) +/// } +/// # Ok::<(), Error>(()) +/// ``` +/// +/// # Invariants +/// +/// * We own an irq handler using `&T` as its private data. +/// +#[pin_data] +pub struct ThreadedRegistration { + #[pin] + inner: Devres, + + #[pin] + handler: T, + + /// Pinned because we need address stability so that we can pass a poi= nter + /// to the callback. + #[pin] + _pin: PhantomPinned, +} + +impl ThreadedRegistration { + /// Registers the IRQ handler with the system for the given IRQ number. + pub fn new<'a>( + request: IrqRequest<'a>, + flags: Flags, + name: &'static CStr, + handler: T, + ) -> impl PinInit + 'a { + try_pin_init!(&this in Self { + handler, + inner <- Devres::new( + request.dev, + try_pin_init!(RegistrationInner { + // SAFETY: `this` is a valid pointer to the `ThreadedR= egistration` instance. + cookie: unsafe { &raw mut (*this.as_ptr()).handler }.c= ast(), + irq: { + // SAFETY: + // - The callbacks are valid for use with request_= threaded_irq. + // - If this succeeds, the slot is guaranteed to b= e valid until the + // destructor of Self runs, which will deregister = the callbacks + // before the memory location becomes invalid. + to_result(unsafe { + bindings::request_threaded_irq( + request.irq, + Some(handle_threaded_irq_callback::), + Some(thread_fn_callback::), + flags.into_inner() as usize, + name.as_char_ptr(), + (&raw mut (*this.as_ptr()).handler).cast(), + ) + })?; + request.irq + } + }) + ), + _pin: PhantomPinned, + }) + } + + /// Returns a reference to the handler that was registered with the sy= stem. + pub fn handler(&self) -> &T { + &self.handler + } + + /// Wait for pending IRQ handlers on other CPUs. + /// + /// This will attempt to access the inner [`Devres`] container. + pub fn try_synchronize(&self) -> Result { + let inner =3D self.inner.try_access().ok_or(ENODEV)?; + inner.synchronize(); + Ok(()) + } + + /// Wait for pending IRQ handlers on other CPUs. + pub fn synchronize(&self, dev: &Device) -> Result { + let inner =3D self.inner.access(dev)?; + inner.synchronize(); + Ok(()) + } +} + +/// # Safety +/// +/// This function should be only used as the callback in `request_threaded= _irq`. +unsafe extern "C" fn handle_threaded_irq_callback( + _irq: i32, + ptr: *mut core::ffi::c_void, +) -> core::ffi::c_uint { + // SAFETY: `ptr` is a pointer to T set in `ThreadedRegistration::new` + let handler =3D unsafe { &*(ptr as *const T) }; + T::handle(handler).into_inner() +} + +/// # Safety +/// +/// This function should be only used as the callback in `request_threaded= _irq`. +unsafe extern "C" fn thread_fn_callback( + _irq: i32, + ptr: *mut core::ffi::c_void, +) -> core::ffi::c_uint { + // SAFETY: `ptr` is a pointer to T set in `ThreadedRegistration::new` + let handler =3D unsafe { &*(ptr as *const T) }; + T::handle_on_thread(handler).into_inner() +} --=20 2.50.0 From nobody Wed Oct 8 12:36:09 2025 Received: from sender4-pp-f112.zoho.com (sender4-pp-f112.zoho.com [136.143.188.112]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 50A9A2EA72E; Fri, 27 Jun 2025 16:22:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=pass smtp.client-ip=136.143.188.112 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751041334; cv=pass; b=hspSQ0bN+q4zl595pfDQOaxXcvWMDeMtukwjJHnxVpaICzmlRwK0CtB3JGEu/p3JWrAp3fT3E0j2dU+YOSwj6/DN4lGcDHGQhlnvmEA2/hWM27seetgQA4qaX+Gd0hGjM9qgXsGHQRq5JwKvOqq5VFTUXqfBCGM9g3UsUfasXq0= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751041334; c=relaxed/simple; bh=KLXw+OaY2NDeo85zk7ENOxEhBfepWsHYrLcPshx09m0=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=JE+4AJiZzdSF04kMyMYN7U1XVQff3MUpl1aiAj/k3cnPC0YLGrQfxtQH6FSSpHvmlnW16pR/oKuyOlVPNsWxjFNWs/EjQ8tD1OJrwaOC7LQssr2OZ3DErz3c3erZkyWmfSPO/7yl6MPbaqk98C32MG+uLEzRpUNY9BqNEHIlKBI= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com; spf=pass smtp.mailfrom=collabora.com; dkim=pass (1024-bit key) header.d=collabora.com header.i=daniel.almeida@collabora.com header.b=YwHqn3IC; arc=pass smtp.client-ip=136.143.188.112 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=collabora.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=collabora.com header.i=daniel.almeida@collabora.com header.b="YwHqn3IC" ARC-Seal: i=1; a=rsa-sha256; t=1751041313; cv=none; d=zohomail.com; s=zohoarc; b=lnckAKUzADuTtHWRQ5Zq2Q5K2xwYR6IDgCvzQ8u7F6qndsRxzktzc54P6HmwAEGgo6l0SzD+fzv1rXN9GDF547pCrxOOMXidiuXeje0YWCPhWJum6J0iJPZqiB0bLh1jOO2XeDbOxFFaQxmvJQ3fsEewQJyqPqirD3HLceh8pPc= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1751041313; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:MIME-Version:Message-ID:References:Subject:Subject:To:To:Message-Id:Reply-To; bh=6O01K+F5jowW9CoOU1UVPobWVghj0zzB8ULxZJtQryc=; b=If7/P5XfQf3o73q/tTBB3aykwyOAoQqZRVIX6heaMMMW9D7533eXjuNTYPl8sBXjnDw4tu7Z/5isxOw+e63ELMcpCp+SHc7MXRJjJkv6omtvz3H4wxciP0lra1utayAULq1Y1LG9Cga3xoFZM9B0qGxW7dIcad9qLPaGzHEQbfE= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass header.i=collabora.com; spf=pass smtp.mailfrom=daniel.almeida@collabora.com; dmarc=pass header.from= DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; t=1751041313; s=zohomail; d=collabora.com; i=daniel.almeida@collabora.com; h=From:From:Date:Date:Subject:Subject:MIME-Version:Content-Type:Content-Transfer-Encoding:Message-Id:Message-Id:References:In-Reply-To:To:To:Cc:Cc:Reply-To; bh=6O01K+F5jowW9CoOU1UVPobWVghj0zzB8ULxZJtQryc=; b=YwHqn3ICbOyz/Al95GJ+tykl3gCVXnvptmPnj4nQZaJT2TLAKOMHBcLhzD/mwpLa lcYi065GbBN29vwvMlvDblYnGr586RKszJ57hbbKwB4eP/bSYM3hW2BL9Wm1y0v44jI aBGs50TcuiwWLAh2uv0BWpcAnUwWq89SlSVtDnUw= Received: by mx.zohomail.com with SMTPS id 1751041310683255.86644801338673; Fri, 27 Jun 2025 09:21:50 -0700 (PDT) From: Daniel Almeida Date: Fri, 27 Jun 2025 13:21:07 -0300 Subject: [PATCH v5 5/6] rust: platform: add irq accessors Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250627-topics-tyr-request_irq-v5-5-0545ee4dadf6@collabora.com> References: <20250627-topics-tyr-request_irq-v5-0-0545ee4dadf6@collabora.com> In-Reply-To: <20250627-topics-tyr-request_irq-v5-0-0545ee4dadf6@collabora.com> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Thomas Gleixner , Benno Lossin , Bjorn Helgaas , =?utf-8?q?Krzysztof_Wilczy=C5=84ski?= , Benno Lossin Cc: linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-pci@vger.kernel.org, Daniel Almeida X-Mailer: b4 0.14.2 X-ZohoMailClient: External These accessors can be used to retrieve a irq::Registration and irq::ThreadedRegistration from a platform device by index or name. Alternatively, drivers can retrieve an IrqRequest from a bound platform device for later use. These accessors ensure that only valid IRQ lines can ever be registered. Signed-off-by: Daniel Almeida --- rust/kernel/platform.rs | 143 ++++++++++++++++++++++++++++++++++++++++++++= +++- 1 file changed, 142 insertions(+), 1 deletion(-) diff --git a/rust/kernel/platform.rs b/rust/kernel/platform.rs index 5b21fa517e55348582622ec10471918919502959..e709afd2a3c3a4383add8174baa= 4163800e9c80c 100644 --- a/rust/kernel/platform.rs +++ b/rust/kernel/platform.rs @@ -5,8 +5,11 @@ //! C header: [`include/linux/platform_device.h`](srctree/include/linux/pl= atform_device.h) =20 use crate::{ - bindings, container_of, device, driver, + bindings, container_of, + device::{self, Bound}, + driver, error::{to_result, Result}, + irq::{self, request::IrqRequest}, of, prelude::*, str::CStr, @@ -190,6 +193,144 @@ fn as_raw(&self) -> *mut bindings::platform_device { } } =20 +macro_rules! define_irq_accessor_by_index { + ($(#[$meta:meta])* $fn_name:ident, $request_fn:ident, $reg_type:ident,= $handler_trait:ident) =3D> { + $(#[$meta])* + pub fn $fn_name( + &self, + index: u32, + flags: irq::flags::Flags, + name: &'static CStr, + handler: T, + ) -> Result, Error> + '_> { + let request =3D self.$request_fn(index)?; + + Ok(irq::$reg_type::::new( + request, + flags, + name, + handler, + )) + } + }; +} + +macro_rules! define_irq_accessor_by_name { + ($(#[$meta:meta])* $fn_name:ident, $request_fn:ident, $reg_type:ident,= $handler_trait:ident) =3D> { + $(#[$meta])* + pub fn $fn_name( + &self, + irq_name: &'static CStr, + name: &'static CStr, + flags: irq::flags::Flags, + handler: T, + ) -> Result, Error> + '_> { + let request =3D self.$request_fn(irq_name)?; + + Ok(irq::$reg_type::::new( + request, + flags, + name, + handler, + )) + } + }; +} + +impl Device { + /// Returns an [`IrqRequest`] for the IRQ at the given index, if any. + pub fn request_irq_by_index(&self, index: u32) -> Result> { + // SAFETY: `self.as_raw` returns a valid pointer to a `struct plat= form_device`. + let irq =3D unsafe { bindings::platform_get_irq(self.as_raw(), ind= ex) }; + + if irq < 0 { + return Err(Error::from_errno(irq)); + } + + // SAFETY: `irq` is guaranteed to be a valid IRQ number for `&self= `. + Ok(unsafe { IrqRequest::new(self.as_ref(), irq as u32) }) + } + + /// Returns an [`IrqRequest`] for the IRQ at the given index, but does= not print an error if the IRQ cannot be obtained. + pub fn request_optional_irq_by_index(&self, index: u32) -> Result> { + // SAFETY: `self.as_raw` returns a valid pointer to a `struct plat= form_device`. + let irq =3D unsafe { bindings::platform_get_irq_optional(self.as_r= aw(), index) }; + + if irq < 0 { + return Err(Error::from_errno(irq)); + } + + // SAFETY: `irq` is guaranteed to be a valid IRQ number for `&self= `. + Ok(unsafe { IrqRequest::new(self.as_ref(), irq as u32) }) + } + + /// Returns an [`IrqRequest`] for the IRQ with the given name, if any. + pub fn request_irq_by_name(&self, name: &'static CStr) -> Result> { + // SAFETY: `self.as_raw` returns a valid pointer to a `struct plat= form_device`. + let irq =3D unsafe { bindings::platform_get_irq_byname(self.as_raw= (), name.as_char_ptr()) }; + + if irq < 0 { + return Err(Error::from_errno(irq)); + } + + // SAFETY: `irq` is guaranteed to be a valid IRQ number for `&self= `. + Ok(unsafe { IrqRequest::new(self.as_ref(), irq as u32) }) + } + + /// Returns an [`IrqRequest`] for the IRQ with the given name, but doe= s not print an error if the IRQ cannot be obtained. + pub fn request_optional_irq_by_name(&self, name: &'static CStr) -> Res= ult> { + // SAFETY: `self.as_raw` returns a valid pointer to a `struct plat= form_device`. + let irq =3D unsafe { + bindings::platform_get_irq_byname_optional(self.as_raw(), name= .as_char_ptr()) + }; + + if irq < 0 { + return Err(Error::from_errno(irq)); + } + + // SAFETY: `irq` is guaranteed to be a valid IRQ number for `&self= `. + Ok(unsafe { IrqRequest::new(self.as_ref(), irq as u32) }) + } + + define_irq_accessor_by_index!( + /// Returns a [`irq::Registration`] for the IRQ at the given index. + irq_by_index, request_irq_by_index, Registration, Handler + ); + define_irq_accessor_by_name!( + /// Returns a [`irq::Registration`] for the IRQ with the given nam= e. + irq_by_name, request_irq_by_name, Registration, Handler + ); + define_irq_accessor_by_index!( + /// Does the same as [`Self::irq_by_index`], except that it does n= ot + /// print an error message if the IRQ cannot be obtained. + optional_irq_by_index, request_optional_irq_by_index, Registration= , Handler + ); + define_irq_accessor_by_name!( + /// Does the same as [`Self::irq_by_name`], except that it does not + /// print an error message if the IRQ cannot be obtained. + optional_irq_by_name, request_optional_irq_by_name, Registration, = Handler + ); + + define_irq_accessor_by_index!( + /// Returns a [`irq::ThreadedRegistration`] for the IRQ at the giv= en index. + threaded_irq_by_index, request_irq_by_index, ThreadedRegistration,= ThreadedHandler + ); + define_irq_accessor_by_name!( + /// Returns a [`irq::ThreadedRegistration`] for the IRQ with the g= iven name. + threaded_irq_by_name, request_irq_by_name, ThreadedRegistration, T= hreadedHandler + ); + define_irq_accessor_by_index!( + /// Does the same as [`Self::threaded_irq_by_index`], except that = it + /// does not print an error message if the IRQ cannot be obtained. + optional_threaded_irq_by_index, request_optional_irq_by_index, Thr= eadedRegistration, ThreadedHandler + ); + define_irq_accessor_by_name!( + /// Does the same as [`Self::threaded_irq_by_name`], except that it + /// does not print an error message if the IRQ cannot be obtained. + optional_threaded_irq_by_name, request_optional_irq_by_name, Threa= dedRegistration, ThreadedHandler + ); +} + // SAFETY: `Device` is a transparent wrapper of a type that doesn't depend= on `Device`'s generic // argument. kernel::impl_device_context_deref!(unsafe { Device }); --=20 2.50.0 From nobody Wed Oct 8 12:36:09 2025 Received: from sender4-pp-f112.zoho.com (sender4-pp-f112.zoho.com [136.143.188.112]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3A9B92EAB80; Fri, 27 Jun 2025 16:22:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=pass smtp.client-ip=136.143.188.112 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751041337; cv=pass; b=iRpruJo/8Yy9fZm02VBO2Xry3Hy/bvK3B4mmQkMGPGGrSoxS4NgW8oVQ5UF5BOyStkaw1A6Um3Mmg0tEnXvhdkGvI2EfW0qfqUZnqw8x3pELwC73i1Ovt4q+Rm4uQQpVjBJ8ZRr1Bna8PeURKpOqr+v280LzrLL8ajTLqeZTDcA= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751041337; c=relaxed/simple; bh=9QVLNmpFlJxco9Io8+xRWl3/tkfvBnkJ5v4p1lVDt5M=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=VcL4qnHCI+8iNlECYrwKpMZ7Eizn49YtaKRQ6wiJL//t7GUSU2pa/gILw2a5ZNUzofaRcxuAzq2KsuTwa1sCT7TVur9bs7V8CFB8amkDP7A/XU7vG2WUVhndKg7olALq1+/UPjQtG2b2mxweOQNCva31yUtcOlPBm1zz4TEFFhY= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com; spf=pass smtp.mailfrom=collabora.com; dkim=pass (1024-bit key) header.d=collabora.com header.i=daniel.almeida@collabora.com header.b=YwGaNcv2; arc=pass smtp.client-ip=136.143.188.112 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=collabora.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=collabora.com header.i=daniel.almeida@collabora.com header.b="YwGaNcv2" ARC-Seal: i=1; a=rsa-sha256; t=1751041317; cv=none; d=zohomail.com; s=zohoarc; b=A5+fBBw1v95twjhxnyHpCGxc12/Aas6YeGTGuPC6frODMdjnjnbHLAHvkPhlSzRIcefhoHKW5PTkSvioMV5ZyvGmywZ6IF7d0TZd6p0wZdMAkQoYPjhJX9jYZ5ywgIcr9IqB1Lqc6wUCzsFr2FL+bT3Tck455Q17bXEWKOih5P0= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1751041317; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:MIME-Version:Message-ID:References:Subject:Subject:To:To:Message-Id:Reply-To; bh=8KUHteAG14bnq4zqajKJEsvYdoQ2vrt6l/2WIKsu2Dc=; b=AP/WW/g/PvwTBliseLvB5kTJw+EzDWvkcmSyULAXDH1jG4pz8CALaLYF/cDb5MMo/5BfJhTIn0jAKhhFeT3X8TyYx97267gDXzONHTZdnhJqRTZB7uJp8j8vhgAqUiqtGEw4UQxB/lfahGLSx/qRAeOtir9KaUBrHq7BnOV01DI= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass header.i=collabora.com; spf=pass smtp.mailfrom=daniel.almeida@collabora.com; dmarc=pass header.from= DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; t=1751041317; s=zohomail; d=collabora.com; i=daniel.almeida@collabora.com; h=From:From:Date:Date:Subject:Subject:MIME-Version:Content-Type:Content-Transfer-Encoding:Message-Id:Message-Id:References:In-Reply-To:To:To:Cc:Cc:Reply-To; bh=8KUHteAG14bnq4zqajKJEsvYdoQ2vrt6l/2WIKsu2Dc=; b=YwGaNcv2htqWgrIfh4UYa4O0olbuAvBjf4Awqpyg8JRZqBzWR9QSrqP42K1K2x6I XV8xF+UBKcKzCNwjK3rP1AS2fPmSe8QFnKDQbXfZl3s7u8SqZ70HrCr9j+RfuQnnbWu V1c2ozJODWN4SZavR158W8X3mTeImmADT7By9Gdc= Received: by mx.zohomail.com with SMTPS id 1751041315119984.016417825778; Fri, 27 Jun 2025 09:21:55 -0700 (PDT) From: Daniel Almeida Date: Fri, 27 Jun 2025 13:21:08 -0300 Subject: [PATCH v5 6/6] rust: pci: add irq accessors Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250627-topics-tyr-request_irq-v5-6-0545ee4dadf6@collabora.com> References: <20250627-topics-tyr-request_irq-v5-0-0545ee4dadf6@collabora.com> In-Reply-To: <20250627-topics-tyr-request_irq-v5-0-0545ee4dadf6@collabora.com> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Thomas Gleixner , Benno Lossin , Bjorn Helgaas , =?utf-8?q?Krzysztof_Wilczy=C5=84ski?= , Benno Lossin Cc: linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-pci@vger.kernel.org, Daniel Almeida X-Mailer: b4 0.14.2 X-ZohoMailClient: External These accessors can be used to retrieve a irq::Registration or a irq::ThreadedRegistration from a pci device. Alternatively, drivers can retrieve an IrqRequest from a bound PCI device for later use. These accessors ensure that only valid IRQ lines can ever be registered. Signed-off-by: Daniel Almeida --- rust/helpers/pci.c | 8 ++++++++ rust/kernel/pci.rs | 45 +++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 51 insertions(+), 2 deletions(-) diff --git a/rust/helpers/pci.c b/rust/helpers/pci.c index cd0e6bf2cc4d9b37db3a717e7a8422b054f348ec..f372a32e8fd19730563ab51500e= 8c8764854ae47 100644 --- a/rust/helpers/pci.c +++ b/rust/helpers/pci.c @@ -21,3 +21,11 @@ bool rust_helper_dev_is_pci(const struct device *dev) { return dev_is_pci(dev); } + +#ifndef CONFIG_PCI_MSI +int rust_helper_pci_irq_vector(struct pci_dev *pdev, unsigned int nvec) +{ + return pci_irq_vector(pdev, nvec); +} + +#endif diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs index db0eb7eaf9b10c5316366ef16fe722a03044a517..60d37d6459518c79136535ce03c= 73a5a3097eda8 100644 --- a/rust/kernel/pci.rs +++ b/rust/kernel/pci.rs @@ -10,8 +10,8 @@ devres::Devres, driver, error::{to_result, Result}, - io::Io, - io::IoRaw, + io::{Io, IoRaw}, + irq::{self, request::IrqRequest}, str::CStr, types::{ARef, ForeignOwnable, Opaque}, ThisModule, @@ -413,6 +413,47 @@ pub fn iomap_region<'a>( ) -> impl PinInit, Error> + 'a { self.iomap_region_sized::<0>(bar, name) } + + /// Returns an [`IrqRequest`] for the IRQ vector at the given index, i= f any. + pub fn request_irq_by_index(&self, index: u32) -> Result> { + // SAFETY: `self.as_raw` returns a valid pointer to a `struct pci_= dev`. + let irq =3D unsafe { crate::bindings::pci_irq_vector(self.as_raw()= , index) }; + if irq < 0 { + return Err(crate::error::Error::from_errno(irq)); + } + // SAFETY: `irq` is guaranteed to be a valid IRQ number for `&self= `. + Ok(unsafe { IrqRequest::new(self.as_ref(), irq as u32) }) + } + + /// Returns a [`kernel::irq::Registration`] for the IRQ vector at the = given + /// index. + pub fn irq_by_index( + &self, + index: u32, + flags: irq::flags::Flags, + name: &'static CStr, + handler: T, + ) -> Result, Error> + '_> { + let request =3D self.request_irq_by_index(index)?; + + Ok(irq::Registration::::new(request, flags, name, handler)) + } + + /// Returns a [`kernel::irq::ThreadedRegistration`] for the IRQ vector= at + /// the given index. + pub fn threaded_irq_by_index( + &self, + index: u32, + flags: irq::flags::Flags, + name: &'static CStr, + handler: T, + ) -> Result, Error> + '_> { + let request =3D self.request_irq_by_index(index)?; + + Ok(irq::ThreadedRegistration::::new( + request, flags, name, handler, + )) + } } =20 impl Device { --=20 2.50.0