From nobody Fri Sep 25 23:51:06 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 142614FC8C1; Fri, 25 Sep 2026 21:22:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790371343; cv=none; b=lfUWc/ZLlD1SvMzNDCNiKTCfHmaBcSy6NRZVyjFAZBQ6RFFShVCyo3XjjzLTLUxSwW6e/QNkhDgIxVL+fyk+vNoR+u8EJYGNYLi7Q6ZgwO/FJKyyTbxAxQdTompoOtI019wR0o28CDV9uX/aWeIkw6T0ZcgDo0k0eUzEizaZCEI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790371343; c=relaxed/simple; bh=a+KdKsTZhfa/DABR8dxHk8cRR3qLZ2vqAHQD6gthLAw=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=V7PswW1BELzhJrKUHEfA+bW+liRHzxgKew6TEKFUWJdDfYjdPu0Xwuu6SoT2+6LhiPft9twM03CGBHdROELFz7GNbSQb+biQtpI6c0Ggi0CbgWoHO2uN7kgvo8cRvS2QqAPozK+KZNFrHhPuMciKWzykGi55RBj/OtF7AbxNFPY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=b3DEYKOd; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="b3DEYKOd" Received: by smtp.kernel.org (Postfix) with ESMTPS id 99D3AC2BCF4; Fri, 25 Sep 2026 21:22:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1790371342; bh=a+KdKsTZhfa/DABR8dxHk8cRR3qLZ2vqAHQD6gthLAw=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=b3DEYKOdu/lnm0xbFmJ64UsluczJG5AT/xvnJNvJAlAivK03MuNcfG5mZGznHvoGe bzAu+Ylk67t8RsP8mxa3nV347UboSzkebBPbSrGsQjBYWQZibX2x9Db/6S4MzlFkS7 0en5sZl03uwnnq5M9snePER0qD0adoNVyIqoUtpcNRuwMub3yh0rGfqsTuQZKw/b0C 8/Qzco8dObIIpiEQUxKJuj3AhNfmUn8+ybok+d0PJSKk6CxcsvZn5c90rmt96UJtiA COLwuw79hbMyOMZWRgAsOvd+wErYAXkRK/t6/7k/6c6xUNyqcx78xIJx6mNhAyK5NN SgiEKKPD9WtUA== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 780A5C98326; Fri, 25 Sep 2026 21:22:22 +0000 (UTC) From: David Heidelberg via B4 Relay Date: Fri, 25 Sep 2026 23:22:19 +0200 Subject: [PATCH v8 1/5] Input: stmfts - wait for controller ready after reset Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260925-stmfts5-v8-1-0fcf49e2c85f@ixit.cz> References: <20260925-stmfts5-v8-0-0fcf49e2c85f@ixit.cz> In-Reply-To: <20260925-stmfts5-v8-0-0fcf49e2c85f@ixit.cz> To: Dmitry Torokhov , Maxime Coquelin , Alexandre Torgue , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Henrik Rydberg , Bjorn Andersson , Konrad Dybcio Cc: Petr Hodina , linux-input@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Krzysztof Kozlowski , devicetree@vger.kernel.org, linux-arm-msm@vger.kernel.org, phone-devel@vger.kernel.org, David Heidelberg , stable@vger.kernel.org X-Mailer: b4 0.16.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=4929; i=david@ixit.cz; h=from:subject:message-id; bh=eDTdFrg/SW6FiqwVfkrIiMqi05Gtrp3Ip5N2yAkOtDM=; b=owEBbQKS/ZANAwAIAWACP8TTSSByAcsmYgBqtuYMVR8nrgjUXsVjL86TgRoFvvNYq6ifK59IW 5gCwJLISBGJAjMEAAEIAB0WIQTXegnP7twrvVOnBHRgAj/E00kgcgUCarbmDAAKCRBgAj/E00kg cgVHD/0R++6Q9P5r44FhEmGEmOc7TvbHDtU0dAQQkxVnqvaEuC3n7VPdmnvwk5yItwwr/ohG7pw AZrIsPsrUY5u4zwLm0E5zE2eaDojGHNWKTCuHIJEeiwrsUic+OllOQJk6YkNzN81A6oLE9nHvBp KQNaR04ChyRBNdL7WN0THb0BysdPLewZ30RaZFtAxgY4OLsAx6K0rqLK1s2G6MHiVrwXi5nQhX2 MAYuRDn88BbjRufeo7GqKVNPg3ACGADSBFDmxG5j75HYSJP4Ab8hZlmrmRh/pOPpeM8hVjTnoea eWUWAflYaz6hVHuBL5IJtWJ5UMi1swReO72MkZqhp+YMM5EIrlz5hy4vrCb/tV0NZR6mvXKnJfh LNM2wjoZramlSopy1p94cX/HkUovJEJEiFbgLlMnV8rjL78Pz5DUHKNo+3yh12wTbaEiMW9k7h7 XUs7jPD1edQYQKeSiUVs6JFRO2slnrM6N6L6VLDUuco/COgU/h2xCHsyl+ByFZBipxIMoLfxXCI xVf5hrT93MDdPm9Etkg3b0+gJHNsm0SQ38tXF6VDLPlHQMmk9IZrEVVHB+VCLDqv3GtX83Le65v 3cy/Kga65M7QhyVMfRBe0XJYpim/IGj7QjF+R28+cmXF202t29zd+UIdcxqkQT6uwI33mgxy3Ya OgUydjXIO4Zsy+g== X-Developer-Key: i=david@ixit.cz; a=openpgp; fpr=D77A09CFEEDC2BBD53A7047460023FC4D3492072 X-Endpoint-Received: by B4 Relay for david@ixit.cz/default with auth_id=355 X-Original-From: David Heidelberg Reply-To: david@ixit.cz From: David Heidelberg After releasing the reset line stmfts_reset() sleeps a fixed 50 ms and stmfts_power_on() another 50 ms before the first I2C access. That is enough for a warm reset, but when both supplies were really cut during system suspend the controller boots from cold and can need longer. If it does, the first read fails, stmfts_resume() returns an error and the touchscreen is left powered off with its interrupt disabled. The controller posts a controller ready event once it has booted, and the event parser already completes cmd_done on it. Enable the interrupt right after releasing reset and wait for that event instead of sleeping, giving the controller 300 ms, the total budget the vendor driver allows. Boards without a reset line keep the old timing. Usually phones such as Pixel 4a and Xiaomi Mi 8 needs longer delay, so without this change touchscreen stops working. Fixes: 8a1f9de80e45 ("Input: stmfts - add optional reset GPIO support") Cc: stable@vger.kernel.org Co-developed-by: Dmitry Torokhov Signed-off-by: David Heidelberg --- drivers/input/touchscreen/stmfts.c | 60 ++++++++++++++++++++++++----------= ---- 1 file changed, 38 insertions(+), 22 deletions(-) diff --git a/drivers/input/touchscreen/stmfts.c b/drivers/input/touchscreen= /stmfts.c index 972687797f826..1720202d6186b 100644 --- a/drivers/input/touchscreen/stmfts.c +++ b/drivers/input/touchscreen/stmfts.c @@ -59,16 +59,18 @@ #define STMFTS_MASK_X_MSB 0x0f #define STMFTS_MASK_Y_LSB 0xf0 =20 /* key related event masks */ #define STMFTS_MASK_KEY_NO_TOUCH 0x00 #define STMFTS_MASK_KEY_MENU 0x01 #define STMFTS_MASK_KEY_BACK 0x02 =20 +#define STMFTS_RESET_TIMEOUT_MS 300 + #define STMFTS_EVENT_SIZE 8 #define STMFTS_STACK_DEPTH 32 #define STMFTS_DATA_MAX_SIZE (STMFTS_EVENT_SIZE * STMFTS_STACK_DEPTH) #define STMFTS_MAX_FINGERS 10 #define STMFTS_DEV_NAME "stmfts" =20 static const struct regulator_bulk_data stmfts_supplies[] =3D { { .supply =3D "vdd" }, @@ -538,25 +540,16 @@ static int stmfts_read_system_info(struct stmfts_data= *sdata) sdata->chip_ver =3D reg[0]; sdata->fw_ver =3D be16_to_cpup((__be16 *)®[2]); sdata->config_id =3D reg[4]; sdata->config_ver =3D reg[5]; =20 return 0; } =20 -static void stmfts_reset(struct stmfts_data *sdata) -{ - gpiod_set_value_cansleep(sdata->reset_gpio, 1); - msleep(20); - - gpiod_set_value_cansleep(sdata->reset_gpio, 0); - msleep(50); -} - static int stmfts_configure(struct stmfts_data *sdata) { int err; =20 err =3D stmfts_command(sdata, STMFTS_SYSTEM_RESET); if (err) return err; =20 @@ -582,53 +575,76 @@ static int stmfts_configure(struct stmfts_data *sdata) =20 return 0; } =20 static int stmfts_power_on(struct stmfts_data *sdata) { int err; =20 + if (sdata->reset_gpio) { + gpiod_set_value_cansleep(sdata->reset_gpio, 1); + /* a short delay before powering up */ + usleep_range(1000, 1500); + } + err =3D regulator_bulk_enable(ARRAY_SIZE(stmfts_supplies), sdata->supplies); if (err) return err; =20 - /* - * The datasheet does not specify the power on time, but considering - * that the reset time is < 10ms, I sleep 20ms to be sure - */ - msleep(20); + if (sdata->reset_gpio) { + reinit_completion(&sdata->cmd_done); =20 - if (sdata->reset_gpio) - stmfts_reset(sdata); + /* + * The datasheet does not specify the power on time, but + * considering that the reset time is < 10ms, sleep for 20ms + * to be sure before releasing reset line. + */ + msleep(20); + gpiod_set_value_cansleep(sdata->reset_gpio, 0); =20 - err =3D stmfts_read_system_info(sdata); - if (err) - goto err_disable_regulators; + enable_irq(sdata->client->irq); =20 - enable_irq(sdata->client->irq); + if (!wait_for_completion_timeout(&sdata->cmd_done, + msecs_to_jiffies(STMFTS_RESET_TIMEOUT_MS))) { + dev_err(&sdata->client->dev, "controller not ready after reset"); + err =3D -ETIMEDOUT; + goto err_disable_irq; + } + } else { + /* + * We do not know the real controller state (was it powered + * off or reset). Let's hope that this is enough time to + * initialize. + */ + msleep(70); + + enable_irq(sdata->client->irq); + } =20 - msleep(50); + err =3D stmfts_read_system_info(sdata); + if (err) + goto err_disable_irq; =20 err =3D stmfts_configure(sdata); if (err) goto err_disable_irq; =20 /* * At this point no one is using the touchscreen * and I don't really care about the return value */ (void)i2c_smbus_write_byte(sdata->client, STMFTS_SLEEP_IN); =20 return 0; =20 err_disable_irq: disable_irq(sdata->client->irq); -err_disable_regulators: + regulator_bulk_disable(ARRAY_SIZE(stmfts_supplies), sdata->supplies); return err; } =20 static void stmfts_power_off(void *data) { struct stmfts_data *sdata =3D data; =20 --=20 2.55.0 From nobody Fri Sep 25 23:51:06 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1ABB34FC8C9; Fri, 25 Sep 2026 21:22:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790371343; cv=none; b=gWcPSHCEUCCTgnqnub4l92X6qCzPdb3f/Wsjgds9EJNLvLRj7xMaBac8ylZpRmlVoJSexKXXLY4gzQ76vc7vtLSHU+z8Jr/rNnoC42c3fT1gOwJnT0pv7sXp3ca1v3y1mpq3xZaO9P3ZAeWzu8gZStZOO43baSCHBiHwE+4SRPs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790371343; c=relaxed/simple; bh=GoyLU2U3ppXbJU9VRV2KKSjfBJtgMQqJ586u/SdHnow=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=N+sS3DMMCBidmIGSMvDCmHHLptdwReTbnqA95zWZRtnB9MFXSiYAPYObUFZkHbN/ziqpJLVEHHy7qMUNtdJDyJR/ae01Y9YQvUBqCzHKbUtNcRITKSmdEH+a43QNZ5/ytRX5KU5EKncgx0CzxcDeJplrAj/A67MR5JH8y7MUdYk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=E6Tt6HN6; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="E6Tt6HN6" Received: by smtp.kernel.org (Postfix) with ESMTPS id AE091C2BCF5; Fri, 25 Sep 2026 21:22:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1790371342; bh=GoyLU2U3ppXbJU9VRV2KKSjfBJtgMQqJ586u/SdHnow=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=E6Tt6HN6dDVsoSQ9s7/R/C5uG/20efuDuoui5xfBmxKuopsKOVMSW7o3Ea0GnFS8d nrHGiplAi1QJXgizemJPopFXCSunX9eLLks43SWZE3vRTlFisTFroOVRCdeups6YAe psFQscgHyCv2cgs2VdZsCF6buhzmuLabB5BZHxlj9TOsQ6Z7VI1OX2jQmn79cs0uGZ nh7HJwRLNENR+7L98lhnts1SJNC9hrAXTT9WUdq/BaGgxxg9zVrAyKz6dVbRWOl8ZV NBZ3sKBWQ582ZApTvxm7h4gmQ4OmI00T3zXUN6EcOCfkhAZS20egjx9dndVcLvkiXi HQESCYtEuJMXg== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8DC45C9830E; Fri, 25 Sep 2026 21:22:22 +0000 (UTC) From: David Heidelberg via B4 Relay Date: Fri, 25 Sep 2026 23:22:20 +0200 Subject: [PATCH v8 2/5] dt-bindings: input: touchscreen: st,stmfts: Improve example Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260925-stmfts5-v8-2-0fcf49e2c85f@ixit.cz> References: <20260925-stmfts5-v8-0-0fcf49e2c85f@ixit.cz> In-Reply-To: <20260925-stmfts5-v8-0-0fcf49e2c85f@ixit.cz> To: Dmitry Torokhov , Maxime Coquelin , Alexandre Torgue , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Henrik Rydberg , Bjorn Andersson , Konrad Dybcio Cc: Petr Hodina , linux-input@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Krzysztof Kozlowski , devicetree@vger.kernel.org, linux-arm-msm@vger.kernel.org, phone-devel@vger.kernel.org, David Heidelberg X-Mailer: b4 0.16.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=1432; i=david@ixit.cz; h=from:subject:message-id; bh=8hrNriBZ9r5NUpjg2ye3gjvx8mrHqp+97D+QCG0V3A8=; b=owEBbQKS/ZANAwAIAWACP8TTSSByAcsmYgBqtuYMItkEShhRrfUYkEQkLKY95RkKZ9aBK821r KzsaRioKoeJAjMEAAEIAB0WIQTXegnP7twrvVOnBHRgAj/E00kgcgUCarbmDAAKCRBgAj/E00kg cgUwD/0fup7gi4EPXq8XUj2gTbqngr8fFCroIEUBSk69EYJYBEP3euvVnv7BWAb1FueivXZz8Qy VcRY+on9bUdVD28j9oP8q3bYjsQwtlI4CkBJYYPxRqT0kdkLWlfyWWWqFR6d6IcB2kdzeuuGnYd zTsdPPhrNH2D61G35Z5ajlLItQ1asun/oSGNOZNlMdFwSD7JGxidOVWh19i3Bgx6/8vyWpZO3s2 OmESlUJIexP0O4l19baYbTmUb08kbQONDEvDJBPBz74fcb/aPG0uOhzpczCT3r65QLUkCxncM2a xYMYoqHN61vTJrWl8W4hCFswqPPG3Yf7VNDoXL3AHpjqDpNo40DdHY+YbdcFkUWHKJhNTzgegiB ftN0w+ZnWgZZsiRqyUmK6hMRkKyKRU1ifRGU10K4rjq3kby5BXjtyGPKf3CrEz8BlKgx29ZaOz8 hoPrmMzkk/dxle3kgDwwlAP1dEzVhe5va21gj2EX1UIVWUcyu0mz2nboz4sx+9NtG94PRav5btm XgNlDQjkoGyBLkQTMUUVw+7EkTAJiW7FcmXyyhgAUeaaMUI90AY3d+lKYsRfNyuGST3cdWXxqtA q9TAzHZVMhNhKIa7qJai5FkT9o9H8FJ0BWN2TpK0syQqrWLorz8sg0HdydidnDnbG/tB349J6/b zgKF1caJjGptipw== X-Developer-Key: i=david@ixit.cz; a=openpgp; fpr=D77A09CFEEDC2BBD53A7047460023FC4D3492072 X-Endpoint-Received: by B4 Relay for david@ixit.cz/default with auth_id=355 X-Original-From: David Heidelberg Reply-To: david@ixit.cz From: David Heidelberg The touchscreen-size-{x,y} is exact number, the -1 deduction is done on driver side. Example now use interrupts-extended and size obviously not deducted by one. Signed-off-by: David Heidelberg --- Documentation/devicetree/bindings/input/touchscreen/st,stmfts.yaml | 7 +++= ---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/Documentation/devicetree/bindings/input/touchscreen/st,stmfts.= yaml b/Documentation/devicetree/bindings/input/touchscreen/st,stmfts.yaml index 64c4f24ea3dd0..6eb1ad6582d82 100644 --- a/Documentation/devicetree/bindings/input/touchscreen/st,stmfts.yaml +++ b/Documentation/devicetree/bindings/input/touchscreen/st,stmfts.yaml @@ -59,18 +59,17 @@ examples: =20 i2c { #address-cells =3D <1>; #size-cells =3D <0>; =20 touchscreen@49 { compatible =3D "st,stmfts"; reg =3D <0x49>; - interrupt-parent =3D <&gpa1>; - interrupts =3D <1 IRQ_TYPE_LEVEL_LOW>; - touchscreen-size-x =3D <1599>; - touchscreen-size-y =3D <2559>; + interrupts-extended =3D <&gpa1 1 IRQ_TYPE_LEVEL_LOW>; + touchscreen-size-x =3D <1600>; + touchscreen-size-y =3D <2560>; touch-key-connected; avdd-supply =3D <&ldo30_reg>; vdd-supply =3D <&ldo31_reg>; ledvdd-supply =3D <&ldo33_reg>; }; }; --=20 2.55.0 From nobody Fri Sep 25 23:51:06 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1AAFD4FC8C5; Fri, 25 Sep 2026 21:22:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790371343; cv=none; b=IbcISqcAsZoRvP6sELhKYuZZ5igyfwzUHdZeuVnjwp3YYfNTMGX4GGzeZ4HtBJrWQve585kTYn3TYHtvisB95KY1/y5ngZeY7/u1G6b2xuLTeseTClbW/2O8dD8isoPKY2XWmsuNJNot4fT7PXY+UIAIJhI6NBc0zD97kdafFxw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790371343; c=relaxed/simple; bh=ONoNtmJiIBVmdYvigtOlZwFCLGUN8EHYDzwyaXRm1j0=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=nMogGTZCmkbcJ/vn/3ZubR81O1fx8xxujfELUOGid885BEfpdfqc0rFUHW68ZbuUVwx8yk+NNTqrNjjNMc4f+e35W6jN+3rNrSoCxrTSpAu/Q0wjDhulykDXQcH7n2zHg591rFIXSRJT7241niPbiDy09SUJv+LF9W/rzY8/U7k= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=EMEHAV3B; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="EMEHAV3B" Received: by smtp.kernel.org (Postfix) with ESMTPS id BC9F1C2BD04; Fri, 25 Sep 2026 21:22:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1790371342; bh=ONoNtmJiIBVmdYvigtOlZwFCLGUN8EHYDzwyaXRm1j0=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=EMEHAV3BEj/A2XGWNm8xZj+jjbAuIstQ0yed9mD/Al1zZcE/csx9mj/XWrbmQthy6 QznCgeOAa0FZwB6wT+dHB1MennOHqknFx44hBdIBYFzBJXH2i2jtF/Y5MJtqh7OHVI ttHry1uQ+Fgqee2yR+ctqXetb5zBQnOOX0kfJzJv3ujAA3/k6gu4coXCnanDy8VDf/ 0k9chKywIp9j/v4IjjRQvHRy9x4dkmnl0pgmy6POZdQ42wD5nvUthxuUT5v3t6WXky Dqi/BTYhEQOeiLMZzf9i6BfuDOVmCCars1eXrWoSPm+8a9+Cy6H664kyL6VUavp1kb 5x7h5ITTvv/XQ== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9E3C9C9832E; Fri, 25 Sep 2026 21:22:22 +0000 (UTC) From: David Heidelberg via B4 Relay Date: Fri, 25 Sep 2026 23:22:21 +0200 Subject: [PATCH v8 3/5] dt-bindings: input: touchscreen: st,stmfts: Introduce STM FTS5 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260925-stmfts5-v8-3-0fcf49e2c85f@ixit.cz> References: <20260925-stmfts5-v8-0-0fcf49e2c85f@ixit.cz> In-Reply-To: <20260925-stmfts5-v8-0-0fcf49e2c85f@ixit.cz> To: Dmitry Torokhov , Maxime Coquelin , Alexandre Torgue , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Henrik Rydberg , Bjorn Andersson , Konrad Dybcio Cc: Petr Hodina , linux-input@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Krzysztof Kozlowski , devicetree@vger.kernel.org, linux-arm-msm@vger.kernel.org, phone-devel@vger.kernel.org, David Heidelberg X-Mailer: b4 0.16.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=2063; i=david@ixit.cz; h=from:subject:message-id; bh=vbynNCWfAo0HQ+BS1gbKGd/f9mQ/YKgvFg8G/NvxKsg=; b=owEBbQKS/ZANAwAIAWACP8TTSSByAcsmYgBqtuYM07qIN5wZpC1R+DMIeJx5PEEPnjxk5Rjy2 wZCQqg459OJAjMEAAEIAB0WIQTXegnP7twrvVOnBHRgAj/E00kgcgUCarbmDAAKCRBgAj/E00kg clNwD/9Lg7M9OCARmi4aw5U9dpXlYVqUYvudwR3TMnYeqDScSaOHLsGU+lwTYIWX6wH74/XBWKd FCknE6jXY/3B+FiZw6W+I37Jiodjcjur0NyfBXxsxonYFqIw+OLEvFQVlFbOrV87bVkSAL2rgk5 47yu8PsjW1gEKEN2tD8TidDhaoR1yCyQDgzNuu9/lm+XcquvxZLVyCMpC6m9No0KmLyFt7bGVV0 K9O15atUUdD/zS5SfgV/FjceTGs3tUl7lokiwmbMSWubQpiFfVd0Z+iIRpm1YNGS/UQv9IN6Cps ETw4xVODF5tAOFErJt2dxCId4lphugOnp2e9TJqabWjooxUC4MhP1UFSDBrIN73tpVCeG07/4eS 9jqaqZrkjqiAJ3pnL+oPex4mjkok/jiKF8BBpKjuWqVx63fuXzMhozRIzaCn4CBB2kgk3BTyyFS 0Q9uUxfmA+fu283l73DEUyycoJIY6rnpfab6ENUKcIMPvbvcXPFoySgzzoAjQwsEniaGSvIHDnz PJJejbnz4+4Vf57aV/cmCu93HbvGv9TAt0RXzNjq4cdyjGBkfxqIkYM9A3WT6vS2k7r7GZu061d On8XhHD8OCISpH8IkQDcd55CyR4SFbrasDUwTOddPXeNHBdGh6Ldlktl0D8X+V+gwsYa7Fi/bnL AKBl/iXIlCFpTeQ== X-Developer-Key: i=david@ixit.cz; a=openpgp; fpr=D77A09CFEEDC2BBD53A7047460023FC4D3492072 X-Endpoint-Received: by B4 Relay for david@ixit.cz/default with auth_id=355 X-Original-From: David Heidelberg Reply-To: david@ixit.cz From: David Heidelberg Introduce more recent STM FTS5 touchscreen support. Signed-off-by: David Heidelberg --- .../bindings/input/touchscreen/st,stmfts.yaml | 22 ++++++++++++++++++= ---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/Documentation/devicetree/bindings/input/touchscreen/st,stmfts.= yaml b/Documentation/devicetree/bindings/input/touchscreen/st,stmfts.yaml index 6eb1ad6582d82..3de4bc5cd3f78 100644 --- a/Documentation/devicetree/bindings/input/touchscreen/st,stmfts.yaml +++ b/Documentation/devicetree/bindings/input/touchscreen/st,stmfts.yaml @@ -9,22 +9,21 @@ title: ST-Microelectronics FingerTip touchscreen controll= er maintainers: - Krzysztof Kozlowski =20 description: The ST-Microelectronics FingerTip device provides a basic touchscreen functionality. Along with it the user can enable the touchkey which can = work as a basic HOME and BACK key for phones. =20 -allOf: - - $ref: touchscreen.yaml# - properties: compatible: - const: st,stmfts + enum: + - st,stmfts + - st,stmfts5 =20 reg: maxItems: 1 =20 avdd-supply: description: Analogic power supply =20 interrupts: @@ -35,27 +34,42 @@ properties: =20 touch-key-connected: type: boolean description: The touchkey feature is connected =20 vdd-supply: description: Power supply =20 + mode-switch-gpios: + description: Optional switch between touchscreen SLPI and AP mode. + maxItems: 1 + reset-gpios: description: Reset GPIO (active-low) maxItems: 1 =20 required: - compatible - reg - avdd-supply - interrupts - vdd-supply =20 +allOf: + - $ref: touchscreen.yaml# + - if: + not: + properties: + compatible: + const: st,stmfts5 + then: + properties: + mode-switch-gpios: false + unevaluatedProperties: false =20 examples: - | #include =20 i2c { #address-cells =3D <1>; --=20 2.55.0 From nobody Fri Sep 25 23:51:06 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1AA264FC8C4; Fri, 25 Sep 2026 21:22:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790371343; cv=none; b=eqIJBGnnLrF9P43l4JXYmtgsm2B76X+R6Fx3PWsStlSHg5eUbyynawVuf1wb1Rw7O+1cGw9ETWXbCJxx/srC2nOrgD1IWRFUNffAGRBj/nNxGu3FmuqX4rtJTYPXNSUg0kOquYuaSR4lNKoXQHLcthn5yg88iJdaCNbYA3Wmpn0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790371343; c=relaxed/simple; bh=oVDp3KU3MRDSnwsswydj17SJS5OVEVi228Nt3Ai5YqM=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=bp9PzDaYvD5Bhbn+TI1Zq84M/HHjzGtw13+L1K2K02MOKMnonkz0GqvYVe75WHPp35C1rXpIcG9fO0706DdwsHMo2q9sc8iBjZ9hrdcq+uuWhZrotlOOxaQXwy4+gVOQORosPRpM0BwuV+Hhjv5uzhhWgPExc8QG3f2ssYqHN7Q= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Th5ITFxC; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Th5ITFxC" Received: by smtp.kernel.org (Postfix) with ESMTPS id C676BC2BCFA; Fri, 25 Sep 2026 21:22:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1790371342; bh=oVDp3KU3MRDSnwsswydj17SJS5OVEVi228Nt3Ai5YqM=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=Th5ITFxCkSeq+c9doPLEaKSmKnRSDcB5evNz/Xg8GpuIfvsIHVDQt0hTPcW1bFKef rcSj4MYEQr/7/7pxFZ7MCm5EmMseOAsZRAczkWea/Rw1f1pG7Qxhc6aqPn/gA0Mf/c d8yJjdjeijwxDESNds8vzkevzUGJ2NUR8ZqDfbzGz1iJ1a7baQOruSEusVwzhvQ04d 7dz4a3NzGYU0qPosVXyZp1vMft+fH0BXT15Ey/lZob7s4nuliGqVM0dn0yko6LJyne YjnpRf2KOOIiUwjgpmIivlMOvszRQ3N5/ZZpg9L5KvcIKQr09DEaCcTRlkzluVS0Ed VueBBiI20+SYQ== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id B327CC9832A; Fri, 25 Sep 2026 21:22:22 +0000 (UTC) From: David Heidelberg via B4 Relay Date: Fri, 25 Sep 2026 23:22:22 +0200 Subject: [PATCH v8 4/5] Input: stmfts - support FTS5 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260925-stmfts5-v8-4-0fcf49e2c85f@ixit.cz> References: <20260925-stmfts5-v8-0-0fcf49e2c85f@ixit.cz> In-Reply-To: <20260925-stmfts5-v8-0-0fcf49e2c85f@ixit.cz> To: Dmitry Torokhov , Maxime Coquelin , Alexandre Torgue , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Henrik Rydberg , Bjorn Andersson , Konrad Dybcio Cc: Petr Hodina , linux-input@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Krzysztof Kozlowski , devicetree@vger.kernel.org, linux-arm-msm@vger.kernel.org, phone-devel@vger.kernel.org, David Heidelberg X-Mailer: b4 0.16.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=24236; i=david@ixit.cz; h=from:subject:message-id; bh=gCJoJPZHSA3O6heBc6j2meOb+Q3LOsuha/Mw7VaWxF8=; b=owEBbQKS/ZANAwAIAWACP8TTSSByAcsmYgBqtuYMd6MGVP8BDe1rnyM21xAH49FvzAmIaH6Su eHe0rICpa+JAjMEAAEIAB0WIQTXegnP7twrvVOnBHRgAj/E00kgcgUCarbmDAAKCRBgAj/E00kg clACD/4n9pKxqek9KWC1eB01XC1YrerZaA5UB6PNDR2Izo8T4c9HML4I1IlrYN+t4WsmmyWP8E1 2IKXj/KMEuC8ijVVEzI4YXUaHO2GfyN1CDiaR6ZHT112ueiklSy7mpAyIK/ClqvVbMsl9OzPcPs T0uLs16vZKBxJV02mZoXEzZLeABDPs4CtdjFsXCewt27/dVTq61UmuqDDLSQJ/T4PbRwl4MvVKT G5njIiZXY/EkZouOJZAotB64Av4z5zq2O9Q/3RsN7PaYOx3ohTEnzs26HQ9NIdkWAMw7YwHNU8T +N0QHXeGYonrYDRuFCxZUt+qA/qbcf62MEL0r6bTTB7DdHTFS1owtToegPqQaSh3nePkIMTFQlX q966bFzqxRROagIp/VoD+MdXOqN5M1vnqVbdV42hp53aexjLg03GKv7cDebkgYBAWflbNzkRSwT e0tYPZ64kmEtLk+goAuLHaK9kZpPwt9jkFGAnGxXZzlpNQcWZF0onSh/TBejTrDS94TU4yzjxiQ Avx3k7/V6weklgq2UDS/g15Q7AvdH3N6/j4Mqk0M6xo0V8XwLCw0g+xEeLLyViBKTEfKCu6fPM0 d3dwTrWWZBOE2EwtivQTvlJ1LA5G8api+fAaGvdDiXhq3vENlZe1vAlv2bxHgmLoCXNz8nWpHm5 GZvCrwFJ4vgqNWg== X-Developer-Key: i=david@ixit.cz; a=openpgp; fpr=D77A09CFEEDC2BBD53A7047460023FC4D3492072 X-Endpoint-Received: by B4 Relay for david@ixit.cz/default with auth_id=355 X-Original-From: David Heidelberg Reply-To: david@ixit.cz From: David Heidelberg The FTS support SLPI and AP mode, introduce mode-switch GPIO to switch between those two. Currently we can handle only full power AP mode, so we just keep the AP on. Useful for devices like Pixel 3 (blueline), Pixel 4a (sunfish), Xiaomi Mi 8 (dipper), and many others. Based on work of Petr Hodina Signed-off-by: David Heidelberg --- drivers/input/touchscreen/stmfts.c | 408 +++++++++++++++++++++++++++++++++= ---- 1 file changed, 368 insertions(+), 40 deletions(-) diff --git a/drivers/input/touchscreen/stmfts.c b/drivers/input/touchscreen= /stmfts.c index 1720202d6186b..2b9faeef7e462 100644 --- a/drivers/input/touchscreen/stmfts.c +++ b/drivers/input/touchscreen/stmfts.c @@ -1,14 +1,18 @@ // SPDX-License-Identifier: GPL-2.0 -// STMicroelectronics FTS Touchscreen device driver -// -// Copyright (c) 2017 Samsung Electronics Co., Ltd. -// Copyright (c) 2017 Andi Shyti +/* STMicroelectronics FTS Touchscreen device driver + * + * Copyright 2017 Samsung Electronics Co., Ltd. + * Copyright 2017 Andi Shyti + * Copyright David Heidelberg + * Copyright Petr Hodina + */ =20 +#include #include #include #include #include #include #include #include #include @@ -30,16 +34,21 @@ #define STMFTS_SS_HOVER_SENSE_ON 0x95 #define STMFTS_MS_KEY_SENSE_OFF 0x9a #define STMFTS_MS_KEY_SENSE_ON 0x9b #define STMFTS_SYSTEM_RESET 0xa0 #define STMFTS_CLEAR_EVENT_STACK 0xa1 #define STMFTS_FULL_FORCE_CALIBRATION 0xa2 #define STMFTS_MS_CX_TUNING 0xa3 #define STMFTS_SS_CX_TUNING 0xa4 +#define STMFTS5_SET_SCAN_MODE 0xa0 + +/* FTS5 scan mode commands */ +#define STMFTS5_SCAN_MODE_ACTIVE 0x00 +#define STMFTS5_SCAN_ACTIVE_MULTI_TOUCH BIT(0) =20 /* events */ #define STMFTS_EV_NO_EVENT 0x00 #define STMFTS_EV_MULTI_TOUCH_DETECTED 0x02 #define STMFTS_EV_MULTI_TOUCH_ENTER 0x03 #define STMFTS_EV_MULTI_TOUCH_LEAVE 0x04 #define STMFTS_EV_MULTI_TOUCH_MOTION 0x05 #define STMFTS_EV_HOVER_ENTER 0x07 @@ -47,22 +56,48 @@ #define STMFTS_EV_HOVER_MOTION 0x09 #define STMFTS_EV_KEY_STATUS 0x0e #define STMFTS_EV_ERROR 0x0f #define STMFTS_EV_CONTROLLER_READY 0x10 #define STMFTS_EV_SLEEP_OUT_CONTROLLER_READY 0x11 #define STMFTS_EV_STATUS 0x16 #define STMFTS_EV_DEBUG 0xdb =20 +/* + * FTS5 events: the event ID is in the high nibble of event[0], the low + * nibble carries additional payload (bits 5:4 of the touch major axis for + * touch events), so it must be masked before comparing. + */ +#define STMFTS5_EV_CONTROLLER_READY 0x03 +#define STMFTS5_EV_MULTI_TOUCH_ENTER 0x10 +#define STMFTS5_EV_MULTI_TOUCH_MOTION 0x20 +#define STMFTS5_EV_MULTI_TOUCH_LEAVE 0x30 +#define STMFTS5_EV_STATUS_UPDATE 0x40 +#define STMFTS5_EV_USER_REPORT 0x50 +#define STMFTS5_EV_DEBUG 0xe0 +#define STMFTS5_EV_ERROR 0xf0 + /* multi touch related event masks */ #define STMFTS_MASK_EVENT_ID 0x0f #define STMFTS_MASK_TOUCH_ID 0xf0 #define STMFTS_MASK_LEFT_EVENT 0x0f #define STMFTS_MASK_X_MSB 0x0f #define STMFTS_MASK_Y_LSB 0xf0 +#define STMFTS5_MASK_EVENT_ID 0xf0 +#define STMFTS5_MASK_TOUCH_TYPE 0x0f +#define STMFTS5_MASK_MAJOR_MSB 0x0c +#define STMFTS5_MASK_MINOR_MSB 0xc0 + +/* touch type classifications */ +#define STMFTS_TOUCH_TYPE_INVALID 0x00 +#define STMFTS_TOUCH_TYPE_FINGER 0x01 +#define STMFTS_TOUCH_TYPE_GLOVE 0x02 +#define STMFTS_TOUCH_TYPE_STYLUS 0x03 +#define STMFTS_TOUCH_TYPE_PALM 0x04 +#define STMFTS_TOUCH_TYPE_HOVER 0x05 =20 /* key related event masks */ #define STMFTS_MASK_KEY_NO_TOUCH 0x00 #define STMFTS_MASK_KEY_MENU 0x01 #define STMFTS_MASK_KEY_BACK 0x02 =20 #define STMFTS_RESET_TIMEOUT_MS 300 =20 @@ -73,19 +108,22 @@ #define STMFTS_DEV_NAME "stmfts" =20 static const struct regulator_bulk_data stmfts_supplies[] =3D { { .supply =3D "vdd" }, { .supply =3D "avdd" }, }; =20 struct stmfts_data { + const struct stmfts_chip_ops *ops; + struct i2c_client *client; struct input_dev *input; struct gpio_desc *reset_gpio; + struct gpio_desc *mode_switch_gpio; struct led_classdev led_cdev; struct mutex mutex; =20 struct touchscreen_properties prop; =20 struct regulator_bulk_data *supplies; =20 /* @@ -102,19 +140,29 @@ struct stmfts_data { =20 u8 data[STMFTS_DATA_MAX_SIZE]; =20 struct completion cmd_done; =20 bool use_key; bool led_status; bool hover_enabled; + bool stylus_enabled; bool running; }; =20 +struct stmfts_chip_ops { + int (*configure)(struct stmfts_data *sdata); + int (*setup_input)(struct stmfts_data *sdata); + void (*parse_events)(struct stmfts_data *sdata); + int (*set_scan)(struct stmfts_data *sdata, bool enable); + int (*set_hover)(struct stmfts_data *sdata, bool enable); + int (*runtime_resume)(struct stmfts_data *sdata); +}; + static int stmfts_brightness_set(struct led_classdev *led_cdev, enum led_brightness value) { struct stmfts_data *sdata =3D container_of(led_cdev, struct stmfts_data, led_cdev); int err; =20 if (value !=3D sdata->led_status && sdata->ledvdd) { @@ -167,16 +215,17 @@ static int stmfts_read_events(struct stmfts_data *sda= ta) =20 ret =3D i2c_transfer(sdata->client->adapter, msgs, ARRAY_SIZE(msgs)); if (ret < 0) return ret; =20 return ret =3D=3D ARRAY_SIZE(msgs) ? 0 : -EIO; } =20 +/* FTS4 event handling functions */ static void stmfts_report_contact_event(struct stmfts_data *sdata, const u8 event[]) { u8 slot_id =3D (event[0] & STMFTS_MASK_TOUCH_ID) >> 4; u16 x =3D event[1] | ((event[2] & STMFTS_MASK_X_MSB) << 8); u16 y =3D (event[2] >> 4) | (event[3] << 4); u8 maj =3D event[4]; u8 min =3D event[5]; @@ -202,16 +251,107 @@ static void stmfts_report_contact_release(struct stm= fts_data *sdata, u8 slot_id =3D (event[0] & STMFTS_MASK_TOUCH_ID) >> 4; =20 input_mt_slot(sdata->input, slot_id); input_mt_report_slot_inactive(sdata->input); =20 input_sync(sdata->input); } =20 +/* FTS5 event handling functions */ +static void stmfts5_report_contact_event(struct stmfts_data *sdata, + const u8 event[]) +{ + /* + * FTS5 touch event format: + * event[0] =3D event ID (high nibble) | major bits 5:4 (bits 3:2) + * event[1] =3D touch ID (high nibble) | touch type (low nibble) + * event[2] =3D X bits 7:0 + * event[3] =3D Y bits 3:0 (high nibble) | X bits 11:8 (low nibble) + * event[4] =3D Y bits 11:4 + * event[5] =3D pressure + * event[6] =3D major bits 3:0 (high nibble) | minor bits 3:0 (low nibble) + * event[7] =3D minor bits 5:4 (bits 7:6) + */ + u8 touch_id =3D (event[1] & STMFTS_MASK_TOUCH_ID) >> 4; + u8 touch_type =3D event[1] & STMFTS5_MASK_TOUCH_TYPE; + u16 x =3D ((event[3] & STMFTS_MASK_X_MSB) << 8) | event[2]; + u16 y =3D (event[4] << 4) | ((event[3] & STMFTS_MASK_Y_LSB) >> 4); + u8 area =3D event[5]; + u8 maj =3D ((event[0] & STMFTS5_MASK_MAJOR_MSB) << 2) | (event[6] >> 4); + u8 min =3D ((event[7] & STMFTS5_MASK_MINOR_MSB) >> 2) | (event[6] & 0x0f); + /* Distance is 0 for touching, max for hovering */ + int distance =3D 0; + unsigned int tool; + + switch (touch_type) { + case STMFTS_TOUCH_TYPE_STYLUS: + if (sdata->stylus_enabled) { + tool =3D MT_TOOL_PEN; + break; + } + fallthrough; /* Report as finger if stylus not enabled */ + + case STMFTS_TOUCH_TYPE_FINGER: + case STMFTS_TOUCH_TYPE_GLOVE: + tool =3D MT_TOOL_FINGER; + break; + + case STMFTS_TOUCH_TYPE_PALM: + /* Palm touch - report but can be filtered by userspace */ + tool =3D MT_TOOL_PALM; + break; + + case STMFTS_TOUCH_TYPE_HOVER: + tool =3D MT_TOOL_FINGER; + distance =3D 255; + break; + + case STMFTS_TOUCH_TYPE_INVALID: + default: + dev_warn(&sdata->client->dev, + "invalid touch type %d for slot %d\n", + touch_type, touch_id); + return; + } + + if (touch_type =3D=3D STMFTS_TOUCH_TYPE_HOVER) { + area =3D 0; + } else if (!area) { + /* + * Should not happen for contact events. Set minimum pressure + * to prevent touch from being dropped. + */ + dev_warn_once(&sdata->client->dev, + "zero pressure on contact event, slot %d\n", + touch_id); + area =3D 1; + } + + input_mt_slot(sdata->input, touch_id); + input_mt_report_slot_state(sdata->input, tool, true); + + input_report_abs(sdata->input, ABS_MT_POSITION_X, x); + input_report_abs(sdata->input, ABS_MT_POSITION_Y, y); + input_report_abs(sdata->input, ABS_MT_TOUCH_MAJOR, maj); + input_report_abs(sdata->input, ABS_MT_TOUCH_MINOR, min); + input_report_abs(sdata->input, ABS_MT_PRESSURE, area); + input_report_abs(sdata->input, ABS_MT_DISTANCE, distance); +} + +static void stmfts5_report_contact_release(struct stmfts_data *sdata, + const u8 event[]) +{ + /* format: touch ID is in high 4 bits of event[1] */ + u8 touch_id =3D (event[1] & STMFTS_MASK_TOUCH_ID) >> 4; + + input_mt_slot(sdata->input, touch_id); + input_mt_report_slot_inactive(sdata->input); +} + static void stmfts_report_hover_event(struct stmfts_data *sdata, const u8 event[]) { u16 x =3D (event[2] << 4) | (event[4] >> 4); u16 y =3D (event[3] << 4) | (event[4] & STMFTS_MASK_Y_LSB); u8 z =3D event[5]; =20 input_report_abs(sdata->input, ABS_X, x); @@ -294,29 +434,76 @@ static void stmfts_parse_events(struct stmfts_data *s= data) =20 default: dev_err(&sdata->client->dev, "unknown event %#02x\n", event[0]); } } } =20 +static void stmfts5_parse_events(struct stmfts_data *sdata) +{ + for (int i =3D 0; i < STMFTS_STACK_DEPTH; i++) { + u8 *event =3D &sdata->data[i * STMFTS_EVENT_SIZE]; + + switch (event[0]) { + case STMFTS5_EV_CONTROLLER_READY: + complete(&sdata->cmd_done); + fallthrough; + + case STMFTS_EV_NO_EVENT: + goto sync; + } + + switch (event[0] & STMFTS5_MASK_EVENT_ID) { + case STMFTS5_EV_STATUS_UPDATE: + case STMFTS5_EV_USER_REPORT: + case STMFTS5_EV_DEBUG: + goto sync; + + case STMFTS5_EV_MULTI_TOUCH_ENTER: + case STMFTS5_EV_MULTI_TOUCH_MOTION: + stmfts5_report_contact_event(sdata, event); + break; + + case STMFTS5_EV_MULTI_TOUCH_LEAVE: + stmfts5_report_contact_release(sdata, event); + break; + + case STMFTS5_EV_ERROR: + dev_warn(&sdata->client->dev, + "error code: 0x%x%x%x%x%x%x", + event[6], event[5], event[4], + event[3], event[2], event[1]); + break; + + default: + dev_err(&sdata->client->dev, + "unknown FTS5 event %#02x\n", event[0]); + } + } + +sync: + input_mt_sync_frame(sdata->input); + input_sync(sdata->input); +} + static irqreturn_t stmfts_irq_handler(int irq, void *dev) { struct stmfts_data *sdata =3D dev; int err; =20 guard(mutex)(&sdata->mutex); =20 err =3D stmfts_read_events(sdata); if (unlikely(err)) dev_err(&sdata->client->dev, "failed to read events: %d\n", err); else - stmfts_parse_events(sdata); + sdata->ops->parse_events(sdata); =20 return IRQ_HANDLED; } =20 static int stmfts_command(struct stmfts_data *sdata, const u8 cmd) { int err; =20 @@ -328,37 +515,64 @@ static int stmfts_command(struct stmfts_data *sdata, = const u8 cmd) =20 if (!wait_for_completion_timeout(&sdata->cmd_done, msecs_to_jiffies(1000))) return -ETIMEDOUT; =20 return 0; } =20 +static int stmfts_set_scan(struct stmfts_data *sdata, bool enable) +{ + return i2c_smbus_write_byte(sdata->client, + enable ? STMFTS_MS_MT_SENSE_ON : + STMFTS_MS_MT_SENSE_OFF); +} + +static int stmfts_set_hover(struct stmfts_data *sdata, bool enable) +{ + return i2c_smbus_write_byte(sdata->client, + enable ? STMFTS_SS_HOVER_SENSE_ON : + STMFTS_SS_HOVER_SENSE_OFF); +} + +static int stmfts5_set_scan(struct stmfts_data *sdata, bool enable) +{ + u8 scan_mode_cmd[3] =3D { STMFTS5_SET_SCAN_MODE, STMFTS5_SCAN_MODE_ACTIVE, + enable ? STMFTS5_SCAN_ACTIVE_MULTI_TOUCH : 0 }; + int err; + + err =3D i2c_master_send(sdata->client, scan_mode_cmd, + sizeof(scan_mode_cmd)); + if (err !=3D sizeof(scan_mode_cmd)) + return err < 0 ? err : -EIO; + + return 0; +} + static int stmfts_input_open(struct input_dev *dev) { struct stmfts_data *sdata =3D input_get_drvdata(dev); int err; =20 err =3D pm_runtime_resume_and_get(&sdata->client->dev); if (err) return err; =20 - err =3D i2c_smbus_write_byte(sdata->client, STMFTS_MS_MT_SENSE_ON); + err =3D sdata->ops->set_scan(sdata, true); if (err) { pm_runtime_put_sync(&sdata->client->dev); return err; } =20 scoped_guard(mutex, &sdata->mutex) { sdata->running =3D true; =20 - if (sdata->hover_enabled) { - err =3D i2c_smbus_write_byte(sdata->client, - STMFTS_SS_HOVER_SENSE_ON); + if (sdata->hover_enabled && sdata->ops->set_hover) { + err =3D sdata->ops->set_hover(sdata, true); if (err) dev_warn(&sdata->client->dev, "failed to enable hover\n"); } } =20 if (sdata->use_key) { err =3D i2c_smbus_write_byte(sdata->client, @@ -372,27 +586,26 @@ static int stmfts_input_open(struct input_dev *dev) return 0; } =20 static void stmfts_input_close(struct input_dev *dev) { struct stmfts_data *sdata =3D input_get_drvdata(dev); int err; =20 - err =3D i2c_smbus_write_byte(sdata->client, STMFTS_MS_MT_SENSE_OFF); + err =3D sdata->ops->set_scan(sdata, false); if (err) dev_warn(&sdata->client->dev, "failed to disable touchscreen: %d\n", err); =20 scoped_guard(mutex, &sdata->mutex) { sdata->running =3D false; =20 - if (sdata->hover_enabled) { - err =3D i2c_smbus_write_byte(sdata->client, - STMFTS_SS_HOVER_SENSE_OFF); + if (sdata->hover_enabled && sdata->ops->set_hover) { + err =3D sdata->ops->set_hover(sdata, false); if (err) dev_warn(&sdata->client->dev, "failed to disable hover: %d\n", err); } } =20 if (sdata->use_key) { err =3D i2c_smbus_write_byte(sdata->client, @@ -484,20 +697,18 @@ static ssize_t stmfts_sysfs_hover_enable_write(struct= device *dev, if (kstrtoul(buf, 0, &value)) return -EINVAL; =20 hover =3D !!value; =20 guard(mutex)(&sdata->mutex); =20 if (hover !=3D sdata->hover_enabled) { - if (sdata->running) { - err =3D i2c_smbus_write_byte(sdata->client, - value ? STMFTS_SS_HOVER_SENSE_ON : - STMFTS_SS_HOVER_SENSE_OFF); + if (sdata->running && sdata->ops->set_hover) { + err =3D sdata->ops->set_hover(sdata, hover); if (err) return err; } =20 sdata->hover_enabled =3D hover; } =20 return len; @@ -544,16 +755,20 @@ static int stmfts_read_system_info(struct stmfts_data= *sdata) =20 return 0; } =20 static int stmfts_configure(struct stmfts_data *sdata) { int err; =20 + err =3D stmfts_read_system_info(sdata); + if (err) + return err; + err =3D stmfts_command(sdata, STMFTS_SYSTEM_RESET); if (err) return err; =20 err =3D stmfts_command(sdata, STMFTS_SLEEP_OUT); if (err) return err; =20 @@ -616,21 +831,17 @@ static int stmfts_power_on(struct stmfts_data *sdata) * off or reset). Let's hope that this is enough time to * initialize. */ msleep(70); =20 enable_irq(sdata->client->irq); } =20 - err =3D stmfts_read_system_info(sdata); - if (err) - goto err_disable_irq; - - err =3D stmfts_configure(sdata); + err =3D sdata->ops->configure(sdata); if (err) goto err_disable_irq; =20 /* * At this point no one is using the touchscreen * and I don't really care about the return value */ (void)i2c_smbus_write_byte(sdata->client, STMFTS_SLEEP_IN); @@ -639,28 +850,87 @@ static int stmfts_power_on(struct stmfts_data *sdata) =20 err_disable_irq: disable_irq(sdata->client->irq); =20 regulator_bulk_disable(ARRAY_SIZE(stmfts_supplies), sdata->supplies); return err; } =20 +static int stmfts5_configure(struct stmfts_data *sdata) +{ + u8 event[STMFTS_EVENT_SIZE]; + int err; + + /* Verify I2C communication */ + err =3D i2c_smbus_read_i2c_block_data(sdata->client, + STMFTS_READ_ALL_EVENT, + sizeof(event), event); + if (err < 0) + return err; + + return 0; +} + static void stmfts_power_off(void *data) { struct stmfts_data *sdata =3D data; =20 disable_irq(sdata->client->irq); =20 if (sdata->reset_gpio) gpiod_set_value_cansleep(sdata->reset_gpio, 1); =20 regulator_bulk_disable(ARRAY_SIZE(stmfts_supplies), sdata->supplies); } =20 +static int stmfts_setup_input(struct stmfts_data *sdata) +{ + struct device *dev =3D &sdata->client->dev; + + input_set_abs_params(sdata->input, ABS_MT_ORIENTATION, 0, 255, 0, 0); + input_set_abs_params(sdata->input, ABS_DISTANCE, 0, 255, 0, 0); + input_set_abs_params(sdata->input, ABS_MT_TOOL_TYPE, 0, + MT_TOOL_PALM, 0, 0); + + sdata->use_key =3D device_property_read_bool(dev, "touch-key-connected"); + if (sdata->use_key) { + input_set_capability(sdata->input, EV_KEY, KEY_MENU); + input_set_capability(sdata->input, EV_KEY, KEY_BACK); + } + + return input_mt_init_slots(sdata->input, STMFTS_MAX_FINGERS, + INPUT_MT_DIRECT); +} + +static int stmfts5_setup_input(struct stmfts_data *sdata) +{ + struct device *dev =3D &sdata->client->dev; + + sdata->mode_switch_gpio =3D devm_gpiod_get_optional(dev, "mode-switch", + GPIOD_OUT_HIGH); + if (IS_ERR(sdata->mode_switch_gpio)) + return dev_err_probe(dev, PTR_ERR(sdata->mode_switch_gpio), + "Failed to get GPIO 'switch'\n"); + + /* Set resolution for accurate calibration */ + if (!input_abs_get_res(sdata->input, ABS_MT_POSITION_X)) { + input_abs_set_res(sdata->input, ABS_MT_POSITION_X, 10); + input_abs_set_res(sdata->input, ABS_MT_POSITION_Y, 10); + } + + input_set_abs_params(sdata->input, ABS_MT_DISTANCE, 0, 255, 0, 0); + + /* Enable stylus support if requested */ + sdata->stylus_enabled =3D device_property_read_bool(dev, "stylus-enabled"= ); + + return input_mt_init_slots(sdata->input, STMFTS_MAX_FINGERS, + INPUT_MT_DIRECT); +} + static int stmfts_enable_led(struct stmfts_data *sdata) { int err; =20 /* get the regulator for powering the leds on */ sdata->ledvdd =3D devm_regulator_get(&sdata->client->dev, "ledvdd"); if (IS_ERR(sdata->ledvdd)) return PTR_ERR(sdata->ledvdd); @@ -696,16 +966,18 @@ static int stmfts_probe(struct i2c_client *client) return -ENOMEM; =20 i2c_set_clientdata(client, sdata); =20 sdata->client =3D client; mutex_init(&sdata->mutex); init_completion(&sdata->cmd_done); =20 + sdata->ops =3D i2c_get_match_data(client); + err =3D devm_regulator_bulk_get_const(dev, ARRAY_SIZE(stmfts_supplies), stmfts_supplies, &sdata->supplies); if (err) return err; =20 sdata->reset_gpio =3D devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIG= H); @@ -723,28 +995,19 @@ static int stmfts_probe(struct i2c_client *client) sdata->input->close =3D stmfts_input_close; =20 input_set_capability(sdata->input, EV_ABS, ABS_MT_POSITION_X); input_set_capability(sdata->input, EV_ABS, ABS_MT_POSITION_Y); touchscreen_parse_properties(sdata->input, true, &sdata->prop); =20 input_set_abs_params(sdata->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0); input_set_abs_params(sdata->input, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0); - input_set_abs_params(sdata->input, ABS_MT_ORIENTATION, 0, 255, 0, 0); input_set_abs_params(sdata->input, ABS_MT_PRESSURE, 0, 255, 0, 0); - input_set_abs_params(sdata->input, ABS_DISTANCE, 0, 255, 0, 0); =20 - sdata->use_key =3D device_property_read_bool(dev, "touch-key-connected"); - if (sdata->use_key) { - input_set_capability(sdata->input, EV_KEY, KEY_MENU); - input_set_capability(sdata->input, EV_KEY, KEY_BACK); - } - - err =3D input_mt_init_slots(sdata->input, - STMFTS_MAX_FINGERS, INPUT_MT_DIRECT); + err =3D sdata->ops->setup_input(sdata); if (err) return err; =20 input_set_drvdata(sdata->input, sdata); =20 /* * stmfts_power_on expects interrupt to be disabled, but * at this point the device is still off and I do not trust @@ -805,27 +1068,71 @@ static int stmfts_runtime_suspend(struct device *dev) =20 ret =3D i2c_smbus_write_byte(sdata->client, STMFTS_SLEEP_IN); if (ret) dev_warn(dev, "failed to suspend device: %d\n", ret); =20 return ret; } =20 +static int stmfts_chip_runtime_resume(struct stmfts_data *sdata) +{ + return i2c_smbus_write_byte(sdata->client, STMFTS_SLEEP_OUT); +} + +static int stmfts5_chip_runtime_resume(struct stmfts_data *sdata) +{ + struct i2c_client *client =3D sdata->client; + struct device *dev =3D &client->dev; + u8 int_enable_cmd[4] =3D { 0xB6, 0x00, 0x2C, 0x01 }; + int err; + + err =3D i2c_smbus_write_byte(client, STMFTS_SLEEP_OUT); + if (err) + return err; + + msleep(20); + + /* Perform capacitance tuning after wakeup */ + err =3D i2c_smbus_write_byte(client, STMFTS_MS_CX_TUNING); + if (err) + dev_warn(dev, "MS_CX_TUNING failed: %d\n", err); + msleep(20); + + err =3D i2c_smbus_write_byte(client, STMFTS_SS_CX_TUNING); + if (err) + dev_warn(dev, "SS_CX_TUNING failed: %d\n", err); + msleep(20); + + /* Force calibration */ + err =3D i2c_smbus_write_byte(client, STMFTS_FULL_FORCE_CALIBRATION); + if (err) + dev_warn(dev, "FORCE_CALIBRATION failed: %d\n", err); + msleep(50); + + /* Enable controller interrupts */ + err =3D i2c_master_send(client, int_enable_cmd, sizeof(int_enable_cmd)); + if (err !=3D sizeof(int_enable_cmd)) + return err < 0 ? err : -EIO; + + msleep(20); + + return 0; +} + static int stmfts_runtime_resume(struct device *dev) { struct stmfts_data *sdata =3D dev_get_drvdata(dev); - struct i2c_client *client =3D sdata->client; - int ret; + int err; =20 - ret =3D i2c_smbus_write_byte(client, STMFTS_SLEEP_OUT); - if (ret) - dev_err(dev, "failed to resume device: %d\n", ret); + err =3D sdata->ops->runtime_resume(sdata); + if (err) + dev_err(dev, "failed to resume device: %d\n", err); =20 - return ret; + return err; } =20 static int stmfts_suspend(struct device *dev) { struct stmfts_data *sdata =3D dev_get_drvdata(dev); =20 stmfts_power_off(sdata); =20 @@ -839,26 +1146,45 @@ static int stmfts_resume(struct device *dev) return stmfts_power_on(sdata); } =20 static const struct dev_pm_ops stmfts_pm_ops =3D { SYSTEM_SLEEP_PM_OPS(stmfts_suspend, stmfts_resume) RUNTIME_PM_OPS(stmfts_runtime_suspend, stmfts_runtime_resume, NULL) }; =20 +static const struct stmfts_chip_ops stmfts4_ops =3D { + .configure =3D stmfts_configure, + .setup_input =3D stmfts_setup_input, + .parse_events =3D stmfts_parse_events, + .set_scan =3D stmfts_set_scan, + .set_hover =3D stmfts_set_hover, + .runtime_resume =3D stmfts_chip_runtime_resume, +}; + +static const struct stmfts_chip_ops stmfts5_ops =3D { + .configure =3D stmfts5_configure, + .setup_input =3D stmfts5_setup_input, + .parse_events =3D stmfts5_parse_events, + .set_scan =3D stmfts5_set_scan, + .runtime_resume =3D stmfts5_chip_runtime_resume, +}; + #ifdef CONFIG_OF static const struct of_device_id stmfts_of_match[] =3D { - { .compatible =3D "st,stmfts", }, + { .compatible =3D "st,stmfts", .data =3D &stmfts4_ops }, + { .compatible =3D "st,stmfts5", .data =3D &stmfts5_ops }, { }, }; MODULE_DEVICE_TABLE(of, stmfts_of_match); #endif =20 static const struct i2c_device_id stmfts_id[] =3D { - { .name =3D "stmfts" }, + { .name =3D "stmfts", .driver_data =3D (kernel_ulong_t)&stmfts4_ops }, + { .name =3D "stmfts5", .driver_data =3D (kernel_ulong_t)&stmfts5_ops }, { } }; MODULE_DEVICE_TABLE(i2c, stmfts_id); =20 static struct i2c_driver stmfts_driver =3D { .driver =3D { .name =3D STMFTS_DEV_NAME, .dev_groups =3D stmfts_sysfs_groups, @@ -869,10 +1195,12 @@ static struct i2c_driver stmfts_driver =3D { .probe =3D stmfts_probe, .remove =3D stmfts_remove, .id_table =3D stmfts_id, }; =20 module_i2c_driver(stmfts_driver); =20 MODULE_AUTHOR("Andi Shyti "); +MODULE_AUTHOR("David Heidelberg "); +MODULE_AUTHOR("Petr Hodina "); MODULE_DESCRIPTION("STMicroelectronics FTS Touch Screen"); MODULE_LICENSE("GPL"); --=20 2.55.0 From nobody Fri Sep 25 23:51:06 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 281C74FC8D7; Fri, 25 Sep 2026 21:22:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790371343; cv=none; b=ZkeXEIrbuLBtQxeenk2y4zbO90Kfx79Uz8GN71KyeyqJuelhZ57swMxdR5e7dmGK4Nm0XAiZGLZ4XeEbSN1DNCTOfCzw6mGJeQ757XyurCWWJVmxc6BKVUt2Wy4dFXjqoZ6ijxYirYyHno4YqETPuPXsMolIsRNG7K1wnVfv52w= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790371343; c=relaxed/simple; bh=i5zkR8i/qyOP6qT5kYypP8zr4dfV4rLPl/6fLtdUfIU=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=MXrY7fBdgfUWlZHnSsnN07UmrSv+49/ZcOP0VEiCI1luPg9gS8dY3iUv1uB7icIkd2V/sw/ZIwmeaSl7LyuRMC3a9mBz4p5fZgaihmj+Gb4nVVY8ikRirp79WFLE0IwU9kpMr+wekawu19y6mDST4FMK91ACaJCNhKyxAHMjZqc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=TH6EtPQ0; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="TH6EtPQ0" Received: by smtp.kernel.org (Postfix) with ESMTPS id DA1ADC2BCFD; Fri, 25 Sep 2026 21:22:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1790371342; bh=i5zkR8i/qyOP6qT5kYypP8zr4dfV4rLPl/6fLtdUfIU=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=TH6EtPQ0tRs424TqcjGYt5eBzku+Rwc59zJ15tVWOc5T9hkUx+hH7I6DrlsoqN80Z 6FXu5OWkipnWap7iOAyKGxKQuQrfGVRT38TlibwnCRTUe5KuYY7SC2JlRIaxfmFDx/ sfJ05rPmGpxs2ptJdJ+FnXb8MU2T7DtNMazu0iEFoG0m6VfrgV5B2rda/0SfG2usDP 0JGQIASKVb8HHlNHCpcOE+dGdpJZFhR58Q18mIcAzQLjPzZWooh+uHDr/jJm5mX/hY yJvdhhAR5Shc8gKOJq+SmpyBGeyFw2rfjKesVlq8AJdhFqp5MzxiiZ6uxaysSCFsvL KxjjpqdZO9eNg== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id C68CAC98330; Fri, 25 Sep 2026 21:22:22 +0000 (UTC) From: David Heidelberg via B4 Relay Date: Fri, 25 Sep 2026 23:22:23 +0200 Subject: [PATCH v8 5/5] arm64: dts: qcom: sdm845-google: Add STM FTS touchscreen support Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260925-stmfts5-v8-5-0fcf49e2c85f@ixit.cz> References: <20260925-stmfts5-v8-0-0fcf49e2c85f@ixit.cz> In-Reply-To: <20260925-stmfts5-v8-0-0fcf49e2c85f@ixit.cz> To: Dmitry Torokhov , Maxime Coquelin , Alexandre Torgue , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Henrik Rydberg , Bjorn Andersson , Konrad Dybcio Cc: Petr Hodina , linux-input@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Krzysztof Kozlowski , devicetree@vger.kernel.org, linux-arm-msm@vger.kernel.org, phone-devel@vger.kernel.org, David Heidelberg , Konrad Dybcio , Dmitry Baryshkov , Abel Vesa X-Mailer: b4 0.16.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=2339; i=david@ixit.cz; h=from:subject:message-id; bh=uByqGmdgQrcbmESUA0mr/va47Uf9HHtA6cjJdf5std0=; b=owEBbQKS/ZANAwAIAWACP8TTSSByAcsmYgBqtuYMtuSAMZngZy19YCnOrmZ2QrkIiPZUKVdob v+EV9XZgeaJAjMEAAEIAB0WIQTXegnP7twrvVOnBHRgAj/E00kgcgUCarbmDAAKCRBgAj/E00kg ciWRD/4rOU0tR8/3StLODI1Ciqe6j7mo43XwWt5DDIunIagZE0HuwAxILx+Zi3wpm1hYzPW6c92 0VqthbFCm7F8edtttgnZ4MaEgJ+DOqBxd0/4v+k3Kb1GMJVwztdoF6WBBk2Gmq1jAqSz3el/hyW /HhBVa7O3SxhSZmiSYs9A76e6+StgDfbA6EGArgW9dgQSs90nzXiXcXZsbM65LcH5+TKrppQFLj 0KHP5VUaWGMjW++CeZmfXArhKqz/SZbtAldBikIwZZwWdjEGY4f4avqiGKBr+HNfKyv23AYpV3B MEsiE4R3Gb2AYopull/wuFNotXIdkpS71S21VogyE75ADHAYMq1ROPoKVMLHm88B/ozQdpJQqpr Q+OfvsxY0tamEWYgi7wx7L4lbsBuWH91I3vZMC6yAmsyISraP8TIGxJjDLgAzJW9TC9enBrP1PI C8NvNaxag63ehjVfOUIqrhY0fixXBzNZ2xpxTeB+6dlHFO1/V5gpuqc4WzL08YYhHiuUbHpW3Hf 5AWx2yOocdMDjfOyaR5/PiSamZe1k0P5VFSp94j5u77Y4rA5bMYNrI6P/aT4NYUyLT9I/Zv1CiD U0yxdU57THR1xeZ8nd9kWuBckhcqKkFuqih30SJEDJCwDkX3olBExeXi4/1L8ivRf+uTWWXwFJp rpDm8eZDL1KRNrw== X-Developer-Key: i=david@ixit.cz; a=openpgp; fpr=D77A09CFEEDC2BBD53A7047460023FC4D3492072 X-Endpoint-Received: by B4 Relay for david@ixit.cz/default with auth_id=355 X-Original-From: David Heidelberg Reply-To: david@ixit.cz From: Petr Hodina Basic touchscreen connected to second i2c bus. Signed-off-by: Petr Hodina Reviewed-by: Konrad Dybcio Reviewed-by: Dmitry Baryshkov Reviewed-by: Abel Vesa Co-developed-by: David Heidelberg Signed-off-by: David Heidelberg --- arch/arm64/boot/dts/qcom/sdm845-google-blueline.dts | 19 +++++++++++++++++= +- arch/arm64/boot/dts/qcom/sdm845-google-common.dtsi | 2 +- 2 files changed, 19 insertions(+), 2 deletions(-) diff --git a/arch/arm64/boot/dts/qcom/sdm845-google-blueline.dts b/arch/arm= 64/boot/dts/qcom/sdm845-google-blueline.dts index fa89be500fb85..51c835dca43f1 100644 --- a/arch/arm64/boot/dts/qcom/sdm845-google-blueline.dts +++ b/arch/arm64/boot/dts/qcom/sdm845-google-blueline.dts @@ -21,17 +21,34 @@ &framebuffer0 { stride =3D <(1080 * 4)>; }; =20 &i2c2 { clock-frequency =3D <1000000>; =20 status =3D "okay"; =20 - /* ST,FTS @ 49 */ + touchscreen@49 { + compatible =3D "st,stmfts5"; + reg =3D <0x49>; + + pinctrl-0 =3D <&touchscreen_irq_n>, <&touchscreen_reset>; + pinctrl-names =3D "default"; + + interrupts-extended =3D <&tlmm 125 IRQ_TYPE_LEVEL_LOW>; + + mode-switch-gpios =3D <&tlmm 136 GPIO_ACTIVE_HIGH>; + reset-gpios =3D <&tlmm 99 GPIO_ACTIVE_LOW>; + + avdd-supply =3D <&vreg_l19a_3p3>; + vdd-supply =3D <&vreg_l14a_1p8>; + + touchscreen-size-x =3D <1080>; + touchscreen-size-y =3D <2160>; + }; }; =20 &mdss_dsi0 { vdda-supply =3D <&vdda_mipi_dsi0_1p2>; =20 status =3D "okay"; =20 panel@0 { diff --git a/arch/arm64/boot/dts/qcom/sdm845-google-common.dtsi b/arch/arm6= 4/boot/dts/qcom/sdm845-google-common.dtsi index f1379857e2742..6ae1973aa8ac7 100644 --- a/arch/arm64/boot/dts/qcom/sdm845-google-common.dtsi +++ b/arch/arm64/boot/dts/qcom/sdm845-google-common.dtsi @@ -504,17 +504,17 @@ firmware-pins { =20 touchscreen_reset: ts-reset-state { pins =3D "gpio99"; function =3D "gpio"; drive-strength =3D <8>; bias-pull-up; }; =20 - touchscreen_pins: ts-pins-gpio-state { + touchscreen_irq_n: ts-irq-n-gpio-state { pins =3D "gpio125"; function =3D "gpio"; drive-strength =3D <2>; bias-disable; }; =20 touchscreen_i2c_pins: qup-i2c2-gpio-state { pins =3D "gpio27", "gpio28"; --=20 2.55.0