pci-sysfs.c 38.9 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
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
Linus Torvalds's avatar
Linus Torvalds committed
14 15 16 17 18
 *
 */


#include <linux/kernel.h>
19
#include <linux/sched.h>
Linus Torvalds's avatar
Linus Torvalds committed
20 21
#include <linux/pci.h>
#include <linux/stat.h>
22
#include <linux/export.h>
Linus Torvalds's avatar
Linus Torvalds committed
23 24
#include <linux/topology.h>
#include <linux/mm.h>
25
#include <linux/fs.h>
26
#include <linux/capability.h>
27
#include <linux/security.h>
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>
Linus Torvalds's avatar
Linus Torvalds committed
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)				\
Linus Torvalds's avatar
Linus Torvalds committed
41 42 43
{									\
	struct pci_dev *pdev;						\
									\
Ryan Desfosses's avatar
Ryan Desfosses committed
44 45
	pdev = to_pci_dev(dev);						\
	return sprintf(buf, format_string, pdev->field);		\
46 47
}									\
static DEVICE_ATTR_RO(field)
Linus Torvalds's avatar
Linus Torvalds committed
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);
Ryan Desfosses's avatar
Ryan Desfosses committed
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

80
static ssize_t pci_dev_show_local_cpu(struct device *dev, bool list,
Ryan Desfosses's avatar
Ryan Desfosses committed
81
				      struct device_attribute *attr, char *buf)
82
{
83
	const struct cpumask *mask;
84

85
#ifdef CONFIG_NUMA
86 87
	mask = (dev_to_node(dev) == -1) ? cpu_online_mask :
					  cpumask_of_node(dev_to_node(dev));
88
#else
89
	mask = cpumask_of_pcibus(to_pci_dev(dev)->bus);
90
#endif
91
	return cpumap_print_to_pagebuf(list, buf, mask);
92 93
}

94
static ssize_t local_cpus_show(struct device *dev,
Ryan Desfosses's avatar
Ryan Desfosses committed
95
			       struct device_attribute *attr, char *buf)
96
{
97
	return pci_dev_show_local_cpu(dev, false, attr, buf);
98
}
99
static DEVICE_ATTR_RO(local_cpus);
100 101

static ssize_t local_cpulist_show(struct device *dev,
Ryan Desfosses's avatar
Ryan Desfosses committed
102
				  struct device_attribute *attr, char *buf)
103
{
104
	return pci_dev_show_local_cpu(dev, true, attr, buf);
Linus Torvalds's avatar
Linus Torvalds committed
105
}
106
static DEVICE_ATTR_RO(local_cpulist);
Linus Torvalds's avatar
Linus Torvalds committed
107

108 109 110
/*
 * PCI Bus Class Devices
 */
111 112
static ssize_t cpuaffinity_show(struct device *dev,
				struct device_attribute *attr, char *buf)
113
{
114 115 116
	const struct cpumask *cpumask = cpumask_of_pcibus(to_pci_bus(dev));

	return cpumap_print_to_pagebuf(false, buf, cpumask);
117
}
118
static DEVICE_ATTR_RO(cpuaffinity);
119

120 121
static ssize_t cpulistaffinity_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
122
{
123 124 125
	const struct cpumask *cpumask = cpumask_of_pcibus(to_pci_bus(dev));

	return cpumap_print_to_pagebuf(true, buf, cpumask);
126
}
127
static DEVICE_ATTR_RO(cpulistaffinity);
128

Linus Torvalds's avatar
Linus Torvalds committed
129
/* show resources */
Ryan Desfosses's avatar
Ryan Desfosses committed
130 131
static ssize_t resource_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
132
{
Ryan Desfosses's avatar
Ryan Desfosses committed
133 134
	struct pci_dev *pci_dev = to_pci_dev(dev);
	char *str = buf;
Linus Torvalds's avatar
Linus Torvalds committed
135
	int i;
136
	int max;
137
	resource_size_t start, end;
Linus Torvalds's avatar
Linus Torvalds committed
138 139 140

	if (pci_dev->subordinate)
		max = DEVICE_COUNT_RESOURCE;
141 142
	else
		max = PCI_BRIDGE_RESOURCES;
Linus Torvalds's avatar
Linus Torvalds committed
143 144

	for (i = 0; i < max; i++) {
145 146
		struct resource *res =  &pci_dev->resource[i];
		pci_resource_to_user(pci_dev, i, res, &start, &end);
Ryan Desfosses's avatar
Ryan Desfosses committed
147
		str += sprintf(str, "0x%016llx 0x%016llx 0x%016llx\n",
148 149 150
			       (unsigned long long)start,
			       (unsigned long long)end,
			       (unsigned long long)res->flags);
Linus Torvalds's avatar
Linus Torvalds committed
151 152 153
	}
	return (str - buf);
}
154
static DEVICE_ATTR_RO(resource);
Linus Torvalds's avatar
Linus Torvalds committed
155

