pci-sysfs.c 38.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12
/*
 * drivers/pci/pci-sysfs.c
 *
 * (C) Copyright 2002-2004 Greg Kroah-Hartman <greg@kroah.com>
 * (C) Copyright 2002-2004 IBM Corp.
 * (C) Copyright 2003 Matthew Wilcox
 * (C) Copyright 2003 Hewlett-Packard
 * (C) Copyright 2004 Jon Smirl <jonsmirl@yahoo.com>
 * (C) Copyright 2004 Silicon Graphics, Inc. Jesse Barnes <jbarnes@sgi.com>
 *
 * File attributes for PCI devices
 *
13
 * Modeled after usb's driverfs.c
L
Linus Torvalds 已提交
14 15 16 17 18
 *
 */


#include <linux/kernel.h>
19
#include <linux/sched.h>
L
Linus Torvalds 已提交
20 21
#include <linux/pci.h>
#include <linux/stat.h>
22
#include <linux/export.h>
L
Linus Torvalds 已提交
23 24
#include <linux/topology.h>
#include <linux/mm.h>
25
#include <linux/fs.h>
A
Alexey Dobriyan 已提交
26
#include <linux/capability.h>
27
#include <linux/security.h>
S
Shaohua Li 已提交
28
#include <linux/pci-aspm.h>
29
#include <linux/slab.h>
30
#include <linux/vgaarb.h>
31
#include <linux/pm_runtime.h>
32
#include <linux/of.h>
L
Linus Torvalds 已提交
33 34 35 36 37 38 39
#include "pci.h"

static int sysfs_initialized;	/* = 0 */

/* show configuration fields */
#define pci_config_attr(field, format_string)				\
static ssize_t								\
40
field##_show(struct device *dev, struct device_attribute *attr, char *buf)				\
L
Linus Torvalds 已提交
41 42 43
{									\
	struct pci_dev *pdev;						\
									\
R
Ryan Desfosses 已提交
44 45
	pdev = to_pci_dev(dev);						\
	return sprintf(buf, format_string, pdev->field);		\
46 47
}									\
static DEVICE_ATTR_RO(field)
L
Linus Torvalds 已提交
48 49 50 51 52 53 54 55

pci_config_attr(vendor, "0x%04x\n");
pci_config_attr(device, "0x%04x\n");
pci_config_attr(subsystem_vendor, "0x%04x\n");
pci_config_attr(subsystem_device, "0x%04x\n");
pci_config_attr(class, "0x%06x\n");
pci_config_attr(irq, "%u\n");

56 57 58 59 60
static ssize_t broken_parity_status_show(struct device *dev,
					 struct device_attribute *attr,
					 char *buf)
{
	struct pci_dev *pdev = to_pci_dev(dev);
R
Ryan Desfosses 已提交
61
	return sprintf(buf, "%u\n", pdev->broken_parity_status);
62 63 64 65 66 67 68
}

static ssize_t broken_parity_status_store(struct device *dev,
					  struct device_attribute *attr,
					  const char *buf, size_t count)
{
	struct pci_dev *pdev = to_pci_dev(dev);
69
	unsigned long val;
70

71
	if (kstrtoul(buf, 0, &val) < 0)
72 73 74 75 76
		return -EINVAL;

	pdev->broken_parity_status = !!val;

	return count;
77
}
78
static DEVICE_ATTR_RW(broken_parity_status);
79

R
Ryan Desfosses 已提交
80 81
static ssize_t pci_dev_show_local_cpu(struct device *dev, int type,
				      struct device_attribute *attr, char *buf)
82
{
83
	const struct cpumask *mask;
84 85
	int len;

86
#ifdef CONFIG_NUMA
87 88
	mask = (dev_to_node(dev) == -1) ? cpu_online_mask :
					  cpumask_of_node(dev_to_node(dev));
89
#else
90
	mask = cpumask_of_pcibus(to_pci_dev(dev)->bus);
91
#endif
92 93 94 95
	len = type ?
		cpumask_scnprintf(buf, PAGE_SIZE-2, mask) :
		cpulist_scnprintf(buf, PAGE_SIZE-2, mask);

96 97 98 99 100
	buf[len++] = '\n';
	buf[len] = '\0';
	return len;
}

101
static ssize_t local_cpus_show(struct device *dev,
R
Ryan Desfosses 已提交
102
			       struct device_attribute *attr, char *buf)
103 104 105
{
	return pci_dev_show_local_cpu(dev, 1, attr, buf);
}
106
static DEVICE_ATTR_RO(local_cpus);
107 108

static ssize_t local_cpulist_show(struct device *dev,
R
Ryan Desfosses 已提交
109
				  struct device_attribute *attr, char *buf)
110
{
111
	return pci_dev_show_local_cpu(dev, 0, attr, buf);
L
Linus Torvalds 已提交
112
}
113
static DEVICE_ATTR_RO(local_cpulist);
L
Linus Torvalds 已提交
114

115 116 117
/*
 * PCI Bus Class Devices
 */
R
Ryan Desfosses 已提交
118
static ssize_t pci_bus_show_cpuaffinity(struct device *dev, int type,
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
					struct device_attribute *attr,
					char *buf)
{
	int ret;
	const struct cpumask *cpumask;

	cpumask = cpumask_of_pcibus(to_pci_bus(dev));
	ret = type ?
		cpulist_scnprintf(buf, PAGE_SIZE-2, cpumask) :
		cpumask_scnprintf(buf, PAGE_SIZE-2, cpumask);
	buf[ret++] = '\n';
	buf[ret] = '\0';
	return ret;
}

134 135
static ssize_t cpuaffinity_show(struct device *dev,
				struct device_attribute *attr, char *buf)
136 137 138
{
	return pci_bus_show_cpuaffinity(dev, 0, attr, buf);
}
139
static DEVICE_ATTR_RO(cpuaffinity);
140

141 142
static ssize_t cpulistaffinity_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
143 144 145
{
	return pci_bus_show_cpuaffinity(dev, 1, attr, buf);
}
146
static DEVICE_ATTR_RO(cpulistaffinity);
147

L
Linus Torvalds 已提交
148
/* show resources */
R
Ryan Desfosses 已提交
149 150
static ssize_t resource_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
L
Linus Torvalds 已提交
151
{
R
Ryan Desfosses 已提交
152 153
	struct pci_dev *pci_dev = to_pci_dev(dev);
	char *str = buf;
L
Linus Torvalds 已提交
154
	int i;
155
	int max;
156
	resource_size_t start, end;
L
Linus Torvalds 已提交
157 158 159

	if (pci_dev->subordinate)
		max = DEVICE_COUNT_RESOURCE;
160 161
	else
		max = PCI_BRIDGE_RESOURCES;
L
Linus Torvalds 已提交
162 163

	for (i = 0; i < max; i++) {
164 165
		struct resource *res =  &pci_dev->resource[i];
		pci_resource_to_user(pci_dev, i, res, &start, &end);
R
Ryan Desfosses 已提交
166
		str += sprintf(str, "0x%016llx 0x%016llx 0x%016llx\n",
167 168 169
			       (unsigned long long)start,
			       (unsigned long long)end,
			       (unsigned long long)res->flags);
L
Linus Torvalds 已提交
170 171 172
	}
	return (str - buf);
}
173
static DEVICE_ATTR_RO(resource);
L
Linus Torvalds 已提交
174

R
Ryan Desfosses 已提交
175 176
static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
177 178 179 180 181 182 183 184 185
{
	struct pci_dev *pci_dev = to_pci_dev(dev);

	return sprintf(buf, "pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x\n",
		       pci_dev->vendor, pci_dev->device,
		       pci_dev->subsystem_vendor, pci_dev->subsystem_device,
		       (u8)(pci_dev->class >> 16), (u8)(pci_dev->class >> 8),
		       (u8)(pci_dev->class));
}
186
static DEVICE_ATTR_RO(modalias);
187

