slot.c 10.5 KB
Newer Older
Alex Chiang's avatar
Alex Chiang committed
1 2 3
/*
 * drivers/pci/slot.c
 * Copyright (C) 2006 Matthew Wilcox <matthew@wil.cx>
4 5
 * Copyright (C) 2006-2009 Hewlett-Packard Development Company, L.P.
 *	Alex Chiang <achiang@hp.com>
Alex Chiang's avatar
Alex Chiang committed
6 7 8
 */

#include <linux/kobject.h>
9
#include <linux/slab.h>
10
#include <linux/module.h>
Alex Chiang's avatar
Alex Chiang committed
11 12 13 14 15 16
#include <linux/pci.h>
#include <linux/err.h>
#include "pci.h"

struct kset *pci_slots_kset;
EXPORT_SYMBOL_GPL(pci_slots_kset);
17
static DEFINE_MUTEX(pci_slot_mutex);
Alex Chiang's avatar
Alex Chiang committed
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

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

35
static const struct sysfs_ops pci_slot_sysfs_ops = {
Alex Chiang's avatar
Alex Chiang committed
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
	.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);
}

53
/* these strings match up with the values in pci_bus_speed */
54
static const char *pci_bus_speed_strings[] = {
55 56
	"33 MHz PCI",		/* 0x00 */
	"66 MHz PCI",		/* 0x01 */
57
	"66 MHz PCI-X",		/* 0x02 */
58 59 60 61 62 63 64 65 66
	"100 MHz PCI-X",	/* 0x03 */
	"133 MHz PCI-X",	/* 0x04 */
	NULL,			/* 0x05 */
	NULL,			/* 0x06 */
	NULL,			/* 0x07 */
	NULL,			/* 0x08 */
	"66 MHz PCI-X 266",	/* 0x09 */
	"100 MHz PCI-X 266",	/* 0x0a */
	"133 MHz PCI-X 266",	/* 0x0b */
67 68 69 70 71
	"Unknown AGP",		/* 0x0c */
	"1x AGP",		/* 0x0d */
	"2x AGP",		/* 0x0e */
	"4x AGP",		/* 0x0f */
	"8x AGP",		/* 0x10 */
72 73 74 75 76
	"66 MHz PCI-X 533",	/* 0x11 */
	"100 MHz PCI-X 533",	/* 0x12 */
	"133 MHz PCI-X 533",	/* 0x13 */
	"2.5 GT/s PCIe",	/* 0x14 */
	"5.0 GT/s PCIe",	/* 0x15 */
77
	"8.0 GT/s PCIe",	/* 0x16 */
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
};

static ssize_t bus_speed_read(enum pci_bus_speed speed, char *buf)
{
	const char *speed_string;

	if (speed < ARRAY_SIZE(pci_bus_speed_strings))
		speed_string = pci_bus_speed_strings[speed];
	else
		speed_string = "Unknown";

	return sprintf(buf, "%s\n", speed_string);
}

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

Alex Chiang's avatar
Alex Chiang committed
102 103
static void pci_slot_release(struct kobject *kobj)
{
104
	struct pci_dev *dev;
Alex Chiang's avatar
Alex Chiang committed
105 106
	struct pci_slot *slot = to_pci_slot(kobj);

107 108
	dev_dbg(&slot->bus->dev, "dev %02x, released physical slot %s\n",
		slot->number, pci_slot_name(slot));
Alex Chiang's avatar
Alex Chiang committed
109

110
	down_read(&pci_bus_sem);
111 112 113
	list_for_each_entry(dev, &slot->bus->devices, bus_list)
		if (PCI_SLOT(dev->devfn) == slot->number)
			dev->slot = NULL;
114
	up_read(&pci_bus_sem);
115

Alex Chiang's avatar
Alex Chiang committed
116 117 118 119 120 121
	list_del(&slot->list);

	kfree(slot);
}

static struct pci_slot_attribute pci_slot_attr_address =
122
	__ATTR(address, S_IRUGO, address_read_file, NULL);
123
static struct pci_slot_attribute pci_slot_attr_max_speed =
124
	__ATTR(max_bus_speed, S_IRUGO, max_speed_read_file, NULL);
125
static struct pci_slot_attribute pci_slot_attr_cur_speed =
126
	__ATTR(cur_bus_speed, S_IRUGO, cur_speed_read_file, NULL);
Alex Chiang's avatar
Alex Chiang committed
127 128 129

static struct attribute *pci_slot_default_attrs[] = {
	&pci_slot_attr_address.attr,
130 131
	&pci_slot_attr_max_speed.attr,
	&pci_slot_attr_cur_speed.attr,
Alex Chiang's avatar
Alex Chiang committed
132 133 134 135 136 137 138 139 140
	NULL,
};

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

141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
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;

184
	if (strcmp(pci_slot_name(slot), name) == 0)
185 186 187 188 189 190 191 192 193 194 195 196
		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;
}

197 198 199 200 201 202 203 204 205 206 207
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);
}

208 209 210
static struct pci_slot *get_slot(struct pci_bus *parent, int slot_nr)
{
	struct pci_slot *slot;
211 212