Ryan Desfosses's avatar
Ryan Desfosses committed
156 157
static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
158 159 160
{
	struct pci_dev *pci_dev = to_pci_dev(dev);

161
	return sprintf(buf, "pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02X\n",
162 163 164 165 166
		       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));
}
167
static DEVICE_ATTR_RO(modalias);
168

169
static ssize_t enable_store(struct device *dev, struct device_attribute *attr,
Ryan Desfosses's avatar
Ryan Desfosses committed
170
			     const char *buf, size_t count)
171 172
{
	struct pci_dev *pdev = to_pci_dev(dev);
173
	unsigned long val;
174
	ssize_t result = kstrtoul(buf, 0, &val);
175 176 177

	if (result < 0)
		return result;
178 179 180

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

183
	if (!val) {
184
		if (pci_is_enabled(pdev))
185 186 187
			pci_disable_device(pdev);
		else
			result = -EIO;
188
	} else
189
		result = pci_enable_device(pdev);
190

191 192 193
	return result < 0 ? result : count;
}

194
static ssize_t enable_show(struct device *dev, struct device_attribute *attr,
Ryan Desfosses's avatar
Ryan Desfosses committed
195
			    char *buf)
196 197
{
	struct pci_dev *pdev;
198

Ryan Desfosses's avatar
Ryan Desfosses committed
199 200
	pdev = to_pci_dev(dev);
	return sprintf(buf, "%u\n", atomic_read(&pdev->enable_cnt));
201
}
202
static DEVICE_ATTR_RW(enable);
203

204
#ifdef CONFIG_NUMA
205 206 207 208 209 210 211 212 213 214 215 216 217 218
static ssize_t numa_node_store(struct device *dev,
			       struct device_attribute *attr, const char *buf,
			       size_t count)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	int node, ret;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	ret = kstrtoint(buf, 0, &node);
	if (ret)
		return ret;

219 220 221 222
	if ((node < 0 && node != NUMA_NO_NODE) || node >= MAX_NUMNODES)
		return -EINVAL;

	if (node != NUMA_NO_NODE && !node_online(node))
223 224 225 226 227 228 229 230 231 232
		return -EINVAL;

	add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
	dev_alert(&pdev->dev, FW_BUG "Overriding NUMA node to %d.  Contact your vendor for updates.",
		  node);

	dev->numa_node = node;
	return count;
}

Ryan Desfosses's avatar
Ryan Desfosses committed
233 234
static ssize_t numa_node_show(struct device *dev, struct device_attribute *attr,
			      char *buf)
235
{
Ryan Desfosses's avatar
Ryan Desfosses committed
236
	return sprintf(buf, "%d\n", dev->numa_node);
237
}
238
static DEVICE_ATTR_RW(numa_node);
239 240
#endif

Ryan Desfosses's avatar
Ryan Desfosses committed
241 242
static ssize_t dma_mask_bits_show(struct device *dev,
				  struct device_attribute *attr, char *buf)
243 244 245
{
	struct pci_dev *pdev = to_pci_dev(dev);

Ryan Desfosses's avatar
Ryan Desfosses committed
246
	return sprintf(buf, "%d\n", fls64(pdev->dma_mask));
247
}
248
static DEVICE_ATTR_RO(dma_mask_bits);
249

Ryan Desfosses's avatar
Ryan Desfosses committed
250 251 252
static ssize_t consistent_dma_mask_bits_show(struct device *dev,
					     struct device_attribute *attr,
					     char *buf)
253
{
Ryan Desfosses's avatar
Ryan Desfosses committed
254
	return sprintf(buf, "%d\n", fls64(dev->coherent_dma_mask));
255
}
256
static DEVICE_ATTR_RO(consistent_dma_mask_bits);
257

Ryan Desfosses's avatar
Ryan Desfosses committed
258 259
static ssize_t msi_bus_show(struct device *dev, struct device_attribute *attr,
			    char *buf)
260 261
{
	struct pci_dev *pdev = to_pci_dev(dev);
262
	struct pci_bus *subordinate = pdev->subordinate;
263

264 265 266
	return sprintf(buf, "%u\n", subordinate ?
		       !(subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI)
			   : !pdev->no_msi);
267 268
}

Ryan Desfosses's avatar
Ryan Desfosses committed
269 270
static ssize_t msi_bus_store(struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
271 272
{
	struct pci_dev *pdev = to_pci_dev(dev);
273
	struct pci_bus *subordinate = pdev->subordinate;
274 275
	unsigned long val;

276
	if (kstrtoul(buf, 0, &val) < 0)
277
		return -EINVAL;
278 279

	if (!capable(CAP_SYS_ADMIN))
280
		return -EPERM;
281

282
	/*
283 284 285
	 * "no_msi" and "bus_flags" only affect what happens when a driver
	 * requests MSI or MSI-X.  They don't affect any drivers that have
	 * already requested MSI or MSI-X.
286
	 */
287 288 289 290
	if (!subordinate) {
		pdev->no_msi = !val;
		dev_info(&pdev->dev, "MSI/MSI-X %s for future drivers\n",
			 val ? "allowed" : "disallowed");
291 292 293
		return count;
	}

294 295 296 297 298 299 300
	if (val)
		subordinate->bus_flags &= ~PCI_BUS_FLAGS_NO_MSI;
	else
		subordinate->bus_flags |= PCI_BUS_FLAGS_NO_MSI;

	dev_info(&subordinate->dev, "MSI/MSI-X %s for future drivers of devices on this bus\n",
		 val ? "allowed" : "disallowed");
301 302
	return count;
}
303
static DEVICE_ATTR_RW(msi_bus);
304

305 306 307 308 309 310
static ssize_t bus_rescan_store(struct bus_type *bus, const char *buf,
				size_t count)
{
	unsigned long val;
	struct pci_bus *b = NULL;

311
	if (kstrtoul(buf, 0, &val) < 0)
312 313 314
		return -EINVAL;

	if (val) {
315
		pci_lock_rescan_remove();
316 317
		while ((b = pci_find_next_bus(b)) != NULL)
			pci_rescan_bus(b);
318
		pci_unlock_rescan_remove();
319 320 321
	}
	return count;
}
322
static BUS_ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, bus_rescan_store);
323

324
static struct attribute *pci_bus_attrs[] = {
325 326 327 328 329 330 331 332 333 334 335
	&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,
336
};
337

Ryan Desfosses's avatar
Ryan Desfosses committed
338 339 340
static ssize_t dev_rescan_store(struct device *dev,
				struct device_attribute *attr, const char *buf,
				size_t count)
341 342 343 344
{
	unsigned long val;
	struct pci_dev *pdev = to_pci_dev(dev);

345
	if (kstrtoul(buf, 0, &val) < 0)
346 347 348
		return -EINVAL;

	if (val) {
349
		pci_lock_rescan_remove();
350
		pci_rescan_bus(pdev->bus);
351
		pci_unlock_rescan_remove();
352 353 354
	}
	return count;
}
355 356 357
static struct device_attribute dev_rescan_attr = __ATTR(rescan,
							(S_IWUSR|S_IWGRP),
							NULL, dev_rescan_store);
358

Ryan Desfosses's avatar
Ryan Desfosses committed
359 360
static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
361 362 363
{
	unsigned long val;

364
	if (kstrtoul(buf, 0, &val) < 0)
365 366
		return -EINVAL;

367 368
	if (val && device_remove_file_self(dev, attr))
		pci_stop_and_remove_bus_device_locked(to_pci_dev(dev));
369 370
	return count;
}
371 372 373
static struct device_attribute dev_remove_attr = __ATTR(remove,
							(S_IWUSR|S_IWGRP),
							NULL, remove_store);
374

Ryan Desfosses's avatar
Ryan Desfosses committed
375 376 377
static ssize_t dev_bus_rescan_store(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
378 379 380 381
{
	unsigned long val;
	struct pci_bus *bus = to_pci_bus(dev);

382
	if (kstrtoul(buf, 0, &val) < 0)
383 384 385
		return -EINVAL;

	if (val) {
386
		pci_lock_rescan_remove();
387 388 389 390
		if (!pci_is_root_bus(bus) && list_empty(&bus->devices))
			pci_rescan_bus_bridge_resize(bus->self);
		else
			pci_rescan_bus(bus);
391
		pci_unlock_rescan_remove();
392 393 394
	}
	return count;
}
395
static DEVICE_ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, dev_bus_rescan_store);
396

397
#if defined(CONFIG_PM) && defined(CONFIG_ACPI)
398 399 400 401 402 403 404
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;

405
	if (kstrtoul(buf, 0, &val) < 0)
406 407 408 409 410 411 412 413 414 415 416 417
		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);
Ryan Desfosses's avatar
Ryan Desfosses committed
418
	return sprintf(buf, "%u\n", pdev->d3cold_allowed);
419
}
420
static DEVICE_ATTR_RW(d3cold_allowed);
421 422
#endif

423 424 425 426 427 428 429 430 431 432 433 434 435 436
#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

437 438 439 440 441 442 443
#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);

444
	return sprintf(buf, "%u\n", pci_sriov_get_totalvfs(pdev));
