bat4fsc.c

C中嵌入汇编

#include <time.h>
#include <dos.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <math.h>

#define EC_TIMER    3000                    /* 3000 * 15usec = 15 msec */
#define EC_OK       0
#define EC_TIMEOUT  1
#define EC_INVALID_PORT 2
#define PPI 0x61
typedef unsigned char   BYTE;
typedef unsigned int    WORD;
typedef unsigned long   DWORD;

typedef enum {
              ec_sc=0x66,
              ec_data=0x62
             }ECIOPORT;

int WaitECOBFReady();
int WaitECIBFReady();
int WriteEC(ECIOPORT port, BYTE cmd);
int ReadEC(BYTE * const data);
void ClearKBDBuf (void);

DWORD SMBIOSEntry=0;
WORD  SMBIOSLen  =0;

typedef struct
{   
  BYTE  type;                    /*The special HEADER type*/
  BYTE  length;                  /*The special HEADER from Begin*/
  WORD  handle;
} HEADER;


typedef struct
{
 int datasize;
 int start;
 int end;
 BYTE type;
 BYTE length;
 WORD handle;
} szType;


typedef struct
{
    BYTE    dbType;
    BYTE    dbLength;
    WORD    dwHandle;
    BYTE    dbVendor;
    BYTE    dbBiosVersion;
    WORD    dwBiosStartAddress;
    BYTE    dbBiosReleaseDate;
    BYTE    dbBiosRomSize;
    BYTE    szBiosCharacteristics[8];
    BYTE    szBiosExtensionCharacteristics[2];
    char    szString[3][100];
}   TYPE0;

typedef struct
{
    BYTE    dbType;
    BYTE    dbLength;
    WORD    dwHandle;
    BYTE    dbManufacture;
    BYTE    dbProductName;
    BYTE    dbVersion;
    BYTE    dbSerialNumber;
    BYTE    szUUID[16];
    BYTE    dbWakeUpType;
    char    szString[4][100];
}   TYPE1;

typedef struct
{
    BYTE    dbType;
    BYTE    dbLength;
    WORD    dwHandle;
    BYTE    dbLocation;
    BYTE    dbManufacturer;
    BYTE    dbManufactureDate;
    BYTE    dbSerialNumber;
    BYTE    dbDeviceName;
    BYTE    dbDeviceChemistry;
    WORD    dwDesignCapacity;
    WORD    dwDesignVoltage;
    BYTE    dbSBDSVersionNumber;
    BYTE    dbMaxErrorinBatteryData;
    WORD    dwSBDSSerialNumber;
    WORD    dwSBDSManufactureDate;
    BYTE    dbSBDSDeviceChemistry;
    BYTE    dbDesignCapacityMultiplier;
    DWORD   ddOEMSpecific;
    char    szString[6][100];
}   TYPE16;

typedef struct
{
    BYTE    dbType;
    BYTE    dbLength;
    WORD    dwHandle;
    BYTE    dbManufacture;
    BYTE    dbProduct;
    BYTE    dbVersion;
    BYTE    dbSerialNumber;
    char    szString[4][100];
}   TYPE2;

typedef struct
{
    BYTE    dbType;
    BYTE    dbLength;
    WORD    dwHandle;
    BYTE    dbManufacture;
    BYTE    dbTypeinfo;
    BYTE    dbVersion;
    BYTE    dbSerialNumber;
    BYTE    dbAssetTagNumber;
    BYTE    dbBootupState;
    BYTE    dbPowerSupplyState;
    BYTE    dbThermalState;
    BYTE    dbSecurityState;
    char    szString[4][100];
}   TYPE3;

typedef struct _Descriptor
{
   unsigned wSegLimit;
   unsigned wLowPhyAddr;
   unsigned char bMidPhyAddr;
   unsigned char bAccess;
   unsigned char bFlag_SegLimit;
   unsigned char bHiPhyAddr;
} DT;

typedef struct _GDT
{
   unsigned long dwUnused1;
   unsigned long dwUnused2;
   unsigned long dwGDT_BIOS1;
   unsigned long dwGDT_BIOS2;
   DT SDT;
   DT DDT;
   unsigned long dwCodeDescriptor1_BIOS;
   unsigned long dwCodeDescriptor2_BIOS;
   unsigned long dwStackDescriptor1_BIOS;
   unsigned long dwStackDescriptor2_BIOS;
}  GDT;






/********************************************************************/
/*Function: Read data from physical memory address                  */
/*                                                                  */
/*Input:  unsigned long dwAddr....physical memory address           */
/*        char *Buffer............data buffer in current address    */
/*        int Size................data *buffer size                 */
/*                                                                  */
/*Output :Rlt.....................Return errorlevel code            */
/*          1.....................read physical memory fail         */
/*          0.....................read physical memory successful   */
/********************************************************************/
int ReadRAM(DWORD dwAddr,BYTE *Buffer,WORD Size)
{
   GDT gdt;
   unsigned wSegment,wOffset;
   unsigned long dwPhyAddr;
   int Rlt=0;

   memset(&gdt,0,sizeof(GDT));

   dwPhyAddr=(unsigned long)FP_SEG(Buffer);
   dwPhyAddr<<=4;
   dwPhyAddr+=FP_OFF(Buffer);

   gdt.DDT.wSegLimit=0xFFFF;
   gdt.DDT.bFlag_SegLimit=0x0001;
   gdt.DDT.bAccess=0x93;
   gdt.DDT.wLowPhyAddr=dwPhyAddr&0xFFFF;
   gdt.DDT.bMidPhyAddr=(unsigned char)((dwPhyAddr)>>16);

   gdt.SDT.wSegLimit=0xFFFF;
   gdt.SDT.bFlag_SegLimit=0x01;
   gdt.SDT.bAccess=0x93;
   gdt.SDT.wLowPhyAddr=(unsigned)(dwAddr&0xFFFF);
   gdt.SDT.bMidPhyAddr=(unsigned char)((dwAddr>>16)&0xff);
   gdt.SDT.bHiPhyAddr=(unsigned char)(dwAddr>>24);

   wSegment=FP_SEG(&gdt);
   wOffset=FP_OFF(&gdt);
   asm push es
   asm push si
   asm mov ah,87h
   asm mov cx,Size
   asm mov es,wSegment
   asm mov si,wOffset
   asm int 15h
   asm jnc  OK
   asm mov Rlt,1
OK:
   asm pop si
   asm pop es
   return Rlt;
}


int FindSMBIOS()
{   
    DWORD i=0;
    BYTE  str[7];
    BYTE  far *ptr;
    WORD  str1,str2,str3,str4,str5,str6,segment,offset;
    ptr=(BYTE far *)MK_FP(0xF000,0x0000);
    str[0]=*ptr;str[1]=*(ptr+1);str[2]=*(ptr+2);str[3]=*(ptr+3);str[4]=*(ptr+4);str[5]=*(ptr+5);str[6]=*(ptr+6);
    while((strncmp(str,"_SM_",4)!=0)&&(i<0xFFF))
    {   
        ptr+=0x10;
        str[0]=*ptr;str[1]=*(ptr+1);str[2]=*(ptr+2);str[3]=*(ptr+3);str[4]='\0';
        i++;
    }
    if (i==0xFFF)
      return 1;
        else
         {
           str1    =(int)(*(ptr+0x18));
           str2    =(int)(*(ptr+0x19));
           str3    =(int)(*(ptr+0x1A));
           str4    =(int)(*(ptr+0x1B));
           str5    =(int)(*(ptr+0x16));
           str6    =(int)(*(ptr+0x17));
           segment =(str4*0x100+str3);
           offset  =str2*0x100+str1;
           SMBIOSEntry=segment*0x10000+offset;
           SMBIOSLen  =str6*0x100+str5;
           /*
           printf("SMBIOS DMI is mapped to offset 0x%lX , Total 0x%04X bytes\n",SMBIOSEntry,SMBIOSLen);
           */
           ptr=(unsigned char far *)MK_FP(segment,offset);
           return 0;
         }
}


