1 /*
2 * pnpbios -- PnP BIOS driver
3 *
4 * This driver provides access to Plug-'n'-Play services provided by
5 * the PnP BIOS firmware, described in the following documents:
6 * Plug and Play BIOS Specification, Version 1.0A, 5 May 1994
7 * Plug and Play BIOS Clarification Paper, 6 October 1994
8 * Compaq Computer Corporation, Phoenix Technologies Ltd., Intel Corp.
9 *
10 * Originally (C) 1998 Christian Schmidt <schmidt@digadd.de>
11 * Modifications (C) 1998 Tom Lees <tom@lpsg.demon.co.uk>
12 * Minor reorganizations by David Hinds <dahinds@users.sourceforge.net>
13 * Further modifications (C) 2001, 2002 by:
14 * Alan Cox <alan@redhat.com>
15 * Thomas Hood
16 * Brian Gerst <bgerst@didntduck.org>
17 *
18 * Ported to the PnP Layer and several additional improvements (C) 2002
19 * by Adam Belay <ambx1@neo.rr.com>
20 *
21 * This program is free software; you can redistribute it and/or modify it
22 * under the terms of the GNU General Public License as published by the
23 * Free Software Foundation; either version 2, or (at your option) any
24 * later version.
25 *
26 * This program is distributed in the hope that it will be useful, but
27 * WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
29 * General Public License for more details.
30 *
31 * You should have received a copy of the GNU General Public License
32 * along with this program; if not, write to the Free Software
33 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34 */
35
36 /* Change Log
37 *
38 * Adam Belay - <ambx1@neo.rr.com> - March 16, 2003
39 * rev 1.01 Only call pnp_bios_dev_node_info once
40 * Added pnpbios_print_status
41 * Added several new error messages and info messages
42 * Added pnpbios_interface_attach_device
43 * integrated core and proc init system
44 * Introduced PNPMODE flags
45 * Removed some useless includes
46 */
47
48 #include <linux/types.h>
49 #include <linux/module.h>
50 #include <linux/init.h>
51 #include <linux/linkage.h>
52 #include <linux/kernel.h>
53 #include <linux/pnpbios.h>
54 #include <linux/device.h>
55 #include <linux/pnp.h>
56 #include <linux/mm.h>
57 #include <linux/smp.h>
58 #include <linux/slab.h>
59 #include <linux/completion.h>
60 #include <linux/spinlock.h>
61 #include <linux/dmi.h>
62 #include <linux/delay.h>
63 #include <linux/acpi.h>
64 #include <linux/freezer.h>
65 #include <linux/kthread.h>
66
67 #include <asm/page.h>
68 #include <asm/desc.h>
69 #include <asm/system.h>
70 #include <asm/byteorder.h>
71
72 #include "pnpbios.h"
73
74 /*
75 *
76 * PnP BIOS INTERFACE
77 *
78 */
79
80 static union pnp_bios_install_struct *pnp_bios_install = NULL;
81
82 int pnp_bios_present(void)
83 {
84 return (pnp_bios_install != NULL);
85 }
86
87 struct pnp_dev_node_info node_info;
88
89 /*
90 *
91 * DOCKING FUNCTIONS
92 *
93 */
94
95 #ifdef CONFIG_HOTPLUG
96
97 static int unloading = 0;
98 static struct completion unload_sem;
99
100 /*
101 * (Much of this belongs in a shared routine somewhere)
102 */
103 static int pnp_dock_event(int dock, struct pnp_docking_station_info *info)
104 {
105 char *argv[3], **envp, *buf, *scratch;
106 int i = 0, value;
107
108 if (!(envp = kcalloc(20, sizeof(char *), GFP_KERNEL)))
109 return -ENOMEM;
110 if (!(buf = kzalloc(256, GFP_KERNEL))) {
111 kfree(envp);
112 return -ENOMEM;
113 }
114
115 /* FIXME: if there are actual users of this, it should be
116 * integrated into the driver core and use the usual infrastructure
117 * like sysfs and uevents
118 */
119 argv[0] = "/sbin/pnpbios";
120 argv[1] = "dock";
121 argv[2] = NULL;
122
123 /* minimal command environment */
124 envp[i++] = "HOME=/";
125 envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
126
127 #ifdef DEBUG
128 /* hint that policy agent should enter no-stdout debug mode */
129 envp[i++] = "DEBUG=kernel";
130 #endif
131 /* extensible set of named bus-specific parameters,
132 * supporting multiple driver selection algorithms.
133 */
134 scratch = buf;
135
136 /* action: add, remove */
137 envp[i++] = scratch;
138 scratch += sprintf(scratch, "ACTION=%s", dock ? "add" : "remove") + 1;
139
140 /* Report the ident for the dock */
141 envp[i++] = scratch;
142 scratch += sprintf(scratch, "DOCK=%x/%x/%x",
143 info->location_id, info->serial, info->capabilities);
144 envp[i] = NULL;
145
146 value = call_usermodehelper(argv [0], argv, envp, UMH_WAIT_EXEC);
147 kfree(buf);
148 kfree(envp);
149 return 0;
150 }
151
152 /*
153 * Poll the PnP docking at regular intervals
154 */
155 static int pnp_dock_thread(void *unused)
156 {
157 static struct pnp_docking_station_info now;
158 int docked = -1, d = 0;
159
160 set_freezable();
161 while (!unloading) {
162 int status;
163
164 /*
165 * Poll every 2 seconds
166 */
167 msleep_interruptible(2000);
168
169 if (try_to_freeze())
170 continue;
171
172 status = pnp_bios_dock_station_info(&now);
173
174 switch (status) {
175 /*
176 * No dock to manage
177 */
178 case PNP_FUNCTION_NOT_SUPPORTED:
179 complete_and_exit(&unload_sem, 0);
180 case PNP_SYSTEM_NOT_DOCKED:
181 d = 0;
182 break;
183 case PNP_SUCCESS:
184 d = 1;
185 break;
186 default:
187 pnpbios_print_status("pnp_dock_thread", status);
188 continue;
189 }
190 if (d != docked) {
191 if (pnp_dock_event(d, &now) == 0) {
192 docked = d;
193 #if 0
194 printk(KERN_INFO
195 "PnPBIOS: Docking station %stached\n",
196 docked ? "at" : "de");
197 #endif
198 }
199 }
200 }
201 complete_and_exit(&unload_sem, 0);
202 }
203
204 #endif /* CONFIG_HOTPLUG */
205
206 static int pnpbios_get_resources(struct pnp_dev *dev,
207 struct pnp_resource_table *res)
208 {
209 u8 nodenum = dev->number;
210 struct pnp_bios_node *node;
211
212 if (!pnpbios_is_dynamic(dev))
213 return -EPERM;
214
215 node = kzalloc(node_info.max_node_size, GFP_KERNEL);
216 if (!node)
217 return -1;
218 if (pnp_bios_get_dev_node(&nodenum, (char)PNPMODE_DYNAMIC, node)) {
219 kfree(node);
220 return -ENODEV;
221 }
222 pnpbios_read_resources_from_node(res, node);
223 dev->active = pnp_is_active(dev);
224 kfree(node);
225 return 0;
226 }
227
228 static int pnpbios_set_resources(struct pnp_dev *dev,
229 struct pnp_resource_table *res)
230 {
231 u8 nodenum = dev->number;
232 struct pnp_bios_node *node;
233 int ret;
234
235 if (!pnpbios_is_dynamic(dev))
236 return -EPERM;
237
238 node = kzalloc(node_info.max_node_size, GFP_KERNEL);
239 if (!node)
240 return -1;
241 if (pnp_bios_get_dev_node(&nodenum, (char)PNPMODE_DYNAMIC, node)) {
242 kfree(node);
243 return -ENODEV;
244 }
245 if (pnpbios_write_resources_to_node(res, node) < 0) {
246 kfree(node);
247 return -1;
248 }
249 ret = pnp_bios_set_dev_node(node->handle, (char)PNPMODE_DYNAMIC, node);
250 kfree(node);
251 if (ret > 0)
252 ret = -1;
253 return ret;
254 }
255
256 static void pnpbios_zero_data_stream(struct pnp_bios_node *node)
257 {
258 unsigned char *p = (char *)node->data;
259 unsigned char *end = (char *)(node->data + node->size);
260 unsigned int len;
261 int i;
262
263 while ((char *)p < (char *)end) {
264 if (p[0] & 0x80) { /* large tag */
265 len = (p[2] << 8) | p[1];
266 p += 3;
267 } else {
268 if (((p[0] >> 3) & 0x0f) == 0x0f)
269 return;
270 len = p[0] & 0x07;
271 p += 1;
272 }
273 for (i = 0; i < len; i++)
274 p[i] = 0;
275 p += len;
276 }
277 printk(KERN_ERR
278 "PnPBIOS: Resource structure did not contain an end tag.\n");
279 }
280
281 static int pnpbios_disable_resources(struct pnp_dev *dev)
282 {
283 struct pnp_bios_node *node;
284 u8 nodenum = dev->number;
285 int ret;
286
287 if (dev->flags & PNPBIOS_NO_DISABLE || !pnpbios_is_dynamic(dev))
288 return -EPERM;
289
290 node = kzalloc(node_info.max_node_size, GFP_KERNEL);
291 if (!node)
292 return -ENOMEM;
293
294 if (pnp_bios_get_dev_node(&nodenum, (char)PNPMODE_DYNAMIC, node)) {
295 kfree(node);
296 return -ENODEV;
297 }
298 pnpbios_zero_data_stream(node);
299
300 ret = pnp_bios_set_dev_node(dev->number, (char)PNPMODE_DYNAMIC, node);
301 kfree(node);
302 if (ret > 0)
303 ret = -1;
304 return ret;
305 }
306
307 /* PnP Layer support */
308
309 struct pnp_protocol pnpbios_protocol = {
310 .name = "Plug and Play BIOS",
311 .get = pnpbios_get_resources,
312 .set = pnpbios_set_resources,
313 .disable = pnpbios_disable_resources,
314 };
315
316 static int __init insert_device(struct pnp_bios_node *node)
317 {
318 struct list_head *pos;
319 struct pnp_dev *dev;
320 struct pnp_id *dev_id;
321 char id[8];
322
323 /* check if the device is already added */
324 list_for_each(pos, &pnpbios_protocol.devices) {
325 dev = list_entry(pos, struct pnp_dev, protocol_list);
326 if (dev->number == node->handle)
327 return -1;
328 }
329
330 dev = kzalloc(sizeof(struct pnp_dev), GFP_KERNEL);
331 if (!dev)
332 return -1;
333
334 dev_id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL);
335 if (!dev_id) {
336 kfree(dev);
337 return -1;
338 }
339
340 dev->number = node->handle;
341 pnpid32_to_pnpid(node->eisa_id, id);
342 memcpy(dev_id->id, id, 7);
343 pnp_add_id(dev_id, dev);
344 pnpbios_parse_data_stream(dev, node);
345 dev->active = pnp_is_active(dev);
346 dev->flags = node->flags;
347 if (!(dev->flags & PNPBIOS_NO_CONFIG))
348 dev->capabilities |= PNP_CONFIGURABLE;
349 if (!(dev->flags & PNPBIOS_NO_DISABLE) && pnpbios_is_dynamic(dev))
350 dev->capabilities |= PNP_DISABLE;
351 dev->capabilities |= PNP_READ;
352 if (pnpbios_is_dynamic(dev))
353 dev->capabilities |= PNP_WRITE;
354 if (dev->flags & PNPBIOS_REMOVABLE)
355 dev->capabilities |= PNP_REMOVABLE;
356 dev->protocol = &pnpbios_protocol;
357
358 /* clear out the damaged flags */
359 if (!dev->active)
360 pnp_init_resource_table(&dev->res);
361
362 pnp_add_device(dev);
363 pnpbios_interface_attach_device(node);
364
365 return 0;
366 }
367
368 static void __init build_devlist(void)
369 {
370 u8 nodenum;
371 unsigned int nodes_got = 0;
372 unsigned int devs = 0;
373 struct pnp_bios_node *node;
374
375 node = kzalloc(node_info.max_node_size, GFP_KERNEL);
376 if (!node)
377 return;
378
379 for (nodenum = 0; nodenum < 0xff;) {
380 u8 thisnodenum = nodenum;
381 /* eventually we will want to use PNPMODE_STATIC here but for now
382 * dynamic will help us catch buggy bioses to add to the blacklist.
383 */
384 if (!pnpbios_dont_use_current_config) {
385 if (pnp_bios_get_dev_node
386 (&nodenum, (char)PNPMODE_DYNAMIC, node))
387 break;
388 } else {
389 if (pnp_bios_get_dev_node
390 (&nodenum, (char)PNPMODE_STATIC, node))
391 break;
392 }
393 nodes_got++;
394 if (insert_device(node) == 0)
395 devs++;
396 if (nodenum <= thisnodenum) {
397 printk(KERN_ERR
398 "PnPBIOS: build_devlist: Node number 0x%x is out of sequence following node 0x%x. Aborting.\n",
399 (unsigned int)nodenum,
400 (unsigned int)thisnodenum);
401 break;
402 }
403 }
404 kfree(node);
405
406 printk(KERN_INFO
407 "PnPBIOS: %i node%s reported by PnP BIOS; %i recorded by driver\n",
408 nodes_got, nodes_got != 1 ? "s" : "", devs);
409 }
410
411 /*
412 *
413 * INIT AND EXIT
414 *
415 */
416
417 static int pnpbios_disabled;
418 int pnpbios_dont_use_current_config;
419
420 static int __init pnpbios_setup(char *str)
421 {
422 int invert;
423
424 while ((str != NULL) && (*str != '\0')) {
425 if (strncmp(str, "off", 3) == 0)
426 pnpbios_disabled = 1;
427 if (strncmp(str, "on", 2) == 0)
428 pnpbios_disabled = 0;
429 invert = (strncmp(str, "no-", 3) == 0);
430 if (invert)
431 str += 3;
432 if (strncmp(str, "curr", 4) == 0)
433 pnpbios_dont_use_current_config = invert;
434 str = strchr(str, ',');
435 if (str != NULL)
436 str += strspn(str, ", \t");
437 }
438
439 return 1;
440 }
441
442 __setup("pnpbios=", pnpbios_setup);
443
444 /* PnP BIOS signature: "$PnP" */
445 #define PNP_SIGNATURE (('$' << 0) + ('P' << 8) + ('n' << 16) + ('P' << 24))
446
447 static int __init pnpbios_probe_system(void)
448 {
449 union pnp_bios_install_struct *check;
450 u8 sum;
451 int length, i;
452
453 printk(KERN_INFO "PnPBIOS: Scanning system for PnP BIOS support...\n");
454
455 /*
456 * Search the defined area (0xf0000-0xffff0) for a valid PnP BIOS
457 * structure and, if one is found, sets up the selectors and
458 * entry points
459 */
460 for (check = (union pnp_bios_install_struct *)__va(0xf0000);
461 check < (union pnp_bios_install_struct *)__va(0xffff0);
462 check = (void *)check + 16) {
463 if (check->fields.signature != PNP_SIGNATURE)
464 continue;
465 printk(KERN_INFO
466 "PnPBIOS: Found PnP BIOS installation structure at 0x%p\n",
467 check);
468 length = check->fields.length;
469 if (!length) {
470 printk(KERN_ERR
471 "PnPBIOS: installation structure is invalid, skipping\n");
472 continue;
473 }
474 for (sum = 0, i = 0; i < length; i++)
475 sum += check->chars[i];
476 if (sum) {
477 printk(KERN_ERR
478 "PnPBIOS: installation structure is corrupted, skipping\n");
479 continue;
480 }
481 if (check->fields.version < 0x10) {
482 printk(KERN_WARNING
483 "PnPBIOS: PnP BIOS version %d.%d is not supported\n",
484 check->fields.version >> 4,
485 check->fields.version & 15);
486 continue;
487 }
488 printk(KERN_INFO
489 "PnPBIOS: PnP BIOS version %d.%d, entry 0x%x:0x%x, dseg 0x%x\n",
490 check->fields.version >> 4, check->fields.version & 15,
491 check->fields.pm16cseg, check->fields.pm16offset,
492 check->fields.pm16dseg);
493 pnp_bios_install = check;
494 return 1;
495 }
496
497 printk(KERN_INFO "PnPBIOS: PnP BIOS support was not detected.\n");
498 return 0;
499 }
500
501 static int __init exploding_pnp_bios(const struct dmi_system_id *d)
502 {
503 printk(KERN_WARNING "%s detected. Disabling PnPBIOS\n", d->ident);
504 return 0;
505 }
506
507 static struct dmi_system_id pnpbios_dmi_table[] __initdata = {
508 { /* PnPBIOS GPF on boot */
509 .callback = exploding_pnp_bios,
510 .ident = "Higraded P14H",
511 .matches = {
512 DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
513 DMI_MATCH(DMI_BIOS_VERSION, "07.00T"),
514 DMI_MATCH(DMI_SYS_VENDOR, "Higraded"),
515 DMI_MATCH(DMI_PRODUCT_NAME, "P14H"),
516 },
517 },
518 { /* PnPBIOS GPF on boot */
519 .callback = exploding_pnp_bios,
520 .ident = "ASUS P4P800",
521 .matches = {
522 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc."),
523 DMI_MATCH(DMI_BOARD_NAME, "P4P800"),
524 },
525 },
526 {}
527 };
528
529 static int __init pnpbios_init(void)
530 {
531 int ret;
532
533 #if defined(CONFIG_PPC_MERGE)
534 if (check_legacy_ioport(PNPBIOS_BASE))
535 return -ENODEV;
536 #endif
537 if (pnpbios_disabled || dmi_check_system(pnpbios_dmi_table) ||
538 paravirt_enabled()) {
539 printk(KERN_INFO "PnPBIOS: Disabled\n");
540 return -ENODEV;
541 }
542 #ifdef CONFIG_PNPACPI
543 if (!acpi_disabled && !pnpacpi_disabled) {
544 pnpbios_disabled = 1;
545 printk(KERN_INFO "PnPBIOS: Disabled by ACPI PNP\n");
546 return -ENODEV;
547 }
548 #endif /* CONFIG_ACPI */
549
550 /* scan the system for pnpbios support */
551 if (!pnpbios_probe_system())
552 return -ENODEV;
553
554 /* make preparations for bios calls */
555 pnpbios_calls_init(pnp_bios_install);
556
557 /* read the node info */
558 ret = pnp_bios_dev_node_info(&node_info);
559 if (ret) {
560 printk(KERN_ERR
561 "PnPBIOS: Unable to get node info. Aborting.\n");
562 return ret;
563 }
564
565 /* register with the pnp layer */
566 ret = pnp_register_protocol(&pnpbios_protocol);
567 if (ret) {
568 printk(KERN_ERR
569 "PnPBIOS: Unable to register driver. Aborting.\n");
570 return ret;
571 }
572
573 /* start the proc interface */
574 ret = pnpbios_proc_init();
575 if (ret)
576 printk(KERN_ERR "PnPBIOS: Failed to create proc interface.\n");
577
578 /* scan for pnpbios devices */
579 build_devlist();
580
581 pnp_platform_devices = 1;
582 return 0;
583 }
584
585 subsys_initcall(pnpbios_init);
586
587 static int __init pnpbios_thread_init(void)
588 {
589 struct task_struct *task;
590
591 #if defined(CONFIG_PPC_MERGE)
592 if (check_legacy_ioport(PNPBIOS_BASE))
593 return 0;
594 #endif
595 if (pnpbios_disabled)
596 return 0;
597 #ifdef CONFIG_HOTPLUG
598 init_completion(&unload_sem);
599 task = kthread_run(pnp_dock_thread, NULL, "kpnpbiosd");
600 if (!IS_ERR(task))
601 unloading = 0;
602 #endif
603 return 0;
604 }
605
606 /* Start the kernel thread later: */
607 module_init(pnpbios_thread_init);
608
609 EXPORT_SYMBOL(pnpbios_protocol);
610
|
This page was automatically generated by the
LXR engine.
|