From patchwork Thu Dec 12 21:09:01 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Markuss Broks X-Patchwork-Id: 13906003 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id ADDE3E7717F for ; Thu, 12 Dec 2024 21:11:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Cc:To:In-Reply-To:References :Message-Id:Content-Transfer-Encoding:Content-Type:MIME-Version:Subject:Date: From:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=nN9qy6kzaYRcTvspSPXcPestPQ9vGh5brGqrf6epwWw=; b=WOjj9WtjvcDMUXF1iEz+Qqznw8 u7DzAsMKwIX5Ld3pe1IQPb8ieLdqfNcI2/msHVBW6LlmIFqvBPHmDgxEV9FxxhRtNkBWWikVVIbSY FId+hE6tp6YnMyjipVJsU246FXZ5dbfdCmGUy4E+c05R2Zz1P079xQeD94sObxepI08fIBtI/zkF7 lOMvUDUhjQ7Bt5IiLKxbfYMGHo9p5T9jw8GcjQUNcKRYO30rpMp6GHZRWDaBDAM5AjSW+jB+Cip/c /cqGMJDGM76BJczgtiXC/zodwX3DQyFGL6o1VEBX1OTsB9bm8TSmZdkJXM56rWs8eKXOJoDkzGviC 2W/4n8Kg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1tLqT4-00000001ust-0y6D; Thu, 12 Dec 2024 21:11:30 +0000 Received: from mail-ed1-x532.google.com ([2a00:1450:4864:20::532]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1tLqQx-00000001uNR-0gPd for linux-arm-kernel@lists.infradead.org; Thu, 12 Dec 2024 21:09:20 +0000 Received: by mail-ed1-x532.google.com with SMTP id 4fb4d7f45d1cf-5d34030ebb2so1855991a12.1 for ; Thu, 12 Dec 2024 13:09:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1734037757; x=1734642557; darn=lists.infradead.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=nN9qy6kzaYRcTvspSPXcPestPQ9vGh5brGqrf6epwWw=; b=lsxmfHIiZNXz4v12sBbH7MLASZVC0YZ6cmRFLhdeR7d1i85Utj/28r/Mc718yNIZRK NKpfSTI6gF1gDncuhvBMUCotkb1/Ob3Ty7kSY2ol0X7YRxbl+ZKTik9D3T/s3Un6Q2sT li9JRfdhcZmG68Wl5900fvMz82KkZ9Q5hMYGHHB0rJiUaVStPeweVu//DNzdBfR9VaLh 2mpdFPSO/QGrbKwJha8qAHMibgdRuL1rWXoqRdOQCOrDH2prMV87XJAJwgEF5RGrbSnz rlwkzA73KCaDXdTmP+X6WCN5EVEX7IRmIpjmaqgKppuiiGGQRbbdYU+EPUo5u+wSW/rY 4M1w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1734037757; x=1734642557; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=nN9qy6kzaYRcTvspSPXcPestPQ9vGh5brGqrf6epwWw=; b=NamJGnDyvNWNjka3hDgIbnhMCPTBabwQ9MAag+6h2h5I78s8VF1lZLK9mqQRKT9ZTe wFW2fPGY68HRuy+5IIsT4Cu7VVWiNTgvxHfU3sIBXfSBCmJ/OfuPkiCyjqC8J4Ndu8Nr 8P2TJZ3arqgGW7toT7/AO7jxiFd5rJObwphLfAbonJurcf2RNuZfLqXbsMstDAJAg23T 9TvP3DGhAUCCpASlFQ0UU+yEN60DeSUkqPOFGBEMzK5D9MSTmFZq9sElcHHd2qX9+oQ2 lbObaIsZpkdEHPXtU/sYn+SfJx0mNSAG2y09Uyanq3c6fLtjNzheCQq2BsGbFjAX0PTf wGSg== X-Forwarded-Encrypted: i=1; AJvYcCU/stNPJhXl4Xpch24nTK9HlKlVwp7HhUzKn1A4P7pEWB8q0wGZBraHovYLr3fbOONKe8rfMjsyyxQzigw++2Wf@lists.infradead.org X-Gm-Message-State: AOJu0YxH4fdmeRTAz1Vklc+MOZGge5LfIovQDFi1IHjPCm9uWxaI9fMm hjSbygaavc/9gql7H8HPky/4oCq6DWc3/tr42AKFx7edLmSovZLo X-Gm-Gg: ASbGnculKVsBT7gWV/T7flncweaSnAHDr0wQPWeFpRMYCew66ad73viAaarRI9ctA0E Ka9SxMxJmpGCnX4T0KiQDsozmlrJCizTzHS9e/XaoMTVIfm0ImBqhAqzl0oSxlrVBCXnK7yOGPQ Nv8QYTakdqzB07KjOTasJ92p8S68cg+XuyXQQQseDYkMSPJh3MA9Vovz6teDT0/3P7luh/gvOrR ze8rV9ygz8OECh3WzpKp741NWqz/fQ+N9q1kbTQWmBQarg/1JdB7JEcSGZFFOh2Ex9Y X-Google-Smtp-Source: AGHT+IERTCYWfJYYkVszTsbpSkVPOiDO17vUGSDsrzxOO1nszolFyLdHEMLSrp83Tj/zAKFwqxyp+A== X-Received: by 2002:a05:6402:35d2:b0:5d0:cfb9:4132 with SMTP id 4fb4d7f45d1cf-5d63239e3f0mr1935496a12.18.1734037757096; Thu, 12 Dec 2024 13:09:17 -0800 (PST) Received: from [192.168.31.111] ([194.39.226.133]) by smtp.gmail.com with ESMTPSA id 4fb4d7f45d1cf-5d3d0f93d54sm9232348a12.68.2024.12.12.13.09.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 12 Dec 2024 13:09:16 -0800 (PST) From: Markuss Broks Date: Thu, 12 Dec 2024 23:09:01 +0200 Subject: [PATCH 1/3] dt-bindings: soc: samsung: exynos-speedy: Document SPEEDY host controller bindings MIME-Version: 1.0 Message-Id: <20241212-speedy-v1-1-544ad7bcfb6a@gmail.com> References: <20241212-speedy-v1-0-544ad7bcfb6a@gmail.com> In-Reply-To: <20241212-speedy-v1-0-544ad7bcfb6a@gmail.com> To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Alim Akhtar , Krzysztof Kozlowski Cc: linux-samsung-soc@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Ivaylo Ivanov , Markuss Broks , Maksym Holovach X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1734037753; l=2792; i=markuss.broks@gmail.com; s=20241024; h=from:subject:message-id; bh=gUnnizAdulAwxg+3Tnxh6d0BvTK9I11iWmyGXZBMs44=; b=ndri8pJVWgLELporVKp1ht8IO8Ncb/897FweJq2tFszKSNCils5GX+Sa2P2ZAR7l8TNZWBDXC MdNOBLDJYT1Bjmd0ooTpO1UucpedTECQS4GsRAMFY4QCeCpmxY94DLm X-Developer-Key: i=markuss.broks@gmail.com; a=ed25519; pk=p3Bh4oPpeCrTpffJvGch5WsWNikteWHJ+4LBICPbZg0= X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20241212_130919_243077_691A3B2A X-CRM114-Status: GOOD ( 13.98 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Add the schema for the Samsung SPEEDY serial bus host controller. The bus has 4 bit wide addresses for addressing devices and 8 bit wide register addressing. Each register is also 8 bit long, so the address can be 0-f (hexadecimal), node name for child device follows the format: node_name@[0-f]. Co-developed-by: Maksym Holovach Signed-off-by: Maksym Holovach Signed-off-by: Markuss Broks --- .../bindings/soc/samsung/exynos-speedy.yaml | 78 ++++++++++++++++++++++ 1 file changed, 78 insertions(+) diff --git a/Documentation/devicetree/bindings/soc/samsung/exynos-speedy.yaml b/Documentation/devicetree/bindings/soc/samsung/exynos-speedy.yaml new file mode 100644 index 0000000000000000000000000000000000000000..304b322a74ea70f23d8c072b44b6ca86b7cc807f --- /dev/null +++ b/Documentation/devicetree/bindings/soc/samsung/exynos-speedy.yaml @@ -0,0 +1,78 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/soc/samsung/exynos-speedy.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Samsung Exynos SPEEDY serial bus host controller + +maintainers: + - Markuss Broks + +description: + Samsung SPEEDY is a proprietary Samsung serial 1-wire bus. + It is used on various Samsung Exynos chips. The bus can + address at most 4 bit (16) devices. The devices on the bus + have 8 bit long register line, and the registers are also + 8 bit long each. It is typically used for communicating with + Samsung PMICs (s2mps17, s2mps18, ...) and other Samsung chips, + such as RF parts. + +properties: + compatible: + - items: + - enum: + - samsung,exynos9810-speedy + - const: samsung,exynos-speedy + + reg: + maxItems: 1 + + clocks: + maxItems: 1 + + clock-names: + - const: pclk + + interrupts: + maxItems: 1 + +required: + - compatible + - reg + - "#address-cells" + - "#size-cells" + +patternProperties: + "^[a-z][a-z0-9]*@[0-9a-f]$": + type: object + additionalProperties: true + + properties: + reg: + maxItems: 1 + + required: + - reg + +additionalProperties: false + +examples: + - | + speedy0: speedy@141c0000 { + compatible = "samsung,exynos9810-speedy", + "samsung-exynos-speedy"; + reg = <0x141c0000 0x2000>; + #address-cells = <1>; + #size-cells = <0>; + + pmic@0 { + compatible = "samsung,s2mps18-pmic"; + reg = <0x0>; + }; + + regulator@1 { + compatible = "samsung,s2mps18-regulator"; + reg = <0x1>; + }; + }; From patchwork Thu Dec 12 21:09:02 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Markuss Broks X-Patchwork-Id: 13906004 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 4F31BE7717F for ; Thu, 12 Dec 2024 21:12:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Cc:To:In-Reply-To:References :Message-Id:Content-Transfer-Encoding:Content-Type:MIME-Version:Subject:Date: From:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=QgIxvdOsMnKX9k+scEpB6Bgeim7EgN0VncA3hBDvj2U=; b=wGScQb3ZGOzkaZfjjeSgK5Nm0r +qiq1H2NJXUqLV6iaOY1wy34MTHDHNIxjUG+aWNuvMZYkIF5kunUDQX51vRQO4Q+aoK/DtWNPVFPl PGbQFIz9BDVxvHbYU2LHaiQCdyrtayRE5sIgfkDPMqbzREG1AJxmM/h61u2xGLWOClYSqxb1tJ+8r 99cXLNWViu20L3Lq8iNIUHSmZ/Hg3LhUOITKxFkegfu8ftbIPOe1+b1kNOxGo/nU+BcsFewf741Im lDksd+IyG+lj93plx16TucWnt8JlAcMO062FMlrN20WJadZHm0jFl9nyd1WG4UVEWQy/+dIOOZx+I IYn+hgyQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1tLqU6-00000001v2w-3bD1; Thu, 12 Dec 2024 21:12:34 +0000 Received: from mail-ed1-x531.google.com ([2a00:1450:4864:20::531]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1tLqQz-00000001uOj-0SUa for linux-arm-kernel@lists.infradead.org; Thu, 12 Dec 2024 21:09:22 +0000 Received: by mail-ed1-x531.google.com with SMTP id 4fb4d7f45d1cf-5d3e8f64d5dso1907400a12.3 for ; Thu, 12 Dec 2024 13:09:20 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1734037759; x=1734642559; darn=lists.infradead.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=QgIxvdOsMnKX9k+scEpB6Bgeim7EgN0VncA3hBDvj2U=; b=WPJhCKPKNKppHATh27lZiDornVGB/MYXMh/d6MGIlrsRnfaPyqopf19sEranlifXYn 6iEiyIPRs+y1KHqbcj6iW5fGgpt868xQ0m1RqnOK7SYhNK1Mv0ChzQ9b+OqB01uVXUmz IKv6DrZa9Ni6parbrIt0jzfKppMm7CUiYj40t5YGAhFKnecA4pBYTXafkk2e9co6o3dx SFWJ8fmaNIQ43+lHZ7zfUehzU/i5Pzw+zKyvTE3VVEbFl+btIDR884FGB87edCzcuwZz YYtzdO5BxZ6Z2C0z7eQ4HAo+QKAmU+a+eQfSxSimySJim7b4nI4KvPHCHyx93TugwTOO NXgQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1734037759; x=1734642559; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=QgIxvdOsMnKX9k+scEpB6Bgeim7EgN0VncA3hBDvj2U=; b=MClrU6uU+SNZUx/88rzKDoHYBg/3PWqkGcZBOSTUFRLoasyc/4dM7EA7dgtOV+tAjY vDPHyBUhtq1n9xipuNaww150X8HLXM2j1Rm09x5V23V8JB9E3VJIARZkeRIztedGByoZ Jbk3aAJpm1OC4rV6X9jhjRHKie6l2BleCGcO3aVRNuXPYZtv53FU5BcfmNmaWXVBxxVI 77Yi0Ritknbm+7Q6SU2fWBQSGE3xbTMiniqgRwEI3Om40DcMPqFrQ8qp0DdGfC0lTOuv zUgDAdfiiSEIano0e9naohr4dAh3C7f7sbZv0l9dWAGw5vAGQzIhn4D5rHy7RbY+lAcB qaKQ== X-Forwarded-Encrypted: i=1; AJvYcCV1HNY8GJgfjO3I7mqs2+DwQ2uSnE2k7s7t2G8k3ThXyW0SjHG8NCuFfssX2jRw4+u3UT0r9qGxF+BnEAu6xl5q@lists.infradead.org X-Gm-Message-State: AOJu0YxidVZ4OGrIPghd4y0pbRsTFPZUlPP8nsD7f4NYyFgaceszipsg /UPv1dBpbBcS1LUeTe2YRvFw8hzsXBueZyQ14XAhu74RE/3mL/IK X-Gm-Gg: ASbGnct5Ihw9yhpenJLohFUIYz+3N9QZ34PJmfAzQXrCBjh/X1Z/xE+jl72Fh/dTCKC y23qmwIQpLM0QVSslD2nSL8cj2yiEPFSrNFiSilW+dCk9csqDk/oWLnRcYZkPrnFx/rQDifgz3p lx0yjG0ypCaCgraRVRM6wxfw1wGkmanWWDJJPdX3VGbmSxPRI8+idHq4UPvcZlk528vbSWSVh6S XH2FTHTl38gf2M3/x3IcXY3JrzhHvtCMSSN+Ipc5KYxoe+pAtzSJ0ROD7cmOmsnF5jo X-Google-Smtp-Source: AGHT+IE12N0Ng+HjgXtLiF39tC//8gVPB0GifXeSoFX7MgfHyn0ze9DeSIt1tWfnGtytJGJyx7V1Iw== X-Received: by 2002:a05:6402:2389:b0:5d6:37ec:60cf with SMTP id 4fb4d7f45d1cf-5d637ec6204mr970555a12.27.1734037758779; Thu, 12 Dec 2024 13:09:18 -0800 (PST) Received: from [192.168.31.111] ([194.39.226.133]) by smtp.gmail.com with ESMTPSA id 4fb4d7f45d1cf-5d3d0f93d54sm9232348a12.68.2024.12.12.13.09.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 12 Dec 2024 13:09:18 -0800 (PST) From: Markuss Broks Date: Thu, 12 Dec 2024 23:09:02 +0200 Subject: [PATCH 2/3] soc: samsung: Add a driver for Samsung SPEEDY host controller MIME-Version: 1.0 Message-Id: <20241212-speedy-v1-2-544ad7bcfb6a@gmail.com> References: <20241212-speedy-v1-0-544ad7bcfb6a@gmail.com> In-Reply-To: <20241212-speedy-v1-0-544ad7bcfb6a@gmail.com> To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Alim Akhtar , Krzysztof Kozlowski Cc: linux-samsung-soc@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Ivaylo Ivanov , Markuss Broks , Maksym Holovach X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1734037753; l=17342; i=markuss.broks@gmail.com; s=20241024; h=from:subject:message-id; bh=QfyrnTKILMbUFdNwbJQymTtew7cB9NvJzYHeI/IYL2Q=; b=Pz56xXjCyDZ82J93Hde4L+wHHkW7ddYg0eJyTEwYrxXPWrSITFe7thviNVzureL2vWI0Jj9E5 c73ZP82jUOfCiB2OeyhQipCt6hr0a7hbBFtRpkzO2Vry2CZhVPsIWEv X-Developer-Key: i=markuss.broks@gmail.com; a=ed25519; pk=p3Bh4oPpeCrTpffJvGch5WsWNikteWHJ+4LBICPbZg0= X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20241212_130921_160687_46EAAAC9 X-CRM114-Status: GOOD ( 20.79 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Add a driver for Samsung SPEEDY serial bus host controller. SPEEDY is a proprietary 1 wire serial bus used by Samsung in various devices (usually mobile), like Samsung Galaxy phones. It is usually used for connecting PMIC or various other peripherals, like audio codecs or RF components. This bus can address at most 1MiB (4 bit device address, 8 bit registers per device, 8 bit wide registers: 256*256*16 = 1MiB of address space. Co-developed-by: Maksym Holovach Signed-off-by: Maksym Holovach Signed-off-by: Markuss Broks --- drivers/soc/samsung/Kconfig | 13 + drivers/soc/samsung/Makefile | 2 + drivers/soc/samsung/exynos-speedy.c | 457 ++++++++++++++++++++++++++++++ include/linux/soc/samsung/exynos-speedy.h | 56 ++++ 4 files changed, 528 insertions(+) diff --git a/drivers/soc/samsung/Kconfig b/drivers/soc/samsung/Kconfig index 1a5dfdc978dc4069eb71c4e8eada7ff1913b86b3..a38150fc9999ded1e1e93e2a9ef43b88175d34bd 100644 --- a/drivers/soc/samsung/Kconfig +++ b/drivers/soc/samsung/Kconfig @@ -49,6 +49,19 @@ config EXYNOS_PMU_ARM_DRIVERS bool "Exynos PMU ARMv7-specific driver extensions" if COMPILE_TEST depends on EXYNOS_PMU +config EXYNOS_SPEEDY + tristate "Exynos SPEEDY host controller driver" + depends on ARCH_EXYNOS || COMPILE_TEST + depends on OF + depends on REGMAP_MMIO + help + Enable support for Exynos SPEEDY host controller block. + SPEEDY is a 1 wire proprietary Samsung serial bus, found in + modern Samsung Exynos SoCs, like Exynos8895 and newer. + + Select this if you have a Samsung Exynos device which uses + SPEEDY bus. + config SAMSUNG_PM_CHECK bool "S3C2410 PM Suspend Memory CRC" depends on PM && (ARCH_S3C64XX || ARCH_S5PV210) diff --git a/drivers/soc/samsung/Makefile b/drivers/soc/samsung/Makefile index 248a33d7754af1a1e5fbbbb79413eb300bbbc8e5..9fe824075be77dbcd22c5f1477c4b34029016ed2 100644 --- a/drivers/soc/samsung/Makefile +++ b/drivers/soc/samsung/Makefile @@ -12,4 +12,6 @@ obj-$(CONFIG_EXYNOS_PMU_ARM_DRIVERS) += exynos3250-pmu.o exynos4-pmu.o \ exynos5250-pmu.o exynos5420-pmu.o obj-$(CONFIG_EXYNOS_REGULATOR_COUPLER) += exynos-regulator-coupler.o +obj-$(CONFIG_EXYNOS_SPEEDY) += exynos-speedy.o + obj-$(CONFIG_SAMSUNG_PM_CHECK) += s3c-pm-check.o diff --git a/drivers/soc/samsung/exynos-speedy.c b/drivers/soc/samsung/exynos-speedy.c new file mode 100644 index 0000000000000000000000000000000000000000..e897b67c80edacee485169ea6dc1ffe0cefdd21f --- /dev/null +++ b/drivers/soc/samsung/exynos-speedy.c @@ -0,0 +1,457 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * exynos-speedy.c - Samsung Exynos SPEEDY Host Controller Driver + * + * Copyright 2024, Markuss Broks + * Copyright 2024, Maksym Holovach + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +/* Speedy MMIO register map */ +#define SPEEDY_CTRL 0x000 +#define SPEEDY_FIFO_CTRL 0x004 +#define SPEEDY_CMD 0x008 +#define SPEEDY_INT_ENABLE 0x00C +#define SPEEDY_INT_STATUS 0x010 +#define SPEEDY_FIFO_STATUS 0x030 +#define SPEEDY_TX_DATA 0x034 +#define SPEEDY_RX_DATA 0x038 +#define SPEEDY_PACKET_GAP_TIME 0x044 +#define SPEEDY_TIMEOUT_COUNT 0x048 +#define SPEEDY_FIFO_DEBUG 0x100 +#define SPEEDY_CTRL_STATUS 0x104 + +/* SPEEDY_CTRL register bits */ +#define SPEEDY_ENABLE (1 << 0) +#define SPEEDY_TIMEOUT_CMD_DISABLE (1 << 1) +#define SPEEDY_TIMEOUT_STANDBY_DISABLE (1 << 2) +#define SPEEDY_TIMEOUT_DATA_DISABLE (1 << 3) +#define SPEEDY_ALWAYS_PULLUP_EN (1 << 7) +#define SPEEDY_DATA_WIDTH_8BIT (0 << 8) +#define SPEEDY_REMOTE_RESET_REQ (1 << 30) +#define SPEEDY_SW_RST (1 << 31) + +/* SPEEDY_FIFO_CTRL register bits */ +#define SPEEDY_RX_TRIGGER_LEVEL(x) ((x) << 0) +#define SPEEDY_TX_TRIGGER_LEVEL(x) ((x) << 8) +#define SPEEDY_FIFO_RESET (1 << 31) + +/* SPEEDY_CMD register bits */ +#define SPEEDY_BURST_LENGTH(x) ((x) << 0) +#define SPEEDY_BURST_FIXED (0 << 5) +#define SPEEDY_BURST_INCR (1 << 5) +#define SPEEDY_BURST_EXTENSION (2 << 5) +#define SPEEDY_ACCESS_BURST (0 << 19) +#define SPEEDY_ACCESS_RANDOM (1 << 19) +#define SPEEDY_DIRECTION_READ (0 << 20) +#define SPEEDY_DIRECTION_WRITE (1 << 20) + +/* SPEEDY_INT_ENABLE register bits */ +#define SPEEDY_TRANSFER_DONE_EN (1 << 0) +#define SPEEDY_TIMEOUT_CMD_EN (1 << 1) +#define SPEEDY_TIMEOUT_STANDBY_EN (1 << 2) +#define SPEEDY_TIMEOUT_DATA_EN (1 << 3) +#define SPEEDY_FIFO_TX_ALMOST_EMPTY_EN (1 << 4) +#define SPEEDY_FIFO_RX_ALMOST_FULL_EN (1 << 8) +#define SPEEDY_RX_FIFO_INT_TRAILER_EN (1 << 9) +#define SPEEDY_RX_MODEBIT_ERR_EN (1 << 16) +#define SPEEDY_RX_GLITCH_ERR_EN (1 << 17) +#define SPEEDY_RX_ENDBIT_ERR_EN (1 << 18) +#define SPEEDY_TX_LINE_BUSY_ERR_EN (1 << 20) +#define SPEEDY_TX_STOPBIT_ERR_EN (1 << 21) +#define SPEEDY_REMOTE_RESET_REQ_EN (1 << 31) + +/* SPEEDY_INT_STATUS register bits */ +#define SPEEDY_TRANSFER_DONE (1 << 0) +#define SPEEDY_TIMEOUT_CMD (1 << 1) +#define SPEEDY_TIMEOUT_STANDBY (1 << 2) +#define SPEEDY_TIMEOUT_DATA (1 << 3) +#define SPEEDY_FIFO_TX_ALMOST_EMPTY (1 << 4) +#define SPEEDY_FIFO_RX_ALMOST_FULL (1 << 8) +#define SPEEDY_RX_FIFO_INT_TRAILER (1 << 9) +#define SPEEDY_RX_MODEBIT_ERR (1 << 16) +#define SPEEDY_RX_GLITCH_ERR (1 << 17) +#define SPEEDY_RX_ENDBIT_ERR (1 << 18) +#define SPEEDY_TX_LINE_BUSY_ERR (1 << 20) +#define SPEEDY_TX_STOPBIT_ERR (1 << 21) +#define SPEEDY_REMOTE_RESET_REQ_STAT (1 << 31) + +/* SPEEDY_FIFO_STATUS register bits */ +#define SPEEDY_VALID_DATA_CNT (0 << 0) +#define SPEEDY_FIFO_FULL (1 << 5) +#define SPEEDY_FIFO_EMPTY (1 << 6) + +/* SPEEDY_PACKET_GAP_TIME register bits */ +#define SPEEDY_FIFO_TX_ALMOST_EMPTY (1 << 4) +#define SPEEDY_FIFO_RX_ALMOST_FULL (1 << 8) +#define SPEEDY_FSM_INIT (1 << 1) +#define SPEEDY_FSM_TX_CMD (1 << 2) +#define SPEEDY_FSM_STANDBY (1 << 3) +#define SPEEDY_FSM_DATA (1 << 4) +#define SPEEDY_FSM_TIMEOUT (1 << 5) +#define SPEEDY_FSM_TRANS_DONE (1 << 6) +#define SPEEDY_FSM_IO_RX_STAT_MASK (3 << 7) +#define SPEEDY_FSM_IO_TX_IDLE (1 << 9) +#define SPEEDY_FSM_IO_TX_GET_PACKET (1 << 10) +#define SPEEDY_FSM_IO_TX_PACKET (1 << 11) +#define SPEEDY_FSM_IO_TX_DONE (1 << 12) + +#define SPEEDY_RX_LENGTH(n) ((n) << 0) +#define SPEEDY_TX_LENGTH(n) ((n) << 8) + +#define SPEEDY_DEVICE(x) ((x & 0xf) << 15) +#define SPEEDY_ADDRESS(x) ((x & 0xff) << 7) + +static const struct of_device_id speedy_match[] = { + { .compatible = "samsung,exynos9810-speedy" }, + { /* Sentinel */ } +}; +MODULE_DEVICE_TABLE(of, speedy_match); + +static const struct regmap_config speedy_map_cfg = { + .reg_bits = 32, + .val_bits = 32, +}; + +/** + * speedy_int_clear() - clear interrupt status + * @speedy: pointer to speedy controller struct + * + * Return: 0 on success, -errno otherwise + */ +static int speedy_int_clear(struct speedy_controller *speedy) +{ + int ret; + + ret = regmap_set_bits(speedy->map, SPEEDY_INT_STATUS, 0xffffffff); + if (ret) + return ret; + + udelay(10); + + return 0; +} + +/** + * speedy_fifo_reset() - reset FIFO of the controller + * @speedy: pointer to speedy controller struct + * + * Return: 0 on success, -errno otherwise + */ +static int speedy_fifo_reset(struct speedy_controller *speedy) +{ + int ret; + + ret = regmap_set_bits(speedy->map, SPEEDY_FIFO_CTRL, SPEEDY_FIFO_RESET); + if (ret) + return ret; + + udelay(10); + + return 0; +} + +/** + * _speedy_read() - internal speedy read operation + * @speedy: pointer to speedy controller struct + * @reg: address of device on the bus + * @addr: address to read + * @val: pointer to store result + * + * Return: 0 on success, -errno otherwise + */ +static int _speedy_read(struct speedy_controller *speedy, u32 reg, u32 addr, u32 *val) +{ + int ret; + u32 cmd, int_ctl, int_status; + + mutex_lock(&speedy->io_lock); + + ret = speedy_fifo_reset(speedy); + if (ret) + return ret; + + ret = regmap_set_bits(speedy->map, SPEEDY_FIFO_CTRL, + SPEEDY_RX_LENGTH(1) | SPEEDY_TX_LENGTH(1)); + if (ret) + return ret; + + cmd = SPEEDY_ACCESS_RANDOM | SPEEDY_DIRECTION_READ | + SPEEDY_DEVICE(reg) | SPEEDY_ADDRESS(addr); + + int_ctl = SPEEDY_TRANSFER_DONE_EN | SPEEDY_FIFO_RX_ALMOST_FULL_EN | + SPEEDY_RX_FIFO_INT_TRAILER_EN | SPEEDY_RX_MODEBIT_ERR_EN | + SPEEDY_RX_GLITCH_ERR_EN | SPEEDY_RX_ENDBIT_ERR_EN | + SPEEDY_REMOTE_RESET_REQ_EN; + + ret = speedy_int_clear(speedy); + if (ret) + return ret; + + ret = regmap_write(speedy->map, SPEEDY_INT_ENABLE, int_ctl); + if (ret) + return ret; + + ret = regmap_write(speedy->map, SPEEDY_CMD, cmd); + if (ret) + return ret; + + /* Wait for xfer done */ + ret = regmap_read_poll_timeout(speedy->map, SPEEDY_INT_STATUS, int_status, + int_status & SPEEDY_TRANSFER_DONE, 5000, 50000); + if (ret) + return ret; + + ret = regmap_read(speedy->map, SPEEDY_RX_DATA, val); + if (ret) + return ret; + + ret = speedy_int_clear(speedy); + + mutex_unlock(&speedy->io_lock); + + return ret; +} + +int exynos_speedy_read(const struct speedy_device *device, u32 addr, u32 *val) +{ + return _speedy_read(device->speedy, device->reg, addr, val); +} +EXPORT_SYMBOL_GPL(exynos_speedy_read); + +/** + * _speedy_write() - internal speedy write operation + * @speedy: pointer to speedy controller struct + * @reg: address of device on the bus + * @addr: address to write + * @val: value to write + * + * Return: 0 on success, -errno otherwise + */ +static int _speedy_write(struct speedy_controller *speedy, u32 reg, u32 addr, u32 val) +{ + int ret; + u32 cmd, int_ctl, int_status; + + mutex_lock(&speedy->io_lock); + + ret = speedy_fifo_reset(speedy); + if (ret) + return ret; + + ret = regmap_set_bits(speedy->map, SPEEDY_FIFO_CTRL, + SPEEDY_RX_LENGTH(1) | SPEEDY_TX_LENGTH(1)); + if (ret) + return ret; + + cmd = SPEEDY_ACCESS_RANDOM | SPEEDY_DIRECTION_WRITE | + SPEEDY_DEVICE(reg) | SPEEDY_ADDRESS(addr); + + int_ctl = (SPEEDY_TRANSFER_DONE_EN | + SPEEDY_FIFO_TX_ALMOST_EMPTY_EN | + SPEEDY_TX_LINE_BUSY_ERR_EN | + SPEEDY_TX_STOPBIT_ERR_EN | + SPEEDY_REMOTE_RESET_REQ_EN); + + ret = speedy_int_clear(speedy); + if (ret) + return ret; + + ret = regmap_write(speedy->map, SPEEDY_INT_ENABLE, int_ctl); + if (ret) + return ret; + + ret = regmap_write(speedy->map, SPEEDY_CMD, cmd); + if (ret) + return ret; + + ret = regmap_write(speedy->map, SPEEDY_TX_DATA, val); + if (ret) + return ret; + + /* Wait for xfer done */ + ret = regmap_read_poll_timeout(speedy->map, SPEEDY_INT_STATUS, int_status, + int_status & SPEEDY_TRANSFER_DONE, 5000, 50000); + if (ret) + return ret; + + speedy_int_clear(speedy); + + mutex_unlock(&speedy->io_lock); + + return 0; +} + +int exynos_speedy_write(const struct speedy_device *device, u32 addr, u32 val) +{ + return _speedy_write(device->speedy, device->reg, addr, val); +} +EXPORT_SYMBOL_GPL(exynos_speedy_write); + +static void devm_speedy_release(struct device *dev, void *res) +{ + const struct speedy_device **ptr = res; + const struct speedy_device *handle = *ptr; + + kfree(handle); +} + +/** + * speedy_get_by_phandle() - internal get speedy device handle + * @np: pointer to OF device node of device + * + * Return: 0 on success, -errno otherwise + */ +static const struct speedy_device *speedy_get_device(struct device_node *np) +{ + const struct of_device_id *speedy_id; + struct device_node *speedy_np; + struct platform_device *speedy_pdev; + struct speedy_controller *speedy = NULL; + struct speedy_device *handle; + int ret; + + if (!np) { + pr_err("I need a device pointer\n"); + return ERR_PTR(-EINVAL); + } + + speedy_np = of_get_parent(np); + if (!speedy_np) + return ERR_PTR(-ENODEV); + + /* Verify if parent node is a speedy controller */ + speedy_id = of_match_node(speedy_match, speedy_np); + if (!speedy_id) { + handle = ERR_PTR(-EINVAL); + goto out; + } + + /* Get platform device of the speedy controller */ + speedy_pdev = of_find_device_by_node(speedy_np); + if (!speedy_pdev) { + handle = ERR_PTR(-EPROBE_DEFER); + goto out; + } + + /* Get drvdata of speedy controller */ + speedy = platform_get_drvdata(speedy_pdev); + if (!speedy) { + handle = ERR_PTR(-EINVAL); + goto out; + } + + handle = kzalloc(sizeof(struct speedy_device), GFP_KERNEL); + if (!handle) { + handle = ERR_PTR(-ENOMEM); + goto out; + } + handle->speedy = speedy; + ret = of_property_read_u32(np, "reg", &handle->reg); + if (ret) { + kfree(handle); + handle = ERR_PTR(-EINVAL); + goto out; + } + +out: + of_node_put(speedy_np); + return handle; +} + +const struct speedy_device *devm_speedy_get_device(struct device *dev) +{ + const struct speedy_device *handle; + const struct speedy_device **ptr; + + ptr = devres_alloc(devm_speedy_release, sizeof(*ptr), GFP_KERNEL); + if (!ptr) + return ERR_PTR(-ENOMEM); + + handle = speedy_get_device(dev_of_node(dev)); + if (!IS_ERR(handle)) { + *ptr = handle; + devres_add(dev, ptr); + } else { + devres_free(ptr); + } + + return handle; +} +EXPORT_SYMBOL_GPL(devm_speedy_get_device); + +static int speedy_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct speedy_controller *speedy; + void __iomem *mem; + int ret; + + speedy = devm_kzalloc(dev, sizeof(struct speedy_controller), GFP_KERNEL); + if (!speedy) + return -ENOMEM; + + platform_set_drvdata(pdev, speedy); + speedy->pdev = pdev; + + mutex_init(&speedy->io_lock); + + mem = devm_platform_ioremap_resource(pdev, 0); + if (IS_ERR(mem)) + return dev_err_probe(dev, PTR_ERR(mem), "Failed to ioremap memory\n"); + + speedy->map = devm_regmap_init_mmio(dev, mem, &speedy_map_cfg); + if (IS_ERR(speedy->map)) + return dev_err_probe(dev, PTR_ERR(speedy->map), "Failed to init the regmap\n"); + + /* Clear any interrupt status remaining */ + ret = speedy_int_clear(speedy); + if (ret) + return ret; + + /* Reset the controller */ + ret = regmap_set_bits(speedy->map, SPEEDY_CTRL, SPEEDY_SW_RST); + if (ret) + return ret; + + msleep(20); + + /* Enable the hw */ + ret = regmap_set_bits(speedy->map, SPEEDY_CTRL, SPEEDY_ENABLE); + if (ret) + return ret; + + msleep(20); + + /* Probe child devices */ + ret = of_platform_populate(pdev->dev.of_node, NULL, NULL, dev); + if (ret) + dev_err(dev, "Failed to populate child devices: %d\n", ret); + + return ret; +} + +static struct platform_driver speedy_driver = { + .probe = speedy_probe, + .driver = { + .name = "exynos-speedy", + .of_match_table = speedy_match, + }, +}; + +module_platform_driver(speedy_driver); + +MODULE_DESCRIPTION("Samsung Exynos SPEEDY host controller driver"); +MODULE_AUTHOR("Markuss Broks "); +MODULE_LICENSE("GPL"); diff --git a/include/linux/soc/samsung/exynos-speedy.h b/include/linux/soc/samsung/exynos-speedy.h new file mode 100644 index 0000000000000000000000000000000000000000..b2857d65d3b50927373866dd8ae1c47e98af6d7b --- /dev/null +++ b/include/linux/soc/samsung/exynos-speedy.h @@ -0,0 +1,56 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright 2024, Markuss Broks + * Copyright 2024, Maksym Holovach + */ + +#ifndef __EXYNOS_SPEEDY_H +#define __EXYNOS_SPEEDY_H + +#include + +struct device; +struct mutex; +struct platform_device; +struct regmap; + +struct speedy_controller { + struct mutex io_lock; + struct platform_device *pdev; + struct regmap *map; +}; + +struct speedy_device { + u32 reg; + struct speedy_controller *speedy; +}; + +/** + * exynos_speedy_read() - exynos speedy read operation + * @device: pointer to speedy device struct + * @addr: address to read + * @val: pointer to store result + * + * Return: 0 on success, -errno otherwise + */ +int exynos_speedy_read(const struct speedy_device *device, u32 addr, u32 *val); + +/** + * exynos_speedy_write() - exynos speedy write operation + * @device: pointer to speedy device struct + * @addr: address to write + * @val: value to write + * + * Return: 0 on success, -errno otherwise + */ +int exynos_speedy_write(const struct speedy_device *device, u32 addr, u32 val); + +/** + * devm_speedy_get_device() - managed get speedy device. + * @dev: device pointer requesting speedy device handle. + * + * Return: pointer to handle on success, ERR_PTR(-errno) otherwise. + */ +const struct speedy_device *devm_speedy_get_device(struct device *dev); + +#endif /* __EXYNOS_SPEEDY_H */ From patchwork Thu Dec 12 21:09:03 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Markuss Broks X-Patchwork-Id: 13906005 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id A287EE7717F for ; Thu, 12 Dec 2024 21:13:52 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Cc:To:In-Reply-To:References :Message-Id:Content-Transfer-Encoding:Content-Type:MIME-Version:Subject:Date: From:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=4LcqT6RFZpU+AfgSkhVCNBVs2JrpNLGjbQouQLx+w/k=; b=3I0yxGGvbVgjsTMV8X4Y0YP078 q6X8q7MVbIe4rhT75sf0jg2lQvMlX0MRxZbfAPmGJe/JdV7gx8Fs61P5uQoMDvI2hu2vB4VyxAmNr t9BoxnjSeaB1E7w8zOIbh0IW25eSZ1kLgS/1YejmcphA+B5/ucw5pbanwBhuOZdTrDWSBTpA9FeWh IBUOKtOkIFVybgCxvAuvPRQGMPtwdZ03JG9LvbS+GN6XiC7t7cWDrby9OnyinGwsdueOpemMElYMA l/Thk1O7kAms0v4Y/eOGO6JO4gGtKNm75NAtQBSBj3GyFIM7CH9yQVRhUkOd1NMvi9rf8QKTPnSax +sZCUZ7w==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1tLqVA-00000001vC6-2Cfe; Thu, 12 Dec 2024 21:13:40 +0000 Received: from mail-ed1-x530.google.com ([2a00:1450:4864:20::530]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1tLqR1-00000001uPc-3Pn3 for linux-arm-kernel@lists.infradead.org; Thu, 12 Dec 2024 21:09:25 +0000 Received: by mail-ed1-x530.google.com with SMTP id 4fb4d7f45d1cf-5d3d14336f0so1861664a12.3 for ; Thu, 12 Dec 2024 13:09:23 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1734037762; x=1734642562; darn=lists.infradead.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=4LcqT6RFZpU+AfgSkhVCNBVs2JrpNLGjbQouQLx+w/k=; b=lpCrMohdfWrT6AEp9ZAbGo9qygpczrwLT9fqKjnnSEaGiHQVElC0Ie3So+xlXBTFec /LVM3NdECWK/A4I088XIsQa9N2FcvN42d8kq8U4ULDCQ13cIyKSLqdZTAVH9JFSf+h9+ XPDzIZwFetvLugiYITlr0ldUPgXLmZmhr0sCAlS4JnP11kSNmyVUEOHxFJWjOOVEPimK R6tx70B/GZeaDvAtFgDVozLBzWI5tSEzywe9kuIFznm8cL3rvm99Sb67Aa2zamcp8kOP fuC2uRuhHLt0KGpfbC3vVcTcF+3Z93nFXSq/UEHnkvKvmbxi+ppC5b92jd/gGqXW8eG9 FM0w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1734037762; x=1734642562; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=4LcqT6RFZpU+AfgSkhVCNBVs2JrpNLGjbQouQLx+w/k=; b=pg8KJu08fpujXIti9mtfefrl1mgrP43lKVUmc4nKCL165URcLBIPzXYhHI/1Y6U9Mc 4g0T7DsW2Zzj/5ltfdJAZTb8paIQW7Ufqx94kyzY4suST8EAsdMf6465F1yY4fV9Lme/ a8XKMWhkJXNm10aUojb9lX3vZUO7tzd0S23GwL3GFCPkQAxg3duq3c/vTSDsukWC3CXS 3giQfCN//HR15bi8GklTU+XxgB77DxFPi3RtsfbzA+8Ii4q4Ue407Wak8LpcgIetubQ1 3nVmzCry8LiF+EEkDB9D3xELJXeA0ThTuFY0XMb/Nrv7+ccDanZuhiXF1R8YkUb53Q39 iZ0g== X-Forwarded-Encrypted: i=1; AJvYcCU2TNgfFDz/xOkKaQvfipg+E6V9F8/dl+n0JV2QiN2bMgqcEBSl8ChsaTS+O4XF8KWE5H//LQrLMwz0utorbZN8@lists.infradead.org X-Gm-Message-State: AOJu0Yz16fQVshMSUrZRTPj7xIDoBZv+mm9vpLCr6OpjzgJi+tArYgU1 uu5Btrv1X8UczN3bqsigM051NMcEU2e/FAZe44V7W183MPb5ciWe X-Gm-Gg: ASbGncuOQzsTJyWoZQBKsFTjMZD9o/tjyRDSvFYxmk5qwJ10/DND7NAVauLQ6kdT47m pAxDbIFhYCyxozwzb3L9nxzVkpLL9rwUMfDXf8qLkNUTL5xjplf5O1+NzSCJLEGiJLv+Ns9WRX4 cJCXNYy0J3/hgGc5xHFVnFNgGCFWYenmwnLa0xQhd3uwPJKSHoqJxobDRscwMYiBL3HFS81DavZ f2w6Cc5OtgBcqrn2JHh0dUY0PlJhqZaeXh1KfwPEFhzfHyNqWbNo4nn2rz9G8to0gGb X-Google-Smtp-Source: AGHT+IGNLsnyopvoEGCAoELFMil/bI95Bbi59GnVO24Tgss+SOkt2jDXgVFqyCrkWQppUAutiI/wVA== X-Received: by 2002:a05:6402:210f:b0:5d1:2652:42ba with SMTP id 4fb4d7f45d1cf-5d63239e3damr1998287a12.16.1734037760215; Thu, 12 Dec 2024 13:09:20 -0800 (PST) Received: from [192.168.31.111] ([194.39.226.133]) by smtp.gmail.com with ESMTPSA id 4fb4d7f45d1cf-5d3d0f93d54sm9232348a12.68.2024.12.12.13.09.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 12 Dec 2024 13:09:19 -0800 (PST) From: Markuss Broks Date: Thu, 12 Dec 2024 23:09:03 +0200 Subject: [PATCH 3/3] MAINTAINERS: Add entry for the Samsung Exynos SPEEDY host controller MIME-Version: 1.0 Message-Id: <20241212-speedy-v1-3-544ad7bcfb6a@gmail.com> References: <20241212-speedy-v1-0-544ad7bcfb6a@gmail.com> In-Reply-To: <20241212-speedy-v1-0-544ad7bcfb6a@gmail.com> To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Alim Akhtar , Krzysztof Kozlowski Cc: linux-samsung-soc@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Ivaylo Ivanov , Markuss Broks X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1734037753; l=963; i=markuss.broks@gmail.com; s=20241024; h=from:subject:message-id; bh=W96WZYcRWJBuUyWOrDs/OpzeK6jPnXsbm8DFk91L+50=; b=vQxIcKGQNSUKYi5s6WONKZzJe7/plvG1ezTM9BPeMsyvRV75HipNqBcJuId8xUxGH6I1S6UUp OCguhCtHIWZDUKzeIFbJZLqtbTahyjdWEuz4elHnfQz6LuuJOWduonh X-Developer-Key: i=markuss.broks@gmail.com; a=ed25519; pk=p3Bh4oPpeCrTpffJvGch5WsWNikteWHJ+4LBICPbZg0= X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20241212_130923_856341_1FAB3287 X-CRM114-Status: UNSURE ( 9.49 ) X-CRM114-Notice: Please train this message. X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Add an entry adding myself as a maintainer of the Exynos SPEEDY host controller driver. Signed-off-by: Markuss Broks --- MAINTAINERS | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index bf2dcd4e0261785add520b5eac747ceac523e112..14041c5373df76c7a7093f106dded1080b5d8664 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -20754,6 +20754,13 @@ S: Maintained F: Documentation/devicetree/bindings/rng/samsung,exynos4-rng.yaml F: drivers/crypto/exynos-rng.c +SAMSUNG EXYNOS SPEEDY SERIAL HOST CONTROLLER DRIVER +M: Markuss Broks +L: linux-samsung-soc@vger.kernel.org +S: Maintained +F: Documentation/devicetree/bindings/soc/samsung/exynos-speedy.yaml +F: drivers/soc/samsung/exynos-speedy.c + SAMSUNG EXYNOS TRUE RANDOM NUMBER GENERATOR (TRNG) DRIVER M: Łukasz Stelmach L: linux-samsung-soc@vger.kernel.org