/* Copyright (C) 2001-2001 Fujitsu Siemens Computers   Joachim Braeuer   This file is part of smbios   smbios 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 of the License,   or (at your option) any later version.   smbios 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 smbios; see the file COPYING. If not, write to the   Free Software Foundation, Inc., 59 Temple Place - Suite 330,   Boston, MA 02111-1307, USA.*//* $Log: cooking.c,v $/* Revision 1.1  2001/09/15 14:52:43  bretthauert/* initial release/* *//** \file cooking.c *  DMI-BIOS and SM-BIOS interpreting (cooking) functions *  The functions defined in this file generate a human readable output of the *  raw binary DMI- and SM-BIOS types. However, every time the specification of *  DMI- and SM-BIOS (types) change, these changes have to be adopted in these *  routines, too. *   *  \author Thomas Bretthauer *  \author Joachim Braeuer *  \version 0.1 *  \date January 2001 */#ifndef __KERNEL__#  define __KERNEL__#endif#ifndef MODULE#  define MODULE#endif#define __NO_VERSION__		/* don't define kernel_version in module.h */#include <linux/module.h>#include <linux/kernel.h>	/* ... for 'printk()' */#include <linux/errno.h>	/* ... error codes */#include <linux/types.h>	/* ... fixed size types definitions, '__u8'... */#include <linux/proc_fs.h>  /* ... /proc file system ... */#include <linux/string.h>	/* ... for 'memcpy()', 'strncmp()' */#include "strgdef.h"        /* human readable output string definitions for directories,                             * files and file contents                             */#include "bios.h"		    /* ... local declarations for DMI-, SM-BIOS */#include "cooking.h"	    /* ... local declarations for interpreting DMI- and SM-BIOS types */EXPORT_NO_SYMBOLS;/** \fn unsigned char * bios_cook (smbios_struct *smbiosstruct, unsigned int * plength)  * \brief huge switch that calls the cooking functions for every SMBIOS structure  * \param smbiosstruct pointer to SMBIOS raw structure  * \param plength amount of memory allocated by functions called from this function  * \return pointer to string that holds the interpreted data  *  * this function gets a raw SMBIOS structure. it calls the appropriate cooking function  * whitch interpretes the raw data and builds a string with the interpreted data.  * the caller is responsible to free the memory allocated by the "sub"-functions.  *  * \author Joachim Braeuer  * \date March 2001  */unsigned char *bios_cook (smbios_struct *smbiosstruct, unsigned int * plength){	unsigned char *scratch = NULL;      /* pointer that holds the interpreded data */	/* do we have a valid SMBIOS? */	if ( !smbiosstruct )	   return NULL;	/* switch between the different smbios types to interpret and call the appropriate	 * cook function.	 */	switch (smbiosstruct->type)	{        case 0:	        scratch = bios_cook_type_0 (smbiosstruct, plength);	        break;	    case 1:	        scratch = bios_cook_type_1 (smbiosstruct, plength);	        break;	    case 2:	        scratch = bios_cook_type_2 (smbiosstruct, plength);	        break;	    case 3:	        scratch = bios_cook_type_3 (smbiosstruct, plength);	        break;	    case 4:	        scratch = bios_cook_type_4 (smbiosstruct, plength);	        break;	    case 5:	        scratch = bios_cook_type_5 (smbiosstruct, plength);	        break;	    case 6:	        scratch = bios_cook_type_6 (smbiosstruct, plength);	        break;	    case 7:	        scratch = bios_cook_type_7 (smbiosstruct, plength);	        break;	    case 8:		        scratch = bios_cook_type_8 (smbiosstruct, plength);		        break;		    case 9:		        scratch = bios_cook_type_9 (smbiosstruct, plength);		        break;	    case 10:		        scratch = bios_cook_type_10 (smbiosstruct, plength);		        break;		    case 11:		        scratch = bios_cook_type_11 (smbiosstruct, plength);		        break;	    case 12:		        scratch = bios_cook_type_12 (smbiosstruct, plength);		        break;    		    case 13:		        scratch = bios_cook_type_13 (smbiosstruct, plength);		        break;	    case 16:		        scratch = bios_cook_type_16 (smbiosstruct, plength);		        break;	    case 17:		        scratch = bios_cook_type_17 (smbiosstruct, plength);		        break;	    case 19:		        scratch = bios_cook_type_19 (smbiosstruct, plength);		        break;	    case 20:		        scratch = bios_cook_type_20 (smbiosstruct, plength);		        break;	    case 32:		        scratch = bios_cook_type_32 (smbiosstruct, plength);		        break;	    case 127:		        scratch = bios_cook_type_127 (smbiosstruct, plength);		        break;        				/* if it's none of the supported types, just display the standard		 * DMI header */	    default:	        {                unsigned char line[512];                unsigned char line_type[128];     /* type */                unsigned char line_length[128];   /* length */                unsigned char line_handle[128];   /* handle */                unsigned char line_text[128];     /* not supported message */                /* prepare type, length, handle and not supported message */                sprintf (line_type, "%20s : %d\n", TYPE, smbiosstruct->type);                sprintf (line_length, "%20s : %d %s\n", LENGTH, smbiosstruct->length, BYTES);                sprintf (line_handle, "%20s : %d\n", HANDLE, smbiosstruct->handle);	            sprintf (line_text, "\n%s\n\n", NOT_SUPPORTED);                sprintf (line, "%s%s%s%s", line_type, line_length, line_handle, line_text);                *plength = strlen (line);                /* allocate memory ... */                scratch = kmalloc (*plength+1, GFP_BUFFER);                if (scratch == NULL)                {                    *plength = 0;                    return NULL;                }	                /* ... and copy the string */                memcpy (scratch, line, *plength);            }	} /* end switch */		/* return a string with all the interpreted data for the given raw structure */	/* the caller is responsible to free the memory. */	return scratch;}/** \fn unsigned char * bios_cook_type_0 (smbios_struct *smbiosstruct, unsigned int * plength)  * \brief writes interpreted SMBIOS Type 0 data to a /proc file  * \param smbiosstruct pointer to SMBIOS Type 0 raw structure  * \param plength amount of memory allocated by this function  * \return pointer to string that holds the interpreted data  *  * this function gets a raw SMBIOS Type 0 (Bios) structure. it  * interpretes the raw data and builds a string with the interpreted  * data. this is the return value of this structure. the caller is  * responsible to free the allocated memory.  *  * \author Joachim Braeuer  * \date March 2001  */unsigned char *bios_cook_type_0 (smbios_struct * smbiosstruct, unsigned int * plength){	smbios_type_0 *type0;    unsigned char * scratch;	/* contains the full block of interpreted data */    /* on some systems the system crashed if the stack (local variables) */    /* is bigger than one pages (4k). since linux needs some space in this */    /* page the variables should never exceed 3kB. */	unsigned char file[2800];	/* contains one line of the above file */    unsigned char line[128];    /* cast raw data to type 0 structure */    type0 = (smbios_type_0 *)smbiosstruct;    /* prepare header string */    sprintf (line, "%-35s%s %d %s\n", TYPE, SEP1, smbiosstruct->type, TYPE0_NAME);    strcpy(file, line);	sprintf (line, "%-35s%s %d %s\n", LENGTH, SEP1, smbiosstruct->length, BYTES);	strcat(file, line);	sprintf (line, "%-35s%s %d\n\n", HANDLE, SEP1, smbiosstruct->handle);	strcat(file, line);	/* prepare strings with type 0 information */	sprintf (line, "%-35s%s %s\n", TYPE0_VENDOR, SEP1, GetString(smbiosstruct, (unsigned int)(type0->vendor)));	strcat(file, line);	sprintf (line, "%-35s%s %s\n", TYPE0_VERSION, SEP1, GetString(smbiosstruct, (unsigned int)(type0->version)));	strcat(file, line);	sprintf (line, "%-35s%s %X\n", TYPE0_ADR_SEG, SEP1, type0->startaddr);	strcat(file, line);	sprintf (line, "%-35s%s %s\n", TYPE0_REL_DATE, SEP1, GetString(smbiosstruct, (unsigned int)(type0->reldate)));	strcat(file, line);	sprintf (line, "%-35s%s %d kB\n", TYPE0_ROM_SIZE, SEP1, ((type0->romsize)+1) * 64);	strcat(file, line);	    /* bios characteristics interpretation */    sprintf(line, "%-35s%s\n", TYPE0_CHAR, SEP1);    strcat(file, line);    if( (type0->characteristics) & 0x0000000000000001 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_RES);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000000002 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_RES);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000000004 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_UNKNOWN);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000000008 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_NOTSUP);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000000010 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_ISA);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000000020 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_MCA);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000000040 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_EISA);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000000080 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_PCI);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000000100 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_PCMCIA);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000000200 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_PNP);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000000400 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_APM);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000000800 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_FLASH);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000001000 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_SHADOWING);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000002000 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_VL);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000004000 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_ESCD);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000008000 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_BOOTCD);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000010000 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_SELBOOT);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000020000 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_BIOS_IS_SOCKETED);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000040000 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_PCMCIA_BOOT);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000080000 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_ENH_DISK_DRIVE);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000100000 )    {        sprintf(line, "%-35s  %s %s \n", "", SEP2, TYPE0_CHAR_FD_NEC);        strcat(file, line);    }    if( (type0->characteristics) & 0x0000000000200000 )