| Message ID | 20200403154834.303105-1-hdegoede@redhat.com (mailing list archive) |
|---|---|
| State | Mainlined, archived |
| Headers | show |
| Series | [v3,1/2] ACPI: PM: Add acpi_[un]register_wakeup_handler() | expand |
On Fri, Apr 3, 2020 at 5:48 PM Hans de Goede <hdegoede@redhat.com> wrote: > > Since commit fdde0ff8590b ("ACPI: PM: s2idle: Prevent spurious SCIs from > waking up the system") the SCI triggering without there being a wakeup > cause recognized by the ACPI sleep code will no longer wakeup the system. > > This works as intended, but this is a problem for devices where the SCI > is shared with another device which is also a wakeup source. > > In the past these, from the pov of the ACPI sleep code, spurious SCIs > would still cause a wakeup so the wakeup from the device sharing the > interrupt would actually wakeup the system. This now no longer works. > > This is a problem on e.g. Bay Trail-T and Cherry Trail devices where > some peripherals (typically the XHCI controller) can signal a > Power Management Event (PME) to the Power Management Controller (PMC) > to wakeup the system, this uses the same interrupt as the SCI. > These wakeups are handled through a special INT0002 ACPI device which > checks for events in the GPE0a_STS for this and takes care of acking > the PME so that the shared interrupt stops triggering. > > The change to the ACPI sleep code to ignore the spurious SCI, causes > the system to no longer wakeup on these PME events. To make things > worse this means that the INT0002 device driver interrupt handler will > no longer run, causing the PME to not get cleared and resulting in the > system hanging. Trying to wakeup the system after such a PME through e.g. > the power button no longer works. > > Add an acpi_register_wakeup_handler() function which registers > a handler to be called from acpi_s2idle_wake() and when the handler > returns true, return true from acpi_s2idle_wake(). > > The INT0002 driver will use this mechanism to check the GPE0a_STS > register from acpi_s2idle_wake() and to tell the system to wakeup > if a PME is signaled in the register. > > Fixes: fdde0ff8590b ("ACPI: PM: s2idle: Prevent spurious SCIs from waking up the system") > Cc: 5.4+ <stable@vger.kernel.org> # 5.4+ > Signed-off-by: Hans de Goede <hdegoede@redhat.com> Rebased on top of the current mainline and applied as 5.7-rc material along with the [2/2], thanks! > --- > Changes in v3: > - Some small indentation changes > > Changes in v2: > - Move the new helpers to drivers/acpi/wakeup.c > - Rename the helpers to acpi_[un]register_wakeup_handler(), also give some > types/variables better names > --- > drivers/acpi/sleep.c | 4 +++ > drivers/acpi/sleep.h | 1 + > drivers/acpi/wakeup.c | 81 +++++++++++++++++++++++++++++++++++++++++++ > include/linux/acpi.h | 5 +++ > 4 files changed, 91 insertions(+) > > diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c > index e5f95922bc21..dc8c71c47285 100644 > --- a/drivers/acpi/sleep.c > +++ b/drivers/acpi/sleep.c > @@ -1025,6 +1025,10 @@ static bool acpi_s2idle_wake(void) > if (acpi_any_gpe_status_set() && !acpi_ec_dispatch_gpe()) > return true; > > + /* Check wakeups from drivers sharing the SCI. */ > + if (acpi_check_wakeup_handlers()) > + return true; > + > /* > * Cancel the wakeup and process all pending events in case > * there are any wakeup ones in there. > diff --git a/drivers/acpi/sleep.h b/drivers/acpi/sleep.h > index 41675d24a9bc..3d90480ce1b1 100644 > --- a/drivers/acpi/sleep.h > +++ b/drivers/acpi/sleep.h > @@ -2,6 +2,7 @@ > > extern void acpi_enable_wakeup_devices(u8 sleep_state); > extern void acpi_disable_wakeup_devices(u8 sleep_state); > +extern bool acpi_check_wakeup_handlers(void); > > extern struct list_head acpi_wakeup_device_list; > extern struct mutex acpi_device_lock; > diff --git a/drivers/acpi/wakeup.c b/drivers/acpi/wakeup.c > index 9614126bf56e..90c40f992e13 100644 > --- a/drivers/acpi/wakeup.c > +++ b/drivers/acpi/wakeup.c > @@ -12,6 +12,15 @@ > #include "internal.h" > #include "sleep.h" > > +struct acpi_wakeup_handler { > + struct list_head list_node; > + bool (*wakeup)(void *context); > + void *context; > +}; > + > +static LIST_HEAD(acpi_wakeup_handler_head); > +static DEFINE_MUTEX(acpi_wakeup_handler_mutex); > + > /* > * We didn't lock acpi_device_lock in the file, because it invokes oops in > * suspend/resume and isn't really required as this is called in S-state. At > @@ -96,3 +105,75 @@ int __init acpi_wakeup_device_init(void) > mutex_unlock(&acpi_device_lock); > return 0; > } > + > +/** > + * acpi_register_wakeup_handler - Register wakeup handler > + * @wake_irq: The IRQ through which the device may receive wakeups > + * @wakeup: Wakeup-handler to call when the SCI has triggered a wakeup > + * @context: Context to pass to the handler when calling it > + * > + * Drivers which may share an IRQ with the SCI can use this to register > + * a handler which returns true when the device they are managing wants > + * to trigger a wakeup. > + */ > +int acpi_register_wakeup_handler(int wake_irq, bool (*wakeup)(void *context), > + void *context) > +{ > + struct acpi_wakeup_handler *handler; > + > + /* > + * If the device is not sharing its IRQ with the SCI, there is no > + * need to register the handler. > + */ > + if (!acpi_sci_irq_valid() || wake_irq != acpi_sci_irq) > + return 0; > + > + handler = kmalloc(sizeof(*handler), GFP_KERNEL); > + if (!handler) > + return -ENOMEM; > + > + handler->wakeup = wakeup; > + handler->context = context; > + > + mutex_lock(&acpi_wakeup_handler_mutex); > + list_add(&handler->list_node, &acpi_wakeup_handler_head); > + mutex_unlock(&acpi_wakeup_handler_mutex); > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(acpi_register_wakeup_handler); > + > +/** > + * acpi_unregister_wakeup_handler - Unregister wakeup handler > + * @wakeup: Wakeup-handler passed to acpi_register_wakeup_handler() > + * @context: Context passed to acpi_register_wakeup_handler() > + */ > +void acpi_unregister_wakeup_handler(bool (*wakeup)(void *context), > + void *context) > +{ > + struct acpi_wakeup_handler *handler; > + > + mutex_lock(&acpi_wakeup_handler_mutex); > + list_for_each_entry(handler, &acpi_wakeup_handler_head, list_node) { > + if (handler->wakeup == wakeup && handler->context == context) { > + list_del(&handler->list_node); > + kfree(handler); > + break; > + } > + } > + mutex_unlock(&acpi_wakeup_handler_mutex); > +} > +EXPORT_SYMBOL_GPL(acpi_unregister_wakeup_handler); > + > +bool acpi_check_wakeup_handlers(void) > +{ > + struct acpi_wakeup_handler *handler; > + > + /* No need to lock, nothing else is running when we're called. */ > + list_for_each_entry(handler, &acpi_wakeup_handler_head, list_node) { > + if (handler->wakeup(handler->context)) > + return true; > + } > + > + return false; > +} > diff --git a/include/linux/acpi.h b/include/linux/acpi.h > index 0f24d701fbdc..efac0f9c01a2 100644 > --- a/include/linux/acpi.h > +++ b/include/linux/acpi.h > @@ -488,6 +488,11 @@ void __init acpi_nvs_nosave_s3(void); > void __init acpi_sleep_no_blacklist(void); > #endif /* CONFIG_PM_SLEEP */ > > +int acpi_register_wakeup_handler( > + int wake_irq, bool (*wakeup)(void *context), void *context); > +void acpi_unregister_wakeup_handler( > + bool (*wakeup)(void *context), void *context); > + > struct acpi_osc_context { > char *uuid_str; /* UUID string */ > int rev; > -- > 2.26.0 >
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c index e5f95922bc21..dc8c71c47285 100644 --- a/drivers/acpi/sleep.c +++ b/drivers/acpi/sleep.c @@ -1025,6 +1025,10 @@ static bool acpi_s2idle_wake(void) if (acpi_any_gpe_status_set() && !acpi_ec_dispatch_gpe()) return true; + /* Check wakeups from drivers sharing the SCI. */ + if (acpi_check_wakeup_handlers()) + return true; + /* * Cancel the wakeup and process all pending events in case * there are any wakeup ones in there. diff --git a/drivers/acpi/sleep.h b/drivers/acpi/sleep.h index 41675d24a9bc..3d90480ce1b1 100644 --- a/drivers/acpi/sleep.h +++ b/drivers/acpi/sleep.h @@ -2,6 +2,7 @@ extern void acpi_enable_wakeup_devices(u8 sleep_state); extern void acpi_disable_wakeup_devices(u8 sleep_state); +extern bool acpi_check_wakeup_handlers(void); extern struct list_head acpi_wakeup_device_list; extern struct mutex acpi_device_lock; diff --git a/drivers/acpi/wakeup.c b/drivers/acpi/wakeup.c index 9614126bf56e..90c40f992e13 100644 --- a/drivers/acpi/wakeup.c +++ b/drivers/acpi/wakeup.c @@ -12,6 +12,15 @@ #include "internal.h" #include "sleep.h" +struct acpi_wakeup_handler { + struct list_head list_node; + bool (*wakeup)(void *context); + void *context; +}; + +static LIST_HEAD(acpi_wakeup_handler_head); +static DEFINE_MUTEX(acpi_wakeup_handler_mutex); + /* * We didn't lock acpi_device_lock in the file, because it invokes oops in * suspend/resume and isn't really required as this is called in S-state. At @@ -96,3 +105,75 @@ int __init acpi_wakeup_device_init(void) mutex_unlock(&acpi_device_lock); return 0; } + +/** + * acpi_register_wakeup_handler - Register wakeup handler + * @wake_irq: The IRQ through which the device may receive wakeups + * @wakeup: Wakeup-handler to call when the SCI has triggered a wakeup + * @context: Context to pass to the handler when calling it + * + * Drivers which may share an IRQ with the SCI can use this to register + * a handler which returns true when the device they are managing wants + * to trigger a wakeup. + */ +int acpi_register_wakeup_handler(int wake_irq, bool (*wakeup)(void *context), + void *context) +{ + struct acpi_wakeup_handler *handler; + + /* + * If the device is not sharing its IRQ with the SCI, there is no + * need to register the handler. + */ + if (!acpi_sci_irq_valid() || wake_irq != acpi_sci_irq) + return 0; + + handler = kmalloc(sizeof(*handler), GFP_KERNEL); + if (!handler) + return -ENOMEM; + + handler->wakeup = wakeup; + handler->context = context; + + mutex_lock(&acpi_wakeup_handler_mutex); + list_add(&handler->list_node, &acpi_wakeup_handler_head); + mutex_unlock(&acpi_wakeup_handler_mutex); + + return 0; +} +EXPORT_SYMBOL_GPL(acpi_register_wakeup_handler); + +/** + * acpi_unregister_wakeup_handler - Unregister wakeup handler + * @wakeup: Wakeup-handler passed to acpi_register_wakeup_handler() + * @context: Context passed to acpi_register_wakeup_handler() + */ +void acpi_unregister_wakeup_handler(bool (*wakeup)(void *context), + void *context) +{ + struct acpi_wakeup_handler *handler; + + mutex_lock(&acpi_wakeup_handler_mutex); + list_for_each_entry(handler, &acpi_wakeup_handler_head, list_node) { + if (handler->wakeup == wakeup && handler->context == context) { + list_del(&handler->list_node); + kfree(handler); + break; + } + } + mutex_unlock(&acpi_wakeup_handler_mutex); +} +EXPORT_SYMBOL_GPL(acpi_unregister_wakeup_handler); + +bool acpi_check_wakeup_handlers(void) +{ + struct acpi_wakeup_handler *handler; + + /* No need to lock, nothing else is running when we're called. */ + list_for_each_entry(handler, &acpi_wakeup_handler_head, list_node) { + if (handler->wakeup(handler->context)) + return true; + } + + return false; +} diff --git a/include/linux/acpi.h b/include/linux/acpi.h index 0f24d701fbdc..efac0f9c01a2 100644 --- a/include/linux/acpi.h +++ b/include/linux/acpi.h @@ -488,6 +488,11 @@ void __init acpi_nvs_nosave_s3(void); void __init acpi_sleep_no_blacklist(void); #endif /* CONFIG_PM_SLEEP */ +int acpi_register_wakeup_handler( + int wake_irq, bool (*wakeup)(void *context), void *context); +void acpi_unregister_wakeup_handler( + bool (*wakeup)(void *context), void *context); + struct acpi_osc_context { char *uuid_str; /* UUID string */ int rev;
Since commit fdde0ff8590b ("ACPI: PM: s2idle: Prevent spurious SCIs from waking up the system") the SCI triggering without there being a wakeup cause recognized by the ACPI sleep code will no longer wakeup the system. This works as intended, but this is a problem for devices where the SCI is shared with another device which is also a wakeup source. In the past these, from the pov of the ACPI sleep code, spurious SCIs would still cause a wakeup so the wakeup from the device sharing the interrupt would actually wakeup the system. This now no longer works. This is a problem on e.g. Bay Trail-T and Cherry Trail devices where some peripherals (typically the XHCI controller) can signal a Power Management Event (PME) to the Power Management Controller (PMC) to wakeup the system, this uses the same interrupt as the SCI. These wakeups are handled through a special INT0002 ACPI device which checks for events in the GPE0a_STS for this and takes care of acking the PME so that the shared interrupt stops triggering. The change to the ACPI sleep code to ignore the spurious SCI, causes the system to no longer wakeup on these PME events. To make things worse this means that the INT0002 device driver interrupt handler will no longer run, causing the PME to not get cleared and resulting in the system hanging. Trying to wakeup the system after such a PME through e.g. the power button no longer works. Add an acpi_register_wakeup_handler() function which registers a handler to be called from acpi_s2idle_wake() and when the handler returns true, return true from acpi_s2idle_wake(). The INT0002 driver will use this mechanism to check the GPE0a_STS register from acpi_s2idle_wake() and to tell the system to wakeup if a PME is signaled in the register. Fixes: fdde0ff8590b ("ACPI: PM: s2idle: Prevent spurious SCIs from waking up the system") Cc: 5.4+ <stable@vger.kernel.org> # 5.4+ Signed-off-by: Hans de Goede <hdegoede@redhat.com> --- Changes in v3: - Some small indentation changes Changes in v2: - Move the new helpers to drivers/acpi/wakeup.c - Rename the helpers to acpi_[un]register_wakeup_handler(), also give some types/variables better names --- drivers/acpi/sleep.c | 4 +++ drivers/acpi/sleep.h | 1 + drivers/acpi/wakeup.c | 81 +++++++++++++++++++++++++++++++++++++++++++ include/linux/acpi.h | 5 +++ 4 files changed, 91 insertions(+)