{
 int d,ok;
 int result,sum;

        ok=0;

        d=(~read_XDATA(PPIPA1)) & 0x03;
        if (d==0x01) ok++;
        if (ok==0) return(0);

        delay(100);
        d=(~read_XDATA(PPIPA1)) & 0x03;
        if (d==0x01) ok++;

        delay(100);
        d=(~read_XDATA(PPIPA1)) & 0x03;
        if (d==0x01) ok++;

        delay(300);
        d=(~read_XDATA(PPIPA1)) & 0x03;
        if (d==0x01) ok++;    /* verify key */
        if (AUTOLOCK) ok=1;

        switch (ok)
        {
         case 4:        /* verify between SRAM and flash memory */
           beep_start();
           line_feed();
           result=verify(0);
           if (result==0) display_str(msg_verify_ok,1);
           else           display_str(msg_no_match,1);
           if (result==0) beep_ok();
           else           beep_err();
           display_prompt();
           break;
         case 1:        /* read then save at SRAM */
         case 2:
         case 3:
           beep_start();
           line_feed();
           display_str("Read then save into RAM BUFFER",1);
           sum=chip_read();
           display_str("Checksum = ",0);
           display_addr((unsigned int)sum);
           line_feed();
           p20_show_signature(1);
           display_prompt();
           beep_ok();
           break;
         default:
           break;
        }
}

int show_fail_in_programming()
{
        display_str("Something wrong in programming this microcontroller",1);
       display_str("Please check :",1);
        display_str("1.Is AT89CXX/AT90XXXX on the TEXTOOL socket ?",1);
        display_str("2.Did you add +12V power supply ?",1);
        display_str("3.Maybe this chip is bad before programming.",1);
}

int command_list()
{
 int m;
        for (m=0;m<CMD_LINE;m++) display_str(command[m],1);
}

int clear_buffer(int c)
{
 int m;
        for (m=0;m<c;m++) write_XDATA(BUFFER+m,0x00);
        checksum=0;
}

int calculate_checksum()
{
 int sum=0;
 int m;
        for (m=0;m<pgm_length;m++) sum+=read_XDATA(BUFFER+m);
        return(sum);
}

int display(char *s)
{
 int m;
        for (m=0;m<strlen(s);m++) display_char(s[m]);
        line_feed();
}

int display_str(s,lf)
char *s;
int lf;
{
 int m;
        for (m=0;m<strlen(s);m++) display_char(s[m]);
        if (lf !=0) line_feed();
}

int display_mem_block(s_add,e_add)
int s_add,e_add;
{
 int m,n;
 int data;
 int sum;

        display_str("Press any key to escape",1);
        display_str("Display data addr ",0);
        display_addr((unsigned int)s_add);
        display_str(" -- ",0);
        display_addr((unsigned int)e_add);
        line_feed();

      for (m=s_add;m<e_add;m=m+16)
      {
        display_addr((unsigned int)m);
        for (n=0;n<16;n++)
         {
          data=read_XDATA(m+n);
          display_hex(data);   /* hex display mode */
          display_char(' ');
          if (n==7) { display_char('-'); display_char(' '); }
          } /* end of n loop */

          display_char('|');   /* seperator */

       for (n=0;n<16;n++)      /* char display mode */
         {
          data=read_XDATA(m+n);
          if ( (data>=' ') && (data< 0x7f) ) display_char(data);
          else                               display_char('.');
         }
        line_feed();
        if (SFB.RI==1) break;
        write_XDATA(0xfffe,m/256);
        write_XDATA(0xffff,m%256);
      }

        for (sum=0,m=0;m<pgm_length;m++)
        { sum+=read_XDATA(s_add+m); }
       return(sum);
}

int download_file()
{
 int m;
 int l1,l2;
 int sum;
 int data,addr;
 int n,cnt;

        /* Load command receive */
        while (SFB.RI==0) {};
        l1=SBUF;
        SFB.RI=0;
        while (SFB.RI==0) {};
        l2=SBUF;
        SFB.RI=0;
        l2=(l2 & 0x3f)<<8;
        l1=l1 & 0xff;
        cnt=l2+l1;
        write_XDATA(0xfffe,cnt%256);
        write_XDATA(0xffff,cnt/256);

        addr=BUFFER;
        n=0;

        while (n<cnt) {
         while (SFB.RI==0) {};
         data=SBUF;
         SFB.RI=0;
         write_XDATA(addr+n,data); /* save program on RAM */
         n++;
        }
        delay(1000);

        line_feed();
        display_str("Download file count = ",0);
        display_addr((unsigned int)cnt);
        display_str(" (HEX)",1);

        display_str("Calculate checksum...",1);
        for (sum=0,m=0;m<pgm_length;m++)
        { sum+=read_XDATA(BUFFER+m); }
        display_str("RAM BUFFER checksum = ",0);
        display_addr((unsigned int)sum);
        line_feed();
        checksum=sum;
        beep_ok();
}

