blob: ef18fcd641e2c478927e5e6f29505d31380b75ae [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>
Mathieu Segaudadd77182008-01-10 14:27:12 +010014#include <linux/smp_lock.h>
Alexey Dobriyanaa0ac362007-07-15 23:40:39 -070015#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#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;
Josef Sipek46cc65a2006-12-08 02:37:28 -080026 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
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{
Josef Sipek46cc65a2006-12-08 02:37:28 -080051 const struct inode *ino = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 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))
David Rientjescd686022007-09-27 13:41:16 -070064 size = dp->size;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 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{
David Rientjesecb39082007-09-27 13:41:17 -0700133 struct inode *ino = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 const struct proc_dir_entry *dp = PDE(ino);
135 struct pci_dev *dev = dp->data;
136 int pos = *ppos;
David Rientjescd686022007-09-27 13:41:16 -0700137 int size = dp->size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 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;
David Rientjesecb39082007-09-27 13:41:17 -0700197 i_size_write(ino, dp->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 return nbytes;
199}
200
201struct pci_filp_private {
202 enum pci_mmap_state mmap_state;
203 int write_combine;
204};
205
Mathieu Segaudadd77182008-01-10 14:27:12 +0100206static long proc_bus_pci_ioctl(struct file *file, unsigned int cmd,
207 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208{
Mathieu Segaudadd77182008-01-10 14:27:12 +0100209 const struct proc_dir_entry *dp = PDE(file->f_dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 struct pci_dev *dev = dp->data;
211#ifdef HAVE_PCI_MMAP
212 struct pci_filp_private *fpriv = file->private_data;
213#endif /* HAVE_PCI_MMAP */
214 int ret = 0;
215
Mathieu Segaudadd77182008-01-10 14:27:12 +0100216 lock_kernel();
217
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 switch (cmd) {
219 case PCIIOC_CONTROLLER:
220 ret = pci_domain_nr(dev->bus);
221 break;
222
223#ifdef HAVE_PCI_MMAP
224 case PCIIOC_MMAP_IS_IO:
225 fpriv->mmap_state = pci_mmap_io;
226 break;
227
228 case PCIIOC_MMAP_IS_MEM:
229 fpriv->mmap_state = pci_mmap_mem;
230 break;
231
232 case PCIIOC_WRITE_COMBINE:
233 if (arg)
234 fpriv->write_combine = 1;
235 else
236 fpriv->write_combine = 0;
237 break;
238
239#endif /* HAVE_PCI_MMAP */
240
241 default:
242 ret = -EINVAL;
243 break;
244 };
245
Mathieu Segaudadd77182008-01-10 14:27:12 +0100246 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 return ret;
248}
249
250#ifdef HAVE_PCI_MMAP
251static int proc_bus_pci_mmap(struct file *file, struct vm_area_struct *vma)
252{
Josef Sipek46cc65a2006-12-08 02:37:28 -0800253 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 const struct proc_dir_entry *dp = PDE(inode);
255 struct pci_dev *dev = dp->data;
256 struct pci_filp_private *fpriv = file->private_data;
257 int ret;
258
259 if (!capable(CAP_SYS_RAWIO))
260 return -EPERM;
261
262 ret = pci_mmap_page_range(dev, vma,
263 fpriv->mmap_state,
264 fpriv->write_combine);
265 if (ret < 0)
266 return ret;
267
268 return 0;
269}
270
271static int proc_bus_pci_open(struct inode *inode, struct file *file)
272{
273 struct pci_filp_private *fpriv = kmalloc(sizeof(*fpriv), GFP_KERNEL);
274
275 if (!fpriv)
276 return -ENOMEM;
277
278 fpriv->mmap_state = pci_mmap_io;
279 fpriv->write_combine = 0;
280
281 file->private_data = fpriv;
282
283 return 0;
284}
285
286static int proc_bus_pci_release(struct inode *inode, struct file *file)
287{
288 kfree(file->private_data);
289 file->private_data = NULL;
290
291 return 0;
292}
293#endif /* HAVE_PCI_MMAP */
294
Arjan van de Vend54b1fd2007-02-12 00:55:34 -0800295static const struct file_operations proc_bus_pci_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 .llseek = proc_bus_pci_lseek,
297 .read = proc_bus_pci_read,
298 .write = proc_bus_pci_write,
Mathieu Segaudadd77182008-01-10 14:27:12 +0100299 .unlocked_ioctl = proc_bus_pci_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300#ifdef HAVE_PCI_MMAP
301 .open = proc_bus_pci_open,
302 .release = proc_bus_pci_release,
303 .mmap = proc_bus_pci_mmap,
304#ifdef HAVE_ARCH_PCI_GET_UNMAPPED_AREA
305 .get_unmapped_area = get_pci_unmapped_area,
306#endif /* HAVE_ARCH_PCI_GET_UNMAPPED_AREA */
307#endif /* HAVE_PCI_MMAP */
308};
309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310/* iterator */
311static void *pci_seq_start(struct seq_file *m, loff_t *pos)
312{
313 struct pci_dev *dev = NULL;
314 loff_t n = *pos;
315
316 for_each_pci_dev(dev) {
317 if (!n--)
318 break;
319 }
320 return dev;
321}
322
323static void *pci_seq_next(struct seq_file *m, void *v, loff_t *pos)
324{
325 struct pci_dev *dev = v;
326
327 (*pos)++;
328 dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev);
329 return dev;
330}
331
332static void pci_seq_stop(struct seq_file *m, void *v)
333{
334 if (v) {
335 struct pci_dev *dev = v;
336 pci_dev_put(dev);
337 }
338}
339
340static int show_device(struct seq_file *m, void *v)
341{
342 const struct pci_dev *dev = v;
343 const struct pci_driver *drv;
344 int i;
345
346 if (dev == NULL)
347 return 0;
348
349 drv = pci_dev_driver(dev);
350 seq_printf(m, "%02x%02x\t%04x%04x\t%x",
351 dev->bus->number,
352 dev->devfn,
353 dev->vendor,
354 dev->device,
355 dev->irq);
356 /* Here should be 7 and not PCI_NUM_RESOURCES as we need to preserve compatibility */
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000357 for (i=0; i<7; i++) {
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -0700358 resource_size_t start, end;
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000359 pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
Greg Kroah-Hartman1396a8c2006-06-12 15:14:29 -0700360 seq_printf(m, "\t%16llx",
361 (unsigned long long)(start |
362 (dev->resource[i].flags & PCI_REGION_FLAG_MASK)));
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000363 }
364 for (i=0; i<7; i++) {
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -0700365 resource_size_t start, end;
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000366 pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
Greg Kroah-Hartman1396a8c2006-06-12 15:14:29 -0700367 seq_printf(m, "\t%16llx",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 dev->resource[i].start < dev->resource[i].end ?
Greg Kroah-Hartman1396a8c2006-06-12 15:14:29 -0700369 (unsigned long long)(end - start) + 1 : 0);
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000370 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 seq_putc(m, '\t');
372 if (drv)
373 seq_printf(m, "%s", drv->name);
374 seq_putc(m, '\n');
375 return 0;
376}
377
Jan Engelhardt02d90fc2008-01-22 20:53:43 +0100378static const struct seq_operations proc_bus_pci_devices_op = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 .start = pci_seq_start,
380 .next = pci_seq_next,
381 .stop = pci_seq_stop,
382 .show = show_device
383};
384
385static struct proc_dir_entry *proc_bus_pci_dir;
386
387int pci_proc_attach_device(struct pci_dev *dev)
388{
389 struct pci_bus *bus = dev->bus;
390 struct proc_dir_entry *e;
391 char name[16];
392
393 if (!proc_initialized)
394 return -EACCES;
395
396 if (!bus->procdir) {
397 if (pci_proc_domain(bus)) {
398 sprintf(name, "%04x:%02x", pci_domain_nr(bus),
399 bus->number);
400 } else {
401 sprintf(name, "%02x", bus->number);
402 }
403 bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
404 if (!bus->procdir)
405 return -ENOMEM;
406 }
407
408 sprintf(name, "%02x.%x", PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
409 e = create_proc_entry(name, S_IFREG | S_IRUGO | S_IWUSR, bus->procdir);
410 if (!e)
411 return -ENOMEM;
412 e->proc_fops = &proc_bus_pci_operations;
413 e->data = dev;
414 e->size = dev->cfg_size;
415 dev->procent = e;
416
417 return 0;
418}
419
420int pci_proc_detach_device(struct pci_dev *dev)
421{
422 struct proc_dir_entry *e;
423
424 if ((e = dev->procent)) {
Kenji Kaneshige79df4c62008-02-21 15:24:16 +0900425 if (atomic_read(&e->count) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 return -EBUSY;
427 remove_proc_entry(e->name, dev->bus->procdir);
428 dev->procent = NULL;
429 }
430 return 0;
431}
432
Adrian Bunk54c762f2005-12-22 01:08:52 +0100433#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434int pci_proc_attach_bus(struct pci_bus* bus)
435{
436 struct proc_dir_entry *de = bus->procdir;
437
438 if (!proc_initialized)
439 return -EACCES;
440
441 if (!de) {
442 char name[16];
443 sprintf(name, "%02x", bus->number);
444 de = bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
445 if (!de)
446 return -ENOMEM;
447 }
448 return 0;
449}
Adrian Bunk54c762f2005-12-22 01:08:52 +0100450#endif /* 0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
452int pci_proc_detach_bus(struct pci_bus* bus)
453{
454 struct proc_dir_entry *de = bus->procdir;
455 if (de)
456 remove_proc_entry(de->name, proc_bus_pci_dir);
457 return 0;
458}
459
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460static int proc_bus_pci_dev_open(struct inode *inode, struct file *file)
461{
462 return seq_open(file, &proc_bus_pci_devices_op);
463}
Arjan van de Vend54b1fd2007-02-12 00:55:34 -0800464static const struct file_operations proc_bus_pci_dev_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 .open = proc_bus_pci_dev_open,
466 .read = seq_read,
467 .llseek = seq_lseek,
468 .release = seq_release,
469};
470
471static int __init pci_proc_init(void)
472{
473 struct proc_dir_entry *entry;
474 struct pci_dev *dev = NULL;
475 proc_bus_pci_dir = proc_mkdir("pci", proc_bus);
476 entry = create_proc_entry("devices", 0, proc_bus_pci_dir);
477 if (entry)
478 entry->proc_fops = &proc_bus_pci_dev_operations;
479 proc_initialized = 1;
480 while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
481 pci_proc_attach_device(dev);
482 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 return 0;
484}
485
486__initcall(pci_proc_init);
487