Skip to contentSkip to conversation

pds_core driver

PATCH Superseded Shannon Nelson 4 participants 26 messages Mar 24, 2023 – Mar 30, 2023

Subsystems (4)

v6 of 11 Superseded Latest is v11 →

lore
Share & tools
lore
#0 lore raw

v6 cover pds_core driver

Summary:
--------
This patchset implements a new driver for use with the AMD/Pensando Distributed Services Card (DSC), intended to provide core configuration services through the auxiliary_bus and through a couple of EXPORTed functions for use initially in VFio and vDPA feature specific drivers.

To keep this patchset to a manageable size, the pds_vdpa and pds_vfio drivers have been split out into their own patchsets to be reviewed separately.

Detail:
-------
AMD/Pensando is making available a new set of devices for supporting vDPA, VFio, and potentially other features in the Distributed Services Card (DSC). These features are implemented through a PF that serves as a Core device for controlling and configuring its VF devices. These VF devices have separate drivers that use the auxiliary_bus to work through the Core device as the control path.

Currently, the DSC supports standard ethernet operations using the ionic driver. This is not replaced by the Core-based devices - these new devices are in addition to the existing Ethernet device. Typical DSC configurations will include both PDS devices and Ionic Eth devices. However, there is a potential future path for ethernet services to come through this device as well.

The Core device is a new PCI PF/VF device managed by a new driver 'pds_core'. The PF device has access to an admin queue for configuring the services used by the VFs, and sets up auxiliary_bus devices for each vDPA VF for communicating with the drivers for the vDPA devices. The VFs may be for VFio or vDPA, and other services in the future; these VF types are selected as part of the DSC internal FW configurations, which is out of the scope of this patchset.

When the vDPA support set is enabled in the core PF through its devlink param, auxiliary_bus devices are created for each VF that supports the feature. The vDPA driver then connects to and uses this auxiliary_device to do control path configuration through the PF device. This can then be used with the vdpa kernel module to provide devices for virtio_vdpa kernel module for host interfaces, or vhost_vdpa kernel module for interfaces exported into your favorite VM.

A cheap ASCII diagram of a vDPA instance looks something like this:

                                ,----------.
                                |   vdpa   |
                                '----------'
                                  |     ||
                                 ctl   data
                                  |     ||
                          .----------.  ||
                          | pds_vdpa |  ||
                          '----------'  ||
                               |        ||
                       pds_core.vDPA.1  ||
                               |        ||
                    .---------------.   ||
                    |   pds_core    |   ||
                    '---------------'   ||
                        ||         ||   ||
                      09:00.0      09:00.1  
        == PCI ============================================
                        ||            ||
                   .----------.   .----------.
            ,------|    PF    |---|    VF    |-------,
            |      '----------'   '----------'       |
            |                  DSC                   |
            |                                        |
            ------------------------------------------

Changes:
v6:
- removed version.h include noticed by kernel test robot's version check

    Link: https://lore.kernel.org/oe-kbuild-all/[email protected]/

- fixed up the more egregious checkpatch line length complaints
- make sure pdsc_auxbus_dev_register() checks padev pointer errcode

v5:

- added devlink health reporter for FW issues
- removed asic_type, asic_rev, serial_num, fw_version from debugfs as they are available through other means
- trimed OS info in pdsc_identify(), we don't need to send that much info to the FW
- removed reg/unreg from auxbus client API, they are now in the core when VF is started
- removed need for pdsc definition in client by simplifying the padev to only carry struct pci_dev pointers rather than full struct pdsc to the pf and vf
- removed the unused pdsc argument in pdsc_notify()
- moved include/linux/pds/pds_core.h to driver/../pds_core/core.h
- restored a few pds_core_if.h interface values and structs that are shared with FW source
- moved final config_lock unlock to before tear down of timer and workqueue to be sure there are no deadlocks while waiting for any stragglers
- changed use of PAGE_SIZE to local PDS_PAGE_SIZE to keep with FW layout needs without regard to kernel PAGE_SIZE configuration
- removed the redundant *adminqcq argument from pdsc_adminq_post()

v4:

- reworked to attach to both Core PF and vDPA VF PCI devices
- now creates auxiliary_device as part of each VF PCI probe, removes them on PCI remove
- auxiliary devices now use simple unique id rather than PCI address for identifier
- replaced home-grown event publishing with kernel-based notifier service
- dropped live_migration parameter, not needed when not creating aux device for it
- replaced devm_* functions with traditional interfaces
- added MAINTAINERS entry
- removed lingering traces of set/get_vf attribute adminq commands
- trimmed some include lists
- cleaned a kernel test robot complaint about a stray unused variable

        Link: https://lore.kernel.org/oe-kbuild-all/[email protected]/

v3:

- changed names from "pensando" to "amd" and updated copyright strings
- dropped the DEVLINK_PARAM_GENERIC_ID_FW_BANK for future development
- changed the auxiliary device creation to be triggered by the PCI bus event BOUND_DRIVER, and torn down at UNBIND_DRIVER in order to properly handle users using the sysfs bind/unbind functions
- dropped some noisy log messages
- rebased to current net-next

RFC to v2:

- added separate devlink param patches for DEVLINK_PARAM_GENERIC_ID_ENABLE_MIGRATION and DEVLINK_PARAM_GENERIC_ID_FW_BANK, and dropped the driver specific implementations
- updated descriptions for the new devlink parameters
- dropped netdev support
- dropped vDPA patches, will followup later
- separated fw update and fw bank select into their own patches

RFC:

Shannon Nelson (14):
pds_core: initial framework for pds_core PF driver
pds_core: add devcmd device interfaces
pds_core: health timer and workqueue
pds_core: add devlink health facilities
pds_core: set up device and adminq
pds_core: Add adminq processing and commands
pds_core: add FW update feature to devlink
pds_core: set up the VIF definitions and defaults
pds_core: add initial VF device handling
pds_core: add auxiliary_bus devices
pds_core: devlink params for enabling VIF support
pds_core: add the aux client API
pds_core: publish events to the clients
pds_core: Kconfig and pds_core.rst

 .../device_drivers/ethernet/amd/pds_core.rst  | 143 ++++
 .../device_drivers/ethernet/index.rst         |   1 +
 MAINTAINERS                                   |   9 +
 drivers/net/ethernet/amd/Kconfig              |  12 +
 drivers/net/ethernet/amd/Makefile             |   1 +
 drivers/net/ethernet/amd/pds_core/Makefile    |  14 +
 drivers/net/ethernet/amd/pds_core/adminq.c    | 291 ++++++++
 drivers/net/ethernet/amd/pds_core/auxbus.c    | 271 ++++++++
 drivers/net/ethernet/amd/pds_core/core.c      | 608 +++++++++++++++++
 drivers/net/ethernet/amd/pds_core/core.h      | 317 +++++++++
 drivers/net/ethernet/amd/pds_core/debugfs.c   | 246 +++++++
 drivers/net/ethernet/amd/pds_core/dev.c       | 352 ++++++++++
 drivers/net/ethernet/amd/pds_core/devlink.c   | 268 ++++++++
 drivers/net/ethernet/amd/pds_core/fw.c        | 194 ++++++
 drivers/net/ethernet/amd/pds_core/main.c      | 450 ++++++++++++
 include/linux/pds/pds_adminq.h                | 645 ++++++++++++++++++
 include/linux/pds/pds_auxbus.h                |  44 ++
 include/linux/pds/pds_common.h                |  97 +++
 include/linux/pds/pds_core_if.h               | 540 +++++++++++++++
 include/linux/pds/pds_intr.h                  | 163 +++++
 20 files changed, 4666 insertions(+)
 create mode 100644 Documentation/networking/device_drivers/ethernet/amd/pds_core.rst
 create mode 100644 drivers/net/ethernet/amd/pds_core/Makefile
 create mode 100644 drivers/net/ethernet/amd/pds_core/adminq.c
 create mode 100644 drivers/net/ethernet/amd/pds_core/auxbus.c
 create mode 100644 drivers/net/ethernet/amd/pds_core/core.c
 create mode 100644 drivers/net/ethernet/amd/pds_core/core.h
 create mode 100644 drivers/net/ethernet/amd/pds_core/debugfs.c
 create mode 100644 drivers/net/ethernet/amd/pds_core/dev.c
 create mode 100644 drivers/net/ethernet/amd/pds_core/devlink.c
 create mode 100644 drivers/net/ethernet/amd/pds_core/fw.c
 create mode 100644 drivers/net/ethernet/amd/pds_core/main.c
 create mode 100644 include/linux/pds/pds_adminq.h
 create mode 100644 include/linux/pds/pds_auxbus.h
 create mode 100644 include/linux/pds/pds_common.h
 create mode 100644 include/linux/pds/pds_core_if.h
 create mode 100644 include/linux/pds/pds_intr.h
Signature · 1 line
2.17.1
#1 lore raw

PATCH v6 1/14 pds_core: initial framework for pds_core PF driver

This is the initial PCI driver framework for the new pds_core device driver and its family of devices. This does the very basics of registering for the new PF PCI device 1dd8:100c, setting up debugfs entries, and registering with devlink.

---
 drivers/net/ethernet/amd/pds_core/Makefile  |   9 +
 drivers/net/ethernet/amd/pds_core/core.h    |  68 +++
 drivers/net/ethernet/amd/pds_core/debugfs.c |  47 ++
 drivers/net/ethernet/amd/pds_core/devlink.c |  51 ++
 drivers/net/ethernet/amd/pds_core/main.c    | 278 ++++++++++
 include/linux/pds/pds_common.h              |  14 +
 include/linux/pds/pds_core_if.h             | 540 ++++++++++++++++++++
 7 files changed, 1007 insertions(+)
 create mode 100644 drivers/net/ethernet/amd/pds_core/Makefile
 create mode 100644 drivers/net/ethernet/amd/pds_core/core.h
 create mode 100644 drivers/net/ethernet/amd/pds_core/debugfs.c
 create mode 100644 drivers/net/ethernet/amd/pds_core/devlink.c
 create mode 100644 drivers/net/ethernet/amd/pds_core/main.c
 create mode 100644 include/linux/pds/pds_common.h
 create mode 100644 include/linux/pds/pds_core_if.h
drivers/net/ethernet/amd/pds_core/Makefile new file +9 -0
new file mode 100644
index 000000000000..b4cc4b242e44
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2023 Advanced Micro Devices, Inc.
+
+obj-$(CONFIG_PDS_CORE) := pds_core.o
+
+pds_core-y := main.o \
+	      devlink.o
+
+pds_core-$(CONFIG_DEBUG_FS) += debugfs.o
drivers/net/ethernet/amd/pds_core/core.h new file +68 -0

68 lines not on this page · raw message

drivers/net/ethernet/amd/pds_core/debugfs.c new file +47 -0

47 lines not on this page · raw message

drivers/net/ethernet/amd/pds_core/devlink.c new file +51 -0

51 lines not on this page · raw message

drivers/net/ethernet/amd/pds_core/main.c new file +278 -0

278 lines not on this page · raw message

include/linux/pds/pds_common.h new file +14 -0
new file mode 100644
index 000000000000..bd041a5170a6
@@ -0,0 +1,14 @@
+/* SPDX-License-Identifier: (GPL-2.0 OR Linux-OpenIB) OR BSD-2-Clause */
+/* Copyright(c) 2023 Advanced Micro Devices, Inc. */
+
+#ifndef _PDS_COMMON_H_
+#define _PDS_COMMON_H_
+
+#define PDS_CORE_DRV_NAME			"pds_core"
+
+/* the device's internal addressing uses up to 52 bits */
+#define PDS_CORE_ADDR_LEN	52
+#define PDS_CORE_ADDR_MASK	(BIT_ULL(PDS_ADDR_LEN) - 1)
+#define PDS_PAGE_SIZE		4096
+
+#endif /* _PDS_COMMON_H_ */
include/linux/pds/pds_core_if.h new file +540 -0

540 lines not on this page · raw message

Signature · 1 line
2.17.1
maintainer
#2 lore raw

Re: [PATCH v6 net-next 01/14] pds_core: initial framework for pds_core PF driver

drivers/net/ethernet/amd/pds_core/debugfs.c line 39

Quoted 7 lines · On Fri, 24 Mar 2023 12:02:30 -0700 Shannon Nelson wrote:

This is the initial PCI driver framework for the new pds_core device driver and its family of devices. This does the very basics of registering for the new PF PCI device 1dd8:100c, setting up debugfs entries, and registering with devlink.

drivers/net/ethernet/amd/pds_core/debugfs.c new file +2 -0
+	debugfs_create_file("state", 0400, pdsc->dentry,
+			    pdsc, &core_state_fops);

debugfs_create_ulong() ?

