[deliverable/linux.git] / drivers / pci / iov.c

/*
 * drivers/pci/iov.c
 *
 * Copyright (C) 2009 Intel Corporation, Yu Zhao <yu.zhao@intel.com>
 *
 * PCI Express I/O Virtualization (IOV) support.
 *   Single Root IOV 1.0
 *   Address Translation Service 1.0
 */

#include <linux/pci.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <linux/export.h>
#include <linux/string.h>
#include <linux/delay.h>
#include <linux/pci-ats.h>
#include "pci.h"

#define VIRTFN_ID_LEN	16

static inline u8 virtfn_bus(struct pci_dev *dev, int id)
{
	return dev->bus->number + ((dev->devfn + dev->sriov->offset +
				    dev->sriov->stride * id) >> 8);
}

static inline u8 virtfn_devfn(struct pci_dev *dev, int id)
{
	return (dev->devfn + dev->sriov->offset +
		dev->sriov->stride * id) & 0xff;
}

static struct pci_bus *virtfn_add_bus(struct pci_bus *bus, int busnr)
{
	int rc;
	struct pci_bus *child;

	if (bus->number == busnr)
		return bus;

	child = pci_find_bus(pci_domain_nr(bus), busnr);
	if (child)
		return child;

	child = pci_add_new_bus(bus, NULL, busnr);
	if (!child)
		return NULL;

	pci_bus_insert_busn_res(child, busnr, busnr);
	child->dev.parent = bus->bridge;
	rc = pci_bus_add_child(child);
	if (rc) {
		pci_remove_bus(child);
		return NULL;
	}

	return child;
}

static void virtfn_remove_bus(struct pci_bus *bus, int busnr)
{
	struct pci_bus *child;

	if (bus->number == busnr)
		return;

	child = pci_find_bus(pci_domain_nr(bus), busnr);
	BUG_ON(!child);

	if (list_empty(&child->devices))
		pci_remove_bus(child);
}

static int virtfn_add(struct pci_dev *dev, int id, int reset)
{
	int i;
	int rc;
	u64 size;
	char buf[VIRTFN_ID_LEN];
	struct pci_dev *virtfn;
	struct resource *res;
	struct pci_sriov *iov = dev->sriov;

	virtfn = alloc_pci_dev();
	if (!virtfn)
		return -ENOMEM;

	mutex_lock(&iov->dev->sriov->lock);
	virtfn->bus = virtfn_add_bus(dev->bus, virtfn_bus(dev, id));
	if (!virtfn->bus) {
		kfree(virtfn);
		mutex_unlock(&iov->dev->sriov->lock);
		return -ENOMEM;
	}
	virtfn->devfn = virtfn_devfn(dev, id);
	virtfn->vendor = dev->vendor;
	pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_DID, &virtfn->device);
	pci_setup_device(virtfn);
	virtfn->dev.parent = dev->dev.parent;

	for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
		res = dev->resource + PCI_IOV_RESOURCES + i;
		if (!res->parent)
			continue;
		virtfn->resource[i].name = pci_name(virtfn);
		virtfn->resource[i].flags = res->flags;
		size = resource_size(res);
		do_div(size, iov->total);
		virtfn->resource[i].start = res->start + size * id;
		virtfn->resource[i].end = virtfn->resource[i].start + size - 1;
		rc = request_resource(res, &virtfn->resource[i]);
		BUG_ON(rc);
	}

	if (reset)
		__pci_reset_function(virtfn);

	pci_device_add(virtfn, virtfn->bus);
	mutex_unlock(&iov->dev->sriov->lock);

	virtfn->physfn = pci_dev_get(dev);
	virtfn->is_virtfn = 1;

	rc = pci_bus_add_device(virtfn);
	if (rc)
		goto failed1;
	sprintf(buf, "virtfn%u", id);
	rc = sysfs_create_link(&dev->dev.kobj, &virtfn->dev.kobj, buf);
	if (rc)
		goto failed1;
	rc = sysfs_create_link(&virtfn->dev.kobj, &dev->dev.kobj, "physfn");
	if (rc)
		goto failed2;

	kobject_uevent(&virtfn->dev.kobj, KOBJ_CHANGE);

	return 0;

failed2:
	sysfs_remove_link(&dev->dev.kobj, buf);
failed1:
	pci_dev_put(dev);
	mutex_lock(&iov->dev->sriov->lock);
	pci_stop_and_remove_bus_device(virtfn);
	virtfn_remove_bus(dev->bus, virtfn_bus(dev, id));
	mutex_unlock(&iov->dev->sriov->lock);

	return rc;
}

static void virtfn_remove(struct pci_dev *dev, int id, int reset)
{
	char buf[VIRTFN_ID_LEN];
	struct pci_dev *virtfn;
	struct pci_sriov *iov = dev->sriov;

	virtfn = pci_get_domain_bus_and_slot(pci_domain_nr(dev->bus),
			virtfn_bus(dev, id), virtfn_devfn(dev, id));
	if (!virtfn)
		return;

	pci_dev_put(virtfn);

	if (reset) {
		device_release_driver(&virtfn->dev);
		__pci_reset_function(virtfn);
	}

	sprintf(buf, "virtfn%u", id);
	sysfs_remove_link(&dev->dev.kobj, buf);
	/*
	 * pci_stop_dev() could have been called for this virtfn already,
	 * so the directory for the virtfn may have been removed before.
	 * Double check to avoid spurious sysfs warnings.
	 */
	if (virtfn->dev.kobj.sd)
		sysfs_remove_link(&virtfn->dev.kobj, "physfn");

	mutex_lock(&iov->dev->sriov->lock);
	pci_stop_and_remove_bus_device(virtfn);
	virtfn_remove_bus(dev->bus, virtfn_bus(dev, id));
	mutex_unlock(&iov->dev->sriov->lock);

	pci_dev_put(dev);
}

static int sriov_migration(struct pci_dev *dev)
{
	u16 status;
	struct pci_sriov *iov = dev->sriov;

	if (!iov->nr_virtfn)
		return 0;

	if (!(iov->cap & PCI_SRIOV_CAP_VFM))
		return 0;

	pci_read_config_word(dev, iov->pos + PCI_SRIOV_STATUS, &status);
	if (!(status & PCI_SRIOV_STATUS_VFM))
		return 0;

	schedule_work(&iov->mtask);

	return 1;
}

static void sriov_migration_task(struct work_struct *work)
{
	int i;
	u8 state;
	u16 status;
	struct pci_sriov *iov = container_of(work, struct pci_sriov, mtask);

	for (i = iov->initial; i < iov->nr_virtfn; i++) {
		state = readb(iov->mstate + i);
		if (state == PCI_SRIOV_VFM_MI) {
			writeb(PCI_SRIOV_VFM_AV, iov->mstate + i);
			state = readb(iov->mstate + i);
			if (state == PCI_SRIOV_VFM_AV)
				virtfn_add(iov->self, i, 1);
		} else if (state == PCI_SRIOV_VFM_MO) {
			virtfn_remove(iov->self, i, 1);
			writeb(PCI_SRIOV_VFM_UA, iov->mstate + i);
			state = readb(iov->mstate + i);
			if (state == PCI_SRIOV_VFM_AV)
				virtfn_add(iov->self, i, 0);
		}
	}

	pci_read_config_word(iov->self, iov->pos + PCI_SRIOV_STATUS, &status);
	status &= ~PCI_SRIOV_STATUS_VFM;
	pci_write_config_word(iov->self, iov->pos + PCI_SRIOV_STATUS, status);
}

static int sriov_enable_migration(struct pci_dev *dev, int nr_virtfn)
{
	int bir;
	u32 table;
	resource_size_t pa;
	struct pci_sriov *iov = dev->sriov;

	if (nr_virtfn <= iov->initial)
		return 0;

	pci_read_config_dword(dev, iov->pos + PCI_SRIOV_VFM, &table);
	bir = PCI_SRIOV_VFM_BIR(table);
	if (bir > PCI_STD_RESOURCE_END)
		return -EIO;

	table = PCI_SRIOV_VFM_OFFSET(table);
	if (table + nr_virtfn > pci_resource_len(dev, bir))
		return -EIO;

	pa = pci_resource_start(dev, bir) + table;
	iov->mstate = ioremap(pa, nr_virtfn);
	if (!iov->mstate)
		return -ENOMEM;

	INIT_WORK(&iov->mtask, sriov_migration_task);

	iov->ctrl |= PCI_SRIOV_CTRL_VFM | PCI_SRIOV_CTRL_INTR;
	pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);

	return 0;
}

static void sriov_disable_migration(struct pci_dev *dev)
{
	struct pci_sriov *iov = dev->sriov;

	iov->ctrl &= ~(PCI_SRIOV_CTRL_VFM | PCI_SRIOV_CTRL_INTR);
	pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);

	cancel_work_sync(&iov->mtask);
	iounmap(iov->mstate);
}

static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
{
	int rc;
	int i, j;
	int nres;
	u16 offset, stride, initial;
	struct resource *res;
	struct pci_dev *pdev;
	struct pci_sriov *iov = dev->sriov;
	int bars = 0;

	if (!nr_virtfn)
		return 0;

	if (iov->nr_virtfn)
		return -EINVAL;

	pci_read_config_word(dev, iov->pos + PCI_SRIOV_INITIAL_VF, &initial);
	if (initial > iov->total ||
	    (!(iov->cap & PCI_SRIOV_CAP_VFM) && (initial != iov->total)))
		return -EIO;

	if (nr_virtfn < 0 || nr_virtfn > iov->total ||
	    (!(iov->cap & PCI_SRIOV_CAP_VFM) && (nr_virtfn > initial)))
		return -EINVAL;

	pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, nr_virtfn);
	pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_OFFSET, &offset);
	pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_STRIDE, &stride);
	if (!offset || (nr_virtfn > 1 && !stride))
		return -EIO;

	nres = 0;
	for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
		bars |= (1 << (i + PCI_IOV_RESOURCES));
		res = dev->resource + PCI_IOV_RESOURCES + i;
		if (res->parent)
			nres++;
	}
	if (nres != iov->nres) {
		dev_err(&dev->dev, "not enough MMIO resources for SR-IOV\n");
		return -ENOMEM;
	}

	iov->offset = offset;
	iov->stride = stride;

	if (virtfn_bus(dev, nr_virtfn - 1) > dev->bus->busn_res.end) {
		dev_err(&dev->dev, "SR-IOV: bus number out of range\n");
		return -ENOMEM;
	}

	if (pci_enable_resources(dev, bars)) {
		dev_err(&dev->dev, "SR-IOV: IOV BARS not allocated\n");
		return -ENOMEM;
	}

	if (iov->link != dev->devfn) {
		pdev = pci_get_slot(dev->bus, iov->link);
		if (!pdev)
			return -ENODEV;

		pci_dev_put(pdev);

		if (!pdev->is_physfn)
			return -ENODEV;

		rc = sysfs_create_link(&dev->dev.kobj,
					&pdev->dev.kobj, "dep_link");
		if (rc)
			return rc;
	}

	iov->ctrl |= PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE;
	pci_cfg_access_lock(dev);
	pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
	msleep(100);
	pci_cfg_access_unlock(dev);

	iov->initial = initial;
	if (nr_virtfn < initial)
		initial = nr_virtfn;

	for (i = 0; i < initial; i++) {
		rc = virtfn_add(dev, i, 0);
		if (rc)
			goto failed;
	}

	if (iov->cap & PCI_SRIOV_CAP_VFM) {
		rc = sriov_enable_migration(dev, nr_virtfn);
		if (rc)
			goto failed;
	}

	kobject_uevent(&dev->dev.kobj, KOBJ_CHANGE);
	iov->nr_virtfn = nr_virtfn;

	return 0;

failed:
	for (j = 0; j < i; j++)
		virtfn_remove(dev, j, 0);

	iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
	pci_cfg_access_lock(dev);
	pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
	ssleep(1);
	pci_cfg_access_unlock(dev);

	if (iov->link != dev->devfn)
		sysfs_remove_link(&dev->dev.kobj, "dep_link");

	return rc;
}

static void sriov_disable(struct pci_dev *dev)
{
	int i;
	struct pci_sriov *iov = dev->sriov;

	if (!iov->nr_virtfn)
		return;

	if (iov->cap & PCI_SRIOV_CAP_VFM)
		sriov_disable_migration(dev);

	for (i = 0; i < iov->nr_virtfn; i++)
		virtfn_remove(dev, i, 0);

	iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
	pci_cfg_access_lock(dev);
	pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
	ssleep(1);
	pci_cfg_access_unlock(dev);

	if (iov->link != dev->devfn)
		sysfs_remove_link(&dev->dev.kobj, "dep_link");

	iov->nr_virtfn = 0;
}

static int sriov_init(struct pci_dev *dev, int pos)
{
	int i;
	int rc;
	int nres;
	u32 pgsz;
	u16 ctrl, total, offset, stride;
	struct pci_sriov *iov;
	struct resource *res;
	struct pci_dev *pdev;

	if (pci_pcie_type(dev) != PCI_EXP_TYPE_RC_END &&
	    pci_pcie_type(dev) != PCI_EXP_TYPE_ENDPOINT)
		return -ENODEV;

	pci_read_config_word(dev, pos + PCI_SRIOV_CTRL, &ctrl);
	if (ctrl & PCI_SRIOV_CTRL_VFE) {
		pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, 0);
		ssleep(1);
	}

	pci_read_config_word(dev, pos + PCI_SRIOV_TOTAL_VF, &total);
	if (!total)
		return 0;

	ctrl = 0;
	list_for_each_entry(pdev, &dev->bus->devices, bus_list)
		if (pdev->is_physfn)
			goto found;

	pdev = NULL;
	if (pci_ari_enabled(dev->bus))
		ctrl |= PCI_SRIOV_CTRL_ARI;

found:
	pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, ctrl);
	pci_read_config_word(dev, pos + PCI_SRIOV_VF_OFFSET, &offset);
	pci_read_config_word(dev, pos + PCI_SRIOV_VF_STRIDE, &stride);
	if (!offset || (total > 1 && !stride))
		return -EIO;

	pci_read_config_dword(dev, pos + PCI_SRIOV_SUP_PGSIZE, &pgsz);
	i = PAGE_SHIFT > 12 ? PAGE_SHIFT - 12 : 0;
	pgsz &= ~((1 << i) - 1);
	if (!pgsz)
		return -EIO;

	pgsz &= ~(pgsz - 1);
	pci_write_config_dword(dev, pos + PCI_SRIOV_SYS_PGSIZE, pgsz);

	nres = 0;
	for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
		res = dev->resource + PCI_IOV_RESOURCES + i;
		i += __pci_read_base(dev, pci_bar_unknown, res,
				     pos + PCI_SRIOV_BAR + i * 4);
		if (!res->flags)
			continue;
		if (resource_size(res) & (PAGE_SIZE - 1)) {
			rc = -EIO;
			goto failed;
		}
		res->end = res->start + resource_size(res) * total - 1;
		nres++;
	}

	iov = kzalloc(sizeof(*iov), GFP_KERNEL);
	if (!iov) {
		rc = -ENOMEM;
		goto failed;
	}

	iov->pos = pos;
	iov->nres = nres;
	iov->ctrl = ctrl;
	iov->total = total;
	iov->offset = offset;
	iov->stride = stride;
	iov->pgsz = pgsz;
	iov->self = dev;
	pci_read_config_dword(dev, pos + PCI_SRIOV_CAP, &iov->cap);
	pci_read_config_byte(dev, pos + PCI_SRIOV_FUNC_LINK, &iov->link);
	if (pci_pcie_type(dev) == PCI_EXP_TYPE_RC_END)
		iov->link = PCI_DEVFN(PCI_SLOT(dev->devfn), iov->link);

	if (pdev)
		iov->dev = pci_dev_get(pdev);
	else
		iov->dev = dev;

	mutex_init(&iov->lock);

	dev->sriov = iov;
	dev->is_physfn = 1;

	return 0;

failed:
	for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
		res = dev->resource + PCI_IOV_RESOURCES + i;
		res->flags = 0;
	}

	return rc;
}

static void sriov_release(struct pci_dev *dev)
{
	BUG_ON(dev->sriov->nr_virtfn);

	if (dev != dev->sriov->dev)
		pci_dev_put(dev->sriov->dev);

	mutex_destroy(&dev->sriov->lock);

	kfree(dev->sriov);
	dev->sriov = NULL;
}

static void sriov_restore_state(struct pci_dev *dev)
{
	int i;
	u16 ctrl;
	struct pci_sriov *iov = dev->sriov;

	pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &ctrl);
	if (ctrl & PCI_SRIOV_CTRL_VFE)
		return;

	for (i = PCI_IOV_RESOURCES; i <= PCI_IOV_RESOURCE_END; i++)
		pci_update_resource(dev, i);

	pci_write_config_dword(dev, iov->pos + PCI_SRIOV_SYS_PGSIZE, iov->pgsz);
	pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, iov->nr_virtfn);
	pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
	if (iov->ctrl & PCI_SRIOV_CTRL_VFE)
		msleep(100);
}

/**
 * pci_iov_init - initialize the IOV capability
 * @dev: the PCI device
 *
 * Returns 0 on success, or negative on failure.
 */
int pci_iov_init(struct pci_dev *dev)
{
	int pos;

	if (!pci_is_pcie(dev))
		return -ENODEV;

	pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_SRIOV);
	if (pos)
		return sriov_init(dev, pos);

	return -ENODEV;
}

/**
 * pci_iov_release - release resources used by the IOV capability
 * @dev: the PCI device
 */
void pci_iov_release(struct pci_dev *dev)
{
	if (dev->is_physfn)
		sriov_release(dev);
}

/**
 * pci_iov_resource_bar - get position of the SR-IOV BAR
 * @dev: the PCI device
 * @resno: the resource number
 * @type: the BAR type to be filled in
 *
 * Returns position of the BAR encapsulated in the SR-IOV capability.
 */
int pci_iov_resource_bar(struct pci_dev *dev, int resno,
			 enum pci_bar_type *type)
{
	if (resno < PCI_IOV_RESOURCES || resno > PCI_IOV_RESOURCE_END)
		return 0;

	BUG_ON(!dev->is_physfn);

	*type = pci_bar_unknown;

	return dev->sriov->pos + PCI_SRIOV_BAR +
		4 * (resno - PCI_IOV_RESOURCES);
}

/**
 * pci_sriov_resource_alignment - get resource alignment for VF BAR
 * @dev: the PCI device
 * @resno: the resource number
 *
 * Returns the alignment of the VF BAR found in the SR-IOV capability.
 * This is not the same as the resource size which is defined as
 * the VF BAR size multiplied by the number of VFs.  The alignment
 * is just the VF BAR size.
 */
resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno)
{
	struct resource tmp;
	enum pci_bar_type type;
	int reg = pci_iov_resource_bar(dev, resno, &type);
	
	if (!reg)
		return 0;

	 __pci_read_base(dev, type, &tmp, reg);
	return resource_alignment(&tmp);
}

/**
 * pci_restore_iov_state - restore the state of the IOV capability
 * @dev: the PCI device
 */
void pci_restore_iov_state(struct pci_dev *dev)
{
	if (dev->is_physfn)
		sriov_restore_state(dev);
}

/**
 * pci_iov_bus_range - find bus range used by Virtual Function
 * @bus: the PCI bus
 *
 * Returns max number of buses (exclude current one) used by Virtual
 * Functions.
 */
int pci_iov_bus_range(struct pci_bus *bus)
{
	int max = 0;
	u8 busnr;
	struct pci_dev *dev;

	list_for_each_entry(dev, &bus->devices, bus_list) {
		if (!dev->is_physfn)
			continue;
		busnr = virtfn_bus(dev, dev->sriov->total - 1);
		if (busnr > max)
			max = busnr;
	}

	return max ? max - bus->number : 0;
}

/**
 * pci_enable_sriov - enable the SR-IOV capability
 * @dev: the PCI device
 * @nr_virtfn: number of virtual functions to enable
 *
 * Returns 0 on success, or negative on failure.
 */
int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn)
{
	might_sleep();

	if (!dev->is_physfn)
		return -ENODEV;

	return sriov_enable(dev, nr_virtfn);
}
EXPORT_SYMBOL_GPL(pci_enable_sriov);

/**
 * pci_disable_sriov - disable the SR-IOV capability
 * @dev: the PCI device
 */
void pci_disable_sriov(struct pci_dev *dev)
{
	might_sleep();

	if (!dev->is_physfn)
		return;

	sriov_disable(dev);
}
EXPORT_SYMBOL_GPL(pci_disable_sriov);

/**
 * pci_sriov_migration - notify SR-IOV core of Virtual Function Migration
 * @dev: the PCI device
 *
 * Returns IRQ_HANDLED if the IRQ is handled, or IRQ_NONE if not.
 *
 * Physical Function driver is responsible to register IRQ handler using
 * VF Migration Interrupt Message Number, and call this function when the
 * interrupt is generated by the hardware.
 */
irqreturn_t pci_sriov_migration(struct pci_dev *dev)
{
	if (!dev->is_physfn)
		return IRQ_NONE;

	return sriov_migration(dev) ? IRQ_HANDLED : IRQ_NONE;
}
EXPORT_SYMBOL_GPL(pci_sriov_migration);

/**
 * pci_num_vf - return number of VFs associated with a PF device_release_driver
 * @dev: the PCI device
 *
 * Returns number of VFs, or 0 if SR-IOV is not enabled.
 */
int pci_num_vf(struct pci_dev *dev)
{
	if (!dev || !dev->is_physfn)
		return 0;
	else
		return dev->sriov->nr_virtfn;
}
EXPORT_SYMBOL_GPL(pci_num_vf);
Commit	Line	Data
d1b054da YZ	1	/*
	2	* drivers/pci/iov.c
	3	*
	4	* Copyright (C) 2009 Intel Corporation, Yu Zhao <yu.zhao@intel.com>
	5	*
	6	* PCI Express I/O Virtualization (IOV) support.
	7	* Single Root IOV 1.0
302b4215	8	* Address Translation Service 1.0
d1b054da YZ	9	*/
	10
	11	#include <linux/pci.h>
5a0e3ad6	12	#include <linux/slab.h>
d1b054da	13	#include <linux/mutex.h>
363c75db	14	#include <linux/export.h>
d1b054da YZ	15	#include <linux/string.h>
d1b054da YZ	16	#include <linux/delay.h>
5cdede24	17	#include <linux/pci-ats.h>
d1b054da YZ	18	#include "pci.h"
d1b054da YZ	19
dd7cc44d	20	#define VIRTFN_ID_LEN 16
d1b054da	21
a28724b0 YZ	22	static inline u8 virtfn_bus(struct pci_dev *dev, int id)
	23	{
	24	return dev->bus->number + ((dev->devfn + dev->sriov->offset +
	25	dev->sriov->stride * id) >> 8);
	26	}
	27
	28	static inline u8 virtfn_devfn(struct pci_dev *dev, int id)
	29	{
	30	return (dev->devfn + dev->sriov->offset +
	31	dev->sriov->stride * id) & 0xff;
	32	}
	33
dd7cc44d YZ	34	static struct pci_bus virtfn_add_bus(struct pci_bus bus, int busnr)
	35	{
	36	int rc;
	37	struct pci_bus *child;
	38
	39	if (bus->number == busnr)
	40	return bus;
	41
	42	child = pci_find_bus(pci_domain_nr(bus), busnr);
	43	if (child)
	44	return child;
	45
	46	child = pci_add_new_bus(bus, NULL, busnr);
	47	if (!child)
	48	return NULL;
	49
b7eac055	50	pci_bus_insert_busn_res(child, busnr, busnr);
dd7cc44d YZ	51	child->dev.parent = bus->bridge;
	52	rc = pci_bus_add_child(child);
	53	if (rc) {
	54	pci_remove_bus(child);
	55	return NULL;
	56	}
	57
	58	return child;
	59	}
	60
	61	static void virtfn_remove_bus(struct pci_bus *bus, int busnr)
	62	{
	63	struct pci_bus *child;
	64
	65	if (bus->number == busnr)
	66	return;
	67
	68	child = pci_find_bus(pci_domain_nr(bus), busnr);
	69	BUG_ON(!child);
	70
	71	if (list_empty(&child->devices))
	72	pci_remove_bus(child);
	73	}
	74
	75	static int virtfn_add(struct pci_dev *dev, int id, int reset)
	76	{
	77	int i;
	78	int rc;
	79	u64 size;
	80	char buf[VIRTFN_ID_LEN];
	81	struct pci_dev *virtfn;
	82	struct resource *res;
	83	struct pci_sriov *iov = dev->sriov;
	84
	85	virtfn = alloc_pci_dev();
	86	if (!virtfn)
	87	return -ENOMEM;
	88
	89	mutex_lock(&iov->dev->sriov->lock);
	90	virtfn->bus = virtfn_add_bus(dev->bus, virtfn_bus(dev, id));
	91	if (!virtfn->bus) {
	92	kfree(virtfn);
	93	mutex_unlock(&iov->dev->sriov->lock);
	94	return -ENOMEM;
	95	}
	96	virtfn->devfn = virtfn_devfn(dev, id);
	97	virtfn->vendor = dev->vendor;
	98	pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_DID, &virtfn->device);
	99	pci_setup_device(virtfn);
	100	virtfn->dev.parent = dev->dev.parent;
	101
	102	for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
	103	res = dev->resource + PCI_IOV_RESOURCES + i;
	104	if (!res->parent)
	105	continue;
	106	virtfn->resource[i].name = pci_name(virtfn);
	107	virtfn->resource[i].flags = res->flags;
	108	size = resource_size(res);
	109	do_div(size, iov->total);
	110	virtfn->resource[i].start = res->start + size * id;
	111	virtfn->resource[i].end = virtfn->resource[i].start + size - 1;
	112	rc = request_resource(res, &virtfn->resource[i]);
	113	BUG_ON(rc);
	114	}
115
116	if (reset)
8c1c699f	117	__pci_reset_function(virtfn);
dd7cc44d YZ	118
	119	pci_device_add(virtfn, virtfn->bus);
	120	mutex_unlock(&iov->dev->sriov->lock);
	121
	122	virtfn->physfn = pci_dev_get(dev);
	123	virtfn->is_virtfn = 1;
	124
	125	rc = pci_bus_add_device(virtfn);
	126	if (rc)
	127	goto failed1;
	128	sprintf(buf, "virtfn%u", id);
	129	rc = sysfs_create_link(&dev->dev.kobj, &virtfn->dev.kobj, buf);
	130	if (rc)
	131	goto failed1;
	132	rc = sysfs_create_link(&virtfn->dev.kobj, &dev->dev.kobj, "physfn");
	133	if (rc)
	134	goto failed2;
	135
	136	kobject_uevent(&virtfn->dev.kobj, KOBJ_CHANGE);
	137
	138	return 0;
	139
	140	failed2:
	141	sysfs_remove_link(&dev->dev.kobj, buf);
	142	failed1:
	143	pci_dev_put(dev);
	144	mutex_lock(&iov->dev->sriov->lock);
210647af	145	pci_stop_and_remove_bus_device(virtfn);
dd7cc44d YZ	146	virtfn_remove_bus(dev->bus, virtfn_bus(dev, id));
	147	mutex_unlock(&iov->dev->sriov->lock);
	148
	149	return rc;
	150	}
	151
	152	static void virtfn_remove(struct pci_dev *dev, int id, int reset)
	153	{
	154	char buf[VIRTFN_ID_LEN];
dd7cc44d YZ	155	struct pci_dev *virtfn;
	156	struct pci_sriov *iov = dev->sriov;
	157
433efd22 JL	158	virtfn = pci_get_domain_bus_and_slot(pci_domain_nr(dev->bus),
433efd22 JL	159	virtfn_bus(dev, id), virtfn_devfn(dev, id));
dd7cc44d YZ	160	if (!virtfn)
	161	return;
	162
	163	pci_dev_put(virtfn);
	164
	165	if (reset) {
	166	device_release_driver(&virtfn->dev);
8c1c699f	167	__pci_reset_function(virtfn);
dd7cc44d YZ	168	}
	169
	170	sprintf(buf, "virtfn%u", id);
	171	sysfs_remove_link(&dev->dev.kobj, buf);
09cedbef YL	172	/*
	173	* pci_stop_dev() could have been called for this virtfn already,
	174	* so the directory for the virtfn may have been removed before.
	175	* Double check to avoid spurious sysfs warnings.
	176	*/
	177	if (virtfn->dev.kobj.sd)
	178	sysfs_remove_link(&virtfn->dev.kobj, "physfn");
dd7cc44d YZ	179
dd7cc44d YZ	180	mutex_lock(&iov->dev->sriov->lock);
210647af	181	pci_stop_and_remove_bus_device(virtfn);
dd7cc44d YZ	182	virtfn_remove_bus(dev->bus, virtfn_bus(dev, id));
	183	mutex_unlock(&iov->dev->sriov->lock);
	184
	185	pci_dev_put(dev);
	186	}
	187
