blob: 0425a7b7350d987760bfff76cbd0e0af6d311800 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014
15#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))
63 size = dev->cfg_size;
64 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 __put_user(cpu_to_le16(val), (unsigned short __user *) buf);
93 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 __put_user(cpu_to_le32(val), (unsigned int __user *) buf);
102 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 __put_user(cpu_to_le16(val), (unsigned short __user *) buf);
111 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{
Josef Sipek46cc65a2006-12-08 02:37:28 -0800132 const 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;
136 int size = dev->cfg_size;
137 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) {
160 unsigned short val;
161 __get_user(val, (unsigned short __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) {
169 unsigned int val;
170 __get_user(val, (unsigned int __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) {
178 unsigned short val;
179 __get_user(val, (unsigned short __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;
196 return nbytes;
197}
198
199struct pci_filp_private {
200 enum pci_mmap_state mmap_state;
201 int write_combine;
202};
203
204static int proc_bus_pci_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
205{
206 const struct proc_dir_entry *dp = PDE(inode);
207 struct pci_dev *dev = dp->data;
208#ifdef HAVE_PCI_MMAP
209 struct pci_filp_private *fpriv = file->private_data;
210#endif /* HAVE_PCI_MMAP */
211 int ret = 0;
212
213 switch (cmd) {
214 case PCIIOC_CONTROLLER:
215 ret = pci_domain_nr(dev->bus);
216 break;
217
218#ifdef HAVE_PCI_MMAP
219 case PCIIOC_MMAP_IS_IO:
220 fpriv->mmap_state = pci_mmap_io;
221 break;
222
223 case PCIIOC_MMAP_IS_MEM:
224 fpriv->mmap_state = pci_mmap_mem;
225 break;
226
227 case PCIIOC_WRITE_COMBINE:
228 if (arg)
229 fpriv->write_combine = 1;
230 else
231 fpriv->write_combine = 0;
232 break;
233
234#endif /* HAVE_PCI_MMAP */
235
236 default:
237 ret = -EINVAL;
238 break;
239 };
240
241 return ret;
242}
243
244#ifdef HAVE_PCI_MMAP
245static int proc_bus_pci_mmap(struct file *file, struct vm_area_struct *vma)
246{
Josef Sipek46cc65a2006-12-08 02:37:28 -0800247 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 const struct proc_dir_entry *dp = PDE(inode);
249 struct pci_dev *dev = dp->data;
250 struct pci_filp_private *fpriv = file->private_data;
251 int ret;
252
253 if (!capable(CAP_SYS_RAWIO))
254 return -EPERM;
255
256 ret = pci_mmap_page_range(dev, vma,
257 fpriv->mmap_state,
258 fpriv->write_combine);
259 if (ret < 0)
260 return ret;
261
262 return 0;
263}
264
265static int proc_bus_pci_open(struct inode *inode, struct file *file)
266{
267 struct pci_filp_private *fpriv = kmalloc(sizeof(*fpriv), GFP_KERNEL);
268
269 if (!fpriv)
270 return -ENOMEM;
271
272 fpriv->mmap_state = pci_mmap_io;
273 fpriv->write_combine = 0;
274
275 file->private_data = fpriv;
276
277 return 0;
278}
279
280static int proc_bus_pci_release(struct inode *inode, struct file *file)
281{
282 kfree(file->private_data);
283 file->private_data = NULL;
284
285 return 0;
286}
287#endif /* HAVE_PCI_MMAP */
288
Arjan van de Vend54b1fd2007-02-12 00:55:34 -0800289static const struct file_operations proc_bus_pci_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 .llseek = proc_bus_pci_lseek,
291 .read = proc_bus_pci_read,
292 .write = proc_bus_pci_write,
293 .ioctl = proc_bus_pci_ioctl,
294#ifdef HAVE_PCI_MMAP
295 .open = proc_bus_pci_open,
296 .release = proc_bus_pci_release,
297 .mmap = proc_bus_pci_mmap,
298#ifdef HAVE_ARCH_PCI_GET_UNMAPPED_AREA
299 .get_unmapped_area = get_pci_unmapped_area,
300#endif /* HAVE_ARCH_PCI_GET_UNMAPPED_AREA */
301#endif /* HAVE_PCI_MMAP */
302};
303
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304/* iterator */
305static void *pci_seq_start(struct seq_file *m, loff_t *pos)
306{
307 struct pci_dev *dev = NULL;
308 loff_t n = *pos;
309
310 for_each_pci_dev(dev) {
311 if (!n--)
312 break;
313 }
314 return dev;
315}
316
317static void *pci_seq_next(struct seq_file *m, void *v, loff_t *pos)
318{
319 struct pci_dev *dev = v;
320
321 (*pos)++;
322 dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev);
323 return dev;
324}
325
326static void pci_seq_stop(struct seq_file *m, void *v)
327{
328 if (v) {
329 struct pci_dev *dev = v;
330 pci_dev_put(dev);
331 }
332}
333
334static int show_device(struct seq_file *m, void *v)
335{
336 const struct pci_dev *dev = v;
337 const struct pci_driver *drv;
338 int i;
339
340 if (dev == NULL)
341 return 0;
342
343 drv = pci_dev_driver(dev);
344 seq_printf(m, "%02x%02x\t%04x%04x\t%x",
345 dev->bus->number,
346 dev->devfn,
347 dev->vendor,
348 dev->device,
349 dev->irq);
350 /* Here should be 7 and not PCI_NUM_RESOURCES as we need to preserve compatibility */
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000351 for (i=0; i<7; i++) {
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -0700352 resource_size_t start, end;
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000353 pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
Greg Kroah-Hartman1396a8c2006-06-12 15:14:29 -0700354 seq_printf(m, "\t%16llx",
355 (unsigned long long)(start |
356 (dev->resource[i].flags & PCI_REGION_FLAG_MASK)));
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000357 }
358 for (i=0; i<7; i++) {
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -0700359 resource_size_t start, end;
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000360 pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
Greg Kroah-Hartman1396a8c2006-06-12 15:14:29 -0700361 seq_printf(m, "\t%16llx",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 dev->resource[i].start < dev->resource[i].end ?
Greg Kroah-Hartman1396a8c2006-06-12 15:14:29 -0700363 (unsigned long long)(end - start) + 1 : 0);
Michael Ellerman2311b1f2005-05-13 17:44:10 +1000364 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 seq_putc(m, '\t');
366 if (drv)
367 seq_printf(m, "%s", drv->name);
368 seq_putc(m, '\n');
369 return 0;
370}
371
372static struct seq_operations proc_bus_pci_devices_op = {
373 .start = pci_seq_start,
374 .next = pci_seq_next,
375 .stop = pci_seq_stop,
376 .show = show_device
377};
378
379static struct proc_dir_entry *proc_bus_pci_dir;
380
381int pci_proc_attach_device(struct pci_dev *dev)
382{
383 struct pci_bus *bus = dev->bus;
384 struct proc_dir_entry *e;
385 char name[16];
386
387 if (!proc_initialized)
388 return -EACCES;
389
390 if (!bus->procdir) {
391 if (pci_proc_domain(bus)) {
392 sprintf(name, "%04x:%02x", pci_domain_nr(bus),
393 bus->number);
394 } else {
395 sprintf(name, "%02x", bus->number);
396 }
397 bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
398 if (!bus->procdir)
399 return -ENOMEM;
400 }
401
402 sprintf(name, "%02x.%x", PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
403 e = create_proc_entry(name, S_IFREG | S_IRUGO | S_IWUSR, bus->procdir);
404 if (!e)
405 return -ENOMEM;
406 e->proc_fops = &proc_bus_pci_operations;
407 e->data = dev;
408 e->size = dev->cfg_size;
409 dev->procent = e;
410
411 return 0;
412}
413
414int pci_proc_detach_device(struct pci_dev *dev)
415{
416 struct proc_dir_entry *e;
417
418 if ((e = dev->procent)) {
419 if (atomic_read(&e->count))
420 return -EBUSY;
421 remove_proc_entry(e->name, dev->bus->procdir);
422 dev->procent = NULL;
423 }
424 return 0;
425}
426
Adrian Bunk54c762f2005-12-22 01:08:52 +0100427#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428int pci_proc_attach_bus(struct pci_bus* bus)
429{
430 struct proc_dir_entry *de = bus->procdir;
431
432 if (!proc_initialized)
433 return -EACCES;
434
435 if (!de) {
436 char name[16];
437 sprintf(name, "%02x", bus->number);
438 de = bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
439 if (!de)
440 return -ENOMEM;
441 }
442 return 0;
443}
Adrian Bunk54c762f2005-12-22 01:08:52 +0100444#endif /* 0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
446int pci_proc_detach_bus(struct pci_bus* bus)
447{
448 struct proc_dir_entry *de = bus->procdir;
449 if (de)
450 remove_proc_entry(de->name, proc_bus_pci_dir);
451 return 0;
452}
453
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454static int proc_bus_pci_dev_open(struct inode *inode, struct file *file)
455{
456 return seq_open(file, &proc_bus_pci_devices_op);
457}
Arjan van de Vend54b1fd2007-02-12 00:55:34 -0800458static const struct file_operations proc_bus_pci_dev_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 .open = proc_bus_pci_dev_open,
460 .read = seq_read,
461 .llseek = seq_lseek,
462 .release = seq_release,
463};
464
465static int __init pci_proc_init(void)
466{
467 struct proc_dir_entry *entry;
468 struct pci_dev *dev = NULL;
469 proc_bus_pci_dir = proc_mkdir("pci", proc_bus);
470 entry = create_proc_entry("devices", 0, proc_bus_pci_dir);
471 if (entry)
472 entry->proc_fops = &proc_bus_pci_dev_operations;
473 proc_initialized = 1;
474 while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
475 pci_proc_attach_device(dev);
476 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 return 0;
478}
479
480__initcall(pci_proc_init);
481
482#ifdef CONFIG_HOTPLUG
483EXPORT_SYMBOL(pci_proc_attach_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484EXPORT_SYMBOL(pci_proc_detach_bus);
485#endif
486