[linux-2.6-block.git] / drivers / pci / slot.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2006 Matthew Wilcox <matthew@wil.cx>
 * Copyright (C) 2006-2009 Hewlett-Packard Development Company, L.P.
 *	Alex Chiang <achiang@hp.com>
 */

#include <linux/kobject.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/err.h>
#include "pci.h"

struct kset *pci_slots_kset;
EXPORT_SYMBOL_GPL(pci_slots_kset);

static ssize_t pci_slot_attr_show(struct kobject *kobj,
					struct attribute *attr, char *buf)
{
	struct pci_slot *slot = to_pci_slot(kobj);
	struct pci_slot_attribute *attribute = to_pci_slot_attr(attr);
	return attribute->show ? attribute->show(slot, buf) : -EIO;
}

static ssize_t pci_slot_attr_store(struct kobject *kobj,
			struct attribute *attr, const char *buf, size_t len)
{
	struct pci_slot *slot = to_pci_slot(kobj);
	struct pci_slot_attribute *attribute = to_pci_slot_attr(attr);
	return attribute->store ? attribute->store(slot, buf, len) : -EIO;
}

static const struct sysfs_ops pci_slot_sysfs_ops = {
	.show = pci_slot_attr_show,
	.store = pci_slot_attr_store,
};

static ssize_t address_read_file(struct pci_slot *slot, char *buf)
{
	if (slot->number == 0xff)
		return sprintf(buf, "%04x:%02x\n",
				pci_domain_nr(slot->bus),
				slot->bus->number);
	else
		return sprintf(buf, "%04x:%02x:%02x\n",
				pci_domain_nr(slot->bus),
				slot->bus->number,
				slot->number);
}

static ssize_t bus_speed_read(enum pci_bus_speed speed, char *buf)
{
	return sprintf(buf, "%s\n", pci_speed_string(speed));
}

static ssize_t max_speed_read_file(struct pci_slot *slot, char *buf)
{
	return bus_speed_read(slot->bus->max_bus_speed, buf);
}

static ssize_t cur_speed_read_file(struct pci_slot *slot, char *buf)
{
	return bus_speed_read(slot->bus->cur_bus_speed, buf);
}

static void pci_slot_release(struct kobject *kobj)
{
	struct pci_dev *dev;
	struct pci_slot *slot = to_pci_slot(kobj);

	dev_dbg(&slot->bus->dev, "dev %02x, released physical slot %s\n",
		slot->number, pci_slot_name(slot));

	down_read(&pci_bus_sem);
	list_for_each_entry(dev, &slot->bus->devices, bus_list)
		if (PCI_SLOT(dev->devfn) == slot->number)
			dev->slot = NULL;
	up_read(&pci_bus_sem);

	list_del(&slot->list);

	kfree(slot);
}

static struct pci_slot_attribute pci_slot_attr_address =
	__ATTR(address, S_IRUGO, address_read_file, NULL);
static struct pci_slot_attribute pci_slot_attr_max_speed =
	__ATTR(max_bus_speed, S_IRUGO, max_speed_read_file, NULL);
static struct pci_slot_attribute pci_slot_attr_cur_speed =
	__ATTR(cur_bus_speed, S_IRUGO, cur_speed_read_file, NULL);

static struct attribute *pci_slot_default_attrs[] = {
	&pci_slot_attr_address.attr,
	&pci_slot_attr_max_speed.attr,
	&pci_slot_attr_cur_speed.attr,
	NULL,
};

static struct kobj_type pci_slot_ktype = {
	.sysfs_ops = &pci_slot_sysfs_ops,
	.release = &pci_slot_release,
	.default_attrs = pci_slot_default_attrs,
};

static char *make_slot_name(const char *name)
{
	char *new_name;
	int len, max, dup;

	new_name = kstrdup(name, GFP_KERNEL);
	if (!new_name)
		return NULL;

	/*
	 * Make sure we hit the realloc case the first time through the
	 * loop.  'len' will be strlen(name) + 3 at that point which is
	 * enough space for "name-X" and the trailing NUL.
	 */
	len = strlen(name) + 2;
	max = 1;
	dup = 1;

	for (;;) {
		struct kobject *dup_slot;
		dup_slot = kset_find_obj(pci_slots_kset, new_name);
		if (!dup_slot)
			break;
		kobject_put(dup_slot);
		if (dup == max) {
			len++;
			max *= 10;
			kfree(new_name);
			new_name = kmalloc(len, GFP_KERNEL);
			if (!new_name)
				break;
		}
		sprintf(new_name, "%s-%d", name, dup++);
	}

	return new_name;
}