74bb1bcc YZ	188	static int sriov_migration(struct pci_dev *dev)
	189	{
	190	u16 status;
	191	struct pci_sriov *iov = dev->sriov;
	192
	193	if (!iov->nr_virtfn)
	194	return 0;
	195
	196	if (!(iov->cap & PCI_SRIOV_CAP_VFM))
	197	return 0;
	198
	199	pci_read_config_word(dev, iov->pos + PCI_SRIOV_STATUS, &status);
	200	if (!(status & PCI_SRIOV_STATUS_VFM))
	201	return 0;
	202
	203	schedule_work(&iov->mtask);
	204
	205	return 1;
	206	}
	207
	208	static void sriov_migration_task(struct work_struct *work)
	209	{
	210	int i;
	211	u8 state;
	212	u16 status;
	213	struct pci_sriov *iov = container_of(work, struct pci_sriov, mtask);
	214
	215	for (i = iov->initial; i < iov->nr_virtfn; i++) {
	216	state = readb(iov->mstate + i);
	217	if (state == PCI_SRIOV_VFM_MI) {
	218	writeb(PCI_SRIOV_VFM_AV, iov->mstate + i);
	219	state = readb(iov->mstate + i);
	220	if (state == PCI_SRIOV_VFM_AV)
	221	virtfn_add(iov->self, i, 1);
	222	} else if (state == PCI_SRIOV_VFM_MO) {
	223	virtfn_remove(iov->self, i, 1);
	224	writeb(PCI_SRIOV_VFM_UA, iov->mstate + i);
	225	state = readb(iov->mstate + i);
	226	if (state == PCI_SRIOV_VFM_AV)
	227	virtfn_add(iov->self, i, 0);
	228	}
	229	}
	230
	231	pci_read_config_word(iov->self, iov->pos + PCI_SRIOV_STATUS, &status);
	232	status &= ~PCI_SRIOV_STATUS_VFM;
	233	pci_write_config_word(iov->self, iov->pos + PCI_SRIOV_STATUS, status);
	234	}
	235
	236	static int sriov_enable_migration(struct pci_dev *dev, int nr_virtfn)
	237	{
	238	int bir;
	239	u32 table;
	240	resource_size_t pa;
	241	struct pci_sriov *iov = dev->sriov;
	242
	243	if (nr_virtfn <= iov->initial)
	244	return 0;
	245
	246	pci_read_config_dword(dev, iov->pos + PCI_SRIOV_VFM, &table);
	247	bir = PCI_SRIOV_VFM_BIR(table);
	248	if (bir > PCI_STD_RESOURCE_END)
	249	return -EIO;
	250
	251	table = PCI_SRIOV_VFM_OFFSET(table);
252	if (table + nr_virtfn > pci_resource_len(dev, bir))
253	return -EIO;
254
255	pa = pci_resource_start(dev, bir) + table;
256	iov->mstate = ioremap(pa, nr_virtfn);
257	if (!iov->mstate)
258	return -ENOMEM;
259
260	INIT_WORK(&iov->mtask, sriov_migration_task);
261
262	iov->ctrl \|= PCI_SRIOV_CTRL_VFM \| PCI_SRIOV_CTRL_INTR;
263	pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
264
265	return 0;
266	}
267
268	static void sriov_disable_migration(struct pci_dev *dev)
269	{
270	struct pci_sriov *iov = dev->sriov;
271
272	iov->ctrl &= ~(PCI_SRIOV_CTRL_VFM \| PCI_SRIOV_CTRL_INTR);
273	pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
274
275	cancel_work_sync(&iov->mtask);
276	iounmap(iov->mstate);
277	}
278
dd7cc44d YZ	279	static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
	280	{
	281	int rc;
	282	int i, j;
	283	int nres;
	284	u16 offset, stride, initial;
	285	struct resource *res;
	286	struct pci_dev *pdev;
	287	struct pci_sriov *iov = dev->sriov;
bbef98ab	288	int bars = 0;
dd7cc44d YZ	289
	290	if (!nr_virtfn)
	291	return 0;
	292
	293	if (iov->nr_virtfn)
	294	return -EINVAL;
	295
	296	pci_read_config_word(dev, iov->pos + PCI_SRIOV_INITIAL_VF, &initial);
	297	if (initial > iov->total \|\|
	298	(!(iov->cap & PCI_SRIOV_CAP_VFM) && (initial != iov->total)))
	299	return -EIO;
	300
	301	if (nr_virtfn < 0 \|\| nr_virtfn > iov->total \|\|
	302	(!(iov->cap & PCI_SRIOV_CAP_VFM) && (nr_virtfn > initial)))
	303	return -EINVAL;
	304
	305	pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, nr_virtfn);
	306	pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_OFFSET, &offset);
	307	pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_STRIDE, &stride);
	308	if (!offset \|\| (nr_virtfn > 1 && !stride))
	309	return -EIO;
	310
	311	nres = 0;
	312	for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
bbef98ab	313	bars \|= (1 << (i + PCI_IOV_RESOURCES));
dd7cc44d YZ	314	res = dev->resource + PCI_IOV_RESOURCES + i;
	315	if (res->parent)
	316	nres++;
	317	}
	318	if (nres != iov->nres) {
	319	dev_err(&dev->dev, "not enough MMIO resources for SR-IOV\n");
	320	return -ENOMEM;
	321	}
	322
	323	iov->offset = offset;
	324	iov->stride = stride;
	325
b918c62e	326	if (virtfn_bus(dev, nr_virtfn - 1) > dev->bus->busn_res.end) {
dd7cc44d YZ	327	dev_err(&dev->dev, "SR-IOV: bus number out of range\n");
	328	return -ENOMEM;
	329	}
	330
bbef98ab RP	331	if (pci_enable_resources(dev, bars)) {
	332	dev_err(&dev->dev, "SR-IOV: IOV BARS not allocated\n");
	333	return -ENOMEM;
	334	}
	335
dd7cc44d YZ	336	if (iov->link != dev->devfn) {
	337	pdev = pci_get_slot(dev->bus, iov->link);
	338	if (!pdev)
	339	return -ENODEV;
	340
	341	pci_dev_put(pdev);
	342
	343	if (!pdev->is_physfn)
	344	return -ENODEV;
	345
	346	rc = sysfs_create_link(&dev->dev.kobj,
	347	&pdev->dev.kobj, "dep_link");
	348	if (rc)
	349	return rc;
	350	}
	351
	352	iov->ctrl \|= PCI_SRIOV_CTRL_VFE \| PCI_SRIOV_CTRL_MSE;
fb51ccbf	353	pci_cfg_access_lock(dev);
dd7cc44d YZ	354	pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
dd7cc44d YZ	355	msleep(100);
fb51ccbf	356	pci_cfg_access_unlock(dev);
dd7cc44d YZ	357
	358	iov->initial = initial;
	359	if (nr_virtfn < initial)
	360	initial = nr_virtfn;
	361
	362	for (i = 0; i < initial; i++) {
	363	rc = virtfn_add(dev, i, 0);
	364	if (rc)
	365	goto failed;
	366	}
	367
74bb1bcc YZ	368	if (iov->cap & PCI_SRIOV_CAP_VFM) {
	369	rc = sriov_enable_migration(dev, nr_virtfn);
	370	if (rc)
	371	goto failed;
	372	}
	373
dd7cc44d YZ	374	kobject_uevent(&dev->dev.kobj, KOBJ_CHANGE);
	375	iov->nr_virtfn = nr_virtfn;
	376
	377	return 0;
	378
	379	failed:
	380	for (j = 0; j < i; j++)
	381	virtfn_remove(dev, j, 0);
	382
	383	iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE \| PCI_SRIOV_CTRL_MSE);
fb51ccbf	384	pci_cfg_access_lock(dev);
dd7cc44d YZ	385	pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
dd7cc44d YZ	386	ssleep(1);
fb51ccbf	387	pci_cfg_access_unlock(dev);
dd7cc44d YZ	388
	389	if (iov->link != dev->devfn)
	390	sysfs_remove_link(&dev->dev.kobj, "dep_link");
	391
	392	return rc;
	393	}
	394
	395	static void sriov_disable(struct pci_dev *dev)
	396	{
	397	int i;
	398	struct pci_sriov *iov = dev->sriov;
	399
	400	if (!iov->nr_virtfn)
	401	return;
	402
74bb1bcc YZ	403	if (iov->cap & PCI_SRIOV_CAP_VFM)
	404	sriov_disable_migration(dev);
	405
dd7cc44d YZ	406	for (i = 0; i < iov->nr_virtfn; i++)
	407	virtfn_remove(dev, i, 0);
	408
	409	iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE \| PCI_SRIOV_CTRL_MSE);
