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