pci-sysfs.c 43.5 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

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");
53
pci_config_attr(revision, "0x%02x\n");
Linus Torvalds's avatar
Linus Torvalds committed
54 55 56
pci_config_attr(class, "0x%06x\n");
pci_config_attr(irq, "%u\n");

57 58 59 60 61
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
62
	return sprintf(buf, "%u\n", pdev->broken_parity_status);
63 64 65 66 67 68 69
}

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);
70
	unsigned long val;
71

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

	pdev->broken_parity_status = !!val;

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

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

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
	return cpumap_print_to_pagebuf(list, buf, mask);
93 94
}

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

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

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

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

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

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

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

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

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

157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
static ssize_t max_link_speed_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct pci_dev *pci_dev = to_pci_dev(dev);
	u32 linkcap;
	int err;
	const char *speed;

	err = pcie_capability_read_dword(pci_dev, PCI_EXP_LNKCAP, &linkcap);
	if (err)
		return -EINVAL;

	switch (linkcap & PCI_EXP_LNKCAP_SLS) {
	case PCI_EXP_LNKCAP_SLS_8_0GB:
		speed = "8 GT/s";
		break;
	case PCI_EXP_LNKCAP_SLS_5_0GB:
		speed = "5 GT/s";
		break;
	case PCI_EXP_LNKCAP_SLS_2_5GB:
		speed = "2.5 GT/s";
		break;
	default:
		speed = "Unknown speed";
	}

	return sprintf(buf, "%s\n", speed);
}
static DEVICE_ATTR_RO(max_link_speed);

static ssize_t max_link_width_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct pci_dev *pci_dev = to_pci_dev(dev);
	u32 linkcap;
	int err;

	err = pcie_capability_read_dword(pci_dev, PCI_EXP_LNKCAP, &linkcap);
	if (err)
		return -EINVAL;

	return sprintf(buf, "%u\n", (linkcap & PCI_EXP_LNKCAP_MLW) >> 4);
}
static DEVICE_ATTR_RO(max_link_width);

static ssize_t current_link_speed_show(struct device *dev,
				       struct device_attribute *attr, char *buf)
{
	struct pci_dev *pci_dev = to_pci_dev(dev);
	u16 linkstat;
	int err;
	const char *speed;

	err = pcie_capability_read_word(pci_dev, PCI_EXP_LNKSTA, &linkstat);
	if (err)
		return -EINVAL;

	switch (linkstat & PCI_EXP_LNKSTA_CLS) {
	case PCI_EXP_LNKSTA_CLS_8_0GB:
		speed = "8 GT/s";
		break;
	case PCI_EXP_LNKSTA_CLS_5_0GB:
		speed = "5 GT/s";
		break;
	case PCI_EXP_LNKSTA_CLS_2_5GB:
		speed = "2.5 GT/s";
		break;
	default:
		speed = "Unknown speed";
	}

	return sprintf(buf, "%s\n", speed);
}
static DEVICE_ATTR_RO(current_link_speed);

static ssize_t current_link_width_show(struct device *dev,
				       struct device_attribute *attr, char *buf)
{
	struct pci_dev *pci_dev = to_pci_dev(dev);
	u16 linkstat;
	int err;

	err = pcie_capability_read_word(pci_dev, PCI_EXP_LNKSTA, &linkstat);
	if (err)
		return -EINVAL;

	return sprintf(buf, "%u\n",
		(linkstat & PCI_EXP_LNKSTA_NLW) >> PCI_EXP_LNKSTA_NLW_SHIFT);
}
static DEVICE_ATTR_RO(current_link_width);

static ssize_t secondary_bus_number_show(struct device *dev,
					 struct device_attribute *attr,
					 char *buf)
{
	struct pci_dev *pci_dev = to_pci_dev(dev);
	u8 sec_bus;
	int err;

	err = pci_read_config_byte(pci_dev, PCI_SECONDARY_BUS, &sec_bus);
	if (err)
		return -EINVAL;

	return sprintf(buf, "%u\n", sec_bus);
}
static DEVICE_ATTR_RO(secondary_bus_number);

