Skip to contentSkip to conversation

PCI Data Object Exchange support + CXL CDAT

RFC PATCH Superseded Jonathan Cameron 5 participants 13 messages Apr 13, 2021 – Apr 14, 2021

Subsystems (3)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

v2 cover PCI Data Object Exchange support + CXL CDAT

Change logs in individual patches.

There are several options for how to implement the DOE support in the kernel. This cover letter will try to assess the main decision to be made in this series.

sync vs single threaded workqueue vs delayed work
=================================================

The DOE works via single input and output registers + some control flags. Protocols are of the query/response type with a short standard header in both followed by protocol specific data. A given DOE instance can support multiple protocols, though individual protocol specifications often limit what combinations are allowed.

Constraints on DOE queue handling.
1. Only a single query/response can be in flight at a time (*)
2. Need to handle timeouts on interrupt, or polling otherwise.

* Not strictly true. The DOE ECN allows for interleaving of multiple query/response pairs as long as only one is in flight for a given protocol at any given time. However, the DOE may use the BUSY status bit to require software to not write a new request to the device. As there is no defined way of knowing when the BUSY bit is no longer set other than polling, such an operating mode cannot sensibly be used in conjunction with interrupts (which indicate response ready or error). Given the current usecases of DOE and restrictions protocols specifications place on what other protocols they can share a DOE instance with, it seems unlikely that this level of interleaving is worth the complexity it would add.

Let us term a query/response sequence an exchange.

