From patchwork Fri Jan 5 08:26:42 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Christoph Winklhofer via B4 Relay X-Patchwork-Id: 760314 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B6C3921A17; Fri, 5 Jan 2024 08:27:05 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="lhvb/brI" Received: by smtp.kernel.org (Postfix) with ESMTPS id 51EA0C433C9; Fri, 5 Jan 2024 08:27:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1704443225; bh=G8eLuVwnsvFwn4kF39vSmn4oX45xzBPrmGlnzDyCVrY=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=lhvb/brIwBcIhUY6hJTYMUIz9BRxjoZkiCe4osmeqKEovt4N/1yvHnpZ/muqgJkSY OPJiUewPw7bk42vS3BiOEMHosaFmoaEB+umU1f+gRyOwkxlprKXLhgXHErbzUeFAUJ LPXx0NnBkgv3bTuZSHdCGLJ8rjwraZXD+5DWGWijGXPq/hlPw4C/LPtD8x0i7wMwId IwUx9ubh4M/OsTdtIk2e7JOgAuE+fA/6k0Q7kiCD/JMZaPqrzh2AvO7ZPxJpVxqg9C fwFG6JLrbVdiAkyUX1YAmUYBOK6JpQWiirIrQPg6qbSSxieoRltLhqf3TukB7wAoFG AjoZOdwVcDDSQ== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 37030C4707B; Fri, 5 Jan 2024 08:27:05 +0000 (UTC) From: Christoph Winklhofer via B4 Relay Date: Fri, 05 Jan 2024 09:26:42 +0100 Subject: [PATCH v3 1/3] dt-bindings: w1: UART 1-Wire bus Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20240105-w1-uart-v3-1-8687093b2e76@gmail.com> References: <20240105-w1-uart-v3-0-8687093b2e76@gmail.com> In-Reply-To: <20240105-w1-uart-v3-0-8687093b2e76@gmail.com> To: Krzysztof Kozlowski , Rob Herring , Conor Dooley , Christoph Winklhofer , Rob Herring , Greg Kroah-Hartman , Jiri Slaby , Krzysztof Kozlowski , Jonathan Corbet Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-serial@vger.kernel.org, linux-doc@vger.kernel.org X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1704443222; l=1794; i=cj.winklhofer@gmail.com; s=20240104; h=from:subject:message-id; bh=mQ67z9MozxmHEO1WDHe54CopgfQx4fCTtQWX0na1aCg=; b=YhCSSb9LicuB5pF3Y8aRvjUrvBF+D+7RDn+7/rpIYWGgWQXV0ZCJP8J7JZAQBxe2GaRDaukJT sgYnkIn+mVzD/FS0UCXTrBJQa9HuNDU8HweE3rd1VxvxnxdwwBqqAy4 X-Developer-Key: i=cj.winklhofer@gmail.com; a=ed25519; pk=lgjGjOt7hFKJT9UXhgUyrdthxvZ7DJ5F1U/7d9qdAsk= X-Endpoint-Received: by B4 Relay for cj.winklhofer@gmail.com/20240104 with auth_id=111 X-Original-From: Christoph Winklhofer Reply-To: From: Christoph Winklhofer Add device tree binding for UART 1-Wire bus. Signed-off-by: Christoph Winklhofer --- Documentation/devicetree/bindings/w1/w1-uart.yaml | 44 +++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/Documentation/devicetree/bindings/w1/w1-uart.yaml b/Documentation/devicetree/bindings/w1/w1-uart.yaml new file mode 100644 index 000000000000..93d83c42c407 --- /dev/null +++ b/Documentation/devicetree/bindings/w1/w1-uart.yaml @@ -0,0 +1,44 @@ +# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/w1/w1-uart.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: UART 1-Wire Bus + +maintainers: + - Christoph Winklhofer + +description: | + UART 1-wire bus. Utilizes the UART interface via the Serial Device Bus + to create the 1-Wire timing patterns. + + The UART peripheral must support full-duplex and operate in open-drain + mode. The timing patterns are generated by a specific combination of + baud-rate and transmitted byte, which corresponds to a 1-Wire read bit, + write bit or reset pulse. + + The default baud-rate for reset and presence detection is 9600 and for + a 1-Wire read or write operation 115200. In case the actual baud-rate + is different from the requested one, the transmitted byte is adapted + to generate the 1-Wire timing patterns. + + https://www.analog.com/en/technical-articles/using-a-uart-to-implement-a-1wire-bus-master.html + + +properties: + compatible: + const: w1-uart + +required: + - compatible + +additionalProperties: false + +examples: + - | + serial { + onewire { + compatible = "w1-uart"; + }; + }; From patchwork Fri Jan 5 08:26:43 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Christoph Winklhofer via B4 Relay X-Patchwork-Id: 760507 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B6BB121A12; Fri, 5 Jan 2024 08:27:05 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="NcFuCEyh" Received: by smtp.kernel.org (Postfix) with ESMTPS id 5D7BBC43391; Fri, 5 Jan 2024 08:27:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1704443225; bh=71uc0hK9NDOdEhHgFTZarT58L7adnWBofG0Y0tpQY4Q=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=NcFuCEyh+prk2fzKt+wDxEd4g9CaqT+SUEmJN6lIgMXxBfamoBotw7SWeFr/qT1qz zoWoWDG8AYA2oo9XA+6mCm3PNxF1xrX7QglLDOVrDneumceTdK/W/3ikMRFeDIhPgK DqOLgVenomd/xYaRsi7LUwrHL3ya3DMk20p5TwXXmr8g/9b8p+UmYLz+9+WE53lXkl LdxOEzTIv4y8MBU29uTsTP0t0t+EvxjGUnJ8YVdhUZyu4hd73l6RXGV8+VlmUS9xrF tZNqGTkJT2OP/Nx3CN5SokCKJpPqF50XyfPo2bHDB4iQYHxRFbq5vUAwAI2agd2Dh1 +3kx3auLxtAPQ== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 43CE4C3DA6E; Fri, 5 Jan 2024 08:27:05 +0000 (UTC) From: Christoph Winklhofer via B4 Relay Date: Fri, 05 Jan 2024 09:26:43 +0100 Subject: [PATCH v3 2/3] dt-bindings: serial: allow onewire as child node Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20240105-w1-uart-v3-2-8687093b2e76@gmail.com> References: <20240105-w1-uart-v3-0-8687093b2e76@gmail.com> In-Reply-To: <20240105-w1-uart-v3-0-8687093b2e76@gmail.com> To: Krzysztof Kozlowski , Rob Herring , Conor Dooley , Christoph Winklhofer , Rob Herring , Greg Kroah-Hartman , Jiri Slaby , Krzysztof Kozlowski , Jonathan Corbet Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-serial@vger.kernel.org, linux-doc@vger.kernel.org X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1704443222; l=827; i=cj.winklhofer@gmail.com; s=20240104; h=from:subject:message-id; bh=BPcWb7esDB40/mUZFKo7VPDltCBO7/vmdkKQuHI4X3c=; b=ay2ffRxDQFeORRmb/dFUU1+2tmYdubWI25/2dywCsok6JsxpAOUY/+GGh2vft0EDpfYIOh9CZ BrLamM8Za7rBjBIbMVgBG0MBgYYvd6Pdyqxpvz1QltICXRCtXrP9SU1 X-Developer-Key: i=cj.winklhofer@gmail.com; a=ed25519; pk=lgjGjOt7hFKJT9UXhgUyrdthxvZ7DJ5F1U/7d9qdAsk= X-Endpoint-Received: by B4 Relay for cj.winklhofer@gmail.com/20240104 with auth_id=111 X-Original-From: Christoph Winklhofer Reply-To: From: Christoph Winklhofer The UART 1-Wire bus utilizes the Serial Device Bus to create the 1-wire timing patterns. Signed-off-by: Christoph Winklhofer --- Documentation/devicetree/bindings/serial/serial.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Documentation/devicetree/bindings/serial/serial.yaml b/Documentation/devicetree/bindings/serial/serial.yaml index 65804ca274ae..ffc9198ae214 100644 --- a/Documentation/devicetree/bindings/serial/serial.yaml +++ b/Documentation/devicetree/bindings/serial/serial.yaml @@ -88,7 +88,7 @@ properties: TX FIFO threshold configuration (in bytes). patternProperties: - "^(bluetooth|bluetooth-gnss|gnss|gps|mcu)$": + "^(bluetooth|bluetooth-gnss|gnss|gps|mcu|onewire)$": if: type: object then: From patchwork Fri Jan 5 08:26:44 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Christoph Winklhofer via B4 Relay X-Patchwork-Id: 760506 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B6C0721A15; Fri, 5 Jan 2024 08:27:05 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="bz/yJr56" Received: by smtp.kernel.org (Postfix) with ESMTPS id 6E112C433AB; Fri, 5 Jan 2024 08:27:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1704443225; bh=y5sPUv2wdBFlG6mssPuU5yUexwpgD81fKWELe21u+eM=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=bz/yJr56LoaIR6SX5U4noxYpRSQNpL0tvyDYYrQYD20c3LxHt+Egcncz54b3+FEcc 2xkUBlK8dJNKK4IWIqIyc+pXdVxCvZ8q8hyr8ykcdBzwSGtxkDupDkqPT3qkjHPT40 kGw3Hagh9eK7pVr8UDkQc58WxuOTstwUddZACJcQrCCZU/MWnL7G7VQVEBrmCS6ENs 0kHt4PuX40HEtWNIbNbZYSw7rUGjb9WBBPDcODRXFcmvkSi23Ej6ZK327SqCJFSbwN eM1M9HDqbvHTd03lJ8OpjiBUBaPxuXLitbB+H5b1Wr5Ne0xFKxZMbawRRlWFNPFCpn c/dv2cfQzik7g== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 54908C47258; Fri, 5 Jan 2024 08:27:05 +0000 (UTC) From: Christoph Winklhofer via B4 Relay Date: Fri, 05 Jan 2024 09:26:44 +0100 Subject: [PATCH v3 3/3] w1: add UART w1 bus driver Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20240105-w1-uart-v3-3-8687093b2e76@gmail.com> References: <20240105-w1-uart-v3-0-8687093b2e76@gmail.com> In-Reply-To: <20240105-w1-uart-v3-0-8687093b2e76@gmail.com> To: Krzysztof Kozlowski , Rob Herring , Conor Dooley , Christoph Winklhofer , Rob Herring , Greg Kroah-Hartman , Jiri Slaby , Krzysztof Kozlowski , Jonathan Corbet Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-serial@vger.kernel.org, linux-doc@vger.kernel.org X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1704443223; l=14126; i=cj.winklhofer@gmail.com; s=20240104; h=from:subject:message-id; bh=+wByONRpAFHLfxLyx4fAPufVsBzip+JPcNQf6S9W/pw=; b=TnsYKBLVR4uC+Wwh7xopTrs0UpEIXucvY2JMVJkh824aD18zuIwpH6BKcBJD3e2DvPmhTJbnk FA/4nnFoPocDvy3WDr6P21lSpjScgJnIgCpxvrVaLPUbJyURS6i+jab X-Developer-Key: i=cj.winklhofer@gmail.com; a=ed25519; pk=lgjGjOt7hFKJT9UXhgUyrdthxvZ7DJ5F1U/7d9qdAsk= X-Endpoint-Received: by B4 Relay for cj.winklhofer@gmail.com/20240104 with auth_id=111 X-Original-From: Christoph Winklhofer Reply-To: From: Christoph Winklhofer Add a UART 1-Wire bus driver. The driver utilizes the UART interface via the Serial Device Bus to create the 1-Wire timing patterns. The driver was tested on a "Raspberry Pi 3B" with a DS18B20 and on a "Variscite DART-6UL" with a DS18S20 temperature sensor. The 1-Wire timing pattern and the corresponding UART baud-rate with the interpretation of the transferred bytes are described in the document: Link: https://www.analog.com/en/technical-articles/using-a-uart-to-implement-a-1wire-bus-master.html In short, the UART peripheral must support full-duplex and operate in open-drain mode. The timing patterns are generated by a specific combination of baud-rate and transmitted byte, which corresponds to a 1-Wire read bit, write bit or reset. Signed-off-by: Christoph Winklhofer --- Documentation/w1/masters/index.rst | 1 + Documentation/w1/masters/w1-uart.rst | 54 ++++++ drivers/w1/masters/Kconfig | 10 + drivers/w1/masters/Makefile | 1 + drivers/w1/masters/w1-uart.c | 350 +++++++++++++++++++++++++++++++++++ 5 files changed, 416 insertions(+) diff --git a/Documentation/w1/masters/index.rst b/Documentation/w1/masters/index.rst index 4442a98850ad..cc40189909fd 100644 --- a/Documentation/w1/masters/index.rst +++ b/Documentation/w1/masters/index.rst @@ -12,3 +12,4 @@ mxc-w1 omap-hdq w1-gpio + w1-uart diff --git a/Documentation/w1/masters/w1-uart.rst b/Documentation/w1/masters/w1-uart.rst new file mode 100644 index 000000000000..8d0f122178d4 --- /dev/null +++ b/Documentation/w1/masters/w1-uart.rst @@ -0,0 +1,54 @@ +.. SPDX-License-Identifier: GPL-2.0-or-later + +===================== +Kernel driver w1-uart +===================== + +Author: Christoph Winklhofer + + +Description +----------- + +UART 1-Wire bus driver. The driver utilizes the UART interface via the +Serial Device Bus to create the 1-Wire timing patterns as described in +the document `"Using a UART to Implement a 1-Wire Bus Master"`_. + +.. _"Using a UART to Implement a 1-Wire Bus Master": https://www.analog.com/en/technical-articles/using-a-uart-to-implement-a-1wire-bus-master.html + +In short, the UART peripheral must support full-duplex and operate in +open-drain mode. The timing patterns are generated by a specific +combination of baud-rate and transmitted byte, which corresponds to a +1-Wire read bit, write bit or reset pulse. + +For instance the timing pattern for a 1-Wire reset and presence detect uses +the baud-rate 9600, i.e. 104.2 us per bit. The transmitted byte 0xf0 over +UART (least significant bit first, start-bit low) sets the reset low time +for 1-Wire to 521 us. A present 1-Wire device changes the received byte by +pulling the line low, which is used by the driver to evaluate the result of +the 1-Wire operation. + +Similar for a 1-Wire read bit or write bit, which uses the baud-rate +115200, i.e. 8.7 us per bit. The transmitted byte 0x80 is used for a +Write-0 operation (low time 69.6us) and the byte 0xff for Read-0, Read-1 +and Write-1 (low time 8.7us). + +The default baud-rate for reset and presence detection is 9600 and for +a 1-Wire read or write operation 115200. In case the actual baud-rate +is different from the requested one, the transmitted byte is adapted +to generate the 1-Wire timing patterns. + + +Usage +----- + +Specify the UART 1-wire bus in the device tree by adding the single child +onewire to the serial node (e.g. uart0). For example: +:: + + @uart0 { + ... + onewire { + compatible = "w1-uart"; + }; + }; diff --git a/drivers/w1/masters/Kconfig b/drivers/w1/masters/Kconfig index 513c0b114337..e6049a75b35b 100644 --- a/drivers/w1/masters/Kconfig +++ b/drivers/w1/masters/Kconfig @@ -78,5 +78,15 @@ config W1_MASTER_SGI This support is also available as a module. If so, the module will be called sgi_w1. +config W1_MASTER_UART + tristate "UART 1-wire driver" + depends on SERIAL_DEV_BUS + help + Say Y here if you want to communicate with your 1-wire devices using + UART interface. + + This support is also available as a module. If so, the module + will be called w1-uart. + endmenu diff --git a/drivers/w1/masters/Makefile b/drivers/w1/masters/Makefile index 6c5a21f9b88c..227f80987e69 100644 --- a/drivers/w1/masters/Makefile +++ b/drivers/w1/masters/Makefile @@ -12,3 +12,4 @@ obj-$(CONFIG_W1_MASTER_MXC) += mxc_w1.o obj-$(CONFIG_W1_MASTER_GPIO) += w1-gpio.o obj-$(CONFIG_HDQ_MASTER_OMAP) += omap_hdq.o obj-$(CONFIG_W1_MASTER_SGI) += sgi_w1.o +obj-$(CONFIG_W1_MASTER_UART) += w1-uart.o diff --git a/drivers/w1/masters/w1-uart.c b/drivers/w1/masters/w1-uart.c new file mode 100644 index 000000000000..cfd1a4753644 --- /dev/null +++ b/drivers/w1/masters/w1-uart.c @@ -0,0 +1,350 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * w1-uart - UART 1-Wire bus driver + * + * Uses the UART interface (via Serial Device Bus) to create the 1-Wire + * timing patterns. Implements the following 1-Wire master interface: + * + * - reset_bus: requests baud-rate 9600 + * + * - touch_bit: requests baud-rate 115200 + * + * Author: Christoph Winklhofer + */ + +#include +#include +#include +#include +#include +#include +#include + +#define W1_UART_TIMEOUT msecs_to_jiffies(500) + +struct w1_uart_config { + unsigned int baudrate; + unsigned char tx_byte; +}; + +struct w1_uart_device { + struct serdev_device *serdev; + struct w1_bus_master bus; + + struct w1_uart_config cfg_reset; + struct w1_uart_config cfg_touch_0; + struct w1_uart_config cfg_touch_1; + + struct completion rx_byte_received; + unsigned char rx_byte; + int rx_err; + + struct mutex mutex; +}; + +/* + * struct w1_uart_limits - limits for 1-Wire operations + * + * @baudrate: Requested baud-rate to create 1-Wire timing pattern + * @bit_us: Recommended bit-time (in us) + * @bit_max_us: maximum time for a bit (in us) + * @time_min_us: minimum time for 1-Wire time slot (in us) + */ +struct w1_uart_limits { + unsigned int baudrate; + unsigned int bit_us; + unsigned int bit_max_us; + unsigned int time_min_us; +}; + +static inline unsigned int baud_to_bit_ns(unsigned int baud) +{ + return 1000000000 / baud; +} + +static inline unsigned int to_ns(unsigned int us) +{ + return us * 1000; +} + +/* + * Set baud-rate and tx-byte to create a 1-Wire pulse and adapt the + * tx-byte according to the actual baud-rate. + * + * Reject when: + * - a bit takes longer than the specified maximum + * - the 1-Wire time slot is too short to send the tx-byte + */ +static int w1_uart_set_config(struct serdev_device *serdev, + const struct w1_uart_limits *limits, + struct w1_uart_config *w1cfg) +{ + unsigned int bits_low; + unsigned int bit_ns; + + w1cfg->baudrate = serdev_device_set_baudrate(serdev, limits->baudrate); + if (w1cfg->baudrate == 0) + return -EINVAL; + + /* Compute in nanoseconds for accuracy */ + bit_ns = baud_to_bit_ns(w1cfg->baudrate); + + if (bit_ns > to_ns(limits->bit_max_us)) + return -EINVAL; + + /* time slot too short for UART byte */ + if (bit_ns * 10 < to_ns(limits->time_min_us)) + return -EINVAL; + + /* byte to create 1-Wire pulse */ + bits_low = to_ns(limits->bit_us) / bit_ns; + w1cfg->tx_byte = 0xff << bits_low; + + return 0; +} + +/* + * Configuration for reset and presence detect where minimum reset low time + * is 480us, use 500us with a margin for bit_us. + */ +static int w1_uart_set_config_reset(struct w1_uart_device *w1dev) +{ + const struct w1_uart_limits limits = { .baudrate = 9600, + .bit_us = 500, + .bit_max_us = 640, + .time_min_us = 960 }; + + return w1_uart_set_config(w1dev->serdev, &limits, &w1dev->cfg_reset); +} + +/* + * Configuration for write-0 cycle (touch bit 0) where minimum low time + * is 60us, use 65us with a margin for bit_us. + */ +static int w1_uart_set_config_touch_0(struct w1_uart_device *w1dev) +{ + const struct w1_uart_limits limits = { .baudrate = 115200, + .bit_us = 65, + .bit_max_us = 120, + .time_min_us = 65 }; + + return w1_uart_set_config(w1dev->serdev, &limits, &w1dev->cfg_touch_0); +} + +/* + * Configuration for write-1 and read cycle (touch bit 1) where + * minimum low time is 5us, use 7us with a margin for bit_us. + */ +static int w1_uart_set_config_touch_1(struct w1_uart_device *w1dev) +{ + const struct w1_uart_limits limits = { .baudrate = 115200, + .bit_us = 7, + .bit_max_us = 15, + .time_min_us = 65 }; + + return w1_uart_set_config(w1dev->serdev, &limits, &w1dev->cfg_touch_1); +} + +/* + * Configure and open the serial device + */ +static int w1_uart_serdev_open(struct w1_uart_device *w1dev) +{ + struct serdev_device *serdev = w1dev->serdev; + struct device *dev = &serdev->dev; + int ret; + + ret = devm_serdev_device_open(dev, serdev); + if (ret < 0) + return ret; + + ret = serdev_device_set_parity(serdev, SERDEV_PARITY_NONE); + if (ret < 0) { + dev_err(dev, "set parity failed\n"); + return ret; + } + + ret = w1_uart_set_config_reset(w1dev); + if (ret < 0) { + dev_err(dev, "config for reset failed\n"); + return ret; + } + + ret = w1_uart_set_config_touch_0(w1dev); + if (ret < 0) { + dev_err(dev, "config for touch-0 failed\n"); + return ret; + } + + ret = w1_uart_set_config_touch_1(w1dev); + if (ret < 0) { + dev_err(dev, "config for touch-1 failed\n"); + return ret; + } + + serdev_device_set_flow_control(serdev, false); + + return 0; +} + +/* + * Send one byte (tx_byte) and read one byte (rx_byte) via serdev. + */ +static int w1_uart_serdev_tx_rx(struct w1_uart_device *w1dev, + const struct w1_uart_config *w1cfg, + unsigned char *rx_byte) +{ + struct serdev_device *serdev = w1dev->serdev; + int ret; + + serdev_device_write_flush(serdev); + serdev_device_set_baudrate(serdev, w1cfg->baudrate); + + /* write and immediately read one byte */ + reinit_completion(&w1dev->rx_byte_received); + ret = serdev_device_write_buf(serdev, &w1cfg->tx_byte, 1); + if (ret != 1) + return -EIO; + ret = wait_for_completion_interruptible_timeout( + &w1dev->rx_byte_received, W1_UART_TIMEOUT); + if (ret <= 0) + return -EIO; + + /* locking could fail during driver remove or when serdev is + * unexpectedly in the receive callback. + */ + if (!mutex_trylock(&w1dev->mutex)) + return -EIO; + + ret = w1dev->rx_err; + if (ret == 0) + *rx_byte = w1dev->rx_byte; + + mutex_unlock(&w1dev->mutex); + + return ret; +} + +static int w1_uart_serdev_receive_buf(struct serdev_device *serdev, + const unsigned char *buf, size_t count) +{ + struct w1_uart_device *w1dev = serdev_device_get_drvdata(serdev); + + mutex_lock(&w1dev->mutex); + + /* sent a single byte and receive one single byte */ + if (count == 1) { + w1dev->rx_byte = buf[0]; + w1dev->rx_err = 0; + } else { + w1dev->rx_err = -EIO; + } + + mutex_unlock(&w1dev->mutex); + complete(&w1dev->rx_byte_received); + + return count; +} + +static const struct serdev_device_ops w1_uart_serdev_ops = { + .receive_buf = w1_uart_serdev_receive_buf, + .write_wakeup = serdev_device_write_wakeup, +}; + +/* + * 1-wire reset and presence detect: A present slave will manipulate + * the received byte by pulling the 1-Wire low. + */ +static u8 w1_uart_reset_bus(void *data) +{ + struct w1_uart_device *w1dev = data; + const struct w1_uart_config *w1cfg = &w1dev->cfg_reset; + unsigned char val; + int ret; + + ret = w1_uart_serdev_tx_rx(w1dev, w1cfg, &val); + if (ret < 0) + return -1; + + /* Device present (0) or no device (1) */ + return val != w1cfg->tx_byte ? 0 : 1; +} + +/* + * 1-Wire read and write cycle: Only the read-0 manipulates the + * received byte, all others left the line untouched. + */ +static u8 w1_uart_touch_bit(void *data, u8 bit) +{ + struct w1_uart_device *w1dev = data; + const struct w1_uart_config *w1cfg = bit ? &w1dev->cfg_touch_1 : + &w1dev->cfg_touch_0; + unsigned char val; + int ret; + + ret = w1_uart_serdev_tx_rx(w1dev, w1cfg, &val); + + /* return inactive bus state on error */ + if (ret < 0) + return 1; + + return val == w1cfg->tx_byte ? 1 : 0; +} + +static int w1_uart_probe(struct serdev_device *serdev) +{ + struct device *dev = &serdev->dev; + struct w1_uart_device *w1dev; + int ret; + + w1dev = devm_kzalloc(dev, sizeof(*w1dev), GFP_KERNEL); + if (!w1dev) + return -ENOMEM; + w1dev->bus.data = w1dev; + w1dev->bus.reset_bus = w1_uart_reset_bus; + w1dev->bus.touch_bit = w1_uart_touch_bit; + w1dev->serdev = serdev; + + init_completion(&w1dev->rx_byte_received); + mutex_init(&w1dev->mutex); + + ret = w1_uart_serdev_open(w1dev); + if (ret < 0) + return ret; + serdev_device_set_drvdata(serdev, w1dev); + serdev_device_set_client_ops(serdev, &w1_uart_serdev_ops); + + return w1_add_master_device(&w1dev->bus); +} + +static void w1_uart_remove(struct serdev_device *serdev) +{ + struct w1_uart_device *w1dev = serdev_device_get_drvdata(serdev); + + mutex_lock(&w1dev->mutex); + + w1_remove_master_device(&w1dev->bus); + + mutex_unlock(&w1dev->mutex); +} + +static const struct of_device_id w1_uart_of_match[] = { + { .compatible = "w1-uart" }, + {}, +}; +MODULE_DEVICE_TABLE(of, w1_uart_of_match); + +static struct serdev_device_driver w1_uart_driver = { + .driver = { + .name = "w1-uart", + .of_match_table = w1_uart_of_match, + }, + .probe = w1_uart_probe, + .remove = w1_uart_remove, +}; + +module_serdev_device_driver(w1_uart_driver); + +MODULE_DESCRIPTION("UART w1 bus driver"); +MODULE_AUTHOR("Christoph Winklhofer "); +MODULE_LICENSE("GPL");