| Message ID | 2026371.DVJN39QYJi@aspire.rjw.lan (mailing list archive) |
|---|---|
| State | Changes Requested, archived |
| Headers | show |
Hi, Rafael > From: linux-acpi-owner@vger.kernel.org [mailto:linux-acpi-owner@vger.kernel.org] On Behalf Of Rafael J. > Wysocki > Subject: [PATCH v2 3/3] ACPI / sleep: EC-based wakeup from suspend-to-idle on recent Dell systems > > From: Rafael J. Wysocki <rafael.j.wysocki@intel.com> > > Some recent Dell laptops, including the XPS13 model numbers 9360 and > 9365, cannot be woken up from suspend-to-idle by pressing the power > button which is unexpected and makes that feature less usable on > those systems. Moreover, on the 9365 ACPI S3 (suspend-to-RAM) is > not expected to be used at all (the OS these systems ship with never > exercises the ACPI S3 path) and suspend-to-idle is the only viable > system suspend mechanism in there. > > The reason why the power button wakeup from suspend-to-idle doesn't > work on those systems is because their power button events are > signaled by the EC (Embedded Controller), whose GPE (General Purpose > Event) line is disabled during suspend-to-idle transitions in Linux. > That is done on purpose, because in general the EC tends to generate > tons of events for various reasons (battery and thermal updates and > similar, for example) and all of them would kick the CPUs out of deep > idle states while in suspend-to-idle, which effectively would defeat > its purpose. > > Of course, on the Dell systems in question the EC GPE must be enabled > during suspend-to-idle transitions for the button press events to > be signaled while suspended at all. For this reason, add a DMI > switch to the ACPI system suspend infrastructure to treat the EC > GPE as a wakeup one on the affected Dell systems. In case the > users would prefer not to do that after all, add a new kernel > command line switch, acpi_sleep=no_ec_wakeup, to disable that new > behavior. > > Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com> > --- > > -> v2: Added acpi_sleep=no_ec_wakeup to prevent EC events from waking up > the system from s2idle on systems where they do that by default. > > --- > Documentation/admin-guide/kernel-parameters.txt | 6 ++- > arch/x86/kernel/acpi/sleep.c | 2 + > drivers/acpi/ec.c | 19 ++++++++++ > drivers/acpi/internal.h | 2 + > drivers/acpi/sleep.c | 43 ++++++++++++++++++++++++ > include/linux/acpi.h | 1 > 6 files changed, 71 insertions(+), 2 deletions(-) > > Index: linux-pm/drivers/acpi/ec.c > =================================================================== > --- linux-pm.orig/drivers/acpi/ec.c > +++ linux-pm/drivers/acpi/ec.c > @@ -40,6 +40,7 @@ > #include <linux/slab.h> > #include <linux/acpi.h> > #include <linux/dmi.h> > +#include <linux/suspend.h> > #include <asm/io.h> > > #include "internal.h" > @@ -1493,6 +1494,16 @@ static int acpi_ec_setup(struct acpi_ec > acpi_handle_info(ec->handle, > "GPE=0x%lx, EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n", > ec->gpe, ec->command_addr, ec->data_addr); > + > + /* > + * On some platforms the EC GPE is used for waking up the system from > + * suspend-to-idle, so mark it as a wakeup one. > + * > + * This can be done unconditionally, as the setting does not matter > + * until acpi_set_gpe_wake_mask() is called for the GPE. > + */ > + acpi_mark_gpe_for_wake(NULL, ec->gpe); > + > return ret; > } > > @@ -1835,8 +1846,11 @@ static int acpi_ec_suspend(struct device > struct acpi_ec *ec = > acpi_driver_data(to_acpi_device(dev)); > > - if (ec_freeze_events) > + if (!pm_suspend_via_firmware() && acpi_sleep_ec_gpe_may_wakeup()) > + acpi_set_gpe_wake_mask(NULL, ec->gpe, ACPI_GPE_ENABLE); > + else if (ec_freeze_events) > acpi_ec_disable_event(ec); > + > return 0; > } > > @@ -1846,6 +1860,9 @@ static int acpi_ec_resume(struct device > acpi_driver_data(to_acpi_device(dev)); > > acpi_ec_enable_event(ec); > + if (!pm_resume_via_firmware() && acpi_sleep_ec_gpe_may_wakeup()) > + acpi_set_gpe_wake_mask(NULL, ec->gpe, ACPI_GPE_DISABLE); > + > return 0; > } > #endif > Index: linux-pm/drivers/acpi/internal.h > =================================================================== > --- linux-pm.orig/drivers/acpi/internal.h > +++ linux-pm/drivers/acpi/internal.h > @@ -199,9 +199,11 @@ void acpi_ec_remove_query_handler(struct > -------------------------------------------------------------------------- */ > #ifdef CONFIG_ACPI_SYSTEM_POWER_STATES_SUPPORT > extern bool acpi_s2idle_wakeup(void); > +extern bool acpi_sleep_ec_gpe_may_wakeup(void); > extern int acpi_sleep_init(void); > #else > static inline bool acpi_s2idle_wakeup(void) { return false; } > +static inline bool acpi_sleep_ec_gpe_may_wakeup(void) { return false; } > static inline int acpi_sleep_init(void) { return -ENXIO; } > #endif > > Index: linux-pm/drivers/acpi/sleep.c > =================================================================== > --- linux-pm.orig/drivers/acpi/sleep.c > +++ linux-pm/drivers/acpi/sleep.c > @@ -160,6 +160,23 @@ static int __init init_nvs_nosave(const > return 0; > } > > +/* If set, it is allowed to use the EC GPE to wake up the system. */ > +static bool ec_gpe_wakeup_allowed __initdata = true; > + > +void __init acpi_disable_ec_gpe_wakeup(void) > +{ > + ec_gpe_wakeup_allowed = false; > +} > + > +/* If set, the EC GPE will be configured to wake up the system. */ > +static bool ec_gpe_wakeup; > + > +static int __init init_ec_gpe_wakeup(const struct dmi_system_id *d) > +{ > + ec_gpe_wakeup = ec_gpe_wakeup_allowed; > + return 0; > +} > + > static struct dmi_system_id acpisleep_dmi_table[] __initdata = { > { > .callback = init_old_suspend_ordering, > @@ -343,6 +360,26 @@ static struct dmi_system_id acpisleep_dm > DMI_MATCH(DMI_PRODUCT_NAME, "80E3"), > }, > }, > + /* > + * Enable the EC to wake up the system from suspend-to-idle to allow > + * power button events to it wake up. > + */ > + { > + .callback = init_ec_gpe_wakeup, > + .ident = "Dell XPS 13 9360", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, "XPS 13 9360"), > + }, > + }, > + { > + .callback = init_ec_gpe_wakeup, > + .ident = "Dell XPS 13 9365", > + .matches = { > + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), > + DMI_MATCH(DMI_PRODUCT_NAME, "XPS 13 9365"), > + }, > + }, > {}, > }; > I have a concern here. ACPI spec has already defined a mechanism to statically Mark GPEs as wake-capable and enable it, it is done via _PRW. We may call it a "static wakeup GPE" mechanism. Now the problem might be on some platforms, _PRW cannot be prepared unconditionally. And the platform designers wants a "dynamic wakeup GPE" mechanism to dynamically mark/enable GPEs as wakeup GPE after having done some platform specific behaviors (ex., after/before saving/restoring some firmware configurations). From this point of view, can we prepare several APIs in sleep.c to allow dynamically mark/enable wakeup GPEs and export EC information via a new API from ec.c, ex., acpi_ec_get_attributes(), or just publish struct acpi_ec and first_ec in acpi_ec.h to the other drivers. So that all such kinds of platforms drivers can use both interfaces to dynamically achieve this, which can help to avoid introducing quirk tables here. Thanks and best regards Lv > @@ -485,6 +522,7 @@ static void acpi_pm_end(void) > } > #else /* !CONFIG_ACPI_SLEEP */ > #define acpi_target_sleep_state ACPI_STATE_S0 > +#define ec_gpe_wakeup false > static inline void acpi_sleep_dmi_check(void) {} > #endif /* CONFIG_ACPI_SLEEP */ > > @@ -740,6 +778,11 @@ bool acpi_s2idle_wakeup(void) > return s2idle_wakeup; > } > > +bool acpi_sleep_ec_gpe_may_wakeup(void) > +{ > + return ec_gpe_wakeup; > +} > + > #ifdef CONFIG_PM_SLEEP > static u32 saved_bm_rld; > > Index: linux-pm/arch/x86/kernel/acpi/sleep.c > =================================================================== > --- linux-pm.orig/arch/x86/kernel/acpi/sleep.c > +++ linux-pm/arch/x86/kernel/acpi/sleep.c > @@ -137,6 +137,8 @@ static int __init acpi_sleep_setup(char > acpi_nvs_nosave_s3(); > if (strncmp(str, "old_ordering", 12) == 0) > acpi_old_suspend_ordering(); > + if (strncmp(str, "no_ec_wakeup", 12) == 0) > + acpi_disable_ec_gpe_wakeup(); > str = strchr(str, ','); > if (str != NULL) > str += strspn(str, ", \t"); > Index: linux-pm/include/linux/acpi.h > =================================================================== > --- linux-pm.orig/include/linux/acpi.h > +++ linux-pm/include/linux/acpi.h > @@ -448,6 +448,7 @@ void __init acpi_no_s4_hw_signature(void > void __init acpi_old_suspend_ordering(void); > void __init acpi_nvs_nosave(void); > void __init acpi_nvs_nosave_s3(void); > +void __init acpi_disable_ec_gpe_wakeup(void); > #endif /* CONFIG_PM_SLEEP */ > > struct acpi_osc_context { > Index: linux-pm/Documentation/admin-guide/kernel-parameters.txt > =================================================================== > --- linux-pm.orig/Documentation/admin-guide/kernel-parameters.txt > +++ linux-pm/Documentation/admin-guide/kernel-parameters.txt > @@ -223,7 +223,8 @@ > > acpi_sleep= [HW,ACPI] Sleep options > Format: { s3_bios, s3_mode, s3_beep, s4_nohwsig, > - old_ordering, nonvs, sci_force_enable } > + old_ordering, nonvs, sci_force_enable, > + no_ec_wakeup } > See Documentation/power/video.txt for information on > s3_bios and s3_mode. > s3_beep is for debugging; it makes the PC's speaker beep > @@ -239,6 +240,9 @@ > sci_force_enable causes the kernel to set SCI_EN directly > on resume from S1/S3 (which is against the ACPI spec, > but some broken systems don't work without it). > + no_ec_wakeup prevents the EC GPE from being configured > + to wake up the system on platforms where that is done by > + default. > > acpi_use_timer_override [HW,ACPI] > Use timer override. For some broken Nvidia NF5 boards > > -- > To unsubscribe from this list: send the line "unsubscribe linux-acpi" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html -- To unsubscribe from this list: send the line "unsubscribe linux-acpi" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Tue, Jun 20, 2017 at 1:37 AM, Zheng, Lv <lv.zheng@intel.com> wrote: > Hi, Rafael > >> From: linux-acpi-owner@vger.kernel.org [mailto:linux-acpi-owner@vger.kernel.org] On Behalf Of Rafael J. >> Wysocki >> Subject: [PATCH v2 3/3] ACPI / sleep: EC-based wakeup from suspend-to-idle on recent Dell systems >> >> From: Rafael J. Wysocki <rafael.j.wysocki@intel.com> >> >> Some recent Dell laptops, including the XPS13 model numbers 9360 and >> 9365, cannot be woken up from suspend-to-idle by pressing the power >> button which is unexpected and makes that feature less usable on >> those systems. Moreover, on the 9365 ACPI S3 (suspend-to-RAM) is >> not expected to be used at all (the OS these systems ship with never >> exercises the ACPI S3 path) and suspend-to-idle is the only viable >> system suspend mechanism in there. >> >> The reason why the power button wakeup from suspend-to-idle doesn't >> work on those systems is because their power button events are >> signaled by the EC (Embedded Controller), whose GPE (General Purpose >> Event) line is disabled during suspend-to-idle transitions in Linux. >> That is done on purpose, because in general the EC tends to generate >> tons of events for various reasons (battery and thermal updates and >> similar, for example) and all of them would kick the CPUs out of deep >> idle states while in suspend-to-idle, which effectively would defeat >> its purpose. >> >> Of course, on the Dell systems in question the EC GPE must be enabled >> during suspend-to-idle transitions for the button press events to >> be signaled while suspended at all. For this reason, add a DMI >> switch to the ACPI system suspend infrastructure to treat the EC >> GPE as a wakeup one on the affected Dell systems. In case the >> users would prefer not to do that after all, add a new kernel >> command line switch, acpi_sleep=no_ec_wakeup, to disable that new >> behavior. >> [cut] >> >> Index: linux-pm/drivers/acpi/sleep.c >> =================================================================== >> --- linux-pm.orig/drivers/acpi/sleep.c >> +++ linux-pm/drivers/acpi/sleep.c >> @@ -160,6 +160,23 @@ static int __init init_nvs_nosave(const >> return 0; >> } >> >> +/* If set, it is allowed to use the EC GPE to wake up the system. */ >> +static bool ec_gpe_wakeup_allowed __initdata = true; >> + >> +void __init acpi_disable_ec_gpe_wakeup(void) >> +{ >> + ec_gpe_wakeup_allowed = false; >> +} >> + >> +/* If set, the EC GPE will be configured to wake up the system. */ >> +static bool ec_gpe_wakeup; >> + >> +static int __init init_ec_gpe_wakeup(const struct dmi_system_id *d) >> +{ >> + ec_gpe_wakeup = ec_gpe_wakeup_allowed; >> + return 0; >> +} >> + >> static struct dmi_system_id acpisleep_dmi_table[] __initdata = { >> { >> .callback = init_old_suspend_ordering, >> @@ -343,6 +360,26 @@ static struct dmi_system_id acpisleep_dm >> DMI_MATCH(DMI_PRODUCT_NAME, "80E3"), >> }, >> }, >> + /* >> + * Enable the EC to wake up the system from suspend-to-idle to allow >> + * power button events to it wake up. >> + */ >> + { >> + .callback = init_ec_gpe_wakeup, >> + .ident = "Dell XPS 13 9360", >> + .matches = { >> + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), >> + DMI_MATCH(DMI_PRODUCT_NAME, "XPS 13 9360"), >> + }, >> + }, >> + { >> + .callback = init_ec_gpe_wakeup, >> + .ident = "Dell XPS 13 9365", >> + .matches = { >> + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), >> + DMI_MATCH(DMI_PRODUCT_NAME, "XPS 13 9365"), >> + }, >> + }, >> {}, >> }; >> > > I have a concern here. > > ACPI spec has already defined a mechanism to statically > Mark GPEs as wake-capable and enable it, it is done via > _PRW. We may call it a "static wakeup GPE" mechanism. > > Now the problem might be on some platforms, _PRW cannot be > prepared unconditionally. And the platform designers wants > a "dynamic wakeup GPE" mechanism to dynamically > mark/enable GPEs as wakeup GPE after having done some > platform specific behaviors (ex., after/before > saving/restoring some firmware configurations). > > From this point of view, can we prepare several APIs in > sleep.c to allow dynamically mark/enable wakeup GPEs and > export EC information via a new API from ec.c, ex., > acpi_ec_get_attributes(), or just publish struct acpi_ec > and first_ec in acpi_ec.h to the other drivers. > So that all such kinds of platforms drivers can use both > interfaces to dynamically achieve this, which can help > to avoid introducing quirk tables here. I'm not sure how this is related to the patch. Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-acpi" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Tue, Jun 20, 2017 at 5:53 AM, Rafael J. Wysocki <rjw@rjwysocki.net> wrote: > > -> v2: Added acpi_sleep=no_ec_wakeup to prevent EC events from waking up > the system from s2idle on systems where they do that by default. This seems a big hacky. Is there no way to simply make acpi_ec_suspend() smarter while going to sleep? Instead of just unconditionally disabling every EC GPE, can we see that "this gpe is the power botton" somehow? Disabling the power button event sounds fundamentally broken, and it sounds like Windows doesn't do that. I doubt Windows has some hacky whitelist. So I'd rather fix a deeper issue than have these kinds of hacks, if at all possible. Linus -- To unsubscribe from this list: send the line "unsubscribe linux-acpi" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Tue, Jun 20, 2017 at 2:07 AM, Linus Torvalds <torvalds@linux-foundation.org> wrote: > On Tue, Jun 20, 2017 at 5:53 AM, Rafael J. Wysocki <rjw@rjwysocki.net> wrote: >> >> -> v2: Added acpi_sleep=no_ec_wakeup to prevent EC events from waking up >> the system from s2idle on systems where they do that by default. > > This seems a big hacky. > > Is there no way to simply make acpi_ec_suspend() smarter while going > to sleep? Instead of just unconditionally disabling every EC GPE, can > we see that "this gpe is the power botton" somehow? Unfortunately, the connection between the GPE and the power button is not direct. The EC GPE handler has no idea that it will generate power button events. It simply executes an AML method doing that. The AML method, in turn, executes Notify(power button device) and the "power button device" driver has to register a notify handler that will recognize and process the events. It doesn't know in principle where the events will come from, though. They may come from the EC or from a different GPE etc. Neither the EC driver, nor the "power button device" driver can figure out that the connection is there. > Disabling the power button event sounds fundamentally broken, and it > sounds like Windows doesn't do that. I doubt Windows has some hacky > whitelist. So I'd rather fix a deeper issue than have these kinds of > hacks, if at all possible. My understanding is that Windows uses the ACPI_FADT_LOW_POWER_S0 flag. It generally enables non-S3 suspend/resume when this flag is set and it doesn't touch S3 then. Keeping the EC GPE (and other GPEs for that matter) enabled over suspend/resume is part of that if my understanding is correct. During suspend we generally disable all GPEs that are not expected to generate wakeup events in order to avoid spurious wakeups, but we can try to keep them enabled if ACPI_FADT_LOW_POWER_S0 is set. That will reduce the ugliness, but the cost may be more energy used while suspended on some systems. Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-acpi" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Tue, Jun 20, 2017 at 9:13 AM, Rafael J. Wysocki <rafael@kernel.org> wrote: > > My understanding is that Windows uses the ACPI_FADT_LOW_POWER_S0 flag. > It generally enables non-S3 suspend/resume when this flag is set and > it doesn't touch S3 then. Keeping the EC GPE (and other GPEs for that > matter) enabled over suspend/resume is part of that if my > understanding is correct. > > During suspend we generally disable all GPEs that are not expected to > generate wakeup events in order to avoid spurious wakeups, but we can > try to keep them enabled if ACPI_FADT_LOW_POWER_S0 is set. That will > reduce the ugliness, but the cost may be more energy used while > suspended on some systems. I think trying to do something similar to what windows does is likely the right thing, since that is (sadly) the only thing that tends to get extensive testing still. Of course, different versions of Windows then probably do different things, but I guess ACPI_FADT_LOW_POWER_S0 ends up being a good sign of "new machine designed for windows 10", so it's probably a good thing to trigger that behavior on. So I suspect it's worth testing, particularly if we're going to be in the situation that a lot of machines are going to do this going forward (ie the "all Dell" may end up being more than just Dell too? Dell usually doesn't do particularly odd and out-of-the-norm design choices like some vendors do). Linus -- To unsubscribe from this list: send the line "unsubscribe linux-acpi" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Tue, Jun 20, 2017 at 4:00 AM, Linus Torvalds <torvalds@linux-foundation.org> wrote: > On Tue, Jun 20, 2017 at 9:13 AM, Rafael J. Wysocki <rafael@kernel.org> wrote: >> >> My understanding is that Windows uses the ACPI_FADT_LOW_POWER_S0 flag. >> It generally enables non-S3 suspend/resume when this flag is set and >> it doesn't touch S3 then. Keeping the EC GPE (and other GPEs for that >> matter) enabled over suspend/resume is part of that if my >> understanding is correct. >> >> During suspend we generally disable all GPEs that are not expected to >> generate wakeup events in order to avoid spurious wakeups, but we can >> try to keep them enabled if ACPI_FADT_LOW_POWER_S0 is set. That will >> reduce the ugliness, but the cost may be more energy used while >> suspended on some systems. > > I think trying to do something similar to what windows does is likely > the right thing, since that is (sadly) the only thing that tends to > get extensive testing still. > > Of course, different versions of Windows then probably do different > things, but I guess ACPI_FADT_LOW_POWER_S0 ends up being a good sign > of "new machine designed for windows 10", so it's probably a good > thing to trigger that behavior on. > > So I suspect it's worth testing, particularly if we're going to be in > the situation that a lot of machines are going to do this going > forward (ie the "all Dell" may end up being more than just Dell too? > Dell usually doesn't do particularly odd and out-of-the-norm design > choices like some vendors do). Well, involving the EC in power button events processing has not been a common practice so far. Anyway, I will replace this patch with something that ought to be more in line with what Windows does. Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-acpi" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
SGksDQoNCj4gRnJvbTogcmp3eXNvY2tpQGdtYWlsLmNvbSBbbWFpbHRvOnJqd3lzb2NraUBnbWFp bC5jb21dIE9uIEJlaGFsZiBPZiBSYWZhZWwgSi4gV3lzb2NraQ0KPiBTdWJqZWN0OiBSZTogW1BB VENIIHYyIDMvM10gQUNQSSAvIHNsZWVwOiBFQy1iYXNlZCB3YWtldXAgZnJvbSBzdXNwZW5kLXRv LWlkbGUgb24gcmVjZW50IERlbGwgc3lzdGVtcw0KPiANCj4gT24gVHVlLCBKdW4gMjAsIDIwMTcg YXQgMTozNyBBTSwgWmhlbmcsIEx2IDxsdi56aGVuZ0BpbnRlbC5jb20+IHdyb3RlOg0KPiA+IEhp LCBSYWZhZWwNCj4gPg0KPiA+PiBGcm9tOiBsaW51eC1hY3BpLW93bmVyQHZnZXIua2VybmVsLm9y ZyBbbWFpbHRvOmxpbnV4LWFjcGktb3duZXJAdmdlci5rZXJuZWwub3JnXSBPbiBCZWhhbGYgT2YN Cj4gUmFmYWVsIEouDQo+ID4+IFd5c29ja2kNCj4gPj4gU3ViamVjdDogW1BBVENIIHYyIDMvM10g QUNQSSAvIHNsZWVwOiBFQy1iYXNlZCB3YWtldXAgZnJvbSBzdXNwZW5kLXRvLWlkbGUgb24gcmVj ZW50IERlbGwgc3lzdGVtcw0KPiA+Pg0KPiA+PiBGcm9tOiBSYWZhZWwgSi4gV3lzb2NraSA8cmFm YWVsLmoud3lzb2NraUBpbnRlbC5jb20+DQo+ID4+DQo+ID4+IFNvbWUgcmVjZW50IERlbGwgbGFw dG9wcywgaW5jbHVkaW5nIHRoZSBYUFMxMyBtb2RlbCBudW1iZXJzIDkzNjAgYW5kDQo+ID4+IDkz NjUsIGNhbm5vdCBiZSB3b2tlbiB1cCBmcm9tIHN1c3BlbmQtdG8taWRsZSBieSBwcmVzc2luZyB0 aGUgcG93ZXINCj4gPj4gYnV0dG9uIHdoaWNoIGlzIHVuZXhwZWN0ZWQgYW5kIG1ha2VzIHRoYXQg ZmVhdHVyZSBsZXNzIHVzYWJsZSBvbg0KPiA+PiB0aG9zZSBzeXN0ZW1zLiAgTW9yZW92ZXIsIG9u IHRoZSA5MzY1IEFDUEkgUzMgKHN1c3BlbmQtdG8tUkFNKSBpcw0KPiA+PiBub3QgZXhwZWN0ZWQg dG8gYmUgdXNlZCBhdCBhbGwgKHRoZSBPUyB0aGVzZSBzeXN0ZW1zIHNoaXAgd2l0aCBuZXZlcg0K PiA+PiBleGVyY2lzZXMgdGhlIEFDUEkgUzMgcGF0aCkgYW5kIHN1c3BlbmQtdG8taWRsZSBpcyB0 aGUgb25seSB2aWFibGUNCj4gPj4gc3lzdGVtIHN1c3BlbmQgbWVjaGFuaXNtIGluIHRoZXJlLg0K PiA+Pg0KPiA+PiBUaGUgcmVhc29uIHdoeSB0aGUgcG93ZXIgYnV0dG9uIHdha2V1cCBmcm9tIHN1 c3BlbmQtdG8taWRsZSBkb2Vzbid0DQo+ID4+IHdvcmsgb24gdGhvc2Ugc3lzdGVtcyBpcyBiZWNh dXNlIHRoZWlyIHBvd2VyIGJ1dHRvbiBldmVudHMgYXJlDQo+ID4+IHNpZ25hbGVkIGJ5IHRoZSBF QyAoRW1iZWRkZWQgQ29udHJvbGxlciksIHdob3NlIEdQRSAoR2VuZXJhbCBQdXJwb3NlDQo+ID4+ IEV2ZW50KSBsaW5lIGlzIGRpc2FibGVkIGR1cmluZyBzdXNwZW5kLXRvLWlkbGUgdHJhbnNpdGlv bnMgaW4gTGludXguDQo+ID4+IFRoYXQgaXMgZG9uZSBvbiBwdXJwb3NlLCBiZWNhdXNlIGluIGdl bmVyYWwgdGhlIEVDIHRlbmRzIHRvIGdlbmVyYXRlDQo+ID4+IHRvbnMgb2YgZXZlbnRzIGZvciB2 YXJpb3VzIHJlYXNvbnMgKGJhdHRlcnkgYW5kIHRoZXJtYWwgdXBkYXRlcyBhbmQNCj4gPj4gc2lt aWxhciwgZm9yIGV4YW1wbGUpIGFuZCBhbGwgb2YgdGhlbSB3b3VsZCBraWNrIHRoZSBDUFVzIG91 dCBvZiBkZWVwDQo+ID4+IGlkbGUgc3RhdGVzIHdoaWxlIGluIHN1c3BlbmQtdG8taWRsZSwgd2hp Y2ggZWZmZWN0aXZlbHkgd291bGQgZGVmZWF0DQo+ID4+IGl0cyBwdXJwb3NlLg0KPiA+Pg0KPiA+ PiBPZiBjb3Vyc2UsIG9uIHRoZSBEZWxsIHN5c3RlbXMgaW4gcXVlc3Rpb24gdGhlIEVDIEdQRSBt dXN0IGJlIGVuYWJsZWQNCj4gPj4gZHVyaW5nIHN1c3BlbmQtdG8taWRsZSB0cmFuc2l0aW9ucyBm b3IgdGhlIGJ1dHRvbiBwcmVzcyBldmVudHMgdG8NCj4gPj4gYmUgc2lnbmFsZWQgd2hpbGUgc3Vz cGVuZGVkIGF0IGFsbC4gIEZvciB0aGlzIHJlYXNvbiwgYWRkIGEgRE1JDQo+ID4+IHN3aXRjaCB0 byB0aGUgQUNQSSBzeXN0ZW0gc3VzcGVuZCBpbmZyYXN0cnVjdHVyZSB0byB0cmVhdCB0aGUgRUMN Cj4gPj4gR1BFIGFzIGEgd2FrZXVwIG9uZSBvbiB0aGUgYWZmZWN0ZWQgRGVsbCBzeXN0ZW1zLiAg SW4gY2FzZSB0aGUNCj4gPj4gdXNlcnMgd291bGQgcHJlZmVyIG5vdCB0byBkbyB0aGF0IGFmdGVy IGFsbCwgYWRkIGEgbmV3IGtlcm5lbA0KPiA+PiBjb21tYW5kIGxpbmUgc3dpdGNoLCBhY3BpX3Ns ZWVwPW5vX2VjX3dha2V1cCwgdG8gZGlzYWJsZSB0aGF0IG5ldw0KPiA+PiBiZWhhdmlvci4NCj4g Pj4NCj4gDQo+IFtjdXRdDQo+IA0KPiA+Pg0KPiA+PiBJbmRleDogbGludXgtcG0vZHJpdmVycy9h Y3BpL3NsZWVwLmMNCj4gPj4gPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KPiA+PiAtLS0gbGludXgtcG0ub3JpZy9kcml2 ZXJzL2FjcGkvc2xlZXAuYw0KPiA+PiArKysgbGludXgtcG0vZHJpdmVycy9hY3BpL3NsZWVwLmMN Cj4gPj4gQEAgLTE2MCw2ICsxNjAsMjMgQEAgc3RhdGljIGludCBfX2luaXQgaW5pdF9udnNfbm9z YXZlKGNvbnN0DQo+ID4+ICAgICAgIHJldHVybiAwOw0KPiA+PiAgfQ0KPiA+Pg0KPiA+PiArLyog SWYgc2V0LCBpdCBpcyBhbGxvd2VkIHRvIHVzZSB0aGUgRUMgR1BFIHRvIHdha2UgdXAgdGhlIHN5 c3RlbS4gKi8NCj4gPj4gK3N0YXRpYyBib29sIGVjX2dwZV93YWtldXBfYWxsb3dlZCBfX2luaXRk YXRhID0gdHJ1ZTsNCj4gPj4gKw0KPiA+PiArdm9pZCBfX2luaXQgYWNwaV9kaXNhYmxlX2VjX2dw ZV93YWtldXAodm9pZCkNCj4gPj4gK3sNCj4gPj4gKyAgICAgZWNfZ3BlX3dha2V1cF9hbGxvd2Vk ID0gZmFsc2U7DQo+ID4+ICt9DQo+ID4+ICsNCj4gPj4gKy8qIElmIHNldCwgdGhlIEVDIEdQRSB3 aWxsIGJlIGNvbmZpZ3VyZWQgdG8gd2FrZSB1cCB0aGUgc3lzdGVtLiAqLw0KPiA+PiArc3RhdGlj IGJvb2wgZWNfZ3BlX3dha2V1cDsNCj4gPj4gKw0KPiA+PiArc3RhdGljIGludCBfX2luaXQgaW5p dF9lY19ncGVfd2FrZXVwKGNvbnN0IHN0cnVjdCBkbWlfc3lzdGVtX2lkICpkKQ0KPiA+PiArew0K PiA+PiArICAgICBlY19ncGVfd2FrZXVwID0gZWNfZ3BlX3dha2V1cF9hbGxvd2VkOw0KPiA+PiAr ICAgICByZXR1cm4gMDsNCj4gPj4gK30NCj4gPj4gKw0KPiA+PiAgc3RhdGljIHN0cnVjdCBkbWlf c3lzdGVtX2lkIGFjcGlzbGVlcF9kbWlfdGFibGVbXSBfX2luaXRkYXRhID0gew0KPiA+PiAgICAg ICB7DQo+ID4+ICAgICAgIC5jYWxsYmFjayA9IGluaXRfb2xkX3N1c3BlbmRfb3JkZXJpbmcsDQo+ ID4+IEBAIC0zNDMsNiArMzYwLDI2IEBAIHN0YXRpYyBzdHJ1Y3QgZG1pX3N5c3RlbV9pZCBhY3Bp c2xlZXBfZG0NCj4gPj4gICAgICAgICAgICAgICBETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwg IjgwRTMiKSwNCj4gPj4gICAgICAgICAgICAgICB9LA0KPiA+PiAgICAgICB9LA0KPiA+PiArICAg ICAvKg0KPiA+PiArICAgICAgKiBFbmFibGUgdGhlIEVDIHRvIHdha2UgdXAgdGhlIHN5c3RlbSBm cm9tIHN1c3BlbmQtdG8taWRsZSB0byBhbGxvdw0KPiA+PiArICAgICAgKiBwb3dlciBidXR0b24g ZXZlbnRzIHRvIGl0IHdha2UgdXAuDQo+ID4+ICsgICAgICAqLw0KPiA+PiArICAgICB7DQo+ID4+ ICsgICAgICAuY2FsbGJhY2sgPSBpbml0X2VjX2dwZV93YWtldXAsDQo+ID4+ICsgICAgICAuaWRl bnQgPSAiRGVsbCBYUFMgMTMgOTM2MCIsDQo+ID4+ICsgICAgICAubWF0Y2hlcyA9IHsNCj4gPj4g KyAgICAgICAgICAgICBETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYy4iKSwNCj4g Pj4gKyAgICAgICAgICAgICBETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIlhQUyAxMyA5MzYw IiksDQo+ID4+ICsgICAgICAgICAgICAgfSwNCj4gPj4gKyAgICAgfSwNCj4gPj4gKyAgICAgew0K PiA+PiArICAgICAgLmNhbGxiYWNrID0gaW5pdF9lY19ncGVfd2FrZXVwLA0KPiA+PiArICAgICAg LmlkZW50ID0gIkRlbGwgWFBTIDEzIDkzNjUiLA0KPiA+PiArICAgICAgLm1hdGNoZXMgPSB7DQo+ ID4+ICsgICAgICAgICAgICAgRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiRGVsbCBJbmMuIiks DQo+ID4+ICsgICAgICAgICAgICAgRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJYUFMgMTMg OTM2NSIpLA0KPiA+PiArICAgICAgICAgICAgIH0sDQo+ID4+ICsgICAgIH0sDQo+ID4+ICAgICAg IHt9LA0KPiA+PiAgfTsNCj4gPj4NCj4gPg0KPiA+IEkgaGF2ZSBhIGNvbmNlcm4gaGVyZS4NCj4g Pg0KPiA+IEFDUEkgc3BlYyBoYXMgYWxyZWFkeSBkZWZpbmVkIGEgbWVjaGFuaXNtIHRvIHN0YXRp Y2FsbHkNCj4gPiBNYXJrIEdQRXMgYXMgd2FrZS1jYXBhYmxlIGFuZCBlbmFibGUgaXQsIGl0IGlz IGRvbmUgdmlhDQo+ID4gX1BSVy4gV2UgbWF5IGNhbGwgaXQgYSAic3RhdGljIHdha2V1cCBHUEUi IG1lY2hhbmlzbS4NCj4gPg0KPiA+IE5vdyB0aGUgcHJvYmxlbSBtaWdodCBiZSBvbiBzb21lIHBs YXRmb3JtcywgX1BSVyBjYW5ub3QgYmUNCj4gPiBwcmVwYXJlZCB1bmNvbmRpdGlvbmFsbHkuIEFu ZCB0aGUgcGxhdGZvcm0gZGVzaWduZXJzIHdhbnRzDQo+ID4gYSAiZHluYW1pYyB3YWtldXAgR1BF IiBtZWNoYW5pc20gdG8gZHluYW1pY2FsbHkNCj4gPiBtYXJrL2VuYWJsZSBHUEVzIGFzIHdha2V1 cCBHUEUgYWZ0ZXIgaGF2aW5nIGRvbmUgc29tZQ0KPiA+IHBsYXRmb3JtIHNwZWNpZmljIGJlaGF2 aW9ycyAoZXguLCBhZnRlci9iZWZvcmUNCj4gPiBzYXZpbmcvcmVzdG9yaW5nIHNvbWUgZmlybXdh cmUgY29uZmlndXJhdGlvbnMpLg0KPiA+DQo+ID4gRnJvbSB0aGlzIHBvaW50IG9mIHZpZXcsIGNh biB3ZSBwcmVwYXJlIHNldmVyYWwgQVBJcyBpbg0KPiA+IHNsZWVwLmMgdG8gYWxsb3cgZHluYW1p Y2FsbHkgbWFyay9lbmFibGUgd2FrZXVwIEdQRXMgYW5kDQo+ID4gZXhwb3J0IEVDIGluZm9ybWF0 aW9uIHZpYSBhIG5ldyBBUEkgZnJvbSBlYy5jLCBleC4sDQo+ID4gYWNwaV9lY19nZXRfYXR0cmli dXRlcygpLCBvciBqdXN0IHB1Ymxpc2ggc3RydWN0IGFjcGlfZWMNCj4gPiBhbmQgZmlyc3RfZWMg aW4gYWNwaV9lYy5oIHRvIHRoZSBvdGhlciBkcml2ZXJzLg0KPiA+IFNvIHRoYXQgYWxsIHN1Y2gg a2luZHMgb2YgcGxhdGZvcm1zIGRyaXZlcnMgY2FuIHVzZSBib3RoDQo+ID4gaW50ZXJmYWNlcyB0 byBkeW5hbWljYWxseSBhY2hpZXZlIHRoaXMsIHdoaWNoIGNhbiBoZWxwDQo+ID4gdG8gYXZvaWQg aW50cm9kdWNpbmcgcXVpcmsgdGFibGVzIGhlcmUuDQo+IA0KPiBJJ20gbm90IHN1cmUgaG93IHRo aXMgaXMgcmVsYXRlZCB0byB0aGUgcGF0Y2guDQoNClNvcnJ5LCBJIHdhcyB0aGlua2luZyB0aGlz IGlzIHN0aWxsIHJlbGF0ZWQgdG8gdVBFUC4NCg0KQmVzdCByZWdhcmRzDQpMdg0K -- To unsubscribe from this list: send the line "unsubscribe linux-acpi" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
SGksIFJhZmFlbA0KDQo+IEZyb206IGxpbnV4LWFjcGktb3duZXJAdmdlci5rZXJuZWwub3JnIFtt YWlsdG86bGludXgtYWNwaS1vd25lckB2Z2VyLmtlcm5lbC5vcmddIE9uIEJlaGFsZiBPZiBSYWZh ZWwgSi4NCj4gV3lzb2NraQ0KPiBTdWJqZWN0OiBSZTogW1BBVENIIHYyIDMvM10gQUNQSSAvIHNs ZWVwOiBFQy1iYXNlZCB3YWtldXAgZnJvbSBzdXNwZW5kLXRvLWlkbGUgb24gcmVjZW50IERlbGwg c3lzdGVtcw0KPiANCj4gT24gVHVlLCBKdW4gMjAsIDIwMTcgYXQgMjowNyBBTSwgTGludXMgVG9y dmFsZHMNCj4gPHRvcnZhbGRzQGxpbnV4LWZvdW5kYXRpb24ub3JnPiB3cm90ZToNCj4gPiBPbiBU dWUsIEp1biAyMCwgMjAxNyBhdCA1OjUzIEFNLCBSYWZhZWwgSi4gV3lzb2NraSA8cmp3QHJqd3lz b2NraS5uZXQ+IHdyb3RlOg0KPiA+Pg0KPiA+PiAtPiB2MjogQWRkZWQgYWNwaV9zbGVlcD1ub19l Y193YWtldXAgdG8gcHJldmVudCBFQyBldmVudHMgZnJvbSB3YWtpbmcgdXANCj4gPj4gICAgICAg ICAgIHRoZSBzeXN0ZW0gZnJvbSBzMmlkbGUgb24gc3lzdGVtcyB3aGVyZSB0aGV5IGRvIHRoYXQg YnkgZGVmYXVsdC4NCj4gPg0KPiA+IFRoaXMgc2VlbXMgYSBiaWcgaGFja3kuDQo+ID4NCj4gPiBJ cyB0aGVyZSBubyB3YXkgdG8gc2ltcGx5IG1ha2UgYWNwaV9lY19zdXNwZW5kKCkgc21hcnRlciB3 aGlsZSBnb2luZw0KPiA+IHRvIHNsZWVwPyBJbnN0ZWFkIG9mIGp1c3QgdW5jb25kaXRpb25hbGx5 IGRpc2FibGluZyBldmVyeSBFQyBHUEUsIGNhbg0KPiA+IHdlIHNlZSB0aGF0ICJ0aGlzIGdwZSBp cyB0aGUgcG93ZXIgYm90dG9uIiBzb21laG93Pw0KPiANCj4gVW5mb3J0dW5hdGVseSwgdGhlIGNv bm5lY3Rpb24gYmV0d2VlbiB0aGUgR1BFIGFuZCB0aGUgcG93ZXIgYnV0dG9uIGlzDQo+IG5vdCBk aXJlY3QuDQo+IA0KPiBUaGUgRUMgR1BFIGhhbmRsZXIgaGFzIG5vIGlkZWEgdGhhdCBpdCB3aWxs IGdlbmVyYXRlIHBvd2VyIGJ1dHRvbg0KPiBldmVudHMuICBJdCBzaW1wbHkgZXhlY3V0ZXMgYW4g QU1MIG1ldGhvZCBkb2luZyB0aGF0Lg0KPiANCj4gVGhlIEFNTCBtZXRob2QsIGluIHR1cm4sIGV4 ZWN1dGVzIE5vdGlmeShwb3dlciBidXR0b24gZGV2aWNlKSBhbmQgdGhlDQo+ICJwb3dlciBidXR0 b24gZGV2aWNlIiBkcml2ZXIgaGFzIHRvIHJlZ2lzdGVyIGEgbm90aWZ5IGhhbmRsZXIgdGhhdA0K PiB3aWxsIHJlY29nbml6ZSBhbmQgcHJvY2VzcyB0aGUgZXZlbnRzLiAgSXQgZG9lc24ndCBrbm93 IGluIHByaW5jaXBsZQ0KPiB3aGVyZSB0aGUgZXZlbnRzIHdpbGwgY29tZSBmcm9tLCB0aG91Z2gu ICBUaGV5IG1heSBjb21lIGZyb20gdGhlIEVDIG9yDQo+IGZyb20gYSBkaWZmZXJlbnQgR1BFIGV0 Yy4NCj4gDQo+IE5laXRoZXIgdGhlIEVDIGRyaXZlciwgbm9yIHRoZSAicG93ZXIgYnV0dG9uIGRl dmljZSIgZHJpdmVyIGNhbiBmaWd1cmUNCj4gb3V0IHRoYXQgdGhlIGNvbm5lY3Rpb24gaXMgdGhl cmUuDQoNClRoZSBFQyBkcml2ZXIgY2FuIG9ubHkgZ2V0IGFuIGV2ZW50IG51bWJlciBhZnRlciBx dWVyeWluZyB0aGUgZmlybXdhcmUuDQpBbmQgaXQgaGFzIG5vIGlkZWEgd2hldGhlciBoYW5kbGlu ZyB0aGlzIGV2ZW50IGJ5IGV4ZWN1dGluZyBfRXh4IHdoZXJlDQpYeCBpcyB0aGUgbnVtYmVyIG9m IHRoZSBldmVudCBjYW4gcmVzdWx0IGluIE5vdGlmeShwb3dlciBidXR0b24gZGV2aWNlKS4NCg0K VHJhZGl0aW9uYWwgQUNQSSBwb3dlciBidXR0b24gZXZlbnRzIGFyZSBBQ1BJIGZpeGVkIGV2ZW50 cywgbm90IEVDIEdQRToNCg0KUG93ZXIgYnV0dG9uIHNpZ25hbA0KQSBwb3dlciBidXR0b24gY2Fu IGJlIHN1cHBsaWVkIGluIHR3byB3YXlzLg0KIE9uZSB3YXkgaXMgdG8gc2ltcGx5IHVzZSB0aGUg Zml4ZWQgc3RhdHVzIGJpdCwgYW5kDQogVGhlIG90aGVyIHVzZXMgdGhlIGRlY2xhcmF0aW9uIG9m IGFuIEFDUEkgcG93ZXIgZGV2aWNlIGFuZCBBTUwgY29kZSB0bw0KICBkZXRlcm1pbmUgdGhlIGV2 ZW50Lg0KRm9yIG1vcmUgaW5mb3JtYXRpb24gYWJvdXQgdGhlIGFsdGVybmF0ZS1kZXZpY2UgYmFz ZWQgcG93ZXIgYnV0dG9uLCBzZWUNClNlY3Rpb24gNC44LjIuMi4xLjIsIENvbnRyb2wgTWV0aG9k IFBvd2VyIEJ1dHRvbi7igJ0NCg0KSWYgaXQgaXMgbm90IGRlc2lnbmVkIGFzIGZpeGVkIGV2ZW50 LCBPUyBoYXMgbm8gaWRlYSB3aGF0IEdQRSwgb3INCkVDIGV2ZW50IG51bWJlciBpcyByZWxhdGVk IHRvIHRoZSBwb3dlciBidXR0b24uDQoNCj4gDQo+ID4gRGlzYWJsaW5nIHRoZSBwb3dlciBidXR0 b24gZXZlbnQgc291bmRzIGZ1bmRhbWVudGFsbHkgYnJva2VuLCBhbmQgaXQNCj4gPiBzb3VuZHMg bGlrZSBXaW5kb3dzIGRvZXNuJ3QgZG8gdGhhdC4gSSBkb3VidCBXaW5kb3dzIGhhcyBzb21lIGhh Y2t5DQo+ID4gd2hpdGVsaXN0LiBTbyBJJ2QgcmF0aGVyIGZpeCBhIGRlZXBlciBpc3N1ZSB0aGFu IGhhdmUgdGhlc2Uga2luZHMgb2YNCj4gPiBoYWNrcywgaWYgYXQgYWxsIHBvc3NpYmxlLg0KPiAN Cj4gTXkgdW5kZXJzdGFuZGluZyBpcyB0aGF0IFdpbmRvd3MgdXNlcyB0aGUgQUNQSV9GQURUX0xP V19QT1dFUl9TMCBmbGFnLg0KPiBJdCBnZW5lcmFsbHkgZW5hYmxlcyBub24tUzMgc3VzcGVuZC9y ZXN1bWUgd2hlbiB0aGlzIGZsYWcgaXMgc2V0IGFuZA0KPiBpdCBkb2Vzbid0IHRvdWNoIFMzIHRo ZW4uICBLZWVwaW5nIHRoZSBFQyBHUEUgKGFuZCBvdGhlciBHUEVzIGZvciB0aGF0DQo+IG1hdHRl cikgZW5hYmxlZCBvdmVyIHN1c3BlbmQvcmVzdW1lIGlzIHBhcnQgb2YgdGhhdCBpZiBteQ0KPiB1 bmRlcnN0YW5kaW5nIGlzIGNvcnJlY3QuDQoNClRoaXMgc291bmRzIHJlYXNvbmFibGUsIGJ1dCBJ IGhhdmUgYSBxdWVzdGlvbi4NCg0KT24gU3VyZmFjZSBub3RlYm9va3MsIGFuIEVDIEdQRSB3YWtl IGNhcGFibGUgc2V0dGluZyBpcyBwcmVwYXJlZDoNCiAgICAgICAgICAgICAgICAgICAgRGV2aWNl IChFQzApDQogICAgICAgICAgICAgICAgICAgIHsNCiAgICAgICAgICAgICAgICAgICAgICAgIE5h bWUgKF9ISUQsIEVpc2FJZCAoIlBOUDBDMDkiKSkgIC8vIF9ISUQ6IEhhcmR3YXJlIElEDQogICAg ICAgICAgICAgICAgICAgICAgICAuLi4NCiAgICAgICAgICAgICAgICAgICAgICAgIE1ldGhvZCAo X1NUQSwgMCwgTm90U2VyaWFsaXplZCkgIC8vIF9TVEE6IFN0YXR1cw0KICAgICAgICAgICAgICAg ICAgICAgICAgew0KICAgICAgICAgICAgICAgICAgICAgICAgICAgIC4uLg0KICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFJldHVybiAoMHgwRikNCiAgICAgICAgICAgICAgICAgICAgICAgIH0N CiAgICAgICAgICAgICAgICAgICAgICAgIE5hbWUgKF9HUEUsIDB4MzgpICAvLyBfR1BFOiBHZW5l cmFsIFB1cnBvc2UgRXZlbnRzDQogICAgICAgICAgICAgICAgICAgICAgICBOYW1lIChfUFJXLCBQ YWNrYWdlICgweDAyKSAgLy8gX1BSVzogUG93ZXIgUmVzb3VyY2VzIGZvciBXYWtlDQogICAgICAg ICAgICAgICAgICAgICAgICB7DQogICAgICAgICAgICAgICAgICAgICAgICAgICAgMHgzOCwgDQog ICAgICAgICAgICAgICAgICAgICAgICAgICAgMHgwMw0KICAgICAgICAgICAgICAgICAgICAgICAg fSkNCg0KVGhlIF9QUlcgbWVhbnMgR1BFIDB4MzggKEVDIEdQRSkgY2FuIHdha2UtdXAgdGhlIHN5 c3RlbSBmcm9tIFMzLVMwLg0KQW5kIHRoZSBwbGF0Zm9ybSBvbmx5IHN1cHBvcnRzIHMyaWRsZS4N CkRlY29kaW5nIGl0cyBGQURULCB3ZSBjYW4gc2VlIHRoZSBmbGFnIGlzIHNldDoNClswNzBoIDAx MTIgICA0XSAgICAgICAgRmxhZ3MgKGRlY29kZWQgYmVsb3cpIDogMDAyMzg0QjUNCi4uLg0KICAg ICAgICAgICAgICAgICAgICAgIExvdyBQb3dlciBTMCBJZGxlIChWNSkgOiAxDQoNCklmIEVDIEdQ RSBzaG91bGQgYWx3YXlzIGJlIGVuYWJsZWQgd2hlbiB0aGUgZmxhZyBpcyBzZXQsIHdoeSBNUw0K KHN1cmZhY2UgcHJvcyBhcmUgbWFudWZhY3R1cmVkIGJ5IE1TKSBwcmVwYXJlcyBfUFJXIGZvciBp dHMgRUM/DQoNClRoYW5rcywNCkx2DQoNCj4gDQo+IER1cmluZyBzdXNwZW5kIHdlIGdlbmVyYWxs eSBkaXNhYmxlIGFsbCBHUEVzIHRoYXQgYXJlIG5vdCBleHBlY3RlZCB0bw0KPiBnZW5lcmF0ZSB3 YWtldXAgZXZlbnRzIGluIG9yZGVyIHRvIGF2b2lkIHNwdXJpb3VzIHdha2V1cHMsIGJ1dCB3ZSBj YW4NCj4gdHJ5IHRvIGtlZXAgdGhlbSBlbmFibGVkIGlmIEFDUElfRkFEVF9MT1dfUE9XRVJfUzAg aXMgc2V0LiAgVGhhdCB3aWxsDQo+IHJlZHVjZSB0aGUgdWdsaW5lc3MsIGJ1dCB0aGUgY29zdCBt YXkgYmUgbW9yZSBlbmVyZ3kgdXNlZCB3aGlsZQ0KPiBzdXNwZW5kZWQgb24gc29tZSBzeXN0ZW1z Lg0KPiANCj4gVGhhbmtzLA0KPiBSYWZhZWwNCj4gLS0NCj4gVG8gdW5zdWJzY3JpYmUgZnJvbSB0 aGlzIGxpc3Q6IHNlbmQgdGhlIGxpbmUgInVuc3Vic2NyaWJlIGxpbnV4LWFjcGkiIGluDQo+IHRo ZSBib2R5IG9mIGEgbWVzc2FnZSB0byBtYWpvcmRvbW9Admdlci5rZXJuZWwub3JnDQo+IE1vcmUg bWFqb3Jkb21vIGluZm8gYXQgIGh0dHA6Ly92Z2VyLmtlcm5lbC5vcmcvbWFqb3Jkb21vLWluZm8u aHRtbA0K -- To unsubscribe from this list: send the line "unsubscribe linux-acpi" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Index: linux-pm/drivers/acpi/ec.c =================================================================== --- linux-pm.orig/drivers/acpi/ec.c +++ linux-pm/drivers/acpi/ec.c @@ -40,6 +40,7 @@ #include <linux/slab.h> #include <linux/acpi.h> #include <linux/dmi.h> +#include <linux/suspend.h> #include <asm/io.h> #include "internal.h" @@ -1493,6 +1494,16 @@ static int acpi_ec_setup(struct acpi_ec acpi_handle_info(ec->handle, "GPE=0x%lx, EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n", ec->gpe, ec->command_addr, ec->data_addr); + + /* + * On some platforms the EC GPE is used for waking up the system from + * suspend-to-idle, so mark it as a wakeup one. + * + * This can be done unconditionally, as the setting does not matter + * until acpi_set_gpe_wake_mask() is called for the GPE. + */ + acpi_mark_gpe_for_wake(NULL, ec->gpe); + return ret; } @@ -1835,8 +1846,11 @@ static int acpi_ec_suspend(struct device struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev)); - if (ec_freeze_events) + if (!pm_suspend_via_firmware() && acpi_sleep_ec_gpe_may_wakeup()) + acpi_set_gpe_wake_mask(NULL, ec->gpe, ACPI_GPE_ENABLE); + else if (ec_freeze_events) acpi_ec_disable_event(ec); + return 0; } @@ -1846,6 +1860,9 @@ static int acpi_ec_resume(struct device acpi_driver_data(to_acpi_device(dev)); acpi_ec_enable_event(ec); + if (!pm_resume_via_firmware() && acpi_sleep_ec_gpe_may_wakeup()) + acpi_set_gpe_wake_mask(NULL, ec->gpe, ACPI_GPE_DISABLE); + return 0; } #endif Index: linux-pm/drivers/acpi/internal.h =================================================================== --- linux-pm.orig/drivers/acpi/internal.h +++ linux-pm/drivers/acpi/internal.h @@ -199,9 +199,11 @@ void acpi_ec_remove_query_handler(struct -------------------------------------------------------------------------- */ #ifdef CONFIG_ACPI_SYSTEM_POWER_STATES_SUPPORT extern bool acpi_s2idle_wakeup(void); +extern bool acpi_sleep_ec_gpe_may_wakeup(void); extern int acpi_sleep_init(void); #else static inline bool acpi_s2idle_wakeup(void) { return false; } +static inline bool acpi_sleep_ec_gpe_may_wakeup(void) { return false; } static inline int acpi_sleep_init(void) { return -ENXIO; } #endif Index: linux-pm/drivers/acpi/sleep.c =================================================================== --- linux-pm.orig/drivers/acpi/sleep.c +++ linux-pm/drivers/acpi/sleep.c @@ -160,6 +160,23 @@ static int __init init_nvs_nosave(const return 0; } +/* If set, it is allowed to use the EC GPE to wake up the system. */ +static bool ec_gpe_wakeup_allowed __initdata = true; + +void __init acpi_disable_ec_gpe_wakeup(void) +{ + ec_gpe_wakeup_allowed = false; +} + +/* If set, the EC GPE will be configured to wake up the system. */ +static bool ec_gpe_wakeup; + +static int __init init_ec_gpe_wakeup(const struct dmi_system_id *d) +{ + ec_gpe_wakeup = ec_gpe_wakeup_allowed; + return 0; +} + static struct dmi_system_id acpisleep_dmi_table[] __initdata = { { .callback = init_old_suspend_ordering, @@ -343,6 +360,26 @@ static struct dmi_system_id acpisleep_dm DMI_MATCH(DMI_PRODUCT_NAME, "80E3"), }, }, + /* + * Enable the EC to wake up the system from suspend-to-idle to allow + * power button events to it wake up. + */ + { + .callback = init_ec_gpe_wakeup, + .ident = "Dell XPS 13 9360", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "XPS 13 9360"), + }, + }, + { + .callback = init_ec_gpe_wakeup, + .ident = "Dell XPS 13 9365", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "XPS 13 9365"), + }, + }, {}, }; @@ -485,6 +522,7 @@ static void acpi_pm_end(void) } #else /* !CONFIG_ACPI_SLEEP */ #define acpi_target_sleep_state ACPI_STATE_S0 +#define ec_gpe_wakeup false static inline void acpi_sleep_dmi_check(void) {} #endif /* CONFIG_ACPI_SLEEP */ @@ -740,6 +778,11 @@ bool acpi_s2idle_wakeup(void) return s2idle_wakeup; } +bool acpi_sleep_ec_gpe_may_wakeup(void) +{ + return ec_gpe_wakeup; +} + #ifdef CONFIG_PM_SLEEP static u32 saved_bm_rld; Index: linux-pm/arch/x86/kernel/acpi/sleep.c =================================================================== --- linux-pm.orig/arch/x86/kernel/acpi/sleep.c +++ linux-pm/arch/x86/kernel/acpi/sleep.c @@ -137,6 +137,8 @@ static int __init acpi_sleep_setup(char acpi_nvs_nosave_s3(); if (strncmp(str, "old_ordering", 12) == 0) acpi_old_suspend_ordering(); + if (strncmp(str, "no_ec_wakeup", 12) == 0) + acpi_disable_ec_gpe_wakeup(); str = strchr(str, ','); if (str != NULL) str += strspn(str, ", \t"); Index: linux-pm/include/linux/acpi.h =================================================================== --- linux-pm.orig/include/linux/acpi.h +++ linux-pm/include/linux/acpi.h @@ -448,6 +448,7 @@ void __init acpi_no_s4_hw_signature(void void __init acpi_old_suspend_ordering(void); void __init acpi_nvs_nosave(void); void __init acpi_nvs_nosave_s3(void); +void __init acpi_disable_ec_gpe_wakeup(void); #endif /* CONFIG_PM_SLEEP */ struct acpi_osc_context { Index: linux-pm/Documentation/admin-guide/kernel-parameters.txt =================================================================== --- linux-pm.orig/Documentation/admin-guide/kernel-parameters.txt +++ linux-pm/Documentation/admin-guide/kernel-parameters.txt @@ -223,7 +223,8 @@ acpi_sleep= [HW,ACPI] Sleep options Format: { s3_bios, s3_mode, s3_beep, s4_nohwsig, - old_ordering, nonvs, sci_force_enable } + old_ordering, nonvs, sci_force_enable, + no_ec_wakeup } See Documentation/power/video.txt for information on s3_bios and s3_mode. s3_beep is for debugging; it makes the PC's speaker beep @@ -239,6 +240,9 @@ sci_force_enable causes the kernel to set SCI_EN directly on resume from S1/S3 (which is against the ACPI spec, but some broken systems don't work without it). + no_ec_wakeup prevents the EC GPE from being configured + to wake up the system on platforms where that is done by + default. acpi_use_timer_override [HW,ACPI] Use timer override. For some broken Nvidia NF5 boards