Approaches investigated:
1. Serialize using a mutex. This either makes exchange operations synchronous or requires a per caller thread. This was the approach in RFC v1. Long sleeps are possible as the protocol allows the response generation to take up to 1 second.
2. Use a single threaded workqueue to serialise exchanges.
Each exchange uses a separate work_struct. Long sleeps can occur within the work items. Note that one of the original stated reasons for the introduction of single threaded workqueues was to cater for work items which can sleep for a long time. This approach is naturally asynchronous, but a trival wrapper can be used to provide a convient synchronous calling API (I have code doing this, works fine but not posted as doesn't avoid long sleeps and discussion around v1 suggested we should do avoid them).
3. Use a single delayed work item to implement a state machine. Queuing is handled via a list to which query/response pairs are added. Any delayed action or timeout is handled via schedule_delayed_work() with interrupts using mod_delayed_work() to immediately advance the state machine. There is no reason to use a dedicated work queue, as here serialization is handled using the exchange list. The proposal in this patch set.

Note I was unable to find any sensible way to combine 2 and 3, that is to use both a delayed work approach to avoid timeouts in work items and a single threaded workqueue to handle ordering + synchronization. Either such an approach would have ended up with one work item just being responsible for scheduling items on a different work queue, or it requires the ability to insert work items at the front of single threaded work queue (to ensure the next step of the state machine for the current exchange runs before a step of the next exchange).

Relative complexity
-------------------

1. (mutex) Very simple.
2. (single thread workqueue) Fairly simple.
3. (delayed work) Most complex (particularly around abort handling).

Fairness
--------

Fairness considered to be work done in order of submission.
1. Potentially unfair given simple lock being used to seralize.
2. Fair as first come first seved.
3. Fair as manual list implementation of first come first served.

Sync vs Async
-------------

Whilst it's not clear there will actually be any async usecases, lets consider how this works.
1. (mutex) Caller implements - either long sleeps in sync, or long sleeps in a thread to which sync operation off loaded.
2. (single thread workqueue) Async is natural state, with sync implemented as wrapper around async. Effectively same as spinning off to a thread in 1.
3. (delayed work) Async is natural state, with sync implemented as wrapper around async.

Decision comes down to trading off complexity against advantages of naturally async operation that avoids sleeping inside a work item / thread / caller.

Cover letter from v1:
https://lore.kernel.org/linux-pci/[email protected]/

Series first introduces generic support for DOE mailboxes as defined in the ECN to the PCI 5.0 specification available from the PCI SIG [0]

A user is then introduced in the form of the table access protocol defined in the CXL 2.0 specification [1] used to access the
Coherent Device Attribtue Table (CDAT) defined in [2]

Various open questions in the individual patches.

All testing conducted against QEMU emulation of a CXL type 3 device in conjunction with DOE mailbox patches [3, 4]

[0] https://pcisig.com/specifications
[1] https://www.computeexpresslink.org/download-the-specification
[2] https://uefi.org/node/4093
[3] https://lore.kernel.org/qemu-devel/[email protected]/
[4] https://lore.kernel.org/qemu-devel/[email protected]/

Jonathan Cameron (4):
PCI: Add vendor define ID for the PCI SIG PCI/doe: Initial support PCI Data Object Exchange cxl/mem: Add CDAT table reading from DOE cxl/mem: Add a debug parser for CDAT commands.

 drivers/cxl/Kconfig           |   1 +
 drivers/cxl/cdat.h            |  79 +++++
 drivers/cxl/cxl.h             |  13 +
 drivers/cxl/mem.c             | 279 ++++++++++++++++
 drivers/pci/pcie/Kconfig      |   8 +
 drivers/pci/pcie/Makefile     |   1 +
 drivers/pci/pcie/doe.c        | 590 ++++++++++++++++++++++++++++++++++
 include/linux/pci.h           |   3 +
 include/linux/pci_ids.h       |   1 +
 include/linux/pcie-doe.h      |  85 +++++
 include/uapi/linux/pci_regs.h |  29 +-
 11 files changed, 1088 insertions(+), 1 deletion(-)
 create mode 100644 drivers/cxl/cdat.h
 create mode 100644 drivers/pci/pcie/doe.c
 create mode 100644 include/linux/pcie-doe.h
Signature · 1 line
2.19.1
#1 lore raw

RFC PATCH v2 1/4 PCI: Add vendor define ID for the PCI SIG

This ID is used in DOE headers to identify protocols that are defined within the PCI Express Base Specification.

---
Since V1: New Patch

 include/linux/pci_ids.h | 1 +
 1 file changed, 1 insertion(+)
include/linux/pci_ids.h +1 -0
index a76ccb697bef..2c0459c23331 100644
@@ -149,6 +149,7 @@
 #define PCI_CLASS_OTHERS		0xff
 
 /* Vendors and devices.  Sort key: vendor first, device next. */
+#define PCI_VENDOR_ID_PCI_SIG		0x0001
 
 #define PCI_VENDOR_ID_LOONGSON		0x0014
 
Signature · 1 line
2.19.1
#2 lore raw

Re: [RFC PATCH v2 1/4] PCI: Add vendor define ID for the PCI SIG

Quoted 2 lines · Jonathan Cameron

This ID is used in DOE headers to identify protocols that are defined within the PCI Express Base Specification.

Can you please include the specific spec citation here?

Quoted 22 lines

---
Since V1: New Patch

 include/linux/pci_ids.h | 1 +
 1 file changed, 1 insertion(+)
include/linux/pci_ids.h +1 -0
index a76ccb697bef..2c0459c23331 100644
@@ -149,6 +149,7 @@
 #define PCI_CLASS_OTHERS		0xff
 
 /* Vendors and devices.  Sort key: vendor first, device next. */
+#define PCI_VENDOR_ID_PCI_SIG		0x0001
 
 #define PCI_VENDOR_ID_LOONGSON		0x0014
 
Signature · 1 line
2.19.1
#3 lore raw

Re: [RFC PATCH v2 1/4] PCI: Add vendor define ID for the PCI SIG

Quoted 5 lines · On Tue, 13 Apr 2021 11:34:48 -0500 Bjorn Helgaas <[email protected]> wrote:
Quoted 2 lines · Jonathan Cameron

This ID is used in DOE headers to identify protocols that are defined within the PCI Express Base Specification.

Can you please include the specific spec citation here?

Will make sure to add to cover leter for next version but for now,

Table 7-x2: Data Object Exchange ECN
(first column lists the Vendor ID for the protocols)

Available on the PCI SIG spec downloads page.
It also exists in various other places in the 5.0 spec, but I'm not sure if any are software visible (e.g. VDMs)

Jonathan

Quoted 23 lines
Quoted 23 lines

---
Since V1: New Patch

 include/linux/pci_ids.h | 1 +
 1 file changed, 1 insertion(+)
include/linux/pci_ids.h +1 -0
index a76ccb697bef..2c0459c23331 100644
@@ -149,6 +149,7 @@
 #define PCI_CLASS_OTHERS		0xff
 
 /* Vendors and devices.  Sort key: vendor first, device next. */
+#define PCI_VENDOR_ID_PCI_SIG		0x0001
 
 #define PCI_VENDOR_ID_LOONGSON		0x0014
 
Signature · 1 line
2.19.1
#4 lore raw

Re: [RFC PATCH v2 1/4] PCI: Add vendor define ID for the PCI SIG

Quoted 7 lines · Jonathan Cameron
Quoted 4 lines · On Tue, 13 Apr 2021 11:34:48 -0500 Bjorn Helgaas <[email protected]> wrote:
Quoted 2 lines · Jonathan Cameron

This ID is used in DOE headers to identify protocols that are defined within the PCI Express Base Specification.

Quoted 6 lines
Quoted 1 line

Can you please include the specific spec citation here?

Will make sure to add to cover leter for next version but for now,

Table 7-x2: Data Object Exchange ECN
(first column lists the Vendor ID for the protocols)

I wish the SIG would formally define this Vendor ID instead of just starting to use it, but this is better than nothing.

Please put this in the log for this commit, since the cover letter may not be merged and isn't directly connected to this commit.

Quoted 29 lines

Available on the PCI SIG spec downloads page.
It also exists in various other places in the 5.0 spec, but I'm not sure if any are software visible (e.g. VDMs)

Jonathan

Quoted 22 lines
Quoted 22 lines

---
Since V1: New Patch

 include/linux/pci_ids.h | 1 +
 1 file changed, 1 insertion(+)
include/linux/pci_ids.h +1 -0
index a76ccb697bef..2c0459c23331 100644
@@ -149,6 +149,7 @@
 #define PCI_CLASS_OTHERS		0xff
 
 /* Vendors and devices.  Sort key: vendor first, device next. */
+#define PCI_VENDOR_ID_PCI_SIG		0x0001
 
 #define PCI_VENDOR_ID_LOONGSON		0x0014
 
Signature · 1 line
2.19.1
#5 lore raw

RFC PATCH v2 2/4 PCI/doe: Initial support PCI Data Object Exchange

In reply to Jonathan Cameron

Introduced in a PCI ECN [1], DOE provides a config space based mailbox with standard protocol discovery. Each mailbox is accessed through a DOE PCIE Extended Capability.

A device may have 1 or more DOE mailboxes, each of which is allowed to support any number of protocols (some DOE protocols specifications apply additional restrictions). A given protocol may be supported on more than one DOE mailbox on a given function.

If a driver wishes to access any number of DOE instances / protocols it makes a single call to pcie_doe_register_all() which will find available DOEs, create the required infrastructure and cache the protocols they support. pcie_doe_find() can then retrieve a pointer to an appropriate DOE instance.

Testing conducted against QEMU using:

https://lore.kernel.org/qemu-devel/[email protected]/
+ fix for interrupt flag mentioned in that thread and a whole load of hacks to exercise error paths etc.

[1] https://members.pcisig.com/wg/PCI-SIG/document/14143

---

Thanks to Dan Williams for reviewing v1.
Note code has changed a lot, so I may well have missed stuff in this log. Details on approaches to the DOE serialization discussed in the cover letter.

Changes since v1:
Major stuff:
* Rework the registration of DOE. DOE instances are added to a list in the struct pci_dev. A single call to pcie_doe_register_all() finds all DOEs present on a device and caches which protocols they support. The lifetime of these can then all be managed alongside the struct pci_dev avoiding need for reference counting etc whilst allowing a driver not to care if different protocols are using the same DOE instance, or different ones. The driver issues a call to pcie_doe_find() to get a pointer to the first appropriate DOE. Note, a side effect of minimizing impact of this on struct pci_dev is that we can't build DOE support as a module.
* Instead of serializing on a mutex, move to a more complex state machine based scheme in which the DOE config space registers are only accessed from a single delayed work item. The state machine uses two states for normal operation, IDLE and WAITING. Two states also exist for ABORT to indicate if it was called in response to error, or at startup. Interrupts result in mod_delayed_work()
to force an immediate check on the status register.
Message queuing is implemented with a list of tasks and kicking the state machine work item as needed.
* Decide, inside the core DOE code, whether to poll based
on if the MSI/MSIX interrupts are enabled and the DOE instance advertises an interrupt.
* Define a struct pcie_doe_exchange to encapsulate header info with payloads etc. Specific fields used for VID and protocol + lengths so the DOE header can be constructed inside the DOE functions rather than relying on callers to do that.
* Don't hide away devm_ stuff in calls that don't make it obvious.

Minor stuff:
* pcie_doe_init() and pcie_doe_register separation to cover the bits that can fail in register() and the bits that can't in init()
* Many typos
* Rename cap_offset field to cap
* Use new PCI_VENDOR_ID_PCI_SIG define to avoid open coding the value
* Add defines for timeouts etc.
* Missing EXPORT_SYMBOL_GPL() added to allow DOE access from modules.

 drivers/pci/pcie/Kconfig      |   8 +
 drivers/pci/pcie/Makefile     |   1 +
 drivers/pci/pcie/doe.c        | 590 ++++++++++++++++++++++++++++++++++
 include/linux/pci.h           |   3 +
 include/linux/pcie-doe.h      |  85 +++++
 include/uapi/linux/pci_regs.h |  29 +-
 6 files changed, 715 insertions(+), 1 deletion(-)
drivers/pci/pcie/Kconfig +8 -0
index 45a2ef702b45..1b566d08bfef 100644
@@ -142,3 +142,11 @@ config PCIE_EDR
 	  the PCI Firmware Specification r3.2.  Enable this if you want to
 	  support hybrid DPC model which uses both firmware and OS to
 	  implement DPC.
+
+config PCIE_DOE
+       bool
+       help
+         This enables library support PCI Data Object Exchange capability.
+         DOE provides a simple mailbox in PCI express config space that is
+         used by a number of different protocols.
+         It is defined in the Data Object Exchange ECN to PCI 5.0.
drivers/pci/pcie/Makefile +1 -0
index b2980db88cc0..801fdd5fbfc1 100644
@@ -13,3 +13,4 @@ obj-$(CONFIG_PCIE_PME)		+= pme.o
 obj-$(CONFIG_PCIE_DPC)		+= dpc.o
 obj-$(CONFIG_PCIE_PTM)		+= ptm.o
 obj-$(CONFIG_PCIE_EDR)		+= edr.o
+obj-$(CONFIG_PCIE_DOE)		+= doe.o
drivers/pci/pcie/doe.c new file +590 -0

590 lines not on this page · raw message

include/linux/pci.h +3 -0
index 86c799c97b77..5d958a63e8c7 100644
@@ -332,6 +332,9 @@ struct pci_dev {
 #ifdef CONFIG_PCIEPORTBUS
 	struct rcec_ea	*rcec_ea;	/* RCEC cached endpoint association */
 	struct pci_dev  *rcec;          /* Associated RCEC device */
+#endif
+#ifdef CONFIG_PCIE_DOE
+	struct list_head doe_list;	/* Data Object Exchange mailboxes */
 #endif
 	u8		pcie_cap;	/* PCIe capability offset */
 	u8		msi_cap;	/* MSI capability offset */
include/linux/pcie-doe.h new file +85 -0

85 lines not on this page · raw message

include/uapi/linux/pci_regs.h +28 -1
index e709ae8235e7..4d8a5fee2cdf 100644
@@ -730,7 +730,8 @@
 #define PCI_EXT_CAP_ID_DVSEC	0x23	/* Designated Vendor-Specific */
 #define PCI_EXT_CAP_ID_DLF	0x25	/* Data Link Feature */
 #define PCI_EXT_CAP_ID_PL_16GT	0x26	/* Physical Layer 16.0 GT/s */
-#define PCI_EXT_CAP_ID_MAX	PCI_EXT_CAP_ID_PL_16GT
+#define PCI_EXT_CAP_ID_DOE	0x2E	/* Data Object Exchange */
+#define PCI_EXT_CAP_ID_MAX	PCI_EXT_CAP_ID_DOE
 
 #define PCI_EXT_CAP_DSN_SIZEOF	12
 #define PCI_EXT_CAP_MCAST_ENDPOINT_SIZEOF 40
@@ -1092,4 +1093,30 @@
 #define  PCI_PL_16GT_LE_CTRL_USP_TX_PRESET_MASK		0x000000F0
 #define  PCI_PL_16GT_LE_CTRL_USP_TX_PRESET_SHIFT	4
 
+/* Data Object Exchange */
+#define PCI_DOE_CAP		0x04	/* DOE Capabilities Register */
+#define  PCI_DOE_CAP_INT			0x00000001  /* Interrupt Support */
+#define  PCI_DOE_CAP_IRQ			0x00000ffe  /* Interrupt Message Number */
+#define PCI_DOE_CTRL		0x08	/* DOE Control Register */
+#define  PCI_DOE_CTRL_ABORT			0x00000001  /* DOE Abort */
+#define  PCI_DOE_CTRL_INT_EN			0x00000002  /* DOE Interrupt Enable */
+#define  PCI_DOE_CTRL_GO			0x80000000  /* DOE Go */
+#define PCI_DOE_STATUS		0x0C	/* DOE Status Register */
+#define  PCI_DOE_STATUS_BUSY			0x00000001  /* DOE Busy */
+#define  PCI_DOE_STATUS_INT_STATUS		0x00000002  /* DOE Interrupt Status */
+#define  PCI_DOE_STATUS_ERROR			0x00000004  /* DOE Error */
+#define  PCI_DOE_STATUS_DATA_OBJECT_READY	0x80000000  /* Data Object Ready */
+#define PCI_DOE_WRITE		0x10	/* DOE Write Data Mailbox Register */
+#define PCI_DOE_READ		0x14	/* DOE Read Data Mailbox Register */
+
+/* DOE Data Object - note not actually registers */
+#define PCI_DOE_DATA_OBJECT_HEADER_1_VID	0x0000FFFF
+#define PCI_DOE_DATA_OBJECT_HEADER_1_TYPE	0x00FF0000
+#define PCI_DOE_DATA_OBJECT_HEADER_2_LENGTH	0x0003FFFF
+
+#define PCI_DOE_DATA_OBJECT_DISC_REQ_3_INDEX	0x000000FF
+#define PCI_DOE_DATA_OBJECT_DISC_RSP_3_VID	0x0000FFFF
+#define PCI_DOE_DATA_OBJECT_DISC_RSP_3_PROTOCOL	0x00FF0000
+#define PCI_DOE_DATA_OBJECT_DISC_RSP_3_NEXT_INDEX 0xFF000000
+
 #endif /* LINUX_PCI_REGS_H */
Signature · 1 line
2.19.1
#6 lore raw

Re: [RFC PATCH v2 2/4] PCI/doe: Initial support PCI Data Object Exchange

To match subject line history:

PCI/DOE: Add Data Object Exchange support

Quoted 3 lines · Jonathan Cameron

Introduced in a PCI ECN [1], DOE provides a config space based mailbox with standard protocol discovery. Each mailbox is accessed through a DOE PCIE Extended Capability.

s/PCIE//

I don't think DOE depends on anything specific to PCIe.

Quoted 2 lines

A device may have 1 or more DOE mailboxes, each of which is allowed to support any number of protocols (some DOE protocols

s/DOE protocols/DOE protocol/

Quoted 8 lines

specifications apply additional restrictions). A given protocol may be supported on more than one DOE mailbox on a given function.

If a driver wishes to access any number of DOE instances / protocols it makes a single call to pcie_doe_register_all() which will find available DOEs, create the required infrastructure and cache the protocols they support. pcie_doe_find() can then retrieve a pointer to an appropriate DOE instance.

Maybe mention the run-time interface (pcie_doe_sync()) here as well. Can we make that name more descriptive? It'd be nice to include a verb.

I think we should globally s/pcie/pci/ in filenames, struct, interfaces, config option, etc.

Quoted 7 lines

Testing conducted against QEMU using:

https://lore.kernel.org/qemu-devel/[email protected]/
+ fix for interrupt flag mentioned in that thread and a whole load of hacks to exercise error paths etc.

[1] https://members.pcisig.com/wg/PCI-SIG/document/14143

Can you please include the title and data of approval here? The URL is useless except to PCI-SIG members, and the URL is likely to become stale eventually even to them.

Quoted 49 lines

---

Thanks to Dan Williams for reviewing v1.
Note code has changed a lot, so I may well have missed stuff in this log. Details on approaches to the DOE serialization discussed in the cover letter.

Changes since v1:
Major stuff:
* Rework the registration of DOE. DOE instances are added to a list in the struct pci_dev. A single call to pcie_doe_register_all() finds all DOEs present on a device and caches which protocols they support. The lifetime of these can then all be managed alongside the struct pci_dev avoiding need for reference counting etc whilst allowing a driver not to care if different protocols are using the same DOE instance, or different ones. The driver issues a call to pcie_doe_find() to get a pointer to the first appropriate DOE. Note, a side effect of minimizing impact of this on struct pci_dev is that we can't build DOE support as a module.
* Instead of serializing on a mutex, move to a more complex state machine based scheme in which the DOE config space registers are only accessed from a single delayed work item. The state machine uses two states for normal operation, IDLE and WAITING. Two states also exist for ABORT to indicate if it was called in response to error, or at startup. Interrupts result in mod_delayed_work()
to force an immediate check on the status register.
Message queuing is implemented with a list of tasks and kicking the state machine work item as needed.
* Decide, inside the core DOE code, whether to poll based
on if the MSI/MSIX interrupts are enabled and the DOE instance advertises an interrupt.
* Define a struct pcie_doe_exchange to encapsulate header info with payloads etc. Specific fields used for VID and protocol + lengths so the DOE header can be constructed inside the DOE functions rather than relying on callers to do that.
* Don't hide away devm_ stuff in calls that don't make it obvious.

Minor stuff:
* pcie_doe_init() and pcie_doe_register separation to cover the bits that can fail in register() and the bits that can't in init()
* Many typos
* Rename cap_offset field to cap
* Use new PCI_VENDOR_ID_PCI_SIG define to avoid open coding the value
* Add defines for timeouts etc.
* Missing EXPORT_SYMBOL_GPL() added to allow DOE access from modules.

Quoted 3 lines
 drivers/pci/pcie/Kconfig      |   8 +
 drivers/pci/pcie/Makefile     |   1 +
 drivers/pci/pcie/doe.c        | 590 ++++++++++++++++++++++++++++++++++

I'd move this up to drivers/pci/ since I don't think there's any actual PCIe dependency.

Quoted 12 lines
 include/linux/pci.h           |   3 +
 include/linux/pcie-doe.h      |  85 +++++
 include/uapi/linux/pci_regs.h |  29 +-
 6 files changed, 715 insertions(+), 1 deletion(-)
drivers/pci/pcie/Kconfig +0 -0
index 45a2ef702b45..1b566d08bfef 100644
@@ -142,3 +142,11 @@ config PCIE_EDR
 	  the PCI Firmware Specification r3.2.  Enable this if you want to

drivers/pci/pcie/Kconfig config PCIE_EDR · line 152

Quoted 10 lines
drivers/pci/pcie/Kconfig +8 -0
 	  support hybrid DPC model which uses both firmware and OS to
 	  implement DPC.
+
+config PCIE_DOE
+       bool
+       help
+         This enables library support PCI Data Object Exchange capability.
+         DOE provides a simple mailbox in PCI express config space that is
+         used by a number of different protocols.
+         It is defined in the Data Object Exchange ECN to PCI 5.0.

s/support PCI/support for the PCI/
s/PCI express/PCI/

Quoted 29 lines
drivers/pci/pcie/Makefile +1 -0
index b2980db88cc0..801fdd5fbfc1 100644
@@ -13,3 +13,4 @@ obj-$(CONFIG_PCIE_PME)		+= pme.o
 obj-$(CONFIG_PCIE_DPC)		+= dpc.o
 obj-$(CONFIG_PCIE_PTM)		+= ptm.o
 obj-$(CONFIG_PCIE_EDR)		+= edr.o
+obj-$(CONFIG_PCIE_DOE)		+= doe.o
drivers/pci/pcie/doe.c new file +14 -0
new file mode 100644
index 000000000000..b8a27c744d09
@@ -0,0 +1,590 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Data Object Exchange ECN
+ * https://members.pcisig.com/wg/PCI-SIG/document/14143
+ *
+ * Copyright (C) 2021 Huawei
+ *     Jonathan Cameron <[email protected]>
+ */
+
+#include <linux/bitfield.h>
+#include <linux/delay.h>
+#include <linux/jiffies.h>
+#include <linux/list.h>
+#include <linux/mutex.h>

drivers/pci/pcie/doe.c line 24

Quoted 10 lines
drivers/pci/pcie/doe.c new file +10 -0
+#include <linux/pci.h>
+#include <linux/pcie-doe.h>
+#include <linux/workqueue.h>
+
+#define PCI_DOE_PROTOCOL_DISCOVERY 0
+
+#define PCI_DOE_BUSY_MAX_RETRIES 16
+#define PCI_DOE_POLL_INTERVAL (HZ / 128)
+
+/* Timeout of 1 second from 6.xx.1 ECN - Data Object Exchange */

Unfortunate that the ECN has two 6.xx.1 sections and no 6.xx.2 section ;) I think this is from the second 6.xx.1 section, i.e., the one that *should* have been 6.xx.2.

Quoted 39 lines
drivers/pci/pcie/doe.c new file +39 -0
+#define PCI_DOE_TIMEOUT HZ
+
+static irqreturn_t pcie_doe_irq(int irq, void *data)
+{
+	struct pcie_doe *doe = data;
+	struct pci_dev *pdev = doe->pdev;
+	u32 val;
+
+	pci_read_config_dword(pdev, doe->cap + PCI_DOE_STATUS, &val);
+	if (FIELD_GET(PCI_DOE_STATUS_INT_STATUS, val)) {
+		pci_write_config_dword(pdev, doe->cap + PCI_DOE_STATUS, val);
+		mod_delayed_work(system_wq, &doe->statemachine, 0);
+		return IRQ_HANDLED;
+	}
+	/* Leave the error case to be handled outside irq */
+	if (FIELD_GET(PCI_DOE_STATUS_ERROR, val)) {
+		mod_delayed_work(system_wq, &doe->statemachine, 0);
+		return IRQ_HANDLED;
+	}
+
+	return IRQ_NONE;
+}
+
+/*
+ * Only call when safe to directly access the DOE, either because no tasks
+ * yet queued, or called from doe_statemachine_work() which has exclusive
+ * access to the DOE config space.
+ */
+static void pcie_doe_abort_start(struct pcie_doe *doe)
+{
+	struct pci_dev *pdev = doe->pdev;
+
+	pci_write_config_dword(pdev, doe->cap + PCI_DOE_CTRL,
+			       PCI_DOE_CTRL_ABORT);
+
+	doe->timeout_jiffies = jiffies + HZ;
+	schedule_delayed_work(&doe->statemachine, HZ);
+}
+

drivers/pci/pcie/doe.c line 73

Quoted 10 lines
drivers/pci/pcie/doe.c new file +10 -0
+static int pcie_doe_send_req(struct pcie_doe *doe, struct pcie_doe_exchange *ex)
+{
+	struct pci_dev *pdev = doe->pdev;
+	u32 val;
+	int i;
+
+	/*
+	 * Check the DOE busy bit is not set.
+	 * If it is set, this could indicate someone other than Linux is
+	 * using the mailbox.

Rewrap to fill 80 columns (or add blank line if you want two paragraphs). What are the possibilities other than Linux? Do you envision user-space usage? Is there a denial-of-service attack here if that other user leaves the busy bit set?

Quoted 27 lines
drivers/pci/pcie/doe.c new file +27 -0
+	 */
+	pci_read_config_dword(pdev, doe->cap + PCI_DOE_STATUS, &val);
+	if (FIELD_GET(PCI_DOE_STATUS_BUSY, val))
+		return -EBUSY;
+
+	if (FIELD_GET(PCI_DOE_STATUS_ERROR, val))
+		return -EIO;
+
+	/* Write DOE Header */
+	val = FIELD_PREP(PCI_DOE_DATA_OBJECT_HEADER_1_VID, ex->vid) |
+		FIELD_PREP(PCI_DOE_DATA_OBJECT_HEADER_1_TYPE, ex->protocol);
+	pci_write_config_dword(pdev, doe->cap + PCI_DOE_WRITE, val);
+	/* Length is 2 DW of header + length of payload in DW */
+	pci_write_config_dword(pdev, doe->cap + PCI_DOE_WRITE,
+			       FIELD_PREP(PCI_DOE_DATA_OBJECT_HEADER_2_LENGTH,
+					  2 + ex->request_pl_sz / 4));
+	for (i = 0; i < ex->request_pl_sz / 4; i++)
+		pci_write_config_dword(pdev, doe->cap + PCI_DOE_WRITE,
+				       ex->request_pl[i]);
+
+	pci_write_config_dword(pdev, doe->cap + PCI_DOE_CTRL, PCI_DOE_CTRL_GO);
+	/* Request is sent - now wait for poll or irq */
+	return 0;
+}
+
+static int pcie_doe_recv_resp(struct pcie_doe *doe, struct pcie_doe_exchange *ex)
+{

drivers/pci/pcie/doe.c line 110

Quoted 10 lines
drivers/pci/pcie/doe.c new file +10 -0
+	struct pci_dev *pdev = doe->pdev;
+	size_t length;
+	u32 val;
+	int i;
+
+	/* Read the first two dwords to get the length and protocol */
+	pci_read_config_dword(pdev, doe->cap + PCI_DOE_READ, &val);
+	if ((FIELD_GET(PCI_DOE_DATA_OBJECT_HEADER_1_VID, val) != ex->vid) ||
+	    (FIELD_GET(PCI_DOE_DATA_OBJECT_HEADER_1_TYPE, val) != ex->protocol)) {
+		dev_err(&pdev->dev, "Expected [VID, Protocol] = [%x, %x], got [%x, %x]\n",

pci_err() (one more below)

Quoted 36 lines
drivers/pci/pcie/doe.c new file +36 -0
+			ex->vid, ex->protocol,
+			FIELD_GET(PCI_DOE_DATA_OBJECT_HEADER_1_VID, val),
+			FIELD_GET(PCI_DOE_DATA_OBJECT_HEADER_1_TYPE, val));
+		return -EIO;
+	}
+
+	pci_write_config_dword(pdev, doe->cap + PCI_DOE_READ, 0);
+	pci_read_config_dword(pdev, doe->cap + PCI_DOE_READ, &val);
+	pci_write_config_dword(pdev, doe->cap + PCI_DOE_READ, 0);
+
+	length = FIELD_GET(PCI_DOE_DATA_OBJECT_HEADER_2_LENGTH, val);
+	if (length > SZ_1M)
+		return -EIO;
+
+	/* Read the rest of the response payload */
+	for (i = 0; i < min(length, ex->response_pl_sz / 4); i++) {
+		pci_read_config_dword(pdev, doe->cap + PCI_DOE_READ,
+				      &ex->response_pl[i]);
+		pci_write_config_dword(pdev, doe->cap + PCI_DOE_READ, 0);
+	}
+
+	/* Flush excess length */
+	for (; i < length; i++) {
+		pci_read_config_dword(pdev, doe->cap + PCI_DOE_READ, &val);
+		pci_write_config_dword(pdev, doe->cap + PCI_DOE_READ, 0);
+	}
+	/* Final error check to pick up on any since Data Object Ready */
+	pci_read_config_dword(pdev, doe->cap + PCI_DOE_STATUS, &val);
+	if (FIELD_GET(PCI_DOE_STATUS_ERROR, val))
+		return -EIO;
+
+	return min(length, ex->response_pl_sz / 4) * 4;
+}
+
+static void pcie_doe_task_complete(void *private)
+{

drivers/pci/pcie/doe.c line 156

Quoted 10 lines
drivers/pci/pcie/doe.c new file +10 -0
+	complete(private);
+}
+
+/**
+ * struct pcie_doe_task - description of a query / response task
+ * @h: Head to add it to the list of outstanding tasks.
+ * @ex: The info details of the task to be done.
+ * @rv: Return value.  Length of received response or error.
+ * @cb: Callback for completion of task.
+ * @private: Private data passed to callback on completion.

Some doc has terminating periods, some doesn't.

Quoted 4 lines
drivers/pci/pcie/doe.c new file +4 -0
+ */
+struct pcie_doe_task {
+	struct list_head h;
+	struct pcie_doe_exchange *ex;

drivers/pci/pcie/doe.c line 170

Quoted 10 lines
drivers/pci/pcie/doe.c new file +10 -0
+	int rv;
+	void (*cb)(void *private);
+	void *private;
+};
+
+/**
+ * pcie_doe_sync() - Send a request, then wait for and receive response.
+ * @doe: DOE mailbox state structure
+ * @ex: Description of the buffers and vid, type used in this
+ *      request/response pair

s/vid/Vendor ID/ (I think?)

drivers/pci/pcie/doe.c line 180

Quoted 9 lines
drivers/pci/pcie/doe.c new file +9 -0
+ * Excess data will be discarded.
+ *
+ * Return: payload in bytes on success, < 0 on error
+ */
+int pcie_doe_sync(struct pcie_doe *doe, struct pcie_doe_exchange *ex)
+{
+	struct pcie_doe_task task;
+	DECLARE_COMPLETION_ONSTACK(c);
+	bool only_task;

list_empty() actually returns "int".

Quoted 33 lines
drivers/pci/pcie/doe.c new file +33 -0
+	/* DOE requests must be a whole number of DW */
+	if (ex->request_pl_sz % sizeof(u32))
+		return -EINVAL;
+
+	task.ex = ex;
+	task.cb = pcie_doe_task_complete;
+	task.private = &c;
+
+	mutex_lock(&doe->tasks_lock);
+	if (doe->dead) {
+		mutex_unlock(&doe->tasks_lock);
+		return -EIO;
+	}
+	only_task = list_empty(&doe->tasks);
+	list_add_tail(&task.h, &doe->tasks);
+	if (only_task)
+		schedule_delayed_work(&doe->statemachine, 0);
+	mutex_unlock(&doe->tasks_lock);
+	wait_for_completion(&c);
+
+	return task.rv;
+}
+
+static void doe_statemachine_work(struct work_struct *work)
+{
+	struct delayed_work *w = to_delayed_work(work);
+	struct pcie_doe *doe = container_of(w, struct pcie_doe, statemachine);
+	struct pci_dev *pdev = doe->pdev;
+	struct pcie_doe_task *task;
+	bool abort;
+	u32 val;
+	int rc;
+

drivers/pci/pcie/doe.c line 224

Quoted 10 lines
drivers/pci/pcie/doe.c new file +10 -0
+	mutex_lock(&doe->tasks_lock);
+	task = list_first_entry_or_null(&doe->tasks, struct pcie_doe_task, h);
+	abort = doe->abort;
+	doe->abort = false;
+	mutex_unlock(&doe->tasks_lock);
+
+	if (abort) {
+		/*
+		 * Currently only used during init - care needed if we want to generally
+		 * expose pcie_doe_abort() as it would impact queries in flight.

Wrap to fit in 80 columns (more below).

Quoted 9 lines
drivers/pci/pcie/doe.c new file +9 -0
+		 */
+		WARN_ON(task);
+		doe->state = DOE_WAIT_ABORT;
+		pcie_doe_abort_start(doe);
+		return;
+	}
+
+	switch (doe->state) {
+	case DOE_IDLE:

drivers/pci/pcie/doe.c line 243

Quoted 10 lines
drivers/pci/pcie/doe.c new file +10 -0
+		if (task == NULL)
+			return;
+
+		/* Nothing currently in flight so queue a task */
+		rc = pcie_doe_send_req(doe, task->ex);
+		/*
+		 * The specification does not provide any guidance on how long some other
+		 * entity could keep the DOE busy, so try for 1 second then fail.
+		 * Busy handling is best effort only, because there is not way of avoiding
+		 * racing against another user of the DOE.

s/not way/no way/

Quoted 8 lines
drivers/pci/pcie/doe.c new file +8 -0
+		 */
+		if (rc == -EBUSY) {
+			doe->busy_retries++;
+			if (doe->busy_retries == PCI_DOE_BUSY_MAX_RETRIES) {
+				/* Long enough, fail this request */
+				doe->busy_retries = 0;
+				goto busy;
+			}

drivers/pci/pcie/doe.c line 261

Quoted 10 lines
drivers/pci/pcie/doe.c new file +10 -0
+			schedule_delayed_work(w, HZ / PCI_DOE_BUSY_MAX_RETRIES);
+			return;
+		}
+		if (rc)
+			goto abort;
+		doe->busy_retries = 0;
+
+		doe->state = DOE_WAIT_RESP;
+		doe->timeout_jiffies = jiffies + HZ;
+		/* Now poll or wait for IRQ with timeout */

Capitalize "IRQ" elsewhere to match this usage.

Quoted 250 lines
drivers/pci/pcie/doe.c new file +250 -0
+		if (doe->irq > 0)
+			schedule_delayed_work(w, PCI_DOE_TIMEOUT);
+		else
+			schedule_delayed_work(w, PCI_DOE_POLL_INTERVAL);
+		return;
+
+	case DOE_WAIT_RESP:
+		/* Not possible to get here with NULL task */
+		pci_read_config_dword(pdev, doe->cap + PCI_DOE_STATUS, &val);
+		if (FIELD_GET(PCI_DOE_STATUS_ERROR, val)) {
+			rc = -EIO;
+			goto abort;
+		}
+
+		if (!FIELD_GET(PCI_DOE_STATUS_DATA_OBJECT_READY, val)) {
+			/* If not yet at timeout reschedule otherwise abort */
+			if (time_after(jiffies, doe->timeout_jiffies)) {
+				rc = -ETIMEDOUT;
+				goto abort;
+			}
+			schedule_delayed_work(w, PCI_DOE_POLL_INTERVAL);
+			return;
+		}
+
+		rc  = pcie_doe_recv_resp(doe, task->ex);
+		if (rc < 0)
+			goto abort;
+
+		doe->state = DOE_IDLE;
+
+		mutex_lock(&doe->tasks_lock);
+		list_del(&task->h);
+		if (!list_empty(&doe->tasks))
+			schedule_delayed_work(w, 0);
+		mutex_unlock(&doe->tasks_lock);
+
+		/* Set the return value to the length of received payload */
+		task->rv = rc;
+		task->cb(task->private);
+		return;
+
+	case DOE_WAIT_ABORT:
+	case DOE_WAIT_ABORT_ON_ERR:
+		pci_read_config_dword(pdev, doe->cap + PCI_DOE_STATUS, &val);
+
+		if (!FIELD_GET(PCI_DOE_STATUS_ERROR, val) &&
+		    !FIELD_GET(PCI_DOE_STATUS_BUSY, val)) {
+			/* Back to normal state - carry on */
+			mutex_lock(&doe->tasks_lock);
+			if (!list_empty(&doe->tasks))
+				schedule_delayed_work(w, 0);
+			mutex_unlock(&doe->tasks_lock);
+
+			/* For deliberately triggered abort, someone is waiting */
+			if (doe->state == DOE_WAIT_ABORT)
+				complete(&doe->abort_c);
+			doe->state = DOE_IDLE;
+
+			return;
+		}
+		if (time_after(jiffies, doe->timeout_jiffies)) {
+			struct pcie_doe_task *t, *n;
+
+			/* We are dead - abort all queued tasks */
+			dev_err(&pdev->dev, "DOE ABORT timed out\n");
+			mutex_lock(&doe->tasks_lock);
+			doe->dead = true;
+			list_for_each_entry_safe(t, n, &doe->tasks, h) {
+				t->rv = -EIO;
+				t->cb(t->private);
+				list_del(&t->h);
+			}
+
+			mutex_unlock(&doe->tasks_lock);
+			if (doe->state == DOE_WAIT_ABORT)
+				complete(&doe->abort_c);
+		}
+		return;
+	}
+
+abort:
+	pcie_doe_abort_start(doe);
+	doe->state = DOE_WAIT_ABORT_ON_ERR;
+busy:
+	mutex_lock(&doe->tasks_lock);
+	list_del(&task->h);
+	mutex_unlock(&doe->tasks_lock);
+
+	task->rv = rc;
+	task->cb(task->private);
+	/* If we got here via busy, and the queue isn't empty then we need to go again */
+	if (doe->state == DOE_IDLE) {
+		mutex_lock(&doe->tasks_lock);
+		if (!list_empty(&doe->tasks))
+			schedule_delayed_work(w, 0);
+		mutex_unlock(&doe->tasks_lock);
+	}
+}
+
+static int pcie_doe_discovery(struct pcie_doe *doe, u8 *index, u16 *vid,
+			      u8 *protocol)
+{
+	u32 request_pl = FIELD_PREP(PCI_DOE_DATA_OBJECT_DISC_REQ_3_INDEX, *index);
+	u32 response_pl;
+	struct pcie_doe_exchange ex = {
+		.vid = PCI_VENDOR_ID_PCI_SIG,
+		.protocol = PCI_DOE_PROTOCOL_DISCOVERY,
+		.request_pl = &request_pl,
+		.request_pl_sz = sizeof(request_pl),
+		.response_pl = &response_pl,
+		.response_pl_sz = sizeof(response_pl),
+	};
+	int ret;
+
+	ret = pcie_doe_sync(doe, &ex);
+	if (ret < 0)
+		return ret;
+
+	if (ret != sizeof(response_pl))
+		return -EIO;
+
+	*vid = FIELD_GET(PCI_DOE_DATA_OBJECT_DISC_RSP_3_VID, response_pl);
+	*protocol = FIELD_GET(PCI_DOE_DATA_OBJECT_DISC_RSP_3_PROTOCOL, response_pl);
+	*index = FIELD_GET(PCI_DOE_DATA_OBJECT_DISC_RSP_3_NEXT_INDEX, response_pl);
+
+	return 0;
+}
+
+static int pcie_doe_cache_protocols(struct pcie_doe *doe)
+{
+	u8 index = 0;
+	int rc;
+
+	/* Discovery protocol must always be supported and must report itself */
+	doe->num_prots = 1;
+	doe->prots = kzalloc(sizeof(*doe->prots) * doe->num_prots, GFP_KERNEL);
+	if (doe->prots == NULL)
+		return -ENOMEM;
+
+	do {
+		struct pcie_doe_prot *prot, *prot_new;
+
+		prot = &doe->prots[doe->num_prots - 1];
+		rc = pcie_doe_discovery(doe, &index, &prot->vid, &prot->type);
+		if (rc)
+			goto free_prots;
+
+		if (index) {
+			prot_new = krealloc(doe->prots,
+					    sizeof(*doe->prots) * doe->num_prots,
+					    GFP_KERNEL);
+			if (prot_new == NULL) {
+				rc = -ENOMEM;
+				goto free_prots;
+			}
+			doe->prots = prot_new;
+			doe->num_prots++;
+		}
+	} while (index);
+
+	return 0;
+
+free_prots:
+	kfree(doe->prots);
+	return rc;
+}
+
+static void pcie_doe_init(struct pcie_doe *doe, struct pci_dev *pdev, int doe_offset)
+{
+	mutex_init(&doe->tasks_lock);
+	init_completion(&doe->abort_c);
+	doe->cap = doe_offset;
+	doe->pdev = pdev;
+	INIT_LIST_HEAD(&doe->tasks);
+	INIT_DELAYED_WORK(&doe->statemachine, doe_statemachine_work);
+}
+
+static int pcie_doe_abort(struct pcie_doe *doe)
+{
+	reinit_completion(&doe->abort_c);
+	mutex_lock(&doe->tasks_lock);
+	doe->abort = true;
+	mutex_unlock(&doe->tasks_lock);
+	schedule_delayed_work(&doe->statemachine, 0);
+	wait_for_completion(&doe->abort_c);
+
+	if (doe->dead)
+		return -EIO;
+
+	return 0;
+}
+
+static int pcie_doe_register(struct pcie_doe *doe)
+{
+	struct pci_dev *pdev = doe->pdev;
+	bool poll = !pci_dev_msi_enabled(pdev);
+	int rc, irq;
+	u32 val;
+
+	pci_read_config_dword(pdev, doe->cap + PCI_DOE_CAP, &val);
+
+	if (!poll && FIELD_GET(PCI_DOE_CAP_INT, val)) {
+		irq = pci_irq_vector(pdev, FIELD_GET(PCI_DOE_CAP_IRQ, val));
+		if (irq < 0)
+			return irq;
+
+		rc = request_irq(irq, pcie_doe_irq, 0, "DOE", doe);
+		if (rc)
+			return rc;
+
+		doe->irq = irq;
+		pci_write_config_dword(pdev, doe->cap + PCI_DOE_CTRL,
+				       FIELD_PREP(PCI_DOE_CTRL_INT_EN, 1));
+	}
+
+	/* Reset the mailbox by issuing an abort */
+	rc = pcie_doe_abort(doe);
+	if (rc)
+		goto err_free_irqs;
+
+	return 0;
+
+err_free_irqs:
+	if (doe->irq > 0)
+		free_irq(doe->irq, doe);
+
+	return rc;
+}
+
+static void pcie_doe_unregister(struct pcie_doe *doe)
+{
+	if (doe->irq > 0)
+		free_irq(doe->irq, doe);
+}
+
+void pcie_doe_unregister_all(struct pci_dev *pdev)
+{
+	struct pcie_doe *doe, *next;
+
+	list_for_each_entry_safe(doe, next, &pdev->doe_list, h) {
+		/* First halt the state machine */
+		cancel_delayed_work_sync(&doe->statemachine);
+		kfree(doe->prots);
+		pcie_doe_unregister(doe);
+		kfree(doe);
+	}
+}
+EXPORT_SYMBOL_GPL(pcie_doe_unregister_all);
+
+/**

drivers/pci/pcie/doe.c line 521

Quoted 10 lines
drivers/pci/pcie/doe.c new file +10 -0
+ * pcie_doe_register_all() - Find and register all DOE mailboxes
+ * @pdev: PCI device whose DOE mailboxes we are finding.
+ *
+ * Will locate any DOE mailboxes present on the device and cache the
+ * protocols so that pcie_doe_find() can be used to retrieve a suitable DOE
+ * instance.
+ * DOE mailboxes are available until pcie_doe_unregister_all()
+ * is called.
+ *
+ * RETURNS: 0 on success, < 0 on error

Different styles, pick one:

* Return: payload in bytes on success, < 0 on error
* RETURNS: 0 on success, < 0 on error
* RETURNS: Pointer to DOE instance, or NULL if no suitable instance available.

Quoted 155 lines
drivers/pci/pcie/doe.c new file +69 -0
+ */
+int pcie_doe_register_all(struct pci_dev *pdev)
+{
+	struct pcie_doe *doe;
+	int pos = 0;
+	int rc;
+
+	INIT_LIST_HEAD(&pdev->doe_list);
+
+	/* Walk the DOE extended capabilities and add to per pci_dev list */
+	while (true) {
+
+		pos = pci_find_next_ext_capability(pdev, pos, PCI_EXT_CAP_ID_DOE);
+		if (!pos)
+			return 0;
+
+		doe = kzalloc(sizeof(*doe), GFP_KERNEL);
+		if (!doe) {
+			rc = -ENOMEM;
+			goto free_does;
+		}
+
+		pcie_doe_init(doe, pdev, pos);
+		rc = pcie_doe_register(doe);
+		if (rc) {
+			kfree(doe);
+			goto free_does;
+		}
+
+		rc = pcie_doe_cache_protocols(doe);
+		if (rc) {
+			pcie_doe_unregister(doe);
+			kfree(doe);
+			goto free_does;
+		}
+
+		list_add(&doe->h, &pdev->doe_list);
+	}
+
+free_does:
+	pcie_doe_unregister_all(pdev);
+
+	return rc;
+}
+EXPORT_SYMBOL_GPL(pcie_doe_register_all);
+
+/**
+ * pcie_doe_find() - Find the first DOE instance that supports a given protocol
+ * @pdev: Device on which to find the DOE instance.
+ * @vid: Vendor ID.
+ * @type: Specific protocol for this vendor.
+ *
+ * RETURNS: Pointer to DOE instance, or NULL if no suitable instance available.
+ */
+struct pcie_doe *pcie_doe_find(struct pci_dev *pdev, u16 vid, u8 type)
+{
+	struct pcie_doe *doe;
+	int i;
+
+	list_for_each_entry(doe, &pdev->doe_list, h) {
+		for (i = 0; i < doe->num_prots; i++)
+			if ((doe->prots[i].vid == vid) &&
+			    (doe->prots[i].type == type))
+				return doe;
+	}
+
+	return NULL;
+}
+EXPORT_SYMBOL_GPL(pcie_doe_find);
include/linux/pci.h +3 -0
index 86c799c97b77..5d958a63e8c7 100644
@@ -332,6 +332,9 @@ struct pci_dev {
 #ifdef CONFIG_PCIEPORTBUS
 	struct rcec_ea	*rcec_ea;	/* RCEC cached endpoint association */
 	struct pci_dev  *rcec;          /* Associated RCEC device */
+#endif
+#ifdef CONFIG_PCIE_DOE
+	struct list_head doe_list;	/* Data Object Exchange mailboxes */
 #endif
 	u8		pcie_cap;	/* PCIe capability offset */
 	u8		msi_cap;	/* MSI capability offset */
include/linux/pcie-doe.h new file +66 -0
new file mode 100644
index 000000000000..794d6f090779
@@ -0,0 +1,85 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Data Object Exchange was added to the PCI spec as an ECN to 5.0.
+ *
+ * Copyright (C) 2021 Huawei
+ *     Jonathan Cameron <[email protected]>
+ */
+
+#include <linux/completion.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+
+#ifndef LINUX_PCIE_DOE_H
+#define LINUX_PCIE_DOE_H
+
+struct pcie_doe_prot {
+	u16 vid;
+	u8 type;
+};
+
+struct workqueue_struct;
+
+enum pcie_doe_state {
+	DOE_IDLE,
+	DOE_WAIT_RESP,
+	DOE_WAIT_ABORT,
+	DOE_WAIT_ABORT_ON_ERR,
+};
+
+struct pcie_doe_exchange {
+	u16 vid;
+	u8 protocol;
+	u32 *request_pl;
+	size_t request_pl_sz;
+	u32 *response_pl;
+	size_t response_pl_sz;
+};
+
+/**
+ * struct pcie_doe - State to support use of DOE mailbox
+ * @cap: Config space offset to base of DOE capability.
+ * @pdev: PCI device that hosts this DOE.
+ * @abort_c: Completion used for initial abort handling.
+ * @irq: Interrupt used for signaling DOE ready or abort.
+ * @prots: Cache of identifiers for protocols supported.
+ * @num_prots: Size of prots cache.
+ * @h: Used for DOE instance lifetime management.
+ * @wq: Workqueue used to handle state machine and polling / timeouts
+ * @tasks: List of task in flight + pending.
+ * @tasks_lock: Protect the tasks list.
+ * @statemachine: Work item for the DOE statemachine
+ * @state: Current state of this DOE.
+ * @timeout_jiffies: 1 second after GO set.
+ * @busy_retries: Count of retry attempts
+ * @abort: Request a manual abort (e.g. on init)
+ * @dead: Used to mark a DOE for which an ABORT has timed out.
+ *        Further messages will immediately be aborted with error.
+ */
+struct pcie_doe {
+	int cap;
+	struct pci_dev *pdev;
+	struct completion abort_c;
+	int irq;
+	struct pcie_doe_prot *prots;
+	int num_prots;
+	struct list_head h;

include/linux/pcie-doe.h line 76

Quoted 10 lines
include/linux/pcie-doe.h new file +10 -0
+
+	struct workqueue_struct *wq;
+	struct list_head tasks;
+	struct mutex tasks_lock;
+	struct delayed_work statemachine;
+	enum pcie_doe_state state;
+	unsigned long timeout_jiffies;
+	unsigned int busy_retries;
+	bool abort;
+	bool dead;

Slight preference for "unsigned int abort:1" in a struct:
https://lore.kernel.org/r/CA+55aFzKQ6Pj18TB8p4Yr0M4t+S+BsiHH=BJNmn=76-NcjTj-g@mail.gmail.com/

Quoted 42 lines
include/linux/pcie-doe.h new file +9 -0
+};
+
+int pcie_doe_register_all(struct pci_dev *pdev);
+void pcie_doe_unregister_all(struct pci_dev *pdev);
+struct pcie_doe *pcie_doe_find(struct pci_dev *pdev, u16 vid, u8 type);
+
+int pcie_doe_sync(struct pcie_doe *doe, struct pcie_doe_exchange *ex);
+
+#endif
include/uapi/linux/pci_regs.h +17 -1
index e709ae8235e7..4d8a5fee2cdf 100644
@@ -730,7 +730,8 @@
 #define PCI_EXT_CAP_ID_DVSEC	0x23	/* Designated Vendor-Specific */
 #define PCI_EXT_CAP_ID_DLF	0x25	/* Data Link Feature */
 #define PCI_EXT_CAP_ID_PL_16GT	0x26	/* Physical Layer 16.0 GT/s */
-#define PCI_EXT_CAP_ID_MAX	PCI_EXT_CAP_ID_PL_16GT
+#define PCI_EXT_CAP_ID_DOE	0x2E	/* Data Object Exchange */
+#define PCI_EXT_CAP_ID_MAX	PCI_EXT_CAP_ID_DOE
 
 #define PCI_EXT_CAP_DSN_SIZEOF	12
 #define PCI_EXT_CAP_MCAST_ENDPOINT_SIZEOF 40
@@ -1092,4 +1093,30 @@
 #define  PCI_PL_16GT_LE_CTRL_USP_TX_PRESET_MASK		0x000000F0
 #define  PCI_PL_16GT_LE_CTRL_USP_TX_PRESET_SHIFT	4
 
+/* Data Object Exchange */
+#define PCI_DOE_CAP		0x04	/* DOE Capabilities Register */
+#define  PCI_DOE_CAP_INT			0x00000001  /* Interrupt Support */
+#define  PCI_DOE_CAP_IRQ			0x00000ffe  /* Interrupt Message Number */
+#define PCI_DOE_CTRL		0x08	/* DOE Control Register */
+#define  PCI_DOE_CTRL_ABORT			0x00000001  /* DOE Abort */
+#define  PCI_DOE_CTRL_INT_EN			0x00000002  /* DOE Interrupt Enable */
+#define  PCI_DOE_CTRL_GO			0x80000000  /* DOE Go */
+#define PCI_DOE_STATUS		0x0C	/* DOE Status Register */
+#define  PCI_DOE_STATUS_BUSY			0x00000001  /* DOE Busy */
+#define  PCI_DOE_STATUS_INT_STATUS		0x00000002  /* DOE Interrupt Status */
+#define  PCI_DOE_STATUS_ERROR			0x00000004  /* DOE Error */
+#define  PCI_DOE_STATUS_DATA_OBJECT_READY	0x80000000  /* Data Object Ready */
+#define PCI_DOE_WRITE		0x10	/* DOE Write Data Mailbox Register */
+#define PCI_DOE_READ		0x14	/* DOE Read Data Mailbox Register */

include/uapi/linux/pci_regs.h line 1120

Quoted 10 lines
include/uapi/linux/pci_regs.h +10 -0
+
+/* DOE Data Object - note not actually registers */
+#define PCI_DOE_DATA_OBJECT_HEADER_1_VID	0x0000FFFF
+#define PCI_DOE_DATA_OBJECT_HEADER_1_TYPE	0x00FF0000
+#define PCI_DOE_DATA_OBJECT_HEADER_2_LENGTH	0x0003FFFF
+
+#define PCI_DOE_DATA_OBJECT_DISC_REQ_3_INDEX	0x000000FF
+#define PCI_DOE_DATA_OBJECT_DISC_RSP_3_VID	0x0000FFFF
+#define PCI_DOE_DATA_OBJECT_DISC_RSP_3_PROTOCOL	0x00FF0000
+#define PCI_DOE_DATA_OBJECT_DISC_RSP_3_NEXT_INDEX 0xFF000000

This file is a mix, but the consensus is lower-case in hex. I'd leave PCI_EXT_CAP_ID_DOE as-is to match the local context and use lower-case consistently in this hunk.

Quoted 4 lines
include/uapi/linux/pci_regs.h +0 -0
 #endif /* LINUX_PCI_REGS_H */
Signature · 1 line
2.19.1
#7 lore raw

RFC PATCH v2 3/4 cxl/mem: Add CDAT table reading from DOE

In reply to Jonathan Cameron

This patch provides a sysfs binary attribute to allow dumping of the whole table.

Binary dumping is modeled on /sys/firmware/ACPI/tables/

The ability to dump this table will be very useful for emulation of real devices once they become available as QEMU CXL type 3 device emulation will be able to load this file in. Access to that file is restricted to root.

Open questions:
* No support here for table updates via the binary attribute. You get whatever was there when it was first cached. Worth including these from the start, or leave that complexity for later? We could read directly from the DOE every time, but need to check we get a coherent table. Let's figure this out once we are making 'real' use of the table.
* What is maximum size of the SSLBIS entry - I haven't quite managed to figure that out and this is the record with largest size. We could support dynamic allocation of the record size, but it would add complexity that seems unnecessary.
It would not be compliant with the specification for a type 3 memory device to report this record anyway so I'm not that worried about this for now. It will become relevant once we have support for reading CDAT from CXL switches.
* cdat.h is formatted in a similar style to pci_regs.h on basis that it may well be helpful to share this header with userspace tools.
* Move the generic parts of this out to driver/cxl/cdat.c or leave that until we have other CXL drivers wishing to use this?

---

Thanks to Dan William's for review

Changes since v1:
* static creation of the binary attribute
* moved the debug print to separate patch to make it easy to drop later.
* select PCIE_DOE
* Changes due to interface changes in previous patch.

 drivers/cxl/Kconfig |   1 +
 drivers/cxl/cdat.h  |  79 ++++++++++++++++++++
 drivers/cxl/cxl.h   |  13 ++++
 drivers/cxl/mem.c   | 177 ++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 270 insertions(+)
drivers/cxl/Kconfig +1 -0
index 3eec9276e586..afc65d594d6b 100644
@@ -15,6 +15,7 @@ if CXL_BUS
 
 config CXL_MEM
 	tristate "CXL.mem: Memory Devices"
+	select PCIE_DOE
 	help
 	  The CXL.mem protocol allows a device to act as a provider of
 	  "System RAM" and/or "Persistent Memory" that is fully coherent
drivers/cxl/cdat.h new file +79 -0

79 lines not on this page · raw message

drivers/cxl/cxl.h +13 -0
index 6f14838c2d25..cd80f589fff7 100644
@@ -7,6 +7,7 @@
 #include <linux/bitfield.h>
 #include <linux/bitops.h>
 #include <linux/io.h>
+#include <linux/pcie-doe.h>
 
 /* CXL 2.0 8.2.8.1 Device Capabilities Array Register */
 #define CXLDEV_CAP_ARRAY_OFFSET 0x0
@@ -57,10 +58,21 @@
 	(FIELD_GET(CXLMDEV_RESET_NEEDED_MASK, status) !=                       \
 	 CXLMDEV_RESET_NEEDED_NOT)
 
+#define CXL_DOE_PROTOCOL_COMPLIANCE 0
+#define CXL_DOE_PROTOCOL_TABLE_ACCESS 2
+
+/* Common to request and response */
+#define CXL_DOE_TABLE_ACCESS_3_CODE GENMASK(7, 0)
+#define   CXL_DOE_TABLE_ACCESS_3_CODE_READ 0
+#define CXL_DOE_TABLE_ACCESS_3_TYPE GENMASK(15, 8)
+#define   CXL_DOE_TABLE_ACCESS_3_TYPE_CDAT 0
+#define CXL_DOE_TABLE_ACCESS_3_ENTRY_HANDLE GENMASK(31, 16)
+
 struct cxl_memdev;
 /**
  * struct cxl_mem - A CXL memory device
  * @pdev: The PCI device associated with this CXL device.
+ * @table_doe: Data exchange object mailbox used to read tables.
  * @regs: IO mappings to the device's MMIO
  * @status_regs: CXL 2.0 8.2.8.3 Device Status Registers
  * @mbox_regs: CXL 2.0 8.2.8.4 Mailbox Registers
@@ -75,6 +87,7 @@ struct cxl_memdev;
  */
 struct cxl_mem {
 	struct pci_dev *pdev;
+	struct pcie_doe *table_doe;
 	void __iomem *regs;
 	struct cxl_memdev *cxlmd;
 
drivers/cxl/mem.c +177 -0

243 lines not on this page · raw message

Signature · 1 line
2.19.1
#8 lore raw

Re: [RFC PATCH v2 3/4] cxl/mem: Add CDAT table reading from DOE

[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch]

Hi Jonathan,

[FYI, it's a private test report for your RFC patch.]
[auto build test ERROR on pci/next]
[also build test ERROR on linus/master v5.12-rc7]
[cannot apply to next-20210413]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Jonathan-Cameron/PCI-Data-Object-Exchange-support-CXL-CDAT/20210414-000832
base:   https://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci.git next
config: x86_64-randconfig-a016-20210413 (attached as .config)
compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 9829f5e6b1bca9b61efc629770d28bb9014dec45)

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
# install x86_64 cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# https://github.com/0day-ci/linux/commit/a4c437e38a2da5abc1d41d09335d34a66668b4fa
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Jonathan-Cameron/PCI-Data-Object-Exchange-support-CXL-CDAT/20210414-000832 git checkout a4c437e38a2da5abc1d41d09335d34a66668b4fa
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64

If you fix the issue, kindly add following tag as appropriate

All errors (new ones prefixed by >>, old ones prefixed by <<):

>> ERROR: modpost: "pcie_doe_sync" [drivers/cxl/cxl_mem.ko] undefined!

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

#9 lore raw

Re: [RFC PATCH v2 3/4] cxl/mem: Add CDAT table reading from DOE

In reply to Jonathan Cameron
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch]

Hi Jonathan,

[FYI, it's a private test report for your RFC patch.]
[auto build test ERROR on pci/next]
[also build test ERROR on linus/master v5.12-rc7]
[cannot apply to next-20210413]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Jonathan-Cameron/PCI-Data-Object-Exchange-support-CXL-CDAT/20210414-000832
base:   https://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci.git next
config: i386-randconfig-a001-20210413 (attached as .config)
compiler: gcc-9 (Debian 9.3.0-22) 9.3.0
reproduce (this is a W=1 build):
        # https://github.com/0day-ci/linux/commit/a4c437e38a2da5abc1d41d09335d34a66668b4fa
        git remote add linux-review https://github.com/0day-ci/linux
        git fetch --no-tags linux-review Jonathan-Cameron/PCI-Data-Object-Exchange-support-CXL-CDAT/20210414-000832
        git checkout a4c437e38a2da5abc1d41d09335d34a66668b4fa
        # save the attached .config to linux build tree
        make W=1 ARCH=i386 

If you fix the issue, kindly add following tag as appropriate

All errors (new ones prefixed by >>, old ones prefixed by <<):

>> ERROR: modpost: "pcie_doe_sync" [drivers/cxl/cxl_mem.ko] undefined!

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

#10 lore raw

Re: [RFC PATCH v2 3/4] cxl/mem: Add CDAT table reading from DOE

In reply to Jonathan Cameron
Quoted 15 lines
drivers/cxl/mem.c +15 -0
+static int cdat_to_buffer(struct pcie_doe *doe, u32 *buffer, size_t length)
+{
+	int entry_handle = 0;
+	int rc;
+
+	do {
+		u32 cdat_request_pl = CDAT_DOE_REQ(entry_handle);
+		u32 cdat_response_pl[32];
+		struct pcie_doe_exchange ex = {
+			.vid = PCI_DVSEC_VENDOR_ID_CXL,
+			.protocol = CXL_DOE_PROTOCOL_TABLE_ACCESS,
+			.request_pl = &cdat_request_pl,
+			.request_pl_sz = sizeof(cdat_request_pl),
+			.response_pl = cdat_response_pl,
+			.response_pl_sz = sizeof(cdat_response_pl),

drivers/cxl/mem.c static int cxl_mem_setup_mailbox(struct cxl_mem *cxlm) · line 1039

Quoted 10 lines
drivers/cxl/mem.c +10 -0
+		};
+		size_t entry_dw;
+		u32 *entry;
+
+		rc = pcie_doe_sync(doe, &ex);
+		if (rc < 0)
+			return rc;
+
+		entry = cdat_response_pl + 1;
+		entry_dw = rc / sizeof(u32);

Could you >> 2?

drivers/cxl/mem.c static int cxl_mem_setup_mailbox(struct cxl_mem *cxlm) · line 1042

Quoted 3 lines
drivers/cxl/mem.c +3 -0
+		/* Skip Header */
+		entry_dw -= 1;
+		entry_dw = min(length / 4, entry_dw);

Ditto here on length?

Also should you double check that length is not greater than sizeof(cdat_respone_pl)?

drivers/cxl/mem.c static int cxl_mem_setup_mailbox(struct cxl_mem *cxlm) · line 1044

Quoted 2 lines
drivers/cxl/mem.c +2 -0
+		memcpy(buffer, entry, entry_dw * sizeof(u32));
+		length -= entry_dw * sizeof(u32);

Would it be just easier to convert length at the start to be >> 2 instead of this * and / ?

Quoted 8 lines
drivers/cxl/mem.c +8 -0
+		buffer += entry_dw;
+		entry_handle = FIELD_GET(CXL_DOE_TABLE_ACCESS_ENTRY_HANDLE, cdat_response_pl[0]);
+
+	} while (entry_handle != 0xFFFF);
+
+	return 0;
+}
+
#11 lore raw

Re: [RFC PATCH v2 3/4] cxl/mem: Add CDAT table reading from DOE

Quoted 19 lines · Konrad Rzeszutek Wilk
Quoted 19 lines
drivers/cxl/mem.c +19 -0
+static int cdat_to_buffer(struct pcie_doe *doe, u32 *buffer, size_t length)
+{
+	int entry_handle = 0;
+	int rc;
+
+	do {
+		u32 cdat_request_pl = CDAT_DOE_REQ(entry_handle);
+		u32 cdat_response_pl[32];
+		struct pcie_doe_exchange ex = {
+			.vid = PCI_DVSEC_VENDOR_ID_CXL,
+			.protocol = CXL_DOE_PROTOCOL_TABLE_ACCESS,
+			.request_pl = &cdat_request_pl,
+			.request_pl_sz = sizeof(cdat_request_pl),
+			.response_pl = cdat_response_pl,
+			.response_pl_sz = sizeof(cdat_response_pl),
+		};
+		size_t entry_dw;
+		u32 *entry;
+
Quoted 8 lines

drivers/cxl/mem.c static int cxl_mem_setup_mailbox(struct cxl_mem *cxlm) · line 1039

Quoted 6 lines
drivers/cxl/mem.c +6 -0
+		rc = pcie_doe_sync(doe, &ex);
+		if (rc < 0)
+			return rc;
+
+		entry = cdat_response_pl + 1;
+		entry_dw = rc / sizeof(u32);

Could you >> 2?

What's the reasoning for >> 2? As someone who regularly does this because of habit, using divide is generally a lot more implicitly descriptive.

Quoted 6 lines

drivers/cxl/mem.c static int cxl_mem_setup_mailbox(struct cxl_mem *cxlm) · line 1042

Quoted 3 lines
drivers/cxl/mem.c +3 -0
+		/* Skip Header */
+		entry_dw -= 1;
+		entry_dw = min(length / 4, entry_dw);

Ditto here on length?

Quoted 9 lines

Also should you double check that length is not greater than sizeof(cdat_respone_pl)?

drivers/cxl/mem.c static int cxl_mem_setup_mailbox(struct cxl_mem *cxlm) · line 1044

Quoted 2 lines
drivers/cxl/mem.c +2 -0
+		memcpy(buffer, entry, entry_dw * sizeof(u32));
+		length -= entry_dw * sizeof(u32);

Would it be just easier to convert length at the start to be >> 2 instead of this * and / ?

Same as above. Assuming the compiler isn't braindead, I think it reads better as it is.

Quoted 9 lines
Quoted 9 lines
drivers/cxl/mem.c +8 -0
+		buffer += entry_dw;
+		entry_handle = FIELD_GET(CXL_DOE_TABLE_ACCESS_ENTRY_HANDLE, cdat_response_pl[0]);
+
+	} while (entry_handle != 0xFFFF);
+
+	return 0;
+}
+
#12 lore raw

RFC PATCH v2 4/4 cxl/mem: Add a debug parser for CDAT commands.

In reply to Jonathan Cameron

Logs a pretty printed version of the CDAT table entries at driver load.

I find this helpful for development, so including as an extra patch that I would suggest is never merged.

---
Changes since v1: Split out as separate patch so we can drop it easily before merging the rest.

 drivers/cxl/mem.c | 102 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 102 insertions(+)
drivers/cxl/mem.c +102 -0
index 29b3054adf1c..d3f40894f3df 100644
@@ -1050,6 +1050,104 @@ static int cdat_to_buffer(struct pcie_doe *doe, u32 *buffer, size_t length)
 	return 0;
 }
 
+static int cdat_dump(struct pcie_doe *doe)
+{
+	struct pci_dev *dev = doe->pdev;
+	int entry_handle = 0;
+	int rc;
+
+	if (doe == NULL)
+		return 0;
+
+	dev = doe->pdev;
+	do {
+		/* Table access is available */
+		u32 cdat_request_pl = CDAT_DOE_REQ(entry_handle);
+		u32 cdat_response_pl[32];
+		struct pcie_doe_exchange ex = {
+			.vid = PCI_DVSEC_VENDOR_ID_CXL,
+			.protocol = CXL_DOE_PROTOCOL_TABLE_ACCESS,
+			.request_pl = &cdat_request_pl,
+			.request_pl_sz = sizeof(cdat_request_pl),
+			.response_pl = cdat_response_pl,
+			.response_pl_sz = sizeof(cdat_response_pl),
+		};
+		u32 *entry;
+
+		rc = pcie_doe_sync(doe, &ex);
+		if (rc < 0)
+			return rc;
+
+		/* Skip past table response header */
+		entry = cdat_response_pl + 1;
+		if (entry_handle == 0) {
+			pci_info(dev,
+				 "CDAT Header (Length=%u, Revision=%u, Checksum=0x%x, Sequence=%u\n",
+				 entry[0],
+				 FIELD_GET(CDAT_HEADER_DW1_REVISION, entry[1]),
+				 FIELD_GET(CDAT_HEADER_DW1_CHECKSUM, entry[1]),
+				 entry[2]);
+		} else {
+			u8 entry_type = FIELD_GET(CDAT_STRUCTURE_DW0_TYPE, entry[0]);
+
+			switch (entry_type) {
+			case CDAT_STRUCTURE_DW0_TYPE_DSMAS:
+				pci_info(dev,
+					 "CDAT DSMAS (handle=%u flags=0x%x, dpa(0x%llx 0x%llx)\n",
+					 FIELD_GET(CDAT_DSMAS_DW1_DSMAD_HANDLE, entry[1]),
+					 FIELD_GET(CDAT_DSMAS_DW1_FLAGS, entry[1]),
+					 CDAT_DSMAS_DPA_OFFSET(entry),
+					 CDAT_DSMAS_DPA_LEN(entry));
+				break;
+			case CDAT_STRUCTURE_DW0_TYPE_DSLBIS:
+				pci_info(dev,
+					 "CDAT DSLBIS (handle=%u flags=0x%x, ent_base=0x%llx, entry[%u %u %u])\n",
+					 FIELD_GET(CDAT_DSLBIS_DW1_HANDLE, entry[1]),
+					 FIELD_GET(CDAT_DSLBIS_DW1_FLAGS, entry[1]),
+					 CDAT_DSLBIS_BASE_UNIT(entry),
+					 FIELD_GET(CDAT_DSLBIS_DW4_ENTRY_0, entry[4]),
+					 FIELD_GET(CDAT_DSLBIS_DW4_ENTRY_1, entry[4]),
+					 FIELD_GET(CDAT_DSLBIS_DW5_ENTRY_2, entry[5]));
+				break;
+			case CDAT_STRUCTURE_DW0_TYPE_DSMSCIS:
+				pci_info(dev,
+					 "CDAT DSMSCIS (handle=%u sc_size=0x%llx attrs=0x%x)\n",
+					 FIELD_GET(CDAT_DSMSCIS_DW1_HANDLE, entry[1]),
+					 CDAT_DSMSCIS_MEMORY_SIDE_CACHE_SIZE(entry),
+					 FIELD_GET(CDAT_DSMSCIS_DW4_MEMORY_SIDE_CACHE_ATTRS,
+						   entry[4]));
+				break;
+			case CDAT_STRUCTURE_DW0_TYPE_DSIS:
+				pci_info(dev,
+					 "CDAT DSIS (handle=%u flags=0x%x)\n",
+					 FIELD_GET(CDAT_DSIS_DW1_HANDLE, entry[1]),
+					 FIELD_GET(CDAT_DSIS_DW1_FLAGS, entry[1]));
+				break;
+			case CDAT_STRUCTURE_DW0_TYPE_DSEMTS:
+				pci_info(dev,
+					 "CDAT DSEMTS (handle=%u EFI=0x%x dpa(0x%llx 0x%llx)\n",
+					 FIELD_GET(CDAT_DSEMTS_DW1_HANDLE, entry[1]),
+					 FIELD_GET(CDAT_DSEMTS_DW1_EFI_MEMORY_TYPE_ATTR,
+						   entry[1]),
+					 CDAT_DSEMTS_DPA_OFFSET(entry),
+					 CDAT_DSEMTS_DPA_LENGTH(entry));
+				break;
+			case CDAT_STRUCTURE_DW0_TYPE_SSLBIS:
+				pci_info(dev,
+					 "CDAT SSLBIS (type%u ent_base=%llu...)\n",
+					 FIELD_GET(CDAT_SSLBIS_DW1_DATA_TYPE,
+						   entry[1]),
+					 CDAT_SSLBIS_BASE_UNIT(entry));
+				break;
+			}
+		}
+		entry_handle = FIELD_GET(CXL_DOE_TABLE_ACCESS_ENTRY_HANDLE,
+					 cdat_response_pl[0]);
+	} while (entry_handle != 0xFFFF);
+
+	return 0;
+}
+
 static void cxl_mem_free_irq_vectors(void *data)
 {
 	pci_free_irq_vectors(data);
@@ -1144,6 +1242,10 @@ static struct cxl_mem *cxl_mem_create(struct pci_dev *pdev, u32 reg_lo,
 	cxlm->table_doe = pcie_doe_find(pdev, PCI_DVSEC_VENDOR_ID_CXL,
 					CXL_DOE_PROTOCOL_TABLE_ACCESS);
 
+	rc = cdat_dump(cxlm->table_doe);
+	if (rc)
+		return NULL;
+
 	dev_dbg(dev, "Mapped CXL Memory Device resource\n");
 	return cxlm;
 }
Signature · 1 line
2.19.1