| Message ID | 284674cb8228f4f2b40f940a3c4a666f367d7b6a.1464775699.git.lv.zheng@intel.com (mailing list archive) |
|---|---|
| State | Accepted, archived |
| Delegated to: | Rafael Wysocki |
| Headers | show |
On Wed, 2016-06-01 at 18:10 +0800, Lv Zheng wrote: > Linux userspace (systemd-logind) keeps on rechecking lid state when the > lid state is closed. If it failed to update the lid state to open after > boot/resume, the system suspending right after the boot/resume could be > resulted. > Graphics drivers also uses the lid notifications to implment > MODESET_ON_LID_OPEN option. "implement" > Before the situation is improved from the userspace and from the graphics > driver, users can simply configure ACPI button driver to send initial > "open" lid state using button.lid_init_state=open to avoid such kind of > issues. And our ultimate target should be making > button.lid_init_state=ignore the default behavior. This patch implements > the 2 options and keep the old behavior (button.lid_init_state=method). I still don't think it's reasonable to expect any changes in user-space unless you start documenting what the API to user-space actually is. (I work on UPower, which also exports that information, and which gets used in gnome-settings-daemon in a number of ways) > Link 1: https://lkml.org/2016/3/7/460 > Link 2: https://github.com/systemd/systemd/issues/2087 > Signed-off-by: Lv Zheng <lv.zheng@intel.com> > Cc: Bastien Nocera: <hadess@hadess.net> > Cc: Benjamin Tissoires <benjamin.tissoires@gmail.com> > --- > drivers/acpi/button.c | 61 > +++++++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 61 insertions(+) > > diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c > index 6e291c1..148f4e5 100644 > --- a/drivers/acpi/button.c > +++ b/drivers/acpi/button.c > @@ -53,6 +53,10 @@ > #define ACPI_BUTTON_DEVICE_NAME_LID "Lid Switch" > #define ACPI_BUTTON_TYPE_LID 0x05 > > +#define ACPI_BUTTON_LID_INIT_IGNORE 0x00 > +#define ACPI_BUTTON_LID_INIT_OPEN 0x01 > +#define ACPI_BUTTON_LID_INIT_METHOD 0x02 > + > #define _COMPONENT ACPI_BUTTON_COMPONENT > ACPI_MODULE_NAME("button"); > > @@ -105,6 +109,7 @@ struct acpi_button { > > static BLOCKING_NOTIFIER_HEAD(acpi_lid_notifier); > static struct acpi_device *lid_device; > +static u8 lid_init_state = ACPI_BUTTON_LID_INIT_METHOD; > > /* --------------------------------------------------------------- > ----------- > FS Interface (/proc) > @@ -285,6 +290,21 @@ static int acpi_lid_update_state(struct > acpi_device *device) > return acpi_lid_notify_state(device, state); > } > > +static void acpi_lid_initialize_state(struct acpi_device *device) > +{ > + switch (lid_init_state) { > + case ACPI_BUTTON_LID_INIT_OPEN: > + (void)acpi_lid_notify_state(device, 1); > + break; > + case ACPI_BUTTON_LID_INIT_METHOD: > + (void)acpi_lid_update_state(device); > + break; > + case ACPI_BUTTON_LID_INIT_IGNORE: > + default: > + break; > + } > +} > + > static void acpi_button_notify(struct acpi_device *device, u32 > event) > { > struct acpi_button *button = acpi_driver_data(device); > @@ -341,6 +361,8 @@ static int acpi_button_resume(struct device *dev) > struct acpi_button *button = acpi_driver_data(device); > > button->suspended = false; > + if (button->type == ACPI_BUTTON_TYPE_LID) > + acpi_lid_initialize_state(device); > return 0; > } > #endif > @@ -421,6 +443,7 @@ static int acpi_button_add(struct acpi_device > *device) > if (error) > goto err_remove_fs; > if (button->type == ACPI_BUTTON_TYPE_LID) { > + acpi_lid_initialize_state(device); > /* > * This assumes there's only one lid device, or if > there are > * more we only care about the last one... > @@ -450,4 +473,42 @@ static int acpi_button_remove(struct acpi_device > *device) > return 0; > } > > +static int param_set_lid_init_state(const char *val, struct > kernel_param *kp) > +{ > + int result = 0; > + > + 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, "method", sizeof("method") - 1)) { > + lid_init_state = ACPI_BUTTON_LID_INIT_METHOD; > + pr_info("Notify initial lid state with _LID return > value\n"); > + } else if (!strncmp(val, "ignore", sizeof("ignore") - 1)) { > + lid_init_state = ACPI_BUTTON_LID_INIT_IGNORE; > + pr_info("Do not notify initial lid state\n"); > + } else > + result = -EINVAL; > + return result; > +} > + > +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_METHOD: > + return sprintf(buffer, "method"); > + case ACPI_BUTTON_LID_INIT_IGNORE: > + return sprintf(buffer, "ignore"); > + default: > + return sprintf(buffer, "invalid"); > + } > + return 0; > +} > + > +module_param_call(lid_init_state, > + param_set_lid_init_state, > param_get_lid_init_state, > + NULL, 0644); > +MODULE_PARM_DESC(lid_init_state, "Behavior for reporting LID initial > state"); > + > module_acpi_driver(acpi_button_driver); -- 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
SGksDQoNCj4gRnJvbTogQmFzdGllbiBOb2NlcmEgW21haWx0bzpoYWRlc3NAaGFkZXNzLm5ldF0N Cj4gU3ViamVjdDogUmU6IFtQQVRDSCB2MyAzLzNdIEFDUEkgLyBidXR0b246IEFkZCBxdWlya3Mg Zm9yIGluaXRpYWwgbGlkIHN0YXRlDQo+IG5vdGlmaWNhdGlvbg0KPiANCj4gT24gV2VkLCAyMDE2 LTA2LTAxIGF0IDE4OjEwICswODAwLCBMdiBaaGVuZyB3cm90ZToNCj4gPiBMaW51eCB1c2Vyc3Bh Y2UgKHN5c3RlbWQtbG9naW5kKSBrZWVwcyBvbiByZWNoZWNraW5nIGxpZCBzdGF0ZSB3aGVuIHRo ZQ0KPiA+IGxpZCBzdGF0ZSBpcyBjbG9zZWQuIElmIGl0IGZhaWxlZCB0byB1cGRhdGUgdGhlIGxp ZCBzdGF0ZSB0byBvcGVuIGFmdGVyDQo+ID4gYm9vdC9yZXN1bWUsIHRoZSBzeXN0ZW0gc3VzcGVu ZGluZyByaWdodCBhZnRlciB0aGUgYm9vdC9yZXN1bWUgY291bGQNCj4gYmUNCj4gPiByZXN1bHRl ZC4NCj4gPiBHcmFwaGljcyBkcml2ZXJzIGFsc28gdXNlcyB0aGUgbGlkIG5vdGlmaWNhdGlvbnMg dG8gaW1wbG1lbnQNCj4gPiBNT0RFU0VUX09OX0xJRF9PUEVOIG9wdGlvbi4NCj4gDQo+ICJpbXBs ZW1lbnQiDQpbTHYgWmhlbmddIA0KVGhhbmtzIGZvciBwb2ludGluZyBvdXQsIEknbGwgc2VuZCBh biBVUERBVEUgdG8gdGhpcy4NCg0KPiANCj4gPiBCZWZvcmUgdGhlIHNpdHVhdGlvbiBpcyBpbXBy b3ZlZCBmcm9tIHRoZSB1c2Vyc3BhY2UgYW5kIGZyb20gdGhlDQo+IGdyYXBoaWNzDQo+ID4gZHJp dmVyLCB1c2VycyBjYW4gc2ltcGx5IGNvbmZpZ3VyZSBBQ1BJIGJ1dHRvbiBkcml2ZXIgdG8gc2Vu ZCBpbml0aWFsDQo+ID4gIm9wZW4iIGxpZCBzdGF0ZSB1c2luZyBidXR0b24ubGlkX2luaXRfc3Rh dGU9b3BlbiB0byBhdm9pZCBzdWNoIGtpbmQgb2YNCj4gPiBpc3N1ZXMuIEFuZCBvdXIgdWx0aW1h dGUgdGFyZ2V0IHNob3VsZCBiZSBtYWtpbmcNCj4gPiBidXR0b24ubGlkX2luaXRfc3RhdGU9aWdu b3JlIHRoZSBkZWZhdWx0IGJlaGF2aW9yLiBUaGlzIHBhdGNoIGltcGxlbWVudHMNCj4gPiB0aGUg MiBvcHRpb25zIGFuZCBrZWVwIHRoZSBvbGQgYmVoYXZpb3IgKGJ1dHRvbi5saWRfaW5pdF9zdGF0 ZT1tZXRob2QpLg0KPiANCj4gSSBzdGlsbCBkb24ndCB0aGluayBpdCdzIHJlYXNvbmFibGUgdG8g ZXhwZWN0IGFueSBjaGFuZ2VzIGluIHVzZXItc3BhY2UNCj4gdW5sZXNzIHlvdSBzdGFydCBkb2N1 bWVudGluZyB3aGF0IHRoZSBBUEkgdG8gdXNlci1zcGFjZSBhY3R1YWxseSBpcy4NCltMdiBaaGVu Z10gDQpJTU8sIHRoZSBBQ1BJIGxpZCBkcml2ZXIgc2hvdWxkIGJlIHJlc3BvbnNpYmxlIGZvciBz ZW5kaW5nIGxpZCBrZXkgZXZlbnQgKGVzcGVjaWFsbHkgImNsb3NlIikgdG8gdGhlIHVzZXIgc3Bh Y2UuDQpTbyBpZiBzb21lb25lIG5lZWQgdG8gaW1wbGVtZW50IGFuIEFDUEkgbGlkIGtleSBldmVu dCBxdWlyaywgd2UgY291bGQgaGVscCB0byBpbXBsZW1lbnQgaXQgZnJvbSB0aGUga2VybmVsIHNw YWNlLg0KQW5kIHNpbmNlIHRoZSBpbml0aWFsIGxpZCBzdGF0ZSBpcyBub3Qgc3RhYmxlLCB3ZSBo YXZlIHRvIHN0b3AgZG9pbmcgcXVpcmtzIGFyb3VuZCBpdCBpbnNpZGUgb2YgdGhlIExpbnV4IGtl cm5lbCwgb3IgaW5zaWRlIG9mIHRoZSBjdXN0b21pemVkIEFNTCB0YWJsZXMuDQpVc2VyIHNwYWNl IGNhbiBzdGlsbCBhY2Nlc3MgL3Byb2MvYWNwaS9idXR0b24vbGlkL0xJRDAvc3RhdGUsIGJ1dCBz aG91bGQgc3RvcCB0aGlua2luZyB0aGF0IGl0IGlzIHJlbGlhYmxlLg0KDQpUaGVzZSBhcmUgd2hh dCBJIGNhbiBjb25jbHVkZSBmcm9tIHRoZSBidWdzLg0KDQpUaGFua3MgYW5kIGJlc3QgcmVnYXJk cw0KLUx2DQoNCj4gDQo+IChJIHdvcmsgb24gVVBvd2VyLCB3aGljaCBhbHNvIGV4cG9ydHMgdGhh dCBpbmZvcm1hdGlvbiwgYW5kIHdoaWNoIGdldHMNCj4gdXNlZCBpbiBnbm9tZS1zZXR0aW5ncy1k YWVtb24gaW4gYSBudW1iZXIgb2Ygd2F5cykNCj4gDQo+ID4gTGluayAxOiBodHRwczovL2xrbWwu b3JnLzIwMTYvMy83LzQ2MA0KPiA+IExpbmsgMjogaHR0cHM6Ly9naXRodWIuY29tL3N5c3RlbWQv c3lzdGVtZC9pc3N1ZXMvMjA4Nw0KPiA+IFNpZ25lZC1vZmYtYnk6IEx2IFpoZW5nIDxsdi56aGVu Z0BpbnRlbC5jb20+DQo+ID4gQ2M6IEJhc3RpZW4gTm9jZXJhOiA8aGFkZXNzQGhhZGVzcy5uZXQ+ DQo+ID4gQ2M6IEJlbmphbWluIFRpc3NvaXJlcyA8YmVuamFtaW4udGlzc29pcmVzQGdtYWlsLmNv bT4NCj4gPiAtLS0NCj4gPiDCoGRyaXZlcnMvYWNwaS9idXR0b24uYyB8wqDCoMKgNjENCj4gPiAr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrDQo+ID4gwqAx IGZpbGUgY2hhbmdlZCwgNjEgaW5zZXJ0aW9ucygrKQ0KPiA+DQo+ID4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvYWNwaS9idXR0b24uYyBiL2RyaXZlcnMvYWNwaS9idXR0b24uYw0KPiA+IGluZGV4IDZl MjkxYzEuLjE0OGY0ZTUgMTAwNjQ0DQo+ID4gLS0tIGEvZHJpdmVycy9hY3BpL2J1dHRvbi5jDQo+ ID4gKysrIGIvZHJpdmVycy9hY3BpL2J1dHRvbi5jDQo+ID4gQEAgLTUzLDYgKzUzLDEwIEBADQo+ ID4gwqAjZGVmaW5lIEFDUElfQlVUVE9OX0RFVklDRV9OQU1FX0xJRAkiTGlkIFN3aXRjaCINCj4g PiDCoCNkZWZpbmUgQUNQSV9CVVRUT05fVFlQRV9MSUQJCTB4MDUNCj4gPg0KPiA+ICsjZGVmaW5l IEFDUElfQlVUVE9OX0xJRF9JTklUX0lHTk9SRQkweDAwDQo+ID4gKyNkZWZpbmUgQUNQSV9CVVRU T05fTElEX0lOSVRfT1BFTgkweDAxDQo+ID4gKyNkZWZpbmUgQUNQSV9CVVRUT05fTElEX0lOSVRf TUVUSE9ECTB4MDINCj4gPiArDQo+ID4gwqAjZGVmaW5lIF9DT01QT05FTlQJCUFDUElfQlVUVE9O X0NPTVBPTkVOVA0KPiA+IMKgQUNQSV9NT0RVTEVfTkFNRSgiYnV0dG9uIik7DQo+ID4NCj4gPiBA QCAtMTA1LDYgKzEwOSw3IEBAIHN0cnVjdCBhY3BpX2J1dHRvbiB7DQo+ID4NCj4gPiDCoHN0YXRp YyBCTE9DS0lOR19OT1RJRklFUl9IRUFEKGFjcGlfbGlkX25vdGlmaWVyKTsNCj4gPiDCoHN0YXRp YyBzdHJ1Y3QgYWNwaV9kZXZpY2UgKmxpZF9kZXZpY2U7DQo+ID4gK3N0YXRpYyB1OCBsaWRfaW5p dF9zdGF0ZSA9IEFDUElfQlVUVE9OX0xJRF9JTklUX01FVEhPRDsNCj4gPg0KPiA+IMKgLyogLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tDQo+ID4gLS0tLS0tLS0tLS0NCj4gPiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoEZTIEludGVyZmFjZSAoL3Byb2MpDQo+ID4g QEAgLTI4NSw2ICsyOTAsMjEgQEAgc3RhdGljIGludCBhY3BpX2xpZF91cGRhdGVfc3RhdGUoc3Ry dWN0DQo+ID4gYWNwaV9kZXZpY2UgKmRldmljZSkNCj4gPiDCoAlyZXR1cm4gYWNwaV9saWRfbm90 aWZ5X3N0YXRlKGRldmljZSwgc3RhdGUpOw0KPiA+IMKgfQ0KPiA+DQo+ID4gK3N0YXRpYyB2b2lk IGFjcGlfbGlkX2luaXRpYWxpemVfc3RhdGUoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpDQo+ ID4gK3sNCj4gPiArCXN3aXRjaCAobGlkX2luaXRfc3RhdGUpIHsNCj4gPiArCWNhc2UgQUNQSV9C VVRUT05fTElEX0lOSVRfT1BFTjoNCj4gPiArCQkodm9pZClhY3BpX2xpZF9ub3RpZnlfc3RhdGUo ZGV2aWNlLCAxKTsNCj4gPiArCQlicmVhazsNCj4gPiArCWNhc2UgQUNQSV9CVVRUT05fTElEX0lO SVRfTUVUSE9EOg0KPiA+ICsJCSh2b2lkKWFjcGlfbGlkX3VwZGF0ZV9zdGF0ZShkZXZpY2UpOw0K PiA+ICsJCWJyZWFrOw0KPiA+ICsJY2FzZSBBQ1BJX0JVVFRPTl9MSURfSU5JVF9JR05PUkU6DQo+ ID4gKwlkZWZhdWx0Og0KPiA+ICsJCWJyZWFrOw0KPiA+ICsJfQ0KPiA+ICt9DQo+ID4gKw0KPiA+ IMKgc3RhdGljIHZvaWQgYWNwaV9idXR0b25fbm90aWZ5KHN0cnVjdCBhY3BpX2RldmljZSAqZGV2 aWNlLCB1MzINCj4gPiBldmVudCkNCj4gPiDCoHsNCj4gPiDCoAlzdHJ1Y3QgYWNwaV9idXR0b24g KmJ1dHRvbiA9IGFjcGlfZHJpdmVyX2RhdGEoZGV2aWNlKTsNCj4gPiBAQCAtMzQxLDYgKzM2MSw4 IEBAIHN0YXRpYyBpbnQgYWNwaV9idXR0b25fcmVzdW1lKHN0cnVjdCBkZXZpY2UNCj4gKmRldikN Cj4gPiDCoAlzdHJ1Y3QgYWNwaV9idXR0b24gKmJ1dHRvbiA9IGFjcGlfZHJpdmVyX2RhdGEoZGV2 aWNlKTsNCj4gPg0KPiA+IMKgCWJ1dHRvbi0+c3VzcGVuZGVkID0gZmFsc2U7DQo+ID4gKwlpZiAo YnV0dG9uLT50eXBlID09IEFDUElfQlVUVE9OX1RZUEVfTElEKQ0KPiA+ICsJCWFjcGlfbGlkX2lu aXRpYWxpemVfc3RhdGUoZGV2aWNlKTsNCj4gPiDCoAlyZXR1cm4gMDsNCj4gPiDCoH0NCj4gPiDC oCNlbmRpZg0KPiA+IEBAIC00MjEsNiArNDQzLDcgQEAgc3RhdGljIGludCBhY3BpX2J1dHRvbl9h ZGQoc3RydWN0IGFjcGlfZGV2aWNlDQo+ID4gKmRldmljZSkNCj4gPiDCoAlpZiAoZXJyb3IpDQo+ ID4gwqAJCWdvdG8gZXJyX3JlbW92ZV9mczsNCj4gPiDCoAlpZiAoYnV0dG9uLT50eXBlID09IEFD UElfQlVUVE9OX1RZUEVfTElEKSB7DQo+ID4gKwkJYWNwaV9saWRfaW5pdGlhbGl6ZV9zdGF0ZShk ZXZpY2UpOw0KPiA+IMKgCQkvKg0KPiA+IMKgCQnCoCogVGhpcyBhc3N1bWVzIHRoZXJlJ3Mgb25s eSBvbmUgbGlkIGRldmljZSwgb3IgaWYNCj4gPiB0aGVyZSBhcmUNCj4gPiDCoAkJwqAqIG1vcmUg d2Ugb25seSBjYXJlIGFib3V0IHRoZSBsYXN0IG9uZS4uLg0KPiA+IEBAIC00NTAsNCArNDczLDQy IEBAIHN0YXRpYyBpbnQgYWNwaV9idXR0b25fcmVtb3ZlKHN0cnVjdA0KPiBhY3BpX2RldmljZQ0K PiA+ICpkZXZpY2UpDQo+ID4gwqAJcmV0dXJuIDA7DQo+ID4gwqB9DQo+ID4NCj4gPiArc3RhdGlj IGludCBwYXJhbV9zZXRfbGlkX2luaXRfc3RhdGUoY29uc3QgY2hhciAqdmFsLCBzdHJ1Y3QNCj4g PiBrZXJuZWxfcGFyYW0gKmtwKQ0KPiA+ICt7DQo+ID4gKwlpbnQgcmVzdWx0ID0gMDsNCj4gPiAr DQo+ID4gKwlpZiAoIXN0cm5jbXAodmFsLCAib3BlbiIsIHNpemVvZigib3BlbiIpIC0gMSkpIHsN Cj4gPiArCQlsaWRfaW5pdF9zdGF0ZSA9IEFDUElfQlVUVE9OX0xJRF9JTklUX09QRU47DQo+ID4g KwkJcHJfaW5mbygiTm90aWZ5IGluaXRpYWwgbGlkIHN0YXRlIGFzIG9wZW5cbiIpOw0KPiA+ICsJ fSBlbHNlIGlmICghc3RybmNtcCh2YWwsICJtZXRob2QiLCBzaXplb2YoIm1ldGhvZCIpIC0gMSkp IHsNCj4gPiArCQlsaWRfaW5pdF9zdGF0ZSA9IEFDUElfQlVUVE9OX0xJRF9JTklUX01FVEhPRDsN Cj4gPiArCQlwcl9pbmZvKCJOb3RpZnkgaW5pdGlhbCBsaWQgc3RhdGUgd2l0aCBfTElEIHJldHVy bg0KPiA+IHZhbHVlXG4iKTsNCj4gPiArCX0gZWxzZSBpZiAoIXN0cm5jbXAodmFsLCAiaWdub3Jl Iiwgc2l6ZW9mKCJpZ25vcmUiKSAtIDEpKSB7DQo+ID4gKwkJbGlkX2luaXRfc3RhdGUgPSBBQ1BJ X0JVVFRPTl9MSURfSU5JVF9JR05PUkU7DQo+ID4gKwkJcHJfaW5mbygiRG8gbm90IG5vdGlmeSBp bml0aWFsIGxpZCBzdGF0ZVxuIik7DQo+ID4gKwl9IGVsc2UNCj4gPiArCQlyZXN1bHQgPSAtRUlO VkFMOw0KPiA+ICsJcmV0dXJuIHJlc3VsdDsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3RhdGljIGlu dCBwYXJhbV9nZXRfbGlkX2luaXRfc3RhdGUoY2hhciAqYnVmZmVyLCBzdHJ1Y3QNCj4gPiBrZXJu ZWxfcGFyYW0gKmtwKQ0KPiA+ICt7DQo+ID4gKwlzd2l0Y2ggKGxpZF9pbml0X3N0YXRlKSB7DQo+ ID4gKwljYXNlIEFDUElfQlVUVE9OX0xJRF9JTklUX09QRU46DQo+ID4gKwkJcmV0dXJuIHNwcmlu dGYoYnVmZmVyLCAib3BlbiIpOw0KPiA+ICsJY2FzZSBBQ1BJX0JVVFRPTl9MSURfSU5JVF9NRVRI T0Q6DQo+ID4gKwkJcmV0dXJuIHNwcmludGYoYnVmZmVyLCAibWV0aG9kIik7DQo+ID4gKwljYXNl IEFDUElfQlVUVE9OX0xJRF9JTklUX0lHTk9SRToNCj4gPiArCQlyZXR1cm4gc3ByaW50ZihidWZm ZXIsICJpZ25vcmUiKTsNCj4gPiArCWRlZmF1bHQ6DQo+ID4gKwkJcmV0dXJuIHNwcmludGYoYnVm ZmVyLCAiaW52YWxpZCIpOw0KPiA+ICsJfQ0KPiA+ICsJcmV0dXJuIDA7DQo+ID4gK30NCj4gPiAr DQo+ID4gK21vZHVsZV9wYXJhbV9jYWxsKGxpZF9pbml0X3N0YXRlLA0KPiA+ICsJCcKgwqBwYXJh bV9zZXRfbGlkX2luaXRfc3RhdGUsDQo+ID4gcGFyYW1fZ2V0X2xpZF9pbml0X3N0YXRlLA0KPiA+ ICsJCcKgwqBOVUxMLCAwNjQ0KTsNCj4gPiArTU9EVUxFX1BBUk1fREVTQyhsaWRfaW5pdF9zdGF0 ZSwgIkJlaGF2aW9yIGZvciByZXBvcnRpbmcgTElEIGluaXRpYWwNCj4gPiBzdGF0ZSIpOw0KPiA+ ICsNCj4gPiDCoG1vZHVsZV9hY3BpX2RyaXZlcihhY3BpX2J1dHRvbl9kcml2ZXIpOw0K -- 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 Thu, 2016-06-02 at 01:08 +0000, Zheng, Lv wrote: > Hi, > > > From: Bastien Nocera [mailto:hadess@hadess.net] > > Subject: Re: [PATCH v3 3/3] ACPI / button: Add quirks for initial > > lid state > > notification > > > > On Wed, 2016-06-01 at 18:10 +0800, Lv Zheng wrote: > > > Linux userspace (systemd-logind) keeps on rechecking lid state > > > when the > > > lid state is closed. If it failed to update the lid state to open > > > after > > > boot/resume, the system suspending right after the boot/resume > > > could > > be > > > resulted. > > > Graphics drivers also uses the lid notifications to implment > > > MODESET_ON_LID_OPEN option. > > > > "implement" > [Lv Zheng] > Thanks for pointing out, I'll send an UPDATE to this. > > > > > > Before the situation is improved from the userspace and from the > > graphics > > > driver, users can simply configure ACPI button driver to send > > > initial > > > "open" lid state using button.lid_init_state=open to avoid such > > > kind of > > > issues. And our ultimate target should be making > > > button.lid_init_state=ignore the default behavior. This patch > > > implements > > > the 2 options and keep the old behavior > > > (button.lid_init_state=method). > > > > I still don't think it's reasonable to expect any changes in user- > > space > > unless you start documenting what the API to user-space actually > > is. > [Lv Zheng] > IMO, the ACPI lid driver should be responsible for sending lid key > event (especially "close") to the user space. > So if someone need to implement an ACPI lid key event quirk, we could > help to implement it from the kernel space. > And since the initial lid state is not stable, we have to stop doing > quirks around it inside of the Linux kernel, or inside of the > customized AML tables. > User space can still access /proc/acpi/button/lid/LID0/state, but > should stop thinking that it is reliable. > > These are what I can conclude from the bugs. There's still no documentation for user-space in the patch, and no way to disable the "legacy" support (disabling access to the cached LID state, especially through the input layer which is what logind and upower use). You can't expect user-space to change in major ways for those few devices if the API doesn't force them to, through deprecation notices and documentation. Cheers -- 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 Thu, Jun 2, 2016 at 4:01 PM, Bastien Nocera <hadess@hadess.net> wrote: > On Thu, 2016-06-02 at 01:08 +0000, Zheng, Lv wrote: >> Hi, >> >> > From: Bastien Nocera [mailto:hadess@hadess.net] >> > Subject: Re: [PATCH v3 3/3] ACPI / button: Add quirks for initial >> > lid state >> > notification >> > >> > On Wed, 2016-06-01 at 18:10 +0800, Lv Zheng wrote: >> > > Linux userspace (systemd-logind) keeps on rechecking lid state >> > > when the >> > > lid state is closed. If it failed to update the lid state to open >> > > after >> > > boot/resume, the system suspending right after the boot/resume >> > > could >> > be >> > > resulted. >> > > Graphics drivers also uses the lid notifications to implment >> > > MODESET_ON_LID_OPEN option. >> > >> > "implement" >> [Lv Zheng] >> Thanks for pointing out, I'll send an UPDATE to this. >> >> > >> > > Before the situation is improved from the userspace and from the >> > graphics >> > > driver, users can simply configure ACPI button driver to send >> > > initial >> > > "open" lid state using button.lid_init_state=open to avoid such >> > > kind of >> > > issues. And our ultimate target should be making >> > > button.lid_init_state=ignore the default behavior. This patch >> > > implements >> > > the 2 options and keep the old behavior >> > > (button.lid_init_state=method). >> > >> > I still don't think it's reasonable to expect any changes in user- >> > space >> > unless you start documenting what the API to user-space actually >> > is. >> [Lv Zheng] >> IMO, the ACPI lid driver should be responsible for sending lid key >> event (especially "close") to the user space. >> So if someone need to implement an ACPI lid key event quirk, we could >> help to implement it from the kernel space. >> And since the initial lid state is not stable, we have to stop doing >> quirks around it inside of the Linux kernel, or inside of the >> customized AML tables. >> User space can still access /proc/acpi/button/lid/LID0/state, but >> should stop thinking that it is reliable. >> >> These are what I can conclude from the bugs. After further thoughts, I also think it is a bad idea to request user space to change behavior with respect to the LID switch event we forward from the keyboard: - it looks like Windows doesn't care about LID open on some (entry-level) platforms: the Samsung N210 is one of the first netbooks from 2010. The Surface (pro or not) are tablets. On these low cost systems, we can easily assume that the user needs to have the LID open to have the system working. You can't connect a docking station, and they are probably not used in a professional environment. - for the high end machines (think professional), we actually need to have a valid LID state given that the machines can be used on a docking station, so LID closed. If we do not send a reliable LID state for those laptops we will break user space and more likely annoy users: we might light up the closed internal monitor and migrate all the currently open applications to this screen. So I think Windows might be able to detect those 2 categories of environments and behave accordingly. Then, if we want to express to user space that the LID switch state is not reliable, we should stop setting it up as an input device with a EV_SWITCH in it. The kernel has to be reliable, and we can't start saying that this particular switch in a system might not be reliable. In this, I join Bastien's point of view where we need to start deprecating and document what needs to be done, and introduce a new way of reporting the LID events to user space (by using a KEY_LID_CLOSE for instance). I still think this patch is necessary. Until we manage to understand what is going on on Windows for the non reliable LID state, we can always ask users to use the button.lid_init_state=open to prevent the freeze loops they are seeing. The deprecation process could be to send the open state at resume on the SW_LID event, and send both the close and a KEY_LID_CLOSE event on close (no KEY_* on open). For professional laptops (with docking capability), I can't see how we could avoid forwarding a reliable state, and we need them to stick to button.lid_init_state=method (keep SW_LID and not send the KEY_LID_CLOSE event so userspace knows it's reliable). Hope this helps, Benjamin > > There's still no documentation for user-space in the patch, and no way > to disable the "legacy" support (disabling access to the cached LID > state, especially through the input layer which is what logind and > upower use). > > You can't expect user-space to change in major ways for those few > devices if the API doesn't force them to, through deprecation notices > and documentation. > > Cheers -- 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
SGksDQoNCj4gRnJvbTogQmVuamFtaW4gVGlzc29pcmVzIFttYWlsdG86YmVuamFtaW4udGlzc29p cmVzQGdtYWlsLmNvbV0NCj4gU3ViamVjdDogUmU6IFtQQVRDSCB2MyAzLzNdIEFDUEkgLyBidXR0 b246IEFkZCBxdWlya3MgZm9yIGluaXRpYWwgbGlkIHN0YXRlDQo+IG5vdGlmaWNhdGlvbg0KPiAN Cj4gT24gVGh1LCBKdW4gMiwgMjAxNiBhdCA0OjAxIFBNLCBCYXN0aWVuIE5vY2VyYSA8aGFkZXNz QGhhZGVzcy5uZXQ+DQo+IHdyb3RlOg0KPiA+IE9uIFRodSwgMjAxNi0wNi0wMiBhdCAwMTowOCAr MDAwMCwgWmhlbmcsIEx2IHdyb3RlOg0KPiA+PiBIaSwNCj4gPj4NCj4gPj4gPiBGcm9tOiBCYXN0 aWVuIE5vY2VyYSBbbWFpbHRvOmhhZGVzc0BoYWRlc3MubmV0XQ0KPiA+PiA+IFN1YmplY3Q6IFJl OiBbUEFUQ0ggdjMgMy8zXSBBQ1BJIC8gYnV0dG9uOiBBZGQgcXVpcmtzIGZvciBpbml0aWFsDQo+ ID4+ID4gbGlkIHN0YXRlDQo+ID4+ID4gbm90aWZpY2F0aW9uDQo+ID4+ID4NCj4gPj4gPiBPbiBX ZWQsIDIwMTYtMDYtMDEgYXQgMTg6MTAgKzA4MDAsIEx2IFpoZW5nIHdyb3RlOg0KPiA+PiA+ID4g TGludXggdXNlcnNwYWNlIChzeXN0ZW1kLWxvZ2luZCkga2VlcHMgb24gcmVjaGVja2luZyBsaWQg c3RhdGUNCj4gPj4gPiA+IHdoZW4gdGhlDQo+ID4+ID4gPiBsaWQgc3RhdGUgaXMgY2xvc2VkLiBJ ZiBpdCBmYWlsZWQgdG8gdXBkYXRlIHRoZSBsaWQgc3RhdGUgdG8gb3Blbg0KPiA+PiA+ID4gYWZ0 ZXINCj4gPj4gPiA+IGJvb3QvcmVzdW1lLCB0aGUgc3lzdGVtIHN1c3BlbmRpbmcgcmlnaHQgYWZ0 ZXIgdGhlIGJvb3QvcmVzdW1lDQo+ID4+ID4gPiBjb3VsZA0KPiA+PiA+IGJlDQo+ID4+ID4gPiBy ZXN1bHRlZC4NCj4gPj4gPiA+IEdyYXBoaWNzIGRyaXZlcnMgYWxzbyB1c2VzIHRoZSBsaWQgbm90 aWZpY2F0aW9ucyB0byBpbXBsbWVudA0KPiA+PiA+ID4gTU9ERVNFVF9PTl9MSURfT1BFTiBvcHRp b24uDQo+ID4+ID4NCj4gPj4gPiAiaW1wbGVtZW50Ig0KPiA+PiBbTHYgWmhlbmddDQo+ID4+IFRo YW5rcyBmb3IgcG9pbnRpbmcgb3V0LCBJJ2xsIHNlbmQgYW4gVVBEQVRFIHRvIHRoaXMuDQo+ID4+ DQo+ID4+ID4NCj4gPj4gPiA+IEJlZm9yZSB0aGUgc2l0dWF0aW9uIGlzIGltcHJvdmVkIGZyb20g dGhlIHVzZXJzcGFjZSBhbmQgZnJvbSB0aGUNCj4gPj4gPiBncmFwaGljcw0KPiA+PiA+ID4gZHJp dmVyLCB1c2VycyBjYW4gc2ltcGx5IGNvbmZpZ3VyZSBBQ1BJIGJ1dHRvbiBkcml2ZXIgdG8gc2Vu ZA0KPiA+PiA+ID4gaW5pdGlhbA0KPiA+PiA+ID4gIm9wZW4iIGxpZCBzdGF0ZSB1c2luZyBidXR0 b24ubGlkX2luaXRfc3RhdGU9b3BlbiB0byBhdm9pZCBzdWNoDQo+ID4+ID4gPiBraW5kIG9mDQo+ ID4+ID4gPiBpc3N1ZXMuIEFuZCBvdXIgdWx0aW1hdGUgdGFyZ2V0IHNob3VsZCBiZSBtYWtpbmcN Cj4gPj4gPiA+IGJ1dHRvbi5saWRfaW5pdF9zdGF0ZT1pZ25vcmUgdGhlIGRlZmF1bHQgYmVoYXZp b3IuIFRoaXMgcGF0Y2gNCj4gPj4gPiA+IGltcGxlbWVudHMNCj4gPj4gPiA+IHRoZSAyIG9wdGlv bnMgYW5kIGtlZXAgdGhlIG9sZCBiZWhhdmlvcg0KPiA+PiA+ID4gKGJ1dHRvbi5saWRfaW5pdF9z dGF0ZT1tZXRob2QpLg0KPiA+PiA+DQo+ID4+ID4gSSBzdGlsbCBkb24ndCB0aGluayBpdCdzIHJl YXNvbmFibGUgdG8gZXhwZWN0IGFueSBjaGFuZ2VzIGluIHVzZXItDQo+ID4+ID4gc3BhY2UNCj4g Pj4gPiB1bmxlc3MgeW91IHN0YXJ0IGRvY3VtZW50aW5nIHdoYXQgdGhlIEFQSSB0byB1c2VyLXNw YWNlIGFjdHVhbGx5DQo+ID4+ID4gaXMuDQo+ID4+IFtMdiBaaGVuZ10NCj4gPj4gSU1PLCB0aGUg QUNQSSBsaWQgZHJpdmVyIHNob3VsZCBiZSByZXNwb25zaWJsZSBmb3Igc2VuZGluZyBsaWQga2V5 DQo+ID4+IGV2ZW50IChlc3BlY2lhbGx5ICJjbG9zZSIpIHRvIHRoZSB1c2VyIHNwYWNlLg0KPiA+ PiBTbyBpZiBzb21lb25lIG5lZWQgdG8gaW1wbGVtZW50IGFuIEFDUEkgbGlkIGtleSBldmVudCBx dWlyaywgd2UgY291bGQNCj4gPj4gaGVscCB0byBpbXBsZW1lbnQgaXQgZnJvbSB0aGUga2VybmVs IHNwYWNlLg0KPiA+PiBBbmQgc2luY2UgdGhlIGluaXRpYWwgbGlkIHN0YXRlIGlzIG5vdCBzdGFi bGUsIHdlIGhhdmUgdG8gc3RvcCBkb2luZw0KPiA+PiBxdWlya3MgYXJvdW5kIGl0IGluc2lkZSBv ZiB0aGUgTGludXgga2VybmVsLCBvciBpbnNpZGUgb2YgdGhlDQo+ID4+IGN1c3RvbWl6ZWQgQU1M IHRhYmxlcy4NCj4gPj4gVXNlciBzcGFjZSBjYW4gc3RpbGwgYWNjZXNzIC9wcm9jL2FjcGkvYnV0 dG9uL2xpZC9MSUQwL3N0YXRlLCBidXQNCj4gPj4gc2hvdWxkIHN0b3AgdGhpbmtpbmcgdGhhdCBp dCBpcyByZWxpYWJsZS4NCj4gPj4NCj4gPj4gVGhlc2UgYXJlIHdoYXQgSSBjYW4gY29uY2x1ZGUg ZnJvbSB0aGUgYnVncy4NCj4gDQo+IEFmdGVyIGZ1cnRoZXIgdGhvdWdodHMsIEkgYWxzbyB0aGlu ayBpdCBpcyBhIGJhZCBpZGVhIHRvIHJlcXVlc3QgdXNlcg0KPiBzcGFjZSB0byBjaGFuZ2UgYmVo YXZpb3Igd2l0aCByZXNwZWN0IHRvIHRoZSBMSUQgc3dpdGNoIGV2ZW50IHdlDQo+IGZvcndhcmQg ZnJvbSB0aGUga2V5Ym9hcmQ6DQo+IC0gaXQgbG9va3MgbGlrZSBXaW5kb3dzIGRvZXNuJ3QgY2Fy ZSBhYm91dCBMSUQgb3BlbiBvbiBzb21lDQo+IChlbnRyeS1sZXZlbCkgcGxhdGZvcm1zOiB0aGUg U2Ftc3VuZyBOMjEwIGlzIG9uZSBvZiB0aGUgZmlyc3QgbmV0Ym9va3MNCj4gZnJvbSAyMDEwLiBU aGUgU3VyZmFjZSAocHJvIG9yIG5vdCkgYXJlIHRhYmxldHMuIE9uIHRoZXNlIGxvdyBjb3N0DQo+ IHN5c3RlbXMsIHdlIGNhbiBlYXNpbHkgYXNzdW1lIHRoYXQgdGhlIHVzZXIgbmVlZHMgdG8gaGF2 ZSB0aGUgTElEIG9wZW4NCj4gdG8gaGF2ZSB0aGUgc3lzdGVtIHdvcmtpbmcuIFlvdSBjYW4ndCBj b25uZWN0IGEgZG9ja2luZyBzdGF0aW9uLCBhbmQNCj4gdGhleSBhcmUgcHJvYmFibHkgbm90IHVz ZWQgaW4gYSBwcm9mZXNzaW9uYWwgZW52aXJvbm1lbnQuDQo+IC0gZm9yIHRoZSBoaWdoIGVuZCBt YWNoaW5lcyAodGhpbmsgcHJvZmVzc2lvbmFsKSwgd2UgYWN0dWFsbHkgbmVlZCB0bw0KPiBoYXZl IGEgdmFsaWQgTElEIHN0YXRlIGdpdmVuIHRoYXQgdGhlIG1hY2hpbmVzIGNhbiBiZSB1c2VkIG9u IGENCj4gZG9ja2luZyBzdGF0aW9uLCBzbyBMSUQgY2xvc2VkLiBJZiB3ZSBkbyBub3Qgc2VuZCBh IHJlbGlhYmxlIExJRCBzdGF0ZQ0KPiBmb3IgdGhvc2UgbGFwdG9wcyB3ZSB3aWxsIGJyZWFrIHVz ZXIgc3BhY2UgYW5kIG1vcmUgbGlrZWx5IGFubm95DQo+IHVzZXJzOiB3ZSBtaWdodCBsaWdodCB1 cCB0aGUgY2xvc2VkIGludGVybmFsIG1vbml0b3IgYW5kIG1pZ3JhdGUgYWxsDQo+IHRoZSBjdXJy ZW50bHkgb3BlbiBhcHBsaWNhdGlvbnMgdG8gdGhpcyBzY3JlZW4uDQo+IA0KPiBTbyBJIHRoaW5r IFdpbmRvd3MgbWlnaHQgYmUgYWJsZSB0byBkZXRlY3QgdGhvc2UgMiBjYXRlZ29yaWVzIG9mDQo+ IGVudmlyb25tZW50cyBhbmQgYmVoYXZlIGFjY29yZGluZ2x5Lg0KPiANCj4gVGhlbiwgaWYgd2Ug d2FudCB0byBleHByZXNzIHRvIHVzZXIgc3BhY2UgdGhhdCB0aGUgTElEIHN3aXRjaCBzdGF0ZSBp cw0KPiBub3QgcmVsaWFibGUsIHdlIHNob3VsZCBzdG9wIHNldHRpbmcgaXQgdXAgYXMgYW4gaW5w dXQgZGV2aWNlIHdpdGggYQ0KPiBFVl9TV0lUQ0ggaW4gaXQuIFRoZSBrZXJuZWwgaGFzIHRvIGJl IHJlbGlhYmxlLCBhbmQgd2UgY2FuJ3Qgc3RhcnQNCj4gc2F5aW5nIHRoYXQgdGhpcyBwYXJ0aWN1 bGFyIHN3aXRjaCBpbiBhIHN5c3RlbSBtaWdodCBub3QgYmUgcmVsaWFibGUuDQo+IEluIHRoaXMs IEkgam9pbiBCYXN0aWVuJ3MgcG9pbnQgb2YgdmlldyB3aGVyZSB3ZSBuZWVkIHRvIHN0YXJ0DQo+ IGRlcHJlY2F0aW5nIGFuZCBkb2N1bWVudCB3aGF0IG5lZWRzIHRvIGJlIGRvbmUsIGFuZCBpbnRy b2R1Y2UgYSBuZXcNCj4gd2F5IG9mIHJlcG9ydGluZyB0aGUgTElEIGV2ZW50cyB0byB1c2VyIHNw YWNlIChieSB1c2luZyBhDQo+IEtFWV9MSURfQ0xPU0UgZm9yIGluc3RhbmNlKS4NCj4gDQo+IEkg c3RpbGwgdGhpbmsgdGhpcyBwYXRjaCBpcyBuZWNlc3NhcnkuIFVudGlsIHdlIG1hbmFnZSB0byB1 bmRlcnN0YW5kDQo+IHdoYXQgaXMgZ29pbmcgb24gb24gV2luZG93cyBmb3IgdGhlIG5vbiByZWxp YWJsZSBMSUQgc3RhdGUsIHdlIGNhbg0KPiBhbHdheXMgYXNrIHVzZXJzIHRvIHVzZSB0aGUgYnV0 dG9uLmxpZF9pbml0X3N0YXRlPW9wZW4gdG8gcHJldmVudCB0aGUNCj4gZnJlZXplIGxvb3BzIHRo ZXkgYXJlIHNlZWluZy4NCj4gVGhlIGRlcHJlY2F0aW9uIHByb2Nlc3MgY291bGQgYmUgdG8gc2Vu ZCB0aGUgb3BlbiBzdGF0ZSBhdCByZXN1bWUgb24NCj4gdGhlIFNXX0xJRCBldmVudCwgYW5kIHNl bmQgYm90aCB0aGUgY2xvc2UgYW5kIGEgS0VZX0xJRF9DTE9TRSBldmVudCBvbg0KPiBjbG9zZSAo bm8gS0VZXyogb24gb3BlbikuDQo+IA0KPiBGb3IgcHJvZmVzc2lvbmFsIGxhcHRvcHMgKHdpdGgg ZG9ja2luZyBjYXBhYmlsaXR5KSwgSSBjYW4ndCBzZWUgaG93IHdlDQo+IGNvdWxkIGF2b2lkIGZv cndhcmRpbmcgYSByZWxpYWJsZSBzdGF0ZSwgYW5kIHdlIG5lZWQgdGhlbSB0byBzdGljayB0bw0K PiBidXR0b24ubGlkX2luaXRfc3RhdGU9bWV0aG9kIChrZWVwIFNXX0xJRCBhbmQgbm90IHNlbmQg dGhlDQo+IEtFWV9MSURfQ0xPU0UgZXZlbnQgc28gdXNlcnNwYWNlIGtub3dzIGl0J3MgcmVsaWFi bGUpLg0KW0x2IFpoZW5nXSANCkFsbCBzb3VuZCByZWFzb25hYmxlIHRvIG1lLg0KV2UnbGwgZGlz Y3VzcyB0aGlzIGludGVybmFsbHkgYmVmb3JlIG1ha2luZyBmdXJ0aGVyIGNoYW5nZXMuDQoNCkZv ciB0aGUgZG9jdW1lbnRhdGlvbiB3b3JrLg0KSSdtIHBsYW5uaW5nIHRvIHNlbmQgc2V2ZXJhbCBk b2N1bWVudHMgYXJvdW5kIEFDUElDQSByZWxlYXNlLCBBQ1BJQ0EgZGVidWdnZXIsIGFuZCBwcm9i aW5nIGRlLWZhY3RvIHN0YW5kYXJkIEFDUEkgYmVoYXZpb3IuDQpTbyBJIGNhbiBoZWxwIHRvIGFk ZCBvbmUgZm9yICJBQ1BJIGNvbnRyb2wgbWV0aG9kIGxpZCBkZXZpY2UiIHRvIGNsYXJpZnkgdGhp cyBpbiB0aGUgc2FtZSBzZXJpZXMuDQoNClRoYW5rcyBhbmQgYmVzdCByZWdhcmRzDQotTHYNCg0K PiANCj4gSG9wZSB0aGlzIGhlbHBzLA0KPiBCZW5qYW1pbg0KPiANCj4gDQo+ID4NCj4gPiBUaGVy ZSdzIHN0aWxsIG5vIGRvY3VtZW50YXRpb24gZm9yIHVzZXItc3BhY2UgaW4gdGhlIHBhdGNoLCBh bmQgbm8gd2F5DQo+ID4gdG8gZGlzYWJsZSB0aGUgImxlZ2FjeSIgc3VwcG9ydCAoZGlzYWJsaW5n IGFjY2VzcyB0byB0aGUgY2FjaGVkIExJRA0KPiA+IHN0YXRlLCBlc3BlY2lhbGx5IHRocm91Z2gg dGhlIGlucHV0IGxheWVyIHdoaWNoIGlzIHdoYXQgbG9naW5kIGFuZA0KPiA+IHVwb3dlciB1c2Up Lg0KPiA+DQo+ID4gWW91IGNhbid0IGV4cGVjdCB1c2VyLXNwYWNlIHRvIGNoYW5nZSBpbiBtYWpv ciB3YXlzIGZvciB0aG9zZSBmZXcNCj4gPiBkZXZpY2VzIGlmIHRoZSBBUEkgZG9lc24ndCBmb3Jj ZSB0aGVtIHRvLCB0aHJvdWdoIGRlcHJlY2F0aW9uIG5vdGljZXMNCj4gPiBhbmQgZG9jdW1lbnRh dGlvbi4NCj4gPg0KPiA+IENoZWVycw0K -- 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/drivers/acpi/button.c b/drivers/acpi/button.c index 6e291c1..148f4e5 100644 --- a/drivers/acpi/button.c +++ b/drivers/acpi/button.c @@ -53,6 +53,10 @@ #define ACPI_BUTTON_DEVICE_NAME_LID "Lid Switch" #define ACPI_BUTTON_TYPE_LID 0x05 +#define ACPI_BUTTON_LID_INIT_IGNORE 0x00 +#define ACPI_BUTTON_LID_INIT_OPEN 0x01 +#define ACPI_BUTTON_LID_INIT_METHOD 0x02 + #define _COMPONENT ACPI_BUTTON_COMPONENT ACPI_MODULE_NAME("button"); @@ -105,6 +109,7 @@ struct acpi_button { static BLOCKING_NOTIFIER_HEAD(acpi_lid_notifier); static struct acpi_device *lid_device; +static u8 lid_init_state = ACPI_BUTTON_LID_INIT_METHOD; /* -------------------------------------------------------------------------- FS Interface (/proc) @@ -285,6 +290,21 @@ static int acpi_lid_update_state(struct acpi_device *device) return acpi_lid_notify_state(device, state); } +static void acpi_lid_initialize_state(struct acpi_device *device) +{ + switch (lid_init_state) { + case ACPI_BUTTON_LID_INIT_OPEN: + (void)acpi_lid_notify_state(device, 1); + break; + case ACPI_BUTTON_LID_INIT_METHOD: + (void)acpi_lid_update_state(device); + break; + case ACPI_BUTTON_LID_INIT_IGNORE: + default: + break; + } +} + static void acpi_button_notify(struct acpi_device *device, u32 event) { struct acpi_button *button = acpi_driver_data(device); @@ -341,6 +361,8 @@ static int acpi_button_resume(struct device *dev) struct acpi_button *button = acpi_driver_data(device); button->suspended = false; + if (button->type == ACPI_BUTTON_TYPE_LID) + acpi_lid_initialize_state(device); return 0; } #endif @@ -421,6 +443,7 @@ static int acpi_button_add(struct acpi_device *device) if (error) goto err_remove_fs; if (button->type == ACPI_BUTTON_TYPE_LID) { + acpi_lid_initialize_state(device); /* * This assumes there's only one lid device, or if there are * more we only care about the last one... @@ -450,4 +473,42 @@ static int acpi_button_remove(struct acpi_device *device) return 0; } +static int param_set_lid_init_state(const char *val, struct kernel_param *kp) +{ + int result = 0; + + 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, "method", sizeof("method") - 1)) { + lid_init_state = ACPI_BUTTON_LID_INIT_METHOD; + pr_info("Notify initial lid state with _LID return value\n"); + } else if (!strncmp(val, "ignore", sizeof("ignore") - 1)) { + lid_init_state = ACPI_BUTTON_LID_INIT_IGNORE; + pr_info("Do not notify initial lid state\n"); + } else + result = -EINVAL; + return result; +} + +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_METHOD: + return sprintf(buffer, "method"); + case ACPI_BUTTON_LID_INIT_IGNORE: + return sprintf(buffer, "ignore"); + default: + return sprintf(buffer, "invalid"); + } + return 0; +} + +module_param_call(lid_init_state, + param_set_lid_init_state, param_get_lid_init_state, + NULL, 0644); +MODULE_PARM_DESC(lid_init_state, "Behavior for reporting LID initial state"); + module_acpi_driver(acpi_button_driver);
Linux userspace (systemd-logind) keeps on rechecking lid state when the lid state is closed. If it failed to update the lid state to open after boot/resume, the system suspending right after the boot/resume could be resulted. Graphics drivers also uses the lid notifications to implment MODESET_ON_LID_OPEN option. Before the situation is improved from the userspace and from the graphics driver, users can simply configure ACPI button driver to send initial "open" lid state using button.lid_init_state=open to avoid such kind of issues. And our ultimate target should be making button.lid_init_state=ignore the default behavior. This patch implements the 2 options and keep the old behavior (button.lid_init_state=method). Link 1: https://lkml.org/2016/3/7/460 Link 2: https://github.com/systemd/systemd/issues/2087 Signed-off-by: Lv Zheng <lv.zheng@intel.com> Cc: Bastien Nocera: <hadess@hadess.net> Cc: Benjamin Tissoires <benjamin.tissoires@gmail.com> --- drivers/acpi/button.c | 61 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+)