From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lv Zheng Subject: [RFC PATCH v6 1/5] ACPI: button: Add a workaround to fix an order issue for old userspace Date: Wed, 21 Jun 2017 16:55:03 +0800 Message-ID: <45932b46ea84bfbab2120092f23aff2c522a3945.1498034513.git.lv.zheng@intel.com> References: <2a779ae8c280c968b3237ac4a3d9580df7262a46.1493951798.git.lv.zheng@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: systemd-devel-bounces@lists.freedesktop.org Sender: "systemd-devel" To: "Rafael J . Wysocki" , "Rafael J . Wysocki" , Len Brown Cc: systemd-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, Lv Zheng , linux-acpi@vger.kernel.org, Benjamin Tissoires , Lv Zheng List-Id: linux-acpi@vger.kernel.org VGhlcmUgYXJlIHBsYXRmb3JtIHZhcmlhdGlvbnMgaW1wbGVtZW50aW5nIEFDUEkgbGlkIGRldmlj ZSBpbiBkaWZmZXJlbnQKd2F5czoKMS4gU29tZSBwbGF0Zm9ybXMgc2VuZCAib3BlbiIgZXZlbnRz IHRvIE9TIGFuZCB0aGUgZXZlbnRzIGFycml2ZSBiZWZvcmUKICAgYnV0dG9uIGRyaXZlciBpcyBy ZXN1bWVkOwoyLiBTb21lIHBsYXRmb3JtcyBzZW5kICJvcGVuIiBldmVudHMgdG8gT1MsIGJ1dCB0 aGUgZXZlbnRzIGFycml2ZSBhZnRlcgogICBidXR0b24gZHJpdmVyIGlzIHJlc3VtZWQsIGV4Liwg U2Ftc3VuZyBOMjEwKzsKMy4gU29tZSBwbGF0Zm9ybXMgbmV2ZXIgc2VuZCAib3BlbiIgZXZlbnRz IHRvIE9TLCBidXQgc2VuZCAib3BlbiIgZXZlbnRzIHRvCiAgIHVwZGF0ZSB0aGUgY2FjaGVkIF9M SUQgcmV0dXJuIHZhbHVlLCBhbmQgdGhlIHVwZGF0ZSBldmVudHMgYXJyaXZlIGJlZm9yZQogICBi dXR0b24gZHJpdmVyIGlzIHJlc3VtZWQ7CjQuIFNvbWUgcGxhdGZvcm1zIG5ldmVyIHNlbmQgIm9w ZW4iIGV2ZW50cyB0byBPUywgYnV0IHNlbmQgIm9wZW4iIGV2ZW50cyB0bwogICB1cGRhdGUgdGhl IGNhY2hlZCBfTElEIHJldHVybiB2YWx1ZSwgYnV0IHRoZSB1cGRhdGUgZXZlbnRzIGFycml2ZSBh ZnRlcgogICBidXR0b24gZHJpdmVyIGlzIHJlc3VtZWQsIGV4LiwgU3VyZmFjZSBQcm8gMzsKNS4g U29tZSBwbGF0Zm9ybXMgbmV2ZXIgc2VuZCAib3BlbiIgZXZlbnRzLCBfTElEIHJldHVybnMgdmFs dWUgc3RpY2tzIHRvCiAgICJjbG9zZSIsIGV4LiwgU3VyZmFjZSBQcm8gMS4KQ3VycmVudGx5LCBh bGwgY2FzZXMgd29yayBmaW5kIHdpdGggc3lzdGVtZCAyMzMsIGJ1dCBvbmx5IGNhc2UgMSB3b3Jr cyBmaW5lCndpdGggc3lzdGVtZCAyMjkuCgpDYXNlIDIsNCBjYW4gYmUgdHJlYXRlZCBhcyBhbiBv cmRlciBpc3N1ZToKICAgSWYgdGhlIGJ1dHRvbiBkcml2ZXIgYWx3YXlzIGV2YWx1YXRlcyBfTElE IGFmdGVyIHNlZWluZyBhIExJRAogICBub3RpZmljYXRpb24sIHRoZXJlIHNob3VsZG4ndCBiZSBz dWNoIGEgcHJvYmxlbS4KCk5vdGUgdGhhdCB0aGlzIG9yZGVyIGlzc3VlIGNhbm5vdCBiZSBmaXhl ZCBieSBzb3J0aW5nIE9TIGRyaXZlcnMnIHJlc3VtZQpjb2RlOgoxLiBXaGVuIGFjcGkuZWNfZnJl ZXplX2V2ZW50cz1ZLCB0aGUgb3JkZXIgZGVwZW5kcyBvbiB3aGV0aGVyIFBOUDBDMEQoTElEKQog ICBvciBQTlAwQzA5KEVDKSBhcHBlYXJzIGZpcnN0IGluIHRoZSBuYW1lc3BhY2UgKHByb2JlIG9y ZGVyKS4KMi4gRXZlbiB3aGVuIGFjcGkuZWNfZnJlZXplX2V2ZW50cz1OLCB3aGljaCBmb3JjZXMg T1MgdG8gaGFuZGxlIEVDIGV2ZW50cwogICBhcyBlYXJseSBhcyBwb3NzaWJsZSwgdGhlIG9yZGVy IGlzc3VlIGNhbiBzdGlsbCBiZSByZXByb2R1Y2VkIGR1ZSB0bwogICBwbGF0Zm9ybSBkZWxheXMg KHJlcHJvZHVjZSByYXRpbyBpcyBsb3dlciB0aGFuIGNhc2UgMSkuCjMuIFNvbWUgcGxhdGZvcm0g c2ltcGx5IGhhcyBhIHZlcnkgYmlnIGRlbGF5IGZvciBMSUQgb3BlbiBldmVudHMuCgpUaGlzIHBh dGNoIHRyaWVzIHRvIGZpeCB0aGlzIGlzc3VlIGZvciBzeXN0ZW1kIDIyOSBieSBkZWZlciBzZW5k aW5nIGluaXRpYWwKbGlkIHN0YXRlIDEwIHNlY29uZHMgbGF0ZXIgYWZ0ZXIgcmVzdW1lLCB3aGlj aCBlbnN1cmVzIEVDIGV2ZW50cyBjYW4gYWx3YXlzCmFycml2ZSBiZWZvcmUgYnV0dG9uIGRyaXZl ciBldmFsdWF0ZXMgX0xJRC4gSXQgZmluYWxseSBvbmx5IGZpeGVzIGNhc2UgMgpwbGF0Zm9ybXMg YXMgZml4aW5nIGNhc2UgNCBwbGF0Zm9ybXMgbmVlZHMgYWRkaXRpb25hbCBlZmZvcnRzIChzZWUg a25vd24KaXNzdWUgYmVsb3cpLgoKVGhlIHVzZXJzIGNhbiBjb25maWd1cmUgd2FpdCB0aW1lb3V0 IHZpYSBidXR0b24ubGlkX25vdGlmeV90aW1lb3V0LgoKS25vd24gaXNzdToKMS4gc3lzdGVtZC9s b2dpbmQgMjI5IHN0aWxsIG1pcy1iYWhhdmVzIHdpdGggY2FzZSAzLDQgcGxhdGZvcm1zCiAgIEFm dGVyIHNlZWluZyBhIExJRCAiY2xvc2UiIGV2ZW50LCBzeXN0ZW1kIDIyOSB3aWxsIHdhaXQgc2V2 ZXJhbCBzZWNvbmRzCiAgIChIb2xkb2ZmVGltZW91dFNlYykgYmVmb3JlIHN1c3BlbmRpbmcgdGhl IHBsYXRmb3JtLiBUaHVzIG9uIGNhc2UgNAogICBwbGF0Zm9ybXMsIGlmIHVzZXJzIGNsb3NlIGxp ZCwgYW5kIHJlLW9wZW4gaXQgZHVyaW5nIHRoZQogICBIb2xkb2ZmVGltZW91dFNlYyBwZXJpb2Qs IHRoZXJlIGlzIHN0aWxsIG5vICJvcGVuIiBldmVudHMgc2VlbiBieSB0aGUKICAgdXNlcnNwYWNl LiBUaHVzIHN5c3RlbWQgc3RpbGwgY29uc2lkZXJzIHRoZSBsYXN0IHN0YXRlIGFzICJjbG9zZSIg YW5kCiAgIHN1c3BlbmRzIHRoZSBwbGF0Zm9ybSBhZnRlciB0aGUgSG9sZG9mZlRpbWVvdXRTZWMg dGltZXMgb3V0LgoKQ2M6IDxzeXN0ZW1kLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZz4KQ2M6 IEJlbmphbWluIFRpc3NvaXJlcyA8YmVuamFtaW4udGlzc29pcmVzQHJlZGhhdC5jb20+CkNjOiBQ ZXRlciBIdXR0ZXJlciA8cGV0ZXIuaHV0dGVyZXJAd2hvLXQubmV0PgpTaWduZWQtb2ZmLWJ5OiBM diBaaGVuZyA8bHYuemhlbmdAaW50ZWwuY29tPgotLS0KIGRyaXZlcnMvYWNwaS9idXR0b24uYyB8 IDM2ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLQogMSBmaWxlIGNoYW5nZWQs IDM0IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9h Y3BpL2J1dHRvbi5jIGIvZHJpdmVycy9hY3BpL2J1dHRvbi5jCmluZGV4IGUxOWY1MzAuLjY3YTBk NzggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9idXR0b24uYworKysgYi9kcml2ZXJzL2FjcGkv YnV0dG9uLmMKQEAgLTI4LDYgKzI4LDcgQEAKICNpbmNsdWRlIDxsaW51eC9wcm9jX2ZzLmg+CiAj aW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KICNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgorI2lu Y2x1ZGUgPGxpbnV4L3RpbWVyLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUg PGxpbnV4L2FjcGkuaD4KICNpbmNsdWRlIDxhY3BpL2J1dHRvbi5oPgpAQCAtNzksNiArODAsNyBA QCBNT0RVTEVfREVWSUNFX1RBQkxFKGFjcGksIGJ1dHRvbl9kZXZpY2VfaWRzKTsKIHN0YXRpYyBp bnQgYWNwaV9idXR0b25fYWRkKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlKTsKIHN0YXRpYyBp bnQgYWNwaV9idXR0b25fcmVtb3ZlKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlKTsKIHN0YXRp YyB2b2lkIGFjcGlfYnV0dG9uX25vdGlmeShzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSwgdTMy IGV2ZW50KTsKK3N0YXRpYyB2b2lkIGFjcGlfbGlkX3RpbWVvdXQodWxvbmcgYXJnKTsKIAogI2lm ZGVmIENPTkZJR19QTV9TTEVFUAogc3RhdGljIGludCBhY3BpX2J1dHRvbl9zdXNwZW5kKHN0cnVj dCBkZXZpY2UgKmRldik7CkBAIC0xMDQsNiArMTA2LDcgQEAgc3RhdGljIHN0cnVjdCBhY3BpX2Ry aXZlciBhY3BpX2J1dHRvbl9kcml2ZXIgPSB7CiBzdHJ1Y3QgYWNwaV9idXR0b24gewogCXVuc2ln bmVkIGludCB0eXBlOwogCXN0cnVjdCBpbnB1dF9kZXYgKmlucHV0OworCXN0cnVjdCB0aW1lcl9s aXN0IGxpZF90aW1lcjsKIAljaGFyIHBoeXNbMzJdOwkJCS8qIGZvciBpbnB1dCBkZXZpY2UgKi8K IAl1bnNpZ25lZCBsb25nIHB1c2hlZDsKIAlpbnQgbGFzdF9zdGF0ZTsKQEAgLTExOSw2ICsxMjIs MTAgQEAgc3RhdGljIHVuc2lnbmVkIGxvbmcgbGlkX3JlcG9ydF9pbnRlcnZhbCBfX3JlYWRfbW9z dGx5ID0gNTAwOwogbW9kdWxlX3BhcmFtKGxpZF9yZXBvcnRfaW50ZXJ2YWwsIHVsb25nLCAwNjQ0 KTsKIE1PRFVMRV9QQVJNX0RFU0MobGlkX3JlcG9ydF9pbnRlcnZhbCwgIkludGVydmFsIChtcykg YmV0d2VlbiBsaWQga2V5IGV2ZW50cyIpOwogCitzdGF0aWMgdW5zaWduZWQgbG9uZyBsaWRfbm90 aWZ5X3RpbWVvdXQgX19yZWFkX21vc3RseSA9IDEwOworbW9kdWxlX3BhcmFtKGxpZF9ub3RpZnlf dGltZW91dCwgdWxvbmcsIDA2NDQpOworTU9EVUxFX1BBUk1fREVTQyhsaWRfbm90aWZ5X3RpbWVv dXQsICJUaW1lb3V0IChzKSBiZWZvcmUgcmVjZWl2aW5nIGxpZCBub3RpZmljYXRpb24iKTsKKwog LyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEZTIElu dGVyZmFjZSAoL3Byb2MpCiAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwpAQCAtMzcxLDYgKzM3OCwx NSBAQCBzdGF0aWMgaW50IGFjcGlfbGlkX3VwZGF0ZV9zdGF0ZShzdHJ1Y3QgYWNwaV9kZXZpY2Ug KmRldmljZSkKIAlyZXR1cm4gYWNwaV9saWRfbm90aWZ5X3N0YXRlKGRldmljZSwgc3RhdGUpOwog fQogCitzdGF0aWMgdm9pZCBhY3BpX2xpZF9zdGFydF90aW1lcihzdHJ1Y3QgYWNwaV9kZXZpY2Ug KmRldmljZSwKKwkJCQkgdW5zaWduZWQgbG9uZyBtc2VjcykKK3sKKwlzdHJ1Y3QgYWNwaV9idXR0 b24gKmJ1dHRvbiA9IGFjcGlfZHJpdmVyX2RhdGEoZGV2aWNlKTsKKworCW1vZF90aW1lcigmYnV0 dG9uLT5saWRfdGltZXIsCisJCSAgamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMobXNlY3MpKTsK K30KKwogc3RhdGljIHZvaWQgYWNwaV9saWRfaW5pdGlhbGl6ZV9zdGF0ZShzdHJ1Y3QgYWNwaV9k ZXZpY2UgKmRldmljZSkKIHsKIAlzd2l0Y2ggKGxpZF9pbml0X3N0YXRlKSB7CkBAIC0zODYsNiAr NDAyLDEzIEBAIHN0YXRpYyB2b2lkIGFjcGlfbGlkX2luaXRpYWxpemVfc3RhdGUoc3RydWN0IGFj cGlfZGV2aWNlICpkZXZpY2UpCiAJfQogfQogCitzdGF0aWMgdm9pZCBhY3BpX2xpZF90aW1lb3V0 KHVsb25nIGFyZykKK3sKKwlzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSA9IChzdHJ1Y3QgYWNw aV9kZXZpY2UgKilhcmc7CisKKwlhY3BpX2xpZF9pbml0aWFsaXplX3N0YXRlKGRldmljZSk7Cit9 CisKIHN0YXRpYyB2b2lkIGFjcGlfYnV0dG9uX25vdGlmeShzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRl dmljZSwgdTMyIGV2ZW50KQogewogCXN0cnVjdCBhY3BpX2J1dHRvbiAqYnV0dG9uID0gYWNwaV9k cml2ZXJfZGF0YShkZXZpY2UpOwpAQCAtNDMyLDYgKzQ1NSw4IEBAIHN0YXRpYyBpbnQgYWNwaV9i dXR0b25fc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCiAJc3RydWN0IGFjcGlfZGV2aWNlICpk ZXZpY2UgPSB0b19hY3BpX2RldmljZShkZXYpOwogCXN0cnVjdCBhY3BpX2J1dHRvbiAqYnV0dG9u ID0gYWNwaV9kcml2ZXJfZGF0YShkZXZpY2UpOwogCisJaWYgKGJ1dHRvbi0+dHlwZSA9PSBBQ1BJ X0JVVFRPTl9UWVBFX0xJRCkKKwkJZGVsX3RpbWVyKCZidXR0b24tPmxpZF90aW1lcik7CiAJYnV0 dG9uLT5zdXNwZW5kZWQgPSB0cnVlOwogCXJldHVybiAwOwogfQpAQCAtNDQzLDcgKzQ2OCw4IEBA IHN0YXRpYyBpbnQgYWNwaV9idXR0b25fcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRldikKIAogCWJ1 dHRvbi0+c3VzcGVuZGVkID0gZmFsc2U7CiAJaWYgKGJ1dHRvbi0+dHlwZSA9PSBBQ1BJX0JVVFRP Tl9UWVBFX0xJRCkKLQkJYWNwaV9saWRfaW5pdGlhbGl6ZV9zdGF0ZShkZXZpY2UpOworCQlhY3Bp X2xpZF9zdGFydF90aW1lcihkZXZpY2UsCisJCQlsaWRfbm90aWZ5X3RpbWVvdXQgKiBNU0VDX1BF Ul9TRUMpOwogCXJldHVybiAwOwogfQogI2VuZGlmCkBAIC00OTAsNiArNTE2LDkgQEAgc3RhdGlj IGludCBhY3BpX2J1dHRvbl9hZGQoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpCiAJCQlBQ1BJ X0JVVFRPTl9DTEFTUywgQUNQSV9CVVRUT05fU1VCQ0xBU1NfTElEKTsKIAkJYnV0dG9uLT5sYXN0 X3N0YXRlID0gISFhY3BpX2xpZF9ldmFsdWF0ZV9zdGF0ZShkZXZpY2UpOwogCQlidXR0b24tPmxh c3RfdGltZSA9IGt0aW1lX2dldCgpOworCQlpbml0X3RpbWVyKCZidXR0b24tPmxpZF90aW1lcik7 CisJCXNldHVwX3RpbWVyKCZidXR0b24tPmxpZF90aW1lciwKKwkJCSAgICBhY3BpX2xpZF90aW1l b3V0LCAodWxvbmcpZGV2aWNlKTsKIAl9IGVsc2UgewogCQlwcmludGsoS0VSTl9FUlIgUFJFRklY ICJVbnN1cHBvcnRlZCBoaWQgWyVzXVxuIiwgaGlkKTsKIAkJZXJyb3IgPSAtRU5PREVWOwpAQCAt NTI2LDEyICs1NTUsMTMgQEAgc3RhdGljIGludCBhY3BpX2J1dHRvbl9hZGQoc3RydWN0IGFjcGlf ZGV2aWNlICpkZXZpY2UpCiAJaWYgKGVycm9yKQogCQlnb3RvIGVycl9yZW1vdmVfZnM7CiAJaWYg KGJ1dHRvbi0+dHlwZSA9PSBBQ1BJX0JVVFRPTl9UWVBFX0xJRCkgewotCQlhY3BpX2xpZF9pbml0 aWFsaXplX3N0YXRlKGRldmljZSk7CiAJCS8qCiAJCSAqIFRoaXMgYXNzdW1lcyB0aGVyZSdzIG9u bHkgb25lIGxpZCBkZXZpY2UsIG9yIGlmIHRoZXJlIGFyZQogCQkgKiBtb3JlIHdlIG9ubHkgY2Fy ZSBhYm91dCB0aGUgbGFzdCBvbmUuLi4KIAkJICovCiAJCWxpZF9kZXZpY2UgPSBkZXZpY2U7CisJ CWFjcGlfbGlkX3N0YXJ0X3RpbWVyKGRldmljZSwKKwkJCWxpZF9ub3RpZnlfdGltZW91dCAqIE1T RUNfUEVSX1NFQyk7CiAJfQogCiAJcHJpbnRrKEtFUk5fSU5GTyBQUkVGSVggIiVzIFslc11cbiIs IG5hbWUsIGFjcGlfZGV2aWNlX2JpZChkZXZpY2UpKTsKQEAgLTU1MSw2ICs1ODEsOCBAQCBzdGF0 aWMgaW50IGFjcGlfYnV0dG9uX3JlbW92ZShzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSkKIAlz dHJ1Y3QgYWNwaV9idXR0b24gKmJ1dHRvbiA9IGFjcGlfZHJpdmVyX2RhdGEoZGV2aWNlKTsKIAog CWFjcGlfYnV0dG9uX3JlbW92ZV9mcyhkZXZpY2UpOworCWlmIChidXR0b24tPnR5cGUgPT0gQUNQ SV9CVVRUT05fVFlQRV9MSUQpCisJCWRlbF90aW1lcl9zeW5jKCZidXR0b24tPmxpZF90aW1lcik7 CiAJaW5wdXRfdW5yZWdpc3Rlcl9kZXZpY2UoYnV0dG9uLT5pbnB1dCk7CiAJa2ZyZWUoYnV0dG9u KTsKIAlyZXR1cm4gMDsKLS0gCjIuNy40CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpzeXN0ZW1kLWRldmVsIG1haWxpbmcgbGlzdApzeXN0ZW1kLWRldmVs QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWls bWFuL2xpc3RpbmZvL3N5c3RlbWQtZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752836AbdFUIzM (ORCPT ); Wed, 21 Jun 2017 04:55:12 -0400 Received: from mga07.intel.com ([134.134.136.100]:44101 "EHLO mga07.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752002AbdFUIzJ (ORCPT ); Wed, 21 Jun 2017 04:55:09 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.39,368,1493708400"; d="scan'208";a="1185172249" From: Lv Zheng To: "Rafael J . Wysocki" , "Rafael J . Wysocki" , Len Brown Cc: Lv Zheng , Lv Zheng , linux-kernel@vger.kernel.org, linux-acpi@vger.kernel.org, systemd-devel@lists.freedesktop.org, Benjamin Tissoires , Peter Hutterer Subject: [RFC PATCH v6 1/5] ACPI: button: Add a workaround to fix an order issue for old userspace Date: Wed, 21 Jun 2017 16:55:03 +0800 Message-Id: <45932b46ea84bfbab2120092f23aff2c522a3945.1498034513.git.lv.zheng@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: References: <2a779ae8c280c968b3237ac4a3d9580df7262a46.1493951798.git.lv.zheng@intel.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org There are platform variations implementing ACPI lid device in different ways: 1. Some platforms send "open" events to OS and the events arrive before button driver is resumed; 2. Some platforms send "open" events to OS, but the events arrive after button driver is resumed, ex., Samsung N210+; 3. Some platforms never send "open" events to OS, but send "open" events to update the cached _LID return value, and the update events arrive before button driver is resumed; 4. Some platforms never send "open" events to OS, but send "open" events to update the cached _LID return value, but the update events arrive after button driver is resumed, ex., Surface Pro 3; 5. Some platforms never send "open" events, _LID returns value sticks to "close", ex., Surface Pro 1. Currently, all cases work find with systemd 233, but only case 1 works fine with systemd 229. Case 2,4 can be treated as an order issue: If the button driver always evaluates _LID after seeing a LID notification, there shouldn't be such a problem. Note that this order issue cannot be fixed by sorting OS drivers' resume code: 1. When acpi.ec_freeze_events=Y, the order depends on whether PNP0C0D(LID) or PNP0C09(EC) appears first in the namespace (probe order). 2. Even when acpi.ec_freeze_events=N, which forces OS to handle EC events as early as possible, the order issue can still be reproduced due to platform delays (reproduce ratio is lower than case 1). 3. Some platform simply has a very big delay for LID open events. This patch tries to fix this issue for systemd 229 by defer sending initial lid state 10 seconds later after resume, which ensures EC events can always arrive before button driver evaluates _LID. It finally only fixes case 2 platforms as fixing case 4 platforms needs additional efforts (see known issue below). The users can configure wait timeout via button.lid_notify_timeout. Known issu: 1. systemd/logind 229 still mis-bahaves with case 3,4 platforms After seeing a LID "close" event, systemd 229 will wait several seconds (HoldoffTimeoutSec) before suspending the platform. Thus on case 4 platforms, if users close lid, and re-open it during the HoldoffTimeoutSec period, there is still no "open" events seen by the userspace. Thus systemd still considers the last state as "close" and suspends the platform after the HoldoffTimeoutSec times out. Cc: Cc: Benjamin Tissoires Cc: Peter Hutterer Signed-off-by: Lv Zheng --- drivers/acpi/button.c | 36 ++++++++++++++++++++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c index e19f530..67a0d78 100644 --- a/drivers/acpi/button.c +++ b/drivers/acpi/button.c @@ -28,6 +28,7 @@ #include #include #include +#include #include #include #include @@ -79,6 +80,7 @@ MODULE_DEVICE_TABLE(acpi, button_device_ids); static int acpi_button_add(struct acpi_device *device); static int acpi_button_remove(struct acpi_device *device); static void acpi_button_notify(struct acpi_device *device, u32 event); +static void acpi_lid_timeout(ulong arg); #ifdef CONFIG_PM_SLEEP static int acpi_button_suspend(struct device *dev); @@ -104,6 +106,7 @@ static struct acpi_driver acpi_button_driver = { struct acpi_button { unsigned int type; struct input_dev *input; + struct timer_list lid_timer; char phys[32]; /* for input device */ unsigned long pushed; int last_state; @@ -119,6 +122,10 @@ static unsigned long lid_report_interval __read_mostly = 500; module_param(lid_report_interval, ulong, 0644); MODULE_PARM_DESC(lid_report_interval, "Interval (ms) between lid key events"); +static unsigned long lid_notify_timeout __read_mostly = 10; +module_param(lid_notify_timeout, ulong, 0644); +MODULE_PARM_DESC(lid_notify_timeout, "Timeout (s) before receiving lid notification"); + /* -------------------------------------------------------------------------- FS Interface (/proc) -------------------------------------------------------------------------- */ @@ -371,6 +378,15 @@ static int acpi_lid_update_state(struct acpi_device *device) return acpi_lid_notify_state(device, state); } +static void acpi_lid_start_timer(struct acpi_device *device, + unsigned long msecs) +{ + struct acpi_button *button = acpi_driver_data(device); + + mod_timer(&button->lid_timer, + jiffies + msecs_to_jiffies(msecs)); +} + static void acpi_lid_initialize_state(struct acpi_device *device) { switch (lid_init_state) { @@ -386,6 +402,13 @@ static void acpi_lid_initialize_state(struct acpi_device *device) } } +static void acpi_lid_timeout(ulong arg) +{ + struct acpi_device *device = (struct acpi_device *)arg; + + acpi_lid_initialize_state(device); +} + static void acpi_button_notify(struct acpi_device *device, u32 event) { struct acpi_button *button = acpi_driver_data(device); @@ -432,6 +455,8 @@ static int acpi_button_suspend(struct device *dev) struct acpi_device *device = to_acpi_device(dev); struct acpi_button *button = acpi_driver_data(device); + if (button->type == ACPI_BUTTON_TYPE_LID) + del_timer(&button->lid_timer); button->suspended = true; return 0; } @@ -443,7 +468,8 @@ static int acpi_button_resume(struct device *dev) button->suspended = false; if (button->type == ACPI_BUTTON_TYPE_LID) - acpi_lid_initialize_state(device); + acpi_lid_start_timer(device, + lid_notify_timeout * MSEC_PER_SEC); return 0; } #endif @@ -490,6 +516,9 @@ static int acpi_button_add(struct acpi_device *device) ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID); button->last_state = !!acpi_lid_evaluate_state(device); button->last_time = ktime_get(); + init_timer(&button->lid_timer); + setup_timer(&button->lid_timer, + acpi_lid_timeout, (ulong)device); } else { printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid); error = -ENODEV; @@ -526,12 +555,13 @@ 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... */ lid_device = device; + acpi_lid_start_timer(device, + lid_notify_timeout * MSEC_PER_SEC); } printk(KERN_INFO PREFIX "%s [%s]\n", name, acpi_device_bid(device)); @@ -551,6 +581,8 @@ static int acpi_button_remove(struct acpi_device *device) struct acpi_button *button = acpi_driver_data(device); acpi_button_remove_fs(device); + if (button->type == ACPI_BUTTON_TYPE_LID) + del_timer_sync(&button->lid_timer); input_unregister_device(button->input); kfree(button); return 0; -- 2.7.4