cxl: Export optional AFU configuration record in sysfs
authorIan Munsie <imunsie@au1.ibm.com>
Wed, 4 Feb 2015 08:09:01 +0000 (19:09 +1100)
committerMichael Ellerman <mpe@ellerman.id.au>
Fri, 6 Feb 2015 00:16:56 +0000 (11:16 +1100)
An AFU may optionally contain one or more PCIe like configuration
records, which can be used to identify the AFU.

This patch adds support for exposing the raw config space and the
vendor, device and class code under sysfs. These will appear in a
subdirectory of the AFU device corresponding with the configuration
record number, e.g.

cat /sys/class/cxl/afu0.0/cr0/vendor
0x1014

cat /sys/class/cxl/afu0.0/cr0/device
0x4350

cat /sys/class/cxl/afu0.0/cr0/class
0x120000

hexdump -C /sys/class/cxl/afu0.0/cr0/config
00000000  14 10 50 43 00 00 00 00  06 00 00 12 00 00 00 00  |..PC............|
00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00000100

These files behave in much the same way as the equivalent files for PCI
devices, with one exception being that the config file is currently
read-only and restricted to the root user. It is not necessarily
required to be this strict, but we currently do not have a compelling
use-case to make it writable and/or world-readable, so I erred on the
side of being restrictive.

Signed-off-by: Ian Munsie <imunsie@au1.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Documentation/ABI/testing/sysfs-class-cxl
drivers/misc/cxl/cxl.h
drivers/misc/cxl/pci.c
drivers/misc/cxl/sysfs.c

index 9ea01068a16c15b91c282145e1e30215c78cff42..3680364b404885cf509f6d2b1261f342873f4244 100644 (file)
@@ -81,6 +81,43 @@ Description:    read only
                 this this kernel supports.
 
 
+AFU configuration records (eg. /sys/class/cxl/afu0.0/cr0):
+
+An AFU may optionally export one or more PCIe like configuration records, known
+as AFU configuration records, which will show up here (if present).
+
+What:           /sys/class/cxl/<afu>/cr<config num>/vendor
+Date:           February 2015
+Contact:        linuxppc-dev@lists.ozlabs.org
+Description:    read only
+               Hexadecimal value of the vendor ID found in this AFU
+               configuration record.
+
+What:           /sys/class/cxl/<afu>/cr<config num>/device
+Date:           February 2015
+Contact:        linuxppc-dev@lists.ozlabs.org
+Description:    read only
+               Hexadecimal value of the device ID found in this AFU
+               configuration record.
+
+What:           /sys/class/cxl/<afu>/cr<config num>/vendor
+Date:           February 2015
+Contact:        linuxppc-dev@lists.ozlabs.org
+Description:    read only
+               Hexadecimal value of the class code found in this AFU
+               configuration record.
+
+What:           /sys/class/cxl/<afu>/cr<config num>/config
+Date:           February 2015
+Contact:        linuxppc-dev@lists.ozlabs.org
+Description:    read only
+               This binary file provides raw access to the AFU configuration
+               record. The format is expected to match the either the standard
+               or extended configuration space defined by the PCIe
+               specification.
+
+
+
 Master contexts (eg. /sys/class/cxl/afu0.0m)
 
 What:           /sys/class/cxl/<afu>m/mmio_size
