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 "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 46 pci_config_attr(vendor, "0x%04x\n"); 47 pci_config_attr(device, "0x%04x\n"); 48 pci_config_attr(subsystem_vendor, "0x%04x\n"); 49 pci_config_attr(subsystem_device, "0x%04x\n"); 50 pci_config_attr(class, "0x%06x\n"); 51 pci_config_attr(irq, "%u\n"); 52 53 static ssize_t broken_parity_status_show(struct device *dev, 54 struct device_attribute *attr, 55 char *buf) 56 { 57 struct pci_dev *pdev = to_pci_dev(dev); 58 return sprintf (buf, "%u\n", pdev->broken_parity_status); 59 } 60 61 static ssize_t broken_parity_status_store(struct device *dev, 62 struct device_attribute *attr, 63 const char *buf, size_t count) 64 { 65 struct pci_dev *pdev = to_pci_dev(dev); 66 unsigned long val; 67 68 if (strict_strtoul(buf, 0, &val) < 0) 69 return -EINVAL; 70 71 pdev->broken_parity_status = !!val; 72 73 return count; 74 } 75 76 static ssize_t local_cpus_show(struct device *dev, 77 struct device_attribute *attr, char *buf) 78 { 79 const struct cpumask *mask; 80 int len; 81 82 #ifdef CONFIG_NUMA 83 mask = (dev_to_node(dev) == -1) ? cpu_online_mask : 84 cpumask_of_node(dev_to_node(dev)); 85 #else 86 mask = cpumask_of_pcibus(to_pci_dev(dev)->bus); 87 #endif 88 len = cpumask_scnprintf(buf, PAGE_SIZE-2, mask); 89 buf[len++] = '\n'; 90 buf[len] = '\0'; 91 return len; 92 } 93 94 95 static ssize_t local_cpulist_show(struct device *dev, 96 struct device_attribute *attr, char *buf) 97 { 98 const struct cpumask *mask; 99 int len; 100 101 #ifdef CONFIG_NUMA 102 mask = (dev_to_node(dev) == -1) ? cpu_online_mask : 103 cpumask_of_node(dev_to_node(dev)); 104 #else 105 mask = cpumask_of_pcibus(to_pci_dev(dev)->bus); 106 #endif 107 len = cpulist_scnprintf(buf, PAGE_SIZE-2, mask); 108 buf[len++] = '\n'; 109 buf[len] = '\0'; 110 return len; 111 } 112 113 /* 114 * PCI Bus Class Devices 115 */ 116 static ssize_t pci_bus_show_cpuaffinity(struct device *dev, 117 int type, 118 struct device_attribute *attr, 119 char *buf) 120 { 121 int ret; 122 const struct cpumask *cpumask; 123 124 cpumask = cpumask_of_pcibus(to_pci_bus(dev)); 125 ret = type ? 126 cpulist_scnprintf(buf, PAGE_SIZE-2, cpumask) : 127 cpumask_scnprintf(buf, PAGE_SIZE-2, cpumask); 128 buf[ret++] = '\n'; 129 buf[ret] = '\0'; 130 return ret; 131 } 132 133 static inline ssize_t pci_bus_show_cpumaskaffinity(struct device *dev, 134 struct device_attribute *attr, 135 char *buf) 136 { 137 return pci_bus_show_cpuaffinity(dev, 0, attr, buf); 138 } 139 140 static inline ssize_t pci_bus_show_cpulistaffinity(struct device *dev, 141 struct device_attribute *attr, 142 char *buf) 143 { 144 return pci_bus_show_cpuaffinity(dev, 1, attr, buf); 145 } 146 147 /* show resources */ 148 static ssize_t 149 resource_show(struct device * dev, struct device_attribute *attr, char * buf) 150 { 151 struct pci_dev * pci_dev = to_pci_dev(dev); 152 char * str = buf; 153 int i; 154 int max; 155 resource_size_t start, end; 156 157 if (pci_dev->subordinate) 158 max = DEVICE_COUNT_RESOURCE; 159 else 160 max = PCI_BRIDGE_RESOURCES; 161 162 for (i = 0; i < max; i++) { 163 struct resource *res = &pci_dev->resource[i]; 164 pci_resource_to_user(pci_dev, i, res, &start, &end); 165 str += sprintf(str,"0x%016llx 0x%016llx 0x%016llx\n", 166 (unsigned long long)start, 167 (unsigned long long)end, 168 (unsigned long long)res->flags); 169 } 170 return (str - buf); 171 } 172 173 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) 174 { 175 struct pci_dev *pci_dev = to_pci_dev(dev); 176 177 return sprintf(buf, "pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x\n", 178 pci_dev->vendor, pci_dev->device, 179 pci_dev->subsystem_vendor, pci_dev->subsystem_device, 180 (u8)(pci_dev->class >> 16), (u8)(pci_dev->class >> 8), 181 (u8)(pci_dev->class)); 182 } 183 184 static ssize_t is_enabled_store(struct device *dev, 185 struct device_attribute *attr, const char *buf, 186 size_t count) 187 { 188 struct pci_dev *pdev = to_pci_dev(dev); 189 unsigned long val; 190 ssize_t result = strict_strtoul(buf, 0, &val); 191 192 if (result < 0) 193 return result; 194 195 /* this can crash the machine when done on the "wrong" device */ 196 if (!capable(CAP_SYS_ADMIN)) 197 return -EPERM; 198 199 if (!val) { 200 if (pci_is_enabled(pdev)) 201 pci_disable_device(pdev); 202 else 203 result = -EIO; 204 } else 205 result = pci_enable_device(pdev); 206 207 return result < 0 ? result : count; 208 } 209 210 static ssize_t is_enabled_show(struct device *dev, 211 struct device_attribute *attr, char *buf) 212 { 213 struct pci_dev *pdev; 214 215 pdev = to_pci_dev (dev); 216 return sprintf (buf, "%u\n", atomic_read(&pdev->enable_cnt)); 217 } 218 219 #ifdef CONFIG_NUMA 220 static ssize_t 221 numa_node_show(struct device *dev, struct device_attribute *attr, char *buf) 222 { 223 return sprintf (buf, "%d\n", dev->numa_node); 224 } 225 #endif 226 227 static ssize_t 228 dma_mask_bits_show(struct device *dev, struct device_attribute *attr, char *buf) 229 { 230 struct pci_dev *pdev = to_pci_dev(dev); 231 232 return sprintf (buf, "%d\n", fls64(pdev->dma_mask)); 233 } 234 235 static ssize_t 236 consistent_dma_mask_bits_show(struct device *dev, struct device_attribute *attr, 237 char *buf) 238 { 239 return sprintf (buf, "%d\n", fls64(dev->coherent_dma_mask)); 240 } 241 242 static ssize_t 243 msi_bus_show(struct device *dev, struct device_attribute *attr, char *buf) 244 { 245 struct pci_dev *pdev = to_pci_dev(dev); 246 247 if (!pdev->subordinate) 248 return 0; 249 250 return sprintf (buf, "%u\n", 251 !(pdev->subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI)); 252 } 253 254 static ssize_t 255 msi_bus_store(struct device *dev, struct device_attribute *attr, 256 const char *buf, size_t count) 257 { 258 struct pci_dev *pdev = to_pci_dev(dev); 259 unsigned long val; 260 261 if (strict_strtoul(buf, 0, &val) < 0) 262 return -EINVAL; 263 264 /* bad things may happen if the no_msi flag is changed 265 * while some drivers are loaded */ 266 if (!capable(CAP_SYS_ADMIN)) 267 return -EPERM; 268 269 /* Maybe pci devices without subordinate busses shouldn't even have this 270 * attribute in the first place? */ 271 if (!pdev->subordinate) 272 return count; 273 274 /* Is the flag going to change, or keep the value it already had? */ 275 if (!(pdev->subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI) ^ 276 !!val) { 277 pdev->subordinate->bus_flags ^= PCI_BUS_FLAGS_NO_MSI; 278 279 dev_warn(&pdev->dev, "forced subordinate bus to%s support MSI," 280 " bad things could happen\n", val ? "" : " not"); 281 } 282 283 return count; 284 } 285 286 #ifdef CONFIG_HOTPLUG 287 static DEFINE_MUTEX(pci_remove_rescan_mutex); 288 static ssize_t bus_rescan_store(struct bus_type *bus, const char *buf, 289 size_t count) 290 { 291 unsigned long val; 292 struct pci_bus *b = NULL; 293 294 if (strict_strtoul(buf, 0, &val) < 0) 295 return -EINVAL; 296 297 if (val) { 298 mutex_lock(&pci_remove_rescan_mutex); 299 while ((b = pci_find_next_bus(b)) != NULL) 300 pci_rescan_bus(b); 301 mutex_unlock(&pci_remove_rescan_mutex); 302 } 303 return count; 304 } 305 306 struct bus_attribute pci_bus_attrs[] = { 307 __ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, bus_rescan_store), 308 __ATTR_NULL 309 }; 310 311 static ssize_t 312 dev_rescan_store(struct device *dev, struct device_attribute *attr, 313 const char *buf, size_t count) 314 { 315 unsigned long val; 316 struct pci_dev *pdev = to_pci_dev(dev); 317 318 if (strict_strtoul(buf, 0, &val) < 0) 319 return -EINVAL; 320 321 if (val) { 322 mutex_lock(&pci_remove_rescan_mutex); 323 pci_rescan_bus(pdev->bus); 324 mutex_unlock(&pci_remove_rescan_mutex); 325 } 326 return count; 327 } 328 329 static void remove_callback(struct device *dev) 330 { 331 struct pci_dev *pdev = to_pci_dev(dev); 332 333 mutex_lock(&pci_remove_rescan_mutex); 334 pci_stop_and_remove_bus_device(pdev); 335 mutex_unlock(&pci_remove_rescan_mutex); 336 } 337 338 static ssize_t 339 remove_store(struct device *dev, struct device_attribute *dummy, 340 const char *buf, size_t count) 341 { 342 int ret = 0; 343 unsigned long val; 344 345 if (strict_strtoul(buf, 0, &val) < 0) 346 return -EINVAL; 347 348 /* An attribute cannot be unregistered by one of its own methods, 349 * so we have to use this roundabout approach. 350 */ 351 if (val) 352 ret = device_schedule_callback(dev, remove_callback); 353 if (ret) 354 count = ret; 355 return count; 356 } 357 358 static ssize_t 359 dev_bus_rescan_store(struct device *dev, struct device_attribute *attr, 360 const char *buf, size_t count) 361 { 362 unsigned long val; 363 struct pci_bus *bus = to_pci_bus(dev); 364 365 if (strict_strtoul(buf, 0, &val) < 0) 366 return -EINVAL; 367 368 if (val) { 369 mutex_lock(&pci_remove_rescan_mutex); 370 if (!pci_is_root_bus(bus) && list_empty(&bus->devices)) 371 pci_rescan_bus_bridge_resize(bus->self); 372 else 373 pci_rescan_bus(bus); 374 mutex_unlock(&pci_remove_rescan_mutex); 375 } 376 return count; 377 } 378 379 #endif 380 381 struct device_attribute pci_dev_attrs[] = { 382 __ATTR_RO(resource), 383 __ATTR_RO(vendor), 384 __ATTR_RO(device), 385 __ATTR_RO(subsystem_vendor), 386 __ATTR_RO(subsystem_device), 387 __ATTR_RO(class), 388 __ATTR_RO(irq), 389 __ATTR_RO(local_cpus), 390 __ATTR_RO(local_cpulist), 391 __ATTR_RO(modalias), 392 #ifdef CONFIG_NUMA 393 __ATTR_RO(numa_node), 394 #endif 395 __ATTR_RO(dma_mask_bits), 396 __ATTR_RO(consistent_dma_mask_bits), 397 __ATTR(enable, 0600, is_enabled_show, is_enabled_store), 398 __ATTR(broken_parity_status,(S_IRUGO|S_IWUSR), 399 broken_parity_status_show,broken_parity_status_store), 400 __ATTR(msi_bus, 0644, msi_bus_show, msi_bus_store), 401 #ifdef CONFIG_HOTPLUG 402 __ATTR(remove, (S_IWUSR|S_IWGRP), NULL, remove_store), 403 __ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, dev_rescan_store), 404 #endif 405 __ATTR_NULL, 406 }; 407 408 struct device_attribute pcibus_dev_attrs[] = { 409 #ifdef CONFIG_HOTPLUG 410 __ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, dev_bus_rescan_store), 411 #endif 412 __ATTR(cpuaffinity, S_IRUGO, pci_bus_show_cpumaskaffinity, NULL), 413 __ATTR(cpulistaffinity, S_IRUGO, pci_bus_show_cpulistaffinity, NULL), 414 __ATTR_NULL, 415 }; 416 417 static ssize_t 418 boot_vga_show(struct device *dev, struct device_attribute *attr, char *buf) 419 { 420 struct pci_dev *pdev = to_pci_dev(dev); 421 struct pci_dev *vga_dev = vga_default_device(); 422 423 if (vga_dev) 424 return sprintf(buf, "%u\n", (pdev == vga_dev)); 425 426 return sprintf(buf, "%u\n", 427 !!(pdev->resource[PCI_ROM_RESOURCE].flags & 428 IORESOURCE_ROM_SHADOW)); 429 } 430 struct device_attribute vga_attr = __ATTR_RO(boot_vga); 431 432 static ssize_t 433 pci_read_config(struct file *filp, struct kobject *kobj, 434 struct bin_attribute *bin_attr, 435 char *buf, loff_t off, size_t count) 436 { 437 struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj)); 438 unsigned int size = 64; 439 loff_t init_off = off; 440 u8 *data = (u8*) buf; 441 442 /* Several chips lock up trying to read undefined config space */ 443 if (security_capable(filp->f_cred, &init_user_ns, CAP_SYS_ADMIN) == 0) { 444 size = dev->cfg_size; 445 } else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) { 446 size = 128; 447 } 448 449 if (off > size) 450 return 0; 451 if (off + count > size) { 452 size -= off; 453 count = size; 454 } else { 455 size = count; 456 } 457 458 if ((off & 1) && size) { 459 u8 val; 460 pci_user_read_config_byte(dev, off, &val); 461 data[off - init_off] = val; 462 off++; 463 size--; 464 } 465 466 if ((off & 3) && size > 2) { 467 u16 val; 468 pci_user_read_config_word(dev, off, &val); 469 data[off - init_off] = val & 0xff; 470 data[off - init_off + 1] = (val >> 8) & 0xff; 471 off += 2; 472 size -= 2; 473 } 474 475 while (size > 3) { 476 u32 val; 477 pci_user_read_config_dword(dev, off, &val); 478 data[off - init_off] = val & 0xff; 479 data[off - init_off + 1] = (val >> 8) & 0xff; 480 data[off - init_off + 2] = (val >> 16) & 0xff; 481 data[off - init_off + 3] = (val >> 24) & 0xff; 482 off += 4; 483 size -= 4; 484 } 485 486 if (size >= 2) { 487 u16 val; 488 pci_user_read_config_word(dev, off, &val); 489 data[off - init_off] = val & 0xff; 490 data[off - init_off + 1] = (val >> 8) & 0xff; 491 off += 2; 492 size -= 2; 493 } 494 495 if (size > 0) { 496 u8 val; 497 pci_user_read_config_byte(dev, off, &val); 498 data[off - init_off] = val; 499 off++; 500 --size; 501 } 502 503 return count; 504 } 505 506 static ssize_t 507 pci_write_config(struct file* filp, struct kobject *kobj, 508 struct bin_attribute *bin_attr, 509 char *buf, loff_t off, size_t count) 510 { 511 struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj)); 512 unsigned int size = count; 513 loff_t init_off = off; 514 u8 *data = (u8*) buf; 515 516 if (off > dev->cfg_size) 517 return 0; 518 if (off + count > dev->cfg_size) { 519 size = dev->cfg_size - off; 520 count = size; 521 } 522 523 if ((off & 1) && size) { 524 pci_user_write_config_byte(dev, off, data[off - init_off]); 525 off++; 526 size--; 527 } 528 529 if ((off & 3) && size > 2) { 530 u16 val = data[off - init_off]; 531 val |= (u16) data[off - init_off + 1] << 8; 532 pci_user_write_config_word(dev, off, val); 533 off += 2; 534 size -= 2; 535 } 536 537 while (size > 3) { 538 u32 val = data[off - init_off]; 539 val |= (u32) data[off - init_off + 1] << 8; 540 val |= (u32) data[off - init_off + 2] << 16; 541 val |= (u32) data[off - init_off + 3] << 24; 542 pci_user_write_config_dword(dev, off, val); 543 off += 4; 544 size -= 4; 545 } 546 547 if (size >= 2) { 548 u16 val = data[off - init_off]; 549 val |= (u16) data[off - init_off + 1] << 8; 550 pci_user_write_config_word(dev, off, val); 551 off += 2; 552 size -= 2; 553 } 554 555 if (size) { 556 pci_user_write_config_byte(dev, off, data[off - init_off]); 557 off++; 558 --size; 559 } 560 561 return count; 562 } 563 564 static ssize_t 565 read_vpd_attr(struct file *filp, struct kobject *kobj, 566 struct bin_attribute *bin_attr, 567 char *buf, loff_t off, size_t count) 568 { 569 struct pci_dev *dev = 570 to_pci_dev(container_of(kobj, struct device, kobj)); 571 572 if (off > bin_attr->size) 573 count = 0; 574 else if (count > bin_attr->size - off) 575 count = bin_attr->size - off; 576 577 return pci_read_vpd(dev, off, count, buf); 578 } 579 580 static ssize_t 581 write_vpd_attr(struct file *filp, struct kobject *kobj, 582 struct bin_attribute *bin_attr, 583 char *buf, loff_t off, size_t count) 584 { 585 struct pci_dev *dev = 586 to_pci_dev(container_of(kobj, struct device, kobj)); 587 588 if (off > bin_attr->size) 589 count = 0; 590 else if (count > bin_attr->size - off) 591 count = bin_attr->size - off; 592 593 return pci_write_vpd(dev, off, count, buf); 594 } 595 596 #ifdef HAVE_PCI_LEGACY 597 /** 598 * pci_read_legacy_io - read byte(s) from legacy I/O port space 599 * @filp: open sysfs file 600 * @kobj: kobject corresponding to file to read from 601 * @bin_attr: struct bin_attribute for this file 602 * @buf: buffer to store results 603 * @off: offset into legacy I/O port space 604 * @count: number of bytes to read 605 * 606 * Reads 1, 2, or 4 bytes from legacy I/O port space using an arch specific 607 * callback routine (pci_legacy_read). 608 */ 609 static ssize_t 610 pci_read_legacy_io(struct file *filp, struct kobject *kobj, 611 struct bin_attribute *bin_attr, 612 char *buf, loff_t off, size_t count) 613 { 614 struct pci_bus *bus = to_pci_bus(container_of(kobj, 615 struct device, 616 kobj)); 617 618 /* Only support 1, 2 or 4 byte accesses */ 619 if (count != 1 && count != 2 && count != 4) 620 return -EINVAL; 621 622 return pci_legacy_read(bus, off, (u32 *)buf, count); 623 } 624 625 /** 626 * pci_write_legacy_io - write byte(s) to legacy I/O port space 627 * @filp: open sysfs file 628 * @kobj: kobject corresponding to file to read from 629 * @bin_attr: struct bin_attribute for this file 630 * @buf: buffer containing value to be written 631 * @off: offset into legacy I/O port space 632 * @count: number of bytes to write 633 * 634 * Writes 1, 2, or 4 bytes from legacy I/O port space using an arch specific 635 * callback routine (pci_legacy_write). 636 */ 637 static ssize_t 638 pci_write_legacy_io(struct file *filp, struct kobject *kobj, 639 struct bin_attribute *bin_attr, 640 char *buf, loff_t off, size_t count) 641 { 642 struct pci_bus *bus = to_pci_bus(container_of(kobj, 643 struct device, 644 kobj)); 645 /* Only support 1, 2 or 4 byte accesses */ 646 if (count != 1 && count != 2 && count != 4) 647 return -EINVAL; 648 649 return pci_legacy_write(bus, off, *(u32 *)buf, count); 650 } 651 652 /** 653 * pci_mmap_legacy_mem - map legacy PCI memory into user memory space 654 * @filp: open sysfs file 655 * @kobj: kobject corresponding to device to be mapped 656 * @attr: struct bin_attribute for this file 657 * @vma: struct vm_area_struct passed to mmap 658 * 659 * Uses an arch specific callback, pci_mmap_legacy_mem_page_range, to mmap 660 * legacy memory space (first meg of bus space) into application virtual 661 * memory space. 662 */ 663 static int 664 pci_mmap_legacy_mem(struct file *filp, struct kobject *kobj, 665 struct bin_attribute *attr, 666 struct vm_area_struct *vma) 667 { 668 struct pci_bus *bus = to_pci_bus(container_of(kobj, 669 struct device, 670 kobj)); 671 672 return pci_mmap_legacy_page_range(bus, vma, pci_mmap_mem); 673 } 674 675 /** 676 * pci_mmap_legacy_io - map legacy PCI IO into user memory space 677 * @filp: open sysfs file 678 * @kobj: kobject corresponding to device to be mapped 679 * @attr: struct bin_attribute for this file 680 * @vma: struct vm_area_struct passed to mmap 681 * 682 * Uses an arch specific callback, pci_mmap_legacy_io_page_range, to mmap 683 * legacy IO space (first meg of bus space) into application virtual 684 * memory space. Returns -ENOSYS if the operation isn't supported 685 */ 686 static int 687 pci_mmap_legacy_io(struct file *filp, struct kobject *kobj, 688 struct bin_attribute *attr, 689 struct vm_area_struct *vma) 690 { 691 struct pci_bus *bus = to_pci_bus(container_of(kobj, 692 struct device, 693 kobj)); 694 695 return pci_mmap_legacy_page_range(bus, vma, pci_mmap_io); 696 } 697 698 /** 699 * pci_adjust_legacy_attr - adjustment of legacy file attributes 700 * @b: bus to create files under 701 * @mmap_type: I/O port or memory 702 * 703 * Stub implementation. Can be overridden by arch if necessary. 704 */ 705 void __weak 706 pci_adjust_legacy_attr(struct pci_bus *b, enum pci_mmap_state mmap_type) 707 { 708 return; 709 } 710 711 /** 712 * pci_create_legacy_files - create legacy I/O port and memory files 713 * @b: bus to create files under 714 * 715 * Some platforms allow access to legacy I/O port and ISA memory space on 716 * a per-bus basis. This routine creates the files and ties them into 717 * their associated read, write and mmap files from pci-sysfs.c 718 * 719 * On error unwind, but don't propagate the error to the caller 720 * as it is ok to set up the PCI bus without these files. 721 */ 722 void pci_create_legacy_files(struct pci_bus *b) 723 { 724 int error; 725 726 b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2, 727 GFP_ATOMIC); 728 if (!b->legacy_io) 729 goto kzalloc_err; 730 731 sysfs_bin_attr_init(b->legacy_io); 732 b->legacy_io->attr.name = "legacy_io"; 733 b->legacy_io->size = 0xffff; 734 b->legacy_io->attr.mode = S_IRUSR | S_IWUSR; 735 b->legacy_io->read = pci_read_legacy_io; 736 b->legacy_io->write = pci_write_legacy_io; 737 b->legacy_io->mmap = pci_mmap_legacy_io; 738 pci_adjust_legacy_attr(b, pci_mmap_io); 739 error = device_create_bin_file(&b->dev, b->legacy_io); 740 if (error) 741 goto legacy_io_err; 742 743 /* Allocated above after the legacy_io struct */ 744 b->legacy_mem = b->legacy_io + 1; 745 sysfs_bin_attr_init(b->legacy_mem); 746 b->legacy_mem->attr.name = "legacy_mem"; 747 b->legacy_mem->size = 1024*1024; 748 b->legacy_mem->attr.mode = S_IRUSR | S_IWUSR; 749 b->legacy_mem->mmap = pci_mmap_legacy_mem; 750 pci_adjust_legacy_attr(b, pci_mmap_mem); 751 error = device_create_bin_file(&b->dev, b->legacy_mem); 752 if (error) 753 goto legacy_mem_err; 754 755 return; 756 757 legacy_mem_err: 758 device_remove_bin_file(&b->dev, b->legacy_io); 759 legacy_io_err: 760 kfree(b->legacy_io); 761 b->legacy_io = NULL; 762 kzalloc_err: 763 printk(KERN_WARNING "pci: warning: could not create legacy I/O port " 764 "and ISA memory resources to sysfs\n"); 765 return; 766 } 767 768 void pci_remove_legacy_files(struct pci_bus *b) 769 { 770 if (b->legacy_io) { 771 device_remove_bin_file(&b->dev, b->legacy_io); 772 device_remove_bin_file(&b->dev, b->legacy_mem); 773 kfree(b->legacy_io); /* both are allocated here */ 774 } 775 } 776 #endif /* HAVE_PCI_LEGACY */ 777 778 #ifdef HAVE_PCI_MMAP 779 780 int pci_mmap_fits(struct pci_dev *pdev, int resno, struct vm_area_struct *vma, 781 enum pci_mmap_api mmap_api) 782 { 783 unsigned long nr, start, size, pci_start; 784 785 if (pci_resource_len(pdev, resno) == 0) 786 return 0; 787 nr = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT; 788 start = vma->vm_pgoff; 789 size = ((pci_resource_len(pdev, resno) - 1) >> PAGE_SHIFT) + 1; 790 pci_start = (mmap_api == PCI_MMAP_PROCFS) ? 791 pci_resource_start(pdev, resno) >> PAGE_SHIFT : 0; 792 if (start >= pci_start && start < pci_start + size && 793 start + nr <= pci_start + size) 794 return 1; 795 return 0; 796 } 797 798 /** 799 * pci_mmap_resource - map a PCI resource into user memory space 800 * @kobj: kobject for mapping 801 * @attr: struct bin_attribute for the file being mapped 802 * @vma: struct vm_area_struct passed into the mmap 803 * @write_combine: 1 for write_combine mapping 804 * 805 * Use the regular PCI mapping routines to map a PCI resource into userspace. 806 */ 807 static int 808 pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr, 809 struct vm_area_struct *vma, int write_combine) 810 { 811 struct pci_dev *pdev = to_pci_dev(container_of(kobj, 812 struct device, kobj)); 813 struct resource *res = attr->private; 814 enum pci_mmap_state mmap_type; 815 resource_size_t start, end; 816 int i; 817 818 for (i = 0; i < PCI_ROM_RESOURCE; i++) 819 if (res == &pdev->resource[i]) 820 break; 821 if (i >= PCI_ROM_RESOURCE) 822 return -ENODEV; 823 824 if (!pci_mmap_fits(pdev, i, vma, PCI_MMAP_SYSFS)) { 825 WARN(1, "process \"%s\" tried to map 0x%08lx bytes " 826 "at page 0x%08lx on %s BAR %d (start 0x%16Lx, size 0x%16Lx)\n", 827 current->comm, vma->vm_end-vma->vm_start, vma->vm_pgoff, 828 pci_name(pdev), i, 829 (u64)pci_resource_start(pdev, i), 830 (u64)pci_resource_len(pdev, i)); 831 return -EINVAL; 832 } 833 834 /* pci_mmap_page_range() expects the same kind of entry as coming 835 * from /proc/bus/pci/ which is a "user visible" value. If this is 836 * different from the resource itself, arch will do necessary fixup. 837 */ 838 pci_resource_to_user(pdev, i, res, &start, &end); 839 vma->vm_pgoff += start >> PAGE_SHIFT; 840 mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io; 841 842 if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(start)) 843 return -EINVAL; 844 845 return pci_mmap_page_range(pdev, vma, mmap_type, write_combine); 846 } 847 848 static int 849 pci_mmap_resource_uc(struct file *filp, struct kobject *kobj, 850 struct bin_attribute *attr, 851 struct vm_area_struct *vma) 852 { 853 return pci_mmap_resource(kobj, attr, vma, 0); 854 } 855 856 static int 857 pci_mmap_resource_wc(struct file *filp, struct kobject *kobj, 858 struct bin_attribute *attr, 859 struct vm_area_struct *vma) 860 { 861 return pci_mmap_resource(kobj, attr, vma, 1); 862 } 863 864 static ssize_t 865 pci_resource_io(struct file *filp, struct kobject *kobj, 866 struct bin_attribute *attr, char *buf, 867 loff_t off, size_t count, bool write) 868 { 869 struct pci_dev *pdev = to_pci_dev(container_of(kobj, 870 struct device, kobj)); 871 struct resource *res = attr->private; 872 unsigned long port = off; 873 int i; 874 875 for (i = 0; i < PCI_ROM_RESOURCE; i++) 876 if (res == &pdev->resource[i]) 877 break; 878 if (i >= PCI_ROM_RESOURCE) 879 return -ENODEV; 880 881 port += pci_resource_start(pdev, i); 882 883 if (port > pci_resource_end(pdev, i)) 884 return 0; 885 886 if (port + count - 1 > pci_resource_end(pdev, i)) 887 return -EINVAL; 888 889 switch (count) { 890 case 1: 891 if (write) 892 outb(*(u8 *)buf, port); 893 else 894 *(u8 *)buf = inb(port); 895 return 1; 896 case 2: 897 if (write) 898 outw(*(u16 *)buf, port); 899 else 900 *(u16 *)buf = inw(port); 901 return 2; 902 case 4: 903 if (write) 904 outl(*(u32 *)buf, port); 905 else 906 *(u32 *)buf = inl(port); 907 return 4; 908 } 909 return -EINVAL; 910 } 911 912 static ssize_t 913 pci_read_resource_io(struct file *filp, struct kobject *kobj, 914 struct bin_attribute *attr, char *buf, 915 loff_t off, size_t count) 916 { 917 return pci_resource_io(filp, kobj, attr, buf, off, count, false); 918 } 919 920 static ssize_t 921 pci_write_resource_io(struct file *filp, struct kobject *kobj, 922 struct bin_attribute *attr, char *buf, 923 loff_t off, size_t count) 924 { 925 return pci_resource_io(filp, kobj, attr, buf, off, count, true); 926 } 927 928 /** 929 * pci_remove_resource_files - cleanup resource files 930 * @pdev: dev to cleanup 931 * 932 * If we created resource files for @pdev, remove them from sysfs and 933 * free their resources. 934 */ 935 static void 936 pci_remove_resource_files(struct pci_dev *pdev) 937 { 938 int i; 939 940 for (i = 0; i < PCI_ROM_RESOURCE; i++) { 941 struct bin_attribute *res_attr; 942 943 res_attr = pdev->res_attr[i]; 944 if (res_attr) { 945 sysfs_remove_bin_file(&pdev->dev.kobj, res_attr); 946 kfree(res_attr); 947 } 948 949 res_attr = pdev->res_attr_wc[i]; 950 if (res_attr) { 951 sysfs_remove_bin_file(&pdev->dev.kobj, res_attr); 952 kfree(res_attr); 953 } 954 } 955 } 956 957 static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine) 958 { 959 /* allocate attribute structure, piggyback attribute name */ 960 int name_len = write_combine ? 13 : 10; 961 struct bin_attribute *res_attr; 962 int retval; 963 964 res_attr = kzalloc(sizeof(*res_attr) + name_len, GFP_ATOMIC); 965 if (res_attr) { 966 char *res_attr_name = (char *)(res_attr + 1); 967 968 sysfs_bin_attr_init(res_attr); 969 if (write_combine) { 970 pdev->res_attr_wc[num] = res_attr; 971 sprintf(res_attr_name, "resource%d_wc", num); 972 res_attr->mmap = pci_mmap_resource_wc; 973 } else { 974 pdev->res_attr[num] = res_attr; 975 sprintf(res_attr_name, "resource%d", num); 976 res_attr->mmap = pci_mmap_resource_uc; 977 } 978 if (pci_resource_flags(pdev, num) & IORESOURCE_IO) { 979 res_attr->read = pci_read_resource_io; 980 res_attr->write = pci_write_resource_io; 981 } 982 res_attr->attr.name = res_attr_name; 983 res_attr->attr.mode = S_IRUSR | S_IWUSR; 984 res_attr->size = pci_resource_len(pdev, num); 985 res_attr->private = &pdev->resource[num]; 986 retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr); 987 } else 988 retval = -ENOMEM; 989 990 return retval; 991 } 992 993 /** 994 * pci_create_resource_files - create resource files in sysfs for @dev 995 * @pdev: dev in question 996 * 997 * Walk the resources in @pdev creating files for each resource available. 998 */ 999 static int pci_create_resource_files(struct pci_dev *pdev) 1000 { 1001 int i; 1002 int retval; 1003 1004 /* Expose the PCI resources from this device as files */ 1005 for (i = 0; i < PCI_ROM_RESOURCE; i++) { 1006 1007 /* skip empty resources */ 1008 if (!pci_resource_len(pdev, i)) 1009 continue; 1010 1011 retval = pci_create_attr(pdev, i, 0); 1012 /* for prefetchable resources, create a WC mappable file */ 1013 if (!retval && pdev->resource[i].flags & IORESOURCE_PREFETCH) 1014 retval = pci_create_attr(pdev, i, 1); 1015 1016 if (retval) { 1017 pci_remove_resource_files(pdev); 1018 return retval; 1019 } 1020 } 1021 return 0; 1022 } 1023 #else /* !HAVE_PCI_MMAP */ 1024 int __weak pci_create_resource_files(struct pci_dev *dev) { return 0; } 1025 void __weak pci_remove_resource_files(struct pci_dev *dev) { return; } 1026 #endif /* HAVE_PCI_MMAP */ 1027 1028 /** 1029 * pci_write_rom - used to enable access to the PCI ROM display 1030 * @filp: sysfs file 1031 * @kobj: kernel object handle 1032 * @bin_attr: struct bin_attribute for this file 1033 * @buf: user input 1034 * @off: file offset 1035 * @count: number of byte in input 1036 * 1037 * writing anything except 0 enables it 1038 */ 1039 static ssize_t 1040 pci_write_rom(struct file *filp, struct kobject *kobj, 1041 struct bin_attribute *bin_attr, 1042 char *buf, loff_t off, size_t count) 1043 { 1044 struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj)); 1045 1046 if ((off == 0) && (*buf == '0') && (count == 2)) 1047 pdev->rom_attr_enabled = 0; 1048 else 1049 pdev->rom_attr_enabled = 1; 1050 1051 return count; 1052 } 1053 1054 /** 1055 * pci_read_rom - read a PCI ROM 1056 * @filp: sysfs file 1057 * @kobj: kernel object handle 1058 * @bin_attr: struct bin_attribute for this file 1059 * @buf: where to put the data we read from the ROM 1060 * @off: file offset 1061 * @count: number of bytes to read 1062 * 1063 * Put @count bytes starting at @off into @buf from the ROM in the PCI 1064 * device corresponding to @kobj. 1065 */ 1066 static ssize_t 1067 pci_read_rom(struct file *filp, struct kobject *kobj, 1068 struct bin_attribute *bin_attr, 1069 char *buf, loff_t off, size_t count) 1070 { 1071 struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj)); 1072 void __iomem *rom; 1073 size_t size; 1074 1075 if (!pdev->rom_attr_enabled) 1076 return -EINVAL; 1077 1078 rom = pci_map_rom(pdev, &size); /* size starts out as PCI window size */ 1079 if (!rom || !size) 1080 return -EIO; 1081 1082 if (off >= size) 1083 count = 0; 1084 else { 1085 if (off + count > size) 1086 count = size - off; 1087 1088 memcpy_fromio(buf, rom + off, count); 1089 } 1090 pci_unmap_rom(pdev, rom); 1091 1092 return count; 1093 } 1094 1095 static struct bin_attribute pci_config_attr = { 1096 .attr = { 1097 .name = "config", 1098 .mode = S_IRUGO | S_IWUSR, 1099 }, 1100 .size = PCI_CFG_SPACE_SIZE, 1101 .read = pci_read_config, 1102 .write = pci_write_config, 1103 }; 1104 1105 static struct bin_attribute pcie_config_attr = { 1106 .attr = { 1107 .name = "config", 1108 .mode = S_IRUGO | S_IWUSR, 1109 }, 1110 .size = PCI_CFG_SPACE_EXP_SIZE, 1111 .read = pci_read_config, 1112 .write = pci_write_config, 1113 }; 1114 1115 int __attribute__ ((weak)) pcibios_add_platform_entries(struct pci_dev *dev) 1116 { 1117 return 0; 1118 } 1119 1120 static ssize_t reset_store(struct device *dev, 1121 struct device_attribute *attr, const char *buf, 1122 size_t count) 1123 { 1124 struct pci_dev *pdev = to_pci_dev(dev); 1125 unsigned long val; 1126 ssize_t result = strict_strtoul(buf, 0, &val); 1127 1128 if (result < 0) 1129 return result; 1130 1131 if (val != 1) 1132 return -EINVAL; 1133 1134 result = pci_reset_function(pdev); 1135 if (result < 0) 1136 return result; 1137 1138 return count; 1139 } 1140 1141 static struct device_attribute reset_attr = __ATTR(reset, 0200, NULL, reset_store); 1142 1143 static int pci_create_capabilities_sysfs(struct pci_dev *dev) 1144 { 1145 int retval; 1146 struct bin_attribute *attr; 1147 1148 /* If the device has VPD, try to expose it in sysfs. */ 1149 if (dev->vpd) { 1150 attr = kzalloc(sizeof(*attr), GFP_ATOMIC); 1151 if (!attr) 1152 return -ENOMEM; 1153 1154 sysfs_bin_attr_init(attr); 1155 attr->size = dev->vpd->len; 1156 attr->attr.name = "vpd"; 1157 attr->attr.mode = S_IRUSR | S_IWUSR; 1158 attr->read = read_vpd_attr; 1159 attr->write = write_vpd_attr; 1160 retval = sysfs_create_bin_file(&dev->dev.kobj, attr); 1161 if (retval) { 1162 kfree(attr); 1163 return retval; 1164 } 1165 dev->vpd->attr = attr; 1166 } 1167 1168 /* Active State Power Management */ 1169 pcie_aspm_create_sysfs_dev_files(dev); 1170 1171 if (!pci_probe_reset_function(dev)) { 1172 retval = device_create_file(&dev->dev, &reset_attr); 1173 if (retval) 1174 goto error; 1175 dev->reset_fn = 1; 1176 } 1177 return 0; 1178 1179 error: 1180 pcie_aspm_remove_sysfs_dev_files(dev); 1181 if (dev->vpd && dev->vpd->attr) { 1182 sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr); 1183 kfree(dev->vpd->attr); 1184 } 1185 1186 return retval; 1187 } 1188 1189 int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev) 1190 { 1191 int retval; 1192 int rom_size = 0; 1193 struct bin_attribute *attr; 1194 1195 if (!sysfs_initialized) 1196 return -EACCES; 1197 1198 if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE) 1199 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr); 1200 else 1201 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr); 1202 if (retval) 1203 goto err; 1204 1205 retval = pci_create_resource_files(pdev); 1206 if (retval) 1207 goto err_config_file; 1208 1209 if (pci_resource_len(pdev, PCI_ROM_RESOURCE)) 1210 rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE); 1211 else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW) 1212 rom_size = 0x20000; 1213 1214 /* If the device has a ROM, try to expose it in sysfs. */ 1215 if (rom_size) { 1216 attr = kzalloc(sizeof(*attr), GFP_ATOMIC); 1217 if (!attr) { 1218 retval = -ENOMEM; 1219 goto err_resource_files; 1220 } 1221 sysfs_bin_attr_init(attr); 1222 attr->size = rom_size; 1223 attr->attr.name = "rom"; 1224 attr->attr.mode = S_IRUSR | S_IWUSR; 1225 attr->read = pci_read_rom; 1226 attr->write = pci_write_rom; 1227 retval = sysfs_create_bin_file(&pdev->dev.kobj, attr); 1228 if (retval) { 1229 kfree(attr); 1230 goto err_resource_files; 1231 } 1232 pdev->rom_attr = attr; 1233 } 1234 1235 if ((pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA) { 1236 retval = device_create_file(&pdev->dev, &vga_attr); 1237 if (retval) 1238 goto err_rom_file; 1239 } 1240 1241 /* add platform-specific attributes */ 1242 retval = pcibios_add_platform_entries(pdev); 1243 if (retval) 1244 goto err_vga_file; 1245 1246 /* add sysfs entries for various capabilities */ 1247 retval = pci_create_capabilities_sysfs(pdev); 1248 if (retval) 1249 goto err_vga_file; 1250 1251 pci_create_firmware_label_files(pdev); 1252 1253 return 0; 1254 1255 err_vga_file: 1256 if ((pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA) 1257 device_remove_file(&pdev->dev, &vga_attr); 1258 err_rom_file: 1259 if (rom_size) { 1260 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr); 1261 kfree(pdev->rom_attr); 1262 pdev->rom_attr = NULL; 1263 } 1264 err_resource_files: 1265 pci_remove_resource_files(pdev); 1266 err_config_file: 1267 if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE) 1268 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr); 1269 else 1270 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr); 1271 err: 1272 return retval; 1273 } 1274 1275 static void pci_remove_capabilities_sysfs(struct pci_dev *dev) 1276 { 1277 if (dev->vpd && dev->vpd->attr) { 1278 sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr); 1279 kfree(dev->vpd->attr); 1280 } 1281 1282 pcie_aspm_remove_sysfs_dev_files(dev); 1283 if (dev->reset_fn) { 1284 device_remove_file(&dev->dev, &reset_attr); 1285 dev->reset_fn = 0; 1286 } 1287 } 1288 1289 /** 1290 * pci_remove_sysfs_dev_files - cleanup PCI specific sysfs files 1291 * @pdev: device whose entries we should free 1292 * 1293 * Cleanup when @pdev is removed from sysfs. 1294 */ 1295 void pci_remove_sysfs_dev_files(struct pci_dev *pdev) 1296 { 1297 int rom_size = 0; 1298 1299 if (!sysfs_initialized) 1300 return; 1301 1302 pci_remove_capabilities_sysfs(pdev); 1303 1304 if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE) 1305 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr); 1306 else 1307 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr); 1308 1309 pci_remove_resource_files(pdev); 1310 1311 if (pci_resource_len(pdev, PCI_ROM_RESOURCE)) 1312 rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE); 1313 else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW) 1314 rom_size = 0x20000; 1315 1316 if (rom_size && pdev->rom_attr) { 1317 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr); 1318 kfree(pdev->rom_attr); 1319 } 1320 1321 pci_remove_firmware_label_files(pdev); 1322 1323 } 1324 1325 static int __init pci_sysfs_init(void) 1326 { 1327 struct pci_dev *pdev = NULL; 1328 int retval; 1329 1330 sysfs_initialized = 1; 1331 for_each_pci_dev(pdev) { 1332 retval = pci_create_sysfs_dev_files(pdev); 1333 if (retval) { 1334 pci_dev_put(pdev); 1335 return retval; 1336 } 1337 } 1338 1339 return 0; 1340 } 1341 1342 late_initcall(pci_sysfs_init); 1343