PCI Data Object Exchange support + CXL CDAT
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
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
@@ -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
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
Signed-off-by Jonathan Cameron <[email protected]>---
Since V1: New Patchinclude/linux/pci_ids.h | 1 + 1 file changed, 1 insertion(+)include/linux/pci_ids.h +1
-0@@ -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 0x0014Signature · 1 line
2.19.1
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
Signed-off-by Jonathan Cameron <[email protected]>---
Since V1: New Patchinclude/linux/pci_ids.h | 1 + 1 file changed, 1 insertion(+)include/linux/pci_ids.h +1
-0@@ -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 0x0014Signature · 1 line
2.19.1
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
Signed-off-by Jonathan Cameron <[email protected]>---
Since V1: New Patchinclude/linux/pci_ids.h | 1 + 1 file changed, 1 insertion(+)include/linux/pci_ids.h +1
-0@@ -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 0x0014Signature · 1 line
2.19.1
RFC PATCH v2 2/4 PCI/doe: Initial support PCI Data Object Exchange
In reply to Jonathan CameronIntroduced 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
@@ -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
@@ -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
@@ -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
@@ -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
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.
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
Signed-off-by Jonathan Cameron <[email protected]>---
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 structpci_dev. A single call topcie_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 structpci_devavoiding 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 topcie_doe_find()to get a pointer to the first appropriate DOE. Note, a side effect of minimizing impact of this on structpci_devis 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 inmod_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 structpcie_doe_exchangeto 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 awaydevm_stuff in calls that don't make it obvious.Minor stuff:
*pcie_doe_init()andpcie_doe_registerseparation to cover the bits that can fail inregister()and the bits that can't ininit()
* Many typos
* Renamecap_offsetfield to cap
* Use newPCI_VENDOR_ID_PCI_SIGdefine to avoid open coding the value
* Add defines for timeouts etc.
* MissingEXPORT_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@@ -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
-0support 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@@ -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.odrivers/pci/pcie/doe.c new file +14
-0@@ -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@@ -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@@ -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@@ -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
RFC PATCH v2 3/4 cxl/mem: Add CDAT table reading from DOE
In reply to Jonathan CameronThis 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
@@ -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
@@ -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
kernel test robot
build botRe: [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
kernel test robot
build botRe: [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
Re: [RFC PATCH v2 3/4] cxl/mem: Add CDAT table reading from DOE
In reply to Jonathan CameronQuoted 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 ; +} +
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 ; +} +
RFC PATCH v2 4/4 cxl/mem: Add a debug parser for CDAT commands.
In reply to Jonathan CameronLogs 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
@@ -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