[deliverable/linux.git] / drivers / xen / xen-pciback / passthrough.c

/*
 * PCI Backend - Provides restricted access to the real PCI bus topology
 *               to the frontend
 *
 *   Author: Ryan Wilson <hap9@epoch.ncsc.mil>
 */

#include <linux/list.h>
#include <linux/pci.h>
#include <linux/mutex.h>
#include "pciback.h"

struct passthrough_dev_data {
	/* Access to dev_list must be protected by lock */
	struct list_head dev_list;
	struct mutex lock;
};

static struct pci_dev *__xen_pcibk_get_pci_dev(struct xen_pcibk_device *pdev,
					       unsigned int domain,
					       unsigned int bus,
					       unsigned int devfn)
{
	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	struct pci_dev_entry *dev_entry;
	struct pci_dev *dev = NULL;

	mutex_lock(&dev_data->lock);

	list_for_each_entry(dev_entry, &dev_data->dev_list, list) {
		if (domain == (unsigned int)pci_domain_nr(dev_entry->dev->bus)
		    && bus == (unsigned int)dev_entry->dev->bus->number
		    && devfn == dev_entry->dev->devfn) {
			dev = dev_entry->dev;
			break;
		}
	}

	mutex_unlock(&dev_data->lock);

	return dev;
}

static int __xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
				   struct pci_dev *dev,
				   int devid, publish_pci_dev_cb publish_cb)
{
	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	struct pci_dev_entry *dev_entry;
	unsigned int domain, bus, devfn;
	int err;

	dev_entry = kmalloc(sizeof(*dev_entry), GFP_KERNEL);
	if (!dev_entry)
		return -ENOMEM;
	dev_entry->dev = dev;

	mutex_lock(&dev_data->lock);
	list_add_tail(&dev_entry->list, &dev_data->dev_list);
	mutex_unlock(&dev_data->lock);

	/* Publish this device. */
	domain = (unsigned int)pci_domain_nr(dev->bus);
	bus = (unsigned int)dev->bus->number;
	devfn = dev->devfn;
	err = publish_cb(pdev, domain, bus, devfn, devid);

	return err;
}

static void __xen_pcibk_release_pci_dev(struct xen_pcibk_device *pdev,
					struct pci_dev *dev)
{
	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	struct pci_dev_entry *dev_entry, *t;
	struct pci_dev *found_dev = NULL;

	mutex_lock(&dev_data->lock);

	list_for_each_entry_safe(dev_entry, t, &dev_data->dev_list, list) {
		if (dev_entry->dev == dev) {
			list_del(&dev_entry->list);
			found_dev = dev_entry->dev;
			kfree(dev_entry);
		}
	}

	mutex_unlock(&dev_data->lock);

	if (found_dev)
		pcistub_put_pci_dev(found_dev);
}

static int __xen_pcibk_init_devices(struct xen_pcibk_device *pdev)
{
	struct passthrough_dev_data *dev_data;

	dev_data = kmalloc(sizeof(*dev_data), GFP_KERNEL);
	if (!dev_data)
		return -ENOMEM;

	mutex_init(&dev_data->lock);

	INIT_LIST_HEAD(&dev_data->dev_list);

	pdev->pci_dev_data = dev_data;

	return 0;
}

static int __xen_pcibk_publish_pci_roots(struct xen_pcibk_device *pdev,
					 publish_pci_root_cb publish_root_cb)
{
	int err = 0;
	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	struct pci_dev_entry *dev_entry, *e;
	struct pci_dev *dev;
	int found;
	unsigned int domain, bus;

	mutex_lock(&dev_data->lock);

	list_for_each_entry(dev_entry, &dev_data->dev_list, list) {
		/* Only publish this device as a root if none of its
		 * parent bridges are exported
		 */
		found = 0;
		dev = dev_entry->dev->bus->self;
		for (; !found && dev != NULL; dev = dev->bus->self) {
			list_for_each_entry(e, &dev_data->dev_list, list) {
				if (dev == e->dev) {
					found = 1;
					break;
				}
			}
		}

		domain = (unsigned int)pci_domain_nr(dev_entry->dev->bus);
		bus = (unsigned int)dev_entry->dev->bus->number;

		if (!found) {
			err = publish_root_cb(pdev, domain, bus);
			if (err)
				break;
		}
	}

	mutex_unlock(&dev_data->lock);

	return err;
}

