PROGRAMER FOR PIC18F87J10 USING LPT PORT: writer.c Source File

00001 /*******************
00002 * Function: Spi flash device driver
00003 * compiler: vc++ 6.0
00004 *
00005 * author: book
00006 * date : 2009.07.13
00007 ********************
00008 */
00009 #include "includes.h"
00010 
00011 #define WRITER_DEBUG_ENABLE 0
00012 
00013 #define WriterIdleState 0
00014 #define WriterCheckHexfileState 1
00015 #define WriterTransmitHexfileState 2
00016 
00017 WRITER_CONTROL WriterCtrl;
00018 
00019 #define WRITER_HEXFILE_SIZE 200000
00020 U8 Counter;
00021 U32 HexStringNumber;
00022 U8 *pHexString;
00023 U8 WriterBuffer[WRITER_HEXFILE_SIZE]; // for hex file
00024 U8 WriterFilename[]="mypic.hex";
00025 FILE *pWriterStream;
00026 U8 FL_Hexdigit2Hex(U8 Data);
00027 BOOL F_WriterHexfileCheck(FILE *pStream);
00028 void F_WriterHexfileWrite(void);
00029 void F_WriterPageProgram(void);
00030 
00031 void F_WriterInit(void){
00032     WriterCtrl.HexStringNumber=0;
00033     WriterCtrl.StreamSize=0;
00034     WriterCtrl.State=WriterIdleState;
00035     WriterCtrl.Status=0;
00036 }
00037 void F_WriterSvc(void){
00038     U32 i;
00039 
00040     switch(WriterCtrl.State){
00041         case WriterIdleState:
00042             break;
00043         case WriterCheckHexfileState:
00044             pWriterStream=NULL;
00045             if(WriterFilename[0]!=0) pWriterStream=fopen((char *)WriterFilename,"rb");
00046             if(pWriterStream==NULL){                            
00047                 printf("\n Can not open file %15s.",WriterFilename);                                
00048                 WriterCtrl.State=WriterIdleState;
00049                 break;
00050             }
00051             for(i=0;i<WRITER_HEXFILE_SIZE;i++) WriterBuffer[i]=0xff;
00052             if(F_WriterHexfileCheck(pWriterStream)==TRUE){
00053                 printf("\n hex file check ok.");
00054             }
00055             else{
00056                 printf("\n hex file check fail.");
00057             }
00058             fclose(pWriterStream);
00059             //WriterCtrl.State=WriterIdleState;
00060             WriterCtrl.State=WriterTransmitHexfileState;
00061             break;
00062         case WriterTransmitHexfileState:
00063             #if(WRITER_DEBUG_ENABLE==1)
00064                 //F_WriterHexfileWrite();
00065                 F_IcspProgramModeEnter(); 
00066                 F_IcspBulkErase();           
00067                 //F_WriterHexfileWrite();
00068                 F_IcspProgramModeExit();
00069                 F_IcspReset();
00070             #else 
00071                 F_IcspProgramModeEnter(); 
00072                 F_IcspBulkErase();           
00073                 F_WriterHexfileWrite();
00074                 F_IcspProgramModeExit();
00075                 F_IcspReset();
00076             #endif
00077                 
00078             printf("\n write done. ");
00079             WriterCtrl.State=WriterIdleState;
00080             break;
00081     }
00082 }
00083 U8 F_WriterStateGet(void){
00084     return WriterCtrl.State;
00085 }
00086 void F_WriterImageWrite(void){
00087     WriterCtrl.State=WriterCheckHexfileState;
00088 }
00089 U8 FL_Hexdigit2Hex(U8 Data){
00090     if(Data>='A') Data=Data-'A'+10;
00091     else Data=Data-'0';
00092     return Data;
00093 }
00094 
00095 #define HexFindColonState  0
00096 #define HexByteCountState  1
00097 #define HexAddressState    2
00098 #define HexRecordTypeState 3
00099 #define HexDataState       4
00100 #define HexChecksumState   5
00101 BOOL F_WriterHexfileCheck(FILE *pStream){
00102     U32 i;
00103     U8 j;
00104     U8 Error;
00105     U8 Data;
00106     U8 Hex0,Hex1,Hexdata;
00107     U8 State;
00108     U8 ByteCount;
00109     U8 Checksum;
00110     U8 meetEOF;
00111     
00112     meetEOF=FALSE;
00113     i=0;
00114     Error=0;
00115     while(feof(pStream)==0){       // store file stream in buffer
00116         Data=(U8)fgetc(pStream);
00117         WriterBuffer[i]=Data;
00118         i++;
00119         if(i>=WRITER_HEXFILE_SIZE) break;   
00120     }
00121     if(i>=WRITER_HEXFILE_SIZE) return FALSE;
00122     WriterCtrl.HexStringNumber=0;
00123     WriterCtrl.StreamSize=i;
00124     State=HexFindColonState;
00125     for(i=0;i<WriterCtrl.StreamSize;){
00126         switch(State){
00127             case HexFindColonState:
00128                 if(WriterBuffer[i]!=':'){
00129                     WriterBuffer[i]=0;
00130                     i++;
00131                     break;
00132                 }
00133                 i++;
00134                 WriterCtrl.HexStringNumber++;
00135                 Checksum=0;
00136                 //printf("[%2x]",WriterCtrl.HexStringNumber);
00137                 State=HexByteCountState;
00138                 break;
00139             case HexByteCountState: // 2 hex digit
00140                 Hex0=WriterBuffer[i++];
00141                 if(((Hex0>'F')&&(Hex0<'A'))&&((Hex0>'9')&&(Hex0<'0'))) return FALSE; // not ascii value
00142                 Hex0=FL_Hexdigit2Hex(Hex0);
00143                 Hex1=WriterBuffer[i++];
00144                 if(((Hex1>'F')&&(Hex1<'A'))&&((Hex1>'9')&&(Hex1<'0'))) return FALSE; // not ascii value
00145                 Hex1=FL_Hexdigit2Hex(Hex1);
00146                 ByteCount=Hex0*16+Hex1;
00147                 //printf("[%2x]",ByteCount);
00148                 Checksum=Checksum+ByteCount;
00149                 State=HexAddressState;
00150                 break;
00151             case HexAddressState: // 4 hex digit
00152                 Hex0=WriterBuffer[i++];
00153                 if(((Hex0>'F')&&(Hex0<'A'))&&((Hex0>'9')&&(Hex0<'0'))) return FALSE; // not ascii value
00154                 Hex0=FL_Hexdigit2Hex(Hex0);             
00155                 Hex1=WriterBuffer[i++];
00156                 if(((Hex1>'F')&&(Hex1<'A'))&&((Hex1>'9')&&(Hex1<'0'))) return FALSE; // not ascii value
00157                 Hex1=FL_Hexdigit2Hex(Hex1);
00158                 Hexdata=Hex0*16+Hex1;
00159                 //printf("[%2x]",Hexdata);
00160                 Checksum=Checksum+Hexdata;
00161 
00162                 Hex0=WriterBuffer[i++];
00163                 if(((Hex0>'F')&&(Hex0<'A'))&&((Hex0>'9')&&(Hex0<'0'))) return FALSE; // not ascii value
00164                 Hex0=FL_Hexdigit2Hex(Hex0);             
00165                 Hex1=WriterBuffer[i++];
00166                 if(((Hex1>'F')&&(Hex1<'A'))&&((Hex1>'9')&&(Hex1<'0'))) return FALSE; // not ascii value
00167                 Hex1=FL_Hexdigit2Hex(Hex1);
00168                 Hexdata=Hex0*16+Hex1;
00169                 //printf("[%2x]",Hexdata);
00170                 Checksum=Checksum+Hexdata;              
00171                 State=HexRecordTypeState;
00172                 break;
00173             case HexRecordTypeState: // 2 hex digit
00174                 Hex0=WriterBuffer[i++];
00175                 if(((Hex0>'F')&&(Hex0<'A'))&&((Hex0>'9')&&(Hex0<'0'))) return FALSE; // not ascii value
00176                 Hex0=FL_Hexdigit2Hex(Hex0);             
00177                 Hex1=WriterBuffer[i++];
00178                 if(((Hex1>'F')&&(Hex1<'A'))&&((Hex1>'9')&&(Hex1<'0'))) return FALSE; // not ascii value
00179                 Hex1=FL_Hexdigit2Hex(Hex1);
00180                 Hexdata=Hex0*16+Hex1;
00181                 //printf("[%2x]",Hexdata);
00182                 if(Hexdata==0x01) meetEOF=TRUE;
00183                 else meetEOF=FALSE;
00184                 Checksum=Checksum+Hexdata;
00185                 State=HexDataState;
00186                 break;
00187             case HexDataState:
00188                 for(j=0;j<ByteCount;j++){
00189                     Hex0=WriterBuffer[i++];
00190                     if(((Hex0>'F')&&(Hex0<'A'))&&((Hex0>'9')&&(Hex0<'0'))) return FALSE; // not ascii value
00191                     Hex0=FL_Hexdigit2Hex(Hex0);             
00192                     Hex1=WriterBuffer[i++];
00193                     if(((Hex1>'F')&&(Hex1<'A'))&&((Hex1>'9')&&(Hex1<'0'))) return FALSE; // not ascii value
00194                     Hex1=FL_Hexdigit2Hex(Hex1);
00195                     Hexdata=Hex0*16+Hex1;
00196                     //printf("[%2x]",Hexdata);
00197                     Checksum=Checksum+Hexdata;                              
00198                 }
00199                 State=HexChecksumState;
00200                 break;
00201             case HexChecksumState:
00202                 Hex0=WriterBuffer[i++];
00203                 if(((Hex0>'F')&&(Hex0<'A'))&&((Hex0>'9')&&(Hex0<'0'))) return FALSE; // not ascii value
00204                 Hex0=FL_Hexdigit2Hex(Hex0);             
00205                 Hex1=WriterBuffer[i++];
00206                 if(((Hex1>'F')&&(Hex1<'A'))&&((Hex1>'9')&&(Hex1<'0'))) return FALSE; // not ascii value
00207                 Hex1=FL_Hexdigit2Hex(Hex1);
00208                 Hexdata=Hex0*16+Hex1;
00209                 //printf("[%2x]",Hexdata);
00210                 Checksum=Checksum+Hexdata;  
00211                 if(Checksum==0) State=HexFindColonState;
00212                 else return FALSE;
00213                 if(meetEOF==TRUE){
00214                     WriterBuffer[i]=0; // end last string with 0
00215                     return TRUE;
00216                 }
00217                 break;
00218         }
00219     }
00220     return FALSE;
00221 }
00222 #define FLASH_WRITE_SIZE 64
00223 
00224 #define HEX_BYTE_COUNT  0
00225 #define HEX_ADDRESS     1 // 1,2
00226 #define HEX_RECORD_TYPE 3
00227 #define HEX_DATA        4
00228 
00229 #define ExtendedSegmentAddress 0 // x86 realmode addressing
00230 #define ExtendedLinearAddress  1 // 32bit linear addressing
00231 
00232 #define RecordType_Data 0 // data record
00233 #define RecordType_EOF  1 // end of file
00234 #define RecordType_ESAR 2 // extended segment address record
00235 #define RecordType_SSAR 3 // start segment address record
00236 #define RecordType_ELAR 4 // extended linear address record
00237 #define RecordType_SLAR 5 // start linear address record
00238 
00239 UN_UL FlashAddress;
00240 U8 FlashBuffer[FLASH_WRITE_SIZE+16];
00241 void F_WriterHexfileWrite(void){
00242     U32 StreamBufferIndex;
00243     U8 u8Temp,i,Data,Data2,Data3,Data4,HasData,MeetEof;
00244     U8 HexBuffer[FLASH_WRITE_SIZE];
00245     U8 FlashBufferIndex;
00246     U8 HexBufferIndex;
00247     U8 ExtendedType;       // segment or linear
00248     U16 u16Temp;
00249     U16 CS;                // for 80x86 CS:IP
00250     U16 IP;                // for 80x86 CS:IP 
00251     UN_UI Address;
00252     UN_UL ExtendedAddress;
00253     UN_UL EIP; // for 80x86 use
00254     
00255     Address.u16=0;
00256     ExtendedAddress.u32=0;
00257     FlashAddress.u32=0;   
00258     ExtendedType=0;  
00259     HasData=FALSE; 
00260     HexBufferIndex=0;
00261     FlashBufferIndex=0;
00262     i=0;
00263     StreamBufferIndex=0;
00264     MeetEof=0;
00265     while(1){
00266         if(MeetEof==1) break;
00267         while(WriterBuffer[StreamBufferIndex]!=':') StreamBufferIndex++;
00268         StreamBufferIndex++; // skip ':'
00269         Data=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00270         Data2=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00271         HexBuffer[HEX_BYTE_COUNT]=(Data<<4)+Data2;
00272 
00273         Data=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);  // get address
00274         Data2=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00275         HexBuffer[HEX_ADDRESS]=(Data<<4)+Data2;
00276         Data=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);  // get address
00277         Data2=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00278         HexBuffer[HEX_ADDRESS+1]=(Data<<4)+Data2;
00279 
00280         Data=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);  // get record type
00281         Data2=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00282         HexBuffer[HEX_RECORD_TYPE]=(Data<<4)+Data2;
00283         HexBufferIndex=HEX_RECORD_TYPE;
00284         for(u8Temp=0;u8Temp<HexBuffer[HEX_BYTE_COUNT];u8Temp++){
00285             Data=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);  // get address
00286             Data2=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00287             HexBuffer[HEX_DATA+u8Temp]=(Data<<4)+Data2;
00288             HexBufferIndex++;
00289         }
00290 
00291         Data=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);  // get checksum
00292         Data2=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00293         u8Temp=(Data<<4)+Data2; // no use checksum...it is already checked 
00294         //printf("\n ");
00295         //for(i=0;i<=HexBufferIndex;i++) printf(" %2x",HexBuffer[i]);
00296 
00297         switch(HexBuffer[HEX_RECORD_TYPE]){ 
00298             case RecordType_Data: // data record                
00299                 if(HasData==FALSE){
00300                     for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff;
00301                     Address.u8[1]=HexBuffer[HEX_ADDRESS];
00302                     Address.u8[0]=HexBuffer[HEX_ADDRESS+1]&0xc0; // take bits 7.6...address is page address
00303                     FlashBufferIndex=HexBuffer[HEX_ADDRESS+1]&0x3f;    // take bits 5.4.3.2.1.0
00304                     for(i=0;i<HexBuffer[HEX_BYTE_COUNT];i++){
00305                         FlashBuffer[FlashBufferIndex++]=HexBuffer[HEX_DATA+i]; // move data in hex buffer to flash buffer
00306                     }
00307                     if(FlashBufferIndex<64){
00308                         HasData=TRUE;
00309                         break; // continue to receive data
00310                     }
00311                     else if(FlashBufferIndex==64){
00312                         FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00313                         F_WriterPageProgram();
00314                         for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00315                         //FlashBufferIndex=0; //no need
00316                         HasData=FALSE;
00317                         break;
00318                     }
00319                     else if(FlashBufferIndex>64){
00320                         FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00321                         F_WriterPageProgram();
00322                         for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00323                         for(i=0;i<(FlashBufferIndex-64);i++) FlashBuffer[i]=FlashBuffer[64+i];
00324                         Address.u16=Address.u16+FLASH_WRITE_SIZE;   // advance to next page, but if 0xffc0?? address reset to 0
00325                         FlashBufferIndex=FlashBufferIndex-64;
00326                         HasData=TRUE;
00327                         break;
00328                     }
00329                 }
00330                 else{
00331                     u16Temp=((U16)HexBuffer[HEX_ADDRESS]<<8)+(HexBuffer[HEX_ADDRESS+1]&0xc0);
00332                     u8Temp=HexBuffer[HEX_ADDRESS+1]&0x3f;
00333                     if(u16Temp==Address.u16){ //in same page
00334                         FlashBufferIndex=u8Temp;  
00335                         for(i=0;i<HexBuffer[HEX_BYTE_COUNT];i++){ // copy data from hexbuffer to flashbuffer
00336                             FlashBuffer[FlashBufferIndex++]=HexBuffer[HEX_DATA+i];
00337                         }
00338                         if(FlashBufferIndex<64) break; // continue to receive data
00339                         else if(FlashBufferIndex==64){
00340                             FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00341                             F_WriterPageProgram();
00342                             for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00343                             //FlashBufferIndex=0; //no need
00344                             HasData=FALSE;
00345                             break;
00346                         }
00347                         else if(FlashBufferIndex>64){
00348                             FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00349                             F_WriterPageProgram();
00350                             for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00351                             for(i=0;i<(FlashBufferIndex-64);i++) FlashBuffer[i]=FlashBuffer[64+i];
00352                             Address.u16=Address.u16+FLASH_WRITE_SIZE;   // advance to next page, but if 0xffc0?? address reset to 0
00353                             FlashBufferIndex=FlashBufferIndex-64;
00354                             HasData=TRUE;
00355                             break;
00356                         }
00357                     }
00358                     else{ // in different page
00359                         FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00360                         F_WriterPageProgram();
00361                         for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00362                         Address.u8[1]=HexBuffer[HEX_ADDRESS];
00363                         Address.u8[0]=HexBuffer[HEX_ADDRESS+1]&0xc0; // take bits 7.6
00364                         FlashBufferIndex=HexBuffer[HEX_ADDRESS+1]&0x3f;    // take bits 5.4.3.2.1.0
00365                         for(i=0;i<HexBuffer[HEX_BYTE_COUNT];i++){
00366                             FlashBuffer[FlashBufferIndex++]=HexBuffer[HEX_DATA+i];
00367                         }
00368                         if(FlashBufferIndex<64){
00369                             HasData=TRUE;
00370                             break; // continue to receive data
00371                         }
00372                         else if(FlashBufferIndex==64){
00373                             FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00374                             F_WriterPageProgram();
00375                             for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00376                             //FlashBufferIndex=0; //no need
00377                             HasData=FALSE;
00378                             break;
00379                         }
00380                         else if(FlashBufferIndex>64){
00381                             FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00382                             F_WriterPageProgram();
00383                             for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00384                             for(i=0;i<(FlashBufferIndex-64);i++) FlashBuffer[i]=FlashBuffer[64+i];
00385                             Address.u16=Address.u16+FLASH_WRITE_SIZE;   // advance to next page, but if 0xffc0?? address reset to 0
00386                             FlashBufferIndex=FlashBufferIndex-64;
00387                             HasData=TRUE;
00388                             break;
00389                         }
00390                         break;
00391                     }
00392                 }
00393                 break;
00394             case RecordType_EOF: // end of file
00395                 if(HasData==TRUE){
00396                     FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00397                     F_WriterPageProgram();
00398                     for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00399                     //FlashIndex=0; //no need
00400                     HasData=FALSE;
00401                 }
00402                 MeetEof=1;
00403                 break;
00404             case RecordType_ESAR: // extended segment address record
00405                 if(HasData==TRUE){
00406                     FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00407                     F_WriterPageProgram();
00408                     for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff;  // reset FlashBuffer[0~63]
00409                     //FlashIndex=0; //no need
00410                     HasData=FALSE;
00411                 }
00412                 ExtendedAddress.u8[1]=HexBuffer[HEX_DATA];
00413                 ExtendedAddress.u8[0]=HexBuffer[HEX_DATA+1];
00414                 ExtendedAddress.u8[3]=0;
00415                 ExtendedAddress.u8[2]=0;
00416                 ExtendedAddress.u32=ExtendedAddress.u32<<4;
00417                 ExtendedType=ExtendedSegmentAddress;
00418                 break;
00419             case RecordType_SSAR: // start segment address record
00420                 if(HasData==TRUE){
00421                     FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00422                     F_WriterPageProgram();
00423                     for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff;  // reset FlashBuffer[0~63]
00424                     //FlashIndex=0; //no need
00425                     HasData=FALSE;
00426                 }
00427                 Data=HexBuffer[HEX_DATA];
00428                 Data2=HexBuffer[HEX_DATA+1];
00429                 Data3=HexBuffer[HEX_DATA+2];
00430                 Data4=HexBuffer[HEX_DATA+3];
00431                 CS=((U16)Data<<12)
00432                    +((U16)Data2<<8)
00433                    +((U16)Data3<<4)
00434                    +((U16)Data4);
00435                 Data=HexBuffer[HEX_DATA+4];
00436                 Data2=HexBuffer[HEX_DATA+5];
00437                 Data3=HexBuffer[HEX_DATA+6];
00438                 Data4=HexBuffer[HEX_DATA+7];
00439                 IP=((U16)Data<<12)
00440                    +((U16)Data2<<8)
00441                    +((U16)Data3<<4)
00442                    +((U16)Data4);
00443                 break;
00444             case RecordType_ELAR: // extended linear address record
00445                 if(HasData==TRUE){
00446                     FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00447                     F_WriterPageProgram();
00448                     for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00449                     //FlashIndex=0; //no need
00450                     HasData=FALSE;
00451                 }
00452                 ExtendedAddress.u8[1]=HexBuffer[HEX_DATA];
00453                 ExtendedAddress.u8[0]=HexBuffer[HEX_DATA+1];
00454                 ExtendedAddress.u8[3]=0;
00455                 ExtendedAddress.u8[2]=0;
00456                 ExtendedAddress.u32=ExtendedAddress.u32<<16;
00457                 ExtendedType=ExtendedLinearAddress;
00458                 //printf("\n RecordType_ELAR ExtendedAddress: %8x ",ExtendedAddress.u32);
00459                 break;
00460             case RecordType_SLAR: // start linear address record
00461                 if(HasData==TRUE){
00462                     FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00463                     F_WriterPageProgram();
00464                     for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff;  // reset FlashBuffer[0~63]
00465                     //FlashIndex=0; //no need
00466                     HasData=FALSE;
00467                 }
00468                 Data=HexBuffer[HEX_DATA];
00469                 Data2=HexBuffer[HEX_DATA+1];
00470                 EIP.u8[3]=(Data<<4)+Data2;
00471                 Data=HexBuffer[HEX_DATA];
00472                 Data2=HexBuffer[HEX_DATA+1];
00473                 EIP.u8[2]=(Data<<4)+Data2;
00474                 Data=HexBuffer[HEX_DATA];
00475                 Data2=HexBuffer[HEX_DATA+1];
00476                 EIP.u8[1]=(Data<<4)+Data2;
00477                 Data=HexBuffer[HEX_DATA+2];
00478                 Data2=HexBuffer[HEX_DATA+3];
00479                 EIP.u8[0]=(Data<<4)+Data2;
00480                 break;
00481         }
00482     }
00483 }
00484 #if(WRITER_DEBUG_ENABLE==1)
00485     void F_WriterPageProgram(void){
00486         U8 i,j;
00487 
00488         printf("\n Address: %8x ",FlashAddress.u32);
00489         //printf(" %2x ",FlashAddress.u8[0]);
00490         //printf(" %2x ",FlashAddress.u8[1]);
00491         //printf(" %2x ",FlashAddress.u8[2]);
00492         //printf(" %2x ",FlashAddress.u8[3]);
00493         j=16;
00494         for(i=0;i<64;i++){
00495             if(j==16){
00496                 printf("\n ");
00497                 j=0;
00498             }
00499             printf(" %2x",FlashBuffer[i]);
00500             j++;
00501         }
00502     }
00503 #else
00504     void F_WriterPageProgram(void){
00505         //U8 i,j;
00506 
00507         IcspCtrl.Address=FlashAddress.u32;
00508         IcspCtrl.pData=&FlashBuffer[0];
00509         F_IcspPageProgram();
00510     }
00511 #endif