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                   enum pci_mmap_api mmap_api)
 710 {
 711         unsigned long nr, start, size, pci_start;
 712
 713         if (pci_resource_len(pdev, resno) == 0)
 714                 return 0;
 715         nr = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
 716         start = vma->vm_pgoff;
 717         size = ((pci_resource_len(pdev, resno) - 1) >> PAGE_SHIFT) + 1;
 718         pci_start = (mmap_api == PCI_MMAP_PROCFS) ?
 719                         pci_resource_start(pdev, resno) >> PAGE_SHIFT : 0;
 720         if (start >= pci_start && start < pci_start + size &&
 721                         start + nr <= pci_start + size)
 722                 return 1;
 723         return 0;
 724 }
 725
 726 /**
 727  * pci_mmap_resource - map a PCI resource into user memory space
 728  * @kobj: kobject for mapping
 729  * @attr: struct bin_attribute for the file being mapped
 730  * @vma: struct vm_area_struct passed into the mmap
 731  * @write_combine: 1 for write_combine mapping
 732  *
 733  * Use the regular PCI mapping routines to map a PCI resource into userspace.
 734  */
 735 static int
 736 pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,
 737                   struct vm_area_struct *vma, int write_combine)
 738 {
 739         struct pci_dev *pdev = to_pci_dev(container_of(kobj,
 740                                                        struct device, kobj));
 741         struct resource *res = (struct resource *)attr->private;
 742         enum pci_mmap_state mmap_type;
 743         resource_size_t start, end;
 744         int i;
 745
 746         for (i = 0; i < PCI_ROM_RESOURCE; i++)
 747                 if (res == &pdev->resource[i])
 748                         break;
 749         if (i >= PCI_ROM_RESOURCE)
 750                 return -ENODEV;
 751
 752         if (!pci_mmap_fits(pdev, i, vma, PCI_MMAP_SYSFS)) {
 753                 WARN(1, "process \"%s\" tried to map 0x%08lx bytes "
 754                         "at page 0x%08lx on %s BAR %d (start 0x%16Lx, size 0x%16Lx)\n",
 755                         current->comm, vma->vm_end-vma->vm_start, vma->vm_pgoff,
 756                         pci_name(pdev), i,
 757                         pci_resource_start(pdev, i), pci_resource_len(pdev, i));
 758                 return -EINVAL;
 759         }
 760
 761         /* pci_mmap_page_range() expects the same kind of entry as coming
 762          * from /proc/bus/pci/ which is a "user visible" value. If this is
 763          * different from the resource itself, arch will do necessary fixup.
 764          */
 765         pci_resource_to_user(pdev, i, res, &start, &end);
 766         vma->vm_pgoff += start >> PAGE_SHIFT;
 767         mmap_type = res->flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io;
 768
 769         if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(start))
 770                 return -EINVAL;
 771
 772         return pci_mmap_page_range(pdev, vma, mmap_type, write_combine);
 773 }
 774
 775 static int
 776 pci_mmap_resource_uc(struct file *filp, struct kobject *kobj,
 777                      struct bin_attribute *attr,
 778                      struct vm_area_struct *vma)
 779 {
 780         return pci_mmap_resource(kobj, attr, vma, 0);
 781 }
 782
 783 static int
 784 pci_mmap_resource_wc(struct file *filp, struct kobject *kobj,
 785                      struct bin_attribute *attr,
 786                      struct vm_area_struct *vma)
 787 {
 788         return pci_mmap_resource(kobj, attr, vma, 1);
 789 }
 790
 791 /**
 792  * pci_remove_resource_files - cleanup resource files
 793  * @pdev: dev to cleanup
 794  *
 795  * If we created resource files for @pdev, remove them from sysfs and
 796  * free their resources.
 797  */
 798 static void
 799 pci_remove_resource_files(struct pci_dev *pdev)
 800 {
 801         int i;
 802
 803         for (i = 0; i < PCI_ROM_RESOURCE; i++) {
 804                 struct bin_attribute *res_attr;
 805
 806                 res_attr = pdev->res_attr[i];
 807                 if (res_attr) {
 808                         sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
 809                         kfree(res_attr);
 810                 }
 811
 812                 res_attr = pdev->res_attr_wc[i];
 813                 if (res_attr) {
 814                         sysfs_remove_bin_file(&pdev->dev.kobj, res_attr);
 815                         kfree(res_attr);
 816                 }
 817         }
 818 }
 819
 820 static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine)
 821 {
 822         /* allocate attribute structure, piggyback attribute name */
 823         int name_len = write_combine ? 13 : 10;
 824         struct bin_attribute *res_attr;
 825         int retval;
 826
 827         res_attr = kzalloc(sizeof(*res_attr) + name_len, GFP_ATOMIC);
 828         if (res_attr) {
 829                 char *res_attr_name = (char *)(res_attr + 1);
 830
 831                 sysfs_bin_attr_init(res_attr);
 832                 if (write_combine) {
 833                         pdev->res_attr_wc[num] = res_attr;
 834                         sprintf(res_attr_name, "resource%d_wc", num);
 835                         res_attr->mmap = pci_mmap_resource_wc;
 836                 } else {
 837                         pdev->res_attr[num] = res_attr;
 838                         sprintf(res_attr_name, "resource%d", num);
 839                         res_attr->mmap = pci_mmap_resource_uc;
 840                 }
 841                 res_attr->attr.name = res_attr_name;
 842                 res_attr->attr.mode = S_IRUSR | S_IWUSR;
 843                 res_attr->size = pci_resource_len(pdev, num);
 844                 res_attr->private = &pdev->resource[num];
 845                 retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr);
 846         } else
 847                 retval = -ENOMEM;
 848
 849         return retval;
 850 }
 851
 852 /**
 853  * pci_create_resource_files - create resource files in sysfs for @dev
 854  * @pdev: dev in question
 855  *
 856  * Walk the resources in @pdev creating files for each resource available.
 857  */
 858 static int pci_create_resource_files(struct pci_dev *pdev)
 859 {
 860         int i;
 861         int retval;
 862
 863         /* Expose the PCI resources from this device as files */
 864         for (i = 0; i < PCI_ROM_RESOURCE; i++) {
 865
 866                 /* skip empty resources */
 867                 if (!pci_resource_len(pdev, i))
 868                         continue;
 869
 870                 retval = pci_create_attr(pdev, i, 0);
 871                 /* for prefetchable resources, create a WC mappable file */
 872                 if (!retval && pdev->resource[i].flags & IORESOURCE_PREFETCH)
 873                         retval = pci_create_attr(pdev, i, 1);
 874
 875                 if (retval) {
 876                         pci_remove_resource_files(pdev);
 877                         return retval;
 878                 }
 879         }
 880         return 0;
 881 }
 882 #else /* !HAVE_PCI_MMAP */
 883 int __weak pci_create_resource_files(struct pci_dev *dev) { return 0; }
 884 void __weak pci_remove_resource_files(struct pci_dev *dev) { return; }
 885 #endif /* HAVE_PCI_MMAP */
 886
 887 /**
 888  * pci_write_rom - used to enable access to the PCI ROM display
 889  * @filp: sysfs file
 890  * @kobj: kernel object handle
 891  * @bin_attr: struct bin_attribute for this file
 892  * @buf: user input
 893  * @off: file offset
 894  * @count: number of byte in input
 895  *
 896  * writing anything except 0 enables it
 897  */
 898 static ssize_t
 899 pci_write_rom(struct file *filp, struct kobject *kobj,
 900               struct bin_attribute *bin_attr,
 901               char *buf, loff_t off, size_t count)
 902 {
 903         struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj));
 904
 905         if ((off ==  0) && (*buf == '0') && (count == 2))
 906                 pdev->rom_attr_enabled = 0;
 907         else
 908                 pdev->rom_attr_enabled = 1;
 909
 910         return count;
 911 }
 912
 913 /**
 914  * pci_read_rom - read a PCI ROM
 915  * @filp: sysfs file
 916  * @kobj: kernel object handle
 917  * @bin_attr: struct bin_attribute for this file
 918  * @buf: where to put the data we read from the ROM
 919  * @off: file offset
 920  * @count: number of bytes to read
 921  *
 922  * Put @count bytes starting at @off into @buf from the ROM in the PCI
 923  * device corresponding to @kobj.
 924  */
 925 static ssize_t
 926 pci_read_rom(struct file *filp, struct kobject *kobj,
 927              struct bin_attribute *bin_attr,
 928              char *buf, loff_t off, size_t count)
 929 {
 930         struct pci_dev *pdev = to_pci_dev(container_of(kobj, struct device, kobj));
 931         void __iomem *rom;
 932         size_t size;
 933
 934         if (!pdev->rom_attr_enabled)
 935                 return -EINVAL;
 936
 937         rom = pci_map_rom(pdev, &size); /* size starts out as PCI window size */
 938         if (!rom || !size)
 939                 return -EIO;
 940
 941         if (off >= size)
 942                 count = 0;
 943         else {
 944                 if (off + count > size)
 945                         count = size - off;
 946
 947                 memcpy_fromio(buf, rom + off, count);
 948         }
 949         pci_unmap_rom(pdev, rom);
 950
 951         return count;
 952 }
 953
 954 static struct bin_attribute pci_config_attr = {
 955         .attr = {
 956                 .name = "config",
 957                 .mode = S_IRUGO | S_IWUSR,
 958         },
 959         .size = PCI_CFG_SPACE_SIZE,
 960         .read = pci_read_config,
 961         .write = pci_write_config,
 962 };
 963
 964 static struct bin_attribute pcie_config_attr = {
 965         .attr = {
 966                 .name = "config",
 967                 .mode = S_IRUGO | S_IWUSR,
 968         },
 969         .size = PCI_CFG_SPACE_EXP_SIZE,
 970         .read = pci_read_config,
 971         .write = pci_write_config,
 972 };
 973
 974 int __attribute__ ((weak)) pcibios_add_platform_entries(struct pci_dev *dev)
 975 {
 976         return 0;
 977 }
 978
 979 static ssize_t reset_store(struct device *dev,
 980                            struct device_attribute *attr, const char *buf,
 981                            size_t count)
 982 {
 983         struct pci_dev *pdev = to_pci_dev(dev);
 984         unsigned long val;
 985         ssize_t result = strict_strtoul(buf, 0, &val);
 986
 987         if (result < 0)
 988                 return result;
 989
 990         if (val != 1)
 991                 return -EINVAL;
 992
 993         result = pci_reset_function(pdev);
 994         if (result < 0)
 995                 return result;
 996
 997         return count;
 998 }
 999