Quoted 46 lines
drivers/net/ethernet/amd/pds_core/devlink.c new file +40 -0
new file mode 100644
index 000000000000..a9021bfe680a
@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright(c) 2023 Advanced Micro Devices, Inc */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/pci.h>
+
+#include "core.h"
+
+static const struct devlink_ops pdsc_dl_ops = {
+};
+
+static const struct devlink_ops pdsc_dl_vf_ops = {
+};
+
+struct pdsc *pdsc_dl_alloc(struct device *dev, bool is_pf)
+{
+	const struct devlink_ops *ops;
+	struct devlink *dl;
+
+	ops = is_pf ? &pdsc_dl_ops : &pdsc_dl_vf_ops;
+	dl = devlink_alloc(ops, sizeof(struct pdsc), dev);
+	if (!dl)
+		return NULL;
+
+	return devlink_priv(dl);
+}
+
+void pdsc_dl_free(struct pdsc *pdsc)
+{
+	struct devlink *dl = priv_to_devlink(pdsc);
+
+	devlink_free(dl);
+}
+
+int pdsc_dl_register(struct pdsc *pdsc)
+{
+	struct devlink *dl = priv_to_devlink(pdsc);
+

drivers/net/ethernet/amd/pds_core/devlink.c line 50

Quoted 10 lines
drivers/net/ethernet/amd/pds_core/devlink.c new file +10 -0
+	devlink_register(dl);
+
+	return 0;
+}
+
+void pdsc_dl_unregister(struct pdsc *pdsc)
+{
+	struct devlink *dl = priv_to_devlink(pdsc);
+
+	devlink_unregister(dl);

Don't put core devlink functionality in a separate file. You're not wrapping all pci_* calls in your own wrappers, why are you wrapping delvink? And use explicit locking, please. devl_* APIs.

#3 lore raw

Re: [PATCH v6 net-next 01/14] pds_core: initial framework for pds_core PF driver

Quoted 10 lines · Jakub Kicinski

drivers/net/ethernet/amd/pds_core/debugfs.c line 39

Quoted 7 lines · On Fri, 24 Mar 2023 12:02:30 -0700 Shannon Nelson wrote:

This is the initial PCI driver framework for the new pds_core device driver and its family of devices. This does the very basics of registering for the new PF PCI device 1dd8:100c, setting up debugfs entries, and registering with devlink.

drivers/net/ethernet/amd/pds_core/debugfs.c new file +2 -0
+     debugfs_create_file("state", 0400, pdsc->dentry,
+                         pdsc, &core_state_fops);

debugfs_create_ulong() ?

Sure, that seems reasonable. I'll double check that I don't have others that need the same treatment.

Quoted 53 lines
Quoted 53 lines
drivers/net/ethernet/amd/pds_core/devlink.c new file +46 -0
new file mode 100644
index 000000000000..a9021bfe680a
@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright(c) 2023 Advanced Micro Devices, Inc */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/pci.h>
+
+#include "core.h"
+
+static const struct devlink_ops pdsc_dl_ops = {
+};
+
+static const struct devlink_ops pdsc_dl_vf_ops = {
+};
+
+struct pdsc *pdsc_dl_alloc(struct device *dev, bool is_pf)
+{
+     const struct devlink_ops *ops;
+     struct devlink *dl;
+
+     ops = is_pf ? &pdsc_dl_ops : &pdsc_dl_vf_ops;
+     dl = devlink_alloc(ops, sizeof(struct pdsc), dev);
+     if (!dl)
+             return NULL;
+
+     return devlink_priv(dl);
+}
+
+void pdsc_dl_free(struct pdsc *pdsc)
+{
+     struct devlink *dl = priv_to_devlink(pdsc);
+
+     devlink_free(dl);
+}
+
+int pdsc_dl_register(struct pdsc *pdsc)
+{
+     struct devlink *dl = priv_to_devlink(pdsc);
+
+     devlink_register(dl);
+
+     return 0;
+}
+
+void pdsc_dl_unregister(struct pdsc *pdsc)
Quoted 8 lines

drivers/net/ethernet/amd/pds_core/devlink.c line 50

Quoted 4 lines
drivers/net/ethernet/amd/pds_core/devlink.c new file +4 -0
+{
+     struct devlink *dl = priv_to_devlink(pdsc);
+
+     devlink_unregister(dl);

Don't put core devlink functionality in a separate file. You're not wrapping all pci_* calls in your own wrappers, why are you wrapping delvink? And use explicit locking, please. devl_* APIs.

Wrapping the devlink_register gives me the ability to abstract out the bit of additional logic that gets added in a later patch, and now the locking logic you mention, and is much like how other relatively current drivers have done it, such as in ionic, ice, and mlx5.

Sure, I can set up the dev_lock() and use the newer devl_* APIs.

sln

maintainer
#4 lore raw

Re: [PATCH v6 net-next 01/14] pds_core: initial framework for pds_core PF driver

Quoted 8 lines · On Sat, 25 Mar 2023 21:07:22 -0700 Shannon Nelson wrote:
Quoted 3 lines

Don't put core devlink functionality in a separate file. You're not wrapping all pci_* calls in your own wrappers, why are you wrapping delvink? And use explicit locking, please. devl_* APIs.

Wrapping the devlink_register gives me the ability to abstract out the bit of additional logic that gets added in a later patch, and now the locking logic you mention, and is much like how other relatively current drivers have done it, such as in ionic, ice, and mlx5.

What are you "abstracting away", exactly? Which "later patch"? I'm not going to read the 5k LoC submission to figure out what you're trying to say :(

#5 lore raw

Re: [PATCH v6 net-next 01/14] pds_core: initial framework for pds_core PF driver

Quoted 6 lines · Jakub Kicinski
Quoted 4 lines · On Sat, 25 Mar 2023 21:07:22 -0700 Shannon Nelson wrote:
Quoted 3 lines

Don't put core devlink functionality in a separate file. You're not wrapping all pci_* calls in your own wrappers, why are you wrapping delvink? And use explicit locking, please. devl_* APIs.

Quoted 8 lines
Quoted 4 lines

Wrapping the devlink_register gives me the ability to abstract out the bit of additional logic that gets added in a later patch, and now the locking logic you mention, and is much like how other relatively current drivers have done it, such as in ionic, ice, and mlx5.

What are you "abstracting away", exactly? Which "later patch"? I'm not going to read the 5k LoC submission to figure out what you're trying to say :(

I'm saying that more code is added in later patches around the devlink_register() for the health (patch 4) and parameters (patch 11). This allows me to have a simple line in the main probe logic that does the devlink-register related things, and then have the details collected together off to the side.

Obviously, when I update the code for using the devl_* interfaces and explicit locking, those two patches will change a little.

sln

maintainer
#6 lore raw

Re: [PATCH v6 net-next 01/14] pds_core: initial framework for pds_core PF driver

Quoted 9 lines · On Mon, 27 Mar 2023 23:19:28 -0700 Shannon Nelson wrote:
Quoted 3 lines

What are you "abstracting away", exactly? Which "later patch"? I'm not going to read the 5k LoC submission to figure out what you're trying to say :(

I'm saying that more code is added in later patches around the devlink_register() for the health (patch 4) and parameters (patch 11). This allows me to have a simple line in the main probe logic that does the devlink-register related things, and then have the details collected together off to the side.

It's not supposed to be off to the side, that's my point. It's a central interface for device control.

Quoted 2 lines

Obviously, when I update the code for using the devl_* interfaces and explicit locking, those two patches will change a little.

#7 lore raw

Re: [PATCH v6 net-next 01/14] pds_core: initial framework for pds_core PF driver

Quoted 5 lines · Jakub Kicinski
Quoted 4 lines · On Mon, 27 Mar 2023 23:19:28 -0700 Shannon Nelson wrote:
Quoted 3 lines

What are you "abstracting away", exactly? Which "later patch"? I'm not going to read the 5k LoC submission to figure out what you're trying to say :(

Quoted 11 lines
Quoted 5 lines

I'm saying that more code is added in later patches around the devlink_register() for the health (patch 4) and parameters (patch 11). This allows me to have a simple line in the main probe logic that does the devlink-register related things, and then have the details collected together off to the side.

It's not supposed to be off to the side, that's my point. It's a central interface for device control.

Quoted 2 lines

Obviously, when I update the code for using the devl_* interfaces and explicit locking, those two patches will change a little.

The devlink alloc and registration are obviously a part of the probe and thus device control setup, so I’m not sure why this is an issue.

As is suggested in coding style, the smaller functions make for easier reading, and keeps the related locking in a nice little package. Having the devlink registration code gathered in one place in the devlink.c file seems to follow most conventions, which then allows the helper functions to be static to that file. This seems to be what about half the drivers that use devlink have chosen to do.

Sure, I could move that function into main.c and make the helper functions more public if that is what you’re looking for. This seems to be the choice for a few of the other drivers.

Or are you looking to have all of the devlink.c code get rolled into main.c?

sln

maintainer
#8 lore raw

Re: [PATCH v6 net-next 01/14] pds_core: initial framework for pds_core PF driver

Quoted 9 lines · On Wed, 29 Mar 2023 13:53:23 -0700 Shannon Nelson wrote:

The devlink alloc and registration are obviously a part of the probe and thus device control setup, so I’m not sure why this is an issue.

As is suggested in coding style, the smaller functions make for easier reading, and keeps the related locking in a nice little package. Having the devlink registration code gathered in one place in the devlink.c file seems to follow most conventions, which then allows the helper functions to be static to that file. This seems to be what about half the drivers that use devlink have chosen to do.

It is precisely the painful experience of dealing with those drivers when refactoring devlink code which makes me ask you to do it right.

Quoted 5 lines

Sure, I could move that function into main.c and make the helper functions more public if that is what you’re looking for. This seems to be the choice for a few of the other drivers.

Or are you looking to have all of the devlink.c code get rolled into main.c?

Not all of the code, but don't wrap parts of probe/remove into out-of-sight helpers. It will lead to other devlink code collecting in the same functions regardless of whether it's the right stage of initialization. Having devlink.c as an entry point for the ops is perfectly fine, OTOH.

#9 lore raw

Re: [PATCH v6 net-next 01/14] pds_core: initial framework for pds_core PF driver

Quoted 11 lines · Jakub Kicinski
Quoted 9 lines · On Wed, 29 Mar 2023 13:53:23 -0700 Shannon Nelson wrote:

The devlink alloc and registration are obviously a part of the probe and thus device control setup, so I’m not sure why this is an issue.

As is suggested in coding style, the smaller functions make for easier reading, and keeps the related locking in a nice little package. Having the devlink registration code gathered in one place in the devlink.c file seems to follow most conventions, which then allows the helper functions to be static to that file. This seems to be what about half the drivers that use devlink have chosen to do.

Quoted 2 lines

It is precisely the painful experience of dealing with those drivers when refactoring devlink code which makes me ask you to do it right.

It will be great if such pushback would be expressed for all types of obfuscations and not devlink only.

Thanks

#10 lore raw

Re: [PATCH v6 net-next 01/14] pds_core: initial framework for pds_core PF driver

In reply to Jakub Kicinski
Quoted 11 lines · Jakub Kicinski
Quoted 9 lines · On Wed, 29 Mar 2023 13:53:23 -0700 Shannon Nelson wrote:

The devlink alloc and registration are obviously a part of the probe and thus device control setup, so I’m not sure why this is an issue.

As is suggested in coding style, the smaller functions make for easier reading, and keeps the related locking in a nice little package. Having the devlink registration code gathered in one place in the devlink.c file seems to follow most conventions, which then allows the helper functions to be static to that file. This seems to be what about half the drivers that use devlink have chosen to do.

Quoted 2 lines

It is precisely the painful experience of dealing with those drivers when refactoring devlink code which makes me ask you to do it right.

Is there a useful place where such guidance can be put to help future folks from falling into the same traps?

Quoted 5 lines
Quoted 5 lines

Sure, I could move that function into main.c and make the helper functions more public if that is what you’re looking for. This seems to be the choice for a few of the other drivers.

Quoted 7 lines
Quoted 1 line

Or are you looking to have all of the devlink.c code get rolled into main.c?

Not all of the code, but don't wrap parts of probe/remove into out-of-sight helpers. It will lead to other devlink code collecting in the same functions regardless of whether it's the right stage of initialization. Having devlink.c as an entry point for the ops is perfectly fine, OTOH.

I started playing with this earlier today to see what it would look like with some reorganization. Because the amount of code in devlink.c by the end of the patchset is not too huge, it doesn't hurt main.c much to include most of the code there. The devlink.c file might just evaporate all together.

I'll try to have the patchset reposted by this weekend in time for your Monday morning entertainment. :-)

sln

maintainer
#11 lore raw

Re: [PATCH v6 net-next 01/14] pds_core: initial framework for pds_core PF driver

Quoted 12 lines · On Thu, 30 Mar 2023 00:43:56 -0700 Shannon Nelson wrote:
Quoted 11 lines · Jakub Kicinski
Quoted 9 lines · On Wed, 29 Mar 2023 13:53:23 -0700 Shannon Nelson wrote:

The devlink alloc and registration are obviously a part of the probe and thus device control setup, so I’m not sure why this is an issue.

As is suggested in coding style, the smaller functions make for easier reading, and keeps the related locking in a nice little package. Having the devlink registration code gathered in one place in the devlink.c file seems to follow most conventions, which then allows the helper functions to be static to that file. This seems to be what about half the drivers that use devlink have chosen to do.

Quoted 5 lines
Quoted 2 lines

It is precisely the painful experience of dealing with those drivers when refactoring devlink code which makes me ask you to do it right.

Is there a useful place where such guidance can be put to help future folks from falling into the same traps?

Putting it mildly we have a reasonable expectation that any large company will have at least one person reading the mailing list :( Who's going to write the documentation you're asking about? This is an open source project, let's be realistic..

#12 lore raw

PATCH v6 2/14 pds_core: add devcmd device interfaces

In reply to Shannon Nelson

The devcmd interface is the basic connection to the device through the PCI BAR for low level identification and command services. This does the early device initialization and finds the identity data, and adds devcmd routines to be used by later driver bits.

---
 drivers/net/ethernet/amd/pds_core/Makefile  |   4 +-
 drivers/net/ethernet/amd/pds_core/core.c    |  36 ++
 drivers/net/ethernet/amd/pds_core/core.h    |  52 +++
 drivers/net/ethernet/amd/pds_core/debugfs.c |  68 ++++
 drivers/net/ethernet/amd/pds_core/dev.c     | 349 ++++++++++++++++++++
 drivers/net/ethernet/amd/pds_core/main.c    |  35 +-
 include/linux/pds/pds_common.h              |  61 ++++
 include/linux/pds/pds_intr.h                | 163 +++++++++
 8 files changed, 764 insertions(+), 4 deletions(-)
 create mode 100644 drivers/net/ethernet/amd/pds_core/core.c
 create mode 100644 drivers/net/ethernet/amd/pds_core/dev.c
 create mode 100644 include/linux/pds/pds_intr.h
drivers/net/ethernet/amd/pds_core/Makefile +3 -1
index b4cc4b242e44..eaca8557ba66 100644
@@ -4,6 +4,8 @@
 obj-$(CONFIG_PDS_CORE) := pds_core.o
 
 pds_core-y := main.o \
-	      devlink.o
+	      devlink.o \
+	      dev.o \
+	      core.o
 
 pds_core-$(CONFIG_DEBUG_FS) += debugfs.o
drivers/net/ethernet/amd/pds_core/core.c new file +36 -0
new file mode 100644
index 000000000000..80d2ecb045df
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright(c) 2023 Advanced Micro Devices, Inc */
+
+#include "core.h"
+
+int pdsc_setup(struct pdsc *pdsc, bool init)
+{
+	int err = 0;
+
+	if (init)
+		err = pdsc_dev_init(pdsc);
+	else
+		err = pdsc_dev_reinit(pdsc);
+	if (err)
+		return err;
+
+	clear_bit(PDSC_S_FW_DEAD, &pdsc->state);
+	return 0;
+}
+
+void pdsc_teardown(struct pdsc *pdsc, bool removing)
+{
+	pdsc_devcmd_reset(pdsc);
+
+	if (removing) {
+		kfree(pdsc->intr_info);
+		pdsc->intr_info = NULL;
+	}
+
+	if (pdsc->kern_dbpage) {
+		iounmap(pdsc->kern_dbpage);
+		pdsc->kern_dbpage = NULL;
+	}
+
+	set_bit(PDSC_S_FW_DEAD, &pdsc->state);
+}
drivers/net/ethernet/amd/pds_core/core.h +52 -0

84 lines not on this page · raw message

drivers/net/ethernet/amd/pds_core/debugfs.c +68 -0

72 lines not on this page · raw message

drivers/net/ethernet/amd/pds_core/dev.c new file +349 -0

349 lines not on this page · raw message

drivers/net/ethernet/amd/pds_core/main.c +32 -3
index ac5a0525df63..a8630cec7b59 100644
@@ -154,13 +154,31 @@ static int pdsc_init_pf(struct pdsc *pdsc)
 	if (err)
 		goto err_out_release_regions;
 
-	err = pdsc_dl_register(pdsc);
+	mutex_init(&pdsc->devcmd_lock);
+	mutex_init(&pdsc->config_lock);
+
+	mutex_lock(&pdsc->config_lock);
+	set_bit(PDSC_S_FW_DEAD, &pdsc->state);
+
+	err = pdsc_setup(pdsc, PDSC_SETUP_INIT);
 	if (err)
 		goto err_out_unmap_bars;
 
+	err = pdsc_dl_register(pdsc);
+	if (err)
+		goto err_out_teardown;
+
+	mutex_unlock(&pdsc->config_lock);
+
 	return 0;
 
+err_out_teardown:
+	pdsc_teardown(pdsc, PDSC_TEARDOWN_REMOVING);
 err_out_unmap_bars:
+	mutex_unlock(&pdsc->config_lock);
+	mutex_destroy(&pdsc->config_lock);
+	mutex_destroy(&pdsc->devcmd_lock);
+	pci_free_irq_vectors(pdsc->pdev);
 	pdsc_unmap_bars(pdsc);
 err_out_release_regions:
 	pci_release_regions(pdsc->pdev);
@@ -244,8 +262,19 @@ static void pdsc_remove(struct pci_dev *pdev)
 	 */
 	pdsc_dl_unregister(pdsc);
 
-	pdsc_unmap_bars(pdsc);
-	pci_release_regions(pdev);
+	if (!pdev->is_virtfn) {
+		mutex_lock(&pdsc->config_lock);
+		set_bit(PDSC_S_STOPPING_DRIVER, &pdsc->state);
+
+		pdsc_teardown(pdsc, PDSC_TEARDOWN_REMOVING);
+		mutex_unlock(&pdsc->config_lock);
+		mutex_destroy(&pdsc->config_lock);
+		mutex_destroy(&pdsc->devcmd_lock);
+
+		pci_free_irq_vectors(pdev);
+		pdsc_unmap_bars(pdsc);
+		pci_release_regions(pdev);
+	}
 
 	pci_clear_master(pdev);
 	pci_disable_device(pdev);
include/linux/pds/pds_common.h +61 -0

65 lines not on this page · raw message

include/linux/pds/pds_intr.h new file +163 -0

163 lines not on this page · raw message

Signature · 1 line
2.17.1
#13 lore raw

PATCH v6 3/14 pds_core: health timer and workqueue

In reply to Shannon Nelson

Add in the periodic health check and the related workqueue, as well as the handlers for when a FW reset is seen.

---
 drivers/net/ethernet/amd/pds_core/core.c | 60 ++++++++++++++++++++++++
 drivers/net/ethernet/amd/pds_core/core.h | 10 ++++
 drivers/net/ethernet/amd/pds_core/dev.c  |  3 ++
 drivers/net/ethernet/amd/pds_core/main.c | 51 ++++++++++++++++++++
 4 files changed, 124 insertions(+)
drivers/net/ethernet/amd/pds_core/core.c +60 -0
index 80d2ecb045df..39e9a215f638 100644
@@ -34,3 +34,63 @@ void pdsc_teardown(struct pdsc *pdsc, bool removing)
 
 	set_bit(PDSC_S_FW_DEAD, &pdsc->state);
 }
+
+static void pdsc_fw_down(struct pdsc *pdsc)
+{
+	mutex_lock(&pdsc->config_lock);
+
+	if (test_and_set_bit(PDSC_S_FW_DEAD, &pdsc->state)) {
+		dev_err(pdsc->dev, "%s: already happening\n", __func__);
+		mutex_unlock(&pdsc->config_lock);
+		return;
+	}
+
+	pdsc_teardown(pdsc, PDSC_TEARDOWN_RECOVERY);
+
+	mutex_unlock(&pdsc->config_lock);
+}
+
+static void pdsc_fw_up(struct pdsc *pdsc)
+{
+	int err;
+
+	mutex_lock(&pdsc->config_lock);
+
+	if (!test_bit(PDSC_S_FW_DEAD, &pdsc->state)) {
+		dev_err(pdsc->dev, "%s: fw not dead\n", __func__);
+		mutex_unlock(&pdsc->config_lock);
+		return;
+	}
+
+	err = pdsc_setup(pdsc, PDSC_SETUP_RECOVERY);
+	if (err)
+		goto err_out;
+
+	mutex_unlock(&pdsc->config_lock);
+
+	return;
+
+err_out:
+	pdsc_teardown(pdsc, PDSC_TEARDOWN_RECOVERY);
+	mutex_unlock(&pdsc->config_lock);
+}
+
+void pdsc_health_thread(struct work_struct *work)
+{
+	struct pdsc *pdsc = container_of(work, struct pdsc, health_work);
+	bool healthy;
+
+	healthy = pdsc_is_fw_good(pdsc);
+	dev_dbg(pdsc->dev, "%s: health %d fw_status %#02x fw_heartbeat %d\n",
+		__func__, healthy, pdsc->fw_status, pdsc->last_hb);
+
+	if (test_bit(PDSC_S_FW_DEAD, &pdsc->state)) {
+		if (healthy)
+			pdsc_fw_up(pdsc);
+	} else {
+		if (!healthy)
+			pdsc_fw_down(pdsc);
+	}
+
+	pdsc->fw_generation = pdsc->fw_status & PDS_CORE_FW_STS_F_GENERATION;
+}
drivers/net/ethernet/amd/pds_core/core.h +10 -0
index a49af9f36e23..29cec08bd795 100644
@@ -12,6 +12,8 @@
 #include <linux/pds/pds_intr.h>
 
 #define PDSC_DRV_DESCRIPTION	"AMD/Pensando Core Driver"
+
+#define PDSC_WATCHDOG_SECS	5
 #define PDSC_TEARDOWN_RECOVERY	false
 #define PDSC_TEARDOWN_REMOVING	true
 #define PDSC_SETUP_RECOVERY	false
@@ -63,12 +65,17 @@ struct pdsc {
 	u8 fw_generation;
 	unsigned long last_fw_time;
 	u32 last_hb;
+	struct timer_list wdtimer;
+	unsigned int wdtimer_period;
+	struct work_struct health_work;
 
 	struct pdsc_devinfo dev_info;
 	struct pds_core_dev_identity dev_ident;
 	unsigned int nintrs;
 	struct pdsc_intr_info *intr_info;	/* array of nintrs elements */
 
+	struct workqueue_struct *wq;
+
 	unsigned int devcmd_timeout;
 	struct mutex devcmd_lock;	/* lock for dev_cmd operations */
 	struct mutex config_lock;	/* lock for configuration operations */
@@ -81,6 +88,8 @@ struct pdsc {
 	u64 __iomem *kern_dbpage;
 };
 
+void pdsc_queue_health_check(struct pdsc *pdsc);
+
 struct pdsc *pdsc_dl_alloc(struct device *dev, bool is_pf);
 void pdsc_dl_free(struct pdsc *pdsc);
 int pdsc_dl_register(struct pdsc *pdsc);
@@ -116,5 +125,6 @@ int pdsc_dev_init(struct pdsc *pdsc);
 
 int pdsc_setup(struct pdsc *pdsc, bool init);
 void pdsc_teardown(struct pdsc *pdsc, bool removing);
+void pdsc_health_thread(struct work_struct *work);
 
 #endif /* _PDSC_H_ */
drivers/net/ethernet/amd/pds_core/dev.c +3 -0
index 52385a72246d..292deaffe8d6 100644
@@ -177,6 +177,9 @@ int pdsc_devcmd_locked(struct pdsc *pdsc, union pds_core_dev_cmd *cmd,
 	err = pdsc_devcmd_wait(pdsc, max_seconds);
 	memcpy_fromio(comp, &pdsc->cmd_regs->comp, sizeof(*comp));
 
+	if (err == -ENXIO || err == -ETIMEDOUT)
+		pdsc_queue_health_check(pdsc);
+
 	return err;
 }
 
drivers/net/ethernet/amd/pds_core/main.c +51 -0

89 lines not on this page · raw message

Signature · 1 line
2.17.1
#14 lore raw

PATCH v6 4/14 pds_core: add devlink health facilities

In reply to Shannon Nelson

Add devlink health reporting on top of our fw watchdog.

Example:

  # devlink health show pci/0000:2b:00.0 reporter fw
  pci/0000:2b:00.0:
    reporter fw
      state healthy error 0 recover 0
---
 drivers/net/ethernet/amd/pds_core/core.c    |  6 ++
 drivers/net/ethernet/amd/pds_core/core.h    |  2 +
 drivers/net/ethernet/amd/pds_core/devlink.c | 65 +++++++++++++++++++++
 3 files changed, 73 insertions(+)
drivers/net/ethernet/amd/pds_core/core.c +6 -0
index 39e9a215f638..a9918c34018f 100644
@@ -45,6 +45,8 @@ static void pdsc_fw_down(struct pdsc *pdsc)
 		return;
 	}
 
+	devlink_health_report(pdsc->fw_reporter, "FW down reported", pdsc);
+
 	pdsc_teardown(pdsc, PDSC_TEARDOWN_RECOVERY);
 
 	mutex_unlock(&pdsc->config_lock);
@@ -68,6 +70,10 @@ static void pdsc_fw_up(struct pdsc *pdsc)
 
 	mutex_unlock(&pdsc->config_lock);
 
+	pdsc->fw_recoveries++;
+	devlink_health_reporter_state_update(pdsc->fw_reporter,
+					     DEVLINK_HEALTH_REPORTER_STATE_HEALTHY);
+
 	return;
 
 err_out:
drivers/net/ethernet/amd/pds_core/core.h +2 -0
index 29cec08bd795..1254f088955f 100644
@@ -68,6 +68,8 @@ struct pdsc {
 	struct timer_list wdtimer;
 	unsigned int wdtimer_period;
 	struct work_struct health_work;
+	struct devlink_health_reporter *fw_reporter;
+	u32 fw_recoveries;
 
 	struct pdsc_devinfo dev_info;
 	struct pds_core_dev_identity dev_ident;
drivers/net/ethernet/amd/pds_core/devlink.c +65 -0

81 lines not on this page · raw message

Signature · 1 line
2.17.1
#15 lore raw

PATCH v6 5/14 pds_core: set up device and adminq

In reply to Shannon Nelson

Set up the basic adminq and notifyq services. These are used mostly by the client drivers for feature configuration.

---
 drivers/net/ethernet/amd/pds_core/core.c    | 443 +++++++++++++-
 drivers/net/ethernet/amd/pds_core/core.h    | 151 +++++
 drivers/net/ethernet/amd/pds_core/debugfs.c | 107 ++++
 drivers/net/ethernet/amd/pds_core/devlink.c |  54 ++
 drivers/net/ethernet/amd/pds_core/main.c    |  16 +-
 include/linux/pds/pds_adminq.h              | 637 ++++++++++++++++++++
 6 files changed, 1404 insertions(+), 4 deletions(-)
 create mode 100644 include/linux/pds/pds_adminq.h
drivers/net/ethernet/amd/pds_core/core.c +440 -3
index a9918c34018f..e93ec596a25d 100644
@@ -1,10 +1,369 @@
 // SPDX-License-Identifier: GPL-2.0
 /* Copyright(c) 2023 Advanced Micro Devices, Inc */
 
+#include <linux/pci.h>
+
 #include "core.h"
 
+void pdsc_work_thread(struct work_struct *work)
+{
+	/* stub */
+}
+
+irqreturn_t pdsc_adminq_isr(int irq, void *data)
+{
+	/* stub */
+	return IRQ_HANDLED;
+}
+
+void pdsc_intr_free(struct pdsc *pdsc, int index)
+{
+	struct pdsc_intr_info *intr_info;
+
+	if (index >= pdsc->nintrs || index < 0) {
+		WARN(true, "bad intr index %d\n", index);
+		return;
+	}
+
+	intr_info = &pdsc->intr_info[index];
+	if (!intr_info->vector)
+		return;
+	dev_dbg(pdsc->dev, "%s: idx %d vec %d name %s\n",
+		__func__, index, intr_info->vector, intr_info->name);
+
+	pds_core_intr_mask(&pdsc->intr_ctrl[index], PDS_CORE_INTR_MASK_SET);
+	pds_core_intr_clean(&pdsc->intr_ctrl[index]);
+
+	free_irq(intr_info->vector, intr_info->data);
+
+	memset(intr_info, 0, sizeof(*intr_info));
+}
+
+int pdsc_intr_alloc(struct pdsc *pdsc, char *name,
+		    irq_handler_t handler, void *data)
+{
+	struct pdsc_intr_info *intr_info;
+	unsigned int index;
+	int err;
+
+	/* Find the first available interrupt */
+	for (index = 0; index < pdsc->nintrs; index++)
+		if (!pdsc->intr_info[index].vector)
+			break;
+	if (index >= pdsc->nintrs) {
+		dev_warn(pdsc->dev, "%s: no intr, index=%d nintrs=%d\n",
+			 __func__, index, pdsc->nintrs);
+		return -ENOSPC;
+	}
+
+	pds_core_intr_clean_flags(&pdsc->intr_ctrl[index],
+				  PDS_CORE_INTR_CRED_RESET_COALESCE);
+
+	intr_info = &pdsc->intr_info[index];
+
+	intr_info->index = index;
+	intr_info->data = data;
+	strscpy(intr_info->name, name, sizeof(intr_info->name));
+
+	/* Get the OS vector number for the interrupt */
+	err = pci_irq_vector(pdsc->pdev, index);
+	if (err < 0) {
+		dev_err(pdsc->dev, "failed to get intr vector index %d: %pe\n",
+			index, ERR_PTR(err));
+		goto err_out_free_intr;
+	}
+	intr_info->vector = err;
+
+	/* Init the device's intr mask */
+	pds_core_intr_clean(&pdsc->intr_ctrl[index]);
+	pds_core_intr_mask_assert(&pdsc->intr_ctrl[index], 1);
+	pds_core_intr_mask(&pdsc->intr_ctrl[index], PDS_CORE_INTR_MASK_SET);
+
+	/* Register the isr with a name */
+	err = request_irq(intr_info->vector, handler, 0, intr_info->name, data);
+	if (err) {
+		dev_err(pdsc->dev, "failed to get intr irq vector %d: %pe\n",
+			intr_info->vector, ERR_PTR(err));
+		goto err_out_free_intr;
+	}
+
+	return index;
+
+err_out_free_intr:
+	pdsc_intr_free(pdsc, index);
+	return err;
+}
+
+static void pdsc_qcq_intr_free(struct pdsc *pdsc, struct pdsc_qcq *qcq)
+{
+	if (!(qcq->flags & PDS_CORE_QCQ_F_INTR) ||
+	    qcq->intx == PDS_CORE_INTR_INDEX_NOT_ASSIGNED)
+		return;
+
+	pdsc_intr_free(pdsc, qcq->intx);
+	qcq->intx = PDS_CORE_INTR_INDEX_NOT_ASSIGNED;
+}
+
+static int pdsc_qcq_intr_alloc(struct pdsc *pdsc, struct pdsc_qcq *qcq)
+{
+	char name[PDSC_INTR_NAME_MAX_SZ];
+	int index;
+
+	if (!(qcq->flags & PDS_CORE_QCQ_F_INTR)) {
+		qcq->intx = PDS_CORE_INTR_INDEX_NOT_ASSIGNED;
+		return 0;
+	}
+
+	snprintf(name, sizeof(name), "%s-%d-%s",
+		 PDS_CORE_DRV_NAME, pdsc->pdev->bus->number, qcq->q.name);
+	index = pdsc_intr_alloc(pdsc, name, pdsc_adminq_isr, qcq);
+	if (index < 0)
+		return index;
+	qcq->intx = index;
+
+	return 0;
+}
+
+void pdsc_qcq_free(struct pdsc *pdsc, struct pdsc_qcq *qcq)
+{
+	struct device *dev = pdsc->dev;
+
+	if (!(qcq && qcq->pdsc))
+		return;
+
+	pdsc_debugfs_del_qcq(qcq);
+
+	pdsc_qcq_intr_free(pdsc, qcq);
+
+	if (qcq->q_base) {
+		dma_free_coherent(dev, qcq->q_size,
+				  qcq->q_base, qcq->q_base_pa);
+		qcq->q_base = NULL;
+		qcq->q_base_pa = 0;
+	}
+
+	if (qcq->cq_base) {
+		dma_free_coherent(dev, qcq->cq_size,
+				  qcq->cq_base, qcq->cq_base_pa);
+		qcq->cq_base = NULL;
+		qcq->cq_base_pa = 0;
+	}
+
+	if (qcq->cq.info) {
+		vfree(qcq->cq.info);
+		qcq->cq.info = NULL;
+	}
+	if (qcq->q.info) {
+		vfree(qcq->q.info);
+		qcq->q.info = NULL;
+	}
+
+	qcq->pdsc = NULL;
+	memset(&qcq->q, 0, sizeof(qcq->q));
+	memset(&qcq->cq, 0, sizeof(qcq->cq));
+}
+
+static void pdsc_q_map(struct pdsc_queue *q, void *base, dma_addr_t base_pa)
+{
+	struct pdsc_q_info *cur;
+	unsigned int i;
+
+	q->base = base;
+	q->base_pa = base_pa;
+
+	for (i = 0, cur = q->info; i < q->num_descs; i++, cur++)
+		cur->desc = base + (i * q->desc_size);
+}
+
+static void pdsc_cq_map(struct pdsc_cq *cq, void *base, dma_addr_t base_pa)
+{
+	struct pdsc_cq_info *cur;
+	unsigned int i;
+
+	cq->base = base;
+	cq->base_pa = base_pa;
+
+	for (i = 0, cur = cq->info; i < cq->num_descs; i++, cur++)
+		cur->comp = base + (i * cq->desc_size);
+}
+
+int pdsc_qcq_alloc(struct pdsc *pdsc, unsigned int type, unsigned int index,
+		   const char *name, unsigned int flags, unsigned int num_descs,
+		   unsigned int desc_size, unsigned int cq_desc_size,
+		   unsigned int pid, struct pdsc_qcq *qcq)
+{
+	struct device *dev = pdsc->dev;
+	dma_addr_t cq_base_pa = 0;
+	dma_addr_t q_base_pa = 0;
+	void *q_base, *cq_base;
+	int err;
+
+	qcq->q.info = vzalloc(num_descs * sizeof(*qcq->q.info));
+	if (!qcq->q.info) {
+		err = -ENOMEM;
+		goto err_out;
+	}
+
+	qcq->pdsc = pdsc;
+	qcq->flags = flags;
+	INIT_WORK(&qcq->work, pdsc_work_thread);
+
+	qcq->q.type = type;
+	qcq->q.index = index;
+	qcq->q.num_descs = num_descs;
+	qcq->q.desc_size = desc_size;
+	qcq->q.tail_idx = 0;
+	qcq->q.head_idx = 0;
+	qcq->q.pid = pid;
+	snprintf(qcq->q.name, sizeof(qcq->q.name), "%s%u", name, index);
+
+	err = pdsc_qcq_intr_alloc(pdsc, qcq);
+	if (err)
+		goto err_out_free_q_info;
+
+	qcq->cq.info = vzalloc(num_descs * sizeof(*qcq->cq.info));
+	if (!qcq->cq.info) {
+		err = -ENOMEM;
+		goto err_out_free_irq;
+	}
+
+	qcq->cq.bound_intr = &pdsc->intr_info[qcq->intx];
+	qcq->cq.num_descs = num_descs;
+	qcq->cq.desc_size = cq_desc_size;
+	qcq->cq.tail_idx = 0;
+	qcq->cq.done_color = 1;
+
+	if (flags & PDS_CORE_QCQ_F_NOTIFYQ) {
+		/* q & cq need to be contiguous in case of notifyq */
+		qcq->q_size = PDS_PAGE_SIZE +
+			      ALIGN(num_descs * desc_size, PDS_PAGE_SIZE) +
+			      ALIGN(num_descs * cq_desc_size, PDS_PAGE_SIZE);
+		qcq->q_base = dma_alloc_coherent(dev,
+						 qcq->q_size + qcq->cq_size,
+						 &qcq->q_base_pa,
+						 GFP_KERNEL);
+		if (!qcq->q_base) {
+			err = -ENOMEM;
+			goto err_out_free_cq_info;
+		}
+		q_base = PTR_ALIGN(qcq->q_base, PDS_PAGE_SIZE);
+		q_base_pa = ALIGN(qcq->q_base_pa, PDS_PAGE_SIZE);
+		pdsc_q_map(&qcq->q, q_base, q_base_pa);
+
+		cq_base = PTR_ALIGN(q_base +
+				    ALIGN(num_descs * desc_size, PDS_PAGE_SIZE),
+				    PDS_PAGE_SIZE);
+		cq_base_pa = ALIGN(qcq->q_base_pa +
+				   ALIGN(num_descs * desc_size, PDS_PAGE_SIZE),
+				   PDS_PAGE_SIZE);
+
+	} else {
+		/* q DMA descriptors */
+		qcq->q_size = PDS_PAGE_SIZE + (num_descs * desc_size);
+		qcq->q_base = dma_alloc_coherent(dev, qcq->q_size,
+						 &qcq->q_base_pa,
+						 GFP_KERNEL);
+		if (!qcq->q_base) {
+			err = -ENOMEM;
+			goto err_out_free_cq_info;
+		}
+		q_base = PTR_ALIGN(qcq->q_base, PDS_PAGE_SIZE);
+		q_base_pa = ALIGN(qcq->q_base_pa, PDS_PAGE_SIZE);
+		pdsc_q_map(&qcq->q, q_base, q_base_pa);
+
+		/* cq DMA descriptors */
+		qcq->cq_size = PDS_PAGE_SIZE + (num_descs * cq_desc_size);
+		qcq->cq_base = dma_alloc_coherent(dev, qcq->cq_size,
+						  &qcq->cq_base_pa,
+						  GFP_KERNEL);
+		if (!qcq->cq_base) {
+			err = -ENOMEM;
+			goto err_out_free_q;
+		}
+		cq_base = PTR_ALIGN(qcq->cq_base, PDS_PAGE_SIZE);
+		cq_base_pa = ALIGN(qcq->cq_base_pa, PDS_PAGE_SIZE);
+	}
+
+	pdsc_cq_map(&qcq->cq, cq_base, cq_base_pa);
+	qcq->cq.bound_q = &qcq->q;
+
+	pdsc_debugfs_add_qcq(pdsc, qcq);
+
+	return 0;
+
+err_out_free_q:
+	dma_free_coherent(dev, qcq->q_size, qcq->q_base, qcq->q_base_pa);
+err_out_free_cq_info:
+	vfree(qcq->cq.info);
+err_out_free_irq:
+	pdsc_qcq_intr_free(pdsc, qcq);
+err_out_free_q_info:
+	vfree(qcq->q.info);
+	memset(qcq, 0, sizeof(*qcq));
+err_out:
+	dev_err(dev, "qcq alloc of %s%d failed %d\n", name, index, err);
+	return err;
+}
+
+static int pdsc_core_init(struct pdsc *pdsc)
+{
+	union pds_core_dev_comp comp = { 0 };
+	union pds_core_dev_cmd cmd = {
+		.init.opcode = PDS_CORE_CMD_INIT,
+	};
+	struct pds_core_dev_init_data_out cido;
+	struct pds_core_dev_init_data_in cidi;
+	u32 dbid_count;
+	u32 dbpage_num;
+	size_t sz;
+	int err;
+
+	cidi.adminq_q_base = cpu_to_le64(pdsc->adminqcq.q_base_pa);
+	cidi.adminq_cq_base = cpu_to_le64(pdsc->adminqcq.cq_base_pa);
+	cidi.notifyq_cq_base = cpu_to_le64(pdsc->notifyqcq.cq.base_pa);
+	cidi.flags = cpu_to_le32(PDS_CORE_QINIT_F_IRQ | PDS_CORE_QINIT_F_ENA);
+	cidi.intr_index = cpu_to_le16(pdsc->adminqcq.intx);
+	cidi.adminq_ring_size = ilog2(pdsc->adminqcq.q.num_descs);
+	cidi.notifyq_ring_size = ilog2(pdsc->notifyqcq.q.num_descs);
+
+	mutex_lock(&pdsc->devcmd_lock);
+
+	sz = min_t(size_t, sizeof(cidi), sizeof(pdsc->cmd_regs->data));
+	memcpy_toio(&pdsc->cmd_regs->data, &cidi, sz);
+
+	err = pdsc_devcmd_locked(pdsc, &cmd, &comp, pdsc->devcmd_timeout);
+
+	sz = min_t(size_t, sizeof(cido), sizeof(pdsc->cmd_regs->data));
+	memcpy_fromio(&cido, &pdsc->cmd_regs->data, sz);
+
+	mutex_unlock(&pdsc->devcmd_lock);
+
+	pdsc->hw_index = le32_to_cpu(cido.core_hw_index);
+
+	dbid_count = le32_to_cpu(pdsc->dev_ident.ndbpgs_per_lif);
+	dbpage_num = pdsc->hw_index * dbid_count;
+	pdsc->kern_dbpage = pdsc_map_dbpage(pdsc, dbpage_num);
+	if (!pdsc->kern_dbpage) {
+		dev_err(pdsc->dev, "Cannot map dbpage, aborting\n");
+		return -ENOMEM;
+	}
+
+	pdsc->adminqcq.q.hw_type = cido.adminq_hw_type;
+	pdsc->adminqcq.q.hw_index = le32_to_cpu(cido.adminq_hw_index);
+	pdsc->adminqcq.q.dbval = PDS_CORE_DBELL_QID(pdsc->adminqcq.q.hw_index);
+
+	pdsc->notifyqcq.q.hw_type = cido.notifyq_hw_type;
+	pdsc->notifyqcq.q.hw_index = le32_to_cpu(cido.notifyq_hw_index);
+	pdsc->notifyqcq.q.dbval = PDS_CORE_DBELL_QID(pdsc->notifyqcq.q.hw_index);
+
+	pdsc->last_eid = 0;
+
+	return err;
+}
+
 int pdsc_setup(struct pdsc *pdsc, bool init)
 {
+	int numdescs;
 	int err = 0;
 
 	if (init)
@@ -14,17 +373,60 @@ int pdsc_setup(struct pdsc *pdsc, bool init)
 	if (err)
 		return err;
 
+	/* Scale the descriptor ring length based on number of CPUs and VFs */
+	numdescs = max_t(int, PDSC_ADMINQ_MIN_LENGTH, num_online_cpus());
+	numdescs += 2 * pci_sriov_get_totalvfs(pdsc->pdev);
+	numdescs = roundup_pow_of_two(numdescs);
+	err = pdsc_qcq_alloc(pdsc, PDS_CORE_QTYPE_ADMINQ, 0, "adminq",
+			     PDS_CORE_QCQ_F_CORE | PDS_CORE_QCQ_F_INTR,
+			     numdescs,
+			     sizeof(union pds_core_adminq_cmd),
+			     sizeof(union pds_core_adminq_comp),
+			     0, &pdsc->adminqcq);
+	if (err)
+		goto err_out_teardown;
+
+	err = pdsc_qcq_alloc(pdsc, PDS_CORE_QTYPE_NOTIFYQ, 0, "notifyq",
+			     PDS_CORE_QCQ_F_NOTIFYQ,
+			     PDSC_NOTIFYQ_LENGTH,
+			     sizeof(struct pds_core_notifyq_cmd),
+			     sizeof(union pds_core_notifyq_comp),
+			     0, &pdsc->notifyqcq);
+	if (err)
+		goto err_out_teardown;
+
+	/* NotifyQ rides on the AdminQ interrupt */
+	pdsc->notifyqcq.intx = pdsc->adminqcq.intx;
+
+	/* Set up the Core with the AdminQ and NotifyQ info */
+	err = pdsc_core_init(pdsc);
+	if (err)
+		goto err_out_teardown;
+
 	clear_bit(PDSC_S_FW_DEAD, &pdsc->state);
 	return 0;
+
+err_out_teardown:
+	pdsc_teardown(pdsc, init);
+	return err;
 }
 
 void pdsc_teardown(struct pdsc *pdsc, bool removing)
 {
+	int i;
+
 	pdsc_devcmd_reset(pdsc);
+	pdsc_qcq_free(pdsc, &pdsc->notifyqcq);
+	pdsc_qcq_free(pdsc, &pdsc->adminqcq);
 
-	if (removing) {
-		kfree(pdsc->intr_info);
-		pdsc->intr_info = NULL;
+	if (pdsc->intr_info) {
+		for (i = 0; i < pdsc->nintrs; i++)
+			pdsc_intr_free(pdsc, i);
+
+		if (removing) {
+			kfree(pdsc->intr_info);
+			pdsc->intr_info = NULL;
+		}
 	}
 
 	if (pdsc->kern_dbpage) {
@@ -35,6 +437,36 @@ void pdsc_teardown(struct pdsc *pdsc, bool removing)
 	set_bit(PDSC_S_FW_DEAD, &pdsc->state);
 }
 
+int pdsc_start(struct pdsc *pdsc)
+{
+	pds_core_intr_mask(&pdsc->intr_ctrl[pdsc->adminqcq.intx],
+			   PDS_CORE_INTR_MASK_CLEAR);
+
+	return 0;
+}
+
+static void pdsc_mask_interrupts(struct pdsc *pdsc)
+{
+	int i;
+
+	if (!pdsc->intr_info)
+		return;
+
+	/* Mask interrupts that are in use */
+	for (i = 0; i < pdsc->nintrs; i++)
+		if (pdsc->intr_info[i].vector)
+			pds_core_intr_mask(&pdsc->intr_ctrl[i],
+					   PDS_CORE_INTR_MASK_SET);
+}
+
+void pdsc_stop(struct pdsc *pdsc)
+{
+	if (pdsc->wq)
+		flush_workqueue(pdsc->wq);
+
+	pdsc_mask_interrupts(pdsc);
+}
+
 static void pdsc_fw_down(struct pdsc *pdsc)
 {
 	mutex_lock(&pdsc->config_lock);
@@ -47,6 +479,7 @@ static void pdsc_fw_down(struct pdsc *pdsc)
 
 	devlink_health_report(pdsc->fw_reporter, "FW down reported", pdsc);
 
+	pdsc_mask_interrupts(pdsc);
 	pdsc_teardown(pdsc, PDSC_TEARDOWN_RECOVERY);
 
 	mutex_unlock(&pdsc->config_lock);
@@ -68,6 +501,10 @@ static void pdsc_fw_up(struct pdsc *pdsc)
 	if (err)
 		goto err_out;
 
+	err = pdsc_start(pdsc);
+	if (err)
+		goto err_out;
+
 	mutex_unlock(&pdsc->config_lock);
 
 	pdsc->fw_recoveries++;
drivers/net/ethernet/amd/pds_core/core.h +151 -0

209 lines not on this page · raw message

drivers/net/ethernet/amd/pds_core/debugfs.c +107 -0

111 lines not on this page · raw message

drivers/net/ethernet/amd/pds_core/devlink.c +54 -0

61 lines not on this page · raw message

drivers/net/ethernet/amd/pds_core/main.c +15 -1
index 6a39faac5c76..9dcc8f4f247d 100644
@@ -157,6 +157,13 @@ static int pdsc_map_bars(struct pdsc *pdsc)
 	return err;
 }
 
+void __iomem *pdsc_map_dbpage(struct pdsc *pdsc, int page_num)
+{
+	return pci_iomap_range(pdsc->pdev,
+			       pdsc->bars[PDS_CORE_PCI_BAR_DBELL].res_index,
+			       (u64)page_num << PAGE_SHIFT, PAGE_SIZE);
+}
+
 static int pdsc_init_vf(struct pdsc *vf)
 {
 	return -1;
@@ -191,6 +198,7 @@ static int pdsc_init_pf(struct pdsc *pdsc)
 
 	mutex_init(&pdsc->devcmd_lock);
 	mutex_init(&pdsc->config_lock);
+	spin_lock_init(&pdsc->adminq_lock);
 
 	mutex_lock(&pdsc->config_lock);
 	set_bit(PDSC_S_FW_DEAD, &pdsc->state);
@@ -198,10 +206,13 @@ static int pdsc_init_pf(struct pdsc *pdsc)
 	err = pdsc_setup(pdsc, PDSC_SETUP_INIT);
 	if (err)
 		goto err_out_unmap_bars;
+	err = pdsc_start(pdsc);
+	if (err)
+		goto err_out_teardown;
 
 	err = pdsc_dl_register(pdsc);
 	if (err)
-		goto err_out_teardown;
+		goto err_out_stop;
 
 	mutex_unlock(&pdsc->config_lock);
 
@@ -210,6 +221,8 @@ static int pdsc_init_pf(struct pdsc *pdsc)
 
 	return 0;
 
+err_out_stop:
+	pdsc_stop(pdsc);
 err_out_teardown:
 	pdsc_teardown(pdsc, PDSC_TEARDOWN_REMOVING);
 err_out_unmap_bars:
@@ -317,6 +330,7 @@ static void pdsc_remove(struct pci_dev *pdev)
 		mutex_lock(&pdsc->config_lock);
 		set_bit(PDSC_S_STOPPING_DRIVER, &pdsc->state);
 
+		pdsc_stop(pdsc);
 		pdsc_teardown(pdsc, PDSC_TEARDOWN_REMOVING);
 		mutex_unlock(&pdsc->config_lock);
 		mutex_destroy(&pdsc->config_lock);
include/linux/pds/pds_adminq.h new file +637 -0

637 lines not on this page · raw message

Signature · 1 line
2.17.1
#16 lore raw

PATCH v6 6/14 pds_core: Add adminq processing and commands

In reply to Shannon Nelson

Add the service routines for submitting and processing the adminq messages and for handling notifyq events.

---
 drivers/net/ethernet/amd/pds_core/Makefile |   1 +
 drivers/net/ethernet/amd/pds_core/adminq.c | 289 +++++++++++++++++++++
 drivers/net/ethernet/amd/pds_core/core.c   |  11 -
 include/linux/pds/pds_adminq.h             |   8 +
 4 files changed, 298 insertions(+), 11 deletions(-)
 create mode 100644 drivers/net/ethernet/amd/pds_core/adminq.c
drivers/net/ethernet/amd/pds_core/Makefile +1 -0
index eaca8557ba66..ef76dcd7fccd 100644
@@ -6,6 +6,7 @@ obj-$(CONFIG_PDS_CORE) := pds_core.o
 pds_core-y := main.o \
 	      devlink.o \
 	      dev.o \
+	      adminq.o \
 	      core.o
 
 pds_core-$(CONFIG_DEBUG_FS) += debugfs.o
drivers/net/ethernet/amd/pds_core/adminq.c new file +289 -0

289 lines not on this page · raw message

drivers/net/ethernet/amd/pds_core/core.c +0 -11
index e93ec596a25d..1babb1b4c04c 100644
@@ -5,17 +5,6 @@
 
 #include "core.h"
 
-void pdsc_work_thread(struct work_struct *work)
-{
-	/* stub */
-}
-
-irqreturn_t pdsc_adminq_isr(int irq, void *data)
-{
-	/* stub */
-	return IRQ_HANDLED;
-}
-
 void pdsc_intr_free(struct pdsc *pdsc, int index)
 {
 	struct pdsc_intr_info *intr_info;
include/linux/pds/pds_adminq.h +8 -0
index 9cd58b7f5fb2..797d93fd0473 100644
@@ -4,6 +4,8 @@
 #ifndef _PDS_CORE_ADMINQ_H_
 #define _PDS_CORE_ADMINQ_H_
 
+#define PDSC_ADMINQ_MAX_POLL_INTERVAL	256
+
 enum pds_core_adminq_flags {
 	PDS_AQ_FLAG_FASTPOLL	= BIT(1),	/* completion poll at 1ms */
 };
@@ -634,4 +636,10 @@ static inline u8 pdsc_color_match(u8 color, u8 done_color)
 {
 	return (!!(color & PDS_COMP_COLOR_MASK)) == done_color;
 }
+
+int pdsc_adminq_post(void *pdsc,
+		     union pds_core_adminq_cmd *cmd,
+		     union pds_core_adminq_comp *comp,
+		     bool fast_poll);
+
 #endif /* _PDS_CORE_ADMINQ_H_ */
Signature · 1 line
2.17.1
#17 lore raw

PATCH v6 7/14 pds_core: add FW update feature to devlink

In reply to Shannon Nelson

Add in the support for doing firmware updates. Of the two main banks available, a and b, this updates the one not in use and then selects it for the next boot.

---
 drivers/net/ethernet/amd/pds_core/Makefile  |   3 +-
 drivers/net/ethernet/amd/pds_core/core.h    |   3 +
 drivers/net/ethernet/amd/pds_core/devlink.c |  10 +
 drivers/net/ethernet/amd/pds_core/fw.c      | 194 ++++++++++++++++++++
 4 files changed, 209 insertions(+), 1 deletion(-)
 create mode 100644 drivers/net/ethernet/amd/pds_core/fw.c
drivers/net/ethernet/amd/pds_core/Makefile +2 -1
index ef76dcd7fccd..6d1d6c58a1fa 100644
@@ -7,6 +7,7 @@ pds_core-y := main.o \
 	      devlink.o \
 	      dev.o \
 	      adminq.o \
-	      core.o
+	      core.o \
+	      fw.o
 
 pds_core-$(CONFIG_DEBUG_FS) += debugfs.o
drivers/net/ethernet/amd/pds_core/core.h +3 -0
index fef23abf9b5b..ba2e23ba8ce5 100644
@@ -280,4 +280,7 @@ void pdsc_process_adminq(struct pdsc_qcq *qcq);
 void pdsc_work_thread(struct work_struct *work);
 irqreturn_t pdsc_adminq_isr(int irq, void *data);
 
+int pdsc_firmware_update(struct pdsc *pdsc, const struct firmware *fw,
+			 struct netlink_ext_ack *extack);
+
 #endif /* _PDSC_H_ */
drivers/net/ethernet/amd/pds_core/devlink.c +10 -0
index 5751ce20479d..17464b063009 100644
@@ -8,6 +8,15 @@
 
 #include "core.h"
 
+static int pdsc_dl_flash_update(struct devlink *dl,
+				struct devlink_flash_update_params *params,
+				struct netlink_ext_ack *extack)
+{
+	struct pdsc *pdsc = devlink_priv(dl);
+
+	return pdsc_firmware_update(pdsc, params->fw, extack);
+}
+
 static int pdsc_dl_info_get(struct devlink *dl, struct devlink_info_req *req,
 			    struct netlink_ext_ack *extack)
 {
@@ -63,6 +72,7 @@ static int pdsc_dl_info_get(struct devlink *dl, struct devlink_info_req *req,
 
 static const struct devlink_ops pdsc_dl_ops = {
 	.info_get	= pdsc_dl_info_get,
+	.flash_update	= pdsc_dl_flash_update,
 };
 
 static const struct devlink_ops pdsc_dl_vf_ops = {
drivers/net/ethernet/amd/pds_core/fw.c new file +194 -0

194 lines not on this page · raw message

Signature · 1 line
2.17.1
#18 lore raw

PATCH v6 8/14 pds_core: set up the VIF definitions and defaults

In reply to Shannon Nelson

The Virtual Interfaces (VIFs) supported by the DSC's configuration (VFio Live Migration, vDPA, etc) are reported in the dev_ident struct.

---
 drivers/net/ethernet/amd/pds_core/core.c    | 48 +++++++++++++++++++++
 drivers/net/ethernet/amd/pds_core/core.h    | 14 ++++++
 drivers/net/ethernet/amd/pds_core/debugfs.c | 24 +++++++++++
 include/linux/pds/pds_common.h              | 19 ++++++++
 4 files changed, 105 insertions(+)
drivers/net/ethernet/amd/pds_core/core.c +48 -0
index 1babb1b4c04c..6b2884f64419 100644
@@ -350,6 +350,43 @@ static int pdsc_core_init(struct pdsc *pdsc)
 	return err;
 }
 
+static struct pdsc_viftype pdsc_viftype_defaults[] = {
+	[PDS_DEV_TYPE_VDPA] = { .name = PDS_DEV_TYPE_VDPA_STR,
+				.vif_id = PDS_DEV_TYPE_VDPA,
+				.dl_id = DEVLINK_PARAM_GENERIC_ID_ENABLE_VNET },
+	[PDS_DEV_TYPE_MAX] = { 0 }
+};
+
+static int pdsc_viftypes_init(struct pdsc *pdsc)
+{
+	enum pds_core_vif_types vt;
+
+	pdsc->viftype_status = kzalloc(sizeof(pdsc_viftype_defaults),
+				       GFP_KERNEL);
+	if (!pdsc->viftype_status)
+		return -ENOMEM;
+
+	for (vt = 0; vt < PDS_DEV_TYPE_MAX; vt++) {
+		bool vt_support;
+
+		if (!pdsc_viftype_defaults[vt].name)
+			continue;
+
+		/* Grab the defaults */
+		pdsc->viftype_status[vt] = pdsc_viftype_defaults[vt];
+
+		/* See what the Core device has for support */
+		vt_support = !!le16_to_cpu(pdsc->dev_ident.vif_types[vt]);
+		dev_dbg(pdsc->dev, "VIF %s is %ssupported\n",
+			pdsc->viftype_status[vt].name,
+			vt_support ? "" : "not ");
+
+		pdsc->viftype_status[vt].supported = vt_support;
+	}
+
+	return 0;
+}
+
 int pdsc_setup(struct pdsc *pdsc, bool init)
 {
 	int numdescs;
@@ -392,6 +429,14 @@ int pdsc_setup(struct pdsc *pdsc, bool init)
 	if (err)
 		goto err_out_teardown;
 
+	/* Set up the VIFs */
+	err = pdsc_viftypes_init(pdsc);
+	if (err)
+		goto err_out_teardown;
+
+	if (init)
+		pdsc_debugfs_add_viftype(pdsc);
+
 	clear_bit(PDSC_S_FW_DEAD, &pdsc->state);
 	return 0;
 
@@ -408,6 +453,9 @@ void pdsc_teardown(struct pdsc *pdsc, bool removing)
 	pdsc_qcq_free(pdsc, &pdsc->notifyqcq);
 	pdsc_qcq_free(pdsc, &pdsc->adminqcq);
 
+	kfree(pdsc->viftype_status);
+	pdsc->viftype_status = NULL;
+
 	if (pdsc->intr_info) {
 		for (i = 0; i < pdsc->nintrs; i++)
 			pdsc_intr_free(pdsc, i);
drivers/net/ethernet/amd/pds_core/core.h +14 -0
index ba2e23ba8ce5..46dd869b60a5 100644
@@ -123,6 +123,15 @@ struct pdsc_qcq {
 	struct dentry *dentry;
 };
 
+struct pdsc_viftype {
+	char *name;
+	bool supported;
+	bool enabled;
+	int dl_id;
+	int vif_id;
+	struct pds_auxiliary_dev *padev;
+};
+
 /* No state flags set means we are in a steady running state */
 enum pdsc_state_flags {
 	PDSC_S_FW_DEAD,		    /* stopped, wait on startup or recovery */
@@ -174,6 +183,7 @@ struct pdsc {
 	struct pdsc_qcq adminqcq;
 	struct pdsc_qcq notifyqcq;
 	u64 last_eid;
+	struct pdsc_viftype *viftype_status;
 };
 
 /** enum pds_core_dbell_bits - bitwise composition of dbell values.
@@ -228,6 +238,8 @@ struct pdsc *pdsc_dl_alloc(struct device *dev, bool is_pf);
 void pdsc_dl_free(struct pdsc *pdsc);
 int pdsc_dl_register(struct pdsc *pdsc);
 void pdsc_dl_unregister(struct pdsc *pdsc);
+int pdsc_dl_vif_add(struct pdsc *pdsc, enum pds_core_vif_types vt,
+		    const char *name);
 
 #ifdef CONFIG_DEBUG_FS
 void pdsc_debugfs_create(void);
@@ -235,6 +247,7 @@ void pdsc_debugfs_destroy(void);
 void pdsc_debugfs_add_dev(struct pdsc *pdsc);
 void pdsc_debugfs_del_dev(struct pdsc *pdsc);
 void pdsc_debugfs_add_ident(struct pdsc *pdsc);
+void pdsc_debugfs_add_viftype(struct pdsc *pdsc);
 void pdsc_debugfs_add_irqs(struct pdsc *pdsc);
 void pdsc_debugfs_add_qcq(struct pdsc *pdsc, struct pdsc_qcq *qcq);
 void pdsc_debugfs_del_qcq(struct pdsc_qcq *qcq);
@@ -244,6 +257,7 @@ static inline void pdsc_debugfs_destroy(void) { }
 static inline void pdsc_debugfs_add_dev(struct pdsc *pdsc) { }
 static inline void pdsc_debugfs_del_dev(struct pdsc *pdsc) { }
 static inline void pdsc_debugfs_add_ident(struct pdsc *pdsc) { }
+static inline void pdsc_debugfs_add_viftype(struct pdsc *pdsc) { }
 static inline void pdsc_debugfs_add_irqs(struct pdsc *pdsc) { }
 static inline void pdsc_debugfs_add_qcq(struct pdsc *pdsc,
 					struct pdsc_qcq *qcq) { }
drivers/net/ethernet/amd/pds_core/debugfs.c +24 -0
index dc3edb8a0628..466a88b0313a 100644
@@ -83,6 +83,30 @@ void pdsc_debugfs_add_ident(struct pdsc *pdsc)
 			    pdsc, &identity_fops);
 }
 
+static int viftype_show(struct seq_file *seq, void *v)
+{
+	struct pdsc *pdsc = seq->private;
+	int vt;
+
+	for (vt = 0; vt < PDS_DEV_TYPE_MAX; vt++) {
+		if (!pdsc->viftype_status[vt].name)
+			continue;
+
+		seq_printf(seq, "%s\t%d supported %d enabled\n",
+			   pdsc->viftype_status[vt].name,
+			   pdsc->viftype_status[vt].supported,
+			   pdsc->viftype_status[vt].enabled);
+	}
+	return 0;
+}
+DEFINE_SHOW_ATTRIBUTE(viftype);
+
+void pdsc_debugfs_add_viftype(struct pdsc *pdsc)
+{
+	debugfs_create_file("viftypes", 0400, pdsc->dentry,
+			    pdsc, &viftype_fops);
+}
+
 static int irqs_show(struct seq_file *seq, void *v)
 {
 	struct pdsc *pdsc = seq->private;
include/linux/pds/pds_common.h +19 -0
index e45a69178f74..350295091d9d 100644
@@ -51,6 +51,25 @@ enum pds_core_driver_type {
 	PDS_DRIVER_ESXI    = 6,
 };
 
+enum pds_core_vif_types {
+	PDS_DEV_TYPE_CORE	= 0,
+	PDS_DEV_TYPE_VDPA	= 1,
+	PDS_DEV_TYPE_VFIO	= 2,
+	PDS_DEV_TYPE_ETH	= 3,
+	PDS_DEV_TYPE_RDMA	= 4,
+	PDS_DEV_TYPE_LM		= 5,
+
+	/* new ones added before this line */
+	PDS_DEV_TYPE_MAX	= 16   /* don't change - used in struct size */
+};
+
+#define PDS_DEV_TYPE_CORE_STR	"Core"
+#define PDS_DEV_TYPE_VDPA_STR	"vDPA"
+#define PDS_DEV_TYPE_VFIO_STR	"VFio"
+#define PDS_DEV_TYPE_ETH_STR	"Eth"
+#define PDS_DEV_TYPE_RDMA_STR	"RDMA"
+#define PDS_DEV_TYPE_LM_STR	"LM"
+
 #define PDS_CORE_IFNAMSIZ		16
 
 /**
Signature · 1 line
2.17.1
#19 lore raw

PATCH v6 9/14 pds_core: add initial VF device handling

In reply to Shannon Nelson

This is the initial VF PCI driver framework for the new pds_vdpa VF device, which will work in conjunction with an auxiliary_bus client of the pds_core driver. This does the very basics of registering for the new VF device, setting up debugfs entries, and registering with devlink.

---
 drivers/net/ethernet/amd/pds_core/core.h | 10 ++++-
 drivers/net/ethernet/amd/pds_core/main.c | 47 +++++++++++++++++++++++-
 2 files changed, 55 insertions(+), 2 deletions(-)
drivers/net/ethernet/amd/pds_core/core.h +9 -1
index 46dd869b60a5..74f80af53067 100644
@@ -30,6 +30,12 @@ struct pdsc_dev_bar {
 	int res_index;
 };
 
+struct pdsc_vf {
+	struct pds_auxiliary_dev *padev;
+	u16     index;
+	__le16  vif_types[PDS_DEV_TYPE_MAX];
+};
+
 struct pdsc_devinfo {
 	u8 asic_type;
 	u8 asic_rev;
@@ -147,6 +153,9 @@ struct pdsc {
 	struct dentry *dentry;
 	struct device *dev;
 	struct pdsc_dev_bar bars[PDS_CORE_BARS_MAX];
+	struct pdsc_vf *vfs;
+	int num_vfs;
+	int vf_id;
 	int hw_index;
 	int id;
 
@@ -296,5 +305,4 @@ irqreturn_t pdsc_adminq_isr(int irq, void *data);
 
 int pdsc_firmware_update(struct pdsc *pdsc, const struct firmware *fw,
 			 struct netlink_ext_ack *extack);
-
 #endif /* _PDSC_H_ */
drivers/net/ethernet/amd/pds_core/main.c +46 -1

73 lines not on this page · raw message

Signature · 1 line
2.17.1
#20 lore raw

PATCH v6 10/14 pds_core: add auxiliary_bus devices

In reply to Shannon Nelson

An auxiliary_bus device is created for each vDPA type VF at VF probe and destroyed at VF remove. The VFs are always removed on PF remove, so there should be no issues with VFs trying to access missing PF structures.

---
 drivers/net/ethernet/amd/pds_core/Makefile |   1 +
 drivers/net/ethernet/amd/pds_core/auxbus.c | 142 +++++++++++++++++++++
 drivers/net/ethernet/amd/pds_core/core.h   |   6 +
 drivers/net/ethernet/amd/pds_core/main.c   |  37 +++++-
 include/linux/pds/pds_auxbus.h             |  16 +++
 include/linux/pds/pds_common.h             |   1 +
 6 files changed, 201 insertions(+), 2 deletions(-)
 create mode 100644 drivers/net/ethernet/amd/pds_core/auxbus.c
 create mode 100644 include/linux/pds/pds_auxbus.h
drivers/net/ethernet/amd/pds_core/Makefile +1 -0
index 6d1d6c58a1fa..0abc33ce826c 100644
@@ -5,6 +5,7 @@ obj-$(CONFIG_PDS_CORE) := pds_core.o
 
 pds_core-y := main.o \
 	      devlink.o \
+	      auxbus.o \
 	      dev.o \
 	      adminq.o \
 	      core.o \
drivers/net/ethernet/amd/pds_core/auxbus.c new file +142 -0

142 lines not on this page · raw message

drivers/net/ethernet/amd/pds_core/core.h +6 -0
index 74f80af53067..ce3598cf8de1 100644
@@ -30,8 +30,11 @@ struct pdsc_dev_bar {
 	int res_index;
 };
 
+struct pdsc;
+
 struct pdsc_vf {
 	struct pds_auxiliary_dev *padev;
+	struct pdsc *vf;
 	u16     index;
 	__le16  vif_types[PDS_DEV_TYPE_MAX];
 };
@@ -299,6 +302,9 @@ int pdsc_start(struct pdsc *pdsc);
 void pdsc_stop(struct pdsc *pdsc);
 void pdsc_health_thread(struct work_struct *work);
 
+int pdsc_auxbus_dev_add_vf(struct pdsc *vf, struct pdsc *pf);
+int pdsc_auxbus_dev_del_vf(struct pdsc *vf, struct pdsc *pf);
+
 void pdsc_process_adminq(struct pdsc_qcq *qcq);
 void pdsc_work_thread(struct work_struct *work);
 irqreturn_t pdsc_adminq_isr(int irq, void *data);
drivers/net/ethernet/amd/pds_core/main.c +35 -2
index 486eb87a0520..d2ff64046db8 100644
@@ -200,15 +200,36 @@ static int pdsc_sriov_configure(struct pci_dev *pdev, int num_vfs)
 
 static int pdsc_init_vf(struct pdsc *vf)
 {
+	struct pdsc *pf;
 	int err;
 
+	pf = pdsc_get_pf_struct(vf->pdev);
+	if (IS_ERR_OR_NULL(pf))
+		return PTR_ERR(pf) ?: -1;
+
 	vf->vf_id = pci_iov_vf_id(vf->pdev);
 
 	err = pdsc_dl_register(vf);
 	if (err)
 		return err;
 
-	return 0;
+	pf->vfs[vf->vf_id].vf = vf;
+	err = pdsc_auxbus_dev_add_vf(vf, pf);
+	if (err)
+		pdsc_dl_unregister(vf);
+
+	return err;
+}
+
+static void pdsc_del_vf(struct pdsc *vf)
+{
+	struct pdsc *pf;
+
+	pf = pdsc_get_pf_struct(vf->pdev);
+	if (IS_ERR(pf))
+		return;
+	pdsc_auxbus_dev_del_vf(vf, pf);
+	pf->vfs[vf->vf_id].vf = NULL;
 }
 
 #define PDSC_WQ_NAME_LEN 24
@@ -361,7 +382,13 @@ static void pdsc_remove(struct pci_dev *pdev)
 	 */
 	pdsc_dl_unregister(pdsc);
 
-	if (!pdev->is_virtfn) {
+	if (pdev->is_virtfn) {
+		pdsc_del_vf(pdsc);
+	} else {
+		/* Remove the VFs and their aux_bus connections before other
+		 * cleanup so that the clients can use the AdminQ to cleanly
+		 * shut themselves down.
+		 */
 		pdsc_sriov_configure(pdev, 0);
 
 		del_timer_sync(&pdsc->wdtimer);
@@ -401,6 +428,12 @@ static struct pci_driver pdsc_driver = {
 	.sriov_configure = pdsc_sriov_configure,
 };
 
+void *pdsc_get_pf_struct(struct pci_dev *vf_pdev)
+{
+	return pci_iov_get_pf_drvdata(vf_pdev, &pdsc_driver);
+}
+EXPORT_SYMBOL_GPL(pdsc_get_pf_struct);
+
 static int __init pdsc_init_module(void)
 {
 	pdsc_debugfs_create();
include/linux/pds/pds_auxbus.h new file +16 -0
new file mode 100644
index 000000000000..aa0192af4a29
@@ -0,0 +1,16 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright(c) 2023 Advanced Micro Devices, Inc */
+
+#ifndef _PDSC_AUXBUS_H_
+#define _PDSC_AUXBUS_H_
+
+#include <linux/auxiliary_bus.h>
+
+struct pds_auxiliary_dev {
+	struct auxiliary_device aux_dev;
+	struct pci_dev *vf_pdev;
+	struct pci_dev *pf_pdev;
+	u16 client_id;
+	void *priv;
+};
+#endif /* _PDSC_AUXBUS_H_ */
include/linux/pds/pds_common.h +1 -0
index 350295091d9d..898f3c7b14b7 100644
@@ -91,4 +91,5 @@ enum pds_core_logical_qtype {
 	PDS_CORE_QTYPE_MAX     = 16   /* don't change - used in struct size */
 };
 
+void *pdsc_get_pf_struct(struct pci_dev *vf_pdev);
 #endif /* _PDS_COMMON_H_ */
Signature · 1 line
2.17.1
#21 lore raw

PATCH v6 11/14 pds_core: devlink params for enabling VIF support

In reply to Shannon Nelson

Add the devlink parameter switches so the user can enable the features supported by the VFs.

---
 drivers/net/ethernet/amd/pds_core/devlink.c | 90 ++++++++++++++++++++-
 1 file changed, 89 insertions(+), 1 deletion(-)
drivers/net/ethernet/amd/pds_core/devlink.c +89 -1
index 17464b063009..45ab7e2e6528 100644
@@ -7,6 +7,87 @@
 #include <linux/pci.h>
 
 #include "core.h"
+#include <linux/pds/pds_auxbus.h>
+
+static struct
+pdsc_viftype *pdsc_dl_find_viftype_by_id(struct pdsc *pdsc,
+					 enum devlink_param_type dl_id)
+{
+	int vt;
+
+	for (vt = 0; vt < PDS_DEV_TYPE_MAX; vt++) {
+		if (pdsc->viftype_status[vt].dl_id == dl_id)
+			return &pdsc->viftype_status[vt];
+	}
+
+	return NULL;
+}
+
+static int pdsc_dl_enable_get(struct devlink *dl, u32 id,
+			      struct devlink_param_gset_ctx *ctx)
+{
+	struct pdsc *pdsc = devlink_priv(dl);
+	struct pdsc_viftype *vt_entry;
+
+	vt_entry = pdsc_dl_find_viftype_by_id(pdsc, id);
+	if (!vt_entry)
+		return -ENOENT;
+
+	ctx->val.vbool = vt_entry->enabled;
+
+	return 0;
+}
+
+static int pdsc_dl_enable_set(struct devlink *dl, u32 id,
+			      struct devlink_param_gset_ctx *ctx)
+{
+	struct pdsc *pdsc = devlink_priv(dl);
+	struct pdsc_viftype *vt_entry;
+	int err = 0;
+	int vf_id;
+
+	vt_entry = pdsc_dl_find_viftype_by_id(pdsc, id);
+	if (!vt_entry || !vt_entry->supported)
+		return -EOPNOTSUPP;
+
+	if (vt_entry->enabled == ctx->val.vbool)
+		return 0;
+
+	vt_entry->enabled = ctx->val.vbool;
+	for (vf_id = 0; vf_id < pdsc->num_vfs; vf_id++) {
+		struct pdsc *vf = pdsc->vfs[vf_id].vf;
+
+		err = ctx->val.vbool ? pdsc_auxbus_dev_add_vf(vf, pdsc) :
+				       pdsc_auxbus_dev_del_vf(vf, pdsc);
+	}
+
+	return err;
+}
+
+static int pdsc_dl_enable_validate(struct devlink *dl, u32 id,
+				   union devlink_param_value val,
+				   struct netlink_ext_ack *extack)
+{
+	struct pdsc *pdsc = devlink_priv(dl);
+	struct pdsc_viftype *vt_entry;
+
+	vt_entry = pdsc_dl_find_viftype_by_id(pdsc, id);
+	if (!vt_entry || !vt_entry->supported)
+		return -EOPNOTSUPP;
+
+	if (!pdsc->viftype_status[vt_entry->vif_id].supported)
+		return -ENODEV;
+
+	return 0;
+}
+
+static const struct devlink_param pdsc_dl_params[] = {
+	DEVLINK_PARAM_GENERIC(ENABLE_VNET,
+			      BIT(DEVLINK_PARAM_CMODE_RUNTIME),
+			      pdsc_dl_enable_get,
+			      pdsc_dl_enable_set,
+			      pdsc_dl_enable_validate),
+};
 
 static int pdsc_dl_flash_update(struct devlink *dl,
 				struct devlink_flash_update_params *params,
@@ -162,9 +243,16 @@ void pdsc_dl_free(struct pdsc *pdsc)
 int pdsc_dl_register(struct pdsc *pdsc)
 {
 	struct devlink *dl = priv_to_devlink(pdsc);
+	int err;
+
+	if (!pdsc->pdev->is_virtfn) {
+		err = devlink_params_register(dl, pdsc_dl_params,
+					      ARRAY_SIZE(pdsc_dl_params));
+		if (err)
+			return err;
 
-	if (!pdsc->pdev->is_virtfn)
 		pdsc_dl_reporters_create(pdsc);
+	}
 
 	devlink_register(dl);
 
Signature · 1 line
2.17.1
#22 lore raw

PATCH v6 12/14 pds_core: add the aux client API

In reply to Shannon Nelson

Add the client API operations for running adminq commands. The core registers the client with the FW, then the client has a context for requesting adminq services. We expect to add additional operations for other clients, including requesting additional private adminqs and IRQs, but don't have the need yet,

---
 drivers/net/ethernet/amd/pds_core/auxbus.c | 135 ++++++++++++++++++++-
 include/linux/pds/pds_auxbus.h             |  28 +++++
 2 files changed, 160 insertions(+), 3 deletions(-)
drivers/net/ethernet/amd/pds_core/auxbus.c +132 -3
index 7c6a84009558..2443339f73de 100644
@@ -6,6 +6,115 @@
 #include "core.h"
 #include <linux/pds/pds_auxbus.h>
 
+static int pds_client_register(struct pdsc *vf, struct pdsc *pf, char *name)
+{
+	union pds_core_adminq_comp comp = { 0 };
+	union pds_core_adminq_cmd cmd = { 0 };
+	int err;
+	u16 ci;
+
+	if (pf->state)
+		return -ENXIO;
+
+	cmd.client_reg.opcode = PDS_AQ_CMD_CLIENT_REG;
+	snprintf(cmd.client_reg.devname, sizeof(cmd.client_reg.devname),
+		 "%s.%s.%d", PDS_CORE_DRV_NAME, name, vf->id);
+
+	err = pdsc_adminq_post(pf, &cmd, &comp, false);
+	if (err) {
+		dev_info(pf->dev, "register dev_name %s with DSC failed, status %d: %pe\n",
+			 name, comp.status, ERR_PTR(err));
+		return err;
+	}
+
+	ci = le16_to_cpu(comp.client_reg.client_id);
+	if (!ci) {
+		dev_err(pf->dev, "%s: device returned null client_id\n",
+			__func__);
+		return -EIO;
+	}
+
+	dev_dbg(pf->dev, "%s: device returned client_id %d for %s\n",
+		__func__, ci, cmd.client_reg.devname);
+
+	return ci;
+}
+
+static int pds_client_unregister(struct pdsc *pf, u16 client_id)
+{
+	union pds_core_adminq_comp comp = { 0 };
+	union pds_core_adminq_cmd cmd = { 0 };
+	int err;
+
+	if (pf->state)
+		return -ENXIO;
+
+	cmd.client_unreg.opcode = PDS_AQ_CMD_CLIENT_UNREG;
+	cmd.client_unreg.client_id = cpu_to_le16(client_id);
+
+	err = pdsc_adminq_post(pf, &cmd, &comp, false);
+	if (err)
+		dev_info(pf->dev, "unregister client_id %d failed, status %d: %pe\n",
+			 client_id, comp.status, ERR_PTR(err));
+
+	return err;
+}
+
+/**
+ * pds_client_adminq_cmd - Process an adminq request for the client
+ * @padev:   ptr to the client device
+ * @req:     ptr to buffer with request
+ * @req_len: length of actual struct used for request
+ * @resp:    ptr to buffer where answer is to be copied
+ * @flags:   optional flags from pds_core_adminq_flags
+ *
+ * Return: 0 on success, or
+ *         negative for error
+ *
+ * Client sends pointers to request and response buffers
+ * Core copies request data into pds_core_client_request_cmd
+ * Core sets other fields as needed
+ * Core posts to AdminQ
+ * Core copies completion data into response buffer
+ */
+static int pds_client_adminq_cmd(struct pds_auxiliary_dev *padev,
+				 union pds_core_adminq_cmd *req,
+				 size_t req_len,
+				 union pds_core_adminq_comp *resp,
+				 u64 flags)
+{
+	union pds_core_adminq_cmd cmd = { 0 };
+	struct pdsc *pf;
+	size_t cp_len;
+	int err;
+
+	pf = pci_get_drvdata(padev->pf_pdev);
+
+	dev_dbg(pf->dev, "%s: %s opcode %d\n",
+		__func__, dev_name(&padev->aux_dev.dev), req->opcode);
+
+	if (pf->state)
+		return -ENXIO;
+
+	/* Wrap the client's request */
+	cmd.client_request.opcode = PDS_AQ_CMD_CLIENT_CMD;
+	cmd.client_request.client_id = cpu_to_le16(padev->client_id);
+	cp_len = min_t(size_t, req_len, sizeof(cmd.client_request.client_cmd));
+	memcpy(cmd.client_request.client_cmd, req, cp_len);
+
+	err = pdsc_adminq_post(pf, &cmd, resp,
+			       !!(flags & PDS_AQ_FLAG_FASTPOLL));
+	if (err && err != -EAGAIN)
+		dev_info(pf->dev, "client admin cmd failed: %pe\n",
+			 ERR_PTR(err));
+
+	return err;
+}
+
+static struct pds_core_ops pds_core_ops = {
+	.adminq_cmd = pds_client_adminq_cmd,
+};
+
 static void pdsc_auxbus_dev_release(struct device *dev)
 {
 	struct pds_auxiliary_dev *padev =
@@ -16,7 +125,9 @@ static void pdsc_auxbus_dev_release(struct device *dev)
 
 static struct pds_auxiliary_dev *pdsc_auxbus_dev_register(struct pdsc *vf,
 							  struct pdsc *pf,
-							  char *name)
+							  u16 client_id,
+							  char *name,
+							  struct pds_core_ops *ops)
 {
 	struct auxiliary_device *aux_dev;
 	struct pds_auxiliary_dev *padev;
@@ -28,6 +139,8 @@ static struct pds_auxiliary_dev *pdsc_auxbus_dev_register(struct pdsc *vf,
 
 	padev->vf_pdev = vf->pdev;
 	padev->pf_pdev = pf->pdev;
+	padev->ops = ops;
+	padev->client_id = client_id;
 
 	aux_dev = &padev->aux_dev;
 	aux_dev->name = name;
@@ -77,6 +190,8 @@ int pdsc_auxbus_dev_del_vf(struct pdsc *vf, struct pdsc *pf)
 
 	padev = pf->vfs[vf->vf_id].padev;
 	if (padev) {
+		pds_client_unregister(pf, padev->client_id);
+		padev->client_id = 0;
 		auxiliary_device_delete(&padev->aux_dev);
 		auxiliary_device_uninit(&padev->aux_dev);
 	}
@@ -91,6 +206,7 @@ int pdsc_auxbus_dev_add_vf(struct pdsc *vf, struct pdsc *pf)
 {
 	struct pds_auxiliary_dev *padev;
 	enum pds_core_vif_types vt;
+	int client_id;
 	int err = 0;
 
 	mutex_lock(&pf->config_lock);
@@ -124,9 +240,22 @@ int pdsc_auxbus_dev_add_vf(struct pdsc *vf, struct pdsc *pf)
 		      pf->viftype_status[vt].enabled))
 			continue;
 
-		padev = pdsc_auxbus_dev_register(vf, pf,
-						 pf->viftype_status[vt].name);
+		/* need to register with FW and get the client_id before
+		 * creating the aux device so that the aux client can run
+		 * adminq commands as part its probe
+		 */
+		client_id = pds_client_register(vf, pf,
+						pf->viftype_status[vt].name);
+		if (client_id < 0) {
+			err = client_id;
+			goto out_unlock;
+		}
+
+		padev = pdsc_auxbus_dev_register(vf, pf, client_id,
+						 pf->viftype_status[vt].name,
+						 &pds_core_ops);
 		if (IS_ERR(padev)) {
+			pds_client_unregister(pf, client_id);
 			err = PTR_ERR(padev);
 			goto out_unlock;
 		}
include/linux/pds/pds_auxbus.h +28 -0
index aa0192af4a29..f98efd578e1c 100644
@@ -10,7 +10,35 @@ struct pds_auxiliary_dev {
 	struct auxiliary_device aux_dev;
 	struct pci_dev *vf_pdev;
 	struct pci_dev *pf_pdev;
+	struct pds_core_ops *ops;
 	u16 client_id;
 	void *priv;
 };
+
+/*
+ *   ptrs to functions to be used by the client for core services
+ */
+struct pds_core_ops {
+	/* .adminq_cmd() - process an adminq request for the client
+	 * padev:  ptr to the client device
+	 * req:     ptr to buffer with request
+	 * req_len: length of actual struct used for request
+	 * resp:    ptr to buffer where answer is to be copied
+	 * flags:   optional flags defined by enum pds_core_adminq_flags
+	 *	    and used for more flexible adminq behvior
+	 *
+	 * returns 0 on success, or
+	 *         negative for error
+	 * Client sends pointers to request and response buffers
+	 * Core copies request data into pds_core_client_request_cmd
+	 * Core sets other fields as needed
+	 * Core posts to AdminQ
+	 * Core copies completion data into response buffer
+	 */
+	int (*adminq_cmd)(struct pds_auxiliary_dev *padev,
+			  union pds_core_adminq_cmd *req,
+			  size_t req_len,
+			  union pds_core_adminq_comp *resp,
+			  u64 flags);
+};
 #endif /* _PDSC_AUXBUS_H_ */
Signature · 1 line
2.17.1
#23 lore raw

PATCH v6 13/14 pds_core: publish events to the clients

In reply to Shannon Nelson

When the Core device gets an event from the device, or notices the device FW to be up or down, it needs to send those events on to the clients that have an event handler. Add the code to pass along the events to the clients.

---
 drivers/net/ethernet/amd/pds_core/adminq.c |  2 ++
 drivers/net/ethernet/amd/pds_core/core.c   | 32 ++++++++++++++++++++++
 drivers/net/ethernet/amd/pds_core/core.h   |  3 ++
 include/linux/pds/pds_common.h             |  2 ++
 4 files changed, 39 insertions(+)
drivers/net/ethernet/amd/pds_core/adminq.c +2 -0
index f9fb04308eff..4f86d1a917c1 100644
@@ -27,11 +27,13 @@ static int pdsc_process_notifyq(struct pdsc_qcq *qcq)
 		case PDS_EVENT_LINK_CHANGE:
 			dev_info(pdsc->dev, "NotifyQ LINK_CHANGE ecode %d eid %lld\n",
 				 ecode, eid);
+			pdsc_notify(PDS_EVENT_LINK_CHANGE, comp);
 			break;
 
 		case PDS_EVENT_RESET:
 			dev_info(pdsc->dev, "NotifyQ RESET ecode %d eid %lld\n",
 				 ecode, eid);
+			pdsc_notify(PDS_EVENT_RESET, comp);
 			break;
 
 		case PDS_EVENT_XCVR:
drivers/net/ethernet/amd/pds_core/core.c +32 -0
index 6b2884f64419..5322caa780f1 100644
@@ -5,6 +5,25 @@
 
 #include "core.h"
 
+static BLOCKING_NOTIFIER_HEAD(pds_notify_chain);
+
+int pdsc_register_notify(struct notifier_block *nb)
+{
+	return blocking_notifier_chain_register(&pds_notify_chain, nb);
+}
+EXPORT_SYMBOL_GPL(pdsc_register_notify);
+
+void pdsc_unregister_notify(struct notifier_block *nb)
+{
+	blocking_notifier_chain_unregister(&pds_notify_chain, nb);
+}
+EXPORT_SYMBOL_GPL(pdsc_unregister_notify);
+
+void pdsc_notify(unsigned long event, void *data)
+{
+	blocking_notifier_call_chain(&pds_notify_chain, event, data);
+}
+
 void pdsc_intr_free(struct pdsc *pdsc, int index)
 {
 	struct pdsc_intr_info *intr_info;
@@ -506,6 +525,11 @@ void pdsc_stop(struct pdsc *pdsc)
 
 static void pdsc_fw_down(struct pdsc *pdsc)
 {
+	union pds_core_notifyq_comp reset_event = {
+		.reset.ecode = cpu_to_le16(PDS_EVENT_RESET),
+		.reset.state = 0,
+	};
+
 	mutex_lock(&pdsc->config_lock);
 
 	if (test_and_set_bit(PDSC_S_FW_DEAD, &pdsc->state)) {
@@ -514,7 +538,9 @@ static void pdsc_fw_down(struct pdsc *pdsc)
 		return;
 	}
 
+	/* Notify clients of fw_down */
 	devlink_health_report(pdsc->fw_reporter, "FW down reported", pdsc);
+	pdsc_notify(PDS_EVENT_RESET, &reset_event);
 
 	pdsc_mask_interrupts(pdsc);
 	pdsc_teardown(pdsc, PDSC_TEARDOWN_RECOVERY);
@@ -524,6 +550,10 @@ static void pdsc_fw_down(struct pdsc *pdsc)
 
 static void pdsc_fw_up(struct pdsc *pdsc)
 {
+	union pds_core_notifyq_comp reset_event = {
+		.reset.ecode = cpu_to_le16(PDS_EVENT_RESET),
+		.reset.state = 1,
+	};
 	int err;
 
 	mutex_lock(&pdsc->config_lock);
@@ -544,9 +574,11 @@ static void pdsc_fw_up(struct pdsc *pdsc)
 
 	mutex_unlock(&pdsc->config_lock);
 
+	/* Notify clients of fw_up */
 	pdsc->fw_recoveries++;
 	devlink_health_reporter_state_update(pdsc->fw_reporter,
 					     DEVLINK_HEALTH_REPORTER_STATE_HEALTHY);
+	pdsc_notify(PDS_EVENT_RESET, &reset_event);
 
 	return;
 
drivers/net/ethernet/amd/pds_core/core.h +3 -0
index ce3598cf8de1..5ec31cc12b1d 100644
@@ -302,6 +302,9 @@ int pdsc_start(struct pdsc *pdsc);
 void pdsc_stop(struct pdsc *pdsc);
 void pdsc_health_thread(struct work_struct *work);
 
+int pdsc_register_notify(struct notifier_block *nb);
+void pdsc_unregister_notify(struct notifier_block *nb);
+void pdsc_notify(unsigned long event, void *data);
 int pdsc_auxbus_dev_add_vf(struct pdsc *vf, struct pdsc *pf);
 int pdsc_auxbus_dev_del_vf(struct pdsc *vf, struct pdsc *pf);
 
include/linux/pds/pds_common.h +2 -0
index 898f3c7b14b7..17708a142349 100644
@@ -91,5 +91,7 @@ enum pds_core_logical_qtype {
 	PDS_CORE_QTYPE_MAX     = 16   /* don't change - used in struct size */
 };
 
+int pdsc_register_notify(struct notifier_block *nb);
+void pdsc_unregister_notify(struct notifier_block *nb);
 void *pdsc_get_pf_struct(struct pci_dev *vf_pdev);
 #endif /* _PDS_COMMON_H_ */
Signature · 1 line
2.17.1
#24 lore raw

PATCH v6 14/14 pds_core: Kconfig and pds_core.rst

In reply to Shannon Nelson

Documentation and Kconfig hook for building the driver.

---
 .../device_drivers/ethernet/amd/pds_core.rst  | 143 ++++++++++++++++++
 .../device_drivers/ethernet/index.rst         |   1 +
 MAINTAINERS                                   |   9 ++
 drivers/net/ethernet/amd/Kconfig              |  12 ++
 drivers/net/ethernet/amd/Makefile             |   1 +
 5 files changed, 166 insertions(+)
 create mode 100644 Documentation/networking/device_drivers/ethernet/amd/pds_core.rst
Documentation/networking/device_drivers/ethernet/amd/pds_core.rst new file +143 -0
new file mode 100644
index 000000000000..16ed45baa81b
@@ -0,0 +1,143 @@
+.. SPDX-License-Identifier: GPL-2.0+
+
+========================================================
+Linux Driver for the AMD/Pensando(R) DSC adapter family
+========================================================
+
+Copyright(c) 2023 Advanced Micro Devices, Inc
+
+Identifying the Adapter
+=======================
+
+To find if one or more AMD/Pensando PCI Core devices are installed on the
+host, check for the PCI devices::
+
+  # lspci -d 1dd8:100c
+  b5:00.0 Processing accelerators: Pensando Systems Device 100c
+  b6:00.0 Processing accelerators: Pensando Systems Device 100c
+
+If such devices are listed as above, then the pds_core.ko driver should find
+and configure them for use.  There should be log entries in the kernel
+messages such as these::
+
+  $ dmesg | grep pds_core
+  pds_core 0000:b5:00.0: 252.048 Gb/s available PCIe bandwidth (16.0 GT/s PCIe x16 link)
+  pds_core 0000:b5:00.0: FW: 1.60.0-73
+  pds_core 0000:b6:00.0: 252.048 Gb/s available PCIe bandwidth (16.0 GT/s PCIe x16 link)
+  pds_core 0000:b6:00.0: FW: 1.60.0-73
+
+Driver and firmware version information can be gathered with devlink::
+
+  $ devlink dev info pci/0000:b5:00.0
+  pci/0000:b5:00.0:
+    driver pds_core
+    serial_number FLM18420073
+    versions:
+        fixed:
+          asic.id 0x0
+          asic.rev 0x0
+        running:
+          fw 1.51.0-73
+        stored:
+          fw.goldfw 1.15.9-C-22
+          fw.mainfwa 1.60.0-73
+          fw.mainfwb 1.60.0-57
+
+
+Info versions
+=============
+
+The ``pds_core`` driver reports the following versions
+
+.. list-table:: devlink info versions implemented
+   :widths: 5 5 90
+
+   * - Name
+     - Type
+     - Description
+   * - ``fw``
+     - running
+     - Version of firmware running on the device
+   * - ``fw.goldfw``
+     - stored
+     - Version of firmware stored in the goldfw slot
+   * - ``fw.mainfwa``
+     - stored
+     - Version of firmware stored in the mainfwa slot
+   * - ``fw.mainfwb``
+     - stored
+     - Version of firmware stored in the mainfwb slot
+   * - ``asic.id``
+     - fixed
+     - The ASIC type for this device
+   * - ``asic.rev``
+     - fixed
+     - The revision of the ASIC for this device
+
+
+Parameters
+==========
+
+The ``pds_core`` driver implements the following generic
+parameters for controlling the functionality to be made available
+as auxiliary_bus devices.
+
+.. list-table:: Generic parameters implemented
+   :widths: 5 5 8 82
+
+   * - Name
+     - Mode
+     - Type
+     - Description
+   * - ``enable_vnet``
+     - runtime
+     - Boolean
+     - Enables vDPA functionality through an auxiliary_bus device
+
+
+Firmware Management
+===================
+
+The ``flash`` command can update a the DSC firmware.  The downloaded firmware
+will be saved into either of firmware bank 1 or bank 2, whichever is not
+currrently in use, and that bank will be then selected for the next boot.
+
+Health Reporters
+================
+
+The driver supports a devlink health reporter for FW status::
+
+  # devlink health show pci/0000:2b:00.0 reporter fw
+  pci/0000:2b:00.0:
+    reporter fw
+      state healthy error 0 recover 0
+
+
+Enabling the driver
+===================
+
+The driver is enabled via the standard kernel configuration system,
+using the make command::
+
+  make oldconfig/menuconfig/etc.
+
+The driver is located in the menu structure at:
+
+  -> Device Drivers
+    -> Network device support (NETDEVICES [=y])
+      -> Ethernet driver support
+        -> AMD devices
+          -> AMD/Pensando Ethernet PDS_CORE Support
+
+Support
+=======
+
+For general Linux networking support, please use the netdev mailing
+list, which is monitored by AMD/Pensando personnel::
+
+  [email protected]
+
+For more specific support needs, please use the AMD/Pensando driver support
+email::
+
+  [email protected]
Documentation/networking/device_drivers/ethernet/index.rst +1 -0
index 6e9e7012d000..eaaf284e69e6 100644
@@ -13,6 +13,7 @@ Contents:
    3com/3c509
    3com/vortex
    amazon/ena
+   amd/pds_core
    altera/altera_tse
    aquantia/atlantic
    chelsio/cxgb
MAINTAINERS +9 -0
index 30ca644d704f..95b5f25a2c06 100644
@@ -1041,6 +1041,15 @@ F:	drivers/gpu/drm/amd/include/vi_structs.h
 F:	include/uapi/linux/kfd_ioctl.h
 F:	include/uapi/linux/kfd_sysfs.h
 
+AMD PDS CORE DRIVER
+M:	Shannon Nelson <[email protected]>
+M:	Brett Creeley <[email protected]>
+M:	[email protected]
+L:	[email protected]
+S:	Supported
+F:	Documentation/networking/device_drivers/ethernet/amd/pds_core.rst
+F:	drivers/net/ethernet/amd/pds_core/
+
 AMD SPI DRIVER
 M:	Sanjay R Mehta <[email protected]>
 S:	Maintained
drivers/net/ethernet/amd/Kconfig +12 -0
index ab42f75b9413..235fcacef5c5 100644
@@ -186,4 +186,16 @@ config AMD_XGBE_HAVE_ECC
 	bool
 	default n
 
+config PDS_CORE
+	tristate "AMD/Pensando Data Systems Core Device Support"
+	depends on 64BIT && PCI
+	help
+	  This enables the support for the AMD/Pensando Core device family of
+	  adapters.  More specific information on this driver can be
+	  found in
+	  <file:Documentation/networking/device_drivers/ethernet/amd/pds_core.rst>.
+
+	  To compile this driver as a module, choose M here. The module
+	  will be called pds_core.
+
 endif # NET_VENDOR_AMD
drivers/net/ethernet/amd/Makefile +1 -0
index 42742afe9115..2dcfb84731e1 100644
@@ -17,3 +17,4 @@ obj-$(CONFIG_PCNET32) += pcnet32.o
 obj-$(CONFIG_SUN3LANCE) += sun3lance.o
 obj-$(CONFIG_SUNLANCE) += sunlance.o
 obj-$(CONFIG_AMD_XGBE) += xgbe/
+obj-$(CONFIG_PDS_CORE) += pds_core/
Signature · 1 line
2.17.1
#25 lore raw

Re: [PATCH v6 net-next 14/14] pds_core: Kconfig and pds_core.rst

I love your patch! Yet something to improve:

Hi Shannon,

I love your patch! Yet something to improve:

[auto build test ERROR on net-next/main]

url:    https://github.com/intel-lab-lkp/linux/commits/Shannon-Nelson/pds_core-initial-framework-for-pds_core-PF-driver/20230325-030501
patch link:    https://lore.kernel.org/r/20230324190243.27722-15-shannon.nelson%40amd.com
patch subject: [PATCH v6 net-next 14/14] pds_core: Kconfig and pds_core.rst
config: mips-randconfig-r006-20230326 (https://download.01.org/0day-ci/archive/20230326/[email protected]/config)
compiler: mips64-linux-gcc (GCC) 12.1.0

reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# https://github.com/intel-lab-lkp/linux/commit/dd8c8b0ffae4db2f83e11b696198afa72d99c1b0
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Shannon-Nelson/pds_core-initial-framework-for-pds_core-PF-driver/20230325-030501 git checkout dd8c8b0ffae4db2f83e11b696198afa72d99c1b0
# save the config file
mkdir build_dir && cp config build_dir/.config
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-12.1.0 make.cross W=1 O=build_dir ARCH=mips olddefconfig COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-12.1.0 make.cross W=1 O=build_dir ARCH=mips SHELL=/bin/bash drivers/net/ethernet/amd/pds_core/

If you fix the issue, kindly add following tag where applicable
| Reported-by: kernel test robot <[email protected]>
| Link: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All error/warnings (new ones prefixed by >>):

drivers/net/ethernet/amd/pds_core/core.c: In function 'pdsc_qcq_free':

>> drivers/net/ethernet/amd/pds_core/core.c:161:17: error: implicit declaration of function 'vfree'; did you mean 'kvfree'? [-Werror=implicit-function-declaration]
     161 |                 vfree(qcq->cq.info);
         |                 ^~~~~
         |                 kvfree
   drivers/net/ethernet/amd/pds_core/core.c: In function 'pdsc_qcq_alloc':
>> drivers/net/ethernet/amd/pds_core/core.c:209:23: error: implicit declaration of function 'vzalloc'; did you mean 'kvzalloc'? [-Werror=implicit-function-declaration]
     209 |         qcq->q.info = vzalloc(num_descs * sizeof(*qcq->q.info));
         |                       ^~~~~~~
         |                       kvzalloc
>> drivers/net/ethernet/amd/pds_core/core.c:209:21: warning: assignment to 'struct pdsc_q_info *' from 'int' makes pointer from integer without a cast [-Wint-conversion]
     209 |         qcq->q.info = vzalloc(num_descs * sizeof(*qcq->q.info));
         |                     ^
>> drivers/net/ethernet/amd/pds_core/core.c:232:22: warning: assignment to 'struct pdsc_cq_info *' from 'int' makes pointer from integer without a cast [-Wint-conversion]
     232 |         qcq->cq.info = vzalloc(num_descs * sizeof(*qcq->cq.info));
         |                      ^

cc1: some warnings being treated as errors

vim +161 drivers/net/ethernet/amd/pds_core/core.c

520bb62de695d83 Shannon Nelson 2023-03-24  134  
520bb62de695d83 Shannon Nelson 2023-03-24  135  void pdsc_qcq_free(struct pdsc *pdsc, struct pdsc_qcq *qcq)
520bb62de695d83 Shannon Nelson 2023-03-24  136  {
520bb62de695d83 Shannon Nelson 2023-03-24  137  	struct device *dev = pdsc->dev;
520bb62de695d83 Shannon Nelson 2023-03-24  138  
520bb62de695d83 Shannon Nelson 2023-03-24  139  	if (!(qcq && qcq->pdsc))
520bb62de695d83 Shannon Nelson 2023-03-24  140  		return;
520bb62de695d83 Shannon Nelson 2023-03-24  141  
520bb62de695d83 Shannon Nelson 2023-03-24  142  	pdsc_debugfs_del_qcq(qcq);
520bb62de695d83 Shannon Nelson 2023-03-24  143  
520bb62de695d83 Shannon Nelson 2023-03-24  144  	pdsc_qcq_intr_free(pdsc, qcq);
520bb62de695d83 Shannon Nelson 2023-03-24  145  
520bb62de695d83 Shannon Nelson 2023-03-24  146  	if (qcq->q_base) {
520bb62de695d83 Shannon Nelson 2023-03-24  147  		dma_free_coherent(dev, qcq->q_size,
520bb62de695d83 Shannon Nelson 2023-03-24  148  				  qcq->q_base, qcq->q_base_pa);
520bb62de695d83 Shannon Nelson 2023-03-24  149  		qcq->q_base = NULL;
520bb62de695d83 Shannon Nelson 2023-03-24  150  		qcq->q_base_pa = 0;
520bb62de695d83 Shannon Nelson 2023-03-24  151  	}
520bb62de695d83 Shannon Nelson 2023-03-24  152  
520bb62de695d83 Shannon Nelson 2023-03-24  153  	if (qcq->cq_base) {
520bb62de695d83 Shannon Nelson 2023-03-24  154  		dma_free_coherent(dev, qcq->cq_size,
520bb62de695d83 Shannon Nelson 2023-03-24  155  				  qcq->cq_base, qcq->cq_base_pa);
520bb62de695d83 Shannon Nelson 2023-03-24  156  		qcq->cq_base = NULL;
520bb62de695d83 Shannon Nelson 2023-03-24  157  		qcq->cq_base_pa = 0;
520bb62de695d83 Shannon Nelson 2023-03-24  158  	}
520bb62de695d83 Shannon Nelson 2023-03-24  159  
520bb62de695d83 Shannon Nelson 2023-03-24  160  	if (qcq->cq.info) {
520bb62de695d83 Shannon Nelson 2023-03-24 @161  		vfree(qcq->cq.info);
520bb62de695d83 Shannon Nelson 2023-03-24  162  		qcq->cq.info = NULL;
520bb62de695d83 Shannon Nelson 2023-03-24  163  	}
520bb62de695d83 Shannon Nelson 2023-03-24  164  	if (qcq->q.info) {
520bb62de695d83 Shannon Nelson 2023-03-24  165  		vfree(qcq->q.info);
520bb62de695d83 Shannon Nelson 2023-03-24  166  		qcq->q.info = NULL;
520bb62de695d83 Shannon Nelson 2023-03-24  167  	}
520bb62de695d83 Shannon Nelson 2023-03-24  168  
520bb62de695d83 Shannon Nelson 2023-03-24  169  	qcq->pdsc = NULL;
520bb62de695d83 Shannon Nelson 2023-03-24  170  	memset(&qcq->q, 0, sizeof(qcq->q));
520bb62de695d83 Shannon Nelson 2023-03-24  171  	memset(&qcq->cq, 0, sizeof(qcq->cq));
520bb62de695d83 Shannon Nelson 2023-03-24  172  }
520bb62de695d83 Shannon Nelson 2023-03-24  173  
520bb62de695d83 Shannon Nelson 2023-03-24  174  static void pdsc_q_map(struct pdsc_queue *q, void *base, dma_addr_t base_pa)
520bb62de695d83 Shannon Nelson 2023-03-24  175  {
520bb62de695d83 Shannon Nelson 2023-03-24  176  	struct pdsc_q_info *cur;
520bb62de695d83 Shannon Nelson 2023-03-24  177  	unsigned int i;
520bb62de695d83 Shannon Nelson 2023-03-24  178  
520bb62de695d83 Shannon Nelson 2023-03-24  179  	q->base = base;
520bb62de695d83 Shannon Nelson 2023-03-24  180  	q->base_pa = base_pa;
520bb62de695d83 Shannon Nelson 2023-03-24  181  
520bb62de695d83 Shannon Nelson 2023-03-24  182  	for (i = 0, cur = q->info; i < q->num_descs; i++, cur++)
520bb62de695d83 Shannon Nelson 2023-03-24  183  		cur->desc = base + (i * q->desc_size);
520bb62de695d83 Shannon Nelson 2023-03-24  184  }
520bb62de695d83 Shannon Nelson 2023-03-24  185  
520bb62de695d83 Shannon Nelson 2023-03-24  186  static void pdsc_cq_map(struct pdsc_cq *cq, void *base, dma_addr_t base_pa)
520bb62de695d83 Shannon Nelson 2023-03-24  187  {
520bb62de695d83 Shannon Nelson 2023-03-24  188  	struct pdsc_cq_info *cur;
520bb62de695d83 Shannon Nelson 2023-03-24  189  	unsigned int i;
520bb62de695d83 Shannon Nelson 2023-03-24  190  
520bb62de695d83 Shannon Nelson 2023-03-24  191  	cq->base = base;
520bb62de695d83 Shannon Nelson 2023-03-24  192  	cq->base_pa = base_pa;
520bb62de695d83 Shannon Nelson 2023-03-24  193  
520bb62de695d83 Shannon Nelson 2023-03-24  194  	for (i = 0, cur = cq->info; i < cq->num_descs; i++, cur++)
520bb62de695d83 Shannon Nelson 2023-03-24  195  		cur->comp = base + (i * cq->desc_size);
520bb62de695d83 Shannon Nelson 2023-03-24  196  }
520bb62de695d83 Shannon Nelson 2023-03-24  197  
520bb62de695d83 Shannon Nelson 2023-03-24  198  int pdsc_qcq_alloc(struct pdsc *pdsc, unsigned int type, unsigned int index,
520bb62de695d83 Shannon Nelson 2023-03-24  199  		   const char *name, unsigned int flags, unsigned int num_descs,
520bb62de695d83 Shannon Nelson 2023-03-24  200  		   unsigned int desc_size, unsigned int cq_desc_size,
520bb62de695d83 Shannon Nelson 2023-03-24  201  		   unsigned int pid, struct pdsc_qcq *qcq)
520bb62de695d83 Shannon Nelson 2023-03-24  202  {
520bb62de695d83 Shannon Nelson 2023-03-24  203  	struct device *dev = pdsc->dev;
520bb62de695d83 Shannon Nelson 2023-03-24  204  	dma_addr_t cq_base_pa = 0;
520bb62de695d83 Shannon Nelson 2023-03-24  205  	dma_addr_t q_base_pa = 0;
520bb62de695d83 Shannon Nelson 2023-03-24  206  	void *q_base, *cq_base;
520bb62de695d83 Shannon Nelson 2023-03-24  207  	int err;
520bb62de695d83 Shannon Nelson 2023-03-24  208  
520bb62de695d83 Shannon Nelson 2023-03-24 @209  	qcq->q.info = vzalloc(num_descs * sizeof(*qcq->q.info));
520bb62de695d83 Shannon Nelson 2023-03-24  210  	if (!qcq->q.info) {
520bb62de695d83 Shannon Nelson 2023-03-24  211  		err = -ENOMEM;
520bb62de695d83 Shannon Nelson 2023-03-24  212  		goto err_out;
520bb62de695d83 Shannon Nelson 2023-03-24  213  	}
520bb62de695d83 Shannon Nelson 2023-03-24  214  
520bb62de695d83 Shannon Nelson 2023-03-24  215  	qcq->pdsc = pdsc;
520bb62de695d83 Shannon Nelson 2023-03-24  216  	qcq->flags = flags;
520bb62de695d83 Shannon Nelson 2023-03-24  217  	INIT_WORK(&qcq->work, pdsc_work_thread);
520bb62de695d83 Shannon Nelson 2023-03-24  218  
520bb62de695d83 Shannon Nelson 2023-03-24  219  	qcq->q.type = type;
520bb62de695d83 Shannon Nelson 2023-03-24  220  	qcq->q.index = index;
520bb62de695d83 Shannon Nelson 2023-03-24  221  	qcq->q.num_descs = num_descs;
520bb62de695d83 Shannon Nelson 2023-03-24  222  	qcq->q.desc_size = desc_size;
520bb62de695d83 Shannon Nelson 2023-03-24  223  	qcq->q.tail_idx = 0;
520bb62de695d83 Shannon Nelson 2023-03-24  224  	qcq->q.head_idx = 0;
520bb62de695d83 Shannon Nelson 2023-03-24  225  	qcq->q.pid = pid;
520bb62de695d83 Shannon Nelson 2023-03-24  226  	snprintf(qcq->q.name, sizeof(qcq->q.name), "%s%u", name, index);
520bb62de695d83 Shannon Nelson 2023-03-24  227  
520bb62de695d83 Shannon Nelson 2023-03-24  228  	err = pdsc_qcq_intr_alloc(pdsc, qcq);
520bb62de695d83 Shannon Nelson 2023-03-24  229  	if (err)
520bb62de695d83 Shannon Nelson 2023-03-24  230  		goto err_out_free_q_info;
520bb62de695d83 Shannon Nelson 2023-03-24  231  
520bb62de695d83 Shannon Nelson 2023-03-24 @232  	qcq->cq.info = vzalloc(num_descs * sizeof(*qcq->cq.info));
520bb62de695d83 Shannon Nelson 2023-03-24  233  	if (!qcq->cq.info) {
520bb62de695d83 Shannon Nelson 2023-03-24  234  		err = -ENOMEM;
520bb62de695d83 Shannon Nelson 2023-03-24  235  		goto err_out_free_irq;
520bb62de695d83 Shannon Nelson 2023-03-24  236  	}
520bb62de695d83 Shannon Nelson 2023-03-24  237  
520bb62de695d83 Shannon Nelson 2023-03-24  238  	qcq->cq.bound_intr = &pdsc->intr_info[qcq->intx];
520bb62de695d83 Shannon Nelson 2023-03-24  239  	qcq->cq.num_descs = num_descs;
520bb62de695d83 Shannon Nelson 2023-03-24  240  	qcq->cq.desc_size = cq_desc_size;
520bb62de695d83 Shannon Nelson 2023-03-24  241  	qcq->cq.tail_idx = 0;
520bb62de695d83 Shannon Nelson 2023-03-24  242  	qcq->cq.done_color = 1;
520bb62de695d83 Shannon Nelson 2023-03-24  243  
520bb62de695d83 Shannon Nelson 2023-03-24  244  	if (flags & PDS_CORE_QCQ_F_NOTIFYQ) {
520bb62de695d83 Shannon Nelson 2023-03-24  245  		/* q & cq need to be contiguous in case of notifyq */
520bb62de695d83 Shannon Nelson 2023-03-24  246  		qcq->q_size = PDS_PAGE_SIZE +
520bb62de695d83 Shannon Nelson 2023-03-24  247  			      ALIGN(num_descs * desc_size, PDS_PAGE_SIZE) +
520bb62de695d83 Shannon Nelson 2023-03-24  248  			      ALIGN(num_descs * cq_desc_size, PDS_PAGE_SIZE);
520bb62de695d83 Shannon Nelson 2023-03-24  249  		qcq->q_base = dma_alloc_coherent(dev,
520bb62de695d83 Shannon Nelson 2023-03-24  250  						 qcq->q_size + qcq->cq_size,
520bb62de695d83 Shannon Nelson 2023-03-24  251  						 &qcq->q_base_pa,
520bb62de695d83 Shannon Nelson 2023-03-24  252  						 GFP_KERNEL);
520bb62de695d83 Shannon Nelson 2023-03-24  253  		if (!qcq->q_base) {
520bb62de695d83 Shannon Nelson 2023-03-24  254  			err = -ENOMEM;
520bb62de695d83 Shannon Nelson 2023-03-24  255  			goto err_out_free_cq_info;
520bb62de695d83 Shannon Nelson 2023-03-24  256  		}
520bb62de695d83 Shannon Nelson 2023-03-24  257  		q_base = PTR_ALIGN(qcq->q_base, PDS_PAGE_SIZE);
520bb62de695d83 Shannon Nelson 2023-03-24  258  		q_base_pa = ALIGN(qcq->q_base_pa, PDS_PAGE_SIZE);
520bb62de695d83 Shannon Nelson 2023-03-24  259  		pdsc_q_map(&qcq->q, q_base, q_base_pa);
520bb62de695d83 Shannon Nelson 2023-03-24  260  
520bb62de695d83 Shannon Nelson 2023-03-24  261  		cq_base = PTR_ALIGN(q_base +
520bb62de695d83 Shannon Nelson 2023-03-24  262  				    ALIGN(num_descs * desc_size, PDS_PAGE_SIZE),
520bb62de695d83 Shannon Nelson 2023-03-24  263  				    PDS_PAGE_SIZE);
520bb62de695d83 Shannon Nelson 2023-03-24  264  		cq_base_pa = ALIGN(qcq->q_base_pa +
520bb62de695d83 Shannon Nelson 2023-03-24  265  				   ALIGN(num_descs * desc_size, PDS_PAGE_SIZE),
520bb62de695d83 Shannon Nelson 2023-03-24  266  				   PDS_PAGE_SIZE);
520bb62de695d83 Shannon Nelson 2023-03-24  267  
520bb62de695d83 Shannon Nelson 2023-03-24  268  	} else {
520bb62de695d83 Shannon Nelson 2023-03-24  269  		/* q DMA descriptors */
520bb62de695d83 Shannon Nelson 2023-03-24  270  		qcq->q_size = PDS_PAGE_SIZE + (num_descs * desc_size);
520bb62de695d83 Shannon Nelson 2023-03-24  271  		qcq->q_base = dma_alloc_coherent(dev, qcq->q_size,
520bb62de695d83 Shannon Nelson 2023-03-24  272  						 &qcq->q_base_pa,
520bb62de695d83 Shannon Nelson 2023-03-24  273  						 GFP_KERNEL);
520bb62de695d83 Shannon Nelson 2023-03-24  274  		if (!qcq->q_base) {
520bb62de695d83 Shannon Nelson 2023-03-24  275  			err = -ENOMEM;
520bb62de695d83 Shannon Nelson 2023-03-24  276  			goto err_out_free_cq_info;
520bb62de695d83 Shannon Nelson 2023-03-24  277  		}
520bb62de695d83 Shannon Nelson 2023-03-24  278  		q_base = PTR_ALIGN(qcq->q_base, PDS_PAGE_SIZE);
520bb62de695d83 Shannon Nelson 2023-03-24  279  		q_base_pa = ALIGN(qcq->q_base_pa, PDS_PAGE_SIZE);
520bb62de695d83 Shannon Nelson 2023-03-24  280  		pdsc_q_map(&qcq->q, q_base, q_base_pa);
520bb62de695d83 Shannon Nelson 2023-03-24  281  
520bb62de695d83 Shannon Nelson 2023-03-24  282  		/* cq DMA descriptors */
520bb62de695d83 Shannon Nelson 2023-03-24  283  		qcq->cq_size = PDS_PAGE_SIZE + (num_descs * cq_desc_size);
520bb62de695d83 Shannon Nelson 2023-03-24  284  		qcq->cq_base = dma_alloc_coherent(dev, qcq->cq_size,
520bb62de695d83 Shannon Nelson 2023-03-24  285  						  &qcq->cq_base_pa,
520bb62de695d83 Shannon Nelson 2023-03-24  286  						  GFP_KERNEL);
520bb62de695d83 Shannon Nelson 2023-03-24  287  		if (!qcq->cq_base) {
520bb62de695d83 Shannon Nelson 2023-03-24  288  			err = -ENOMEM;
520bb62de695d83 Shannon Nelson 2023-03-24  289  			goto err_out_free_q;
520bb62de695d83 Shannon Nelson 2023-03-24  290  		}
520bb62de695d83 Shannon Nelson 2023-03-24  291  		cq_base = PTR_ALIGN(qcq->cq_base, PDS_PAGE_SIZE);
520bb62de695d83 Shannon Nelson 2023-03-24  292  		cq_base_pa = ALIGN(qcq->cq_base_pa, PDS_PAGE_SIZE);
520bb62de695d83 Shannon Nelson 2023-03-24  293  	}
520bb62de695d83 Shannon Nelson 2023-03-24  294  
520bb62de695d83 Shannon Nelson 2023-03-24  295  	pdsc_cq_map(&qcq->cq, cq_base, cq_base_pa);
520bb62de695d83 Shannon Nelson 2023-03-24  296  	qcq->cq.bound_q = &qcq->q;
520bb62de695d83 Shannon Nelson 2023-03-24  297  
520bb62de695d83 Shannon Nelson 2023-03-24  298  	pdsc_debugfs_add_qcq(pdsc, qcq);
520bb62de695d83 Shannon Nelson 2023-03-24  299  
520bb62de695d83 Shannon Nelson 2023-03-24  300  	return 0;
520bb62de695d83 Shannon Nelson 2023-03-24  301  
520bb62de695d83 Shannon Nelson 2023-03-24  302  err_out_free_q:
520bb62de695d83 Shannon Nelson 2023-03-24  303  	dma_free_coherent(dev, qcq->q_size, qcq->q_base, qcq->q_base_pa);
520bb62de695d83 Shannon Nelson 2023-03-24  304  err_out_free_cq_info:
520bb62de695d83 Shannon Nelson 2023-03-24  305  	vfree(qcq->cq.info);
520bb62de695d83 Shannon Nelson 2023-03-24  306  err_out_free_irq:
520bb62de695d83 Shannon Nelson 2023-03-24  307  	pdsc_qcq_intr_free(pdsc, qcq);
520bb62de695d83 Shannon Nelson 2023-03-24  308  err_out_free_q_info:
520bb62de695d83 Shannon Nelson 2023-03-24  309  	vfree(qcq->q.info);
520bb62de695d83 Shannon Nelson 2023-03-24  310  	memset(qcq, 0, sizeof(*qcq));
520bb62de695d83 Shannon Nelson 2023-03-24  311  err_out:
520bb62de695d83 Shannon Nelson 2023-03-24  312  	dev_err(dev, "qcq alloc of %s%d failed %d\n", name, index, err);
520bb62de695d83 Shannon Nelson 2023-03-24  313  	return err;
520bb62de695d83 Shannon Nelson 2023-03-24  314  }
520bb62de695d83 Shannon Nelson 2023-03-24  315  
Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests