1// SPDX-License-Identifier: GPL-2.0 2/* 3 * (C) Copyright 2002-2004 Greg Kroah-Hartman <greg@kroah.com> 4 * (C) Copyright 2002-2004 IBM Corp. 5 * (C) Copyright 2003 Matthew Wilcox 6 * (C) Copyright 2003 Hewlett-Packard 7 * (C) Copyright 2004 Jon Smirl <jonsmirl@yahoo.com> 8 * (C) Copyright 2004 Silicon Graphics, Inc. Jesse Barnes <jbarnes@sgi.com> 9 * 10 * File attributes for PCI devices 11 * 12 * Modeled after usb's driverfs.c 13 */ 14 15 16#include <linux/kernel.h> 17#include <linux/sched.h> 18#include <linux/pci.h> 19#include <linux/stat.h> 20#include <linux/export.h> 21#include <linux/topology.h> 22#include <linux/mm.h> 23#include <linux/fs.h> 24#include <linux/capability.h> 25#include <linux/security.h> 26#include <linux/slab.h> 27#include <linux/vgaarb.h> 28#include <linux/pm_runtime.h> 29#include <linux/of.h> 30#include "pci.h" 31 32static int sysfs_initialized; /* = 0 */ 33 34/* show configuration fields */ 35#define pci_config_attr(field, format_string) \ 36static ssize_t \ 37field##_show(struct device *dev, struct device_attribute *attr, char *buf) \ 38{ \ 39 struct pci_dev *pdev; \ 40 \ 41 pdev = to_pci_dev(dev); \ 42 return sprintf(buf, format_string, pdev->field); \ 43} \ 44static DEVICE_ATTR_RO(field) 45 46pci_config_attr(vendor, "0x%04x\n"); 47pci_config_attr(device, "0x%04x\n"); 48pci_config_attr(subsystem_vendor, "0x%04x\n"); 49pci_config_attr(subsystem_device, "0x%04x\n"); 50pci_config_attr(revision, "0x%02x\n"); 51pci_config_attr(class, "0x%06x\n"); 52pci_config_attr(irq, "%u\n"); 53 54static ssize_t broken_parity_status_show(struct device *dev, 55 struct device_attribute *attr, 56 char *buf) 57{ 58 struct pci_dev *pdev = to_pci_dev(dev); 59 return sprintf(buf, "%u\n", pdev->broken_parity_status); 60} 61 62static ssize_t broken_parity_status_store(struct device *dev, 63 struct device_attribute *attr, 64 const char *buf, size_t count) 65{ 66 struct pci_dev *pdev = to_pci_dev(dev); 67 unsigned long val; 68 69 if (kstrtoul(buf, 0, &val) < 0) 70 return -EINVAL; 71 72 pdev->broken_parity_status = !!val; 73 74 return count; 75} 76static DEVICE_ATTR_RW(broken_parity_status); 77 78static ssize_t pci_dev_show_local_cpu(struct device *dev, bool list, 79 struct device_attribute *attr, char *buf) 80{ 81 const struct cpumask *mask; 82 83#ifdef CONFIG_NUMA 84 mask = (dev_to_node(dev) == -1) ? cpu_online_mask : 85 cpumask_of_node(dev_to_node(dev)); 86#else 87 mask = cpumask_of_pcibus(to_pci_dev(dev)->bus); 88#endif 89 return cpumap_print_to_pagebuf(list, buf, mask); 90} 91 92static ssize_t local_cpus_show(struct device *dev, 93 struct device_attribute *attr, char *buf) 94{ 95 return pci_dev_show_local_cpu(dev, false, attr, buf); 96} 97static DEVICE_ATTR_RO(local_cpus); 98 99static ssize_t local_cpulist_show(struct device *dev, 100 struct device_attribute *attr, char *buf) 101{ 102 return pci_dev_show_local_cpu(dev, true, attr, buf); 103} 104static DEVICE_ATTR_RO(local_cpulist); 105 106/* 107 * PCI Bus Class Devices 108 */ 109static ssize_t cpuaffinity_show(struct device *dev, 110 struct device_attribute *attr, char *buf) 111{ 112 const struct cpumask *cpumask = cpumask_of_pcibus(to_pci_bus(dev)); 113 114 return cpumap_print_to_pagebuf(false, buf, cpumask); 115} 116static DEVICE_ATTR_RO(cpuaffinity); 117 118static ssize_t cpulistaffinity_show(struct device *dev, 119 struct device_attribute *attr, char *buf) 120{ 121 const struct cpumask *cpumask = cpumask_of_pcibus(to_pci_bus(dev)); 122 123 return cpumap_print_to_pagebuf(true, buf, cpumask); 124} 125static DEVICE_ATTR_RO(cpulistaffinity); 126 127/* show resources */ 128static ssize_t resource_show(struct device *dev, struct device_attribute *attr, 129 char *buf) 130{ 131 struct pci_dev *pci_dev = to_pci_dev(dev); 132 char *str = buf; 133 int i; 134 int max; 135 resource_size_t start, end; 136 137 if (pci_dev->subordinate) 138 max = DEVICE_COUNT_RESOURCE; 139 else 140 max = PCI_BRIDGE_RESOURCES; 141 142 for (i = 0; i < max; i++) { 143 struct resource *res = &pci_dev->resource[i]; 144 pci_resource_to_user(pci_dev, i, res, &start, &end); 145 str += sprintf(str, "0x%016llx 0x%016llx 0x%016llx\n", 146 (unsigned long long)start, 147 (unsigned long long)end, 148 (unsigned long long)res->flags); 149 } 150 return (str - buf); 151} 152static DEVICE_ATTR_RO(resource); 153 154static ssize_t max_link_speed_show(struct device *dev, 155 struct device_attribute *attr, char *buf) 156{ 157 struct pci_dev *pdev = to_pci_dev(dev); 158 159 return sprintf(buf, "%s\n", 160 pci_speed_string(pcie_get_speed_cap(pdev))); 161} 162static DEVICE_ATTR_RO(max_link_speed); 163 164static ssize_t max_link_width_show(struct device *dev, 165 struct device_attribute *attr, char *buf) 166{ 167 struct pci_dev *pdev = to_pci_dev(dev); 168 169 return sprintf(buf, "%u\n", pcie_get_width_cap(pdev)); 170} 171static DEVICE_ATTR_RO(max_link_width); 172 173static ssize_t current_link_speed_show(struct device *dev, 174 struct device_attribute *attr, char *buf) 175{ 176 struct pci_dev *pci_dev = to_pci_dev(dev); 177 u16 linkstat; 178 int err; 179 enum pci_bus_speed speed; 180 181 err = pcie_capability_read_word(pci_dev, PCI_EXP_LNKSTA, &linkstat); 182 if (err) 183 return -EINVAL; 184 185 speed = pcie_link_speed[linkstat & PCI_EXP_LNKSTA_CLS]; 186 187 return sprintf(buf, "%s\n", pci_speed_string(speed)); 188} 189static DEVICE_ATTR_RO(current_link_speed); 190 191static ssize_t current_link_width_show(struct device *dev, 192 struct device_attribute *attr, char *buf) 193{ 194 struct pci_dev *pci_dev = to_pci_dev(dev); 195 u16 linkstat; 196 int err; 197 198 err = pcie_capability_read_word(pci_dev, PCI_EXP_LNKSTA, &linkstat); 199 if (err) 200 return -EINVAL; 201 202 return sprintf(buf, "%u\n", 203 (linkstat & PCI_EXP_LNKSTA_NLW) >> PCI_EXP_LNKSTA_NLW_SHIFT); 204} 205static DEVICE_ATTR_RO(current_link_width); 206 207static ssize_t secondary_bus_number_show(struct device *dev, 208 struct device_attribute *attr, 209 char *buf) 210{ 211 struct pci_dev *pci_dev = to_pci_dev(dev); 212 u8 sec_bus; 213 int err; 214 215 err = pci_read_config_byte(pci_dev, PCI_SECONDARY_BUS, &sec_bus); 216 if (err) 217 return -EINVAL; 218 219 return sprintf(buf, "%u\n", sec_bus); 220} 221static DEVICE_ATTR_RO(secondary_bus_number); 222 223static ssize_t subordinate_bus_number_show(struct device *dev, 224 struct device_attribute *attr, 225 char *buf) 226{ 227 struct pci_dev *pci_dev = to_pci_dev(dev); 228 u8 sub_bus; 229 int err; 230 231 err = pci_read_config_byte(pci_dev, PCI_SUBORDINATE_BUS, &sub_bus); 232 if (err) 233 return -EINVAL; 234 235 return sprintf(buf, "%u\n", sub_bus); 236} 237static DEVICE_ATTR_RO(subordinate_bus_number); 238 239static ssize_t ari_enabled_show(struct device *dev, 240 struct device_attribute *attr, 241 char *buf) 242{ 243 struct pci_dev *pci_dev = to_pci_dev(dev); 244 245 return sprintf(buf, "%u\n", pci_ari_enabled(pci_dev->bus)); 246} 247static DEVICE_ATTR_RO(ari_enabled); 248 249static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 250 char *buf) 251{ 252 struct pci_dev *pci_dev = to_pci_dev(dev); 253 254 return sprintf(buf, "pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02X\n", 255 pci_dev->vendor, pci_dev->device, 256 pci_dev->subsystem_vendor, pci_dev->subsystem_device, 257 (u8)(pci_dev->class >> 16), (u8)(pci_dev->class >> 8), 258 (u8)(pci_dev->class)); 259} 260static DEVICE_ATTR_RO(modalias); 261 262static ssize_t enable_store(struct device *dev, struct device_attribute *attr, 263 const char *buf, size_t count) 264{ 265 struct pci_dev *pdev = to_pci_dev(dev); 266 unsigned long val; 267 ssize_t result = kstrtoul(buf, 0, &val); 268 269 if (result < 0) 270 return result; 271 272 /* this can crash the machine when done on the "wrong" device */ 273 if (!capable(CAP_SYS_ADMIN)) 274 return -EPERM; 275 276 device_lock(dev); 277 if (dev->driver) 278 result = -EBUSY; 279 else if (val) 280 result = pci_enable_device(pdev); 281 else if (pci_is_enabled(pdev)) 282 pci_disable_device(pdev); 283 else 284 result = -EIO; 285 device_unlock(dev); 286 287 return result < 0 ? result : count; 288} 289 290static ssize_t enable_show(struct device *dev, struct device_attribute *attr, 291 char *buf) 292{ 293 struct pci_dev *pdev; 294 295 pdev = to_pci_dev(dev); 296 return sprintf(buf, "%u\n", atomic_read(&pdev->enable_cnt)); 297} 298static DEVICE_ATTR_RW(enable); 299 300#ifdef CONFIG_NUMA 301static ssize_t numa_node_store(struct device *dev, 302 struct device_attribute *attr, const char *buf, 303 size_t count) 304{ 305 struct pci_dev *pdev = to_pci_dev(dev); 306 int node, ret; 307 308 if (!capable(CAP_SYS_ADMIN)) 309 return -EPERM; 310 311 ret = kstrtoint(buf, 0, &node); 312 if (ret) 313 return ret; 314 315 if ((node < 0 && node != NUMA_NO_NODE) || node >= MAX_NUMNODES) 316 return -EINVAL; 317 318 if (node != NUMA_NO_NODE && !node_online(node)) 319 return -EINVAL; 320 321 add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK); 322 pci_alert(pdev, FW_BUG "Overriding NUMA node to %d. Contact your vendor for updates.", 323 node); 324 325 dev->numa_node = node; 326 return count; 327} 328 329static ssize_t numa_node_show(struct device *dev, struct device_attribute *attr, 330 char *buf) 331{ 332 return sprintf(buf, "%d\n", dev->numa_node); 333} 334static DEVICE_ATTR_RW(numa_node); 335#endif 336 337static ssize_t dma_mask_bits_show(struct device *dev, 338 struct device_attribute *attr, char *buf) 339{ 340 struct pci_dev *pdev = to_pci_dev(dev); 341 342 return sprintf(buf, "%d\n", fls64(pdev->dma_mask)); 343} 344static DEVICE_ATTR_RO(dma_mask_bits); 345 346static ssize_t consistent_dma_mask_bits_show(struct device *dev, 347 struct device_attribute *attr, 348 char *buf) 349{ 350 return sprintf(buf, "%d\n", fls64(dev->coherent_dma_mask)); 351} 352static DEVICE_ATTR_RO(consistent_dma_mask_bits); 353 354static ssize_t msi_bus_show(struct device *dev, struct device_attribute *attr, 355 char *buf) 356{ 357 struct pci_dev *pdev = to_pci_dev(dev); 358 struct pci_bus *subordinate = pdev->subordinate; 359 360 return sprintf(buf, "%u\n", subordinate ? 361 !(subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI) 362 : !pdev->no_msi); 363} 364 365static ssize_t msi_bus_store(struct device *dev, struct device_attribute *attr, 366 const char *buf, size_t count) 367{ 368 struct pci_dev *pdev = to_pci_dev(dev); 369 struct pci_bus *subordinate = pdev->subordinate; 370 unsigned long val; 371 372 if (kstrtoul(buf, 0, &val) < 0) 373 return -EINVAL; 374 375 if (!capable(CAP_SYS_ADMIN)) 376 return -EPERM; 377 378 /* 379 * "no_msi" and "bus_flags" only affect what happens when a driver 380 * requests MSI or MSI-X. They don't affect any drivers that have 381 * already requested MSI or MSI-X. 382 */ 383 if (!subordinate) { 384 pdev->no_msi = !val; 385 pci_info(pdev, "MSI/MSI-X %s for future drivers\n", 386 val ? "allowed" : "disallowed"); 387 return count; 388 } 389 390 if (val) 391 subordinate->bus_flags &= ~PCI_BUS_FLAGS_NO_MSI; 392 else 393 subordinate->bus_flags |= PCI_BUS_FLAGS_NO_MSI; 394 395 dev_info(&subordinate->dev, "MSI/MSI-X %s for future drivers of devices on this bus\n", 396 val ? "allowed" : "disallowed"); 397 return count; 398} 399static DEVICE_ATTR_RW(msi_bus); 400 401static ssize_t rescan_store(struct bus_type *bus, const char *buf, size_t count) 402{ 403 unsigned long val; 404 struct pci_bus *b = NULL; 405 406 if (kstrtoul(buf, 0, &val) < 0) 407 return -EINVAL; 408 409 if (val) { 410 pci_lock_rescan_remove(); 411 while ((b = pci_find_next_bus(b)) != NULL) 412 pci_rescan_bus(b); 413 pci_unlock_rescan_remove(); 414 } 415 return count; 416} 417static BUS_ATTR_WO(rescan); 418 419static struct attribute *pci_bus_attrs[] = { 420 &bus_attr_rescan.attr, 421 NULL, 422}; 423 424static const struct attribute_group pci_bus_group = { 425 .attrs = pci_bus_attrs, 426}; 427 428const struct attribute_group *pci_bus_groups[] = { 429 &pci_bus_group, 430 NULL, 431}; 432 433static ssize_t dev_rescan_store(struct device *dev, 434 struct device_attribute *attr, const char *buf, 435 size_t count) 436{ 437 unsigned long val; 438 struct pci_dev *pdev = to_pci_dev(dev); 439 440 if (kstrtoul(buf, 0, &val) < 0) 441 return -EINVAL; 442 443 if (val) { 444 pci_lock_rescan_remove(); 445 pci_rescan_bus(pdev->bus); 446 pci_unlock_rescan_remove(); 447 } 448 return count; 449} 450static struct device_attribute dev_attr_dev_rescan = __ATTR(rescan, 0200, NULL, 451 dev_rescan_store); 452 453static ssize_t remove_store(struct device *dev, struct device_attribute *attr, 454 const char *buf, size_t count) 455{ 456 unsigned long val; 457 458 if (kstrtoul(buf, 0, &val) < 0) 459 return -EINVAL; 460 461 if (val && device_remove_file_self(dev, attr)) 462 pci_stop_and_remove_bus_device_locked(to_pci_dev(dev)); 463 return count; 464} 465static DEVICE_ATTR_IGNORE_LOCKDEP(remove, 0220, NULL, 466 remove_store); 467 468static ssize_t bus_rescan_store(struct device *dev, 469 struct device_attribute *attr, 470 const char *buf, size_t count) 471{ 472 unsigned long val; 473 struct pci_bus *bus = to_pci_bus(dev); 474 475 if (kstrtoul(buf, 0, &val) < 0) 476 return -EINVAL; 477 478 if (val) { 479 pci_lock_rescan_remove(); 480 if (!pci_is_root_bus(bus) && list_empty(&bus->devices)) 481 pci_rescan_bus_bridge_resize(bus->self); 482 else 483 pci_rescan_bus(bus); 484 pci_unlock_rescan_remove(); 485 } 486 return count; 487} 488static struct device_attribute dev_attr_bus_rescan = __ATTR(rescan, 0200, NULL, 489 bus_rescan_store); 490 491#if defined(CONFIG_PM) && defined(CONFIG_ACPI) 492static ssize_t d3cold_allowed_store(struct device *dev, 493 struct device_attribute *attr, 494 const char *buf, size_t count) 495{ 496 struct pci_dev *pdev = to_pci_dev(dev); 497 unsigned long val; 498 499 if (kstrtoul(buf, 0, &val) < 0) 500 return -EINVAL; 501 502 pdev->d3cold_allowed = !!val; 503 pci_bridge_d3_update(pdev); 504 505 pm_runtime_resume(dev); 506 507 return count; 508} 509 510static ssize_t d3cold_allowed_show(struct device *dev, 511 struct device_attribute *attr, char *buf) 512{ 513 struct pci_dev *pdev = to_pci_dev(dev); 514 return sprintf(buf, "%u\n", pdev->d3cold_allowed); 515} 516static DEVICE_ATTR_RW(d3cold_allowed); 517#endif 518 519#ifdef CONFIG_OF 520static ssize_t devspec_show(struct device *dev, 521 struct device_attribute *attr, char *buf) 522{ 523 struct pci_dev *pdev = to_pci_dev(dev); 524 struct device_node *np = pci_device_to_OF_node(pdev); 525 526 if (np == NULL) 527 return 0; 528 return sprintf(buf, "%pOF", np); 529} 530static DEVICE_ATTR_RO(devspec); 531#endif 532 533static ssize_t driver_override_store(struct device *dev, 534 struct device_attribute *attr, 535 const char *buf, size_t count) 536{ 537 struct pci_dev *pdev = to_pci_dev(dev); 538 char *driver_override, *old, *cp; 539 540 /* We need to keep extra room for a newline */ 541 if (count >= (PAGE_SIZE - 1)) 542 return -EINVAL; 543 544 driver_override = kstrndup(buf, count, GFP_KERNEL); 545 if (!driver_override) 546 return -ENOMEM; 547 548 cp = strchr(driver_override, '\n'); 549 if (cp) 550 *cp = '\0'; 551 552 device_lock(dev); 553 old = pdev->driver_override; 554 if (strlen(driver_override)) { 555 pdev->driver_override = driver_override; 556 } else { 557 kfree(driver_override); 558 pdev->driver_override = NULL; 559 } 560 device_unlock(dev); 561 562 kfree(old); 563 564 return count; 565} 566 567static ssize_t driver_override_show(struct device *dev, 568 struct device_attribute *attr, char *buf) 569{ 570 struct pci_dev *pdev = to_pci_dev(dev); 571 ssize_t len; 572 573 device_lock(dev); 574 len = scnprintf(buf, PAGE_SIZE, "%s\n", pdev->driver_override); 575 device_unlock(dev); 576 return len; 577} 578static DEVICE_ATTR_RW(driver_override); 579 580static struct attribute *pci_dev_attrs[] = { 581 &dev_attr_resource.attr, 582 &dev_attr_vendor.attr, 583 &dev_attr_device.attr, 584 &dev_attr_subsystem_vendor.attr, 585 &dev_attr_subsystem_device.attr, 586 &dev_attr_revision.attr, 587 &dev_attr_class.attr, 588 &dev_attr_irq.attr, 589 &dev_attr_local_cpus.attr, 590 &dev_attr_local_cpulist.attr, 591 &dev_attr_modalias.attr, 592#ifdef CONFIG_NUMA 593 &dev_attr_numa_node.attr, 594#endif 595 &dev_attr_dma_mask_bits.attr, 596 &dev_attr_consistent_dma_mask_bits.attr, 597 &dev_attr_enable.attr, 598 &dev_attr_broken_parity_status.attr, 599 &dev_attr_msi_bus.attr, 600#if defined(CONFIG_PM) && defined(CONFIG_ACPI) 601 &dev_attr_d3cold_allowed.attr, 602#endif 603#ifdef CONFIG_OF 604 &dev_attr_devspec.attr, 605#endif 606 &dev_attr_driver_override.attr, 607 &dev_attr_ari_enabled.attr, 608 NULL, 609}; 610 611static struct attribute *pci_bridge_attrs[] = { 612 &dev_attr_subordinate_bus_number.attr, 613 &dev_attr_secondary_bus_number.attr, 614 NULL, 615}; 616 617static struct attribute *pcie_dev_attrs[] = { 618 &dev_attr_current_link_speed.attr, 619 &dev_attr_current_link_width.attr, 620 &dev_attr_max_link_width.attr, 621 &dev_attr_max_link_speed.attr, 622 NULL, 623}; 624 625static struct attribute *pcibus_attrs[] = { 626 &dev_attr_bus_rescan.attr, 627 &dev_attr_cpuaffinity.attr, 628 &dev_attr_cpulistaffinity.attr, 629 NULL, 630}; 631 632static const struct attribute_group pcibus_group = { 633 .attrs = pcibus_attrs, 634}; 635 636const struct attribute_group *pcibus_groups[] = { 637 &pcibus_group, 638 NULL, 639}; 640 641static ssize_t boot_vga_show(struct device *dev, struct device_attribute *attr, 642 char *buf) 643{ 644 struct pci_dev *pdev = to_pci_dev(dev); 645 struct pci_dev *vga_dev = vga_default_device(); 646 647 if (vga_dev) 648 return sprintf(buf, "%u\n", (pdev == vga_dev)); 649 650 return sprintf(buf, "%u\n", 651 !!(pdev->resource[PCI_ROM_RESOURCE].flags & 652 IORESOURCE_ROM_SHADOW)); 653} 654static DEVICE_ATTR_RO(boot_vga); 655 656static ssize_t pci_read_config(struct file *filp, struct kobject *kobj, 657 struct bin_attribute *bin_attr, char *buf, 658 loff_t off, size_t count) 659{ 660 struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj)); 661 unsigned int size = 64; 662 loff_t init_off = off; 663 u8 *data = (u8 *) buf; 664 665 /* Several chips lock up trying to read undefined config space */ 666 if (file_ns_capable(filp, &init_user_ns, CAP_SYS_ADMIN)) 667 size = dev->cfg_size; 668 else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) 669 size = 128; 670 671 if (off > size) 672 return 0; 673 if (off + count > size) { 674 size -= off; 675 count = size; 676 } else { 677 size = count; 678 } 679 680 pci_config_pm_runtime_get(dev); 681 682 if ((off & 1) && size) { 683 u8 val; 684 pci_user_read_config_byte(dev, off, &val); 685 data[off - init_off] = val; 686 off++; 687 size--; 688 } 689 690 if ((off & 3) && size > 2) { 691 u16 val; 692 pci_user_read_config_word(dev, off, &val); 693 data[off - init_off] = val & 0xff; 694 data[off - init_off + 1] = (val >> 8) & 0xff; 695 off += 2; 696 size -= 2; 697 } 698 699 while (size > 3) { 700 u32 val; 701 pci_user_read_config_dword(dev, off, &val); 702 data[off - init_off] = val & 0xff; 703 data[off - init_off + 1] = (val >> 8) & 0xff; 704 data[off - init_off + 2] = (val >> 16) & 0xff; 705 data[off - init_off + 3] = (val >> 24) & 0xff; 706 off += 4; 707 size -= 4; 708 cond_resched(); 709 } 710 711 if (size >= 2) { 712 u16 val; 713 pci_user_read_config_word(dev, off, &val); 714 data[off - init_off] = val & 0xff; 715 data[off - init_off + 1] = (val >> 8) & 0xff; 716 off += 2; 717 size -= 2; 718 } 719 720 if (size > 0) { 721 u8 val; 722 pci_user_read_config_byte(dev, off, &val); 723 data[off - init_off] = val; 724 off++; 725 --size; 726 } 727 728 pci_config_pm_runtime_put(dev); 729 730 return count; 731} 732 733static ssize_t pci_write_config(struct file *filp, struct kobject *kobj, 734 struct bin_attribute *bin_attr, char *buf, 735 loff_t off, size_t count) 736{ 737 struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj)); 738 unsigned int size = count; 739 loff_t init_off = off; 740 u8 *data = (u8 *) buf; 741 int ret; 742 743 ret = security_locked_down(LOCKDOWN_PCI_ACCESS); 744 if (ret) 745 return ret; 746 747 if (off > dev->cfg_size) 748 return 0; 749 if (off + count > dev->cfg_size) { 750 size = dev->cfg_size - off; 751 count = size; 752 } 753 754 pci_config_pm_runtime_get(dev); 755 756 if ((off & 1) && size) { 757 pci_user_write_config_byte(dev, off, data[off - init_off]); 758 off++; 759 size--; 760 } 761 762 if ((off & 3) && size > 2) { 763 u16 val = data[off - init_off]; 764 val |= (u16) data[off - init_off + 1] << 8; 765 pci_user_write_config_word(dev, off, val); 766 off += 2; 767 size -= 2; 768 } 769 770 while (size > 3) { 771 u32 val = data[off - init_off]; 772 val |= (u32) data[off - init_off + 1] << 8; 773 val |= (u32) data[off - init_off + 2] << 16; 774 val |= (u32) data[off - init_off + 3] << 24; 775 pci_user_write_config_dword(dev, off, val); 776 off += 4; 777 size -= 4; 778 } 779 780 if (size >= 2) { 781 u16 val = data[off - init_off]; 782 val |= (u16) data[off - init_off + 1] << 8; 783 pci_user_write_config_word(dev, off, val); 784 off += 2; 785 size -= 2; 786 } 787 788 if (size) { 789 pci_user_write_config_byte(dev, off, data[off - init_off]); 790 off++; 791 --size; 792 } 793 794 pci_config_pm_runtime_put(dev); 795 796 return count; 797} 798 799#ifdef HAVE_PCI_LEGACY 800/** 801 * pci_read_legacy_io - read byte(s) from legacy I/O port space 802 * @filp: open sysfs file 803 * @kobj: kobject corresponding to file to read from 804 * @bin_attr: struct bin_attribute for this file 805 * @buf: buffer to store results 806 * @off: offset into legacy I/O port space 807 * @count: number of bytes to read 808 * 809 * Reads 1, 2, or 4 bytes from legacy I/O port space using an arch specific 810 * callback routine (pci_legacy_read). 811 */ 812static ssize_t pci_read_legacy_io(struct file *filp, struct kobject *kobj, 813 struct bin_attribute *bin_attr, char *buf, 814 loff_t off, size_t count) 815{ 816 struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj)); 817 818 /* Only support 1, 2 or 4 byte accesses */ 819 if (count != 1 && count != 2 && count != 4) 820 return -EINVAL; 821 822 return pci_legacy_read(bus, off, (u32 *)buf, count); 823} 824 825/** 826 * pci_write_legacy_io - write byte(s) to legacy I/O port space 827 * @filp: open sysfs file 828 * @kobj: kobject corresponding to file to read from 829 * @bin_attr: struct bin_attribute for this file 830 * @buf: buffer containing value to be written 831 * @off: offset into legacy I/O port space 832 * @count: number of bytes to write 833 * 834 * Writes 1, 2, or 4 bytes from legacy I/O port space using an arch specific 835 * callback routine (pci_legacy_write). 836 */ 837static ssize_t pci_write_legacy_io(struct file *filp, struct kobject *kobj, 838 struct bin_attribute *bin_attr, char *buf, 839 loff_t off, size_t count) 840{ 841 struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj)); 842 843 /* Only support 1, 2 or 4 byte accesses */ 844 if (count != 1 && count != 2 && count != 4) 845 return -EINVAL; 846 847 return pci_legacy_write(bus, off, *(u32 *)buf, count); 848} 849 850/** 851 * pci_mmap_legacy_mem - map legacy PCI memory into user memory space 852 * @filp: open sysfs file 853 * @kobj: kobject corresponding to device to be mapped 854 * @attr: struct bin_attribute for this file 855 * @vma: struct vm_area_struct passed to mmap 856 * 857 * Uses an arch specific callback, pci_mmap_legacy_mem_page_range, to mmap 858 * legacy memory space (first meg of bus space) into application virtual 859 * memory space. 860 */ 861static int pci_mmap_legacy_mem(struct file *filp, struct kobject *kobj, 862 struct bin_attribute *attr, 863 struct vm_area_struct *vma) 864{ 865 struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj)); 866 867 return pci_mmap_legacy_page_range(bus, vma, pci_mmap_mem); 868} 869 870/** 871 * pci_mmap_legacy_io - map legacy PCI IO into user memory space 872 * @filp: open sysfs file 873 * @kobj: kobject corresponding to device to be mapped 874 * @attr: struct bin_attribute for this file 875 * @vma: struct vm_area_struct passed to mmap 876 * 877 * Uses an arch specific callback, pci_mmap_legacy_io_page_range, to mmap 878 * legacy IO space (first meg of bus space) into application virtual 879 * memory space. Returns -ENOSYS if the operation isn't supported 880 */ 881static int pci_mmap_legacy_io(struct file *filp, struct kobject *kobj, 882 struct bin_attribute *attr, 883 struct vm_area_struct *vma) 884{ 885 struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj)); 886 887 return pci_mmap_legacy_page_range(bus, vma, pci_mmap_io); 888} 889 890/** 891 * pci_adjust_legacy_attr - adjustment of legacy file attributes 892 * @b: bus to create files under 893 * @mmap_type: I/O port or memory 894 * 895 * Stub implementation. Can be overridden by arch if necessary. 896 */ 897void __weak pci_adjust_legacy_attr(struct pci_bus *b, 898 enum pci_mmap_state mmap_type) 899{ 900} 901 902/** 903 * pci_create_legacy_files - create legacy I/O port and memory files 904 * @b: bus to create files under 905 * 906 * Some platforms allow access to legacy I/O port and ISA memory space on 907 * a per-bus basis. This routine creates the files and ties them into 908 * their associated read, write and mmap files from pci-sysfs.c 909 * 910 * On error unwind, but don't propagate the error to the caller 911 * as it is ok to set up the PCI bus without these files. 912 */ 913void pci_create_legacy_files(struct pci_bus *b) 914{ 915 int error; 916 917 b->legacy_io = kcalloc(2, sizeof(struct bin_attribute), 918 GFP_ATOMIC); 919 if (!b->legacy_io) 920 goto kzalloc_err; 921 922 sysfs_bin_attr_init(b->legacy_io); 923 b->legacy_io->attr.name = "legacy_io"; 924 b->legacy_io->size = 0xffff; 925 b->legacy_io->attr.mode = 0600; 926 b->legacy_io->read = pci_read_legacy_io; 927 b->legacy_io->write = pci_write_legacy_io; 928 b->legacy_io->mmap = pci_mmap_legacy_io; 929 pci_adjust_legacy_attr(b, pci_mmap_io); 930 error = device_create_bin_file(&b->dev, b->legacy_io); 931 if (error) 932 goto legacy_io_err; 933 934 /* Allocated above after the legacy_io struct */ 935 b->legacy_mem = b->legacy_io + 1; 936 sysfs_bin_attr_init(b->legacy_mem); 937 b->legacy_mem->attr.name = "legacy_mem"; 938 b->legacy_mem->size = 1024*1024; 939 b->legacy_mem->attr.mode = 0600; 940 b->legacy_mem->mmap = pci_mmap_legacy_mem; 941 pci_adjust_legacy_attr(b, pci_mmap_mem); 942 error = device_create_bin_file(&b->dev, b->legacy_mem); 943 if (error) 944 goto legacy_mem_err; 945 946 return; 947 948legacy_mem_err: 949 device_remove_bin_file(&b->dev, b->legacy_io); 950legacy_io_err: 951 kfree(b->legacy_io); 952 b->legacy_io = NULL; 953kzalloc_err: 954 dev_warn(&b->dev, "could not create legacy I/O port and ISA memory resources in sysfs\n"); 955} 956 957void pci_remove_legacy_files(struct pci_bus *b) 958{ 959 if (b->legacy_io) { 960 device_remove_bin_file(&b->dev, b->legacy_io); 961 device_remove_bin_file(&b->dev, b->legacy_mem); 962 kfree(b->legacy_io); /* both are allocated here */ 963 } 964} 965#endif /* HAVE_PCI_LEGACY */ 966 967#if defined(HAVE_PCI_MMAP) || defined(ARCH_GENERIC_PCI_MMAP_RESOURCE) 968 969int pci_mmap_fits(struct pci_dev *pdev, int resno, struct vm_area_struct *vma, 970 enum pci_mmap_api mmap_api) 971{ 972 unsigned long nr, start, size; 973 resource_size_t pci_start = 0, pci_end; 974 975 if (pci_resource_len(pdev, resno) == 0) 976 return 0; 977 nr = vma_pages(vma); 978 start = vma->vm_pgoff; 979 size = ((pci_resource_len(pdev, resno) - 1) >> PAGE_SHIFT) + 1; 980 if (mmap_api == PCI_MMAP_PROCFS) { 981 pci_resource_to_user(pdev, resno, &pdev->resource[resno], 982 &pci_start, &pci_end); 983 pci_start >>= PAGE_SHIFT; 984 } 985 if (start >= pci_start && start < pci_start + size && 986 start + nr <= pci_start + size) 987 return 1; 988 return 0; 989} 990 991/** 992 * pci_mmap_resource - map a PCI resource into user memory space 993 * @kobj: kobject for mapping 994 * @attr: struct bin_attribute for the file being mapped 995 * @vma: struct vm_area_struct passed into the mmap 996 * @write_combine: 1 for write_combine mapping 997 * 998 * Use the regular PCI mapping routines to map a PCI resource into userspace. 999 */ 1000static int pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr, 1001 struct vm_area_struct *vma, int write_combine) 1002{ 1003 struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj)); 1004 int bar = (unsigned long)attr->private; 1005 enum pci_mmap_state mmap_type; 1006 struct resource *res = &pdev->resource[bar]; 1007 int ret; 1008 1009 ret = security_locked_down(LOCKDOWN_PCI_ACCESS); 1010 if (ret) 1011 return ret; 1012 1013 if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(res->start)) 1014 return -EINVAL; 1015 1016 if (!pci_mmap_fits(pdev, bar, vma, PCI_MMAP_SYSFS)) 1017 return -EINVAL; 1018 1019 mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io; 1020 1021 return pci_mmap_resource_range(pdev, bar, vma, mmap_type, write_combine); 1022} 1023 1024static int pci_mmap_resource_uc(struct file *filp, struct kobject *kobj, 1025 struct bin_attribute *attr, 1026 struct vm_area_struct *vma) 1027{ 1028 return pci_mmap_resource(kobj, attr, vma, 0); 1029} 1030 1031static int pci_mmap_resource_wc(struct file *filp, struct kobject *kobj, 1032 struct bin_attribute *attr, 1033 struct vm_area_struct *vma) 1034{ 1035 return pci_mmap_resource(kobj, attr, vma, 1); 1036} 1037 1038static ssize_t pci_resource_io(struct file *filp, struct kobject *kobj, 1039 struct bin_attribute *attr, char *buf, 1040 loff_t off, size_t count, bool write) 1041{ 1042 struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj)); 1043 int bar = (unsigned long)attr->private; 1044 unsigned long port = off; 1045 1046 port += pci_resource_start(pdev, bar); 1047 1048 if (port > pci_resource_end(pdev, bar)) 1049 return 0; 1050 1051 if (port + count - 1 > pci_resource_end(pdev, bar)) 1052 return -EINVAL; 1053 1054 switch (count) { 1055 case 1: 1056 if (write) 1057 outb(*(u8 *)buf, port); 1058 else 1059 *(u8 *)buf = inb(port); 1060 return 1; 1061 case 2: 1062 if (write) 1063 outw(*(u16 *)buf, port); 1064 else 1065 *(u16 *)buf = inw(port); 1066 return 2; 1067 case 4: 1068 if (write) 1069 outl(*(u32 *)buf, port); 1070 else 1071 *(u32 *)buf = inl(port); 1072 return 4; 1073 } 1074 return -EINVAL; 1075} 1076 1077static ssize_t pci_read_resource_io(struct file *filp, struct kobject *kobj, 1078 struct bin_attribute *attr, char *buf, 1079 loff_t off, size_t count) 1080{ 1081 return pci_resource_io(filp, kobj, attr, buf, off, count, false); 1082} 1083 1084static ssize_t pci_write_resource_io(struct file *filp, struct kobject *kobj, 1085 struct bin_attribute *attr, char *buf, 1086 loff_t off, size_t count) 1087{ 1088 int ret; 1089 1090 ret = security_locked_down(LOCKDOWN_PCI_ACCESS); 1091 if (ret) 1092 return ret; 1093 1094 return pci_resource_io(filp, kobj, attr, buf, off, count, true); 1095} 1096 1097/** 1098 * pci_remove_resource_files - cleanup resource files 1099 * @pdev: dev to cleanup 1100 * 1101 * If we created resource files for @pdev, remove them from sysfs and 1102 * free their resources. 1103 */ 1104static void pci_remove_resource_files(struct pci_dev *pdev) 1105{ 1106 int i; 1107 1108 for (i = 0; i < PCI_STD_NUM_BARS; i++) { 1109 struct bin_attribute *res_attr; 1110 1111 res_attr = pdev->res_attr[i]; 1112 if (res_attr) { 1113 sysfs_remove_bin_file(&pdev->dev.kobj, res_attr); 1114 kfree(res_attr); 1115 } 1116 1117 res_attr = pdev->res_attr_wc[i]; 1118 if (res_attr) { 1119 sysfs_remove_bin_file(&pdev->dev.kobj, res_attr); 1120 kfree(res_attr); 1121 } 1122 } 1123} 1124 1125static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine) 1126{ 1127 /* allocate attribute structure, piggyback attribute name */ 1128 int name_len = write_combine ? 13 : 10; 1129 struct bin_attribute *res_attr; 1130 char *res_attr_name; 1131 int retval; 1132 1133 res_attr = kzalloc(sizeof(*res_attr) + name_len, GFP_ATOMIC); 1134 if (!res_attr) 1135 return -ENOMEM; 1136 1137 res_attr_name = (char *)(res_attr + 1); 1138 1139 sysfs_bin_attr_init(res_attr); 1140 if (write_combine) { 1141 sprintf(res_attr_name, "resource%d_wc", num); 1142 res_attr->mmap = pci_mmap_resource_wc; 1143 } else { 1144 sprintf(res_attr_name, "resource%d", num); 1145 if (pci_resource_flags(pdev, num) & IORESOURCE_IO) { 1146 res_attr->read = pci_read_resource_io; 1147 res_attr->write = pci_write_resource_io; 1148 if (arch_can_pci_mmap_io()) 1149 res_attr->mmap = pci_mmap_resource_uc; 1150 } else { 1151 res_attr->mmap = pci_mmap_resource_uc; 1152 } 1153 } 1154 res_attr->attr.name = res_attr_name; 1155 res_attr->attr.mode = 0600; 1156 res_attr->size = pci_resource_len(pdev, num); 1157 res_attr->private = (void *)(unsigned long)num; 1158 retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr); 1159 if (retval) { 1160 kfree(res_attr); 1161 return retval; 1162 } 1163 1164 if (write_combine) 1165 pdev->res_attr_wc[num] = res_attr; 1166 else 1167 pdev->res_attr[num] = res_attr; 1168 1169 return 0; 1170} 1171 1172/** 1173 * pci_create_resource_files - create resource files in sysfs for @dev 1174 * @pdev: dev in question 1175 * 1176 * Walk the resources in @pdev creating files for each resource available. 1177 */ 1178static int pci_create_resource_files(struct pci_dev *pdev) 1179{ 1180 int i; 1181 int retval; 1182 1183 /* Expose the PCI resources from this device as files */ 1184 for (i = 0; i < PCI_STD_NUM_BARS; i++) { 1185 1186 /* skip empty resources */ 1187 if (!pci_resource_len(pdev, i)) 1188 continue; 1189 1190 retval = pci_create_attr(pdev, i, 0); 1191 /* for prefetchable resources, create a WC mappable file */ 1192 if (!retval && arch_can_pci_mmap_wc() && 1193 pdev->resource[i].flags & IORESOURCE_PREFETCH) 1194 retval = pci_create_attr(pdev, i, 1); 1195 if (retval) { 1196 pci_remove_resource_files(pdev); 1197 return retval; 1198 } 1199 } 1200 return 0; 1201} 1202#else /* !(defined(HAVE_PCI_MMAP) || defined(ARCH_GENERIC_PCI_MMAP_RESOURCE)) */ 1203int __weak pci_create_resource_files(struct pci_dev *dev) { return 0; } 1204void __weak pci_remove_resource_files(struct pci_dev *dev) { return; } 1205#endif 1206 1207/** 1208 * pci_write_rom - used to enable access to the PCI ROM display 1209 * @filp: sysfs file 1210 * @kobj: kernel object handle 1211 * @bin_attr: struct bin_attribute for this file 1212 * @buf: user input 1213 * @off: file offset 1214 * @count: number of byte in input 1215 * 1216 * writing anything except 0 enables it 1217 */ 1218static ssize_t pci_write_rom(struct file *filp, struct kobject *kobj, 1219 struct bin_attribute *bin_attr, char *buf, 1220 loff_t off, size_t count) 1221{ 1222 struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj)); 1223 1224 if ((off == 0) && (*buf == '0') && (count == 2)) 1225 pdev->rom_attr_enabled = 0; 1226 else 1227 pdev->rom_attr_enabled = 1; 1228 1229 return count; 1230} 1231 1232/** 1233 * pci_read_rom - read a PCI ROM 1234 * @filp: sysfs file 1235 * @kobj: kernel object handle 1236 * @bin_attr: struct bin_attribute for this file 1237 * @buf: where to put the data we read from the ROM 1238 * @off: file offset 1239 * @count: number of bytes to read 1240 * 1241 * Put @count bytes starting at @off into @buf from the ROM in the PCI 1242 * device corresponding to @kobj. 1243 */ 1244static ssize_t pci_read_rom(struct file *filp, struct kobject *kobj, 1245 struct bin_attribute *bin_attr, char *buf, 1246 loff_t off, size_t count) 1247{ 1248 struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj)); 1249 void __iomem *rom; 1250 size_t size; 1251 1252 if (!pdev->rom_attr_enabled) 1253 return -EINVAL; 1254 1255 rom = pci_map_rom(pdev, &size); /* size starts out as PCI window size */ 1256 if (!rom || !size) 1257 return -EIO; 1258 1259 if (off >= size) 1260 count = 0; 1261 else { 1262 if (off + count > size) 1263 count = size - off; 1264 1265 memcpy_fromio(buf, rom + off, count); 1266 } 1267 pci_unmap_rom(pdev, rom); 1268 1269 return count; 1270} 1271 1272static const struct bin_attribute pci_config_attr = { 1273 .attr = { 1274 .name = "config", 1275 .mode = 0644, 1276 }, 1277 .size = PCI_CFG_SPACE_SIZE, 1278 .read = pci_read_config, 1279 .write = pci_write_config, 1280}; 1281 1282static const struct bin_attribute pcie_config_attr = { 1283 .attr = { 1284 .name = "config", 1285 .mode = 0644, 1286 }, 1287 .size = PCI_CFG_SPACE_EXP_SIZE, 1288 .read = pci_read_config, 1289 .write = pci_write_config, 1290}; 1291 1292static ssize_t reset_store(struct device *dev, struct device_attribute *attr, 1293 const char *buf, size_t count) 1294{ 1295 struct pci_dev *pdev = to_pci_dev(dev); 1296 unsigned long val; 1297 ssize_t result = kstrtoul(buf, 0, &val); 1298 1299 if (result < 0) 1300 return result; 1301 1302 if (val != 1) 1303 return -EINVAL; 1304 1305 pm_runtime_get_sync(dev); 1306 result = pci_reset_function(pdev); 1307 pm_runtime_put(dev); 1308 if (result < 0) 1309 return result; 1310 1311 return count; 1312} 1313 1314static DEVICE_ATTR(reset, 0200, NULL, reset_store); 1315 1316static int pci_create_capabilities_sysfs(struct pci_dev *dev) 1317{ 1318 int retval; 1319 1320 pcie_vpd_create_sysfs_dev_files(dev); 1321 1322 if (dev->reset_fn) { 1323 retval = device_create_file(&dev->dev, &dev_attr_reset); 1324 if (retval) 1325 goto error; 1326 } 1327 return 0; 1328 1329error: 1330 pcie_vpd_remove_sysfs_dev_files(dev); 1331 return retval; 1332} 1333 1334int __must_check pci_create_sysfs_dev_files(struct pci_dev *pdev) 1335{ 1336 int retval; 1337 int rom_size; 1338 struct bin_attribute *attr; 1339 1340 if (!sysfs_initialized) 1341 return -EACCES; 1342 1343 if (pdev->cfg_size > PCI_CFG_SPACE_SIZE) 1344 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr); 1345 else 1346 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr); 1347 if (retval) 1348 goto err; 1349 1350 retval = pci_create_resource_files(pdev); 1351 if (retval) 1352 goto err_config_file; 1353 1354 /* If the device has a ROM, try to expose it in sysfs. */ 1355 rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE); 1356 if (rom_size) { 1357 attr = kzalloc(sizeof(*attr), GFP_ATOMIC); 1358 if (!attr) { 1359 retval = -ENOMEM; 1360 goto err_resource_files; 1361 } 1362 sysfs_bin_attr_init(attr); 1363 attr->size = rom_size; 1364 attr->attr.name = "rom"; 1365 attr->attr.mode = 0600; 1366 attr->read = pci_read_rom; 1367 attr->write = pci_write_rom; 1368 retval = sysfs_create_bin_file(&pdev->dev.kobj, attr); 1369 if (retval) { 1370 kfree(attr); 1371 goto err_resource_files; 1372 } 1373 pdev->rom_attr = attr; 1374 } 1375 1376 /* add sysfs entries for various capabilities */ 1377 retval = pci_create_capabilities_sysfs(pdev); 1378 if (retval) 1379 goto err_rom_file; 1380 1381 pci_create_firmware_label_files(pdev); 1382 1383 return 0; 1384 1385err_rom_file: 1386 if (pdev->rom_attr) { 1387 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr); 1388 kfree(pdev->rom_attr); 1389 pdev->rom_attr = NULL; 1390 } 1391err_resource_files: 1392 pci_remove_resource_files(pdev); 1393err_config_file: 1394 if (pdev->cfg_size > PCI_CFG_SPACE_SIZE) 1395 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr); 1396 else 1397 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr); 1398err: 1399 return retval; 1400} 1401 1402static void pci_remove_capabilities_sysfs(struct pci_dev *dev) 1403{ 1404 pcie_vpd_remove_sysfs_dev_files(dev); 1405 if (dev->reset_fn) { 1406 device_remove_file(&dev->dev, &dev_attr_reset); 1407 dev->reset_fn = 0; 1408 } 1409} 1410 1411/** 1412 * pci_remove_sysfs_dev_files - cleanup PCI specific sysfs files 1413 * @pdev: device whose entries we should free 1414 * 1415 * Cleanup when @pdev is removed from sysfs. 1416 */ 1417void pci_remove_sysfs_dev_files(struct pci_dev *pdev) 1418{ 1419 if (!sysfs_initialized) 1420 return; 1421 1422 pci_remove_capabilities_sysfs(pdev); 1423 1424 if (pdev->cfg_size > PCI_CFG_SPACE_SIZE) 1425 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr); 1426 else 1427 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr); 1428 1429 pci_remove_resource_files(pdev); 1430 1431 if (pdev->rom_attr) { 1432 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr); 1433 kfree(pdev->rom_attr); 1434 pdev->rom_attr = NULL; 1435 } 1436 1437 pci_remove_firmware_label_files(pdev); 1438} 1439 1440static int __init pci_sysfs_init(void) 1441{ 1442 struct pci_dev *pdev = NULL; 1443 int retval; 1444 1445 sysfs_initialized = 1; 1446 for_each_pci_dev(pdev) { 1447 retval = pci_create_sysfs_dev_files(pdev); 1448 if (retval) { 1449 pci_dev_put(pdev); 1450 return retval; 1451 } 1452 } 1453 1454 return 0; 1455} 1456late_initcall(pci_sysfs_init); 1457 1458static struct attribute *pci_dev_dev_attrs[] = { 1459 &dev_attr_boot_vga.attr, 1460 NULL, 1461}; 1462 1463static umode_t pci_dev_attrs_are_visible(struct kobject *kobj, 1464 struct attribute *a, int n) 1465{ 1466 struct device *dev = kobj_to_dev(kobj); 1467 struct pci_dev *pdev = to_pci_dev(dev); 1468 1469 if (a == &dev_attr_boot_vga.attr) 1470 if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA) 1471 return 0; 1472 1473 return a->mode; 1474} 1475 1476static struct attribute *pci_dev_hp_attrs[] = { 1477 &dev_attr_remove.attr, 1478 &dev_attr_dev_rescan.attr, 1479 NULL, 1480}; 1481 1482static umode_t pci_dev_hp_attrs_are_visible(struct kobject *kobj, 1483 struct attribute *a, int n) 1484{ 1485 struct device *dev = kobj_to_dev(kobj); 1486 struct pci_dev *pdev = to_pci_dev(dev); 1487 1488 if (pdev->is_virtfn) 1489 return 0; 1490 1491 return a->mode; 1492} 1493 1494static umode_t pci_bridge_attrs_are_visible(struct kobject *kobj, 1495 struct attribute *a, int n) 1496{ 1497 struct device *dev = kobj_to_dev(kobj); 1498 struct pci_dev *pdev = to_pci_dev(dev); 1499 1500 if (pci_is_bridge(pdev)) 1501 return a->mode; 1502 1503 return 0; 1504} 1505 1506static umode_t pcie_dev_attrs_are_visible(struct kobject *kobj, 1507 struct attribute *a, int n) 1508{ 1509 struct device *dev = kobj_to_dev(kobj); 1510 struct pci_dev *pdev = to_pci_dev(dev); 1511 1512 if (pci_is_pcie(pdev)) 1513 return a->mode; 1514 1515 return 0; 1516} 1517 1518static const struct attribute_group pci_dev_group = { 1519 .attrs = pci_dev_attrs, 1520}; 1521 1522const struct attribute_group *pci_dev_groups[] = { 1523 &pci_dev_group, 1524 NULL, 1525}; 1526 1527static const struct attribute_group pci_dev_hp_attr_group = { 1528 .attrs = pci_dev_hp_attrs, 1529 .is_visible = pci_dev_hp_attrs_are_visible, 1530}; 1531 1532static const struct attribute_group pci_dev_attr_group = { 1533 .attrs = pci_dev_dev_attrs, 1534 .is_visible = pci_dev_attrs_are_visible, 1535}; 1536 1537static const struct attribute_group pci_bridge_attr_group = { 1538 .attrs = pci_bridge_attrs, 1539 .is_visible = pci_bridge_attrs_are_visible, 1540}; 1541 1542static const struct attribute_group pcie_dev_attr_group = { 1543 .attrs = pcie_dev_attrs, 1544 .is_visible = pcie_dev_attrs_are_visible, 1545}; 1546 1547static const struct attribute_group *pci_dev_attr_groups[] = { 1548 &pci_dev_attr_group, 1549 &pci_dev_hp_attr_group, 1550#ifdef CONFIG_PCI_IOV 1551 &sriov_dev_attr_group, 1552#endif 1553 &pci_bridge_attr_group, 1554 &pcie_dev_attr_group, 1555#ifdef CONFIG_PCIEAER 1556 &aer_stats_attr_group, 1557#endif 1558#ifdef CONFIG_PCIEASPM 1559 &aspm_ctrl_attr_group, 1560#endif 1561 NULL, 1562}; 1563 1564const struct device_type pci_dev_type = { 1565 .groups = pci_dev_attr_groups, 1566}; 1567