static int rename_slot(struct pci_slot *slot, const char *name)
{
	int result = 0;
	char *slot_name;

	if (strcmp(pci_slot_name(slot), name) == 0)
		return result;

	slot_name = make_slot_name(name);
	if (!slot_name)
		return -ENOMEM;

	result = kobject_rename(&slot->kobj, slot_name);
	kfree(slot_name);

	return result;
}

void pci_dev_assign_slot(struct pci_dev *dev)
{
	struct pci_slot *slot;

	mutex_lock(&pci_slot_mutex);
	list_for_each_entry(slot, &dev->bus->slots, list)
		if (PCI_SLOT(dev->devfn) == slot->number)
			dev->slot = slot;
	mutex_unlock(&pci_slot_mutex);
}

static struct pci_slot *get_slot(struct pci_bus *parent, int slot_nr)
{
	struct pci_slot *slot;

	/* We already hold pci_slot_mutex */
	list_for_each_entry(slot, &parent->slots, list)
		if (slot->number == slot_nr) {
			kobject_get(&slot->kobj);
			return slot;
		}

	return NULL;
}

/**
 * pci_create_slot - create or increment refcount for physical PCI slot
 * @parent: struct pci_bus of parent bridge
 * @slot_nr: PCI_SLOT(pci_dev->devfn) or -1 for placeholder
 * @name: user visible string presented in /sys/bus/pci/slots/<name>
 * @hotplug: set if caller is hotplug driver, NULL otherwise
 *
 * PCI slots have first class attributes such as address, speed, width,
 * and a &struct pci_slot is used to manage them. This interface will
 * either return a new &struct pci_slot to the caller, or if the pci_slot
 * already exists, its refcount will be incremented.
 *
 * Slots are uniquely identified by a @pci_bus, @slot_nr tuple.
 *
 * There are known platforms with broken firmware that assign the same
 * name to multiple slots. Workaround these broken platforms by renaming
 * the slots on behalf of the caller. If firmware assigns name N to
 * multiple slots:
 *
 * The first slot is assigned N
 * The second slot is assigned N-1
 * The third slot is assigned N-2
 * etc.
 *
 * Placeholder slots:
 * In most cases, @pci_bus, @slot_nr will be sufficient to uniquely identify
 * a slot. There is one notable exception - pSeries (rpaphp), where the
 * @slot_nr cannot be determined until a device is actually inserted into
 * the slot. In this scenario, the caller may pass -1 for @slot_nr.
 *
 * The following semantics are imposed when the caller passes @slot_nr ==
 * -1. First, we no longer check for an existing %struct pci_slot, as there
 * may be many slots with @slot_nr of -1.  The other change in semantics is
 * user-visible, which is the 'address' parameter presented in sysfs will
 * consist solely of a dddd:bb tuple, where dddd is the PCI domain of the
 * %struct pci_bus and bb is the bus number. In other words, the devfn of
 * the 'placeholder' slot will not be displayed.
 */
struct pci_slot *pci_create_slot(struct pci_bus *parent, int slot_nr,
				 const char *name,
				 struct hotplug_slot *hotplug)
{
	struct pci_dev *dev;
	struct pci_slot *slot;
	int err = 0;
	char *slot_name = NULL;

	mutex_lock(&pci_slot_mutex);

	if (slot_nr == -1)
		goto placeholder;

	/*
	 * Hotplug drivers are allowed to rename an existing slot,
	 * but only if not already claimed.
	 */
	slot = get_slot(parent, slot_nr);
	if (slot) {
		if (hotplug) {
			if ((err = slot->hotplug ? -EBUSY : 0)
			     || (err = rename_slot(slot, name))) {
				kobject_put(&slot->kobj);
				slot = NULL;
				goto err;
			}
		}
		goto out;
	}

placeholder:
	slot = kzalloc(sizeof(*slot), GFP_KERNEL);
	if (!slot) {
		err = -ENOMEM;
		goto err;
	}

