dmaengine: idxd: add event log size sysfs attribute

Add support for changing of the event log size. Event log is a
feature added to DSA 2.0 hardware to improve error reporting.
It supersedes the SWERROR register on DSA 1.0 hardware and hope
to prevent loss of reported errors.

The error log size determines how many error entries supported for
the device. It can be configured by the user via sysfs attribute.

Tested-by: Tony Zhu <tony.zhu@intel.com>
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Co-developed-by: Fenghua Yu <fenghua.yu@intel.com>
Signed-off-by: Fenghua Yu <fenghua.yu@intel.com>
Link: https://lore.kernel.org/r/20230407203143.2189681-3-fenghua.yu@intel.com
Signed-off-by: Vinod Koul <vkoul@kernel.org>

diff --git a/Documentation/ABI/stable/sysfs-driver-dma-idxd b/Documentation/ABI/stable/sysfs-driver-dma-idxd
index d5e3dd3d843475f22a722be553f58b448282b922..e019166114525075c0d2d12f3ea52c9e310af880 100644 (file)
--- a/Documentation/ABI/stable/sysfs-driver-dma-idxd
+++ b/Documentation/ABI/stable/sysfs-driver-dma-idxd
@@ -144,6 +144,14 @@ Description:       IAA (IAX) capability mask. Exported to user space for application
                consumption. This attribute should only be visible on IAA devices
                that are version 2 or later.
 
+What:          /sys/bus/dsa/devices/dsa<m>/event_log_size
+Date:          Sept 14, 2022
+KernelVersion: 6.4.0
+Contact:       dmaengine@vger.kernel.org
+Description:   The event log size to be configured. Default is 64 entries and
+               occupies 4k size if the evl entry is 64 bytes. It's visible
+               only on platforms that support the capability.
+
 What:          /sys/bus/dsa/devices/wq<m>.<n>/block_on_fault
 Date:          Oct 27, 2020
 KernelVersion: 5.11.0

diff --git a/drivers/dma/idxd/idxd.h b/drivers/dma/idxd/idxd.h
index eca2c9d76db6e9020fbed7e8f695f0c2eb6cf6f3..2a71273f18226ca90535f74680f8906f5741dbf7 100644 (file)
--- a/drivers/dma/idxd/idxd.h
+++ b/drivers/dma/idxd/idxd.h
@@ -261,6 +261,10 @@ struct idxd_driver_data {
        int align;
 };
 
+struct idxd_evl {
+       u16 size;
+};
+
 struct idxd_device {
        struct idxd_dev idxd_dev;
        struct idxd_driver_data *data;
@@ -317,6 +321,7 @@ struct idxd_device {
        struct idxd_pmu *idxd_pmu;
 
        unsigned long *opcap_bmap;
+       struct idxd_evl *evl;
 };
 
 /* IDXD software descriptor */

diff --git a/drivers/dma/idxd/init.c b/drivers/dma/idxd/init.c
index a78cfd361c04a173e56920e2b8fcf535930ebc34..525de59df82a2e82d509b53fc2f8e044969af0ff 100644 (file)
--- a/drivers/dma/idxd/init.c
+++ b/drivers/dma/idxd/init.c
@@ -331,6 +331,23 @@ static void idxd_cleanup_internals(struct idxd_device *idxd)
        destroy_workqueue(idxd->wq);
 }
 
+static int idxd_init_evl(struct idxd_device *idxd)
+{
+       struct device *dev = &idxd->pdev->dev;
+       struct idxd_evl *evl;
+
+       if (idxd->hw.gen_cap.evl_support == 0)
+               return 0;
+
+       evl = kzalloc_node(sizeof(*evl), GFP_KERNEL, dev_to_node(dev));
+       if (!evl)
+               return -ENOMEM;
+
+       evl->size = IDXD_EVL_SIZE_MIN;
+       idxd->evl = evl;
+       return 0;
+}
+
 static int idxd_setup_internals(struct idxd_device *idxd)
 {
        struct device *dev = &idxd->pdev->dev;
@@ -356,8 +373,14 @@ static int idxd_setup_internals(struct idxd_device *idxd)
                goto err_wkq_create;
        }
 
+       rc = idxd_init_evl(idxd);
+       if (rc < 0)
+               goto err_evl;
+
        return 0;
 
+ err_evl:
+       destroy_workqueue(idxd->wq);
  err_wkq_create:
        for (i = 0; i < idxd->max_groups; i++)
                put_device(group_confdev(idxd->groups[i]));