445 446 447 448 449 450 451 452 453
}


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

454
	return sprintf(buf, "%u\n", pdev->sriov->num_VFs);
455 456 457
}

/*
458 459
 * num_vfs > 0; number of VFs to enable
 * num_vfs = 0; disable all VFs
460 461
 *
 * Note: SRIOV spec doesn't allow partial VF
462
 *       disable, so it's all or none.
463 464 465 466 467 468
 */
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);
469 470
	int ret;
	u16 num_vfs;
471

472 473 474 475 476 477 478 479 480
	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 */
481 482 483

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

488 489 490 491 492 493
	if (num_vfs == 0) {
		/* disable VFs */
		ret = pdev->driver->sriov_configure(pdev, 0);
		if (ret < 0)
			return ret;
		return count;
494 495
	}

496 497 498 499 500
	/* 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;
501 502
	}

503 504 505
	ret = pdev->driver->sriov_configure(pdev, num_vfs);
	if (ret < 0)
		return ret;
506

507 508 509 510 511
	if (ret != num_vfs)
		dev_warn(&pdev->dev, "%d VFs requested; only %d enabled\n",
			 num_vfs, ret);

	return count;
512 513 514 515 516 517 518 519
}

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 */

520 521 522 523 524 525 526
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;

527 528
	/* We need to keep extra room for a newline */
	if (count >= (PAGE_SIZE - 1))
529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
		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);

556
	return snprintf(buf, PAGE_SIZE, "%s\n", pdev->driver_override);
557 558 559
}
static DEVICE_ATTR_RW(driver_override);

560
static struct attribute *pci_dev_attrs[] = {
561 562 563 564 565 566 567 568 569 570
	&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,
571
#ifdef CONFIG_NUMA
572
	&dev_attr_numa_node.attr,
573
#endif
574 575
	&dev_attr_dma_mask_bits.attr,
	&dev_attr_consistent_dma_mask_bits.attr,
576
	&dev_attr_enable.attr,
577 578
	&dev_attr_broken_parity_status.attr,
	&dev_attr_msi_bus.attr,
579
#if defined(CONFIG_PM) && defined(CONFIG_ACPI)
580
	&dev_attr_d3cold_allowed.attr,
581 582 583
#endif
#ifdef CONFIG_OF
	&dev_attr_devspec.attr,
584
#endif
585
	&dev_attr_driver_override.attr,
586 587 588 589 590 591 592 593 594 595
	NULL,
};

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

const struct attribute_group *pci_dev_groups[] = {
	&pci_dev_group,
	NULL,
Linus Torvalds's avatar
Linus Torvalds committed
596 597
};

598 599 600 601 602 603 604 605 606 607 608 609 610 611
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,
612 613
};

Ryan Desfosses's avatar
Ryan Desfosses committed
614 615
static ssize_t boot_vga_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
616 617
{
	struct pci_dev *pdev = to_pci_dev(dev);
618 619 620 621
	struct pci_dev *vga_dev = vga_default_device();

	if (vga_dev)
		return sprintf(buf, "%u\n", (pdev == vga_dev));
622 623 624 625 626

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

Ryan Desfosses's avatar
Ryan Desfosses committed
629 630 631
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)
Linus Torvalds's avatar
Linus Torvalds committed
632
{
633
	struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj));
Linus Torvalds's avatar
Linus Torvalds committed
634 635
	unsigned int size = 64;
	loff_t init_off = off;
Ryan Desfosses's avatar
Ryan Desfosses committed
636
	u8 *data = (u8 *) buf;
Linus Torvalds's avatar
Linus Torvalds committed
637 638

	/* Several chips lock up trying to read undefined config space */
Ryan Desfosses's avatar
Ryan Desfosses committed
639
	if (security_capable(filp->f_cred, &init_user_ns, CAP_SYS_ADMIN) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
640
		size = dev->cfg_size;
Ryan Desfosses's avatar
Ryan Desfosses committed
641
	else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
Linus Torvalds's avatar
Linus Torvalds committed
642 643 644 645 646 647 648 649 650 651 652
		size = 128;

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

653 654
	pci_config_pm_runtime_get(dev);

655 656
	if ((off & 1) && size) {
		u8 val;
657
		pci_user_read_config_byte(dev, off, &val);
658
		data[off - init_off] = val;
Linus Torvalds's avatar
Linus Torvalds committed
659
		off++;
660 661 662 663 664
		size--;
	}

	if ((off & 3) && size > 2) {
		u16 val;
665
		pci_user_read_config_word(dev, off, &val);
666 667 668 669
		data[off - init_off] = val & 0xff;
		data[off - init_off + 1] = (val >> 8) & 0xff;
		off += 2;
		size -= 2;
Linus Torvalds's avatar
Linus Torvalds committed
670 671 672
	}

	while (size > 3) {
673
		u32 val;
674
		pci_user_read_config_dword(dev, off, &val);
675 676 677 678
		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;
Linus Torvalds's avatar
Linus Torvalds committed
679 680 681 682
		off += 4;
		size -= 4;
	}

683 684
	if (size >= 2) {
		u16 val;
685
		pci_user_read_config_word(dev, off, &val);
686 687 688 689 690 691 692 693
		data[off - init_off] = val & 0xff;
		data[off - init_off + 1] = (val >> 8) & 0xff;
		off += 2;
		size -= 2;
	}

	if (size > 0) {
		u8 val;
694
		pci_user_read_config_byte(dev, off, &val);
695
		data[off - init_off] = val;
Linus Torvalds's avatar
Linus Torvalds committed
696 697 698 699
		off++;
		--size;
	}

700 701
	pci_config_pm_runtime_put(dev);

Linus Torvalds's avatar
Linus Torvalds committed
702 703 704
	return count;
}

