From nobody Sat Sep 26 01:07:59 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 8A58518C02E; Sun, 6 Sep 2026 16:33:54 +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=1788712434; cv=none; b=kXQ1hdQcwlzNgf/Wcn0ipRRwvbRGC8WY/Rl7B80Np6f/+fcMVO+v5dG3WIEwDaPyV06jAcr4xv54Jm2LApN8PBEx18Yo9JgE58TJOiWW8CM0bwJ0EysxyMdkqD4StUrxoJb1cOUZbZg9UjTsfqcKITczbiBA5Qb9S4PQoGfAP1Y= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788712434; c=relaxed/simple; bh=NnOq+xRUSpOQqEwshprztuziPWpVBsyCAlS5zdxPx2U=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=DZAiEaj67w/AD5oLWkGfGgFsITGyosL/aKIvqShKb9WE0Nktkz0SLgCykIaMpm6576FYyCjKjIwgyM1H6TggImZeWChkSEp5Bzbj1X3K0nnO2syHHYBGbDi7eh9Vf1DL0sp65aUOUlW2l8fAndJuqZeb/pxXBkpyLwgLy92z07c= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Bnl8zsL/; 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="Bnl8zsL/" Received: by smtp.kernel.org (Postfix) with ESMTPS id 2F3A1C2BCFB; Sun, 6 Sep 2026 16:33:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1788712434; bh=NnOq+xRUSpOQqEwshprztuziPWpVBsyCAlS5zdxPx2U=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=Bnl8zsL/JyT/dgcCAq8LTdnrWW1o2J3TusKDfzsmt8x6BIgBFDjiKHEX9udLTrt3Z 0NulHgLX9seBNcpW5jAZoo7BjgDvFPjz8yCNeflKhAuzZNdy3dAqV16DA283RTVr8+ 2ra8ZyBtXgweRj4tfWL6vjn5B8h3T5th610XlillOnPQ/VMhpaUHkcsd2HZv5BG2qJ n+cvAM2gwy/DYeQpPG6hpXpntgKIYjSwg/hjDCf9eXA4U84qz8QWjjR1wYMsVddvpk 7fJAjqITAxjvCpnynVeYs9zY3+JowlAniKBmk6Nb2RA30RCg14t0qSO1WZV7VMI49w UozsEVCQ8yZWg== 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 0F754C79F8C; Sun, 6 Sep 2026 16:33:54 +0000 (UTC) From: David Heidelberg via B4 Relay Date: Sun, 06 Sep 2026 18:33:49 +0200 Subject: [PATCH v6 1/3] 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: <20260906-stmfts5-v6-1-50fbf6af8718@ixit.cz> References: <20260906-stmfts5-v6-0-50fbf6af8718@ixit.cz> In-Reply-To: <20260906-stmfts5-v6-0-50fbf6af8718@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=2705; i=david@ixit.cz; h=from:subject:message-id; bh=pbzOh5CHeD/4F3W1fha7bB0ZUX+yDlqPPUvexzr6fCU=; b=owEBbQKS/ZANAwAIAWACP8TTSSByAcsmYgBqnZXwUAH+eKJkEZ1gLvyh6j1bO8MilyV+1mlSi jqW94afWTKJAjMEAAEIAB0WIQTXegnP7twrvVOnBHRgAj/E00kgcgUCap2V8AAKCRBgAj/E00kg cjbBD/wPVJGY3JAGm5ebpcqA9d684JGdvBJdssDoNdmrCAMzePqjUYW8aQ/QPphJIBvA0izatL0 kcsZ0R2O2cKTzTh67UPJRzDfFaaEst0DAPgJCUqgBEJhKJYhss2CEoBAw4W+BRAID9pSUlsMF3w UNEqhgeISyabwcD34X0zkWpnEueat04hV1NzSOSXfrdwevFr/H+bfgxs+fmcXjI3wfnQaPwo4Tw uQfsbpHD1VPay2Z6q6ySoQSRCSRGsft8bvREW8aDYAN1vM4MhA9wvV6fNDHmOheUgGOdUtpHDue boadbhrEOQiq4m0oNMZV+/2UOt+9cABQVhIMM855QbHdGKB4FNxrkWMZ1GrRh9D8LhB/WAjI0E0 4t6a1A3G2S6VZfcgfWAbxf0xijIyO1N7LOPGVXc3CeGPuKJLr6Ql2KYvCq/DKG0B61BohGbz05Z Zdbx2fmYrPSg1fFwihVr8Uz1XsoOj2gpInbITn4zYTiZ1MT+3t+8MVDaJME6Xi5fHItTGXMNvvH UL8CfHl0hX6IZrwQQ7rlLgW3mlQ/ols6FXsg65z3VIZsmUvhgGQJQUqpqzMMl3TjSxeXQfjEMZK wChMhWRpXIO+UPO9hth8JmppjiDjmf+uDyCNPGAEUNgIiZfxpo/E9JUFajxacfH3AEKKU28CgZQ zQWs7SeVTnMrUvA== 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 | 29 ++++++++++++++++--= ---- 1 file changed, 21 insertions(+), 8 deletions(-) diff --git a/Documentation/devicetree/bindings/input/touchscreen/st,stmfts.= yaml b/Documentation/devicetree/bindings/input/touchscreen/st,stmfts.yaml index 64c4f24ea3dd0..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,42 +34,56 @@ 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>; #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 Sat Sep 26 01:07:59 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 8ADD2305E1F; Sun, 6 Sep 2026 16:33:54 +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=1788712434; cv=none; b=I0yse4icIo6NUnz1DSkJvcIC4X5a4dQtU7jnfmkq5V5oH+9wj6MzUaC1V6QAWF0vuquc4Z+fw64RboMvf4mOhbxVBVFS6qggJQU1bxkEB3021RdNy6Tp5IHVQLeA1Jf6XMNdtUPYQ05EQOi5BCx7vqyESDVYpNotQwHi1TqinII= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788712434; c=relaxed/simple; bh=jhslZg7q8W0ReJftY9R+hsMa6zJHhRwubmZHbSMssuY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=HMNe0YXBuSN6KoY7pcA7y7vMUTU664QuGTRerBvYenaFX4w2n3AQfl1G4117kt7xnz6Xh31ZHi/3RKNqUZ6uZY7NRjnNmxDnZxEOAFAEPqA2b6LJOZzn1DmCmtVAjoclfOiaaeSmHtLxrKiCz+RouBV3/naW4TSyyC3huvGubVs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=oVSbSaGh; 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="oVSbSaGh" Received: by smtp.kernel.org (Postfix) with ESMTPS id 43B82C2BCFD; Sun, 6 Sep 2026 16:33:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1788712434; bh=jhslZg7q8W0ReJftY9R+hsMa6zJHhRwubmZHbSMssuY=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=oVSbSaGhT31vjPDFgVWdSjRw6WQeWzt9W9UpTKf2JVovRVVVLn5Pkr55FVzNbcBHA Vzr5ZLfnK49pRhO+YJ0ykz3joyHEtk8YGtA9SaFyhB0mJQJdWbXgjbK4YKQBu+pvIR sI/1ECncKPimod3x+2qOyWJj7XH4wlNKAcyyEU7ahpW399hYlSQd9smBswQU30J1xC VNk0b/BCyWNvr+k9jn2k1alRFDi/CDq2YlZMfYT6fOMJhI668wIEulgUCzoGp7s6p0 ihvHeev6lSJfqylryDxPvvt6ZPKkVZ0YIZLOruD3wUspIQdfUxKzV3b/T+dWSB0tsI Cw2PELQw3KqPQ== 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 24D5DC79FA0; Sun, 6 Sep 2026 16:33:54 +0000 (UTC) From: David Heidelberg via B4 Relay Date: Sun, 06 Sep 2026 18:33:50 +0200 Subject: [PATCH v6 2/3] 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: <20260906-stmfts5-v6-2-50fbf6af8718@ixit.cz> References: <20260906-stmfts5-v6-0-50fbf6af8718@ixit.cz> In-Reply-To: <20260906-stmfts5-v6-0-50fbf6af8718@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=24295; i=david@ixit.cz; h=from:subject:message-id; bh=KcKIJB0ZVwltFTf86KDa+flJN8svWe3RWzfwcxy3St8=; b=owEBbQKS/ZANAwAIAWACP8TTSSByAcsmYgBqnZXw5Hfe9gXnmD5ckcR5n+Q1F9uzEyCzpeOsn +up+zWbxsKJAjMEAAEIAB0WIQTXegnP7twrvVOnBHRgAj/E00kgcgUCap2V8AAKCRBgAj/E00kg cqZhD/9bYSZLuDSsks31lzNLKMK2LARGVP1PoqiHD4AEr47RekIH9S0aiNH06todn6uOqZvbDrB 85EHbs1e2NAT220C9oBUoNSazRh5MHEhPlBF+ZgjGIlbJo1EtLv/8Q0D4zaQ5i7/1+L/21CZH9n 7NdE2+RVqB89J7bSIgUAz3w1pjiJME/5NDX8iuHzGziWek13TXC5NmP8mntW4JKOIKlA0v8RPqO lu6HftKbDhY0UKlc6H76O/unt+3vq9kH9mKHwF4b1SMRWlpdz+Ihq2w+Ig5KdZZTdqCarSfL220 YBffwCXbUtqKVoCwc/cs8Z75HNuGm1+AZj0oLKU/ZG3BXfplImC5jjuX/tczbc318H1EKl0RuED PF4kO4nMcYfcUq8NbdLs/u2oB4AY4/SuNGWDDwktznkE8g0lKU9/P4AkuQyDfqqmLGQdv9Uckv1 fbxRPIMVJww/88hw/j1zU0aIfgvfJ8ojUiiGg8gxDZTrYtP8i2GVnPdXzaepVxaqHLDL4z/CIxn mVYRKgpgSUSb1+YRAtM4TKf7sJraoADKscBuj9/IdliLeEIL6T3OhRqJVKX091jHOZhSGGbdeEi U59sb2HRNyVEX6qj76sea3PXQmiafLEAGEy+7/u1ks1F1R/rlXBaN0BcxqgbcpeQ/Jia/e//V7p Imggc55zENfvpoQ== 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 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 | 407 +++++++++++++++++++++++++++++++++= ---- 1 file changed, 366 insertions(+), 41 deletions(-) diff --git a/drivers/input/touchscreen/stmfts.c b/drivers/input/touchscreen= /stmfts.c index 972687797f826..019945f64c48b 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_EVENT_SIZE 8 #define STMFTS_STACK_DEPTH 32 @@ -71,19 +106,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 /* @@ -100,19 +138,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) { @@ -165,16 +213,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]; @@ -200,16 +249,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[]) +{ + /* FTM5 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); @@ -292,29 +432,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 @@ -326,37 +513,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, @@ -370,27 +584,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, @@ -482,20 +695,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; @@ -551,16 +762,20 @@ static void stmfts_reset(struct stmfts_data *sdata) gpiod_set_value_cansleep(sdata->reset_gpio, 0); msleep(50); } =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 @@ -596,55 +811,107 @@ static int stmfts_power_on(struct stmfts_data *sdata) * 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); =20 if (sdata->reset_gpio) stmfts_reset(sdata); =20 - err =3D stmfts_read_system_info(sdata); - if (err) - goto err_disable_regulators; - enable_irq(sdata->client->irq); =20 msleep(50); =20 - 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); =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 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); + + 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); @@ -680,16 +947,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); @@ -707,28 +976,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); - - 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); - } =20 - 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 @@ -789,27 +1049,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 @@ -823,26 +1127,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, @@ -853,10 +1176,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 Sat Sep 26 01:07:59 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 96F3630EF97; Sun, 6 Sep 2026 16:33:54 +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=1788712434; cv=none; b=ccMdbKCAzLzvsq+QNVWavSiPlXe67+E28a/C3SxnhOUWAAGA30nPcU0nYk0xzXe6At0BTWwEyFOpM9rdjG78D4Tu7ZbODXMN2VJ2j4fKiM/OwuFD7gK8reavwZMvI5seZX+gGELSvtHa+Ujt7aMqYoi/jvY1o6ZYxie7DRcFXto= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788712434; c=relaxed/simple; bh=GTKCuKerEVjbEq+ru51jw6Xl/RomTGKgH6W2wG3Nmm8=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=oCC+Wcm8J18W1mDQxkZtoUUmbwUZ2UGm3impPZNthL8iSsDtcxG/gq0dq+gK55to9cF+xxCtsvIeP8uS7ofarsLeTthj/JJ2koAOtKntWrdr9T2q2CD7+hyMByCQobSbNEP3POlGA23ITgAuUb2CcOnHmrGnSub0CcMqZvz6t1s= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ZoQ3oFPw; 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="ZoQ3oFPw" Received: by smtp.kernel.org (Postfix) with ESMTPS id 5044CC2BD00; Sun, 6 Sep 2026 16:33:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1788712434; bh=GTKCuKerEVjbEq+ru51jw6Xl/RomTGKgH6W2wG3Nmm8=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=ZoQ3oFPwoNw9uiHW4BQLLbE0rsLeOl+zQrlsWmeTLmFUmw5bTA5YftJ7/wmZkATZ0 +3Eblv5JM3tmGohRuKIUizIiW2ezU2SBilw6UF8u6JC0UjWtJzsl3fm08mWvcQL8m2 HH4VTacIb/JQjMh2o3/9Ps4e4ex6+hgMLaIzNXIBOBsmWPz5kolfMyRByQJBzQ0S72 4x546Q70u51aIdYefGVpNanY7QF6oUkb8xcCnoTILbiQ7WvmFKk8dOCVBn8AL3hRfb 1YljXUEWNOE1VV2plxetkZ4Kr1VaPj9Zv2RuG3GX5dI1CzlkmBmOOHSG/bd37Eg27K Jd1zZH/X1rDyg== 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 36C51C79F85; Sun, 6 Sep 2026 16:33:54 +0000 (UTC) From: David Heidelberg via B4 Relay Date: Sun, 06 Sep 2026 18:33:51 +0200 Subject: [PATCH v6 3/3] 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: <20260906-stmfts5-v6-3-50fbf6af8718@ixit.cz> References: <20260906-stmfts5-v6-0-50fbf6af8718@ixit.cz> In-Reply-To: <20260906-stmfts5-v6-0-50fbf6af8718@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 X-Mailer: b4 0.16.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=2317; i=david@ixit.cz; h=from:subject:message-id; bh=UYybbePhFZQL67dBaI7ZZMSBOFWG/ciE0qllsHbgzEk=; b=owEBbQKS/ZANAwAIAWACP8TTSSByAcsmYgBqnZXweyV+w1DXqt1mMsyGPwwNYULoSaJ+5XDXl CX8VS1RRnGJAjMEAAEIAB0WIQTXegnP7twrvVOnBHRgAj/E00kgcgUCap2V8AAKCRBgAj/E00kg cpbAD/4+PL3GBlMtZ7FWZ6NoUDM1965ux0TqDTVHiZv91Sn09Lfqy5NPwLsgc6dqt6JeE+fJeRP LsJPNGteE0kWPSAUYJ0cYsz76ikj3NLYY7x1oQgSp/ASmFlw455D7GNY4Aae/ifQoBA4EivZA4r ecKs6GlKv1xvYhCQxH6DN6ILzIrn6IfhRAAWJ3ROJzyj4xwGh9Jw5kTenCqE9KPma7Qj6D6MLim ZAaLBZg8hYEpFVE3N5iNyDkRFZF70fOcQ3azh05Q1EbOoL5L+1yx9ZXPOmKHt70LnkDb/GlK3in WzjITu4HA9hcKRMEC63JiHdIQikf+1mDlBgutJ+MKqrMldLZMlxJa3pmTNL+dULO2+vZz84Iozu qfTX38VRKYpScCUH6kdugXYZ/3g/5dU81fTEkhNiV/9cGwukoX37K923zBL/RUf5UqbdfEXvSRL lLYP4oT9Y8Jn6xnpAN7vcclCH5ZtuCpQwbqHQbIPo/6SD+mnl2IdT76JpviKzmMMjPTIBvgCAC7 wWYzxK0rw6sNTGMOWRrhZoGY0p2pqYl9zbqUR2Pbha94ICczVNxXdKrkFq6WcRk3vrexqi7TZv/ dC8nZ4CYwvy4m5etjLAmmJLWH/XqmsOLuUdUfbOUj22VgN6y/chZUchbRs8XO1HcWIRlxwRgAg7 qYGgCrzDVyhH4IA== 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 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 9e952f9862f24..c9db3ea50f5ed 100644 --- a/arch/arm64/boot/dts/qcom/sdm845-google-common.dtsi +++ b/arch/arm64/boot/dts/qcom/sdm845-google-common.dtsi @@ -492,17 +492,17 @@ nfc_enable_default: nfc-enable-default-state { =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