On Wed, Sep 02 2020 at 13:26, Doug Anderson wrote:
> Specifically I think it gets back to the idea that, from a device
> driver's point of view, there isn't a separate concept of disabling an
> IRQ (turn it off and stop tracking it) and masking an IRQ (keep track
> of it but don't call my handler until I unmask). As I understand it
> drivers expect that the disable_irq() call is actually a mask and that
> an IRQ is never fully disabled unless released by the driver. It is a
> little unfortunate (IMO) that the function is called disable_irq() but
> as far as I understand that's historical.
Yes, the naming is historical but it always meant:
Don't invoke an interrupt handler. Whether that's achieved by actually
masking it at the interrupt chip level in hardware or by software state
in the core does not matter from the driver perspective.
>> The point is that the core suspend code disables all interrupts which
>> are not marked as wakeup enabled automatically and reenables them after
>> resume. So why would any driver invoke disable_irq() in the suspend
>> function at all? Historical raisins?
>
> One case I can imagine: pretend that there are two power rails
> controlling a device. One power rail controls the communication
> channel between the CPU and the peripheral and the other power rail
> controls whether the peripheral is on. At suspend time we want to
> keep the peripheral on but we can shut down the power to the
> communication channel.
>
> One way you could do this is at suspend time:
> disable_irq()
> turn_off_comm_power()
> enable_irq_wake()
>
> You'd do the disable_irq() (AKA mask your interrupt) because you'd
> really want to make sure that your handler isn't called after you
> turned off the communication power. You want to leave the interrupt
> pending/masked until you are able to turn the communications channel
> back on and then you can query why the wakeup happened.
Ok.
> Now, admittedly, you could redesign the above driver to work any
> number of different ways. Maybe you could use the "noirq" suspend to
> turn off your comm power or maybe you could come up with another
> solution. However, since the above has always worked and is quite
> simple I guess that's what drivers use?
That comm power case is a reasonable argument for having that
sequence. So we need to make sure that the underlying interrupt chips do
the right thing.
We have the following two cases:
1) irq chip does not have a irq_disable() callback and does not
have IRQ_DISABLE_UNLAZY set
In that case the interrupt is not masked at the hardware level. It's
just software state. If the interrupt fires while disabled it is
marked pending and actually masked at the hardware level.
Actually there is a race condition which is not handled:
disable_irq()
...
interrupt fires
mask and mark pending
....
suspend_device_irq()
if (wakeup source) {
set_state(WAKEUP ARMED);
return;
}
That pending interrupt will not prevent the machine from going into
suspend and if it's an edge interrupt then an unmask in
suspend_device_irq() won't help. Edge interrupts are not resent in
hardware. They are fire and forget from the POV of the device
hardware.
2) irq chip has a irq_disable() callback or has IRQ_DISABLE_UNLAZY set
In that case disable_irq() will mask it at the hardware level and it
stays that way until enable_irq() is invoked.
#1 kinda works and the gap is reasonably trivial to fix in
suspend_device_irq() by checking the pending state and telling the PM
core that there is a wakeup pending.
#2 Needs an indication from the chip flags that an interrupt which is
masked has to be unmasked when it is a enabled wakeup source.
I assume your problem is #2, right? If it's #1 then UNMASK_IF_WAKEUP is
the wrong answer.
Thanks,
tglx
