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