// SPDX-License-Identifier: GPL-2.0
/*
 * Intel Platform Monitory Technology Telemetry driver
 *
 * Copyright (c) 2020, Intel Corporation.
 * All Rights Reserved.
 *
 * Author: "Alexander Duyck" <alexander.h.duyck@linux.intel.com>
 */

#include <linux/kernel.h>
#include <linux/log2.h>
#include <linux/intel_vsec.h>
#include <linux/io-64-nonatomic-lo-hi.h>
#include <linux/minmax.h>
#include <linux/module.h>
#include <linux/mm.h>
#include <linux/pci.h>
#include <linux/sysfs.h>

#include "class.h"

#define PMT_XA_START            1
#define PMT_XA_MAX              INT_MAX
#define PMT_XA_LIMIT            XA_LIMIT(PMT_XA_START, PMT_XA_MAX)
#define GUID_SPR_PUNIT          0x9956f43f

bool intel_pmt_is_early_client_hw(struct device *dev)
{
        struct intel_vsec_device *ivdev = dev_to_ivdev(dev);

        /*
         * Early implementations of PMT on client platforms have some
         * differences from the server platforms (which use the Out Of Band
         * Management Services Module OOBMSM).
         */
        return !!(ivdev->quirks & VSEC_QUIRK_EARLY_HW);
}
EXPORT_SYMBOL_NS_GPL(intel_pmt_is_early_client_hw, "INTEL_PMT");

static inline int
pmt_memcpy64_fromio(void *to, const u64 __iomem *from, size_t count)
{
        int i, remain;
        u64 *buf = to;

        if (!IS_ALIGNED((unsigned long)from, 8))
                return -EFAULT;

        for (i = 0; i < count/8; i++)
                buf[i] = readq(&from[i]);

        /* Copy any remaining bytes */
        remain = count % 8;
        if (remain) {
                u64 tmp = readq(&from[i]);

                memcpy(&buf[i], &tmp, remain);
        }

        return count;
}

int pmt_telem_read_mmio(struct device *dev, struct pmt_callbacks *cb, u32 guid, void *buf,
                        void __iomem *addr, loff_t off, u32 count)
{
        if (cb && cb->read_telem)
                return cb->read_telem(dev, guid, buf, off, count);

        addr += off;

        if (guid == GUID_SPR_PUNIT)
                /* PUNIT on SPR only supports aligned 64-bit read */
                return pmt_memcpy64_fromio(buf, addr, count);

        memcpy_fromio(buf, addr, count);

        return count;
}
EXPORT_SYMBOL_NS_GPL(pmt_telem_read_mmio, "INTEL_PMT");

/*
 * sysfs
 */
static ssize_t
intel_pmt_read(struct file *filp, struct kobject *kobj,
               const struct bin_attribute *attr, char *buf, loff_t off,
               size_t count)
{
        struct intel_pmt_entry *entry = container_of(attr,
                                                     struct intel_pmt_entry,
                                                     pmt_bin_attr);

        if (off < 0)
                return -EINVAL;

        if (off >= entry->size)
                return 0;

        if (count > entry->size - off)
                count = entry->size - off;

        count = pmt_telem_read_mmio(entry->ep->dev, entry->cb, entry->header.guid, buf,
                                    entry->base, off, count);

        return count;
}

static int
intel_pmt_mmap(struct file *filp, struct kobject *kobj,
                const struct bin_attribute *attr, struct vm_area_struct *vma)
{
        struct intel_pmt_entry *entry = container_of(attr,
                                                     struct intel_pmt_entry,
                                                     pmt_bin_attr);
        unsigned long vsize = vma->vm_end - vma->vm_start;
        struct device *dev = kobj_to_dev(kobj);
        unsigned long phys = entry->base_addr;
        unsigned long pfn = PFN_DOWN(phys);
        unsigned long psize;

        if (vma->vm_flags & (VM_WRITE | VM_MAYWRITE))
                return -EROFS;

        psize = (PFN_UP(entry->base_addr + entry->size) - pfn) * PAGE_SIZE;
        if (vsize > psize) {
                dev_err(dev, "Requested mmap size is too large\n");
                return -EINVAL;
        }

        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
        if (io_remap_pfn_range(vma, vma->vm_start, pfn,
                vsize, vma->vm_page_prot))
                return -EAGAIN;

        return 0;
}

static ssize_t
guid_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        struct intel_pmt_entry *entry = dev_get_drvdata(dev);

        return sysfs_emit(buf, "0x%x\n", entry->guid);
}
static DEVICE_ATTR_RO(guid);