fb51ccbf	410	pci_cfg_access_lock(dev);
dd7cc44d YZ	411	pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
dd7cc44d YZ	412	ssleep(1);
fb51ccbf	413	pci_cfg_access_unlock(dev);
dd7cc44d YZ	414
	415	if (iov->link != dev->devfn)
	416	sysfs_remove_link(&dev->dev.kobj, "dep_link");
	417
	418	iov->nr_virtfn = 0;
	419	}
	420
d1b054da YZ	421	static int sriov_init(struct pci_dev *dev, int pos)
	422	{
	423	int i;
	424	int rc;
	425	int nres;
	426	u32 pgsz;
	427	u16 ctrl, total, offset, stride;
	428	struct pci_sriov *iov;
	429	struct resource *res;
	430	struct pci_dev *pdev;
	431
62f87c0e YW	432	if (pci_pcie_type(dev) != PCI_EXP_TYPE_RC_END &&
62f87c0e YW	433	pci_pcie_type(dev) != PCI_EXP_TYPE_ENDPOINT)
d1b054da YZ	434	return -ENODEV;
	435
	436	pci_read_config_word(dev, pos + PCI_SRIOV_CTRL, &ctrl);
	437	if (ctrl & PCI_SRIOV_CTRL_VFE) {
	438	pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, 0);
	439	ssleep(1);
	440	}
	441
	442	pci_read_config_word(dev, pos + PCI_SRIOV_TOTAL_VF, &total);
	443	if (!total)
	444	return 0;
	445
	446	ctrl = 0;
	447	list_for_each_entry(pdev, &dev->bus->devices, bus_list)
	448	if (pdev->is_physfn)
	449	goto found;
	450
	451	pdev = NULL;
	452	if (pci_ari_enabled(dev->bus))
	453	ctrl \|= PCI_SRIOV_CTRL_ARI;
	454
	455	found:
	456	pci_write_config_word(dev, pos + PCI_SRIOV_CTRL, ctrl);
d1b054da YZ	457	pci_read_config_word(dev, pos + PCI_SRIOV_VF_OFFSET, &offset);
	458	pci_read_config_word(dev, pos + PCI_SRIOV_VF_STRIDE, &stride);
	459	if (!offset \|\| (total > 1 && !stride))
	460	return -EIO;
	461
	462	pci_read_config_dword(dev, pos + PCI_SRIOV_SUP_PGSIZE, &pgsz);
	463	i = PAGE_SHIFT > 12 ? PAGE_SHIFT - 12 : 0;
	464	pgsz &= ~((1 << i) - 1);
	465	if (!pgsz)
	466	return -EIO;
	467
	468	pgsz &= ~(pgsz - 1);
8161fe91	469	pci_write_config_dword(dev, pos + PCI_SRIOV_SYS_PGSIZE, pgsz);
d1b054da YZ	470
	471	nres = 0;
	472	for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
	473	res = dev->resource + PCI_IOV_RESOURCES + i;
	474	i += __pci_read_base(dev, pci_bar_unknown, res,
	475	pos + PCI_SRIOV_BAR + i * 4);
	476	if (!res->flags)
	477	continue;
	478	if (resource_size(res) & (PAGE_SIZE - 1)) {
	479	rc = -EIO;
	480	goto failed;
	481	}
	482	res->end = res->start + resource_size(res) * total - 1;
	483	nres++;
	484	}
	485
	486	iov = kzalloc(sizeof(*iov), GFP_KERNEL);
	487	if (!iov) {
	488	rc = -ENOMEM;
	489	goto failed;
	490	}
	491
	492	iov->pos = pos;
	493	iov->nres = nres;
	494	iov->ctrl = ctrl;
	495	iov->total = total;
	496	iov->offset = offset;
	497	iov->stride = stride;
	498	iov->pgsz = pgsz;
	499	iov->self = dev;
	500	pci_read_config_dword(dev, pos + PCI_SRIOV_CAP, &iov->cap);
	501	pci_read_config_byte(dev, pos + PCI_SRIOV_FUNC_LINK, &iov->link);
62f87c0e	502	if (pci_pcie_type(dev) == PCI_EXP_TYPE_RC_END)
4d135dbe	503	iov->link = PCI_DEVFN(PCI_SLOT(dev->devfn), iov->link);
d1b054da YZ	504
	505	if (pdev)
	506	iov->dev = pci_dev_get(pdev);
e277d2fc	507	else
d1b054da	508	iov->dev = dev;
e277d2fc YZ	509
e277d2fc YZ	510	mutex_init(&iov->lock);
d1b054da YZ	511
	512	dev->sriov = iov;
	513	dev->is_physfn = 1;
	514
	515	return 0;
	516
	517	failed:
	518	for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
	519	res = dev->resource + PCI_IOV_RESOURCES + i;
	520	res->flags = 0;
	521	}
	522
	523	return rc;
	524	}
	525
	526	static void sriov_release(struct pci_dev *dev)
	527	{
dd7cc44d YZ	528	BUG_ON(dev->sriov->nr_virtfn);
dd7cc44d YZ	529
e277d2fc	530	if (dev != dev->sriov->dev)
d1b054da YZ	531	pci_dev_put(dev->sriov->dev);
d1b054da YZ	532
e277d2fc YZ	533	mutex_destroy(&dev->sriov->lock);
e277d2fc YZ	534
d1b054da YZ	535	kfree(dev->sriov);
	536	dev->sriov = NULL;
	537	}
	538
8c5cdb6a YZ	539	static void sriov_restore_state(struct pci_dev *dev)
	540	{
	541	int i;
	542	u16 ctrl;
	543	struct pci_sriov *iov = dev->sriov;
	544
	545	pci_read_config_word(dev, iov->pos + PCI_SRIOV_CTRL, &ctrl);
	546	if (ctrl & PCI_SRIOV_CTRL_VFE)
	547	return;
	548
	549	for (i = PCI_IOV_RESOURCES; i <= PCI_IOV_RESOURCE_END; i++)
	550	pci_update_resource(dev, i);
	551
	552	pci_write_config_dword(dev, iov->pos + PCI_SRIOV_SYS_PGSIZE, iov->pgsz);
dd7cc44d	553	pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, iov->nr_virtfn);
8c5cdb6a YZ	554	pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
	555	if (iov->ctrl & PCI_SRIOV_CTRL_VFE)
	556	msleep(100);
	557	}
	558