R
Ryan Desfosses 已提交
188 189
static ssize_t enabled_store(struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
190 191
{
	struct pci_dev *pdev = to_pci_dev(dev);
192
	unsigned long val;
193
	ssize_t result = kstrtoul(buf, 0, &val);
194 195 196

	if (result < 0)
		return result;
197 198 199

	/* this can crash the machine when done on the "wrong" device */
	if (!capable(CAP_SYS_ADMIN))
200
		return -EPERM;
201

202
	if (!val) {
203
		if (pci_is_enabled(pdev))
204 205 206
			pci_disable_device(pdev);
		else
			result = -EIO;
207
	} else
208
		result = pci_enable_device(pdev);
209

210 211 212
	return result < 0 ? result : count;
}

R
Ryan Desfosses 已提交
213 214
static ssize_t enabled_show(struct device *dev, struct device_attribute *attr,
			    char *buf)
215 216
{
	struct pci_dev *pdev;
217

R
Ryan Desfosses 已提交
218 219
	pdev = to_pci_dev(dev);
	return sprintf(buf, "%u\n", atomic_read(&pdev->enable_cnt));
220
}
221
static DEVICE_ATTR_RW(enabled);
222

223
#ifdef CONFIG_NUMA
R
Ryan Desfosses 已提交
224 225
static ssize_t numa_node_show(struct device *dev, struct device_attribute *attr,
			      char *buf)
226
{
R
Ryan Desfosses 已提交
227
	return sprintf(buf, "%d\n", dev->numa_node);
228
}
229
static DEVICE_ATTR_RO(numa_node);
230 231
#endif

R
Ryan Desfosses 已提交
232 233
static ssize_t dma_mask_bits_show(struct device *dev,
				  struct device_attribute *attr, char *buf)
Y
Yinghai Lu 已提交
234 235 236
{
	struct pci_dev *pdev = to_pci_dev(dev);

R
Ryan Desfosses 已提交
237
	return sprintf(buf, "%d\n", fls64(pdev->dma_mask));
Y
Yinghai Lu 已提交
238
}
239
static DEVICE_ATTR_RO(dma_mask_bits);
Y
Yinghai Lu 已提交
240

R
Ryan Desfosses 已提交
241 242 243
static ssize_t consistent_dma_mask_bits_show(struct device *dev,
					     struct device_attribute *attr,
					     char *buf)
Y
Yinghai Lu 已提交
244
{
R
Ryan Desfosses 已提交
245
	return sprintf(buf, "%d\n", fls64(dev->coherent_dma_mask));
Y
Yinghai Lu 已提交
246
}
247
static DEVICE_ATTR_RO(consistent_dma_mask_bits);
Y
Yinghai Lu 已提交
248

R
Ryan Desfosses 已提交
249 250
static ssize_t msi_bus_show(struct device *dev, struct device_attribute *attr,
			    char *buf)
251 252 253 254 255 256
{
	struct pci_dev *pdev = to_pci_dev(dev);

	if (!pdev->subordinate)
		return 0;

R
Ryan Desfosses 已提交
257 258
	return sprintf(buf, "%u\n",
		       !(pdev->subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI));
259 260
}

R
Ryan Desfosses 已提交
261 262
static ssize_t msi_bus_store(struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
263 264
{
	struct pci_dev *pdev = to_pci_dev(dev);
265 266
	unsigned long val;

267
	if (kstrtoul(buf, 0, &val) < 0)
268
		return -EINVAL;
269

270 271 272 273
	/*
	 * Bad things may happen if the no_msi flag is changed
	 * while drivers are loaded.
	 */
274
	if (!capable(CAP_SYS_ADMIN))
275
		return -EPERM;
276

277 278 279 280
	/*
	 * Maybe devices without subordinate buses shouldn't have this
	 * attribute in the first place?
	 */
281 282 283
	if (!pdev->subordinate)
		return count;

284 285 286 287
	/* Is the flag going to change, or keep the value it already had? */
	if (!(pdev->subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI) ^
	    !!val) {
		pdev->subordinate->bus_flags ^= PCI_BUS_FLAGS_NO_MSI;
288

289 290
		dev_warn(&pdev->dev, "forced subordinate bus to%s support MSI, bad things could happen\n",
			 val ? "" : " not");
291 292 293 294
	}

	return count;
}
295
static DEVICE_ATTR_RW(msi_bus);
296

A
Alex Chiang 已提交
297 298 299 300 301 302
static ssize_t bus_rescan_store(struct bus_type *bus, const char *buf,
				size_t count)
{
	unsigned long val;
	struct pci_bus *b = NULL;

303
	if (kstrtoul(buf, 0, &val) < 0)
A
Alex Chiang 已提交
304 305 306
		return -EINVAL;

	if (val) {
307
		pci_lock_rescan_remove();
A
Alex Chiang 已提交
308 309
		while ((b = pci_find_next_bus(b)) != NULL)
			pci_rescan_bus(b);
310
		pci_unlock_rescan_remove();
A
Alex Chiang 已提交
311 312 313
	}
	return count;
}
314
static BUS_ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, bus_rescan_store);
A
Alex Chiang 已提交
315

316
static struct attribute *pci_bus_attrs[] = {
317 318 319 320 321 322 323 324 325 326 327
	&bus_attr_rescan.attr,
	NULL,
};

static const struct attribute_group pci_bus_group = {
	.attrs = pci_bus_attrs,
};

const struct attribute_group *pci_bus_groups[] = {
	&pci_bus_group,
	NULL,
A
Alex Chiang 已提交
328
};
329

R
Ryan Desfosses 已提交
330 331 332
static ssize_t dev_rescan_store(struct device *dev,
				struct device_attribute *attr, const char *buf,
				size_t count)
333 334 335 336
{
	unsigned long val;
	struct pci_dev *pdev = to_pci_dev(dev);

337
	if (kstrtoul(buf, 0, &val) < 0)
338 339 340
		return -EINVAL;

	if (val) {
341
		pci_lock_rescan_remove();
342
		pci_rescan_bus(pdev->bus);
343
		pci_unlock_rescan_remove();
344 345 346
	}
	return count;
}
347 348 349
static struct device_attribute dev_rescan_attr = __ATTR(rescan,
							(S_IWUSR|S_IWGRP),
							NULL, dev_rescan_store);
350

R
Ryan Desfosses 已提交
351 352
static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
353 354 355
{
	unsigned long val;

356
	if (kstrtoul(buf, 0, &val) < 0)
357 358
		return -EINVAL;

359 360
	if (val && device_remove_file_self(dev, attr))
		pci_stop_and_remove_bus_device_locked(to_pci_dev(dev));
361 362
	return count;
}
363 364 365
static struct device_attribute dev_remove_attr = __ATTR(remove,
							(S_IWUSR|S_IWGRP),
							NULL, remove_store);
366

R
Ryan Desfosses 已提交
367 368 369
static ssize_t dev_bus_rescan_store(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
370 371 372 373
{
	unsigned long val;
	struct pci_bus *bus = to_pci_bus(dev);

374
	if (kstrtoul(buf, 0, &val) < 0)
375 376 377
		return -EINVAL;

	if (val) {
378
		pci_lock_rescan_remove();
379 380 381 382
		if (!pci_is_root_bus(bus) && list_empty(&bus->devices))
			pci_rescan_bus_bridge_resize(bus->self);
		else
			pci_rescan_bus(bus);
383
		pci_unlock_rescan_remove();
384 385 386
	}
	return count;
}
387
static DEVICE_ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, dev_bus_rescan_store);
388

389 390 391 392 393 394 395 396
#if defined(CONFIG_PM_RUNTIME) && defined(CONFIG_ACPI)
static ssize_t d3cold_allowed_store(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	unsigned long val;

397
	if (kstrtoul(buf, 0, &val) < 0)
398 399 400 401 402 403 404 405 406 407 408 409
		return -EINVAL;

	pdev->d3cold_allowed = !!val;
	pm_runtime_resume(dev);

	return count;
}

static ssize_t d3cold_allowed_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct pci_dev *pdev = to_pci_dev(dev);
R
Ryan Desfosses 已提交
410
	return sprintf(buf, "%u\n", pdev->d3cold_allowed);
411
}
412
static DEVICE_ATTR_RW(d3cold_allowed);
413 414
#endif

