From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753958AbeDPHTc (ORCPT ); Mon, 16 Apr 2018 03:19:32 -0400 Received: from mailout2.w1.samsung.com ([210.118.77.12]:38722 "EHLO mailout2.w1.samsung.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750735AbeDPHT3 (ORCPT ); Mon, 16 Apr 2018 03:19:29 -0400 DKIM-Filter: OpenDKIM Filter v2.11.0 mailout2.w1.samsung.com 20180416071927euoutp02a22b0aa90f8957bdef4e76dca3895815~l2XoKF2GU0359703597euoutp02r X-AuditID: cbfec7f4-713ff700000043e4-3b-5ad44e7d0728 Subject: Re: [PATCH v6 24/30] drm/rockchip: Disable PSR on input events To: Enric Balletbo i Serra , architt@codeaurora.org, inki.dae@samsung.com, thierry.reding@gmail.com, hjc@rock-chips.com, seanpaul@chromium.org, airlied@linux.ie, tfiga@chromium.org, heiko@sntech.de Cc: dri-devel@lists.freedesktop.org, dianders@chromium.org, ykk@rock-chips.com, kernel@collabora.com, m.szyprowski@samsung.com, linux-samsung-soc@vger.kernel.org, jy0922.shim@samsung.com, rydberg@bitmath.org, krzk@kernel.org, linux-rockchip@lists.infradead.org, kgene@kernel.org, linux-input@vger.kernel.org, orjan.eide@arm.com, wxt@rock-chips.com, jeffy.chen@rock-chips.com, linux-arm-kernel@lists.infradead.org, mark.yao@rock-chips.com, wzz@rock-chips.com, hl@rock-chips.com, jingoohan1@gmail.com, sw0312.kim@samsung.com, linux-kernel@vger.kernel.org, kyungmin.park@samsung.com, Laurent.pinchart@ideasonboard.com, kuankuan.y@gmail.com, hshi@chromium.org, "Kristian H. Kristensen" , Dmitry Torokhov , "linux-input@vger.kernel.org" From: Andrzej Hajda Message-ID: <20d2aa03-63e3-0072-5ca7-5f3ca42c3c9e@samsung.com> Date: Mon, 16 Apr 2018 09:19:21 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.7.0 MIME-Version: 1.0 In-Reply-To: <20180405095000.9756-25-enric.balletbo@collabora.com> Content-Transfer-Encoding: 7bit Content-Language: en-US X-Brightmail-Tracker: H4sIAAAAAAAAA02Tf1DTdRjH7/P9ue0YfZzQPlFX14w7rHDN6/K5DO3Ku75lZ51dnoeVLfyG JgxvE8k8gqbxSwEFFTZsehwiR1i0kSw80Ea5lMZkMxVzQUqGrGW3MYqLH7F99eK/1/Pr/X6e Px4ZrRrnUmRbDNtFo0Gfo+EUzKlzk970wjWXMp+61ZgOlf3nKTCXhVjwNH/LQW/jKIJL0Tsc tP3sQjB7I8jCZzWF8E/7BRr2ev6iobTjBgU1Q/sZ+Puqh4OWcQsPo78MMODo38dC9c0gDV5v Ow8Xz/RR4DH/wUP5gSYe7DcvszAYnmDB33WEg/DwLA313h4KTn4X4MF58CwFPY5eBn6YOExB oN2DoL72NgeRT2c4mOyyMVC6u5mCkiv3Q39xLf98qtBma0NCpHWMFRqKBxjBX1VJCc5AExK+ sQZ44Zg9X2gos7CCvbWcEzonhllhaK+bEhxNRcK09QwjVHW0IqHzso0WIvaHX8eZiuc2iTlb dohG7Yp3FZuj1w9x28ozPvzTcYAqRnW6CiSXEfw08Z/wcRVIIVPhFkRa3N20FIwjUmKruhtE EPF1n6TujRw+u4ePsQqfQGQ4hKWmECKfewNsrLAQv0QOztTEdZPwbUTavw9SsYDGLo7UX4sw sS4OLybTjkEuxkq8gkxdMceZwankuuVcXCkZryfm3yd5qWcBOW8Zic/K8QukcncYxZjGj5DO 0BFaYjW5NnI0bkawT06+GD3NSnuvIj81+niJF5Ixd8ddfoj01e5jJN5FBkfNjDRchsjQv6Wc VFhOet0Dc0KyOYfF5MsubQwJziBm24sSJpKroQXSComk5lQdLaWVpKxEJWk8SoY8X9MSq8nx i1FuP1pknXeYdd4x1nnHWP+3PYaYVqQW80252aJpqUEsWGLS55ryDdlLsvJy7WjuF/pm3ONO 1DX1ngthGdIkKJ0ef6aK1e8w7cx1ISKjNUnKZv1cSrlJv/Mj0Zi30ZifI5pc6EEZo1Er30n7 OFOFs/Xbxa2iuE003qtSMnlKMdKmFGSstxSVjiXLl20MH197562SlT9+9eSG4OoNRfcV/rou ocLv1S7aE05NGCtQ80npdDDtmbePulbp1qnfx3lLo59spRqe/eDlcJoqsTuZf+yW1vrba0+4 11b7dq1OfOWCLku3bMqpeICv4wwjy7NmX1VNvxF9s9q2smfNaSFSnmYSNYxps173OG006f8D 5i7GsQcEAAA= X-Brightmail-Tracker: H4sIAAAAAAAAA02Se0xTdxTH87vPona5Fhy/kMVHE2Nw4eoFkcNSiS7G3e2PxUQzTY3gjdyA GW1db2uoc47BRB4rAjJniwJTxIWwBVsCtdsAq0GRlYIYmI+iUZKhiC4w8IUwaDXhv0/O93xO zkmOitQUMjGqfUaLbDZKWVpmAdU1fTUYd+jzm/q1xa9iwd7dSUBuwSgN/rpLDFw+M4zg5sQz Bhru+BDMPBih4XT5N/Ci8ToJxf5/STja9ICA8nulFDz/28/AL/85WBge7KXA3f0DDccejpAQ CDSy0NPWRYA/9wkLhWW1LLge9tNwa2yShj7vKQbG7s+QcDLQSsCvV4IseCraCWh1X6bg2uQJ AoKNfgQnjz9iYPzINAMvvVUUHM2rIyB/4H3ozjnOblwpNlQ1IHG8/jEtVub0UmJfiZ0QPcFa JF50BlmxxmUVKwsctOiqL2TElsn7tHiv+Cohumu/Fd842yixpKkeiS39VaQ47lq6ldPzOrPJ apGXZ5oUywbtLgHieSEZ+Ph1ybyQkLT7o/hE7ZoUXbqcte+AbF6TsofPnLj7I7O/cEP2U3cZ kYN+EopQhApz6/CJ9u/ZIrRApeHOIZxbmU+Fg2j8e/UoGeZIPNVfxISbRhD2+p7Qc0Ek9wmu mC4PBVHcI4Q77Y9Do0juCoM7SmuosPIXwg2XvMycwnCx+I37VojVXAqeGsgNMcWtxHcdHaGx S7ideDAw9rZnMe50DIV2iuA+xva8MTTHJLcKT1XdIMO8DLeMnnrL0fj2UDVRijTOebpznuKc pzjnKTWIqkdRslUxZBgUgVckg2I1ZvB7TQYXmn3D5o6Xbg+6cWGbD3EqpF2k9vj79BpaOqDY DD6EVaQ2Sl0nzZbU6ZLtoGw2pZmtWbLiQ4mzx5WRMUv2mmaf2mhJExKFJEgWkhKSEtaDNlod WGvTa7gMySJ/Kcv7ZfM7j1BFxOSgL7Zaopeldm2Kq3ihdqSidt2fO6TIPa5DPXadjW9KS2eR IXMq5TxvlJ6f3VL7M5/a8t7mr2wFrbvO9ex+doxcwbTHxP6xKm7y8PnKiU+bv36dPfRBSc9A WfaWmd90+pmLK6r1Ha+y8wY9ff6uC814/fDr5fkRny1s+26795/eRTWeD7WUkikJq0mzIv0P l2LlGZwDAAA= X-CMS-MailID: 20180416071925eucas1p20d61ccf3173617be9363716561f93fb3 X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" X-MTR: 20180416071925eucas1p20d61ccf3173617be9363716561f93fb3 X-EPHeader: CA CMS-TYPE: 201P X-CMS-RootMailID: 20180405095330epcas1p33487d73838f08a65ce7935f0d3e8b9e4 X-RootMTR: 20180405095330epcas1p33487d73838f08a65ce7935f0d3e8b9e4 References: <20180405095000.9756-1-enric.balletbo@collabora.com> <20180405095000.9756-25-enric.balletbo@collabora.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org +CC: linux-input list and maintainer On 05.04.2018 11:49, Enric Balletbo i Serra wrote: > From: "Kristian H. Kristensen" > > To improve PSR exit latency, we speculatively start exiting when we > receive input events. Occasionally, this may lead to false positives, > but most of the time we get a head start on coming out of PSR. Depending > on how userspace takes to produce a new frame in response to the event, > this can completely hide the exit latency. In case of Chrome OS, we > typically get the input notifier 50ms or more before the dirty_fb > triggered exit. As I see from the code below, you just need notification from input subsystem on user activity. Maybe there is some simpler notification mechanism for such things? If not, maybe such helper should be created in input subsystem, I suppose it could be reused in other places as well. Regards Andrzej > > Signed-off-by: Kristian H. Kristensen > Signed-off-by: Thierry Escande > Signed-off-by: Enric Balletbo i Serra > Tested-by: Marek Szyprowski > --- > > drivers/gpu/drm/rockchip/rockchip_drm_psr.c | 134 ++++++++++++++++++++++++++++ > 1 file changed, 134 insertions(+) > > diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_psr.c b/drivers/gpu/drm/rockchip/rockchip_drm_psr.c > index 9376f4396b6b..a107845ba97c 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_drm_psr.c > +++ b/drivers/gpu/drm/rockchip/rockchip_drm_psr.c > @@ -12,6 +12,8 @@ > * GNU General Public License for more details. > */ > > +#include > + > #include > #include > > @@ -35,6 +37,9 @@ struct psr_drv { > enum psr_state state; > > struct delayed_work flush_work; > + struct work_struct disable_work; > + > + struct input_handler input_handler; > > int (*set)(struct drm_encoder *encoder, bool enable); > }; > @@ -133,6 +138,18 @@ static void psr_flush_handler(struct work_struct *work) > mutex_unlock(&psr->lock); > } > > +static void psr_disable_handler(struct work_struct *work) > +{ > + struct psr_drv *psr = container_of(work, struct psr_drv, disable_work); > + > + /* If the state has changed since we initiated the flush, do nothing */ > + mutex_lock(&psr->lock); > + if (psr->state == PSR_ENABLE) > + psr_set_state_locked(psr, PSR_FLUSH); > + mutex_unlock(&psr->lock); > + mod_delayed_work(system_wq, &psr->flush_work, PSR_FLUSH_TIMEOUT_MS); > +} > + > /** > * rockchip_drm_psr_activate - activate PSR on the given pipe > * @encoder: encoder to obtain the PSR encoder > @@ -173,6 +190,7 @@ int rockchip_drm_psr_deactivate(struct drm_encoder *encoder) > psr->active = false; > mutex_unlock(&psr->lock); > cancel_delayed_work_sync(&psr->flush_work); > + cancel_work_sync(&psr->disable_work); > > return 0; > } > @@ -226,6 +244,95 @@ void rockchip_drm_psr_flush_all(struct drm_device *dev) > } > EXPORT_SYMBOL(rockchip_drm_psr_flush_all); > > +static void psr_input_event(struct input_handle *handle, > + unsigned int type, unsigned int code, > + int value) > +{ > + struct psr_drv *psr = handle->handler->private; > + > + schedule_work(&psr->disable_work); > +} > + > +static int psr_input_connect(struct input_handler *handler, > + struct input_dev *dev, > + const struct input_device_id *id) > +{ > + struct input_handle *handle; > + int error; > + > + handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL); > + if (!handle) > + return -ENOMEM; > + > + handle->dev = dev; > + handle->handler = handler; > + handle->name = "rockchip-psr"; > + > + error = input_register_handle(handle); > + if (error) > + goto err2; > + > + error = input_open_device(handle); > + if (error) > + goto err1; > + > + return 0; > + > +err1: > + input_unregister_handle(handle); > +err2: > + kfree(handle); > + return error; > +} > + > +static void psr_input_disconnect(struct input_handle *handle) > +{ > + input_close_device(handle); > + input_unregister_handle(handle); > + kfree(handle); > +} > + > +/* Same device ids as cpu-boost */ > +static const struct input_device_id psr_ids[] = { > + { > + .flags = INPUT_DEVICE_ID_MATCH_EVBIT | > + INPUT_DEVICE_ID_MATCH_ABSBIT, > + .evbit = { BIT_MASK(EV_ABS) }, > + .absbit = { [BIT_WORD(ABS_MT_POSITION_X)] = > + BIT_MASK(ABS_MT_POSITION_X) | > + BIT_MASK(ABS_MT_POSITION_Y) }, > + }, /* multi-touch touchscreen */ > + { > + .flags = INPUT_DEVICE_ID_MATCH_EVBIT, > + .evbit = { BIT_MASK(EV_ABS) }, > + .absbit = { [BIT_WORD(ABS_X)] = BIT_MASK(ABS_X) } > + > + }, /* stylus or joystick device */ > + { > + .flags = INPUT_DEVICE_ID_MATCH_EVBIT, > + .evbit = { BIT_MASK(EV_KEY) }, > + .keybit = { [BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) }, > + }, /* pointer (e.g. trackpad, mouse) */ > + { > + .flags = INPUT_DEVICE_ID_MATCH_EVBIT, > + .evbit = { BIT_MASK(EV_KEY) }, > + .keybit = { [BIT_WORD(KEY_ESC)] = BIT_MASK(KEY_ESC) }, > + }, /* keyboard */ > + { > + .flags = INPUT_DEVICE_ID_MATCH_EVBIT | > + INPUT_DEVICE_ID_MATCH_KEYBIT, > + .evbit = { BIT_MASK(EV_KEY) }, > + .keybit = {[BIT_WORD(BTN_JOYSTICK)] = BIT_MASK(BTN_JOYSTICK) }, > + }, /* joysticks not caught by ABS_X above */ > + { > + .flags = INPUT_DEVICE_ID_MATCH_EVBIT | > + INPUT_DEVICE_ID_MATCH_KEYBIT, > + .evbit = { BIT_MASK(EV_KEY) }, > + .keybit = { [BIT_WORD(BTN_GAMEPAD)] = BIT_MASK(BTN_GAMEPAD) }, > + }, /* gamepad */ > + { }, > +}; > + > /** > * rockchip_drm_psr_register - register encoder to psr driver > * @encoder: encoder that obtain the PSR function > @@ -239,6 +346,7 @@ int rockchip_drm_psr_register(struct drm_encoder *encoder, > { > struct rockchip_drm_private *drm_drv = encoder->dev->dev_private; > struct psr_drv *psr; > + int error; > > if (!encoder || !psr_set) > return -EINVAL; > @@ -248,6 +356,7 @@ int rockchip_drm_psr_register(struct drm_encoder *encoder, > return -ENOMEM; > > INIT_DELAYED_WORK(&psr->flush_work, psr_flush_handler); > + INIT_WORK(&psr->disable_work, psr_disable_handler); > mutex_init(&psr->lock); > > psr->active = true; > @@ -255,11 +364,33 @@ int rockchip_drm_psr_register(struct drm_encoder *encoder, > psr->encoder = encoder; > psr->set = psr_set; > > + psr->input_handler.event = psr_input_event; > + psr->input_handler.connect = psr_input_connect; > + psr->input_handler.disconnect = psr_input_disconnect; > + psr->input_handler.name = > + kasprintf(GFP_KERNEL, "rockchip-psr-%s", encoder->name); > + if (!psr->input_handler.name) { > + error = -ENOMEM; > + goto err2; > + } > + psr->input_handler.id_table = psr_ids; > + psr->input_handler.private = psr; > + > + error = input_register_handler(&psr->input_handler); > + if (error) > + goto err1; > + > mutex_lock(&drm_drv->psr_list_lock); > list_add_tail(&psr->list, &drm_drv->psr_list); > mutex_unlock(&drm_drv->psr_list_lock); > > return 0; > + > + err1: > + kfree(psr->input_handler.name); > + err2: > + kfree(psr); > + return error; > } > EXPORT_SYMBOL(rockchip_drm_psr_register); > > @@ -279,8 +410,11 @@ void rockchip_drm_psr_unregister(struct drm_encoder *encoder) > mutex_lock(&drm_drv->psr_list_lock); > list_for_each_entry_safe(psr, n, &drm_drv->psr_list, list) { > if (psr->encoder == encoder) { > + input_unregister_handler(&psr->input_handler); > cancel_delayed_work_sync(&psr->flush_work); > + cancel_work_sync(&psr->disable_work); > list_del(&psr->list); > + kfree(psr->input_handler.name); > kfree(psr); > } > } From mboxrd@z Thu Jan 1 00:00:00 1970 From: Andrzej Hajda Subject: Re: [PATCH v6 24/30] drm/rockchip: Disable PSR on input events Date: Mon, 16 Apr 2018 09:19:21 +0200 Message-ID: <20d2aa03-63e3-0072-5ca7-5f3ca42c3c9e@samsung.com> References: <20180405095000.9756-1-enric.balletbo@collabora.com> <20180405095000.9756-25-enric.balletbo@collabora.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180405095000.9756-25-enric.balletbo@collabora.com> Content-Language: en-US List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Enric Balletbo i Serra , architt@codeaurora.org, inki.dae@samsung.com, thierry.reding@gmail.com, hjc@rock-chips.com, seanpaul@chromium.org, airlied@linux.ie, tfiga@chromium.org, heiko@sntech.de Cc: dri-devel@lists.freedesktop.org, dianders@chromium.org, Laurent.pinchart@ideasonboard.com, ykk@rock-chips.com, kernel@collabora.com, m.szyprowski@samsung.com, linux-samsung-soc@vger.kernel.org, rydberg@bitmath.org, krzk@kernel.org, linux-rockchip@lists.infradead.org, kgene@kernel.org, "linux-input@vger.kernel.org" , orjan.eide@arm.com, wxt@rock-chips.com, jeffy.chen@rock-chips.com, linux-arm-kernel@lists.infradead.org, mark.yao@rock-chips.com, wzz@rock-chips.com, hl@rock-chips.com, jingoohan1@gmail.com, Dmitry Torokhov , sw0312.kim@samsung.com, linux-kernel@vger.kernel.org, kyungmin.park@samsung.com, "Kristian H. Kristensen" , kuankuan.y@gmail.com, hshi@chromium.org List-Id: linux-input@vger.kernel.org CitDQzogbGludXgtaW5wdXQgbGlzdCBhbmQgbWFpbnRhaW5lcgoKCk9uIDA1LjA0LjIwMTggMTE6 NDksIEVucmljIEJhbGxldGJvIGkgU2VycmEgd3JvdGU6Cj4gRnJvbTogIktyaXN0aWFuIEguIEty aXN0ZW5zZW4iIDxob2Vnc2JlcmdAZ29vZ2xlLmNvbT4KPgo+IFRvIGltcHJvdmUgUFNSIGV4aXQg bGF0ZW5jeSwgd2Ugc3BlY3VsYXRpdmVseSBzdGFydCBleGl0aW5nIHdoZW4gd2UKPiByZWNlaXZl IGlucHV0IGV2ZW50cy4gT2NjYXNpb25hbGx5LCB0aGlzIG1heSBsZWFkIHRvIGZhbHNlIHBvc2l0 aXZlcywKPiBidXQgbW9zdCBvZiB0aGUgdGltZSB3ZSBnZXQgYSBoZWFkIHN0YXJ0IG9uIGNvbWlu ZyBvdXQgb2YgUFNSLiBEZXBlbmRpbmcKPiBvbiBob3cgdXNlcnNwYWNlIHRha2VzIHRvIHByb2R1 Y2UgYSBuZXcgZnJhbWUgaW4gcmVzcG9uc2UgdG8gdGhlIGV2ZW50LAo+IHRoaXMgY2FuIGNvbXBs ZXRlbHkgaGlkZSB0aGUgZXhpdCBsYXRlbmN5LiBJbiBjYXNlIG9mIENocm9tZSBPUywgd2UKPiB0 eXBpY2FsbHkgZ2V0IHRoZSBpbnB1dCBub3RpZmllciA1MG1zIG9yIG1vcmUgYmVmb3JlIHRoZSBk aXJ0eV9mYgo+IHRyaWdnZXJlZCBleGl0LgoKQXMgSSBzZWUgZnJvbSB0aGUgY29kZSBiZWxvdywg eW91IGp1c3QgbmVlZCBub3RpZmljYXRpb24gZnJvbSBpbnB1dApzdWJzeXN0ZW0gb24gdXNlciBh Y3Rpdml0eS4KTWF5YmUgdGhlcmUgaXMgc29tZSBzaW1wbGVyIG5vdGlmaWNhdGlvbiBtZWNoYW5p c20gZm9yIHN1Y2ggdGhpbmdzPwpJZiBub3QsIG1heWJlIHN1Y2ggaGVscGVyIHNob3VsZCBiZSBj cmVhdGVkIGluIGlucHV0IHN1YnN5c3RlbSwgSQpzdXBwb3NlIGl0IGNvdWxkIGJlIHJldXNlZCBp biBvdGhlciBwbGFjZXMgYXMgd2VsbC4KClJlZ2FyZHMKQW5kcnplagoKPgo+IFNpZ25lZC1vZmYt Ynk6IEtyaXN0aWFuIEguIEtyaXN0ZW5zZW4gPGhvZWdzYmVyZ0Bnb29nbGUuY29tPgo+IFNpZ25l ZC1vZmYtYnk6IFRoaWVycnkgRXNjYW5kZSA8dGhpZXJyeS5lc2NhbmRlQGNvbGxhYm9yYS5jb20+ Cj4gU2lnbmVkLW9mZi1ieTogRW5yaWMgQmFsbGV0Ym8gaSBTZXJyYSA8ZW5yaWMuYmFsbGV0Ym9A Y29sbGFib3JhLmNvbT4KPiBUZXN0ZWQtYnk6IE1hcmVrIFN6eXByb3dza2kgPG0uc3p5cHJvd3Nr aUBzYW1zdW5nLmNvbT4KPiAtLS0KPgo+ICBkcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2No aXBfZHJtX3Bzci5jIHwgMTM0ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiAgMSBmaWxl IGNoYW5nZWQsIDEzNCBpbnNlcnRpb25zKCspCj4KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV9wc3IuYyBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hp cC9yb2NrY2hpcF9kcm1fcHNyLmMKPiBpbmRleCA5Mzc2ZjQzOTZiNmIuLmExMDc4NDViYTk3YyAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX3Bzci5j Cj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV9wc3IuYwo+IEBA IC0xMiw2ICsxMiw4IEBACj4gICAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3Jl IGRldGFpbHMuCj4gICAqLwo+ICAKPiArI2luY2x1ZGUgPGxpbnV4L2lucHV0Lmg+Cj4gKwo+ICAj aW5jbHVkZSA8ZHJtL2RybVAuaD4KPiAgI2luY2x1ZGUgPGRybS9kcm1fY3J0Y19oZWxwZXIuaD4K PiAgCj4gQEAgLTM1LDYgKzM3LDkgQEAgc3RydWN0IHBzcl9kcnYgewo+ICAJZW51bSBwc3Jfc3Rh dGUJCXN0YXRlOwo+ICAKPiAgCXN0cnVjdCBkZWxheWVkX3dvcmsJZmx1c2hfd29yazsKPiArCXN0 cnVjdCB3b3JrX3N0cnVjdAlkaXNhYmxlX3dvcms7Cj4gKwo+ICsJc3RydWN0IGlucHV0X2hhbmRs ZXIgICAgaW5wdXRfaGFuZGxlcjsKPiAgCj4gIAlpbnQgKCpzZXQpKHN0cnVjdCBkcm1fZW5jb2Rl ciAqZW5jb2RlciwgYm9vbCBlbmFibGUpOwo+ICB9Owo+IEBAIC0xMzMsNiArMTM4LDE4IEBAIHN0 YXRpYyB2b2lkIHBzcl9mbHVzaF9oYW5kbGVyKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKPiAg CW11dGV4X3VubG9jaygmcHNyLT5sb2NrKTsKPiAgfQo+ICAKPiArc3RhdGljIHZvaWQgcHNyX2Rp c2FibGVfaGFuZGxlcihzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCj4gK3sKPiArCXN0cnVjdCBw c3JfZHJ2ICpwc3IgPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0IHBzcl9kcnYsIGRpc2FibGVf d29yayk7Cj4gKwo+ICsJLyogSWYgdGhlIHN0YXRlIGhhcyBjaGFuZ2VkIHNpbmNlIHdlIGluaXRp YXRlZCB0aGUgZmx1c2gsIGRvIG5vdGhpbmcgKi8KPiArCW11dGV4X2xvY2soJnBzci0+bG9jayk7 Cj4gKwlpZiAocHNyLT5zdGF0ZSA9PSBQU1JfRU5BQkxFKQo+ICsJCXBzcl9zZXRfc3RhdGVfbG9j a2VkKHBzciwgUFNSX0ZMVVNIKTsKPiArCW11dGV4X3VubG9jaygmcHNyLT5sb2NrKTsKPiArCW1v ZF9kZWxheWVkX3dvcmsoc3lzdGVtX3dxLCAmcHNyLT5mbHVzaF93b3JrLCBQU1JfRkxVU0hfVElN RU9VVF9NUyk7Cj4gK30KPiArCj4gIC8qKgo+ICAgKiByb2NrY2hpcF9kcm1fcHNyX2FjdGl2YXRl IC0gYWN0aXZhdGUgUFNSIG9uIHRoZSBnaXZlbiBwaXBlCj4gICAqIEBlbmNvZGVyOiBlbmNvZGVy IHRvIG9idGFpbiB0aGUgUFNSIGVuY29kZXIKPiBAQCAtMTczLDYgKzE5MCw3IEBAIGludCByb2Nr Y2hpcF9kcm1fcHNyX2RlYWN0aXZhdGUoc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyKQo+ICAJ cHNyLT5hY3RpdmUgPSBmYWxzZTsKPiAgCW11dGV4X3VubG9jaygmcHNyLT5sb2NrKTsKPiAgCWNh bmNlbF9kZWxheWVkX3dvcmtfc3luYygmcHNyLT5mbHVzaF93b3JrKTsKPiArCWNhbmNlbF93b3Jr X3N5bmMoJnBzci0+ZGlzYWJsZV93b3JrKTsKPiAgCj4gIAlyZXR1cm4gMDsKPiAgfQo+IEBAIC0y MjYsNiArMjQ0LDk1IEBAIHZvaWQgcm9ja2NoaXBfZHJtX3Bzcl9mbHVzaF9hbGwoc3RydWN0IGRy bV9kZXZpY2UgKmRldikKPiAgfQo+ICBFWFBPUlRfU1lNQk9MKHJvY2tjaGlwX2RybV9wc3JfZmx1 c2hfYWxsKTsKPiAgCj4gK3N0YXRpYyB2b2lkIHBzcl9pbnB1dF9ldmVudChzdHJ1Y3QgaW5wdXRf aGFuZGxlICpoYW5kbGUsCj4gKwkJCSAgICB1bnNpZ25lZCBpbnQgdHlwZSwgdW5zaWduZWQgaW50 IGNvZGUsCj4gKwkJCSAgICBpbnQgdmFsdWUpCj4gK3sKPiArCXN0cnVjdCBwc3JfZHJ2ICpwc3Ig PSBoYW5kbGUtPmhhbmRsZXItPnByaXZhdGU7Cj4gKwo+ICsJc2NoZWR1bGVfd29yaygmcHNyLT5k aXNhYmxlX3dvcmspOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHBzcl9pbnB1dF9jb25uZWN0KHN0 cnVjdCBpbnB1dF9oYW5kbGVyICpoYW5kbGVyLAo+ICsJCQkgICAgIHN0cnVjdCBpbnB1dF9kZXYg KmRldiwKPiArCQkJICAgICBjb25zdCBzdHJ1Y3QgaW5wdXRfZGV2aWNlX2lkICppZCkKPiArewo+ ICsJc3RydWN0IGlucHV0X2hhbmRsZSAqaGFuZGxlOwo+ICsJaW50IGVycm9yOwo+ICsKPiArCWhh bmRsZSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBpbnB1dF9oYW5kbGUpLCBHRlBfS0VSTkVMKTsK PiArCWlmICghaGFuZGxlKQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsKPiArCWhhbmRsZS0+ZGV2 ID0gZGV2Owo+ICsJaGFuZGxlLT5oYW5kbGVyID0gaGFuZGxlcjsKPiArCWhhbmRsZS0+bmFtZSA9 ICJyb2NrY2hpcC1wc3IiOwo+ICsKPiArCWVycm9yID0gaW5wdXRfcmVnaXN0ZXJfaGFuZGxlKGhh bmRsZSk7Cj4gKwlpZiAoZXJyb3IpCj4gKwkJZ290byBlcnIyOwo+ICsKPiArCWVycm9yID0gaW5w dXRfb3Blbl9kZXZpY2UoaGFuZGxlKTsKPiArCWlmIChlcnJvcikKPiArCQlnb3RvIGVycjE7Cj4g Kwo+ICsJcmV0dXJuIDA7Cj4gKwo+ICtlcnIxOgo+ICsJaW5wdXRfdW5yZWdpc3Rlcl9oYW5kbGUo aGFuZGxlKTsKPiArZXJyMjoKPiArCWtmcmVlKGhhbmRsZSk7Cj4gKwlyZXR1cm4gZXJyb3I7Cj4g K30KPiArCj4gK3N0YXRpYyB2b2lkIHBzcl9pbnB1dF9kaXNjb25uZWN0KHN0cnVjdCBpbnB1dF9o YW5kbGUgKmhhbmRsZSkKPiArewo+ICsJaW5wdXRfY2xvc2VfZGV2aWNlKGhhbmRsZSk7Cj4gKwlp bnB1dF91bnJlZ2lzdGVyX2hhbmRsZShoYW5kbGUpOwo+ICsJa2ZyZWUoaGFuZGxlKTsKPiArfQo+ ICsKPiArLyogU2FtZSBkZXZpY2UgaWRzIGFzIGNwdS1ib29zdCAqLwo+ICtzdGF0aWMgY29uc3Qg c3RydWN0IGlucHV0X2RldmljZV9pZCBwc3JfaWRzW10gPSB7Cj4gKwl7Cj4gKwkJLmZsYWdzID0g SU5QVVRfREVWSUNFX0lEX01BVENIX0VWQklUIHwKPiArCQkJIElOUFVUX0RFVklDRV9JRF9NQVRD SF9BQlNCSVQsCj4gKwkJLmV2Yml0ID0geyBCSVRfTUFTSyhFVl9BQlMpIH0sCj4gKwkJLmFic2Jp dCA9IHsgW0JJVF9XT1JEKEFCU19NVF9QT1NJVElPTl9YKV0gPQo+ICsJCQkgICAgQklUX01BU0so QUJTX01UX1BPU0lUSU9OX1gpIHwKPiArCQkJICAgIEJJVF9NQVNLKEFCU19NVF9QT1NJVElPTl9Z KSB9LAo+ICsJfSwgLyogbXVsdGktdG91Y2ggdG91Y2hzY3JlZW4gKi8KPiArCXsKPiArCQkuZmxh Z3MgPSBJTlBVVF9ERVZJQ0VfSURfTUFUQ0hfRVZCSVQsCj4gKwkJLmV2Yml0ID0geyBCSVRfTUFT SyhFVl9BQlMpIH0sCj4gKwkJLmFic2JpdCA9IHsgW0JJVF9XT1JEKEFCU19YKV0gPSBCSVRfTUFT SyhBQlNfWCkgfQo+ICsKPiArCX0sIC8qIHN0eWx1cyBvciBqb3lzdGljayBkZXZpY2UgKi8KPiAr CXsKPiArCQkuZmxhZ3MgPSBJTlBVVF9ERVZJQ0VfSURfTUFUQ0hfRVZCSVQsCj4gKwkJLmV2Yml0 ID0geyBCSVRfTUFTSyhFVl9LRVkpIH0sCj4gKwkJLmtleWJpdCA9IHsgW0JJVF9XT1JEKEJUTl9M RUZUKV0gPSBCSVRfTUFTSyhCVE5fTEVGVCkgfSwKPiArCX0sIC8qIHBvaW50ZXIgKGUuZy4gdHJh Y2twYWQsIG1vdXNlKSAqLwo+ICsJewo+ICsJCS5mbGFncyA9IElOUFVUX0RFVklDRV9JRF9NQVRD SF9FVkJJVCwKPiArCQkuZXZiaXQgPSB7IEJJVF9NQVNLKEVWX0tFWSkgfSwKPiArCQkua2V5Yml0 ID0geyBbQklUX1dPUkQoS0VZX0VTQyldID0gQklUX01BU0soS0VZX0VTQykgfSwKPiArCX0sIC8q IGtleWJvYXJkICovCj4gKwl7Cj4gKwkJLmZsYWdzID0gSU5QVVRfREVWSUNFX0lEX01BVENIX0VW QklUIHwKPiArCQkJCUlOUFVUX0RFVklDRV9JRF9NQVRDSF9LRVlCSVQsCj4gKwkJLmV2Yml0ID0g eyBCSVRfTUFTSyhFVl9LRVkpIH0sCj4gKwkJLmtleWJpdCA9IHtbQklUX1dPUkQoQlROX0pPWVNU SUNLKV0gPSBCSVRfTUFTSyhCVE5fSk9ZU1RJQ0spIH0sCj4gKwl9LCAvKiBqb3lzdGlja3Mgbm90 IGNhdWdodCBieSBBQlNfWCBhYm92ZSAqLwo+ICsJewo+ICsJCS5mbGFncyA9IElOUFVUX0RFVklD RV9JRF9NQVRDSF9FVkJJVCB8Cj4gKwkJCQlJTlBVVF9ERVZJQ0VfSURfTUFUQ0hfS0VZQklULAo+ ICsJCS5ldmJpdCA9IHsgQklUX01BU0soRVZfS0VZKSB9LAo+ICsJCS5rZXliaXQgPSB7IFtCSVRf V09SRChCVE5fR0FNRVBBRCldID0gQklUX01BU0soQlROX0dBTUVQQUQpIH0sCj4gKwl9LCAvKiBn YW1lcGFkICovCj4gKwl7IH0sCj4gK307Cj4gKwo+ICAvKioKPiAgICogcm9ja2NoaXBfZHJtX3Bz cl9yZWdpc3RlciAtIHJlZ2lzdGVyIGVuY29kZXIgdG8gcHNyIGRyaXZlcgo+ICAgKiBAZW5jb2Rl cjogZW5jb2RlciB0aGF0IG9idGFpbiB0aGUgUFNSIGZ1bmN0aW9uCj4gQEAgLTIzOSw2ICszNDYs NyBAQCBpbnQgcm9ja2NoaXBfZHJtX3Bzcl9yZWdpc3RlcihzdHJ1Y3QgZHJtX2VuY29kZXIgKmVu Y29kZXIsCj4gIHsKPiAgCXN0cnVjdCByb2NrY2hpcF9kcm1fcHJpdmF0ZSAqZHJtX2RydiA9IGVu Y29kZXItPmRldi0+ZGV2X3ByaXZhdGU7Cj4gIAlzdHJ1Y3QgcHNyX2RydiAqcHNyOwo+ICsJaW50 IGVycm9yOwo+ICAKPiAgCWlmICghZW5jb2RlciB8fCAhcHNyX3NldCkKPiAgCQlyZXR1cm4gLUVJ TlZBTDsKPiBAQCAtMjQ4LDYgKzM1Niw3IEBAIGludCByb2NrY2hpcF9kcm1fcHNyX3JlZ2lzdGVy KHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2RlciwKPiAgCQlyZXR1cm4gLUVOT01FTTsKPiAgCj4g IAlJTklUX0RFTEFZRURfV09SSygmcHNyLT5mbHVzaF93b3JrLCBwc3JfZmx1c2hfaGFuZGxlcik7 Cj4gKwlJTklUX1dPUksoJnBzci0+ZGlzYWJsZV93b3JrLCBwc3JfZGlzYWJsZV9oYW5kbGVyKTsK PiAgCW11dGV4X2luaXQoJnBzci0+bG9jayk7Cj4gIAo+ICAJcHNyLT5hY3RpdmUgPSB0cnVlOwo+ IEBAIC0yNTUsMTEgKzM2NCwzMyBAQCBpbnQgcm9ja2NoaXBfZHJtX3Bzcl9yZWdpc3RlcihzdHJ1 Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsCj4gIAlwc3ItPmVuY29kZXIgPSBlbmNvZGVyOwo+ICAJ cHNyLT5zZXQgPSBwc3Jfc2V0Owo+ICAKPiArCXBzci0+aW5wdXRfaGFuZGxlci5ldmVudCA9IHBz cl9pbnB1dF9ldmVudDsKPiArCXBzci0+aW5wdXRfaGFuZGxlci5jb25uZWN0ID0gcHNyX2lucHV0 X2Nvbm5lY3Q7Cj4gKwlwc3ItPmlucHV0X2hhbmRsZXIuZGlzY29ubmVjdCA9IHBzcl9pbnB1dF9k aXNjb25uZWN0Owo+ICsJcHNyLT5pbnB1dF9oYW5kbGVyLm5hbWUgPQo+ICsJCWthc3ByaW50ZihH RlBfS0VSTkVMLCAicm9ja2NoaXAtcHNyLSVzIiwgZW5jb2Rlci0+bmFtZSk7Cj4gKwlpZiAoIXBz ci0+aW5wdXRfaGFuZGxlci5uYW1lKSB7Cj4gKwkJZXJyb3IgPSAtRU5PTUVNOwo+ICsJCWdvdG8g ZXJyMjsKPiArCX0KPiArCXBzci0+aW5wdXRfaGFuZGxlci5pZF90YWJsZSA9IHBzcl9pZHM7Cj4g Kwlwc3ItPmlucHV0X2hhbmRsZXIucHJpdmF0ZSA9IHBzcjsKPiArCj4gKwllcnJvciA9IGlucHV0 X3JlZ2lzdGVyX2hhbmRsZXIoJnBzci0+aW5wdXRfaGFuZGxlcik7Cj4gKwlpZiAoZXJyb3IpCj4g KwkJZ290byBlcnIxOwo+ICsKPiAgCW11dGV4X2xvY2soJmRybV9kcnYtPnBzcl9saXN0X2xvY2sp Owo+ICAJbGlzdF9hZGRfdGFpbCgmcHNyLT5saXN0LCAmZHJtX2Rydi0+cHNyX2xpc3QpOwo+ICAJ bXV0ZXhfdW5sb2NrKCZkcm1fZHJ2LT5wc3JfbGlzdF9sb2NrKTsKPiAgCj4gIAlyZXR1cm4gMDsK PiArCj4gKyBlcnIxOgo+ICsJa2ZyZWUocHNyLT5pbnB1dF9oYW5kbGVyLm5hbWUpOwo+ICsgZXJy MjoKPiArCWtmcmVlKHBzcik7Cj4gKwlyZXR1cm4gZXJyb3I7Cj4gIH0KPiAgRVhQT1JUX1NZTUJP TChyb2NrY2hpcF9kcm1fcHNyX3JlZ2lzdGVyKTsKPiAgCj4gQEAgLTI3OSw4ICs0MTAsMTEgQEAg dm9pZCByb2NrY2hpcF9kcm1fcHNyX3VucmVnaXN0ZXIoc3RydWN0IGRybV9lbmNvZGVyICplbmNv ZGVyKQo+ICAJbXV0ZXhfbG9jaygmZHJtX2Rydi0+cHNyX2xpc3RfbG9jayk7Cj4gIAlsaXN0X2Zv cl9lYWNoX2VudHJ5X3NhZmUocHNyLCBuLCAmZHJtX2Rydi0+cHNyX2xpc3QsIGxpc3QpIHsKPiAg CQlpZiAocHNyLT5lbmNvZGVyID09IGVuY29kZXIpIHsKPiArCQkJaW5wdXRfdW5yZWdpc3Rlcl9o YW5kbGVyKCZwc3ItPmlucHV0X2hhbmRsZXIpOwo+ICAJCQljYW5jZWxfZGVsYXllZF93b3JrX3N5 bmMoJnBzci0+Zmx1c2hfd29yayk7Cj4gKwkJCWNhbmNlbF93b3JrX3N5bmMoJnBzci0+ZGlzYWJs ZV93b3JrKTsKPiAgCQkJbGlzdF9kZWwoJnBzci0+bGlzdCk7Cj4gKwkJCWtmcmVlKHBzci0+aW5w dXRfaGFuZGxlci5uYW1lKTsKPiAgCQkJa2ZyZWUocHNyKTsKPiAgCQl9Cj4gIAl9CgoKX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxp bmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJl ZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: a.hajda@samsung.com (Andrzej Hajda) Date: Mon, 16 Apr 2018 09:19:21 +0200 Subject: [PATCH v6 24/30] drm/rockchip: Disable PSR on input events In-Reply-To: <20180405095000.9756-25-enric.balletbo@collabora.com> References: <20180405095000.9756-1-enric.balletbo@collabora.com> <20180405095000.9756-25-enric.balletbo@collabora.com> Message-ID: <20d2aa03-63e3-0072-5ca7-5f3ca42c3c9e@samsung.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org +CC: linux-input list and maintainer On 05.04.2018 11:49, Enric Balletbo i Serra wrote: > From: "Kristian H. Kristensen" > > To improve PSR exit latency, we speculatively start exiting when we > receive input events. Occasionally, this may lead to false positives, > but most of the time we get a head start on coming out of PSR. Depending > on how userspace takes to produce a new frame in response to the event, > this can completely hide the exit latency. In case of Chrome OS, we > typically get the input notifier 50ms or more before the dirty_fb > triggered exit. As I see from the code below, you just need notification from input subsystem on user activity. Maybe there is some simpler notification mechanism for such things? If not, maybe such helper should be created in input subsystem, I suppose it could be reused in other places as well. Regards Andrzej > > Signed-off-by: Kristian H. Kristensen > Signed-off-by: Thierry Escande > Signed-off-by: Enric Balletbo i Serra > Tested-by: Marek Szyprowski > --- > > drivers/gpu/drm/rockchip/rockchip_drm_psr.c | 134 ++++++++++++++++++++++++++++ > 1 file changed, 134 insertions(+) > > diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_psr.c b/drivers/gpu/drm/rockchip/rockchip_drm_psr.c > index 9376f4396b6b..a107845ba97c 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_drm_psr.c > +++ b/drivers/gpu/drm/rockchip/rockchip_drm_psr.c > @@ -12,6 +12,8 @@ > * GNU General Public License for more details. > */ > > +#include > + > #include > #include > > @@ -35,6 +37,9 @@ struct psr_drv { > enum psr_state state; > > struct delayed_work flush_work; > + struct work_struct disable_work; > + > + struct input_handler input_handler; > > int (*set)(struct drm_encoder *encoder, bool enable); > }; > @@ -133,6 +138,18 @@ static void psr_flush_handler(struct work_struct *work) > mutex_unlock(&psr->lock); > } > > +static void psr_disable_handler(struct work_struct *work) > +{ > + struct psr_drv *psr = container_of(work, struct psr_drv, disable_work); > + > + /* If the state has changed since we initiated the flush, do nothing */ > + mutex_lock(&psr->lock); > + if (psr->state == PSR_ENABLE) > + psr_set_state_locked(psr, PSR_FLUSH); > + mutex_unlock(&psr->lock); > + mod_delayed_work(system_wq, &psr->flush_work, PSR_FLUSH_TIMEOUT_MS); > +} > + > /** > * rockchip_drm_psr_activate - activate PSR on the given pipe > * @encoder: encoder to obtain the PSR encoder > @@ -173,6 +190,7 @@ int rockchip_drm_psr_deactivate(struct drm_encoder *encoder) > psr->active = false; > mutex_unlock(&psr->lock); > cancel_delayed_work_sync(&psr->flush_work); > + cancel_work_sync(&psr->disable_work); > > return 0; > } > @@ -226,6 +244,95 @@ void rockchip_drm_psr_flush_all(struct drm_device *dev) > } > EXPORT_SYMBOL(rockchip_drm_psr_flush_all); > > +static void psr_input_event(struct input_handle *handle, > + unsigned int type, unsigned int code, > + int value) > +{ > + struct psr_drv *psr = handle->handler->private; > + > + schedule_work(&psr->disable_work); > +} > + > +static int psr_input_connect(struct input_handler *handler, > + struct input_dev *dev, > + const struct input_device_id *id) > +{ > + struct input_handle *handle; > + int error; > + > + handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL); > + if (!handle) > + return -ENOMEM; > + > + handle->dev = dev; > + handle->handler = handler; > + handle->name = "rockchip-psr"; > + > + error = input_register_handle(handle); > + if (error) > + goto err2; > + > + error = input_open_device(handle); > + if (error) > + goto err1; > + > + return 0; > + > +err1: > + input_unregister_handle(handle); > +err2: > + kfree(handle); > + return error; > +} > + > +static void psr_input_disconnect(struct input_handle *handle) > +{ > + input_close_device(handle); > + input_unregister_handle(handle); > + kfree(handle); > +} > + > +/* Same device ids as cpu-boost */ > +static const struct input_device_id psr_ids[] = { > + { > + .flags = INPUT_DEVICE_ID_MATCH_EVBIT | > + INPUT_DEVICE_ID_MATCH_ABSBIT, > + .evbit = { BIT_MASK(EV_ABS) }, > + .absbit = { [BIT_WORD(ABS_MT_POSITION_X)] = > + BIT_MASK(ABS_MT_POSITION_X) | > + BIT_MASK(ABS_MT_POSITION_Y) }, > + }, /* multi-touch touchscreen */ > + { > + .flags = INPUT_DEVICE_ID_MATCH_EVBIT, > + .evbit = { BIT_MASK(EV_ABS) }, > + .absbit = { [BIT_WORD(ABS_X)] = BIT_MASK(ABS_X) } > + > + }, /* stylus or joystick device */ > + { > + .flags = INPUT_DEVICE_ID_MATCH_EVBIT, > + .evbit = { BIT_MASK(EV_KEY) }, > + .keybit = { [BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) }, > + }, /* pointer (e.g. trackpad, mouse) */ > + { > + .flags = INPUT_DEVICE_ID_MATCH_EVBIT, > + .evbit = { BIT_MASK(EV_KEY) }, > + .keybit = { [BIT_WORD(KEY_ESC)] = BIT_MASK(KEY_ESC) }, > + }, /* keyboard */ > + { > + .flags = INPUT_DEVICE_ID_MATCH_EVBIT | > + INPUT_DEVICE_ID_MATCH_KEYBIT, > + .evbit = { BIT_MASK(EV_KEY) }, > + .keybit = {[BIT_WORD(BTN_JOYSTICK)] = BIT_MASK(BTN_JOYSTICK) }, > + }, /* joysticks not caught by ABS_X above */ > + { > + .flags = INPUT_DEVICE_ID_MATCH_EVBIT | > + INPUT_DEVICE_ID_MATCH_KEYBIT, > + .evbit = { BIT_MASK(EV_KEY) }, > + .keybit = { [BIT_WORD(BTN_GAMEPAD)] = BIT_MASK(BTN_GAMEPAD) }, > + }, /* gamepad */ > + { }, > +}; > + > /** > * rockchip_drm_psr_register - register encoder to psr driver > * @encoder: encoder that obtain the PSR function > @@ -239,6 +346,7 @@ int rockchip_drm_psr_register(struct drm_encoder *encoder, > { > struct rockchip_drm_private *drm_drv = encoder->dev->dev_private; > struct psr_drv *psr; > + int error; > > if (!encoder || !psr_set) > return -EINVAL; > @@ -248,6 +356,7 @@ int rockchip_drm_psr_register(struct drm_encoder *encoder, > return -ENOMEM; > > INIT_DELAYED_WORK(&psr->flush_work, psr_flush_handler); > + INIT_WORK(&psr->disable_work, psr_disable_handler); > mutex_init(&psr->lock); > > psr->active = true; > @@ -255,11 +364,33 @@ int rockchip_drm_psr_register(struct drm_encoder *encoder, > psr->encoder = encoder; > psr->set = psr_set; > > + psr->input_handler.event = psr_input_event; > + psr->input_handler.connect = psr_input_connect; > + psr->input_handler.disconnect = psr_input_disconnect; > + psr->input_handler.name = > + kasprintf(GFP_KERNEL, "rockchip-psr-%s", encoder->name); > + if (!psr->input_handler.name) { > + error = -ENOMEM; > + goto err2; > + } > + psr->input_handler.id_table = psr_ids; > + psr->input_handler.private = psr; > + > + error = input_register_handler(&psr->input_handler); > + if (error) > + goto err1; > + > mutex_lock(&drm_drv->psr_list_lock); > list_add_tail(&psr->list, &drm_drv->psr_list); > mutex_unlock(&drm_drv->psr_list_lock); > > return 0; > + > + err1: > + kfree(psr->input_handler.name); > + err2: > + kfree(psr); > + return error; > } > EXPORT_SYMBOL(rockchip_drm_psr_register); > > @@ -279,8 +410,11 @@ void rockchip_drm_psr_unregister(struct drm_encoder *encoder) > mutex_lock(&drm_drv->psr_list_lock); > list_for_each_entry_safe(psr, n, &drm_drv->psr_list, list) { > if (psr->encoder == encoder) { > + input_unregister_handler(&psr->input_handler); > cancel_delayed_work_sync(&psr->flush_work); > + cancel_work_sync(&psr->disable_work); > list_del(&psr->list); > + kfree(psr->input_handler.name); > kfree(psr); > } > }