Ryan Desfosses's avatar
Ryan Desfosses committed
705 706 707
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)
Linus Torvalds's avatar
Linus Torvalds committed
708
{
709
	struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj));
Linus Torvalds's avatar
Linus Torvalds committed
710 711
	unsigned int size = count;
	loff_t init_off = off;
Ryan Desfosses's avatar
Ryan Desfosses committed
712
	u8 *data = (u8 *) buf;
Linus Torvalds's avatar
Linus Torvalds committed
713 714 715 716 717 718 719

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

721 722
	pci_config_pm_runtime_get(dev);

723
	if ((off & 1) && size) {
724
		pci_user_write_config_byte(dev, off, data[off - init_off]);
Linus Torvalds's avatar
Linus Torvalds committed
725
		off++;
726
		size--;
Linus Torvalds's avatar
Linus Torvalds committed
727
	}
728

729 730 731
	if ((off & 3) && size > 2) {
		u16 val = data[off - init_off];
		val |= (u16) data[off - init_off + 1] << 8;
Ryan Desfosses's avatar
Ryan Desfosses committed
732 733 734 735
		pci_user_write_config_word(dev, off, val);
		off += 2;
		size -= 2;
	}
Linus Torvalds's avatar
Linus Torvalds committed
736 737

	while (size > 3) {
738 739 740 741
		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;
742
		pci_user_write_config_dword(dev, off, val);
Linus Torvalds's avatar
Linus Torvalds committed
743 744 745
		off += 4;
		size -= 4;
	}
746

747 748 749
	if (size >= 2) {
		u16 val = data[off - init_off];
		val |= (u16) data[off - init_off + 1] << 8;
750
		pci_user_write_config_word(dev, off, val);
751 752 753
		off += 2;
		size -= 2;
	}
Linus Torvalds's avatar
Linus Torvalds committed
754

755
	if (size) {
756
		pci_user_write_config_byte(dev, off, data[off - init_off]);
Linus Torvalds's avatar
Linus Torvalds committed
757 758 759 760
		off++;
		--size;
	}

761 762
	pci_config_pm_runtime_put(dev);

Linus Torvalds's avatar
Linus Torvalds committed
763 764 765
	return count;
}

Ryan Desfosses's avatar
Ryan Desfosses committed
766 767 768
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)
769
{
770
	struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj));
771

772 773 774 775 776 777
	if (bin_attr->size > 0) {
		if (off > bin_attr->size)
			count = 0;
		else if (count > bin_attr->size - off)
			count = bin_attr->size - off;
	}
778

779
	return pci_read_vpd(dev, off, count, buf);
780 781
}

Ryan Desfosses's avatar
Ryan Desfosses committed
782 783 784
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)
785
{
786
	struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj));
787

788 789 790 791 792 793
	if (bin_attr->size > 0) {
		if (off > bin_attr->size)
			count = 0;
		else if (count > bin_attr->size - off)
			count = bin_attr->size - off;
	}
794

795
	return pci_write_vpd(dev, off, count, buf);
796 797
}

Linus Torvalds's avatar
Linus Torvalds committed
798 799 800
#ifdef HAVE_PCI_LEGACY
/**
 * pci_read_legacy_io - read byte(s) from legacy I/O port space
801
 * @filp: open sysfs file
Linus Torvalds's avatar
Linus Torvalds committed
802
 * @kobj: kobject corresponding to file to read from
803
 * @bin_attr: struct bin_attribute for this file
Linus Torvalds's avatar
Linus Torvalds committed
804 805 806 807 808 809 810
 * @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).
 */
Ryan Desfosses's avatar
Ryan Desfosses committed
811 812 813
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)
Linus Torvalds's avatar
Linus Torvalds committed
814
{
815
	struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj));
