drivers/pci/proc.c

   1 /*
   2  *      $Id: proc.c,v 1.1.1.1 2005/04/11 02:50:33 jack Exp $
   3  *
   4  *      Procfs interface for the PCI bus.
   5  *
   6  *      Copyright (c) 1997--1999 Martin Mares <mj@ucw.cz>
   7  */
   8
   9 #include <linux/types.h>
  10 #include <linux/kernel.h>
  11 #include <linux/pci.h>
  12 #include <linux/proc_fs.h>
  13 #include <linux/init.h>
  14 #include <linux/seq_file.h>
  15
  16 #include <asm/uaccess.h>
  17 #include <asm/byteorder.h>
  18
  19 #define PCI_CFG_SPACE_SIZE 256
  20
  21 static loff_t
  22 proc_bus_pci_lseek(struct file *file, loff_t off, int whence)
  23 {
  24         loff_t new;
  25
  26         switch (whence) {
  27         case 0:
  28                 new = off;
  29                 break;
  30         case 1:
  31                 new = file->f_pos + off;
  32                 break;
  33         case 2:
  34                 new = PCI_CFG_SPACE_SIZE + off;
  35                 break;
  36         default:
  37                 return -EINVAL;
  38         }
  39         if (new < 0 || new > PCI_CFG_SPACE_SIZE)
  40                 return -EINVAL;
  41         return (file->f_pos = new);
  42 }
  43
  44 static ssize_t
  45 proc_bus_pci_read(struct file *file, char *buf, size_t nbytes, loff_t *ppos)
  46 {
  47         const struct inode *ino = file->f_dentry->d_inode;
  48         const struct proc_dir_entry *dp = ino->u.generic_ip;
  49         struct pci_dev *dev = dp->data;
  50         unsigned int pos = *ppos;
  51         unsigned int cnt, size;
  52
  53         /*
  54          * Normal users can read only the standardized portion of the
  55          * configuration space as several chips lock up when trying to read
  56          * undefined locations (think of Intel PIIX4 as a typical example).
  57          */
  58
  59         if (capable(CAP_SYS_ADMIN))
  60                 size = PCI_CFG_SPACE_SIZE;
  61         else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
  62                 size = 128;
  63         else
  64                 size = 64;
  65
  66         if (pos >= size)
  67                 return 0;
  68         if (nbytes >= size)
  69                 nbytes = size;
  70         if (pos + nbytes > size)
  71                 nbytes = size - pos;
  72         cnt = nbytes;
  73
  74         if (!access_ok(VERIFY_WRITE, buf, cnt))
  75                 return -EINVAL;
  76
  77         if ((pos & 1) && cnt) {
  78                 unsigned char val;
  79                 pci_read_config_byte(dev, pos, &val);
  80                 __put_user(val, buf);
  81                 buf++;
  82                 pos++;
  83                 cnt--;
  84         }
  85
  86         if ((pos & 3) && cnt > 2) {
  87                 unsigned short val;
  88                 pci_read_config_word(dev, pos, &val);
  89                 __put_user(cpu_to_le16(val), (unsigned short *) buf);
  90                 buf += 2;
  91                 pos += 2;
  92                 cnt -= 2;
  93         }
  94
  95         while (cnt >= 4) {
  96                 unsigned int val;
  97                 pci_read_config_dword(dev, pos, &val);
  98                 __put_user(cpu_to_le32(val), (unsigned int *) buf);
  99                 buf += 4;
 100                 pos += 4;
 101                 cnt -= 4;
 102         }
 103
 104         if (cnt >= 2) {
 105                 unsigned short val;
 106                 pci_read_config_word(dev, pos, &val);
 107                 __put_user(cpu_to_le16(val), (unsigned short *) buf);
 108                 buf += 2;
 109                 pos += 2;
 110                 cnt -= 2;
 111         }
 112
 113         if (cnt) {
 114                 unsigned char val;
 115                 pci_read_config_byte(dev, pos, &val);
 116                 __put_user(val, buf);
 117                 buf++;
 118                 pos++;
 119                 cnt--;
 120         }
 121
 122         *ppos = pos;
 123         return nbytes;
 124 }
 125
 126 static ssize_t
 127 proc_bus_pci_write(struct file *file, const char *buf, size_t nbytes, loff_t *ppos)
 128 {
 129         const struct inode *ino = file->f_dentry->d_inode;
 130         const struct proc_dir_entry *dp = ino->u.generic_ip;
 131         struct pci_dev *dev = dp->data;
 132         int pos = *ppos;
 133         int cnt;
 134
 135         if (pos >= PCI_CFG_SPACE_SIZE)
 136                 return 0;
 137         if (nbytes >= PCI_CFG_SPACE_SIZE)
 138                 nbytes = PCI_CFG_SPACE_SIZE;
 139         if (pos + nbytes > PCI_CFG_SPACE_SIZE)
 140                 nbytes = PCI_CFG_SPACE_SIZE - pos;
 141         cnt = nbytes;
 142
 143         if (!access_ok(VERIFY_READ, buf, cnt))
 144                 return -EINVAL;
 145
 146         if ((pos & 1) && cnt) {
 147                 unsigned char val;
 148                 __get_user(val, buf);
 149                 pci_write_config_byte(dev, pos, val);
 150                 buf++;
 151                 pos++;
 152                 cnt--;
 153         }
 154
 155         if ((pos & 3) && cnt > 2) {
 156                 unsigned short val;
 157                 __get_user(val, (unsigned short *) buf);
 158                 pci_write_config_word(dev, pos, le16_to_cpu(val));
 159                 buf += 2;
 160                 pos += 2;
 161                 cnt -= 2;
 162         }
 163
 164         while (cnt >= 4) {
 165                 unsigned int val;
 166                 __get_user(val, (unsigned int *) buf);
 167                 pci_write_config_dword(dev, pos, le32_to_cpu(val));
 168                 buf += 4;
 169                 pos += 4;
 170                 cnt -= 4;
 171         }
 172
 173         if (cnt >= 2) {
 174                 unsigned short val;
 175                 __get_user(val, (unsigned short *) buf);
 176                 pci_write_config_word(dev, pos, le16_to_cpu(val));
 177                 buf += 2;
 178                 pos += 2;
 179                 cnt -= 2;
 180         }
 181
 182         if (cnt) {
 183                 unsigned char val;
 184                 __get_user(val, buf);
 185                 pci_write_config_byte(dev, pos, val);
 186                 buf++;
 187                 pos++;
 188                 cnt--;
 189         }
 190
 191         *ppos = pos;
 192         return nbytes;
 193 }
 194
 195 struct pci_filp_private {
 196         enum pci_mmap_state mmap_state;
 197         int write_combine;
 198 };
 199
 200 static int proc_bus_pci_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 201 {
 202         const struct proc_dir_entry *dp = inode->u.generic_ip;
 203         struct pci_dev *dev = dp->data;
 204 #ifdef HAVE_PCI_MMAP
 205         struct pci_filp_private *fpriv = file->private_data;
 206 #endif /* HAVE_PCI_MMAP */
 207         int ret = 0;
 208
 209         switch (cmd) {
 210         case PCIIOC_CONTROLLER:
 211                 ret = pci_controller_num(dev);
 212                 break;
 213
 214 #ifdef HAVE_PCI_MMAP
 215         case PCIIOC_MMAP_IS_IO:
 216                 fpriv->mmap_state = pci_mmap_io;
 217                 break;
 218
 219         case PCIIOC_MMAP_IS_MEM:
 220                 fpriv->mmap_state = pci_mmap_mem;
 221                 break;
 222
 223         case PCIIOC_WRITE_COMBINE:
 224                 if (arg)
 225                         fpriv->write_combine = 1;
 226                 else
 227                         fpriv->write_combine = 0;
 228                 break;
 229
 230 #endif /* HAVE_PCI_MMAP */
 231
 232         default:
 233                 ret = -EINVAL;
 234                 break;
 235         };
 236
 237         return ret;
 238 }
 239
 240 #ifdef HAVE_PCI_MMAP
 241 static int proc_bus_pci_mmap(struct file *file, struct vm_area_struct *vma)
 242 {
 243         struct inode *inode = file->f_dentry->d_inode;
 244         const struct proc_dir_entry *dp = inode->u.generic_ip;
 245         struct pci_dev *dev = dp->data;
 246         struct pci_filp_private *fpriv = file->private_data;
 247         int ret;
 248
 249         if (!capable(CAP_SYS_RAWIO))
 250                 return -EPERM;
 251
 252         ret = pci_mmap_page_range(dev, vma,
 253                                   fpriv->mmap_state,
 254                                   fpriv->write_combine);
 255         if (ret < 0)
 256                 return ret;
 257
 258         return 0;
 259 }
 260
 261 static int proc_bus_pci_open(struct inode *inode, struct file *file)
 262 {
 263         struct pci_filp_private *fpriv = kmalloc(sizeof(*fpriv), GFP_KERNEL);
 264
 265         if (!fpriv)
 266                 return -ENOMEM;
 267
 268         fpriv->mmap_state = pci_mmap_io;
 269         fpriv->write_combine = 0;
 270
 271         file->private_data = fpriv;
 272
 273         return 0;
 274 }
 275
 276 static int proc_bus_pci_release(struct inode *inode, struct file *file)
 277 {
 278         kfree(file->private_data);
 279         file->private_data = NULL;
 280
 281         return 0;
 282 }
 283 #endif /* HAVE_PCI_MMAP */
 284
 285 static struct file_operations proc_bus_pci_operations = {
 286         llseek:         proc_bus_pci_lseek,
 287         read:           proc_bus_pci_read,
 288         write:          proc_bus_pci_write,
 289         ioctl:          proc_bus_pci_ioctl,
 290 #ifdef HAVE_PCI_MMAP
 291         open:           proc_bus_pci_open,
 292         release:        proc_bus_pci_release,
 293         mmap:           proc_bus_pci_mmap,
 294 #ifdef HAVE_ARCH_PCI_GET_UNMAPPED_AREA
 295         get_unmapped_area: get_pci_unmapped_area,
 296 #endif /* HAVE_ARCH_PCI_GET_UNMAPPED_AREA */
 297 #endif /* HAVE_PCI_MMAP */
 298 };
 299
 300 #if BITS_PER_LONG == 32
 301 #define LONG_FORMAT "\t%08lx"
 302 #else
 303 #define LONG_FORMAT "\t%16lx"
 304 #endif
 305
 306 /* iterator */
 307 static void *pci_seq_start(struct seq_file *m, loff_t *pos)
 308 {
 309         struct list_head *p = &pci_devices;
 310         loff_t n = *pos;
 311
 312         /* XXX: surely we need some locking for traversing the list? */
 313         while (n--) {
 314                 p = p->next;
 315                 if (p == &pci_devices)
 316                         return NULL;
 317         }
 318         return p;
 319 }
 320 static void *pci_seq_next(struct seq_file *m, void *v, loff_t *pos)
 321 {
 322         struct list_head *p = v;
 323         (*pos)++;
 324         return p->next != &pci_devices ? p->next : NULL;
 325 }
 326 static void pci_seq_stop(struct seq_file *m, void *v)
 327 {
 328         /* release whatever locks we need */
 329 }
 330
 331 static int show_device(struct seq_file *m, void *v)
 332 {
 333         struct list_head *p = v;
 334         const struct pci_dev *dev;
 335         const struct pci_driver *drv;
 336         int i;
 337
 338         if (p == &pci_devices)
 339                 return 0;
 340
 341         dev = pci_dev_g(p);
 342         drv = pci_dev_driver(dev);
 343         seq_printf(m, "%02x%02x\t%04x%04x\t%x",
 344                         dev->bus->number,
 345                         dev->devfn,
 346                         dev->vendor,
 347                         dev->device,
 348                         dev->irq);
 349         /* Here should be 7 and not PCI_NUM_RESOURCES as we need to preserve compatibility */
 350         for(i=0; i<7; i++)
 351                 seq_printf(m, LONG_FORMAT,
 352                         dev->resource[i].start |
 353                         (dev->resource[i].flags & PCI_REGION_FLAG_MASK));
 354         for(i=0; i<7; i++)
 355                 seq_printf(m, LONG_FORMAT,
 356                         dev->resource[i].start < dev->resource[i].end ?
 357                         dev->resource[i].end - dev->resource[i].start + 1 : 0);
 358         seq_putc(m, '\t');
 359         if (drv)
 360                 seq_printf(m, "%s", drv->name);
 361         seq_putc(m, '\n');
 362         return 0;
 363 }
 364
 365 static struct seq_operations proc_bus_pci_devices_op = {
 366         start:  pci_seq_start,
 367         next:   pci_seq_next,
 368         stop:   pci_seq_stop,
 369         show:   show_device
 370 };
 371
 372 struct proc_dir_entry *proc_bus_pci_dir;
 373
 374 int pci_proc_attach_device(struct pci_dev *dev)
 375 {
 376         struct pci_bus *bus = dev->bus;
 377         struct proc_dir_entry *de, *e;
 378         char name[16];
 379
 380         if (!(de = bus->procdir)) {
 381                 sprintf(name, "%02x", bus->number);
 382                 de = bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
 383                 if (!de)
 384                         return -ENOMEM;
 385         }
 386         sprintf(name, "%02x.%x", PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
 387         e = dev->procent = create_proc_entry(name, S_IFREG | S_IRUGO | S_IWUSR, de);
 388         if (!e)
 389                 return -ENOMEM;
 390         e->proc_fops = &proc_bus_pci_operations;
 391         e->data = dev;
 392         e->size = PCI_CFG_SPACE_SIZE;
 393         return 0;
 394 }
 395
 396 int pci_proc_detach_device(struct pci_dev *dev)
 397 {
 398         struct proc_dir_entry *e;
 399
 400         if ((e = dev->procent)) {
 401                 if (atomic_read(&e->count))
 402                         return -EBUSY;
 403                 remove_proc_entry(e->name, dev->bus->procdir);
 404                 dev->procent = NULL;
 405         }
 406         return 0;
 407 }
 408
 409 int pci_proc_attach_bus(struct pci_bus* bus)
 410 {
 411         struct proc_dir_entry *de = bus->procdir;
 412
 413         if (!de) {
 414                 char name[16];
 415                 sprintf(name, "%02x", bus->number);
 416                 de = bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
 417                 if (!de)
 418                         return -ENOMEM;
 419         }
 420         return 0;
 421 }
 422
 423 int pci_proc_detach_bus(struct pci_bus* bus)
 424 {
 425         struct proc_dir_entry *de = bus->procdir;
 426         if (de)
 427                 remove_proc_entry(de->name, proc_bus_pci_dir);
 428         return 0;
 429 }
 430
 431
 432 /*
 433  *  Backward compatible /proc/pci interface.
 434  */
 435
 436 /*
 437  * Convert some of the configuration space registers of the device at
 438  * address (bus,devfn) into a string (possibly several lines each).
 439  * The configuration string is stored starting at buf[len].  If the
 440  * string would exceed the size of the buffer (SIZE), 0 is returned.
 441  */
 442 static int show_dev_config(struct seq_file *m, void *v)
 443 {
 444         struct list_head *p = v;
 445         struct pci_dev *dev;
 446         struct pci_driver *drv;
 447         u32 class_rev;
 448         unsigned char latency, min_gnt, max_lat, *class;
 449         int reg;
 450
 451         if (p == &pci_devices) {
 452                 seq_puts(m, "PCI devices found:\n");
 453                 return 0;
 454         }
 455
 456         dev = pci_dev_g(p);
 457         drv = pci_dev_driver(dev);
 458
 459         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
 460         pci_read_config_byte (dev, PCI_LATENCY_TIMER, &latency);
 461         pci_read_config_byte (dev, PCI_MIN_GNT, &min_gnt);
 462         pci_read_config_byte (dev, PCI_MAX_LAT, &max_lat);
 463         seq_printf(m, "  Bus %2d, device %3d, function %2d:\n",
 464                dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
 465         class = pci_class_name(class_rev >> 16);
 466         if (class)
 467                 seq_printf(m, "    %s", class);
 468         else
 469                 seq_printf(m, "    Class %04x", class_rev >> 16);
 470         seq_printf(m, ": %s (rev %d).\n", dev->name, class_rev & 0xff);
 471
 472         //if (dev->irq)         //+Bing modified 01122005
 473                 seq_printf(m, "      IRQ %d.\n", dev->irq);
 474
 475         if (latency || min_gnt || max_lat) {
 476                 seq_printf(m, "      Master Capable.  ");
 477                 if (latency)
 478                         seq_printf(m, "Latency=%d.  ", latency);
 479                 else
 480                         seq_puts(m, "No bursts.  ");
 481                 if (min_gnt)
 482                         seq_printf(m, "Min Gnt=%d.", min_gnt);
 483                 if (max_lat)
 484                         seq_printf(m, "Max Lat=%d.", max_lat);
 485                 seq_putc(m, '\n');
 486         }
 487
 488         for (reg = 0; reg < 6; reg++) {
 489                 struct resource *res = dev->resource + reg;
 490                 unsigned long base, end, flags;
 491
 492                 base = res->start;
 493                 end = res->end;
 494                 flags = res->flags;
 495                 if (!end)
 496                         continue;
 497
 498                 if (flags & PCI_BASE_ADDRESS_SPACE_IO) {
 499                         seq_printf(m, "      I/O at 0x%lx [0x%lx].\n",
 500                                 base, end);
 501                 } else {
 502                         const char *pref, *type = "unknown";
 503
 504                         if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
 505                                 pref = "P";
 506                         else
 507                                 pref = "Non-p";
 508                         switch (flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK) {
 509                               case PCI_BASE_ADDRESS_MEM_TYPE_32:
 510                                 type = "32 bit"; break;
 511                               case PCI_BASE_ADDRESS_MEM_TYPE_1M:
 512                                 type = "20 bit"; break;
 513                               case PCI_BASE_ADDRESS_MEM_TYPE_64:
 514                                 type = "64 bit"; break;
 515                         }
 516                         seq_printf(m, "      %srefetchable %s memory at "
 517                                        "0x%lx [0x%lx].\n", pref, type,
 518                                        base,
 519                                        end);
 520                 }
 521         }
 522         return 0;
 523 }
 524
 525 static struct seq_operations proc_pci_op = {
 526         start:  pci_seq_start,
 527         next:   pci_seq_next,
 528         stop:   pci_seq_stop,
 529         show:   show_dev_config
 530 };
 531
 532 static int proc_bus_pci_dev_open(struct inode *inode, struct file *file)
 533 {
 534         return seq_open(file, &proc_bus_pci_devices_op);
 535 }
 536 static struct file_operations proc_bus_pci_dev_operations = {
 537         open:           proc_bus_pci_dev_open,
 538         read:           seq_read,
 539         llseek:         seq_lseek,
 540         release:        seq_release,
 541 };
 542 static int proc_pci_open(struct inode *inode, struct file *file)
 543 {
 544         return seq_open(file, &proc_pci_op);
 545 }
 546 static struct file_operations proc_pci_operations = {
 547         open:           proc_pci_open,
 548         read:           seq_read,
 549         llseek:         seq_lseek,
 550         release:        seq_release,
 551 };
 552
 553 static int __init pci_proc_init(void)
 554 {
 555         if (pci_present()) {
 556                 struct proc_dir_entry *entry;
 557                 struct pci_dev *dev;
 558                 proc_bus_pci_dir = proc_mkdir("pci", proc_bus);
 559                 entry = create_proc_entry("devices", 0, proc_bus_pci_dir);
 560                 if (entry)
 561                         entry->proc_fops = &proc_bus_pci_dev_operations;
 562                 pci_for_each_dev(dev) {
 563                         pci_proc_attach_device(dev);
 564                 }
 565                 entry = create_proc_entry("pci", 0, NULL);
 566                 if (entry)
 567                         entry->proc_fops = &proc_pci_operations;
 568         }
 569         return 0;
 570 }
 571
 572 __initcall(pci_proc_init);