drivers/pci/endpoint/pci-epf-core.c - arm/linux - Git at Google

 /**
  * 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 const 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);

 const struct pci_epf_device_id *
 pci_epf_match_device(const struct pci_epf_device_id *id, struct pci_epf *epf)
 {
 	if (!id || !epf)
 		return NULL;

 	while (*id->name) {
 		if (strcmp(epf->name, id->name) == 0)
 			return id;
 		id++;
 	}

 	return NULL;
 }
 EXPORT_SYMBOL_GPL(pci_epf_match_device);

 static void pci_epf_dev_release(struct device *dev)
 {
 	struct pci_epf *epf = to_pci_epf(dev);

 	kfree(epf->name);
 	kfree(epf);
 }

 static const 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 = 0;
 	struct pci_epf *epf = to_pci_epf(dev);
 	struct pci_epf_driver *driver = to_pci_epf_driver(dev->driver);

 	if (driver->remove)
 		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");
	/**
	* 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 const 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);

	const struct pci_epf_device_id *
	pci_epf_match_device(const struct pci_epf_device_id id, struct pci_epf epf)
	{
	if (!id \|\| !epf)
	return NULL;

	while (*id->name) {
	if (strcmp(epf->name, id->name) == 0)
	return id;
	id++;
	}

	return NULL;
	}
	EXPORT_SYMBOL_GPL(pci_epf_match_device);

	static void pci_epf_dev_release(struct device *dev)
	{
	struct pci_epf *epf = to_pci_epf(dev);

	kfree(epf->name);
	kfree(epf);
	}

	static const 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 = 0;
	struct pci_epf *epf = to_pci_epf(dev);
	struct pci_epf_driver *driver = to_pci_epf_driver(dev->driver);

	if (driver->remove)
	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");