cmostool.c

在dos 与Linux下通过命令来改变BIOS项设置。

#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h> /* for libc5 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
#include <i86.h>
#include "cmostool.h"


struct  nvtokenIndex
{
   unsigned short token;
   unsigned short start;
};


#define flash_phy_addr 0xFFF00000
#define Flash_Size 1024*1024*2
unsigned char flash[Flash_Size];
#define TokenItemMax 700


#define  Media1 0x0001 // Media type 1
#define Media2  0x0002 // Media type 2
#define Media3  0x0003 // Media type 3
#define MEDIAMASK  0x0007 // ; Mask to determine media type
#define READONLY   0x0004 //; Field has no writable storage
#define BYTESTRING  0x0008 // ; Field is byte string
#define TOKENSUM  0x0010 // ; Checksum required
#define CHKSUM   0x0050 // ; TOKENSUM plus INITIALIZED
#define CRC    0x0060 //; CRC field plus INITIALIZED
#define INITIALIZED   0x0040 // ; Defaults used and setup writes
#define EARLY_CHECKSUM_POS  0x0F0 //   
#define EARLY_CHECKSUM  0x080

struct bcpHeader
{
        unsigned char  signature[6];
        unsigned char  majorRev;
        unsigned char  minorRev;
        unsigned short  bcpLength; 
};

struct tablePtr
{
  unsigned short  toffset;
  unsigned short  tsize;
};

#pragma pack(1)
struct bcpNVStruc
{
   struct bcpHeader bcpheader;
   unsigned char bcpiCMOSControl;
   struct tablePtr tableptr;
   unsigned char extCmosStart;
   unsigned char extCmosEnd;
   unsigned short cmosCRCSignature;
   short cmosCRCMask;
 
   unsigned short tokenTableStart;
   unsigned short tokenTableEnd;
   unsigned short stdDefaults;
   unsigned short mfgDefaults;
   unsigned short mediaStart;
} ;//__attribute__ ((packed));
#pragma pack()

/*struct bcpPnpNvsStruc
{
  struct bcpHeader bcpheader;
//  Header bcpHeader  <'BCPNVS', 0, 2, SIZEOF bcpPnpNvsStruc>
  unsigned short NvramTotalSize; 
  unsigned short NvramMaxCfgSpace;
  unsigned int NvramBaseAddress;
  unsigned short ESCDTotalSize; 
  unsigned short  ESCDSegmentAddress; 
  unsigned int    NvramLeadingControlArea;
  unsigned short  NvramLeadingDataArea;
} __attribute__ ((packed));*/

 struct NVTStruc
{
        unsigned char nvt_beg_Signature[4];
        unsigned char nvt_end_Signature[4];
        unsigned int nvt_beg_pos;
        unsigned int nvt_end_pos;
}; 

struct NVTStruc nvstruct;

//struct bcpPnpNvsStruc bcppnpnvstruct;

#pragma pack(1)
union tokenStruc
{
   unsigned char  tokenitem[3];
   struct token_union 
   {
        unsigned char flag:8;
        unsigned short start_pos:12;
        unsigned short width:4; 
   }token;
     
} ;//__attribute__ ((packed));
#pragma pack()


_Packed struct NVPHeader
{
        unsigned char  signature[4];
        unsigned char  majorRev;
        unsigned char  minorRev;
        unsigned short tokenTableEnd;
};//__attribute__ ((packed));


struct tokentableStruc
{
//        struct NVPHeader nvpheader;
        union tokenStruc tokenItem[TokenItemMax];
        unsigned int itemCount;
};//__attribute__ ((packed));;


struct tokentableStruc tokentable;


void fill_flash()
{
        unsigned char *pflash;
        unsigned int i;
        int fd;

        pflash=(unsigned char*)flash_phy_addr;
        for(i=0; i<Flash_Size; i++)
                flash[i]=*(pflash+i);
    
};

struct bcpNVStruc bcpnvstruc;

void fill_bcpNV_NVT_Stuct()
{
        unsigned int i;
        strncpy(bcpnvstruc.bcpheader.signature,"BCPNV ",6);
        strncpy(nvstruct.nvt_beg_Signature,"$NVT",4);
        strncpy(nvstruct.nvt_end_Signature,"$TVN",4);
        for(i=0;i<Flash_Size;i++)
        {

                if(strncmp((flash+i),bcpnvstruc.bcpheader.signature,6)==0)
                {
                                memcpy(((unsigned char*)(&(bcpnvstruc))),(flash+i),sizeof(bcpnvstruc));
                                i=i+sizeof(bcpnvstruc);
                                //printf("CMOSsignature=%x\n",bcpnvstruc.cmosCRCSignature);
                                continue;
                        
                }


                if(strncmp((flash+i),nvstruct.nvt_beg_Signature,4)==0)
                {
                                nvstruct.nvt_beg_pos = i+8;
                                //printf("nv_beg_pos=%x\n",nvstruct.nvt_beg_pos);
                                i+=20;
                                continue;

                }


                if(strncmp((flash+i),nvstruct.nvt_end_Signature,4)==0)
                {
                                nvstruct.nvt_end_pos = i;
                                //printf("nv_end_pos=%x\n",i);
                                break;

                }

        } 
}


