PCI: endpoint: Add EP core layer to enable EP controller and EP functions

Introduce a new EP core layer in order to support endpoint functions in
linux kernel. This comprises the EPC library (Endpoint Controller Library)
and EPF library (Endpoint Function Library). EPC library implements
functions specific to an endpoint controller and EPF library implements
functions specific to an endpoint function.

Signed-off-by: Kishon Vijay Abraham I <kishon@ti.com>
Acked-by: Joao Pinto <jpinto@synopsys.com>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>

7 files changed, 1103 insertions, 0 deletions

diff --git a/drivers/Makefile b/drivers/Makefile
index 2eced9afba53..a5f8e43b2c4d 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -14,7 +14,9 @@ obj-$(CONFIG_GENERIC_PHY)	+= phy/
 obj-$(CONFIG_PINCTRL)           += pinctrl/
 obj-$(CONFIG_GPIOLIB)           += gpio/
 obj-y                           += pwm/
+
 obj-$(CONFIG_PCI)               += pci/
+obj-$(CONFIG_PCI_ENDPOINT)      += pci/endpoint/
 # PCI dwc controller drivers
 obj-y                           += pci/dwc/
 
diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index df141420c902..9747c1ec8c74 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -134,3 +134,4 @@ config PCI_HYPERV
 source "drivers/pci/hotplug/Kconfig"
 source "drivers/pci/dwc/Kconfig"
 source "drivers/pci/host/Kconfig"