diff --git a/drivers/dma/idxd/registers.h b/drivers/dma/idxd/registers.h
index 338289a66f00804bb1b4c066b6640432325806fa..ea3a499a3c3c478490634197a2beeb6d0d40db34 100644 (file)
--- a/drivers/dma/idxd/registers.h
+++ b/drivers/dma/idxd/registers.h
@@ -31,7 +31,9 @@ union gen_cap_reg {
                u64 rsvd:3;
                u64 dest_readback:1;
                u64 drain_readback:1;
-               u64 rsvd2:6;
+               u64 rsvd2:3;
+               u64 evl_support:2;
+               u64 rsvd4:1;
                u64 max_xfer_shift:5;
                u64 max_batch_shift:4;
                u64 max_ims_mult:6;
@@ -297,6 +299,9 @@ union iaa_cap_reg {
 
 #define IDXD_IAACAP_OFFSET     0x180
 
+#define IDXD_EVL_SIZE_MIN      0x0040
+#define IDXD_EVL_SIZE_MAX      0xffff
+
 union msix_perm {
        struct {
                u32 rsvd:2;

diff --git a/drivers/dma/idxd/sysfs.c b/drivers/dma/idxd/sysfs.c
index 2eba8cab25a1e93660311571642cecf3ae95281e..85644e5bde8398b1eb2cc2e6a23565b86cdc3f6f 100644 (file)
--- a/drivers/dma/idxd/sysfs.c
+++ b/drivers/dma/idxd/sysfs.c
@@ -1573,6 +1573,46 @@ static ssize_t iaa_cap_show(struct device *dev,
 }
 static DEVICE_ATTR_RO(iaa_cap);
 
+static ssize_t event_log_size_show(struct device *dev,
+                                  struct device_attribute *attr, char *buf)
+{
+       struct idxd_device *idxd = confdev_to_idxd(dev);
+
+       if (!idxd->evl)
+               return -EOPNOTSUPP;
+
+       return sysfs_emit(buf, "%u\n", idxd->evl->size);
+}
+
+static ssize_t event_log_size_store(struct device *dev,
+                                   struct device_attribute *attr,
+                                   const char *buf, size_t count)
+{
+       struct idxd_device *idxd = confdev_to_idxd(dev);
+       unsigned long val;
+       int rc;
+
+       if (!idxd->evl)
+               return -EOPNOTSUPP;
+
+       rc = kstrtoul(buf, 10, &val);
+       if (rc < 0)
+               return -EINVAL;
+
+       if (idxd->state == IDXD_DEV_ENABLED)
+               return -EPERM;
+
+       if (!test_bit(IDXD_FLAG_CONFIGURABLE, &idxd->flags))
+               return -EPERM;
+
+       if (val < IDXD_EVL_SIZE_MIN || val > IDXD_EVL_SIZE_MAX)
+               return -EINVAL;
+
+       idxd->evl->size = val;
+       return count;
+}
+static DEVICE_ATTR_RW(event_log_size);
+
 static bool idxd_device_attr_max_batch_size_invisible(struct attribute *attr,
                                                      struct idxd_device *idxd)
 {
@@ -1603,6 +1643,13 @@ static bool idxd_device_attr_iaa_cap_invisible(struct attribute *attr,
               idxd->hw.version < DEVICE_VERSION_2);
 }
 
+static bool idxd_device_attr_event_log_size_invisible(struct attribute *attr,
+                                                     struct idxd_device *idxd)
+{
+       return (attr == &dev_attr_event_log_size.attr &&
+               !idxd->hw.gen_cap.evl_support);
+}
+
 static umode_t idxd_device_attr_visible(struct kobject *kobj,
                                        struct attribute *attr, int n)
 {
@@ -1618,6 +1665,9 @@ static umode_t idxd_device_attr_visible(struct kobject *kobj,
        if (idxd_device_attr_iaa_cap_invisible(attr, idxd))
                return 0;
 
+       if (idxd_device_attr_event_log_size_invisible(attr, idxd))
+               return 0;
+
        return attr->mode;
 }
 
@@ -1644,6 +1694,7 @@ static struct attribute *idxd_device_attributes[] = {
        &dev_attr_cdev_major.attr,
        &dev_attr_cmd_status.attr,
        &dev_attr_iaa_cap.attr,
+       &dev_attr_event_log_size.attr,
        NULL,
 };
 
@@ -1665,6 +1716,7 @@ static void idxd_conf_device_release(struct device *dev)
        bitmap_free(idxd->wq_enable_map);
        kfree(idxd->wqs);
        kfree(idxd->engines);
+       kfree(idxd->evl);
        ida_free(&idxd_ida, idxd->id);
        bitmap_free(idxd->opcap_bmap);
        kfree(idxd);