From patchwork Wed Feb 14 06:36:13 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: 200824 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:7300:bc8a:b0:106:860b:bbdd with SMTP id dn10csp1024744dyb; Tue, 13 Feb 2024 22:37:19 -0800 (PST) X-Forwarded-Encrypted: i=3; AJvYcCXEUp8P3sKnudCnP8yqtcZZKEXYZVrCAGWN1lR//OjJ1DyEPRInU2v/DY5w2xKJbacz9iEqbkl7c28vKU1EbBr+9W1WJQ== X-Google-Smtp-Source: AGHT+IFCi+uJXs5Y3cd0ZnGJkQ8ZlGbkUTOf8jaw89bpPTDe0q3XjrwHKGqS1xqGMfWo6qiYpOuk X-Received: by 2002:a05:6808:648f:b0:3c0:4502:7669 with SMTP id fh15-20020a056808648f00b003c045027669mr1974495oib.20.1707892639538; Tue, 13 Feb 2024 22:37:19 -0800 (PST) ARC-Seal: i=2; a=rsa-sha256; t=1707892639; cv=pass; d=google.com; s=arc-20160816; b=x59bSc8y27D9owp4NoT7/OahydaP9o3oW7qHHi2hy+ROEMQQp7gWXOn4euwP8pKKbC 31iJ796iQ8Cv4JIHwjRt/WED/AKHuaH6CkP8GosjKbAVSRDZHcIxLqwUQiA+QzhDGCs4 gJ467/tA2LcaQ8bktc3sGS55KH5R1TyeP7q2vy8e6YOyOa1Yy7OVk9QDojkLGM7HlTLE sz9dilJikX8OnVYeK1IGQbVmy2hsU/9BhCddJuIEwh+Dt3jKfMqOsMYi1mDVel2VcG0v TKqzK48hL4TZq7DH9fyUj8Km0AU+5HrGcFZ66YYqNj1/3i6PkYe+rDkNCqYcMf909alU d+fw== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=reply-to:cc:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:list-unsubscribe :list-subscribe:list-id:precedence:subject:date:from:dkim-signature; bh=tEgDorvBuJGU5YIabV9jOCAycxFxDhRp7PtLF8ukfaQ=; fh=yV05Ww952crU3G16/g/b2Ljqk1ahKDuddRo2DVutTho=; b=IspRYudlswrf9oX7dMFePo3VCInr3isABZsuUnBwi5EfThp4hGHuzRTtHJV3ck74Dv JliAbFB3cNy+rGPTVF27ueljtzaOKq4XYnEKSdbeqfy89nS5qjUNRqb4UKX3RE3muQUw ZzudIHAhVW4edfSYY77Wn4l1F8vVrA/QtjjTI0vWdaQZDenTTik+QAtEQMC4u2b5IxLc VCRcJ2iwy+JynxF8Xy9I2eW88lHPK1JkQUO5gRLxdGlEDqKfTb9+VSvYa1pDZ7XxFpfx pkYw+UYmgIUPDJ0dSEOPrdnHWWTbOwuqiRnfe0prqI8Mkd4MEVav5UPLlZmP+c7G9tmx G0pw==; dara=google.com ARC-Authentication-Results: i=2; mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=IKdl5r8o; arc=pass (i=1 dkim=pass dkdomain=kernel.org); spf=pass (google.com: domain of linux-kernel+bounces-64791-ouuuleilei=gmail.com@vger.kernel.org designates 2604:1380:45e3:2400::1 as permitted sender) smtp.mailfrom="linux-kernel+bounces-64791-ouuuleilei=gmail.com@vger.kernel.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org X-Forwarded-Encrypted: i=2; AJvYcCWckEBMoOdQ5gWBxhCKHiCUX8uSV8qu7aL/Olyc4WJYjtzE0XmOemBV0dH/zueAZqHyg+mqyM1hXFQYZsO+Bqtuts7RjA== Received: from sv.mirrors.kernel.org (sv.mirrors.kernel.org. [2604:1380:45e3:2400::1]) by mx.google.com with ESMTPS id z16-20020aa78890000000b006e0541d5951si8273330pfe.385.2024.02.13.22.37.19 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 13 Feb 2024 22:37:19 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel+bounces-64791-ouuuleilei=gmail.com@vger.kernel.org designates 2604:1380:45e3:2400::1 as permitted sender) client-ip=2604:1380:45e3:2400::1; Authentication-Results: mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=IKdl5r8o; arc=pass (i=1 dkim=pass dkdomain=kernel.org); spf=pass (google.com: domain of linux-kernel+bounces-64791-ouuuleilei=gmail.com@vger.kernel.org designates 2604:1380:45e3:2400::1 as permitted sender) smtp.mailfrom="linux-kernel+bounces-64791-ouuuleilei=gmail.com@vger.kernel.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org Received: from smtp.subspace.kernel.org (wormhole.subspace.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by sv.mirrors.kernel.org (Postfix) with ESMTPS id 4435D28596B for ; Wed, 14 Feb 2024 06:37:19 +0000 (UTC) Received: from localhost.localdomain (localhost.localdomain [127.0.0.1]) by smtp.subspace.kernel.org (Postfix) with ESMTP id 02B0412B9B; Wed, 14 Feb 2024 06:36:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="IKdl5r8o" 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 37CFCDDA6; Wed, 14 Feb 2024 06:36:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1707892584; cv=none; b=YPJRoX5Emj9aGJa+fKr1S4JpyoCB7jXGOjzYpBLj5GTylax95DOJqzxZ8yTM2KCxaLiAgukeVmP4Cee0I4K2hboV3IrVvtbTBrzdYsZPdadmZ+VEK7+zrM/DSltXKN6nMj0yPxHB+3g+e9O+c0cjyPAbsNr+ptHSerLeZBPPlbI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1707892584; c=relaxed/simple; bh=S5QTvUq6sE9Cp1C8VwuWZA/YXB1LZbFmxjhmWirs68s=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Lp8xTJzsVHi3ZTfDORpNjv9rAW2S1XvgLz6ghrv/QIrGJhrkqvqWoCh99Gpr152lOm9CIIJtExkL4zxskZcURgKhZa9pmNwyirrrKqqDtEgBTPuW6escvTofBW7nW0DGcBCKcUBcybyj80iU0kbq1GKfaXOZ9NWxXzmMhF9GgEY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=IKdl5r8o; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPS id BDA69C433C7; Wed, 14 Feb 2024 06:36:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1707892583; bh=S5QTvUq6sE9Cp1C8VwuWZA/YXB1LZbFmxjhmWirs68s=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=IKdl5r8o/bdg/0ik9UeFg9GA9nvIUn469qlp45XfESDvS+BcGOTLSombxGzDjzpRh PaJ5wbOo39bimBb6rBJ/Qi1/GCBQPFo0aJRmodl/2dxIm77pDl3f8qLvz/7MfGq0R8 N2SOujs16mJC5UVLfPAS05ojrEDsHL/xrW3TrRBovgPORgxP3sbPY7zlOKjntq4oQr DAlbIbxBjyyK6uVZl/TQCD9u+TwOUyaTqwL0XHNDMbmcGfG4AiNRFCBm+oSp5N24fk B9BBRmMe2aZcJQwg/mw7rCt8OQ/xs9vSN+Tk+B4kssMOoC+PTtPIyqthr0h6Rczy8j iBCFypBaD7JHA== 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 A3B06C48BC4; Wed, 14 Feb 2024 06:36:23 +0000 (UTC) From: Christoph Winklhofer via B4 Relay Date: Wed, 14 Feb 2024 07:36:13 +0100 Subject: [PATCH v7 1/3] dt-bindings: serial: allow onewire as child node Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20240214-w1-uart-v7-1-6e21fa24e066@gmail.com> References: <20240214-w1-uart-v7-0-6e21fa24e066@gmail.com> In-Reply-To: <20240214-w1-uart-v7-0-6e21fa24e066@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=1707892581; l=868; i=cj.winklhofer@gmail.com; s=20240104; h=from:subject:message-id; bh=f5JrNqSq+DhQN/cCXZvlLdSNxNweO7or4GNetVHb2s4=; b=MjZYFlxIpcjH+7xYKTHb6sA+5nJV83dewBpgdSNFdhsZJCr1cZrxfi4bKq1nCPPY0k+dr9N++ PdwW0PHK+iGCN5BGG3Df0NszztBB1Gw+zlGlzt4Jda+k2xGlbM5XtSs 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: X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1790855232595499768 X-GMAIL-MSGID: 1790855232595499768 From: Christoph Winklhofer The UART 1-Wire bus utilizes the Serial Device Bus to create the 1-wire timing patterns. Acked-by: Rob Herring 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 Wed Feb 14 06:36:14 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: 200825 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:7300:bc8a:b0:106:860b:bbdd with SMTP id dn10csp1024769dyb; Tue, 13 Feb 2024 22:37:20 -0800 (PST) X-Forwarded-Encrypted: i=3; AJvYcCXxfgitYcoMqwXhxRwnHwIoFYsQX+73JFFXwPKcysuwDMMZa6KjjST9qvTyNc9o61M5xR1LpbOqxvsGf1iTOTPXrajwYA== X-Google-Smtp-Source: AGHT+IHA424ii7GL5wehw0UXTY9muO3u7J5K350rcrOmYpAlRwJJiu08+HrBQJyz7IWosCNs/5gI X-Received: by 2002:a05:6402:528c:b0:55f:d6b9:245f with SMTP id en12-20020a056402528c00b0055fd6b9245fmr941594edb.6.1707892640583; Tue, 13 Feb 2024 22:37:20 -0800 (PST) ARC-Seal: i=2; a=rsa-sha256; t=1707892640; cv=pass; d=google.com; s=arc-20160816; b=Xhu0ytJGUviaMrbi2hp10fTTc1NUvyag0lWfLu7mYN+dl+BNFKjB+oRMG/AAASw6MM LIKSEMWcL/6gaOxq7ef6Whp8rd0Gep7YfrHuRfiTHh0/yjROCGdQbbaNsa9iYhnpL71j eIygcQNqM9pXIKsItMICLGWsCtkaSU2uQCFFHUbRjDNx3ikbePykeJlxoinRMgCRBIiD aegdCpqZ8KI5IMtGkJ1TpeGnu0JZmffahP5qhfALCOqWjF/QgQMskqw3VzWXjmGEPSwZ YunlMrSIs2kgqNp9JLB3EUVnzIUnyp0rrCz69nh1bSRmwJByllIW0uv1ET1mXyx9eOMQ Xx3w== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=reply-to:cc:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:list-unsubscribe :list-subscribe:list-id:precedence:subject:date:from:dkim-signature; bh=P7Rn/hlGc9wu3rZPc4JxKCNa0wjj1l/5y4j9ZOLsbT4=; fh=kuNF4b8QkJm75jLViRiQe1zE1p4+4ZLo8R4PBoNcu1k=; b=XFdV+dHhPc0PovkkgVr+hu5Vb9YuHVQAXbT9QQVVnzfYUSscCKhwTTQhPr/tOD/1nT 6N3njfsb2gBO2kdCLDOXyny63O9ueqLFSOXMZvcomIWMW5mA+q2ORM0n+qqBCg+1ttJM RmedkYJklPl7lo8wquL3LlfIBwe9V89nHRVZOfs878YABKI4gSoxxQQ0i+cyfSPxD7Ai MrMPKl0B1/ESO7ertyivnd14ByDmaBlER0C6UEYbfAg6k1O5xJmGfal6pyIjeh4ess0a tVAXYBNQ17S3wIL2HNDcym8jwlsQ5EAxApEjE0z/CneQzRV0uYV7erBD6Whzyd2kwObG LvrQ==; dara=google.com ARC-Authentication-Results: i=2; mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=nkD7FZ9G; arc=pass (i=1 dkim=pass dkdomain=kernel.org); spf=pass (google.com: domain of linux-kernel+bounces-64793-ouuuleilei=gmail.com@vger.kernel.org designates 2604:1380:4601:e00::3 as permitted sender) smtp.mailfrom="linux-kernel+bounces-64793-ouuuleilei=gmail.com@vger.kernel.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org X-Forwarded-Encrypted: i=2; AJvYcCXfsCo1ny/t4XIgcjSAHI197NigyvnhWXMESM9DrQ0Aqp58Po6e4vOI6IcHEloFp8PUfZmQoq3FsJEmg4hlF0d/EjMezA== Received: from am.mirrors.kernel.org (am.mirrors.kernel.org. [2604:1380:4601:e00::3]) by mx.google.com with ESMTPS id j18-20020a05640211d200b005621f2ad0c3si570133edw.207.2024.02.13.22.37.20 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 13 Feb 2024 22:37:20 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel+bounces-64793-ouuuleilei=gmail.com@vger.kernel.org designates 2604:1380:4601:e00::3 as permitted sender) client-ip=2604:1380:4601:e00::3; Authentication-Results: mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=nkD7FZ9G; arc=pass (i=1 dkim=pass dkdomain=kernel.org); spf=pass (google.com: domain of linux-kernel+bounces-64793-ouuuleilei=gmail.com@vger.kernel.org designates 2604:1380:4601:e00::3 as permitted sender) smtp.mailfrom="linux-kernel+bounces-64793-ouuuleilei=gmail.com@vger.kernel.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org Received: from smtp.subspace.kernel.org (wormhole.subspace.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by am.mirrors.kernel.org (Postfix) with ESMTPS id 0B4291F23A46 for ; Wed, 14 Feb 2024 06:37:20 +0000 (UTC) Received: from localhost.localdomain (localhost.localdomain [127.0.0.1]) by smtp.subspace.kernel.org (Postfix) with ESMTP id 02B6712E41; Wed, 14 Feb 2024 06:36:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="nkD7FZ9G" 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 37D9311193; Wed, 14 Feb 2024 06:36:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1707892584; cv=none; b=OFmY/CXufpSBlRsBvJg8aeP/U7auRMtbWu63J2Ft0ArZtIFp7d0wnMlNuIR4TahuAeum/53kYr8pqyfX54zQJu76oXaRIIB0npTrjQPGlkZdDCbX0na5KxekiflyLTlWD1jGKYDK9NUEGl3t84oGBgGFVtsrrd+fciaq5iS5HYI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1707892584; c=relaxed/simple; bh=eMfD7O3mKBgytq6cqeXHFyoxCZgEikAzzCVwKh35KmQ=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=luLtjAPRmyheptS39xCkefnWHiKBvsPRetgLWqfsp/EqXjXHsOhkIOv1Vz7xLc6TSQZHLOXOQlFROUS+IktYAmK+JP6wXNUiUvbeRtYqdN+yPoYC8L8/hR9m79EFTLWAnLE8VxenqB5iVqcyPA2Anp8YbQFhpdpu2w9IAn2sOVA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=nkD7FZ9G; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPS id CEC07C43390; Wed, 14 Feb 2024 06:36:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1707892583; bh=eMfD7O3mKBgytq6cqeXHFyoxCZgEikAzzCVwKh35KmQ=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=nkD7FZ9GsL5MU5+3M1s2IwTCiv4bAdPmDDV6PpAAjtUydJ6wZhho1+vkQyVbe8IVz CYlgHW6NVlzCnP0LDTCCiZ9nf+dZTpxgAdtmpHfBmcsjcy9JgmBapGJj4AC0gTc5kq uw7jvJzDY1YRJr22WmdmmOfom5Y9w+cD2i1OQqqsWU3c57G9TwIObCPKu/ou/aIGnF gpSIwwoHuQDr5Q/qMfgU1R+WfOghHKKhN76Pq1RGcR4gMwY2qmUtLtf7GvQnjYye35 XM7/p8+oq+Eb0KP/TvXzNSOP6YeAltNwkkolfX9VLHqmDbNVUw/+By1zYnmL3FPt8y 7XoITRFFWI4cQ== 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 B2370C48BEB; Wed, 14 Feb 2024 06:36:23 +0000 (UTC) From: Christoph Winklhofer via B4 Relay Date: Wed, 14 Feb 2024 07:36:14 +0100 Subject: [PATCH v7 2/3] dt-bindings: w1: UART 1-Wire bus Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20240214-w1-uart-v7-2-6e21fa24e066@gmail.com> References: <20240214-w1-uart-v7-0-6e21fa24e066@gmail.com> In-Reply-To: <20240214-w1-uart-v7-0-6e21fa24e066@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=1707892581; l=2213; i=cj.winklhofer@gmail.com; s=20240104; h=from:subject:message-id; bh=yLV7IXmfdL8oY7fuePFUPpVLjP+tA63tYbAEut11d5g=; b=92emIKE9Ak5J2oB0JGnAAtKQWiPr0DGMmL4XQKKeyWWY2JOcZvn2YQJiHdw50/TNkXo5HMTQ8 g0MsLndArVLDR3etY1s2hi3m7fzx/hOe9lC//yYky3eadru94LnkRzY 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: X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1790855233268098459 X-GMAIL-MSGID: 1790855233268098459 From: Christoph Winklhofer Add device tree binding for UART 1-Wire bus. Reviewed-by: Rob Herring Signed-off-by: Christoph Winklhofer --- Documentation/devicetree/bindings/w1/w1-uart.yaml | 60 +++++++++++++++++++++++ 1 file changed, 60 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..7173820c78f9 --- /dev/null +++ b/Documentation/devicetree/bindings/w1/w1-uart.yaml @@ -0,0 +1,60 @@ +# 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 + + reset-bps: + default: 9600 + description: + The baud rate for the 1-Wire reset and presence detect. + + write-0-bps: + default: 115200 + description: + The baud rate for the 1-Wire write-0 cycle. + + write-1-bps: + default: 115200 + description: + The baud rate for the 1-Wire write-1 and read cycle. + +required: + - compatible + +additionalProperties: + type: object + +examples: + - | + serial { + onewire { + compatible = "w1-uart"; + }; + }; From patchwork Wed Feb 14 06:36:15 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: 200832 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:7300:bc8a:b0:106:860b:bbdd with SMTP id dn10csp1025931dyb; Tue, 13 Feb 2024 22:41:02 -0800 (PST) X-Forwarded-Encrypted: i=3; AJvYcCXbuhfDum80iqMGdN6hJ/T/coqjsnr5+8PwroBi6V1ODQ6Owmd+ub81nFzcnt3Ina48Q4KVjf9sWvQemJQ64D9WTrVUQg== X-Google-Smtp-Source: AGHT+IGxZgPiba3i6R8Me6lsDxSCzB0XFQzfKF1tZxOvXIXkAywjLti6TM7pOYBEvUQVT0VzG+SO X-Received: by 2002:a05:6a21:87a9:b0:1a0:5a4c:c6b9 with SMTP id ph41-20020a056a2187a900b001a05a4cc6b9mr1408612pzb.18.1707892862217; Tue, 13 Feb 2024 22:41:02 -0800 (PST) ARC-Seal: i=2; a=rsa-sha256; t=1707892862; cv=pass; d=google.com; s=arc-20160816; b=rMwG2h6FWCmEkibrfMpjw6Od3JqMroY0lgLCj5qC/cH907yWsq2X0VxZGlq4Y18zCp NpC29lELYiLExsPQz1dOgXdnoDlQ2drjvHSdQDWnQxgWbN16CdyEUD4AVY8i2sK81T73 15bsoI0DbkyKKPFy6HuBNGlpRtuv3Zd2cHk+aBzileBxogO1hqmmU02HewlJM15M2OPg vBhDwfghmjnTfiGqfv1ZhdsimFaICT8EH62gn9+AToyd/qmGAggHNc7JlPjkRBiHTTJO PIDHeauJFTa2x3fV1bcnleI1lT1rc2bUAac+Nv71Is+3ndeOwERw6E4Ob84KOOFF1KrG MyPw== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=reply-to:cc:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:list-unsubscribe :list-subscribe:list-id:precedence:subject:date:from:dkim-signature; bh=KYFVaso706UKfT4horwOrYNxFlWhTe4bUsOM2M9h51E=; fh=0330Z+yITkbXN65HjXO9vzbv+JAdujQ34pCNet26nhA=; b=cv11S4pZu7W1g2jw29je22hBiczQgLw7aTBLjwD9nav2+eTMywQVrQgf3FNMvmMqQi k4wXLgmwMvI1kqWoUMmWXW3Q4zSJODWyaACQ0aTDX/k8y0S2auxXroNHoev6ZNXJUoXm yiaiFCEOJ34I3kgHjvYMgCqeFA29qfHQCYJMTid/5oM+CivPb4jSjRWb2s7NmSnxHhdi WOiM+xMJz3Tb4OaALS5sHNGRL4/3wU0havrK8o/Kjt+sn0m8JJ1LWwx55fAJuNfMyW3C I40ZjVQwdAWBQmfTRVcPBBJ+v2XhZT1cWd6h66GVXHSBGRlJaCv1tvro+RUFcZfRVUdo 4EgQ==; dara=google.com ARC-Authentication-Results: i=2; mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=R18eELVQ; arc=pass (i=1 dkim=pass dkdomain=kernel.org); spf=pass (google.com: domain of linux-kernel+bounces-64790-ouuuleilei=gmail.com@vger.kernel.org designates 147.75.48.161 as permitted sender) smtp.mailfrom="linux-kernel+bounces-64790-ouuuleilei=gmail.com@vger.kernel.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org X-Forwarded-Encrypted: i=2; AJvYcCVR5D8zvc4WqBpQ19lk+YT+QLY85cLEuKlyDZmYCw8oPAJB+OD6nI43uTUHMP/q0/IyQLBioH0ujIVuxXfqtGdhzdBXBw== Received: from sy.mirrors.kernel.org (sy.mirrors.kernel.org. [147.75.48.161]) by mx.google.com with ESMTPS id c4-20020a170902d48400b001db5379cbb9si1071917plg.334.2024.02.13.22.41.01 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 13 Feb 2024 22:41:02 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel+bounces-64790-ouuuleilei=gmail.com@vger.kernel.org designates 147.75.48.161 as permitted sender) client-ip=147.75.48.161; Authentication-Results: mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=R18eELVQ; arc=pass (i=1 dkim=pass dkdomain=kernel.org); spf=pass (google.com: domain of linux-kernel+bounces-64790-ouuuleilei=gmail.com@vger.kernel.org designates 147.75.48.161 as permitted sender) smtp.mailfrom="linux-kernel+bounces-64790-ouuuleilei=gmail.com@vger.kernel.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org Received: from smtp.subspace.kernel.org (wormhole.subspace.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by sy.mirrors.kernel.org (Postfix) with ESMTPS id CA62FB28B06 for ; Wed, 14 Feb 2024 06:37:38 +0000 (UTC) Received: from localhost.localdomain (localhost.localdomain [127.0.0.1]) by smtp.subspace.kernel.org (Postfix) with ESMTP id 59C9B13FED; Wed, 14 Feb 2024 06:36:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="R18eELVQ" 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 37D33BE4B; Wed, 14 Feb 2024 06:36:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1707892584; cv=none; b=gsnDpDMXuJDysV4ZT+JjxwTvkJRL++/S6qCykVZMUTaZpIyVZRt4vjlhm1XC7zkV3fWwEFDnDqs1q2bW5CM1BCsnTrU6cW64Pc9mOjrLB97GDCLkNMgph64nHsn2Q69xdlg3HgFuvyL4Pb4MmwA6BLSy+odyhwtjU38eNowPTZM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1707892584; c=relaxed/simple; bh=Xh/T+lHMQLdNGs8mKEVRYwAbFA+4KjcFZev93aLHyAo=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=jP4YqJMD+IDSrnfeVUjhe31DOThskWFhfJRGLkq3WnGf05XHZzLJnJEkx1WWrGWLCpgZIPzrP/haVJMRfOD5yVB0YwYHfdJkmLWrzGfL0zNwuI+JogtTGChrZtdBA3fEa3aks/dBru/wrsV+iXiI6LWQdtprEmL4S+wE2rxVTJs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=R18eELVQ; arc=none smtp.client-ip=10.30.226.201 Received: by smtp.kernel.org (Postfix) with ESMTPS id DA801C43394; Wed, 14 Feb 2024 06:36:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1707892583; bh=Xh/T+lHMQLdNGs8mKEVRYwAbFA+4KjcFZev93aLHyAo=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=R18eELVQL1mURA/rhG4Su4rMgIL64g3myTY5O2koerdqoYssB0OAx0OaAz4EUN4lB ebtC78F4i+20UlEnX9fGlOh1zoQk/0i1GHiHItvZQu49rqdH/BM2e0K7XdRMvtEy4f VGU8ZaZeG2IBRtdFCjSP6VyWKhRzGrvckembA+PkwNWN2wDEZQexilDXaRp1Cx0w1c t79dKlvxYuI7K7IKwMVxjkkhsq+4IEO5aWeaTnuxdn7CukhHLBMN4U1q3tYv2dXxhl tNbn6oYnLcZIVXTERG3NfkIGtIlK2UB9FUSsDf/NLBfz3MUl6wIRrXeX1VU6boVr3p X3014dCCIZIFg== 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 C1213C4829F; Wed, 14 Feb 2024 06:36:23 +0000 (UTC) From: Christoph Winklhofer via B4 Relay Date: Wed, 14 Feb 2024 07:36:15 +0100 Subject: [PATCH v7 3/3] w1: add UART w1 bus driver Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20240214-w1-uart-v7-3-6e21fa24e066@gmail.com> References: <20240214-w1-uart-v7-0-6e21fa24e066@gmail.com> In-Reply-To: <20240214-w1-uart-v7-0-6e21fa24e066@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=1707892581; l=16376; i=cj.winklhofer@gmail.com; s=20240104; h=from:subject:message-id; bh=hW42ii/T9gqSaww4aeiWP8FJuUUpVsz3GWRoHr3oT/k=; b=m2CV2tpTsK89ubOw5bCC5NGNeikgKwftrP71vrQcc1bSaTY+c7mA7+BTIi3Rc94xEr482KB6n DzHUniCRn9xC/b78xW3pFb9dMOGMFSHYDqBkyirQ8JqsLqnDXGEF0gN 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: X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1790855454202050081 X-GMAIL-MSGID: 1790855465966081729 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 | 415 +++++++++++++++++++++++++++++++++++ 5 files changed, 481 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..6950d29d7dac --- /dev/null +++ b/drivers/w1/masters/w1-uart.c @@ -0,0 +1,415 @@ +// 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 +#include + +/* UART packet contains start and stop bit */ +#define W1_UART_BITS_PER_PACKET (BITS_PER_BYTE + 2) + +/* Timeout to wait for completion of serdev-receive */ +#define W1_UART_TIMEOUT msecs_to_jiffies(500) + +/** + * struct w1_uart_config - configuration for 1-Wire operation + * @baudrate: baud-rate returned from serdev + * @delay_us: delay to complete a 1-Wire cycle (in us) + * @tx_byte: byte to generate 1-Wire timing pattern + */ +struct w1_uart_config { + unsigned int baudrate; + unsigned int delay_us; + u8 tx_byte; +}; + +/** + * struct w1_uart_device - 1-Wire UART device structure + * @serdev: serial device + * @bus: w1-bus master + * @cfg_reset: config for 1-Wire reset + * @cfg_touch_0: config for 1-Wire write-0 cycle + * @cfg_touch_1: config for 1-Wire write-1 and read cycle + * @rx_byte_received: completion for serdev receive + * @rx_mutex: mutex to protect rx_err and rx_byte + * @rx_err: indicates an error in serdev-receive + * @rx_byte: result byte from serdev-receive + */ +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; + /* + * protect rx_err and rx_byte from concurrent access in + * w1-callbacks and serdev-receive. + */ + struct mutex rx_mutex; + int rx_err; + u8 rx_byte; +}; + +/** + * struct w1_uart_limits - limits for 1-Wire operations + * @baudrate: Requested baud-rate to create 1-Wire timing pattern + * @bit_min_us: minimum time for a bit (in us) + * @bit_max_us: maximum time for a bit (in us) + * @sample_us: timespan to sample 1-Wire response + * @cycle_us: duration of the 1-Wire cycle + */ +struct w1_uart_limits { + unsigned int baudrate; + unsigned int bit_min_us; + unsigned int bit_max_us; + unsigned int sample_us; + unsigned int cycle_us; +}; + +static inline unsigned int baud_to_bit_ns(unsigned int baud) +{ + return NSEC_PER_SEC / baud; +} + +static inline unsigned int to_ns(unsigned int us) +{ + return us * NSEC_PER_USEC; +} + +/* + * Set baud-rate, delay and tx-byte to create a 1-Wire pulse and adapt + * the tx-byte according to the actual baud-rate. + * + * Reject when: + * - time for a bit outside min/max range + * - a 1-Wire response is not detectable for sent byte + */ +static int w1_uart_set_config(struct serdev_device *serdev, + const struct w1_uart_limits *limits, + struct w1_uart_config *w1cfg) +{ + unsigned int packet_ns; + unsigned int bits_low; + unsigned int bit_ns; + unsigned int low_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); + bits_low = to_ns(limits->bit_min_us) / bit_ns; + /* start bit is always low */ + low_ns = bit_ns * (bits_low + 1); + + if (low_ns < to_ns(limits->bit_min_us)) + return -EINVAL; + + if (low_ns > to_ns(limits->bit_max_us)) + return -EINVAL; + + /* 1-Wire response detectable for sent byte */ + if (limits->sample_us > 0 && + bit_ns * BITS_PER_BYTE < low_ns + to_ns(limits->sample_us)) + return -EINVAL; + + /* delay: 1-Wire cycle takes longer than the UART packet */ + packet_ns = bit_ns * W1_UART_BITS_PER_PACKET; + w1cfg->delay_us = 0; + if (to_ns(limits->cycle_us) > packet_ns) + w1cfg->delay_us = + (to_ns(limits->cycle_us) - packet_ns) / NSEC_PER_USEC; + + /* byte to create 1-Wire pulse */ + w1cfg->tx_byte = 0xff << bits_low; + + return 0; +} + +/* + * Configuration for reset and presence detect + * - bit_min_us is 480us, add margin and use 485us + * - limits for sample time 60us-75us, use 65us + */ +static int w1_uart_set_config_reset(struct w1_uart_device *w1dev) +{ + struct serdev_device *serdev = w1dev->serdev; + struct device_node *np = serdev->dev.of_node; + + struct w1_uart_limits limits = { .baudrate = 9600, + .bit_min_us = 485, + .bit_max_us = 640, + .sample_us = 65, + .cycle_us = 960 }; + + of_property_read_u32(np, "reset-bps", &limits.baudrate); + + return w1_uart_set_config(serdev, &limits, &w1dev->cfg_reset); +} + +/* + * Configuration for write-0 cycle (touch bit 0) + * - bit_min_us is 60us, add margin and use 65us + * - no sampling required, sample_us = 0 + */ +static int w1_uart_set_config_touch_0(struct w1_uart_device *w1dev) +{ + struct serdev_device *serdev = w1dev->serdev; + struct device_node *np = serdev->dev.of_node; + + struct w1_uart_limits limits = { .baudrate = 115200, + .bit_min_us = 65, + .bit_max_us = 120, + .sample_us = 0, + .cycle_us = 70 }; + + of_property_read_u32(np, "write-0-bps", &limits.baudrate); + + return w1_uart_set_config(serdev, &limits, &w1dev->cfg_touch_0); +} + +/* + * Configuration for write-1 and read cycle (touch bit 1) + * - bit_min_us is 5us, add margin and use 6us + * - limits for sample time 5us-15us, use 15us + */ +static int w1_uart_set_config_touch_1(struct w1_uart_device *w1dev) +{ + struct serdev_device *serdev = w1dev->serdev; + struct device_node *np = serdev->dev.of_node; + + struct w1_uart_limits limits = { .baudrate = 115200, + .bit_min_us = 6, + .bit_max_us = 15, + .sample_us = 15, + .cycle_us = 70 }; + + of_property_read_u32(np, "write-1-bps", &limits.baudrate); + + return w1_uart_set_config(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, u8 *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 when serdev is unexpectedly receiving. */ + if (!mutex_trylock(&w1dev->rx_mutex)) + return -EIO; + + ret = w1dev->rx_err; + if (ret == 0) + *rx_byte = w1dev->rx_byte; + + mutex_unlock(&w1dev->rx_mutex); + + if (w1cfg->delay_us > 0) + fsleep(w1cfg->delay_us); + + return ret; +} + +static ssize_t w1_uart_serdev_receive_buf(struct serdev_device *serdev, + const u8 *buf, size_t count) +{ + struct w1_uart_device *w1dev = serdev_device_get_drvdata(serdev); + + mutex_lock(&w1dev->rx_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->rx_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; + int ret; + u8 val; + + 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; + int ret; + u8 val; + + 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->rx_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); + + /* + * Waits until w1-uart callbacks are finished, serdev is closed + * and its device data released automatically by devres (waits + * until serdev-receive is finished). + */ + w1_remove_master_device(&w1dev->bus); +} + +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");