pci-sysfs.c 17.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * 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
 *
 * Modeled after usb's driverfs.c 
 *
 */


#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/stat.h>
#include <linux/topology.h>
#include <linux/mm.h>
A
Alexey Dobriyan 已提交
23
#include <linux/capability.h>
S
Shaohua Li 已提交
24
#include <linux/aspm.h>
L
Linus Torvalds 已提交
25 26 27 28 29 30 31
#include "pci.h"

static int sysfs_initialized;	/* = 0 */

/* show configuration fields */
#define pci_config_attr(field, format_string)				\
static ssize_t								\
32
field##_show(struct device *dev, struct device_attribute *attr, char *buf)				\
L
Linus Torvalds 已提交
33 34 35 36 37 38 39 40 41 42 43 44 45 46
{									\
	struct pci_dev *pdev;						\
									\
	pdev = to_pci_dev (dev);					\
	return sprintf (buf, format_string, pdev->field);		\
}

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

47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
static ssize_t broken_parity_status_show(struct device *dev,
					 struct device_attribute *attr,
					 char *buf)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	return sprintf (buf, "%u\n", pdev->broken_parity_status);
}

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);
	ssize_t consumed = -EINVAL;

	if ((count > 0) && (*buf == '0' || *buf == '1')) {
		pdev->broken_parity_status = *buf == '1' ? 1 : 0;
		consumed = count;
	}
	return consumed;
}

69 70
static ssize_t local_cpus_show(struct device *dev,
			struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
71
{		
72 73 74 75 76
	cpumask_t mask;
	int len;

	mask = pcibus_to_cpumask(to_pci_dev(dev)->bus);
	len = cpumask_scnprintf(buf, PAGE_SIZE-2, mask);
L
Linus Torvalds 已提交
77 78 79 80 81 82
	strcat(buf,"\n"); 
	return 1+len;
}

/* show resources */
static ssize_t
83
resource_show(struct device * dev, struct device_attribute *attr, char * buf)
L
Linus Torvalds 已提交
84 85 86 87 88
{
	struct pci_dev * pci_dev = to_pci_dev(dev);
	char * str = buf;
	int i;
	int max = 7;
89
	resource_size_t start, end;
L
Linus Torvalds 已提交
90 91 92 93 94

	if (pci_dev->subordinate)
		max = DEVICE_COUNT_RESOURCE;

	for (i = 0; i < max; i++) {
95 96 97 98 99 100
		struct resource *res =  &pci_dev->resource[i];
		pci_resource_to_user(pci_dev, i, res, &start, &end);
		str += sprintf(str,"0x%016llx 0x%016llx 0x%016llx\n",
			       (unsigned long long)start,
			       (unsigned long long)end,
			       (unsigned long long)res->flags);
L
Linus Torvalds 已提交
101 102 103 104
	}
	return (str - buf);
}

105
static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
106 107 108 109 110 111 112 113 114
{
	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));
}
115 116 117 118

static ssize_t is_enabled_store(struct device *dev,
				struct device_attribute *attr, const char *buf,
				size_t count)
119
{
120
	ssize_t result = -EINVAL;
121 122 123 124 125 126
	struct pci_dev *pdev = to_pci_dev(dev);

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

127 128 129 130 131 132 133
	if (*buf == '0') {
		if (atomic_read(&pdev->enable_cnt) != 0)
			pci_disable_device(pdev);
		else
			result = -EIO;
	} else if (*buf == '1')
		result = pci_enable_device(pdev);
134

135 136 137 138 139 140 141
	return result < 0 ? result : count;
}

static ssize_t is_enabled_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
	struct pci_dev *pdev;
142

143 144
	pdev = to_pci_dev (dev);
	return sprintf (buf, "%u\n", atomic_read(&pdev->enable_cnt));
145 146
}

147 148 149 150 151 152 153 154
#ifdef CONFIG_NUMA
static ssize_t
numa_node_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	return sprintf (buf, "%d\n", dev->numa_node);
}
#endif

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
static ssize_t
msi_bus_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct pci_dev *pdev = to_pci_dev(dev);

	if (!pdev->subordinate)
		return 0;

	return sprintf (buf, "%u\n",
			!(pdev->subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI));
}

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

	/* bad things may happen if the no_msi flag is changed
	 * while some drivers are loaded */
	if (!capable(CAP_SYS_ADMIN))
		return count;

	if (!pdev->subordinate)
		return count;

	if (*buf == '0') {
		pdev->subordinate->bus_flags |= PCI_BUS_FLAGS_NO_MSI;
		dev_warn(&pdev->dev, "forced subordinate bus to not support MSI,"
			 " bad things could happen.\n");
	}

	if (*buf == '1') {
		pdev->subordinate->bus_flags &= ~PCI_BUS_FLAGS_NO_MSI;
		dev_warn(&pdev->dev, "forced subordinate bus to support MSI,"
			 " bad things could happen.\n");
	}

	return count;
}
195

L
Linus Torvalds 已提交
196 197 198 199 200 201 202 203 204
struct device_attribute pci_dev_attrs[] = {
	__ATTR_RO(resource),
	__ATTR_RO(vendor),
	__ATTR_RO(device),
	__ATTR_RO(subsystem_vendor),
	__ATTR_RO(subsystem_device),
	__ATTR_RO(class),
	__ATTR_RO(irq),
	__ATTR_RO(local_cpus),
205
	__ATTR_RO(modalias),
206 207 208
#ifdef CONFIG_NUMA
	__ATTR_RO(numa_node),
#endif
209
	__ATTR(enable, 0600, is_enabled_show, is_enabled_store),
210 211
	__ATTR(broken_parity_status,(S_IRUGO|S_IWUSR),
		broken_parity_status_show,broken_parity_status_store),
212
	__ATTR(msi_bus, 0644, msi_bus_show, msi_bus_store),
L
Linus Torvalds 已提交
213 214 215 216
	__ATTR_NULL,
};

static ssize_t
217 218
pci_read_config(struct kobject *kobj, struct bin_attribute *bin_attr,
		char *buf, loff_t off, size_t count)
L
Linus Torvalds 已提交
219 220 221 222
{
	struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
	unsigned int size = 64;
	loff_t init_off = off;
223
	u8 *data = (u8*) buf;
L
Linus Torvalds 已提交
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240

	/* Several chips lock up trying to read undefined config space */
	if (capable(CAP_SYS_ADMIN)) {
		size = dev->cfg_size;
	} else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) {
		size = 128;
	}

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

241 242
	if ((off & 1) && size) {
		u8 val;
243
		pci_user_read_config_byte(dev, off, &val);
244
		data[off - init_off] = val;
L
Linus Torvalds 已提交
245
		off++;
246 247 248 249 250
		size--;
	}

	if ((off & 3) && size > 2) {
		u16 val;
251
		pci_user_read_config_word(dev, off, &val);
252 253 254 255
		data[off - init_off] = val & 0xff;
		data[off - init_off + 1] = (val >> 8) & 0xff;
		off += 2;
		size -= 2;
L
Linus Torvalds 已提交
256 257 258
	}

	while (size > 3) {
259
		u32 val;
260
		pci_user_read_config_dword(dev, off, &val);
261 262 263 264
		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 已提交
265 266 267 268
		off += 4;
		size -= 4;
	}

269 270
	if (size >= 2) {
		u16 val;
271
		pci_user_read_config_word(dev, off, &val);
272 273 274 275 276 277 278 279
		data[off - init_off] = val & 0xff;
		data[off - init_off + 1] = (val >> 8) & 0xff;
		off += 2;
		size -= 2;
	}

	if (size > 0) {
		u8 val;
280
		pci_user_read_config_byte(dev, off, &val);
281
		data[off - init_off] = val;
L
Linus Torvalds 已提交
282 283 284 285 286 287 288 289
		off++;
		--size;
	}

	return count;
}

static ssize_t
290 291
pci_write_config(struct kobject *kobj, struct bin_attribute *bin_attr,
		 char *buf, loff_t off, size_t count)
L
Linus Torvalds 已提交
292 293 294 295
{
	struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
	unsigned int size = count;
	loff_t init_off = off;
296
	u8 *data = (u8*) buf;
L
Linus Torvalds 已提交
297 298 299 300 301 302 303

	if (off > dev->cfg_size)
		return 0;
	if (off + count > dev->cfg_size) {
		size = dev->cfg_size - off;
		count = size;
	}
304 305
	
	if ((off & 1) && size) {
306
		pci_user_write_config_byte(dev, off, data[off - init_off]);
L
Linus Torvalds 已提交
307
		off++;
308
		size--;
L
Linus Torvalds 已提交
309
	}
310 311 312 313
	
	if ((off & 3) && size > 2) {
		u16 val = data[off - init_off];
		val |= (u16) data[off - init_off + 1] << 8;
314
                pci_user_write_config_word(dev, off, val);
315 316 317
                off += 2;
                size -= 2;
        }
L
Linus Torvalds 已提交
318 319

	while (size > 3) {
320 321 322 323
		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;
324
		pci_user_write_config_dword(dev, off, val);
L
Linus Torvalds 已提交
325 326 327
		off += 4;
		size -= 4;
	}
328 329 330 331
	
	if (size >= 2) {
		u16 val = data[off - init_off];
		val |= (u16) data[off - init_off + 1] << 8;
332
		pci_user_write_config_word(dev, off, val);
333 334 335
		off += 2;
		size -= 2;
	}
L
Linus Torvalds 已提交
336

337
	if (size) {
338
		pci_user_write_config_byte(dev, off, data[off - init_off]);
L
Linus Torvalds 已提交
339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
		off++;
		--size;
	}

	return count;
}

#ifdef HAVE_PCI_LEGACY
/**
 * pci_read_legacy_io - read byte(s) from legacy I/O port space
 * @kobj: kobject corresponding to file to read from
 * @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).
 */
ssize_t
358 359
pci_read_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
		   char *buf, loff_t off, size_t count)
L
Linus Torvalds 已提交
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
{
        struct pci_bus *bus = to_pci_bus(container_of(kobj,
                                                      struct class_device,
						      kobj));

        /* Only support 1, 2 or 4 byte accesses */
        if (count != 1 && count != 2 && count != 4)
                return -EINVAL;

        return pci_legacy_read(bus, off, (u32 *)buf, count);
}

/**
 * pci_write_legacy_io - write byte(s) to legacy I/O port space
 * @kobj: kobject corresponding to file to read from
 * @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).
 */
ssize_t
383 384
pci_write_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
		    char *buf, loff_t off, size_t count)
L
Linus Torvalds 已提交
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
{
        struct pci_bus *bus = to_pci_bus(container_of(kobj,
						      struct class_device,
						      kobj));
        /* 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);
}

/**
 * pci_mmap_legacy_mem - map legacy PCI memory into user memory space
 * @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_page_range, to mmap
 * legacy memory space (first meg of bus space) into application virtual
 * memory space.
 */
int
pci_mmap_legacy_mem(struct kobject *kobj, struct bin_attribute *attr,
                    struct vm_area_struct *vma)
{
        struct pci_bus *bus = to_pci_bus(container_of(kobj,
                                                      struct class_device,
						      kobj));

        return pci_mmap_legacy_page_range(bus, vma);
}
#endif /* HAVE_PCI_LEGACY */

#ifdef HAVE_PCI_MMAP
/**
 * 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
 *
 * Use the regular PCI mapping routines to map a PCI resource into userspace.
 * FIXME: write combining?  maybe automatic for prefetchable regions?
 */
static int
pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,
		  struct vm_area_struct *vma)
{
	struct pci_dev *pdev = to_pci_dev(container_of(kobj,
						       struct device, kobj));
	struct resource *res = (struct resource *)attr->private;
	enum pci_mmap_state mmap_type;
436
	resource_size_t start, end;
437
	int i;
L
Linus Torvalds 已提交
438

439 440 441 442 443 444 445 446 447 448 449 450
	for (i = 0; i < PCI_ROM_RESOURCE; i++)
		if (res == &pdev->resource[i])
			break;
	if (i >= PCI_ROM_RESOURCE)
		return -ENODEV;

	/* 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 已提交
451 452 453 454 455
	mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io;

	return pci_mmap_page_range(pdev, vma, mmap_type, 0);
}

456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
/**
 * pci_remove_resource_files - cleanup resource files
 * @dev: dev to cleanup
 *
 * If we created resource files for @dev, remove them from sysfs and
 * free their resources.
 */
static void
pci_remove_resource_files(struct pci_dev *pdev)
{
	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);
		}
	}
}

L
Linus Torvalds 已提交
479 480 481 482 483 484
/**
 * pci_create_resource_files - create resource files in sysfs for @dev
 * @dev: dev in question
 *
 * Walk the resources in @dev creating files for each resource available.
 */
485
static int pci_create_resource_files(struct pci_dev *pdev)
L
Linus Torvalds 已提交
486 487
{
	int i;
488
	int retval;
L
Linus Torvalds 已提交
489 490 491 492 493 494 495 496 497

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

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

498
		/* allocate attribute structure, piggyback attribute name */
499
		res_attr = kzalloc(sizeof(*res_attr) + 10, GFP_ATOMIC);
L
Linus Torvalds 已提交
500
		if (res_attr) {
501 502
			char *res_attr_name = (char *)(res_attr + 1);

L
Linus Torvalds 已提交
503
			pdev->res_attr[i] = res_attr;
504 505
			sprintf(res_attr_name, "resource%d", i);
			res_attr->attr.name = res_attr_name;
L
Linus Torvalds 已提交
506
			res_attr->attr.mode = S_IRUSR | S_IWUSR;
507
			res_attr->size = pci_resource_len(pdev, i);
L
Linus Torvalds 已提交
508 509
			res_attr->mmap = pci_mmap_resource;
			res_attr->private = &pdev->resource[i];
510 511 512 513 514 515 516
			retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr);
			if (retval) {
				pci_remove_resource_files(pdev);
				return retval;
			}
		} else {
			return -ENOMEM;
L
Linus Torvalds 已提交
517 518
		}
	}
519
	return 0;
L
Linus Torvalds 已提交
520 521
}
#else /* !HAVE_PCI_MMAP */
522
static inline int pci_create_resource_files(struct pci_dev *dev) { return 0; }
L
Linus Torvalds 已提交
523 524 525 526 527 528 529 530 531 532 533 534 535
static inline void pci_remove_resource_files(struct pci_dev *dev) { return; }
#endif /* HAVE_PCI_MMAP */

/**
 * pci_write_rom - used to enable access to the PCI ROM display
 * @kobj: kernel object handle
 * @buf: user input
 * @off: file offset
 * @count: number of byte in input
 *
 * writing anything except 0 enables it
 */
static ssize_t
536 537
pci_write_rom(struct kobject *kobj, struct bin_attribute *bin_attr,
	      char *buf, loff_t off, size_t count)
L
Linus Torvalds 已提交
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
{
	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
 * @kobj: kernel object handle
 * @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.
 */
static ssize_t
560 561
pci_read_rom(struct kobject *kobj, struct bin_attribute *bin_attr,
	     char *buf, loff_t off, size_t count)
L
Linus Torvalds 已提交
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
{
	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;
	
	rom = pci_map_rom(pdev, &size);	/* size starts out as PCI window size */
	if (!rom)
		return 0;
		
	if (off >= size)
		count = 0;
	else {
		if (off + count > size)
			count = size - off;
		
		memcpy_fromio(buf, rom + off, count);
	}
	pci_unmap_rom(pdev, rom);
		
	return count;
}

static struct bin_attribute pci_config_attr = {
	.attr =	{
		.name = "config",
		.mode = S_IRUGO | S_IWUSR,
	},
	.size = 256,
	.read = pci_read_config,
	.write = pci_write_config,
};

static struct bin_attribute pcie_config_attr = {
	.attr =	{
		.name = "config",
		.mode = S_IRUGO | S_IWUSR,
	},
	.size = 4096,
	.read = pci_read_config,
	.write = pci_write_config,
};

607
int __attribute__ ((weak)) pcibios_add_platform_entries(struct pci_dev *dev)
608
{
609
	return 0;
610 611
}

612
int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
L
Linus Torvalds 已提交
613
{
614 615 616
	struct bin_attribute *rom_attr = NULL;
	int retval;

L
Linus Torvalds 已提交
617 618 619 620
	if (!sysfs_initialized)
		return -EACCES;

	if (pdev->cfg_size < 4096)
621
		retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr);
L
Linus Torvalds 已提交
622
	else
623 624 625
		retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr);
	if (retval)
		goto err;
L
Linus Torvalds 已提交
626

627 628 629
	retval = pci_create_resource_files(pdev);
	if (retval)
		goto err_bin_file;
L
Linus Torvalds 已提交
630 631

	/* If the device has a ROM, try to expose it in sysfs. */
632 633
	if (pci_resource_len(pdev, PCI_ROM_RESOURCE) ||
	    (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)) {
634
		rom_attr = kzalloc(sizeof(*rom_attr), GFP_ATOMIC);
L
Linus Torvalds 已提交
635 636 637 638 639 640 641
		if (rom_attr) {
			pdev->rom_attr = rom_attr;
			rom_attr->size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
			rom_attr->attr.name = "rom";
			rom_attr->attr.mode = S_IRUSR;
			rom_attr->read = pci_read_rom;
			rom_attr->write = pci_write_rom;
642 643 644 645 646
			retval = sysfs_create_bin_file(&pdev->dev.kobj, rom_attr);
			if (retval)
				goto err_rom;
		} else {
			retval = -ENOMEM;
647
			goto err_resource_files;
L
Linus Torvalds 已提交
648 649 650
		}
	}
	/* add platform-specific attributes */
651 652
	if (pcibios_add_platform_entries(pdev))
		goto err_rom_file;
653

S
Shaohua Li 已提交
654 655
	pcie_aspm_create_sysfs_dev_files(pdev);

L
Linus Torvalds 已提交
656
	return 0;
657

658 659 660
err_rom_file:
	if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
		sysfs_remove_bin_file(&pdev->dev.kobj, rom_attr);
661 662
err_rom:
	kfree(rom_attr);
663 664
err_resource_files:
	pci_remove_resource_files(pdev);
665 666 667 668 669 670 671
err_bin_file:
	if (pdev->cfg_size < 4096)
		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 已提交
672 673 674 675 676 677 678 679 680 681
}

/**
 * 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)
{
682 683 684
	if (!sysfs_initialized)
		return;

S
Shaohua Li 已提交
685 686
	pcie_aspm_remove_sysfs_dev_files(pdev);

L
Linus Torvalds 已提交
687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
	if (pdev->cfg_size < 4096)
		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);

	if (pci_resource_len(pdev, PCI_ROM_RESOURCE)) {
		if (pdev->rom_attr) {
			sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
			kfree(pdev->rom_attr);
		}
	}
}

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

L
Linus Torvalds 已提交
707
	sysfs_initialized = 1;
708 709
	for_each_pci_dev(pdev) {
		retval = pci_create_sysfs_dev_files(pdev);
710 711
		if (retval) {
			pci_dev_put(pdev);
712
			return retval;
713
		}
714
	}
L
Linus Torvalds 已提交
715 716 717 718

	return 0;
}

719
late_initcall(pci_sysfs_init);