static void __xen_pcibk_release_devices(struct xen_pcibk_device *pdev)
{
	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	struct pci_dev_entry *dev_entry, *t;

	list_for_each_entry_safe(dev_entry, t, &dev_data->dev_list, list) {
		list_del(&dev_entry->list);
		pcistub_put_pci_dev(dev_entry->dev);
		kfree(dev_entry);
	}

	kfree(dev_data);
	pdev->pci_dev_data = NULL;
}

static int __xen_pcibk_get_pcifront_dev(struct pci_dev *pcidev,
					struct xen_pcibk_device *pdev,
					unsigned int *domain, unsigned int *bus,
					unsigned int *devfn)
{
	*domain = pci_domain_nr(pcidev->bus);
	*bus = pcidev->bus->number;
	*devfn = pcidev->devfn;
	return 1;
}

const struct xen_pcibk_backend xen_pcibk_passthrough_backend = {
	.name           = "passthrough",
	.init           = __xen_pcibk_init_devices,
	.free		= __xen_pcibk_release_devices,
	.find           = __xen_pcibk_get_pcifront_dev,
	.publish        = __xen_pcibk_publish_pci_roots,
	.release        = __xen_pcibk_release_pci_dev,
	.add            = __xen_pcibk_add_pci_dev,
	.get            = __xen_pcibk_get_pci_dev,
};
Commit	Line	Data
30edc14b KRW	1	/*
	2	* PCI Backend - Provides restricted access to the real PCI bus topology
	3	* to the frontend
	4	*
	5	* Author: Ryan Wilson <hap9@epoch.ncsc.mil>
	6	*/
	7
	8	#include <linux/list.h>
	9	#include <linux/pci.h>
04df3552	10	#include <linux/mutex.h>
30edc14b KRW	11	#include "pciback.h"
	12
	13	struct passthrough_dev_data {
	14	/* Access to dev_list must be protected by lock */
	15	struct list_head dev_list;
04df3552	16	struct mutex lock;
30edc14b KRW	17	};
30edc14b KRW	18
2ebdc426 KRW	19	static struct pci_dev __xen_pcibk_get_pci_dev(struct xen_pcibk_device pdev,
	20	unsigned int domain,
	21	unsigned int bus,
	22	unsigned int devfn)
30edc14b KRW	23	{
	24	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	25	struct pci_dev_entry *dev_entry;
	26	struct pci_dev *dev = NULL;
30edc14b	27
04df3552	28	mutex_lock(&dev_data->lock);
30edc14b KRW	29
	30	list_for_each_entry(dev_entry, &dev_data->dev_list, list) {
	31	if (domain == (unsigned int)pci_domain_nr(dev_entry->dev->bus)
	32	&& bus == (unsigned int)dev_entry->dev->bus->number
	33	&& devfn == dev_entry->dev->devfn) {
	34	dev = dev_entry->dev;
	35	break;
	36	}
	37	}
	38
04df3552	39	mutex_unlock(&dev_data->lock);
30edc14b KRW	40
	41	return dev;
	42	}
	43
2ebdc426 KRW	44	static int __xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
	45	struct pci_dev *dev,
	46	int devid, publish_pci_dev_cb publish_cb)
30edc14b KRW	47	{
	48	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	49	struct pci_dev_entry *dev_entry;
30edc14b KRW	50	unsigned int domain, bus, devfn;
	51	int err;
	52
	53	dev_entry = kmalloc(sizeof(*dev_entry), GFP_KERNEL);
	54	if (!dev_entry)
	55	return -ENOMEM;
	56	dev_entry->dev = dev;
	57
04df3552	58	mutex_lock(&dev_data->lock);
30edc14b	59	list_add_tail(&dev_entry->list, &dev_data->dev_list);
04df3552	60	mutex_unlock(&dev_data->lock);
30edc14b KRW	61
	62	/* Publish this device. */
	63	domain = (unsigned int)pci_domain_nr(dev->bus);
	64	bus = (unsigned int)dev->bus->number;
	65	devfn = dev->devfn;
	66	err = publish_cb(pdev, domain, bus, devfn, devid);
	67
	68	return err;
	69	}
	70
