From mboxrd@z Thu Jan 1 00:00:00 1970 From: Benjamin Tissoires Subject: Re: [RFC PATCH v6 1/5] ACPI: button: Add a workaround to fix an order issue for old userspace Date: Fri, 23 Jun 2017 16:02:48 +0200 Message-ID: <20170623140248.GO26073@mail.corp.redhat.com> References: <2a779ae8c280c968b3237ac4a3d9580df7262a46.1493951798.git.lv.zheng@intel.com> <45932b46ea84bfbab2120092f23aff2c522a3945.1498034513.git.lv.zheng@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <45932b46ea84bfbab2120092f23aff2c522a3945.1498034513.git.lv.zheng@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: systemd-devel-bounces@lists.freedesktop.org Sender: "systemd-devel" To: Lv Zheng Cc: Len Brown , systemd-devel@lists.freedesktop.org, "Rafael J . Wysocki" , "Rafael J . Wysocki" , linux-kernel@vger.kernel.org, Lv Zheng , linux-acpi@vger.kernel.org List-Id: linux-acpi@vger.kernel.org T24gSnVuIDIxIDIwMTcgb3IgdGhlcmVhYm91dHMsIEx2IFpoZW5nIHdyb3RlOgo+IFRoZXJlIGFy ZSBwbGF0Zm9ybSB2YXJpYXRpb25zIGltcGxlbWVudGluZyBBQ1BJIGxpZCBkZXZpY2UgaW4gZGlm ZmVyZW50Cj4gd2F5czoKPiAxLiBTb21lIHBsYXRmb3JtcyBzZW5kICJvcGVuIiBldmVudHMgdG8g T1MgYW5kIHRoZSBldmVudHMgYXJyaXZlIGJlZm9yZQo+ICAgIGJ1dHRvbiBkcml2ZXIgaXMgcmVz dW1lZDsKPiAyLiBTb21lIHBsYXRmb3JtcyBzZW5kICJvcGVuIiBldmVudHMgdG8gT1MsIGJ1dCB0 aGUgZXZlbnRzIGFycml2ZSBhZnRlcgo+ICAgIGJ1dHRvbiBkcml2ZXIgaXMgcmVzdW1lZCwgZXgu LCBTYW1zdW5nIE4yMTArOwo+IDMuIFNvbWUgcGxhdGZvcm1zIG5ldmVyIHNlbmQgIm9wZW4iIGV2 ZW50cyB0byBPUywgYnV0IHNlbmQgIm9wZW4iIGV2ZW50cyB0bwo+ICAgIHVwZGF0ZSB0aGUgY2Fj aGVkIF9MSUQgcmV0dXJuIHZhbHVlLCBhbmQgdGhlIHVwZGF0ZSBldmVudHMgYXJyaXZlIGJlZm9y ZQo+ICAgIGJ1dHRvbiBkcml2ZXIgaXMgcmVzdW1lZDsKPiA0LiBTb21lIHBsYXRmb3JtcyBuZXZl ciBzZW5kICJvcGVuIiBldmVudHMgdG8gT1MsIGJ1dCBzZW5kICJvcGVuIiBldmVudHMgdG8KPiAg ICB1cGRhdGUgdGhlIGNhY2hlZCBfTElEIHJldHVybiB2YWx1ZSwgYnV0IHRoZSB1cGRhdGUgZXZl bnRzIGFycml2ZSBhZnRlcgo+ICAgIGJ1dHRvbiBkcml2ZXIgaXMgcmVzdW1lZCwgZXguLCBTdXJm YWNlIFBybyAzOwo+IDUuIFNvbWUgcGxhdGZvcm1zIG5ldmVyIHNlbmQgIm9wZW4iIGV2ZW50cywg X0xJRCByZXR1cm5zIHZhbHVlIHN0aWNrcyB0bwo+ICAgICJjbG9zZSIsIGV4LiwgU3VyZmFjZSBQ cm8gMS4KPiBDdXJyZW50bHksIGFsbCBjYXNlcyB3b3JrIGZpbmQgd2l0aCBzeXN0ZW1kIDIzMywg YnV0IG9ubHkgY2FzZSAxIHdvcmtzIGZpbmUKPiB3aXRoIHN5c3RlbWQgMjI5Lgo+IAo+IENhc2Ug Miw0IGNhbiBiZSB0cmVhdGVkIGFzIGFuIG9yZGVyIGlzc3VlOgo+ICAgIElmIHRoZSBidXR0b24g ZHJpdmVyIGFsd2F5cyBldmFsdWF0ZXMgX0xJRCBhZnRlciBzZWVpbmcgYSBMSUQKPiAgICBub3Rp ZmljYXRpb24sIHRoZXJlIHNob3VsZG4ndCBiZSBzdWNoIGEgcHJvYmxlbS4KPiAKPiBOb3RlIHRo YXQgdGhpcyBvcmRlciBpc3N1ZSBjYW5ub3QgYmUgZml4ZWQgYnkgc29ydGluZyBPUyBkcml2ZXJz JyByZXN1bWUKPiBjb2RlOgo+IDEuIFdoZW4gYWNwaS5lY19mcmVlemVfZXZlbnRzPVksIHRoZSBv cmRlciBkZXBlbmRzIG9uIHdoZXRoZXIgUE5QMEMwRChMSUQpCj4gICAgb3IgUE5QMEMwOShFQykg YXBwZWFycyBmaXJzdCBpbiB0aGUgbmFtZXNwYWNlIChwcm9iZSBvcmRlcikuCj4gMi4gRXZlbiB3 aGVuIGFjcGkuZWNfZnJlZXplX2V2ZW50cz1OLCB3aGljaCBmb3JjZXMgT1MgdG8gaGFuZGxlIEVD IGV2ZW50cwo+ICAgIGFzIGVhcmx5IGFzIHBvc3NpYmxlLCB0aGUgb3JkZXIgaXNzdWUgY2FuIHN0 aWxsIGJlIHJlcHJvZHVjZWQgZHVlIHRvCj4gICAgcGxhdGZvcm0gZGVsYXlzIChyZXByb2R1Y2Ug cmF0aW8gaXMgbG93ZXIgdGhhbiBjYXNlIDEpLgo+IDMuIFNvbWUgcGxhdGZvcm0gc2ltcGx5IGhh cyBhIHZlcnkgYmlnIGRlbGF5IGZvciBMSUQgb3BlbiBldmVudHMuCj4gCj4gVGhpcyBwYXRjaCB0 cmllcyB0byBmaXggdGhpcyBpc3N1ZSBmb3Igc3lzdGVtZCAyMjkgYnkgZGVmZXIgc2VuZGluZyBp bml0aWFsCj4gbGlkIHN0YXRlIDEwIHNlY29uZHMgbGF0ZXIgYWZ0ZXIgcmVzdW1lLCB3aGljaCBl bnN1cmVzIEVDIGV2ZW50cyBjYW4gYWx3YXlzCj4gYXJyaXZlIGJlZm9yZSBidXR0b24gZHJpdmVy IGV2YWx1YXRlcyBfTElELiBJdCBmaW5hbGx5IG9ubHkgZml4ZXMgY2FzZSAyCj4gcGxhdGZvcm1z IGFzIGZpeGluZyBjYXNlIDQgcGxhdGZvcm1zIG5lZWRzIGFkZGl0aW9uYWwgZWZmb3J0cyAoc2Vl IGtub3duCj4gaXNzdWUgYmVsb3cpLgo+IAo+IFRoZSB1c2VycyBjYW4gY29uZmlndXJlIHdhaXQg dGltZW91dCB2aWEgYnV0dG9uLmxpZF9ub3RpZnlfdGltZW91dC4KPiAKPiBLbm93biBpc3N1Ogo+ IDEuIHN5c3RlbWQvbG9naW5kIDIyOSBzdGlsbCBtaXMtYmFoYXZlcyB3aXRoIGNhc2UgMyw0IHBs YXRmb3Jtcwo+ICAgIEFmdGVyIHNlZWluZyBhIExJRCAiY2xvc2UiIGV2ZW50LCBzeXN0ZW1kIDIy OSB3aWxsIHdhaXQgc2V2ZXJhbCBzZWNvbmRzCj4gICAgKEhvbGRvZmZUaW1lb3V0U2VjKSBiZWZv cmUgc3VzcGVuZGluZyB0aGUgcGxhdGZvcm0uIFRodXMgb24gY2FzZSA0Cj4gICAgcGxhdGZvcm1z LCBpZiB1c2VycyBjbG9zZSBsaWQsIGFuZCByZS1vcGVuIGl0IGR1cmluZyB0aGUKPiAgICBIb2xk b2ZmVGltZW91dFNlYyBwZXJpb2QsIHRoZXJlIGlzIHN0aWxsIG5vICJvcGVuIiBldmVudHMgc2Vl biBieSB0aGUKPiAgICB1c2Vyc3BhY2UuIFRodXMgc3lzdGVtZCBzdGlsbCBjb25zaWRlcnMgdGhl IGxhc3Qgc3RhdGUgYXMgImNsb3NlIiBhbmQKPiAgICBzdXNwZW5kcyB0aGUgcGxhdGZvcm0gYWZ0 ZXIgdGhlIEhvbGRvZmZUaW1lb3V0U2VjIHRpbWVzIG91dC4KPiAKPiBDYzogPHN5c3RlbWQtZGV2 ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnPgo+IENjOiBCZW5qYW1pbiBUaXNzb2lyZXMgPGJlbmph bWluLnRpc3NvaXJlc0ByZWRoYXQuY29tPgo+IENjOiBQZXRlciBIdXR0ZXJlciA8cGV0ZXIuaHV0 dGVyZXJAd2hvLXQubmV0Pgo+IFNpZ25lZC1vZmYtYnk6IEx2IFpoZW5nIDxsdi56aGVuZ0BpbnRl bC5jb20+Cj4gLS0tCgpOQUNLIG9uIHRoaXMgb25lIChhdCBsZWFzdCBpbiB0aGlzIGN1cnJlbnQg Zm9ybSk6IFlvdSBhcmUgcHJlc2VudGluZyBhCmRldmljZSB0byB1c2VyIHNwYWNlIHdpdGggYW4g dW5rbm93biBzdGF0ZS4KSWYgeW91IHdhbnQgdG8gZGVsYXkgdGhlIHF1ZXJ5IG9mIHRoZSBzdGF0 ZSwgeW91IGFsc28gbmVlZCB0byBkZWxheSB0aGUKY2FsbCBvZiBpbnB1dF9yZWdpc3Rlcl9kZXZp Y2UoKS4KCkNoZWVycywKQmVuamFtaW4KCj4gIGRyaXZlcnMvYWNwaS9idXR0b24uYyB8IDM2ICsr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLQo+ICAxIGZpbGUgY2hhbmdlZCwgMzQg aW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9h Y3BpL2J1dHRvbi5jIGIvZHJpdmVycy9hY3BpL2J1dHRvbi5jCj4gaW5kZXggZTE5ZjUzMC4uNjdh MGQ3OCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2FjcGkvYnV0dG9uLmMKPiArKysgYi9kcml2ZXJz L2FjcGkvYnV0dG9uLmMKPiBAQCAtMjgsNiArMjgsNyBAQAo+ICAjaW5jbHVkZSA8bGludXgvcHJv Y19mcy5oPgo+ICAjaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KPiAgI2luY2x1ZGUgPGxpbnV4 L2lucHV0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC90aW1lci5oPgo+ICAjaW5jbHVkZSA8bGludXgv c2xhYi5oPgo+ICAjaW5jbHVkZSA8bGludXgvYWNwaS5oPgo+ICAjaW5jbHVkZSA8YWNwaS9idXR0 b24uaD4KPiBAQCAtNzksNiArODAsNyBAQCBNT0RVTEVfREVWSUNFX1RBQkxFKGFjcGksIGJ1dHRv bl9kZXZpY2VfaWRzKTsKPiAgc3RhdGljIGludCBhY3BpX2J1dHRvbl9hZGQoc3RydWN0IGFjcGlf ZGV2aWNlICpkZXZpY2UpOwo+ICBzdGF0aWMgaW50IGFjcGlfYnV0dG9uX3JlbW92ZShzdHJ1Y3Qg YWNwaV9kZXZpY2UgKmRldmljZSk7Cj4gIHN0YXRpYyB2b2lkIGFjcGlfYnV0dG9uX25vdGlmeShz dHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSwgdTMyIGV2ZW50KTsKPiArc3RhdGljIHZvaWQgYWNw aV9saWRfdGltZW91dCh1bG9uZyBhcmcpOwo+ICAKPiAgI2lmZGVmIENPTkZJR19QTV9TTEVFUAo+ ICBzdGF0aWMgaW50IGFjcGlfYnV0dG9uX3N1c3BlbmQoc3RydWN0IGRldmljZSAqZGV2KTsKPiBA QCAtMTA0LDYgKzEwNiw3IEBAIHN0YXRpYyBzdHJ1Y3QgYWNwaV9kcml2ZXIgYWNwaV9idXR0b25f ZHJpdmVyID0gewo+ICBzdHJ1Y3QgYWNwaV9idXR0b24gewo+ICAJdW5zaWduZWQgaW50IHR5cGU7 Cj4gIAlzdHJ1Y3QgaW5wdXRfZGV2ICppbnB1dDsKPiArCXN0cnVjdCB0aW1lcl9saXN0IGxpZF90 aW1lcjsKPiAgCWNoYXIgcGh5c1szMl07CQkJLyogZm9yIGlucHV0IGRldmljZSAqLwo+ICAJdW5z aWduZWQgbG9uZyBwdXNoZWQ7Cj4gIAlpbnQgbGFzdF9zdGF0ZTsKPiBAQCAtMTE5LDYgKzEyMiwx MCBAQCBzdGF0aWMgdW5zaWduZWQgbG9uZyBsaWRfcmVwb3J0X2ludGVydmFsIF9fcmVhZF9tb3N0 bHkgPSA1MDA7Cj4gIG1vZHVsZV9wYXJhbShsaWRfcmVwb3J0X2ludGVydmFsLCB1bG9uZywgMDY0 NCk7Cj4gIE1PRFVMRV9QQVJNX0RFU0MobGlkX3JlcG9ydF9pbnRlcnZhbCwgIkludGVydmFsICht cykgYmV0d2VlbiBsaWQga2V5IGV2ZW50cyIpOwo+ICAKPiArc3RhdGljIHVuc2lnbmVkIGxvbmcg bGlkX25vdGlmeV90aW1lb3V0IF9fcmVhZF9tb3N0bHkgPSAxMDsKPiArbW9kdWxlX3BhcmFtKGxp ZF9ub3RpZnlfdGltZW91dCwgdWxvbmcsIDA2NDQpOwo+ICtNT0RVTEVfUEFSTV9ERVNDKGxpZF9u b3RpZnlfdGltZW91dCwgIlRpbWVvdXQgKHMpIGJlZm9yZSByZWNlaXZpbmcgbGlkIG5vdGlmaWNh dGlvbiIpOwo+ICsKPiAgLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgRlMgSW50ZXJmYWNlICgvcHJvYykKPiAgICAgLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0g Ki8KPiBAQCAtMzcxLDYgKzM3OCwxNSBAQCBzdGF0aWMgaW50IGFjcGlfbGlkX3VwZGF0ZV9zdGF0 ZShzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSkKPiAgCXJldHVybiBhY3BpX2xpZF9ub3RpZnlf c3RhdGUoZGV2aWNlLCBzdGF0ZSk7Cj4gIH0KPiAgCj4gK3N0YXRpYyB2b2lkIGFjcGlfbGlkX3N0 YXJ0X3RpbWVyKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlLAo+ICsJCQkJIHVuc2lnbmVkIGxv bmcgbXNlY3MpCj4gK3sKPiArCXN0cnVjdCBhY3BpX2J1dHRvbiAqYnV0dG9uID0gYWNwaV9kcml2 ZXJfZGF0YShkZXZpY2UpOwo+ICsKPiArCW1vZF90aW1lcigmYnV0dG9uLT5saWRfdGltZXIsCj4g KwkJICBqaWZmaWVzICsgbXNlY3NfdG9famlmZmllcyhtc2VjcykpOwo+ICt9Cj4gKwo+ICBzdGF0 aWMgdm9pZCBhY3BpX2xpZF9pbml0aWFsaXplX3N0YXRlKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2 aWNlKQo+ICB7Cj4gIAlzd2l0Y2ggKGxpZF9pbml0X3N0YXRlKSB7Cj4gQEAgLTM4Niw2ICs0MDIs MTMgQEAgc3RhdGljIHZvaWQgYWNwaV9saWRfaW5pdGlhbGl6ZV9zdGF0ZShzdHJ1Y3QgYWNwaV9k ZXZpY2UgKmRldmljZSkKPiAgCX0KPiAgfQo+ICAKPiArc3RhdGljIHZvaWQgYWNwaV9saWRfdGlt ZW91dCh1bG9uZyBhcmcpCj4gK3sKPiArCXN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlID0gKHN0 cnVjdCBhY3BpX2RldmljZSAqKWFyZzsKPiArCj4gKwlhY3BpX2xpZF9pbml0aWFsaXplX3N0YXRl KGRldmljZSk7Cj4gK30KPiArCj4gIHN0YXRpYyB2b2lkIGFjcGlfYnV0dG9uX25vdGlmeShzdHJ1 Y3QgYWNwaV9kZXZpY2UgKmRldmljZSwgdTMyIGV2ZW50KQo+ICB7Cj4gIAlzdHJ1Y3QgYWNwaV9i dXR0b24gKmJ1dHRvbiA9IGFjcGlfZHJpdmVyX2RhdGEoZGV2aWNlKTsKPiBAQCAtNDMyLDYgKzQ1 NSw4IEBAIHN0YXRpYyBpbnQgYWNwaV9idXR0b25fc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYp Cj4gIAlzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSA9IHRvX2FjcGlfZGV2aWNlKGRldik7Cj4g IAlzdHJ1Y3QgYWNwaV9idXR0b24gKmJ1dHRvbiA9IGFjcGlfZHJpdmVyX2RhdGEoZGV2aWNlKTsK PiAgCj4gKwlpZiAoYnV0dG9uLT50eXBlID09IEFDUElfQlVUVE9OX1RZUEVfTElEKQo+ICsJCWRl bF90aW1lcigmYnV0dG9uLT5saWRfdGltZXIpOwo+ICAJYnV0dG9uLT5zdXNwZW5kZWQgPSB0cnVl Owo+ICAJcmV0dXJuIDA7Cj4gIH0KPiBAQCAtNDQzLDcgKzQ2OCw4IEBAIHN0YXRpYyBpbnQgYWNw aV9idXR0b25fcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRldikKPiAgCj4gIAlidXR0b24tPnN1c3Bl bmRlZCA9IGZhbHNlOwo+ICAJaWYgKGJ1dHRvbi0+dHlwZSA9PSBBQ1BJX0JVVFRPTl9UWVBFX0xJ RCkKPiAtCQlhY3BpX2xpZF9pbml0aWFsaXplX3N0YXRlKGRldmljZSk7Cj4gKwkJYWNwaV9saWRf c3RhcnRfdGltZXIoZGV2aWNlLAo+ICsJCQlsaWRfbm90aWZ5X3RpbWVvdXQgKiBNU0VDX1BFUl9T RUMpOwo+ICAJcmV0dXJuIDA7Cj4gIH0KPiAgI2VuZGlmCj4gQEAgLTQ5MCw2ICs1MTYsOSBAQCBz dGF0aWMgaW50IGFjcGlfYnV0dG9uX2FkZChzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSkKPiAg CQkJQUNQSV9CVVRUT05fQ0xBU1MsIEFDUElfQlVUVE9OX1NVQkNMQVNTX0xJRCk7Cj4gIAkJYnV0 dG9uLT5sYXN0X3N0YXRlID0gISFhY3BpX2xpZF9ldmFsdWF0ZV9zdGF0ZShkZXZpY2UpOwo+ICAJ CWJ1dHRvbi0+bGFzdF90aW1lID0ga3RpbWVfZ2V0KCk7Cj4gKwkJaW5pdF90aW1lcigmYnV0dG9u LT5saWRfdGltZXIpOwo+ICsJCXNldHVwX3RpbWVyKCZidXR0b24tPmxpZF90aW1lciwKPiArCQkJ ICAgIGFjcGlfbGlkX3RpbWVvdXQsICh1bG9uZylkZXZpY2UpOwo+ICAJfSBlbHNlIHsKPiAgCQlw cmludGsoS0VSTl9FUlIgUFJFRklYICJVbnN1cHBvcnRlZCBoaWQgWyVzXVxuIiwgaGlkKTsKPiAg CQllcnJvciA9IC1FTk9ERVY7Cj4gQEAgLTUyNiwxMiArNTU1LDEzIEBAIHN0YXRpYyBpbnQgYWNw aV9idXR0b25fYWRkKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlKQo+ICAJaWYgKGVycm9yKQo+ ICAJCWdvdG8gZXJyX3JlbW92ZV9mczsKPiAgCWlmIChidXR0b24tPnR5cGUgPT0gQUNQSV9CVVRU T05fVFlQRV9MSUQpIHsKPiAtCQlhY3BpX2xpZF9pbml0aWFsaXplX3N0YXRlKGRldmljZSk7Cj4g IAkJLyoKPiAgCQkgKiBUaGlzIGFzc3VtZXMgdGhlcmUncyBvbmx5IG9uZSBsaWQgZGV2aWNlLCBv ciBpZiB0aGVyZSBhcmUKPiAgCQkgKiBtb3JlIHdlIG9ubHkgY2FyZSBhYm91dCB0aGUgbGFzdCBv bmUuLi4KPiAgCQkgKi8KPiAgCQlsaWRfZGV2aWNlID0gZGV2aWNlOwo+ICsJCWFjcGlfbGlkX3N0 YXJ0X3RpbWVyKGRldmljZSwKPiArCQkJbGlkX25vdGlmeV90aW1lb3V0ICogTVNFQ19QRVJfU0VD KTsKPiAgCX0KPiAgCj4gIAlwcmludGsoS0VSTl9JTkZPIFBSRUZJWCAiJXMgWyVzXVxuIiwgbmFt ZSwgYWNwaV9kZXZpY2VfYmlkKGRldmljZSkpOwo+IEBAIC01NTEsNiArNTgxLDggQEAgc3RhdGlj IGludCBhY3BpX2J1dHRvbl9yZW1vdmUoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpCj4gIAlz dHJ1Y3QgYWNwaV9idXR0b24gKmJ1dHRvbiA9IGFjcGlfZHJpdmVyX2RhdGEoZGV2aWNlKTsKPiAg Cj4gIAlhY3BpX2J1dHRvbl9yZW1vdmVfZnMoZGV2aWNlKTsKPiArCWlmIChidXR0b24tPnR5cGUg PT0gQUNQSV9CVVRUT05fVFlQRV9MSUQpCj4gKwkJZGVsX3RpbWVyX3N5bmMoJmJ1dHRvbi0+bGlk X3RpbWVyKTsKPiAgCWlucHV0X3VucmVnaXN0ZXJfZGV2aWNlKGJ1dHRvbi0+aW5wdXQpOwo+ICAJ a2ZyZWUoYnV0dG9uKTsKPiAgCXJldHVybiAwOwo+IC0tIAo+IDIuNy40Cj4gCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCnN5c3RlbWQtZGV2ZWwgbWFpbGlu ZyBsaXN0CnN5c3RlbWQtZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMu ZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vc3lzdGVtZC1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754174AbdFWOC5 (ORCPT ); Fri, 23 Jun 2017 10:02:57 -0400 Received: from mx1.redhat.com ([209.132.183.28]:39052 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751217AbdFWOCz (ORCPT ); Fri, 23 Jun 2017 10:02:55 -0400 DMARC-Filter: OpenDMARC Filter v1.3.2 mx1.redhat.com D4266C0587DB Authentication-Results: ext-mx08.extmail.prod.ext.phx2.redhat.com; dmarc=none (p=none dis=none) header.from=redhat.com Authentication-Results: ext-mx08.extmail.prod.ext.phx2.redhat.com; spf=pass smtp.mailfrom=benjamin.tissoires@redhat.com DKIM-Filter: OpenDKIM Filter v2.11.0 mx1.redhat.com D4266C0587DB Date: Fri, 23 Jun 2017 16:02:48 +0200 From: Benjamin Tissoires To: Lv Zheng Cc: "Rafael J . Wysocki" , "Rafael J . Wysocki" , Len Brown , Lv Zheng , linux-kernel@vger.kernel.org, linux-acpi@vger.kernel.org, systemd-devel@lists.freedesktop.org, Peter Hutterer Subject: Re: [RFC PATCH v6 1/5] ACPI: button: Add a workaround to fix an order issue for old userspace Message-ID: <20170623140248.GO26073@mail.corp.redhat.com> References: <2a779ae8c280c968b3237ac4a3d9580df7262a46.1493951798.git.lv.zheng@intel.com> <45932b46ea84bfbab2120092f23aff2c522a3945.1498034513.git.lv.zheng@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline In-Reply-To: <45932b46ea84bfbab2120092f23aff2c522a3945.1498034513.git.lv.zheng@intel.com> X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.32]); Fri, 23 Jun 2017 14:02:55 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Jun 21 2017 or thereabouts, Lv Zheng wrote: > 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 > --- NACK on this one (at least in this current form): You are presenting a device to user space with an unknown state. If you want to delay the query of the state, you also need to delay the call of input_register_device(). Cheers, Benjamin > 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 >