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