static ssize_t subordinate_bus_number_show(struct device *dev,
					   struct device_attribute *attr,
					   char *buf)
{
	struct pci_dev *pci_dev = to_pci_dev(dev);
	u8 sub_bus;
	int err;

	err = pci_read_config_byte(pci_dev, PCI_SUBORDINATE_BUS, &sub_bus);
	if (err)
		return -EINVAL;

	return sprintf(buf, "%u\n", sub_bus);
}
static DEVICE_ATTR_RO(subordinate_bus_number);

Ryan Desfosses's avatar
Ryan Desfosses committed
280 281
static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
282 283 284
{
	struct pci_dev *pci_dev = to_pci_dev(dev);

285
	return sprintf(buf, "pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02X\n",
286 287 288 289 290
		       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));
}
291
static DEVICE_ATTR_RO(modalias);
292

293
static ssize_t enable_store(struct device *dev, struct device_attribute *attr,
Ryan Desfosses's avatar
Ryan Desfosses committed
294
			     const char *buf, size_t count)
295 296
{
	struct pci_dev *pdev = to_pci_dev(dev);
297
	unsigned long val;
298
	ssize_t result = kstrtoul(buf, 0, &val);
299 300 301

	if (result < 0)
		return result;
302 303 304

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

307
	if (!val) {
308
		if (pci_is_enabled(pdev))
309 310 311
			pci_disable_device(pdev);
		else
			result = -EIO;
312
	} else
313
		result = pci_enable_device(pdev);
314

315 316 317
	return result < 0 ? result : count;
}

318
static ssize_t enable_show(struct device *dev, struct device_attribute *attr,
Ryan Desfosses's avatar
Ryan Desfosses committed
319
			    char *buf)
320 321
{
	struct pci_dev *pdev;
322

Ryan Desfosses's avatar
Ryan Desfosses committed
323 324
	pdev = to_pci_dev(dev);
	return sprintf(buf, "%u\n", atomic_read(&pdev->enable_cnt));
325
}
326
static DEVICE_ATTR_RW(enable);
327

328
#ifdef CONFIG_NUMA
329 330 331 332 333 334 335 336 337 338 339 340 341 342
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;

343 344 345 346
	if ((node < 0 && node != NUMA_NO_NODE) || node >= MAX_NUMNODES)
		return -EINVAL;

	if (node != NUMA_NO_NODE && !node_online(node))
347 348 349 350 351 352 353 354 355 356
		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
357 358
static ssize_t numa_node_show(struct device *dev, struct device_attribute *attr,
			      char *buf)
359
{
Ryan Desfosses's avatar
Ryan Desfosses committed
360
	return sprintf(buf, "%d\n", dev->numa_node);
361
}
362
static DEVICE_ATTR_RW(numa_node);
363 364
#endif

Ryan Desfosses's avatar
Ryan Desfosses committed
365 366
static ssize_t dma_mask_bits_show(struct device *dev,
				  struct device_attribute *attr, char *buf)
Yinghai Lu's avatar
Yinghai Lu committed
367 368 369
{
	struct pci_dev *pdev = to_pci_dev(dev);

Ryan Desfosses's avatar
Ryan Desfosses committed
370
	return sprintf(buf, "%d\n", fls64(pdev->dma_mask));
Yinghai Lu's avatar
Yinghai Lu committed
371
}
372
static DEVICE_ATTR_RO(dma_mask_bits);
Yinghai Lu's avatar
Yinghai Lu committed
373

Ryan Desfosses's avatar
Ryan Desfosses committed
374 375 376
static ssize_t consistent_dma_mask_bits_show(struct device *dev,
					     struct device_attribute *attr,
					     char *buf)
Yinghai Lu's avatar
Yinghai Lu committed
377
{
Ryan Desfosses's avatar
Ryan Desfosses committed
378
	return sprintf(buf, "%d\n", fls64(dev->coherent_dma_mask));
Yinghai Lu's avatar
Yinghai Lu committed
379
}
380
static DEVICE_ATTR_RO(consistent_dma_mask_bits);
Yinghai Lu's avatar
Yinghai Lu committed
381

Ryan Desfosses's avatar
Ryan Desfosses committed
382 383
static ssize_t msi_bus_show(struct device *dev, struct device_attribute *attr,
			    char *buf)
384 385
{
	struct pci_dev *pdev = to_pci_dev(dev);
386
	struct pci_bus *subordinate = pdev->subordinate;
387

388 389 390
	return sprintf(buf, "%u\n", subordinate ?
		       !(subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI)
			   : !pdev->no_msi);
391 392
}

