From nobody Fri Dec 19 13:09:42 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id A7F2FC4167B for ; Mon, 11 Dec 2023 12:14:47 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234832AbjLKMOj (ORCPT ); Mon, 11 Dec 2023 07:14:39 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60474 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234790AbjLKMOh (ORCPT ); Mon, 11 Dec 2023 07:14:37 -0500 Received: from relay8-d.mail.gandi.net (relay8-d.mail.gandi.net [IPv6:2001:4b98:dc4:8::228]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CAAA8D5; Mon, 11 Dec 2023 04:14:42 -0800 (PST) Received: by mail.gandi.net (Postfix) with ESMTPSA id 51D461BF204; Mon, 11 Dec 2023 12:14:40 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1702296881; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=PyU0MrPkAquO0yDvZ3LG19USjtRAx9Zi0FGDGYHw/pQ=; b=XNJ4ic/305M6+X+lKQnyuEWHW9sv0O3tlNi1Fl2mff859EFMspqQe1X8fJmcrcTIvsuFPd 1OFj6e9wErqMZuUBHRAA8Lwj17meEPSlkJE80aHnhS1j+ivxdgiZetReOxviqNFFra0VyZ 0f96UiHbLVxM53dVaQSIR/9YCpzJmhzUlN8Wpy6udLvGz8JsFWoONtK7TNYEenMP6xRdu2 04pCZd/m7mwJU6lfsBLewF1r5D9sNIs+xeKRIW3/hKPUoTmWwzVpZ2oNiq7aphNhe8F7W9 0CKcIn+enSCMga8N1jjbtbS5ldgPNx1iy7x2bM49PH0lOOVHKxlEoS11OzU5Ww== From: Kamel Bouhara To: Dmitry Torokhov , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Henrik Rydberg , linux-input@vger.kernel.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, Marco Felsch , Jeff LaBundy Cc: catalin.popescu@leica-geosystems.com, mark.satterthwaite@touchnetix.com, bartp@baasheep.co.uk, hannah.rossiter@touchnetix.com, Thomas Petazzoni , Gregory Clement , bsp-development.geo@leica-geosystems.com, Kamel Bouhara , Krzysztof Kozlowski Subject: [PATCH v5 1/3] dt-bindings: vendor-prefixes: Add TouchNetix AS Date: Mon, 11 Dec 2023 13:14:27 +0100 Message-ID: <20231211121430.1689139-2-kamel.bouhara@bootlin.com> X-Mailer: git-send-email 2.42.0 In-Reply-To: <20231211121430.1689139-1-kamel.bouhara@bootlin.com> References: <20231211121430.1689139-1-kamel.bouhara@bootlin.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-GND-Sasl: kamel.bouhara@bootlin.com Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add vendor prefix for TouchNetix AS (https://www.touchnetix.com/products/). Signed-off-by: Kamel Bouhara Acked-by: Krzysztof Kozlowski --- Documentation/devicetree/bindings/vendor-prefixes.yaml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Documentation/devicetree/bindings/vendor-prefixes.yaml b/Docum= entation/devicetree/bindings/vendor-prefixes.yaml index 573578db9509..78581001a79c 100644 --- a/Documentation/devicetree/bindings/vendor-prefixes.yaml +++ b/Documentation/devicetree/bindings/vendor-prefixes.yaml @@ -1400,6 +1400,8 @@ patternProperties: description: Toradex AG "^toshiba,.*": description: Toshiba Corporation + "^touchnetix,.*": + description: TouchNetix AS "^toumaz,.*": description: Toumaz "^tpk,.*": --=20 2.25.1 From nobody Fri Dec 19 13:09:42 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 649D6C4167B for ; Mon, 11 Dec 2023 12:14:56 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234851AbjLKMOr (ORCPT ); Mon, 11 Dec 2023 07:14:47 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60490 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234803AbjLKMOi (ORCPT ); Mon, 11 Dec 2023 07:14:38 -0500 Received: from relay5-d.mail.gandi.net (relay5-d.mail.gandi.net [IPv6:2001:4b98:dc4:8::225]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 58ABADC; Mon, 11 Dec 2023 04:14:43 -0800 (PST) Received: by mail.gandi.net (Postfix) with ESMTPSA id 795DD1C000A; Mon, 11 Dec 2023 12:14:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1702296882; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Eg87ZovtTfscZWbYAJIdbHo+yXOg2XwLG3HN8O/pMsg=; b=QH6gccPCVALh6eD2FyEtc0C4RVC37GtrEsTRk8a6j6rGH5DXwN/K/MchaZW0XGMjeS0PEK z7NWkjpCKIjM7g7/2qBTUzDN86vdFLHhJE/89nx5n7uU2U8hcAgWLPupdbCpdWPzIXrcT9 5CiVDc5WFQqevtFhwv23E+qnfFxoSFkbL10GEtWaMX5yJdyK9joUEiTUpZV2Pz+RlI48AO Z5rbWBFA7+QM5JKjjKHgSsHdovYI3gMx+39g43BKf+TBRJwtXDvr77XVMix4EV7/Y6kXXY XoaYMqjIDVuG9iHlaRVyxNh8fBMUBbmtewZRQkVRP3TLr0he4PfRYA8GLWFFwA== From: Kamel Bouhara To: Dmitry Torokhov , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Henrik Rydberg , linux-input@vger.kernel.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, Marco Felsch , Jeff LaBundy Cc: catalin.popescu@leica-geosystems.com, mark.satterthwaite@touchnetix.com, bartp@baasheep.co.uk, hannah.rossiter@touchnetix.com, Thomas Petazzoni , Gregory Clement , bsp-development.geo@leica-geosystems.com, Kamel Bouhara Subject: [PATCH v5 2/3] dt-bindings: input: Add TouchNetix axiom touchscreen Date: Mon, 11 Dec 2023 13:14:28 +0100 Message-ID: <20231211121430.1689139-3-kamel.bouhara@bootlin.com> X-Mailer: git-send-email 2.42.0 In-Reply-To: <20231211121430.1689139-1-kamel.bouhara@bootlin.com> References: <20231211121430.1689139-1-kamel.bouhara@bootlin.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-GND-Sasl: kamel.bouhara@bootlin.com Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add the TouchNetix axiom I2C touchscreen device tree bindings documentation. Signed-off-by: Kamel Bouhara --- .../input/touchscreen/touchnetix,ax54a.yaml | 64 +++++++++++++++++++ MAINTAINERS | 6 ++ 2 files changed, 70 insertions(+) create mode 100644 Documentation/devicetree/bindings/input/touchscreen/tou= chnetix,ax54a.yaml diff --git a/Documentation/devicetree/bindings/input/touchscreen/touchnetix= ,ax54a.yaml b/Documentation/devicetree/bindings/input/touchscreen/touchneti= x,ax54a.yaml new file mode 100644 index 000000000000..cbdf48fc538b --- /dev/null +++ b/Documentation/devicetree/bindings/input/touchscreen/touchnetix,ax54a.= yaml @@ -0,0 +1,64 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/input/touchscreen/touchnetix,ax54a.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: TouchNetix Axiom series touchscreen controller + +maintainers: + - Kamel Bouhara + +allOf: + - $ref: /schemas/input/touchscreen/touchscreen.yaml# + - $ref: /schemas/input/input.yaml# + +properties: + compatible: + const: touchnetix,ax54a + + reg: + const: 0x66 + + interrupts: + maxItems: 1 + + reset-gpios: + maxItems: 1 + + vdda-supply: + description: Analog power supply regulator on VDDA pin + + vddi-supply: + description: I/O power supply regulator on VDDI pin + + poll-interval: true + +required: + - compatible + - reg + - vdda-supply + - vddi-supply + +additionalProperties: false + +examples: + - | + #include + #include + i2c { + #address-cells =3D <1>; + #size-cells =3D <0>; + + touchscreen@66 { + compatible =3D "touchnetix,ax54a"; + reg =3D <0x66>; + interrupt-parent =3D <&gpio2>; + interrupts =3D <2 IRQ_TYPE_EDGE_FALLING>; + reset-gpios =3D <&gpio1 1 GPIO_ACTIVE_HIGH>; + vdda-supply =3D <&vdda_reg>; + vddi-supply =3D <&vddi_reg>; + poll-interval =3D <20>; + }; + }; +... diff --git a/MAINTAINERS b/MAINTAINERS index 7608b714653f..4752d8436dbb 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -21431,6 +21431,12 @@ S: Maintained F: Documentation/ABI/testing/sysfs-class-firmware-attributes F: drivers/platform/x86/think-lmi.? =20 +TOUCHNETIX AXIOM I2C TOUCHSCREEN DRIVER +M: Kamel Bouhara +L: linux-input@vger.kernel.org +S: Maintained +F: Documentation/devicetree/bindings/input/touchscreen/touchnetix,ax54a.ya= ml + THUNDERBOLT DMA TRAFFIC TEST DRIVER M: Isaac Hazan L: linux-usb@vger.kernel.org --=20 2.25.1 From nobody Fri Dec 19 13:09:42 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 862E2C4167B for ; Mon, 11 Dec 2023 12:14:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234898AbjLKMOv (ORCPT ); Mon, 11 Dec 2023 07:14:51 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60386 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234843AbjLKMOo (ORCPT ); Mon, 11 Dec 2023 07:14:44 -0500 Received: from relay1-d.mail.gandi.net (relay1-d.mail.gandi.net [217.70.183.193]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 63C7FD6; Mon, 11 Dec 2023 04:14:44 -0800 (PST) Received: by mail.gandi.net (Postfix) with ESMTPSA id 8B4CE240007; Mon, 11 Dec 2023 12:14:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1702296883; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=3NHd7/TIBMO6ajuA6MciK2iY40x565JzIM9NwkMsObI=; b=QDzI6xnjbheJAlkgXnowBHXmIw1SpTKMVau6uJ9VoP+8FCNpWX0jmXoOJxXBWynXGqFBJ8 V2s5Zt++vnEMvyfi6vzHUudCr1QxCqEDtQdlDOvFhAuI0TInM+yHP1JfmKq0eGqBQkK3Zz +NWBYftIB7LwGectEeTCK6pVwWUMR1fKjcgBb6T9C5SWtTVMAh2gyMbozSTS3q9ISC59Ls 5adKL+OkJjBy1BWqqTbN1qkxqQIkfIiB6b4LKhSayv9Vqrgop6+qs9uU7qEQsg1S17TFNo ao460YggYOTx+D+4Cu+/PNYmcoUG/U6GY4/sSTWmjepmwPKgQJsNZbwT0eKb8g== From: Kamel Bouhara To: Dmitry Torokhov , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Henrik Rydberg , linux-input@vger.kernel.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, Marco Felsch , Jeff LaBundy Cc: catalin.popescu@leica-geosystems.com, mark.satterthwaite@touchnetix.com, bartp@baasheep.co.uk, hannah.rossiter@touchnetix.com, Thomas Petazzoni , Gregory Clement , bsp-development.geo@leica-geosystems.com, Kamel Bouhara Subject: [PATCH v5 3/3] Input: Add TouchNetix axiom i2c touchscreen driver Date: Mon, 11 Dec 2023 13:14:29 +0100 Message-ID: <20231211121430.1689139-4-kamel.bouhara@bootlin.com> X-Mailer: git-send-email 2.42.0 In-Reply-To: <20231211121430.1689139-1-kamel.bouhara@bootlin.com> References: <20231211121430.1689139-1-kamel.bouhara@bootlin.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-GND-Sasl: kamel.bouhara@bootlin.com Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add a new driver for the TouchNetix's axiom family of touchscreen controllers. This driver only supports i2c and can be later adapted for SPI and USB support. Signed-off-by: Kamel Bouhara --- MAINTAINERS | 1 + drivers/input/touchscreen/Kconfig | 12 + drivers/input/touchscreen/Makefile | 1 + drivers/input/touchscreen/touchnetix_axiom.c | 667 +++++++++++++++++++ 4 files changed, 681 insertions(+) create mode 100644 drivers/input/touchscreen/touchnetix_axiom.c diff --git a/MAINTAINERS b/MAINTAINERS index 4752d8436dbb..337ddac6c74b 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -21436,6 +21436,7 @@ M: Kamel Bouhara L: linux-input@vger.kernel.org S: Maintained F: Documentation/devicetree/bindings/input/touchscreen/touchnetix,ax54a.ya= ml +F: drivers/input/touchscreen/touchnetix_axiom.c =20 THUNDERBOLT DMA TRAFFIC TEST DRIVER M: Isaac Hazan diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/= Kconfig index e3e2324547b9..f36bee8d8696 100644 --- a/drivers/input/touchscreen/Kconfig +++ b/drivers/input/touchscreen/Kconfig @@ -803,6 +803,18 @@ config TOUCHSCREEN_MIGOR To compile this driver as a module, choose M here: the module will be called migor_ts. =20 +config TOUCHSCREEN_TOUCHNETIX_AXIOM + tristate "TouchNetix AXIOM based touchscreen controllers" + depends on I2C + help + Say Y here if you have a axiom touchscreen connected to + your system. + + If unsure, say N. + + To compile this driver as a module, choose M here: the + module will be called axiom. + config TOUCHSCREEN_TOUCHRIGHT tristate "Touchright serial touchscreen" select SERIO diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen= /Makefile index 62bd24f3ac8e..8e32a2df5e18 100644 --- a/drivers/input/touchscreen/Makefile +++ b/drivers/input/touchscreen/Makefile @@ -88,6 +88,7 @@ obj-$(CONFIG_TOUCHSCREEN_SUR40) +=3D sur40.o obj-$(CONFIG_TOUCHSCREEN_SURFACE3_SPI) +=3D surface3_spi.o obj-$(CONFIG_TOUCHSCREEN_TI_AM335X_TSC) +=3D ti_am335x_tsc.o obj-$(CONFIG_TOUCHSCREEN_TOUCHIT213) +=3D touchit213.o +obj-$(CONFIG_TOUCHSCREEN_TOUCHNETIX_AXIOM) +=3D touchnetix_axiom.o obj-$(CONFIG_TOUCHSCREEN_TOUCHRIGHT) +=3D touchright.o obj-$(CONFIG_TOUCHSCREEN_TOUCHWIN) +=3D touchwin.o obj-$(CONFIG_TOUCHSCREEN_TS4800) +=3D ts4800-ts.o diff --git a/drivers/input/touchscreen/touchnetix_axiom.c b/drivers/input/t= ouchscreen/touchnetix_axiom.c new file mode 100644 index 000000000000..4ade2d1adba0 --- /dev/null +++ b/drivers/input/touchscreen/touchnetix_axiom.c @@ -0,0 +1,667 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * TouchNetix axiom Touchscreen Driver + * + * Copyright (C) 2020-2023 TouchNetix Ltd. + * + * Author(s): Bart Prescott + * Pedro Torruella + * Mark Satterthwaite + * Hannah Rossiter + * Kamel Bouhara + * + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define AXIOM_PROX_LEVEL -128 +/* + * Register group u31 has 2 pages for usage table entries. + */ +#define AXIOM_U31_MAX_USAGES ((2 * AXIOM_COMMS_PAGE_SIZE) / AXIOM_U31_BYT= ES_PER_USAGE) +#define AXIOM_U31_BYTES_PER_USAGE 6 +#define AXIOM_U31_PAGE0_LENGTH 0x0C +#define AXIOM_U31_BOOTMODE_MASK BIT(7) +#define AXIOM_U31_DEVID_MASK GENMASK(14, 0) + +#define AXIOM_CMD_HEADER_READ_MASK BIT(15) +#define AXIOM_U41_MAX_TARGETS 10 + +#define AXIOM_U46_AUX_CHANNELS 4 +#define AXIOM_U46_AUX_MASK GENMASK(11, 0) + +#define AXIOM_COMMS_MAX_USAGE_PAGES 3 +#define AXIOM_COMMS_PAGE_SIZE 256 +#define AXIOM_COMMS_REPORT_LEN_MASK GENMASK(6, 0) + +#define AXIOM_REPORT_USAGE_ID 0x34 +#define AXIOM_DEVINFO_USAGE_ID 0x31 +#define AXIOM_USAGE_2HB_REPORT_ID 0x01 +#define AXIOM_USAGE_2AUX_REPORT_ID 0x46 +#define AXIOM_USAGE_2DCTS_REPORT_ID 0x41 + +#define AXIOM_PAGE_OFFSET_MASK GENMASK(6, 0) + +struct axiom_devinfo { + u16 device_id; + u8 fw_minor; + u8 fw_major; + u8 fw_info_extra; + u8 tcp_revision; + u8 bootloader_fw_minor; + u8 bootloader_fw_major; + u16 jedec_id; + u8 num_usages; +} __packed; + +/* + * Describes parameters of a specific usage, essentially a single element = of + * the "Usage Table" + */ +struct axiom_usage_entry { + u8 id; + u8 is_report; + u8 start_page; + u8 num_pages; +}; + +/* + * Represents state of a touch or target when detected prior a touch (eg. + * hover or proximity events). + */ +enum axiom_target_state { + AXIOM_TARGET_STATE_NOT_PRESENT =3D 0, + AXIOM_TARGET_STATE_PROX =3D 1, + AXIOM_TARGET_STATE_HOVER =3D 2, + AXIOM_TARGET_STATE_TOUCHING =3D 3, +}; + +struct axiom_u41_target { + enum axiom_target_state state; + u16 x; + u16 y; + s8 z; + bool insert; + bool touch; +}; + +struct axiom_target_report { + u8 index; + u8 present; + u16 x; + u16 y; + s8 z; +}; + +struct axiom_cmd_header { + __le16 target_address; + __le16 length; +} __packed; + +struct axiom_data { + struct axiom_devinfo devinfo; + struct device *dev; + struct gpio_desc *reset_gpio; + struct i2c_client *client; + struct input_dev *input_dev; + u32 max_report_len; + char rx_buf[AXIOM_COMMS_MAX_USAGE_PAGES * AXIOM_COMMS_PAGE_SIZE]; + struct axiom_u41_target targets[AXIOM_U41_MAX_TARGETS]; + struct axiom_usage_entry usage_table[AXIOM_U31_MAX_USAGES]; + bool usage_table_populated; + struct regulator *vdda; + struct regulator *vddi; +}; + +/* + * axiom devices are typically configured to report + * touches at a rate of 100Hz (10ms). For systems + * that require polling for reports. + * When reports are polled, it will be expected to + * occasionally observe the overflow bit being set + * in the reports. This indicates that reports are not + * being read fast enough. + */ +#define POLL_INTERVAL_DEFAULT_MS 10 + +/* Translate usage/page/offset triplet into physical address. */ +static u16 axiom_usage_to_target_address(struct axiom_data *ts, char usage= , char page, + char offset) +{ + u32 i; + + /* At the moment the convention is that u31 is always at physical address= 0x0 */ + if (!ts->usage_table_populated) { + if (usage =3D=3D AXIOM_DEVINFO_USAGE_ID) + return ((page << 8) + offset); + else + return 0xffff; + } + + for (i =3D 0; i < ts->devinfo.num_usages; i++) { + if (ts->usage_table[i].id !=3D usage) + continue; + + if (page >=3D ts->usage_table[i].num_pages) { + dev_err(ts->dev, "Invalid usage table! usage: %u, page: %u, offset: %u\= n", + usage, page, offset); + return 0xffff; + } + break; + } + + return ((ts->usage_table[i].start_page + page) << 8) + offset; +} + +static int axiom_i2c_read(struct i2c_client *client, u8 usage, u8 page, u8= *buf, u16 len) +{ + struct axiom_data *ts =3D i2c_get_clientdata(client); + struct axiom_cmd_header cmd_header; + struct i2c_msg msg[2]; + int error; + + cmd_header.target_address =3D cpu_to_le16(axiom_usage_to_target_address(t= s, usage, page, 0)); + cmd_header.length =3D cpu_to_le16(len | AXIOM_CMD_HEADER_READ_MASK); + + msg[0].addr =3D client->addr; + msg[0].flags =3D 0; + msg[0].len =3D sizeof(cmd_header); + msg[0].buf =3D (u8 *)&cmd_header; + + msg[1].addr =3D client->addr; + msg[1].flags =3D I2C_M_RD; + msg[1].len =3D len; + msg[1].buf =3D (char *)buf; + + error =3D i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg)); + if (error !=3D ARRAY_SIZE(msg)) { + dev_err(&client->dev, + "Failed reading usage %#x page %#x, error=3D%d\n", + usage, page, error); + return -EIO; + } + + usleep_range(250, 300); + + return 0; +} + +/* + * One of the main purposes for reading the usage table is to identify + * which usages reside at which target address. + * When performing subsequent reads or writes to AXIOM, the target address + * is used to specify which usage is being accessed. + * Consider the following discovery code which will build up the usage tab= le. + */ +static u32 axiom_populate_usage_table(struct axiom_data *ts) +{ + struct axiom_usage_entry *usage_table; + u32 max_report_len =3D 0; + char *rx_data =3D ts->rx_buf; + u32 usage_id; + int error; + + usage_table =3D ts->usage_table; + + /* Read the second page of usage u31 to get the usage table */ + error =3D axiom_i2c_read(ts->client, AXIOM_DEVINFO_USAGE_ID, 1, rx_data, + (AXIOM_U31_BYTES_PER_USAGE * ts->devinfo.num_usages)); + if (error) + return error; + + for (usage_id =3D 0; usage_id < ts->devinfo.num_usages; usage_id++) { + u16 offset =3D (usage_id * AXIOM_U31_BYTES_PER_USAGE); + u8 id =3D rx_data[offset + 0]; + u8 start_page =3D rx_data[offset + 1]; + u8 num_pages =3D rx_data[offset + 2]; + u32 max_offset =3D ((rx_data[offset + 3] & AXIOM_PAGE_OFFSET_MASK) + 1) = * 2; + + if (!num_pages) + usage_table[usage_id].is_report =3D true; + + /* Store the entry into the usage table */ + usage_table[usage_id].id =3D id; + usage_table[usage_id].start_page =3D start_page; + usage_table[usage_id].num_pages =3D num_pages; + + dev_dbg(ts->dev, "Usage u%02x Info: %*ph\n", id, + AXIOM_U31_BYTES_PER_USAGE, &rx_data[offset]); + + /* Identify the max report length the module will receive */ + if (usage_table[usage_id].is_report && max_offset > max_report_len) + max_report_len =3D max_offset; + } + + ts->usage_table_populated =3D true; + + return max_report_len; +} + +static int axiom_discover(struct axiom_data *ts) +{ + int error; + + /* + * Fetch the first page of usage u31 to get the + * device information and the number of usages + */ + error =3D axiom_i2c_read(ts->client, AXIOM_DEVINFO_USAGE_ID, 0, (char *)&= ts->devinfo, + AXIOM_U31_PAGE0_LENGTH); + if (error) + return error; + + dev_dbg(ts->dev, " Boot Mode : %s\n", + FIELD_GET(AXIOM_U31_BOOTMODE_MASK, ts->devinfo.device_id) ? "BLP" : "TCP= "); + dev_dbg(ts->dev, " Device ID : %04lx\n", + FIELD_GET(AXIOM_U31_DEVID_MASK, ts->devinfo.device_id)); + dev_dbg(ts->dev, " Firmware Rev : %02x.%02x\n", ts->devinfo.fw_major, + ts->devinfo.fw_minor); + dev_dbg(ts->dev, " Bootloader Rev : %02x.%02x\n", ts->devinfo.bootloader= _fw_major, + ts->devinfo.bootloader_fw_minor); + dev_dbg(ts->dev, " FW Extra Info : %04x\n", ts->devinfo.fw_info_extra); + dev_dbg(ts->dev, " Silicon : %04x\n", ts->devinfo.jedec_id); + dev_dbg(ts->dev, " Number usages : %04x\n", ts->devinfo.num_usage= s); + + ts->max_report_len =3D axiom_populate_usage_table(ts); + if (!ts->max_report_len || !ts->devinfo.num_usages) + return -EINVAL; + + dev_dbg(ts->dev, "Max Report Length: %u\n", ts->max_report_len); + + return 0; +} + +/* + * Support function to axiom_process_u41_report. + * Generates input-subsystem events for every target. + * After calling this function the caller shall issue + * a Sync to the input sub-system. + */ +static bool axiom_process_u41_report_target(struct axiom_data *ts, + struct axiom_target_report *target) +{ + struct input_dev *input_dev =3D ts->input_dev; + struct axiom_u41_target *target_prev_state; + enum axiom_target_state current_state; + bool update =3D false; + int slot; + + /* Verify the target index */ + if (target->index >=3D AXIOM_U41_MAX_TARGETS) { + dev_dbg(ts->dev, "Invalid target index! %u\n", target->index); + return false; + } + + target_prev_state =3D &ts->targets[target->index]; + + current_state =3D AXIOM_TARGET_STATE_NOT_PRESENT; + + if (target->present) { + if (target->z >=3D 0) + current_state =3D AXIOM_TARGET_STATE_TOUCHING; + else if (target->z > AXIOM_PROX_LEVEL && target->z < 0) + current_state =3D AXIOM_TARGET_STATE_HOVER; + else if (target->z =3D=3D AXIOM_PROX_LEVEL) + current_state =3D AXIOM_TARGET_STATE_PROX; + } + + if (target_prev_state->state =3D=3D current_state && + target_prev_state->x =3D=3D target->x && + target_prev_state->y =3D=3D target->y && + target_prev_state->z =3D=3D target->z) { + return false; + } + + slot =3D target->index; + + dev_dbg(ts->dev, "U41 Target T%u, slot:%u present:%u, x:%u, y:%u, z:%d\n", + target->index, slot, target->present, + target->x, target->y, target->z); + + switch (current_state) { + case AXIOM_TARGET_STATE_NOT_PRESENT: + case AXIOM_TARGET_STATE_PROX: + if (!target_prev_state->insert) + break; + update =3D true; + target_prev_state->insert =3D false; + input_mt_slot(input_dev, slot); + + if (!slot) + input_report_key(input_dev, BTN_TOUCH, 0); + + input_mt_report_slot_inactive(input_dev); + /* + * make sure the previous coordinates are + * all off screen when the finger comes back + */ + target->x =3D 65535; + target->y =3D 65535; + target->z =3D AXIOM_PROX_LEVEL; + break; + case AXIOM_TARGET_STATE_HOVER: + case AXIOM_TARGET_STATE_TOUCHING: + target_prev_state->insert =3D true; + update =3D true; + input_mt_slot(input_dev, slot); + input_report_abs(input_dev, ABS_MT_TRACKING_ID, slot); + input_report_abs(input_dev, ABS_MT_POSITION_X, target->x); + input_report_abs(input_dev, ABS_X, target->x); + input_report_abs(input_dev, ABS_MT_POSITION_Y, target->y); + input_report_abs(input_dev, ABS_Y, target->y); + + if (current_state =3D=3D AXIOM_TARGET_STATE_TOUCHING) { + input_report_abs(input_dev, ABS_MT_DISTANCE, 0); + input_report_abs(input_dev, ABS_DISTANCE, 0); + input_report_abs(input_dev, ABS_MT_PRESSURE, target->z); + input_report_abs(input_dev, ABS_PRESSURE, target->z); + } else { + input_report_abs(input_dev, ABS_MT_DISTANCE, -target->z); + input_report_abs(input_dev, ABS_DISTANCE, -target->z); + input_report_abs(input_dev, ABS_MT_PRESSURE, 0); + input_report_abs(input_dev, ABS_PRESSURE, 0); + } + + if (!slot) + input_report_key(input_dev, BTN_TOUCH, (current_state =3D=3D + AXIOM_TARGET_STATE_TOUCHING)); + break; + default: + break; + } + + target_prev_state->state =3D current_state; + target_prev_state->x =3D target->x; + target_prev_state->y =3D target->y; + target_prev_state->z =3D target->z; + + return update; +} + +/* + * U41 is the output report of the 2D CTS and contains the status of targe= ts + * (including contacts and pre-contacts) along with their X,Y,Z values. + * When a target has been removed (no longer detected), + * the corresponding X,Y,Z values will be zeroed. + */ +static bool axiom_process_u41_report(struct axiom_data *ts, char *rx_buf) +{ + struct axiom_target_report target; + bool update_done =3D false; + u16 target_status; + u32 i; + + target_status =3D ((rx_buf[1]) | (rx_buf[2] << 8)); + + for (i =3D 0; i < AXIOM_U41_MAX_TARGETS; i++) { + char target_step =3D i * 4; + + target.index =3D i; + target.present =3D ((target_status & (1 << i)) !=3D 0) ? 1 : 0; + target.x =3D (rx_buf[(target_step + 3)] | (rx_buf[target_step + 4] << 8)= ); + target.y =3D (rx_buf[(target_step + 5)] | (rx_buf[target_step + 6] << 8)= ); + target.z =3D (s8)(rx_buf[i + 43]); + update_done |=3D axiom_process_u41_report_target(ts, &target); + } + + return update_done; +} + +/* + * U46 report contains a low level measurement data generated by the CDS + * algorithms from the AUX channels. This information is useful when tuning + * multi-press to assess mechanical consistency in the unit's construction. + */ +static void axiom_process_u46_report(struct axiom_data *ts, char *rx_buf) +{ + struct input_dev *input_dev =3D ts->input_dev; + u32 event_value; + u16 aux_value; + u32 i =3D 0; + + for (i =3D 0; i < AXIOM_U46_AUX_CHANNELS; i++) { + char target_step =3D i * 2; + + aux_value =3D ((rx_buf[target_step + 2] << 8) | (rx_buf[target_step + 1]= )) + & AXIOM_U46_AUX_MASK; + event_value =3D (i << 16) | (aux_value); + input_event(input_dev, EV_MSC, MSC_RAW, event_value); + } +} + +/* + * Validates the crc and demultiplexes the axiom reports to the appropriate + * report handler + */ +static int axiom_handle_events(struct axiom_data *ts) +{ + struct input_dev *input_dev =3D ts->input_dev; + char *report_data =3D ts->rx_buf; + struct device *dev =3D ts->dev; + u16 crc_report; + u16 crc_calc; + int error; + char len; + + error =3D axiom_i2c_read(ts->client, AXIOM_REPORT_USAGE_ID, 0, report_dat= a, + ts->max_report_len); + if (error) + return error; + + len =3D (report_data[0] & AXIOM_COMMS_REPORT_LEN_MASK) << 1; + if (!len) { + dev_err(dev, "Zero length report discarded.\n"); + return -ENODATA; + } + + /* Validate the report CRC */ + crc_report =3D (report_data[len - 1] << 8) | (report_data[len - 2]); + /* Length is in 16 bit words and remove the size of the CRC16 itself */ + crc_calc =3D crc16(0, report_data, (len - 2)); + + if (crc_calc !=3D crc_report) { + dev_err(dev, + "CRC mismatch! Expected: %#x, Calculated CRC: %#x.\n", + crc_report, crc_calc); + return -EINVAL; + } + + switch (report_data[1]) { + case AXIOM_USAGE_2DCTS_REPORT_ID: + if (axiom_process_u41_report(ts, &report_data[1])) { + input_mt_sync_frame(input_dev); + input_sync(input_dev); + } + break; + + case AXIOM_USAGE_2AUX_REPORT_ID: + /* This is an aux report (force) */ + axiom_process_u46_report(ts, &report_data[1]); + input_mt_sync(input_dev); + input_sync(input_dev); + break; + + case AXIOM_USAGE_2HB_REPORT_ID: + /* This is a heartbeat report */ + break; + default: + return -EINVAL; + } + + return 0; +} + +static void axiom_i2c_poll(struct input_dev *input_dev) +{ + struct axiom_data *ts =3D input_get_drvdata(input_dev); + + axiom_handle_events(ts); +} + +static irqreturn_t axiom_irq(int irq, void *dev_id) +{ + struct axiom_data *ts =3D dev_id; + + axiom_handle_events(ts); + + return IRQ_HANDLED; +} + +static void axiom_reset(struct gpio_desc *reset_gpio) +{ + gpiod_set_value_cansleep(reset_gpio, 1); + usleep_range(1000, 2000); + gpiod_set_value_cansleep(reset_gpio, 0); + msleep(110); +} + +static int axiom_i2c_probe(struct i2c_client *client) +{ + struct device *dev =3D &client->dev; + struct input_dev *input_dev; + struct axiom_data *ts; + u32 startup_delay_ms; + u32 poll_interval; + int target; + int error; + + ts =3D devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL); + if (!ts) + return -ENOMEM; + + ts->client =3D client; + i2c_set_clientdata(client, ts); + ts->dev =3D dev; + + ts->reset_gpio =3D devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH); + if (IS_ERR(ts->reset_gpio)) + return dev_err_probe(dev, PTR_ERR(ts->reset_gpio), "failed to get reset = GPIO\n"); + + if (ts->reset_gpio) + axiom_reset(ts->reset_gpio); + + ts->vddi =3D devm_regulator_get_optional(dev, "VDDI"); + if (!IS_ERR(ts->vddi)) { + error =3D regulator_enable(ts->vddi); + if (error) + return dev_err_probe(&client->dev, error, + "Failed to enable VDDI regulator\n"); + } + + ts->vdda =3D devm_regulator_get_optional(dev, "VDDA"); + if (!IS_ERR(ts->vdda)) { + error =3D regulator_enable(ts->vdda); + if (error) { + dev_err(dev, "Failed to get VDDA regulator\n"); + regulator_disable(ts->vddi); + return error; + } + if (!device_property_read_u32(dev, "startup-time-ms", &startup_delay_ms)) + msleep(startup_delay_ms); + } + + error =3D axiom_discover(ts); + if (error) + return dev_err_probe(dev, error, "Failed touchscreen discover\n"); + + input_dev =3D devm_input_allocate_device(ts->dev); + if (!input_dev) + return -ENOMEM; + + input_dev->name =3D "TouchNetix axiom Touchscreen"; + input_dev->phys =3D "input/axiom_ts"; + + /* Single Touch */ + input_set_abs_params(input_dev, ABS_X, 0, 65535, 0, 0); + input_set_abs_params(input_dev, ABS_Y, 0, 65535, 0, 0); + + /* Multi Touch */ + /* Min, Max, Fuzz (expected noise in px, try 4?) and Flat */ + input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, 65535, 0, 0); + /* Min, Max, Fuzz (expected noise in px, try 4?) and Flat */ + input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, 65535, 0, 0); + input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE, 0, MT_TOOL_MAX, 0, 0); + input_set_abs_params(input_dev, ABS_MT_DISTANCE, 0, 127, 0, 0); + input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 127, 0, 0); + + input_set_capability(input_dev, EV_KEY, BTN_TOUCH); + + /* Registers the axiom device as a touchscreen instead of a mouse pointer= */ + error =3D input_mt_init_slots(input_dev, AXIOM_U41_MAX_TARGETS, INPUT_MT_= DIRECT); + if (error) + return error; + + /* Enables the raw data for up to 4 force channels to be sent to the inpu= t subsystem */ + set_bit(EV_REL, input_dev->evbit); + set_bit(EV_MSC, input_dev->evbit); + /* Declare that we support "RAW" Miscellaneous events */ + set_bit(MSC_RAW, input_dev->mscbit); + + ts->input_dev =3D input_dev; + input_set_drvdata(ts->input_dev, ts); + + /* Ensure that all reports are initialised to not be present. */ + for (target =3D 0; target < AXIOM_U41_MAX_TARGETS; target++) + ts->targets[target].state =3D AXIOM_TARGET_STATE_NOT_PRESENT; + + error =3D input_register_device(input_dev); + if (error) + return dev_err_probe(ts->dev, error, + "Could not register with Input Sub-system.\n"); + + error =3D devm_request_threaded_irq(dev, client->irq, NULL, + axiom_irq, IRQF_ONESHOT, dev_name(dev), ts); + if (error < 0) { + dev_warn(dev, "Request irq failed, falling back to polling mode"); + + error =3D input_setup_polling(input_dev, axiom_i2c_poll); + if (error) + return dev_err_probe(ts->dev, error, "Unable to set up polling mode\n"); + + if (!device_property_read_u32(ts->dev, "poll-interval", &poll_interval)) + input_set_poll_interval(input_dev, poll_interval); + else + input_set_poll_interval(input_dev, POLL_INTERVAL_DEFAULT_MS); + } + + return 0; +} + +static const struct i2c_device_id axiom_i2c_id_table[] =3D { + { "ax54a" }, + {}, +}; +MODULE_DEVICE_TABLE(i2c, axiom_i2c_id_table); + +static const struct of_device_id axiom_i2c_of_match[] =3D { + { .compatible =3D "touchnetix,ax54a", }, + { } +}; +MODULE_DEVICE_TABLE(of, axiom_i2c_of_match); + +static struct i2c_driver axiom_i2c_driver =3D { + .driver =3D { + .name =3D "axiom", + .of_match_table =3D axiom_i2c_of_match, + }, + .id_table =3D axiom_i2c_id_table, + .probe =3D axiom_i2c_probe, +}; +module_i2c_driver(axiom_i2c_driver); +MODULE_AUTHOR("Bart Prescott "); +MODULE_AUTHOR("Pedro Torruella "); +MODULE_AUTHOR("Mark Satterthwaite "); +MODULE_AUTHOR("Hannah Rossiter "); +MODULE_AUTHOR("Kamel Bouhara "); +MODULE_DESCRIPTION("TouchNetix axiom touchscreen I2C bus driver"); +MODULE_LICENSE("GPL"); --=20 2.25.1