Linus Torvalds's avatar
Linus Torvalds committed
816

Ryan Desfosses's avatar
Ryan Desfosses committed
817 818 819
	/* Only support 1, 2 or 4 byte accesses */
	if (count != 1 && count != 2 && count != 4)
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
820

Ryan Desfosses's avatar
Ryan Desfosses committed
821
	return pci_legacy_read(bus, off, (u32 *)buf, count);
Linus Torvalds's avatar
Linus Torvalds committed
822 823 824 825
}

/**
 * pci_write_legacy_io - write byte(s) to legacy I/O port space
826
 * @filp: open sysfs file
Linus Torvalds's avatar
Linus Torvalds committed
827
 * @kobj: kobject corresponding to file to read from
828
 * @bin_attr: struct bin_attribute for this file
Linus Torvalds's avatar
Linus Torvalds committed
829 830 831 832 833 834 835
 * @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).
 */
Ryan Desfosses's avatar
Ryan Desfosses committed
836 837 838
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)
Linus Torvalds's avatar
Linus Torvalds committed
839
{
840
	struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj));
Linus Torvalds's avatar
Linus Torvalds committed
841

Ryan Desfosses's avatar
Ryan Desfosses committed
842 843 844 845 846
	/* 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);
Linus Torvalds's avatar
Linus Torvalds committed
847 848 849 850
}

/**
 * pci_mmap_legacy_mem - map legacy PCI memory into user memory space
851
 * @filp: open sysfs file
Linus Torvalds's avatar
Linus Torvalds committed
852 853 854 855
 * @kobj: kobject corresponding to device to be mapped
 * @attr: struct bin_attribute for this file
 * @vma: struct vm_area_struct passed to mmap
 *
856
 * Uses an arch specific callback, pci_mmap_legacy_mem_page_range, to mmap
Linus Torvalds's avatar
Linus Torvalds committed
857 858 859
 * legacy memory space (first meg of bus space) into application virtual
 * memory space.
 */
Ryan Desfosses's avatar
Ryan Desfosses committed
860 861 862
static int pci_mmap_legacy_mem(struct file *filp, struct kobject *kobj,
			       struct bin_attribute *attr,
			       struct vm_area_struct *vma)
Linus Torvalds's avatar
Linus Torvalds committed
863
{
864
	struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj));
Linus Torvalds's avatar
Linus Torvalds committed
865

Ryan Desfosses's avatar
Ryan Desfosses committed
866
	return pci_mmap_legacy_page_range(bus, vma, pci_mmap_mem);
867 868 869 870
}

/**
 * pci_mmap_legacy_io - map legacy PCI IO into user memory space
871
 * @filp: open sysfs file
872 873 874 875 876 877 878 879
 * @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
 */
Ryan Desfosses's avatar
Ryan Desfosses committed
880 881 882
static int pci_mmap_legacy_io(struct file *filp, struct kobject *kobj,
			      struct bin_attribute *attr,
			      struct vm_area_struct *vma)
883
{
884
	struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj));
885

Ryan Desfosses's avatar
Ryan Desfosses committed
886
	return pci_mmap_legacy_page_range(bus, vma, pci_mmap_io);
887 888
}

889 890 891 892 893 894 895
/**
 * 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.
 */
Ryan Desfosses's avatar
Ryan Desfosses committed
896 897
void __weak pci_adjust_legacy_attr(struct pci_bus *b,
				   enum pci_mmap_state mmap_type)
898 899 900
{
}

901 902 903 904 905 906 907 908
/**
 * 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
 *
909
 * On error unwind, but don't propagate the error to the caller
910 911 912 913 914 915 916 917 918 919 920
 * 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;

921
	sysfs_bin_attr_init(b->legacy_io);
922 923 924 925 926 927
	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;
928
	pci_adjust_legacy_attr(b, pci_mmap_io);
929 930 931 932 933 934
	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;
935
	sysfs_bin_attr_init(b->legacy_mem);
936 937 938 939
	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;
940
	pci_adjust_legacy_attr(b, pci_mmap_mem);
941 942 943 944 945 946 947 948 949 950 951 952
	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:
953
	printk(KERN_WARNING "pci: warning: could not create legacy I/O port and ISA memory resources to sysfs\n");
954 955 956 957 958 959 960 961 962 963
	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 */
	}
Linus Torvalds's avatar
Linus Torvalds committed
964 965 966 967
}
#endif /* HAVE_PCI_LEGACY */

#ifdef HAVE_PCI_MMAP
968

969 970
int pci_mmap_fits(struct pci_dev *pdev, int resno, struct vm_area_struct *vma,
		  enum pci_mmap_api mmap_api)
