[linux-2.6-block.git] / drivers / dca / dca-core.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright(c) 2007 - 2009 Intel Corporation. All rights reserved.
 */

/*
 * This driver supports an interface for DCA clients and providers to meet.
 */

#include <linux/kernel.h>
#include <linux/notifier.h>
#include <linux/device.h>
#include <linux/dca.h>
#include <linux/slab.h>
#include <linux/module.h>

#define DCA_VERSION "1.12.1"

MODULE_VERSION(DCA_VERSION);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Intel Corporation");

static DEFINE_RAW_SPINLOCK(dca_lock);

static LIST_HEAD(dca_domains);

static BLOCKING_NOTIFIER_HEAD(dca_provider_chain);

static int dca_providers_blocked;

static struct pci_bus *dca_pci_rc_from_dev(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct pci_bus *bus = pdev->bus;

	while (bus->parent)
		bus = bus->parent;

	return bus;
}

static struct dca_domain *dca_allocate_domain(struct pci_bus *rc)
{
	struct dca_domain *domain;

	domain = kzalloc(sizeof(*domain), GFP_NOWAIT);
	if (!domain)
		return NULL;

	INIT_LIST_HEAD(&domain->dca_providers);
	domain->pci_rc = rc;

	return domain;
}

static void dca_free_domain(struct dca_domain *domain)
{
	list_del(&domain->node);
	kfree(domain);
}

static int dca_provider_ioat_ver_3_0(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);

	return ((pdev->vendor == PCI_VENDOR_ID_INTEL) &&
		((pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG0) ||
		(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG1) ||
		(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG2) ||
		(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG3) ||
		(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG4) ||
		(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG5) ||
		(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG6) ||
		(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG7)));
}

static void unregister_dca_providers(void)
{
	struct dca_provider *dca, *_dca;
	struct list_head unregistered_providers;
	struct dca_domain *domain;
	unsigned long flags;

	blocking_notifier_call_chain(&dca_provider_chain,
				     DCA_PROVIDER_REMOVE, NULL);

	INIT_LIST_HEAD(&unregistered_providers);

	raw_spin_lock_irqsave(&dca_lock, flags);

	if (list_empty(&dca_domains)) {
		raw_spin_unlock_irqrestore(&dca_lock, flags);
		return;
	}

	/* at this point only one domain in the list is expected */
	domain = list_first_entry(&dca_domains, struct dca_domain, node);

	list_for_each_entry_safe(dca, _dca, &domain->dca_providers, node)
		list_move(&dca->node, &unregistered_providers);

	dca_free_domain(domain);

	raw_spin_unlock_irqrestore(&dca_lock, flags);

	list_for_each_entry_safe(dca, _dca, &unregistered_providers, node) {
		dca_sysfs_remove_provider(dca);
		list_del(&dca->node);
	}
}

static struct dca_domain *dca_find_domain(struct pci_bus *rc)
{
	struct dca_domain *domain;

	list_for_each_entry(domain, &dca_domains, node)
		if (domain->pci_rc == rc)
			return domain;

	return NULL;
}

static struct dca_domain *dca_get_domain(struct device *dev)
{
	struct pci_bus *rc;
	struct dca_domain *domain;

	rc = dca_pci_rc_from_dev(dev);
	domain = dca_find_domain(rc);

	if (!domain) {
		if (dca_provider_ioat_ver_3_0(dev) && !list_empty(&dca_domains))
			dca_providers_blocked = 1;
	}

	return domain;
}

static struct dca_provider *dca_find_provider_by_dev(struct device *dev)
{
	struct dca_provider *dca;
	struct pci_bus *rc;
	struct dca_domain *domain;

	if (dev) {
		rc = dca_pci_rc_from_dev(dev);
		domain = dca_find_domain(rc);
		if (!domain)
			return NULL;
	} else {
		if (!list_empty(&dca_domains))
			domain = list_first_entry(&dca_domains,
						  struct dca_domain,
						  node);
		else
			return NULL;
	}

