proc.c revision 496ad9aa8ef448058e36ca7a787c61f2e63f0f54 
1/*
2 * /proc/bus/pnp interface for Plug and Play devices
3 *
4 * Written by David Hinds, dahinds@users.sourceforge.net
5 * Modified by Thomas Hood
6 *
7 * The .../devices and .../<node> and .../boot/<node> files are
8 * utilized by the lspnp and setpnp utilities, supplied with the
9 * pcmcia-cs package.
10 *     http://pcmcia-cs.sourceforge.net
11 *
12 * The .../escd file is utilized by the lsescd utility written by
13 * Gunther Mayer.
14 *
15 * The .../legacy_device_resources file is not used yet.
16 *
17 * The other files are human-readable.
18 */
19
20#include <linux/module.h>
21#include <linux/kernel.h>
22#include <linux/slab.h>
23#include <linux/types.h>
24#include <linux/proc_fs.h>
25#include <linux/pnp.h>
26#include <linux/seq_file.h>
27#include <linux/init.h>
28
29#include <asm/uaccess.h>
30
31#include "pnpbios.h"
32
33static struct proc_dir_entry *proc_pnp = NULL;
34static struct proc_dir_entry *proc_pnp_boot = NULL;
35
36static int pnpconfig_proc_show(struct seq_file *m, void *v)
37{
38	struct pnp_isa_config_struc pnps;
39
40	if (pnp_bios_isapnp_config(&pnps))
41		return -EIO;
42	seq_printf(m, "structure_revision %d\n"
43		      "number_of_CSNs %d\n"
44		      "ISA_read_data_port 0x%x\n",
45		   pnps.revision, pnps.no_csns, pnps.isa_rd_data_port);
46	return 0;
47}
48
49static int pnpconfig_proc_open(struct inode *inode, struct file *file)
50{
51	return single_open(file, pnpconfig_proc_show, NULL);
52}
53
54static const struct file_operations pnpconfig_proc_fops = {
55	.owner		= THIS_MODULE,
56	.open		= pnpconfig_proc_open,
57	.read		= seq_read,
58	.llseek		= seq_lseek,
59	.release	= single_release,
60};
61
62static int escd_info_proc_show(struct seq_file *m, void *v)
63{
64	struct escd_info_struc escd;
65
66	if (pnp_bios_escd_info(&escd))
67		return -EIO;
68	seq_printf(m, "min_ESCD_write_size %d\n"
69			"ESCD_size %d\n"
70			"NVRAM_base 0x%x\n",
71			escd.min_escd_write_size,
72			escd.escd_size, escd.nv_storage_base);
73	return 0;
74}
75
76static int escd_info_proc_open(struct inode *inode, struct file *file)
77{
78	return single_open(file, escd_info_proc_show, NULL);
79}
80
81static const struct file_operations escd_info_proc_fops = {
82	.owner		= THIS_MODULE,
83	.open		= escd_info_proc_open,
84	.read		= seq_read,
85	.llseek		= seq_lseek,
86	.release	= single_release,
87};
88
89#define MAX_SANE_ESCD_SIZE (32*1024)
90static int escd_proc_show(struct seq_file *m, void *v)
91{
92	struct escd_info_struc escd;
93	char *tmpbuf;
94	int escd_size;
95
96	if (pnp_bios_escd_info(&escd))
97		return -EIO;
98
99	/* sanity check */
100	if (escd.escd_size > MAX_SANE_ESCD_SIZE) {
101		printk(KERN_ERR
102		       "PnPBIOS: %s: ESCD size reported by BIOS escd_info call is too great\n", __func__);
103		return -EFBIG;
104	}
105
106	tmpbuf = kzalloc(escd.escd_size, GFP_KERNEL);
107	if (!tmpbuf)
108		return -ENOMEM;
109
110	if (pnp_bios_read_escd(tmpbuf, escd.nv_storage_base)) {
111		kfree(tmpbuf);
112		return -EIO;
113	}
114
115	escd_size =
116	    (unsigned char)(tmpbuf[0]) + (unsigned char)(tmpbuf[1]) * 256;
117
118	/* sanity check */
119	if (escd_size > MAX_SANE_ESCD_SIZE) {
120		printk(KERN_ERR "PnPBIOS: %s: ESCD size reported by"
121				" BIOS read_escd call is too great\n", __func__);
122		kfree(tmpbuf);
123		return -EFBIG;
124	}
125
126	seq_write(m, tmpbuf, escd_size);
127	kfree(tmpbuf);
128	return 0;
129}
130
131static int escd_proc_open(struct inode *inode, struct file *file)
132{
133	return single_open(file, escd_proc_show, NULL);
134}
135
136static const struct file_operations escd_proc_fops = {
137	.owner		= THIS_MODULE,
138	.open		= escd_proc_open,
139	.read		= seq_read,
140	.llseek		= seq_lseek,
141	.release	= single_release,
142};
143
144static int pnp_legacyres_proc_show(struct seq_file *m, void *v)
145{
146	void *buf;
147
148	buf = kmalloc(65536, GFP_KERNEL);
149	if (!buf)
150		return -ENOMEM;
151	if (pnp_bios_get_stat_res(buf)) {
152		kfree(buf);
153		return -EIO;
154	}
155
156	seq_write(m, buf, 65536);
157	kfree(buf);
158	return 0;
159}
160
161static int pnp_legacyres_proc_open(struct inode *inode, struct file *file)
162{
163	return single_open(file, pnp_legacyres_proc_show, NULL);
164}
165
166static const struct file_operations pnp_legacyres_proc_fops = {
167	.owner		= THIS_MODULE,
168	.open		= pnp_legacyres_proc_open,
169	.read		= seq_read,
170	.llseek		= seq_lseek,
171	.release	= single_release,
172};
173
174static int pnp_devices_proc_show(struct seq_file *m, void *v)
175{
176	struct pnp_bios_node *node;
177	u8 nodenum;
178
179	node = kzalloc(node_info.max_node_size, GFP_KERNEL);
180	if (!node)
181		return -ENOMEM;
182
183	for (nodenum = 0; nodenum < 0xff;) {
184		u8 thisnodenum = nodenum;
185
186		if (pnp_bios_get_dev_node(&nodenum, PNPMODE_DYNAMIC, node))
187			break;
188		seq_printf(m, "%02x\t%08x\t%02x:%02x:%02x\t%04x\n",
189			     node->handle, node->eisa_id,
190			     node->type_code[0], node->type_code[1],
191			     node->type_code[2], node->flags);
192		if (nodenum <= thisnodenum) {
193			printk(KERN_ERR
194			       "%s Node number 0x%x is out of sequence following node 0x%x. Aborting.\n",
195			       "PnPBIOS: proc_read_devices:",
196			       (unsigned int)nodenum,
197			       (unsigned int)thisnodenum);
198			break;
199		}
200	}
201	kfree(node);
202	return 0;
203}
204
205static int pnp_devices_proc_open(struct inode *inode, struct file *file)
206{
207	return single_open(file, pnp_devices_proc_show, NULL);
208}
209
210static const struct file_operations pnp_devices_proc_fops = {
211	.owner		= THIS_MODULE,
212	.open		= pnp_devices_proc_open,
213	.read		= seq_read,
214	.llseek		= seq_lseek,
215	.release	= single_release,
216};
217
218static int pnpbios_proc_show(struct seq_file *m, void *v)
219{
220	void *data = m->private;
221	struct pnp_bios_node *node;
222	int boot = (long)data >> 8;
223	u8 nodenum = (long)data;
224	int len;
225
226	node = kzalloc(node_info.max_node_size, GFP_KERNEL);
227	if (!node)
228		return -ENOMEM;
229	if (pnp_bios_get_dev_node(&nodenum, boot, node)) {
230		kfree(node);
231		return -EIO;
232	}
233	len = node->size - sizeof(struct pnp_bios_node);
234	seq_write(m, node->data, len);
235	kfree(node);
236	return 0;
237}
238
239static int pnpbios_proc_open(struct inode *inode, struct file *file)
240{
241	return single_open(file, pnpbios_proc_show, PDE(inode)->data);
242}
243
244static ssize_t pnpbios_proc_write(struct file *file, const char __user *buf,
245				  size_t count, loff_t *pos)
246{
247	void *data = PDE(file_inode(file))->data;
248	struct pnp_bios_node *node;
249	int boot = (long)data >> 8;
250	u8 nodenum = (long)data;
251	int ret = count;
252
253	node = kzalloc(node_info.max_node_size, GFP_KERNEL);
254	if (!node)
255		return -ENOMEM;
256	if (pnp_bios_get_dev_node(&nodenum, boot, node)) {
257		ret = -EIO;
258		goto out;
259	}
260	if (count != node->size - sizeof(struct pnp_bios_node)) {
261		ret = -EINVAL;
262		goto out;
263	}
264	if (copy_from_user(node->data, buf, count)) {
265		ret = -EFAULT;
266		goto out;
267	}
268	if (pnp_bios_set_dev_node(node->handle, boot, node) != 0) {
269		ret = -EINVAL;
270		goto out;
271	}
272	ret = count;
273out:
274	kfree(node);
275	return ret;
276}
277
278static const struct file_operations pnpbios_proc_fops = {
279	.owner		= THIS_MODULE,
280	.open		= pnpbios_proc_open,
281	.read		= seq_read,
282	.llseek		= seq_lseek,
283	.release	= single_release,
284	.write		= pnpbios_proc_write,
285};
286
287int pnpbios_interface_attach_device(struct pnp_bios_node *node)
288{
289	char name[3];
290
291	sprintf(name, "%02x", node->handle);
292
293	if (!proc_pnp)
294		return -EIO;
295	if (!pnpbios_dont_use_current_config) {
296		proc_create_data(name, 0644, proc_pnp, &pnpbios_proc_fops,
297				 (void *)(long)(node->handle));
298	}
299
300	if (!proc_pnp_boot)
301		return -EIO;
302	if (proc_create_data(name, 0644, proc_pnp_boot, &pnpbios_proc_fops,
303			     (void *)(long)(node->handle + 0x100)))
304		return 0;
305	return -EIO;
306}
307
308/*
309 * When this is called, pnpbios functions are assumed to
310 * work and the pnpbios_dont_use_current_config flag
311 * should already have been set to the appropriate value
312 */
313int __init pnpbios_proc_init(void)
314{
315	proc_pnp = proc_mkdir("bus/pnp", NULL);
316	if (!proc_pnp)
317		return -EIO;
318	proc_pnp_boot = proc_mkdir("boot", proc_pnp);
319	if (!proc_pnp_boot)
320		return -EIO;
321	proc_create("devices", 0, proc_pnp, &pnp_devices_proc_fops);
322	proc_create("configuration_info", 0, proc_pnp, &pnpconfig_proc_fops);
323	proc_create("escd_info", 0, proc_pnp, &escd_info_proc_fops);
324	proc_create("escd", S_IRUSR, proc_pnp, &escd_proc_fops);
325	proc_create("legacy_device_resources", 0, proc_pnp, &pnp_legacyres_proc_fops);
326
327	return 0;
328}
329
330void __exit pnpbios_proc_exit(void)
331{
332	int i;
333	char name[3];
334
335	if (!proc_pnp)
336		return;
337
338	for (i = 0; i < 0xff; i++) {
339		sprintf(name, "%02x", i);
340		if (!pnpbios_dont_use_current_config)
341			remove_proc_entry(name, proc_pnp);
342		remove_proc_entry(name, proc_pnp_boot);
343	}
344	remove_proc_entry("legacy_device_resources", proc_pnp);
345	remove_proc_entry("escd", proc_pnp);
346	remove_proc_entry("escd_info", proc_pnp);
347	remove_proc_entry("configuration_info", proc_pnp);
348	remove_proc_entry("devices", proc_pnp);
349	remove_proc_entry("boot", proc_pnp);
350	remove_proc_entry("bus/pnp", NULL);
351}
352