int display_line(code)
char code;
{
 int m;
        for (m=0;m<75;m++) display_char(code);
        line_feed();
}

int display_addr(addr)
unsigned int addr;
{
 int p,q;
        p=addr/256;
        q=addr%256;
        display_hex(p);
        display_hex(q);
        display_char('H');
        display_char(' ');
}

int display_addr_woh(addr)
unsigned int addr;
{
 int p,q;
        p=addr/256;
        q=addr%256;
        display_hex(p);
        display_hex(q);
}

int display_hex(data)
int data;
{
int l4bit,h4bit;
          h4bit=(data & 0xf0)/16;
          h4bit=hex_table[h4bit];
          display_char((char)h4bit);

          delay(2);
          l4bit=data & 0x0f;
          l4bit=hex_table[l4bit];
          display_char((char)l4bit);
          delay(2);
}

int beep_start()
{
        beep_on();  delay(200);
        beep_off(); delay(50);
        beep_on();  delay(100);
        beep_off(); delay(50);
}

int beep_err()
{
 int m;
        for (m=0;m<3;m++) {
         beep_on();  delay(50);
         beep_off(); delay(50);
        }
}

int beep_ok()
{
        beep_on();  delay(200);
        beep_off(); delay(100);
}

int show_mail_box()
{
        line_feed();
        display_str(title2,1);
        display_str(title3,1);
        display_str(title4,1);

        line_feed();
}
int display_char(data)
char data;
{
        SBUF=data;
        while (SFB.TI==0) {};
        delay(1);
}

int display_char_no_wait(data)
char data;
{
        SBUF=data;
        while (SFB.TI==0) {};
}


int line_feed()
{
        display_char(0x0d); delay(10);
        display_char(0x0a); delay(10);
}

int delay(t)
int t;
{
 int q,m;
        for (m=0;m<t;m++) {
         for (q=0;q<t_of_delay;q++) {}
        }
        return(0);
}
/*
int check_rom()
{
 int m;
        for (m=0x0000;m<0x7fff;m+=0x800)
        { delay_10ms(); }
}
*/
int check_mem()
{
 int m,n,flag;
 char data,chk;

        for (m=0x8000;m<0xffff;m+=0x1000)
        { flag=0;
          for (n=0;n<32;n++)
           {
            data=read_XDATA(m+n);
            write_XDATA(m+n,~data);
            chk=~read_XDATA(m+n);
            write_XDATA(m+n,data); /* write back */
            if (data == chk) flag=1;
           }
          display_str("SRAM Addr ",0);
          display_addr((unsigned int)m);

          if (flag==0) display_str(" X ",1);
          else         display_str("R/W OK!",1);
          if (m >=0xf000) break;
        }
        line_feed();
}

int read_XDATA(int addr)
{
/*
 char *p;
 int r;
        p=(char *)addr;
        r=(int)(*p);
        return(r);
*/
        .asm
        .arg    addr
        push    dpl
        push    dph
        push    acc
        mov     dpl,r6
        mov     dph,r7
        movx    a,@dptr         ;get addr_h
        mov     r0,a
        inc     dptr
        movx    a,@dptr         ;get addr_l
        mov     dph,r0
        mov     dpl,a
        movx    a,@dptr         ;read external data
        mov     r0,a
        mov     r2,#00h
        pop     acc
        pop     dph
        pop     dpl
        .endasm
}

int write_XDATA(int addr,int data)
{
/*
 char *p;
        p=(char *)addr;
        *p=(char)data; */
        .asm
        .arg    addr,data
        push    dpl
        push    dph
        push    acc
        mov     dpl,r6
        mov     dph,r7
        movx    a,@dptr         ;get addr_h
        mov     r0,a
        inc     dptr
        movx    a,@dptr         ;get addr_l
        mov     r2,a
        inc     dptr
        inc     dptr
        movx    a,@dptr         ;get data_l
        mov     dph,r0
        mov     dpl,r2
        movx    @dptr,a         ;write external data
        pop     acc
        pop     dph
        pop     dpl
        .endasm
}