971
{
972
	unsigned long nr, start, size, pci_start;
973

974 975
	if (pci_resource_len(pdev, resno) == 0)
		return 0;
976
	nr = vma_pages(vma);
977
	start = vma->vm_pgoff;
978
	size = ((pci_resource_len(pdev, resno) - 1) >> PAGE_SHIFT) + 1;
979
	pci_start = (mmap_api == PCI_MMAP_PROCFS) ?
980 981 982
			pci_resource_start(pdev, resno) >> PAGE_SHIFT : 0;
	if (start >= pci_start && start < pci_start + size &&
			start + nr <= pci_start + size)
983 984 985 986
		return 1;
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
987 988 989 990 991
/**
 * 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
992
 * @write_combine: 1 for write_combine mapping
Linus Torvalds's avatar
Linus Torvalds committed
993 994 995
 *
 * Use the regular PCI mapping routines to map a PCI resource into userspace.
 */
Ryan Desfosses's avatar
Ryan Desfosses committed
996 997
static int pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,
			     struct vm_area_struct *vma, int write_combine)
Linus Torvalds's avatar
Linus Torvalds committed
998
{
999
	struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj));
1000
	struct resource *res = attr->private;
Linus Torvalds's avatar
Linus Torvalds committed
1001
	enum pci_mmap_state mmap_type;
1002
	resource_size_t start, end;
1003
	int i;
Linus Torvalds's avatar
Linus Torvalds committed
1004

1005 1006 1007 1008 1009 1010
	for (i = 0; i < PCI_ROM_RESOURCE; i++)
		if (res == &pdev->resource[i])
			break;
	if (i >= PCI_ROM_RESOURCE)
		return -ENODEV;

1011
	if (!pci_mmap_fits(pdev, i, vma, PCI_MMAP_SYSFS)) {
1012
		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",
1013 1014
			current->comm, vma->vm_end-vma->vm_start, vma->vm_pgoff,
			pci_name(pdev), i,
1015 1016
			(u64)pci_resource_start(pdev, i),
			(u64)pci_resource_len(pdev, i));
1017
		return -EINVAL;
1018
	}
1019

1020 1021 1022 1023 1024 1025
	/* 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;
Linus Torvalds's avatar
Linus Torvalds committed
1026 1027
	mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io;

1028 1029 1030
	if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(start))
		return -EINVAL;

1031 1032 1033
	return pci_mmap_page_range(pdev, vma, mmap_type, write_combine);
}

Ryan Desfosses's avatar
Ryan Desfosses committed
1034 1035 1036
static int pci_mmap_resource_uc(struct file *filp, struct kobject *kobj,
				struct bin_attribute *attr,
				struct vm_area_struct *vma)
1037 1038 1039 1040
{
	return pci_mmap_resource(kobj, attr, vma, 0);
}

Ryan Desfosses's avatar
Ryan Desfosses committed
1041 1042 1043
static int pci_mmap_resource_wc(struct file *filp, struct kobject *kobj,
				struct bin_attribute *attr,
				struct vm_area_struct *vma)
1044 1045
{
	return pci_mmap_resource(kobj, attr, vma, 1);
Linus Torvalds's avatar
Linus Torvalds committed
1046 1047
}

Ryan Desfosses's avatar
Ryan Desfosses committed
1048 1049 1050
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)
1051
{
1052
	struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj));
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 1091 1092 1093
	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;
}

Ryan Desfosses's avatar
Ryan Desfosses committed
1094 1095 1096
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)
1097 1098 1099 1100
{
	return pci_resource_io(filp, kobj, attr, buf, off, count, false);
}

Ryan Desfosses's avatar
Ryan Desfosses committed
1101 1102 1103
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)
1104 1105 1106 1107
{
	return pci_resource_io(filp, kobj, attr, buf, off, count, true);
}

1108 1109
/**
 * pci_remove_resource_files - cleanup resource files
1110
 * @pdev: dev to cleanup
1111
 *
1112
 * If we created resource files for @pdev, remove them from sysfs and
1113 1114
 * free their resources.
 */
Ryan Desfosses's avatar
Ryan Desfosses committed
1115
static void pci_remove_resource_files(struct pci_dev *pdev)
1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126
{
	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);
		}
1127 1128 1129 1130 1131 1132

		res_attr = pdev->res_attr_wc[i];
		if (res_attr) {
			sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
			kfree(res_attr);
		}
1133 1134 1135
	}
}

1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
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);

1147
		sysfs_bin_attr_init(res_attr);
1148 1149 1150 1151 1152 1153 1154 1155 1156
		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;
		}
1157 1158 1159 1160
		if (pci_resource_flags(pdev, num) & IORESOURCE_IO) {
			res_attr->read = pci_read_resource_io;
			res_attr->write = pci_write_resource_io;
		}
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
		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;
}

