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/pci.h> 20#include <linux/stat.h> 21#include <linux/topology.h> 22#include <linux/mm.h> 23 24#include "pci.h" 25 26static int sysfs_initialized; /* = 0 */ 27 28/* show configuration fields */ 29#define pci_config_attr(field, format_string) \ 30static ssize_t \ 31field##_show(struct device *dev, struct device_attribute *attr, char *buf) \ 32{ \ 33 struct pci_dev *pdev; \ 34 \ 35 pdev = to_pci_dev (dev); \ 36 return sprintf (buf, format_string, pdev->field); \ 37} 38 39pci_config_attr(vendor, "0x%04x\n"); 40pci_config_attr(device, "0x%04x\n"); 41pci_config_attr(subsystem_vendor, "0x%04x\n"); 42pci_config_attr(subsystem_device, "0x%04x\n"); 43pci_config_attr(class, "0x%06x\n"); 44pci_config_attr(irq, "%u\n"); 45 46static ssize_t broken_parity_status_show(struct device *dev, 47 struct device_attribute *attr, 48 char *buf) 49{ 50 struct pci_dev *pdev = to_pci_dev(dev); 51 return sprintf (buf, "%u\n", pdev->broken_parity_status); 52} 53 54static ssize_t broken_parity_status_store(struct device *dev, 55 struct device_attribute *attr, 56 const char *buf, size_t count) 57{ 58 struct pci_dev *pdev = to_pci_dev(dev); 59 ssize_t consumed = -EINVAL; 60 61 if ((count > 0) && (*buf == '0' || *buf == '1')) { 62 pdev->broken_parity_status = *buf == '1' ? 1 : 0; 63 consumed = count; 64 } 65 return consumed; 66} 67 68static ssize_t local_cpus_show(struct device *dev, 69 struct device_attribute *attr, char *buf) 70{ 71 cpumask_t mask; 72 int len; 73 74 mask = pcibus_to_cpumask(to_pci_dev(dev)->bus); 75 len = cpumask_scnprintf(buf, PAGE_SIZE-2, mask); 76 strcat(buf,"\n"); 77 return 1+len; 78} 79 80/* show resources */ 81static ssize_t 82resource_show(struct device * dev, struct device_attribute *attr, char * buf) 83{ 84 struct pci_dev * pci_dev = to_pci_dev(dev); 85 char * str = buf; 86 int i; 87 int max = 7; 88 resource_size_t start, end; 89 90 if (pci_dev->subordinate) 91 max = DEVICE_COUNT_RESOURCE; 92 93 for (i = 0; i < max; i++) { 94 struct resource *res = &pci_dev->resource[i]; 95 pci_resource_to_user(pci_dev, i, res, &start, &end); 96 str += sprintf(str,"0x%016llx 0x%016llx 0x%016llx\n", 97 (unsigned long long)start, 98 (unsigned long long)end, 99 (unsigned long long)res->flags); 100 } 101 return (str - buf); 102} 103 104static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) 105{ 106 struct pci_dev *pci_dev = to_pci_dev(dev); 107 108 return sprintf(buf, "pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x\n", 109 pci_dev->vendor, pci_dev->device, 110 pci_dev->subsystem_vendor, pci_dev->subsystem_device, 111 (u8)(pci_dev->class >> 16), (u8)(pci_dev->class >> 8), 112 (u8)(pci_dev->class)); 113} 114 115static ssize_t is_enabled_store(struct device *dev, 116 struct device_attribute *attr, const char *buf, 117 size_t count) 118{ 119 ssize_t result = -EINVAL; 120 struct pci_dev *pdev = to_pci_dev(dev); 121 122 /* this can crash the machine when done on the "wrong" device */ 123 if (!capable(CAP_SYS_ADMIN)) 124 return count; 125 126 if (*buf == '0') { 127 if (atomic_read(&pdev->enable_cnt) != 0) 128 pci_disable_device(pdev); 129 else 130 result = -EIO; 131 } else if (*buf == '1') 132 result = pci_enable_device(pdev); 133 134 return result < 0 ? result : count; 135} 136 137static ssize_t is_enabled_show(struct device *dev, 138 struct device_attribute *attr, char *buf) 139{ 140 struct pci_dev *pdev; 141 142 pdev = to_pci_dev (dev); 143 return sprintf (buf, "%u\n", atomic_read(&pdev->enable_cnt)); 144} 145 146#ifdef CONFIG_NUMA 147static ssize_t 148numa_node_show(struct device *dev, struct device_attribute *attr, char *buf) 149{ 150 return sprintf (buf, "%d\n", dev->numa_node); 151} 152#endif 153 154static ssize_t 155msi_bus_show(struct device *dev, struct device_attribute *attr, char *buf) 156{ 157 struct pci_dev *pdev = to_pci_dev(dev); 158 159 if (!pdev->subordinate) 160 return 0; 161 162 return sprintf (buf, "%u\n", 163 !(pdev->subordinate->bus_flags & PCI_BUS_FLAGS_NO_MSI)); 164} 165 166static ssize_t 167msi_bus_store(struct device *dev, struct device_attribute *attr, 168 const char *buf, size_t count) 169{ 170 struct pci_dev *pdev = to_pci_dev(dev); 171 172 /* bad things may happen if the no_msi flag is changed 173 * while some drivers are loaded */ 174 if (!capable(CAP_SYS_ADMIN)) 175 return count; 176 177 if (!pdev->subordinate) 178 return count; 179 180 if (*buf == '0') { 181 pdev->subordinate->bus_flags |= PCI_BUS_FLAGS_NO_MSI; 182 dev_warn(&pdev->dev, "forced subordinate bus to not support MSI," 183 " bad things could happen.\n"); 184 } 185 186 if (*buf == '1') { 187 pdev->subordinate->bus_flags &= ~PCI_BUS_FLAGS_NO_MSI; 188 dev_warn(&pdev->dev, "forced subordinate bus to support MSI," 189 " bad things could happen.\n"); 190 } 191 192 return count; 193} 194 195struct device_attribute pci_dev_attrs[] = { 196 __ATTR_RO(resource), 197 __ATTR_RO(vendor), 198 __ATTR_RO(device), 199 __ATTR_RO(subsystem_vendor), 200 __ATTR_RO(subsystem_device), 201 __ATTR_RO(class), 202 __ATTR_RO(irq), 203 __ATTR_RO(local_cpus), 204 __ATTR_RO(modalias), 205#ifdef CONFIG_NUMA 206 __ATTR_RO(numa_node), 207#endif 208 __ATTR(enable, 0600, is_enabled_show, is_enabled_store), 209 __ATTR(broken_parity_status,(S_IRUGO|S_IWUSR), 210 broken_parity_status_show,broken_parity_status_store), 211 __ATTR(msi_bus, 0644, msi_bus_show, msi_bus_store), 212 __ATTR_NULL, 213}; 214 215static ssize_t 216pci_read_config(struct kobject *kobj, char *buf, loff_t off, size_t count) 217{ 218 struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj)); 219 unsigned int size = 64; 220 loff_t init_off = off; 221 u8 *data = (u8*) buf; 222 223 /* Several chips lock up trying to read undefined config space */ 224 if (capable(CAP_SYS_ADMIN)) { 225 size = dev->cfg_size; 226 } else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) { 227 size = 128; 228 } 229 230 if (off > size) 231 return 0; 232 if (off + count > size) { 233 size -= off; 234 count = size; 235 } else { 236 size = count; 237 } 238 239 if ((off & 1) && size) { 240 u8 val; 241 pci_user_read_config_byte(dev, off, &val); 242 data[off - init_off] = val; 243 off++; 244 size--; 245 } 246 247 if ((off & 3) && size > 2) { 248 u16 val; 249 pci_user_read_config_word(dev, off, &val); 250 data[off - init_off] = val & 0xff; 251 data[off - init_off + 1] = (val >> 8) & 0xff; 252 off += 2; 253 size -= 2; 254 } 255 256 while (size > 3) { 257 u32 val; 258 pci_user_read_config_dword(dev, off, &val); 259 data[off - init_off] = val & 0xff; 260 data[off - init_off + 1] = (val >> 8) & 0xff; 261 data[off - init_off + 2] = (val >> 16) & 0xff; 262 data[off - init_off + 3] = (val >> 24) & 0xff; 263 off += 4; 264 size -= 4; 265 } 266 267 if (size >= 2) { 268 u16 val; 269 pci_user_read_config_word(dev, off, &val); 270 data[off - init_off] = val & 0xff; 271 data[off - init_off + 1] = (val >> 8) & 0xff; 272 off += 2; 273 size -= 2; 274 } 275 276 if (size > 0) { 277 u8 val; 278 pci_user_read_config_byte(dev, off, &val); 279 data[off - init_off] = val; 280 off++; 281 --size; 282 } 283 284 return count; 285} 286 287static ssize_t 288pci_write_config(struct kobject *kobj, char *buf, loff_t off, size_t count) 289{ 290 struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj)); 291 unsigned int size = count; 292 loff_t init_off = off; 293 u8 *data = (u8*) buf; 294 295 if (off > dev->cfg_size) 296 return 0; 297 if (off + count > dev->cfg_size) { 298 size = dev->cfg_size - off; 299 count = size; 300 } 301 302 if ((off & 1) && size) { 303 pci_user_write_config_byte(dev, off, data[off - init_off]); 304 off++; 305 size--; 306 } 307 308 if ((off & 3) && size > 2) { 309 u16 val = data[off - init_off]; 310 val |= (u16) data[off - init_off + 1] << 8; 311 pci_user_write_config_word(dev, off, val); 312 off += 2; 313 size -= 2; 314 } 315 316 while (size > 3) { 317 u32 val = data[off - init_off]; 318 val |= (u32) data[off - init_off + 1] << 8; 319 val |= (u32) data[off - init_off + 2] << 16; 320 val |= (u32) data[off - init_off + 3] << 24; 321 pci_user_write_config_dword(dev, off, val); 322 off += 4; 323 size -= 4; 324 } 325 326 if (size >= 2) { 327 u16 val = data[off - init_off]; 328 val |= (u16) data[off - init_off + 1] << 8; 329 pci_user_write_config_word(dev, off, val); 330 off += 2; 331 size -= 2; 332 } 333 334 if (size) { 335 pci_user_write_config_byte(dev, off, data[off - init_off]); 336 off++; 337 --size; 338 } 339 340 return count; 341} 342 343#ifdef HAVE_PCI_LEGACY 344/** 345 * pci_read_legacy_io - read byte(s) from legacy I/O port space 346 * @kobj: kobject corresponding to file to read from 347 * @buf: buffer to store results 348 * @off: offset into legacy I/O port space 349 * @count: number of bytes to read 350 * 351 * Reads 1, 2, or 4 bytes from legacy I/O port space using an arch specific 352 * callback routine (pci_legacy_read). 353 */ 354ssize_t 355pci_read_legacy_io(struct kobject *kobj, char *buf, loff_t off, size_t count) 356{ 357 struct pci_bus *bus = to_pci_bus(container_of(kobj, 358 struct class_device, 359 kobj)); 360 361 /* Only support 1, 2 or 4 byte accesses */ 362 if (count != 1 && count != 2 && count != 4) 363 return -EINVAL; 364 365 return pci_legacy_read(bus, off, (u32 *)buf, count); 366} 367 368/** 369 * pci_write_legacy_io - write byte(s) to legacy I/O port space 370 * @kobj: kobject corresponding to file to read from 371 * @buf: buffer containing value to be written 372 * @off: offset into legacy I/O port space 373 * @count: number of bytes to write 374 * 375 * Writes 1, 2, or 4 bytes from legacy I/O port space using an arch specific 376 * callback routine (pci_legacy_write). 377 */ 378ssize_t 379pci_write_legacy_io(struct kobject *kobj, char *buf, loff_t off, size_t count) 380{ 381 struct pci_bus *bus = to_pci_bus(container_of(kobj, 382 struct class_device, 383 kobj)); 384 /* Only support 1, 2 or 4 byte accesses */ 385 if (count != 1 && count != 2 && count != 4) 386 return -EINVAL; 387 388 return pci_legacy_write(bus, off, *(u32 *)buf, count); 389} 390 391/** 392 * pci_mmap_legacy_mem - map legacy PCI memory into user memory space 393 * @kobj: kobject corresponding to device to be mapped 394 * @attr: struct bin_attribute for this file 395 * @vma: struct vm_area_struct passed to mmap 396 * 397 * Uses an arch specific callback, pci_mmap_legacy_page_range, to mmap 398 * legacy memory space (first meg of bus space) into application virtual 399 * memory space. 400 */ 401int 402pci_mmap_legacy_mem(struct kobject *kobj, struct bin_attribute *attr, 403 struct vm_area_struct *vma) 404{ 405 struct pci_bus *bus = to_pci_bus(container_of(kobj, 406 struct class_device, 407 kobj)); 408 409 return pci_mmap_legacy_page_range(bus, vma); 410} 411#endif /* HAVE_PCI_LEGACY */ 412 413#ifdef HAVE_PCI_MMAP 414static int 415pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr, 416 struct vm_area_struct *vma) 417{ 418 struct pci_dev *pdev = to_pci_dev(container_of(kobj, 419 struct device, kobj)); 420 struct resource *res = (struct resource *)attr->private; 421 enum pci_mmap_state mmap_type; 422 resource_size_t start, end; 423 int i; 424 425 for (i = 0; i < PCI_ROM_RESOURCE; i++) 426 if (res == &pdev->resource[i]) 427 break; 428 if (i >= PCI_ROM_RESOURCE) 429 return -ENODEV; 430 431 /* pci_mmap_page_range() expects the same kind of entry as coming 432 * from /proc/bus/pci/ which is a "user visible" value. If this is 433 * different from the resource itself, arch will do necessary fixup. 434 */ 435 pci_resource_to_user(pdev, i, res, &start, &end); 436 vma->vm_pgoff += start >> PAGE_SHIFT; 437 mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io; 438 439 return pci_mmap_page_range(pdev, vma, mmap_type, 0); 440} 441 442/** 443 * pci_remove_resource_files - cleanup resource files 444 * @dev: dev to cleanup 445 * 446 * If we created resource files for @dev, remove them from sysfs and 447 * free their resources. 448 */ 449static void 450pci_remove_resource_files(struct pci_dev *pdev) 451{ 452 int i; 453 454 for (i = 0; i < PCI_ROM_RESOURCE; i++) { 455 struct bin_attribute *res_attr; 456 457 res_attr = pdev->res_attr[i]; 458 if (res_attr) { 459 sysfs_remove_bin_file(&pdev->dev.kobj, res_attr); 460 kfree(res_attr); 461 } 462 } 463} 464 465/** 466 * pci_create_resource_files - create resource files in sysfs for @dev 467 * @dev: dev in question 468 * 469 * Walk the resources in @dev creating files for each resource available. 470 */ 471static int pci_create_resource_files(struct pci_dev *pdev) 472{ 473 int i; 474 int retval; 475 476 /* Expose the PCI resources from this device as files */ 477 for (i = 0; i < PCI_ROM_RESOURCE; i++) { 478 struct bin_attribute *res_attr; 479 480 /* skip empty resources */ 481 if (!pci_resource_len(pdev, i)) 482 continue; 483 484 /* allocate attribute structure, piggyback attribute name */ 485 res_attr = kzalloc(sizeof(*res_attr) + 10, GFP_ATOMIC); 486 if (res_attr) { 487 char *res_attr_name = (char *)(res_attr + 1); 488 489 pdev->res_attr[i] = res_attr; 490 sprintf(res_attr_name, "resource%d", i); 491 res_attr->attr.name = res_attr_name; 492 res_attr->attr.mode = S_IRUSR | S_IWUSR; 493 res_attr->attr.owner = THIS_MODULE; 494 res_attr->size = pci_resource_len(pdev, i); 495 res_attr->mmap = pci_mmap_resource; 496 res_attr->private = &pdev->resource[i]; 497 retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr); 498 if (retval) { 499 pci_remove_resource_files(pdev); 500 return retval; 501 } 502 } else { 503 return -ENOMEM; 504 } 505 } 506 return 0; 507} 508#else /* !HAVE_PCI_MMAP */ 509static inline int pci_create_resource_files(struct pci_dev *dev) { return 0; } 510static inline void pci_remove_resource_files(struct pci_dev *dev) { return; } 511#endif /* HAVE_PCI_MMAP */ 512 513/** 514 * pci_write_rom - used to enable access to the PCI ROM display 515 * @kobj: kernel object handle 516 * @buf: user input 517 * @off: file offset 518 * @count: number of byte in input 519 * 520 * writing anything except 0 enables it 521 */ 522static ssize_t 523pci_write_rom(struct kobject *kobj, char *buf, loff_t off, size_t count) 524{ 525 struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj)); 526 527 if ((off == 0) && (*buf == '0') && (count == 2)) 528 pdev->rom_attr_enabled = 0; 529 else 530 pdev->rom_attr_enabled = 1; 531 532 return count; 533} 534 535/** 536 * pci_read_rom - read a PCI ROM 537 * @kobj: kernel object handle 538 * @buf: where to put the data we read from the ROM 539 * @off: file offset 540 * @count: number of bytes to read 541 * 542 * Put @count bytes starting at @off into @buf from the ROM in the PCI 543 * device corresponding to @kobj. 544 */ 545static ssize_t 546pci_read_rom(struct kobject *kobj, char *buf, loff_t off, size_t count) 547{ 548 struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj)); 549 void __iomem *rom; 550 size_t size; 551 552 if (!pdev->rom_attr_enabled) 553 return -EINVAL; 554 555 rom = pci_map_rom(pdev, &size); /* size starts out as PCI window size */ 556 if (!rom) 557 return 0; 558 559 if (off >= size) 560 count = 0; 561 else { 562 if (off + count > size) 563 count = size - off; 564 565 memcpy_fromio(buf, rom + off, count); 566 } 567 pci_unmap_rom(pdev, rom); 568 569 return count; 570} 571 572static struct bin_attribute pci_config_attr = { 573 .attr = { 574 .name = "config", 575 .mode = S_IRUGO | S_IWUSR, 576 .owner = THIS_MODULE, 577 }, 578 .size = 256, 579 .read = pci_read_config, 580 .write = pci_write_config, 581}; 582 583static struct bin_attribute pcie_config_attr = { 584 .attr = { 585 .name = "config", 586 .mode = S_IRUGO | S_IWUSR, 587 .owner = THIS_MODULE, 588 }, 589 .size = 4096, 590 .read = pci_read_config, 591 .write = pci_write_config, 592}; 593 594int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev) 595{ 596 struct bin_attribute *rom_attr = NULL; 597 int retval; 598 599 if (!sysfs_initialized) 600 return -EACCES; 601 602 if (pdev->cfg_size < 4096) 603 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr); 604 else 605 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr); 606 if (retval) 607 goto err; 608 609 retval = pci_create_resource_files(pdev); 610 if (retval) 611 goto err_bin_file; 612 613 /* If the device has a ROM, try to expose it in sysfs. */ 614 if (pci_resource_len(pdev, PCI_ROM_RESOURCE) || 615 (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)) { 616 rom_attr = kzalloc(sizeof(*rom_attr), GFP_ATOMIC); 617 if (rom_attr) { 618 pdev->rom_attr = rom_attr; 619 rom_attr->size = pci_resource_len(pdev, PCI_ROM_RESOURCE); 620 rom_attr->attr.name = "rom"; 621 rom_attr->attr.mode = S_IRUSR; 622 rom_attr->attr.owner = THIS_MODULE; 623 rom_attr->read = pci_read_rom; 624 rom_attr->write = pci_write_rom; 625 retval = sysfs_create_bin_file(&pdev->dev.kobj, rom_attr); 626 if (retval) 627 goto err_rom; 628 } else { 629 retval = -ENOMEM; 630 goto err_resource_files; 631 } 632 } 633 /* add platform-specific attributes */ 634 pcibios_add_platform_entries(pdev); 635 636 return 0; 637 638err_rom: 639 kfree(rom_attr); 640err_resource_files: 641 pci_remove_resource_files(pdev); 642err_bin_file: 643 if (pdev->cfg_size < 4096) 644 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr); 645 else 646 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr); 647err: 648 return retval; 649} 650 651/** 652 * pci_remove_sysfs_dev_files - cleanup PCI specific sysfs files 653 * @pdev: device whose entries we should free 654 * 655 * Cleanup when @pdev is removed from sysfs. 656 */ 657void pci_remove_sysfs_dev_files(struct pci_dev *pdev) 658{ 659 if (!sysfs_initialized) 660 return; 661 662 if (pdev->cfg_size < 4096) 663 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr); 664 else 665 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr); 666 667 pci_remove_resource_files(pdev); 668 669 if (pci_resource_len(pdev, PCI_ROM_RESOURCE)) { 670 if (pdev->rom_attr) { 671 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr); 672 kfree(pdev->rom_attr); 673 } 674 } 675} 676 677static int __init pci_sysfs_init(void) 678{ 679 struct pci_dev *pdev = NULL; 680 int retval; 681 682 sysfs_initialized = 1; 683 for_each_pci_dev(pdev) { 684 retval = pci_create_sysfs_dev_files(pdev); 685 if (retval) 686 return retval; 687 } 688 689 return 0; 690} 691 692late_initcall(pci_sysfs_init); 693