1/*
2 *	$Id: proc.c,v 1.1.1.1 2007/08/03 18:52:51 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
15#include <asm/uaccess.h>
16#include <asm/byteorder.h>
17#include "pci.h"
18
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;
25	struct inode *inode = file->f_path.dentry->d_inode;
26
27	mutex_lock(&inode->i_mutex);
28	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;
43	mutex_unlock(&inode->i_mutex);
44	return new;
45}
46
47static ssize_t
48proc_bus_pci_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
49{
50	const struct inode *ino = file->f_path.dentry->d_inode;
51	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;
82		pci_user_read_config_byte(dev, pos, &val);
83		__put_user(val, buf);
84		buf++;
85		pos++;
86		cnt--;
87	}
88
89	if ((pos & 3) && cnt > 2) {
90		unsigned short val;
91		pci_user_read_config_word(dev, pos, &val);
92		__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;
100		pci_user_read_config_dword(dev, pos, &val);
101		__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;
109		pci_user_read_config_word(dev, pos, &val);
110		__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;
118		pci_user_read_config_byte(dev, pos, &val);
119		__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{
132	const struct inode *ino = file->f_path.dentry->d_inode;
133	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);
153		pci_user_write_config_byte(dev, pos, val);
154		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);
162		pci_user_write_config_word(dev, pos, le16_to_cpu(val));
163		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);
171		pci_user_write_config_dword(dev, pos, le32_to_cpu(val));
172		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);
180		pci_user_write_config_word(dev, pos, le16_to_cpu(val));
181		buf += 2;
182		pos += 2;
183		cnt -= 2;
184	}
185
186	if (cnt) {
187		unsigned char val;
188		__get_user(val, buf);
189		pci_user_write_config_byte(dev, pos, val);
190		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{
247	struct inode *inode = file->f_path.dentry->d_inode;
248	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
289static const struct file_operations proc_bus_pci_operations = {
290	.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
304/* 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 */
351	for (i=0; i<7; i++) {
352		resource_size_t start, end;
353		pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
354		seq_printf(m, "\t%16llx",
355			(unsigned long long)(start |
356			(dev->resource[i].flags & PCI_REGION_FLAG_MASK)));
357	}
358	for (i=0; i<7; i++) {
359		resource_size_t start, end;
360		pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
361		seq_printf(m, "\t%16llx",
362			dev->resource[i].start < dev->resource[i].end ?
363			(unsigned long long)(end - start) + 1 : 0);
364	}
365	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
427
428int pci_proc_detach_bus(struct pci_bus* bus)
429{
430	struct proc_dir_entry *de = bus->procdir;
431	if (de)
432		remove_proc_entry(de->name, proc_bus_pci_dir);
433	return 0;
434}
435
436static int proc_bus_pci_dev_open(struct inode *inode, struct file *file)
437{
438	return seq_open(file, &proc_bus_pci_devices_op);
439}
440static const struct file_operations proc_bus_pci_dev_operations = {
441	.open		= proc_bus_pci_dev_open,
442	.read		= seq_read,
443	.llseek		= seq_lseek,
444	.release	= seq_release,
445};
446
447static int __init pci_proc_init(void)
448{
449	struct proc_dir_entry *entry;
450	struct pci_dev *dev = NULL;
451	proc_bus_pci_dir = proc_mkdir("pci", proc_bus);
452	entry = create_proc_entry("devices", 0, proc_bus_pci_dir);
453	if (entry)
454		entry->proc_fops = &proc_bus_pci_dev_operations;
455	proc_initialized = 1;
456	while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
457		pci_proc_attach_device(dev);
458	}
459	return 0;
460}
461
462__initcall(pci_proc_init);
463
464#ifdef CONFIG_HOTPLUG
465EXPORT_SYMBOL(pci_proc_attach_device);
466EXPORT_SYMBOL(pci_proc_detach_bus);
467#endif
468