static ssize_t size_show(struct device *dev, struct device_attribute *attr,
                         char *buf)
{
        struct intel_pmt_entry *entry = dev_get_drvdata(dev);

        return sysfs_emit(buf, "%zu\n", entry->size);
}
static DEVICE_ATTR_RO(size);

static ssize_t
offset_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        struct intel_pmt_entry *entry = dev_get_drvdata(dev);

        return sysfs_emit(buf, "%lu\n", offset_in_page(entry->base_addr));
}
static DEVICE_ATTR_RO(offset);

static struct attribute *intel_pmt_attrs[] = {
        &dev_attr_guid.attr,
        &dev_attr_size.attr,
        &dev_attr_offset.attr,
        NULL
};

static umode_t intel_pmt_attr_visible(struct kobject *kobj,
                                      struct attribute *attr, int n)
{
        struct device *dev = container_of(kobj, struct device, kobj);
        struct auxiliary_device *auxdev = to_auxiliary_dev(dev->parent);
        struct intel_vsec_device *ivdev = auxdev_to_ivdev(auxdev);

        /*
         * Place the discovery features folder in /sys/class/intel_pmt, but
         * exclude the common attributes as they are not applicable.
         */
        if (ivdev->cap_id == ilog2(VSEC_CAP_DISCOVERY))
                return 0;

        return attr->mode;
}

static bool intel_pmt_group_visible(struct kobject *kobj)
{
        return true;
}
DEFINE_SYSFS_GROUP_VISIBLE(intel_pmt);

static const struct attribute_group intel_pmt_group = {
        .attrs = intel_pmt_attrs,
        .is_visible = SYSFS_GROUP_VISIBLE(intel_pmt),
};
__ATTRIBUTE_GROUPS(intel_pmt);

struct class intel_pmt_class = {
        .name = "intel_pmt",
        .dev_groups = intel_pmt_groups,
};
EXPORT_SYMBOL_GPL(intel_pmt_class);

static int pmt_resolve_access_pci(struct intel_pmt_entry *entry,
                                  struct intel_vsec_device *ivdev,
                                  int idx)
{
        struct pci_dev *pci_dev = to_pci_dev(ivdev->dev);
        struct device *dev = &ivdev->auxdev.dev;
        struct intel_pmt_header *header = &entry->header;
        struct resource *disc_res;
        u8 bir;

        /*
         * The base offset should always be 8 byte aligned.
         *
         * For non-local access types the lower 3 bits of base offset
         * contains the index of the base address register where the
         * telemetry can be found.
         */
        bir = GET_BIR(header->base_offset);

        /* Local access and BARID only for now */
        switch (header->access_type) {
        case ACCESS_LOCAL:
                if (bir) {
                        dev_err(dev,
                                "Unsupported BAR index %d for access type %d\n",
                                bir, header->access_type);
                        return -EINVAL;
                }
                /*
                 * For access_type LOCAL, the base address is as follows:
                 * base address = end of discovery region + base offset
                 */
                disc_res = &ivdev->resource[idx];
                entry->base_addr = disc_res->end + 1 + header->base_offset;

                /*
                 * Some hardware use a different calculation for the base address
                 * when access_type == ACCESS_LOCAL. On the these systems
                 * ACCESS_LOCAL refers to an address in the same BAR as the
                 * header but at a fixed offset. But as the header address was
                 * supplied to the driver, we don't know which BAR it was in.
                 * So search for the bar whose range includes the header address.
                 */
                if (intel_pmt_is_early_client_hw(dev)) {
                        int i;

                        entry->base_addr = 0;
                        for (i = 0; i < 6; i++)
                                if (disc_res->start >= pci_resource_start(pci_dev, i) &&
                                   (disc_res->start <= pci_resource_end(pci_dev, i))) {
                                        entry->base_addr = pci_resource_start(pci_dev, i) +
                                                           header->base_offset;
                                        break;
                                }
                        if (!entry->base_addr)
                                return -EINVAL;
                }

                break;
        case ACCESS_BARID:
                /* Use the provided base address if it exists */
                if (ivdev->base_addr) {
                        entry->base_addr = ivdev->base_addr +
                                   GET_ADDRESS(header->base_offset);
                        break;
                }

                /*
                 * If another BAR was specified then the base offset
                 * represents the offset within that BAR. SO retrieve the
                 * address from the parent PCI device and add offset.
                 */
                entry->base_addr = pci_resource_start(pci_dev, bir) +
                                   GET_ADDRESS(header->base_offset);
                break;
        default:
                dev_err(dev, "Unsupported access type %d\n",
                        header->access_type);
                return -EINVAL;
        }

        entry->pcidev = pci_dev;

        return 0;
}

