[PATCH AUTOSEL 6.19-5.10] iio: magnetometer: Remove IRQF_ONESHOT

[Sasha Levin <sashal@kernel.org>]

From: Sebastian Andrzej Siewior <bigeasy@linutronix.de>

[ Upstream commit a54e9440925e6617c98669066b4753c4cdcea8a0 ]

Passing IRQF_ONESHOT ensures that the interrupt source is masked until
the secondary (threaded) handler is done. If only a primary handler is
used then the flag makes no sense because the interrupt can not fire
(again) while its handler is running.
The flag also disallows force-threading of the primary handler and the
irq-core will warn about this.
The force-threading functionality is required on PREEMPT_RT because the
handler is using locks with can sleep on PREEMPT_RT.

Remove IRQF_ONESHOT from irqflags.

Tested-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@intel.com>
Reviewed-by: Nuno Sá <nuno.sa@analog.com>
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Signed-off-by: Sasha Levin <sashal@kernel.org>
---

LLM Generated explanations, may be completely bogus:

`IRQF_ONESHOT` has been in this driver since 2013, so it's present in
all stable trees that contain this driver.

## Classification

This fix addresses a **real bug on PREEMPT_RT kernels**:
- With `IRQF_ONESHOT` set, `irq_setup_forced_threading()` returns early
  (line 1295 of `kernel/irq/manage.c`), preventing the interrupt handler
  from being force-threaded
- On PREEMPT_RT, spinlocks become sleeping locks. `wake_up()` in the
  handler acquires a wait queue spinlock, which can sleep under RT
- Running this handler in hardirq context (non-threaded) on an RT kernel
  can cause sleeping-in-atomic-context bugs, warnings, or system
  instability

## Risk Assessment

**Change scope**: Minimal — removes one flag (`IRQF_ONESHOT`) from one
`devm_request_irq()` call.

**Risk**: Very low.
- On non-RT kernels: `IRQF_ONESHOT` was already semantically meaningless
  since there's no threaded handler. The flag only affects behavior when
  a threaded handler is present (masks the line until the thread runs).
  With only a primary handler, the interrupt line is naturally masked
  while the handler runs anyway.
- On RT kernels: This fix is essential for correct operation.
- The handler (`ak8975_irq_handler`) just does `set_bit()` and
  `wake_up()` — it's trivially simple.

**Quality signals**:
- `Tested-by: Geert Uytterhoeven` (well-known kernel developer)
- `Reviewed-by: Andy Shevchenko` (prolific reviewer)
- `Reviewed-by: Nuno Sá` (IIO maintainer)
- Part of a well-established pattern of similar fixes across multiple
  subsystems (I found 12+ similar commits)

## Stable Kernel Criteria

1. **Obviously correct and tested**: Yes — the flag has no semantic
   meaning for primary-only handlers, and it has multiple reviews +
   testing
2. **Fixes a real bug**: Yes — on PREEMPT_RT, this prevents sleeping-in-
   atomic-context (and on non-RT prevents force-threading which could be
   useful)
3. **Important issue**: Moderate — affects PREEMPT_RT users of this
   magnetometer, and also triggers warnings
4. **Small and contained**: Yes — single character-level change
5. **No new features**: Correct — only removes an incorrect flag
6. **Applies cleanly**: Likely yes — the surrounding code hasn't changed
   significantly

## Verification

- **Read `ak8975_irq_handler`** (line 557-565): Confirmed it's a
  primary-only handler returning `IRQ_HANDLED` (not `IRQ_WAKE_THREAD`),
  and the call uses `devm_request_irq()` (not
  `devm_request_threaded_irq()`)
- **Read `irq_setup_forced_threading()`**
  (kernel/irq/manage.c:1291-1296): Confirmed that `IRQF_ONESHOT` in the
  flags causes the function to return 0, bypassing force-threading
- **git log --grep** confirmed this is part of a well-known series of
  12+ similar fixes across multiple subsystems
- **git log -S** confirmed `IRQF_ONESHOT` has been present since 2013
  (commit 94a6d5cf7caa5), meaning it exists in all active stable trees
- The handler uses `wake_up()` which acquires a spinlock — verified this
  is problematic in hardirq context on RT where spinlocks become
  sleeping locks

## Conclusion

This is a small, well-reviewed, well-tested fix that corrects a bug
affecting PREEMPT_RT kernels (and removes a semantically incorrect flag
on all kernels). The change is minimal risk — removing a flag that was
never appropriate for a primary-only interrupt handler. It's part of a
well-established pattern of identical fixes across the kernel. It meets
all stable kernel criteria.

**YES**

 drivers/iio/magnetometer/ak8975.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/iio/magnetometer/ak8975.c b/drivers/iio/magnetometer/ak8975.c
index 3fd0171e5d69b..d30315ad85ded 100644
--- a/drivers/iio/magnetometer/ak8975.c
+++ b/drivers/iio/magnetometer/ak8975.c
@@ -581,7 +581,7 @@ static int ak8975_setup_irq(struct ak8975_data *data)
 		irq = gpiod_to_irq(data->eoc_gpiod);
 
 	rc = devm_request_irq(&client->dev, irq, ak8975_irq_handler,
-			      IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+			      IRQF_TRIGGER_RISING,
 			      dev_name(&client->dev), data);
 	if (rc < 0) {
 		dev_err(&client->dev, "irq %d request failed: %d\n", irq, rc);
-- 
2.51.0