	slot->bus = parent;
	slot->number = slot_nr;

	slot->kobj.kset = pci_slots_kset;

	slot_name = make_slot_name(name);
	if (!slot_name) {
		err = -ENOMEM;
		kfree(slot);
		goto err;
	}

	err = kobject_init_and_add(&slot->kobj, &pci_slot_ktype, NULL,
				   "%s", slot_name);
	if (err) {
		kobject_put(&slot->kobj);
		goto err;
	}

	INIT_LIST_HEAD(&slot->list);
	list_add(&slot->list, &parent->slots);

	down_read(&pci_bus_sem);
	list_for_each_entry(dev, &parent->devices, bus_list)
		if (PCI_SLOT(dev->devfn) == slot_nr)
			dev->slot = slot;
	up_read(&pci_bus_sem);

	dev_dbg(&parent->dev, "dev %02x, created physical slot %s\n",
		slot_nr, pci_slot_name(slot));

out:
	kfree(slot_name);
	mutex_unlock(&pci_slot_mutex);
	return slot;
err:
	slot = ERR_PTR(err);
	goto out;
}
EXPORT_SYMBOL_GPL(pci_create_slot);

/**
 * pci_destroy_slot - decrement refcount for physical PCI slot
 * @slot: struct pci_slot to decrement
 *
 * %struct pci_slot is refcounted, so destroying them is really easy; we
 * just call kobject_put on its kobj and let our release methods do the
 * rest.
 */
void pci_destroy_slot(struct pci_slot *slot)
{
	dev_dbg(&slot->bus->dev, "dev %02x, dec refcount to %d\n",
		slot->number, kref_read(&slot->kobj.kref) - 1);

	mutex_lock(&pci_slot_mutex);
	kobject_put(&slot->kobj);
	mutex_unlock(&pci_slot_mutex);
}
EXPORT_SYMBOL_GPL(pci_destroy_slot);

#if defined(CONFIG_HOTPLUG_PCI) || defined(CONFIG_HOTPLUG_PCI_MODULE)
#include <linux/pci_hotplug.h>
/**
 * pci_hp_create_link - create symbolic link to the hotplug driver module.
 * @pci_slot: struct pci_slot
 *
 * Helper function for pci_hotplug_core.c to create symbolic link to
 * the hotplug driver module.
 */
void pci_hp_create_module_link(struct pci_slot *pci_slot)
{
	struct hotplug_slot *slot = pci_slot->hotplug;
	struct kobject *kobj = NULL;
	int ret;

	if (!slot || !slot->ops)
		return;
	kobj = kset_find_obj(module_kset, slot->mod_name);
	if (!kobj)
		return;
	ret = sysfs_create_link(&pci_slot->kobj, kobj, "module");
	if (ret)
		dev_err(&pci_slot->bus->dev, "Error creating sysfs link (%d)\n",
			ret);
	kobject_put(kobj);
}
EXPORT_SYMBOL_GPL(pci_hp_create_module_link);

/**
 * pci_hp_remove_link - remove symbolic link to the hotplug driver module.
 * @pci_slot: struct pci_slot
 *
 * Helper function for pci_hotplug_core.c to remove symbolic link to
 * the hotplug driver module.
 */
void pci_hp_remove_module_link(struct pci_slot *pci_slot)
{
	sysfs_remove_link(&pci_slot->kobj, "module");
}
EXPORT_SYMBOL_GPL(pci_hp_remove_module_link);
#endif

static int pci_slot_init(void)
{
	struct kset *pci_bus_kset;

	pci_bus_kset = bus_get_kset(&pci_bus_type);
	pci_slots_kset = kset_create_and_add("slots", NULL,
						&pci_bus_kset->kobj);
	if (!pci_slots_kset) {
		pr_err("PCI: Slot initialization failure\n");
		return -ENOMEM;
	}
	return 0;
}

subsys_initcall(pci_slot_init);
Commit	Line	Data
7328c8f4	1	// SPDX-License-Identifier: GPL-2.0
f46753c5	2	/*
f46753c5	3	* Copyright (C) 2006 Matthew Wilcox <matthew@wil.cx>
62795041 AC	4	* Copyright (C) 2006-2009 Hewlett-Packard Development Company, L.P.
62795041 AC	5	* Alex Chiang <achiang@hp.com>
f46753c5 AC	6	*/
	7
	8	#include <linux/kobject.h>
5a0e3ad6	9	#include <linux/slab.h>
eefa9cfc	10	#include <linux/module.h>
f46753c5 AC	11	#include <linux/pci.h>
	12	#include <linux/err.h>
	13	#include "pci.h"
	14
	15	struct kset *pci_slots_kset;
	16	EXPORT_SYMBOL_GPL(pci_slots_kset);
	17
	18	static ssize_t pci_slot_attr_show(struct kobject *kobj,
	19	struct attribute attr, char buf)
	20	{
	21	struct pci_slot *slot = to_pci_slot(kobj);
	22	struct pci_slot_attribute *attribute = to_pci_slot_attr(attr);
	23	return attribute->show ? attribute->show(slot, buf) : -EIO;
	24	}
	25
	26	static ssize_t pci_slot_attr_store(struct kobject *kobj,
	27	struct attribute attr, const char buf, size_t len)
	28	{
	29	struct pci_slot *slot = to_pci_slot(kobj);
	30	struct pci_slot_attribute *attribute = to_pci_slot_attr(attr);
	31	return attribute->store ? attribute->store(slot, buf, len) : -EIO;
	32	}
	33
52cf25d0	34	static const struct sysfs_ops pci_slot_sysfs_ops = {
f46753c5 AC	35	.show = pci_slot_attr_show,
	36	.store = pci_slot_attr_store,
	37	};
	38
	39	static ssize_t address_read_file(struct pci_slot slot, char buf)
	40	{
	41	if (slot->number == 0xff)
	42	return sprintf(buf, "%04x:%02x\n",
	43	pci_domain_nr(slot->bus),
	44	slot->bus->number);
	45	else
	46	return sprintf(buf, "%04x:%02x:%02x\n",
	47	pci_domain_nr(slot->bus),
	48	slot->bus->number,
	49	slot->number);
	50	}
	51
3749c51a MW	52	static ssize_t bus_speed_read(enum pci_bus_speed speed, char *buf)
3749c51a MW	53	{
e56faff5	54	return sprintf(buf, "%s\n", pci_speed_string(speed));
3749c51a MW	55	}
	56
	57	static ssize_t max_speed_read_file(struct pci_slot slot, char buf)
	58	{
	59	return bus_speed_read(slot->bus->max_bus_speed, buf);
	60	}
	61
	62	static ssize_t cur_speed_read_file(struct pci_slot slot, char buf)
	63	{
	64	return bus_speed_read(slot->bus->cur_bus_speed, buf);
	65	}
	66
f46753c5 AC	67	static void pci_slot_release(struct kobject *kobj)
f46753c5 AC	68	{
cef354db	69	struct pci_dev *dev;
f46753c5 AC	70	struct pci_slot *slot = to_pci_slot(kobj);
f46753c5 AC	71
62795041 AC	72	dev_dbg(&slot->bus->dev, "dev %02x, released physical slot %s\n",
62795041 AC	73	slot->number, pci_slot_name(slot));
f46753c5	74
67546762	75	down_read(&pci_bus_sem);
cef354db AC	76	list_for_each_entry(dev, &slot->bus->devices, bus_list)
	77	if (PCI_SLOT(dev->devfn) == slot->number)
	78	dev->slot = NULL;
67546762	79	up_read(&pci_bus_sem);
cef354db	80
f46753c5 AC	81	list_del(&slot->list);
	82
	83	kfree(slot);
	84	}
	85
	86	static struct pci_slot_attribute pci_slot_attr_address =
58f86cc8	87	__ATTR(address, S_IRUGO, address_read_file, NULL);
3749c51a	88	static struct pci_slot_attribute pci_slot_attr_max_speed =
58f86cc8	89	__ATTR(max_bus_speed, S_IRUGO, max_speed_read_file, NULL);
3749c51a	90	static struct pci_slot_attribute pci_slot_attr_cur_speed =
58f86cc8	91	__ATTR(cur_bus_speed, S_IRUGO, cur_speed_read_file, NULL);
f46753c5 AC	92
	93	static struct attribute *pci_slot_default_attrs[] = {
	94	&pci_slot_attr_address.attr,
3749c51a MW	95	&pci_slot_attr_max_speed.attr,
3749c51a MW	96	&pci_slot_attr_cur_speed.attr,
f46753c5 AC	97	NULL,
	98	};
	99
	100	static struct kobj_type pci_slot_ktype = {
	101	.sysfs_ops = &pci_slot_sysfs_ops,
	102	.release = &pci_slot_release,
	103	.default_attrs = pci_slot_default_attrs,
	104	};
	105
5fe6cc60 AC	106	static char make_slot_name(const char name)
	107	{
	108	char *new_name;
	109	int len, max, dup;
	110
	111	new_name = kstrdup(name, GFP_KERNEL);
	112	if (!new_name)
	113	return NULL;
	114
	115	/*
	116	* Make sure we hit the realloc case the first time through the
	117	* loop. 'len' will be strlen(name) + 3 at that point which is
	118	* enough space for "name-X" and the trailing NUL.
	119	*/
	120	len = strlen(name) + 2;
	121	max = 1;
	122	dup = 1;
	123
	124	for (;;) {
	125	struct kobject *dup_slot;
	126	dup_slot = kset_find_obj(pci_slots_kset, new_name);
	127	if (!dup_slot)
	128	break;
	129	kobject_put(dup_slot);
	130	if (dup == max) {
	131	len++;
	132	max *= 10;
	133	kfree(new_name);
	134	new_name = kmalloc(len, GFP_KERNEL);
	135	if (!new_name)
	136	break;
	137	}
	138	sprintf(new_name, "%s-%d", name, dup++);
	139	}
	140
	141	return new_name;
	142	}
	143
	144	static int rename_slot(struct pci_slot slot, const char name)
	145	{
	146	int result = 0;
	147	char *slot_name;
	148
0ad772ec	149	if (strcmp(pci_slot_name(slot), name) == 0)
5fe6cc60 AC	150	return result;
	151
	152	slot_name = make_slot_name(name);
	153	if (!slot_name)
	154	return -ENOMEM;
	155
	156	result = kobject_rename(&slot->kobj, slot_name);
	157	kfree(slot_name);
	158
	159	return result;
	160	}
	161
017ffe64 YW	162	void pci_dev_assign_slot(struct pci_dev *dev)
	163	{
	164	struct pci_slot *slot;
	165
	166	mutex_lock(&pci_slot_mutex);
	167	list_for_each_entry(slot, &dev->bus->slots, list)
	168	if (PCI_SLOT(dev->devfn) == slot->number)
	169	dev->slot = slot;
	170	mutex_unlock(&pci_slot_mutex);
	171	}
	172
5fe6cc60 AC	173	static struct pci_slot get_slot(struct pci_bus parent, int slot_nr)
	174	{
	175	struct pci_slot *slot;
67546762 YW	176
67546762 YW	177	/* We already hold pci_slot_mutex */
5fe6cc60 AC	178	list_for_each_entry(slot, &parent->slots, list)
	179	if (slot->number == slot_nr) {
	180	kobject_get(&slot->kobj);
	181	return slot;
	182	}
	183
	184	return NULL;
	185	}
	186
f46753c5 AC	187	/**
	188	* pci_create_slot - create or increment refcount for physical PCI slot
	189	* @parent: struct pci_bus of parent bridge
	190	* @slot_nr: PCI_SLOT(pci_dev->devfn) or -1 for placeholder
	191	* @name: user visible string presented in /sys/bus/pci/slots/<name>
828f3768	192	* @hotplug: set if caller is hotplug driver, NULL otherwise
f46753c5 AC	193	*
	194	* PCI slots have first class attributes such as address, speed, width,
	195	* and a &struct pci_slot is used to manage them. This interface will
	196	* either return a new &struct pci_slot to the caller, or if the pci_slot
	197	* already exists, its refcount will be incremented.
	198	*
5fe6cc60 AC	199	* Slots are uniquely identified by a @pci_bus, @slot_nr tuple.
	200	*
	201	* There are known platforms with broken firmware that assign the same
	202	* name to multiple slots. Workaround these broken platforms by renaming
	203	* the slots on behalf of the caller. If firmware assigns name N to
	204	* multiple slots:
	205	*
	206	* The first slot is assigned N
	207	* The second slot is assigned N-1
	208	* The third slot is assigned N-2
	209	* etc.
f46753c5 AC	210	*
	211	* Placeholder slots:
	212	* In most cases, @pci_bus, @slot_nr will be sufficient to uniquely identify
	213	* a slot. There is one notable exception - pSeries (rpaphp), where the
	214	* @slot_nr cannot be determined until a device is actually inserted into
	215	* the slot. In this scenario, the caller may pass -1 for @slot_nr.
	216	*
	217	* The following semantics are imposed when the caller passes @slot_nr ==
5fe6cc60 AC	218	* -1. First, we no longer check for an existing %struct pci_slot, as there
5fe6cc60 AC	219	* may be many slots with @slot_nr of -1. The other change in semantics is
f46753c5 AC	220	* user-visible, which is the 'address' parameter presented in sysfs will
	221	* consist solely of a dddd:bb tuple, where dddd is the PCI domain of the
	222	* %struct pci_bus and bb is the bus number. In other words, the devfn of
	223	* the 'placeholder' slot will not be displayed.
	224	*/
f46753c5	225	struct pci_slot pci_create_slot(struct pci_bus parent, int slot_nr,
828f3768 AC	226	const char *name,
828f3768 AC	227	struct hotplug_slot *hotplug)
f46753c5	228	{
cef354db	229	struct pci_dev *dev;
f46753c5	230	struct pci_slot *slot;
5fe6cc60 AC	231	int err = 0;
5fe6cc60 AC	232	char *slot_name = NULL;
f46753c5	233
67546762	234	mutex_lock(&pci_slot_mutex);
f46753c5 AC	235
	236	if (slot_nr == -1)
	237	goto placeholder;
	238
5fe6cc60 AC	239	/*
	240	* Hotplug drivers are allowed to rename an existing slot,
	241	* but only if not already claimed.
	242	*/
	243	slot = get_slot(parent, slot_nr);
	244	if (slot) {
	245	if (hotplug) {
	246	if ((err = slot->hotplug ? -EBUSY : 0)
	247	\|\| (err = rename_slot(slot, name))) {
	248	kobject_put(&slot->kobj);
	249	slot = NULL;
	250	goto err;
	251	}
f46753c5	252	}
5fe6cc60	253	goto out;
f46753c5 AC	254	}
	255
	256	placeholder:
	257	slot = kzalloc(sizeof(*slot), GFP_KERNEL);
	258	if (!slot) {
5fe6cc60 AC	259	err = -ENOMEM;
5fe6cc60 AC	260	goto err;
f46753c5 AC	261	}
	262
	263	slot->bus = parent;
	264	slot->number = slot_nr;
	265
	266	slot->kobj.kset = pci_slots_kset;
5fe6cc60 AC	267
	268	slot_name = make_slot_name(name);
	269	if (!slot_name) {
	270	err = -ENOMEM;
8a94644b	271	kfree(slot);
f46753c5 AC	272	goto err;
	273	}
	274
5fe6cc60 AC	275	err = kobject_init_and_add(&slot->kobj, &pci_slot_ktype, NULL,
5fe6cc60 AC	276	"%s", slot_name);
8a94644b QW	277	if (err) {
8a94644b QW	278	kobject_put(&slot->kobj);
5fe6cc60	279	goto err;
8a94644b	280	}
5fe6cc60	281
f46753c5 AC	282	INIT_LIST_HEAD(&slot->list);
	283	list_add(&slot->list, &parent->slots);
	284
67546762	285	down_read(&pci_bus_sem);
cef354db AC	286	list_for_each_entry(dev, &parent->devices, bus_list)
	287	if (PCI_SLOT(dev->devfn) == slot_nr)
	288	dev->slot = slot;
67546762	289	up_read(&pci_bus_sem);
cef354db	290
62795041 AC	291	dev_dbg(&parent->dev, "dev %02x, created physical slot %s\n",
62795041 AC	292	slot_nr, pci_slot_name(slot));
f46753c5	293
5fe6cc60	294	out:
3b5dd45e	295	kfree(slot_name);
67546762	296	mutex_unlock(&pci_slot_mutex);
f46753c5	297	return slot;
5fe6cc60	298	err:
f46753c5 AC	299	slot = ERR_PTR(err);
	300	goto out;
	301	}
	302	EXPORT_SYMBOL_GPL(pci_create_slot);
	303
