From nobody Sun May 24 19:35:20 2026 Received: from mail-wm1-f51.google.com (mail-wm1-f51.google.com [209.85.128.51]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9CBFD2BEC27 for ; Sat, 23 May 2026 02:48:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.51 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779504540; cv=none; b=r/TAw8dYpSb+/w4C4NftMbdTN0Q1X6PpdTXHFtNrVllbddc3pB3oJzzr4PY7mfQdnWRNU+SVCkNvvsIrqOOtWC9UQ/3s1SEhbxKhucAjhQrYhD8F48npjooGWO/hx+XjcjNgXHrMCRvFs960ocWPmNMIUGFI6sDyPPGCLhR9d0w= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779504540; c=relaxed/simple; bh=ksE9IzGsVOiPiMz3PetPeTc3/hG40XGcqECVS4HfclM=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=g68qJnyxCThZO0oGJdVBcxFPkOwz7El4cPpIi4zXW2B4dTldtj7yUOhdCd9DOsua4TBCI/c0pvwXJCVUYMxcL4mkpo56/pD1LmIKMFWfGoP1vHxvWUX1o96QWzwAeeX5vmgrizt2kn1C1ZqZnNHPUQnxCDmXv4symY0j32uI41g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org; spf=pass smtp.mailfrom=linaro.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b=v757jC0A; arc=none smtp.client-ip=209.85.128.51 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linaro.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="v757jC0A" Received: by mail-wm1-f51.google.com with SMTP id 5b1f17b1804b1-48a563e4ef7so60289565e9.0 for ; Fri, 22 May 2026 19:48:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1779504535; x=1780109335; darn=vger.kernel.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=ZpqokVh1FuDolR3bjOrXVJUhBU/P6kIDy2rIFcxqce8=; b=v757jC0AU/bDjs/JZ5pd6q/IoACAKx4ozTZYMvOcz6AAOk2vBZyjN+CqGit/vjhyK2 Q+q12epBLcMCQ3ils6fRiivz+1Kht65yyjwr1SouDHX4pGI0jSf+ek6d4LpJze5gRHWZ CrQDpZYTmiGQlf+q0xdrpbHZzy3ZuHHUnKYPJFScebpd58teqT/2HMh3iRKkYhij6QpE 22hbx3vTKnTiFLbjnE+ppdrFBfKoqA7Cq/Q5QSES/gqPH3AmEKiY0IsmD1wlJmeLmlO2 Da10HEaKqSVHmsvtBFdB3HMAeV6kuozf1Eh6MbXgLgh9C6qNR5tdNUKG+dyU9xEPwUwQ M3RQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779504535; x=1780109335; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=ZpqokVh1FuDolR3bjOrXVJUhBU/P6kIDy2rIFcxqce8=; b=cC8FcrStIFlfTlhl3vvI/nB3mvun1H0P+UmceUSzU4YkY+zUECCw3y4lrI5xQPDjGI XsY3HxLJ1HMcTJNTS5SGVReRn4if5SQRUzNDvcFJerx3c8uYyvJj3fFan8h6aS6UW5G1 mzSKIazQSz6nHWjAhPEB+zcjp139uF+xXBI7BQSmP0JdkUSCoX3vMdbAoTzQie1IMj94 f7hN7Cp8Ag37Nv7+IkZm2SmMn1bCzggxMrcNawue9psvVt2WEFqYzEXNdy2eFWWzFNGn O8epAG1vJLaetey1XPIw+iupnSwNWmqmzp8t/aUlRU800sHiQ7QK2clxn8Kgt9UoRAao D0pA== X-Forwarded-Encrypted: i=1; AFNElJ/iljU2qd00WKcFqqAWF2zp243tAMO7Fd8rPVXCVDV2Vhtu+lHLjh5aPYfNpyxzyynXk8zNxqy9RxtuJCg=@vger.kernel.org X-Gm-Message-State: AOJu0Yz8lFiTHT2itX2zfbPCP349KtRSv8dnDHcdvoexdPMDi8EEOaRR xGWppJIMPbyWyHK7impkIwhKT0XEn98bqqdccG4sCy+rVRlQxx54xV2V6BqRhggHi1A= X-Gm-Gg: Acq92OG+eH4fUhKe6ZAh8uIduJq8MBIbRA9zbPoZ+53xFJRIqirqxeMts+97JIgRvfz PnZlh6m6i1FDdhUqUAxETZcvEAS23eiWiKQvtyuY/grMZBBOPJpeEVZp/hSEaAycffWIcNyRZSy 8df9fGHq1nuLA+/P23CJFHBHieQO1cozej4e7E1sv5GoIr+KVLdC4HiLf7eAgtzXjT9tBhT00lh 9EwiG8WXPzT98sN4NatfJNTxSaizMNH2rQT1n38E/RFUwGEFY7JMOKo5Sd3/F6kFn2YpstUAayd tFnFhG4AwZrlxcQJC7/hqBPoU+Irvbf00kvB1LKpJZ+xKFtzuFRDVRqhGT+URneQ1T9pF+Tf4T0 VAQr3PnYFHlDIw6H8u8d1XJsjGTGUNF+ziGV1+UkiiJFJNGvGpGmlgBNMQvrxuXkrLfhkLRl2gq RtI78McVosZVm8AJK+WyEIaSciLlFopYP3qg== X-Received: by 2002:a05:600c:8217:b0:490:51e9:deba with SMTP id 5b1f17b1804b1-49051e9e233mr7104605e9.27.1779504534976; Fri, 22 May 2026 19:48:54 -0700 (PDT) Received: from [192.168.0.35] ([109.76.145.17]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-4904526ca50sm77938765e9.2.2026.05.22.19.48.53 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 22 May 2026 19:48:53 -0700 (PDT) From: Bryan O'Donoghue Date: Sat, 23 May 2026 03:48:47 +0100 Subject: [PATCH v8 1/2] dt-bindings: phy: qcom: Add CSI2 C-PHY/DPHY schema Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260523-x1e-csi2-phy-v8-1-a85668459521@linaro.org> References: <20260523-x1e-csi2-phy-v8-0-a85668459521@linaro.org> In-Reply-To: <20260523-x1e-csi2-phy-v8-0-a85668459521@linaro.org> To: Vinod Koul , Kishon Vijay Abraham I , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Neil Armstrong Cc: Bryan O'Donoghue , Vladimir Zapolskiy , linux-arm-msm@vger.kernel.org, linux-phy@lists.infradead.org, linux-media@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Bryan O'Donoghue X-Mailer: b4 0.15.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=7217; i=bryan.odonoghue@linaro.org; h=from:subject:message-id; bh=ksE9IzGsVOiPiMz3PetPeTc3/hG40XGcqECVS4HfclM=; b=owEBbQKS/ZANAwAKASJxO7Ohjcg6AcsmYgBqERWSME4EpK2d/5JPuYSQIQCI4mTc8FjYMEryO I9h1w8mgdCJAjMEAAEKAB0WIQTmk/sqq6Nt4Rerb7QicTuzoY3IOgUCahEVkgAKCRAicTuzoY3I OoFoD/9rMWDg4FRxEc7CpWP3FkkNIhLhPloMolmD2ZizRvmmtxOMiic4MznI9AdWEDMdCi9yAZn hRqwrtpkHeg3pQLRmWU5TTryFgz5WTMLyaXAcY4HqoG2Gyw08FuJwbtwvwH2aH44v1HoZvp0O4/ M6OYL2qQm6J65cizP0iy3yKA1mQ6B9RWlsvqeLAfQ4Lk9Xd8gHTvIUwa7W8YAEzyiXgX/B+hC6A nZCOFEjwUDsKQg6/1YM6QkkDE9k99lt9Qc/goJtVoiOIG1qJb0cB4tNlfCbD2p2LkZM1p/dOVAL XlponAKgOUZ775V+4mVmqBfgfHU1GlXaAjhmNAwQW8kFUT0zwXwnrqFgbPoOj3DX6Xouvn5IR56 dDoJhlQp0ztOAXMDy0tgzt6gxp6ywBeo/rfhBo76C2yY23xsMr1QDI6aeijjiLNlE0cGsrZ/mA6 bRvXttP4q/3BLEREEAFctAHr+6y04Y0LiUDHHcVB1c/aMYaMIXiP/mwJ2ZrHzkdgsqIYN/wMtY2 8SJ3fbTsc6hFvpT7VRZHzQrl9E87wKernw2OEdja7gT1gj3p6Shfvj1c07nK/rAzibYLWdhJCk3 6FDa6jmQZbTDvI2nSO2BbPYJ+Fb8QMnG2a7a0k8ZWUPlgBzXxSx9Aoxy7ITYUo2yTE4Nncbhimm BBn7IN6anHmnHHA== X-Developer-Key: i=bryan.odonoghue@linaro.org; a=openpgp; fpr=E693FB2AABA36DE117AB6FB422713BB3A18DC83A Add a base schema initially compatible with x1e80100 to describe MIPI CSI2 PHY devices. The hardware can support both CPHY, DPHY and a special split-mode DPHY. The schema here defines three ports: port@0: The first input port where a sensor is always required. port@1: A second optional input port which if present implies DPHY split-mode. port@2: A third always required output port which connects to the controller. The CSIPHY devices have their own pinouts on the SoC as well as their own individual voltage rails. The need to model voltage rails on a per-PHY basis leads us to define CSIPHY devices as individual nodes. Two nice outcomes in terms of schema and DT arise from this change. 1. The ability to define on a per-PHY basis voltage rails. 2. The ability to require those voltage. We have had a complete bodge upstream for this where a single set of voltage rail for all CSIPHYs has been buried inside of CAMSS. Much like the I2C bus which is dedicated to Camera sensors - the CCI bus in CAMSS parlance, the CSIPHY devices should be individually modelled. Signed-off-by: Bryan O'Donoghue --- .../bindings/phy/qcom,x1e80100-csi2-phy.yaml | 209 +++++++++++++++++= ++++ 1 file changed, 209 insertions(+) diff --git a/Documentation/devicetree/bindings/phy/qcom,x1e80100-csi2-phy.y= aml b/Documentation/devicetree/bindings/phy/qcom,x1e80100-csi2-phy.yaml new file mode 100644 index 0000000000000..270375f949880 --- /dev/null +++ b/Documentation/devicetree/bindings/phy/qcom,x1e80100-csi2-phy.yaml @@ -0,0 +1,209 @@ +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/phy/qcom,x1e80100-csi2-phy.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Qualcomm CSI2 PHY + +maintainers: + - Bryan O'Donoghue + +description: + Qualcomm MIPI CSI2 C-PHY/D-PHY combination PHY. Connects MIPI CSI2 senso= rs + to Qualcomm's Camera CSI Decoder. The PHY supports both C-PHY and D-PHY + modes. + +properties: + compatible: + const: qcom,x1e80100-csi2-phy + + reg: + maxItems: 1 + + "#phy-cells": + const: 1 + description: + The single cell specifies the PHY operating mode. + + clocks: + maxItems: 2 + + clock-names: + items: + - const: core + - const: timer + + interrupts: + maxItems: 1 + + operating-points-v2: + maxItems: 1 + + power-domains: + items: + - description: MMCX voltage rail + - description: MXC or MXA voltage rail + + power-domain-names: + items: + - const: mmcx + - const: mx + + vdda-0p9-supply: + description: Phandle to a 0.9V regulator supply to a PHY. + + vdda-1p2-supply: + description: Phandle to 1.2V regulator supply to a PHY. + + ports: + $ref: /schemas/graph.yaml#/properties/ports + + properties: + port@0: + $ref: /schemas/graph.yaml#/$defs/port-base + description: Sensor input. Always present. + unevaluatedProperties: false + + properties: + endpoint: + $ref: /schemas/media/video-interfaces.yaml# + unevaluatedProperties: false + properties: + data-lanes: + minItems: 1 + maxItems: 4 + clock-lanes: + maxItems: 1 + remote-endpoint: true + required: + - data-lanes + - remote-endpoint + + port@1: + $ref: /schemas/graph.yaml#/$defs/port-base + description: + Second sensor input. When present, indicates DPHY split mode. + unevaluatedProperties: false + + properties: + endpoint: + $ref: /schemas/media/video-interfaces.yaml# + unevaluatedProperties: false + properties: + data-lanes: + maxItems: 1 + clock-lanes: + maxItems: 1 + remote-endpoint: true + required: + - data-lanes + - clock-lanes + - remote-endpoint + + port@2: + $ref: /schemas/graph.yaml#/$defs/port-base + description: Output to CAMSS controller. + unevaluatedProperties: false + + properties: + endpoint: + $ref: /schemas/graph.yaml#/$defs/endpoint-base + unevaluatedProperties: false + properties: + remote-endpoint: true + required: + - remote-endpoint + + required: + - port@0 + - port@2 + +required: + - compatible + - reg + - "#phy-cells" + - clocks + - clock-names + - interrupts + - operating-points-v2 + - power-domains + - power-domain-names + - vdda-0p9-supply + - vdda-1p2-supply + - ports + +additionalProperties: false + +examples: + - | + #include + #include + #include + #include + + csiphy4: csiphy@ace4000 { + compatible =3D "qcom,x1e80100-csi2-phy"; + reg =3D <0x0ace4000 0x2000>; + #phy-cells =3D <1>; + + clocks =3D <&camcc CAM_CC_CSIPHY0_CLK>, + <&camcc CAM_CC_CSI0PHYTIMER_CLK>; + clock-names =3D "core", + "timer"; + + operating-points-v2 =3D <&csiphy_opp_table>; + + interrupts =3D ; + + power-domains =3D <&rpmhpd RPMHPD_MMCX>, + <&rpmhpd RPMHPD_MX>; + power-domain-names =3D "mmcx", + "mx"; + + vdda-0p9-supply =3D <&vreg_l2c_0p8>; + vdda-1p2-supply =3D <&vreg_l1c_1p2>; + + ports { + #address-cells =3D <1>; + #size-cells =3D <0>; + + port@0 { + reg =3D <0>; + csiphy0_in_ep: endpoint { + data-lanes =3D <0 1>; + clock-lanes =3D <2>; + remote-endpoint =3D <&sensor_out>; + }; + }; + + port@2 { + reg =3D <2>; + csiphy0_out_ep: endpoint { + remote-endpoint =3D <&controller_in>; + }; + }; + }; + }; + + csiphy_opp_table: opp-table { + compatible =3D "operating-points-v2"; + + opp-300000000 { + opp-hz =3D /bits/ 64 <300000000>; + required-opps =3D <&rpmhpd_opp_low_svs_d1>, + <&rpmhpd_opp_low_svs_d1>; + }; + + opp-400000000 { + opp-hz =3D /bits/ 64 <400000000>; + required-opps =3D <&rpmhpd_opp_low_svs>, + <&rpmhpd_opp_low_svs_d1>; + }; + + opp-480000000 { + opp-hz =3D /bits/ 64 <480000000>; + required-opps =3D <&rpmhpd_opp_low_svs>, + <&rpmhpd_opp_low_svs_d1>; + }; + }; --=20 2.54.0 From nobody Sun May 24 19:35:20 2026 Received: from mail-wm1-f44.google.com (mail-wm1-f44.google.com [209.85.128.44]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3072C332918 for ; Sat, 23 May 2026 02:48:59 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.44 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779504544; cv=none; b=tDDNTT2ueYmUmgAfdttknA1sRDDGnjWBJsMLb02+4peGnA8S+flOg3gN/zVe7fjWBAuTdbWR+lSOdv9Z+Bb4XSQPCzXxyJ7CqKDOOPMUIq8ymgR/zP4hoPc38/iREQhnmUEhw6NeodoY6xMexA2tQkBZ118GQ6K4B2OPRKraql0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779504544; c=relaxed/simple; bh=qUIU2i6uB2n+BGlErGLwXYiRhUKHamgWTH51BzZMfrk=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Hn/cNjHiS29ZQoP0kj1+5x6Ogd5bE/xSctWjufwoqFZpr+jv5Qi2tBhncqOuIr10ON1W11bA4b4RgkFx/T1du8FmAAhLr1hD/1MwkunTEydLpPmtI9qQbh35gK9EdwbvUdOd8w+GniLJQCb8qEajuSBeDsVYK7cbQ8V1bmxUQqg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org; spf=pass smtp.mailfrom=linaro.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b=VX9vKrCU; arc=none smtp.client-ip=209.85.128.44 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linaro.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="VX9vKrCU" Received: by mail-wm1-f44.google.com with SMTP id 5b1f17b1804b1-4896c22fcbaso66319215e9.0 for ; Fri, 22 May 2026 19:48:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1779504537; x=1780109337; darn=vger.kernel.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=J+DPhxj31b+09iYxhLOy+gEpAX+73ntgaEg3gXHlJZI=; b=VX9vKrCU23v81SbOUC9iuxFMCKEDse/i6i7vjJ4NwYmD4bZznbxxnNR3H8/2o0SyZ6 ijhUG2U3grAVtBMxyJRWGmnDipwum8/fDPFzb5E8XAN+GPKwDxyXs0lyujnhk/KB73Xs +6YOZHesQ9o8Do9QY/CZBV9JM5z4PYONYhIH4S6Y2jA4QxhjVwz09zfIYBPhvHPTfg4B QRbDOF0eak9dPrM1smpeYHP86oENXqqbFGsNiHTERdBteBPQ0CnCMiK9ShHlcErTci+A h+ngXr+kVR4FawhOcIBJRAlghXEtbTl7tZ51lNuYdgfBFcgsL9SdkNfRsK8iTE4StEaf EdXQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779504537; x=1780109337; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=J+DPhxj31b+09iYxhLOy+gEpAX+73ntgaEg3gXHlJZI=; b=ULnD5A6cYUePxbqb2ODZhMq6f9RRyTmcL7MxU3ozy9BxXrmaSQo+QdGF47LoWAP4Ax 17RrZzwq/kuwEiLNNrrg2i0Q5SYTs2hHyBQiM2D2a0Kb3vRVYNDonrFMQrdZZ+BVYO/o r3alJpCXXCVteI2Ef/xb7F6lPqjURIHdtjk/muuubUZZQBs7cGbXv1kYD9ZJKGResNCv CLGFRfun7ZGMljW1nZtvtqMWMVL469AWND/aSP7fBnYen0xPJtA05TowPovyvEOn0+n/ y1aJxugbz3CRWi5vboeUCuajmXPvjZYlV5PwLaxDIiOkkUeHZTaDlSQ9Zh6gqcybfGAT e3MA== X-Forwarded-Encrypted: i=1; AFNElJ/yWI9ypOgnnw+Y20+ZjnPo3xqILcUdgwtGtH5z3NozFY/kMAASnetXWYQzbFrSVibybx6d0Io0v9jhQTI=@vger.kernel.org X-Gm-Message-State: AOJu0YwRaYr1WV9q13xkm2P0CdERysv9UGpszE4sULX2lVJTDC+pBD5u yhcf8j2Pp1CwLxr+Zp3UiG62IP0h9jK2AR0EP6WG+5O2XCvGGBIKjg08ABhAl0S/5mk= X-Gm-Gg: Acq92OF6t9pF4IMxtvJ+1EipyZgdDbHt/9mbj+lLjZNuuHNYU9xC2iOqMdJluaaRypL YbROsqcRSzyqNbfC2YfsqQO2m+P0YuGmuxNhJa8xD2cyKOcpT+ePkpKSMQUkeu1POG1CYEWIFt1 4Ft+DqSOI7DB/kkC0uFcKr4UDp/0uWSWPwf6xhY2A6mkjLfwNPqe3aO8WBXz9Q5s5Qt0QTNKM8m hxbIqeW79BDplq7r9bxR6rUKH5E26wBgjJFNlknKKV42i6xnUoPmPeAVKk8GjwN8khF3LhMDcO4 5oSwEeSEyJvTxGijT0or/YiL9CW1QIR8TcgHekgyaMg6EqLEkEN8T2Vq8epkvyX4ecGtxoFGdjW 7qwB/nU4zXo6xasoeZqlpH6rNHzVT2wM8FzTN2f/RHIkV4qiO+kPdBfi6YlvveucsCyeZwD2Ejm aM4IePiWLBvqNcfLQcXhOi7f8nS1dMblQ+CQ== X-Received: by 2002:a05:600c:6290:b0:490:46df:a852 with SMTP id 5b1f17b1804b1-49046dfaa16mr74845455e9.10.1779504536984; Fri, 22 May 2026 19:48:56 -0700 (PDT) Received: from [192.168.0.35] ([109.76.145.17]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-4904526ca50sm77938765e9.2.2026.05.22.19.48.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 22 May 2026 19:48:56 -0700 (PDT) From: Bryan O'Donoghue Date: Sat, 23 May 2026 03:48:48 +0100 Subject: [PATCH v8 2/2] phy: qcom-mipi-csi2: Add a CSI2 MIPI DPHY driver Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260523-x1e-csi2-phy-v8-2-a85668459521@linaro.org> References: <20260523-x1e-csi2-phy-v8-0-a85668459521@linaro.org> In-Reply-To: <20260523-x1e-csi2-phy-v8-0-a85668459521@linaro.org> To: Vinod Koul , Kishon Vijay Abraham I , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Neil Armstrong Cc: Bryan O'Donoghue , Vladimir Zapolskiy , linux-arm-msm@vger.kernel.org, linux-phy@lists.infradead.org, linux-media@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Bryan O'Donoghue X-Mailer: b4 0.15.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=35878; i=bryan.odonoghue@linaro.org; h=from:subject:message-id; bh=qUIU2i6uB2n+BGlErGLwXYiRhUKHamgWTH51BzZMfrk=; b=owEBbQKS/ZANAwAKASJxO7Ohjcg6AcsmYgBqERWS9xBs8jsZL4SS8uxKMTCFJDdKB2ahy03dl L/fPt4tmKWJAjMEAAEKAB0WIQTmk/sqq6Nt4Rerb7QicTuzoY3IOgUCahEVkgAKCRAicTuzoY3I OjOYEACeboxRAByqbf41WwXFbca1uu7ChkcMUbo1Z2Y2NiDZAnOf3Q5YDDrBnolMQdmWLf6207E S+r2BFsuerQc9f5YpwXgbl7S03QRnKMXNm0Ca/rSQ51MYUnfQGdmszSqwQ7Ir5lCwHKJX4f0OSg CskX2XA01YTnVKNTRsondjtCYLDNrPh29H/JYHJgJIOvcqIG7xi2g219t+YyeGIgDJRZ89XN6aw snmqWI0VhZMImHLPyZAfVPt8HbcUrafHYpQ/I6Cv0c0eHpShoy2MnU6wvOz7lE6IE+1+lZla+GV 645WfxjkmhJ0UvRaJcgB6Ny0HtQZ2UMsM/7RGJv9g1YubyUN5b+lG1zGt1abY1C565yT4rDRj3I C0nVtTcy2BGdZE2pXrPpLYsC0LpBnoNCc1maPYgwHV8fqO8R+92Sf8GJSKiAl+rDVAlKnX6M7vg NyIMdj5CjLc2jtnz1e506qm/57FIsghl4sog4mG0OhoupKMsfEoytsjALkl++1jjQYdGbJHEEND 87NLoYZ3qDx09/U1j2PfDqQR8avYleGSMMMiw/7EoNX4kTi5Q+Ea4OSaUr/02Y3ClA6H0fD3k86 e+WPvAyHek8766YgYT9tT7kjeciwVP3ps7po3yvME6ACknmWr85NSH7n1sRRUnIoINS18gy1syG voxVefHUvuROnjQ== X-Developer-Key: i=bryan.odonoghue@linaro.org; a=openpgp; fpr=E693FB2AABA36DE117AB6FB422713BB3A18DC83A Add a new MIPI CSI2 driver in DPHY mode initially. The entire set of existing CAMSS CSI PHY init sequences are imported in order to save time and effort in later patches. The following devices are supported in this drop: "qcom,x1e80100-csi2-phy" In-line with other PHY drivers the process node is included in the name. Data-lane and clock lane positioning and polarity selection via newly amended struct phy_configure_opts_mipi_dphy{} is supported. The Qualcomm 3PH class of PHYs can do both DPHY and CPHY mode. For now only DPHY is supported. In porting some of the logic over from camss-csiphy*.c to here its also possible to rationalise some of the code. In particular use of regulator_bulk and clk_bulk as well as dropping the seemingly useless and unused interrupt handler. The PHY sequences and a lot of the logic that goes with them are well proven in CAMSS and mature so the main thing to watch out for here is how to get the right sequencing of regulators, clocks and register-writes. The register init sequence table is imported verbatim from the existing CAMSS csiphy driver. A follow-up series will rework the table to extract the repetitive per-lane pattern into a loop. Signed-off-by: Bryan O'Donoghue --- MAINTAINERS | 10 + drivers/phy/qualcomm/Kconfig | 14 + drivers/phy/qualcomm/Makefile | 5 + drivers/phy/qualcomm/phy-qcom-mipi-csi2-3ph-dphy.c | 376 +++++++++++++++++= ++ drivers/phy/qualcomm/phy-qcom-mipi-csi2-core.c | 402 +++++++++++++++++= ++++ drivers/phy/qualcomm/phy-qcom-mipi-csi2.h | 95 +++++ 6 files changed, 902 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 63389fea5d150..3b5da8a40383f 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -22018,6 +22018,16 @@ S: Maintained F: Documentation/devicetree/bindings/media/qcom,*-iris.yaml F: drivers/media/platform/qcom/iris/ =20 +QUALCOMM MIPI CSI2 PHY DRIVER +M: Bryan O'Donoghue +L: linux-phy@lists.infradead.org +L: linux-media@vger.kernel.org +L: linux-arm-msm@vger.kernel.org +S: Maintained +F: Documentation/devicetree/bindings/phy/qcom,*-csi2-phy.yaml +F: drivers/phy/qualcomm/phy-qcom-mipi-csi2*.c +F: drivers/phy/qualcomm/phy-qcom-mipi-csi2*.h + QUALCOMM NAND CONTROLLER DRIVER M: Manivannan Sadhasivam L: linux-mtd@lists.infradead.org diff --git a/drivers/phy/qualcomm/Kconfig b/drivers/phy/qualcomm/Kconfig index 60a0ead127fa9..779a3511ba852 100644 --- a/drivers/phy/qualcomm/Kconfig +++ b/drivers/phy/qualcomm/Kconfig @@ -28,6 +28,20 @@ config PHY_QCOM_EDP Enable this driver to support the Qualcomm eDP PHY found in various Qualcomm chipsets. =20 +config PHY_QCOM_MIPI_CSI2 + tristate "Qualcomm MIPI CSI2 PHY driver" + depends on ARCH_QCOM || COMPILE_TEST + depends on OF + depends on PM + depends on COMMON_CLK + select GENERIC_PHY + select GENERIC_PHY_MIPI_DPHY + help + Enable this to support the MIPI CSI2 PHY driver found in various + Qualcomm chipsets. This PHY is used to connect MIPI CSI2 + camera sensors to the CSI Decoder in the Qualcomm Camera Subsystem + CAMSS. + config PHY_QCOM_IPQ4019_USB tristate "Qualcomm IPQ4019 USB PHY driver" depends on OF && (ARCH_QCOM || COMPILE_TEST) diff --git a/drivers/phy/qualcomm/Makefile b/drivers/phy/qualcomm/Makefile index b71a6a0bed3f1..382cb594b06b6 100644 --- a/drivers/phy/qualcomm/Makefile +++ b/drivers/phy/qualcomm/Makefile @@ -6,6 +6,11 @@ obj-$(CONFIG_PHY_QCOM_IPQ4019_USB) +=3D phy-qcom-ipq4019-u= sb.o obj-$(CONFIG_PHY_QCOM_IPQ806X_SATA) +=3D phy-qcom-ipq806x-sata.o obj-$(CONFIG_PHY_QCOM_M31_USB) +=3D phy-qcom-m31.o obj-$(CONFIG_PHY_QCOM_M31_EUSB) +=3D phy-qcom-m31-eusb2.o + +phy-qcom-mipi-csi2-objs +=3D phy-qcom-mipi-csi2-core.o \ + phy-qcom-mipi-csi2-3ph-dphy.o +obj-$(CONFIG_PHY_QCOM_MIPI_CSI2) +=3D phy-qcom-mipi-csi2.o + obj-$(CONFIG_PHY_QCOM_PCIE2) +=3D phy-qcom-pcie2.o =20 obj-$(CONFIG_PHY_QCOM_QMP_COMBO) +=3D phy-qcom-qmp-combo.o phy-qcom-qmp-us= bc.o diff --git a/drivers/phy/qualcomm/phy-qcom-mipi-csi2-3ph-dphy.c b/drivers/p= hy/qualcomm/phy-qcom-mipi-csi2-3ph-dphy.c new file mode 100644 index 0000000000000..86ec405820e62 --- /dev/null +++ b/drivers/phy/qualcomm/phy-qcom-mipi-csi2-3ph-dphy.c @@ -0,0 +1,376 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Qualcomm MSM Camera Subsystem - CSIPHY Module 3phase v1.0 + * + * Copyright (c) 2011-2015, The Linux Foundation. All rights reserved. + * Copyright (C) 2016-2025 Linaro Ltd. + */ + +#include +#include +#include +#include + +#include "phy-qcom-mipi-csi2.h" + +#define CSIPHY_3PH_CMN_CSI_COMMON_CTRLn(offset, n) ((offset) + 0x4 * (n)) +#define CSIPHY_3PH_CMN_CSI_COMMON_CTRL0_PHY_SW_RESET BIT(0) +#define CSIPHY_3PH_CMN_CSI_COMMON_CTRL5_CLK_ENABLE BIT(7) +#define CSIPHY_3PH_CMN_CSI_COMMON_CTRL6_COMMON_PWRDN_B BIT(0) +#define CSIPHY_3PH_CMN_CSI_COMMON_CTRL6_SHOW_REV_ID BIT(1) +#define CSIPHY_3PH_CMN_CSI_COMMON_CTRL10_IRQ_CLEAR_CMD BIT(0) +#define CSIPHY_3PH_CMN_CSI_COMMON_STATUSn(offset, n) ((offset) + 0xb0 + 0x= 4 * (n)) + +#define CSIPHY_2PH_LN_CSI_2PHASE_CTRL9n(n) ((0x200 * (n)) + 0x24) + +/* + * 3 phase CSI has 19 common status regs with only 0-10 being used + * and 11-18 being reserved. + */ +#define CSI_COMMON_STATUS_NUM 11 +/* + * There are a number of common control registers + * The offset to clear the CSIPHY IRQ status starts @ 22 + * So to clear CSI_COMMON_STATUS0 this is CSI_COMMON_CONTROL22, STATUS1 is + * CONTROL23 and so on + */ +#define CSI_CTRL_STATUS_INDEX 22 + +/* + * There are 43 COMMON_CTRL registers with regs after # 33 being reserved + */ +#define CSI_CTRL_MAX 33 + +#define CSIPHY_DEFAULT_PARAMS 0 +#define CSIPHY_SETTLE_CNT_LOWER_BYTE 2 +#define CSIPHY_SKEW_CAL 7 + +/* 4nm 2PH v 2.1.2 2p5Gbps 4 lane DPHY mode */ +static const struct +mipi_csi2phy_lane_regs lane_regs_x1e80100[] =3D { + /* Power up lanes 2ph mode */ + {.reg_addr =3D 0x1014, .reg_data =3D 0xd5, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x101c, .reg_data =3D 0x7a, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x1018, .reg_data =3D 0x01, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + + {.reg_addr =3D 0x0094, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x00a0, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0090, .reg_data =3D 0x0f, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0098, .reg_data =3D 0x08, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0094, .reg_data =3D 0x07, .delay_us =3D 0x01, .param_typ= e =3D CSIPHY_DEFAULT_PARAMS}, + {.reg_addr =3D 0x0030, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0000, .reg_data =3D 0x8e, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0038, .reg_data =3D 0xfe, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x002c, .reg_data =3D 0x01, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0034, .reg_data =3D 0x0f, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x001c, .reg_data =3D 0x0a, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0014, .reg_data =3D 0x60, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x003c, .reg_data =3D 0xb8, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0004, .reg_data =3D 0x0c, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0020, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0008, .reg_data =3D 0x10, .param_type =3D CSIPHY_SETTLE_= CNT_LOWER_BYTE}, + {.reg_addr =3D 0x0010, .reg_data =3D 0x52, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0094, .reg_data =3D 0xd7, .param_type =3D CSIPHY_SKEW_CA= L}, + {.reg_addr =3D 0x005c, .reg_data =3D 0x00, .param_type =3D CSIPHY_SKEW_CA= L}, + {.reg_addr =3D 0x0060, .reg_data =3D 0xbd, .param_type =3D CSIPHY_SKEW_CA= L}, + {.reg_addr =3D 0x0064, .reg_data =3D 0x7f, .param_type =3D CSIPHY_SKEW_CA= L}, + + {.reg_addr =3D 0x0e94, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0ea0, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e90, .reg_data =3D 0x0f, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e98, .reg_data =3D 0x08, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e94, .reg_data =3D 0x07, .delay_us =3D 0x01, .param_ty= pe =3D CSIPHY_DEFAULT_PARAMS}, + {.reg_addr =3D 0x0e30, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e28, .reg_data =3D 0x04, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e00, .reg_data =3D 0x80, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e0c, .reg_data =3D 0xff, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e38, .reg_data =3D 0x1f, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e2c, .reg_data =3D 0x01, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e34, .reg_data =3D 0x0f, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e1c, .reg_data =3D 0x0a, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e14, .reg_data =3D 0x60, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e3c, .reg_data =3D 0xb8, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e04, .reg_data =3D 0x0c, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e20, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0e08, .reg_data =3D 0x10, .param_type =3D CSIPHY_SETTLE_= CNT_LOWER_BYTE}, + {.reg_addr =3D 0x0e10, .reg_data =3D 0x52, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + + {.reg_addr =3D 0x0494, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x04a0, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0490, .reg_data =3D 0x0f, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0498, .reg_data =3D 0x08, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0494, .reg_data =3D 0x07, .delay_us =3D 0x01, .param_ty= pe =3D CSIPHY_DEFAULT_PARAMS}, + {.reg_addr =3D 0x0430, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0400, .reg_data =3D 0x8e, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0438, .reg_data =3D 0xfe, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x042c, .reg_data =3D 0x01, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0434, .reg_data =3D 0x0f, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x041c, .reg_data =3D 0x0a, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0414, .reg_data =3D 0x60, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x043c, .reg_data =3D 0xb8, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0404, .reg_data =3D 0x0c, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0420, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0408, .reg_data =3D 0x10, .param_type =3D CSIPHY_SETTLE_= CNT_LOWER_BYTE}, + {.reg_addr =3D 0x0410, .reg_data =3D 0x52, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0494, .reg_data =3D 0xd7, .param_type =3D CSIPHY_SKEW_CA= L}, + {.reg_addr =3D 0x045c, .reg_data =3D 0x00, .param_type =3D CSIPHY_SKEW_CA= L}, + {.reg_addr =3D 0x0460, .reg_data =3D 0xbd, .param_type =3D CSIPHY_SKEW_CA= L}, + {.reg_addr =3D 0x0464, .reg_data =3D 0x7f, .param_type =3D CSIPHY_SKEW_CA= L}, + + {.reg_addr =3D 0x0894, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x08a0, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0890, .reg_data =3D 0x0f, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0898, .reg_data =3D 0x08, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0894, .reg_data =3D 0x07, .delay_us =3D 0x01, .param_ty= pe =3D CSIPHY_DEFAULT_PARAMS}, + {.reg_addr =3D 0x0830, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0800, .reg_data =3D 0x8e, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0838, .reg_data =3D 0xfe, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x082c, .reg_data =3D 0x01, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0834, .reg_data =3D 0x0f, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x081c, .reg_data =3D 0x0a, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0814, .reg_data =3D 0x60, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x083c, .reg_data =3D 0xb8, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0804, .reg_data =3D 0x0c, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0820, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0808, .reg_data =3D 0x10, .param_type =3D CSIPHY_SETTLE_= CNT_LOWER_BYTE}, + {.reg_addr =3D 0x0810, .reg_data =3D 0x52, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0894, .reg_data =3D 0xd7, .param_type =3D CSIPHY_SKEW_CA= L}, + {.reg_addr =3D 0x085c, .reg_data =3D 0x00, .param_type =3D CSIPHY_SKEW_CA= L}, + {.reg_addr =3D 0x0860, .reg_data =3D 0xbd, .param_type =3D CSIPHY_SKEW_CA= L}, + {.reg_addr =3D 0x0864, .reg_data =3D 0x7f, .param_type =3D CSIPHY_SKEW_CA= L}, + + {.reg_addr =3D 0x0c94, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0ca0, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c90, .reg_data =3D 0x0f, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c98, .reg_data =3D 0x08, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c94, .reg_data =3D 0x07, .delay_us =3D 0x01, .param_ty= pe =3D CSIPHY_DEFAULT_PARAMS}, + {.reg_addr =3D 0x0c30, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c00, .reg_data =3D 0x8e, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c38, .reg_data =3D 0xfe, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c2c, .reg_data =3D 0x01, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c34, .reg_data =3D 0x0f, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c1c, .reg_data =3D 0x0a, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c14, .reg_data =3D 0x60, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c3c, .reg_data =3D 0xb8, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c04, .reg_data =3D 0x0c, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c20, .reg_data =3D 0x00, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c08, .reg_data =3D 0x10, .param_type =3D CSIPHY_SETTLE_= CNT_LOWER_BYTE}, + {.reg_addr =3D 0x0c10, .reg_data =3D 0x52, .param_type =3D CSIPHY_DEFAULT= _PARAMS}, + {.reg_addr =3D 0x0c94, .reg_data =3D 0xd7, .param_type =3D CSIPHY_SKEW_CA= L}, + {.reg_addr =3D 0x0c5c, .reg_data =3D 0x00, .param_type =3D CSIPHY_SKEW_CA= L}, + {.reg_addr =3D 0x0c60, .reg_data =3D 0xbd, .param_type =3D CSIPHY_SKEW_CA= L}, + {.reg_addr =3D 0x0c64, .reg_data =3D 0x7f, .param_type =3D CSIPHY_SKEW_CA= L}, +}; + +static inline const struct mipi_csi2phy_device_regs * +csi2phy_dev_to_regs(struct mipi_csi2phy_device *csi2phy) +{ + return &csi2phy->soc_cfg->reg_info; +} + +static void phy_qcom_mipi_csi2_hw_version_read(struct mipi_csi2phy_device = *csi2phy) +{ + const struct mipi_csi2phy_device_regs *regs =3D csi2phy_dev_to_regs(csi2p= hy); + u32 tmp; + + writel(CSIPHY_3PH_CMN_CSI_COMMON_CTRL6_SHOW_REV_ID, csi2phy->base + + CSIPHY_3PH_CMN_CSI_COMMON_CTRLn(regs->common_regs_offset, 6)); + + tmp =3D readl_relaxed(csi2phy->base + + CSIPHY_3PH_CMN_CSI_COMMON_STATUSn(regs->common_regs_offset, 12)); + csi2phy->hw_version =3D tmp; + + tmp =3D readl_relaxed(csi2phy->base + + CSIPHY_3PH_CMN_CSI_COMMON_STATUSn(regs->common_regs_offset, 13)); + csi2phy->hw_version |=3D (tmp << 8) & 0xFF00; + + tmp =3D readl_relaxed(csi2phy->base + + CSIPHY_3PH_CMN_CSI_COMMON_STATUSn(regs->common_regs_offset, 14)); + csi2phy->hw_version |=3D (tmp << 16) & 0xFF0000; + + tmp =3D readl_relaxed(csi2phy->base + + CSIPHY_3PH_CMN_CSI_COMMON_STATUSn(regs->common_regs_offset, 15)); + csi2phy->hw_version |=3D (tmp << 24) & 0xFF000000; + + dev_dbg_once(csi2phy->dev, "CSIPHY 3PH HW Version =3D 0x%08x\n", csi2phy-= >hw_version); +} + +/* + * phy_qcom_mipi_csi2_reset - Perform software reset on CSIPHY module + * @phy_qcom_mipi_csi2: CSIPHY device + */ +static void phy_qcom_mipi_csi2_reset(struct mipi_csi2phy_device *csi2phy) +{ + const struct mipi_csi2phy_device_regs *regs =3D csi2phy_dev_to_regs(csi2p= hy); + + writel(CSIPHY_3PH_CMN_CSI_COMMON_CTRL0_PHY_SW_RESET, + csi2phy->base + CSIPHY_3PH_CMN_CSI_COMMON_CTRLn(regs->common_regs_= offset, 0)); + usleep_range(5000, 8000); + writel(0x0, csi2phy->base + + CSIPHY_3PH_CMN_CSI_COMMON_CTRLn(regs->common_regs_offset, 0)); +} + +/* + * phy_qcom_mipi_csi2_settle_cnt_calc - Calculate settle count value + * + * Helper function to calculate settle count value. This is + * based on the CSI2 T_hs_settle parameter which in turn + * is calculated based on the CSI2 transmitter link frequency. + * + * Return settle count value or 0 if the CSI2 link frequency + * is not available + */ +static u8 phy_qcom_mipi_csi2_settle_cnt_calc(s64 link_freq, u32 timer_clk_= rate) +{ + u32 t_hs_prepare_max_ps; + u32 timer_period_ps; + u32 t_hs_settle_ps; + u8 settle_cnt; + u32 ui_ps; + + if (link_freq <=3D 0) + return 0; + + ui_ps =3D div_u64(PSEC_PER_SEC, link_freq); + ui_ps /=3D 2; + t_hs_prepare_max_ps =3D 85000 + 6 * ui_ps; + t_hs_settle_ps =3D t_hs_prepare_max_ps; + + timer_period_ps =3D div_u64(PSEC_PER_SEC, timer_clk_rate); + settle_cnt =3D t_hs_settle_ps / timer_period_ps - 6; + + return settle_cnt; +} + +static void +phy_qcom_mipi_csi2_gen2_config_lanes(struct mipi_csi2phy_device *csi2phy, + u8 settle_cnt) +{ + const struct mipi_csi2phy_device_regs *regs =3D csi2phy_dev_to_regs(csi2p= hy); + const struct mipi_csi2phy_lane_regs *r =3D regs->init_seq; + int i, array_size =3D regs->lane_array_size; + u32 val; + + for (i =3D 0; i < array_size; i++, r++) { + switch (r->param_type) { + case CSIPHY_SETTLE_CNT_LOWER_BYTE: + val =3D settle_cnt & 0xff; + break; + case CSIPHY_SKEW_CAL: + /* TODO: support application of skew from dt flag */ + continue; + default: + val =3D r->reg_data; + break; + } + writel(val, csi2phy->base + r->reg_addr); + if (r->delay_us) + udelay(r->delay_us); + } +} + +static int phy_qcom_mipi_csi2_lanes_enable(struct mipi_csi2phy_device *csi= 2phy, + struct mipi_csi2phy_stream_cfg *cfg) +{ + const struct mipi_csi2phy_device_regs *regs =3D csi2phy_dev_to_regs(csi2p= hy); + struct mipi_csi2phy_lanes_cfg *lane_cfg =3D &cfg->lane_cfg; + u8 settle_cnt; + u8 val; + int i; + + settle_cnt =3D phy_qcom_mipi_csi2_settle_cnt_calc(cfg->link_freq, csi2phy= ->timer_clk_rate); + + /* Lane position enable in common reg offset */ + val =3D BIT(lane_cfg->clk.pos); + for (i =3D 0; i < cfg->num_data_lanes; i++) + val |=3D BIT(lane_cfg->data[i].pos); + + writel(val, csi2phy->base + + CSIPHY_3PH_CMN_CSI_COMMON_CTRLn(regs->common_regs_offset, 5)); + + /* Lane configuration for polarity @ CSIPHY-base + CTRL9 */ + for (i =3D 0; i < cfg->num_data_lanes; i++) { + if (lane_cfg->data[i].pol) { + u8 pos =3D lane_cfg->data[i].pos; + + writel(BIT(2), csi2phy->base + CSIPHY_2PH_LN_CSI_2PHASE_CTRL9n(pos)); + } + } + + if (lane_cfg->clk.pol) + writel(BIT(2), csi2phy->base + CSIPHY_2PH_LN_CSI_2PHASE_CTRL9n(lane_cfg-= >clk.pos)); + + val =3D CSIPHY_3PH_CMN_CSI_COMMON_CTRL6_COMMON_PWRDN_B; + writel(val, csi2phy->base + + CSIPHY_3PH_CMN_CSI_COMMON_CTRLn(regs->common_regs_offset, 6)); + + val =3D 0x02; + writel(val, csi2phy->base + + CSIPHY_3PH_CMN_CSI_COMMON_CTRLn(regs->common_regs_offset, 7)); + + val =3D 0x00; + writel(val, csi2phy->base + + CSIPHY_3PH_CMN_CSI_COMMON_CTRLn(regs->common_regs_offset, 0)); + + phy_qcom_mipi_csi2_gen2_config_lanes(csi2phy, settle_cnt); + + /* IRQ_MASK registers - disable all interrupts */ + for (i =3D CSI_COMMON_STATUS_NUM; i < CSI_CTRL_STATUS_INDEX; i++) { + writel(0, csi2phy->base + + CSIPHY_3PH_CMN_CSI_COMMON_CTRLn(regs->common_regs_offset, i)); + } + + return 0; +} + +static void +phy_qcom_mipi_csi2_lanes_disable(struct mipi_csi2phy_device *csi2phy, + struct mipi_csi2phy_stream_cfg *cfg) +{ + const struct mipi_csi2phy_device_regs *regs =3D csi2phy_dev_to_regs(csi2p= hy); + + writel(0, csi2phy->base + + CSIPHY_3PH_CMN_CSI_COMMON_CTRLn(regs->common_regs_offset, 5)); + + writel(0, csi2phy->base + + CSIPHY_3PH_CMN_CSI_COMMON_CTRLn(regs->common_regs_offset, 6)); +} + +static const struct mipi_csi2phy_hw_ops phy_qcom_mipi_csi2_ops_3ph_1_0 =3D= { + .hw_version_read =3D phy_qcom_mipi_csi2_hw_version_read, + .reset =3D phy_qcom_mipi_csi2_reset, + .lanes_enable =3D phy_qcom_mipi_csi2_lanes_enable, + .lanes_disable =3D phy_qcom_mipi_csi2_lanes_disable, +}; + +static const char * const x1e_clks[] =3D { + "core", + "timer" +}; + +static const char * const x1e_supplies[] =3D { + "vdda-0p9", + "vdda-1p2" +}; + +static const char * const x1e_genpd_names[] =3D { + "mmcx", + "mx", +}; + +const struct mipi_csi2phy_soc_cfg mipi_csi2_dphy_4nm_x1e =3D { + .ops =3D &phy_qcom_mipi_csi2_ops_3ph_1_0, + .reg_info =3D { + .init_seq =3D lane_regs_x1e80100, + .lane_array_size =3D ARRAY_SIZE(lane_regs_x1e80100), + .common_regs_offset =3D 0x1000, + }, + .supply_names =3D (const char **)x1e_supplies, + .num_supplies =3D ARRAY_SIZE(x1e_supplies), + .clk_names =3D (const char **)x1e_clks, + .num_clk =3D ARRAY_SIZE(x1e_clks), + .opp_clk =3D x1e_clks[0], + .timer_clk =3D x1e_clks[1], + .genpd_names =3D (const char **)x1e_genpd_names, + .num_genpd_names =3D ARRAY_SIZE(x1e_genpd_names), +}; diff --git a/drivers/phy/qualcomm/phy-qcom-mipi-csi2-core.c b/drivers/phy/q= ualcomm/phy-qcom-mipi-csi2-core.c new file mode 100644 index 0000000000000..dfeff863a406f --- /dev/null +++ b/drivers/phy/qualcomm/phy-qcom-mipi-csi2-core.c @@ -0,0 +1,402 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2025, Linaro Ltd. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "phy-qcom-mipi-csi2.h" + +static int +phy_qcom_mipi_csi2_set_clock_rates(struct mipi_csi2phy_device *csi2phy, + s64 link_freq) +{ + struct device *dev =3D csi2phy->dev; + unsigned long opp_rate =3D link_freq / 4; + struct dev_pm_opp *opp; + long timer_rate; + int i, ret; + + opp =3D dev_pm_opp_find_freq_ceil(dev, &opp_rate); + if (IS_ERR(opp)) { + dev_err(csi2phy->dev, "Couldn't find ceiling for %lld Hz\n", + link_freq); + return PTR_ERR(opp); + } + + for (i =3D 0; i < csi2phy->pd_list->num_pds; i++) { + unsigned int perf =3D dev_pm_opp_get_required_pstate(opp, i); + + ret =3D dev_pm_genpd_set_performance_state(csi2phy->pd_list->pd_devs[i],= perf); + if (ret) { + dev_err(csi2phy->dev, "Couldn't set perf state %u\n", + perf); + dev_pm_opp_put(opp); + goto unset_pstate; + } + } + dev_pm_opp_put(opp); + + ret =3D dev_pm_opp_set_rate(dev, opp_rate); + if (ret) { + dev_err(csi2phy->dev, "dev_pm_opp_set_rate() fail\n"); + goto unset_opp_rate; + } + + timer_rate =3D clk_round_rate(csi2phy->timer_clk, link_freq / 4); + if (timer_rate <=3D 0) { + ret =3D -ENODEV; + goto unset_opp_rate; + } + + ret =3D clk_set_rate(csi2phy->timer_clk, timer_rate); + if (ret) + goto unset_opp_rate; + + csi2phy->timer_clk_rate =3D timer_rate; + + return 0; + +unset_opp_rate: + dev_pm_opp_set_rate(dev, 0); + +unset_pstate: + while (i--) + dev_pm_genpd_set_performance_state(csi2phy->pd_list->pd_devs[i], 0); + + return ret; +} + +static int phy_qcom_mipi_csi2_configure(struct phy *phy, + union phy_configure_opts *opts) +{ + struct mipi_csi2phy_device *csi2phy =3D phy_get_drvdata(phy); + struct phy_configure_opts_mipi_dphy *dphy_cfg =3D &opts->mipi_dphy; + struct mipi_csi2phy_stream_cfg *stream_cfg =3D &csi2phy->stream_cfg; + int ret; + + ret =3D phy_mipi_dphy_config_validate(dphy_cfg); + if (ret) + return ret; + + if (dphy_cfg->lanes < 1 || dphy_cfg->lanes > CSI2_MAX_DATA_LANES) + return -EINVAL; + + stream_cfg->link_freq =3D dphy_cfg->hs_clk_rate; + + return 0; +} + +static int phy_qcom_mipi_csi2_power_on(struct phy *phy) +{ + struct mipi_csi2phy_device *csi2phy =3D phy_get_drvdata(phy); + const struct mipi_csi2phy_hw_ops *ops =3D csi2phy->soc_cfg->ops; + struct device *dev =3D &phy->dev; + int i, ret; + + ret =3D regulator_bulk_enable(csi2phy->soc_cfg->num_supplies, + csi2phy->supplies); + if (ret) + return ret; + + ret =3D pm_runtime_resume_and_get(csi2phy->dev); + if (ret < 0) + goto disable_regulators; + + ret =3D phy_qcom_mipi_csi2_set_clock_rates(csi2phy, csi2phy->stream_cfg.l= ink_freq); + if (ret) + goto poweroff_phy; + + ret =3D clk_bulk_prepare_enable(csi2phy->soc_cfg->num_clk, + csi2phy->clks); + if (ret) { + dev_err(dev, "failed to enable clocks, %d\n", ret); + goto unset_rate; + } + + ops->reset(csi2phy); + + ops->hw_version_read(csi2phy); + + return ops->lanes_enable(csi2phy, &csi2phy->stream_cfg); + +unset_rate: + for (i =3D 0; i < csi2phy->pd_list->num_pds; i++) + dev_pm_genpd_set_performance_state(csi2phy->pd_list->pd_devs[i], 0); + + dev_pm_opp_set_rate(csi2phy->dev, 0); + +poweroff_phy: + pm_runtime_put_sync(csi2phy->dev); + +disable_regulators: + regulator_bulk_disable(csi2phy->soc_cfg->num_supplies, + csi2phy->supplies); + + return ret; +} + +static int phy_qcom_mipi_csi2_power_off(struct phy *phy) +{ + struct mipi_csi2phy_device *csi2phy =3D phy_get_drvdata(phy); + const struct mipi_csi2phy_hw_ops *ops =3D csi2phy->soc_cfg->ops; + int i; + + ops->lanes_disable(csi2phy, &csi2phy->stream_cfg); + + clk_bulk_disable_unprepare(csi2phy->soc_cfg->num_clk, + csi2phy->clks); + + for (i =3D 0; i < csi2phy->pd_list->num_pds; i++) + dev_pm_genpd_set_performance_state(csi2phy->pd_list->pd_devs[i], 0); + + dev_pm_opp_set_rate(csi2phy->dev, 0); + + pm_runtime_put_sync(csi2phy->dev); + + regulator_bulk_disable(csi2phy->soc_cfg->num_supplies, + csi2phy->supplies); + + return 0; +} + +static const struct phy_ops phy_qcom_mipi_csi2_ops =3D { + .configure =3D phy_qcom_mipi_csi2_configure, + .power_on =3D phy_qcom_mipi_csi2_power_on, + .power_off =3D phy_qcom_mipi_csi2_power_off, + .owner =3D THIS_MODULE, +}; + +static struct phy *qcom_csi2_phy_xlate(struct device *dev, + const struct of_phandle_args *args) +{ + struct mipi_csi2phy_device *csi2phy =3D dev_get_drvdata(dev); + + if (args->args[0] !=3D PHY_TYPE_DPHY) { + dev_err(csi2phy->dev, "mode %d -EOPNOTSUPP\n", args->args[0]); + return ERR_PTR(-EOPNOTSUPP); + } + + csi2phy->phy_mode =3D args->args[0]; + + return csi2phy->phy; +} + +static int phy_qcom_mipi_csi2_attach_pm_domains(struct mipi_csi2phy_device= *csi2phy) +{ + const struct dev_pm_domain_attach_data pd_data =3D { + .pd_names =3D csi2phy->soc_cfg->genpd_names, + .num_pd_names =3D csi2phy->soc_cfg->num_genpd_names, + }; + + return devm_pm_domain_attach_list(csi2phy->dev, &pd_data, &csi2phy->pd_li= st); +} + +static int phy_qcom_mipi_csi2_parse_routing(struct mipi_csi2phy_device *cs= i2phy) +{ + struct mipi_csi2phy_stream_cfg *stream_cfg =3D &csi2phy->stream_cfg; + u32 lane_polarities[CSI2_MAX_DATA_LANES + 1]; + u32 data_lanes[CSI2_MAX_DATA_LANES]; + struct device *dev =3D csi2phy->dev; + struct fwnode_handle *ep; + int num_polarities; + int num_data_lanes; + u32 clock_lane; + int i, ret; + + ep =3D fwnode_graph_get_endpoint_by_id(dev_fwnode(dev), 1, 0, + FWNODE_GRAPH_ENDPOINT_NEXT); + if (ep) { + fwnode_handle_put(ep); + dev_err(dev, "DPHY split mode is not supported\n"); + return -EOPNOTSUPP; + } + + ep =3D fwnode_graph_get_endpoint_by_id(dev_fwnode(dev), 0, 0, 0); + if (!ep) { + dev_err(dev, "Missing port@0\n"); + return -ENODEV; + } + + num_data_lanes =3D fwnode_property_count_u32(ep, "data-lanes"); + if (num_data_lanes < 1 || num_data_lanes > CSI2_MAX_DATA_LANES) { + ret =3D -EINVAL; + dev_err(dev, "Invalid data-lanes count: %d\n", num_data_lanes); + goto out_put; + } + stream_cfg->num_data_lanes =3D num_data_lanes; + + ret =3D fwnode_property_read_u32_array(ep, "data-lanes", data_lanes, + stream_cfg->num_data_lanes); + if (ret) { + dev_err(dev, "Failed to read data-lanes: %d\n", ret); + goto out_put; + } + + ret =3D fwnode_property_read_u32(ep, "clock-lanes", &clock_lane); + if (ret) { + clock_lane =3D CSI2_DEFAULT_CLK_LN; + dev_info(dev, "Using default clock-lane %d\n", + CSI2_DEFAULT_CLK_LN); + } + + /* lane-polarities: optional, up to num_data_lanes + 1 entries */ + memset(lane_polarities, 0x00, sizeof(lane_polarities)); + num_polarities =3D fwnode_property_count_u32(ep, "lane-polarities"); + if (num_polarities > 0) { + if (num_polarities !=3D stream_cfg->num_data_lanes + 1) { + ret =3D -EINVAL; + dev_err(dev, "clock+data-lane %d/polarities %d mismatch\n", + stream_cfg->num_data_lanes + 1, num_polarities); + goto out_put; + } + + ret =3D fwnode_property_read_u32_array(ep, "lane-polarities", lane_polar= ities, + num_polarities); + if (ret) { + dev_err(dev, "Failed to read lane-polarities: %d\n", ret); + goto out_put; + } + } + + for (i =3D 0; i < csi2phy->stream_cfg.num_data_lanes; i++) { + csi2phy->stream_cfg.lane_cfg.data[i].pos =3D data_lanes[i]; + csi2phy->stream_cfg.lane_cfg.data[i].pol =3D lane_polarities[i + 1]; + } + csi2phy->stream_cfg.lane_cfg.clk.pos =3D clock_lane; + csi2phy->stream_cfg.lane_cfg.clk.pol =3D lane_polarities[0]; + + ret =3D 0; + +out_put: + fwnode_handle_put(ep); + + return ret; +} + +static int phy_qcom_mipi_csi2_probe(struct platform_device *pdev) +{ + unsigned int i, num_clk, num_supplies; + struct mipi_csi2phy_device *csi2phy; + struct phy_provider *phy_provider; + struct device *dev =3D &pdev->dev; + struct phy *generic_phy; + int ret; + + csi2phy =3D devm_kzalloc(dev, sizeof(*csi2phy), GFP_KERNEL); + if (!csi2phy) + return -ENOMEM; + + csi2phy->dev =3D dev; + dev_set_drvdata(dev, csi2phy); + + csi2phy->soc_cfg =3D device_get_match_data(&pdev->dev); + + if (!csi2phy->soc_cfg) + return -EINVAL; + + num_clk =3D csi2phy->soc_cfg->num_clk; + csi2phy->clks =3D devm_kzalloc(dev, sizeof(*csi2phy->clks) * num_clk, GFP= _KERNEL); + if (!csi2phy->clks) + return -ENOMEM; + + ret =3D phy_qcom_mipi_csi2_parse_routing(csi2phy); + if (ret) + return ret; + + ret =3D phy_qcom_mipi_csi2_attach_pm_domains(csi2phy); + if (ret < 0) + return dev_err_probe(dev, ret, "Failed to attach power-domain list\n"); + + devm_pm_runtime_enable(dev); + + for (i =3D 0; i < num_clk; i++) + csi2phy->clks[i].id =3D csi2phy->soc_cfg->clk_names[i]; + + ret =3D devm_clk_bulk_get(dev, num_clk, csi2phy->clks); + if (ret) + return dev_err_probe(dev, ret, "Failed to get clocks\n"); + + csi2phy->timer_clk =3D devm_clk_get(dev, csi2phy->soc_cfg->timer_clk); + if (IS_ERR(csi2phy->timer_clk)) { + return dev_err_probe(dev, PTR_ERR(csi2phy->timer_clk), + "Failed to get timer clock\n"); + } + + ret =3D devm_pm_opp_set_clkname(dev, csi2phy->soc_cfg->opp_clk); + if (ret) + return dev_err_probe(dev, ret, "Failed to set opp clkname\n"); + + ret =3D devm_pm_opp_of_add_table(dev); + if (ret && ret !=3D -ENODEV) + return dev_err_probe(dev, ret, "invalid OPP table in device tree\n"); + + num_supplies =3D csi2phy->soc_cfg->num_supplies; + csi2phy->supplies =3D devm_kzalloc(dev, sizeof(*csi2phy->supplies) * num_= supplies, + GFP_KERNEL); + if (!csi2phy->supplies) + return -ENOMEM; + + for (i =3D 0; i < num_supplies; i++) + csi2phy->supplies[i].supply =3D csi2phy->soc_cfg->supply_names[i]; + + ret =3D devm_regulator_bulk_get(dev, num_supplies, csi2phy->supplies); + if (ret) + return dev_err_probe(dev, ret, + "failed to get regulator supplies\n"); + + csi2phy->base =3D devm_platform_ioremap_resource(pdev, 0); + if (IS_ERR(csi2phy->base)) + return PTR_ERR(csi2phy->base); + + generic_phy =3D devm_phy_create(dev, NULL, &phy_qcom_mipi_csi2_ops); + if (IS_ERR(generic_phy)) { + ret =3D PTR_ERR(generic_phy); + return dev_err_probe(dev, ret, "failed to create phy\n"); + } + csi2phy->phy =3D generic_phy; + + phy_set_drvdata(generic_phy, csi2phy); + + phy_provider =3D devm_of_phy_provider_register(dev, qcom_csi2_phy_xlate); + if (!IS_ERR(phy_provider)) + dev_dbg(dev, "Registered MIPI CSI2 PHY device\n"); + + return PTR_ERR_OR_ZERO(phy_provider); +} + +static const struct of_device_id phy_qcom_mipi_csi2_of_match_table[] =3D { + { .compatible =3D "qcom,x1e80100-csi2-phy", .data =3D &mipi_csi2_dphy_4nm= _x1e }, + { } +}; +MODULE_DEVICE_TABLE(of, phy_qcom_mipi_csi2_of_match_table); + +static struct platform_driver phy_qcom_mipi_csi2_driver =3D { + .probe =3D phy_qcom_mipi_csi2_probe, + .driver =3D { + .name =3D "qcom-mipi-csi2-phy", + .of_match_table =3D phy_qcom_mipi_csi2_of_match_table, + }, +}; + +module_platform_driver(phy_qcom_mipi_csi2_driver); + +MODULE_DESCRIPTION("Qualcomm MIPI CSI2 PHY driver"); +MODULE_AUTHOR("Bryan O'Donoghue "); +MODULE_LICENSE("GPL"); diff --git a/drivers/phy/qualcomm/phy-qcom-mipi-csi2.h b/drivers/phy/qualco= mm/phy-qcom-mipi-csi2.h new file mode 100644 index 0000000000000..e7c1ce00916e3 --- /dev/null +++ b/drivers/phy/qualcomm/phy-qcom-mipi-csi2.h @@ -0,0 +1,95 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * + * Qualcomm MIPI CSI2 CPHY/DPHY driver + * + * Copyright (C) 2025 Linaro Ltd. + */ +#ifndef __PHY_QCOM_MIPI_CSI2_H__ +#define __PHY_QCOM_MIPI_CSI2_H__ + +#include + +#define CSI2_MAX_DATA_LANES 4 +#define CSI2_DEFAULT_CLK_LN 7 + +struct mipi_csi2phy_lane { + u8 pos; + u8 pol; +}; + +struct mipi_csi2phy_lanes_cfg { + struct mipi_csi2phy_lane data[CSI2_MAX_DATA_LANES]; + struct mipi_csi2phy_lane clk; +}; + +struct mipi_csi2phy_stream_cfg { + s64 link_freq; + u8 num_data_lanes; + struct mipi_csi2phy_lanes_cfg lane_cfg; +}; + +struct mipi_csi2phy_device; + +struct mipi_csi2phy_hw_ops { + void (*hw_version_read)(struct mipi_csi2phy_device *csi2phy_dev); + void (*reset)(struct mipi_csi2phy_device *csi2phy_dev); + int (*lanes_enable)(struct mipi_csi2phy_device *csi2phy_dev, + struct mipi_csi2phy_stream_cfg *cfg); + void (*lanes_disable)(struct mipi_csi2phy_device *csi2phy_dev, + struct mipi_csi2phy_stream_cfg *cfg); +}; + +struct mipi_csi2phy_lane_regs { + const s32 reg_addr; + const s32 reg_data; + const u32 delay_us; + const u32 param_type; +}; + +struct mipi_csi2phy_device_regs { + const struct mipi_csi2phy_lane_regs *init_seq; + const int lane_array_size; + const u32 common_regs_offset; +}; + +struct mipi_csi2phy_soc_cfg { + const struct mipi_csi2phy_hw_ops *ops; + const struct mipi_csi2phy_device_regs reg_info; + + const char ** const supply_names; + const unsigned int num_supplies; + + const char ** const clk_names; + const unsigned int num_clk; + + const char * const opp_clk; + const char * const timer_clk; + + const char ** const genpd_names; + const unsigned int num_genpd_names; +}; + +struct mipi_csi2phy_device { + struct device *dev; + u8 phy_mode; + + struct phy *phy; + void __iomem *base; + + struct clk_bulk_data *clks; + struct clk *timer_clk; + u32 timer_clk_rate; + + struct regulator_bulk_data *supplies; + struct dev_pm_domain_list *pd_list; + + const struct mipi_csi2phy_soc_cfg *soc_cfg; + struct mipi_csi2phy_stream_cfg stream_cfg; + + u32 hw_version; +}; + +extern const struct mipi_csi2phy_soc_cfg mipi_csi2_dphy_4nm_x1e; + +#endif /* __PHY_QCOM_MIPI_CSI2_H__ */ --=20 2.54.0