From patchwork Tue Apr 16 02:12:25 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Allen_Lin X-Patchwork-Id: 790610 Received: from APC01-SG2-obe.outbound.protection.outlook.com (mail-sgaapc01olkn2080.outbound.protection.outlook.com [40.92.53.80]) (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 5665011720; Tue, 16 Apr 2024 02:13:01 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=40.92.53.80 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1713233583; cv=fail; b=jSfzakmVPGLRgXkErlxnNRLjJpSrBO6sTldR0pizUhk6eLHifnotpXCQgNZ4TMFeNT+9dN/NiCQnfh9tdDfF9s3mzS2EITKopK2vg0t48T7Zf4BHb82gepCVAGz2jbT4sq3Zb3I0JhMWz0osG1We+SlNTsB3S5ZPEsgWvwxqQAk= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1713233583; c=relaxed/simple; bh=zpNqSVUlrN62Z1uCEHRK8dfLOVwB/3hrtcvMwua510Q=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: Content-Type:MIME-Version; b=hP+kuWjhI2iWxOthE8Su1DRm4kO95/kxlm9efHCVfJClFmAtRuzJVxfH27J1RcvR4BZC0OirNP54KptU8K4dDUkDsMYClITam/Pmqba42U/2ZzW0TkP3LgJ1y+EABYvrnloEURPi58hmicwea/Mj5d52sHYy2kDbW7TvjO/j0HE= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=hotmail.com; spf=pass smtp.mailfrom=hotmail.com; dkim=pass (2048-bit key) header.d=hotmail.com header.i=@hotmail.com header.b=rvu+wAen; arc=fail smtp.client-ip=40.92.53.80 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=hotmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=hotmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=hotmail.com header.i=@hotmail.com header.b="rvu+wAen" ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=Qfa8ixKjzb732EAZ0l+2A9zt6TWimIt3Gf0cERPIiE2fIAbwT3LfqOXmQRXdccF3zU4kXoW5AMhjpnYafReRlEf5II/83tq6nsZcBg3kP1OuQNQZEfnRbSB2b9e8mq2tyvs0Pbl8BTaL13Dium5N3m7wz8+3f1ceL2m/DJSJgrB2O8/S7KjydvXW9aTLLG5x2C4zUAYgPrYYv0D4+Ls+uJHos/GAF10cyE3gLQoSlTj9q44utvd2kYnnctqWOGcHzVnAcZtKNwtBS89qVb+gyp9zywwL4NHfJRli7/gqgVrVzHe1oBb6wGhNBHukVHV+eUu7WVNZlUvXpR6Uqw17Cg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=8l6JNomgXx6iLskAvS7xv0kglOAogOZdEre0qmlkQs0=; b=SgdmffTak7IEc76kirv5KQCGgmnxmjo9d5C5R/XcEJxY3hRFGtU4bLIVCR3bVZa/PLYTGzX9nRZlvSCkzsAuorrpLMln12BTCpkV7MMhqbUW5gx8MqyMkJ1p+0+L2Pj5Kz6G6h42x/bsZ3kbSmRNiS8vaDuKRKRbfkY1lR0VFujY2CUWdM5o50KfoMXrqHfVQ7nBgcKDRtBJv65gI4Hmg56a8D0vJ+guLFmqvW5csEFKqcVZLjLyWULGB3au44T5iyYZtUWbQ4HAxMGU/Ri/izW4FGsWicANeP14YkYiE5JkZZeakzP/Bko0MJy6mDAXIyIhUiBj2UI97BnQb1lqfA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=hotmail.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=8l6JNomgXx6iLskAvS7xv0kglOAogOZdEre0qmlkQs0=; b=rvu+wAenHi6Fq0Ds9RM0lZyZMTD3JJNb1PbGq9PAZF1I42zrQEnFAx783qt6XEOGDANOLVyrstybfmeU23puPJxdQLwhjyl0/nsM4pGyUSIH/EUi0f1oWHqKJMqwoJ6dnQvVoOTwKL6DkOqIscjwN+T173DgHWnvphVVCgMyVhNCfzZCbMancQEsU3yFzDCIFjqcaIcDOFFqVTdcaKbsv18FE3H8ctipscwi823BmWo7RdBAWkxMYICkyt0fK6ZVoVc0Hu5O5uBcLmo385/GUVrd6oBJJ0xDVcj6xGZV/sS9rBLLD3qDtNDvsU8Afef1vo+LXwZoOoZEzA6bSs/06A== Received: from TY0PR06MB5611.apcprd06.prod.outlook.com (2603:1096:400:31e::8) by TYZPR06MB5323.apcprd06.prod.outlook.com (2603:1096:400:1f1::8) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7452.50; Tue, 16 Apr 2024 02:12:56 +0000 Received: from TY0PR06MB5611.apcprd06.prod.outlook.com ([fe80::d57a:9f0e:1ee7:85bf]) by TY0PR06MB5611.apcprd06.prod.outlook.com ([fe80::d57a:9f0e:1ee7:85bf%5]) with mapi id 15.20.7452.049; Tue, 16 Apr 2024 02:12:55 +0000 From: Allen_Lin To: dmitry.torokhov@gmail.com, robh@kernel.org, krzysztof.kozlowski+dt@linaro.org, conor@kernel.org, jikos@kernel.org, benjamin.tissoires@redhat.com, linux-input@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Cc: Allen_Lin Subject: [PATCH v3 1/4] dt-bindings: input: Add Himax HX83102J touchscreen Date: Tue, 16 Apr 2024 10:12:25 +0800 Message-ID: X-Mailer: git-send-email 2.34.1 In-Reply-To: <20240416021228.1092678-1-allencl_lin@hotmail.com> References: <20240416021228.1092678-1-allencl_lin@hotmail.com> X-TMN: [xqfrmftdHqajCiJlIdZfpb6gfvHbyhpc] X-ClientProxiedBy: PS2PR01CA0002.apcprd01.prod.exchangelabs.com (2603:1096:300:2d::14) To TY0PR06MB5611.apcprd06.prod.outlook.com (2603:1096:400:31e::8) X-Microsoft-Original-Message-ID: <20240416021228.1092678-2-allencl_lin@hotmail.com> Precedence: bulk X-Mailing-List: linux-input@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: TY0PR06MB5611:EE_|TYZPR06MB5323:EE_ X-MS-Office365-Filtering-Correlation-Id: e9478ebe-b7cf-4672-a6a3-08dc5dbaba96 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: DYmmPHsHz9aYbL9hEcxiAYZnDSFs5dbUlThxoT5xOQIhLwFu/ubZK+lbQLHQYraum65oVqldRWj4T2+lLK3YdmAvR99fXlJs8QzrZiVX1L627JAAlbyh5z2QY8niDJeEFZwJoWt2/oX0SnkTULrgaYDrK5+Y/aV/4LW3ZPbTbktS5+Vrc61nGT5/Em0eapDZVgl961mZ4KcYCdJ+VwNFHNka1Rpr20LBTsU0gbutdBAiaomGnhciin0q38kkQeD6NMVyTo41E9Dhur1w29fB5YPvRU3j4DwWP1rdmZReCEjvDb0G/EYDmfqvkpMDi/MltoVfGHWCI2OiKDcdg+dNs6J8yjGSSFxHl78WGPKPJkZB26i/gqVvWPEuXpyO0wnkbTOTyxGgeYOvFnOFlzT5Z6MhaKFauj4TF1js6s9bSA+35bIkXU4sqkh1XNiDdPg4iLjEyyGs65jlVg1f6R9/yURwDVEkEBGjD/pfQ++8nmXYSy8WZDf+KYCNKdC5OvVBd6O5QiqTmXClUyxl+5t7NYIemQ7WiGkaW9tuarih5juUygcwmYAPphH/Rv65/uN2s5bbFwRNYJLWq88gg3p0PxazqZDSw30ySvfjpSOKtHlNF2Gh4f139xBBUJiLSPnjU9OsjVU6EGXk6yPFW/141kYzN8qlL8nzc+0b/44ZhjnAS0DgX3pWV/AlPwibay8H X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: aI047R7XjmHvjiibiSXENU3YZEzV5a9FT3Gnwn6gG4cCmCiQQuA4WIibvUPP+Wcw0PDPq0bPwKS7km0SY32RLOkCKvTJ45Be8O0VtH0QvxgUJX665X3xkQPAlPBhJb0c+OWYH6asjcfXXdEJqI6rIJ+cm+MOmWxBp0E/kLBVG0iAgF2xJnWQHxLPkKt8eYK6Fc8ms1yGIEsTmz9YBIwRwM3qCDCVlh9ekdJlBY0uEmx5XThjlgpn4OKZI9FtX+m0nxt1IKfbACOqWRZizq1cg5mpmG0EPiZlD2ERyq3aIIo6HVCujL80i4G9XaR2+FvGPhWM1DNXqp5bUufegD6AALFsHIYNVc3r11c+4W2p+mgUOUpdMKKk4xvsJCFXklq5ojVseSRZuMzmWoYBQk4R0brooboasMF0p7w7EtPh9Lfno6x0nrSvoPDF3Ncj4eN+UObtZYcMKkQ6Q+Gg6jtzRPEk1SqhraHgedjvPe+wLk7FI3yP4rnyyVr+FB+uolhsgw31sHa7cGXt55HA3K+0w1EAtcK6CzOg6iE9Pk2LfYAUC1yOg56Nr75SU/S1SFaWTl1n1xmjiTVy7C+juC9NxJvgoTOj9f85UQcy/U0Us8uhXMQjkSsgMzKBtp/hg4DguYl+XXN9eznJitVH7q6DGwUpfoLRRhE0U3Ii1ghgkqodJjYznxsODVwqKAAwwiHPAaQWCUSpVlQkJvQCYdx5wi1PuzgDvgBqbv8kSpstmqGM3CPiyYo9Yb3pCLRFC3sxPmPwAWR187SBd/+A+hkujVhZMBGPHkRCaiSFDUqUEsgGZd9nwW/mqnf5/Rjaeqo8iqx3cBqIGjC/KxK4dIiQUtKfgK2LBIfxgI0yw0tmhkcBR+vcd0ZmKMoE63ohXqvcr2sG3ZnTdAhTCBVEi0XWprylAhMlgiRGwiLPwk4NdVLtFi3BRIaodUzkDjRnciwSoLG1t1j7iDMiuEeKXJu1ANfNftH9F81Q3/Aft4yeY3WuR5sdkJhU+gwDjs1tjJ3J2xlu1hPWyZJKob88f1VEXMaD79mfBtSYdIBk2ci5CAgHHBrS9WQwxWUAeoASUP4K8STJxiTsH40Wxl1l55zKC0WbGk+pLVxq1iPdCYZbR6rGO8/REZ9Gvy/J5vG3kcB5WNXI9VlQoWwIv959JIiid+zXG9XPeNmUwai5n1YHr/Lq8A9bUgw+RVag+GnJxtAc+Jn/qfnyEHT8SWyUDRiEYNgRu55VKmB6WCi04cGgXzk8krdwU1jJh9l1snvYrjlg X-OriginatorOrg: sct-15-20-4755-11-msonline-outlook-3208f.templateTenant X-MS-Exchange-CrossTenant-Network-Message-Id: e9478ebe-b7cf-4672-a6a3-08dc5dbaba96 X-MS-Exchange-CrossTenant-AuthSource: TY0PR06MB5611.apcprd06.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 16 Apr 2024 02:12:55.8971 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: TYZPR06MB5323 Add the HX83102j touchscreen device tree bindings documents. HX83102j is a Himax TDDI touchscreen controller. It's power sequence should be bound with a lcm driver, thus it needs to be a panel follower. Others are the same as normal SPI touchscreen controller. Reviewed-by: Rob Herring Signed-off-by: Allen_Lin --- .../input/touchscreen/himax,hx83102j.yaml | 93 +++++++++++++++++++ MAINTAINERS | 6 ++ 2 files changed, 99 insertions(+) create mode 100644 Documentation/devicetree/bindings/input/touchscreen/himax,hx83102j.yaml diff --git a/Documentation/devicetree/bindings/input/touchscreen/himax,hx83102j.yaml b/Documentation/devicetree/bindings/input/touchscreen/himax,hx83102j.yaml new file mode 100644 index 000000000000..113fa7945c0a --- /dev/null +++ b/Documentation/devicetree/bindings/input/touchscreen/himax,hx83102j.yaml @@ -0,0 +1,93 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/input/touchscreen/himax,hx83102j.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Himax hx83102j touchscreen + +maintainers: + - Allen Lin + +description: + This Himax hx83102j touchscreen uses the spi protocol. + +allOf: + - $ref: /schemas/input/touchscreen/touchscreen.yaml# + - $ref: /schemas/spi/spi-peripheral-props.yaml# + +properties: + compatible: + const: himax,hx83102j + + reg: + maxItems: 1 + + interrupts: + maxItems: 1 + + reset-gpios: + maxItems: 1 + + vccd-supply: + description: A phandle for the regulator supplying IO power. + + vsn-supply: + description: Negative supply regulator. + + vsp-supply: + description: Positive supply regulator. + + ddreset-gpios: + description: A phandle of gpio for display reset controlled by the LCD driver. + This is the master reset, if this reset is triggered, the TP reset will + also be triggered. + + spi-cpha: true + + spi-cpol: true + + spi-max-frequency: true + + panel: true + + firmware-name: + description: Specify the file name for firmware loading. + +required: + - compatible + - reg + - interrupts + - reset-gpios + - panel + - vccd-supply + - vsn-supply + - vsp-supply + - ddreset-gpios + +additionalProperties: false + +examples: + - | + #include + #include + spi { + #address-cells = <1>; + #size-cells = <0>; + ap_ts: touchscreen@0 { + compatible = "himax,hx83102j"; + reg = <0>; + pinctrl-names = "default"; + pinctrl-0 = <&touch_int0 &touch_reset>; + reset-gpios = <&gpio1 8 GPIO_ACTIVE_LOW>; + spi-cpha; + spi-cpol; + interrupt-parent = <&gpio1>; + interrupts = <7 IRQ_TYPE_LEVEL_LOW>; + panel = <&panel>; + vccd-supply = <®ulator>; + vsn-supply = <®ulator>; + vsp-supply = <®ulator>; + ddreset-gpios = <&gpio1>; + }; + }; \ No newline at end of file diff --git a/MAINTAINERS b/MAINTAINERS index 43b39956694a..bb7b363cb2ed 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -9669,6 +9669,12 @@ L: linux-kernel@vger.kernel.org S: Maintained F: drivers/misc/hisi_hikey_usb.c +HIMAX HID TOUCHSCREEN +M: Allen Lin +L: linux-input@vger.kernel.org +S: Maintained +F: Documentation/devicetree/bindings/input/touchscreen/himax,hx83102j.yaml + HIMAX HX83112B TOUCHSCREEN SUPPORT M: Job Noorman L: linux-input@vger.kernel.org From patchwork Tue Apr 16 02:12:26 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Allen_Lin X-Patchwork-Id: 789562 Received: from APC01-TYZ-obe.outbound.protection.outlook.com (mail-tyzapc01olkn2085.outbound.protection.outlook.com [40.92.107.85]) (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 93AAD13AF9; Tue, 16 Apr 2024 02:13:06 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=40.92.107.85 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1713233590; cv=fail; b=MKzocLxvssMItuO64lWEJ0dT4lHN8axmGQogDp3DAILwDDtE21eAgk1l45YH97wzdx9zMJXnmKKelPiHW5OEag8tUje+QbOLnR9bZZxfsRMFX9PoKNEWxNKwN+PRr4f+wL5nqiIHbsc52mITY1kbz4UyqiLquOiS1ruti9rF2QY= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1713233590; c=relaxed/simple; bh=27g4H2QQxVwF4RKRk6EfLm4B/fOYXfj/HCIMKiljrOM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: Content-Type:MIME-Version; b=p7pdjFB6AEVyJMyDKyL87XBWu4gWevIQLN86XtCuaDumu/Ti7dhFuF0mMb+ASM/cXtvJ53JeRNizmDbJ7DC1pO4mxRZ9lv/18/mAW+2jDhLL/29s+ALBZbS22LogY4fXy9FkpJuOLH55UZtQndcs+rhy1ABH6BuMJcF5zZdIHPU= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=hotmail.com; spf=pass smtp.mailfrom=hotmail.com; dkim=pass (2048-bit key) header.d=hotmail.com header.i=@hotmail.com header.b=tznPYPmv; arc=fail smtp.client-ip=40.92.107.85 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=hotmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=hotmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=hotmail.com header.i=@hotmail.com header.b="tznPYPmv" ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=gQG7CXMwydKKrsmJyiCR8+Eu8pq/vcfkQW/XLcixuEAAcdqKnIXcHby+hn/y087CfUntwM9xSf47Ncbx4+Judk4Etbo7SxT7l+LJIX5eIzBIeuIIeQ1a/tbeqS66z/0RY4z5jLIFRkVBHXTCQW0sMeIQcZDC36WnTSk/QMBhFKn+72unWDRfnhoSRCMDTNK5IMI5wCfEJUgdxQ0m8ntjaHeC+JDOmaS48tg6QgEMqze3YsDwsWHjV+nu6ALoRNum4V22IVxHRcsVTj8g/haIaPP6TzGYBDcuW1taHyLCEHdiqe2ly4bARh4Fcs4tMfkQDrcrsyq4eZDfHKGxMuuFzA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=IWcDS0lBCZ1ykKMtmMunZ+E9sxypEYxzQK/EwHwZ6N0=; b=bB3KfvJTNOQEsLCINdtsqFEeaOIYwJDF9M9tXDnxPiOMT8pjb654Y2lxmVmciyx22W8KmEaguHkxbz7lCnwDPkXyerwhKGKs/bsqcrtiN6bO8whnA6bTlHcFSAYUkrdlp8Nh2of/bl+7GKsdWLhqjDatDANnfBS1jXIfPEusSIx7KWDmUK9Tjoo9KeyClCit8iV4sr5Kb8mRCXBw4+94aRJ83xJ+Kn2hqi+A3J9QPdDjoj3SKrQDnY4QXj1L/pela6pClaYEb5Pp6C22Gf8ejXuX0vtdAS4Zmq1ZiJRRYjuwMOCXiOAYqP2lIIRd6AlqmUnqPfYwftBXzFQhQWCFdQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=hotmail.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=IWcDS0lBCZ1ykKMtmMunZ+E9sxypEYxzQK/EwHwZ6N0=; b=tznPYPmvThf6MrdS3OcuReGXRTSnSKIa/Uwm3dO5iFBE/Vct2ArQBd1l5w9W9xo4GBFhfC815F3f9Oei0igFQ4f9xv77qUYIuJ3nxRxQSpGkSdTmaktD7YMJp2yUaC3HAAihD0Z/x+pdsqsHf8De4Uzo/F9jPhQXqYQpriVPojAoicsmc8zyfq5Knmd+JEpLoEv4D7IMVCNuo5yxsBEtLqQKLg46b6gmFDXgVBAyHjXA7DQ+1GnyRUKfhj9hZBhxmp6U+0kHNibCyxOCb16WR3xzrOuSYfgbLR9I+pWaKCoHi2wsqW15DVBqaCTidGjNcMik5QCgep5t8FxUEdq9LA== Received: from TY0PR06MB5611.apcprd06.prod.outlook.com (2603:1096:400:31e::8) by TYZPR06MB5323.apcprd06.prod.outlook.com (2603:1096:400:1f1::8) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7452.50; Tue, 16 Apr 2024 02:13:01 +0000 Received: from TY0PR06MB5611.apcprd06.prod.outlook.com ([fe80::d57a:9f0e:1ee7:85bf]) by TY0PR06MB5611.apcprd06.prod.outlook.com ([fe80::d57a:9f0e:1ee7:85bf%5]) with mapi id 15.20.7452.049; Tue, 16 Apr 2024 02:13:01 +0000 From: Allen_Lin To: dmitry.torokhov@gmail.com, robh@kernel.org, krzysztof.kozlowski+dt@linaro.org, conor@kernel.org, jikos@kernel.org, benjamin.tissoires@redhat.com, linux-input@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Cc: Allen_Lin Subject: [PATCH v3 2/4] HID: Add Himax HX83102J touchscreen driver Date: Tue, 16 Apr 2024 10:12:26 +0800 Message-ID: X-Mailer: git-send-email 2.34.1 In-Reply-To: <20240416021228.1092678-1-allencl_lin@hotmail.com> References: <20240416021228.1092678-1-allencl_lin@hotmail.com> X-TMN: [kGL0GWjSmNADsKWgDnMbp4qb6hGPUdyo] X-ClientProxiedBy: PS2PR01CA0002.apcprd01.prod.exchangelabs.com (2603:1096:300:2d::14) To TY0PR06MB5611.apcprd06.prod.outlook.com (2603:1096:400:31e::8) X-Microsoft-Original-Message-ID: <20240416021228.1092678-3-allencl_lin@hotmail.com> Precedence: bulk X-Mailing-List: linux-input@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: TY0PR06MB5611:EE_|TYZPR06MB5323:EE_ X-MS-Office365-Filtering-Correlation-Id: 2b86d53d-6b27-48b3-3536-08dc5dbabdb0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: D3tTXp3yV3VrZQ8m7F/CXKY3TPwryG7W1c8yZ2fyplrypQ642lGmzF/HmyCDG4bXwklahl+UU0Z27BbatsJV32GvhRLR6kGI0umXem6cU0cf5lyGmoaB9G9cAHj7LW1hoTqI4Nw0JV9Cd1ED6O+qPaupdH+LcndaQUtualJY6c05AGPCK54mbB8g/d25XztWufn3dXZgERDAQ7JpmatnSyMso3yQP0/3VO0C6CUrkiN/9zAXAHG/BUIm70XeDDof/n8+cdqQmNOsB4BsVEhRwbLwBzroJx8szQ46w8DGMfrxCzBRSNtksvt9tIVNLkKrDao4k070QE3WOsBwIECdFM5aEROQL3e5sBolAtcs+nUKqm1wS2J57qx3dS3gZcmDhGr/dlLZehK2v5ZsAXiho3yfZifCFqze8o36Z6zEaBaR9IngH1atCHbHr2besa7U2LLtZIkjWdRb7GABP9MYtvlrxqJq93oLK3aZtqN0OWaIEBdokLK5iJ7er6uOWg2oylD/PXWm88QJk9A1+BlESBS+6RORiUMF0mccDaLC+8EZyv04tgnYbZeulDVahCqvAOgCkta3UVyxWunFMmvStbD9n0I/vQ/wQrxylddz1l09sR1gSBY2jsRXjCRMoQM0 X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: frlwO5bcQN+1qB0wLy3/Dw2t/cZVVWKH9CtwNcOsngLrXUNPZuLyue3mSvib3L3ZMz7wx+1MHThWwUVZjeVZ7wZTjM9ci/V5baKcKQ/A5Ywbytx2pB686QiYoaNpLcT2/JzenIdB+H+RzlNI2e14jsiHpCeBAsBegcwpNZITRjVHgOWO8qGJQIFZU6ew5gD8osQez+vKPeDphagdbjpo0pY3ZeYVLJzhKCvP6OYXTqqPMo4r1V55VB9a3N5mrQlz/mVSaancEW1HqTbNFN2k1DexAinNyXNKbt+wBxD8iJeQRf83C3RSdqq03nOZ+rREfGAMdJDY7Ij+Y8DU8jIyUCh1+qEzrBXe/hq7K8swnDSUvAKnM+N8jMoP2B27UEt2kbOjeF+guS0oZCXGq4OPkfz7l+xxltaMEBzLgsTGsIuUdwVA88NUI2NsiWYzgABIYVR/EHX6RwLAiqMqlZjrAiPPxcdYyWrSiSYnWWVGyj3Y5Qp02XVcnX/mkhV2QNIJ8abhuOR5nkJuQiqLQQBNUpUXmegHXWT5vryRxieCw3Q6Z5hMM91/Oovoqxhkg2piq6ptmNwXnPWMETgudKCExmWkHv2nVOQlhV18mlx20jX+a2fbFEZ1f9FilPeqSXd2snkhOOwSlaY9I5/9l/UqVd00hH6mjueQVvgtWTLWvGUssONRIYqBn5sF0g0V4LBGEkvE7b3Uou7Y1RqgksUmvSRl+4MYrIORn3/ZAn4Vx2oyLA8Co/NzXSMVus76iWNWiwZdyw+02e21NXavfgmpMddeBzlg4Gconr0g1+OKk85wZiIS+nTPGHxzeYuO0lUtrFdjWk2Sf5jls+OHRxJwJIfYRpGIXzWyD80S7eLrMqgQbuuMKV9u2IPxKyPeI+VWEXbrJVV1bMcwZ1pEyWEAH9Mr0dMtFI8Xir8o3J9m3FqOjqOrbmHJ+bz2Gc300QdmehG7uko+qcmdM36iLhrW8TKbMmN1PsK50rfVBO5Ksi7VuTVHCSrwCwmVaziN8VjRq4C1mRpDKEnj9SdVHjLP8G+mEcpqCLD/jRZlx9y04usvINWthNx1efsbkqXu7hihj7za4jtILWExkJhS8MUCztB4F6okf99+dmuFGMgAS7aX0Rcuhizd9zD20YUQTEwkVad/am56w2ihxwns19vRObAUB6yT5I3uIkb6ft5o4Aj+bK6HEIL5nmJoFX9acf1Lqiz2L3w7hSdP/+I9CKrfjC9fvLHQAzLcmoPvv1skWn8YB+fuHtmiljB2gvuy+BQy X-OriginatorOrg: sct-15-20-4755-11-msonline-outlook-3208f.templateTenant X-MS-Exchange-CrossTenant-Network-Message-Id: 2b86d53d-6b27-48b3-3536-08dc5dbabdb0 X-MS-Exchange-CrossTenant-AuthSource: TY0PR06MB5611.apcprd06.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 16 Apr 2024 02:13:01.2802 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: TYZPR06MB5323 Add a new driver for Himax HX83102J touchscreen controllers. This driver supports Himax IC using the SPI interface to acquire HID packets. After confirmed the IC's exsitence the driver loads the firmware image from flash to get the HID report descriptor, VID and PID. And use those information to register HID device. Signed-off-by: Allen_Lin --- MAINTAINERS | 1 + drivers/hid/Kconfig | 7 + drivers/hid/Makefile | 2 + drivers/hid/hid-himax.c | 1768 +++++++++++++++++++++++++++++++++++++++ drivers/hid/hid-himax.h | 288 +++++++ 5 files changed, 2066 insertions(+) create mode 100644 drivers/hid/hid-himax.c create mode 100644 drivers/hid/hid-himax.h diff --git a/MAINTAINERS b/MAINTAINERS index bb7b363cb2ed..34ec2f0241d7 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -9674,6 +9674,7 @@ M: Allen Lin L: linux-input@vger.kernel.org S: Maintained F: Documentation/devicetree/bindings/input/touchscreen/himax,hx83102j.yaml +F: drivers/hid/hid-himax.* HIMAX HX83112B TOUCHSCREEN SUPPORT M: Job Noorman diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig index 4c682c650704..0e5146ee40d6 100644 --- a/drivers/hid/Kconfig +++ b/drivers/hid/Kconfig @@ -376,6 +376,13 @@ config HID_GLORIOUS Support for Glorious PC Gaming Race mice such as the Glorious Model O, O- and D. +config HID_HIMAX + tristate "Himax hx83102j touchscreen" + depends on HID + depends on SPI + help + Support for Himax TDDI hx83102j touchscreen. + config HID_HOLTEK tristate "Holtek HID devices" depends on USB_HID diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile index 082a728eac60..2ad21d60492e 100644 --- a/drivers/hid/Makefile +++ b/drivers/hid/Makefile @@ -170,3 +170,5 @@ obj-$(INTEL_ISH_FIRMWARE_DOWNLOADER) += intel-ish-hid/ obj-$(CONFIG_AMD_SFH_HID) += amd-sfh-hid/ obj-$(CONFIG_SURFACE_HID_CORE) += surface-hid/ + +obj-$(CONFIG_HID_HIMAX) += hid-himax.o diff --git a/drivers/hid/hid-himax.c b/drivers/hid/hid-himax.c new file mode 100644 index 000000000000..f8a417e07f0c --- /dev/null +++ b/drivers/hid/hid-himax.c @@ -0,0 +1,1768 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Himax hx83102j SPI Driver Code for HID. + * + * Copyright (C) 2024 Himax Corporation. + */ + +#include "hid-himax.h" + +static int himax_chip_init(struct himax_ts_data *ts); +static void himax_ts_work(struct himax_ts_data *ts); + +/** + * himax_spi_read() - Read data from SPI + * @ts: Himax touch screen data + * @cmd_len: Length of command + * @buf: Buffer to store data + * @len: Length of data to read + * + * Himax spi_sync wrapper for read. Read protocol start with write command, + * and received the data after that. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_spi_read(struct himax_ts_data *ts, u8 cmd_len, u8 *buf, u32 len) +{ + int ret; + int retry_cnt; + struct spi_message msg; + struct spi_transfer xfer = { + .len = cmd_len + len, + .tx_buf = ts->xfer_tx_data, + .rx_buf = ts->xfer_rx_data + }; + + spi_message_init(&msg); + spi_message_add_tail(&xfer, &msg); + + for (retry_cnt = 0; retry_cnt < HIMAX_BUS_RETRY; retry_cnt++) { + ret = spi_sync(ts->spi, &msg); + if (!ret) + break; + } + + if (retry_cnt == HIMAX_BUS_RETRY) { + dev_err(ts->dev, "%s: SPI read error retry over %d\n", __func__, HIMAX_BUS_RETRY); + return -EIO; + } + + if (ret < 0) + return ret; + + if (msg.status < 0) + return msg.status; + + memcpy(buf, ts->xfer_rx_data + cmd_len, len); + + return 0; +} + +/** + * himax_spi_write() - Write data to SPI + * @ts: Himax touch screen data + * @tx_buf: Buffer to write + * @tx_len: Length of data to write + * @written: Length of data written + * + * Himax spi_sync wrapper for write. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_spi_write(struct himax_ts_data *ts, u8 *tx_buf, u32 tx_len, u32 *written) +{ + int ret; + struct spi_message msg; + struct spi_transfer xfer = { + .tx_buf = tx_buf, + .len = tx_len, + }; + + spi_message_init(&msg); + spi_message_add_tail(&xfer, &msg); + + *written = 0; + ret = spi_sync(ts->spi, &msg); + + if (ret < 0) + return ret; + + if (msg.status < 0) + return msg.status; + + *written = msg.actual_length; + + return 0; +} + +/** + * himax_read() - Read data from Himax bus + * @ts: Himax touch screen data + * @cmd: Command to send + * @buf: Buffer to store data, caller should allocate the buffer + * @len: Length of data to read + * + * Basic read operation for Himax SPI bus. Which start with a 3 bytes command, + * 1st byte is the spi function select, 2nd byte is the command belong to the + * spi function and 3rd byte is the dummy byte for IC to process the command. + * + * The IC takes 1 basic operation at a time, so the read/write operation + * is proctected by rw_lock mutex_unlock. Also the buffer xfer_rx/tx_data is + * shared between read and write operation, protected by the same mutex lock. + * The xfer data limit by SPI constroller max xfer size + BUS_R/W_HLEN + * + * Return: 0 on success, negative error code on failure + */ +static int himax_read(struct himax_ts_data *ts, u8 cmd, u8 *buf, u32 len) +{ + int ret; + + if (len + HIMAX_BUS_R_HLEN > ts->spi_xfer_max_sz) { + dev_err(ts->dev, "%s, len[%u] is over %u\n", __func__, + len + HIMAX_BUS_R_HLEN, ts->spi_xfer_max_sz); + return -EINVAL; + } + + mutex_lock(&ts->rw_lock); + + memset(ts->xfer_rx_data, 0, HIMAX_BUS_R_HLEN + len); + ts->xfer_tx_data[0] = HIMAX_SPI_FUNCTION_READ; + ts->xfer_tx_data[1] = cmd; + ts->xfer_tx_data[2] = 0x00; + ret = himax_spi_read(ts, HIMAX_BUS_R_HLEN, buf, len); + + mutex_unlock(&ts->rw_lock); + if (ret < 0) + dev_err(ts->dev, "%s: failed = %d\n", __func__, ret); + + return ret; +} + +/** + * himax_write() - Write data to Himax bus + * @ts: Himax touch screen data + * @cmd: Command to send + * @addr: Address to write + * @data: Data to write + * @len: Length of data to write + * + * Basic write operation for Himax IC. Which start with a 2 bytes command, + * 1st byte is the spi function select and 2nd byte is the command belong to the + * spi function. Else is the data to write. + * + * The IC takes 1 basic operation at a time, so the read/write operation + * is proctected by rw_lock mutex_unlock. Also the buffer xfer_tx_data is + * shared between read and write operation, protected by the same mutex lock. + * The xfer data limit by SPI constroller max xfer size + HIMAX_BUS_W_HLEN + * + * Return: 0 on success, negative error code on failure + */ +static int himax_write(struct himax_ts_data *ts, u8 cmd, u8 *addr, const u8 *data, u32 len) +{ + int ret; + u8 offset; + u32 written; + u32 tmp_len; + + if (len + HIMAX_BUS_W_HLEN > ts->spi_xfer_max_sz) { + dev_err(ts->dev, "%s: len[%u] is over %u\n", __func__, + len + HIMAX_BUS_W_HLEN, ts->spi_xfer_max_sz); + return -EFAULT; + } + + mutex_lock(&ts->rw_lock); + + memset(ts->xfer_tx_data, 0, len + HIMAX_BUS_W_HLEN); + ts->xfer_tx_data[0] = HIMAX_SPI_FUNCTION_WRITE; + ts->xfer_tx_data[1] = cmd; + offset = HIMAX_BUS_W_HLEN; + tmp_len = len; + + if (addr) { + memcpy(ts->xfer_tx_data + offset, addr, 4); + offset += 4; + tmp_len -= 4; + } + + if (data) + memcpy(ts->xfer_tx_data + offset, data, tmp_len); + + ret = himax_spi_write(ts, ts->xfer_tx_data, len + HIMAX_BUS_W_HLEN, &written); + + mutex_unlock(&ts->rw_lock); + + if (ret < 0) { + dev_err(ts->dev, "%s: failed, ret = %d\n", __func__, ret); + return ret; + } + + if (written != len + HIMAX_BUS_W_HLEN) { + dev_err(ts->dev, "%s: actual write length mismatched: %u != %u\n", + __func__, written, len + HIMAX_BUS_W_HLEN); + return -EIO; + } + + return 0; +} + +/** + * himax_mcu_set_burst_mode() - Set burst mode for MCU + * @ts: Himax touch screen data + * @auto_add_4_byte: Enable auto add 4 byte mode + * + * Set burst mode for MCU, which is used for read/write data from/to MCU. + * HIMAX_AHB_ADDR_CONTI config the IC to take data continuously, + * HIMAX_AHB_ADDR_INCR4 config the IC to auto increment the address by 4 byte when + * each 4 bytes read/write. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_mcu_set_burst_mode(struct himax_ts_data *ts, bool auto_add_4_byte) +{ + int ret; + u8 tmp_data[HIMAX_REG_SZ]; + + tmp_data[0] = HIMAX_AHB_CMD_CONTI; + + ret = himax_write(ts, HIMAX_AHB_ADDR_CONTI, NULL, tmp_data, 1); + if (ret < 0) { + dev_err(ts->dev, "%s: write ahb_addr_conti failed\n", __func__); + return ret; + } + + tmp_data[0] = HIMAX_AHB_CMD_INCR4; + if (auto_add_4_byte) + tmp_data[0] |= HIMAX_AHB_CMD_INCR4_ADD_4_BYTE; + + ret = himax_write(ts, HIMAX_AHB_ADDR_INCR4, NULL, tmp_data, 1); + if (ret < 0) + dev_err(ts->dev, "%s: write ahb_addr_incr4 failed\n", __func__); + + return ret; +} + +/** + * himax_burst_mode_enable() - Enable burst mode for MCU if possible + * @ts: Himax touch screen data + * @addr: Address to read/write + * @len: Length of data to read/write + * + * Enable burst mode for MCU, helper function to determine the burst mode + * operation for MCU. When the address is HIMAX_REG_ADDR_SPI200_DATA, the burst + * mode is disabled. When the length of data is over HIMAX_REG_SZ, the burst + * mode is enabled. Else the burst mode is disabled. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_burst_mode_enable(struct himax_ts_data *ts, u32 addr, u32 len) +{ + int ret; + + if (addr == HIMAX_REG_ADDR_SPI200_DATA) + ret = himax_mcu_set_burst_mode(ts, false); + else if (len > HIMAX_REG_SZ) + ret = himax_mcu_set_burst_mode(ts, true); + else + ret = himax_mcu_set_burst_mode(ts, false); + + if (ret) + dev_err(ts->dev, "%s: burst enable fail!\n", __func__); + + return ret; +} + +/** + * himax_mcu_register_read() - Read data from IC register/sram + * @ts: Himax touch screen data + * @addr: Address to read + * @buf: Buffer to store data, caller should allocate the buffer + * @len: Length of data to read + * + * Himax TP IC has its internal register and SRAM, this function is used to + * read data from it. The reading protocol require a sequence of write and read, + * which include write address to IC and read data from IC. Thus the read/write + * operation is proctected by reg_lock mutex_unlock to protect the sequence. + * The first step is to set the burst mode for MCU, then write the address to + * AHB register to tell where to read. Then set the access direction to read, + * and read the data from AHB register. The max length of data to read is decided + * by AHB register max transfer size, but if it could't bigger then SPI controller + * max transfer size. When the length of data is over the max transfer size, + * the data will be read in multiple times. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_mcu_register_read(struct himax_ts_data *ts, u32 addr, u8 *buf, u32 len) +{ + int i; + int ret; + u8 direction_switch = HIMAX_AHB_CMD_ACCESS_DIRECTION_READ; + u32 read_sz; + const u32 max_trans_sz = + min(HIMAX_HX83102J_REG_XFER_MAX, ts->spi_xfer_max_sz - HIMAX_BUS_R_HLEN); + union himax_dword_data target_addr; + + mutex_lock(&ts->reg_lock); + + ret = himax_burst_mode_enable(ts, addr, len); + if (ret) + goto read_end; + + for (i = 0; i < len; i += read_sz) { + target_addr.dword = cpu_to_le32(addr + i); + ret = himax_write(ts, HIMAX_AHB_ADDR_BYTE_0, target_addr.byte, NULL, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: write ahb_addr_byte_0 failed\n", __func__); + goto read_end; + } + + ret = himax_write(ts, HIMAX_AHB_ADDR_ACCESS_DIRECTION, NULL, + &direction_switch, 1); + if (ret < 0) { + dev_err(ts->dev, "%s: write ahb_addr_access_direction failed\n", __func__); + goto read_end; + } + + read_sz = min((len - i), max_trans_sz); + ret = himax_read(ts, HIMAX_AHB_ADDR_RDATA_BYTE_0, buf + i, read_sz); + if (ret < 0) { + dev_err(ts->dev, "%s: read ahb_addr_rdata_byte_0 failed\n", __func__); + goto read_end; + } + } + +read_end: + mutex_unlock(&ts->reg_lock); + if (ret < 0) + dev_err(ts->dev, "%s: addr = 0x%08X, len = %u, ret = %d\n", __func__, + addr, len, ret); + + return ret; +} + +/** + * himax_mcu_register_write() - Write data to IC register/sram + * @ts: Himax touch screen data + * @addr: Address to write + * @buf: Data to write + * @len: Length of data to write + * + * Himax TP IC has its internal register and SRAM, this function is used to + * write data to it. The writing protocol require a sequence of write, which + * include write address to IC and write data to IC. Thus the write operation + * is proctected by reg_lock mutex_unlock to protect the sequence. The first + * step is to set the burst mode for MCU, then write the address and data to + * AHB register. The max length of data to read is decided by AHB register max + * transfer size, but if it could't bigger then SPI controller max transfer + * size. When the length of data is over the max transfer size, the data will + * be written in multiple times. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_mcu_register_write(struct himax_ts_data *ts, u32 addr, const u8 *buf, u32 len) +{ + int i; + int ret; + u32 write_sz; + const u32 max_trans_sz = min(HIMAX_HX83102J_REG_XFER_MAX, + ts->spi_xfer_max_sz - HIMAX_BUS_W_HLEN - HIMAX_REG_SZ); + union himax_dword_data target_addr; + + mutex_lock(&ts->reg_lock); + + ret = himax_burst_mode_enable(ts, addr, len); + if (ret) + goto write_end; + + for (i = 0; i < len; i += max_trans_sz) { + write_sz = min((len - i), max_trans_sz); + target_addr.dword = cpu_to_le32(addr + i); + ret = himax_write(ts, HIMAX_AHB_ADDR_BYTE_0, + target_addr.byte, buf + i, write_sz + HIMAX_REG_SZ); + if (ret < 0) { + dev_err(ts->dev, "%s: write ahb_addr_byte_0 failed\n", __func__); + break; + } + } + +write_end: + mutex_unlock(&ts->reg_lock); + if (ret < 0) + dev_err(ts->dev, "%s: addr = 0x%08X, len = %u, ret = %d\n", __func__, + addr, len, ret); + + return ret; +} + +/** + * himax_mcu_interface_on() - Wakeup IC bus interface + * @ts: Himax touch screen data + * + * This function is used to wakeup IC bus interface. The IC may enter sleep mode + * and need to wakeup before any operation. The wakeup process is to read a dummy + * AHB register to wakeup the IC bus interface. Also, the function setup the burst + * mode as default for MCU and read back the burst mode setting to confirm the + * setting is written. The action is a double check to confirm the IC bus interface + * is ready for operation. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_mcu_interface_on(struct himax_ts_data *ts) +{ + int ret; + u8 buf[2][HIMAX_REG_SZ]; + u32 retry_cnt; + const u32 burst_retry_limit = 10; + + mutex_lock(&ts->reg_lock); + /* Read a dummy register to wake up BUS. */ + ret = himax_read(ts, HIMAX_AHB_ADDR_RDATA_BYTE_0, buf[0], 4); + mutex_unlock(&ts->reg_lock); + if (ret < 0) { + dev_err(ts->dev, "%s: read ahb_addr_rdata_byte_0 failed\n", __func__); + return ret; + } + + for (retry_cnt = 0; retry_cnt < burst_retry_limit; retry_cnt++) { + /* AHB: read/write to SRAM in sequential order */ + buf[0][0] = HIMAX_AHB_CMD_CONTI; + ret = himax_write(ts, HIMAX_AHB_ADDR_CONTI, NULL, buf[0], 1); + if (ret < 0) { + dev_err(ts->dev, "%s: write ahb_addr_conti failed\n", __func__); + return ret; + } + + /* AHB: Auto increment SRAM addr+4 while each 4 bytes read/write */ + buf[0][0] = HIMAX_AHB_CMD_INCR4; + ret = himax_write(ts, HIMAX_AHB_ADDR_INCR4, NULL, buf[0], 1); + if (ret < 0) { + dev_err(ts->dev, "%s: write ahb_addr_incr4 failed\n", __func__); + return ret; + } + + /* Check cmd */ + ret = himax_read(ts, HIMAX_AHB_ADDR_CONTI, buf[0], 1); + if (ret < 0) { + dev_err(ts->dev, "%s: read ahb_addr_conti failed\n", __func__); + return ret; + } + + ret = himax_read(ts, HIMAX_AHB_ADDR_INCR4, buf[1], 1); + if (ret < 0) { + dev_err(ts->dev, "%s: read ahb_addr_incr4 failed\n", __func__); + return ret; + } + + if (buf[0][0] == HIMAX_AHB_CMD_CONTI && buf[1][0] == HIMAX_AHB_CMD_INCR4) + return 0; + + usleep_range(1000, 1100); + } + + dev_err(ts->dev, "%s: failed!\n", __func__); + + return -EIO; +} + +/** + * hx83102j_pin_reset() - Reset the touch chip by hardware pin + * @ts: Himax touch screen data + * + * This function is used to hardware reset the touch chip. By pull down the + * reset pin to low over 20ms, ensure the reset circuit perform a complete reset + * to the touch chip. + * + * Return: None + */ +static void hx83102j_pin_reset(struct himax_ts_data *ts) +{ + gpiod_set_value(ts->pdata.gpiod_rst, 1); + usleep_range(10000, 10100); + gpiod_set_value(ts->pdata.gpiod_rst, 0); + usleep_range(20000, 20100); +} + +/** + * himax_int_enable() - Enable/Disable interrupt + * @ts: Himax touch screen data + * @enable: true for enable, false for disable + * + * This function is used to enable or disable the interrupt. + * + * Return: None + */ +static void himax_int_enable(struct himax_ts_data *ts, bool enable) +{ + int irqnum = ts->himax_irq; + unsigned long flags; + + spin_lock_irqsave(&ts->irq_lock, flags); + if (enable && atomic_read(&ts->irq_state) == 0) { + atomic_set(&ts->irq_state, 1); + enable_irq(irqnum); + } else if (!enable && atomic_read(&ts->irq_state) == 1) { + atomic_set(&ts->irq_state, 0); + disable_irq_nosync(irqnum); + } + spin_unlock_irqrestore(&ts->irq_lock, flags); + dev_info(ts->dev, "%s: Interrupt %s\n", __func__, + atomic_read(&ts->irq_state) ? "enabled" : "disabled"); +} + +/** + * himax_mcu_ic_reset() - Reset the touch chip and disable/enable interrupt + * @ts: Himax touch screen data + * @int_off: true for disable/enable interrupt, false for not + * + * This function is used to reset the touch chip with interrupt control. The + * TPIC will pull low the interrupt pin when IC is reset. When the ISR has been + * set and need to be take care of, the caller could set int_off to true to disable + * the interrupt before reset and enable the interrupt after reset. + * + * Return: None + */ +static void himax_mcu_ic_reset(struct himax_ts_data *ts, bool int_off) +{ + if (int_off) + himax_int_enable(ts, false); + + hx83102j_pin_reset(ts); + + if (int_off) + himax_int_enable(ts, true); +} + +/** + * hx83102j_sense_off() - Stop MCU and enter safe mode + * @ts: Himax touch screen data + * @check_en: Check if need to ensure FW is stopped by its owne process + * + * Sense off is a process to make sure the MCU inside the touch chip is stopped. + * The process has two stage, first stage is to request FW to stop. Write + * HIMAX_REG_DATA_FW_GO_SAFEMODE to HIMAX_REG_ADDR_CTRL_FW tells the FW to stop by its own. + * Then read back the FW status to confirm the FW is stopped. When check_en is true, + * the function will resend the stop FW command until the retry limit reached. + * There maybe a chance that the FW is not stopped by its own, in this case, the + * safe mode in next stage still stop the MCU, but FW internal flag may not be + * configured correctly. The second stage is to enter safe mode and reset TCON. + * Safe mode is a mode that the IC circuit ensure the internal MCU is stopped. + * Since this IC is TDDI, the TCON need to be reset to make sure the IC is ready + * for next operation. + * + * Return: 0 on success, negative error code on failure + */ +static int hx83102j_sense_off(struct himax_ts_data *ts, bool check_en) +{ + int ret; + u32 retry_cnt; + const u32 stop_fw_retry_limit = 35; + const u32 enter_safe_mode_retry_limit = 5; + const union himax_dword_data safe_mode = { + .dword = cpu_to_le32(HIMAX_REG_DATA_FW_GO_SAFEMODE) + }; + union himax_dword_data data; + + dev_info(ts->dev, "%s: check %s\n", __func__, check_en ? "True" : "False"); + if (!check_en) + goto without_check; + + for (retry_cnt = 0; retry_cnt < stop_fw_retry_limit; retry_cnt++) { + if (retry_cnt == 0 || + (data.byte[0] != HIMAX_REG_DATA_FW_GO_SAFEMODE && + data.byte[0] != HIMAX_REG_DATA_FW_RE_INIT && + data.byte[0] != HIMAX_REG_DATA_FW_IN_SAFEMODE)) { + ret = himax_mcu_register_write(ts, HIMAX_REG_ADDR_CTRL_FW, + safe_mode.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: stop FW failed\n", __func__); + return ret; + } + } + usleep_range(10000, 11000); + + ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_FW_STATUS, data.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read central state failed\n", __func__); + return ret; + } + if (data.byte[0] != HIMAX_REG_DATA_FW_STATE_RUNNING) { + dev_info(ts->dev, "%s: Do not need wait FW, Status = 0x%02X!\n", __func__, + data.byte[0]); + break; + } + + ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_CTRL_FW, data.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read ctrl FW failed\n", __func__); + return ret; + } + if (data.byte[0] == HIMAX_REG_DATA_FW_IN_SAFEMODE) + break; + } + + if (data.byte[0] != HIMAX_REG_DATA_FW_IN_SAFEMODE) + dev_warn(ts->dev, "%s: Failed to stop FW!\n", __func__); + +without_check: + for (retry_cnt = 0; retry_cnt < enter_safe_mode_retry_limit; retry_cnt++) { + /* set Enter safe mode : 0x31 ==> 0x9527 */ + data.word[0] = cpu_to_le16(HIMAX_HX83102J_SAFE_MODE_PASSWORD); + ret = himax_write(ts, HIMAX_AHB_ADDR_PSW_LB, NULL, data.byte, 2); + if (ret < 0) { + dev_err(ts->dev, "%s: enter safe mode failed\n", __func__); + return ret; + } + + /* Check enter_save_mode */ + ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_FW_STATUS, data.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read central state failed\n", __func__); + return ret; + } + + if (data.byte[0] == HIMAX_REG_DATA_FW_STATE_SAFE_MODE) { + dev_info(ts->dev, "%s: Safe mode entered\n", __func__); + /* Reset TCON */ + data.dword = cpu_to_le32(HIMAX_REG_DATA_TCON_RST); + ret = himax_mcu_register_write(ts, HIMAX_HX83102J_REG_ADDR_TCON_RST, + data.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: reset TCON failed\n", __func__); + return ret; + } + usleep_range(1000, 1100); + return 0; + } + usleep_range(5000, 5100); + hx83102j_pin_reset(ts); + } + dev_err(ts->dev, "%s: failed!\n", __func__); + + return -EIO; +} + +/** + * hx83102j_chip_detect() - Check if the touch chip is HX83102J + * @ts: Himax touch screen data + * + * This function is used to check if the touch chip is HX83102J. The process + * start with a hardware reset to the touch chip, then knock the IC bus interface + * to wakeup the IC bus interface. Then sense off the MCU to prevent bus conflict + * when reading the IC ID. The IC ID is read from the IC register, and compare + * with the expected ID. If the ID is matched, the chip is HX83102J. Due to display + * IC initial code may not ready before the IC ID is read, the function will retry + * to read the IC ID for several times to make sure the IC ID is read correctly. + * In any case, the SPI bus shouldn't have error when reading the IC ID, so the + * function will return error if the SPI bus has error. When the IC is not HX83102J, + * the function will return -ENODEV. + * + * Return: 0 on success, negative error code on failure + */ +static int hx83102j_chip_detect(struct himax_ts_data *ts) +{ + int ret; + u32 retry_cnt; + const u32 read_icid_retry_limit = 5; + const u32 ic_id_mask = GENMASK(31, 8); + union himax_dword_data data; + + hx83102j_pin_reset(ts); + ret = himax_mcu_interface_on(ts); + if (ret) + return ret; + + ret = hx83102j_sense_off(ts, false); + if (ret) + return ret; + + for (retry_cnt = 0; retry_cnt < read_icid_retry_limit; retry_cnt++) { + ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_ICID, data.byte, 4); + if (ret) { + dev_err(ts->dev, "%s: Read IC ID Fail\n", __func__); + return ret; + } + + data.dword = le32_to_cpu(data.dword); + if ((data.dword & ic_id_mask) == HIMAX_REG_DATA_ICID) { + ts->ic_data.icid = data.dword; + dev_info(ts->dev, "%s: Detect IC HX83102J successfully\n", __func__); + return 0; + } + } + dev_err(ts->dev, "%s: Read driver ID register Fail! IC ID = %X,%X,%X\n", __func__, + data.byte[3], data.byte[2], data.byte[1]); + + return -ENODEV; +} + +/** + * himax_ts_thread() - Thread for interrupt handling + * @irq: Interrupt number + * @ptr: Pointer to the touch screen data + * + * This function is used to handle the interrupt. The function will call himax_ts_work() + * to handle the interrupt. + * + * Return: IRQ_HANDLED + */ +static irqreturn_t himax_ts_thread(int irq, void *ptr) +{ + himax_ts_work((struct himax_ts_data *)ptr); + + return IRQ_HANDLED; +} + +/** + * __himax_ts_register_interrupt() - Register interrupt trigger + * @ts: Himax touch screen data + * + * This function is used to register the interrupt. The function will call + * devm_request_threaded_irq() to register the interrupt by the trigger type. + * + * Return: 0 on success, negative error code on failure + */ +static int __himax_ts_register_interrupt(struct himax_ts_data *ts) +{ + if (ts->ic_data.interrupt_is_edge) + return devm_request_threaded_irq(ts->dev, ts->himax_irq, NULL, + himax_ts_thread, + IRQF_TRIGGER_FALLING | IRQF_ONESHOT, + ts->dev->driver->name, ts); + + return devm_request_threaded_irq(ts->dev, ts->himax_irq, NULL, + himax_ts_thread, + IRQF_TRIGGER_LOW | IRQF_ONESHOT, + ts->dev->driver->name, ts); +} + +/** + * himax_ts_register_interrupt() - Register interrupt + * @ts: Himax touch screen data + * + * This function is a wrapper to call __himax_ts_register_interrupt() to register the + * interrupt and set irq_state. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_ts_register_interrupt(struct himax_ts_data *ts) +{ + int ret; + + if (!ts || !ts->himax_irq) { + dev_err(ts->dev, "%s: ts or ts->himax_irq invalid!\n", __func__); + return -EINVAL; + } + + ret = __himax_ts_register_interrupt(ts); + if (!ret) { + atomic_set(&ts->irq_state, 1); + dev_info(ts->dev, "%s: irq enabled at: %d\n", __func__, ts->himax_irq); + return 0; + } + + atomic_set(&ts->irq_state, 0); + dev_err(ts->dev, "%s: request_irq failed\n", __func__); + + return ret; +} + +/** + * hx83102j_read_event_stack() - Read event stack from touch chip + * @ts: Himax touch screen data + * @buf: Buffer to store the data + * @length: Length of data to read + * + * This function is used to read the event stack from the touch chip. The event stack + * is an AHB output buffer, which store the touch report data. + * + * Return: 0 on success, negative error code on failure + */ +static int hx83102j_read_event_stack(struct himax_ts_data *ts, u8 *buf, u32 length) +{ + u32 i; + int ret; + const u32 max_trunk_sz = ts->spi_xfer_max_sz - HIMAX_BUS_R_HLEN; + + for (i = 0; i < length; i += max_trunk_sz) { + ret = himax_read(ts, HIMAX_AHB_ADDR_EVENT_STACK, buf + i, + min(length - i, max_trunk_sz)); + if (ret) { + dev_err(ts->dev, "%s: read event stack error!\n", __func__); + return ret; + } + } + + return 0; +} + +/** + * himax_touch_get() - Get touch data from touch chip + * @ts: Himax touch screen data + * @buf: Buffer to store the data + * + * This function is a wrapper to call hx83102j_read_event_stack() to read the touch + * data from the touch chip. The touch_data_sz is the size of the touch data to read, + * which is calculated by hid report descriptor provided by the firmware. + * + * Return: HIMAX_TS_SUCCESS on success, negative error code on failure. We categorize + * the error code into HIMAX_TS_GET_DATA_FAIL when the read fails, and HIMAX_TS_SUCCESS + * when the read is successful. The reason is that the may need special handling when + * the read fails. + */ +static int himax_touch_get(struct himax_ts_data *ts, u8 *buf) +{ + if (hx83102j_read_event_stack(ts, buf, ts->touch_data_sz)) { + dev_err(ts->dev, "can't read data from chip!"); + return HIMAX_TS_GET_DATA_FAIL; + } + + return HIMAX_TS_SUCCESS; +} + +/** + * himax_bin_desc_data_get() - Parse descriptor data from firmware token + * @ts: Himax touch screen data + * @addr: Address of the data in firmware image + * @descript_buf: token for parsing + * + * This function is used to parse the descriptor data from the firmware token. The + * descriptors are mappings of information in the firmware image. The function will + * check checksum of each token first, and then parse the token to get the related + * data. The data includes CID version, FW version, CFG version, touch config table, + * HID table, HID descriptor, and HID read descriptor. + * + * Return: true on success, false on failure + */ +static bool himax_bin_desc_data_get(struct himax_ts_data *ts, u32 addr, u8 *descript_buf) +{ + u16 chk_end; + u16 chk_sum; + u32 hid_table_addr; + u32 i, j; + u32 image_offset; + u32 map_code; + const u32 data_sz = 16; + const u32 report_desc_offset = 24; + union { + u8 *buf; + u32 *word; + } map_data; + + /* looking for mapping in page, each mapping is 16 bytes */ + for (i = 0; i < HIMAX_HX83102J_PAGE_SIZE; i = i + data_sz) { + chk_end = 0; + chk_sum = 0; + for (j = i; j < (i + data_sz); j++) { + chk_end |= descript_buf[j]; + chk_sum += descript_buf[j]; + } + if (!chk_end) { /* 1. Check all zero */ + return false; + } else if (chk_sum % 0x100) { /* 2. Check sum */ + dev_warn(ts->dev, "%s: chk sum failed in %X\n", __func__, i + addr); + } else { /* 3. get data */ + map_data.buf = &descript_buf[i]; + map_code = le32_to_cpup(map_data.word); + map_data.buf = &descript_buf[i + 4]; + image_offset = le32_to_cpup(map_data.word); + /* 4. load info from FW image by specified mapping offset */ + switch (map_code) { + /* Config ID */ + case HIMAX_FW_CID: + ts->fw_info_table.addr_cid_ver_major = image_offset; + ts->fw_info_table.addr_cid_ver_minor = image_offset + 1; + break; + /* FW version */ + case HIMAX_FW_VER: + ts->fw_info_table.addr_fw_ver_major = image_offset; + ts->fw_info_table.addr_fw_ver_minor = image_offset + 1; + break; + /* Config version */ + case HIMAX_CFG_VER: + ts->fw_info_table.addr_cfg_ver_major = image_offset; + ts->fw_info_table.addr_cfg_ver_minor = image_offset + 1; + break; + /* Touch config table */ + case HIMAX_TP_CONFIG_TABLE: + ts->fw_info_table.addr_cfg_table = image_offset; + break; + /* HID table */ + case HIMAX_HID_TABLE: + ts->fw_info_table.addr_hid_table = image_offset; + hid_table_addr = image_offset; + ts->fw_info_table.addr_hid_desc = hid_table_addr; + ts->fw_info_table.addr_hid_rd_desc = + hid_table_addr + report_desc_offset; + break; + } + } + } + + return true; +} + +/** + * himax_mcu_bin_desc_get() - Check and get the bin description from the data + * @fw: Firmware data + * @ts: Himax touch screen data + * @max_sz: Maximum size to check + * + * This function is used to check and get the bin description from the firmware data. + * It will check the given data to see if it match the bin description format, and + * call himax_bin_desc_data_get() to get the related data. + * + * Return: true on mapping_count > 0, false on otherwise + */ +static bool himax_mcu_bin_desc_get(unsigned char *fw, struct himax_ts_data *ts, u32 max_sz) +{ + bool keep_on_flag; + u32 addr; + u32 mapping_count; + unsigned char *fw_buf; + const u8 header_id = 0x87; + const u8 header_id_loc = 0x0e; + const u8 header_sz = 8; + const u8 header[8] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + /* Check bin is with description table or not */ + if (!(memcmp(fw, header, header_sz) == 0 && fw[header_id_loc] == header_id)) { + dev_err(ts->dev, "%s: No description table\n", __func__); + return false; + } + + for (addr = 0, mapping_count = 0; addr < max_sz; addr += HIMAX_HX83102J_PAGE_SIZE) { + fw_buf = &fw[addr]; + /* Get related data */ + keep_on_flag = himax_bin_desc_data_get(ts, addr, fw_buf); + if (keep_on_flag) + mapping_count++; + else + break; + } + + return mapping_count > 0; +} + +/** + * himax_hid_parse() - Parse the HID report descriptor + * @hid: HID device + * + * This function is used to parse the HID report descriptor. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_hid_parse(struct hid_device *hid) +{ + int ret; + struct himax_ts_data *ts; + + if (!hid) + return -ENODEV; + + ts = hid->driver_data; + if (!ts) + return -EINVAL; + + ret = hid_parse_report(hid, ts->hid_rd_data.rd_data, ts->hid_rd_data.rd_length); + if (ret) { + dev_err(ts->dev, "%s: failed parse report\n", __func__); + return ret; + } + + return 0; +} + +/** + * himax_hid_start - Start the HID device + * @hid: HID device + * + * The function for hid_ll_driver.start to start the HID device. + * This driver does not need to do anything here. + * + * Return: 0 for success + */ +static int himax_hid_start(struct hid_device *hid) +{ + return 0; +} + +/** + * himax_hid_stop - Stop the HID device + * @hid: HID device + * + * The function for hid_ll_driver.stop to stop the HID device. + * This driver does not need to do anything here. + * + * Return: None + */ +static void himax_hid_stop(struct hid_device *hid) +{ +} + +/** + * himax_hid_open - Open the HID device + * @hid: HID device + * + * The function for hid_ll_driver.open to open the HID device. + * This driver does not need to do anything here. + * + * Return: 0 for success + */ +static int himax_hid_open(struct hid_device *hid) +{ + return 0; +} + +/** + * himax_hid_close - Close the HID device + * @hid: HID device + * + * The function for hid_ll_driver.close to close the HID device. + * This driver does not need to do anything here. + * + * Return: None + */ +static void himax_hid_close(struct hid_device *hid) +{ +} + +/** + * himax_hid_get_raw_report - Process hidraw GET REPORT operation + * @hid: HID device + * @reportnum: Report ID + * @buf: Buffer for communication + * @len: Length of data in the buffer + * @report_type: Report type + * + * The function for hid_ll_driver.get_raw_report to handle the HIDRAW ioctl + * get report request. The report number to handle is based on the report + * descriptor of the HID device. The buf is used to communicate with user + * program, user pass the ID and parameters to the driver use this buf, and + * the driver will return the result to user also use this buf. The len is + * the length of data in the buf, passed by user program. The report_type is + * not used in this driver. We currently support the following report number: + * - HIMAX_ID_CONTACT_COUNT: Report the maximum number of touch points + * Case not listed here will return -EINVAL. + * + * Return: The length of the data in the buf on success, negative error code + */ +static int himax_hid_get_raw_report(const struct hid_device *hid, + unsigned char reportnum, __u8 *buf, + size_t len, unsigned char report_type) +{ + int ret; + struct himax_ts_data *ts; + + ts = hid->driver_data; + if (!ts) { + dev_err(ts->dev, "hid->driver_data is NULL"); + return -EINVAL; + } + + switch (reportnum) { + case HIMAX_ID_CONTACT_COUNT: + /* buf[0] is ID; buf[1] and later used as parameters for ID */ + buf[0] = HIMAX_ID_CONTACT_COUNT; + buf[1] = ts->ic_data.max_point; + ret = len; + break; + default: + dev_err(ts->dev, "%s: Invalid report number\n", __func__); + ret = -EINVAL; + break; + }; + + return ret; +} + +/** + * himax_raw_request - Handle the HIDRAW ioctl request + * @hid: HID device + * @reportnum: Report ID + * @buf: Buffer for communication + * @len: Length of data in the buffer + * @rtype: Report type + * @reqtype: Request type + * + * The function for hid_ll_driver.raw_request to handle the HIDRAW ioctl + * request. We handle only the GET_REPORT and SET_REPORT request. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_raw_request(struct hid_device *hid, unsigned char reportnum, __u8 *buf, + size_t len, unsigned char rtype, int reqtype) +{ + int ret; + + switch (reqtype) { + case HID_REQ_GET_REPORT: + ret = himax_hid_get_raw_report(hid, reportnum, buf, len, rtype); + break; + default: + ret = -EINVAL; + } + + return ret; +} + +static struct hid_ll_driver himax_hid_ll_driver = { + .parse = himax_hid_parse, + .start = himax_hid_start, + .stop = himax_hid_stop, + .open = himax_hid_open, + .close = himax_hid_close, + .raw_request = himax_raw_request +}; + +/** + * himax_hid_report() - Report input data to HID core + * @ts: Himax touch screen data + * @data: Data to report + * @len: Length of the data + * + * This function is a wrapper to report input data to HID core. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_hid_report(const struct himax_ts_data *ts, u8 *data, s32 len) +{ + return hid_input_report(ts->hid, HID_INPUT_REPORT, data, len, 1); +} + +/** + * himax_hid_probe() - Probe the HID device + * @ts: Himax touch screen data + * + * This function is used to probe the HID device. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_hid_probe(struct himax_ts_data *ts) +{ + int ret; + struct hid_device *hid; + + hid = ts->hid; + if (hid) { + dev_warn(ts->dev, "%s: hid device already exist!\n", __func__); + hid_destroy_device(hid); + hid = NULL; + } + + hid = hid_allocate_device(); + if (IS_ERR(hid)) { + ret = PTR_ERR(hid); + return ret; + } + + hid->driver_data = ts; + hid->ll_driver = &himax_hid_ll_driver; + hid->bus = BUS_SPI; + hid->dev.parent = &ts->spi->dev; + + hid->version = ts->hid_desc.bcd_version; + hid->vendor = ts->hid_desc.vendor_id; + hid->product = ts->hid_desc.product_id; + snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X", "hid-hxtp", + hid->vendor, hid->product); + + ret = hid_add_device(hid); + if (ret) { + dev_err(ts->dev, "%s: failed add hid device\n", __func__); + goto err_hid_data; + } + ts->hid = hid; + + return 0; + +err_hid_data: + hid_destroy_device(hid); + + return ret; +} + +/** + * himax_hid_remove() - Remove the HID device + * @ts: Himax touch screen data + * + * This function is used to remove the HID device. + * + * Return: None + */ +static void himax_hid_remove(struct himax_ts_data *ts) +{ + if (ts && ts->hid) + hid_destroy_device(ts->hid); + else + return; + + ts->hid = NULL; +} + +/** + * himax_ts_operation() - Process the touch interrupt data + * @ts: Himax touch screen data + * + * This function is used to process the touch interrupt data. It will + * call the himax_touch_get() to get the touch data. + * If the hid is probed, it will call the himax_hid_report() to report the + * touch data to the HID core. Due to the report data must match the HID + * report descriptor, the size of report data is fixed. To prevent next report + * data being contaminated by the previous data, all the data must be reported + * wheather previous data is valid or not. + * + * Return: HIMAX_TS_SUCCESS on success, negative error code in + * himax_touch_report_status on failure + */ +static int himax_ts_operation(struct himax_ts_data *ts) +{ + int ret; + u32 offset; + + memset(ts->xfer_buf, 0x00, ts->xfer_buf_sz); + ret = himax_touch_get(ts, ts->xfer_buf); + if (ret == HIMAX_TS_GET_DATA_FAIL) + return ret; + if (ts->hid_probed) { + offset = ts->hid_desc.max_input_length; + if (ts->ic_data.stylus_function) { + ret += himax_hid_report(ts, + ts->xfer_buf + offset + HIMAX_HID_REPORT_HDR_SZ, + ts->hid_desc.max_input_length - + HIMAX_HID_REPORT_HDR_SZ); + offset += ts->hid_desc.max_input_length; + } + } + + if (ret != 0) + return HIMAX_TS_GET_DATA_FAIL; + + return HIMAX_TS_SUCCESS; +} + +/** + * himax_ts_work() - Work function for the touch screen + * @ts: Himax touch screen data + * + * This function is used to handle interrupt bottom half work. It will + * call the himax_ts_operation() to get the touch data, dispatch the data + * to HID core. If the touch data is not valid, it will reset the TPIC. + * + * Return: void + */ +static void himax_ts_work(struct himax_ts_data *ts) +{ + if (himax_ts_operation(ts) == HIMAX_TS_GET_DATA_FAIL) { + dev_info(ts->dev, "%s: Now reset the Touch chip\n", __func__); + himax_mcu_ic_reset(ts, true); + } +} + +/** + * himax_hid_rd_init() - Initialize the HID report descriptor + * @ts: Himax touch screen data + * + * The function is used to calculate the size of the HID report descriptor, + * allocate the memory and copy the report descriptor from firmware data to + * the allocated memory for later hid device registration. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_hid_rd_init(struct himax_ts_data *ts) +{ + u32 rd_sz; + + /* The rd_sz is taken from RD size in FW hid report table. */ + rd_sz = ts->hid_desc.report_desc_length; + /* fw_info_table should contain address of hid_rd_desc in FW image */ + if (ts->fw_info_table.addr_hid_rd_desc != 0) { + /* if rd_sz has been change, need to release old one */ + if (ts->hid_rd_data.rd_data && + rd_sz != ts->hid_rd_data.rd_length) { + devm_kfree(ts->dev, ts->hid_rd_data.rd_data); + ts->hid_rd_data.rd_data = NULL; + } + + if (!ts->hid_rd_data.rd_data) { + ts->hid_rd_data.rd_data = devm_kzalloc(ts->dev, rd_sz, GFP_KERNEL); + if (!ts->hid_rd_data.rd_data) + return -ENOMEM; + } + /* Copy the base RD from firmware table */ + memcpy((void *)ts->hid_rd_data.rd_data, + &ts->himax_fw_data[ts->fw_info_table.addr_hid_rd_desc], + ts->hid_desc.report_desc_length); + ts->hid_rd_data.rd_length = ts->hid_desc.report_desc_length; + } + + return 0; +} + +/** + * himax_hid_register() - Register the HID device + * @ts: Himax touch screen data + * + * The function is used to register the HID device. If the hid is probed, + * it will destroy the previous hid device and re-probe the hid device. + * + * Return: None + */ +static void himax_hid_register(struct himax_ts_data *ts) +{ + if (ts->hid_probed) { + hid_destroy_device(ts->hid); + ts->hid = NULL; + ts->hid_probed = false; + } + + if (himax_hid_probe(ts)) { + dev_err(ts->dev, "%s: hid probe fail\n", __func__); + ts->hid_probed = false; + } else { + ts->hid_probed = true; + } +} + +/** + * himax_hid_report_data_init() - Calculate the size of the HID report data + * @ts: Himax touch screen data + * + * The function is used to calculate the final size of the HID report data. + * The base size is equal to the max_input_length of the hid descriptor. + * If the size of the HID report data is not equal to the previous size, it + * will free the previous allocated memory and allocate the new memory which + * size is equal to the final size of touch_data_sz. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_hid_report_data_init(struct himax_ts_data *ts) +{ + ts->touch_data_sz = ts->hid_desc.max_input_length; + if (ts->ic_data.stylus_function) + ts->touch_data_sz += ts->hid_desc.max_input_length; + if (ts->touch_data_sz != ts->xfer_buf_sz) { + kfree(ts->xfer_buf); + ts->xfer_buf_sz = 0; + ts->xfer_buf = kzalloc(ts->touch_data_sz, GFP_KERNEL); + if (!ts->xfer_buf) + return -ENOMEM; + ts->xfer_buf_sz = ts->touch_data_sz; + } + + return 0; +} + +/** + * himax_power_set() - Set the power supply of touch screen + * @ts: Himax touch screen data + * @en: enable/disable regualtor + * + * This function is used to set the power supply of touch screen. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_power_set(struct himax_ts_data *ts, bool en) +{ + int ret; + struct himax_platform_data *pdata = &ts->pdata; + + if (pdata->vccd_supply) { + if (en) + ret = regulator_enable(pdata->vccd_supply); + else + ret = regulator_disable(pdata->vccd_supply); + if (ret) { + dev_err(ts->dev, "%s: unable to %s vccd supply\n", __func__, + en ? "enable" : "disable"); + return ret; + } + } + + if (pdata->vccd_supply) + usleep_range(2000, 2100); + + return 0; +} + +/** + * himax_power_deconfig() - De-configure the power supply of touchsreen + * @pdata: Himax platform data + * + * This function is used to de-configure the power supply of touch screen. + * + * Return: None + */ +static void himax_power_deconfig(struct himax_platform_data *pdata) +{ + if (pdata->vccd_supply) { + regulator_disable(pdata->vccd_supply); + regulator_put(pdata->vccd_supply); + } +} + +/* load firmware data from flash, parse HID info and register HID */ +/** + * himax_load_config() - Load the firmware from the flash + * @ts: Himax touch screen data + * + * This function is used to load the firmware from the flash. It will read + * the firmware from the flash and parse the HID info. If the HID info is + * valid, it will initialize the HID report descriptor and register the HID + * device. If the HID device is probed, it will initialize the report data + * and enable the interrupt. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_load_config(struct himax_ts_data *ts) +{ + int ret; + s32 i; + s32 page_sz = (s32)HIMAX_HX83102J_PAGE_SIZE; + s32 flash_sz = (s32)HIMAX_HX83102J_FLASH_SIZE; + bool fw_load_status = false; + const u32 fw_bin_header_sz = 1024; + + ts->ic_boot_done = false; + + ts->himax_fw_data = devm_kzalloc(ts->dev, HIMAX_HX83102J_FLASH_SIZE, GFP_KERNEL); + if (!ts->himax_fw_data) + return -ENOMEM; + + for (i = 0; i < flash_sz; i += page_sz) { + ret = himax_mcu_register_read(ts, i, ts->himax_fw_data + i, + (flash_sz - i) > page_sz ? page_sz : (flash_sz - i)); + if (ret < 0) { + dev_err(ts->dev, "%s: read FW from flash fail!\n", __func__); + return ret; + } + } + /* Search mapping table in 1k header */ + fw_load_status = himax_mcu_bin_desc_get((unsigned char *)ts->himax_fw_data, + ts, fw_bin_header_sz); + if (!fw_load_status) { + dev_err(ts->dev, "%s: FW load status fail!\n", __func__); + return -EINVAL; + } + + if (ts->fw_info_table.addr_hid_desc != 0) { + memcpy(&ts->hid_desc, + &ts->himax_fw_data[ts->fw_info_table.addr_hid_desc], + sizeof(struct himax_hid_desc)); + ts->hid_desc.desc_length = + le16_to_cpu(ts->hid_desc.desc_length); + ts->hid_desc.bcd_version = + le16_to_cpu(ts->hid_desc.bcd_version); + ts->hid_desc.report_desc_length = + le16_to_cpu(ts->hid_desc.report_desc_length); + ts->hid_desc.max_input_length = + le16_to_cpu(ts->hid_desc.max_input_length); + ts->hid_desc.max_output_length = + le16_to_cpu(ts->hid_desc.max_output_length); + ts->hid_desc.max_fragment_length = + le16_to_cpu(ts->hid_desc.max_fragment_length); + ts->hid_desc.vendor_id = + le16_to_cpu(ts->hid_desc.vendor_id); + ts->hid_desc.product_id = + le16_to_cpu(ts->hid_desc.product_id); + ts->hid_desc.version_id = + le16_to_cpu(ts->hid_desc.version_id); + ts->hid_desc.flags = + le16_to_cpu(ts->hid_desc.flags); + } + + if (himax_hid_rd_init(ts)) { + dev_err(ts->dev, "%s: hid rd init fail\n", __func__); + goto err_hid_rd_init_failed; + } + + himax_hid_register(ts); + if (!ts->hid_probed) { + goto err_hid_probe_failed; + } else { + if (himax_hid_report_data_init(ts)) { + dev_err(ts->dev, "%s: report data init fail\n", __func__); + goto err_report_data_init_failed; + } + } + + ts->himax_fw_data = NULL; + ts->ic_boot_done = true; + himax_int_enable(ts, true); + + return 0; + +err_report_data_init_failed: + himax_hid_remove(ts); + ts->hid_probed = false; +err_hid_probe_failed: +err_hid_rd_init_failed: + + return -EINVAL; +} + +/** + * himax_chip_init() - Initialize the Himax touch screen + * @ts: Himax touch screen data + * + * This function is used to initialize the Himax touch screen. It will + * initialize interrupt lock, register the interrupt, and disable the + * interrupt. If later part of initialization succeed, then interrupt will + * be enabled. + * It will also load the firmware from the flash, parse the HID info, and + * register the HID device by calling the himax_load_config(). + * + * Return: 0 on success, negative error code on failure + */ +static int himax_chip_init(struct himax_ts_data *ts) +{ + int ret; + + if (himax_ts_register_interrupt(ts)) { + dev_err(ts->dev, "%s: register interrupt failed\n", __func__); + return -EIO; + } + himax_int_enable(ts, false); + ret = himax_load_config(ts); + if (ret < 0) + return ret; + ts->initialized = true; + + return 0; +} + +/** + * himax_platform_deinit() - Deinitialize the platform related settings + * @ts: Pointer to the himax_ts_data structure + * + * This function deinitializes the platform related settings, frees the + * xfer_buf. + * + * Return: None + */ +static void himax_platform_deinit(struct himax_ts_data *ts) +{ + struct himax_platform_data *pdata = &ts->pdata; + + if (ts->xfer_buf_sz) { + kfree(ts->xfer_buf); + ts->xfer_buf = NULL; + ts->xfer_buf_sz = 0; + } + himax_power_deconfig(pdata); +} + +/** + * himax_platform_init - Initialize the platform related settings + * @ts: Pointer to the himax_ts_data structure + * + * This function initializes the platform related settings. + * The xfer_buf is used for interrupt data receive. gpio reset pin is set to + * active and then deactivate to reset the IC. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_platform_init(struct himax_ts_data *ts) +{ + int ret; + struct himax_platform_data *pdata = &ts->pdata; + + ts->xfer_buf_sz = 0; + ts->xfer_buf = kzalloc(HIMAX_HX83102J_FULL_STACK_SZ, GFP_KERNEL); + if (!ts->xfer_buf) + return -ENOMEM; + ts->xfer_buf_sz = HIMAX_HX83102J_FULL_STACK_SZ; + + gpiod_set_value(pdata->gpiod_rst, 1); + ret = himax_power_set(ts, true); + if (ret) { + dev_err(ts->dev, "%s: gpio power config failed\n", __func__); + return ret; + } + + usleep_range(2000, 2100); + gpiod_set_value(pdata->gpiod_rst, 0); + + return 0; +} + +/** + * himax_spi_drv_probe - Probe function for the SPI driver + * @spi: Pointer to the spi_device structure + * + * This function is called when the SPI driver is probed. It initializes the + * himax_ts_data structure and assign the settings from spi device to + * himax_ts_data. The buffer for SPI transfer is allocate here. The SPI + * transfer settings also setup before any communication starts. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_spi_drv_probe(struct spi_device *spi) +{ + int ret; + struct himax_ts_data *ts; + static struct himax_platform_data *pdata; + + dev_info(&spi->dev, "%s: Himax SPI driver probe\n", __func__); + ts = devm_kzalloc(&spi->dev, sizeof(struct himax_ts_data), GFP_KERNEL); + if (!ts) + return -ENOMEM; + if (spi->master->flags & SPI_MASTER_HALF_DUPLEX) { + dev_err(ts->dev, "%s: Full duplex not supported by host\n", __func__); + return -EIO; + } + pdata = &ts->pdata; + ts->dev = &spi->dev; + if (!spi->irq) { + dev_err(ts->dev, "%s: no IRQ?\n", __func__); + return -EINVAL; + } + ts->himax_irq = spi->irq; + pdata->gpiod_rst = devm_gpiod_get(ts->dev, "reset", GPIOD_OUT_HIGH); + if (IS_ERR(pdata->gpiod_rst)) { + dev_err(ts->dev, "%s: gpio-rst value is not valid\n", __func__); + return -EIO; + } + + spi->bits_per_word = 8; + spi->mode = SPI_MODE_3; + spi->cs_setup.value = HIMAX_SPI_CS_SETUP_TIME; + + ts->spi = spi; + /* + * The max_transfer_size is used to allocate the buffer for SPI transfer. + * The size should be given by the SPI master driver, but if not available + * then use the HIMAX_MAX_TP_EV_STACK_SZ as default. Which is the least size for + * each TP event data. + */ + if (spi->master->max_transfer_size) + ts->spi_xfer_max_sz = spi->master->max_transfer_size(spi); + else + ts->spi_xfer_max_sz = HIMAX_MAX_TP_EV_STACK_SZ; + + ts->spi_xfer_max_sz = min(ts->spi_xfer_max_sz, HIMAX_BUS_RW_MAX_LEN); + /* SPI full-duplex rx_buf and tx_buf should be equal */ + ts->xfer_rx_data = devm_kzalloc(ts->dev, ts->spi_xfer_max_sz, GFP_KERNEL); + if (!ts->xfer_rx_data) + return -ENOMEM; + + ts->xfer_tx_data = devm_kzalloc(ts->dev, ts->spi_xfer_max_sz, GFP_KERNEL); + if (!ts->xfer_tx_data) + return -ENOMEM; + + spin_lock_init(&ts->irq_lock); + mutex_init(&ts->rw_lock); + mutex_init(&ts->reg_lock); + dev_set_drvdata(&spi->dev, ts); + spi_set_drvdata(spi, ts); + + ts->probe_finish = false; + ts->initialized = false; + ts->ic_boot_done = false; + + ret = himax_platform_init(ts); + if (ret) { + dev_err(ts->dev, "%s: platform init failed\n", __func__); + return ret; + } + + ret = hx83102j_chip_detect(ts); + if (ret) { + dev_err(ts->dev, "%s: IC detect failed\n", __func__); + return ret; + } + + ret = himax_chip_init(ts); + if (ret < 0) + return ret; + ts->probe_finish = true; + + return ret; + himax_platform_deinit(ts); +} + +/** + * himax_spi_drv_remove - Remove function for the SPI driver + * @spi: Pointer to the spi_device structure + * + * This function is called when the SPI driver is removed. It deinitializes the + * himax_ts_data structure and free the resources allocated for the SPI + * communication. + */ +static void himax_spi_drv_remove(struct spi_device *spi) +{ + struct himax_ts_data *ts = spi_get_drvdata(spi); + + if (ts->probe_finish) { + if (ts->ic_boot_done) { + himax_int_enable(ts, false); + + if (ts->hid_probed) + himax_hid_remove(ts); + } + himax_platform_deinit(ts); + } +} + +/** + * himax_shutdown - Shutdown the touch screen + * @spi: Himax touch screen spi device + * + * This function is used to shutdown the touch screen. It will disable the + * interrupt, set the reset pin to activate state. Then remove the hid device. + * + * Return: None + */ +static void himax_shutdown(struct spi_device *spi) +{ + struct himax_ts_data *ts = spi_get_drvdata(spi); + + if (!ts->initialized) { + dev_err(ts->dev, "%s: init not ready, skip!\n", __func__); + return; + } + + himax_int_enable(ts, false); + gpiod_set_value(ts->pdata.gpiod_rst, 1); + himax_power_deconfig(&ts->pdata); + himax_hid_remove(ts); +} + +#if defined(CONFIG_OF) +static const struct of_device_id himax_table[] = { + { .compatible = "himax,hx83102j" }, + {}, +}; +MODULE_DEVICE_TABLE(of, himax_table); +#endif + +static struct spi_driver himax_hid_over_spi_driver = { + .driver = { + .name = "hx83102j", + .owner = THIS_MODULE, +#if defined(CONFIG_OF) + .of_match_table = of_match_ptr(himax_table), +#endif + }, + .probe = himax_spi_drv_probe, + .remove = himax_spi_drv_remove, + .shutdown = himax_shutdown, +}; + +static int __init himax_ic_init(void) +{ + return spi_register_driver(&himax_hid_over_spi_driver); +} + +static void __exit himax_ic_exit(void) +{ + spi_unregister_driver(&himax_hid_over_spi_driver); +} + +module_init(himax_ic_init); +module_exit(himax_ic_exit); + +MODULE_VERSION("1.3.4"); +MODULE_DESCRIPTION("Himax HX83102J SPI driver for HID"); +MODULE_AUTHOR("Himax, Inc."); +MODULE_LICENSE("GPL"); diff --git a/drivers/hid/hid-himax.h b/drivers/hid/hid-himax.h new file mode 100644 index 000000000000..26b47be49714 --- /dev/null +++ b/drivers/hid/hid-himax.h @@ -0,0 +1,288 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Himax hx83102j SPI Driver Code for HID. + * + * Copyright (C) 2024 Himax Corporation. + */ + +#ifndef __HID_HIMAX_83102J_H__ +#define __HID_HIMAX_83102J_H__ + +#include +#include +#include +#include +#include +#include +#include + +/* Constants */ +#define HIMAX_BUS_RETRY 3 +/* SPI bus read header length */ +#define HIMAX_BUS_R_HLEN 3U +/* SPI bus write header length */ +#define HIMAX_BUS_W_HLEN 2U +/* TP SRAM address size and data size */ +#define HIMAX_REG_SZ 4U +/* TP MAX TX/RX number */ +#define HIMAX_MAX_RX 144U +#define HIMAX_MAX_TX 48U +/* TP FW main code size */ +#define HIMAX_FW_MAIN_CODE_SZ 0x20000U +/* TP max event data size */ +#define HIMAX_MAX_TP_EVENT_SZ 128U +/* TP max interrupt data size : event size + raw data size(rx * tx 16bits) */ +#define HIMAX_MAX_TP_EV_STACK_SZ (HIMAX_BUS_R_HLEN + \ + HIMAX_MAX_TP_EVENT_SZ + \ + (HIMAX_MAX_RX * HIMAX_MAX_TX) * 2) +/* SPI Max read/write size for max possible usage, write FW main code */ +#define HIMAX_BUS_RW_MAX_LEN (HIMAX_FW_MAIN_CODE_SZ + \ + HIMAX_BUS_W_HLEN + HIMAX_REG_SZ) +/* SPI CS setup time */ +#define HIMAX_SPI_CS_SETUP_TIME 300 +/* HIDRAW report header size */ +#define HIMAX_HID_REPORT_HDR_SZ 2U +/* hx83102j IC parameters */ +#define HIMAX_HX83102J_DSRAM_SZ 73728U +#define HIMAX_HX83102J_FLASH_SIZE 261120U +#define HIMAX_HX83102J_MAX_RX_NUM 50U +#define HIMAX_HX83102J_MAX_TX_NUM 32U +#define HIMAX_HX83102J_PAGE_SIZE 128U +#define HIMAX_HX83102J_SAFE_MODE_PASSWORD 0x9527 +#define HIMAX_HX83102J_STACK_SIZE 128U +#define HIMAX_HX83102J_FULL_STACK_SZ \ + (HIMAX_HX83102J_STACK_SIZE + \ + (2 + HIMAX_HX83102J_MAX_RX_NUM * HIMAX_HX83102J_MAX_TX_NUM + \ + HIMAX_HX83102J_MAX_TX_NUM + HIMAX_HX83102J_MAX_RX_NUM) * 2) +#define HIMAX_HX83102J_REG_XFER_MAX 4096U +/* AHB register addresses */ +#define HIMAX_AHB_ADDR_BYTE_0 0x00 +#define HIMAX_AHB_ADDR_RDATA_BYTE_0 0x08 +#define HIMAX_AHB_ADDR_ACCESS_DIRECTION 0x0c +#define HIMAX_AHB_ADDR_INCR4 0x0d +#define HIMAX_AHB_ADDR_CONTI 0x13 +#define HIMAX_AHB_ADDR_EVENT_STACK 0x30 +#define HIMAX_AHB_ADDR_PSW_LB 0x31 +/* AHB register values/commands */ +#define HIMAX_AHB_CMD_ACCESS_DIRECTION_READ 0x00 +#define HIMAX_AHB_CMD_CONTI 0x31 +#define HIMAX_AHB_CMD_INCR4 0x10 +#define HIMAX_AHB_CMD_INCR4_ADD_4_BYTE 0x01 +#define HIMAX_AHB_CMD_LEAVE_SAFE_MODE 0x0000 +/* hx83102j-specific register/dsram flags/data */ +#define HIMAX_HX83102J_REG_ADDR_TCON_RST 0x80020004 +/* hardware register addresses */ +#define HIMAX_REG_ADDR_SPI200_DATA 0x8000002c +#define HIMAX_REG_ADDR_CTRL_FW 0x9000005c +#define HIMAX_REG_ADDR_FW_STATUS 0x900000a8 +#define HIMAX_REG_ADDR_ICID 0x900000d0 +/* hardware reg data/flags */ +#define HIMAX_REG_DATA_FW_STATE_RUNNING 0x05 +#define HIMAX_REG_DATA_FW_STATE_SAFE_MODE 0x0c +#define HIMAX_REG_DATA_FW_RE_INIT 0x00 +#define HIMAX_REG_DATA_FW_GO_SAFEMODE 0xa5 +#define HIMAX_REG_DATA_FW_IN_SAFEMODE 0x87 +#define HIMAX_REG_DATA_ICID 0x83102900 +#define HIMAX_REG_DATA_TCON_RST 0x00000000 +/* HIMAX SPI function select, 1st byte of any SPI command sequence */ +#define HIMAX_SPI_FUNCTION_READ 0xf3 +#define HIMAX_SPI_FUNCTION_WRITE 0xf2 +/* Map code of FW 1k header */ +#define HIMAX_TP_CONFIG_TABLE 0x00000a00 +#define HIMAX_FW_CID 0x10000000 +#define HIMAX_FW_VER 0x10000100 +#define HIMAX_CFG_VER 0x10000600 +#define HIMAX_HID_TABLE 0x30000100 +#define HIMAX_FW_BIN_DESC 0x10000000 + +/** + * enum himax_hidraw_id_function - HIDRAW report IDs + * @HIMAX_ID_CONTACT_COUNT: Contact count report ID + */ +enum himax_hidraw_id_function { + HIMAX_ID_CONTACT_COUNT = 0x03, +}; + +/** + * enum himax_touch_report_status - ts operation return code for touch report + * @HIMAX_TS_GET_DATA_FAIL: Get touch data fail + * @HIMAX_TS_SUCCESS: Get touch data success + */ +enum himax_touch_report_status { + HIMAX_TS_GET_DATA_FAIL = -4, + HIMAX_TS_SUCCESS = 0, +}; + +/** + * struct himax_fw_address_table - address/offset in firmware image + * @addr_fw_ver_major: Address to Major version of firmware + * @addr_fw_ver_minor: Address to Minor version of firmware + * @addr_cfg_ver_major: Address to Major version of config + * @addr_cfg_ver_minor: Address to Minor version of config + * @addr_cid_ver_major: Address to Major version of Customer ID + * @addr_cid_ver_minor: Address to Minor version of Customer ID + * @addr_cfg_table: Address to Configuration table + * @addr_hid_table: Address to HID tables start offset + * @addr_hid_desc: Address to HID descriptor table + * @addr_hid_rd_desc: Address to HID report descriptor table + */ +struct himax_fw_address_table { + u32 addr_fw_ver_major; + u32 addr_fw_ver_minor; + u32 addr_cfg_ver_major; + u32 addr_cfg_ver_minor; + u32 addr_cid_ver_major; + u32 addr_cid_ver_minor; + u32 addr_cfg_table; + u32 addr_hid_table; + u32 addr_hid_desc; + u32 addr_hid_rd_desc; +}; + +/** + * struct himax_hid_rd_data - HID report descriptor data + * @rd_data: Point to report description data + * @rd_length: Length of report description data + */ +struct himax_hid_rd_data { + u8 *rd_data; + u32 rd_length; +}; + +/** + * union himax_dword_data - 4 bytes data union + * @dword: 1 dword data + * @word: 2 words data in word array + * @byte: 4 bytes data in byte array + */ +union himax_dword_data { + u32 dword; + u16 word[2]; + u8 byte[4]; +}; + +/** + * struct himax_ic_data - IC information holder + * @stylus_ratio: Stylus ratio + * @rx_num: Number of RX + * @tx_num: Number of TX + * @button_num: Number of buttons + * @max_point: Maximum touch point + * @icid: IC ID + * @interrupt_is_edge: Interrupt is edge otherwise level + * @stylus_function: Stylus function available or not + * @stylus_v2: Is stylus version 2 + */ +struct himax_ic_data { + u8 stylus_ratio; + u32 rx_num; + u32 tx_num; + u32 button_num; + u32 max_point; + u32 icid; + bool interrupt_is_edge; + bool stylus_function; + bool stylus_v2; +}; + +/** + * struct himax_hid_desc - HID descriptor + * @desc_length: Length of HID descriptor + * @bcd_version: BCD version + * @report_desc_length: Length of report descriptor + * @max_input_length: Maximum input length + * @max_output_length: Maximum output length + * @max_fragment_length: Maximum fragment length + * @vendor_id: Vendor ID + * @product_id: Product ID + * @version_id: Version ID + * @flags: Flags + * @reserved: Reserved + * + * This structure is used to hold the HID descriptor. + * It directly maps to a sequence of bytes in firmware image, + * thus need to be packed. + */ +struct himax_hid_desc { + u16 desc_length; + u16 bcd_version; + u16 report_desc_length; + u16 max_input_length; + u16 max_output_length; + u16 max_fragment_length; + u16 vendor_id; + u16 product_id; + u16 version_id; + u16 flags; + u32 reserved; +} __packed; + +/** + * struct himax_platform_data - Platform data holder + * @vccd_supply: VCCD supply + * @gpiod_rst: GPIO reset + * + * This structure is used to hold the platform related data. + */ +struct himax_platform_data { + struct regulator *vccd_supply; + struct gpio_desc *gpiod_rst; +}; + +/** + * struct himax_ts_data - Touchscreen data holder + * @xfer_buf: Interrupt data buffer + * @xfer_rx_data: SPI Transfer receive data buffer + * @xfer_tx_data: SPI Transfer transmit data buffer + * @himax_fw_data: Firmware data holder from flash + * @himax_irq: IRQ number + * @spi_xfer_max_sz: Size of SPI controller max transfer size + * @xfer_buf_sz: Size of interrupt data buffer + * @irq_state: IRQ state + * @irq_lock: Spin lock for irq + * @initialized: Indicate the driver is initialized + * @probe_finish: Indicate the driver probe is finished + * @ic_boot_done: Indicate the IC boot is done + * @hid_probed: Indicate the HID device is probed + * @touch_data_sz: Size of each interrupt data from IC + * @dev: Device pointer + * @spi: SPI device pointer + * @hid: HID device pointer + * @reg_lock: Mutex lock for reg access + * @rw_lock: Mutex lock for read/write action + * @ic_data: IC information holder + * @pdata: Platform data holder + * @fw_info_table: Firmware information address table of firmware image + * @hid_desc: HID descriptor + * @hid_rd_data: HID report descriptor data + */ +struct himax_ts_data { + u8 *xfer_buf; + u8 *xfer_rx_data; + u8 *xfer_tx_data; + u8 *himax_fw_data; + s32 himax_irq; + u32 spi_xfer_max_sz; + u32 xfer_buf_sz; + atomic_t irq_state; + /* lock for irq_save */ + spinlock_t irq_lock; + bool initialized; + bool probe_finish; + bool ic_boot_done; + bool hid_probed; + int touch_data_sz; + struct device *dev; + struct spi_device *spi; + struct hid_device *hid; + /* lock for register operation */ + struct mutex reg_lock; + /* lock for bus read/write action */ + struct mutex rw_lock; + struct himax_ic_data ic_data; + struct himax_platform_data pdata; + struct himax_fw_address_table fw_info_table; + struct himax_hid_desc hid_desc; + struct himax_hid_rd_data hid_rd_data; +}; +#endif From patchwork Tue Apr 16 02:12:27 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Allen_Lin X-Patchwork-Id: 790609 Received: from APC01-TYZ-obe.outbound.protection.outlook.com (mail-tyzapc01olkn2085.outbound.protection.outlook.com [40.92.107.85]) (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 A95821097B; Tue, 16 Apr 2024 02:13:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=40.92.107.85 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1713233592; cv=fail; b=uwwQ0On0P4zy8CcphtmHPXgzwo7hJ616wjwb1fCzsgP00ixfLJIbbwgo+04wHUQ7PC2PhUdUPSQHc+ZfaNDYAY/iUTNITh+ko/JP4cHniaozIiThI3qDeeupaYRsZbNdGVRnyZoTUW3Os00csrxSPY8c91fty9VQJocZRk1WPXs= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1713233592; c=relaxed/simple; bh=NHXiNIS4SV+N3FIj8fzVb2/lualN7izIdYHoiES3N18=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: Content-Type:MIME-Version; b=hIsp1S/Yw53j7VvotPpkS1/Q7kfEgT6awUE22/AQVPasWw5umb4rAnXqdvQDSSsh4Pk1SAyJ6i2gQBhlnDwlDitFuH+burO1Xl/4kcfPAQfC0t4/790KUfLTDPcst7Em4MQrBcUTlrwE1pAjNR+DU7/VZLJ+SwP+iXTQWnJTV3U= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=hotmail.com; spf=pass smtp.mailfrom=hotmail.com; dkim=pass (2048-bit key) header.d=hotmail.com header.i=@hotmail.com header.b=Fe/UVHFZ; arc=fail smtp.client-ip=40.92.107.85 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=hotmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=hotmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=hotmail.com header.i=@hotmail.com header.b="Fe/UVHFZ" ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=eMmknd7JBbjCT4Qnmdpx8xMoRjfStYBIfRW6QyZ1spFcyNIGiRiXBkYXetnGSxlfYcNjD6+sOy9X3x0ZrhVCsW5uOwF0J30bvHlhDgVqpFrp+8QgEgfwIikbgB0C4vx/f5lg2tqv2kkUKGu8+ktX3WnJwqCYF+QPX7TrFaF435+QZbAgRjCDiyAgrcjNQHtaMlz3egEW5t86AvOVP7wXpxyHCcmrCksMHfj+O8R9Uv4PYbI6xzc0u5pIKbMGCQES0toIwUx6iwALp/6cJ/ZZExjmhEwnVn1Y79W3XJ1JkTBrxdJQbf/aEEp2bBrgxTdngYftwNyli1m0+JTqs8EHfA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=qCOj7uV9ms03Ow1RoUlRpVuhMHp2LsgloqSeKq63ceQ=; b=n20Ihuu809tHGAf2nE390Rc4bRMD0A9OP0d2eYen8SXxZ7+Ft+6TR8c04MwnT/vyFoQ7enqkGCZD4vcSc7EUt6bITpXmcFI4FZWIUjNa5+Vedcu4rcqYLV8yPWSM2lIsFEyRt2VWxiQM2FfWGY46aQ3u6z4lOd9AtMldY0lkJ5dSC6Tc9EUagsTgdMI2nlVFxTliiNGdqgabM61BzdKyKQLBbCTYQnNH2ObOwbbN1anOIpiMxKU72bUNB8ukMGgqvnTAf2GIMYN5GEdhSFFT/wydE5dcL5Q3N1yPL36G6vCeaLV+tvM7PzPtGzGFlzoItAe4thGZFwPETUgPIx+FRQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=hotmail.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=qCOj7uV9ms03Ow1RoUlRpVuhMHp2LsgloqSeKq63ceQ=; b=Fe/UVHFZtrnBrjrsI6Uha4hYFLcupybw/QKVDQZEXenn9RVTJPWGTZc1mcu7/Pk/VIZA2iSymp+okOwg2ToY8r3KK4WaN7/7IYKKQKWt9eSpq3aAEmrmu6ixtQfp5VY4uufq1xx34fCm96frkRJUl8LWUVGzfnn+V6fNYEPfQqOhMPAqUWAZ4n76V/P3HYgSs8Xqyqk2hudiqIytMY1CKdJHd/ypvGNzNZSjm6JULP4QMpyNJCOtLl3Zfe8st9hupVaguDJLKqJDo5wqbWBWZHkofbTa0iZcwrrYLWmPvOUoo8kYZL/AkpAtutfZi0FFW3pT7w0kCqt6+00m0NRg+w== Received: from TY0PR06MB5611.apcprd06.prod.outlook.com (2603:1096:400:31e::8) by TYZPR06MB5323.apcprd06.prod.outlook.com (2603:1096:400:1f1::8) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7452.50; Tue, 16 Apr 2024 02:13:07 +0000 Received: from TY0PR06MB5611.apcprd06.prod.outlook.com ([fe80::d57a:9f0e:1ee7:85bf]) by TY0PR06MB5611.apcprd06.prod.outlook.com ([fe80::d57a:9f0e:1ee7:85bf%5]) with mapi id 15.20.7452.049; Tue, 16 Apr 2024 02:13:07 +0000 From: Allen_Lin To: dmitry.torokhov@gmail.com, robh@kernel.org, krzysztof.kozlowski+dt@linaro.org, conor@kernel.org, jikos@kernel.org, benjamin.tissoires@redhat.com, linux-input@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Cc: Allen_Lin Subject: [PATCH v3 3/4] HID: Add DRM panel follower function Date: Tue, 16 Apr 2024 10:12:27 +0800 Message-ID: X-Mailer: git-send-email 2.34.1 In-Reply-To: <20240416021228.1092678-1-allencl_lin@hotmail.com> References: <20240416021228.1092678-1-allencl_lin@hotmail.com> X-TMN: [uaiYKQzXt5GGVkD4tHBvzjDJMJPLlpYX] X-ClientProxiedBy: PS2PR01CA0002.apcprd01.prod.exchangelabs.com (2603:1096:300:2d::14) To TY0PR06MB5611.apcprd06.prod.outlook.com (2603:1096:400:31e::8) X-Microsoft-Original-Message-ID: <20240416021228.1092678-4-allencl_lin@hotmail.com> Precedence: bulk X-Mailing-List: linux-input@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: TY0PR06MB5611:EE_|TYZPR06MB5323:EE_ X-MS-Office365-Filtering-Correlation-Id: c28d2106-b3c2-417b-9b90-08dc5dbac176 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: XVZiwgpwR7piUQZvv7CJy9aC+KoGYxhmwE928vne1rCxlIEpZ5UGkXWsvlPHNge5PCliXjA2/qv4UJp27RYdCyaUF/ap0ZiOmQFAmHpVXmkkVdB+B8y2msc/V0spXYdpUZN+eUxW1WAslihu6hWVeh5DlNC+I/3YiusxyvYvYr2S+OqC5Cj/HwL6N5fiQV8z1ra/I4hV7RaVUk2mtSHERYN+xA72ivdjTuHHOQn4+6VjKsP51jrgMQfzWFN3dCCxhiY273K/QNvY7+ZaLBzuJD+uqqJ30WrQ8VxuRjBexhIdfrSLu8ogONTbGxqrfVIBBa7KyYeonf246411JHvswjSude0KN46ky+w0GpPHG7gp8JsRC/beUP3B07aSyrTuL0swb9SAvFrsg1NIqK5C00pzwoqvPXl8z3MA13lJ7+xDyCNSAymQU5JAfeTWONGNs8jkG3X3lUDIAGi7zUXFvVDL0BRwcFTSQolDA76OZTtzCRu9hlsiTNc+r4Jh0HrolCXKpMuTssJia+qdwTA65aQ8NJ6q9SR0aF1pmvPMYkCfX03qWTU5jywxF8/jBqleDIYW/jhVw/Djh8fFF6eQioZiPWjRD6CjH3rLUNW3raVOqPwZ/N+/7p7glDq1nYSQUoEeo19Cl5P6GKiSsTfFtpbjGoQe09C/K3b5lIv7Ega1PbBLmdeyguANGbWZQGeSAHV7YT8u7vFIJTG0ZVZLjs6RssH4evXC57U/o6QTzsaUBpdf2MXNb7ODLaYlBjn/ X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: 0xAAnr/5AAK7NVWUcJBm5UrqjksDsvWDNa+WF8IPSbc/ILZFepKxVcWVs6WuctNIac5sMRWebQg+W1UANHfgENA286n9KZAWB2HpZtQmI8zHXK6rHko4b7ZYh1lcrcb6JyLU7RqxGkuBJRRtmIvb6f4nJLYnMwlIJcRYAwQVkghCqyraTFyuuAPX43YS0KKmfDb6FiDuSdnXb1blwHUmyWR2ac6eTBpqOmOg1PdxIgdwObwZ4EjzkSPTYq4no2YUlE7HN+VhH3Vy7wYsv21CJjR4T3vhQlN3IO7csK74ZIDvKteHhFZNDeGnEO85Up3MoWOGlXHuid6TKpBpWx/rySjrTq7/irg4A+fFCGIkoxDh5fLw/gegha3DtqU/mKaEJtNWOFKkkfK2GzcxuYNPMKh4b63nYV98Qm/rX7aW5FLrmHWVFUI9fwKHKN3QOyvMqcW+emQwpcaa08lfwyItvRI80M0YsAb96eprLDu9/yE7ia4zgObUY0eo20ECSXuPjSfVtqxhLRkiKHoJu/YZCZlZAEH97a6jMTnNeXkpAjy8EsGOYHIErcNHr7qY+upFFCIoJGR2N7dGQpVsVTrEAOhDarZ6abwncxsTqh4tEUZrNMjKUxo8sn6aaZTZ7QN2tELgTxFhcRJlLyv+re8onvUfzWm7gDpHAM5cHt6KdqUQhrEXE6BngP3pd196Gtmr1F8b07jmFpwLsxosn3EhMs/2nFEJAdxSnZmJUFfJSINoYbtAGKKJ1gdru1ZNoGNdg07BL5g0tSvmjuDV3RFb6qKiualNn20DuvgiNMHolMPC40UYR8AINzJtQkfgHzl2bPIIQepOhfsBx3CUtgU+MIx9/+zjRYhwTD+24YmlWCvcaSNURM0Ppx2HvrxpkDGmcDSwiEOO0/t1OV2tGT+3ZE1MprISzSw7Jg/NuwmD3kX7tuJKER6QPlSrzN/AGkIPO7wsq8UD0plf9T2e/I5Ys9h0/+SO1M+63s8ucAOsq86RJyi06OvRt0036KCzH+Qv4OqHDlQ32C380KbYcpOHrYFrfyAtMZ2NrP53q+tSWkb6sGPJ4JEd1N2rTd0upNjACv3/r6m4eTu2de4neGDZw41R+uPVXwQglSTM61WODlssd2Pa/ukMBQ2+c6zBE1JzmciWlyCB4PZ102lzSusHFAMMoLmc4IPBH8JZgmD59iRi+s1qSQM3z0LuDufVuFgdZlJndLOGAdLkSrL0fAJ77mbY9JwK9Y3WC4gScx6cKr07LNPNm9qo2zR+PDHFoqnT X-OriginatorOrg: sct-15-20-4755-11-msonline-outlook-3208f.templateTenant X-MS-Exchange-CrossTenant-Network-Message-Id: c28d2106-b3c2-417b-9b90-08dc5dbac176 X-MS-Exchange-CrossTenant-AuthSource: TY0PR06MB5611.apcprd06.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 16 Apr 2024 02:13:07.3755 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: TYZPR06MB5323 Add DRM panel follower[1] to trigger suspend/resume due to TDDI nature, TP need to follow panel power sequence. [1]: https://lore.kernel.org/all/20230727171750.633410-1-dianders@chromium.org Signed-off-by: Allen_Lin --- drivers/hid/hid-himax.c | 292 +++++++++++++++++++++++++++++++++++++--- drivers/hid/hid-himax.h | 10 ++ 2 files changed, 286 insertions(+), 16 deletions(-) diff --git a/drivers/hid/hid-himax.c b/drivers/hid/hid-himax.c index f8a417e07f0c..7b0ee48acfae 100644 --- a/drivers/hid/hid-himax.c +++ b/drivers/hid/hid-himax.c @@ -8,6 +8,7 @@ #include "hid-himax.h" static int himax_chip_init(struct himax_ts_data *ts); +static int himax_platform_init(struct himax_ts_data *ts); static void himax_ts_work(struct himax_ts_data *ts); /** @@ -1145,7 +1146,6 @@ static int himax_hid_probe(struct himax_ts_data *ts) hid = ts->hid; if (hid) { - dev_warn(ts->dev, "%s: hid device already exist!\n", __func__); hid_destroy_device(hid); hid = NULL; } @@ -1501,6 +1501,154 @@ static int himax_load_config(struct himax_ts_data *ts) return -EINVAL; } +/** + * himax_ap_notify_fw_suspend() - Notify the FW of AP suspend status + * @ts: Himax touch screen data + * @suspend: Suspend status, true for suspend, false for resume + * + * This function is used to notify the FW of AP suspend status. It will write + * the suspend status to the DSRAM and read the status back to check if the + * status is written successfully. If IC is powered off when suspend, this + * function will only be used when resume. + * + * Return: None + */ +static void himax_ap_notify_fw_suspend(struct himax_ts_data *ts, bool suspend) +{ + int ret; + u32 retry_cnt; + const u32 retry_limit = 10; + union himax_dword_data rdata, data; + + if (suspend) + data.dword = cpu_to_le32(HIMAX_DSRAM_DATA_AP_NOTIFY_FW_SUSPEND); + else + data.dword = cpu_to_le32(HIMAX_DSRAM_DATA_AP_NOTIFY_FW_RESUME); + + for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) { + ret = himax_mcu_register_write(ts, HIMAX_DSRAM_ADDR_AP_NOTIFY_FW_SUSPEND, + data.byte, 4); + if (ret) { + dev_err(ts->dev, "%s: write suspend status failed!\n", __func__); + return; + } + usleep_range(1000, 1100); + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_AP_NOTIFY_FW_SUSPEND, + rdata.byte, 4); + if (ret) { + dev_err(ts->dev, "%s: read suspend status failed!\n", __func__); + return; + } + + if (rdata.dword == data.dword) + break; + } +} + +/** + * himax_resume_proc() - Chip resume procedure of touch screen + * @ts: Himax touch screen data + * + * This function is used to resume the touch screen. It will call the + * himax_ap_notify_fw_suspend() to notify the FW of AP resume status. + * + * Return: None + */ +static void himax_resume_proc(struct himax_ts_data *ts) +{ + himax_ap_notify_fw_suspend(ts, false); +} + +/** + * himax_chip_suspend() - Suspend the touch screen + * @ts: Himax touch screen data + * + * This function is used to suspend the touch screen. It will disable the + * interrupt and set the reset pin to activate state. Remove the HID at + * the end, to prevent stuck finger when resume. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_chip_suspend(struct himax_ts_data *ts) +{ + himax_int_enable(ts, false); + gpiod_set_value(ts->pdata.gpiod_rst, 1); + himax_power_set(ts, false); + himax_hid_remove(ts); + + return 0; +} + +/** + * himax_chip_resume() - Setup flags, I/O and resume + * @ts: Himax touch screen data + * + * This function is used to resume the touch screen. It will set the resume + * success flag to false, and disable reset pin. Then call the himax_resume_proc() + * to process detailed resume procedure. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_chip_resume(struct himax_ts_data *ts) +{ + if (himax_power_set(ts, true)) + return -EIO; + gpiod_set_value(ts->pdata.gpiod_rst, 0); + himax_resume_proc(ts); + himax_hid_probe(ts); + himax_int_enable(ts, true); + + return 0; +} + +/** + * himax_suspend() - Suspend the touch screen + * @dev: Device structure + * + * Wrapper function for himax_chip_suspend() to be called by the PM or + * the DRM panel notifier. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_suspend(struct device *dev) +{ + struct himax_ts_data *ts = dev_get_drvdata(dev); + + if (!ts->initialized) { + dev_err(ts->dev, "%s: init not ready, skip!\n", __func__); + return -ECANCELED; + } + himax_chip_suspend(ts); + + return 0; +} + +/** + * himax_resume() - Resume the touch screen + * @dev: Device structure + * + * Wrapper function for himax_chip_resume() to be called by the PM or + * the DRM panel notifier. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_resume(struct device *dev) +{ + int ret; + struct himax_ts_data *ts = dev_get_drvdata(dev); + + if (!ts->initialized) { + if (himax_chip_init(ts)) + return -ECANCELED; + } + + ret = himax_chip_resume(ts); + if (ret < 0) + dev_err(ts->dev, "%s: resume failed!\n", __func__); + + return ret; +} + /** * himax_chip_init() - Initialize the Himax touch screen * @ts: Himax touch screen data @@ -1531,6 +1679,130 @@ static int himax_chip_init(struct himax_ts_data *ts) return 0; } +/** + * __himax_initial_power_up() - Initial power up of the Himax touch screen + * @ts: Himax touch screen data + * + * This function is used to perform the initial power up sequence of the Himax + * touch screen for DRM panel notifier. + * + * Return: 0 on success, negative error code on failure + */ +static int __himax_initial_power_up(struct himax_ts_data *ts) +{ + int ret; + + ret = himax_platform_init(ts); + if (ret) { + dev_err(ts->dev, "%s: platform init failed\n", __func__); + return ret; + } + + ret = hx83102j_chip_detect(ts); + if (ret) { + dev_err(ts->dev, "%s: IC detect failed\n", __func__); + return ret; + } + + ret = himax_chip_init(ts); + if (ret) { + dev_err(ts->dev, "%s: chip init failed\n", __func__); + return ret; + } + ts->probe_finish = true; + + return 0; +} + +/** + * himax_panel_prepared() - Panel prepared callback + * @follower: DRM panel follower + * + * This function is called when the panel is prepared. It will call the + * __himax_initial_power_up() when the probe is not finished which means + * the first time driver start. Otherwise, it will call the himax_resume() + * to performed resume process. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_panel_prepared(struct drm_panel_follower *follower) +{ + struct himax_platform_data *pdata = + container_of(follower, struct himax_platform_data, panel_follower); + struct himax_ts_data *ts = container_of(pdata, struct himax_ts_data, pdata); + + if (!ts->probe_finish) + return __himax_initial_power_up(ts); + else + return himax_resume(ts->dev); +} + +/** + * himax_panel_unpreparing() - Panel unpreparing callback + * @follower: DRM panel follower + * + * This function is called when the panel is unpreparing. It will call the + * himax_suspend() to perform the suspend process. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_panel_unpreparing(struct drm_panel_follower *follower) +{ + struct himax_platform_data *pdata = + container_of(follower, struct himax_platform_data, panel_follower); + struct himax_ts_data *ts = container_of(pdata, struct himax_ts_data, pdata); + + return himax_suspend(ts->dev); +} + +/* Panel follower function table */ +static const struct drm_panel_follower_funcs himax_panel_follower_funcs = { + .panel_prepared = himax_panel_prepared, + .panel_unpreparing = himax_panel_unpreparing, +}; + +/** + * himax_register_panel_follower() - Register the panel follower + * @ts: Himax touch screen data + * + * This function is used to register the panel follower. It will set the + * pdata.is_panel_follower to true and register the panel follower. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_register_panel_follower(struct himax_ts_data *ts) +{ + struct device *dev = ts->dev; + + ts->pdata.is_panel_follower = true; + ts->pdata.panel_follower.funcs = &himax_panel_follower_funcs; + + if (device_can_wakeup(dev)) { + dev_warn(ts->dev, "Can't wakeup if following panel"); + device_set_wakeup_capable(dev, false); + } + + return drm_panel_add_follower(dev, &ts->pdata.panel_follower); +} + +/** + * himax_initial_power_up() - Initial power up of the Himax touch screen + * @ts: Himax touch screen data + * + * This function checks if the device is a panel follower and calls + * himax_register_panel_follower() if it is. Otherwise, it calls + * __himax_initial_power_up(). + * + * Return: 0 on success, negative error code on failure + */ +static int himax_initial_power_up(struct himax_ts_data *ts) +{ + if (drm_is_panel_follower(ts->dev)) + return himax_register_panel_follower(ts); + else + return __himax_initial_power_up(ts); +} + /** * himax_platform_deinit() - Deinitialize the platform related settings * @ts: Pointer to the himax_ts_data structure @@ -1660,25 +1932,13 @@ static int himax_spi_drv_probe(struct spi_device *spi) ts->initialized = false; ts->ic_boot_done = false; - ret = himax_platform_init(ts); - if (ret) { - dev_err(ts->dev, "%s: platform init failed\n", __func__); - return ret; - } - - ret = hx83102j_chip_detect(ts); + ret = himax_initial_power_up(ts); if (ret) { - dev_err(ts->dev, "%s: IC detect failed\n", __func__); - return ret; + dev_err(ts->dev, "%s: initial power up failed\n", __func__); + return -ENODEV; } - ret = himax_chip_init(ts); - if (ret < 0) - return ret; - ts->probe_finish = true; - return ret; - himax_platform_deinit(ts); } /** diff --git a/drivers/hid/hid-himax.h b/drivers/hid/hid-himax.h index 26b47be49714..45dc3e6283ae 100644 --- a/drivers/hid/hid-himax.h +++ b/drivers/hid/hid-himax.h @@ -8,6 +8,7 @@ #ifndef __HID_HIMAX_83102J_H__ #define __HID_HIMAX_83102J_H__ +#include #include #include #include @@ -69,6 +70,11 @@ #define HIMAX_AHB_CMD_INCR4 0x10 #define HIMAX_AHB_CMD_INCR4_ADD_4_BYTE 0x01 #define HIMAX_AHB_CMD_LEAVE_SAFE_MODE 0x0000 +/* DSRAM flag addresses */ +#define HIMAX_DSRAM_ADDR_AP_NOTIFY_FW_SUSPEND 0x10007fd0 +/* dsram flag data */ +#define HIMAX_DSRAM_DATA_AP_NOTIFY_FW_SUSPEND 0xa55aa55a +#define HIMAX_DSRAM_DATA_AP_NOTIFY_FW_RESUME 0x00000000 /* hx83102j-specific register/dsram flags/data */ #define HIMAX_HX83102J_REG_ADDR_TCON_RST 0x80020004 /* hardware register addresses */ @@ -219,13 +225,17 @@ struct himax_hid_desc { /** * struct himax_platform_data - Platform data holder + * @is_panel_follower: Is panel follower enabled * @vccd_supply: VCCD supply + * @panel_follower: DRM panel follower * @gpiod_rst: GPIO reset * * This structure is used to hold the platform related data. */ struct himax_platform_data { + bool is_panel_follower; struct regulator *vccd_supply; + struct drm_panel_follower panel_follower; struct gpio_desc *gpiod_rst; }; From patchwork Tue Apr 16 02:12:28 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Allen_Lin X-Patchwork-Id: 789561 Received: from APC01-TYZ-obe.outbound.protection.outlook.com (mail-tyzapc01olkn2101.outbound.protection.outlook.com [40.92.107.101]) (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 B964B1B812; Tue, 16 Apr 2024 02:13:17 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=40.92.107.101 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1713233601; cv=fail; b=WMw9DG7QcE87kwbr+kQZ3icOJF/N3XZxu5HrTIrzow2Q/SBoZ0P6kk5cmduRsvSjfA6rrpo+7E1ZqayRd0OPf4ePafBtH/B9Xjzd32CRGdQ2PLoyd8ZH1Vn93n2XnxvkvmlULWV5idxAx08qkY1SmmNvAupxxNnjc6CpPey+wJU= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1713233601; c=relaxed/simple; bh=T/a31Qb4WtJ1yYukKpkIo3R/awxFw5sN6SEY3njPn7k=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: Content-Type:MIME-Version; b=WXGGkGzM468bVg3cBQlm3ZFtBBT7WRH2C6kyS952i7R8CZiTHg+d+1HMYH0zZQxKLfOApbp+8tOdH6xKd1U2rK8ftbqPitDuvUoR918ryPBRN1EwmU+b/nWjr+Tg45CuqjvmenVIB/W39cep1NircVtK1SKRj8AVDWlwG3psU1s= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=hotmail.com; spf=pass smtp.mailfrom=hotmail.com; dkim=pass (2048-bit key) header.d=hotmail.com header.i=@hotmail.com header.b=Djqp9CbL; arc=fail smtp.client-ip=40.92.107.101 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=hotmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=hotmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=hotmail.com header.i=@hotmail.com header.b="Djqp9CbL" ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=jyou6DU5yGNewlfwM3dyLLQLIqDmgQGIC+dRfSGziafOCJCEeS/UWFL9Z7P1G2Qa+qhDWwP13BUimavfsUEF7f8tWSUEzEqIQiRi21aTV2UKZ/oIXM3bJfcEDWAlxvhZKOyb2fj8XKpHoxdKN585LzGJpyVg5YV96IFZeO1reFBWCDDBoM58BTGg4KAZKRebRij7SjqTQGKKqPTqHYdjB9AZ6vU5CB810knNeshk6bPi4pWRGgyND2itH4SWqRz8EQ0s+qS3U9FG3DLjiiCIfARqRS7ZQTt1rm2qX9aV43MyNcHmPCWxEUSS556YqEKZ5ZKNwcY4lwZUPq32/zH+vg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=2pQXezMRgn+zhmfmeqnHHpMDvnQzpKuIvb6hdfC2rd0=; b=a3r77kpAHK27DJ2uE61tBvYK3VnKSbSachTirFBXuZtcFWL+LZXYfW4vKvQapTwQRig+w7NJeph/KNB55xkoHLlfo5qxc8fsC43jvgXi9XzxFiZYnCZqwVhbpzUHjdp7+GemVngXMgzuhKNLMZWFupH3uAT/gGEl0OO3FWlvm8GMtidKnMVYaGf4aK4c4XxS1B8LcyY9ObQL5tihpZhPTQys5ibVIadbWx8Ja+ypLqrIvSa49IGyfxfiwOc370w0EkagsDsjp1KqfkAkMYGKqrcl5/MqvrgCeh9mOtF1kpe4EWelV4cTapw+01SQ3S96guquKXpUKCh/SxNXaMXZCA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=hotmail.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=2pQXezMRgn+zhmfmeqnHHpMDvnQzpKuIvb6hdfC2rd0=; b=Djqp9CbLf7p/gI5FCu3cMJjFYiOLujLkwIQhOn+HVaEgUqqDpCMdycXVYm6A0ZXYoMru7SqLURFntMEguB/52uAUfTIZ6uA7hNM80i4sxh+rChkOXpqYk2EY3FDgjjGw5PUKgTp64H+paSt9q2FOUY9740UGu3OwPGblj1X4cy/CwNeA1OxFfFBm40qYyK7AphAVY2eVtepR4A3rsY4s9y+gMqBHAh5Yw17U5YH6w4UBLpY0dk21GAZdk/6TD0vw2D6ZXYdqNXK47JLExbftzegwIP7rfYATja0kHyMJMWrGCc3LVAh9fZRTBXw5JKslWubD6cVGciMCl/adcAeh9Q== Received: from TY0PR06MB5611.apcprd06.prod.outlook.com (2603:1096:400:31e::8) by TYZPR06MB5323.apcprd06.prod.outlook.com (2603:1096:400:1f1::8) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7452.50; Tue, 16 Apr 2024 02:13:12 +0000 Received: from TY0PR06MB5611.apcprd06.prod.outlook.com ([fe80::d57a:9f0e:1ee7:85bf]) by TY0PR06MB5611.apcprd06.prod.outlook.com ([fe80::d57a:9f0e:1ee7:85bf%5]) with mapi id 15.20.7452.049; Tue, 16 Apr 2024 02:13:12 +0000 From: Allen_Lin To: dmitry.torokhov@gmail.com, robh@kernel.org, krzysztof.kozlowski+dt@linaro.org, conor@kernel.org, jikos@kernel.org, benjamin.tissoires@redhat.com, linux-input@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Cc: Allen_Lin Subject: [PATCH v3 4/4] HID: Load firmware directly from file to IC Date: Tue, 16 Apr 2024 10:12:28 +0800 Message-ID: X-Mailer: git-send-email 2.34.1 In-Reply-To: <20240416021228.1092678-1-allencl_lin@hotmail.com> References: <20240416021228.1092678-1-allencl_lin@hotmail.com> X-TMN: [JeGE7dpZ4g6n3WcR2eFJKHVJYDLcGYfe] X-ClientProxiedBy: PS2PR01CA0002.apcprd01.prod.exchangelabs.com (2603:1096:300:2d::14) To TY0PR06MB5611.apcprd06.prod.outlook.com (2603:1096:400:31e::8) X-Microsoft-Original-Message-ID: <20240416021228.1092678-5-allencl_lin@hotmail.com> Precedence: bulk X-Mailing-List: linux-input@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: TY0PR06MB5611:EE_|TYZPR06MB5323:EE_ X-MS-Office365-Filtering-Correlation-Id: bca1f807-f09a-40d7-4b94-08dc5dbac457 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: hYONiaQ7o9dvVCGMGxXsAgdua4Gmbz8di7BseAlANS1oUtImyoAQ5am5JH1Y2dAev19ZS8vF2iS7t7MYqw6ywBH1L6NHCvOTCxFl6oqa456CswPsr6K4Bw8SZFW5oZ8k/0FPljs2BKCV82sYfBRF5UZ1/SZPcghdJmJtKvifaPPk5XIuagmMbayMw9n2W+ZCGLYPst5DX2v9Bvq5a+HhgMhTQ0jXLo64MgSqDRGLzXRzb+byxguMCWbhGPG8gFtMR2tn9jkPXcjau/vr1+Hbh2CBuCJ5wvnitx/LySEteVx0uRZ5xsSpRKV6xaoj+cf2CKIkCliEoHXa4DMtKqWtRp5RY2z7HTP8OsmyNm+ZODfSgiYBBhjbhKExBi3qBIKQRwXzrUjN5xukQz7H1iDv3aId3aSw+bgUOMOKlQLcf3yvfhrEu8OyfMcJzQcs5PBfV/AFXHVqBtvoU5Moz0RpMzJM9ZJ6Wezox2CKt8oAIKqtvq6Qwy+b5d6qknFnZLnBPn5WtnrBI2EOy+4gzEDEC02Gkuq7ETekLt2qwV7wF80JmU5X9PCDlvD2it2hSsYWIpDSqCQ7RuRiuIVx0E38vQB/tS3JQAVejF4/4LaFxhUAOnuXSToTOD7bYPzTu6LS X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: x4VxfRiRawpZXyvnaJyk0FHeP+GkxbAeTHaL7QMhurb+UCXxNREdD2mZzBl2/HzufslCytQrD+SK7T05v62B+EDG3URfVsVzXWBAIl9UsfHqbFYZAclEOWyba2OegUrCGk6Rro3dOe5Tt760uwyOT/NuwkqQVQnh+2VDsOzEhDCiQZ0gsQkyixpr38P4d61UoSK+v1ZVXGm3dCAnbtNvHgHvRNdkceV5YqZBfAOwLfQaZXbDumoSUJ0SDGpROwSQVYp7Ojx6NHt5HujhR3bsO9w60HGqoo4CbvdvodPEqg39XxRrIZeW/CkWFr6BXa8wz3KgkBzcJHUHSMlhO00OhMVdqfdBef/UpyDtthoBPQCBbuTiIqnYGqqkVYGFrzkRK7L2KW/Al0AGXUmFBdyyRahPwQc6An+L9CIKwHoW/hZT/KOPtTGPc6w5uZJC3ayxZpGbPXFkty9sdxVGlbNj1qcdwOcE2ew5VenrW/YiUrir6cCgf/SLEwxiDtaqbySOfP6EzRjytwOKx7GvvzQkzTH8AHz1prgPa0Qo+vCeo/Lv9HibDGciPYiLc6pce4rQ1ihDt5/t2uJz7Rbsw9nuc/srwFas0snsYgDNlQBg7dG3DuMmUYFbJpxQFng8/qXijnonSpvEzr+AaIMETvEj66NZ2hZvhrYwOLzLs6ZTNQ4VTXn2HUBIQVKzkmq28ZIpO7wyRfPXM4pQr+zhEDzrX8dVzgnnp15wPNFpWeLqEHajv/dvOkIi8EaJbnafojf65/LYyMCKhpLLRW3TS+JmkbT5JryOuoLhAAq564TceG6HCwDu+68DPl16vPyfrShSMv81c5t89fAdkPJPtjNt0fm2UL0rnhWueCU7+SpMsSnH/GHBXl8TvpQPHjYm/nly0A7B9djrFkowBYyzl8JfHZKdwGDENSrJQd1d3jjCaX3GSM4sKohkEZNRWJt+zsZ9p0cO0SkzFHHgH2Td+N57yXLnU/9geUFtvARzIVTWj56Uwj4fc5cyQgr1JDSLiI6gWqdT6wCsEtpAyeVztQIFTGH9OVvayre9XwfH2Q2lb4j1NA8bfc6srEYve7fcMRMpLQpr452e+i84qLwcqVXBl+oCmqkB2Q9LPqAd7XXWDI3oF6LSI9k2wYR7KZkhGaZ5Bhslzhh+lqOTJqlgPM5yJbuhxtOghCjpNAcFixjiFWzXyv2282XxtWNrKkwBlfY7H4FAkbaSNWNd3DTzl1HGiNuxIFiLScCgRPC3IuisNwFdUXv1ZrcpV0nwrwLrUq9t X-OriginatorOrg: sct-15-20-4755-11-msonline-outlook-3208f.templateTenant X-MS-Exchange-CrossTenant-Network-Message-Id: bca1f807-f09a-40d7-4b94-08dc5dbac457 X-MS-Exchange-CrossTenant-AuthSource: TY0PR06MB5611.apcprd06.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 16 Apr 2024 02:13:12.3869 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: TYZPR06MB5323 For HX83102J, often shipped without flash for costdown purpose. This patch implement the function to load firmware file from user-space, write into IC sram and make it running. The procedure as following: 1. Check OF to get FW name specified: himax_parse_dt 2. Load specified FW: i_get_FW, upload process use workqueue himax_boot_upgrade 3. Write FW into IC sram: i_update_FW 3-1. FW file contain a mapping table to indicate various section, such code, data, version info and HID info 3-2. Call update process himax_mcu_firmware_update_0f, which stop the internal MCU: i. system reset. ii. hx83102j_sense_off 3-3. Parsing FW and upload file: himax_zf_part_info. info[0] contain the code section and will upload to ISRAM. Other info[x] are data sections will be combined and upload to DSRAM separately. After upload FW, driver will use crc to check integrity: himax_sram_write_crc_check for code(HW CRC result must be 0), himax_mcu_calculate_crc_with_ap for pre-calculate data CRC[1], Upload data section by himax_mcu_register_write, himax_mcu_check_crc use HW calculate CRC and compared with [1] 4. Disable HW reload FW from flash function before MCU start running: himax_disable_fw_reload 5. Start running the FW: himax_mcu_power_on_init 5-1. Setting varies FW settings before FW start running 5-2. Start FW: hx83102j_sense_on 5-3. Wait until FW initial process complete: Read 0x72C0 from IC 6. Read HID info from FW 7. Read TP properties from IC: himax_mcu_tp_info_check 8. Read FW information fromIC: himax_mcu_read_FW_ver 9. Release FW, IC initial complete The resume procedure do part of boot process, it also need to reload FW from user-space into IC sram: himax_0f_op_file_dirly 1. Request FW 2. Upload FW: himax_mcu_firmware_update_0f 3. Disable HW reload FW from flash function: himax_disable_fw_reload 4. Start running the FW: himax_mcu_power_on_init Signed-off-by: Allen_Lin --- drivers/hid/hid-himax.c | 1501 +++++++++++++++++++++++++++++++++------ drivers/hid/hid-himax.h | 166 ++++- 2 files changed, 1467 insertions(+), 200 deletions(-) diff --git a/drivers/hid/hid-himax.c b/drivers/hid/hid-himax.c index 7b0ee48acfae..50acb87bee35 100644 --- a/drivers/hid/hid-himax.c +++ b/drivers/hid/hid-himax.c @@ -532,6 +532,92 @@ static void himax_mcu_ic_reset(struct himax_ts_data *ts, bool int_off) himax_int_enable(ts, true); } +/** + * hx83102j_reload_to_active() - Reload to active mode + * @ts: Himax touch screen data + * + * This function is used to write a flag to the IC register to make MCU restart without + * reload the firmware. + * + * Return: 0 on success, negative error code on failure + */ +static int hx83102j_reload_to_active(struct himax_ts_data *ts) +{ + int ret; + u32 retry_cnt; + const u32 addr = HIMAX_REG_ADDR_RELOAD_TO_ACTIVE; + const u32 reload_to_active_cmd = 0xec; + const u32 reload_to_active_done = 0x01ec; + const u32 retry_limit = 5; + union himax_dword_data data; + + for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) { + data.dword = cpu_to_le32(reload_to_active_cmd); + ret = himax_mcu_register_write(ts, addr, data.byte, 4); + if (ret < 0) + return ret; + usleep_range(1000, 1100); + ret = himax_mcu_register_read(ts, addr, data.byte, 4); + if (ret < 0) + return ret; + data.dword = le32_to_cpu(data.dword); + if (data.word[0] == reload_to_active_done) + break; + } + + if (data.word[0] != reload_to_active_done) { + dev_err(ts->dev, "%s: Reload to active failed!\n", __func__); + return -EINVAL; + } + + return 0; +} + +/** + * hx83102j_en_hw_crc() - Enable/Disable HW CRC + * @ts: Himax touch screen data + * @en: true for enable, false for disable + * + * This function is used to enable or disable the HW CRC. The HW CRC + * is used to protect the SRAM data. + * + * Return: 0 on success, negative error code on failure + */ +static int hx83102j_en_hw_crc(struct himax_ts_data *ts, bool en) +{ + int ret; + u32 retry_cnt; + const u32 addr = HIMAX_HX83102J_REG_ADDR_HW_CRC; + const u32 retry_limit = 5; + union himax_dword_data data, wrt_data; + + if (en) + data.dword = cpu_to_le32(HIMAX_HX83102J_REG_DATA_HW_CRC); + else + data.dword = cpu_to_le32(HIMAX_HX83102J_REG_DATA_HW_CRC_DISABLE); + + wrt_data.dword = data.dword; + for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) { + ret = himax_mcu_register_write(ts, addr, data.byte, 4); + if (ret < 0) + return ret; + usleep_range(1000, 1100); + ret = himax_mcu_register_read(ts, addr, data.byte, 4); + if (ret < 0) + return ret; + + if (data.word[0] == wrt_data.word[0]) + break; + } + + if (data.word[0] != wrt_data.word[0]) { + dev_err(ts->dev, "%s: ECC fail!\n", __func__); + return -EINVAL; + } + + return 0; +} + /** * hx83102j_sense_off() - Stop MCU and enter safe mode * @ts: Himax touch screen data @@ -641,6 +727,56 @@ static int hx83102j_sense_off(struct himax_ts_data *ts, bool check_en) return -EIO; } +/** + * hx83102j_sense_on() - Sense on the touch chip + * @ts: Himax touch screen data + * @sw_reset: true for software reset, false for hardware reset + * + * This function is used to sense on the touch chip, which means to start running the + * FW. The process begin with wakeup the IC bus interface, then write a flag to the IC + * register to make MCU restart running the FW. When sw_reset is true, the function will + * send a command to the IC to leave safe mode. Otherwise, the function will call + * himax_mcu_ic_reset() to reset the touch chip by hardware pin. + * Then enable the HW CRC to protect sram data, and reload to active to make the MCU + * start running without reload the firmware. + * + * Return: 0 on success, negative error code on failure + */ +static int hx83102j_sense_on(struct himax_ts_data *ts, bool sw_reset) +{ + int ret; + const union himax_dword_data re_init = { + .dword = cpu_to_le32(HIMAX_REG_DATA_FW_RE_INIT) + }; + union himax_dword_data data; + + dev_info(ts->dev, "%s: software reset %s\n", __func__, sw_reset ? "true" : "false"); + ret = himax_mcu_interface_on(ts); + if (ret < 0) + return ret; + + ret = himax_mcu_register_write(ts, HIMAX_REG_ADDR_CTRL_FW, re_init.byte, 4); + if (ret < 0) + return ret; + usleep_range(10000, 11000); + if (!sw_reset) { + himax_mcu_ic_reset(ts, false); + } else { + data.word[0] = cpu_to_le16(HIMAX_AHB_CMD_LEAVE_SAFE_MODE); + ret = himax_write(ts, HIMAX_AHB_ADDR_PSW_LB, NULL, data.byte, 2); + if (ret < 0) + return ret; + } + ret = hx83102j_en_hw_crc(ts, true); + if (ret < 0) + return ret; + ret = hx83102j_reload_to_active(ts); + if (ret < 0) + return ret; + + return 0; +} + /** * hx83102j_chip_detect() - Check if the touch chip is HX83102J * @ts: Himax touch screen data @@ -783,166 +919,980 @@ static int hx83102j_read_event_stack(struct himax_ts_data *ts, u8 *buf, u32 leng int ret; const u32 max_trunk_sz = ts->spi_xfer_max_sz - HIMAX_BUS_R_HLEN; - for (i = 0; i < length; i += max_trunk_sz) { - ret = himax_read(ts, HIMAX_AHB_ADDR_EVENT_STACK, buf + i, - min(length - i, max_trunk_sz)); + for (i = 0; i < length; i += max_trunk_sz) { + ret = himax_read(ts, HIMAX_AHB_ADDR_EVENT_STACK, buf + i, + min(length - i, max_trunk_sz)); + if (ret) { + dev_err(ts->dev, "%s: read event stack error!\n", __func__); + return ret; + } + } + + return 0; +} + +/** + * hx83102j_chip_init_data() - Initialize the touch chip data + * @ts: Himax touch screen data + * + * This function is used to initialize hx83102j touch specific data in himax_ts_data. + * The chip_max_dsram_size is the maximum size of the DSRAM of hx83102j. + * + * Return: None + */ +static void hx83102j_chip_init_data(struct himax_ts_data *ts) +{ + ts->chip_max_dsram_size = HIMAX_HX83102J_DSRAM_SZ; +} + +/** + * himax_touch_get() - Get touch data from touch chip + * @ts: Himax touch screen data + * @buf: Buffer to store the data + * + * This function is a wrapper to call hx83102j_read_event_stack() to read the touch + * data from the touch chip. The touch_data_sz is the size of the touch data to read, + * which is calculated by hid report descriptor provided by the firmware. + * + * Return: HIMAX_TS_SUCCESS on success, negative error code on failure. We categorize + * the error code into HIMAX_TS_GET_DATA_FAIL when the read fails, and HIMAX_TS_SUCCESS + * when the read is successful. The reason is that the may need special handling when + * the read fails. + */ +static int himax_touch_get(struct himax_ts_data *ts, u8 *buf) +{ + if (hx83102j_read_event_stack(ts, buf, ts->touch_data_sz)) { + dev_err(ts->dev, "can't read data from chip!"); + return HIMAX_TS_GET_DATA_FAIL; + } + + return HIMAX_TS_SUCCESS; +} + +/** + * himax_mcu_assign_sorting_mode() - Write sorting mode to dsram and verify + * @ts: Himax touch screen data + * @tmp_data_in: password to write + * + * This function is used to write the sorting mode password to dsram and verify the + * password is written correctly. The sorting mode password is used as a flag to + * FW to let it know which mode the touch chip is working on. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_mcu_assign_sorting_mode(struct himax_ts_data *ts, u8 *tmp_data_in) +{ + int ret; + u8 rdata[4]; + u32 retry_cnt; + const u32 retry_limit = 3; + + for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) { + ret = himax_mcu_register_write(ts, HIMAX_DSRAM_ADDR_SORTING_MODE_EN, + tmp_data_in, HIMAX_REG_SZ); + if (ret < 0) { + dev_err(ts->dev, "%s: write sorting mode fail\n", __func__); + return ret; + } + usleep_range(1000, 1100); + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_SORTING_MODE_EN, + rdata, HIMAX_REG_SZ); + if (ret < 0) { + dev_err(ts->dev, "%s: read sorting mode fail\n", __func__); + return ret; + } + + if (!memcmp(tmp_data_in, rdata, HIMAX_REG_SZ)) + return 0; + } + dev_err(ts->dev, "%s: fail to write sorting mode\n", __func__); + + return -EINVAL; +} + +/** + * himax_mcu_read_FW_status() - Read FW status from touch chip + * @ts: Himax touch screen data + * + * This function is used to read the FW status from the touch chip. The FW status is + * values from dsram and register from TPIC. Which shows the FW vital working status + * for developer debug. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_mcu_read_FW_status(struct himax_ts_data *ts) +{ + int i; + int ret; + size_t len; + u8 data[4]; + const char * const reg_name[] = { + "DBG_MSG", + "FW_STATUS", + "DD_STATUS", + "RESET_FLAG" + }; + const u32 dbg_reg_array[] = { + HIMAX_DSRAM_ADDR_DBG_MSG, + HIMAX_REG_ADDR_FW_STATUS, + HIMAX_REG_ADDR_DD_STATUS, + HIMAX_REG_ADDR_RESET_FLAG + }; + + len = ARRAY_SIZE(dbg_reg_array); + + for (i = 0; i < len; i++) { + ret = himax_mcu_register_read(ts, dbg_reg_array[i], data, HIMAX_REG_SZ); + if (ret < 0) { + dev_err(ts->dev, "%s: read FW status fail\n", __func__); + return ret; + } + + dev_info(ts->dev, "%s: %10s(0x%08X) = 0x%02X, 0x%02X, 0x%02X, 0x%02X\n", + __func__, reg_name[i], dbg_reg_array[i], + data[0], data[1], data[2], data[3]); + } + + return 0; +} + +/** + * himax_mcu_power_on_init() - Power on initialization + * @ts: Himax touch screen data + * + * This function is used to do the power on initialization after firmware has been + * loaded to sram. The process initialize varies IC register and dsram to make sure + * FW start running correctly. When all set, sense on the touch chip to make the FW + * start running and wait for the FW reload done password. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_mcu_power_on_init(struct himax_ts_data *ts) +{ + int ret; + u32 retry_cnt; + const u32 retry_limit = 30; + union himax_dword_data data; + + /* RawOut select initial */ + data.dword = cpu_to_le32(HIMAX_DATA_CLEAR); + ret = himax_mcu_register_write(ts, HIMAX_HX83102J_DSRAM_ADDR_RAW_OUT_SEL, data.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: set RawOut select fail\n", __func__); + return ret; + } + /* Initial sorting mode password to normal mode */ + ret = himax_mcu_assign_sorting_mode(ts, data.byte); + if (ret < 0) { + dev_err(ts->dev, "%s: assign sorting mode fail\n", __func__); + return ret; + } + /* N frame initial */ + /* reset N frame back to default value 1 for normal mode */ + data.dword = cpu_to_le32(1); + ret = himax_mcu_register_write(ts, HIMAX_DSRAM_ADDR_SET_NFRAME, data.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: set N frame fail\n", __func__); + return ret; + } + /* Initial FW reload status */ + data.dword = cpu_to_le32(HIMAX_DATA_CLEAR); + ret = himax_mcu_register_write(ts, HIMAX_DSRAM_ADDR_2ND_FLASH_RELOAD, data.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: initial FW reload status fail\n", __func__); + return ret; + } + + ret = hx83102j_sense_on(ts, false); + if (ret < 0) { + dev_err(ts->dev, "%s: sense on fail\n", __func__); + return ret; + } + + dev_info(ts->dev, "%s: waiting for FW reload data\n", __func__); + for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) { + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_2ND_FLASH_RELOAD, data.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read FW reload status fail\n", __func__); + return ret; + } + + /* use all 4 bytes to compare */ + if (le32_to_cpu(data.dword) == HIMAX_DSRAM_DATA_FW_RELOAD_DONE) { + dev_info(ts->dev, "%s: FW reload done\n", __func__); + break; + } + dev_info(ts->dev, "%s: wait FW reload %u times\n", __func__, retry_cnt + 1); + ret = himax_mcu_read_FW_status(ts); + if (ret < 0) + dev_err(ts->dev, "%s: read FW status fail\n", __func__); + + usleep_range(10000, 11000); + } + + if (retry_cnt == retry_limit) { + dev_err(ts->dev, "%s: FW reload fail!\n", __func__); + return -EINVAL; + } + + return 0; +} + +/** + * himax_mcu_calculate_crc() - Calculate CRC-32 of given data + * @data: Data to calculate CRC + * @len: Length of data + * + * This function is used to calculate the CRC-32 of the given data. The function + * calculate the CRC-32 value by the polynomial 0x82f63b78. + * + * Return: CRC-32 value + */ +static u32 himax_mcu_calculate_crc(const u8 *data, int len) +{ + int i, j, length; + u32 crc = GENMASK(31, 0); + u32 current_data; + u32 tmp; + const u32 mask = GENMASK(30, 0); + + length = len / 4; + + for (i = 0; i < length; i++) { + current_data = data[i * 4]; + + for (j = 1; j < 4; j++) { + tmp = data[i * 4 + j]; + current_data += (tmp) << (8 * j); + } + crc = current_data ^ crc; + for (j = 0; j < 32; j++) { + if ((crc % 2) != 0) + crc = ((crc >> 1) & mask) ^ CRC32C_POLY_LE; + else + crc = (((crc >> 1) & mask)); + } + } + + return crc; +} + +/** + * himax_mcu_check_crc() - Let TPIC check CRC itself + * @ts: Himax touch screen data + * @start_addr: Start address of the data in sram to check + * @reload_length: Length of the data to check + * @crc_result: CRC result for return + * + * This function is used to let TPIC check the CRC of the given data in sram. The + * function write the start address and length of the data to the TPIC, and wait for + * the TPIC to finish the CRC check. When the CRC check is done, the function read + * the CRC result from the TPIC. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_mcu_check_crc(struct himax_ts_data *ts, u32 start_addr, + int reload_length, u32 *crc_result) +{ + int ret; + int length = reload_length / HIMAX_REG_SZ; + u32 retry_cnt; + const u32 retry_limit = 100; + union himax_dword_data data, addr; + + addr.dword = cpu_to_le32(start_addr); + ret = himax_mcu_register_write(ts, HIMAX_REG_ADDR_RELOAD_ADDR_FROM, addr.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: write reload start address fail\n", __func__); + return ret; + } + + data.word[1] = cpu_to_le16(HIMAX_REG_DATA_RELOAD_PASSWORD); + data.word[0] = cpu_to_le16(length); + ret = himax_mcu_register_write(ts, HIMAX_REG_ADDR_RELOAD_ADDR_CMD_BEAT, data.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: write reload length and password fail!\n", __func__); + return ret; + } + + ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_RELOAD_ADDR_CMD_BEAT, data.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read reload length and password fail!\n", __func__); + return ret; + } + + if (le16_to_cpu(data.word[0]) != length) { + dev_err(ts->dev, "%s: length verify failed!\n", __func__); + return -EINVAL; + } + + for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) { + ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_RELOAD_STATUS, data.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read reload status fail!\n", __func__); + return ret; + } + + data.dword = le32_to_cpu(data.dword); + if ((data.byte[0] & HIMAX_REG_DATA_RELOAD_DONE) != HIMAX_REG_DATA_RELOAD_DONE) { + ret = himax_mcu_register_read(ts, HIMAX_REG_ADDR_RELOAD_CRC32_RESULT, + data.byte, HIMAX_REG_SZ); + if (ret < 0) { + dev_err(ts->dev, "%s: read crc32 result fail!\n", __func__); + return ret; + } + *crc_result = le32_to_cpu(data.dword); + return 0; + } + + dev_info(ts->dev, "%s: Waiting for HW ready!\n", __func__); + usleep_range(1000, 1100); + } + + if (retry_cnt == retry_limit) { + ret = himax_mcu_read_FW_status(ts); + if (ret < 0) + dev_err(ts->dev, "%s: read FW status fail\n", __func__); + } + + return -EINVAL; +} + +/** + * himax_mcu_read_FW_ver() - Read varies version from touch chip + * @ts: Himax touch screen data + * + * This function is used to read the firmware version, config version, touch config + * version, display config version, customer ID, customer info, and project info from + * the touch chip. The function will call himax_mcu_register_read() to read the data + * from the TPIC, and store the data to the IC data in himax_ts_data. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_mcu_read_FW_ver(struct himax_ts_data *ts) +{ + int ret; + u8 data[HIMAX_TP_INFO_STR_LEN]; + + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_FW_VER, data, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read FW version fail\n", __func__); + return ret; + } + ts->ic_data.vendor_panel_ver = data[0]; + ts->ic_data.vendor_fw_ver = data[1] << 8 | data[2]; + dev_info(ts->dev, "%s: PANEL_VER: %X\n", __func__, ts->ic_data.vendor_panel_ver); + dev_info(ts->dev, "%s: FW_VER: %X\n", __func__, ts->ic_data.vendor_fw_ver); + + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_CFG, data, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read CFG version fail\n", __func__); + return ret; + } + ts->ic_data.vendor_config_ver = data[2] << 8 | data[3]; + ts->ic_data.vendor_touch_cfg_ver = data[2]; + dev_info(ts->dev, "%s: TOUCH_VER: %X\n", __func__, ts->ic_data.vendor_touch_cfg_ver); + ts->ic_data.vendor_display_cfg_ver = data[3]; + dev_info(ts->dev, "%s: DISPLAY_VER: %X\n", __func__, ts->ic_data.vendor_display_cfg_ver); + + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_VENDOR, data, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read customer ID fail\n", __func__); + return ret; + } + ts->ic_data.vendor_cid_maj_ver = data[2]; + ts->ic_data.vendor_cid_min_ver = data[3]; + dev_info(ts->dev, "%s: CID_VER: %X\n", __func__, (ts->ic_data.vendor_cid_maj_ver << 8 + | ts->ic_data.vendor_cid_min_ver)); + + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_CUS_INFO, data, HIMAX_TP_INFO_STR_LEN); + if (ret < 0) { + dev_err(ts->dev, "%s: read customer info fail\n", __func__); + return ret; + } + memcpy(ts->ic_data.vendor_cus_info, data, HIMAX_TP_INFO_STR_LEN); + dev_info(ts->dev, "%s: Cusomer ID : %s\n", __func__, ts->ic_data.vendor_cus_info); + + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_PROJ_INFO, data, HIMAX_TP_INFO_STR_LEN); + if (ret < 0) { + dev_err(ts->dev, "%s: read project info fail\n", __func__); + return ret; + } + memcpy(ts->ic_data.vendor_proj_info, data, HIMAX_TP_INFO_STR_LEN); + dev_info(ts->dev, "%s: Project ID : %s\n", __func__, ts->ic_data.vendor_proj_info); + + return 0; +} + +/** + * himax_bin_desc_data_get() - Parse descriptor data from firmware token + * @ts: Himax touch screen data + * @addr: Address of the data in firmware image + * @descript_buf: token for parsing + * + * This function is used to parse the descriptor data from the firmware token. The + * descriptors are mappings of information in the firmware image. The function will + * check checksum of each token first, and then parse the token to get the related + * data. The data includes CID version, FW version, CFG version, touch config table, + * HID table, HID descriptor, and HID read descriptor. + * + * Return: true on success, false on failure + */ +static bool himax_bin_desc_data_get(struct himax_ts_data *ts, u32 addr, u8 *descript_buf) +{ + u16 chk_end; + u16 chk_sum; + u32 hid_table_addr; + u32 i, j; + u32 image_offset; + u32 map_code; + const u32 data_sz = 16; + const u32 report_desc_offset = 24; + union { + u8 *buf; + u32 *word; + } map_data; + + /* looking for mapping in page, each mapping is 16 bytes */ + for (i = 0; i < HIMAX_HX83102J_PAGE_SIZE; i = i + data_sz) { + chk_end = 0; + chk_sum = 0; + for (j = i; j < (i + data_sz); j++) { + chk_end |= descript_buf[j]; + chk_sum += descript_buf[j]; + } + if (!chk_end) { /* 1. Check all zero */ + return false; + } else if (chk_sum % 0x100) { /* 2. Check sum */ + dev_warn(ts->dev, "%s: chk sum failed in %X\n", __func__, i + addr); + } else { /* 3. get data */ + map_data.buf = &descript_buf[i]; + map_code = le32_to_cpup(map_data.word); + map_data.buf = &descript_buf[i + 4]; + image_offset = le32_to_cpup(map_data.word); + /* 4. load info from FW image by specified mapping offset */ + switch (map_code) { + /* Config ID */ + case HIMAX_FW_CID: + ts->fw_info_table.addr_cid_ver_major = image_offset; + ts->fw_info_table.addr_cid_ver_minor = image_offset + 1; + break; + /* FW version */ + case HIMAX_FW_VER: + ts->fw_info_table.addr_fw_ver_major = image_offset; + ts->fw_info_table.addr_fw_ver_minor = image_offset + 1; + break; + /* Config version */ + case HIMAX_CFG_VER: + ts->fw_info_table.addr_cfg_ver_major = image_offset; + ts->fw_info_table.addr_cfg_ver_minor = image_offset + 1; + break; + /* Touch config table */ + case HIMAX_TP_CONFIG_TABLE: + ts->fw_info_table.addr_cfg_table = image_offset; + break; + /* HID table */ + case HIMAX_HID_TABLE: + ts->fw_info_table.addr_hid_table = image_offset; + hid_table_addr = image_offset; + ts->fw_info_table.addr_hid_desc = hid_table_addr; + ts->fw_info_table.addr_hid_rd_desc = + hid_table_addr + report_desc_offset; + break; + } + } + } + + return true; +} + +/** + * himax_mcu_bin_desc_get() - Check and get the bin description from the data + * @fw: Firmware data + * @ts: Himax touch screen data + * @max_sz: Maximum size to check + * + * This function is used to check and get the bin description from the firmware data. + * It will check the given data to see if it match the bin description format, and + * call himax_bin_desc_data_get() to get the related data. + * + * Return: true on mapping_count > 0, false on otherwise + */ +static bool himax_mcu_bin_desc_get(unsigned char *fw, struct himax_ts_data *ts, u32 max_sz) +{ + bool keep_on_flag; + u32 addr; + u32 mapping_count; + unsigned char *fw_buf; + const u8 header_id = 0x87; + const u8 header_id_loc = 0x0e; + const u8 header_sz = 8; + const u8 header[8] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + /* Check bin is with description table or not */ + if (!(memcmp(fw, header, header_sz) == 0 && fw[header_id_loc] == header_id)) { + dev_err(ts->dev, "%s: No description table\n", __func__); + return false; + } + + for (addr = 0, mapping_count = 0; addr < max_sz; addr += HIMAX_HX83102J_PAGE_SIZE) { + fw_buf = &fw[addr]; + /* Get related data */ + keep_on_flag = himax_bin_desc_data_get(ts, addr, fw_buf); + if (keep_on_flag) + mapping_count++; + else + break; + } + + return mapping_count > 0; +} + +/** + * himax_mcu_tp_info_check() - Read touch information from touch chip + * @ts: Himax touch screen data + * + * This function is used to read the touch information from the touch chip. The + * information includes the touch resolution, touch point number, interrupt type, + * button number, stylus function, stylus version, and stylus ratio. These information + * is filled by FW after the FW initialized, so it must be called after FW finish + * loading. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_mcu_tp_info_check(struct himax_ts_data *ts) +{ + int ret; + char data[HIMAX_REG_SZ]; + u8 stylus_ratio; + u32 button_num; + u32 max_pt; + u32 rx_num; + u32 tx_num; + u32 x_res; + u32 y_res; + const u32 button_num_mask = 0x03; + const u32 interrupt_type_mask = 0x01; + const u32 interrupt_type_edge = 0x01; + bool int_is_edge; + bool stylus_func; + bool stylus_id_v2; + + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_RXNUM_TXNUM, data, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read rx/tx num fail\n", __func__); + return ret; + } + rx_num = data[2]; + tx_num = data[3]; + + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_MAXPT_XYRVS, data, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read max touch point fail\n", __func__); + return ret; + } + max_pt = data[0]; + + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_X_Y_RES, data, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read x/y resolution fail\n", __func__); + return ret; + } + y_res = be16_to_cpup((u16 *)&data[0]); + x_res = be16_to_cpup((u16 *)&data[2]); + + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_INT_IS_EDGE, data, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read interrupt type fail\n", __func__); + return ret; + } + if ((data[1] & interrupt_type_mask) == interrupt_type_edge) + int_is_edge = true; + else + int_is_edge = false; + + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_MKEY, data, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read button number fail\n", __func__); + return ret; + } + button_num = data[0] & button_num_mask; + + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_STYLUS_FUNCTION, data, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read stylus function fail\n", __func__); + return ret; + } + stylus_func = data[3] ? true : false; + + if (stylus_func) { + ret = himax_mcu_register_read(ts, HIMAX_DSRAM_ADDR_STYLUS_VERSION, data, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: read stylus version fail\n", __func__); + return ret; + } + /* dsram_addr_stylus_version + 2 : 0=off 1=on */ + stylus_id_v2 = data[2] ? true : false; + /* dsram_addr_stylus_version + 3 : 0=ratio_1 10=ratio_10 */ + stylus_ratio = data[3]; + } + + ts->ic_data.button_num = button_num; + ts->ic_data.stylus_function = stylus_func; + ts->ic_data.rx_num = rx_num; + ts->ic_data.tx_num = tx_num; + ts->ic_data.x_res = x_res; + ts->ic_data.y_res = y_res; + ts->ic_data.max_point = max_pt; + ts->ic_data.interrupt_is_edge = int_is_edge; + if (stylus_func) { + ts->ic_data.stylus_v2 = stylus_id_v2; + ts->ic_data.stylus_ratio = stylus_ratio; + } else { + ts->ic_data.stylus_v2 = false; + ts->ic_data.stylus_ratio = 0; + } + + dev_info(ts->dev, "%s: rx_num = %u, tx_num = %u\n", __func__, + ts->ic_data.rx_num, ts->ic_data.tx_num); + dev_info(ts->dev, "%s: max_point = %u\n", __func__, ts->ic_data.max_point); + dev_info(ts->dev, "%s: interrupt_is_edge = %s, stylus_function = %s\n", __func__, + ts->ic_data.interrupt_is_edge ? "true" : "false", + ts->ic_data.stylus_function ? "true" : "false"); + dev_info(ts->dev, "%s: stylus_v2 = %s, stylus_ratio = %u\n", __func__, + ts->ic_data.stylus_v2 ? "true" : "false", ts->ic_data.stylus_ratio); + dev_info(ts->dev, "%s: TOUCH INFO updated\n", __func__); + + return 0; +} + +/** + * himax_disable_fw_reload() - Disable the FW reload data from flash + * @ts: Himax touch screen data + * + * This function is used to tell FW not to reload data from flash. It needs to be + * set before FW start running. + * + * return: 0 on success, negative error code on failure + */ +static int himax_disable_fw_reload(struct himax_ts_data *ts) +{ + union himax_dword_data data = { + /* + * HIMAX_DSRAM_ADDR_FLASH_RELOAD: 0x10007f00 + * 0x10007f00 <= 0x9aa9, let FW know there's no flash + * <= 0x5aa5, there has flash, but not reload + * <= 0x0000, there has flash, and reload + */ + .dword = cpu_to_le32(HIMAX_DSRAM_DATA_DISABLE_FLASH_RELOAD) + }; + + /* Disable Flash Reload */ + return himax_mcu_register_write(ts, HIMAX_DSRAM_ADDR_FLASH_RELOAD, data.byte, 4); +} + +/** + * himax_sram_write_crc_check() - Write the data to SRAM and check the CRC by hardware + * @ts: Himax touch screen data + * @addr: Address to write to + * @data: Data to write + * @len: Length of data + * + * This function is use to write FW code/data to SRAM and check the CRC by hardware to make + * sure the written data is correct. The FW code is designed to be CRC result 0, so if the + * CRC result is not 0, it means the written data is not correct. + * + * return: 0 on success, negative error code on failure + */ +static int himax_sram_write_crc_check(struct himax_ts_data *ts, u32 addr, const u8 *data, u32 len) +{ + int ret; + u32 crc; + u32 retry_cnt; + const u32 retry_limit = 3; + + for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) { + dev_info(ts->dev, "%s: Write FW to SRAM - total write size = %u\n", __func__, len); + ret = himax_mcu_register_write(ts, addr, data, len); + if (ret) { + dev_err(ts->dev, "%s: write FW to SRAM fail\n", __func__); + return ret; + } + ret = himax_mcu_check_crc(ts, addr, len, &crc); + if (ret) { + dev_err(ts->dev, "%s: check CRC fail\n", __func__); + return ret; + } + dev_info(ts->dev, "%s: HW CRC %s in %u time\n", __func__, + crc == 0 ? "OK" : "Fail", retry_cnt); + + if (crc == 0) + break; + } + + if (crc != 0) { + dev_err(ts->dev, "%s: HW CRC fail\n", __func__); + return -EINVAL; + } + + return 0; +} + +/** + * himax_zf_part_info() - Get and write the partition from the firmware to SRAM + * @fw: Firmware data + * @ts: Himax touch screen data + * + * This function is used to get the partition information from the firmware and write + * the partition to SRAM. The partition information includes the DSRAM address, the + * firmware offset, and the write size. The function will get the partition information + * into a table, and then write the partition to SRAM according to the table. After + * writing the partition to SRAM, the function will check the CRC by hardware to make + * sure the written data is correct. + * + * return: 0 on success, negative error code on failure + */ +static int himax_zf_part_info(const struct firmware *fw, struct himax_ts_data *ts) +{ + int i; + int i_max = -1; + int i_min = -1; + int pnum; + int ret; + u8 buf[HIMAX_ZF_PARTITION_DESC_SZ]; + u32 cfg_crc_sw; + u32 cfg_crc_hw; + u32 cfg_sz; + u32 dsram_base = 0xffffffff; + u32 dsram_max = 0; + u32 retry_cnt = 0; + u32 sram_min; + const u32 retry_limit = 3; + const u32 table_addr = ts->fw_info_table.addr_cfg_table; + struct himax_zf_info *info; + + /* 1. initial check */ + ret = hx83102j_en_hw_crc(ts, true); + if (ret < 0) { + dev_err(ts->dev, "%s: Failed to enable HW CRC\n", __func__); + return ret; + } + pnum = fw->data[table_addr + HIMAX_ZF_PARTITION_AMOUNT_OFFSET]; + if (pnum < 2) { + dev_err(ts->dev, "%s: partition number is not correct\n", __func__); + return -EINVAL; + } + + info = kcalloc(pnum, sizeof(struct himax_zf_info), GFP_KERNEL); + if (!info) + return -ENOMEM; + + memset(info, 0, pnum * sizeof(struct himax_zf_info)); + + /* + * 2. record partition information: + * partition 0: FW main code + */ + memcpy(buf, &fw->data[table_addr], HIMAX_ZF_PARTITION_DESC_SZ); + memcpy(info[0].sram_addr, buf, 4); + info[0].write_size = le32_to_cpup((u32 *)&buf[4]); + info[0].fw_addr = le32_to_cpup((u32 *)&buf[8]); + + /* partition 1 ~ n: config data */ + for (i = 1; i < pnum; i++) { + memcpy(buf, &fw->data[i * HIMAX_ZF_PARTITION_DESC_SZ + table_addr], + HIMAX_ZF_PARTITION_DESC_SZ); + memcpy(info[i].sram_addr, buf, 4); + info[i].write_size = le32_to_cpup((u32 *)&buf[4]); + info[i].fw_addr = le32_to_cpup((u32 *)&buf[8]); + info[i].cfg_addr = le32_to_cpup((u32 *)&info[i].sram_addr[0]); + + /* Write address must be multiple of 4 */ + if (info[i].cfg_addr % 4 != 0) { + info[i].cfg_addr -= (info[i].cfg_addr % 4); + info[i].fw_addr -= (info[i].cfg_addr % 4); + info[i].write_size += (info[i].cfg_addr % 4); + } + + if (dsram_base > info[i].cfg_addr) { + dsram_base = info[i].cfg_addr; + i_min = i; + } + if (dsram_max < info[i].cfg_addr) { + dsram_max = info[i].cfg_addr; + i_max = i; + } + } + + if (i_min < 0 || i_max < 0) { + dev_err(ts->dev, "%s: DSRAM address invalid!\n", __func__); + return -EINVAL; + } + + /* 3. prepare data to update */ + sram_min = info[i_min].cfg_addr; + + cfg_sz = (dsram_max - dsram_base) + info[i_max].write_size; + /* Wrtie size must be multiple of 4 */ + if (cfg_sz % 4 != 0) + cfg_sz = cfg_sz + 4 - (cfg_sz % 4); + + dev_info(ts->dev, "%s: main code sz = %d, config sz = %d\n", __func__, + info[0].write_size, cfg_sz); + /* config size should be smaller than DSRAM size */ + if (cfg_sz > ts->chip_max_dsram_size) { + dev_err(ts->dev, "%s: config size error[%d, %u]!!\n", __func__, + cfg_sz, ts->chip_max_dsram_size); + ret = -EINVAL; + goto alloc_cfg_buffer_failed; + } + + memset(ts->zf_update_cfg_buffer, 0x00, + ts->chip_max_dsram_size * sizeof(u8)); + + /* Collect all partition in FW for DSRAM in a cfg buffer */ + for (i = 1; i < pnum; i++) + memcpy(&ts->zf_update_cfg_buffer[info[i].cfg_addr - dsram_base], + &fw->data[info[i].fw_addr], info[i].write_size); + + /* + * 4. write to sram + * First, write FW main code and check CRC by HW + */ + ret = himax_sram_write_crc_check(ts, le32_to_cpup((u32 *)info[0].sram_addr), + &fw->data[info[0].fw_addr], info[0].write_size); + if (ret < 0) { + dev_err(ts->dev, "%s: HW CRC fail\n", __func__); + goto write_main_code_failed; + } + + /* + * Second, FW config data: Calculate CRC of CFG data which is going to write. + * CFG data don't have CRC pre-defined in FW and need to be calculated by driver. + */ + cfg_crc_sw = himax_mcu_calculate_crc(ts->zf_update_cfg_buffer, cfg_sz); + for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) { + /* Write hole cfg data to DSRAM */ + dev_info(ts->dev, "%s: Write cfg to SRAM - total write size = %d\n", + __func__, cfg_sz); + ret = himax_mcu_register_write(ts, sram_min, ts->zf_update_cfg_buffer, cfg_sz); + if (ret < 0) { + dev_err(ts->dev, "%s: write cfg to SRAM fail\n", __func__); + goto write_cfg_failed; + } + /* + * Check CRC: Tell HW to calculate CRC from CFG start address in SRAM and check + * size is equal to size of CFG buffer written. Then we compare the two CRC data + * make sure data written is correct. + */ + ret = himax_mcu_check_crc(ts, sram_min, cfg_sz, &cfg_crc_hw); if (ret) { - dev_err(ts->dev, "%s: read event stack error!\n", __func__); - return ret; + dev_err(ts->dev, "%s: check CRC failed!\n", __func__); + goto crc_failed; } - } - return 0; -} + if (cfg_crc_hw != cfg_crc_sw) + dev_err(ts->dev, "%s: Cfg CRC FAIL, HWCRC = %X, SWCRC = %X, retry = %u\n", + __func__, cfg_crc_hw, cfg_crc_sw, retry_cnt); + else + break; + } -/** - * himax_touch_get() - Get touch data from touch chip - * @ts: Himax touch screen data - * @buf: Buffer to store the data - * - * This function is a wrapper to call hx83102j_read_event_stack() to read the touch - * data from the touch chip. The touch_data_sz is the size of the touch data to read, - * which is calculated by hid report descriptor provided by the firmware. - * - * Return: HIMAX_TS_SUCCESS on success, negative error code on failure. We categorize - * the error code into HIMAX_TS_GET_DATA_FAIL when the read fails, and HIMAX_TS_SUCCESS - * when the read is successful. The reason is that the may need special handling when - * the read fails. - */ -static int himax_touch_get(struct himax_ts_data *ts, u8 *buf) -{ - if (hx83102j_read_event_stack(ts, buf, ts->touch_data_sz)) { - dev_err(ts->dev, "can't read data from chip!"); - return HIMAX_TS_GET_DATA_FAIL; + if (retry_cnt == retry_limit && cfg_crc_hw != cfg_crc_sw) { + dev_err(ts->dev, "%s: Write cfg to SRAM fail\n", __func__); + ret = -EINVAL; + goto crc_not_match; } - return HIMAX_TS_SUCCESS; +crc_not_match: +crc_failed: +write_cfg_failed: +write_main_code_failed: +alloc_cfg_buffer_failed: + kfree(info); + + return ret; } /** - * himax_bin_desc_data_get() - Parse descriptor data from firmware token + * himax_mcu_firmware_update_zf() - Update the firmware to the touch chip + * @fw: Firmware data * @ts: Himax touch screen data - * @addr: Address of the data in firmware image - * @descript_buf: token for parsing * - * This function is used to parse the descriptor data from the firmware token. The - * descriptors are mappings of information in the firmware image. The function will - * check checksum of each token first, and then parse the token to get the related - * data. The data includes CID version, FW version, CFG version, touch config table, - * HID table, HID descriptor, and HID read descriptor. + * This function is used to update the firmware to the touch chip. The first step is + * to reset the touch chip, stop the MCU and then write the firmware to the touch chip. * - * Return: true on success, false on failure + * return: 0 on success, negative error code on failure */ -static bool himax_bin_desc_data_get(struct himax_ts_data *ts, u32 addr, u8 *descript_buf) +static int himax_mcu_firmware_update_zf(const struct firmware *fw, struct himax_ts_data *ts) { - u16 chk_end; - u16 chk_sum; - u32 hid_table_addr; - u32 i, j; - u32 image_offset; - u32 map_code; - const u32 data_sz = 16; - const u32 report_desc_offset = 24; - union { - u8 *buf; - u32 *word; - } map_data; + int ret; + union himax_dword_data data_system_reset = { + .dword = cpu_to_le32(HIMAX_REG_DATA_SYSTEM_RESET) + }; - /* looking for mapping in page, each mapping is 16 bytes */ - for (i = 0; i < HIMAX_HX83102J_PAGE_SIZE; i = i + data_sz) { - chk_end = 0; - chk_sum = 0; - for (j = i; j < (i + data_sz); j++) { - chk_end |= descript_buf[j]; - chk_sum += descript_buf[j]; - } - if (!chk_end) { /* 1. Check all zero */ - return false; - } else if (chk_sum % 0x100) { /* 2. Check sum */ - dev_warn(ts->dev, "%s: chk sum failed in %X\n", __func__, i + addr); - } else { /* 3. get data */ - map_data.buf = &descript_buf[i]; - map_code = le32_to_cpup(map_data.word); - map_data.buf = &descript_buf[i + 4]; - image_offset = le32_to_cpup(map_data.word); - /* 4. load info from FW image by specified mapping offset */ - switch (map_code) { - /* Config ID */ - case HIMAX_FW_CID: - ts->fw_info_table.addr_cid_ver_major = image_offset; - ts->fw_info_table.addr_cid_ver_minor = image_offset + 1; - break; - /* FW version */ - case HIMAX_FW_VER: - ts->fw_info_table.addr_fw_ver_major = image_offset; - ts->fw_info_table.addr_fw_ver_minor = image_offset + 1; - break; - /* Config version */ - case HIMAX_CFG_VER: - ts->fw_info_table.addr_cfg_ver_major = image_offset; - ts->fw_info_table.addr_cfg_ver_minor = image_offset + 1; - break; - /* Touch config table */ - case HIMAX_TP_CONFIG_TABLE: - ts->fw_info_table.addr_cfg_table = image_offset; - break; - /* HID table */ - case HIMAX_HID_TABLE: - ts->fw_info_table.addr_hid_table = image_offset; - hid_table_addr = image_offset; - ts->fw_info_table.addr_hid_desc = hid_table_addr; - ts->fw_info_table.addr_hid_rd_desc = - hid_table_addr + report_desc_offset; - break; - } - } + dev_info(ts->dev, "%s: Updating FW - total FW size = %u\n", __func__, (u32)fw->size); + ret = himax_mcu_register_write(ts, HIMAX_REG_ADDR_SYSTEM_RESET, data_system_reset.byte, 4); + if (ret < 0) { + dev_err(ts->dev, "%s: system reset fail\n", __func__); + return ret; } - return true; + ret = hx83102j_sense_off(ts, false); + if (ret) + return ret; + + ret = himax_zf_part_info(fw, ts); + + return ret; } /** - * himax_mcu_bin_desc_get() - Check and get the bin description from the data - * @fw: Firmware data + * himax_zf_reload_from_file() - Complete firmware update sequence + * @file_name: File name of the firmware * @ts: Himax touch screen data - * @max_sz: Maximum size to check * - * This function is used to check and get the bin description from the firmware data. - * It will check the given data to see if it match the bin description format, and - * call himax_bin_desc_data_get() to get the related data. + * This function process the full sequence of updating the firmware to the touch chip. + * It will first check if the other thread is updating now, if not, it will request the + * firmware from user space and then call himax_mcu_firmware_update_zf() to update the + * firmware, and then tell firmware not to reload data from flash and initial the touch + * chip by calling himax_mcu_power_on_init(). * - * Return: true on mapping_count > 0, false on otherwise + * return: 0 on success, negative error code on failure */ -static bool himax_mcu_bin_desc_get(unsigned char *fw, struct himax_ts_data *ts, u32 max_sz) +static int himax_zf_reload_from_file(char *file_name, struct himax_ts_data *ts) { - bool keep_on_flag; - u32 addr; - u32 mapping_count; - unsigned char *fw_buf; - const u8 header_id = 0x87; - const u8 header_id_loc = 0x0e; - const u8 header_sz = 8; - const u8 header[8] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 - }; + int ret; + const struct firmware *fw; - /* Check bin is with description table or not */ - if (!(memcmp(fw, header, header_sz) == 0 && fw[header_id_loc] == header_id)) { - dev_err(ts->dev, "%s: No description table\n", __func__); - return false; + if (!mutex_trylock(&ts->zf_update_lock)) { + dev_warn(ts->dev, "%s: Other thread is updating now!\n", __func__); + return 0; } + dev_info(ts->dev, "%s: Preparing to update %s!\n", __func__, file_name); - for (addr = 0, mapping_count = 0; addr < max_sz; addr += HIMAX_HX83102J_PAGE_SIZE) { - fw_buf = &fw[addr]; - /* Get related data */ - keep_on_flag = himax_bin_desc_data_get(ts, addr, fw_buf); - if (keep_on_flag) - mapping_count++; - else - break; + ret = request_firmware(&fw, file_name, ts->dev); + if (ret < 0) { + dev_err(ts->dev, "%s: request firmware fail, code[%d]!!\n", __func__, ret); + goto load_firmware_error; } - return mapping_count > 0; + ret = himax_mcu_firmware_update_zf(fw, ts); + release_firmware(fw); + if (ret < 0) + goto load_firmware_error; + + ret = himax_disable_fw_reload(ts); + if (ret < 0) + goto load_firmware_error; + ret = himax_mcu_power_on_init(ts); + +load_firmware_error: + mutex_unlock(&ts->zf_update_lock); + + return ret; } /** @@ -1248,6 +2198,7 @@ static int himax_ts_operation(struct himax_ts_data *ts) * This function is used to handle interrupt bottom half work. It will * call the himax_ts_operation() to get the touch data, dispatch the data * to HID core. If the touch data is not valid, it will reset the TPIC. + * It will also call the hx83102j_reload_to_active() after the reset action. * * Return: void */ @@ -1256,7 +2207,38 @@ static void himax_ts_work(struct himax_ts_data *ts) if (himax_ts_operation(ts) == HIMAX_TS_GET_DATA_FAIL) { dev_info(ts->dev, "%s: Now reset the Touch chip\n", __func__); himax_mcu_ic_reset(ts, true); + if (hx83102j_reload_to_active(ts)) + dev_warn(ts->dev, "%s: Reload to active failed\n", __func__); + } +} + +/** + * himax_update_fw() - update firmware using firmware structure + * @ts: Himax touch screen data + * + * This function use already initialize firmware structure in ts to update + * firmware. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_update_fw(struct himax_ts_data *ts) +{ + int ret; + u32 retry_cnt; + const u32 retry_limit = 3; + + for (retry_cnt = 0; retry_cnt < retry_limit; retry_cnt++) { + ret = himax_mcu_firmware_update_zf(ts->himax_fw, ts); + if (ret < 0) { + dev_err(ts->dev, "%s: TP upgrade error, upgrade_times = %d\n", __func__, + retry_cnt); + } else { + dev_info(ts->dev, "%s: TP FW upgrade OK\n", __func__); + return 0; + } } + + return -EIO; } /** @@ -1289,9 +2271,8 @@ static int himax_hid_rd_init(struct himax_ts_data *ts) if (!ts->hid_rd_data.rd_data) return -ENOMEM; } - /* Copy the base RD from firmware table */ memcpy((void *)ts->hid_rd_data.rd_data, - &ts->himax_fw_data[ts->fw_info_table.addr_hid_rd_desc], + &ts->himax_fw->data[ts->fw_info_table.addr_hid_rd_desc], ts->hid_desc.report_desc_length); ts->hid_rd_data.rd_length = ts->hid_desc.report_desc_length; } @@ -1401,81 +2382,95 @@ static void himax_power_deconfig(struct himax_platform_data *pdata) } } -/* load firmware data from flash, parse HID info and register HID */ /** - * himax_load_config() - Load the firmware from the flash - * @ts: Himax touch screen data + * himax_initial_work() - Initial work for the touch screen + * @work: Work structure + * + * This function is used to do the initial work for the touch screen. It will + * call the request_firmware() to get the firmware from the file system, and parse the + * mapping table in 1k header. If the headers are parsed successfully, it will + * call the himax_update_fw() to update the firmware and power on the touch screen. + * If the power on action is successful, it will load the hid descriptor and + * check the touch panel information. If the touch panel information is correct, + * it will call the himax_hid_rd_init() to initialize the HID report descriptor, + * and call the himax_hid_register() to register the HID device. After all is done, + * it will release the firmware and enable the interrupt. * - * This function is used to load the firmware from the flash. It will read - * the firmware from the flash and parse the HID info. If the HID info is - * valid, it will initialize the HID report descriptor and register the HID - * device. If the HID device is probed, it will initialize the report data - * and enable the interrupt. - * - * Return: 0 on success, negative error code on failure + * Return: None */ -static int himax_load_config(struct himax_ts_data *ts) +static void himax_initial_work(struct work_struct *work) { + struct himax_ts_data *ts = container_of(work, struct himax_ts_data, + initial_work.work); int ret; - s32 i; - s32 page_sz = (s32)HIMAX_HX83102J_PAGE_SIZE; - s32 flash_sz = (s32)HIMAX_HX83102J_FLASH_SIZE; - bool fw_load_status = false; + bool fw_load_status; const u32 fw_bin_header_sz = 1024; ts->ic_boot_done = false; - - ts->himax_fw_data = devm_kzalloc(ts->dev, HIMAX_HX83102J_FLASH_SIZE, GFP_KERNEL); - if (!ts->himax_fw_data) - return -ENOMEM; - - for (i = 0; i < flash_sz; i += page_sz) { - ret = himax_mcu_register_read(ts, i, ts->himax_fw_data + i, - (flash_sz - i) > page_sz ? page_sz : (flash_sz - i)); - if (ret < 0) { - dev_err(ts->dev, "%s: read FW from flash fail!\n", __func__); - return ret; - } + dev_info(ts->dev, "%s: request file %s\n", __func__, ts->firmware_name); + ret = request_firmware(&ts->himax_fw, ts->firmware_name, ts->dev); + if (ret < 0) { + dev_err(ts->dev, "%s: request firmware failed, error code = %d\n", __func__, ret); + return; } - /* Search mapping table in 1k header */ - fw_load_status = himax_mcu_bin_desc_get((unsigned char *)ts->himax_fw_data, + /* Parse the mapping table in 1k header */ + fw_load_status = himax_mcu_bin_desc_get((unsigned char *)ts->himax_fw->data, ts, fw_bin_header_sz); if (!fw_load_status) { - dev_err(ts->dev, "%s: FW load status fail!\n", __func__); - return -EINVAL; + dev_err(ts->dev, "%s: Failed to parse the mapping table!\n", __func__); + goto err_load_bin_descriptor; } - if (ts->fw_info_table.addr_hid_desc != 0) { - memcpy(&ts->hid_desc, - &ts->himax_fw_data[ts->fw_info_table.addr_hid_desc], - sizeof(struct himax_hid_desc)); - ts->hid_desc.desc_length = - le16_to_cpu(ts->hid_desc.desc_length); - ts->hid_desc.bcd_version = - le16_to_cpu(ts->hid_desc.bcd_version); - ts->hid_desc.report_desc_length = - le16_to_cpu(ts->hid_desc.report_desc_length); - ts->hid_desc.max_input_length = - le16_to_cpu(ts->hid_desc.max_input_length); - ts->hid_desc.max_output_length = - le16_to_cpu(ts->hid_desc.max_output_length); - ts->hid_desc.max_fragment_length = - le16_to_cpu(ts->hid_desc.max_fragment_length); - ts->hid_desc.vendor_id = - le16_to_cpu(ts->hid_desc.vendor_id); - ts->hid_desc.product_id = - le16_to_cpu(ts->hid_desc.product_id); - ts->hid_desc.version_id = - le16_to_cpu(ts->hid_desc.version_id); - ts->hid_desc.flags = - le16_to_cpu(ts->hid_desc.flags); + if (himax_update_fw(ts)) { + dev_err(ts->dev, "%s: Update FW fail\n", __func__); + goto err_update_fw_failed; } + dev_info(ts->dev, "%s: Update FW success\n", __func__); + /* write flag to sram to stop fw reload again. */ + if (himax_disable_fw_reload(ts)) + goto err_disable_fw_reload; + if (himax_mcu_power_on_init(ts)) + goto err_power_on_init; + /* get hid descriptors */ + if (!ts->fw_info_table.addr_hid_desc) { + dev_err(ts->dev, "%s: No HID descriptor! Wrong FW!\n", __func__); + goto err_wrong_firmware; + } + memcpy(&ts->hid_desc, + &ts->himax_fw->data[ts->fw_info_table.addr_hid_desc], + sizeof(struct himax_hid_desc)); + ts->hid_desc.desc_length = + le16_to_cpu(ts->hid_desc.desc_length); + ts->hid_desc.bcd_version = + le16_to_cpu(ts->hid_desc.bcd_version); + ts->hid_desc.report_desc_length = + le16_to_cpu(ts->hid_desc.report_desc_length); + ts->hid_desc.max_input_length = + le16_to_cpu(ts->hid_desc.max_input_length); + ts->hid_desc.max_output_length = + le16_to_cpu(ts->hid_desc.max_output_length); + ts->hid_desc.max_fragment_length = + le16_to_cpu(ts->hid_desc.max_fragment_length); + ts->hid_desc.vendor_id = + le16_to_cpu(ts->hid_desc.vendor_id); + ts->hid_desc.product_id = + le16_to_cpu(ts->hid_desc.product_id); + ts->hid_desc.version_id = + le16_to_cpu(ts->hid_desc.version_id); + ts->hid_desc.flags = + le16_to_cpu(ts->hid_desc.flags); + + if (himax_mcu_tp_info_check(ts)) + goto err_tp_info_failed; + if (himax_mcu_read_FW_ver(ts)) + goto err_read_fw_ver; if (himax_hid_rd_init(ts)) { dev_err(ts->dev, "%s: hid rd init fail\n", __func__); goto err_hid_rd_init_failed; } + usleep_range(1000000, 1000100); himax_hid_register(ts); if (!ts->hid_probed) { goto err_hid_probe_failed; @@ -1486,19 +2481,28 @@ static int himax_load_config(struct himax_ts_data *ts) } } - ts->himax_fw_data = NULL; + release_firmware(ts->himax_fw); + ts->himax_fw = NULL; + ts->ic_boot_done = true; himax_int_enable(ts, true); - return 0; + return; err_report_data_init_failed: himax_hid_remove(ts); ts->hid_probed = false; err_hid_probe_failed: err_hid_rd_init_failed: - - return -EINVAL; +err_read_fw_ver: +err_tp_info_failed: +err_wrong_firmware: +err_power_on_init: +err_disable_fw_reload: +err_update_fw_failed: +err_load_bin_descriptor: + release_firmware(ts->himax_fw); + ts->himax_fw = NULL; } /** @@ -1550,12 +2554,22 @@ static void himax_ap_notify_fw_suspend(struct himax_ts_data *ts, bool suspend) * @ts: Himax touch screen data * * This function is used to resume the touch screen. It will call the + * himax_zf_reload_from_file() to reload the firmware. And call the * himax_ap_notify_fw_suspend() to notify the FW of AP resume status. * * Return: None */ static void himax_resume_proc(struct himax_ts_data *ts) { + int ret; + + ret = himax_zf_reload_from_file(ts->firmware_name, ts); + if (ret) { + dev_err(ts->dev, "%s: update FW fail, code[%d]!!\n", __func__, ret); + return; + } + ts->resume_succeeded = true; + himax_ap_notify_fw_suspend(ts, false); } @@ -1586,17 +2600,25 @@ static int himax_chip_suspend(struct himax_ts_data *ts) * This function is used to resume the touch screen. It will set the resume * success flag to false, and disable reset pin. Then call the himax_resume_proc() * to process detailed resume procedure. + * If the resume action is succeeded, it will call the himax_hid_probe() to restore + * the HID device and enable the interrupt. * * Return: 0 on success, negative error code on failure */ static int himax_chip_resume(struct himax_ts_data *ts) { + ts->resume_succeeded = false; if (himax_power_set(ts, true)) return -EIO; gpiod_set_value(ts->pdata.gpiod_rst, 0); himax_resume_proc(ts); - himax_hid_probe(ts); - himax_int_enable(ts, true); + if (ts->resume_succeeded) { + himax_hid_probe(ts); + himax_int_enable(ts, true); + } else { + dev_err(ts->dev, "%s: resume failed!\n", __func__); + return -ECANCELED; + } return 0; } @@ -1657,8 +2679,7 @@ static int himax_resume(struct device *dev) * initialize interrupt lock, register the interrupt, and disable the * interrupt. If later part of initialization succeed, then interrupt will * be enabled. - * It will also load the firmware from the flash, parse the HID info, and - * register the HID device by calling the himax_load_config(). + * And initialize varies flags, workqueue and delayed work for later use. * * Return: 0 on success, negative error code on failure */ @@ -1666,18 +2687,93 @@ static int himax_chip_init(struct himax_ts_data *ts) { int ret; + hx83102j_chip_init_data(ts); if (himax_ts_register_interrupt(ts)) { dev_err(ts->dev, "%s: register interrupt failed\n", __func__); return -EIO; } himax_int_enable(ts, false); - ret = himax_load_config(ts); - if (ret < 0) - return ret; + ts->zf_update_cfg_buffer = devm_kzalloc(ts->dev, ts->chip_max_dsram_size, GFP_KERNEL); + if (!ts->zf_update_cfg_buffer) { + ret = -ENOMEM; + goto err_update_cfg_buf_alloc_failed; + } + INIT_DELAYED_WORK(&ts->initial_work, himax_initial_work); + schedule_delayed_work(&ts->initial_work, msecs_to_jiffies(HIMAX_DELAY_BOOT_UPDATE_MS)); ts->initialized = true; + return 0; + cancel_delayed_work_sync(&ts->initial_work); +err_update_cfg_buf_alloc_failed: + + return ret; +} + +/** + * himax_chip_deinit() - Deinitialize the Himax touch screen + * @ts: Himax touch screen data + * + * This function is used to deinitialize the Himax touch screen. + * + * Return: None + */ +static void himax_chip_deinit(struct himax_ts_data *ts) +{ + cancel_delayed_work_sync(&ts->initial_work); +} + +#if defined(CONFIG_OF) +/** + * himax_parse_dt() - Parse the device tree + * @dt: Device node + * @pdata: Himax platform data + * + * This function is used to parse the device tree. If "himax,pid" is found, + * it will parse the PID value and set it to the platform data. The firmware + * name will set to himax_i2chid_$PID.bin if the PID is found, or + * himax_i2chid.bin if the PID is not found. + * + * Return: 0 on success, negative error code on failure + */ +static int himax_parse_dt(struct device_node *dt, struct himax_platform_data *pdata) +{ + int err; + size_t fw_name_len; + const char *fw_name; + struct himax_ts_data *ts; + + if (!dt || !pdata) + return -EINVAL; + + ts = container_of(pdata, struct himax_ts_data, pdata); + /* Set default firmware name, without PID */ + strscpy(ts->firmware_name, HIMAX_BOOT_UPGRADE_FWNAME HIMAX_FW_EXT_NAME, + sizeof(HIMAX_BOOT_UPGRADE_FWNAME HIMAX_FW_EXT_NAME)); + + if (of_property_read_bool(dt, "vccd-supply")) { + pdata->vccd_supply = regulator_get(ts->dev, "vccd"); + if (IS_ERR(pdata->vccd_supply)) { + dev_err(ts->dev, "%s: DT:failed to get vccd supply\n", __func__); + err = PTR_ERR(pdata->vccd_supply); + pdata->vccd_supply = NULL; + return err; + } + dev_info(ts->dev, "%s: DT:vccd-supply=%p\n", __func__, pdata->vccd_supply); + } else { + pdata->vccd_supply = NULL; + } + + if (of_property_read_string(dt, "firmware-name", &fw_name)) { + dev_info(ts->dev, "%s: DT:firmware-name not found\n", __func__); + } else { + fw_name_len = strlen(fw_name) + 1; + strscpy(ts->firmware_name, fw_name, min(sizeof(ts->firmware_name), fw_name_len)); + dev_info(ts->dev, "%s: firmware-name = %s\n", __func__, ts->firmware_name); + } + return 0; } +#endif /** * __himax_initial_power_up() - Initial power up of the Himax touch screen @@ -1895,6 +2991,13 @@ static int himax_spi_drv_probe(struct spi_device *spi) dev_err(ts->dev, "%s: gpio-rst value is not valid\n", __func__); return -EIO; } +#if defined(CONFIG_OF) + if (himax_parse_dt(spi->dev.of_node, pdata) < 0) { + dev_err(ts->dev, "%s: parse OF data failed!\n", __func__); + ts->dev = NULL; + return -ENODEV; + } +#endif spi->bits_per_word = 8; spi->mode = SPI_MODE_3; @@ -1925,6 +3028,7 @@ static int himax_spi_drv_probe(struct spi_device *spi) spin_lock_init(&ts->irq_lock); mutex_init(&ts->rw_lock); mutex_init(&ts->reg_lock); + mutex_init(&ts->zf_update_lock); dev_set_drvdata(&spi->dev, ts); spi_set_drvdata(spi, ts); @@ -1960,6 +3064,7 @@ static void himax_spi_drv_remove(struct spi_device *spi) if (ts->hid_probed) himax_hid_remove(ts); } + himax_chip_deinit(ts); himax_platform_deinit(ts); } } diff --git a/drivers/hid/hid-himax.h b/drivers/hid/hid-himax.h index 45dc3e6283ae..e426ffdc4cf2 100644 --- a/drivers/hid/hid-himax.h +++ b/drivers/hid/hid-himax.h @@ -9,7 +9,9 @@ #define __HID_HIMAX_83102J_H__ #include +#include #include +#include #include #include #include @@ -41,6 +43,13 @@ HIMAX_BUS_W_HLEN + HIMAX_REG_SZ) /* SPI CS setup time */ #define HIMAX_SPI_CS_SETUP_TIME 300 +/* Clear 4 bytes data */ +#define HIMAX_DATA_CLEAR 0x00000000 +/* boot update start delay */ +#define HIMAX_DELAY_BOOT_UPDATE_MS 2000 +#define HIMAX_TP_INFO_STR_LEN 12U +#define HIMAX_ZF_PARTITION_AMOUNT_OFFSET 12 +#define HIMAX_ZF_PARTITION_DESC_SZ 16U /* HIDRAW report header size */ #define HIMAX_HID_REPORT_HDR_SZ 2U /* hx83102j IC parameters */ @@ -71,17 +80,48 @@ #define HIMAX_AHB_CMD_INCR4_ADD_4_BYTE 0x01 #define HIMAX_AHB_CMD_LEAVE_SAFE_MODE 0x0000 /* DSRAM flag addresses */ +#define HIMAX_DSRAM_ADDR_VENDOR 0x10007000 +#define HIMAX_DSRAM_ADDR_FW_VER 0x10007004 +#define HIMAX_DSRAM_ADDR_CUS_INFO 0x10007008 +#define HIMAX_DSRAM_ADDR_PROJ_INFO 0x10007014 +#define HIMAX_DSRAM_ADDR_CFG 0x10007084 +#define HIMAX_DSRAM_ADDR_INT_IS_EDGE 0x10007088 +#define HIMAX_DSRAM_ADDR_MKEY 0x100070e8 +#define HIMAX_DSRAM_ADDR_RXNUM_TXNUM 0x100070f4 +#define HIMAX_DSRAM_ADDR_MAXPT_XYRVS 0x100070f8 +#define HIMAX_DSRAM_ADDR_X_Y_RES 0x100070fc +#define HIMAX_DSRAM_ADDR_STYLUS_FUNCTION 0x1000719c +#define HIMAX_DSRAM_ADDR_STYLUS_VERSION 0x100071fc +#define HIMAX_DSRAM_ADDR_SET_NFRAME 0x10007294 +#define HIMAX_DSRAM_ADDR_2ND_FLASH_RELOAD 0x100072c0 +#define HIMAX_DSRAM_ADDR_FLASH_RELOAD 0x10007f00 +#define HIMAX_DSRAM_ADDR_SORTING_MODE_EN 0x10007f04 +#define HIMAX_DSRAM_ADDR_DBG_MSG 0x10007f40 #define HIMAX_DSRAM_ADDR_AP_NOTIFY_FW_SUSPEND 0x10007fd0 /* dsram flag data */ #define HIMAX_DSRAM_DATA_AP_NOTIFY_FW_SUSPEND 0xa55aa55a #define HIMAX_DSRAM_DATA_AP_NOTIFY_FW_RESUME 0x00000000 +#define HIMAX_DSRAM_DATA_DISABLE_FLASH_RELOAD 0x00009aa9 +#define HIMAX_DSRAM_DATA_FW_RELOAD_DONE 0x000072c0 /* hx83102j-specific register/dsram flags/data */ +#define HIMAX_HX83102J_DSRAM_ADDR_RAW_OUT_SEL 0x100072ec +#define HIMAX_HX83102J_REG_ADDR_HW_CRC 0x80010000 #define HIMAX_HX83102J_REG_ADDR_TCON_RST 0x80020004 +#define HIMAX_HX83102J_REG_DATA_HW_CRC 0x0000ecce +#define HIMAX_HX83102J_REG_DATA_HW_CRC_DISABLE 0x00000000 /* hardware register addresses */ #define HIMAX_REG_ADDR_SPI200_DATA 0x8000002c +#define HIMAX_REG_ADDR_RELOAD_STATUS 0x80050000 +#define HIMAX_REG_ADDR_RELOAD_CRC32_RESULT 0x80050018 +#define HIMAX_REG_ADDR_RELOAD_ADDR_FROM 0x80050020 +#define HIMAX_REG_ADDR_RELOAD_ADDR_CMD_BEAT 0x80050028 +#define HIMAX_REG_ADDR_SYSTEM_RESET 0x90000018 +#define HIMAX_REG_ADDR_RELOAD_TO_ACTIVE 0x90000048 #define HIMAX_REG_ADDR_CTRL_FW 0x9000005c #define HIMAX_REG_ADDR_FW_STATUS 0x900000a8 #define HIMAX_REG_ADDR_ICID 0x900000d0 +#define HIMAX_REG_ADDR_RESET_FLAG 0x900000e4 +#define HIMAX_REG_ADDR_DD_STATUS 0x900000e8 /* hardware reg data/flags */ #define HIMAX_REG_DATA_FW_STATE_RUNNING 0x05 #define HIMAX_REG_DATA_FW_STATE_SAFE_MODE 0x0c @@ -89,6 +129,9 @@ #define HIMAX_REG_DATA_FW_GO_SAFEMODE 0xa5 #define HIMAX_REG_DATA_FW_IN_SAFEMODE 0x87 #define HIMAX_REG_DATA_ICID 0x83102900 +#define HIMAX_REG_DATA_RELOAD_DONE 0x01 +#define HIMAX_REG_DATA_RELOAD_PASSWORD 0x99 +#define HIMAX_REG_DATA_SYSTEM_RESET 0x00000055 #define HIMAX_REG_DATA_TCON_RST 0x00000000 /* HIMAX SPI function select, 1st byte of any SPI command sequence */ #define HIMAX_SPI_FUNCTION_READ 0xf3 @@ -100,6 +143,8 @@ #define HIMAX_CFG_VER 0x10000600 #define HIMAX_HID_TABLE 0x30000100 #define HIMAX_FW_BIN_DESC 0x10000000 +#define HIMAX_BOOT_UPGRADE_FWNAME "himax_i2chid" +#define HIMAX_FW_EXT_NAME ".bin" /** * enum himax_hidraw_id_function - HIDRAW report IDs @@ -119,6 +164,20 @@ enum himax_touch_report_status { HIMAX_TS_SUCCESS = 0, }; +/** + * struct himax_zf_info - Zero flash update information + * @sram_addr: SRAM address byte array buffer + * @write_size: Write size of each chunk + * @fw_addr: Offset in firmware file + * @cfg_addr: target sram address + */ +struct himax_zf_info { + u8 sram_addr[4]; + int write_size; + u32 fw_addr; + u32 cfg_addr; +}; + /** * struct himax_fw_address_table - address/offset in firmware image * @addr_fw_ver_major: Address to Major version of firmware @@ -170,9 +229,21 @@ union himax_dword_data { /** * struct himax_ic_data - IC information holder * @stylus_ratio: Stylus ratio + * @vendor_cus_info: Vendor customer information + * @vendor_proj_info: Vendor project information + * @vendor_fw_ver: Vendor firmware version + * @vendor_config_ver: Vendor config version + * @vendor_touch_cfg_ver: Vendor touch config version + * @vendor_display_cfg_ver: Vendor display config version + * @vendor_cid_maj_ver: Vendor CID major version + * @vendor_cid_min_ver: Vendor CID minor version + * @vendor_panel_ver: Vendor panel version + * @vendor_sensor_id: Vendor sensor ID * @rx_num: Number of RX * @tx_num: Number of TX * @button_num: Number of buttons + * @x_res: X resolution + * @y_res: Y resolution * @max_point: Maximum touch point * @icid: IC ID * @interrupt_is_edge: Interrupt is edge otherwise level @@ -181,9 +252,21 @@ union himax_dword_data { */ struct himax_ic_data { u8 stylus_ratio; + u8 vendor_cus_info[12]; + u8 vendor_proj_info[12]; + int vendor_fw_ver; + int vendor_config_ver; + int vendor_touch_cfg_ver; + int vendor_display_cfg_ver; + int vendor_cid_maj_ver; + int vendor_cid_min_ver; + int vendor_panel_ver; + int vendor_sensor_id; u32 rx_num; u32 tx_num; u32 button_num; + u32 x_res; + u32 y_res; u32 max_point; u32 icid; bool interrupt_is_edge; @@ -191,6 +274,38 @@ struct himax_ic_data { bool stylus_v2; }; +/** + * struct himax_bin_desc - Firmware binary descriptor + * @passwd: Password to indicate the binary is valid + * @cid: Customer ID + * @panel_ver: Panel version + * @fw_ver: Firmware version + * @ic_sign: IC signature + * @customer: Customer name + * @project: Project name + * @fw_major: Major version of firmware + * @fw_minor: Minor version of firmware + * @date: Generate date of firmware + * @ic_sign_2: IC signature 2 + * + * This structure is used to hold the firmware binary descriptor. + * It directly maps to a sequence of bytes in firmware image, + * thus need to be packed. + */ +struct himax_bin_desc { + u16 passwd; + u16 cid; + u8 panel_ver; + u16 fw_ver; + u8 ic_sign; + char customer[12]; + char project[12]; + char fw_major[12]; + char fw_minor[12]; + char date[12]; + char ic_sign_2[12]; +} __packed; + /** * struct himax_hid_desc - HID descriptor * @desc_length: Length of HID descriptor @@ -223,6 +338,39 @@ struct himax_hid_desc { u32 reserved; } __packed; +/** + * struct himax_hid_info - IC information holder for HIDRAW function + * @vid: Vendor ID + * @pid: Product ID + * @cfg_info: Configuration information + * @cfg_version: Configuration version + * @disp_version: Display version + * @rx: Number of RX + * @tx: Number of TX + * @y_res: Y resolution + * @x_res: X resolution + * @pt_num: Number of touch points + * @mkey_num: Number of mkey + * @debug_info: Debug information + * + * This structure is used to hold the IC config information for HIDRAW. + * The format is binary fixed, thus need to be packed. + */ +struct himax_hid_info { + u16 vid; + u16 pid; + u8 cfg_info[32]; + u8 cfg_version; + u8 disp_version; + u8 rx; + u8 tx; + u16 y_res; + u16 x_res; + u8 pt_num; + u8 mkey_num; + u8 debug_info[78]; +} __packed; + /** * struct himax_platform_data - Platform data holder * @is_panel_follower: Is panel follower enabled @@ -244,8 +392,9 @@ struct himax_platform_data { * @xfer_buf: Interrupt data buffer * @xfer_rx_data: SPI Transfer receive data buffer * @xfer_tx_data: SPI Transfer transmit data buffer - * @himax_fw_data: Firmware data holder from flash + * @zf_update_cfg_buffer: Zero flash update configuration buffer * @himax_irq: IRQ number + * @chip_max_dsram_size: Maximum size of DSRAM * @spi_xfer_max_sz: Size of SPI controller max transfer size * @xfer_buf_sz: Size of interrupt data buffer * @irq_state: IRQ state @@ -254,24 +403,30 @@ struct himax_platform_data { * @probe_finish: Indicate the driver probe is finished * @ic_boot_done: Indicate the IC boot is done * @hid_probed: Indicate the HID device is probed + * @resume_succeeded: Indicate the resume is succeeded + * @firmware_name: Firmware name * @touch_data_sz: Size of each interrupt data from IC + * @himax_fw: Firmware data holder from user space * @dev: Device pointer * @spi: SPI device pointer * @hid: HID device pointer * @reg_lock: Mutex lock for reg access * @rw_lock: Mutex lock for read/write action + * @zf_update_lock: Mutex lock for zero-flash FW update * @ic_data: IC information holder * @pdata: Platform data holder * @fw_info_table: Firmware information address table of firmware image * @hid_desc: HID descriptor * @hid_rd_data: HID report descriptor data + * @initial_work: Delayed work for TP initialization */ struct himax_ts_data { u8 *xfer_buf; u8 *xfer_rx_data; u8 *xfer_tx_data; - u8 *himax_fw_data; + u8 *zf_update_cfg_buffer; s32 himax_irq; + u32 chip_max_dsram_size; u32 spi_xfer_max_sz; u32 xfer_buf_sz; atomic_t irq_state; @@ -281,7 +436,11 @@ struct himax_ts_data { bool probe_finish; bool ic_boot_done; bool hid_probed; + bool resume_succeeded; + bool zf_update_flag; + char firmware_name[64]; int touch_data_sz; + const struct firmware *himax_fw; struct device *dev; struct spi_device *spi; struct hid_device *hid; @@ -289,10 +448,13 @@ struct himax_ts_data { struct mutex reg_lock; /* lock for bus read/write action */ struct mutex rw_lock; + /* lock for zero-flash FW update */ + struct mutex zf_update_lock; struct himax_ic_data ic_data; struct himax_platform_data pdata; struct himax_fw_address_table fw_info_table; struct himax_hid_desc hid_desc; struct himax_hid_rd_data hid_rd_data; + struct delayed_work initial_work; }; #endif