415 416 417 418 419 420 421 422 423 424 425 426 427 428
#ifdef CONFIG_OF
static ssize_t devspec_show(struct device *dev,
			    struct device_attribute *attr, char *buf)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct device_node *np = pci_device_to_OF_node(pdev);

	if (np == NULL || np->full_name == NULL)
		return 0;
	return sprintf(buf, "%s", np->full_name);
}
static DEVICE_ATTR_RO(devspec);
#endif

429 430 431 432 433 434 435
#ifdef CONFIG_PCI_IOV
static ssize_t sriov_totalvfs_show(struct device *dev,
				   struct device_attribute *attr,
				   char *buf)
{
	struct pci_dev *pdev = to_pci_dev(dev);

436
	return sprintf(buf, "%u\n", pci_sriov_get_totalvfs(pdev));
437 438 439 440 441 442 443 444 445
}


static ssize_t sriov_numvfs_show(struct device *dev,
				 struct device_attribute *attr,
				 char *buf)
{
	struct pci_dev *pdev = to_pci_dev(dev);

446
	return sprintf(buf, "%u\n", pdev->sriov->num_VFs);
447 448 449
}

/*
450 451
 * num_vfs > 0; number of VFs to enable
 * num_vfs = 0; disable all VFs
452 453
 *
 * Note: SRIOV spec doesn't allow partial VF
454
 *       disable, so it's all or none.
455 456 457 458 459 460
 */
static ssize_t sriov_numvfs_store(struct device *dev,
				  struct device_attribute *attr,
				  const char *buf, size_t count)
{
	struct pci_dev *pdev = to_pci_dev(dev);
461 462
	int ret;
	u16 num_vfs;
463

464 465 466 467 468 469 470 471 472
	ret = kstrtou16(buf, 0, &num_vfs);
	if (ret < 0)
		return ret;

	if (num_vfs > pci_sriov_get_totalvfs(pdev))
		return -ERANGE;

	if (num_vfs == pdev->sriov->num_VFs)
		return count;		/* no change */
473 474 475

	/* is PF driver loaded w/callback */
	if (!pdev->driver || !pdev->driver->sriov_configure) {
476
		dev_info(&pdev->dev, "Driver doesn't support SRIOV configuration via sysfs\n");
477 478 479
		return -ENOSYS;
	}

480 481 482 483 484 485
	if (num_vfs == 0) {
		/* disable VFs */
		ret = pdev->driver->sriov_configure(pdev, 0);
		if (ret < 0)
			return ret;
		return count;
486 487
	}

488 489 490 491 492
	/* enable VFs */
	if (pdev->sriov->num_VFs) {
		dev_warn(&pdev->dev, "%d VFs already enabled. Disable before enabling %d VFs\n",
			 pdev->sriov->num_VFs, num_vfs);
		return -EBUSY;
493 494
	}

495 496 497
	ret = pdev->driver->sriov_configure(pdev, num_vfs);
	if (ret < 0)
		return ret;
498

499 500 501 502 503
	if (ret != num_vfs)
		dev_warn(&pdev->dev, "%d VFs requested; only %d enabled\n",
			 num_vfs, ret);

	return count;
504 505 506 507 508 509 510 511
}

static struct device_attribute sriov_totalvfs_attr = __ATTR_RO(sriov_totalvfs);
static struct device_attribute sriov_numvfs_attr =
		__ATTR(sriov_numvfs, (S_IRUGO|S_IWUSR|S_IWGRP),
		       sriov_numvfs_show, sriov_numvfs_store);
#endif /* CONFIG_PCI_IOV */

512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
static ssize_t driver_override_store(struct device *dev,
				     struct device_attribute *attr,
				     const char *buf, size_t count)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	char *driver_override, *old = pdev->driver_override, *cp;

	if (count > PATH_MAX)
		return -EINVAL;

	driver_override = kstrndup(buf, count, GFP_KERNEL);
	if (!driver_override)
		return -ENOMEM;

	cp = strchr(driver_override, '\n');
	if (cp)
		*cp = '\0';

	if (strlen(driver_override)) {
		pdev->driver_override = driver_override;
	} else {
		kfree(driver_override);
		pdev->driver_override = NULL;
	}

	kfree(old);

	return count;
}

static ssize_t driver_override_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
	struct pci_dev *pdev = to_pci_dev(dev);

	return sprintf(buf, "%s\n", pdev->driver_override);
}
static DEVICE_ATTR_RW(driver_override);

551
static struct attribute *pci_dev_attrs[] = {
552 553 554 555 556 557 558 559 560 561
	&dev_attr_resource.attr,
	&dev_attr_vendor.attr,
	&dev_attr_device.attr,
	&dev_attr_subsystem_vendor.attr,
	&dev_attr_subsystem_device.attr,
	&dev_attr_class.attr,
	&dev_attr_irq.attr,
	&dev_attr_local_cpus.attr,
	&dev_attr_local_cpulist.attr,
	&dev_attr_modalias.attr,
562
#ifdef CONFIG_NUMA
563
	&dev_attr_numa_node.attr,
564
#endif
565 566 567 568 569
	&dev_attr_dma_mask_bits.attr,
	&dev_attr_consistent_dma_mask_bits.attr,
	&dev_attr_enabled.attr,
	&dev_attr_broken_parity_status.attr,
	&dev_attr_msi_bus.attr,
570
#if defined(CONFIG_PM_RUNTIME) && defined(CONFIG_ACPI)
571
	&dev_attr_d3cold_allowed.attr,
572 573 574
#endif
#ifdef CONFIG_OF
	&dev_attr_devspec.attr,
575
#endif
576
	&dev_attr_driver_override.attr,
577 578 579 580 581 582 583 584 585 586
	NULL,
};

static const struct attribute_group pci_dev_group = {
	.attrs = pci_dev_attrs,
};

const struct attribute_group *pci_dev_groups[] = {
	&pci_dev_group,
	NULL,
L
Linus Torvalds 已提交
587 588
};

589 590 591 592 593 594 595 596 597 598 599 600 601 602
static struct attribute *pcibus_attrs[] = {
	&dev_attr_rescan.attr,
	&dev_attr_cpuaffinity.attr,
	&dev_attr_cpulistaffinity.attr,
	NULL,
};

static const struct attribute_group pcibus_group = {
	.attrs = pcibus_attrs,
};

const struct attribute_group *pcibus_groups[] = {
	&pcibus_group,
	NULL,
603 604
};

R
Ryan Desfosses 已提交
605 606
static ssize_t boot_vga_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
607 608
{
	struct pci_dev *pdev = to_pci_dev(dev);
609 610 611 612
	struct pci_dev *vga_dev = vga_default_device();

	if (vga_dev)
		return sprintf(buf, "%u\n", (pdev == vga_dev));
613 614 615 616 617

	return sprintf(buf, "%u\n",
		!!(pdev->resource[PCI_ROM_RESOURCE].flags &
		   IORESOURCE_ROM_SHADOW));
}
618
static struct device_attribute vga_attr = __ATTR_RO(boot_vga);
619

