From patchwork Tue Jan 24 14:07:41 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Gupta, Nipun" X-Patchwork-Id: 122481 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id B585B4247C; Tue, 24 Jan 2023 15:08:00 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id CE227427EE; Tue, 24 Jan 2023 15:07:58 +0100 (CET) Received: from NAM04-MW2-obe.outbound.protection.outlook.com (mail-mw2nam04on2052.outbound.protection.outlook.com [40.107.101.52]) by mails.dpdk.org (Postfix) with ESMTP id 45DC0427EE for ; Tue, 24 Jan 2023 15:07:56 +0100 (CET) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=RaV+XFSPU/NDuSUr8iayCV8psbkSh7wxqJ209OVsBJQtNo8k7ND0IBq0gA8J6tqVegKRsXBuO841rYYP0P9DJkQWA9WQkXVhRv4wwGC5omQ9IkuIR6uE8l+sFBwPDInA3mnAM3ZtFnI+T5HwBKYeRwCGi2I9P+flOQHX3Vtge/8iFk3N0NLh9YwUSDc/0xD4HyfaQrIkcjT5hj6PSyTb2ulqK7NFhBE6iLsYsYx4XO17DMfaoyWgNm7zFXpu1ri4RvgTkx5eVO/qcIEB+eojsGlm4zMSRjz7ieb7R7x5mPUvIcXJiZLtTwi8Xv9BuoUT0qPkpger+/MXDAG3gyh/dA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=CisS/3JOSHCDVUoSarXDnFyTKo4p/wC1bYp7eqLuVYU=; b=HWCDCPumqtnuCIVbMDotQn7VTmP5FTYaazTPNwdem0GM6/6mBdF/0XO8NyYOh0sFdu+NrJaCzlCfbW7mjzPdkEnTyzvfDpVCECYtlU0BWLPPdLU0SCcHGaASS8RrNl1MSdd1llhxYKTHqwQvFb4EhD+vRuBSYpHpto9UWc8kEvi2LsZTbAv1O8halNMFUn6EDSm6MDLpXnpSGASMSCjN3hEducitCTB0TcQaj3yta9QKS+VXHR63B0M3GxXwGrlOV/GcgDBhLE9abCgi19lIHD0p4JUuvKOQc1iQNufBZfwY/zwxBlMCqKEUj6+6ZnYqGscsL5FsDeZtQFvI1O6tKQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=dpdk.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 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=CisS/3JOSHCDVUoSarXDnFyTKo4p/wC1bYp7eqLuVYU=; b=F5OpPSuaBxRLA+v3UlPLFzJenFkGOYkCPdSGejbV1CQyKRlpDKUpbwbAfge9joJJ7AgQ+i5yXXku21ppMpXmA1RxDm2kOdHqSXkqjLCXfAa9za/UqXNeV7UvWnBXOkVMEJ0IBp20Va/SHjVOgenlJfnoXIJirOMUHmX3FAt5Wpw= Received: from BN0PR02CA0009.namprd02.prod.outlook.com (2603:10b6:408:e4::14) by CH3PR12MB8330.namprd12.prod.outlook.com (2603:10b6:610:12c::22) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6002.33; Tue, 24 Jan 2023 14:07:53 +0000 Received: from BN8NAM11FT101.eop-nam11.prod.protection.outlook.com (2603:10b6:408:e4:cafe::e1) by BN0PR02CA0009.outlook.office365.com (2603:10b6:408:e4::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6002.33 via Frontend Transport; Tue, 24 Jan 2023 14:07:53 +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=SATLEXMB04.amd.com; pr=C Received: from SATLEXMB04.amd.com (165.204.84.17) by BN8NAM11FT101.mail.protection.outlook.com (10.13.177.126) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.6002.13 via Frontend Transport; Tue, 24 Jan 2023 14:07:52 +0000 Received: from SATLEXMB03.amd.com (10.181.40.144) by SATLEXMB04.amd.com (10.181.40.145) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.34; Tue, 24 Jan 2023 08:07:51 -0600 Received: from xhdipdslab49.xilinx.com (10.180.168.240) by SATLEXMB03.amd.com (10.181.40.144) with Microsoft SMTP Server id 15.1.2375.34 via Frontend Transport; Tue, 24 Jan 2023 08:07:49 -0600 From: Nipun Gupta To: , , CC: , , Subject: [RFC PATCH 1/6] bus/cdx: introduce cdx bus Date: Tue, 24 Jan 2023 19:37:41 +0530 Message-ID: <20230124140746.594066-2-nipun.gupta@amd.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230124140746.594066-1-nipun.gupta@amd.com> References: <20230124140746.594066-1-nipun.gupta@amd.com> MIME-Version: 1.0 X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: BN8NAM11FT101:EE_|CH3PR12MB8330:EE_ X-MS-Office365-Filtering-Correlation-Id: 9adf0de7-d07e-413c-c086-08dafe14623d X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 3bUhpAF6o1ljBzhnQrDZ1uhMXuaoGkoyrNYEk15T3XPhtOdVSlcntngmraamKc8/vBsdVgfuh9VtuxO3HK8baHved2lRd3VYtIX8r2f+o09WOqhiriVTBBWs320k4lYHMuEKJJiMEaCXfTEAyfQQ39sTFaoOCUtNZliHMgjuYvd6YydgBjq9f6qKdS7c9Kz2n/Zv44T16qPDnmTR7oBD8fqsCFuqTYanwCCyXitNam8KG5uWEhdwwFR9K4IxO0HIp2y+irKGzWwJHJKKwFcD/AKCUAznS9jDKGFe5jSWhAkOCpM6c/XRBzioM/4I8js+U3eaS2tApsaLXwn7rH+8o9+BzylC1v4LhI5No70RkCCTEOXEqqoXeKSjuc8Bd7i/KM78N6T9fcKe8i1+l5IkmDliA93/C4T2aDS6qi7qkjHL664zSoATu68qTySMAew0ykBFgadC89SOenblKD5Lr/Dz8oQJQeveA9lQYdUxjSwNKeBuGxt8zOHBRkK7avhXAo5vGrZ1R/fVE/Yo5afUcjLawIATM/cPQDEkDECGi5XCgRg4A7T4niy08QeekaxlS+nPzofOPBwPhPMwTC765rgHE32UIlvjiQ659E8T1uARYpYKripg0I7LDBzjjLgp/ajEPk5pTUYQsSVwPif/QgtV4fzx4MTpEPap0STb/UOVCNn30OifL2//X23b/yi6cce1KWqHcw0GUwjrtDKmMdtDj8VMm3ixuzIxWejttzY= X-Forefront-Antispam-Report: CIP:165.204.84.17; CTRY:US; LANG:en; SCL:1; SRV:; IPV:CAL; SFV:NSPM; H:SATLEXMB04.amd.com; PTR:InfoDomainNonexistent; CAT:NONE; SFS:(13230022)(4636009)(136003)(396003)(39860400002)(346002)(376002)(451199015)(40470700004)(46966006)(36840700001)(36860700001)(83380400001)(82740400003)(356005)(2906002)(81166007)(41300700001)(30864003)(44832011)(82310400005)(8936002)(5660300002)(4326008)(110136005)(6666004)(26005)(186003)(8676002)(40460700003)(40480700001)(47076005)(426003)(1076003)(336012)(70206006)(316002)(70586007)(54906003)(2616005)(478600001)(86362001)(36756003)(36900700001); DIR:OUT; SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 24 Jan 2023 14:07:52.7049 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 9adf0de7-d07e-413c-c086-08dafe14623d 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=[SATLEXMB04.amd.com] X-MS-Exchange-CrossTenant-AuthSource: BN8NAM11FT101.eop-nam11.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: CH3PR12MB8330 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org CDX bus supports multiple type of devices, which can be exposed to user-space via vfio-cdx. vfio-cdx provides the MMIO IO_MEMORY regions as well as the DMA interface for the device (IOMMU). This support aims to enable the DPDK to support the cdx devices in user-space using VFIO interface. Signed-off-by: Nipun Gupta --- MAINTAINERS | 5 + drivers/bus/cdx/cdx.c | 564 ++++++++++++++++++++++++++++++++++ drivers/bus/cdx/cdx.h | 54 ++++ drivers/bus/cdx/cdx_logs.h | 37 +++ drivers/bus/cdx/cdx_vfio.c | 428 ++++++++++++++++++++++++++ drivers/bus/cdx/meson.build | 13 + drivers/bus/cdx/rte_bus_cdx.h | 219 +++++++++++++ drivers/bus/cdx/version.map | 12 + 8 files changed, 1332 insertions(+) create mode 100644 drivers/bus/cdx/cdx.c create mode 100644 drivers/bus/cdx/cdx.h create mode 100644 drivers/bus/cdx/cdx_logs.h create mode 100644 drivers/bus/cdx/cdx_vfio.c create mode 100644 drivers/bus/cdx/meson.build create mode 100644 drivers/bus/cdx/rte_bus_cdx.h create mode 100644 drivers/bus/cdx/version.map diff --git a/MAINTAINERS b/MAINTAINERS index 9a0f416d2e..9edce0e739 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -563,6 +563,11 @@ M: Parav Pandit M: Xueming Li F: drivers/bus/auxiliary/ +CDX bus driver +M: Nipun Gupta +M: Nikhil Agarwal +F: drivers/bus/cdx/ + Intel FPGA bus M: Rosen Xu F: drivers/bus/ifpga/ diff --git a/drivers/bus/cdx/cdx.c b/drivers/bus/cdx/cdx.c new file mode 100644 index 0000000000..4c85c5dc01 --- /dev/null +++ b/drivers/bus/cdx/cdx.c @@ -0,0 +1,564 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (C) 2022-2023, Advanced Micro Devices, Inc. + */ + +/* + * Architecture Overview + * ===================== + * CDX is a Hardware Architecture designed for AMD FPGA devices. It + * consists of sophisticated mechanism for interaction between FPGA, + * Firmware and the APUs (Application CPUs). + * + * Firmware resides on RPU (Realtime CPUs) which interacts with + * the FPGA program manager and the APUs. The RPU provides memory-mapped + * interface (RPU if) which is used to communicate with APUs. + * + * The diagram below shows an overview of the CDX architecture: + * + * +--------------------------------------+ + * | DPDK | + * | DPDK CDX drivers | + * | | | + * | DPDK CDX bus | + * | | | + * +-----------------------------|--------+ + * | + * +-----------------------------|--------+ + * | Application CPUs (APU) | | + * | | | + * | VFIO CDX driver | + * | Linux OS | | + * | Linux CDX bus | + * | | | + * +-----------------------------|--------+ + * | + * | + * +------------------------| RPU if |----+ + * | | | + * | V | + * | Realtime CPUs (RPU) | + * | | + * +--------------------------------------+ + * | + * +---------------------|----------------+ + * | FPGA | | + * | +-----------------------+ | + * | | | | | + * | +-------+ +-------+ +-------+ | + * | | dev 1 | | dev 2 | | dev 3 | | + * | +-------+ +-------+ +-------+ | + * +--------------------------------------+ + * + * The RPU firmware extracts the device information from the loaded FPGA + * image and implements a mechanism that allows the APU drivers to + * enumerate such devices (device personality and resource details) via + * a dedicated communication channel. + * + * VFIO CDX driver provides the CDX device resources like MMIO and interrupts + * to map to user-space. DPDK CDX bus uses sysfs interface and the vfio-cdx + * driver to discover and initialize the CDX devices for user-space + * applications. + */ + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "cdx.h" +#include "cdx_logs.h" + +#define SYSFS_CDX_DEVICES "/sys/bus/cdx/devices" +#define CDX_BUS_NAME cdx + +/** + * @file + * CDX probing using Linux sysfs. + */ + +/* Add a device to CDX bus */ +static void +rte_cdx_add_device(struct rte_cdx_device *cdx_dev) +{ + TAILQ_INSERT_TAIL(&rte_cdx_bus.device_list, cdx_dev, next); +} + +static int +cdx_get_kernel_driver_by_path(const char *filename, char *driver_name, + size_t len) +{ + int count; + char path[PATH_MAX]; + char *name; + + if (!filename || !driver_name) + return -1; + + count = readlink(filename, path, PATH_MAX); + if (count >= PATH_MAX) + return -1; + + /* For device does not have a driver */ + if (count < 0) + return 1; + + path[count] = '\0'; + + name = strrchr(path, '/'); + if (name) { + strlcpy(driver_name, name + 1, len); + return 0; + } + + return -1; +} + +int rte_cdx_map_device(struct rte_cdx_device *dev) +{ + return cdx_vfio_map_resource(dev); +} + +void rte_cdx_unmap_device(struct rte_cdx_device *dev) +{ + cdx_vfio_unmap_resource(dev); +} + +static int +find_max_end_va(const struct rte_memseg_list *msl, void *arg) +{ + size_t sz = msl->len; + void *end_va = RTE_PTR_ADD(msl->base_va, sz); + void **max_va = arg; + + if (*max_va < end_va) + *max_va = end_va; + return 0; +} + +void * +cdx_find_max_end_va(void) +{ + void *va = NULL; + + rte_memseg_list_walk(find_max_end_va, &va); + return va; +} + +static struct rte_devargs * +cdx_devargs_lookup(const char *dev_name) +{ + struct rte_devargs *devargs; + + RTE_EAL_DEVARGS_FOREACH("cdx", devargs) { + if (strcmp(devargs->name, dev_name) == 0) + return devargs; + } + return NULL; +} + +static bool +cdx_ignore_device(const char *dev_name) +{ + struct rte_devargs *devargs = cdx_devargs_lookup(dev_name); + + switch (rte_cdx_bus.bus.conf.scan_mode) { + case RTE_BUS_SCAN_ALLOWLIST: + if (devargs && devargs->policy == RTE_DEV_ALLOWED) + return false; + break; + case RTE_BUS_SCAN_UNDEFINED: + case RTE_BUS_SCAN_BLOCKLIST: + if (devargs == NULL || devargs->policy != RTE_DEV_BLOCKED) + return false; + break; + } + return true; +} + +/* + * Scan one cdx sysfs entry, and fill the devices list from it. + * It checks if the CDX device is bound to vfio-cdx driver. In case + * the device is vfio bound, it reads the vendor and device id and + * stores it for device-driver matching. + */ +static int +cdx_scan_one(const char *dirname, const char *dev_name) +{ + char filename[PATH_MAX]; + struct rte_cdx_device *dev = NULL; + char driver[PATH_MAX]; + unsigned long tmp; + char *name = NULL; + int ret; + + dev = calloc(1, sizeof(*dev)); + if (!dev) + return -ENOMEM; + + name = calloc(1, RTE_DEV_NAME_MAX_LEN); + if (!name) { + ret = -ENOMEM; + goto err; + } + + dev->device.bus = &rte_cdx_bus.bus; + memcpy(name, dev_name, RTE_DEV_NAME_MAX_LEN); + dev->device.name = name; + + /* parse driver */ + snprintf(filename, sizeof(filename), "%s/driver", dirname); + ret = cdx_get_kernel_driver_by_path(filename, driver, sizeof(driver)); + if (ret < 0) { + CDX_BUS_ERR("Fail to get kernel driver"); + ret = -1; + goto err; + } + + /* + * Check if device is bound to 'vfio-cdx' driver, so that user-space + * can gracefully access the device. + */ + if (ret || strcmp(driver, "vfio-cdx")) { + ret = 0; + goto err; + } + + /* get vendor id */ + snprintf(filename, sizeof(filename), "%s/vendor", dirname); + if (eal_parse_sysfs_value(filename, &tmp) < 0) { + ret = -1; + goto err; + } + dev->id.vendor_id = (uint16_t)tmp; + + /* get device id */ + snprintf(filename, sizeof(filename), "%s/device", dirname); + if (eal_parse_sysfs_value(filename, &tmp) < 0) { + free(dev); + return -1; + } + dev->id.device_id = (uint16_t)tmp; + + rte_cdx_add_device(dev); + + return 0; + +err: + if (name) + free(name); + if (dev) + free(dev); + return ret; +} + +/* + * Scan the content of the CDX bus, and the devices in the devices + * list. + */ +static int +rte_cdx_scan(void) +{ + struct dirent *e; + DIR *dir; + char dirname[PATH_MAX]; + + dir = opendir(rte_cdx_get_sysfs_path()); + if (dir == NULL) { + CDX_BUS_ERR("%s(): opendir failed: %s", __func__, + strerror(errno)); + return -1; + } + + while ((e = readdir(dir)) != NULL) { + if (e->d_name[0] == '.') + continue; + + if (cdx_ignore_device(e->d_name)) + continue; + + snprintf(dirname, sizeof(dirname), "%s/%s", + rte_cdx_get_sysfs_path(), e->d_name); + + if (cdx_scan_one(dirname, e->d_name) < 0) + goto error; + } + closedir(dir); + return 0; + +error: + closedir(dir); + return -1; +} + +const char * +rte_cdx_get_sysfs_path(void) +{ + return SYSFS_CDX_DEVICES; +} + +/* map a particular resource from a file */ +void * +cdx_map_resource(void *requested_addr, int fd, off_t offset, size_t size, + int additional_flags) +{ + void *mapaddr; + + /* Map the cdx MMIO memory resource of device */ + mapaddr = rte_mem_map(requested_addr, size, + RTE_PROT_READ | RTE_PROT_WRITE, + RTE_MAP_SHARED | additional_flags, fd, offset); + if (mapaddr == NULL) { + CDX_BUS_ERR("%s(): cannot map resource(%d, %p, 0x%zx, 0x%llx): %s (%p)", + __func__, fd, requested_addr, size, + (unsigned long long)offset, + rte_strerror(rte_errno), mapaddr); + } + CDX_BUS_DEBUG("CDX MMIO memory mapped at %p", mapaddr); + + return mapaddr; +} + +/* unmap a particular resource */ +void +cdx_unmap_resource(void *requested_addr, size_t size) +{ + if (requested_addr == NULL) + return; + + /* Unmap the CDX memory resource of device */ + if (rte_mem_unmap(requested_addr, size)) { + CDX_BUS_ERR("%s(): cannot mem unmap(%p, %#zx): %s", __func__, + requested_addr, size, rte_strerror(rte_errno)); + } + CDX_BUS_DEBUG("CDX memory unmapped at %p", requested_addr); +} +/* + * Match the CDX Driver and Device using device id and vendor id. + */ +static int +rte_cdx_match(const struct rte_cdx_driver *cdx_drv, + const struct rte_cdx_device *cdx_dev) +{ + const struct rte_cdx_id *id_table; + + for (id_table = cdx_drv->id_table; id_table->vendor_id != 0; + id_table++) { + /* check if device's identifiers match the driver's ones */ + if (id_table->vendor_id != cdx_dev->id.vendor_id && + id_table->vendor_id != RTE_CDX_ANY_ID) + continue; + if (id_table->device_id != cdx_dev->id.device_id && + id_table->device_id != RTE_CDX_ANY_ID) + continue; + + return 1; + } + + return 0; +} + +/* + * If vendor id and device id match, call the probe() function of the + * driver. + */ +static int +rte_cdx_probe_one_driver(struct rte_cdx_driver *dr, + struct rte_cdx_device *dev) +{ + const char *dev_name = dev->device.name; + bool already_probed; + int ret; + + if ((dr == NULL) || (dev == NULL)) + return -EINVAL; + + /* The device is not blocked; Check if driver supports it */ + if (!rte_cdx_match(dr, dev)) + /* Match of device and driver failed */ + return 1; + + already_probed = rte_dev_is_probed(&dev->device); + if (already_probed) { + CDX_BUS_INFO("Device %s is already probed", dev->device.name); + return -EEXIST; + } + + CDX_BUS_DEBUG(" probe device %s using driver: %s", dev_name, + dr->driver.name); + + ret = cdx_vfio_map_resource(dev); + if (ret != 0) { + CDX_BUS_ERR("CDX map device failed: %d", ret); + goto error_map_device; + } + + /* call the driver probe() function */ + ret = dr->probe(dr, dev); + if (ret) { + CDX_BUS_ERR("Probe CDX driver: %s device: %s failed: %d", + dr->driver.name, dev_name, ret); + goto error_probe; + } else { + dev->device.driver = &dr->driver; + } + + return ret; + +error_probe: + cdx_vfio_unmap_resource(dev); +error_map_device: + return ret; +} + +/* + * If vendor/device ID match, call the probe() function of all + * registered driver for the given device. Return < 0 if initialization + * failed, return 1 if no driver is found for this device. + */ +static int +cdx_probe_all_drivers(struct rte_cdx_device *dev) +{ + struct rte_cdx_driver *dr = NULL; + int rc = 0; + + if (dev == NULL) + return -EINVAL; + + FOREACH_DRIVER_ON_CDXBUS(dr) { + rc = rte_cdx_probe_one_driver(dr, dev); + if (rc < 0) + /* negative value is an error */ + return rc; + if (rc > 0) + /* positive value means driver doesn't support it */ + continue; + return 0; + } + return 1; +} + +/* + * Scan the content of the CDX bus, and call the probe() function for + * all registered drivers that have a matching entry in its id_table + * for discovered devices. + */ +static int +cdx_probe(void) +{ + struct rte_cdx_device *dev = NULL; + size_t probed = 0, failed = 0; + int ret = 0; + + FOREACH_DEVICE_ON_CDXBUS(dev) { + probed++; + + ret = cdx_probe_all_drivers(dev); + if (ret < 0) { + CDX_BUS_ERR("Requested device %s cannot be used", + dev->device.name); + rte_errno = errno; + failed++; + ret = 0; + } + } + + return (probed && probed == failed) ? -1 : 0; +} + +/* dump one device */ +static int +cdx_dump_one_device(FILE *f, struct rte_cdx_device *dev) +{ + int i; + + fprintf(f, "cdx device %s\n", dev->device.name); + + for (i = 0; i != sizeof(dev->mem_resource) / + sizeof(dev->mem_resource[0]); i++) { + if (dev->mem_resource[i].len) + fprintf(f, " Resource[%d]: %p %16.16"PRIx64"\n", + i, dev->mem_resource[i].addr, + dev->mem_resource[i].len); + } + return 0; +} + +/* dump devices on the bus */ +void +rte_cdx_dump(FILE *f) +{ + struct rte_cdx_device *dev = NULL; + + FOREACH_DEVICE_ON_CDXBUS(dev) + cdx_dump_one_device(f, dev); +} + +static int +cdx_parse(const char *name, void *addr) +{ + if (addr) + strcpy(addr, name); + + return 0; +} + +/* register a driver */ +void +rte_cdx_register(struct rte_cdx_driver *driver) +{ + TAILQ_INSERT_TAIL(&rte_cdx_bus.driver_list, driver, next); + driver->bus = &rte_cdx_bus; +} + +/* unregister a driver */ +void +rte_cdx_unregister(struct rte_cdx_driver *driver) +{ + TAILQ_REMOVE(&rte_cdx_bus.driver_list, driver, next); + driver->bus = NULL; +} + +static struct rte_device * +cdx_find_device(const struct rte_device *start, rte_dev_cmp_t cmp, + const void *data) +{ + const struct rte_cdx_device *cdx_start; + struct rte_cdx_device *cdx_dev; + + if (start != NULL) { + cdx_start = RTE_DEV_TO_CDX_DEV_CONST(start); + cdx_dev = TAILQ_NEXT(cdx_start, next); + } else { + cdx_dev = TAILQ_FIRST(&rte_cdx_bus.device_list); + } + while (cdx_dev != NULL) { + if (cmp(&cdx_dev->device, data) == 0) + return &cdx_dev->device; + cdx_dev = TAILQ_NEXT(cdx_dev, next); + } + return NULL; +} + +struct rte_cdx_bus rte_cdx_bus = { + .bus = { + .scan = rte_cdx_scan, + .probe = cdx_probe, + .find_device = cdx_find_device, + .parse = cdx_parse, + }, + .device_list = TAILQ_HEAD_INITIALIZER(rte_cdx_bus.device_list), + .driver_list = TAILQ_HEAD_INITIALIZER(rte_cdx_bus.driver_list), +}; + +RTE_REGISTER_BUS(cdx, rte_cdx_bus.bus); +RTE_LOG_REGISTER_DEFAULT(cdx_logtype_bus, NOTICE); diff --git a/drivers/bus/cdx/cdx.h b/drivers/bus/cdx/cdx.h new file mode 100644 index 0000000000..d428149bb9 --- /dev/null +++ b/drivers/bus/cdx/cdx.h @@ -0,0 +1,54 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (C) 2022-2023, Advanced Micro Devices, Inc. + */ + +#ifndef _CDX_H_ +#define _CDX_H_ + +#include +#include + +#include "rte_bus_cdx.h" + +extern struct rte_cdx_bus rte_cdx_bus; + +/** + * Map a particular resource from a file. + * + * @param requested_addr + * The starting address for the new mapping range. + * @param fd + * The file descriptor. + * @param offset + * The offset for the mapping range. + * @param size + * The size for the mapping range. + * @param additional_flags + * The additional rte_mem_map() flags for the mapping range. + * @return + * - On success, the function returns a pointer to the mapped area. + * - On error, NULL is returned. + */ +void *cdx_map_resource(void *requested_addr, int fd, off_t offset, + size_t size, int additional_flags); + +/** + * Unmap a particular resource. + * + * @param requested_addr + * The address for the unmapping range. + * @param size + * The size for the unmapping range. + */ +void cdx_unmap_resource(void *requested_addr, size_t size); + +/* + * Helper function to map CDX resources right after hugepages in virtual memory + */ +void *cdx_find_max_end_va(void); + +/* map/unmap VFIO resource */ +int cdx_vfio_map_resource(struct rte_cdx_device *dev); +int cdx_vfio_unmap_resource(struct rte_cdx_device *dev); + +#endif /* _CDX_H_ */ diff --git a/drivers/bus/cdx/cdx_logs.h b/drivers/bus/cdx/cdx_logs.h new file mode 100644 index 0000000000..7a53633a1b --- /dev/null +++ b/drivers/bus/cdx/cdx_logs.h @@ -0,0 +1,37 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (C) 2022-2023, Advanced Micro Devices, Inc. + */ + +#ifndef _CDX_LOGS_H_ +#define _CDX_LOGS_H_ + +extern int cdx_logtype_bus; + +#define CDX_BUS_LOG(level, fmt, args...) \ + rte_log(RTE_LOG_ ## level, cdx_logtype_bus, "fslmc: " fmt "\n", \ + ##args) + +/* Debug logs are with Function names */ +#define CDX_BUS_DEBUG(fmt, args...) \ + rte_log(RTE_LOG_DEBUG, cdx_logtype_bus, "fslmc: %s(): " fmt "\n", \ + __func__, ##args) + +#define CDX_BUS_INFO(fmt, args...) \ + CDX_BUS_LOG(INFO, fmt, ## args) +#define CDX_BUS_ERR(fmt, args...) \ + CDX_BUS_LOG(ERR, fmt, ## args) +#define CDX_BUS_WARN(fmt, args...) \ + CDX_BUS_LOG(WARNING, fmt, ## args) + +/* DP Logs, toggled out at compile time if level lower than current level */ +#define CDX_BUS_DP_LOG(level, fmt, args...) \ + RTE_LOG_DP(level, PMD, fmt, ## args) + +#define CDX_BUS_DP_DEBUG(fmt, args...) \ + CDX_BUS_DP_LOG(DEBUG, fmt, ## args) +#define CDX_BUS_DP_INFO(fmt, args...) \ + CDX_BUS_DP_LOG(INFO, fmt, ## args) +#define CDX_BUS_DP_WARN(fmt, args...) \ + CDX_BUS_DP_LOG(WARNING, fmt, ## args) + +#endif /* _CDX_LOGS_H_ */ diff --git a/drivers/bus/cdx/cdx_vfio.c b/drivers/bus/cdx/cdx_vfio.c new file mode 100644 index 0000000000..f52adc4655 --- /dev/null +++ b/drivers/bus/cdx/cdx_vfio.c @@ -0,0 +1,428 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (C) 2022-2023, Advanced Micro Devices, Inc. + */ + +/** + * @file + * CDX probing using Linux VFIO. + * + * This code tries to determine if the CDX device is bound to VFIO driver, + * and initialize it (map BARs, set up interrupts) if that's the case. + * + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "eal_filesystem.h" + +#include "cdx.h" +#include "cdx_logs.h" + +/** + * A structure describing a CDX mapping. + */ +struct cdx_map { + void *addr; + char *path; + uint64_t offset; + uint64_t size; +}; + +/** + * A structure describing a mapped CDX resource. + * For multi-process we need to reproduce all CDX mappings in secondary + * processes, so save them in a tailq. + */ +struct mapped_cdx_resource { + TAILQ_ENTRY(mapped_cdx_resource) next; + char name[RTE_DEV_NAME_MAX_LEN]; /**< CDX device name */ + char path[PATH_MAX]; + int nb_maps; + struct cdx_map maps[CDX_MAX_RESOURCE]; +}; + +/** mapped cdx device list */ +TAILQ_HEAD(mapped_cdx_res_list, mapped_cdx_resource); + +static struct rte_tailq_elem cdx_vfio_tailq = { + .name = "VFIO_CDX_RESOURCE_LIST", +}; +EAL_REGISTER_TAILQ(cdx_vfio_tailq) + +static struct mapped_cdx_resource * +cdx_vfio_find_and_unmap_resource(struct mapped_cdx_res_list *vfio_res_list, + struct rte_cdx_device *dev) +{ + struct mapped_cdx_resource *vfio_res = NULL; + const char *dev_name = dev->device.name; + struct cdx_map *maps; + int i; + + /* Get vfio_res */ + TAILQ_FOREACH(vfio_res, vfio_res_list, next) { + if (strcmp(vfio_res->name, dev_name)) + continue; + break; + } + + if (vfio_res == NULL) + return vfio_res; + + CDX_BUS_INFO("Releasing CDX mapped resource for %s", dev_name); + + maps = vfio_res->maps; + for (i = 0; i < vfio_res->nb_maps; i++) { + /* + * We do not need to be aware of MSI-X table BAR mappings as + * when mapping. Just using current maps array is enough + */ + if (maps[i].addr) { + CDX_BUS_DEBUG("Calling cdx_unmap_resource for %s at %p", + dev_name, maps[i].addr); + cdx_unmap_resource(maps[i].addr, maps[i].size); + } + } + + return vfio_res; +} + +static int +cdx_vfio_unmap_resource_primary(struct rte_cdx_device *dev) +{ + char cdx_addr[PATH_MAX] = {0}; + struct mapped_cdx_resource *vfio_res = NULL; + struct mapped_cdx_res_list *vfio_res_list; + + vfio_res_list = + RTE_TAILQ_CAST(cdx_vfio_tailq.head, mapped_cdx_res_list); + vfio_res = cdx_vfio_find_and_unmap_resource(vfio_res_list, dev); + + /* if we haven't found our tailq entry, something's wrong */ + if (vfio_res == NULL) { + CDX_BUS_ERR("%s cannot find TAILQ entry for cdx device!", + cdx_addr); + return -1; + } + + TAILQ_REMOVE(vfio_res_list, vfio_res, next); + rte_free(vfio_res); + return 0; +} + +static int +cdx_vfio_unmap_resource_secondary(struct rte_cdx_device *dev) +{ + struct mapped_cdx_resource *vfio_res = NULL; + struct mapped_cdx_res_list *vfio_res_list; + + vfio_res_list = + RTE_TAILQ_CAST(cdx_vfio_tailq.head, mapped_cdx_res_list); + vfio_res = cdx_vfio_find_and_unmap_resource(vfio_res_list, dev); + + /* if we haven't found our tailq entry, something's wrong */ + if (vfio_res == NULL) { + CDX_BUS_ERR("%s cannot find TAILQ entry for CDX device!", + dev->device.name); + return -1; + } + + return 0; +} + +int +cdx_vfio_unmap_resource(struct rte_cdx_device *dev) +{ + if (rte_eal_process_type() == RTE_PROC_PRIMARY) + return cdx_vfio_unmap_resource_primary(dev); + else + return cdx_vfio_unmap_resource_secondary(dev); +} + +static int +cdx_rte_vfio_setup_device(int vfio_dev_fd) +{ + /* + * Reset the device. If the device is not capable of resetting, + * then it updates errno as EINVAL. + */ + if (ioctl(vfio_dev_fd, VFIO_DEVICE_RESET) && errno != EINVAL) { + CDX_BUS_ERR("Unable to reset device! Error: %d (%s)", errno, + strerror(errno)); + return -1; + } + + return 0; +} + +static int +cdx_vfio_mmap_resource(int vfio_dev_fd, struct mapped_cdx_resource *vfio_res, + int index, int additional_flags) +{ + struct memreg { + uint64_t offset; + size_t size; + } memreg[2] = { 0 }; + void *vaddr; + struct cdx_map *map = &vfio_res->maps[index]; + + if (map->size == 0) { + CDX_BUS_DEBUG("map size is 0, skip region %d", index); + return 0; + } + + memreg[0].offset = map->offset; + memreg[0].size = map->size; + + /* reserve the address using an inaccessible mapping */ + vaddr = mmap(map->addr, map->size, 0, MAP_PRIVATE | + MAP_ANONYMOUS | additional_flags, -1, 0); + if (vaddr != MAP_FAILED) { + void *map_addr = NULL; + + if (memreg[0].size) { + /* actual map of first part */ + map_addr = cdx_map_resource(vaddr, vfio_dev_fd, + memreg[0].offset, + memreg[0].size, + RTE_MAP_FORCE_ADDRESS); + } + + if (map_addr == NULL) { + munmap(vaddr, map->size); + vaddr = MAP_FAILED; + CDX_BUS_ERR("Failed to map cdx MMIO region %d", index); + return -1; + } + } else { + CDX_BUS_ERR("Failed to create inaccessible mapping for MMIO region %d", + index); + return -1; + } + + map->addr = vaddr; + return 0; +} + +/* + * region info may contain capability headers, so we need to keep reallocating + * the memory until we match allocated memory size with argsz. + */ +static int +cdx_vfio_get_region_info(int vfio_dev_fd, struct vfio_region_info **info, + int region) +{ + struct vfio_region_info *ri; + size_t argsz = sizeof(*ri); + int ret; + + ri = malloc(sizeof(*ri)); + if (ri == NULL) { + CDX_BUS_ERR("Cannot allocate memory for VFIO region info"); + return -1; + } +again: + memset(ri, 0, argsz); + ri->argsz = argsz; + ri->index = region; + + ret = ioctl(vfio_dev_fd, VFIO_DEVICE_GET_REGION_INFO, ri); + if (ret < 0) { + free(ri); + return ret; + } + if (ri->argsz != argsz) { + struct vfio_region_info *tmp; + + argsz = ri->argsz; + tmp = realloc(ri, argsz); + + if (tmp == NULL) { + /* realloc failed but the ri is still there */ + free(ri); + CDX_BUS_ERR("Cannot reallocate memory for VFIO region info"); + return -1; + } + ri = tmp; + goto again; + } + *info = ri; + + return 0; +} + +static int +cdx_vfio_map_resource_primary(struct rte_cdx_device *dev) +{ + struct vfio_device_info device_info = { .argsz = sizeof(device_info) }; + char cdx_addr[PATH_MAX] = {0}; + static void *cdx_map_addr; + struct mapped_cdx_resource *vfio_res = NULL; + struct mapped_cdx_res_list *vfio_res_list = + RTE_TAILQ_CAST(cdx_vfio_tailq.head, mapped_cdx_res_list); + const char *dev_name = dev->device.name; + struct cdx_map *maps; + int vfio_dev_fd, i, ret; + + ret = rte_vfio_setup_device(rte_cdx_get_sysfs_path(), dev_name, + &vfio_dev_fd, &device_info); + if (ret) + return ret; + + /* allocate vfio_res and get region info */ + vfio_res = rte_zmalloc("VFIO_RES", sizeof(*vfio_res), 0); + if (vfio_res == NULL) { + CDX_BUS_ERR("Cannot store VFIO mmap details"); + goto err_vfio_dev_fd; + } + memcpy(vfio_res->name, dev_name, RTE_DEV_NAME_MAX_LEN); + + /* get number of registers */ + vfio_res->nb_maps = device_info.num_regions; + + /* map memory regions */ + maps = vfio_res->maps; + + for (i = 0; i < vfio_res->nb_maps; i++) { + struct vfio_region_info *reg = NULL; + void *vaddr; + + ret = cdx_vfio_get_region_info(vfio_dev_fd, ®, i); + if (ret < 0) { + CDX_BUS_ERR("%s cannot get device region info error %i (%s)", + dev_name, errno, strerror(errno)); + goto err_vfio_res; + } + + /* skip non-mmappable regions */ + if ((reg->flags & VFIO_REGION_INFO_FLAG_MMAP) == 0) { + free(reg); + continue; + } + + /* try mapping somewhere close to the end of hugepages */ + if (cdx_map_addr == NULL) + cdx_map_addr = cdx_find_max_end_va(); + + vaddr = cdx_map_addr; + cdx_map_addr = RTE_PTR_ADD(vaddr, (size_t)reg->size); + + cdx_map_addr = RTE_PTR_ALIGN(cdx_map_addr, + sysconf(_SC_PAGE_SIZE)); + + maps[i].addr = vaddr; + maps[i].offset = reg->offset; + maps[i].size = reg->size; + maps[i].path = NULL; /* vfio doesn't have per-resource paths */ + + ret = cdx_vfio_mmap_resource(vfio_dev_fd, vfio_res, i, 0); + if (ret < 0) { + CDX_BUS_ERR("%s mapping region %i failed: %s", + cdx_addr, i, strerror(errno)); + free(reg); + goto err_vfio_res; + } + + dev->mem_resource[i].addr = maps[i].addr; + dev->mem_resource[i].len = maps[i].size; + + free(reg); + } + + if (cdx_rte_vfio_setup_device(vfio_dev_fd) < 0) { + CDX_BUS_ERR("%s setup device failed", dev_name); + goto err_vfio_res; + } + + TAILQ_INSERT_TAIL(vfio_res_list, vfio_res, next); + + return 0; +err_vfio_res: + cdx_vfio_find_and_unmap_resource(vfio_res_list, dev); + rte_free(vfio_res); +err_vfio_dev_fd: + rte_vfio_release_device(rte_cdx_get_sysfs_path(), + dev_name, vfio_dev_fd); + return -1; +} + +static int +cdx_vfio_map_resource_secondary(struct rte_cdx_device *dev) +{ + struct vfio_device_info device_info = { .argsz = sizeof(device_info) }; + char cdx_addr[PATH_MAX] = {0}; + int vfio_dev_fd; + int i, ret; + struct mapped_cdx_resource *vfio_res = NULL; + struct mapped_cdx_res_list *vfio_res_list = + RTE_TAILQ_CAST(cdx_vfio_tailq.head, mapped_cdx_res_list); + const char *dev_name = dev->device.name; + struct cdx_map *maps; + + /* if we're in a secondary process, just find our tailq entry */ + TAILQ_FOREACH(vfio_res, vfio_res_list, next) { + if (strcmp(vfio_res->name, dev_name)) + continue; + break; + } + /* if we haven't found our tailq entry, something's wrong */ + if (vfio_res == NULL) { + CDX_BUS_ERR("%s cannot find TAILQ entry for cdx device!", + dev_name); + return -1; + } + + ret = rte_vfio_setup_device(rte_cdx_get_sysfs_path(), dev_name, + &vfio_dev_fd, &device_info); + if (ret) + return ret; + + /* map MMIO regions */ + maps = vfio_res->maps; + + for (i = 0; i < vfio_res->nb_maps; i++) { + ret = cdx_vfio_mmap_resource(vfio_dev_fd, vfio_res, i, MAP_FIXED); + if (ret < 0) { + CDX_BUS_ERR("%s mapping MMIO region %i failed: %s", + dev_name, i, strerror(errno)); + goto err_vfio_dev_fd; + } + + dev->mem_resource[i].addr = maps[i].addr; + dev->mem_resource[i].len = maps[i].size; + } + + return 0; +err_vfio_dev_fd: + rte_vfio_release_device(rte_cdx_get_sysfs_path(), + cdx_addr, vfio_dev_fd); + return -1; +} + +/* + * map the CDX resources of a CDX device in virtual memory (VFIO version). + * primary and secondary processes follow almost exactly the same path + */ +int +cdx_vfio_map_resource(struct rte_cdx_device *dev) +{ + if (rte_eal_process_type() == RTE_PROC_PRIMARY) + return cdx_vfio_map_resource_primary(dev); + else + return cdx_vfio_map_resource_secondary(dev); +} diff --git a/drivers/bus/cdx/meson.build b/drivers/bus/cdx/meson.build new file mode 100644 index 0000000000..2fb0e1cefd --- /dev/null +++ b/drivers/bus/cdx/meson.build @@ -0,0 +1,13 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright (C) 2022-2023, Advanced Micro Devices, Inc. + +if not is_linux + build = false + reason = 'only supported on Linux' +endif + +headers = files('rte_bus_cdx.h') +sources = files( + 'cdx.c', + 'cdx_vfio.c', +) diff --git a/drivers/bus/cdx/rte_bus_cdx.h b/drivers/bus/cdx/rte_bus_cdx.h new file mode 100644 index 0000000000..ef04dfc88b --- /dev/null +++ b/drivers/bus/cdx/rte_bus_cdx.h @@ -0,0 +1,219 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (C) 2022-2023, Advanced Micro Devices, Inc. + */ + +#ifndef _RTE_BUS_CDX_H_ +#define _RTE_BUS_CDX_H_ + +/** + * @file + * + * CDX device & driver interface + * + * @warning + * @b EXPERIMENTAL: + * All functions in this file may be changed or removed without prior notice. + * + * CDX is a Hardware Architecture designed for AMD FPGA and HNIC devices. + * These devices are provided as CDX devices for the user. This driver + * provides user interface for devices on the CDX bus. + * + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +/* Forward declarations */ +struct rte_cdx_device; +struct rte_cdx_driver; + +#define CDX_MAX_RESOURCE 4 + +/** List of CDX devices */ +RTE_TAILQ_HEAD(rte_cdx_device_list, rte_cdx_device); +/** List of CDX drivers */ +RTE_TAILQ_HEAD(rte_cdx_driver_list, rte_cdx_driver); + +/* CDX Bus iterators */ +#define FOREACH_DEVICE_ON_CDXBUS(p) \ + RTE_TAILQ_FOREACH(p, &rte_cdx_bus.device_list, next) + +#define FOREACH_DRIVER_ON_CDXBUS(p) \ + RTE_TAILQ_FOREACH(p, &rte_cdx_bus.driver_list, next) + +/** Any CDX device identifier (vendor, device) */ +#define RTE_CDX_ANY_ID (0xffff) + +#define RTE_PMD_REGISTER_CDX_TABLE(name, table) \ +static const char DRV_EXP_TAG(name, cdx_tbl_export)[] __rte_used = \ +RTE_STR(table) + +/** + * A structure describing an ID for a CDX driver. Each driver provides a + * table of these IDs for each device that it supports. + */ +struct rte_cdx_id { + uint16_t vendor_id; /**< Vendor ID. */ + uint16_t device_id; /**< Device ID. */ +}; + +/** + * A structure describing a CDX device. + */ +struct rte_cdx_device { + RTE_TAILQ_ENTRY(rte_cdx_device) next; /**< Next probed CDX device. */ + struct rte_device device; /**< Inherit core device */ + struct rte_cdx_id id; /**< CDX ID. */ + struct rte_mem_resource mem_resource[CDX_MAX_RESOURCE]; + /**< CDX Memory Resource */ +}; + +/** + * @internal + * Helper macro for drivers that need to convert to struct rte_cdx_device. + */ +#define RTE_DEV_TO_CDX_DEV(ptr) \ + container_of(ptr, struct rte_cdx_device, device) + +#define RTE_DEV_TO_CDX_DEV_CONST(ptr) \ + container_of(ptr, const struct rte_cdx_device, device) + +#define RTE_ETH_DEV_TO_CDX_DEV(eth_dev) RTE_DEV_TO_CDX_DEV((eth_dev)->device) + +#ifdef __cplusplus +/** C++ macro used to help building up tables of device IDs */ +#define RTE_CDX_DEVICE(vend, dev) \ + (vend), \ + (dev) +#else +/** Macro used to help building up tables of device IDs */ +#define RTE_CDX_DEVICE(vend, dev) \ + .vendor_id = (vend), \ + .device_id = (dev) +#endif + +/** + * Initialisation function for the driver called during CDX probing. + */ +typedef int (rte_cdx_probe_t)(struct rte_cdx_driver *, struct rte_cdx_device *); + +/** + * Uninitialisation function for the driver called during hotplugging. + */ +typedef int (rte_cdx_remove_t)(struct rte_cdx_device *); + +/** + * A structure describing a CDX driver. + */ +struct rte_cdx_driver { + RTE_TAILQ_ENTRY(rte_cdx_driver) next; /**< Next in list. */ + struct rte_driver driver; /**< Inherit core driver. */ + struct rte_cdx_bus *bus; /**< CDX bus reference. */ + rte_cdx_probe_t *probe; /**< Device probe function. */ + rte_cdx_remove_t *remove; /**< Device remove function. */ + const struct rte_cdx_id *id_table; /**< ID table, NULL terminated. */ + uint32_t drv_flags; /**< Flags RTE_CDX_DRV_*. */ +}; + +/** + * Structure describing the CDX bus + */ +struct rte_cdx_bus { + struct rte_bus bus; /**< Inherit the generic class */ + struct rte_cdx_device_list device_list; /**< List of CDX devices */ + struct rte_cdx_driver_list driver_list; /**< List of CDX drivers */ +}; + +/** + * Get Pathname of CDX devices directory. + * + * @return + * sysfs path for CDX devices. + */ +__rte_experimental +const char *rte_cdx_get_sysfs_path(void); + +/** + * Map the CDX device resources in user space virtual memory address + * + * @param dev + * A pointer to a rte_cdx_device structure describing the device + * to use + * + * @return + * 0 on success, negative on error and positive if no driver + * is found for the device. + */ +__rte_experimental +int rte_cdx_map_device(struct rte_cdx_device *dev); + +/** + * Unmap this device + * + * @param dev + * A pointer to a rte_cdx_device structure describing the device + * to use + */ +__rte_experimental +void rte_cdx_unmap_device(struct rte_cdx_device *dev); + +/** + * Dump the content of the CDX bus. + * + * @param f + * A pointer to a file for output + */ +__rte_experimental +void rte_cdx_dump(FILE *f); + +/** + * Register a CDX driver. + * + * @param driver + * A pointer to a rte_cdx_driver structure describing the driver + * to be registered. + */ +__rte_experimental +void rte_cdx_register(struct rte_cdx_driver *driver); + +/** + * Helper for CDX device registration from driver (eth, crypto, raw) instance + */ +#define RTE_PMD_REGISTER_CDX(nm, cdx_drv) \ + RTE_INIT(cdxinitfn_ ##nm) \ + {\ + (cdx_drv).driver.name = RTE_STR(nm);\ + rte_cdx_register(&cdx_drv); \ + } \ + RTE_PMD_EXPORT_NAME(nm, __COUNTER__) + +/** + * Unregister a CDX driver. + * + * @param driver + * A pointer to a rte_cdx_driver structure describing the driver + * to be unregistered. + */ +__rte_experimental +void rte_cdx_unregister(struct rte_cdx_driver *driver); + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_BUS_CDX_H_ */ diff --git a/drivers/bus/cdx/version.map b/drivers/bus/cdx/version.map new file mode 100644 index 0000000000..23dff36125 --- /dev/null +++ b/drivers/bus/cdx/version.map @@ -0,0 +1,12 @@ +EXPERIMENTAL { + global: + + rte_cdx_dump; + rte_cdx_get_sysfs_path; + rte_cdx_map_device; + rte_cdx_register; + rte_cdx_unmap_device; + rte_cdx_unregister; + + local: *; +}; From patchwork Tue Jan 24 14:07:42 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Gupta, Nipun" X-Patchwork-Id: 122482 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 2C2E74247C; Tue, 24 Jan 2023 15:08:11 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 353E442D3E; Tue, 24 Jan 2023 15:08:00 +0100 (CET) Received: from NAM12-BN8-obe.outbound.protection.outlook.com (mail-bn8nam12on2070.outbound.protection.outlook.com [40.107.237.70]) by mails.dpdk.org (Postfix) with ESMTP id EEB5C427EE for ; Tue, 24 Jan 2023 15:07:57 +0100 (CET) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=j9gjz9C/pZNR+kyEMtGE94gK2g7z2tT3CZts2J+DC3Xxp3zWI6vNrDDHzeNT33R6PR8YtVcQTV523GmAt7FDS1YaNt21PvOVF8diR9tnyrVG5OPSpVDTtkd+yeje7cGBRsbfHFg9xr8NT5YpX2MJwnfSI7O8zBVlq0aFb7Wzlft+M6nKO4qD3xaEFHEa+k/7mmJzmE41/OEi4IA7x0pHT3xLiBKUIqvry5Qg28aqWAKuibpxI03hTtyJ2J9kZChS7gLKUy1l5G2NtC6WQk3l9b2oJqjqAJm99+A8r8ozM/6f+S0ybApHtol8CrB31obgAGjWcwG5lQiDK5yPykrSLQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=bmq14dUO9n5MxgfnEPpcbmGDrOmELcVU7I6hnhqfGy8=; b=ZiBf6sRZqJMyVFchkgTHY1UnBORoAmxoWjnqbGrm8iagGYViwtReCl6BVWBmeoeIxHa/j9lqWsHOfcIhlYMsZwbCJBZk6J1m08UzX5WBnX6oDrzUMEnMJy2+e5VBhEV9LTo/wX+XJdg0VVQ4J98HFTtPty04aCWZ+sNE1EcDqCE6Lwc521EA1Cq0DflbHdHGzYPoaaMSl5y8whjVyRnBrLpOwzTt2saiK2X+T32Wka9Je0vkw5KCbFqK15f3rOYs36cJ59r/yeviNL/Lswel5ep8jdjL4LLirLl5tbXxqmigK02wIsK6XfW0tXymIWb/VK6n+bs8rG3CdEnNFB9xyw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=dpdk.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 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=bmq14dUO9n5MxgfnEPpcbmGDrOmELcVU7I6hnhqfGy8=; b=391BuqoytBXsH20v7gXRM41wfcJcvgSgMv6UVLmKdLzsgolOmDevMLXqvZVw+BVvl6/GlwP4a54w0jc4sHqDfYrRqWT2hM10+1gfi5Y8kgHhBbbXHlENiLcpE4HpmFefDdlPetrOdMpn87Dq4p+E4I3GaEhKd/U+zZqgvq5KKmI= Received: from BN9PR03CA0238.namprd03.prod.outlook.com (2603:10b6:408:f8::33) by MN0PR12MB5810.namprd12.prod.outlook.com (2603:10b6:208:376::6) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6002.33; Tue, 24 Jan 2023 14:07:55 +0000 Received: from BN8NAM11FT021.eop-nam11.prod.protection.outlook.com (2603:10b6:408:f8:cafe::66) by BN9PR03CA0238.outlook.office365.com (2603:10b6:408:f8::33) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6002.33 via Frontend Transport; Tue, 24 Jan 2023 14:07:55 +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=SATLEXMB04.amd.com; pr=C Received: from SATLEXMB04.amd.com (165.204.84.17) by BN8NAM11FT021.mail.protection.outlook.com (10.13.177.114) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.6043.17 via Frontend Transport; Tue, 24 Jan 2023 14:07:54 +0000 Received: from SATLEXMB03.amd.com (10.181.40.144) by SATLEXMB04.amd.com (10.181.40.145) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.34; Tue, 24 Jan 2023 08:07:53 -0600 Received: from xhdipdslab49.xilinx.com (10.180.168.240) by SATLEXMB03.amd.com (10.181.40.144) with Microsoft SMTP Server id 15.1.2375.34 via Frontend Transport; Tue, 24 Jan 2023 08:07:52 -0600 From: Nipun Gupta To: , , CC: , , Subject: [RFC PATCH 2/6] bus/cdx: add dma map and unmap support Date: Tue, 24 Jan 2023 19:37:42 +0530 Message-ID: <20230124140746.594066-3-nipun.gupta@amd.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230124140746.594066-1-nipun.gupta@amd.com> References: <20230124140746.594066-1-nipun.gupta@amd.com> MIME-Version: 1.0 X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: BN8NAM11FT021:EE_|MN0PR12MB5810:EE_ X-MS-Office365-Filtering-Correlation-Id: 0445afc4-5672-4547-30b5-08dafe146382 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 3Kgi207AxwSasgAQFGUl+anZSVJ/NGZlx9tyx3/aPUfGZJIk9tpoJNuZcepOJ/MzU/0Paf0EHDDXI/hsoWmE118RIDMeQFRfgioSk7W5gapoTW4ymh1QiaUWzfRjHNsH2ppep6sJdgSnRcHtk2UchVPEjD9YpKtC8cFb9OYee/Pkut0mHfVBGnKTnAYLXvue4HiD0ORe8VVccKM9Al0nAvYXEXMbwkfAfJZwNh+0oLSQRpbPXLtIMLlampO24vVTub0lsjdALgMFw3qKjm+Fy7pYm0rOZ8sqfvgaaSyGaMse+RBSWuCX5UbZYdJwbNZhUF0fLAaCbOMc7yA3eeyyKsx9DqxCzBgsEqxobrVVNIpvRj+QeYdxip0QF75ydspdRqxzfAfSpfQLdiJEwu84np0sgk9Y1uPmiFhd4ah0dwkmk6NGKLnphdwnemuK5+c24jEBtqS2zzL70keARbQhRqMCQc5o+SBr9nGBAj580IugYpmq2Dy37WkfTgbCaTdcPf8LxbUGGBQaN/FztleNtV30+ATSHMow3/dj+cb0JcYY3KU0iW1jlmZDQVK8JQGM6R2MSk+lUkHyufK6/ZttUobeMuXYCfEDWqdpc9TC8DWhSOhmcW5vwuXRbpsxI417VHsSUvSLtmJaDSgFYvv7VAl8r4J4op0VhKEQ7RLVYtGo37aZzvIvAqOLbe6duZLS2w8j9aJGrSOHTwfLXonKGKCgmhImM9BT71EpXb5HTjk= X-Forefront-Antispam-Report: CIP:165.204.84.17; CTRY:US; LANG:en; SCL:1; SRV:; IPV:CAL; SFV:NSPM; H:SATLEXMB04.amd.com; PTR:InfoDomainNonexistent; CAT:NONE; SFS:(13230022)(4636009)(39860400002)(346002)(376002)(136003)(396003)(451199015)(46966006)(40470700004)(36840700001)(36756003)(356005)(86362001)(2906002)(82740400003)(81166007)(4326008)(82310400005)(8936002)(5660300002)(44832011)(41300700001)(36860700001)(478600001)(110136005)(8676002)(26005)(40460700003)(186003)(40480700001)(70206006)(70586007)(54906003)(1076003)(2616005)(316002)(6666004)(426003)(47076005)(336012)(36900700001); DIR:OUT; SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 24 Jan 2023 14:07:54.8155 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 0445afc4-5672-4547-30b5-08dafe146382 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=[SATLEXMB04.amd.com] X-MS-Exchange-CrossTenant-AuthSource: BN8NAM11FT021.eop-nam11.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: MN0PR12MB5810 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org CDX bus can use VFIO interface for mapping and unmapping of DMA addresses in the IOMMU. This change adds the callback support for map and unmap APIs as well as fetching the IOMMU class. Signed-off-by: Nipun Gupta --- drivers/bus/cdx/cdx.c | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/drivers/bus/cdx/cdx.c b/drivers/bus/cdx/cdx.c index 4c85c5dc01..cb04639b0d 100644 --- a/drivers/bus/cdx/cdx.c +++ b/drivers/bus/cdx/cdx.c @@ -549,12 +549,52 @@ cdx_find_device(const struct rte_device *start, rte_dev_cmp_t cmp, return NULL; } +static int +cdx_dma_map(struct rte_device *dev, void *addr, uint64_t iova, size_t len) +{ + struct rte_cdx_device *cdx_dev = RTE_DEV_TO_CDX_DEV(dev); + + if (!cdx_dev) { + rte_errno = EINVAL; + return -1; + } + + return rte_vfio_container_dma_map(RTE_VFIO_DEFAULT_CONTAINER_FD, + (uintptr_t)addr, iova, len); +} + +static int +cdx_dma_unmap(struct rte_device *dev, void *addr, uint64_t iova, size_t len) +{ + struct rte_cdx_device *cdx_dev = RTE_DEV_TO_CDX_DEV(dev); + + if (!cdx_dev) { + rte_errno = EINVAL; + return -1; + } + + return rte_vfio_container_dma_unmap(RTE_VFIO_DEFAULT_CONTAINER_FD, + (uintptr_t)addr, iova, len); +} + +static enum rte_iova_mode +rte_cdx_get_iommu_class(void) +{ + if (TAILQ_EMPTY(&rte_cdx_bus.device_list)) + return RTE_IOVA_DC; + + return RTE_IOVA_VA; +} + struct rte_cdx_bus rte_cdx_bus = { .bus = { .scan = rte_cdx_scan, .probe = cdx_probe, .find_device = cdx_find_device, .parse = cdx_parse, + .dma_map = cdx_dma_map, + .dma_unmap = cdx_dma_unmap, + .get_iommu_class = rte_cdx_get_iommu_class, }, .device_list = TAILQ_HEAD_INITIALIZER(rte_cdx_bus.device_list), .driver_list = TAILQ_HEAD_INITIALIZER(rte_cdx_bus.driver_list), From patchwork Tue Jan 24 14:07:43 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Gupta, Nipun" X-Patchwork-Id: 122483 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id A88E54247C; Tue, 24 Jan 2023 15:08:18 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 3A74B42D44; Tue, 24 Jan 2023 15:08:03 +0100 (CET) Received: from NAM10-DM6-obe.outbound.protection.outlook.com (mail-dm6nam10on2088.outbound.protection.outlook.com [40.107.93.88]) by mails.dpdk.org (Postfix) with ESMTP id CCF6142D31 for ; Tue, 24 Jan 2023 15:07:59 +0100 (CET) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=UB0VT/6ryHTzPRpMZaDx05AhcnOWMldYHJJlnromX8DM6oyGX1O9S5IAuA7kMsNGwBHXHieBbzDGvBKItSXAPBS37nFgPb1CU82GnsUMoTE+KzXg1Nbay3rAOIDn0MA+rWf4E8dVXyaxiYz8T7B8SORxPGrchjn1yypgnn1Uy+l+814eYs+v2EUE1zcb9Yhdq01tKRhbU+NsHHHrt5l1liHrz8UURdzgzVUtwtXPDq+iiXUXALOm1OZ0hLeWQTMiGkGB9TDmNYXezADE1vo+0tpo3MVPHFLPByvt/055jb+n85G143y8Y10x4jIvmlOy+NLAnNK5Ulo5wDtCXomrBg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=2ag3IHYryDFcW46Byvy15R9GshexrOmawC5G0obWegc=; b=M9xjZ0OrE1q0IcO4OHWhtM2B7P7bUsHUP6mNMMHWaXzIWIqYYIKgEmdZk+EYNPc8WnPpOnJ9bbnmmBRScPbzbUh+huOs+fv35CrzK8hHzcnEuYFK34Rd3dQQOc2OtXEJ1SC4JJ3PMI8btMQlI4FjmSZpF95k2w2GI2hsvBNPiTT9yAzoKWzcCUR55MbH5utLNoWaZya5XmRRHk16Am433cy+pXvDOrlkh8b5Rbw0jEhzjwcvHWBt/4N6+if3lSv5MBlKphrtiMeCyZHydn/8W0NxDA7CHbkGQZylNv+VJyqXThynN95aBVNM1vXCUFc+rzSlZtHbWYkkEzCcIuFlwA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=dpdk.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 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=2ag3IHYryDFcW46Byvy15R9GshexrOmawC5G0obWegc=; b=a0XwLG0cGEiCpj/9VZPjT6kvRapZhabaYzM9WiXXktTvPbU82/A+73dzl5DN/VXsE8BCmd8gHWmDZyglCUpZGhcplHSzqLl7p0HtMmp7Xg6K3QjzjuZ89B/cc2omaNCM1wZ9zuOhfb3GoMLxrv9Ri260nV0l6IXvSnDbCu5jUh4= Received: from DM6PR11CA0064.namprd11.prod.outlook.com (2603:10b6:5:14c::41) by BL3PR12MB6569.namprd12.prod.outlook.com (2603:10b6:208:38c::9) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6002.27; Tue, 24 Jan 2023 14:07:57 +0000 Received: from DM6NAM11FT107.eop-nam11.prod.protection.outlook.com (2603:10b6:5:14c:cafe::a) by DM6PR11CA0064.outlook.office365.com (2603:10b6:5:14c::41) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6002.33 via Frontend Transport; Tue, 24 Jan 2023 14:07:57 +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=SATLEXMB03.amd.com; pr=C Received: from SATLEXMB03.amd.com (165.204.84.17) by DM6NAM11FT107.mail.protection.outlook.com (10.13.172.142) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.6023.16 via Frontend Transport; Tue, 24 Jan 2023 14:07:57 +0000 Received: from SATLEXMB07.amd.com (10.181.41.45) 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.2375.34; Tue, 24 Jan 2023 08:07:56 -0600 Received: from SATLEXMB03.amd.com (10.181.40.144) by SATLEXMB07.amd.com (10.181.41.45) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.34; Tue, 24 Jan 2023 06:07:56 -0800 Received: from xhdipdslab49.xilinx.com (10.180.168.240) by SATLEXMB03.amd.com (10.181.40.144) with Microsoft SMTP Server id 15.1.2375.34 via Frontend Transport; Tue, 24 Jan 2023 08:07:54 -0600 From: Nipun Gupta To: , , CC: , , Subject: [RFC PATCH 3/6] bus/cdx: add support for MSI Date: Tue, 24 Jan 2023 19:37:43 +0530 Message-ID: <20230124140746.594066-4-nipun.gupta@amd.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230124140746.594066-1-nipun.gupta@amd.com> References: <20230124140746.594066-1-nipun.gupta@amd.com> MIME-Version: 1.0 X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: DM6NAM11FT107:EE_|BL3PR12MB6569:EE_ X-MS-Office365-Filtering-Correlation-Id: 272c21e9-8ece-4e28-9a4d-08dafe1464e4 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: X8phz/cKW1yC6teBqdttl1Ls8HAHLtDFQ5U0yIRwN6Yi5IhSNqamZTVEPbSXZXZ5tgZCGLF9s+hj3xf/Ds74TrLYwPnQmhDDi5TQLoGJ7CgM6/99bb4l/dWrvQ4hhsWX/wRxOs8m78bPg8B68ZpqO7pZpBHpimum+0vkcAfFH8T+Asacl34Ysb14VoyRFxgHyKsD8mtNhxEq8pjZdDKbKWMC7psjO9hgtBwCrLR04ooOuddSX7t6Zx/2AAdoLgzP5kr9JsLyg8+fuNYs8erOgQMp8gD07nbERLqvPCiZfGXdXZfO0Ysus3c11jHKk1PBaxAY3m2hy8AwnvD0oOG3jJWYKPhMeU7qxaoGB5pVt4S+vqsTkcrurJYlAvSCQCvqqswlaDlnHugo6xdPmif2OpKWBmvlybrnr+KxHWkV9lw50Q4JxYamF48nTYNf2KZKe5VAv3RJjrOz6Q3cHntjtgaGmIErS3LoEZ2riYI9Pja8QD1YHvOnhJNpSTnuID1Knz2dhwUlBCsQ3FnpmnWmw8wvybI2dDH7aQEurfX1wzhVTL4ESdSZnK+Gfji8YGvSA6I26f3eZ7dpUiywnUYkqVSOkwlNAZ6g0rAar0pXwpQBB5h+1u/kyHj8HKIPe8pKczvxhJG4kxVuHXfNllzYX6ds34KP9YuEBCbaYJEcyLdmpPf1HwY2j3u+R46BTFbleCHKnvna/6IE+IbFhy86aVABZtPRceNPXjqQNXG+o7k= X-Forefront-Antispam-Report: CIP:165.204.84.17; CTRY:US; LANG:en; SCL:1; SRV:; IPV:CAL; SFV:NSPM; H:SATLEXMB03.amd.com; PTR:InfoDomainNonexistent; CAT:NONE; SFS:(13230022)(4636009)(396003)(39860400002)(376002)(346002)(136003)(451199015)(36840700001)(46966006)(40470700004)(186003)(2906002)(110136005)(26005)(54906003)(2616005)(316002)(478600001)(6666004)(36860700001)(36756003)(82740400003)(1076003)(81166007)(356005)(40460700003)(47076005)(86362001)(426003)(336012)(40480700001)(41300700001)(83380400001)(70206006)(5660300002)(4326008)(44832011)(30864003)(8936002)(70586007)(82310400005)(8676002)(36900700001); DIR:OUT; SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 24 Jan 2023 14:07:57.1069 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 272c21e9-8ece-4e28-9a4d-08dafe1464e4 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=[SATLEXMB03.amd.com] X-MS-Exchange-CrossTenant-AuthSource: DM6NAM11FT107.eop-nam11.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BL3PR12MB6569 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org MSI's are exposed to the devices using VFIO (vfio-cdx). This patch uses the same to add support for MSI for the devices on the cdx bus. Signed-off-by: Nipun Gupta --- drivers/bus/cdx/cdx.c | 11 ++ drivers/bus/cdx/cdx_vfio.c | 182 ++++++++++++++++++++++++- drivers/bus/cdx/rte_bus_cdx.h | 25 ++++ drivers/bus/cdx/version.map | 9 ++ lib/eal/common/eal_common_interrupts.c | 21 +++ lib/eal/common/eal_interrupts.h | 1 + lib/eal/include/rte_interrupts.h | 32 +++++ lib/eal/version.map | 2 + 8 files changed, 281 insertions(+), 2 deletions(-) diff --git a/drivers/bus/cdx/cdx.c b/drivers/bus/cdx/cdx.c index cb04639b0d..d0adfb74ef 100644 --- a/drivers/bus/cdx/cdx.c +++ b/drivers/bus/cdx/cdx.c @@ -224,6 +224,15 @@ cdx_scan_one(const char *dirname, const char *dev_name) goto err; } + /* Allocate interrupt instance for cdx device */ + dev->intr_handle = + rte_intr_instance_alloc(RTE_INTR_INSTANCE_F_PRIVATE); + if (dev->intr_handle == NULL) { + CDX_BUS_ERR("Failed to create interrupt instance for %s\n", + dev->device.name); + return -ENOMEM; + } + /* * Check if device is bound to 'vfio-cdx' driver, so that user-space * can gracefully access the device. @@ -415,6 +424,8 @@ rte_cdx_probe_one_driver(struct rte_cdx_driver *dr, return ret; error_probe: + rte_intr_instance_free(dev->intr_handle); + dev->intr_handle = NULL; cdx_vfio_unmap_resource(dev); error_map_device: return ret; diff --git a/drivers/bus/cdx/cdx_vfio.c b/drivers/bus/cdx/cdx_vfio.c index f52adc4655..fd90da6727 100644 --- a/drivers/bus/cdx/cdx_vfio.c +++ b/drivers/bus/cdx/cdx_vfio.c @@ -60,6 +60,10 @@ struct mapped_cdx_resource { /** mapped cdx device list */ TAILQ_HEAD(mapped_cdx_res_list, mapped_cdx_resource); +/* irq set buffer length for MSI interrupts */ +#define MSI_IRQ_SET_BUF_LEN (sizeof(struct vfio_irq_set) + \ + sizeof(int) * (RTE_MAX_RXTX_INTR_VEC_ID + 1)) + static struct rte_tailq_elem cdx_vfio_tailq = { .name = "VFIO_CDX_RESOURCE_LIST", }; @@ -108,6 +112,27 @@ cdx_vfio_unmap_resource_primary(struct rte_cdx_device *dev) char cdx_addr[PATH_MAX] = {0}; struct mapped_cdx_resource *vfio_res = NULL; struct mapped_cdx_res_list *vfio_res_list; + int ret, vfio_dev_fd; + + if (rte_intr_fd_get(dev->intr_handle) < 0) + return -1; + + if (close(rte_intr_fd_get(dev->intr_handle)) < 0) { + CDX_BUS_ERR("Error when closing eventfd file descriptor for %s", + dev->device.name); + return -1; + } + + vfio_dev_fd = rte_intr_dev_fd_get(dev->intr_handle); + if (vfio_dev_fd < 0) + return -1; + + ret = rte_vfio_release_device(rte_cdx_get_sysfs_path(), dev->device.name, + vfio_dev_fd); + if (ret < 0) { + CDX_BUS_ERR("Cannot release VFIO device"); + return ret; + } vfio_res_list = RTE_TAILQ_CAST(cdx_vfio_tailq.head, mapped_cdx_res_list); @@ -130,6 +155,18 @@ cdx_vfio_unmap_resource_secondary(struct rte_cdx_device *dev) { struct mapped_cdx_resource *vfio_res = NULL; struct mapped_cdx_res_list *vfio_res_list; + int ret, vfio_dev_fd; + + vfio_dev_fd = rte_intr_dev_fd_get(dev->intr_handle); + if (vfio_dev_fd < 0) + return -1; + + ret = rte_vfio_release_device(rte_cdx_get_sysfs_path(), dev->device.name, + vfio_dev_fd); + if (ret < 0) { + CDX_BUS_ERR("Cannot release VFIO device"); + return ret; + } vfio_res_list = RTE_TAILQ_CAST(cdx_vfio_tailq.head, mapped_cdx_res_list); @@ -154,9 +191,80 @@ cdx_vfio_unmap_resource(struct rte_cdx_device *dev) return cdx_vfio_unmap_resource_secondary(dev); } +/* set up interrupt support (but not enable interrupts) */ static int -cdx_rte_vfio_setup_device(int vfio_dev_fd) +cdx_vfio_setup_interrupts(struct rte_cdx_device *dev, int vfio_dev_fd, + int num_irqs) { + int i, ret; + + if (num_irqs == 0) + return 0; + + /* start from MSI interrupt type */ + for (i = 0; i < num_irqs; i++) { + struct vfio_irq_info irq = { .argsz = sizeof(irq) }; + int fd = -1; + + irq.index = i; + + ret = ioctl(vfio_dev_fd, VFIO_DEVICE_GET_IRQ_INFO, &irq); + if (ret < 0) { + CDX_BUS_ERR("Cannot get VFIO IRQ info, error %i (%s)", + errno, strerror(errno)); + return -1; + } + + /* if this vector cannot be used with eventfd, fail if we explicitly + * specified interrupt type, otherwise continue + */ + if ((irq.flags & VFIO_IRQ_INFO_EVENTFD) == 0) + continue; + + if (rte_intr_irq_count_set(dev->intr_handle, irq.count)) + return -1; + + /* Reallocate the efds and elist fields of intr_handle based + * on CDX device MSI size. + */ + if ((uint32_t)rte_intr_nb_intr_get(dev->intr_handle) < irq.count && + rte_intr_event_list_update(dev->intr_handle, irq.count)) + return -1; + + /* set up an eventfd for interrupts */ + fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); + if (fd < 0) { + CDX_BUS_ERR("Cannot set up eventfd, error %i (%s)", + errno, strerror(errno)); + return -1; + } + + if (rte_intr_fd_set(dev->intr_handle, fd)) + return -1; + + /* DPDK CDX bus currently supports only MSI-X */ + if (rte_intr_type_set(dev->intr_handle, RTE_INTR_HANDLE_VFIO_MSIX)) + return -1; + + if (rte_intr_dev_fd_set(dev->intr_handle, vfio_dev_fd)) + return -1; + + return 0; + } + + /* if we're here, we haven't found a suitable interrupt vector */ + return -1; +} + +static int +cdx_rte_vfio_setup_device(struct rte_cdx_device *dev, int vfio_dev_fd, + int num_irqs) +{ + if (cdx_vfio_setup_interrupts(dev, vfio_dev_fd, num_irqs) != 0) { + CDX_BUS_ERR("Error setting up interrupts!"); + return -1; + } + /* * Reset the device. If the device is not capable of resetting, * then it updates errno as EINVAL. @@ -279,6 +387,9 @@ cdx_vfio_map_resource_primary(struct rte_cdx_device *dev) struct cdx_map *maps; int vfio_dev_fd, i, ret; + if (rte_intr_fd_set(dev->intr_handle, -1)) + return -1; + ret = rte_vfio_setup_device(rte_cdx_get_sysfs_path(), dev_name, &vfio_dev_fd, &device_info); if (ret) @@ -344,7 +455,7 @@ cdx_vfio_map_resource_primary(struct rte_cdx_device *dev) free(reg); } - if (cdx_rte_vfio_setup_device(vfio_dev_fd) < 0) { + if (cdx_rte_vfio_setup_device(dev, vfio_dev_fd, device_info.num_irqs) < 0) { CDX_BUS_ERR("%s setup device failed", dev_name); goto err_vfio_res; } @@ -374,6 +485,9 @@ cdx_vfio_map_resource_secondary(struct rte_cdx_device *dev) const char *dev_name = dev->device.name; struct cdx_map *maps; + if (rte_intr_fd_set(dev->intr_handle, -1)) + return -1; + /* if we're in a secondary process, just find our tailq entry */ TAILQ_FOREACH(vfio_res, vfio_res_list, next) { if (strcmp(vfio_res->name, dev_name)) @@ -407,6 +521,10 @@ cdx_vfio_map_resource_secondary(struct rte_cdx_device *dev) dev->mem_resource[i].len = maps[i].size; } + /* we need save vfio_dev_fd, so it can be used during release */ + if (rte_intr_dev_fd_set(dev->intr_handle, vfio_dev_fd)) + goto err_vfio_dev_fd; + return 0; err_vfio_dev_fd: rte_vfio_release_device(rte_cdx_get_sysfs_path(), @@ -426,3 +544,63 @@ cdx_vfio_map_resource(struct rte_cdx_device *dev) else return cdx_vfio_map_resource_secondary(dev); } + +int +rte_cdx_vfio_intr_enable(const struct rte_intr_handle *intr_handle) +{ + char irq_set_buf[MSI_IRQ_SET_BUF_LEN]; + struct vfio_irq_set *irq_set; + int *fd_ptr, vfio_dev_fd, i; + int ret; + + irq_set = (struct vfio_irq_set *) irq_set_buf; + irq_set->count = rte_intr_irq_count_get(intr_handle); + irq_set->argsz = sizeof(struct vfio_irq_set) + + (sizeof(int) * irq_set->count); + + irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | VFIO_IRQ_SET_ACTION_TRIGGER; + irq_set->index = 0; + irq_set->start = 0; + fd_ptr = (int *) &irq_set->data; + + for (i = 0; i < rte_intr_nb_efd_get(intr_handle); i++) + fd_ptr[i] = rte_intr_efds_index_get(intr_handle, i); + + vfio_dev_fd = rte_intr_dev_fd_get(intr_handle); + ret = ioctl(vfio_dev_fd, VFIO_DEVICE_SET_IRQS, irq_set); + + if (ret) { + CDX_BUS_ERR("Error enabling MSI interrupts for fd %d", + rte_intr_fd_get(intr_handle)); + return -1; + } + + return 0; +} + +/* disable MSI interrupts */ +int +rte_cdx_vfio_intr_disable(const struct rte_intr_handle *intr_handle) +{ + struct vfio_irq_set *irq_set; + char irq_set_buf[MSI_IRQ_SET_BUF_LEN]; + int len, ret, vfio_dev_fd; + + len = sizeof(struct vfio_irq_set); + + irq_set = (struct vfio_irq_set *) irq_set_buf; + irq_set->argsz = len; + irq_set->count = 0; + irq_set->flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_TRIGGER; + irq_set->index = 0; + irq_set->start = 0; + + vfio_dev_fd = rte_intr_dev_fd_get(intr_handle); + ret = ioctl(vfio_dev_fd, VFIO_DEVICE_SET_IRQS, irq_set); + + if (ret) + CDX_BUS_ERR("Error disabling MSI interrupts for fd %d", + rte_intr_fd_get(intr_handle)); + + return ret; +} diff --git a/drivers/bus/cdx/rte_bus_cdx.h b/drivers/bus/cdx/rte_bus_cdx.h index ef04dfc88b..43d75bc3b4 100644 --- a/drivers/bus/cdx/rte_bus_cdx.h +++ b/drivers/bus/cdx/rte_bus_cdx.h @@ -81,6 +81,7 @@ struct rte_cdx_device { struct rte_cdx_id id; /**< CDX ID. */ struct rte_mem_resource mem_resource[CDX_MAX_RESOURCE]; /**< CDX Memory Resource */ + struct rte_intr_handle *intr_handle; /**< Interrupt handle */ }; /** @@ -181,6 +182,30 @@ void rte_cdx_unmap_device(struct rte_cdx_device *dev); __rte_experimental void rte_cdx_dump(FILE *f); +/** + * Enables VFIO Interrupts for CDX bus devices. + * + * @param intr_handle + * Pointer to the interrupt handle. + * + * @return + * 0 on success, -1 on error. + */ +__rte_internal +int rte_cdx_vfio_intr_enable(const struct rte_intr_handle *intr_handle); + +/** + * Disable VFIO Interrupts for CDX bus devices. + * + * @param intr_handle + * Pointer to the interrupt handle. + * + * @return + * 0 on success, -1 on error. + */ +__rte_internal +int rte_cdx_vfio_intr_disable(const struct rte_intr_handle *intr_handle); + /** * Register a CDX driver. * diff --git a/drivers/bus/cdx/version.map b/drivers/bus/cdx/version.map index 23dff36125..8fc51b090b 100644 --- a/drivers/bus/cdx/version.map +++ b/drivers/bus/cdx/version.map @@ -10,3 +10,12 @@ EXPERIMENTAL { local: *; }; + +INTERNAL { + global: + + rte_cdx_vfio_intr_disable; + rte_cdx_vfio_intr_enable; + + local: *; +}; diff --git a/lib/eal/common/eal_common_interrupts.c b/lib/eal/common/eal_common_interrupts.c index 97b64fed58..a0167d9ad4 100644 --- a/lib/eal/common/eal_common_interrupts.c +++ b/lib/eal/common/eal_common_interrupts.c @@ -398,6 +398,27 @@ int rte_intr_elist_index_set(struct rte_intr_handle *intr_handle, return -rte_errno; } +int rte_intr_irq_count_set(struct rte_intr_handle *intr_handle, + int irq_count) +{ + CHECK_VALID_INTR_HANDLE(intr_handle); + + intr_handle->irq_count = irq_count; + + return 0; +fail: + return -rte_errno; +} + +int rte_intr_irq_count_get(const struct rte_intr_handle *intr_handle) +{ + CHECK_VALID_INTR_HANDLE(intr_handle); + + return intr_handle->irq_count; +fail: + return -rte_errno; +} + int rte_intr_vec_list_alloc(struct rte_intr_handle *intr_handle, const char *name, int size) { diff --git a/lib/eal/common/eal_interrupts.h b/lib/eal/common/eal_interrupts.h index 482781b862..237f471a76 100644 --- a/lib/eal/common/eal_interrupts.h +++ b/lib/eal/common/eal_interrupts.h @@ -16,6 +16,7 @@ struct rte_intr_handle { }; uint32_t alloc_flags; /**< flags passed at allocation */ enum rte_intr_handle_type type; /**< handle type */ + uint32_t irq_count; /**< IRQ count provided via VFIO */ uint32_t max_intr; /**< max interrupt requested */ uint32_t nb_efd; /**< number of available efd(event fd) */ uint8_t efd_counter_size; /**< size of efd counter, used for vdev */ diff --git a/lib/eal/include/rte_interrupts.h b/lib/eal/include/rte_interrupts.h index 487e3c8875..bc477a483f 100644 --- a/lib/eal/include/rte_interrupts.h +++ b/lib/eal/include/rte_interrupts.h @@ -506,6 +506,38 @@ __rte_internal int rte_intr_max_intr_get(const struct rte_intr_handle *intr_handle); +/** + * @internal + * Set the irq count field of interrupt handle with user + * provided irq count value. + * + * @param intr_handle + * pointer to the interrupt handle. + * @param irq_count + * IRQ count + * + * @return + * - On success, zero. + * - On failure, a negative value and rte_errno is set. + */ +__rte_internal +int +rte_intr_irq_count_set(struct rte_intr_handle *intr_handle, int irq_count); + +/** + * @internal + * Returns the irq count field of the given interrupt handle instance. + * + * @param intr_handle + * pointer to the interrupt handle. + * + * @return + * - On success, ir count. + * - On failure, a negative value and rte_errno is set. + */ +__rte_internal +int rte_intr_irq_count_get(const struct rte_intr_handle *intr_handle); + /** * @internal * Set the number of event fd field of interrupt handle diff --git a/lib/eal/version.map b/lib/eal/version.map index 7ad12a7dc9..8cda43247d 100644 --- a/lib/eal/version.map +++ b/lib/eal/version.map @@ -468,6 +468,8 @@ INTERNAL { rte_intr_instance_dup; rte_intr_instance_windows_handle_get; rte_intr_instance_windows_handle_set; + rte_intr_irq_count_get; + rte_intr_irq_count_set; rte_intr_max_intr_get; rte_intr_max_intr_set; rte_intr_nb_efd_get; From patchwork Tue Jan 24 14:07:44 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Gupta, Nipun" X-Patchwork-Id: 122484 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 2D4754247C; Tue, 24 Jan 2023 15:08:26 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 320C242D47; Tue, 24 Jan 2023 15:08:04 +0100 (CET) Received: from NAM10-DM6-obe.outbound.protection.outlook.com (mail-dm6nam10on2044.outbound.protection.outlook.com [40.107.93.44]) by mails.dpdk.org (Postfix) with ESMTP id 3B8EA42D43 for ; Tue, 24 Jan 2023 15:08:02 +0100 (CET) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=PWY7aJIXGXaMW4ksL0FLadZYogXGZ4YXuj9xhA9AMnOEV7lZcOHBc1xySE+bKM5ss+T6SdTwiGWbKGQTghNoge3OOT4GnzDmEkaQzrzSRvS2Nc/Vvi6zyTOt2NyUHXJ+c33/9pPyTkP3sNQXy7WcnYJR/xwVEFsbhRIRKmkouzxN4woHrW3gheBBmkd6gy5h0C2fjKPMwQTj9+woNHi1xRtMnRBkl4Tn3HG/agdPp+KoEOVGR6YNL/D7pDk8LRe6YnvFQFgrs9ZKpPNp7BxqRWZd9XE1GMnuZWbrKcywP8tsBHEhMxK8ZTAsSLFkTX2oO9emAZhw01zslxkB9hDqNA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=GiDzTkd0yyjAobMW/5JQtrlyuUeZjzAABq83NxC13Jo=; b=BCsxq24y4hNNOR5UvAfkJ7NFgyBT8tcCHtXwoqlNSVmnLtJICVd9788tLK1AQPf9SPMQ5Qg5K4GQH9taA/19jDuPpEAnSqUao+jZG4tK13IseOth7/8TDCEEkmQr8GFckVf02YX/oMSQN+tscpwkzBJ80ZkSYY2HeueaeHaUXdShiD4Fk5nw6pPTjPViC5WK96FA//QtechcCp1sbpyDdRtEu7K0QTVgWqRinVslCg3DnKO9Ych66cwwM7PBFhz1Ptkq0RoVY+Jt2qc1WGqRA1pCbyJiuL9EESPsdasZ1IlenN1eS75LKt5Blam/1KlZhaELqyRFlDgQCtp/VbvFaQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=dpdk.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 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=GiDzTkd0yyjAobMW/5JQtrlyuUeZjzAABq83NxC13Jo=; b=2//1c8xanf6qOEf0o7L5E2sikzwuZGgwdgt92sNMcAXJ8QC9QeBvaW7yOIhmSA2WxLeCQQWzDvYivVQCoPo1nN5U0DtkLZEl3BEBiUd0ttsOWiBcJe4dOlaAIXQUWTi01kKTxDVHinnR6qramqE+XBP7i4glw1FE/XQ6qTG9kW8= Received: from BN0PR02CA0021.namprd02.prod.outlook.com (2603:10b6:408:e4::26) by IA1PR12MB8468.namprd12.prod.outlook.com (2603:10b6:208:445::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6002.33; Tue, 24 Jan 2023 14:07:59 +0000 Received: from BN8NAM11FT101.eop-nam11.prod.protection.outlook.com (2603:10b6:408:e4:cafe::b5) by BN0PR02CA0021.outlook.office365.com (2603:10b6:408:e4::26) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6002.33 via Frontend Transport; Tue, 24 Jan 2023 14:07:59 +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=SATLEXMB04.amd.com; pr=C Received: from SATLEXMB04.amd.com (165.204.84.17) by BN8NAM11FT101.mail.protection.outlook.com (10.13.177.126) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.6002.13 via Frontend Transport; Tue, 24 Jan 2023 14:07:59 +0000 Received: from SATLEXMB03.amd.com (10.181.40.144) by SATLEXMB04.amd.com (10.181.40.145) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.34; Tue, 24 Jan 2023 08:07:58 -0600 Received: from xhdipdslab49.xilinx.com (10.180.168.240) by SATLEXMB03.amd.com (10.181.40.144) with Microsoft SMTP Server id 15.1.2375.34 via Frontend Transport; Tue, 24 Jan 2023 08:07:56 -0600 From: Nipun Gupta To: , , CC: , , Subject: [RFC PATCH 4/6] bus/cdx: support plug unplug and dev iterator Date: Tue, 24 Jan 2023 19:37:44 +0530 Message-ID: <20230124140746.594066-5-nipun.gupta@amd.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230124140746.594066-1-nipun.gupta@amd.com> References: <20230124140746.594066-1-nipun.gupta@amd.com> MIME-Version: 1.0 X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: BN8NAM11FT101:EE_|IA1PR12MB8468:EE_ X-MS-Office365-Filtering-Correlation-Id: 0609f3ff-06f4-4e0c-f62f-08dafe146632 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 0CfLfEmcmKtzo5FV2k2BwwzlnszCHL2uTh+Vu5ctfH49dKACvbR6RhMdUMafdz75t1BC06yPA3cdbTQKD6z0jcv4Ri+FMKCGXrsEwqeNPuLbHJLxEduL1uQdGkSTJrA17BSEnTmlbZhuj+6UGU+oLoxq6F6Eu34bRiDDa9Tua+OnvIM+cdqaEmMd3KtLdZCTO8/UurkcR2n2LBLdDDIjLu6KdV3L+KoV5InW6zmq513PBN4hb6IlnSYDDtLAS0L4ZohyPzdJpK10xOuchVfQxhEU3H1IkRj7IHX5Q+syYCuvasL3XSlwmX/cGN7BuAhBAb1E12EQRFUVa2IVKqu5Yc4Y8hVN1ayFzw7pvcBfd0lv0M23s4m00LqPrGWA/ymLjD0fmpdrtQ40WmlN1aHAy1W8M1Sg805Uz8BnD8rL07LSA9KE6iOurkS0tuTrsIWNINaPP2YguPXLD88nZ6UXPhdb0+E5gO+xY8Nf6QnI3NdPr9Y0PQR5kr/tgUqjmV23lt7QukE62cYU3M62QQyX9tgyjV5ZIpbM/0NZAGBig4fE8ML4jl01xGcvq5DmJ6kJ0lQxsSuhMwI+UpEFb7Z8oGe/x5g8MJ27XGHZfuDL8O4po36yciRDJ/iWxMUMLL3qpoKbdydiL8zwvNCo+hasih9hiUMZNriY/7OOhmo/SqMfc4yKZkQ3qyqHOLMT4B7rTqTwYD2LBu7kNV0teh9WV7vPsrSuxHaCawHio1Zz2cY= X-Forefront-Antispam-Report: CIP:165.204.84.17; CTRY:US; LANG:en; SCL:1; SRV:; IPV:CAL; SFV:NSPM; H:SATLEXMB04.amd.com; PTR:InfoDomainNonexistent; CAT:NONE; SFS:(13230022)(4636009)(136003)(39860400002)(346002)(376002)(396003)(451199015)(40470700004)(36840700001)(46966006)(82740400003)(40460700003)(36860700001)(36756003)(81166007)(356005)(86362001)(8936002)(5660300002)(44832011)(2906002)(70586007)(41300700001)(8676002)(4326008)(70206006)(82310400005)(316002)(40480700001)(47076005)(426003)(2616005)(336012)(83380400001)(54906003)(110136005)(1076003)(478600001)(6666004)(26005)(186003)(36900700001); DIR:OUT; SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 24 Jan 2023 14:07:59.3294 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 0609f3ff-06f4-4e0c-f62f-08dafe146632 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=[SATLEXMB04.amd.com] X-MS-Exchange-CrossTenant-AuthSource: BN8NAM11FT101.eop-nam11.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: IA1PR12MB8468 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Add support for plugging and unplugging CDX devices on the CDX bus. Also, CDX dev iterator support has been added for the CDX bus. Signed-off-by: Nipun Gupta --- drivers/bus/cdx/cdx.c | 142 +++++++++++++++++++++++++++++++--- drivers/bus/cdx/rte_bus_cdx.h | 1 + 2 files changed, 133 insertions(+), 10 deletions(-) diff --git a/drivers/bus/cdx/cdx.c b/drivers/bus/cdx/cdx.c index d0adfb74ef..151d35ffd3 100644 --- a/drivers/bus/cdx/cdx.c +++ b/drivers/bus/cdx/cdx.c @@ -69,6 +69,7 @@ #include #include #include +#include #include #include #include @@ -81,6 +82,15 @@ #define SYSFS_CDX_DEVICES "/sys/bus/cdx/devices" #define CDX_BUS_NAME cdx +enum cdx_params { + RTE_CDX_PARAM_NAME, +}; + +static const char * const cdx_params_keys[] = { + [RTE_CDX_PARAM_NAME] = "name", + NULL, +}; + /** * @file * CDX probing using Linux sysfs. @@ -88,7 +98,7 @@ /* Add a device to CDX bus */ static void -rte_cdx_add_device(struct rte_cdx_device *cdx_dev) +cdx_add_device(struct rte_cdx_device *cdx_dev) { TAILQ_INSERT_TAIL(&rte_cdx_bus.device_list, cdx_dev, next); } @@ -258,7 +268,7 @@ cdx_scan_one(const char *dirname, const char *dev_name) } dev->id.device_id = (uint16_t)tmp; - rte_cdx_add_device(dev); + cdx_add_device(dev); return 0; @@ -275,7 +285,7 @@ cdx_scan_one(const char *dirname, const char *dev_name) * list. */ static int -rte_cdx_scan(void) +cdx_scan(void) { struct dirent *e; DIR *dir; @@ -355,7 +365,7 @@ cdx_unmap_resource(void *requested_addr, size_t size) * Match the CDX Driver and Device using device id and vendor id. */ static int -rte_cdx_match(const struct rte_cdx_driver *cdx_drv, +cdx_match(const struct rte_cdx_driver *cdx_drv, const struct rte_cdx_device *cdx_dev) { const struct rte_cdx_id *id_table; @@ -381,7 +391,7 @@ rte_cdx_match(const struct rte_cdx_driver *cdx_drv, * driver. */ static int -rte_cdx_probe_one_driver(struct rte_cdx_driver *dr, +cdx_probe_one_driver(struct rte_cdx_driver *dr, struct rte_cdx_device *dev) { const char *dev_name = dev->device.name; @@ -392,7 +402,7 @@ rte_cdx_probe_one_driver(struct rte_cdx_driver *dr, return -EINVAL; /* The device is not blocked; Check if driver supports it */ - if (!rte_cdx_match(dr, dev)) + if (!cdx_match(dr, dev)) /* Match of device and driver failed */ return 1; @@ -420,6 +430,7 @@ rte_cdx_probe_one_driver(struct rte_cdx_driver *dr, } else { dev->device.driver = &dr->driver; } + dev->driver = dr; return ret; @@ -446,7 +457,7 @@ cdx_probe_all_drivers(struct rte_cdx_device *dev) return -EINVAL; FOREACH_DRIVER_ON_CDXBUS(dr) { - rc = rte_cdx_probe_one_driver(dr, dev); + rc = cdx_probe_one_driver(dr, dev); if (rc < 0) /* negative value is an error */ return rc; @@ -560,6 +571,71 @@ cdx_find_device(const struct rte_device *start, rte_dev_cmp_t cmp, return NULL; } +/* Remove a device from CDX bus */ +static void +cdx_remove_device(struct rte_cdx_device *cdx_dev) +{ + TAILQ_REMOVE(&rte_cdx_bus.device_list, cdx_dev, next); +} + +/* + * If vendor/device ID match, call the remove() function of the + * driver. + */ +static int +cdx_detach_dev(struct rte_cdx_device *dev) +{ + struct rte_cdx_driver *dr; + int ret = 0; + + if (dev == NULL) + return -EINVAL; + + dr = dev->driver; + + CDX_BUS_DEBUG("detach device %s using driver: %s", + dev->device.name, dr->driver.name); + + if (dr->remove) { + ret = dr->remove(dev); + if (ret < 0) + return ret; + } + + /* clear driver structure */ + dev->driver = NULL; + dev->device.driver = NULL; + + rte_cdx_unmap_device(dev); + + rte_intr_instance_free(dev->intr_handle); + dev->intr_handle = NULL; + + return 0; +} + +static int +cdx_plug(struct rte_device *dev) +{ + return cdx_probe_all_drivers(RTE_DEV_TO_CDX_DEV(dev)); +} + +static int +cdx_unplug(struct rte_device *dev) +{ + struct rte_cdx_device *cdx_dev; + int ret; + + cdx_dev = RTE_DEV_TO_CDX_DEV(dev); + ret = cdx_detach_dev(cdx_dev); + if (ret == 0) { + cdx_remove_device(cdx_dev); + rte_devargs_remove(dev->devargs); + free(cdx_dev); + } + return ret; +} + static int cdx_dma_map(struct rte_device *dev, void *addr, uint64_t iova, size_t len) { @@ -589,7 +665,7 @@ cdx_dma_unmap(struct rte_device *dev, void *addr, uint64_t iova, size_t len) } static enum rte_iova_mode -rte_cdx_get_iommu_class(void) +cdx_get_iommu_class(void) { if (TAILQ_EMPTY(&rte_cdx_bus.device_list)) return RTE_IOVA_DC; @@ -597,15 +673,61 @@ rte_cdx_get_iommu_class(void) return RTE_IOVA_VA; } +static int +cdx_dev_match(const struct rte_device *dev, + const void *_kvlist) +{ + const struct rte_kvargs *kvlist = _kvlist; + const char *key = cdx_params_keys[RTE_CDX_PARAM_NAME]; + const char *name; + + /* no kvlist arg, all devices match */ + if (kvlist == NULL) + return 0; + + /* if key is present in kvlist and does not match, filter device */ + name = rte_kvargs_get(kvlist, key); + if (name != NULL && strcmp(name, dev->name)) + return -1; + + return 0; +} + +static void * +cdx_dev_iterate(const void *start, + const char *str, + const struct rte_dev_iterator *it __rte_unused) +{ + rte_bus_find_device_t find_device; + struct rte_kvargs *kvargs = NULL; + struct rte_device *dev; + + if (str != NULL) { + kvargs = rte_kvargs_parse(str, cdx_params_keys); + if (kvargs == NULL) { + CDX_BUS_ERR("cannot parse argument list %s", str); + rte_errno = EINVAL; + return NULL; + } + } + find_device = rte_cdx_bus.bus.find_device; + dev = find_device(start, cdx_dev_match, kvargs); + rte_kvargs_free(kvargs); + return dev; +} + struct rte_cdx_bus rte_cdx_bus = { .bus = { - .scan = rte_cdx_scan, + .scan = cdx_scan, .probe = cdx_probe, .find_device = cdx_find_device, + .plug = cdx_plug, + .unplug = cdx_unplug, .parse = cdx_parse, .dma_map = cdx_dma_map, .dma_unmap = cdx_dma_unmap, - .get_iommu_class = rte_cdx_get_iommu_class, + .get_iommu_class = cdx_get_iommu_class, + .dev_iterate = cdx_dev_iterate, }, .device_list = TAILQ_HEAD_INITIALIZER(rte_cdx_bus.device_list), .driver_list = TAILQ_HEAD_INITIALIZER(rte_cdx_bus.driver_list), diff --git a/drivers/bus/cdx/rte_bus_cdx.h b/drivers/bus/cdx/rte_bus_cdx.h index 43d75bc3b4..564fa8d047 100644 --- a/drivers/bus/cdx/rte_bus_cdx.h +++ b/drivers/bus/cdx/rte_bus_cdx.h @@ -78,6 +78,7 @@ struct rte_cdx_id { struct rte_cdx_device { RTE_TAILQ_ENTRY(rte_cdx_device) next; /**< Next probed CDX device. */ struct rte_device device; /**< Inherit core device */ + struct rte_cdx_driver *driver; /**< CDX driver used in probing */ struct rte_cdx_id id; /**< CDX ID. */ struct rte_mem_resource mem_resource[CDX_MAX_RESOURCE]; /**< CDX Memory Resource */ From patchwork Tue Jan 24 14:07:45 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Gupta, Nipun" X-Patchwork-Id: 122485 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 8E8174247C; Tue, 24 Jan 2023 15:08:35 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 8D4DB42D57; Tue, 24 Jan 2023 15:08:06 +0100 (CET) Received: from NAM12-BN8-obe.outbound.protection.outlook.com (mail-bn8nam12on2066.outbound.protection.outlook.com [40.107.237.66]) by mails.dpdk.org (Postfix) with ESMTP id 6EF3D42D54 for ; Tue, 24 Jan 2023 15:08:05 +0100 (CET) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=aYwHXOQfRchMPwEAGf93yzpAOahiU4AN2Fm0SW0xBRxvP/NPtGelZVq+bJCvcQLi3xa2K3ssTcg0vI8axIsSadd2U1EG8nYwu00ykvvVWCz5o//51eF2HtKzimE4r7mGLF2cPkjCvsvFW6cOBwVJ/COrCnv63NLXlMWjoUOAaHU2DW9+rLTcUqQX9S0ClkmCE2Td9eDuS8gXb9c0gJ4W5gAovXpaZM/o3XHpYoH5o+3nEkRMQokIcJO+28hMitc4J0Khl42ji29CNst2EjRFj6voy9AjY84VWsgJNut5B5sl3jXBYkW7XbZVKhGMV+/3Oy8SmcfXTP89fJY6gTqRqg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=YpHroHAfhja4rRTC5ndHntfmeOPnnAn3iHh2mvEYQnw=; b=Bj8eKBCaLC0AJJIQiLYeHhGIi8N7eCeu0awiVM3e8Sam4SwD/IJdfV+h4AlWkvsD7oB+HZnp7Nuo1B3KrYAXIPBEKRIdzrCA+UwlVFFNhL2VJKpWkYhW1nnh4t7TCEWK9jAxC1qFZKj6us7QiRGL6V1E2doGiJu2mdMl4aRzPwvwtiFXpsza58VldfoeDn3R0kE6MmU2YfAX+c8/WCSEXC2qvr/z8OciTkaPXfIXv1lwGtXh63P7QvEchKLteOcvQpXbhh6JKfINdQjPEZ+POt/Kyygj+LgMN6b75Wgh98oitS5IeZCISJ5e0ThCXZk73jfAtTAP7rbQ5eVzB6x1Ng== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=dpdk.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 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=YpHroHAfhja4rRTC5ndHntfmeOPnnAn3iHh2mvEYQnw=; b=NkaX1DDy1luGwjD2gV1IF9ETV85lOjjbE1iFKxGF8pmSMKwoksbxmEUGDYIN/XSkrCrsBojZXa7PTyy3tgRNLo1hiUt0n5Q+3mHpq/NpdUpStVydbfgy7/enIPUJjckW8c/KJX2IDMG4JxZ+RXEjTbwYVPFEsM4O6f9R3KiL6wM= Received: from DM6PR14CA0041.namprd14.prod.outlook.com (2603:10b6:5:18f::18) by BL3PR12MB6593.namprd12.prod.outlook.com (2603:10b6:208:38c::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6002.33; Tue, 24 Jan 2023 14:08:02 +0000 Received: from DM6NAM11FT085.eop-nam11.prod.protection.outlook.com (2603:10b6:5:18f:cafe::1) by DM6PR14CA0041.outlook.office365.com (2603:10b6:5:18f::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6002.33 via Frontend Transport; Tue, 24 Jan 2023 14:08:01 +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=SATLEXMB03.amd.com; pr=C Received: from SATLEXMB03.amd.com (165.204.84.17) by DM6NAM11FT085.mail.protection.outlook.com (10.13.172.236) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.6023.16 via Frontend Transport; Tue, 24 Jan 2023 14:08:01 +0000 Received: from SATLEXMB06.amd.com (10.181.40.147) 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.2375.34; Tue, 24 Jan 2023 08:08:01 -0600 Received: from SATLEXMB03.amd.com (10.181.40.144) by SATLEXMB06.amd.com (10.181.40.147) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.34; Tue, 24 Jan 2023 08:08:00 -0600 Received: from xhdipdslab49.xilinx.com (10.180.168.240) by SATLEXMB03.amd.com (10.181.40.144) with Microsoft SMTP Server id 15.1.2375.34 via Frontend Transport; Tue, 24 Jan 2023 08:07:58 -0600 From: Nipun Gupta To: , , CC: , , Subject: [RFC PATCH 5/6] bus: enable cdx bus Date: Tue, 24 Jan 2023 19:37:45 +0530 Message-ID: <20230124140746.594066-6-nipun.gupta@amd.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230124140746.594066-1-nipun.gupta@amd.com> References: <20230124140746.594066-1-nipun.gupta@amd.com> MIME-Version: 1.0 X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: DM6NAM11FT085:EE_|BL3PR12MB6593:EE_ X-MS-Office365-Filtering-Correlation-Id: aaaa2fa9-1f0b-4616-f691-08dafe146791 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: LY11AJ0WhuAxzb2MStb6oB8PRJCCJSh3vS93/huRspZy7IZgGNEdu1SgesJbCSzBI2kqgjy0qD5+TKCX3LTtazLZDH6CoAH4H8ufl9yqlbUlpARVXd+DYs4y2Wg2pIRAw7Fvw0aZZpZ+oYr8oHXWDuC6eL7OmFnSwC2AsBH2XfdRBHHkGBVjed/B/ab1cVTo6Mzb5T+pduyfvEtdmcglNbcFmQ0b5GHM98SJm2e3aA/ZL7VQH0WtdYpR3eXX9jXF/2uYxEBpYrA6a3EHpbHz6qExr+aluXO5N7/kEIEly2nGDN1uKNMC2sy8DNTlfTVQxE3heoGGHXc4ePdMhM6FTMWajTKiKaGjvAdnAoc9w2vUPsDs8gTM3srYqnard16N7FY+svVEXJE/KtksOVJuFjjUQJXI8gzlt3cEKwSJ6lQgmMRg8ZwFHbYtBk5ydpczpvSXaI2PC9Z//IGvN8BPWhr22XzcRdlgrhhVJvIWFplFuFQSoqK7BpXDcJC79rbTEGCEjPaYaLmhDXJSudiWzShdCmEiQo5Bn6QpWljG807Hf29LuETTLRWfAnpuYDoEPIarpyDXx+1RcIaksuYuc7q6v6pCZkzro3qj/EVdPlRY00pOUEphhhk7ovk/oQsmOkryzoOng3m+Bze9uIHtK98stQss7zAgFiS/fOHABiR8tXPZC00UISOfvfDRLHEvoUC4kp5m2MfPdfnZzNCk3psMzjaFz3lmXEg6vyxZhZ0= X-Forefront-Antispam-Report: CIP:165.204.84.17; CTRY:US; LANG:en; SCL:1; SRV:; IPV:CAL; SFV:NSPM; H:SATLEXMB03.amd.com; PTR:InfoDomainNonexistent; CAT:NONE; SFS:(13230022)(4636009)(136003)(39860400002)(396003)(346002)(376002)(451199015)(36840700001)(46966006)(40470700004)(81166007)(82740400003)(36860700001)(86362001)(356005)(70586007)(5660300002)(8936002)(2906002)(44832011)(8676002)(4744005)(70206006)(4326008)(40480700001)(41300700001)(82310400005)(186003)(1076003)(336012)(2616005)(26005)(426003)(47076005)(40460700003)(110136005)(316002)(54906003)(478600001)(6666004)(36756003)(36900700001); DIR:OUT; SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 24 Jan 2023 14:08:01.5985 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: aaaa2fa9-1f0b-4616-f691-08dafe146791 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=[SATLEXMB03.amd.com] X-MS-Exchange-CrossTenant-AuthSource: DM6NAM11FT085.eop-nam11.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BL3PR12MB6593 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org enable compilation of cdx bus Signed-off-by: Nipun Gupta --- drivers/bus/meson.build | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/bus/meson.build b/drivers/bus/meson.build index 45eab5233d..884470234c 100644 --- a/drivers/bus/meson.build +++ b/drivers/bus/meson.build @@ -7,6 +7,7 @@ drivers = [ 'fslmc', 'ifpga', 'pci', + 'cdx', 'vdev', 'vmbus', ] From patchwork Tue Jan 24 14:07:46 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Gupta, Nipun" X-Patchwork-Id: 122486 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 6DD474247C; Tue, 24 Jan 2023 15:08:42 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 9CA0542D41; Tue, 24 Jan 2023 15:08:12 +0100 (CET) Received: from NAM11-DM6-obe.outbound.protection.outlook.com (mail-dm6nam11on2068.outbound.protection.outlook.com [40.107.223.68]) by mails.dpdk.org (Postfix) with ESMTP id C8E3F42D3C for ; Tue, 24 Jan 2023 15:08:10 +0100 (CET) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=H03ELA4wj+l9gPOURudY79WVSaO4otBrqU7R+SQkynqFFSP3Fw0qqY12nstujvqQwNpCqikvy8Z/pRLr6gnX6sZROt67z8EaHXy9Yo6EixEgJGoFN3NgdH9V9eEu6xiCYNdNP3Lis1KyU/n7Y22YFZRao6N5TSxg0C1Pp8jrLt7NLlmhOUm5GNzDSdcpfjLAjve/yRqoq4Ij3MmVYCXz7BH8CIIB3U4QSviZFRBtlXG5u80geRcT5tq8a58kMG7k/kQ1aTlEznf/p+E3tTMek3h8QQQPC+Y1wn/16VtKvVcEZA+pEnBqJ4ul3qqaVw8xnUwzzmV/yH6ZGg8kZmUTMQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=WhbO2kAJLUI1PvMdRsumRlz702cPn1BssFFzCxI7eVE=; b=QWwJb0swCvwjbdcB4C24eg7Wby2ZADMcwxzKO6dCjhaV7BuorM2TN5kS7zrTMAZZG/Jji8ITKxt3kBEgK6nWjNpqf1zE4m4SeETKhTile3G4ZOiFo2ePYe03gVRQQkwY4oe3uYbcPnTKUKrAcIcf2d6EQGO5okUgtCnWLhHGHRMiDRKz/Zv344GW2cYtGIhWL6P0YM8bTgPfKsQFTg8dlEsyOf8m8irz68ez7CwQXzJmYG+OG+i2cST3fY/C734vxxDCqHJ2uP0c7Jeh5AZHJa7L2nAZ1fnUP8SVjIfGYIRmVRUQvWxO1RTLoOqk6ZS5mPINnVYxJecGLHwk+KzKBg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=dpdk.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 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=WhbO2kAJLUI1PvMdRsumRlz702cPn1BssFFzCxI7eVE=; b=n2wPPsF5c+Iz8S1A+cvpyt+PPEbpQ6AmDGZqzFiTjia9x+AxVjPR+jAfnACOYdMHzVWXZ15P2RA2LbZX9ld6RuguVQJErDQ92G8nI/3rHPrzzBnLB3GHd7kEemXxEn7U+rRTa5WQioJkEgVle4wUmpKoJz1OzgIrj95rj32DTk4= Received: from BN9PR03CA0961.namprd03.prod.outlook.com (2603:10b6:408:109::6) by LV2PR12MB5965.namprd12.prod.outlook.com (2603:10b6:408:172::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6002.33; Tue, 24 Jan 2023 14:08:06 +0000 Received: from BN8NAM11FT005.eop-nam11.prod.protection.outlook.com (2603:10b6:408:109:cafe::94) by BN9PR03CA0961.outlook.office365.com (2603:10b6:408:109::6) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6002.33 via Frontend Transport; Tue, 24 Jan 2023 14:08:06 +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=SATLEXMB04.amd.com; pr=C Received: from SATLEXMB04.amd.com (165.204.84.17) by BN8NAM11FT005.mail.protection.outlook.com (10.13.176.69) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.6043.17 via Frontend Transport; Tue, 24 Jan 2023 14:08:06 +0000 Received: from SATLEXMB06.amd.com (10.181.40.147) by SATLEXMB04.amd.com (10.181.40.145) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.34; Tue, 24 Jan 2023 08:08:03 -0600 Received: from SATLEXMB03.amd.com (10.181.40.144) by SATLEXMB06.amd.com (10.181.40.147) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.34; Tue, 24 Jan 2023 08:08:02 -0600 Received: from xhdipdslab49.xilinx.com (10.180.168.240) by SATLEXMB03.amd.com (10.181.40.144) with Microsoft SMTP Server id 15.1.2375.34 via Frontend Transport; Tue, 24 Jan 2023 08:08:01 -0600 From: Nipun Gupta To: , , CC: , , Subject: [RFC PATCH 6/6] config/arm: add AMD CDX Date: Tue, 24 Jan 2023 19:37:46 +0530 Message-ID: <20230124140746.594066-7-nipun.gupta@amd.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230124140746.594066-1-nipun.gupta@amd.com> References: <20230124140746.594066-1-nipun.gupta@amd.com> MIME-Version: 1.0 X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: BN8NAM11FT005:EE_|LV2PR12MB5965:EE_ X-MS-Office365-Filtering-Correlation-Id: 2f92f13b-a052-4e09-5bc2-08dafe146a6b X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: IoWuwsxoYHtPNkK5Jwv90idzuKf8c54l5Q2YNoUKV0rdqUSZK+s5ouLJ5SOOyUMGXUlxEIo1l7unz1N5rOl0cvzGSb/NT0nX/FKPwp/HPOQnm0ZC81xTSgHUsPN+8AoZoXwiPAhvE1jfbaQYlBW78sC3pfeFE0i6hZelbn/4WVgFCMXJF8enxv2EV4pHQbdgveNGlyyKXeSHaRQrJBBOfGB7clFvIPjjQAPk411ky3daLrgjdIrRGwo/rX9gaZqrTTRZ1tRYsEYw0YV5MHodTOn+IBIAFO5NPINUPeecCCxovnysH0W/8r6goyk8+9Iq/ABn3Kq+J6zV2Pn0kfu9HXfdAAzO/WwPlwUGAJUlYr637rnth3gsisfSlk8Gz7Out0UDVN/BKGfHu+t7GxfvYrmDgljXqEhLXtFZ3tX9eSub0jw7WB3tZckselvsIm/gec8oyjleduZqunBCeVZKijYJjWc0P74qlXMbHv8y+e057YjnvcD+1pJXoHJ3vGqxKg51SBQxLNfZMsf/3rGJ3iYmH7TwCS/vYNRUMoZyM2ooqbKGmrO8epm0kop4lOZCZh5J/re1KRxab8thEUMLFpk2oy4pxVO/qVD9u6aV0Eej93CNhLjAkNQaLIA99ZHdCOt3Epgefez7qJ0kSAs2y8GiD7f/Cj20ZohKDjuS1UrZk4hlEp9WcgxGsvTsPQWIOltojMUH7Z2mKGavlKZ7Q77mrjxUAsbpNIBGURphsDE= X-Forefront-Antispam-Report: CIP:165.204.84.17; CTRY:US; LANG:en; SCL:1; SRV:; IPV:CAL; SFV:NSPM; H:SATLEXMB04.amd.com; PTR:InfoDomainNonexistent; CAT:NONE; SFS:(13230022)(4636009)(396003)(39860400002)(346002)(376002)(136003)(451199015)(36840700001)(46966006)(40470700004)(36860700001)(36756003)(316002)(86362001)(70586007)(4326008)(70206006)(54906003)(8676002)(110136005)(186003)(26005)(40480700001)(6666004)(356005)(478600001)(336012)(81166007)(2616005)(1076003)(44832011)(5660300002)(47076005)(8936002)(40460700003)(426003)(41300700001)(82740400003)(2906002)(82310400005)(36900700001); DIR:OUT; SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 24 Jan 2023 14:08:06.4099 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 2f92f13b-a052-4e09-5bc2-08dafe146a6b 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=[SATLEXMB04.amd.com] X-MS-Exchange-CrossTenant-AuthSource: BN8NAM11FT005.eop-nam11.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: LV2PR12MB5965 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Adding support for AMD CDX devices Signed-off-by: Nipun Gupta --- config/arm/arm64_cdx_linux_gcc | 17 +++++++++++++++++ config/arm/meson.build | 15 +++++++++++++++ 2 files changed, 32 insertions(+) create mode 100644 config/arm/arm64_cdx_linux_gcc diff --git a/config/arm/arm64_cdx_linux_gcc b/config/arm/arm64_cdx_linux_gcc new file mode 100644 index 0000000000..8e6d619dae --- /dev/null +++ b/config/arm/arm64_cdx_linux_gcc @@ -0,0 +1,17 @@ +[binaries] +c = ['ccache', 'aarch64-linux-gnu-gcc'] +cpp = ['ccache', 'aarch64-linux-gnu-g++'] +ar = 'aarch64-linux-gnu-ar' +as = 'aarch64-linux-gnu-as' +strip = 'aarch64-linux-gnu-strip' +pkgconfig = 'aarch64-linux-gnu-pkg-config' +pcap-config = '' + +[host_machine] +system = 'linux' +cpu_family = 'aarch64' +cpu = 'armv8-a' +endian = 'little' + +[properties] +platform = 'cdx' diff --git a/config/arm/meson.build b/config/arm/meson.build index 6442ec9596..76806b2820 100644 --- a/config/arm/meson.build +++ b/config/arm/meson.build @@ -63,6 +63,7 @@ part_number_config_arm = { '0xd09': {'compiler_options': ['-mcpu=cortex-a73']}, '0xd0a': {'compiler_options': ['-mcpu=cortex-a75']}, '0xd0b': {'compiler_options': ['-mcpu=cortex-a76']}, + '0xd42': {'compiler_options': ['-mcpu=cortex-a78']}, '0xd0c': { 'march': 'armv8.2-a', 'march_features': ['crypto'], @@ -302,6 +303,18 @@ soc_bluefield = { 'numa': false } +soc_cdx = { + 'description': 'AMD CDX', + 'implementer': '0x41', + 'part_number': '0xd42', + 'flags': [ + ['RTE_MACHINE', '"cdx"'], + ['RTE_MAX_LCORE', 16], + ['RTE_MAX_NUMA_NODES', 1] + ], + 'numa': false +} + soc_centriq2400 = { 'description': 'Qualcomm Centriq 2400', 'implementer': '0x51', @@ -448,6 +461,7 @@ generic: Generic un-optimized build for armv8 aarch64 execution mode. generic_aarch32: Generic un-optimized build for armv8 aarch32 execution mode. armada: Marvell ARMADA bluefield: NVIDIA BlueField +cdx: AMD CDX centriq2400: Qualcomm Centriq 2400 cn9k: Marvell OCTEON 9 cn10k: Marvell OCTEON 10 @@ -474,6 +488,7 @@ socs = { 'generic_aarch32': soc_generic_aarch32, 'armada': soc_armada, 'bluefield': soc_bluefield, + 'cdx': soc_cdx, 'centriq2400': soc_centriq2400, 'cn9k': soc_cn9k, 'cn10k' : soc_cn10k,