void fill_TokenTable()
{
        unsigned int tokenStartAddr;
        unsigned int tokenEndAddr;
        unsigned int tokenCount;
        
        tokenStartAddr = bcpnvstruc.tokenTableStart;
        tokenEndAddr = bcpnvstruc.tokenTableEnd;
//        tokenCount = (tokenEndAddr - tokenStartAddr)/sizeof(union tokenStruc);  
        tokenStartAddr = nvstruct.nvt_beg_pos ;
        tokenEndAddr = nvstruct.nvt_end_pos-1;
        tokenCount = (tokenEndAddr - tokenStartAddr+1)/sizeof(union tokenStruc);

        bzero(&tokentable,sizeof(tokentable)); 
        memcpy(&tokentable,(flash+tokenStartAddr),tokenEndAddr - tokenStartAddr+1);
            
        tokentable.itemCount = tokenCount;
}


struct cmosTokenStruct 
{
   unsigned char media;
   unsigned char tokensum:1;
   unsigned char bytestring:1;
   unsigned char early:1;
   unsigned short len;
   unsigned short pos;
};

unsigned short getSTDtokenValue(struct cmosTokenStruct tokenstruct,unsigned char* cmosValue)
{
        unsigned int  *pstorage;
        unsigned int  storagemask=0xFFFFFF;
        unsigned char offset_r;
        unsigned int offset_l;
        unsigned int CMOS_pos_char;
        unsigned int retVal;

        CMOS_pos_char = tokenstruct.pos/8;
             offset_r = tokenstruct.pos%8;      
             offset_l = 32-offset_r-tokenstruct.len;

        pstorage = (unsigned int*)( cmosValue + CMOS_pos_char); 
        storagemask >>= offset_r;
        storagemask <<= offset_r;
        storagemask <<= offset_l;
        storagemask >>= offset_l;

        retVal = *pstorage & storagemask;
        return retVal>>offset_r; 
}

unsigned short  setSTDtokenValue(struct cmosTokenStruct tokenstruct,unsigned char* cmosValue,unsigned short tokenValue1)
{
        unsigned int  *pstorage;
        unsigned int  storagemask=0xFFFFFF;
        unsigned char offset_r;
        unsigned int offset_l;
        unsigned int CMOS_pos_char;
        unsigned int retVal;
        unsigned int tokenValue=tokenValue1;

        CMOS_pos_char = tokenstruct.pos/8;
             offset_r = tokenstruct.pos%8;      
             offset_l = 32-offset_r-tokenstruct.len;

        pstorage = (unsigned int*)( cmosValue + CMOS_pos_char); 
        storagemask >>= offset_r;
        storagemask <<= offset_r;
        storagemask <<= offset_l;
        storagemask >>= offset_l;

        tokenValue<<=offset_r;
        *pstorage=(*pstorage&(~storagemask))+tokenValue; 
        return *pstorage; 
}       



struct CMOSStruct
{
        struct cmosTokenStruct cmostokenstruct[TokenItemMax];
        unsigned short tokenValue[TokenItemMax];
        unsigned short tokenItemCount;
        unsigned short checksum_position; 
        unsigned short earlysum_position;
        unsigned short crc_position;
        unsigned short ipl_position;
};

static struct CMOSStruct cmosstruct;

//static unsigned short startaddMedia[8]={0x00,0x400,0x620,0x620,0x620,0x628,0x628,0x628};

//static unsigned short startaddMedia[8]={0x00,0x400,0x7c0,0x840,0x840,0x848,0x848,0x848};//stuttgart