Ryan Desfosses's avatar
Ryan Desfosses committed
393 394
static ssize_t msi_bus_store(struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
395 396
{
	struct pci_dev *pdev = to_pci_dev(dev);
397
	struct pci_bus *subordinate = pdev->subordinate;
398 399
	unsigned long val;

400
	if (kstrtoul(buf, 0, &val) < 0)
401
		return -EINVAL;
402 403

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

406
	/*
407 408 409
	 * "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.
410
	 */
411 412 413 414
	if (!subordinate) {
		pdev->no_msi = !val;
		dev_info(&pdev->dev, "MSI/MSI-X %s for future drivers\n",
			 val ? "allowed" : "disallowed");
415 416 417
		return count;
	}

418 419 420 421 422 423 424
	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");
425 426
	return count;
}
427
static DEVICE_ATTR_RW(msi_bus);
428

429 430 431 432 433 434
static ssize_t bus_rescan_store(struct bus_type *bus, const char *buf,
				size_t count)
{
	unsigned long val;
	struct pci_bus *b = NULL;

435
	if (kstrtoul(buf, 0, &val) < 0)
436 437 438
		return -EINVAL;

	if (val) {
439
		pci_lock_rescan_remove();
440 441
		while ((b = pci_find_next_bus(b)) != NULL)
			pci_rescan_bus(b);
442
		pci_unlock_rescan_remove();
443 444 445
	}
	return count;
}
446
static BUS_ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, bus_rescan_store);
447

448
static struct attribute *pci_bus_attrs[] = {
449 450 451 452 453 454 455 456 457 458 459
	&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,
460
};
461

Ryan Desfosses's avatar
Ryan Desfosses committed
462 463 464
static ssize_t dev_rescan_store(struct device *dev,
				struct device_attribute *attr, const char *buf,
				size_t count)
465 466 467 468
{
	unsigned long val;
	struct pci_dev *pdev = to_pci_dev(dev);

469
	if (kstrtoul(buf, 0, &val) < 0)
470 471 472
		return -EINVAL;

	if (val) {
473
		pci_lock_rescan_remove();
474
		pci_rescan_bus(pdev->bus);
475
		pci_unlock_rescan_remove();
476 477 478
	}
	return count;
}
479 480 481
static struct device_attribute dev_rescan_attr = __ATTR(rescan,
							(S_IWUSR|S_IWGRP),
							NULL, dev_rescan_store);
482

Ryan Desfosses's avatar
Ryan Desfosses committed
483 484
static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
485 486 487
{
	unsigned long val;

488
	if (kstrtoul(buf, 0, &val) < 0)
489 490
		return -EINVAL;

491 492
	if (val && device_remove_file_self(dev, attr))
		pci_stop_and_remove_bus_device_locked(to_pci_dev(dev));
493 494
	return count;
}
495 496 497
static struct device_attribute dev_remove_attr = __ATTR(remove,
							(S_IWUSR|S_IWGRP),
							NULL, remove_store);
498

Ryan Desfosses's avatar
Ryan Desfosses committed
499 500 501
static ssize_t dev_bus_rescan_store(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
502 503 504 505
{
	unsigned long val;
	struct pci_bus *bus = to_pci_bus(dev);

506
	if (kstrtoul(buf, 0, &val) < 0)
507 508 509
		return -EINVAL;

	if (val) {
510
		pci_lock_rescan_remove();
511 512 513 514
		if (!pci_is_root_bus(bus) && list_empty(&bus->devices))
			pci_rescan_bus_bridge_resize(bus->self);
		else
			pci_rescan_bus(bus);
515
		pci_unlock_rescan_remove();
516 517 518
	}
	return count;
}
519
static DEVICE_ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, dev_bus_rescan_store);
520

521
#if defined(CONFIG_PM) && defined(CONFIG_ACPI)
522 523 524 525 526 527 528
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;

529
	if (kstrtoul(buf, 0, &val) < 0)
530 531 532
		return -EINVAL;

	pdev->d3cold_allowed = !!val;
533 534 535 536 537
	if (pdev->d3cold_allowed)
		pci_d3cold_enable(pdev);
	else
		pci_d3cold_disable(pdev);

538 539 540 541 542 543 544 545 546
	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
547
	return sprintf(buf, "%u\n", pdev->d3cold_allowed);
548
}
549
static DEVICE_ATTR_RW(d3cold_allowed);
550 551
#endif

552 553 554 555 556 557 558
#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);

559
	if (np == NULL)
560
		return 0;
561
	return sprintf(buf, "%pOF", np);
562 563 564 565
}
static DEVICE_ATTR_RO(devspec);
#endif

566 567 568 569 570 571 572
#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);

573
	return sprintf(buf, "%u\n", pci_sriov_get_totalvfs(pdev));
574 575 576 577 578 579 580 581 582
}


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

583
	return sprintf(buf, "%u\n", pdev->sriov->num_VFs);
584 585 586
}

/*
587 588
 * num_vfs > 0; number of VFs to enable
 * num_vfs = 0; disable all VFs
589 590
 *
 * Note: SRIOV spec doesn't allow partial VF
591
 *       disable, so it's all or none.
592 593 594 595 596 597
 */
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);
598 599
	int ret;
	u16 num_vfs;
600

601 602 603 604 605 606 607
	ret = kstrtou16(buf, 0, &num_vfs);
	if (ret < 0)
		return ret;

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

608
	device_lock(&pdev->dev);
609

610
	if (num_vfs == pdev->sriov->num_VFs)
611
		goto exit;
612 613 614

	/* is PF driver loaded w/callback */
	if (!pdev->driver || !pdev->driver->sriov_configure) {
615
		dev_info(&pdev->dev, "Driver doesn't support SRIOV configuration via sysfs\n");
616 617
		ret = -ENOENT;
		goto exit;
618 619
	}

620 621 622
	if (num_vfs == 0) {
		/* disable VFs */
		ret = pdev->driver->sriov_configure(pdev, 0);
623
		goto exit;
624 625
	}

626 627 628 629
	/* 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);
630 631
		ret = -EBUSY;
		goto exit;
632 633
	}

634 635
	ret = pdev->driver->sriov_configure(pdev, num_vfs);
	if (ret < 0)
636
		goto exit;
637

638 639 640 641
	if (ret != num_vfs)
		dev_warn(&pdev->dev, "%d VFs requested; only %d enabled\n",
			 num_vfs, ret);

642
exit:
643
	device_unlock(&pdev->dev);
644 645 646 647

	if (ret < 0)
		return ret;

648
	return count;
649 650
}

651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
static ssize_t sriov_drivers_autoprobe_show(struct device *dev,
					    struct device_attribute *attr,
					    char *buf)
{
	struct pci_dev *pdev = to_pci_dev(dev);

	return sprintf(buf, "%u\n", pdev->sriov->drivers_autoprobe);
}

static ssize_t sriov_drivers_autoprobe_store(struct device *dev,
					     struct device_attribute *attr,
					     const char *buf, size_t count)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	bool drivers_autoprobe;

	if (kstrtobool(buf, &drivers_autoprobe) < 0)
		return -EINVAL;

	pdev->sriov->drivers_autoprobe = drivers_autoprobe;

	return count;
}

675 676 677 678
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);
679 680 681
static struct device_attribute sriov_drivers_autoprobe_attr =
		__ATTR(sriov_drivers_autoprobe, (S_IRUGO|S_IWUSR|S_IWGRP),
		       sriov_drivers_autoprobe_show, sriov_drivers_autoprobe_store);
682 683
#endif /* CONFIG_PCI_IOV */

684 685 686 687 688 689 690
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;

691 692
	/* We need to keep extra room for a newline */
	if (count >= (PAGE_SIZE - 1))
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
		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);

720
	return snprintf(buf, PAGE_SIZE, "%s\n", pdev->driver_override);
721 722 723
}
static DEVICE_ATTR_RW(driver_override);

724
static struct attribute *pci_dev_attrs[] = {
725 726 727 728 729
	&dev_attr_resource.attr,
	&dev_attr_vendor.attr,
	&dev_attr_device.attr,
	&dev_attr_subsystem_vendor.attr,
	&dev_attr_subsystem_device.attr,
730
	&dev_attr_revision.attr,
731 732 733 734 735
	&dev_attr_class.attr,
	&dev_attr_irq.attr,
	&dev_attr_local_cpus.attr,
	&dev_attr_local_cpulist.attr,
	&dev_attr_modalias.attr,
736
#ifdef CONFIG_NUMA
737
	&dev_attr_numa_node.attr,
738
#endif
739 740
	&dev_attr_dma_mask_bits.attr,
	&dev_attr_consistent_dma_mask_bits.attr,
741
	&dev_attr_enable.attr,
742 743
	&dev_attr_broken_parity_status.attr,
	&dev_attr_msi_bus.attr,
744
#if defined(CONFIG_PM) && defined(CONFIG_ACPI)
745
	&dev_attr_d3cold_allowed.attr,
746 747 748
#endif
#ifdef CONFIG_OF
	&dev_attr_devspec.attr,
749
#endif
750
	&dev_attr_driver_override.attr,
751 752 753
	NULL,
};

754 755 756 757
static struct attribute *pci_bridge_attrs[] = {
	&dev_attr_subordinate_bus_number.attr,
	&dev_attr_secondary_bus_number.attr,
	NULL,
758 759
};

760 761 762 763 764
static struct attribute *pcie_dev_attrs[] = {
	&dev_attr_current_link_speed.attr,
	&dev_attr_current_link_width.attr,
	&dev_attr_max_link_width.attr,
	&dev_attr_max_link_speed.attr,
765
	NULL,
Linus Torvalds's avatar
Linus Torvalds committed
766 767
};

768 769 770 771 772 773 774 775 776 777 778 779 780 781
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,
782 783
};

Ryan Desfosses's avatar
Ryan Desfosses committed
784 785
static ssize_t boot_vga_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
786 787
{
	struct pci_dev *pdev = to_pci_dev(dev);
788 789 790 791
	struct pci_dev *vga_dev = vga_default_device();

	if (vga_dev)
		return sprintf(buf, "%u\n", (pdev == vga_dev));
792 793 794 795 796

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

Ryan Desfosses's avatar
Ryan Desfosses committed
799 800 801
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
802
{
803
	struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj));
Linus Torvalds's avatar
Linus Torvalds committed
804 805
	unsigned int size = 64;
	loff_t init_off = off;
Ryan Desfosses's avatar
Ryan Desfosses committed
806
	u8 *data = (u8 *) buf;
Linus Torvalds's avatar
Linus Torvalds committed
807 808

	/* Several chips lock up trying to read undefined config space */
809
	if (file_ns_capable(filp, &init_user_ns, CAP_SYS_ADMIN))
Linus Torvalds's avatar
Linus Torvalds committed
810
		size = dev->cfg_size;
Ryan Desfosses's avatar
Ryan Desfosses committed
811
	else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
Linus Torvalds's avatar
Linus Torvalds committed
812 813 814 815 816 817 818 819 820 821 822
		size = 128;

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

823 824
	pci_config_pm_runtime_get(dev);

825 826
	if ((off & 1) && size) {
		u8 val;
827
		pci_user_read_config_byte(dev, off, &val);
828
		data[off - init_off] = val;
Linus Torvalds's avatar
Linus Torvalds committed
829
		off++;
830 831 832 833 834
		size--;
	}

	if ((off & 3) && size > 2) {
		u16 val;
835
		pci_user_read_config_word(dev, off, &val);
836 837 838 839
		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
840 841 842
	}

	while (size > 3) {
843
		u32 val;
844
		pci_user_read_config_dword(dev, off, &val);
845 846 847 848
		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
849 850 851 852
		off += 4;
		size -= 4;
	}

853 854
	if (size >= 2) {
		u16 val;
855
		pci_user_read_config_word(dev, off, &val);
856 857 858 859 860 861 862 863
		data[off - init_off] = val & 0xff;
		data[off - init_off + 1] = (val >> 8) & 0xff;
		off += 2;
		size -= 2;
	}

	if (size > 0) {
		u8 val;
864
		pci_user_read_config_byte(dev, off, &val);
865
		data[off - init_off] = val;
Linus Torvalds's avatar
Linus Torvalds committed
866 867 868 869
		off++;
		--size;
	}

870 871
	pci_config_pm_runtime_put(dev);

Linus Torvalds's avatar
Linus Torvalds committed
872 873 874
	return count;
}

Ryan Desfosses's avatar
Ryan Desfosses committed
875 876 877
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
878
{
879
	struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj));
Linus Torvalds's avatar
Linus Torvalds committed
880 881
	unsigned int size = count;
	loff_t init_off = off;
Ryan Desfosses's avatar
Ryan Desfosses committed
882
	u8 *data = (u8 *) buf;
Linus Torvalds's avatar
Linus Torvalds committed
883 884 885 886 887 888 889

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

891 892
	pci_config_pm_runtime_get(dev);

893
	if ((off & 1) && size) {
894
		pci_user_write_config_byte(dev, off, data[off - init_off]);
Linus Torvalds's avatar
Linus Torvalds committed
895
		off++;
896
		size--;
Linus Torvalds's avatar
Linus Torvalds committed
897
	}
898

899 900 901
	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
902 903 904 905
		pci_user_write_config_word(dev, off, val);
		off += 2;
		size -= 2;
	}
Linus Torvalds's avatar
Linus Torvalds committed
906 907

	while (size > 3) {
908 909 910 911
		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;
912
		pci_user_write_config_dword(dev, off, val);
Linus Torvalds's avatar
Linus Torvalds committed
913 914 915
		off += 4;
		size -= 4;
	}
916

917 918 919
	if (size >= 2) {
		u16 val = data[off - init_off];
		val |= (u16) data[off - init_off + 1] << 8;
920
		pci_user_write_config_word(dev, off, val);
921 922 923
		off += 2;
		size -= 2;
	}
Linus Torvalds's avatar
Linus Torvalds committed
924

925
	if (size) {
926
		pci_user_write_config_byte(dev, off, data[off - init_off]);
Linus Torvalds's avatar
Linus Torvalds committed
927 928 929 930
		off++;
		--size;
	}

931 932
	pci_config_pm_runtime_put(dev);

Linus Torvalds's avatar
Linus Torvalds committed
933 934 935
	return count;
}

Ryan Desfosses's avatar
Ryan Desfosses committed
936 937 938
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)
939
{
940
	struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj));
941

942 943 944 945 946 947
	if (bin_attr->size > 0) {
		if (off > bin_attr->size)
			count = 0;
		else if (count > bin_attr->size - off)
			count = bin_attr->size - off;
	}
948

949
	return pci_read_vpd(dev, off, count, buf);
950 951
}

Ryan Desfosses's avatar
Ryan Desfosses committed
952 953 954
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)
955
{
956
	struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj));
957

958 959 960 961 962 963
	if (bin_attr->size > 0) {
		if (off > bin_attr->size)
			count = 0;
		else if (count > bin_attr->size - off)
			count = bin_attr->size - off;
	}
964

965
	return pci_write_vpd(dev, off, count, buf);
966 967
}

Linus Torvalds's avatar
Linus Torvalds committed
968 969 970
#ifdef HAVE_PCI_LEGACY
/**
 * pci_read_legacy_io - read byte(s) from legacy I/O port space
971
 * @filp: open sysfs file
Linus Torvalds's avatar
Linus Torvalds committed
972
 * @kobj: kobject corresponding to file to read from
973
 * @bin_attr: struct bin_attribute for this file
Linus Torvalds's avatar
Linus Torvalds committed
974 975 976 977 978 979 980
 * @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
981 982 983
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
984
{
985
	struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj));
Linus Torvalds's avatar
Linus Torvalds committed
986

Ryan Desfosses's avatar
Ryan Desfosses committed
987 988 989
	/* Only support 1, 2 or 4 byte accesses */
	if (count != 1 && count != 2 && count != 4)
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
990

Ryan Desfosses's avatar
Ryan Desfosses committed
991
	return pci_legacy_read(bus, off, (u32 *)buf, count);
Linus Torvalds's avatar
Linus Torvalds committed
992 993 994 995
}

/**
 * pci_write_legacy_io - write byte(s) to legacy I/O port space
996
 * @filp: open sysfs file
Linus Torvalds's avatar
Linus Torvalds committed
997
 * @kobj: kobject corresponding to file to read from
998
 * @bin_attr: struct bin_attribute for this file
Linus Torvalds's avatar
Linus Torvalds committed
999 1000 1001 1002 1003 1004 1005
 * @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
1006 1007 1008
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
1009
{
1010
	struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj));
Linus Torvalds's avatar
Linus Torvalds committed
1011

Ryan Desfosses's avatar
Ryan Desfosses committed
1012 1013 1014 1015 1016
	/* 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
1017 1018 1019 1020
}

/**
 * pci_mmap_legacy_mem - map legacy PCI memory into user memory space
1021
 * @filp: open sysfs file
Linus Torvalds's avatar
Linus Torvalds committed
1022 1023 1024 1025
 * @kobj: kobject corresponding to device to be mapped
 * @attr: struct bin_attribute for this file
 * @vma: struct vm_area_struct passed to mmap
 *
1026
 * Uses an arch specific callback, pci_mmap_legacy_mem_page_range, to mmap
Linus Torvalds's avatar
Linus Torvalds committed
1027 1028 1029
 * legacy memory space (first meg of bus space) into application virtual
 * memory space.
 */
Ryan Desfosses's avatar
Ryan Desfosses committed
1030 1031 1032
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
1033
{
1034
	struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj));
Linus Torvalds's avatar
Linus Torvalds committed
1035

Ryan Desfosses's avatar
Ryan Desfosses committed
1036
	return pci_mmap_legacy_page_range(bus, vma, pci_mmap_mem);
1037 1038 1039 1040
}

/**
 * pci_mmap_legacy_io - map legacy PCI IO into user memory space
1041
 * @filp: open sysfs file
1042 1043 1044 1045 1046 1047 1048 1049
 * @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
1050 1051 1052
static int pci_mmap_legacy_io(struct file *filp, struct kobject *kobj,
			      struct bin_attribute *attr,
			      struct vm_area_struct *vma)
1053
{
1054
	struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj));
1055

Ryan Desfosses's avatar
Ryan Desfosses committed
1056
	return pci_mmap_legacy_page_range(bus, vma, pci_mmap_io);
1057 1058
}

1059 1060 1061 1062 1063 1064 1065
/**
 * 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
1066 1067
void __weak pci_adjust_legacy_attr(struct pci_bus *b,
				   enum pci_mmap_state mmap_type)
1068 1069 1070
{
}

1071 1072 1073 1074 1075 1076 1077 1078
/**
 * 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
 *
Lucas De Marchi's avatar
Lucas De Marchi committed
1079
 * On error unwind, but don't propagate the error to the caller
1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
 * 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;

1091
	sysfs_bin_attr_init(b->legacy_io);
1092 1093 1094 1095 1096 1097
	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;
1098
	pci_adjust_legacy_attr(b, pci_mmap_io);
1099 1100 1101 1102 1103 1104
	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;
1105
	sysfs_bin_attr_init(b->legacy_mem);
1106 1107 1108 1109
	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;
1110
	pci_adjust_legacy_attr(b, pci_mmap_mem);
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
	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:
1123
	printk(KERN_WARNING "pci: warning: could not create legacy I/O port and ISA memory resources to sysfs\n");
1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
	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
1134 1135 1136
}
#endif /* HAVE_PCI_LEGACY */

1137
#if defined(HAVE_PCI_MMAP) || defined(ARCH_GENERIC_PCI_MMAP_RESOURCE)
1138

1139 1140
int pci_mmap_fits(struct pci_dev *pdev, int resno, struct vm_area_struct *vma,
		  enum pci_mmap_api mmap_api)
1141
{
1142 1143
	unsigned long nr, start, size;
	resource_size_t pci_start = 0, pci_end;
1144

1145 1146
	if (pci_resource_len(pdev, resno) == 0)
		return 0;
1147
	nr = vma_pages(vma);
1148
	start = vma->vm_pgoff;
1149
	size = ((pci_resource_len(pdev, resno) - 1) >> PAGE_SHIFT) + 1;
1150 1151 1152 1153 1154
	if (mmap_api == PCI_MMAP_PROCFS) {
		pci_resource_to_user(pdev, resno, &pdev->resource[resno],
				     &pci_start, &pci_end);
		pci_start >>= PAGE_SHIFT;
	}
1155 1156
	if (start >= pci_start && start < pci_start + size &&
			start + nr <= pci_start + size)
1157 1158 1159 1160
		return 1;
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
1161 1162 1163 1164 1165
/**
 * 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
1166
 * @write_combine: 1 for write_combine mapping
Linus Torvalds's avatar
Linus Torvalds committed
1167 1168 1169
 *
 * Use the regular PCI mapping routines to map a PCI resource into userspace.
 */