?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] w1: Make w1 connector notifications depend on connector.
[linux-2.6/verdex.git] / drivers / pci / proc.c
blob54b2ebc9c91a4b4e18dead4f363b0c9c5150d2a5
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@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>
18 #include "pci.h"
19
20 static int proc_initialized; /* = 0 */
21
22 static loff_t
23 proc_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
28 mutex_lock(&inode->i_mutex);
29 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;
44 mutex_unlock(&inode->i_mutex);
45 return new;
46 }
47
48 static ssize_t
49 proc_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;
83 pci_user_read_config_byte(dev, pos, &val);
84 __put_user(val, buf);
85 buf++;
86 pos++;
87 cnt--;
88 }
89
90 if ((pos & 3) && cnt > 2) {
91 unsigned short val;
92 pci_user_read_config_word(dev, pos, &val);
93 __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;
101 pci_user_read_config_dword(dev, pos, &val);
102 __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;
110 pci_user_read_config_word(dev, pos, &val);
111 __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;
119 pci_user_read_config_byte(dev, pos, &val);
120 __put_user(val, buf);
121 buf++;
122 pos++;
123 cnt--;
124 }
125
126 *ppos = pos;
127 return nbytes;
128 }
129
130 static ssize_t
131 proc_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);
154 pci_user_write_config_byte(dev, pos, val);
155 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);
163 pci_user_write_config_word(dev, pos, le16_to_cpu(val));
164 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);
172 pci_user_write_config_dword(dev, pos, le32_to_cpu(val));
173 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);
181 pci_user_write_config_word(dev, pos, le16_to_cpu(val));
182 buf += 2;
183 pos += 2;
184 cnt -= 2;
185 }
186
187 if (cnt) {
188 unsigned char val;
189 __get_user(val, buf);
190 pci_user_write_config_byte(dev, pos, val);
191 buf++;
192 pos++;
193 cnt--;
194 }
195
196 *ppos = pos;
197 return nbytes;
198 }
199
200 struct pci_filp_private {
201 enum pci_mmap_state mmap_state;
202 int write_combine;
203 };
204
205 static 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
246 static 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
266 static 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
281 static 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
290 static 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 */
312 static 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
324 static 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
333 static 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
341 static 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 */
358 for (i=0; i<7; i++) {
359 u64 start, end;
360 pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
361 seq_printf(m, LONG_FORMAT,
362 ((unsigned long)start) |
363 (dev->resource[i].flags & PCI_REGION_FLAG_MASK));
364 }
365 for (i=0; i<7; i++) {
366 u64 start, end;
367 pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
368 seq_printf(m, LONG_FORMAT,
369 dev->resource[i].start < dev->resource[i].end ?
370 (unsigned long)(end - start) + 1 : 0);
371 }
372 seq_putc(m, '\t');
373 if (drv)
374 seq_printf(m, "%s", drv->name);
375 seq_putc(m, '\n');
376 return 0;
377 }
378
379 static 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
386 static struct proc_dir_entry *proc_bus_pci_dir;
387
388 int 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
421 int 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
434 #if 0
435 int 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 }
451 #endif /* 0 */
452
453 int 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 static int proc_bus_pci_dev_open(struct inode *inode, struct file *file)
462 {
463 return seq_open(file, &proc_bus_pci_devices_op);
464 }
465 static struct file_operations proc_bus_pci_dev_operations = {
466 .open = proc_bus_pci_dev_open,
467 .read = seq_read,
468 .llseek = seq_lseek,
469 .release = seq_release,
470 };
471
472 static int __init pci_proc_init(void)
473 {
474 struct proc_dir_entry *entry;
475 struct pci_dev *dev = NULL;
476 proc_bus_pci_dir = proc_mkdir("pci", proc_bus);
477 entry = create_proc_entry("devices", 0, proc_bus_pci_dir);
478 if (entry)
479 entry->proc_fops = &proc_bus_pci_dev_operations;
480 proc_initialized = 1;
481 while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
482 pci_proc_attach_device(dev);
483 }
484 return 0;
485 }
486
487 __initcall(pci_proc_init);
488
489 #ifdef CONFIG_HOTPLUG
490 EXPORT_SYMBOL(pci_proc_attach_device);
491 EXPORT_SYMBOL(pci_proc_detach_bus);
492 #endif
493
Verdex Pro support