//static unsigned short startaddMedia[8]={0x00,0x400,0x800,0x858,0x858,0x860,0x860,0x860};//for Dell project
static unsigned short startaddMedia[8]={0x00,0x400,0x700,0x700,0x700,0x708,0x708,0x708}; //for 5372
void fillcmosTokenStruct()
{
        unsigned short i=0;
        unsigned short flag=0;

        cmosstruct.earlysum_position=0;
        cmosstruct.checksum_position=0;
        cmosstruct.crc_position=0;

        for(i=0; i<tokentable.itemCount;i++)
        {

                flag=tokentable.tokenItem[i].token.flag;
                cmosstruct.cmostokenstruct[i].media = flag&0x7;
                cmosstruct.cmostokenstruct[i].tokensum = flag&TOKENSUM?1:0;  
                cmosstruct.cmostokenstruct[i].early = flag&EARLY_CHECKSUM?1:0;
                cmosstruct.cmostokenstruct[i].bytestring = flag&BYTESTRING?1:0;
                cmosstruct.cmostokenstruct[i].pos = tokentable.tokenItem[i].token.start_pos+startaddMedia[flag&0x7];
                cmosstruct.cmostokenstruct[i].len = tokentable.tokenItem[i].token.width+1;

              
                if((flag& EARLY_CHECKSUM_POS) == EARLY_CHECKSUM_POS)
                {       
                        cmosstruct.earlysum_position = i;
                        continue;
                }       

                if(flag==CRC)
                {
                        unsigned short crcflag=tokentable.tokenItem[i+1].token.flag;
                        if(crcflag==CRC)
                        {       
                                cmosstruct.checksum_position=i;
                                i++;
                        }
                        else
                                cmosstruct.crc_position=i;
                }

        }
                i=cmosstruct.checksum_position+1;
                flag=tokentable.tokenItem[i].token.flag;
                cmosstruct.cmostokenstruct[i].media = flag&0x7;
                cmosstruct.cmostokenstruct[i].tokensum = flag&TOKENSUM?1:0;
                cmosstruct.cmostokenstruct[i].bytestring = flag&BYTESTRING?1:0;
                cmosstruct.cmostokenstruct[i].pos = tokentable.tokenItem[i].token.start_pos+startaddMedia[flag&0x7];
                cmosstruct.cmostokenstruct[i].len = tokentable.tokenItem[i].token.width+1;
                cmosstruct.tokenItemCount=tokentable.itemCount;
#ifdef DEBUG
                i=cmosstruct.earlysum_position;
                printf("Earlycheckpos=%d start_pos=0x%x  width=0x%x flag=0x%x\n",i,tokentable.tokenItem[i].token.start_pos,tokentable.tokenItem[i].token.width+1,tokentable.tokenItem[i].token.flag);

                i=cmosstruct.checksum_position;
                printf("checksumpos=%d start_pos=0x%x  width=0x%x flag=0x%x\n",i,tokentable.tokenItem[i].token.start_pos,tokentable.tokenItem[i].token.width+1,tokentable.tokenItem[i].token.flag);

                i=cmosstruct.crc_position;
                printf("CRC pos=%d start_pos=0x%x  width=0x%x flag=0x%x\n",i,tokentable.tokenItem[i].token.start_pos,tokentable.tokenItem[i].token.width+1,tokentable.tokenItem[i].token.flag);

#endif



};


void fillcmosTokenValue(struct CMOSStruct* pcmosstruct,unsigned char* CMOSvalue)
{
       unsigned short i=0;
       for(i=0; i<pcmosstruct->tokenItemCount;i++)
       {
                if(!pcmosstruct->cmostokenstruct[i].bytestring)
                {
                        pcmosstruct->tokenValue[i]=getSTDtokenValue(pcmosstruct->cmostokenstruct[i], CMOSvalue);
                }
                else
                {
                         pcmosstruct->tokenValue[i]=i;
                }

#ifdef DEBUG
//           if(pcmosstruct->cmostokenstruct[i].tokensum && pcmosstruct->cmostokenstruct[i].media==0)   
#endif


       }                

}

/*
 * CRC function begins
 */

unsigned short crc=0;

unsigned short  coreUpdateCRC(unsigned char data)
{
        unsigned short retval=0;
        static unsigned short polymask=0xA001;
        unsigned char i=0;
       
        crc=crc&0xFF00 + (crc&0xFF)^data;
        for(i=0;i<8;i++)
        {
                   unsigned short  carry=0;
                   unsigned short  shiftcrc;
                   carry=crc&0x1;
                   shiftcrc = crc>>1;
                   crc=shiftcrc+(carry<<15);
                   if(carry)
                   {
                        crc=crc^0xA001;
                   }

       }
        return crc;
}

/*unsigned short  coreUpdateCRC(unsigned char data)
{
   static unsigned short crc=0x305d;
//   static unsigned short crc=0x3309; //for BIOS 1.20
   unsigned short  POLY_MASK=0xA001;

 //  printf("Initial CRC value=%x\n",crc);



   _asm mov  dx, crc
   _asm mov  al, data
   _asm xor dl, al
   _asm mov cx, 8

   feedbackLoop:
   _asm    clc
   _asm    ror dx, 1
   _asm    jnc feedbackLoopBottom
   _asm    xor dx,POLY_MASK
   feedbackLoopBottom:
   _asm  loop feedbackLoop
   _asm  mov  crc, dx

   return  crc;

}*/



unsigned short UpdateCorefromStrToken(struct cmosTokenStruct Tokenitem,unsigned char* DefaultCmos)
{

        unsigned short Startbybyte;
        unsigned char  Sizebybyte,buf;
        int index;
        unsigned int crcvalue;


        Startbybyte = (Tokenitem.pos)/ 8;
        Sizebybyte = Tokenitem.len;

        //printf("Byte string\n"); 
        for(index=0;index<Sizebybyte;index++)
        {
                 buf = DefaultCmos[Startbybyte+index];
                 crcvalue= coreUpdateCRC(buf);
        }
        return crcvalue;
};

unsigned short UpdateCorefromStdToken(struct cmosTokenStruct Tokenitem,unsigned short tokenValue)