From nobody Sun Nov 24 13:38:43 2024 Received: from mx08-00178001.pphosted.com (mx08-00178001.pphosted.com [91.207.212.93]) (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 6DFCA1ABEBA; Mon, 18 Nov 2024 13:40:17 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.207.212.93 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937220; cv=none; b=jFXYiHQVaTB2VKd5pFvb4HsNEHUDVh+uXrnvekqttsggiz/YqWzXY08/k33xL5j1KKcnetEf/hhUnNsbhpvAPWOx7G7TBpqfF5WwJadnHVeCrnYSGGh4BzNawEmry0Sa7C12H87alETI4vdMBhEpZUMaRT1AY1HWhubpfeFXPy8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937220; c=relaxed/simple; bh=DV8WgtfiJ3jSHJlxMtKq/+R3q5ybHbBcGIdrmJZDwp8=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=rtgp/qfqB87yufUtu9IBUy7ranaixkspyLoosmeqkbRGskeJRWxaJRavOduGtmgxxdRnZHQQvEEPL1sL93eDWYGwPppPrjEE4nAwVtsBNFcezrX/1sGs21TRf6PnUNR8M9vIfl5TpEwkYmHmHEswNcJzGEsrntuLpbGhRv4nrvw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=hHX18/pz; arc=none smtp.client-ip=91.207.212.93 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="hHX18/pz" Received: from pps.filterd (m0369457.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AIBMjHi001561; Mon, 18 Nov 2024 14:39:52 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= Rc3oBPTl0l/qKEzDpFWg02aAFeNOrXK/95DogEMtNjc=; b=hHX18/pzqzEtNDLZ OioOCVtEpHzYFSL+MCdUINOfBfWaIvaffrCyu4+0lnZ5HGLAlkPPtRUbTg3XCmGv J7IQc8zUqM1gCBZ+CCM51KywpVFffC28lvhDP4QM0jM42wD3XPX6pHTJs22xc6nj t+M1zWHfzrZ4nk+lwp8EXKtgzkAmmH+95Xcwdx81yQBlwP7dYnH8i7AZow9SXqxI fhqg/75pY+WsQrFxQ536aoyGNJjQc0VRy9M7r2phOUuHYv3pVAQxutf5r4zzXJN2 QrOmuZpjeBGPPVPyGEfT/XkEoGxiM0R7yc0rIXQy0DT/jxdk5KEpcnzaHoag21pd YAURpA== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42y77n504q-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:52 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id E334C4005A; Mon, 18 Nov 2024 14:38:32 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id BDF352721D0; Mon, 18 Nov 2024 14:35:26 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:26 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:24 +0100 Subject: [PATCH v3 01/15] media: stm32: dcmipp: correct dma_set_mask_and_coherent mask value 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: <20241118-csi_dcmipp_mp25-v3-1-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat , X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 Correct the call to dma_set_mask_and_coherent which should be set to DMA_BIT_MASK(32). Fixes: 28e0f3772296 ("media: stm32-dcmipp: STM32 DCMIPP camera interface dr= iver") Cc: stable@vger.kernel.org Signed-off-by: Alain Volmat --- drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c = b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c index 9f768f011fa25a0981cd0d1d3f114b02e58223d4..0f6918f4db383f4e07620302181= 01f759f375e95 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c @@ -893,7 +893,7 @@ struct dcmipp_ent_device *dcmipp_bytecap_ent_init(struc= t device *dev, q->dev =3D dev; =20 /* DCMIPP requires 16 bytes aligned buffers */ - ret =3D dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32) & ~0x0f); + ret =3D dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32)); if (ret) { dev_err(dev, "Failed to set DMA mask\n"); goto err_mutex_destroy; --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx07-00178001.pphosted.com (mx08-00178001.pphosted.com [91.207.212.93]) (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 03F8E1991A5; Mon, 18 Nov 2024 13:40:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.207.212.93 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937218; cv=none; b=OLC08yrLxuJuqacJPs4lSlSkB40VIhHgP9hUo+zYgAfzfeFIkE8PWsBAhj6lzKECnm+t7GqajuAe8gw3kT2nMgJpSal3d+tiYKhIGUyNflRgToG6YJ9kVTKSNlLvAzCszx5zBrSuNY5B2pJwCh+mRDy6cUC+06cALJSCjtIukZQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937218; c=relaxed/simple; bh=inE9kFVLCmvSAeXHoc+I1KKHTYYTqpPm0WjcTjjoSIY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=peBoQEBEYLWc17Vv9R7iUNNEOpWUPG8MBKE0W325oSKWPimnRthbQZXjvYl4UV4j/3h9X9XwrpG1tQ85Z5doOx5o2gnTaVFwV607yLgrfGOuDfrJN66K5u7iYtqtq9G0bg5okw7AGHNrArgoewPvd2XvQrV4diQDBfblDt0T/Do= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=OsWDIh0W; arc=none smtp.client-ip=91.207.212.93 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="OsWDIh0W" Received: from pps.filterd (m0046661.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AIBbYPd032344; Mon, 18 Nov 2024 14:39:52 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= QEJZk2vCEJhGT0eZcp9hmNAE/SV2uyT+MnBUZGRJClc=; b=OsWDIh0W/bzuo23+ VvDUKMHc1ANgZ/u2jrvRZx7pTkbCMdOuoVWvZFzFKKlXZOKDNbXo1BAA388vIlv4 Xm2GefEvnUo1xIEnUB3aJwO3wWn15w/C6ZbM2V7dE/7uPgc9PJgl9ICNVbrGgT64 HUfbdzGF0RpBQTgnWFxF44eb/pwQRIZ99bBf1WNuuaWZkFEuGpf8juzMVBifDd8s xEnsSluRmT78CBwAG0iEtkL2hvmsJ3UT7joJAErUsjYqUu58Ft4wAzpRDRelHTTH ixSe9SFSjbnVebgPUkHD7DGA2dayLXkc4bDj5yAa80gW9DL161b3mEIyXoHd9QLq ybz/iw== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42xkqeq7s1-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:52 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id 01F1D4005C; Mon, 18 Nov 2024 14:38:32 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 614BC2721D3; Mon, 18 Nov 2024 14:35:27 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:27 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:25 +0100 Subject: [PATCH v3 02/15] dt-bindings: media: add description of stm32 csi 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: <20241118-csi_dcmipp_mp25-v3-2-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat , Krzysztof Kozlowski X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 Add the stm32 csi controller description. Reviewed-by: Krzysztof Kozlowski Signed-off-by: Alain Volmat --- v2: - rename into st,stm32mp25-csi.yaml to match compatible - correct port / data-lanes (remove useless lines & use data-lanes 1 and 2 instead of 0 and 1) - correct commit log --- .../bindings/media/st,stm32mp25-csi.yaml | 125 +++++++++++++++++= ++++ 1 file changed, 125 insertions(+) diff --git a/Documentation/devicetree/bindings/media/st,stm32mp25-csi.yaml = b/Documentation/devicetree/bindings/media/st,stm32mp25-csi.yaml new file mode 100644 index 0000000000000000000000000000000000000000..33bedfe419244e12dbb98b35882= 1bbc39ea6facf --- /dev/null +++ b/Documentation/devicetree/bindings/media/st,stm32mp25-csi.yaml @@ -0,0 +1,125 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/media/st,stm32mp25-csi.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: STMicroelectronics STM32 CSI controller + +description: + The STM32 CSI controller allows connecting a CSI based + camera to the DCMIPP camera pipeline. + +maintainers: + - Alain Volmat + +properties: + compatible: + enum: + - st,stm32mp25-csi + + reg: + maxItems: 1 + + interrupts: + maxItems: 1 + + clocks: + maxItems: 3 + + clock-names: + items: + - const: pclk + - const: txesc + - const: csi2phy + + resets: + maxItems: 1 + + vdd-supply: + description: Digital core power supply (0.91V) + + vdda18-supply: + description: System analog power supply (1.8V) + + access-controllers: + minItems: 1 + maxItems: 2 + + ports: + $ref: /schemas/graph.yaml#/properties/ports + + properties: + port@0: + $ref: /schemas/graph.yaml#/$defs/port-base + unevaluatedProperties: false + description: + Input port node + + properties: + endpoint: + $ref: video-interfaces.yaml# + unevaluatedProperties: false + + properties: + data-lanes: + minItems: 1 + items: + - const: 1 + - const: 2 + + required: + - data-lanes + + port@1: + $ref: /schemas/graph.yaml#/properties/port + description: + Output port node + +required: + - compatible + - reg + - interrupts + - clocks + - clock-names + - resets + - ports + +additionalProperties: false + +examples: + - | + #include + #include + #include + #include + csi@48020000 { + compatible =3D "st,stm32mp25-csi"; + reg =3D <0x48020000 0x2000>; + interrupts =3D ; + resets =3D <&rcc CSI_R>; + clocks =3D <&rcc CK_KER_CSI>, <&rcc CK_KER_CSITXESC>, <&rcc CK_KER= _CSIPHY>; + clock-names =3D "pclk", "txesc", "csi2phy"; + + ports { + #address-cells =3D <1>; + #size-cells =3D <0>; + port@0 { + reg =3D <0>; + endpoint { + remote-endpoint =3D <&imx335_ep>; + data-lanes =3D <1 2>; + bus-type =3D ; + }; + }; + + port@1 { + reg =3D <1>; + endpoint { + remote-endpoint =3D <&dcmipp_0>; + }; + }; + }; + }; + +... --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx07-00178001.pphosted.com (mx08-00178001.pphosted.com [91.207.212.93]) (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 6D66E1A0B00; Mon, 18 Nov 2024 13:40:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.207.212.93 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937218; cv=none; b=rk1TzWkpIeyjOvxUsiN9YSh1bmt8ttpS3+Ve61nQZ0gG4YUryBgAafuyG7KVzmy3Bf+CoCXNLYmhn3SoPSeBgOgoVYCB0+CwQKibvxhdvhQSUir1lDoFcD7I5t0J8QGEEZcNxIueHW2gHKy0Eq/I9WFxvx+BLpuLfo/PtpIT544= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937218; c=relaxed/simple; bh=M9+H+w4T/7coYuxfgcAWNiSywBdIJzCE/H2pgIKvwMs=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=Af5z+Io3GZeMBBilqB/kTP1mUp+RuE9bxjbS1QmMCw+ttBIJVI7cS5IBh+JgLKpNmf2+nwx8i+xevfMaq73FpzKdTiXJf22u2cwYvwjQlNnDih+fGaU3n8jpHwUvpXNj8I6auX6bysYRnB8/CjPfIUuMGn2cosOnHPkNsKQj+Bs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=b1DdemGn; arc=none smtp.client-ip=91.207.212.93 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="b1DdemGn" Received: from pps.filterd (m0046661.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AIDMhXB009376; Mon, 18 Nov 2024 14:39:42 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= fgK8A10VhFJB6HF20SKO/jpS1VTivlkq4Hjvs1bvrl0=; b=b1DdemGnchMM6e+R 0POd01ZtjNOJ2zJZD5TVl1IaVpxpd1ichVzpx3b5a8T4vY+yPwZbqIlWTy+djHmN zppPkh3ZXyd1VhCNy7dX36P4lthH3Na+27piL07DszqqWjSXnULhL13pzdejeL1C RISJ19e3V+gNb1tS+ZuwKDD+MIF74N9rMI0S7jqUHtJ1r295Jy4BNq6pXXnMwqoV HcHwg70KJnM8IgoFAomFgzJI6sWEqDhw+M8xFRTRJvJSdGCzoCa8ebtnc4jMfA3Y YcSPf2i1k8XfKeJ6/flLO2HegF/s/XR9/T5H9m6akXFbEt3oVf75ZWawjvSukiM9 mxz7iA== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42xkqeq7rk-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:42 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id 6E37D40052; Mon, 18 Nov 2024 14:38:29 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 0FED22721E0; Mon, 18 Nov 2024 14:35:28 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:27 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:26 +0100 Subject: [PATCH v3 03/15] media: stm32: csi: addition of the STM32 CSI 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: <20241118-csi_dcmipp_mp25-v3-3-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 The STM32 CSI controller is tightly coupled with the DCMIPP and act as an input stage to receive data coming from the sensor and transferring them into the DCMIPP. Signed-off-by: Alain Volmat --- v3: get reset controller within probe function and remove it from the driver structure use devm_clk_bulk apis rather 3 separate clks v2: correct data-lanes handling, using values 1 & 2 update yaml filename in MAINTAINERS --- MAINTAINERS | 8 + drivers/media/platform/st/stm32/Kconfig | 14 + drivers/media/platform/st/stm32/Makefile | 1 + drivers/media/platform/st/stm32/stm32-csi.c | 1137 +++++++++++++++++++++++= ++++ 4 files changed, 1160 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index c27f3190737f8b85779bde5489639c8b899f4fd8..9c54863d28bb605f8a5f96c9edd= 38af6a538d423 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -14376,6 +14376,14 @@ W: https://linuxtv.org T: git git://linuxtv.org/media_tree.git F: drivers/media/dvb-frontends/stv6111* =20 +MEDIA DRIVERS FOR STM32 - CSI +M: Alain Volmat +L: linux-media@vger.kernel.org +S: Supported +T: git git://linuxtv.org/media_tree.git +F: Documentation/devicetree/bindings/media/st,stm32mp25-csi.yaml +F: drivers/media/platform/stm32/stm32-csi.c + MEDIA DRIVERS FOR STM32 - DCMI / DCMIPP M: Hugues Fruchet M: Alain Volmat diff --git a/drivers/media/platform/st/stm32/Kconfig b/drivers/media/platfo= rm/st/stm32/Kconfig index 9df9a2a177280c2e473c1312fc257154817bc2bc..f12e67bcc9bc494120ed70552e4= 8da45fb064b6b 100644 --- a/drivers/media/platform/st/stm32/Kconfig +++ b/drivers/media/platform/st/stm32/Kconfig @@ -1,6 +1,20 @@ # SPDX-License-Identifier: GPL-2.0-only =20 # V4L drivers +config VIDEO_STM32_CSI + tristate "STM32 Camera Serial Interface (CSI) support" + depends on V4L_PLATFORM_DRIVERS + depends on VIDEO_DEV && OF + depends on ARCH_STM32 || COMPILE_TEST + select MEDIA_CONTROLLER + select V4L2_FWNODE + help + This module makes the STM32 Camera Serial Interface (CSI) + available as a v4l2 device. + + To compile this driver as a module, choose M here: the module + will be called stm32-csi. + config VIDEO_STM32_DCMI tristate "STM32 Digital Camera Memory Interface (DCMI) support" depends on V4L_PLATFORM_DRIVERS diff --git a/drivers/media/platform/st/stm32/Makefile b/drivers/media/platf= orm/st/stm32/Makefile index 7ed8297b9b1913b04eb07015f847491aa80ba529..9ae57897f0307fd6d1db3d06dce= 832b0f8613b04 100644 --- a/drivers/media/platform/st/stm32/Makefile +++ b/drivers/media/platform/st/stm32/Makefile @@ -1,4 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-only +obj-$(CONFIG_VIDEO_STM32_CSI) +=3D stm32-csi.o obj-$(CONFIG_VIDEO_STM32_DCMI) +=3D stm32-dcmi.o obj-$(CONFIG_VIDEO_STM32_DCMIPP) +=3D stm32-dcmipp/ stm32-dma2d-objs :=3D dma2d/dma2d.o dma2d/dma2d-hw.o diff --git a/drivers/media/platform/st/stm32/stm32-csi.c b/drivers/media/pl= atform/st/stm32/stm32-csi.c new file mode 100644 index 0000000000000000000000000000000000000000..48941aae8c9b8d00bd6c3486b8e= ee15e13e9f3b3 --- /dev/null +++ b/drivers/media/platform/st/stm32/stm32-csi.c @@ -0,0 +1,1137 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Driver for STM32 Camera Serial Interface + * + * Copyright (C) STMicroelectronics SA 2024 + * Author: Alain Volmat + * for STMicroelectronics. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#define STM32_CSI_CR 0x0000 +#define STM32_CSI_CR_CSIEN BIT(0) +#define STM32_CSI_CR_VCXSTART(x) BIT(2 + ((x) * 4)) +#define STM32_CSI_CR_VCXSTOP(x) BIT(3 + ((x) * 4)) +#define STM32_CSI_PCR 0x0004 +#define STM32_CSI_PCR_DL1EN BIT(3) +#define STM32_CSI_PCR_DL0EN BIT(2) +#define STM32_CSI_PCR_CLEN BIT(1) +#define STM32_CSI_PCR_PWRDOWN BIT(0) +#define STM32_CSI_VCXCFGR1(x) ((((x) + 1) * 0x0010) + 0x0) +#define STM32_CSI_VCXCFGR1_ALLDT BIT(0) +#define STM32_CSI_VCXCFGR1_DT0EN BIT(1) +#define STM32_CSI_VCXCFGR1_DT1EN BIT(2) +#define STM32_CSI_VCXCFGR1_CDTFT_SHIFT 8 +#define STM32_CSI_VCXCFGR1_DT0_SHIFT 16 +#define STM32_CSI_VCXCFGR1_DT0FT_SHIFT 24 +#define STM32_CSI_VCXCFGR2(x) ((((x) + 1) * 0x0010) + 0x4) +#define STM32_CSI_VCXCFGR2_DT1_SHIFT 0 +#define STM32_CSI_VCXCFGR2_DT1FT_SHIFT 8 +#define STM32_CSI_INPUT_BPP8 2 +#define STM32_CSI_INPUT_BPP10 3 +#define STM32_CSI_INPUT_BPP12 4 +#define STM32_CSI_INPUT_BPP14 5 +#define STM32_CSI_LMCFGR 0x0070 +#define STM32_CSI_LMCFGR_LANENB_SHIFT 8 +#define STM32_CSI_LMCFGR_DLMAP_SHIFT 16 +#define STM32_CSI_IER0 0x0080 +#define STM32_CSI_IER1 0x0084 +#define STM32_CSI_SR0 0x0090 +#define STM32_CSI_SR0_SYNCERRF BIT(30) +#define STM32_CSI_SR0_SPKTERRF BIT(28) +#define STM32_CSI_SR0_IDERRF BIT(27) +#define STM32_CSI_SR0_CECCERRF BIT(26) +#define STM32_CSI_SR0_ECCERRF BIT(25) +#define STM32_CSI_SR0_CRCERRF BIT(24) +#define STM32_CSI_SR0_CCFIFOFF BIT(21) +#define STM32_CSI_SR0_VCXSTATEF(x) BIT(17 + (x)) +#define STM32_CSI_SR1 0x0094 +#define STM32_CSI_SR1_ECTRLDL1F BIT(12) +#define STM32_CSI_SR1_ESYNCESCDL1F BIT(11) +#define STM32_CSI_SR1_EESCDL1F BIT(10) +#define STM32_CSI_SR1_ESOTSYNCDL1F BIT(9) +#define STM32_CSI_SR1_ESOTDL1F BIT(8) +#define STM32_CSI_SR1_ECTRLDL0F BIT(4) +#define STM32_CSI_SR1_ESYNCESCDL0F BIT(3) +#define STM32_CSI_SR1_EESCDL0F BIT(2) +#define STM32_CSI_SR1_ESOTSYNCDL0F BIT(1) +#define STM32_CSI_SR1_ESOTDL0F BIT(0) +#define STM32_CSI_FCR0 0x0100 +#define STM32_CSI_FCR1 0x0104 +#define STM32_CSI_SPDFR 0x0110 +#define STM32_CSI_DT_MASK 0x3f +#define STM32_CSI_VC_MASK 0x03 +#define STM32_CSI_ERR1 0x0114 +#define STM32_CSI_ERR1_IDVCERR_SHIFT 22 +#define STM32_CSI_ERR1_IDDTERR_SHIFT 16 +#define STM32_CSI_ERR1_CECCVCERR_SHIFT 14 +#define STM32_CSI_ERR1_CECCDTERR_SHIFT 8 +#define STM32_CSI_ERR1_CRCVCERR_SHIFT 6 +#define STM32_CSI_ERR1_CRCDTERR_SHIFT 0 +#define STM32_CSI_ERR2 0x0118 +#define STM32_CSI_ERR2_SYNCVCERR_SHIFT 18 +#define STM32_CSI_ERR2_SPKTVCERR_SHIFT 6 +#define STM32_CSI_ERR2_SPKTDTERR_SHIFT 0 +#define STM32_CSI_PRCR 0x1000 +#define STM32_CSI_PRCR_PEN BIT(1) +#define STM32_CSI_PMCR 0x1004 +#define STM32_CSI_PFCR 0x1008 +#define STM32_CSI_PFCR_CCFR_MASK GENMASK(5, 0) +#define STM32_CSI_PFCR_CCFR_SHIFT 0 +#define STM32_CSI_PFCR_HSFR_MASK GENMASK(14, 8) +#define STM32_CSI_PFCR_HSFR_SHIFT 8 +#define STM32_CSI_PFCR_DLD BIT(16) +#define STM32_CSI_PTCR0 0x1010 +#define STM32_CSI_PTCR0_TCKEN BIT(0) +#define STM32_CSI_PTCR1 0x1014 +#define STM32_CSI_PTCR1_TWM BIT(16) +#define STM32_CSI_PTCR1_TDI_MASK GENMASK(7, 0) +#define STM32_CSI_PTCR1_TDI_SHIFT 0 +#define STM32_CSI_PTSR 0x1018 + +#define STM32_CSI_LANES_MAX 2 + +#define STM32_CSI_SR0_ERRORS (STM32_CSI_SR0_SYNCERRF | STM32_CSI_SR0_SPKTE= RRF |\ + STM32_CSI_SR0_IDERRF | STM32_CSI_SR0_CECCERRF |\ + STM32_CSI_SR0_ECCERRF | STM32_CSI_SR0_CRCERRF |\ + STM32_CSI_SR0_CCFIFOFF) +#define STM32_CSI_SR1_DL0_ERRORS (STM32_CSI_SR1_ECTRLDL0F | STM32_CSI_SR1_= ESYNCESCDL0F |\ + STM32_CSI_SR1_EESCDL0F | STM32_CSI_SR1_ESOTSYNCDL0F |\ + STM32_CSI_SR1_ESOTDL0F) +#define STM32_CSI_SR1_DL1_ERRORS (STM32_CSI_SR1_ECTRLDL1F | STM32_CSI_SR1_= ESYNCESCDL1F |\ + STM32_CSI_SR1_EESCDL1F | STM32_CSI_SR1_ESOTSYNCDL1F |\ + STM32_CSI_SR1_ESOTDL1F) +#define STM32_CSI_SR1_ERRORS (STM32_CSI_SR1_DL0_ERRORS | STM32_CSI_SR1_DL1= _ERRORS) + +enum stm32_csi_pads { + STM32_CSI_PAD_SINK, + STM32_CSI_PAD_SOURCE, + STM32_CSI_PAD_MAX, +}; + +struct stm32_csi_event { + u32 mask; + const char * const name; +}; + +static const struct stm32_csi_event stm32_csi_events_sr0[] =3D { + {STM32_CSI_SR0_SYNCERRF, "Synchronization error"}, + {STM32_CSI_SR0_SPKTERRF, "Short packet error"}, + {STM32_CSI_SR0_IDERRF, "Data type ID error"}, + {STM32_CSI_SR0_CECCERRF, "Corrected ECC error"}, + {STM32_CSI_SR0_ECCERRF, "ECC error"}, + {STM32_CSI_SR0_CRCERRF, "CRC error"}, + {STM32_CSI_SR0_CCFIFOFF, "Clk changer FIFO full error"}, +}; + +#define STM32_CSI_NUM_SR0_EVENTS ARRAY_SIZE(stm32_csi_events_sr0) + +static const struct stm32_csi_event stm32_csi_events_sr1[] =3D { + {STM32_CSI_SR1_ECTRLDL1F, "L1: D-PHY control error"}, + {STM32_CSI_SR1_ESYNCESCDL1F, + "L1: D-PHY low power data transmission synchro error"}, + {STM32_CSI_SR1_EESCDL1F, "L1: D-PHY escape entry error"}, + {STM32_CSI_SR1_ESOTSYNCDL1F, + "L1: Start of transmission synchro error"}, + {STM32_CSI_SR1_ESOTDL1F, "L1: Start of transmission error"}, + {STM32_CSI_SR1_ECTRLDL0F, "L0: D-PHY control error"}, + {STM32_CSI_SR1_ESYNCESCDL0F, + "L0: D-PHY low power data transmission synchro error"}, + {STM32_CSI_SR1_EESCDL0F, "L0: D-PHY escape entry error"}, + {STM32_CSI_SR1_ESOTSYNCDL0F, + "L0: Start of transmission synchro error"}, + {STM32_CSI_SR1_ESOTDL0F, "L0: Start of transmission error"}, +}; + +#define STM32_CSI_NUM_SR1_EVENTS ARRAY_SIZE(stm32_csi_events_sr1) + +enum stm32_csi_clk { + STM32_CSI_CLK_PCLK, + STM32_CSI_CLK_TXESC, + STM32_CSI_CLK_CSI2PHY, + STM32_CSI_CLK_NB, +}; + +static const char * const stm32_csi_clks_id[] =3D { + "pclk", + "txesc", + "csi2phy", +}; + +struct stm32_csi_dev { + struct device *dev; + + void __iomem *base; + + struct clk_bulk_data clks[STM32_CSI_CLK_NB]; + struct regulator_bulk_data supplies[2]; + + u8 lanes[STM32_CSI_LANES_MAX]; + u8 num_lanes; + + /* + * spinlock slock is used to protect to srX_counters tables being + * accessed from log_status and interrupt context + */ + spinlock_t slock; + + u32 sr0_counters[STM32_CSI_NUM_SR0_EVENTS]; + u32 sr1_counters[STM32_CSI_NUM_SR1_EVENTS]; + + struct v4l2_subdev sd; + struct v4l2_async_notifier notifier; + struct media_pad pads[STM32_CSI_PAD_MAX]; + + /* Remote source */ + struct v4l2_subdev *s_subdev; + u32 s_subdev_pad_nb; +}; + +struct stm32_csi_fmts { + u32 code; + u32 datatype; + u32 input_fmt; + u8 bpp; +}; + +#define FMT_MBUS_DT_DTFMT_BPP(mbus, dt, input, byteperpixel) \ + { \ + .code =3D MEDIA_BUS_FMT_##mbus, \ + .datatype =3D MIPI_CSI2_DT_##dt, \ + .input_fmt =3D STM32_CSI_INPUT_##input, \ + .bpp =3D byteperpixel, \ + } +static const struct stm32_csi_fmts stm32_csi_formats[] =3D { + /* YUV 422 8 bit */ + FMT_MBUS_DT_DTFMT_BPP(UYVY8_1X16, YUV422_8B, BPP8, 8), + FMT_MBUS_DT_DTFMT_BPP(YUYV8_1X16, YUV422_8B, BPP8, 8), + FMT_MBUS_DT_DTFMT_BPP(YVYU8_1X16, YUV422_8B, BPP8, 8), + FMT_MBUS_DT_DTFMT_BPP(VYUY8_1X16, YUV422_8B, BPP8, 8), + + /* Raw Bayer */ + /* 8 bit */ + FMT_MBUS_DT_DTFMT_BPP(SBGGR8_1X8, RAW8, BPP8, 8), + FMT_MBUS_DT_DTFMT_BPP(SGBRG8_1X8, RAW8, BPP8, 8), + FMT_MBUS_DT_DTFMT_BPP(SGRBG8_1X8, RAW8, BPP8, 8), + FMT_MBUS_DT_DTFMT_BPP(SRGGB8_1X8, RAW8, BPP8, 8), + /* 10 bit */ + FMT_MBUS_DT_DTFMT_BPP(SRGGB10_1X10, RAW10, BPP10, 10), + FMT_MBUS_DT_DTFMT_BPP(SGBRG10_1X10, RAW10, BPP10, 10), + FMT_MBUS_DT_DTFMT_BPP(SGRBG10_1X10, RAW10, BPP10, 10), + FMT_MBUS_DT_DTFMT_BPP(SRGGB10_1X10, RAW10, BPP10, 10), + /* 12 bit */ + FMT_MBUS_DT_DTFMT_BPP(SRGGB12_1X12, RAW12, BPP12, 12), + FMT_MBUS_DT_DTFMT_BPP(SGBRG12_1X12, RAW12, BPP12, 12), + FMT_MBUS_DT_DTFMT_BPP(SGRBG12_1X12, RAW12, BPP12, 12), + FMT_MBUS_DT_DTFMT_BPP(SRGGB12_1X12, RAW12, BPP12, 12), + /* 14 bit */ + FMT_MBUS_DT_DTFMT_BPP(SRGGB14_1X14, RAW14, BPP14, 14), + FMT_MBUS_DT_DTFMT_BPP(SGBRG14_1X14, RAW14, BPP14, 14), + FMT_MBUS_DT_DTFMT_BPP(SGRBG14_1X14, RAW14, BPP14, 14), + FMT_MBUS_DT_DTFMT_BPP(SRGGB14_1X14, RAW14, BPP14, 14), + + /* RGB 565 */ + FMT_MBUS_DT_DTFMT_BPP(RGB565_1X16, RGB565, BPP8, 8), + + /* JPEG (datatype isn't used) */ + FMT_MBUS_DT_DTFMT_BPP(JPEG_1X8, NULL, BPP8, 8), +}; + +struct stm32_csi_mbps_phy_reg { + unsigned int mbps; + unsigned int hsfreqrange; + unsigned int osc_freq_target; +}; + +/* + * Table describing configuration of the PHY depending on the + * intended Bit Rate. From table 5-8 Frequency Ranges and Defaults + * of the Synopsis DWC MIPI PHY databook + */ +static const struct stm32_csi_mbps_phy_reg snps_stm32mp25[] =3D { + { .mbps =3D 80, .hsfreqrange =3D 0x00, .osc_freq_target =3D 460 }, + { .mbps =3D 90, .hsfreqrange =3D 0x10, .osc_freq_target =3D 460 }, + { .mbps =3D 100, .hsfreqrange =3D 0x20, .osc_freq_target =3D 460 }, + { .mbps =3D 110, .hsfreqrange =3D 0x30, .osc_freq_target =3D 460 }, + { .mbps =3D 120, .hsfreqrange =3D 0x01, .osc_freq_target =3D 460 }, + { .mbps =3D 130, .hsfreqrange =3D 0x11, .osc_freq_target =3D 460 }, + { .mbps =3D 140, .hsfreqrange =3D 0x21, .osc_freq_target =3D 460 }, + { .mbps =3D 150, .hsfreqrange =3D 0x31, .osc_freq_target =3D 460 }, + { .mbps =3D 160, .hsfreqrange =3D 0x02, .osc_freq_target =3D 460 }, + { .mbps =3D 170, .hsfreqrange =3D 0x12, .osc_freq_target =3D 460 }, + { .mbps =3D 180, .hsfreqrange =3D 0x22, .osc_freq_target =3D 460 }, + { .mbps =3D 190, .hsfreqrange =3D 0x32, .osc_freq_target =3D 460 }, + { .mbps =3D 205, .hsfreqrange =3D 0x03, .osc_freq_target =3D 460 }, + { .mbps =3D 220, .hsfreqrange =3D 0x13, .osc_freq_target =3D 460 }, + { .mbps =3D 235, .hsfreqrange =3D 0x23, .osc_freq_target =3D 460 }, + { .mbps =3D 250, .hsfreqrange =3D 0x33, .osc_freq_target =3D 460 }, + { .mbps =3D 275, .hsfreqrange =3D 0x04, .osc_freq_target =3D 460 }, + { .mbps =3D 300, .hsfreqrange =3D 0x14, .osc_freq_target =3D 460 }, + { .mbps =3D 325, .hsfreqrange =3D 0x25, .osc_freq_target =3D 460 }, + { .mbps =3D 350, .hsfreqrange =3D 0x35, .osc_freq_target =3D 460 }, + { .mbps =3D 400, .hsfreqrange =3D 0x05, .osc_freq_target =3D 460 }, + { .mbps =3D 450, .hsfreqrange =3D 0x16, .osc_freq_target =3D 460 }, + { .mbps =3D 500, .hsfreqrange =3D 0x26, .osc_freq_target =3D 460 }, + { .mbps =3D 550, .hsfreqrange =3D 0x37, .osc_freq_target =3D 460 }, + { .mbps =3D 600, .hsfreqrange =3D 0x07, .osc_freq_target =3D 460 }, + { .mbps =3D 650, .hsfreqrange =3D 0x18, .osc_freq_target =3D 460 }, + { .mbps =3D 700, .hsfreqrange =3D 0x28, .osc_freq_target =3D 460 }, + { .mbps =3D 750, .hsfreqrange =3D 0x39, .osc_freq_target =3D 460 }, + { .mbps =3D 800, .hsfreqrange =3D 0x09, .osc_freq_target =3D 460 }, + { .mbps =3D 850, .hsfreqrange =3D 0x19, .osc_freq_target =3D 460 }, + { .mbps =3D 900, .hsfreqrange =3D 0x29, .osc_freq_target =3D 460 }, + { .mbps =3D 950, .hsfreqrange =3D 0x3a, .osc_freq_target =3D 460 }, + { .mbps =3D 1000, .hsfreqrange =3D 0x0a, .osc_freq_target =3D 460 }, + { .mbps =3D 1050, .hsfreqrange =3D 0x1a, .osc_freq_target =3D 460 }, + { .mbps =3D 1100, .hsfreqrange =3D 0x2a, .osc_freq_target =3D 460 }, + { .mbps =3D 1150, .hsfreqrange =3D 0x3b, .osc_freq_target =3D 460 }, + { .mbps =3D 1200, .hsfreqrange =3D 0x0b, .osc_freq_target =3D 460 }, + { .mbps =3D 1250, .hsfreqrange =3D 0x1b, .osc_freq_target =3D 460 }, + { .mbps =3D 1300, .hsfreqrange =3D 0x2b, .osc_freq_target =3D 460 }, + { .mbps =3D 1350, .hsfreqrange =3D 0x3c, .osc_freq_target =3D 460 }, + { .mbps =3D 1400, .hsfreqrange =3D 0x0c, .osc_freq_target =3D 460 }, + { .mbps =3D 1450, .hsfreqrange =3D 0x1c, .osc_freq_target =3D 460 }, + { .mbps =3D 1500, .hsfreqrange =3D 0x2c, .osc_freq_target =3D 460 }, + { .mbps =3D 1550, .hsfreqrange =3D 0x3d, .osc_freq_target =3D 285 }, + { .mbps =3D 1600, .hsfreqrange =3D 0x0d, .osc_freq_target =3D 295 }, + { .mbps =3D 1650, .hsfreqrange =3D 0x1d, .osc_freq_target =3D 304 }, + { .mbps =3D 1700, .hsfreqrange =3D 0x2e, .osc_freq_target =3D 313 }, + { .mbps =3D 1750, .hsfreqrange =3D 0x3e, .osc_freq_target =3D 322 }, + { .mbps =3D 1800, .hsfreqrange =3D 0x0e, .osc_freq_target =3D 331 }, + { .mbps =3D 1850, .hsfreqrange =3D 0x1e, .osc_freq_target =3D 341 }, + { .mbps =3D 1900, .hsfreqrange =3D 0x2f, .osc_freq_target =3D 350 }, + { .mbps =3D 1950, .hsfreqrange =3D 0x3f, .osc_freq_target =3D 359 }, + { .mbps =3D 2000, .hsfreqrange =3D 0x0f, .osc_freq_target =3D 368 }, + { .mbps =3D 2050, .hsfreqrange =3D 0x40, .osc_freq_target =3D 377 }, + { .mbps =3D 2100, .hsfreqrange =3D 0x41, .osc_freq_target =3D 387 }, + { .mbps =3D 2150, .hsfreqrange =3D 0x42, .osc_freq_target =3D 396 }, + { .mbps =3D 2200, .hsfreqrange =3D 0x43, .osc_freq_target =3D 405 }, + { .mbps =3D 2250, .hsfreqrange =3D 0x44, .osc_freq_target =3D 414 }, + { .mbps =3D 2300, .hsfreqrange =3D 0x45, .osc_freq_target =3D 423 }, + { .mbps =3D 2350, .hsfreqrange =3D 0x46, .osc_freq_target =3D 432 }, + { .mbps =3D 2400, .hsfreqrange =3D 0x47, .osc_freq_target =3D 442 }, + { .mbps =3D 2450, .hsfreqrange =3D 0x48, .osc_freq_target =3D 451 }, + { .mbps =3D 2500, .hsfreqrange =3D 0x49, .osc_freq_target =3D 460 }, + { /* sentinel */ } +}; + +static const struct v4l2_mbus_framefmt fmt_default =3D { + .width =3D 640, + .height =3D 480, + .code =3D MEDIA_BUS_FMT_RGB565_1X16, + .field =3D V4L2_FIELD_NONE, + .colorspace =3D V4L2_COLORSPACE_REC709, + .ycbcr_enc =3D V4L2_YCBCR_ENC_DEFAULT, + .quantization =3D V4L2_QUANTIZATION_DEFAULT, + .xfer_func =3D V4L2_XFER_FUNC_DEFAULT, +}; + +static const struct stm32_csi_fmts *stm32_csi_code_to_fmt(unsigned int cod= e) +{ + unsigned int i; + + for (i =3D 0; i < ARRAY_SIZE(stm32_csi_formats); i++) + if (stm32_csi_formats[i].code =3D=3D code) + return &stm32_csi_formats[i]; + + return NULL; +} + +static inline struct stm32_csi_dev *to_csidev(struct v4l2_subdev *sd) +{ + return container_of(sd, struct stm32_csi_dev, sd); +} + +static int stm32_csi_setup_lane_merger(struct stm32_csi_dev *csidev) +{ + u32 lmcfgr =3D 0; + int i; + + for (i =3D 0; i < csidev->num_lanes; i++) { + if (!csidev->lanes[i] || csidev->lanes[i] > STM32_CSI_LANES_MAX) { + dev_err(csidev->dev, "Invalid lane id (%d)\n", csidev->lanes[i]); + return -EINVAL; + } + lmcfgr |=3D (csidev->lanes[i] << ((i * 4) + STM32_CSI_LMCFGR_DLMAP_SHIFT= )); + } + + lmcfgr |=3D (csidev->num_lanes << STM32_CSI_LMCFGR_LANENB_SHIFT); + + writel_relaxed(lmcfgr, csidev->base + STM32_CSI_LMCFGR); + + return 0; +} + +static void stm32_csi_phy_reg_write(struct stm32_csi_dev *csidev, + u32 addr, u32 val) +{ + /* Based on sequence described at section 5.2.3.2 of DesignWave document = */ + /* For writing the 4-bit testcode MSBs */ + /* Set testen to high */ + writel_relaxed(STM32_CSI_PTCR1_TWM, csidev->base + STM32_CSI_PTCR1); + + /* Set testclk to high */ + writel_relaxed(STM32_CSI_PTCR0_TCKEN, csidev->base + STM32_CSI_PTCR0); + + /* Place 0x00 in testdin */ + writel_relaxed(STM32_CSI_PTCR1_TWM, csidev->base + STM32_CSI_PTCR1); + + /* + * Set testclk to low (with the falling edge on testclk, the testdin + * signal content is latched internally) + */ + writel_relaxed(0, csidev->base + STM32_CSI_PTCR0); + + /* Set testen to low */ + writel_relaxed(0, csidev->base + STM32_CSI_PTCR1); + + /* Place the 8-bit word corresponding to the testcode MSBs in testdin */ + writel_relaxed(((addr >> 8) & STM32_CSI_PTCR1_TDI_MASK) << STM32_CSI_PTCR= 1_TDI_SHIFT, + csidev->base + STM32_CSI_PTCR1); + + /* Set testclk to high */ + writel_relaxed(STM32_CSI_PTCR0_TCKEN, csidev->base + STM32_CSI_PTCR0); + + /* For writing the 8-bit testcode LSBs */ + /* Set testclk to low */ + writel_relaxed(0, csidev->base + STM32_CSI_PTCR0); + + /* Set testen to high */ + writel_relaxed(STM32_CSI_PTCR1_TWM, csidev->base + STM32_CSI_PTCR1); + + /* Set testclk to high */ + writel_relaxed(STM32_CSI_PTCR0_TCKEN, csidev->base + STM32_CSI_PTCR0); + + /* Place the 8-bit word test data in testdin */ + writel_relaxed((addr & STM32_CSI_PTCR1_TDI_MASK) << + STM32_CSI_PTCR1_TDI_SHIFT | STM32_CSI_PTCR1_TWM, + csidev->base + STM32_CSI_PTCR1); + + /* + * Set testclk to low (with the falling edge on testclk, the testdin + * signal content is latched internally) + */ + writel_relaxed(0, csidev->base + STM32_CSI_PTCR0); + + /* Set testen to low */ + writel_relaxed(0, csidev->base + STM32_CSI_PTCR1); + + /* For writing the data */ + /* Place the 8-bit word corresponding to the page offset in testdin */ + writel_relaxed((val & STM32_CSI_PTCR1_TDI_MASK) << STM32_CSI_PTCR1_TDI_SH= IFT, + csidev->base + STM32_CSI_PTCR1); + + /* Set testclk to high (test data is programmed internally */ + writel_relaxed(STM32_CSI_PTCR0_TCKEN, csidev->base + STM32_CSI_PTCR0); + + /* Finish by setting testclk to low */ + writel_relaxed(0, csidev->base + STM32_CSI_PTCR0); +} + +static int stm32_csi_start(struct stm32_csi_dev *csidev, + struct v4l2_subdev_state *state) +{ + const struct stm32_csi_mbps_phy_reg *phy_regs; + struct v4l2_mbus_framefmt *sink_fmt; + const struct stm32_csi_fmts *fmt; + unsigned long phy_clk_frate; + unsigned int mbps; + u32 lanes_ie =3D 0; + u32 lanes_en =3D 0; + s64 link_freq; + int ret; + u32 ccfr; + + dev_dbg(csidev->dev, "Starting the CSI2\n"); + + /* Get the bpp value on pad0 (input of CSI) */ + sink_fmt =3D v4l2_subdev_state_get_format(state, STM32_CSI_PAD_SINK); + fmt =3D stm32_csi_code_to_fmt(sink_fmt->code); + + /* Get the remote sensor link frequency */ + if (!csidev->s_subdev) + return -EIO; + + link_freq =3D v4l2_get_link_freq(csidev->s_subdev->ctrl_handler, + fmt->bpp, 2 * csidev->num_lanes); + if (link_freq < 0) + return link_freq; + + /* MBPS is expressed in Mbps, hence link_freq / 100000 * 2 */ + mbps =3D div_s64(link_freq, 500000); + dev_dbg(csidev->dev, "Computed Mbps: %u\n", mbps); + + for (phy_regs =3D snps_stm32mp25; phy_regs->mbps !=3D 0; phy_regs++) + if (phy_regs->mbps >=3D mbps) + break; + + if (!phy_regs->mbps) { + dev_err(csidev->dev, "Unsupported PHY speed (%u Mbps)", mbps); + return -ERANGE; + } + + dev_dbg(csidev->dev, "PHY settings: (%u Mbps, %u HS FRange, %u OSC Freq)\= n", + phy_regs->mbps, phy_regs->hsfreqrange, + phy_regs->osc_freq_target); + + /* Prepare lanes related configuration bits */ + lanes_ie |=3D STM32_CSI_SR1_DL0_ERRORS; + lanes_en |=3D STM32_CSI_PCR_DL0EN; + if (csidev->num_lanes =3D=3D 2) { + lanes_ie |=3D STM32_CSI_SR1_DL1_ERRORS; + lanes_en |=3D STM32_CSI_PCR_DL1EN; + } + + ret =3D pm_runtime_get_sync(csidev->dev); + if (ret < 0) + return ret; + + /* Retrieve CSI2PHY clock rate to compute CCFR value */ + phy_clk_frate =3D clk_get_rate(csidev->clks[STM32_CSI_CLK_CSI2PHY].clk); + if (!phy_clk_frate) { + pm_runtime_put(csidev->dev); + dev_err(csidev->dev, "CSI2PHY clock rate invalid (0)\n"); + return ret; + } + + ret =3D stm32_csi_setup_lane_merger(csidev); + if (ret) { + pm_runtime_put(csidev->dev); + return ret; + } + + /* Enable the CSI */ + writel_relaxed(STM32_CSI_CR_CSIEN, csidev->base + STM32_CSI_CR); + + /* Enable some global CSI related interrupts - bits are same as SR0 */ + writel_relaxed(STM32_CSI_SR0_ERRORS, csidev->base + STM32_CSI_IER0); + + /* Enable lanes related error interrupts */ + writel_relaxed(lanes_ie, csidev->base + STM32_CSI_IER1); + + /* Initialization of the D-PHY */ + /* Stop the D-PHY */ + writel_relaxed(0, csidev->base + STM32_CSI_PRCR); + + /* Keep the D-PHY in power down state */ + writel_relaxed(0, csidev->base + STM32_CSI_PCR); + + /* Enable testclr clock during 15ns */ + writel_relaxed(STM32_CSI_PTCR0_TCKEN, csidev->base + STM32_CSI_PTCR0); + udelay(1); + writel_relaxed(0, csidev->base + STM32_CSI_PTCR0); + + /* Set hsfreqrange */ + phy_clk_frate /=3D 1000000; + ccfr =3D (phy_clk_frate - 17) * 4; + writel_relaxed((ccfr << STM32_CSI_PFCR_CCFR_SHIFT) | + (phy_regs->hsfreqrange << STM32_CSI_PFCR_HSFR_SHIFT), + csidev->base + STM32_CSI_PFCR); + + /* set reg @08 deskew_polarity_rw 1'b1 */ + stm32_csi_phy_reg_write(csidev, 0x08, 0x38); + + /* set reg @0xE4 counter_for_des_en_config_if_rx 0x10 + DLL prog EN */ + /* This is because 13<=3D cfgclkfreqrange[5:0]<=3D38 */ + stm32_csi_phy_reg_write(csidev, 0xe4, 0x11); + + /* set reg @0xe2 & reg @0xe3 value DLL target oscilation freq */ + /* Based on the table page 77, osc_freq_target */ + stm32_csi_phy_reg_write(csidev, 0xe2, phy_regs->osc_freq_target & 0xFF); + stm32_csi_phy_reg_write(csidev, 0xe3, (phy_regs->osc_freq_target >> 8) & = 0x0F); + + writel_relaxed(STM32_CSI_PFCR_DLD | readl_relaxed(csidev->base + STM32_CS= I_PFCR), + csidev->base + STM32_CSI_PFCR); + + /* Enable Lanes */ + writel_relaxed(lanes_en | STM32_CSI_PCR_CLEN, csidev->base + STM32_CSI_PC= R); + writel_relaxed(lanes_en | STM32_CSI_PCR_CLEN | STM32_CSI_PCR_PWRDOWN, + csidev->base + STM32_CSI_PCR); + + writel_relaxed(STM32_CSI_PRCR_PEN, csidev->base + STM32_CSI_PRCR); + + /* Remove the force */ + writel_relaxed(0, csidev->base + STM32_CSI_PMCR); + + return ret; +} + +static void stm32_csi_stop(struct stm32_csi_dev *csidev) +{ + dev_dbg(csidev->dev, "Stopping the CSI2\n"); + + /* Disable the D-PHY */ + writel_relaxed(0, csidev->base + STM32_CSI_PCR); + + /* Disable ITs */ + writel_relaxed(0, csidev->base + STM32_CSI_IER0); + writel_relaxed(0, csidev->base + STM32_CSI_IER1); + + /* Disable the CSI */ + writel_relaxed(0, csidev->base + STM32_CSI_CR); + + pm_runtime_put(csidev->dev); +} + +static int stm32_csi_start_vc(struct stm32_csi_dev *csidev, + struct v4l2_subdev_state *state, u32 vc) +{ + struct v4l2_mbus_framefmt *mbus_fmt; + const struct stm32_csi_fmts *fmt; + u32 cfgr1 =3D 0; + int ret =3D 0; + u32 status; + + mbus_fmt =3D v4l2_subdev_state_get_format(state, STM32_CSI_PAD_SOURCE); + fmt =3D stm32_csi_code_to_fmt(mbus_fmt->code); + + /* If the mbus code is JPEG, don't enable filtering */ + if (mbus_fmt->code =3D=3D MEDIA_BUS_FMT_JPEG_1X8) { + cfgr1 |=3D STM32_CSI_VCXCFGR1_ALLDT; + cfgr1 |=3D fmt->input_fmt << STM32_CSI_VCXCFGR1_CDTFT_SHIFT; + dev_dbg(csidev->dev, "VC%d: enable AllDT mode\n", vc); + } else { + cfgr1 |=3D fmt->datatype << STM32_CSI_VCXCFGR1_DT0_SHIFT; + cfgr1 |=3D fmt->input_fmt << STM32_CSI_VCXCFGR1_DT0FT_SHIFT; + cfgr1 |=3D STM32_CSI_VCXCFGR1_DT0EN; + dev_dbg(csidev->dev, "VC%d: enable DT0(0x%x)/DT0FT(0x%x)\n", + vc, fmt->datatype, fmt->input_fmt); + } + writel_relaxed(cfgr1, csidev->base + STM32_CSI_VCXCFGR1(vc)); + + /* Enable processing of the virtual-channel and wait for its status */ + writel_relaxed(STM32_CSI_CR_VCXSTART(vc) | STM32_CSI_CR_CSIEN, + csidev->base + STM32_CSI_CR); + + ret =3D readl_relaxed_poll_timeout(csidev->base + STM32_CSI_SR0, + status, + status & STM32_CSI_SR0_VCXSTATEF(vc), + 1000, 1000000); + if (ret) { + dev_err(csidev->dev, "failed to start VC(%d)\n", vc); + return ret; + } + + return 0; +} + +static int stm32_csi_stop_vc(struct stm32_csi_dev *csidev, u32 vc) +{ + int ret =3D 0; + u32 status; + + /* Stop the Virtual Channel */ + writel_relaxed(STM32_CSI_CR_VCXSTOP(vc) | STM32_CSI_CR_CSIEN, + csidev->base + STM32_CSI_CR); + + ret =3D readl_relaxed_poll_timeout(csidev->base + STM32_CSI_SR0, + status, + !(status & STM32_CSI_SR0_VCXSTATEF(vc)), + 1000, 1000000); + if (ret) { + dev_err(csidev->dev, "failed to stop VC(%d)\n", vc); + return ret; + } + + /* Disable all DTs */ + writel_relaxed(0, csidev->base + STM32_CSI_VCXCFGR1(vc)); + writel_relaxed(0, csidev->base + STM32_CSI_VCXCFGR2(vc)); + + return 0; +} + +static int stm32_csi_disable_streams(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, u32 pad, + u64 streams_mask) +{ + struct stm32_csi_dev *csidev =3D to_csidev(sd); + int ret; + + ret =3D v4l2_subdev_disable_streams(csidev->s_subdev, + csidev->s_subdev_pad_nb, BIT_ULL(0)); + if (ret) + return ret; + + /* Stop the VC0 */ + ret =3D stm32_csi_stop_vc(csidev, 0); + if (ret) + dev_err(csidev->dev, "Failed to stop VC0\n"); + + stm32_csi_stop(csidev); + + return 0; +} + +static int stm32_csi_enable_streams(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, u32 pad, + u64 streams_mask) +{ + struct stm32_csi_dev *csidev =3D to_csidev(sd); + int ret; + + ret =3D stm32_csi_start(csidev, state); + if (ret) + return ret; + + /* Configure & start the VC0 */ + ret =3D stm32_csi_start_vc(csidev, state, 0); + if (ret) { + dev_err(csidev->dev, "Failed to start VC0\n"); + stm32_csi_stop(csidev); + return ret; + } + + ret =3D v4l2_subdev_enable_streams(csidev->s_subdev, + csidev->s_subdev_pad_nb, BIT_ULL(0)); + if (ret) { + stm32_csi_stop_vc(csidev, 0); + stm32_csi_stop(csidev); + return ret; + } + + return 0; +} + +static int stm32_csi_init_state(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state) +{ + int i; + + for (i =3D 0; i < sd->entity.num_pads; i++) + *v4l2_subdev_state_get_format(state, i) =3D fmt_default; + + return 0; +} + +static int stm32_csi_enum_mbus_code(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, + struct v4l2_subdev_mbus_code_enum *code) +{ + if (code->index >=3D ARRAY_SIZE(stm32_csi_formats)) + return -EINVAL; + + code->code =3D stm32_csi_formats[code->index].code; + return 0; +} + +static int stm32_csi_set_pad_format(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, + struct v4l2_subdev_format *format) +{ + struct stm32_csi_dev *csidev =3D to_csidev(sd); + struct v4l2_mbus_framefmt *framefmt; + const struct stm32_csi_fmts *fmt; + + fmt =3D stm32_csi_code_to_fmt(format->format.code); + if (!fmt) { + dev_dbg(csidev->dev, "Unsupported code %d, use default\n", + format->format.code); + format->format.code =3D fmt_default.code; + } + + framefmt =3D v4l2_subdev_state_get_format(state, STM32_CSI_PAD_SINK); + + if (format->pad =3D=3D STM32_CSI_PAD_SOURCE) + format->format =3D *framefmt; + else + *framefmt =3D format->format; + + framefmt =3D v4l2_subdev_state_get_format(state, STM32_CSI_PAD_SOURCE); + *framefmt =3D format->format; + + return 0; +} + +static int stm32_csi_log_status(struct v4l2_subdev *sd) +{ + struct stm32_csi_dev *csidev =3D to_csidev(sd); + unsigned long flags; + unsigned int i; + + spin_lock_irqsave(&csidev->slock, flags); + + for (i =3D 0; i < STM32_CSI_NUM_SR0_EVENTS; i++) { + if (csidev->sr0_counters[i]) + dev_info(csidev->dev, "%s events: %d\n", + stm32_csi_events_sr0[i].name, + csidev->sr0_counters[i]); + } + + for (i =3D 0; i < STM32_CSI_NUM_SR1_EVENTS; i++) { + if (csidev->sr1_counters[i]) + dev_info(csidev->dev, "%s events: %d\n", + stm32_csi_events_sr1[i].name, + csidev->sr1_counters[i]); + } + + spin_unlock_irqrestore(&csidev->slock, flags); + + return 0; +} + +static const struct v4l2_subdev_core_ops stm32_csi_core_ops =3D { + .log_status =3D stm32_csi_log_status, +}; + +static const struct v4l2_subdev_video_ops stm32_csi_video_ops =3D { + .s_stream =3D v4l2_subdev_s_stream_helper, +}; + +static const struct v4l2_subdev_pad_ops stm32_csi_pad_ops =3D { + .enum_mbus_code =3D stm32_csi_enum_mbus_code, + .set_fmt =3D stm32_csi_set_pad_format, + .get_fmt =3D v4l2_subdev_get_fmt, + .enable_streams =3D stm32_csi_enable_streams, + .disable_streams =3D stm32_csi_disable_streams, +}; + +static const struct v4l2_subdev_ops stm32_csi_subdev_ops =3D { + .core =3D &stm32_csi_core_ops, + .pad =3D &stm32_csi_pad_ops, + .video =3D &stm32_csi_video_ops, +}; + +static const struct v4l2_subdev_internal_ops stm32_csi_subdev_internal_ops= =3D { + .init_state =3D stm32_csi_init_state, +}; + +static int stm32_csi_async_bound(struct v4l2_async_notifier *notifier, + struct v4l2_subdev *s_subdev, + struct v4l2_async_connection *asd) +{ + struct v4l2_subdev *sd =3D notifier->sd; + struct stm32_csi_dev *csidev =3D to_csidev(sd); + int remote_pad; + + remote_pad =3D media_entity_get_fwnode_pad(&s_subdev->entity, + s_subdev->fwnode, + MEDIA_PAD_FL_SOURCE); + if (remote_pad < 0) { + dev_err(csidev->dev, "Couldn't find output pad for subdev %s\n", + s_subdev->name); + return remote_pad; + } + + csidev->s_subdev =3D s_subdev; + csidev->s_subdev_pad_nb =3D remote_pad; + + return media_create_pad_link(&csidev->s_subdev->entity, + remote_pad, &csidev->sd.entity, + STM32_CSI_PAD_SINK, + MEDIA_LNK_FL_ENABLED | + MEDIA_LNK_FL_IMMUTABLE); +} + +static const struct v4l2_async_notifier_operations stm32_csi_notifier_ops = =3D { + .bound =3D stm32_csi_async_bound, +}; + +static irqreturn_t stm32_csi_irq_thread(int irq, void *arg) +{ + struct stm32_csi_dev *csidev =3D arg; + unsigned long flags; + u32 sr0, sr1; + int i; + + sr0 =3D readl_relaxed(csidev->base + STM32_CSI_SR0); + sr1 =3D readl_relaxed(csidev->base + STM32_CSI_SR1); + + /* Clear interrupt */ + writel_relaxed(sr0 & STM32_CSI_SR0_ERRORS, + csidev->base + STM32_CSI_FCR0); + writel_relaxed(sr1 & STM32_CSI_SR1_ERRORS, + csidev->base + STM32_CSI_FCR1); + + spin_lock_irqsave(&csidev->slock, flags); + + for (i =3D 0; i < STM32_CSI_NUM_SR0_EVENTS; i++) + if (sr0 & stm32_csi_events_sr0[i].mask) + csidev->sr0_counters[i]++; + + for (i =3D 0; i < STM32_CSI_NUM_SR1_EVENTS; i++) + if (sr1 & stm32_csi_events_sr1[i].mask) + csidev->sr1_counters[i]++; + + spin_unlock_irqrestore(&csidev->slock, flags); + + return IRQ_HANDLED; +} + +static int stm32_csi_get_resources(struct stm32_csi_dev *csidev, + struct platform_device *pdev) +{ + int irq, ret, i; + + csidev->base =3D devm_platform_get_and_ioremap_resource(pdev, 0, NULL); + if (IS_ERR(csidev->base)) + return dev_err_probe(&pdev->dev, PTR_ERR(csidev->base), + "Failed to ioremap resource\n"); + + for (i =3D 0; i < STM32_CSI_CLK_NB; i++) + csidev->clks[i].id =3D stm32_csi_clks_id[i]; + + ret =3D devm_clk_bulk_get(&pdev->dev, STM32_CSI_CLK_NB, + csidev->clks); + if (ret < 0) + return dev_err_probe(&pdev->dev, ret, "Couldn't get clks\n"); + + csidev->supplies[0].supply =3D "vdd"; + csidev->supplies[1].supply =3D "vdda18"; + ret =3D devm_regulator_bulk_get(&pdev->dev, ARRAY_SIZE(csidev->supplies), + csidev->supplies); + if (ret) + return dev_err_probe(&pdev->dev, ret, + "Failed to request regulator vdd\n"); + + irq =3D platform_get_irq(pdev, 0); + if (irq < 0) + return irq; + + ret =3D devm_request_threaded_irq(&pdev->dev, irq, NULL, + stm32_csi_irq_thread, IRQF_ONESHOT, + dev_name(&pdev->dev), csidev); + if (ret) + return dev_err_probe(&pdev->dev, ret, + "Unable to request irq"); + + return 0; +} + +static int stm32_csi_parse_dt(struct stm32_csi_dev *csidev) +{ + struct v4l2_fwnode_endpoint v4l2_ep =3D { .bus_type =3D V4L2_MBUS_CSI2_DP= HY }; + struct v4l2_async_connection *asd; + struct fwnode_handle *ep; + int ret; + + /* Get bus characteristics from devicetree */ + ep =3D fwnode_graph_get_endpoint_by_id(dev_fwnode(csidev->dev), 0, 0, + FWNODE_GRAPH_ENDPOINT_NEXT); + if (!ep) { + dev_err(csidev->dev, "Could not find the endpoint\n"); + return -ENODEV; + } + + ret =3D v4l2_fwnode_endpoint_parse(ep, &v4l2_ep); + fwnode_handle_put(ep); + if (ret) { + dev_err(csidev->dev, "Could not parse v4l2 endpoint\n"); + return ret; + } + + csidev->num_lanes =3D v4l2_ep.bus.mipi_csi2.num_data_lanes; + if (csidev->num_lanes > STM32_CSI_LANES_MAX) { + dev_err(csidev->dev, "Unsupported number of data-lanes: %d\n", + csidev->num_lanes); + return -EINVAL; + } + + memcpy(csidev->lanes, v4l2_ep.bus.mipi_csi2.data_lanes, + sizeof(csidev->lanes)); + + ep =3D fwnode_graph_get_next_endpoint(dev_fwnode(csidev->dev), NULL); + if (!ep) { + dev_err(csidev->dev, "Failed to get next endpoint\n"); + return -EINVAL; + } + + v4l2_async_subdev_nf_init(&csidev->notifier, &csidev->sd); + + asd =3D v4l2_async_nf_add_fwnode_remote(&csidev->notifier, ep, + struct v4l2_async_connection); + + fwnode_handle_put(ep); + + if (IS_ERR(asd)) { + dev_err(csidev->dev, "Failed to add fwnode remote subdev\n"); + return PTR_ERR(asd); + } + + csidev->notifier.ops =3D &stm32_csi_notifier_ops; + + ret =3D v4l2_async_nf_register(&csidev->notifier); + if (ret) { + dev_err(csidev->dev, "Failed to register notifier\n"); + v4l2_async_nf_cleanup(&csidev->notifier); + return ret; + } + + return ret; +} + +static int stm32_csi_probe(struct platform_device *pdev) +{ + struct stm32_csi_dev *csidev; + struct reset_control *rstc; + int ret; + + csidev =3D devm_kzalloc(&pdev->dev, sizeof(*csidev), GFP_KERNEL); + if (!csidev) + return -ENOMEM; + + platform_set_drvdata(pdev, csidev); + csidev->dev =3D &pdev->dev; + + spin_lock_init(&csidev->slock); + + ret =3D stm32_csi_get_resources(csidev, pdev); + if (ret) + goto err_free_priv; + + ret =3D stm32_csi_parse_dt(csidev); + if (ret) + goto err_free_priv; + + csidev->sd.owner =3D THIS_MODULE; + csidev->sd.dev =3D &pdev->dev; + csidev->sd.internal_ops =3D &stm32_csi_subdev_internal_ops; + v4l2_subdev_init(&csidev->sd, &stm32_csi_subdev_ops); + v4l2_set_subdevdata(&csidev->sd, &pdev->dev); + snprintf(csidev->sd.name, sizeof(csidev->sd.name), "%s", + dev_name(&pdev->dev)); + + /* Create our media pads */ + csidev->sd.entity.function =3D MEDIA_ENT_F_VID_IF_BRIDGE; + csidev->sd.flags |=3D V4L2_SUBDEV_FL_HAS_DEVNODE; + csidev->pads[STM32_CSI_PAD_SINK].flags =3D MEDIA_PAD_FL_SINK; + csidev->pads[STM32_CSI_PAD_SOURCE].flags =3D MEDIA_PAD_FL_SOURCE; + + ret =3D media_entity_pads_init(&csidev->sd.entity, STM32_CSI_PAD_MAX, + csidev->pads); + if (ret) + goto err_cleanup; + + ret =3D v4l2_subdev_init_finalize(&csidev->sd); + if (ret < 0) + goto err_cleanup; + + ret =3D v4l2_async_register_subdev(&csidev->sd); + if (ret < 0) + goto err_cleanup; + + /* Reset device */ + rstc =3D devm_reset_control_get_exclusive(&pdev->dev, NULL); + if (IS_ERR(rstc)) { + ret =3D dev_err_probe(&pdev->dev, PTR_ERR(rstc), + "Couldn't get reset control\n"); + goto err_cleanup; + } + + ret =3D reset_control_assert(rstc); + if (ret) { + ret =3D dev_err_probe(&pdev->dev, ret, + "Failed to assert the reset line\n"); + goto err_cleanup; + } + + usleep_range(3000, 5000); + + ret =3D reset_control_deassert(rstc); + if (ret) { + ret =3D dev_err_probe(&pdev->dev, ret, + "Failed to deassert the reset line\n"); + goto err_cleanup; + } + + pm_runtime_enable(&pdev->dev); + + dev_info(&pdev->dev, + "Probed CSI with %u lanes\n", csidev->num_lanes); + + return 0; + +err_cleanup: + v4l2_async_nf_cleanup(&csidev->notifier); +err_free_priv: + return ret; +} + +static void stm32_csi_remove(struct platform_device *pdev) +{ + struct stm32_csi_dev *csidev =3D platform_get_drvdata(pdev); + + v4l2_async_unregister_subdev(&csidev->sd); + + pm_runtime_disable(&pdev->dev); +} + +static int stm32_csi_runtime_suspend(struct device *dev) +{ + struct stm32_csi_dev *csidev =3D dev_get_drvdata(dev); + int ret; + + clk_bulk_disable_unprepare(STM32_CSI_CLK_NB, csidev->clks); + + ret =3D regulator_bulk_disable(ARRAY_SIZE(csidev->supplies), + csidev->supplies); + if (ret < 0) + dev_err(dev, "cannot disable regulators %d\n", ret); + + return 0; +} + +static int stm32_csi_runtime_resume(struct device *dev) +{ + struct stm32_csi_dev *csidev =3D dev_get_drvdata(dev); + int ret; + + ret =3D regulator_bulk_enable(ARRAY_SIZE(csidev->supplies), + csidev->supplies); + if (ret) + goto error_out; + + ret =3D clk_bulk_prepare_enable(STM32_CSI_CLK_NB, csidev->clks); + if (ret) + goto error_disable_supplies; + + return 0; + +error_disable_supplies: + ret =3D regulator_bulk_disable(ARRAY_SIZE(csidev->supplies), csidev->supp= lies); + if (ret < 0) + dev_err(dev, "cannot disable regulators %d\n", ret); +error_out: + dev_err(csidev->dev, "Failed to resume: %d\n", ret); + + return ret; +} + +static const struct of_device_id stm32_csi_of_table[] =3D { + { .compatible =3D "st,stm32mp25-csi", }, + { /* end node */ }, +}; +MODULE_DEVICE_TABLE(of, stm32_csi_of_table); + +static const struct dev_pm_ops stm32_csi_pm_ops =3D { + RUNTIME_PM_OPS(stm32_csi_runtime_suspend, + stm32_csi_runtime_resume, NULL) +}; + +static struct platform_driver stm32_csi_driver =3D { + .driver =3D { + .name =3D "stm32-csi", + .of_match_table =3D stm32_csi_of_table, + .pm =3D pm_ptr(&stm32_csi_pm_ops), + }, + .probe =3D stm32_csi_probe, + .remove =3D stm32_csi_remove, +}; + +module_platform_driver(stm32_csi_driver); + +MODULE_AUTHOR("Alain Volmat "); +MODULE_DESCRIPTION("STM32 CSI controller"); +MODULE_LICENSE("GPL"); --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx08-00178001.pphosted.com (mx08-00178001.pphosted.com [91.207.212.93]) (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 6DCAA1ABEA6; Mon, 18 Nov 2024 13:40:17 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.207.212.93 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937219; cv=none; b=qiND5NpLWdvyD6Xsj/p5nk5PjfDzhm9p8UnbCnbVqVCDn95u1tUc/jD0LbEwBS4bVo6Bmm0xgcjy8KbE1cKT0RxjZueCAEOH5R4HHsn6vy3jiUFc5UAIQ2xih4XlZsj5JTQLjdJqfF1h9b8X59PbXAjnzWIGB47LtdeCS4NS8mE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937219; c=relaxed/simple; bh=b4urTh22AIvaqz2EmuC9UlyYLkWnaPQp2f86++BSplA=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=nx8PmtsHhhmNTc8q2lKwGqCiM91FIXwLYK6k0twdO4GqwOHei+MX1nph7C0wIC6c8togFa1e3eFBYCsJIDrGq02zHkz2m+iBvlaNNlH5AsOvKQ7OrmRl14Q3b2T0+/wM3Ind78huvaE/VPb84DflXJihtFvr/z+bGnSd7yWWMFY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=2M4v1XZi; arc=none smtp.client-ip=91.207.212.93 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="2M4v1XZi" Received: from pps.filterd (m0369457.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AI9DM2l028148; Mon, 18 Nov 2024 14:39:52 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= Boh51om16/6cUq1DCmo9haIf3b5vZQi+saUvgPu/98Y=; b=2M4v1XZiijK8nefF ak2n/7yBsecDvequuWx6nRBUKZpgK6HJwQLNrK8PLdkTkNlCi1wom4T4Tl59V3U4 o64j6uR/yXRLYjHSUAabFZRTRcs8nRNMWcGHgmn5Vdmr3WSyj9yDQE0bhR3QCorR bogGW+Yj9LPuyNXwvTuxRSCk22T+paXMgFFDYrjs/vep67/5Psux8qKKwZQnmKYi cKdmN487K55apXykg0qiKeISzXWk2Kdtr4wvLlByesJ35w5AYLJtZiG7uJl3PnW2 Ycs5c/RqI8T+VhtDaaiONuPeo3DcpxRYX9W7mjMuvO5cK1OQSi164KyuERAhSFUX MEpKhQ== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42y77n504r-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:52 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id F23E64005B; Mon, 18 Nov 2024 14:38:32 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 9F1FD2747D7; Mon, 18 Nov 2024 14:35:28 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:28 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:27 +0100 Subject: [PATCH v3 04/15] media: stm32: dcmipp: use v4l2_subdev_is_streaming 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: <20241118-csi_dcmipp_mp25-v3-4-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 Rely on v4l2_subdev_is_streaming in order to know if the subdev is streaming or not instead of relying on a local variable. Signed-off-by: Alain Volmat --- drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c | 6 +----- drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-parallel.c | 5 +---- 2 files changed, 2 insertions(+), 9 deletions(-) diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c= b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c index 5a361ad6b0234c5de03c12b0b7b9d428eae63c06..50500112eab9a7b10a0c5e29773= e31ded1a66628 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c @@ -78,7 +78,6 @@ struct dcmipp_byteproc_device { struct v4l2_subdev sd; struct device *dev; void __iomem *regs; - bool streaming; }; =20 static const struct v4l2_mbus_framefmt fmt_default =3D { @@ -239,11 +238,10 @@ static int dcmipp_byteproc_set_fmt(struct v4l2_subdev= *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_format *fmt) { - struct dcmipp_byteproc_device *byteproc =3D v4l2_get_subdevdata(sd); struct v4l2_mbus_framefmt *mf; struct v4l2_rect *crop, *compose; =20 - if (byteproc->streaming) + if (v4l2_subdev_is_streaming(sd)) return -EBUSY; =20 mf =3D v4l2_subdev_state_get_format(sd_state, fmt->pad); @@ -495,8 +493,6 @@ static int dcmipp_byteproc_s_stream(struct v4l2_subdev = *sd, int enable) } } =20 - byteproc->streaming =3D enable; - return 0; } =20 diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-parallel.c= b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-parallel.c index 62c5c3331cfecdf5fcf0a5d20b4051b1b024968e..05e8897ae37a4b6c8e16c066e83= ff5b1d1e07635 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-parallel.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-parallel.c @@ -129,7 +129,6 @@ struct dcmipp_par_device { struct v4l2_subdev sd; struct device *dev; void __iomem *regs; - bool streaming; }; =20 static const struct v4l2_mbus_framefmt fmt_default =3D { @@ -230,7 +229,7 @@ static int dcmipp_par_set_fmt(struct v4l2_subdev *sd, struct dcmipp_par_device *par =3D v4l2_get_subdevdata(sd); struct v4l2_mbus_framefmt *mf; =20 - if (par->streaming) + if (v4l2_subdev_is_streaming(sd)) return -EBUSY; =20 mf =3D v4l2_subdev_state_get_format(sd_state, fmt->pad); @@ -370,8 +369,6 @@ static int dcmipp_par_s_stream(struct v4l2_subdev *sd, = int enable) reg_clear(par, DCMIPP_PRCR, DCMIPP_PRCR_ENABLE); } =20 - par->streaming =3D enable; - return ret; } =20 --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx07-00178001.pphosted.com (mx07-00178001.pphosted.com [185.132.182.106]) (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 7F8F91A0B0C; Mon, 18 Nov 2024 13:40:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=185.132.182.106 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937217; cv=none; b=nTxJrjqkKTvxImLkvikfe0/8is0ao3bKM5KQmaJf+umY/X+J2CwAbhgkjvO7bFCAGmfoilaUcbT0b7b+B3ZUqFl97ND6rsj/yuDsGFQR3DoiUsqP0AMSxjitqk8P1UYxmJKkToPLpZBl9vlk3K1MHBPMrqo2LxBQ9vc3DkWDOcw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937217; c=relaxed/simple; bh=iwMMj6hFeKCXUBKnWgk+dNDNW1m0V5G2ddgEDKZdbpo=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=QC/hD7yXPrkoq6PG77srpx4x6Hd05nQ82grzf34JDkrQyTd4UfmO5Nui+Lbmi5CDWTwke6Jk7goPGrN7vx3YfwTpV9iAH24qYPhY1mhTGqhHEnH1FO4NReYfjjntgHQcaTmf3WfsV5jmEcpwOOiWrx6EIhvtuKE3prbKf9+XCUw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=s8rC4xfC; arc=none smtp.client-ip=185.132.182.106 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="s8rC4xfC" Received: from pps.filterd (m0241204.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AIBhWMD021684; Mon, 18 Nov 2024 14:39:52 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= K2o8RWIwZHcDnCoRZbJ0AgekAHRjrD6szKnoYOlNjHE=; b=s8rC4xfCBxwrPn82 T3VMocSMSWD4Zu5iyWVL5wFsLeF/s5ku/Yup4cGOGw50sRaKHd9c9RFbCBSE4mUz ijOt2nq6wnbTBAC3WhmYYVIab5DBk1YCZ26yumhbt0LLM41oreh3qPMiDKtn1pJV DtrO0w0YTDqWftSGYkyPJNCXnkODNjoIuiNzLdXnVy3zIApKVKc2fK2zba4dEsGy zaet3Rt79jDOr12XuMZaFvXZ2QwkblgXqh5VlMF6/W1as2hhjsXSz17wKvNJVATy WKu3qpiZhfZhVpaKjqm520YzvejJXsG1EBTdNbGjiriPYeHRUEIzMji66W1eBXUQ DrwIOw== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42xkq5qhhn-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:52 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id 06CE84005D; Mon, 18 Nov 2024 14:38:33 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 555BC2747D8; Mon, 18 Nov 2024 14:35:29 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:29 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:28 +0100 Subject: [PATCH v3 05/15] media: stm32: dcmipp: replace s_stream with enable/disable_streams 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: <20241118-csi_dcmipp_mp25-v3-5-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 Replace s_stream ops with enable_streams and disable_streams. At the same time, use v4l2_subdev_enable_streams and v4l2_subdev_disable_streams functions instead of direct s_stream calls. Signed-off-by: Alain Volmat --- v2: add missing state argument within dcmipp_par_configure call --- .../st/stm32/stm32-dcmipp/dcmipp-bytecap.c | 49 ++++------ .../st/stm32/stm32-dcmipp/dcmipp-byteproc.c | 98 +++++++++++------= -- .../st/stm32/stm32-dcmipp/dcmipp-parallel.c | 107 ++++++++++++-----= ---- 3 files changed, 139 insertions(+), 115 deletions(-) diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c = b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c index 0f6918f4db383f4e0762030218101f759f375e95..48596592bfd517b9d46946d27f1= 54f0d17ebed78 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c @@ -112,6 +112,7 @@ struct dcmipp_bytecap_device { u32 sequence; struct media_pipeline pipe; struct v4l2_subdev *s_subdev; + u32 s_subdev_pad_nb; =20 enum dcmipp_state state; =20 @@ -337,33 +338,6 @@ static const struct v4l2_ioctl_ops dcmipp_bytecap_ioct= l_ops =3D { .vidioc_streamoff =3D vb2_ioctl_streamoff, }; =20 -static int dcmipp_pipeline_s_stream(struct dcmipp_bytecap_device *vcap, - int state) -{ - struct media_pad *pad; - int ret; - - /* - * Get source subdev - since link is IMMUTABLE, pointer is cached - * within the dcmipp_bytecap_device structure - */ - if (!vcap->s_subdev) { - pad =3D media_pad_remote_pad_first(&vcap->vdev.entity.pads[0]); - if (!pad || !is_media_entity_v4l2_subdev(pad->entity)) - return -EINVAL; - vcap->s_subdev =3D media_entity_to_v4l2_subdev(pad->entity); - } - - ret =3D v4l2_subdev_call(vcap->s_subdev, video, s_stream, state); - if (ret < 0) { - dev_err(vcap->dev, "failed to %s streaming (%d)\n", - state ? "start" : "stop", ret); - return ret; - } - - return 0; -} - static void dcmipp_start_capture(struct dcmipp_bytecap_device *vcap, struct dcmipp_buf *buf) { @@ -395,11 +369,24 @@ static int dcmipp_bytecap_start_streaming(struct vb2_= queue *vq, struct dcmipp_bytecap_device *vcap =3D vb2_get_drv_priv(vq); struct media_entity *entity =3D &vcap->vdev.entity; struct dcmipp_buf *buf; + struct media_pad *pad; int ret; =20 vcap->sequence =3D 0; memset(&vcap->count, 0, sizeof(vcap->count)); =20 + /* + * Get source subdev - since link is IMMUTABLE, pointer is cached + * within the dcmipp_bytecap_device structure + */ + if (!vcap->s_subdev) { + pad =3D media_pad_remote_pad_first(&vcap->vdev.entity.pads[0]); + if (!pad || !is_media_entity_v4l2_subdev(pad->entity)) + return -EINVAL; + vcap->s_subdev =3D media_entity_to_v4l2_subdev(pad->entity); + vcap->s_subdev_pad_nb =3D pad->index; + } + ret =3D pm_runtime_resume_and_get(vcap->dev); if (ret < 0) { dev_err(vcap->dev, "%s: Failed to start streaming, cannot get sync (%d)\= n", @@ -414,7 +401,8 @@ static int dcmipp_bytecap_start_streaming(struct vb2_qu= eue *vq, goto err_pm_put; } =20 - ret =3D dcmipp_pipeline_s_stream(vcap, 1); + ret =3D v4l2_subdev_enable_streams(vcap->s_subdev, + vcap->s_subdev_pad_nb, BIT_ULL(0)); if (ret) goto err_media_pipeline_stop; =20 @@ -482,7 +470,10 @@ static void dcmipp_bytecap_stop_streaming(struct vb2_q= ueue *vq) int ret; u32 status; =20 - dcmipp_pipeline_s_stream(vcap, 0); + ret =3D v4l2_subdev_disable_streams(vcap->s_subdev, + vcap->s_subdev_pad_nb, BIT_ULL(0)); + if (ret) + dev_warn(vcap->dev, "Failed to disable stream\n"); =20 /* Stop the media pipeline */ media_pipeline_stop(vcap->vdev.entity.pads); diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c= b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c index 50500112eab9a7b10a0c5e29773e31ded1a66628..a19c8235af565fb5f673ba90b37= ebfcadf03d72e 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c @@ -380,30 +380,19 @@ static int dcmipp_byteproc_set_selection(struct v4l2_= subdev *sd, return 0; } =20 -static const struct v4l2_subdev_pad_ops dcmipp_byteproc_pad_ops =3D { - .enum_mbus_code =3D dcmipp_byteproc_enum_mbus_code, - .enum_frame_size =3D dcmipp_byteproc_enum_frame_size, - .get_fmt =3D v4l2_subdev_get_fmt, - .set_fmt =3D dcmipp_byteproc_set_fmt, - .get_selection =3D dcmipp_byteproc_get_selection, - .set_selection =3D dcmipp_byteproc_set_selection, -}; - static int dcmipp_byteproc_configure_scale_crop - (struct dcmipp_byteproc_device *byteproc) + (struct dcmipp_byteproc_device *byteproc, + struct v4l2_subdev_state *state) { const struct dcmipp_byteproc_pix_map *vpix; - struct v4l2_subdev_state *state; struct v4l2_mbus_framefmt *sink_fmt; u32 hprediv, vprediv; struct v4l2_rect *compose, *crop; u32 val =3D 0; =20 - state =3D v4l2_subdev_lock_and_get_active_state(&byteproc->sd); sink_fmt =3D v4l2_subdev_state_get_format(state, 0); compose =3D v4l2_subdev_state_get_compose(state, 0); crop =3D v4l2_subdev_state_get_crop(state, 1); - v4l2_subdev_unlock_state(state); =20 /* find output format bpp */ vpix =3D dcmipp_byteproc_pix_map_by_code(sink_fmt->code); @@ -458,46 +447,73 @@ static int dcmipp_byteproc_configure_scale_crop return 0; } =20 -static int dcmipp_byteproc_s_stream(struct v4l2_subdev *sd, int enable) +static int dcmipp_byteproc_enable_streams(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, + u32 pad, u64 streams_mask) { struct dcmipp_byteproc_device *byteproc =3D v4l2_get_subdevdata(sd); struct v4l2_subdev *s_subdev; - struct media_pad *pad; - int ret =3D 0; + struct media_pad *s_pad; + int ret; =20 /* Get source subdev */ - pad =3D media_pad_remote_pad_first(&sd->entity.pads[0]); - if (!pad || !is_media_entity_v4l2_subdev(pad->entity)) + s_pad =3D media_pad_remote_pad_first(&sd->entity.pads[0]); + if (!s_pad || !is_media_entity_v4l2_subdev(s_pad->entity)) return -EINVAL; - s_subdev =3D media_entity_to_v4l2_subdev(pad->entity); - - if (enable) { - ret =3D dcmipp_byteproc_configure_scale_crop(byteproc); - if (ret) - return ret; - - ret =3D v4l2_subdev_call(s_subdev, video, s_stream, enable); - if (ret < 0) { - dev_err(byteproc->dev, - "failed to start source subdev streaming (%d)\n", - ret); - return ret; - } - } else { - ret =3D v4l2_subdev_call(s_subdev, video, s_stream, enable); - if (ret < 0) { - dev_err(byteproc->dev, - "failed to stop source subdev streaming (%d)\n", - ret); - return ret; - } + s_subdev =3D media_entity_to_v4l2_subdev(s_pad->entity); + + ret =3D dcmipp_byteproc_configure_scale_crop(byteproc, state); + if (ret) + return ret; + + ret =3D v4l2_subdev_enable_streams(s_subdev, s_pad->index, BIT_ULL(0)); + if (ret < 0) { + dev_err(byteproc->dev, + "failed to start source subdev streaming (%d)\n", ret); + return ret; } =20 return 0; } =20 +static int dcmipp_byteproc_disable_streams(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, + u32 pad, u64 streams_mask) +{ + struct dcmipp_byteproc_device *byteproc =3D v4l2_get_subdevdata(sd); + struct v4l2_subdev *s_subdev; + struct media_pad *s_pad; + int ret; + + /* Get source subdev */ + s_pad =3D media_pad_remote_pad_first(&sd->entity.pads[0]); + if (!s_pad || !is_media_entity_v4l2_subdev(s_pad->entity)) + return -EINVAL; + s_subdev =3D media_entity_to_v4l2_subdev(s_pad->entity); + + ret =3D v4l2_subdev_disable_streams(s_subdev, s_pad->index, BIT_ULL(0)); + if (ret < 0) { + dev_err(byteproc->dev, + "failed to start source subdev streaming (%d)\n", ret); + return ret; + } + + return 0; +} + +static const struct v4l2_subdev_pad_ops dcmipp_byteproc_pad_ops =3D { + .enum_mbus_code =3D dcmipp_byteproc_enum_mbus_code, + .enum_frame_size =3D dcmipp_byteproc_enum_frame_size, + .get_fmt =3D v4l2_subdev_get_fmt, + .set_fmt =3D dcmipp_byteproc_set_fmt, + .get_selection =3D dcmipp_byteproc_get_selection, + .set_selection =3D dcmipp_byteproc_set_selection, + .enable_streams =3D dcmipp_byteproc_enable_streams, + .disable_streams =3D dcmipp_byteproc_disable_streams, +}; + static const struct v4l2_subdev_video_ops dcmipp_byteproc_video_ops =3D { - .s_stream =3D dcmipp_byteproc_s_stream, + .s_stream =3D v4l2_subdev_s_stream_helper, }; =20 static const struct v4l2_subdev_ops dcmipp_byteproc_ops =3D { diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-parallel.c= b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-parallel.c index 05e8897ae37a4b6c8e16c066e83ff5b1d1e07635..823c9da336a7fc63dca2aeeb2ac= 9377821bf6371 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-parallel.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-parallel.c @@ -260,18 +260,11 @@ static int dcmipp_par_set_fmt(struct v4l2_subdev *sd, return 0; } =20 -static const struct v4l2_subdev_pad_ops dcmipp_par_pad_ops =3D { - .enum_mbus_code =3D dcmipp_par_enum_mbus_code, - .enum_frame_size =3D dcmipp_par_enum_frame_size, - .get_fmt =3D v4l2_subdev_get_fmt, - .set_fmt =3D dcmipp_par_set_fmt, -}; - -static int dcmipp_par_configure(struct dcmipp_par_device *par) +static int dcmipp_par_configure(struct dcmipp_par_device *par, + struct v4l2_subdev_state *state) { u32 val =3D 0; const struct dcmipp_par_pix_map *vpix; - struct v4l2_subdev_state *state; struct v4l2_mbus_framefmt *sink_fmt; struct v4l2_mbus_framefmt *src_fmt; =20 @@ -305,10 +298,8 @@ static int dcmipp_par_configure(struct dcmipp_par_devi= ce *par) } =20 /* Set format */ - state =3D v4l2_subdev_lock_and_get_active_state(&par->sd); sink_fmt =3D v4l2_subdev_state_get_format(state, 0); src_fmt =3D v4l2_subdev_state_get_format(state, 1); - v4l2_subdev_unlock_state(state); =20 vpix =3D dcmipp_par_pix_map_by_code(sink_fmt->code, src_fmt->code); if (!vpix) { @@ -327,53 +318,79 @@ static int dcmipp_par_configure(struct dcmipp_par_dev= ice *par) return 0; } =20 -static int dcmipp_par_s_stream(struct v4l2_subdev *sd, int enable) +static int dcmipp_par_enable_streams(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, + u32 pad, u64 streams_mask) { struct dcmipp_par_device *par =3D container_of(sd, struct dcmipp_par_device, sd); struct v4l2_subdev *s_subdev; - struct media_pad *pad; - int ret =3D 0; + struct media_pad *s_pad; + int ret; =20 /* Get source subdev */ - pad =3D media_pad_remote_pad_first(&sd->entity.pads[0]); - if (!pad || !is_media_entity_v4l2_subdev(pad->entity)) + s_pad =3D media_pad_remote_pad_first(&sd->entity.pads[0]); + if (!s_pad || !is_media_entity_v4l2_subdev(s_pad->entity)) return -EINVAL; - s_subdev =3D media_entity_to_v4l2_subdev(pad->entity); - - if (enable) { - ret =3D dcmipp_par_configure(par); - if (ret) - return ret; - - /* Enable parallel interface */ - reg_set(par, DCMIPP_PRCR, DCMIPP_PRCR_ENABLE); - - ret =3D v4l2_subdev_call(s_subdev, video, s_stream, enable); - if (ret < 0) { - dev_err(par->dev, - "failed to start source subdev streaming (%d)\n", - ret); - return ret; - } - } else { - ret =3D v4l2_subdev_call(s_subdev, video, s_stream, enable); - if (ret < 0) { - dev_err(par->dev, - "failed to stop source subdev streaming (%d)\n", - ret); - return ret; - } + s_subdev =3D media_entity_to_v4l2_subdev(s_pad->entity); + + ret =3D dcmipp_par_configure(par, state); + if (ret) + return ret; + + /* Enable parallel interface */ + reg_set(par, DCMIPP_PRCR, DCMIPP_PRCR_ENABLE); =20 - /* Disable parallel interface */ - reg_clear(par, DCMIPP_PRCR, DCMIPP_PRCR_ENABLE); + ret =3D v4l2_subdev_enable_streams(s_subdev, s_pad->index, BIT_ULL(0)); + if (ret < 0) { + dev_err(par->dev, + "failed to start source subdev streaming (%d)\n", ret); + return ret; } =20 - return ret; + return 0; } =20 +static int dcmipp_par_disable_streams(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, + u32 pad, u64 streams_mask) +{ + struct dcmipp_par_device *par =3D + container_of(sd, struct dcmipp_par_device, sd); + struct v4l2_subdev *s_subdev; + struct media_pad *s_pad; + int ret; + + /* Get source subdev */ + s_pad =3D media_pad_remote_pad_first(&sd->entity.pads[0]); + if (!s_pad || !is_media_entity_v4l2_subdev(s_pad->entity)) + return -EINVAL; + s_subdev =3D media_entity_to_v4l2_subdev(s_pad->entity); + + ret =3D v4l2_subdev_disable_streams(s_subdev, s_pad->index, BIT_ULL(0)); + if (ret < 0) { + dev_err(par->dev, + "failed to stop source subdev streaming (%d)\n", ret); + return ret; + } + + /* Disable parallel interface */ + reg_clear(par, DCMIPP_PRCR, DCMIPP_PRCR_ENABLE); + + return 0; +} + +static const struct v4l2_subdev_pad_ops dcmipp_par_pad_ops =3D { + .enum_mbus_code =3D dcmipp_par_enum_mbus_code, + .enum_frame_size =3D dcmipp_par_enum_frame_size, + .get_fmt =3D v4l2_subdev_get_fmt, + .set_fmt =3D dcmipp_par_set_fmt, + .enable_streams =3D dcmipp_par_enable_streams, + .disable_streams =3D dcmipp_par_disable_streams, +}; + static const struct v4l2_subdev_video_ops dcmipp_par_video_ops =3D { - .s_stream =3D dcmipp_par_s_stream, + .s_stream =3D v4l2_subdev_s_stream_helper, }; =20 static const struct v4l2_subdev_ops dcmipp_par_ops =3D { --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx07-00178001.pphosted.com (mx08-00178001.pphosted.com [91.207.212.93]) (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 3F7301A9B4D; Mon, 18 Nov 2024 13:40:15 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.207.212.93 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937219; cv=none; b=guT9TtDJblZzYYGYBBoZneV9DuvQREZQ0LjUsc4xyZkZ+QzJnoOh5eXr8w8sctbixUSmTtvdSbyvW66PWW4dI9jb6ARD5opjNZ7smL51BYKz9J7AXDaiN+FiXY0AJjMQpyA920OZs3cNZ4izkUT+036yYU7YqX6Z8NXm/HgRZCo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937219; c=relaxed/simple; bh=0L0wzzkDtib2Wnd8hi1ULjk1/pzs7S/3Q3eiYVfK5O8=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=lZphQtMgYT+iBpa5r2Vb/XxUEIzqu+AB12QwwshJOxi0AEkfKai1sc8pUTUjZGJ+ayJFNtylPyBTc5vq/u1gWCBp2Q+rwPtxa3cptOjugAyypKBwltVQe699dWgo80J7M7OKuLggeldjkV7zPDVRkPvG8YAiNvSU2pvFlTMmgMs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=b6VCc1uW; arc=none smtp.client-ip=91.207.212.93 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="b6VCc1uW" Received: from pps.filterd (m0046660.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AIC2gsi026244; Mon, 18 Nov 2024 14:39:58 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= j5WNgw8r9+Ld0aSEqHvq7bt6ZOBQA4a8Zivto1yf4ZA=; b=b6VCc1uWTxxzSaQG OnugvQYe/m1ktcVeOtka/SCrPCy805qi27EhIbgETc1ELHmvCbE7Eshng1YMIwAh KrIjghE3Xvg2YAS4kHrZrGqAnbEN+sFJ1eIwIFJZ12xMuKLEqAtjFw+2XtEJW8YH 1DB7S3cbzphwajy1mXapxlVtgdTTyteOrwz3jDu5mcPkGQ97x4Fha9fPtfAh0Hth 7nn0nHdKd4qrKaw8X82dEeHRusdSxwb5Fj7OASWzX3K5xCOisWnZ4l/N9m3oep9x ZoOnseeWaFaUu5MmWXyAtyPKICXnCFrQBmxJmYLcS7+iOT7kibwTmrQ7ArH9ygYK dlYFCQ== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42xkqh77pm-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:57 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id 0DC1A4005E; Mon, 18 Nov 2024 14:38:33 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id F09FA275641; Mon, 18 Nov 2024 14:35:29 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:29 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:29 +0100 Subject: [PATCH v3 06/15] media: stm32: dcmipp: rename dcmipp_parallel into dcmipp_input 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: <20241118-csi_dcmipp_mp25-v3-6-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 In preparation of the introduction of dcmipp csi input support, rename the dcmipp_parallel subdev into a generic dcmipp_input which will be in charge of handling both parallel input & csi input. Only structures / variables / functions and file naming are changed without any functional modifications. Signed-off-by: Alain Volmat --- .../media/platform/st/stm32/stm32-dcmipp/Makefile | 2 +- .../platform/st/stm32/stm32-dcmipp/dcmipp-common.h | 4 +- .../platform/st/stm32/stm32-dcmipp/dcmipp-core.c | 12 +- .../{dcmipp-parallel.c =3D> dcmipp-input.c} | 178 ++++++++++-----= ------ 4 files changed, 98 insertions(+), 98 deletions(-) diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/Makefile b/driver= s/media/platform/st/stm32/stm32-dcmipp/Makefile index 8920d9388a215757381ad7d58bd445c3ba76c792..159105fb40b88b8483368aab03f= 0170b133d4fac 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/Makefile +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/Makefile @@ -1,4 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 -stm32-dcmipp-y :=3D dcmipp-core.o dcmipp-common.o dcmipp-parallel.o dcmipp= -byteproc.o dcmipp-bytecap.o +stm32-dcmipp-y :=3D dcmipp-core.o dcmipp-common.o dcmipp-input.o dcmipp-by= teproc.o dcmipp-bytecap.o =20 obj-$(CONFIG_VIDEO_STM32_DCMIPP) +=3D stm32-dcmipp.o diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-common.h b= /drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-common.h index 7a7cf43baf24dd2b3242a191d2d8d870d26b5f58..fe5f97233f5e8bd2cd778930656= b14464f52d22f 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-common.h +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-common.h @@ -199,11 +199,11 @@ static inline void __reg_clear(struct device *dev, vo= id __iomem *base, u32 reg, } =20 /* DCMIPP subdev init / release entry points */ -struct dcmipp_ent_device *dcmipp_par_ent_init(struct device *dev, +struct dcmipp_ent_device *dcmipp_inp_ent_init(struct device *dev, const char *entity_name, struct v4l2_device *v4l2_dev, void __iomem *regs); -void dcmipp_par_ent_release(struct dcmipp_ent_device *ved); +void dcmipp_inp_ent_release(struct dcmipp_ent_device *ved); struct dcmipp_ent_device * dcmipp_byteproc_ent_init(struct device *dev, const char *entity_name, struct v4l2_device *v4l2_dev, void __iomem *regs); diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-core.c b/d= rivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-core.c index 7f771ea49b78484560af9f543e916406f4f2945e..50b9b964fbc4674b870189736a4= 9f1d6a02b2503 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-core.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-core.c @@ -95,9 +95,9 @@ struct dcmipp_pipeline_config { =20 static const struct dcmipp_ent_config stm32mp13_ent_config[] =3D { { - .name =3D "dcmipp_parallel", - .init =3D dcmipp_par_ent_init, - .release =3D dcmipp_par_ent_release, + .name =3D "dcmipp_input", + .init =3D dcmipp_inp_ent_init, + .release =3D dcmipp_inp_ent_release, }, { .name =3D "dcmipp_dump_postproc", @@ -111,12 +111,12 @@ static const struct dcmipp_ent_config stm32mp13_ent_c= onfig[] =3D { }, }; =20 -#define ID_PARALLEL 0 +#define ID_INPUT 0 #define ID_DUMP_BYTEPROC 1 #define ID_DUMP_CAPTURE 2 =20 static const struct dcmipp_ent_link stm32mp13_ent_links[] =3D { - DCMIPP_ENT_LINK(ID_PARALLEL, 1, ID_DUMP_BYTEPROC, 0, + DCMIPP_ENT_LINK(ID_INPUT, 1, ID_DUMP_BYTEPROC, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), DCMIPP_ENT_LINK(ID_DUMP_BYTEPROC, 1, ID_DUMP_CAPTURE, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), @@ -309,7 +309,7 @@ static int dcmipp_graph_notify_bound(struct v4l2_async_= notifier *notifier, } =20 /* Parallel input device detected, connect it to parallel subdev */ - sink =3D dcmipp->entity[ID_PARALLEL]; + sink =3D dcmipp->entity[ID_INPUT]; sink->bus.flags =3D vep.bus.parallel.flags; sink->bus.bus_width =3D vep.bus.parallel.bus_width; sink->bus.data_shift =3D vep.bus.parallel.data_shift; diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-parallel.c= b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-input.c similarity index 66% rename from drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-parallel.c rename to drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-input.c index 823c9da336a7fc63dca2aeeb2ac9377821bf6371..689eb4c72e1808bc30a2a175d90= 7229c0910542d 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-parallel.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-input.c @@ -34,7 +34,7 @@ #define IS_SINK(pad) (!(pad)) #define IS_SRC(pad) ((pad)) =20 -struct dcmipp_par_pix_map { +struct dcmipp_inp_pix_map { unsigned int code_sink; unsigned int code_src; u8 prcr_format; @@ -48,7 +48,7 @@ struct dcmipp_par_pix_map { .prcr_format =3D DCMIPP_PRCR_FORMAT_##prcr, \ .prcr_swapcycles =3D swap, \ } -static const struct dcmipp_par_pix_map dcmipp_par_pix_map_list[] =3D { +static const struct dcmipp_inp_pix_map dcmipp_inp_pix_map_list[] =3D { /* RGB565 */ PIXMAP_SINK_SRC_PRCR_SWAP(RGB565_2X8_LE, RGB565_2X8_LE, RGB565, 1), PIXMAP_SINK_SRC_PRCR_SWAP(RGB565_2X8_BE, RGB565_2X8_LE, RGB565, 0), @@ -74,18 +74,18 @@ static const struct dcmipp_par_pix_map dcmipp_par_pix_m= ap_list[] =3D { * Search through the pix_map table, skipping two consecutive entry with t= he * same code */ -static inline const struct dcmipp_par_pix_map *dcmipp_par_pix_map_by_index +static inline const struct dcmipp_inp_pix_map *dcmipp_inp_pix_map_by_index (unsigned int index, unsigned int pad) { unsigned int i =3D 0; u32 prev_code =3D 0, cur_code; =20 - while (i < ARRAY_SIZE(dcmipp_par_pix_map_list)) { + while (i < ARRAY_SIZE(dcmipp_inp_pix_map_list)) { if (IS_SRC(pad)) - cur_code =3D dcmipp_par_pix_map_list[i].code_src; + cur_code =3D dcmipp_inp_pix_map_list[i].code_src; else - cur_code =3D dcmipp_par_pix_map_list[i].code_sink; + cur_code =3D dcmipp_inp_pix_map_list[i].code_sink; =20 if (cur_code =3D=3D prev_code) { i++; @@ -99,32 +99,32 @@ static inline const struct dcmipp_par_pix_map *dcmipp_p= ar_pix_map_by_index index--; } =20 - if (i >=3D ARRAY_SIZE(dcmipp_par_pix_map_list)) + if (i >=3D ARRAY_SIZE(dcmipp_inp_pix_map_list)) return NULL; =20 - return &dcmipp_par_pix_map_list[i]; + return &dcmipp_inp_pix_map_list[i]; } =20 -static inline const struct dcmipp_par_pix_map *dcmipp_par_pix_map_by_code +static inline const struct dcmipp_inp_pix_map *dcmipp_inp_pix_map_by_code (u32 code_sink, u32 code_src) { unsigned int i; =20 - for (i =3D 0; i < ARRAY_SIZE(dcmipp_par_pix_map_list); i++) { - if ((dcmipp_par_pix_map_list[i].code_sink =3D=3D code_sink && - dcmipp_par_pix_map_list[i].code_src =3D=3D code_src) || - (dcmipp_par_pix_map_list[i].code_sink =3D=3D code_src && - dcmipp_par_pix_map_list[i].code_src =3D=3D code_sink) || - (dcmipp_par_pix_map_list[i].code_sink =3D=3D code_sink && + for (i =3D 0; i < ARRAY_SIZE(dcmipp_inp_pix_map_list); i++) { + if ((dcmipp_inp_pix_map_list[i].code_sink =3D=3D code_sink && + dcmipp_inp_pix_map_list[i].code_src =3D=3D code_src) || + (dcmipp_inp_pix_map_list[i].code_sink =3D=3D code_src && + dcmipp_inp_pix_map_list[i].code_src =3D=3D code_sink) || + (dcmipp_inp_pix_map_list[i].code_sink =3D=3D code_sink && code_src =3D=3D 0) || (code_sink =3D=3D 0 && - dcmipp_par_pix_map_list[i].code_src =3D=3D code_src)) - return &dcmipp_par_pix_map_list[i]; + dcmipp_inp_pix_map_list[i].code_src =3D=3D code_src)) + return &dcmipp_inp_pix_map_list[i]; } return NULL; } =20 -struct dcmipp_par_device { +struct dcmipp_inp_device { struct dcmipp_ent_device ved; struct v4l2_subdev sd; struct device *dev; @@ -142,7 +142,7 @@ static const struct v4l2_mbus_framefmt fmt_default =3D { .xfer_func =3D DCMIPP_XFER_FUNC_DEFAULT, }; =20 -static int dcmipp_par_init_state(struct v4l2_subdev *sd, +static int dcmipp_inp_init_state(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state) { unsigned int i; @@ -157,12 +157,12 @@ static int dcmipp_par_init_state(struct v4l2_subdev *= sd, return 0; } =20 -static int dcmipp_par_enum_mbus_code(struct v4l2_subdev *sd, +static int dcmipp_inp_enum_mbus_code(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_mbus_code_enum *code) { - const struct dcmipp_par_pix_map *vpix =3D - dcmipp_par_pix_map_by_index(code->index, code->pad); + const struct dcmipp_inp_pix_map *vpix =3D + dcmipp_inp_pix_map_by_index(code->index, code->pad); =20 if (!vpix) return -EINVAL; @@ -172,17 +172,17 @@ static int dcmipp_par_enum_mbus_code(struct v4l2_subd= ev *sd, return 0; } =20 -static int dcmipp_par_enum_frame_size(struct v4l2_subdev *sd, +static int dcmipp_inp_enum_frame_size(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_frame_size_enum *fse) { - const struct dcmipp_par_pix_map *vpix; + const struct dcmipp_inp_pix_map *vpix; =20 if (fse->index) return -EINVAL; =20 /* Only accept code in the pix map table */ - vpix =3D dcmipp_par_pix_map_by_code(IS_SINK(fse->pad) ? fse->code : 0, + vpix =3D dcmipp_inp_pix_map_by_code(IS_SINK(fse->pad) ? fse->code : 0, IS_SRC(fse->pad) ? fse->code : 0); if (!vpix) return -EINVAL; @@ -195,20 +195,20 @@ static int dcmipp_par_enum_frame_size(struct v4l2_sub= dev *sd, return 0; } =20 -static void dcmipp_par_adjust_fmt(struct dcmipp_par_device *par, +static void dcmipp_inp_adjust_fmt(struct dcmipp_inp_device *inp, struct v4l2_mbus_framefmt *fmt, __u32 pad) { - const struct dcmipp_par_pix_map *vpix; + const struct dcmipp_inp_pix_map *vpix; =20 /* Only accept code in the pix map table */ - vpix =3D dcmipp_par_pix_map_by_code(IS_SINK(pad) ? fmt->code : 0, + vpix =3D dcmipp_inp_pix_map_by_code(IS_SINK(pad) ? fmt->code : 0, IS_SRC(pad) ? fmt->code : 0); if (!vpix) fmt->code =3D fmt_default.code; =20 /* Exclude JPEG if BT656 bus is selected */ if (vpix && vpix->code_sink =3D=3D MEDIA_BUS_FMT_JPEG_1X8 && - par->ved.bus_type =3D=3D V4L2_MBUS_BT656) + inp->ved.bus_type =3D=3D V4L2_MBUS_BT656) fmt->code =3D fmt_default.code; =20 fmt->width =3D clamp_t(u32, fmt->width, DCMIPP_FRAME_MIN_WIDTH, @@ -222,11 +222,11 @@ static void dcmipp_par_adjust_fmt(struct dcmipp_par_d= evice *par, dcmipp_colorimetry_clamp(fmt); } =20 -static int dcmipp_par_set_fmt(struct v4l2_subdev *sd, +static int dcmipp_inp_set_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_format *fmt) { - struct dcmipp_par_device *par =3D v4l2_get_subdevdata(sd); + struct dcmipp_inp_device *inp =3D v4l2_get_subdevdata(sd); struct v4l2_mbus_framefmt *mf; =20 if (v4l2_subdev_is_streaming(sd)) @@ -235,10 +235,10 @@ static int dcmipp_par_set_fmt(struct v4l2_subdev *sd, mf =3D v4l2_subdev_state_get_format(sd_state, fmt->pad); =20 /* Set the new format */ - dcmipp_par_adjust_fmt(par, &fmt->format, fmt->pad); + dcmipp_inp_adjust_fmt(inp, &fmt->format, fmt->pad); =20 - dev_dbg(par->dev, "%s: format update: old:%dx%d (0x%x, %d, %d, %d, %d) ne= w:%dx%d (0x%x, %d, %d, %d, %d)\n", - par->sd.name, + dev_dbg(inp->dev, "%s: format update: old:%dx%d (0x%x, %d, %d, %d, %d) ne= w:%dx%d (0x%x, %d, %d, %d, %d)\n", + inp->sd.name, /* old */ mf->width, mf->height, mf->code, mf->colorspace, mf->quantization, @@ -254,30 +254,30 @@ static int dcmipp_par_set_fmt(struct v4l2_subdev *sd, if (IS_SINK(fmt->pad)) { mf =3D v4l2_subdev_state_get_format(sd_state, 1); *mf =3D fmt->format; - dcmipp_par_adjust_fmt(par, mf, 1); + dcmipp_inp_adjust_fmt(inp, mf, 1); } =20 return 0; } =20 -static int dcmipp_par_configure(struct dcmipp_par_device *par, +static int dcmipp_inp_configure(struct dcmipp_inp_device *inp, struct v4l2_subdev_state *state) { u32 val =3D 0; - const struct dcmipp_par_pix_map *vpix; + const struct dcmipp_inp_pix_map *vpix; struct v4l2_mbus_framefmt *sink_fmt; struct v4l2_mbus_framefmt *src_fmt; =20 /* Set vertical synchronization polarity */ - if (par->ved.bus.flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH) + if (inp->ved.bus.flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH) val |=3D DCMIPP_PRCR_VSPOL; =20 /* Set horizontal synchronization polarity */ - if (par->ved.bus.flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH) + if (inp->ved.bus.flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH) val |=3D DCMIPP_PRCR_HSPOL; =20 /* Set pixel clock polarity */ - if (par->ved.bus.flags & V4L2_MBUS_PCLK_SAMPLE_RISING) + if (inp->ved.bus.flags & V4L2_MBUS_PCLK_SAMPLE_RISING) val |=3D DCMIPP_PRCR_PCKPOL; =20 /* @@ -287,23 +287,23 @@ static int dcmipp_par_configure(struct dcmipp_par_dev= ice *par, * SAV=3D0xff000080 & EAV=3D0xff00009d. * With DCMIPP this means LSC=3DSAV=3D0x80 & LEC=3DEAV=3D0x9d. */ - if (par->ved.bus_type =3D=3D V4L2_MBUS_BT656) { + if (inp->ved.bus_type =3D=3D V4L2_MBUS_BT656) { val |=3D DCMIPP_PRCR_ESS; =20 /* Unmask all codes */ - reg_write(par, DCMIPP_PRESUR, 0xffffffff);/* FEC:LEC:LSC:FSC */ + reg_write(inp, DCMIPP_PRESUR, 0xffffffff);/* FEC:LEC:LSC:FSC */ =20 /* Trig on LSC=3D0x80 & LEC=3D0x9d codes, ignore FSC and FEC */ - reg_write(par, DCMIPP_PRESCR, 0xff9d80ff);/* FEC:LEC:LSC:FSC */ + reg_write(inp, DCMIPP_PRESCR, 0xff9d80ff);/* FEC:LEC:LSC:FSC */ } =20 /* Set format */ sink_fmt =3D v4l2_subdev_state_get_format(state, 0); src_fmt =3D v4l2_subdev_state_get_format(state, 1); =20 - vpix =3D dcmipp_par_pix_map_by_code(sink_fmt->code, src_fmt->code); + vpix =3D dcmipp_inp_pix_map_by_code(sink_fmt->code, src_fmt->code); if (!vpix) { - dev_err(par->dev, "Invalid sink/src format configuration\n"); + dev_err(inp->dev, "Invalid sink/src format configuration\n"); return -EINVAL; } =20 @@ -313,17 +313,17 @@ static int dcmipp_par_configure(struct dcmipp_par_dev= ice *par, if (vpix->prcr_swapcycles) val |=3D DCMIPP_PRCR_SWAPCYCLES; =20 - reg_write(par, DCMIPP_PRCR, val); + reg_write(inp, DCMIPP_PRCR, val); =20 return 0; } =20 -static int dcmipp_par_enable_streams(struct v4l2_subdev *sd, +static int dcmipp_inp_enable_streams(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, u32 pad, u64 streams_mask) { - struct dcmipp_par_device *par =3D - container_of(sd, struct dcmipp_par_device, sd); + struct dcmipp_inp_device *inp =3D + container_of(sd, struct dcmipp_inp_device, sd); struct v4l2_subdev *s_subdev; struct media_pad *s_pad; int ret; @@ -334,16 +334,16 @@ static int dcmipp_par_enable_streams(struct v4l2_subd= ev *sd, return -EINVAL; s_subdev =3D media_entity_to_v4l2_subdev(s_pad->entity); =20 - ret =3D dcmipp_par_configure(par, state); + ret =3D dcmipp_inp_configure(inp, state); if (ret) return ret; =20 /* Enable parallel interface */ - reg_set(par, DCMIPP_PRCR, DCMIPP_PRCR_ENABLE); + reg_set(inp, DCMIPP_PRCR, DCMIPP_PRCR_ENABLE); =20 ret =3D v4l2_subdev_enable_streams(s_subdev, s_pad->index, BIT_ULL(0)); if (ret < 0) { - dev_err(par->dev, + dev_err(inp->dev, "failed to start source subdev streaming (%d)\n", ret); return ret; } @@ -351,12 +351,12 @@ static int dcmipp_par_enable_streams(struct v4l2_subd= ev *sd, return 0; } =20 -static int dcmipp_par_disable_streams(struct v4l2_subdev *sd, +static int dcmipp_inp_disable_streams(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, u32 pad, u64 streams_mask) { - struct dcmipp_par_device *par =3D - container_of(sd, struct dcmipp_par_device, sd); + struct dcmipp_inp_device *inp =3D + container_of(sd, struct dcmipp_inp_device, sd); struct v4l2_subdev *s_subdev; struct media_pad *s_pad; int ret; @@ -369,86 +369,86 @@ static int dcmipp_par_disable_streams(struct v4l2_sub= dev *sd, =20 ret =3D v4l2_subdev_disable_streams(s_subdev, s_pad->index, BIT_ULL(0)); if (ret < 0) { - dev_err(par->dev, + dev_err(inp->dev, "failed to stop source subdev streaming (%d)\n", ret); return ret; } =20 /* Disable parallel interface */ - reg_clear(par, DCMIPP_PRCR, DCMIPP_PRCR_ENABLE); + reg_clear(inp, DCMIPP_PRCR, DCMIPP_PRCR_ENABLE); =20 return 0; } =20 -static const struct v4l2_subdev_pad_ops dcmipp_par_pad_ops =3D { - .enum_mbus_code =3D dcmipp_par_enum_mbus_code, - .enum_frame_size =3D dcmipp_par_enum_frame_size, +static const struct v4l2_subdev_pad_ops dcmipp_inp_pad_ops =3D { + .enum_mbus_code =3D dcmipp_inp_enum_mbus_code, + .enum_frame_size =3D dcmipp_inp_enum_frame_size, .get_fmt =3D v4l2_subdev_get_fmt, - .set_fmt =3D dcmipp_par_set_fmt, - .enable_streams =3D dcmipp_par_enable_streams, - .disable_streams =3D dcmipp_par_disable_streams, + .set_fmt =3D dcmipp_inp_set_fmt, + .enable_streams =3D dcmipp_inp_enable_streams, + .disable_streams =3D dcmipp_inp_disable_streams, }; =20 -static const struct v4l2_subdev_video_ops dcmipp_par_video_ops =3D { +static const struct v4l2_subdev_video_ops dcmipp_inp_video_ops =3D { .s_stream =3D v4l2_subdev_s_stream_helper, }; =20 -static const struct v4l2_subdev_ops dcmipp_par_ops =3D { - .pad =3D &dcmipp_par_pad_ops, - .video =3D &dcmipp_par_video_ops, +static const struct v4l2_subdev_ops dcmipp_inp_ops =3D { + .pad =3D &dcmipp_inp_pad_ops, + .video =3D &dcmipp_inp_video_ops, }; =20 -static void dcmipp_par_release(struct v4l2_subdev *sd) +static void dcmipp_inp_release(struct v4l2_subdev *sd) { - struct dcmipp_par_device *par =3D - container_of(sd, struct dcmipp_par_device, sd); + struct dcmipp_inp_device *inp =3D + container_of(sd, struct dcmipp_inp_device, sd); =20 - kfree(par); + kfree(inp); } =20 -static const struct v4l2_subdev_internal_ops dcmipp_par_int_ops =3D { - .init_state =3D dcmipp_par_init_state, - .release =3D dcmipp_par_release, +static const struct v4l2_subdev_internal_ops dcmipp_inp_int_ops =3D { + .init_state =3D dcmipp_inp_init_state, + .release =3D dcmipp_inp_release, }; =20 -void dcmipp_par_ent_release(struct dcmipp_ent_device *ved) +void dcmipp_inp_ent_release(struct dcmipp_ent_device *ved) { - struct dcmipp_par_device *par =3D - container_of(ved, struct dcmipp_par_device, ved); + struct dcmipp_inp_device *inp =3D + container_of(ved, struct dcmipp_inp_device, ved); =20 - dcmipp_ent_sd_unregister(ved, &par->sd); + dcmipp_ent_sd_unregister(ved, &inp->sd); } =20 -struct dcmipp_ent_device *dcmipp_par_ent_init(struct device *dev, +struct dcmipp_ent_device *dcmipp_inp_ent_init(struct device *dev, const char *entity_name, struct v4l2_device *v4l2_dev, void __iomem *regs) { - struct dcmipp_par_device *par; + struct dcmipp_inp_device *inp; const unsigned long pads_flag[] =3D { MEDIA_PAD_FL_SINK, MEDIA_PAD_FL_SOURCE, }; int ret; =20 - /* Allocate the par struct */ - par =3D kzalloc(sizeof(*par), GFP_KERNEL); - if (!par) + /* Allocate the inp struct */ + inp =3D kzalloc(sizeof(*inp), GFP_KERNEL); + if (!inp) return ERR_PTR(-ENOMEM); =20 - par->regs =3D regs; + inp->regs =3D regs; =20 /* Initialize ved and sd */ - ret =3D dcmipp_ent_sd_register(&par->ved, &par->sd, v4l2_dev, + ret =3D dcmipp_ent_sd_register(&inp->ved, &inp->sd, v4l2_dev, entity_name, MEDIA_ENT_F_VID_IF_BRIDGE, ARRAY_SIZE(pads_flag), pads_flag, - &dcmipp_par_int_ops, &dcmipp_par_ops, + &dcmipp_inp_int_ops, &dcmipp_inp_ops, NULL, NULL); if (ret) { - kfree(par); + kfree(inp); return ERR_PTR(ret); } =20 - par->dev =3D dev; + inp->dev =3D dev; =20 - return &par->ved; + return &inp->ved; } --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx07-00178001.pphosted.com (mx08-00178001.pphosted.com [91.207.212.93]) (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 59C6E1B982E; Mon, 18 Nov 2024 13:40:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.207.212.93 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937222; cv=none; b=X208pzobmH6sh/qwGoEvZwgtteEaW8lcaVoTsnnjzfn6QYMb6J6K0fjkx/d/ktJiL0Kpzqumb1A+dqIBLwKVmlhkndBb6bK96L3mHELH5ZnJ0DBdZOBynNtMFqGIiAxcZdxfMjkUJoq/Lg2RdtuFedmBpsm9tSVYYt9X25861+M= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937222; c=relaxed/simple; bh=RAbKXpSxicJQY5KFlUMpktE5KJy3SfEZldaI12SGjGg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=GlB/pe5bOKdR6G4A3pclBeWCm/T30fcOH3D4t0Uxj0wATa61LjnlGtiA2opc3h3SG/8NV1u6mSX7evlO+5LpsTIMVGggyOMMOxzujx4d2vtyDcTF1wMtv9Q5PTlwZJ1Z8cZTXD69sIrrJEAGXzPKoePxgALomCL/wIXiVILU14Y= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=JktS9fUb; arc=none smtp.client-ip=91.207.212.93 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="JktS9fUb" Received: from pps.filterd (m0046660.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AIDRGIJ015951; Mon, 18 Nov 2024 14:39:52 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= iHx2eom3Akmcm5QWtlSVlU1UQOIIrq4QkF16il1vv7A=; b=JktS9fUbe+jM9X4Q BYOYGWCBrPHf7Fc3IEQinBlqw7ri5yRdFwbR7xgj6CxqvKfc6WTzJpeqwRJOrOyJ Jl2yor/X1MGBRojo2YVN4fA7uHNZ/Dv7+j6V063migsgMmuWg1rf0wJNyrYRYdPL pgXDLi+gLF5cwc6LOqBlQmrf0oeWvFNxLfdrF3OM9HpktgNVnweJp5UvjkqZqPNs /fEiRrVBwVK6BCbAZBwwgc4o7ALloTXRCzcn4q/pHHPK/FFOLNYo4E+gzimotp+x tPIMUvUhJpRwxuIT3Dy1AnUasDAdzxUhl7YlNjt/lpAWjUM5eYwqu5LDp2eDyVyP cJbbew== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42xkqh77pe-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:52 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id 153614005F; Mon, 18 Nov 2024 14:38:33 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 91F38275645; Mon, 18 Nov 2024 14:35:30 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:30 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:30 +0100 Subject: [PATCH v3 07/15] media: stm32: dcmipp: add support for csi input into dcmipp-input 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: <20241118-csi_dcmipp_mp25-v3-7-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 On stm32mp25, the dcmipp can accept data coming from a CSI bus in addition to the parallel interface. Add this support into dcmipp-input subdev. Signed-off-by: Alain Volmat --- .../platform/st/stm32/stm32-dcmipp/dcmipp-input.c | 134 +++++++++++++++++= ---- 1 file changed, 110 insertions(+), 24 deletions(-) diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-input.c b/= drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-input.c index 689eb4c72e1808bc30a2a175d907229c0910542d..7e5311b67d7ea4e84dec1456c58= 491153d69ef17 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-input.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-input.c @@ -9,6 +9,7 @@ */ =20 #include +#include #include #include =20 @@ -19,6 +20,9 @@ #define DCMIPP_PRCR_FORMAT_YUV422 0x1e #define DCMIPP_PRCR_FORMAT_RGB565 0x22 #define DCMIPP_PRCR_FORMAT_RAW8 0x2a +#define DCMIPP_PRCR_FORMAT_RAW10 0x2b +#define DCMIPP_PRCR_FORMAT_RAW12 0x2c +#define DCMIPP_PRCR_FORMAT_RAW14 0x2d #define DCMIPP_PRCR_FORMAT_G8 0x4a #define DCMIPP_PRCR_FORMAT_BYTE_STREAM 0x5a #define DCMIPP_PRCR_ESS BIT(4) @@ -31,43 +35,75 @@ #define DCMIPP_PRESCR 0x108 #define DCMIPP_PRESUR 0x10c =20 +#define DCMIPP_CMCR 0x204 +#define DCMIPP_CMCR_INSEL BIT(0) + +#define DCMIPP_P0FSCR 0x404 +#define DCMIPP_P0FSCR_DTMODE_MASK GENMASK(17, 16) +#define DCMIPP_P0FSCR_DTMODE_SHIFT 16 +#define DCMIPP_P0FSCR_DTMODE_DTIDA 0x00 +#define DCMIPP_P0FSCR_DTMODE_ALLDT 0x03 +#define DCMIPP_P0FSCR_DTIDA_MASK GENMASK(5, 0) +#define DCMIPP_P0FSCR_DTIDA_SHIFT 0 + #define IS_SINK(pad) (!(pad)) #define IS_SRC(pad) ((pad)) =20 struct dcmipp_inp_pix_map { unsigned int code_sink; unsigned int code_src; + /* Parallel related information */ u8 prcr_format; u8 prcr_swapcycles; + /* CSI related information */ + unsigned int dt; }; =20 -#define PIXMAP_SINK_SRC_PRCR_SWAP(sink, src, prcr, swap) \ +#define PIXMAP_SINK_SRC_PRCR_SWAP(sink, src, prcr, swap, data_type) \ { \ .code_sink =3D MEDIA_BUS_FMT_##sink, \ .code_src =3D MEDIA_BUS_FMT_##src, \ .prcr_format =3D DCMIPP_PRCR_FORMAT_##prcr, \ .prcr_swapcycles =3D swap, \ + .dt =3D data_type, \ } static const struct dcmipp_inp_pix_map dcmipp_inp_pix_map_list[] =3D { /* RGB565 */ - PIXMAP_SINK_SRC_PRCR_SWAP(RGB565_2X8_LE, RGB565_2X8_LE, RGB565, 1), - PIXMAP_SINK_SRC_PRCR_SWAP(RGB565_2X8_BE, RGB565_2X8_LE, RGB565, 0), + PIXMAP_SINK_SRC_PRCR_SWAP(RGB565_2X8_LE, RGB565_2X8_LE, RGB565, 1, MIPI_C= SI2_DT_RGB565), + PIXMAP_SINK_SRC_PRCR_SWAP(RGB565_2X8_BE, RGB565_2X8_LE, RGB565, 0, MIPI_C= SI2_DT_RGB565), + PIXMAP_SINK_SRC_PRCR_SWAP(RGB565_1X16, RGB565_1X16, RGB565, 0, MIPI_CSI2_= DT_RGB565), /* YUV422 */ - PIXMAP_SINK_SRC_PRCR_SWAP(YUYV8_2X8, YUYV8_2X8, YUV422, 1), - PIXMAP_SINK_SRC_PRCR_SWAP(YUYV8_2X8, UYVY8_2X8, YUV422, 0), - PIXMAP_SINK_SRC_PRCR_SWAP(UYVY8_2X8, UYVY8_2X8, YUV422, 1), - PIXMAP_SINK_SRC_PRCR_SWAP(UYVY8_2X8, YUYV8_2X8, YUV422, 0), - PIXMAP_SINK_SRC_PRCR_SWAP(YVYU8_2X8, YVYU8_2X8, YUV422, 1), - PIXMAP_SINK_SRC_PRCR_SWAP(VYUY8_2X8, VYUY8_2X8, YUV422, 1), + PIXMAP_SINK_SRC_PRCR_SWAP(YUYV8_2X8, YUYV8_2X8, YUV422, 1, MIPI_CSI2_DT_Y= UV422_8B), + PIXMAP_SINK_SRC_PRCR_SWAP(YUYV8_1X16, YUYV8_1X16, YUV422, 0, MIPI_CSI2_DT= _YUV422_8B), + PIXMAP_SINK_SRC_PRCR_SWAP(YUYV8_2X8, UYVY8_2X8, YUV422, 0, MIPI_CSI2_DT_Y= UV422_8B), + PIXMAP_SINK_SRC_PRCR_SWAP(UYVY8_2X8, UYVY8_2X8, YUV422, 1, MIPI_CSI2_DT_Y= UV422_8B), + PIXMAP_SINK_SRC_PRCR_SWAP(UYVY8_1X16, UYVY8_1X16, YUV422, 0, MIPI_CSI2_DT= _YUV422_8B), + PIXMAP_SINK_SRC_PRCR_SWAP(UYVY8_2X8, YUYV8_2X8, YUV422, 0, MIPI_CSI2_DT_Y= UV422_8B), + PIXMAP_SINK_SRC_PRCR_SWAP(YVYU8_2X8, YVYU8_2X8, YUV422, 1, MIPI_CSI2_DT_Y= UV422_8B), + PIXMAP_SINK_SRC_PRCR_SWAP(YVYU8_1X16, YVYU8_1X16, YUV422, 0, MIPI_CSI2_DT= _YUV422_8B), + PIXMAP_SINK_SRC_PRCR_SWAP(VYUY8_2X8, VYUY8_2X8, YUV422, 1, MIPI_CSI2_DT_Y= UV422_8B), + PIXMAP_SINK_SRC_PRCR_SWAP(VYUY8_1X16, VYUY8_1X16, YUV422, 0, MIPI_CSI2_DT= _YUV422_8B), /* GREY */ - PIXMAP_SINK_SRC_PRCR_SWAP(Y8_1X8, Y8_1X8, G8, 0), + PIXMAP_SINK_SRC_PRCR_SWAP(Y8_1X8, Y8_1X8, G8, 0, MIPI_CSI2_DT_RAW8), /* Raw Bayer */ - PIXMAP_SINK_SRC_PRCR_SWAP(SBGGR8_1X8, SBGGR8_1X8, RAW8, 0), - PIXMAP_SINK_SRC_PRCR_SWAP(SGBRG8_1X8, SGBRG8_1X8, RAW8, 0), - PIXMAP_SINK_SRC_PRCR_SWAP(SGRBG8_1X8, SGRBG8_1X8, RAW8, 0), - PIXMAP_SINK_SRC_PRCR_SWAP(SRGGB8_1X8, SRGGB8_1X8, RAW8, 0), + PIXMAP_SINK_SRC_PRCR_SWAP(SBGGR8_1X8, SBGGR8_1X8, RAW8, 0, MIPI_CSI2_DT_R= AW8), + PIXMAP_SINK_SRC_PRCR_SWAP(SGBRG8_1X8, SGBRG8_1X8, RAW8, 0, MIPI_CSI2_DT_R= AW8), + PIXMAP_SINK_SRC_PRCR_SWAP(SGRBG8_1X8, SGRBG8_1X8, RAW8, 0, MIPI_CSI2_DT_R= AW8), + PIXMAP_SINK_SRC_PRCR_SWAP(SRGGB8_1X8, SRGGB8_1X8, RAW8, 0, MIPI_CSI2_DT_R= AW8), + PIXMAP_SINK_SRC_PRCR_SWAP(SBGGR10_1X10, SBGGR10_1X10, RAW10, 0, MIPI_CSI2= _DT_RAW10), + PIXMAP_SINK_SRC_PRCR_SWAP(SGBRG10_1X10, SGBRG10_1X10, RAW10, 0, MIPI_CSI2= _DT_RAW10), + PIXMAP_SINK_SRC_PRCR_SWAP(SGRBG10_1X10, SGRBG10_1X10, RAW10, 0, MIPI_CSI2= _DT_RAW10), + PIXMAP_SINK_SRC_PRCR_SWAP(SRGGB10_1X10, SRGGB10_1X10, RAW10, 0, MIPI_CSI2= _DT_RAW10), + PIXMAP_SINK_SRC_PRCR_SWAP(SBGGR12_1X12, SBGGR12_1X12, RAW12, 0, MIPI_CSI2= _DT_RAW12), + PIXMAP_SINK_SRC_PRCR_SWAP(SGBRG12_1X12, SGBRG12_1X12, RAW12, 0, MIPI_CSI2= _DT_RAW12), + PIXMAP_SINK_SRC_PRCR_SWAP(SGRBG12_1X12, SGRBG12_1X12, RAW12, 0, MIPI_CSI2= _DT_RAW12), + PIXMAP_SINK_SRC_PRCR_SWAP(SRGGB12_1X12, SRGGB12_1X12, RAW12, 0, MIPI_CSI2= _DT_RAW12), + PIXMAP_SINK_SRC_PRCR_SWAP(SBGGR14_1X14, SBGGR14_1X14, RAW14, 0, MIPI_CSI2= _DT_RAW14), + PIXMAP_SINK_SRC_PRCR_SWAP(SGBRG14_1X14, SGBRG14_1X14, RAW14, 0, MIPI_CSI2= _DT_RAW14), + PIXMAP_SINK_SRC_PRCR_SWAP(SGRBG14_1X14, SGRBG14_1X14, RAW14, 0, MIPI_CSI2= _DT_RAW14), + PIXMAP_SINK_SRC_PRCR_SWAP(SRGGB14_1X14, SRGGB14_1X14, RAW14, 0, MIPI_CSI2= _DT_RAW14), /* JPEG */ - PIXMAP_SINK_SRC_PRCR_SWAP(JPEG_1X8, JPEG_1X8, BYTE_STREAM, 0), + PIXMAP_SINK_SRC_PRCR_SWAP(JPEG_1X8, JPEG_1X8, BYTE_STREAM, 0, 0), }; =20 /* @@ -260,8 +296,8 @@ static int dcmipp_inp_set_fmt(struct v4l2_subdev *sd, return 0; } =20 -static int dcmipp_inp_configure(struct dcmipp_inp_device *inp, - struct v4l2_subdev_state *state) +static int dcmipp_inp_configure_parallel(struct dcmipp_inp_device *inp, + struct v4l2_subdev_state *state) { u32 val =3D 0; const struct dcmipp_inp_pix_map *vpix; @@ -315,6 +351,52 @@ static int dcmipp_inp_configure(struct dcmipp_inp_devi= ce *inp, =20 reg_write(inp, DCMIPP_PRCR, val); =20 + /* Select the DCMIPP parallel interface */ + reg_write(inp, DCMIPP_CMCR, 0); + + /* Enable parallel interface */ + reg_set(inp, DCMIPP_PRCR, DCMIPP_PRCR_ENABLE); + + return 0; +} + +static int dcmipp_inp_configure_csi(struct dcmipp_inp_device *inp, + struct v4l2_subdev_state *state) +{ + const struct dcmipp_inp_pix_map *vpix; + struct v4l2_mbus_framefmt *sink_fmt; + struct v4l2_mbus_framefmt *src_fmt; + + /* Get format information */ + sink_fmt =3D v4l2_subdev_state_get_format(state, 0); + src_fmt =3D v4l2_subdev_state_get_format(state, 1); + + vpix =3D dcmipp_inp_pix_map_by_code(sink_fmt->code, src_fmt->code); + if (!vpix) { + dev_err(inp->dev, "Invalid sink/src format configuration\n"); + return -EINVAL; + } + + /* Apply configuration on each input pipe */ + reg_clear(inp, DCMIPP_P0FSCR, + DCMIPP_P0FSCR_DTMODE_MASK | DCMIPP_P0FSCR_DTIDA_MASK); + + /* In case of JPEG we don't know the DT so we allow all data */ + /* + * TODO - check instead dt =3D=3D 0 for the time being to allow other + * unknown data-type + */ + if (!vpix->dt) + reg_set(inp, DCMIPP_P0FSCR, + DCMIPP_P0FSCR_DTMODE_ALLDT << DCMIPP_P0FSCR_DTMODE_SHIFT); + else + reg_set(inp, DCMIPP_P0FSCR, + vpix->dt << DCMIPP_P0FSCR_DTIDA_SHIFT | + DCMIPP_P0FSCR_DTMODE_DTIDA); + + /* Select the DCMIPP CSI interface */ + reg_write(inp, DCMIPP_CMCR, DCMIPP_CMCR_INSEL); + return 0; } =20 @@ -326,7 +408,7 @@ static int dcmipp_inp_enable_streams(struct v4l2_subdev= *sd, container_of(sd, struct dcmipp_inp_device, sd); struct v4l2_subdev *s_subdev; struct media_pad *s_pad; - int ret; + int ret =3D 0; =20 /* Get source subdev */ s_pad =3D media_pad_remote_pad_first(&sd->entity.pads[0]); @@ -334,13 +416,14 @@ static int dcmipp_inp_enable_streams(struct v4l2_subd= ev *sd, return -EINVAL; s_subdev =3D media_entity_to_v4l2_subdev(s_pad->entity); =20 - ret =3D dcmipp_inp_configure(inp, state); + if (inp->ved.bus_type =3D=3D V4L2_MBUS_PARALLEL || + inp->ved.bus_type =3D=3D V4L2_MBUS_BT656) + ret =3D dcmipp_inp_configure_parallel(inp, state); + else if (inp->ved.bus_type =3D=3D V4L2_MBUS_CSI2_DPHY) + ret =3D dcmipp_inp_configure_csi(inp, state); if (ret) return ret; =20 - /* Enable parallel interface */ - reg_set(inp, DCMIPP_PRCR, DCMIPP_PRCR_ENABLE); - ret =3D v4l2_subdev_enable_streams(s_subdev, s_pad->index, BIT_ULL(0)); if (ret < 0) { dev_err(inp->dev, @@ -374,8 +457,11 @@ static int dcmipp_inp_disable_streams(struct v4l2_subd= ev *sd, return ret; } =20 - /* Disable parallel interface */ - reg_clear(inp, DCMIPP_PRCR, DCMIPP_PRCR_ENABLE); + if (inp->ved.bus_type =3D=3D V4L2_MBUS_PARALLEL || + inp->ved.bus_type =3D=3D V4L2_MBUS_BT656) { + /* Disable parallel interface */ + reg_clear(inp, DCMIPP_PRCR, DCMIPP_PRCR_ENABLE); + } =20 return 0; } --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx07-00178001.pphosted.com (mx08-00178001.pphosted.com [91.207.212.93]) (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 6D6C21A0B05; Mon, 18 Nov 2024 13:40:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.207.212.93 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937216; cv=none; b=mj53wd0WbY7Z3tqnc1KXXgnhfYrLmOGxaKQz+8BK6Wj2t1pk1f5Gs0Vfw1ILOpeJLYLQF1647gcyEV2yDhRydJiFRDjAa8h+vHIqiOjS6rXphJBKBboHBxuAG3SXTszylGF0bWed7PlvSIrex1kZcdJR20kAOpueNRW0ZTMzaIo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937216; c=relaxed/simple; bh=a1OVlPf5Odsut2kjBhNTJuvJTaMz6Fm/zZor5eKkscE=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=VAUcG+eHnkX5icxanzchlFjkEoAynwS+3HYFqydOSJ/Bbh2PK9L8VJ5ZyzgTfKgOSIw56RHPr9/UG/wSqbYAGVSN8++vtLU9u8b3AZ2UMEI1Y1hA0rj1X9HA5Idi7RPfWOQ1K9Doy2+MHBtClLoekFcBKvXA7pABb8uZbUhcqgU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=TDdKmm2/; arc=none smtp.client-ip=91.207.212.93 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="TDdKmm2/" Received: from pps.filterd (m0046661.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AIBDkP6027114; Mon, 18 Nov 2024 14:39:52 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= kO/XdeoBo7X02W334+E6LhxLlDrGOL8A5vE8mC37cg8=; b=TDdKmm2/csD8ICFl s9jjVnrmzUOwf/krJUiDOGR6VQdbkDtIoEsdHsq1bUfYk4CiE6ZVb8RFTvos5QxM UpzQ0yBHOKY4xpRxVs4N9C+hfcxgVucgAA+0sqZNg8+nfVwjkBcImmA7k7dKXxcW ucnUn2ph2RKqHVvFL9iyXbQGBMOAV0y7zDYMvxai/r6f1jzSvJf+WBZL97XLA7LF aILmlHKesQniNIH/GuM9hXsCIujbSgVxSuO7pMZZF+J3ccTNUcATBMYcRiQ81ziL Y0Nl7WRMl8IhmvFCVBgwN9vrEjOoODvqt3/q4BDV5zwbCa4tVjIydfxgpGyMBoQE NMPw9w== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42xkqeq7s2-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:52 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id 65AF140060; Mon, 18 Nov 2024 14:38:33 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 30BAD27564C; Mon, 18 Nov 2024 14:35:31 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:30 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:31 +0100 Subject: [PATCH v3 08/15] media: stm32: dcmipp: add bayer 10~14 bits formats 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: <20241118-csi_dcmipp_mp25-v3-8-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 Add support for bayer formats from 10 to 14 bits. Signed-off-by: Alain Volmat --- .../media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c | 12 ++++++++= ++++ .../media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c | 12 ++++++++= ++++ 2 files changed, 24 insertions(+) diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c = b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c index 48596592bfd517b9d46946d27f154f0d17ebed78..d6fad99e44bba5bcab1df056ba9= 208e82aff4bea 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c @@ -65,6 +65,18 @@ static const struct dcmipp_bytecap_pix_map dcmipp_byteca= p_pix_map_list[] =3D { PIXMAP_MBUS_PFMT(SGBRG8_1X8, SGBRG8), PIXMAP_MBUS_PFMT(SGRBG8_1X8, SGRBG8), PIXMAP_MBUS_PFMT(SRGGB8_1X8, SRGGB8), + PIXMAP_MBUS_PFMT(SBGGR10_1X10, SBGGR10), + PIXMAP_MBUS_PFMT(SGBRG10_1X10, SGBRG10), + PIXMAP_MBUS_PFMT(SGRBG10_1X10, SGRBG10), + PIXMAP_MBUS_PFMT(SRGGB10_1X10, SRGGB10), + PIXMAP_MBUS_PFMT(SBGGR12_1X12, SBGGR12), + PIXMAP_MBUS_PFMT(SGBRG12_1X12, SGBRG12), + PIXMAP_MBUS_PFMT(SGRBG12_1X12, SGRBG12), + PIXMAP_MBUS_PFMT(SRGGB12_1X12, SRGGB12), + PIXMAP_MBUS_PFMT(SBGGR14_1X14, SBGGR14), + PIXMAP_MBUS_PFMT(SGBRG14_1X14, SGBRG14), + PIXMAP_MBUS_PFMT(SGRBG14_1X14, SGRBG14), + PIXMAP_MBUS_PFMT(SRGGB14_1X14, SRGGB14), PIXMAP_MBUS_PFMT(JPEG_1X8, JPEG), }; =20 diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c= b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c index a19c8235af565fb5f673ba90b37ebfcadf03d72e..72f1bb4c64ad4c194c14467dfc3= 54a04bc69e208 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c @@ -57,6 +57,18 @@ static const struct dcmipp_byteproc_pix_map dcmipp_bytep= roc_pix_map_list[] =3D { PIXMAP_MBUS_BPP(SGBRG8_1X8, 1), PIXMAP_MBUS_BPP(SGRBG8_1X8, 1), PIXMAP_MBUS_BPP(SRGGB8_1X8, 1), + PIXMAP_MBUS_BPP(SBGGR10_1X10, 2), + PIXMAP_MBUS_BPP(SGBRG10_1X10, 2), + PIXMAP_MBUS_BPP(SGRBG10_1X10, 2), + PIXMAP_MBUS_BPP(SRGGB10_1X10, 2), + PIXMAP_MBUS_BPP(SBGGR12_1X12, 2), + PIXMAP_MBUS_BPP(SGBRG12_1X12, 2), + PIXMAP_MBUS_BPP(SGRBG12_1X12, 2), + PIXMAP_MBUS_BPP(SRGGB12_1X12, 2), + PIXMAP_MBUS_BPP(SBGGR14_1X14, 2), + PIXMAP_MBUS_BPP(SGBRG14_1X14, 2), + PIXMAP_MBUS_BPP(SGRBG14_1X14, 2), + PIXMAP_MBUS_BPP(SRGGB14_1X14, 2), PIXMAP_MBUS_BPP(JPEG_1X8, 1), }; =20 --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx07-00178001.pphosted.com (mx07-00178001.pphosted.com [185.132.182.106]) (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 7DADC1A08B6; Mon, 18 Nov 2024 13:40:13 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=185.132.182.106 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937215; cv=none; b=Jh2mLLRlG6o0Xv1FGSZutXLuq1/HzFvX8FQMC4Uy8Znunpyn6A5seXmcFlJvZqK4GJFOPZMp71Eqy0D2vuXsdT7YP9yrOsST496TOngXQ2Mgrzii8ho2c4JZxErAUuBkSPhEdPZZScUSoxXQhEG46T3yr/aEsntS08kgo3aBNN8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937215; c=relaxed/simple; bh=I7l3/M2qaiyoegFrTjSIvWPFvYUUxhxa8ZQTpsAoRBY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=t1AIKgddQp2qjL+WQ3tMW8mSVlk0335oLw0UDik9fuw/cTbNNqR1WFjjKP5kEDPp4Xoqf/ZdC/+48AzLTBINIPdAhlKjbL01zPOOvq+1ITAjmavIUMVOWg2ofq5oZXb3/h0cDBmTaBNN1bTCgctee9Y+/m1POmoi/eAgZ6LrEto= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=ceGhG0/o; arc=none smtp.client-ip=185.132.182.106 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="ceGhG0/o" Received: from pps.filterd (m0288072.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AIBWj5G006648; Mon, 18 Nov 2024 14:39:52 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= CljfqA+tRNBhppv+/47HW/+wKiyeRMWC8XV1LMidIbQ=; b=ceGhG0/oMDAZzn09 fHYpZU+nk03UDXUas7ZgVvweSWqHHTQZaWQA7YLnEu+7RMSrW46Zddnh5Saox0MM QpT7rWXRAJ4+VUSZF2VOxlvXSRlrlrBxZ4BRUkeO9v/car7pSThpXLrjnIckMv1y T0stgRMJSCyIVMB8j3Q5ujdEefCRxNL4L+fS3zfuVfgWAMdrHOqIgJNES9eYSME9 OB1KIiGCKA5FPc9dNyFaBezScakGrmMzFE1mYsz0MJBmCV6OTLOxvDcFpdEoj0R/ U9yxPCEcQrB2H7Mod8hev2687iSaFKitBBAcDIJ+kdBNF+yDblLrb0TwSBYgJide 82BVNQ== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42xknvyh8x-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:52 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id 7BCCA40062; Mon, 18 Nov 2024 14:38:33 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id C4DC4275651; Mon, 18 Nov 2024 14:35:31 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:31 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:32 +0100 Subject: [PATCH v3 09/15] media: stm32: dcmipp: add 1X16 RGB / YUV formats support 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: <20241118-csi_dcmipp_mp25-v3-9-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 Add 1X16 RGB & YUV formats support within bytecap & byteproc. Slightly change the link_validate function to be able to validate against either 1X16 or 2X8 variant of a format. Signed-off-by: Alain Volmat --- .../st/stm32/stm32-dcmipp/dcmipp-bytecap.c | 23 ++++++++++++++++--= ---- .../st/stm32/stm32-dcmipp/dcmipp-byteproc.c | 5 +++++ 2 files changed, 22 insertions(+), 6 deletions(-) diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c = b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c index d6fad99e44bba5bcab1df056ba9208e82aff4bea..99732d19dc4d5f4692588118ead= b236d4ed9c8a1 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c @@ -56,10 +56,15 @@ struct dcmipp_bytecap_pix_map { =20 static const struct dcmipp_bytecap_pix_map dcmipp_bytecap_pix_map_list[] = =3D { PIXMAP_MBUS_PFMT(RGB565_2X8_LE, RGB565), + PIXMAP_MBUS_PFMT(RGB565_1X16, RGB565), PIXMAP_MBUS_PFMT(YUYV8_2X8, YUYV), + PIXMAP_MBUS_PFMT(YUYV8_1X16, YUYV), PIXMAP_MBUS_PFMT(YVYU8_2X8, YVYU), + PIXMAP_MBUS_PFMT(YVYU8_1X16, YVYU), PIXMAP_MBUS_PFMT(UYVY8_2X8, UYVY), + PIXMAP_MBUS_PFMT(UYVY8_1X16, UYVY), PIXMAP_MBUS_PFMT(VYUY8_2X8, VYUY), + PIXMAP_MBUS_PFMT(VYUY8_1X16, VYUY), PIXMAP_MBUS_PFMT(Y8_1X8, GREY), PIXMAP_MBUS_PFMT(SBGGR8_1X8, SBGGR8), PIXMAP_MBUS_PFMT(SGBRG8_1X8, SGBRG8), @@ -819,8 +824,7 @@ static int dcmipp_bytecap_link_validate(struct media_li= nk *link) .which =3D V4L2_SUBDEV_FORMAT_ACTIVE, .pad =3D link->source->index, }; - const struct dcmipp_bytecap_pix_map *vpix; - int ret; + int ret, i; =20 ret =3D v4l2_subdev_call(source_sd, pad, get_fmt, NULL, &source_fmt); if (ret < 0) @@ -834,10 +838,17 @@ static int dcmipp_bytecap_link_validate(struct media_= link *link) return -EINVAL; } =20 - vpix =3D dcmipp_bytecap_pix_map_by_pixelformat(vcap->format.pixelformat); - if (source_fmt.format.code !=3D vpix->code) { - dev_err(vcap->dev, "Wrong mbus_code 0x%x, (0x%x expected)\n", - vpix->code, source_fmt.format.code); + for (i =3D 0; i < ARRAY_SIZE(dcmipp_bytecap_pix_map_list); i++) { + if (dcmipp_bytecap_pix_map_list[i].pixelformat =3D=3D + vcap->format.pixelformat && + dcmipp_bytecap_pix_map_list[i].code =3D=3D + source_fmt.format.code) + break; + } + + if (i =3D=3D ARRAY_SIZE(dcmipp_bytecap_pix_map_list)) { + dev_err(vcap->dev, "mbus code 0x%x do not match capture device format (0= x%x)\n", + vcap->format.pixelformat, source_fmt.format.code); return -EINVAL; } =20 diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c= b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c index 72f1bb4c64ad4c194c14467dfc354a04bc69e208..3c742a546441e190b7d93d5e940= 1d6824acf509b 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-byteproc.c @@ -48,10 +48,15 @@ struct dcmipp_byteproc_pix_map { } static const struct dcmipp_byteproc_pix_map dcmipp_byteproc_pix_map_list[]= =3D { PIXMAP_MBUS_BPP(RGB565_2X8_LE, 2), + PIXMAP_MBUS_BPP(RGB565_1X16, 2), PIXMAP_MBUS_BPP(YUYV8_2X8, 2), + PIXMAP_MBUS_BPP(YUYV8_1X16, 2), PIXMAP_MBUS_BPP(YVYU8_2X8, 2), + PIXMAP_MBUS_BPP(YVYU8_1X16, 2), PIXMAP_MBUS_BPP(UYVY8_2X8, 2), + PIXMAP_MBUS_BPP(UYVY8_1X16, 2), PIXMAP_MBUS_BPP(VYUY8_2X8, 2), + PIXMAP_MBUS_BPP(VYUY8_1X16, 2), PIXMAP_MBUS_BPP(Y8_1X8, 1), PIXMAP_MBUS_BPP(SBGGR8_1X8, 1), PIXMAP_MBUS_BPP(SGBRG8_1X8, 1), --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx08-00178001.pphosted.com (mx08-00178001.pphosted.com [91.207.212.93]) (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 59BB71B86DC; Mon, 18 Nov 2024 13:40:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.207.212.93 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937221; cv=none; b=UQCOi4l4MesiNl6nEpJV/RliYE0omfbBGrG1wjaGx5d9M2onBKrBbyw/Uu40+PXjPRIMOBDae3Uijw7FFIWizif+XFPy4wmcM00WMAq3TbRNykLQ5LsER74dwTv5xA+RsTDJP0csmBZOu1R/hdt9/p3Tu2UqeinXdngh6Zy69YQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937221; c=relaxed/simple; bh=Qp2LhD+mvheCt9M8icvw5D+LfrU+/8Xoq/mwVn1OEFI=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=lbWS8PFmA968mGdOfi27UCpg3ruRnc7D5RT32AvD9O+EXV/e45YhIz/X42LHVGiwc4ZfZ1eh8nHBvr/su+68v7kO4EPrT4mAbFiQ2uAczJPeQmdoRd1RX16QUUG2E1RpYZXTVC0mNGfYnw1D79tVVuJXTDn9p643Z+df2lt9inU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=0jSLLrLH; arc=none smtp.client-ip=91.207.212.93 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="0jSLLrLH" Received: from pps.filterd (m0369457.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AIBUIsZ010521; Mon, 18 Nov 2024 14:39:53 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= VXDDwUFZyaE/RsM7y+LjqGPAbZCI0j8Q6ZVfXNBJ3xs=; b=0jSLLrLH76MZWCQf 4R4UlggCkN7lTg800E5B4mO6wX8eAYEClZJR5gEsqYzbTgAF3wzMVbu/zBMoGLkB keies0quVzK1vI6zqkEJ8qsRZ2P9OrY5CzSfMV2mOoxrBJIqh8Wv27K1ineOzTD2 NyswxktFSI8hc45PQl4WvosWh/XjdelGfXhoaMhm4pjQjVrhz0mLCIzSJ56M0f7M rFe/eVmESrH5IekAdvKNksmVA16ffXOd2JiKbFG6/e3sBkl77bC4wmVdrcD1tQJk oEB0QJ7Bml090fqMSWS+dsRxYbHDxPPloBuCT202+Dzwe9Av8Xy06JX+ORMKm+uv sBwHRg== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42y77n504t-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:52 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id 7225C40061; Mon, 18 Nov 2024 14:38:33 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 6135C275655; Mon, 18 Nov 2024 14:35:32 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:32 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:33 +0100 Subject: [PATCH v3 10/15] media: stm32: dcmipp: avoid duplicated format on enum in bytecap 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: <20241118-csi_dcmipp_mp25-v3-10-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 Avoid duplication of enumerated pixelformat on the bytecap video capture device. Indeed, since the bytecap format list contains both CSI & parallel 16bits formats, ensure that same pixelformat are not reported twice when performing enumeration of supported formats. Signed-off-by: Alain Volmat --- .../st/stm32/stm32-dcmipp/dcmipp-bytecap.c | 42 +++++++++++-------= ---- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c = b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c index 99732d19dc4d5f4692588118eadb236d4ed9c8a1..8f5f69a3afc413b49d82303cd4d= 98da15f62e34d 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c @@ -268,34 +268,34 @@ static int dcmipp_bytecap_enum_fmt_vid_cap(struct fil= e *file, void *priv, { const struct dcmipp_bytecap_pix_map *vpix; unsigned int index =3D f->index; - unsigned int i; + unsigned int i, prev_pixelformat =3D 0; =20 - if (f->mbus_code) { - /* - * If a media bus code is specified, only enumerate formats - * compatible with it. - */ - for (i =3D 0; i < ARRAY_SIZE(dcmipp_bytecap_pix_map_list); i++) { - vpix =3D &dcmipp_bytecap_pix_map_list[i]; - if (vpix->code !=3D f->mbus_code) - continue; + /* + * List up all formats (or only ones matching f->mbus_code), taking + * care of removing duplicated entries (due to support of both + * parallel & csi 16 bits formats + */ + for (i =3D 0; i < ARRAY_SIZE(dcmipp_bytecap_pix_map_list); i++) { + vpix =3D &dcmipp_bytecap_pix_map_list[i]; + /* Skip formats not matching requested mbus code */ + if (f->mbus_code && vpix->code !=3D f->mbus_code) + continue; =20 - if (index =3D=3D 0) - break; + /* Skip duplicated pixelformat */ + if (vpix->pixelformat =3D=3D prev_pixelformat) + continue; =20 - index--; - } + prev_pixelformat =3D vpix->pixelformat; =20 - if (i =3D=3D ARRAY_SIZE(dcmipp_bytecap_pix_map_list)) - return -EINVAL; - } else { - /* Otherwise, enumerate all formats. */ - if (f->index >=3D ARRAY_SIZE(dcmipp_bytecap_pix_map_list)) - return -EINVAL; + if (index =3D=3D 0) + break; =20 - vpix =3D &dcmipp_bytecap_pix_map_list[f->index]; + index--; } =20 + if (i =3D=3D ARRAY_SIZE(dcmipp_bytecap_pix_map_list)) + return -EINVAL; + f->pixelformat =3D vpix->pixelformat; =20 return 0; --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx07-00178001.pphosted.com (mx07-00178001.pphosted.com [185.132.182.106]) (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 5DDA1881E; Mon, 18 Nov 2024 13:40:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=185.132.182.106 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937215; cv=none; b=eg8qtP0OvKfX0OYBnsBlgT0Rt2QOpFhNCk5fDN6XbYCx4u3qr7Sbbt9ak6l7pXv8xeJXUa/z1a13A5My7OzR5XwTKaCGw3nkkuk1Yzq4qV5ImrvkmG6x6/D4b9H1+Dl2CGEkzmyjtMnnxBRF/nUbagVyNWebVWi19K3Q60qxakk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937215; c=relaxed/simple; bh=GOKG+WYlTeedFL3kFxhYDlA0nfvxaCGr7DSSSCv1Y2E=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=luXcbEOc/8WXngwqbJodhoxp5tvUC5ACbSDo9IkDCgL42Zcbq7bV6vht2633Xb9iA5tIk6Yks4HEy9bMzuCGjOwEDYqVLuAuZ92HjV2SeW8fwIiz1v5Vj7UqXzNk0J44CatVmgC2xWhXpdc8dXwGXicb4pLMPIHAOAc7vOraEUY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=CpJJSK4G; arc=none smtp.client-ip=185.132.182.106 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="CpJJSK4G" Received: from pps.filterd (m0288072.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AID5lPf003253; Mon, 18 Nov 2024 14:39:52 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= UMjisKeEpQSwI1Wvbjb6PN1AjDm43YkTXsgIuNYi82g=; b=CpJJSK4GczB4Whmm EyhcTzi7W6Q17/ykcRA3pLJvvAsd+/gT8Oe4Rwc9tQrRRaz4f6iTK4GzVjvxVzdM anriOsTirrOisSTXQbJU/+n2xcmCyqpBcrm5wHBbdv9UrhgqxXYvolygRtWz3U+V VFAKPEchRP/WeTEOVNUk7UiZL5rLu9kGFVLVfjh4ae2Gz9LFdLsUAPOCr+kt5Uay jP7vkCYLf1n7rcdNINyeWRo4L5t+bVqTCAKukkhAP+ZiwmC9BHVRKeKSWwwReZoj OZt3fe98OIcGp3WYKfkcYpPMQUTR8FL/C4aG7F9eF6YRz55YdoAm++On+neWTr3P wtF1Yg== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42xknvyh8y-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:52 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id 8629C40063; Mon, 18 Nov 2024 14:38:33 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 01D16275656; Mon, 18 Nov 2024 14:35:33 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:32 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:34 +0100 Subject: [PATCH v3 11/15] media: stm32: dcmipp: fill media ctl hw_revision field 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: <20241118-csi_dcmipp_mp25-v3-11-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 Add hw_revision field information of the media controller so that application can distinguish between variants of DCMIPP implementations. Signed-off-by: Alain Volmat --- drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-core.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-core.c b/d= rivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-core.c index 50b9b964fbc4674b870189736a49f1d6a02b2503..d2cc19bb40d77f67a1f5fe565bc= 62f45eff2d266 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-core.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-core.c @@ -87,6 +87,7 @@ struct dcmipp_pipeline_config { size_t num_ents; const struct dcmipp_ent_link *links; size_t num_links; + u32 hw_revision; }; =20 /* -----------------------------------------------------------------------= --- @@ -122,11 +123,13 @@ static const struct dcmipp_ent_link stm32mp13_ent_lin= ks[] =3D { MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), }; =20 +#define DCMIPP_STM32MP13_VERR 0x10 static const struct dcmipp_pipeline_config stm32mp13_pipe_cfg =3D { .ents =3D stm32mp13_ent_config, .num_ents =3D ARRAY_SIZE(stm32mp13_ent_config), .links =3D stm32mp13_ent_links, - .num_links =3D ARRAY_SIZE(stm32mp13_ent_links) + .num_links =3D ARRAY_SIZE(stm32mp13_ent_links), + .hw_revision =3D DCMIPP_STM32MP13_VERR }; =20 #define LINK_FLAG_TO_STR(f) ((f) =3D=3D 0 ? "" :\ @@ -496,6 +499,7 @@ static int dcmipp_probe(struct platform_device *pdev) /* Initialize media device */ strscpy(dcmipp->mdev.model, DCMIPP_MDEV_MODEL_NAME, sizeof(dcmipp->mdev.model)); + dcmipp->mdev.hw_revision =3D pipe_cfg->hw_revision; dcmipp->mdev.dev =3D &pdev->dev; media_device_init(&dcmipp->mdev); =20 --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx07-00178001.pphosted.com (mx07-00178001.pphosted.com [185.132.182.106]) (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 85C801BC077; Mon, 18 Nov 2024 13:40:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=185.132.182.106 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937222; cv=none; b=PWtm9Ol4F0dbRczXt7QACnmpzZbikoiiMC3SHFZrpSqS1Ge6V3/RcJ0Pvoh0asNEvz3KUfl4VyeQ9aK37mG3/ufFHLZHE0614KCa5UXykJZ5nkGIXn7UxNzHSJ/nEuoRehkuH7JWPYyayaI5sCQ2BdDqNyVZjKrLItmsDeM5Lus= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937222; c=relaxed/simple; bh=ubFYdCEynD+lJZJLcz94poeTz7a2f/6tf8zufGEHQJ0=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=WRCcqeM7gWVx64qz3apoqnG/Pyi7QUEJe42CVRTIbTFo/2XchPA8TYvc3Us+vM4YgYWUjL6SFNmIICiVz7GshnOW0L+nDDXkVyd03ErFG8DxrxZxi31bNWeKFJaZksTmjcid1AZY1o4wzsQ+OLJKAnmqfoXfywkFN0eQAYh5VKM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=byk/hIN/; arc=none smtp.client-ip=185.132.182.106 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="byk/hIN/" Received: from pps.filterd (m0288072.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AID4PQs027884; Mon, 18 Nov 2024 14:40:06 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= CA9mLyN7QIrUDL6u8u0tTlS47U1mfv8GbnJkKf4gDkY=; b=byk/hIN//Z6cQnEq cXiYBfHP0AwT0GuR8ewTds/hbu3xcKzZRw83i1AVb5I8i3wV6vQwu7JX80zKm0r/ 9YF7/nkQR0ZL/4PtQCqxDULwPGYSyOCN1raWInE6sNkRegKGEuAzAxk48jTrv3kz rM3qJ6eQR2AZ4ULn8VoYNSh3rZG6S0EJd89Syf/mJ1dvlEdIacn7bmmWq9Jdd1AM DrJl2Aq7Tbb9vFEjb7RIKYAm3pOrcY1oOHluwLiZiCEiaV4CYeCHbLvprTge8Fmk IUszVlzWWPHJ1vi14VNgE/AIOCWc7OF4oeVdvAlRWwAy7zOJhL2/Lm699Otrcjsn /fWK1g== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42xknvyh9q-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:40:05 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id 8DB1340049; Mon, 18 Nov 2024 14:38:36 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 925BD276BB9; Mon, 18 Nov 2024 14:35:33 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:33 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:35 +0100 Subject: [PATCH v3 12/15] dt-bindings: media: add the stm32mp25 compatible of DCMIPP 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: <20241118-csi_dcmipp_mp25-v3-12-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat , Krzysztof Kozlowski X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 Add the stm32mp25 compatible for the DCMIPP. The stm32mp25 distinguish with the stm32mp13 by the fact that: - supports also csi inputs in addition to parallel inputs - requires an addition csi clock to be present Add also access-controllers, an optional property that allows a peripheral to refer to one or more domain access controller(s). Reviewed-by: Krzysztof Kozlowski Signed-off-by: Alain Volmat --- v2: - move allOf after required - reword commit message --- .../devicetree/bindings/media/st,stm32-dcmipp.yaml | 53 ++++++++++++++++++= +--- 1 file changed, 47 insertions(+), 6 deletions(-) diff --git a/Documentation/devicetree/bindings/media/st,stm32-dcmipp.yaml b= /Documentation/devicetree/bindings/media/st,stm32-dcmipp.yaml index 87731f3ce7bd528840d5fa85a863dbdfcabfad3f..7b03a77adbce8512f622fc992ef= 9913d52880f74 100644 --- a/Documentation/devicetree/bindings/media/st,stm32-dcmipp.yaml +++ b/Documentation/devicetree/bindings/media/st,stm32-dcmipp.yaml @@ -12,7 +12,9 @@ maintainers: =20 properties: compatible: - const: st,stm32mp13-dcmipp + enum: + - st,stm32mp13-dcmipp + - st,stm32mp25-dcmipp =20 reg: maxItems: 1 @@ -21,11 +23,24 @@ properties: maxItems: 1 =20 clocks: - maxItems: 1 + items: + - description: bus clock + - description: csi clock + minItems: 1 + + clock-names: + items: + - const: kclk + - const: mclk + minItems: 1 =20 resets: maxItems: 1 =20 + access-controllers: + minItems: 1 + maxItems: 2 + port: $ref: /schemas/graph.yaml#/$defs/port-base unevaluatedProperties: false @@ -39,7 +54,7 @@ properties: =20 properties: bus-type: - enum: [5, 6] + enum: [4, 5, 6] default: 5 =20 bus-width: @@ -50,9 +65,6 @@ properties: hsync-active: true vsync-active: true =20 - required: - - pclk-sample - required: - compatible - reg @@ -61,6 +73,35 @@ required: - resets - port =20 +allOf: + - if: + properties: + compatible: + contains: + enum: + - st,stm32mp13-dcmipp + then: + properties: + clocks: + maxItems: 1 + + clock-names: + maxItems: 1 + + port: + properties: + endpoint: + properties: + bus-type: + enum: [5, 6] + else: + properties: + clocks: + minItems: 2 + + clock-names: + minItems: 2 + additionalProperties: false =20 examples: --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx07-00178001.pphosted.com (mx08-00178001.pphosted.com [91.207.212.93]) (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 59C1C1B86E9; Mon, 18 Nov 2024 13:40:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.207.212.93 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937222; cv=none; b=oGtQk5ZXmlGf0fRumiiWgHjLc20AwhvQxiGQlezQ+NWIcafxkaQ/awb2/IbAwHoN0GRcPC8LsiGC0UxF0Tv8WwCeuxNsKk0v24SXg2a0Us/QEIiLYbmCPE5OLh3pveNRVHgPFxtdFO/FYblhtPyazFmjwrxsgvsCxTlecYa0ecU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937222; c=relaxed/simple; bh=yDH91BTX2Vq65u37DJRYA5qaSAe3gqvRH0thHa6GVeY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=doCzWlkp7V6WDPRPFyiJo/6WQ9VUJR84Z8B73Kd0XUajxXhZfJMabwQCHl2kjY5xSLTXJr8byC9P4GRr14H6L9GsvsHddVg43sUhRmZ8+TJ9nCcB71EBBAqhY8jYSJiG6wR/5il47Wm0PVlbc931cU3tgLcLfi5Q3YX4GQch6L4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=rFGUqcwN; arc=none smtp.client-ip=91.207.212.93 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="rFGUqcwN" Received: from pps.filterd (m0046660.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AICwI7j006812; Mon, 18 Nov 2024 14:39:53 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= mh3X05T5H06SX13NOd/vtfLsw3De2vyHd/Fa/OGJ4zs=; b=rFGUqcwNgUiAptGe sanaZS8s0ItbmGKx5VaJUOBcQCJCOdVp0yXcotsDR7lvXv7jNEo5QNRJMlRTuw6j ak+LXoB40E8YTCseITlAKsP7Mj9PE0U7WoXL0JBYMp/3thXQFgtM2TPD6RDT0t6L 3ijlyP+8JiuJdXGR/i8BbZ4Df4X/t3Isi8RI2nTJNOPR6SSggoux7mlc1o4WAi2h vXoL8/ugVnWFSOukBiOCaNS74vAyhG/QD4iTnzj7wy/esxp7QRxGKapETIFLMLvE nBUoQpKQ26XpcXjRAdRklyBsYqCcp3onl+Jz5gWfHQLIk9yexiawMXIxoqMskq34 9a2mLA== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42xkqh77pf-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:52 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id A93C140064; Mon, 18 Nov 2024 14:38:33 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 3351A276F07; Mon, 18 Nov 2024 14:35:34 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:33 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:36 +0100 Subject: [PATCH v3 13/15] media: stm32: dcmipp: add core support for the stm32mp25 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: <20241118-csi_dcmipp_mp25-v3-13-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 The stm32mp25 supports both parallel & csi inputs. An additional clock control is necessary. Skeleton of the subdev structures for the stm32mp25 is added, identical for the time being to the stm32mp13 however more subdeves will be added in further commits. Signed-off-by: Alain Volmat --- .../platform/st/stm32/stm32-dcmipp/dcmipp-core.c | 98 ++++++++++++++++++= ---- 1 file changed, 80 insertions(+), 18 deletions(-) diff --git a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-core.c b/d= rivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-core.c index d2cc19bb40d77f67a1f5fe565bc62f45eff2d266..0087f9017f024ba6b918b99c1ef= 39212ad6b881a 100644 --- a/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-core.c +++ b/drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-core.c @@ -40,6 +40,7 @@ struct dcmipp_device { =20 /* Hardware resources */ void __iomem *regs; + struct clk *mclk; struct clk *kclk; =20 /* The pipeline configuration */ @@ -132,6 +133,40 @@ static const struct dcmipp_pipeline_config stm32mp13_p= ipe_cfg =3D { .hw_revision =3D DCMIPP_STM32MP13_VERR }; =20 +static const struct dcmipp_ent_config stm32mp25_ent_config[] =3D { + { + .name =3D "dcmipp_input", + .init =3D dcmipp_inp_ent_init, + .release =3D dcmipp_inp_ent_release, + }, + { + .name =3D "dcmipp_dump_postproc", + .init =3D dcmipp_byteproc_ent_init, + .release =3D dcmipp_byteproc_ent_release, + }, + { + .name =3D "dcmipp_dump_capture", + .init =3D dcmipp_bytecap_ent_init, + .release =3D dcmipp_bytecap_ent_release, + }, +}; + +static const struct dcmipp_ent_link stm32mp25_ent_links[] =3D { + DCMIPP_ENT_LINK(ID_INPUT, 1, ID_DUMP_BYTEPROC, 0, + MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), + DCMIPP_ENT_LINK(ID_DUMP_BYTEPROC, 1, ID_DUMP_CAPTURE, 0, + MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), +}; + +#define DCMIPP_STM32MP25_VERR 0x30 +static const struct dcmipp_pipeline_config stm32mp25_pipe_cfg =3D { + .ents =3D stm32mp25_ent_config, + .num_ents =3D ARRAY_SIZE(stm32mp25_ent_config), + .links =3D stm32mp25_ent_links, + .num_links =3D ARRAY_SIZE(stm32mp25_ent_links), + .hw_revision =3D DCMIPP_STM32MP25_VERR +}; + #define LINK_FLAG_TO_STR(f) ((f) =3D=3D 0 ? "" :\ (f) =3D=3D MEDIA_LNK_FL_ENABLED ? "ENABLED" :\ (f) =3D=3D MEDIA_LNK_FL_IMMUTABLE ? "IMMUTABLE" :\ @@ -212,6 +247,7 @@ static int dcmipp_create_subdevs(struct dcmipp_device *= dcmipp) =20 static const struct of_device_id dcmipp_of_match[] =3D { { .compatible =3D "st,stm32mp13-dcmipp", .data =3D &stm32mp13_pipe_cfg }, + { .compatible =3D "st,stm32mp25-dcmipp", .data =3D &stm32mp25_pipe_cfg }, { /* end node */ }, }; MODULE_DEVICE_TABLE(of, dcmipp_of_match); @@ -261,13 +297,22 @@ static int dcmipp_graph_notify_bound(struct v4l2_asyn= c_notifier *notifier, { struct dcmipp_device *dcmipp =3D notifier_to_dcmipp(notifier); unsigned int ret; - int src_pad; + int src_pad, i; struct dcmipp_ent_device *sink; - struct v4l2_fwnode_endpoint vep =3D { .bus_type =3D V4L2_MBUS_PARALLEL }; + struct v4l2_fwnode_endpoint vep =3D { 0 }; struct fwnode_handle *ep; + enum v4l2_mbus_type supported_types[] =3D { + V4L2_MBUS_PARALLEL, V4L2_MBUS_BT656, V4L2_MBUS_CSI2_DPHY + }; + int supported_types_nb =3D ARRAY_SIZE(supported_types); =20 dev_dbg(dcmipp->dev, "Subdev \"%s\" bound\n", subdev->name); =20 + /* Only MP25 supports CSI input */ + if (!of_device_is_compatible(dcmipp->dev->of_node, + "st,stm32mp25-dcmipp")) + supported_types_nb--; + /* * Link this sub-device to DCMIPP, it could be * a parallel camera sensor or a CSI-2 to parallel bridge @@ -284,21 +329,23 @@ static int dcmipp_graph_notify_bound(struct v4l2_asyn= c_notifier *notifier, return -ENODEV; } =20 - /* Check for parallel bus-type first, then bt656 */ - ret =3D v4l2_fwnode_endpoint_parse(ep, &vep); - if (ret) { - vep.bus_type =3D V4L2_MBUS_BT656; + /* Check for supported MBUS type */ + for (i =3D 0; i < supported_types_nb; i++) { + vep.bus_type =3D supported_types[i]; ret =3D v4l2_fwnode_endpoint_parse(ep, &vep); - if (ret) { - dev_err(dcmipp->dev, "Could not parse the endpoint\n"); - fwnode_handle_put(ep); - return ret; - } + if (!ret) + break; } =20 fwnode_handle_put(ep); =20 - if (vep.bus.parallel.bus_width =3D=3D 0) { + if (ret) { + dev_err(dcmipp->dev, "Could not parse the endpoint\n"); + return ret; + } + + if (vep.bus_type !=3D V4L2_MBUS_CSI2_DPHY && + vep.bus.parallel.bus_width =3D=3D 0) { dev_err(dcmipp->dev, "Invalid parallel interface bus-width\n"); return -ENODEV; } @@ -311,11 +358,13 @@ static int dcmipp_graph_notify_bound(struct v4l2_asyn= c_notifier *notifier, return -ENODEV; } =20 - /* Parallel input device detected, connect it to parallel subdev */ + /* Connect input device to the dcmipp_input subdev */ sink =3D dcmipp->entity[ID_INPUT]; - sink->bus.flags =3D vep.bus.parallel.flags; - sink->bus.bus_width =3D vep.bus.parallel.bus_width; - sink->bus.data_shift =3D vep.bus.parallel.data_shift; + if (vep.bus_type !=3D V4L2_MBUS_CSI2_DPHY) { + sink->bus.flags =3D vep.bus.parallel.flags; + sink->bus.bus_width =3D vep.bus.parallel.bus_width; + sink->bus.data_shift =3D vep.bus.parallel.data_shift; + } sink->bus_type =3D vep.bus_type; ret =3D media_create_pad_link(&subdev->entity, src_pad, sink->ent, 0, MEDIA_LNK_FL_IMMUTABLE | @@ -414,7 +463,7 @@ static int dcmipp_graph_init(struct dcmipp_device *dcmi= pp) static int dcmipp_probe(struct platform_device *pdev) { struct dcmipp_device *dcmipp; - struct clk *kclk; + struct clk *kclk, *mclk; const struct dcmipp_pipeline_config *pipe_cfg; struct reset_control *rstc; int irq; @@ -474,12 +523,20 @@ static int dcmipp_probe(struct platform_device *pdev) return ret; } =20 - kclk =3D devm_clk_get(&pdev->dev, NULL); + kclk =3D devm_clk_get(&pdev->dev, "kclk"); if (IS_ERR(kclk)) return dev_err_probe(&pdev->dev, PTR_ERR(kclk), "Unable to get kclk\n"); dcmipp->kclk =3D kclk; =20 + if (!of_device_is_compatible(pdev->dev.of_node, "st,stm32mp13-dcmipp")) { + mclk =3D devm_clk_get(&pdev->dev, "mclk"); + if (IS_ERR(mclk)) + return dev_err_probe(&pdev->dev, PTR_ERR(mclk), + "Unable to get mclk\n"); + dcmipp->mclk =3D mclk; + } + dcmipp->entity =3D devm_kcalloc(&pdev->dev, dcmipp->pipe_cfg->num_ents, sizeof(*dcmipp->entity), GFP_KERNEL); if (!dcmipp->entity) @@ -542,6 +599,7 @@ static int dcmipp_runtime_suspend(struct device *dev) struct dcmipp_device *dcmipp =3D dev_get_drvdata(dev); =20 clk_disable_unprepare(dcmipp->kclk); + clk_disable_unprepare(dcmipp->mclk); =20 return 0; } @@ -551,6 +609,10 @@ static int dcmipp_runtime_resume(struct device *dev) struct dcmipp_device *dcmipp =3D dev_get_drvdata(dev); int ret; =20 + ret =3D clk_prepare_enable(dcmipp->mclk); + if (ret) + dev_err(dev, "%s: Failed to prepare_enable mclk\n", __func__); + ret =3D clk_prepare_enable(dcmipp->kclk); if (ret) dev_err(dev, "%s: Failed to prepare_enable kclk\n", __func__); --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx07-00178001.pphosted.com (mx07-00178001.pphosted.com [185.132.182.106]) (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 EF61E53A7; Mon, 18 Nov 2024 13:40:08 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=185.132.182.106 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937210; cv=none; b=O2oiDxqun7W1wSSIoq6UwEgbl4yjPGgNeTBzmArnqUupowjvdd6CFOZVMUmaYqqgOJl56M5bsLUd3FFXtVN9k11LK8Q9w1iQKBLq0gXddtySh0Trlg2Ck0GdPPp+KmDYOMFj1AWfrMccgn74QeiZDc5spYEHYpJCWp/zSQ91XTU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937210; c=relaxed/simple; bh=V1zV4dk2RexT0VlhFpEXjyqddvw7mzRMMkBenDXXQzs=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=QRgP90VcNMVKKWyXUTWJ2TtHc6azBkkfrf2tuRu3w4pm2IwrYUxd6lgVIsHPFG09BYBfkO7Pv10Wl0yddXF/LkctFyfwhbmW7raANj2dc4oxLLodlXkdJZaqDE3fnWzWR6xVUfuS4vzcwY6YAWjmRWvBVtjEiWquC7OiffnS2GY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=2dO/+dQd; arc=none smtp.client-ip=185.132.182.106 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="2dO/+dQd" Received: from pps.filterd (m0369458.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AIBVd9e023803; Mon, 18 Nov 2024 14:39:52 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= XnAbYm4VWUKZ0F1ePtL5cGK91Okpi3RKOo0VHnxT3ak=; b=2dO/+dQddZPaI+VI 1moKrpObqUbwCvFB2SC7idmegRg3FWWx+kO8fmBHSqcyo7FV1pa7g1PjC626/d8b 64/WmExCIiU6oMLZN3d/t3KFM3TVKG72bRFJgONp2EOGpwM36nQZs750z496cnT2 PvwwIcLf1k31JXcpSsP2xafnJeLciSFfl8FBUAG9ikjmLYCUcule68iH1hhTwuA3 u5W96u+P0siQKe34eMMQWZAJAgfw5UBVOSCECao+Fn/HMoWojP2reWOFajjYMzvA 2pRWmJkA2io7yH75LrS3MUyX3FrGKxiezNHRAUFI8yHpUQc553UFxeNrD/PDAgpt c5Yhew== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42y5u3n8j0-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:52 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id AEC6340059; Mon, 18 Nov 2024 14:38:32 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id C4727278260; Mon, 18 Nov 2024 14:35:34 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:34 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:37 +0100 Subject: [PATCH v3 14/15] arm64: dts: st: add csi & dcmipp node in stm32mp25 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: <20241118-csi_dcmipp_mp25-v3-14-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 Add nodes describing the csi and dcmipp controllers handling the camera pipeline on the stm32mp25x. Signed-off-by: Alain Volmat --- arch/arm64/boot/dts/st/stm32mp251.dtsi | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/arch/arm64/boot/dts/st/stm32mp251.dtsi b/arch/arm64/boot/dts/s= t/stm32mp251.dtsi index 1167cf63d7e87aaa15c5c1ed70a9f6511fd818d4..6f8cabf2c5985f358689f152963= 00de24e9d9b25 100644 --- a/arch/arm64/boot/dts/st/stm32mp251.dtsi +++ b/arch/arm64/boot/dts/st/stm32mp251.dtsi @@ -518,6 +518,29 @@ i2c8: i2c@46040000 { status =3D "disabled"; }; =20 + csi: csi@48020000 { + compatible =3D "st,stm32mp25-csi"; + reg =3D <0x48020000 0x2000>; + interrupts =3D ; + resets =3D <&rcc CSI_R>; + clocks =3D <&rcc CK_KER_CSI>, <&rcc CK_KER_CSITXESC>, + <&rcc CK_KER_CSIPHY>; + clock-names =3D "pclk", "txesc", "csi2phy"; + access-controllers =3D <&rifsc 86>; + status =3D "disabled"; + }; + + dcmipp: dcmipp@48030000 { + compatible =3D "st,stm32mp25-dcmipp"; + reg =3D <0x48030000 0x1000>; + interrupts =3D ; + resets =3D <&rcc DCMIPP_R>; + clocks =3D <&rcc CK_BUS_DCMIPP>, <&rcc CK_KER_CSI>; + clock-names =3D "kclk", "mclk"; + access-controllers =3D <&rifsc 87>; + status =3D "disabled"; + }; + sdmmc1: mmc@48220000 { compatible =3D "st,stm32mp25-sdmmc2", "arm,pl18x", "arm,primecell"; arm,primecell-periphid =3D <0x00353180>; --=20 2.25.1 From nobody Sun Nov 24 13:38:43 2024 Received: from mx07-00178001.pphosted.com (mx08-00178001.pphosted.com [91.207.212.93]) (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 6D57453A7; Mon, 18 Nov 2024 13:40:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.207.212.93 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937216; cv=none; b=WKn8uuyq6IZowelBJ0fODxvHJgCpVblAZlXT/kqGNuOttm/OhEIfqhhvR7Dki8Cr1KBAtYKyOKcL+/E1MyOLVzlmu/QcKTUUkwb2xwrEQQ/mos+o5fa5dL03dbwbXy9taeekhj/fC4RuwpvOIbp/eT5iyXFL6Xp0aVzGqwJ63ss= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1731937216; c=relaxed/simple; bh=t0g3tyGLXDa9mEU8ERU+pY2ZJyv+jnWCEShMpLm4R7o=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=Q/qBKTh++pqFqhiwj1Dwi26KWx6EZzzzJOVZoS+nH5I0b+FFUu1K+KWr+mHmMrif9G1HjUAmPU5+MKRK5MADtGKuyTUeAl2ln60NxlFKpKqfoftnkqzQsWt8oJHHmImL2Y3uTocSahfyTPLidmxQ4VhTvatp7wbV9cvTi8Vbj2g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com; spf=pass smtp.mailfrom=foss.st.com; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b=WsGmFeZN; arc=none smtp.client-ip=91.207.212.93 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=foss.st.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=foss.st.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=foss.st.com header.i=@foss.st.com header.b="WsGmFeZN" Received: from pps.filterd (m0046660.ppops.net [127.0.0.1]) by mx07-00178001.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AIBWncd032001; Mon, 18 Nov 2024 14:39:40 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=foss.st.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=selector1; bh= i0SEXjer4NUU2DKUJapl8bqAlE+SwlDXXIr03qjV7WU=; b=WsGmFeZNfXpWzr1t ZjPJIzd5lXu2bbvc8+LL0V1RSkYcDytf3M2dgkQB8/XI0PpHJJnnNJBoaP7hoUV3 mA/a/pabRama9ZeoV5ykwjChXY4pKG4Z+wDOqqC6FSS867LnUWVMqG7Hn/Hc7qnH NqPxnUZd750F3HOERDZOJWmcRlpfQWIbrSyKV+eVafx53dMD2CqP/PVly4liwbWT AHkJBQVPFmhPUyks+kwfEUFxRKQ0b82Hd5O+byr488e6JPAxVkXkkHjUSLcbLI90 PV7czHidpOnRDAOJptOYLbj8l6xXXvjOsQIGdKSpyqWSQT3ihLLYtVSBVLBLAL5Y wLunow== Received: from beta.dmz-ap.st.com (beta.dmz-ap.st.com [138.198.100.35]) by mx07-00178001.pphosted.com (PPS) with ESMTPS id 42xkqh77nv-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Nov 2024 14:39:39 +0100 (CET) Received: from euls16034.sgp.st.com (euls16034.sgp.st.com [10.75.44.20]) by beta.dmz-ap.st.com (STMicroelectronics) with ESMTP id B030A40046; Mon, 18 Nov 2024 14:38:35 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 6318D2786FB; Mon, 18 Nov 2024 14:35:35 +0100 (CET) Received: from localhost (10.129.178.213) by SHFDAG1NODE1.st.com (10.75.129.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.37; Mon, 18 Nov 2024 14:35:35 +0100 From: Alain Volmat Date: Mon, 18 Nov 2024 14:35:38 +0100 Subject: [PATCH v3 15/15] arm64: dts: st: enable imx335/csi/dcmipp pipeline on stm32mp257f-ev1 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: <20241118-csi_dcmipp_mp25-v3-15-c1914afb0a0f@foss.st.com> References: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> In-Reply-To: <20241118-csi_dcmipp_mp25-v3-0-c1914afb0a0f@foss.st.com> To: Hugues Fruchet , Mauro Carvalho Chehab , Maxime Coquelin , Alexandre Torgue , Hans Verkuil , Sakari Ailus , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Philipp Zabel CC: , , , , , Alain Volmat X-Mailer: b4 0.14.2 X-ClientProxiedBy: EQNCAS1NODE3.st.com (10.75.129.80) To SHFDAG1NODE1.st.com (10.75.129.69) X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 Enable the camera pipeline with a imx335 sensor connected to the dcmipp via the csi interface. Signed-off-by: Alain Volmat --- v2: - correct regulators & camera node names - removal of powerdown property within imx335 node - removal of useless status property within imx335 node - correct imx335 reset-gpio polarity --- arch/arm64/boot/dts/st/stm32mp257f-ev1.dts | 85 ++++++++++++++++++++++++++= ++++ 1 file changed, 85 insertions(+) diff --git a/arch/arm64/boot/dts/st/stm32mp257f-ev1.dts b/arch/arm64/boot/d= ts/st/stm32mp257f-ev1.dts index 214191a8322b81e7ae453503863b4465d9b625e0..d45851b3904d760f73298bf7b26= 0f917b582db55 100644 --- a/arch/arm64/boot/dts/st/stm32mp257f-ev1.dts +++ b/arch/arm64/boot/dts/st/stm32mp257f-ev1.dts @@ -27,6 +27,38 @@ chosen { stdout-path =3D "serial0:115200n8"; }; =20 + clocks { + clk_ext_camera: clk-ext-camera { + #clock-cells =3D <0>; + compatible =3D "fixed-clock"; + clock-frequency =3D <24000000>; + }; + }; + + imx335_2v9: regulator-2v9 { + compatible =3D "regulator-fixed"; + regulator-name =3D "imx335-avdd"; + regulator-min-microvolt =3D <2900000>; + regulator-max-microvolt =3D <2900000>; + regulator-always-on; + }; + + imx335_1v8: regulator-1v8 { + compatible =3D "regulator-fixed"; + regulator-name =3D "imx335-ovdd"; + regulator-min-microvolt =3D <1800000>; + regulator-max-microvolt =3D <1800000>; + regulator-always-on; + }; + + imx335_1v2: regulator-1v2 { + compatible =3D "regulator-fixed"; + regulator-name =3D "imx335-dvdd"; + regulator-min-microvolt =3D <1200000>; + regulator-max-microvolt =3D <1200000>; + regulator-always-on; + }; + memory@80000000 { device_type =3D "memory"; reg =3D <0x0 0x80000000 0x1 0x0>; @@ -50,6 +82,40 @@ &arm_wdt { status =3D "okay"; }; =20 +&csi { + vdd-supply =3D <&scmi_vddcore>; + vdda18-supply =3D <&scmi_v1v8>; + status =3D "okay"; + ports { + #address-cells =3D <1>; + #size-cells =3D <0>; + port@0 { + reg =3D <0>; + csi_sink: endpoint { + remote-endpoint =3D <&imx335_ep>; + data-lanes =3D <1 2>; + bus-type =3D <4>; + }; + }; + port@1 { + reg =3D <1>; + csi_source: endpoint { + remote-endpoint =3D <&dcmipp_0>; + }; + }; + }; +}; + +&dcmipp { + status =3D "okay"; + port { + dcmipp_0: endpoint { + remote-endpoint =3D <&csi_source>; + bus-type =3D <4>; + }; + }; +}; + ðernet2 { pinctrl-names =3D "default", "sleep"; pinctrl-0 =3D <ð2_rgmii_pins_a>; @@ -81,6 +147,25 @@ &i2c2 { i2c-scl-falling-time-ns =3D <13>; clock-frequency =3D <400000>; status =3D "okay"; + + imx335: camera@1a { + compatible =3D "sony,imx335"; + reg =3D <0x1a>; + clocks =3D <&clk_ext_camera>; + avdd-supply =3D <&imx335_2v9>; + ovdd-supply =3D <&imx335_1v8>; + dvdd-supply =3D <&imx335_1v2>; + reset-gpios =3D <&gpioi 7 (GPIO_ACTIVE_LOW | GPIO_PUSH_PULL)>; + + port { + imx335_ep: endpoint { + remote-endpoint =3D <&csi_sink>; + clock-lanes =3D <0>; + data-lanes =3D <1 2>; + link-frequencies =3D /bits/ 64 <594000000>; + }; + }; + }; }; =20 &i2c8 { --=20 2.25.1