drivers/pci/proc.c

   1 /*
   2  *      $Id: proc.c,v 1.13 1998/05/12 07:36:07 mj Exp $
   3  *
   4  *      Procfs interface for the PCI bus.
   5  *
   6  *      Copyright (c) 1997--1999 Martin Mares <mj@suse.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
  15 #include <asm/uaccess.h>
  16 #include <asm/byteorder.h>
  17
  18 #define PCI_CFG_SPACE_SIZE 256
  19
  20 static loff_t
  21 proc_bus_pci_lseek(struct file *file, loff_t off, int whence)
  22 {
  23         loff_t new;
  24
  25         switch (whence) {
  26         case 0:
  27                 new = off;
  28                 break;
  29         case 1:
  30                 new = file->f_pos + off;
  31                 break;
  32         case 2:
  33                 new = PCI_CFG_SPACE_SIZE + off;
  34                 break;
  35         default:
  36                 return -EINVAL;
  37         }
  38         if (new < 0 || new > PCI_CFG_SPACE_SIZE)
  39                 return -EINVAL;
  40         return (file->f_pos = new);
  41 }
  42
  43 static ssize_t
  44 proc_bus_pci_read(struct file *file, char *buf, size_t nbytes, loff_t *ppos)
  45 {
  46         const struct inode *ino = file->f_dentry->d_inode;
  47         const struct proc_dir_entry *dp = ino->u.generic_ip;
  48         struct pci_dev *dev = dp->data;
  49         unsigned int pos = *ppos;
  50         unsigned int cnt, size;
  51
  52         /*
  53          * Normal users can read only the standardized portion of the
  54          * configuration space as several chips lock up when trying to read
  55          * undefined locations (think of Intel PIIX4 as a typical example).
  56          */
  57
  58         if (capable(CAP_SYS_ADMIN))
  59                 size = PCI_CFG_SPACE_SIZE;
  60         else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
  61                 size = 128;
  62         else
  63                 size = 64;
  64
  65         if (pos >= size)
  66                 return 0;
  67         if (nbytes >= size)
  68                 nbytes = size;
  69         if (pos + nbytes > size)
  70                 nbytes = size - pos;
  71         cnt = nbytes;
  72
  73         if (!access_ok(VERIFY_WRITE, buf, cnt))
  74                 return -EINVAL;
  75
  76         if ((pos & 1) && cnt) {
  77                 unsigned char val;
  78                 pci_read_config_byte(dev, pos, &val);
  79                 __put_user(val, buf);
  80                 buf++;
  81                 pos++;
  82                 cnt--;
  83         }
  84
  85         if ((pos & 3) && cnt > 2) {
  86                 unsigned short val;
  87                 pci_read_config_word(dev, pos, &val);
  88                 __put_user(cpu_to_le16(val), (unsigned short *) buf);
  89                 buf += 2;
  90                 pos += 2;
  91                 cnt -= 2;
  92         }
  93
  94         while (cnt >= 4) {
  95                 unsigned int val;
  96                 pci_read_config_dword(dev, pos, &val);
  97                 __put_user(cpu_to_le32(val), (unsigned int *) buf);
  98                 buf += 4;
  99                 pos += 4;
 100                 cnt -= 4;
 101         }
 102
 103         if (cnt >= 2) {
 104                 unsigned short val;
 105                 pci_read_config_word(dev, pos, &val);
 106                 __put_user(cpu_to_le16(val), (unsigned short *) buf);
 107                 buf += 2;
 108                 pos += 2;
 109                 cnt -= 2;
 110         }
 111
 112         if (cnt) {
 113                 unsigned char val;
 114                 pci_read_config_byte(dev, pos, &val);
 115                 __put_user(val, buf);
 116                 buf++;
 117                 pos++;
 118                 cnt--;
 119         }
 120
 121         *ppos = pos;
 122         return nbytes;
 123 }
 124
 125 static ssize_t
 126 proc_bus_pci_write(struct file *file, const char *buf, size_t nbytes, loff_t *ppos)
 127 {
 128         const struct inode *ino = file->f_dentry->d_inode;
 129         const struct proc_dir_entry *dp = ino->u.generic_ip;
 130         struct pci_dev *dev = dp->data;
 131         int pos = *ppos;
 132         int cnt;
 133
 134         if (pos >= PCI_CFG_SPACE_SIZE)
 135                 return 0;
 136         if (nbytes >= PCI_CFG_SPACE_SIZE)
 137                 nbytes = PCI_CFG_SPACE_SIZE;
 138         if (pos + nbytes > PCI_CFG_SPACE_SIZE)
 139                 nbytes = PCI_CFG_SPACE_SIZE - pos;
 140         cnt = nbytes;
 141
 142         if (!access_ok(VERIFY_READ, buf, cnt))
 143                 return -EINVAL;
 144
 145         if ((pos & 1) && cnt) {
 146                 unsigned char val;
 147                 __get_user(val, buf);
 148                 pci_write_config_byte(dev, pos, val);
 149                 buf++;
 150                 pos++;
 151                 cnt--;
 152         }
 153
 154         if ((pos & 3) && cnt > 2) {
 155                 unsigned short val;
 156                 __get_user(val, (unsigned short *) buf);
 157                 pci_write_config_word(dev, pos, le16_to_cpu(val));
 158                 buf += 2;
 159                 pos += 2;
 160                 cnt -= 2;
 161         }
 162
 163         while (cnt >= 4) {
 164                 unsigned int val;
 165                 __get_user(val, (unsigned int *) buf);
 166                 pci_write_config_dword(dev, pos, le32_to_cpu(val));
 167                 buf += 4;
 168                 pos += 4;
 169                 cnt -= 4;
 170         }
 171
 172         if (cnt >= 2) {
 173                 unsigned short val;
 174                 __get_user(val, (unsigned short *) buf);
 175                 pci_write_config_word(dev, pos, le16_to_cpu(val));
 176                 buf += 2;
 177                 pos += 2;
 178                 cnt -= 2;
 179         }
 180
 181         if (cnt) {
 182                 unsigned char val;
 183                 __get_user(val, buf);
 184                 pci_write_config_byte(dev, pos, val);
 185                 buf++;
 186                 pos++;
 187                 cnt--;
 188         }
 189
 190         *ppos = pos;
 191         return nbytes;
 192 }
 193
 194 static struct file_operations proc_bus_pci_operations = {
 195         llseek: proc_bus_pci_lseek,
 196         read:   proc_bus_pci_read,
 197         write:  proc_bus_pci_write,
 198 };
 199
 200 #if BITS_PER_LONG == 32
 201 #define LONG_FORMAT "\t%08lx"
 202 #else
 203 #define LONG_FORMAT "\t%16lx"
 204 #endif
 205
 206 static int
 207 get_pci_dev_info(char *buf, char **start, off_t pos, int count)
 208 {
 209         const struct pci_dev *dev;
 210         off_t at = 0;
 211         int len, i, cnt;
 212
 213         cnt = 0;
 214         pci_for_each_dev(dev) {
 215                 const struct pci_driver *drv = pci_dev_driver(dev);
 216                 len = sprintf(buf, "%02x%02x\t%04x%04x\t%x",
 217                         dev->bus->number,
 218                         dev->devfn,
 219                         dev->vendor,
 220                         dev->device,
 221                         dev->irq);
 222                 /* Here should be 7 and not PCI_NUM_RESOURCES as we need to preserve compatibility */
 223                 for(i=0; i<7; i++)
 224                         len += sprintf(buf+len, LONG_FORMAT,
 225                                        dev->resource[i].start | (dev->resource[i].flags & PCI_REGION_FLAG_MASK));
 226                 for(i=0; i<7; i++)
 227                         len += sprintf(buf+len, LONG_FORMAT, dev->resource[i].start < dev->resource[i].end ?
 228                                        dev->resource[i].end - dev->resource[i].start + 1 : 0);
 229                 buf[len++] = '\t';
 230                 if (drv)
 231                         len += sprintf(buf+len, "%s", drv->name);
 232                 buf[len++] = '\n';
 233                 at += len;
 234                 if (at >= pos) {
 235                         if (!*start) {
 236                                 *start = buf + (pos - (at - len));
 237                                 cnt = at - pos;
 238                         } else
 239                                 cnt += len;
 240                         buf += len;
 241                         if (cnt >= count)
 242                                 /*
 243                                  * proc_file_read() gives us 1KB of slack so it's OK if the
 244                                  * above printfs write a little beyond the buffer end (we
 245                                  * never write more than 1KB beyond the buffer end).
 246                                  */
 247                                 break;
 248                 }
 249         }
 250         return (count > cnt) ? cnt : count;
 251 }
 252
 253 static struct proc_dir_entry *proc_bus_pci_dir;
 254
 255 int pci_proc_attach_device(struct pci_dev *dev)
 256 {
 257         struct pci_bus *bus = dev->bus;
 258         struct proc_dir_entry *de, *e;
 259         char name[16];
 260
 261         if (!(de = bus->procdir)) {
 262                 sprintf(name, "%02x", bus->number);
 263                 de = bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
 264                 if (!de)
 265                         return -ENOMEM;
 266         }
 267         sprintf(name, "%02x.%x", PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
 268         e = dev->procent = create_proc_entry(name, S_IFREG | S_IRUGO | S_IWUSR, de);
 269         if (!e)
 270                 return -ENOMEM;
 271         e->proc_fops = &proc_bus_pci_operations;
 272         e->data = dev;
 273         e->size = PCI_CFG_SPACE_SIZE;
 274         return 0;
 275 }
 276
 277 int pci_proc_detach_device(struct pci_dev *dev)
 278 {
 279         struct proc_dir_entry *e;
 280
 281         if ((e = dev->procent)) {
 282                 if (e->count)
 283                         return -EBUSY;
 284                 remove_proc_entry(e->name, dev->bus->procdir);
 285                 dev->procent = NULL;
 286         }
 287         return 0;
 288 }
 289
 290
 291 /*
 292  *  Backward compatible /proc/pci interface.
 293  */
 294
 295 /*
 296  * Convert some of the configuration space registers of the device at
 297  * address (bus,devfn) into a string (possibly several lines each).
 298  * The configuration string is stored starting at buf[len].  If the
 299  * string would exceed the size of the buffer (SIZE), 0 is returned.
 300  */
 301 static int sprint_dev_config(struct pci_dev *dev, char *buf, int size)
 302 {
 303         u32 class_rev;
 304         unsigned char latency, min_gnt, max_lat, *class;
 305         int reg, len = 0;
 306
 307         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
 308         pci_read_config_byte (dev, PCI_LATENCY_TIMER, &latency);
 309         pci_read_config_byte (dev, PCI_MIN_GNT, &min_gnt);
 310         pci_read_config_byte (dev, PCI_MAX_LAT, &max_lat);
 311         if (len + 160 > size)
 312                 return -1;
 313         len += sprintf(buf + len, "  Bus %2d, device %3d, function %2d:\n",
 314                        dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
 315         class = pci_class_name(class_rev >> 16);
 316         if (class)
 317                 len += sprintf(buf+len, "    %s", class);
 318         else
 319                 len += sprintf(buf+len, "    Class %04x", class_rev >> 16);
 320         len += sprintf(buf+len, ": %s (rev %d).\n", dev->name, class_rev & 0xff);
 321
 322         if (dev->irq) {
 323                 if (len + 40 > size)
 324                         return -1;
 325                 len += sprintf(buf + len, "      IRQ %d.\n", dev->irq);
 326         }
 327
 328         if (latency || min_gnt || max_lat) {
 329                 if (len + 80 > size)
 330                         return -1;
 331                 len += sprintf(buf + len, "      Master Capable.  ");
 332                 if (latency)
 333                   len += sprintf(buf + len, "Latency=%d.  ", latency);
 334                 else
 335                   len += sprintf(buf + len, "No bursts.  ");
 336                 if (min_gnt)
 337                   len += sprintf(buf + len, "Min Gnt=%d.", min_gnt);
 338                 if (max_lat)
 339                   len += sprintf(buf + len, "Max Lat=%d.", max_lat);
 340                 len += sprintf(buf + len, "\n");
 341         }
 342
 343         for (reg = 0; reg < 6; reg++) {
 344                 struct resource *res = dev->resource + reg;
 345                 unsigned long base, end, flags;
 346
 347                 if (len + 40 > size)
 348                         return -1;
 349                 base = res->start;
 350                 end = res->end;
 351                 flags = res->flags;
 352                 if (!end)
 353                         continue;
 354
 355                 if (flags & PCI_BASE_ADDRESS_SPACE_IO) {
 356                         len += sprintf(buf + len,
 357                                        "      I/O at 0x%lx [0x%lx].\n",
 358                                        base, end);
 359                 } else {
 360                         const char *pref, *type = "unknown";
 361
 362                         if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
 363                                 pref = "P";
 364                         else
 365                                 pref = "Non-p";
 366                         switch (flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK) {
 367                               case PCI_BASE_ADDRESS_MEM_TYPE_32:
 368                                 type = "32 bit"; break;
 369                               case PCI_BASE_ADDRESS_MEM_TYPE_1M:
 370                                 type = "20 bit"; break;
 371                               case PCI_BASE_ADDRESS_MEM_TYPE_64:
 372                                 type = "64 bit"; break;
 373                         }
 374                         len += sprintf(buf + len,
 375                                        "      %srefetchable %s memory at "
 376                                        "0x%lx [0x%lx].\n", pref, type,
 377                                        base,
 378                                        end);
 379                 }
 380         }
 381
 382         return len;
 383 }
 384
 385 /*
 386  * Return list of PCI devices as a character string for /proc/pci.
 387  * BUF is a buffer that is PAGE_SIZE bytes long.
 388  */
 389 static int pci_read_proc(char *buf, char **start, off_t off,
 390                                 int count, int *eof, void *data)
 391 {
 392         int nprinted, len, begin = 0;
 393         struct pci_dev *dev;
 394
 395         len = sprintf(buf, "PCI devices found:\n");
 396
 397         *eof = 1;
 398         pci_for_each_dev(dev) {
 399                 nprinted = sprint_dev_config(dev, buf + len, PAGE_SIZE - len);
 400                 if (nprinted < 0) {
 401                         *eof = 0;
 402                         break;
 403                 }
 404                 len += nprinted;
 405                 if (len+begin < off) {
 406                         begin += len;
 407                         len = 0;
 408                 }
 409                 if (len+begin >= off+count)
 410                         break;
 411         }
 412         off -= begin;
 413         *start = buf + off;
 414         len -= off;
 415         if (len>count)
 416                 len = count;
 417         if (len<0)
 418                 len = 0;
 419         return len;
 420 }
 421
 422 static int __init pci_proc_init(void)
 423 {
 424         if (pci_present()) {
 425                 struct pci_dev *dev;
 426                 proc_bus_pci_dir = proc_mkdir("pci", proc_bus);
 427                 create_proc_info_entry("devices", 0, proc_bus_pci_dir,
 428                                         get_pci_dev_info);
 429                 pci_for_each_dev(dev) {
 430                         pci_proc_attach_device(dev);
 431                 }
 432                 create_proc_read_entry("pci", 0, NULL, pci_read_proc, NULL);
 433         }
 434         return 0;
 435 }
 436
 437 __initcall(pci_proc_init);