Linus Torvalds's avatar
Linus Torvalds committed
1172 1173
/**
 * pci_create_resource_files - create resource files in sysfs for @dev
1174
 * @pdev: dev in question
Linus Torvalds's avatar
Linus Torvalds committed
1175
 *
1176
 * Walk the resources in @pdev creating files for each resource available.
Linus Torvalds's avatar
Linus Torvalds committed
1177
 */
1178
static int pci_create_resource_files(struct pci_dev *pdev)
Linus Torvalds's avatar
Linus Torvalds committed
1179 1180
{
	int i;
1181
	int retval;
Linus Torvalds's avatar
Linus Torvalds committed
1182 1183 1184 1185 1186 1187 1188 1189

	/* 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;

1190 1191 1192 1193 1194 1195 1196 1197
		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;
Linus Torvalds's avatar
Linus Torvalds committed
1198 1199
		}
	}
1200
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1201 1202
}
#else /* !HAVE_PCI_MMAP */
1203 1204
int __weak pci_create_resource_files(struct pci_dev *dev) { return 0; }
void __weak pci_remove_resource_files(struct pci_dev *dev) { return; }
Linus Torvalds's avatar
Linus Torvalds committed
1205 1206 1207 1208
#endif /* HAVE_PCI_MMAP */

/**
 * pci_write_rom - used to enable access to the PCI ROM display
1209
 * @filp: sysfs file
Linus Torvalds's avatar
Linus Torvalds committed
1210
 * @kobj: kernel object handle
1211
 * @bin_attr: struct bin_attribute for this file
Linus Torvalds's avatar
Linus Torvalds committed
1212 1213 1214 1215 1216 1217
 * @buf: user input
 * @off: file offset
 * @count: number of byte in input
 *
 * writing anything except 0 enables it
 */
Ryan Desfosses's avatar
Ryan Desfosses committed
1218 1219 1220
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)
Linus Torvalds's avatar
Linus Torvalds committed
1221
{
1222
	struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj));
Linus Torvalds's avatar
Linus Torvalds committed
1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233

	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
1234
 * @filp: sysfs file
Linus Torvalds's avatar
Linus Torvalds committed
1235
 * @kobj: kernel object handle
1236
 * @bin_attr: struct bin_attribute for this file
Linus Torvalds's avatar
Linus Torvalds committed
1237 1238 1239 1240 1241 1242 1243
 * @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.
 */
Ryan Desfosses's avatar
Ryan Desfosses committed
1244 1245 1246
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)
Linus Torvalds's avatar
Linus Torvalds committed
1247
{
1248
	struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj));
Linus Torvalds's avatar
Linus Torvalds committed
1249 1250 1251 1252 1253
	void __iomem *rom;
	size_t size;

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

Linus Torvalds's avatar
Linus Torvalds committed
1255
	rom = pci_map_rom(pdev, &size);	/* size starts out as PCI window size */
1256 1257
	if (!rom || !size)
		return -EIO;
1258

Linus Torvalds's avatar
Linus Torvalds committed
1259 1260 1261 1262 1263
	if (off >= size)
		count = 0;
	else {
		if (off + count > size)
			count = size - off;
1264

Linus Torvalds's avatar
Linus Torvalds committed
1265 1266 1267
		memcpy_fromio(buf, rom + off, count);
	}
	pci_unmap_rom(pdev, rom);
1268

Linus Torvalds's avatar
Linus Torvalds committed
1269 1270 1271 1272 1273 1274 1275 1276
	return count;
}

static struct bin_attribute pci_config_attr = {
	.attr =	{
		.name = "config",
		.mode = S_IRUGO | S_IWUSR,
	},
1277
	.size = PCI_CFG_SPACE_SIZE,
Linus Torvalds's avatar
Linus Torvalds committed
1278 1279 1280 1281 1282 1283 1284 1285 1286
	.read = pci_read_config,
	.write = pci_write_config,
};

static struct bin_attribute pcie_config_attr = {
	.attr =	{
		.name = "config",
		.mode = S_IRUGO | S_IWUSR,
	},
1287
	.size = PCI_CFG_SPACE_EXP_SIZE,
Linus Torvalds's avatar
Linus Torvalds committed
1288 1289 1290 1291
	.read = pci_read_config,
	.write = pci_write_config,
};

Ryan Desfosses's avatar
Ryan Desfosses committed
1292 1293
static ssize_t reset_store(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
1294 1295 1296
{
	struct pci_dev *pdev = to_pci_dev(dev);
	unsigned long val;
1297
	ssize_t result = kstrtoul(buf, 0, &val);
1298 1299 1300 1301 1302 1303

	if (result <