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 30 static int sysfs_initialized; /* = 0 */ 31 32 /* show configuration fields */ 33 #define pci_config_attr(field, format_string) \ 34 static ssize_t \ 35 field##_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 43 pci_config_attr(vendor, "0x%04x\n"); 44 pci_config_attr(device, "0x%04x\n"); 45 pci_config_attr(subsystem_vendor, "0x%04x\n"); 46 pci_config_attr(subsystem_device, "0x%04x\n"); 47 pci_config_attr(class, "0x%06x\n"); 48 pci_config_attr(irq, "%u\n"); 49 50 static 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 58 static 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 73 static 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 92 static 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 */ 111 static ssize_t 112 resource_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 136 static 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 147 static 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 173 static 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 183 static ssize_t 184 numa_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 190 static ssize_t 191 dma_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 198 static ssize_t 199 consistent_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 205 static ssize_t 206 msi_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 217 static ssize_t 218 msi_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 250 static DEFINE_MUTEX(pci_remove_rescan_mutex); 251 static 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 269 struct bus_attribute pci_bus_attrs[] = { 270 __ATTR(rescan, (S_IWUSR|S_IWGRP), NULL, bus_rescan_store), 271 __ATTR_NULL 272 }; 273 274 static ssize_t 275 dev_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 292 static 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 301 static ssize_t 302 remove_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 322 struct 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 349 static ssize_t 350 boot_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 } 358 struct device_attribute vga_attr = __ATTR_RO(boot_vga); 359 360 static ssize_t 361 pci_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 434 static ssize_t 435 pci_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 492 static ssize_t 493 read_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 508 static ssize_t 509 write_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 */ 537 static ssize_t 538 pci_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 */ 565 static ssize_t 566 pci_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 */ 591 static int 592 pci_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 */ 614 static int 615 pci_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 */ 633 void __weak 634 pci_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 */ 650 void 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 685 legacy_mem_err: 686 device_remove_bin_file(&b->dev, b->legacy_io); 687 legacy_io_err: 688 kfree(b->legacy_io); 689 b->legacy_io = NULL; 690 kzalloc_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 696 void 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 708 int 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 */ 735 static int 736 pci_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 (u64)pci_resource_start(pdev, i), 758 (u64)pci_resource_len(pdev, i)); 759 return -EINVAL; 760 } 761 762 /* pci_mmap_page_range() expects the same kind of entry as coming 763 * from /proc/bus/pci/ which is a "user visible" value. If this is 764 * different from the resource itself, arch will do necessary fixup. 765 */ 766 pci_resource_to_user(pdev, i, res, &start, &end); 767 vma->vm_pgoff += start >> PAGE_SHIFT; 768 mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io; 769 770 if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(start)) 771 return -EINVAL; 772 773 return pci_mmap_page_range(pdev, vma, mmap_type, write_combine); 774 } 775 776 static int 777 pci_mmap_resource_uc(struct file *filp, struct kobject *kobj, 778 struct bin_attribute *attr, 779 struct vm_area_struct *vma) 780 { 781 return pci_mmap_resource(kobj, attr, vma, 0); 782 } 783 784 static int 785 pci_mmap_resource_wc(struct file *filp, struct kobject *kobj, 786 struct bin_attribute *attr, 787 struct vm_area_struct *vma) 788 { 789 return pci_mmap_resource(kobj, attr, vma, 1); 790 } 791 792 static ssize_t 793 pci_resource_io(struct file *filp, struct kobject *kobj, 794 struct bin_attribute *attr, char *buf, 795 loff_t off, size_t count, bool write) 796 { 797 struct pci_dev *pdev = to_pci_dev(container_of(kobj, 798 struct device, kobj)); 799 struct resource *res = attr->private; 800 unsigned long port = off; 801 int i; 802 803 for (i = 0; i < PCI_ROM_RESOURCE; i++) 804 if (res == &pdev->resource[i]) 805 break; 806 if (i >= PCI_ROM_RESOURCE) 807 return -ENODEV; 808 809 port += pci_resource_start(pdev, i); 810 811 if (port > pci_resource_end(pdev, i)) 812 return 0; 813 814 if (port + count - 1 > pci_resource_end(pdev, i)) 815 return -EINVAL; 816 817 switch (count) { 818 case 1: 819 if (write) 820 outb(*(u8 *)buf, port); 821 else 822 *(u8 *)buf = inb(port); 823 return 1; 824 case 2: 825 if (write) 826 outw(*(u16 *)buf, port); 827 else 828 *(u16 *)buf = inw(port); 829 return 2; 830 case 4: 831 if (write) 832 outl(*(u32 *)buf, port); 833 else 834 *(u32 *)buf = inl(port); 835 return 4; 836 } 837 return -EINVAL; 838 } 839 840 static ssize_t 841 pci_read_resource_io(struct file *filp, struct kobject *kobj, 842 struct bin_attribute *attr, char *buf, 843 loff_t off, size_t count) 844 { 845 return pci_resource_io(filp, kobj, attr, buf, off, count, false); 846 } 847 848 static ssize_t 849 pci_write_resource_io(struct file *filp, struct kobject *kobj, 850 struct bin_attribute *attr, char *buf, 851 loff_t off, size_t count) 852 { 853 return pci_resource_io(filp, kobj, attr, buf, off, count, true); 854 } 855 856 /** 857 * pci_remove_resource_files - cleanup resource files 858 * @pdev: dev to cleanup 859 * 860 * If we created resource files for @pdev, remove them from sysfs and 861 * free their resources. 862 */ 863 static void 864 pci_remove_resource_files(struct pci_dev *pdev) 865 { 866 int i; 867 868 for (i = 0; i < PCI_ROM_RESOURCE; i++) { 869 struct bin_attribute *res_attr; 870 871 res_attr = pdev->res_attr[i]; 872 if (res_attr) { 873 sysfs_remove_bin_file(&pdev->dev.kobj, res_attr); 874 kfree(res_attr); 875 } 876 877 res_attr = pdev->res_attr_wc[i]; 878 if (res_attr) { 879 sysfs_remove_bin_file(&pdev->dev.kobj, res_attr); 880 kfree(res_attr); 881 } 882 } 883 } 884 885 static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine) 886 { 887 /* allocate attribute structure, piggyback attribute name */ 888 int name_len = write_combine ? 13 : 10; 889 struct bin_attribute *res_attr; 890 int retval; 891 892 res_attr = kzalloc(sizeof(*res_attr) + name_len, GFP_ATOMIC); 893 if (res_attr) { 894 char *res_attr_name = (char *)(res_attr + 1); 895 896 sysfs_bin_attr_init(res_attr); 897 if (write_combine) { 898 pdev->res_attr_wc[num] = res_attr; 899 sprintf(res_attr_name, "resource%d_wc", num); 900 res_attr->mmap = pci_mmap_resource_wc; 901 } else { 902 pdev->res_attr[num] = res_attr; 903 sprintf(res_attr_name, "resource%d", num); 904 res_attr->mmap = pci_mmap_resource_uc; 905 } 906 if (pci_resource_flags(pdev, num) & IORESOURCE_IO) { 907 res_attr->read = pci_read_resource_io; 908 res_attr->write = pci_write_resource_io; 909 } 910 res_attr->attr.name = res_attr_name; 911 res_attr->attr.mode = S_IRUSR | S_IWUSR; 912 res_attr->size = pci_resource_len(pdev, num); 913 res_attr->private = &pdev->resource[num]; 914 retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr); 915 } else 916 retval = -ENOMEM; 917 918 return retval; 919 } 920 921 /** 922 * pci_create_resource_files - create resource files in sysfs for @dev 923 * @pdev: dev in question 924 * 925 * Walk the resources in @pdev creating files for each resource available. 926 */ 927 static int pci_create_resource_files(struct pci_dev *pdev) 928 { 929 int i; 930 int retval; 931 932 /* Expose the PCI resources from this device as files */ 933 for (i = 0; i < PCI_ROM_RESOURCE; i++) { 934 935 /* skip empty resources */ 936 if (!pci_resource_len(pdev, i)) 937 continue; 938 939 retval = pci_create_attr(pdev, i, 0); 940 /* for prefetchable resources, create a WC mappable file */ 941 if (!retval && pdev->resource[i].flags & IORESOURCE_PREFETCH) 942 retval = pci_create_attr(pdev, i, 1); 943 944 if (retval) { 945 pci_remove_resource_files(pdev); 946 return retval; 947 } 948 } 949 return 0; 950 } 951 #else /* !HAVE_PCI_MMAP */ 952 int __weak pci_create_resource_files(struct pci_dev *dev) { return 0; } 953 void __weak pci_remove_resource_files(struct pci_dev *dev) { return; } 954 #endif /* HAVE_PCI_MMAP */ 955 956 /** 957 * pci_write_rom - used to enable access to the PCI ROM display 958 * @filp: sysfs file 959 * @kobj: kernel object handle 960 * @bin_attr: struct bin_attribute for this file 961 * @buf: user input 962 * @off: file offset 963 * @count: number of byte in input 964 * 965 * writing anything except 0 enables it 966 */ 967 static ssize_t 968 pci_write_rom(struct file *filp, struct kobject *kobj, 969 struct bin_attribute *bin_attr, 970 char *buf, loff_t off, size_t count) 971 { 972 struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj)); 973 974 if ((off == 0) && (*buf == '0') && (count == 2)) 975 pdev->rom_attr_enabled = 0; 976 else 977 pdev->rom_attr_enabled = 1; 978 979 return count; 980 } 981 982 /** 983 * pci_read_rom - read a PCI ROM 984 * @filp: sysfs file 985 * @kobj: kernel object handle 986 * @bin_attr: struct bin_attribute for this file 987 * @buf: where to put the data we read from the ROM 988 * @off: file offset 989 * @count: number of bytes to read 990 * 991 * Put @count bytes starting at @off into @buf from the ROM in the PCI 992 * device corresponding to @kobj. 993 */ 994 static ssize_t 995 pci_read_rom(struct file *filp, struct kobject *kobj, 996 struct bin_attribute *bin_attr, 997 char *buf, loff_t off, size_t count) 998 { 999 struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj)); 1000 void __iomem *rom; 1001 size_t size; 1002 1003 if (!pdev->rom_attr_enabled) 1004 return -EINVAL; 1005 1006 rom = pci_map_rom(pdev, &size); /* size starts out as PCI window size */ 1007 if (!rom || !size) 1008 return -EIO; 1009 1010 if (off >= size) 1011 count = 0; 1012 else { 1013 if (off + count > size) 1014 count = size - off; 1015 1016 memcpy_fromio(buf, rom + off, count); 1017 } 1018 pci_unmap_rom(pdev, rom); 1019 1020 return count; 1021 } 1022 1023 static struct bin_attribute pci_config_attr = { 1024 .attr = { 1025 .name = "config", 1026 .mode = S_IRUGO | S_IWUSR, 1027 }, 1028 .size = PCI_CFG_SPACE_SIZE, 1029 .read = pci_read_config, 1030 .write = pci_write_config, 1031 }; 1032 1033 static struct bin_attribute pcie_config_attr = { 1034 .attr = { 1035 .name = "config", 1036 .mode = S_IRUGO | S_IWUSR, 1037 }, 1038 .size = PCI_CFG_SPACE_EXP_SIZE, 1039 .read = pci_read_config, 1040 .write = pci_write_config, 1041 }; 1042 1043 int __attribute__ ((weak)) pcibios_add_platform_entries(struct pci_dev *dev) 1044 { 1045 return 0; 1046 } 1047 1048 static ssize_t reset_store(struct device *dev, 1049 struct device_attribute *attr, const char *buf, 1050 size_t count) 1051 { 1052 struct pci_dev *pdev = to_pci_dev(dev); 1053 unsigned long val; 1054 ssize_t result = strict_strtoul(buf, 0, &val); 1055 1056 if (result < 0) 1057 return result; 1058 1059 if (val != 1) 1060 return -EINVAL; 1061 1062 result = pci_reset_function(pdev); 1063 if (result < 0) 1064 return result; 1065 1066 return count; 1067 } 1068 1069 static struct device_attribute reset_attr = __ATTR(reset, 0200, NULL, reset_store); 1070 1071 static int pci_create_capabilities_sysfs(struct pci_dev *dev) 1072 { 1073 int retval; 1074 struct bin_attribute *attr; 1075 1076 /* If the device has VPD, try to expose it in sysfs. */ 1077 if (dev->vpd) { 1078 attr = kzalloc(sizeof(*attr), GFP_ATOMIC); 1079 if (!attr) 1080 return -ENOMEM; 1081 1082 sysfs_bin_attr_init(attr); 1083 attr->size = dev->vpd->len; 1084 attr->attr.name = "vpd"; 1085 attr->attr.mode = S_IRUSR | S_IWUSR; 1086 attr->read = read_vpd_attr; 1087 attr->write = write_vpd_attr; 1088 retval = sysfs_create_bin_file(&dev->dev.kobj, attr); 1089 if (retval) { 1090 kfree(dev->vpd->attr); 1091 return retval; 1092 } 1093 dev->vpd->attr = attr; 1094 } 1095 1096 /* Active State Power Management */ 1097 pcie_aspm_create_sysfs_dev_files(dev); 1098 1099 if (!pci_probe_reset_function(dev)) { 1100 retval = device_create_file(&dev->dev, &reset_attr); 1101 if (retval) 1102 goto error; 1103 dev->reset_fn = 1; 1104 } 1105 return 0; 1106 1107 error: 1108 pcie_aspm_remove_sysfs_dev_files(dev); 1109 if (dev->vpd && dev->vpd->attr) { 1110 sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr); 1111 kfree(dev->vpd->attr); 1112 } 1113 1114 return retval; 1115 } 1116 1117 int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev) 1118 { 1119 int retval; 1120 int rom_size = 0; 1121 struct bin_attribute *attr; 1122 1123 if (!sysfs_initialized) 1124 return -EACCES; 1125 1126 if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE) 1127 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr); 1128 else 1129 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr); 1130 if (retval) 1131 goto err; 1132 1133 retval = pci_create_resource_files(pdev); 1134 if (retval) 1135 goto err_config_file; 1136 1137 if (pci_resource_len(pdev, PCI_ROM_RESOURCE)) 1138 rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE); 1139 else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW) 1140 rom_size = 0x20000; 1141 1142 /* If the device has a ROM, try to expose it in sysfs. */ 1143 if (rom_size) { 1144 attr = kzalloc(sizeof(*attr), GFP_ATOMIC); 1145 if (!attr) { 1146 retval = -ENOMEM; 1147 goto err_resource_files; 1148 } 1149 sysfs_bin_attr_init(attr); 1150 attr->size = rom_size; 1151 attr->attr.name = "rom"; 1152 attr->attr.mode = S_IRUSR | S_IWUSR; 1153 attr->read = pci_read_rom; 1154 attr->write = pci_write_rom; 1155 retval = sysfs_create_bin_file(&pdev->dev.kobj, attr); 1156 if (retval) { 1157 kfree(attr); 1158 goto err_resource_files; 1159 } 1160 pdev->rom_attr = attr; 1161 } 1162 1163 if ((pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA) { 1164 retval = device_create_file(&pdev->dev, &vga_attr); 1165 if (retval) 1166 goto err_rom_file; 1167 } 1168 1169 /* add platform-specific attributes */ 1170 retval = pcibios_add_platform_entries(pdev); 1171 if (retval) 1172 goto err_vga_file; 1173 1174 /* add sysfs entries for various capabilities */ 1175 retval = pci_create_capabilities_sysfs(pdev); 1176 if (retval) 1177 goto err_vga_file; 1178 1179 pci_create_firmware_label_files(pdev); 1180 1181 return 0; 1182 1183 err_vga_file: 1184 if ((pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA) 1185 device_remove_file(&pdev->dev, &vga_attr); 1186 err_rom_file: 1187 if (rom_size) { 1188 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr); 1189 kfree(pdev->rom_attr); 1190 pdev->rom_attr = NULL; 1191 } 1192 err_resource_files: 1193 pci_remove_resource_files(pdev); 1194 err_config_file: 1195 if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE) 1196 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr); 1197 else 1198 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr); 1199 err: 1200 return retval; 1201 } 1202 1203 static void pci_remove_capabilities_sysfs(struct pci_dev *dev) 1204 { 1205 if (dev->vpd && dev->vpd->attr) { 1206 sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr); 1207 kfree(dev->vpd->attr); 1208 } 1209 1210 pcie_aspm_remove_sysfs_dev_files(dev); 1211 if (dev->reset_fn) { 1212 device_remove_file(&dev->dev, &reset_attr); 1213 dev->reset_fn = 0; 1214 } 1215 } 1216 1217 /** 1218 * pci_remove_sysfs_dev_files - cleanup PCI specific sysfs files 1219 * @pdev: device whose entries we should free 1220 * 1221 * Cleanup when @pdev is removed from sysfs. 1222 */ 1223 void pci_remove_sysfs_dev_files(struct pci_dev *pdev) 1224 { 1225 int rom_size = 0; 1226 1227 if (!sysfs_initialized) 1228 return; 1229 1230 pci_remove_capabilities_sysfs(pdev); 1231 1232 if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE) 1233 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr); 1234 else 1235 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr); 1236 1237 pci_remove_resource_files(pdev); 1238 1239 if (pci_resource_len(pdev, PCI_ROM_RESOURCE)) 1240 rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE); 1241 else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW) 1242 rom_size = 0x20000; 1243 1244 if (rom_size && pdev->rom_attr) { 1245 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr); 1246 kfree(pdev->rom_attr); 1247 } 1248 1249 pci_remove_firmware_label_files(pdev); 1250 1251 } 1252 1253 static int __init pci_sysfs_init(void) 1254 { 1255 struct pci_dev *pdev = NULL; 1256 int retval; 1257 1258 sysfs_initialized = 1; 1259 for_each_pci_dev(pdev) { 1260 retval = pci_create_sysfs_dev_files(pdev); 1261 if (retval) { 1262 pci_dev_put(pdev); 1263 return retval; 1264 } 1265 } 1266 1267 return 0; 1268 } 1269 1270 late_initcall(pci_sysfs_init); 1271