	/* We already hold pci_slot_mutex */
213 214 215 216 217 218 219 220 221
	list_for_each_entry(slot, &parent->slots, list)
		if (slot->number == slot_nr) {
			kobject_get(&slot->kobj);
			return slot;
		}

	return NULL;
}

Alex Chiang's avatar
Alex Chiang committed
222 223 224 225 226
/**
 * 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>
227
 * @hotplug: set if caller is hotplug driver, NULL otherwise
Alex Chiang's avatar
Alex Chiang committed
228 229 230 231 232 233
 *
 * 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.
 *
234 235 236 237 238 239 240 241 242 243 244
 * 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.
Alex Chiang's avatar
Alex Chiang committed
245 246 247 248 249 250 251 252
 *
 * 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 ==
253 254
 * -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
Alex Chiang's avatar
Alex Chiang committed
255 256 257 258 259 260
 * 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,
261 262
				 const char *name,
				 struct hotplug_slot *hotplug)
Alex Chiang's avatar
Alex Chiang committed
263
{
264
	struct pci_dev *dev;
Alex Chiang's avatar
Alex Chiang committed
265
	struct pci_slot *slot;
266 267
	int err = 0;
	char *slot_name = NULL;
Alex Chiang's avatar
Alex Chiang committed
268

269
	mutex_lock(&pci_slot_mutex);
Alex Chiang's avatar
Alex Chiang committed
270 271 272 273

	if (slot_nr == -1)
		goto placeholder;

274 275 276 277 278 279 280 281 282 283 284 285 286
	/*
	 * 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;
			}
Alex Chiang's avatar
Alex Chiang committed
287
		}
288
		goto out;
Alex Chiang's avatar
Alex Chiang committed
289 290 291 292 293
	}

placeholder:
	slot = kzalloc(sizeof(*slot), GFP_KERNEL);
	if (!slot) {
294 295
		err = -ENOMEM;
		goto err;
Alex Chiang's avatar
Alex Chiang committed
296 297 298 299 300 301
	}

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

	slot->kobj.kset = pci_slots_kset;
302 303 304 305

	slot_name = make_slot_name(name);
	if (!slot_name) {
		err = -ENOMEM;
Alex Chiang's avatar
Alex Chiang committed
306 307 308
		goto err;
	}

309 310 311 312 313
	err = kobject_init_and_add(&slot->kobj, &pci_slot_ktype, NULL,
				   "%s", slot_name);
	if (err)
		goto err;

Alex Chiang's avatar
Alex Chiang committed
314 315 316
	INIT_LIST_HEAD(&slot->list);
	list_add(&slot->list, &parent->slots);

317
	down_read(&pci_bus_sem);
318 319 320
	list_for_each_entry(dev, &parent->devices, bus_list)
		if (PCI_SLOT(dev->devfn) == slot_nr)
			dev->slot = slot;
321
	up_read(&pci_bus_sem);
322

323 324
	dev_dbg(&parent->dev, "dev %02x, created physical slot %s\n",
		slot_nr, pci_slot_name(slot));
Alex Chiang's avatar
Alex Chiang committed
325

326
out:
327
	kfree(slot_name);
328
	mutex_unlock(&pci_slot_mutex);
Alex Chiang's avatar
Alex Chiang committed
329
	return slot;
330
err:
Alex Chiang's avatar
Alex Chiang committed
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
	kfree(slot);
	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)
{
347
	dev_dbg(&slot->bus->dev, "dev %02x, dec refcount to %d\n",
348
		slot->number, kref_read(&slot->kobj.kref) - 1);
Alex Chiang's avatar
Alex Chiang committed
349

350
	mutex_lock(&pci_slot_mutex);
Alex Chiang's avatar
Alex Chiang committed
351
	kobject_put(&slot->kobj);
352
	mutex_unlock(&pci_slot_mutex);
Alex Chiang's avatar
Alex Chiang committed
353 354 355
}
EXPORT_SYMBOL_GPL(pci_destroy_slot);

356 357 358 359
#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.
360
 * @pci_slot: struct pci_slot
361 362 363 364 365 366 367 368
 *
 * 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;
369
	int ret;
370 371 372 373 374 375

	if (!slot || !slot->ops)
		return;
	kobj = kset_find_obj(module_kset, slot->ops->mod_name);
	if (!kobj)
		return;
376 377 378 379
	ret = sysfs_create_link(&pci_slot->kobj, kobj, "module");
	if (ret)
		dev_err(&pci_slot->bus->dev, "Error creating sysfs link (%d)\n",
			ret);
380 381 382 383 384 385
	kobject_put(kobj);
}
EXPORT_SYMBOL_GPL(pci_hp_create_module_link);

/**
 * pci_hp_remove_link - remove symbolic link to the hotplug driver module.
386
 * @pci_slot: struct pci_slot
387 388 389 390 391 392 393 394 395 396 397
 *
 * 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

Alex Chiang's avatar
Alex Chiang committed
398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
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) {
		printk(KERN_ERR "PCI: Slot initialization failure\n");
		return -ENOMEM;
	}
	return 0;
}

subsys_initcall(pci_slot_init);