From nobody Mon Feb 9 17:35:27 2026 Received: from BL2PR02CU003.outbound.protection.outlook.com (mail-eastusazon11011029.outbound.protection.outlook.com [52.101.52.29]) (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 58462284894 for ; Mon, 26 Jan 2026 19:28:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=52.101.52.29 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769455709; cv=fail; b=dt/Ip1EMNcV6zkqohnCIK/dI0YEt79I8T3xJjRWUGHv86DVZXGrooSnINLxlGKSJ3+SOgf9LnUHinblsWDNN+qkZ7PBPU/XBoRSZ6yKJCEKC1R55nUbiU7yuyMd2TgBmXs/XypyITF35whlQVGQ8EAHOa7z0bor6f/tKtNkMJwQ= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1769455709; c=relaxed/simple; bh=S2XoAAtlsaBIVcg/j49R3cD/HuMextrr/sOenmmdgDA=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=gsMrGGZIrWXkAbhZUwfiJvSAIf7O0S0kn00OeEqMRy2yDQhhz/qL2oAtQwf3FsFALEwj3nVsj5atA4l+DKXiDR5Atj3e34Me63OHFxMiNiZU7bK8iHGHHuw5pZPep2Xu958LdrMaWj8DaNCV48ynUA/2pPd53l5U6cm663PJ3qU= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=amd.com; spf=fail smtp.mailfrom=amd.com; dkim=pass (1024-bit key) header.d=amd.com header.i=@amd.com header.b=PuMbPYRe; arc=fail smtp.client-ip=52.101.52.29 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=amd.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=amd.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=amd.com header.i=@amd.com header.b="PuMbPYRe" ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=SIrKKjm/TbAUhHL1eQusMK7tbiSHEZUwqKtHNQU4MHgW7TP1x0p46QCklVgH6WdSbr3qPljKptCva/uGbE+TH/AXgwW6noS2vx1+KBSfxn2p/m9kJ5/Gu7CWmW7Gwt9rd3045kS1Pl227QJfWzVGvdkolaFFEWKfMJqPP2vJwO4tc3fRsnXSHMhrffnJHZ00FyCtxIt2jE9ct0dfo2sK05Gh86fj/fFpuNfUmSAKjO6lp31N2bV5YQCrealuBqFrfPXN1qQqbP+9ZqOPCgcPe2psq9dyCZhBWm4OVYk1dB4UbisXRBUQfOu74Q/yNb/Nl9AUd38lsrCWfMzkFmmpmA== 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=wTbSn/EkbBKDF5WC+GqtU9wMbP7eMfLgwR/ZBugwlm8=; b=T0s2w9LKi7eo+dtmcJTnR/RYUdjpm1J6uzqCOWusFPzTmnfeHGn6aG/bATT1wCDfEUMPDRq0pWhYB2BZObERpuIWn8qobDYjYBUl9GvvDEEDZ7x58xUkRrywX+wljDFM9eSOvGPQJruWMo732Y1s4q29uS5uZQQp4rpaL6D2x18Fi/6tOf6c1PfyT3uHVowUk3hV/v54h3YGyPbTfK8KBbBpeTCQf2PDkkwBwWPlvjtoCi5siqlEERcpi6P//SZyidYZRbXbchlJyEIIjJ2AQhGCmnbSY1wpWDBFIljJnTF8yxCo4CjdSHxcorLl35bZGnJLiY4OXj0YjH3XD8QDNg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=kernel.org smtp.mailfrom=amd.com; dmarc=pass (p=quarantine sp=quarantine pct=100) action=none header.from=amd.com; dkim=none (message not signed); arc=none (0) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amd.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=wTbSn/EkbBKDF5WC+GqtU9wMbP7eMfLgwR/ZBugwlm8=; b=PuMbPYReuhBjr17VMW+7ItdADZK6r2zJAkGXRxfR7f5+ZKTqm4GFmi7F2qkfgH+fUf/YZ6qtFaa5F74eqd+8loDnOc7ZCGRX5iLPOvXLGc5YsVsCgJN0BNsg6L4Nb9SQhZETYY0rnqPgRuf2vt3zI/irhG5Un+5uonXF1t45x4k= Received: from BL1PR13CA0170.namprd13.prod.outlook.com (2603:10b6:208:2bd::25) by DS2PR12MB9589.namprd12.prod.outlook.com (2603:10b6:8:279::7) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.9542.15; Mon, 26 Jan 2026 19:28:20 +0000 Received: from MN1PEPF0000F0E1.namprd04.prod.outlook.com (2603:10b6:208:2bd:cafe::37) by BL1PR13CA0170.outlook.office365.com (2603:10b6:208:2bd::25) with Microsoft SMTP Server (version=TLS1_3, cipher=TLS_AES_256_GCM_SHA384) id 15.20.9564.7 via Frontend Transport; Mon, 26 Jan 2026 19:28:14 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 165.204.84.17) smtp.mailfrom=amd.com; dkim=none (message not signed) header.d=none;dmarc=pass action=none header.from=amd.com; Received-SPF: Pass (protection.outlook.com: domain of amd.com designates 165.204.84.17 as permitted sender) receiver=protection.outlook.com; client-ip=165.204.84.17; helo=satlexmb08.amd.com; pr=C Received: from satlexmb08.amd.com (165.204.84.17) by MN1PEPF0000F0E1.mail.protection.outlook.com (10.167.242.39) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.9564.3 via Frontend Transport; Mon, 26 Jan 2026 19:28:20 +0000 Received: from SATLEXMB03.amd.com (10.181.40.144) by satlexmb08.amd.com (10.181.42.217) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.2.2562.17; Mon, 26 Jan 2026 13:28:02 -0600 Received: from satlexmb08.amd.com (10.181.42.217) by SATLEXMB03.amd.com (10.181.40.144) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.39; Mon, 26 Jan 2026 13:28:02 -0600 Received: from xsjdavidzha51.xilinx.com (10.180.168.240) by satlexmb08.amd.com (10.181.42.217) with Microsoft SMTP Server id 15.2.2562.17 via Frontend Transport; Mon, 26 Jan 2026 13:28:01 -0600 From: David Zhang To: , , , , CC: , , , , Nishad Saraf Subject: [PATCH V2 3/5] accel/amd_vpci: Add Remote Management(RM) queue infrastructure Date: Mon, 26 Jan 2026 11:27:30 -0800 Message-ID: <20260126192732.1507084-4-yidong.zhang@amd.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260126192732.1507084-1-yidong.zhang@amd.com> References: <20260126192732.1507084-1-yidong.zhang@amd.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: None (SATLEXMB03.amd.com: yidong.zhang@amd.com does not designate permitted sender hosts) X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: MN1PEPF0000F0E1:EE_|DS2PR12MB9589:EE_ X-MS-Office365-Filtering-Correlation-Id: 02a4ed89-5115-49ba-89cf-08de5d11106a X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|82310400026|376014|36860700013|1800799024; X-Microsoft-Antispam-Message-Info: =?us-ascii?Q?YeDuPVQHtuJVLwGXP+8YDdaRMSJvlArbXibMd6/q7lOEPDGc8yRxhPQqmktA?= =?us-ascii?Q?v+XBfrdBC+5EkQ9Nex5dO7oqmt1YkpWhOymGw5Jys6s1VehJCyvfDjnund+n?= =?us-ascii?Q?ioLdjv2j11lDzEPtfoeF4tcS6YzZsiybOKA2B5leRMcidjGIPZwMDYyvSpbf?= =?us-ascii?Q?U6UzqI4eiJ3zu0qgzkatXQzF214/3q+pGQWCbZPoy99B0RP7TMJFIoggxvE1?= =?us-ascii?Q?bmIaTdYvFK7MOoc7iIlaZ3rQZLKY7PlMXUEckB81ikNMMZ3D0EOP4JYmm8os?= =?us-ascii?Q?eEgdv/HnONUV8bR6YuzH07pF0ZQ3yJxzFufSBLbQaxGnHNdtrxpnE3IYhAlP?= =?us-ascii?Q?JoxEHDdxtufoUyab7erRRdbjsaXQXWpcCc+bH9qZ4CkhULdWoRpXp07Mbx9U?= =?us-ascii?Q?yS8asxPlGfjKzkRSOAJy1G5HMDXSFgAGYZsxd6IvokSpaDlXduLG+CET5zOA?= =?us-ascii?Q?Sf1ptasu18vD1LCcVtO1MHadRf5mtt9IYrOzclu1RYs0YXrPBBMf2D5wT+J3?= =?us-ascii?Q?RAvKeLG1ZjQtKoXLbUBTAoxjSTJs/R09/NBDsFOXuaefIDQcmr2g6vLB8SYB?= =?us-ascii?Q?IbHELw37DcBNeC8R7vkSfba3XUxCHeQFbrWArhSLO9Vlo6D6Kt2+V6yOo1dv?= =?us-ascii?Q?Fvo9eHRcstv7XDTJMPjZ62LoatkCdgGpDbkr4DN7i7KT/iFRL5BQLSa+K1W3?= =?us-ascii?Q?/kLj26xqZIAJYB0IW7m1kp09du8Rqfn6X0BcC8r9dmA2Dc04ZupEh7QvUWxq?= =?us-ascii?Q?PfZe9ZFfq1hEQJRumLbUrYRdkA+mUBrNabKzCrvIxgI1fKKQsS2lfsQywmcz?= =?us-ascii?Q?5ZjIAC7UGOUPKzqC0WiHrBIqJ85nEYVHe3qKtCyLkX/8Al4WmtGGPgEAEYTe?= =?us-ascii?Q?1AxSbL8hrSejSALaQUS7NC74CYyLUXXPXrDB+o+slRL13ht0fe0I7aEaGgxI?= =?us-ascii?Q?j0Ai+kO71Va2uoIinzFlUkJFyo/HzvCF+hYQOw+FnAInrAgJbwGcxxrf1B+3?= =?us-ascii?Q?hDX1AXRehr0zimavf9HrZ+ywRkYMxPW94InjNgOSfe754Ihlanf2UqUefrcw?= =?us-ascii?Q?eN6MWdXFfSgZb9R7GMBCiEri0poP9l8n9H5vv8VmTxR6v6vVd9pZuUUAtvIZ?= =?us-ascii?Q?fEcDF6iVa8AJGfsF4C2aRgGqsakRTwQNJ29WiHEjWJ/k2g5ho3ddGA4Xl2Ad?= =?us-ascii?Q?aE4v0aet/2+Hz48laaU0V3SreThnwC0Qgx5PN/K/EmVz7eHwz8494c0LPfa2?= =?us-ascii?Q?I52TYBQT2cPpwZmUgukRt4xUC4Ug8aP4nsTVRZQ5fKrJNecitHgHngoZRLVX?= =?us-ascii?Q?CtVb/3nfCEykGEe0A/3zOC5c2dRNcbGlWm8DSjh+/YamhePW9OP7/ANx1hoM?= =?us-ascii?Q?Tp+hWu2KEmKFYO3OZznccsN+CmzDVhZcj7DqcIKXhkjklY9v7sQfINhCLo+1?= =?us-ascii?Q?wowqvagzS7uNtBEBIvr+OQb9lEVHH1MlPq1Eg+9n9508L5psfYHDoaMv3Btw?= =?us-ascii?Q?0+mgRH2w/1bZhPAC58SsAW6uVvzN+BYzYC5TdrhL1iznswKbTDvVBi5nxBYN?= =?us-ascii?Q?7aZj6oPPPrEMELUQ3K1JTNZ93gVRUdwNFovvN2kSz93138U0aUfGpOHPlf78?= =?us-ascii?Q?w7ZEmAAQfUMSTZKniI6cvAFt4uRvuiN7/bxquTTC70+jb/7E/F4Q+Aagnvta?= =?us-ascii?Q?x0MfEw=3D=3D?= X-Forefront-Antispam-Report: CIP:165.204.84.17;CTRY:US;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:satlexmb08.amd.com;PTR:InfoDomainNonexistent;CAT:NONE;SFS:(13230040)(82310400026)(376014)(36860700013)(1800799024);DIR:OUT;SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 26 Jan 2026 19:28:20.4071 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 02a4ed89-5115-49ba-89cf-08de5d11106a X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=3dd8961f-e488-4e60-8e11-a82d994e183d;Ip=[165.204.84.17];Helo=[satlexmb08.amd.com] X-MS-Exchange-CrossTenant-AuthSource: MN1PEPF0000F0E1.namprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: DS2PR12MB9589 Content-Type: text/plain; charset="utf-8" This patch introduces a Remote Management (RM) queue service, which provides a way to communicate between the management PCIe function (PF0) and the embedded firmware running on AMD Versal SoCs. The RM service implements a hardware-based ring buffer for bidirectional command and response exchange between the host driver and the firmware. This patch adds the core infrastructure for: - Initializing and managing the RM queue - Submitting commands to the embedded firmware - Polling for command completion Subsequent patches will integrate the infrastructure with the firmware management logic to enable firmware download, status query, and other control operations. Co-developed-by: Nishad Saraf Signed-off-by: Nishad Saraf Signed-off-by: David Zhang --- drivers/accel/amd_vpci/Makefile | 3 +- drivers/accel/amd_vpci/versal-pci-rm-queue.c | 316 ++++++++++++++++++ drivers/accel/amd_vpci/versal-pci-rm-queue.h | 21 ++ .../accel/amd_vpci/versal-pci-rm-service.h | 209 ++++++++++++ drivers/accel/amd_vpci/versal-pci.h | 1 + 5 files changed, 549 insertions(+), 1 deletion(-) create mode 100644 drivers/accel/amd_vpci/versal-pci-rm-queue.c create mode 100644 drivers/accel/amd_vpci/versal-pci-rm-queue.h create mode 100644 drivers/accel/amd_vpci/versal-pci-rm-service.h diff --git a/drivers/accel/amd_vpci/Makefile b/drivers/accel/amd_vpci/Makef= ile index 03849875ad0b..9e4e56ac2dee 100644 --- a/drivers/accel/amd_vpci/Makefile +++ b/drivers/accel/amd_vpci/Makefile @@ -3,4 +3,5 @@ obj-$(CONFIG_DRM_ACCEL_AMD_VPCI) :=3D versal-pci.o =20 versal-pci-y :=3D \ - versal-pci-main.o + versal-pci-main.o \ + versal-pci-rm-queue.o diff --git a/drivers/accel/amd_vpci/versal-pci-rm-queue.c b/drivers/accel/a= md_vpci/versal-pci-rm-queue.c new file mode 100644 index 000000000000..eeda07065487 --- /dev/null +++ b/drivers/accel/amd_vpci/versal-pci-rm-queue.c @@ -0,0 +1,316 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Driver for Versal PCIe device + * + * Copyright (C) 2026 Advanced Micro Devices, Inc. All rights reserved. + */ + +#include + +#include "versal-pci.h" +#include "versal-pci-rm-queue.h" +#include "versal-pci-rm-service.h" + +static inline struct rm_device *to_rdev_msg_monitor(struct work_struct *w) +{ + return container_of(w, struct rm_device, msg_monitor); +} + +static inline struct rm_device *to_rdev_msg_timer(struct timer_list *t) +{ + return container_of(t, struct rm_device, msg_timer); +} + +static inline u32 rm_io_read(struct rm_device *rdev, u32 offset) +{ + /* TODO */ + return 0; +} + +static inline int rm_io_write(struct rm_device *rdev, u32 offset, u32 valu= e) +{ + /* TODO */ + return 0; +} + +static inline u32 rm_queue_read(struct rm_device *rdev, u32 offset) +{ + /* TODO */ + return 0; +} + +static inline void rm_queue_write(struct rm_device *rdev, u32 offset, u32 = value) +{ + /* TODO */ +} + +static inline void rm_queue_bulk_read(struct rm_device *rdev, u32 offset, + u32 *value, u32 size) +{ + /* TODO */ +} + +static inline void rm_queue_bulk_write(struct rm_device *rdev, u32 offset, + u32 *value, u32 size) +{ + /* TODO */ +} + +static inline u32 rm_queue_get_cidx(struct rm_device *rdev, enum rm_queue_= type type) +{ + u32 off; + + if (type =3D=3D RM_QUEUE_SQ) + off =3D offsetof(struct rm_queue_header, sq_cidx); + else + off =3D offsetof(struct rm_queue_header, cq_cidx); + + return rm_queue_read(rdev, off); +} + +static inline void rm_queue_set_cidx(struct rm_device *rdev, enum rm_queue= _type type, + u32 value) +{ + u32 off; + + if (type =3D=3D RM_QUEUE_SQ) + off =3D offsetof(struct rm_queue_header, sq_cidx); + else + off =3D offsetof(struct rm_queue_header, cq_cidx); + + rm_queue_write(rdev, off, value); +} + +static inline u32 rm_queue_get_pidx(struct rm_device *rdev, enum rm_queue_= type type) +{ + if (type =3D=3D RM_QUEUE_SQ) + return rm_io_read(rdev, RM_IO_SQ_PIDX_OFF); + else + return rm_io_read(rdev, RM_IO_CQ_PIDX_OFF); +} + +static inline int rm_queue_set_pidx(struct rm_device *rdev, + enum rm_queue_type type, u32 value) +{ + if (type =3D=3D RM_QUEUE_SQ) + return rm_io_write(rdev, RM_IO_SQ_PIDX_OFF, value); + else + return rm_io_write(rdev, RM_IO_CQ_PIDX_OFF, value); +} + +static inline u32 rm_queue_get_sq_slot_offset(struct rm_device *rdev) +{ + u32 index; + + if ((rdev->sq.pidx - rdev->sq.cidx) >=3D rdev->queue_size) + return RM_INVALID_SLOT; + + index =3D rdev->sq.pidx & (rdev->queue_size - 1); + return rdev->sq.offset + RM_CMD_SQ_SLOT_SIZE * index; +} + +static inline u32 rm_queue_get_cq_slot_offset(struct rm_device *rdev) +{ + u32 index; + + index =3D rdev->cq.cidx & (rdev->queue_size - 1); + return rdev->cq.offset + RM_CMD_CQ_SLOT_SIZE * index; +} + +static int rm_queue_submit_cmd(struct rm_cmd *cmd) +{ + struct versal_pci_device *vdev =3D cmd->rdev->vdev; + struct rm_device *rdev =3D cmd->rdev; + u32 offset; + int ret; + + guard(mutex)(&rdev->queue); + + offset =3D rm_queue_get_sq_slot_offset(rdev); + if (!offset) { + vdev_err(vdev, "No SQ slot available"); + return -ENOSPC; + } + + rm_queue_bulk_write(rdev, offset, (u32 *)&cmd->sq_msg, + sizeof(cmd->sq_msg)); + + ret =3D rm_queue_set_pidx(rdev, RM_QUEUE_SQ, ++rdev->sq.pidx); + if (ret) { + vdev_err(vdev, "Failed to update PIDX, ret %d", ret); + return ret; + } + + list_add_tail(&cmd->list, &rdev->submitted_cmds); + return ret; +} + +void rm_queue_withdraw_cmd(struct rm_cmd *cmd) +{ + guard(mutex)(&cmd->rdev->queue); + list_del(&cmd->list); +} + +static int rm_queue_wait_cmd_timeout(struct rm_cmd *cmd, unsigned long tim= eout) +{ + struct versal_pci_device *vdev =3D cmd->rdev->vdev; + int ret; + + if (wait_for_completion_timeout(&cmd->executed, timeout)) { + ret =3D cmd->cq_msg.data.rcode; + if (!ret) + return 0; + + vdev_err(vdev, "CMD returned with a failure: %d", ret); + return ret; + } + + /* + * each cmds will be cleaned up by complete before it times out. + * if we reach here, the cmd should be cleared and hot reset should + * be issued. + */ + vdev_err(vdev, "cmd timed out, please reset the card"); + rm_queue_withdraw_cmd(cmd); + return -ETIME; +} + +int rm_queue_send_cmd(struct rm_cmd *cmd, unsigned long timeout) +{ + int ret; + + ret =3D rm_queue_submit_cmd(cmd); + if (ret) + return ret; + + return rm_queue_wait_cmd_timeout(cmd, timeout); +} + +static int rm_process_msg(struct rm_device *rdev) +{ + struct versal_pci_device *vdev =3D rdev->vdev; + struct rm_cmd *cmd, *next; + struct rm_cmd_cq_hdr header; + u32 offset; + + offset =3D rm_queue_get_cq_slot_offset(rdev); + if (!offset) { + vdev_err(vdev, "Invalid CQ offset"); + return -EINVAL; + } + + rm_queue_bulk_read(rdev, offset, (u32 *)&header, sizeof(header)); + + list_for_each_entry_safe(cmd, next, &rdev->submitted_cmds, list) { + u32 value =3D 0; + + if (cmd->sq_msg.hdr.id !=3D header.id) + continue; + + rm_queue_bulk_read(rdev, offset + sizeof(cmd->cq_msg.hdr), + (u32 *)&cmd->cq_msg.data, + sizeof(cmd->cq_msg.data)); + + rm_queue_write(rdev, offset, value); + + list_del(&cmd->list); + complete(&cmd->executed); + return 0; + } + + vdev_err(vdev, "Unknown cmd ID %d found in CQ", header.id); + return -EFAULT; +} + +static void rm_check_msg(struct work_struct *w) +{ + struct rm_device *rdev =3D to_rdev_msg_monitor(w); + int ret; + + guard(mutex)(&rdev->queue); + + rdev->sq.cidx =3D rm_queue_get_cidx(rdev, RM_QUEUE_SQ); + rdev->cq.pidx =3D rm_queue_get_pidx(rdev, RM_QUEUE_CQ); + + while (rdev->cq.cidx < rdev->cq.pidx) { + ret =3D rm_process_msg(rdev); + if (ret) + break; + + rdev->cq.cidx++; + + rm_queue_set_cidx(rdev, RM_QUEUE_CQ, rdev->cq.cidx); + } +} + +static void rm_sched_work(struct timer_list *t) +{ + struct rm_device *rdev =3D to_rdev_msg_timer(t); + + /* Schedule a work in the general workqueue */ + schedule_work(&rdev->msg_monitor); + /* Periodic timer */ + mod_timer(&rdev->msg_timer, jiffies + RM_COMPLETION_TIMER); +} + +void rm_queue_fini(struct rm_device *rdev) +{ + timer_delete_sync(&rdev->msg_timer); + cancel_work_sync(&rdev->msg_monitor); +} + +int rm_queue_init(struct rm_device *rdev) +{ + struct versal_pci_device *vdev =3D rdev->vdev; + struct rm_queue_header header =3D {0}; + int ret; + + INIT_LIST_HEAD(&rdev->submitted_cmds); + ret =3D devm_mutex_init(&vdev->pdev->dev, &rdev->queue); + if (ret) + return ret; + + rm_queue_bulk_read(rdev, RM_HDR_OFF, (u32 *)&header, sizeof(header)); + + if (header.magic !=3D RM_QUEUE_HDR_MAGIC_NUM) { + vdev_err(vdev, "Invalid RM queue header"); + return -ENODEV; + } + + if (!header.version) { + vdev_err(vdev, "Invalid RM queue header"); + return -ENODEV; + } + + sema_init(&rdev->sq.data_lock, 1); + sema_init(&rdev->cq.data_lock, 1); + rdev->queue_size =3D header.size; + rdev->sq.offset =3D header.sq_off; + rdev->cq.offset =3D header.cq_off; + rdev->sq.type =3D RM_QUEUE_SQ; + rdev->cq.type =3D RM_QUEUE_CQ; + rdev->sq.data_size =3D rdev->queue_buffer_size - RM_CMD_CQ_BUFFER_SIZE; + rdev->cq.data_size =3D RM_CMD_CQ_BUFFER_SIZE; + rdev->sq.data_offset =3D rdev->queue_buffer_start + + RM_CMD_CQ_BUFFER_OFFSET + RM_CMD_CQ_BUFFER_SIZE; + rdev->cq.data_offset =3D rdev->queue_buffer_start + + RM_CMD_CQ_BUFFER_OFFSET; + rdev->sq.cidx =3D header.sq_cidx; + rdev->cq.cidx =3D header.cq_cidx; + + rdev->sq.pidx =3D rm_queue_get_pidx(rdev, RM_QUEUE_SQ); + rdev->cq.pidx =3D rm_queue_get_pidx(rdev, RM_QUEUE_CQ); + + if (rdev->cq.cidx !=3D rdev->cq.pidx) { + vdev_warn(vdev, "Clearing stale completions"); + rdev->cq.cidx =3D rdev->cq.pidx; + rm_queue_set_cidx(rdev, RM_QUEUE_CQ, rdev->cq.cidx); + } + + /* Create and schedule timer to do recurring work */ + INIT_WORK(&rdev->msg_monitor, &rm_check_msg); + timer_setup(&rdev->msg_timer, &rm_sched_work, 0); + mod_timer(&rdev->msg_timer, jiffies + RM_COMPLETION_TIMER); + + return 0; +} diff --git a/drivers/accel/amd_vpci/versal-pci-rm-queue.h b/drivers/accel/a= md_vpci/versal-pci-rm-queue.h new file mode 100644 index 000000000000..80e587b5a12a --- /dev/null +++ b/drivers/accel/amd_vpci/versal-pci-rm-queue.h @@ -0,0 +1,21 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Driver for Versal PCIe device + * + * Copyright (C) 2026 Advanced Micro Devices, Inc. All rights reserved. + */ + +#ifndef __RM_QUEUE_H +#define __RM_QUEUE_H + +struct rm_device; + +/* rm queue hardware setup */ +int rm_queue_init(struct rm_device *rdev); +void rm_queue_fini(struct rm_device *rdev); + +/* rm queue common API */ +int rm_queue_send_cmd(struct rm_cmd *cmd, unsigned long timeout); +void rm_queue_withdraw_cmd(struct rm_cmd *cmd); + +#endif /* __RM_QUEUE_H */ diff --git a/drivers/accel/amd_vpci/versal-pci-rm-service.h b/drivers/accel= /amd_vpci/versal-pci-rm-service.h new file mode 100644 index 000000000000..a16198944e17 --- /dev/null +++ b/drivers/accel/amd_vpci/versal-pci-rm-service.h @@ -0,0 +1,209 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Driver for Versal PCIe device + * + * Copyright (C) 2026 Advanced Micro Devices, Inc. All rights reserved. + */ + +#ifndef __RM_SERVICE_H +#define __RM_SERVICE_H + +#define RM_HDR_OFF 0x0 +#define RM_HDR_MAGIC_NUM 0x564D5230 +#define RM_QUEUE_HDR_MAGIC_NUM 0x5847513F +#define RM_PCI_IO_BAR_OFF 0x2010000 +#define RM_PCI_IO_SIZE SZ_4K +#define RM_PCI_SHMEM_BAR_OFF 0x8000000 +#define RM_PCI_SHMEM_SIZE SZ_128M +#define RM_PCI_SHMEM_HDR_SIZE 0x28 + +#define RM_QUEUE_HDR_MAGIC_NUM_OFF 0x0 +#define RM_IO_SQ_PIDX_OFF 0x0 +#define RM_IO_CQ_PIDX_OFF 0x100 + +#define RM_CMD_ID_MIN 1 +#define RM_CMD_ID_MAX (BIT(17) - 1) +#define RM_CMD_SQ_HDR_OPS_MSK GENMASK(15, 0) +#define RM_CMD_SQ_HDR_SIZE_MSK GENMASK(14, 0) +#define RM_CMD_SQ_SLOT_SIZE SZ_512 +#define RM_CMD_CQ_SLOT_SIZE SZ_16 +#define RM_CMD_CQ_BUFFER_SIZE SZ_1M +#define RM_CMD_CQ_BUFFER_OFFSET 0x0 +#define RM_CMD_LOG_PAGE_TYPE_MASK GENMASK(15, 0) +#define RM_CMD_VMR_CONTROL_MSK GENMASK(10, 8) +#define RM_CMD_VMR_CONTROL_PS_MASK BIT(9) + +#define RM_CMD_WAIT_CONFIG_TIMEOUT secs_to_jiffies(10) +#define RM_CMD_WAIT_DOWNLOAD_TIMEOUT secs_to_jiffies(300) + +#define RM_COMPLETION_TIMER (HZ / 10) +#define RM_HEALTH_CHECK_TIMER (HZ) + +#define RM_INVALID_SLOT 0 + +enum rm_queue_opcode { + RM_QUEUE_OP_LOAD_XCLBIN =3D 0x0, + RM_QUEUE_OP_GET_LOG_PAGE =3D 0x8, + RM_QUEUE_OP_LOAD_FW =3D 0xA, + RM_QUEUE_OP_LOAD_APU_FW =3D 0xD, + RM_QUEUE_OP_VMR_CONTROL =3D 0xE, + RM_QUEUE_OP_IDENTIFY =3D 0x202, +}; + +struct rm_cmd_sq_hdr { + __u16 opcode; + __u16 msg_size; + __u16 id; + __u16 reserved; +} __packed; + +struct rm_cmd_cq_hdr { + __u16 id; + __u16 reserved; +} __packed; + +struct rm_cmd_sq_bin { + __u64 address; + __u32 size; + __u32 reserved1; + __u32 reserved2; + __u32 reserved3; + __u64 reserved4; +} __packed; + +struct rm_cmd_sq_log_page { + __u64 address; + __u32 size; + __u32 reserved1; + __u32 type; + __u32 reserved2; +} __packed; + +struct rm_cmd_sq_ctrl { + __u32 status; +} __packed; + +struct rm_cmd_sq_data { + union { + struct rm_cmd_sq_log_page page; + struct rm_cmd_sq_bin bin; + struct rm_cmd_sq_ctrl ctrl; + }; +} __packed; + +struct rm_cmd_cq_identify { + __u16 major; + __u16 minor; + __u32 reserved; +} __packed; + +struct rm_cmd_cq_log_page { + __u32 len; + __u32 reserved; +} __packed; + +struct rm_cmd_cq_control { + __u16 status; + __u16 reserved1; + __u32 reserved2; +} __packed; + +struct rm_cmd_cq_data { + union { + struct rm_cmd_cq_identify identify; + struct rm_cmd_cq_log_page page; + struct rm_cmd_cq_control ctrl; + __u32 reserved[2]; + }; + __u32 rcode; +} __packed; + +struct rm_cmd_sq_msg { + struct rm_cmd_sq_hdr hdr; + struct rm_cmd_sq_data data; +} __packed; + +struct rm_cmd_cq_msg { + struct rm_cmd_cq_hdr hdr; + struct rm_cmd_cq_data data; +} __packed; + +struct rm_cmd { + struct rm_device *rdev; + struct list_head list; + struct completion executed; + struct rm_cmd_sq_msg sq_msg; + struct rm_cmd_cq_msg cq_msg; + enum rm_queue_opcode opcode; + __u8 *buffer; + ssize_t size; +}; + +enum rm_queue_type { + RM_QUEUE_SQ, + RM_QUEUE_CQ +}; + +enum rm_cmd_log_page_type { + RM_CMD_LOG_PAGE_AXI_TRIP_STATUS =3D 0x0, + RM_CMD_LOG_PAGE_FW_ID =3D 0xA, +}; + +struct rm_queue { + enum rm_queue_type type; + __u32 pidx; + __u32 cidx; + __u32 offset; + __u32 data_offset; + __u32 data_size; + struct semaphore data_lock; +}; + +struct rm_queue_header { + __u32 magic; + __u32 version; + __u32 size; + __u32 sq_off; + __u32 sq_slot_size; + __u32 cq_off; + __u32 sq_cidx; + __u32 cq_cidx; +}; + +struct rm_header { + __u32 magic; + __u32 queue_base; + __u32 queue_size; + __u32 status_off; + __u32 status_len; + __u32 log_index; + __u32 log_off; + __u32 log_size; + __u32 data_start; + __u32 data_end; +}; + +struct rm_device { + struct versal_pci_device *vdev; + + struct rm_header rm_metadata; + __u32 queue_buffer_start; + __u32 queue_buffer_size; + __u32 queue_base; + + /* Lock to queue access */ + struct mutex queue; + struct rm_queue sq; + struct rm_queue cq; + __u32 queue_size; + + struct timer_list msg_timer; + struct work_struct msg_monitor; + struct timer_list health_timer; + struct work_struct health_monitor; + struct list_head submitted_cmds; + + __u32 firewall_tripped; +}; + +#endif /* __RM_SERVICE_H */ diff --git a/drivers/accel/amd_vpci/versal-pci.h b/drivers/accel/amd_vpci/v= ersal-pci.h index 890da1d6bcc9..be69dda8da73 100644 --- a/drivers/accel/amd_vpci/versal-pci.h +++ b/drivers/accel/amd_vpci/versal-pci.h @@ -26,6 +26,7 @@ dev_dbg(&(vdev)->pdev->dev, fmt, ##args) =20 struct versal_pci_device; +struct rm_cmd; =20 struct axlf_header { __u64 length; --=20 2.34.1