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