Loading...
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%3phC\t%04x\n",
189 node->handle, node->eisa_id,
190 node->type_code, node->flags);
191 if (nodenum <= thisnodenum) {
192 printk(KERN_ERR
193 "%s Node number 0x%x is out of sequence following node 0x%x. Aborting.\n",
194 "PnPBIOS: proc_read_devices:",
195 (unsigned int)nodenum,
196 (unsigned int)thisnodenum);
197 break;
198 }
199 }
200 kfree(node);
201 return 0;
202}
203
204static int pnp_devices_proc_open(struct inode *inode, struct file *file)
205{
206 return single_open(file, pnp_devices_proc_show, NULL);
207}
208
209static const struct file_operations pnp_devices_proc_fops = {
210 .owner = THIS_MODULE,
211 .open = pnp_devices_proc_open,
212 .read = seq_read,
213 .llseek = seq_lseek,
214 .release = single_release,
215};
216
217static int pnpbios_proc_show(struct seq_file *m, void *v)
218{
219 void *data = m->private;
220 struct pnp_bios_node *node;
221 int boot = (long)data >> 8;
222 u8 nodenum = (long)data;
223 int len;
224
225 node = kzalloc(node_info.max_node_size, GFP_KERNEL);
226 if (!node)
227 return -ENOMEM;
228 if (pnp_bios_get_dev_node(&nodenum, boot, node)) {
229 kfree(node);
230 return -EIO;
231 }
232 len = node->size - sizeof(struct pnp_bios_node);
233 seq_write(m, node->data, len);
234 kfree(node);
235 return 0;
236}
237
238static int pnpbios_proc_open(struct inode *inode, struct file *file)
239{
240 return single_open(file, pnpbios_proc_show, PDE_DATA(inode));
241}
242
243static ssize_t pnpbios_proc_write(struct file *file, const char __user *buf,
244 size_t count, loff_t *pos)
245{
246 void *data = PDE_DATA(file_inode(file));
247 struct pnp_bios_node *node;
248 int boot = (long)data >> 8;
249 u8 nodenum = (long)data;
250 int ret = count;
251
252 node = kzalloc(node_info.max_node_size, GFP_KERNEL);
253 if (!node)
254 return -ENOMEM;
255 if (pnp_bios_get_dev_node(&nodenum, boot, node)) {
256 ret = -EIO;
257 goto out;
258 }
259 if (count != node->size - sizeof(struct pnp_bios_node)) {
260 ret = -EINVAL;
261 goto out;
262 }
263 if (copy_from_user(node->data, buf, count)) {
264 ret = -EFAULT;
265 goto out;
266 }
267 if (pnp_bios_set_dev_node(node->handle, boot, node) != 0) {
268 ret = -EINVAL;
269 goto out;
270 }
271 ret = count;
272out:
273 kfree(node);
274 return ret;
275}
276
277static const struct file_operations pnpbios_proc_fops = {
278 .owner = THIS_MODULE,
279 .open = pnpbios_proc_open,
280 .read = seq_read,
281 .llseek = seq_lseek,
282 .release = single_release,
283 .write = pnpbios_proc_write,
284};
285
286int pnpbios_interface_attach_device(struct pnp_bios_node *node)
287{
288 char name[3];
289
290 sprintf(name, "%02x", node->handle);
291
292 if (!proc_pnp)
293 return -EIO;
294 if (!pnpbios_dont_use_current_config) {
295 proc_create_data(name, 0644, proc_pnp, &pnpbios_proc_fops,
296 (void *)(long)(node->handle));
297 }
298
299 if (!proc_pnp_boot)
300 return -EIO;
301 if (proc_create_data(name, 0644, proc_pnp_boot, &pnpbios_proc_fops,
302 (void *)(long)(node->handle + 0x100)))
303 return 0;
304 return -EIO;
305}
306
307/*
308 * When this is called, pnpbios functions are assumed to
309 * work and the pnpbios_dont_use_current_config flag
310 * should already have been set to the appropriate value
311 */
312int __init pnpbios_proc_init(void)
313{
314 proc_pnp = proc_mkdir("bus/pnp", NULL);
315 if (!proc_pnp)
316 return -EIO;
317 proc_pnp_boot = proc_mkdir("boot", proc_pnp);
318 if (!proc_pnp_boot)
319 return -EIO;
320 proc_create("devices", 0, proc_pnp, &pnp_devices_proc_fops);
321 proc_create("configuration_info", 0, proc_pnp, &pnpconfig_proc_fops);
322 proc_create("escd_info", 0, proc_pnp, &escd_info_proc_fops);
323 proc_create("escd", S_IRUSR, proc_pnp, &escd_proc_fops);
324 proc_create("legacy_device_resources", 0, proc_pnp, &pnp_legacyres_proc_fops);
325
326 return 0;
327}
328
329void __exit pnpbios_proc_exit(void)
330{
331 int i;
332 char name[3];
333
334 if (!proc_pnp)
335 return;
336
337 for (i = 0; i < 0xff; i++) {
338 sprintf(name, "%02x", i);
339 if (!pnpbios_dont_use_current_config)
340 remove_proc_entry(name, proc_pnp);
341 remove_proc_entry(name, proc_pnp_boot);
342 }
343 remove_proc_entry("legacy_device_resources", proc_pnp);
344 remove_proc_entry("escd", proc_pnp);
345 remove_proc_entry("escd_info", proc_pnp);
346 remove_proc_entry("configuration_info", proc_pnp);
347 remove_proc_entry("devices", proc_pnp);
348 remove_proc_entry("boot", proc_pnp);
349 remove_proc_entry("bus/pnp", NULL);
350}
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->f_path.dentry->d_inode)->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}