From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from smtp3.osuosl.org (smtp3.osuosl.org [140.211.166.136]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 919EFC25B47 for ; Wed, 25 Oct 2023 10:21:22 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp3.osuosl.org (Postfix) with ESMTP id 1398D70498; Wed, 25 Oct 2023 10:21:22 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp3.osuosl.org 1398D70498 Authentication-Results: smtp3.osuosl.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=UZlwvjUS X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp3.osuosl.org ([127.0.0.1]) by localhost (smtp3.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 2i4wYl8TEdQH; Wed, 25 Oct 2023 10:21:20 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [IPv6:2605:bc80:3010:104::8cd3:938]) by smtp3.osuosl.org (Postfix) with ESMTPS id 4979D70426; Wed, 25 Oct 2023 10:21:20 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp3.osuosl.org 4979D70426 Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 1E0BBC0071; Wed, 25 Oct 2023 10:21:20 +0000 (UTC) Received: from smtp3.osuosl.org (smtp3.osuosl.org [IPv6:2605:bc80:3010::136]) by lists.linuxfoundation.org (Postfix) with ESMTP id DE705C0071 for ; Wed, 25 Oct 2023 10:21:18 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp3.osuosl.org (Postfix) with ESMTP id AC87B70426 for ; Wed, 25 Oct 2023 10:21:18 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp3.osuosl.org AC87B70426 X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp3.osuosl.org ([127.0.0.1]) by localhost (smtp3.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id MM-d_JzxY3Fw for ; Wed, 25 Oct 2023 10:21:17 +0000 (UTC) Received: from mail-pf1-x433.google.com (mail-pf1-x433.google.com [IPv6:2607:f8b0:4864:20::433]) by smtp3.osuosl.org (Postfix) with ESMTPS id 1B91F60674 for ; Wed, 25 Oct 2023 10:21:16 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp3.osuosl.org 1B91F60674 Received: by mail-pf1-x433.google.com with SMTP id d2e1a72fcca58-6b709048d8eso4418627b3a.2 for ; Wed, 25 Oct 2023 03:21:16 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1698229276; x=1698834076; darn=lists.linuxfoundation.org; h=content-transfer-encoding:in-reply-to:from:content-language :references:cc:to:subject:user-agent:mime-version:date:message-id :from:to:cc:subject:date:message-id:reply-to; bh=SDsqw0sXkcqQTP0sCa4Jkp7YyhsxVpWNPP+SpDa1yZw=; b=UZlwvjUSbwt2T7STeUrj9Wusb2PobYy+3cAksj6ar/mrgtYSHS1MnCbvfOgc0vHT5w e47zLhs34ibukDekFOBXAPfuaUo2Vs08GkOjxNoJW7qVsBTS37tAYjFMZM0uVr/v6kkB f3XythvHe0M0SyhIlFiMUV6Ln6ApQIo+RLiYuRC+hLD2t+qu28scyeqMadSzXZbqWMQq tirzMM0J+Dc/fsWUVGM8kKTsaBDgrVPdz02UEx4rgEyXmT698edqMVnOG/xFllZXFgH6 iHkAmpjJ1dZcjL2IU9lOsYS40ZHatXU46NpWey1WZYbH1gHp2dp8lTRfA81UeuK78+e3 OG5w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698229276; x=1698834076; h=content-transfer-encoding:in-reply-to:from:content-language :references:cc:to:subject:user-agent:mime-version:date:message-id :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=SDsqw0sXkcqQTP0sCa4Jkp7YyhsxVpWNPP+SpDa1yZw=; b=gHlANKzgJ62djsE0DrN+KWnCs0icDD+ennaR8ZQFG38rKAgvsEwd00XYuUoTZR2+zB fGFHPjxEpITLEQPt2MC6ZNDKW8is/LfQoA3PxyLpWbzk+52YbUCBmIJyEVCtOp8NFacq ojY8GL5LJwH/crfN6jsEhqHtWBDJbd2zksB8ONHgd6ahjo+98fveAVx25dMFyW18e1ES HxjsMZ/t+y+Tj8TiEXp6SzdDoIU9F/7Jh1TiSYQPU3gZTEicy0VsYC/Hr1M2mdm0v7aa /z//BovfSmAvHFe6c5p5kXu2LvVaaOXxnk3RNL1aQiOB/SWJwZfQ1DRHiWUA+1R5iWhN jBlg== X-Gm-Message-State: AOJu0Yy0/UQEvOtO+tXVa/MY/i6wPj3q5ZeDF/rGcBnzlazFYcoaH/Xi 9TeLKUZg9wI4ef/gny42elM= X-Google-Smtp-Source: AGHT+IH9yiMfJqlyqVWm1XKh6cflreVosWhbEfsZ/kiLIaq/2Tu34NO9j5LGH3M2R0l95i7g8f7Cow== X-Received: by 2002:a05:6a21:1506:b0:17a:f2ed:e921 with SMTP id nq6-20020a056a21150600b0017af2ede921mr5397424pzb.55.1698229276129; Wed, 25 Oct 2023 03:21:16 -0700 (PDT) Received: from [10.5.209.17] ([59.152.80.69]) by smtp.gmail.com with ESMTPSA id y3-20020a1709029b8300b001b81a97860asm8834554plp.27.2023.10.25.03.21.13 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Wed, 25 Oct 2023 03:21:15 -0700 (PDT) Message-ID: Date: Wed, 25 Oct 2023 15:50:04 +0530 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v5 2/2] input: joystick: driver for Adafruit Seesaw Gamepad To: Jeff LaBundy References: <20231017034356.1436677-1-anshulusr@gmail.com> <20231017034356.1436677-2-anshulusr@gmail.com> Content-Language: en-US From: Anshul Dalal In-Reply-To: Cc: devicetree@vger.kernel.org, Conor Dooley , Dmitry Torokhov , =?UTF-8?Q?Thomas_Wei=C3=9Fschuh?= , linux-kernel@vger.kernel.org, Rob Herring , Krzysztof Kozlowski , linux-input@vger.kernel.org, linux-kernel-mentees@lists.linuxfoundation.org X-BeenThere: linux-kernel-mentees@lists.linuxfoundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: linux-kernel-mentees-bounces@lists.linuxfoundation.org Sender: "Linux-kernel-mentees" SGVsbG8gSmVmZiwKVGhhbmtzIGZvciB0aGUgcmV2aWV3LCBJIHBsYW4gb24gYWRkcmVzc2luZyB0 aGUgY2hhbmdlcyB5b3UgcmVxdWVzdGVkIGluCnRoZSBuZXh0IHZlcnNpb24gb2YgdGhlIHBhdGNo LiBUaG91Z2ggSSBoYWQgYSBmZXcgcXVlc3Rpb25zOgoKT24gMTAvMjMvMjMgMDU6MTIsIEplZmYg TGFCdW5keSB3cm90ZToKPiBIaSBBbnNodWwsCj4gCj4gT24gVHVlLCBPY3QgMTcsIDIwMjMgYXQg MDk6MTM6NDVBTSArMDUzMCwgQW5zaHVsIERhbGFsIHdyb3RlOgo+PiBBZGRzIGEgZHJpdmVyIGZv ciBhIG1pbmkgZ2FtZXBhZCB0aGF0IGNvbW11bmljYXRlcyBvdmVyIGkyYywgdGhlIGdhbWVwYWQK Pj4gaGFzIGJpZGlyZWN0aW9uYWwgdGh1bWIgc3RpY2sgaW5wdXQgYW5kIHNpeCBidXR0b25zLgo+ Pgo+PiBUaGUgZ2FtZXBhZCBjaGlwIHV0aWxpemVzIHRoZSBvcGVuIGZyYW1ld29yayBmcm9tIEFk YWZydWl0IGNhbGxlZCAnU2Vlc2F3Jwo+PiB0byB0cmFuc21pdCB0aGUgQURDIGRhdGEgZm9yIHRo ZSBqb3lzdGljayBhbmQgZGlnaXRhbCBwaW4gc3RhdGUgZm9yIHRoZQo+PiBidXR0b25zLiBJIGhh dmUgb25seSBpbXBsZW1lbnRlZCB0aGUgZnVuY3Rpb25hbGl0eSByZXF1aXJlZCB0byByZWNlaXZl IHRoZQo+PiB0aHVtYiBzdGljayBhbmQgYnV0dG9uIHN0YXRlLgo+Pgo+PiBTdGVwcyBpbiByZWFk aW5nIHRoZSBnYW1lcGFkIHN0YXRlIG92ZXIgaTJjOgo+PiAgIDEuIFJlc2V0IHRoZSByZWdpc3Rl cnMKPj4gICAyLiBTZXQgdGhlIHBpbiBtb2RlIG9mIHRoZSBwaW5zIHNwZWNpZmllZCBieSB0aGUg YEJVVFRPTl9NQVNLYCB0byBpbnB1dAo+PiAgICAgICBgQlVUVE9OX01BU0tgOiBBIGJpdC1tYXAg Zm9yIHRoZSBzaXggZGlnaXRhbCBwaW5zIGludGVybmFsbHkKPj4gICAgICAgIGNvbm5lY3RlZCB0 byB0aGUgam95c3RpY2sgYnV0dG9ucy4KPj4gICAzLiBFbmFibGUgaW50ZXJuYWwgcHVsbHVwIHJl c2lzdG9ycyBmb3IgdGhlIGBCVVRUT05fTUFTS2AKPj4gICA0LiBCdWxrIHNldCB0aGUgcGluIHN0 YXRlIEhJR0ggZm9yIGBCVVRUT05fTUFTS2AKPj4gICA1LiBQb2xsIHRoZSBkZXZpY2UgZm9yIGJ1 dHRvbiBhbmQgam95c3RpY2sgc3RhdGUgZG9uZSBieToKPj4gICAgICAgYHNlZXNhd19yZWFkX2Rh dGEoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgc3RydWN0IHNlZXNhd19kYXRhICpkYXRhKWAK Pj4KPj4gUHJvZHVjdCBwYWdlOgo+PiAgIGh0dHBzOi8vd3d3LmFkYWZydWl0LmNvbS9wcm9kdWN0 LzU3NDMKPj4gQXJkdWlubyBkcml2ZXI6Cj4+ICAgaHR0cHM6Ly9naXRodWIuY29tL2FkYWZydWl0 L0FkYWZydWl0X1NlZXNhdwo+Pgo+PiBEcml2ZXIgdGVzdGVkIG9uIFJQaSBaZXJvIDJXCj4+Cj4+ IFJldmlld2VkLWJ5OiBUaG9tYXMgV2Vpw59zY2h1aCA8bGludXhAd2Vpc3NzY2h1aC5uZXQ+Cj4+ IFNpZ25lZC1vZmYtYnk6IEFuc2h1bCBEYWxhbCA8YW5zaHVsdXNyQGdtYWlsLmNvbT4KPj4gLS0t Cj4+Cj4+IENoYW5nZXMgZm9yIHY1Ogo+PiAtIEFkZGVkIGxpbmsgdG8gdGhlIGRhdGFzaGVldAo+ PiAtIEFkZGVkIGRlYnVnIGxvZyBtZXNzYWdlIHdoZW4gYHNlZXNhd19yZWFkX2RhdGFgIGZhaWxz Cj4+Cj4+IENoYW5nZXMgZm9yIHY0Ogo+PiAtIENoYW5nZWQgYDFVTCA8PCBCVVRUT05fYCB0byBC SVQoQlVUVE9OXykKPj4gLSBSZW1vdmVkIGBoYXJkd2FyZV9pZGAgZmllbGQgZnJvbSBgc3RydWN0 IHNlZXNhd19nYW1lcGFkYAo+PiAtIFJlbW92ZWQgcmVkdW5kYW50IGNoZWNrcyBmb3IgdGhlIG51 bWJlciBvZiBieXRlcyB3cml0dGVuIGFuZCByZWNlaXZlZCBieQo+PiAgIGBpMmNfbWFzdGVyX3Nl bmRgIGFuZCBgaTJjX21hc3Rlcl9yZWN2YAo+PiAtIFVzZWQgYGdldF91bmFsaWduZWRfYmUzMmAg dG8gaW5zdGFudGlhdGUgYHUzMiByZXN1bHRgIGZyb20gYHJlYWRfYnVmYAo+PiAtIENoYW5nZWQg IGByZXN1bHQgJiAoMVVMIDw8IEJVVFRPTl8pYCB0bwo+PiAgIGB0ZXN0X2JpdChCVVRUT05fLCAo bG9uZyAqKSZyZXN1bHQpYAo+PiAtIENoYW5nZWQgYEtCVUlMRF9NT0ROQU1FYCBpbiBpZC10YWJs ZXMgdG8gYFNFRVNBV19ERVZJQ0VfTkFNRWAKPj4gLSBGaXhlZCBmb3JtYXR0aW5nIGlzc3Vlcwo+ PiAtIENoYW5nZWQgYnV0dG9uIHJlcG9ydGluZzoKPj4gICAgIFNpbmNlIHRoZSBnYW1lcGFkIGhh ZCB0aGUgYWN0aW9uIGJ1dHRvbnMgaW4gYSBub24tc3RhbmRhcmQgbGF5b3V0Ogo+PiAgICAgICAg ICAoWCkKPj4gICAgICAgKFkpICAgKEEpCj4+ICAgICAgICAgIChCKQo+PiAgICAgVGhlcmVmb3Jl IG1vdmVkIHRvIHVzaW5nIGdlbmVyaWMgZGlyZWN0aW9uYWwgYWN0aW9uIGJ1dHRvbiBldmVudCBj b2Rlcwo+PiAgICAgaW5zdGVhZCBvZiBCVE5fW0FCWFldLgo+Pgo+PiBDaGFuZ2VzIGZvciB2MzoK Pj4gLSBubyB1cGRhdGVzCj4+Cj4+IENoYW5nZXMgZm9yIHYyOgo+PiBhZGFmcnVpdC1zZWVzYXcu YzoKPj4gLSBSZW5hbWVkIGZpbGUgZnJvbSAnYWRhZnJ1aXRfc2Vlc2F3LmMnCj4+IC0gQ2hhbmdl ZCBkZXZpY2UgbmFtZSBmcm9tICdzZWVzYXdfZ2FtZXBhZCcgdG8gJ3NlZXNhdy1nYW1lcGFkJwo+ PiAtIENoYW5nZWQgY291bnQgcGFyYW1ldGVyIGZvciByZWNlaXZpbmcgam95c3RpY2sgeCBvbiBs aW5lIDExODoKPj4gICAgIGAyYCB0byBgc2l6ZW9mKHdyaXRlX2J1ZilgCj4+IC0gRml4ZWQgaW52 YWxpZCBidWZmZXIgc2l6ZSBvbiBsaW5lIDEyMyBhbmQgMTI2Ogo+PiAgICAgYGRhdGEtPnlgIHRv IGBzaXplb2YoZGF0YS0+eSlgCj4+IC0gQWRkZWQgY29tbWVudCBmb3IgdGhlIGBtZGVsYXkoMTAp YCBvbiBsaW5lIDE2OQo+PiAtIENoYW5nZWQgaW5jb25zaXN0ZW50IGluZGVudGF0aW9uIG9uIGxp bmUgMjcxCj4+IEtjb25maWc6Cj4+IC0gRml4ZWQgaW5kZW50YXRpb24gZm9yIHRoZSBoZWxwIHRl eHQKPj4gLSBVcGRhdGVkIG1vZHVsZSBuYW1lCj4+IE1ha2VmaWxlOgo+PiAtIFVwZGF0ZWQgbW9k dWxlIG9iamVjdCBmaWxlIG5hbWUKPj4gTUFJTlRBSU5FUlM6Cj4+IC0gVXBkYXRlZCBmaWxlIG5h bWUgZm9yIHRoZSBkcml2ZXIgYW5kIGJpbmRpbmdzCj4+Cj4+ICBNQUlOVEFJTkVSUyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgICA3ICsKPj4gIGRyaXZlcnMvaW5wdXQvam95c3RpY2sv S2NvbmZpZyAgICAgICAgICAgfCAgIDkgKwo+PiAgZHJpdmVycy9pbnB1dC9qb3lzdGljay9NYWtl ZmlsZSAgICAgICAgICB8ICAgMSArCj4+ICBkcml2ZXJzL2lucHV0L2pveXN0aWNrL2FkYWZydWl0 LXNlZXNhdy5jIHwgMjczICsrKysrKysrKysrKysrKysrKysrKysrCj4+ICA0IGZpbGVzIGNoYW5n ZWQsIDI5MCBpbnNlcnRpb25zKCspCj4+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9pbnB1 dC9qb3lzdGljay9hZGFmcnVpdC1zZWVzYXcuYwo+Pgo+PiBkaWZmIC0tZ2l0IGEvTUFJTlRBSU5F UlMgYi9NQUlOVEFJTkVSUwo+PiBpbmRleCA2YzRjY2U0NWEwOWQuLmEzMTRmOWI0OGUyMSAxMDA2 NDQKPj4gLS0tIGEvTUFJTlRBSU5FUlMKPj4gKysrIGIvTUFJTlRBSU5FUlMKPj4gQEAgLTQ0MSw2 ICs0NDEsMTMgQEAgVzoJaHR0cDovL3dpa2kuYW5hbG9nLmNvbS9BRDc4NzkKPj4gIFc6CWh0dHBz Oi8vZXouYW5hbG9nLmNvbS9saW51eC1zb2Z0d2FyZS1kcml2ZXJzCj4+ICBGOglkcml2ZXJzL2lu cHV0L3RvdWNoc2NyZWVuL2FkNzg3OS5jCj4+ICAKPj4gK0FEQUZSVUlUIE1JTkkgSTJDIEdBTUVQ QUQKPj4gK006CUFuc2h1bCBEYWxhbCA8YW5zaHVsdXNyQGdtYWlsLmNvbT4KPj4gK0w6CWxpbnV4 LWlucHV0QHZnZXIua2VybmVsLm9yZwo+PiArUzoJTWFpbnRhaW5lZAo+PiArRjoJRG9jdW1lbnRh dGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2lucHV0L2FkYWZydWl0LHNlZXNhdy1nYW1lcGFkLnlh bWwKPj4gK0Y6CWRyaXZlcnMvaW5wdXQvam95c3RpY2svYWRhZnJ1aXQtc2Vlc2F3LmMKPj4gKwo+ PiAgQUREUkVTUyBTUEFDRSBMQVlPVVQgUkFORE9NSVpBVElPTiAoQVNMUikKPj4gIE06CUppcmkg S29zaW5hIDxqaWtvc0BrZXJuZWwub3JnPgo+PiAgUzoJTWFpbnRhaW5lZAo+PiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy9pbnB1dC9qb3lzdGljay9LY29uZmlnIGIvZHJpdmVycy9pbnB1dC9qb3lzdGlj ay9LY29uZmlnCj4+IGluZGV4IGFjNjkyNWNlODM2Ni4uZGY5Y2QxODMwYjI5IDEwMDY0NAo+PiAt LS0gYS9kcml2ZXJzL2lucHV0L2pveXN0aWNrL0tjb25maWcKPj4gKysrIGIvZHJpdmVycy9pbnB1 dC9qb3lzdGljay9LY29uZmlnCj4+IEBAIC00MTIsNCArNDEyLDEzIEBAIGNvbmZpZyBKT1lTVElD S19TRU5TRUhBVAo+PiAgCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hv b3NlIE0gaGVyZTogdGhlCj4+ICAJICBtb2R1bGUgd2lsbCBiZSBjYWxsZWQgc2Vuc2VoYXRfam95 c3RpY2suCj4+ICAKPj4gK2NvbmZpZyBKT1lTVElDS19TRUVTQVcKPj4gKwl0cmlzdGF0ZSAiQWRh ZnJ1aXQgTWluaSBJMkMgR2FtZXBhZCB3aXRoIFNlZXNhdyIKPj4gKwlkZXBlbmRzIG9uIEkyQwo+ PiArCWhlbHAKPj4gKwkgIFNheSBZIGhlcmUgaWYgeW91IHdhbnQgdG8gdXNlIHRoZSBBZGFmcnVp dCBNaW5pIEkyQyBHYW1lcGFkLgo+PiArCj4+ICsJICBUbyBjb21waWxlIHRoaXMgZHJpdmVyIGFz IGEgbW9kdWxlLCBjaG9vc2UgTSBoZXJlOiB0aGUgbW9kdWxlIHdpbGwgYmUKPj4gKwkgIGNhbGxl ZCBhZGFmcnVpdC1zZWVzYXcuCj4+ICsKPj4gIGVuZGlmCj4+IGRpZmYgLS1naXQgYS9kcml2ZXJz L2lucHV0L2pveXN0aWNrL01ha2VmaWxlIGIvZHJpdmVycy9pbnB1dC9qb3lzdGljay9NYWtlZmls ZQo+PiBpbmRleCAzOTM3NTM1ZjAwOTguLjk5NzZmNTk2YTkyMCAxMDA2NDQKPj4gLS0tIGEvZHJp dmVycy9pbnB1dC9qb3lzdGljay9NYWtlZmlsZQo+PiArKysgYi9kcml2ZXJzL2lucHV0L2pveXN0 aWNrL01ha2VmaWxlCj4+IEBAIC0yOCw2ICsyOCw3IEBAIG9iai0kKENPTkZJR19KT1lTVElDS19O NjQpCQkrPSBuNjRqb3kubwo+PiAgb2JqLSQoQ09ORklHX0pPWVNUSUNLX1BTWFBBRF9TUEkpCSs9 IHBzeHBhZC1zcGkubwo+PiAgb2JqLSQoQ09ORklHX0pPWVNUSUNLX1BYUkMpCQkrPSBweHJjLm8K Pj4gIG9iai0kKENPTkZJR19KT1lTVElDS19RV0lJQykJCSs9IHF3aWljLWpveXN0aWNrLm8KPj4g K29iai0kKENPTkZJR19KT1lTVElDS19TRUVTQVcpCQkrPSBhZGFmcnVpdC1zZWVzYXcubwo+PiAg b2JqLSQoQ09ORklHX0pPWVNUSUNLX1NFTlNFSEFUKQkrPSBzZW5zZWhhdC1qb3lzdGljay5vCj4+ ICBvYmotJChDT05GSUdfSk9ZU1RJQ0tfU0lERVdJTkRFUikJKz0gc2lkZXdpbmRlci5vCj4+ICBv YmotJChDT05GSUdfSk9ZU1RJQ0tfU1BBQ0VCQUxMKQkrPSBzcGFjZWJhbGwubwo+PiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9pbnB1dC9qb3lzdGljay9hZGFmcnVpdC1zZWVzYXcuYyBiL2RyaXZlcnMv aW5wdXQvam95c3RpY2svYWRhZnJ1aXQtc2Vlc2F3LmMKPj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQK Pj4gaW5kZXggMDAwMDAwMDAwMDAwLi4yYTFlYWU4ZDI4NjEKPj4gLS0tIC9kZXYvbnVsbAo+PiAr KysgYi9kcml2ZXJzL2lucHV0L2pveXN0aWNrL2FkYWZydWl0LXNlZXNhdy5jCj4+IEBAIC0wLDAg KzEsMjczIEBACj4+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vci1sYXRl cgo+PiArLyoKPj4gKyAqIENvcHlyaWdodCAoQykgMjAyMyBBbnNodWwgRGFsYWwgPGFuc2h1bHVz ckBnbWFpbC5jb20+Cj4+ICsgKgo+PiArICogRHJpdmVyIGZvciBBZGFmcnVpdCBNaW5pIEkyQyBH YW1lcGFkCj4+ICsgKgo+PiArICogQmFzZWQgb24gdGhlIHdvcmsgb2Y6Cj4+ICsgKglPbGVoIEty YXZjaGVua28gKFNwYXJrZnVuIFF3aWljIEpveXN0aWNrIGRyaXZlcikKPj4gKyAqCj4+ICsgKiBE YXRhc2hlZXQ6IGh0dHBzOi8vY2RuLWxlYXJuLmFkYWZydWl0LmNvbS9kb3dubG9hZHMvcGRmL2dh bWVwYWQtcXQucGRmCj4+ICsgKiBQcm9kdWN0IHBhZ2U6IGh0dHBzOi8vd3d3LmFkYWZydWl0LmNv bS9wcm9kdWN0LzU3NDMKPj4gKyAqIEZpcm13YXJlIGFuZCBoYXJkd2FyZSBzb3VyY2VzOiBodHRw czovL2dpdGh1Yi5jb20vYWRhZnJ1aXQvQWRhZnJ1aXRfU2Vlc2F3Cj4+ICsgKi8KPj4gKwo+PiAr I2luY2x1ZGUgPGFzbS1nZW5lcmljL3VuYWxpZ25lZC5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2Jp dHMuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2ky Yy5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2lucHV0Lmg+Cj4+ICsjaW5jbHVkZSA8bGludXgva2Vy bmVsLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4+ICsKPj4gKy8qIGNsYW5nLWZv cm1hdCBvZmYgKi8KPiAKPiBJIGRvbid0IHRoaW5rIHdlIG5lZWQgdGhpcyBkaXJlY3RpdmU7IGF0 IGxlYXN0LCBubyBvdGhlciBpbnB1dCBkcml2ZXJzIGhhdmUKPiBpdCwgb3IgcmVhbGx5IGFueSBk cml2ZXJzIGZvciB0aGF0IG1hdHRlci4KPiAKPj4gKyNkZWZpbmUgU0VFU0FXX0RFVklDRV9OQU1F CSJzZWVzYXctZ2FtZXBhZCIKPj4gKwo+PiArI2RlZmluZSBTRUVTQVdfU1RBVFVTX0JBU0UJMAo+ PiArI2RlZmluZSBTRUVTQVdfR1BJT19CQVNFCTEKPj4gKyNkZWZpbmUgU0VFU0FXX0FEQ19CQVNF CQk5Cj4+ICsKPj4gKyNkZWZpbmUgU0VFU0FXX0dQSU9fRElSQ0xSX0JVTEsJMwo+PiArI2RlZmlu ZSBTRUVTQVdfR1BJT19CVUxLCTQKPj4gKyNkZWZpbmUgU0VFU0FXX0dQSU9fQlVMS19TRVQJNQo+ PiArI2RlZmluZSBTRUVTQVdfR1BJT19QVUxMRU5TRVQJMTEKPj4gKwo+PiArI2RlZmluZSBTRUVT QVdfU1RBVFVTX0hXX0lECTEKPj4gKyNkZWZpbmUgU0VFU0FXX1NUQVRVU19TV1JTVAkxMjcKPj4g Kwo+PiArI2RlZmluZSBTRUVTQVdfQURDX09GRlNFVAk3Cj4+ICsKPj4gKyNkZWZpbmUgQlVUVE9O X0EJNQo+PiArI2RlZmluZSBCVVRUT05fQgkxCj4+ICsjZGVmaW5lIEJVVFRPTl9YCTYKPj4gKyNk ZWZpbmUgQlVUVE9OX1kJMgo+PiArI2RlZmluZSBCVVRUT05fU1RBUlQJMTYKPj4gKyNkZWZpbmUg QlVUVE9OX1NFTEVDVAkwCj4gCj4gUGxlYXNlIG5hbWVzcGFjZSB0aGVzZSAoZS5nLiBTRUVTQVdf QlVUVE9OX0EpIHRvIG1ha2UgaXQgY2xlYXIgdGhleSByZWZlcgo+IHRvIGRldmljZS1zcGVjaWZp YyBiaXRzIGFuZCBub3Qgc3RhbmRhcmQga2V5Y29kZXMgKGUuZy4gQlROX0EpLiBJbiBmYWN0LAo+ IHRoZXNlIHNlZW0gYmV0dGVyIG9mZiBhcyBwYXJ0IG9mIGFuIGFycmF5IG9mIHN0cnVjdHM7IG1v cmUgb24gdGhhdCBiZWxvdy4KPiAKPj4gKwo+PiArI2RlZmluZSBBTkFMT0dfWAkxNAo+PiArI2Rl ZmluZSBBTkFMT0dfWQkxNQo+IAo+IFBsZWFzZSBuYW1lc3BhY2UgdGhlc2UgYXMgd2VsbC4KPiAK Pj4gKwo+PiArI2RlZmluZSBTRUVTQVdfSk9ZU1RJQ0tfTUFYX0FYSVMJMTAyMwo+PiArI2RlZmlu ZSBTRUVTQVdfSk9ZU1RJQ0tfRlVaWgkJMgo+PiArI2RlZmluZSBTRUVTQVdfSk9ZU1RJQ0tfRkxB VAkJNAo+PiArCj4+ICsjZGVmaW5lIFNFRVNBV19HQU1FUEFEX1BPTExfSU5URVJWQUwJMTYKPj4g KyNkZWZpbmUgU0VFU0FXX0dBTUVQQURfUE9MTF9NSU4JCTgKPj4gKyNkZWZpbmUgU0VFU0FXX0dB TUVQQURfUE9MTF9NQVgJCTMyCj4+ICsvKiBjbGFuZy1mb3JtYXQgb24gKi8KPj4gKwo+PiArdTMy IEJVVFRPTl9NQVNLID0gQklUKEJVVFRPTl9BKSB8IEJJVChCVVRUT05fQikgfCBCSVQoQlVUVE9O X1gpIHwKPj4gKwkJICBCSVQoQlVUVE9OX1kpIHwgQklUKEJVVFRPTl9TVEFSVCkgfCBCSVQoQlVU VE9OX1NFTEVDVCk7Cj4+ICsKPj4gK3N0cnVjdCBzZWVzYXdfZ2FtZXBhZCB7Cj4+ICsJY2hhciBw aHlzaWNhbF9wYXRoWzMyXTsKPj4gKwlzdHJ1Y3QgaW5wdXRfZGV2ICppbnB1dF9kZXY7Cj4+ICsJ c3RydWN0IGkyY19jbGllbnQgKmkyY19jbGllbnQ7Cj4+ICt9Owo+PiArCj4+ICtzdHJ1Y3Qgc2Vl c2F3X2RhdGEgewo+PiArCV9fYmUxNiB4Owo+PiArCV9fYmUxNiB5Owo+PiArCXU4IGJ1dHRvbl9h LCBidXR0b25fYiwgYnV0dG9uX3gsIGJ1dHRvbl95LCBidXR0b25fc3RhcnQsIGJ1dHRvbl9zZWxl Y3Q7Cj4gCj4gUGxlYXNlIGtlZXAgdGhlc2UgZWFjaCBvbiBhIHNlcGFyYXRlIGxpbmUuCj4gCj4+ ICt9Owo+IAo+IFBsZWFzZSBkZWNsYXJlIHRoaXMgc3RydWN0IGFzIF9fcGFja2VkLCBhcyB0aGF0 IGlzIGhvdyBpdCBhcHBlYXJzIHRvIGJlIHVzZWQuCj4gCj4+ICsKPj4gK3N0YXRpYyBpbnQgc2Vl c2F3X3JlYWRfZGF0YShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LCBzdHJ1Y3Qgc2Vlc2F3X2Rh dGEgKmRhdGEpCj4+ICt7Cj4+ICsJaW50IGVycjsKPiAKPiBQbGVhc2UgdXNlICdyZXQnIGZvciBy ZXR1cm4gdmFyaWFibGVzIHRoYXQgY2FuIGluZGljYXRlIGEgcG9zaXRpdmUgdmFsdWUgb24gc3Vj Y2Vzcy4KPiAKPj4gKwl1bnNpZ25lZCBjaGFyIHdyaXRlX2J1ZlsyXSA9IHsgU0VFU0FXX0dQSU9f QkFTRSwgU0VFU0FXX0dQSU9fQlVMSyB9Owo+PiArCXVuc2lnbmVkIGNoYXIgcmVhZF9idWZbNF07 Cj4gCj4gUGxlYXNlIHVzZSBzdGFuZGFyZCBrZXJuZWwgdHlwZSBkZWZpbml0aW9ucyAoaS5lLiB1 OCBpbiB0aGlzIGNhc2UpLgo+IAo+PiArCj4+ICsJZXJyID0gaTJjX21hc3Rlcl9zZW5kKGNsaWVu dCwgd3JpdGVfYnVmLCBzaXplb2Yod3JpdGVfYnVmKSk7Cj4+ICsJaWYgKGVyciA8IDApCj4+ICsJ CXJldHVybiBlcnI7Cj4gCj4gWW91IGNvcnJlY3RseSByZXR1cm4gZXJyIChvciByYXRoZXIsIHJl dCkgZm9yIG5lZ2F0aXZlIHZhbHVlcywgYnV0IHlvdSBzaG91bGQgYWxzbwo+IGNoZWNrIHRoYXQg cmV0IG1hdGNoZXMgdGhlIHNpemUgb2YgdGhlIGRhdGEgc2VudC4gRm9yIDAgPD0gcmV0IDwgc2l6 ZW9mKHdyaXRlYnVmKSwKPiByZXR1cm4gLUVJTy4KPiAKPj4gKwllcnIgPSBpMmNfbWFzdGVyX3Jl Y3YoY2xpZW50LCByZWFkX2J1Ziwgc2l6ZW9mKHJlYWRfYnVmKSk7Cj4+ICsJaWYgKGVyciA8IDAp Cj4+ICsJCXJldHVybiBlcnI7Cj4gCj4gQW5kIGhlcmUuCj4gCj4+ICsKPj4gKwl1MzIgcmVzdWx0 ID0gZ2V0X3VuYWxpZ25lZF9iZTMyKCZyZWFkX2J1Zik7Cj4gCj4gUGxlYXNlIGRvIG5vdCBtaXgg ZGVjbGFyYXRpb25zIGFuZCBjb2RlOyBhbGwgZGVjbGFyYXRpb25zIG11c3QgYmUgYXQgdGhlCj4g dG9wIG9mIHRoZSBmdW5jdGlvbi4KPiAKPj4gKwo+PiArCWRhdGEtPmJ1dHRvbl9hID0gIXRlc3Rf Yml0KEJVVFRPTl9BLCAobG9uZyAqKSZyZXN1bHQpOwo+PiArCWRhdGEtPmJ1dHRvbl9iID0gIXRl c3RfYml0KEJVVFRPTl9CLCAobG9uZyAqKSZyZXN1bHQpOwo+PiArCWRhdGEtPmJ1dHRvbl94ID0g IXRlc3RfYml0KEJVVFRPTl9YLCAobG9uZyAqKSZyZXN1bHQpOwo+PiArCWRhdGEtPmJ1dHRvbl95 ID0gIXRlc3RfYml0KEJVVFRPTl9ZLCAobG9uZyAqKSZyZXN1bHQpOwo+PiArCWRhdGEtPmJ1dHRv bl9zdGFydCA9ICF0ZXN0X2JpdChCVVRUT05fU1RBUlQsIChsb25nICopJnJlc3VsdCk7Cj4+ICsJ ZGF0YS0+YnV0dG9uX3NlbGVjdCA9ICF0ZXN0X2JpdChCVVRUT05fU0VMRUNULCAobG9uZyAqKSZy ZXN1bHQpOwo+PiArCj4+ICsJd3JpdGVfYnVmWzBdID0gU0VFU0FXX0FEQ19CQVNFOwo+PiArCXdy aXRlX2J1ZlsxXSA9IFNFRVNBV19BRENfT0ZGU0VUICsgQU5BTE9HX1g7Cj4+ICsJZXJyID0gaTJj X21hc3Rlcl9zZW5kKGNsaWVudCwgd3JpdGVfYnVmLCBzaXplb2Yod3JpdGVfYnVmKSk7Cj4+ICsJ aWYgKGVyciA8IDApCj4+ICsJCXJldHVybiBlcnI7Cj4+ICsJZXJyID0gaTJjX21hc3Rlcl9yZWN2 KGNsaWVudCwgKGNoYXIgKikmZGF0YS0+eCwgc2l6ZW9mKGRhdGEtPngpKTsKPj4gKwlpZiAoZXJy IDwgMCkKPj4gKwkJcmV0dXJuIGVycjsKPiAKPiBUaGlzIGlzIHN0YXJ0aW5nIHRvIGxvb2sgbGlr ZSBhIDE2LWJpdCByZWdpc3RlciBtYXAuIFRvIHRoYXQgZW5kLCBwbGVhc2UKPiBjb25zaWRlciB1 c2luZyByZWdtYXAgaW5zdGVhZCBvZiBvcGVuLWNvZGluZyBlYWNoIG9mIHRoZXNlIHN0YW5kYXJk IHdyaXRlLQo+IHRoZW4tcmVhZCBvcGVyYXRpb25zLgo+IAo+IFVzaW5nIHJlZ21hcCB3b3VsZCBh bHNvIHNhdmUgeW91IHRoZSB0cm91YmxlIG9mIG1hbmFnaW5nIHRoZSBlbmRpYW5uZXNzCj4geW91 cnNlbGYsIGFzIHdlbGwgYXMgaGF2aW5nIHRvIGNoZWNrIGZvciBpbmNvbXBsZXRlIHRyYW5zZmVy cyBzaW5jZSBpdHMKPiBmdW5jdGlvbnMgcmV0dXJuIHplcm8gb3IgYSBuZWdhdGl2ZSBlcnJvciBj b2RlIG9ubHkuCj4gCkluIHRoaXMgZHJpdmVyIHRoZXJlIGFyZSBvbmx5IHR3byBwbGFjZXMgYSAx Ni1iaXQgcmVnbWFwIGNvdWxkIGJlIHVzZWQsCmZvciBnZXR0aW5nIHRoZSBqb3lzdGljayBYIGFu ZCBZIHZhbHVlcy4gSSBzZWUgbWluaW1hbCB1dGlsaXR5IGluIGFkZGluZwp0aGUgYm9pbGVycGxh dGUgbmVjZXNzYXJ5IHRvIHVzZSB0aGUgbW9yZSBzb3BoaXN0aWNhdGVkIHJlZ21hcCBBUEkgaW4K dGhpcyBjYXNlLgoKQXMgZm9yIHRoZSBoYW5kbGluZyBvZiBlbmRpYW5uZXNzLCBpZiBJIGFtIG5v dCBtaXN0YWtlbiB0aGUKYGJlMTZfdG9fY3B1YCBtYWNybyBzaG91bGQgbWFuYWdlIGl0LgoKSWYg eW91IHByZWZlciBJIGNvdWxkIGFkZCB0aGUgZm9sbG93aW5nIGZ1bmN0aW9uIHRvIHJlZHVjZSBj b2RlIGR1cGxpY2F0aW9uOgoKaW50IHNlZXNhd19nZXRfYW5hbG9nKGludCBwaW4pIHsKCV9fYmUx NiByZXN1bHQ7Cgl1OCB3cml0ZV9idWZbMl0gPSB7IFNFRVNBV19BRENfQkFTRSwgU0VFU0FXX0FE Q19PRkZTRVQgKyBwaW4gfTsKCWludCByZXQ7CglyZXQgPSBpMmNfbWFzdGVyX3NlbmQoY2xpZW50 LCB3cml0ZV9idWYsIHNpemVvZih3cml0ZV9idWYpKTsKCWlmIChyZXQgPCAwKQoJCXJldHVybiBy ZXQ7CglyZXQgPSBpMmNfbWFzdGVyX3JlY3YoY2xpZW50LCAoY2hhciAqKSZyZXN1bHQsIHNpemVv ZihyZXN1bHQpKTsKCWlmIChyZXQgPCAwKQoJCXJldHVybiByZXQ7CglyZXR1cm4gcmVzdWx0Owp9 Cgo+PiArCS8qCj4+ICsJICogQURDIHJlYWRzIGxlZnQgYXMgbWF4IGFuZCByaWdodCBhcyAwLCBt dXN0IGJlIHJldmVyc2VkIHNpbmNlIGtlcm5lbAo+PiArCSAqIGV4cGVjdHMgcmVwb3J0cyBpbiBv cHBvc2l0ZSBvcmRlci4KPj4gKwkgKi8KPj4gKwlkYXRhLT54ID0gU0VFU0FXX0pPWVNUSUNLX01B WF9BWElTIC0gYmUxNl90b19jcHUoZGF0YS0+eCk7Cj4+ICsKPj4gKwl3cml0ZV9idWZbMV0gPSBT RUVTQVdfQURDX09GRlNFVCArIEFOQUxPR19ZOwo+PiArCWVyciA9IGkyY19tYXN0ZXJfc2VuZChj bGllbnQsIHdyaXRlX2J1Ziwgc2l6ZW9mKHdyaXRlX2J1ZikpOwo+PiArCWlmIChlcnIgPCAwKQo+ PiArCQlyZXR1cm4gZXJyOwo+PiArCWVyciA9IGkyY19tYXN0ZXJfcmVjdihjbGllbnQsIChjaGFy ICopJmRhdGEtPnksIHNpemVvZihkYXRhLT55KSk7Cj4+ICsJaWYgKGVyciA8IDApCj4+ICsJCXJl dHVybiBlcnI7Cj4+ICsJZGF0YS0+eSA9IGJlMTZfdG9fY3B1KGRhdGEtPnkpOwo+PiArCj4+ICsJ cmV0dXJuIDA7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyB2b2lkIHNlZXNhd19wb2xsKHN0cnVjdCBp bnB1dF9kZXYgKmlucHV0KQo+PiArewo+PiArCXN0cnVjdCBzZWVzYXdfZ2FtZXBhZCAqcHJpdmF0 ZSA9IGlucHV0X2dldF9kcnZkYXRhKGlucHV0KTsKPj4gKwlzdHJ1Y3Qgc2Vlc2F3X2RhdGEgZGF0 YTsKPj4gKwlpbnQgZXJyOwo+PiArCj4+ICsJZXJyID0gc2Vlc2F3X3JlYWRfZGF0YShwcml2YXRl LT5pMmNfY2xpZW50LCAmZGF0YSk7Cj4+ICsJaWYgKGVyciAhPSAwKSB7Cj4+ICsJCWRldl9kYmco JmlucHV0LT5kZXYsICJmYWlsZWQgdG8gcmVhZCBqb3lzdGljayBzdGF0ZTogJWRcbiIsCj4+ICsJ CQllcnIpOwo+IAo+IFRoaXMgc2hvdWxkIGJlIGRldl9lcnJfcmF0ZWxpbWl0ZWQoKS4KPiAKPj4g KwkJcmV0dXJuOwo+PiArCX0KPj4gKwo+PiArCWlucHV0X3JlcG9ydF9hYnMoaW5wdXQsIEFCU19Y LCBkYXRhLngpOwo+PiArCWlucHV0X3JlcG9ydF9hYnMoaW5wdXQsIEFCU19ZLCBkYXRhLnkpOwo+ PiArCWlucHV0X3JlcG9ydF9rZXkoaW5wdXQsIEJUTl9FQVNULCBkYXRhLmJ1dHRvbl9hKTsKPj4g KwlpbnB1dF9yZXBvcnRfa2V5KGlucHV0LCBCVE5fU09VVEgsIGRhdGEuYnV0dG9uX2IpOwo+PiAr CWlucHV0X3JlcG9ydF9rZXkoaW5wdXQsIEJUTl9OT1JUSCwgZGF0YS5idXR0b25feCk7Cj4+ICsJ aW5wdXRfcmVwb3J0X2tleShpbnB1dCwgQlROX1dFU1QsIGRhdGEuYnV0dG9uX3kpOwo+PiArCWlu cHV0X3JlcG9ydF9rZXkoaW5wdXQsIEJUTl9TVEFSVCwgZGF0YS5idXR0b25fc3RhcnQpOwo+PiAr CWlucHV0X3JlcG9ydF9rZXkoaW5wdXQsIEJUTl9TRUxFQ1QsIGRhdGEuYnV0dG9uX3NlbGVjdCk7 Cj4gCj4gSSB0aGluayB5b3UgY2FuIG1ha2UgdGhpcyBtdWNoIGNsZWFuZXIgYW5kIHNtYWxsZXIg YnkgZGVmaW5pbmcgYW4gYXJyYXkKPiBvZiBzdHJ1Y3RzLCBlYWNoIHdpdGggYSBrZXkgY29kZSBh bmQgYml0IHBvc2l0aW9uLiBZb3UgY2FuIHRoZW4gc2ltcGx5Cj4gaXRlcmF0ZSBvdmVyIHRoZSBh cnJheSBhbmQgY2FsbCBpbnB1dF9yZXBvcnRfa2V5KCkgb25jZSBwZXIgZWxlbWVudCBhcwo+IGlu IHRoZSBmb2xsb3dpbmc6Cj4gCj4gc3RydWN0IHNlZXNhd19idG5fZGVzYyB7Cj4gCXVuc2lnbmVk IGludCBjb2RlOwo+IAl1bnNpZ25lZCBpbnQgc2hpZnQ7Cj4gfTsKPiAKPiBzdGF0aWMgY29uc3Qg c3RydWN0IHNlZXNhd19idG5fZGVzYyBzZWVzYXdfYnRuc1tdID0gewo+IAl7Cj4gCQkuY29kZSA9 IEJUTl9FQVNULAo+IAkJLm1hc2sgPSA1LAo+IAl9LAo+IAlbLi4uXQo+IH07Cj4gCj4gQW5kIHRo ZW46Cj4gCj4gCWJ0bl9zdGF0dXMgPSAuLi47Cj4gCj4gCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9T SVpFKHNlZXNhd19idG5zKTsgaSsrKQo+IAkJaW5wdXRfcmVwb3J0X2tleShpbnB1dCwgc2Vlc2F3 X2J0bnNbaV0uY29kZSwKPiAJCQkJIGJ0bl9zdGF0dXMgJiBzZWVzYXdfYnRuc1tpXS5tYXNrKTsK PiAKPiBUaGlzIHdvdWxkIGFsc28gbWFrZSBpdCBlYXNpZXIgdG8gcXVpY2tseSBkaXNjZXJuIHdo YXQga2V5Y29kZXMgYXJlIG1hcHBlZAo+IHRvIHdoaWNoIGJpdHMgaW4gdGhlIHJlZ2lzdGVyLgo+ IAo+PiArCWlucHV0X3N5bmMoaW5wdXQpOwo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW50IHNlZXNh d19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50KQo+PiArewo+PiArCWludCBlcnI7Cj4+ ICsJc3RydWN0IHNlZXNhd19nYW1lcGFkICpwcml2YXRlOwo+IAo+IEknZCByYXRoZXIgdGhpcyBi ZSBjYWxsZWQgc29tZXRoaW5nIGxpa2UgJ3NlZXNhdycgcmF0aGVyIHRoYW4gcHJpdmF0ZS4KPiAK Pj4gKwl1bnNpZ25lZCBjaGFyIHJlZ2lzdGVyX3Jlc2V0W10gPSB7IFNFRVNBV19TVEFUVVNfQkFT RSwKPj4gKwkJCQkJICAgU0VFU0FXX1NUQVRVU19TV1JTVCwgMHhGRiB9Owo+PiArCXVuc2lnbmVk IGNoYXIgZ2V0X2h3X2lkW10gPSB7IFNFRVNBV19TVEFUVVNfQkFTRSwgU0VFU0FXX1NUQVRVU19I V19JRCB9Owo+PiArCj4+ICsJZXJyID0gaTJjX21hc3Rlcl9zZW5kKGNsaWVudCwgcmVnaXN0ZXJf cmVzZXQsIHNpemVvZihyZWdpc3Rlcl9yZXNldCkpOwo+PiArCWlmIChlcnIgPCAwKQo+PiArCQly ZXR1cm4gZXJyOwo+PiArCj4+ICsJLyogV2FpdCBmb3IgdGhlIHJlZ2lzdGVycyB0byByZXNldCBi ZWZvcmUgcHJvY2VlZGluZyAqLwo+PiArCW1kZWxheSgxMCk7Cj4+ICsKPj4gKwlwcml2YXRlID0g ZGV2bV9remFsbG9jKCZjbGllbnQtPmRldiwgc2l6ZW9mKCpwcml2YXRlKSwgR0ZQX0tFUk5FTCk7 Cj4+ICsJaWYgKCFwcml2YXRlKQo+PiArCQlyZXR1cm4gLUVOT01FTTsKPj4gKwo+PiArCWVyciA9 IGkyY19tYXN0ZXJfc2VuZChjbGllbnQsIGdldF9od19pZCwgc2l6ZW9mKGdldF9od19pZCkpOwo+ PiArCWlmIChlcnIgPCAwKQo+PiArCQlyZXR1cm4gZXJyOwo+PiArCj4+ICsJdW5zaWduZWQgY2hh ciBoYXJkd2FyZV9pZDsKPiAKPiBTYW1lIGNvbW1lbnQgYXMgZWFybGllciB3aXRoIHJlZ2FyZCB0 byBtaXhlZCBkZWNsYXJhdGlvbnMuCj4gCj4+ICsKPj4gKwllcnIgPSBpMmNfbWFzdGVyX3JlY3Yo Y2xpZW50LCAmaGFyZHdhcmVfaWQsIDEpOwo+PiArCWlmIChlcnIgPCAwKQo+PiArCQlyZXR1cm4g ZXJyOwo+PiArCj4+ICsJZGV2X2RiZygmY2xpZW50LT5kZXYsICJBZGFmcnVpdCBTZWVzYXcgR2Ft ZXBhZCwgSGFyZHdhcmUgSUQ6ICUwMnhcbiIsCj4+ICsJCWhhcmR3YXJlX2lkKTsKPj4gKwo+PiAr CXByaXZhdGUtPmkyY19jbGllbnQgPSBjbGllbnQ7Cj4+ICsJc2NucHJpbnRmKHByaXZhdGUtPnBo eXNpY2FsX3BhdGgsIHNpemVvZihwcml2YXRlLT5waHlzaWNhbF9wYXRoKSwKPj4gKwkJICAiaTJj LyVzIiwgZGV2X25hbWUoJmNsaWVudC0+ZGV2KSk7Cj4gCj4gVGhpcyBzZWVtcyBvdmVybHkgY29t cGxleDsgY2FuIHdlIG5vdCBzaW1wbHkgc2V0IGlucHV0X2Rldi0+cGh5cyB0byB0aGUKPiBsaXRl cmFsICJpMmMvc2Vlc2F3LWdhbWVwYWQiPyBXaHkgdG8gY29weSBhdCBydW50aW1lIGFuZCBpbmN1 ciB0aGUgY29zdAo+IG9mIGNhcnJ5aW5nICdwaHlzaWNhbF9wYXRoJyB0aHJvdWdob3V0IHRoZSBs aWZlIG9mIHRoZSBtb2R1bGU/Cj4gCj4+ICsJaTJjX3NldF9jbGllbnRkYXRhKGNsaWVudCwgcHJp dmF0ZSk7Cj4+ICsKPj4gKwlwcml2YXRlLT5pbnB1dF9kZXYgPSBkZXZtX2lucHV0X2FsbG9jYXRl X2RldmljZSgmY2xpZW50LT5kZXYpOwo+PiArCWlmICghcHJpdmF0ZS0+aW5wdXRfZGV2KQo+PiAr CQlyZXR1cm4gLUVOT01FTTsKPj4gKwo+PiArCXByaXZhdGUtPmlucHV0X2Rldi0+aWQuYnVzdHlw ZSA9IEJVU19JMkM7Cj4+ICsJcHJpdmF0ZS0+aW5wdXRfZGV2LT5uYW1lID0gIkFkYWZydWl0IFNl ZXNhdyBHYW1lcGFkIjsKPj4gKwlwcml2YXRlLT5pbnB1dF9kZXYtPnBoeXMgPSBwcml2YXRlLT5w aHlzaWNhbF9wYXRoOwo+PiArCWlucHV0X3NldF9kcnZkYXRhKHByaXZhdGUtPmlucHV0X2Rldiwg cHJpdmF0ZSk7Cj4+ICsJaW5wdXRfc2V0X2Fic19wYXJhbXMocHJpdmF0ZS0+aW5wdXRfZGV2LCBB QlNfWCwgMCwKPj4gKwkJCSAgICAgU0VFU0FXX0pPWVNUSUNLX01BWF9BWElTLCBTRUVTQVdfSk9Z U1RJQ0tfRlVaWiwKPj4gKwkJCSAgICAgU0VFU0FXX0pPWVNUSUNLX0ZMQVQpOwo+PiArCWlucHV0 X3NldF9hYnNfcGFyYW1zKHByaXZhdGUtPmlucHV0X2RldiwgQUJTX1ksIDAsCj4+ICsJCQkgICAg IFNFRVNBV19KT1lTVElDS19NQVhfQVhJUywgU0VFU0FXX0pPWVNUSUNLX0ZVWlosCj4+ICsJCQkg ICAgIFNFRVNBV19KT1lTVElDS19GTEFUKTsKPj4gKwlpbnB1dF9zZXRfY2FwYWJpbGl0eShwcml2 YXRlLT5pbnB1dF9kZXYsIEVWX0tFWSwgQlROX0VBU1QpOwo+PiArCWlucHV0X3NldF9jYXBhYmls aXR5KHByaXZhdGUtPmlucHV0X2RldiwgRVZfS0VZLCBCVE5fU09VVEgpOwo+PiArCWlucHV0X3Nl dF9jYXBhYmlsaXR5KHByaXZhdGUtPmlucHV0X2RldiwgRVZfS0VZLCBCVE5fTk9SVEgpOwo+PiAr CWlucHV0X3NldF9jYXBhYmlsaXR5KHByaXZhdGUtPmlucHV0X2RldiwgRVZfS0VZLCBCVE5fV0VT VCk7Cj4+ICsJaW5wdXRfc2V0X2NhcGFiaWxpdHkocHJpdmF0ZS0+aW5wdXRfZGV2LCBFVl9LRVks IEJUTl9TVEFSVCk7Cj4+ICsJaW5wdXRfc2V0X2NhcGFiaWxpdHkocHJpdmF0ZS0+aW5wdXRfZGV2 LCBFVl9LRVksIEJUTl9TRUxFQ1QpOwo+IAo+IFNhbWUgY29tbWVudCB3aXRoIHJlZ2FyZCB0byBj cmVhdGluZyBhbiBhcnJheSBvZiBzdHJ1Y3RzLCBhbmQgaGVuY2Ugb25seQo+IGhhdmluZyB0byBj YWxsIGlucHV0X3NldF9jYXBhYmlsaXR5KCkgZnJvbSB3aXRoaW4gYSBzbWFsbCBsb29wLgo+IAo+ PiArCj4+ICsJZXJyID0gaW5wdXRfc2V0dXBfcG9sbGluZyhwcml2YXRlLT5pbnB1dF9kZXYsIHNl ZXNhd19wb2xsKTsKPj4gKwlpZiAoZXJyKSB7Cj4+ICsJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAi ZmFpbGVkIHRvIHNldCB1cCBwb2xsaW5nOiAlZFxuIiwgZXJyKTsKPj4gKwkJcmV0dXJuIGVycjsK Pj4gKwl9Cj4+ICsKPj4gKwlpbnB1dF9zZXRfcG9sbF9pbnRlcnZhbChwcml2YXRlLT5pbnB1dF9k ZXYsCj4+ICsJCQkJU0VFU0FXX0dBTUVQQURfUE9MTF9JTlRFUlZBTCk7Cj4+ICsJaW5wdXRfc2V0 X21heF9wb2xsX2ludGVydmFsKHByaXZhdGUtPmlucHV0X2RldiwKPj4gKwkJCQkgICAgU0VFU0FX X0dBTUVQQURfUE9MTF9NQVgpOwo+PiArCWlucHV0X3NldF9taW5fcG9sbF9pbnRlcnZhbChwcml2 YXRlLT5pbnB1dF9kZXYsCj4+ICsJCQkJICAgIFNFRVNBV19HQU1FUEFEX1BPTExfTUlOKTsKPj4g Kwo+PiArCWVyciA9IGlucHV0X3JlZ2lzdGVyX2RldmljZShwcml2YXRlLT5pbnB1dF9kZXYpOwo+ PiArCWlmIChlcnIpIHsKPj4gKwkJZGV2X2VycigmY2xpZW50LT5kZXYsICJmYWlsZWQgdG8gcmVn aXN0ZXIgam95c3RpY2s6ICVkXG4iLCBlcnIpOwo+PiArCQlyZXR1cm4gZXJyOwo+PiArCX0KPj4g Kwo+PiArCS8qIFNldCBQaW4gTW9kZSB0byBpbnB1dCBhbmQgZW5hYmxlIHB1bGwtdXAgcmVzaXN0 b3JzICovCj4+ICsJdW5zaWduZWQgY2hhciBwaW5fbW9kZVtdID0geyBTRUVTQVdfR1BJT19CQVNF LAlTRUVTQVdfR1BJT19ESVJDTFJfQlVMSywKPj4gKwkJCQkgICAgIEJVVFRPTl9NQVNLID4+IDI0 LCBCVVRUT05fTUFTSyA+PiAxNiwKPj4gKwkJCQkgICAgIEJVVFRPTl9NQVNLID4+IDgsCUJVVFRP Tl9NQVNLIH07Cj4+ICsJZXJyID0gaTJjX21hc3Rlcl9zZW5kKGNsaWVudCwgcGluX21vZGUsIHNp emVvZihwaW5fbW9kZSkpOwo+PiArCWlmIChlcnIgPCAwKQo+PiArCQlyZXR1cm4gZXJyOwo+PiAr CXBpbl9tb2RlWzFdID0gU0VFU0FXX0dQSU9fUFVMTEVOU0VUOwo+PiArCWVyciA9IGkyY19tYXN0 ZXJfc2VuZChjbGllbnQsIHBpbl9tb2RlLCBzaXplb2YocGluX21vZGUpKTsKPj4gKwlpZiAoZXJy IDwgMCkKPj4gKwkJcmV0dXJuIGVycjsKPj4gKwlwaW5fbW9kZVsxXSA9IFNFRVNBV19HUElPX0JV TEtfU0VUOwo+PiArCWVyciA9IGkyY19tYXN0ZXJfc2VuZChjbGllbnQsIHBpbl9tb2RlLCBzaXpl b2YocGluX21vZGUpKTsKPj4gKwlpZiAoZXJyIDwgMCkKPj4gKwkJcmV0dXJuIGVycjsKPiAKPiBQ bGVhc2UgY29uZmlndXJlIHRoZSBIVyBiZWZvcmUgdGhlIGlucHV0IGRldmljZSBpcyBsaXZlIGFu ZCBiZWluZyBwb2xsZWQuCj4gCgpDb3VsZCB5b3UgZWxhYm9yYXRlIG9uIHdoYXQgeW91IG1lYW50 IGJ5IHRoaXMuIFRvIG15IGtub3dsZWRnZSwgdGhlCmRldmljZSBpcyByZWFkeSB0byBiZSBwb2xs ZWQgcmlnaHQgYWZ0ZXIgdGhlIHBpbiBzdGF0ZSBmb3IgdGhlCmBCVVRUT05fTUFTS2AgaXMgY29u ZmlndXJlZC4gVGhhdCBpcyBhbHNvIGhvdyBpdCdzIGRvbmUgaW4gdGhlIEFyZHVpbm8KZHJpdmVy IHByb3ZpZGVkIGJ5IHRoZSBtYW51ZmFjdHVyZXIuIFBsZWFzZSBjbGFyaWZ5IGlmIEknbSBtaXNz aW5nCnNvbWV0aGluZyBoZXJlLgoKPj4gKwo+PiArCXJldHVybiAwOwo+PiArfQo+PiArCj4+ICsj aWZkZWYgQ09ORklHX09GCj4+ICtzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBvZl9z ZWVzYXdfbWF0Y2hbXSA9IHsKPj4gKwl7Cj4+ICsJCS5jb21wYXRpYmxlID0gImFkYWZydWl0LHNl ZXNhdy1nYW1lcGFkIiwKPj4gKwl9LAo+PiArCXsgLyogU2VudGluZWwgKi8gfQo+PiArfTsKPj4g K01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIG9mX3NlZXNhd19tYXRjaCk7Cj4+ICsjZW5kaWYgLyog Q09ORklHX09GICovCj4gCj4gUGxlYXNlIGNvcnJlY3QgbWUgaWYgSSBhbSB3cm9uZywgYnV0IGl0 IGRvZXMgbm90IHNlZW0gdGhhdCBPRiBzdXBwb3J0IGlzCj4gcmVxdWlyZWQgYnkgdGhpcyBkcml2 ZXIuIFRoZXJlIGFyZSBubyBwcm9wZXJ0aWVzIGJleW9uZCB0aGUgc3RhbmRhcmQgb25lcwo+IHVu ZGVyc3Rvb2QgYnkgdGhlIEkyQyBjb3JlLCB3aGljaCBjYW4gbWF0Y2ggYmFzZWQgb24gdGhlIElE IHRhYmxlIGJlbG93Lgo+IAo+PiArCj4+ICsvKiBjbGFuZy1mb3JtYXQgb2ZmICovCj4+ICtzdGF0 aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgc2Vlc2F3X2lkX3RhYmxlW10gPSB7Cj4+ICsJ eyBTRUVTQVdfREVWSUNFX05BTUUsIDAgfSwKPj4gKwl7IC8qIFNlbnRpbmVsICovIH0KPj4gK307 Cj4+ICsvKiBjbGFuZy1mb3JtYXQgb24gKi8KPiAKPiBBZ2FpbiwgSSBkb24ndCBzZWUgYW55IG5l ZWQgZm9yIHRoZXNlIGRpcmVjdGl2ZXMuCj4gCj4+ICsKPiAKPiBOaXQ6IHVubmVjZXNzYXJ5IE5M Lgo+IAo+PiArTU9EVUxFX0RFVklDRV9UQUJMRShpMmMsIHNlZXNhd19pZF90YWJsZSk7Cj4+ICsK Pj4gK3N0YXRpYyBzdHJ1Y3QgaTJjX2RyaXZlciBzZWVzYXdfZHJpdmVyID0gewo+PiArCS5kcml2 ZXIgPSB7Cj4+ICsJCS5uYW1lID0gU0VFU0FXX0RFVklDRV9OQU1FLAo+PiArCQkub2ZfbWF0Y2hf dGFibGUgPSBvZl9tYXRjaF9wdHIob2Zfc2Vlc2F3X21hdGNoKSwKPj4gKwl9LAo+PiArCS5pZF90 YWJsZSA9IHNlZXNhd19pZF90YWJsZSwKPj4gKwkucHJvYmUgPSBzZWVzYXdfcHJvYmUsCj4+ICt9 Owo+PiArbW9kdWxlX2kyY19kcml2ZXIoc2Vlc2F3X2RyaXZlcik7Cj4+ICsKPj4gK01PRFVMRV9B VVRIT1IoIkFuc2h1bCBEYWxhbCA8YW5zaHVsdXNyQGdtYWlsLmNvbT4iKTsKPj4gK01PRFVMRV9E RVNDUklQVElPTigiQWRhZnJ1aXQgTWluaSBJMkMgR2FtZXBhZCBkcml2ZXIiKTsKPj4gK01PRFVM RV9MSUNFTlNFKCJHUEwiKTsKPj4gLS0gCj4+IDIuNDIuMAo+Pgo+IAo+IEtpbmQgcmVnYXJkcywK PiBKZWZmIExhQnVuZHkKClJlZ2FyZHMsCkFuc2h1bCBEYWxhbApfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51eC1rZXJuZWwtbWVudGVlcyBtYWlsaW5n IGxpc3QKTGludXgta2VybmVsLW1lbnRlZXNAbGlzdHMubGludXhmb3VuZGF0aW9uLm9yZwpodHRw czovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1rZXJu ZWwtbWVudGVlcwo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CF696C0032E for ; Wed, 25 Oct 2023 10:21:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233581AbjJYKVV (ORCPT ); Wed, 25 Oct 2023 06:21:21 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54428 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232789AbjJYKVT (ORCPT ); Wed, 25 Oct 2023 06:21:19 -0400 Received: from mail-pf1-x42b.google.com (mail-pf1-x42b.google.com [IPv6:2607:f8b0:4864:20::42b]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 06D7FDD; Wed, 25 Oct 2023 03:21:17 -0700 (PDT) Received: by mail-pf1-x42b.google.com with SMTP id d2e1a72fcca58-692c02adeefso4429399b3a.3; Wed, 25 Oct 2023 03:21:17 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1698229276; x=1698834076; darn=vger.kernel.org; h=content-transfer-encoding:in-reply-to:from:content-language :references:cc:to:subject:user-agent:mime-version:date:message-id :from:to:cc:subject:date:message-id:reply-to; bh=SDsqw0sXkcqQTP0sCa4Jkp7YyhsxVpWNPP+SpDa1yZw=; b=Ry08MFy++i10BUT9Gr1QsV2SwmVt967p13eu7P4Mb20068ecWUdDy9Em2FN79ZpMAd SWDQ2o4J274/xQAYY4EkGRnEyoNOtsSuYYnOI1jS2lYuwYiR06qGuPHR0g/1wusHQIAU YkjFbVc3BKb7u3GYDq5sK5iGVwqc8D/FhxflepBYRVzs/CwEKEA40Kb97He2hmAgoRPL kYWGUrG2m2kwq0Rw8cmAqSkuPmQ+EHNdDY1u1Jy9gjaBQUz2NnjMvLo0JTPLX0Zey5eR SN1JXUNBooqQQBVV4X4YUJaw/rYW4k0wB/nVCIzlznjFyx4aroDsM6iP7j0lCVcdoTuO +VVA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698229276; x=1698834076; h=content-transfer-encoding:in-reply-to:from:content-language :references:cc:to:subject:user-agent:mime-version:date:message-id :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=SDsqw0sXkcqQTP0sCa4Jkp7YyhsxVpWNPP+SpDa1yZw=; b=lwXxN0POF4bi7wE1XSlTMGn+1HmJPTSi6nCDNRrQB2xqOdQdEoReiltwM4i+MIO0fH pYRUtX6wtQ9InIYTRkyVT/v95hao4nqpn76b8PWHCNCfWuX2m+DzGRAnk0zPs2w8m53o IqDnqvsq78Y0sg5dwL6Yjo2dwiAAtOAxbHi+wSEk3Ms6PNC8Eg6IA51iuRG8jHP32ZlF jrcH0P1wC+k4FnWG5lLhoDICO0hYhdqPieZsVVKiT7eFyjLhZyAmVXm4w/2QYOwHkdy2 963IW44U1cCR4M9R17377rRPtlrACKxDe+TKR88eK6phgBUVfe9ijyCMrgQEStieZfAZ Cb2w== X-Gm-Message-State: AOJu0YwU4lUkrdo9rRosoVqAbfvqs6JenYQ8fQqMj9gRsXM8/5GYJ3ZN 1VUq0agW0uhjBqBbX944F/k= X-Google-Smtp-Source: AGHT+IH9yiMfJqlyqVWm1XKh6cflreVosWhbEfsZ/kiLIaq/2Tu34NO9j5LGH3M2R0l95i7g8f7Cow== X-Received: by 2002:a05:6a21:1506:b0:17a:f2ed:e921 with SMTP id nq6-20020a056a21150600b0017af2ede921mr5397424pzb.55.1698229276129; Wed, 25 Oct 2023 03:21:16 -0700 (PDT) Received: from [10.5.209.17] ([59.152.80.69]) by smtp.gmail.com with ESMTPSA id y3-20020a1709029b8300b001b81a97860asm8834554plp.27.2023.10.25.03.21.13 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Wed, 25 Oct 2023 03:21:15 -0700 (PDT) Message-ID: Date: Wed, 25 Oct 2023 15:50:04 +0530 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v5 2/2] input: joystick: driver for Adafruit Seesaw Gamepad To: Jeff LaBundy Cc: linux-input@vger.kernel.org, devicetree@vger.kernel.org, Dmitry Torokhov , Rob Herring , Krzysztof Kozlowski , Conor Dooley , =?UTF-8?Q?Thomas_Wei=C3=9Fschuh?= , Shuah Khan , linux-kernel-mentees@lists.linuxfoundation.org, linux-kernel@vger.kernel.org References: <20231017034356.1436677-1-anshulusr@gmail.com> <20231017034356.1436677-2-anshulusr@gmail.com> Content-Language: en-US From: Anshul Dalal In-Reply-To: Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-input@vger.kernel.org Hello Jeff, Thanks for the review, I plan on addressing the changes you requested in the next version of the patch. Though I had a few questions: On 10/23/23 05:12, Jeff LaBundy wrote: > Hi Anshul, > > On Tue, Oct 17, 2023 at 09:13:45AM +0530, Anshul Dalal wrote: >> Adds a driver for a mini gamepad that communicates over i2c, the gamepad >> has bidirectional thumb stick input and six buttons. >> >> The gamepad chip utilizes the open framework from Adafruit called 'Seesaw' >> to transmit the ADC data for the joystick and digital pin state for the >> buttons. I have only implemented the functionality required to receive the >> thumb stick and button state. >> >> Steps in reading the gamepad state over i2c: >> 1. Reset the registers >> 2. Set the pin mode of the pins specified by the `BUTTON_MASK` to input >> `BUTTON_MASK`: A bit-map for the six digital pins internally >> connected to the joystick buttons. >> 3. Enable internal pullup resistors for the `BUTTON_MASK` >> 4. Bulk set the pin state HIGH for `BUTTON_MASK` >> 5. Poll the device for button and joystick state done by: >> `seesaw_read_data(struct i2c_client *client, struct seesaw_data *data)` >> >> Product page: >> https://www.adafruit.com/product/5743 >> Arduino driver: >> https://github.com/adafruit/Adafruit_Seesaw >> >> Driver tested on RPi Zero 2W >> >> Reviewed-by: Thomas Weißschuh >> Signed-off-by: Anshul Dalal >> --- >> >> Changes for v5: >> - Added link to the datasheet >> - Added debug log message when `seesaw_read_data` fails >> >> Changes for v4: >> - Changed `1UL << BUTTON_` to BIT(BUTTON_) >> - Removed `hardware_id` field from `struct seesaw_gamepad` >> - Removed redundant checks for the number of bytes written and received by >> `i2c_master_send` and `i2c_master_recv` >> - Used `get_unaligned_be32` to instantiate `u32 result` from `read_buf` >> - Changed `result & (1UL << BUTTON_)` to >> `test_bit(BUTTON_, (long *)&result)` >> - Changed `KBUILD_MODNAME` in id-tables to `SEESAW_DEVICE_NAME` >> - Fixed formatting issues >> - Changed button reporting: >> Since the gamepad had the action buttons in a non-standard layout: >> (X) >> (Y) (A) >> (B) >> Therefore moved to using generic directional action button event codes >> instead of BTN_[ABXY]. >> >> Changes for v3: >> - no updates >> >> Changes for v2: >> adafruit-seesaw.c: >> - Renamed file from 'adafruit_seesaw.c' >> - Changed device name from 'seesaw_gamepad' to 'seesaw-gamepad' >> - Changed count parameter for receiving joystick x on line 118: >> `2` to `sizeof(write_buf)` >> - Fixed invalid buffer size on line 123 and 126: >> `data->y` to `sizeof(data->y)` >> - Added comment for the `mdelay(10)` on line 169 >> - Changed inconsistent indentation on line 271 >> Kconfig: >> - Fixed indentation for the help text >> - Updated module name >> Makefile: >> - Updated module object file name >> MAINTAINERS: >> - Updated file name for the driver and bindings >> >> MAINTAINERS | 7 + >> drivers/input/joystick/Kconfig | 9 + >> drivers/input/joystick/Makefile | 1 + >> drivers/input/joystick/adafruit-seesaw.c | 273 +++++++++++++++++++++++ >> 4 files changed, 290 insertions(+) >> create mode 100644 drivers/input/joystick/adafruit-seesaw.c >> >> diff --git a/MAINTAINERS b/MAINTAINERS >> index 6c4cce45a09d..a314f9b48e21 100644 >> --- a/MAINTAINERS >> +++ b/MAINTAINERS >> @@ -441,6 +441,13 @@ W: http://wiki.analog.com/AD7879 >> W: https://ez.analog.com/linux-software-drivers >> F: drivers/input/touchscreen/ad7879.c >> >> +ADAFRUIT MINI I2C GAMEPAD >> +M: Anshul Dalal >> +L: linux-input@vger.kernel.org >> +S: Maintained >> +F: Documentation/devicetree/bindings/input/adafruit,seesaw-gamepad.yaml >> +F: drivers/input/joystick/adafruit-seesaw.c >> + >> ADDRESS SPACE LAYOUT RANDOMIZATION (ASLR) >> M: Jiri Kosina >> S: Maintained >> diff --git a/drivers/input/joystick/Kconfig b/drivers/input/joystick/Kconfig >> index ac6925ce8366..df9cd1830b29 100644 >> --- a/drivers/input/joystick/Kconfig >> +++ b/drivers/input/joystick/Kconfig >> @@ -412,4 +412,13 @@ config JOYSTICK_SENSEHAT >> To compile this driver as a module, choose M here: the >> module will be called sensehat_joystick. >> >> +config JOYSTICK_SEESAW >> + tristate "Adafruit Mini I2C Gamepad with Seesaw" >> + depends on I2C >> + help >> + Say Y here if you want to use the Adafruit Mini I2C Gamepad. >> + >> + To compile this driver as a module, choose M here: the module will be >> + called adafruit-seesaw. >> + >> endif >> diff --git a/drivers/input/joystick/Makefile b/drivers/input/joystick/Makefile >> index 3937535f0098..9976f596a920 100644 >> --- a/drivers/input/joystick/Makefile >> +++ b/drivers/input/joystick/Makefile >> @@ -28,6 +28,7 @@ obj-$(CONFIG_JOYSTICK_N64) += n64joy.o >> obj-$(CONFIG_JOYSTICK_PSXPAD_SPI) += psxpad-spi.o >> obj-$(CONFIG_JOYSTICK_PXRC) += pxrc.o >> obj-$(CONFIG_JOYSTICK_QWIIC) += qwiic-joystick.o >> +obj-$(CONFIG_JOYSTICK_SEESAW) += adafruit-seesaw.o >> obj-$(CONFIG_JOYSTICK_SENSEHAT) += sensehat-joystick.o >> obj-$(CONFIG_JOYSTICK_SIDEWINDER) += sidewinder.o >> obj-$(CONFIG_JOYSTICK_SPACEBALL) += spaceball.o >> diff --git a/drivers/input/joystick/adafruit-seesaw.c b/drivers/input/joystick/adafruit-seesaw.c >> new file mode 100644 >> index 000000000000..2a1eae8d2861 >> --- /dev/null >> +++ b/drivers/input/joystick/adafruit-seesaw.c >> @@ -0,0 +1,273 @@ >> +// SPDX-License-Identifier: GPL-2.0-or-later >> +/* >> + * Copyright (C) 2023 Anshul Dalal >> + * >> + * Driver for Adafruit Mini I2C Gamepad >> + * >> + * Based on the work of: >> + * Oleh Kravchenko (Sparkfun Qwiic Joystick driver) >> + * >> + * Datasheet: https://cdn-learn.adafruit.com/downloads/pdf/gamepad-qt.pdf >> + * Product page: https://www.adafruit.com/product/5743 >> + * Firmware and hardware sources: https://github.com/adafruit/Adafruit_Seesaw >> + */ >> + >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> + >> +/* clang-format off */ > > I don't think we need this directive; at least, no other input drivers have > it, or really any drivers for that matter. > >> +#define SEESAW_DEVICE_NAME "seesaw-gamepad" >> + >> +#define SEESAW_STATUS_BASE 0 >> +#define SEESAW_GPIO_BASE 1 >> +#define SEESAW_ADC_BASE 9 >> + >> +#define SEESAW_GPIO_DIRCLR_BULK 3 >> +#define SEESAW_GPIO_BULK 4 >> +#define SEESAW_GPIO_BULK_SET 5 >> +#define SEESAW_GPIO_PULLENSET 11 >> + >> +#define SEESAW_STATUS_HW_ID 1 >> +#define SEESAW_STATUS_SWRST 127 >> + >> +#define SEESAW_ADC_OFFSET 7 >> + >> +#define BUTTON_A 5 >> +#define BUTTON_B 1 >> +#define BUTTON_X 6 >> +#define BUTTON_Y 2 >> +#define BUTTON_START 16 >> +#define BUTTON_SELECT 0 > > Please namespace these (e.g. SEESAW_BUTTON_A) to make it clear they refer > to device-specific bits and not standard keycodes (e.g. BTN_A). In fact, > these seem better off as part of an array of structs; more on that below. > >> + >> +#define ANALOG_X 14 >> +#define ANALOG_Y 15 > > Please namespace these as well. > >> + >> +#define SEESAW_JOYSTICK_MAX_AXIS 1023 >> +#define SEESAW_JOYSTICK_FUZZ 2 >> +#define SEESAW_JOYSTICK_FLAT 4 >> + >> +#define SEESAW_GAMEPAD_POLL_INTERVAL 16 >> +#define SEESAW_GAMEPAD_POLL_MIN 8 >> +#define SEESAW_GAMEPAD_POLL_MAX 32 >> +/* clang-format on */ >> + >> +u32 BUTTON_MASK = BIT(BUTTON_A) | BIT(BUTTON_B) | BIT(BUTTON_X) | >> + BIT(BUTTON_Y) | BIT(BUTTON_START) | BIT(BUTTON_SELECT); >> + >> +struct seesaw_gamepad { >> + char physical_path[32]; >> + struct input_dev *input_dev; >> + struct i2c_client *i2c_client; >> +}; >> + >> +struct seesaw_data { >> + __be16 x; >> + __be16 y; >> + u8 button_a, button_b, button_x, button_y, button_start, button_select; > > Please keep these each on a separate line. > >> +}; > > Please declare this struct as __packed, as that is how it appears to be used. > >> + >> +static int seesaw_read_data(struct i2c_client *client, struct seesaw_data *data) >> +{ >> + int err; > > Please use 'ret' for return variables that can indicate a positive value on success. > >> + unsigned char write_buf[2] = { SEESAW_GPIO_BASE, SEESAW_GPIO_BULK }; >> + unsigned char read_buf[4]; > > Please use standard kernel type definitions (i.e. u8 in this case). > >> + >> + err = i2c_master_send(client, write_buf, sizeof(write_buf)); >> + if (err < 0) >> + return err; > > You correctly return err (or rather, ret) for negative values, but you should also > check that ret matches the size of the data sent. For 0 <= ret < sizeof(writebuf), > return -EIO. > >> + err = i2c_master_recv(client, read_buf, sizeof(read_buf)); >> + if (err < 0) >> + return err; > > And here. > >> + >> + u32 result = get_unaligned_be32(&read_buf); > > Please do not mix declarations and code; all declarations must be at the > top of the function. > >> + >> + data->button_a = !test_bit(BUTTON_A, (long *)&result); >> + data->button_b = !test_bit(BUTTON_B, (long *)&result); >> + data->button_x = !test_bit(BUTTON_X, (long *)&result); >> + data->button_y = !test_bit(BUTTON_Y, (long *)&result); >> + data->button_start = !test_bit(BUTTON_START, (long *)&result); >> + data->button_select = !test_bit(BUTTON_SELECT, (long *)&result); >> + >> + write_buf[0] = SEESAW_ADC_BASE; >> + write_buf[1] = SEESAW_ADC_OFFSET + ANALOG_X; >> + err = i2c_master_send(client, write_buf, sizeof(write_buf)); >> + if (err < 0) >> + return err; >> + err = i2c_master_recv(client, (char *)&data->x, sizeof(data->x)); >> + if (err < 0) >> + return err; > > This is starting to look like a 16-bit register map. To that end, please > consider using regmap instead of open-coding each of these standard write- > then-read operations. > > Using regmap would also save you the trouble of managing the endianness > yourself, as well as having to check for incomplete transfers since its > functions return zero or a negative error code only. > In this driver there are only two places a 16-bit regmap could be used, for getting the joystick X and Y values. I see minimal utility in adding the boilerplate necessary to use the more sophisticated regmap API in this case. As for the handling of endianness, if I am not mistaken the `be16_to_cpu` macro should manage it. If you prefer I could add the following function to reduce code duplication: int seesaw_get_analog(int pin) { __be16 result; u8 write_buf[2] = { SEESAW_ADC_BASE, SEESAW_ADC_OFFSET + pin }; int ret; ret = i2c_master_send(client, write_buf, sizeof(write_buf)); if (ret < 0) return ret; ret = i2c_master_recv(client, (char *)&result, sizeof(result)); if (ret < 0) return ret; return result; } >> + /* >> + * ADC reads left as max and right as 0, must be reversed since kernel >> + * expects reports in opposite order. >> + */ >> + data->x = SEESAW_JOYSTICK_MAX_AXIS - be16_to_cpu(data->x); >> + >> + write_buf[1] = SEESAW_ADC_OFFSET + ANALOG_Y; >> + err = i2c_master_send(client, write_buf, sizeof(write_buf)); >> + if (err < 0) >> + return err; >> + err = i2c_master_recv(client, (char *)&data->y, sizeof(data->y)); >> + if (err < 0) >> + return err; >> + data->y = be16_to_cpu(data->y); >> + >> + return 0; >> +} >> + >> +static void seesaw_poll(struct input_dev *input) >> +{ >> + struct seesaw_gamepad *private = input_get_drvdata(input); >> + struct seesaw_data data; >> + int err; >> + >> + err = seesaw_read_data(private->i2c_client, &data); >> + if (err != 0) { >> + dev_dbg(&input->dev, "failed to read joystick state: %d\n", >> + err); > > This should be dev_err_ratelimited(). > >> + return; >> + } >> + >> + input_report_abs(input, ABS_X, data.x); >> + input_report_abs(input, ABS_Y, data.y); >> + input_report_key(input, BTN_EAST, data.button_a); >> + input_report_key(input, BTN_SOUTH, data.button_b); >> + input_report_key(input, BTN_NORTH, data.button_x); >> + input_report_key(input, BTN_WEST, data.button_y); >> + input_report_key(input, BTN_START, data.button_start); >> + input_report_key(input, BTN_SELECT, data.button_select); > > I think you can make this much cleaner and smaller by defining an array > of structs, each with a key code and bit position. You can then simply > iterate over the array and call input_report_key() once per element as > in the following: > > struct seesaw_btn_desc { > unsigned int code; > unsigned int shift; > }; > > static const struct seesaw_btn_desc seesaw_btns[] = { > { > .code = BTN_EAST, > .mask = 5, > }, > [...] > }; > > And then: > > btn_status = ...; > > for (i = 0; i < ARRAY_SIZE(seesaw_btns); i++) > input_report_key(input, seesaw_btns[i].code, > btn_status & seesaw_btns[i].mask); > > This would also make it easier to quickly discern what keycodes are mapped > to which bits in the register. > >> + input_sync(input); >> +} >> + >> +static int seesaw_probe(struct i2c_client *client) >> +{ >> + int err; >> + struct seesaw_gamepad *private; > > I'd rather this be called something like 'seesaw' rather than private. > >> + unsigned char register_reset[] = { SEESAW_STATUS_BASE, >> + SEESAW_STATUS_SWRST, 0xFF }; >> + unsigned char get_hw_id[] = { SEESAW_STATUS_BASE, SEESAW_STATUS_HW_ID }; >> + >> + err = i2c_master_send(client, register_reset, sizeof(register_reset)); >> + if (err < 0) >> + return err; >> + >> + /* Wait for the registers to reset before proceeding */ >> + mdelay(10); >> + >> + private = devm_kzalloc(&client->dev, sizeof(*private), GFP_KERNEL); >> + if (!private) >> + return -ENOMEM; >> + >> + err = i2c_master_send(client, get_hw_id, sizeof(get_hw_id)); >> + if (err < 0) >> + return err; >> + >> + unsigned char hardware_id; > > Same comment as earlier with regard to mixed declarations. > >> + >> + err = i2c_master_recv(client, &hardware_id, 1); >> + if (err < 0) >> + return err; >> + >> + dev_dbg(&client->dev, "Adafruit Seesaw Gamepad, Hardware ID: %02x\n", >> + hardware_id); >> + >> + private->i2c_client = client; >> + scnprintf(private->physical_path, sizeof(private->physical_path), >> + "i2c/%s", dev_name(&client->dev)); > > This seems overly complex; can we not simply set input_dev->phys to the > literal "i2c/seesaw-gamepad"? Why to copy at runtime and incur the cost > of carrying 'physical_path' throughout the life of the module? > >> + i2c_set_clientdata(client, private); >> + >> + private->input_dev = devm_input_allocate_device(&client->dev); >> + if (!private->input_dev) >> + return -ENOMEM; >> + >> + private->input_dev->id.bustype = BUS_I2C; >> + private->input_dev->name = "Adafruit Seesaw Gamepad"; >> + private->input_dev->phys = private->physical_path; >> + input_set_drvdata(private->input_dev, private); >> + input_set_abs_params(private->input_dev, ABS_X, 0, >> + SEESAW_JOYSTICK_MAX_AXIS, SEESAW_JOYSTICK_FUZZ, >> + SEESAW_JOYSTICK_FLAT); >> + input_set_abs_params(private->input_dev, ABS_Y, 0, >> + SEESAW_JOYSTICK_MAX_AXIS, SEESAW_JOYSTICK_FUZZ, >> + SEESAW_JOYSTICK_FLAT); >> + input_set_capability(private->input_dev, EV_KEY, BTN_EAST); >> + input_set_capability(private->input_dev, EV_KEY, BTN_SOUTH); >> + input_set_capability(private->input_dev, EV_KEY, BTN_NORTH); >> + input_set_capability(private->input_dev, EV_KEY, BTN_WEST); >> + input_set_capability(private->input_dev, EV_KEY, BTN_START); >> + input_set_capability(private->input_dev, EV_KEY, BTN_SELECT); > > Same comment with regard to creating an array of structs, and hence only > having to call input_set_capability() from within a small loop. > >> + >> + err = input_setup_polling(private->input_dev, seesaw_poll); >> + if (err) { >> + dev_err(&client->dev, "failed to set up polling: %d\n", err); >> + return err; >> + } >> + >> + input_set_poll_interval(private->input_dev, >> + SEESAW_GAMEPAD_POLL_INTERVAL); >> + input_set_max_poll_interval(private->input_dev, >> + SEESAW_GAMEPAD_POLL_MAX); >> + input_set_min_poll_interval(private->input_dev, >> + SEESAW_GAMEPAD_POLL_MIN); >> + >> + err = input_register_device(private->input_dev); >> + if (err) { >> + dev_err(&client->dev, "failed to register joystick: %d\n", err); >> + return err; >> + } >> + >> + /* Set Pin Mode to input and enable pull-up resistors */ >> + unsigned char pin_mode[] = { SEESAW_GPIO_BASE, SEESAW_GPIO_DIRCLR_BULK, >> + BUTTON_MASK >> 24, BUTTON_MASK >> 16, >> + BUTTON_MASK >> 8, BUTTON_MASK }; >> + err = i2c_master_send(client, pin_mode, sizeof(pin_mode)); >> + if (err < 0) >> + return err; >> + pin_mode[1] = SEESAW_GPIO_PULLENSET; >> + err = i2c_master_send(client, pin_mode, sizeof(pin_mode)); >> + if (err < 0) >> + return err; >> + pin_mode[1] = SEESAW_GPIO_BULK_SET; >> + err = i2c_master_send(client, pin_mode, sizeof(pin_mode)); >> + if (err < 0) >> + return err; > > Please configure the HW before the input device is live and being polled. > Could you elaborate on what you meant by this. To my knowledge, the device is ready to be polled right after the pin state for the `BUTTON_MASK` is configured. That is also how it's done in the Arduino driver provided by the manufacturer. Please clarify if I'm missing something here. >> + >> + return 0; >> +} >> + >> +#ifdef CONFIG_OF >> +static const struct of_device_id of_seesaw_match[] = { >> + { >> + .compatible = "adafruit,seesaw-gamepad", >> + }, >> + { /* Sentinel */ } >> +}; >> +MODULE_DEVICE_TABLE(of, of_seesaw_match); >> +#endif /* CONFIG_OF */ > > Please correct me if I am wrong, but it does not seem that OF support is > required by this driver. There are no properties beyond the standard ones > understood by the I2C core, which can match based on the ID table below. > >> + >> +/* clang-format off */ >> +static const struct i2c_device_id seesaw_id_table[] = { >> + { SEESAW_DEVICE_NAME, 0 }, >> + { /* Sentinel */ } >> +}; >> +/* clang-format on */ > > Again, I don't see any need for these directives. > >> + > > Nit: unnecessary NL. > >> +MODULE_DEVICE_TABLE(i2c, seesaw_id_table); >> + >> +static struct i2c_driver seesaw_driver = { >> + .driver = { >> + .name = SEESAW_DEVICE_NAME, >> + .of_match_table = of_match_ptr(of_seesaw_match), >> + }, >> + .id_table = seesaw_id_table, >> + .probe = seesaw_probe, >> +}; >> +module_i2c_driver(seesaw_driver); >> + >> +MODULE_AUTHOR("Anshul Dalal "); >> +MODULE_DESCRIPTION("Adafruit Mini I2C Gamepad driver"); >> +MODULE_LICENSE("GPL"); >> -- >> 2.42.0 >> > > Kind regards, > Jeff LaBundy Regards, Anshul Dalal