int GetStructureTable(szType *myType,BYTE far *b,BYTE sztype)
{
  int i,i_bak;
  int flag=0;

  i=0;
  while(i<SMBIOSLen)
  {

    i_bak=i;

    i+=b[i_bak+1];

    while(!((b[i]==0)&&(b[i+1]==0)))
    {
       i++;
    }
    i+=2;

    myType->type    =b[i_bak];
    myType->length  =b[i_bak+1];
    myType->handle  =b[i_bak+3]*0x100+b[i_bak+2];
    myType->start   =i_bak;
    myType->end     =i-2;
    myType->datasize=myType->end-myType->start;

    textcolor(WHITE);
    cprintf("Type :0x%02X    Length :0x%02X     Handle :0x%04X     Size :0x%02X\r",myType->type,myType->length,myType->handle,myType->datasize);
    if(myType->type==sztype)
    {
      flag=1;
      break;
    }
  }
  printf("\r\n");
  return flag;
}



void GetType0(TYPE0 *Type0, BYTE far *buffer ,szType *szmy)
{
 int i,j,_i,_j;

  Type0->dbType            =szmy->type;
  Type0->dbLength          =szmy->length;
  Type0->dwHandle          =szmy->handle;
  Type0->dbVendor          =buffer[szmy->start+4];
  Type0->dbBiosVersion     =buffer[szmy->start+5];
  Type0->dwBiosStartAddress=buffer[szmy->start+7]*0x100+buffer[szmy->start+6];
  Type0->dbBiosReleaseDate =buffer[szmy->start+8];
  Type0->dbBiosRomSize     =buffer[szmy->start+9];

  _i=0;
  j=szmy->start+szmy->length;
  while (_i<3)
  {
      _j=0;
      while ((buffer[j]!=0)&&(_j<100))
      {
        Type0->szString[_i][_j++]=buffer[j++];
      }
      Type0->szString[_i][_j]=0;
      _i++;
      if(buffer[j]==0x00)
        j++;

  }

}


void GetType1(TYPE1 *Type1, BYTE far *buffer ,szType *szmy)
{
 int i,j,_i,_j;

  Type1->dbType            =szmy->type;
  Type1->dbLength          =szmy->length;
  Type1->dwHandle          =szmy->handle;
  Type1->dbManufacture     =buffer[szmy->start+4];
  Type1->dbProductName     =buffer[szmy->start+5];
  Type1->dbVersion         =buffer[szmy->start+6];
  Type1->dbSerialNumber    =buffer[szmy->start+7];

  for(i=szmy->start+0x08;i<szmy->start+0x18;i++)
    Type1->szUUID[i-szmy->start-0x08]=buffer[i];


  Type1->dbWakeUpType=buffer[szmy->start+0x18];

  _i=0;
  j=szmy->start+szmy->length;
  while (_i<4)
  {
      _j=0;
      while ((buffer[j]!=0)&&(_j<100))
      {
        Type1->szString[_i][_j++]=buffer[j++];
      }
      Type1->szString[_i][_j]=0;
      _i++;
      if(buffer[j]==0x00)
        j++;

  }
}

void GetType2(TYPE2 *Type2, BYTE far *buffer ,szType *szmy)
{
 int i,j,_i,_j;

 Type2->dbType            =szmy->type;
 Type2->dbLength          =szmy->length;
 Type2->dwHandle          =szmy->handle;
 Type2->dbManufacture     =buffer[szmy->start+4];
 Type2->dbProduct         =buffer[szmy->start+5];
 Type2->dbVersion         =buffer[szmy->start+6];
 Type2->dbSerialNumber    =buffer[szmy->start+7];

  _i=0;
  j=szmy->start+szmy->length;
  while (_i<4)
  {
      _j=0;
      while ((buffer[j]!=0)&&(_j<100))
      {
        Type2->szString[_i][_j++]=buffer[j++];
      }
      Type2->szString[_i][_j]=0;
      _i++;
      if(buffer[j]==0x00)
        j++;

  }

}


