From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 235DDA0A0F; Mon, 5 Jul 2021 08:47:44 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 06A3A40686; Mon, 5 Jul 2021 08:47:44 +0200 (CEST) Received: from NAM02-SN1-obe.outbound.protection.outlook.com (mail-sn1anam02on2059.outbound.protection.outlook.com [40.107.96.59]) by mails.dpdk.org (Postfix) with ESMTP id 7A5B240141 for ; Mon, 5 Jul 2021 08:47:42 +0200 (CEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=n93Z7XLdLekeVzEKeTiG8e2x0Tvckkd1tH8kHzH1Am0udbT7J1Go7YYfib6FrhvjmuApNmzbit6A0FTHKy6+k3DzeQq9YjxojBr7TPO9Ar/63MLNyq9qBZml9PvPPFPl6Kd40GtGDfYCKnVIn3/cOOOxZn265qqqkZQTr3GVhSON8N0g7dOzJQgkh8rwn713zhsBNit8aLx2DK1HL67xrcBWsAtCd+oGoceOtcW2j5lMealCl98EKnz3xQfdRsISZTjKD/uiWQbPRgn9vzU1VWDJ401ieXZIlHhAUa/vo8DpWGgLElwjL8A5msCRb8dBom222QSTUhuFcBv1KJCVbw== 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-SenderADCheck; bh=aONJ9EM3E9lHigq9+qb8EiOtCS3szY5JxfwL79p7ZvU=; b=i9kcoBylnRmn1kSGX3ZzKa+fzR3GkNBn6il53JuDuuK3ztsSx7ogCr8FiHSqBntoZ31Cnbbkuu/biu8grCSjexz2M6GMc+VGDTjDmoTbop7oJNRdPBjccSYAoaXe1wIp/stY7TRvmaVWGZzrgCeza6WrTHwnrHgBeWnIkixJ/00eypnLOflK9XocW5H4GZikPWVFdlCHKzJx/w5xv0hc2RCDMMOfvuGtlga5hUgpwOHzmjejPw4N6wPJlLkk2aNDug7g9nGMW6PRqts0QROyMacdCXkNz8YdNwMl64/RnJPUbeYA2bmz4jPugTCBtdbVX3LbSYDC7zp4mt8splUjCg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nvidia.com; dmarc=pass action=none header.from=nvidia.com; dkim=pass header.d=nvidia.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=Nvidia.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=aONJ9EM3E9lHigq9+qb8EiOtCS3szY5JxfwL79p7ZvU=; b=nRLvqvA/4CaLI4pjCONxbkImL0yiNKqyT5Fnztkn8/gppm0OPVgGbWU43Rcrh5t37AAyeth+XEIZUFj3XbxZ2d7lEBXG7UtCaPQfp62yHxuDW3uZnUMT7DON8RSHvob4N5GeimeB8bUPGVy59Qq3Uka0+gyHLhs5D74VuvBYG3uf089nnFWDNelU0PgOtm8p+rA9BH+ca3aBGIVaM6dW0pHv8m2VaPgLQSS+rRb41f0124o22+AZ7IezY6jMKzSlh1HKIufTeLHfLegcfYhgBd7O5TqC57evDHYUFlhv319TtxrzqevZHGakt2j6Oye1ykh52LbehyuEKnuzJJcYWg== Received: from DM4PR12MB5373.namprd12.prod.outlook.com (2603:10b6:5:39a::17) by DM4PR12MB5376.namprd12.prod.outlook.com (2603:10b6:5:39a::9) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.4287.27; Mon, 5 Jul 2021 06:47:40 +0000 Received: from DM4PR12MB5373.namprd12.prod.outlook.com ([fe80::ac75:9b9a:a03f:1676]) by DM4PR12MB5373.namprd12.prod.outlook.com ([fe80::ac75:9b9a:a03f:1676%3]) with mapi id 15.20.4287.033; Mon, 5 Jul 2021 06:47:40 +0000 From: "Xueming(Steven) Li" CC: "dev@dpdk.org" , Wang Haiyue , NBU-Contact-Thomas Monjalon , Kinsella Ray , Andrew Rybchenko , Parav Pandit , Neil Horman Thread-Topic: [PATCH v7 2/2] bus/auxiliary: introduce auxiliary bus Thread-Index: AQHXcV/flOIBTS0Jl0O1MlCU6x6JEasz8CGw Date: Mon, 5 Jul 2021 06:47:40 +0000 Message-ID: References: <20210625114726.776425-1-xuemingl@nvidia.com> <20210705053659.12350-2-xuemingl@nvidia.com> In-Reply-To: <20210705053659.12350-2-xuemingl@nvidia.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: authentication-results: dpdk.org; dkim=none (message not signed) header.d=none;dpdk.org; dmarc=none action=none header.from=nvidia.com; x-originating-ip: [2409:891f:c020:78b2:6904:8926:afd9:665f] x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: b93f38e6-96a3-4d6a-ede4-08d93f80c8e5 x-ms-traffictypediagnostic: DM4PR12MB5376: x-ld-processed: 43083d15-7273-40c1-b7db-39efd9ccc17a,ExtAddr x-ms-exchange-transport-forked: True x-microsoft-antispam-prvs: x-ms-oob-tlc-oobclassifiers: OLM:6790; x-ms-exchange-senderadcheck: 1 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: TMn06zZhHM1EyBvJTooNr9dci9ZI1um8cQSJ0hASNkeIOLQIl6yr56sTSXxaeLPJ11zIiSWpCGxFZpSWHtarXAl298BRiGmWYwyjqmlguUcGhoXvLRNd4UI/G92rMXVA6ewwIxoVRke2ZdWLWc/sM79qmoIt2CRa0CK70ZiyCHHSQi2FjtWpODwZXiFX/3AJjicvdh/smv5wtvRkT3dTIPBlNpguVd4/IkbPp+hc6JzrbzQuSkPynDIJzV34/P1xlTtq2AGSgHF8AXUiOkY7Buf1Z81KIt+leR1kkWj0sTsS28fjGHWatVrDEH9e5g3iB2E34RETmaEGQE6tk+Nk3/y7gJSBZcUsgA8IsOCrO7JNic3TgFeMg4jdKRTLy7y5IDiGamOdmdaAmKpvekR89oOHNhHVraikxw1FKirRgYQunwpqfO8fgaqUWxjO794DXTV0AZlX0ooFls4KSniNMdZz2BZNeQWzdMG1ADI7H8wUBgAwAFr5kDLZgfSBxn10oIgaTMKVh/yxvdDZvj1WH02gbgd0Z16b35AzI9aDhII3f7fBrQOjAzOv+QqQMSCmzwfcqyvCzEGV/UgWlUxeIwKa6sTPOmFRPK6Pnm/jFmIYaip3HNxEwmVH3IUwxH/LtJyte+JiJAuHv+ld7IUdfd8sqHtT92IHLsOG/Ky8H0OHUcthG6lm2qmIu6kPhQ7qu7wpYxweh4yyG+/IbKRu+MLm4YLINghKOGkzNd2rZtY= x-forefront-antispam-report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:DM4PR12MB5373.namprd12.prod.outlook.com; PTR:; CAT:NONE; SFS:(4636009)(346002)(376002)(396003)(136003)(39860400002)(366004)(8676002)(55016002)(2906002)(30864003)(186003)(38100700002)(52536014)(76116006)(122000001)(9686003)(8936002)(4326008)(66946007)(66476007)(109986005)(6506007)(5660300002)(33656002)(7696005)(966005)(316002)(66446008)(64756008)(66556008)(86362001)(54906003)(71200400001)(83380400001)(478600001)(559001)(579004); DIR:OUT; SFP:1101; x-ms-exchange-antispam-messagedata-chunkcount: 1 x-ms-exchange-antispam-messagedata-0: =?us-ascii?Q?S+2cwHhZ/O0uASis8pI5f9pxuBvXFCKqDs6l59sgMdi3cvZoP1D5cHeKgcj6?= =?us-ascii?Q?LGYCXBLC+z/FaBB00Hv1Tdyp22K9aMbMYhX62kX6zFh+s5lQL7lDVGFOWjQn?= =?us-ascii?Q?0HtMhJq/OLQ3I2zK5QJdBLxeFNAfxWUDcM0hDEUzhns/IQxIqLRsSxQSAfHf?= =?us-ascii?Q?rbg7wtBDT4t0aTzBgfRFHoVFwIY+J5RNblTg7k+ylQIfFyh+PFYtWN+E1bzL?= =?us-ascii?Q?W+KWcleBzGh3h5KUO9rxH12iKC7ZkJQe2iVFS+H+D92jGFJBO85ZQqEgtU72?= =?us-ascii?Q?V2XpyIQSSNkBmSvGoHAMEZTDxGvkAO4LZ47syXtiAd3mD2U9ILuEn60twZFq?= =?us-ascii?Q?SxAP0jbT0WX0LmqyEDmvq8SJTb2S9Kt32w/E3FHVlyzjzXTVRj1NZBXKxIlf?= =?us-ascii?Q?FkME8hcpqXPEyk3Y1jJtq6J/mEEytGZi9XahxqISWJE0sIG6YPEoR/crL4y2?= =?us-ascii?Q?GFxv1o8aj4S4o/+orrBwgrNiVdJQCoT1MVtj/eha6bu8NwsDX1w0pNi108TM?= =?us-ascii?Q?pWwtAir1+jWOJ20RFVLrZKhADTUT5lafo45eDYs+t3cvvh8OneTfJg15Bm7i?= =?us-ascii?Q?OOE3jG0c6xr+h5Lt3q5QjCcchxNTSNwu47nhQUDglBDAy8oQtvqo1kDz5KDb?= =?us-ascii?Q?MdTcLQPVu65A87yV2PF8vDWuZLF1jx5dVbJlvgSdud8u0cyrjwBcZaOkORpS?= =?us-ascii?Q?HgVWFs5el1R27uSi1d3CyTWlUqGxRaDifq3W3dvgfiZy0BAV0w0DQWxsWHKm?= =?us-ascii?Q?8qNInSz5I2KK0wAzMUACPahWGPMdQ/mllWXzM+WDb10krdpzvU4wr/lC6hEM?= =?us-ascii?Q?5+h0FzPe9278I9179o4wh7vGEYIPVZ/YwPqtn02mOY9SbQXo8Dnh5v17PH5F?= =?us-ascii?Q?55nLfQmobVoLD618ADH1ej3E3sQP7CrX1oCe+YyJgeaXh0anD+MzWwpTmuzY?= =?us-ascii?Q?lKD1CxZoWjbIZOZGIr6Mxxi5+yHmHIoD1Qwy/fccjQlKee11JtRUM0KJYZbF?= =?us-ascii?Q?E2J3NP32joESgcHThTCAmcZhHqxeiU22pYcSAOKeFIF4I+5nCV2k4SaY5VXn?= =?us-ascii?Q?q8deddnpwFw1ZPXUOQtOx0sdRGmuHda4ydYZmpRCIvKq8620Zp9+u85NbQ8u?= =?us-ascii?Q?iKSu2OR9HGG/Yc7LCWKy65/o7KCpUzSE4sQwIOk117htO2RZPJQCPishqME/?= =?us-ascii?Q?LZdf6GzE+uUkm5S47/GlGQD6BuQhlt6BNozvqxCZGx1DBngdxCeMZ2pf29yp?= =?us-ascii?Q?naUpPymE/1oDm3jeN4CJ9vlfTIPFrSt5k+6RSHQMHLoa4UjQQz78bqa6AzEs?= =?us-ascii?Q?4o8dL62ltYWvFp/dixPoX9WA+KZs0RrQ4zNpuzGgDGEg5N/om0A//F8yYw5U?= =?us-ascii?Q?+GuGc3fhbXRpfv3/rXNlwI+QkRrD?= Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 X-OriginatorOrg: Nvidia.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-AuthSource: DM4PR12MB5373.namprd12.prod.outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: b93f38e6-96a3-4d6a-ede4-08d93f80c8e5 X-MS-Exchange-CrossTenant-originalarrivaltime: 05 Jul 2021 06:47:40.7137 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: 43083d15-7273-40c1-b7db-39efd9ccc17a X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: VYpW9tXFzMcg9qjzidmHdeZiWXvv9TbTS3j9gin6FpIyvggsLsKkEuH1u08sfXDx6vrICsZvPRkFEdtzIswzsg== X-MS-Exchange-Transport-CrossTenantHeadersStamped: DM4PR12MB5376 Subject: Re: [dpdk-dev] [PATCH v7 2/2] bus/auxiliary: introduce auxiliary bus 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 Sender: "dev" Made changes and forgot to commit :( please ignore and refer to new v8. > -----Original Message----- > From: Xueming(Steven) Li > Sent: Monday, July 5, 2021 1:37 PM > Cc: dev@dpdk.org; Xueming(Steven) Li ; Wang Haiyue <= haiyue.wang@intel.com>; NBU-Contact-Thomas > Monjalon ; Kinsella Ray ; Andrew Rybc= henko ; Parav > Pandit ; Neil Horman > Subject: [PATCH v7 2/2] bus/auxiliary: introduce auxiliary bus >=20 > Auxiliary bus [1] provides a way to split function into child-devices rep= resenting sub-domains of functionality. Each auxiliary device > represents a part of its parent functionality. >=20 > Auxiliary device is identified by unique device name, sysfs path: > /sys/bus/auxiliary/devices/ >=20 > Devargs legacy syntax of auxiliary device: > -a auxiliary:[,args...] > Devargs generic syntax of auxiliary device: > -a bus=3Dauxiliary,name=3D/class=3D/driver=3D[,arg= s...] >=20 > [1] kernel auxiliary bus document: > https://www.kernel.org/doc/html/latest/driver-api/auxiliary_bus.html >=20 > Signed-off-by: Xueming Li > Cc: Wang Haiyue > Cc: Thomas Monjalon > Cc: Kinsella Ray > Acked-by: Andrew Rybchenko > --- > MAINTAINERS | 5 + > doc/guides/rel_notes/release_21_08.rst | 6 + > drivers/bus/auxiliary/auxiliary_common.c | 411 ++++++++++++++++++++++ = drivers/bus/auxiliary/auxiliary_params.c | 59 ++++ > drivers/bus/auxiliary/linux/auxiliary.c | 141 ++++++++ > drivers/bus/auxiliary/meson.build | 16 + > drivers/bus/auxiliary/private.h | 74 ++++ > drivers/bus/auxiliary/rte_bus_auxiliary.h | 201 +++++++++++ > drivers/bus/auxiliary/version.map | 7 + > drivers/bus/meson.build | 1 + > 10 files changed, 921 insertions(+) > create mode 100644 drivers/bus/auxiliary/auxiliary_common.c > create mode 100644 drivers/bus/auxiliary/auxiliary_params.c > create mode 100644 drivers/bus/auxiliary/linux/auxiliary.c > create mode 100644 drivers/bus/auxiliary/meson.build create mode 100644= drivers/bus/auxiliary/private.h create mode 100644 > drivers/bus/auxiliary/rte_bus_auxiliary.h > create mode 100644 drivers/bus/auxiliary/version.map >=20 > diff --git a/MAINTAINERS b/MAINTAINERS > index 5877a16971..9b0d0d4348 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -525,6 +525,11 @@ F: doc/guides/mempool/octeontx2.rst Bus Drivers > ----------- >=20 > +Auxiliary bus driver - EXPERIMENTAL > +M: Parav Pandit > +M: Xueming Li > +F: drivers/bus/auxiliary/ > + > Intel FPGA bus > M: Rosen Xu > F: drivers/bus/ifpga/ > diff --git a/doc/guides/rel_notes/release_21_08.rst b/doc/guides/rel_note= s/release_21_08.rst > index a6ecfdf3ce..e7ef4c8a05 100644 > --- a/doc/guides/rel_notes/release_21_08.rst > +++ b/doc/guides/rel_notes/release_21_08.rst > @@ -55,6 +55,12 @@ New Features > Also, make sure to start the actual text at the margin. > =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D >=20 > +* **Added auxiliary bus support.** > + > + Auxiliary bus provides a way to split function into child-devices > + representing sub-domains of functionality. Each auxiliary device > + represents a part of its parent functionality. > + >=20 > Removed Items > ------------- > diff --git a/drivers/bus/auxiliary/auxiliary_common.c b/drivers/bus/auxil= iary/auxiliary_common.c > new file mode 100644 > index 0000000000..8a75306da5 > --- /dev/null > +++ b/drivers/bus/auxiliary/auxiliary_common.c > @@ -0,0 +1,411 @@ > +/* SPDX-License-Identifier: BSD-3-Clause > + * Copyright (c) 2021 NVIDIA Corporation & Affiliates */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "private.h" > +#include "rte_bus_auxiliary.h" > + > +static struct rte_devargs * > +auxiliary_devargs_lookup(const char *name) { > + struct rte_devargs *devargs; > + > + RTE_EAL_DEVARGS_FOREACH(RTE_BUS_AUXILIARY_NAME, devargs) { > + if (strcmp(devargs->name, name) =3D=3D 0) > + return devargs; > + } > + return NULL; > +} > + > +/* > + * Test whether the auxiliary device exist > + * > + * Stub for OS not supporting auxiliary bus. > + */ > +__rte_weak bool > +auxiliary_dev_exists(const char *name) > +{ > + RTE_SET_USED(name); > + return false; > +} > + > +/* > + * Scan the devices in the auxiliary bus. > + * > + * Stub for OS not supporting auxiliary bus. > + */ > +__rte_weak int > +auxiliary_scan(void) > +{ > + return 0; > +} > + > +/* > + * Update a device's devargs being scanned. > + * > + * @param aux_dev > + * AUXILIARY device. > + */ > +void > +auxiliary_on_scan(struct rte_auxiliary_device *aux_dev) { > + aux_dev->device.devargs =3D auxiliary_devargs_lookup(aux_dev->name); > +} > + > +/* > + * Match the auxiliary driver and device using driver function. > + */ > +bool > +auxiliary_match(const struct rte_auxiliary_driver *aux_drv, > + const struct rte_auxiliary_device *aux_dev) { > + if (aux_drv->match =3D=3D NULL) > + return false; > + return aux_drv->match(aux_dev->name); > +} > + > +/* > + * Call the probe() function of the driver. > + */ > +static int > +rte_auxiliary_probe_one_driver(struct rte_auxiliary_driver *drv, > + struct rte_auxiliary_device *dev) { > + enum rte_iova_mode iova_mode; > + int ret; > + > + if ((drv =3D=3D NULL) || (dev =3D=3D NULL)) > + return -EINVAL; > + > + /* Check if driver supports it. */ > + if (!auxiliary_match(drv, dev)) > + /* Match of device and driver failed */ > + return 1; > + > + /* No initialization when marked as blocked, return without error. */ > + if (dev->device.devargs !=3D NULL && > + dev->device.devargs->policy =3D=3D RTE_DEV_BLOCKED) { > + AUXILIARY_LOG(INFO, "Device is blocked, not initializing"); > + return -1; > + } > + > + if (dev->device.numa_node < 0) { > + AUXILIARY_LOG(INFO, "Device is not NUMA-aware, defaulting socket to 0"= ); > + dev->device.numa_node =3D 0; > + } > + > + iova_mode =3D rte_eal_iova_mode(); > + if ((drv->drv_flags & RTE_AUXILIARY_DRV_NEED_IOVA_AS_VA) > 0 && > + iova_mode !=3D RTE_IOVA_VA) { > + AUXILIARY_LOG(ERR, "Driver %s expecting VA IOVA mode but current mode = is PA, not initializing", > + drv->driver.name); > + return -EINVAL; > + } > + > + dev->driver =3D drv; > + > + AUXILIARY_LOG(INFO, "Probe auxiliary driver: %s device: %s (socket %i)"= , > + drv->driver.name, dev->name, dev->device.numa_node); > + ret =3D drv->probe(drv, dev); > + if (ret !=3D 0) > + dev->driver =3D NULL; > + else > + dev->device.driver =3D &drv->driver; > + > + return ret; > +} > + > +/* > + * Call the remove() function of the driver. > + */ > +static int > +rte_auxiliary_driver_remove_dev(struct rte_auxiliary_device *dev) { > + struct rte_auxiliary_driver *drv; > + int ret =3D 0; > + > + if (dev =3D=3D NULL) > + return -EINVAL; > + > + drv =3D dev->driver; > + > + AUXILIARY_LOG(DEBUG, "Driver %s remove auxiliary device %s on NUMA sock= et %i", > + drv->driver.name, dev->name, dev->device.numa_node); > + > + if (drv->remove !=3D NULL) { > + ret =3D drv->remove(dev); > + if (ret < 0) > + return ret; > + } > + > + /* clear driver structure */ > + dev->driver =3D NULL; > + dev->device.driver =3D NULL; > + > + return 0; > +} > + > +/* > + * Call the probe() function of all registered driver for the given devi= ce. > + * Return < 0 if initialization failed. > + * Return 1 if no driver is found for this device. > + */ > +static int > +auxiliary_probe_all_drivers(struct rte_auxiliary_device *dev) { > + struct rte_auxiliary_driver *drv; > + int rc; > + > + if (dev =3D=3D NULL) > + return -EINVAL; > + > + FOREACH_DRIVER_ON_AUXILIARY_BUS(drv) { > + if (!drv->match(dev->name)) > + continue; > + > + rc =3D rte_auxiliary_probe_one_driver(drv, 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 auxiliary bus, and call the probe function > +for > + * all registered drivers to try to probe discovered devices. > + */ > +static int > +auxiliary_probe(void) > +{ > + struct rte_auxiliary_device *dev =3D NULL; > + size_t probed =3D 0, failed =3D 0; > + int ret =3D 0; > + > + FOREACH_DEVICE_ON_AUXILIARY_BUS(dev) { > + probed++; > + > + ret =3D auxiliary_probe_all_drivers(dev); > + if (ret < 0) { > + if (ret !=3D -EEXIST) { > + AUXILIARY_LOG(ERR, "Requested device %s cannot be used", > + dev->name); > + rte_errno =3D errno; > + failed++; > + } > + ret =3D 0; > + } > + } > + > + return (probed && probed =3D=3D failed) ? -1 : 0; } > + > +static int > +auxiliary_parse(const char *name, void *addr) { > + struct rte_auxiliary_driver *drv =3D NULL; > + const char **out =3D addr; > + > + /* Allow empty device name "auxiliary:" to bypass entire bus scan. */ > + if (strlen(name) =3D=3D 0) > + return 0; > + > + FOREACH_DRIVER_ON_AUXILIARY_BUS(drv) { > + if (drv->match(name)) > + break; > + } > + if (drv !=3D NULL && addr !=3D NULL) > + *out =3D name; > + return drv !=3D NULL ? 0 : -1; > +} > + > +/* Register a driver */ > +void > +rte_auxiliary_register(struct rte_auxiliary_driver *driver) { > + TAILQ_INSERT_TAIL(&auxiliary_bus.driver_list, driver, next); > + driver->bus =3D &auxiliary_bus; > +} > + > +/* Unregister a driver */ > +void > +rte_auxiliary_unregister(struct rte_auxiliary_driver *driver) { > + TAILQ_REMOVE(&auxiliary_bus.driver_list, driver, next); > + driver->bus =3D NULL; > +} > + > +/* Add a device to auxiliary bus */ > +void > +auxiliary_add_device(struct rte_auxiliary_device *aux_dev) { > + TAILQ_INSERT_TAIL(&auxiliary_bus.device_list, aux_dev, next); } > + > +/* Insert a device into a predefined position in auxiliary bus */ void > +auxiliary_insert_device(struct rte_auxiliary_device *exist_aux_dev, > + struct rte_auxiliary_device *new_aux_dev) { > + TAILQ_INSERT_BEFORE(exist_aux_dev, new_aux_dev, next); } > + > +/* Remove a device from auxiliary bus */ static void > +rte_auxiliary_remove_device(struct rte_auxiliary_device *auxiliary_dev) > +{ > + TAILQ_REMOVE(&auxiliary_bus.device_list, auxiliary_dev, next); } > + > +static struct rte_device * > +auxiliary_find_device(const struct rte_device *start, rte_dev_cmp_t cmp, > + const void *data) > +{ > + const struct rte_auxiliary_device *pstart; > + struct rte_auxiliary_device *adev; > + > + if (start !=3D NULL) { > + pstart =3D RTE_DEV_TO_AUXILIARY_CONST(start); > + adev =3D TAILQ_NEXT(pstart, next); > + } else { > + adev =3D TAILQ_FIRST(&auxiliary_bus.device_list); > + } > + while (adev !=3D NULL) { > + if (cmp(&adev->device, data) =3D=3D 0) > + return &adev->device; > + adev =3D TAILQ_NEXT(adev, next); > + } > + return NULL; > +} > + > +static int > +auxiliary_plug(struct rte_device *dev) > +{ > + if (!auxiliary_dev_exists(dev->name)) > + return -ENOENT; > + return auxiliary_probe_all_drivers(RTE_DEV_TO_AUXILIARY(dev)); > +} > + > +static int > +auxiliary_unplug(struct rte_device *dev) { > + struct rte_auxiliary_device *adev; > + int ret; > + > + adev =3D RTE_DEV_TO_AUXILIARY(dev); > + ret =3D rte_auxiliary_driver_remove_dev(adev); > + if (ret =3D=3D 0) { > + rte_auxiliary_remove_device(adev); > + rte_devargs_remove(dev->devargs); > + free(adev); > + } > + return ret; > +} > + > +static int > +auxiliary_dma_map(struct rte_device *dev, void *addr, uint64_t iova, > +size_t len) { > + struct rte_auxiliary_device *aux_dev =3D RTE_DEV_TO_AUXILIARY(dev); > + > + if (dev =3D=3D NULL || aux_dev->driver =3D=3D NULL) { > + rte_errno =3D EINVAL; > + return -1; > + } > + if (aux_dev->driver->dma_map =3D=3D NULL) { > + rte_errno =3D ENOTSUP; > + return -1; > + } > + return aux_dev->driver->dma_map(aux_dev, addr, iova, len); } > + > +static int > +auxiliary_dma_unmap(struct rte_device *dev, void *addr, uint64_t iova, > + size_t len) > +{ > + struct rte_auxiliary_device *aux_dev =3D RTE_DEV_TO_AUXILIARY(dev); > + > + if (dev =3D=3D NULL || aux_dev->driver =3D=3D NULL) { > + rte_errno =3D EINVAL; > + return -1; > + } > + if (aux_dev->driver->dma_unmap =3D=3D NULL) { > + rte_errno =3D ENOTSUP; > + return -1; > + } > + return aux_dev->driver->dma_unmap(aux_dev, addr, iova, len); } > + > +bool > +auxiliary_is_ignored_device(const char *name) { > + struct rte_devargs *devargs =3D auxiliary_devargs_lookup(name); > + > + switch (auxiliary_bus.bus.conf.scan_mode) { > + case RTE_BUS_SCAN_ALLOWLIST: > + if (devargs && devargs->policy =3D=3D RTE_DEV_ALLOWED) > + return false; > + break; > + case RTE_BUS_SCAN_UNDEFINED: > + case RTE_BUS_SCAN_BLOCKLIST: > + if (devargs =3D=3D NULL || devargs->policy !=3D RTE_DEV_BLOCKED) > + return false; > + break; > + } > + return true; > +} > + > +static enum rte_iova_mode > +auxiliary_get_iommu_class(void) > +{ > + const struct rte_auxiliary_driver *drv; > + > + FOREACH_DRIVER_ON_AUXILIARY_BUS(drv) { > + if ((drv->drv_flags & RTE_AUXILIARY_DRV_NEED_IOVA_AS_VA) > 0) > + return RTE_IOVA_VA; > + } > + > + return RTE_IOVA_DC; > +} > + > +struct rte_auxiliary_bus auxiliary_bus =3D { > + .bus =3D { > + .scan =3D auxiliary_scan, > + .probe =3D auxiliary_probe, > + .find_device =3D auxiliary_find_device, > + .plug =3D auxiliary_plug, > + .unplug =3D auxiliary_unplug, > + .parse =3D auxiliary_parse, > + .dma_map =3D auxiliary_dma_map, > + .dma_unmap =3D auxiliary_dma_unmap, > + .get_iommu_class =3D auxiliary_get_iommu_class, > + .dev_iterate =3D auxiliary_dev_iterate, > + }, > + .device_list =3D TAILQ_HEAD_INITIALIZER(auxiliary_bus.device_list), > + .driver_list =3D TAILQ_HEAD_INITIALIZER(auxiliary_bus.driver_list), > +}; > + > +RTE_REGISTER_BUS(auxiliary, auxiliary_bus.bus); > +RTE_LOG_REGISTER_DEFAULT(auxiliary_bus_logtype, NOTICE); > diff --git a/drivers/bus/auxiliary/auxiliary_params.c b/drivers/bus/auxil= iary/auxiliary_params.c > new file mode 100644 > index 0000000000..cd3fa56cb4 > --- /dev/null > +++ b/drivers/bus/auxiliary/auxiliary_params.c > @@ -0,0 +1,59 @@ > +/* SPDX-License-Identifier: BSD-3-Clause > + * Copyright (c) 2021 NVIDIA Corporation & Affiliates */ > + > +#include > + > +#include > +#include > +#include > +#include > + > +#include "private.h" > +#include "rte_bus_auxiliary.h" > + > +enum auxiliary_params { > + RTE_AUXILIARY_PARAM_NAME, > +}; > + > +static const char * const auxiliary_params_keys[] =3D { > + [RTE_AUXILIARY_PARAM_NAME] =3D "name", > +}; > + > +static int > +auxiliary_dev_match(const struct rte_device *dev, > + const void *_kvlist) > +{ > + const struct rte_kvargs *kvlist =3D _kvlist; > + int ret; > + > + ret =3D rte_kvargs_process(kvlist, > + auxiliary_params_keys[RTE_AUXILIARY_PARAM_NAME], > + rte_kvargs_strcmp, (void *)(uintptr_t)dev->name); > + > + return ret !=3D 0 ? -1 : 0; > +} > + > +void * > +auxiliary_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 =3D NULL; > + struct rte_device *dev; > + > + if (str !=3D NULL) { > + kvargs =3D rte_kvargs_parse(str, auxiliary_params_keys); > + if (kvargs =3D=3D NULL) { > + AUXILIARY_LOG(ERR, "cannot parse argument list %s", > + str); > + rte_errno =3D EINVAL; > + return NULL; > + } > + } > + find_device =3D auxiliary_bus.bus.find_device; > + dev =3D find_device(start, auxiliary_dev_match, kvargs); > + rte_kvargs_free(kvargs); > + return dev; > +} > diff --git a/drivers/bus/auxiliary/linux/auxiliary.c b/drivers/bus/auxili= ary/linux/auxiliary.c > new file mode 100644 > index 0000000000..8464487971 > --- /dev/null > +++ b/drivers/bus/auxiliary/linux/auxiliary.c > @@ -0,0 +1,141 @@ > +/* SPDX-License-Identifier: BSD-3-Clause > + * Copyright (c) 2021 NVIDIA Corporation & Affiliates */ > + > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "../rte_bus_auxiliary.h" > +#include "../private.h" > + > +#define AUXILIARY_SYSFS_PATH "/sys/bus/auxiliary/devices" > + > +/* Scan one auxiliary sysfs entry, and fill the devices list from it. > +*/ static int auxiliary_scan_one(const char *dirname, const char *name) > +{ > + struct rte_auxiliary_device *dev; > + struct rte_auxiliary_device *dev2; > + char filename[PATH_MAX]; > + unsigned long tmp; > + int ret; > + > + dev =3D malloc(sizeof(*dev)); > + if (dev =3D=3D NULL) > + return -1; > + > + memset(dev, 0, sizeof(*dev)); > + if (rte_strscpy(dev->name, name, sizeof(dev->name)) < 0) { > + free(dev); > + return -1; > + } > + dev->device.name =3D dev->name; > + dev->device.bus =3D &auxiliary_bus.bus; > + > + /* Get NUMA node, default to 0 if not present */ > + snprintf(filename, sizeof(filename), "%s/%s/numa_node", > + dirname, name); > + if (access(filename, F_OK) !=3D -1) { > + if (eal_parse_sysfs_value(filename, &tmp) =3D=3D 0) > + dev->device.numa_node =3D tmp; > + else > + dev->device.numa_node =3D -1; > + } else { > + dev->device.numa_node =3D 0; > + } > + > + auxiliary_on_scan(dev); > + > + /* Device is valid, add in list (sorted) */ > + TAILQ_FOREACH(dev2, &auxiliary_bus.device_list, next) { > + ret =3D strcmp(dev->name, dev2->name); > + if (ret > 0) > + continue; > + if (ret < 0) { > + auxiliary_insert_device(dev2, dev); > + } else { /* already registered */ > + if (rte_dev_is_probed(&dev2->device) && > + dev2->device.devargs !=3D dev->device.devargs) { > + /* To probe device with new devargs. */ > + rte_devargs_remove(dev2->device.devargs); > + auxiliary_on_scan(dev2); > + } > + free(dev); > + } > + return 0; > + } > + auxiliary_add_device(dev); > + return 0; > +} > + > +/* > + * Test whether the auxiliary device exist */ bool > +auxiliary_dev_exists(const char *name) { > + DIR *dir; > + char dirname[PATH_MAX]; > + > + snprintf(dirname, sizeof(dirname), "%s/%s", > + AUXILIARY_SYSFS_PATH, name); > + dir =3D opendir(dirname); > + if (dir =3D=3D NULL) > + return false; > + closedir(dir); > + return true; > +} > + > +/* > + * Scan the devices in the auxiliary bus */ int > +auxiliary_scan(void) > +{ > + struct dirent *e; > + DIR *dir; > + char dirname[PATH_MAX]; > + struct rte_auxiliary_driver *drv; > + > + dir =3D opendir(AUXILIARY_SYSFS_PATH); > + if (dir =3D=3D NULL) { > + AUXILIARY_LOG(INFO, "%s not found, is auxiliary module loaded?", > + AUXILIARY_SYSFS_PATH); > + return 0; > + } > + > + while ((e =3D readdir(dir)) !=3D NULL) { > + if (e->d_name[0] =3D=3D '.') > + continue; > + > + if (auxiliary_is_ignored_device(e->d_name)) > + continue; > + > + snprintf(dirname, sizeof(dirname), "%s/%s", > + AUXILIARY_SYSFS_PATH, e->d_name); > + > + /* Ignore if no driver can handle. */ > + FOREACH_DRIVER_ON_AUXILIARY_BUS(drv) { > + if (drv->match(e->d_name)) > + break; > + } > + if (drv =3D=3D NULL) > + continue; > + > + if (auxiliary_scan_one(dirname, e->d_name) < 0) > + goto error; > + } > + closedir(dir); > + return 0; > + > +error: > + closedir(dir); > + return -1; > +} > diff --git a/drivers/bus/auxiliary/meson.build b/drivers/bus/auxiliary/me= son.build > new file mode 100644 > index 0000000000..357550eff7 > --- /dev/null > +++ b/drivers/bus/auxiliary/meson.build > @@ -0,0 +1,16 @@ > +# SPDX-License-Identifier: BSD-3-Clause # Copyright (c) 2021 NVIDIA > +Corporation & Affiliates > + > +headers =3D files( > + 'rte_bus_auxiliary.h', > +) > +sources =3D files( > + 'auxiliary_common.c', > + 'auxiliary_params.c', > +) > +if is_linux > + sources +=3D files( > + 'linux/auxiliary.c', > + ) > +endif > +deps +=3D ['kvargs'] > diff --git a/drivers/bus/auxiliary/private.h b/drivers/bus/auxiliary/priv= ate.h new file mode 100644 index 0000000000..cb3e849993 > --- /dev/null > +++ b/drivers/bus/auxiliary/private.h > @@ -0,0 +1,74 @@ > +/* SPDX-License-Identifier: BSD-3-Clause > + * Copyright (c) 2021 NVIDIA Corporation & Affiliates */ > + > +#ifndef AUXILIARY_PRIVATE_H > +#define AUXILIARY_PRIVATE_H > + > +#include > +#include > + > +#include "rte_bus_auxiliary.h" > + > +extern struct rte_auxiliary_bus auxiliary_bus; extern int > +auxiliary_bus_logtype; > + > +#define AUXILIARY_LOG(level, ...) \ > + rte_log(RTE_LOG_ ## level, auxiliary_bus_logtype, \ > + RTE_FMT("auxiliary bus: " RTE_FMT_HEAD(__VA_ARGS__,) "\n", \ > + RTE_FMT_TAIL(__VA_ARGS__,))) > + > +/* Auxiliary bus iterators */ > +#define FOREACH_DEVICE_ON_AUXILIARY_BUS(p) \ > + TAILQ_FOREACH(p, &(auxiliary_bus.device_list), next) > + > +#define FOREACH_DRIVER_ON_AUXILIARY_BUS(p) \ > + TAILQ_FOREACH(p, &(auxiliary_bus.driver_list), next) > + > +bool auxiliary_dev_exists(const char *name); > + > +/* > + * Scan the content of the auxiliary bus, and the devices in the > +devices > + * list. > + */ > +int auxiliary_scan(void); > + > +/* > + * Update a device being scanned. > + */ > +void auxiliary_on_scan(struct rte_auxiliary_device *aux_dev); > + > +/* > + * Validate whether a device with given auxiliary device should be > +ignored > + * or not. > + */ > +bool auxiliary_is_ignored_device(const char *name); > + > +/* > + * Add an auxiliary device to the auxiliary bus (append to auxiliary > +device > + * list). This function also updates the bus references of the > +auxiliary > + * device and the generic device object embedded within. > + */ > +void auxiliary_add_device(struct rte_auxiliary_device *aux_dev); > + > +/* > + * Insert an auxiliary device in the auxiliary bus at a particular > +location > + * in the device list. It also updates the auxiliary bus reference of > +the > + * new devices to be inserted. > + */ > +void auxiliary_insert_device(struct rte_auxiliary_device *exist_aux_dev, > + struct rte_auxiliary_device *new_aux_dev); > + > +/* > + * Match the auxiliary driver and device by driver function */ bool > +auxiliary_match(const struct rte_auxiliary_driver *aux_drv, > + const struct rte_auxiliary_device *aux_dev); > + > +/* > + * Iterate over devices, matching any device against the provided > +string */ void *auxiliary_dev_iterate(const void *start, const char > +*str, > + const struct rte_dev_iterator *it); > + > +#endif /* AUXILIARY_PRIVATE_H */ > diff --git a/drivers/bus/auxiliary/rte_bus_auxiliary.h b/drivers/bus/auxi= liary/rte_bus_auxiliary.h > new file mode 100644 > index 0000000000..16b147e387 > --- /dev/null > +++ b/drivers/bus/auxiliary/rte_bus_auxiliary.h > @@ -0,0 +1,201 @@ > +/* SPDX-License-Identifier: BSD-3-Clause > + * Copyright (c) 2021 NVIDIA Corporation & Affiliates */ > + > +#ifndef RTE_BUS_AUXILIARY_H > +#define RTE_BUS_AUXILIARY_H > + > +/** > + * @file > + * > + * Auxiliary Bus Interface. > + */ > + > +#ifdef __cplusplus > +extern "C" { > +#endif > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > + > +#define RTE_BUS_AUXILIARY_NAME "auxiliary" > + > +/* Forward declarations */ > +struct rte_auxiliary_driver; > +struct rte_auxiliary_bus; > +struct rte_auxiliary_device; > + > +/** > + * Match function for the driver to decide if device can be handled. > + * > + * @param name > + * Pointer to the auxiliary device name. > + * @return > + * Whether the driver can handle the auxiliary device. > + */ > +typedef bool(rte_auxiliary_match_t)(const char *name); > + > +/** > + * Initialization function for the driver called during auxiliary probin= g. > + * > + * @param drv > + * Pointer to the auxiliary driver. > + * @param dev > + * Pointer to the auxiliary device. > + * @return > + * - 0 On success. > + * - Negative value and rte_errno is set otherwise. > + */ > +typedef int(rte_auxiliary_probe_t)(struct rte_auxiliary_driver *drv, > + struct rte_auxiliary_device *dev); > + > +/** > + * Uninitialization function for the driver called during hotplugging. > + * > + * @param dev > + * Pointer to the auxiliary device. > + * @return > + * - 0 On success. > + * - Negative value and rte_errno is set otherwise. > + */ > +typedef int (rte_auxiliary_remove_t)(struct rte_auxiliary_device *dev); > + > +/** > + * Driver-specific DMA mapping. After a successful call the device > + * will be able to read/write from/to this segment. > + * > + * @param dev > + * Pointer to the auxiliary device. > + * @param addr > + * Starting virtual address of memory to be mapped. > + * @param iova > + * Starting IOVA address of memory to be mapped. > + * @param len > + * Length of memory segment being mapped. > + * @return > + * - 0 On success. > + * - Negative value and rte_errno is set otherwise. > + */ > +typedef int (rte_auxiliary_dma_map_t)(struct rte_auxiliary_device *dev, > + void *addr, uint64_t iova, size_t len); > + > +/** > + * Driver-specific DMA un-mapping. After a successful call the device > + * will not be able to read/write from/to this segment. > + * > + * @param dev > + * Pointer to the auxiliary device. > + * @param addr > + * Starting virtual address of memory to be unmapped. > + * @param iova > + * Starting IOVA address of memory to be unmapped. > + * @param len > + * Length of memory segment being unmapped. > + * @return > + * - 0 On success. > + * - Negative value and rte_errno is set otherwise. > + */ > +typedef int (rte_auxiliary_dma_unmap_t)(struct rte_auxiliary_device *dev= , > + void *addr, uint64_t iova, size_t len); > + > +/** > + * A structure describing an auxiliary device. > + */ > +struct rte_auxiliary_device { > + TAILQ_ENTRY(rte_auxiliary_device) next; /**< Next probed device. */ > + struct rte_device device; /**< Inherit core device */ > + char name[RTE_DEV_NAME_MAX_LEN + 1]; /**< ASCII device name */ > + struct rte_intr_handle intr_handle; /**< Interrupt handle */ > + struct rte_auxiliary_driver *driver; /**< Device driver */ > +}; > + > +/** List of auxiliary devices */ > +TAILQ_HEAD(rte_auxiliary_device_list, rte_auxiliary_device); > +/** List of auxiliary drivers */ > +TAILQ_HEAD(rte_auxiliary_driver_list, rte_auxiliary_driver); > + > +/** > + * Structure describing the auxiliary bus */ struct rte_auxiliary_bus > +{ > + struct rte_bus bus; /**< Inherit the generic class */ > + struct rte_auxiliary_device_list device_list; /**< List of devices */ > + struct rte_auxiliary_driver_list driver_list; /**< List of drivers */ > +}; > + > +/** > + * A structure describing an auxiliary driver. > + */ > +struct rte_auxiliary_driver { > + TAILQ_ENTRY(rte_auxiliary_driver) next; /**< Next in list. */ > + struct rte_driver driver; /**< Inherit core driver. */ > + struct rte_auxiliary_bus *bus; /**< Auxiliary bus reference. */ > + rte_auxiliary_match_t *match; /**< Device match function. */ > + rte_auxiliary_probe_t *probe; /**< Device probe function. */ > + rte_auxiliary_remove_t *remove; /**< Device remove function. */ > + rte_auxiliary_dma_map_t *dma_map; /**< Device DMA map function. */ > + rte_auxiliary_dma_unmap_t *dma_unmap; /**< Device DMA unmap function. *= / > + uint32_t drv_flags; /**< Flags RTE_AUXILIARY_DRV_*. *= / > +}; > + > +/** > + * @internal > + * Helper macro for drivers that need to convert to struct rte_auxiliary= _device. > + */ > +#define RTE_DEV_TO_AUXILIARY(ptr) \ > + container_of(ptr, struct rte_auxiliary_device, device) > + > +#define RTE_DEV_TO_AUXILIARY_CONST(ptr) \ > + container_of(ptr, const struct rte_auxiliary_device, device) > + > +#define RTE_ETH_DEV_TO_AUXILIARY(eth_dev) \ > + RTE_DEV_TO_AUXILIARY((eth_dev)->device) > + > +/** Device driver needs IOVA as VA and cannot work with IOVA as PA */ > +#define RTE_AUXILIARY_DRV_NEED_IOVA_AS_VA 0x002 > + > +/** > + * Register an auxiliary driver. > + * > + * @param driver > + * A pointer to a rte_auxiliary_driver structure describing the driver > + * to be registered. > + */ > +__rte_experimental > +void rte_auxiliary_register(struct rte_auxiliary_driver *driver); > + > +/** Helper for auxiliary device registration from driver instance */ > +#define RTE_PMD_REGISTER_AUXILIARY(nm, auxiliary_drv) \ > + RTE_INIT(auxiliaryinitfn_ ##nm) \ > + { \ > + (auxiliary_drv).driver.name =3D RTE_STR(nm); \ > + rte_auxiliary_register(&(auxiliary_drv)); \ > + } \ > + RTE_PMD_EXPORT_NAME(nm, __COUNTER__) > + > +/** > + * Unregister an auxiliary driver. > + * > + * @param driver > + * A pointer to a rte_auxiliary_driver structure describing the driver > + * to be unregistered. > + */ > +__rte_experimental > +void rte_auxiliary_unregister(struct rte_auxiliary_driver *driver); > + > +#ifdef __cplusplus > +} > +#endif > + > +#endif /* RTE_BUS_AUXILIARY_H */ > diff --git a/drivers/bus/auxiliary/version.map b/drivers/bus/auxiliary/ve= rsion.map > new file mode 100644 > index 0000000000..a52260657c > --- /dev/null > +++ b/drivers/bus/auxiliary/version.map > @@ -0,0 +1,7 @@ > +EXPERIMENTAL { > + global: > + > + # added in 21.08 > + rte_auxiliary_register; > + rte_auxiliary_unregister; > +}; > diff --git a/drivers/bus/meson.build b/drivers/bus/meson.build index 4100= 58de3a..45eab5233d 100644 > --- a/drivers/bus/meson.build > +++ b/drivers/bus/meson.build > @@ -2,6 +2,7 @@ > # Copyright(c) 2017 Intel Corporation >=20 > drivers =3D [ > + 'auxiliary', > 'dpaa', > 'fslmc', > 'ifpga', > -- > 2.25.1