index 6a6a487464c58e003ec3207fd17a2dfb25a8ab05..a1cee4767ec6c571344e93ca874e8bdac83ed3a5 100644 (file)
@@ -382,6 +382,10 @@ struct cxl_afu {
        int slice;
        int modes_supported;
        int current_mode;
+       int crs_num;
+       u64 crs_len;
+       u64 crs_offset;
+       struct list_head crs;
        enum prefault_modes prefault_mode;
        bool psa;
        bool pp_psa;
@@ -551,6 +555,15 @@ static inline void __iomem *_cxl_p2n_addr(struct cxl_afu *afu, cxl_p2n_reg_t reg
 #define cxl_p2n_read(afu, reg) \
        in_be64(_cxl_p2n_addr(afu, reg))
 
+
+#define cxl_afu_cr_read64(afu, cr, off) \
+       in_le64((afu)->afu_desc_mmio + (afu)->crs_offset + ((cr) * (afu)->crs_len) + (off))
+#define cxl_afu_cr_read32(afu, cr, off) \
+       in_le32((afu)->afu_desc_mmio + (afu)->crs_offset + ((cr) * (afu)->crs_len) + (off))
+u16 cxl_afu_cr_read16(struct cxl_afu *afu, int cr, u64 off);
+u8 cxl_afu_cr_read8(struct cxl_afu *afu, int cr, u64 off);
+
+
 struct cxl_calls {
        void (*cxl_slbia)(struct mm_struct *mm);
        struct module *owner;
index cb250673b5c634b13aaeff3aab935dd92e7735e8..2b2e1b80d759851dba2c15774e407e728523e56f 100644 (file)
 #define   AFUD_EB_LEN(val)             EXTRACT_PPC_BITS(val, 8, 63)
 #define AFUD_READ_EB_OFF(afu)          AFUD_READ(afu, 0x48)
 
+u16 cxl_afu_cr_read16(struct cxl_afu *afu, int cr, u64 off)
+{
+       u64 aligned_off = off & ~0x3L;
+       u32 val;
+
+       val = cxl_afu_cr_read32(afu, cr, aligned_off);
+       return (val >> ((off & 0x2) * 8)) & 0xffff;
+}
+
+u8 cxl_afu_cr_read8(struct cxl_afu *afu, int cr, u64 off)
+{
+       u64 aligned_off = off & ~0x3L;
+       u32 val;
+
+       val = cxl_afu_cr_read32(afu, cr, aligned_off);
+       return (val >> ((off & 0x3) * 8)) & 0xff;
+}
+
 static DEFINE_PCI_DEVICE_TABLE(cxl_pci_tbl) = {
        { PCI_DEVICE(PCI_VENDOR_ID_IBM, 0x0477), },
        { PCI_DEVICE(PCI_VENDOR_ID_IBM, 0x044b), },
@@ -556,6 +574,7 @@ static int cxl_read_afu_descriptor(struct cxl_afu *afu)
        val = AFUD_READ_INFO(afu);
        afu->pp_irqs = AFUD_NUM_INTS_PER_PROC(val);
        afu->max_procs_virtualised = AFUD_NUM_PROCS(val);
+       afu->crs_num = AFUD_NUM_CRS(val);
 
        if (AFUD_AFU_DIRECTED(val))
                afu->modes_supported |= CXL_MODE_DIRECTED;
@@ -570,6 +589,10 @@ static int cxl_read_afu_descriptor(struct cxl_afu *afu)
        if ((afu->pp_psa = AFUD_PPPSA_PP(val)))
                afu->pp_offset = AFUD_READ_PPPSA_OFF(afu);
 
+       val = AFUD_READ_CR(afu);
+       afu->crs_len = AFUD_CR_LEN(val) * 256;
+       afu->crs_offset = AFUD_READ_CR_OFF(afu);
+
        return 0;
 }
 
index adf1f6d849131eefaf6f7520651dd780800cd326..d0c38c7bc0c4bfb552f568f59f4f4371809b3b1f 100644 (file)
@@ -10,6 +10,7 @@
 #include <linux/kernel.h>
 #include <linux/device.h>
 #include <linux/sysfs.h>
+#include <linux/pci_regs.h>
 
 #include "cxl.h"
 
@@ -367,8 +368,6 @@ static struct device_attribute afu_attrs[] = {
        __ATTR(reset, S_IWUSR, NULL, reset_store_afu),
 };
 
-
-
 int cxl_sysfs_adapter_add(struct cxl *adapter)
 {
        int i, rc;
@@ -391,31 +390,191 @@ void cxl_sysfs_adapter_remove(struct cxl *adapter)
                device_remove_file(&adapter->dev, &adapter_attrs[i]);
 }
 
+struct afu_config_record {
+       struct kobject kobj;
+       struct bin_attribute config_attr;
+       struct list_head list;
+       int cr;
+       u16 device;
+       u16 vendor;
+       u32 class;
+};
+
+#define to_cr(obj) container_of(obj, struct afu_config_record, kobj)
+
+static ssize_t vendor_show(struct kobject *kobj,
+                          struct kobj_attribute *attr, char *buf)
+{
+       struct afu_config_record *cr = to_cr(kobj);
+
+       return scnprintf(buf, PAGE_SIZE, "0x%.4x\n", cr->vendor);
+}
+
+static ssize_t device_show(struct kobject *kobj,
+                          struct kobj_attribute *attr, char *buf)
+{
+       struct afu_config_record *cr = to_cr(kobj);
+
+       return scnprintf(buf, PAGE_SIZE, "0x%.4x\n", cr->device);
+}
+
+static ssize_t class_show(struct kobject *kobj,
+                         struct kobj_attribute *attr, char *buf)
+{
+       struct afu_config_record *cr = to_cr(kobj);
+
+       return scnprintf(buf, PAGE_SIZE, "0x%.6x\n", cr->class);
+}
+
+static ssize_t afu_read_config(struct file *filp, struct kobject *kobj,
+                              struct bin_attribute *bin_attr, char *buf,
+                              loff_t off, size_t count)
+{
+       struct afu_config_record *cr = to_cr(kobj);
+       struct cxl_afu *afu = to_cxl_afu(container_of(kobj->parent, struct device, kobj));
+
+       u64 i, j, val, size = afu->crs_len;
+
+       if (off > size)
+               return 0;
+       if (off + count > size)
+               count = size - off;
+
+       for (i = 0; i < count;) {
+               val = cxl_afu_cr_read64(afu, cr->cr, off & ~0x7);
+               for (j = off & 0x7; j < 8 && i < count; i++, j++, off++)
+                       buf[i] = (val >> (j * 8)) & 0xff;
+       }
+
+       return count;
+}
+
+static struct kobj_attribute vendor_attribute =
+       __ATTR_RO(vendor);
+static struct kobj_attribute device_attribute =
+       __ATTR_RO(device);
+static struct kobj_attribute class_attribute =
+       __ATTR_RO(class);
+
+static struct attribute *afu_cr_attrs[] = {
+       &vendor_attribute.attr,
+       &device_attribute.attr,
+       &class_attribute.attr,
+       NULL,
+};
+
+static void release_afu_config_record(struct kobject *kobj)
+{
+       struct afu_config_record *cr = to_cr(kobj);
+
+       kfree(cr);
+}
+
+static struct kobj_type afu_config_record_type = {
+       .sysfs_ops = &kobj_sysfs_ops,
+       .release = release_afu_config_record,
+       .default_attrs = afu_cr_attrs,
+};
+
+static struct afu_config_record *cxl_sysfs_afu_new_cr(struct cxl_afu *afu, int cr_idx)
+{
+       struct afu_config_record *cr;
+       int rc;
+
+       cr = kzalloc(sizeof(struct afu_config_record), GFP_KERNEL);
+       if (!cr)
+               return ERR_PTR(-ENOMEM);
+
+       cr->cr = cr_idx;
+       cr->device = cxl_afu_cr_read16(afu, cr_idx, PCI_DEVICE_ID);
+       cr->vendor = cxl_afu_cr_read16(afu, cr_idx, PCI_VENDOR_ID);
+       cr->class = cxl_afu_cr_read32(afu, cr_idx, PCI_CLASS_REVISION) >> 8;
+
+       /*
+        * Export raw AFU PCIe like config record. For now this is read only by
+        * root - we can expand that later to be readable by non-root and maybe
+        * even writable provided we have a good use-case. Once we suport
+        * exposing AFUs through a virtual PHB they will get that for free from
+        * Linux' PCI infrastructure, but until then it's not clear that we
+        * need it for anything since the main use case is just identifying
+        * AFUs, which can be done via the vendor, device and class attributes.
+        */
+       sysfs_bin_attr_init(&cr->config_attr);
+       cr->config_attr.attr.name = "config";
+       cr->config_attr.attr.mode = S_IRUSR;
+       cr->config_attr.size = afu->crs_len;
+       cr->config_attr.read = afu_read_config;
+
+       rc = kobject_init_and_add(&cr->kobj, &afu_config_record_type,
+                                 &afu->dev.kobj, "cr%i", cr->cr);
+       if (rc)
+               goto err;
+
+       rc = sysfs_create_bin_file(&cr->kobj, &cr->config_attr);
+       if (rc)
+               goto err1;
+
+       rc = kobject_uevent(&cr->kobj, KOBJ_ADD);
+       if (rc)
+               goto err2;
+
+       return cr;
+err2:
+       sysfs_remove_bin_file(&cr->kobj, &cr->config_attr);
+err1:
+       kobject_put(&cr->kobj);
+       return ERR_PTR(rc);
+err:
+       kfree(cr);
+       return ERR_PTR(rc);
+}
+
+void cxl_sysfs_afu_remove(struct cxl_afu *afu)
+{
+       struct afu_config_record *cr, *tmp;
+       int i;
+
+       for (i = 0; i < ARRAY_SIZE(afu_attrs); i++)
+               device_remove_file(&afu->dev, &afu_attrs[i]);
+
+       list_for_each_entry_safe(cr, tmp, &afu->crs, list) {
+               sysfs_remove_bin_file(&cr->kobj, &cr->config_attr);
+               kobject_put(&cr->kobj);
+       }
+}
+
 int cxl_sysfs_afu_add(struct cxl_afu *afu)
 {
+       struct afu_config_record *cr;
        int i, rc;
 
+       INIT_LIST_HEAD(&afu->crs);
+
        for (i = 0; i < ARRAY_SIZE(afu_attrs); i++) {
                if ((rc = device_create_file(&afu->dev, &afu_attrs[i])))
                        goto err;
        }
 
+       for (i = 0; i < afu->crs_num; i++) {
+               cr = cxl_sysfs_afu_new_cr(afu, i);
+               if (IS_ERR(cr)) {
+                       rc = PTR_ERR(cr);
+                       goto err1;
+               }
+               list_add(&cr->list, &afu->crs);
+       }
+
        return 0;
 
+err1:
+       cxl_sysfs_afu_remove(afu);
+       return rc;
 err:
        for (i--; i >= 0; i--)
                device_remove_file(&afu->dev, &afu_attrs[i]);
        return rc;
 }
 
-void cxl_sysfs_afu_remove(struct cxl_afu *afu)
-{
-       int i;
-
-       for (i = 0; i < ARRAY_SIZE(afu_attrs); i++)
-               device_remove_file(&afu->dev, &afu_attrs[i]);
-}
-
 int cxl_sysfs_afu_m_add(struct cxl_afu *afu)
 {
        int i, rc;