void GetType3(TYPE3 *Type3, BYTE far *buffer ,szType *szmy)
{
 int i,j,_i,_j;

 Type3->dbType            =szmy->type;
 Type3->dbLength          =szmy->length;
 Type3->dwHandle          =szmy->handle;
 Type3->dbManufacture     =buffer[szmy->start+4];
 Type3->dbTypeinfo        =buffer[szmy->start+5];
 Type3->dbVersion         =buffer[szmy->start+6];
 Type3->dbSerialNumber    =buffer[szmy->start+7];
 Type3->dbAssetTagNumber  =buffer[szmy->start+8];
 Type3->dbBootupState     =buffer[szmy->start+9];
 Type3->dbPowerSupplyState=buffer[szmy->start+10];
 Type3->dbThermalState    =buffer[szmy->start+11];
 Type3->dbSecurityState   =buffer[szmy->start+12];

  _i=0;
  j=szmy->start+szmy->length;
  while (_i<4)
  {
      _j=0;
      while ((buffer[j]!=0)&&(_j<100))
      {
        Type3->szString[_i][_j++]=buffer[j++];
      }
      Type3->szString[_i][_j]=0;
      _i++;
      if(buffer[j]==0x00)
        j++;

  }
}


void GetType16(TYPE16 *Type16, BYTE far *buffer ,szType *szmy)
{
 int i,j,_i,_j;


 Type16->dbType            =szmy->type;
 Type16->dbLength          =szmy->length;
 Type16->dwHandle          =szmy->handle;
 Type16->dbLocation        =buffer[szmy->start+4];
 Type16->dbManufacturer    =buffer[szmy->start+5];
 Type16->dbManufactureDate =buffer[szmy->start+6];
 Type16->dbSerialNumber    =buffer[szmy->start+7];
 Type16->dbDeviceName      =buffer[szmy->start+8];
 Type16->dbDeviceChemistry   =buffer[szmy->start+9];
 Type16->dwDesignCapacity    =buffer[szmy->start+11]*0x100+buffer[szmy->start+10];
 Type16->dwDesignVoltage   =buffer[szmy->start+13]*0x100+buffer[szmy->start+12];

 Type16->dbSBDSVersionNumber      =buffer[szmy->start+14];
 Type16->dbMaxErrorinBatteryData  =buffer[szmy->start+15];

 Type16->dwSBDSSerialNumber    =buffer[szmy->start+17]*0x100+buffer[szmy->start+16];
 Type16->dwSBDSManufactureDate =buffer[szmy->start+19]*0x100+buffer[szmy->start+18];

 Type16->dbSBDSDeviceChemistry       =buffer[szmy->start+20];
 Type16->dbDesignCapacityMultiplier  =buffer[szmy->start+21];


  _i=0;
  j=szmy->start+szmy->length;
  while (_i<7)
  {
      _j=0;
      while ((buffer[j]!=0)&&(_j<100))
      {
        Type16->szString[_i][_j++]=buffer[j++];
      }
      Type16->szString[_i][_j]=0;
      _i++;
      if(buffer[j]==0x00)
        j++;

  }
}


int Return2Dos()
{
 union   REGS    regs;
 regs.h.ah=0x4c;
 intdos(&regs,&regs);

}

void Showline(int n)
{
 int i=0;
 for(i=1;i<n;i++)
 {
   textcolor(i+1);
   cprintf("%c",196);
 }
 printf("\r\n");
}



int SendKBCCmd(int cmd)
{
  outportb(0x64,cmd);
  return 0;
}


unsigned int scancode;
int smart=0;
int dumb=0;

int main(int argc,char *argv[])
{
     BYTE P1;
     BYTE DATA_L[1]={NULL},DATA_H[1]={NULL};
     float Bat_Temp=0,BAT1_FCC=0,BAT1_RC=0,CHARGE_VOLTAGE=0,CHARGE_CURRENT=0,CHARGE_State=0,LCD_Brightness_AC=0,LCD_Brightness_DC=0,SM_TEMP=0,CPU_TEMP=0,Designed_FCC=0,PER=0;
     WORD Date=0;
     int RET=0,i=0,j=0,h=0,m=0,s=0,C1=0,C2=0;
     union REGS rs;
     int ERROR=0;
     float per=0,maxcur=0,mincur=0;
     int pack_year,pack_month,pack_day,year,week;
     int now_year,now_month,now_day;
     int cycle;
     int E1,E2;

     DWORD temp;
     char buffer[0x100]={NULL};

     TYPE16 *stpType16;
     szType *szmy;
     BYTE far *buf;
     FILE *pfHANDEL;

     outportb(0x70,0x32);
     temp=(inportb(0x71)&0xff)*0x100;
     outportb(0x70,0x09);
     temp+=inportb(0x71)&0xff;
     sprintf(buffer,"%04X",temp);