R
Ryan Desfosses 已提交
620 621 622
static ssize_t pci_read_config(struct file *filp, struct kobject *kobj,
			       struct bin_attribute *bin_attr, char *buf,
			       loff_t off, size_t count)
L
Linus Torvalds 已提交
623
{
R
Ryan Desfosses 已提交
624 625
	struct pci_dev *dev = to_pci_dev(container_of(kobj, struct device,
						      kobj));
L
Linus Torvalds 已提交
626 627
	unsigned int size = 64;
	loff_t init_off = off;
R
Ryan Desfosses 已提交
628
	u8 *data = (u8 *) buf;
L
Linus Torvalds 已提交
629 630

	/* Several chips lock up trying to read undefined config space */
R
Ryan Desfosses 已提交
631
	if (security_capable(filp->f_cred, &init_user_ns, CAP_SYS_ADMIN) == 0)
L
Linus Torvalds 已提交
632
		size = dev->cfg_size;
R
Ryan Desfosses 已提交
633
	else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
L
Linus Torvalds 已提交
634 635 636 637 638 639 640 641 642 643 644
		size = 128;

	if (off > size)
		return 0;
	if (off + count > size) {
		size -= off;
		count = size;
	} else {
		size = count;
	}

645 646
	pci_config_pm_runtime_get(dev);

647 648
	if ((off & 1) && size) {
		u8 val;
649
		pci_user_read_config_byte(dev, off, &val);
650
		data[off - init_off] = val;
L
Linus Torvalds 已提交
651
		off++;
652 653 654 655 656
		size--;
	}

	if ((off & 3) && size > 2) {
		u16 val;
657
		pci_user_read_config_word(dev, off, &val);
658 659 660 661
		data[off - init_off] = val & 0xff;
		data[off - init_off + 1] = (val >> 8) & 0xff;
		off += 2;
		size -= 2;
L
Linus Torvalds 已提交
662 663 664
	}

	while (size > 3) {
665
		u32 val;
666
		pci_user_read_config_dword(dev, off, &val);
667 668 669 670
		data[off - init_off] = val & 0xff;
		data[off - init_off + 1] = (val >> 8) & 0xff;
		data[off - init_off + 2] = (val >> 16) & 0xff;
		data[off - init_off + 3] = (val >> 24) & 0xff;
L
Linus Torvalds 已提交
671 672 673 674
		off += 4;
		size -= 4;
	}

675 676
	if (size >= 2) {
		u16 val;
677
		pci_user_read_config_word(dev, off, &val);
678 679 680 681 682 683 684 685
		data[off - init_off] = val & 0xff;
		data[off - init_off + 1] = (val >> 8) & 0xff;
		off += 2;
		size -= 2;
	}

	if (size > 0) {
		u8 val;
686
		pci_user_read_config_byte(dev, off, &val);
687
		data[off - init_off] = val;
L
Linus Torvalds 已提交
688 689 690 691
		off++;
		--size;
	}

692 693
	pci_config_pm_runtime_put(dev);

L
Linus Torvalds 已提交
694 695 696
	return count;
}

R
Ryan Desfosses 已提交
697 698 699
static ssize_t pci_write_config(struct file *filp, struct kobject *kobj,
				struct bin_attribute *bin_attr, char *buf,
				loff_t off, size_t count)
L
Linus Torvalds 已提交
700
{
R
Ryan Desfosses 已提交
701 702
	struct pci_dev *dev = to_pci_dev(container_of(kobj, struct device,
						      kobj));
L
Linus Torvalds 已提交
703 704
	unsigned int size = count;
	loff_t init_off = off;
R
Ryan Desfosses 已提交
705
	u8 *data = (u8 *) buf;
L
Linus Torvalds 已提交
706 707 708 709 710 711 712

	if (off > dev->cfg_size)
		return 0;
	if (off + count > dev->cfg_size) {
		size = dev->cfg_size - off;
		count = size;
	}
713

714 715
	pci_config_pm_runtime_get(dev);

716
	if ((off & 1) && size) {
717
		pci_user_write_config_byte(dev, off, data[off - init_off]);
L
Linus Torvalds 已提交
718
		off++;
719
		size--;
L
Linus Torvalds 已提交
720
	}
721

722 723 724
	if ((off & 3) && size > 2) {
		u16 val = data[off - init_off];
		val |= (u16) data[off - init_off + 1] << 8;
R
Ryan Desfosses 已提交
725 726 727 728
		pci_user_write_config_word(dev, off, val);
		off += 2;
		size -= 2;
	}
L
Linus Torvalds 已提交
729 730

	while (size > 3) {
731 732 733 734
		u32 val = data[off - init_off];
		val |= (u32) data[off - init_off + 1] << 8;
		val |= (u32) data[off - init_off + 2] << 16;
		val |= (u32) data[off - init_off + 3] << 24;
735
		pci_user_write_config_dword(dev, off, val);
L
Linus Torvalds 已提交
736 737 738
		off += 4;
		size -= 4;
	}
739

740 741 742
	if (size >= 2) {
		u16 val = data[off - init_off];
		val |= (u16) data[off - init_off + 1] << 8;
743
		pci_user_write_config_word(dev, off, val);
744 745 746
		off += 2;
		size -= 2;
	}
L
Linus Torvalds 已提交
747

748
	if (size) {
749
		pci_user_write_config_byte(dev, off, data[off - init_off]);
L
Linus Torvalds 已提交
750 751 752 753
		off++;
		--size;
	}

754 755
	pci_config_pm_runtime_put(dev);

L
Linus Torvalds 已提交
756 757 758
	return count;
}

R
Ryan Desfosses 已提交
759 760 761
static ssize_t read_vpd_attr(struct file *filp, struct kobject *kobj,
			     struct bin_attribute *bin_attr, char *buf,
			     loff_t off, size_t count)
762 763 764 765 766 767 768 769 770
{
	struct pci_dev *dev =
		to_pci_dev(container_of(kobj, struct device, kobj));

	if (off > bin_attr->size)
		count = 0;
	else if (count > bin_attr->size - off)
		count = bin_attr->size - off;

771
	return pci_read_vpd(dev, off, count, buf);
772 773
}

R
Ryan Desfosses 已提交
774 775 776
static ssize_t write_vpd_attr(struct file *filp, struct kobject *kobj,
			      struct bin_attribute *bin_attr, char *buf,
			      loff_t off, size_t count)
777 778 779 780 781 782 783 784 785
{
	struct pci_dev *dev =
		to_pci_dev(container_of(kobj, struct device, kobj));

	if (off > bin_attr->size)
		count = 0;
	else if (count > bin_attr->size - off)
		count = bin_attr->size - off;

786
	return pci_write_vpd(dev, off, count, buf);
787 788
}

L
Linus Torvalds 已提交
789 790 791
#ifdef HAVE_PCI_LEGACY
/**
 * pci_read_legacy_io - read byte(s) from legacy I/O port space
792
 * @filp: open sysfs file
L
Linus Torvalds 已提交
793
 * @kobj: kobject corresponding to file to read from
R
Randy Dunlap 已提交
794
 * @bin_attr: struct bin_attribute for this file
L
Linus Torvalds 已提交
795 796 797 798 799 800 801
 * @buf: buffer to store results
 * @off: offset into legacy I/O port space
 * @count: number of bytes to read
 *
 * Reads 1, 2, or 4 bytes from legacy I/O port space using an arch specific
 * callback routine (pci_legacy_read).
 */
R
Ryan Desfosses 已提交
802 803 804
static ssize_t pci_read_legacy_io(struct file *filp, struct kobject *kobj,
				  struct bin_attribute *bin_attr, char *buf,
				  loff_t off, size_t count)
