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 struct pci_sriov *iov = pdev->sriov; 476 int ret; 477 u16 num_vfs; 478 479 ret = kstrtou16(buf, 0, &num_vfs); 480 if (ret < 0) 481 return ret; 482 483 if (num_vfs > pci_sriov_get_totalvfs(pdev)) 484 return -ERANGE; 485 486 mutex_lock(&iov->dev->sriov->lock); 487 488 if (num_vfs == pdev->sriov->num_VFs) 489 goto exit; 490 491 /* is PF driver loaded w/callback */ 492 if (!pdev->driver || !pdev->driver->sriov_configure) { 493 dev_info(&pdev->dev, "Driver doesn't support SRIOV configuration via sysfs\n"); 494 ret = -ENOENT; 495 goto exit; 496 } 497 498 if (num_vfs == 0) { 499 /* disable VFs */ 500 ret = pdev->driver->sriov_configure(pdev, 0); 501 goto exit; 502 } 503 504 /* enable VFs */ 505 if (pdev->sriov->num_VFs) { 506 dev_warn(&pdev->dev, "%d VFs already enabled. Disable before enabling %d VFs\n", 507 pdev->sriov->num_VFs, num_vfs); 508 ret = -EBUSY; 509 goto exit; 510 } 511 512 ret = pdev->driver->sriov_configure(pdev, num_vfs); 513 if (ret < 0) 514 goto exit; 515 516 if (ret != num_vfs) 517 dev_warn(&pdev->dev, "%d VFs requested; only %d enabled\n", 518 num_vfs, ret); 519 520 exit: 521 mutex_unlock(&iov->dev->sriov->lock); 522 523 if (ret < 0) 524 return ret; 525 526 return count; 527 } 528 529 static struct device_attribute sriov_totalvfs_attr = __ATTR_RO(sriov_totalvfs); 530 static struct device_attribute sriov_numvfs_attr = 531 __ATTR(sriov_numvfs, (S_IRUGO|S_IWUSR|S_IWGRP), 532 sriov_numvfs_show, sriov_numvfs_store); 533 #endif /* CONFIG_PCI_IOV */ 534 535 static ssize_t driver_override_store(struct device *dev, 536 struct device_attribute *attr, 537 const char *buf, size_t count) 538 { 539 struct pci_dev *pdev = to_pci_dev(dev); 540 char *driver_override, *old = pdev->driver_override, *cp; 541 542 /* We need to keep extra room for a newline */ 543 if (count >= (PAGE_SIZE - 1)) 544 return -EINVAL; 545 546 driver_override = kstrndup(buf, count, GFP_KERNEL); 547 if (!driver_override) 548 return -ENOMEM; 549 550 cp = strchr(driver_override, '\n'); 551 if (cp) 552 *cp = '\0'; 553 554 if (strlen(driver_override)) { 555 pdev->driver_override = driver_override; 556 } else { 557 kfree(driver_override); 558 pdev->driver_override = NULL; 559 } 560 561 kfree(old); 562 563 return count; 564 } 565 566 static ssize_t driver_override_show(struct device *dev, 567 struct device_attribute *attr, char *buf) 568 { 569 struct pci_dev *pdev = to_pci_dev(dev); 570 571 return snprintf(buf, PAGE_SIZE, "%s\n", pdev->driver_override); 572 } 573 static DEVICE_ATTR_RW(driver_override); 574 575 static struct attribute *pci_dev_attrs[] = { 576 &dev_attr_resource.attr, 577 &dev_attr_vendor.attr, 578 &dev_attr_device.attr, 579 &dev_attr_subsystem_vendor.attr, 580 &dev_attr_subsystem_device.attr, 581 &dev_attr_revision.attr, 582 &dev_attr_class.attr, 583 &dev_attr_irq.attr, 584 &dev_attr_local_cpus.attr, 585 &dev_attr_local_cpulist.attr, 586 &dev_attr_modalias.attr, 587 #ifdef CONFIG_NUMA 588 &dev_attr_numa_node.attr, 589 #endif 590 &dev_attr_dma_mask_bits.attr, 591 &dev_attr_consistent_dma_mask_bits.attr, 592 &dev_attr_enable.attr, 593 &dev_attr_broken_parity_status.attr, 594 &dev_attr_msi_bus.attr, 595 #if defined(CONFIG_PM) && defined(CONFIG_ACPI) 596 &dev_attr_d3cold_allowed.attr, 597 #endif 598 #ifdef CONFIG_OF 599 &dev_attr_devspec.attr, 600 #endif 601 &dev_attr_driver_override.attr, 602 NULL, 603 }; 604 605 static const struct attribute_group pci_dev_group = { 606 .attrs = pci_dev_attrs, 607 }; 608 609 const struct attribute_group *pci_dev_groups[] = { 610 &pci_dev_group, 611 NULL, 612 }; 613 614 static struct attribute *pcibus_attrs[] = { 615 &dev_attr_rescan.attr, 616 &dev_attr_cpuaffinity.attr, 617 &dev_attr_cpulistaffinity.attr, 618 NULL, 619 }; 620 621 static const struct attribute_group pcibus_group = { 622 .attrs = pcibus_attrs, 623 }; 624 625 const struct attribute_group *pcibus_groups[] = { 626 &pcibus_group, 627 NULL, 628 }; 629 630 static ssize_t boot_vga_show(struct device *dev, struct device_attribute *attr, 631 char *buf) 632 { 633 struct pci_dev *pdev = to_pci_dev(dev); 634 struct pci_dev *vga_dev = vga_default_device(); 635 636 if (vga_dev) 637 return sprintf(buf, "%u\n", (pdev == vga_dev)); 638 639 return sprintf(buf, "%u\n", 640 !!(pdev->resource[PCI_ROM_RESOURCE].flags & 641 IORESOURCE_ROM_SHADOW)); 642 } 643 static struct device_attribute vga_attr = __ATTR_RO(boot_vga); 644 645 static ssize_t pci_read_config(struct file *filp, struct kobject *kobj, 646 struct bin_attribute *bin_attr, char *buf, 647 loff_t off, size_t count) 648 { 649 struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj)); 650 unsigned int size = 64; 651 loff_t init_off = off; 652 u8 *data = (u8 *) buf; 653 654 /* Several chips lock up trying to read undefined config space */ 655 if (file_ns_capable(filp, &init_user_ns, CAP_SYS_ADMIN)) 656 size = dev->cfg_size; 657 else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) 658 size = 128; 659 660 if (off > size) 661 return 0; 662 if (off + count > size) { 663 size -= off; 664 count = size; 665 } else { 666 size = count; 667 } 668 669 pci_config_pm_runtime_get(dev); 670 671 if ((off & 1) && size) { 672 u8 val; 673 pci_user_read_config_byte(dev, off, &val); 674 data[off - init_off] = val; 675 off++; 676 size--; 677 } 678 679 if ((off & 3) && size > 2) { 680 u16 val; 681 pci_user_read_config_word(dev, off, &val); 682 data[off - init_off] = val & 0xff; 683 data[off - init_off + 1] = (val >> 8) & 0xff; 684 off += 2; 685 size -= 2; 686 } 687 688 while (size > 3) { 689 u32 val; 690 pci_user_read_config_dword(dev, off, &val); 691 data[off - init_off] = val & 0xff; 692 data[off - init_off + 1] = (val >> 8) & 0xff; 693 data[off - init_off + 2] = (val >> 16) & 0xff; 694 data[off - init_off + 3] = (val >> 24) & 0xff; 695 off += 4; 696 size -= 4; 697 } 698 699 if (size >= 2) { 700 u16 val; 701 pci_user_read_config_word(dev, off, &val); 702 data[off - init_off] = val & 0xff; 703 data[off - init_off + 1] = (val >> 8) & 0xff; 704 off += 2; 705 size -= 2; 706 } 707 708 if (size > 0) { 709 u8 val; 710 pci_user_read_config_byte(dev, off, &val); 711 data[off - init_off] = val; 712 off++; 713 --size; 714 } 715 716 pci_config_pm_runtime_put(dev); 717 718 return count; 719 } 720 721 static ssize_t pci_write_config(struct file *filp, struct kobject *kobj, 722 struct bin_attribute *bin_attr, char *buf, 723 loff_t off, size_t count) 724 { 725 struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj)); 726 unsigned int size = count; 727 loff_t init_off = off; 728 u8 *data = (u8 *) buf; 729 730 if (off > dev->cfg_size) 731 return 0; 732 if (off + count > dev->cfg_size) { 733 size = dev->cfg_size - off; 734 count = size; 735 } 736 737 pci_config_pm_runtime_get(dev); 738 739 if ((off & 1) && size) { 740 pci_user_write_config_byte(dev, off, data[off - init_off]); 741 off++; 742 size--; 743 } 744 745 if ((off & 3) && size > 2) { 746 u16 val = data[off - init_off]; 747 val |= (u16) data[off - init_off + 1] << 8; 748 pci_user_write_config_word(dev, off, val); 749 off += 2; 750 size -= 2; 751 } 752 753 while (size > 3) { 754 u32 val = data[off - init_off]; 755 val |= (u32) data[off - init_off + 1] << 8; 756 val |= (u32) data[off - init_off + 2] << 16; 757 val |= (u32) data[off - init_off + 3] << 24; 758 pci_user_write_config_dword(dev, off, val); 759 off += 4; 760 size -= 4; 761 } 762 763 if (size >= 2) { 764 u16 val = data[off - init_off]; 765 val |= (u16) data[off - init_off + 1] << 8; 766 pci_user_write_config_word(dev, off, val); 767 off += 2; 768 size -= 2; 769 } 770 771 if (size) { 772 pci_user_write_config_byte(dev, off, data[off - init_off]); 773 off++; 774 --size; 775 } 776 777 pci_config_pm_runtime_put(dev); 778 779 return count; 780 } 781 782 static ssize_t read_vpd_attr(struct file *filp, struct kobject *kobj, 783 struct bin_attribute *bin_attr, char *buf, 784 loff_t off, size_t count) 785 { 786 struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj)); 787 788 if (bin_attr->size > 0) { 789 if (off > bin_attr->size) 790 count = 0; 791 else if (count > bin_attr->size - off) 792 count = bin_attr->size - off; 793 } 794 795 return pci_read_vpd(dev, off, count, buf); 796 } 797 798 static ssize_t write_vpd_attr(struct file *filp, struct kobject *kobj, 799 struct bin_attribute *bin_attr, char *buf, 800 loff_t off, size_t count) 801 { 802 struct pci_dev *dev = to_pci_dev(kobj_to_dev(kobj)); 803 804 if (bin_attr->size > 0) { 805 if (off > bin_attr->size) 806 count = 0; 807 else if (count > bin_attr->size - off) 808 count = bin_attr->size - off; 809 } 810 811 return pci_write_vpd(dev, off, count, buf); 812 } 813 814 #ifdef HAVE_PCI_LEGACY 815 /** 816 * pci_read_legacy_io - read byte(s) from legacy I/O port space 817 * @filp: open sysfs file 818 * @kobj: kobject corresponding to file to read from 819 * @bin_attr: struct bin_attribute for this file 820 * @buf: buffer to store results 821 * @off: offset into legacy I/O port space 822 * @count: number of bytes to read 823 * 824 * Reads 1, 2, or 4 bytes from legacy I/O port space using an arch specific 825 * callback routine (pci_legacy_read). 826 */ 827 static ssize_t pci_read_legacy_io(struct file *filp, struct kobject *kobj, 828 struct bin_attribute *bin_attr, char *buf, 829 loff_t off, size_t count) 830 { 831 struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj)); 832 833 /* Only support 1, 2 or 4 byte accesses */ 834 if (count != 1 && count != 2 && count != 4) 835 return -EINVAL; 836 837 return pci_legacy_read(bus, off, (u32 *)buf, count); 838 } 839 840 /** 841 * pci_write_legacy_io - write byte(s) to legacy I/O port space 842 * @filp: open sysfs file 843 * @kobj: kobject corresponding to file to read from 844 * @bin_attr: struct bin_attribute for this file 845 * @buf: buffer containing value to be written 846 * @off: offset into legacy I/O port space 847 * @count: number of bytes to write 848 * 849 * Writes 1, 2, or 4 bytes from legacy I/O port space using an arch specific 850 * callback routine (pci_legacy_write). 851 */ 852 static ssize_t pci_write_legacy_io(struct file *filp, struct kobject *kobj, 853 struct bin_attribute *bin_attr, char *buf, 854 loff_t off, size_t count) 855 { 856 struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj)); 857 858 /* Only support 1, 2 or 4 byte accesses */ 859 if (count != 1 && count != 2 && count != 4) 860 return -EINVAL; 861 862 return pci_legacy_write(bus, off, *(u32 *)buf, count); 863 } 864 865 /** 866 * pci_mmap_legacy_mem - map legacy PCI memory into user memory space 867 * @filp: open sysfs file 868 * @kobj: kobject corresponding to device to be mapped 869 * @attr: struct bin_attribute for this file 870 * @vma: struct vm_area_struct passed to mmap 871 * 872 * Uses an arch specific callback, pci_mmap_legacy_mem_page_range, to mmap 873 * legacy memory space (first meg of bus space) into application virtual 874 * memory space. 875 */ 876 static int pci_mmap_legacy_mem(struct file *filp, struct kobject *kobj, 877 struct bin_attribute *attr, 878 struct vm_area_struct *vma) 879 { 880 struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj)); 881 882 return pci_mmap_legacy_page_range(bus, vma, pci_mmap_mem); 883 } 884 885 /** 886 * pci_mmap_legacy_io - map legacy PCI IO into user memory space 887 * @filp: open sysfs file 888 * @kobj: kobject corresponding to device to be mapped 889 * @attr: struct bin_attribute for this file 890 * @vma: struct vm_area_struct passed to mmap 891 * 892 * Uses an arch specific callback, pci_mmap_legacy_io_page_range, to mmap 893 * legacy IO space (first meg of bus space) into application virtual 894 * memory space. Returns -ENOSYS if the operation isn't supported 895 */ 896 static int pci_mmap_legacy_io(struct file *filp, struct kobject *kobj, 897 struct bin_attribute *attr, 898 struct vm_area_struct *vma) 899 { 900 struct pci_bus *bus = to_pci_bus(kobj_to_dev(kobj)); 901 902 return pci_mmap_legacy_page_range(bus, vma, pci_mmap_io); 903 } 904 905 /** 906 * pci_adjust_legacy_attr - adjustment of legacy file attributes 907 * @b: bus to create files under 908 * @mmap_type: I/O port or memory 909 * 910 * Stub implementation. Can be overridden by arch if necessary. 911 */ 912 void __weak pci_adjust_legacy_attr(struct pci_bus *b, 913 enum pci_mmap_state mmap_type) 914 { 915 } 916 917 /** 918 * pci_create_legacy_files - create legacy I/O port and memory files 919 * @b: bus to create files under 920 * 921 * Some platforms allow access to legacy I/O port and ISA memory space on 922 * a per-bus basis. This routine creates the files and ties them into 923 * their associated read, write and mmap files from pci-sysfs.c 924 * 925 * On error unwind, but don't propagate the error to the caller 926 * as it is ok to set up the PCI bus without these files. 927 */ 928 void pci_create_legacy_files(struct pci_bus *b) 929 { 930 int error; 931 932 b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2, 933 GFP_ATOMIC); 934 if (!b->legacy_io) 935 goto kzalloc_err; 936 937 sysfs_bin_attr_init(b->legacy_io); 938 b->legacy_io->attr.name = "legacy_io"; 939 b->legacy_io->size = 0xffff; 940 b->legacy_io->attr.mode = S_IRUSR | S_IWUSR; 941 b->legacy_io->read = pci_read_legacy_io; 942 b->legacy_io->write = pci_write_legacy_io; 943 b->legacy_io->mmap = pci_mmap_legacy_io; 944 pci_adjust_legacy_attr(b, pci_mmap_io); 945 error = device_create_bin_file(&b->dev, b->legacy_io); 946 if (error) 947 goto legacy_io_err; 948 949 /* Allocated above after the legacy_io struct */ 950 b->legacy_mem = b->legacy_io + 1; 951 sysfs_bin_attr_init(b->legacy_mem); 952 b->legacy_mem->attr.name = "legacy_mem"; 953 b->legacy_mem->size = 1024*1024; 954 b->legacy_mem->attr.mode = S_IRUSR | S_IWUSR; 955 b->legacy_mem->mmap = pci_mmap_legacy_mem; 956 pci_adjust_legacy_attr(b, pci_mmap_mem); 957 error = device_create_bin_file(&b->dev, b->legacy_mem); 958 if (error) 959 goto legacy_mem_err; 960 961 return; 962 963 legacy_mem_err: 964 device_remove_bin_file(&b->dev, b->legacy_io); 965 legacy_io_err: 966 kfree(b->legacy_io); 967 b->legacy_io = NULL; 968 kzalloc_err: 969 printk(KERN_WARNING "pci: warning: could not create legacy I/O port and ISA memory resources to sysfs\n"); 970 return; 971 } 972 973 void pci_remove_legacy_files(struct pci_bus *b) 974 { 975 if (b->legacy_io) { 976 device_remove_bin_file(&b->dev, b->legacy_io); 977 device_remove_bin_file(&b->dev, b->legacy_mem); 978 kfree(b->legacy_io); /* both are allocated here */ 979 } 980 } 981 #endif /* HAVE_PCI_LEGACY */ 982 983 #ifdef HAVE_PCI_MMAP 984 985 int pci_mmap_fits(struct pci_dev *pdev, int resno, struct vm_area_struct *vma, 986 enum pci_mmap_api mmap_api) 987 { 988 unsigned long nr, start, size, pci_start; 989 990 if (pci_resource_len(pdev, resno) == 0) 991 return 0; 992 nr = vma_pages(vma); 993 start = vma->vm_pgoff; 994 size = ((pci_resource_len(pdev, resno) - 1) >> PAGE_SHIFT) + 1; 995 pci_start = (mmap_api == PCI_MMAP_PROCFS) ? 996 pci_resource_start(pdev, resno) >> PAGE_SHIFT : 0; 997 if (start >= pci_start && start < pci_start + size && 998 start + nr <= pci_start + size) 999 return 1; 1000 return 0; 1001 } 1002 1003 /** 1004 * pci_mmap_resource - map a PCI resource into user memory space 1005 * @kobj: kobject for mapping 1006 * @attr: struct bin_attribute for the file being mapped 1007 * @vma: struct vm_area_struct passed into the mmap 1008 * @write_combine: 1 for write_combine mapping 1009 * 1010 * Use the regular PCI mapping routines to map a PCI resource into userspace. 1011 */ 1012 static int pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr, 1013 struct vm_area_struct *vma, int write_combine) 1014 { 1015 struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj)); 1016 struct resource *res = attr->private; 1017 enum pci_mmap_state mmap_type; 1018 resource_size_t start, end; 1019 int i; 1020 1021 for (i = 0; i < PCI_ROM_RESOURCE; i++) 1022 if (res == &pdev->resource[i]) 1023 break; 1024 if (i >= PCI_ROM_RESOURCE) 1025 return -ENODEV; 1026 1027 if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(res->start)) 1028 return -EINVAL; 1029 1030 if (!pci_mmap_fits(pdev, i, vma, PCI_MMAP_SYSFS)) { 1031 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", 1032 current->comm, vma->vm_end-vma->vm_start, vma->vm_pgoff, 1033 pci_name(pdev), i, 1034 (u64)pci_resource_start(pdev, i), 1035 (u64)pci_resource_len(pdev, i)); 1036 return -EINVAL; 1037 } 1038 1039 /* pci_mmap_page_range() expects the same kind of entry as coming 1040 * from /proc/bus/pci/ which is a "user visible" value. If this is 1041 * different from the resource itself, arch will do necessary fixup. 1042 */ 1043 pci_resource_to_user(pdev, i, res, &start, &end); 1044 vma->vm_pgoff += start >> PAGE_SHIFT; 1045 mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io; 1046 return pci_mmap_page_range(pdev, vma, mmap_type, write_combine); 1047 } 1048 1049 static int pci_mmap_resource_uc(struct file *filp, struct kobject *kobj, 1050 struct bin_attribute *attr, 1051 struct vm_area_struct *vma) 1052 { 1053 return pci_mmap_resource(kobj, attr, vma, 0); 1054 } 1055 1056 static int pci_mmap_resource_wc(struct file *filp, struct kobject *kobj, 1057 struct bin_attribute *attr, 1058 struct vm_area_struct *vma) 1059 { 1060 return pci_mmap_resource(kobj, attr, vma, 1); 1061 } 1062 1063 static ssize_t pci_resource_io(struct file *filp, struct kobject *kobj, 1064 struct bin_attribute *attr, char *buf, 1065 loff_t off, size_t count, bool write) 1066 { 1067 struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj)); 1068 struct resource *res = attr->private; 1069 unsigned long port = off; 1070 int i; 1071 1072 for (i = 0; i < PCI_ROM_RESOURCE; i++) 1073 if (res == &pdev->resource[i]) 1074 break; 1075 if (i >= PCI_ROM_RESOURCE) 1076 return -ENODEV; 1077 1078 port += pci_resource_start(pdev, i); 1079 1080 if (port > pci_resource_end(pdev, i)) 1081 return 0; 1082 1083 if (port + count - 1 > pci_resource_end(pdev, i)) 1084 return -EINVAL; 1085 1086 switch (count) { 1087 case 1: 1088 if (write) 1089 outb(*(u8 *)buf, port); 1090 else 1091 *(u8 *)buf = inb(port); 1092 return 1; 1093 case 2: 1094 if (write) 1095 outw(*(u16 *)buf, port); 1096 else 1097 *(u16 *)buf = inw(port); 1098 return 2; 1099 case 4: 1100 if (write) 1101 outl(*(u32 *)buf, port); 1102 else 1103 *(u32 *)buf = inl(port); 1104 return 4; 1105 } 1106 return -EINVAL; 1107 } 1108 1109 static ssize_t pci_read_resource_io(struct file *filp, struct kobject *kobj, 1110 struct bin_attribute *attr, char *buf, 1111 loff_t off, size_t count) 1112 { 1113 return pci_resource_io(filp, kobj, attr, buf, off, count, false); 1114 } 1115 1116 static ssize_t pci_write_resource_io(struct file *filp, struct kobject *kobj, 1117 struct bin_attribute *attr, char *buf, 1118 loff_t off, size_t count) 1119 { 1120 return pci_resource_io(filp, kobj, attr, buf, off, count, true); 1121 } 1122 1123 /** 1124 * pci_remove_resource_files - cleanup resource files 1125 * @pdev: dev to cleanup 1126 * 1127 * If we created resource files for @pdev, remove them from sysfs and 1128 * free their resources. 1129 */ 1130 static void pci_remove_resource_files(struct pci_dev *pdev) 1131 { 1132 int i; 1133 1134 for (i = 0; i < PCI_ROM_RESOURCE; i++) { 1135 struct bin_attribute *res_attr; 1136 1137 res_attr = pdev->res_attr[i]; 1138 if (res_attr) { 1139 sysfs_remove_bin_file(&pdev->dev.kobj, res_attr); 1140 kfree(res_attr); 1141 } 1142 1143 res_attr = pdev->res_attr_wc[i]; 1144 if (res_attr) { 1145 sysfs_remove_bin_file(&pdev->dev.kobj, res_attr); 1146 kfree(res_attr); 1147 } 1148 } 1149 } 1150 1151 static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine) 1152 { 1153 /* allocate attribute structure, piggyback attribute name */ 1154 int name_len = write_combine ? 13 : 10; 1155 struct bin_attribute *res_attr; 1156 char *res_attr_name; 1157 int retval; 1158 1159 res_attr = kzalloc(sizeof(*res_attr) + name_len, GFP_ATOMIC); 1160 if (!res_attr) 1161 return -ENOMEM; 1162 1163 res_attr_name = (char *)(res_attr + 1); 1164 1165 sysfs_bin_attr_init(res_attr); 1166 if (write_combine) { 1167 pdev->res_attr_wc[num] = res_attr; 1168 sprintf(res_attr_name, "resource%d_wc", num); 1169 res_attr->mmap = pci_mmap_resource_wc; 1170 } else { 1171 pdev->res_attr[num] = res_attr; 1172 sprintf(res_attr_name, "resource%d", num); 1173 res_attr->mmap = pci_mmap_resource_uc; 1174 } 1175 if (pci_resource_flags(pdev, num) & IORESOURCE_IO) { 1176 res_attr->read = pci_read_resource_io; 1177 res_attr->write = pci_write_resource_io; 1178 } 1179 res_attr->attr.name = res_attr_name; 1180 res_attr->attr.mode = S_IRUSR | S_IWUSR; 1181 res_attr->size = pci_resource_len(pdev, num); 1182 res_attr->private = &pdev->resource[num]; 1183 retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr); 1184 if (retval) 1185 kfree(res_attr); 1186 1187 return retval; 1188 } 1189 1190 /** 1191 * pci_create_resource_files - create resource files in sysfs for @dev 1192 * @pdev: dev in question 1193 * 1194 * Walk the resources in @pdev creating files for each resource available. 1195 */ 1196 static int pci_create_resource_files(struct pci_dev *pdev) 1197 { 1198 int i; 1199 int retval; 1200 1201 /* Expose the PCI resources from this device as files */ 1202 for (i = 0; i < PCI_ROM_RESOURCE; i++) { 1203 1204 /* skip empty resources */ 1205 if (!pci_resource_len(pdev, i)) 1206 continue; 1207 1208 retval = pci_create_attr(pdev, i, 0); 1209 /* for prefetchable resources, create a WC mappable file */ 1210 if (!retval && pdev->resource[i].flags & IORESOURCE_PREFETCH) 1211 retval = pci_create_attr(pdev, i, 1); 1212 1213 if (retval) { 1214 pci_remove_resource_files(pdev); 1215 return retval; 1216 } 1217 } 1218 return 0; 1219 } 1220 #else /* !HAVE_PCI_MMAP */ 1221 int __weak pci_create_resource_files(struct pci_dev *dev) { return 0; } 1222 void __weak pci_remove_resource_files(struct pci_dev *dev) { return; } 1223 #endif /* HAVE_PCI_MMAP */ 1224 1225 /** 1226 * pci_write_rom - used to enable access to the PCI ROM display 1227 * @filp: sysfs file 1228 * @kobj: kernel object handle 1229 * @bin_attr: struct bin_attribute for this file 1230 * @buf: user input 1231 * @off: file offset 1232 * @count: number of byte in input 1233 * 1234 * writing anything except 0 enables it 1235 */ 1236 static ssize_t pci_write_rom(struct file *filp, struct kobject *kobj, 1237 struct bin_attribute *bin_attr, char *buf, 1238 loff_t off, size_t count) 1239 { 1240 struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj)); 1241 1242 if ((off == 0) && (*buf == '0') && (count == 2)) 1243 pdev->rom_attr_enabled = 0; 1244 else 1245 pdev->rom_attr_enabled = 1; 1246 1247 return count; 1248 } 1249 1250 /** 1251 * pci_read_rom - read a PCI ROM 1252 * @filp: sysfs file 1253 * @kobj: kernel object handle 1254 * @bin_attr: struct bin_attribute for this file 1255 * @buf: where to put the data we read from the ROM 1256 * @off: file offset 1257 * @count: number of bytes to read 1258 * 1259 * Put @count bytes starting at @off into @buf from the ROM in the PCI 1260 * device corresponding to @kobj. 1261 */ 1262 static ssize_t pci_read_rom(struct file *filp, struct kobject *kobj, 1263 struct bin_attribute *bin_attr, char *buf, 1264 loff_t off, size_t count) 1265 { 1266 struct pci_dev *pdev = to_pci_dev(kobj_to_dev(kobj)); 1267 void __iomem *rom; 1268 size_t size; 1269 1270 if (!pdev->rom_attr_enabled) 1271 return -EINVAL; 1272 1273 rom = pci_map_rom(pdev, &size); /* size starts out as PCI window size */ 1274 if (!rom || !size) 1275 return -EIO; 1276 1277 if (off >= size) 1278 count = 0; 1279 else { 1280 if (off + count > size) 1281 count = size - off; 1282 1283 memcpy_fromio(buf, rom + off, count); 1284 } 1285 pci_unmap_rom(pdev, rom); 1286 1287 return count; 1288 } 1289 1290 static struct bin_attribute pci_config_attr = { 1291 .attr = { 1292 .name = "config", 1293 .mode = S_IRUGO | S_IWUSR, 1294 }, 1295 .size = PCI_CFG_SPACE_SIZE, 1296 .read = pci_read_config, 1297 .write = pci_write_config, 1298 }; 1299 1300 static struct bin_attribute pcie_config_attr = { 1301 .attr = { 1302 .name = "config", 1303 .mode = S_IRUGO | S_IWUSR, 1304 }, 1305 .size = PCI_CFG_SPACE_EXP_SIZE, 1306 .read = pci_read_config, 1307 .write = pci_write_config, 1308 }; 1309 1310 static ssize_t reset_store(struct device *dev, struct device_attribute *attr, 1311 const char *buf, size_t count) 1312 { 1313 struct pci_dev *pdev = to_pci_dev(dev); 1314 unsigned long val; 1315 ssize_t result = kstrtoul(buf, 0, &val); 1316 1317 if (result < 0) 1318 return result; 1319 1320 if (val != 1) 1321 return -EINVAL; 1322 1323 result = pci_reset_function(pdev); 1324 if (result < 0) 1325 return result; 1326 1327 return count; 1328 } 1329 1330 static struct device_attribute reset_attr = __ATTR(reset, 0200, NULL, reset_store); 1331 1332 static int pci_create_capabilities_sysfs(struct pci_dev *dev) 1333 { 1334 int retval; 1335 struct bin_attribute *attr; 1336 1337 /* If the device has VPD, try to expose it in sysfs. */ 1338 if (dev->vpd) { 1339 attr = kzalloc(sizeof(*attr), GFP_ATOMIC); 1340 if (!attr) 1341 return -ENOMEM; 1342 1343 sysfs_bin_attr_init(attr); 1344 attr->size = 0; 1345 attr->attr.name = "vpd"; 1346 attr->attr.mode = S_IRUSR | S_IWUSR; 1347 attr->read = read_vpd_attr; 1348 attr->write = write_vpd_attr; 1349 retval = sysfs_create_bin_file(&dev->dev.kobj, attr); 1350 if (retval) { 1351 kfree(attr); 1352 return retval; 1353 } 1354 dev->vpd->attr = attr; 1355 } 1356 1357 /* Active State Power Management */ 1358 pcie_aspm_create_sysfs_dev_files(dev); 1359 1360 if (!pci_probe_reset_function(dev)) { 1361 retval = device_create_file(&dev->dev, &reset_attr); 1362 if (retval) 1363 goto error; 1364 dev->reset_fn = 1; 1365 } 1366 return 0; 1367 1368 error: 1369 pcie_aspm_remove_sysfs_dev_files(dev); 1370 if (dev->vpd && dev->vpd->attr) { 1371 sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr); 1372 kfree(dev->vpd->attr); 1373 } 1374 1375 return retval; 1376 } 1377 1378 int __must_check pci_create_sysfs_dev_files(struct pci_dev *pdev) 1379 { 1380 int retval; 1381 int rom_size; 1382 struct bin_attribute *attr; 1383 1384 if (!sysfs_initialized) 1385 return -EACCES; 1386 1387 if (pdev->cfg_size > PCI_CFG_SPACE_SIZE) 1388 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr); 1389 else 1390 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr); 1391 if (retval) 1392 goto err; 1393 1394 retval = pci_create_resource_files(pdev); 1395 if (retval) 1396 goto err_config_file; 1397 1398 /* If the device has a ROM, try to expose it in sysfs. */ 1399 rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE); 1400 if (rom_size) { 1401 attr = kzalloc(sizeof(*attr), GFP_ATOMIC); 1402 if (!attr) { 1403 retval = -ENOMEM; 1404 goto err_resource_files; 1405 } 1406 sysfs_bin_attr_init(attr); 1407 attr->size = rom_size; 1408 attr->attr.name = "rom"; 1409 attr->attr.mode = S_IRUSR | S_IWUSR; 1410 attr->read = pci_read_rom; 1411 attr->write = pci_write_rom; 1412 retval = sysfs_create_bin_file(&pdev->dev.kobj, attr); 1413 if (retval) { 1414 kfree(attr); 1415 goto err_resource_files; 1416 } 1417 pdev->rom_attr = attr; 1418 } 1419 1420 /* add sysfs entries for various capabilities */ 1421 retval = pci_create_capabilities_sysfs(pdev); 1422 if (retval) 1423 goto err_rom_file; 1424 1425 pci_create_firmware_label_files(pdev); 1426 1427 return 0; 1428 1429 err_rom_file: 1430 if (pdev->rom_attr) { 1431 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr); 1432 kfree(pdev->rom_attr); 1433 pdev->rom_attr = NULL; 1434 } 1435 err_resource_files: 1436 pci_remove_resource_files(pdev); 1437 err_config_file: 1438 if (pdev->cfg_size > PCI_CFG_SPACE_SIZE) 1439 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr); 1440 else 1441 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr); 1442 err: 1443 return retval; 1444 } 1445 1446 static void pci_remove_capabilities_sysfs(struct pci_dev *dev) 1447 { 1448 if (dev->vpd && dev->vpd->attr) { 1449 sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr); 1450 kfree(dev->vpd->attr); 1451 } 1452 1453 pcie_aspm_remove_sysfs_dev_files(dev); 1454 if (dev->reset_fn) { 1455 device_remove_file(&dev->dev, &reset_attr); 1456 dev->reset_fn = 0; 1457 } 1458 } 1459 1460 /** 1461 * pci_remove_sysfs_dev_files - cleanup PCI specific sysfs files 1462 * @pdev: device whose entries we should free 1463 * 1464 * Cleanup when @pdev is removed from sysfs. 1465 */ 1466 void pci_remove_sysfs_dev_files(struct pci_dev *pdev) 1467 { 1468 if (!sysfs_initialized) 1469 return; 1470 1471 pci_remove_capabilities_sysfs(pdev); 1472 1473 if (pdev->cfg_size > PCI_CFG_SPACE_SIZE) 1474 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr); 1475 else 1476 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr); 1477 1478 pci_remove_resource_files(pdev); 1479 1480 if (pdev->rom_attr) { 1481 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr); 1482 kfree(pdev->rom_attr); 1483 pdev->rom_attr = NULL; 1484 } 1485 1486 pci_remove_firmware_label_files(pdev); 1487 } 1488 1489 static int __init pci_sysfs_init(void) 1490 { 1491 struct pci_dev *pdev = NULL; 1492 int retval; 1493 1494 sysfs_initialized = 1; 1495 for_each_pci_dev(pdev) { 1496 retval = pci_create_sysfs_dev_files(pdev); 1497 if (retval) { 1498 pci_dev_put(pdev); 1499 return retval; 1500 } 1501 } 1502 1503 return 0; 1504 } 1505 late_initcall(pci_sysfs_init); 1506 1507 static struct attribute *pci_dev_dev_attrs[] = { 1508 &vga_attr.attr, 1509 NULL, 1510 }; 1511 1512 static umode_t pci_dev_attrs_are_visible(struct kobject *kobj, 1513 struct attribute *a, int n) 1514 { 1515 struct device *dev = kobj_to_dev(kobj); 1516 struct pci_dev *pdev = to_pci_dev(dev); 1517 1518 if (a == &vga_attr.attr) 1519 if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA) 1520 return 0; 1521 1522 return a->mode; 1523 } 1524 1525 static struct attribute *pci_dev_hp_attrs[] = { 1526 &dev_remove_attr.attr, 1527 &dev_rescan_attr.attr, 1528 NULL, 1529 }; 1530 1531 static umode_t pci_dev_hp_attrs_are_visible(struct kobject *kobj, 1532 struct attribute *a, int n) 1533 { 1534 struct device *dev = kobj_to_dev(kobj); 1535 struct pci_dev *pdev = to_pci_dev(dev); 1536 1537 if (pdev->is_virtfn) 1538 return 0; 1539 1540 return a->mode; 1541 } 1542 1543 static struct attribute_group pci_dev_hp_attr_group = { 1544 .attrs = pci_dev_hp_attrs, 1545 .is_visible = pci_dev_hp_attrs_are_visible, 1546 }; 1547 1548 #ifdef CONFIG_PCI_IOV 1549 static struct attribute *sriov_dev_attrs[] = { 1550 &sriov_totalvfs_attr.attr, 1551 &sriov_numvfs_attr.attr, 1552 NULL, 1553 }; 1554 1555 static umode_t sriov_attrs_are_visible(struct kobject *kobj, 1556 struct attribute *a, int n) 1557 { 1558 struct device *dev = kobj_to_dev(kobj); 1559 1560 if (!dev_is_pf(dev)) 1561 return 0; 1562 1563 return a->mode; 1564 } 1565 1566 static struct attribute_group sriov_dev_attr_group = { 1567 .attrs = sriov_dev_attrs, 1568 .is_visible = sriov_attrs_are_visible, 1569 }; 1570 #endif /* CONFIG_PCI_IOV */ 1571 1572 static struct attribute_group pci_dev_attr_group = { 1573 .attrs = pci_dev_dev_attrs, 1574 .is_visible = pci_dev_attrs_are_visible, 1575 }; 1576 1577 static const struct attribute_group *pci_dev_attr_groups[] = { 1578 &pci_dev_attr_group, 1579 &pci_dev_hp_attr_group, 1580 #ifdef CONFIG_PCI_IOV 1581 &sriov_dev_attr_group, 1582 #endif 1583 NULL, 1584 }; 1585 1586 struct device_type pci_dev_type = { 1587 .groups = pci_dev_attr_groups, 1588 }; 1589