d1b054da YZ	559	/**
	560	* pci_iov_init - initialize the IOV capability
	561	* @dev: the PCI device
	562	*
	563	* Returns 0 on success, or negative on failure.
	564	*/
	565	int pci_iov_init(struct pci_dev *dev)
	566	{
	567	int pos;
	568
5f4d91a1	569	if (!pci_is_pcie(dev))
d1b054da YZ	570	return -ENODEV;
	571
	572	pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_SRIOV);
	573	if (pos)
	574	return sriov_init(dev, pos);
	575
	576	return -ENODEV;
	577	}
	578
	579	/**
	580	* pci_iov_release - release resources used by the IOV capability
	581	* @dev: the PCI device
	582	*/
	583	void pci_iov_release(struct pci_dev *dev)
	584	{
	585	if (dev->is_physfn)
	586	sriov_release(dev);
	587	}
	588
	589	/**
	590	* pci_iov_resource_bar - get position of the SR-IOV BAR
	591	* @dev: the PCI device
	592	* @resno: the resource number
	593	* @type: the BAR type to be filled in
	594	*
	595	* Returns position of the BAR encapsulated in the SR-IOV capability.
	596	*/
	597	int pci_iov_resource_bar(struct pci_dev *dev, int resno,
	598	enum pci_bar_type *type)
	599	{
	600	if (resno < PCI_IOV_RESOURCES \|\| resno > PCI_IOV_RESOURCE_END)
	601	return 0;
	602
	603	BUG_ON(!dev->is_physfn);
	604
	605	*type = pci_bar_unknown;
	606
	607	return dev->sriov->pos + PCI_SRIOV_BAR +
	608	4 * (resno - PCI_IOV_RESOURCES);
	609	}
8c5cdb6a	610
6faf17f6 CW	611	/**
	612	* pci_sriov_resource_alignment - get resource alignment for VF BAR
	613	* @dev: the PCI device
	614	* @resno: the resource number
	615	*
	616	* Returns the alignment of the VF BAR found in the SR-IOV capability.
	617	* This is not the same as the resource size which is defined as
	618	* the VF BAR size multiplied by the number of VFs. The alignment
	619	* is just the VF BAR size.
	620	*/
0e52247a	621	resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno)
6faf17f6 CW	622	{
	623	struct resource tmp;
	624	enum pci_bar_type type;
	625	int reg = pci_iov_resource_bar(dev, resno, &type);
	626
	627	if (!reg)
	628	return 0;
	629
	630	__pci_read_base(dev, type, &tmp, reg);
	631	return resource_alignment(&tmp);
	632	}
	633
8c5cdb6a YZ	634	/**
	635	* pci_restore_iov_state - restore the state of the IOV capability
	636	* @dev: the PCI device
	637	*/
	638	void pci_restore_iov_state(struct pci_dev *dev)
	639	{
	640	if (dev->is_physfn)
	641	sriov_restore_state(dev);
	642	}
a28724b0 YZ	643
	644	/**
	645	* pci_iov_bus_range - find bus range used by Virtual Function
	646	* @bus: the PCI bus
	647	*
	648	* Returns max number of buses (exclude current one) used by Virtual
	649	* Functions.
	650	*/
	651	int pci_iov_bus_range(struct pci_bus *bus)
	652	{
	653	int max = 0;
	654	u8 busnr;
	655	struct pci_dev *dev;
	656
	657	list_for_each_entry(dev, &bus->devices, bus_list) {
	658	if (!dev->is_physfn)
	659	continue;
	660	busnr = virtfn_bus(dev, dev->sriov->total - 1);
	661	if (busnr > max)
	662	max = busnr;
	663	}
	664
	665	return max ? max - bus->number : 0;
	666	}
dd7cc44d YZ	667
	668	/**
	669	* pci_enable_sriov - enable the SR-IOV capability
	670	* @dev: the PCI device
52a8873b	671	* @nr_virtfn: number of virtual functions to enable
dd7cc44d YZ	672	*
	673	* Returns 0 on success, or negative on failure.
	674	*/
	675	int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn)
	676	{
	677	might_sleep();
	678
	679	if (!dev->is_physfn)
	680	return -ENODEV;
	681
	682	return sriov_enable(dev, nr_virtfn);
	683	}
	684	EXPORT_SYMBOL_GPL(pci_enable_sriov);
	685
	686	/**
	687	* pci_disable_sriov - disable the SR-IOV capability
	688	* @dev: the PCI device
	689	*/
	690	void pci_disable_sriov(struct pci_dev *dev)
	691	{
	692	might_sleep();
	693
	694	if (!dev->is_physfn)
	695	return;
	696
	697	sriov_disable(dev);
	698	}
	699	EXPORT_SYMBOL_GPL(pci_disable_sriov);
74bb1bcc YZ	700
	701	/**
	702	* pci_sriov_migration - notify SR-IOV core of Virtual Function Migration
	703	* @dev: the PCI device
	704	*
	705	* Returns IRQ_HANDLED if the IRQ is handled, or IRQ_NONE if not.
	706	*
	707	* Physical Function driver is responsible to register IRQ handler using
	708	* VF Migration Interrupt Message Number, and call this function when the
	709	* interrupt is generated by the hardware.
	710	*/
	711	irqreturn_t pci_sriov_migration(struct pci_dev *dev)
	712	{
	713	if (!dev->is_physfn)
	714	return IRQ_NONE;
	715
	716	return sriov_migration(dev) ? IRQ_HANDLED : IRQ_NONE;
	717	}
	718	EXPORT_SYMBOL_GPL(pci_sriov_migration);
302b4215	719
fb8a0d9d WM	720	/**
	721	* pci_num_vf - return number of VFs associated with a PF device_release_driver
	722	* @dev: the PCI device
	723	*
	724	* Returns number of VFs, or 0 if SR-IOV is not enabled.
	725	*/
	726	int pci_num_vf(struct pci_dev *dev)
	727	{
	728	if (!dev \|\| !dev->is_physfn)
	729	return 0;
	730	else
	731	return dev->sriov->nr_virtfn;
	732	}
	733	EXPORT_SYMBOL_GPL(pci_num_vf);