static int pmt_resolve_access_acpi(struct intel_pmt_entry *entry,
                                   struct intel_vsec_device *ivdev)
{
        struct pci_dev *pci_dev = NULL;
        struct device *dev = &ivdev->auxdev.dev;
        struct intel_pmt_header *header = &entry->header;
        u8 bir;

        if (dev_is_pci(ivdev->dev))
                pci_dev = to_pci_dev(ivdev->dev);

        /*
         * The base offset should always be 8 byte aligned.
         *
         * For non-local access types the lower 3 bits of base offset
         * contains the index of the base address register where the
         * telemetry can be found.
         */
        bir = GET_BIR(header->base_offset);

        switch (header->access_type) {
        case ACCESS_BARID:
                /* ACPI platform drivers use base_addr */
                if (ivdev->base_addr) {
                        entry->base_addr = ivdev->base_addr +
                                           GET_ADDRESS(header->base_offset);
                        break;
                }

                /* If base_addr is not provided, then this is an ACPI companion device */
                if (!pci_dev) {
                        dev_err(dev, "ACCESS_BARID requires PCI BAR resources or base_addr\n");
                        return -EINVAL;
                }

                entry->base_addr = pci_resource_start(pci_dev, bir) +
                                   GET_ADDRESS(header->base_offset);
                break;
        default:
                dev_err(dev, "Unsupported access type %d for ACPI based PMT\n",
                        header->access_type);
                return -EINVAL;
        }

        return 0;
}

static int intel_pmt_populate_entry(struct intel_pmt_entry *entry,
                                    struct intel_vsec_device *ivdev,
                                    int idx)
{
        struct intel_pmt_header *header = &entry->header;
        struct device *dev = &ivdev->auxdev.dev;
        int ret;

        switch (ivdev->src) {
        case INTEL_VSEC_DISC_PCI:
                ret = pmt_resolve_access_pci(entry, ivdev, idx);
                if (ret)
                        return ret;
                break;
        case INTEL_VSEC_DISC_ACPI:
                ret = pmt_resolve_access_acpi(entry, ivdev);
                if (ret)
                        return ret;
                break;
        default:
                dev_err(dev, "Unknown discovery source: %d\n", ivdev->src);
                return -EINVAL;
        }

        entry->guid = header->guid;
        entry->size = header->size;
        entry->cb = ivdev->priv_data;

        return 0;
}

static int intel_pmt_dev_register(struct intel_pmt_entry *entry,
                                  struct intel_pmt_namespace *ns,
                                  struct device *parent)
{
        struct intel_vsec_device *ivdev = dev_to_ivdev(parent);
        struct resource res = {0};
        struct device *dev;
        int ret;

        ret = xa_alloc(ns->xa, &entry->devid, entry, PMT_XA_LIMIT, GFP_KERNEL);
        if (ret)
                return ret;

        dev = device_create(&intel_pmt_class, parent, MKDEV(0, 0), entry,
                            "%s%d", ns->name, entry->devid);

        if (IS_ERR(dev)) {
                dev_err(parent, "Could not create %s%d device node\n",
                        ns->name, entry->devid);
                ret = PTR_ERR(dev);
                goto fail_dev_create;
        }

        entry->kobj = &dev->kobj;

        if (entry->attr_grp) {
                ret = sysfs_create_group(entry->kobj, entry->attr_grp);
                if (ret)
                        goto fail_sysfs_create_group;
        }

        /* if size is 0 assume no data buffer, so no file needed */
        if (!entry->size)
                return 0;

        res.start = entry->base_addr;
        res.end = res.start + entry->size - 1;
        res.flags = IORESOURCE_MEM;

        entry->base = devm_ioremap_resource(dev, &res);
        if (IS_ERR(entry->base)) {
                ret = PTR_ERR(entry->base);
                goto fail_ioremap;
        }

        sysfs_bin_attr_init(&entry->pmt_bin_attr);
        entry->pmt_bin_attr.attr.name = ns->name;
        entry->pmt_bin_attr.attr.mode = 0440;
        entry->pmt_bin_attr.mmap = intel_pmt_mmap;
        entry->pmt_bin_attr.read = intel_pmt_read;
        entry->pmt_bin_attr.size = entry->size;

        ret = sysfs_create_bin_file(&dev->kobj, &entry->pmt_bin_attr);
        if (ret)
                goto fail_ioremap;