L
Linus Torvalds 已提交
805
{
R
Ryan Desfosses 已提交
806
	struct pci_bus *bus = to_pci_bus(container_of(kobj, struct device,
L
Linus Torvalds 已提交
807 808
						      kobj));

R
Ryan Desfosses 已提交
809 810 811
	/* Only support 1, 2 or 4 byte accesses */
	if (count != 1 && count != 2 && count != 4)
		return -EINVAL;
L
Linus Torvalds 已提交
812

R
Ryan Desfosses 已提交
813
	return pci_legacy_read(bus, off, (u32 *)buf, count);
L
Linus Torvalds 已提交
814 815 816 817
}

/**
 * pci_write_legacy_io - write byte(s) to legacy I/O port space
818
 * @filp: open sysfs file
L
Linus Torvalds 已提交
819
 * @kobj: kobject corresponding to file to read from
R
Randy Dunlap 已提交
820
 * @bin_attr: struct bin_attribute for this file
L
Linus Torvalds 已提交
821 822 823 824 825 826 827
 * @buf: buffer containing value to be written
 * @off: offset into legacy I/O port space
 * @count: number of bytes to write
 *
 * Writes 1, 2, or 4 bytes from legacy I/O port space using an arch specific
 * callback routine (pci_legacy_write).
 */
R
Ryan Desfosses 已提交
828 829 830
static ssize_t pci_write_legacy_io(struct file *filp, struct kobject *kobj,
				   struct bin_attribute *bin_attr, char *buf,
				   loff_t off, size_t count)
L
Linus Torvalds 已提交
831
{
R
Ryan Desfosses 已提交
832
	struct pci_bus *bus = to_pci_bus(container_of(kobj, struct device,
L
Linus Torvalds 已提交
833 834
						      kobj));

R
Ryan Desfosses 已提交
835 836 837 838 839
	/* Only support 1, 2 or 4 byte accesses */
	if (count != 1 && count != 2 && count != 4)
		return -EINVAL;

	return pci_legacy_write(bus, off, *(u32 *)buf, count);
L
Linus Torvalds 已提交
840 841 842 843
}

/**
 * pci_mmap_legacy_mem - map legacy PCI memory into user memory space
844
 * @filp: open sysfs file
L
Linus Torvalds 已提交
845 846 847 848
 * @kobj: kobject corresponding to device to be mapped
 * @attr: struct bin_attribute for this file
 * @vma: struct vm_area_struct passed to mmap
 *
849
 * Uses an arch specific callback, pci_mmap_legacy_mem_page_range, to mmap
L
Linus Torvalds 已提交
850 851 852
 * legacy memory space (first meg of bus space) into application virtual
 * memory space.
 */
R
Ryan Desfosses 已提交
853 854 855
static int pci_mmap_legacy_mem(struct file *filp, struct kobject *kobj,
			       struct bin_attribute *attr,
			       struct vm_area_struct *vma)
L
Linus Torvalds 已提交
856
{
R
Ryan Desfosses 已提交
857
	struct pci_bus *bus = to_pci_bus(container_of(kobj, struct device,
L
Linus Torvalds 已提交
858 859
						      kobj));

R
Ryan Desfosses 已提交
860
	return pci_mmap_legacy_page_range(bus, vma, pci_mmap_mem);
861 862 863 864
}

/**
 * pci_mmap_legacy_io - map legacy PCI IO into user memory space
865
 * @filp: open sysfs file
866 867 868 869 870 871 872 873
 * @kobj: kobject corresponding to device to be mapped
 * @attr: struct bin_attribute for this file
 * @vma: struct vm_area_struct passed to mmap
 *
 * Uses an arch specific callback, pci_mmap_legacy_io_page_range, to mmap
 * legacy IO space (first meg of bus space) into application virtual
 * memory space. Returns -ENOSYS if the operation isn't supported
 */
R
Ryan Desfosses 已提交
874 875 876
static int pci_mmap_legacy_io(struct file *filp, struct kobject *kobj,
			      struct bin_attribute *attr,
			      struct vm_area_struct *vma)
877
{
R
Ryan Desfosses 已提交
878
	struct pci_bus *bus = to_pci_bus(container_of(kobj, struct device,
879 880
						      kobj));

R
Ryan Desfosses 已提交
881
	return pci_mmap_legacy_page_range(bus, vma, pci_mmap_io);
882 883
}

I
Ivan Kokshaysky 已提交
884 885 886 887 888 889 890
/**
 * pci_adjust_legacy_attr - adjustment of legacy file attributes
 * @b: bus to create files under
 * @mmap_type: I/O port or memory
 *
 * Stub implementation. Can be overridden by arch if necessary.
 */
R
Ryan Desfosses 已提交
891 892
void __weak pci_adjust_legacy_attr(struct pci_bus *b,
				   enum pci_mmap_state mmap_type)
I
Ivan Kokshaysky 已提交
893 894 895
{
}

896 897 898 899 900 901 902 903
/**
 * pci_create_legacy_files - create legacy I/O port and memory files
 * @b: bus to create files under
 *
 * Some platforms allow access to legacy I/O port and ISA memory space on
 * a per-bus basis.  This routine creates the files and ties them into
 * their associated read, write and mmap files from pci-sysfs.c
 *
L
Lucas De Marchi 已提交
904
 * On error unwind, but don't propagate the error to the caller
905 906 907 908 909 910 911 912 913 914 915
 * as it is ok to set up the PCI bus without these files.
 */
void pci_create_legacy_files(struct pci_bus *b)
{
	int error;

	b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2,
			       GFP_ATOMIC);
	if (!b->legacy_io)
		goto kzalloc_err;

916
	sysfs_bin_attr_init(b->legacy_io);
917 918 919 920 921 922
	b->legacy_io->attr.name = "legacy_io";
	b->legacy_io->size = 0xffff;
	b->legacy_io->attr.mode = S_IRUSR | S_IWUSR;
	b->legacy_io->read = pci_read_legacy_io;
	b->legacy_io->write = pci_write_legacy_io;
	b->legacy_io->mmap = pci_mmap_legacy_io;
I
Ivan Kokshaysky 已提交
923
	pci_adjust_legacy_attr(b, pci_mmap_io);
924 925 926 927 928 929
	error = device_create_bin_file(&b->dev, b->legacy_io);
	if (error)
		goto legacy_io_err;

	/* Allocated above after the legacy_io struct */
	b->legacy_mem = b->legacy_io + 1;
930
	sysfs_bin_attr_init(b->legacy_mem);
931 932 933 934
	b->legacy_mem->attr.name = "legacy_mem";
	b->legacy_mem->size = 1024*1024;
	b->legacy_mem->attr.mode = S_IRUSR | S_IWUSR;
	b->legacy_mem->mmap = pci_mmap_legacy_mem;
I
Ivan Kokshaysky 已提交
935
	pci_adjust_legacy_attr(b, pci_mmap_mem);
936 937 938 939 940 941 942 943 944 945 946 947
	error = device_create_bin_file(&b->dev, b->legacy_mem);
	if (error)
		goto legacy_mem_err;

	return;

legacy_mem_err:
	device_remove_bin_file(&b->dev, b->legacy_io);
legacy_io_err:
	kfree(b->legacy_io);
	b->legacy_io = NULL;
kzalloc_err:
948
	printk(KERN_WARNING "pci: warning: could not create legacy I/O port and ISA memory resources to sysfs\n");
949 950 951 952 953 954 955 956 957 958
	return;
}

void pci_remove_legacy_files(struct pci_bus *b)
{
	if (b->legacy_io) {
		device_remove_bin_file(&b->dev, b->legacy_io);
		device_remove_bin_file(&b->dev, b->legacy_mem);
		kfree(b->legacy_io); /* both are allocated here */
	}
L
Linus Torvalds 已提交
959 960 961 962
}
#endif /* HAVE_PCI_LEGACY */