1000 static struct device_attribute reset_attr = __ATTR(reset, 0200, NULL, reset_store);
1001
1002 static int pci_create_capabilities_sysfs(struct pci_dev *dev)
1003 {
1004         int retval;
1005         struct bin_attribute *attr;
1006
1007         /* If the device has VPD, try to expose it in sysfs. */
1008         if (dev->vpd) {
1009                 attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
1010                 if (!attr)
1011                         return -ENOMEM;
1012
1013                 sysfs_bin_attr_init(attr);
1014                 attr->size = dev->vpd->len;
1015                 attr->attr.name = "vpd";
1016                 attr->attr.mode = S_IRUSR | S_IWUSR;
1017                 attr->read = read_vpd_attr;
1018                 attr->write = write_vpd_attr;
1019                 retval = sysfs_create_bin_file(&dev->dev.kobj, attr);
1020                 if (retval) {
1021                         kfree(attr);
1022                         return retval;
1023                 }
1024                 dev->vpd->attr = attr;
1025         }
1026
1027         /* Active State Power Management */
1028         pcie_aspm_create_sysfs_dev_files(dev);
1029
1030         if (!pci_probe_reset_function(dev)) {
1031                 retval = device_create_file(&dev->dev, &reset_attr);
1032                 if (retval)
1033                         goto error;
1034                 dev->reset_fn = 1;
1035         }
1036         return 0;
1037
1038 error:
1039         pcie_aspm_remove_sysfs_dev_files(dev);
1040         if (dev->vpd && dev->vpd->attr) {
1041                 sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr);
1042                 kfree(dev->vpd->attr);
1043         }
1044
1045         return retval;
1046 }
1047
1048 int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
1049 {
1050         int retval;
1051         int rom_size = 0;
1052         struct bin_attribute *attr;
1053
1054         if (!sysfs_initialized)
1055                 return -EACCES;
1056
1057         if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
1058                 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr);
1059         else
1060                 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr);
1061         if (retval)
1062                 goto err;
1063
1064         retval = pci_create_resource_files(pdev);
1065         if (retval)
1066                 goto err_config_file;
1067
1068         if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
1069                 rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
1070         else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
1071                 rom_size = 0x20000;
1072
1073         /* If the device has a ROM, try to expose it in sysfs. */
1074         if (rom_size) {
1075                 attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
1076                 if (!attr) {
1077                         retval = -ENOMEM;
1078                         goto err_resource_files;
1079                 }
1080                 sysfs_bin_attr_init(attr);
1081                 attr->size = rom_size;
1082                 attr->attr.name = "rom";
1083                 attr->attr.mode = S_IRUSR;
1084                 attr->read = pci_read_rom;
1085                 attr->write = pci_write_rom;
1086                 retval = sysfs_create_bin_file(&pdev->dev.kobj, attr);
1087                 if (retval) {
1088                         kfree(attr);
1089                         goto err_resource_files;
1090                 }
1091                 pdev->rom_attr = attr;
1092         }
1093
1094         if ((pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA) {
1095                 retval = device_create_file(&pdev->dev, &vga_attr);
1096                 if (retval)
1097                         goto err_rom_file;
1098         }
1099
1100         /* add platform-specific attributes */
1101         retval = pcibios_add_platform_entries(pdev);
1102         if (retval)
1103                 goto err_vga_file;
1104
1105         /* add sysfs entries for various capabilities */
1106         retval = pci_create_capabilities_sysfs(pdev);
1107         if (retval)
1108                 goto err_vga_file;
1109
1110         return 0;
1111
1112 err_vga_file:
1113         if ((pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
1114                 device_remove_file(&pdev->dev, &vga_attr);
1115 err_rom_file:
1116         if (rom_size) {
1117                 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
1118                 kfree(pdev->rom_attr);
1119                 pdev->rom_attr = NULL;
1120         }
1121 err_resource_files:
1122         pci_remove_resource_files(pdev);
1123 err_config_file:
1124         if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
1125                 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
1126         else
1127                 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
1128 err:
1129         return retval;
1130 }
1131
1132 static void pci_remove_capabilities_sysfs(struct pci_dev *dev)
1133 {
1134         if (dev->vpd && dev->vpd->attr) {
1135                 sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr);
1136                 kfree(dev->vpd->attr);
1137         }
1138
1139         pcie_aspm_remove_sysfs_dev_files(dev);
1140         if (dev->reset_fn) {
1141                 device_remove_file(&dev->dev, &reset_attr);
1142                 dev->reset_fn = 0;
1143         }
1144 }
1145
1146 /**
1147  * pci_remove_sysfs_dev_files - cleanup PCI specific sysfs files
1148  * @pdev: device whose entries we should free
1149  *
1150  * Cleanup when @pdev is removed from sysfs.
1151  */
1152 void pci_remove_sysfs_dev_files(struct pci_dev *pdev)
1153 {
1154         int rom_size = 0;
1155
1156         if (!sysfs_initialized)
1157                 return;
1158
1159         pci_remove_capabilities_sysfs(pdev);
1160
1161         if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
1162                 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
1163         else
1164                 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
1165
1166         pci_remove_resource_files(pdev);
1167
1168         if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
1169                 rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
1170         else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
1171                 rom_size = 0x20000;
1172
1173         if (rom_size && pdev->rom_attr) {
1174                 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
1175                 kfree(pdev->rom_attr);
1176         }
1177 }
1178
1179 static int __init pci_sysfs_init(void)
1180 {
1181         struct pci_dev *pdev = NULL;
1182         int retval;
1183
1184         sysfs_initialized = 1;
1185         for_each_pci_dev(pdev) {
1186                 retval = pci_create_sysfs_dev_files(pdev);
1187                 if (retval) {
1188                         pci_dev_put(pdev);
1189                         return retval;
1190                 }
1191         }
1192
1193         return 0;
1194 }
1195
1196 late_initcall(pci_sysfs_init);