2ebdc426 KRW	71	static void __xen_pcibk_release_pci_dev(struct xen_pcibk_device *pdev,
2ebdc426 KRW	72	struct pci_dev *dev)
30edc14b KRW	73	{
	74	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	75	struct pci_dev_entry dev_entry, t;
	76	struct pci_dev *found_dev = NULL;
30edc14b	77
04df3552	78	mutex_lock(&dev_data->lock);
30edc14b KRW	79
	80	list_for_each_entry_safe(dev_entry, t, &dev_data->dev_list, list) {
	81	if (dev_entry->dev == dev) {
	82	list_del(&dev_entry->list);
	83	found_dev = dev_entry->dev;
	84	kfree(dev_entry);
	85	}
	86	}
	87
04df3552	88	mutex_unlock(&dev_data->lock);
30edc14b KRW	89
	90	if (found_dev)
	91	pcistub_put_pci_dev(found_dev);
	92	}
	93
2ebdc426	94	static int __xen_pcibk_init_devices(struct xen_pcibk_device *pdev)
30edc14b KRW	95	{
	96	struct passthrough_dev_data *dev_data;
	97
	98	dev_data = kmalloc(sizeof(*dev_data), GFP_KERNEL);
	99	if (!dev_data)
	100	return -ENOMEM;
	101
04df3552	102	mutex_init(&dev_data->lock);
30edc14b KRW	103
	104	INIT_LIST_HEAD(&dev_data->dev_list);
	105
	106	pdev->pci_dev_data = dev_data;
	107
	108	return 0;
	109	}
	110
2ebdc426 KRW	111	static int __xen_pcibk_publish_pci_roots(struct xen_pcibk_device *pdev,
2ebdc426 KRW	112	publish_pci_root_cb publish_root_cb)
30edc14b KRW	113	{
	114	int err = 0;
	115	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
04df3552	116	struct pci_dev_entry dev_entry, e;
30edc14b KRW	117	struct pci_dev *dev;
	118	int found;
	119	unsigned int domain, bus;
	120
04df3552	121	mutex_lock(&dev_data->lock);
30edc14b	122
04df3552	123	list_for_each_entry(dev_entry, &dev_data->dev_list, list) {
30edc14b KRW	124	/* Only publish this device as a root if none of its
	125	* parent bridges are exported
	126	*/
	127	found = 0;
	128	dev = dev_entry->dev->bus->self;
	129	for (; !found && dev != NULL; dev = dev->bus->self) {
	130	list_for_each_entry(e, &dev_data->dev_list, list) {
	131	if (dev == e->dev) {
	132	found = 1;
	133	break;
	134	}
	135	}
	136	}
	137
	138	domain = (unsigned int)pci_domain_nr(dev_entry->dev->bus);
	139	bus = (unsigned int)dev_entry->dev->bus->number;
	140
	141	if (!found) {
	142	err = publish_root_cb(pdev, domain, bus);
	143	if (err)
	144	break;
	145	}
	146	}
	147
04df3552	148	mutex_unlock(&dev_data->lock);
30edc14b KRW	149
	150	return err;
	151	}
	152
2ebdc426	153	static void __xen_pcibk_release_devices(struct xen_pcibk_device *pdev)
30edc14b KRW	154	{
	155	struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
	156	struct pci_dev_entry dev_entry, t;
	157
	158	list_for_each_entry_safe(dev_entry, t, &dev_data->dev_list, list) {
	159	list_del(&dev_entry->list);
	160	pcistub_put_pci_dev(dev_entry->dev);
	161	kfree(dev_entry);
	162	}
	163
	164	kfree(dev_data);
	165	pdev->pci_dev_data = NULL;
	166	}
	167
2ebdc426 KRW	168	static int __xen_pcibk_get_pcifront_dev(struct pci_dev *pcidev,
	169	struct xen_pcibk_device *pdev,
	170	unsigned int domain, unsigned int bus,
	171	unsigned int *devfn)
30edc14b KRW	172	{
	173	*domain = pci_domain_nr(pcidev->bus);
	174	*bus = pcidev->bus->number;
	175	*devfn = pcidev->devfn;
	176	return 1;
	177	}
2ebdc426	178
402c5e15	179	const struct xen_pcibk_backend xen_pcibk_passthrough_backend = {
2ebdc426 KRW	180	.name = "passthrough",
	181	.init = __xen_pcibk_init_devices,
	182	.free = __xen_pcibk_release_devices,
	183	.find = __xen_pcibk_get_pcifront_dev,
	184	.publish = __xen_pcibk_publish_pci_roots,
	185	.release = __xen_pcibk_release_pci_dev,
	186	.add = __xen_pcibk_add_pci_dev,
	187	.get = __xen_pcibk_get_pci_dev,
	188	};