#ifdef HAVE_PCI_MMAP
963

964 965
int pci_mmap_fits(struct pci_dev *pdev, int resno, struct vm_area_struct *vma,
		  enum pci_mmap_api mmap_api)
966
{
967
	unsigned long nr, start, size, pci_start;
968

969 970
	if (pci_resource_len(pdev, resno) == 0)
		return 0;
971
	nr = vma_pages(vma);
972
	start = vma->vm_pgoff;
973
	size = ((pci_resource_len(pdev, resno) - 1) >> PAGE_SHIFT) + 1;
974
	pci_start = (mmap_api == PCI_MMAP_PROCFS) ?
975 976 977
			pci_resource_start(pdev, resno) >> PAGE_SHIFT : 0;
	if (start >= pci_start && start < pci_start + size &&
			start + nr <= pci_start + size)
978 979 980 981
		return 1;
	return 0;
}

L
Linus Torvalds 已提交
982 983 984 985 986
/**
 * pci_mmap_resource - map a PCI resource into user memory space
 * @kobj: kobject for mapping
 * @attr: struct bin_attribute for the file being mapped
 * @vma: struct vm_area_struct passed into the mmap
987
 * @write_combine: 1 for write_combine mapping
L
Linus Torvalds 已提交
988 989 990
 *
 * Use the regular PCI mapping routines to map a PCI resource into userspace.
 */
R
Ryan Desfosses 已提交
991 992
static int pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,
			     struct vm_area_struct *vma, int write_combine)
L
Linus Torvalds 已提交
993 994 995
{
	struct pci_dev *pdev = to_pci_dev(container_of(kobj,
						       struct device, kobj));
996
	struct resource *res = attr->private;
L
Linus Torvalds 已提交
997
	enum pci_mmap_state mmap_type;
998
	resource_size_t start, end;
999
	int i;
L
Linus Torvalds 已提交
1000

1001 1002 1003 1004 1005 1006
	for (i = 0; i < PCI_ROM_RESOURCE; i++)
		if (res == &pdev->resource[i])
			break;
	if (i >= PCI_ROM_RESOURCE)
		return -ENODEV;

1007
	if (!pci_mmap_fits(pdev, i, vma, PCI_MMAP_SYSFS)) {
1008
		WARN(1, "process \"%s\" tried to map 0x%08lx bytes at page 0x%08lx on %s BAR %d (start 0x%16Lx, size 0x%16Lx)\n",
1009 1010
			current->comm, vma->vm_end-vma->vm_start, vma->vm_pgoff,
			pci_name(pdev), i,
R
Randy Dunlap 已提交
1011 1012
			(u64)pci_resource_start(pdev, i),
			(u64)pci_resource_len(pdev, i));
1013
		return -EINVAL;
1014
	}
1015

1016 1017 1018 1019 1020 1021
	/* pci_mmap_page_range() expects the same kind of entry as coming
	 * from /proc/bus/pci/ which is a "user visible" value. If this is
	 * different from the resource itself, arch will do necessary fixup.
	 */
	pci_resource_to_user(pdev, i, res, &start, &end);
	vma->vm_pgoff += start >> PAGE_SHIFT;
L
Linus Torvalds 已提交
1022 1023
	mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io;

1024 1025 1026
	if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(start))
		return -EINVAL;

1027 1028 1029
	return pci_mmap_page_range(pdev, vma, mmap_type, write_combine);
}

R
Ryan Desfosses 已提交
1030 1031 1032
static int pci_mmap_resource_uc(struct file *filp, struct kobject *kobj,
				struct bin_attribute *attr,
				struct vm_area_struct *vma)
1033 1034 1035 1036
{
	return pci_mmap_resource(kobj, attr, vma, 0);
}

R
Ryan Desfosses 已提交
1037 1038 1039
static int pci_mmap_resource_wc(struct file *filp, struct kobject *kobj,
				struct bin_attribute *attr,
				struct vm_area_struct *vma)
1040 1041
{
	return pci_mmap_resource(kobj, attr, vma, 1);
L
Linus Torvalds 已提交
1042 1043
}

R
Ryan Desfosses 已提交
1044 1045 1046
static ssize_t pci_resource_io(struct file *filp, struct kobject *kobj,
			       struct bin_attribute *attr, char *buf,
			       loff_t off, size_t count, bool write)
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
{
	struct pci_dev *pdev = to_pci_dev(container_of(kobj,
						       struct device, kobj));
	struct resource *res = attr->private;
	unsigned long port = off;
	int i;

	for (i = 0; i < PCI_ROM_RESOURCE; i++)
		if (res == &pdev->resource[i])
			break;
	if (i >= PCI_ROM_RESOURCE)
		return -ENODEV;

	port += pci_resource_start(pdev, i);

	if (port > pci_resource_end(pdev, i))
		return 0;

	if (port + count - 1 > pci_resource_end(pdev, i))
		return -EINVAL;

	switch (count) {
	case 1:
		if (write)
			outb(*(u8 *)buf, port);
		else
			*(u8 *)buf = inb(port);
		return 1;
	case 2:
		if (write)
			outw(*(u16 *)buf, port);
		else
			*(u16 *)buf = inw(port);
		return 2;
	case 4:
		if (write)
			outl(*(u32 *)buf, port);
		else
			*(u32 *)buf = inl(port);
		return 4;
	}
	return -EINVAL;
}

R
Ryan Desfosses 已提交
1091 1092 1093
static ssize_t pci_read_resource_io(struct file *filp, struct kobject *kobj,
				    struct bin_attribute *attr, char *buf,
				    loff_t off, size_t count)
1094 1095 1096 1097
{
	return pci_resource_io(filp, kobj, attr, buf, off, count, false);
}

R
Ryan Desfosses 已提交
1098 1099 1100
static ssize_t pci_write_resource_io(struct file *filp, struct kobject *kobj,
				     struct bin_attribute *attr, char *buf,
				     loff_t off, size_t count)
1101 1102 1103 1104
{
	return pci_resource_io(filp, kobj, attr, buf, off, count, true);
}

1105 1106
/**
 * pci_remove_resource_files - cleanup resource files
R
Randy Dunlap 已提交
1107
 * @pdev: dev to cleanup
1108
 *
R
Randy Dunlap 已提交
1109
 * If we created resource files for @pdev, remove them from sysfs and
1110 1111
 * free their resources.
 */
R
Ryan Desfosses 已提交
1112
static void pci_remove_resource_files(struct pci_dev *pdev)
1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
{
	int i;

	for (i = 0; i < PCI_ROM_RESOURCE; i++) {
		struct bin_attribute *res_attr;

		res_attr = pdev->res_attr[i];
		if (res_attr) {
			sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
			kfree(res_attr);
		}
1124 1125 1126 1127 1128 1129

		res_attr = pdev->res_attr_wc[i];
		if (res_attr) {
			sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
			kfree(res_attr);
		}
1130 1131 1132
	}
}

1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine)
{
	/* allocate attribute structure, piggyback attribute name */
	int name_len = write_combine ? 13 : 10;
	struct bin_attribute *res_attr;
	int retval;

	res_attr = kzalloc(sizeof(*res_attr) + name_len, GFP_ATOMIC);
	if (res_attr) {
		char *res_attr_name = (char *)(res_attr + 1);

1144
		sysfs_bin_attr_init(res_attr);
1145 1146 1147 1148 1149 1150 1151 1152 1153
		if (write_combine) {
			pdev->res_attr_wc[num] = res_attr;
			sprintf(res_attr_name, "resource%d_wc", num);
			res_attr->mmap = pci_mmap_resource_wc;
		} else {
			pdev->res_attr[num] = res_attr;
			sprintf(res_attr_name, "resource%d", num);
			res_attr->mmap = pci_mmap_resource_uc;
		}
1154 1155 1156 1157
		if (pci_resource_flags(pdev, num) & IORESOURCE_IO) {
			res_attr->read = pci_read_resource_io;
			res_attr->write = pci_write_resource_io;
		}
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
		res_attr->attr.name = res_attr_name;
		res_attr->attr.mode = S_IRUSR | S_IWUSR;
		res_attr->size = pci_resource_len(pdev, num);
		res_attr->private = &pdev->resource[num];
		retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr);
	} else
		retval = -ENOMEM;

	return retval;
}