        if (ns->pmt_add_endpoint) {
                ret = ns->pmt_add_endpoint(ivdev, entry);
                if (ret)
                        goto fail_add_endpoint;
        }

        return 0;

fail_add_endpoint:
        sysfs_remove_bin_file(entry->kobj, &entry->pmt_bin_attr);
fail_ioremap:
        if (entry->attr_grp)
                sysfs_remove_group(entry->kobj, entry->attr_grp);
fail_sysfs_create_group:
        device_unregister(dev);
fail_dev_create:
        xa_erase(ns->xa, entry->devid);

        return ret;
}

static int pmt_get_headers(struct intel_vsec_device *ivdev, int idx,
                           struct intel_pmt_entry *entry)
{
        struct device *dev = &ivdev->auxdev.dev;
        size_t header_bytes = sizeof(entry->disc_header);

        switch (ivdev->src) {
        case INTEL_VSEC_DISC_PCI: {
                struct resource *disc_res = &ivdev->resource[idx];
                void __iomem *disc_table;

                disc_table = devm_ioremap_resource(dev, disc_res);
                if (IS_ERR(disc_table))
                        return PTR_ERR(disc_table);

                /*
                 * The mapped resource is sized by the namespace's DVSEC
                 * entry_size (in dwords), which can be less than the default
                 * size (e.g. telemetry uses entry_size = 3, 12 bytes). Cap the
                 * copy to resource_size() to avoid reading past the mapped
                 * region.
                 */
                memset(entry->disc_header, 0, header_bytes);
                memcpy_fromio(entry->disc_header, disc_table,
                              min(header_bytes, resource_size(disc_res)));

                /* Used by crashlog driver */
                entry->disc_table = disc_table;

                return 0;
        }
        case INTEL_VSEC_DISC_ACPI: {
                memcpy(entry->disc_header, &ivdev->acpi_disc[idx][0], header_bytes);
                /*
                 * No MMIO mapping exists on the ACPI source path; the cached
                 * headers are the only view of the discovery record. Consumers
                 * that dereference disc_table (e.g. crashlog) must therefore
                 * only be wired to namespaces backed by INTEL_VSEC_DISC_PCI.
                 */
                entry->disc_table = NULL;

                return 0;
        }
        default:
                dev_err(dev, "Unknown discovery source type: %d\n", ivdev->src);
                break;
        }

        return -EINVAL;
}

int intel_pmt_dev_create(struct intel_pmt_entry *entry, struct intel_pmt_namespace *ns,
                         struct intel_vsec_device *intel_vsec_dev, int idx)
{
        struct device *dev = &intel_vsec_dev->auxdev.dev;
        int ret;

        ret = pmt_get_headers(intel_vsec_dev, idx, entry);
        if (ret)
                return ret;

        if (ns->pmt_pre_decode) {
                ret = ns->pmt_pre_decode(intel_vsec_dev, entry);
                if (ret)
                        return ret;
        }

        ret = ns->pmt_header_decode(entry, dev);
        if (ret)
                return ret;

        if (ns->pmt_post_decode) {
                ret = ns->pmt_post_decode(intel_vsec_dev, entry);
                if (ret)
                        return ret;
        }

        ret = intel_pmt_populate_entry(entry, intel_vsec_dev, idx);
        if (ret)
                return ret;

        return intel_pmt_dev_register(entry, ns, dev);
}
EXPORT_SYMBOL_NS_GPL(intel_pmt_dev_create, "INTEL_PMT");

void intel_pmt_dev_destroy(struct intel_pmt_entry *entry,
                           struct intel_pmt_namespace *ns)
{
        struct device *dev = kobj_to_dev(entry->kobj);

        if (entry->size)
                sysfs_remove_bin_file(entry->kobj, &entry->pmt_bin_attr);

        if (entry->attr_grp)
                sysfs_remove_group(entry->kobj, entry->attr_grp);

        device_unregister(dev);
        xa_erase(ns->xa, entry->devid);
}
EXPORT_SYMBOL_NS_GPL(intel_pmt_dev_destroy, "INTEL_PMT");

static int __init pmt_class_init(void)
{
        return class_register(&intel_pmt_class);
}

static void __exit pmt_class_exit(void)
{
        class_unregister(&intel_pmt_class);
}

module_init(pmt_class_init);
module_exit(pmt_class_exit);

MODULE_AUTHOR("Alexander Duyck <alexander.h.duyck@linux.intel.com>");
MODULE_DESCRIPTION("Intel PMT Class driver");
MODULE_LICENSE("GPL v2");