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 4B627CDB483 for ; Tue, 17 Oct 2023 03:45:35 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp3.osuosl.org (Postfix) with ESMTP id BB1EF60C0C; Tue, 17 Oct 2023 03:45:34 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp3.osuosl.org BB1EF60C0C 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=nczYou3w 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 npY6c51IU1Rk; Tue, 17 Oct 2023 03:45:33 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp3.osuosl.org (Postfix) with ESMTPS id 56BAC60B83; Tue, 17 Oct 2023 03:45:33 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp3.osuosl.org 56BAC60B83 Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 33B0DC0071; Tue, 17 Oct 2023 03:45:33 +0000 (UTC) Received: from smtp2.osuosl.org (smtp2.osuosl.org [140.211.166.133]) by lists.linuxfoundation.org (Postfix) with ESMTP id CD56DC0032 for ; Tue, 17 Oct 2023 03:45:31 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id A635E40467 for ; Tue, 17 Oct 2023 03:45:31 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp2.osuosl.org A635E40467 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=nczYou3w 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 dOjFQ7C3d1Ks for ; Tue, 17 Oct 2023 03:45:30 +0000 (UTC) Received: from mail-ot1-x334.google.com (mail-ot1-x334.google.com [IPv6:2607:f8b0:4864:20::334]) by smtp2.osuosl.org (Postfix) with ESMTPS id CBEC14031D for ; Tue, 17 Oct 2023 03:45:29 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp2.osuosl.org CBEC14031D Received: by mail-ot1-x334.google.com with SMTP id 46e09a7af769-6c4b9e09521so3492436a34.3 for ; Mon, 16 Oct 2023 20:45:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1697514329; x=1698119129; 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=xYJgt5+b5HVwNIIrlfXEoBwZ8hfn4jjcSeUfjjs6Z20=; b=nczYou3wKhJ3IH7VXVRj+I+HoN6kwLBgXbaDOL+nsjp3nlDlAeMOY51zNCV7d85KRI 8U5zV88s/MlnyMh/X445VNOWnyhj8xu2vELHsfos3FMAY1FF6MQehyslRj47iNe/xIeF RJ7KgBPLDF2oY7T0tpIBHr8EccZCO5oSdDFj4/PlAvh8ZyXRBcQ29Req+K59SGV9prg0 2Ksi/LXjVg+watqW86o+jd6OAKd5OL7K/9FRjlVe2zLSQnWLZqd5uDwm2AYzUc4OjzlS rnIMasZLjHPUPeCwQSkDaADn7Eij1oZN3C+8odYEqQp26B1T0lVHz1cD9fpwgjl0p4EV jvRA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1697514329; x=1698119129; 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=xYJgt5+b5HVwNIIrlfXEoBwZ8hfn4jjcSeUfjjs6Z20=; b=fB9jsl4UCZ3jIQ1IJcN4ay00R1hnh1AFmb9kbw6JgyQ2LLSYFpVrAS9QDljxf1n+G/ 7Tn+mmsAF74ri4432/JlG99XbZvWG34FDTsSQwi+JMCGNDQS0g4DIyTHKbSTO4Z6dzgV sOpZ/4CbRZPQ8kN8GKAGxvtIYF9V4MnuioYDePhv2afPZ8X5skOoDGfgj8kvxvWVkXoF nFInTCeCmclEOoIo+7uSAyI82dzLyI+VdmlkveSCPyiPnbCIEOETufvHBpVV+1D6GAs3 UDwMkOLnSmIUUhLmVK4LrcUGDcKerzf2DblKHS05kJWuhZIHHTVJYJNZJpP7/alkeG+z z2HQ== X-Gm-Message-State: AOJu0YxAogTl+x1Al0nlfSV9pVoHoP0bkTh1rAvFmQBaSseq6eJnpxjA 9KnCn9ltfeCY0AML6LmmkLo= X-Google-Smtp-Source: AGHT+IGd5h0eR/hvzmIeetJD4HfGJWvoSL9BsCP1F3rrJaFSMUT77YeMQxH8QvNmKtl6vfRxcynrHQ== X-Received: by 2002:a05:6830:1e65:b0:6bc:fdc8:d600 with SMTP id m5-20020a0568301e6500b006bcfdc8d600mr1078616otr.25.1697514328668; Mon, 16 Oct 2023 20:45:28 -0700 (PDT) Received: from localhost.localdomain ([2401:4900:628c:a92e:5b03:91a2:57c8:16f3]) by smtp.gmail.com with ESMTPSA id y13-20020aa793cd000000b0069305627491sm313777pff.159.2023.10.16.20.45.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 16 Oct 2023 20:45:28 -0700 (PDT) From: Anshul Dalal To: linux-input@vger.kernel.org, devicetree@vger.kernel.org Subject: [PATCH v5 2/2] input: joystick: driver for Adafruit Seesaw Gamepad Date: Tue, 17 Oct 2023 09:13:45 +0530 Message-ID: <20231017034356.1436677-2-anshulusr@gmail.com> X-Mailer: git-send-email 2.42.0 In-Reply-To: <20231017034356.1436677-1-anshulusr@gmail.com> References: <20231017034356.1436677-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 , 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+ ClNpZ25lZC1vZmYtYnk6IEFuc2h1bCBEYWxhbCA8YW5zaHVsdXNyQGdtYWlsLmNvbT4KLS0tCgpD aGFuZ2VzIGZvciB2NToKLSBBZGRlZCBsaW5rIHRvIHRoZSBkYXRhc2hlZXQKLSBBZGRlZCBkZWJ1 ZyBsb2cgbWVzc2FnZSB3aGVuIGBzZWVzYXdfcmVhZF9kYXRhYCBmYWlscwoKQ2hhbmdlcyBmb3Ig djQ6Ci0gQ2hhbmdlZCBgMVVMIDw8IEJVVFRPTl9gIHRvIEJJVChCVVRUT05fKQotIFJlbW92ZWQg YGhhcmR3YXJlX2lkYCBmaWVsZCBmcm9tIGBzdHJ1Y3Qgc2Vlc2F3X2dhbWVwYWRgCi0gUmVtb3Zl ZCByZWR1bmRhbnQgY2hlY2tzIGZvciB0aGUgbnVtYmVyIG9mIGJ5dGVzIHdyaXR0ZW4gYW5kIHJl Y2VpdmVkIGJ5CiAgYGkyY19tYXN0ZXJfc2VuZGAgYW5kIGBpMmNfbWFzdGVyX3JlY3ZgCi0gVXNl ZCBgZ2V0X3VuYWxpZ25lZF9iZTMyYCB0byBpbnN0YW50aWF0ZSBgdTMyIHJlc3VsdGAgZnJvbSBg cmVhZF9idWZgCi0gQ2hhbmdlZCAgYHJlc3VsdCAmICgxVUwgPDwgQlVUVE9OXylgIHRvCiAgYHRl c3RfYml0KEJVVFRPTl8sIChsb25nICopJnJlc3VsdClgCi0gQ2hhbmdlZCBgS0JVSUxEX01PRE5B TUVgIGluIGlkLXRhYmxlcyB0byBgU0VFU0FXX0RFVklDRV9OQU1FYAotIEZpeGVkIGZvcm1hdHRp bmcgaXNzdWVzCi0gQ2hhbmdlZCBidXR0b24gcmVwb3J0aW5nOgogICAgU2luY2UgdGhlIGdhbWVw YWQgaGFkIHRoZSBhY3Rpb24gYnV0dG9ucyBpbiBhIG5vbi1zdGFuZGFyZCBsYXlvdXQ6CiAgICAg ICAgIChYKQogICAgICAoWSkgICAoQSkKICAgICAgICAgKEIpCiAgICBUaGVyZWZvcmUgbW92ZWQg dG8gdXNpbmcgZ2VuZXJpYyBkaXJlY3Rpb25hbCBhY3Rpb24gYnV0dG9uIGV2ZW50IGNvZGVzCiAg ICBpbnN0ZWFkIG9mIEJUTl9bQUJYWV0uCgpDaGFuZ2VzIGZvciB2MzoKLSBubyB1cGRhdGVzCgpD aGFuZ2VzIGZvciB2MjoKYWRhZnJ1aXQtc2Vlc2F3LmM6Ci0gUmVuYW1lZCBmaWxlIGZyb20gJ2Fk YWZydWl0X3NlZXNhdy5jJwotIENoYW5nZWQgZGV2aWNlIG5hbWUgZnJvbSAnc2Vlc2F3X2dhbWVw YWQnIHRvICdzZWVzYXctZ2FtZXBhZCcKLSBDaGFuZ2VkIGNvdW50IHBhcmFtZXRlciBmb3IgcmVj ZWl2aW5nIGpveXN0aWNrIHggb24gbGluZSAxMTg6CiAgICBgMmAgdG8gYHNpemVvZih3cml0ZV9i dWYpYAotIEZpeGVkIGludmFsaWQgYnVmZmVyIHNpemUgb24gbGluZSAxMjMgYW5kIDEyNjoKICAg IGBkYXRhLT55YCB0byBgc2l6ZW9mKGRhdGEtPnkpYAotIEFkZGVkIGNvbW1lbnQgZm9yIHRoZSBg bWRlbGF5KDEwKWAgb24gbGluZSAxNjkKLSBDaGFuZ2VkIGluY29uc2lzdGVudCBpbmRlbnRhdGlv biBvbiBsaW5lIDI3MQpLY29uZmlnOgotIEZpeGVkIGluZGVudGF0aW9uIGZvciB0aGUgaGVscCB0 ZXh0Ci0gVXBkYXRlZCBtb2R1bGUgbmFtZQpNYWtlZmlsZToKLSBVcGRhdGVkIG1vZHVsZSBvYmpl Y3QgZmlsZSBuYW1lCk1BSU5UQUlORVJTOgotIFVwZGF0ZWQgZmlsZSBuYW1lIGZvciB0aGUgZHJp dmVyIGFuZCBiaW5kaW5ncwoKIE1BSU5UQUlORVJTICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgIDcgKwogZHJpdmVycy9pbnB1dC9qb3lzdGljay9LY29uZmlnICAgICAgICAgICB8ICAg OSArCiBkcml2ZXJzL2lucHV0L2pveXN0aWNrL01ha2VmaWxlICAgICAgICAgIHwgICAxICsKIGRy aXZlcnMvaW5wdXQvam95c3RpY2svYWRhZnJ1aXQtc2Vlc2F3LmMgfCAyNzMgKysrKysrKysrKysr KysrKysrKysrKysKIDQgZmlsZXMgY2hhbmdlZCwgMjkwIGluc2VydGlvbnMoKykKIGNyZWF0ZSBt b2RlIDEwMDY0NCBkcml2ZXJzL2lucHV0L2pveXN0aWNrL2FkYWZydWl0LXNlZXNhdy5jCgpkaWZm IC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJTkVSUwppbmRleCA2YzRjY2U0NWEwOWQuLmEz MTRmOWI0OGUyMSAxMDA2NDQKLS0tIGEvTUFJTlRBSU5FUlMKKysrIGIvTUFJTlRBSU5FUlMKQEAg LTQ0MSw2ICs0NDEsMTMgQEAgVzoJaHR0cDovL3dpa2kuYW5hbG9nLmNvbS9BRDc4NzkKIFc6CWh0 dHBzOi8vZXouYW5hbG9nLmNvbS9saW51eC1zb2Z0d2FyZS1kcml2ZXJzCiBGOglkcml2ZXJzL2lu cHV0L3RvdWNoc2NyZWVuL2FkNzg3OS5jCiAKK0FEQUZSVUlUIE1JTkkgSTJDIEdBTUVQQUQKK006 CUFuc2h1bCBEYWxhbCA8YW5zaHVsdXNyQGdtYWlsLmNvbT4KK0w6CWxpbnV4LWlucHV0QHZnZXIu a2VybmVsLm9yZworUzoJTWFpbnRhaW5lZAorRjoJRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2Jp bmRpbmdzL2lucHV0L2FkYWZydWl0LHNlZXNhdy1nYW1lcGFkLnlhbWwKK0Y6CWRyaXZlcnMvaW5w dXQvam95c3RpY2svYWRhZnJ1aXQtc2Vlc2F3LmMKKwogQUREUkVTUyBTUEFDRSBMQVlPVVQgUkFO RE9NSVpBVElPTiAoQVNMUikKIE06CUppcmkgS29zaW5hIDxqaWtvc0BrZXJuZWwub3JnPgogUzoJ TWFpbnRhaW5lZApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9qb3lzdGljay9LY29uZmlnIGIv ZHJpdmVycy9pbnB1dC9qb3lzdGljay9LY29uZmlnCmluZGV4IGFjNjkyNWNlODM2Ni4uZGY5Y2Qx ODMwYjI5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L2pveXN0aWNrL0tjb25maWcKKysrIGIv ZHJpdmVycy9pbnB1dC9qb3lzdGljay9LY29uZmlnCkBAIC00MTIsNCArNDEyLDEzIEBAIGNvbmZp ZyBKT1lTVElDS19TRU5TRUhBVAogCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVs ZSwgY2hvb3NlIE0gaGVyZTogdGhlCiAJICBtb2R1bGUgd2lsbCBiZSBjYWxsZWQgc2Vuc2VoYXRf am95c3RpY2suCiAKK2NvbmZpZyBKT1lTVElDS19TRUVTQVcKKwl0cmlzdGF0ZSAiQWRhZnJ1aXQg TWluaSBJMkMgR2FtZXBhZCB3aXRoIFNlZXNhdyIKKwlkZXBlbmRzIG9uIEkyQworCWhlbHAKKwkg IFNheSBZIGhlcmUgaWYgeW91IHdhbnQgdG8gdXNlIHRoZSBBZGFmcnVpdCBNaW5pIEkyQyBHYW1l cGFkLgorCisJICBUbyBjb21waWxlIHRoaXMgZHJpdmVyIGFzIGEgbW9kdWxlLCBjaG9vc2UgTSBo ZXJlOiB0aGUgbW9kdWxlIHdpbGwgYmUKKwkgIGNhbGxlZCBhZGFmcnVpdC1zZWVzYXcuCisKIGVu ZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L2pveXN0aWNrL01ha2VmaWxlIGIvZHJpdmVy cy9pbnB1dC9qb3lzdGljay9NYWtlZmlsZQppbmRleCAzOTM3NTM1ZjAwOTguLjk5NzZmNTk2YTky MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC9qb3lzdGljay9NYWtlZmlsZQorKysgYi9kcml2 ZXJzL2lucHV0L2pveXN0aWNrL01ha2VmaWxlCkBAIC0yOCw2ICsyOCw3IEBAIG9iai0kKENPTkZJ R19KT1lTVElDS19ONjQpCQkrPSBuNjRqb3kubwogb2JqLSQoQ09ORklHX0pPWVNUSUNLX1BTWFBB RF9TUEkpCSs9IHBzeHBhZC1zcGkubwogb2JqLSQoQ09ORklHX0pPWVNUSUNLX1BYUkMpCQkrPSBw eHJjLm8KIG9iai0kKENPTkZJR19KT1lTVElDS19RV0lJQykJCSs9IHF3aWljLWpveXN0aWNrLm8K K29iai0kKENPTkZJR19KT1lTVElDS19TRUVTQVcpCQkrPSBhZGFmcnVpdC1zZWVzYXcubwogb2Jq LSQoQ09ORklHX0pPWVNUSUNLX1NFTlNFSEFUKQkrPSBzZW5zZWhhdC1qb3lzdGljay5vCiBvYmot JChDT05GSUdfSk9ZU1RJQ0tfU0lERVdJTkRFUikJKz0gc2lkZXdpbmRlci5vCiBvYmotJChDT05G SUdfSk9ZU1RJQ0tfU1BBQ0VCQUxMKQkrPSBzcGFjZWJhbGwubwpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9pbnB1dC9qb3lzdGljay9hZGFmcnVpdC1zZWVzYXcuYyBiL2RyaXZlcnMvaW5wdXQvam95c3Rp Y2svYWRhZnJ1aXQtc2Vlc2F3LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwLi4yYTFlYWU4ZDI4NjEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2lucHV0L2pveXN0 aWNrL2FkYWZydWl0LXNlZXNhdy5jCkBAIC0wLDAgKzEsMjczIEBACisvLyBTUERYLUxpY2Vuc2Ut SWRlbnRpZmllcjogR1BMLTIuMC1vci1sYXRlcgorLyoKKyAqIENvcHlyaWdodCAoQykgMjAyMyBB bnNodWwgRGFsYWwgPGFuc2h1bHVzckBnbWFpbC5jb20+CisgKgorICogRHJpdmVyIGZvciBBZGFm cnVpdCBNaW5pIEkyQyBHYW1lcGFkCisgKgorICogQmFzZWQgb24gdGhlIHdvcmsgb2Y6CisgKglP bGVoIEtyYXZjaGVua28gKFNwYXJrZnVuIFF3aWljIEpveXN0aWNrIGRyaXZlcikKKyAqCisgKiBE YXRhc2hlZXQ6IGh0dHBzOi8vY2RuLWxlYXJuLmFkYWZydWl0LmNvbS9kb3dubG9hZHMvcGRmL2dh bWVwYWQtcXQucGRmCisgKiBQcm9kdWN0IHBhZ2U6IGh0dHBzOi8vd3d3LmFkYWZydWl0LmNvbS9w cm9kdWN0LzU3NDMKKyAqIEZpcm13YXJlIGFuZCBoYXJkd2FyZSBzb3VyY2VzOiBodHRwczovL2dp dGh1Yi5jb20vYWRhZnJ1aXQvQWRhZnJ1aXRfU2Vlc2F3CisgKi8KKworI2luY2x1ZGUgPGFzbS1n ZW5lcmljL3VuYWxpZ25lZC5oPgorI2luY2x1ZGUgPGxpbnV4L2JpdHMuaD4KKyNpbmNsdWRlIDxs aW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgorI2luY2x1ZGUgPGxpbnV4L2lu cHV0Lmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxl Lmg+CisKKy8qIGNsYW5nLWZvcm1hdCBvZmYgKi8KKyNkZWZpbmUgU0VFU0FXX0RFVklDRV9OQU1F CSJzZWVzYXctZ2FtZXBhZCIKKworI2RlZmluZSBTRUVTQVdfU1RBVFVTX0JBU0UJMAorI2RlZmlu ZSBTRUVTQVdfR1BJT19CQVNFCTEKKyNkZWZpbmUgU0VFU0FXX0FEQ19CQVNFCQk5CisKKyNkZWZp bmUgU0VFU0FXX0dQSU9fRElSQ0xSX0JVTEsJMworI2RlZmluZSBTRUVTQVdfR1BJT19CVUxLCTQK KyNkZWZpbmUgU0VFU0FXX0dQSU9fQlVMS19TRVQJNQorI2RlZmluZSBTRUVTQVdfR1BJT19QVUxM RU5TRVQJMTEKKworI2RlZmluZSBTRUVTQVdfU1RBVFVTX0hXX0lECTEKKyNkZWZpbmUgU0VFU0FX X1NUQVRVU19TV1JTVAkxMjcKKworI2RlZmluZSBTRUVTQVdfQURDX09GRlNFVAk3CisKKyNkZWZp bmUgQlVUVE9OX0EJNQorI2RlZmluZSBCVVRUT05fQgkxCisjZGVmaW5lIEJVVFRPTl9YCTYKKyNk ZWZpbmUgQlVUVE9OX1kJMgorI2RlZmluZSBCVVRUT05fU1RBUlQJMTYKKyNkZWZpbmUgQlVUVE9O X1NFTEVDVAkwCisKKyNkZWZpbmUgQU5BTE9HX1gJMTQKKyNkZWZpbmUgQU5BTE9HX1kJMTUKKwor I2RlZmluZSBTRUVTQVdfSk9ZU1RJQ0tfTUFYX0FYSVMJMTAyMworI2RlZmluZSBTRUVTQVdfSk9Z U1RJQ0tfRlVaWgkJMgorI2RlZmluZSBTRUVTQVdfSk9ZU1RJQ0tfRkxBVAkJNAorCisjZGVmaW5l IFNFRVNBV19HQU1FUEFEX1BPTExfSU5URVJWQUwJMTYKKyNkZWZpbmUgU0VFU0FXX0dBTUVQQURf UE9MTF9NSU4JCTgKKyNkZWZpbmUgU0VFU0FXX0dBTUVQQURfUE9MTF9NQVgJCTMyCisvKiBjbGFu Zy1mb3JtYXQgb24gKi8KKwordTMyIEJVVFRPTl9NQVNLID0gQklUKEJVVFRPTl9BKSB8IEJJVChC VVRUT05fQikgfCBCSVQoQlVUVE9OX1gpIHwKKwkJICBCSVQoQlVUVE9OX1kpIHwgQklUKEJVVFRP Tl9TVEFSVCkgfCBCSVQoQlVUVE9OX1NFTEVDVCk7CisKK3N0cnVjdCBzZWVzYXdfZ2FtZXBhZCB7 CisJY2hhciBwaHlzaWNhbF9wYXRoWzMyXTsKKwlzdHJ1Y3QgaW5wdXRfZGV2ICppbnB1dF9kZXY7 CisJc3RydWN0IGkyY19jbGllbnQgKmkyY19jbGllbnQ7Cit9OworCitzdHJ1Y3Qgc2Vlc2F3X2Rh dGEgeworCV9fYmUxNiB4OworCV9fYmUxNiB5OworCXU4IGJ1dHRvbl9hLCBidXR0b25fYiwgYnV0 dG9uX3gsIGJ1dHRvbl95LCBidXR0b25fc3RhcnQsIGJ1dHRvbl9zZWxlY3Q7Cit9OworCitzdGF0 aWMgaW50IHNlZXNhd19yZWFkX2RhdGEoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgc3RydWN0 IHNlZXNhd19kYXRhICpkYXRhKQoreworCWludCBlcnI7CisJdW5zaWduZWQgY2hhciB3cml0ZV9i dWZbMl0gPSB7IFNFRVNBV19HUElPX0JBU0UsIFNFRVNBV19HUElPX0JVTEsgfTsKKwl1bnNpZ25l ZCBjaGFyIHJlYWRfYnVmWzRdOworCisJZXJyID0gaTJjX21hc3Rlcl9zZW5kKGNsaWVudCwgd3Jp dGVfYnVmLCBzaXplb2Yod3JpdGVfYnVmKSk7CisJaWYgKGVyciA8IDApCisJCXJldHVybiBlcnI7 CisJZXJyID0gaTJjX21hc3Rlcl9yZWN2KGNsaWVudCwgcmVhZF9idWYsIHNpemVvZihyZWFkX2J1 ZikpOworCWlmIChlcnIgPCAwKQorCQlyZXR1cm4gZXJyOworCisJdTMyIHJlc3VsdCA9IGdldF91 bmFsaWduZWRfYmUzMigmcmVhZF9idWYpOworCisJZGF0YS0+YnV0dG9uX2EgPSAhdGVzdF9iaXQo QlVUVE9OX0EsIChsb25nICopJnJlc3VsdCk7CisJZGF0YS0+YnV0dG9uX2IgPSAhdGVzdF9iaXQo QlVUVE9OX0IsIChsb25nICopJnJlc3VsdCk7CisJZGF0YS0+YnV0dG9uX3ggPSAhdGVzdF9iaXQo QlVUVE9OX1gsIChsb25nICopJnJlc3VsdCk7CisJZGF0YS0+YnV0dG9uX3kgPSAhdGVzdF9iaXQo QlVUVE9OX1ksIChsb25nICopJnJlc3VsdCk7CisJZGF0YS0+YnV0dG9uX3N0YXJ0ID0gIXRlc3Rf Yml0KEJVVFRPTl9TVEFSVCwgKGxvbmcgKikmcmVzdWx0KTsKKwlkYXRhLT5idXR0b25fc2VsZWN0 ID0gIXRlc3RfYml0KEJVVFRPTl9TRUxFQ1QsIChsb25nICopJnJlc3VsdCk7CisKKwl3cml0ZV9i dWZbMF0gPSBTRUVTQVdfQURDX0JBU0U7CisJd3JpdGVfYnVmWzFdID0gU0VFU0FXX0FEQ19PRkZT RVQgKyBBTkFMT0dfWDsKKwllcnIgPSBpMmNfbWFzdGVyX3NlbmQoY2xpZW50LCB3cml0ZV9idWYs IHNpemVvZih3cml0ZV9idWYpKTsKKwlpZiAoZXJyIDwgMCkKKwkJcmV0dXJuIGVycjsKKwllcnIg PSBpMmNfbWFzdGVyX3JlY3YoY2xpZW50LCAoY2hhciAqKSZkYXRhLT54LCBzaXplb2YoZGF0YS0+ eCkpOworCWlmIChlcnIgPCAwKQorCQlyZXR1cm4gZXJyOworCS8qCisJICogQURDIHJlYWRzIGxl ZnQgYXMgbWF4IGFuZCByaWdodCBhcyAwLCBtdXN0IGJlIHJldmVyc2VkIHNpbmNlIGtlcm5lbAor CSAqIGV4cGVjdHMgcmVwb3J0cyBpbiBvcHBvc2l0ZSBvcmRlci4KKwkgKi8KKwlkYXRhLT54ID0g U0VFU0FXX0pPWVNUSUNLX01BWF9BWElTIC0gYmUxNl90b19jcHUoZGF0YS0+eCk7CisKKwl3cml0 ZV9idWZbMV0gPSBTRUVTQVdfQURDX09GRlNFVCArIEFOQUxPR19ZOworCWVyciA9IGkyY19tYXN0 ZXJfc2VuZChjbGllbnQsIHdyaXRlX2J1Ziwgc2l6ZW9mKHdyaXRlX2J1ZikpOworCWlmIChlcnIg PCAwKQorCQlyZXR1cm4gZXJyOworCWVyciA9IGkyY19tYXN0ZXJfcmVjdihjbGllbnQsIChjaGFy ICopJmRhdGEtPnksIHNpemVvZihkYXRhLT55KSk7CisJaWYgKGVyciA8IDApCisJCXJldHVybiBl cnI7CisJZGF0YS0+eSA9IGJlMTZfdG9fY3B1KGRhdGEtPnkpOworCisJcmV0dXJuIDA7Cit9CisK K3N0YXRpYyB2b2lkIHNlZXNhd19wb2xsKHN0cnVjdCBpbnB1dF9kZXYgKmlucHV0KQoreworCXN0 cnVjdCBzZWVzYXdfZ2FtZXBhZCAqcHJpdmF0ZSA9IGlucHV0X2dldF9kcnZkYXRhKGlucHV0KTsK KwlzdHJ1Y3Qgc2Vlc2F3X2RhdGEgZGF0YTsKKwlpbnQgZXJyOworCisJZXJyID0gc2Vlc2F3X3Jl YWRfZGF0YShwcml2YXRlLT5pMmNfY2xpZW50LCAmZGF0YSk7CisJaWYgKGVyciAhPSAwKSB7CisJ CWRldl9kYmcoJmlucHV0LT5kZXYsICJmYWlsZWQgdG8gcmVhZCBqb3lzdGljayBzdGF0ZTogJWRc biIsCisJCQllcnIpOworCQlyZXR1cm47CisJfQorCisJaW5wdXRfcmVwb3J0X2FicyhpbnB1dCwg QUJTX1gsIGRhdGEueCk7CisJaW5wdXRfcmVwb3J0X2FicyhpbnB1dCwgQUJTX1ksIGRhdGEueSk7 CisJaW5wdXRfcmVwb3J0X2tleShpbnB1dCwgQlROX0VBU1QsIGRhdGEuYnV0dG9uX2EpOworCWlu cHV0X3JlcG9ydF9rZXkoaW5wdXQsIEJUTl9TT1VUSCwgZGF0YS5idXR0b25fYik7CisJaW5wdXRf cmVwb3J0X2tleShpbnB1dCwgQlROX05PUlRILCBkYXRhLmJ1dHRvbl94KTsKKwlpbnB1dF9yZXBv cnRfa2V5KGlucHV0LCBCVE5fV0VTVCwgZGF0YS5idXR0b25feSk7CisJaW5wdXRfcmVwb3J0X2tl eShpbnB1dCwgQlROX1NUQVJULCBkYXRhLmJ1dHRvbl9zdGFydCk7CisJaW5wdXRfcmVwb3J0X2tl eShpbnB1dCwgQlROX1NFTEVDVCwgZGF0YS5idXR0b25fc2VsZWN0KTsKKwlpbnB1dF9zeW5jKGlu cHV0KTsKK30KKworc3RhdGljIGludCBzZWVzYXdfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNs aWVudCkKK3sKKwlpbnQgZXJyOworCXN0cnVjdCBzZWVzYXdfZ2FtZXBhZCAqcHJpdmF0ZTsKKwl1 bnNpZ25lZCBjaGFyIHJlZ2lzdGVyX3Jlc2V0W10gPSB7IFNFRVNBV19TVEFUVVNfQkFTRSwKKwkJ CQkJICAgU0VFU0FXX1NUQVRVU19TV1JTVCwgMHhGRiB9OworCXVuc2lnbmVkIGNoYXIgZ2V0X2h3 X2lkW10gPSB7IFNFRVNBV19TVEFUVVNfQkFTRSwgU0VFU0FXX1NUQVRVU19IV19JRCB9OworCisJ ZXJyID0gaTJjX21hc3Rlcl9zZW5kKGNsaWVudCwgcmVnaXN0ZXJfcmVzZXQsIHNpemVvZihyZWdp c3Rlcl9yZXNldCkpOworCWlmIChlcnIgPCAwKQorCQlyZXR1cm4gZXJyOworCisJLyogV2FpdCBm b3IgdGhlIHJlZ2lzdGVycyB0byByZXNldCBiZWZvcmUgcHJvY2VlZGluZyAqLworCW1kZWxheSgx MCk7CisKKwlwcml2YXRlID0gZGV2bV9remFsbG9jKCZjbGllbnQtPmRldiwgc2l6ZW9mKCpwcml2 YXRlKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFwcml2YXRlKQorCQlyZXR1cm4gLUVOT01FTTsKKwor CWVyciA9IGkyY19tYXN0ZXJfc2VuZChjbGllbnQsIGdldF9od19pZCwgc2l6ZW9mKGdldF9od19p ZCkpOworCWlmIChlcnIgPCAwKQorCQlyZXR1cm4gZXJyOworCisJdW5zaWduZWQgY2hhciBoYXJk d2FyZV9pZDsKKworCWVyciA9IGkyY19tYXN0ZXJfcmVjdihjbGllbnQsICZoYXJkd2FyZV9pZCwg MSk7CisJaWYgKGVyciA8IDApCisJCXJldHVybiBlcnI7CisKKwlkZXZfZGJnKCZjbGllbnQtPmRl diwgIkFkYWZydWl0IFNlZXNhdyBHYW1lcGFkLCBIYXJkd2FyZSBJRDogJTAyeFxuIiwKKwkJaGFy ZHdhcmVfaWQpOworCisJcHJpdmF0ZS0+aTJjX2NsaWVudCA9IGNsaWVudDsKKwlzY25wcmludGYo cHJpdmF0ZS0+cGh5c2ljYWxfcGF0aCwgc2l6ZW9mKHByaXZhdGUtPnBoeXNpY2FsX3BhdGgpLAor CQkgICJpMmMvJXMiLCBkZXZfbmFtZSgmY2xpZW50LT5kZXYpKTsKKwlpMmNfc2V0X2NsaWVudGRh dGEoY2xpZW50LCBwcml2YXRlKTsKKworCXByaXZhdGUtPmlucHV0X2RldiA9IGRldm1faW5wdXRf YWxsb2NhdGVfZGV2aWNlKCZjbGllbnQtPmRldik7CisJaWYgKCFwcml2YXRlLT5pbnB1dF9kZXYp CisJCXJldHVybiAtRU5PTUVNOworCisJcHJpdmF0ZS0+aW5wdXRfZGV2LT5pZC5idXN0eXBlID0g QlVTX0kyQzsKKwlwcml2YXRlLT5pbnB1dF9kZXYtPm5hbWUgPSAiQWRhZnJ1aXQgU2Vlc2F3IEdh bWVwYWQiOworCXByaXZhdGUtPmlucHV0X2Rldi0+cGh5cyA9IHByaXZhdGUtPnBoeXNpY2FsX3Bh dGg7CisJaW5wdXRfc2V0X2RydmRhdGEocHJpdmF0ZS0+aW5wdXRfZGV2LCBwcml2YXRlKTsKKwlp bnB1dF9zZXRfYWJzX3BhcmFtcyhwcml2YXRlLT5pbnB1dF9kZXYsIEFCU19YLCAwLAorCQkJICAg ICBTRUVTQVdfSk9ZU1RJQ0tfTUFYX0FYSVMsIFNFRVNBV19KT1lTVElDS19GVVpaLAorCQkJICAg ICBTRUVTQVdfSk9ZU1RJQ0tfRkxBVCk7CisJaW5wdXRfc2V0X2Fic19wYXJhbXMocHJpdmF0ZS0+ aW5wdXRfZGV2LCBBQlNfWSwgMCwKKwkJCSAgICAgU0VFU0FXX0pPWVNUSUNLX01BWF9BWElTLCBT RUVTQVdfSk9ZU1RJQ0tfRlVaWiwKKwkJCSAgICAgU0VFU0FXX0pPWVNUSUNLX0ZMQVQpOworCWlu cHV0X3NldF9jYXBhYmlsaXR5KHByaXZhdGUtPmlucHV0X2RldiwgRVZfS0VZLCBCVE5fRUFTVCk7 CisJaW5wdXRfc2V0X2NhcGFiaWxpdHkocHJpdmF0ZS0+aW5wdXRfZGV2LCBFVl9LRVksIEJUTl9T T1VUSCk7CisJaW5wdXRfc2V0X2NhcGFiaWxpdHkocHJpdmF0ZS0+aW5wdXRfZGV2LCBFVl9LRVks IEJUTl9OT1JUSCk7CisJaW5wdXRfc2V0X2NhcGFiaWxpdHkocHJpdmF0ZS0+aW5wdXRfZGV2LCBF Vl9LRVksIEJUTl9XRVNUKTsKKwlpbnB1dF9zZXRfY2FwYWJpbGl0eShwcml2YXRlLT5pbnB1dF9k ZXYsIEVWX0tFWSwgQlROX1NUQVJUKTsKKwlpbnB1dF9zZXRfY2FwYWJpbGl0eShwcml2YXRlLT5p bnB1dF9kZXYsIEVWX0tFWSwgQlROX1NFTEVDVCk7CisKKwllcnIgPSBpbnB1dF9zZXR1cF9wb2xs aW5nKHByaXZhdGUtPmlucHV0X2Rldiwgc2Vlc2F3X3BvbGwpOworCWlmIChlcnIpIHsKKwkJZGV2 X2VycigmY2xpZW50LT5kZXYsICJmYWlsZWQgdG8gc2V0IHVwIHBvbGxpbmc6ICVkXG4iLCBlcnIp OworCQlyZXR1cm4gZXJyOworCX0KKworCWlucHV0X3NldF9wb2xsX2ludGVydmFsKHByaXZhdGUt PmlucHV0X2RldiwKKwkJCQlTRUVTQVdfR0FNRVBBRF9QT0xMX0lOVEVSVkFMKTsKKwlpbnB1dF9z ZXRfbWF4X3BvbGxfaW50ZXJ2YWwocHJpdmF0ZS0+aW5wdXRfZGV2LAorCQkJCSAgICBTRUVTQVdf R0FNRVBBRF9QT0xMX01BWCk7CisJaW5wdXRfc2V0X21pbl9wb2xsX2ludGVydmFsKHByaXZhdGUt PmlucHV0X2RldiwKKwkJCQkgICAgU0VFU0FXX0dBTUVQQURfUE9MTF9NSU4pOworCisJZXJyID0g aW5wdXRfcmVnaXN0ZXJfZGV2aWNlKHByaXZhdGUtPmlucHV0X2Rldik7CisJaWYgKGVycikgewor CQlkZXZfZXJyKCZjbGllbnQtPmRldiwgImZhaWxlZCB0byByZWdpc3RlciBqb3lzdGljazogJWRc biIsIGVycik7CisJCXJldHVybiBlcnI7CisJfQorCisJLyogU2V0IFBpbiBNb2RlIHRvIGlucHV0 IGFuZCBlbmFibGUgcHVsbC11cCByZXNpc3RvcnMgKi8KKwl1bnNpZ25lZCBjaGFyIHBpbl9tb2Rl W10gPSB7IFNFRVNBV19HUElPX0JBU0UsCVNFRVNBV19HUElPX0RJUkNMUl9CVUxLLAorCQkJCSAg ICAgQlVUVE9OX01BU0sgPj4gMjQsIEJVVFRPTl9NQVNLID4+IDE2LAorCQkJCSAgICAgQlVUVE9O X01BU0sgPj4gOCwJQlVUVE9OX01BU0sgfTsKKwllcnIgPSBpMmNfbWFzdGVyX3NlbmQoY2xpZW50 LCBwaW5fbW9kZSwgc2l6ZW9mKHBpbl9tb2RlKSk7CisJaWYgKGVyciA8IDApCisJCXJldHVybiBl cnI7CisJcGluX21vZGVbMV0gPSBTRUVTQVdfR1BJT19QVUxMRU5TRVQ7CisJZXJyID0gaTJjX21h c3Rlcl9zZW5kKGNsaWVudCwgcGluX21vZGUsIHNpemVvZihwaW5fbW9kZSkpOworCWlmIChlcnIg PCAwKQorCQlyZXR1cm4gZXJyOworCXBpbl9tb2RlWzFdID0gU0VFU0FXX0dQSU9fQlVMS19TRVQ7 CisJZXJyID0gaTJjX21hc3Rlcl9zZW5kKGNsaWVudCwgcGluX21vZGUsIHNpemVvZihwaW5fbW9k ZSkpOworCWlmIChlcnIgPCAwKQorCQlyZXR1cm4gZXJyOworCisJcmV0dXJuIDA7Cit9CisKKyNp ZmRlZiBDT05GSUdfT0YKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIG9mX3NlZXNh d19tYXRjaFtdID0geworCXsKKwkJLmNvbXBhdGlibGUgPSAiYWRhZnJ1aXQsc2Vlc2F3LWdhbWVw YWQiLAorCX0sCisJeyAvKiBTZW50aW5lbCAqLyB9Cit9OworTU9EVUxFX0RFVklDRV9UQUJMRShv Ziwgb2Zfc2Vlc2F3X21hdGNoKTsKKyNlbmRpZiAvKiBDT05GSUdfT0YgKi8KKworLyogY2xhbmct Zm9ybWF0IG9mZiAqLworc3RhdGljIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkIHNlZXNhd19p ZF90YWJsZVtdID0geworCXsgU0VFU0FXX0RFVklDRV9OQU1FLCAwIH0sCisJeyAvKiBTZW50aW5l bCAqLyB9Cit9OworLyogY2xhbmctZm9ybWF0IG9uICovCisKK01PRFVMRV9ERVZJQ0VfVEFCTEUo aTJjLCBzZWVzYXdfaWRfdGFibGUpOworCitzdGF0aWMgc3RydWN0IGkyY19kcml2ZXIgc2Vlc2F3 X2RyaXZlciA9IHsKKwkuZHJpdmVyID0geworCQkubmFtZSA9IFNFRVNBV19ERVZJQ0VfTkFNRSwK KwkJLm9mX21hdGNoX3RhYmxlID0gb2ZfbWF0Y2hfcHRyKG9mX3NlZXNhd19tYXRjaCksCisJfSwK KwkuaWRfdGFibGUgPSBzZWVzYXdfaWRfdGFibGUsCisJLnByb2JlID0gc2Vlc2F3X3Byb2JlLAor fTsKK21vZHVsZV9pMmNfZHJpdmVyKHNlZXNhd19kcml2ZXIpOworCitNT0RVTEVfQVVUSE9SKCJB bnNodWwgRGFsYWwgPGFuc2h1bHVzckBnbWFpbC5jb20+Iik7CitNT0RVTEVfREVTQ1JJUFRJT04o IkFkYWZydWl0IE1pbmkgSTJDIEdhbWVwYWQgZHJpdmVyIik7CitNT0RVTEVfTElDRU5TRSgiR1BM Iik7Ci0tIAoyLjQyLjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCkxpbnV4LWtlcm5lbC1tZW50ZWVzIG1haWxpbmcgbGlzdApMaW51eC1rZXJuZWwtbWVu dGVlc0BsaXN0cy5saW51eGZvdW5kYXRpb24ub3JnCmh0dHBzOi8vbGlzdHMubGludXhmb3VuZGF0 aW9uLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWtlcm5lbC1tZW50ZWVzCg== 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 F0818CDB474 for ; Tue, 17 Oct 2023 03:45:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234082AbjJQDpd (ORCPT ); Mon, 16 Oct 2023 23:45:33 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:36906 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234070AbjJQDpc (ORCPT ); Mon, 16 Oct 2023 23:45:32 -0400 Received: from mail-ot1-x32a.google.com (mail-ot1-x32a.google.com [IPv6:2607:f8b0:4864:20::32a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CDEE395; Mon, 16 Oct 2023 20:45:29 -0700 (PDT) Received: by mail-ot1-x32a.google.com with SMTP id 46e09a7af769-6c620883559so3505258a34.0; Mon, 16 Oct 2023 20:45:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1697514329; x=1698119129; 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=xYJgt5+b5HVwNIIrlfXEoBwZ8hfn4jjcSeUfjjs6Z20=; b=kx+rKXR6E/Zpq/Fr4DSFOmcN4/Ge0T0isA7F2Wp6pCWHVwLBzOjlKSnK1ksqLwFMjZ fLnL10aC+It0COGru80hNwyG6Ej9q+HsQp8howU94fF7IYPvwhHAkHXxKxJ21P/zctDr 0aT/Rdh3P1t2JyfZxugqmwpwU2b9i0KA8FZjk0ypKShqsDjh+lq8KQ+HoazaAu6c8cmr 0pIlZXexkzz1oySe+XpxHNjY3MZHH1yw/gTAiA8JgzhQc67iJHEZWVctxSjN5tXy4nnr dbe7BLlh6BYd5Uv8Id51GAV26KcXzGPhMXrmoL0Wf5uqLUY4UrUBQasFXzhAHZUWRW6l J4pQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1697514329; x=1698119129; 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=xYJgt5+b5HVwNIIrlfXEoBwZ8hfn4jjcSeUfjjs6Z20=; b=thfnyf9GJeAxe/2s/kffCqd+3ZG+/Y4Y4A+KDCDvsGkKG9wNPJ7wXID1DSO+CTeRo1 SdhgHKEiNEmtWoshRl6FPX2WuOszXBZRy3z0Mlxdu51KaDVeT5EfJMXTcRqguAQNvVyr BWIlVB3DYIFWz10FD3TvgJSzJhYbCw7Nx+0YoGICSV6aDJsV8HE6WrSp61VXrNgWldM9 1SYumGZKoo6NOxuVMP2C9DfS92CRmAy5BYElqn//yopxS8pFqQRLWHUBQLRQawM+CHlU 0iav9vF5EKyuQoBjCdNSr3E2Bl9tSrfcDBgyCXEQrlqp3jfMx9FOuyhE1N757yj/FPXJ 0iKA== X-Gm-Message-State: AOJu0YwwCIsUzIiqMJnz/qqv5GJ9VRXr/+kaRMV8mecYn7fM/cZUxZzt 2oXlbhohwSpCpwf4g/5Rm1ye/h94HZojrg== X-Google-Smtp-Source: AGHT+IGd5h0eR/hvzmIeetJD4HfGJWvoSL9BsCP1F3rrJaFSMUT77YeMQxH8QvNmKtl6vfRxcynrHQ== X-Received: by 2002:a05:6830:1e65:b0:6bc:fdc8:d600 with SMTP id m5-20020a0568301e6500b006bcfdc8d600mr1078616otr.25.1697514328668; Mon, 16 Oct 2023 20:45:28 -0700 (PDT) Received: from localhost.localdomain ([2401:4900:628c:a92e:5b03:91a2:57c8:16f3]) by smtp.gmail.com with ESMTPSA id y13-20020aa793cd000000b0069305627491sm313777pff.159.2023.10.16.20.45.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 16 Oct 2023 20:45:28 -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?= , Shuah Khan , linux-kernel-mentees@lists.linuxfoundation.org, linux-kernel@vger.kernel.org Subject: [PATCH v5 2/2] input: joystick: driver for Adafruit Seesaw Gamepad Date: Tue, 17 Oct 2023 09:13:45 +0530 Message-ID: <20231017034356.1436677-2-anshulusr@gmail.com> X-Mailer: git-send-email 2.42.0 In-Reply-To: <20231017034356.1436677-1-anshulusr@gmail.com> References: <20231017034356.1436677-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 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 */ +#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 + +#define ANALOG_X 14 +#define 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 +/* 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; +}; + +static int seesaw_read_data(struct i2c_client *client, struct seesaw_data *data) +{ + int err; + unsigned char write_buf[2] = { SEESAW_GPIO_BASE, SEESAW_GPIO_BULK }; + unsigned char read_buf[4]; + + err = i2c_master_send(client, write_buf, sizeof(write_buf)); + if (err < 0) + return err; + err = i2c_master_recv(client, read_buf, sizeof(read_buf)); + if (err < 0) + return err; + + u32 result = get_unaligned_be32(&read_buf); + + 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; + /* + * 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); + 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); + input_sync(input); +} + +static int seesaw_probe(struct i2c_client *client) +{ + int err; + struct seesaw_gamepad *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; + + 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)); + 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); + + 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; + + 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 */ + +/* clang-format off */ +static const struct i2c_device_id seesaw_id_table[] = { + { SEESAW_DEVICE_NAME, 0 }, + { /* Sentinel */ } +}; +/* clang-format on */ + +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