L
Linus Torvalds 已提交
1169 1170
/**
 * pci_create_resource_files - create resource files in sysfs for @dev
R
Randy Dunlap 已提交
1171
 * @pdev: dev in question
L
Linus Torvalds 已提交
1172
 *
R
Randy Dunlap 已提交
1173
 * Walk the resources in @pdev creating files for each resource available.
L
Linus Torvalds 已提交
1174
 */
1175
static int pci_create_resource_files(struct pci_dev *pdev)
L
Linus Torvalds 已提交
1176 1177
{
	int i;
1178
	int retval;
L
Linus Torvalds 已提交
1179 1180 1181 1182 1183 1184 1185 1186

	/* Expose the PCI resources from this device as files */
	for (i = 0; i < PCI_ROM_RESOURCE; i++) {

		/* skip empty resources */
		if (!pci_resource_len(pdev, i))
			continue;

1187 1188 1189 1190 1191 1192 1193 1194
		retval = pci_create_attr(pdev, i, 0);
		/* for prefetchable resources, create a WC mappable file */
		if (!retval && pdev->resource[i].flags & IORESOURCE_PREFETCH)
			retval = pci_create_attr(pdev, i, 1);

		if (retval) {
			pci_remove_resource_files(pdev);
			return retval;
L
Linus Torvalds 已提交
1195 1196
		}
	}
1197
	return 0;
L
Linus Torvalds 已提交
1198 1199
}
#else /* !HAVE_PCI_MMAP */
I
Ivan Kokshaysky 已提交
1200 1201
int __weak pci_create_resource_files(struct pci_dev *dev) { return 0; }
void __weak pci_remove_resource_files(struct pci_dev *dev) { return; }
L
Linus Torvalds 已提交
1202 1203 1204 1205
#endif /* HAVE_PCI_MMAP */

/**
 * pci_write_rom - used to enable access to the PCI ROM display
1206
 * @filp: sysfs file
L
Linus Torvalds 已提交
1207
 * @kobj: kernel object handle
R
Randy Dunlap 已提交
1208
 * @bin_attr: struct bin_attribute for this file
L
Linus Torvalds 已提交
1209 1210 1211 1212 1213 1214
 * @buf: user input
 * @off: file offset
 * @count: number of byte in input
 *
 * writing anything except 0 enables it
 */
R
Ryan Desfosses 已提交
1215 1216 1217
static ssize_t pci_write_rom(struct file *filp, struct kobject *kobj,
			     struct bin_attribute *bin_attr, char *buf,
			     loff_t off, size_t count)
L
Linus Torvalds 已提交
1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
{
	struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj));

	if ((off ==  0) && (*buf == '0') && (count == 2))
		pdev->rom_attr_enabled = 0;
	else
		pdev->rom_attr_enabled = 1;

	return count;
}

/**
 * pci_read_rom - read a PCI ROM
1231
 * @filp: sysfs file
L
Linus Torvalds 已提交
1232
 * @kobj: kernel object handle
R
Randy Dunlap 已提交
1233
 * @bin_attr: struct bin_attribute for this file
L
Linus Torvalds 已提交
1234 1235 1236 1237 1238 1239 1240
 * @buf: where to put the data we read from the ROM
 * @off: file offset
 * @count: number of bytes to read
 *
 * Put @count bytes starting at @off into @buf from the ROM in the PCI
 * device corresponding to @kobj.
 */
R
Ryan Desfosses 已提交
1241 1242 1243
static ssize_t pci_read_rom(struct file *filp, struct kobject *kobj,
			    struct bin_attribute *bin_attr, char *buf,
			    loff_t off, size_t count)
L
Linus Torvalds 已提交
1244 1245 1246 1247 1248 1249 1250
{
	struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj));
	void __iomem *rom;
	size_t size;

	if (!pdev->rom_attr_enabled)
		return -EINVAL;
1251

L
Linus Torvalds 已提交
1252
	rom = pci_map_rom(pdev, &size);	/* size starts out as PCI window size */
1253 1254
	if (!rom || !size)
		return -EIO;
1255

L
Linus Torvalds 已提交
1256 1257 1258 1259 1260
	if (off >= size)
		count = 0;
	else {
		if (off + count > size)
			count = size - off;
1261

L
Linus Torvalds 已提交
1262 1263 1264
		memcpy_fromio(buf, rom + off, count);
	}
	pci_unmap_rom(pdev, rom);
1265

L
Linus Torvalds 已提交
1266 1267 1268 1269 1270 1271 1272 1273
	return count;
}

static struct bin_attribute pci_config_attr = {
	.attr =	{
		.name = "config",
		.mode = S_IRUGO | S_IWUSR,
	},
1274
	.size = PCI_CFG_SPACE_SIZE,
L
Linus Torvalds 已提交
1275 1276 1277 1278 1279 1280 1281 1282 1283
	.read = pci_read_config,
	.write = pci_write_config,
};

static struct bin_attribute pcie_config_attr = {
	.attr =	{
		.name = "config",
		.mode = S_IRUGO | S_IWUSR,
	},
1284
	.size = PCI_CFG_SPACE_EXP_SIZE,
L
Linus Torvalds 已提交
1285 1286 1287 1288
	.read = pci_read_config,
	.write = pci_write_config,
};

R
Ryan Desfosses 已提交
1289 1290
static ssize_t reset_store(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
1291 1292 1293
{
	struct pci_dev *pdev = to_pci_dev(dev);
	unsigned long val;
1294
	ssize_t result = kstrtoul(buf, 0, &val);
1295 1296 1297 1298 1299 1300

	if (result < 0)
		return result;

	if (val != 1)
		return -EINVAL;
1301 1302 1303 1304 1305 1306

	result = pci_reset_function(pdev);
	if (result < 0)
		return result;

	return count;
1307 1308 1309 1310
}

static struct device_attribute reset_attr = __ATTR(reset, 0200, NULL, reset_store);

1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321
static int pci_create_capabilities_sysfs(struct pci_dev *dev)
{
	int retval;
	struct bin_attribute *attr;

	/* If the device has VPD, try to expose it in sysfs. */
	if (dev->vpd) {
		attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
		if (!attr)
			return -ENOMEM;

1322
		sysfs_bin_attr_init(attr);
1323 1324 1325
		attr->size = dev->vpd->len;
		attr->attr.name = "vpd";
		attr->attr.mode = S_IRUSR | S_IWUSR;
1326 1327
		attr->read = read_vpd_attr;
		attr->write = write_vpd_attr;
1328 1329
		retval = sysfs_create_bin_file(&dev->dev.kobj, attr);
		if (retval) {
1330
			kfree(attr);
1331 1332 1333 1334 1335 1336 1337 1338
			return retval;
		}
		dev->vpd->attr = attr;
	}

	/* Active State Power Management */
	pcie_aspm_create_sysfs_dev_files(dev);

1339 1340 1341 1342 1343 1344
	if (!pci_probe_reset_function(dev)) {
		retval = device_create_file(&dev->dev, &reset_attr);
		if (retval)
			goto error;
		dev->reset_fn = 1;
	}
1345
	return 0;
1346 1347 1348 1349 1350 1351 1352 1353 1354

error:
	pcie_aspm_remove_sysfs_dev_files(dev);
	if (dev->vpd && dev->vpd->attr) {
		sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr);
		kfree(dev->vpd->attr);
	}

	return retval;
1355 1356
}

