blob: ea00647f4732fcb83f60db140265e1b1465a3548 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Procfs interface for the PCI bus.
3 *
4 * Copyright (c) 1997--1999 Martin Mares <mj@ucw.cz>
5 */
6
7#include <linux/init.h>
8#include <linux/pci.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09009#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/module.h>
11#include <linux/proc_fs.h>
12#include <linux/seq_file.h>
Mathieu Segaudadd77182008-01-10 14:27:12 +010013#include <linux/smp_lock.h>
Alexey Dobriyanaa0ac362007-07-15 23:40:39 -070014#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <asm/uaccess.h>
16#include <asm/byteorder.h>
Greg KHbc56b9e2005-04-08 14:53:31 +090017#include "pci.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070018
19static int proc_initialized; /* = 0 */
20
21static loff_t
22proc_bus_pci_lseek(struct file *file, loff_t off, int whence)
23{
24 loff_t new = -1;
Josef Sipek46cc65a2006-12-08 02:37:28 -080025 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080027 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 switch (whence) {
29 case 0:
30 new = off;
31 break;
32 case 1:
33 new = file->f_pos + off;
34 break;
35 case 2:
36 new = inode->i_size + off;
37 break;
38 }
39 if (new < 0 || new > inode->i_size)
40 new = -EINVAL;
41 else
42 file->f_pos = new;
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080043 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 return new;
45}
46
47static ssize_t
48proc_bus_pci_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
49{
Josef Sipek46cc65a2006-12-08 02:37:28 -080050 const struct inode *ino = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 const struct proc_dir_entry *dp = PDE(ino);
52 struct pci_dev *dev = dp->data;
53 unsigned int pos = *ppos;
54 unsigned int cnt, size;
55
56 /*
57 * Normal users can read only the standardized portion of the
58 * configuration space as several chips lock up when trying to read
59 * undefined locations (think of Intel PIIX4 as a typical example).
60 */
61
62 if (capable(CAP_SYS_ADMIN))
David Rientjescd686022007-09-27 13:41:16 -070063 size = dp->size;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
65 size = 128;
66 else
67 size = 64;
68
69 if (pos >= size)
70 return 0;
71 if (nbytes >= size)
72 nbytes = size;
73 if (pos + nbytes > size)
74 nbytes = size - pos;
75 cnt = nbytes;
76
77 if (!access_ok(VERIFY_WRITE, buf, cnt))
78 return -EINVAL;
79
80 if ((pos & 1) && cnt) {
81 unsigned char val;
Brian Kinge04b0ea2005-09-27 01:21:55 -070082 pci_user_read_config_byte(dev, pos, &val);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 __put_user(val, buf);
84 buf++;
85 pos++;
86 cnt--;
87 }
88
89 if ((pos & 3) && cnt > 2) {
90 unsigned short val;
Brian Kinge04b0ea2005-09-27 01:21:55 -070091 pci_user_read_config_word(dev, pos, &val);
Harvey Harrisonf17a0772008-07-22 14:40:47 -070092 __put_user(cpu_to_le16(val), (__le16 __user *) buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 buf += 2;
94 pos += 2;
95 cnt -= 2;
96 }
97
98 while (cnt >= 4) {
99 unsigned int val;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700100 pci_user_read_config_dword(dev, pos, &val);
Harvey Harrisonf17a0772008-07-22 14:40:47 -0700101 __put_user(cpu_to_le32(val), (__le32 __user *) buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 buf += 4;
103 pos += 4;
104 cnt -= 4;
105 }
106
107 if (cnt >= 2) {
108 unsigned short val;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700109 pci_user_read_config_word(dev, pos, &val);
Harvey Harrisonf17a0772008-07-22 14:40:47 -0700110 __put_user(cpu_to_le16(val), (__le16 __user *) buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 buf += 2;
112 pos += 2;
113 cnt -= 2;
114 }
115
116 if (cnt) {
117 unsigned char val;
Brian Kinge04b0ea2005-09-27 01:21:55 -0700118 pci_user_read_config_byte(dev, pos, &val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 __put_user(val, buf);
120 buf++;
121 pos++;
122 cnt--;
123 }
124
125 *ppos = pos;
126 return nbytes;
127}
128
129static ssize_t
130proc_bus_pci_write(struct file *file, const char __user *buf, size_t nbytes, loff_t *ppos)
131{
David Rientjesecb39082007-09-27 13:41:17 -0700132 struct inode *ino = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 const struct proc_dir_entry *dp = PDE(ino);
134 struct pci_dev *dev = dp->data;
135 int pos = *ppos;
David Rientjescd686022007-09-27 13:41:16 -0700136 int size = dp->size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 int cnt;
138
139 if (pos >= size)
140 return 0;
141 if (nbytes >= size)
142 nbytes = size;
143 if (pos + nbytes > size)
144 nbytes = size - pos;
145 cnt = nbytes;
146
147 if (!access_ok(VERIFY_READ, buf, cnt))
148 return -EINVAL;
149
150 if ((pos & 1) && cnt) {
151 unsigned char val;
152 __get_user(val, buf);
Brian Kinge04b0ea2005-09-27 01:21:55 -0700153 pci_user_write_config_byte(dev, pos, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 buf++;
155 pos++;
156 cnt--;
157 }
158
159 if ((pos & 3) && cnt > 2) {
Harvey Harrisonf17a0772008-07-22 14:40:47 -0700160 __le16 val;
161 __get_user(val, (__le16 __user *) buf);
Brian Kinge04b0ea2005-09-27 01:21:55 -0700162 pci_user_write_config_word(dev, pos, le16_to_cpu(val));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 buf += 2;
164 pos += 2;
165 cnt -= 2;
166 }
167
168 while (cnt >= 4) {
Harvey Harrisonf17a0772008-07-22 14:40:47 -0700169 __le32 val;
170 __get_user(val, (__le32 __user *) buf);
Brian Kinge04b0ea2005-09-27 01:21:55 -0700171 pci_user_write_config_dword(dev, pos, le32_to_cpu(val));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 buf += 4;
173 pos += 4;
174 cnt -= 4;
175 }
176
177 if (cnt >= 2) {
Harvey Harrisonf17a0772008-07-22 14:40:47 -0700178 __le16 val;
179 __get_user(val, (__le16 __user *) buf);
Brian Kinge04b0ea2005-09-27 01:21:55 -0700180 pci_user_write_config_word(dev, pos, le16_to_cpu(val));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 buf += 2;
182 pos += 2;
183 cnt -= 2;
184 }
185
186 if (cnt) {
187 unsigned char val;
188 __get_user(val, buf);
Brian Kinge04b0ea2005-09-27 01:21:55 -0700189 pci_user_write_config_byte(dev, pos, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 buf++;
191 pos++;
192 cnt--;
193 }
194
195 *ppos = pos;
David Rientjesecb39082007-09-27 13:41:17 -0700196 i_size_write(ino, dp->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 return nbytes;
198}
199
200struct pci_filp_private {
201 enum pci_mmap_state mmap_state;
202 int write_combine;
203};
204
Mathieu Segaudadd77182008-01-10 14:27:12 +0100205static long proc_bus_pci_ioctl(struct file *file, unsigned int cmd,
206 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207{
Mathieu Segaudadd77182008-01-10 14:27:12 +0100208 const struct proc_dir_entry *dp = PDE(file->f_dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 struct pci_dev *dev = dp->data;
210#ifdef HAVE_PCI_MMAP
211 struct pci_filp_private *fpriv = file->private_data;
212#endif /* HAVE_PCI_MMAP */
213 int ret = 0;
214
215 switch (cmd) {
216 case PCIIOC_CONTROLLER:
217 ret = pci_domain_nr(dev->bus);
218 break;
219
220#ifdef HAVE_PCI_MMAP
221 case PCIIOC_MMAP_IS_IO:
222 fpriv->mmap_state = pci_mmap_io;
223 break;
224
225 case PCIIOC_MMAP_IS_MEM:
226 fpriv->mmap_state = pci_mmap_mem;
227 break;
228
229 case PCIIOC_WRITE_COMBINE:
230 if (arg)
231 fpriv->write_combine = 1;
232 else
233 fpriv->write_combine = 0;
234 break;
235
236#endif /* HAVE_PCI_MMAP */
237
238 default:
239 ret = -EINVAL;
240 break;
241 };
242
243 return ret;
244}
245
246#ifdef HAVE_PCI_MMAP
247static int proc_bus_pci_mmap(struct file *file, struct vm_area_struct *vma)
248{
Josef Sipek46cc65a2006-12-08 02:37:28 -0800249 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 const struct proc_dir_entry *dp = PDE(inode);
251 struct pci_dev *dev = dp->data;
252 struct pci_filp_private *fpriv = file->private_data;
Jesse Barnes9eff02e2008-10-24 10:32:33 -0700253 int i, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
255 if (!capable(CAP_SYS_RAWIO))
256 return -EPERM;
257
Jesse Barnes9eff02e2008-10-24 10:32:33 -0700258 /* Make sure the caller is mapping a real resource for this device */
259 for (i = 0; i < PCI_ROM_RESOURCE; i++) {
Martin Wilck3b519e42010-11-10 11:03:21 +0100260 if (pci_mmap_fits(dev, i, vma, PCI_MMAP_PROCFS))
Jesse Barnes9eff02e2008-10-24 10:32:33 -0700261 break;
262 }
263
264 if (i >= PCI_ROM_RESOURCE)
265 return -ENODEV;
266
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 ret = pci_mmap_page_range(dev, vma,
268 fpriv->mmap_state,
269 fpriv->write_combine);
270 if (ret < 0)
271 return ret;
272
273 return 0;
274}
275
276static int proc_bus_pci_open(struct inode *inode, struct file *file)
277{
278 struct pci_filp_private *fpriv = kmalloc(sizeof(*fpriv), GFP_KERNEL);
279
280 if (!fpriv)
281 return -ENOMEM;
282
283 fpriv->mmap_state = pci_mmap_io;
284 fpriv->write_combine = 0;
285
286 file->private_data = fpriv;
287
288 return 0;
289}
290
291static int proc_bus_pci_release(struct inode *inode, struct file *file)
292{
293 kfree(file->private_data);
294 file->private_data = NULL;
295
296 return 0;
297}
298#endif /* HAVE_PCI_MMAP */
299
Arjan van de Vend54b1fd2007-02-12 00:55:34 -0800300static const struct file_operations proc_bus_pci_operations = {
Denis V. Lunevc7705f3442008-04-29 01:02:35 -0700301 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 .llseek = proc_bus_pci_lseek,
303 .read = proc_bus_pci_read,
304 .write = proc_bus_pci_write,
Mathieu Segaudadd77182008-01-10 14:27:12 +0100305 .unlocked_ioctl = proc_bus_pci_ioctl,
Arnd Bergmann991f7392010-07-04 00:02:28 +0200306 .compat_ioctl = proc_bus_pci_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307#ifdef HAVE_PCI_MMAP
308 .open = proc_bus_pci_open,
309 .release = proc_bus_pci_release,
310 .mmap = proc_bus_pci_mmap,
311#ifdef HAVE_ARCH_PCI_GET_UNMAPPED_AREA
312 .get_unmapped_area = get_pci_unmapped_area,
313#endif /* HAVE_ARCH_PCI_GET_UNMAPPED_AREA */
314#endif /* HAVE_PCI_MMAP */
315};
316
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317/* iterator */
318static void *pci_seq_start(struct seq_file *m, loff_t *pos)
319{
320 struct pci_dev *dev = NULL;
321 loff_t n = *pos;
322
323 for_each_pci_dev(dev) {
324 if (!n--)
325 break;
326 }
327 return dev;
328}
329
330static void *pci_seq_next(struct seq_file *m, void *v, loff_t *pos)
331{
332 struct pci_dev *dev = v;
333
334 (*pos)++;
335 dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev);
336 return dev;
337}
338
339static void pci_seq_stop(struct seq_file *m, void *v)
340{
341 if (v) {
342 struct pci_dev *dev = v;
343 pci_dev_put(dev);
344 }
345}
346
347static int show_device(struct seq_file *m, void *v)
348{
349 const struct pci_dev *dev = v;
350 const struct pci_driver *drv;
351 int i;
352
353 if (dev == NULL)
354 return 0;
355
356 drv = pci_dev_driver(dev);
357 seq_printf(m, "%02x%02x\t%04x%04x\t%x",
358 dev->bus->number,
359 dev->devfn,
360 dev->vendor,
361 dev->device,
362 dev->irq);
Yu Zhaofde09c62008-11-22 02:39:32 +0800363
364 /* only print standard and ROM resources to preserve compatibility */
365 for (i = 0; i <= PCI_ROM_RESOURCE; i++) {
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -0700366 resource_size_t start, end;
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000367 pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
Greg Kroah-Hartman1396a8c2006-06-12 15:14:29 -0700368 seq_printf(m, "\t%16llx",
369 (unsigned long long)(start |
370 (dev->resource[i].flags & PCI_REGION_FLAG_MASK)));
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000371 }
Yu Zhaofde09c62008-11-22 02:39:32 +0800372 for (i = 0; i <= PCI_ROM_RESOURCE; i++) {
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -0700373 resource_size_t start, end;
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000374 pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
Greg Kroah-Hartman1396a8c2006-06-12 15:14:29 -0700375 seq_printf(m, "\t%16llx",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 dev->resource[i].start < dev->resource[i].end ?
Greg Kroah-Hartman1396a8c2006-06-12 15:14:29 -0700377 (unsigned long long)(end - start) + 1 : 0);
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000378 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 seq_putc(m, '\t');
380 if (drv)
381 seq_printf(m, "%s", drv->name);
382 seq_putc(m, '\n');
383 return 0;
384}
385
Jan Engelhardt02d90fc2008-01-22 20:53:43 +0100386static const struct seq_operations proc_bus_pci_devices_op = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 .start = pci_seq_start,
388 .next = pci_seq_next,
389 .stop = pci_seq_stop,
390 .show = show_device
391};
392
393static struct proc_dir_entry *proc_bus_pci_dir;
394
395int pci_proc_attach_device(struct pci_dev *dev)
396{
397 struct pci_bus *bus = dev->bus;
398 struct proc_dir_entry *e;
399 char name[16];
400
401 if (!proc_initialized)
402 return -EACCES;
403
404 if (!bus->procdir) {
405 if (pci_proc_domain(bus)) {
406 sprintf(name, "%04x:%02x", pci_domain_nr(bus),
407 bus->number);
408 } else {
409 sprintf(name, "%02x", bus->number);
410 }
411 bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
412 if (!bus->procdir)
413 return -ENOMEM;
414 }
415
416 sprintf(name, "%02x.%x", PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
Denis V. Lunevc7705f3442008-04-29 01:02:35 -0700417 e = proc_create_data(name, S_IFREG | S_IRUGO | S_IWUSR, bus->procdir,
418 &proc_bus_pci_operations, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 if (!e)
420 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 e->size = dev->cfg_size;
422 dev->procent = e;
423
424 return 0;
425}
426
427int pci_proc_detach_device(struct pci_dev *dev)
428{
429 struct proc_dir_entry *e;
430
431 if ((e = dev->procent)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 remove_proc_entry(e->name, dev->bus->procdir);
433 dev->procent = NULL;
434 }
435 return 0;
436}
437
Adrian Bunk54c762f2005-12-22 01:08:52 +0100438#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439int pci_proc_attach_bus(struct pci_bus* bus)
440{
441 struct proc_dir_entry *de = bus->procdir;
442
443 if (!proc_initialized)
444 return -EACCES;
445
446 if (!de) {
447 char name[16];
448 sprintf(name, "%02x", bus->number);
449 de = bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
450 if (!de)
451 return -ENOMEM;
452 }
453 return 0;
454}
Adrian Bunk54c762f2005-12-22 01:08:52 +0100455#endif /* 0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
457int pci_proc_detach_bus(struct pci_bus* bus)
458{
459 struct proc_dir_entry *de = bus->procdir;
460 if (de)
461 remove_proc_entry(de->name, proc_bus_pci_dir);
462 return 0;
463}
464
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465static int proc_bus_pci_dev_open(struct inode *inode, struct file *file)
466{
467 return seq_open(file, &proc_bus_pci_devices_op);
468}
Arjan van de Vend54b1fd2007-02-12 00:55:34 -0800469static const struct file_operations proc_bus_pci_dev_operations = {
Denis V. Lunevc7705f3442008-04-29 01:02:35 -0700470 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 .open = proc_bus_pci_dev_open,
472 .read = seq_read,
473 .llseek = seq_lseek,
474 .release = seq_release,
475};
476
477static int __init pci_proc_init(void)
478{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 struct pci_dev *dev = NULL;
Alexey Dobriyan9c370662008-04-29 01:01:41 -0700480 proc_bus_pci_dir = proc_mkdir("bus/pci", NULL);
Denis V. Lunevc7705f3442008-04-29 01:02:35 -0700481 proc_create("devices", 0, proc_bus_pci_dir,
482 &proc_bus_pci_dev_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 proc_initialized = 1;
Kulikov Vasiliy4e344b12010-07-03 20:04:39 +0400484 for_each_pci_dev(dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 pci_proc_attach_device(dev);
Kulikov Vasiliy4e344b12010-07-03 20:04:39 +0400486
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 return 0;
488}
489
Robert P. J. Dayeaf61142008-05-11 16:58:53 -0400490device_initcall(pci_proc_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491