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 smtp4.osuosl.org (smtp4.osuosl.org [140.211.166.137]) (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 568C0C25B48 for ; Fri, 27 Oct 2023 05:19:59 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp4.osuosl.org (Postfix) with ESMTP id E9E7140673; Fri, 27 Oct 2023 05:19:58 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp4.osuosl.org E9E7140673 Authentication-Results: smtp4.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=gTfTFS9c X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp4.osuosl.org ([127.0.0.1]) by localhost (smtp4.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id cl3BVkHe1p96; Fri, 27 Oct 2023 05:19:57 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp4.osuosl.org (Postfix) with ESMTPS id 59AA640590; Fri, 27 Oct 2023 05:19:57 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp4.osuosl.org 59AA640590 Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 2BF17C007F; Fri, 27 Oct 2023 05:19:57 +0000 (UTC) Received: from smtp2.osuosl.org (smtp2.osuosl.org [IPv6:2605:bc80:3010::133]) by lists.linuxfoundation.org (Postfix) with ESMTP id D4EEAC0032 for ; Fri, 27 Oct 2023 05:19:56 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id A273E419AF for ; Fri, 27 Oct 2023 05:19:56 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp2.osuosl.org A273E419AF Authentication-Results: smtp2.osuosl.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20230601 header.b=gTfTFS9c X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp2.osuosl.org ([127.0.0.1]) by localhost (smtp2.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id JCv1LgDDQxwb for ; Fri, 27 Oct 2023 05:19:55 +0000 (UTC) Received: from mail-pf1-x435.google.com (mail-pf1-x435.google.com [IPv6:2607:f8b0:4864:20::435]) by smtp2.osuosl.org (Postfix) with ESMTPS id DB225431BF for ; Fri, 27 Oct 2023 05:19:54 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp2.osuosl.org DB225431BF Received: by mail-pf1-x435.google.com with SMTP id d2e1a72fcca58-6b26a3163acso1597815b3a.2 for ; Thu, 26 Oct 2023 22:19:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1698383994; x=1698988794; darn=lists.linuxfoundation.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=2RNEzIaVtV/414HT6haHn0l0T8tiTVRxqza3+tEj9I8=; b=gTfTFS9cKziIkdf1wCC5fF1pA+rgcB/juOBYRcARk4U9k5a1a+Fjko352guDek3owq CuBo3dA5WS7WMLhSYmPVLcr+FYZmJkGIdkXKqV5n7rgRb3oltQxec2t2clULm/VndJpt vCiHzGZB3nKyXy5HuHBymlBd3fVvGL82+WOoUpoLBNhKw1pO3EsGE8uXGZLf/tkyU03Q pOwghHWM18H8plpTzzFw1BlnSKXHRazojtTQpiY0Yg8hdmmitjQ44E6pe7QMbTJj2qTl 2DKrzVUCKuaV/aJ9zI8Y3aw3U5Cyp4ZuaJMTdBlpgMHgqDzKsRpuE/PkqH7LhDJ+6hME Uu8g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698383994; x=1698988794; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=2RNEzIaVtV/414HT6haHn0l0T8tiTVRxqza3+tEj9I8=; b=jl8f+azBzJGH6g2b44y0yFxqJO0FcNSPWDSrHT844rd+qSF3wVLCkZXO0QYI9mHH7b zCMp2MggFVvmgZTFNBz6TuP8C6q8Q9NQ1KWJV+sBuOIHweNuRMHn4WXMvRHJMnJ/q4S3 6qKGL65OW9lwojH9PzzZbY4gLJWSW1mSyfuZN0f1EmsAGbg5J0L7DvnaIYAba5q5mcTl rZPoT3noUxkrLLCnbSeV1QNxLo5bp3VLH1H7E5/LJx0C1bxQF7Imqr0z84n2zt7fkmHU X4v7bipaAmvuy4JZmqInZMF9meM9CCNImAyqk3EZL/BBCyPzL+W2nG88+gpjMIowYheJ k3Gw== X-Gm-Message-State: AOJu0Yyy4yo9Q4dCuivqVeQwXSts0r7Emt7Lvu00xUH4gbtseUJ2LbyC HidF7RC0ZMhuqJOpFv0D62U= X-Google-Smtp-Source: AGHT+IEtM5nh8wn5Oqu0JDonDDESC+MoaubQennMrDPVsT5Cy4OtMVtMZXN/UFscmwWI5cgbu2K/NA== X-Received: by 2002:a05:6a20:12c7:b0:138:836c:5370 with SMTP id v7-20020a056a2012c700b00138836c5370mr2058597pzg.42.1698383994036; Thu, 26 Oct 2023 22:19:54 -0700 (PDT) Received: from localhost.localdomain ([2401:4900:6286:35cd:e1b0:b6b4:69e:b5fb]) by smtp.gmail.com with ESMTPSA id h16-20020a17090adb9000b00276e8e4f1fbsm2494296pjv.1.2023.10.26.22.19.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 26 Oct 2023 22:19:53 -0700 (PDT) From: Anshul Dalal To: linux-input@vger.kernel.org, devicetree@vger.kernel.org Subject: [PATCH v6 2/2] input: joystick: driver for Adafruit Seesaw Gamepad Date: Fri, 27 Oct 2023 10:48:11 +0530 Message-ID: <20231027051819.81333-2-anshulusr@gmail.com> X-Mailer: git-send-email 2.42.0 In-Reply-To: <20231027051819.81333-1-anshulusr@gmail.com> References: <20231027051819.81333-1-anshulusr@gmail.com> MIME-Version: 1.0 Cc: Conor Dooley , Anshul Dalal , Dmitry Torokhov , =?UTF-8?q?Thomas=20Wei=C3=9Fschuh?= , linux-kernel@vger.kernel.org, Rob Herring , Krzysztof Kozlowski , Jeff LaBundy , 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" QWRkcyBhIGRyaXZlciBmb3IgYSBtaW5pIGdhbWVwYWQgdGhhdCBjb21tdW5pY2F0ZXMgb3ZlciBp MmMsIHRoZSBnYW1lcGFkCmhhcyBiaWRpcmVjdGlvbmFsIHRodW1iIHN0aWNrIGlucHV0IGFuZCBz aXggYnV0dG9ucy4KClRoZSBnYW1lcGFkIGNoaXAgdXRpbGl6ZXMgdGhlIG9wZW4gZnJhbWV3b3Jr IGZyb20gQWRhZnJ1aXQgY2FsbGVkICdTZWVzYXcnCnRvIHRyYW5zbWl0IHRoZSBBREMgZGF0YSBm b3IgdGhlIGpveXN0aWNrIGFuZCBkaWdpdGFsIHBpbiBzdGF0ZSBmb3IgdGhlCmJ1dHRvbnMuIEkg aGF2ZSBvbmx5IGltcGxlbWVudGVkIHRoZSBmdW5jdGlvbmFsaXR5IHJlcXVpcmVkIHRvIHJlY2Vp dmUgdGhlCnRodW1iIHN0aWNrIGFuZCBidXR0b24gc3RhdGUuCgpTdGVwcyBpbiByZWFkaW5nIHRo ZSBnYW1lcGFkIHN0YXRlIG92ZXIgaTJjOgogIDEuIFJlc2V0IHRoZSByZWdpc3RlcnMKICAyLiBT ZXQgdGhlIHBpbiBtb2RlIG9mIHRoZSBwaW5zIHNwZWNpZmllZCBieSB0aGUgYEJVVFRPTl9NQVNL YCB0byBpbnB1dAogICAgICBgQlVUVE9OX01BU0tgOiBBIGJpdC1tYXAgZm9yIHRoZSBzaXggZGln aXRhbCBwaW5zIGludGVybmFsbHkKICAgICAgIGNvbm5lY3RlZCB0byB0aGUgam95c3RpY2sgYnV0 dG9ucy4KICAzLiBFbmFibGUgaW50ZXJuYWwgcHVsbHVwIHJlc2lzdG9ycyBmb3IgdGhlIGBCVVRU T05fTUFTS2AKICA0LiBCdWxrIHNldCB0aGUgcGluIHN0YXRlIEhJR0ggZm9yIGBCVVRUT05fTUFT S2AKICA1LiBQb2xsIHRoZSBkZXZpY2UgZm9yIGJ1dHRvbiBhbmQgam95c3RpY2sgc3RhdGUgZG9u ZSBieToKICAgICAgYHNlZXNhd19yZWFkX2RhdGEoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwg c3RydWN0IHNlZXNhd19kYXRhICpkYXRhKWAKClByb2R1Y3QgcGFnZToKICBodHRwczovL3d3dy5h ZGFmcnVpdC5jb20vcHJvZHVjdC81NzQzCkFyZHVpbm8gZHJpdmVyOgogIGh0dHBzOi8vZ2l0aHVi LmNvbS9hZGFmcnVpdC9BZGFmcnVpdF9TZWVzYXcKCkRyaXZlciB0ZXN0ZWQgb24gUlBpIFplcm8g MlcKClJldmlld2VkLWJ5OiBUaG9tYXMgV2Vpw59zY2h1aCA8bGludXhAd2Vpc3NzY2h1aC5uZXQ+ ClNpZ25lZC1vZmYtYnk6IEFuc2h1bCBEYWxhbCA8YW5zaHVsdXNyQGdtYWlsLmNvbT4KLS0tCkNo YW5nZXMgZm9yIHY2OgotIEFkZGVkIFRPRE8KLSBSZW1vdmVkIGBjbGFuZy1mb3JtYXRgIGRpcmVj dGl2ZXMKLSBOYW1lc3BhY2VkIGRldmljZSBidXR0b25zCi0gUmVtb3ZlZCBgY2hhciBwaHlzaWNh bF9wYXRoWzMyXWAgZmllbGQgZnJvbSBgc3RydWN0IHNlZXNhd19nYW1lcGFkYAotIEFkZGVkIGBw YWNrZWRgIGF0dHJpYnV0ZSB0byBgc3RydWN0IHNlZXNhd19kYXRhYAotIE1vdmVkIGZyb20gaGF2 aW5nIGJvb2xlYW5zIHBlciBidXR0b24gdG8gc2luZ2xlIGB1MzIgYnV0dG9uX3N0YXRlYAotIEFk ZGVkIGBzZWVzYXdfYnV0dG9uX2Rlc2NyaXB0aW9uYCBhcnJheSB0byBkaXJlY3RseSBhc3NvY2lh dGUgZGV2aWNlCiAgYnV0dG9ucyB3aXRoIHJlc3BlY3RpdmUga2V5Y29kZXMKLSBBZGRlZCB3cmFw cGVyIGZ1bmN0aW9ucyBgc2Vlc2F3X3JlZ2lzdGVyX2AgYXJvdW5kIGBpMmNfbWFzdGVyX2AgQVBJ Ci0gUmF0ZWxpbWl0ZWQgaW5wdXQgZXJyb3IgcmVwb3J0aW5nIHdpdGggYGRldl9lcnJfcmF0ZWxp bWl0ZWRgCi0gUmVtb3ZlZCBgb2ZfZGV2aWNlX2lkYAoKQ2hhbmdlcyBmb3IgdjU6Ci0gQWRkZWQg bGluayB0byB0aGUgZGF0YXNoZWV0Ci0gQWRkZWQgZGVidWcgbG9nIG1lc3NhZ2Ugd2hlbiBgc2Vl c2F3X3JlYWRfZGF0YWAgZmFpbHMKCkNoYW5nZXMgZm9yIHY0OgotIENoYW5nZWQgYDFVTCA8PCBC VVRUT05fYCB0byBCSVQoQlVUVE9OXykKLSBSZW1vdmVkIGBoYXJkd2FyZV9pZGAgZmllbGQgZnJv bSBgc3RydWN0IHNlZXNhd19nYW1lcGFkYAotIFJlbW92ZWQgcmVkdW5kYW50IGNoZWNrcyBmb3Ig dGhlIG51bWJlciBvZiBieXRlcyB3cml0dGVuIGFuZCByZWNlaXZlZCBieQogIGBpMmNfbWFzdGVy X3NlbmRgIGFuZCBgaTJjX21hc3Rlcl9yZWN2YAotIFVzZWQgYGdldF91bmFsaWduZWRfYmUzMmAg dG8gaW5zdGFudGlhdGUgYHUzMiByZXN1bHRgIGZyb20gYHJlYWRfYnVmYAotIENoYW5nZWQgIGBy ZXN1bHQgJiAoMVVMIDw8IEJVVFRPTl8pYCB0bwogIGB0ZXN0X2JpdChCVVRUT05fLCAobG9uZyAq KSZyZXN1bHQpYAotIENoYW5nZWQgYEtCVUlMRF9NT0ROQU1FYCBpbiBpZC10YWJsZXMgdG8gYFNF RVNBV19ERVZJQ0VfTkFNRWAKLSBGaXhlZCBmb3JtYXR0aW5nIGlzc3VlcwotIENoYW5nZWQgYnV0 dG9uIHJlcG9ydGluZzoKICAgIFNpbmNlIHRoZSBnYW1lcGFkIGhhZCB0aGUgYWN0aW9uIGJ1dHRv bnMgaW4gYSBub24tc3RhbmRhcmQgbGF5b3V0OgogICAgICAgICAoWCkKICAgICAgKFkpICAgKEEp CiAgICAgICAgIChCKQogICAgVGhlcmVmb3JlIG1vdmVkIHRvIHVzaW5nIGdlbmVyaWMgZGlyZWN0 aW9uYWwgYWN0aW9uIGJ1dHRvbiBldmVudCBjb2RlcwogICAgaW5zdGVhZCBvZiBCVE5fW0FCWFld LgoKQ2hhbmdlcyBmb3IgdjM6Ci0gbm8gdXBkYXRlcwoKQ2hhbmdlcyBmb3IgdjI6CmFkYWZydWl0 LXNlZXNhdy5jOgotIFJlbmFtZWQgZmlsZSBmcm9tICdhZGFmcnVpdF9zZWVzYXcuYycKLSBDaGFu Z2VkIGRldmljZSBuYW1lIGZyb20gJ3NlZXNhd19nYW1lcGFkJyB0byAnc2Vlc2F3LWdhbWVwYWQn Ci0gQ2hhbmdlZCBjb3VudCBwYXJhbWV0ZXIgZm9yIHJlY2VpdmluZyBqb3lzdGljayB4IG9uIGxp bmUgMTE4OgogICAgYDJgIHRvIGBzaXplb2Yod3JpdGVfYnVmKWAKLSBGaXhlZCBpbnZhbGlkIGJ1 ZmZlciBzaXplIG9uIGxpbmUgMTIzIGFuZCAxMjY6CiAgICBgZGF0YS0+eWAgdG8gYHNpemVvZihk YXRhLT55KWAKLSBBZGRlZCBjb21tZW50IGZvciB0aGUgYG1kZWxheSgxMClgIG9uIGxpbmUgMTY5 Ci0gQ2hhbmdlZCBpbmNvbnNpc3RlbnQgaW5kZW50YXRpb24gb24gbGluZSAyNzEKS2NvbmZpZzoK LSBGaXhlZCBpbmRlbnRhdGlvbiBmb3IgdGhlIGhlbHAgdGV4dAotIFVwZGF0ZWQgbW9kdWxlIG5h bWUKTWFrZWZpbGU6Ci0gVXBkYXRlZCBtb2R1bGUgb2JqZWN0IGZpbGUgbmFtZQpNQUlOVEFJTkVS UzoKLSBVcGRhdGVkIGZpbGUgbmFtZSBmb3IgdGhlIGRyaXZlciBhbmQgYmluZGluZ3MKCiBNQUlO VEFJTkVSUyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICA3ICsKIGRyaXZlcnMvaW5w dXQvam95c3RpY2svS2NvbmZpZyAgICAgICAgICAgfCAgIDkgKwogZHJpdmVycy9pbnB1dC9qb3lz dGljay9NYWtlZmlsZSAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL2lucHV0L2pveXN0aWNrL2Fk YWZydWl0LXNlZXNhdy5jIHwgMzEwICsrKysrKysrKysrKysrKysrKysrKysrCiA0IGZpbGVzIGNo YW5nZWQsIDMyNyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9pbnB1 dC9qb3lzdGljay9hZGFmcnVpdC1zZWVzYXcuYwoKZGlmZiAtLWdpdCBhL01BSU5UQUlORVJTIGIv TUFJTlRBSU5FUlMKaW5kZXggNGNjNmJmNzlmZGQ4Li4wNTk1YzgzMmMyNDggMTAwNjQ0Ci0tLSBh L01BSU5UQUlORVJTCisrKyBiL01BSU5UQUlORVJTCkBAIC00NDEsNiArNDQxLDEzIEBAIFc6CWh0 dHA6Ly93aWtpLmFuYWxvZy5jb20vQUQ3ODc5CiBXOglodHRwczovL2V6LmFuYWxvZy5jb20vbGlu dXgtc29mdHdhcmUtZHJpdmVycwogRjoJZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi9hZDc4Nzku YwogCitBREFGUlVJVCBNSU5JIEkyQyBHQU1FUEFECitNOglBbnNodWwgRGFsYWwgPGFuc2h1bHVz ckBnbWFpbC5jb20+CitMOglsaW51eC1pbnB1dEB2Z2VyLmtlcm5lbC5vcmcKK1M6CU1haW50YWlu ZWQKK0Y6CURvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pbnB1dC9hZGFmcnVpdCxz ZWVzYXctZ2FtZXBhZC55YW1sCitGOglkcml2ZXJzL2lucHV0L2pveXN0aWNrL2FkYWZydWl0LXNl ZXNhdy5jCisKIEFERFJFU1MgU1BBQ0UgTEFZT1VUIFJBTkRPTUlaQVRJT04gKEFTTFIpCiBNOglK aXJpIEtvc2luYSA8amlrb3NAa2VybmVsLm9yZz4KIFM6CU1haW50YWluZWQKZGlmZiAtLWdpdCBh L2RyaXZlcnMvaW5wdXQvam95c3RpY2svS2NvbmZpZyBiL2RyaXZlcnMvaW5wdXQvam95c3RpY2sv S2NvbmZpZwppbmRleCBhYzY5MjVjZTgzNjYuLmRmOWNkMTgzMGIyOSAxMDA2NDQKLS0tIGEvZHJp dmVycy9pbnB1dC9qb3lzdGljay9LY29uZmlnCisrKyBiL2RyaXZlcnMvaW5wdXQvam95c3RpY2sv S2NvbmZpZwpAQCAtNDEyLDQgKzQxMiwxMyBAQCBjb25maWcgSk9ZU1RJQ0tfU0VOU0VIQVQKIAkg IFRvIGNvbXBpbGUgdGhpcyBkcml2ZXIgYXMgYSBtb2R1bGUsIGNob29zZSBNIGhlcmU6IHRoZQog CSAgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIHNlbnNlaGF0X2pveXN0aWNrLgogCitjb25maWcgSk9Z U1RJQ0tfU0VFU0FXCisJdHJpc3RhdGUgIkFkYWZydWl0IE1pbmkgSTJDIEdhbWVwYWQgd2l0aCBT ZWVzYXciCisJZGVwZW5kcyBvbiBJMkMKKwloZWxwCisJICBTYXkgWSBoZXJlIGlmIHlvdSB3YW50 IHRvIHVzZSB0aGUgQWRhZnJ1aXQgTWluaSBJMkMgR2FtZXBhZC4KKworCSAgVG8gY29tcGlsZSB0 aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hvb3NlIE0gaGVyZTogdGhlIG1vZHVsZSB3aWxsIGJl CisJICBjYWxsZWQgYWRhZnJ1aXQtc2Vlc2F3LgorCiBlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9pbnB1dC9qb3lzdGljay9NYWtlZmlsZSBiL2RyaXZlcnMvaW5wdXQvam95c3RpY2svTWFrZWZp bGUKaW5kZXggMzkzNzUzNWYwMDk4Li45OTc2ZjU5NmE5MjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv aW5wdXQvam95c3RpY2svTWFrZWZpbGUKKysrIGIvZHJpdmVycy9pbnB1dC9qb3lzdGljay9NYWtl ZmlsZQpAQCAtMjgsNiArMjgsNyBAQCBvYmotJChDT05GSUdfSk9ZU1RJQ0tfTjY0KQkJKz0gbjY0 am95Lm8KIG9iai0kKENPTkZJR19KT1lTVElDS19QU1hQQURfU1BJKQkrPSBwc3hwYWQtc3BpLm8K IG9iai0kKENPTkZJR19KT1lTVElDS19QWFJDKQkJKz0gcHhyYy5vCiBvYmotJChDT05GSUdfSk9Z U1RJQ0tfUVdJSUMpCQkrPSBxd2lpYy1qb3lzdGljay5vCitvYmotJChDT05GSUdfSk9ZU1RJQ0tf U0VFU0FXKQkJKz0gYWRhZnJ1aXQtc2Vlc2F3Lm8KIG9iai0kKENPTkZJR19KT1lTVElDS19TRU5T RUhBVCkJKz0gc2Vuc2VoYXQtam95c3RpY2subwogb2JqLSQoQ09ORklHX0pPWVNUSUNLX1NJREVX SU5ERVIpCSs9IHNpZGV3aW5kZXIubwogb2JqLSQoQ09ORklHX0pPWVNUSUNLX1NQQUNFQkFMTCkJ Kz0gc3BhY2ViYWxsLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvam95c3RpY2svYWRhZnJ1 aXQtc2Vlc2F3LmMgYi9kcml2ZXJzL2lucHV0L2pveXN0aWNrL2FkYWZydWl0LXNlZXNhdy5jCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMWFhNmZiZTRmZGE0Ci0tLSAv ZGV2L251bGwKKysrIGIvZHJpdmVycy9pbnB1dC9qb3lzdGljay9hZGFmcnVpdC1zZWVzYXcuYwpA QCAtMCwwICsxLDMxMCBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb3It bGF0ZXIKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgQW5zaHVsIERhbGFsIDxhbnNodWx1c3JA Z21haWwuY29tPgorICoKKyAqIERyaXZlciBmb3IgQWRhZnJ1aXQgTWluaSBJMkMgR2FtZXBhZAor ICoKKyAqIEJhc2VkIG9uIHRoZSB3b3JrIG9mOgorICoJT2xlaCBLcmF2Y2hlbmtvIChTcGFya2Z1 biBRd2lpYyBKb3lzdGljayBkcml2ZXIpCisgKgorICogRGF0YXNoZWV0OiBodHRwczovL2Nkbi1s ZWFybi5hZGFmcnVpdC5jb20vZG93bmxvYWRzL3BkZi9nYW1lcGFkLXF0LnBkZgorICogUHJvZHVj dCBwYWdlOiBodHRwczovL3d3dy5hZGFmcnVpdC5jb20vcHJvZHVjdC81NzQzCisgKiBGaXJtd2Fy ZSBhbmQgaGFyZHdhcmUgc291cmNlczogaHR0cHM6Ly9naXRodWIuY29tL2FkYWZydWl0L0FkYWZy dWl0X1NlZXNhdworICoKKyAqIFRPRE86CisgKgktIEFkZCBpbnRlcnJ1cHQgc3VwcG9ydAorICov CisKKyNpbmNsdWRlIDxhc20tZ2VuZXJpYy91bmFsaWduZWQuaD4KKyNpbmNsdWRlIDxsaW51eC9i aXRzLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9pMmMuaD4K KyNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2lu Y2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorCisjZGVmaW5lIFNFRVNBV19ERVZJQ0VfTkFNRQkic2Vl c2F3LWdhbWVwYWQiCisKKyNkZWZpbmUgU0VFU0FXX1NUQVRVU19CQVNFCTAKKyNkZWZpbmUgU0VF U0FXX0dQSU9fQkFTRQkxCisjZGVmaW5lIFNFRVNBV19BRENfQkFTRQkJOQorCisjZGVmaW5lIFNF RVNBV19HUElPX0RJUkNMUl9CVUxLCTMKKyNkZWZpbmUgU0VFU0FXX0dQSU9fQlVMSwk0CisjZGVm aW5lIFNFRVNBV19HUElPX0JVTEtfU0VUCTUKKyNkZWZpbmUgU0VFU0FXX0dQSU9fUFVMTEVOU0VU CTExCisKKyNkZWZpbmUgU0VFU0FXX1NUQVRVU19IV19JRAkxCisjZGVmaW5lIFNFRVNBV19TVEFU VVNfU1dSU1QJMTI3CisKKyNkZWZpbmUgU0VFU0FXX0FEQ19PRkZTRVQJNworCisjZGVmaW5lIFNF RVNBV19CVVRUT05fQQkJNQorI2RlZmluZSBTRUVTQVdfQlVUVE9OX0IJCTEKKyNkZWZpbmUgU0VF U0FXX0JVVFRPTl9YCQk2CisjZGVmaW5lIFNFRVNBV19CVVRUT05fWQkJMgorI2RlZmluZSBTRUVT QVdfQlVUVE9OX1NUQVJUCTE2CisjZGVmaW5lIFNFRVNBV19CVVRUT05fU0VMRUNUCTAKKworI2Rl ZmluZSBTRUVTQVdfQU5BTE9HX1gJCTE0CisjZGVmaW5lIFNFRVNBV19BTkFMT0dfWQkJMTUKKwor I2RlZmluZSBTRUVTQVdfSk9ZU1RJQ0tfTUFYX0FYSVMJMTAyMworI2RlZmluZSBTRUVTQVdfSk9Z U1RJQ0tfRlVaWgkJMgorI2RlZmluZSBTRUVTQVdfSk9ZU1RJQ0tfRkxBVAkJNAorCisjZGVmaW5l IFNFRVNBV19HQU1FUEFEX1BPTExfSU5URVJWQUwJMTYKKyNkZWZpbmUgU0VFU0FXX0dBTUVQQURf UE9MTF9NSU4JCTgKKyNkZWZpbmUgU0VFU0FXX0dBTUVQQURfUE9MTF9NQVgJCTMyCisKK3UzMiBT RUVTQVdfQlVUVE9OX01BU0sgPSBCSVQoU0VFU0FXX0JVVFRPTl9BKSB8IEJJVChTRUVTQVdfQlVU VE9OX0IpIHwKKwkJCSBCSVQoU0VFU0FXX0JVVFRPTl9YKSB8IEJJVChTRUVTQVdfQlVUVE9OX1kp IHwKKwkJCSBCSVQoU0VFU0FXX0JVVFRPTl9TVEFSVCkgfCBCSVQoU0VFU0FXX0JVVFRPTl9TRUxF Q1QpOworCitzdHJ1Y3Qgc2Vlc2F3X2dhbWVwYWQgeworCXN0cnVjdCBpbnB1dF9kZXYgKmlucHV0 X2RldjsKKwlzdHJ1Y3QgaTJjX2NsaWVudCAqaTJjX2NsaWVudDsKK307CisKK3N0cnVjdCBzZWVz YXdfZGF0YSB7CisJX19iZTE2IHg7CisJX19iZTE2IHk7CisJdTMyIGJ1dHRvbl9zdGF0ZTsKK30g X19wYWNrZWQ7CisKK3N0cnVjdCBzZWVzYXdfYnV0dG9uX2Rlc2NyaXB0aW9uIHsKKwl1bnNpZ25l ZCBpbnQgY29kZTsKKwl1bnNpZ25lZCBpbnQgYml0OworfTsKKworc3RhdGljIGNvbnN0IHN0cnVj dCBzZWVzYXdfYnV0dG9uX2Rlc2NyaXB0aW9uIHNlZXNhd19idXR0b25zW10gPSB7CisJeworCQku Y29kZSA9IEJUTl9FQVNULAorCQkuYml0ID0gU0VFU0FXX0JVVFRPTl9BLAorCX0sCisJeworCQku Y29kZSA9IEJUTl9TT1VUSCwKKwkJLmJpdCA9IFNFRVNBV19CVVRUT05fQiwKKwl9LAorCXsKKwkJ LmNvZGUgPSBCVE5fTk9SVEgsCisJCS5iaXQgPSBTRUVTQVdfQlVUVE9OX1gsCisJfSwKKwl7CisJ CS5jb2RlID0gQlROX1dFU1QsCisJCS5iaXQgPSBTRUVTQVdfQlVUVE9OX1ksCisJfSwKKwl7CisJ CS5jb2RlID0gQlROX1NUQVJULAorCQkuYml0ID0gU0VFU0FXX0JVVFRPTl9TVEFSVCwKKwl9LAor CXsKKwkJLmNvZGUgPSBCVE5fU0VMRUNULAorCQkuYml0ID0gU0VFU0FXX0JVVFRPTl9TRUxFQ1Qs CisJfSwKK307CisKK3N0YXRpYyBpbnQgc2Vlc2F3X3JlZ2lzdGVyX3JlYWQoc3RydWN0IGkyY19j bGllbnQgKmNsaWVudCwgdTggcmVnaXN0ZXJfaGlnaCwKKwkJCQl1OCByZWdpc3Rlcl9sb3csIGNo YXIgKmJ1ZiwgaW50IGNvdW50KQoreworCWludCByZXQ7CisJdTggcmVnaXN0ZXJfYnVmWzJdID0g eyByZWdpc3Rlcl9oaWdoLCByZWdpc3Rlcl9sb3cgfTsKKworCXJldCA9IGkyY19tYXN0ZXJfc2Vu ZChjbGllbnQsIHJlZ2lzdGVyX2J1Ziwgc2l6ZW9mKHJlZ2lzdGVyX2J1ZikpOworCWlmIChyZXQg PCAwKQorCQlyZXR1cm4gcmV0OworCXJldCA9IGkyY19tYXN0ZXJfcmVjdihjbGllbnQsIGJ1Ziwg Y291bnQpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJcmV0dXJuIDA7Cit9CisK K3N0YXRpYyBpbnQgc2Vlc2F3X3JlZ2lzdGVyX3dyaXRlX3U4KHN0cnVjdCBpMmNfY2xpZW50ICpj bGllbnQsIHU4IHJlZ2lzdGVyX2hpZ2gsCisJCQkJICAgIHU4IHJlZ2lzdGVyX2xvdywgdTggdmFs dWUpCit7CisJaW50IHJldDsKKwl1OCB3cml0ZV9idWZbM10gPSB7IHJlZ2lzdGVyX2hpZ2gsIHJl Z2lzdGVyX2xvdywgdmFsdWUgfTsKKworCXJldCA9IGkyY19tYXN0ZXJfc2VuZChjbGllbnQsIHdy aXRlX2J1Ziwgc2l6ZW9mKHdyaXRlX2J1ZikpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0 OworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgc2Vlc2F3X3JlZ2lzdGVyX3dyaXRlX3Uz MihzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LAorCQkJCSAgICAgdTggcmVnaXN0ZXJfaGlnaCwg dTggcmVnaXN0ZXJfbG93LAorCQkJCSAgICAgdTMyIHZhbHVlKQoreworCWludCByZXQ7CisJdTgg d3JpdGVfYnVmWzZdID0geyByZWdpc3Rlcl9oaWdoLCByZWdpc3Rlcl9sb3cgfTsKKworCXB1dF91 bmFsaWduZWRfYmUzMih2YWx1ZSwgd3JpdGVfYnVmICsgMik7CisJcmV0ID0gaTJjX21hc3Rlcl9z ZW5kKGNsaWVudCwgd3JpdGVfYnVmLCBzaXplb2Yod3JpdGVfYnVmKSk7CisJaWYgKHJldCA8IDAp CisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBzZWVzYXdfcmVh ZF9kYXRhKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsIHN0cnVjdCBzZWVzYXdfZGF0YSAqZGF0 YSkKK3sKKwlpbnQgcmV0OworCXU4IHJlYWRfYnVmWzRdOworCisJcmV0ID0gc2Vlc2F3X3JlZ2lz dGVyX3JlYWQoY2xpZW50LCBTRUVTQVdfR1BJT19CQVNFLCBTRUVTQVdfR1BJT19CVUxLLAorCQkJ CSAgIHJlYWRfYnVmLCBzaXplb2YocmVhZF9idWYpKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0 OworCisJZGF0YS0+YnV0dG9uX3N0YXRlID0gfmdldF91bmFsaWduZWRfYmUzMigmcmVhZF9idWYp OworCisJcmV0ID0gc2Vlc2F3X3JlZ2lzdGVyX3JlYWQoY2xpZW50LCBTRUVTQVdfQURDX0JBU0Us CisJCQkJICAgU0VFU0FXX0FEQ19PRkZTRVQgKyBTRUVTQVdfQU5BTE9HX1gsCisJCQkJICAgKGNo YXIgKikmZGF0YS0+eCwgc2l6ZW9mKGRhdGEtPngpKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0 OworCS8qCisJICogQURDIHJlYWRzIGxlZnQgYXMgbWF4IGFuZCByaWdodCBhcyAwLCBtdXN0IGJl IHJldmVyc2VkIHNpbmNlIGtlcm5lbAorCSAqIGV4cGVjdHMgcmVwb3J0cyBpbiBvcHBvc2l0ZSBv cmRlci4KKwkgKi8KKwlkYXRhLT54ID0gU0VFU0FXX0pPWVNUSUNLX01BWF9BWElTIC0gYmUxNl90 b19jcHUoZGF0YS0+eCk7CisKKwlyZXQgPSBzZWVzYXdfcmVnaXN0ZXJfcmVhZChjbGllbnQsIFNF RVNBV19BRENfQkFTRSwKKwkJCQkgICBTRUVTQVdfQURDX09GRlNFVCArIFNFRVNBV19BTkFMT0df WSwKKwkJCQkgICAoY2hhciAqKSZkYXRhLT55LCBzaXplb2YoZGF0YS0+eSkpOworCWlmIChyZXQp CisJCXJldHVybiByZXQ7CisJZGF0YS0+eSA9IGJlMTZfdG9fY3B1KGRhdGEtPnkpOworCisJcmV0 dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIHNlZXNhd19wb2xsKHN0cnVjdCBpbnB1dF9kZXYgKmlu cHV0KQoreworCWludCBlcnIsIGk7CisJc3RydWN0IHNlZXNhd19nYW1lcGFkICpwcml2YXRlID0g aW5wdXRfZ2V0X2RydmRhdGEoaW5wdXQpOworCXN0cnVjdCBzZWVzYXdfZGF0YSBkYXRhOworCisJ ZXJyID0gc2Vlc2F3X3JlYWRfZGF0YShwcml2YXRlLT5pMmNfY2xpZW50LCAmZGF0YSk7CisJaWYg KGVyciAhPSAwKSB7CisJCWRldl9lcnJfcmF0ZWxpbWl0ZWQoJmlucHV0LT5kZXYsCisJCQkJICAg ICJmYWlsZWQgdG8gcmVhZCBqb3lzdGljayBzdGF0ZTogJWRcbiIsIGVycik7CisJCXJldHVybjsK Kwl9CisKKwlpbnB1dF9yZXBvcnRfYWJzKGlucHV0LCBBQlNfWCwgZGF0YS54KTsKKwlpbnB1dF9y ZXBvcnRfYWJzKGlucHV0LCBBQlNfWSwgZGF0YS55KTsKKworCWZvciAoaSA9IDA7IGkgPCBBUlJB WV9TSVpFKHNlZXNhd19idXR0b25zKTsgaSsrKSB7CisJCWlucHV0X3JlcG9ydF9rZXkoaW5wdXQs IHNlZXNhd19idXR0b25zW2ldLmNvZGUsCisJCQkJIGRhdGEuYnV0dG9uX3N0YXRlICYKKwkJCQkJ IEJJVChzZWVzYXdfYnV0dG9uc1tpXS5iaXQpKTsKKwl9CisJaW5wdXRfc3luYyhpbnB1dCk7Cit9 CisKK3N0YXRpYyBpbnQgc2Vlc2F3X3Byb2JlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQpCit7 CisJaW50IGVyciwgaTsKKwl1OCBoYXJkd2FyZV9pZDsKKwlzdHJ1Y3Qgc2Vlc2F3X2dhbWVwYWQg KnNlZXNhdzsKKworCWVyciA9IHNlZXNhd19yZWdpc3Rlcl93cml0ZV91OChjbGllbnQsIFNFRVNB V19TVEFUVVNfQkFTRSwKKwkJCQkgICAgICAgU0VFU0FXX1NUQVRVU19TV1JTVCwgMHhGRik7CisJ aWYgKGVycikKKwkJcmV0dXJuIGVycjsKKworCS8qIFdhaXQgZm9yIHRoZSByZWdpc3RlcnMgdG8g cmVzZXQgYmVmb3JlIHByb2NlZWRpbmcgKi8KKwltZGVsYXkoMTApOworCisJc2Vlc2F3ID0gZGV2 bV9remFsbG9jKCZjbGllbnQtPmRldiwgc2l6ZW9mKCpzZWVzYXcpLCBHRlBfS0VSTkVMKTsKKwlp ZiAoIXNlZXNhdykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwllcnIgPSBzZWVzYXdfcmVnaXN0ZXJf cmVhZChjbGllbnQsIFNFRVNBV19TVEFUVVNfQkFTRSwKKwkJCQkgICBTRUVTQVdfU1RBVFVTX0hX X0lELCAmaGFyZHdhcmVfaWQsIDEpOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CisKKwlkZXZf ZGJnKCZjbGllbnQtPmRldiwgIkFkYWZydWl0IFNlZXNhdyBHYW1lcGFkLCBIYXJkd2FyZSBJRDog JTAyeFxuIiwKKwkJaGFyZHdhcmVfaWQpOworCisJLyogU2V0IFBpbiBNb2RlIHRvIGlucHV0IGFu ZCBlbmFibGUgcHVsbC11cCByZXNpc3RvcnMgKi8KKwllcnIgPSBzZWVzYXdfcmVnaXN0ZXJfd3Jp dGVfdTMyKGNsaWVudCwgU0VFU0FXX0dQSU9fQkFTRSwKKwkJCQkJU0VFU0FXX0dQSU9fRElSQ0xS X0JVTEssCisJCQkJCVNFRVNBV19CVVRUT05fTUFTSyk7CisJaWYgKGVycikKKwkJcmV0dXJuIGVy cjsKKwllcnIgPSBzZWVzYXdfcmVnaXN0ZXJfd3JpdGVfdTMyKGNsaWVudCwgU0VFU0FXX0dQSU9f QkFTRSwKKwkJCQkJU0VFU0FXX0dQSU9fUFVMTEVOU0VULAorCQkJCQlTRUVTQVdfQlVUVE9OX01B U0spOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CisJZXJyID0gc2Vlc2F3X3JlZ2lzdGVyX3dy aXRlX3UzMihjbGllbnQsIFNFRVNBV19HUElPX0JBU0UsCisJCQkJCVNFRVNBV19HUElPX0JVTEtf U0VULAorCQkJCQlTRUVTQVdfQlVUVE9OX01BU0spOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7 CisKKwlzZWVzYXctPmkyY19jbGllbnQgPSBjbGllbnQ7CisJaTJjX3NldF9jbGllbnRkYXRhKGNs aWVudCwgc2Vlc2F3KTsKKworCXNlZXNhdy0+aW5wdXRfZGV2ID0gZGV2bV9pbnB1dF9hbGxvY2F0 ZV9kZXZpY2UoJmNsaWVudC0+ZGV2KTsKKwlpZiAoIXNlZXNhdy0+aW5wdXRfZGV2KQorCQlyZXR1 cm4gLUVOT01FTTsKKworCXNlZXNhdy0+aW5wdXRfZGV2LT5pZC5idXN0eXBlID0gQlVTX0kyQzsK KwlzZWVzYXctPmlucHV0X2Rldi0+bmFtZSA9ICJBZGFmcnVpdCBTZWVzYXcgR2FtZXBhZCI7CisJ c2Vlc2F3LT5pbnB1dF9kZXYtPnBoeXMgPSAiaTJjLyIgU0VFU0FXX0RFVklDRV9OQU1FOworCWlu cHV0X3NldF9kcnZkYXRhKHNlZXNhdy0+aW5wdXRfZGV2LCBzZWVzYXcpOworCWlucHV0X3NldF9h YnNfcGFyYW1zKHNlZXNhdy0+aW5wdXRfZGV2LCBBQlNfWCwgMCwKKwkJCSAgICAgU0VFU0FXX0pP WVNUSUNLX01BWF9BWElTLCBTRUVTQVdfSk9ZU1RJQ0tfRlVaWiwKKwkJCSAgICAgU0VFU0FXX0pP WVNUSUNLX0ZMQVQpOworCWlucHV0X3NldF9hYnNfcGFyYW1zKHNlZXNhdy0+aW5wdXRfZGV2LCBB QlNfWSwgMCwKKwkJCSAgICAgU0VFU0FXX0pPWVNUSUNLX01BWF9BWElTLCBTRUVTQVdfSk9ZU1RJ Q0tfRlVaWiwKKwkJCSAgICAgU0VFU0FXX0pPWVNUSUNLX0ZMQVQpOworCWZvciAoaSA9IDA7IGkg PCBBUlJBWV9TSVpFKHNlZXNhd19idXR0b25zKTsgaSsrKSB7CisJCWlucHV0X3NldF9jYXBhYmls aXR5KHNlZXNhdy0+aW5wdXRfZGV2LCBFVl9LRVksCisJCQkJICAgICBzZWVzYXdfYnV0dG9uc1tp XS5jb2RlKTsKKwl9CisKKwllcnIgPSBpbnB1dF9zZXR1cF9wb2xsaW5nKHNlZXNhdy0+aW5wdXRf ZGV2LCBzZWVzYXdfcG9sbCk7CisJaWYgKGVycikgeworCQlkZXZfZXJyKCZjbGllbnQtPmRldiwg ImZhaWxlZCB0byBzZXQgdXAgcG9sbGluZzogJWRcbiIsIGVycik7CisJCXJldHVybiBlcnI7CisJ fQorCisJaW5wdXRfc2V0X3BvbGxfaW50ZXJ2YWwoc2Vlc2F3LT5pbnB1dF9kZXYsCisJCQkJU0VF U0FXX0dBTUVQQURfUE9MTF9JTlRFUlZBTCk7CisJaW5wdXRfc2V0X21heF9wb2xsX2ludGVydmFs KHNlZXNhdy0+aW5wdXRfZGV2LCBTRUVTQVdfR0FNRVBBRF9QT0xMX01BWCk7CisJaW5wdXRfc2V0 X21pbl9wb2xsX2ludGVydmFsKHNlZXNhdy0+aW5wdXRfZGV2LCBTRUVTQVdfR0FNRVBBRF9QT0xM X01JTik7CisKKwllcnIgPSBpbnB1dF9yZWdpc3Rlcl9kZXZpY2Uoc2Vlc2F3LT5pbnB1dF9kZXYp OworCWlmIChlcnIpIHsKKwkJZGV2X2VycigmY2xpZW50LT5kZXYsICJmYWlsZWQgdG8gcmVnaXN0 ZXIgam95c3RpY2s6ICVkXG4iLCBlcnIpOworCQlyZXR1cm4gZXJyOworCX0KKworCXJldHVybiAw OworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgc2Vlc2F3X2lkX3RhYmxl W10gPSB7CisJeyBTRUVTQVdfREVWSUNFX05BTUUsIDAgfSwKKwl7IC8qIFNlbnRpbmVsICovIH0K K307CitNT0RVTEVfREVWSUNFX1RBQkxFKGkyYywgc2Vlc2F3X2lkX3RhYmxlKTsKKworc3RhdGlj IHN0cnVjdCBpMmNfZHJpdmVyIHNlZXNhd19kcml2ZXIgPSB7CisJLmRyaXZlciA9IHsKKwkJLm5h bWUgPSBTRUVTQVdfREVWSUNFX05BTUUsCisJfSwKKwkuaWRfdGFibGUgPSBzZWVzYXdfaWRfdGFi bGUsCisJLnByb2JlID0gc2Vlc2F3X3Byb2JlLAorfTsKK21vZHVsZV9pMmNfZHJpdmVyKHNlZXNh d19kcml2ZXIpOworCitNT0RVTEVfQVVUSE9SKCJBbnNodWwgRGFsYWwgPGFuc2h1bHVzckBnbWFp bC5jb20+Iik7CitNT0RVTEVfREVTQ1JJUFRJT04oIkFkYWZydWl0IE1pbmkgSTJDIEdhbWVwYWQg ZHJpdmVyIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7Ci0tIAoyLjQyLjAKCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkxpbnV4LWtlcm5lbC1tZW50ZWVz IG1haWxpbmcgbGlzdApMaW51eC1rZXJuZWwtbWVudGVlc0BsaXN0cy5saW51eGZvdW5kYXRpb24u b3JnCmh0dHBzOi8vbGlzdHMubGludXhmb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xp bnV4LWtlcm5lbC1tZW50ZWVzCg== 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 0C5C1C25B47 for ; Fri, 27 Oct 2023 05:20:00 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232135AbjJ0FT7 (ORCPT ); Fri, 27 Oct 2023 01:19:59 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60744 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229590AbjJ0FT6 (ORCPT ); Fri, 27 Oct 2023 01:19:58 -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 2F9B71A5; Thu, 26 Oct 2023 22:19:55 -0700 (PDT) Received: by mail-pf1-x42b.google.com with SMTP id d2e1a72fcca58-6b26a3163acso1597818b3a.2; Thu, 26 Oct 2023 22:19:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1698383994; x=1698988794; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=2RNEzIaVtV/414HT6haHn0l0T8tiTVRxqza3+tEj9I8=; b=bhPKnWwL86oaRXxZXlPEzMFXhSwgxZyokK4ZV3OuIWb9BmxXhheoDSOO4cmk0ZteY0 06QerrqKT5mo69rktSY/zkfWiQx9U+IfXcSuZGmmFzGXMagBwzS8HYKrF6uPOYBpUhO2 9YsCjAfyofy3CfnGfqzAJyPGWzNuOVW1ruMlvbYIAj76Bm2cgz1r4EqEgx8uGFIdBNb+ X9vOtWyWM/5sm4mpPtF+W6iSU/puzX/FBu5QOcDvyBTGlIC3o7YNXzasiD9omDg8hkUX p7/4bW7XC4nq0N8L1MeI/slo0J+nVFF6Dj1/E5hfL2lGZbfknZOW2QXcx5xlVBrIheVE j/JA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698383994; x=1698988794; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=2RNEzIaVtV/414HT6haHn0l0T8tiTVRxqza3+tEj9I8=; b=VyQdU1u+hhEQMVr6M+pmpY1qFbzIyapcGH2dy8Bj/ICTdzyP0/U0qn42RwlBIkQwBH F3jSHpvOaKkf+jgtPwDlGs4nXEjsqrH+uB8So0O6hieWKDzz/I1cTIsUNoxSpNcK7Vm9 R4xRnJ8nOXYZS5tAWTfKi+dXyUlCqFgtmYi+Bm3YsWy4K0nOyWMv4UEMKMOzYuwDDO4u V/OhGHQ9XVqIxdJdiizjhCtVYYIiaQ11XNW5pFiwJWKoGtxyYPrCXrJHoqAZcP/Epm0G kMadXahIL2tYZWhihnSXmFbtvvnzS6PQK6AfMeOUPpF5uFFAV/2p55ZRNuw+Tp8Rxi/4 RXbg== X-Gm-Message-State: AOJu0YxD3UB85zgS2bWH1SHVOUImmu+SG7wCifqUMr3AYj+eDT+wo+dt +hh4HmMv9ps4SuOvj8coTe7d0slXbEFskCTx X-Google-Smtp-Source: AGHT+IEtM5nh8wn5Oqu0JDonDDESC+MoaubQennMrDPVsT5Cy4OtMVtMZXN/UFscmwWI5cgbu2K/NA== X-Received: by 2002:a05:6a20:12c7:b0:138:836c:5370 with SMTP id v7-20020a056a2012c700b00138836c5370mr2058597pzg.42.1698383994036; Thu, 26 Oct 2023 22:19:54 -0700 (PDT) Received: from localhost.localdomain ([2401:4900:6286:35cd:e1b0:b6b4:69e:b5fb]) by smtp.gmail.com with ESMTPSA id h16-20020a17090adb9000b00276e8e4f1fbsm2494296pjv.1.2023.10.26.22.19.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 26 Oct 2023 22:19:53 -0700 (PDT) From: Anshul Dalal To: linux-input@vger.kernel.org, devicetree@vger.kernel.org Cc: Anshul Dalal , Dmitry Torokhov , Rob Herring , Krzysztof Kozlowski , Conor Dooley , =?UTF-8?q?Thomas=20Wei=C3=9Fschuh?= , Jeff LaBundy , Shuah Khan , linux-kernel-mentees@lists.linuxfoundation.org, linux-kernel@vger.kernel.org Subject: [PATCH v6 2/2] input: joystick: driver for Adafruit Seesaw Gamepad Date: Fri, 27 Oct 2023 10:48:11 +0530 Message-ID: <20231027051819.81333-2-anshulusr@gmail.com> X-Mailer: git-send-email 2.42.0 In-Reply-To: <20231027051819.81333-1-anshulusr@gmail.com> References: <20231027051819.81333-1-anshulusr@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-input@vger.kernel.org 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 v6: - Added TODO - Removed `clang-format` directives - Namespaced device buttons - Removed `char physical_path[32]` field from `struct seesaw_gamepad` - Added `packed` attribute to `struct seesaw_data` - Moved from having booleans per button to single `u32 button_state` - Added `seesaw_button_description` array to directly associate device buttons with respective keycodes - Added wrapper functions `seesaw_register_` around `i2c_master_` API - Ratelimited input error reporting with `dev_err_ratelimited` - Removed `of_device_id` 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 | 310 +++++++++++++++++++++++ 4 files changed, 327 insertions(+) create mode 100644 drivers/input/joystick/adafruit-seesaw.c diff --git a/MAINTAINERS b/MAINTAINERS index 4cc6bf79fdd8..0595c832c248 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..1aa6fbe4fda4 --- /dev/null +++ b/drivers/input/joystick/adafruit-seesaw.c @@ -0,0 +1,310 @@ +// 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 + * + * TODO: + * - Add interrupt support + */ + +#include +#include +#include +#include +#include +#include +#include + +#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 SEESAW_BUTTON_A 5 +#define SEESAW_BUTTON_B 1 +#define SEESAW_BUTTON_X 6 +#define SEESAW_BUTTON_Y 2 +#define SEESAW_BUTTON_START 16 +#define SEESAW_BUTTON_SELECT 0 + +#define SEESAW_ANALOG_X 14 +#define SEESAW_ANALOG_Y 15 + +#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 + +u32 SEESAW_BUTTON_MASK = BIT(SEESAW_BUTTON_A) | BIT(SEESAW_BUTTON_B) | + BIT(SEESAW_BUTTON_X) | BIT(SEESAW_BUTTON_Y) | + BIT(SEESAW_BUTTON_START) | BIT(SEESAW_BUTTON_SELECT); + +struct seesaw_gamepad { + struct input_dev *input_dev; + struct i2c_client *i2c_client; +}; + +struct seesaw_data { + __be16 x; + __be16 y; + u32 button_state; +} __packed; + +struct seesaw_button_description { + unsigned int code; + unsigned int bit; +}; + +static const struct seesaw_button_description seesaw_buttons[] = { + { + .code = BTN_EAST, + .bit = SEESAW_BUTTON_A, + }, + { + .code = BTN_SOUTH, + .bit = SEESAW_BUTTON_B, + }, + { + .code = BTN_NORTH, + .bit = SEESAW_BUTTON_X, + }, + { + .code = BTN_WEST, + .bit = SEESAW_BUTTON_Y, + }, + { + .code = BTN_START, + .bit = SEESAW_BUTTON_START, + }, + { + .code = BTN_SELECT, + .bit = SEESAW_BUTTON_SELECT, + }, +}; + +static int seesaw_register_read(struct i2c_client *client, u8 register_high, + u8 register_low, char *buf, int count) +{ + int ret; + u8 register_buf[2] = { register_high, register_low }; + + ret = i2c_master_send(client, register_buf, sizeof(register_buf)); + if (ret < 0) + return ret; + ret = i2c_master_recv(client, buf, count); + if (ret < 0) + return ret; + + return 0; +} + +static int seesaw_register_write_u8(struct i2c_client *client, u8 register_high, + u8 register_low, u8 value) +{ + int ret; + u8 write_buf[3] = { register_high, register_low, value }; + + ret = i2c_master_send(client, write_buf, sizeof(write_buf)); + if (ret < 0) + return ret; + + return 0; +} + +static int seesaw_register_write_u32(struct i2c_client *client, + u8 register_high, u8 register_low, + u32 value) +{ + int ret; + u8 write_buf[6] = { register_high, register_low }; + + put_unaligned_be32(value, write_buf + 2); + ret = i2c_master_send(client, write_buf, sizeof(write_buf)); + if (ret < 0) + return ret; + + return 0; +} + +static int seesaw_read_data(struct i2c_client *client, struct seesaw_data *data) +{ + int ret; + u8 read_buf[4]; + + ret = seesaw_register_read(client, SEESAW_GPIO_BASE, SEESAW_GPIO_BULK, + read_buf, sizeof(read_buf)); + if (ret) + return ret; + + data->button_state = ~get_unaligned_be32(&read_buf); + + ret = seesaw_register_read(client, SEESAW_ADC_BASE, + SEESAW_ADC_OFFSET + SEESAW_ANALOG_X, + (char *)&data->x, sizeof(data->x)); + if (ret) + return ret; + /* + * 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); + + ret = seesaw_register_read(client, SEESAW_ADC_BASE, + SEESAW_ADC_OFFSET + SEESAW_ANALOG_Y, + (char *)&data->y, sizeof(data->y)); + if (ret) + return ret; + data->y = be16_to_cpu(data->y); + + return 0; +} + +static void seesaw_poll(struct input_dev *input) +{ + int err, i; + struct seesaw_gamepad *private = input_get_drvdata(input); + struct seesaw_data data; + + err = seesaw_read_data(private->i2c_client, &data); + if (err != 0) { + dev_err_ratelimited(&input->dev, + "failed to read joystick state: %d\n", err); + return; + } + + input_report_abs(input, ABS_X, data.x); + input_report_abs(input, ABS_Y, data.y); + + for (i = 0; i < ARRAY_SIZE(seesaw_buttons); i++) { + input_report_key(input, seesaw_buttons[i].code, + data.button_state & + BIT(seesaw_buttons[i].bit)); + } + input_sync(input); +} + +static int seesaw_probe(struct i2c_client *client) +{ + int err, i; + u8 hardware_id; + struct seesaw_gamepad *seesaw; + + err = seesaw_register_write_u8(client, SEESAW_STATUS_BASE, + SEESAW_STATUS_SWRST, 0xFF); + if (err) + return err; + + /* Wait for the registers to reset before proceeding */ + mdelay(10); + + seesaw = devm_kzalloc(&client->dev, sizeof(*seesaw), GFP_KERNEL); + if (!seesaw) + return -ENOMEM; + + err = seesaw_register_read(client, SEESAW_STATUS_BASE, + SEESAW_STATUS_HW_ID, &hardware_id, 1); + if (err) + return err; + + dev_dbg(&client->dev, "Adafruit Seesaw Gamepad, Hardware ID: %02x\n", + hardware_id); + + /* Set Pin Mode to input and enable pull-up resistors */ + err = seesaw_register_write_u32(client, SEESAW_GPIO_BASE, + SEESAW_GPIO_DIRCLR_BULK, + SEESAW_BUTTON_MASK); + if (err) + return err; + err = seesaw_register_write_u32(client, SEESAW_GPIO_BASE, + SEESAW_GPIO_PULLENSET, + SEESAW_BUTTON_MASK); + if (err) + return err; + err = seesaw_register_write_u32(client, SEESAW_GPIO_BASE, + SEESAW_GPIO_BULK_SET, + SEESAW_BUTTON_MASK); + if (err) + return err; + + seesaw->i2c_client = client; + i2c_set_clientdata(client, seesaw); + + seesaw->input_dev = devm_input_allocate_device(&client->dev); + if (!seesaw->input_dev) + return -ENOMEM; + + seesaw->input_dev->id.bustype = BUS_I2C; + seesaw->input_dev->name = "Adafruit Seesaw Gamepad"; + seesaw->input_dev->phys = "i2c/" SEESAW_DEVICE_NAME; + input_set_drvdata(seesaw->input_dev, seesaw); + input_set_abs_params(seesaw->input_dev, ABS_X, 0, + SEESAW_JOYSTICK_MAX_AXIS, SEESAW_JOYSTICK_FUZZ, + SEESAW_JOYSTICK_FLAT); + input_set_abs_params(seesaw->input_dev, ABS_Y, 0, + SEESAW_JOYSTICK_MAX_AXIS, SEESAW_JOYSTICK_FUZZ, + SEESAW_JOYSTICK_FLAT); + for (i = 0; i < ARRAY_SIZE(seesaw_buttons); i++) { + input_set_capability(seesaw->input_dev, EV_KEY, + seesaw_buttons[i].code); + } + + err = input_setup_polling(seesaw->input_dev, seesaw_poll); + if (err) { + dev_err(&client->dev, "failed to set up polling: %d\n", err); + return err; + } + + input_set_poll_interval(seesaw->input_dev, + SEESAW_GAMEPAD_POLL_INTERVAL); + input_set_max_poll_interval(seesaw->input_dev, SEESAW_GAMEPAD_POLL_MAX); + input_set_min_poll_interval(seesaw->input_dev, SEESAW_GAMEPAD_POLL_MIN); + + err = input_register_device(seesaw->input_dev); + if (err) { + dev_err(&client->dev, "failed to register joystick: %d\n", err); + return err; + } + + return 0; +} + +static const struct i2c_device_id seesaw_id_table[] = { + { SEESAW_DEVICE_NAME, 0 }, + { /* Sentinel */ } +}; +MODULE_DEVICE_TABLE(i2c, seesaw_id_table); + +static struct i2c_driver seesaw_driver = { + .driver = { + .name = SEESAW_DEVICE_NAME, + }, + .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