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