Release 4.16 drivers/pci/endpoint/pci-epf-core.c

// SPDX-License-Identifier: GPL-2.0
/**
 * PCI Endpoint *Function* (EPF) library
 *
 * Copyright (C) 2017 Texas Instruments
 * Author: Kishon Vijay Abraham I <kishon@ti.com>
 */

#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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
41
100.00%
1
100.00%
Total
41
100.00%
1
100.00%

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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
50
100.00%
1
100.00%
Total
50
100.00%
1
100.00%

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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
61
100.00%
1
100.00%
Total
61
100.00%
1
100.00%

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->epc->dev.parent;

	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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
84
100.00%
2
100.00%
Total
84
100.00%
2
100.00%

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->epc->dev.parent;
	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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
111
100.00%
2
100.00%
Total
111
100.00%
2
100.00%

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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
25
100.00%
2
100.00%
Total
25
100.00%
2
100.00%

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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
106
100.00%
2
100.00%
Total
106
100.00%
2
100.00%

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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
18
100.00%
1
100.00%
Total
18
100.00%
1
100.00%

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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
233
100.00%
1
100.00%
Total
233
100.00%
1
100.00%

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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
63
100.00%
1
100.00%
Total
63
100.00%
1
100.00%

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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
33
100.00%
1
100.00%
Total
33
100.00%
1
100.00%


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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
53
100.00%
1
100.00%
Total
53
100.00%
1
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
65
100.00%
1
100.00%
Total
65
100.00%
1
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
58
100.00%
1
100.00%
Total
58
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
62
100.00%
2
100.00%
Total
62
100.00%
2
100.00%


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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
39
100.00%
1
100.00%
Total
39
100.00%
1
100.00%

module_init(pci_epf_init);



static void __exit pci_epf_exit(void)
{
	bus_unregister(&pci_epf_bus_type);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%

module_exit(pci_epf_exit);

MODULE_DESCRIPTION("PCI EPF Library");
MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
MODULE_LICENSE("GPL v2");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Kishon Vijay Abraham I
1271
99.69%
5
71.43%
Björn Helgaas
2
0.16%
1
14.29%
Bhumika Goyal
2
0.16%
1
14.29%
Total
1275
100.00%
7
100.00%
Directory: drivers/pci/endpoint

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.