+source "drivers/pci/endpoint/Kconfig"
diff --git a/drivers/pci/endpoint/Kconfig b/drivers/pci/endpoint/Kconfig
new file mode 100644
index 000000000000..a5442ace7077
--- /dev/null
+++ b/drivers/pci/endpoint/Kconfig
@@ -0,0 +1,20 @@
+#
+# PCI Endpoint Support
+#
+
+menu "PCI Endpoint"
+
+config PCI_ENDPOINT
+        bool "PCI Endpoint Support"
+        help
+           Enable this configuration option to support configurable PCI
+           endpoint. This should be enabled if the platform has a PCI
+           controller that can operate in endpoint mode.
+
+           Enabling this option will build the endpoint library, which
+           includes endpoint controller library and endpoint function
+           library.
+
+           If in doubt, say "N" to disable Endpoint support.
+
+endmenu
diff --git a/drivers/pci/endpoint/Makefile b/drivers/pci/endpoint/Makefile
new file mode 100644
index 000000000000..dc1bc16491e6
--- /dev/null
+++ b/drivers/pci/endpoint/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for PCI Endpoint Support
+#
+
+obj-$(CONFIG_PCI_ENDPOINT)              += pci-epc-core.o pci-epf-core.o\
+                                           pci-epc-mem.o
diff --git a/drivers/pci/endpoint/pci-epc-core.c b/drivers/pci/endpoint/pci-epc-core.c
new file mode 100644
index 000000000000..7c71dd94721c
--- /dev/null
+++ b/drivers/pci/endpoint/pci-epc-core.c
@@ -0,0 +1,576 @@
+/**
+ * PCI Endpoint *Controller* (EPC) 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>
+
+static struct class *pci_epc_class;
+
+static void devm_pci_epc_release(struct device *dev, void *res)
+{
+        struct pci_epc *epc = *(struct pci_epc **)res;
+
+        pci_epc_destroy(epc);
+}
+
+static int devm_pci_epc_match(struct device *dev, void *res, void *match_data)
+{
+        struct pci_epc **epc = res;
+
+        return *epc == match_data;
+}
+
+/**
+ * pci_epc_put() - release the PCI endpoint controller
+ * @epc: epc returned by pci_epc_get()
+ *
+ * release the refcount the caller obtained by invoking pci_epc_get()
+ */
+void pci_epc_put(struct pci_epc *epc)
+{
+        if (!epc || IS_ERR(epc))
+                return;
+
+        module_put(epc->ops->owner);
+        put_device(&epc->dev);
+}
+EXPORT_SYMBOL_GPL(pci_epc_put);
+
+/**
+ * pci_epc_get() - get the PCI endpoint controller
+ * @epc_name: device name of the endpoint controller
+ *
+ * Invoke to get struct pci_epc * corresponding to the device name of the
+ * endpoint controller
+ */
+struct pci_epc *pci_epc_get(const char *epc_name)
+{
+        int ret = -EINVAL;
+        struct pci_epc *epc;
+        struct device *dev;
+        struct class_dev_iter iter;
+
+        class_dev_iter_init(&iter, pci_epc_class, NULL, NULL);
+        while ((dev = class_dev_iter_next(&iter))) {
+                if (strcmp(epc_name, dev_name(dev)))
+                        continue;
+
+                epc = to_pci_epc(dev);
+                if (!try_module_get(epc->ops->owner)) {
+                        ret = -EINVAL;
+                        goto err;
+                }
+
+                class_dev_iter_exit(&iter);
+                get_device(&epc->dev);
+                return epc;
+        }
+
+err:
+        class_dev_iter_exit(&iter);
+        return ERR_PTR(ret);
+}
+EXPORT_SYMBOL_GPL(pci_epc_get);
+
+/**
+ * pci_epc_stop() - stop the PCI link
+ * @epc: the link of the EPC device that has to be stopped
+ *
+ * Invoke to stop the PCI link
+ */
+void pci_epc_stop(struct pci_epc *epc)
+{
+        unsigned long flags;
+
+        if (IS_ERR(epc) || !epc->ops->stop)
+                return;
+
+        spin_lock_irqsave(&epc->lock, flags);
+        epc->ops->stop(epc);
+        spin_unlock_irqrestore(&epc->lock, flags);
+}
+EXPORT_SYMBOL_GPL(pci_epc_stop);
+
+/**
+ * pci_epc_start() - start the PCI link
+ * @epc: the link of *this* EPC device has to be started
+ *
+ * Invoke to start the PCI link
+ */
+int pci_epc_start(struct pci_epc *epc)
+{
+        int ret;
+        unsigned long flags;
+
+        if (IS_ERR(epc))
+                return -EINVAL;
+
+        if (!epc->ops->start)
+                return 0;
+
+        spin_lock_irqsave(&epc->lock, flags);
+        ret = epc->ops->start(epc);
+        spin_unlock_irqrestore(&epc->lock, flags);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pci_epc_start);
+
+/**
+ * pci_epc_raise_irq() - interrupt the host system
+ * @epc: the EPC device which has to interrupt the host
+ * @type: specify the type of interrupt; legacy or MSI
+ * @interrupt_num: the MSI interrupt number
+ *
+ * Invoke to raise an MSI or legacy interrupt
+ */
+int pci_epc_raise_irq(struct pci_epc *epc, enum pci_epc_irq_type type,
+                      u8 interrupt_num)
+{
+        int ret;
+        unsigned long flags;
+
+        if (IS_ERR(epc))
+                return -EINVAL;
+
+        if (!epc->ops->raise_irq)
+                return 0;
+
+        spin_lock_irqsave(&epc->lock, flags);
+        ret = epc->ops->raise_irq(epc, type, interrupt_num);
+        spin_unlock_irqrestore(&epc->lock, flags);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pci_epc_raise_irq);
+
+/**
+ * pci_epc_get_msi() - get the number of MSI interrupt numbers allocated
+ * @epc: the EPC device to which MSI interrupts was requested
+ *
+ * Invoke to get the number of MSI interrupts allocated by the RC
+ */
+int pci_epc_get_msi(struct pci_epc *epc)
+{
+        int interrupt;
+        unsigned long flags;
+
+        if (IS_ERR(epc))
+                return 0;
+
+        if (!epc->ops->get_msi)
+                return 0;
+
+        spin_lock_irqsave(&epc->lock, flags);
+        interrupt = epc->ops->get_msi(epc);
+        spin_unlock_irqrestore(&epc->lock, flags);
+
+        if (interrupt < 0)
+                return 0;
+
+        interrupt = 1 << interrupt;
+
+        return interrupt;
+}
+EXPORT_SYMBOL_GPL(pci_epc_get_msi);
+
+/**
+ * pci_epc_set_msi() - set the number of MSI interrupt numbers required
+ * @epc: the EPC device on which MSI has to be configured
+ * @interrupts: number of MSI interrupts required by the EPF
+ *
+ * Invoke to set the required number of MSI interrupts.
+ */
+int pci_epc_set_msi(struct pci_epc *epc, u8 interrupts)
+{
+        int ret;
+        u8 encode_int;
+        unsigned long flags;
+
+        if (IS_ERR(epc))
+                return -EINVAL;
+
+        if (!epc->ops->set_msi)
+                return 0;
+
+        encode_int = order_base_2(interrupts);
+
+        spin_lock_irqsave(&epc->lock, flags);
+        ret = epc->ops->set_msi(epc, encode_int);
+        spin_unlock_irqrestore(&epc->lock, flags);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pci_epc_set_msi);
+
+/**
+ * pci_epc_unmap_addr() - unmap CPU address from PCI address
+ * @epc: the EPC device on which address is allocated
+ * @phys_addr: physical address of the local system
+ *
+ * Invoke to unmap the CPU address from PCI address.
+ */
+void pci_epc_unmap_addr(struct pci_epc *epc, phys_addr_t phys_addr)
+{
+        unsigned long flags;
+
+        if (IS_ERR(epc))
+                return;
+
+        if (!epc->ops->unmap_addr)
+                return;
+
+        spin_lock_irqsave(&epc->lock, flags);
+        epc->ops->unmap_addr(epc, phys_addr);
+        spin_unlock_irqrestore(&epc->lock, flags);
+}
+EXPORT_SYMBOL_GPL(pci_epc_unmap_addr);
+
+/**
+ * pci_epc_map_addr() - map CPU address to PCI address
+ * @epc: the EPC device on which address is allocated
+ * @phys_addr: physical address of the local system
+ * @pci_addr: PCI address to which the physical address should be mapped
+ * @size: the size of the allocation
+ *
+ * Invoke to map CPU address with PCI address.
+ */
+int pci_epc_map_addr(struct pci_epc *epc, phys_addr_t phys_addr,
+                     u64 pci_addr, size_t size)
+{
+        int ret;
+        unsigned long flags;
+
+        if (IS_ERR(epc))
+                return -EINVAL;
+
+        if (!epc->ops->map_addr)
+                return 0;
+
+        spin_lock_irqsave(&epc->lock, flags);
+        ret = epc->ops->map_addr(epc, phys_addr, pci_addr, size);
+        spin_unlock_irqrestore(&epc->lock, flags);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pci_epc_map_addr);
+
+/**
+ * pci_epc_clear_bar() - reset the BAR
+ * @epc: the EPC device for which the BAR has to be cleared
+ * @bar: the BAR number that has to be reset
+ *
+ * Invoke to reset the BAR of the endpoint device.
+ */
+void pci_epc_clear_bar(struct pci_epc *epc, int bar)
+{
+        unsigned long flags;
+
+        if (IS_ERR(epc))
+                return;
+
+        if (!epc->ops->clear_bar)
+                return;
+
+        spin_lock_irqsave(&epc->lock, flags);
+        epc->ops->clear_bar(epc, bar);
+        spin_unlock_irqrestore(&epc->lock, flags);
+}
+EXPORT_SYMBOL_GPL(pci_epc_clear_bar);
+
+/**
+ * pci_epc_set_bar() - configure BAR in order for host to assign PCI addr space
+ * @epc: the EPC device on which BAR has to be configured
+ * @bar: the BAR number that has to be configured
+ * @size: the size of the addr space
+ * @flags: specify memory allocation/io allocation/32bit address/64 bit address
+ *
+ * Invoke to configure the BAR of the endpoint device.
+ */
+int pci_epc_set_bar(struct pci_epc *epc, enum pci_barno bar,
+                    dma_addr_t bar_phys, size_t size, int flags)
+{
+        int ret;
+        unsigned long irq_flags;
+
+        if (IS_ERR(epc))
+                return -EINVAL;
+
+        if (!epc->ops->set_bar)
+                return 0;
+
+        spin_lock_irqsave(&epc->lock, irq_flags);
+        ret = epc->ops->set_bar(epc, bar, bar_phys, size, flags);
+        spin_unlock_irqrestore(&epc->lock, irq_flags);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pci_epc_set_bar);
+
+/**
+ * pci_epc_write_header() - write standard configuration header
+ * @epc: the EPC device to which the configuration header should be written
+ * @header: standard configuration header fields
+ *
+ * Invoke to write the configuration header to the endpoint controller. Every
+ * endpoint controller will have a dedicated location to which the standard
+ * configuration header would be written. The callback function should write
+ * the header fields to this dedicated location.
+ */
+int pci_epc_write_header(struct pci_epc *epc, struct pci_epf_header *header)
+{
+        int ret;
+        unsigned long flags;
+
+        if (IS_ERR(epc))
+                return -EINVAL;
+
+        if (!epc->ops->write_header)
+                return 0;
+
+        spin_lock_irqsave(&epc->lock, flags);
+        ret = epc->ops->write_header(epc, header);
+        spin_unlock_irqrestore(&epc->lock, flags);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pci_epc_write_header);
+
+/**
+ * pci_epc_add_epf() - bind PCI endpoint function to an endpoint controller
+ * @epc: the EPC device to which the endpoint function should be added
+ * @epf: the endpoint function to be added
+ *
+ * A PCI endpoint device can have one or more functions. In the case of PCIe,
+ * the specification allows up to 8 PCIe endpoint functions. Invoke
+ * pci_epc_add_epf() to add a PCI endpoint function to an endpoint controller.
+ */
+int pci_epc_add_epf(struct pci_epc *epc, struct pci_epf *epf)
+{
+        unsigned long flags;
+
+        if (epf->epc)
+                return -EBUSY;
+
+        if (IS_ERR(epc))
+                return -EINVAL;
+
+        if (epf->func_no > epc->max_functions - 1)
+                return -EINVAL;
+
+        epf->epc = epc;
+        dma_set_coherent_mask(&epf->dev, epc->dev.coherent_dma_mask);
+        epf->dev.dma_mask = epc->dev.dma_mask;
+
+        spin_lock_irqsave(&epc->lock, flags);
+        list_add_tail(&epf->list, &epc->pci_epf);
+        spin_unlock_irqrestore(&epc->lock, flags);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(pci_epc_add_epf);
+
+/**
+ * pci_epc_remove_epf() - remove PCI endpoint function from endpoint controller
+ * @epc: the EPC device from which the endpoint function should be removed
+ * @epf: the endpoint function to be removed
+ *
+ * Invoke to remove PCI endpoint function from the endpoint controller.
+ */
+void pci_epc_remove_epf(struct pci_epc *epc, struct pci_epf *epf)
+{
+        unsigned long flags;
+
+        if (!epc || IS_ERR(epc))
+                return;
+
+        spin_lock_irqsave(&epc->lock, flags);
+        list_del(&epf->list);
+        spin_unlock_irqrestore(&epc->lock, flags);
+}
+EXPORT_SYMBOL_GPL(pci_epc_remove_epf);
+
+/**
+ * pci_epc_linkup() - Notify the EPF device that EPC device has established a
+ *                    connection with the Root Complex.
+ * @epc: the EPC device which has established link with the host
+ *
+ * Invoke to Notify the EPF device that the EPC device has established a
+ * connection with the Root Complex.
+ */
+void pci_epc_linkup(struct pci_epc *epc)
+{
+        unsigned long flags;
+        struct pci_epf *epf;
+
+        if (!epc || IS_ERR(epc))
+                return;
+
+        spin_lock_irqsave(&epc->lock, flags);
+        list_for_each_entry(epf, &epc->pci_epf, list)
+                pci_epf_linkup(epf);
+        spin_unlock_irqrestore(&epc->lock, flags);
+}
+EXPORT_SYMBOL_GPL(pci_epc_linkup);
+
+/**
+ * pci_epc_destroy() - destroy the EPC device
+ * @epc: the EPC device that has to be destroyed
+ *
+ * Invoke to destroy the PCI EPC device
+ */
+void pci_epc_destroy(struct pci_epc *epc)
+{
+        device_unregister(&epc->dev);
+        kfree(epc);
+}
+EXPORT_SYMBOL_GPL(pci_epc_destroy);
+
+/**
+ * devm_pci_epc_destroy() - destroy the EPC device
+ * @dev: device that wants to destroy the EPC
+ * @epc: the EPC device that has to be destroyed
+ *
+ * Invoke to destroy the devres associated with this
+ * pci_epc and destroy the EPC device.
+ */
+void devm_pci_epc_destroy(struct device *dev, struct pci_epc *epc)
+{
+        int r;
+
+        r = devres_destroy(dev, devm_pci_epc_release, devm_pci_epc_match,
+                           epc);
+        dev_WARN_ONCE(dev, r, "couldn't find PCI EPC resource\n");
+}
+EXPORT_SYMBOL_GPL(devm_pci_epc_destroy);
+
+/**
+ * __pci_epc_create() - create a new endpoint controller (EPC) device
+ * @dev: device that is creating the new EPC
+ * @ops: function pointers for performing EPC operations
+ * @owner: the owner of the module that creates the EPC device
+ *
+ * Invoke to create a new EPC device and add it to pci_epc class.
+ */
+struct pci_epc *
+__pci_epc_create(struct device *dev, const struct pci_epc_ops *ops,
+                 struct module *owner)
+{
+        int ret;
+        struct pci_epc *epc;
+
+        if (WARN_ON(!dev)) {
+                ret = -EINVAL;
+                goto err_ret;
+        }
+
+        epc = kzalloc(sizeof(*epc), GFP_KERNEL);
+        if (!epc) {
+                ret = -ENOMEM;
+                goto err_ret;
+        }
+
+        spin_lock_init(&epc->lock);
+        INIT_LIST_HEAD(&epc->pci_epf);
+
+        device_initialize(&epc->dev);
+        dma_set_coherent_mask(&epc->dev, dev->coherent_dma_mask);
+        epc->dev.class = pci_epc_class;
+        epc->dev.dma_mask = dev->dma_mask;
+        epc->ops = ops;
+
+        ret = dev_set_name(&epc->dev, "%s", dev_name(dev));
+        if (ret)
+                goto put_dev;
+
+        ret = device_add(&epc->dev);
+        if (ret)
+                goto put_dev;
+
+        return epc;
+
+put_dev:
+        put_device(&epc->dev);
+        kfree(epc);
+
+err_ret:
+        return ERR_PTR(ret);
+}
+EXPORT_SYMBOL_GPL(__pci_epc_create);
+
+/**
+ * __devm_pci_epc_create() - create a new endpoint controller (EPC) device
+ * @dev: device that is creating the new EPC
+ * @ops: function pointers for performing EPC operations
+ * @owner: the owner of the module that creates the EPC device
+ *
+ * Invoke to create a new EPC device and add it to pci_epc class.
+ * While at that, it also associates the device with the pci_epc using devres.
+ * On driver detach, release function is invoked on the devres data,
+ * then, devres data is freed.
+ */
+struct pci_epc *
+__devm_pci_epc_create(struct device *dev, const struct pci_epc_ops *ops,
+                      struct module *owner)
+{
+        struct pci_epc **ptr, *epc;
+
+        ptr = devres_alloc(devm_pci_epc_release, sizeof(*ptr), GFP_KERNEL);
+        if (!ptr)
+                return ERR_PTR(-ENOMEM);
+
+        epc = __pci_epc_create(dev, ops, owner);
+        if (!IS_ERR(epc)) {
+                *ptr = epc;
+                devres_add(dev, ptr);
+        } else {
+                devres_free(ptr);
+        }
+
+        return epc;
+}
+EXPORT_SYMBOL_GPL(__devm_pci_epc_create);
+
+static int __init pci_epc_init(void)
+{
+        pci_epc_class = class_create(THIS_MODULE, "pci_epc");
+        if (IS_ERR(pci_epc_class)) {
+                pr_err("failed to create pci epc class --> %ld\n",
+                       PTR_ERR(pci_epc_class));
+                return PTR_ERR(pci_epc_class);
+        }
+
+        return 0;
+}
+module_init(pci_epc_init);
+
+static void __exit pci_epc_exit(void)
+{
+        class_destroy(pci_epc_class);
+}
+module_exit(pci_epc_exit);
+
+MODULE_DESCRIPTION("PCI EPC Library");
+MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/pci/endpoint/pci-epc-mem.c b/drivers/pci/endpoint/pci-epc-mem.c
new file mode 100644
index 000000000000..3a94cc1caf22
--- /dev/null
+++ b/drivers/pci/endpoint/pci-epc-mem.c
@@ -0,0 +1,143 @@
+/**
+ * PCI Endpoint *Controller* Address Space Management
+ *
+ * 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/io.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include <linux/pci-epc.h>
+
+/**
+ * pci_epc_mem_init() - initialize the pci_epc_mem structure
+ * @epc: the EPC device that invoked pci_epc_mem_init
+ * @phys_base: the physical address of the base
+ * @size: the size of the address space
+ *
+ * Invoke to initialize the pci_epc_mem structure used by the
+ * endpoint functions to allocate mapped PCI address.
+ */
+int pci_epc_mem_init(struct pci_epc *epc, phys_addr_t phys_base, size_t size)
+{
+        int ret;
+        struct pci_epc_mem *mem;
+        unsigned long *bitmap;
+        int pages = size >> PAGE_SHIFT;
+        int bitmap_size = BITS_TO_LONGS(pages) * sizeof(long);
+
+        mem = kzalloc(sizeof(*mem), GFP_KERNEL);
+        if (!mem) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        bitmap = kzalloc(bitmap_size, GFP_KERNEL);
+        if (!bitmap) {
+                ret = -ENOMEM;
+                goto err_mem;
+        }
+
+        mem->bitmap = bitmap;
+        mem->phys_base = phys_base;
+        mem->pages = pages;
+        mem->size = size;
+
+        epc->mem = mem;
+
+        return 0;
+
+err_mem:
+        kfree(mem);
+
+err:
+return ret;
+}
+EXPORT_SYMBOL_GPL(pci_epc_mem_init);
+
+/**
+ * pci_epc_mem_exit() - cleanup the pci_epc_mem structure
+ * @epc: the EPC device that invoked pci_epc_mem_exit
+ *
+ * Invoke to cleanup the pci_epc_mem structure allocated in
+ * pci_epc_mem_init().
+ */
+void pci_epc_mem_exit(struct pci_epc *epc)
+{
+        struct pci_epc_mem *mem = epc->mem;
+
+        epc->mem = NULL;
+        kfree(mem->bitmap);
+        kfree(mem);
+}
+EXPORT_SYMBOL_GPL(pci_epc_mem_exit);
+
+/**
+ * pci_epc_mem_alloc_addr() - allocate memory address from EPC addr space
+ * @epc: the EPC device on which memory has to be allocated
+ * @phys_addr: populate the allocated physical address here
+ * @size: the size of the address space that has to be allocated
+ *
+ * Invoke to allocate memory address from the EPC address space. This
+ * is usually done to map the remote RC address into the local system.
+ */
+void __iomem *pci_epc_mem_alloc_addr(struct pci_epc *epc,
+                                     phys_addr_t *phys_addr, size_t size)
+{
+        int pageno;
+        void __iomem *virt_addr;
+        struct pci_epc_mem *mem = epc->mem;
+        int order = get_order(size);
+
+        pageno = bitmap_find_free_region(mem->bitmap, mem->pages, order);
+        if (pageno < 0)
+                return NULL;
+
+        *phys_addr = mem->phys_base + (pageno << PAGE_SHIFT);
+        virt_addr = ioremap(*phys_addr, size);
+        if (!virt_addr)
+                bitmap_release_region(mem->bitmap, pageno, order);
+
+        return virt_addr;
+}
+EXPORT_SYMBOL_GPL(pci_epc_mem_alloc_addr);
+
+/**
+ * pci_epc_mem_free_addr() - free the allocated memory address
+ * @epc: the EPC device on which memory was allocated
+ * @phys_addr: the allocated physical address
+ * @virt_addr: virtual address of the allocated mem space
+ * @size: the size of the allocated address space
+ *
+ * Invoke to free the memory allocated using pci_epc_mem_alloc_addr.
+ */
+void pci_epc_mem_free_addr(struct pci_epc *epc, phys_addr_t phys_addr,
+                           void __iomem *virt_addr, size_t size)
+{
+        int pageno;
+        int order = get_order(size);
+        struct pci_epc_mem *mem = epc->mem;
+
+        iounmap(virt_addr);
+        pageno = (phys_addr - mem->phys_base) >> PAGE_SHIFT;
+        bitmap_release_region(mem->bitmap, pageno, order);
+}
+EXPORT_SYMBOL_GPL(pci_epc_mem_free_addr);
+
+MODULE_DESCRIPTION("PCI EPC Address Space Management");
+MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/pci/endpoint/pci-epf-core.c b/drivers/pci/endpoint/pci-epf-core.c
new file mode 100644
index 000000000000..a281c599a504
--- /dev/null
+++ b/drivers/pci/endpoint/pci-epf-core.c
@@ -0,0 +1,355 @@
+/**
+ * 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>
+
+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)
+{
+        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;
+
+        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");