From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 9363BC79F83 for ; Fri, 4 Sep 2026 07:54:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:MIME-Version:Cc:To: In-Reply-To:References:Message-Id:Content-Transfer-Encoding:Content-Type: Subject:Date:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=ozX5BWYmzocdrJ5YHKY8zieqe+xXTwfcDNt9rtEtf9c=; b=ZcHRQOZ13LYqttVxR0s356Yg88 M5b7zkEWIU2RLDTzxIzTcy2cxCUytFSvyyAUhiZUwnQ3RNRhgT9dGg72apORZjLdb1Fl43mE0Hg08 4uHEzjdbUj18w1zls5Sh1mXqkBAjeolLXxwv17+k14mHWMBpEIeX7FIvLrrVeonrVHiVE0C2F5Xj2 hJKYNFcCJnuobha4aFj+9A1Q7/TiETVIubVJQPkiUbCH2VRIjZ2rCBLM3NTQZG6HuRK0JxzwzluJX iw0po/0FXeLvRlZFjpVIXMSZVc5jkOCmIFbeFcudSL26RmXKzyzzPV2LO5ZO4n/vak1oK2/5z1RfF 69XsAQlw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1x2Okd-00000001Hqc-0HA9; Fri, 04 Sep 2026 07:54:19 +0000 Received: from mail-westeuropeazlp170110003.outbound.protection.outlook.com ([2a01:111:f403:c201::3] helo=AS8PR04CU009.outbound.protection.outlook.com) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1x2OkY-00000001Hn2-3Q6Q for linux-arm-kernel@lists.infradead.org; Fri, 04 Sep 2026 07:54:16 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=ueuPXFfqysB9CFqaNmsgKeXMJkOO5i6cMa6jY6oJoIe7vz+Ok8AmRIS2jri1S7XYa/kNEp2Xv9wUEyDvPCDiow45C0jVw6NRts7Y77kGayxvpzNEC156H2KnkBAAyn1W1rE+7WCZ+XbIt4QMNfcrtVwyTTX6ce0g2JOT5IeTin5hImgAhawA3mvNKpy6mdGdY7fcGljZ+CWe6M4GKnLLE/HaEARsPzIPr+lVAxnD1rJcLIz5NCQ03exM19nizb9mQogjOh6mPp3ftFhlpBGCeEOuXCs7q7aM6V2tI9R3qy7DEGrprHed16msr2Y8haFO5Q2FazFlOmLUdlR6YQ7F5w== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=ozX5BWYmzocdrJ5YHKY8zieqe+xXTwfcDNt9rtEtf9c=; b=tU0sKg952vB1VN5xxrfc7fNjoVpTI8dWf1luENwz/hhEyfzt05KW2pPnPHNLIzKcRetZ5Ut/iTspPxeA/EIkvB8qg59t11EmIsqXoN4/ZVlh+2K5I9HyhCeIe4MAZaaAlqkalABFQ2fMtp7zo6CuSjkoHrj3Kftz9N3LXAC8k87YiAunN17R9lS/b3iGExk+QqTLWsoKOM6YaxZwaV0AHN+XpcqXBDnzllz0Nt8uqwvdvob45S8AAKsqFP974qpfgDIK2QS5sbuWcV9/S330S17Wk4s19ob3WGlszV6eedBjk/g4YLkE/oKXGY5C7FOCxPnePVq0z35ubiJx/XHcZA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nxp.com; dmarc=pass action=none header.from=nxp.com; dkim=pass header.d=nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=ozX5BWYmzocdrJ5YHKY8zieqe+xXTwfcDNt9rtEtf9c=; b=NV+CMsiAH27syGDssSoqEZ7C/Q0UdEEX/qMfcOrQ5Br/9DU5LQtFaKu2I3z0CyCbXwz8lHhIypDCXULY7Q/oTrV2E2V/2wAi0glCytooIrDC9DFJhuAHesU7b7DDl/o+MW3gczAWZyzD3biG6bwfmjcyNCLVIGqnGalakN2OrdiLgimeYjTfGq7mmrzJUGZXwuVXj8xsfMMf+NAMtR9bpUoVpbUXIz0p9y+YMeUZKlMxlwaDPnheJrNt5OrP22pyxMJwe4yzDwFWN6pce5/eG+QDDQG9qjPTkb9ZxxTOOYL9BCNRMHN80+1FBlc5SUBUbRxYa76zgJHEYQyKKvMn9A== Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=nxp.com; Received: from MI9PR04MB350878.eurprd04.prod.outlook.com (2603:10a6:290:c0::7) by DB8PR04MB7115.eurprd04.prod.outlook.com (2603:10a6:10:128::20) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.21.360.13; Fri, 4 Sep 2026 07:54:11 +0000 Received: from MI9PR04MB350878.eurprd04.prod.outlook.com ([fe80::8537:1cdd:6c49:6151]) by MI9PR04MB350878.eurprd04.prod.outlook.com ([fe80::8537:1cdd:6c49:6151%6]) with mapi id 15.21.0360.008; Fri, 4 Sep 2026 07:54:11 +0000 From: Liu Ying Date: Fri, 04 Sep 2026 15:54:56 +0800 Subject: [PATCH v6 06/13] drm/imx: dc: Add DPR channel support Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Message-Id: <20260904-imx8-dc-prefetch-v6-6-26643e3f6cb7@nxp.com> References: <20260904-imx8-dc-prefetch-v6-0-26643e3f6cb7@nxp.com> In-Reply-To: <20260904-imx8-dc-prefetch-v6-0-26643e3f6cb7@nxp.com> To: Philipp Zabel , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , David Airlie , Simona Vetter , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Shawn Guo , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , Dmitry Baryshkov Cc: dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org, imx@lists.linux.dev, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Marek Vasut , Liu Ying , Frank Li X-Mailer: b4 0.15.2 X-ClientProxiedBy: MA5P287CA0034.INDP287.PROD.OUTLOOK.COM (2603:1096:a01:17a::11) To MI9PR04MB350878.eurprd04.prod.outlook.com (2603:10a6:290:c0::7) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: MI9PR04MB350878:EE_|DB8PR04MB7115:EE_ X-MS-Office365-Filtering-Correlation-Id: fef1edb7-b8c0-4078-fd74-08df0a59b4fa X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|19092799006|376014|7416014|23010399003|1800799024|366016|921020|11063799006|6133799003|10067099003|18002099003|22082099003|56012099006; X-Microsoft-Antispam-Message-Info: PJ5n8pBl4dUItdUh09mq9yJ7gBAUtu/f9SStjForkyTsguqqQQpND0mCbC4kFTiKjt8f2bumbkcTra7QkRWju3Gv7guJZ9HtuLVyT+ClBXS3F6iLCxUxOq3EmAxW9QU+fpYivk28WtXNRyjnWyG1VkyBGtiQN8iwTXsf55ieUtNG41SMAolU3heC859zcfSnRYpyC+txn2F/pyiskJRSCPYTcGUHqob7kw7OiOz84rjpVCK3jNZL3SHPtZiHw6yoQmYPO6KuUbheUBF67+JOFgJIQ9bGCnj4PEvAjtcBkj0bu+zdTXWXjUPlzywM0ELWx7BW/wKY/r0NXYo2K0jFRaNhIrLxQ5CMbodwDFn8MdF/Nc6xtz+b74sIT3deSAoRNN+Fd82BKsbk/PTsod73k4JGazMMrZ5se95bD/1d4Z7HDYCVzgBJxk3+eExlm/ylAjWrAj1o7SDC5Gs96kxktb2Xe2LCeIIXM7J7C/YHV8S9+ZBsEl2qKtvWEmlsY3SAgc52f7yGYEW+FeI5LofjKMpZJ5vAy5zj3ksYtsIL0S8s1VcdJZVq/vFECdyhSvL6Vv1ge6eezoXf33ngbX0fHRfHXgrG+Ig0ZCCMO5D6SzMJAVOa2p8F0jEVy5wKWyRgNw+h9GnKGlo1xvAixevSRdxwF/Frsmh+N78i5D14TWgzRng4lUWNG5VHYM71EzpcJHF1rKTHMLls2NEgnYK8IA== X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:MI9PR04MB350878.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230040)(19092799006)(376014)(7416014)(23010399003)(1800799024)(366016)(921020)(11063799006)(6133799003)(10067099003)(18002099003)(22082099003)(56012099006);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?ZGdsS0dVRXlrRWlJNUJ0bGZPdkRHM0oweHVyUlNVZEQ4R0NYcVhva0k4czlP?= =?utf-8?B?QTZzWUQzOEUvQ0tnUWoySndRaG13LzYvcVA4SFducXU5dWoybm9aQWRhbU5H?= =?utf-8?B?bWN1VVphK0dYMEdDdldPcGpTR1ltMHYwYnRyRUVjbWV0VHRxeUhlSmlTdDJ0?= =?utf-8?B?OCtYTURDZHVocVR3MVdhakNUV3NoVUVFNmwyL0l5SWF4SjlKbWpOb3A5UE1i?= =?utf-8?B?ank5d05nbFBYNVBCOS8wTG15Wk45WjBLTkVaR0YwSmF5L3NyQWtZRWlLTGdZ?= =?utf-8?B?S2ZjS1RpS0YxYzBrbGJJdDVMZ2kvOTEvei83UXYzUWpSRDdZQUw1SkVmaDdG?= =?utf-8?B?WTcwcmxYRXFxeUUxRytOcU9zTzRTV3RZMGFLaWhmT0NJMkdHNU1ad0JrSS8w?= =?utf-8?B?NVEwL2hKYVh5LythTkhQZjIzeXRoanJ5VWV4ZjNEdkxCUVRWZXVKMUd1SHd0?= =?utf-8?B?SFc2aGVXMXdFbVBFY3FGdUE3NHZOM2ZVc0RjcXQvZWJabjJzMzQ2R1EvWHF4?= =?utf-8?B?elBiY1dhcVdqMHhVa05nTU95OEdRV2ppa0NROUdxZk43M1FiSklLMmprWjBW?= =?utf-8?B?R0NJcHQvdWo2ZVIxbnRrcHR6QVN1Sm5aNTZvWXR6S1ZJbmVKSjJOTnk0OXdt?= =?utf-8?B?M2xzcTFwcWNSaVc1U2o2ZGY5QlhlcnVNTVlIeTZkTDF1WmwyOFo0blRsdFVQ?= =?utf-8?B?K045VEdGMDhKUXNMMVdGRjlDOEhyd3VpWXp4WFBCS05FSytqTzBWOXk1VGVF?= =?utf-8?B?ZW0zMkFPNEhqSnR5djZmMmJDaVhuODk3K0ltdEV6bmhwZXBJS0xLMzVxaWIw?= =?utf-8?B?ZGhKODR2c3Fub3MxL2xxNFpkTEVNRnplSVRFZ002QlhKMWo2TmsrL2VpRmtQ?= =?utf-8?B?aTY5NWl2b1llSHBMMkNrdUtzVG4zRENWZng4akIrWDN1OHc2TDZpdkRYbEJL?= =?utf-8?B?MDg4OFVWT1ozcVlxYkJpOGhhVDEwblFwdFFvTmhuWlBQWXkyUWNKUHZQdlZw?= =?utf-8?B?QzJEVzluZmR3ckRCTU1lTmNJa01IRjhqYjM2dlpqQ0Z3VUxtUXJTQnI4T0ZN?= =?utf-8?B?TWNNUlJES0FuZWpUUWZxcktUS1A0aVZ4dUExM3MvMUhFRm40c3NFZnk5cFZP?= =?utf-8?B?cDZGUEpTdHRTUWpGTFNQSWxNTVBUYWpVK3hyaEFBN0k1Q0Q4Zno1eFpCdjJJ?= =?utf-8?B?dzVDc3ZYNUxoZ0o3YjFYOTJiVVh1TEUxMWxpTUpHUEhUZkllWFFhU2Q2UGd6?= =?utf-8?B?eWE2Um4yTTJsR0RXYzVhYjBydmRtb29MNEIxYklDOUd4MDhZNEJ5UVpZc1VV?= =?utf-8?B?VUZLWUx1Y3JsMWY2WERjMnBPYjQvVmVTcEMxMTBMQmhlVS9MRVI3cTFubW5s?= =?utf-8?B?QzlIcm5CbVUwZG1xMjhyRXpORXIxR0EvdERNd1NOdmdyRFltZmVtbWVkUFBz?= =?utf-8?B?V256Q2lONTZtZEpUdXM5TGVGbllrclprSGc5TENFNnNEQUpSRFRVM2g0ZCtn?= =?utf-8?B?OHE4L2pHVkJxaHhTZlpEcUplQ1Fwbm01MW1MVDFFVGM4MFovb3ZBUXA2d0xq?= =?utf-8?B?bXlHRGhLNk1LZ1lQQWhseUJvV3NDcmlXVlBiYWVPSVg4c1VsOWtpTDJjYzY2?= =?utf-8?B?OVJFTzdBRE1QNzhLM2FMd1lBbGJNZ0VBa1ZHVFJGM05DZXhGOFlOaGNjelBO?= =?utf-8?B?SDlBQ25rN01OM2dVN2wvc3Azc1UxVVJWMkZxemdhRG81VVhlYkdqVFJWdHlM?= =?utf-8?B?WnJZbnlRM3JzejBUS05OMDJwU3RpajN0R3JlU0RKS0FnaitUSGtqT1h1MWdr?= =?utf-8?B?aVI3SDJWL1dtcnN3eFlwL251WGtVS1VlaVRwT1kyUjJaQ0loVGlmeDh1QVBl?= =?utf-8?B?WTdIb0hxRWYrTXppVE9oZ1JuSDVGSzkrR1lTQm41b2lwaGdoRXM4blQ3Z3RC?= =?utf-8?B?dGFGS21GbndybW9PcWE1WmxrbDFLZkl1ZCtETk1ORGNzZDhtZDR5VzRyV1BG?= =?utf-8?B?Snh1cWVEN0JpS1YvQS80c01OREpDNVNQS3huZjVxRkNxei8wVytYRFBVL1FR?= =?utf-8?B?VDlMdjIzdkJPdUo4ZWhuVC8reG9COTV2bHk0K0Q0R0FFZmpRRkJhcGZRKzdF?= =?utf-8?B?Q1BMSGgrV2RtYXRjTTg5R0IvcGxVNHhqekU4MHVOMTg4SS9NQ01WbllERVVG?= =?utf-8?B?d3B2dzhqTW8zOUtmNkludlZpbFdEWkNnZXhyUGJwRGdTWGNaOHhsdlZzQlVr?= =?utf-8?B?STdlREVodUpiRENSRmJ4UjJSSDFHbWhJbk5obUcxWUVwSVFxcjBxRmtNVmRH?= =?utf-8?B?UGJmS2RrcTIzWjRDVWhSMGlvTm0yeis0V0NndE9XTHVOek9lU3ZwUT09?= X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: fef1edb7-b8c0-4078-fd74-08df0a59b4fa X-MS-Exchange-CrossTenant-AuthSource: MI9PR04MB350878.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 Sep 2026 07:54:11.6640 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: Ypucmi8LM3u1QExhPLwOEEQK0DTG82Nja+I7+HXXrt3pDIcithlGLuJ+nwEFIRU6tKL3fWDcNGfl0Onc40i0yQ== X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB8PR04MB7115 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.9.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260904_005415_128411_2794C0C3 X-CRM114-Status: GOOD ( 19.10 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Display Prefetch Resolve Channel(DPRC) is a part of a prefetch engine. It fetches display data, transforms it to linear format and stores it to DPRC's RTRAM. PRG, as the other part of a prefetch engine, acts as a gasket between the RTRAM controller and a FetchUnit. Add a platform driver to support the DPRC. Reviewed-by: Frank Li Signed-off-by: Liu Ying --- v6: - Include "dc-drv.h" to avoid build warning with C=1. v3: - Call dc_dprc_enable() only when start == true. (Frank) - Collect Frank's R-b tag. v2: - Manage clocks with bulk interfaces. (Frank) - Sort variables in probe function in reverse Christmas tree fashion. (Frank) --- drivers/gpu/drm/imx/dc/Kconfig | 1 + drivers/gpu/drm/imx/dc/Makefile | 6 +- drivers/gpu/drm/imx/dc/dc-dprc.c | 467 +++++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/imx/dc/dc-dprc.h | 35 +++ drivers/gpu/drm/imx/dc/dc-drv.c | 1 + drivers/gpu/drm/imx/dc/dc-drv.h | 1 + drivers/gpu/drm/imx/dc/dc-prg.c | 12 + drivers/gpu/drm/imx/dc/dc-prg.h | 4 + 8 files changed, 524 insertions(+), 3 deletions(-) diff --git a/drivers/gpu/drm/imx/dc/Kconfig b/drivers/gpu/drm/imx/dc/Kconfig index 415993207f2e..507dc9a92d96 100644 --- a/drivers/gpu/drm/imx/dc/Kconfig +++ b/drivers/gpu/drm/imx/dc/Kconfig @@ -1,6 +1,7 @@ config DRM_IMX8_DC tristate "Freescale i.MX8 Display Controller Graphics" depends on DRM && COMMON_CLK && OF && (ARCH_MXC || COMPILE_TEST) + depends on IMX_SCU select DRM_CLIENT_SELECTION select DRM_GEM_DMA_HELPER select DRM_KMS_HELPER diff --git a/drivers/gpu/drm/imx/dc/Makefile b/drivers/gpu/drm/imx/dc/Makefile index e3a06ee3ce1a..fd5d62783971 100644 --- a/drivers/gpu/drm/imx/dc/Makefile +++ b/drivers/gpu/drm/imx/dc/Makefile @@ -1,7 +1,7 @@ # SPDX-License-Identifier: GPL-2.0 -imx8-dc-drm-objs := dc-cf.o dc-crtc.o dc-de.o dc-drv.o dc-ed.o dc-fg.o dc-fl.o \ - dc-fu.o dc-fw.o dc-ic.o dc-kms.o dc-lb.o dc-pe.o dc-prg.o \ - dc-plane.o dc-tc.o +imx8-dc-drm-objs := dc-cf.o dc-crtc.o dc-de.o dc-dprc.o dc-drv.o dc-ed.o \ + dc-fg.o dc-fl.o dc-fu.o dc-fw.o dc-ic.o dc-kms.o dc-lb.o \ + dc-pe.o dc-prg.o dc-plane.o dc-tc.o obj-$(CONFIG_DRM_IMX8_DC) += imx8-dc-drm.o diff --git a/drivers/gpu/drm/imx/dc/dc-dprc.c b/drivers/gpu/drm/imx/dc/dc-dprc.c new file mode 100644 index 000000000000..c837307f23ae --- /dev/null +++ b/drivers/gpu/drm/imx/dc/dc-dprc.c @@ -0,0 +1,467 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Copyright 2025 NXP + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "dc-dprc.h" +#include "dc-drv.h" +#include "dc-prg.h" + +#define SET 0x4 +#define CLR 0x8 +#define TOG 0xc + +#define SYSTEM_CTRL0 0x00 +#define SW_SHADOW_LOAD_SEL BIT(4) +#define SHADOW_LOAD_EN BIT(3) +#define REPEAT_EN BIT(2) +#define SOFT_RESET BIT(1) +#define RUN_EN BIT(0) /* self-clearing */ + +#define IRQ_MASK 0x20 +#define IRQ_MASK_STATUS 0x30 +#define IRQ_NONMASK_STATUS 0x40 +#define DPR2RTR_FIFO_LOAD_BUF_RDY_UV_ERROR BIT(7) +#define DPR2RTR_FIFO_LOAD_BUF_RDY_YRGB_ERROR BIT(6) +#define DPR2RTR_UV_FIFO_OVFL BIT(5) +#define DPR2RTR_YRGB_FIFO_OVFL BIT(4) +#define IRQ_AXI_READ_ERROR BIT(3) +#define IRQ_DPR_SHADOW_LOADED_MASK BIT(2) +#define IRQ_DPR_RUN BIT(1) +#define IRQ_DPR_CRTL_DONE BIT(0) +#define IRQ_CTRL_MASK GENMASK(2, 0) + +#define MODE_CTRL0 0x50 +#define A_COMP_SEL(byte) FIELD_PREP(GENMASK(17, 16), (byte)) +#define R_COMP_SEL(byte) FIELD_PREP(GENMASK(15, 14), (byte)) +#define G_COMP_SEL(byte) FIELD_PREP(GENMASK(13, 12), (byte)) +#define B_COMP_SEL(byte) FIELD_PREP(GENMASK(11, 10), (byte)) +#define PIX_SIZE_32BIT FIELD_PREP(GENMASK(7, 6), 0x2) +#define LINE4 BIT(1) +#define BUF2 0 + +#define FRAME_CTRL0 0x70 +#define PITCH(n) FIELD_PREP(GENMASK(31, 16), (n)) + +#define FRAME_1P_CTRL0 0x90 +#define FRAME_2P_CTRL0 0xe0 +#define MAX_BYTES_PREQ_MASK GENMASK(2, 0) +#define BYTE_1K FIELD_PREP(MAX_BYTES_PREQ_MASK, 0x4) + +#define FRAME_1P_PIX_X_CTRL 0xa0 +#define NUM_X_PIX_WIDE(n) FIELD_PREP(GENMASK(15, 0), (n)) + +#define FRAME_1P_PIX_Y_CTRL 0xb0 +#define NUM_Y_PIX_HIGH(n) FIELD_PREP(GENMASK(15, 0), (n)) + +#define FRAME_1P_BASE_ADDR_CTRL0 0xc0 + +#define FRAME_PIX_X_ULC_CTRL 0xf0 +#define CROP_ULC_X(n) FIELD_PREP(GENMASK(15, 0), (n)) + +#define FRAME_PIX_Y_ULC_CTRL 0x100 +#define CROP_ULC_Y(n) FIELD_PREP(GENMASK(15, 0), (n)) + +#define FRAME_2P_BASE_ADDR_CTRL0 0x110 + +#define STATUS_CTRL0 0x130 +#define STATUS_CTRL1 0x140 + +#define RTRAM_CTRL0 0x200 +#define THRES_LOW(n) FIELD_PREP(GENMASK(6, 4), (n)) +#define THRES_HIGH(n) FIELD_PREP(GENMASK(3, 1), (n)) + +#define DPU_DRPC_MAX_STRIDE 0x10000 +#define DPU_DPRC_MAX_RTRAM_WIDTH 2880 + +struct dc_dprc { + struct device *dev; + struct regmap *reg; + struct clk_bulk_data *clks; + int num_clks; + struct imx_sc_ipc *ipc_handle; + spinlock_t lock; /* protect IRQ registers */ + u32 sc_resource; + struct dc_prg *prg; +}; + +static const struct regmap_range dc_dprc_regmap_write_ranges[] = { + regmap_reg_range(SYSTEM_CTRL0, SYSTEM_CTRL0 + TOG), + regmap_reg_range(IRQ_MASK, IRQ_MASK + TOG), + regmap_reg_range(IRQ_NONMASK_STATUS, MODE_CTRL0 + TOG), + regmap_reg_range(FRAME_CTRL0, FRAME_CTRL0 + TOG), + regmap_reg_range(FRAME_1P_CTRL0, FRAME_1P_BASE_ADDR_CTRL0 + TOG), + regmap_reg_range(FRAME_PIX_X_ULC_CTRL, FRAME_2P_BASE_ADDR_CTRL0 + TOG), + regmap_reg_range(STATUS_CTRL0, STATUS_CTRL0 + TOG), + regmap_reg_range(RTRAM_CTRL0, RTRAM_CTRL0 + TOG), +}; + +static const struct regmap_range dc_dprc_regmap_read_ranges[] = { + regmap_reg_range(SYSTEM_CTRL0, SYSTEM_CTRL0 + TOG), + regmap_reg_range(IRQ_MASK, IRQ_MASK_STATUS + TOG), + regmap_reg_range(MODE_CTRL0, MODE_CTRL0 + TOG), + regmap_reg_range(FRAME_CTRL0, FRAME_CTRL0 + TOG), + regmap_reg_range(FRAME_1P_CTRL0, FRAME_1P_BASE_ADDR_CTRL0 + TOG), + regmap_reg_range(FRAME_PIX_X_ULC_CTRL, FRAME_2P_BASE_ADDR_CTRL0 + TOG), + regmap_reg_range(STATUS_CTRL0, STATUS_CTRL1 + TOG), + regmap_reg_range(RTRAM_CTRL0, RTRAM_CTRL0 + TOG), +}; + +static const struct regmap_access_table dc_dprc_regmap_write_table = { + .yes_ranges = dc_dprc_regmap_write_ranges, + .n_yes_ranges = ARRAY_SIZE(dc_dprc_regmap_write_ranges), +}; + +static const struct regmap_access_table dc_dprc_regmap_read_table = { + .yes_ranges = dc_dprc_regmap_read_ranges, + .n_yes_ranges = ARRAY_SIZE(dc_dprc_regmap_read_ranges), +}; + +static const struct regmap_config dc_dprc_regmap_config = { + .reg_bits = 32, + .reg_stride = 4, + .val_bits = 32, + .fast_io = true, + .wr_table = &dc_dprc_regmap_write_table, + .rd_table = &dc_dprc_regmap_read_table, + .max_register = RTRAM_CTRL0 + TOG, +}; + +static void dc_dprc_set_stream_id(struct dc_dprc *dprc, unsigned int stream_id) +{ + int ret; + + ret = imx_sc_misc_set_control(dprc->ipc_handle, dprc->sc_resource, + IMX_SC_C_KACHUNK_SEL, stream_id); + if (ret) + dev_err(dprc->dev, "failed to set KACHUNK_SEL: %d\n", ret); +} + +static void dc_dprc_reset(struct dc_dprc *dprc) +{ + regmap_write(dprc->reg, SYSTEM_CTRL0 + SET, SOFT_RESET); + fsleep(20); + regmap_write(dprc->reg, SYSTEM_CTRL0 + CLR, SOFT_RESET); + fsleep(20); +} + +static void dc_dprc_enable(struct dc_dprc *dprc) +{ + dc_prg_enable(dprc->prg); +} + +static void dc_dprc_reg_update(struct dc_dprc *dprc) +{ + dc_prg_reg_update(dprc->prg); +} + +static void dc_dprc_enable_ctrl_done_irq(struct dc_dprc *dprc) +{ + guard(spinlock_irqsave)(&dprc->lock); + regmap_write(dprc->reg, IRQ_MASK + CLR, IRQ_DPR_CRTL_DONE); +} + +void dc_dprc_configure(struct dc_dprc *dprc, unsigned int stream_id, + unsigned int width, unsigned int height, + unsigned int stride, + const struct drm_format_info *format, + dma_addr_t baddr, bool start) +{ + unsigned int prg_stride = width * format->cpp[0]; + unsigned int bpp = format->cpp[0] * 8; + struct device *dev = dprc->dev; + unsigned int p1_w, p1_h; + u32 val; + int ret; + + if (start) { + ret = pm_runtime_resume_and_get(dev); + if (ret < 0) { + dev_err(dev, "failed to get RPM: %d\n", ret); + return; + } + + dc_dprc_set_stream_id(dprc, stream_id); + } + + p1_w = round_up(width, format->cpp[0] == 2 ? 32 : 16); + p1_h = round_up(height, 4); + + regmap_write(dprc->reg, FRAME_CTRL0, PITCH(stride)); + regmap_write(dprc->reg, FRAME_1P_CTRL0, BYTE_1K); + regmap_write(dprc->reg, FRAME_1P_PIX_X_CTRL, NUM_X_PIX_WIDE(p1_w)); + regmap_write(dprc->reg, FRAME_1P_PIX_Y_CTRL, NUM_Y_PIX_HIGH(p1_h)); + regmap_write(dprc->reg, FRAME_1P_BASE_ADDR_CTRL0, baddr); + regmap_write(dprc->reg, FRAME_PIX_X_ULC_CTRL, CROP_ULC_X(0)); + regmap_write(dprc->reg, FRAME_PIX_Y_ULC_CTRL, CROP_ULC_Y(0)); + + regmap_write(dprc->reg, RTRAM_CTRL0, THRES_LOW(3) | THRES_HIGH(7)); + + val = LINE4 | BUF2; + switch (format->format) { + case DRM_FORMAT_XRGB8888: + /* + * It turns out pixel components are mapped directly + * without position change via DPR processing with + * the following color component configurations. + * Leave the pixel format to be handled by the + * display controllers. + */ + val |= A_COMP_SEL(3) | R_COMP_SEL(2) | + G_COMP_SEL(1) | B_COMP_SEL(0); + val |= PIX_SIZE_32BIT; + break; + default: + dev_err(dev, "unsupported format 0x%08x\n", format->format); + return; + } + regmap_write(dprc->reg, MODE_CTRL0, val); + + if (start) { + /* software shadow load for the first frame */ + val = SW_SHADOW_LOAD_SEL | SHADOW_LOAD_EN; + regmap_write(dprc->reg, SYSTEM_CTRL0, val); + + /* and then, run... */ + val |= RUN_EN | REPEAT_EN; + regmap_write(dprc->reg, SYSTEM_CTRL0, val); + } + + dc_prg_configure(dprc->prg, width, height, prg_stride, bpp, baddr, start); + + if (start) + dc_dprc_enable(dprc); + + dc_dprc_reg_update(dprc); + + if (start) + dc_dprc_enable_ctrl_done_irq(dprc); + + dev_dbg(dev, "w: %u, h: %u, s: %u, fmt: 0x%08x\n", + width, height, stride, format->format); +} + +void dc_dprc_disable_repeat_en(struct dc_dprc *dprc) +{ + regmap_write(dprc->reg, SYSTEM_CTRL0 + CLR, REPEAT_EN); + dev_dbg(dprc->dev, "disable REPEAT_EN\n"); +} + +void dc_dprc_disable(struct dc_dprc *dprc) +{ + dc_prg_disable(dprc->prg); + + pm_runtime_put(dprc->dev); + + dev_dbg(dprc->dev, "disable\n"); +} + +void dc_dprc_disable_at_boot(struct dc_dprc *dprc) +{ + dc_prg_disable_at_boot(dprc->prg); + + clk_bulk_disable_unprepare(dprc->num_clks, dprc->clks); + + dev_dbg(dprc->dev, "disable at boot\n"); +} + +static void dc_dprc_ctrl_done_handle(struct dc_dprc *dprc) +{ + regmap_write(dprc->reg, SYSTEM_CTRL0, REPEAT_EN); + + dc_prg_shadow_enable(dprc->prg); + + dev_dbg(dprc->dev, "CTRL done handle\n"); +} + +static irqreturn_t dc_dprc_wrap_irq_handler(int irq, void *data) +{ + struct dc_dprc *dprc = data; + struct device *dev = dprc->dev; + u32 mask, status; + + scoped_guard(spinlock, &dprc->lock) { + /* cache valid IRQ status */ + regmap_read(dprc->reg, IRQ_MASK, &mask); + regmap_read(dprc->reg, IRQ_MASK_STATUS, &status); + status &= ~mask; + + /* mask the IRQ(s) being handled */ + regmap_write(dprc->reg, IRQ_MASK + SET, status); + + /* clear status register */ + regmap_write(dprc->reg, IRQ_MASK_STATUS, status); + } + + if (status & DPR2RTR_FIFO_LOAD_BUF_RDY_UV_ERROR) + dev_err(dev, "DPR to RTRAM FIFO load UV buffer ready error\n"); + + if (status & DPR2RTR_FIFO_LOAD_BUF_RDY_YRGB_ERROR) + dev_err(dev, "DPR to RTRAM FIFO load YRGB buffer ready error\n"); + + if (status & DPR2RTR_UV_FIFO_OVFL) + dev_err(dev, "DPR to RTRAM FIFO UV FIFO overflow\n"); + + if (status & DPR2RTR_YRGB_FIFO_OVFL) + dev_err(dev, "DPR to RTRAM FIFO YRGB FIFO overflow\n"); + + if (status & IRQ_AXI_READ_ERROR) + dev_err(dev, "AXI read error\n"); + + if (status & IRQ_DPR_CRTL_DONE) + dc_dprc_ctrl_done_handle(dprc); + + return IRQ_HANDLED; +} + +bool dc_dprc_rtram_width_supported(struct dc_dprc *dprc, unsigned int width) +{ + return width <= DPU_DPRC_MAX_RTRAM_WIDTH; +} + +bool dc_dprc_stride_supported(struct dc_dprc *dprc, + unsigned int stride, unsigned int width, + const struct drm_format_info *format, + dma_addr_t baddr) +{ + unsigned int prg_stride = width * format->cpp[0]; + + if (stride > DPU_DRPC_MAX_STRIDE) + return false; + + if (!dc_prg_stride_supported(dprc->prg, prg_stride, baddr)) + return false; + + return true; +} + +static int dc_dprc_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct device_node *np = dev->of_node; + struct resource *res; + struct dc_dprc *dprc; + void __iomem *base; + int ret, wrap_irq; + + dprc = devm_kzalloc(dev, sizeof(*dprc), GFP_KERNEL); + if (!dprc) + return -ENOMEM; + + ret = imx_scu_get_handle(&dprc->ipc_handle); + if (ret) + return dev_err_probe(dev, ret, "failed to get SCU ipc handle\n"); + + base = devm_platform_get_and_ioremap_resource(pdev, 0, &res); + if (IS_ERR(base)) + return PTR_ERR(base); + + dprc->reg = devm_regmap_init_mmio(dev, base, &dc_dprc_regmap_config); + if (IS_ERR(dprc->reg)) + return PTR_ERR(dprc->reg); + + wrap_irq = platform_get_irq_byname(pdev, "dpr_wrap"); + if (wrap_irq < 0) + return -ENODEV; + + dprc->num_clks = devm_clk_bulk_get_all(dev, &dprc->clks); + if (dprc->num_clks < 0) + return dev_err_probe(dev, dprc->num_clks, "failed to get clocks\n"); + + ret = of_property_read_u32(np, "fsl,sc-resource", &dprc->sc_resource); + if (ret) { + dev_err(dev, "failed to get SC resource %d\n", ret); + return ret; + } + + dprc->prg = dc_prg_lookup_by_phandle(dev, "fsl,prgs", 0); + if (!dprc->prg) + return dev_err_probe(dev, -EPROBE_DEFER, + "failed to lookup PRG\n"); + + dc_prg_set_dprc(dprc->prg, dprc); + + dprc->dev = dev; + spin_lock_init(&dprc->lock); + + ret = devm_request_irq(dev, wrap_irq, dc_dprc_wrap_irq_handler, + IRQF_SHARED, dev_name(dev), dprc); + if (ret < 0) { + dev_err(dev, "failed to request dpr_wrap IRQ(%d): %d\n", + wrap_irq, ret); + return ret; + } + + dev_set_drvdata(dev, dprc); + + ret = devm_pm_runtime_enable(dev); + if (ret) + return dev_err_probe(dev, ret, "failed to enable PM runtime\n"); + + return 0; +} + +static int dc_dprc_runtime_suspend(struct device *dev) +{ + struct dc_dprc *dprc = dev_get_drvdata(dev); + + clk_bulk_disable_unprepare(dprc->num_clks, dprc->clks); + + return 0; +} + +static int dc_dprc_runtime_resume(struct device *dev) +{ + struct dc_dprc *dprc = dev_get_drvdata(dev); + int ret; + + ret = clk_bulk_prepare_enable(dprc->num_clks, dprc->clks); + if (ret) { + dev_err(dev, "failed to enable clocks: %d\n", ret); + return ret; + } + + dc_dprc_reset(dprc); + + /* disable all control IRQs and enable all error IRQs */ + guard(spinlock_irqsave)(&dprc->lock); + regmap_write(dprc->reg, IRQ_MASK, IRQ_CTRL_MASK); + + return 0; +} + +static const struct dev_pm_ops dc_dprc_pm_ops = { + RUNTIME_PM_OPS(dc_dprc_runtime_suspend, dc_dprc_runtime_resume, NULL) +}; + +static const struct of_device_id dc_dprc_dt_ids[] = { + { .compatible = "fsl,imx8qxp-dpr-channel", }, + { /* sentinel */ } +}; + +struct platform_driver dc_dprc_driver = { + .probe = dc_dprc_probe, + .driver = { + .name = "imx8-dc-dpr-channel", + .suppress_bind_attrs = true, + .of_match_table = dc_dprc_dt_ids, + .pm = pm_ptr(&dc_dprc_pm_ops), + }, +}; diff --git a/drivers/gpu/drm/imx/dc/dc-dprc.h b/drivers/gpu/drm/imx/dc/dc-dprc.h new file mode 100644 index 000000000000..f977858b57fe --- /dev/null +++ b/drivers/gpu/drm/imx/dc/dc-dprc.h @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright 2025 NXP + */ + +#ifndef __DC_DPRC_H__ +#define __DC_DPRC_H__ + +#include +#include + +#include + +struct dc_dprc; + +void dc_dprc_configure(struct dc_dprc *dprc, unsigned int stream_id, + unsigned int width, unsigned int height, + unsigned int stride, + const struct drm_format_info *format, + dma_addr_t baddr, bool start); + +void dc_dprc_disable_repeat_en(struct dc_dprc *dprc); + +void dc_dprc_disable(struct dc_dprc *dprc); + +void dc_dprc_disable_at_boot(struct dc_dprc *dprc); + +bool dc_dprc_rtram_width_supported(struct dc_dprc *dprc, unsigned int width); + +bool dc_dprc_stride_supported(struct dc_dprc *dprc, + unsigned int stride, unsigned int width, + const struct drm_format_info *format, + dma_addr_t baddr); + +#endif diff --git a/drivers/gpu/drm/imx/dc/dc-drv.c b/drivers/gpu/drm/imx/dc/dc-drv.c index 49e18ed59d8c..0ce48b248cfa 100644 --- a/drivers/gpu/drm/imx/dc/dc-drv.c +++ b/drivers/gpu/drm/imx/dc/dc-drv.c @@ -268,6 +268,7 @@ static struct platform_driver dc_driver = { static struct platform_driver * const dc_drivers[] = { &dc_cf_driver, &dc_de_driver, + &dc_dprc_driver, &dc_ed_driver, &dc_fg_driver, &dc_fl_driver, diff --git a/drivers/gpu/drm/imx/dc/dc-drv.h b/drivers/gpu/drm/imx/dc/dc-drv.h index 557e7d90e4ea..93a8ce4e7c31 100644 --- a/drivers/gpu/drm/imx/dc/dc-drv.h +++ b/drivers/gpu/drm/imx/dc/dc-drv.h @@ -74,6 +74,7 @@ int dc_plane_init(struct dc_drm_device *dc_drm, struct dc_plane *dc_plane); extern struct platform_driver dc_cf_driver; extern struct platform_driver dc_de_driver; +extern struct platform_driver dc_dprc_driver; extern struct platform_driver dc_ed_driver; extern struct platform_driver dc_fg_driver; extern struct platform_driver dc_fl_driver; diff --git a/drivers/gpu/drm/imx/dc/dc-prg.c b/drivers/gpu/drm/imx/dc/dc-prg.c index 111ff026eec8..232a73917714 100644 --- a/drivers/gpu/drm/imx/dc/dc-prg.c +++ b/drivers/gpu/drm/imx/dc/dc-prg.c @@ -19,6 +19,7 @@ #include #include +#include "dc-dprc.h" #include "dc-drv.h" #include "dc-prg.h" @@ -64,6 +65,7 @@ struct dc_prg { struct list_head list; struct clk_bulk_data *clks; int num_clks; + struct dc_dprc *dprc; }; static DEFINE_MUTEX(dc_prg_list_mutex); @@ -216,6 +218,16 @@ dc_prg_lookup_by_phandle(struct device *dev, const char *name, int index) return NULL; } +void dc_prg_set_dprc(struct dc_prg *prg, struct dc_dprc *dprc) +{ + prg->dprc = dprc; +} + +struct dc_dprc *dc_prg_get_dprc(struct dc_prg *prg) +{ + return prg->dprc; +} + static int dc_prg_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; diff --git a/drivers/gpu/drm/imx/dc/dc-prg.h b/drivers/gpu/drm/imx/dc/dc-prg.h index 6fd9b050bfa1..f29d154f7de5 100644 --- a/drivers/gpu/drm/imx/dc/dc-prg.h +++ b/drivers/gpu/drm/imx/dc/dc-prg.h @@ -32,4 +32,8 @@ bool dc_prg_stride_supported(struct dc_prg *prg, struct dc_prg * dc_prg_lookup_by_phandle(struct device *dev, const char *name, int index); +void dc_prg_set_dprc(struct dc_prg *prg, struct dc_dprc *dprc); + +struct dc_dprc *dc_prg_get_dprc(struct dc_prg *prg); + #endif -- 2.43.0