f46753c5 AC	304	/**
	305	* pci_destroy_slot - decrement refcount for physical PCI slot
	306	* @slot: struct pci_slot to decrement
	307	*
	308	* %struct pci_slot is refcounted, so destroying them is really easy; we
	309	* just call kobject_put on its kobj and let our release methods do the
	310	* rest.
	311	*/
f46753c5 AC	312	void pci_destroy_slot(struct pci_slot *slot)
f46753c5 AC	313	{
62795041	314	dev_dbg(&slot->bus->dev, "dev %02x, dec refcount to %d\n",
2c935bc5	315	slot->number, kref_read(&slot->kobj.kref) - 1);
f46753c5	316
67546762	317	mutex_lock(&pci_slot_mutex);
f46753c5	318	kobject_put(&slot->kobj);
67546762	319	mutex_unlock(&pci_slot_mutex);
f46753c5 AC	320	}
	321	EXPORT_SYMBOL_GPL(pci_destroy_slot);
	322
c825bc94 KK	323	#if defined(CONFIG_HOTPLUG_PCI) \|\| defined(CONFIG_HOTPLUG_PCI_MODULE)
	324	#include <linux/pci_hotplug.h>
	325	/**
	326	* pci_hp_create_link - create symbolic link to the hotplug driver module.
503998ca	327	* @pci_slot: struct pci_slot
c825bc94 KK	328	*
	329	* Helper function for pci_hotplug_core.c to create symbolic link to
	330	* the hotplug driver module.
	331	*/
	332	void pci_hp_create_module_link(struct pci_slot *pci_slot)
	333	{
	334	struct hotplug_slot *slot = pci_slot->hotplug;
	335	struct kobject *kobj = NULL;
9fc9eea0	336	int ret;
c825bc94 KK	337
	338	if (!slot \|\| !slot->ops)
	339	return;
81c4b5bf	340	kobj = kset_find_obj(module_kset, slot->mod_name);
c825bc94 KK	341	if (!kobj)
c825bc94 KK	342	return;
9fc9eea0 BH	343	ret = sysfs_create_link(&pci_slot->kobj, kobj, "module");
	344	if (ret)
	345	dev_err(&pci_slot->bus->dev, "Error creating sysfs link (%d)\n",
	346	ret);
c825bc94 KK	347	kobject_put(kobj);
	348	}
	349	EXPORT_SYMBOL_GPL(pci_hp_create_module_link);
	350
	351	/**
	352	* pci_hp_remove_link - remove symbolic link to the hotplug driver module.
503998ca	353	* @pci_slot: struct pci_slot
c825bc94 KK	354	*
	355	* Helper function for pci_hotplug_core.c to remove symbolic link to
	356	* the hotplug driver module.
	357	*/
	358	void pci_hp_remove_module_link(struct pci_slot *pci_slot)
	359	{
	360	sysfs_remove_link(&pci_slot->kobj, "module");
	361	}
	362	EXPORT_SYMBOL_GPL(pci_hp_remove_module_link);
	363	#endif
	364
f46753c5 AC	365	static int pci_slot_init(void)
	366	{
	367	struct kset *pci_bus_kset;
	368
	369	pci_bus_kset = bus_get_kset(&pci_bus_type);
	370	pci_slots_kset = kset_create_and_add("slots", NULL,
	371	&pci_bus_kset->kobj);
	372	if (!pci_slots_kset) {
25da8dba	373	pr_err("PCI: Slot initialization failure\n");
f46753c5 AC	374	return -ENOMEM;
	375	}
	376	return 0;
	377	}
	378
	379	subsys_initcall(pci_slot_init);