From nobody Sun Nov 24 13:50:38 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 EAEDD200B9A; Tue, 5 Nov 2024 07:52:45 +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=1730793167; cv=none; b=kSlYxrnYJfNTEK2kujAhtIfmeepNaxk3g+BM2zBM7YgIj2jHOutBfrzO8wr1X7CzZtQihKBlsK7PN78L1nzdtbjOMo3rMD+V4xHqzD4OHpEgjfR7YKEcVCx+i9P5A3o/iae0E9TaCH9ti6JHqXQGfJmso013ztJ4zUfxtrEHR4o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793167; c=relaxed/simple; bh=DV8WgtfiJ3jSHJlxMtKq/+R3q5ybHbBcGIdrmJZDwp8=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=XYdHp6xlnVNXvM6G+SaROWUlwXAmWBmBhcvELP5uMCGycJlZBDbxT5eDheMgSn5QPz0VVpNRh05DK/raszzWRmLnCmFJzgf3Gn+OxT1mROoq0jQ8EgaoAE60ngjU72WR7ixVil4LU88YQybox6UXWp8V4ScyeZpEyh+pyKaq1lI= 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=t4adEIlN; 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="t4adEIlN" 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 4A55JfM8025506; Tue, 5 Nov 2024 08:52:32 +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=t4adEIlNXi5Epg2W 9f5TUuaje+zz6Z2t9vAJrVLKBHPEkoU8Taml9YFKfKeQKWg4eVxgGKqkzhzMq0db UiAin/GS5+Nep8N9U36qUZM9iHsEZy4Vv9MZwwQ/LTaMxUYVHFw2paSx28jRAamp IpTSexUfbnJqpDU++zaL6bItAo6FFYU6h4TyMMQjUAMbM+SkWnOGSiGb8u2XZGYy tq+5nwql9UWdwrU0Dc0Lu3uV+q/BHaKn39k6vuAwXEk4K5Y5EL6ek0JlV9sfveE9 +S3Con3hGamkUy7Eu77qSkYCKslHG5RYY0+2DYeMZDSdXATda6+zJLs+3XqNq/ij mz/p1w== 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 42nd002dh3-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:52:32 +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 0E5FB40054; Tue, 5 Nov 2024 08:50:27 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 21BDC24FE5C; Tue, 5 Nov 2024 08:49: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; Tue, 5 Nov 2024 08:49:28 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:04 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-1-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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:50:38 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 71D551FEFB6; Tue, 5 Nov 2024 07:52:09 +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=1730793132; cv=none; b=b79tXQWKO0u6OAFblkUF9ZUflL/MUrE+WahIUlcnssGrDCLNiY8j+3tAgL76t1xmlmvajmm9v7Z6MuFD9lm1p58feA1fmYAHCHHG0HZIUWhihDrP5RlZi04rjZ77fHeNHC6y7hyLfYrUxq93yonjhFiDECSYk1qBENuaL5pBQZA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793132; c=relaxed/simple; bh=h57xlnB3Mhh32cejNhE1wIW8ECscZ6ZvJjql2h7EF4U=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=WTsZCPHWI30G2taMkaM+FzpsryONfx/Sm1eXvpm4cT2NhupNoGFUEQUA/NiXp8JIXLQU5y0Qc/B0IQnxmUXqZ7t1GaajlcAwwybo4zcrnZwqOwdlJ/HmkPA81WC9Z2CnkGWwsCYWiAH2TYPbfrDS2lbwRvKepYUmXIaCToYWU5c= 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=sv76dPRE; 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="sv76dPRE" 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 4A52iEOw028085; Tue, 5 Nov 2024 08:51:55 +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= 7Nnxla3UOXbGveUOQ2wYAl4yXcze3QodV3rJ6QQi4dk=; b=sv76dPRE3yuQSR// YJq+3qrrc+RITjDfS7CXlVj0Kzlj1WF0Z6kRg4OwMDHJ4vSbqih2zXewxPoGZ6wy 0izqYwxQ344vo/5D7UaFWFTQ+klpzZpX+R9mJ8THOYg1xKBN0z8Sqd0dSyIO/pht PF+p/NZOeGXRHF8ikj84drHLuin0XIXMgqa4eOeIiBlQ7W7mfEg39/sWtcngC19z h7gdQYJ8gaS2dkfIuFGftPLfK8pcXMEISTpUfoabNoap2qo8wz3Fibr7cRYhCFH2 Uu7n6YucKV3pIiUV2/yotBtWdXFUITxFUeWFdbg1+WD/IOwFfUN9mD83YeMmg/sj 69/i7A== 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 42nd00jdff-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:51:55 +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 66F894002D; Tue, 5 Nov 2024 08:50:22 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id BB02924FE55; Tue, 5 Nov 2024 08:49: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; Tue, 5 Nov 2024 08:49:29 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:05 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-2-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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. Signed-off-by: Alain Volmat Reviewed-by: Krzysztof Kozlowski --- 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:50:38 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 359D71FF7BD; Tue, 5 Nov 2024 07:52: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=1730793137; cv=none; b=VEhFVDyr8cp0XI2CSmcYvhXrBgrZyWN8xdmJBc53briIzqn7F2unRIaxHjFWP1PJwWH9PqwCASrdoGNapDhFEeYMCr+pTCXNP91+Jh3jzZaVy5Ye4cAxtzFacyM7UGLEM0+eWSIGHLF+I04ooAM7eR8juzWwjh0ikFwmVYEWZpM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793137; c=relaxed/simple; bh=8RgNFVj3GnP1M2S1nH82yLN5XTVYmpKduGITg4S9vrQ=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=uCBDzoPP/9ywLOhHSPyZ/CKg3ERyE9DsVZmQz0QX5r7lHZTBaOakizRvogbWXESVdTXeTln+5Cczg1KGKxA60wg/07DjCL4Gjt+NSlI2Wrhz6dR08P8SxvI32+xrKx7C4Mw1Sg7a8nnzINI4TolpbqLRxT+d5YtdBpSpZXS8dPI= 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=emVcxOnj; 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="emVcxOnj" 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 4A5010SM018754; Tue, 5 Nov 2024 08:51: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= LEI0L7Vd9qdSttB09dN779qaFaja8+yMfgm0l2nekcE=; b=emVcxOnjyJVekEwM DtR0O0ZyWUE2uHG9L8Opyu7YIJ9XEZVeTuZwZYcNGCPzR3yETNxkJP3i65VC+8Yu dKJC5WraKZuNf4Pu5PDPyS5GkGUTJbfF0+PRLJpJPWWJTFGg1XvcEv1fvS/qw/7t st/vLF3attMWGcvFBz5cDKxgMJuEtB67QnrBqOB4v/VxDO0Al5Hq+FMfcp46H8Ha pej2MJsKODOdsSPqY2XHIKIjZmyYIb+by92rAeYqT6L9+V63oGoYcibW8G6VDD81 dOF6UDS2qZ7QV9vhChRQr32xKH6jPebnd2Pygu1DC+Qz0DzJoXuPzsJVK+Q7koAv bRD6sQ== 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 42ncxbtu9n-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:51:51 +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 81CB54004A; Tue, 5 Nov 2024 08:50:22 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 6D68A2504EC; Tue, 5 Nov 2024 08:49: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; Tue, 5 Nov 2024 08:49:30 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:06 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-3-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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 --- 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 | 1144 +++++++++++++++++++++++= ++++ 4 files changed, 1167 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..c7f47472c6b3699e94113ce0f38= b280a2e45ce15 --- /dev/null +++ b/drivers/media/platform/st/stm32/stm32-csi.c @@ -0,0 +1,1144 @@ +// 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) + +struct stm32_csi_dev { + struct device *dev; + + void __iomem *base; + struct clk *pclk; + struct clk *txesc; + struct clk *csi2phy; + struct regulator_bulk_data supplies[2]; + struct reset_control *rstc; + + 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->csi2phy); + 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; + + 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"); + + csidev->pclk =3D devm_clk_get(&pdev->dev, "pclk"); + if (IS_ERR(csidev->pclk)) + return dev_err_probe(&pdev->dev, PTR_ERR(csidev->pclk), + "Couldn't get pclk\n"); + + csidev->txesc =3D devm_clk_get(&pdev->dev, "txesc"); + if (IS_ERR(csidev->txesc)) + return dev_err_probe(&pdev->dev, PTR_ERR(csidev->txesc), + "Couldn't get txesc\n"); + + csidev->csi2phy =3D devm_clk_get(&pdev->dev, "csi2phy"); + if (IS_ERR(csidev->csi2phy)) + return dev_err_probe(&pdev->dev, PTR_ERR(csidev->csi2phy), + "Couldn't get csi2phy\n"); + + csidev->rstc =3D devm_reset_control_get_exclusive(&pdev->dev, NULL); + if (IS_ERR(csidev->rstc)) + return dev_err_probe(&pdev->dev, PTR_ERR(csidev->rstc), + "Couldn't get reset control\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; + 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 */ + ret =3D reset_control_assert(csidev->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(csidev->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_disable_unprepare(csidev->csi2phy); + clk_disable_unprepare(csidev->txesc); + clk_disable_unprepare(csidev->pclk); + + 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_prepare_enable(csidev->pclk); + if (ret) + goto error_disable_supplies; + + ret =3D clk_prepare_enable(csidev->txesc); + if (ret) + goto error_disable_pclk; + + ret =3D clk_prepare_enable(csidev->csi2phy); + if (ret) + goto error_disable_txesc; + + return 0; + +error_disable_txesc: + clk_disable_unprepare(csidev->txesc); +error_disable_pclk: + clk_disable_unprepare(csidev->pclk); +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:50:38 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 D73A31FF058; Tue, 5 Nov 2024 07:52:10 +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=1730793132; cv=none; b=Ww5Mk6Wp6hxZFxeRUE8xAwxtkc1fkcCstE0Zm56hDtoUYL0ypfye0Glm362YTHq9QGn81g35Hnm4gj4dNSGkgypnPphMbx+Ky1bBBrIgA5TcwXPKvk5D36fK5I/ma2ZQUOyZdEoytJSc9M5I9upT++/q9ki0vJDdzeF9JerY/T8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793132; c=relaxed/simple; bh=b4urTh22AIvaqz2EmuC9UlyYLkWnaPQp2f86++BSplA=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=DdYZRSLwgVsihhPe0KLLYu/9rikVFrCzIZmmDTvYEL7krgOjLsQu54/fvwm1gA5/z8Qqr9wEdsAGRK35NcLE3gC06QyOR+Qdqw8Bm5G9Jr01WuvOM4I/YzgYHD9jtmuLfoxhJihfuHJUIN017XF0hSIoiNyadiGv51FUR+9/Gic= 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=M480Qcui; 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="M480Qcui" 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 4A53GSeR022439; Tue, 5 Nov 2024 08:51:57 +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=M480QcuiNz5z7pQA LXJocxUpAq5ZgtUAwLy8QkxMolyCxe02Ar4CZMgwmCSJgXbqmLNccXCwpowO6TZP mty4EsT32g2tE3is2pQv56E1X9n9kG+bHbjkJC+cJnHSnbOBDBWvy3YzXveZ8W0B uyzhY/Hp4N3VqVo72bFly3+s7AoM+EoPEVr2V+mrTgPn9j2j6Ig0kPqKDFwntbJ4 AI4idtYgtjfaNZrX6SgHZu1LE2gUd1eDqxyYQoMT2kmkYpgn/zjnZgU/rvnGSpN4 yIQfsQNWR3h6g6gCxVKn27c7o/O4OVeZWDOcH0EyTQm9xDYdeYMBJnG6pxR/L1Mz +8IyLQ== 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 42nxh3rnj1-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:51: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 CBF384004F; Tue, 5 Nov 2024 08:50:22 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 026A62504FA; Tue, 5 Nov 2024 08:49: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; Tue, 5 Nov 2024 08:49:30 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:07 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-4-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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:50:38 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 E58C61FDFA0; Tue, 5 Nov 2024 07:51:58 +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=1730793121; cv=none; b=nTt+aPkGPlI3YT4jL4QlQGOwieZGoUXC8hHGF75Ybg3uOV4qCZnybfhcIRRh7y/SZ3zOpiqlCNAytgkuaGMwCdWTXTuXVt1UuRw2L6j9uLmBEhiHHeD1J2DH9/iFrFLl6cPeSIdaZPSuLwahheQVQyAgyu5jBHBxpjTkQEaNqis= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793121; c=relaxed/simple; bh=iwMMj6hFeKCXUBKnWgk+dNDNW1m0V5G2ddgEDKZdbpo=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=LYaVbdUQiAAZVeJudTCcqtNmzE4O6729BY8rVyArvtO7OW8fNChYWkWGLARRa5bz9ZBgkgijjAL1skf7Po0woKzfbxyW0ys4ShDegvjle0WCnpbP+1gNPNubkzFhW1W7huiozUtT725leEKJa9cRwrWoflhz3NbL9kUAohpydxc= 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=KoLzlDxq; 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="KoLzlDxq" 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 4A53Dbis018217; Tue, 5 Nov 2024 08:51:35 +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=KoLzlDxqv9DVPeHW vdjtmD/HREZkk34tSTtB5S9Bcp3srGYR3QkOgCkgWRZGQHuM5zuVT6j315plNGC4 LkknNEt4dgWCQOIcYrTMByuSViQlS+zzut8FBd9FbjLFR3/SD8uXNFvjk3+FRm3l 1YRU4NFRvBFscBwHsKP1F9FP2v4sGZiS89iQOxpiCs4NKy1GPp5wLb27dz+5wmZb WaGPyhYMs79ZzT/YSJ56jOdzHiB9X6WWtAfAPWLsWflS7PTXUcgldOxfGZJDRqTH typXjkSbqGuupaZ2PE4VvS0Z8ff2Z2gCCU4HJg9vlUWKU6OaR5V3NVJgWvTslfic eRc5mg== 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 42ncxbtu7k-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:51:35 +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 822A24004B; Tue, 5 Nov 2024 08:50:22 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 965DD25051F; Tue, 5 Nov 2024 08:49: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; Tue, 5 Nov 2024 08:49:31 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:08 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-5-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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:50:38 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 4AA5F1FF5E3; Tue, 5 Nov 2024 07:52:48 +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=1730793171; cv=none; b=SFysXnHk0E99nYahct2RQPdVpmNet4HxzUPjla6blKHI3uBeGdbeTdzmdPaq7XWTddYbtXctqmy8xxBy7A0BuDM37mBIVZMIufocuWTDDUQoRpeMVg7Y2YCFsGPuq9RS/PsoqgWu5DOEL3zNcuxqTc+ucVKi0TsWKNbDwsL/XrM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793171; c=relaxed/simple; bh=0L0wzzkDtib2Wnd8hi1ULjk1/pzs7S/3Q3eiYVfK5O8=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=KG1KBI/9S0VeKwDXPkySdN1cnMgRWu2OiUQrAVsR3jIuS4H5uyUcDCWalO8TIoKblB4zvdeVeotAh7N5aTltkZFYN5rYn1w6lXE2VLs3GmAgLzS99MvusdIXraRQLYgi/NaF4WkhBvzkLiY3505w7N3BPRnlRNDtPJW0+iPgJG8= 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=iI7TwTGl; 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="iI7TwTGl" 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 4A52Eak7029108; Tue, 5 Nov 2024 08:52:33 +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=iI7TwTGlMXDX638F D9n6O57b+IRnqGMn8yXG8OHJK+PDh/PEy4Ldfwf8Of+SG+huUVI5FijmP+BjTFzz 5x0QKrhecHNui/fTDYnHe8Wm6JKf6jGg42XV0OzfAkzCQ7RPqq+0DqoKYJXfLVTk t6S8/Put7kSnLiIUhPYDpNavGJn8zAYkD+4Dz/j27kPQr//hs04kYfohRzncPIya Aw02za8pa16hdcnVy7geCbm1OAFJ0WHVWNJZ4j/S7OgYz+OhHewiIqIFOWTM3O3j 1ovHYWJlEkTLUGhs+WoMsf3DdyBuT4nvjGnIhu/IS4hryAdLbrlUyjH4//7CvSE6 icjlhw== 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 42nd05atae-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:52:32 +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 9C65240046; Tue, 5 Nov 2024 08:50:26 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 38827250790; Tue, 5 Nov 2024 08:49: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; Tue, 5 Nov 2024 08:49:31 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:09 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-6-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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:50:38 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 D8D94282F1; Tue, 5 Nov 2024 07:51:58 +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=1730793120; cv=none; b=G/Nka7dFq+BIqryeuFBuQJK424mG4DvtF2F/rWn2K3hfk3b/kSzxe6w5RWIGOhSjZa1iUG8ijhY3ZBN07qKoYx5y+g+3vj4jjy/zWoXIKKvqtzvmoNUZyUmatpmh2CTbvEVld2s+7oviWT37qCwzTbOdJqPkgB6xpV5cdKDk94Y= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793120; c=relaxed/simple; bh=RAbKXpSxicJQY5KFlUMpktE5KJy3SfEZldaI12SGjGg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=L8qoXGNJYA9Uirx98BAl5cWwr/VnZDRxr6K0qx3b4KxjP1udiJerPGJ4jhMCEW3DGk3+w02g06KbTstoZL2bG8rlUv/ZB4WsYAsMupGNH+SoD4h8Wg9gMLHYd7H92vKJo6tQi1IMJCVA8bVKQ3nc2cvzSeyxvwfUhd0McIQp4gs= 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=7e9kUUUn; 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="7e9kUUUn" 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 4A50majW015451; Tue, 5 Nov 2024 08:51:38 +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=7e9kUUUnNmPyh80c 4mutBrqZScO3HOBqBENsYxdG4bIjAT0CY3DQq0qcBm9MgnAvKyGEXT5KcNMLf68F hlUlCJrYPLqq42JtvVrfvoqfR6NlMb4WU3XOo1ZUqyIZqrhlgTcY9qSWDGZ985O1 ZdlgGFNipwMnCX1cboAdg/xHEEiesOoFysLYjMjvxKgyAIZ6qPH0Wq28FNdTY164 BSS739WmIcHuVERYi3rTBfVN/fCb0Aj8C2bps4vlSFOjIM/1uoDayIU1zvlEeDcE uyfq+UbMMmo5GLknL57QfpGvuEUIhpHe/ESGbVS/2l+CKHAb7bBxGGEJCWxTGx77 v9fAow== 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 42ncxbtu83-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:51:38 +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 9E78C4004C; Tue, 5 Nov 2024 08:50:22 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id C8CCA25079F; Tue, 5 Nov 2024 08:49: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; Tue, 5 Nov 2024 08:49:32 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:10 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-7-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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:50:38 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 ED2561FEFAC; Tue, 5 Nov 2024 07:52:40 +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=1730793162; cv=none; b=CQZUhOuAq+okYWfv9NH+lYf62/fDQeEPCgFbipJmvDh7zyo+itfymzFtPDMmDxS4VcaSfBPdkJjWqAfS6t7FaR1b4n5ZLcHHdGfWjUMkTlxdlTak2tD6d+tgtutFHIoho80shLeLBhfhnYzYacZGWu8d5+PJ4jqg5Sk2yJrEwLg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793162; c=relaxed/simple; bh=a1OVlPf5Odsut2kjBhNTJuvJTaMz6Fm/zZor5eKkscE=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=ijElAvCEfkLoLTKuOSUpCGR9/Z++NZWYUlsPlC2dkk7NkZfIiYGfQjL1i41KY4ba8cVEGPFcHE6jdsZGfP7EHNU2lKCRBVT28L6e2C94Oun8Fy2vM0avXJ/FA9jdr4GG3OyyxL7gc5MhmwQIKuu+GmIjFZlLVX35r+/UJTWotAU= 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=XpkexCjy; 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="XpkexCjy" 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 4A56uQp6022315; Tue, 5 Nov 2024 08:52:27 +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=XpkexCjym+l4hQgo U6c1wzZjWYwCdjZqsUb7tcu4lZelqK17QRqJJkf+eLkVd0EK8n0xLUUmFpEVd4H4 HmVC+eMUmnfePgGeTlfkepYwIgmAXvbQts7BTPj3gp66aBIHYviZ09QnG89nnQZM fFwy45+NXFMYDthNLbpJMcs0Gi3j/Cdr5TIm4mmc15h/2cWdIYv2loDMIS1wyQ3J O1adt7S/XWxj8bdQ/moGAXiQFXL+M/D68QtqHs1uV7qIvvoTnuaLqVus8AEOn+h+ n0UYYt1D3QNamd4dq8SOQ9XMXMQYMKaOGzT6/xezRaXMQMUn2v2g/WYOwCcCapS4 wWe9cQ== 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 42ncxbtucv-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:52:27 +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 9C6E440047; Tue, 5 Nov 2024 08:50:26 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 64495250FA3; Tue, 5 Nov 2024 08:49: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; Tue, 5 Nov 2024 08:49:33 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:11 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-8-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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:50:38 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 89A6C1FDFA0; Tue, 5 Nov 2024 07:52:08 +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=1730793130; cv=none; b=K8DzIRZzRNpolBdUbdMq39k8CofRofaJQbjDnXnz6tIJC6XKdXo76CEXf+wXxnKRvi+UtTJobNlBPJ1sGPX7l4884acFvhhpNOmL7QcffxfC8IdGhUicPwYSKNjablLgqB5LoaNLIUsniH2x52sNRy2SDG8kINTu1e0kfPnA3ZM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793130; c=relaxed/simple; bh=I7l3/M2qaiyoegFrTjSIvWPFvYUUxhxa8ZQTpsAoRBY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=jY4Jyhe5NM2QnFrr8NHXhImfeGkHVwjknanCF7pB/rWDmE/L8klgq8WBzDTp2IX2rH48omDbLSc+blZiux1+etAJiCAuyo2JxrgnsuM0sEdsBokc7rb6yZnA4MYwvU/2Eb0XXo2enbiCcBHmsCy9MumEl4DnqIsgQg7UlKXCf4w= 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=IeCMdxPn; 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="IeCMdxPn" 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 4A50ipN5016086; Tue, 5 Nov 2024 08:51: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=IeCMdxPnny2UPDK0 EXen4p37aawTZIZW2wC2Fz2wJMNyeVnpOXjmELySXjsrJk3NjspCUFVLkaCxuJR2 6G529OZvRWbUAsSElVjsimfm6MJQ+lSRo3sWoPXQex1/WoYj+JXDl3erKvQ90QAG QrQOkw8Wuwrw/paZHQpbDTvFNzVPxTf17wyX4DBNDyMnbG+y+uAP9LErDSoVTYmd x40kBkKwcanler5KGKmfEWOU1crEDryUemnO+KBTcPx0zj54NccLZEUJncgddqum Tq6UVFNIWxYT7JiKXkI6yOB0Yk/qPFNCokfYjBTlwjrsM3eJgYj553e9otUWVpWz /jt/gQ== 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 42nywn8931-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:51:51 +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 B99D54004D; Tue, 5 Nov 2024 08:50:22 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 02345250FB2; Tue, 5 Nov 2024 08:49: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; Tue, 5 Nov 2024 08:49:33 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:12 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-9-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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:50:38 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 1D4A1200C9E; Tue, 5 Nov 2024 07:52:47 +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=1730793169; cv=none; b=L5WLiiijJFWMt8SRXxqhOTs7YE7zqHZBVsl9mwW/Pw2iPqVqQ1fT/KwuLBegf3PMg/2Ims/HXsRrrKxeCzbU36598gl/0BQyVERxlSwkngOsByYww3mSFHsoQCPZhI7maOaMKcLtTlNAdQpWbkPZzzJF/M6DNcN7th0rcQCwa4o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793169; 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=hbNIDVI+czAGLE6BDlLY6lgbvVZAN8W6HgU3tOs9w+qptSuBetlnQqjb8SpWKmqLpA3q7y1jqDeU3sHSZq1xG5IXI3XKBPjb52xrSuRuoQHJ8cM9qM27Oz663JyiuIyu13cAOyMf+Uwip6++GxcpbGI3ima9wqKEsy4msg5qpbE= 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=oAqww/Ll; 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="oAqww/Ll" 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 4A56U0Ai026411; Tue, 5 Nov 2024 08:52:33 +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=oAqww/LlsHcoQ7fN mdhDSQCZo0kQE+YF0NuDt1Ieq/wCy4PDmfOTM1IRHOYU5vmeYZga7YD7m9H0u9dV cdV1TZMbDtct5+hK+WeoEcbWcSzoh2Cr/RG50cm1IMViTPyAaIriDzS8DHRucA4h 1T7UtDwU4ctna/IyYVdBKXF8A8xH7ZTGG1b4+lVZZEmxXDeoT/NsuzjgdCoOup6c GTYxKTEgSQ77R9cZdU3dncAECUoTDWQ7OQj+0B1BtKHRSOf/TQ1qiO9s/9NYW5Fw q2XFCwhUW5SYmnf737qSHYiRX3XnVOuutDRvj3XtdnOzTpNrGHWpuhgIx02XXuG+ yaXTFQ== 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 42nxh3rnn8-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:52:32 +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 BFE7940051; Tue, 5 Nov 2024 08:50:26 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 8F950250FBD; Tue, 5 Nov 2024 08:49: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; Tue, 5 Nov 2024 08:49:34 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:13 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-10-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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:50:38 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 8B2DC1FEFC5; Tue, 5 Nov 2024 07:52:39 +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=1730793161; cv=none; b=p+pfg7bthwNYhnLPvb8JosIwP9egxRLPXybpjTRYax15Gl+eXD+lItvawU8wkuo/BtpgDJLyFET9SCu/8Nxvg8tSVed2fNuKa/pn6KTgD/r9YlMZS0BY6KJUtxGLq6hU1rIVdMmfq6Zct21gs7ytCIYlJQVCKktRCAzBmDfpMNs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793161; c=relaxed/simple; bh=GOKG+WYlTeedFL3kFxhYDlA0nfvxaCGr7DSSSCv1Y2E=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=fqCxX93/lI141IvLs2CedqMFV4WAkOCbEa3EaY4RjZcvOcoROfJchI46JNicKzJtduCm4BpRk2klySFOt5zrVQP+2ah+w6pycxYvQelF9aJixeYG+JfDoZ1lPII98Lw1ZED7sBMsqJOgQfEvBhCaQXWw6HvmWFxyQMjBIPpsqvQ= 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=SQSUSbUM; 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="SQSUSbUM" 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 4A53GSeY022439; Tue, 5 Nov 2024 08:52:27 +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=SQSUSbUM2zkhZuws PBy6S0AJewSp/6u3emy5wgWhSViEBlty0Wa9jCWGWeq3OnZTW+yDBQa5tdKRad+t nhL/+BPn1tfwKUS9wVq7Z+5WnGo4lsSqpD1NX63G9FiXDzUIM61z8YTkdYksIgxp MISSsopE+EBSc3bAYEArY8UYMiMf5UvK1byNc2zszl27ZiLCo9bvqkgIN/yiD0J5 DACOi5g36lZdDhU94mHYSYg2nhnO4ja2nWUQ3sxfW3VR6DWCJDKln4ohFJTLLcJ0 dT6WFF2mrB96vHBBXa5bRk/2av2m0Esa5r/tKbmUHE6V4uR2c6DnKLjO24EBt/UZ kA2+bQ== 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 42nxh3rnmj-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:52:27 +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 D735C40052; Tue, 5 Nov 2024 08:50:26 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 2DBCA250FA5; Tue, 5 Nov 2024 08:49: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; Tue, 5 Nov 2024 08:49:34 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:14 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-11-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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:50:38 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 EF1E01FEFAC; Tue, 5 Nov 2024 07:52:46 +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=1730793169; cv=none; b=j70PzV20U6q8QfOIJfmYdXJIQAgPKwigds/FlIqNKJmuEpff9ag0ewzFabU4N6xYic1SorhBZ4ZIF82+J5rdzaTT1yal+R88OnQuXtLjgHt920xL39Ouvhf/MkJEXTmdkUpHuy9hFfMXDr3rvGnHqmXR7wcobcTitbCjLfLiN8k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793169; c=relaxed/simple; bh=vdyHSmHFvDc9twKJwiPBujvnXDLawADf12qsuOd+aLI=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=Drkr8/OB6t/v+A+qKAzLvtn2gyDw4E886VYWDmYrfagd1U83kbwHeq5JrzYYJNEpHGGTS/kGHAIZS69y2nRe8E+0OGQw7xv3kj4A8q7JhB7gHaUsuFGatvsaoGh+AYjuUTM9/sD8keSg0gYJ1BizTJKe2wk0NHKb3DuMs3WIUpw= 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=h75RoMIT; 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="h75RoMIT" 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 4A56uQpA022315; Tue, 5 Nov 2024 08:52:33 +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= PXYsh4+cHK9hqfvNP3YcsqDOvzA978FnhDRsJy2BW4U=; b=h75RoMITGbMYJj+9 hRHrpc5Nkw697o+iL6nBexnCigwF6TEs3wUTuG8VQ6qKcD5BuHIQEVDMyMUZuar1 iPxz/kupKp1nxA9lCN/SSG26ZB6jA6hhgyAvCIxrsUywyYNFW4hTyap/qo55ilxF Bd7pdDaqPVnDaW1tWcDf+4zjiCmBIjnTXR3UkvMgFt35fGyT5a5jtvMUsOs/QW2A d5KOocUvaxzkRSRK6/HTOLw0zag9W0Yyghr0TodXTcdro2JdzJQKfGsygu67hIji A6ZwUPrMc8J33sMYUX4n6v3cHHR3Vwf1wAwiOyBPnUhOvNLN1Fl7ZUINh8m/qf0b uEmzng== 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 42ncxbtudg-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:52:33 +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 2565840044; Tue, 5 Nov 2024 08:50:26 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id C18B0250FC9; Tue, 5 Nov 2024 08:49: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; Tue, 5 Nov 2024 08:49:35 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:15 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-12-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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). Signed-off-by: Alain Volmat Reviewed-by: Krzysztof Kozlowski --- 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:50:38 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 5F9A71FEFC7; Tue, 5 Nov 2024 07:52:48 +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=1730793170; cv=none; b=HHBsZGWTB/RzAqh9VP4dsZqv8wgMbxJg/lB/moKAEueWu4cnKMVHPSPYUcT+MEtE75dyeosW8/mJdWauDpIGi/rRbb73z4OpOhA+OtfyvUcIGAx/+dxy812XGLjp0YOCsaVPzzEaxXhTw/WjJS+kzyEfPH9JELi7ogDRVA//uig= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793170; c=relaxed/simple; bh=yDH91BTX2Vq65u37DJRYA5qaSAe3gqvRH0thHa6GVeY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=MWfRh08o+e3XJVSZtzZYC3jkgNDxRad2PmBSr0RORKo/2q2j5vZiWrZut5BVZcmskQOfGSOY+hsRN9Nskj7pbpJbWc/rcp+Or4fuPRhvD/cgsipdPllOhsJNe6htSBoEvERxSbMou4ONOXJqGwtyq6LdMtQh87hd3Ca3iJHtJjw= 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=tHNtW1sx; 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="tHNtW1sx" 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 4A56i7rg023031; Tue, 5 Nov 2024 08:52:32 +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=tHNtW1sx8kWy2APc u0pk0Fi8C6OC38UdL/54No6ohFUPs6/gyusEn40HOrtflJMKqK5RkLCVi4H94eFl zot0q7vAQXGPQpQsig6TwmEO+sPmglm+gOsyGU3h+mvFGqfIn+xdElh6N+VSHBjR Q1Wtnp1hU1AB1f62MTMKY2a5vvEVviWBKtzHNkNnktkWQhYcL2GfLzq8ytgejkt2 bEZkgwz1Z3fOHpxPJOxUtNcPKcFWgLcOPwz3bAOLmgz9uWL/+wsvqVqj23tz9H2h Rriu9xFsqP5msrj2e4N5QTjx8WKSftFa6shvzQHoW5wcFhkdFnG8C8nV02BkF+rR Mn5MXQ== 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 42nywn897a-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:52:32 +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 2690340055; Tue, 5 Nov 2024 08:50:27 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 67340250FCC; Tue, 5 Nov 2024 08:49:36 +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; Tue, 5 Nov 2024 08:49:36 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:16 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-13-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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:50:38 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 B5B56282F1; Tue, 5 Nov 2024 07:52:40 +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=1730793162; cv=none; b=W0Ck2dI/Hpz1IDbaj02DSNgFXDe2KU+3j6vM7E2F/uAr6YHU2nYtzcblXawB3M0Fvn0+PFHktXNSnCEh/CktJ9vNTKFYiOzroabHMidOckiiwsR0jUV9tLmF4JriRh3cZXkPB1frpAUmCL84W8YdvJXmSP0n6OXA2hmTvFTVycI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793162; c=relaxed/simple; bh=V1zV4dk2RexT0VlhFpEXjyqddvw7mzRMMkBenDXXQzs=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=mf6ZE5mRYMLIabJUn3ZFE+9quKlBNHtPnB9QfYha5MLDdrNVt1oykCj7lZyqfi6OppdxjtuYEQq9UQ/ad0SV9ptPwner0Bxs/u0iiN1w61jqhIEGHGhRKcnxtQph+b5PtpVU0MyAnZrJtcloQQAIGVjNb9NjKq5l0806vI0cCJ8= 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=AcmwMSyn; 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="AcmwMSyn" 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 4A549V48025479; Tue, 5 Nov 2024 08:52:27 +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=AcmwMSynS2cZtSqX TJVEsdn86r9uuFsyt5bwqAuKA6eYiWjgAOVfMgvxnFfzjRIP8ZrWBtAp1vQfpKSG 8Gtiy+06sRCuPSlE6TzCvrksd4ohbFRY/hoYZJ/cLfWAlGHmTro32+wdUhIPG+Dn 6O5DA8Bv2erZBoZfKnn6HblXPNyX/38TCs/y1OmW5UGBeQUomZd4HAtY5PUCl1ai tjR37UNjcJngxsxG9yXO+8GdUw8boCcwu5ZbbZVS7UWiU/g28FPycM3/tF4S5uIH 98N68fD+p/V2oFqS2IlHHz6XwQPCZX4MQOFcv5TXw5SzY6TiePr/DZDnWLn960rr +Zeqcg== 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 42ncxbtucu-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:52:27 +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 AE4F040050; Tue, 5 Nov 2024 08:50:26 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 088E72513C1; Tue, 5 Nov 2024 08:49:37 +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; Tue, 5 Nov 2024 08:49:36 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:17 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-14-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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:50:38 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 585831FF02D; Tue, 5 Nov 2024 07:52:25 +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=1730793147; cv=none; b=MU37QmRs50JptsU46csetgVzdUZxcDb+/nl/X/a3KKTaN/Q3GdNV1GBj7bBNcHW65urii2l07nECs7mmA/kN1m0Tvze0rVcDHakDfyssCyfhuvNJOAMulqQIQdB8McEVCaKvHKi65jEbBK5zyEg4Gs7R7GluHQZE9wZWYrsw6aI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730793147; c=relaxed/simple; bh=t0g3tyGLXDa9mEU8ERU+pY2ZJyv+jnWCEShMpLm4R7o=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=DZpqyXzL3xOp3Wq4R2kLjX4ZLnkQI5lWOuEwQUNKIOzp4qDQX8ar81EvPykcemUbvR1eat041tAr6rihTxq4OHjx2NwQtsANLwbU8GpONsFr8OLBYAIors9j3mkqCFEGUx7wQQtY7QwOKkri4rC6BKrjyQpeULIUNeBHsdnFChs= 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=PVKwV3x5; 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="PVKwV3x5" 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 4A53M0JY005010; Tue, 5 Nov 2024 08:52:12 +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=PVKwV3x5dgrvKDs4 CVTXpQti/lb4DAzxkkYtJA3QpfonI89d7Tv8JjurCZC8CrF75RC0dTzR4IQFMq5L RmOlUVmlyodsdZ8cq24i3uURyZ24N3bLycByeNRtZKc69UHlmhvjGnNCzOqApGBJ QhxB0x1QsG6rRSoG/knLu5EYecAJcRSYLA1610DQnS5gkvjlxwHwQM4safrKmxsp ewJvEjhAVfrrRHIa1ic3B47udaD7WCkKL0YXYyIIswCgnnzpAI8foxrZM+UezxsB Nq3TrYsN9MquOFYGwdKqFHWJI7u8v0ASo5NeGkxBqbu9sb81b4QfNsnswP5zGyxp 0tWsPA== 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 42nxh3rnkd-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 05 Nov 2024 08:52:11 +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 07D3040056; Tue, 5 Nov 2024 08:50:30 +0100 (CET) Received: from Webmail-eu.st.com (shfdag1node1.st.com [10.75.129.69]) by euls16034.sgp.st.com (STMicroelectronics) with ESMTP id 9DA622513C4; Tue, 5 Nov 2024 08:49:37 +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; Tue, 5 Nov 2024 08:49:37 +0100 From: Alain Volmat Date: Tue, 5 Nov 2024 08:49:18 +0100 Subject: [PATCH v2 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: <20241105-csi_dcmipp_mp25-v2-15-b9fc8a7273c2@foss.st.com> References: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@foss.st.com> In-Reply-To: <20241105-csi_dcmipp_mp25-v2-0-b9fc8a7273c2@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: SHFCAS1NODE1.st.com (10.75.129.72) 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