| Message ID | 7c7f3a265974fb1f885dbfafcc0b97adc7b72f3b.1494311429.git.lv.zheng@intel.com (mailing list archive) |
|---|---|
| State | Not Applicable, archived |
| Headers | show |
On Tue, May 9, 2017 at 9:02 AM, Lv Zheng <lv.zheng@intel.com> wrote: > We have tested that: > 1. If ACPI button driver sends "open" to the user space but _LID return > value to the kernel space, external monitor issues still cannot be fixed > (link #1, comment #33, test result #2), while > 2. if ACPI button driver sends "close" to the user space but _LID return > value to the kernel space, external monitor issues can be fixed (link > #1, comment #33, test result #3). > We knew that some platforms require "open" to be sent to the user space to > avoid entering a suspend/resume loop. So we have 2 contradictory user space > requirements and are not possible to fix them both in 1 kernel driver mode > without using platform specific quirks. This actually can also be treated > as a proof that the root causes of the bugs are not in the kernel button > driver but in the user space usage models. > > This patch adds button.lid_init_state=close so that it can explicitly > explain the contradictory requirements and help the kernel community to > raise such bugs to the correct responsibles. Well, I just can't see the difference between "close" and "method". The intel driver actually triggers the evaluation of _LID, so this explains why the value gets corrected on platform where the _LID method is accurate. And I don't see the point of sending "close" to user space if close means suspend loops and only fixes a dynamic case where you boot your laptop with the lid closed. Do you expect users to append this option at each boot when the lid is closed? Cheers, Benjamin > > Link: https://bugzilla.kernel.org/show_bug.cgi?id=195455 [#1] > Link: https://bugzilla.redhat.com/show_bug.cgi?id=1430259 > Tested-by: Steffen Weber <steffen.weber@gmail.com> > Tested-by: Julian Wiedmann <julian.wiedmann@jwi.name> > Reported-by: Joachim Frieben <jfrieben@hotmail.com> > Signed-off-by: Lv Zheng <lv.zheng@intel.com> > --- > Documentation/acpi/acpi-lid.txt | 12 +++++++----- > drivers/acpi/button.c | 11 ++++++++++- > 2 files changed, 17 insertions(+), 6 deletions(-) > > diff --git a/Documentation/acpi/acpi-lid.txt b/Documentation/acpi/acpi-lid.txt > index effe7af..e846a59 100644 > --- a/Documentation/acpi/acpi-lid.txt > +++ b/Documentation/acpi/acpi-lid.txt > @@ -69,13 +69,15 @@ A. button.lid_init_state=method: > notification is missing. > This option is the default behavior during the period the userspace > isn't ready to handle the buggy AML tables. > -B. button.lid_init_state=open: > - When this option is specified, the ACPI button driver always reports the > - initial lid state as "opened" and whether the "opened"/"closed" events > - are paired fully relies on the firmware implementation. > +B. button.lid_init_state=open/close: > + When one of these options are specified, the ACPI button driver always > + reports the initial lid state as fixed "opened"/"closed" and whether the > + "opened"/"closed" events are paired fully relies on the firmware > + implementation. > This may fix some platforms where the returning value of the _LID > control method is not reliable and the initial lid state notification is > - missing. > + missing. Especially useful for platforms where different usage models > + require contractory initial lid state. > > If the userspace has been prepared to ignore the unreliable "opened" events > and the unreliable initial state notification, Linux users should always > diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c > index 6d5a8c1..8b4666f 100644 > --- a/drivers/acpi/button.c > +++ b/drivers/acpi/button.c > @@ -57,7 +57,8 @@ > > #define ACPI_BUTTON_LID_INIT_IGNORE 0x00 > #define ACPI_BUTTON_LID_INIT_OPEN 0x01 > -#define ACPI_BUTTON_LID_INIT_METHOD 0x02 > +#define ACPI_BUTTON_LID_INIT_CLOSE 0x02 > +#define ACPI_BUTTON_LID_INIT_METHOD 0x03 > > #define _COMPONENT ACPI_BUTTON_COMPONENT > ACPI_MODULE_NAME("button"); > @@ -377,6 +378,9 @@ static void acpi_lid_initialize_state(struct acpi_device *device) > case ACPI_BUTTON_LID_INIT_OPEN: > (void)acpi_lid_notify_state(device, 1); > break; > + case ACPI_BUTTON_LID_INIT_CLOSE: > + (void)acpi_lid_notify_state(device, 0); > + break; > case ACPI_BUTTON_LID_INIT_METHOD: > (void)acpi_lid_update_state(device); > break; > @@ -563,6 +567,9 @@ static int param_set_lid_init_state(const char *val, struct kernel_param *kp) > if (!strncmp(val, "open", sizeof("open") - 1)) { > lid_init_state = ACPI_BUTTON_LID_INIT_OPEN; > pr_info("Notify initial lid state as open\n"); > + } else if (!strncmp(val, "close", sizeof("close") - 1)) { > + lid_init_state = ACPI_BUTTON_LID_INIT_CLOSE; > + pr_info("Notify initial lid state as close\n"); > } else if (!strncmp(val, "method", sizeof("method") - 1)) { > lid_init_state = ACPI_BUTTON_LID_INIT_METHOD; > pr_info("Notify initial lid state with _LID return value\n"); > @@ -579,6 +586,8 @@ static int param_get_lid_init_state(char *buffer, struct kernel_param *kp) > switch (lid_init_state) { > case ACPI_BUTTON_LID_INIT_OPEN: > return sprintf(buffer, "open"); > + case ACPI_BUTTON_LID_INIT_CLOSE: > + return sprintf(buffer, "close"); > case ACPI_BUTTON_LID_INIT_METHOD: > return sprintf(buffer, "method"); > case ACPI_BUTTON_LID_INIT_IGNORE: > -- > 2.7.4 > > -- > 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
Hi, > From: linux-acpi-owner@vger.kernel.org [mailto:linux-acpi-owner@vger.kernel.org] On Behalf Of Benjamin > Tissoires > Subject: Re: [PATCH v2 2/5] ACPI: button: Add button.lid_init_state=close > > On Tue, May 9, 2017 at 9:02 AM, Lv Zheng <lv.zheng@intel.com> wrote: > > We have tested that: > > 1. If ACPI button driver sends "open" to the user space but _LID return > > value to the kernel space, external monitor issues still cannot be fixed > > (link #1, comment #33, test result #2), while > > 2. if ACPI button driver sends "close" to the user space but _LID return > > value to the kernel space, external monitor issues can be fixed (link > > #1, comment #33, test result #3). > > We knew that some platforms require "open" to be sent to the user space to > > avoid entering a suspend/resume loop. So we have 2 contradictory user space > > requirements and are not possible to fix them both in 1 kernel driver mode > > without using platform specific quirks. This actually can also be treated > > as a proof that the root causes of the bugs are not in the kernel button > > driver but in the user space usage models. > > > > This patch adds button.lid_init_state=close so that it can explicitly > > explain the contradictory requirements and help the kernel community to > > raise such bugs to the correct responsibles. > > Well, I just can't see the difference between "close" and "method". > The intel driver actually triggers the evaluation of _LID, so this > explains why the value gets corrected on platform where the _LID > method is accurate. > > And I don't see the point of sending "close" to user space if close > means suspend loops and only fixes a dynamic case where you boot your > laptop with the lid closed. Do you expect users to append this option > at each boot when the lid is closed? There in fact is a difference. If a BIOS implements _LID using cached value. And BIOS AML code never generates lid notification after boot/resume. And the _LID default value is "open" after boot/resume. Then let's compare: 1. after boot: 1.1. button.lid_init_state=method sends open to the user space 1.2. button.lid_init_state=close sends close to the user space 2. after resume: 1.1. button.lid_init_state=method sends open to the user space 1.2. button.lid_init_state=close sends close to the user space See, that's the difference. If there is such a platform, for the reported user space issues, button.lid_init_state=method cannot work for them, they'll have to use button.lid_init_state=close to achieve the expected behavior. So I believe this mode is useful. Cheers, Lv > > Cheers, > Benjamin > > > > > Link: https://bugzilla.kernel.org/show_bug.cgi?id=195455 [#1] > > Link: https://bugzilla.redhat.com/show_bug.cgi?id=1430259 > > Tested-by: Steffen Weber <steffen.weber@gmail.com> > > Tested-by: Julian Wiedmann <julian.wiedmann@jwi.name> > > Reported-by: Joachim Frieben <jfrieben@hotmail.com> > > Signed-off-by: Lv Zheng <lv.zheng@intel.com> > > --- > > Documentation/acpi/acpi-lid.txt | 12 +++++++----- > > drivers/acpi/button.c | 11 ++++++++++- > > 2 files changed, 17 insertions(+), 6 deletions(-) > > > > diff --git a/Documentation/acpi/acpi-lid.txt b/Documentation/acpi/acpi-lid.txt > > index effe7af..e846a59 100644 > > --- a/Documentation/acpi/acpi-lid.txt > > +++ b/Documentation/acpi/acpi-lid.txt > > @@ -69,13 +69,15 @@ A. button.lid_init_state=method: > > notification is missing. > > This option is the default behavior during the period the userspace > > isn't ready to handle the buggy AML tables. > > -B. button.lid_init_state=open: > > - When this option is specified, the ACPI button driver always reports the > > - initial lid state as "opened" and whether the "opened"/"closed" events > > - are paired fully relies on the firmware implementation. > > +B. button.lid_init_state=open/close: > > + When one of these options are specified, the ACPI button driver always > > + reports the initial lid state as fixed "opened"/"closed" and whether the > > + "opened"/"closed" events are paired fully relies on the firmware > > + implementation. > > This may fix some platforms where the returning value of the _LID > > control method is not reliable and the initial lid state notification is > > - missing. > > + missing. Especially useful for platforms where different usage models > > + require contractory initial lid state. > > > > If the userspace has been prepared to ignore the unreliable "opened" events > > and the unreliable initial state notification, Linux users should always > > diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c > > index 6d5a8c1..8b4666f 100644 > > --- a/drivers/acpi/button.c > > +++ b/drivers/acpi/button.c > > @@ -57,7 +57,8 @@ > > > > #define ACPI_BUTTON_LID_INIT_IGNORE 0x00 > > #define ACPI_BUTTON_LID_INIT_OPEN 0x01 > > -#define ACPI_BUTTON_LID_INIT_METHOD 0x02 > > +#define ACPI_BUTTON_LID_INIT_CLOSE 0x02 > > +#define ACPI_BUTTON_LID_INIT_METHOD 0x03 > > > > #define _COMPONENT ACPI_BUTTON_COMPONENT > > ACPI_MODULE_NAME("button"); > > @@ -377,6 +378,9 @@ static void acpi_lid_initialize_state(struct acpi_device *device) > > case ACPI_BUTTON_LID_INIT_OPEN: > > (void)acpi_lid_notify_state(device, 1); > > break; > > + case ACPI_BUTTON_LID_INIT_CLOSE: > > + (void)acpi_lid_notify_state(device, 0); > > + break; > > case ACPI_BUTTON_LID_INIT_METHOD: > > (void)acpi_lid_update_state(device); > > break; > > @@ -563,6 +567,9 @@ static int param_set_lid_init_state(const char *val, struct kernel_param *kp) > > if (!strncmp(val, "open", sizeof("open") - 1)) { > > lid_init_state = ACPI_BUTTON_LID_INIT_OPEN; > > pr_info("Notify initial lid state as open\n"); > > + } else if (!strncmp(val, "close", sizeof("close") - 1)) { > > + lid_init_state = ACPI_BUTTON_LID_INIT_CLOSE; > > + pr_info("Notify initial lid state as close\n"); > > } else if (!strncmp(val, "method", sizeof("method") - 1)) { > > lid_init_state = ACPI_BUTTON_LID_INIT_METHOD; > > pr_info("Notify initial lid state with _LID return value\n"); > > @@ -579,6 +586,8 @@ static int param_get_lid_init_state(char *buffer, struct kernel_param *kp) > > switch (lid_init_state) { > > case ACPI_BUTTON_LID_INIT_OPEN: > > return sprintf(buffer, "open"); > > + case ACPI_BUTTON_LID_INIT_CLOSE: > > + return sprintf(buffer, "close"); > > case ACPI_BUTTON_LID_INIT_METHOD: > > return sprintf(buffer, "method"); > > case ACPI_BUTTON_LID_INIT_IGNORE: > > -- > > 2.7.4 > > > > -- > > 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 Fri, May 12, 2017 at 3:31 AM, Zheng, Lv <lv.zheng@intel.com> wrote: > Hi, > >> From: linux-acpi-owner@vger.kernel.org [mailto:linux-acpi-owner@vger.kernel.org] On Behalf Of Benjamin >> Tissoires >> Subject: Re: [PATCH v2 2/5] ACPI: button: Add button.lid_init_state=close >> >> On Tue, May 9, 2017 at 9:02 AM, Lv Zheng <lv.zheng@intel.com> wrote: >> > We have tested that: >> > 1. If ACPI button driver sends "open" to the user space but _LID return >> > value to the kernel space, external monitor issues still cannot be fixed >> > (link #1, comment #33, test result #2), while >> > 2. if ACPI button driver sends "close" to the user space but _LID return >> > value to the kernel space, external monitor issues can be fixed (link >> > #1, comment #33, test result #3). >> > We knew that some platforms require "open" to be sent to the user space to >> > avoid entering a suspend/resume loop. So we have 2 contradictory user space >> > requirements and are not possible to fix them both in 1 kernel driver mode >> > without using platform specific quirks. This actually can also be treated >> > as a proof that the root causes of the bugs are not in the kernel button >> > driver but in the user space usage models. >> > >> > This patch adds button.lid_init_state=close so that it can explicitly >> > explain the contradictory requirements and help the kernel community to >> > raise such bugs to the correct responsibles. >> >> Well, I just can't see the difference between "close" and "method". >> The intel driver actually triggers the evaluation of _LID, so this >> explains why the value gets corrected on platform where the _LID >> method is accurate. >> >> And I don't see the point of sending "close" to user space if close >> means suspend loops and only fixes a dynamic case where you boot your >> laptop with the lid closed. Do you expect users to append this option >> at each boot when the lid is closed? > > There in fact is a difference. > If a BIOS implements _LID using cached value. > And BIOS AML code never generates lid notification after boot/resume. > And the _LID default value is "open" after boot/resume. > > Then let's compare: > 1. after boot: > 1.1. button.lid_init_state=method sends open to the user space > 1.2. button.lid_init_state=close sends close to the user space > 2. after resume: > 1.1. button.lid_init_state=method sends open to the user space > 1.2. button.lid_init_state=close sends close to the user space > > See, that's the difference. > > If there is such a platform, for the reported user space issues, > button.lid_init_state=method cannot work for them, > they'll have to use button.lid_init_state=close > to achieve the expected behavior. > > So I believe this mode is useful. I don't buy it because you are missing a parameter here: what is the actual state of the lid (open or closed). And if you report "close" while it's opened, that's not good. So maybe, it can be interesting for debugging, but for end users, I don't see why anyone would use it. Because a laptop can be moved, docked or not, and this is a static parameter. So there will always be a state where you will be reporting a false state. Cheers, Benjamin > > Cheers, > Lv > >> >> Cheers, >> Benjamin >> >> > >> > Link: https://bugzilla.kernel.org/show_bug.cgi?id=195455 [#1] >> > Link: https://bugzilla.redhat.com/show_bug.cgi?id=1430259 >> > Tested-by: Steffen Weber <steffen.weber@gmail.com> >> > Tested-by: Julian Wiedmann <julian.wiedmann@jwi.name> >> > Reported-by: Joachim Frieben <jfrieben@hotmail.com> >> > Signed-off-by: Lv Zheng <lv.zheng@intel.com> >> > --- >> > Documentation/acpi/acpi-lid.txt | 12 +++++++----- >> > drivers/acpi/button.c | 11 ++++++++++- >> > 2 files changed, 17 insertions(+), 6 deletions(-) >> > >> > diff --git a/Documentation/acpi/acpi-lid.txt b/Documentation/acpi/acpi-lid.txt >> > index effe7af..e846a59 100644 >> > --- a/Documentation/acpi/acpi-lid.txt >> > +++ b/Documentation/acpi/acpi-lid.txt >> > @@ -69,13 +69,15 @@ A. button.lid_init_state=method: >> > notification is missing. >> > This option is the default behavior during the period the userspace >> > isn't ready to handle the buggy AML tables. >> > -B. button.lid_init_state=open: >> > - When this option is specified, the ACPI button driver always reports the >> > - initial lid state as "opened" and whether the "opened"/"closed" events >> > - are paired fully relies on the firmware implementation. >> > +B. button.lid_init_state=open/close: >> > + When one of these options are specified, the ACPI button driver always >> > + reports the initial lid state as fixed "opened"/"closed" and whether the >> > + "opened"/"closed" events are paired fully relies on the firmware >> > + implementation. >> > This may fix some platforms where the returning value of the _LID >> > control method is not reliable and the initial lid state notification is >> > - missing. >> > + missing. Especially useful for platforms where different usage models >> > + require contractory initial lid state. >> > >> > If the userspace has been prepared to ignore the unreliable "opened" events >> > and the unreliable initial state notification, Linux users should always >> > diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c >> > index 6d5a8c1..8b4666f 100644 >> > --- a/drivers/acpi/button.c >> > +++ b/drivers/acpi/button.c >> > @@ -57,7 +57,8 @@ >> > >> > #define ACPI_BUTTON_LID_INIT_IGNORE 0x00 >> > #define ACPI_BUTTON_LID_INIT_OPEN 0x01 >> > -#define ACPI_BUTTON_LID_INIT_METHOD 0x02 >> > +#define ACPI_BUTTON_LID_INIT_CLOSE 0x02 >> > +#define ACPI_BUTTON_LID_INIT_METHOD 0x03 >> > >> > #define _COMPONENT ACPI_BUTTON_COMPONENT >> > ACPI_MODULE_NAME("button"); >> > @@ -377,6 +378,9 @@ static void acpi_lid_initialize_state(struct acpi_device *device) >> > case ACPI_BUTTON_LID_INIT_OPEN: >> > (void)acpi_lid_notify_state(device, 1); >> > break; >> > + case ACPI_BUTTON_LID_INIT_CLOSE: >> > + (void)acpi_lid_notify_state(device, 0); >> > + break; >> > case ACPI_BUTTON_LID_INIT_METHOD: >> > (void)acpi_lid_update_state(device); >> > break; >> > @@ -563,6 +567,9 @@ static int param_set_lid_init_state(const char *val, struct kernel_param *kp) >> > if (!strncmp(val, "open", sizeof("open") - 1)) { >> > lid_init_state = ACPI_BUTTON_LID_INIT_OPEN; >> > pr_info("Notify initial lid state as open\n"); >> > + } else if (!strncmp(val, "close", sizeof("close") - 1)) { >> > + lid_init_state = ACPI_BUTTON_LID_INIT_CLOSE; >> > + pr_info("Notify initial lid state as close\n"); >> > } else if (!strncmp(val, "method", sizeof("method") - 1)) { >> > lid_init_state = ACPI_BUTTON_LID_INIT_METHOD; >> > pr_info("Notify initial lid state with _LID return value\n"); >> > @@ -579,6 +586,8 @@ static int param_get_lid_init_state(char *buffer, struct kernel_param *kp) >> > switch (lid_init_state) { >> > case ACPI_BUTTON_LID_INIT_OPEN: >> > return sprintf(buffer, "open"); >> > + case ACPI_BUTTON_LID_INIT_CLOSE: >> > + return sprintf(buffer, "close"); >> > case ACPI_BUTTON_LID_INIT_METHOD: >> > return sprintf(buffer, "method"); >> > case ACPI_BUTTON_LID_INIT_IGNORE: >> > -- >> > 2.7.4 >> > >> > -- >> > 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 -- 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
SGksIEJlbmphbWluDQoNCj4gRnJvbTogQmVuamFtaW4gVGlzc29pcmVzIFttYWlsdG86YmVuamFt aW4udGlzc29pcmVzQGdtYWlsLmNvbV0NCj4gU3ViamVjdDogUmU6IFtQQVRDSCB2MiAyLzVdIEFD UEk6IGJ1dHRvbjogQWRkIGJ1dHRvbi5saWRfaW5pdF9zdGF0ZT1jbG9zZQ0KPiANCj4gT24gRnJp LCBNYXkgMTIsIDIwMTcgYXQgMzozMSBBTSwgWmhlbmcsIEx2IDxsdi56aGVuZ0BpbnRlbC5jb20+ IHdyb3RlOg0KPiA+IEhpLA0KPiA+DQo+ID4+IEZyb206IGxpbnV4LWFjcGktb3duZXJAdmdlci5r ZXJuZWwub3JnIFttYWlsdG86bGludXgtYWNwaS1vd25lckB2Z2VyLmtlcm5lbC5vcmddIE9uIEJl aGFsZiBPZg0KPiBCZW5qYW1pbg0KPiA+PiBUaXNzb2lyZXMNCj4gPj4gU3ViamVjdDogUmU6IFtQ QVRDSCB2MiAyLzVdIEFDUEk6IGJ1dHRvbjogQWRkIGJ1dHRvbi5saWRfaW5pdF9zdGF0ZT1jbG9z ZQ0KPiA+Pg0KPiA+PiBPbiBUdWUsIE1heSA5LCAyMDE3IGF0IDk6MDIgQU0sIEx2IFpoZW5nIDxs di56aGVuZ0BpbnRlbC5jb20+IHdyb3RlOg0KPiA+PiA+IFdlIGhhdmUgdGVzdGVkIHRoYXQ6DQo+ ID4+ID4gMS4gSWYgQUNQSSBidXR0b24gZHJpdmVyIHNlbmRzICJvcGVuIiB0byB0aGUgdXNlciBz cGFjZSBidXQgX0xJRCByZXR1cm4NCj4gPj4gPiAgICB2YWx1ZSB0byB0aGUga2VybmVsIHNwYWNl LCBleHRlcm5hbCBtb25pdG9yIGlzc3VlcyBzdGlsbCBjYW5ub3QgYmUgZml4ZWQNCj4gPj4gPiAg ICAobGluayAjMSwgY29tbWVudCAjMzMsIHRlc3QgcmVzdWx0ICMyKSwgd2hpbGUNCj4gPj4gPiAy LiBpZiBBQ1BJIGJ1dHRvbiBkcml2ZXIgc2VuZHMgImNsb3NlIiB0byB0aGUgdXNlciBzcGFjZSBi dXQgX0xJRCByZXR1cm4NCj4gPj4gPiAgICB2YWx1ZSB0byB0aGUga2VybmVsIHNwYWNlLCBleHRl cm5hbCBtb25pdG9yIGlzc3VlcyBjYW4gYmUgZml4ZWQgKGxpbmsNCj4gPj4gPiAgICAjMSwgY29t bWVudCAjMzMsIHRlc3QgcmVzdWx0ICMzKS4NCj4gPj4gPiBXZSBrbmV3IHRoYXQgc29tZSBwbGF0 Zm9ybXMgcmVxdWlyZSAib3BlbiIgdG8gYmUgc2VudCB0byB0aGUgdXNlciBzcGFjZSB0bw0KPiA+ PiA+IGF2b2lkIGVudGVyaW5nIGEgc3VzcGVuZC9yZXN1bWUgbG9vcC4gU28gd2UgaGF2ZSAyIGNv bnRyYWRpY3RvcnkgdXNlciBzcGFjZQ0KPiA+PiA+IHJlcXVpcmVtZW50cyBhbmQgYXJlIG5vdCBw b3NzaWJsZSB0byBmaXggdGhlbSBib3RoIGluIDEga2VybmVsIGRyaXZlciBtb2RlDQo+ID4+ID4g d2l0aG91dCB1c2luZyBwbGF0Zm9ybSBzcGVjaWZpYyBxdWlya3MuIFRoaXMgYWN0dWFsbHkgY2Fu IGFsc28gYmUgdHJlYXRlZA0KPiA+PiA+IGFzIGEgcHJvb2YgdGhhdCB0aGUgcm9vdCBjYXVzZXMg b2YgdGhlIGJ1Z3MgYXJlIG5vdCBpbiB0aGUga2VybmVsIGJ1dHRvbg0KPiA+PiA+IGRyaXZlciBi dXQgaW4gdGhlIHVzZXIgc3BhY2UgdXNhZ2UgbW9kZWxzLg0KPiA+PiA+DQo+ID4+ID4gVGhpcyBw YXRjaCBhZGRzIGJ1dHRvbi5saWRfaW5pdF9zdGF0ZT1jbG9zZSBzbyB0aGF0IGl0IGNhbiBleHBs aWNpdGx5DQo+ID4+ID4gZXhwbGFpbiB0aGUgY29udHJhZGljdG9yeSByZXF1aXJlbWVudHMgYW5k IGhlbHAgdGhlIGtlcm5lbCBjb21tdW5pdHkgdG8NCj4gPj4gPiByYWlzZSBzdWNoIGJ1Z3MgdG8g dGhlIGNvcnJlY3QgcmVzcG9uc2libGVzLg0KPiA+Pg0KPiA+PiBXZWxsLCBJIGp1c3QgY2FuJ3Qg c2VlIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gImNsb3NlIiBhbmQgIm1ldGhvZCIuDQo+ID4+IFRo ZSBpbnRlbCBkcml2ZXIgYWN0dWFsbHkgdHJpZ2dlcnMgdGhlIGV2YWx1YXRpb24gb2YgX0xJRCwg c28gdGhpcw0KPiA+PiBleHBsYWlucyB3aHkgdGhlIHZhbHVlIGdldHMgY29ycmVjdGVkIG9uIHBs YXRmb3JtIHdoZXJlIHRoZSBfTElEDQo+ID4+IG1ldGhvZCBpcyBhY2N1cmF0ZS4NCj4gPj4NCj4g Pj4gQW5kIEkgZG9uJ3Qgc2VlIHRoZSBwb2ludCBvZiBzZW5kaW5nICJjbG9zZSIgdG8gdXNlciBz cGFjZSBpZiBjbG9zZQ0KPiA+PiBtZWFucyBzdXNwZW5kIGxvb3BzIGFuZCBvbmx5IGZpeGVzIGEg ZHluYW1pYyBjYXNlIHdoZXJlIHlvdSBib290IHlvdXINCj4gPj4gbGFwdG9wIHdpdGggdGhlIGxp ZCBjbG9zZWQuIERvIHlvdSBleHBlY3QgdXNlcnMgdG8gYXBwZW5kIHRoaXMgb3B0aW9uDQo+ID4+ IGF0IGVhY2ggYm9vdCB3aGVuIHRoZSBsaWQgaXMgY2xvc2VkPw0KPiA+DQo+ID4gVGhlcmUgaW4g ZmFjdCBpcyBhIGRpZmZlcmVuY2UuDQo+ID4gSWYgYSBCSU9TIGltcGxlbWVudHMgX0xJRCB1c2lu ZyBjYWNoZWQgdmFsdWUuDQo+ID4gQW5kIEJJT1MgQU1MIGNvZGUgbmV2ZXIgZ2VuZXJhdGVzIGxp ZCBub3RpZmljYXRpb24gYWZ0ZXIgYm9vdC9yZXN1bWUuDQo+ID4gQW5kIHRoZSBfTElEIGRlZmF1 bHQgdmFsdWUgaXMgIm9wZW4iIGFmdGVyIGJvb3QvcmVzdW1lLg0KPiA+DQo+ID4gVGhlbiBsZXQn cyBjb21wYXJlOg0KPiA+IDEuIGFmdGVyIGJvb3Q6DQo+ID4gMS4xLiBidXR0b24ubGlkX2luaXRf c3RhdGU9bWV0aG9kIHNlbmRzIG9wZW4gdG8gdGhlIHVzZXIgc3BhY2UNCj4gPiAxLjIuIGJ1dHRv bi5saWRfaW5pdF9zdGF0ZT1jbG9zZSBzZW5kcyBjbG9zZSB0byB0aGUgdXNlciBzcGFjZQ0KPiA+ IDIuIGFmdGVyIHJlc3VtZToNCj4gPiAxLjEuIGJ1dHRvbi5saWRfaW5pdF9zdGF0ZT1tZXRob2Qg c2VuZHMgb3BlbiB0byB0aGUgdXNlciBzcGFjZQ0KPiA+IDEuMi4gYnV0dG9uLmxpZF9pbml0X3N0 YXRlPWNsb3NlIHNlbmRzIGNsb3NlIHRvIHRoZSB1c2VyIHNwYWNlDQo+ID4NCj4gPiBTZWUsIHRo YXQncyB0aGUgZGlmZmVyZW5jZS4NCj4gPg0KPiA+IElmIHRoZXJlIGlzIHN1Y2ggYSBwbGF0Zm9y bSwgZm9yIHRoZSByZXBvcnRlZCB1c2VyIHNwYWNlIGlzc3VlcywNCj4gPiBidXR0b24ubGlkX2lu aXRfc3RhdGU9bWV0aG9kIGNhbm5vdCB3b3JrIGZvciB0aGVtLA0KPiA+IHRoZXknbGwgaGF2ZSB0 byB1c2UgYnV0dG9uLmxpZF9pbml0X3N0YXRlPWNsb3NlDQo+ID4gdG8gYWNoaWV2ZSB0aGUgZXhw ZWN0ZWQgYmVoYXZpb3IuDQo+ID4NCj4gPiBTbyBJIGJlbGlldmUgdGhpcyBtb2RlIGlzIHVzZWZ1 bC4NCj4gDQo+IEkgZG9uJ3QgYnV5IGl0IGJlY2F1c2UgeW91IGFyZSBtaXNzaW5nIGEgcGFyYW1l dGVyIGhlcmU6IHdoYXQgaXMgdGhlDQo+IGFjdHVhbCBzdGF0ZSBvZiB0aGUgbGlkIChvcGVuIG9y IGNsb3NlZCkuDQo+IEFuZCBpZiB5b3UgcmVwb3J0ICJjbG9zZSIgd2hpbGUgaXQncyBvcGVuZWQs IHRoYXQncyBub3QgZ29vZC4NCg0KSSB0aGluayB5b3UgaGF2ZSBzb21ldGhpbmcgd3JvbmcgaGVy ZS4NCkluIGZhY3QgYnV0dG9uIGRyaXZlciBkb2Vzbid0IHdhbnQgdG8gcmVwb3J0IGFueXRoaW5n IGhlcmUuDQpBbmQgaXQgYWN0dWFsbHkgd29uJ3QgYW55dGhpbmcgd3JvbmcgdGhpbmcgaWYgYnV0 dG9uLmxpZF9pbml0X3N0YXRlPWlnbm9yZSBpcyBzcGVjaWZpZWQuDQoNClRoZSB3cm9uZyBzdGF0 ZXMgdGhlIHVzZXIgc3BhY2Uva2VybmVsIHNwYWNlIHJlY2VpdmVkIGFyZSBiZWNhdXNlIG9mIHRo ZSB1c2VyIHNwYWNlIHdyb25nIGV4cGVjdGF0aW9uIGFnYWluc3Qgd2hhdCBBQ1BJIGNvbnRyb2wg bWV0aG9kIGxpZCBkZXZpY2UgaXMgcHJvdmlkaW5nLg0KDQo+IA0KPiBTbyBtYXliZSwgaXQgY2Fu IGJlIGludGVyZXN0aW5nIGZvciBkZWJ1Z2dpbmcsIGJ1dCBmb3IgZW5kIHVzZXJzLCBJDQo+IGRv bid0IHNlZSB3aHkgYW55b25lIHdvdWxkIHVzZSBpdC4gQmVjYXVzZSBhIGxhcHRvcCBjYW4gYmUg bW92ZWQsDQo+IGRvY2tlZCBvciBub3QsIGFuZCB0aGlzIGlzIGEgc3RhdGljIHBhcmFtZXRlci4g U28gdGhlcmUgd2lsbCBhbHdheXMgYmUNCj4gYSBzdGF0ZSB3aGVyZSB5b3Ugd2lsbCBiZSByZXBv cnRpbmcgYSBmYWxzZSBzdGF0ZS4NCg0KVGhlcmUgaXMgbm8gZmFsc2Ugc3RhdGUgcmVwb3J0Lg0K VXNlciBzcGFjZSBwcm9ncmFtcyBnZXQgdGhlIGZhbHNlIHN0YXRlIGJlY2F1c2UgdGhleSB3YW50 IGJ1dHRvbiBkcml2ZXIgdG8gd29yayBpbiBidXR0b24ubGlkX2luaXRfc3RhdGU9bWV0aG9kIG1v ZGUuDQpXaGlsZSBCSU9TIGV4cGVjdHMgdGhlIEFDUEkgYnV0dG9uIGRyaXZlciB0byB3b3JrIGlu IGJ1dHRvbi5saWRfaW5pdF9zdGF0ZT1pZ25vcmUuDQoNClNvIGlmIHVzZXIgc3BhY2UgcmVhbGx5 IHdhbnRzIHNvbWV0aGluZyBiZXlvbmQgd2hhdCBBQ1BJIGNvbnRyb2wgbWV0aG9kIGxpZCBkZXZp Y2UgY2FuIHByb3ZpZGUuDQpJTU8sIGJ1dHRvbiBkcml2ZXIgaXMgb2sgdG8gcHJvdmlkZSAid29y a2Fyb3VuZCIgbW9kZXMgZm9yIHRoZW0uDQpUaGVuIGFmdGVyIHRoYXQsIGV2ZXJ5dGhpbmcgc2hv dWxkIGJlIGRvbmUgb24gdGhlaXIgb3duLg0KDQpDaGVlcnMsDQpMdg0KDQo+IA0KPiBDaGVlcnMs DQo+IEJlbmphbWluDQo+IA0KPiA+DQo+ID4gQ2hlZXJzLA0KPiA+IEx2DQo+ID4NCj4gPj4NCj4g Pj4gQ2hlZXJzLA0KPiA+PiBCZW5qYW1pbg0KPiA+Pg0KPiA+PiA+DQo+ID4+ID4gTGluazogaHR0 cHM6Ly9idWd6aWxsYS5rZXJuZWwub3JnL3Nob3dfYnVnLmNnaT9pZD0xOTU0NTUgWyMxXQ0KPiA+ PiA+IExpbms6IGh0dHBzOi8vYnVnemlsbGEucmVkaGF0LmNvbS9zaG93X2J1Zy5jZ2k/aWQ9MTQz MDI1OQ0KPiA+PiA+IFRlc3RlZC1ieTogU3RlZmZlbiBXZWJlciA8c3RlZmZlbi53ZWJlckBnbWFp bC5jb20+DQo+ID4+ID4gVGVzdGVkLWJ5OiBKdWxpYW4gV2llZG1hbm4gPGp1bGlhbi53aWVkbWFu bkBqd2kubmFtZT4NCj4gPj4gPiBSZXBvcnRlZC1ieTogSm9hY2hpbSBGcmllYmVuIDxqZnJpZWJl bkBob3RtYWlsLmNvbT4NCj4gPj4gPiBTaWduZWQtb2ZmLWJ5OiBMdiBaaGVuZyA8bHYuemhlbmdA aW50ZWwuY29tPg0KPiA+PiA+IC0tLQ0KPiA+PiA+ICBEb2N1bWVudGF0aW9uL2FjcGkvYWNwaS1s aWQudHh0IHwgMTIgKysrKysrKy0tLS0tDQo+ID4+ID4gIGRyaXZlcnMvYWNwaS9idXR0b24uYyAg ICAgICAgICAgfCAxMSArKysrKysrKysrLQ0KPiA+PiA+ICAyIGZpbGVzIGNoYW5nZWQsIDE3IGlu c2VydGlvbnMoKyksIDYgZGVsZXRpb25zKC0pDQo+ID4+ID4NCj4gPj4gPiBkaWZmIC0tZ2l0IGEv RG9jdW1lbnRhdGlvbi9hY3BpL2FjcGktbGlkLnR4dCBiL0RvY3VtZW50YXRpb24vYWNwaS9hY3Bp LWxpZC50eHQNCj4gPj4gPiBpbmRleCBlZmZlN2FmLi5lODQ2YTU5IDEwMDY0NA0KPiA+PiA+IC0t LSBhL0RvY3VtZW50YXRpb24vYWNwaS9hY3BpLWxpZC50eHQNCj4gPj4gPiArKysgYi9Eb2N1bWVu dGF0aW9uL2FjcGkvYWNwaS1saWQudHh0DQo+ID4+ID4gQEAgLTY5LDEzICs2OSwxNSBAQCBBLiBi dXR0b24ubGlkX2luaXRfc3RhdGU9bWV0aG9kOg0KPiA+PiA+ICAgICBub3RpZmljYXRpb24gaXMg bWlzc2luZy4NCj4gPj4gPiAgICAgVGhpcyBvcHRpb24gaXMgdGhlIGRlZmF1bHQgYmVoYXZpb3Ig ZHVyaW5nIHRoZSBwZXJpb2QgdGhlIHVzZXJzcGFjZQ0KPiA+PiA+ICAgICBpc24ndCByZWFkeSB0 byBoYW5kbGUgdGhlIGJ1Z2d5IEFNTCB0YWJsZXMuDQo+ID4+ID4gLUIuIGJ1dHRvbi5saWRfaW5p dF9zdGF0ZT1vcGVuOg0KPiA+PiA+IC0gICBXaGVuIHRoaXMgb3B0aW9uIGlzIHNwZWNpZmllZCwg dGhlIEFDUEkgYnV0dG9uIGRyaXZlciBhbHdheXMgcmVwb3J0cyB0aGUNCj4gPj4gPiAtICAgaW5p dGlhbCBsaWQgc3RhdGUgYXMgIm9wZW5lZCIgYW5kIHdoZXRoZXIgdGhlICJvcGVuZWQiLyJjbG9z ZWQiIGV2ZW50cw0KPiA+PiA+IC0gICBhcmUgcGFpcmVkIGZ1bGx5IHJlbGllcyBvbiB0aGUgZmly bXdhcmUgaW1wbGVtZW50YXRpb24uDQo+ID4+ID4gK0IuIGJ1dHRvbi5saWRfaW5pdF9zdGF0ZT1v cGVuL2Nsb3NlOg0KPiA+PiA+ICsgICBXaGVuIG9uZSBvZiB0aGVzZSBvcHRpb25zIGFyZSBzcGVj aWZpZWQsIHRoZSBBQ1BJIGJ1dHRvbiBkcml2ZXIgYWx3YXlzDQo+ID4+ID4gKyAgIHJlcG9ydHMg dGhlIGluaXRpYWwgbGlkIHN0YXRlIGFzIGZpeGVkICJvcGVuZWQiLyJjbG9zZWQiIGFuZCB3aGV0 aGVyIHRoZQ0KPiA+PiA+ICsgICAib3BlbmVkIi8iY2xvc2VkIiBldmVudHMgYXJlIHBhaXJlZCBm dWxseSByZWxpZXMgb24gdGhlIGZpcm13YXJlDQo+ID4+ID4gKyAgIGltcGxlbWVudGF0aW9uLg0K PiA+PiA+ICAgICBUaGlzIG1heSBmaXggc29tZSBwbGF0Zm9ybXMgd2hlcmUgdGhlIHJldHVybmlu ZyB2YWx1ZSBvZiB0aGUgX0xJRA0KPiA+PiA+ICAgICBjb250cm9sIG1ldGhvZCBpcyBub3QgcmVs aWFibGUgYW5kIHRoZSBpbml0aWFsIGxpZCBzdGF0ZSBub3RpZmljYXRpb24gaXMNCj4gPj4gPiAt ICAgbWlzc2luZy4NCj4gPj4gPiArICAgbWlzc2luZy4gRXNwZWNpYWxseSB1c2VmdWwgZm9yIHBs YXRmb3JtcyB3aGVyZSBkaWZmZXJlbnQgdXNhZ2UgbW9kZWxzDQo+ID4+ID4gKyAgIHJlcXVpcmUg Y29udHJhY3RvcnkgaW5pdGlhbCBsaWQgc3RhdGUuDQo+ID4+ID4NCj4gPj4gPiAgSWYgdGhlIHVz ZXJzcGFjZSBoYXMgYmVlbiBwcmVwYXJlZCB0byBpZ25vcmUgdGhlIHVucmVsaWFibGUgIm9wZW5l ZCIgZXZlbnRzDQo+ID4+ID4gIGFuZCB0aGUgdW5yZWxpYWJsZSBpbml0aWFsIHN0YXRlIG5vdGlm aWNhdGlvbiwgTGludXggdXNlcnMgc2hvdWxkIGFsd2F5cw0KPiA+PiA+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2FjcGkvYnV0dG9uLmMgYi9kcml2ZXJzL2FjcGkvYnV0dG9uLmMNCj4gPj4gPiBpbmRl eCA2ZDVhOGMxLi44YjQ2NjZmIDEwMDY0NA0KPiA+PiA+IC0tLSBhL2RyaXZlcnMvYWNwaS9idXR0 b24uYw0KPiA+PiA+ICsrKyBiL2RyaXZlcnMvYWNwaS9idXR0b24uYw0KPiA+PiA+IEBAIC01Nyw3 ICs1Nyw4IEBADQo+ID4+ID4NCj4gPj4gPiAgI2RlZmluZSBBQ1BJX0JVVFRPTl9MSURfSU5JVF9J R05PUkUgICAgMHgwMA0KPiA+PiA+ICAjZGVmaW5lIEFDUElfQlVUVE9OX0xJRF9JTklUX09QRU4g ICAgICAweDAxDQo+ID4+ID4gLSNkZWZpbmUgQUNQSV9CVVRUT05fTElEX0lOSVRfTUVUSE9EICAg IDB4MDINCj4gPj4gPiArI2RlZmluZSBBQ1BJX0JVVFRPTl9MSURfSU5JVF9DTE9TRSAgICAgMHgw Mg0KPiA+PiA+ICsjZGVmaW5lIEFDUElfQlVUVE9OX0xJRF9JTklUX01FVEhPRCAgICAweDAzDQo+ ID4+ID4NCj4gPj4gPiAgI2RlZmluZSBfQ09NUE9ORU5UICAgICAgICAgICAgIEFDUElfQlVUVE9O X0NPTVBPTkVOVA0KPiA+PiA+ICBBQ1BJX01PRFVMRV9OQU1FKCJidXR0b24iKTsNCj4gPj4gPiBA QCAtMzc3LDYgKzM3OCw5IEBAIHN0YXRpYyB2b2lkIGFjcGlfbGlkX2luaXRpYWxpemVfc3RhdGUo c3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpDQo+ID4+ID4gICAgICAgICBjYXNlIEFDUElfQlVU VE9OX0xJRF9JTklUX09QRU46DQo+ID4+ID4gICAgICAgICAgICAgICAgICh2b2lkKWFjcGlfbGlk X25vdGlmeV9zdGF0ZShkZXZpY2UsIDEpOw0KPiA+PiA+ICAgICAgICAgICAgICAgICBicmVhazsN Cj4gPj4gPiArICAgICAgIGNhc2UgQUNQSV9CVVRUT05fTElEX0lOSVRfQ0xPU0U6DQo+ID4+ID4g KyAgICAgICAgICAgICAgICh2b2lkKWFjcGlfbGlkX25vdGlmeV9zdGF0ZShkZXZpY2UsIDApOw0K PiA+PiA+ICsgICAgICAgICAgICAgICBicmVhazsNCj4gPj4gPiAgICAgICAgIGNhc2UgQUNQSV9C VVRUT05fTElEX0lOSVRfTUVUSE9EOg0KPiA+PiA+ICAgICAgICAgICAgICAgICAodm9pZClhY3Bp X2xpZF91cGRhdGVfc3RhdGUoZGV2aWNlKTsNCj4gPj4gPiAgICAgICAgICAgICAgICAgYnJlYWs7 DQo+ID4+ID4gQEAgLTU2Myw2ICs1NjcsOSBAQCBzdGF0aWMgaW50IHBhcmFtX3NldF9saWRfaW5p dF9zdGF0ZShjb25zdCBjaGFyICp2YWwsIHN0cnVjdCBrZXJuZWxfcGFyYW0gKmtwKQ0KPiA+PiA+ ICAgICAgICAgaWYgKCFzdHJuY21wKHZhbCwgIm9wZW4iLCBzaXplb2YoIm9wZW4iKSAtIDEpKSB7 DQo+ID4+ID4gICAgICAgICAgICAgICAgIGxpZF9pbml0X3N0YXRlID0gQUNQSV9CVVRUT05fTElE X0lOSVRfT1BFTjsNCj4gPj4gPiAgICAgICAgICAgICAgICAgcHJfaW5mbygiTm90aWZ5IGluaXRp YWwgbGlkIHN0YXRlIGFzIG9wZW5cbiIpOw0KPiA+PiA+ICsgICAgICAgfSBlbHNlIGlmICghc3Ry bmNtcCh2YWwsICJjbG9zZSIsIHNpemVvZigiY2xvc2UiKSAtIDEpKSB7DQo+ID4+ID4gKyAgICAg ICAgICAgICAgIGxpZF9pbml0X3N0YXRlID0gQUNQSV9CVVRUT05fTElEX0lOSVRfQ0xPU0U7DQo+ ID4+ID4gKyAgICAgICAgICAgICAgIHByX2luZm8oIk5vdGlmeSBpbml0aWFsIGxpZCBzdGF0ZSBh cyBjbG9zZVxuIik7DQo+ID4+ID4gICAgICAgICB9IGVsc2UgaWYgKCFzdHJuY21wKHZhbCwgIm1l dGhvZCIsIHNpemVvZigibWV0aG9kIikgLSAxKSkgew0KPiA+PiA+ICAgICAgICAgICAgICAgICBs aWRfaW5pdF9zdGF0ZSA9IEFDUElfQlVUVE9OX0xJRF9JTklUX01FVEhPRDsNCj4gPj4gPiAgICAg ICAgICAgICAgICAgcHJfaW5mbygiTm90aWZ5IGluaXRpYWwgbGlkIHN0YXRlIHdpdGggX0xJRCBy ZXR1cm4gdmFsdWVcbiIpOw0KPiA+PiA+IEBAIC01NzksNiArNTg2LDggQEAgc3RhdGljIGludCBw YXJhbV9nZXRfbGlkX2luaXRfc3RhdGUoY2hhciAqYnVmZmVyLCBzdHJ1Y3Qga2VybmVsX3BhcmFt ICprcCkNCj4gPj4gPiAgICAgICAgIHN3aXRjaCAobGlkX2luaXRfc3RhdGUpIHsNCj4gPj4gPiAg ICAgICAgIGNhc2UgQUNQSV9CVVRUT05fTElEX0lOSVRfT1BFTjoNCj4gPj4gPiAgICAgICAgICAg ICAgICAgcmV0dXJuIHNwcmludGYoYnVmZmVyLCAib3BlbiIpOw0KPiA+PiA+ICsgICAgICAgY2Fz ZSBBQ1BJX0JVVFRPTl9MSURfSU5JVF9DTE9TRToNCj4gPj4gPiArICAgICAgICAgICAgICAgcmV0 dXJuIHNwcmludGYoYnVmZmVyLCAiY2xvc2UiKTsNCj4gPj4gPiAgICAgICAgIGNhc2UgQUNQSV9C VVRUT05fTElEX0lOSVRfTUVUSE9EOg0KPiA+PiA+ICAgICAgICAgICAgICAgICByZXR1cm4gc3By aW50ZihidWZmZXIsICJtZXRob2QiKTsNCj4gPj4gPiAgICAgICAgIGNhc2UgQUNQSV9CVVRUT05f TElEX0lOSVRfSUdOT1JFOg0KPiA+PiA+IC0tDQo+ID4+ID4gMi43LjQNCj4gPj4gPg0KPiA+PiA+ IC0tDQo+ID4+ID4gVG8gdW5zdWJzY3JpYmUgZnJvbSB0aGlzIGxpc3Q6IHNlbmQgdGhlIGxpbmUg InVuc3Vic2NyaWJlIGxpbnV4LWFjcGkiIGluDQo+ID4+ID4gdGhlIGJvZHkgb2YgYSBtZXNzYWdl IHRvIG1ham9yZG9tb0B2Z2VyLmtlcm5lbC5vcmcNCj4gPj4gPiBNb3JlIG1ham9yZG9tbyBpbmZv IGF0ICBodHRwOi8vdmdlci5rZXJuZWwub3JnL21ham9yZG9tby1pbmZvLmh0bWwNCj4gPj4gLS0N Cj4gPj4gVG8gdW5zdWJzY3JpYmUgZnJvbSB0aGlzIGxpc3Q6IHNlbmQgdGhlIGxpbmUgInVuc3Vi c2NyaWJlIGxpbnV4LWFjcGkiIGluDQo+ID4+IHRoZSBib2R5IG9mIGEgbWVzc2FnZSB0byBtYWpv cmRvbW9Admdlci5rZXJuZWwub3JnDQo+ID4+IE1vcmUgbWFqb3Jkb21vIGluZm8gYXQgIGh0dHA6 Ly92Z2VyLmtlcm5lbC5vcmcvbWFqb3Jkb21vLWluZm8uaHRtbA0K -- 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
diff --git a/Documentation/acpi/acpi-lid.txt b/Documentation/acpi/acpi-lid.txt index effe7af..e846a59 100644 --- a/Documentation/acpi/acpi-lid.txt +++ b/Documentation/acpi/acpi-lid.txt @@ -69,13 +69,15 @@ A. button.lid_init_state=method: notification is missing. This option is the default behavior during the period the userspace isn't ready to handle the buggy AML tables. -B. button.lid_init_state=open: - When this option is specified, the ACPI button driver always reports the - initial lid state as "opened" and whether the "opened"/"closed" events - are paired fully relies on the firmware implementation. +B. button.lid_init_state=open/close: + When one of these options are specified, the ACPI button driver always + reports the initial lid state as fixed "opened"/"closed" and whether the + "opened"/"closed" events are paired fully relies on the firmware + implementation. This may fix some platforms where the returning value of the _LID control method is not reliable and the initial lid state notification is - missing. + missing. Especially useful for platforms where different usage models + require contractory initial lid state. If the userspace has been prepared to ignore the unreliable "opened" events and the unreliable initial state notification, Linux users should always diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c index 6d5a8c1..8b4666f 100644 --- a/drivers/acpi/button.c +++ b/drivers/acpi/button.c @@ -57,7 +57,8 @@ #define ACPI_BUTTON_LID_INIT_IGNORE 0x00 #define ACPI_BUTTON_LID_INIT_OPEN 0x01 -#define ACPI_BUTTON_LID_INIT_METHOD 0x02 +#define ACPI_BUTTON_LID_INIT_CLOSE 0x02 +#define ACPI_BUTTON_LID_INIT_METHOD 0x03 #define _COMPONENT ACPI_BUTTON_COMPONENT ACPI_MODULE_NAME("button"); @@ -377,6 +378,9 @@ static void acpi_lid_initialize_state(struct acpi_device *device) case ACPI_BUTTON_LID_INIT_OPEN: (void)acpi_lid_notify_state(device, 1); break; + case ACPI_BUTTON_LID_INIT_CLOSE: + (void)acpi_lid_notify_state(device, 0); + break; case ACPI_BUTTON_LID_INIT_METHOD: (void)acpi_lid_update_state(device); break; @@ -563,6 +567,9 @@ static int param_set_lid_init_state(const char *val, struct kernel_param *kp) if (!strncmp(val, "open", sizeof("open") - 1)) { lid_init_state = ACPI_BUTTON_LID_INIT_OPEN; pr_info("Notify initial lid state as open\n"); + } else if (!strncmp(val, "close", sizeof("close") - 1)) { + lid_init_state = ACPI_BUTTON_LID_INIT_CLOSE; + pr_info("Notify initial lid state as close\n"); } else if (!strncmp(val, "method", sizeof("method") - 1)) { lid_init_state = ACPI_BUTTON_LID_INIT_METHOD; pr_info("Notify initial lid state with _LID return value\n"); @@ -579,6 +586,8 @@ static int param_get_lid_init_state(char *buffer, struct kernel_param *kp) switch (lid_init_state) { case ACPI_BUTTON_LID_INIT_OPEN: return sprintf(buffer, "open"); + case ACPI_BUTTON_LID_INIT_CLOSE: + return sprintf(buffer, "close"); case ACPI_BUTTON_LID_INIT_METHOD: return sprintf(buffer, "method"); case ACPI_BUTTON_LID_INIT_IGNORE: