2 * drivers/pci/pci-sysfs.c
4 * (C) Copyright 2002-2004 Greg Kroah-Hartman <greg@kroah.com>
5 * (C) Copyright 2002-2004 IBM Corp.
6 * (C) Copyright 2003 Matthew Wilcox
7 * (C) Copyright 2003 Hewlett-Packard
8 * (C) Copyright 2004 Jon Smirl <jonsmirl@yahoo.com>
9 * (C) Copyright 2004 Silicon Graphics, Inc. Jesse Barnes <jbarnes@sgi.com>
11 * File attributes for PCI devices
13 * Modeled after usb's driverfs.c
18 #include <linux/kernel.h>
19 #include <linux/sched.h>
20 #include <linux/pci.h>
21 #include <linux/stat.h>
22 #include <linux/export.h>
23 #include <linux/topology.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>
35 static int sysfs_initialized
; /* = 0 */
37 /* show configuration fields */
38 #define pci_config_attr(field, format_string) \
40 field##_show(struct device *dev, struct device_attribute *attr, char *buf) \
42 struct pci_dev *pdev; \
44 pdev = to_pci_dev(dev); \
45 return sprintf(buf, format_string, pdev->field); \
47 static DEVICE_ATTR_RO(field)
49 pci_config_attr(vendor
, "0x%04x\n");
50 pci_config_attr(device
, "0x%04x\n");
51 pci_config_attr(subsystem_vendor
, "0x%04x\n");
52 pci_config_attr(subsystem_device
, "0x%04x\n");
53 pci_config_attr(revision
, "0x%02x\n");
54 pci_config_attr(class, "0x%06x\n");
55 pci_config_attr(irq
, "%u\n");
57 static ssize_t
broken_parity_status_show(struct device
*dev
,
58 struct device_attribute
*attr
,
61 struct pci_dev
*pdev
= to_pci_dev(dev
);
62 return sprintf(buf
, "%u\n", pdev
->broken_parity_status
);
65 static ssize_t
broken_parity_status_store(struct device
*dev
,
66 struct device_attribute
*attr
,
67 const char *buf
, size_t count
)
69 struct pci_dev
*pdev
= to_pci_dev(dev
);
72 if (kstrtoul(buf
, 0, &val
) < 0)
75 pdev
->broken_parity_status
= !!val
;
79 static DEVICE_ATTR_RW(broken_parity_status
);
81 static ssize_t
pci_dev_show_local_cpu(struct device
*dev
, bool list
,
82 struct device_attribute
*attr
, char *buf
)
84 const struct cpumask
*mask
;
87 mask
= (dev_to_node(dev
) == -1) ? cpu_online_mask
:
88 cpumask_of_node(dev_to_node(dev
));
90 mask
= cpumask_of_pcibus(to_pci_dev(dev
)->bus
);
92 return cpumap_print_to_pagebuf(list
, buf
, mask
);
95 static ssize_t
local_cpus_show(struct device
*dev
,
96 struct device_attribute
*attr
, char *buf
)
98 return pci_dev_show_local_cpu(dev
, false, attr
, buf
);
100 static DEVICE_ATTR_RO(local_cpus
);
102 static ssize_t
local_cpulist_show(struct device
*dev
,
103 struct device_attribute
*attr
, char *buf
)
105 return pci_dev_show_local_cpu(dev
, true, attr
, buf
);
107 static DEVICE_ATTR_RO(local_cpulist
);
110 * PCI Bus Class Devices
112 static ssize_t
cpuaffinity_show(struct device
*dev
,
113 struct device_attribute
*attr
, char *buf
)
115 const struct cpumask
*cpumask
= cpumask_of_pcibus(to_pci_bus(dev
));
117 return cpumap_print_to_pagebuf(false, buf
, cpumask
);
119 static DEVICE_ATTR_RO(cpuaffinity
);
121 static ssize_t
cpulistaffinity_show(struct device
*dev
,
122 struct device_attribute
*attr
, char *buf
)
124 const struct cpumask
*cpumask
= cpumask_of_pcibus(to_pci_bus(dev
));
126 return cpumap_print_to_pagebuf(true, buf
, cpumask
);
128 static DEVICE_ATTR_RO(cpulistaffinity
);
131 static ssize_t
resource_show(struct device
*dev
, struct device_attribute
*attr
,
134 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
138 resource_size_t start
, end
;
140 if (pci_dev
->subordinate
)
141 max
= DEVICE_COUNT_RESOURCE
;
143 max
= PCI_BRIDGE_RESOURCES
;
145 for (i
= 0; i
< max
; i
++) {
146 struct resource
*res
= &pci_dev
->resource
[i
];
147 pci_resource_to_user(pci_dev
, i
, res
, &start
, &end
);
148 str
+= sprintf(str
, "0x%016llx 0x%016llx 0x%016llx\n",
149 (unsigned long long)start
,
150 (unsigned long long)end
,
151 (unsigned long long)res
->flags
);
155 static DEVICE_ATTR_RO(resource
);
157 static ssize_t
max_link_speed_show(struct device
*dev
,
158 struct device_attribute
*attr
, char *buf
)
160 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
165 err
= pcie_capability_read_dword(pci_dev
, PCI_EXP_LNKCAP
, &linkcap
);
169 switch (linkcap
& PCI_EXP_LNKCAP_SLS
) {
170 case PCI_EXP_LNKCAP_SLS_8_0GB
:
173 case PCI_EXP_LNKCAP_SLS_5_0GB
:
176 case PCI_EXP_LNKCAP_SLS_2_5GB
:
180 speed
= "Unknown speed";
183 return sprintf(buf
, "%s\n", speed
);
185 static DEVICE_ATTR_RO(max_link_speed
);
187 static ssize_t
max_link_width_show(struct device
*dev
,
188 struct device_attribute
*attr
, char *buf
)
190 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
194 err
= pcie_capability_read_dword(pci_dev
, PCI_EXP_LNKCAP
, &linkcap
);
198 return sprintf(buf
, "%u\n", (linkcap
& PCI_EXP_LNKCAP_MLW
) >> 4);
200 static DEVICE_ATTR_RO(max_link_width
);
202 static ssize_t
current_link_speed_show(struct device
*dev
,
203 struct device_attribute
*attr
, char *buf
)
205 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
210 err
= pcie_capability_read_word(pci_dev
, PCI_EXP_LNKSTA
, &linkstat
);
214 switch (linkstat
& PCI_EXP_LNKSTA_CLS
) {
215 case PCI_EXP_LNKSTA_CLS_8_0GB
:
218 case PCI_EXP_LNKSTA_CLS_5_0GB
:
221 case PCI_EXP_LNKSTA_CLS_2_5GB
:
225 speed
= "Unknown speed";
228 return sprintf(buf
, "%s\n", speed
);
230 static DEVICE_ATTR_RO(current_link_speed
);
232 static ssize_t
current_link_width_show(struct device
*dev
,
233 struct device_attribute
*attr
, char *buf
)
235 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
239 err
= pcie_capability_read_word(pci_dev
, PCI_EXP_LNKSTA
, &linkstat
);
243 return sprintf(buf
, "%u\n",
244 (linkstat
& PCI_EXP_LNKSTA_NLW
) >> PCI_EXP_LNKSTA_NLW_SHIFT
);
246 static DEVICE_ATTR_RO(current_link_width
);
248 static ssize_t
secondary_bus_number_show(struct device
*dev
,
249 struct device_attribute
*attr
,
252 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
256 err
= pci_read_config_byte(pci_dev
, PCI_SECONDARY_BUS
, &sec_bus
);
260 return sprintf(buf
, "%u\n", sec_bus
);
262 static DEVICE_ATTR_RO(secondary_bus_number
);
264 static ssize_t
subordinate_bus_number_show(struct device
*dev
,
265 struct device_attribute
*attr
,
268 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
272 err
= pci_read_config_byte(pci_dev
, PCI_SUBORDINATE_BUS
, &sub_bus
);
276 return sprintf(buf
, "%u\n", sub_bus
);
278 static DEVICE_ATTR_RO(subordinate_bus_number
);
280 static ssize_t
modalias_show(struct device
*dev
, struct device_attribute
*attr
,
283 struct pci_dev
*pci_dev
= to_pci_dev(dev
);
285 return sprintf(buf
, "pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02X\n",
286 pci_dev
->vendor
, pci_dev
->device
,
287 pci_dev
->subsystem_vendor
, pci_dev
->subsystem_device
,
288 (u8
)(pci_dev
->class >> 16), (u8
)(pci_dev
->class >> 8),
289 (u8
)(pci_dev
->class));
291 static DEVICE_ATTR_RO(modalias
);
293 static ssize_t
enable_store(struct device
*dev
, struct device_attribute
*attr
,
294 const char *buf
, size_t count
)
296 struct pci_dev
*pdev
= to_pci_dev(dev
);
298 ssize_t result
= kstrtoul(buf
, 0, &val
);
303 /* this can crash the machine when done on the "wrong" device */
304 if (!capable(CAP_SYS_ADMIN
))
308 if (pci_is_enabled(pdev
))
309 pci_disable_device(pdev
);
313 result
= pci_enable_device(pdev
);
315 return result
< 0 ? result
: count
;
318 static ssize_t
enable_show(struct device
*dev
, struct device_attribute
*attr
,
321 struct pci_dev
*pdev
;
323 pdev
= to_pci_dev(dev
);
324 return sprintf(buf
, "%u\n", atomic_read(&pdev
->enable_cnt
));
326 static DEVICE_ATTR_RW(enable
);
329 static ssize_t
numa_node_store(struct device
*dev
,
330 struct device_attribute
*attr
, const char *buf
,
333 struct pci_dev
*pdev
= to_pci_dev(dev
);
336 if (!capable(CAP_SYS_ADMIN
))
339 ret
= kstrtoint(buf
, 0, &node
);
343 if ((node
< 0 && node
!= NUMA_NO_NODE
) || node
>= MAX_NUMNODES
)
346 if (node
!= NUMA_NO_NODE
&& !node_online(node
))
349 add_taint(TAINT_FIRMWARE_WORKAROUND
, LOCKDEP_STILL_OK
);
350 dev_alert(&pdev
->dev
, FW_BUG
"Overriding NUMA node to %d. Contact your vendor for updates.",
353 dev
->numa_node
= node
;
357 static ssize_t
numa_node_show(struct device
*dev
, struct device_attribute
*attr
,
360 return sprintf(buf
, "%d\n", dev
->numa_node
);
362 static DEVICE_ATTR_RW(numa_node
);
365 static ssize_t
dma_mask_bits_show(struct device
*dev
,
366 struct device_attribute
*attr
, char *buf
)
368 struct pci_dev
*pdev
= to_pci_dev(dev
);
370 return sprintf(buf
, "%d\n", fls64(pdev
->dma_mask
));
372 static DEVICE_ATTR_RO(dma_mask_bits
);
374 static ssize_t
consistent_dma_mask_bits_show(struct device
*dev
,
375 struct device_attribute
*attr
,
378 return sprintf(buf
, "%d\n", fls64(dev
->coherent_dma_mask
));
380 static DEVICE_ATTR_RO(consistent_dma_mask_bits
);
382 static ssize_t
msi_bus_show(struct device
*dev
, struct device_attribute
*attr
,
385 struct pci_dev
*pdev
= to_pci_dev(dev
);
386 struct pci_bus
*subordinate
= pdev
->subordinate
;
388 return sprintf(buf
, "%u\n", subordinate
?
389 !(subordinate
->bus_flags
& PCI_BUS_FLAGS_NO_MSI
)
393 static ssize_t
msi_bus_store(struct device
*dev
, struct device_attribute
*attr
,
394 const char *buf
, size_t count
)
396 struct pci_dev
*pdev
= to_pci_dev(dev
);
397 struct pci_bus
*subordinate
= pdev
->subordinate
;
400 if (kstrtoul(buf
, 0, &val
) < 0)
403 if (!capable(CAP_SYS_ADMIN
))
407 * "no_msi" and "bus_flags" only affect what happens when a driver
408 * requests MSI or MSI-X. They don't affect any drivers that have
409 * already requested MSI or MSI-X.
413 dev_info(&pdev
->dev
, "MSI/MSI-X %s for future drivers\n",
414 val
? "allowed" : "disallowed");
419 subordinate
->bus_flags
&= ~PCI_BUS_FLAGS_NO_MSI
;
421 subordinate
->bus_flags
|= PCI_BUS_FLAGS_NO_MSI
;
423 dev_info(&subordinate
->dev
, "MSI/MSI-X %s for future drivers of devices on this bus\n",
424 val
? "allowed" : "disallowed");
427 static DEVICE_ATTR_RW(msi_bus
);
429 static ssize_t
bus_rescan_store(struct bus_type
*bus
, const char *buf
,
433 struct pci_bus
*b
= NULL
;
435 if (kstrtoul(buf
, 0, &val
) < 0)
439 pci_lock_rescan_remove();
440 while ((b
= pci_find_next_bus(b
)) != NULL
)
442 pci_unlock_rescan_remove();
446 static BUS_ATTR(rescan
, (S_IWUSR
|S_IWGRP
), NULL
, bus_rescan_store
);
448 static struct attribute
*pci_bus_attrs
[] = {
449 &bus_attr_rescan
.attr
,
453 static const struct attribute_group pci_bus_group
= {
454 .attrs
= pci_bus_attrs
,
457 const struct attribute_group
*pci_bus_groups
[] = {
462 static ssize_t
dev_rescan_store(struct device
*dev
,
463 struct device_attribute
*attr
, const char *buf
,
467 struct pci_dev
*pdev
= to_pci_dev(dev
);
469 if (kstrtoul(buf
, 0, &val
) < 0)
473 pci_lock_rescan_remove();
474 pci_rescan_bus(pdev
->bus
);
475 pci_unlock_rescan_remove();
479 static struct device_attribute dev_rescan_attr
= __ATTR(rescan
,
481 NULL
, dev_rescan_store
);
483 static ssize_t
remove_store(struct device
*dev
, struct device_attribute
*attr
,
484 const char *buf
, size_t count
)
488 if (kstrtoul(buf
, 0, &val
) < 0)
491 if (val
&& device_remove_file_self(dev
, attr
))
492 pci_stop_and_remove_bus_device_locked(to_pci_dev(dev
));
495 static struct device_attribute dev_remove_attr
= __ATTR(remove
,
499 static ssize_t
dev_bus_rescan_store(struct device
*dev
,
500 struct device_attribute
*attr
,
501 const char *buf
, size_t count
)
504 struct pci_bus
*bus
= to_pci_bus(dev
);
506 if (kstrtoul(buf
, 0, &val
) < 0)
510 pci_lock_rescan_remove();
511 if (!pci_is_root_bus(bus
) && list_empty(&bus
->devices
))
512 pci_rescan_bus_bridge_resize(bus
->self
);
515 pci_unlock_rescan_remove();
519 static DEVICE_ATTR(rescan
, (S_IWUSR
|S_IWGRP
), NULL
, dev_bus_rescan_store
);
521 #if defined(CONFIG_PM) && defined(CONFIG_ACPI)
522 static ssize_t
d3cold_allowed_store(struct device
*dev
,
523 struct device_attribute
*attr
,
524 const char *buf
, size_t count
)
526 struct pci_dev
*pdev
= to_pci_dev(dev
);
529 if (kstrtoul(buf
, 0, &val
) < 0)
532 pdev
->d3cold_allowed
= !!val
;
533 if (pdev
->d3cold_allowed
)
534 pci_d3cold_enable(pdev
);
536 pci_d3cold_disable(pdev
);
538 pm_runtime_resume(dev
);
543 static ssize_t
d3cold_allowed_show(struct device
*dev
,
544 struct device_attribute
*attr
, char *buf
)
546 struct pci_dev
*pdev
= to_pci_dev(dev
);
547 return sprintf(buf
, "%u\n", pdev
->d3cold_allowed
);
549 static DEVICE_ATTR_RW(d3cold_allowed
);
553 static ssize_t
devspec_show(struct device
*dev
,
554 struct device_attribute
*attr
, char *buf
)
556 struct pci_dev
*pdev
= to_pci_dev(dev
);
557 struct device_node
*np
= pci_device_to_OF_node(pdev
);
559 if (np
== NULL
|| np
->full_name
== NULL
)
561 return sprintf(buf
, "%s", np
->full_name
);
563 static DEVICE_ATTR_RO(devspec
);
566 #ifdef CONFIG_PCI_IOV
567 static ssize_t
sriov_totalvfs_show(struct device
*dev
,
568 struct device_attribute
*attr
,
571 struct pci_dev
*pdev
= to_pci_dev(dev
);
573 return sprintf(buf
, "%u\n", pci_sriov_get_totalvfs(pdev
));
577 static ssize_t
sriov_numvfs_show(struct device
*dev
,
578 struct device_attribute
*attr
,
581 struct pci_dev
*pdev
= to_pci_dev(dev
);
583 return sprintf(buf
, "%u\n", pdev
->sriov
->num_VFs
);
587 * num_vfs > 0; number of VFs to enable
588 * num_vfs = 0; disable all VFs
590 * Note: SRIOV spec doesn't allow partial VF
591 * disable, so it's all or none.
593 static ssize_t
sriov_numvfs_store(struct device
*dev
,
594 struct device_attribute
*attr
,
595 const char *buf
, size_t count
)
597 struct pci_dev
*pdev
= to_pci_dev(dev
);
601 ret
= kstrtou16(buf
, 0, &num_vfs
);
605 if (num_vfs
> pci_sriov_get_totalvfs(pdev
))
608 device_lock(&pdev
->dev
);
610 if (num_vfs
== pdev
->sriov
->num_VFs
)
613 /* is PF driver loaded w/callback */
614 if (!pdev
->driver
|| !pdev
->driver
->sriov_configure
) {
615 dev_info(&pdev
->dev
, "Driver doesn't support SRIOV configuration via sysfs\n");
622 ret
= pdev
->driver
->sriov_configure(pdev
, 0);
627 if (pdev
->sriov
->num_VFs
) {
628 dev_warn(&pdev
->dev
, "%d VFs already enabled. Disable before enabling %d VFs\n",
629 pdev
->sriov
->num_VFs
, num_vfs
);
634 ret
= pdev
->driver
->sriov_configure(pdev
, num_vfs
);
639 dev_warn(&pdev
->dev
, "%d VFs requested; only %d enabled\n",
643 device_unlock(&pdev
->dev
);
651 static ssize_t
sriov_drivers_autoprobe_show(struct device
*dev
,
652 struct device_attribute
*attr
,
655 struct pci_dev
*pdev
= to_pci_dev(dev
);
657 return sprintf(buf
, "%u\n", pdev
->sriov
->drivers_autoprobe
);
660 static ssize_t
sriov_drivers_autoprobe_store(struct device
*dev
,
661 struct device_attribute
*attr
,
662 const char *buf
, size_t count
)
664 struct pci_dev
*pdev
= to_pci_dev(dev
);
665 bool drivers_autoprobe
;
667 if (kstrtobool(buf
, &drivers_autoprobe
) < 0)
670 pdev
->sriov
->drivers_autoprobe
= drivers_autoprobe
;
675 static struct device_attribute sriov_totalvfs_attr
= __ATTR_RO(sriov_totalvfs
);
676 static struct device_attribute sriov_numvfs_attr
=
677 __ATTR(sriov_numvfs
, (S_IRUGO
|S_IWUSR
|S_IWGRP
),
678 sriov_numvfs_show
, sriov_numvfs_store
);
679 static struct device_attribute sriov_drivers_autoprobe_attr
=
680 __ATTR(sriov_drivers_autoprobe
, (S_IRUGO
|S_IWUSR
|S_IWGRP
),
681 sriov_drivers_autoprobe_show
, sriov_drivers_autoprobe_store
);
682 #endif /* CONFIG_PCI_IOV */
684 static ssize_t
driver_override_store(struct device
*dev
,
685 struct device_attribute
*attr
,
686 const char *buf
, size_t count
)
688 struct pci_dev
*pdev
= to_pci_dev(dev
);
689 char *driver_override
, *old
= pdev
->driver_override
, *cp
;
691 /* We need to keep extra room for a newline */
692 if (count
>= (PAGE_SIZE
- 1))
695 driver_override
= kstrndup(buf
, count
, GFP_KERNEL
);
696 if (!driver_override
)
699 cp
= strchr(driver_override
, '\n');
703 if (strlen(driver_override
)) {
704 pdev
->driver_override
= driver_override
;
706 kfree(driver_override
);
707 pdev
->driver_override
= NULL
;
715 static ssize_t
driver_override_show(struct device
*dev
,
716 struct device_attribute
*attr
, char *buf
)
718 struct pci_dev
*pdev
= to_pci_dev(dev
);
720 return snprintf(buf
, PAGE_SIZE
, "%s\n", pdev
->driver_override
);
722 static DEVICE_ATTR_RW(driver_override
);
724 static struct attribute
*pci_dev_attrs
[] = {
725 &dev_attr_resource
.attr
,
726 &dev_attr_vendor
.attr
,
727 &dev_attr_device
.attr
,
728 &dev_attr_subsystem_vendor
.attr
,
729 &dev_attr_subsystem_device
.attr
,
730 &dev_attr_revision
.attr
,
731 &dev_attr_class
.attr
,
733 &dev_attr_local_cpus
.attr
,
734 &dev_attr_local_cpulist
.attr
,
735 &dev_attr_modalias
.attr
,
737 &dev_attr_numa_node
.attr
,
739 &dev_attr_dma_mask_bits
.attr
,
740 &dev_attr_consistent_dma_mask_bits
.attr
,
741 &dev_attr_enable
.attr
,
742 &dev_attr_broken_parity_status
.attr
,
743 &dev_attr_msi_bus
.attr
,
744 #if defined(CONFIG_PM) && defined(CONFIG_ACPI)
745 &dev_attr_d3cold_allowed
.attr
,
748 &dev_attr_devspec
.attr
,
750 &dev_attr_driver_override
.attr
,
754 static struct attribute
*pci_bridge_attrs
[] = {
755 &dev_attr_subordinate_bus_number
.attr
,
756 &dev_attr_secondary_bus_number
.attr
,
760 static struct attribute
*pcie_dev_attrs
[] = {
761 &dev_attr_current_link_speed
.attr
,
762 &dev_attr_current_link_width
.attr
,
763 &dev_attr_max_link_width
.attr
,
764 &dev_attr_max_link_speed
.attr
,
768 static struct attribute
*pcibus_attrs
[] = {
769 &dev_attr_rescan
.attr
,
770 &dev_attr_cpuaffinity
.attr
,
771 &dev_attr_cpulistaffinity
.attr
,
775 static const struct attribute_group pcibus_group
= {
776 .attrs
= pcibus_attrs
,
779 const struct attribute_group
*pcibus_groups
[] = {
784 static ssize_t
boot_vga_show(struct device
*dev
, struct device_attribute
*attr
,
787 struct pci_dev
*pdev
= to_pci_dev(dev
);
788 struct pci_dev
*vga_dev
= vga_default_device();
791 return sprintf(buf
, "%u\n", (pdev
== vga_dev
));
793 return sprintf(buf
, "%u\n",
794 !!(pdev
->resource
[PCI_ROM_RESOURCE
].flags
&
795 IORESOURCE_ROM_SHADOW
));
797 static struct device_attribute vga_attr
= __ATTR_RO(boot_vga
);
799 static ssize_t
pci_read_config(struct file
*filp
, struct kobject
*kobj
,
800 struct bin_attribute
*bin_attr
, char *buf
,
801 loff_t off
, size_t count
)
803 struct pci_dev
*dev
= to_pci_dev(kobj_to_dev(kobj
));
804 unsigned int size
= 64;
805 loff_t init_off
= off
;
806 u8
*data
= (u8
*) buf
;
808 /* Several chips lock up trying to read undefined config space */
809 if (file_ns_capable(filp
, &init_user_ns
, CAP_SYS_ADMIN
))
810 size
= dev
->cfg_size
;
811 else if (dev
->hdr_type
== PCI_HEADER_TYPE_CARDBUS
)
816 if (off
+ count
> size
) {
823 pci_config_pm_runtime_get(dev
);
825 if ((off
& 1) && size
) {
827 pci_user_read_config_byte(dev
, off
, &val
);
828 data
[off
- init_off
] = val
;
833 if ((off
& 3) && size
> 2) {
835 pci_user_read_config_word(dev
, off
, &val
);
836 data
[off
- init_off
] = val
& 0xff;
837 data
[off
- init_off
+ 1] = (val
>> 8) & 0xff;
844 pci_user_read_config_dword(dev
, off
, &val
);
845 data
[off
- init_off
] = val
& 0xff;
846 data
[off
- init_off
+ 1] = (val
>> 8) & 0xff;
847 data
[off
- init_off
+ 2] = (val
>> 16) & 0xff;
848 data
[off
- init_off
+ 3] = (val
>> 24) & 0xff;
855 pci_user_read_config_word(dev
, off
, &val
);
856 data
[off
- init_off
] = val
& 0xff;
857 data
[off
- init_off
+ 1] = (val
>> 8) & 0xff;
864 pci_user_read_config_byte(dev
, off
, &val
);
865 data
[off
- init_off
] = val
;
870 pci_config_pm_runtime_put(dev
);
875 static ssize_t
pci_write_config(struct file
*filp
, struct kobject
*kobj
,
876 struct bin_attribute
*bin_attr
, char *buf
,
877 loff_t off
, size_t count
)
879 struct pci_dev
*dev
= to_pci_dev(kobj_to_dev(kobj
));
880 unsigned int size
= count
;
881 loff_t init_off
= off
;
882 u8
*data
= (u8
*) buf
;
884 if (kernel_is_locked_down())
887 if (off
> dev
->cfg_size
)
889 if (off
+ count
> dev
->cfg_size
) {
890 size
= dev
->cfg_size
- off
;
894 pci_config_pm_runtime_get(dev
);
896 if ((off
& 1) && size
) {
897 pci_user_write_config_byte(dev
, off
, data
[off
- init_off
]);
902 if ((off
& 3) && size
> 2) {
903 u16 val
= data
[off
- init_off
];
904 val
|= (u16
) data
[off
- init_off
+ 1] << 8;
905 pci_user_write_config_word(dev
, off
, val
);
911 u32 val
= data
[off
- init_off
];
912 val
|= (u32
) data
[off
- init_off
+ 1] << 8;
913 val
|= (u32
) data
[off
- init_off
+ 2] << 16;
914 val
|= (u32
) data
[off
- init_off
+ 3] << 24;
915 pci_user_write_config_dword(dev
, off
, val
);
921 u16 val
= data
[off
- init_off
];
922 val
|= (u16
) data
[off
- init_off
+ 1] << 8;
923 pci_user_write_config_word(dev
, off
, val
);
929 pci_user_write_config_byte(dev
, off
, data
[off
- init_off
]);
934 pci_config_pm_runtime_put(dev
);
939 static ssize_t
read_vpd_attr(struct file
*filp
, struct kobject
*kobj
,
940 struct bin_attribute
*bin_attr
, char *buf
,
941 loff_t off
, size_t count
)
943 struct pci_dev
*dev
= to_pci_dev(kobj_to_dev(kobj
));
945 if (bin_attr
->size
> 0) {
946 if (off
> bin_attr
->size
)
948 else if (count
> bin_attr
->size
- off
)
949 count
= bin_attr
->size
- off
;
952 return pci_read_vpd(dev
, off
, count
, buf
);
955 static ssize_t
write_vpd_attr(struct file
*filp
, struct kobject
*kobj
,
956 struct bin_attribute
*bin_attr
, char *buf
,
957 loff_t off
, size_t count
)
959 struct pci_dev
*dev
= to_pci_dev(kobj_to_dev(kobj
));
961 if (bin_attr
->size
> 0) {
962 if (off
> bin_attr
->size
)
964 else if (count
> bin_attr
->size
- off
)
965 count
= bin_attr
->size
- off
;
968 return pci_write_vpd(dev
, off
, count
, buf
);
971 #ifdef HAVE_PCI_LEGACY
973 * pci_read_legacy_io - read byte(s) from legacy I/O port space
974 * @filp: open sysfs file
975 * @kobj: kobject corresponding to file to read from
976 * @bin_attr: struct bin_attribute for this file
977 * @buf: buffer to store results
978 * @off: offset into legacy I/O port space
979 * @count: number of bytes to read
981 * Reads 1, 2, or 4 bytes from legacy I/O port space using an arch specific
982 * callback routine (pci_legacy_read).
984 static ssize_t
pci_read_legacy_io(struct file
*filp
, struct kobject
*kobj
,
985 struct bin_attribute
*bin_attr
, char *buf
,
986 loff_t off
, size_t count
)
988 struct pci_bus
*bus
= to_pci_bus(kobj_to_dev(kobj
));
990 /* Only support 1, 2 or 4 byte accesses */
991 if (count
!= 1 && count
!= 2 && count
!= 4)
994 return pci_legacy_read(bus
, off
, (u32
*)buf
, count
);
998 * pci_write_legacy_io - write byte(s) to legacy I/O port space
999 * @filp: open sysfs file
1000 * @kobj: kobject corresponding to file to read from
1001 * @bin_attr: struct bin_attribute for this file
1002 * @buf: buffer containing value to be written
1003 * @off: offset into legacy I/O port space
1004 * @count: number of bytes to write
1006 * Writes 1, 2, or 4 bytes from legacy I/O port space using an arch specific
1007 * callback routine (pci_legacy_write).
1009 static ssize_t
pci_write_legacy_io(struct file
*filp
, struct kobject
*kobj
,
1010 struct bin_attribute
*bin_attr
, char *buf
,
1011 loff_t off
, size_t count
)
1013 struct pci_bus
*bus
= to_pci_bus(kobj_to_dev(kobj
));
1015 /* Only support 1, 2 or 4 byte accesses */
1016 if (count
!= 1 && count
!= 2 && count
!= 4)
1019 return pci_legacy_write(bus
, off
, *(u32
*)buf
, count
);
1023 * pci_mmap_legacy_mem - map legacy PCI memory into user memory space
1024 * @filp: open sysfs file
1025 * @kobj: kobject corresponding to device to be mapped
1026 * @attr: struct bin_attribute for this file
1027 * @vma: struct vm_area_struct passed to mmap
1029 * Uses an arch specific callback, pci_mmap_legacy_mem_page_range, to mmap
1030 * legacy memory space (first meg of bus space) into application virtual
1033 static int pci_mmap_legacy_mem(struct file
*filp
, struct kobject
*kobj
,
1034 struct bin_attribute
*attr
,
1035 struct vm_area_struct
*vma
)
1037 struct pci_bus
*bus
= to_pci_bus(kobj_to_dev(kobj
));
1039 return pci_mmap_legacy_page_range(bus
, vma
, pci_mmap_mem
);
1043 * pci_mmap_legacy_io - map legacy PCI IO into user memory space
1044 * @filp: open sysfs file
1045 * @kobj: kobject corresponding to device to be mapped
1046 * @attr: struct bin_attribute for this file
1047 * @vma: struct vm_area_struct passed to mmap
1049 * Uses an arch specific callback, pci_mmap_legacy_io_page_range, to mmap
1050 * legacy IO space (first meg of bus space) into application virtual
1051 * memory space. Returns -ENOSYS if the operation isn't supported
1053 static int pci_mmap_legacy_io(struct file
*filp
, struct kobject
*kobj
,
1054 struct bin_attribute
*attr
,
1055 struct vm_area_struct
*vma
)
1057 struct pci_bus
*bus
= to_pci_bus(kobj_to_dev(kobj
));
1059 return pci_mmap_legacy_page_range(bus
, vma
, pci_mmap_io
);
1063 * pci_adjust_legacy_attr - adjustment of legacy file attributes
1064 * @b: bus to create files under
1065 * @mmap_type: I/O port or memory
1067 * Stub implementation. Can be overridden by arch if necessary.
1069 void __weak
pci_adjust_legacy_attr(struct pci_bus
*b
,
1070 enum pci_mmap_state mmap_type
)
1075 * pci_create_legacy_files - create legacy I/O port and memory files
1076 * @b: bus to create files under
1078 * Some platforms allow access to legacy I/O port and ISA memory space on
1079 * a per-bus basis. This routine creates the files and ties them into
1080 * their associated read, write and mmap files from pci-sysfs.c
1082 * On error unwind, but don't propagate the error to the caller
1083 * as it is ok to set up the PCI bus without these files.
1085 void pci_create_legacy_files(struct pci_bus
*b
)
1089 b
->legacy_io
= kzalloc(sizeof(struct bin_attribute
) * 2,
1094 sysfs_bin_attr_init(b
->legacy_io
);
1095 b
->legacy_io
->attr
.name
= "legacy_io";
1096 b
->legacy_io
->size
= 0xffff;
1097 b
->legacy_io
->attr
.mode
= S_IRUSR
| S_IWUSR
;
1098 b
->legacy_io
->read
= pci_read_legacy_io
;
1099 b
->legacy_io
->write
= pci_write_legacy_io
;
1100 b
->legacy_io
->mmap
= pci_mmap_legacy_io
;
1101 pci_adjust_legacy_attr(b
, pci_mmap_io
);
1102 error
= device_create_bin_file(&b
->dev
, b
->legacy_io
);
1106 /* Allocated above after the legacy_io struct */
1107 b
->legacy_mem
= b
->legacy_io
+ 1;
1108 sysfs_bin_attr_init(b
->legacy_mem
);
1109 b
->legacy_mem
->attr
.name
= "legacy_mem";
1110 b
->legacy_mem
->size
= 1024*1024;
1111 b
->legacy_mem
->attr
.mode
= S_IRUSR
| S_IWUSR
;
1112 b
->legacy_mem
->mmap
= pci_mmap_legacy_mem
;
1113 pci_adjust_legacy_attr(b
, pci_mmap_mem
);
1114 error
= device_create_bin_file(&b
->dev
, b
->legacy_mem
);
1116 goto legacy_mem_err
;
1121 device_remove_bin_file(&b
->dev
, b
->legacy_io
);
1123 kfree(b
->legacy_io
);
1124 b
->legacy_io
= NULL
;
1126 printk(KERN_WARNING
"pci: warning: could not create legacy I/O port and ISA memory resources to sysfs\n");
1130 void pci_remove_legacy_files(struct pci_bus
*b
)
1133 device_remove_bin_file(&b
->dev
, b
->legacy_io
);
1134 device_remove_bin_file(&b
->dev
, b
->legacy_mem
);
1135 kfree(b
->legacy_io
); /* both are allocated here */
1138 #endif /* HAVE_PCI_LEGACY */
1140 #if defined(HAVE_PCI_MMAP) || defined(ARCH_GENERIC_PCI_MMAP_RESOURCE)
1142 int pci_mmap_fits(struct pci_dev
*pdev
, int resno
, struct vm_area_struct
*vma
,
1143 enum pci_mmap_api mmap_api
)
1145 unsigned long nr
, start
, size
;
1146 resource_size_t pci_start
= 0, pci_end
;
1148 if (pci_resource_len(pdev
, resno
) == 0)
1150 nr
= vma_pages(vma
);
1151 start
= vma
->vm_pgoff
;
1152 size
= ((pci_resource_len(pdev
, resno
) - 1) >> PAGE_SHIFT
) + 1;
1153 if (mmap_api
== PCI_MMAP_PROCFS
) {
1154 pci_resource_to_user(pdev
, resno
, &pdev
->resource
[resno
],
1155 &pci_start
, &pci_end
);
1156 pci_start
>>= PAGE_SHIFT
;
1158 if (start
>= pci_start
&& start
< pci_start
+ size
&&
1159 start
+ nr
<= pci_start
+ size
)
1165 * pci_mmap_resource - map a PCI resource into user memory space
1166 * @kobj: kobject for mapping
1167 * @attr: struct bin_attribute for the file being mapped
1168 * @vma: struct vm_area_struct passed into the mmap
1169 * @write_combine: 1 for write_combine mapping
1171 * Use the regular PCI mapping routines to map a PCI resource into userspace.
1173 static int pci_mmap_resource(struct kobject
*kobj
, struct bin_attribute
*attr
,
1174 struct vm_area_struct
*vma
, int write_combine
)
1176 struct pci_dev
*pdev
= to_pci_dev(kobj_to_dev(kobj
));
1177 int bar
= (unsigned long)attr
->private;
1178 enum pci_mmap_state mmap_type
;
1179 struct resource
*res
= &pdev
->resource
[bar
];
1181 if (kernel_is_locked_down())
1184 if (res
->flags
& IORESOURCE_MEM
&& iomem_is_exclusive(res
->start
))
1187 if (!pci_mmap_fits(pdev
, bar
, vma
, PCI_MMAP_SYSFS
)) {
1188 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",
1189 current
->comm
, vma
->vm_end
-vma
->vm_start
, vma
->vm_pgoff
,
1190 pci_name(pdev
), bar
,
1191 (u64
)pci_resource_start(pdev
, bar
),
1192 (u64
)pci_resource_len(pdev
, bar
));
1195 mmap_type
= res
->flags
& IORESOURCE_MEM
? pci_mmap_mem
: pci_mmap_io
;
1197 return pci_mmap_resource_range(pdev
, bar
, vma
, mmap_type
, write_combine
);
1200 static int pci_mmap_resource_uc(struct file
*filp
, struct kobject
*kobj
,
1201 struct bin_attribute
*attr
,
1202 struct vm_area_struct
*vma
)
1204 return pci_mmap_resource(kobj
, attr
, vma
, 0);
1207 static int pci_mmap_resource_wc(struct file
*filp
, struct kobject
*kobj
,
1208 struct bin_attribute
*attr
,
1209 struct vm_area_struct
*vma
)
1211 return pci_mmap_resource(kobj
, attr
, vma
, 1);
1214 static ssize_t
pci_resource_io(struct file
*filp
, struct kobject
*kobj
,
1215 struct bin_attribute
*attr
, char *buf
,
1216 loff_t off
, size_t count
, bool write
)
1218 struct pci_dev
*pdev
= to_pci_dev(kobj_to_dev(kobj
));
1219 int bar
= (unsigned long)attr
->private;
1220 struct resource
*res
;
1221 unsigned long port
= off
;
1223 res
= &pdev
->resource
[bar
];
1225 port
+= pci_resource_start(pdev
, bar
);
1227 if (port
> pci_resource_end(pdev
, bar
))
1230 if (port
+ count
- 1 > pci_resource_end(pdev
, bar
))
1236 outb(*(u8
*)buf
, port
);
1238 *(u8
*)buf
= inb(port
);
1242 outw(*(u16
*)buf
, port
);
1244 *(u16
*)buf
= inw(port
);
1248 outl(*(u32
*)buf
, port
);
1250 *(u32
*)buf
= inl(port
);
1256 static ssize_t
pci_read_resource_io(struct file
*filp
, struct kobject
*kobj
,
1257 struct bin_attribute
*attr
, char *buf
,
1258 loff_t off
, size_t count
)
1260 return pci_resource_io(filp
, kobj
, attr
, buf
, off
, count
, false);
1263 static ssize_t
pci_write_resource_io(struct file
*filp
, struct kobject
*kobj
,
1264 struct bin_attribute
*attr
, char *buf
,
1265 loff_t off
, size_t count
)
1267 if (kernel_is_locked_down())
1270 return pci_resource_io(filp
, kobj
, attr
, buf
, off
, count
, true);
1274 * pci_remove_resource_files - cleanup resource files
1275 * @pdev: dev to cleanup
1277 * If we created resource files for @pdev, remove them from sysfs and
1278 * free their resources.
1280 static void pci_remove_resource_files(struct pci_dev
*pdev
)
1284 for (i
= 0; i
< PCI_ROM_RESOURCE
; i
++) {
1285 struct bin_attribute
*res_attr
;
1287 res_attr
= pdev
->res_attr
[i
];
1289 sysfs_remove_bin_file(&pdev
->dev
.kobj
, res_attr
);
1293 res_attr
= pdev
->res_attr_wc
[i
];
1295 sysfs_remove_bin_file(&pdev
->dev
.kobj
, res_attr
);
1301 static int pci_create_attr(struct pci_dev
*pdev
, int num
, int write_combine
)
1303 /* allocate attribute structure, piggyback attribute name */
1304 int name_len
= write_combine
? 13 : 10;
1305 struct bin_attribute
*res_attr
;
1306 char *res_attr_name
;
1309 res_attr
= kzalloc(sizeof(*res_attr
) + name_len
, GFP_ATOMIC
);
1313 res_attr_name
= (char *)(res_attr
+ 1);
1315 sysfs_bin_attr_init(res_attr
);
1316 if (write_combine
) {
1317 pdev
->res_attr_wc
[num
] = res_attr
;
1318 sprintf(res_attr_name
, "resource%d_wc", num
);
1319 res_attr
->mmap
= pci_mmap_resource_wc
;
1321 pdev
->res_attr
[num
] = res_attr
;
1322 sprintf(res_attr_name
, "resource%d", num
);
1323 if (pci_resource_flags(pdev
, num
) & IORESOURCE_IO
) {
1324 res_attr
->read
= pci_read_resource_io
;
1325 res_attr
->write
= pci_write_resource_io
;
1326 if (arch_can_pci_mmap_io())
1327 res_attr
->mmap
= pci_mmap_resource_uc
;
1329 res_attr
->mmap
= pci_mmap_resource_uc
;
1332 res_attr
->attr
.name
= res_attr_name
;
1333 res_attr
->attr
.mode
= S_IRUSR
| S_IWUSR
;
1334 res_attr
->size
= pci_resource_len(pdev
, num
);
1335 res_attr
->private = (void *)(unsigned long)num
;
1336 retval
= sysfs_create_bin_file(&pdev
->dev
.kobj
, res_attr
);
1344 * pci_create_resource_files - create resource files in sysfs for @dev
1345 * @pdev: dev in question
1347 * Walk the resources in @pdev creating files for each resource available.
1349 static int pci_create_resource_files(struct pci_dev
*pdev
)
1354 /* Expose the PCI resources from this device as files */
1355 for (i
= 0; i
< PCI_ROM_RESOURCE
; i
++) {
1357 /* skip empty resources */
1358 if (!pci_resource_len(pdev
, i
))
1361 retval
= pci_create_attr(pdev
, i
, 0);
1362 /* for prefetchable resources, create a WC mappable file */
1363 if (!retval
&& arch_can_pci_mmap_wc() &&
1364 pdev
->resource
[i
].flags
& IORESOURCE_PREFETCH
)
1365 retval
= pci_create_attr(pdev
, i
, 1);
1367 pci_remove_resource_files(pdev
);
1373 #else /* !HAVE_PCI_MMAP */
1374 int __weak
pci_create_resource_files(struct pci_dev
*dev
) { return 0; }
1375 void __weak
pci_remove_resource_files(struct pci_dev
*dev
) { return; }
1376 #endif /* HAVE_PCI_MMAP */
1379 * pci_write_rom - used to enable access to the PCI ROM display
1381 * @kobj: kernel object handle
1382 * @bin_attr: struct bin_attribute for this file
1385 * @count: number of byte in input
1387 * writing anything except 0 enables it
1389 static ssize_t
pci_write_rom(struct file
*filp
, struct kobject
*kobj
,
1390 struct bin_attribute
*bin_attr
, char *buf
,
1391 loff_t off
, size_t count
)
1393 struct pci_dev
*pdev
= to_pci_dev(kobj_to_dev(kobj
));
1395 if ((off
== 0) && (*buf
== '0') && (count
== 2))
1396 pdev
->rom_attr_enabled
= 0;
1398 pdev
->rom_attr_enabled
= 1;
1404 * pci_read_rom - read a PCI ROM
1406 * @kobj: kernel object handle
1407 * @bin_attr: struct bin_attribute for this file
1408 * @buf: where to put the data we read from the ROM
1410 * @count: number of bytes to read
1412 * Put @count bytes starting at @off into @buf from the ROM in the PCI
1413 * device corresponding to @kobj.
1415 static ssize_t
pci_read_rom(struct file
*filp
, struct kobject
*kobj
,
1416 struct bin_attribute
*bin_attr
, char *buf
,
1417 loff_t off
, size_t count
)
1419 struct pci_dev
*pdev
= to_pci_dev(kobj_to_dev(kobj
));
1423 if (!pdev
->rom_attr_enabled
)
1426 rom
= pci_map_rom(pdev
, &size
); /* size starts out as PCI window size */
1433 if (off
+ count
> size
)
1436 memcpy_fromio(buf
, rom
+ off
, count
);
1438 pci_unmap_rom(pdev
, rom
);
1443 static struct bin_attribute pci_config_attr
= {
1446 .mode
= S_IRUGO
| S_IWUSR
,
1448 .size
= PCI_CFG_SPACE_SIZE
,
1449 .read
= pci_read_config
,
1450 .write
= pci_write_config
,
1453 static struct bin_attribute pcie_config_attr
= {
1456 .mode
= S_IRUGO
| S_IWUSR
,
1458 .size
= PCI_CFG_SPACE_EXP_SIZE
,
1459 .read
= pci_read_config
,
1460 .write
= pci_write_config
,
1463 static ssize_t
reset_store(struct device
*dev
, struct device_attribute
*attr
,
1464 const char *buf
, size_t count
)
1466 struct pci_dev
*pdev
= to_pci_dev(dev
);
1468 ssize_t result
= kstrtoul(buf
, 0, &val
);
1476 result
= pci_reset_function(pdev
);
1483 static struct device_attribute reset_attr
= __ATTR(reset
, 0200, NULL
, reset_store
);
1485 static int pci_create_capabilities_sysfs(struct pci_dev
*dev
)
1488 struct bin_attribute
*attr
;
1490 /* If the device has VPD, try to expose it in sysfs. */
1492 attr
= kzalloc(sizeof(*attr
), GFP_ATOMIC
);
1496 sysfs_bin_attr_init(attr
);
1498 attr
->attr
.name
= "vpd";
1499 attr
->attr
.mode
= S_IRUSR
| S_IWUSR
;
1500 attr
->read
= read_vpd_attr
;
1501 attr
->write
= write_vpd_attr
;
1502 retval
= sysfs_create_bin_file(&dev
->dev
.kobj
, attr
);
1507 dev
->vpd
->attr
= attr
;
1510 /* Active State Power Management */
1511 pcie_aspm_create_sysfs_dev_files(dev
);
1513 if (!pci_probe_reset_function(dev
)) {
1514 retval
= device_create_file(&dev
->dev
, &reset_attr
);
1522 pcie_aspm_remove_sysfs_dev_files(dev
);
1523 if (dev
->vpd
&& dev
->vpd
->attr
) {
1524 sysfs_remove_bin_file(&dev
->dev
.kobj
, dev
->vpd
->attr
);
1525 kfree(dev
->vpd
->attr
);
1531 int __must_check
pci_create_sysfs_dev_files(struct pci_dev
*pdev
)
1535 struct bin_attribute
*attr
;
1537 if (!sysfs_initialized
)
1540 if (pdev
->cfg_size
> PCI_CFG_SPACE_SIZE
)
1541 retval
= sysfs_create_bin_file(&pdev
->dev
.kobj
, &pcie_config_attr
);
1543 retval
= sysfs_create_bin_file(&pdev
->dev
.kobj
, &pci_config_attr
);
1547 retval
= pci_create_resource_files(pdev
);
1549 goto err_config_file
;
1551 /* If the device has a ROM, try to expose it in sysfs. */
1552 rom_size
= pci_resource_len(pdev
, PCI_ROM_RESOURCE
);
1554 attr
= kzalloc(sizeof(*attr
), GFP_ATOMIC
);
1557 goto err_resource_files
;
1559 sysfs_bin_attr_init(attr
);
1560 attr
->size
= rom_size
;
1561 attr
->attr
.name
= "rom";
1562 attr
->attr
.mode
= S_IRUSR
| S_IWUSR
;
1563 attr
->read
= pci_read_rom
;
1564 attr
->write
= pci_write_rom
;
1565 retval
= sysfs_create_bin_file(&pdev
->dev
.kobj
, attr
);
1568 goto err_resource_files
;
1570 pdev
->rom_attr
= attr
;
1573 /* add sysfs entries for various capabilities */
1574 retval
= pci_create_capabilities_sysfs(pdev
);
1578 pci_create_firmware_label_files(pdev
);
1583 if (pdev
->rom_attr
) {
1584 sysfs_remove_bin_file(&pdev
->dev
.kobj
, pdev
->rom_attr
);
1585 kfree(pdev
->rom_attr
);
1586 pdev
->rom_attr
= NULL
;
1589 pci_remove_resource_files(pdev
);
1591 if (pdev
->cfg_size
> PCI_CFG_SPACE_SIZE
)
1592 sysfs_remove_bin_file(&pdev
->dev
.kobj
, &pcie_config_attr
);
1594 sysfs_remove_bin_file(&pdev
->dev
.kobj
, &pci_config_attr
);
1599 static void pci_remove_capabilities_sysfs(struct pci_dev
*dev
)
1601 if (dev
->vpd
&& dev
->vpd
->attr
) {
1602 sysfs_remove_bin_file(&dev
->dev
.kobj
, dev
->vpd
->attr
);
1603 kfree(dev
->vpd
->attr
);
1606 pcie_aspm_remove_sysfs_dev_files(dev
);
1607 if (dev
->reset_fn
) {
1608 device_remove_file(&dev
->dev
, &reset_attr
);
1614 * pci_remove_sysfs_dev_files - cleanup PCI specific sysfs files
1615 * @pdev: device whose entries we should free
1617 * Cleanup when @pdev is removed from sysfs.
1619 void pci_remove_sysfs_dev_files(struct pci_dev
*pdev
)
1621 if (!sysfs_initialized
)
1624 pci_remove_capabilities_sysfs(pdev
);
1626 if (pdev
->cfg_size
> PCI_CFG_SPACE_SIZE
)
1627 sysfs_remove_bin_file(&pdev
->dev
.kobj
, &pcie_config_attr
);
1629 sysfs_remove_bin_file(&pdev
->dev
.kobj
, &pci_config_attr
);
1631 pci_remove_resource_files(pdev
);
1633 if (pdev
->rom_attr
) {
1634 sysfs_remove_bin_file(&pdev
->dev
.kobj
, pdev
->rom_attr
);
1635 kfree(pdev
->rom_attr
);
1636 pdev
->rom_attr
= NULL
;
1639 pci_remove_firmware_label_files(pdev
);
1642 static int __init
pci_sysfs_init(void)
1644 struct pci_dev
*pdev
= NULL
;
1647 sysfs_initialized
= 1;
1648 for_each_pci_dev(pdev
) {
1649 retval
= pci_create_sysfs_dev_files(pdev
);
1658 late_initcall(pci_sysfs_init
);
1660 static struct attribute
*pci_dev_dev_attrs
[] = {
1665 static umode_t
pci_dev_attrs_are_visible(struct kobject
*kobj
,
1666 struct attribute
*a
, int n
)
1668 struct device
*dev
= kobj_to_dev(kobj
);
1669 struct pci_dev
*pdev
= to_pci_dev(dev
);
1671 if (a
== &vga_attr
.attr
)
1672 if ((pdev
->class >> 8) != PCI_CLASS_DISPLAY_VGA
)
1678 static struct attribute
*pci_dev_hp_attrs
[] = {
1679 &dev_remove_attr
.attr
,
1680 &dev_rescan_attr
.attr
,
1684 static umode_t
pci_dev_hp_attrs_are_visible(struct kobject
*kobj
,
1685 struct attribute
*a
, int n
)
1687 struct device
*dev
= kobj_to_dev(kobj
);
1688 struct pci_dev
*pdev
= to_pci_dev(dev
);
1690 if (pdev
->is_virtfn
)
1696 static umode_t
pci_bridge_attrs_are_visible(struct kobject
*kobj
,
1697 struct attribute
*a
, int n
)
1699 struct device
*dev
= kobj_to_dev(kobj
);
1700 struct pci_dev
*pdev
= to_pci_dev(dev
);
1702 if (pci_is_bridge(pdev
))
1708 static umode_t
pcie_dev_attrs_are_visible(struct kobject
*kobj
,
1709 struct attribute
*a
, int n
)
1711 struct device
*dev
= kobj_to_dev(kobj
);
1712 struct pci_dev
*pdev
= to_pci_dev(dev
);
1714 if (pci_is_pcie(pdev
))
1720 static const struct attribute_group pci_dev_group
= {
1721 .attrs
= pci_dev_attrs
,
1724 const struct attribute_group
*pci_dev_groups
[] = {
1729 static const struct attribute_group pci_bridge_group
= {
1730 .attrs
= pci_bridge_attrs
,
1733 const struct attribute_group
*pci_bridge_groups
[] = {
1738 static const struct attribute_group pcie_dev_group
= {
1739 .attrs
= pcie_dev_attrs
,
1742 const struct attribute_group
*pcie_dev_groups
[] = {
1747 static struct attribute_group pci_dev_hp_attr_group
= {
1748 .attrs
= pci_dev_hp_attrs
,
1749 .is_visible
= pci_dev_hp_attrs_are_visible
,
1752 #ifdef CONFIG_PCI_IOV
1753 static struct attribute
*sriov_dev_attrs
[] = {
1754 &sriov_totalvfs_attr
.attr
,
1755 &sriov_numvfs_attr
.attr
,
1756 &sriov_drivers_autoprobe_attr
.attr
,
1760 static umode_t
sriov_attrs_are_visible(struct kobject
*kobj
,
1761 struct attribute
*a
, int n
)
1763 struct device
*dev
= kobj_to_dev(kobj
);
1765 if (!dev_is_pf(dev
))
1771 static struct attribute_group sriov_dev_attr_group
= {
1772 .attrs
= sriov_dev_attrs
,
1773 .is_visible
= sriov_attrs_are_visible
,
1775 #endif /* CONFIG_PCI_IOV */
1777 static struct attribute_group pci_dev_attr_group
= {
1778 .attrs
= pci_dev_dev_attrs
,
1779 .is_visible
= pci_dev_attrs_are_visible
,
1782 static struct attribute_group pci_bridge_attr_group
= {
1783 .attrs
= pci_bridge_attrs
,
1784 .is_visible
= pci_bridge_attrs_are_visible
,
1787 static struct attribute_group pcie_dev_attr_group
= {
1788 .attrs
= pcie_dev_attrs
,
1789 .is_visible
= pcie_dev_attrs_are_visible
,
1792 static const struct attribute_group
*pci_dev_attr_groups
[] = {
1793 &pci_dev_attr_group
,
1794 &pci_dev_hp_attr_group
,
1795 #ifdef CONFIG_PCI_IOV
1796 &sriov_dev_attr_group
,
1798 &pci_bridge_attr_group
,
1799 &pcie_dev_attr_group
,
1803 struct device_type pci_dev_type
= {
1804 .groups
= pci_dev_attr_groups
,