	list_for_each_entry(dca, &domain->dca_providers, node)
		if ((!dev) || (dca->ops->dev_managed(dca, dev)))
			return dca;

	return NULL;
}

/**
 * dca_add_requester - add a dca client to the list
 * @dev - the device that wants dca service
 */
int dca_add_requester(struct device *dev)
{
	struct dca_provider *dca;
	int err, slot = -ENODEV;
	unsigned long flags;
	struct pci_bus *pci_rc;
	struct dca_domain *domain;

	if (!dev)
		return -EFAULT;

	raw_spin_lock_irqsave(&dca_lock, flags);

	/* check if the requester has not been added already */
	dca = dca_find_provider_by_dev(dev);
	if (dca) {
		raw_spin_unlock_irqrestore(&dca_lock, flags);
		return -EEXIST;
	}

	pci_rc = dca_pci_rc_from_dev(dev);
	domain = dca_find_domain(pci_rc);
	if (!domain) {
		raw_spin_unlock_irqrestore(&dca_lock, flags);
		return -ENODEV;
	}

	list_for_each_entry(dca, &domain->dca_providers, node) {
		slot = dca->ops->add_requester(dca, dev);
		if (slot >= 0)
			break;
	}

	raw_spin_unlock_irqrestore(&dca_lock, flags);

	if (slot < 0)
		return slot;

	err = dca_sysfs_add_req(dca, dev, slot);
	if (err) {
		raw_spin_lock_irqsave(&dca_lock, flags);
		if (dca == dca_find_provider_by_dev(dev))
			dca->ops->remove_requester(dca, dev);
		raw_spin_unlock_irqrestore(&dca_lock, flags);
		return err;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(dca_add_requester);

/**
 * dca_remove_requester - remove a dca client from the list
 * @dev - the device that wants dca service
 */
int dca_remove_requester(struct device *dev)
{
	struct dca_provider *dca;
	int slot;
	unsigned long flags;

	if (!dev)
		return -EFAULT;

	raw_spin_lock_irqsave(&dca_lock, flags);
	dca = dca_find_provider_by_dev(dev);
	if (!dca) {
		raw_spin_unlock_irqrestore(&dca_lock, flags);
		return -ENODEV;
	}
	slot = dca->ops->remove_requester(dca, dev);
	raw_spin_unlock_irqrestore(&dca_lock, flags);

	if (slot < 0)
		return slot;

	dca_sysfs_remove_req(dca, slot);

	return 0;
}
EXPORT_SYMBOL_GPL(dca_remove_requester);

/**
 * dca_common_get_tag - return the dca tag (serves both new and old api)
 * @dev - the device that wants dca service
 * @cpu - the cpuid as returned by get_cpu()
 */
static u8 dca_common_get_tag(struct device *dev, int cpu)
{
	struct dca_provider *dca;
	u8 tag;
	unsigned long flags;

	raw_spin_lock_irqsave(&dca_lock, flags);

	dca = dca_find_provider_by_dev(dev);
	if (!dca) {
		raw_spin_unlock_irqrestore(&dca_lock, flags);
		return -ENODEV;
	}
	tag = dca->ops->get_tag(dca, dev, cpu);

	raw_spin_unlock_irqrestore(&dca_lock, flags);
	return tag;
}

/**
 * dca3_get_tag - return the dca tag to the requester device
 *                for the given cpu (new api)
 * @dev - the device that wants dca service
 * @cpu - the cpuid as returned by get_cpu()
 */
u8 dca3_get_tag(struct device *dev, int cpu)
{
	if (!dev)
		return -EFAULT;

	return dca_common_get_tag(dev, cpu);
}
EXPORT_SYMBOL_GPL(dca3_get_tag);

/**
 * dca_get_tag - return the dca tag for the given cpu (old api)
 * @cpu - the cpuid as returned by get_cpu()
 */
u8 dca_get_tag(int cpu)
{
	struct device *dev = NULL;

	return dca_common_get_tag(dev, cpu);
}
EXPORT_SYMBOL_GPL(dca_get_tag);

/**
 * alloc_dca_provider - get data struct for describing a dca provider
 * @ops - pointer to struct of dca operation function pointers
 * @priv_size - size of extra mem to be added for provider's needs
 */
struct dca_provider *alloc_dca_provider(const struct dca_ops *ops,
					int priv_size)
{
	struct dca_provider *dca;
	int alloc_size;

	alloc_size = (sizeof(*dca) + priv_size);
	dca = kzalloc(alloc_size, GFP_KERNEL);
	if (!dca)
		return NULL;
	dca->ops = ops;

	return dca;
}
EXPORT_SYMBOL_GPL(alloc_dca_provider);

/**
 * free_dca_provider - release the dca provider data struct
 * @ops - pointer to struct of dca operation function pointers
 * @priv_size - size of extra mem to be added for provider's needs
 */
void free_dca_provider(struct dca_provider *dca)
{
	kfree(dca);
}
EXPORT_SYMBOL_GPL(free_dca_provider);

/**
 * register_dca_provider - register a dca provider
 * @dca - struct created by alloc_dca_provider()
 * @dev - device providing dca services
 */
int register_dca_provider(struct dca_provider *dca, struct device *dev)
{
	int err;
	unsigned long flags;
	struct dca_domain *domain, *newdomain = NULL;

	raw_spin_lock_irqsave(&dca_lock, flags);
	if (dca_providers_blocked) {
		raw_spin_unlock_irqrestore(&dca_lock, flags);
		return -ENODEV;
	}
	raw_spin_unlock_irqrestore(&dca_lock, flags);

	err = dca_sysfs_add_provider(dca, dev);
	if (err)
		return err;

	raw_spin_lock_irqsave(&dca_lock, flags);
	domain = dca_get_domain(dev);
	if (!domain) {
		struct pci_bus *rc;

		if (dca_providers_blocked) {
			raw_spin_unlock_irqrestore(&dca_lock, flags);
			dca_sysfs_remove_provider(dca);
			unregister_dca_providers();
			return -ENODEV;
		}

		raw_spin_unlock_irqrestore(&dca_lock, flags);
		rc = dca_pci_rc_from_dev(dev);
		newdomain = dca_allocate_domain(rc);
		if (!newdomain)
			return -ENODEV;
		raw_spin_lock_irqsave(&dca_lock, flags);
		/* Recheck, we might have raced after dropping the lock */
		domain = dca_get_domain(dev);
		if (!domain) {
			domain = newdomain;
			newdomain = NULL;
			list_add(&domain->node, &dca_domains);
		}
	}
	list_add(&dca->node, &domain->dca_providers);
	raw_spin_unlock_irqrestore(&dca_lock, flags);

	blocking_notifier_call_chain(&dca_provider_chain,
				     DCA_PROVIDER_ADD, NULL);
	kfree(newdomain);
	return 0;
}
EXPORT_SYMBOL_GPL(register_dca_provider);

/**
 * unregister_dca_provider - remove a dca provider
 * @dca - struct created by alloc_dca_provider()
 */
void unregister_dca_provider(struct dca_provider *dca, struct device *dev)
{
	unsigned long flags;
	struct pci_bus *pci_rc;
	struct dca_domain *domain;

	blocking_notifier_call_chain(&dca_provider_chain,
				     DCA_PROVIDER_REMOVE, NULL);

	raw_spin_lock_irqsave(&dca_lock, flags);

	if (list_empty(&dca_domains)) {
		raw_spin_unlock_irqrestore(&dca_lock, flags);
		return;
	}

	list_del(&dca->node);

	pci_rc = dca_pci_rc_from_dev(dev);
	domain = dca_find_domain(pci_rc);
	if (list_empty(&domain->dca_providers))
		dca_free_domain(domain);

	raw_spin_unlock_irqrestore(&dca_lock, flags);

	dca_sysfs_remove_provider(dca);
}
EXPORT_SYMBOL_GPL(unregister_dca_provider);

/**
 * dca_register_notify - register a client's notifier callback
 */
void dca_register_notify(struct notifier_block *nb)
{
	blocking_notifier_chain_register(&dca_provider_chain, nb);
}
EXPORT_SYMBOL_GPL(dca_register_notify);

/**
 * dca_unregister_notify - remove a client's notifier callback
 */
void dca_unregister_notify(struct notifier_block *nb)
{
	blocking_notifier_chain_unregister(&dca_provider_chain, nb);
}
EXPORT_SYMBOL_GPL(dca_unregister_notify);

static int __init dca_init(void)
{
	pr_info("dca service started, version %s\n", DCA_VERSION);
	return dca_sysfs_init();
}

static void __exit dca_exit(void)
{
	dca_sysfs_exit();
}

arch_initcall(dca_init);
module_exit(dca_exit);
Commit	Line	Data
e62d9491	1	// SPDX-License-Identifier: GPL-2.0-or-later
7589670f	2	/*
211a22ce	3	* Copyright(c) 2007 - 2009 Intel Corporation. All rights reserved.
7589670f SN	4	*/
	5
	6	/*
	7	* This driver supports an interface for DCA clients and providers to meet.
	8	*/
	9
	10	#include <linux/kernel.h>
	11	#include <linux/notifier.h>
	12	#include <linux/device.h>
	13	#include <linux/dca.h>
5a0e3ad6	14	#include <linux/slab.h>
d229807f	15	#include <linux/module.h>
7589670f	16
1a5aeeec	17	#define DCA_VERSION "1.12.1"
7589670f	18
7f1b358a MS	19	MODULE_VERSION(DCA_VERSION);
	20	MODULE_LICENSE("GPL");
	21	MODULE_AUTHOR("Intel Corporation");
7589670f	22
a1741e7f	23	static DEFINE_RAW_SPINLOCK(dca_lock);
7589670f	24
1a5aeeec	25	static LIST_HEAD(dca_domains);
7f1b358a	26
4e8cec26 SM	27	static BLOCKING_NOTIFIER_HEAD(dca_provider_chain);
	28
	29	static int dca_providers_blocked;
	30
1a5aeeec	31	static struct pci_bus dca_pci_rc_from_dev(struct device dev)
7f1b358a	32	{
1a5aeeec MS	33	struct pci_dev *pdev = to_pci_dev(dev);
1a5aeeec MS	34	struct pci_bus *bus = pdev->bus;
7f1b358a	35
1a5aeeec MS	36	while (bus->parent)
	37	bus = bus->parent;
	38
	39	return bus;
	40	}
	41
	42	static struct dca_domain dca_allocate_domain(struct pci_bus rc)
	43	{
	44	struct dca_domain *domain;
	45
	46	domain = kzalloc(sizeof(*domain), GFP_NOWAIT);
	47	if (!domain)
	48	return NULL;
	49
	50	INIT_LIST_HEAD(&domain->dca_providers);
	51	domain->pci_rc = rc;
	52
	53	return domain;
	54	}
	55
	56	static void dca_free_domain(struct dca_domain *domain)
	57	{
	58	list_del(&domain->node);
	59	kfree(domain);
	60	}
	61
4e8cec26 SM	62	static int dca_provider_ioat_ver_3_0(struct device *dev)
	63	{
	64	struct pci_dev *pdev = to_pci_dev(dev);
	65
	66	return ((pdev->vendor == PCI_VENDOR_ID_INTEL) &&
	67	((pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG0) \|\|
	68	(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG1) \|\|
	69	(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG2) \|\|
	70	(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG3) \|\|
	71	(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG4) \|\|
	72	(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG5) \|\|
	73	(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG6) \|\|
	74	(pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG7)));
	75	}
	76
	77	static void unregister_dca_providers(void)
	78	{
	79	struct dca_provider dca, _dca;
	80	struct list_head unregistered_providers;
	81	struct dca_domain *domain;
	82	unsigned long flags;
	83
	84	blocking_notifier_call_chain(&dca_provider_chain,
	85	DCA_PROVIDER_REMOVE, NULL);
	86
	87	INIT_LIST_HEAD(&unregistered_providers);
	88
a1741e7f	89	raw_spin_lock_irqsave(&dca_lock, flags);
4e8cec26 SM	90
4e8cec26 SM	91	if (list_empty(&dca_domains)) {
a1741e7f	92	raw_spin_unlock_irqrestore(&dca_lock, flags);
4e8cec26 SM	93	return;
	94	}
	95
	96	/* at this point only one domain in the list is expected */
	97	domain = list_first_entry(&dca_domains, struct dca_domain, node);
4e8cec26	98
3bb598fb KS	99	list_for_each_entry_safe(dca, _dca, &domain->dca_providers, node)
3bb598fb KS	100	list_move(&dca->node, &unregistered_providers);
4e8cec26 SM	101
	102	dca_free_domain(domain);
	103
a1741e7f	104	raw_spin_unlock_irqrestore(&dca_lock, flags);
4e8cec26 SM	105
	106	list_for_each_entry_safe(dca, _dca, &unregistered_providers, node) {
	107	dca_sysfs_remove_provider(dca);
	108	list_del(&dca->node);
	109	}
	110	}
	111
1a5aeeec MS	112	static struct dca_domain dca_find_domain(struct pci_bus rc)
	113	{
	114	struct dca_domain *domain;
	115
	116	list_for_each_entry(domain, &dca_domains, node)
	117	if (domain->pci_rc == rc)
	118	return domain;
	119
	120	return NULL;
	121	}
	122
	123	static struct dca_domain dca_get_domain(struct device dev)
	124	{
	125	struct pci_bus *rc;
	126	struct dca_domain *domain;
	127
	128	rc = dca_pci_rc_from_dev(dev);
	129	domain = dca_find_domain(rc);
	130
	131	if (!domain) {
a1741e7f	132	if (dca_provider_ioat_ver_3_0(dev) && !list_empty(&dca_domains))
4e8cec26	133	dca_providers_blocked = 1;
1a5aeeec MS	134	}
	135
	136	return domain;
	137	}
	138
	139	static struct dca_provider dca_find_provider_by_dev(struct device dev)
	140	{
	141	struct dca_provider *dca;
	142	struct pci_bus *rc;
	143	struct dca_domain *domain;
	144
	145	if (dev) {
	146	rc = dca_pci_rc_from_dev(dev);
	147	domain = dca_find_domain(rc);
	148	if (!domain)
	149	return NULL;
	150	} else {
	151	if (!list_empty(&dca_domains))
	152	domain = list_first_entry(&dca_domains,
	153	struct dca_domain,
	154	node);
	155	else
	156	return NULL;
7f1b358a MS	157	}
7f1b358a MS	158
1a5aeeec MS	159	list_for_each_entry(dca, &domain->dca_providers, node)
	160	if ((!dev) \|\| (dca->ops->dev_managed(dca, dev)))
	161	return dca;
	162
	163	return NULL;
7f1b358a	164	}
7589670f SN	165
	166	/**
	167	* dca_add_requester - add a dca client to the list
	168	* @dev - the device that wants dca service
	169	*/
	170	int dca_add_requester(struct device *dev)
	171	{
7f1b358a MS	172	struct dca_provider *dca;
7f1b358a MS	173	int err, slot = -ENODEV;
eb4400e3	174	unsigned long flags;
1a5aeeec MS	175	struct pci_bus *pci_rc;
1a5aeeec MS	176	struct dca_domain *domain;
7589670f	177
7f1b358a MS	178	if (!dev)
7f1b358a MS	179	return -EFAULT;
7589670f	180
a1741e7f	181	raw_spin_lock_irqsave(&dca_lock, flags);
7f1b358a MS	182
	183	/* check if the requester has not been added already */
	184	dca = dca_find_provider_by_dev(dev);
	185	if (dca) {
a1741e7f	186	raw_spin_unlock_irqrestore(&dca_lock, flags);
7f1b358a MS	187	return -EEXIST;
	188	}
	189
1a5aeeec MS	190	pci_rc = dca_pci_rc_from_dev(dev);
	191	domain = dca_find_domain(pci_rc);
	192	if (!domain) {
a1741e7f	193	raw_spin_unlock_irqrestore(&dca_lock, flags);
1a5aeeec MS	194	return -ENODEV;
	195	}
	196
	197	list_for_each_entry(dca, &domain->dca_providers, node) {
7f1b358a MS	198	slot = dca->ops->add_requester(dca, dev);
	199	if (slot >= 0)
	200	break;
	201	}
eb4400e3	202
a1741e7f	203	raw_spin_unlock_irqrestore(&dca_lock, flags);
eb4400e3 MS	204
eb4400e3 MS	205	if (slot < 0)
7589670f SN	206	return slot;
7589670f SN	207
7f1b358a	208	err = dca_sysfs_add_req(dca, dev, slot);
7589670f	209	if (err) {
a1741e7f	210	raw_spin_lock_irqsave(&dca_lock, flags);
eb4400e3 MS	211	if (dca == dca_find_provider_by_dev(dev))
eb4400e3 MS	212	dca->ops->remove_requester(dca, dev);
a1741e7f	213	raw_spin_unlock_irqrestore(&dca_lock, flags);
7589670f SN	214	return err;
	215	}
	216
	217	return 0;
	218	}
	219	EXPORT_SYMBOL_GPL(dca_add_requester);
	220
	221	/**
	222	* dca_remove_requester - remove a dca client from the list
	223	* @dev - the device that wants dca service
	224	*/
	225	int dca_remove_requester(struct device *dev)
	226	{
7f1b358a	227	struct dca_provider *dca;
7589670f	228	int slot;
eb4400e3	229	unsigned long flags;
7f1b358a MS	230
	231	if (!dev)
	232	return -EFAULT;
7589670f	233
a1741e7f	234	raw_spin_lock_irqsave(&dca_lock, flags);
7f1b358a MS	235	dca = dca_find_provider_by_dev(dev);
7f1b358a MS	236	if (!dca) {
a1741e7f	237	raw_spin_unlock_irqrestore(&dca_lock, flags);
7f1b358a MS	238	return -ENODEV;
	239	}
	240	slot = dca->ops->remove_requester(dca, dev);
a1741e7f	241	raw_spin_unlock_irqrestore(&dca_lock, flags);
eb4400e3 MS	242
eb4400e3 MS	243	if (slot < 0)
7589670f SN	244	return slot;
7589670f SN	245
7f1b358a MS	246	dca_sysfs_remove_req(dca, slot);
7f1b358a MS	247
7589670f SN	248	return 0;
	249	}
	250	EXPORT_SYMBOL_GPL(dca_remove_requester);
	251
	252	/**
7f1b358a MS	253	* dca_common_get_tag - return the dca tag (serves both new and old api)
7f1b358a MS	254	* @dev - the device that wants dca service
7589670f SN	255	* @cpu - the cpuid as returned by get_cpu()
7589670f SN	256	*/
064223c1	257	static u8 dca_common_get_tag(struct device *dev, int cpu)
7589670f	258	{
7f1b358a MS	259	struct dca_provider *dca;
7f1b358a MS	260	u8 tag;
eb4400e3	261	unsigned long flags;
7f1b358a	262
a1741e7f	263	raw_spin_lock_irqsave(&dca_lock, flags);
7f1b358a MS	264
	265	dca = dca_find_provider_by_dev(dev);
	266	if (!dca) {
a1741e7f	267	raw_spin_unlock_irqrestore(&dca_lock, flags);
7589670f	268	return -ENODEV;
7f1b358a MS	269	}
	270	tag = dca->ops->get_tag(dca, dev, cpu);
	271
a1741e7f	272	raw_spin_unlock_irqrestore(&dca_lock, flags);
7f1b358a MS	273	return tag;
	274	}
	275
	276	/**
	277	* dca3_get_tag - return the dca tag to the requester device
	278	* for the given cpu (new api)
	279	* @dev - the device that wants dca service
	280	* @cpu - the cpuid as returned by get_cpu()
	281	*/
	282	u8 dca3_get_tag(struct device *dev, int cpu)
	283	{
	284	if (!dev)
	285	return -EFAULT;
	286
	287	return dca_common_get_tag(dev, cpu);
	288	}
	289	EXPORT_SYMBOL_GPL(dca3_get_tag);
	290
	291	/**
	292	* dca_get_tag - return the dca tag for the given cpu (old api)
	293	* @cpu - the cpuid as returned by get_cpu()
	294	*/
	295	u8 dca_get_tag(int cpu)
	296	{
	297	struct device *dev = NULL;
	298
	299	return dca_common_get_tag(dev, cpu);
7589670f SN	300	}
	301	EXPORT_SYMBOL_GPL(dca_get_tag);
	302
	303	/**
	304	* alloc_dca_provider - get data struct for describing a dca provider
	305	* @ops - pointer to struct of dca operation function pointers
	306	* @priv_size - size of extra mem to be added for provider's needs
	307	*/
2bb129eb JL	308	struct dca_provider alloc_dca_provider(const struct dca_ops ops,
2bb129eb JL	309	int priv_size)
7589670f SN	310	{
	311	struct dca_provider *dca;
	312	int alloc_size;
	313
	314	alloc_size = (sizeof(*dca) + priv_size);
	315	dca = kzalloc(alloc_size, GFP_KERNEL);
	316	if (!dca)
	317	return NULL;
	318	dca->ops = ops;
	319
	320	return dca;
	321	}
	322	EXPORT_SYMBOL_GPL(alloc_dca_provider);
	323
	324	/**
	325	* free_dca_provider - release the dca provider data struct
	326	* @ops - pointer to struct of dca operation function pointers
	327	* @priv_size - size of extra mem to be added for provider's needs
	328	*/
	329	void free_dca_provider(struct dca_provider *dca)
	330	{
	331	kfree(dca);
	332	}
	333	EXPORT_SYMBOL_GPL(free_dca_provider);
	334
7589670f SN	335	/**
	336	* register_dca_provider - register a dca provider
	337	* @dca - struct created by alloc_dca_provider()
	338	* @dev - device providing dca services
	339	*/
	340	int register_dca_provider(struct dca_provider dca, struct device dev)
	341	{
	342	int err;
eb4400e3	343	unsigned long flags;
a1741e7f	344	struct dca_domain domain, newdomain = NULL;
7589670f	345
a1741e7f	346	raw_spin_lock_irqsave(&dca_lock, flags);
4e8cec26	347	if (dca_providers_blocked) {
a1741e7f	348	raw_spin_unlock_irqrestore(&dca_lock, flags);
4e8cec26 SM	349	return -ENODEV;
4e8cec26 SM	350	}
a1741e7f	351	raw_spin_unlock_irqrestore(&dca_lock, flags);
4e8cec26	352
7589670f SN	353	err = dca_sysfs_add_provider(dca, dev);
	354	if (err)
	355	return err;
eb4400e3	356
a1741e7f	357	raw_spin_lock_irqsave(&dca_lock, flags);
1a5aeeec MS	358	domain = dca_get_domain(dev);
1a5aeeec MS	359	if (!domain) {
a1741e7f MG	360	struct pci_bus *rc;
a1741e7f MG	361
4e8cec26	362	if (dca_providers_blocked) {
a1741e7f	363	raw_spin_unlock_irqrestore(&dca_lock, flags);
4e8cec26 SM	364	dca_sysfs_remove_provider(dca);
4e8cec26 SM	365	unregister_dca_providers();
a1741e7f MG	366	return -ENODEV;
	367	}
	368
	369	raw_spin_unlock_irqrestore(&dca_lock, flags);
	370	rc = dca_pci_rc_from_dev(dev);
	371	newdomain = dca_allocate_domain(rc);
	372	if (!newdomain)
	373	return -ENODEV;
	374	raw_spin_lock_irqsave(&dca_lock, flags);
	375	/* Recheck, we might have raced after dropping the lock */
	376	domain = dca_get_domain(dev);
	377	if (!domain) {
	378	domain = newdomain;
	379	newdomain = NULL;
	380	list_add(&domain->node, &dca_domains);
4e8cec26	381	}
1a5aeeec MS	382	}
1a5aeeec MS	383	list_add(&dca->node, &domain->dca_providers);
a1741e7f	384	raw_spin_unlock_irqrestore(&dca_lock, flags);
eb4400e3	385
7589670f SN	386	blocking_notifier_call_chain(&dca_provider_chain,
7589670f SN	387	DCA_PROVIDER_ADD, NULL);
a1741e7f	388	kfree(newdomain);
7589670f SN	389	return 0;
	390	}
	391	EXPORT_SYMBOL_GPL(register_dca_provider);
	392
	393	/**
	394	* unregister_dca_provider - remove a dca provider
	395	* @dca - struct created by alloc_dca_provider()
	396	*/
1a5aeeec	397	void unregister_dca_provider(struct dca_provider dca, struct device dev)
7589670f	398	{
eb4400e3	399	unsigned long flags;
1a5aeeec MS	400	struct pci_bus *pci_rc;
1a5aeeec MS	401	struct dca_domain *domain;
eb4400e3	402
7589670f SN	403	blocking_notifier_call_chain(&dca_provider_chain,
7589670f SN	404	DCA_PROVIDER_REMOVE, NULL);
eb4400e3	405
a1741e7f	406	raw_spin_lock_irqsave(&dca_lock, flags);
1a5aeeec	407
c419fcfd MS	408	if (list_empty(&dca_domains)) {
	409	raw_spin_unlock_irqrestore(&dca_lock, flags);
	410	return;
	411	}
	412
7f1b358a	413	list_del(&dca->node);
1a5aeeec MS	414
	415	pci_rc = dca_pci_rc_from_dev(dev);
	416	domain = dca_find_domain(pci_rc);
	417	if (list_empty(&domain->dca_providers))
	418	dca_free_domain(domain);
	419
a1741e7f	420	raw_spin_unlock_irqrestore(&dca_lock, flags);
eb4400e3	421
7589670f SN	422	dca_sysfs_remove_provider(dca);
	423	}
	424	EXPORT_SYMBOL_GPL(unregister_dca_provider);
	425
	426	/**
	427	* dca_register_notify - register a client's notifier callback
	428	*/
	429	void dca_register_notify(struct notifier_block *nb)
	430	{
	431	blocking_notifier_chain_register(&dca_provider_chain, nb);
	432	}
	433	EXPORT_SYMBOL_GPL(dca_register_notify);
	434
	435	/**
	436	* dca_unregister_notify - remove a client's notifier callback
	437	*/
	438	void dca_unregister_notify(struct notifier_block *nb)
	439	{
	440	blocking_notifier_chain_unregister(&dca_provider_chain, nb);
	441	}
	442	EXPORT_SYMBOL_GPL(dca_unregister_notify);
	443
	444	static int __init dca_init(void)
	445	{
084dac53	446	pr_info("dca service started, version %s\n", DCA_VERSION);
7589670f SN	447	return dca_sysfs_init();
	448	}
	449
	450	static void __exit dca_exit(void)
	451	{
	452	dca_sysfs_exit();
	453	}
	454
652afc27	455	arch_initcall(dca_init);
7589670f SN	456	module_exit(dca_exit);
7589670f SN	457