int baud_rate_setting()
{
        SCON=0x50;
        TMOD=0x20;
        TH1=rate;
        TL1=rate;
        SFB.TR1=1;
}

int enable_int0()
{
        TMOD=0x21; /* timer1 as baud rate gen,timer0 16bit count */
        TH0=TmsH;
        TL0=TmsL;
        SFB.TR0=1;  /* timer0 start count */
        SFB.TF0=0;  /* timer 0 overflow flag clear */
/*
        SCON=0x52; /* 8 bit UART */
        TCON=0x54;
        TH1=rate;
        TL1=0;
        SFB.TR1=1;  /* timer1 start count */
*/
/*      SFB.ET0=0;     disable timer0 interrupt */
/*      SFB.PS=1;      serial higher priority */

        SFB.ES=0;   /* disable serial interrupt */
        SFB.EA=0;   /* disable interrupt */
        SFB.RI=0;
        SFB.TI=0;
}

interrupt t0_int()
{
        TH0=TmsH;          /* count reload */
        TL0=TmsL;
        SFB.TF0=0;
}

int upload_file()
{
 int data;
 int addr;
 int m;

        addr=BUFFER; /* addr */

        for (m=0;m<pgm_length;m++) {
        data=read_XDATA(addr+m); /* read RAM data */
        SBUF=data;
        while (SFB.TI==0) {};
        delay(2);
        }
}

int serial_int()
{ }

/* sub-functions for AT89C51/52 only */

int p26_low() {       write_XDATA(PPICTL2,0x08); }
int p26_hi()  {       write_XDATA(PPICTL2,0x09); }

int p27_low() {       write_XDATA(PPICTL2,0x0a); }
int p27_hi()  {       write_XDATA(PPICTL2,0x0b); }

int p36_low() {       write_XDATA(PPICTL2,0x0c); }
int p36_hi()  {       write_XDATA(PPICTL2,0x0d); }

int p37_low() {       write_XDATA(PPICTL2,0x0e); }
int p37_hi()  {       write_XDATA(PPICTL2,0x0f); }


int rst_hi()   {      write_XDATA(PPICTL2,0x07); }
int psen_low() {      write_XDATA(PPICTL2,0x04); }

int vpp_12v() {       write_XDATA(PPICTL2,0x01); }
int vpp_5v()  {       write_XDATA(PPICTL2,0x00); }

int prog_low() {      write_XDATA(PPICTL2,0x02); }
int prog_hi()  {      write_XDATA(PPICTL2,0x03); }

int read_extra_signature()
{
 int c1;
 int code;
        read_signature_mode();
        addr_out(0x0032);
        c1=read_byte();         /* c1 must be 1EH */
        code=c1;
        return(code);
}

int write_byte(int d)
{
        write_XDATA(PPIPB1,d);
}

int read_byte()
{
 int d;
        d=read_XDATA(PPIPB1);
        return(d);
}

int addr_out(int a)
{
 int addr_h,addr_l;

/*      addr_h=(a/256);
        addr_l=a%256; */
        addr_h=a >> 8;
        addr_l=a & 0xff;
        write_XDATA(PPIPA1,addr_l);
        write_XDATA(PPIPA2,addr_h);
}

int read_signature_mode()
{
        init_8255(0x82,0x82);
        rst_hi();
        psen_low();
        prog_hi();
        vpp_5v();
        p26_low();
        p27_low();
        p36_low();
        p37_low();
}

int read_signature()
{
 int c1,c2;
 int code;
        read_signature_mode();
        if (flash_type==AT89S8252) vpp_12v();
        addr_out(0x0030);
        c1=read_byte();         /* c1 must be 1EH */
        addr_out(0x0031);
        c2=read_byte();         /* c2 must be 51H */
        code=c2*256+c1;
        vpp_5v();
        return(code);
}

int read_code_mode()
{
        init_8255(0x82,0x82);
        rst_hi();
        psen_low();
        prog_hi();
        vpp_5v();
        p26_low();
        p27_low();
        p36_hi();
        p37_hi();
}