drivers/pci/pci-sysfs.c

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