R
Ryan Desfosses 已提交
1357
int __must_check pci_create_sysfs_dev_files(struct pci_dev *pdev)
L
Linus Torvalds 已提交
1358
{
1359
	int retval;
1360 1361
	int rom_size = 0;
	struct bin_attribute *attr;
1362

L
Linus Torvalds 已提交
1363 1364 1365
	if (!sysfs_initialized)
		return -EACCES;

1366
	if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
1367
		retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr);
L
Linus Torvalds 已提交
1368
	else
1369 1370 1371
		retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr);
	if (retval)
		goto err;
L
Linus Torvalds 已提交
1372

1373 1374
	retval = pci_create_resource_files(pdev);
	if (retval)
1375 1376 1377 1378 1379 1380
		goto err_config_file;

	if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
		rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
	else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
		rom_size = 0x20000;
L
Linus Torvalds 已提交
1381 1382

	/* If the device has a ROM, try to expose it in sysfs. */
1383
	if (rom_size) {
1384
		attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
1385
		if (!attr) {
1386
			retval = -ENOMEM;
1387
			goto err_resource_files;
L
Linus Torvalds 已提交
1388
		}
1389
		sysfs_bin_attr_init(attr);
1390 1391
		attr->size = rom_size;
		attr->attr.name = "rom";
1392
		attr->attr.mode = S_IRUSR | S_IWUSR;
1393 1394 1395 1396 1397 1398 1399 1400
		attr->read = pci_read_rom;
		attr->write = pci_write_rom;
		retval = sysfs_create_bin_file(&pdev->dev.kobj, attr);
		if (retval) {
			kfree(attr);
			goto err_resource_files;
		}
		pdev->rom_attr = attr;
L
Linus Torvalds 已提交
1401
	}
1402 1403 1404 1405

	/* add sysfs entries for various capabilities */
	retval = pci_create_capabilities_sysfs(pdev);
	if (retval)
1406
		goto err_rom_file;
S
Shaohua Li 已提交
1407

1408 1409
	pci_create_firmware_label_files(pdev);

L
Linus Torvalds 已提交
1410
	return 0;
1411

1412
err_rom_file:
1413
	if (rom_size) {
1414
		sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
1415 1416 1417
		kfree(pdev->rom_attr);
		pdev->rom_attr = NULL;
	}
1418 1419
err_resource_files:
	pci_remove_resource_files(pdev);
1420
err_config_file:
1421
	if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
1422 1423 1424 1425 1426
		sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
	else
		sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
err:
	return retval;
L
Linus Torvalds 已提交
1427 1428
}

1429 1430 1431 1432 1433 1434 1435 1436
static void pci_remove_capabilities_sysfs(struct pci_dev *dev)
{
	if (dev->vpd && dev->vpd->attr) {
		sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr);
		kfree(dev->vpd->attr);
	}

	pcie_aspm_remove_sysfs_dev_files(dev);
1437 1438 1439 1440
	if (dev->reset_fn) {
		device_remove_file(&dev->dev, &reset_attr);
		dev->reset_fn = 0;
	}
1441 1442
}

L
Linus Torvalds 已提交
1443 1444 1445 1446 1447 1448 1449 1450
/**
 * pci_remove_sysfs_dev_files - cleanup PCI specific sysfs files
 * @pdev: device whose entries we should free
 *
 * Cleanup when @pdev is removed from sysfs.
 */
void pci_remove_sysfs_dev_files(struct pci_dev *pdev)
{
1451 1452
	int rom_size = 0;

1453 1454 1455
	if (!sysfs_initialized)
		return;

1456
	pci_remove_capabilities_sysfs(pdev);
S
Shaohua Li 已提交
1457

1458
	if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
L
Linus Torvalds 已提交
1459 1460 1461 1462 1463 1464
		sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
	else
		sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);

	pci_remove_resource_files(pdev);

1465 1466 1467 1468 1469 1470 1471 1472
	if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
		rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
	else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
		rom_size = 0x20000;

	if (rom_size && pdev->rom_attr) {
		sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
		kfree(pdev->rom_attr);
L
Linus Torvalds 已提交
1473
	}
1474 1475 1476

	pci_remove_firmware_label_files(pdev);

L
Linus Torvalds 已提交
1477 1478 1479 1480 1481
}

static int __init pci_sysfs_init(void)
{
	struct pci_dev *pdev = NULL;
1482 1483
	int retval;

L
Linus Torvalds 已提交
1484
	sysfs_initialized = 1;
1485 1486
	for_each_pci_dev(pdev) {
		retval = pci_create_sysfs_dev_files(pdev);
1487 1488
		if (retval) {
			pci_dev_put(pdev);
1489
			return retval;
1490
		}
1491
	}
L
Linus Torvalds 已提交
1492 1493 1494

	return 0;
}
1495
late_initcall(pci_sysfs_init);
1496 1497

static struct attribute *pci_dev_dev_attrs[] = {
1498
	&vga_attr.attr,
1499 1500 1501 1502
	NULL,
};

static umode_t pci_dev_attrs_are_visible(struct kobject *kobj,
R
Ryan Desfosses 已提交
1503
					 struct attribute *a, int n)
1504
{
1505 1506 1507 1508 1509 1510 1511
	struct device *dev = container_of(kobj, struct device, kobj);
	struct pci_dev *pdev = to_pci_dev(dev);

	if (a == &vga_attr.attr)
		if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
			return 0;

1512 1513 1514
	return a->mode;
}

1515 1516 1517 1518 1519 1520 1521
static struct attribute *pci_dev_hp_attrs[] = {
	&dev_remove_attr.attr,
	&dev_rescan_attr.attr,
	NULL,
};

static umode_t pci_dev_hp_attrs_are_visible(struct kobject *kobj,
R
Ryan Desfosses 已提交
1522
					    struct attribute *a, int n)
1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct pci_dev *pdev = to_pci_dev(dev);

	if (pdev->is_virtfn)
		return 0;

	return a->mode;
}

static struct attribute_group pci_dev_hp_attr_group = {
	.attrs = pci_dev_hp_attrs,
	.is_visible = pci_dev_hp_attrs_are_visible,
};

1538 1539 1540 1541 1542 1543 1544 1545
#ifdef CONFIG_PCI_IOV
static struct attribute *sriov_dev_attrs[] = {
	&sriov_totalvfs_attr.attr,
	&sriov_numvfs_attr.attr,
	NULL,
};

static umode_t sriov_attrs_are_visible(struct kobject *kobj,
R
Ryan Desfosses 已提交
1546
				       struct attribute *a, int n)
1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561
{
	struct device *dev = container_of(kobj, struct device, kobj);

	if (!dev_is_pf(dev))
		return 0;

	return a->mode;
}

static struct attribute_group sriov_dev_attr_group = {
	.attrs = sriov_dev_attrs,
	.is_visible = sriov_attrs_are_visible,
};
#endif /* CONFIG_PCI_IOV */

1562 1563 1564 1565 1566 1567 1568
static struct attribute_group pci_dev_attr_group = {
	.attrs = pci_dev_dev_attrs,
	.is_visible = pci_dev_attrs_are_visible,
};

static const struct attribute_group *pci_dev_attr_groups[] = {
	&pci_dev_attr_group,
1569
	&pci_dev_hp_attr_group,
1570 1571 1572
#ifdef CONFIG_PCI_IOV
	&sriov_dev_attr_group,
#endif
1573 1574 1575 1576 1577 1578
	NULL,
};

struct device_type pci_dev_type = {
	.groups = pci_dev_attr_groups,
};