1 files changed, 359 insertions, 0 deletions

diff --git a/drivers/pci/endpoint/pci-epf-core.c b/drivers/pci/endpoint/pci-epf-core.c
new file mode 100644
index 000000000000..6877d6a5bcc9
--- /dev/null
+++ b/drivers/pci/endpoint/pci-epf-core.c
@@ -0,0 +1,359 @@
+/**
+ * PCI Endpoint *Function* (EPF) library
+ *
+ * Copyright (C) 2017 Texas Instruments
+ * Author: Kishon Vijay Abraham I <kishon@ti.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 of
+ * the License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+
+#include <linux/pci-epc.h>
+#include <linux/pci-epf.h>
+#include <linux/pci-ep-cfs.h>
+
+static struct bus_type pci_epf_bus_type;
+static struct device_type pci_epf_type;
+
+/**
+ * pci_epf_linkup() - Notify the function driver that EPC device has
+ *                    established a connection with the Root Complex.
+ * @epf: the EPF device bound to the EPC device which has established
+ *       the connection with the host
+ *
+ * Invoke to notify the function driver that EPC device has established
+ * a connection with the Root Complex.
+ */
+void pci_epf_linkup(struct pci_epf *epf)
+{
+        if (!epf->driver) {
+                dev_WARN(&epf->dev, "epf device not bound to driver\n");
+                return;
+        }
+
+        epf->driver->ops->linkup(epf);
+}
+EXPORT_SYMBOL_GPL(pci_epf_linkup);
+
+/**
+ * pci_epf_unbind() - Notify the function driver that the binding between the
+ *                    EPF device and EPC device has been lost
+ * @epf: the EPF device which has lost the binding with the EPC device
+ *
+ * Invoke to notify the function driver that the binding between the EPF device
+ * and EPC device has been lost.
+ */
+void pci_epf_unbind(struct pci_epf *epf)
+{
+        if (!epf->driver) {
+                dev_WARN(&epf->dev, "epf device not bound to driver\n");
+                return;
+        }
+
+        epf->driver->ops->unbind(epf);
+        module_put(epf->driver->owner);
+}
+EXPORT_SYMBOL_GPL(pci_epf_unbind);
+
+/**
+ * pci_epf_bind() - Notify the function driver that the EPF device has been
+ *                  bound to a EPC device
+ * @epf: the EPF device which has been bound to the EPC device
+ *
+ * Invoke to notify the function driver that it has been bound to a EPC device
+ */
+int pci_epf_bind(struct pci_epf *epf)
+{
+        if (!epf->driver) {
+                dev_WARN(&epf->dev, "epf device not bound to driver\n");
+                return -EINVAL;
+        }
+
+        if (!try_module_get(epf->driver->owner))
+                return -EAGAIN;
+
+        return epf->driver->ops->bind(epf);
+}
+EXPORT_SYMBOL_GPL(pci_epf_bind);
+
+/**
+ * pci_epf_free_space() - free the allocated PCI EPF register space
+ * @addr: the virtual address of the PCI EPF register space
+ * @bar: the BAR number corresponding to the register space
+ *
+ * Invoke to free the allocated PCI EPF register space.
+ */
+void pci_epf_free_space(struct pci_epf *epf, void *addr, enum pci_barno bar)
+{
+        struct device *dev = &epf->dev;
+
+        if (!addr)
+                return;
+
+        dma_free_coherent(dev, epf->bar[bar].size, addr,
+                          epf->bar[bar].phys_addr);
+
+        epf->bar[bar].phys_addr = 0;
+        epf->bar[bar].size = 0;
+}
+EXPORT_SYMBOL_GPL(pci_epf_free_space);
+
+/**
+ * pci_epf_alloc_space() - allocate memory for the PCI EPF register space
+ * @size: the size of the memory that has to be allocated
+ * @bar: the BAR number corresponding to the allocated register space
+ *
+ * Invoke to allocate memory for the PCI EPF register space.
+ */
+void *pci_epf_alloc_space(struct pci_epf *epf, size_t size, enum pci_barno bar)
+{
+        void *space;
+        struct device *dev = &epf->dev;
+        dma_addr_t phys_addr;
+
+        if (size < 128)
+                size = 128;
+        size = roundup_pow_of_two(size);
+
+        space = dma_alloc_coherent(dev, size, &phys_addr, GFP_KERNEL);
+        if (!space) {
+                dev_err(dev, "failed to allocate mem space\n");
+                return NULL;
+        }
+
+        epf->bar[bar].phys_addr = phys_addr;
+        epf->bar[bar].size = size;
+
+        return space;
+}
+EXPORT_SYMBOL_GPL(pci_epf_alloc_space);
+
+/**
+ * pci_epf_unregister_driver() - unregister the PCI EPF driver
+ * @driver: the PCI EPF driver that has to be unregistered
+ *
+ * Invoke to unregister the PCI EPF driver.
+ */
+void pci_epf_unregister_driver(struct pci_epf_driver *driver)
+{
+        pci_ep_cfs_remove_epf_group(driver->group);
+        driver_unregister(&driver->driver);
+}
+EXPORT_SYMBOL_GPL(pci_epf_unregister_driver);
+
+/**
+ * __pci_epf_register_driver() - register a new PCI EPF driver
+ * @driver: structure representing PCI EPF driver
+ * @owner: the owner of the module that registers the PCI EPF driver
+ *
+ * Invoke to register a new PCI EPF driver.
+ */
+int __pci_epf_register_driver(struct pci_epf_driver *driver,
+                              struct module *owner)
+{
+        int ret;
+
+        if (!driver->ops)
+                return -EINVAL;
+
+        if (!driver->ops->bind || !driver->ops->unbind || !driver->ops->linkup)
+                return -EINVAL;
+
+        driver->driver.bus = &pci_epf_bus_type;
+        driver->driver.owner = owner;
+
+        ret = driver_register(&driver->driver);
+        if (ret)
+                return ret;
+
+        driver->group = pci_ep_cfs_add_epf_group(driver->driver.name);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(__pci_epf_register_driver);
+
+/**
+ * pci_epf_destroy() - destroy the created PCI EPF device
+ * @epf: the PCI EPF device that has to be destroyed.
+ *
+ * Invoke to destroy the PCI EPF device created by invoking pci_epf_create().
+ */
+void pci_epf_destroy(struct pci_epf *epf)
+{
+        device_unregister(&epf->dev);
+}
+EXPORT_SYMBOL_GPL(pci_epf_destroy);
+
+/**
+ * pci_epf_create() - create a new PCI EPF device
+ * @name: the name of the PCI EPF device. This name will be used to bind the
+ *        the EPF device to a EPF driver
+ *
+ * Invoke to create a new PCI EPF device by providing the name of the function
+ * device.
+ */
+struct pci_epf *pci_epf_create(const char *name)
+{
+        int ret;
+        struct pci_epf *epf;
+        struct device *dev;
+        char *func_name;
+        char *buf;
+
+        epf = kzalloc(sizeof(*epf), GFP_KERNEL);
+        if (!epf) {
+                ret = -ENOMEM;
+                goto err_ret;
+        }
+
+        buf = kstrdup(name, GFP_KERNEL);
+        if (!buf) {
+                ret = -ENOMEM;
+                goto free_epf;
+        }
+
+        func_name = buf;
+        buf = strchrnul(buf, '.');
+        *buf = '\0';
+
+        epf->name = kstrdup(func_name, GFP_KERNEL);
+        if (!epf->name) {
+                ret = -ENOMEM;
+                goto free_func_name;
+        }
+
+        dev = &epf->dev;
+        device_initialize(dev);
+        dev->bus = &pci_epf_bus_type;
+        dev->type = &pci_epf_type;
+
+        ret = dev_set_name(dev, "%s", name);
+        if (ret)
+                goto put_dev;
+
+        ret = device_add(dev);
+        if (ret)
+                goto put_dev;
+
+        kfree(func_name);
+        return epf;
+
+put_dev:
+        put_device(dev);
+        kfree(epf->name);
+
+free_func_name:
+        kfree(func_name);
+
+free_epf:
+        kfree(epf);
+
+err_ret:
+        return ERR_PTR(ret);
+}
+EXPORT_SYMBOL_GPL(pci_epf_create);
+
+static void pci_epf_dev_release(struct device *dev)
+{
+        struct pci_epf *epf = to_pci_epf(dev);
+
+        kfree(epf->name);
+        kfree(epf);
+}
+
+static struct device_type pci_epf_type = {
+        .release        = pci_epf_dev_release,
+};
+
+static int
+pci_epf_match_id(const struct pci_epf_device_id *id, const struct pci_epf *epf)
+{
+        while (id->name[0]) {
+                if (strcmp(epf->name, id->name) == 0)
+                        return true;
+                id++;
+        }
+
+        return false;
+}
+
+static int pci_epf_device_match(struct device *dev, struct device_driver *drv)
+{
+        struct pci_epf *epf = to_pci_epf(dev);
+        struct pci_epf_driver *driver = to_pci_epf_driver(drv);
+
+        if (driver->id_table)
+                return pci_epf_match_id(driver->id_table, epf);
+
+        return !strcmp(epf->name, drv->name);
+}
+
+static int pci_epf_device_probe(struct device *dev)
+{
+        struct pci_epf *epf = to_pci_epf(dev);
+        struct pci_epf_driver *driver = to_pci_epf_driver(dev->driver);
+
+        if (!driver->probe)
+                return -ENODEV;
+
+        epf->driver = driver;
+
+        return driver->probe(epf);
+}
+
+static int pci_epf_device_remove(struct device *dev)
+{
+        int ret;
+        struct pci_epf *epf = to_pci_epf(dev);
+        struct pci_epf_driver *driver = to_pci_epf_driver(dev->driver);
+
+        ret = driver->remove(epf);
+        epf->driver = NULL;
+
+        return ret;
+}
+
+static struct bus_type pci_epf_bus_type = {
+        .name           = "pci-epf",
+        .match          = pci_epf_device_match,
+        .probe          = pci_epf_device_probe,
+        .remove         = pci_epf_device_remove,
+};
+
+static int __init pci_epf_init(void)
+{
+        int ret;
+
+        ret = bus_register(&pci_epf_bus_type);
+        if (ret) {
+                pr_err("failed to register pci epf bus --> %d\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+module_init(pci_epf_init);
+
+static void __exit pci_epf_exit(void)
+{
+        bus_unregister(&pci_epf_bus_type);
+}
+module_exit(pci_epf_exit);
+
+MODULE_DESCRIPTION("PCI EPF Library");
+MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
+MODULE_LICENSE("GPL v2");