From 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Sat, 16 Apr 2005 15:20:36 -0700 Subject: Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip! --- drivers/pnp/pnpbios/Kconfig | 42 +++ drivers/pnp/pnpbios/Makefile | 7 + drivers/pnp/pnpbios/bioscalls.c | 544 +++++++++++++++++++++++++++ drivers/pnp/pnpbios/core.c | 644 ++++++++++++++++++++++++++++++++ drivers/pnp/pnpbios/pnpbios.h | 47 +++ drivers/pnp/pnpbios/proc.c | 292 +++++++++++++++ drivers/pnp/pnpbios/rsparser.c | 795 ++++++++++++++++++++++++++++++++++++++++ 7 files changed, 2371 insertions(+) create mode 100644 drivers/pnp/pnpbios/Kconfig create mode 100644 drivers/pnp/pnpbios/Makefile create mode 100644 drivers/pnp/pnpbios/bioscalls.c create mode 100644 drivers/pnp/pnpbios/core.c create mode 100644 drivers/pnp/pnpbios/pnpbios.h create mode 100644 drivers/pnp/pnpbios/proc.c create mode 100644 drivers/pnp/pnpbios/rsparser.c (limited to 'drivers/pnp/pnpbios') diff --git a/drivers/pnp/pnpbios/Kconfig b/drivers/pnp/pnpbios/Kconfig new file mode 100644 index 000000000000..fab848cae89d --- /dev/null +++ b/drivers/pnp/pnpbios/Kconfig @@ -0,0 +1,42 @@ +# +# Plug and Play BIOS configuration +# +config PNPBIOS + bool "Plug and Play BIOS support (EXPERIMENTAL)" + depends on PNP && ISA && X86 && EXPERIMENTAL + default n + ---help--- + Linux uses the PNPBIOS as defined in "Plug and Play BIOS + Specification Version 1.0A May 5, 1994" to autodetect built-in + mainboard resources (e.g. parallel port resources). + + Some features (e.g. event notification, docking station information, + ISAPNP services) are not currently implemented. + + If you would like the kernel to detect and allocate resources to + your mainboard devices (on some systems they are disabled by the + BIOS) say Y here. Also the PNPBIOS can help prevent resource + conflicts between mainboard devices and other bus devices. + + Note: ACPI is expected to supersede PNPBIOS some day, currently it + co-exists nicely. If you have a non-ISA system that supports ACPI, + you probably don't need PNPBIOS support. + +config PNPBIOS_PROC_FS + bool "Plug and Play BIOS /proc interface" + depends on PNPBIOS && PROC_FS + ---help--- + If you say Y here and to "/proc file system support", you will be + able to directly access the PNPBIOS. This includes resource + allocation, ESCD, and other PNPBIOS services. Using this + interface is potentially dangerous because the PNPBIOS driver will + not be notified of any resource changes made by writing directly. + Also some buggy systems will fault when accessing certain features + in the PNPBIOS /proc interface (e.g. "boot" configs). + + See the latest pcmcia-cs (stand-alone package) for a nice set of + PNPBIOS /proc interface tools (lspnp and setpnp). + + Unless you are debugging or have other specific reasons, it is + recommended that you say N here. + diff --git a/drivers/pnp/pnpbios/Makefile b/drivers/pnp/pnpbios/Makefile new file mode 100644 index 000000000000..3cd3ed760605 --- /dev/null +++ b/drivers/pnp/pnpbios/Makefile @@ -0,0 +1,7 @@ +# +# Makefile for the kernel PNPBIOS driver. +# + +pnpbios-proc-$(CONFIG_PNPBIOS_PROC_FS) = proc.o + +obj-y := core.o bioscalls.o rsparser.o $(pnpbios-proc-y) diff --git a/drivers/pnp/pnpbios/bioscalls.c b/drivers/pnp/pnpbios/bioscalls.c new file mode 100644 index 000000000000..6b7583f497d0 --- /dev/null +++ b/drivers/pnp/pnpbios/bioscalls.c @@ -0,0 +1,544 @@ +/* + * bioscalls.c - the lowlevel layer of the PnPBIOS driver + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "pnpbios.h" + +static struct { + u16 offset; + u16 segment; +} pnp_bios_callpoint; + + +/* The PnP BIOS entries in the GDT */ +#define PNP_GDT (GDT_ENTRY_PNPBIOS_BASE * 8) + +#define PNP_CS32 (PNP_GDT+0x00) /* segment for calling fn */ +#define PNP_CS16 (PNP_GDT+0x08) /* code segment for BIOS */ +#define PNP_DS (PNP_GDT+0x10) /* data segment for BIOS */ +#define PNP_TS1 (PNP_GDT+0x18) /* transfer data segment */ +#define PNP_TS2 (PNP_GDT+0x20) /* another data segment */ + +/* + * These are some opcodes for a "static asmlinkage" + * As this code is *not* executed inside the linux kernel segment, but in a + * alias at offset 0, we need a far return that can not be compiled by + * default (please, prove me wrong! this is *really* ugly!) + * This is the only way to get the bios to return into the kernel code, + * because the bios code runs in 16 bit protected mode and therefore can only + * return to the caller if the call is within the first 64kB, and the linux + * kernel begins at offset 3GB... + */ + +asmlinkage void pnp_bios_callfunc(void); + +__asm__( + ".text \n" + __ALIGN_STR "\n" + "pnp_bios_callfunc:\n" + " pushl %edx \n" + " pushl %ecx \n" + " pushl %ebx \n" + " pushl %eax \n" + " lcallw *pnp_bios_callpoint\n" + " addl $16, %esp \n" + " lret \n" + ".previous \n" +); + +#define Q_SET_SEL(cpu, selname, address, size) \ +do { \ +set_base(per_cpu(cpu_gdt_table,cpu)[(selname) >> 3], __va((u32)(address))); \ +set_limit(per_cpu(cpu_gdt_table,cpu)[(selname) >> 3], size); \ +} while(0) + +#define Q2_SET_SEL(cpu, selname, address, size) \ +do { \ +set_base(per_cpu(cpu_gdt_table,cpu)[(selname) >> 3], (u32)(address)); \ +set_limit(per_cpu(cpu_gdt_table,cpu)[(selname) >> 3], size); \ +} while(0) + +static struct desc_struct bad_bios_desc = { 0, 0x00409200 }; + +/* + * At some point we want to use this stack frame pointer to unwind + * after PnP BIOS oopses. + */ + +u32 pnp_bios_fault_esp; +u32 pnp_bios_fault_eip; +u32 pnp_bios_is_utter_crap = 0; + +static spinlock_t pnp_bios_lock; + + +/* + * Support Functions + */ + +static inline u16 call_pnp_bios(u16 func, u16 arg1, u16 arg2, u16 arg3, + u16 arg4, u16 arg5, u16 arg6, u16 arg7, + void *ts1_base, u32 ts1_size, + void *ts2_base, u32 ts2_size) +{ + unsigned long flags; + u16 status; + struct desc_struct save_desc_40; + int cpu; + + /* + * PnP BIOSes are generally not terribly re-entrant. + * Also, don't rely on them to save everything correctly. + */ + if(pnp_bios_is_utter_crap) + return PNP_FUNCTION_NOT_SUPPORTED; + + cpu = get_cpu(); + save_desc_40 = per_cpu(cpu_gdt_table,cpu)[0x40 / 8]; + per_cpu(cpu_gdt_table,cpu)[0x40 / 8] = bad_bios_desc; + + /* On some boxes IRQ's during PnP BIOS calls are deadly. */ + spin_lock_irqsave(&pnp_bios_lock, flags); + + /* The lock prevents us bouncing CPU here */ + if (ts1_size) + Q2_SET_SEL(smp_processor_id(), PNP_TS1, ts1_base, ts1_size); + if (ts2_size) + Q2_SET_SEL(smp_processor_id(), PNP_TS2, ts2_base, ts2_size); + + __asm__ __volatile__( + "pushl %%ebp\n\t" + "pushl %%edi\n\t" + "pushl %%esi\n\t" + "pushl %%ds\n\t" + "pushl %%es\n\t" + "pushl %%fs\n\t" + "pushl %%gs\n\t" + "pushfl\n\t" + "movl %%esp, pnp_bios_fault_esp\n\t" + "movl $1f, pnp_bios_fault_eip\n\t" + "lcall %5,%6\n\t" + "1:popfl\n\t" + "popl %%gs\n\t" + "popl %%fs\n\t" + "popl %%es\n\t" + "popl %%ds\n\t" + "popl %%esi\n\t" + "popl %%edi\n\t" + "popl %%ebp\n\t" + : "=a" (status) + : "0" ((func) | (((u32)arg1) << 16)), + "b" ((arg2) | (((u32)arg3) << 16)), + "c" ((arg4) | (((u32)arg5) << 16)), + "d" ((arg6) | (((u32)arg7) << 16)), + "i" (PNP_CS32), + "i" (0) + : "memory" + ); + spin_unlock_irqrestore(&pnp_bios_lock, flags); + + per_cpu(cpu_gdt_table,cpu)[0x40 / 8] = save_desc_40; + put_cpu(); + + /* If we get here and this is set then the PnP BIOS faulted on us. */ + if(pnp_bios_is_utter_crap) + { + printk(KERN_ERR "PnPBIOS: Warning! Your PnP BIOS caused a fatal error. Attempting to continue\n"); + printk(KERN_ERR "PnPBIOS: You may need to reboot with the \"pnpbios=off\" option to operate stably\n"); + printk(KERN_ERR "PnPBIOS: Check with your vendor for an updated BIOS\n"); + } + + return status; +} + +void pnpbios_print_status(const char * module, u16 status) +{ + switch(status) { + case PNP_SUCCESS: + printk(KERN_ERR "PnPBIOS: %s: function successful\n", module); + break; + case PNP_NOT_SET_STATICALLY: + printk(KERN_ERR "PnPBIOS: %s: unable to set static resources\n", module); + break; + case PNP_UNKNOWN_FUNCTION: + printk(KERN_ERR "PnPBIOS: %s: invalid function number passed\n", module); + break; + case PNP_FUNCTION_NOT_SUPPORTED: + printk(KERN_ERR "PnPBIOS: %s: function not supported on this system\n", module); + break; + case PNP_INVALID_HANDLE: + printk(KERN_ERR "PnPBIOS: %s: invalid handle\n", module); + break; + case PNP_BAD_PARAMETER: + printk(KERN_ERR "PnPBIOS: %s: invalid parameters were passed\n", module); + break; + case PNP_SET_FAILED: + printk(KERN_ERR "PnPBIOS: %s: unable to set resources\n", module); + break; + case PNP_EVENTS_NOT_PENDING: + printk(KERN_ERR "PnPBIOS: %s: no events are pending\n", module); + break; + case PNP_SYSTEM_NOT_DOCKED: + printk(KERN_ERR "PnPBIOS: %s: the system is not docked\n", module); + break; + case PNP_NO_ISA_PNP_CARDS: + printk(KERN_ERR "PnPBIOS: %s: no isapnp cards are installed on this system\n", module); + break; + case PNP_UNABLE_TO_DETERMINE_DOCK_CAPABILITIES: + printk(KERN_ERR "PnPBIOS: %s: cannot determine the capabilities of the docking station\n", module); + break; + case PNP_CONFIG_CHANGE_FAILED_NO_BATTERY: + printk(KERN_ERR "PnPBIOS: %s: unable to undock, the system does not have a battery\n", module); + break; + case PNP_CONFIG_CHANGE_FAILED_RESOURCE_CONFLICT: + printk(KERN_ERR "PnPBIOS: %s: could not dock due to resource conflicts\n", module); + break; + case PNP_BUFFER_TOO_SMALL: + printk(KERN_ERR "PnPBIOS: %s: the buffer passed is too small\n", module); + break; + case PNP_USE_ESCD_SUPPORT: + printk(KERN_ERR "PnPBIOS: %s: use ESCD instead\n", module); + break; + case PNP_MESSAGE_NOT_SUPPORTED: + printk(KERN_ERR "PnPBIOS: %s: the message is unsupported\n", module); + break; + case PNP_HARDWARE_ERROR: + printk(KERN_ERR "PnPBIOS: %s: a hardware failure has occured\n", module); + break; + default: + printk(KERN_ERR "PnPBIOS: %s: unexpected status 0x%x\n", module, status); + break; + } +} + + +/* + * PnP BIOS Low Level Calls + */ + +#define PNP_GET_NUM_SYS_DEV_NODES 0x00 +#define PNP_GET_SYS_DEV_NODE 0x01 +#define PNP_SET_SYS_DEV_NODE 0x02 +#define PNP_GET_EVENT 0x03 +#define PNP_SEND_MESSAGE 0x04 +#define PNP_GET_DOCKING_STATION_INFORMATION 0x05 +#define PNP_SET_STATIC_ALLOCED_RES_INFO 0x09 +#define PNP_GET_STATIC_ALLOCED_RES_INFO 0x0a +#define PNP_GET_APM_ID_TABLE 0x0b +#define PNP_GET_PNP_ISA_CONFIG_STRUC 0x40 +#define PNP_GET_ESCD_INFO 0x41 +#define PNP_READ_ESCD 0x42 +#define PNP_WRITE_ESCD 0x43 + +/* + * Call PnP BIOS with function 0x00, "get number of system device nodes" + */ +static int __pnp_bios_dev_node_info(struct pnp_dev_node_info *data) +{ + u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_GET_NUM_SYS_DEV_NODES, 0, PNP_TS1, 2, PNP_TS1, PNP_DS, 0, 0, + data, sizeof(struct pnp_dev_node_info), NULL, 0); + data->no_nodes &= 0xff; + return status; +} + +int pnp_bios_dev_node_info(struct pnp_dev_node_info *data) +{ + int status = __pnp_bios_dev_node_info( data ); + if ( status ) + pnpbios_print_status( "dev_node_info", status ); + return status; +} + +/* + * Note that some PnP BIOSes (e.g., on Sony Vaio laptops) die a horrible + * death if they are asked to access the "current" configuration. + * Therefore, if it's a matter of indifference, it's better to call + * get_dev_node() and set_dev_node() with boot=1 rather than with boot=0. + */ + +/* + * Call PnP BIOS with function 0x01, "get system device node" + * Input: *nodenum = desired node, + * boot = whether to get nonvolatile boot (!=0) + * or volatile current (0) config + * Output: *nodenum=next node or 0xff if no more nodes + */ +static int __pnp_bios_get_dev_node(u8 *nodenum, char boot, struct pnp_bios_node *data) +{ + u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + if ( !boot && pnpbios_dont_use_current_config ) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_GET_SYS_DEV_NODE, 0, PNP_TS1, 0, PNP_TS2, boot ? 2 : 1, PNP_DS, 0, + nodenum, sizeof(char), data, 65536); + return status; +} + +int pnp_bios_get_dev_node(u8 *nodenum, char boot, struct pnp_bios_node *data) +{ + int status; + status = __pnp_bios_get_dev_node( nodenum, boot, data ); + if ( status ) + pnpbios_print_status( "get_dev_node", status ); + return status; +} + + +/* + * Call PnP BIOS with function 0x02, "set system device node" + * Input: *nodenum = desired node, + * boot = whether to set nonvolatile boot (!=0) + * or volatile current (0) config + */ +static int __pnp_bios_set_dev_node(u8 nodenum, char boot, struct pnp_bios_node *data) +{ + u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + if ( !boot && pnpbios_dont_use_current_config ) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_SET_SYS_DEV_NODE, nodenum, 0, PNP_TS1, boot ? 2 : 1, PNP_DS, 0, 0, + data, 65536, NULL, 0); + return status; +} + +int pnp_bios_set_dev_node(u8 nodenum, char boot, struct pnp_bios_node *data) +{ + int status; + status = __pnp_bios_set_dev_node( nodenum, boot, data ); + if ( status ) { + pnpbios_print_status( "set_dev_node", status ); + return status; + } + if ( !boot ) { /* Update devlist */ + status = pnp_bios_get_dev_node( &nodenum, boot, data ); + if ( status ) + return status; + } + return status; +} + +#if needed +/* + * Call PnP BIOS with function 0x03, "get event" + */ +static int pnp_bios_get_event(u16 *event) +{ + u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_GET_EVENT, 0, PNP_TS1, PNP_DS, 0, 0 ,0 ,0, + event, sizeof(u16), NULL, 0); + return status; +} +#endif + +#if needed +/* + * Call PnP BIOS with function 0x04, "send message" + */ +static int pnp_bios_send_message(u16 message) +{ + u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_SEND_MESSAGE, message, PNP_DS, 0, 0, 0, 0, 0, 0, 0, 0, 0); + return status; +} +#endif + +/* + * Call PnP BIOS with function 0x05, "get docking station information" + */ +int pnp_bios_dock_station_info(struct pnp_docking_station_info *data) +{ + u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_GET_DOCKING_STATION_INFORMATION, 0, PNP_TS1, PNP_DS, 0, 0, 0, 0, + data, sizeof(struct pnp_docking_station_info), NULL, 0); + return status; +} + +#if needed +/* + * Call PnP BIOS with function 0x09, "set statically allocated resource + * information" + */ +static int pnp_bios_set_stat_res(char *info) +{ + u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_SET_STATIC_ALLOCED_RES_INFO, 0, PNP_TS1, PNP_DS, 0, 0, 0, 0, + info, *((u16 *) info), 0, 0); + return status; +} +#endif + +/* + * Call PnP BIOS with function 0x0a, "get statically allocated resource + * information" + */ +static int __pnp_bios_get_stat_res(char *info) +{ + u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_GET_STATIC_ALLOCED_RES_INFO, 0, PNP_TS1, PNP_DS, 0, 0, 0, 0, + info, 65536, NULL, 0); + return status; +} + +int pnp_bios_get_stat_res(char *info) +{ + int status; + status = __pnp_bios_get_stat_res( info ); + if ( status ) + pnpbios_print_status( "get_stat_res", status ); + return status; +} + +#if needed +/* + * Call PnP BIOS with function 0x0b, "get APM id table" + */ +static int pnp_bios_apm_id_table(char *table, u16 *size) +{ + u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_GET_APM_ID_TABLE, 0, PNP_TS2, 0, PNP_TS1, PNP_DS, 0, 0, + table, *size, size, sizeof(u16)); + return status; +} +#endif + +/* + * Call PnP BIOS with function 0x40, "get isa pnp configuration structure" + */ +static int __pnp_bios_isapnp_config(struct pnp_isa_config_struc *data) +{ + u16 status; + if (!pnp_bios_present()) + return PNP_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_GET_PNP_ISA_CONFIG_STRUC, 0, PNP_TS1, PNP_DS, 0, 0, 0, 0, + data, sizeof(struct pnp_isa_config_struc), NULL, 0); + return status; +} + +int pnp_bios_isapnp_config(struct pnp_isa_config_struc *data) +{ + int status; + status = __pnp_bios_isapnp_config( data ); + if ( status ) + pnpbios_print_status( "isapnp_config", status ); + return status; +} + +/* + * Call PnP BIOS with function 0x41, "get ESCD info" + */ +static int __pnp_bios_escd_info(struct escd_info_struc *data) +{ + u16 status; + if (!pnp_bios_present()) + return ESCD_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_GET_ESCD_INFO, 0, PNP_TS1, 2, PNP_TS1, 4, PNP_TS1, PNP_DS, + data, sizeof(struct escd_info_struc), NULL, 0); + return status; +} + +int pnp_bios_escd_info(struct escd_info_struc *data) +{ + int status; + status = __pnp_bios_escd_info( data ); + if ( status ) + pnpbios_print_status( "escd_info", status ); + return status; +} + +/* + * Call PnP BIOS function 0x42, "read ESCD" + * nvram_base is determined by calling escd_info + */ +static int __pnp_bios_read_escd(char *data, u32 nvram_base) +{ + u16 status; + if (!pnp_bios_present()) + return ESCD_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_READ_ESCD, 0, PNP_TS1, PNP_TS2, PNP_DS, 0, 0, 0, + data, 65536, __va(nvram_base), 65536); + return status; +} + +int pnp_bios_read_escd(char *data, u32 nvram_base) +{ + int status; + status = __pnp_bios_read_escd( data, nvram_base ); + if ( status ) + pnpbios_print_status( "read_escd", status ); + return status; +} + +#if needed +/* + * Call PnP BIOS function 0x43, "write ESCD" + */ +static int pnp_bios_write_escd(char *data, u32 nvram_base) +{ + u16 status; + if (!pnp_bios_present()) + return ESCD_FUNCTION_NOT_SUPPORTED; + status = call_pnp_bios(PNP_WRITE_ESCD, 0, PNP_TS1, PNP_TS2, PNP_DS, 0, 0, 0, + data, 65536, __va(nvram_base), 65536); + return status; +} +#endif + + +/* + * Initialization + */ + +void pnpbios_calls_init(union pnp_bios_install_struct *header) +{ + int i; + spin_lock_init(&pnp_bios_lock); + pnp_bios_callpoint.offset = header->fields.pm16offset; + pnp_bios_callpoint.segment = PNP_CS16; + + set_base(bad_bios_desc, __va((unsigned long)0x40 << 4)); + _set_limit((char *)&bad_bios_desc, 4095 - (0x40 << 4)); + for(i=0; i < NR_CPUS; i++) + { + Q2_SET_SEL(i, PNP_CS32, &pnp_bios_callfunc, 64 * 1024); + Q_SET_SEL(i, PNP_CS16, header->fields.pm16cseg, 64 * 1024); + Q_SET_SEL(i, PNP_DS, header->fields.pm16dseg, 64 * 1024); + } +} diff --git a/drivers/pnp/pnpbios/core.c b/drivers/pnp/pnpbios/core.c new file mode 100644 index 000000000000..0f6330b3af12 --- /dev/null +++ b/drivers/pnp/pnpbios/core.c @@ -0,0 +1,644 @@ +/* + * pnpbios -- PnP BIOS driver + * + * This driver provides access to Plug-'n'-Play services provided by + * the PnP BIOS firmware, described in the following documents: + * Plug and Play BIOS Specification, Version 1.0A, 5 May 1994 + * Plug and Play BIOS Clarification Paper, 6 October 1994 + * Compaq Computer Corporation, Phoenix Technologies Ltd., Intel Corp. + * + * Originally (C) 1998 Christian Schmidt + * Modifications (C) 1998 Tom Lees + * Minor reorganizations by David Hinds + * Further modifications (C) 2001, 2002 by: + * Alan Cox + * Thomas Hood + * Brian Gerst + * + * Ported to the PnP Layer and several additional improvements (C) 2002 + * by Adam Belay + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2, or (at your option) any + * later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +/* Change Log + * + * Adam Belay - - March 16, 2003 + * rev 1.01 Only call pnp_bios_dev_node_info once + * Added pnpbios_print_status + * Added several new error messages and info messages + * Added pnpbios_interface_attach_device + * integrated core and proc init system + * Introduced PNPMODE flags + * Removed some useless includes + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "pnpbios.h" + + +/* + * + * PnP BIOS INTERFACE + * + */ + +static union pnp_bios_install_struct * pnp_bios_install = NULL; + +int pnp_bios_present(void) +{ + return (pnp_bios_install != NULL); +} + +struct pnp_dev_node_info node_info; + +void *pnpbios_kmalloc(size_t size, int f) +{ + void *p = kmalloc( size, f ); + if ( p == NULL ) + printk(KERN_ERR "PnPBIOS: kmalloc() failed\n"); + else + memset(p, 0, size); + return p; +} + +/* + * + * DOCKING FUNCTIONS + * + */ + +#ifdef CONFIG_HOTPLUG + +static int unloading = 0; +static struct completion unload_sem; + +/* + * (Much of this belongs in a shared routine somewhere) + */ + +static int pnp_dock_event(int dock, struct pnp_docking_station_info *info) +{ + char *argv [3], **envp, *buf, *scratch; + int i = 0, value; + + if (!hotplug_path [0]) + return -ENOENT; + if (!current->fs->root) { + return -EAGAIN; + } + if (!(envp = (char **) pnpbios_kmalloc (20 * sizeof (char *), GFP_KERNEL))) { + return -ENOMEM; + } + if (!(buf = pnpbios_kmalloc (256, GFP_KERNEL))) { + kfree (envp); + return -ENOMEM; + } + + /* only one standardized param to hotplug command: type */ + argv [0] = hotplug_path; + argv [1] = "dock"; + argv [2] = NULL; + + /* minimal command environment */ + envp [i++] = "HOME=/"; + envp [i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; + +#ifdef DEBUG + /* hint that policy agent should enter no-stdout debug mode */ + envp [i++] = "DEBUG=kernel"; +#endif + /* extensible set of named bus-specific parameters, + * supporting multiple driver selection algorithms. + */ + scratch = buf; + + /* action: add, remove */ + envp [i++] = scratch; + scratch += sprintf (scratch, "ACTION=%s", dock?"add":"remove") + 1; + + /* Report the ident for the dock */ + envp [i++] = scratch; + scratch += sprintf (scratch, "DOCK=%x/%x/%x", + info->location_id, info->serial, info->capabilities); + envp[i] = NULL; + + value = call_usermodehelper (argv [0], argv, envp, 0); + kfree (buf); + kfree (envp); + return 0; +} + +/* + * Poll the PnP docking at regular intervals + */ +static int pnp_dock_thread(void * unused) +{ + static struct pnp_docking_station_info now; + int docked = -1, d = 0; + daemonize("kpnpbiosd"); + allow_signal(SIGKILL); + while(!unloading && !signal_pending(current)) + { + int status; + + /* + * Poll every 2 seconds + */ + msleep_interruptible(2000); + + if(signal_pending(current)) { + if (try_to_freeze(PF_FREEZE)) + continue; + break; + } + + status = pnp_bios_dock_station_info(&now); + + switch(status) + { + /* + * No dock to manage + */ + case PNP_FUNCTION_NOT_SUPPORTED: + complete_and_exit(&unload_sem, 0); + case PNP_SYSTEM_NOT_DOCKED: + d = 0; + break; + case PNP_SUCCESS: + d = 1; + break; + default: + pnpbios_print_status( "pnp_dock_thread", status ); + continue; + } + if(d != docked) + { + if(pnp_dock_event(d, &now)==0) + { + docked = d; +#if 0 + printk(KERN_INFO "PnPBIOS: Docking station %stached\n", docked?"at":"de"); +#endif + } + } + } + complete_and_exit(&unload_sem, 0); +} + +#endif /* CONFIG_HOTPLUG */ + +static int pnpbios_get_resources(struct pnp_dev * dev, struct pnp_resource_table * res) +{ + u8 nodenum = dev->number; + struct pnp_bios_node * node; + + /* just in case */ + if(!pnpbios_is_dynamic(dev)) + return -EPERM; + + node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL); + if (!node) + return -1; + if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node)) { + kfree(node); + return -ENODEV; + } + pnpbios_read_resources_from_node(res, node); + dev->active = pnp_is_active(dev); + kfree(node); + return 0; +} + +static int pnpbios_set_resources(struct pnp_dev * dev, struct pnp_resource_table * res) +{ + u8 nodenum = dev->number; + struct pnp_bios_node * node; + int ret; + + /* just in case */ + if (!pnpbios_is_dynamic(dev)) + return -EPERM; + + node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL); + if (!node) + return -1; + if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node)) { + kfree(node); + return -ENODEV; + } + if(pnpbios_write_resources_to_node(res, node)<0) { + kfree(node); + return -1; + } + ret = pnp_bios_set_dev_node(node->handle, (char)PNPMODE_DYNAMIC, node); + kfree(node); + if (ret > 0) + ret = -1; + return ret; +} + +static void pnpbios_zero_data_stream(struct pnp_bios_node * node) +{ + unsigned char * p = (char *)node->data; + unsigned char * end = (char *)(node->data + node->size); + unsigned int len; + int i; + while ((char *)p < (char *)end) { + if(p[0] & 0x80) { /* large tag */ + len = (p[2] << 8) | p[1]; + p += 3; + } else { + if (((p[0]>>3) & 0x0f) == 0x0f) + return; + len = p[0] & 0x07; + p += 1; + } + for (i = 0; i < len; i++) + p[i] = 0; + p += len; + } + printk(KERN_ERR "PnPBIOS: Resource structure did not contain an end tag.\n"); +} + +static int pnpbios_disable_resources(struct pnp_dev *dev) +{ + struct pnp_bios_node * node; + u8 nodenum = dev->number; + int ret; + + /* just in case */ + if(dev->flags & PNPBIOS_NO_DISABLE || !pnpbios_is_dynamic(dev)) + return -EPERM; + + node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL); + if (!node) + return -ENOMEM; + + if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node)) { + kfree(node); + return -ENODEV; + } + pnpbios_zero_data_stream(node); + + ret = pnp_bios_set_dev_node(dev->number, (char)PNPMODE_DYNAMIC, node); + kfree(node); + if (ret > 0) + ret = -1; + return ret; +} + +/* PnP Layer support */ + +struct pnp_protocol pnpbios_protocol = { + .name = "Plug and Play BIOS", + .get = pnpbios_get_resources, + .set = pnpbios_set_resources, + .disable = pnpbios_disable_resources, +}; + +static int insert_device(struct pnp_dev *dev, struct pnp_bios_node * node) +{ + struct list_head * pos; + struct pnp_dev * pnp_dev; + struct pnp_id *dev_id; + char id[8]; + + /* check if the device is already added */ + dev->number = node->handle; + list_for_each (pos, &pnpbios_protocol.devices){ + pnp_dev = list_entry(pos, struct pnp_dev, protocol_list); + if (dev->number == pnp_dev->number) + return -1; + } + + /* set the initial values for the PnP device */ + dev_id = pnpbios_kmalloc(sizeof(struct pnp_id), GFP_KERNEL); + if (!dev_id) + return -1; + pnpid32_to_pnpid(node->eisa_id,id); + memcpy(dev_id->id,id,7); + pnp_add_id(dev_id, dev); + pnpbios_parse_data_stream(dev, node); + dev->active = pnp_is_active(dev); + dev->flags = node->flags; + if (!(dev->flags & PNPBIOS_NO_CONFIG)) + dev->capabilities |= PNP_CONFIGURABLE; + if (!(dev->flags & PNPBIOS_NO_DISABLE)) + dev->capabilities |= PNP_DISABLE; + dev->capabilities |= PNP_READ; + if (pnpbios_is_dynamic(dev)) + dev->capabilities |= PNP_WRITE; + if (dev->flags & PNPBIOS_REMOVABLE) + dev->capabilities |= PNP_REMOVABLE; + dev->protocol = &pnpbios_protocol; + + /* clear out the damaged flags */ + if (!dev->active) + pnp_init_resource_table(&dev->res); + + pnp_add_device(dev); + pnpbios_interface_attach_device(node); + + return 0; +} + +static void __init build_devlist(void) +{ + u8 nodenum; + unsigned int nodes_got = 0; + unsigned int devs = 0; + struct pnp_bios_node *node; + struct pnp_dev *dev; + + node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL); + if (!node) + return; + + for(nodenum=0; nodenum<0xff; ) { + u8 thisnodenum = nodenum; + /* eventually we will want to use PNPMODE_STATIC here but for now + * dynamic will help us catch buggy bioses to add to the blacklist. + */ + if (!pnpbios_dont_use_current_config) { + if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node)) + break; + } else { + if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_STATIC, node)) + break; + } + nodes_got++; + dev = pnpbios_kmalloc(sizeof (struct pnp_dev), GFP_KERNEL); + if (!dev) + break; + if(insert_device(dev,node)<0) + kfree(dev); + else + devs++; + if (nodenum <= thisnodenum) { + printk(KERN_ERR "PnPBIOS: build_devlist: Node number 0x%x is out of sequence following node 0x%x. Aborting.\n", (unsigned int)nodenum, (unsigned int)thisnodenum); + break; + } + } + kfree(node); + + printk(KERN_INFO "PnPBIOS: %i node%s reported by PnP BIOS; %i recorded by driver\n", + nodes_got, nodes_got != 1 ? "s" : "", devs); +} + +/* + * + * INIT AND EXIT + * + */ + +static int pnpbios_disabled; /* = 0 */ +int pnpbios_dont_use_current_config; /* = 0 */ + +#ifndef MODULE +static int __init pnpbios_setup(char *str) +{ + int invert; + + while ((str != NULL) && (*str != '\0')) { + if (strncmp(str, "off", 3) == 0) + pnpbios_disabled=1; + if (strncmp(str, "on", 2) == 0) + pnpbios_disabled=0; + invert = (strncmp(str, "no-", 3) == 0); + if (invert) + str += 3; + if (strncmp(str, "curr", 4) == 0) + pnpbios_dont_use_current_config = invert; + str = strchr(str, ','); + if (str != NULL) + str += strspn(str, ", \t"); + } + + return 1; +} + +__setup("pnpbios=", pnpbios_setup); +#endif + +/* PnP BIOS signature: "$PnP" */ +#define PNP_SIGNATURE (('$' << 0) + ('P' << 8) + ('n' << 16) + ('P' << 24)) + +static int __init pnpbios_probe_system(void) +{ + union pnp_bios_install_struct *check; + u8 sum; + int length, i; + + printk(KERN_INFO "PnPBIOS: Scanning system for PnP BIOS support...\n"); + + /* + * Search the defined area (0xf0000-0xffff0) for a valid PnP BIOS + * structure and, if one is found, sets up the selectors and + * entry points + */ + for (check = (union pnp_bios_install_struct *) __va(0xf0000); + check < (union pnp_bios_install_struct *) __va(0xffff0); + check = (void *)check + 16) { + if (check->fields.signature != PNP_SIGNATURE) + continue; + printk(KERN_INFO "PnPBIOS: Found PnP BIOS installation structure at 0x%p\n", check); + length = check->fields.length; + if (!length) { + printk(KERN_ERR "PnPBIOS: installation structure is invalid, skipping\n"); + continue; + } + for (sum = 0, i = 0; i < length; i++) + sum += check->chars[i]; + if (sum) { + printk(KERN_ERR "PnPBIOS: installation structure is corrupted, skipping\n"); + continue; + } + if (check->fields.version < 0x10) { + printk(KERN_WARNING "PnPBIOS: PnP BIOS version %d.%d is not supported\n", + check->fields.version >> 4, + check->fields.version & 15); + continue; + } + printk(KERN_INFO "PnPBIOS: PnP BIOS version %d.%d, entry 0x%x:0x%x, dseg 0x%x\n", + check->fields.version >> 4, check->fields.version & 15, + check->fields.pm16cseg, check->fields.pm16offset, + check->fields.pm16dseg); + pnp_bios_install = check; + return 1; + } + + printk(KERN_INFO "PnPBIOS: PnP BIOS support was not detected.\n"); + return 0; +} + +static int __init exploding_pnp_bios(struct dmi_system_id *d) +{ + printk(KERN_WARNING "%s detected. Disabling PnPBIOS\n", d->ident); + return 0; +} + +static struct dmi_system_id pnpbios_dmi_table[] = { + { /* PnPBIOS GPF on boot */ + .callback = exploding_pnp_bios, + .ident = "Higraded P14H", + .matches = { + DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."), + DMI_MATCH(DMI_BIOS_VERSION, "07.00T"), + DMI_MATCH(DMI_SYS_VENDOR, "Higraded"), + DMI_MATCH(DMI_PRODUCT_NAME, "P14H"), + }, + }, + { /* PnPBIOS GPF on boot */ + .callback = exploding_pnp_bios, + .ident = "ASUS P4P800", + .matches = { + DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc."), + DMI_MATCH(DMI_BOARD_NAME, "P4P800"), + }, + }, + { } +}; + +static int __init pnpbios_init(void) +{ + int ret; + + if (pnpbios_disabled || dmi_check_system(pnpbios_dmi_table)) { + printk(KERN_INFO "PnPBIOS: Disabled\n"); + return -ENODEV; + } + +#ifdef CONFIG_PNPACPI + if (!acpi_disabled && !pnpacpi_disabled) { + pnpbios_disabled = 1; + printk(KERN_INFO "PnPBIOS: Disabled by ACPI PNP\n"); + return -ENODEV; + } +#endif /* CONFIG_ACPI */ + + /* scan the system for pnpbios support */ + if (!pnpbios_probe_system()) + return -ENODEV; + + /* make preparations for bios calls */ + pnpbios_calls_init(pnp_bios_install); + + /* read the node info */ + ret = pnp_bios_dev_node_info(&node_info); + if (ret) { + printk(KERN_ERR "PnPBIOS: Unable to get node info. Aborting.\n"); + return ret; + } + + /* register with the pnp layer */ + ret = pnp_register_protocol(&pnpbios_protocol); + if (ret) { + printk(KERN_ERR "PnPBIOS: Unable to register driver. Aborting.\n"); + return ret; + } + + /* start the proc interface */ + ret = pnpbios_proc_init(); + if (ret) + printk(KERN_ERR "PnPBIOS: Failed to create proc interface.\n"); + + /* scan for pnpbios devices */ + build_devlist(); + + return 0; +} + +subsys_initcall(pnpbios_init); + +static int __init pnpbios_thread_init(void) +{ + if (pnpbios_disabled) + return 0; +#ifdef CONFIG_HOTPLUG + init_completion(&unload_sem); + if (kernel_thread(pnp_dock_thread, NULL, CLONE_KERNEL) > 0) + unloading = 0; +#endif + return 0; +} + +#ifndef MODULE + +/* init/main.c calls pnpbios_init early */ + +/* Start the kernel thread later: */ +module_init(pnpbios_thread_init); + +#else + +/* + * N.B.: Building pnpbios as a module hasn't been fully implemented + */ + +MODULE_LICENSE("GPL"); + +static int __init pnpbios_init_all(void) +{ + int r; + + r = pnpbios_init(); + if (r) + return r; + r = pnpbios_thread_init(); + if (r) + return r; + return 0; +} + +static void __exit pnpbios_exit(void) +{ +#ifdef CONFIG_HOTPLUG + unloading = 1; + wait_for_completion(&unload_sem); +#endif + pnpbios_proc_exit(); + /* We ought to free resources here */ + return; +} + +module_init(pnpbios_init_all); +module_exit(pnpbios_exit); + +#endif + +EXPORT_SYMBOL(pnpbios_protocol); diff --git a/drivers/pnp/pnpbios/pnpbios.h b/drivers/pnp/pnpbios/pnpbios.h new file mode 100644 index 000000000000..01896e705ed4 --- /dev/null +++ b/drivers/pnp/pnpbios/pnpbios.h @@ -0,0 +1,47 @@ +/* + * pnpbios.h - contains local definitions + */ + +#pragma pack(1) +union pnp_bios_install_struct { + struct { + u32 signature; /* "$PnP" */ + u8 version; /* in BCD */ + u8 length; /* length in bytes, currently 21h */ + u16 control; /* system capabilities */ + u8 checksum; /* all bytes must add up to 0 */ + + u32 eventflag; /* phys. address of the event flag */ + u16 rmoffset; /* real mode entry point */ + u16 rmcseg; + u16 pm16offset; /* 16 bit protected mode entry */ + u32 pm16cseg; + u32 deviceID; /* EISA encoded system ID or 0 */ + u16 rmdseg; /* real mode data segment */ + u32 pm16dseg; /* 16 bit pm data segment base */ + } fields; + char chars[0x21]; /* To calculate the checksum */ +}; +#pragma pack() + +extern int pnp_bios_present(void); +extern int pnpbios_dont_use_current_config; +extern void *pnpbios_kmalloc(size_t size, int f); + +extern int pnpbios_parse_data_stream(struct pnp_dev *dev, struct pnp_bios_node * node); +extern int pnpbios_read_resources_from_node(struct pnp_resource_table *res, struct pnp_bios_node * node); +extern int pnpbios_write_resources_to_node(struct pnp_resource_table *res, struct pnp_bios_node * node); +extern void pnpid32_to_pnpid(u32 id, char *str); + +extern void pnpbios_print_status(const char * module, u16 status); +extern void pnpbios_calls_init(union pnp_bios_install_struct * header); + +#ifdef CONFIG_PNPBIOS_PROC_FS +extern int pnpbios_interface_attach_device(struct pnp_bios_node * node); +extern int pnpbios_proc_init (void); +extern void pnpbios_proc_exit (void); +#else +static inline int pnpbios_interface_attach_device(struct pnp_bios_node * node) { return 0; } +static inline int pnpbios_proc_init (void) { return 0; } +static inline void pnpbios_proc_exit (void) { ; } +#endif /* CONFIG_PNPBIOS_PROC_FS */ diff --git a/drivers/pnp/pnpbios/proc.c b/drivers/pnp/pnpbios/proc.c new file mode 100644 index 000000000000..6bb8e1973fd4 --- /dev/null +++ b/drivers/pnp/pnpbios/proc.c @@ -0,0 +1,292 @@ +/* + * /proc/bus/pnp interface for Plug and Play devices + * + * Written by David Hinds, dahinds@users.sourceforge.net + * Modified by Thomas Hood + * + * The .../devices and .../ and .../boot/ files are + * utilized by the lspnp and setpnp utilities, supplied with the + * pcmcia-cs package. + * http://pcmcia-cs.sourceforge.net + * + * The .../escd file is utilized by the lsescd utility written by + * Gunther Mayer. + * http://home.t-online.de/home/gunther.mayer/lsescd + * + * The .../legacy_device_resources file is not used yet. + * + * The other files are human-readable. + */ + +//#include +//#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "pnpbios.h" + +static struct proc_dir_entry *proc_pnp = NULL; +static struct proc_dir_entry *proc_pnp_boot = NULL; + +static int proc_read_pnpconfig(char *buf, char **start, off_t pos, + int count, int *eof, void *data) +{ + struct pnp_isa_config_struc pnps; + + if (pnp_bios_isapnp_config(&pnps)) + return -EIO; + return snprintf(buf, count, + "structure_revision %d\n" + "number_of_CSNs %d\n" + "ISA_read_data_port 0x%x\n", + pnps.revision, + pnps.no_csns, + pnps.isa_rd_data_port + ); +} + +static int proc_read_escdinfo(char *buf, char **start, off_t pos, + int count, int *eof, void *data) +{ + struct escd_info_struc escd; + + if (pnp_bios_escd_info(&escd)) + return -EIO; + return snprintf(buf, count, + "min_ESCD_write_size %d\n" + "ESCD_size %d\n" + "NVRAM_base 0x%x\n", + escd.min_escd_write_size, + escd.escd_size, + escd.nv_storage_base + ); +} + +#define MAX_SANE_ESCD_SIZE (32*1024) +static int proc_read_escd(char *buf, char **start, off_t pos, + int count, int *eof, void *data) +{ + struct escd_info_struc escd; + char *tmpbuf; + int escd_size, escd_left_to_read, n; + + if (pnp_bios_escd_info(&escd)) + return -EIO; + + /* sanity check */ + if (escd.escd_size > MAX_SANE_ESCD_SIZE) { + printk(KERN_ERR "PnPBIOS: proc_read_escd: ESCD size reported by BIOS escd_info call is too great\n"); + return -EFBIG; + } + + tmpbuf = pnpbios_kmalloc(escd.escd_size, GFP_KERNEL); + if (!tmpbuf) return -ENOMEM; + + if (pnp_bios_read_escd(tmpbuf, escd.nv_storage_base)) { + kfree(tmpbuf); + return -EIO; + } + + escd_size = (unsigned char)(tmpbuf[0]) + (unsigned char)(tmpbuf[1])*256; + + /* sanity check */ + if (escd_size > MAX_SANE_ESCD_SIZE) { + printk(KERN_ERR "PnPBIOS: proc_read_escd: ESCD size reported by BIOS read_escd call is too great\n"); + return -EFBIG; + } + + escd_left_to_read = escd_size - pos; + if (escd_left_to_read < 0) escd_left_to_read = 0; + if (escd_left_to_read == 0) *eof = 1; + n = min(count,escd_left_to_read); + memcpy(buf, tmpbuf + pos, n); + kfree(tmpbuf); + *start = buf; + return n; +} + +static int proc_read_legacyres(char *buf, char **start, off_t pos, + int count, int *eof, void *data) +{ + /* Assume that the following won't overflow the buffer */ + if (pnp_bios_get_stat_res(buf)) + return -EIO; + + return count; // FIXME: Return actual length +} + +static int proc_read_devices(char *buf, char **start, off_t pos, + int count, int *eof, void *data) +{ + struct pnp_bios_node *node; + u8 nodenum; + char *p = buf; + + if (pos >= 0xff) + return 0; + + node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL); + if (!node) return -ENOMEM; + + for (nodenum=pos; nodenum<0xff; ) { + u8 thisnodenum = nodenum; + /* 26 = the number of characters per line sprintf'ed */ + if ((p - buf + 26) > count) + break; + if (pnp_bios_get_dev_node(&nodenum, PNPMODE_DYNAMIC, node)) + break; + p += sprintf(p, "%02x\t%08x\t%02x:%02x:%02x\t%04x\n", + node->handle, node->eisa_id, + node->type_code[0], node->type_code[1], + node->type_code[2], node->flags); + if (nodenum <= thisnodenum) { + printk(KERN_ERR "%s Node number 0x%x is out of sequence following node 0x%x. Aborting.\n", "PnPBIOS: proc_read_devices:", (unsigned int)nodenum, (unsigned int)thisnodenum); + *eof = 1; + break; + } + } + kfree(node); + if (nodenum == 0xff) + *eof = 1; + *start = (char *)((off_t)nodenum - pos); + return p - buf; +} + +static int proc_read_node(char *buf, char **start, off_t pos, + int count, int *eof, void *data) +{ + struct pnp_bios_node *node; + int boot = (long)data >> 8; + u8 nodenum = (long)data; + int len; + + node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL); + if (!node) return -ENOMEM; + if (pnp_bios_get_dev_node(&nodenum, boot, node)) { + kfree(node); + return -EIO; + } + len = node->size - sizeof(struct pnp_bios_node); + memcpy(buf, node->data, len); + kfree(node); + return len; +} + +static int proc_write_node(struct file *file, const char __user *buf, + unsigned long count, void *data) +{ + struct pnp_bios_node *node; + int boot = (long)data >> 8; + u8 nodenum = (long)data; + int ret = count; + + node = pnpbios_kmalloc(node_info.max_node_size, GFP_KERNEL); + if (!node) + return -ENOMEM; + if (pnp_bios_get_dev_node(&nodenum, boot, node)) { + ret = -EIO; + goto out; + } + if (count != node->size - sizeof(struct pnp_bios_node)) { + ret = -EINVAL; + goto out; + } + if (copy_from_user(node->data, buf, count)) { + ret = -EFAULT; + goto out; + } + if (pnp_bios_set_dev_node(node->handle, boot, node) != 0) { + ret = -EINVAL; + goto out; + } + ret = count; +out: + kfree(node); + return ret; +} + +int pnpbios_interface_attach_device(struct pnp_bios_node * node) +{ + char name[3]; + struct proc_dir_entry *ent; + + sprintf(name, "%02x", node->handle); + + if (!proc_pnp) + return -EIO; + if ( !pnpbios_dont_use_current_config ) { + ent = create_proc_entry(name, 0, proc_pnp); + if (ent) { + ent->read_proc = proc_read_node; + ent->write_proc = proc_write_node; + ent->data = (void *)(long)(node->handle); + } + } + + if (!proc_pnp_boot) + return -EIO; + ent = create_proc_entry(name, 0, proc_pnp_boot); + if (ent) { + ent->read_proc = proc_read_node; + ent->write_proc = proc_write_node; + ent->data = (void *)(long)(node->handle+0x100); + return 0; + } + + return -EIO; +} + +/* + * When this is called, pnpbios functions are assumed to + * work and the pnpbios_dont_use_current_config flag + * should already have been set to the appropriate value + */ +int __init pnpbios_proc_init( void ) +{ + proc_pnp = proc_mkdir("pnp", proc_bus); + if (!proc_pnp) + return -EIO; + proc_pnp_boot = proc_mkdir("boot", proc_pnp); + if (!proc_pnp_boot) + return -EIO; + create_proc_read_entry("devices", 0, proc_pnp, proc_read_devices, NULL); + create_proc_read_entry("configuration_info", 0, proc_pnp, proc_read_pnpconfig, NULL); + create_proc_read_entry("escd_info", 0, proc_pnp, proc_read_escdinfo, NULL); + create_proc_read_entry("escd", S_IRUSR, proc_pnp, proc_read_escd, NULL); + create_proc_read_entry("legacy_device_resources", 0, proc_pnp, proc_read_legacyres, NULL); + + return 0; +} + +void __exit pnpbios_proc_exit(void) +{ + int i; + char name[3]; + + if (!proc_pnp) + return; + + for (i=0; i<0xff; i++) { + sprintf(name, "%02x", i); + if ( !pnpbios_dont_use_current_config ) + remove_proc_entry(name, proc_pnp); + remove_proc_entry(name, proc_pnp_boot); + } + remove_proc_entry("legacy_device_resources", proc_pnp); + remove_proc_entry("escd", proc_pnp); + remove_proc_entry("escd_info", proc_pnp); + remove_proc_entry("configuration_info", proc_pnp); + remove_proc_entry("devices", proc_pnp); + remove_proc_entry("boot", proc_pnp); + remove_proc_entry("pnp", proc_bus); + + return; +} diff --git a/drivers/pnp/pnpbios/rsparser.c b/drivers/pnp/pnpbios/rsparser.c new file mode 100644 index 000000000000..618ac15a9e90 --- /dev/null +++ b/drivers/pnp/pnpbios/rsparser.c @@ -0,0 +1,795 @@ +/* + * rsparser.c - parses and encodes pnpbios resource data streams + * + */ + +#include +#include +#include +#include + +#ifdef CONFIG_PCI +#include +#else +inline void pcibios_penalize_isa_irq(int irq) {} +#endif /* CONFIG_PCI */ + +#include "pnpbios.h" + +/* standard resource tags */ +#define SMALL_TAG_PNPVERNO 0x01 +#define SMALL_TAG_LOGDEVID 0x02 +#define SMALL_TAG_COMPATDEVID 0x03 +#define SMALL_TAG_IRQ 0x04 +#define SMALL_TAG_DMA 0x05 +#define SMALL_TAG_STARTDEP 0x06 +#define SMALL_TAG_ENDDEP 0x07 +#define SMALL_TAG_PORT 0x08 +#define SMALL_TAG_FIXEDPORT 0x09 +#define SMALL_TAG_VENDOR 0x0e +#define SMALL_TAG_END 0x0f +#define LARGE_TAG 0x80 +#define LARGE_TAG_MEM 0x81 +#define LARGE_TAG_ANSISTR 0x82 +#define LARGE_TAG_UNICODESTR 0x83 +#define LARGE_TAG_VENDOR 0x84 +#define LARGE_TAG_MEM32 0x85 +#define LARGE_TAG_FIXEDMEM32 0x86 + +/* + * Resource Data Stream Format: + * + * Allocated Resources (required) + * end tag -> + * Resource Configuration Options (optional) + * end tag -> + * Compitable Device IDs (optional) + * final end tag -> + */ + +/* + * Allocated Resources + */ + +static void +pnpbios_parse_allocated_irqresource(struct pnp_resource_table * res, int irq) +{ + int i = 0; + while (!(res->irq_resource[i].flags & IORESOURCE_UNSET) && i < PNP_MAX_IRQ) i++; + if (i < PNP_MAX_IRQ) { + res->irq_resource[i].flags = IORESOURCE_IRQ; // Also clears _UNSET flag + if (irq == -1) { + res->irq_resource[i].flags |= IORESOURCE_DISABLED; + return; + } + res->irq_resource[i].start = + res->irq_resource[i].end = (unsigned long) irq; + pcibios_penalize_isa_irq(irq); + } +} + +static void +pnpbios_parse_allocated_dmaresource(struct pnp_resource_table * res, int dma) +{ + int i = 0; + while (!(res->dma_resource[i].flags & IORESOURCE_UNSET) && i < PNP_MAX_DMA) i++; + if (i < PNP_MAX_DMA) { + res->dma_resource[i].flags = IORESOURCE_DMA; // Also clears _UNSET flag + if (dma == -1) { + res->dma_resource[i].flags |= IORESOURCE_DISABLED; + return; + } + res->dma_resource[i].start = + res->dma_resource[i].end = (unsigned long) dma; + } +} + +static void +pnpbios_parse_allocated_ioresource(struct pnp_resource_table * res, int io, int len) +{ + int i = 0; + while (!(res->port_resource[i].flags & IORESOURCE_UNSET) && i < PNP_MAX_PORT) i++; + if (i < PNP_MAX_PORT) { + res->port_resource[i].flags = IORESOURCE_IO; // Also clears _UNSET flag + if (len <= 0 || (io + len -1) >= 0x10003) { + res->port_resource[i].flags |= IORESOURCE_DISABLED; + return; + } + res->port_resource[i].start = (unsigned long) io; + res->port_resource[i].end = (unsigned long)(io + len - 1); + } +} + +static void +pnpbios_parse_allocated_memresource(struct pnp_resource_table * res, int mem, int len) +{ + int i = 0; + while (!(res->mem_resource[i].flags & IORESOURCE_UNSET) && i < PNP_MAX_MEM) i++; + if (i < PNP_MAX_MEM) { + res->mem_resource[i].flags = IORESOURCE_MEM; // Also clears _UNSET flag + if (len <= 0) { + res->mem_resource[i].flags |= IORESOURCE_DISABLED; + return; + } + res->mem_resource[i].start = (unsigned long) mem; + res->mem_resource[i].end = (unsigned long)(mem + len - 1); + } +} + +static unsigned char * +pnpbios_parse_allocated_resource_data(unsigned char * p, unsigned char * end, struct pnp_resource_table * res) +{ + unsigned int len, tag; + int io, size, mask, i; + + if (!p) + return NULL; + + /* Blank the resource table values */ + pnp_init_resource_table(res); + + while ((char *)p < (char *)end) { + + /* determine the type of tag */ + if (p[0] & LARGE_TAG) { /* large tag */ + len = (p[2] << 8) | p[1]; + tag = p[0]; + } else { /* small tag */ + len = p[0] & 0x07; + tag = ((p[0]>>3) & 0x0f); + } + + switch (tag) { + + case LARGE_TAG_MEM: + if (len != 9) + goto len_err; + io = *(short *) &p[4]; + size = *(short *) &p[10]; + pnpbios_parse_allocated_memresource(res, io, size); + break; + + case LARGE_TAG_ANSISTR: + /* ignore this for now */ + break; + + case LARGE_TAG_VENDOR: + /* do nothing */ + break; + + case LARGE_TAG_MEM32: + if (len != 17) + goto len_err; + io = *(int *) &p[4]; + size = *(int *) &p[16]; + pnpbios_parse_allocated_memresource(res, io, size); + break; + + case LARGE_TAG_FIXEDMEM32: + if (len != 9) + goto len_err; + io = *(int *) &p[4]; + size = *(int *) &p[8]; + pnpbios_parse_allocated_memresource(res, io, size); + break; + + case SMALL_TAG_IRQ: + if (len < 2 || len > 3) + goto len_err; + io = -1; + mask= p[1] + p[2]*256; + for (i=0;i<16;i++, mask=mask>>1) + if(mask & 0x01) io=i; + pnpbios_parse_allocated_irqresource(res, io); + break; + + case SMALL_TAG_DMA: + if (len != 2) + goto len_err; + io = -1; + mask = p[1]; + for (i=0;i<8;i++, mask = mask>>1) + if(mask & 0x01) io=i; + pnpbios_parse_allocated_dmaresource(res, io); + break; + + case SMALL_TAG_PORT: + if (len != 7) + goto len_err; + io = p[2] + p[3] *256; + size = p[7]; + pnpbios_parse_allocated_ioresource(res, io, size); + break; + + case SMALL_TAG_VENDOR: + /* do nothing */ + break; + + case SMALL_TAG_FIXEDPORT: + if (len != 3) + goto len_err; + io = p[1] + p[2] * 256; + size = p[3]; + pnpbios_parse_allocated_ioresource(res, io, size); + break; + + case SMALL_TAG_END: + p = p + 2; + return (unsigned char *)p; + break; + + default: /* an unkown tag */ + len_err: + printk(KERN_ERR "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", tag, len); + break; + } + + /* continue to the next tag */ + if (p[0] & LARGE_TAG) + p += len + 3; + else + p += len + 1; + } + + printk(KERN_ERR "PnPBIOS: Resource structure does not contain an end tag.\n"); + + return NULL; +} + + +/* + * Resource Configuration Options + */ + +static void +pnpbios_parse_mem_option(unsigned char *p, int size, struct pnp_option *option) +{ + struct pnp_mem * mem; + mem = pnpbios_kmalloc(sizeof(struct pnp_mem), GFP_KERNEL); + if (!mem) + return; + mem->min = ((p[5] << 8) | p[4]) << 8; + mem->max = ((p[7] << 8) | p[6]) << 8; + mem->align = (p[9] << 8) | p[8]; + mem->size = ((p[11] << 8) | p[10]) << 8; + mem->flags = p[3]; + pnp_register_mem_resource(option,mem); + return; +} + +static void +pnpbios_parse_mem32_option(unsigned char *p, int size, struct pnp_option *option) +{ + struct pnp_mem * mem; + mem = pnpbios_kmalloc(sizeof(struct pnp_mem), GFP_KERNEL); + if (!mem) + return; + mem->min = (p[7] << 24) | (p[6] << 16) | (p[5] << 8) | p[4]; + mem->max = (p[11] << 24) | (p[10] << 16) | (p[9] << 8) | p[8]; + mem->align = (p[15] << 24) | (p[14] << 16) | (p[13] << 8) | p[12]; + mem->size = (p[19] << 24) | (p[18] << 16) | (p[17] << 8) | p[16]; + mem->flags = p[3]; + pnp_register_mem_resource(option,mem); + return; +} + +static void +pnpbios_parse_fixed_mem32_option(unsigned char *p, int size, struct pnp_option *option) +{ + struct pnp_mem * mem; + mem = pnpbios_kmalloc(sizeof(struct pnp_mem), GFP_KERNEL); + if (!mem) + return; + mem->min = mem->max = (p[7] << 24) | (p[6] << 16) | (p[5] << 8) | p[4]; + mem->size = (p[11] << 24) | (p[10] << 16) | (p[9] << 8) | p[8]; + mem->align = 0; + mem->flags = p[3]; + pnp_register_mem_resource(option,mem); + return; +} + +static void +pnpbios_parse_irq_option(unsigned char *p, int size, struct pnp_option *option) +{ + struct pnp_irq * irq; + unsigned long bits; + + irq = pnpbios_kmalloc(sizeof(struct pnp_irq), GFP_KERNEL); + if (!irq) + return; + bits = (p[2] << 8) | p[1]; + bitmap_copy(irq->map, &bits, 16); + if (size > 2) + irq->flags = p[3]; + else + irq->flags = IORESOURCE_IRQ_HIGHEDGE; + pnp_register_irq_resource(option,irq); + return; +} + +static void +pnpbios_parse_dma_option(unsigned char *p, int size, struct pnp_option *option) +{ + struct pnp_dma * dma; + dma = pnpbios_kmalloc(sizeof(struct pnp_dma), GFP_KERNEL); + if (!dma) + return; + dma->map = p[1]; + dma->flags = p[2]; + pnp_register_dma_resource(option,dma); + return; +} + +static void +pnpbios_parse_port_option(unsigned char *p, int size, struct pnp_option *option) +{ + struct pnp_port * port; + port = pnpbios_kmalloc(sizeof(struct pnp_port), GFP_KERNEL); + if (!port) + return; + port->min = (p[3] << 8) | p[2]; + port->max = (p[5] << 8) | p[4]; + port->align = p[6]; + port->size = p[7]; + port->flags = p[1] ? PNP_PORT_FLAG_16BITADDR : 0; + pnp_register_port_resource(option,port); + return; +} + +static void +pnpbios_parse_fixed_port_option(unsigned char *p, int size, struct pnp_option *option) +{ + struct pnp_port * port; + port = pnpbios_kmalloc(sizeof(struct pnp_port), GFP_KERNEL); + if (!port) + return; + port->min = port->max = (p[2] << 8) | p[1]; + port->size = p[3]; + port->align = 0; + port->flags = PNP_PORT_FLAG_FIXED; + pnp_register_port_resource(option,port); + return; +} + +static unsigned char * +pnpbios_parse_resource_option_data(unsigned char * p, unsigned char * end, struct pnp_dev *dev) +{ + unsigned int len, tag; + int priority = 0; + struct pnp_option *option, *option_independent; + + if (!p) + return NULL; + + option_independent = option = pnp_register_independent_option(dev); + if (!option) + return NULL; + + while ((char *)p < (char *)end) { + + /* determine the type of tag */ + if (p[0] & LARGE_TAG) { /* large tag */ + len = (p[2] << 8) | p[1]; + tag = p[0]; + } else { /* small tag */ + len = p[0] & 0x07; + tag = ((p[0]>>3) & 0x0f); + } + + switch (tag) { + + case LARGE_TAG_MEM: + if (len != 9) + goto len_err; + pnpbios_parse_mem_option(p, len, option); + break; + + case LARGE_TAG_MEM32: + if (len != 17) + goto len_err; + pnpbios_parse_mem32_option(p, len, option); + break; + + case LARGE_TAG_FIXEDMEM32: + if (len != 9) + goto len_err; + pnpbios_parse_fixed_mem32_option(p, len, option); + break; + + case SMALL_TAG_IRQ: + if (len < 2 || len > 3) + goto len_err; + pnpbios_parse_irq_option(p, len, option); + break; + + case SMALL_TAG_DMA: + if (len != 2) + goto len_err; + pnpbios_parse_dma_option(p, len, option); + break; + + case SMALL_TAG_PORT: + if (len != 7) + goto len_err; + pnpbios_parse_port_option(p, len, option); + break; + + case SMALL_TAG_VENDOR: + /* do nothing */ + break; + + case SMALL_TAG_FIXEDPORT: + if (len != 3) + goto len_err; + pnpbios_parse_fixed_port_option(p, len, option); + break; + + case SMALL_TAG_STARTDEP: + if (len > 1) + goto len_err; + priority = 0x100 | PNP_RES_PRIORITY_ACCEPTABLE; + if (len > 0) + priority = 0x100 | p[1]; + option = pnp_register_dependent_option(dev, priority); + if (!option) + return NULL; + break; + + case SMALL_TAG_ENDDEP: + if (len != 0) + goto len_err; + if (option_independent == option) + printk(KERN_WARNING "PnPBIOS: Missing SMALL_TAG_STARTDEP tag\n"); + option = option_independent; + break; + + case SMALL_TAG_END: + if (option_independent != option) + printk(KERN_WARNING "PnPBIOS: Missing SMALL_TAG_ENDDEP tag\n"); + p = p + 2; + return (unsigned char *)p; + break; + + default: /* an unkown tag */ + len_err: + printk(KERN_ERR "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", tag, len); + break; + } + + /* continue to the next tag */ + if (p[0] & LARGE_TAG) + p += len + 3; + else + p += len + 1; + } + + printk(KERN_ERR "PnPBIOS: Resource structure does not contain an end tag.\n"); + + return NULL; +} + + +/* + * Compatible Device IDs + */ + +#define HEX(id,a) hex[((id)>>a) & 15] +#define CHAR(id,a) (0x40 + (((id)>>a) & 31)) +// + +void pnpid32_to_pnpid(u32 id, char *str) +{ + const char *hex = "0123456789abcdef"; + + id = be32_to_cpu(id); + str[0] = CHAR(id, 26); + str[1] = CHAR(id, 21); + str[2] = CHAR(id,16); + str[3] = HEX(id, 12); + str[4] = HEX(id, 8); + str[5] = HEX(id, 4); + str[6] = HEX(id, 0); + str[7] = '\0'; + + return; +} +// +#undef CHAR +#undef HEX + +static unsigned char * +pnpbios_parse_compatible_ids(unsigned char *p, unsigned char *end, struct pnp_dev *dev) +{ + int len, tag; + char id[8]; + struct pnp_id *dev_id; + + if (!p) + return NULL; + + while ((char *)p < (char *)end) { + + /* determine the type of tag */ + if (p[0] & LARGE_TAG) { /* large tag */ + len = (p[2] << 8) | p[1]; + tag = p[0]; + } else { /* small tag */ + len = p[0] & 0x07; + tag = ((p[0]>>3) & 0x0f); + } + + switch (tag) { + + case LARGE_TAG_ANSISTR: + strncpy(dev->name, p + 3, len >= PNP_NAME_LEN ? PNP_NAME_LEN - 2 : len); + dev->name[len >= PNP_NAME_LEN ? PNP_NAME_LEN - 1 : len] = '\0'; + break; + + case SMALL_TAG_COMPATDEVID: /* compatible ID */ + if (len != 4) + goto len_err; + dev_id = pnpbios_kmalloc(sizeof (struct pnp_id), GFP_KERNEL); + if (!dev_id) + return NULL; + memset(dev_id, 0, sizeof(struct pnp_id)); + pnpid32_to_pnpid(p[1] | p[2] << 8 | p[3] << 16 | p[4] << 24,id); + memcpy(&dev_id->id, id, 7); + pnp_add_id(dev_id, dev); + break; + + case SMALL_TAG_END: + p = p + 2; + return (unsigned char *)p; + break; + + default: /* an unkown tag */ + len_err: + printk(KERN_ERR "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", tag, len); + break; + } + + /* continue to the next tag */ + if (p[0] & LARGE_TAG) + p += len + 3; + else + p += len + 1; + } + + printk(KERN_ERR "PnPBIOS: Resource structure does not contain an end tag.\n"); + + return NULL; +} + + +/* + * Allocated Resource Encoding + */ + +static void pnpbios_encode_mem(unsigned char *p, struct resource * res) +{ + unsigned long base = res->start; + unsigned long len = res->end - res->start + 1; + p[4] = (base >> 8) & 0xff; + p[5] = ((base >> 8) >> 8) & 0xff; + p[6] = (base >> 8) & 0xff; + p[7] = ((base >> 8) >> 8) & 0xff; + p[10] = (len >> 8) & 0xff; + p[11] = ((len >> 8) >> 8) & 0xff; + return; +} + +static void pnpbios_encode_mem32(unsigned char *p, struct resource * res) +{ + unsigned long base = res->start; + unsigned long len = res->end - res->start + 1; + p[4] = base & 0xff; + p[5] = (base >> 8) & 0xff; + p[6] = (base >> 16) & 0xff; + p[7] = (base >> 24) & 0xff; + p[8] = base & 0xff; + p[9] = (base >> 8) & 0xff; + p[10] = (base >> 16) & 0xff; + p[11] = (base >> 24) & 0xff; + p[16] = len & 0xff; + p[17] = (len >> 8) & 0xff; + p[18] = (len >> 16) & 0xff; + p[19] = (len >> 24) & 0xff; + return; +} + +static void pnpbios_encode_fixed_mem32(unsigned char *p, struct resource * res) +{ unsigned long base = res->start; + unsigned long len = res->end - res->start + 1; + p[4] = base & 0xff; + p[5] = (base >> 8) & 0xff; + p[6] = (base >> 16) & 0xff; + p[7] = (base >> 24) & 0xff; + p[8] = len & 0xff; + p[9] = (len >> 8) & 0xff; + p[10] = (len >> 16) & 0xff; + p[11] = (len >> 24) & 0xff; + return; +} + +static void pnpbios_encode_irq(unsigned char *p, struct resource * res) +{ + unsigned long map = 0; + map = 1 << res->start; + p[1] = map & 0xff; + p[2] = (map >> 8) & 0xff; + return; +} + +static void pnpbios_encode_dma(unsigned char *p, struct resource * res) +{ + unsigned long map = 0; + map = 1 << res->start; + p[1] = map & 0xff; + return; +} + +static void pnpbios_encode_port(unsigned char *p, struct resource * res) +{ + unsigned long base = res->start; + unsigned long len = res->end - res->start + 1; + p[2] = base & 0xff; + p[3] = (base >> 8) & 0xff; + p[4] = base & 0xff; + p[5] = (base >> 8) & 0xff; + p[7] = len & 0xff; + return; +} + +static void pnpbios_encode_fixed_port(unsigned char *p, struct resource * res) +{ + unsigned long base = res->start; + unsigned long len = res->end - res->start + 1; + p[1] = base & 0xff; + p[2] = (base >> 8) & 0xff; + p[3] = len & 0xff; + return; +} + +static unsigned char * +pnpbios_encode_allocated_resource_data(unsigned char * p, unsigned char * end, struct pnp_resource_table * res) +{ + unsigned int len, tag; + int port = 0, irq = 0, dma = 0, mem = 0; + + if (!p) + return NULL; + + while ((char *)p < (char *)end) { + + /* determine the type of tag */ + if (p[0] & LARGE_TAG) { /* large tag */ + len = (p[2] << 8) | p[1]; + tag = p[0]; + } else { /* small tag */ + len = p[0] & 0x07; + tag = ((p[0]>>3) & 0x0f); + } + + switch (tag) { + + case LARGE_TAG_MEM: + if (len != 9) + goto len_err; + pnpbios_encode_mem(p, &res->mem_resource[mem]); + mem++; + break; + + case LARGE_TAG_MEM32: + if (len != 17) + goto len_err; + pnpbios_encode_mem32(p, &res->mem_resource[mem]); + mem++; + break; + + case LARGE_TAG_FIXEDMEM32: + if (len != 9) + goto len_err; + pnpbios_encode_fixed_mem32(p, &res->mem_resource[mem]); + mem++; + break; + + case SMALL_TAG_IRQ: + if (len < 2 || len > 3) + goto len_err; + pnpbios_encode_irq(p, &res->irq_resource[irq]); + irq++; + break; + + case SMALL_TAG_DMA: + if (len != 2) + goto len_err; + pnpbios_encode_dma(p, &res->dma_resource[dma]); + dma++; + break; + + case SMALL_TAG_PORT: + if (len != 7) + goto len_err; + pnpbios_encode_port(p, &res->port_resource[port]); + port++; + break; + + case SMALL_TAG_VENDOR: + /* do nothing */ + break; + + case SMALL_TAG_FIXEDPORT: + if (len != 3) + goto len_err; + pnpbios_encode_fixed_port(p, &res->port_resource[port]); + port++; + break; + + case SMALL_TAG_END: + p = p + 2; + return (unsigned char *)p; + break; + + default: /* an unkown tag */ + len_err: + printk(KERN_ERR "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", tag, len); + break; + } + + /* continue to the next tag */ + if (p[0] & LARGE_TAG) + p += len + 3; + else + p += len + 1; + } + + printk(KERN_ERR "PnPBIOS: Resource structure does not contain an end tag.\n"); + + return NULL; +} + + +/* + * Core Parsing Functions + */ + +int +pnpbios_parse_data_stream(struct pnp_dev *dev, struct pnp_bios_node * node) +{ + unsigned char * p = (char *)node->data; + unsigned char * end = (char *)(node->data + node->size); + p = pnpbios_parse_allocated_resource_data(p,end,&dev->res); + if (!p) + return -EIO; + p = pnpbios_parse_resource_option_data(p,end,dev); + if (!p) + return -EIO; + p = pnpbios_parse_compatible_ids(p,end,dev); + if (!p) + return -EIO; + return 0; +} + +int +pnpbios_read_resources_from_node(struct pnp_resource_table *res, + struct pnp_bios_node * node) +{ + unsigned char * p = (char *)node->data; + unsigned char * end = (char *)(node->data + node->size); + p = pnpbios_parse_allocated_resource_data(p,end,res); + if (!p) + return -EIO; + return 0; +} + +int +pnpbios_write_resources_to_node(struct pnp_resource_table *res, + struct pnp_bios_node * node) +{ + unsigned char * p = (char *)node->data; + unsigned char * end = (char *)(node->data + node->size); + p = pnpbios_encode_allocated_resource_data(p,end,res); + if (!p) + return -EIO; + return 0; +} -- cgit v1.2.3-59-g8ed1b