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