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