blob: 92a8857608329f26892c990e6425be88020df5c3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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@ucw.cz>
7 */
8
9#include <linux/init.h>
10#include <linux/pci.h>
11#include <linux/module.h>
12#include <linux/proc_fs.h>
13#include <linux/seq_file.h>
14#include <linux/smp_lock.h>
15
16#include <asm/uaccess.h>
17#include <asm/byteorder.h>
Greg KHbc56b9e2005-04-08 14:53:31 +090018#include "pci.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
20static int proc_initialized; /* = 0 */
21
22static loff_t
23proc_bus_pci_lseek(struct file *file, loff_t off, int whence)
24{
25 loff_t new = -1;
26 struct inode *inode = file->f_dentry->d_inode;
27
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080028 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 switch (whence) {
30 case 0:
31 new = off;
32 break;
33 case 1:
34 new = file->f_pos + off;
35 break;
36 case 2:
37 new = inode->i_size + off;
38 break;
39 }
40 if (new < 0 || new > inode->i_size)
41 new = -EINVAL;
42 else
43 file->f_pos = new;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080044 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 return new;
46}
47
48static ssize_t
49proc_bus_pci_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
50{
51 const struct inode *ino = file->f_dentry->d_inode;
52 const struct proc_dir_entry *dp = PDE(ino);
53 struct pci_dev *dev = dp->data;
54 unsigned int pos = *ppos;
55 unsigned int cnt, size;
56
57 /*
58 * Normal users can read only the standardized portion of the
59 * configuration space as several chips lock up when trying to read
60 * undefined locations (think of Intel PIIX4 as a typical example).
61 */
62
63 if (capable(CAP_SYS_ADMIN))
64 size = dev->cfg_size;
65 else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
66 size = 128;
67 else
68 size = 64;
69
70 if (pos >= size)
71 return 0;
72 if (nbytes >= size)
73 nbytes = size;
74 if (pos + nbytes > size)
75 nbytes = size - pos;
76 cnt = nbytes;
77
78 if (!access_ok(VERIFY_WRITE, buf, cnt))
79 return -EINVAL;
80
81 if ((pos & 1) && cnt) {
82 unsigned char val;
Brian Kinge04b0ea2005-09-27 01:21:55 -070083 pci_user_read_config_byte(dev, pos, &val);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 __put_user(val, buf);
85 buf++;
86 pos++;
87 cnt--;
88 }
89
90 if ((pos & 3) && cnt > 2) {
91 unsigned short val;
Brian Kinge04b0ea2005-09-27 01:21:55 -070092 pci_user_read_config_word(dev, pos, &val);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 __put_user(cpu_to_le16(val), (unsigned short __user *) buf);
94 buf += 2;
95 pos += 2;
96 cnt -= 2;
97 }
98
99 while (cnt >= 4) {
100 unsigned int val;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700101 pci_user_read_config_dword(dev, pos, &val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 __put_user(cpu_to_le32(val), (unsigned int __user *) buf);
103 buf += 4;
104 pos += 4;
105 cnt -= 4;
106 }
107
108 if (cnt >= 2) {
109 unsigned short val;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700110 pci_user_read_config_word(dev, pos, &val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 __put_user(cpu_to_le16(val), (unsigned short __user *) buf);
112 buf += 2;
113 pos += 2;
114 cnt -= 2;
115 }
116
117 if (cnt) {
118 unsigned char val;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700119 pci_user_read_config_byte(dev, pos, &val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 __put_user(val, buf);
121 buf++;
122 pos++;
123 cnt--;
124 }
125
126 *ppos = pos;
127 return nbytes;
128}
129
130static ssize_t
131proc_bus_pci_write(struct file *file, const char __user *buf, size_t nbytes, loff_t *ppos)
132{
133 const struct inode *ino = file->f_dentry->d_inode;
134 const struct proc_dir_entry *dp = PDE(ino);
135 struct pci_dev *dev = dp->data;
136 int pos = *ppos;
137 int size = dev->cfg_size;
138 int cnt;
139
140 if (pos >= size)
141 return 0;
142 if (nbytes >= size)
143 nbytes = size;
144 if (pos + nbytes > size)
145 nbytes = size - pos;
146 cnt = nbytes;
147
148 if (!access_ok(VERIFY_READ, buf, cnt))
149 return -EINVAL;
150
151 if ((pos & 1) && cnt) {
152 unsigned char val;
153 __get_user(val, buf);
Brian Kinge04b0ea2005-09-27 01:21:55 -0700154 pci_user_write_config_byte(dev, pos, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 buf++;
156 pos++;
157 cnt--;
158 }
159
160 if ((pos & 3) && cnt > 2) {
161 unsigned short val;
162 __get_user(val, (unsigned short __user *) buf);
Brian Kinge04b0ea2005-09-27 01:21:55 -0700163 pci_user_write_config_word(dev, pos, le16_to_cpu(val));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 buf += 2;
165 pos += 2;
166 cnt -= 2;
167 }
168
169 while (cnt >= 4) {
170 unsigned int val;
171 __get_user(val, (unsigned int __user *) buf);
Brian Kinge04b0ea2005-09-27 01:21:55 -0700172 pci_user_write_config_dword(dev, pos, le32_to_cpu(val));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 buf += 4;
174 pos += 4;
175 cnt -= 4;
176 }
177
178 if (cnt >= 2) {
179 unsigned short val;
180 __get_user(val, (unsigned short __user *) buf);
Brian Kinge04b0ea2005-09-27 01:21:55 -0700181 pci_user_write_config_word(dev, pos, le16_to_cpu(val));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 buf += 2;
183 pos += 2;
184 cnt -= 2;
185 }
186
187 if (cnt) {
188 unsigned char val;
189 __get_user(val, buf);
Brian Kinge04b0ea2005-09-27 01:21:55 -0700190 pci_user_write_config_byte(dev, pos, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 buf++;
192 pos++;
193 cnt--;
194 }
195
196 *ppos = pos;
197 return nbytes;
198}
199
200struct pci_filp_private {
201 enum pci_mmap_state mmap_state;
202 int write_combine;
203};
204
205static int proc_bus_pci_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
206{
207 const struct proc_dir_entry *dp = PDE(inode);
208 struct pci_dev *dev = dp->data;
209#ifdef HAVE_PCI_MMAP
210 struct pci_filp_private *fpriv = file->private_data;
211#endif /* HAVE_PCI_MMAP */
212 int ret = 0;
213
214 switch (cmd) {
215 case PCIIOC_CONTROLLER:
216 ret = pci_domain_nr(dev->bus);
217 break;
218
219#ifdef HAVE_PCI_MMAP
220 case PCIIOC_MMAP_IS_IO:
221 fpriv->mmap_state = pci_mmap_io;
222 break;
223
224 case PCIIOC_MMAP_IS_MEM:
225 fpriv->mmap_state = pci_mmap_mem;
226 break;
227
228 case PCIIOC_WRITE_COMBINE:
229 if (arg)
230 fpriv->write_combine = 1;
231 else
232 fpriv->write_combine = 0;
233 break;
234
235#endif /* HAVE_PCI_MMAP */
236
237 default:
238 ret = -EINVAL;
239 break;
240 };
241
242 return ret;
243}
244
245#ifdef HAVE_PCI_MMAP
246static int proc_bus_pci_mmap(struct file *file, struct vm_area_struct *vma)
247{
248 struct inode *inode = file->f_dentry->d_inode;
249 const struct proc_dir_entry *dp = PDE(inode);
250 struct pci_dev *dev = dp->data;
251 struct pci_filp_private *fpriv = file->private_data;
252 int ret;
253
254 if (!capable(CAP_SYS_RAWIO))
255 return -EPERM;
256
257 ret = pci_mmap_page_range(dev, vma,
258 fpriv->mmap_state,
259 fpriv->write_combine);
260 if (ret < 0)
261 return ret;
262
263 return 0;
264}
265
266static int proc_bus_pci_open(struct inode *inode, struct file *file)
267{
268 struct pci_filp_private *fpriv = kmalloc(sizeof(*fpriv), GFP_KERNEL);
269
270 if (!fpriv)
271 return -ENOMEM;
272
273 fpriv->mmap_state = pci_mmap_io;
274 fpriv->write_combine = 0;
275
276 file->private_data = fpriv;
277
278 return 0;
279}
280
281static int proc_bus_pci_release(struct inode *inode, struct file *file)
282{
283 kfree(file->private_data);
284 file->private_data = NULL;
285
286 return 0;
287}
288#endif /* HAVE_PCI_MMAP */
289
290static struct file_operations proc_bus_pci_operations = {
291 .llseek = proc_bus_pci_lseek,
292 .read = proc_bus_pci_read,
293 .write = proc_bus_pci_write,
294 .ioctl = proc_bus_pci_ioctl,
295#ifdef HAVE_PCI_MMAP
296 .open = proc_bus_pci_open,
297 .release = proc_bus_pci_release,
298 .mmap = proc_bus_pci_mmap,
299#ifdef HAVE_ARCH_PCI_GET_UNMAPPED_AREA
300 .get_unmapped_area = get_pci_unmapped_area,
301#endif /* HAVE_ARCH_PCI_GET_UNMAPPED_AREA */
302#endif /* HAVE_PCI_MMAP */
303};
304
305#if BITS_PER_LONG == 32
306#define LONG_FORMAT "\t%08lx"
307#else
308#define LONG_FORMAT "\t%16lx"
309#endif
310
311/* iterator */
312static void *pci_seq_start(struct seq_file *m, loff_t *pos)
313{
314 struct pci_dev *dev = NULL;
315 loff_t n = *pos;
316
317 for_each_pci_dev(dev) {
318 if (!n--)
319 break;
320 }
321 return dev;
322}
323
324static void *pci_seq_next(struct seq_file *m, void *v, loff_t *pos)
325{
326 struct pci_dev *dev = v;
327
328 (*pos)++;
329 dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev);
330 return dev;
331}
332
333static void pci_seq_stop(struct seq_file *m, void *v)
334{
335 if (v) {
336 struct pci_dev *dev = v;
337 pci_dev_put(dev);
338 }
339}
340
341static int show_device(struct seq_file *m, void *v)
342{
343 const struct pci_dev *dev = v;
344 const struct pci_driver *drv;
345 int i;
346
347 if (dev == NULL)
348 return 0;
349
350 drv = pci_dev_driver(dev);
351 seq_printf(m, "%02x%02x\t%04x%04x\t%x",
352 dev->bus->number,
353 dev->devfn,
354 dev->vendor,
355 dev->device,
356 dev->irq);
357 /* Here should be 7 and not PCI_NUM_RESOURCES as we need to preserve compatibility */
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000358 for (i=0; i<7; i++) {
359 u64 start, end;
360 pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 seq_printf(m, LONG_FORMAT,
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000362 ((unsigned long)start) |
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 (dev->resource[i].flags & PCI_REGION_FLAG_MASK));
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000364 }
365 for (i=0; i<7; i++) {
366 u64 start, end;
367 pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 seq_printf(m, LONG_FORMAT,
369 dev->resource[i].start < dev->resource[i].end ?
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000370 (unsigned long)(end - start) + 1 : 0);
371 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 seq_putc(m, '\t');
373 if (drv)
374 seq_printf(m, "%s", drv->name);
375 seq_putc(m, '\n');
376 return 0;
377}
378
379static struct seq_operations proc_bus_pci_devices_op = {
380 .start = pci_seq_start,
381 .next = pci_seq_next,
382 .stop = pci_seq_stop,
383 .show = show_device
384};
385
386static struct proc_dir_entry *proc_bus_pci_dir;
387
388int pci_proc_attach_device(struct pci_dev *dev)
389{
390 struct pci_bus *bus = dev->bus;
391 struct proc_dir_entry *e;
392 char name[16];
393
394 if (!proc_initialized)
395 return -EACCES;
396
397 if (!bus->procdir) {
398 if (pci_proc_domain(bus)) {
399 sprintf(name, "%04x:%02x", pci_domain_nr(bus),
400 bus->number);
401 } else {
402 sprintf(name, "%02x", bus->number);
403 }
404 bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
405 if (!bus->procdir)
406 return -ENOMEM;
407 }
408
409 sprintf(name, "%02x.%x", PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
410 e = create_proc_entry(name, S_IFREG | S_IRUGO | S_IWUSR, bus->procdir);
411 if (!e)
412 return -ENOMEM;
413 e->proc_fops = &proc_bus_pci_operations;
414 e->data = dev;
415 e->size = dev->cfg_size;
416 dev->procent = e;
417
418 return 0;
419}
420
421int pci_proc_detach_device(struct pci_dev *dev)
422{
423 struct proc_dir_entry *e;
424
425 if ((e = dev->procent)) {
426 if (atomic_read(&e->count))
427 return -EBUSY;
428 remove_proc_entry(e->name, dev->bus->procdir);
429 dev->procent = NULL;
430 }
431 return 0;
432}
433
Adrian Bunk54c762f2005-12-22 01:08:52 +0100434#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435int pci_proc_attach_bus(struct pci_bus* bus)
436{
437 struct proc_dir_entry *de = bus->procdir;
438
439 if (!proc_initialized)
440 return -EACCES;
441
442 if (!de) {
443 char name[16];
444 sprintf(name, "%02x", bus->number);
445 de = bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
446 if (!de)
447 return -ENOMEM;
448 }
449 return 0;
450}
Adrian Bunk54c762f2005-12-22 01:08:52 +0100451#endif /* 0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
453int pci_proc_detach_bus(struct pci_bus* bus)
454{
455 struct proc_dir_entry *de = bus->procdir;
456 if (de)
457 remove_proc_entry(de->name, proc_bus_pci_dir);
458 return 0;
459}
460
461#ifdef CONFIG_PCI_LEGACY_PROC
462
463/*
464 * Backward compatible /proc/pci interface.
465 */
466
467/*
468 * Convert some of the configuration space registers of the device at
469 * address (bus,devfn) into a string (possibly several lines each).
470 * The configuration string is stored starting at buf[len]. If the
471 * string would exceed the size of the buffer (SIZE), 0 is returned.
472 */
473static int show_dev_config(struct seq_file *m, void *v)
474{
475 struct pci_dev *dev = v;
476 struct pci_dev *first_dev;
477 struct pci_driver *drv;
478 u32 class_rev;
Adrian Bunk982245f2005-07-17 04:22:20 +0200479 unsigned char latency, min_gnt, max_lat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 int reg;
481
482 first_dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
483 if (dev == first_dev)
484 seq_puts(m, "PCI devices found:\n");
485 pci_dev_put(first_dev);
486
487 drv = pci_dev_driver(dev);
488
Brian Kinge04b0ea2005-09-27 01:21:55 -0700489 pci_user_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
490 pci_user_read_config_byte (dev, PCI_LATENCY_TIMER, &latency);
491 pci_user_read_config_byte (dev, PCI_MIN_GNT, &min_gnt);
492 pci_user_read_config_byte (dev, PCI_MAX_LAT, &max_lat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 seq_printf(m, " Bus %2d, device %3d, function %2d:\n",
494 dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
Adrian Bunk982245f2005-07-17 04:22:20 +0200495 seq_printf(m, " Class %04x", class_rev >> 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 seq_printf(m, ": PCI device %04x:%04x", dev->vendor, dev->device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 seq_printf(m, " (rev %d).\n", class_rev & 0xff);
498
499 if (dev->irq)
500 seq_printf(m, " IRQ %d.\n", dev->irq);
501
502 if (latency || min_gnt || max_lat) {
503 seq_printf(m, " Master Capable. ");
504 if (latency)
505 seq_printf(m, "Latency=%d. ", latency);
506 else
507 seq_puts(m, "No bursts. ");
508 if (min_gnt)
509 seq_printf(m, "Min Gnt=%d.", min_gnt);
510 if (max_lat)
511 seq_printf(m, "Max Lat=%d.", max_lat);
512 seq_putc(m, '\n');
513 }
514
515 for (reg = 0; reg < 6; reg++) {
516 struct resource *res = dev->resource + reg;
517 unsigned long base, end, flags;
518
519 base = res->start;
520 end = res->end;
521 flags = res->flags;
522 if (!end)
523 continue;
524
525 if (flags & PCI_BASE_ADDRESS_SPACE_IO) {
526 seq_printf(m, " I/O at 0x%lx [0x%lx].\n",
527 base, end);
528 } else {
529 const char *pref, *type = "unknown";
530
531 if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
532 pref = "P";
533 else
534 pref = "Non-p";
535 switch (flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK) {
536 case PCI_BASE_ADDRESS_MEM_TYPE_32:
537 type = "32 bit"; break;
538 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
539 type = "20 bit"; break;
540 case PCI_BASE_ADDRESS_MEM_TYPE_64:
541 type = "64 bit"; break;
542 }
543 seq_printf(m, " %srefetchable %s memory at "
544 "0x%lx [0x%lx].\n", pref, type,
545 base,
546 end);
547 }
548 }
549 return 0;
550}
551
552static struct seq_operations proc_pci_op = {
553 .start = pci_seq_start,
554 .next = pci_seq_next,
555 .stop = pci_seq_stop,
556 .show = show_dev_config
557};
558
559static int proc_pci_open(struct inode *inode, struct file *file)
560{
561 return seq_open(file, &proc_pci_op);
562}
563static struct file_operations proc_pci_operations = {
564 .open = proc_pci_open,
565 .read = seq_read,
566 .llseek = seq_lseek,
567 .release = seq_release,
568};
569
570static void legacy_proc_init(void)
571{
572 struct proc_dir_entry * entry = create_proc_entry("pci", 0, NULL);
573 if (entry)
574 entry->proc_fops = &proc_pci_operations;
575}
576
577#else
578
579static void legacy_proc_init(void)
580{
581
582}
583
584#endif /* CONFIG_PCI_LEGACY_PROC */
585
586static int proc_bus_pci_dev_open(struct inode *inode, struct file *file)
587{
588 return seq_open(file, &proc_bus_pci_devices_op);
589}
590static struct file_operations proc_bus_pci_dev_operations = {
591 .open = proc_bus_pci_dev_open,
592 .read = seq_read,
593 .llseek = seq_lseek,
594 .release = seq_release,
595};
596
597static int __init pci_proc_init(void)
598{
599 struct proc_dir_entry *entry;
600 struct pci_dev *dev = NULL;
601 proc_bus_pci_dir = proc_mkdir("pci", proc_bus);
602 entry = create_proc_entry("devices", 0, proc_bus_pci_dir);
603 if (entry)
604 entry->proc_fops = &proc_bus_pci_dev_operations;
605 proc_initialized = 1;
606 while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
607 pci_proc_attach_device(dev);
608 }
609 legacy_proc_init();
610 return 0;
611}
612
613__initcall(pci_proc_init);
614
615#ifdef CONFIG_HOTPLUG
616EXPORT_SYMBOL(pci_proc_attach_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617EXPORT_SYMBOL(pci_proc_detach_bus);
618#endif
619