From mboxrd@z Thu Jan 1 00:00:00 1970 From: Benjamin Tissoires Subject: Re: [RFC PATCH v6 3/5] ACPI: button: Rework lid_init_state=ignore mode Date: Fri, 23 Jun 2017 16:03:31 +0200 Message-ID: <20170623140331.GQ26073@mail.corp.redhat.com> References: <14729dcd394f41facb871bd3cd3faf7fbf14231e.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: 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 YnV0IG9ubHkgY2FzZSAxLDIsMyw0IHdvcmsKPiBmaW5lIHdpdGggc3lzdGVtZCAyMjkuCj4gCj4g QWZ0ZXIgZml4aW5nIGFsbCB0aGUgb3RoZXIgaXNzdWVzIGZvciBvbGQgdXNlcnNwYWNlIHByb2dy YW1zLCBjYXNlIDUgaXMgdGhlCj4gb25seSBjYXNlIHRoYXQgdGhlIGV4cG9ydGVkIGlucHV0IG5v ZGUgaXMgc3RpbGwgbm90IGZ1bGx5IGNvbXBsaWFudCB0bwo+IFNXX0xJRCBBQkkgYW5kIHRodXMg bmVlZHMgcXVpcmtzIG9yIEFCSSBjaGFuZ2VzLgo+IAo+IFRoZSBvcmlnaW5hbCBidXR0b24ubGlk X2luaXRfc3RhdGU9aWdub3JlIEFCSSBjaGFuZ2Ugc29sdXRpb24gaXMgbm93IHRvbwo+IGNvbXBs aWNhdGVkIGlmIGl0cyBwdXJwb3NlIGlzIHRvIG9ubHkgc29sdmUgdGhpcyBmaW5hbCBpbmNvbXBs aWFudCB1c2UKPiBjYXNlLiBUaGlzIHBhdGNoIHJlLXdvcmtzIGl0IGJ5IHVuY29uZGl0aW9uYWxs eSBwcmVwZW5kaW5nICJvcGVuIgo+IGNvbXBsZW1lbnQgZXZlbnRzLgoKT3VjaC4gSSB0aG91Z2h0 IHRoZSBwdXJwb3NlIG9mICJpZ25vcmUiIHdhcyB0byBub3QgcXVlcnkgdGhlIHN0YXRlIG9uCmJv b3QvcmVzdW1lIGFuZCBvbmx5IHJlbHkgb24gYWNwaSBub3RpZmljYXRpb24gdG8gc3dpdGNoIHRo ZSBzdGF0ZXMuCgpJIGxpa2UgdGhlIHBhdGNoLCB0aGUgY29tbWl0IG1lc3NhZ2UgaXMgSU1PIHRv byBmYXIgZnJvbSB3aGF0IGl0CmFjdHVhbGx5IGRvZXM6Ci0gaXQgcmVtb3ZlcyB0aGUgY2FjaGlu ZyB1cGRhdGUgb2YgX0xJRCBzd2l0Y2gKLSBpdCByZW1vdmVzIHRoZSBmaWx0ZXJpbmcgb2YgdG9v IGNsb3NlIG5vdGlmaWNhdGlvbnMuCgpPbmUgbW9yZSBub3RlIGlubGluZWQ6Cgo+IAo+IENjOiA8 c3lzdGVtZC1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmc+Cj4gQ2M6IEJlbmphbWluIFRpc3Nv aXJlcyA8YmVuamFtaW4udGlzc29pcmVzQHJlZGhhdC5jb20+Cj4gQ2M6IFBldGVyIEh1dHRlcmVy IDxwZXRlci5odXR0ZXJlckB3aG8tdC5uZXQ+Cj4gU2lnbmVkLW9mZi1ieTogTHYgWmhlbmcgPGx2 LnpoZW5nQGludGVsLmNvbT4KPiAtLS0KPiAgZHJpdmVycy9hY3BpL2J1dHRvbi5jIHwgODUgKysr LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gIDEgZmls ZSBjaGFuZ2VkLCA1IGluc2VydGlvbnMoKyksIDgwIGRlbGV0aW9ucygtKQo+IAo+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL2FjcGkvYnV0dG9uLmMgYi9kcml2ZXJzL2FjcGkvYnV0dG9uLmMKPiBpbmRl eCBhOGIxMTllLi4xMjU2YThjIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvYWNwaS9idXR0b24uYwo+ ICsrKyBiL2RyaXZlcnMvYWNwaS9idXR0b24uYwo+IEBAIC0xMDksOCArMTA5LDYgQEAgc3RydWN0 IGFjcGlfYnV0dG9uIHsKPiAgCXN0cnVjdCB0aW1lcl9saXN0IGxpZF90aW1lcjsKPiAgCWNoYXIg cGh5c1szMl07CQkJLyogZm9yIGlucHV0IGRldmljZSAqLwo+ICAJdW5zaWduZWQgbG9uZyBwdXNo ZWQ7Cj4gLQlpbnQgbGFzdF9zdGF0ZTsKPiAtCWt0aW1lX3QgbGFzdF90aW1lOwo+ICAJYm9vbCBz dXNwZW5kZWQ7Cj4gIH07Cj4gIAo+IEBAIC0xMTgsMTAgKzExNiw2IEBAIHN0YXRpYyBCTE9DS0lO R19OT1RJRklFUl9IRUFEKGFjcGlfbGlkX25vdGlmaWVyKTsKPiAgc3RhdGljIHN0cnVjdCBhY3Bp X2RldmljZSAqbGlkX2RldmljZTsKPiAgc3RhdGljIHU4IGxpZF9pbml0X3N0YXRlID0gQUNQSV9C VVRUT05fTElEX0lOSVRfTUVUSE9EOwo+ICAKPiAtc3RhdGljIHVuc2lnbmVkIGxvbmcgbGlkX3Jl cG9ydF9pbnRlcnZhbCBfX3JlYWRfbW9zdGx5ID0gNTAwOwo+IC1tb2R1bGVfcGFyYW0obGlkX3Jl cG9ydF9pbnRlcnZhbCwgdWxvbmcsIDA2NDQpOwo+IC1NT0RVTEVfUEFSTV9ERVNDKGxpZF9yZXBv cnRfaW50ZXJ2YWwsICJJbnRlcnZhbCAobXMpIGJldHdlZW4gbGlkIGtleSBldmVudHMiKTsKPiAt CgpZb3Ugc2hvdWxkbid0IGRvIHRoYXQuIEl0IGlzIGtlcm5lbCBBQkksIGFuZCBpZiB5b3UgcmVt b3ZlIHRoZSBtb2R1bGUsCnBlb3BsZSB0aGF0IHR1bmVkIHRoZWlyIGtlcm5lbCB3aXRoIHRoaXMg cGFyYW1ldGVyIHdpbGwgaGF2ZSB0aGUgbW9kdWxlCmZhaWxpbmcgdG8gbG9hZC4gWW91IHNob3Vs ZCBrZWVwIHRoaXMgYXJvdW5kIGZvciBhIGZldyBrZXJuZWwgcmVsZWFzZXMsCmFuZCBtYXJrIGl0 cyB1c2FnZSBkZXByZWNhdGVkIGJ5IGlzc3VpbmcgYSB3YXJuaW5nIGluIHRoZSBkbWVzZy4KCkNo ZWVycywKQmVuamFtaW4KCj4gIHN0YXRpYyB1bnNpZ25lZCBsb25nIGxpZF9ub3RpZnlfdGltZW91 dCBfX3JlYWRfbW9zdGx5ID0gMTA7Cj4gIG1vZHVsZV9wYXJhbShsaWRfbm90aWZ5X3RpbWVvdXQs IHVsb25nLCAwNjQ0KTsKPiAgTU9EVUxFX1BBUk1fREVTQyhsaWRfbm90aWZ5X3RpbWVvdXQsICJU aW1lb3V0IChzKSBiZWZvcmUgcmVjZWl2aW5nIGxpZCBub3RpZmljYXRpb24iKTsKPiBAQCAtMTU3 LDc5ICsxNTEsMTIgQEAgc3RhdGljIGludCBhY3BpX2xpZF9ub3RpZnlfc3RhdGUoc3RydWN0IGFj cGlfZGV2aWNlICpkZXZpY2UsIGludCBzdGF0ZSkKPiAgewo+ICAJc3RydWN0IGFjcGlfYnV0dG9u ICpidXR0b24gPSBhY3BpX2RyaXZlcl9kYXRhKGRldmljZSk7Cj4gIAlpbnQgcmV0Owo+IC0Ja3Rp bWVfdCBuZXh0X3JlcG9ydDsKPiAtCWJvb2wgZG9fdXBkYXRlOwo+IC0KPiAtCS8qCj4gLQkgKiBJ biBsaWRfaW5pdF9zdGF0ZT1pZ25vcmUgbW9kZSwgaWYgdXNlciBvcGVucy9jbG9zZXMgbGlkCj4g LQkgKiBmcmVxdWVudGx5IHdpdGggIm9wZW4iIG1pc3NpbmcsIGFuZCAibGFzdF90aW1lIiBpcyBh bHNvIHVwZGF0ZWQKPiAtCSAqIGZyZXF1ZW50bHksICJjbG9zZSIgY2Fubm90IGJlIGRlbGl2ZXJl ZCB0byB0aGUgdXNlcnNwYWNlLgo+IC0JICogU28gImxhc3RfdGltZSIgaXMgb25seSB1cGRhdGVk IGFmdGVyIGEgdGltZW91dCBvciBhbiBhY3R1YWwKPiAtCSAqIHN3aXRjaC4KPiAtCSAqLwo+IC0J aWYgKGxpZF9pbml0X3N0YXRlICE9IEFDUElfQlVUVE9OX0xJRF9JTklUX0lHTk9SRSB8fAo+IC0J ICAgIGJ1dHRvbi0+bGFzdF9zdGF0ZSAhPSAhIXN0YXRlKQo+IC0JCWRvX3VwZGF0ZSA9IHRydWU7 Cj4gLQllbHNlCj4gLQkJZG9fdXBkYXRlID0gZmFsc2U7Cj4gLQo+IC0JbmV4dF9yZXBvcnQgPSBr dGltZV9hZGQoYnV0dG9uLT5sYXN0X3RpbWUsCj4gLQkJCQltc190b19rdGltZShsaWRfcmVwb3J0 X2ludGVydmFsKSk7Cj4gLQlpZiAoYnV0dG9uLT5sYXN0X3N0YXRlID09ICEhc3RhdGUgJiYKPiAt CSAgICBrdGltZV9hZnRlcihrdGltZV9nZXQoKSwgbmV4dF9yZXBvcnQpKSB7Cj4gLQkJLyogQ29t cGxhaW4gdGhlIGJ1Z2d5IGZpcm13YXJlICovCj4gLQkJcHJfd2Fybl9vbmNlKCJUaGUgbGlkIGRl dmljZSBpcyBub3QgY29tcGxpYW50IHRvIFNXX0xJRC5cbiIpOwo+ICAKPiAtCQkvKgo+IC0JCSAq IFNlbmQgdGhlIHVucmVsaWFibGUgY29tcGxlbWVudCBzd2l0Y2ggZXZlbnQ6Cj4gLQkJICoKPiAt CQkgKiBPbiBtb3N0IHBsYXRmb3JtcywgdGhlIGxpZCBkZXZpY2UgaXMgcmVsaWFibGUuIEhvd2V2 ZXIKPiAtCQkgKiB0aGVyZSBhcmUgZXhjZXB0aW9uczoKPiAtCQkgKiAxLiBQbGF0Zm9ybXMgcmV0 dXJuaW5nIGluaXRpYWwgbGlkIHN0YXRlIGFzICJjbG9zZSIgYnkKPiAtCQkgKiAgICBkZWZhdWx0 IGFmdGVyIGJvb3RpbmcvcmVzdW1pbmc6Cj4gLQkJICogICAgIGh0dHBzOi8vYnVnemlsbGEua2Vy bmVsLm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODkyMTEKPiAtCQkgKiAgICAgaHR0cHM6Ly9idWd6aWxs YS5rZXJuZWwub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDYxNTEKPiAtCQkgKiAyLiBQbGF0Zm9ybXMg bmV2ZXIgcmVwb3J0aW5nICJvcGVuIiBldmVudHM6Cj4gLQkJICogICAgIGh0dHBzOi8vYnVnemls bGEua2VybmVsLm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTA2OTQxCj4gLQkJICogT24gdGhlc2UgYnVn Z3kgcGxhdGZvcm1zLCB0aGUgdXNhZ2UgbW9kZWwgb2YgdGhlIEFDUEkKPiAtCQkgKiBsaWQgZGV2 aWNlIGFjdHVhbGx5IGlzOgo+IC0JCSAqIDEuIFRoZSBpbml0aWFsIHJldHVybmluZyB2YWx1ZSBv ZiBfTElEIG1heSBub3QgYmUKPiAtCQkgKiAgICByZWxpYWJsZS4KPiAtCQkgKiAyLiBUaGUgb3Bl biBldmVudCBtYXkgbm90IGJlIHJlbGlhYmxlLgo+IC0JCSAqIDMuIFRoZSBjbG9zZSBldmVudCBp cyByZWxpYWJsZS4KPiAtCQkgKgo+IC0JCSAqIEJ1dCBTV19MSUQgaXMgdHlwZWQgYXMgaW5wdXQg c3dpdGNoIGV2ZW50LCB0aGUgaW5wdXQKPiAtCQkgKiBsYXllciBjaGVja3MgaWYgdGhlIGV2ZW50 IGlzIHJlZHVuZGFudC4gSGVuY2UgaWYgdGhlCj4gLQkJICogc3RhdGUgaXMgbm90IHN3aXRjaGVk LCB0aGUgdXNlcnNwYWNlIGNhbm5vdCBzZWUgdGhpcwo+IC0JCSAqIHBsYXRmb3JtIHRyaWdnZXJl ZCByZWxpYWJsZSBldmVudC4gQnkgaW5zZXJ0aW5nIGEKPiAtCQkgKiBjb21wbGVtZW50IHN3aXRj aCBldmVudCwgaXQgdGhlbiBpcyBndWFyYW50ZWVkIHRoYXQgdGhlCj4gLQkJICogcGxhdGZvcm0g dHJpZ2dlcmVkIHJlbGlhYmxlIG9uZSBjYW4gYWx3YXlzIGJlIHNlZW4gYnkKPiAtCQkgKiB0aGUg dXNlcnNwYWNlLgo+IC0JCSAqLwo+IC0JCWlmIChsaWRfaW5pdF9zdGF0ZSA9PSBBQ1BJX0JVVFRP Tl9MSURfSU5JVF9JR05PUkUpIHsKPiAtCQkJZG9fdXBkYXRlID0gdHJ1ZTsKPiAtCQkJLyoKPiAt CQkJICogRG8gZ2VuZXJhdGUgY29tcGxlbWVudCBzd2l0Y2ggZXZlbnQgZm9yICJjbG9zZSIKPiAt CQkJICogYXMgImNsb3NlIiBpcyByZWxpYWJsZSBhbmQgd3JvbmcgIm9wZW4iIHdvbid0Cj4gLQkJ CSAqIHRyaWdnZXIgdW5leHBlY3RlZCBiZWhhdmlvcnMuCj4gLQkJCSAqIERvIG5vdCBnZW5lcmF0 ZSBjb21wbGVtZW50IHN3aXRjaCBldmVudCBmb3IKPiAtCQkJICogIm9wZW4iIGFzICJvcGVuIiBp cyBub3QgcmVsaWFibGUgYW5kIHdyb25nCj4gLQkJCSAqICJjbG9zZSIgd2lsbCB0cmlnZ2VyIHVu ZXhwZWN0ZWQgYmVoYXZpb3JzLgo+IC0JCQkgKi8KPiAtCQkJaWYgKCFzdGF0ZSkgewo+IC0JCQkJ aW5wdXRfcmVwb3J0X3N3aXRjaChidXR0b24tPmlucHV0LAo+IC0JCQkJCQkgICAgU1dfTElELCBz dGF0ZSk7Cj4gLQkJCQlpbnB1dF9zeW5jKGJ1dHRvbi0+aW5wdXQpOwo+IC0JCQl9Cj4gLQkJfQo+ IC0JfQo+IC0JLyogU2VuZCB0aGUgcGxhdGZvcm0gdHJpZ2dlcmVkIHJlbGlhYmxlIGV2ZW50ICov Cj4gLQlpZiAoZG9fdXBkYXRlKSB7Cj4gLQkJaW5wdXRfcmVwb3J0X3N3aXRjaChidXR0b24tPmlu cHV0LCBTV19MSUQsICFzdGF0ZSk7Cj4gLQkJaW5wdXRfc3luYyhidXR0b24tPmlucHV0KTsKPiAt CQlidXR0b24tPmxhc3Rfc3RhdGUgPSAhIXN0YXRlOwo+IC0JCWJ1dHRvbi0+bGFzdF90aW1lID0g a3RpbWVfZ2V0KCk7Cj4gLQl9Cj4gKwlpZiAobGlkX2luaXRfc3RhdGUgPT0gQUNQSV9CVVRUT05f TElEX0lOSVRfSUdOT1JFKQo+ICsJCWlucHV0X3JlcG9ydF9zd2l0Y2goYnV0dG9uLT5pbnB1dCwg U1dfTElELCAwKTsKPiArCj4gKwlpbnB1dF9yZXBvcnRfc3dpdGNoKGJ1dHRvbi0+aW5wdXQsIFNX X0xJRCwgIXN0YXRlKTsKPiArCWlucHV0X3N5bmMoYnV0dG9uLT5pbnB1dCk7Cj4gIAo+ICAJaWYg KHN0YXRlKQo+ICAJCXBtX3dha2V1cF9ldmVudCgmZGV2aWNlLT5kZXYsIDApOwo+IEBAIC01MjQs OCArNDUxLDYgQEAgc3RhdGljIGludCBhY3BpX2J1dHRvbl9hZGQoc3RydWN0IGFjcGlfZGV2aWNl ICpkZXZpY2UpCj4gIAkJc3RyY3B5KG5hbWUsIEFDUElfQlVUVE9OX0RFVklDRV9OQU1FX0xJRCk7 Cj4gIAkJc3ByaW50ZihjbGFzcywgIiVzLyVzIiwKPiAgCQkJQUNQSV9CVVRUT05fQ0xBU1MsIEFD UElfQlVUVE9OX1NVQkNMQVNTX0xJRCk7Cj4gLQkJYnV0dG9uLT5sYXN0X3N0YXRlID0gISFhY3Bp X2xpZF9ldmFsdWF0ZV9zdGF0ZShkZXZpY2UpOwo+IC0JCWJ1dHRvbi0+bGFzdF90aW1lID0ga3Rp bWVfZ2V0KCk7Cj4gIAkJaW5pdF90aW1lcigmYnV0dG9uLT5saWRfdGltZXIpOwo+ICAJCXNldHVw X3RpbWVyKCZidXR0b24tPmxpZF90aW1lciwKPiAgCQkJICAgIGFjcGlfbGlkX3RpbWVvdXQsICh1 bG9uZylkZXZpY2UpOwo+IC0tIAo+IDIuNy40Cj4gCl9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fCnN5c3RlbWQtZGV2ZWwgbWFpbGluZyBsaXN0CnN5c3RlbWQt ZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3Jn L21haWxtYW4vbGlzdGluZm8vc3lzdGVtZC1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754396AbdFWODi (ORCPT ); Fri, 23 Jun 2017 10:03:38 -0400 Received: from mx1.redhat.com ([209.132.183.28]:58548 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754361AbdFWODg (ORCPT ); Fri, 23 Jun 2017 10:03:36 -0400 DMARC-Filter: OpenDMARC Filter v1.3.2 mx1.redhat.com 5E6407CE1E Authentication-Results: ext-mx04.extmail.prod.ext.phx2.redhat.com; dmarc=none (p=none dis=none) header.from=redhat.com Authentication-Results: ext-mx04.extmail.prod.ext.phx2.redhat.com; spf=pass smtp.mailfrom=benjamin.tissoires@redhat.com DKIM-Filter: OpenDKIM Filter v2.11.0 mx1.redhat.com 5E6407CE1E Date: Fri, 23 Jun 2017 16:03:31 +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 3/5] ACPI: button: Rework lid_init_state=ignore mode Message-ID: <20170623140331.GQ26073@mail.corp.redhat.com> References: <14729dcd394f41facb871bd3cd3faf7fbf14231e.1498034513.git.lv.zheng@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline In-Reply-To: X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.28]); Fri, 23 Jun 2017 14:03:36 +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,2,3,4 work > fine with systemd 229. > > After fixing all the other issues for old userspace programs, case 5 is the > only case that the exported input node is still not fully compliant to > SW_LID ABI and thus needs quirks or ABI changes. > > The original button.lid_init_state=ignore ABI change solution is now too > complicated if its purpose is to only solve this final incompliant use > case. This patch re-works it by unconditionally prepending "open" > complement events. Ouch. I thought the purpose of "ignore" was to not query the state on boot/resume and only rely on acpi notification to switch the states. I like the patch, the commit message is IMO too far from what it actually does: - it removes the caching update of _LID switch - it removes the filtering of too close notifications. One more note inlined: > > Cc: > Cc: Benjamin Tissoires > Cc: Peter Hutterer > Signed-off-by: Lv Zheng > --- > drivers/acpi/button.c | 85 +++------------------------------------------------ > 1 file changed, 5 insertions(+), 80 deletions(-) > > diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c > index a8b119e..1256a8c 100644 > --- a/drivers/acpi/button.c > +++ b/drivers/acpi/button.c > @@ -109,8 +109,6 @@ struct acpi_button { > struct timer_list lid_timer; > char phys[32]; /* for input device */ > unsigned long pushed; > - int last_state; > - ktime_t last_time; > bool suspended; > }; > > @@ -118,10 +116,6 @@ static BLOCKING_NOTIFIER_HEAD(acpi_lid_notifier); > static struct acpi_device *lid_device; > static u8 lid_init_state = ACPI_BUTTON_LID_INIT_METHOD; > > -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"); > - You shouldn't do that. It is kernel ABI, and if you remove the module, people that tuned their kernel with this parameter will have the module failing to load. You should keep this around for a few kernel releases, and mark its usage deprecated by issuing a warning in the dmesg. Cheers, Benjamin > 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"); > @@ -157,79 +151,12 @@ static int acpi_lid_notify_state(struct acpi_device *device, int state) > { > struct acpi_button *button = acpi_driver_data(device); > int ret; > - ktime_t next_report; > - bool do_update; > - > - /* > - * In lid_init_state=ignore mode, if user opens/closes lid > - * frequently with "open" missing, and "last_time" is also updated > - * frequently, "close" cannot be delivered to the userspace. > - * So "last_time" is only updated after a timeout or an actual > - * switch. > - */ > - if (lid_init_state != ACPI_BUTTON_LID_INIT_IGNORE || > - button->last_state != !!state) > - do_update = true; > - else > - do_update = false; > - > - next_report = ktime_add(button->last_time, > - ms_to_ktime(lid_report_interval)); > - if (button->last_state == !!state && > - ktime_after(ktime_get(), next_report)) { > - /* Complain the buggy firmware */ > - pr_warn_once("The lid device is not compliant to SW_LID.\n"); > > - /* > - * Send the unreliable complement switch event: > - * > - * On most platforms, the lid device is reliable. However > - * there are exceptions: > - * 1. Platforms returning initial lid state as "close" by > - * default after booting/resuming: > - * https://bugzilla.kernel.org/show_bug.cgi?id=89211 > - * https://bugzilla.kernel.org/show_bug.cgi?id=106151 > - * 2. Platforms never reporting "open" events: > - * https://bugzilla.kernel.org/show_bug.cgi?id=106941 > - * On these buggy platforms, the usage model of the ACPI > - * lid device actually is: > - * 1. The initial returning value of _LID may not be > - * reliable. > - * 2. The open event may not be reliable. > - * 3. The close event is reliable. > - * > - * But SW_LID is typed as input switch event, the input > - * layer checks if the event is redundant. Hence if the > - * state is not switched, the userspace cannot see this > - * platform triggered reliable event. By inserting a > - * complement switch event, it then is guaranteed that the > - * platform triggered reliable one can always be seen by > - * the userspace. > - */ > - if (lid_init_state == ACPI_BUTTON_LID_INIT_IGNORE) { > - do_update = true; > - /* > - * Do generate complement switch event for "close" > - * as "close" is reliable and wrong "open" won't > - * trigger unexpected behaviors. > - * Do not generate complement switch event for > - * "open" as "open" is not reliable and wrong > - * "close" will trigger unexpected behaviors. > - */ > - if (!state) { > - input_report_switch(button->input, > - SW_LID, state); > - input_sync(button->input); > - } > - } > - } > - /* Send the platform triggered reliable event */ > - if (do_update) { > - input_report_switch(button->input, SW_LID, !state); > - input_sync(button->input); > - button->last_state = !!state; > - button->last_time = ktime_get(); > - } > + if (lid_init_state == ACPI_BUTTON_LID_INIT_IGNORE) > + input_report_switch(button->input, SW_LID, 0); > + > + input_report_switch(button->input, SW_LID, !state); > + input_sync(button->input); > > if (state) > pm_wakeup_event(&device->dev, 0); > @@ -524,8 +451,6 @@ static int acpi_button_add(struct acpi_device *device) > strcpy(name, ACPI_BUTTON_DEVICE_NAME_LID); > sprintf(class, "%s/%s", > 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); > -- > 2.7.4 >